← Back to branch summary

~ubuntu-branches/ubuntu/lucid/blender/lucid

« back to all changes in this revision

Viewing changes to extern/libopenjpeg/pi.c

  • Committer: Bazaar Package Importer
  • Author(s): Chris Coulson
  • Date: 2009-08-06 22:32:19 UTC
  • mfrom: (1.2.10 upstream)
  • Revision ID: james.westby@ubuntu.com-20090806223219-8z4eej1u8levu4pz
Tags: 2.49a+dfsg-0ubuntu1
https://launchpad.net/bugs/382153
* Merge from debian unstable, remaining changes:
  - debian/control: Build-depend on python-2.6 rather than python-2.5.
  - debian/misc/*.desktop: Add Spanish translation to .desktop 
    files.
  - debian/pyversions: 2.6.
  - debian/rules: Clean *.o of source/blender/python/api2_2x/
* New upstream release (LP: #382153).
* Refreshed patches:
  - 01_sanitize_sys.patch
  - 02_tmp_in_HOME
  - 10_use_systemwide_ftgl
  - 70_portability_platform_detection
* Removed patches merged upstream:
  - 30_fix_python_syntax_warning
  - 90_ubuntu_ffmpeg_52_changes

Show diffs side-by-side

added added

removed removed

Lines of Context:
extern/libopenjpeg/pi.c
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 << rpx))))){
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->pw==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 << rpx))))){
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->pw==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 << rpx))))){
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->pw==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