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) 2010-2011, Kaori Hagihara
15  * Copyright (c) 2008, 2011-2012, Centre National d'Etudes Spatiales (CNES), FR
16  * Copyright (c) 2012, CS Systemes d'Information, France
17  * All rights reserved.
18  *
19  * Redistribution and use in source and binary forms, with or without
20  * modification, are permitted provided that the following conditions
21  * are met:
22  * 1. Redistributions of source code must retain the above copyright
23  *    notice, this list of conditions and the following disclaimer.
24  * 2. Redistributions in binary form must reproduce the above copyright
25  *    notice, this list of conditions and the following disclaimer in the
26  *    documentation and/or other materials provided with the distribution.
27  *
28  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
29  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
30  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
31  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
32  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
33  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
34  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
35  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
36  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
37  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
38  * POSSIBILITY OF SUCH DAMAGE.
39  */
40 #include "opj_includes.h"
41 
42 /** @defgroup JP2 JP2 - JPEG-2000 file format reader/writer */
43 /*@{*/
44 
45 #define OPJ_BOX_SIZE	1024
46 
47 /** @name Local static functions */
48 /*@{*/
49 
50 /*static void jp2_write_url(opj_cio_t *cio, char *Idx_file);*/
51 
52 /**
53  * Reads a IHDR box - Image Header box
54  *
55  * @param	p_image_header_data			pointer to actual data (already read from file)
56  * @param	jp2							the jpeg2000 file codec.
57  * @param	p_image_header_size			the size of the image header
58  * @param	p_manager					the user event manager.
59  *
60  * @return	true if the image header is valid, false else.
61  */
62 static OPJ_BOOL opj_jp2_read_ihdr(  opj_jp2_t *jp2,
63                                     OPJ_BYTE *p_image_header_data,
64                                     OPJ_UINT32 p_image_header_size,
65                                     opj_event_mgr_t * p_manager );
66 
67 /**
68  * Writes the Image Header box - Image Header box.
69  *
70  * @param jp2					jpeg2000 file codec.
71  * @param p_nb_bytes_written	pointer to store the nb of bytes written by the function.
72  *
73  * @return	the data being copied.
74 */
75 static OPJ_BYTE * opj_jp2_write_ihdr(opj_jp2_t *jp2,
76                                      OPJ_UINT32 * p_nb_bytes_written );
77 
78 /**
79  * Writes the Bit per Component box.
80  *
81  * @param	jp2						jpeg2000 file codec.
82  * @param	p_nb_bytes_written		pointer to store the nb of bytes written by the function.
83  *
84  * @return	the data being copied.
85 */
86 static OPJ_BYTE * opj_jp2_write_bpcc(	opj_jp2_t *jp2,
87 								        OPJ_UINT32 * p_nb_bytes_written );
88 
89 /**
90  * Reads a Bit per Component box.
91  *
92  * @param	p_bpc_header_data			pointer to actual data (already read from file)
93  * @param	jp2							the jpeg2000 file codec.
94  * @param	p_bpc_header_size			the size of the bpc header
95  * @param	p_manager					the user event manager.
96  *
97  * @return	true if the bpc header is valid, fale else.
98  */
99 static OPJ_BOOL opj_jp2_read_bpcc(  opj_jp2_t *jp2,
100                                     OPJ_BYTE * p_bpc_header_data,
101                                     OPJ_UINT32 p_bpc_header_size,
102                                     opj_event_mgr_t * p_manager );
103 
104 static OPJ_BOOL opj_jp2_read_cdef(	opj_jp2_t * jp2,
105                                     OPJ_BYTE * p_cdef_header_data,
106 									OPJ_UINT32 p_cdef_header_size,
107 									opj_event_mgr_t * p_manager );
108 
109 static void opj_jp2_apply_cdef(opj_image_t *image, opj_jp2_color_t *color, opj_event_mgr_t *);
110 
111 /**
112  * Writes the Channel Definition box.
113  *
114  * @param jp2					jpeg2000 file codec.
115  * @param p_nb_bytes_written	pointer to store the nb of bytes written by the function.
116  *
117  * @return	the data being copied.
118  */
119 static OPJ_BYTE * opj_jp2_write_cdef(   opj_jp2_t *jp2,
120 																		 OPJ_UINT32 * p_nb_bytes_written );
121 
122 /**
123  * Writes the Colour Specification box.
124  *
125  * @param jp2					jpeg2000 file codec.
126  * @param p_nb_bytes_written	pointer to store the nb of bytes written by the function.
127  *
128  * @return	the data being copied.
129 */
130 static OPJ_BYTE * opj_jp2_write_colr(   opj_jp2_t *jp2,
131 									    OPJ_UINT32 * p_nb_bytes_written );
132 
133 /**
134  * Writes a FTYP box - File type box
135  *
136  * @param	cio			the stream to write data to.
137  * @param	jp2			the jpeg2000 file codec.
138  * @param	p_manager	the user event manager.
139  *
140  * @return	true if writing was successful.
141  */
142 static OPJ_BOOL opj_jp2_write_ftyp(	opj_jp2_t *jp2,
143 									opj_stream_private_t *cio,
144 									opj_event_mgr_t * p_manager );
145 
146 /**
147  * Reads a a FTYP box - File type box
148  *
149  * @param	p_header_data	the data contained in the FTYP box.
150  * @param	jp2				the jpeg2000 file codec.
151  * @param	p_header_size	the size of the data contained in the FTYP box.
152  * @param	p_manager		the user event manager.
153  *
154  * @return true if the FTYP box is valid.
155  */
156 static OPJ_BOOL opj_jp2_read_ftyp(	opj_jp2_t *jp2,
157 									OPJ_BYTE * p_header_data,
158 									OPJ_UINT32 p_header_size,
159 									opj_event_mgr_t * p_manager );
160 
161 static OPJ_BOOL opj_jp2_skip_jp2c(	opj_jp2_t *jp2,
162 						    opj_stream_private_t *cio,
163 						    opj_event_mgr_t * p_manager );
164 
165 /**
166  * Reads the Jpeg2000 file Header box - JP2 Header box (warning, this is a super box).
167  *
168  * @param	p_header_data	the data contained in the file header box.
169  * @param	jp2				the jpeg2000 file codec.
170  * @param	p_header_size	the size of the data contained in the file header box.
171  * @param	p_manager		the user event manager.
172  *
173  * @return true if the JP2 Header box was successfully recognized.
174 */
175 static OPJ_BOOL opj_jp2_read_jp2h(  opj_jp2_t *jp2,
176                                     OPJ_BYTE *p_header_data,
177                                     OPJ_UINT32 p_header_size,
178                                     opj_event_mgr_t * p_manager );
179 
180 /**
181  * Writes the Jpeg2000 file Header box - JP2 Header box (warning, this is a super box).
182  *
183  * @param  jp2      the jpeg2000 file codec.
184  * @param  stream      the stream to write data to.
185  * @param  p_manager  user event manager.
186  *
187  * @return true if writing was successful.
188  */
189 static OPJ_BOOL opj_jp2_write_jp2h(opj_jp2_t *jp2,
190 														opj_stream_private_t *stream,
191 														opj_event_mgr_t * p_manager );
192 
193 /**
194  * Writes the Jpeg2000 codestream Header box - JP2C Header box. This function must be called AFTER the coding has been done.
195  *
196  * @param	cio			the stream to write data to.
197  * @param	jp2			the jpeg2000 file codec.
198  * @param	p_manager	user event manager.
199  *
200  * @return true if writing was successful.
201 */
202 static OPJ_BOOL opj_jp2_write_jp2c(	opj_jp2_t *jp2,
203 								    opj_stream_private_t *cio,
204 								    opj_event_mgr_t * p_manager );
205 
206 #ifdef USE_JPIP
207 /**
208  * Write index Finder box
209  * @param cio     the stream to write to.
210  * @param	jp2			the jpeg2000 file codec.
211  * @param	p_manager	user event manager.
212 */
213 static OPJ_BOOL opj_jpip_write_iptr(	opj_jp2_t *jp2,
214 								    opj_stream_private_t *cio,
215 								    opj_event_mgr_t * p_manager );
216 
217 /**
218  * Write index Finder box
219  * @param cio     the stream to write to.
220  * @param	jp2			the jpeg2000 file codec.
221  * @param	p_manager	user event manager.
222  */
223 static OPJ_BOOL opj_jpip_write_cidx(opj_jp2_t *jp2,
224   opj_stream_private_t *cio,
225   opj_event_mgr_t * p_manager );
226 
227 /**
228  * Write file Index (superbox)
229  * @param cio     the stream to write to.
230  * @param	jp2			the jpeg2000 file codec.
231  * @param	p_manager	user event manager.
232  */
233 static OPJ_BOOL opj_jpip_write_fidx(opj_jp2_t *jp2,
234   opj_stream_private_t *cio,
235   opj_event_mgr_t * p_manager );
236 #endif /* USE_JPIP */
237 
238 /**
239  * Reads a jpeg2000 file signature box.
240  *
241  * @param	p_header_data	the data contained in the signature box.
242  * @param	jp2				the jpeg2000 file codec.
243  * @param	p_header_size	the size of the data contained in the signature box.
244  * @param	p_manager		the user event manager.
245  *
246  * @return true if the file signature box is valid.
247  */
248 static OPJ_BOOL opj_jp2_read_jp(opj_jp2_t *jp2,
249                                 OPJ_BYTE * p_header_data,
250                                 OPJ_UINT32 p_header_size,
251                                 opj_event_mgr_t * p_manager);
252 
253 /**
254  * Writes a jpeg2000 file signature box.
255  *
256  * @param cio the stream to write data to.
257  * @param	jp2			the jpeg2000 file codec.
258  * @param p_manager the user event manager.
259  *
260  * @return true if writing was successful.
261  */
262 static OPJ_BOOL opj_jp2_write_jp(	opj_jp2_t *jp2,
263 			    	        	    opj_stream_private_t *cio,
264 				            		opj_event_mgr_t * p_manager );
265 
266 /**
267 Apply collected palette data
268 @param color Collector for profile, cdef and pclr data
269 @param image
270 */
271 static void opj_jp2_apply_pclr(opj_image_t *image, opj_jp2_color_t *color);
272 
273 static void opj_jp2_free_pclr(opj_jp2_color_t *color);
274 
275 /**
276  * Collect palette data
277  *
278  * @param jp2 JP2 handle
279  * @param p_pclr_header_data    FIXME DOC
280  * @param p_pclr_header_size    FIXME DOC
281  * @param p_manager
282  *
283  * @return Returns true if successful, returns false otherwise
284 */
285 static OPJ_BOOL opj_jp2_read_pclr(	opj_jp2_t *jp2,
286                                     OPJ_BYTE * p_pclr_header_data,
287                                     OPJ_UINT32 p_pclr_header_size,
288                                     opj_event_mgr_t * p_manager );
289 
290 /**
291  * Collect component mapping data
292  *
293  * @param jp2                 JP2 handle
294  * @param p_cmap_header_data  FIXME DOC
295  * @param p_cmap_header_size  FIXME DOC
296  * @param p_manager           FIXME DOC
297  *
298  * @return Returns true if successful, returns false otherwise
299 */
300 
301 static OPJ_BOOL opj_jp2_read_cmap(	opj_jp2_t * jp2,
302                                     OPJ_BYTE * p_cmap_header_data,
303                                     OPJ_UINT32 p_cmap_header_size,
304                                     opj_event_mgr_t * p_manager );
305 
306 /**
307  * Reads the Color Specification box.
308  *
309  * @param	p_colr_header_data			pointer to actual data (already read from file)
310  * @param	jp2							the jpeg2000 file codec.
311  * @param	p_colr_header_size			the size of the color header
312  * @param	p_manager					the user event manager.
313  *
314  * @return	true if the bpc header is valid, fale else.
315 */
316 static OPJ_BOOL opj_jp2_read_colr(  opj_jp2_t *jp2,
317                                     OPJ_BYTE * p_colr_header_data,
318                                     OPJ_UINT32 p_colr_header_size,
319                                     opj_event_mgr_t * p_manager );
320 
321 /*@}*/
322 
323 /*@}*/
324 
325 /**
326  * Sets up the procedures to do on writing header after the codestream.
327  * Developpers wanting to extend the library can add their own writing procedures.
328  */
329 static OPJ_BOOL opj_jp2_setup_end_header_writing (opj_jp2_t *jp2, opj_event_mgr_t * p_manager);
330 
331 /**
332  * Sets up the procedures to do on reading header after the codestream.
333  * Developpers wanting to extend the library can add their own writing procedures.
334  */
335 static OPJ_BOOL opj_jp2_setup_end_header_reading (opj_jp2_t *jp2, opj_event_mgr_t * p_manager);
336 
337 /**
338  * Reads a jpeg2000 file header structure.
339  *
340  * @param jp2 the jpeg2000 file header structure.
341  * @param stream the stream to read data from.
342  * @param p_manager the user event manager.
343  *
344  * @return true if the box is valid.
345  */
346 static OPJ_BOOL opj_jp2_read_header_procedure(  opj_jp2_t *jp2,
347                                                 opj_stream_private_t *stream,
348                                                 opj_event_mgr_t * p_manager );
349 
350 /**
351  * Excutes the given procedures on the given codec.
352  *
353  * @param	p_procedure_list	the list of procedures to execute
354  * @param	jp2					the jpeg2000 file codec to execute the procedures on.
355  * @param	stream					the stream to execute the procedures on.
356  * @param	p_manager			the user manager.
357  *
358  * @return	true				if all the procedures were successfully executed.
359  */
360 static OPJ_BOOL opj_jp2_exec (  opj_jp2_t * jp2,
361                                 opj_procedure_list_t * p_procedure_list,
362                                 opj_stream_private_t *stream,
363                                 opj_event_mgr_t * p_manager );
364 
365 /**
366  * Reads a box header. The box is the way data is packed inside a jpeg2000 file structure.
367  *
368  * @param	cio						the input stream to read data from.
369  * @param	box						the box structure to fill.
370  * @param	p_number_bytes_read		pointer to an int that will store the number of bytes read from the stream (shoul usually be 2).
371  * @param	p_manager				user event manager.
372  *
373  * @return	true if the box is recognized, false otherwise
374 */
375 static OPJ_BOOL opj_jp2_read_boxhdr(opj_jp2_box_t *box,
376                                     OPJ_UINT32 * p_number_bytes_read,
377                                     opj_stream_private_t *cio,
378                                     opj_event_mgr_t * p_manager);
379 
380 /**
381  * Sets up the validation ,i.e. adds the procedures to lauch to make sure the codec parameters
382  * are valid. Developpers wanting to extend the library can add their own validation procedures.
383  */
384 static OPJ_BOOL opj_jp2_setup_encoding_validation (opj_jp2_t *jp2, opj_event_mgr_t * p_manager);
385 
386 /**
387  * Sets up the procedures to do on writing header. Developpers wanting to extend the library can add their own writing procedures.
388  */
389 static OPJ_BOOL opj_jp2_setup_header_writing (opj_jp2_t *jp2, opj_event_mgr_t * p_manager);
390 
391 static OPJ_BOOL opj_jp2_default_validation (	opj_jp2_t * jp2,
392                                         opj_stream_private_t *cio,
393                                         opj_event_mgr_t * p_manager );
394 
395 /**
396  * Finds the image execution function related to the given box id.
397  *
398  * @param	p_id	the id of the handler to fetch.
399  *
400  * @return	the given handler or NULL if it could not be found.
401  */
402 static const opj_jp2_header_handler_t * opj_jp2_img_find_handler (OPJ_UINT32 p_id);
403 
404 /**
405  * Finds the execution function related to the given box id.
406  *
407  * @param	p_id	the id of the handler to fetch.
408  *
409  * @return	the given handler or NULL if it could not be found.
410  */
411 static const opj_jp2_header_handler_t * opj_jp2_find_handler (OPJ_UINT32 p_id );
412 
413 static const opj_jp2_header_handler_t jp2_header [] =
414 {
415 	{JP2_JP,opj_jp2_read_jp},
416 	{JP2_FTYP,opj_jp2_read_ftyp},
417 	{JP2_JP2H,opj_jp2_read_jp2h}
418 };
419 
420 static const opj_jp2_header_handler_t jp2_img_header [] =
421 {
422 	{JP2_IHDR,opj_jp2_read_ihdr},
423 	{JP2_COLR,opj_jp2_read_colr},
424 	{JP2_BPCC,opj_jp2_read_bpcc},
425 	{JP2_PCLR,opj_jp2_read_pclr},
426 	{JP2_CMAP,opj_jp2_read_cmap},
427 	{JP2_CDEF,opj_jp2_read_cdef}
428 
429 };
430 
431 /**
432  * Reads a box header. The box is the way data is packed inside a jpeg2000 file structure. Data is read from a character string
433  *
434  * @param	box						the box structure to fill.
435  * @param	p_data					the character string to read data from.
436  * @param	p_number_bytes_read		pointer to an int that will store the number of bytes read from the stream (shoul usually be 2).
437  * @param	p_box_max_size			the maximum number of bytes in the box.
438  * @param	p_manager         FIXME DOC
439  *
440  * @return	true if the box is recognized, false otherwise
441 */
442 static OPJ_BOOL opj_jp2_read_boxhdr_char(   opj_jp2_box_t *box,
443                                             OPJ_BYTE * p_data,
444                                             OPJ_UINT32 * p_number_bytes_read,
445                                             OPJ_UINT32 p_box_max_size,
446                                             opj_event_mgr_t * p_manager );
447 
448 /**
449  * Sets up the validation ,i.e. adds the procedures to lauch to make sure the codec parameters
450  * are valid. Developpers wanting to extend the library can add their own validation procedures.
451  */
452 static OPJ_BOOL opj_jp2_setup_decoding_validation (opj_jp2_t *jp2, opj_event_mgr_t * p_manager);
453 
454 /**
455  * Sets up the procedures to do on reading header.
456  * Developpers wanting to extend the library can add their own writing procedures.
457  */
458 static OPJ_BOOL opj_jp2_setup_header_reading (opj_jp2_t *jp2, opj_event_mgr_t * p_manager);
459 
460 /* ----------------------------------------------------------------------- */
opj_jp2_read_boxhdr(opj_jp2_box_t * box,OPJ_UINT32 * p_number_bytes_read,opj_stream_private_t * cio,opj_event_mgr_t * p_manager)461 static OPJ_BOOL opj_jp2_read_boxhdr(opj_jp2_box_t *box,
462                               OPJ_UINT32 * p_number_bytes_read,
463                               opj_stream_private_t *cio,
464                               opj_event_mgr_t * p_manager )
465 {
466 	/* read header from file */
467 	OPJ_BYTE l_data_header [8];
468 
469 	/* preconditions */
470 	assert(cio != 00);
471 	assert(box != 00);
472 	assert(p_number_bytes_read != 00);
473 	assert(p_manager != 00);
474 
475 	*p_number_bytes_read = (OPJ_UINT32)opj_stream_read_data(cio,l_data_header,8,p_manager);
476 	if (*p_number_bytes_read != 8) {
477 		return OPJ_FALSE;
478 	}
479 
480 	/* process read data */
481 	opj_read_bytes(l_data_header,&(box->length), 4);
482 	opj_read_bytes(l_data_header+4,&(box->type), 4);
483 
484   if(box->length == 0)/* last box */
485     {
486     const OPJ_OFF_T bleft = opj_stream_get_number_byte_left(cio);
487     box->length = (OPJ_UINT32)bleft;
488     assert( (OPJ_OFF_T)box->length == bleft );
489     return OPJ_TRUE;
490     }
491 
492 	/* do we have a "special very large box ?" */
493 	/* read then the XLBox */
494 	if (box->length == 1) {
495 		OPJ_UINT32 l_xl_part_size;
496 
497 		OPJ_UINT32 l_nb_bytes_read = (OPJ_UINT32)opj_stream_read_data(cio,l_data_header,8,p_manager);
498 		if (l_nb_bytes_read != 8) {
499 			if (l_nb_bytes_read > 0) {
500 				*p_number_bytes_read += l_nb_bytes_read;
501 			}
502 
503 			return OPJ_FALSE;
504 		}
505 
506         *p_number_bytes_read = 16;
507 		opj_read_bytes(l_data_header,&l_xl_part_size, 4);
508 		if (l_xl_part_size != 0) {
509 			opj_event_msg(p_manager, EVT_ERROR, "Cannot handle box sizes higher than 2^32\n");
510 			return OPJ_FALSE;
511 		}
512 		opj_read_bytes(l_data_header+4,&(box->length), 4);
513 	}
514     return OPJ_TRUE;
515 }
516 
517 #if 0
518 static void jp2_write_url(opj_cio_t *cio, char *Idx_file) {
519 	OPJ_UINT32 i;
520 	opj_jp2_box_t box;
521 
522 	box.init_pos = cio_tell(cio);
523 	cio_skip(cio, 4);
524 	cio_write(cio, JP2_URL, 4);	/* DBTL */
525 	cio_write(cio, 0, 1);		/* VERS */
526 	cio_write(cio, 0, 3);		/* FLAG */
527 
528 	if(Idx_file) {
529 		for (i = 0; i < strlen(Idx_file); i++) {
530 			cio_write(cio, Idx_file[i], 1);
531 		}
532 	}
533 
534 	box.length = cio_tell(cio) - box.init_pos;
535 	cio_seek(cio, box.init_pos);
536 	cio_write(cio, box.length, 4);	/* L */
537 	cio_seek(cio, box.init_pos + box.length);
538 }
539 #endif
540 
opj_jp2_read_ihdr(opj_jp2_t * jp2,OPJ_BYTE * p_image_header_data,OPJ_UINT32 p_image_header_size,opj_event_mgr_t * p_manager)541 static OPJ_BOOL opj_jp2_read_ihdr( opj_jp2_t *jp2,
542                             OPJ_BYTE *p_image_header_data,
543                             OPJ_UINT32 p_image_header_size,
544                             opj_event_mgr_t * p_manager )
545 {
546 	/* preconditions */
547 	assert(p_image_header_data != 00);
548 	assert(jp2 != 00);
549 	assert(p_manager != 00);
550 
551 	if (p_image_header_size != 14) {
552 		opj_event_msg(p_manager, EVT_ERROR, "Bad image header box (bad size)\n");
553 		return OPJ_FALSE;
554 	}
555 
556 	opj_read_bytes(p_image_header_data,&(jp2->h),4);			/* HEIGHT */
557 	p_image_header_data += 4;
558 	opj_read_bytes(p_image_header_data,&(jp2->w),4);			/* WIDTH */
559 	p_image_header_data += 4;
560 	opj_read_bytes(p_image_header_data,&(jp2->numcomps),2);		/* NC */
561 	p_image_header_data += 2;
562 
563 	/* allocate memory for components */
564 	jp2->comps = (opj_jp2_comps_t*) opj_calloc(jp2->numcomps, sizeof(opj_jp2_comps_t));
565 	if (jp2->comps == 0) {
566 		opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to handle image header (ihdr)\n");
567 		return OPJ_FALSE;
568 	}
569 
570 	opj_read_bytes(p_image_header_data,&(jp2->bpc),1);			/* BPC */
571 	++ p_image_header_data;
572 
573 	opj_read_bytes(p_image_header_data,&(jp2->C),1);			/* C */
574 	++ p_image_header_data;
575 
576 	/* Should be equal to 7 cf. chapter about image header box of the norm */
577 	if (jp2->C != 7){
578 		opj_event_msg(p_manager, EVT_INFO, "JP2 IHDR box: compression type indicate that the file is not a conforming JP2 file (%d) \n", jp2->C);
579 	}
580 
581 	opj_read_bytes(p_image_header_data,&(jp2->UnkC),1);			/* UnkC */
582 	++ p_image_header_data;
583 	opj_read_bytes(p_image_header_data,&(jp2->IPR),1);			/* IPR */
584 	++ p_image_header_data;
585 
586 	return OPJ_TRUE;
587 }
588 
opj_jp2_write_ihdr(opj_jp2_t * jp2,OPJ_UINT32 * p_nb_bytes_written)589 static OPJ_BYTE * opj_jp2_write_ihdr(opj_jp2_t *jp2,
590                               OPJ_UINT32 * p_nb_bytes_written
591                               )
592 {
593 	OPJ_BYTE * l_ihdr_data,* l_current_ihdr_ptr;
594 
595 	/* preconditions */
596 	assert(jp2 != 00);
597 	assert(p_nb_bytes_written != 00);
598 
599 	/* default image header is 22 bytes wide */
600 	l_ihdr_data = (OPJ_BYTE *) opj_calloc(1,22);
601 	if (l_ihdr_data == 00) {
602 		return 00;
603 	}
604 
605 	l_current_ihdr_ptr = l_ihdr_data;
606 
607 	opj_write_bytes(l_current_ihdr_ptr,22,4);				/* write box size */
608 	l_current_ihdr_ptr+=4;
609 
610 	opj_write_bytes(l_current_ihdr_ptr,JP2_IHDR, 4);		/* IHDR */
611 	l_current_ihdr_ptr+=4;
612 
613 	opj_write_bytes(l_current_ihdr_ptr,jp2->h, 4);		/* HEIGHT */
614 	l_current_ihdr_ptr+=4;
615 
616 	opj_write_bytes(l_current_ihdr_ptr, jp2->w, 4);		/* WIDTH */
617 	l_current_ihdr_ptr+=4;
618 
619 	opj_write_bytes(l_current_ihdr_ptr, jp2->numcomps, 2);		/* NC */
620 	l_current_ihdr_ptr+=2;
621 
622 	opj_write_bytes(l_current_ihdr_ptr, jp2->bpc, 1);		/* BPC */
623 	++l_current_ihdr_ptr;
624 
625 	opj_write_bytes(l_current_ihdr_ptr, jp2->C, 1);		/* C : Always 7 */
626 	++l_current_ihdr_ptr;
627 
628 	opj_write_bytes(l_current_ihdr_ptr, jp2->UnkC, 1);		/* UnkC, colorspace unknown */
629 	++l_current_ihdr_ptr;
630 
631 	opj_write_bytes(l_current_ihdr_ptr, jp2->IPR, 1);		/* IPR, no intellectual property */
632 	++l_current_ihdr_ptr;
633 
634 	*p_nb_bytes_written = 22;
635 
636 	return l_ihdr_data;
637 }
638 
opj_jp2_write_bpcc(opj_jp2_t * jp2,OPJ_UINT32 * p_nb_bytes_written)639 static OPJ_BYTE * opj_jp2_write_bpcc(	opj_jp2_t *jp2,
640 						        OPJ_UINT32 * p_nb_bytes_written
641                                 )
642 {
643 	OPJ_UINT32 i;
644 	/* room for 8 bytes for box and 1 byte for each component */
645 	OPJ_UINT32 l_bpcc_size = 8 + jp2->numcomps;
646 	OPJ_BYTE * l_bpcc_data,* l_current_bpcc_ptr;
647 
648 	/* preconditions */
649 	assert(jp2 != 00);
650 	assert(p_nb_bytes_written != 00);
651 
652 	l_bpcc_data = (OPJ_BYTE *) opj_calloc(1,l_bpcc_size);
653 	if (l_bpcc_data == 00) {
654 		return 00;
655 	}
656 
657 	l_current_bpcc_ptr = l_bpcc_data;
658 
659 	opj_write_bytes(l_current_bpcc_ptr,l_bpcc_size,4);				/* write box size */
660 	l_current_bpcc_ptr += 4;
661 
662 	opj_write_bytes(l_current_bpcc_ptr,JP2_BPCC,4);					/* BPCC */
663 	l_current_bpcc_ptr += 4;
664 
665 	for (i = 0; i < jp2->numcomps; ++i)  {
666 		opj_write_bytes(l_current_bpcc_ptr, jp2->comps[i].bpcc, 1); /* write each component information */
667 		++l_current_bpcc_ptr;
668 	}
669 
670 	*p_nb_bytes_written = l_bpcc_size;
671 
672 	return l_bpcc_data;
673 }
674 
opj_jp2_read_bpcc(opj_jp2_t * jp2,OPJ_BYTE * p_bpc_header_data,OPJ_UINT32 p_bpc_header_size,opj_event_mgr_t * p_manager)675 static OPJ_BOOL opj_jp2_read_bpcc( opj_jp2_t *jp2,
676                             OPJ_BYTE * p_bpc_header_data,
677                             OPJ_UINT32 p_bpc_header_size,
678                             opj_event_mgr_t * p_manager
679                             )
680 {
681 	OPJ_UINT32 i;
682 
683 	/* preconditions */
684 	assert(p_bpc_header_data != 00);
685 	assert(jp2 != 00);
686 	assert(p_manager != 00);
687 
688 
689 	if (jp2->bpc != 255 ){
690 		opj_event_msg(p_manager, EVT_WARNING, "A BPCC header box is available although BPC given by the IHDR box (%d) indicate components bit depth is constant\n",jp2->bpc);
691 	}
692 
693 	/* and length is relevant */
694 	if (p_bpc_header_size != jp2->numcomps) {
695 		opj_event_msg(p_manager, EVT_ERROR, "Bad BPCC header box (bad size)\n");
696 		return OPJ_FALSE;
697 	}
698 
699 	/* read info for each component */
700 	for (i = 0; i < jp2->numcomps; ++i) {
701 		opj_read_bytes(p_bpc_header_data,&jp2->comps[i].bpcc ,1);	/* read each BPCC component */
702 		++p_bpc_header_data;
703 	}
704 
705 	return OPJ_TRUE;
706 }
opj_jp2_write_cdef(opj_jp2_t * jp2,OPJ_UINT32 * p_nb_bytes_written)707 static OPJ_BYTE * opj_jp2_write_cdef(opj_jp2_t *jp2, OPJ_UINT32 * p_nb_bytes_written)
708 {
709 	/* room for 8 bytes for box, 2 for n */
710 	OPJ_UINT32 l_cdef_size = 10;
711 	OPJ_BYTE * l_cdef_data,* l_current_cdef_ptr;
712 	OPJ_UINT32 l_value;
713 	OPJ_UINT16 i;
714 
715 	/* preconditions */
716 	assert(jp2 != 00);
717 	assert(p_nb_bytes_written != 00);
718 	assert(jp2->color.jp2_cdef != 00);
719 	assert(jp2->color.jp2_cdef->info != 00);
720 	assert(jp2->color.jp2_cdef->n > 0U);
721 
722 	l_cdef_size += 6U * jp2->color.jp2_cdef->n;
723 
724 	l_cdef_data = (OPJ_BYTE *) opj_malloc(l_cdef_size);
725 	if (l_cdef_data == 00) {
726 		return 00;
727 	}
728 
729 	l_current_cdef_ptr = l_cdef_data;
730 
731 	opj_write_bytes(l_current_cdef_ptr,l_cdef_size,4);			/* write box size */
732 	l_current_cdef_ptr += 4;
733 
734 	opj_write_bytes(l_current_cdef_ptr,JP2_CDEF,4);					/* BPCC */
735 	l_current_cdef_ptr += 4;
736 
737 	l_value = jp2->color.jp2_cdef->n;
738 	opj_write_bytes(l_current_cdef_ptr,l_value,2);					/* N */
739 	l_current_cdef_ptr += 2;
740 
741 	for (i = 0U; i < jp2->color.jp2_cdef->n; ++i) {
742 		l_value = jp2->color.jp2_cdef->info[i].cn;
743 		opj_write_bytes(l_current_cdef_ptr,l_value,2);					/* Cni */
744 		l_current_cdef_ptr += 2;
745 		l_value = jp2->color.jp2_cdef->info[i].typ;
746 		opj_write_bytes(l_current_cdef_ptr,l_value,2);					/* Typi */
747 		l_current_cdef_ptr += 2;
748 		l_value = jp2->color.jp2_cdef->info[i].asoc;
749 		opj_write_bytes(l_current_cdef_ptr,l_value,2);					/* Asoci */
750 		l_current_cdef_ptr += 2;
751 	}
752 	*p_nb_bytes_written = l_cdef_size;
753 
754 	return l_cdef_data;
755 }
756 
opj_jp2_write_colr(opj_jp2_t * jp2,OPJ_UINT32 * p_nb_bytes_written)757 static OPJ_BYTE * opj_jp2_write_colr(  opj_jp2_t *jp2,
758 							    OPJ_UINT32 * p_nb_bytes_written
759                                 )
760 {
761 	/* room for 8 bytes for box 3 for common data and variable upon profile*/
762 	OPJ_UINT32 l_colr_size = 11;
763 	OPJ_BYTE * l_colr_data,* l_current_colr_ptr;
764 
765 	/* preconditions */
766 	assert(jp2 != 00);
767 	assert(p_nb_bytes_written != 00);
768     assert(jp2->meth == 1 || jp2->meth == 2);
769 
770 	switch (jp2->meth) {
771 		case 1 :
772 			l_colr_size += 4; /* EnumCS */
773 			break;
774 		case 2 :
775             assert(jp2->color.icc_profile_len);	/* ICC profile */
776             l_colr_size += jp2->color.icc_profile_len;
777 			break;
778 		default :
779 			return 00;
780 	}
781 
782 	l_colr_data = (OPJ_BYTE *) opj_calloc(1,l_colr_size);
783 	if (l_colr_data == 00) {
784 		return 00;
785 	}
786 
787 	l_current_colr_ptr = l_colr_data;
788 
789 	opj_write_bytes(l_current_colr_ptr,l_colr_size,4);				/* write box size */
790 	l_current_colr_ptr += 4;
791 
792 	opj_write_bytes(l_current_colr_ptr,JP2_COLR,4);					/* BPCC */
793 	l_current_colr_ptr += 4;
794 
795 	opj_write_bytes(l_current_colr_ptr, jp2->meth,1);				/* METH */
796 	++l_current_colr_ptr;
797 
798 	opj_write_bytes(l_current_colr_ptr, jp2->precedence,1);			/* PRECEDENCE */
799 	++l_current_colr_ptr;
800 
801 	opj_write_bytes(l_current_colr_ptr, jp2->approx,1);				/* APPROX */
802 	++l_current_colr_ptr;
803 
804 	if (jp2->meth == 1) { /* Meth value is restricted to 1 or 2 (Table I.9 of part 1) */
805         opj_write_bytes(l_current_colr_ptr, jp2->enumcs,4); }       /* EnumCS */
806     else {
807         if (jp2->meth == 2) {                                      /* ICC profile */
808             OPJ_UINT32 i;
809             for(i = 0; i < jp2->color.icc_profile_len; ++i) {
810                 opj_write_bytes(l_current_colr_ptr, jp2->color.icc_profile_buf[i], 1);
811                 ++l_current_colr_ptr;
812             }
813         }
814 	}
815 
816 	*p_nb_bytes_written = l_colr_size;
817 
818 	return l_colr_data;
819 }
820 
opj_jp2_free_pclr(opj_jp2_color_t * color)821 static void opj_jp2_free_pclr(opj_jp2_color_t *color)
822 {
823     opj_free(color->jp2_pclr->channel_sign);
824     opj_free(color->jp2_pclr->channel_size);
825     opj_free(color->jp2_pclr->entries);
826 
827 	if(color->jp2_pclr->cmap) opj_free(color->jp2_pclr->cmap);
828 
829     opj_free(color->jp2_pclr); color->jp2_pclr = NULL;
830 }
831 
opj_jp2_check_color(opj_image_t * image,opj_jp2_color_t * color,opj_event_mgr_t * p_manager)832 static OPJ_BOOL opj_jp2_check_color(opj_image_t *image, opj_jp2_color_t *color, opj_event_mgr_t *p_manager)
833 {
834 	OPJ_UINT16 i;
835 
836 	/* testcase 4149.pdf.SIGSEGV.cf7.3501 */
837 	if (color->jp2_cdef) {
838 		opj_jp2_cdef_info_t *info = color->jp2_cdef->info;
839 		OPJ_UINT16 n = color->jp2_cdef->n;
840 		OPJ_UINT32 nr_channels = image->numcomps; /* FIXME image->numcomps == jp2->numcomps before color is applied ??? */
841 
842 		/* cdef applies to cmap channels if any */
843 		if (color->jp2_pclr && color->jp2_pclr->cmap) {
844 			nr_channels = (OPJ_UINT32)color->jp2_pclr->nr_channels;
845 		}
846 
847 		for (i = 0; i < n; i++) {
848 			if (info[i].cn >= nr_channels) {
849 				opj_event_msg(p_manager, EVT_ERROR, "Invalid component index %d (>= %d).\n", info[i].cn, nr_channels);
850 				return OPJ_FALSE;
851 			}
852 			if (info[i].asoc == 65535U) continue;
853 
854 			if (info[i].asoc > 0 && (OPJ_UINT32)(info[i].asoc - 1) >= nr_channels) {
855 				opj_event_msg(p_manager, EVT_ERROR, "Invalid component index %d (>= %d).\n", info[i].asoc - 1, nr_channels);
856 				return OPJ_FALSE;
857 			}
858 		}
859 
860 		/* issue 397 */
861 		/* ISO 15444-1 states that if cdef is present, it shall contain a complete list of channel definitions. */
862 		while (nr_channels > 0)
863 		{
864 			for(i = 0; i < n; ++i) {
865 				if ((OPJ_UINT32)info[i].cn == (nr_channels - 1U)) {
866 					break;
867 				}
868 			}
869 			if (i == n) {
870 				opj_event_msg(p_manager, EVT_ERROR, "Incomplete channel definitions.\n");
871 				return OPJ_FALSE;
872 			}
873 			--nr_channels;
874 		}
875 	}
876 
877 	/* testcases 451.pdf.SIGSEGV.f4c.3723, 451.pdf.SIGSEGV.5b5.3723 and
878 	   66ea31acbb0f23a2bbc91f64d69a03f5_signal_sigsegv_13937c0_7030_5725.pdf */
879 	if (color->jp2_pclr && color->jp2_pclr->cmap) {
880 		OPJ_UINT16 nr_channels = color->jp2_pclr->nr_channels;
881 		opj_jp2_cmap_comp_t *cmap = color->jp2_pclr->cmap;
882 		OPJ_BOOL *pcol_usage, is_sane = OPJ_TRUE;
883 
884 		/* verify that all original components match an existing one */
885 		for (i = 0; i < nr_channels; i++) {
886 			if (cmap[i].cmp >= image->numcomps) {
887 				opj_event_msg(p_manager, EVT_ERROR, "Invalid component index %d (>= %d).\n", cmap[i].cmp, image->numcomps);
888 				is_sane = OPJ_FALSE;
889 			}
890 		}
891 
892 		pcol_usage = opj_calloc(nr_channels, sizeof(OPJ_BOOL));
893 		if (!pcol_usage) {
894 			opj_event_msg(p_manager, EVT_ERROR, "Unexpected OOM.\n");
895 			return OPJ_FALSE;
896 		}
897 		/* verify that no component is targeted more than once */
898 		for (i = 0; i < nr_channels; i++) {
899 			if (cmap[i].mtyp != 0 && cmap[i].mtyp != 1) {
900 				opj_event_msg(p_manager, EVT_ERROR, "Unexpected MTYP value.\n");
901 				opj_free(pcol_usage);
902 				return OPJ_FALSE;
903 			}
904 			OPJ_UINT16 pcol = cmap[i].pcol;
905 			if (pcol >= nr_channels) {
906 				opj_event_msg(p_manager, EVT_ERROR, "Invalid component/palette index for direct mapping %d.\n", pcol);
907 				is_sane = OPJ_FALSE;
908 			}
909 			else if (pcol_usage[pcol] && cmap[i].mtyp != 0) {
910 				opj_event_msg(p_manager, EVT_ERROR, "Component %d is mapped twice.\n", pcol);
911 				is_sane = OPJ_FALSE;
912 			}
913       else if (cmap[i].mtyp == 0 && cmap[i].pcol != 0) {
914         /* I.5.3.5 PCOL: If the value of the MTYP field for this channel is 0, then
915          * the value of this field shall be 0. */
916 				opj_event_msg(p_manager, EVT_ERROR, "Direct use at #%d however pcol=%d.\n", i, pcol);
917 				is_sane = OPJ_FALSE;
918       }
919 			else
920 				pcol_usage[pcol] = OPJ_TRUE;
921 		}
922 		/* verify that all components are targeted at least once */
923 		for (i = 0; i < nr_channels; i++) {
924 			if (!pcol_usage[i] && cmap[i].mtyp != 0) {
925 				opj_event_msg(p_manager, EVT_ERROR, "Component %d doesn't have a mapping.\n", i);
926 				is_sane = OPJ_FALSE;
927 			}
928 		}
929 		/* Issue 235/447 weird cmap */
930 		if (1 && is_sane && (image->numcomps==1U)) {
931 			for (i = 0; i < nr_channels; i++) {
932 				if (!pcol_usage[i]) {
933 					is_sane = 0U;
934 					opj_event_msg(p_manager, EVT_WARNING, "Component mapping seems wrong. Trying to correct.\n", i);
935 					break;
936 				}
937 			}
938 			if (!is_sane) {
939 				is_sane = OPJ_TRUE;
940 				for (i = 0; i < nr_channels; i++) {
941 					cmap[i].mtyp = 1U;
942 					cmap[i].pcol = (OPJ_BYTE) i;
943 				}
944 			}
945 		}
946 		opj_free(pcol_usage);
947 		if (!is_sane) {
948 			return OPJ_FALSE;
949 		}
950 	}
951 
952 	return OPJ_TRUE;
953 }
954 
955 /* file9.jp2 */
opj_jp2_apply_pclr(opj_image_t * image,opj_jp2_color_t * color)956 static void opj_jp2_apply_pclr(opj_image_t *image, opj_jp2_color_t *color)
957 {
958 	opj_image_comp_t *old_comps, *new_comps;
959 	OPJ_BYTE *channel_size, *channel_sign;
960 	OPJ_UINT32 *entries;
961 	opj_jp2_cmap_comp_t *cmap;
962 	OPJ_INT32 *src, *dst;
963 	OPJ_UINT32 j, max;
964 	OPJ_UINT16 i, nr_channels, cmp, pcol;
965 	OPJ_INT32 k, top_k;
966 
967 	channel_size = color->jp2_pclr->channel_size;
968 	channel_sign = color->jp2_pclr->channel_sign;
969 	entries = color->jp2_pclr->entries;
970 	cmap = color->jp2_pclr->cmap;
971 	nr_channels = color->jp2_pclr->nr_channels;
972 
973 	old_comps = image->comps;
974 	new_comps = (opj_image_comp_t*)
975 			opj_malloc(nr_channels * sizeof(opj_image_comp_t));
976 	if (!new_comps) {
977 		/* FIXME no error code for opj_jp2_apply_pclr */
978 		/* FIXME event manager error callback */
979 		return;
980 	}
981 	for(i = 0; i < nr_channels; ++i) {
982 		pcol = cmap[i].pcol; cmp = cmap[i].cmp;
983 
984 		/* Direct use */
985     if(cmap[i].mtyp == 0){
986       assert( pcol == 0 );
987       new_comps[i] = old_comps[cmp];
988     } else {
989       assert( i == pcol ); // probably wrong?
990       new_comps[i] = old_comps[cmp];
991     }
992 
993 		/* Palette mapping: */
994 		new_comps[i].data = (OPJ_INT32*)
995 				opj_malloc(old_comps[cmp].w * old_comps[cmp].h * sizeof(OPJ_INT32));
996 		if (!new_comps[i].data) {
997 			opj_free(new_comps);
998 			new_comps = NULL;
999 			/* FIXME no error code for opj_jp2_apply_pclr */
1000 			/* FIXME event manager error callback */
1001 			return;
1002 		}
1003 		new_comps[i].prec = channel_size[i];
1004 		new_comps[i].sgnd = channel_sign[i];
1005 	}
1006 
1007 	top_k = color->jp2_pclr->nr_entries - 1;
1008 
1009 	for(i = 0; i < nr_channels; ++i) {
1010 		/* Palette mapping: */
1011 		cmp = cmap[i].cmp; pcol = cmap[i].pcol;
1012 		src = old_comps[cmp].data;
1013     assert( src );
1014 		max = new_comps[i].w * new_comps[i].h;
1015 
1016 		/* Direct use: */
1017     if(cmap[i].mtyp == 0) {
1018       assert( cmp == 0 ); // probably wrong.
1019       dst = new_comps[i].data;
1020       assert( dst );
1021       for(j = 0; j < max; ++j) {
1022         dst[j] = src[j];
1023       }
1024     }
1025     else {
1026       assert( i == pcol ); // probably wrong?
1027       dst = new_comps[i].data;
1028       assert( dst );
1029       for(j = 0; j < max; ++j) {
1030         /* The index */
1031         if((k = src[j]) < 0) k = 0; else if(k > top_k) k = top_k;
1032 
1033         /* The colour */
1034         dst[j] = (OPJ_INT32)entries[k * nr_channels + pcol];
1035         }
1036     }
1037 	}
1038 
1039 	max = image->numcomps;
1040 	for(i = 0; i < max; ++i) {
1041 		if(old_comps[i].data) opj_free(old_comps[i].data);
1042 	}
1043 
1044 	opj_free(old_comps);
1045 	image->comps = new_comps;
1046 	image->numcomps = nr_channels;
1047 
1048 	opj_jp2_free_pclr(color);
1049 
1050 }/* apply_pclr() */
1051 
opj_jp2_read_pclr(opj_jp2_t * jp2,OPJ_BYTE * p_pclr_header_data,OPJ_UINT32 p_pclr_header_size,opj_event_mgr_t * p_manager)1052 static OPJ_BOOL opj_jp2_read_pclr(	opj_jp2_t *jp2,
1053                             OPJ_BYTE * p_pclr_header_data,
1054                             OPJ_UINT32 p_pclr_header_size,
1055                             opj_event_mgr_t * p_manager
1056                             )
1057 {
1058 	opj_jp2_pclr_t *jp2_pclr;
1059 	OPJ_BYTE *channel_size, *channel_sign;
1060 	OPJ_UINT32 *entries;
1061 	OPJ_UINT16 nr_entries,nr_channels;
1062 	OPJ_UINT16 i, j;
1063 	OPJ_UINT32 l_value;
1064 	OPJ_BYTE *orig_header_data = p_pclr_header_data;
1065 
1066 	/* preconditions */
1067 	assert(p_pclr_header_data != 00);
1068 	assert(jp2 != 00);
1069 	assert(p_manager != 00);
1070     (void)p_pclr_header_size;
1071 
1072 	if(jp2->color.jp2_pclr)
1073 		return OPJ_FALSE;
1074 
1075 	if (p_pclr_header_size < 3)
1076 		return OPJ_FALSE;
1077 
1078 	opj_read_bytes(p_pclr_header_data, &l_value , 2);	/* NE */
1079 	p_pclr_header_data += 2;
1080 	nr_entries = (OPJ_UINT16) l_value;
1081 	if ((nr_entries == 0U) || (nr_entries > 1024U)) {
1082 		opj_event_msg(p_manager, EVT_ERROR, "Invalid PCLR box. Reports %d entries\n", (int)nr_entries);
1083 		return OPJ_FALSE;
1084 	}
1085 
1086 	opj_read_bytes(p_pclr_header_data, &l_value , 1);	/* NPC */
1087 	++p_pclr_header_data;
1088 	nr_channels = (OPJ_UINT16) l_value;
1089 	if (nr_channels == 0U) {
1090 		opj_event_msg(p_manager, EVT_ERROR, "Invalid PCLR box. Reports 0 palette columns\n");
1091 		return OPJ_FALSE;
1092 	}
1093 
1094 	if (p_pclr_header_size < 3 + (OPJ_UINT32)nr_channels)
1095 		return OPJ_FALSE;
1096 
1097 	entries = (OPJ_UINT32*) opj_malloc((size_t)nr_channels * nr_entries * sizeof(OPJ_UINT32));
1098     if (!entries)
1099         return OPJ_FALSE;
1100 	channel_size = (OPJ_BYTE*) opj_malloc(nr_channels);
1101     if (!channel_size)
1102     {
1103         opj_free(entries);
1104         return OPJ_FALSE;
1105     }
1106 	channel_sign = (OPJ_BYTE*) opj_malloc(nr_channels);
1107 	if (!channel_sign)
1108 	{
1109         opj_free(entries);
1110         opj_free(channel_size);
1111         return OPJ_FALSE;
1112 	}
1113 
1114 	jp2_pclr = (opj_jp2_pclr_t*)opj_malloc(sizeof(opj_jp2_pclr_t));
1115     if (!jp2_pclr)
1116     {
1117         opj_free(entries);
1118         opj_free(channel_size);
1119         opj_free(channel_sign);
1120         return OPJ_FALSE;
1121     }
1122 
1123 	jp2_pclr->channel_sign = channel_sign;
1124 	jp2_pclr->channel_size = channel_size;
1125 	jp2_pclr->entries = entries;
1126 	jp2_pclr->nr_entries = nr_entries;
1127 	jp2_pclr->nr_channels = (OPJ_BYTE) l_value;
1128 	jp2_pclr->cmap = NULL;
1129 
1130 	jp2->color.jp2_pclr = jp2_pclr;
1131 
1132 	for(i = 0; i < nr_channels; ++i) {
1133 		opj_read_bytes(p_pclr_header_data, &l_value , 1);	/* Bi */
1134 		++p_pclr_header_data;
1135 
1136 		channel_size[i] = (OPJ_BYTE)((l_value & 0x7f) + 1);
1137 		channel_sign[i] = (l_value & 0x80) ? 1 : 0;
1138 	}
1139 
1140 	for(j = 0; j < nr_entries; ++j) {
1141 		for(i = 0; i < nr_channels; ++i) {
1142 			OPJ_UINT32 bytes_to_read = (OPJ_UINT32)((channel_size[i]+7)>>3);
1143 
1144 			if (bytes_to_read > sizeof(OPJ_UINT32))
1145 				bytes_to_read = sizeof(OPJ_UINT32);
1146 			if ((ptrdiff_t)p_pclr_header_size < (ptrdiff_t)(p_pclr_header_data - orig_header_data) + (ptrdiff_t)bytes_to_read)
1147 				return OPJ_FALSE;
1148 
1149 			opj_read_bytes(p_pclr_header_data, &l_value , bytes_to_read);	/* Cji */
1150 			p_pclr_header_data += bytes_to_read;
1151 			*entries = (OPJ_UINT32) l_value;
1152 			entries++;
1153 		}
1154 	}
1155 
1156 	return OPJ_TRUE;
1157 }
1158 
opj_jp2_read_cmap(opj_jp2_t * jp2,OPJ_BYTE * p_cmap_header_data,OPJ_UINT32 p_cmap_header_size,opj_event_mgr_t * p_manager)1159 static OPJ_BOOL opj_jp2_read_cmap(	opj_jp2_t * jp2,
1160                             OPJ_BYTE * p_cmap_header_data,
1161                             OPJ_UINT32 p_cmap_header_size,
1162                             opj_event_mgr_t * p_manager
1163                             )
1164 {
1165 	opj_jp2_cmap_comp_t *cmap;
1166 	OPJ_BYTE i, nr_channels;
1167 	OPJ_UINT32 l_value;
1168 
1169 	/* preconditions */
1170 	assert(jp2 != 00);
1171 	assert(p_cmap_header_data != 00);
1172 	assert(p_manager != 00);
1173     (void)p_cmap_header_size;
1174 
1175 	/* Need nr_channels: */
1176 	if(jp2->color.jp2_pclr == NULL) {
1177 		opj_event_msg(p_manager, EVT_ERROR, "Need to read a PCLR box before the CMAP box.\n");
1178 		return OPJ_FALSE;
1179 	}
1180 
1181 	/* Part 1, I.5.3.5: 'There shall be at most one Component Mapping box
1182 	 * inside a JP2 Header box' :
1183 	*/
1184 	if(jp2->color.jp2_pclr->cmap) {
1185 		opj_event_msg(p_manager, EVT_ERROR, "Only one CMAP box is allowed.\n");
1186 		return OPJ_FALSE;
1187 	}
1188 
1189 	nr_channels = jp2->color.jp2_pclr->nr_channels;
1190 	if (p_cmap_header_size < (OPJ_UINT32)nr_channels * 4) {
1191 		opj_event_msg(p_manager, EVT_ERROR, "Insufficient data for CMAP box.\n");
1192 		return OPJ_FALSE;
1193 	}
1194 
1195 	cmap = (opj_jp2_cmap_comp_t*) opj_malloc(nr_channels * sizeof(opj_jp2_cmap_comp_t));
1196     if (!cmap)
1197         return OPJ_FALSE;
1198 
1199 
1200 	for(i = 0; i < nr_channels; ++i) {
1201 		opj_read_bytes_BE(p_cmap_header_data, &l_value, 2);			/* CMP^i */
1202 		p_cmap_header_data +=2;
1203 		cmap[i].cmp = (OPJ_UINT16) l_value;
1204 
1205 		opj_read_bytes(p_cmap_header_data, &l_value, 1);			/* MTYP^i */
1206 		++p_cmap_header_data;
1207 		cmap[i].mtyp = (OPJ_BYTE) l_value;
1208 
1209 		opj_read_bytes(p_cmap_header_data, &l_value, 1);			/* PCOL^i */
1210 		++p_cmap_header_data;
1211 		cmap[i].pcol = (OPJ_BYTE) l_value;
1212 	}
1213 
1214 	jp2->color.jp2_pclr->cmap = cmap;
1215 
1216 	return OPJ_TRUE;
1217 }
1218 
opj_jp2_apply_cdef(opj_image_t * image,opj_jp2_color_t * color,opj_event_mgr_t * manager)1219 static void opj_jp2_apply_cdef(opj_image_t *image, opj_jp2_color_t *color, opj_event_mgr_t *manager)
1220 {
1221 	opj_jp2_cdef_info_t *info;
1222 	OPJ_UINT16 i, n, cn, asoc, acn;
1223 
1224 	info = color->jp2_cdef->info;
1225 	n = color->jp2_cdef->n;
1226 
1227 	for(i = 0; i < n; ++i)
1228 	{
1229 		/* WATCH: acn = asoc - 1 ! */
1230 		asoc = info[i].asoc;
1231 		cn = info[i].cn;
1232 
1233 		if( cn >= image->numcomps)
1234 		{
1235 			opj_event_msg(manager, EVT_WARNING, "opj_jp2_apply_cdef: cn=%d, numcomps=%d\n", cn, image->numcomps);
1236 			continue;
1237 		}
1238 		if(asoc == 0 || asoc == 65535)
1239 		{
1240 			image->comps[cn].alpha = info[i].typ;
1241 			continue;
1242 		}
1243 
1244 		acn = (OPJ_UINT16)(asoc - 1);
1245 		if( acn >= image->numcomps )
1246 		{
1247 			opj_event_msg(manager, EVT_WARNING, "opj_jp2_apply_cdef: acn=%d, numcomps=%d\n", acn, image->numcomps);
1248 			continue;
1249 		}
1250 
1251 		/* Swap only if color channel */
1252 		if((cn != acn) && (info[i].typ == 0))
1253 		{
1254 			opj_image_comp_t saved;
1255 			OPJ_UINT16 j;
1256 
1257 			memcpy(&saved, &image->comps[cn], sizeof(opj_image_comp_t));
1258 			memcpy(&image->comps[cn], &image->comps[acn], sizeof(opj_image_comp_t));
1259 			memcpy(&image->comps[acn], &saved, sizeof(opj_image_comp_t));
1260 
1261 			/* Swap channels in following channel definitions, don't bother with j <= i that are already processed */
1262 			for (j = (OPJ_UINT16)(i + 1U); j < n ; ++j)
1263 			{
1264 				if (info[j].cn == cn) {
1265 					info[j].cn = acn;
1266 				}
1267 				else if (info[j].cn == acn) {
1268 					info[j].cn = cn;
1269 				}
1270 				/* asoc is related to color index. Do not update. */
1271 			}
1272 		}
1273 
1274 		image->comps[cn].alpha = info[i].typ;
1275 	}
1276 
1277 	if(color->jp2_cdef->info) opj_free(color->jp2_cdef->info);
1278 
1279 	opj_free(color->jp2_cdef); color->jp2_cdef = NULL;
1280 
1281 }/* jp2_apply_cdef() */
1282 
opj_jp2_read_cdef(opj_jp2_t * jp2,OPJ_BYTE * p_cdef_header_data,OPJ_UINT32 p_cdef_header_size,opj_event_mgr_t * p_manager)1283 static OPJ_BOOL opj_jp2_read_cdef(	opj_jp2_t * jp2,
1284                             OPJ_BYTE * p_cdef_header_data,
1285 							OPJ_UINT32 p_cdef_header_size,
1286 							opj_event_mgr_t * p_manager
1287                             )
1288 {
1289 	opj_jp2_cdef_info_t *cdef_info;
1290 	OPJ_UINT16 i;
1291 	OPJ_UINT32 l_value;
1292 
1293 	/* preconditions */
1294 	assert(jp2 != 00);
1295 	assert(p_cdef_header_data != 00);
1296 	assert(p_manager != 00);
1297     (void)p_cdef_header_size;
1298 
1299 	/* Part 1, I.5.3.6: 'The shall be at most one Channel Definition box
1300 	 * inside a JP2 Header box.'*/
1301 	if(jp2->color.jp2_cdef) return OPJ_FALSE;
1302 
1303 	if (p_cdef_header_size < 2) {
1304 		opj_event_msg(p_manager, EVT_ERROR, "Insufficient data for CDEF box.\n");
1305 		return OPJ_FALSE;
1306 	}
1307 
1308 	opj_read_bytes(p_cdef_header_data,&l_value ,2);			/* N */
1309 	p_cdef_header_data+= 2;
1310 
1311 	if ( (OPJ_UINT16)l_value == 0){ /* szukw000: FIXME */
1312 		opj_event_msg(p_manager, EVT_ERROR, "Number of channel description is equal to zero in CDEF box.\n");
1313 		return OPJ_FALSE;
1314 	}
1315 
1316 	if (p_cdef_header_size < 2 + (OPJ_UINT32)(OPJ_UINT16)l_value * 6) {
1317 		opj_event_msg(p_manager, EVT_ERROR, "Insufficient data for CDEF box.\n");
1318 		return OPJ_FALSE;
1319 	}
1320 
1321 	cdef_info = (opj_jp2_cdef_info_t*) opj_malloc(l_value * sizeof(opj_jp2_cdef_info_t));
1322 	if (!cdef_info)
1323 		return OPJ_FALSE;
1324 
1325 	jp2->color.jp2_cdef = (opj_jp2_cdef_t*)opj_malloc(sizeof(opj_jp2_cdef_t));
1326 	if(!jp2->color.jp2_cdef)
1327 	{
1328 		opj_free(cdef_info);
1329 		return OPJ_FALSE;
1330 	}
1331 	jp2->color.jp2_cdef->info = cdef_info;
1332 	jp2->color.jp2_cdef->n = (OPJ_UINT16) l_value;
1333 
1334 	for(i = 0; i < jp2->color.jp2_cdef->n; ++i) {
1335 		opj_read_bytes(p_cdef_header_data, &l_value, 2);			/* Cn^i */
1336 		p_cdef_header_data +=2;
1337 		cdef_info[i].cn = (OPJ_UINT16) l_value;
1338 
1339 		opj_read_bytes(p_cdef_header_data, &l_value, 2);			/* Typ^i */
1340 		p_cdef_header_data +=2;
1341 		cdef_info[i].typ = (OPJ_UINT16) l_value;
1342 
1343 		opj_read_bytes(p_cdef_header_data, &l_value, 2);			/* Asoc^i */
1344 		p_cdef_header_data +=2;
1345 		cdef_info[i].asoc = (OPJ_UINT16) l_value;
1346    }
1347 
1348 	return OPJ_TRUE;
1349 }
1350 
opj_jp2_read_colr(opj_jp2_t * jp2,OPJ_BYTE * p_colr_header_data,OPJ_UINT32 p_colr_header_size,opj_event_mgr_t * p_manager)1351 static OPJ_BOOL opj_jp2_read_colr( opj_jp2_t *jp2,
1352                             OPJ_BYTE * p_colr_header_data,
1353                             OPJ_UINT32 p_colr_header_size,
1354                             opj_event_mgr_t * p_manager
1355                             )
1356 {
1357 	OPJ_UINT32 l_value;
1358 
1359 	/* preconditions */
1360 	assert(jp2 != 00);
1361 	assert(p_colr_header_data != 00);
1362 	assert(p_manager != 00);
1363 
1364 	if (p_colr_header_size < 3) {
1365 		opj_event_msg(p_manager, EVT_ERROR, "Bad COLR header box (bad size)\n");
1366 		return OPJ_FALSE;
1367 	}
1368 
1369 	/* Part 1, I.5.3.3 : 'A conforming JP2 reader shall ignore all Colour
1370 	 * Specification boxes after the first.'
1371 	*/
1372 	if(jp2->color.jp2_has_colr) {
1373 		opj_event_msg(p_manager, EVT_INFO, "A conforming JP2 reader shall ignore all Colour Specification boxes after the first, so we ignore this one.\n");
1374 		p_colr_header_data += p_colr_header_size;
1375 		return OPJ_TRUE;
1376 	}
1377 
1378 	opj_read_bytes(p_colr_header_data,&jp2->meth ,1);			/* METH */
1379 	++p_colr_header_data;
1380 
1381 	opj_read_bytes(p_colr_header_data,&jp2->precedence ,1);		/* PRECEDENCE */
1382 	++p_colr_header_data;
1383 
1384 	opj_read_bytes(p_colr_header_data,&jp2->approx ,1);			/* APPROX */
1385 	++p_colr_header_data;
1386 
1387 	if (jp2->meth == 1) {
1388 		if (p_colr_header_size < 7) {
1389 			opj_event_msg(p_manager, EVT_ERROR, "Bad COLR header box (bad size: %d)\n", p_colr_header_size);
1390 			return OPJ_FALSE;
1391 		}
1392 		if ((p_colr_header_size > 7) && (jp2->enumcs != 14)) { /* handled below for CIELab) */
1393 			/* testcase Altona_Technical_v20_x4.pdf */
1394 			opj_event_msg(p_manager, EVT_WARNING, "Bad COLR header box (bad size: %d)\n", p_colr_header_size);
1395 		}
1396 
1397 		opj_read_bytes(p_colr_header_data,&jp2->enumcs ,4);			/* EnumCS */
1398 
1399 		p_colr_header_data += 4;
1400 
1401 		if(jp2->enumcs == 14)/* CIELab */
1402 		{
1403 			OPJ_UINT32 *cielab;
1404 			OPJ_UINT32 rl, ol, ra, oa, rb, ob, il;
1405 
1406 			cielab = (OPJ_UINT32*)opj_malloc(9 * sizeof(OPJ_UINT32));
1407 			cielab[0] = 14; /* enumcs */
1408 
1409 			/* default values */
1410 			rl = ra = rb = ol = oa = ob = 0;
1411 			il = 0x00443530; /* D50 */
1412 			cielab[1] = 0x44454600;/* DEF */
1413 
1414 			if(p_colr_header_size == 35)
1415 			{
1416 				opj_read_bytes(p_colr_header_data, &rl, 4);
1417 				p_colr_header_data += 4;
1418 				opj_read_bytes(p_colr_header_data, &ol, 4);
1419 				p_colr_header_data += 4;
1420 				opj_read_bytes(p_colr_header_data, &ra, 4);
1421 				p_colr_header_data += 4;
1422 				opj_read_bytes(p_colr_header_data, &oa, 4);
1423 				p_colr_header_data += 4;
1424 				opj_read_bytes(p_colr_header_data, &rb, 4);
1425 				p_colr_header_data += 4;
1426 				opj_read_bytes(p_colr_header_data, &ob, 4);
1427 				p_colr_header_data += 4;
1428 				opj_read_bytes(p_colr_header_data, &il, 4);
1429 				p_colr_header_data += 4;
1430 
1431 				cielab[1] = 0;
1432 			}
1433 			else if(p_colr_header_size != 7)
1434 			{
1435 				opj_event_msg(p_manager, EVT_WARNING, "Bad COLR header box (CIELab, bad size: %d)\n", p_colr_header_size);
1436 			}
1437 			cielab[2] = rl; cielab[4] = ra; cielab[6] = rb;
1438 			cielab[3] = ol; cielab[5] = oa; cielab[7] = ob;
1439 			cielab[8] = il;
1440 
1441 			jp2->color.icc_profile_buf = (OPJ_BYTE*)cielab;
1442 			jp2->color.icc_profile_len = 0;
1443 		}
1444 		jp2->color.jp2_has_colr = 1;
1445 	}
1446 	else if (jp2->meth == 2) {
1447 		/* ICC profile */
1448 		OPJ_INT32 it_icc_value = 0;
1449 		OPJ_INT32 icc_len = (OPJ_INT32)p_colr_header_size - 3;
1450 
1451 		jp2->color.icc_profile_len = (OPJ_UINT32)icc_len;
1452 		jp2->color.icc_profile_buf = (OPJ_BYTE*) opj_calloc(1,(size_t)icc_len);
1453 		if (!jp2->color.icc_profile_buf)
1454 		{
1455 			jp2->color.icc_profile_len = 0;
1456 			return OPJ_FALSE;
1457 		}
1458 
1459 		for (it_icc_value = 0; it_icc_value < icc_len; ++it_icc_value)
1460 		{
1461 			opj_read_bytes(p_colr_header_data,&l_value,1);		/* icc values */
1462 			++p_colr_header_data;
1463 			jp2->color.icc_profile_buf[it_icc_value] = (OPJ_BYTE) l_value;
1464 		}
1465 
1466 		jp2->color.jp2_has_colr = 1;
1467 	}
1468 	else if (jp2->meth > 2)
1469 	{
1470 		/*	ISO/IEC 15444-1:2004 (E), Table I.9 Legal METH values:
1471 		conforming JP2 reader shall ignore the entire Colour Specification box.*/
1472 		opj_event_msg(p_manager, EVT_INFO, "COLR BOX meth value is not a regular value (%d), "
1473 			"so we will ignore the entire Colour Specification box. \n", jp2->meth);
1474 	}
1475 	return OPJ_TRUE;
1476 }
1477 
opj_jp2_decode(opj_jp2_t * jp2,opj_stream_private_t * p_stream,opj_image_t * p_image,opj_event_mgr_t * p_manager)1478 OPJ_BOOL opj_jp2_decode(opj_jp2_t *jp2,
1479                         opj_stream_private_t *p_stream,
1480                         opj_image_t* p_image,
1481                         opj_event_mgr_t * p_manager)
1482 {
1483 	if (!p_image)
1484 		return OPJ_FALSE;
1485 
1486 	/* J2K decoding */
1487 	if( ! opj_j2k_decode(jp2->j2k, p_stream, p_image, p_manager) ) {
1488 		opj_event_msg(p_manager, EVT_ERROR, "Failed to decode the codestream in the JP2 file\n");
1489 		return OPJ_FALSE;
1490 	}
1491 
1492 	if (!jp2->ignore_pclr_cmap_cdef){
1493 		if (!opj_jp2_check_color(p_image, &(jp2->color), p_manager)) {
1494 			return OPJ_FALSE;
1495 		}
1496 
1497 		/* Set Image Color Space */
1498 		if (jp2->enumcs == 16)
1499 			p_image->color_space = OPJ_CLRSPC_SRGB;
1500 		else if (jp2->enumcs == 17)
1501 			p_image->color_space = OPJ_CLRSPC_GRAY;
1502 		else if (jp2->enumcs == 18)
1503 			p_image->color_space = OPJ_CLRSPC_SYCC;
1504 		else if (jp2->enumcs == 24)
1505 			p_image->color_space = OPJ_CLRSPC_EYCC;
1506 		else if (jp2->enumcs == 12)
1507 			p_image->color_space = OPJ_CLRSPC_CMYK;
1508 		else
1509 			p_image->color_space = OPJ_CLRSPC_UNKNOWN;
1510 
1511 		if(jp2->color.jp2_pclr) {
1512 			/* Part 1, I.5.3.4: Either both or none : */
1513 			if( !jp2->color.jp2_pclr->cmap)
1514 				opj_jp2_free_pclr(&(jp2->color));
1515 			else if (p_image->pdfium_use_colorspace)
1516 				opj_jp2_apply_pclr(p_image, &(jp2->color));
1517 		}
1518 
1519 		/* Apply the color space if needed */
1520 		if(jp2->color.jp2_cdef) {
1521 			opj_jp2_apply_cdef(p_image, &(jp2->color), p_manager);
1522 		}
1523 
1524 		if(jp2->color.icc_profile_buf) {
1525 			p_image->icc_profile_buf = jp2->color.icc_profile_buf;
1526 			p_image->icc_profile_len = jp2->color.icc_profile_len;
1527 			jp2->color.icc_profile_buf = NULL;
1528 		}
1529 	}
1530 
1531 	return OPJ_TRUE;
1532 }
1533 
opj_jp2_write_jp2h(opj_jp2_t * jp2,opj_stream_private_t * stream,opj_event_mgr_t * p_manager)1534 static OPJ_BOOL opj_jp2_write_jp2h(opj_jp2_t *jp2,
1535                             opj_stream_private_t *stream,
1536                             opj_event_mgr_t * p_manager
1537                             )
1538 {
1539 	opj_jp2_img_header_writer_handler_t l_writers [4];
1540 	opj_jp2_img_header_writer_handler_t * l_current_writer;
1541 
1542 	OPJ_INT32 i, l_nb_pass;
1543 	/* size of data for super box*/
1544 	OPJ_UINT32 l_jp2h_size = 8;
1545 	OPJ_BOOL l_result = OPJ_TRUE;
1546 
1547 	/* to store the data of the super box */
1548 	OPJ_BYTE l_jp2h_data [8];
1549 
1550 	/* preconditions */
1551 	assert(stream != 00);
1552 	assert(jp2 != 00);
1553 	assert(p_manager != 00);
1554 
1555 	memset(l_writers,0,sizeof(l_writers));
1556 
1557 	if (jp2->bpc == 255) {
1558 		l_nb_pass = 3;
1559 		l_writers[0].handler = opj_jp2_write_ihdr;
1560 		l_writers[1].handler = opj_jp2_write_bpcc;
1561 		l_writers[2].handler = opj_jp2_write_colr;
1562 	}
1563 	else {
1564 		l_nb_pass = 2;
1565 		l_writers[0].handler = opj_jp2_write_ihdr;
1566 		l_writers[1].handler = opj_jp2_write_colr;
1567 	}
1568 
1569 	if (jp2->color.jp2_cdef != NULL) {
1570 		l_writers[l_nb_pass].handler = opj_jp2_write_cdef;
1571 		l_nb_pass++;
1572 	}
1573 
1574 	/* write box header */
1575 	/* write JP2H type */
1576 	opj_write_bytes(l_jp2h_data+4,JP2_JP2H,4);
1577 
1578 	l_current_writer = l_writers;
1579 	for (i=0;i<l_nb_pass;++i) {
1580 		l_current_writer->m_data = l_current_writer->handler(jp2,&(l_current_writer->m_size));
1581 		if (l_current_writer->m_data == 00) {
1582 			opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to hold JP2 Header data\n");
1583 			l_result = OPJ_FALSE;
1584 			break;
1585 		}
1586 
1587 		l_jp2h_size += l_current_writer->m_size;
1588 		++l_current_writer;
1589 	}
1590 
1591 	if (! l_result) {
1592 		l_current_writer = l_writers;
1593 		for (i=0;i<l_nb_pass;++i) {
1594 			if (l_current_writer->m_data != 00) {
1595 				opj_free(l_current_writer->m_data );
1596 			}
1597 			++l_current_writer;
1598 		}
1599 
1600 		return OPJ_FALSE;
1601 	}
1602 
1603 	/* write super box size */
1604 	opj_write_bytes(l_jp2h_data,l_jp2h_size,4);
1605 
1606 	/* write super box data on stream */
1607 	if (opj_stream_write_data(stream,l_jp2h_data,8,p_manager) != 8) {
1608 		opj_event_msg(p_manager, EVT_ERROR, "Stream error while writing JP2 Header box\n");
1609 		l_result = OPJ_FALSE;
1610 	}
1611 
1612 	if (l_result) {
1613 		l_current_writer = l_writers;
1614 		for (i=0;i<l_nb_pass;++i) {
1615 			if (opj_stream_write_data(stream,l_current_writer->m_data,l_current_writer->m_size,p_manager) != l_current_writer->m_size) {
1616 				opj_event_msg(p_manager, EVT_ERROR, "Stream error while writing JP2 Header box\n");
1617 				l_result = OPJ_FALSE;
1618 				break;
1619 			}
1620 			++l_current_writer;
1621 		}
1622 	}
1623 
1624 	l_current_writer = l_writers;
1625 
1626 	/* cleanup */
1627 	for (i=0;i<l_nb_pass;++i) {
1628 		if (l_current_writer->m_data != 00) {
1629 			opj_free(l_current_writer->m_data );
1630 		}
1631 		++l_current_writer;
1632 	}
1633 
1634 	return l_result;
1635 }
1636 
opj_jp2_write_ftyp(opj_jp2_t * jp2,opj_stream_private_t * cio,opj_event_mgr_t * p_manager)1637 static OPJ_BOOL opj_jp2_write_ftyp(opj_jp2_t *jp2,
1638 							opj_stream_private_t *cio,
1639 							opj_event_mgr_t * p_manager )
1640 {
1641 	OPJ_UINT32 i;
1642 	OPJ_UINT32 l_ftyp_size = 16 + 4 * jp2->numcl;
1643 	OPJ_BYTE * l_ftyp_data, * l_current_data_ptr;
1644 	OPJ_BOOL l_result;
1645 
1646 	/* preconditions */
1647 	assert(cio != 00);
1648 	assert(jp2 != 00);
1649 	assert(p_manager != 00);
1650 
1651 	l_ftyp_data = (OPJ_BYTE *) opj_calloc(1,l_ftyp_size);
1652 
1653 	if (l_ftyp_data == 00) {
1654 		opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to handle ftyp data\n");
1655 		return OPJ_FALSE;
1656 	}
1657 
1658 	l_current_data_ptr = l_ftyp_data;
1659 
1660 	opj_write_bytes(l_current_data_ptr, l_ftyp_size,4); /* box size */
1661 	l_current_data_ptr += 4;
1662 
1663 	opj_write_bytes(l_current_data_ptr, JP2_FTYP,4); /* FTYP */
1664 	l_current_data_ptr += 4;
1665 
1666 	opj_write_bytes(l_current_data_ptr, jp2->brand,4); /* BR */
1667 	l_current_data_ptr += 4;
1668 
1669 	opj_write_bytes(l_current_data_ptr, jp2->minversion,4); /* MinV */
1670 	l_current_data_ptr += 4;
1671 
1672 	for (i = 0; i < jp2->numcl; i++)  {
1673 		opj_write_bytes(l_current_data_ptr, jp2->cl[i],4);	/* CL */
1674 	}
1675 
1676 	l_result = (opj_stream_write_data(cio,l_ftyp_data,l_ftyp_size,p_manager) == l_ftyp_size);
1677 	if (! l_result)
1678 	{
1679 		opj_event_msg(p_manager, EVT_ERROR, "Error while writing ftyp data to stream\n");
1680 	}
1681 
1682 	opj_free(l_ftyp_data);
1683 
1684 	return l_result;
1685 }
1686 
opj_jp2_write_jp2c(opj_jp2_t * jp2,opj_stream_private_t * cio,opj_event_mgr_t * p_manager)1687 static OPJ_BOOL opj_jp2_write_jp2c(opj_jp2_t *jp2,
1688 							opj_stream_private_t *cio,
1689 							opj_event_mgr_t * p_manager )
1690 {
1691 	OPJ_OFF_T j2k_codestream_exit;
1692 	OPJ_BYTE l_data_header [8];
1693 
1694 	/* preconditions */
1695 	assert(jp2 != 00);
1696 	assert(cio != 00);
1697 	assert(p_manager != 00);
1698 	assert(opj_stream_has_seek(cio));
1699 
1700 	j2k_codestream_exit = opj_stream_tell(cio);
1701 	opj_write_bytes(l_data_header,
1702                     (OPJ_UINT32) (j2k_codestream_exit - jp2->j2k_codestream_offset),
1703                     4); /* size of codestream */
1704 	opj_write_bytes(l_data_header + 4,JP2_JP2C,4);									   /* JP2C */
1705 
1706 	if (! opj_stream_seek(cio,jp2->j2k_codestream_offset,p_manager)) {
1707 		opj_event_msg(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
1708 		return OPJ_FALSE;
1709 	}
1710 
1711 	if (opj_stream_write_data(cio,l_data_header,8,p_manager) != 8) {
1712 		opj_event_msg(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
1713 		return OPJ_FALSE;
1714 	}
1715 
1716 	if (! opj_stream_seek(cio,j2k_codestream_exit,p_manager)) {
1717 		opj_event_msg(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
1718 		return OPJ_FALSE;
1719 	}
1720 
1721 	return OPJ_TRUE;
1722 }
1723 
opj_jp2_write_jp(opj_jp2_t * jp2,opj_stream_private_t * cio,opj_event_mgr_t * p_manager)1724 static OPJ_BOOL opj_jp2_write_jp(	opj_jp2_t *jp2,
1725 			    		    opj_stream_private_t *cio,
1726 				    		opj_event_mgr_t * p_manager )
1727 {
1728 	/* 12 bytes will be read */
1729 	OPJ_BYTE l_signature_data [12];
1730 
1731 	/* preconditions */
1732 	assert(cio != 00);
1733 	assert(jp2 != 00);
1734 	assert(p_manager != 00);
1735 
1736 	/* write box length */
1737 	opj_write_bytes(l_signature_data,12,4);
1738 	/* writes box type */
1739 	opj_write_bytes(l_signature_data+4,JP2_JP,4);
1740 	/* writes magic number*/
1741 	opj_write_bytes(l_signature_data+8,0x0d0a870a,4);
1742 
1743 	if (opj_stream_write_data(cio,l_signature_data,12,p_manager) != 12) {
1744 		return OPJ_FALSE;
1745 	}
1746 
1747 	return OPJ_TRUE;
1748 }
1749 
1750 /* ----------------------------------------------------------------------- */
1751 /* JP2 decoder interface                                             */
1752 /* ----------------------------------------------------------------------- */
1753 
opj_jp2_setup_decoder(opj_jp2_t * jp2,opj_dparameters_t * parameters)1754 void opj_jp2_setup_decoder(opj_jp2_t *jp2, opj_dparameters_t *parameters)
1755 {
1756 	/* setup the J2K codec */
1757 	opj_j2k_setup_decoder(jp2->j2k, parameters);
1758 
1759 	/* further JP2 initializations go here */
1760 	jp2->color.jp2_has_colr = 0;
1761     jp2->ignore_pclr_cmap_cdef = parameters->flags & OPJ_DPARAMETERS_IGNORE_PCLR_CMAP_CDEF_FLAG;
1762 }
1763 
1764 /* ----------------------------------------------------------------------- */
1765 /* JP2 encoder interface                                             */
1766 /* ----------------------------------------------------------------------- */
1767 
opj_jp2_setup_encoder(opj_jp2_t * jp2,opj_cparameters_t * parameters,opj_image_t * image,opj_event_mgr_t * p_manager)1768 OPJ_BOOL opj_jp2_setup_encoder(	opj_jp2_t *jp2,
1769                             opj_cparameters_t *parameters,
1770                             opj_image_t *image,
1771                             opj_event_mgr_t * p_manager)
1772 {
1773 	OPJ_UINT32 i;
1774 	OPJ_UINT32 depth_0;
1775   OPJ_UINT32 sign;
1776 	OPJ_UINT32 alpha_count;
1777 	OPJ_UINT32 color_channels = 0U;
1778 	OPJ_UINT32 alpha_channel = 0U;
1779 
1780 
1781 	if(!jp2 || !parameters || !image)
1782 		return OPJ_FALSE;
1783 
1784 	/* setup the J2K codec */
1785 	/* ------------------- */
1786 
1787 	/* Check if number of components respects standard */
1788 	if (image->numcomps < 1 || image->numcomps > 16384) {
1789 		opj_event_msg(p_manager, EVT_ERROR, "Invalid number of components specified while setting up JP2 encoder\n");
1790 		return OPJ_FALSE;
1791 	}
1792 
1793 	if (opj_j2k_setup_encoder(jp2->j2k, parameters, image, p_manager ) == OPJ_FALSE) {
1794 		return OPJ_FALSE;
1795 	}
1796 
1797 	/* setup the JP2 codec */
1798 	/* ------------------- */
1799 
1800 	/* Profile box */
1801 
1802 	jp2->brand = JP2_JP2;	/* BR */
1803 	jp2->minversion = 0;	/* MinV */
1804 	jp2->numcl = 1;
1805 	jp2->cl = (OPJ_UINT32*) opj_malloc(jp2->numcl * sizeof(OPJ_UINT32));
1806 	if (!jp2->cl){
1807 		jp2->cl = NULL;
1808 		opj_event_msg(p_manager, EVT_ERROR, "Not enough memory when setup the JP2 encoder\n");
1809 		return OPJ_FALSE;
1810 	}
1811 	jp2->cl[0] = JP2_JP2;	/* CL0 : JP2 */
1812 
1813 	/* Image Header box */
1814 
1815 	jp2->numcomps = image->numcomps;	/* NC */
1816 	jp2->comps = (opj_jp2_comps_t*) opj_malloc(jp2->numcomps * sizeof(opj_jp2_comps_t));
1817 	if (!jp2->comps) {
1818 		jp2->comps = NULL;
1819 		opj_event_msg(p_manager, EVT_ERROR, "Not enough memory when setup the JP2 encoder\n");
1820 		/* Memory of jp2->cl will be freed by opj_jp2_destroy */
1821 		return OPJ_FALSE;
1822 	}
1823 
1824 	jp2->h = image->y1 - image->y0;		/* HEIGHT */
1825 	jp2->w = image->x1 - image->x0;		/* WIDTH */
1826 	/* BPC */
1827 	depth_0 = image->comps[0].prec - 1;
1828 	sign = image->comps[0].sgnd;
1829 	jp2->bpc = depth_0 + (sign << 7);
1830 	for (i = 1; i < image->numcomps; i++) {
1831 		OPJ_UINT32 depth = image->comps[i].prec - 1;
1832 		sign = image->comps[i].sgnd;
1833 		if (depth_0 != depth)
1834 			jp2->bpc = 255;
1835 	}
1836 	jp2->C = 7;			/* C : Always 7 */
1837 	jp2->UnkC = 0;		/* UnkC, colorspace specified in colr box */
1838 	jp2->IPR = 0;		/* IPR, no intellectual property */
1839 
1840 	/* BitsPerComponent box */
1841 	for (i = 0; i < image->numcomps; i++) {
1842 		jp2->comps[i].bpcc = image->comps[i].prec - 1 + (image->comps[i].sgnd << 7);
1843 	}
1844 
1845 	/* Colour Specification box */
1846     if(image->icc_profile_len) {
1847         jp2->meth = 2;
1848         jp2->enumcs = 0;
1849     }
1850     else {
1851         jp2->meth = 1;
1852         if (image->color_space == 1)
1853             jp2->enumcs = 16;	/* sRGB as defined by IEC 61966-2-1 */
1854         else if (image->color_space == 2)
1855             jp2->enumcs = 17;	/* greyscale */
1856         else if (image->color_space == 3)
1857             jp2->enumcs = 18;	/* YUV */
1858     }
1859 
1860 	/* Channel Definition box */
1861 	/* FIXME not provided by parameters */
1862 	/* We try to do what we can... */
1863 	alpha_count = 0U;
1864 	for (i = 0; i < image->numcomps; i++) {
1865 		if (image->comps[i].alpha != 0) {
1866 			alpha_count++;
1867 			alpha_channel = i;
1868 		}
1869 	}
1870 	if (alpha_count == 1U) { /* no way to deal with more than 1 alpha channel */
1871 		switch (jp2->enumcs) {
1872 			case 16:
1873 			case 18:
1874 				color_channels = 3;
1875 				break;
1876 			case 17:
1877 				color_channels = 1;
1878 				break;
1879 			default:
1880 				alpha_count = 0U;
1881 				break;
1882 		}
1883 		if (alpha_count == 0U) {
1884 			opj_event_msg(p_manager, EVT_WARNING, "Alpha channel specified but unknown enumcs. No cdef box will be created.\n");
1885 		} else if (image->numcomps < (color_channels+1)) {
1886 			opj_event_msg(p_manager, EVT_WARNING, "Alpha channel specified but not enough image components for an automatic cdef box creation.\n");
1887 			alpha_count = 0U;
1888 		} else if ((OPJ_UINT32)alpha_channel < color_channels) {
1889 			opj_event_msg(p_manager, EVT_WARNING, "Alpha channel position conflicts with color channel. No cdef box will be created.\n");
1890 			alpha_count = 0U;
1891 		}
1892 	} else if (alpha_count > 1) {
1893 		opj_event_msg(p_manager, EVT_WARNING, "Multiple alpha channels specified. No cdef box will be created.\n");
1894 	}
1895 	if (alpha_count == 1U) { /* if here, we know what we can do */
1896 		jp2->color.jp2_cdef = (opj_jp2_cdef_t*)opj_malloc(sizeof(opj_jp2_cdef_t));
1897 		if(!jp2->color.jp2_cdef) {
1898 			opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to setup the JP2 encoder\n");
1899 			return OPJ_FALSE;
1900 		}
1901 		/* no memset needed, all values will be overwritten except if jp2->color.jp2_cdef->info allocation fails, */
1902 		/* in which case jp2->color.jp2_cdef->info will be NULL => valid for destruction */
1903 		jp2->color.jp2_cdef->info = (opj_jp2_cdef_info_t*) opj_malloc(image->numcomps * sizeof(opj_jp2_cdef_info_t));
1904 		if (!jp2->color.jp2_cdef->info) {
1905 			/* memory will be freed by opj_jp2_destroy */
1906 			opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to setup the JP2 encoder\n");
1907 			return OPJ_FALSE;
1908 		}
1909 		jp2->color.jp2_cdef->n = (OPJ_UINT16) image->numcomps; /* cast is valid : image->numcomps [1,16384] */
1910 		for (i = 0U; i < color_channels; i++) {
1911 			jp2->color.jp2_cdef->info[i].cn = (OPJ_UINT16)i; /* cast is valid : image->numcomps [1,16384] */
1912 			jp2->color.jp2_cdef->info[i].typ = 0U;
1913 			jp2->color.jp2_cdef->info[i].asoc = (OPJ_UINT16)(i+1U); /* No overflow + cast is valid : image->numcomps [1,16384] */
1914 		}
1915 		for (; i < image->numcomps; i++) {
1916 			if (image->comps[i].alpha != 0) { /* we'll be here exactly once */
1917 				jp2->color.jp2_cdef->info[i].cn = (OPJ_UINT16)i; /* cast is valid : image->numcomps [1,16384] */
1918 				jp2->color.jp2_cdef->info[i].typ = 1U; /* Opacity channel */
1919 				jp2->color.jp2_cdef->info[i].asoc = 0U; /* Apply alpha channel to the whole image */
1920 			} else {
1921 				/* Unknown channel */
1922 				jp2->color.jp2_cdef->info[i].cn = (OPJ_UINT16)i; /* cast is valid : image->numcomps [1,16384] */
1923 				jp2->color.jp2_cdef->info[i].typ = 65535U;
1924 				jp2->color.jp2_cdef->info[i].asoc = 65535U;
1925 			}
1926 		}
1927 	}
1928 
1929 	jp2->precedence = 0;	/* PRECEDENCE */
1930 	jp2->approx = 0;		/* APPROX */
1931 
1932 	jp2->jpip_on = parameters->jpip_on;
1933 
1934 	return OPJ_TRUE;
1935 }
1936 
opj_jp2_encode(opj_jp2_t * jp2,opj_stream_private_t * stream,opj_event_mgr_t * p_manager)1937 OPJ_BOOL opj_jp2_encode(opj_jp2_t *jp2,
1938 						opj_stream_private_t *stream,
1939 						opj_event_mgr_t * p_manager)
1940 {
1941 	return opj_j2k_encode(jp2->j2k, stream, p_manager);
1942 }
1943 
opj_jp2_end_decompress(opj_jp2_t * jp2,opj_stream_private_t * cio,opj_event_mgr_t * p_manager)1944 OPJ_BOOL opj_jp2_end_decompress(opj_jp2_t *jp2,
1945                                 opj_stream_private_t *cio,
1946                                 opj_event_mgr_t * p_manager
1947                                 )
1948 {
1949 	/* preconditions */
1950 	assert(jp2 != 00);
1951 	assert(cio != 00);
1952 	assert(p_manager != 00);
1953 
1954 	/* customization of the end encoding */
1955 	if (! opj_jp2_setup_end_header_reading(jp2, p_manager)) {
1956 		return OPJ_FALSE;
1957 	}
1958 
1959 	/* write header */
1960 	if (! opj_jp2_exec (jp2,jp2->m_procedure_list,cio,p_manager)) {
1961 		return OPJ_FALSE;
1962 	}
1963 
1964 	return opj_j2k_end_decompress(jp2->j2k, cio, p_manager);
1965 }
1966 
opj_jp2_end_compress(opj_jp2_t * jp2,opj_stream_private_t * cio,opj_event_mgr_t * p_manager)1967 OPJ_BOOL opj_jp2_end_compress(	opj_jp2_t *jp2,
1968 							    opj_stream_private_t *cio,
1969 							    opj_event_mgr_t * p_manager
1970                                 )
1971 {
1972 	/* preconditions */
1973 	assert(jp2 != 00);
1974 	assert(cio != 00);
1975 	assert(p_manager != 00);
1976 
1977 	/* customization of the end encoding */
1978 	if (! opj_jp2_setup_end_header_writing(jp2, p_manager)) {
1979 		return OPJ_FALSE;
1980 	}
1981 
1982 	if (! opj_j2k_end_compress(jp2->j2k,cio,p_manager)) {
1983 		return OPJ_FALSE;
1984 	}
1985 
1986 	/* write header */
1987 	return opj_jp2_exec(jp2,jp2->m_procedure_list,cio,p_manager);
1988 }
1989 
opj_jp2_setup_end_header_writing(opj_jp2_t * jp2,opj_event_mgr_t * p_manager)1990 static OPJ_BOOL opj_jp2_setup_end_header_writing (opj_jp2_t *jp2, opj_event_mgr_t * p_manager)
1991 {
1992 	/* preconditions */
1993 	assert(jp2 != 00);
1994 	assert(p_manager != 00);
1995 
1996 #ifdef USE_JPIP
1997 	if( jp2->jpip_on ) {
1998 		if (! opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jpip_write_iptr, p_manager)) {
1999 			return OPJ_FALSE;
2000 		}
2001 	}
2002 #endif
2003 	if (! opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jp2_write_jp2c, p_manager)) {
2004 		return OPJ_FALSE;
2005 	}
2006 	/* DEVELOPER CORNER, add your custom procedures */
2007 #ifdef USE_JPIP
2008   if( jp2->jpip_on )
2009 	{
2010 		if (! opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jpip_write_cidx, p_manager)) {
2011 			return OPJ_FALSE;
2012 		}
2013 		if (! opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jpip_write_fidx, p_manager)) {
2014 			return OPJ_FALSE;
2015 		}
2016 	}
2017 #endif
2018 	return OPJ_TRUE;
2019 }
2020 
opj_jp2_setup_end_header_reading(opj_jp2_t * jp2,opj_event_mgr_t * p_manager)2021 static OPJ_BOOL opj_jp2_setup_end_header_reading (opj_jp2_t *jp2, opj_event_mgr_t * p_manager)
2022 {
2023 	/* preconditions */
2024 	assert(jp2 != 00);
2025 	assert(p_manager != 00);
2026 
2027 	if (! opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jp2_read_header_procedure, p_manager)) {
2028 		return OPJ_FALSE;
2029 	}
2030 	/* DEVELOPER CORNER, add your custom procedures */
2031 
2032 	return OPJ_TRUE;
2033 }
2034 
opj_jp2_default_validation(opj_jp2_t * jp2,opj_stream_private_t * cio,opj_event_mgr_t * p_manager)2035 static OPJ_BOOL opj_jp2_default_validation (	opj_jp2_t * jp2,
2036                                         opj_stream_private_t *cio,
2037                                         opj_event_mgr_t * p_manager
2038                                         )
2039 {
2040 	OPJ_BOOL l_is_valid = OPJ_TRUE;
2041 	OPJ_UINT32 i;
2042 
2043 	/* preconditions */
2044 	assert(jp2 != 00);
2045 	assert(cio != 00);
2046 	assert(p_manager != 00);
2047 
2048 	/* JPEG2000 codec validation */
2049 
2050 	/* STATE checking */
2051 	/* make sure the state is at 0 */
2052 	l_is_valid &= (jp2->jp2_state == JP2_STATE_NONE);
2053 
2054 	/* make sure not reading a jp2h ???? WEIRD */
2055 	l_is_valid &= (jp2->jp2_img_state == JP2_IMG_STATE_NONE);
2056 
2057 	/* POINTER validation */
2058 	/* make sure a j2k codec is present */
2059 	l_is_valid &= (jp2->j2k != 00);
2060 
2061 	/* make sure a procedure list is present */
2062 	l_is_valid &= (jp2->m_procedure_list != 00);
2063 
2064 	/* make sure a validation list is present */
2065 	l_is_valid &= (jp2->m_validation_list != 00);
2066 
2067 	/* PARAMETER VALIDATION */
2068 	/* number of components */
2069 	l_is_valid &= (jp2->numcl > 0);
2070 	/* width */
2071 	l_is_valid &= (jp2->h > 0);
2072 	/* height */
2073 	l_is_valid &= (jp2->w > 0);
2074 	/* precision */
2075 	for (i = 0; i < jp2->numcomps; ++i)	{
2076 		l_is_valid &= ((jp2->comps[i].bpcc & 0x7FU) < 38U); /* 0 is valid, ignore sign for check */
2077 	}
2078 
2079 	/* METH */
2080 	l_is_valid &= ((jp2->meth > 0) && (jp2->meth < 3));
2081 
2082 	/* stream validation */
2083 	/* back and forth is needed */
2084 	l_is_valid &= opj_stream_has_seek(cio);
2085 
2086 	return l_is_valid;
2087 }
2088 
opj_jp2_read_header_procedure(opj_jp2_t * jp2,opj_stream_private_t * stream,opj_event_mgr_t * p_manager)2089 static OPJ_BOOL opj_jp2_read_header_procedure(  opj_jp2_t *jp2,
2090                                                 opj_stream_private_t *stream,
2091                                                 opj_event_mgr_t * p_manager
2092                                                 )
2093 {
2094 	opj_jp2_box_t box;
2095 	OPJ_UINT32 l_nb_bytes_read;
2096 	const opj_jp2_header_handler_t * l_current_handler;
2097 	const opj_jp2_header_handler_t * l_current_handler_misplaced;
2098 	OPJ_UINT32 l_last_data_size = OPJ_BOX_SIZE;
2099 	OPJ_UINT32 l_current_data_size;
2100 	OPJ_BYTE * l_current_data = 00;
2101 
2102 	/* preconditions */
2103 	assert(stream != 00);
2104 	assert(jp2 != 00);
2105 	assert(p_manager != 00);
2106 
2107 	l_current_data = (OPJ_BYTE*)opj_calloc(1,l_last_data_size);
2108 
2109 	if (l_current_data == 00) {
2110 		opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to handle jpeg2000 file header\n");
2111 		return OPJ_FALSE;
2112 	}
2113 
2114 	while (opj_jp2_read_boxhdr(&box,&l_nb_bytes_read,stream,p_manager)) {
2115 		/* is it the codestream box ? */
2116 		if (box.type == JP2_JP2C) {
2117 			if (jp2->jp2_state & JP2_STATE_HEADER) {
2118 				jp2->jp2_state |= JP2_STATE_CODESTREAM;
2119                                 opj_free(l_current_data);
2120 				return OPJ_TRUE;
2121 			}
2122 			else {
2123 				opj_event_msg(p_manager, EVT_ERROR, "bad placed jpeg codestream\n");
2124 				opj_free(l_current_data);
2125 				return OPJ_FALSE;
2126 			}
2127 		}
2128 		else if	(box.length == 0) {
2129 			opj_event_msg(p_manager, EVT_ERROR, "Cannot handle box of undefined sizes\n");
2130 			opj_free(l_current_data);
2131 			return OPJ_FALSE;
2132 		}
2133 		/* testcase 1851.pdf.SIGSEGV.ce9.948 */
2134         else if (box.length < l_nb_bytes_read) {
2135 			opj_event_msg(p_manager, EVT_ERROR, "invalid box size %d (%x)\n", box.length, box.type);
2136 			opj_free(l_current_data);
2137 			return OPJ_FALSE;
2138 		}
2139 
2140 		l_current_handler = opj_jp2_find_handler(box.type);
2141 		l_current_handler_misplaced = opj_jp2_img_find_handler(box.type);
2142 		l_current_data_size = box.length - l_nb_bytes_read;
2143 
2144 		if ((l_current_handler != 00) || (l_current_handler_misplaced != 00)) {
2145 			if (l_current_handler == 00) {
2146 				opj_event_msg(p_manager, EVT_WARNING, "Found a misplaced '%c%c%c%c' box outside jp2h box\n", (OPJ_BYTE)(box.type>>24), (OPJ_BYTE)(box.type>>16), (OPJ_BYTE)(box.type>>8), (OPJ_BYTE)(box.type>>0));
2147 				if (jp2->jp2_state & JP2_STATE_HEADER) {
2148 					/* read anyway, we already have jp2h */
2149 					l_current_handler = l_current_handler_misplaced;
2150 				} else {
2151 					opj_event_msg(p_manager, EVT_WARNING, "JPEG2000 Header box not read yet, '%c%c%c%c' box will be ignored\n", (OPJ_BYTE)(box.type>>24), (OPJ_BYTE)(box.type>>16), (OPJ_BYTE)(box.type>>8), (OPJ_BYTE)(box.type>>0));
2152 					jp2->jp2_state |= JP2_STATE_UNKNOWN;
2153 					if (opj_stream_skip(stream,l_current_data_size,p_manager) != l_current_data_size) {
2154 							opj_event_msg(p_manager, EVT_ERROR, "Problem with skipping JPEG2000 box, stream error\n");
2155 							opj_free(l_current_data);
2156 							return OPJ_FALSE;
2157 					}
2158 					continue;
2159 				}
2160 			}
2161 			if ((OPJ_OFF_T)l_current_data_size > opj_stream_get_number_byte_left(stream)) {
2162 				/* do not even try to malloc if we can't read */
2163 				opj_event_msg(p_manager, EVT_ERROR, "Invalid box size %d for box '%c%c%c%c'. Need %d bytes, %d bytes remaining \n", box.length, (OPJ_BYTE)(box.type>>24), (OPJ_BYTE)(box.type>>16), (OPJ_BYTE)(box.type>>8), (OPJ_BYTE)(box.type>>0), l_current_data_size, (OPJ_UINT32)opj_stream_get_number_byte_left(stream));
2164 				opj_free(l_current_data);
2165 				return OPJ_FALSE;
2166 			}
2167 			if (l_current_data_size > l_last_data_size) {
2168 				OPJ_BYTE* new_current_data = (OPJ_BYTE*)opj_realloc(l_current_data,l_current_data_size);
2169 				if (!new_current_data) {
2170 					opj_free(l_current_data);
2171                     opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to handle jpeg2000 box\n");
2172 					return OPJ_FALSE;
2173 				}
2174                 l_current_data = new_current_data;
2175 				l_last_data_size = l_current_data_size;
2176 			}
2177 
2178 			l_nb_bytes_read = (OPJ_UINT32)opj_stream_read_data(stream,l_current_data,l_current_data_size,p_manager);
2179 			if (l_nb_bytes_read != l_current_data_size) {
2180 				opj_event_msg(p_manager, EVT_ERROR, "Problem with reading JPEG2000 box, stream error\n");
2181                 opj_free(l_current_data);
2182 				return OPJ_FALSE;
2183 			}
2184 
2185 			if (! l_current_handler->handler(jp2,l_current_data,l_current_data_size,p_manager)) {
2186 				opj_free(l_current_data);
2187 				return OPJ_FALSE;
2188 			}
2189 		}
2190 		else {
2191             if (!(jp2->jp2_state & JP2_STATE_SIGNATURE)) {
2192                 opj_event_msg(p_manager, EVT_ERROR, "Malformed JP2 file format: first box must be JPEG 2000 signature box\n");
2193                 opj_free(l_current_data);
2194                 return OPJ_FALSE;
2195             }
2196             if (!(jp2->jp2_state & JP2_STATE_FILE_TYPE)) {
2197                 opj_event_msg(p_manager, EVT_ERROR, "Malformed JP2 file format: second box must be file type box\n");
2198                 opj_free(l_current_data);
2199                 return OPJ_FALSE;
2200             }
2201 			jp2->jp2_state |= JP2_STATE_UNKNOWN;
2202 			if (opj_stream_skip(stream,l_current_data_size,p_manager) != l_current_data_size) {
2203 				opj_event_msg(p_manager, EVT_ERROR, "Problem with skipping JPEG2000 box, stream error\n");
2204 				opj_free(l_current_data);
2205 				return OPJ_FALSE;
2206 			}
2207 		}
2208 	}
2209 
2210 	opj_free(l_current_data);
2211 
2212 	return OPJ_TRUE;
2213 }
2214 
2215 /**
2216  * Excutes the given procedures on the given codec.
2217  *
2218  * @param	p_procedure_list	the list of procedures to execute
2219  * @param	jp2					the jpeg2000 file codec to execute the procedures on.
2220  * @param	stream					the stream to execute the procedures on.
2221  * @param	p_manager			the user manager.
2222  *
2223  * @return	true				if all the procedures were successfully executed.
2224  */
opj_jp2_exec(opj_jp2_t * jp2,opj_procedure_list_t * p_procedure_list,opj_stream_private_t * stream,opj_event_mgr_t * p_manager)2225 static OPJ_BOOL opj_jp2_exec (  opj_jp2_t * jp2,
2226                                 opj_procedure_list_t * p_procedure_list,
2227                                 opj_stream_private_t *stream,
2228                                 opj_event_mgr_t * p_manager
2229                                 )
2230 
2231 {
2232 	OPJ_BOOL (** l_procedure) (opj_jp2_t * jp2, opj_stream_private_t *, opj_event_mgr_t *) = 00;
2233 	OPJ_BOOL l_result = OPJ_TRUE;
2234 	OPJ_UINT32 l_nb_proc, i;
2235 
2236 	/* preconditions */
2237 	assert(p_procedure_list != 00);
2238 	assert(jp2 != 00);
2239 	assert(stream != 00);
2240 	assert(p_manager != 00);
2241 
2242 	l_nb_proc = opj_procedure_list_get_nb_procedures(p_procedure_list);
2243 	l_procedure = (OPJ_BOOL (**) (opj_jp2_t * jp2, opj_stream_private_t *, opj_event_mgr_t *)) opj_procedure_list_get_first_procedure(p_procedure_list);
2244 
2245 	for	(i=0;i<l_nb_proc;++i) {
2246 		l_result = l_result && (*l_procedure) (jp2,stream,p_manager);
2247 		++l_procedure;
2248 	}
2249 
2250 	/* and clear the procedure list at the end. */
2251 	opj_procedure_list_clear(p_procedure_list);
2252 	return l_result;
2253 }
2254 
opj_jp2_start_compress(opj_jp2_t * jp2,opj_stream_private_t * stream,opj_image_t * p_image,opj_event_mgr_t * p_manager)2255 OPJ_BOOL opj_jp2_start_compress(opj_jp2_t *jp2,
2256                                 opj_stream_private_t *stream,
2257                                 opj_image_t * p_image,
2258                                 opj_event_mgr_t * p_manager
2259                                 )
2260 {
2261 	/* preconditions */
2262 	assert(jp2 != 00);
2263 	assert(stream != 00);
2264 	assert(p_manager != 00);
2265 
2266 	/* customization of the validation */
2267 	if (! opj_jp2_setup_encoding_validation (jp2, p_manager)) {
2268 		return OPJ_FALSE;
2269 	}
2270 
2271 	/* validation of the parameters codec */
2272 	if (! opj_jp2_exec(jp2,jp2->m_validation_list,stream,p_manager)) {
2273 		return OPJ_FALSE;
2274 	}
2275 
2276 	/* customization of the encoding */
2277 	if (! opj_jp2_setup_header_writing(jp2, p_manager)) {
2278 		return OPJ_FALSE;
2279 	}
2280 
2281 	/* write header */
2282 	if (! opj_jp2_exec (jp2,jp2->m_procedure_list,stream,p_manager)) {
2283 		return OPJ_FALSE;
2284 	}
2285 
2286 	return opj_j2k_start_compress(jp2->j2k,stream,p_image,p_manager);
2287 }
2288 
opj_jp2_find_handler(OPJ_UINT32 p_id)2289 static const opj_jp2_header_handler_t * opj_jp2_find_handler (OPJ_UINT32 p_id)
2290 {
2291 	OPJ_UINT32 i, l_handler_size = sizeof(jp2_header) / sizeof(opj_jp2_header_handler_t);
2292 
2293 	for (i=0;i<l_handler_size;++i) {
2294 		if (jp2_header[i].id == p_id) {
2295 			return &jp2_header[i];
2296 		}
2297 	}
2298 	return NULL;
2299 }
2300 
2301 /**
2302  * Finds the image execution function related to the given box id.
2303  *
2304  * @param	p_id	the id of the handler to fetch.
2305  *
2306  * @return	the given handler or 00 if it could not be found.
2307  */
opj_jp2_img_find_handler(OPJ_UINT32 p_id)2308 static const opj_jp2_header_handler_t * opj_jp2_img_find_handler (OPJ_UINT32 p_id)
2309 {
2310 	OPJ_UINT32 i, l_handler_size = sizeof(jp2_img_header) / sizeof(opj_jp2_header_handler_t);
2311 	for (i=0;i<l_handler_size;++i)
2312 	{
2313 		if (jp2_img_header[i].id == p_id) {
2314 			return &jp2_img_header[i];
2315 		}
2316 	}
2317 
2318 	return NULL;
2319 }
2320 
2321 /**
2322  * Reads a jpeg2000 file signature box.
2323  *
2324  * @param	p_header_data	the data contained in the signature box.
2325  * @param	jp2				the jpeg2000 file codec.
2326  * @param	p_header_size	the size of the data contained in the signature box.
2327  * @param	p_manager		the user event manager.
2328  *
2329  * @return true if the file signature box is valid.
2330  */
opj_jp2_read_jp(opj_jp2_t * jp2,OPJ_BYTE * p_header_data,OPJ_UINT32 p_header_size,opj_event_mgr_t * p_manager)2331 static OPJ_BOOL opj_jp2_read_jp(opj_jp2_t *jp2,
2332                                 OPJ_BYTE * p_header_data,
2333                                 OPJ_UINT32 p_header_size,
2334                                 opj_event_mgr_t * p_manager
2335                                 )
2336 
2337 {
2338 	OPJ_UINT32 l_magic_number;
2339 
2340 	/* preconditions */
2341 	assert(p_header_data != 00);
2342 	assert(jp2 != 00);
2343 	assert(p_manager != 00);
2344 
2345 	if (jp2->jp2_state != JP2_STATE_NONE) {
2346 		opj_event_msg(p_manager, EVT_ERROR, "The signature box must be the first box in the file.\n");
2347 		return OPJ_FALSE;
2348 	}
2349 
2350 	/* assure length of data is correct (4 -> magic number) */
2351 	if (p_header_size != 4) {
2352 		opj_event_msg(p_manager, EVT_ERROR, "Error with JP signature Box size\n");
2353 		return OPJ_FALSE;
2354 	}
2355 
2356 	/* rearrange data */
2357 	opj_read_bytes(p_header_data,&l_magic_number,4);
2358 	if (l_magic_number != 0x0d0a870a ) {
2359 		opj_event_msg(p_manager, EVT_ERROR, "Error with JP Signature : bad magic number\n");
2360 		return OPJ_FALSE;
2361 	}
2362 
2363 	jp2->jp2_state |= JP2_STATE_SIGNATURE;
2364 
2365 	return OPJ_TRUE;
2366 }
2367 
2368 /**
2369  * Reads a a FTYP box - File type box
2370  *
2371  * @param	p_header_data	the data contained in the FTYP box.
2372  * @param	jp2				the jpeg2000 file codec.
2373  * @param	p_header_size	the size of the data contained in the FTYP box.
2374  * @param	p_manager		the user event manager.
2375  *
2376  * @return true if the FTYP box is valid.
2377  */
opj_jp2_read_ftyp(opj_jp2_t * jp2,OPJ_BYTE * p_header_data,OPJ_UINT32 p_header_size,opj_event_mgr_t * p_manager)2378 static OPJ_BOOL opj_jp2_read_ftyp(	opj_jp2_t *jp2,
2379 									OPJ_BYTE * p_header_data,
2380 									OPJ_UINT32 p_header_size,
2381 									opj_event_mgr_t * p_manager
2382                                     )
2383 {
2384 	OPJ_UINT32 i, l_remaining_bytes;
2385 
2386 	/* preconditions */
2387 	assert(p_header_data != 00);
2388 	assert(jp2 != 00);
2389 	assert(p_manager != 00);
2390 
2391 	if (jp2->jp2_state != JP2_STATE_SIGNATURE) {
2392 		opj_event_msg(p_manager, EVT_ERROR, "The ftyp box must be the second box in the file.\n");
2393 		return OPJ_FALSE;
2394 	}
2395 
2396 	/* assure length of data is correct */
2397 	if (p_header_size < 8) {
2398 		opj_event_msg(p_manager, EVT_ERROR, "Error with FTYP signature Box size\n");
2399 		return OPJ_FALSE;
2400 	}
2401 
2402 	opj_read_bytes(p_header_data,&jp2->brand,4);		/* BR */
2403 	p_header_data += 4;
2404 
2405 	opj_read_bytes(p_header_data,&jp2->minversion,4);		/* MinV */
2406 	p_header_data += 4;
2407 
2408 	l_remaining_bytes = p_header_size - 8;
2409 
2410 	/* the number of remaining bytes should be a multiple of 4 */
2411 	if ((l_remaining_bytes & 0x3) != 0) {
2412 		opj_event_msg(p_manager, EVT_ERROR, "Error with FTYP signature Box size\n");
2413 		return OPJ_FALSE;
2414 	}
2415 
2416 	/* div by 4 */
2417 	jp2->numcl = l_remaining_bytes >> 2;
2418 	if (jp2->numcl) {
2419 		jp2->cl = (OPJ_UINT32 *) opj_calloc(jp2->numcl, sizeof(OPJ_UINT32));
2420 		if (jp2->cl == 00) {
2421 			opj_event_msg(p_manager, EVT_ERROR, "Not enough memory with FTYP Box\n");
2422 			return OPJ_FALSE;
2423 		}
2424 	}
2425 
2426 	for (i = 0; i < jp2->numcl; ++i)
2427 	{
2428 		opj_read_bytes(p_header_data,&jp2->cl[i],4);		/* CLi */
2429 		p_header_data += 4;
2430 	}
2431 
2432 	jp2->jp2_state |= JP2_STATE_FILE_TYPE;
2433 
2434 	return OPJ_TRUE;
2435 }
2436 
opj_jp2_skip_jp2c(opj_jp2_t * jp2,opj_stream_private_t * stream,opj_event_mgr_t * p_manager)2437 static OPJ_BOOL opj_jp2_skip_jp2c(	opj_jp2_t *jp2,
2438 					    	opj_stream_private_t *stream,
2439 					    	opj_event_mgr_t * p_manager )
2440 {
2441 	/* preconditions */
2442 	assert(jp2 != 00);
2443 	assert(stream != 00);
2444 	assert(p_manager != 00);
2445 
2446 	jp2->j2k_codestream_offset = opj_stream_tell(stream);
2447 
2448 	if (opj_stream_skip(stream,8,p_manager) != 8) {
2449 		return OPJ_FALSE;
2450 	}
2451 
2452 	return OPJ_TRUE;
2453 }
2454 
opj_jpip_skip_iptr(opj_jp2_t * jp2,opj_stream_private_t * stream,opj_event_mgr_t * p_manager)2455 static OPJ_BOOL opj_jpip_skip_iptr(	opj_jp2_t *jp2,
2456   opj_stream_private_t *stream,
2457   opj_event_mgr_t * p_manager )
2458 {
2459   /* preconditions */
2460   assert(jp2 != 00);
2461   assert(stream != 00);
2462   assert(p_manager != 00);
2463 
2464   jp2->jpip_iptr_offset = opj_stream_tell(stream);
2465 
2466   if (opj_stream_skip(stream,24,p_manager) != 24) {
2467     return OPJ_FALSE;
2468   }
2469 
2470   return OPJ_TRUE;
2471 }
2472 
2473 /**
2474  * Reads the Jpeg2000 file Header box - JP2 Header box (warning, this is a super box).
2475  *
2476  * @param	p_header_data	the data contained in the file header box.
2477  * @param	jp2				the jpeg2000 file codec.
2478  * @param	p_header_size	the size of the data contained in the file header box.
2479  * @param	p_manager		the user event manager.
2480  *
2481  * @return true if the JP2 Header box was successfully recognized.
2482 */
opj_jp2_read_jp2h(opj_jp2_t * jp2,OPJ_BYTE * p_header_data,OPJ_UINT32 p_header_size,opj_event_mgr_t * p_manager)2483 static OPJ_BOOL opj_jp2_read_jp2h(  opj_jp2_t *jp2,
2484                                     OPJ_BYTE *p_header_data,
2485                                     OPJ_UINT32 p_header_size,
2486                                     opj_event_mgr_t * p_manager
2487                                     )
2488 {
2489 	OPJ_UINT32 l_box_size=0, l_current_data_size = 0;
2490 	opj_jp2_box_t box;
2491 	const opj_jp2_header_handler_t * l_current_handler;
2492 	OPJ_BOOL l_has_ihdr = 0;
2493 
2494 	/* preconditions */
2495 	assert(p_header_data != 00);
2496 	assert(jp2 != 00);
2497 	assert(p_manager != 00);
2498 
2499 	/* make sure the box is well placed */
2500 	if ((jp2->jp2_state & JP2_STATE_FILE_TYPE) != JP2_STATE_FILE_TYPE ) {
2501 		opj_event_msg(p_manager, EVT_ERROR, "The  box must be the first box in the file.\n");
2502 		return OPJ_FALSE;
2503 	}
2504 
2505 	jp2->jp2_img_state = JP2_IMG_STATE_NONE;
2506 
2507 	/* iterate while remaining data */
2508 	while (p_header_size > 0) {
2509 
2510 		if (! opj_jp2_read_boxhdr_char(&box,p_header_data,&l_box_size,p_header_size, p_manager)) {
2511 			opj_event_msg(p_manager, EVT_ERROR, "Stream error while reading JP2 Header box\n");
2512 			return OPJ_FALSE;
2513 		}
2514 
2515 		if (box.length > p_header_size) {
2516 			opj_event_msg(p_manager, EVT_ERROR, "Stream error while reading JP2 Header box: box length is inconsistent.\n");
2517 			return OPJ_FALSE;
2518 		}
2519 
2520 		l_current_handler = opj_jp2_img_find_handler(box.type);
2521 		l_current_data_size = box.length - l_box_size;
2522 		p_header_data += l_box_size;
2523 
2524 		if (l_current_handler != 00) {
2525 			if (! l_current_handler->handler(jp2,p_header_data,l_current_data_size,p_manager)) {
2526 				return OPJ_FALSE;
2527 			}
2528 		}
2529 		else {
2530 			jp2->jp2_img_state |= JP2_IMG_STATE_UNKNOWN;
2531 		}
2532 
2533 		if (box.type == JP2_IHDR) {
2534 			l_has_ihdr = 1;
2535 		}
2536 
2537 		p_header_data += l_current_data_size;
2538 		p_header_size -= box.length;
2539 	}
2540 
2541 	if (l_has_ihdr == 0) {
2542 		opj_event_msg(p_manager, EVT_ERROR, "Stream error while reading JP2 Header box: no 'ihdr' box.\n");
2543 		return OPJ_FALSE;
2544 	}
2545 
2546 	jp2->jp2_state |= JP2_STATE_HEADER;
2547 
2548 	return OPJ_TRUE;
2549 }
2550 
opj_jp2_read_boxhdr_char(opj_jp2_box_t * box,OPJ_BYTE * p_data,OPJ_UINT32 * p_number_bytes_read,OPJ_UINT32 p_box_max_size,opj_event_mgr_t * p_manager)2551 static OPJ_BOOL opj_jp2_read_boxhdr_char(   opj_jp2_box_t *box,
2552                                      OPJ_BYTE * p_data,
2553                                      OPJ_UINT32 * p_number_bytes_read,
2554                                      OPJ_UINT32 p_box_max_size,
2555                                      opj_event_mgr_t * p_manager
2556                                      )
2557 {
2558 	OPJ_UINT32 l_value;
2559 
2560 	/* preconditions */
2561 	assert(p_data != 00);
2562 	assert(box != 00);
2563 	assert(p_number_bytes_read != 00);
2564 	assert(p_manager != 00);
2565 
2566 	if (p_box_max_size < 8) {
2567 		opj_event_msg(p_manager, EVT_ERROR, "Cannot handle box of less than 8 bytes\n");
2568 		return OPJ_FALSE;
2569 	}
2570 
2571 	/* process read data */
2572 	opj_read_bytes(p_data, &l_value, 4);
2573 	p_data += 4;
2574 	box->length = (OPJ_UINT32)(l_value);
2575 
2576 	opj_read_bytes(p_data, &l_value, 4);
2577 	p_data += 4;
2578 	box->type = (OPJ_UINT32)(l_value);
2579 
2580 	*p_number_bytes_read = 8;
2581 
2582 	/* do we have a "special very large box ?" */
2583 	/* read then the XLBox */
2584 	if (box->length == 1) {
2585 		OPJ_UINT32 l_xl_part_size;
2586 
2587 		if (p_box_max_size < 16) {
2588 			opj_event_msg(p_manager, EVT_ERROR, "Cannot handle XL box of less than 16 bytes\n");
2589 			return OPJ_FALSE;
2590 		}
2591 
2592 		opj_read_bytes(p_data,&l_xl_part_size, 4);
2593 		p_data += 4;
2594 		*p_number_bytes_read += 4;
2595 
2596 		if (l_xl_part_size != 0) {
2597 			opj_event_msg(p_manager, EVT_ERROR, "Cannot handle box sizes higher than 2^32\n");
2598 			return OPJ_FALSE;
2599 		}
2600 
2601 		opj_read_bytes(p_data, &l_value, 4);
2602 		*p_number_bytes_read += 4;
2603 		box->length = (OPJ_UINT32)(l_value);
2604 
2605 		if (box->length == 0) {
2606 			opj_event_msg(p_manager, EVT_ERROR, "Cannot handle box of undefined sizes\n");
2607 			return OPJ_FALSE;
2608 		}
2609 	}
2610 	else if (box->length == 0) {
2611 		opj_event_msg(p_manager, EVT_ERROR, "Cannot handle box of undefined sizes\n");
2612 		return OPJ_FALSE;
2613 	}
2614 	if (box->length < *p_number_bytes_read) {
2615 		opj_event_msg(p_manager, EVT_ERROR, "Box length is inconsistent.\n");
2616 		return OPJ_FALSE;
2617 	}
2618 	return OPJ_TRUE;
2619 }
2620 
opj_jp2_read_header(opj_stream_private_t * p_stream,opj_jp2_t * jp2,opj_image_t ** p_image,opj_event_mgr_t * p_manager)2621 OPJ_BOOL opj_jp2_read_header(	opj_stream_private_t *p_stream,
2622                                 opj_jp2_t *jp2,
2623                                 opj_image_t ** p_image,
2624                                 opj_event_mgr_t * p_manager
2625                                 )
2626 {
2627 	/* preconditions */
2628 	assert(jp2 != 00);
2629 	assert(p_stream != 00);
2630 	assert(p_manager != 00);
2631 
2632 	/* customization of the validation */
2633 	if (! opj_jp2_setup_decoding_validation (jp2, p_manager)) {
2634 		return OPJ_FALSE;
2635 	}
2636 
2637 	/* customization of the encoding */
2638 	if (! opj_jp2_setup_header_reading(jp2, p_manager)) {
2639 		return OPJ_FALSE;
2640 	}
2641 
2642 	/* validation of the parameters codec */
2643 	if (! opj_jp2_exec(jp2,jp2->m_validation_list,p_stream,p_manager)) {
2644 		return OPJ_FALSE;
2645 	}
2646 
2647 	/* read header */
2648 	if (! opj_jp2_exec (jp2,jp2->m_procedure_list,p_stream,p_manager)) {
2649 		return OPJ_FALSE;
2650 	}
2651 
2652 	return opj_j2k_read_header(	p_stream,
2653 							jp2->j2k,
2654 							p_image,
2655 							p_manager);
2656 }
2657 
opj_jp2_setup_encoding_validation(opj_jp2_t * jp2,opj_event_mgr_t * p_manager)2658 static OPJ_BOOL opj_jp2_setup_encoding_validation (opj_jp2_t *jp2, opj_event_mgr_t * p_manager)
2659 {
2660 	/* preconditions */
2661 	assert(jp2 != 00);
2662 	assert(p_manager != 00);
2663 
2664 	if (! opj_procedure_list_add_procedure(jp2->m_validation_list, (opj_procedure)opj_jp2_default_validation, p_manager)) {
2665 		return OPJ_FALSE;
2666 	}
2667 	/* DEVELOPER CORNER, add your custom validation procedure */
2668 
2669 	return OPJ_TRUE;
2670 }
2671 
opj_jp2_setup_decoding_validation(opj_jp2_t * jp2,opj_event_mgr_t * p_manager)2672 static OPJ_BOOL opj_jp2_setup_decoding_validation (opj_jp2_t *jp2, opj_event_mgr_t * p_manager)
2673 {
2674 	/* preconditions */
2675 	assert(jp2 != 00);
2676 	assert(p_manager != 00);
2677 
2678 	/* DEVELOPER CORNER, add your custom validation procedure */
2679 
2680 	return OPJ_TRUE;
2681 }
2682 
opj_jp2_setup_header_writing(opj_jp2_t * jp2,opj_event_mgr_t * p_manager)2683 static OPJ_BOOL opj_jp2_setup_header_writing (opj_jp2_t *jp2, opj_event_mgr_t * p_manager)
2684 {
2685 	/* preconditions */
2686 	assert(jp2 != 00);
2687 	assert(p_manager != 00);
2688 
2689 	if (! opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jp2_write_jp, p_manager)) {
2690 		return OPJ_FALSE;
2691 	}
2692 	if (! opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jp2_write_ftyp, p_manager)) {
2693 		return OPJ_FALSE;
2694 	}
2695 	if (! opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jp2_write_jp2h, p_manager)) {
2696 		return OPJ_FALSE;
2697 	}
2698 	if( jp2->jpip_on ) {
2699 		if (! opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jpip_skip_iptr, p_manager)) {
2700 			return OPJ_FALSE;
2701 		}
2702 	}
2703 	if (! opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jp2_skip_jp2c,p_manager)) {
2704 		return OPJ_FALSE;
2705 	}
2706 
2707 	/* DEVELOPER CORNER, insert your custom procedures */
2708 
2709 	return OPJ_TRUE;
2710 }
2711 
opj_jp2_setup_header_reading(opj_jp2_t * jp2,opj_event_mgr_t * p_manager)2712 static OPJ_BOOL opj_jp2_setup_header_reading (opj_jp2_t *jp2, opj_event_mgr_t * p_manager)
2713 {
2714 	/* preconditions */
2715 	assert(jp2 != 00);
2716 	assert(p_manager != 00);
2717 
2718 	if (! opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jp2_read_header_procedure, p_manager)) {
2719 		return OPJ_FALSE;
2720 	}
2721 
2722 	/* DEVELOPER CORNER, add your custom procedures */
2723 
2724 	return OPJ_TRUE;
2725 }
2726 
opj_jp2_read_tile_header(opj_jp2_t * p_jp2,OPJ_UINT32 * p_tile_index,OPJ_UINT32 * p_data_size,OPJ_INT32 * p_tile_x0,OPJ_INT32 * p_tile_y0,OPJ_INT32 * p_tile_x1,OPJ_INT32 * p_tile_y1,OPJ_UINT32 * p_nb_comps,OPJ_BOOL * p_go_on,opj_stream_private_t * p_stream,opj_event_mgr_t * p_manager)2727 OPJ_BOOL opj_jp2_read_tile_header ( opj_jp2_t * p_jp2,
2728                                     OPJ_UINT32 * p_tile_index,
2729                                     OPJ_UINT32 * p_data_size,
2730                                     OPJ_INT32 * p_tile_x0,
2731                                     OPJ_INT32 * p_tile_y0,
2732                                     OPJ_INT32 * p_tile_x1,
2733                                     OPJ_INT32 * p_tile_y1,
2734                                     OPJ_UINT32 * p_nb_comps,
2735                                     OPJ_BOOL * p_go_on,
2736                                     opj_stream_private_t *p_stream,
2737                                     opj_event_mgr_t * p_manager
2738                                     )
2739 {
2740 	return opj_j2k_read_tile_header(p_jp2->j2k,
2741 								p_tile_index,
2742 								p_data_size,
2743 								p_tile_x0, p_tile_y0,
2744 								p_tile_x1, p_tile_y1,
2745 								p_nb_comps,
2746 								p_go_on,
2747 								p_stream,
2748 								p_manager);
2749 }
2750 
opj_jp2_write_tile(opj_jp2_t * p_jp2,OPJ_UINT32 p_tile_index,OPJ_BYTE * p_data,OPJ_UINT32 p_data_size,opj_stream_private_t * p_stream,opj_event_mgr_t * p_manager)2751 OPJ_BOOL opj_jp2_write_tile (	opj_jp2_t *p_jp2,
2752 					 	 	    OPJ_UINT32 p_tile_index,
2753 					 	 	    OPJ_BYTE * p_data,
2754 					 	 	    OPJ_UINT32 p_data_size,
2755 					 	 	    opj_stream_private_t *p_stream,
2756 					 	 	    opj_event_mgr_t * p_manager
2757                                 )
2758 
2759 {
2760 	return opj_j2k_write_tile (p_jp2->j2k,p_tile_index,p_data,p_data_size,p_stream,p_manager);
2761 }
2762 
opj_jp2_decode_tile(opj_jp2_t * p_jp2,OPJ_UINT32 p_tile_index,OPJ_BYTE * p_data,OPJ_UINT32 p_data_size,opj_stream_private_t * p_stream,opj_event_mgr_t * p_manager)2763 OPJ_BOOL opj_jp2_decode_tile (  opj_jp2_t * p_jp2,
2764                                 OPJ_UINT32 p_tile_index,
2765                                 OPJ_BYTE * p_data,
2766                                 OPJ_UINT32 p_data_size,
2767                                 opj_stream_private_t *p_stream,
2768                                 opj_event_mgr_t * p_manager
2769                                 )
2770 {
2771 	return opj_j2k_decode_tile (p_jp2->j2k,p_tile_index,p_data,p_data_size,p_stream,p_manager);
2772 }
2773 
opj_jp2_destroy(opj_jp2_t * jp2)2774 void opj_jp2_destroy(opj_jp2_t *jp2)
2775 {
2776 	if (jp2) {
2777 		/* destroy the J2K codec */
2778 		opj_j2k_destroy(jp2->j2k);
2779 		jp2->j2k = 00;
2780 
2781 		if (jp2->comps) {
2782 			opj_free(jp2->comps);
2783 			jp2->comps = 00;
2784 		}
2785 
2786 		if (jp2->cl) {
2787 			opj_free(jp2->cl);
2788 			jp2->cl = 00;
2789 		}
2790 
2791 		if (jp2->color.icc_profile_buf) {
2792 			opj_free(jp2->color.icc_profile_buf);
2793 			jp2->color.icc_profile_buf = 00;
2794 		}
2795 
2796 		if (jp2->color.jp2_cdef) {
2797 			if (jp2->color.jp2_cdef->info) {
2798 				opj_free(jp2->color.jp2_cdef->info);
2799 				jp2->color.jp2_cdef->info = NULL;
2800 			}
2801 
2802 			opj_free(jp2->color.jp2_cdef);
2803 			jp2->color.jp2_cdef = 00;
2804 		}
2805 
2806 		if (jp2->color.jp2_pclr) {
2807 			if (jp2->color.jp2_pclr->cmap) {
2808 				opj_free(jp2->color.jp2_pclr->cmap);
2809 				jp2->color.jp2_pclr->cmap = NULL;
2810 			}
2811 			if (jp2->color.jp2_pclr->channel_sign) {
2812 				opj_free(jp2->color.jp2_pclr->channel_sign);
2813 				jp2->color.jp2_pclr->channel_sign = NULL;
2814 			}
2815 			if (jp2->color.jp2_pclr->channel_size) {
2816 				opj_free(jp2->color.jp2_pclr->channel_size);
2817 				jp2->color.jp2_pclr->channel_size = NULL;
2818 			}
2819 			if (jp2->color.jp2_pclr->entries) {
2820 				opj_free(jp2->color.jp2_pclr->entries);
2821 				jp2->color.jp2_pclr->entries = NULL;
2822 			}
2823 
2824 			opj_free(jp2->color.jp2_pclr);
2825 			jp2->color.jp2_pclr = 00;
2826 		}
2827 
2828 		if (jp2->m_validation_list) {
2829 			opj_procedure_list_destroy(jp2->m_validation_list);
2830 			jp2->m_validation_list = 00;
2831 		}
2832 
2833 		if (jp2->m_procedure_list) {
2834 			opj_procedure_list_destroy(jp2->m_procedure_list);
2835 			jp2->m_procedure_list = 00;
2836 		}
2837 
2838 		opj_free(jp2);
2839 	}
2840 }
2841 
opj_jp2_set_decode_area(opj_jp2_t * p_jp2,opj_image_t * p_image,OPJ_INT32 p_start_x,OPJ_INT32 p_start_y,OPJ_INT32 p_end_x,OPJ_INT32 p_end_y,opj_event_mgr_t * p_manager)2842 OPJ_BOOL opj_jp2_set_decode_area(	opj_jp2_t *p_jp2,
2843 								    opj_image_t* p_image,
2844 								    OPJ_INT32 p_start_x, OPJ_INT32 p_start_y,
2845 								    OPJ_INT32 p_end_x, OPJ_INT32 p_end_y,
2846 								    opj_event_mgr_t * p_manager
2847                                     )
2848 {
2849 	return opj_j2k_set_decode_area(p_jp2->j2k, p_image, p_start_x, p_start_y, p_end_x, p_end_y, p_manager);
2850 }
2851 
opj_jp2_get_tile(opj_jp2_t * p_jp2,opj_stream_private_t * p_stream,opj_image_t * p_image,opj_event_mgr_t * p_manager,OPJ_UINT32 tile_index)2852 OPJ_BOOL opj_jp2_get_tile(	opj_jp2_t *p_jp2,
2853                             opj_stream_private_t *p_stream,
2854                             opj_image_t* p_image,
2855                             opj_event_mgr_t * p_manager,
2856                             OPJ_UINT32 tile_index
2857                             )
2858 {
2859 	if (!p_image)
2860 		return OPJ_FALSE;
2861 
2862 	opj_event_msg(p_manager, EVT_WARNING, "JP2 box which are after the codestream will not be read by this function.\n");
2863 
2864 	if (! opj_j2k_get_tile(p_jp2->j2k, p_stream, p_image, p_manager, tile_index) ){
2865 		opj_event_msg(p_manager, EVT_ERROR, "Failed to decode the codestream in the JP2 file\n");
2866 		return OPJ_FALSE;
2867 	}
2868 
2869 	if (!opj_jp2_check_color(p_image, &(p_jp2->color), p_manager)) {
2870 		return OPJ_FALSE;
2871 	}
2872 
2873 	/* Set Image Color Space */
2874 	if (p_jp2->enumcs == 16)
2875 		p_image->color_space = OPJ_CLRSPC_SRGB;
2876 	else if (p_jp2->enumcs == 17)
2877 		p_image->color_space = OPJ_CLRSPC_GRAY;
2878 	else if (p_jp2->enumcs == 18)
2879 		p_image->color_space = OPJ_CLRSPC_SYCC;
2880 	else if (p_jp2->enumcs == 24)
2881 		p_image->color_space = OPJ_CLRSPC_EYCC;
2882 	else if (p_jp2->enumcs == 12)
2883 		p_image->color_space = OPJ_CLRSPC_CMYK;
2884 	else
2885 		p_image->color_space = OPJ_CLRSPC_UNKNOWN;
2886 
2887 	if(p_jp2->color.jp2_pclr) {
2888 		/* Part 1, I.5.3.4: Either both or none : */
2889 		if( !p_jp2->color.jp2_pclr->cmap)
2890 			opj_jp2_free_pclr(&(p_jp2->color));
2891 		else
2892 			opj_jp2_apply_pclr(p_image, &(p_jp2->color));
2893 	}
2894 
2895 	/* Apply the color space if needed */
2896 	if(p_jp2->color.jp2_cdef) {
2897 		opj_jp2_apply_cdef(p_image, &(p_jp2->color), p_manager);
2898 	}
2899 
2900 	if(p_jp2->color.icc_profile_buf) {
2901 		p_image->icc_profile_buf = p_jp2->color.icc_profile_buf;
2902 		p_image->icc_profile_len = p_jp2->color.icc_profile_len;
2903 		p_jp2->color.icc_profile_buf = NULL;
2904 	}
2905 
2906 	return OPJ_TRUE;
2907 }
2908 
2909 /* ----------------------------------------------------------------------- */
2910 /* JP2 encoder interface                                             */
2911 /* ----------------------------------------------------------------------- */
2912 
opj_jp2_create(OPJ_BOOL p_is_decoder)2913 opj_jp2_t* opj_jp2_create(OPJ_BOOL p_is_decoder)
2914 {
2915 	opj_jp2_t *jp2 = (opj_jp2_t*)opj_calloc(1,sizeof(opj_jp2_t));
2916 	if (jp2) {
2917 
2918 		/* create the J2K codec */
2919 		if (! p_is_decoder) {
2920 			jp2->j2k = opj_j2k_create_compress();
2921 		}
2922 		else {
2923 			jp2->j2k = opj_j2k_create_decompress();
2924 		}
2925 
2926 		if (jp2->j2k == 00) {
2927 			opj_jp2_destroy(jp2);
2928 			return 00;
2929 		}
2930 
2931 		/* Color structure */
2932 		jp2->color.icc_profile_buf = NULL;
2933 		jp2->color.icc_profile_len = 0;
2934 		jp2->color.jp2_cdef = NULL;
2935 		jp2->color.jp2_pclr = NULL;
2936 		jp2->color.jp2_has_colr = 0;
2937 
2938 		/* validation list creation */
2939 		jp2->m_validation_list = opj_procedure_list_create();
2940 		if (! jp2->m_validation_list) {
2941 			opj_jp2_destroy(jp2);
2942 			return 00;
2943 		}
2944 
2945 		/* execution list creation */
2946 		jp2->m_procedure_list = opj_procedure_list_create();
2947 		if (! jp2->m_procedure_list) {
2948 			opj_jp2_destroy(jp2);
2949 			return 00;
2950 		}
2951 	}
2952 
2953 	return jp2;
2954 }
2955 
jp2_dump(opj_jp2_t * p_jp2,OPJ_INT32 flag,FILE * out_stream)2956 void jp2_dump(opj_jp2_t* p_jp2, OPJ_INT32 flag, FILE* out_stream)
2957 {
2958 	/* preconditions */
2959 	assert(p_jp2 != 00);
2960 
2961 	j2k_dump(p_jp2->j2k,
2962 					flag,
2963 					out_stream);
2964 }
2965 
jp2_get_cstr_index(opj_jp2_t * p_jp2)2966 opj_codestream_index_t* jp2_get_cstr_index(opj_jp2_t* p_jp2)
2967 {
2968 	return j2k_get_cstr_index(p_jp2->j2k);
2969 }
2970 
jp2_get_cstr_info(opj_jp2_t * p_jp2)2971 opj_codestream_info_v2_t* jp2_get_cstr_info(opj_jp2_t* p_jp2)
2972 {
2973 	return j2k_get_cstr_info(p_jp2->j2k);
2974 }
2975 
opj_jp2_set_decoded_resolution_factor(opj_jp2_t * p_jp2,OPJ_UINT32 res_factor,opj_event_mgr_t * p_manager)2976 OPJ_BOOL opj_jp2_set_decoded_resolution_factor(opj_jp2_t *p_jp2,
2977                                                OPJ_UINT32 res_factor,
2978                                                opj_event_mgr_t * p_manager)
2979 {
2980 	return opj_j2k_set_decoded_resolution_factor(p_jp2->j2k, res_factor, p_manager);
2981 }
2982 
2983 /* JPIP specific */
2984 
2985 #ifdef USE_JPIP
opj_jpip_write_iptr(opj_jp2_t * jp2,opj_stream_private_t * cio,opj_event_mgr_t * p_manager)2986 static OPJ_BOOL opj_jpip_write_iptr(opj_jp2_t *jp2,
2987   opj_stream_private_t *cio,
2988   opj_event_mgr_t * p_manager )
2989 {
2990   OPJ_OFF_T j2k_codestream_exit;
2991   OPJ_BYTE l_data_header [24];
2992 
2993   /* preconditions */
2994   assert(jp2 != 00);
2995   assert(cio != 00);
2996   assert(p_manager != 00);
2997   assert(opj_stream_has_seek(cio));
2998 
2999   j2k_codestream_exit = opj_stream_tell(cio);
3000   opj_write_bytes(l_data_header, 24, 4); /* size of iptr */
3001   opj_write_bytes(l_data_header + 4,JPIP_IPTR,4);									   /* IPTR */
3002 #if 0
3003   opj_write_bytes(l_data_header + 4 + 4, 0, 8); /* offset */
3004   opj_write_bytes(l_data_header + 8 + 8, 0, 8); /* length */
3005 #else
3006   opj_write_double(l_data_header + 4 + 4, 0); /* offset */
3007   opj_write_double(l_data_header + 8 + 8, 0); /* length */
3008 #endif
3009 
3010   if (! opj_stream_seek(cio,jp2->jpip_iptr_offset,p_manager)) {
3011     opj_event_msg(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
3012     return OPJ_FALSE;
3013   }
3014 
3015   if (opj_stream_write_data(cio,l_data_header,24,p_manager) != 24) {
3016     opj_event_msg(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
3017     return OPJ_FALSE;
3018   }
3019 
3020   if (! opj_stream_seek(cio,j2k_codestream_exit,p_manager)) {
3021     opj_event_msg(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
3022     return OPJ_FALSE;
3023   }
3024 
3025   return OPJ_TRUE;
3026 }
3027 
opj_jpip_write_fidx(opj_jp2_t * jp2,opj_stream_private_t * cio,opj_event_mgr_t * p_manager)3028 static OPJ_BOOL opj_jpip_write_fidx(opj_jp2_t *jp2,
3029   opj_stream_private_t *cio,
3030   opj_event_mgr_t * p_manager )
3031 {
3032   OPJ_OFF_T j2k_codestream_exit;
3033   OPJ_BYTE l_data_header [24];
3034 
3035   /* preconditions */
3036   assert(jp2 != 00);
3037   assert(cio != 00);
3038   assert(p_manager != 00);
3039   assert(opj_stream_has_seek(cio));
3040 
3041   opj_write_bytes(l_data_header, 24, 4); /* size of iptr */
3042   opj_write_bytes(l_data_header + 4,JPIP_FIDX,4);									   /* IPTR */
3043   opj_write_double(l_data_header + 4 + 4, 0); /* offset */
3044   opj_write_double(l_data_header + 8 + 8, 0); /* length */
3045 
3046   if (opj_stream_write_data(cio,l_data_header,24,p_manager) != 24) {
3047     opj_event_msg(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
3048     return OPJ_FALSE;
3049   }
3050 
3051   j2k_codestream_exit = opj_stream_tell(cio);
3052   if (! opj_stream_seek(cio,j2k_codestream_exit,p_manager)) {
3053     opj_event_msg(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
3054     return OPJ_FALSE;
3055   }
3056 
3057   return OPJ_TRUE;
3058 }
3059 
opj_jpip_write_cidx(opj_jp2_t * jp2,opj_stream_private_t * cio,opj_event_mgr_t * p_manager)3060 static OPJ_BOOL opj_jpip_write_cidx(opj_jp2_t *jp2,
3061   opj_stream_private_t *cio,
3062   opj_event_mgr_t * p_manager )
3063 {
3064   OPJ_OFF_T j2k_codestream_exit;
3065   OPJ_BYTE l_data_header [24];
3066 
3067   /* preconditions */
3068   assert(jp2 != 00);
3069   assert(cio != 00);
3070   assert(p_manager != 00);
3071   assert(opj_stream_has_seek(cio));
3072 
3073   j2k_codestream_exit = opj_stream_tell(cio);
3074   opj_write_bytes(l_data_header, 24, 4); /* size of iptr */
3075   opj_write_bytes(l_data_header + 4,JPIP_CIDX,4);									   /* IPTR */
3076 #if 0
3077   opj_write_bytes(l_data_header + 4 + 4, 0, 8); /* offset */
3078   opj_write_bytes(l_data_header + 8 + 8, 0, 8); /* length */
3079 #else
3080   opj_write_double(l_data_header + 4 + 4, 0); /* offset */
3081   opj_write_double(l_data_header + 8 + 8, 0); /* length */
3082 #endif
3083 
3084   if (! opj_stream_seek(cio,j2k_codestream_exit,p_manager)) {
3085     opj_event_msg(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
3086     return OPJ_FALSE;
3087   }
3088 
3089   if (opj_stream_write_data(cio,l_data_header,24,p_manager) != 24) {
3090     opj_event_msg(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
3091     return OPJ_FALSE;
3092   }
3093 
3094   j2k_codestream_exit = opj_stream_tell(cio);
3095   if (! opj_stream_seek(cio,j2k_codestream_exit,p_manager)) {
3096     opj_event_msg(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
3097     return OPJ_FALSE;
3098   }
3099 
3100   return OPJ_TRUE;
3101 }
3102 
3103 #if 0
3104 static void write_prxy( int offset_jp2c, int length_jp2c, int offset_idx, int length_idx, opj_stream_private_t *cio,
3105   opj_event_mgr_t * p_manager )
3106 {
3107   OPJ_BYTE l_data_header [8];
3108   OPJ_OFF_T len, lenp;
3109 
3110   lenp = opj_stream_tell(cio);
3111   opj_stream_skip(cio, 4, p_manager);         /* L [at the end] */
3112   opj_write_bytes(l_data_header,JPIP_PRXY,4); /* IPTR           */
3113   opj_stream_write_data(cio,l_data_header,4,p_manager);
3114 
3115   opj_write_bytes( l_data_header, offset_jp2c, 8); /* OOFF           */
3116   opj_stream_write_data(cio,l_data_header,8,p_manager);
3117   opj_write_bytes( l_data_header, length_jp2c, 4); /* OBH part 1     */
3118   opj_write_bytes( l_data_header+4, JP2_JP2C, 4);  /* OBH part 2     */
3119   opj_stream_write_data(cio,l_data_header,8,p_manager);
3120 
3121   opj_write_bytes( l_data_header, 1, 1);/* NI             */
3122   opj_stream_write_data(cio,l_data_header,1,p_manager);
3123 
3124   opj_write_bytes( l_data_header, offset_idx, 8);  /* IOFF           */
3125   opj_stream_write_data(cio,l_data_header,8,p_manager);
3126   opj_write_bytes( l_data_header, length_idx, 4);  /* IBH part 1     */
3127   opj_write_bytes( l_data_header+4, JPIP_CIDX, 4);   /* IBH part 2     */
3128   opj_stream_write_data(cio,l_data_header,8,p_manager);
3129 
3130   len = opj_stream_tell(cio)-lenp;
3131   opj_stream_skip(cio, lenp, p_manager);
3132   opj_write_bytes(l_data_header,len,4);/* L              */
3133   opj_stream_write_data(cio,l_data_header,4,p_manager);
3134   opj_stream_seek(cio, lenp+len,p_manager);
3135 }
3136 #endif
3137 
3138 
3139 #if 0
3140 static int write_fidx( int offset_jp2c, int length_jp2c, int offset_idx, int length_idx, opj_stream_private_t *cio,
3141   opj_event_mgr_t * p_manager )
3142 {
3143   OPJ_BYTE l_data_header [4];
3144   OPJ_OFF_T len, lenp;
3145 
3146   lenp = opj_stream_tell(cio);
3147   opj_stream_skip(cio, 4, p_manager);
3148   opj_write_bytes(l_data_header,JPIP_FIDX,4); /* FIDX */
3149   opj_stream_write_data(cio,l_data_header,4,p_manager);
3150 
3151   write_prxy( offset_jp2c, length_jp2c, offset_idx, length_idx, cio,p_manager);
3152 
3153   len = opj_stream_tell(cio)-lenp;
3154   opj_stream_skip(cio, lenp, p_manager);
3155   opj_write_bytes(l_data_header,len,4);/* L              */
3156   opj_stream_write_data(cio,l_data_header,4,p_manager);
3157   opj_stream_seek(cio, lenp+len,p_manager);
3158 
3159   return len;
3160 }
3161 #endif
3162 #endif /* USE_JPIP */
3163