* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* Copyright (c) 2010-2011, Kaori Hagihara
+ * Copyright (c) 2008;2011-2012, Centre National d'Etudes Spatiales (CNES), France
+ * Copyright (c) 2012, CS Systemes d'Information, France
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
/** @defgroup JP2 JP2 - JPEG-2000 file format reader/writer */
/*@{*/
-#define BOX_SIZE 1024
+#define OPJ_BOX_SIZE 1024
/** @name Local static functions */
/*@{*/
*
* @return true if the image header is valid, false else.
*/
-static opj_bool opj_jp2_read_ihdr( opj_jp2_t *jp2,
+static OPJ_BOOL 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 );
*
* @return true if the bpc header is valid, fale else.
*/
-static opj_bool opj_jp2_read_bpcc( opj_jp2_t *jp2,
+static OPJ_BOOL 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 );
-static opj_bool opj_jp2_read_cdef( opj_jp2_t * jp2,
+static OPJ_BOOL 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 );
*
* @return true if writing was successful.
*/
-static opj_bool opj_jp2_write_ftyp( opj_jp2_t *jp2,
+static OPJ_BOOL opj_jp2_write_ftyp( opj_jp2_t *jp2,
opj_stream_private_t *cio,
opj_event_mgr_t * p_manager );
*
* @return true if the FTYP box is valid.
*/
-static opj_bool opj_jp2_read_ftyp( opj_jp2_t *jp2,
+static OPJ_BOOL opj_jp2_read_ftyp( opj_jp2_t *jp2,
OPJ_BYTE * p_header_data,
OPJ_UINT32 p_header_size,
opj_event_mgr_t * p_manager );
-opj_bool opj_jp2_skip_jp2c( opj_jp2_t *jp2,
+OPJ_BOOL opj_jp2_skip_jp2c( opj_jp2_t *jp2,
opj_stream_private_t *cio,
opj_event_mgr_t * p_manager );
*
* @return true if the JP2 Header box was successfully reconized.
*/
-static opj_bool opj_jp2_read_jp2h( opj_jp2_t *jp2,
+static OPJ_BOOL opj_jp2_read_jp2h( opj_jp2_t *jp2,
OPJ_BYTE *p_header_data,
OPJ_UINT32 p_header_size,
opj_event_mgr_t * p_manager );
*
* @return true if writing was successful.
*/
-static opj_bool opj_jp2_write_jp2c( opj_jp2_t *jp2,
+static OPJ_BOOL opj_jp2_write_jp2c( opj_jp2_t *jp2,
opj_stream_private_t *cio,
opj_event_mgr_t * p_manager );
* @param jp2 the jpeg2000 file codec.
* @param p_manager user event manager.
*/
-static opj_bool opj_jpip_write_iptr( opj_jp2_t *jp2,
+static OPJ_BOOL opj_jpip_write_iptr( opj_jp2_t *jp2,
opj_stream_private_t *cio,
opj_event_mgr_t * p_manager );
* @param jp2 the jpeg2000 file codec.
* @param p_manager user event manager.
*/
-static opj_bool opj_jpip_write_cidx(opj_jp2_t *jp2,
+static OPJ_BOOL opj_jpip_write_cidx(opj_jp2_t *jp2,
opj_stream_private_t *cio,
opj_event_mgr_t * p_manager );
* @param jp2 the jpeg2000 file codec.
* @param p_manager user event manager.
*/
-static opj_bool opj_jpip_write_fidx(opj_jp2_t *jp2,
+static OPJ_BOOL opj_jpip_write_fidx(opj_jp2_t *jp2,
opj_stream_private_t *cio,
opj_event_mgr_t * p_manager );
#endif /* USE_JPIP */
*
* @return true if the file signature box is valid.
*/
-static opj_bool opj_jp2_read_jp(opj_jp2_t *jp2,
+static OPJ_BOOL opj_jp2_read_jp(opj_jp2_t *jp2,
OPJ_BYTE * p_header_data,
OPJ_UINT32 p_header_size,
opj_event_mgr_t * p_manager);
*
* @return true if writing was successful.
*/
-static opj_bool opj_jp2_write_jp( opj_jp2_t *jp2,
+static OPJ_BOOL opj_jp2_write_jp( opj_jp2_t *jp2,
opj_stream_private_t *cio,
opj_event_mgr_t * p_manager );
*
* @return Returns true if successful, returns false otherwise
*/
-static opj_bool opj_jp2_read_pclr( opj_jp2_t *jp2,
+static OPJ_BOOL 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 );
* @return Returns true if successful, returns false otherwise
*/
-static opj_bool opj_jp2_read_cmap( opj_jp2_t * jp2,
+static OPJ_BOOL 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 );
*
* @return true if the bpc header is valid, fale else.
*/
-static opj_bool opj_jp2_read_colr( opj_jp2_t *jp2,
+static OPJ_BOOL 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 );
*
* @return true if the box is valid.
*/
-static opj_bool opj_jp2_read_header_procedure( opj_jp2_t *jp2,
+static OPJ_BOOL opj_jp2_read_header_procedure( opj_jp2_t *jp2,
opj_stream_private_t *stream,
opj_event_mgr_t * p_manager );
*
* @return true if all the procedures were successfully executed.
*/
-static opj_bool opj_jp2_exec ( opj_jp2_t * jp2,
+static OPJ_BOOL 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 );
*
* @return true if the box is reconized, false otherwise
*/
-static opj_bool opj_jp2_read_boxhdr(opj_jp2_box_t *box,
+static OPJ_BOOL 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);
*/
static void opj_jp2_setup_header_writing (opj_jp2_t *jp2);
-opj_bool opj_jp2_default_validation ( opj_jp2_t * jp2,
+OPJ_BOOL opj_jp2_default_validation ( opj_jp2_t * jp2,
opj_stream_private_t *cio,
opj_event_mgr_t * p_manager );
*
* @return true if the box is reconized, false otherwise
*/
-static opj_bool opj_jp2_read_boxhdr_char( opj_jp2_box_t *box,
+static OPJ_BOOL 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,
static void opj_jp2_setup_header_reading (opj_jp2_t *jp2);
/* ----------------------------------------------------------------------- */
-
- opj_bool 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
- )
+ OPJ_BOOL 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 )
{
/* read header from file */
OPJ_BYTE l_data_header [8];
/* process read data */
opj_read_bytes(l_data_header,&(box->length), 4);
opj_read_bytes(l_data_header+4,&(box->type), 4);
+
+ if(box->length == 0)/* last box */
+ {
+ box->length = opj_stream_get_number_byte_left(cio);
+ return OPJ_TRUE;
+ }
/* do we have a "special very large box ?" */
/* read then the XLBox */
return OPJ_FALSE;
}
+ *p_number_bytes_read = 16;
opj_read_bytes(l_data_header,&l_xl_part_size, 4);
if (l_xl_part_size != 0) {
opj_event_msg(p_manager, EVT_ERROR, "Cannot handle box sizes higher than 2^32\n");
return OPJ_FALSE;
}
- opj_read_bytes(l_data_header,&(box->length), 4);
+ opj_read_bytes(l_data_header+4,&(box->length), 4);
}
- return OPJ_TRUE;
+ return OPJ_TRUE;
}
#if 0
}
#endif
-opj_bool opj_jp2_read_ihdr( opj_jp2_t *jp2,
+OPJ_BOOL 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 )
return l_bpcc_data;
}
-opj_bool opj_jp2_read_bpcc( opj_jp2_t *jp2,
+OPJ_BOOL 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
/* preconditions */
assert(jp2 != 00);
assert(p_nb_bytes_written != 00);
+ assert(jp2->meth == 1 || jp2->meth == 2);
- switch (jp2->meth) {
+ switch (jp2->meth) {
case 1 :
- l_colr_size += 4;
+ l_colr_size += 4; /* EnumCS */
break;
case 2 :
- ++l_colr_size;
+ assert(jp2->color.icc_profile_len); /* ICC profile */
+ l_colr_size += jp2->color.icc_profile_len;
break;
default :
return 00;
opj_write_bytes(l_current_colr_ptr, jp2->approx,1); /* APPROX */
++l_current_colr_ptr;
- if (jp2->meth == 1) {
- opj_write_bytes(l_current_colr_ptr, jp2->enumcs,4); /* EnumCS */
- }
- else {
- opj_write_bytes(l_current_colr_ptr, 0, 1); /* PROFILE (??) */
+ if (jp2->meth == 1) { /* Meth value is restricted to 1 or 2 (Table I.9 of part 1) */
+ opj_write_bytes(l_current_colr_ptr, jp2->enumcs,4); } /* EnumCS */
+ else {
+ if (jp2->meth == 2) { /* ICC profile */
+ OPJ_UINT32 i;
+ for(i = 0; i < jp2->color.icc_profile_len; ++i) {
+ opj_write_bytes(l_current_colr_ptr, jp2->color.icc_profile_buf[i], 1);
+ ++l_current_colr_ptr;
+ }
+ }
}
*p_nb_bytes_written = l_colr_size;
opj_free(color->jp2_pclr); color->jp2_pclr = NULL;
}
+static OPJ_BOOL opj_jp2_check_color(opj_image_t *image, opj_jp2_color_t *color, opj_event_mgr_t *p_manager)
+{
+ OPJ_UINT16 i;
+
+ /* testcase 4149.pdf.SIGSEGV.cf7.3501 */
+ if (color->jp2_cdef) {
+ opj_jp2_cdef_info_t *info = color->jp2_cdef->info;
+ OPJ_UINT16 n = color->jp2_cdef->n;
+
+ for (i = 0; i < n; i++) {
+ if (info[i].cn >= image->numcomps) {
+ opj_event_msg(p_manager, EVT_ERROR, "Invalid component index %d (>= %d).\n", info[i].cn, image->numcomps);
+ return OPJ_FALSE;
+ }
+ if (info[i].asoc > 0 && (OPJ_UINT32)(info[i].asoc - 1) >= image->numcomps) {
+ opj_event_msg(p_manager, EVT_ERROR, "Invalid component index %d (>= %d).\n", info[i].asoc - 1, image->numcomps);
+ return OPJ_FALSE;
+ }
+ }
+ }
+
+ /* testcases 451.pdf.SIGSEGV.f4c.3723, 451.pdf.SIGSEGV.5b5.3723 and
+ 66ea31acbb0f23a2bbc91f64d69a03f5_signal_sigsegv_13937c0_7030_5725.pdf */
+ if (color->jp2_pclr && color->jp2_pclr->cmap) {
+ OPJ_UINT16 nr_channels = color->jp2_pclr->nr_channels;
+ opj_jp2_cmap_comp_t *cmap = color->jp2_pclr->cmap;
+ OPJ_BOOL *pcol_usage, is_sane = OPJ_TRUE;
+
+ /* verify that all original components match an existing one */
+ for (i = 0; i < nr_channels; i++) {
+ if (cmap[i].cmp >= image->numcomps) {
+ opj_event_msg(p_manager, EVT_ERROR, "Invalid component index %d (>= %d).\n", cmap[i].cmp, image->numcomps);
+ is_sane = OPJ_FALSE;
+ }
+ }
+
+ pcol_usage = opj_calloc(nr_channels, sizeof(OPJ_BOOL));
+ if (!pcol_usage) {
+ opj_event_msg(p_manager, EVT_ERROR, "Unexpected OOM.\n");
+ return OPJ_FALSE;
+ }
+ /* verify that no component is targeted more than once */
+ for (i = 0; i < nr_channels; i++) {
+ OPJ_UINT16 pcol = cmap[i].pcol;
+ if (pcol >= nr_channels) {
+ opj_event_msg(p_manager, EVT_ERROR, "Invalid component/palette index for direct mapping %d.\n", pcol);
+ is_sane = OPJ_FALSE;
+ }
+ else if (pcol_usage[pcol]) {
+ opj_event_msg(p_manager, EVT_ERROR, "Component %d is mapped twice.\n", pcol);
+ is_sane = OPJ_FALSE;
+ }
+ else
+ pcol_usage[pcol] = OPJ_TRUE;
+ }
+ /* verify that all components are targeted at least once */
+ for (i = 0; i < nr_channels; i++) {
+ if (!pcol_usage[i]) {
+ opj_event_msg(p_manager, EVT_ERROR, "Component %d doesn't have a mapping.\n", i);
+ is_sane = OPJ_FALSE;
+ }
+ }
+ opj_free(pcol_usage);
+ if (!is_sane) {
+ return OPJ_FALSE;
+ }
+ }
+
+ return OPJ_TRUE;
+}
+
+/* file9.jp2 */
void opj_jp2_apply_pclr(opj_image_t *image, opj_jp2_color_t *color)
{
opj_image_comp_t *old_comps, *new_comps;
}/* apply_pclr() */
-opj_bool opj_jp2_read_pclr( opj_jp2_t *jp2,
+OPJ_BOOL 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
OPJ_UINT16 nr_entries,nr_channels;
OPJ_UINT16 i, j;
OPJ_UINT32 l_value;
+ OPJ_BYTE *orig_header_data = p_pclr_header_data;
/* preconditions */
assert(p_pclr_header_data != 00);
if(jp2->color.jp2_pclr)
return OPJ_FALSE;
+ if (p_pclr_header_size < 3)
+ return OPJ_FALSE;
+
opj_read_bytes(p_pclr_header_data, &l_value , 2); /* NE */
p_pclr_header_data += 2;
nr_entries = (OPJ_UINT16) l_value;
++p_pclr_header_data;
nr_channels = (OPJ_UINT16) l_value;
+ if (p_pclr_header_size < 3 + (OPJ_UINT32)nr_channels || nr_channels == 0 || nr_entries >= (OPJ_UINT32)-1 / nr_channels)
+ return OPJ_FALSE;
+
entries = (OPJ_UINT32*) opj_malloc(nr_channels * nr_entries * sizeof(OPJ_UINT32));
if (!entries)
return OPJ_FALSE;
for(i = 0; i < nr_channels; ++i) {
OPJ_INT32 bytes_to_read = (channel_size[i]+7)>>3;
+ if (bytes_to_read > sizeof(OPJ_UINT32))
+ bytes_to_read = sizeof(OPJ_UINT32);
+ if ((ptrdiff_t)p_pclr_header_size < p_pclr_header_data - orig_header_data + bytes_to_read)
+ return OPJ_FALSE;
+
+ if (bytes_to_read > sizeof(OPJ_UINT32))
+ bytes_to_read = sizeof(OPJ_UINT32);
+ if ((ptrdiff_t)p_pclr_header_size < p_pclr_header_data - orig_header_data + bytes_to_read)
+ return OPJ_FALSE;
+
opj_read_bytes(p_pclr_header_data, &l_value , bytes_to_read); /* Cji */
p_pclr_header_data += bytes_to_read;
*entries = (OPJ_UINT32) l_value;
return OPJ_TRUE;
}
-opj_bool opj_jp2_read_cmap( opj_jp2_t * jp2,
+OPJ_BOOL 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
}
nr_channels = jp2->color.jp2_pclr->nr_channels;
+ if (p_cmap_header_size < (OPJ_UINT32)nr_channels * 4) {
+ opj_event_msg(p_manager, EVT_ERROR, "Insufficient data for CMAP box.\n");
+ return OPJ_FALSE;
+ }
+
+ if (p_cmap_header_size < (OPJ_UINT32)nr_channels * 4) {
+ opj_event_msg(p_manager, EVT_ERROR, "Insufficient data for CMAP box.\n");
+ return OPJ_FALSE;
+ }
+
cmap = (opj_jp2_cmap_comp_t*) opj_malloc(nr_channels * sizeof(opj_jp2_cmap_comp_t));
if (!cmap)
return OPJ_FALSE;
for(i = 0; i < n; ++i)
{
/* WATCH: acn = asoc - 1 ! */
- if((asoc = info[i].asoc) == 0) continue;
+ asoc = info[i].asoc;
+ if(asoc == 0 || asoc == 65535)
+ {
+ if (i < image->numcomps)
+ image->comps[i].alpha = info[i].typ;
+ continue;
+ }
cn = info[i].cn;
acn = asoc - 1;
+ if( cn >= image->numcomps || acn >= image->numcomps )
+ {
+ fprintf(stderr, "cn=%d, acn=%d, numcomps=%d\n", cn, acn, image->numcomps);
+ continue;
+ }
if(cn != acn)
{
info[i].asoc = cn + 1;
info[acn].asoc = info[acn].cn + 1;
}
+
+ image->comps[cn].alpha = info[i].typ;
}
if(color->jp2_cdef->info) opj_free(color->jp2_cdef->info);
}/* jp2_apply_cdef() */
-opj_bool opj_jp2_read_cdef( opj_jp2_t * jp2,
+OPJ_BOOL 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
* inside a JP2 Header box.'*/
if(jp2->color.jp2_cdef) return OPJ_FALSE;
+ if (p_cdef_header_size < 2) {
+ opj_event_msg(p_manager, EVT_ERROR, "Insufficient data for CDEF box.\n");
+ return OPJ_FALSE;
+ }
+
+ if (p_cdef_header_size < 2) {
+ opj_event_msg(p_manager, EVT_ERROR, "Insufficient data for CDEF box.\n");
+ return OPJ_FALSE;
+ }
+
opj_read_bytes(p_cdef_header_data,&l_value ,2); /* N */
p_cdef_header_data+= 2;
return OPJ_FALSE;
}
+ if (p_cdef_header_size < 2 + (OPJ_UINT32)(OPJ_UINT16)l_value * 6) {
+ opj_event_msg(p_manager, EVT_ERROR, "Insufficient data for CDEF box.\n");
+ return OPJ_FALSE;
+ }
+
+ if (p_cdef_header_size < 2 + (OPJ_UINT32)(OPJ_UINT16)l_value * 6) {
+ opj_event_msg(p_manager, EVT_ERROR, "Insufficient data for CDEF box.\n");
+ return OPJ_FALSE;
+ }
+
cdef_info = (opj_jp2_cdef_info_t*) opj_malloc(l_value * sizeof(opj_jp2_cdef_info_t));
if (!cdef_info)
return OPJ_FALSE;
return OPJ_TRUE;
}
-opj_bool opj_jp2_read_colr( opj_jp2_t *jp2,
+OPJ_BOOL 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
++p_colr_header_data;
if (jp2->meth == 1) {
- if (p_colr_header_size != 7) {
- opj_event_msg(p_manager, EVT_ERROR, "Bad BPCC header box (bad size)\n");
+ if (p_colr_header_size < 7) {
+ opj_event_msg(p_manager, EVT_ERROR, "Bad COLR header box (bad size: %d)\n", p_colr_header_size);
return OPJ_FALSE;
}
+ if (p_colr_header_size > 7) {
+ /* testcase Altona_Technical_v20_x4.pdf */
+ opj_event_msg(p_manager, EVT_WARNING, "Bad COLR header box (bad size: %d)\n", p_colr_header_size);
+ }
opj_read_bytes(p_colr_header_data,&jp2->enumcs ,4); /* EnumCS */
+
+ jp2->color.jp2_has_colr = 1;
}
else if (jp2->meth == 2) {
/* ICC profile */
++p_colr_header_data;
jp2->color.icc_profile_buf[it_icc_value] = (OPJ_BYTE) l_value;
}
-
+
+ jp2->color.jp2_has_colr = 1;
}
- else
- opj_event_msg(p_manager, EVT_INFO, "COLR BOX meth value is not a regular value (%d), so we will skip the fields following the approx field.\n", jp2->meth);
-
- jp2->color.jp2_has_colr = 1;
-
- return OPJ_TRUE;
+ else if (jp2->meth > 2)
+ {
+ /* ISO/IEC 15444-1:2004 (E), Table I.9 � Legal METH values:
+ conforming JP2 reader shall ignore the entire Colour Specification box.*/
+ opj_event_msg(p_manager, EVT_INFO, "COLR BOX meth value is not a regular value (%d), "
+ "so we will ignore the entire Colour Specification box. \n", jp2->meth);
+ }
+ return OPJ_TRUE;
}
-opj_bool opj_jp2_decode(opj_jp2_t *jp2,
+OPJ_BOOL opj_jp2_decode(opj_jp2_t *jp2,
opj_stream_private_t *p_stream,
opj_image_t* p_image,
opj_event_mgr_t * p_manager)
}
if (!jp2->ignore_pclr_cmap_cdef){
+ if (!opj_jp2_check_color(p_image, &(jp2->color), p_manager)) {
+ return OPJ_FALSE;
+ }
/* Set Image Color Space */
if (jp2->enumcs == 16)
p_image->color_space = OPJ_CLRSPC_GRAY;
else if (jp2->enumcs == 18)
p_image->color_space = OPJ_CLRSPC_SYCC;
+ else if (jp2->enumcs == 24)
+ p_image->color_space = OPJ_CLRSPC_EYCC;
else
p_image->color_space = OPJ_CLRSPC_UNKNOWN;
return OPJ_TRUE;
}
-opj_bool opj_jp2_write_jp2h(opj_jp2_t *jp2,
+OPJ_BOOL opj_jp2_write_jp2h(opj_jp2_t *jp2,
opj_stream_private_t *stream,
opj_event_mgr_t * p_manager
)
OPJ_INT32 i, l_nb_pass;
/* size of data for super box*/
OPJ_INT32 l_jp2h_size = 8;
- opj_bool l_result = OPJ_TRUE;
+ OPJ_BOOL l_result = OPJ_TRUE;
/* to store the data of the super box */
OPJ_BYTE l_jp2h_data [8];
return l_result;
}
-opj_bool opj_jp2_write_ftyp(opj_jp2_t *jp2,
+OPJ_BOOL opj_jp2_write_ftyp(opj_jp2_t *jp2,
opj_stream_private_t *cio,
opj_event_mgr_t * p_manager )
{
OPJ_UINT32 i;
OPJ_UINT32 l_ftyp_size = 16 + 4 * jp2->numcl;
OPJ_BYTE * l_ftyp_data, * l_current_data_ptr;
- opj_bool l_result;
+ OPJ_BOOL l_result;
/* preconditions */
assert(cio != 00);
return l_result;
}
-opj_bool opj_jp2_write_jp2c(opj_jp2_t *jp2,
+OPJ_BOOL opj_jp2_write_jp2c(opj_jp2_t *jp2,
opj_stream_private_t *cio,
opj_event_mgr_t * p_manager )
{
return OPJ_TRUE;
}
-opj_bool opj_jp2_write_jp( opj_jp2_t *jp2,
+OPJ_BOOL opj_jp2_write_jp( opj_jp2_t *jp2,
opj_stream_private_t *cio,
opj_event_mgr_t * p_manager )
{
}
/* Colour Specification box */
- if ((image->numcomps == 1 || image->numcomps == 3) && (jp2->bpc != 255)) {
- jp2->meth = 1; /* METH: Enumerated colourspace */
- } else {
- jp2->meth = 2; /* METH: Restricted ICC profile */
- }
- if (jp2->meth == 1) {
- if (image->color_space == 1)
- jp2->enumcs = 16; /* sRGB as defined by IEC 61966-2-1 */
- else if (image->color_space == 2)
- jp2->enumcs = 17; /* greyscale */
- else if (image->color_space == 3)
- jp2->enumcs = 18; /* YUV */
- } else {
- jp2->enumcs = 0; /* PROFILE (??) */
- }
+ if(image->icc_profile_len) {
+ jp2->meth = 2;
+ jp2->enumcs = 0;
+ }
+ else {
+ jp2->meth = 1;
+ if (image->color_space == 1)
+ jp2->enumcs = 16; /* sRGB as defined by IEC 61966-2-1 */
+ else if (image->color_space == 2)
+ jp2->enumcs = 17; /* greyscale */
+ else if (image->color_space == 3)
+ jp2->enumcs = 18; /* YUV */
+ }
+
+
jp2->precedence = 0; /* PRECEDENCE */
jp2->approx = 0; /* APPROX */
jp2->jpip_on = parameters->jpip_on;
}
-opj_bool opj_jp2_encode(opj_jp2_t *jp2,
+OPJ_BOOL opj_jp2_encode(opj_jp2_t *jp2,
opj_stream_private_t *stream,
opj_event_mgr_t * p_manager)
{
- return opj_j2k_encode_v2(jp2->j2k, stream, p_manager);
+ return opj_j2k_encode(jp2->j2k, stream, p_manager);
}
-opj_bool opj_jp2_end_decompress(opj_jp2_t *jp2,
+OPJ_BOOL opj_jp2_end_decompress(opj_jp2_t *jp2,
opj_stream_private_t *cio,
opj_event_mgr_t * p_manager
)
return opj_j2k_end_decompress(jp2->j2k, cio, p_manager);
}
-opj_bool opj_jp2_end_compress( opj_jp2_t *jp2,
+OPJ_BOOL opj_jp2_end_compress( opj_jp2_t *jp2,
opj_stream_private_t *cio,
opj_event_mgr_t * p_manager
)
/* DEVELOPER CORNER, add your custom procedures */
}
-opj_bool opj_jp2_default_validation ( opj_jp2_t * jp2,
+OPJ_BOOL opj_jp2_default_validation ( opj_jp2_t * jp2,
opj_stream_private_t *cio,
opj_event_mgr_t * p_manager
)
{
- opj_bool l_is_valid = OPJ_TRUE;
+ OPJ_BOOL l_is_valid = OPJ_TRUE;
OPJ_UINT32 i;
/* preconditions */
return l_is_valid;
}
-opj_bool opj_jp2_read_header_procedure( opj_jp2_t *jp2,
+OPJ_BOOL opj_jp2_read_header_procedure( opj_jp2_t *jp2,
opj_stream_private_t *stream,
opj_event_mgr_t * p_manager
)
opj_jp2_box_t box;
OPJ_UINT32 l_nb_bytes_read;
const opj_jp2_header_handler_t * l_current_handler;
- OPJ_UINT32 l_last_data_size = BOX_SIZE;
+ OPJ_UINT32 l_last_data_size = OPJ_BOX_SIZE;
OPJ_UINT32 l_current_data_size;
OPJ_BYTE * l_current_data = 00;
opj_free(l_current_data);
return OPJ_FALSE;
}
+ /* testcase 1851.pdf.SIGSEGV.ce9.948 */
+ else if (box.length < l_nb_bytes_read) {
+ opj_event_msg(p_manager, EVT_ERROR, "invalid box size %d (%x)\n", box.length, box.type);
+ opj_free(l_current_data);
+ return OPJ_FALSE;
+ }
l_current_handler = opj_jp2_find_handler(box.type);
l_current_data_size = box.length - l_nb_bytes_read;
if (l_current_handler != 00) {
if (l_current_data_size > l_last_data_size) {
OPJ_BYTE* new_current_data = (OPJ_BYTE*)opj_realloc(l_current_data,l_current_data_size);
- if (!l_current_data){
+ if (!new_current_data) {
opj_free(l_current_data);
opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to handle jpeg2000 box\n");
return OPJ_FALSE;
*
* @return true if all the procedures were successfully executed.
*/
-static opj_bool opj_jp2_exec ( opj_jp2_t * jp2,
+static OPJ_BOOL 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
)
{
- opj_bool (** l_procedure) (opj_jp2_t * jp2, opj_stream_private_t *, opj_event_mgr_t *) = 00;
- opj_bool l_result = OPJ_TRUE;
+ OPJ_BOOL (** l_procedure) (opj_jp2_t * jp2, opj_stream_private_t *, opj_event_mgr_t *) = 00;
+ OPJ_BOOL l_result = OPJ_TRUE;
OPJ_UINT32 l_nb_proc, i;
/* preconditions */
assert(p_manager != 00);
l_nb_proc = opj_procedure_list_get_nb_procedures(p_procedure_list);
- 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);
+ 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);
for (i=0;i<l_nb_proc;++i) {
l_result = l_result && (*l_procedure) (jp2,stream,p_manager);
return l_result;
}
-opj_bool opj_jp2_start_compress(opj_jp2_t *jp2,
+OPJ_BOOL opj_jp2_start_compress(opj_jp2_t *jp2,
opj_stream_private_t *stream,
opj_image_t * p_image,
opj_event_mgr_t * p_manager
*
* @return true if the file signature box is valid.
*/
-static opj_bool opj_jp2_read_jp(opj_jp2_t *jp2,
+static OPJ_BOOL opj_jp2_read_jp(opj_jp2_t *jp2,
OPJ_BYTE * p_header_data,
OPJ_UINT32 p_header_size,
opj_event_mgr_t * p_manager
*
* @return true if the FTYP box is valid.
*/
-static opj_bool opj_jp2_read_ftyp( opj_jp2_t *jp2,
+static OPJ_BOOL opj_jp2_read_ftyp( opj_jp2_t *jp2,
OPJ_BYTE * p_header_data,
OPJ_UINT32 p_header_size,
opj_event_mgr_t * p_manager
return OPJ_TRUE;
}
-opj_bool opj_jp2_skip_jp2c( opj_jp2_t *jp2,
+OPJ_BOOL opj_jp2_skip_jp2c( opj_jp2_t *jp2,
opj_stream_private_t *stream,
opj_event_mgr_t * p_manager )
{
return OPJ_TRUE;
}
-static opj_bool opj_jpip_skip_iptr( opj_jp2_t *jp2,
+static OPJ_BOOL opj_jpip_skip_iptr( opj_jp2_t *jp2,
opj_stream_private_t *stream,
opj_event_mgr_t * p_manager )
{
*
* @return true if the JP2 Header box was successfully reconized.
*/
-static opj_bool opj_jp2_read_jp2h( opj_jp2_t *jp2,
+static OPJ_BOOL opj_jp2_read_jp2h( opj_jp2_t *jp2,
OPJ_BYTE *p_header_data,
OPJ_UINT32 p_header_size,
opj_event_mgr_t * p_manager
return OPJ_TRUE;
}
-opj_bool opj_jp2_read_boxhdr_char( opj_jp2_box_t *box,
+OPJ_BOOL 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,
return OPJ_TRUE;
}
-opj_bool opj_jp2_read_header( opj_stream_private_t *p_stream,
+OPJ_BOOL 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
/* DEVELOPER CORNER, add your custom procedures */
}
-opj_bool opj_jp2_read_tile_header ( opj_jp2_t * p_jp2,
+OPJ_BOOL 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_x1,
OPJ_INT32 * p_tile_y1,
OPJ_UINT32 * p_nb_comps,
- opj_bool * p_go_on,
+ OPJ_BOOL * p_go_on,
opj_stream_private_t *p_stream,
opj_event_mgr_t * p_manager
)
p_manager);
}
-opj_bool opj_jp2_write_tile ( opj_jp2_t *p_jp2,
+OPJ_BOOL opj_jp2_write_tile ( opj_jp2_t *p_jp2,
OPJ_UINT32 p_tile_index,
OPJ_BYTE * p_data,
OPJ_UINT32 p_data_size,
return opj_j2k_write_tile (p_jp2->j2k,p_tile_index,p_data,p_data_size,p_stream,p_manager);
}
-opj_bool opj_jp2_decode_tile ( opj_jp2_t * p_jp2,
+OPJ_BOOL opj_jp2_decode_tile ( opj_jp2_t * p_jp2,
OPJ_UINT32 p_tile_index,
OPJ_BYTE * p_data,
OPJ_UINT32 p_data_size,
}
}
-opj_bool opj_jp2_set_decode_area( opj_jp2_t *p_jp2,
+OPJ_BOOL 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,
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);
}
-opj_bool opj_jp2_get_tile( opj_jp2_t *p_jp2,
+OPJ_BOOL 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,
return OPJ_FALSE;
}
+ if (!opj_jp2_check_color(p_image, &(p_jp2->color), p_manager)) {
+ return OPJ_FALSE;
+ }
+
/* Set Image Color Space */
if (p_jp2->enumcs == 16)
p_image->color_space = OPJ_CLRSPC_SRGB;
/* JP2 encoder interface */
/* ----------------------------------------------------------------------- */
-opj_jp2_t* opj_jp2_create(opj_bool p_is_decoder)
+opj_jp2_t* opj_jp2_create(OPJ_BOOL p_is_decoder)
{
opj_jp2_t *jp2 = (opj_jp2_t*)opj_malloc(sizeof(opj_jp2_t));
if (jp2) {
return j2k_get_cstr_info(p_jp2->j2k);
}
-opj_bool opj_jp2_set_decoded_resolution_factor(opj_jp2_t *p_jp2,
+OPJ_BOOL opj_jp2_set_decoded_resolution_factor(opj_jp2_t *p_jp2,
OPJ_UINT32 res_factor,
opj_event_mgr_t * p_manager)
{
/* JPIP specific */
#ifdef USE_JPIP
-static opj_bool opj_jpip_write_iptr(opj_jp2_t *jp2,
+static OPJ_BOOL opj_jpip_write_iptr(opj_jp2_t *jp2,
opj_stream_private_t *cio,
opj_event_mgr_t * p_manager )
{
return OPJ_TRUE;
}
-static opj_bool opj_jpip_write_fidx(opj_jp2_t *jp2,
+static OPJ_BOOL opj_jpip_write_fidx(opj_jp2_t *jp2,
opj_stream_private_t *cio,
opj_event_mgr_t * p_manager )
{
return OPJ_TRUE;
}
-static opj_bool opj_jpip_write_cidx(opj_jp2_t *jp2,
+static OPJ_BOOL opj_jpip_write_cidx(opj_jp2_t *jp2,
opj_stream_private_t *cio,
opj_event_mgr_t * p_manager )
{
projects / openjpeg.git / blobdiff