Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
  3.  * Copyright (c) 2002-2007, Professor Benoit Macq
  4.  * Copyright (c) 2001-2003, David Janssens
  5.  * Copyright (c) 2002-2003, Yannick Verschueren
  6.  * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
  7.  * Copyright (c) 2005, Herve Drolon, FreeImage Team
  8.  * Copyright (c) 2006-2007, Parvatha Elangovan
  9.  * All rights reserved.
  10.  *
  11.  * Redistribution and use in source and binary forms, with or without
  12.  * modification, are permitted provided that the following conditions
  13.  * are met:
  14.  * 1. Redistributions of source code must retain the above copyright
  15.  *    notice, this list of conditions and the following disclaimer.
  16.  * 2. Redistributions in binary form must reproduce the above copyright
  17.  *    notice, this list of conditions and the following disclaimer in the
  18.  *    documentation and/or other materials provided with the distribution.
  19.  *
  20.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
  21.  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  24.  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25.  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26.  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27.  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28.  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29.  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30.  * POSSIBILITY OF SUCH DAMAGE.
  31.  */
  32.  
  33. #include "opj_includes.h"
  34.  
  35. /** @defgroup PI PI - Implementation of a packet iterator */
  36. /*@{*/
  37.  
  38. /** @name Local static functions */
  39. /*@{*/
  40.  
  41. /**
  42. Get next packet in layer-resolution-component-precinct order.
  43. @param pi packet iterator to modify
  44. @return returns false if pi pointed to the last packet or else returns true
  45. */
  46. static bool pi_next_lrcp(opj_pi_iterator_t * pi);
  47. /**
  48. Get next packet in resolution-layer-component-precinct order.
  49. @param pi packet iterator to modify
  50. @return returns false if pi pointed to the last packet or else returns true
  51. */
  52. static bool pi_next_rlcp(opj_pi_iterator_t * pi);
  53. /**
  54. Get next packet in resolution-precinct-component-layer order.
  55. @param pi packet iterator to modify
  56. @return returns false if pi pointed to the last packet or else returns true
  57. */
  58. static bool pi_next_rpcl(opj_pi_iterator_t * pi);
  59. /**
  60. Get next packet in precinct-component-resolution-layer order.
  61. @param pi packet iterator to modify
  62. @return returns false if pi pointed to the last packet or else returns true
  63. */
  64. static bool pi_next_pcrl(opj_pi_iterator_t * pi);
  65. /**
  66. Get next packet in component-precinct-resolution-layer order.
  67. @param pi packet iterator to modify
  68. @return returns false if pi pointed to the last packet or else returns true
  69. */
  70. static bool pi_next_cprl(opj_pi_iterator_t * pi);
  71.  
  72. /*@}*/
  73.  
  74. /*@}*/
  75.  
  76. /*
  77. ==========================================================
  78.    local functions
  79. ==========================================================
  80. */
  81.  
  82. static bool pi_next_lrcp(opj_pi_iterator_t * pi) {
  83.         opj_pi_comp_t *comp = NULL;
  84.         opj_pi_resolution_t *res = NULL;
  85.         long index = 0;
  86.        
  87.         if (!pi->first) {
  88.                 comp = &pi->comps[pi->compno];
  89.                 res = &comp->resolutions[pi->resno];
  90.                 goto LABEL_SKIP;
  91.         } else {
  92.                 pi->first = 0;
  93.         }
  94.  
  95.         for (pi->layno = pi->poc.layno0; pi->layno < pi->poc.layno1; pi->layno++) {
  96.                 for (pi->resno = pi->poc.resno0; pi->resno < pi->poc.resno1;
  97.                 pi->resno++) {
  98.                         for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1; pi->compno++) {
  99.                                 comp = &pi->comps[pi->compno];
  100.                                 if (pi->resno >= comp->numresolutions) {
  101.                                         continue;
  102.                                 }
  103.                                 res = &comp->resolutions[pi->resno];
  104.                                 if (!pi->tp_on){
  105.                                         pi->poc.precno1 = res->pw * res->ph;
  106.                                 }
  107.                                 for (pi->precno = pi->poc.precno0; pi->precno < pi->poc.precno1; pi->precno++) {
  108.                                         index = pi->layno * pi->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p;
  109.                                         if (!pi->include[index]) {
  110.                                                 pi->include[index] = 1;
  111.                                                 return true;
  112.                                         }
  113. LABEL_SKIP:;
  114.                                 }
  115.                         }
  116.                 }
  117.         }
  118.        
  119.         return false;
  120. }
  121.  
  122. static bool pi_next_rlcp(opj_pi_iterator_t * pi) {
  123.         opj_pi_comp_t *comp = NULL;
  124.         opj_pi_resolution_t *res = NULL;
  125.         long index = 0;
  126.  
  127.         if (!pi->first) {
  128.                 comp = &pi->comps[pi->compno];
  129.                 res = &comp->resolutions[pi->resno];
  130.                 goto LABEL_SKIP;
  131.         } else {
  132.                 pi->first = 0;
  133.         }
  134.  
  135.         for (pi->resno = pi->poc.resno0; pi->resno < pi->poc.resno1; pi->resno++) {
  136.                 for (pi->layno = pi->poc.layno0; pi->layno < pi->poc.layno1; pi->layno++) {
  137.                         for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1; pi->compno++) {
  138.                                 comp = &pi->comps[pi->compno];
  139.                                 if (pi->resno >= comp->numresolutions) {
  140.                                         continue;
  141.                                 }
  142.                                 res = &comp->resolutions[pi->resno];
  143.                                 if(!pi->tp_on){
  144.                                         pi->poc.precno1 = res->pw * res->ph;
  145.                                 }
  146.                                 for (pi->precno = pi->poc.precno0; pi->precno < pi->poc.precno1; pi->precno++) {
  147.                                         index = pi->layno * pi->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p;
  148.                                         if (!pi->include[index]) {
  149.                                                 pi->include[index] = 1;
  150.                                                 return true;
  151.                                         }
  152. LABEL_SKIP:;
  153.                                 }
  154.                         }
  155.                 }
  156.         }
  157.        
  158.         return false;
  159. }
  160.  
  161. static bool pi_next_rpcl(opj_pi_iterator_t * pi) {
  162.         opj_pi_comp_t *comp = NULL;
  163.         opj_pi_resolution_t *res = NULL;
  164.         long index = 0;
  165.  
  166.         if (!pi->first) {
  167.                 goto LABEL_SKIP;
  168.         } else {
  169.                 int compno, resno;
  170.                 pi->first = 0;
  171.                 pi->dx = 0;
  172.                 pi->dy = 0;
  173.                 for (compno = 0; compno < pi->numcomps; compno++) {
  174.                         comp = &pi->comps[compno];
  175.                         for (resno = 0; resno < comp->numresolutions; resno++) {
  176.                                 int dx, dy;
  177.                                 res = &comp->resolutions[resno];
  178.                                 dx = comp->dx * (1 << (res->pdx + comp->numresolutions - 1 - resno));
  179.                                 dy = comp->dy * (1 << (res->pdy + comp->numresolutions - 1 - resno));
  180.                                 pi->dx = !pi->dx ? dx : int_min(pi->dx, dx);
  181.                                 pi->dy = !pi->dy ? dy : int_min(pi->dy, dy);
  182.                         }
  183.                 }
  184.         }
  185. if (!pi->tp_on){
  186.                         pi->poc.ty0 = pi->ty0;
  187.                         pi->poc.tx0 = pi->tx0;
  188.                         pi->poc.ty1 = pi->ty1;
  189.                         pi->poc.tx1 = pi->tx1;
  190.                 }
  191.         for (pi->resno = pi->poc.resno0; pi->resno < pi->poc.resno1; pi->resno++) {
  192.                 for (pi->y = pi->poc.ty0; pi->y < pi->poc.ty1; pi->y += pi->dy - (pi->y % pi->dy)) {
  193.                         for (pi->x = pi->poc.tx0; pi->x < pi->poc.tx1; pi->x += pi->dx - (pi->x % pi->dx)) {
  194.                                 for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1; pi->compno++) {
  195.                                         int levelno;
  196.                                         int trx0, try0;
  197.                                         int trx1, try1;
  198.                                         int rpx, rpy;
  199.                                         int prci, prcj;
  200.                                         comp = &pi->comps[pi->compno];
  201.                                         if (pi->resno >= comp->numresolutions) {
  202.                                                 continue;
  203.                                         }
  204.                                         res = &comp->resolutions[pi->resno];
  205.                                         levelno = comp->numresolutions - 1 - pi->resno;
  206.                                         trx0 = int_ceildiv(pi->tx0, comp->dx << levelno);
  207.                                         try0 = int_ceildiv(pi->ty0, comp->dy << levelno);
  208.                                         trx1 = int_ceildiv(pi->tx1, comp->dx << levelno);
  209.                                         try1 = int_ceildiv(pi->ty1, comp->dy << levelno);
  210.                                         rpx = res->pdx + levelno;
  211.                                         rpy = res->pdy + levelno;
  212.                                         if (!((pi->y % (comp->dy << rpy) == 0) || ((pi->y == pi->ty0) && ((try0 << levelno) % (1 << rpy))))){
  213.                                                 continue;      
  214.                                         }
  215.                                         if (!((pi->x % (comp->dx << rpx) == 0) || ((pi->x == pi->tx0) && ((trx0 << levelno) % (1 << rpx))))){
  216.                                                 continue;
  217.                                         }
  218.                                        
  219.                                         if ((res->pw==0)||(res->ph==0)) continue;
  220.                                        
  221.                                         if ((trx0==trx1)||(try0==try1)) continue;
  222.                                        
  223.                                         prci = int_floordivpow2(int_ceildiv(pi->x, comp->dx << levelno), res->pdx)
  224.                                                  - int_floordivpow2(trx0, res->pdx);
  225.                                         prcj = int_floordivpow2(int_ceildiv(pi->y, comp->dy << levelno), res->pdy)
  226.                                                  - int_floordivpow2(try0, res->pdy);
  227.                                         pi->precno = prci + prcj * res->pw;
  228.                                         for (pi->layno = pi->poc.layno0; pi->layno < pi->poc.layno1; pi->layno++) {
  229.                                                 index = pi->layno * pi->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p;
  230.                                                 if (!pi->include[index]) {
  231.                                                         pi->include[index] = 1;
  232.                                                         return true;
  233.                                                 }
  234. LABEL_SKIP:;
  235.                                         }
  236.                                 }
  237.                         }
  238.                 }
  239.         }
  240.        
  241.         return false;
  242. }
  243.  
  244. static bool pi_next_pcrl(opj_pi_iterator_t * pi) {
  245.         opj_pi_comp_t *comp = NULL;
  246.         opj_pi_resolution_t *res = NULL;
  247.         long index = 0;
  248.  
  249.         if (!pi->first) {
  250.                 comp = &pi->comps[pi->compno];
  251.                 goto LABEL_SKIP;
  252.         } else {
  253.                 int compno, resno;
  254.                 pi->first = 0;
  255.                 pi->dx = 0;
  256.                 pi->dy = 0;
  257.                 for (compno = 0; compno < pi->numcomps; compno++) {
  258.                         comp = &pi->comps[compno];
  259.                         for (resno = 0; resno < comp->numresolutions; resno++) {
  260.                                 int dx, dy;
  261.                                 res = &comp->resolutions[resno];
  262.                                 dx = comp->dx * (1 << (res->pdx + comp->numresolutions - 1 - resno));
  263.                                 dy = comp->dy * (1 << (res->pdy + comp->numresolutions - 1 - resno));
  264.                                 pi->dx = !pi->dx ? dx : int_min(pi->dx, dx);
  265.                                 pi->dy = !pi->dy ? dy : int_min(pi->dy, dy);
  266.                         }
  267.                 }
  268.         }
  269.         if (!pi->tp_on){
  270.                         pi->poc.ty0 = pi->ty0;
  271.                         pi->poc.tx0 = pi->tx0;
  272.                         pi->poc.ty1 = pi->ty1;
  273.                         pi->poc.tx1 = pi->tx1;
  274.                 }
  275.         for (pi->y = pi->poc.ty0; pi->y < pi->poc.ty1; pi->y += pi->dy - (pi->y % pi->dy)) {
  276.                 for (pi->x = pi->poc.tx0; pi->x < pi->poc.tx1; pi->x += pi->dx - (pi->x % pi->dx)) {
  277.                         for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1; pi->compno++) {
  278.                                 comp = &pi->comps[pi->compno];
  279.                                 for (pi->resno = pi->poc.resno0; pi->resno < int_min(pi->poc.resno1, comp->numresolutions); pi->resno++) {
  280.                                         int levelno;
  281.                                         int trx0, try0;
  282.                                         int trx1, try1;
  283.                                         int rpx, rpy;
  284.                                         int prci, prcj;
  285.                                         res = &comp->resolutions[pi->resno];
  286.                                         levelno = comp->numresolutions - 1 - pi->resno;
  287.                                         trx0 = int_ceildiv(pi->tx0, comp->dx << levelno);
  288.                                         try0 = int_ceildiv(pi->ty0, comp->dy << levelno);
  289.                                         trx1 = int_ceildiv(pi->tx1, comp->dx << levelno);
  290.                                         try1 = int_ceildiv(pi->ty1, comp->dy << levelno);
  291.                                         rpx = res->pdx + levelno;
  292.                                         rpy = res->pdy + levelno;
  293.                                         if (!((pi->y % (comp->dy << rpy) == 0) || ((pi->y == pi->ty0) && ((try0 << levelno) % (1 << rpy))))){
  294.                                                 continue;      
  295.                                         }
  296.                                         if (!((pi->x % (comp->dx << rpx) == 0) || ((pi->x == pi->tx0) && ((trx0 << levelno) % (1 << rpx))))){
  297.                                                 continue;
  298.                                         }
  299.                                        
  300.                                         if ((res->pw==0)||(res->ph==0)) continue;
  301.                                        
  302.                                         if ((trx0==trx1)||(try0==try1)) continue;
  303.                                        
  304.                                         prci = int_floordivpow2(int_ceildiv(pi->x, comp->dx << levelno), res->pdx)
  305.                                                  - int_floordivpow2(trx0, res->pdx);
  306.                                         prcj = int_floordivpow2(int_ceildiv(pi->y, comp->dy << levelno), res->pdy)
  307.                                                  - int_floordivpow2(try0, res->pdy);
  308.                                         pi->precno = prci + prcj * res->pw;
  309.                                         for (pi->layno = pi->poc.layno0; pi->layno < pi->poc.layno1; pi->layno++) {
  310.                                                 index = pi->layno * pi->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p;
  311.                                                 if (!pi->include[index]) {
  312.                                                         pi->include[index] = 1;
  313.                                                         return true;
  314.                                                 }      
  315. LABEL_SKIP:;
  316.                                         }
  317.                                 }
  318.                         }
  319.                 }
  320.         }
  321.        
  322.         return false;
  323. }
  324.  
  325. static bool pi_next_cprl(opj_pi_iterator_t * pi) {
  326.         opj_pi_comp_t *comp = NULL;
  327.         opj_pi_resolution_t *res = NULL;
  328.         long index = 0;
  329.  
  330.         if (!pi->first) {
  331.                 comp = &pi->comps[pi->compno];
  332.                 goto LABEL_SKIP;
  333.         } else {
  334.                 pi->first = 0;
  335.         }
  336.  
  337.         for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1; pi->compno++) {
  338.                 int resno;
  339.                 comp = &pi->comps[pi->compno];
  340.                 pi->dx = 0;
  341.                 pi->dy = 0;
  342.                 for (resno = 0; resno < comp->numresolutions; resno++) {
  343.                         int dx, dy;
  344.                         res = &comp->resolutions[resno];
  345.                         dx = comp->dx * (1 << (res->pdx + comp->numresolutions - 1 - resno));
  346.                         dy = comp->dy * (1 << (res->pdy + comp->numresolutions - 1 - resno));
  347.                         pi->dx = !pi->dx ? dx : int_min(pi->dx, dx);
  348.                         pi->dy = !pi->dy ? dy : int_min(pi->dy, dy);
  349.                 }
  350.                 if (!pi->tp_on){
  351.                         pi->poc.ty0 = pi->ty0;
  352.                         pi->poc.tx0 = pi->tx0;
  353.                         pi->poc.ty1 = pi->ty1;
  354.                         pi->poc.tx1 = pi->tx1;
  355.                 }
  356.                 for (pi->y = pi->poc.ty0; pi->y < pi->poc.ty1; pi->y += pi->dy - (pi->y % pi->dy)) {
  357.                         for (pi->x = pi->poc.tx0; pi->x < pi->poc.tx1; pi->x += pi->dx - (pi->x % pi->dx)) {
  358.                                 for (pi->resno = pi->poc.resno0; pi->resno < int_min(pi->poc.resno1, comp->numresolutions); pi->resno++) {
  359.                                         int levelno;
  360.                                         int trx0, try0;
  361.                                         int trx1, try1;
  362.                                         int rpx, rpy;
  363.                                         int prci, prcj;
  364.                                         res = &comp->resolutions[pi->resno];
  365.                                         levelno = comp->numresolutions - 1 - pi->resno;
  366.                                         trx0 = int_ceildiv(pi->tx0, comp->dx << levelno);
  367.                                         try0 = int_ceildiv(pi->ty0, comp->dy << levelno);
  368.                                         trx1 = int_ceildiv(pi->tx1, comp->dx << levelno);
  369.                                         try1 = int_ceildiv(pi->ty1, comp->dy << levelno);
  370.                                         rpx = res->pdx + levelno;
  371.                                         rpy = res->pdy + levelno;
  372.                                         if (!((pi->y % (comp->dy << rpy) == 0) || ((pi->y == pi->ty0) && ((try0 << levelno) % (1 << rpy))))){
  373.                                                 continue;      
  374.                                         }
  375.                                         if (!((pi->x % (comp->dx << rpx) == 0) || ((pi->x == pi->tx0) && ((trx0 << levelno) % (1 << rpx))))){
  376.                                                 continue;
  377.                                         }
  378.                                        
  379.                                         if ((res->pw==0)||(res->ph==0)) continue;
  380.                                        
  381.                                         if ((trx0==trx1)||(try0==try1)) continue;
  382.                                        
  383.                                         prci = int_floordivpow2(int_ceildiv(pi->x, comp->dx << levelno), res->pdx)
  384.                                                  - int_floordivpow2(trx0, res->pdx);
  385.                                         prcj = int_floordivpow2(int_ceildiv(pi->y, comp->dy << levelno), res->pdy)
  386.                                                  - int_floordivpow2(try0, res->pdy);
  387.                                         pi->precno = prci + prcj * res->pw;
  388.                                         for (pi->layno = pi->poc.layno0; pi->layno < pi->poc.layno1; pi->layno++) {
  389.                                                 index = pi->layno * pi->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p;
  390.                                                 if (!pi->include[index]) {
  391.                                                         pi->include[index] = 1;
  392.                                                         return true;
  393.                                                 }
  394. LABEL_SKIP:;
  395.                                         }
  396.                                 }
  397.                         }
  398.                 }
  399.         }
  400.        
  401.         return false;
  402. }
  403.  
  404. /*
  405. ==========================================================
  406.    Packet iterator interface
  407. ==========================================================
  408. */
  409.  
  410. opj_pi_iterator_t *pi_create_decode(opj_image_t *image, opj_cp_t *cp, int tileno) {
  411.         int p, q;
  412.         int compno, resno, pino;
  413.         opj_pi_iterator_t *pi = NULL;
  414.         opj_tcp_t *tcp = NULL;
  415.         opj_tccp_t *tccp = NULL;
  416.  
  417.         tcp = &cp->tcps[tileno];
  418.  
  419.         pi = (opj_pi_iterator_t*) opj_calloc((tcp->numpocs + 1), sizeof(opj_pi_iterator_t));
  420.         if(!pi) {
  421.                 /* TODO: throw an error */
  422.                 return NULL;
  423.         }
  424.  
  425.         for (pino = 0; pino < tcp->numpocs + 1; pino++) {       /* change */
  426.                 int maxres = 0;
  427.                 int maxprec = 0;
  428.                 p = tileno % cp->tw;
  429.                 q = tileno / cp->tw;
  430.  
  431.                 pi[pino].tx0 = int_max(cp->tx0 + p * cp->tdx, image->x0);
  432.                 pi[pino].ty0 = int_max(cp->ty0 + q * cp->tdy, image->y0);
  433.                 pi[pino].tx1 = int_min(cp->tx0 + (p + 1) * cp->tdx, image->x1);
  434.                 pi[pino].ty1 = int_min(cp->ty0 + (q + 1) * cp->tdy, image->y1);
  435.                 pi[pino].numcomps = image->numcomps;
  436.  
  437.                 pi[pino].comps = (opj_pi_comp_t*) opj_calloc(image->numcomps, sizeof(opj_pi_comp_t));
  438.                 if(!pi[pino].comps) {
  439.                         /* TODO: throw an error */
  440.                         pi_destroy(pi, cp, tileno);
  441.                         return NULL;
  442.                 }
  443.                
  444.                 for (compno = 0; compno < pi->numcomps; compno++) {
  445.                         int tcx0, tcy0, tcx1, tcy1;
  446.                         opj_pi_comp_t *comp = &pi[pino].comps[compno];
  447.                         tccp = &tcp->tccps[compno];
  448.                         comp->dx = image->comps[compno].dx;
  449.                         comp->dy = image->comps[compno].dy;
  450.                         comp->numresolutions = tccp->numresolutions;
  451.  
  452.                         comp->resolutions = (opj_pi_resolution_t*) opj_calloc(comp->numresolutions, sizeof(opj_pi_resolution_t));
  453.                         if(!comp->resolutions) {
  454.                                 /* TODO: throw an error */
  455.                                 pi_destroy(pi, cp, tileno);
  456.                                 return NULL;
  457.                         }
  458.  
  459.                         tcx0 = int_ceildiv(pi->tx0, comp->dx);
  460.                         tcy0 = int_ceildiv(pi->ty0, comp->dy);
  461.                         tcx1 = int_ceildiv(pi->tx1, comp->dx);
  462.                         tcy1 = int_ceildiv(pi->ty1, comp->dy);
  463.                         if (comp->numresolutions > maxres) {
  464.                                 maxres = comp->numresolutions;
  465.                         }
  466.  
  467.                         for (resno = 0; resno < comp->numresolutions; resno++) {
  468.                                 int levelno;
  469.                                 int rx0, ry0, rx1, ry1;
  470.                                 int px0, py0, px1, py1;
  471.                                 opj_pi_resolution_t *res = &comp->resolutions[resno];
  472.                                 if (tccp->csty & J2K_CCP_CSTY_PRT) {
  473.                                         res->pdx = tccp->prcw[resno];
  474.                                         res->pdy = tccp->prch[resno];
  475.                                 } else {
  476.                                         res->pdx = 15;
  477.                                         res->pdy = 15;
  478.                                 }
  479.                                 levelno = comp->numresolutions - 1 - resno;
  480.                                 rx0 = int_ceildivpow2(tcx0, levelno);
  481.                                 ry0 = int_ceildivpow2(tcy0, levelno);
  482.                                 rx1 = int_ceildivpow2(tcx1, levelno);
  483.                                 ry1 = int_ceildivpow2(tcy1, levelno);
  484.                                 px0 = int_floordivpow2(rx0, res->pdx) << res->pdx;
  485.                                 py0 = int_floordivpow2(ry0, res->pdy) << res->pdy;
  486.                                 px1 = int_ceildivpow2(rx1, res->pdx) << res->pdx;
  487.                                 py1 = int_ceildivpow2(ry1, res->pdy) << res->pdy;
  488.                                 res->pw = (rx0==rx1)?0:((px1 - px0) >> res->pdx);
  489.                                 res->ph = (ry0==ry1)?0:((py1 - py0) >> res->pdy);
  490.                                
  491.                                 if (res->pw*res->ph > maxprec) {
  492.                                         maxprec = res->pw*res->ph;
  493.                                 }
  494.                                
  495.                         }
  496.                 }
  497.                
  498.                 tccp = &tcp->tccps[0];
  499.                 pi[pino].step_p = 1;
  500.                 pi[pino].step_c = maxprec * pi[pino].step_p;
  501.                 pi[pino].step_r = image->numcomps * pi[pino].step_c;
  502.                 pi[pino].step_l = maxres * pi[pino].step_r;
  503.                
  504.                 if (pino == 0) {
  505.                         pi[pino].include = (short int*) opj_calloc(image->numcomps * maxres * tcp->numlayers * maxprec, sizeof(short int));
  506.                         if(!pi[pino].include) {
  507.                                 /* TODO: throw an error */
  508.                                 pi_destroy(pi, cp, tileno);
  509.                                 return NULL;
  510.                         }
  511.                 }
  512.                 else {
  513.                         pi[pino].include = pi[pino - 1].include;
  514.                 }
  515.                
  516.                 if (tcp->POC == 0) {
  517.                         pi[pino].first = 1;
  518.                         pi[pino].poc.resno0 = 0;
  519.                         pi[pino].poc.compno0 = 0;
  520.                         pi[pino].poc.layno1 = tcp->numlayers;
  521.                         pi[pino].poc.resno1 = maxres;
  522.                         pi[pino].poc.compno1 = image->numcomps;
  523.                         pi[pino].poc.prg = tcp->prg;
  524.                 } else {
  525.                         pi[pino].first = 1;
  526.                         pi[pino].poc.resno0 = tcp->pocs[pino].resno0;
  527.                         pi[pino].poc.compno0 = tcp->pocs[pino].compno0;
  528.                         pi[pino].poc.layno1 = tcp->pocs[pino].layno1;
  529.                         pi[pino].poc.resno1 = tcp->pocs[pino].resno1;
  530.                         pi[pino].poc.compno1 = tcp->pocs[pino].compno1;
  531.                         pi[pino].poc.prg = tcp->pocs[pino].prg;
  532.                 }
  533.                 pi[pino].poc.layno0  = 0;
  534.                 pi[pino].poc.precno0 = 0;
  535.                 pi[pino].poc.precno1 = maxprec;
  536.                        
  537.         }
  538.        
  539.         return pi;
  540. }
  541.  
  542.  
  543. opj_pi_iterator_t *pi_initialise_encode(opj_image_t *image, opj_cp_t *cp, int tileno, J2K_T2_MODE t2_mode){
  544.         int p, q, pino;
  545.         int compno, resno;
  546.         int maxres = 0;
  547.         int maxprec = 0;
  548.         opj_pi_iterator_t *pi = NULL;
  549.         opj_tcp_t *tcp = NULL;
  550.         opj_tccp_t *tccp = NULL;
  551.        
  552.         tcp = &cp->tcps[tileno];
  553.  
  554.         pi = (opj_pi_iterator_t*) opj_calloc((tcp->numpocs + 1), sizeof(opj_pi_iterator_t));
  555.         if(!pi) {       return NULL;}
  556.         pi->tp_on = cp->tp_on;
  557.  
  558.         for(pino = 0;pino < tcp->numpocs+1 ; pino ++){
  559.                 p = tileno % cp->tw;
  560.                 q = tileno / cp->tw;
  561.  
  562.                 pi[pino].tx0 = int_max(cp->tx0 + p * cp->tdx, image->x0);
  563.                 pi[pino].ty0 = int_max(cp->ty0 + q * cp->tdy, image->y0);
  564.                 pi[pino].tx1 = int_min(cp->tx0 + (p + 1) * cp->tdx, image->x1);
  565.                 pi[pino].ty1 = int_min(cp->ty0 + (q + 1) * cp->tdy, image->y1);
  566.                 pi[pino].numcomps = image->numcomps;
  567.                
  568.                 pi[pino].comps = (opj_pi_comp_t*) opj_calloc(image->numcomps, sizeof(opj_pi_comp_t));
  569.                 if(!pi[pino].comps) {
  570.                         pi_destroy(pi, cp, tileno);
  571.                         return NULL;
  572.                 }
  573.                
  574.                 for (compno = 0; compno < pi[pino].numcomps; compno++) {
  575.                         int tcx0, tcy0, tcx1, tcy1;
  576.                         opj_pi_comp_t *comp = &pi[pino].comps[compno];
  577.                         tccp = &tcp->tccps[compno];
  578.                         comp->dx = image->comps[compno].dx;
  579.                         comp->dy = image->comps[compno].dy;
  580.                         comp->numresolutions = tccp->numresolutions;
  581.  
  582.                         comp->resolutions = (opj_pi_resolution_t*) opj_malloc(comp->numresolutions * sizeof(opj_pi_resolution_t));
  583.                         if(!comp->resolutions) {
  584.                                 pi_destroy(pi, cp, tileno);
  585.                                 return NULL;
  586.                         }
  587.  
  588.                         tcx0 = int_ceildiv(pi[pino].tx0, comp->dx);
  589.                         tcy0 = int_ceildiv(pi[pino].ty0, comp->dy);
  590.                         tcx1 = int_ceildiv(pi[pino].tx1, comp->dx);
  591.                         tcy1 = int_ceildiv(pi[pino].ty1, comp->dy);
  592.                         if (comp->numresolutions > maxres) {
  593.                                 maxres = comp->numresolutions;
  594.                         }
  595.  
  596.                         for (resno = 0; resno < comp->numresolutions; resno++) {
  597.                                 int levelno;
  598.                                 int rx0, ry0, rx1, ry1;
  599.                                 int px0, py0, px1, py1;
  600.                                 opj_pi_resolution_t *res = &comp->resolutions[resno];
  601.                                 if (tccp->csty & J2K_CCP_CSTY_PRT) {
  602.                                         res->pdx = tccp->prcw[resno];
  603.                                         res->pdy = tccp->prch[resno];
  604.                                 } else {
  605.                                         res->pdx = 15;
  606.                                         res->pdy = 15;
  607.                                 }
  608.                                 levelno = comp->numresolutions - 1 - resno;
  609.                                 rx0 = int_ceildivpow2(tcx0, levelno);
  610.                                 ry0 = int_ceildivpow2(tcy0, levelno);
  611.                                 rx1 = int_ceildivpow2(tcx1, levelno);
  612.                                 ry1 = int_ceildivpow2(tcy1, levelno);
  613.                                 px0 = int_floordivpow2(rx0, res->pdx) << res->pdx;
  614.                                 py0 = int_floordivpow2(ry0, res->pdy) << res->pdy;
  615.                                 px1 = int_ceildivpow2(rx1, res->pdx) << res->pdx;
  616.                                 py1 = int_ceildivpow2(ry1, res->pdy) << res->pdy;
  617.                                 res->pw = (rx0==rx1)?0:((px1 - px0) >> res->pdx);
  618.                                 res->ph = (ry0==ry1)?0:((py1 - py0) >> res->pdy);
  619.  
  620.                                 if (res->pw*res->ph > maxprec) {
  621.                                         maxprec = res->pw * res->ph;
  622.                                 }
  623.                         }
  624.                 }
  625.                
  626.                 tccp = &tcp->tccps[0];
  627.                 pi[pino].step_p = 1;
  628.                 pi[pino].step_c = maxprec * pi[pino].step_p;
  629.                 pi[pino].step_r = image->numcomps * pi[pino].step_c;
  630.                 pi[pino].step_l = maxres * pi[pino].step_r;
  631.                
  632.                 for (compno = 0; compno < pi->numcomps; compno++) {
  633.                         opj_pi_comp_t *comp = &pi->comps[compno];
  634.                         for (resno = 0; resno < comp->numresolutions; resno++) {
  635.                                 int dx, dy;
  636.                                 opj_pi_resolution_t *res = &comp->resolutions[resno];
  637.                                 dx = comp->dx * (1 << (res->pdx + comp->numresolutions - 1 - resno));
  638.                                 dy = comp->dy * (1 << (res->pdy + comp->numresolutions - 1 - resno));
  639.                                 pi[pino].dx = !pi->dx ? dx : int_min(pi->dx, dx);
  640.                                 pi[pino].dy = !pi->dy ? dy : int_min(pi->dy, dy);
  641.                         }
  642.                 }
  643.  
  644.                 if (pino == 0) {
  645.                         pi[pino].include = (short int*) opj_calloc(tcp->numlayers * pi[pino].step_l, sizeof(short int));
  646.                         if(!pi[pino].include) {
  647.                                 pi_destroy(pi, cp, tileno);
  648.                                 return NULL;
  649.                         }
  650.                 }
  651.                 else {
  652.                         pi[pino].include = pi[pino - 1].include;
  653.                 }
  654.                
  655.                 /* Generation of boundaries for each prog flag*/
  656.                         if(tcp->POC && ( cp->cinema || ((!cp->cinema) && (t2_mode == FINAL_PASS)))){
  657.                                 tcp->pocs[pino].compS= tcp->pocs[pino].compno0;
  658.                                 tcp->pocs[pino].compE= tcp->pocs[pino].compno1;
  659.                                 tcp->pocs[pino].resS = tcp->pocs[pino].resno0;
  660.                                 tcp->pocs[pino].resE = tcp->pocs[pino].resno1;
  661.                                 tcp->pocs[pino].layE = tcp->pocs[pino].layno1;
  662.                                 tcp->pocs[pino].prg  = tcp->pocs[pino].prg1;
  663.                                 if (pino > 0)
  664.                                         tcp->pocs[pino].layS = (tcp->pocs[pino].layE > tcp->pocs[pino - 1].layE) ? tcp->pocs[pino - 1].layE : 0;
  665.                         }else {
  666.                                 tcp->pocs[pino].compS= 0;
  667.                                 tcp->pocs[pino].compE= image->numcomps;
  668.                                 tcp->pocs[pino].resS = 0;
  669.                                 tcp->pocs[pino].resE = maxres;
  670.                                 tcp->pocs[pino].layS = 0;
  671.                                 tcp->pocs[pino].layE = tcp->numlayers;
  672.                                 tcp->pocs[pino].prg  = tcp->prg;
  673.                         }
  674.                         tcp->pocs[pino].prcS = 0;
  675.                         tcp->pocs[pino].prcE = maxprec;;
  676.                         tcp->pocs[pino].txS = pi[pino].tx0;
  677.                         tcp->pocs[pino].txE = pi[pino].tx1;
  678.                         tcp->pocs[pino].tyS = pi[pino].ty0;
  679.                         tcp->pocs[pino].tyE = pi[pino].ty1;
  680.                         tcp->pocs[pino].dx = pi[pino].dx;
  681.                         tcp->pocs[pino].dy = pi[pino].dy;
  682.                 }
  683.                         return pi;
  684.         }
  685.  
  686.  
  687.  
  688. void pi_destroy(opj_pi_iterator_t *pi, opj_cp_t *cp, int tileno) {
  689.         int compno, pino;
  690.         opj_tcp_t *tcp = &cp->tcps[tileno];
  691.         if(pi) {
  692.                 for (pino = 0; pino < tcp->numpocs + 1; pino++) {      
  693.                         if(pi[pino].comps) {
  694.                                 for (compno = 0; compno < pi->numcomps; compno++) {
  695.                                         opj_pi_comp_t *comp = &pi[pino].comps[compno];
  696.                                         if(comp->resolutions) {
  697.                                                 opj_free(comp->resolutions);
  698.                                         }
  699.                                 }
  700.                                 opj_free(pi[pino].comps);
  701.                         }
  702.                 }
  703.                 if(pi->include) {
  704.                         opj_free(pi->include);
  705.                 }
  706.                 opj_free(pi);
  707.         }
  708. }
  709.  
  710. bool pi_next(opj_pi_iterator_t * pi) {
  711.         switch (pi->poc.prg) {
  712.                 case LRCP:
  713.                         return pi_next_lrcp(pi);
  714.                 case RLCP:
  715.                         return pi_next_rlcp(pi);
  716.                 case RPCL:
  717.                         return pi_next_rpcl(pi);
  718.                 case PCRL:
  719.                         return pi_next_pcrl(pi);
  720.                 case CPRL:
  721.                         return pi_next_cprl(pi);
  722.                 case PROG_UNKNOWN:
  723.                         return false;
  724.         }
  725.        
  726.         return false;
  727. }
  728.  
  729. bool pi_create_encode( opj_pi_iterator_t *pi, opj_cp_t *cp,int tileno, int pino,int tpnum, int tppos, J2K_T2_MODE t2_mode,int cur_totnum_tp){
  730.         char prog[4];
  731.         int i;
  732.         int incr_top=1,resetX=0;
  733.         opj_tcp_t *tcps =&cp->tcps[tileno];
  734.         opj_poc_t *tcp= &tcps->pocs[pino];
  735.  
  736.         pi[pino].first = 1;
  737.         pi[pino].poc.prg = tcp->prg;
  738.  
  739.         switch(tcp->prg){
  740.                 case CPRL: strncpy(prog, "CPRL",4);
  741.                         break;
  742.                 case LRCP: strncpy(prog, "LRCP",4);
  743.                         break;
  744.                 case PCRL: strncpy(prog, "PCRL",4);
  745.                         break;
  746.                 case RLCP: strncpy(prog, "RLCP",4);
  747.                         break;
  748.                 case RPCL: strncpy(prog, "RPCL",4);
  749.                         break;
  750.                 case PROG_UNKNOWN:
  751.                         return true;
  752.         }
  753.  
  754.         if(!(cp->tp_on && ((!cp->cinema && (t2_mode == FINAL_PASS)) || cp->cinema))){
  755.                 pi[pino].poc.resno0 = tcp->resS;
  756.                 pi[pino].poc.resno1 = tcp->resE;
  757.                 pi[pino].poc.compno0 = tcp->compS;
  758.                 pi[pino].poc.compno1 = tcp->compE;
  759.                 pi[pino].poc.layno0 = tcp->layS;
  760.                 pi[pino].poc.layno1 = tcp->layE;
  761.                 pi[pino].poc.precno0 = tcp->prcS;
  762.                 pi[pino].poc.precno1 = tcp->prcE;
  763.                 pi[pino].poc.tx0 = tcp->txS;
  764.                 pi[pino].poc.ty0 = tcp->tyS;
  765.                 pi[pino].poc.tx1 = tcp->txE;
  766.                 pi[pino].poc.ty1 = tcp->tyE;
  767.         }else {
  768.                 if( tpnum < cur_totnum_tp){
  769.                         for(i=3;i>=0;i--){
  770.                                 switch(prog[i]){
  771.                                 case 'C':
  772.                                         if (i > tppos){
  773.                                                 pi[pino].poc.compno0 = tcp->compS;
  774.                                                 pi[pino].poc.compno1 = tcp->compE;
  775.                                         }else{
  776.                                                 if (tpnum == 0){
  777.                                                         tcp->comp_t = tcp->compS;
  778.                                                         pi[pino].poc.compno0 = tcp->comp_t;
  779.                                                         pi[pino].poc.compno1 = tcp->comp_t+1;
  780.                                                         tcp->comp_t+=1;
  781.                                                 }else{
  782.                                                         if (incr_top == 1){
  783.                                                                 if(tcp->comp_t ==tcp->compE){
  784.                                                                         tcp->comp_t = tcp->compS;
  785.                                                                         pi[pino].poc.compno0 = tcp->comp_t;
  786.                                                                         pi[pino].poc.compno1 = tcp->comp_t+1;
  787.                                                                         tcp->comp_t+=1;
  788.                                                                         incr_top=1;
  789.                                                                 }else{
  790.                                                                         pi[pino].poc.compno0 = tcp->comp_t;
  791.                                                                         pi[pino].poc.compno1 = tcp->comp_t+1;
  792.                                                                         tcp->comp_t+=1;
  793.                                                                         incr_top=0;
  794.                                                                 }
  795.                                                         }else{
  796.                                                                 pi[pino].poc.compno0 = tcp->comp_t-1;
  797.                                                                 pi[pino].poc.compno1 = tcp->comp_t;
  798.                                                         }
  799.                                                 }
  800.                                         }
  801.                                         break;
  802.  
  803.                                 case 'R':
  804.                                         if (i > tppos){
  805.                                                 pi[pino].poc.resno0 = tcp->resS;
  806.                                                 pi[pino].poc.resno1 = tcp->resE;
  807.                                         }else{
  808.                                                 if (tpnum == 0){
  809.                                                         tcp->res_t = tcp->resS;
  810.                                                         pi[pino].poc.resno0 = tcp->res_t;
  811.                                                         pi[pino].poc.resno1 = tcp->res_t+1;
  812.                                                         tcp->res_t+=1;
  813.                                                 }else{
  814.                                                         if (incr_top == 1){
  815.                                                                 if(tcp->res_t==tcp->resE){
  816.                                                                         tcp->res_t = tcp->resS;
  817.                                                                         pi[pino].poc.resno0 = tcp->res_t;
  818.                                                                         pi[pino].poc.resno1 = tcp->res_t+1;
  819.                                                                         tcp->res_t+=1;
  820.                                                                         incr_top=1;
  821.                                                                 }else{
  822.                                                                         pi[pino].poc.resno0 = tcp->res_t;
  823.                                                                         pi[pino].poc.resno1 = tcp->res_t+1;
  824.                                                                         tcp->res_t+=1;
  825.                                                                         incr_top=0;
  826.                                                                 }
  827.                                                         }else{
  828.                                                                 pi[pino].poc.resno0 = tcp->res_t - 1;
  829.                                                                 pi[pino].poc.resno1 = tcp->res_t;
  830.                                                         }
  831.                                                 }
  832.                                         }
  833.                                         break;
  834.  
  835.                                 case 'L':
  836.                                         if (i > tppos){
  837.                                                 pi[pino].poc.layno0 = tcp->layS;
  838.                                                 pi[pino].poc.layno1 = tcp->layE;
  839.                                         }else{
  840.                                                 if (tpnum == 0){
  841.                                                         tcp->lay_t = tcp->layS;
  842.                                                         pi[pino].poc.layno0 = tcp->lay_t;
  843.                                                         pi[pino].poc.layno1 = tcp->lay_t+1;
  844.                                                         tcp->lay_t+=1;
  845.                                                 }else{
  846.                                                         if (incr_top == 1){
  847.                                                                 if(tcp->lay_t == tcp->layE){
  848.                                                                         tcp->lay_t = tcp->layS;
  849.                                                                         pi[pino].poc.layno0 = tcp->lay_t;
  850.                                                                         pi[pino].poc.layno1 = tcp->lay_t+1;
  851.                                                                         tcp->lay_t+=1;
  852.                                                                         incr_top=1;
  853.                                                                 }else{
  854.                                                                         pi[pino].poc.layno0 = tcp->lay_t;
  855.                                                                         pi[pino].poc.layno1 = tcp->lay_t+1;
  856.                                                                         tcp->lay_t+=1;
  857.                                                                         incr_top=0;
  858.                                                                 }
  859.                                                         }else{
  860.                                                                 pi[pino].poc.layno0 = tcp->lay_t - 1;
  861.                                                                 pi[pino].poc.layno1 = tcp->lay_t;
  862.                                                         }
  863.                                                 }
  864.                                         }
  865.                                         break;
  866.  
  867.                                 case 'P':
  868.                                         switch(tcp->prg){
  869.                                                 case LRCP:
  870.                                                 case RLCP:
  871.                                                         if (i > tppos){
  872.                                                                 pi[pino].poc.precno0 = tcp->prcS;
  873.                                                                 pi[pino].poc.precno1 = tcp->prcE;
  874.                                                         }else{
  875.                                                                 if (tpnum == 0){
  876.                                                                         tcp->prc_t = tcp->prcS;
  877.                                                                         pi[pino].poc.precno0 = tcp->prc_t;
  878.                                                                         pi[pino].poc.precno1 = tcp->prc_t+1;
  879.                                                                         tcp->prc_t+=1;
  880.                                                                 }else{
  881.                                                                         if (incr_top == 1){
  882.                                                                                 if(tcp->prc_t == tcp->prcE){
  883.                                                                                         tcp->prc_t = tcp->prcS;
  884.                                                                                         pi[pino].poc.precno0 = tcp->prc_t;
  885.                                                                                         pi[pino].poc.precno1 = tcp->prc_t+1;
  886.                                                                                         tcp->prc_t+=1;
  887.                                                                                         incr_top=1;
  888.                                                                                 }else{
  889.                                                                                         pi[pino].poc.precno0 = tcp->prc_t;
  890.                                                                                         pi[pino].poc.precno1 = tcp->prc_t+1;
  891.                                                                                         tcp->prc_t+=1;
  892.                                                                                         incr_top=0;
  893.                                                                                 }
  894.                                                                         }else{
  895.                                                                                 pi[pino].poc.precno0 = tcp->prc_t - 1;
  896.                                                                                 pi[pino].poc.precno1 = tcp->prc_t;
  897.                                                                         }
  898.                                                                 }
  899.                                                         }
  900.                                                 break;
  901.                                                 default:
  902.                                                         if (i > tppos){
  903.                                                                 pi[pino].poc.tx0 = tcp->txS;
  904.                                                                 pi[pino].poc.ty0 = tcp->tyS;
  905.                                                                 pi[pino].poc.tx1 = tcp->txE;
  906.                                                                 pi[pino].poc.ty1 = tcp->tyE;
  907.                                                         }else{
  908.                                                                 if (tpnum == 0){
  909.                                                                         tcp->tx0_t = tcp->txS;
  910.                                                                         tcp->ty0_t = tcp->tyS;
  911.                                                                         pi[pino].poc.tx0 = tcp->tx0_t;
  912.                                                                         pi[pino].poc.tx1 = tcp->tx0_t + tcp->dx - (tcp->tx0_t % tcp->dx);
  913.                                                                         pi[pino].poc.ty0 = tcp->ty0_t;
  914.                                                                         pi[pino].poc.ty1 = tcp->ty0_t + tcp->dy - (tcp->ty0_t % tcp->dy);
  915.                                                                         tcp->tx0_t = pi[pino].poc.tx1;
  916.                                                                         tcp->ty0_t = pi[pino].poc.ty1;
  917.                                                                 }else{
  918.                                                                         if (incr_top == 1){
  919.                                                                                 if(tcp->tx0_t >= tcp->txE){
  920.                                                                                         if(tcp->ty0_t >= tcp->tyE){
  921.                                                                                                 tcp->ty0_t = tcp->tyS;
  922.                                                                                                 pi[pino].poc.ty0 = tcp->ty0_t;
  923.                                                                                                 pi[pino].poc.ty1 = tcp->ty0_t + tcp->dy - (tcp->ty0_t % tcp->dy);
  924.                                                                                                 tcp->ty0_t = pi[pino].poc.ty1;
  925.                                                                                                 incr_top=1;resetX=1;
  926.                                                                                         }else{
  927.                                                                                                 pi[pino].poc.ty0 = tcp->ty0_t;
  928.                                                                                                 pi[pino].poc.ty1 = tcp->ty0_t + tcp->dy - (tcp->ty0_t % tcp->dy);
  929.                                                                                                 tcp->ty0_t = pi[pino].poc.ty1;
  930.                                                                                                 incr_top=0;resetX=1;
  931.                                                                                         }
  932.                                                                                         if(resetX==1){
  933.                                                                                                 tcp->tx0_t = tcp->txS;
  934.                                                                                                 pi[pino].poc.tx0 = tcp->tx0_t;
  935.                                                                                                 pi[pino].poc.tx1 = tcp->tx0_t + tcp->dx- (tcp->tx0_t % tcp->dx);
  936.                                                                                                 tcp->tx0_t = pi[pino].poc.tx1;
  937.                                                                                         }
  938.                                                                                 }else{
  939.                                                                                         pi[pino].poc.tx0 = tcp->tx0_t;
  940.                                                                                         pi[pino].poc.tx1 = tcp->tx0_t + tcp->dx- (tcp->tx0_t % tcp->dx);
  941.                                                                                         tcp->tx0_t = pi[pino].poc.tx1;
  942.                                                                                         pi[pino].poc.ty0 = tcp->ty0_t - tcp->dy - (tcp->ty0_t % tcp->dy);
  943.                                                                                         pi[pino].poc.ty1 = tcp->ty0_t ;
  944.                                                                                         incr_top=0;
  945.                                                                                 }
  946.                                                                         }else{
  947.                                                                                 pi[pino].poc.tx0 = tcp->tx0_t - tcp->dx - (tcp->tx0_t % tcp->dx);
  948.                                                                                 pi[pino].poc.tx1 = tcp->tx0_t ;
  949.                                                                                 pi[pino].poc.ty0 = tcp->ty0_t - tcp->dy - (tcp->ty0_t % tcp->dy);
  950.                                                                                 pi[pino].poc.ty1 = tcp->ty0_t ;
  951.                                                                         }
  952.                                                                 }
  953.                                                         }
  954.                                                 break;
  955.                                                 }
  956.                                                 break;
  957.                                 }              
  958.                         }
  959.                 }
  960.         }      
  961.         return false;
  962. }
  963.  
  964.