walkero
/
openjpeg
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity

[trunk] Fix all C90 issues using gcc -pedantic -Wno-long-long to track them 

As a side effect, fix all comment style to remove extra gcc output

Fixes issue 173
This commit is contained in:
Mathieu Malaterre 2012-09-10 09:04:47 +00:00
parent 3135642ff5
commit 20beb093a1
11 changed files with 193 additions and 176 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
applications/codec/j2k_to_image.c
View File

@ -811,7 +811,7 @@ int main(int argc, char **argv)
} }
if (!parameters.nb_tile_to_decode) { if (!parameters.nb_tile_to_decode) {
// Optional if you want decode the entire image /* Optional if you want decode the entire image */
if (!opj_set_decode_area(l_codec, image, parameters.DA_x0, if (!opj_set_decode_area(l_codec, image, parameters.DA_x0,
parameters.DA_y0, parameters.DA_x1, parameters.DA_y1)){ parameters.DA_y0, parameters.DA_x1, parameters.DA_y1)){
fprintf(stderr, "ERROR -> j2k_to_image: failed to set the decoded area\n"); fprintf(stderr, "ERROR -> j2k_to_image: failed to set the decoded area\n");
@ -834,7 +834,7 @@ int main(int argc, char **argv)
} }
else { else {
// It is just here to illustrate how to use the resolution after set parameters /* It is just here to illustrate how to use the resolution after set parameters */
/*if (!opj_set_decoded_resolution_factor(l_codec, 5)) { /*if (!opj_set_decoded_resolution_factor(l_codec, 5)) {
fprintf(stderr, "ERROR -> j2k_to_image: failed to set the resolution factor tile!\n"); fprintf(stderr, "ERROR -> j2k_to_image: failed to set the resolution factor tile!\n");
opj_destroy_codec(l_codec); opj_destroy_codec(l_codec);

2
libopenjpeg/event.c
View File

@ -66,7 +66,7 @@ _itoa(int i, char *a, int r) {
* Default callback function. * Default callback function.
* Do nothing. * Do nothing.
*/ */
static void opj_default_callback (const char *msg, void *client_data){}; static void opj_default_callback (const char *msg, void *client_data){}
/* ----------------------------------------------------------------------- */ /* ----------------------------------------------------------------------- */
opj_bool opj_event_msg(opj_common_ptr cinfo, int event_type, const char *fmt, ...) { opj_bool opj_event_msg(opj_common_ptr cinfo, int event_type, const char *fmt, ...) {

32
libopenjpeg/event.h
View File

@ -40,21 +40,23 @@ used for
<li>Debugging messages <li>Debugging messages
</ul> </ul>
*/ */
//typedef struct opj_event_mgr #if 0
//{ typedef struct opj_event_mgr
// /** Data to call the event manager upon */ {
// void * m_error_data; /** Data to call the event manager upon */
// /** Data to call the event manager upon */ void * m_error_data;
// void * m_warning_data; /** Data to call the event manager upon */
// /** Data to call the event manager upon */ void * m_warning_data;
// void * m_info_data; /** Data to call the event manager upon */
// /** Error message callback if available, NULL otherwise */ void * m_info_data;
// opj_msg_callback error_handler; /** Error message callback if available, NULL otherwise */
// /** Warning message callback if available, NULL otherwise */ opj_msg_callback error_handler;
// opj_msg_callback warning_handler; /** Warning message callback if available, NULL otherwise */
// /** Debug message callback if available, NULL otherwise */ opj_msg_callback warning_handler;
// opj_msg_callback info_handler; /** Debug message callback if available, NULL otherwise */
//} opj_event_mgr_t; opj_msg_callback info_handler;
} opj_event_mgr_t;
#endif
#define EVT_ERROR 1 /**< Error event type */ #define EVT_ERROR 1 /**< Error event type */
#define EVT_WARNING 2 /**< Warning event type */ #define EVT_WARNING 2 /**< Warning event type */

93
libopenjpeg/j2k.c
View File

@ -1465,18 +1465,18 @@ opj_bool opj_j2k_check_poc_val( const opj_poc_t *p_pocs,
} }
index = step_r * p_pocs->resno0; index = step_r * p_pocs->resno0;
// take each resolution for each poc /* take each resolution for each poc */
for (resno = p_pocs->resno0 ; resno < p_pocs->resno1 ; ++resno) for (resno = p_pocs->resno0 ; resno < p_pocs->resno1 ; ++resno)
{ {
OPJ_UINT32 res_index = index + p_pocs->compno0 * step_c; OPJ_UINT32 res_index = index + p_pocs->compno0 * step_c;
// take each comp of each resolution for each poc /* take each comp of each resolution for each poc */
for (compno = p_pocs->compno0 ; compno < p_pocs->compno1 ; ++compno) { for (compno = p_pocs->compno0 ; compno < p_pocs->compno1 ; ++compno) {
OPJ_UINT32 comp_index = res_index + layno0 * step_l; OPJ_UINT32 comp_index = res_index + layno0 * step_l;
// and finally take each layer of each res of ... /* and finally take each layer of each res of ... */
for (layno = layno0; layno < p_pocs->layno1 ; ++layno) { for (layno = layno0; layno < p_pocs->layno1 ; ++layno) {
//index = step_r * resno + step_c * compno + step_l * layno; /*index = step_r * resno + step_c * compno + step_l * layno;*/
packet_array[comp_index] = 1; packet_array[comp_index] = 1;
comp_index += step_l; comp_index += step_l;
} }
@ -1488,24 +1488,24 @@ opj_bool opj_j2k_check_poc_val( const opj_poc_t *p_pocs,
} }
++p_pocs; ++p_pocs;
// iterate through all the pocs /* iterate through all the pocs */
for (i = 1; i < p_nb_pocs ; ++i) { for (i = 1; i < p_nb_pocs ; ++i) {
OPJ_UINT32 l_last_layno1 = (p_pocs-1)->layno1 ; OPJ_UINT32 l_last_layno1 = (p_pocs-1)->layno1 ;
layno0 = (p_pocs->layno1 > l_last_layno1)? l_last_layno1 : 0; layno0 = (p_pocs->layno1 > l_last_layno1)? l_last_layno1 : 0;
index = step_r * p_pocs->resno0; index = step_r * p_pocs->resno0;
// take each resolution for each poc /* take each resolution for each poc */
for (resno = p_pocs->resno0 ; resno < p_pocs->resno1 ; ++resno) { for (resno = p_pocs->resno0 ; resno < p_pocs->resno1 ; ++resno) {
OPJ_UINT32 res_index = index + p_pocs->compno0 * step_c; OPJ_UINT32 res_index = index + p_pocs->compno0 * step_c;
// take each comp of each resolution for each poc /* take each comp of each resolution for each poc */
for (compno = p_pocs->compno0 ; compno < p_pocs->compno1 ; ++compno) { for (compno = p_pocs->compno0 ; compno < p_pocs->compno1 ; ++compno) {
OPJ_UINT32 comp_index = res_index + layno0 * step_l; OPJ_UINT32 comp_index = res_index + layno0 * step_l;
// and finally take each layer of each res of ... /* and finally take each layer of each res of ... */
for (layno = layno0; layno < p_pocs->layno1 ; ++layno) { for (layno = layno0; layno < p_pocs->layno1 ; ++layno) {
//index = step_r * resno + step_c * compno + step_l * layno; /*index = step_r * resno + step_c * compno + step_l * layno;*/
packet_array[comp_index] = 1; packet_array[comp_index] = 1;
comp_index += step_l; comp_index += step_l;
} }
@ -1524,7 +1524,7 @@ opj_bool opj_j2k_check_poc_val( const opj_poc_t *p_pocs,
for (resno = 0; resno < p_nb_resolutions; ++resno) { for (resno = 0; resno < p_nb_resolutions; ++resno) {
for (compno = 0; compno < p_num_comps; ++compno) { for (compno = 0; compno < p_num_comps; ++compno) {
loss |= (packet_array[index]!=1); loss |= (packet_array[index]!=1);
//index = step_r * resno + step_c * compno + step_l * layno; /*index = step_r * resno + step_c * compno + step_l * layno;*/
index += step_c; index += step_c;
} }
} }
@ -2174,7 +2174,7 @@ opj_bool opj_j2k_write_com( opj_j2k_v2_t *p_j2k,
const OPJ_CHAR *l_comment; const OPJ_CHAR *l_comment;
OPJ_BYTE * l_current_ptr = 00; OPJ_BYTE * l_current_ptr = 00;
// preconditions /* preconditions */
assert(p_j2k != 00); assert(p_j2k != 00);
assert(p_stream != 00); assert(p_stream != 00);
assert(p_manager != 00); assert(p_manager != 00);
@ -2419,12 +2419,13 @@ opj_bool opj_j2k_write_coc( opj_j2k_v2_t *p_j2k,
l_coc_size = 5 + l_comp_room + opj_j2k_get_SPCod_SPCoc_size(p_j2k,p_j2k->m_current_tile_number,p_comp_no); l_coc_size = 5 + l_comp_room + opj_j2k_get_SPCod_SPCoc_size(p_j2k,p_j2k->m_current_tile_number,p_comp_no);
if (l_coc_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) { if (l_coc_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) {
OPJ_BYTE *new_header_tile_data;
p_j2k->m_specific_param.m_encoder.m_header_tile_data p_j2k->m_specific_param.m_encoder.m_header_tile_data
= (OPJ_BYTE*)opj_realloc( = (OPJ_BYTE*)opj_realloc(
p_j2k->m_specific_param.m_encoder.m_header_tile_data, p_j2k->m_specific_param.m_encoder.m_header_tile_data,
l_coc_size); l_coc_size);
OPJ_BYTE *new_header_tile_data = (OPJ_BYTE *) opj_realloc(p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_coc_size); new_header_tile_data = (OPJ_BYTE *) opj_realloc(p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_coc_size);
if (! new_header_tile_data) { if (! new_header_tile_data) {
opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data); opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL; p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL;
@ -2851,7 +2852,7 @@ opj_bool opj_j2k_write_poc( opj_j2k_v2_t *p_j2k,
opj_tccp_t *l_tccp = 00; opj_tccp_t *l_tccp = 00;
OPJ_UINT32 l_poc_room; OPJ_UINT32 l_poc_room;
// preconditions /* preconditions */
assert(p_j2k != 00); assert(p_j2k != 00);
assert(p_manager != 00); assert(p_manager != 00);
assert(p_stream != 00); assert(p_stream != 00);
@ -3501,13 +3502,14 @@ opj_bool j2k_read_ppm_v3 (
l_N_ppm = l_cp->ppm_len - l_cp->ppm_data_read; l_N_ppm = l_cp->ppm_len - l_cp->ppm_data_read;
} }
else { else {
OPJ_BYTE *new_ppm_data;
opj_read_bytes(p_header_data,&l_N_ppm,4); /* First N_ppm */ opj_read_bytes(p_header_data,&l_N_ppm,4); /* First N_ppm */
p_header_data+=4; p_header_data+=4;
p_header_size-=4; p_header_size-=4;
/* Increase the size of ppm_data to add the new Ippm series*/ /* Increase the size of ppm_data to add the new Ippm series*/
assert(l_cp->ppm_data == l_cp->ppm_buffer && "We need ppm_data and ppm_buffer to be the same when reallocating"); assert(l_cp->ppm_data == l_cp->ppm_buffer && "We need ppm_data and ppm_buffer to be the same when reallocating");
OPJ_BYTE *new_ppm_data = (OPJ_BYTE *) opj_realloc(l_cp->ppm_data, l_cp->ppm_len + l_N_ppm); new_ppm_data = (OPJ_BYTE *) opj_realloc(l_cp->ppm_data, l_cp->ppm_len + l_N_ppm);
if (! new_ppm_data) { if (! new_ppm_data) {
opj_free(l_cp->ppm_data); opj_free(l_cp->ppm_data);
l_cp->ppm_data = NULL; l_cp->ppm_data = NULL;
@ -3551,9 +3553,10 @@ opj_bool j2k_read_ppm_v3 (
/* Next Ippm series is a complete series ?*/ /* Next Ippm series is a complete series ?*/
if (l_remaining_data > l_N_ppm) { if (l_remaining_data > l_N_ppm) {
OPJ_BYTE *new_ppm_data;
/* Increase the size of ppm_data to add the new Ippm series*/ /* Increase the size of ppm_data to add the new Ippm series*/
assert(l_cp->ppm_data == l_cp->ppm_buffer && "We need ppm_data and ppm_buffer to be the same when reallocating"); assert(l_cp->ppm_data == l_cp->ppm_buffer && "We need ppm_data and ppm_buffer to be the same when reallocating");
OPJ_BYTE *new_ppm_data = (OPJ_BYTE *) opj_realloc(l_cp->ppm_data, l_cp->ppm_len + l_N_ppm); new_ppm_data = (OPJ_BYTE *) opj_realloc(l_cp->ppm_data, l_cp->ppm_len + l_N_ppm);
if (! new_ppm_data) { if (! new_ppm_data) {
opj_free(l_cp->ppm_data); opj_free(l_cp->ppm_data);
l_cp->ppm_data = NULL; l_cp->ppm_data = NULL;
@ -3574,8 +3577,9 @@ opj_bool j2k_read_ppm_v3 (
/* Need to read an incomplete Ippm series*/ /* Need to read an incomplete Ippm series*/
if (l_remaining_data) { if (l_remaining_data) {
OPJ_BYTE *new_ppm_data;
assert(l_cp->ppm_data == l_cp->ppm_buffer && "We need ppm_data and ppm_buffer to be the same when reallocating"); assert(l_cp->ppm_data == l_cp->ppm_buffer && "We need ppm_data and ppm_buffer to be the same when reallocating");
OPJ_BYTE *new_ppm_data = (OPJ_BYTE *) opj_realloc(l_cp->ppm_data, l_cp->ppm_len + l_N_ppm); new_ppm_data = (OPJ_BYTE *) opj_realloc(l_cp->ppm_data, l_cp->ppm_len + l_N_ppm);
if (! new_ppm_data) { if (! new_ppm_data) {
opj_free(l_cp->ppm_data); opj_free(l_cp->ppm_data);
l_cp->ppm_data = NULL; l_cp->ppm_data = NULL;
@ -3706,9 +3710,10 @@ static opj_bool opj_j2k_read_ppt ( opj_j2k_v2_t *p_j2k,
/* memset(l_tcp->ppt_buffer,0,l_tcp->ppt_len); */ /* memset(l_tcp->ppt_buffer,0,l_tcp->ppt_len); */
} }
else { else {
OPJ_BYTE *new_ppt_buffer;
l_tcp->ppt_len += p_header_size; l_tcp->ppt_len += p_header_size;
OPJ_BYTE *new_ppt_buffer = (OPJ_BYTE *) opj_realloc(l_tcp->ppt_buffer, l_tcp->ppt_len); new_ppt_buffer = (OPJ_BYTE *) opj_realloc(l_tcp->ppt_buffer, l_tcp->ppt_len);
if (! new_ppt_buffer) { if (! new_ppt_buffer) {
opj_free(l_tcp->ppt_buffer); opj_free(l_tcp->ppt_buffer);
l_tcp->ppt_buffer = NULL; l_tcp->ppt_buffer = NULL;
@ -3738,7 +3743,7 @@ opj_bool opj_j2k_write_tlm( opj_j2k_v2_t *p_j2k,
OPJ_BYTE * l_current_data = 00; OPJ_BYTE * l_current_data = 00;
OPJ_UINT32 l_tlm_size; OPJ_UINT32 l_tlm_size;
// preconditions /* preconditions */
assert(p_j2k != 00); assert(p_j2k != 00);
assert(p_manager != 00); assert(p_manager != 00);
assert(p_stream != 00); assert(p_stream != 00);
@ -3761,7 +3766,7 @@ opj_bool opj_j2k_write_tlm( opj_j2k_v2_t *p_j2k,
l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data; l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
/* change the way data is written to avoid seeking if possible */ /* change the way data is written to avoid seeking if possible */
// TODO /* TODO */
p_j2k->m_specific_param.m_encoder.m_tlm_start = opj_stream_tell(p_stream); p_j2k->m_specific_param.m_encoder.m_tlm_start = opj_stream_tell(p_stream);
opj_write_bytes(l_current_data,J2K_MS_TLM,2); /* TLM */ opj_write_bytes(l_current_data,J2K_MS_TLM,2); /* TLM */
@ -4017,8 +4022,9 @@ opj_bool opj_j2k_read_sot ( opj_j2k_v2_t *p_j2k,
} }
if ( l_current_part >= p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps ){ if ( l_current_part >= p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps ){
opj_tp_index_t *new_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].current_nb_tps += 10;
opj_tp_index_t *new_tp_index = (opj_tp_index_t *) opj_realloc( new_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].tp_index,
p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps * sizeof(opj_tp_index_t)); p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps * sizeof(opj_tp_index_t));
if (! new_tp_index) { if (! new_tp_index) {
@ -4190,10 +4196,10 @@ opj_bool opj_j2k_read_sod (opj_j2k_v2_t *p_j2k,
OPJ_BYTE *l_new_current_data = (OPJ_BYTE *) opj_realloc(*l_current_data, *l_tile_len + p_j2k->m_specific_param.m_decoder.m_sot_length); OPJ_BYTE *l_new_current_data = (OPJ_BYTE *) opj_realloc(*l_current_data, *l_tile_len + p_j2k->m_specific_param.m_decoder.m_sot_length);
if (! l_new_current_data) { if (! l_new_current_data) {
opj_free(*l_current_data); opj_free(*l_current_data);
// nothing more is done as l_current_data will be set to null, and just /*nothing more is done as l_current_data will be set to null, and just
// afterward we enter in the error path afterward we enter in the error path
// and the actual tile_len is updated (committed) at the end of the and the actual tile_len is updated (committed) at the end of the
// function. function. */
} }
*l_current_data = l_new_current_data; *l_current_data = l_new_current_data;
} }
@ -4964,9 +4970,10 @@ static opj_bool opj_j2k_read_mct ( opj_j2k_v2_t *p_j2k,
/* NOT FOUND */ /* NOT FOUND */
if (i == l_tcp->m_nb_mct_records) { if (i == l_tcp->m_nb_mct_records) {
if (l_tcp->m_nb_mct_records == l_tcp->m_nb_max_mct_records) { if (l_tcp->m_nb_mct_records == l_tcp->m_nb_max_mct_records) {
opj_mct_data_t *new_mct_records;
l_tcp->m_nb_max_mct_records += J2K_MCT_DEFAULT_NB_RECORDS; l_tcp->m_nb_max_mct_records += J2K_MCT_DEFAULT_NB_RECORDS;
opj_mct_data_t *new_mct_records = (opj_mct_data_t *) opj_realloc(l_tcp->m_mct_records, l_tcp->m_nb_max_mct_records * sizeof(opj_mct_data_t)); new_mct_records = (opj_mct_data_t *) opj_realloc(l_tcp->m_mct_records, l_tcp->m_nb_max_mct_records * sizeof(opj_mct_data_t));
if (! new_mct_records) { if (! new_mct_records) {
opj_free(l_tcp->m_mct_records); opj_free(l_tcp->m_mct_records);
l_tcp->m_mct_records = NULL; l_tcp->m_mct_records = NULL;
@ -5174,9 +5181,10 @@ opj_bool opj_j2k_read_mcc ( opj_j2k_v2_t *p_j2k,
/** NOT FOUND */ /** NOT FOUND */
if (i == l_tcp->m_nb_mcc_records) { if (i == l_tcp->m_nb_mcc_records) {
if (l_tcp->m_nb_mcc_records == l_tcp->m_nb_max_mcc_records) { if (l_tcp->m_nb_mcc_records == l_tcp->m_nb_max_mcc_records) {
opj_simple_mcc_decorrelation_data_t *new_mcc_records;
l_tcp->m_nb_max_mcc_records += J2K_MCC_DEFAULT_NB_RECORDS; l_tcp->m_nb_max_mcc_records += J2K_MCC_DEFAULT_NB_RECORDS;
opj_simple_mcc_decorrelation_data_t *new_mcc_records = (opj_simple_mcc_decorrelation_data_t *) opj_realloc( new_mcc_records = (opj_simple_mcc_decorrelation_data_t *) opj_realloc(
l_tcp->m_mcc_records, l_tcp->m_nb_max_mcc_records * sizeof(opj_simple_mcc_decorrelation_data_t)); l_tcp->m_mcc_records, l_tcp->m_nb_max_mcc_records * sizeof(opj_simple_mcc_decorrelation_data_t));
if (! new_mcc_records) { if (! new_mcc_records) {
opj_free(l_tcp->m_mcc_records); opj_free(l_tcp->m_mcc_records);
@ -5844,7 +5852,7 @@ void opj_j2k_setup_encoder( opj_j2k_v2_t *p_j2k,
if (parameters->numpocs) { if (parameters->numpocs) {
/* initialisation of POC */ /* initialisation of POC */
l_res = opj_j2k_check_poc_val(parameters->POC,parameters->numpocs, parameters->numresolution, image->numcomps, parameters->tcp_numlayers, p_manager); l_res = opj_j2k_check_poc_val(parameters->POC,parameters->numpocs, parameters->numresolution, image->numcomps, parameters->tcp_numlayers, p_manager);
// TODO /* TODO */
} }
for (tileno = 0; tileno < cp->tw * cp->th; tileno++) { for (tileno = 0; tileno < cp->tw * cp->th; tileno++) {
@ -5876,7 +5884,7 @@ void opj_j2k_setup_encoder( opj_j2k_v2_t *p_j2k,
if (parameters->numpocs) { if (parameters->numpocs) {
/* initialisation of POC */ /* initialisation of POC */
tcp->POC = 1; tcp->POC = 1;
// TODO /* TODO */
for (i = 0; i < (unsigned int) parameters->numpocs; i++) { for (i = 0; i < (unsigned int) parameters->numpocs; i++) {
if((tileno == parameters->POC[i].tile - 1) || (parameters->POC[i].tile == -1)) { if((tileno == parameters->POC[i].tile - 1) || (parameters->POC[i].tile == -1)) {
opj_poc_t *tcp_poc = &tcp->pocs[numpocs_tile]; opj_poc_t *tcp_poc = &tcp->pocs[numpocs_tile];
@ -5962,10 +5970,10 @@ void opj_j2k_setup_encoder( opj_j2k_v2_t *p_j2k,
} }
if(parameters->cp_cinema) { if(parameters->cp_cinema) {
//Precinct size for lowest frequency subband=128 /*Precinct size for lowest frequency subband=128*/
tccp->prcw[0] = 7; tccp->prcw[0] = 7;
tccp->prch[0] = 7; tccp->prch[0] = 7;
//Precinct size at all other resolutions = 256 /*Precinct size at all other resolutions = 256*/
for (j = 1; j < tccp->numresolutions; j++) { for (j = 1; j < tccp->numresolutions; j++) {
tccp->prcw[j] = 8; tccp->prcw[j] = 8;
tccp->prch[j] = 8; tccp->prch[j] = 8;
@ -6007,7 +6015,7 @@ void opj_j2k_setup_encoder( opj_j2k_v2_t *p_j2k,
} }
p++; p++;
/*printf("\nsize precinct for level %d : %d,%d\n", it_res,tccp->prcw[it_res], tccp->prch[it_res]); */ /*printf("\nsize precinct for level %d : %d,%d\n", it_res,tccp->prcw[it_res], tccp->prch[it_res]); */
} //end for } /*end for*/
} else { } else {
for (j = 0; j < tccp->numresolutions; j++) { for (j = 0; j < tccp->numresolutions; j++) {
tccp->prcw[j] = 15; tccp->prcw[j] = 15;
@ -6032,8 +6040,9 @@ static opj_bool opj_j2k_add_mhmarker(opj_codestream_index_t *cstr_index, OPJ_UIN
/* expand the list? */ /* expand the list? */
if ((cstr_index->marknum + 1) > cstr_index->maxmarknum) { if ((cstr_index->marknum + 1) > cstr_index->maxmarknum) {
opj_marker_info_t *new_marker;
cstr_index->maxmarknum = 100 + (int) ((float) cstr_index->maxmarknum * 1.0F); cstr_index->maxmarknum = 100 + (int) ((float) cstr_index->maxmarknum * 1.0F);
opj_marker_info_t *new_marker = (opj_marker_info_t *) opj_realloc(cstr_index->marker, cstr_index->maxmarknum *sizeof(opj_marker_info_t)); new_marker = (opj_marker_info_t *) opj_realloc(cstr_index->marker, cstr_index->maxmarknum *sizeof(opj_marker_info_t));
if (! new_marker) { if (! new_marker) {
opj_free(cstr_index->marker); opj_free(cstr_index->marker);
cstr_index->marker = NULL; cstr_index->marker = NULL;
@ -6060,8 +6069,9 @@ static opj_bool opj_j2k_add_tlmarker(OPJ_UINT32 tileno, opj_codestream_index_t *
/* expand the list? */ /* expand the list? */
if ((cstr_index->tile_index[tileno].marknum + 1) > cstr_index->tile_index[tileno].maxmarknum) { if ((cstr_index->tile_index[tileno].marknum + 1) > cstr_index->tile_index[tileno].maxmarknum) {
opj_marker_info_t *new_marker;
cstr_index->tile_index[tileno].maxmarknum = 100 + (int) ((float) cstr_index->tile_index[tileno].maxmarknum * 1.0F); cstr_index->tile_index[tileno].maxmarknum = 100 + (int) ((float) cstr_index->tile_index[tileno].maxmarknum * 1.0F);
opj_marker_info_t *new_marker = (opj_marker_info_t *) opj_realloc( new_marker = (opj_marker_info_t *) opj_realloc(
cstr_index->tile_index[tileno].marker, cstr_index->tile_index[tileno].marker,
cstr_index->tile_index[tileno].maxmarknum *sizeof(opj_marker_info_t)); cstr_index->tile_index[tileno].maxmarknum *sizeof(opj_marker_info_t));
if (! new_marker) { if (! new_marker) {
@ -6226,7 +6236,7 @@ opj_bool opj_j2k_setup_mct_encoding(opj_tcp_v2_t * p_tcp, opj_image_t * p_image)
OPJ_FLOAT32 * l_data, * l_current_data; OPJ_FLOAT32 * l_data, * l_current_data;
opj_tccp_t * l_tccp; opj_tccp_t * l_tccp;
// preconditions /* preconditions */
assert(p_tcp != 00); assert(p_tcp != 00);
if (p_tcp->mct != 2) { if (p_tcp->mct != 2) {
@ -6235,9 +6245,10 @@ opj_bool opj_j2k_setup_mct_encoding(opj_tcp_v2_t * p_tcp, opj_image_t * p_image)
if (p_tcp->m_mct_decoding_matrix) { if (p_tcp->m_mct_decoding_matrix) {
if (p_tcp->m_nb_mct_records == p_tcp->m_nb_max_mct_records) { if (p_tcp->m_nb_mct_records == p_tcp->m_nb_max_mct_records) {
opj_mct_data_t *new_mct_records;
p_tcp->m_nb_max_mct_records += J2K_MCT_DEFAULT_NB_RECORDS; p_tcp->m_nb_max_mct_records += J2K_MCT_DEFAULT_NB_RECORDS;
opj_mct_data_t *new_mct_records = (opj_mct_data_t *) opj_realloc(p_tcp->m_mct_records, p_tcp->m_nb_max_mct_records * sizeof(opj_mct_data_t)); new_mct_records = (opj_mct_data_t *) opj_realloc(p_tcp->m_mct_records, p_tcp->m_nb_max_mct_records * sizeof(opj_mct_data_t));
if (! new_mct_records) { if (! new_mct_records) {
opj_free(p_tcp->m_mct_records); opj_free(p_tcp->m_mct_records);
p_tcp->m_mct_records = NULL; p_tcp->m_mct_records = NULL;
@ -6276,8 +6287,9 @@ opj_bool opj_j2k_setup_mct_encoding(opj_tcp_v2_t * p_tcp, opj_image_t * p_image)
} }
if (p_tcp->m_nb_mct_records == p_tcp->m_nb_max_mct_records) { if (p_tcp->m_nb_mct_records == p_tcp->m_nb_max_mct_records) {
opj_mct_data_t *new_mct_records;
p_tcp->m_nb_max_mct_records += J2K_MCT_DEFAULT_NB_RECORDS; p_tcp->m_nb_max_mct_records += J2K_MCT_DEFAULT_NB_RECORDS;
opj_mct_data_t *new_mct_records = (opj_mct_data_t *) opj_realloc(p_tcp->m_mct_records, p_tcp->m_nb_max_mct_records * sizeof(opj_mct_data_t)); new_mct_records = (opj_mct_data_t *) opj_realloc(p_tcp->m_mct_records, p_tcp->m_nb_max_mct_records * sizeof(opj_mct_data_t));
if (! new_mct_records) { if (! new_mct_records) {
opj_free(p_tcp->m_mct_records); opj_free(p_tcp->m_mct_records);
p_tcp->m_mct_records = NULL; p_tcp->m_mct_records = NULL;
@ -6338,8 +6350,9 @@ opj_bool opj_j2k_setup_mct_encoding(opj_tcp_v2_t * p_tcp, opj_image_t * p_image)
++p_tcp->m_nb_mct_records; ++p_tcp->m_nb_mct_records;
if (p_tcp->m_nb_mcc_records == p_tcp->m_nb_max_mcc_records) { if (p_tcp->m_nb_mcc_records == p_tcp->m_nb_max_mcc_records) {
opj_simple_mcc_decorrelation_data_t *new_mcc_records;
p_tcp->m_nb_max_mcc_records += J2K_MCT_DEFAULT_NB_RECORDS; p_tcp->m_nb_max_mcc_records += J2K_MCT_DEFAULT_NB_RECORDS;
opj_simple_mcc_decorrelation_data_t *new_mcc_records = (opj_simple_mcc_decorrelation_data_t *) opj_realloc( new_mcc_records = (opj_simple_mcc_decorrelation_data_t *) opj_realloc(
p_tcp->m_mcc_records, p_tcp->m_nb_max_mcc_records * sizeof(opj_simple_mcc_decorrelation_data_t)); p_tcp->m_mcc_records, p_tcp->m_nb_max_mcc_records * sizeof(opj_simple_mcc_decorrelation_data_t));
if (! new_mcc_records) { if (! new_mcc_records) {
opj_free(p_tcp->m_mcc_records); opj_free(p_tcp->m_mcc_records);
@ -8779,8 +8792,8 @@ static opj_bool opj_j2k_decode_one_tile ( opj_j2k_v2_t *p_j2k,
if (! l_new_current_data) { if (! l_new_current_data) {
opj_free(l_current_data); opj_free(l_current_data);
l_current_data = NULL; l_current_data = NULL;
// TODO: LH: why tile numbering policy used in messages differs from /* TODO: LH: why tile numbering policy used in messages differs from
// the one used in opj_j2k_decode_tiles() ? the one used in opj_j2k_decode_tiles() ? */
opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to decode tile %d/%d\n", l_current_tile_no, (p_j2k->m_cp.th * p_j2k->m_cp.tw) - 1); opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to decode tile %d/%d\n", l_current_tile_no, (p_j2k->m_cp.th * p_j2k->m_cp.tw) - 1);
return OPJ_FALSE; return OPJ_FALSE;
} }
@ -9071,7 +9084,7 @@ opj_bool opj_j2k_start_compress(opj_j2k_v2_t *p_j2k,
p_j2k->m_private_image = opj_image_create0(); p_j2k->m_private_image = opj_image_create0();
opj_copy_image_header(p_image, p_j2k->m_private_image); opj_copy_image_header(p_image, p_j2k->m_private_image);
// TODO_MSD: Find a better way /* TODO_MSD: Find a better way */
if (p_image->comps) { if (p_image->comps) {
OPJ_UINT32 it_comp; OPJ_UINT32 it_comp;
for (it_comp = 0 ; it_comp < p_image->numcomps; it_comp++) { for (it_comp = 0 ; it_comp < p_image->numcomps; it_comp++) {

22
libopenjpeg/jp2.c
View File

@ -527,7 +527,7 @@ OPJ_BYTE * opj_jp2_write_ihdr(opj_jp2_v2_t *jp2,
{ {
unsigned char * l_ihdr_data,* l_current_ihdr_ptr; unsigned char * l_ihdr_data,* l_current_ihdr_ptr;
// preconditions /* preconditions */
assert(jp2 != 00); assert(jp2 != 00);
assert(p_nb_bytes_written != 00); assert(p_nb_bytes_written != 00);
@ -581,7 +581,7 @@ OPJ_BYTE * opj_jp2_write_bpcc( opj_jp2_v2_t *jp2,
int l_bpcc_size = 8 + jp2->numcomps; int l_bpcc_size = 8 + jp2->numcomps;
unsigned char * l_bpcc_data,* l_current_bpcc_ptr; unsigned char * l_bpcc_data,* l_current_bpcc_ptr;
// preconditions /* preconditions */
assert(jp2 != 00); assert(jp2 != 00);
assert(p_nb_bytes_written != 00); assert(p_nb_bytes_written != 00);
@ -650,7 +650,7 @@ OPJ_BYTE * opj_jp2_write_colr( opj_jp2_v2_t *jp2,
unsigned int l_colr_size = 11; unsigned int l_colr_size = 11;
unsigned char * l_colr_data,* l_current_colr_ptr; unsigned char * l_colr_data,* l_current_colr_ptr;
// preconditions /* preconditions */
assert(jp2 != 00); assert(jp2 != 00);
assert(p_nb_bytes_written != 00); assert(p_nb_bytes_written != 00);
@ -1124,7 +1124,7 @@ opj_bool opj_jp2_write_jp2h(opj_jp2_v2_t *jp2,
/* to store the data of the super box */ /* to store the data of the super box */
unsigned char l_jp2h_data [8]; unsigned char l_jp2h_data [8];
// preconditions /* preconditions */
assert(stream != 00); assert(stream != 00);
assert(jp2 != 00); assert(jp2 != 00);
assert(p_manager != 00); assert(p_manager != 00);
@ -1215,7 +1215,7 @@ opj_bool opj_jp2_write_ftyp(opj_jp2_v2_t *jp2,
unsigned char * l_ftyp_data, * l_current_data_ptr; unsigned char * l_ftyp_data, * l_current_data_ptr;
opj_bool l_result; opj_bool l_result;
// preconditions /* preconditions */
assert(cio != 00); assert(cio != 00);
assert(jp2 != 00); assert(jp2 != 00);
assert(p_manager != 00); assert(p_manager != 00);
@ -1265,7 +1265,7 @@ opj_bool opj_jp2_write_jp2c(opj_jp2_v2_t *jp2,
OPJ_OFF_T j2k_codestream_exit; OPJ_OFF_T j2k_codestream_exit;
OPJ_BYTE l_data_header [8]; OPJ_BYTE l_data_header [8];
// preconditions /* preconditions */
assert(jp2 != 00); assert(jp2 != 00);
assert(cio != 00); assert(cio != 00);
assert(p_manager != 00); assert(p_manager != 00);
@ -1302,7 +1302,7 @@ opj_bool opj_jp2_write_jp( opj_jp2_v2_t *jp2,
/* 12 bytes will be read */ /* 12 bytes will be read */
unsigned char l_signature_data [12]; unsigned char l_signature_data [12];
// preconditions /* preconditions */
assert(cio != 00); assert(cio != 00);
assert(jp2 != 00); assert(jp2 != 00);
assert(p_manager != 00); assert(p_manager != 00);
@ -1416,7 +1416,7 @@ void opj_jp2_setup_encoder( opj_jp2_v2_t *jp2,
jp2->precedence = 0; /* PRECEDENCE */ jp2->precedence = 0; /* PRECEDENCE */
jp2->approx = 0; /* APPROX */ jp2->approx = 0; /* APPROX */
// jp2->jpip_on = parameters->jpip_on; /* jp2->jpip_on = parameters->jpip_on; */
} }
opj_bool opj_jp2_encode(opj_jp2_v2_t *jp2, opj_bool opj_jp2_encode(opj_jp2_v2_t *jp2,
@ -1603,9 +1603,9 @@ opj_bool opj_jp2_read_header_procedure( opj_jp2_v2_t *jp2,
l_nb_bytes_read = opj_stream_read_data(stream,l_current_data,l_current_data_size,p_manager); l_nb_bytes_read = opj_stream_read_data(stream,l_current_data,l_current_data_size,p_manager);
if (l_nb_bytes_read != l_current_data_size) { if (l_nb_bytes_read != l_current_data_size) {
opj_event_msg_v2(p_manager, EVT_ERROR, "Problem with reading JPEG2000 box, stream error\n"); opj_event_msg_v2(p_manager, EVT_ERROR, "Problem with reading JPEG2000 box, stream error\n");
// TODO: LH: why nothing is freed here (as /* TODO: LH: why nothing is freed here (as
// all other returns imply a free, even all other returns imply a free, even
// in the nominal case)? in the nominal case)? */
return OPJ_FALSE; return OPJ_FALSE;
} }

10
libopenjpeg/mct.c
View File

@ -201,15 +201,15 @@ double mct_getnorm_real(int compno) {
opj_bool mct_encode_custom( opj_bool mct_encode_custom(
// MCT data /* MCT data */
OPJ_BYTE * pCodingdata, OPJ_BYTE * pCodingdata,
// size of components /* size of components */
OPJ_UINT32 n, OPJ_UINT32 n,
// components /* components */
OPJ_BYTE ** pData, OPJ_BYTE ** pData,
// nb of components (i.e. size of pData) /* nb of components (i.e. size of pData) */
OPJ_UINT32 pNbComp, OPJ_UINT32 pNbComp,
// tells if the data is signed /* tells if the data is signed */
OPJ_UINT32 isSigned) OPJ_UINT32 isSigned)
{ {
OPJ_FLOAT32 * lMct = (OPJ_FLOAT32 *) pCodingdata; OPJ_FLOAT32 * lMct = (OPJ_FLOAT32 *) pCodingdata;

2
libopenjpeg/mqc.c
View File

@ -363,7 +363,7 @@ opj_mqc_t* mqc_create(void) {
void mqc_destroy(opj_mqc_t *mqc) { void mqc_destroy(opj_mqc_t *mqc) {
if(mqc) { if(mqc) {
#ifdef MQC_PERF_OPT #ifdef MQC_PERF_OPT
if (mqc->buffer) { // TODO: LH: this test is pointless as free() is a no-op on 0 if (mqc->buffer) { /* TODO: LH: this test is pointless as free() is a no-op on 0 */
opj_free(mqc->buffer); opj_free(mqc->buffer);
} }
#endif #endif

174
libopenjpeg/pi.c
View File

@ -621,15 +621,15 @@ opj_pi_iterator_t *pi_create_decode_v2( opj_image_t *p_image,
OPJ_UINT32 p_tile_no OPJ_UINT32 p_tile_no
) )
{ {
// loop /* loop */
OPJ_UINT32 pino; OPJ_UINT32 pino;
OPJ_UINT32 compno, resno; OPJ_UINT32 compno, resno;
// to store w, h, dx and dy fro all components and resolutions /* to store w, h, dx and dy fro all components and resolutions */
OPJ_UINT32 * l_tmp_data; OPJ_UINT32 * l_tmp_data;
OPJ_UINT32 ** l_tmp_ptr; OPJ_UINT32 ** l_tmp_ptr;
// encoding prameters to set /* encoding prameters to set */
OPJ_UINT32 l_max_res; OPJ_UINT32 l_max_res;
OPJ_UINT32 l_max_prec; OPJ_UINT32 l_max_prec;
OPJ_INT32 l_tx0,l_tx1,l_ty0,l_ty1; OPJ_INT32 l_tx0,l_tx1,l_ty0,l_ty1;
@ -638,7 +638,7 @@ opj_pi_iterator_t *pi_create_decode_v2( opj_image_t *p_image,
OPJ_UINT32 l_step_p , l_step_c , l_step_r , l_step_l ; OPJ_UINT32 l_step_p , l_step_c , l_step_r , l_step_l ;
OPJ_UINT32 l_data_stride; OPJ_UINT32 l_data_stride;
// pointers /* pointers */
opj_pi_iterator_t *l_pi = 00; opj_pi_iterator_t *l_pi = 00;
opj_tcp_v2_t *l_tcp = 00; opj_tcp_v2_t *l_tcp = 00;
const opj_tccp_t *l_tccp = 00; const opj_tccp_t *l_tccp = 00;
@ -647,12 +647,12 @@ opj_pi_iterator_t *pi_create_decode_v2( opj_image_t *p_image,
opj_pi_iterator_t * l_current_pi = 00; opj_pi_iterator_t * l_current_pi = 00;
OPJ_UINT32 * l_encoding_value_ptr = 00; OPJ_UINT32 * l_encoding_value_ptr = 00;
// preconditions in debug /* preconditions in debug */
assert(p_cp != 00); assert(p_cp != 00);
assert(p_image != 00); assert(p_image != 00);
assert(p_tile_no < p_cp->tw * p_cp->th); assert(p_tile_no < p_cp->tw * p_cp->th);
// initializations /* initializations */
l_tcp = &p_cp->tcps[p_tile_no]; l_tcp = &p_cp->tcps[p_tile_no];
l_bound = l_tcp->numpocs+1; l_bound = l_tcp->numpocs+1;
@ -673,7 +673,7 @@ opj_pi_iterator_t *pi_create_decode_v2( opj_image_t *p_image,
return 00; return 00;
} }
// memory allocation for pi /* memory allocation for pi */
l_pi = pi_create(p_image, p_cp, p_tile_no); l_pi = pi_create(p_image, p_cp, p_tile_no);
if (!l_pi) { if (!l_pi) {
opj_free(l_tmp_data); opj_free(l_tmp_data);
@ -682,26 +682,26 @@ opj_pi_iterator_t *pi_create_decode_v2( opj_image_t *p_image,
} }
l_encoding_value_ptr = l_tmp_data; l_encoding_value_ptr = l_tmp_data;
// update pointer array /* update pointer array */
for for
(compno = 0; compno < p_image->numcomps; ++compno) (compno = 0; compno < p_image->numcomps; ++compno)
{ {
l_tmp_ptr[compno] = l_encoding_value_ptr; l_tmp_ptr[compno] = l_encoding_value_ptr;
l_encoding_value_ptr += l_data_stride; l_encoding_value_ptr += l_data_stride;
} }
// get encoding parameters /* get encoding parameters */
get_all_encoding_parameters(p_image,p_cp,p_tile_no,&l_tx0,&l_tx1,&l_ty0,&l_ty1,&l_dx_min,&l_dy_min,&l_max_prec,&l_max_res,l_tmp_ptr); get_all_encoding_parameters(p_image,p_cp,p_tile_no,&l_tx0,&l_tx1,&l_ty0,&l_ty1,&l_dx_min,&l_dy_min,&l_max_prec,&l_max_res,l_tmp_ptr);
// step calculations /* step calculations */
l_step_p = 1; l_step_p = 1;
l_step_c = l_max_prec * l_step_p; l_step_c = l_max_prec * l_step_p;
l_step_r = p_image->numcomps * l_step_c; l_step_r = p_image->numcomps * l_step_c;
l_step_l = l_max_res * l_step_r; l_step_l = l_max_res * l_step_r;
// set values for first packet iterator /* set values for first packet iterator */
l_current_pi = l_pi; l_current_pi = l_pi;
// memory allocation for include /* memory allocation for include */
l_current_pi->include = (OPJ_INT16*) opj_calloc((l_tcp->numlayers +1) * l_step_l, sizeof(OPJ_INT16)); l_current_pi->include = (OPJ_INT16*) opj_calloc((l_tcp->numlayers +1) * l_step_l, sizeof(OPJ_INT16));
if if
(!l_current_pi->include) (!l_current_pi->include)
@ -713,7 +713,7 @@ opj_pi_iterator_t *pi_create_decode_v2( opj_image_t *p_image,
} }
memset(l_current_pi->include,0, (l_tcp->numlayers + 1) * l_step_l* sizeof(OPJ_INT16)); memset(l_current_pi->include,0, (l_tcp->numlayers + 1) * l_step_l* sizeof(OPJ_INT16));
// special treatment for the first packet iterator /* special treatment for the first packet iterator */
l_current_comp = l_current_pi->comps; l_current_comp = l_current_pi->comps;
l_img_comp = p_image->comps; l_img_comp = p_image->comps;
l_tccp = l_tcp->tccps; l_tccp = l_tcp->tccps;
@ -723,8 +723,8 @@ opj_pi_iterator_t *pi_create_decode_v2( opj_image_t *p_image,
l_current_pi->tx1 = l_tx1; l_current_pi->tx1 = l_tx1;
l_current_pi->ty1 = l_ty1; l_current_pi->ty1 = l_ty1;
//l_current_pi->dx = l_img_comp->dx; /*l_current_pi->dx = l_img_comp->dx;*/
//l_current_pi->dy = l_img_comp->dy; /*l_current_pi->dy = l_img_comp->dy;*/
l_current_pi->step_p = l_step_p; l_current_pi->step_p = l_step_p;
l_current_pi->step_c = l_step_c; l_current_pi->step_c = l_step_c;
@ -767,8 +767,8 @@ opj_pi_iterator_t *pi_create_decode_v2( opj_image_t *p_image,
l_current_pi->ty0 = l_ty0; l_current_pi->ty0 = l_ty0;
l_current_pi->tx1 = l_tx1; l_current_pi->tx1 = l_tx1;
l_current_pi->ty1 = l_ty1; l_current_pi->ty1 = l_ty1;
//l_current_pi->dx = l_dx_min; /*l_current_pi->dx = l_dx_min;*/
//l_current_pi->dy = l_dy_min; /*l_current_pi->dy = l_dy_min;*/
l_current_pi->step_p = l_step_p; l_current_pi->step_p = l_step_p;
l_current_pi->step_c = l_step_c; l_current_pi->step_c = l_step_c;
l_current_pi->step_r = l_step_r; l_current_pi->step_r = l_step_r;
@ -797,7 +797,7 @@ opj_pi_iterator_t *pi_create_decode_v2( opj_image_t *p_image,
++l_img_comp; ++l_img_comp;
++l_tccp; ++l_tccp;
} }
// special treatment /* special treatment*/
l_current_pi->include = (l_current_pi-1)->include; l_current_pi->include = (l_current_pi-1)->include;
++l_current_pi; ++l_current_pi;
} }
@ -967,15 +967,15 @@ opj_pi_iterator_t *pi_initialise_encode_v2(
J2K_T2_MODE p_t2_mode J2K_T2_MODE p_t2_mode
) )
{ {
// loop /* loop*/
OPJ_UINT32 pino; OPJ_UINT32 pino;
OPJ_UINT32 compno, resno; OPJ_UINT32 compno, resno;
// to store w, h, dx and dy fro all components and resolutions /* to store w, h, dx and dy fro all components and resolutions*/
OPJ_UINT32 * l_tmp_data; OPJ_UINT32 * l_tmp_data;
OPJ_UINT32 ** l_tmp_ptr; OPJ_UINT32 ** l_tmp_ptr;
// encoding prameters to set /* encoding prameters to set*/
OPJ_UINT32 l_max_res; OPJ_UINT32 l_max_res;
OPJ_UINT32 l_max_prec; OPJ_UINT32 l_max_prec;
OPJ_INT32 l_tx0,l_tx1,l_ty0,l_ty1; OPJ_INT32 l_tx0,l_tx1,l_ty0,l_ty1;
@ -984,7 +984,7 @@ opj_pi_iterator_t *pi_initialise_encode_v2(
OPJ_UINT32 l_step_p , l_step_c , l_step_r , l_step_l ; OPJ_UINT32 l_step_p , l_step_c , l_step_r , l_step_l ;
OPJ_UINT32 l_data_stride; OPJ_UINT32 l_data_stride;
// pointers /* pointers*/
opj_pi_iterator_t *l_pi = 00; opj_pi_iterator_t *l_pi = 00;
opj_tcp_v2_t *l_tcp = 00; opj_tcp_v2_t *l_tcp = 00;
const opj_tccp_t *l_tccp = 00; const opj_tccp_t *l_tccp = 00;
@ -993,12 +993,12 @@ opj_pi_iterator_t *pi_initialise_encode_v2(
opj_pi_iterator_t * l_current_pi = 00; opj_pi_iterator_t * l_current_pi = 00;
OPJ_UINT32 * l_encoding_value_ptr = 00; OPJ_UINT32 * l_encoding_value_ptr = 00;
// preconditions in debug /* preconditions in debug*/
assert(p_cp != 00); assert(p_cp != 00);
assert(p_image != 00); assert(p_image != 00);
assert(p_tile_no < p_cp->tw * p_cp->th); assert(p_tile_no < p_cp->tw * p_cp->th);
// initializations /* initializations*/
l_tcp = &p_cp->tcps[p_tile_no]; l_tcp = &p_cp->tcps[p_tile_no];
l_bound = l_tcp->numpocs+1; l_bound = l_tcp->numpocs+1;
@ -1016,7 +1016,7 @@ opj_pi_iterator_t *pi_initialise_encode_v2(
return 00; return 00;
} }
// memory allocation for pi /* memory allocation for pi*/
l_pi = pi_create(p_image,p_cp,p_tile_no); l_pi = pi_create(p_image,p_cp,p_tile_no);
if (!l_pi) { if (!l_pi) {
opj_free(l_tmp_data); opj_free(l_tmp_data);
@ -1025,26 +1025,26 @@ opj_pi_iterator_t *pi_initialise_encode_v2(
} }
l_encoding_value_ptr = l_tmp_data; l_encoding_value_ptr = l_tmp_data;
// update pointer array /* update pointer array*/
for (compno = 0; compno < p_image->numcomps; ++compno) { for (compno = 0; compno < p_image->numcomps; ++compno) {
l_tmp_ptr[compno] = l_encoding_value_ptr; l_tmp_ptr[compno] = l_encoding_value_ptr;
l_encoding_value_ptr += l_data_stride; l_encoding_value_ptr += l_data_stride;
} }
// get encoding parameters /* get encoding parameters*/
get_all_encoding_parameters(p_image,p_cp,p_tile_no,&l_tx0,&l_tx1,&l_ty0,&l_ty1,&l_dx_min,&l_dy_min,&l_max_prec,&l_max_res,l_tmp_ptr); get_all_encoding_parameters(p_image,p_cp,p_tile_no,&l_tx0,&l_tx1,&l_ty0,&l_ty1,&l_dx_min,&l_dy_min,&l_max_prec,&l_max_res,l_tmp_ptr);
// step calculations /* step calculations*/
l_step_p = 1; l_step_p = 1;
l_step_c = l_max_prec * l_step_p; l_step_c = l_max_prec * l_step_p;
l_step_r = p_image->numcomps * l_step_c; l_step_r = p_image->numcomps * l_step_c;
l_step_l = l_max_res * l_step_r; l_step_l = l_max_res * l_step_r;
// set values for first packet iterator /* set values for first packet iterator*/
l_pi->tp_on = p_cp->m_specific_param.m_enc.m_tp_on; l_pi->tp_on = p_cp->m_specific_param.m_enc.m_tp_on;
l_current_pi = l_pi; l_current_pi = l_pi;
// memory allocation for include /* memory allocation for include*/
l_current_pi->include = (OPJ_INT16*) opj_calloc(l_tcp->numlayers * l_step_l, sizeof(OPJ_INT16)); l_current_pi->include = (OPJ_INT16*) opj_calloc(l_tcp->numlayers * l_step_l, sizeof(OPJ_INT16));
if (!l_current_pi->include) { if (!l_current_pi->include) {
opj_free(l_tmp_data); opj_free(l_tmp_data);
@ -1054,7 +1054,7 @@ opj_pi_iterator_t *pi_initialise_encode_v2(
} }
memset(l_current_pi->include,0,l_tcp->numlayers * l_step_l* sizeof(OPJ_INT16)); memset(l_current_pi->include,0,l_tcp->numlayers * l_step_l* sizeof(OPJ_INT16));
// special treatment for the first packet iterator /* special treatment for the first packet iterator*/
l_current_comp = l_current_pi->comps; l_current_comp = l_current_pi->comps;
l_img_comp = p_image->comps; l_img_comp = p_image->comps;
l_tccp = l_tcp->tccps; l_tccp = l_tcp->tccps;
@ -1128,7 +1128,7 @@ opj_pi_iterator_t *pi_initialise_encode_v2(
++l_tccp; ++l_tccp;
} }
// special treatment /* special treatment*/
l_current_pi->include = (l_current_pi-1)->include; l_current_pi->include = (l_current_pi-1)->include;
++l_current_pi; ++l_current_pi;
} }
@ -1604,31 +1604,31 @@ void get_all_encoding_parameters(
OPJ_UINT32 ** p_resolutions OPJ_UINT32 ** p_resolutions
) )
{ {
// loop /* loop*/
OPJ_UINT32 compno, resno; OPJ_UINT32 compno, resno;
// pointers /* pointers*/
const opj_tcp_v2_t *tcp = 00; const opj_tcp_v2_t *tcp = 00;
const opj_tccp_t * l_tccp = 00; const opj_tccp_t * l_tccp = 00;
const opj_image_comp_t * l_img_comp = 00; const opj_image_comp_t * l_img_comp = 00;
// to store l_dx, l_dy, w and h for each resolution and component. /* to store l_dx, l_dy, w and h for each resolution and component.*/
OPJ_UINT32 * lResolutionPtr; OPJ_UINT32 * lResolutionPtr;
// position in x and y of tile /* position in x and y of tile*/
OPJ_UINT32 p, q; OPJ_UINT32 p, q;
// preconditions in debug /* preconditions in debug*/
assert(p_cp != 00); assert(p_cp != 00);
assert(p_image != 00); assert(p_image != 00);
assert(tileno < p_cp->tw * p_cp->th); assert(tileno < p_cp->tw * p_cp->th);
// initializations /* initializations*/
tcp = &p_cp->tcps [tileno]; tcp = &p_cp->tcps [tileno];
l_tccp = tcp->tccps; l_tccp = tcp->tccps;
l_img_comp = p_image->comps; l_img_comp = p_image->comps;
// position in x and y of tile /* position in x and y of tile*/
p = tileno % p_cp->tw; p = tileno % p_cp->tw;
q = tileno / p_cp->tw; q = tileno / p_cp->tw;
@ -1639,18 +1639,18 @@ void get_all_encoding_parameters(
*p_ty0 = int_max(p_cp->ty0 + q * p_cp->tdy, p_image->y0); *p_ty0 = int_max(p_cp->ty0 + q * p_cp->tdy, p_image->y0);
*p_ty1 = int_min(p_cp->ty0 + (q + 1) * p_cp->tdy, p_image->y1); *p_ty1 = int_min(p_cp->ty0 + (q + 1) * p_cp->tdy, p_image->y1);
// max precision and resolution is 0 (can only grow) /* max precision and resolution is 0 (can only grow)*/
*p_max_prec = 0; *p_max_prec = 0;
*p_max_res = 0; *p_max_res = 0;
// take the largest value for dx_min and dy_min /* take the largest value for dx_min and dy_min*/
*p_dx_min = 0x7fffffff; *p_dx_min = 0x7fffffff;
*p_dy_min = 0x7fffffff; *p_dy_min = 0x7fffffff;
for for
(compno = 0; compno < p_image->numcomps; ++compno) (compno = 0; compno < p_image->numcomps; ++compno)
{ {
// aritmetic variables to calculate /* aritmetic variables to calculate*/
OPJ_UINT32 l_level_no; OPJ_UINT32 l_level_no;
OPJ_INT32 l_rx0, l_ry0, l_rx1, l_ry1; OPJ_INT32 l_rx0, l_ry0, l_rx1, l_ry1;
OPJ_INT32 l_px0, l_py0, l_px1, py1; OPJ_INT32 l_px0, l_py0, l_px1, py1;
@ -1670,23 +1670,23 @@ void get_all_encoding_parameters(
*p_max_res = l_tccp->numresolutions; *p_max_res = l_tccp->numresolutions;
} }
// use custom size for precincts /* use custom size for precincts*/
l_level_no = l_tccp->numresolutions - 1; l_level_no = l_tccp->numresolutions - 1;
for for
(resno = 0; resno < l_tccp->numresolutions; ++resno) (resno = 0; resno < l_tccp->numresolutions; ++resno)
{ {
OPJ_UINT32 l_dx, l_dy; OPJ_UINT32 l_dx, l_dy;
// precinct width and height /* precinct width and height*/
l_pdx = l_tccp->prcw[resno]; l_pdx = l_tccp->prcw[resno];
l_pdy = l_tccp->prch[resno]; l_pdy = l_tccp->prch[resno];
*lResolutionPtr++ = l_pdx; *lResolutionPtr++ = l_pdx;
*lResolutionPtr++ = l_pdy; *lResolutionPtr++ = l_pdy;
l_dx = l_img_comp->dx * (1 << (l_pdx + l_level_no)); l_dx = l_img_comp->dx * (1 << (l_pdx + l_level_no));
l_dy = l_img_comp->dy * (1 << (l_pdy + l_level_no)); l_dy = l_img_comp->dy * (1 << (l_pdy + l_level_no));
// take the minimum size for l_dx for each comp and resolution /* take the minimum size for l_dx for each comp and resolution*/
*p_dx_min = int_min(*p_dx_min, l_dx); *p_dx_min = int_min(*p_dx_min, l_dx);
*p_dy_min = int_min(*p_dy_min, l_dy); *p_dy_min = int_min(*p_dy_min, l_dy);
// various calculations of extents /* various calculations of extents*/
l_rx0 = int_ceildivpow2(l_tcx0, l_level_no); l_rx0 = int_ceildivpow2(l_tcx0, l_level_no);
l_ry0 = int_ceildivpow2(l_tcy0, l_level_no); l_ry0 = int_ceildivpow2(l_tcy0, l_level_no);
@ -1701,7 +1701,7 @@ void get_all_encoding_parameters(
*lResolutionPtr++ = l_pw; *lResolutionPtr++ = l_pw;
*lResolutionPtr++ = l_ph; *lResolutionPtr++ = l_ph;
l_product = l_pw * l_ph; l_product = l_pw * l_ph;
// update precision /* update precision*/
if if
(l_product > *p_max_prec) (l_product > *p_max_prec)
{ {
@ -1718,29 +1718,29 @@ opj_pi_iterator_t * pi_create( const opj_image_t *image,
const opj_cp_v2_t *cp, const opj_cp_v2_t *cp,
OPJ_UINT32 tileno ) OPJ_UINT32 tileno )
{ {
// loop /* loop*/
OPJ_UINT32 pino, compno; OPJ_UINT32 pino, compno;
// number of poc in the p_pi /* number of poc in the p_pi*/
OPJ_UINT32 l_poc_bound; OPJ_UINT32 l_poc_bound;
// pointers to tile coding parameters and components. /* pointers to tile coding parameters and components.*/
opj_pi_iterator_t *l_pi = 00; opj_pi_iterator_t *l_pi = 00;
opj_tcp_v2_t *tcp = 00; opj_tcp_v2_t *tcp = 00;
const opj_tccp_t *tccp = 00; const opj_tccp_t *tccp = 00;
// current packet iterator being allocated /* current packet iterator being allocated*/
opj_pi_iterator_t *l_current_pi = 00; opj_pi_iterator_t *l_current_pi = 00;
// preconditions in debug /* preconditions in debug*/
assert(cp != 00); assert(cp != 00);
assert(image != 00); assert(image != 00);
assert(tileno < cp->tw * cp->th); assert(tileno < cp->tw * cp->th);
// initializations /* initializations*/
tcp = &cp->tcps[tileno]; tcp = &cp->tcps[tileno];
l_poc_bound = tcp->numpocs+1; l_poc_bound = tcp->numpocs+1;
// memory allocations /* memory allocations*/
l_pi = (opj_pi_iterator_t*) opj_calloc((l_poc_bound), sizeof(opj_pi_iterator_t)); l_pi = (opj_pi_iterator_t*) opj_calloc((l_poc_bound), sizeof(opj_pi_iterator_t));
if (!l_pi) { if (!l_pi) {
return NULL; return NULL;
@ -1789,27 +1789,27 @@ void pi_update_encode_poc_and_final (opj_cp_v2_t *p_cp,
OPJ_UINT32 p_dx_min, OPJ_UINT32 p_dx_min,
OPJ_UINT32 p_dy_min) OPJ_UINT32 p_dy_min)
{ {
// loop /* loop*/
OPJ_UINT32 pino; OPJ_UINT32 pino;
// tile coding parameter /* tile coding parameter*/
opj_tcp_v2_t *l_tcp = 00; opj_tcp_v2_t *l_tcp = 00;
// current poc being updated /* current poc being updated*/
opj_poc_t * l_current_poc = 00; opj_poc_t * l_current_poc = 00;
// number of pocs /* number of pocs*/
OPJ_UINT32 l_poc_bound; OPJ_UINT32 l_poc_bound;
// preconditions in debug /* preconditions in debug*/
assert(p_cp != 00); assert(p_cp != 00);
assert(p_tileno < p_cp->tw * p_cp->th); assert(p_tileno < p_cp->tw * p_cp->th);
// initializations /* initializations*/
l_tcp = &p_cp->tcps [p_tileno]; l_tcp = &p_cp->tcps [p_tileno];
/* number of iterations in the loop */ /* number of iterations in the loop */
l_poc_bound = l_tcp->numpocs+1; l_poc_bound = l_tcp->numpocs+1;
// start at first element, and to make sure the compiler will not make a calculation each time in the loop /* start at first element, and to make sure the compiler will not make a calculation each time in the loop
// store a pointer to the current element to modify rather than l_tcp->pocs[i] store a pointer to the current element to modify rather than l_tcp->pocs[i]*/
l_current_poc = l_tcp->pocs; l_current_poc = l_tcp->pocs;
l_current_poc->compS = l_current_poc->compno0; l_current_poc->compS = l_current_poc->compno0;
@ -1818,7 +1818,7 @@ void pi_update_encode_poc_and_final (opj_cp_v2_t *p_cp,
l_current_poc->resE = l_current_poc->resno1; l_current_poc->resE = l_current_poc->resno1;
l_current_poc->layE = l_current_poc->layno1; l_current_poc->layE = l_current_poc->layno1;
// special treatment for the first element /* special treatment for the first element*/
l_current_poc->layS = 0; l_current_poc->layS = 0;
l_current_poc->prg = l_current_poc->prg1; l_current_poc->prg = l_current_poc->prg1;
l_current_poc->prcS = 0; l_current_poc->prcS = 0;
@ -1840,7 +1840,7 @@ void pi_update_encode_poc_and_final (opj_cp_v2_t *p_cp,
l_current_poc->layE = l_current_poc->layno1; l_current_poc->layE = l_current_poc->layno1;
l_current_poc->prg = l_current_poc->prg1; l_current_poc->prg = l_current_poc->prg1;
l_current_poc->prcS = 0; l_current_poc->prcS = 0;
// special treatment here different from the first element /* special treatment here different from the first element*/
l_current_poc->layS = (l_current_poc->layE > (l_current_poc-1)->layE) ? l_current_poc->layE : 0; l_current_poc->layS = (l_current_poc->layE > (l_current_poc-1)->layE) ? l_current_poc->layE : 0;
l_current_poc->prcE = p_max_prec; l_current_poc->prcE = p_max_prec;
@ -1866,27 +1866,27 @@ void pi_update_encode_not_poc ( opj_cp_v2_t *p_cp,
OPJ_UINT32 p_dx_min, OPJ_UINT32 p_dx_min,
OPJ_UINT32 p_dy_min) OPJ_UINT32 p_dy_min)
{ {
// loop /* loop*/
OPJ_UINT32 pino; OPJ_UINT32 pino;
// tile coding parameter /* tile coding parameter*/
opj_tcp_v2_t *l_tcp = 00; opj_tcp_v2_t *l_tcp = 00;
// current poc being updated /* current poc being updated*/
opj_poc_t * l_current_poc = 00; opj_poc_t * l_current_poc = 00;
// number of pocs /* number of pocs*/
OPJ_UINT32 l_poc_bound; OPJ_UINT32 l_poc_bound;
// preconditions in debug /* preconditions in debug*/
assert(p_cp != 00); assert(p_cp != 00);
assert(p_tileno < p_cp->tw * p_cp->th); assert(p_tileno < p_cp->tw * p_cp->th);
// initializations /* initializations*/
l_tcp = &p_cp->tcps [p_tileno]; l_tcp = &p_cp->tcps [p_tileno];
/* number of iterations in the loop */ /* number of iterations in the loop */
l_poc_bound = l_tcp->numpocs+1; l_poc_bound = l_tcp->numpocs+1;
// start at first element, and to make sure the compiler will not make a calculation each time in the loop /* start at first element, and to make sure the compiler will not make a calculation each time in the loop
// store a pointer to the current element to modify rather than l_tcp->pocs[i] store a pointer to the current element to modify rather than l_tcp->pocs[i]*/
l_current_poc = l_tcp->pocs; l_current_poc = l_tcp->pocs;
for (pino = 0; pino < l_poc_bound ; ++pino) { for (pino = 0; pino < l_poc_bound ; ++pino) {
@ -1924,7 +1924,7 @@ void pi_destroy_v2(
opj_free(p_pi->include); opj_free(p_pi->include);
p_pi->include = 00; p_pi->include = 00;
} }
// TODO /* TODO*/
for for
(pino = 0; pino < p_nb_elements; ++pino) (pino = 0; pino < p_nb_elements; ++pino)
{ {
@ -1954,20 +1954,20 @@ void pi_destroy_v2(
void pi_update_decode_poc (opj_pi_iterator_t * p_pi,opj_tcp_v2_t * p_tcp,OPJ_UINT32 p_max_precision,OPJ_UINT32 p_max_res) void pi_update_decode_poc (opj_pi_iterator_t * p_pi,opj_tcp_v2_t * p_tcp,OPJ_UINT32 p_max_precision,OPJ_UINT32 p_max_res)
{ {
// loop /* loop*/
OPJ_UINT32 pino; OPJ_UINT32 pino;
// encoding prameters to set /* encoding prameters to set*/
OPJ_UINT32 l_bound; OPJ_UINT32 l_bound;
opj_pi_iterator_t * l_current_pi = 00; opj_pi_iterator_t * l_current_pi = 00;
opj_poc_t* l_current_poc = 0; opj_poc_t* l_current_poc = 0;
// preconditions in debug /* preconditions in debug*/
assert(p_pi != 00); assert(p_pi != 00);
assert(p_tcp != 00); assert(p_tcp != 00);
// initializations /* initializations*/
l_bound = p_tcp->numpocs+1; l_bound = p_tcp->numpocs+1;
l_current_pi = p_pi; l_current_pi = p_pi;
l_current_poc = p_tcp->pocs; l_current_poc = p_tcp->pocs;
@ -1993,18 +1993,18 @@ void pi_update_decode_poc (opj_pi_iterator_t * p_pi,opj_tcp_v2_t * p_tcp,OPJ_UIN
void pi_update_decode_not_poc (opj_pi_iterator_t * p_pi,opj_tcp_v2_t * p_tcp,OPJ_UINT32 p_max_precision,OPJ_UINT32 p_max_res) void pi_update_decode_not_poc (opj_pi_iterator_t * p_pi,opj_tcp_v2_t * p_tcp,OPJ_UINT32 p_max_precision,OPJ_UINT32 p_max_res)
{ {
// loop /* loop*/
OPJ_UINT32 pino; OPJ_UINT32 pino;
// encoding prameters to set /* encoding prameters to set*/
OPJ_UINT32 l_bound; OPJ_UINT32 l_bound;
opj_pi_iterator_t * l_current_pi = 00; opj_pi_iterator_t * l_current_pi = 00;
// preconditions in debug /* preconditions in debug*/
assert(p_tcp != 00); assert(p_tcp != 00);
assert(p_pi != 00); assert(p_pi != 00);
// initializations /* initializations*/
l_bound = p_tcp->numpocs+1; l_bound = p_tcp->numpocs+1;
l_current_pi = p_pi; l_current_pi = p_pi;
@ -2353,7 +2353,7 @@ OPJ_INT32 pi_check_next_level( OPJ_INT32 pos,
break; break;
default: default:
if(tcp->tx0_t == tcp->txE){ if(tcp->tx0_t == tcp->txE){
//TY /*TY*/
if(tcp->ty0_t == tcp->tyE){ if(tcp->ty0_t == tcp->tyE){
l=pi_check_next_level(i-1,cp,tileno,pino,prog); l=pi_check_next_level(i-1,cp,tileno,pino,prog);
if(l==1){ if(l==1){
@ -2363,14 +2363,14 @@ OPJ_INT32 pi_check_next_level( OPJ_INT32 pos,
} }
}else{ }else{
return 1; return 1;
}//TY }/*TY*/
}else{ }else{
return 1; return 1;
} }
break; break;
}//end case P }/*end case P*/
}//end switch }/*end switch*/
}//end for }/*end for*/
}//end if }/*end if*/
return 0; return 0;
} }

4
libopenjpeg/t1.c
View File

@ -1727,8 +1727,8 @@ opj_bool opj_t1_decode_cblks( opj_t1_t* t1,
} }
} }
} }
//opj_free(cblk->segs); /*opj_free(cblk->segs);*/
//cblk->segs = 00; /*cblk->segs = 00;*/
} /* cblkno */ } /* cblkno */
} /* precno */ } /* precno */
} /* bandno */ } /* bandno */

2
libopenjpeg/t1.h
View File

@ -92,7 +92,7 @@ Tier-1 coding (coding of code-block coefficients)
*/ */
typedef struct opj_t1 { typedef struct opj_t1 {
/** codec context */ /** codec context */
opj_common_ptr cinfo; // TODO MSD : TO BE REMOVED opj_common_ptr cinfo; /* TODO MSD : TO BE REMOVED */
/** MQC component */ /** MQC component */
opj_mqc_t *mqc; opj_mqc_t *mqc;

24
libopenjpeg/t2.c
View File

@ -397,7 +397,7 @@ static opj_bool t2_init_seg(opj_tcd_cblk_dec_t* cblk, int index, int cblksty, in
opj_tcd_seg_t* new_segs = (opj_tcd_seg_t*) opj_realloc(cblk->segs, (index + 1) * sizeof(opj_tcd_seg_t)); opj_tcd_seg_t* new_segs = (opj_tcd_seg_t*) opj_realloc(cblk->segs, (index + 1) * sizeof(opj_tcd_seg_t));
if (!new_segs) { if (!new_segs) {
/* opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to init segment #%d\n", index); */ /* opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to init segment #%d\n", index); */
// TODO: tell cblk has no segment (in order to update the range of valid indices) /* TODO: tell cblk has no segment (in order to update the range of valid indices)*/
cblk->segs = NULL; cblk->segs = NULL;
return OPJ_FALSE; return OPJ_FALSE;
} }
@ -567,7 +567,7 @@ static int t2_decode_packet(opj_t2_t* t2, unsigned char *src, int len, opj_tcd_t
segno = 0; segno = 0;
if (!cblk->numsegs) { if (!cblk->numsegs) {
if (OPJ_FALSE == t2_init_seg(cblk, segno, tcp->tccps[compno].cblksty, 1)) { if (OPJ_FALSE == t2_init_seg(cblk, segno, tcp->tccps[compno].cblksty, 1)) {
// TODO: LH: shall we destroy bio here ? /* TODO: LH: shall we destroy bio here ?*/
opj_event_msg(t2->cinfo, EVT_WARNING, "Not enough memory to init segment #%d\n", segno); opj_event_msg(t2->cinfo, EVT_WARNING, "Not enough memory to init segment #%d\n", segno);
return -999; return -999;
} }
@ -576,7 +576,7 @@ static int t2_decode_packet(opj_t2_t* t2, unsigned char *src, int len, opj_tcd_t
if (cblk->segs[segno].numpasses == cblk->segs[segno].maxpasses) { if (cblk->segs[segno].numpasses == cblk->segs[segno].maxpasses) {
++segno; ++segno;
if (OPJ_FALSE == t2_init_seg(cblk, segno, tcp->tccps[compno].cblksty, 0)) { if (OPJ_FALSE == t2_init_seg(cblk, segno, tcp->tccps[compno].cblksty, 0)) {
// TODO: LH: shall we destroy bio here ? /* TODO: LH: shall we destroy bio here ?*/
opj_event_msg(t2->cinfo, EVT_WARNING, "Not enough memory to init segment #%d\n", segno); opj_event_msg(t2->cinfo, EVT_WARNING, "Not enough memory to init segment #%d\n", segno);
return -999; return -999;
} }
@ -591,7 +591,7 @@ static int t2_decode_packet(opj_t2_t* t2, unsigned char *src, int len, opj_tcd_t
if (n > 0) { if (n > 0) {
++segno; ++segno;
if (OPJ_FALSE == t2_init_seg(cblk, segno, tcp->tccps[compno].cblksty, 0)) { if (OPJ_FALSE == t2_init_seg(cblk, segno, tcp->tccps[compno].cblksty, 0)) {
// TODO: LH: shall we destroy bio here ? /* TODO: LH: shall we destroy bio here ? */
opj_event_msg(t2->cinfo, EVT_WARNING, "Not enough memory to init segment #%d\n", segno); opj_event_msg(t2->cinfo, EVT_WARNING, "Not enough memory to init segment #%d\n", segno);
return -999; return -999;
} }
@ -660,6 +660,7 @@ static int t2_decode_packet(opj_t2_t* t2, unsigned char *src, int len, opj_tcd_t
} }
do { do {
unsigned char * new_data;
if (c + seg->newlen > src + len) { if (c + seg->newlen > src + len) {
return -999; return -999;
} }
@ -684,12 +685,12 @@ static int t2_decode_packet(opj_t2_t* t2, unsigned char *src, int len, opj_tcd_t
#endif /* USE_JPWL */ #endif /* USE_JPWL */
unsigned char * new_data = (unsigned char*) opj_realloc(cblk->data, (cblk->len + seg->newlen) * sizeof(unsigned char)); new_data = (unsigned char*) opj_realloc(cblk->data, (cblk->len + seg->newlen) * sizeof(unsigned char));
if (! new_data) { if (! new_data) {
opj_event_msg(t2->cinfo, EVT_ERROR, "JPWL: Not enough memory for codeblock data %d (p=%d, b=%d, r=%d, c=%d)\n", opj_event_msg(t2->cinfo, EVT_ERROR, "JPWL: Not enough memory for codeblock data %d (p=%d, b=%d, r=%d, c=%d)\n",
seg->newlen, cblkno, precno, bandno, resno, compno); seg->newlen, cblkno, precno, bandno, resno, compno);
cblk->data = 0; cblk->data = 0;
cblk->len = 0; // TODO: LH: other things to reset ? cblk->len = 0; /* TODO: LH: other things to reset ?*/
opj_free(cblk->data); opj_free(cblk->data);
return -999; return -999;
} }
@ -912,8 +913,8 @@ opj_bool t2_encode_packets_v2(
info_PK->start_pos = ((l_cp->m_specific_param.m_enc.m_tp_on | l_tcp->POC)&& info_PK->start_pos) ? info_PK->start_pos : info_TL->packet[cstr_info->packno - 1].end_pos + 1; info_PK->start_pos = ((l_cp->m_specific_param.m_enc.m_tp_on | l_tcp->POC)&& info_PK->start_pos) ? info_PK->start_pos : info_TL->packet[cstr_info->packno - 1].end_pos + 1;
} }
info_PK->end_pos = info_PK->start_pos + l_nb_bytes - 1; info_PK->end_pos = info_PK->start_pos + l_nb_bytes - 1;
info_PK->end_ph_pos += info_PK->start_pos - 1; // End of packet header which now only represents the distance info_PK->end_ph_pos += info_PK->start_pos - 1; /* End of packet header which now only represents the distance
// to start of packet is incremented by value of start of packet to start of packet is incremented by value of start of packet*/
} }
cstr_info->packno++; cstr_info->packno++;
@ -1401,8 +1402,8 @@ static opj_bool t2_encode_packet_v2(
/* </EPH> */ /* </EPH> */
/* << INDEX */ /* << INDEX */
// End of packet header position. Currently only represents the distance to start of packet /* End of packet header position. Currently only represents the distance to start of packet
// Will be updated later by incrementing with packet start value Will be updated later by incrementing with packet start value*/
if(cstr_info && cstr_info->index_write) { if(cstr_info && cstr_info->index_write) {
opj_packet_info_t *info_PK = &cstr_info->tile[tileno].packet[cstr_info->packno]; opj_packet_info_t *info_PK = &cstr_info->tile[tileno].packet[cstr_info->packno];
info_PK->end_ph_pos = (OPJ_INT32)(c - dest); info_PK->end_ph_pos = (OPJ_INT32)(c - dest);
@ -1960,9 +1961,10 @@ static opj_bool t2_init_seg_v2(opj_tcd_cblk_dec_v2_t* cblk, OPJ_UINT32 index, OP
OPJ_UINT32 l_nb_segs = index + 1; OPJ_UINT32 l_nb_segs = index + 1;
if (l_nb_segs > cblk->m_current_max_segs) { if (l_nb_segs > cblk->m_current_max_segs) {
opj_tcd_seg_t* new_segs;
cblk->m_current_max_segs += J2K_DEFAULT_NB_SEGS; cblk->m_current_max_segs += J2K_DEFAULT_NB_SEGS;
opj_tcd_seg_t* new_segs = (opj_tcd_seg_t*) opj_realloc(cblk->segs, cblk->m_current_max_segs * sizeof(opj_tcd_seg_t)); new_segs = (opj_tcd_seg_t*) opj_realloc(cblk->segs, cblk->m_current_max_segs * sizeof(opj_tcd_seg_t));
if(! new_segs) { if(! new_segs) {
opj_free(cblk->segs); opj_free(cblk->segs);
cblk->segs = NULL; cblk->segs = NULL;