* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
* Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* Copyright (c) 2006-2007, Parvatha Elangovan
* Copyright (c) 2010-2011, Kaori Hagihara
+ * Copyright (c) 2011, Mickael Savinaud, Communications & Systemes <mickael.savinaud@c-s.fr>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
static void j2k_tcp_destroy (opj_tcp_v2_t *p_tcp);
/**
- * Destroys a codestream index structure.
+ * Destroys the data inside a tile coding parameter structure.
*
- * @param p_cstr_ind the codestream index parameter to destroy.
+ * @param p_tcp the tile coding parameter which contain data to destroy.
*/
-static void j2k_destroy_cstr_index (opj_codestream_index_t* p_cstr_ind);
+static void j2k_tcp_data_destroy (opj_tcp_v2_t *p_tcp);
/**
* Destroys a coding parameter structure.
opj_stream_private_t *p_stream,
opj_event_mgr_t * p_manager);
-static opj_bool j2k_update_image_data (opj_tcd_v2_t * p_tcd, OPJ_BYTE * p_data);
+static opj_bool j2k_update_image_data (opj_tcd_v2_t * p_tcd, OPJ_BYTE * p_data, opj_image_t* p_output_image);
/*
*/
static void j2k_add_mhmarker(opj_codestream_info_t *cstr_info, unsigned short int type, int pos, int len);
-static void j2k_add_mhmarker_v2(opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_UINT32 pos, OPJ_UINT32 len) ;
+static void j2k_add_mhmarker_v2(opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_OFF_T pos, OPJ_UINT32 len) ;
/**
Add tile header marker information
@param tileno tile index number
*/
static void j2k_add_tlmarker( int tileno, opj_codestream_info_t *cstr_info, unsigned short int type, int pos, int len);
+static void j2k_add_tlmarker_v2(OPJ_UINT32 tileno, opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_OFF_T pos, OPJ_UINT32 len);
/**
* Reads an unknown marker
struct opj_event_mgr * p_manager);
-/**
- * Copy the image header from the jpeg2000 codec into an external image_header
- *
- * @param p_j2k the jpeg2000 codec.
- * @param p_image_header the external empty image header
- *
- * @return true if the image header is correctly copy.
- */
-static opj_bool j2k_copy_img_header(opj_j2k_v2_t* p_j2k, opj_image_t** p_image);
-
-
static void j2k_dump_MH_info(opj_j2k_v2_t* p_j2k, FILE* out_stream);
static void j2k_dump_MH_index(opj_j2k_v2_t* p_j2k, FILE* out_stream);
{(OPJ_PROG_ORDER)-1, ""}
};
+
+
/**
* FIXME DOC
*/
p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_MHSIZ;
/* FIXME move it in a index structure included in p_j2k*/
- p_j2k->cstr_index->main_head_start = (OPJ_UINT32) opj_stream_tell(p_stream) - 2;
+ p_j2k->cstr_index->main_head_start = opj_stream_tell(p_stream) - 2;
opj_event_msg_v2(p_manager, EVT_INFO, "Start to read j2k main header (%d).\n", p_j2k->cstr_index->main_head_start);
assert(p_manager != 00);
assert(p_header_data != 00);
- l_image = p_j2k->m_image;
+ l_image = p_j2k->m_private_image;
l_cp = &(p_j2k->m_cp);
// minimum size == 39 - 3 (= minimum component parameter)
assert(p_j2k != 00);
assert(p_manager != 00);
- l_image = p_j2k->m_image;
+ l_image = p_j2k->m_private_image;
l_cp = &(p_j2k->m_cp);
/* If we are in the first tile-part header of the current tile */
l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH ) ? /*FIXME J2K_DEC_STATE_TPH*/
&l_cp->tcps[p_j2k->m_current_tile_number] :
p_j2k->m_specific_param.m_decoder.m_default_tcp;
- l_image = p_j2k->m_image;
+ l_image = p_j2k->m_private_image;
l_comp_room = l_image->numcomps <= 256 ? 1 : 2;
assert(p_j2k != 00);
assert(p_manager != 00);
- l_num_comp = p_j2k->m_image->numcomps;
+ l_num_comp = p_j2k->m_private_image->numcomps;
if (l_num_comp <= 256) {
if (p_header_size < 1) {
assert(p_j2k != 00);
assert(p_manager != 00);
- l_image = p_j2k->m_image;
+ l_image = p_j2k->m_private_image;
l_nb_comp = l_image->numcomps;
if (l_nb_comp <= 256) {
l_comp_room = 1;
assert(p_j2k != 00);
assert(p_manager != 00);
- l_nb_comp = p_j2k->m_image->numcomps;
+ l_nb_comp = p_j2k->m_private_image->numcomps;
if (p_header_size != l_nb_comp *4) {
opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading CRG marker\n");
p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_TPH;
- /* Check if the current tile is outside the area we want decode (in tile index)*/
- p_j2k->m_specific_param.m_decoder.m_skip_data =
- (l_tile_x < p_j2k->m_specific_param.m_decoder.m_start_tile_x)
- || (l_tile_x >= p_j2k->m_specific_param.m_decoder.m_end_tile_x)
- || (l_tile_y < p_j2k->m_specific_param.m_decoder.m_start_tile_y)
- || (l_tile_y >= p_j2k->m_specific_param.m_decoder.m_end_tile_y);
+ /* Check if the current tile is outside the area we want decode or not corresponding to the tile index*/
+ if (p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec == -1) {
+ p_j2k->m_specific_param.m_decoder.m_skip_data =
+ (l_tile_x < p_j2k->m_specific_param.m_decoder.m_start_tile_x)
+ || (l_tile_x >= p_j2k->m_specific_param.m_decoder.m_end_tile_x)
+ || (l_tile_y < p_j2k->m_specific_param.m_decoder.m_start_tile_y)
+ || (l_tile_y >= p_j2k->m_specific_param.m_decoder.m_end_tile_y);
+ }
+ else
+ p_j2k->m_specific_param.m_decoder.m_skip_data =
+ (p_j2k->m_current_tile_number != p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec);
/* Index */
+ if (p_j2k->cstr_index)
+ {
+ p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tileno = p_j2k->m_current_tile_number;
+ p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_tpsno = l_current_part;
+
+ if (l_num_parts != 0){
+ p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].nb_tps = l_num_parts;
+ p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps = l_num_parts;
+
+
+ if (!p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index)
+ p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index =
+ (opj_tp_index_t*)opj_calloc(l_num_parts, sizeof(opj_tp_index_t));
+ else
+ p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index =
+ (opj_tp_index_t*)opj_realloc(
+ p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index,
+ l_num_parts* sizeof(opj_tp_index_t));
+ }
+ else{
+ /*if (!p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index)*/ {
+
+ if (!p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index) {
+ p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps = 10;
+ p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index =
+ (opj_tp_index_t*)opj_calloc( p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps,
+ sizeof(opj_tp_index_t));
+ }
+
+ if ( l_current_part >= p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps ){
+ p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps += 10;
+ p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index =
+ (opj_tp_index_t*)opj_realloc( p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index,
+ p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps
+ * sizeof(opj_tp_index_t));
+ }
+ }
+
+ }
+
+ }
+
/* FIXME move this onto a separate method to call before reading any SOT, remove part about main_end header, use a index struct inside p_j2k */
/* if (p_j2k->cstr_info) {
l_tcp = &(p_j2k->m_cp.tcps[p_j2k->m_current_tile_number]);
- if (p_j2k->m_specific_param.m_decoder.m_last_tile_part)
- p_j2k->m_specific_param.m_decoder.m_sot_length = opj_stream_get_number_byte_left(p_stream) - 2;
+ if (p_j2k->m_specific_param.m_decoder.m_last_tile_part) {
+ // opj_stream_get_number_byte_left returns OPJ_OFF_T
+ // but we are in the last tile part,
+ // so its result will fit on OPJ_UINT32 unless we find
+ // a file with a single tile part of more than 4 GB...
+ p_j2k->m_specific_param.m_decoder.m_sot_length = (OPJ_UINT32)(opj_stream_get_number_byte_left(p_stream) - 2);
+ }
else
p_j2k->m_specific_param.m_decoder.m_sot_length -= 2;
l_tile_len = &l_tcp->m_data_size;
if (! *l_current_data) {
- *l_current_data = (OPJ_BYTE*) opj_malloc/*FIXME V2 -> my_opj_malloc*/(p_j2k->m_specific_param.m_decoder.m_sot_length);
+ *l_current_data = (OPJ_BYTE*) opj_malloc(p_j2k->m_specific_param.m_decoder.m_sot_length);
}
else {
- *l_current_data = (OPJ_BYTE*) opj_realloc/*FIXME V2 -> my_opj_realloc*/(*l_current_data, *l_tile_len + p_j2k->m_specific_param.m_decoder.m_sot_length);
+ *l_current_data = (OPJ_BYTE*) opj_realloc(*l_current_data, *l_tile_len + p_j2k->m_specific_param.m_decoder.m_sot_length);
}
if (*l_current_data == 00) {
return OPJ_FALSE;
}
-#ifdef TODO_MSD /* FIXME */
- l_cstr_index = p_j2k->cstr_index;
/* Index */
+ l_cstr_index = p_j2k->cstr_index;
if (l_cstr_index) {
- OPJ_SIZE_T l_current_pos = opj_stream_tell(p_stream)-1;
- l_cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index[p_j2k->m_specific_param.m_encoder.m_current_tile_part_number].tp_end_header = l_current_pos;
+ OPJ_OFF_T l_current_pos = opj_stream_tell(p_stream) - 2;
- l_cstr_index->packno = 0;
+ OPJ_UINT32 l_current_tile_part = l_cstr_index->tile_index[p_j2k->m_current_tile_number].current_tpsno;
+ l_cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index[l_current_tile_part].end_header =
+ l_current_pos;
+ l_cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index[l_current_tile_part].end_pos =
+ l_current_pos + p_j2k->m_specific_param.m_decoder.m_sot_length + 2;
+
+ j2k_add_tlmarker_v2(p_j2k->m_current_tile_number,
+ l_cstr_index,
+ J2K_MS_SOD,
+ l_current_pos,
+ p_j2k->m_specific_param.m_decoder.m_sot_length + 2);
+
+ /*l_cstr_index->packno = 0;*/
}
-#endif
l_current_read_size = opj_stream_read_data( p_stream,
*l_current_data + *l_tile_len,
assert(p_j2k != 00);
assert(p_manager != 00);
- l_image = p_j2k->m_image;
+ l_image = p_j2k->m_private_image;
l_nb_comp = l_image->numcomps;
if (l_nb_comp <= 256) {
assert(p_j2k != 00);
assert(p_manager != 00);
- l_image = p_j2k->m_image;
+ l_image = p_j2k->m_private_image;
l_tcp = p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH ?
&p_j2k->m_cp.tcps[p_j2k->m_current_tile_number] :
p_j2k->m_specific_param.m_decoder.m_default_tcp;
opj_read_bytes(p_header_data,&l_tmp,1);
++p_header_data;
- if (! j2k_add_mct(l_tcp,p_j2k->m_image,l_tmp)) {
+ if (! j2k_add_mct(l_tcp,p_j2k->m_private_image,l_tmp)) {
return OPJ_FALSE;
}
}
assert(p_j2k != 00);
assert(p_manager != 00);
- l_num_comp = p_j2k->m_image->numcomps;
+ l_num_comp = p_j2k->m_private_image->numcomps;
- if (p_header_size != (p_j2k->m_image->numcomps + 2)) {
+ if (p_header_size != (p_j2k->m_private_image->numcomps + 2)) {
opj_event_msg_v2(p_manager, EVT_ERROR, "Crror reading CBD marker\n");
return OPJ_FALSE;
}
return OPJ_FALSE;
}
- l_comp = p_j2k->m_image->comps;
+ l_comp = p_j2k->m_private_image->comps;
for (i=0;i<l_num_comp;++i) {
opj_read_bytes(p_header_data,&l_comp_def,1); /* Component bit depth */
++p_header_data;
}
-static void j2k_add_mhmarker_v2(opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_UINT32 pos, OPJ_UINT32 len) {
+static void j2k_add_mhmarker_v2(opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_OFF_T pos, OPJ_UINT32 len) {
if (!cstr_index)
return;
cstr_info->tile[tileno].marknum++;
}
+static void j2k_add_tlmarker_v2(OPJ_UINT32 tileno, opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_OFF_T pos, OPJ_UINT32 len)
+{
+
+ if (!cstr_index)
+ return;
+
+ if (!cstr_index->tile_index)
+
+ /* expand the list? */
+ if ((cstr_index->tile_index[tileno].marknum + 1) > cstr_index->tile_index[tileno].maxmarknum) {
+ cstr_index->tile_index[tileno].maxmarknum = 100 + (int) ((float) cstr_index->tile_index[tileno].maxmarknum * 1.0F);
+ cstr_index->tile_index[tileno].marker =
+ (opj_marker_info_t*)opj_realloc(cstr_index->tile_index[tileno].marker,
+ cstr_index->tile_index[tileno].maxmarknum *sizeof(opj_marker_info_t));
+ }
+
+ /* add the marker */
+ cstr_index->tile_index[tileno].marker[cstr_index->tile_index[tileno].marknum].type = (OPJ_UINT16)type;
+ cstr_index->tile_index[tileno].marker[cstr_index->tile_index[tileno].marknum].pos = (OPJ_INT32)pos;
+ cstr_index->tile_index[tileno].marker[cstr_index->tile_index[tileno].marknum].len = (OPJ_INT32)len;
+ cstr_index->tile_index[tileno].marknum++;
+
+ if (type == J2K_MS_SOT) {
+ OPJ_UINT32 l_current_tile_part = cstr_index->tile_index[tileno].current_tpsno;
+
+ if (cstr_index->tile_index[tileno].tp_index)
+ cstr_index->tile_index[tileno].tp_index[l_current_tile_part].start_pos = pos;
+
+ }
+
+}
+
assert(p_manager != 00);
/* create an empty image header */
- p_j2k->m_image = opj_image_create0();
- if (! p_j2k->m_image) {
+ p_j2k->m_private_image = opj_image_create0();
+ if (! p_j2k->m_private_image) {
return OPJ_FALSE;
}
/* validation of the parameters codec */
if (! j2k_exec(p_j2k, p_j2k->m_validation_list, p_stream,p_manager)) {
- opj_image_destroy(p_j2k->m_image);
- p_j2k->m_image = NULL;
+ opj_image_destroy(p_j2k->m_private_image);
+ p_j2k->m_private_image = NULL;
return OPJ_FALSE;
}
/* read header */
if (! j2k_exec (p_j2k,p_j2k->m_procedure_list,p_stream,p_manager)) {
- opj_image_destroy(p_j2k->m_image);
- p_j2k->m_image = NULL;
+ opj_image_destroy(p_j2k->m_private_image);
+ p_j2k->m_private_image = NULL;
return OPJ_FALSE;
}
return OPJ_FALSE;
}
- if (! j2k_copy_img_header(p_j2k, p_image)){
- opj_image_destroy(p_j2k->m_image);
- p_j2k->m_image = NULL;
- return OPJ_FALSE;
- }
+ /* Copy codestream image information to the output image */
+ opj_copy_image_header(p_j2k->m_private_image, *p_image);
return OPJ_TRUE;
}
-opj_bool j2k_copy_img_header(opj_j2k_v2_t* p_j2k, opj_image_t** p_image)
-{
- OPJ_UINT16 compno;
-
- /* preconditions */
- assert(p_j2k != 00);
-
- (*p_image)->x0 = p_j2k->m_image->x0;
- (*p_image)->y0 = p_j2k->m_image->y0;
- (*p_image)->x1 = p_j2k->m_image->x1;
- (*p_image)->y1 = p_j2k->m_image->y1;
-
- (*p_image)->numcomps = p_j2k->m_image->numcomps;
- (*p_image)->comps = (opj_image_comp_t*)opj_malloc((*p_image)->numcomps * sizeof(opj_image_comp_t));
- if (!(*p_image)->comps)
- return OPJ_FALSE;
- for (compno=0; compno < (*p_image)->numcomps; compno++){
- memcpy( &((*p_image)->comps[compno]),
- &(p_j2k->m_image->comps[compno]),
- sizeof(opj_image_comp_t));
- }
-
- (*p_image)->color_space = p_j2k->m_image->color_space;
- (*p_image)->icc_profile_len = p_j2k->m_image->icc_profile_len;
- if (!(*p_image)->icc_profile_len) {
-
- (*p_image)->icc_profile_buf = (unsigned char*)opj_malloc((*p_image)->icc_profile_len);
- if (!(*p_image)->icc_profile_buf)
- return OPJ_FALSE;
- memcpy( (*p_image)->icc_profile_buf,
- p_j2k->m_image->icc_profile_buf,
- p_j2k->m_image->icc_profile_len);
- }
- else
- (*p_image)->icc_profile_buf = NULL;
-
- return OPJ_TRUE;
-}
-
-
-
/**
* Sets up the procedures to do on reading header. Developpers wanting to extend the library can add their own reading procedures.
*/
assert(p_stream != 00);
assert(p_manager != 00);
- l_image = p_j2k->m_image;
+ l_image = p_j2k->m_private_image;
l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
l_tcp = p_j2k->m_cp.tcps;
l_tccp_size = l_image->numcomps * sizeof(opj_tccp_t);
*
* @return the handler associated with the id.
*/
-const opj_dec_memory_marker_handler_t * j2k_get_marker_handler (const OPJ_UINT32 p_id)
+const opj_dec_memory_marker_handler_t * j2k_get_marker_handler (OPJ_UINT32 p_id)
{
const opj_dec_memory_marker_handler_t *e;
for (e = j2k_memory_marker_handler_tab; e->id != 0; ++e) {
j2k_destroy_cstr_index(p_j2k->cstr_index);
p_j2k->cstr_index = NULL;
- opj_image_destroy(p_j2k->m_image);
- p_j2k->m_image = NULL;
+ opj_image_destroy(p_j2k->m_private_image);
+ p_j2k->m_private_image = NULL;
+
+ opj_image_destroy(p_j2k->m_output_image);
+ p_j2k->m_output_image = NULL;
opj_free(p_j2k);
}
}
if (p_cstr_ind->tile_index) {
- // FIXME not used for the moment
+ OPJ_UINT32 it_tile = 0;
+
+ for (it_tile=0; it_tile < p_cstr_ind->nb_of_tiles; it_tile++) {
+
+ if(p_cstr_ind->tile_index[it_tile].packet_index) {
+ opj_free(p_cstr_ind->tile_index[it_tile].packet_index);
+ p_cstr_ind->tile_index[it_tile].packet_index = NULL;
+ }
+
+ if(p_cstr_ind->tile_index[it_tile].tp_index){
+ opj_free(p_cstr_ind->tile_index[it_tile].tp_index);
+ p_cstr_ind->tile_index[it_tile].tp_index = NULL;
+ }
+
+ if(p_cstr_ind->tile_index[it_tile].marker){
+ opj_free(p_cstr_ind->tile_index[it_tile].marker);
+ p_cstr_ind->tile_index[it_tile].marker = NULL;
+
+ }
+ }
+
+ opj_free( p_cstr_ind->tile_index);
+ p_cstr_ind->tile_index = NULL;
}
opj_free(p_cstr_ind);
p_tcp->mct_norms = 00;
}
+ j2k_tcp_data_destroy(p_tcp);
+
+}
+
+/**
+ * Destroys the data inside a tile coding parameter structure.
+ *
+ * @param p_tcp the tile coding parameter which contain data to destroy.
+ */
+void j2k_tcp_data_destroy (opj_tcp_v2_t *p_tcp)
+{
if (p_tcp->m_data) {
opj_free(p_tcp->m_data);
- p_tcp->m_data = 00;
+ p_tcp->m_data = NULL;
+ p_tcp->m_data_size = 0;
}
}
-
/**
* Destroys a coding parameter structure.
*
return OPJ_FALSE;
}
+ /* Add the marker to the codestream index*/
+ j2k_add_tlmarker_v2(p_j2k->m_current_tile_number,
+ p_j2k->cstr_index,
+ l_marker_handler->id,
+ (OPJ_UINT32) opj_stream_tell(p_stream) - l_marker_size - 4,
+ l_marker_size + 4 );
+
+ /* Keep the position of the last SOT marker read */
+ if ( l_marker_handler->id == J2K_MS_SOT ) {
+ OPJ_UINT32 sot_pos = (OPJ_UINT32) opj_stream_tell(p_stream) - l_marker_size - 4 ;
+ if (sot_pos > p_j2k->m_specific_param.m_decoder.m_last_sot_read_pos)
+ {
+ p_j2k->m_specific_param.m_decoder.m_last_sot_read_pos = sot_pos;
+ }
+ }
+
+
if (p_j2k->m_specific_param.m_decoder.m_skip_data) {
/* Skip the rest of the tile part header*/
if (opj_stream_skip(p_stream,p_j2k->m_specific_param.m_decoder.m_sot_length,p_manager) != p_j2k->m_specific_param.m_decoder.m_sot_length) {
return OPJ_FALSE;
}
+
+
if (! p_j2k->m_specific_param.m_decoder.m_can_decode){
/* Try to read 2 bytes (the next marker ID) from stream and copy them into the buffer */
if (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,2,p_manager) != 2) {
}
opj_event_msg_v2(p_manager, EVT_INFO, "Header of tile %d / %d has been read.\n",
- p_j2k->m_current_tile_number +1, p_j2k->m_cp.th * p_j2k->m_cp.tw);
+ p_j2k->m_current_tile_number, (p_j2k->m_cp.th * p_j2k->m_cp.tw) - 1);
*p_tile_index = p_j2k->m_current_tile_number;
*p_go_on = OPJ_TRUE;
l_tcp = &(p_j2k->m_cp.tcps[p_tile_index]);
if (! l_tcp->m_data) {
- j2k_tcp_destroy(&(p_j2k->m_cp.tcps[p_tile_index]));
+ j2k_tcp_destroy(l_tcp);
return OPJ_FALSE;
}
return OPJ_FALSE;
}
- j2k_tcp_destroy(l_tcp);
- p_j2k->m_tcd->tcp = 0;
+ /* To avoid to destroy the tcp which can be useful when we try to decode a tile decoded before (cf j2k_random_tile_access)
+ * we destroy just the data which will be re-read in read_tile_header*/
+ /*j2k_tcp_destroy(l_tcp);
+ p_j2k->m_tcd->tcp = 0;*/
+ j2k_tcp_data_destroy(l_tcp);
p_j2k->m_specific_param.m_decoder.m_can_decode = 0;
p_j2k->m_specific_param.m_decoder.m_state &= (~ (0x0080));// FIXME J2K_DEC_STATE_DATA);
}
-opj_bool j2k_update_image_data (opj_tcd_v2_t * p_tcd, OPJ_BYTE * p_data)
+opj_bool j2k_update_image_data (opj_tcd_v2_t * p_tcd, OPJ_BYTE * p_data, opj_image_t* p_output_image)
{
OPJ_UINT32 i,j,k = 0;
- OPJ_UINT32 l_width,l_height,l_offset_x,l_offset_y;
- opj_image_comp_t * l_img_comp = 00;
+ OPJ_UINT32 l_width_src,l_height_src;
+ OPJ_UINT32 l_width_dest,l_height_dest;
+ OPJ_INT32 l_offset_x0_src, l_offset_y0_src, l_offset_x1_src, l_offset_y1_src;
+ OPJ_INT32 l_start_offset_src, l_line_offset_src, l_end_offset_src ;
+ OPJ_UINT32 l_start_x_dest , l_start_y_dest;
+ OPJ_UINT32 l_x0_dest, l_y0_dest, l_x1_dest, l_y1_dest;
+ OPJ_INT32 l_start_offset_dest, l_line_offset_dest;
+
+ opj_image_comp_t * l_img_comp_src = 00;
+ opj_image_comp_t * l_img_comp_dest = 00;
+
opj_tcd_tilecomp_v2_t * l_tilec = 00;
- opj_image_t * l_image = 00;
+ opj_image_t * l_image_src = 00;
OPJ_UINT32 l_size_comp, l_remaining;
- OPJ_UINT32 l_dest_stride;
OPJ_INT32 * l_dest_ptr;
opj_tcd_resolution_v2_t* l_res= 00;
-
l_tilec = p_tcd->tcd_image->tiles->comps;
- l_image = p_tcd->image;
- l_img_comp = l_image->comps;
+ l_image_src = p_tcd->image;
+ l_img_comp_src = l_image_src->comps;
+
+ l_img_comp_dest = p_output_image->comps;
- for (i=0;i<p_tcd->image->numcomps;++i) {
+ for (i=0; i<l_image_src->numcomps; i++) {
- if (!l_img_comp->data) {
+ /* Allocate output component buffer if necessary */
+ if (!l_img_comp_dest->data) {
- l_img_comp->data = (OPJ_INT32*) opj_malloc(l_img_comp->w * l_img_comp->h * sizeof(OPJ_INT32));
- if (! l_img_comp->data) {
+ l_img_comp_dest->data = (OPJ_INT32*) opj_calloc(l_img_comp_dest->w * l_img_comp_dest->h, sizeof(OPJ_INT32));
+ if (! l_img_comp_dest->data) {
return OPJ_FALSE;
}
- memset(l_img_comp->data,0,l_img_comp->w * l_img_comp->h * sizeof(OPJ_INT32));
}
- l_size_comp = l_img_comp->prec >> 3; /*(/ 8)*/
- l_remaining = l_img_comp->prec & 7; /* (%8) */
- l_res = l_tilec->resolutions + l_img_comp->resno_decoded;
+ /* Copy info from decoded comp image to output image */
+ l_img_comp_dest->resno_decoded = l_img_comp_src->resno_decoded;
+
+ /*-----*/
+ /* Compute the precision of the output buffer */
+ l_size_comp = l_img_comp_src->prec >> 3; /*(/ 8)*/
+ l_remaining = l_img_comp_src->prec & 7; /* (%8) */
+ l_res = l_tilec->resolutions + l_img_comp_src->resno_decoded;
if (l_remaining) {
++l_size_comp;
if (l_size_comp == 3) {
l_size_comp = 4;
}
+ /*-----*/
+
+ /* Current tile component size*/
+ /*if (i == 0) {
+ fprintf(stdout, "SRC: l_res_x0=%d, l_res_x1=%d, l_res_y0=%d, l_res_y1=%d\n",
+ l_res->x0, l_res->x1, l_res->y0, l_res->y1);
+ }*/
+
+ l_width_src = (l_res->x1 - l_res->x0);
+ l_height_src = (l_res->y1 - l_res->y0);
+
+ /* Border of the current output component*/
+ l_x0_dest = int_ceildivpow2(l_img_comp_dest->x0, l_img_comp_dest->factor);
+ l_y0_dest = int_ceildivpow2(l_img_comp_dest->y0, l_img_comp_dest->factor);
+ l_x1_dest = l_x0_dest + l_img_comp_dest->w;
+ l_y1_dest = l_y0_dest + l_img_comp_dest->h;
+
+ /*if (i == 0) {
+ fprintf(stdout, "DEST: l_x0_dest=%d, l_x1_dest=%d, l_y0_dest=%d, l_y1_dest=%d (%d)\n",
+ l_x0_dest, l_x1_dest, l_y0_dest, l_y1_dest, l_img_comp_dest->factor );
+ }*/
+
+ /*-----*/
+ /* Compute the area (l_offset_x0_src, l_offset_y0_src, l_offset_x1_src, l_offset_y1_src)
+ * of the input buffer (decoded tile component) which will be move
+ * in the output buffer. Compute the area of the output buffer (l_start_x_dest,
+ * l_start_y_dest, l_width_dest, l_height_dest) which will be modified
+ * by this input area.
+ * */
+ if ( l_x0_dest < l_res->x0 ) {
+ l_start_x_dest = l_res->x0 - l_x0_dest;
+ l_offset_x0_src = 0;
+
+ if ( l_x1_dest >= l_res->x1 ) {
+ l_width_dest = l_width_src;
+ l_offset_x1_src = 0;
+ }
+ else {
+ l_width_dest = l_x1_dest - l_res->x0 ;
+ l_offset_x1_src = l_width_src - l_width_dest;
+ }
+ }
+ else {
+ l_start_x_dest = 0 ;
+ l_offset_x0_src = l_x0_dest - l_res->x0;
- l_width = (l_res->x1 - l_res->x0);
- l_height = (l_res->y1 - l_res->y0);
+ if ( l_x1_dest >= l_res->x1 ) {
+ l_width_dest = l_width_src - l_offset_x0_src;
+ l_offset_x1_src = 0;
+ }
+ else {
+ l_width_dest = l_img_comp_dest->w ;
+ l_offset_x1_src = l_res->x1 - l_x1_dest;
+ }
+ }
- l_dest_stride = (l_img_comp->w) - l_width;
+ if ( l_y0_dest < l_res->y0 ) {
+ l_start_y_dest = l_res->y0 - l_y0_dest;
+ l_offset_y0_src = 0;
+
+ if ( l_y1_dest >= l_res->y1 ) {
+ l_height_dest = l_height_src;
+ l_offset_y1_src = 0;
+ }
+ else {
+ l_height_dest = l_y1_dest - l_res->y0 ;
+ l_offset_y1_src = l_height_src - l_height_dest;
+ }
+ }
+ else {
+ l_start_y_dest = 0 ;
+ l_offset_y0_src = l_y0_dest - l_res->y0;
+
+ if ( l_y1_dest >= l_res->y1 ) {
+ l_height_dest = l_height_src - l_offset_y0_src;
+ l_offset_y1_src = 0;
+ }
+ else {
+ l_height_dest = l_img_comp_dest->h ;
+ l_offset_y1_src = l_res->y1 - l_y1_dest;
+ }
+ }
+
+ if( (l_offset_x0_src < 0 ) || (l_offset_y0_src < 0 ) || (l_offset_x1_src < 0 ) || (l_offset_y1_src < 0 ) ){
+ return OPJ_FALSE;
+ }
+ /*-----*/
+
+ /* Compute the input buffer offset */
+ l_start_offset_src = l_offset_x0_src + l_offset_y0_src * l_width_src;
+ l_line_offset_src = l_offset_x1_src + l_offset_x0_src;
+ l_end_offset_src = l_offset_y1_src * l_width_src - l_offset_x0_src;
+
+ /* Compute the output buffer offset */
+ l_start_offset_dest = l_start_x_dest + l_start_y_dest * l_img_comp_dest->w;
+ l_line_offset_dest = l_img_comp_dest->w - l_width_dest;
+
+ /* Move the output buffer to the first place where we will write*/
+ l_dest_ptr = l_img_comp_dest->data + l_start_offset_dest;
+
+ /*if (i == 0) {
+ fprintf(stdout, "COMPO[%d]:\n",i);
+ fprintf(stdout, "SRC: l_start_x_src=%d, l_start_y_src=%d, l_width_src=%d, l_height_src=%d\n"
+ "\t tile offset:%d, %d, %d, %d\n"
+ "\t buffer offset: %d; %d, %d\n",
+ l_res->x0, l_res->y0, l_width_src, l_height_src,
+ l_offset_x0_src, l_offset_y0_src, l_offset_x1_src, l_offset_y1_src,
+ l_start_offset_src, l_line_offset_src, l_end_offset_src);
+
+ fprintf(stdout, "DEST: l_start_x_dest=%d, l_start_y_dest=%d, l_width_dest=%d, l_height_dest=%d\n"
+ "\t start offset: %d, line offset= %d\n",
+ l_start_x_dest, l_start_y_dest, l_width_dest, l_height_dest, l_start_offset_dest, l_line_offset_dest);
+ }*/
- l_offset_x = int_ceildivpow2(l_img_comp->x0, l_img_comp->factor);
- l_offset_y = int_ceildivpow2(l_img_comp->y0, l_img_comp->factor);
- l_dest_ptr = l_img_comp->data + (l_res->x0 - l_offset_x) + (l_res->y0 - l_offset_y) * l_img_comp->w;
switch (l_size_comp) {
case 1:
{
OPJ_CHAR * l_src_ptr = (OPJ_CHAR*) p_data;
- if (l_img_comp->sgnd) {
- for (j=0;j<l_height;++j) {
- for (k=0;k<l_width;++k) {
- *(l_dest_ptr++) = (OPJ_INT32) (*(l_src_ptr++));
+ l_src_ptr += l_start_offset_src; /* Move to the first place where we will read*/
+
+ if (l_img_comp_src->sgnd) {
+ for (j = 0 ; j < l_height_dest ; ++j) {
+ for ( k = 0 ; k < l_width_dest ; ++k) {
+ *(l_dest_ptr++) = (OPJ_INT32) (*(l_src_ptr++)); /* Copy only the data needed for the output image */
}
- l_dest_ptr += l_dest_stride;
+ l_dest_ptr+= l_line_offset_dest; /* Move to the next place where we will write */
+ l_src_ptr += l_line_offset_src ; /* Move to the next place where we will read */
}
}
else {
- for (j=0;j<l_height;++j) {
- for (k=0;k<l_width;++k) {
+ for ( j = 0 ; j < l_height_dest ; ++j ) {
+ for ( k = 0 ; k < l_width_dest ; ++k) {
*(l_dest_ptr++) = (OPJ_INT32) ((*(l_src_ptr++))&0xff);
}
- l_dest_ptr += l_dest_stride;
+ l_dest_ptr+= l_line_offset_dest;
+ l_src_ptr += l_line_offset_src;
}
}
- p_data = (OPJ_BYTE*) l_src_ptr;
+ l_src_ptr += l_end_offset_src; /* Move to the end of this component-part of the input buffer */
+ p_data = (OPJ_BYTE*) l_src_ptr; /* Keep the current position for the next component-part */
}
break;
case 2:
{
OPJ_INT16 * l_src_ptr = (OPJ_INT16 *) p_data;
+ l_src_ptr += l_start_offset_src;
- if (l_img_comp->sgnd) {
- for (j=0;j<l_height;++j) {
- for (k=0;k<l_width;++k) {
+ if (l_img_comp_src->sgnd) {
+ for (j=0;j<l_height_dest;++j) {
+ for (k=0;k<l_width_dest;++k) {
*(l_dest_ptr++) = *(l_src_ptr++);
}
- l_dest_ptr += l_dest_stride;
+ l_dest_ptr+= l_line_offset_dest;
+ l_src_ptr += l_line_offset_src ;
}
}
else {
- for (j=0;j<l_height;++j) {
- for (k=0;k<l_width;++k) {
+ for (j=0;j<l_height_dest;++j) {
+ for (k=0;k<l_width_dest;++k) {
*(l_dest_ptr++) = (*(l_src_ptr++))&0xffff;
}
- l_dest_ptr += l_dest_stride;
+ l_dest_ptr+= l_line_offset_dest;
+ l_src_ptr += l_line_offset_src ;
}
}
+ l_src_ptr += l_end_offset_src;
p_data = (OPJ_BYTE*) l_src_ptr;
}
break;
case 4:
{
OPJ_INT32 * l_src_ptr = (OPJ_INT32 *) p_data;
- for (j=0;j<l_height;++j) {
- for (k=0;k<l_width;++k) {
+ l_src_ptr += l_start_offset_src;
+
+ for (j=0;j<l_height_dest;++j) {
+ for (k=0;k<l_width_dest;++k) {
*(l_dest_ptr++) = (*(l_src_ptr++));
}
- l_dest_ptr += l_dest_stride;
+ l_dest_ptr+= l_line_offset_dest;
+ l_src_ptr += l_line_offset_src ;
}
+ l_src_ptr += l_end_offset_src;
p_data = (OPJ_BYTE*) l_src_ptr;
}
break;
}
- ++l_img_comp;
+ ++l_img_comp_dest;
+ ++l_img_comp_src;
++l_tilec;
}
+
return OPJ_TRUE;
}
* @return true if the area could be set.
*/
opj_bool j2k_set_decode_area( opj_j2k_v2_t *p_j2k,
+ 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,
struct opj_event_mgr * p_manager )
{
opj_cp_v2_t * l_cp = &(p_j2k->m_cp);
+ opj_image_t * l_image = p_j2k->m_private_image;
+
+ OPJ_UINT32 it_comp;
+ OPJ_INT32 l_comp_x1, l_comp_y1;
+ opj_image_comp_t* l_img_comp = NULL;
/* Check if we are read the main header */
if (p_j2k->m_specific_param.m_decoder.m_state != J2K_STATE_TPHSOT) { // FIXME J2K_DEC_STATE_TPHSOT)
return OPJ_FALSE;
}
+ if ( !p_start_x && !p_start_y && !p_end_x && !p_end_y){
+ opj_event_msg_v2(p_manager, EVT_INFO, "No decoded area parameters, set the decoded area to the all image\n");
+
+ p_j2k->m_specific_param.m_decoder.m_start_tile_x = 0;
+ p_j2k->m_specific_param.m_decoder.m_start_tile_y = 0;
+ p_j2k->m_specific_param.m_decoder.m_end_tile_x = l_cp->tw;
+ p_j2k->m_specific_param.m_decoder.m_end_tile_y = l_cp->th;
+
+ return OPJ_TRUE;
+ }
+
/* ----- */
/* Check if the positions provided by the user are correct */
/* Left */
- if (p_start_x > l_cp->tx0 + l_cp->tw * l_cp->tdx) {
+ if (p_start_x > l_image->x1 ) {
opj_event_msg_v2(p_manager, EVT_ERROR,
- "Left position of the decoded area (ROI_x0=%d) is outside the tile area (XTOsiz + nb_tw x XTsiz=%d).\n",
- p_start_x, l_cp->tx0 + l_cp->tw * l_cp->tdx);
+ "Left position of the decoded area (region_x0=%d) is outside the image area (Xsiz=%d).\n",
+ p_start_x, l_image->x1);
return OPJ_FALSE;
}
- else if (p_start_x < l_cp->tx0){
+ else if (p_start_x < l_image->x0){
opj_event_msg_v2(p_manager, EVT_WARNING,
- "Left position of the decoded area (ROI_x0=%d) is outside the tile area (XTOsiz=%d).\n",
- p_start_x, l_cp->tx0);
+ "Left position of the decoded area (region_x0=%d) is outside the image area (XOsiz=%d).\n",
+ p_start_x, l_image->x0);
p_j2k->m_specific_param.m_decoder.m_start_tile_x = 0;
+ p_image->x0 = l_image->x0;
}
- else
+ else {
p_j2k->m_specific_param.m_decoder.m_start_tile_x = (p_start_x - l_cp->tx0) / l_cp->tdx;
+ p_image->x0 = p_start_x;
+ }
/* Up */
- if (p_start_y > l_cp->ty0 + l_cp->th * l_cp->tdy){
+ if (p_start_y > l_image->y1){
opj_event_msg_v2(p_manager, EVT_ERROR,
- "Up position of the decoded area (ROI_y0=%d) is outside the tile area (YTOsiz + nb_th x YTsiz=%d).\n",
- p_start_y, l_cp->ty0 + l_cp->th * l_cp->tdy);
+ "Up position of the decoded area (region_y0=%d) is outside the image area (Ysiz=%d).\n",
+ p_start_y, l_image->y1);
return OPJ_FALSE;
}
- else if (p_start_y < l_cp->ty0){
+ else if (p_start_y < l_image->y0){
opj_event_msg_v2(p_manager, EVT_WARNING,
- "Up position of the decoded area (ROI_y0=%d) is outside the tile area (YTOsiz=%d).\n",
- p_start_y, l_cp->ty0);
+ "Up position of the decoded area (region_y0=%d) is outside the image area (YOsiz=%d).\n",
+ p_start_y, l_image->y0);
p_j2k->m_specific_param.m_decoder.m_start_tile_y = 0;
+ p_image->y0 = l_image->y0;
}
- else
+ else {
p_j2k->m_specific_param.m_decoder.m_start_tile_y = (p_start_y - l_cp->ty0) / l_cp->tdy;
+ p_image->y0 = p_start_y;
+ }
/* Right */
- if (p_end_x < l_cp->tx0) {
+ if (p_end_x < l_image->x0) {
opj_event_msg_v2(p_manager, EVT_ERROR,
- "Right position of the decoded area (ROI_x1=%d) is outside the tile area (XTOsiz=%d).\n",
- p_end_x, l_cp->tx0);
+ "Right position of the decoded area (region_x1=%d) is outside the image area (XOsiz=%d).\n",
+ p_end_x, l_image->x0);
return OPJ_FALSE;
}
- else if (p_end_x > l_cp->tx0 + l_cp->tw * l_cp->tdx) {
+ else if (p_end_x > l_image->x1) {
opj_event_msg_v2(p_manager, EVT_WARNING,
- "Right position of the decoded area (ROI_x1=%d) is outside the tile area (XTOsiz + nb_tw x XTsiz=%d).\n",
- p_end_x, l_cp->tx0 + l_cp->tw * l_cp->tdx);
- p_j2k->m_specific_param.m_decoder.m_end_tile_x = l_cp->tw; // FIXME (-1) ???
+ "Right position of the decoded area (region_x1=%d) is outside the image area (Xsiz=%d).\n",
+ p_end_x, l_image->x1);
+ p_j2k->m_specific_param.m_decoder.m_end_tile_x = l_cp->tw;
+ p_image->x1 = l_image->x1;
}
- else
+ else {
p_j2k->m_specific_param.m_decoder.m_end_tile_x = int_ceildiv((p_end_x - l_cp->tx0), l_cp->tdx);
+ p_image->x1 = p_end_x;
+ }
/* Bottom */
- if (p_end_y < l_cp->ty0) {
+ if (p_end_y < l_image->y0) {
opj_event_msg_v2(p_manager, EVT_ERROR,
- "Right position of the decoded area (ROI_y1=%d) is outside the tile area (YTOsiz=%d).\n",
- p_end_y, l_cp->ty0);
+ "Right position of the decoded area (region_y1=%d) is outside the image area (YOsiz=%d).\n",
+ p_end_y, l_image->y0);
return OPJ_FALSE;
}
- if (p_end_y > l_cp->ty0 + l_cp->th * l_cp->tdy){
+ if (p_end_y > l_image->y1){
opj_event_msg_v2(p_manager, EVT_WARNING,
- "Bottom position of the decoded area (ROI_y1=%d) is outside the tile area (YTOsiz + nb_th x YTsiz=%d).\n",
- p_end_y, l_cp->ty0 + l_cp->th * l_cp->tdy);
- p_j2k->m_specific_param.m_decoder.m_start_tile_y = l_cp->th; // FIXME (-1) ???
+ "Bottom position of the decoded area (region_y1=%d) is outside the image area (Ysiz=%d).\n",
+ p_end_y, l_image->y1);
+ p_j2k->m_specific_param.m_decoder.m_end_tile_y = l_cp->th;
+ p_image->y1 = l_image->y1;
}
- else
+ else{
p_j2k->m_specific_param.m_decoder.m_end_tile_y = int_ceildiv((p_end_y - l_cp->ty0), l_cp->tdy);
+ p_image->y1 = p_end_y;
+ }
/* ----- */
p_j2k->m_specific_param.m_decoder.m_discard_tiles = 1;
+ l_img_comp = p_image->comps;
+ for (it_comp=0; it_comp < p_image->numcomps; ++it_comp)
+ {
+ OPJ_INT32 l_h,l_w;
+
+ l_img_comp->x0 = int_ceildiv(p_image->x0, l_img_comp->dx);
+ l_img_comp->y0 = int_ceildiv(p_image->y0, l_img_comp->dy);
+ l_comp_x1 = int_ceildiv(p_image->x1, l_img_comp->dx);
+ l_comp_y1 = int_ceildiv(p_image->y1, l_img_comp->dy);
+
+ l_w = int_ceildivpow2(l_comp_x1, l_img_comp->factor)
+ - int_ceildivpow2(l_img_comp->x0, l_img_comp->factor);
+ if (l_w < 0){
+ opj_event_msg_v2(p_manager, EVT_ERROR,
+ "Size x of the decoded component image is incorrect (comp[%d].w=%d).\n",
+ it_comp, l_w);
+ return OPJ_FALSE;
+ }
+ l_img_comp->w = l_w;
+
+ l_h = int_ceildivpow2(l_comp_y1, l_img_comp->factor)
+ - int_ceildivpow2(l_img_comp->y0, l_img_comp->factor);
+ if (l_h < 0){
+ opj_event_msg_v2(p_manager, EVT_ERROR,
+ "Size y of the decoded component image is incorrect (comp[%d].h=%d).\n",
+ it_comp, l_h);
+ return OPJ_FALSE;
+ }
+ l_img_comp->h = l_h;
+
+ l_img_comp++;
+ }
+
+ opj_event_msg_v2( p_manager, EVT_INFO,"Setting decoding area to %d,%d,%d,%d\n",
+ p_image->x0, p_image->y0, p_image->x1, p_image->y1);
+
+
return OPJ_TRUE;
}
l_j2k->m_specific_param.m_decoder.m_header_data_size = J2K_DEFAULT_HEADER_SIZE;
+ l_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec = -1 ;
+
+ l_j2k->m_specific_param.m_decoder.m_last_sot_read_pos = 0 ;
+
/* codestream index creation */
l_j2k->cstr_index = j2k_create_cstr_index();
p_j2k->m_specific_param.m_decoder.m_default_tcp;
/* precondition again */
- assert(compno < p_j2k->m_image->numcomps);
+ assert(compno < p_j2k->m_private_image->numcomps);
l_tccp = &l_tcp->tccps[compno];
l_current_ptr = p_header_data;
l_copied_tccp = l_ref_tccp + 1;
l_prc_size = l_ref_tccp->numresolutions * sizeof(OPJ_UINT32);
- for (i=1; i<p_j2k->m_image->numcomps; ++i) {
+ for (i=1; i<p_j2k->m_private_image->numcomps; ++i) {
l_copied_tccp->numresolutions = l_ref_tccp->numresolutions;
l_copied_tccp->cblkw = l_ref_tccp->cblkw;
l_copied_tccp->cblkh = l_ref_tccp->cblkh;
p_j2k->m_specific_param.m_decoder.m_default_tcp;
// precondition again
- assert(p_comp_no < p_j2k->m_image->numcomps);
+ assert(p_comp_no < p_j2k->m_private_image->numcomps);
l_tccp = &l_tcp->tccps[p_comp_no];
l_current_ptr = p_header_data;
l_copied_tccp = l_ref_tccp + 1;
l_size = J2K_MAXBANDS * sizeof(opj_stepsize_t);
- for (i=1;i<p_j2k->m_image->numcomps;++i) {
+ for (i=1;i<p_j2k->m_private_image->numcomps;++i) {
l_copied_tccp->qntsty = l_ref_tccp->qntsty;
l_copied_tccp->numgbits = l_ref_tccp->numgbits;
memcpy(l_copied_tccp->stepsizes,l_ref_tccp->stepsizes,l_size);
/* Dump the image_header */
if (flag & OPJ_IMG_INFO){
- if (p_j2k->m_image)
- j2k_dump_image_header(p_j2k->m_image, 0, out_stream);
+ if (p_j2k->m_private_image)
+ j2k_dump_image_header(p_j2k->m_private_image, 0, out_stream);
}
/* Dump the codestream info from main header */
void j2k_dump_MH_index(opj_j2k_v2_t* p_j2k, FILE* out_stream)
{
opj_codestream_index_t* cstr_index = p_j2k->cstr_index;
- OPJ_UINT32 it_marker;
+ OPJ_UINT32 it_marker, it_tile, it_tile_part;
fprintf(out_stream, "Codestream index from main header: {\n");
- fprintf(out_stream, "\t Main header start position=%d\n\t Main header end position=%d\n",
+ fprintf(out_stream, "\t Main header start position=%" OPJ_OFF_F "d\n"
+ "\t Main header end position=%" OPJ_OFF_F "d\n",
cstr_index->main_head_start, cstr_index->main_head_end);
fprintf(out_stream, "\t Marker list: {\n");
- for (it_marker=0; it_marker < cstr_index->marknum ; it_marker++){
- fprintf(out_stream, "\t\t type=%#x, pos=%d, len=%d\n",
- cstr_index->marker[it_marker].type,
- cstr_index->marker[it_marker].pos,
- cstr_index->marker[it_marker].len );
+ if (cstr_index->marker){
+ for (it_marker=0; it_marker < cstr_index->marknum ; it_marker++){
+ fprintf(out_stream, "\t\t type=%#x, pos=%" OPJ_OFF_F "d, len=%d\n",
+ cstr_index->marker[it_marker].type,
+ cstr_index->marker[it_marker].pos,
+ cstr_index->marker[it_marker].len );
+ }
+ }
+
+ fprintf(out_stream, "\t }\n");
+
+
+ if (cstr_index->tile_index){
+ fprintf(out_stream, "\t Tile index: {\n");
+
+ for (it_tile=0; it_tile < cstr_index->nb_of_tiles ; it_tile++){
+ OPJ_UINT32 nb_of_tile_part = cstr_index->tile_index[it_tile].nb_tps;
+
+ fprintf(out_stream, "\t\t nb of tile-part in tile [%d]=%d\n", it_tile, nb_of_tile_part);
+
+ if (cstr_index->tile_index[it_tile].tp_index){
+ for (it_tile_part =0; it_tile_part < nb_of_tile_part; it_tile_part++){
+ fprintf(out_stream, "\t\t\t tile-part[%d]: star_pos=%" OPJ_OFF_F "d, end_header=%" OPJ_OFF_F "d, end_pos=%" OPJ_OFF_F "d.\n",
+ it_tile_part,
+ cstr_index->tile_index[it_tile].tp_index[it_tile_part].start_pos,
+ cstr_index->tile_index[it_tile].tp_index[it_tile_part].end_header,
+ cstr_index->tile_index[it_tile].tp_index[it_tile_part].end_pos);
+ }
+ }
+
+ if (cstr_index->tile_index[it_tile].marker){
+ for (it_marker=0; it_marker < cstr_index->tile_index[it_tile].marknum ; it_marker++){
+ fprintf(out_stream, "\t\t type=%#x, pos=%" OPJ_OFF_F "d, len=%d\n",
+ cstr_index->tile_index[it_tile].marker[it_marker].type,
+ cstr_index->tile_index[it_tile].marker[it_marker].pos,
+ cstr_index->tile_index[it_tile].marker[it_marker].len );
+ }
+ }
+ }
+ fprintf(out_stream,"\t }\n");
}
- fprintf(out_stream, "\t }\n}\n");
+ fprintf(out_stream,"}\n");
}
if (l_default_tile)
{
OPJ_INT32 compno;
- OPJ_INT32 numcomps = p_j2k->m_image->numcomps;
+ OPJ_INT32 numcomps = p_j2k->m_private_image->numcomps;
fprintf(out_stream, "\t default tile {\n");
fprintf(out_stream, "\t\t csty=%#x\n", l_default_tile->csty);
opj_codestream_info_v2_t* j2k_get_cstr_info(opj_j2k_v2_t* p_j2k)
{
OPJ_UINT16 compno;
- OPJ_UINT16 numcomps = p_j2k->m_image->numcomps;
+ OPJ_UINT16 numcomps = p_j2k->m_private_image->numcomps;
opj_tcp_v2_t *l_default_tile;
opj_codestream_info_v2_t* cstr_info = (opj_codestream_info_v2_t*) opj_calloc(1,sizeof(opj_codestream_info_v2_t));
- cstr_info->nbcomps = p_j2k->m_image->numcomps;
+ cstr_info->nbcomps = p_j2k->m_private_image->numcomps;
cstr_info->tx0 = p_j2k->m_cp.tx0;
cstr_info->ty0 = p_j2k->m_cp.ty0;
l_cstr_index->main_head_end = p_j2k->cstr_index->main_head_end;
l_cstr_index->codestream_size = p_j2k->cstr_index->codestream_size;
- l_cstr_index->maxmarknum = p_j2k->cstr_index->maxmarknum;
l_cstr_index->marknum = p_j2k->cstr_index->marknum;
l_cstr_index->marker = (opj_marker_info_t*)opj_malloc(l_cstr_index->marknum*sizeof(opj_marker_info_t));
- if (!l_cstr_index->marker)
+ if (!l_cstr_index->marker){
+ opj_free( l_cstr_index);
+ return NULL;
+ }
+
+ if (p_j2k->cstr_index->marker)
+ memcpy(l_cstr_index->marker, p_j2k->cstr_index->marker, l_cstr_index->marknum * sizeof(opj_marker_info_t) );
+ else{
+ opj_free(l_cstr_index->marker);
+ l_cstr_index->marker = NULL;
+ }
+
+ l_cstr_index->nb_of_tiles = p_j2k->cstr_index->nb_of_tiles;
+ l_cstr_index->tile_index = (opj_tile_index_t*)opj_calloc(l_cstr_index->nb_of_tiles, sizeof(opj_tile_index_t) );
+ if (!l_cstr_index->tile_index){
+ opj_free( l_cstr_index->marker);
+ opj_free( l_cstr_index);
return NULL;
+ }
- memcpy(l_cstr_index->marker, p_j2k->cstr_index->marker, l_cstr_index->marknum * sizeof(opj_marker_info_t) );
+ if (!p_j2k->cstr_index->tile_index){
+ opj_free(l_cstr_index->tile_index);
+ l_cstr_index->tile_index = NULL;
+ }
+ else {
+ OPJ_UINT32 it_tile = 0;
+ for (it_tile = 0; it_tile < l_cstr_index->nb_of_tiles; it_tile++ ){
- l_cstr_index->tile_index = NULL; /* FIXME not used for the moment*/
+ /* Tile Marker*/
+ l_cstr_index->tile_index[it_tile].marknum = p_j2k->cstr_index->tile_index[it_tile].marknum;
+
+ l_cstr_index->tile_index[it_tile].marker =
+ (opj_marker_info_t*)opj_malloc(l_cstr_index->tile_index[it_tile].marknum*sizeof(opj_marker_info_t));
+
+ if (!l_cstr_index->tile_index[it_tile].marker) {
+ OPJ_UINT32 it_tile_free;
+
+ for (it_tile_free=0; it_tile_free < it_tile; it_tile_free++){
+ opj_free(l_cstr_index->tile_index[it_tile_free].marker);
+ }
+
+ opj_free( l_cstr_index->tile_index);
+ opj_free( l_cstr_index->marker);
+ opj_free( l_cstr_index);
+ return NULL;
+ }
+
+ if (p_j2k->cstr_index->tile_index[it_tile].marker)
+ memcpy( l_cstr_index->tile_index[it_tile].marker,
+ p_j2k->cstr_index->tile_index[it_tile].marker,
+ l_cstr_index->tile_index[it_tile].marknum * sizeof(opj_marker_info_t) );
+ else{
+ opj_free(l_cstr_index->tile_index[it_tile].marker);
+ l_cstr_index->tile_index[it_tile].marker = NULL;
+ }
+
+ /* Tile part index*/
+ l_cstr_index->tile_index[it_tile].nb_tps = p_j2k->cstr_index->tile_index[it_tile].nb_tps;
+
+ l_cstr_index->tile_index[it_tile].tp_index =
+ (opj_tp_index_t*)opj_malloc(l_cstr_index->tile_index[it_tile].nb_tps*sizeof(opj_tp_index_t));
+
+ if(!l_cstr_index->tile_index[it_tile].tp_index){
+ OPJ_UINT32 it_tile_free;
+
+ for (it_tile_free=0; it_tile_free < it_tile; it_tile_free++){
+ opj_free(l_cstr_index->tile_index[it_tile_free].marker);
+ opj_free(l_cstr_index->tile_index[it_tile_free].tp_index);
+ }
+
+ opj_free( l_cstr_index->tile_index);
+ opj_free( l_cstr_index->marker);
+ opj_free( l_cstr_index);
+ return NULL;
+ }
+
+ if (p_j2k->cstr_index->tile_index[it_tile].tp_index){
+ memcpy( l_cstr_index->tile_index[it_tile].tp_index,
+ p_j2k->cstr_index->tile_index[it_tile].tp_index,
+ l_cstr_index->tile_index[it_tile].nb_tps * sizeof(opj_tp_index_t) );
+ }
+ else{
+ opj_free(l_cstr_index->tile_index[it_tile].tp_index);
+ l_cstr_index->tile_index[it_tile].tp_index = NULL;
+ }
+
+ /* Packet index (NOT USED)*/
+ l_cstr_index->tile_index[it_tile].nb_packet = 0;
+ l_cstr_index->tile_index[it_tile].packet_index = NULL;
+
+ }
+ }
return l_cstr_index;
}
+opj_bool j2k_allocate_tile_element_cstr_index(opj_j2k_v2_t *p_j2k)
+{
+ OPJ_UINT32 it_tile=0;
+
+ p_j2k->cstr_index->nb_of_tiles = p_j2k->m_cp.tw * p_j2k->m_cp.tw;
+ p_j2k->cstr_index->tile_index = (opj_tile_index_t*)opj_calloc(p_j2k->cstr_index->nb_of_tiles, sizeof(opj_tile_index_t));
+ if (!p_j2k->cstr_index->tile_index)
+ return OPJ_FALSE;
+
+ for (it_tile=0; it_tile < p_j2k->cstr_index->nb_of_tiles; it_tile++){
+ p_j2k->cstr_index->tile_index[it_tile].maxmarknum = 100;
+ p_j2k->cstr_index->tile_index[it_tile].marknum = 0;
+ p_j2k->cstr_index->tile_index[it_tile].marker = (opj_marker_info_t*)
+ opj_calloc(p_j2k->cstr_index->tile_index[it_tile].maxmarknum, sizeof(opj_marker_info_t));
+ if (!p_j2k->cstr_index->tile_index[it_tile].marker)
+ return OPJ_FALSE;
+ }
+ return OPJ_TRUE;
+}
/**
* Reads the tiles.
}
l_max_data_size = 1000;
+ /*Allocate and initialize some elements of codestrem index*/
+ if (!j2k_allocate_tile_element_cstr_index(p_j2k))
+ return OPJ_FALSE;
+
while (OPJ_TRUE) {
if (! j2k_read_tile_header( p_j2k,
&l_current_tile_no,
&l_go_on,
p_stream,
p_manager)) {
+ opj_free(l_current_data);
return OPJ_FALSE;
}
}
opj_event_msg_v2(p_manager, EVT_INFO, "Tile %d/%d has been decode.\n", l_current_tile_no +1, p_j2k->m_cp.th * p_j2k->m_cp.tw);
- if (! j2k_update_image_data(p_j2k->m_tcd,l_current_data)) {
+ if (! j2k_update_image_data(p_j2k->m_tcd,l_current_data, p_j2k->m_output_image)) {
opj_free(l_current_data);
return OPJ_FALSE;
}
}
opj_free(l_current_data);
+
return OPJ_TRUE;
}
-
/**
* Sets up the procedures to do on decoding data. Developpers wanting to extend the library can add their own reading procedures.
*/
}
+/*
+ * Read and decode one tile.
+ */
+opj_bool j2k_decode_one_tile ( opj_j2k_v2_t *p_j2k,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager)
+{
+ opj_bool l_go_on = OPJ_TRUE;
+ OPJ_UINT32 l_current_tile_no;
+ OPJ_UINT32 l_tile_no_to_dec;
+ OPJ_UINT32 l_data_size,l_max_data_size;
+ OPJ_INT32 l_tile_x0,l_tile_y0,l_tile_x1,l_tile_y1;
+ OPJ_UINT32 l_nb_comps;
+ OPJ_BYTE * l_current_data;
+
+ l_current_data = (OPJ_BYTE*)opj_malloc(1000);
+ if (! l_current_data) {
+ return OPJ_FALSE;
+ }
+ l_max_data_size = 1000;
+
+ /*Allocate and initialize some elements of codestrem index if not already done*/
+ if( !p_j2k->cstr_index->tile_index)
+ {
+ if (!j2k_allocate_tile_element_cstr_index(p_j2k))
+ return OPJ_FALSE;
+ }
+ /* Move into the codestream to the first SOT used to decode the desired tile */
+ l_tile_no_to_dec = p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec;
+ if (p_j2k->cstr_index->tile_index)
+ if(p_j2k->cstr_index->tile_index->tp_index)
+ {
+ if ( ! p_j2k->cstr_index->tile_index[l_tile_no_to_dec].nb_tps) {
+ /* the index for this tile has not been built,
+ * so move to the last SOT read */
+ if ( opj_stream_read_seek(p_stream, p_j2k->m_specific_param.m_decoder.m_last_sot_read_pos+2, p_manager) ){
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Problem with seek function\n");
+ return OPJ_FALSE;
+ }
+ }
+ else{
+ if (opj_stream_read_seek(p_stream, p_j2k->cstr_index->tile_index[l_tile_no_to_dec].tp_index[0].start_pos+2, p_manager)) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Problem with seek function\n");
+ return OPJ_FALSE;
+ }
+ }
+ /* Special case if we have previously read the EOC marker (if the previous tile getted is the last ) */
+ if(p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_EOC)
+ p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_TPHSOT;
+ }
+
+ while (OPJ_TRUE) {
+ if (! j2k_read_tile_header( p_j2k,
+ &l_current_tile_no,
+ &l_data_size,
+ &l_tile_x0, &l_tile_y0,
+ &l_tile_x1, &l_tile_y1,
+ &l_nb_comps,
+ &l_go_on,
+ p_stream,
+ p_manager)) {
+ opj_free(l_current_data);
+ return OPJ_FALSE;
+ }
+
+
+ if (! l_go_on) {
+ break;
+ }
+
+ if (l_data_size > l_max_data_size) {
+ l_current_data = (OPJ_BYTE*)opj_realloc(l_current_data,l_data_size);
+ if (! l_current_data) {
+ return OPJ_FALSE;
+ }
+
+ l_max_data_size = l_data_size;
+ }
+
+
+
+ if (! j2k_decode_tile(p_j2k,l_current_tile_no,l_current_data,l_data_size,p_stream,p_manager)) {
+ opj_free(l_current_data);
+ return OPJ_FALSE;
+ }
+ opj_event_msg_v2(p_manager, EVT_INFO, "Tile %d/%d has been decode.\n", l_current_tile_no, (p_j2k->m_cp.th * p_j2k->m_cp.tw) - 1);
+
+ if (! j2k_update_image_data(p_j2k->m_tcd,l_current_data, p_j2k->m_output_image)) {
+ opj_free(l_current_data);
+ return OPJ_FALSE;
+ }
+ opj_event_msg_v2(p_manager, EVT_INFO, "Image data has been updated with tile %d.\n\n", l_current_tile_no);
+
+ if(l_current_tile_no == l_tile_no_to_dec)
+ {
+ /* move into the codestream to the the first SOT (FIXME or not move?)*/
+ if (opj_stream_read_seek(p_stream, p_j2k->cstr_index->main_head_end + 2, p_manager) ) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Problem with seek function\n");
+ return OPJ_FALSE;
+ }
+ break;
+ }
+ else {
+ opj_event_msg_v2(p_manager, EVT_WARNING, "Tile read, decode and updated is not the desired (%d vs %d).\n", l_current_tile_no, l_tile_no_to_dec);
+ }
+
+ }
+
+ opj_free(l_current_data);
+
+ return OPJ_TRUE;
+}
+
+
+/**
+ * Sets up the procedures to do on decoding one tile. Developpers wanting to extend the library can add their own reading procedures.
+ */
+void j2k_setup_decoding_tile (opj_j2k_v2_t *p_j2k)
+{
+ // preconditions
+ assert(p_j2k != 00);
+
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_decode_one_tile);
+ /* DEVELOPER CORNER, add your custom procedures */
+
+}
+
/**
* Decodes the tiles of the stream.
if (!p_image)
return OPJ_FALSE;
+ p_j2k->m_output_image = opj_image_create0();
+ if (! (p_j2k->m_output_image)) {
+ return OPJ_FALSE;
+ }
+ opj_copy_image_header(p_image, p_j2k->m_output_image);
+
/* customization of the decoding */
j2k_setup_decoding(p_j2k);
/* Decode the codestream */
if (! j2k_exec (p_j2k,p_j2k->m_procedure_list,p_stream,p_manager)) {
- opj_image_destroy(p_j2k->m_image);
- p_j2k->m_image = NULL;
+ opj_image_destroy(p_j2k->m_private_image);
+ p_j2k->m_private_image = NULL;
+ return OPJ_FALSE;
+ }
+
+ /* Move data and copy one information from codec to output image*/
+ for (compno = 0; compno < p_image->numcomps; compno++) {
+ p_image->comps[compno].resno_decoded = p_j2k->m_output_image->comps[compno].resno_decoded;
+ p_image->comps[compno].data = p_j2k->m_output_image->comps[compno].data;
+ p_j2k->m_output_image->comps[compno].data = NULL;
+ }
+
+ return OPJ_TRUE;
+}
+
+
+/**
+ * Get the decoded tile.
+ *
+ * @param p_j2k the jpeg2000 codestream codec.
+ * @param p_stream input_stream
+ * @param p_image output image. .
+ * @param p_manager the user event manager
+ * @param tile_index index of the tile we want decode
+ *
+ * @return true if succeed.
+ */
+opj_bool j2k_get_tile( opj_j2k_v2_t *p_j2k,
+ opj_stream_private_t *p_stream,
+ opj_image_t* p_image,
+ struct opj_event_mgr * p_manager,
+ OPJ_UINT32 tile_index )
+{
+ OPJ_UINT32 compno;
+ OPJ_UINT32 l_tile_x, l_tile_y;
+ opj_image_comp_t* l_img_comp;
+
+ if (!p_image) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "We need a image previously created.\n");
+ return OPJ_FALSE;
+ }
+
+ if ( (tile_index < 0) && (tile_index >= p_j2k->m_cp.tw * p_j2k->m_cp.th) ){
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Tile index provided by the user is incorrect %d (max = %d) \n", tile_index, (p_j2k->m_cp.tw * p_j2k->m_cp.th) - 1);
+ return OPJ_FALSE;
+ }
+
+ /* Compute the dimension of the desired tile*/
+ l_tile_x = tile_index % p_j2k->m_cp.tw;
+ l_tile_y = tile_index / p_j2k->m_cp.tw;
+
+ p_image->x0 = l_tile_x * p_j2k->m_cp.tdx + p_j2k->m_cp.tx0;
+ if (p_image->x0 < p_j2k->m_private_image->x0)
+ p_image->x0 = p_j2k->m_private_image->x0;
+ p_image->x1 = (l_tile_x + 1) * p_j2k->m_cp.tdx + p_j2k->m_cp.tx0;
+ if (p_image->x1 > p_j2k->m_private_image->x1)
+ p_image->x1 = p_j2k->m_private_image->x1;
+
+ p_image->y0 = l_tile_y * p_j2k->m_cp.tdy + p_j2k->m_cp.ty0;
+ if (p_image->y0 < p_j2k->m_private_image->y0)
+ p_image->y0 = p_j2k->m_private_image->y0;
+ p_image->y1 = (l_tile_y + 1) * p_j2k->m_cp.tdy + p_j2k->m_cp.ty0;
+ if (p_image->y1 > p_j2k->m_private_image->y1)
+ p_image->y1 = p_j2k->m_private_image->y1;
+
+ l_img_comp = p_image->comps;
+ for (compno=0; compno < p_image->numcomps; ++compno)
+ {
+ OPJ_INT32 l_comp_x1, l_comp_y1;
+
+ l_img_comp->factor = p_j2k->m_private_image->comps[compno].factor;
+
+ l_img_comp->x0 = int_ceildiv(p_image->x0, l_img_comp->dx);
+ l_img_comp->y0 = int_ceildiv(p_image->y0, l_img_comp->dy);
+ l_comp_x1 = int_ceildiv(p_image->x1, l_img_comp->dx);
+ l_comp_y1 = int_ceildiv(p_image->y1, l_img_comp->dy);
+
+ l_img_comp->w = int_ceildivpow2(l_comp_x1, l_img_comp->factor) - int_ceildivpow2(l_img_comp->x0, l_img_comp->factor);
+ l_img_comp->h = int_ceildivpow2(l_comp_y1, l_img_comp->factor) - int_ceildivpow2(l_img_comp->y0, l_img_comp->factor);
+
+ l_img_comp++;
+ }
+
+ /* Destroy the previous output image*/
+ if (p_j2k->m_output_image)
+ opj_image_destroy(p_j2k->m_output_image);
+
+ /* Create the ouput image from the information previously computed*/
+ p_j2k->m_output_image = opj_image_create0();
+ if (! (p_j2k->m_output_image)) {
+ return OPJ_FALSE;
+ }
+ opj_copy_image_header(p_image, p_j2k->m_output_image);
+
+ p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec = tile_index;
+
+ /* customization of the decoding */
+ j2k_setup_decoding_tile(p_j2k);
+
+ /* Decode the codestream */
+ if (! j2k_exec (p_j2k,p_j2k->m_procedure_list,p_stream,p_manager)) {
+ opj_image_destroy(p_j2k->m_private_image);
+ p_j2k->m_private_image = NULL;
return OPJ_FALSE;
}
- /* Copy data from codec to output image*/
+ /* Move data and copy one information from codec to output image*/
for (compno = 0; compno < p_image->numcomps; compno++) {
- p_image->comps[compno].data = p_j2k->m_image->comps[compno].data;
- p_j2k->m_image->comps[compno].data = NULL;
+ p_image->comps[compno].resno_decoded = p_j2k->m_output_image->comps[compno].resno_decoded;
+
+ if (p_image->comps[compno].data)
+ opj_free(p_image->comps[compno].data);
+
+ p_image->comps[compno].data = p_j2k->m_output_image->comps[compno].data;
+
+ p_j2k->m_output_image->comps[compno].data = NULL;
}
return OPJ_TRUE;
}
+
+opj_bool j2k_set_decoded_resolution_factor(opj_j2k_v2_t *p_j2k, OPJ_UINT32 res_factor, opj_event_mgr_t * p_manager)
+{
+ OPJ_UINT32 it_comp;
+
+ p_j2k->m_cp.m_specific_param.m_dec.m_reduce = res_factor;
+
+ if (p_j2k->m_private_image) {
+ if (p_j2k->m_private_image->comps) {
+ if (p_j2k->m_specific_param.m_decoder.m_default_tcp) {
+ if (p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps) {
+ for (it_comp = 0 ; it_comp < p_j2k->m_private_image->numcomps; it_comp++) {
+ OPJ_UINT32 max_res = p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps[it_comp].numresolutions;
+ if ( res_factor >= max_res){
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Resolution factor is superior to the maximum resolution in the component.\n");
+ return OPJ_FALSE;
+ }
+ p_j2k->m_private_image->comps[it_comp].factor = res_factor;
+ }
+ return OPJ_TRUE;
+ }
+ }
+ }
+ }
+
+ return OPJ_FALSE;
+}
projects / openjpeg.git / blobdiff