Update openjpeg
[pdfium.git] / core / src / fxcodec / fx_libopenjpeg / libopenjpeg20 / t2.c
1 /*
2  * The copyright in this software is being made available under the 2-clauses 
3  * BSD License, included below. This software may be subject to other third 
4  * party and contributor rights, including patent rights, and no such rights
5  * are granted under this license.
6  *
7  * Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
8  * Copyright (c) 2002-2014, Professor Benoit Macq
9  * Copyright (c) 2001-2003, David Janssens
10  * Copyright (c) 2002-2003, Yannick Verschueren
11  * Copyright (c) 2003-2007, Francois-Olivier Devaux 
12  * Copyright (c) 2003-2014, Antonin Descampe
13  * Copyright (c) 2005, Herve Drolon, FreeImage Team
14  * Copyright (c) 2008, 2011-2012, Centre National d'Etudes Spatiales (CNES), FR 
15  * Copyright (c) 2012, CS Systemes d'Information, France
16  * All rights reserved.
17  *
18  * Redistribution and use in source and binary forms, with or without
19  * modification, are permitted provided that the following conditions
20  * are met:
21  * 1. Redistributions of source code must retain the above copyright
22  *    notice, this list of conditions and the following disclaimer.
23  * 2. Redistributions in binary form must reproduce the above copyright
24  *    notice, this list of conditions and the following disclaimer in the
25  *    documentation and/or other materials provided with the distribution.
26  *
27  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
28  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
31  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37  * POSSIBILITY OF SUCH DAMAGE.
38  */
39
40 #include "opj_includes.h"
41
42 /** @defgroup T2 T2 - Implementation of a tier-2 coding */
43 /*@{*/
44
45 /** @name Local static functions */
46 /*@{*/
47
48 static void opj_t2_putcommacode(opj_bio_t *bio, OPJ_INT32 n);
49
50 static OPJ_UINT32 opj_t2_getcommacode(opj_bio_t *bio); 
51 /**
52 Variable length code for signalling delta Zil (truncation point)
53 @param bio  Bit Input/Output component
54 @param n    delta Zil
55 */
56 static void opj_t2_putnumpasses(opj_bio_t *bio, OPJ_UINT32 n);
57 static OPJ_UINT32 opj_t2_getnumpasses(opj_bio_t *bio);
58
59 /**
60 Encode a packet of a tile to a destination buffer
61 @param tileno Number of the tile encoded
62 @param tile Tile for which to write the packets
63 @param tcp Tile coding parameters
64 @param pi Packet identity
65 @param dest Destination buffer
66 @param p_data_written   FIXME DOC
67 @param len Length of the destination buffer
68 @param cstr_info Codestream information structure
69 @return
70 */
71 static OPJ_BOOL opj_t2_encode_packet(   OPJ_UINT32 tileno,
72                                         opj_tcd_tile_t *tile,
73                                         opj_tcp_t *tcp,
74                                         opj_pi_iterator_t *pi,
75                                         OPJ_BYTE *dest,
76                                         OPJ_UINT32 * p_data_written,
77                                         OPJ_UINT32 len,
78                                         opj_codestream_info_t *cstr_info);
79
80 /**
81 Decode a packet of a tile from a source buffer
82 @param t2 T2 handle
83 @param tile Tile for which to write the packets
84 @param tcp Tile coding parameters
85 @param pi Packet identity
86 @param src Source buffer
87 @param data_read   FIXME DOC
88 @param max_length  FIXME DOC
89 @param pack_info Packet information
90
91 @return  FIXME DOC
92 */
93 static OPJ_BOOL opj_t2_decode_packet(   opj_t2_t* t2,
94                                         opj_tcd_tile_t *tile,
95                                         opj_tcp_t *tcp,
96                                         opj_pi_iterator_t *pi,
97                                         OPJ_BYTE *src,
98                                         OPJ_UINT32 * data_read,
99                                         OPJ_UINT32 max_length,
100                                         opj_packet_info_t *pack_info);
101
102 static OPJ_BOOL opj_t2_skip_packet( opj_t2_t* p_t2,
103                                     opj_tcd_tile_t *p_tile,
104                                     opj_tcp_t *p_tcp,
105                                     opj_pi_iterator_t *p_pi,
106                                     OPJ_BYTE *p_src,
107                                     OPJ_UINT32 * p_data_read,
108                                     OPJ_UINT32 p_max_length,
109                                     opj_packet_info_t *p_pack_info);
110
111 static OPJ_BOOL opj_t2_read_packet_header(  opj_t2_t* p_t2,
112                                             opj_tcd_tile_t *p_tile,
113                                             opj_tcp_t *p_tcp,
114                                             opj_pi_iterator_t *p_pi,
115                                             OPJ_BOOL * p_is_data_present,
116                                             OPJ_BYTE *p_src_data,
117                                             OPJ_UINT32 * p_data_read,
118                                             OPJ_UINT32 p_max_length,
119                                             opj_packet_info_t *p_pack_info);
120
121 static OPJ_BOOL opj_t2_read_packet_data(opj_t2_t* p_t2,
122                                         opj_tcd_tile_t *p_tile,
123                                         opj_pi_iterator_t *p_pi,
124                                         OPJ_BYTE *p_src_data,
125                                         OPJ_UINT32 * p_data_read,
126                                         OPJ_UINT32 p_max_length,
127                                         opj_packet_info_t *pack_info);
128
129 static OPJ_BOOL opj_t2_skip_packet_data(opj_t2_t* p_t2,
130                                         opj_tcd_tile_t *p_tile,
131                                         opj_pi_iterator_t *p_pi,
132                                         OPJ_UINT32 * p_data_read,
133                                         OPJ_UINT32 p_max_length,
134                                         opj_packet_info_t *pack_info);
135
136 /**
137 @param cblk
138 @param index
139 @param cblksty
140 @param first
141 */
142 static OPJ_BOOL opj_t2_init_seg(    opj_tcd_cblk_dec_t* cblk,
143                                     OPJ_UINT32 index,
144                                     OPJ_UINT32 cblksty,
145                                     OPJ_UINT32 first);
146
147 /*@}*/
148
149 /*@}*/
150
151 /* ----------------------------------------------------------------------- */
152
153 /* #define RESTART 0x04 */
154 static void opj_t2_putcommacode(opj_bio_t *bio, OPJ_INT32 n) {
155         while (--n >= 0) {
156                 opj_bio_write(bio, 1, 1);
157         }
158         opj_bio_write(bio, 0, 1);
159 }
160
161 OPJ_UINT32 opj_t2_getcommacode(opj_bio_t *bio) 
162 {
163     OPJ_UINT32 n = 0;
164     while (opj_bio_read(bio, 1)) {
165             ++n;
166     }
167     return n;
168 }
169
170 void opj_t2_putnumpasses(opj_bio_t *bio, OPJ_UINT32 n) {
171         if (n == 1) {
172                 opj_bio_write(bio, 0, 1);
173         } else if (n == 2) {
174                 opj_bio_write(bio, 2, 2);
175         } else if (n <= 5) {
176                 opj_bio_write(bio, 0xc | (n - 3), 4);
177         } else if (n <= 36) {
178                 opj_bio_write(bio, 0x1e0 | (n - 6), 9);
179         } else if (n <= 164) {
180                 opj_bio_write(bio, 0xff80 | (n - 37), 16);
181         }
182 }
183
184 OPJ_UINT32 opj_t2_getnumpasses(opj_bio_t *bio) {
185         OPJ_UINT32 n;
186         if (!opj_bio_read(bio, 1))
187                 return 1;
188         if (!opj_bio_read(bio, 1))
189                 return 2;
190         if ((n = opj_bio_read(bio, 2)) != 3)
191                 return (3 + n);
192         if ((n = opj_bio_read(bio, 5)) != 31)
193                 return (6 + n);
194         return (37 + opj_bio_read(bio, 7));
195 }
196
197 /* ----------------------------------------------------------------------- */
198
199 OPJ_BOOL opj_t2_encode_packets( opj_t2_t* p_t2,
200                                 OPJ_UINT32 p_tile_no,
201                                 opj_tcd_tile_t *p_tile,
202                                 OPJ_UINT32 p_maxlayers,
203                                 OPJ_BYTE *p_dest,
204                                 OPJ_UINT32 * p_data_written,
205                                 OPJ_UINT32 p_max_len,
206                                 opj_codestream_info_t *cstr_info,
207                                 OPJ_UINT32 p_tp_num,
208                                 OPJ_INT32 p_tp_pos,
209                                 OPJ_UINT32 p_pino,
210                                 J2K_T2_MODE p_t2_mode)
211 {
212         OPJ_BYTE *l_current_data = p_dest;
213         OPJ_UINT32 l_nb_bytes = 0;
214         OPJ_UINT32 compno;
215         OPJ_UINT32 poc;
216         opj_pi_iterator_t *l_pi = 00;
217         opj_pi_iterator_t *l_current_pi = 00;
218         opj_image_t *l_image = p_t2->image;
219         opj_cp_t *l_cp = p_t2->cp;
220         opj_tcp_t *l_tcp = &l_cp->tcps[p_tile_no];
221         OPJ_UINT32 pocno = (l_cp->rsiz == OPJ_PROFILE_CINEMA_4K)? 2: 1;
222         OPJ_UINT32 l_max_comp = l_cp->m_specific_param.m_enc.m_max_comp_size > 0 ? l_image->numcomps : 1;
223         OPJ_UINT32 l_nb_pocs = l_tcp->numpocs + 1;
224
225         l_pi = opj_pi_initialise_encode(l_image, l_cp, p_tile_no, p_t2_mode);
226         if (!l_pi) {
227                 return OPJ_FALSE;
228         }
229
230         * p_data_written = 0;
231
232         if (p_t2_mode == THRESH_CALC ){ /* Calculating threshold */
233                 l_current_pi = l_pi;
234
235                 for     (compno = 0; compno < l_max_comp; ++compno) {
236                         OPJ_UINT32 l_comp_len = 0;
237                         l_current_pi = l_pi;
238
239                         for (poc = 0; poc < pocno ; ++poc) {
240                                 OPJ_UINT32 l_tp_num = compno;
241
242                                 /* TODO MSD : check why this function cannot fail (cf. v1) */
243                                 opj_pi_create_encode(l_pi, l_cp,p_tile_no,poc,l_tp_num,p_tp_pos,p_t2_mode);
244
245                                 while (opj_pi_next(l_current_pi)) {
246                                         if (l_current_pi->layno < p_maxlayers) {
247                                                 l_nb_bytes = 0;
248
249                                                 if (! opj_t2_encode_packet(p_tile_no,p_tile, l_tcp, l_current_pi, l_current_data, &l_nb_bytes, p_max_len, cstr_info)) {
250                                                         opj_pi_destroy(l_pi, l_nb_pocs);
251                                                         return OPJ_FALSE;
252                                                 }
253
254                                                 l_comp_len += l_nb_bytes;
255                                                 l_current_data += l_nb_bytes;
256                                                 p_max_len -= l_nb_bytes;
257
258                                                 * p_data_written += l_nb_bytes;
259                                         }
260                                 }
261
262                                 if (l_cp->m_specific_param.m_enc.m_max_comp_size) {
263                                         if (l_comp_len > l_cp->m_specific_param.m_enc.m_max_comp_size) {
264                                                 opj_pi_destroy(l_pi, l_nb_pocs);
265                                                 return OPJ_FALSE;
266                                         }
267                                 }
268
269                                 ++l_current_pi;
270                         }
271                 }
272         }
273         else {  /* t2_mode == FINAL_PASS  */
274                 opj_pi_create_encode(l_pi, l_cp,p_tile_no,p_pino,p_tp_num,p_tp_pos,p_t2_mode);
275
276                 l_current_pi = &l_pi[p_pino];
277
278                 while (opj_pi_next(l_current_pi)) {
279                         if (l_current_pi->layno < p_maxlayers) {
280                                 l_nb_bytes=0;
281
282                                 if (! opj_t2_encode_packet(p_tile_no,p_tile, l_tcp, l_current_pi, l_current_data, &l_nb_bytes, p_max_len, cstr_info)) {
283                                         opj_pi_destroy(l_pi, l_nb_pocs);
284                                         return OPJ_FALSE;
285                                 }
286
287                                 l_current_data += l_nb_bytes;
288                                 p_max_len -= l_nb_bytes;
289
290                                 * p_data_written += l_nb_bytes;
291
292                                 /* INDEX >> */
293                                 if(cstr_info) {
294                                         if(cstr_info->index_write) {
295                                                 opj_tile_info_t *info_TL = &cstr_info->tile[p_tile_no];
296                                                 opj_packet_info_t *info_PK = &info_TL->packet[cstr_info->packno];
297                                                 if (!cstr_info->packno) {
298                                                         info_PK->start_pos = info_TL->end_header + 1;
299                                                 } else {
300                                                         info_PK->start_pos = ((l_cp->m_specific_param.m_enc.m_tp_on | l_tcp->POC)&& info_PK->start_pos) ? info_PK->start_pos : info_TL->packet[cstr_info->packno - 1].end_pos + 1;
301                                                 }
302                                                 info_PK->end_pos = info_PK->start_pos + l_nb_bytes - 1;
303                                                 info_PK->end_ph_pos += info_PK->start_pos - 1;  /* End of packet header which now only represents the distance
304                                                                                                                                                                                                                                                    to start of packet is incremented by value of start of packet*/
305                                         }
306
307                                         cstr_info->packno++;
308                                 }
309                                 /* << INDEX */
310                                 ++p_tile->packno;
311                         }
312                 }
313         }
314
315         opj_pi_destroy(l_pi, l_nb_pocs);
316
317         return OPJ_TRUE;
318 }
319
320 /* see issue 80 */
321 #if 0
322 #define JAS_FPRINTF fprintf
323 #else
324 /* issue 290 */
325 static void opj_null_jas_fprintf(FILE* file, const char * format, ...)
326 {
327   (void)file;
328   (void)format;
329 }
330 #define JAS_FPRINTF opj_null_jas_fprintf
331 #endif
332
333 OPJ_BOOL opj_t2_decode_packets( opj_t2_t *p_t2,
334                                 OPJ_UINT32 p_tile_no,
335                                 opj_tcd_tile_t *p_tile,
336                                 OPJ_BYTE *p_src,
337                                 OPJ_UINT32 * p_data_read,
338                                 OPJ_UINT32 p_max_len,
339                                 opj_codestream_index_t *p_cstr_index)
340 {
341         OPJ_BYTE *l_current_data = p_src;
342         opj_pi_iterator_t *l_pi = 00;
343         OPJ_UINT32 pino;
344         opj_image_t *l_image = p_t2->image;
345         opj_cp_t *l_cp = p_t2->cp;
346         opj_tcp_t *l_tcp = &(p_t2->cp->tcps[p_tile_no]);
347         OPJ_UINT32 l_nb_bytes_read;
348         OPJ_UINT32 l_nb_pocs = l_tcp->numpocs + 1;
349         opj_pi_iterator_t *l_current_pi = 00;
350 #ifdef TODO_MSD
351         OPJ_UINT32 curtp = 0;
352         OPJ_UINT32 tp_start_packno;
353 #endif 
354         opj_packet_info_t *l_pack_info = 00;
355         opj_image_comp_t* l_img_comp = 00;
356
357         OPJ_ARG_NOT_USED(p_cstr_index);
358
359 #ifdef TODO_MSD
360         if (p_cstr_index) {
361                 l_pack_info = p_cstr_index->tile_index[p_tile_no].packet;
362         }
363 #endif
364
365         /* create a packet iterator */
366         l_pi = opj_pi_create_decode(l_image, l_cp, p_tile_no);
367         if (!l_pi) {
368                 return OPJ_FALSE;
369         }
370
371
372         l_current_pi = l_pi;
373
374         for     (pino = 0; pino <= l_tcp->numpocs; ++pino) {
375
376                 /* if the resolution needed is too low, one dim of the tilec could be equal to zero
377                  * and no packets are used to decode this resolution and
378                  * l_current_pi->resno is always >= p_tile->comps[l_current_pi->compno].minimum_num_resolutions
379                  * and no l_img_comp->resno_decoded are computed
380                  */
381                 OPJ_BOOL* first_pass_failed = (OPJ_BOOL*)opj_malloc(l_image->numcomps * sizeof(OPJ_BOOL));
382                 if (!first_pass_failed)
383                 {
384                     opj_pi_destroy(l_pi,l_nb_pocs);
385                     return OPJ_FALSE;
386                 }
387                 memset(first_pass_failed, OPJ_TRUE, l_image->numcomps * sizeof(OPJ_BOOL));
388
389                 while (opj_pi_next(l_current_pi)) {
390                   JAS_FPRINTF( stderr, "packet offset=00000166 prg=%d cmptno=%02d rlvlno=%02d prcno=%03d lyrno=%02d\n\n",
391                     l_current_pi->poc.prg1, l_current_pi->compno, l_current_pi->resno, l_current_pi->precno, l_current_pi->layno );
392
393                         if (l_tcp->num_layers_to_decode > l_current_pi->layno
394                                         && l_current_pi->resno < p_tile->comps[l_current_pi->compno].minimum_num_resolutions) {
395                                 l_nb_bytes_read = 0;
396
397                                 first_pass_failed[l_current_pi->compno] = OPJ_FALSE;
398
399                                 if (! opj_t2_decode_packet(p_t2,p_tile,l_tcp,l_current_pi,l_current_data,&l_nb_bytes_read,p_max_len,l_pack_info)) {
400                                         opj_pi_destroy(l_pi,l_nb_pocs);
401                                         opj_free(first_pass_failed);
402                                         return OPJ_FALSE;
403                                 }
404
405                                 l_img_comp = &(l_image->comps[l_current_pi->compno]);
406                                 l_img_comp->resno_decoded = opj_uint_max(l_current_pi->resno, l_img_comp->resno_decoded);
407                         }
408                         else {
409                                 l_nb_bytes_read = 0;
410                                 if (! opj_t2_skip_packet(p_t2,p_tile,l_tcp,l_current_pi,l_current_data,&l_nb_bytes_read,p_max_len,l_pack_info)) {
411                                         opj_pi_destroy(l_pi,l_nb_pocs);
412                                         opj_free(first_pass_failed);
413                                         return OPJ_FALSE;
414                                 }
415                         }
416
417                         if (first_pass_failed[l_current_pi->compno]) {
418                                 l_img_comp = &(l_image->comps[l_current_pi->compno]);
419                                 if (l_img_comp->resno_decoded == 0)
420                                         l_img_comp->resno_decoded = p_tile->comps[l_current_pi->compno].minimum_num_resolutions - 1;
421                         }
422
423                         l_current_data += l_nb_bytes_read;
424                         p_max_len -= l_nb_bytes_read;
425
426                         /* INDEX >> */
427 #ifdef TODO_MSD
428                         if(p_cstr_info) {
429                                 opj_tile_info_v2_t *info_TL = &p_cstr_info->tile[p_tile_no];
430                                 opj_packet_info_t *info_PK = &info_TL->packet[p_cstr_info->packno];
431                                 tp_start_packno = 0;
432                                 if (!p_cstr_info->packno) {
433                                         info_PK->start_pos = info_TL->end_header + 1;
434                                 } else if (info_TL->packet[p_cstr_info->packno-1].end_pos >= (OPJ_INT32)p_cstr_info->tile[p_tile_no].tp[curtp].tp_end_pos){ /* New tile part */
435                                         info_TL->tp[curtp].tp_numpacks = p_cstr_info->packno - tp_start_packno; /* Number of packets in previous tile-part */
436                                         tp_start_packno = p_cstr_info->packno;
437                                         curtp++;
438                                         info_PK->start_pos = p_cstr_info->tile[p_tile_no].tp[curtp].tp_end_header+1;
439                                 } else {
440                                         info_PK->start_pos = (l_cp->m_specific_param.m_enc.m_tp_on && info_PK->start_pos) ? info_PK->start_pos : info_TL->packet[p_cstr_info->packno - 1].end_pos + 1;
441                                 }
442                                 info_PK->end_pos = info_PK->start_pos + l_nb_bytes_read - 1;
443                                 info_PK->end_ph_pos += info_PK->start_pos - 1;  /* End of packet header which now only represents the distance */
444                                 ++p_cstr_info->packno;
445                         }
446 #endif
447                         /* << INDEX */
448                 }
449                 ++l_current_pi;
450
451                 opj_free(first_pass_failed);
452         }
453         /* INDEX >> */
454 #ifdef TODO_MSD
455         if
456                 (p_cstr_info) {
457                 p_cstr_info->tile[p_tile_no].tp[curtp].tp_numpacks = p_cstr_info->packno - tp_start_packno; /* Number of packets in last tile-part */
458         }
459 #endif
460         /* << INDEX */
461
462         /* don't forget to release pi */
463         opj_pi_destroy(l_pi,l_nb_pocs);
464         *p_data_read = (OPJ_UINT32)(l_current_data - p_src);
465         return OPJ_TRUE;
466 }
467
468 /* ----------------------------------------------------------------------- */
469
470 /**
471  * Creates a Tier 2 handle
472  *
473  * @param       p_image         Source or destination image
474  * @param       p_cp            Image coding parameters.
475  * @return              a new T2 handle if successful, NULL otherwise.
476 */
477 opj_t2_t* opj_t2_create(opj_image_t *p_image, opj_cp_t *p_cp)
478 {
479         /* create the t2 structure */
480         opj_t2_t *l_t2 = (opj_t2_t*)opj_calloc(1,sizeof(opj_t2_t));
481         if (!l_t2) {
482                 return NULL;
483         }
484
485         l_t2->image = p_image;
486         l_t2->cp = p_cp;
487
488         return l_t2;
489 }
490
491 void opj_t2_destroy(opj_t2_t *t2) {
492         if(t2) {
493                 opj_free(t2);
494         }
495 }
496
497 OPJ_BOOL opj_t2_decode_packet(  opj_t2_t* p_t2,
498                                 opj_tcd_tile_t *p_tile,
499                                 opj_tcp_t *p_tcp,
500                                 opj_pi_iterator_t *p_pi,
501                                 OPJ_BYTE *p_src,
502                                 OPJ_UINT32 * p_data_read,
503                                 OPJ_UINT32 p_max_length,
504                                 opj_packet_info_t *p_pack_info)
505 {
506         OPJ_BOOL l_read_data;
507         OPJ_UINT32 l_nb_bytes_read = 0;
508         OPJ_UINT32 l_nb_total_bytes_read = 0;
509
510         *p_data_read = 0;
511
512         if (! opj_t2_read_packet_header(p_t2,p_tile,p_tcp,p_pi,&l_read_data,p_src,&l_nb_bytes_read,p_max_length,p_pack_info)) {
513                 return OPJ_FALSE;
514         }
515
516         p_src += l_nb_bytes_read;
517         l_nb_total_bytes_read += l_nb_bytes_read;
518         p_max_length -= l_nb_bytes_read;
519
520         /* we should read data for the packet */
521         if (l_read_data) {
522                 l_nb_bytes_read = 0;
523
524                 if (! opj_t2_read_packet_data(p_t2,p_tile,p_pi,p_src,&l_nb_bytes_read,p_max_length,p_pack_info)) {
525                         return OPJ_FALSE;
526                 }
527
528                 l_nb_total_bytes_read += l_nb_bytes_read;
529         }
530
531         *p_data_read = l_nb_total_bytes_read;
532
533         return OPJ_TRUE;
534 }
535
536 OPJ_BOOL opj_t2_encode_packet(  OPJ_UINT32 tileno,
537                                 opj_tcd_tile_t * tile,
538                                 opj_tcp_t * tcp,
539                                 opj_pi_iterator_t *pi,
540                                 OPJ_BYTE *dest,
541                                 OPJ_UINT32 * p_data_written,
542                                 OPJ_UINT32 length,
543                                 opj_codestream_info_t *cstr_info)
544 {
545         OPJ_UINT32 bandno, cblkno;
546         OPJ_BYTE* c = dest;
547         OPJ_UINT32 l_nb_bytes;
548         OPJ_UINT32 compno = pi->compno;     /* component value */
549         OPJ_UINT32 resno  = pi->resno;      /* resolution level value */
550         OPJ_UINT32 precno = pi->precno;     /* precinct value */
551         OPJ_UINT32 layno  = pi->layno;      /* quality layer value */
552         OPJ_UINT32 l_nb_blocks;
553         opj_tcd_band_t *band = 00;
554         opj_tcd_cblk_enc_t* cblk = 00;
555         opj_tcd_pass_t *pass = 00;
556
557         opj_tcd_tilecomp_t *tilec = &tile->comps[compno];
558         opj_tcd_resolution_t *res = &tilec->resolutions[resno];
559
560         opj_bio_t *bio = 00;    /* BIO component */
561
562         /* <SOP 0xff91> */
563         if (tcp->csty & J2K_CP_CSTY_SOP) {
564                 c[0] = 255;
565                 c[1] = 145;
566                 c[2] = 0;
567                 c[3] = 4;
568 #if 0
569                 c[4] = (tile->packno % 65536) / 256;
570                 c[5] = (tile->packno % 65536) % 256;
571 #else
572                 c[4] = (tile->packno >> 8) & 0xff; /* packno is uint32_t */
573                 c[5] = tile->packno & 0xff;
574 #endif
575                 c += 6;
576                 length -= 6;
577         }
578         /* </SOP> */
579
580         if (!layno) {
581                 band = res->bands;
582
583                 for(bandno = 0; bandno < res->numbands; ++bandno) {
584                         opj_tcd_precinct_t *prc = &band->precincts[precno];
585
586                         opj_tgt_reset(prc->incltree);
587                         opj_tgt_reset(prc->imsbtree);
588
589                         l_nb_blocks = prc->cw * prc->ch;
590                         for     (cblkno = 0; cblkno < l_nb_blocks; ++cblkno) {
591                                 cblk = &prc->cblks.enc[cblkno];
592
593                                 cblk->numpasses = 0;
594                                 opj_tgt_setvalue(prc->imsbtree, cblkno, band->numbps - (OPJ_INT32)cblk->numbps);
595                         }
596                         ++band;
597                 }
598         }
599
600         bio = opj_bio_create();
601         if (!bio) {
602                 /* FIXME event manager error callback */
603                 return OPJ_FALSE;
604         }
605         opj_bio_init_enc(bio, c, length);
606         opj_bio_write(bio, 1, 1);           /* Empty header bit */
607
608         /* Writing Packet header */
609         band = res->bands;
610         for (bandno = 0; bandno < res->numbands; ++bandno)      {
611                 opj_tcd_precinct_t *prc = &band->precincts[precno];
612
613                 l_nb_blocks = prc->cw * prc->ch;
614                 cblk = prc->cblks.enc;
615
616                 for (cblkno = 0; cblkno < l_nb_blocks; ++cblkno) {
617                         opj_tcd_layer_t *layer = &cblk->layers[layno];
618
619                         if (!cblk->numpasses && layer->numpasses) {
620                                 opj_tgt_setvalue(prc->incltree, cblkno, (OPJ_INT32)layno);
621                         }
622
623                         ++cblk;
624                 }
625
626                 cblk = prc->cblks.enc;
627                 for (cblkno = 0; cblkno < l_nb_blocks; cblkno++) {
628                         opj_tcd_layer_t *layer = &cblk->layers[layno];
629                         OPJ_UINT32 increment = 0;
630                         OPJ_UINT32 nump = 0;
631                         OPJ_UINT32 len = 0, passno;
632                         OPJ_UINT32 l_nb_passes;
633
634                         /* cblk inclusion bits */
635                         if (!cblk->numpasses) {
636                                 opj_tgt_encode(bio, prc->incltree, cblkno, (OPJ_INT32)(layno + 1));
637                         } else {
638                                 opj_bio_write(bio, layer->numpasses != 0, 1);
639                         }
640
641                         /* if cblk not included, go to the next cblk  */
642                         if (!layer->numpasses) {
643                                 ++cblk;
644                                 continue;
645                         }
646
647                         /* if first instance of cblk --> zero bit-planes information */
648                         if (!cblk->numpasses) {
649                                 cblk->numlenbits = 3;
650                                 opj_tgt_encode(bio, prc->imsbtree, cblkno, 999);
651                         }
652
653                         /* number of coding passes included */
654                         opj_t2_putnumpasses(bio, layer->numpasses);
655                         l_nb_passes = cblk->numpasses + layer->numpasses;
656                         pass = cblk->passes +  cblk->numpasses;
657
658                         /* computation of the increase of the length indicator and insertion in the header     */
659                         for (passno = cblk->numpasses; passno < l_nb_passes; ++passno) {
660                                 ++nump;
661                                 len += pass->len;
662
663                                 if (pass->term || passno == (cblk->numpasses + layer->numpasses) - 1) {
664                                   increment = (OPJ_UINT32)opj_int_max((OPJ_INT32)increment, opj_int_floorlog2((OPJ_INT32)len) + 1
665                                     - ((OPJ_INT32)cblk->numlenbits + opj_int_floorlog2((OPJ_INT32)nump)));
666                                         len = 0;
667                                         nump = 0;
668                                 }
669
670                                 ++pass;
671                         }
672                         opj_t2_putcommacode(bio, (OPJ_INT32)increment);
673
674                         /* computation of the new Length indicator */
675                         cblk->numlenbits += increment;
676
677                         pass = cblk->passes +  cblk->numpasses;
678                         /* insertion of the codeword segment length */
679                         for (passno = cblk->numpasses; passno < l_nb_passes; ++passno) {
680                                 nump++;
681                                 len += pass->len;
682
683                                 if (pass->term || passno == (cblk->numpasses + layer->numpasses) - 1) {
684                                         opj_bio_write(bio, (OPJ_UINT32)len, cblk->numlenbits + (OPJ_UINT32)opj_int_floorlog2((OPJ_INT32)nump));
685                                         len = 0;
686                                         nump = 0;
687                                 }
688                                 ++pass;
689                         }
690
691                         ++cblk;
692                 }
693
694                 ++band;
695         }
696
697         if (!opj_bio_flush(bio)) {
698                 opj_bio_destroy(bio);
699                 return OPJ_FALSE;               /* modified to eliminate longjmp !! */
700         }
701
702         l_nb_bytes = (OPJ_UINT32)opj_bio_numbytes(bio);
703         c += l_nb_bytes;
704         length -= l_nb_bytes;
705
706         opj_bio_destroy(bio);
707
708         /* <EPH 0xff92> */
709         if (tcp->csty & J2K_CP_CSTY_EPH) {
710                 c[0] = 255;
711                 c[1] = 146;
712                 c += 2;
713                 length -= 2;
714         }
715         /* </EPH> */
716
717         /* << INDEX */
718         /* End of packet header position. Currently only represents the distance to start of packet
719            Will be updated later by incrementing with packet start value*/
720         if(cstr_info && cstr_info->index_write) {
721                 opj_packet_info_t *info_PK = &cstr_info->tile[tileno].packet[cstr_info->packno];
722                 info_PK->end_ph_pos = (OPJ_INT32)(c - dest);
723         }
724         /* INDEX >> */
725
726         /* Writing the packet body */
727         band = res->bands;
728         for (bandno = 0; bandno < res->numbands; bandno++) {
729                 opj_tcd_precinct_t *prc = &band->precincts[precno];
730
731                 l_nb_blocks = prc->cw * prc->ch;
732                 cblk = prc->cblks.enc;
733
734                 for (cblkno = 0; cblkno < l_nb_blocks; ++cblkno) {
735                         opj_tcd_layer_t *layer = &cblk->layers[layno];
736
737                         if (!layer->numpasses) {
738                                 ++cblk;
739                                 continue;
740                         }
741
742                         if (layer->len > length) {
743                                 return OPJ_FALSE;
744                         }
745
746                         memcpy(c, layer->data, layer->len);
747                         cblk->numpasses += layer->numpasses;
748                         c += layer->len;
749                         length -= layer->len;
750
751                         /* << INDEX */
752                         if(cstr_info && cstr_info->index_write) {
753                                 opj_packet_info_t *info_PK = &cstr_info->tile[tileno].packet[cstr_info->packno];
754                                 info_PK->disto += layer->disto;
755                                 if (cstr_info->D_max < info_PK->disto) {
756                                         cstr_info->D_max = info_PK->disto;
757                                 }
758                         }
759
760                         ++cblk;
761                         /* INDEX >> */
762                 }
763                 ++band;
764         }
765
766         assert( c >= dest );
767         * p_data_written += (OPJ_UINT32)(c - dest);
768
769         return OPJ_TRUE;
770 }
771
772 static OPJ_BOOL opj_t2_skip_packet( opj_t2_t* p_t2,
773                                     opj_tcd_tile_t *p_tile,
774                                     opj_tcp_t *p_tcp,
775                                     opj_pi_iterator_t *p_pi,
776                                     OPJ_BYTE *p_src,
777                                     OPJ_UINT32 * p_data_read,
778                                     OPJ_UINT32 p_max_length,
779                                     opj_packet_info_t *p_pack_info)
780 {
781         OPJ_BOOL l_read_data;
782         OPJ_UINT32 l_nb_bytes_read = 0;
783         OPJ_UINT32 l_nb_total_bytes_read = 0;
784
785         *p_data_read = 0;
786
787         if (! opj_t2_read_packet_header(p_t2,p_tile,p_tcp,p_pi,&l_read_data,p_src,&l_nb_bytes_read,p_max_length,p_pack_info)) {
788                 return OPJ_FALSE;
789         }
790
791         p_src += l_nb_bytes_read;
792         l_nb_total_bytes_read += l_nb_bytes_read;
793         p_max_length -= l_nb_bytes_read;
794
795         /* we should read data for the packet */
796         if (l_read_data) {
797                 l_nb_bytes_read = 0;
798
799                 if (! opj_t2_skip_packet_data(p_t2,p_tile,p_pi,&l_nb_bytes_read,p_max_length,p_pack_info)) {
800                         return OPJ_FALSE;
801                 }
802
803                 l_nb_total_bytes_read += l_nb_bytes_read;
804         }
805         *p_data_read = l_nb_total_bytes_read;
806
807         return OPJ_TRUE;
808 }
809
810
811 OPJ_BOOL opj_t2_read_packet_header( opj_t2_t* p_t2,
812                                     opj_tcd_tile_t *p_tile,
813                                     opj_tcp_t *p_tcp,
814                                     opj_pi_iterator_t *p_pi,
815                                     OPJ_BOOL * p_is_data_present,
816                                     OPJ_BYTE *p_src_data,
817                                     OPJ_UINT32 * p_data_read,
818                                     OPJ_UINT32 p_max_length,
819                                     opj_packet_info_t *p_pack_info)
820
821 {
822         /* loop */
823         OPJ_UINT32 bandno, cblkno;
824         OPJ_UINT32 l_nb_code_blocks;
825         OPJ_UINT32 l_remaining_length;
826         OPJ_UINT32 l_header_length;
827         OPJ_UINT32 * l_modified_length_ptr = 00;
828         OPJ_BYTE *l_current_data = p_src_data;
829         opj_cp_t *l_cp = p_t2->cp;
830         opj_bio_t *l_bio = 00;  /* BIO component */
831         opj_tcd_band_t *l_band = 00;
832         opj_tcd_cblk_dec_t* l_cblk = 00;
833         opj_tcd_resolution_t* l_res = &p_tile->comps[p_pi->compno].resolutions[p_pi->resno];
834
835         OPJ_BYTE *l_header_data = 00;
836         OPJ_BYTE **l_header_data_start = 00;
837
838         OPJ_UINT32 l_present;
839
840         if (p_pi->layno == 0) {
841                 l_band = l_res->bands;
842
843                 /* reset tagtrees */
844                 for (bandno = 0; bandno < l_res->numbands; ++bandno) {
845                         opj_tcd_precinct_t *l_prc = &l_band->precincts[p_pi->precno];
846
847                         if ( ! ((l_band->x1-l_band->x0 == 0)||(l_band->y1-l_band->y0 == 0)) ) {
848                                 opj_tgt_reset(l_prc->incltree);
849                                 opj_tgt_reset(l_prc->imsbtree);
850                                 l_cblk = l_prc->cblks.dec;
851
852                                 l_nb_code_blocks = l_prc->cw * l_prc->ch;
853                                 for (cblkno = 0; cblkno < l_nb_code_blocks; ++cblkno) {
854                                         l_cblk->numsegs = 0;
855                                         l_cblk->real_num_segs = 0;
856                                         ++l_cblk;
857                                 }
858                         }
859
860                         ++l_band;
861                 }
862         }
863
864         /* SOP markers */
865
866         if (p_tcp->csty & J2K_CP_CSTY_SOP) {
867                 if (p_max_length < 6) {
868                         /* TODO opj_event_msg(p_t2->cinfo->event_mgr, EVT_WARNING, "Not enough space for expected SOP marker\n"); */
869                         fprintf(stderr, "Not enough space for expected SOP marker\n");
870                 } else if ((*l_current_data) != 0xff || (*(l_current_data + 1) != 0x91)) {
871                         /* TODO opj_event_msg(p_t2->cinfo->event_mgr, EVT_WARNING, "Expected SOP marker\n"); */
872                         fprintf(stderr, "Warning: expected SOP marker\n");
873                 } else {
874                         l_current_data += 6;
875                 }
876
877                 /** TODO : check the Nsop value */
878         }
879
880         /*
881         When the marker PPT/PPM is used the packet header are store in PPT/PPM marker
882         This part deal with this caracteristic
883         step 1: Read packet header in the saved structure
884         step 2: Return to codestream for decoding
885         */
886
887         l_bio = opj_bio_create();
888         if (! l_bio) {
889                 return OPJ_FALSE;
890         }
891
892         if (l_cp->ppm == 1) { /* PPM */
893                 l_header_data_start = &l_cp->ppm_data;
894                 l_header_data = *l_header_data_start;
895                 l_modified_length_ptr = &(l_cp->ppm_len);
896
897         }
898         else if (p_tcp->ppt == 1) { /* PPT */
899                 l_header_data_start = &(p_tcp->ppt_data);
900                 l_header_data = *l_header_data_start;
901                 l_modified_length_ptr = &(p_tcp->ppt_len);
902         }
903         else {  /* Normal Case */
904                 l_header_data_start = &(l_current_data);
905                 l_header_data = *l_header_data_start;
906                 l_remaining_length = (OPJ_UINT32)(p_src_data+p_max_length-l_header_data);
907                 l_modified_length_ptr = &(l_remaining_length);
908         }
909
910         opj_bio_init_dec(l_bio, l_header_data,*l_modified_length_ptr);
911
912         l_present = opj_bio_read(l_bio, 1);
913         JAS_FPRINTF(stderr, "present=%d \n", l_present );
914         if (!l_present) {
915             /* TODO MSD: no test to control the output of this function*/
916                 opj_bio_inalign(l_bio);
917                 l_header_data += opj_bio_numbytes(l_bio);
918                 opj_bio_destroy(l_bio);
919
920                 /* EPH markers */
921                 if (p_tcp->csty & J2K_CP_CSTY_EPH) {
922                         if ((*l_modified_length_ptr - (OPJ_UINT32)(l_header_data - *l_header_data_start)) < 2U) {
923                                 fprintf(stderr, "Not enough space for expected EPH marker\n");
924                         } else if ((*l_header_data) != 0xff || (*(l_header_data + 1) != 0x92)) {
925                                 fprintf(stderr, "Error : expected EPH marker\n");
926                         } else {
927                                 l_header_data += 2;
928                         }
929                 }
930
931                 l_header_length = (OPJ_UINT32)(l_header_data - *l_header_data_start);
932                 *l_modified_length_ptr -= l_header_length;
933                 *l_header_data_start += l_header_length;
934
935                 /* << INDEX */
936                 /* End of packet header position. Currently only represents the distance to start of packet
937                    Will be updated later by incrementing with packet start value */
938                 if (p_pack_info) {
939                         p_pack_info->end_ph_pos = (OPJ_INT32)(l_current_data - p_src_data);
940                 }
941                 /* INDEX >> */
942
943                 * p_is_data_present = OPJ_FALSE;
944                 *p_data_read = (OPJ_UINT32)(l_current_data - p_src_data);
945                 return OPJ_TRUE;
946         }
947
948         l_band = l_res->bands;
949         for (bandno = 0; bandno < l_res->numbands; ++bandno) {
950                 opj_tcd_precinct_t *l_prc = &(l_band->precincts[p_pi->precno]);
951
952                 if ((l_band->x1-l_band->x0 == 0)||(l_band->y1-l_band->y0 == 0)) {
953                         ++l_band;
954                         continue;
955                 }
956
957                 l_nb_code_blocks = l_prc->cw * l_prc->ch;
958                 l_cblk = l_prc->cblks.dec;
959                 for (cblkno = 0; cblkno < l_nb_code_blocks; cblkno++) {
960                         OPJ_UINT32 l_included,l_increment, l_segno;
961                         OPJ_INT32 n;
962
963                         /* if cblk not yet included before --> inclusion tagtree */
964                         if (!l_cblk->numsegs) {
965                                 l_included = opj_tgt_decode(l_bio, l_prc->incltree, cblkno, (OPJ_INT32)(p_pi->layno + 1));
966                                 /* else one bit */
967                         }
968                         else {
969                                 l_included = opj_bio_read(l_bio, 1);
970                         }
971
972                         /* if cblk not included */
973                         if (!l_included) {
974                                 l_cblk->numnewpasses = 0;
975                                 ++l_cblk;
976         JAS_FPRINTF(stderr, "included=%d \n", l_included);
977                                 continue;
978                         }
979
980                         /* if cblk not yet included --> zero-bitplane tagtree */
981                         if (!l_cblk->numsegs) {
982                                 OPJ_UINT32 i = 0;
983
984                                 while (!opj_tgt_decode(l_bio, l_prc->imsbtree, cblkno, (OPJ_INT32)i)) {
985                                         ++i;
986                                 }
987
988                                 l_cblk->numbps = (OPJ_UINT32)l_band->numbps + 1 - i;
989                                 l_cblk->numlenbits = 3;
990                         }
991
992                         /* number of coding passes */
993                         l_cblk->numnewpasses = opj_t2_getnumpasses(l_bio);
994                         l_increment = opj_t2_getcommacode(l_bio);
995
996                         /* length indicator increment */
997                         l_cblk->numlenbits += l_increment;
998                         l_segno = 0;
999
1000                         if (!l_cblk->numsegs) {
1001                                 if (! opj_t2_init_seg(l_cblk, l_segno, p_tcp->tccps[p_pi->compno].cblksty, 1)) {
1002                                         opj_bio_destroy(l_bio);
1003                                         return OPJ_FALSE;
1004                                 }
1005                         }
1006                         else {
1007                                 l_segno = l_cblk->numsegs - 1;
1008                                 if (l_cblk->segs[l_segno].numpasses == l_cblk->segs[l_segno].maxpasses) {
1009                                         ++l_segno;
1010                                         if (! opj_t2_init_seg(l_cblk, l_segno, p_tcp->tccps[p_pi->compno].cblksty, 0)) {
1011                                                 opj_bio_destroy(l_bio);
1012                                                 return OPJ_FALSE;
1013                                         }
1014                                 }
1015                         }
1016                         n = (OPJ_INT32)l_cblk->numnewpasses;
1017
1018                         do {
1019                                 l_cblk->segs[l_segno].numnewpasses = (OPJ_UINT32)opj_int_min((OPJ_INT32)(l_cblk->segs[l_segno].maxpasses - l_cblk->segs[l_segno].numpasses), n);
1020                                 l_cblk->segs[l_segno].newlen = opj_bio_read(l_bio, l_cblk->numlenbits + opj_uint_floorlog2(l_cblk->segs[l_segno].numnewpasses));
1021                                         JAS_FPRINTF(stderr, "included=%d numnewpasses=%d increment=%d len=%d \n", l_included, l_cblk->segs[l_segno].numnewpasses, l_increment, l_cblk->segs[l_segno].newlen );
1022
1023                                 n -= (OPJ_INT32)l_cblk->segs[l_segno].numnewpasses;
1024                                 if (n > 0) {
1025                                         ++l_segno;
1026
1027                                         if (! opj_t2_init_seg(l_cblk, l_segno, p_tcp->tccps[p_pi->compno].cblksty, 0)) {
1028                                                 opj_bio_destroy(l_bio);
1029                                                 return OPJ_FALSE;
1030                                         }
1031                                 }
1032                         } while (n > 0);
1033
1034                         ++l_cblk;
1035                 }
1036
1037                 ++l_band;
1038         }
1039
1040         if (!opj_bio_inalign(l_bio)) {
1041                 opj_bio_destroy(l_bio);
1042                 return OPJ_FALSE;
1043         }
1044
1045         l_header_data += opj_bio_numbytes(l_bio);
1046         opj_bio_destroy(l_bio);
1047
1048         /* EPH markers */
1049         if (p_tcp->csty & J2K_CP_CSTY_EPH) {
1050                 if ((*l_modified_length_ptr - (OPJ_UINT32)(l_header_data - *l_header_data_start)) < 2U) {
1051                         fprintf(stderr, "Not enough space for expected EPH marker\n");
1052                 } else if ((*l_header_data) != 0xff || (*(l_header_data + 1) != 0x92)) {
1053                         /* TODO opj_event_msg(t2->cinfo->event_mgr, EVT_ERROR, "Expected EPH marker\n"); */
1054                         fprintf(stderr, "Error : expected EPH marker\n");
1055                 } else {
1056                         l_header_data += 2;
1057                 }
1058         }
1059
1060         l_header_length = (OPJ_UINT32)(l_header_data - *l_header_data_start);
1061         JAS_FPRINTF( stderr, "hdrlen=%d \n", l_header_length );
1062         JAS_FPRINTF( stderr, "packet body\n");
1063         *l_modified_length_ptr -= l_header_length;
1064         *l_header_data_start += l_header_length;
1065
1066         /* << INDEX */
1067         /* End of packet header position. Currently only represents the distance to start of packet
1068          Will be updated later by incrementing with packet start value */
1069         if (p_pack_info) {
1070                 p_pack_info->end_ph_pos = (OPJ_INT32)(l_current_data - p_src_data);
1071         }
1072         /* INDEX >> */
1073
1074         *p_is_data_present = OPJ_TRUE;
1075         *p_data_read = (OPJ_UINT32)(l_current_data - p_src_data);
1076
1077         return OPJ_TRUE;
1078 }
1079
1080 OPJ_BOOL opj_t2_read_packet_data(   opj_t2_t* p_t2,
1081                                     opj_tcd_tile_t *p_tile,
1082                                     opj_pi_iterator_t *p_pi,
1083                                     OPJ_BYTE *p_src_data,
1084                                     OPJ_UINT32 * p_data_read,
1085                                     OPJ_UINT32 p_max_length,
1086                                     opj_packet_info_t *pack_info)
1087 {
1088         OPJ_UINT32 bandno, cblkno;
1089         OPJ_UINT32 l_nb_code_blocks;
1090         OPJ_BYTE *l_current_data = p_src_data;
1091         opj_tcd_band_t *l_band = 00;
1092         opj_tcd_cblk_dec_t* l_cblk = 00;
1093         opj_tcd_resolution_t* l_res = &p_tile->comps[p_pi->compno].resolutions[p_pi->resno];
1094
1095         OPJ_ARG_NOT_USED(p_t2);
1096         OPJ_ARG_NOT_USED(pack_info);
1097
1098         l_band = l_res->bands;
1099         for (bandno = 0; bandno < l_res->numbands; ++bandno) {
1100                 opj_tcd_precinct_t *l_prc = &l_band->precincts[p_pi->precno];
1101
1102                 if ((l_band->x1-l_band->x0 == 0)||(l_band->y1-l_band->y0 == 0)) {
1103                         ++l_band;
1104                         continue;
1105                 }
1106
1107                 l_nb_code_blocks = l_prc->cw * l_prc->ch;
1108                 l_cblk = l_prc->cblks.dec;
1109
1110                 for (cblkno = 0; cblkno < l_nb_code_blocks; ++cblkno) {
1111                         opj_tcd_seg_t *l_seg = 00;
1112
1113                         if (!l_cblk->numnewpasses) {
1114                                 /* nothing to do */
1115                                 ++l_cblk;
1116                                 continue;
1117                         }
1118
1119                         if (!l_cblk->numsegs) {
1120                                 l_seg = l_cblk->segs;
1121                                 ++l_cblk->numsegs;
1122                                 l_cblk->data_current_size = 0;
1123                         }
1124                         else {
1125                                 l_seg = &l_cblk->segs[l_cblk->numsegs - 1];
1126
1127                                 if (l_seg->numpasses == l_seg->maxpasses) {
1128                                         ++l_seg;
1129                                         ++l_cblk->numsegs;
1130                                 }
1131                         }
1132
1133                         do {
1134                                 /* Check possible overflow (on l_current_data only, assumes input args already checked) then size */
1135                                 if (((OPJ_SIZE_T)(l_current_data + l_seg->newlen) < (OPJ_SIZE_T)l_current_data) || (l_current_data + l_seg->newlen > p_src_data + p_max_length)) {
1136                                         fprintf(stderr, "read: segment too long (%d) with max (%d) for codeblock %d (p=%d, b=%d, r=%d, c=%d)\n",
1137                                                 l_seg->newlen, p_max_length, cblkno, p_pi->precno, bandno, p_pi->resno, p_pi->compno);
1138                                         return OPJ_FALSE;
1139                                 }
1140
1141 #ifdef USE_JPWL
1142                         /* we need here a j2k handle to verify if making a check to
1143                         the validity of cblocks parameters is selected from user (-W) */
1144
1145                                 /* let's check that we are not exceeding */
1146                                 if ((l_cblk->len + l_seg->newlen) > 8192) {
1147                                         opj_event_msg(p_t2->cinfo, EVT_WARNING,
1148                                                 "JPWL: segment too long (%d) for codeblock %d (p=%d, b=%d, r=%d, c=%d)\n",
1149                                                 l_seg->newlen, cblkno, p_pi->precno, bandno, p_pi->resno, p_pi->compno);
1150                                         if (!JPWL_ASSUME) {
1151                                                 opj_event_msg(p_t2->cinfo, EVT_ERROR, "JPWL: giving up\n");
1152                                                 return OPJ_FALSE;
1153                                         }
1154                                         l_seg->newlen = 8192 - l_cblk->len;
1155                                         opj_event_msg(p_t2->cinfo, EVT_WARNING, "      - truncating segment to %d\n", l_seg->newlen);
1156                                         break;
1157                                 };
1158
1159 #endif /* USE_JPWL */
1160                                 /* Check possible overflow on size */
1161                                 if ((l_cblk->data_current_size + l_seg->newlen) < l_cblk->data_current_size) {
1162                                         fprintf(stderr, "read: segment too long (%d) with current size (%d > %d) for codeblock %d (p=%d, b=%d, r=%d, c=%d)\n",
1163                                                 l_seg->newlen, l_cblk->data_current_size, 0xFFFFFFFF - l_seg->newlen, cblkno, p_pi->precno, bandno, p_pi->resno, p_pi->compno);
1164                                         return OPJ_FALSE;
1165                                 }
1166                                 /* Check if the cblk->data have allocated enough memory */
1167                                 if ((l_cblk->data_current_size + l_seg->newlen) > l_cblk->data_max_size) {
1168                                     OPJ_BYTE* new_cblk_data = (OPJ_BYTE*) opj_realloc(l_cblk->data, l_cblk->data_current_size + l_seg->newlen);
1169                                     if(! new_cblk_data) {
1170                                         opj_free(l_cblk->data);
1171                                         l_cblk->data = NULL;
1172                                         l_cblk->data_max_size = 0;
1173                                         /* opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to realloc code block cata!\n"); */
1174                                         return OPJ_FALSE;
1175                                     }
1176                                     l_cblk->data_max_size = l_cblk->data_current_size + l_seg->newlen;
1177                                     l_cblk->data = new_cblk_data;
1178                                 }
1179                                
1180                                 memcpy(l_cblk->data + l_cblk->data_current_size, l_current_data, l_seg->newlen);
1181
1182                                 if (l_seg->numpasses == 0) {
1183                                         l_seg->data = &l_cblk->data;
1184                                         l_seg->dataindex = l_cblk->data_current_size;
1185                                 }
1186
1187                                 l_current_data += l_seg->newlen;
1188                                 l_seg->numpasses += l_seg->numnewpasses;
1189                                 l_cblk->numnewpasses -= l_seg->numnewpasses;
1190
1191                                 l_seg->real_num_passes = l_seg->numpasses;
1192                                 l_cblk->data_current_size += l_seg->newlen;
1193                                 l_seg->len += l_seg->newlen;
1194
1195                                 if (l_cblk->numnewpasses > 0) {
1196                                         ++l_seg;
1197                                         ++l_cblk->numsegs;
1198                                 }
1199                         } while (l_cblk->numnewpasses > 0);
1200
1201                         l_cblk->real_num_segs = l_cblk->numsegs;
1202                         ++l_cblk;
1203                 } /* next code_block */
1204
1205                 ++l_band;
1206         }
1207
1208         *(p_data_read) = (OPJ_UINT32)(l_current_data - p_src_data);
1209
1210
1211         return OPJ_TRUE;
1212 }
1213
1214 OPJ_BOOL opj_t2_skip_packet_data(   opj_t2_t* p_t2,
1215                                     opj_tcd_tile_t *p_tile,
1216                                     opj_pi_iterator_t *p_pi,
1217                                     OPJ_UINT32 * p_data_read,
1218                                     OPJ_UINT32 p_max_length,
1219                                     opj_packet_info_t *pack_info)
1220 {
1221         OPJ_UINT32 bandno, cblkno;
1222         OPJ_UINT32 l_nb_code_blocks;
1223         opj_tcd_band_t *l_band = 00;
1224         opj_tcd_cblk_dec_t* l_cblk = 00;
1225         opj_tcd_resolution_t* l_res = &p_tile->comps[p_pi->compno].resolutions[p_pi->resno];
1226
1227         OPJ_ARG_NOT_USED(p_t2);
1228         OPJ_ARG_NOT_USED(pack_info);
1229
1230         *p_data_read = 0;
1231         l_band = l_res->bands;
1232
1233         for (bandno = 0; bandno < l_res->numbands; ++bandno) {
1234                 opj_tcd_precinct_t *l_prc = &l_band->precincts[p_pi->precno];
1235
1236                 if ((l_band->x1-l_band->x0 == 0)||(l_band->y1-l_band->y0 == 0)) {
1237                         ++l_band;
1238                         continue;
1239                 }
1240
1241                 l_nb_code_blocks = l_prc->cw * l_prc->ch;
1242                 l_cblk = l_prc->cblks.dec;
1243
1244                 for (cblkno = 0; cblkno < l_nb_code_blocks; ++cblkno) {
1245                         opj_tcd_seg_t *l_seg = 00;
1246
1247                         if (!l_cblk->numnewpasses) {
1248                                 /* nothing to do */
1249                                 ++l_cblk;
1250                                 continue;
1251                         }
1252
1253                         if (!l_cblk->numsegs) {
1254                                 l_seg = l_cblk->segs;
1255                                 ++l_cblk->numsegs;
1256                                 l_cblk->data_current_size = 0;
1257                         }
1258                         else {
1259                                 l_seg = &l_cblk->segs[l_cblk->numsegs - 1];
1260
1261                                 if (l_seg->numpasses == l_seg->maxpasses) {
1262                                         ++l_seg;
1263                                         ++l_cblk->numsegs;
1264                                 }
1265                         }
1266
1267                         do {
1268                                 if (* p_data_read + l_seg->newlen > p_max_length) {
1269                                         fprintf(stderr, "skip: segment too long (%d) with max (%d) for codeblock %d (p=%d, b=%d, r=%d, c=%d)\n",
1270                                                 l_seg->newlen, p_max_length, cblkno, p_pi->precno, bandno, p_pi->resno, p_pi->compno);
1271                                         return OPJ_FALSE;
1272                                 }
1273
1274 #ifdef USE_JPWL
1275                         /* we need here a j2k handle to verify if making a check to
1276                         the validity of cblocks parameters is selected from user (-W) */
1277
1278                                 /* let's check that we are not exceeding */
1279                                 if ((l_cblk->len + l_seg->newlen) > 8192) {
1280                                         opj_event_msg(p_t2->cinfo, EVT_WARNING,
1281                                                 "JPWL: segment too long (%d) for codeblock %d (p=%d, b=%d, r=%d, c=%d)\n",
1282                                                 l_seg->newlen, cblkno, p_pi->precno, bandno, p_pi->resno, p_pi->compno);
1283                                         if (!JPWL_ASSUME) {
1284                                                 opj_event_msg(p_t2->cinfo, EVT_ERROR, "JPWL: giving up\n");
1285                                                 return -999;
1286                                         }
1287                                         l_seg->newlen = 8192 - l_cblk->len;
1288                                         opj_event_msg(p_t2->cinfo, EVT_WARNING, "      - truncating segment to %d\n", l_seg->newlen);
1289                                         break;
1290                                 };
1291
1292 #endif /* USE_JPWL */
1293                                         JAS_FPRINTF(stderr, "p_data_read (%d) newlen (%d) \n", *p_data_read, l_seg->newlen );
1294                                 *(p_data_read) += l_seg->newlen;
1295
1296                                 l_seg->numpasses += l_seg->numnewpasses;
1297                                 l_cblk->numnewpasses -= l_seg->numnewpasses;
1298                                 if (l_cblk->numnewpasses > 0)
1299                                 {
1300                                         ++l_seg;
1301                                         ++l_cblk->numsegs;
1302                                 }
1303                         } while (l_cblk->numnewpasses > 0);
1304
1305                         ++l_cblk;
1306                 }
1307
1308                 ++l_band;
1309         }
1310
1311         return OPJ_TRUE;
1312 }
1313
1314
1315 OPJ_BOOL opj_t2_init_seg(   opj_tcd_cblk_dec_t* cblk,
1316                             OPJ_UINT32 index, 
1317                             OPJ_UINT32 cblksty, 
1318                             OPJ_UINT32 first)
1319 {
1320         opj_tcd_seg_t* seg = 00;
1321         OPJ_UINT32 l_nb_segs = index + 1;
1322
1323         if (l_nb_segs > cblk->m_current_max_segs) {
1324                 opj_tcd_seg_t* new_segs;
1325                 cblk->m_current_max_segs += OPJ_J2K_DEFAULT_NB_SEGS;
1326
1327                 new_segs = (opj_tcd_seg_t*) opj_realloc(cblk->segs, cblk->m_current_max_segs * sizeof(opj_tcd_seg_t));
1328                 if(! new_segs) {
1329                         opj_free(cblk->segs);
1330                         cblk->segs = NULL;
1331                         cblk->m_current_max_segs = 0;
1332                         /* opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to initialize segment %d\n", l_nb_segs); */
1333                         return OPJ_FALSE;
1334                 }
1335                 cblk->segs = new_segs;
1336         }
1337
1338         seg = &cblk->segs[index];
1339         memset(seg,0,sizeof(opj_tcd_seg_t));
1340
1341         if (cblksty & J2K_CCP_CBLKSTY_TERMALL) {
1342                 seg->maxpasses = 1;
1343         }
1344         else if (cblksty & J2K_CCP_CBLKSTY_LAZY) {
1345                 if (first) {
1346                         seg->maxpasses = 10;
1347                 } else {
1348                         seg->maxpasses = (((seg - 1)->maxpasses == 1) || ((seg - 1)->maxpasses == 10)) ? 2 : 1;
1349                 }
1350         } else {
1351                 seg->maxpasses = 109;
1352         }
1353
1354         return OPJ_TRUE;
1355 }