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