Merge to M46: upgrade openjpeg to commit# cf352af

third_party/libopenjpeg20/tcd.c

 /*
  * The copyright in this software is being made available under the 2-clauses 
  * BSD License, included below. This software may be subject to other third 
  * party and contributor rights, including patent rights, and no such rights
  * are granted under this license.
  *
  * Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
  * Copyright (c) 2002-2014, Professor Benoit Macq
  * Copyright (c) 2001-2003, David Janssens
  * Copyright (c) 2002-2003, Yannick Verschueren
@@ skipping 89 matching lines @@
                 }
                 fprintf(fd, "  }\n");
         }
         fprintf(fd, "}\n");
 }
 #endif
 
 /**
  * Initializes tile coding/decoding
  */
-static INLINE OPJ_BOOL opj_tcd_init_tile(opj_tcd_t *p_tcd, OPJ_UINT32 p_tile_no, OPJ_BOOL isEncoder, OPJ_FLOAT32 fraction, OPJ_SIZE_T sizeof_block);
+static INLINE OPJ_BOOL opj_tcd_init_tile(opj_tcd_t *p_tcd, OPJ_UINT32 p_tile_no, OPJ_BOOL isEncoder, OPJ_FLOAT32 fraction, OPJ_SIZE_T sizeof_block, opj_event_mgr_t* manager);
 
 /**
 * Allocates memory for a decoding code block.
 */
 static OPJ_BOOL opj_tcd_code_block_dec_allocate (opj_tcd_cblk_dec_t * p_code_block);
 
 /**
  * Deallocates the decoding data of the given precinct.
  */
 static void opj_tcd_code_block_dec_deallocate (opj_tcd_precinct_t * p_precinct);
@@ skipping 18 matching lines @@
 Free the memory allocated for encoding
 @param tcd TCD handle
 */
 static void opj_tcd_free_tile(opj_tcd_t *tcd);
 
 
 static OPJ_BOOL opj_tcd_t2_decode ( opj_tcd_t *p_tcd,
                                     OPJ_BYTE * p_src_data,
                                     OPJ_UINT32 * p_data_read,
                                     OPJ_UINT32 p_max_src_size,
-                                    opj_codestream_index_t *p_cstr_index );
+                                    opj_codestream_index_t *p_cstr_index,
+                                    opj_event_mgr_t *p_manager);
 
 static OPJ_BOOL opj_tcd_t1_decode (opj_tcd_t *p_tcd);
 
 static OPJ_BOOL opj_tcd_dwt_decode (opj_tcd_t *p_tcd);
 
-static OPJ_BOOL opj_tcd_mct_decode (opj_tcd_t *p_tcd);
+static OPJ_BOOL opj_tcd_mct_decode (opj_tcd_t *p_tcd, opj_event_mgr_t *p_manager);
 
 static OPJ_BOOL opj_tcd_dc_level_shift_decode (opj_tcd_t *p_tcd);
 
 
 static OPJ_BOOL opj_tcd_dc_level_shift_encode ( opj_tcd_t *p_tcd );
 
 static OPJ_BOOL opj_tcd_mct_encode ( opj_tcd_t *p_tcd );
 
 static OPJ_BOOL opj_tcd_dwt_encode ( opj_tcd_t *p_tcd );
 
@@ skipping 94 matching lines @@
                                                         } else {
                                                                 dr = pass->rate - cblk->passes[n - 1].rate;
                                                                 dd = pass->distortiondec - cblk->passes[n - 1].distortiondec;
                                                         }
 
                                                         if (!dr) {
                                                                 if (dd != 0)
                                                                         n = passno + 1;
                                                                 continue;
                                                         }
-                                                        if (dd / dr >= thresh)
+                                                        if (thresh - (dd / dr) < DBL_EPSILON) /* do not rely on float equality, check with DBL_EPSILON margin */
                                                                 n = passno + 1;
                                                 }
 
                                                 layer->numpasses = n - cblk->numpassesinlayers;
 
                                                 if (!layer->numpasses) {
                                                         layer->disto = 0;
                                                         continue;
                                                 }
 
@@ skipping 367 matching lines @@
                 l_tilec->data = new_data;
                 /*fprintf(stderr, "tReallocate data of tilec (int): from %d to %d x OPJ_UINT32n", l_tilec->data_size, l_data_size);*/
                 l_tilec->data_size = l_tilec->data_size_needed;
                 l_tilec->ownsData = OPJ_TRUE;
         }
         return OPJ_TRUE;
 }
 
 /* ----------------------------------------------------------------------- */
 
-static INLINE OPJ_BOOL opj_tcd_init_tile(opj_tcd_t *p_tcd, OPJ_UINT32 p_tile_no, OPJ_BOOL isEncoder, OPJ_FLOAT32 fraction, OPJ_SIZE_T sizeof_block)
+static INLINE OPJ_BOOL opj_tcd_init_tile(opj_tcd_t *p_tcd, OPJ_UINT32 p_tile_no, OPJ_BOOL isEncoder, OPJ_FLOAT32 fraction, OPJ_SIZE_T sizeof_block, opj_event_mgr_t* manager)
 {
         OPJ_UINT32 (*l_gain_ptr)(OPJ_UINT32) = 00;
         OPJ_UINT32 compno, resno, bandno, precno, cblkno;
         opj_tcp_t * l_tcp = 00;
         opj_cp_t * l_cp = 00;
         opj_tcd_tile_t * l_tile = 00;
         opj_tccp_t *l_tccp = 00;
         opj_tcd_tilecomp_t *l_tilec = 00;
         opj_image_comp_t * l_image_comp = 00;
         opj_tcd_resolution_t *l_res = 00;
@@ skipping 35 matching lines @@
         /* 4 borders of the tile rescale on the image if necessary */
         l_tx0 = l_cp->tx0 + p * l_cp->tdx; /* can't be greater than l_image->x1 so won't overflow */
         l_tile->x0 = (OPJ_INT32)opj_uint_max(l_tx0, l_image->x0);
         l_tile->x1 = (OPJ_INT32)opj_uint_min(opj_uint_adds(l_tx0, l_cp->tdx), l_image->x1);
         l_ty0 = l_cp->ty0 + q * l_cp->tdy; /* can't be greater than l_image->y1 so won't overflow */
         l_tile->y0 = (OPJ_INT32)opj_uint_max(l_ty0, l_image->y0);
         l_tile->y1 = (OPJ_INT32)opj_uint_min(opj_uint_adds(l_ty0, l_cp->tdy), l_image->y1);
 
         /* testcase 1888.pdf.asan.35.988 */
         if (l_tccp->numresolutions == 0) {
-                fprintf(stderr, "tiles require at least one resolution\n");
+                opj_event_msg(manager, EVT_ERROR, "tiles require at least one resolution\n");
                 return OPJ_FALSE;
         }
         /*fprintf(stderr, "Tile border = %d,%d,%d,%d\n", l_tile->x0, l_tile->y0,l_tile->x1,l_tile->y1);*/
         
         /*tile->numcomps = image->numcomps; */
         for (compno = 0; compno < l_tile->numcomps; ++compno) {
                 /*fprintf(stderr, "compno = %d/%d\n", compno, l_tile->numcomps);*/
                 l_image_comp->resno_decoded = 0;
                 /* border of each l_tile component (global) */
                 l_tilec->x0 = opj_int_ceildiv(l_tile->x0, (OPJ_INT32)l_image_comp->dx);
                 l_tilec->y0 = opj_int_ceildiv(l_tile->y0, (OPJ_INT32)l_image_comp->dy);
                 l_tilec->x1 = opj_int_ceildiv(l_tile->x1, (OPJ_INT32)l_image_comp->dx);
                 l_tilec->y1 = opj_int_ceildiv(l_tile->y1, (OPJ_INT32)l_image_comp->dy);
                 /*fprintf(stderr, "\tTile compo border = %d,%d,%d,%d\n", l_tilec->x0, l_tilec->y0,l_tilec->x1,l_tilec->y1);*/
                 
                 /* compute l_data_size with overflow check */
                 l_data_size = (OPJ_UINT32)(l_tilec->x1 - l_tilec->x0);
                 if ((((OPJ_UINT32)-1) / l_data_size) < (OPJ_UINT32)(l_tilec->y1 - l_tilec->y0)) {
-                        /* TODO event */
+                        opj_event_msg(manager, EVT_ERROR, "Not enough memory for tile data\n");
                         return OPJ_FALSE;
                 }
                 l_data_size = l_data_size * (OPJ_UINT32)(l_tilec->y1 - l_tilec->y0);
                 
                 if ((((OPJ_UINT32)-1) / (OPJ_UINT32)sizeof(OPJ_UINT32)) < l_data_size) {
-                        /* TODO event */
+                        opj_event_msg(manager, EVT_ERROR, "Not enough memory for tile data\n");
                         return OPJ_FALSE;
                 }
                 l_data_size = l_data_size * (OPJ_UINT32)sizeof(OPJ_UINT32);
                 l_tilec->numresolutions = l_tccp->numresolutions;
                 if (l_tccp->numresolutions < l_cp->m_specific_param.m_dec.m_reduce) {
                         l_tilec->minimum_num_resolutions = 1;
                 }
                 else {
                         l_tilec->minimum_num_resolutions = l_tccp->numresolutions - l_cp->m_specific_param.m_dec.m_reduce;
                 }
                 
                 l_tilec->data_size_needed = l_data_size;
                 if (p_tcd->m_is_decoder && !opj_alloc_tile_component_data(l_tilec)) {
+                        opj_event_msg(manager, EVT_ERROR, "Not enough memory for tile data\n");
                         return OPJ_FALSE;
                 }
                 
                 l_data_size = l_tilec->numresolutions * (OPJ_UINT32)sizeof(opj_tcd_resolution_t);
                 
                 if (l_tilec->resolutions == 00) {
                         l_tilec->resolutions = (opj_tcd_resolution_t *) opj_malloc(l_data_size);
                         if (! l_tilec->resolutions ) {
                                 return OPJ_FALSE;
                         }
                         /*fprintf(stderr, "\tAllocate resolutions of tilec (opj_tcd_resolution_t): %d\n",l_data_size);*/
                         l_tilec->resolutions_size = l_data_size;
                         memset(l_tilec->resolutions,0,l_data_size);
                 }
                 else if (l_data_size > l_tilec->resolutions_size) {
                         opj_tcd_resolution_t* new_resolutions = (opj_tcd_resolution_t *) opj_realloc(l_tilec->resolutions, l_data_size);
                         if (! new_resolutions) {
-                                /* opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to tile resolutions\n");                                                                                         */
-                                fprintf(stderr, "Not enough memory to tile resolutions\n");
+                                opj_event_msg(manager, EVT_ERROR, "Not enough memory for tile resolutions\n");
                                 opj_free(l_tilec->resolutions);
                                 l_tilec->resolutions = NULL;
                                 l_tilec->resolutions_size = 0;
                                 return OPJ_FALSE;
                         }
                         l_tilec->resolutions = new_resolutions;
                         /*fprintf(stderr, "\tReallocate data of tilec (int): from %d to %d x OPJ_UINT32\n", l_tilec->resolutions_size, l_data_size);*/
                         memset(((OPJ_BYTE*) l_tilec->resolutions)+l_tilec->resolutions_size,0,l_data_size - l_tilec->resolutions_size);
                         l_tilec->resolutions_size = l_data_size;
                 }
@@ skipping 72 matching lines @@
                                         l_band->x1 = opj_int_ceildivpow2(l_tilec->x1, (OPJ_INT32)l_level_no);
                                         l_band->y1 = opj_int_ceildivpow2(l_tilec->y1, (OPJ_INT32)l_level_no);
                                 }
                                 else {
                                         l_band->bandno = bandno + 1;
                                         /* x0b = 1 if bandno = 1 or 3 */
                                         l_x0b = l_band->bandno&1;
                                         /* y0b = 1 if bandno = 2 or 3 */
                                         l_y0b = (OPJ_INT32)((l_band->bandno)>>1);
                                         /* l_band border (global) */
-                                        l_band->x0 = opj_int_ceildivpow2(l_tilec->x0 - (1 << l_level_no) * l_x0b, (OPJ_INT32)(l_level_no + 1));
-                                        l_band->y0 = opj_int_ceildivpow2(l_tilec->y0 - (1 << l_level_no) * l_y0b, (OPJ_INT32)(l_level_no + 1));
-                                        l_band->x1 = opj_int_ceildivpow2(l_tilec->x1 - (1 << l_level_no) * l_x0b, (OPJ_INT32)(l_level_no + 1));
-                                        l_band->y1 = opj_int_ceildivpow2(l_tilec->y1 - (1 << l_level_no) * l_y0b, (OPJ_INT32)(l_level_no + 1));
+                                        l_band->x0 = opj_int64_ceildivpow2(l_tilec->x0 - ((OPJ_INT64)l_x0b << l_level_no), (OPJ_INT32)(l_level_no + 1));
+                                        l_band->y0 = opj_int64_ceildivpow2(l_tilec->y0 - ((OPJ_INT64)l_y0b << l_level_no), (OPJ_INT32)(l_level_no + 1));
+                                        l_band->x1 = opj_int64_ceildivpow2(l_tilec->x1 - ((OPJ_INT64)l_x0b << l_level_no), (OPJ_INT32)(l_level_no + 1));
+                                        l_band->y1 = opj_int64_ceildivpow2(l_tilec->y1 - ((OPJ_INT64)l_y0b << l_level_no), (OPJ_INT32)(l_level_no + 1));
                                 }
                                 
                                 /** avoid an if with storing function pointer */
                                 l_gain = (*l_gain_ptr) (l_band->bandno);
                                 numbps = (OPJ_INT32)(l_image_comp->prec + l_gain);
                                 l_band->stepsize = (OPJ_FLOAT32)(((1.0 + l_step_size->mant / 2048.0) * pow(2.0, (OPJ_INT32) (numbps - l_step_size->expn)))) * fraction;
                                 l_band->numbps = l_step_size->expn + (OPJ_INT32)l_tccp->numgbits - 1;      /* WHY -1 ? */
                                 
                                 if (! l_band->precincts) {
                                         l_band->precincts = (opj_tcd_precinct_t *) opj_malloc( /*3 * */ l_nb_precinct_size);
                                         if (! l_band->precincts) {
                                                 return OPJ_FALSE;
                                         }
                                         /*fprintf(stderr, "\t\t\t\tAllocate precincts of a band (opj_tcd_precinct_t): %d\n",l_nb_precinct_size);     */
                                         memset(l_band->precincts,0,l_nb_precinct_size);
                                         l_band->precincts_data_size = l_nb_precinct_size;
                                 }
                                 else if (l_band->precincts_data_size < l_nb_precinct_size) {
                                         
                                         opj_tcd_precinct_t * new_precincts = (opj_tcd_precinct_t *) opj_realloc(l_band->precincts,/*3 * */ l_nb_precinct_size);
                                         if (! new_precincts) {
-                                                /* opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to handle band precints\n");                                                                    */
-                                                fprintf(stderr, "Not enough memory to handle band precints\n");
+                                                opj_event_msg(manager, EVT_ERROR, "Not enough memory to handle band precints\n");
                                                 opj_free(l_band->precincts);
                                                 l_band->precincts = NULL;
                                                 l_band->precincts_data_size = 0;
                                                 return OPJ_FALSE;
                                         }
                                         l_band->precincts = new_precincts;
                                         /*fprintf(stderr, "\t\t\t\tReallocate precincts of a band (opj_tcd_precinct_t): from %d to %d\n",l_band->precincts_data_size, l_nb_precinct_size);*/
                                         memset(((OPJ_BYTE *) l_band->precincts) + l_band->precincts_data_size,0,l_nb_precinct_size - l_band->precincts_data_size);
                                         l_band->precincts_data_size = l_nb_precinct_size;
                                 }
@@ skipping 42 matching lines @@
                                                 memset(l_current_precinct->cblks.blocks,0,l_nb_code_blocks_size);
                                                 
                                                 l_current_precinct->block_size = l_nb_code_blocks_size;
                                         }
                                         else if (l_nb_code_blocks_size > l_current_precinct->block_size) {
                                                 void *new_blocks = opj_realloc(l_current_precinct->cblks.blocks, l_nb_code_blocks_size);
                                                 if (! new_blocks) {
                                                         opj_free(l_current_precinct->cblks.blocks);
                                                         l_current_precinct->cblks.blocks = NULL;
                                                         l_current_precinct->block_size = 0;
-                                                        /* opj_event_msg(p_manager, EVT_ERROR, "Not enough memory for current precinct codeblock element\n");                                              */
-                                                        fprintf(stderr, "Not enough memory for current precinct codeblock element\n");
+                                                        opj_event_msg(manager, EVT_ERROR, "Not enough memory for current precinct codeblock element\n");
                                                         return OPJ_FALSE;
                                                 }
                                                 l_current_precinct->cblks.blocks = new_blocks;
                                                 /*fprintf(stderr, "\t\t\t\tReallocate cblks of a precinct (opj_tcd_cblk_dec_t): from %d to %d\n",l_current_precinct->block_size, l_nb_code_blocks_size);     */
                                                 
                                                 memset(((OPJ_BYTE *) l_current_precinct->cblks.blocks) + l_current_precinct->block_size
                                                                          ,0
                                                                          ,l_nb_code_blocks_size - l_current_precinct->block_size);
                                                 
                                                 l_current_precinct->block_size = l_nb_code_blocks_size;
                                         }
                                         
                                         if (! l_current_precinct->incltree) {
-                                                l_current_precinct->incltree = opj_tgt_create(l_current_precinct->cw,
-                                                                                                                                                                                                                                        l_current_precinct->ch);
+                                                l_current_precinct->incltree = opj_tgt_create(l_current_precinct->cw, l_current_precinct->ch, manager);
                                         }
                                         else{
-                                                l_current_precinct->incltree = opj_tgt_init(l_current_precinct->incltree,
-                                                                                                                                                                                                                                l_current_precinct->cw,
-                                                                                                                                                                                                                                l_current_precinct->ch);
+                                                l_current_precinct->incltree = opj_tgt_init(l_current_precinct->incltree, l_current_precinct->cw, l_current_precinct->ch, manager);
                                         }
 
                                         if (! l_current_precinct->incltree)     {
-                                                fprintf(stderr, "WARNING: No incltree created.\n");
+                                                opj_event_msg(manager, EVT_WARNING, "No incltree created.\n");
                                                 /*return OPJ_FALSE;*/
                                         }
 
                                         if (! l_current_precinct->imsbtree) {
-                                                l_current_precinct->imsbtree = opj_tgt_create(
-                                                                                                                                                                                                                                        l_current_precinct->cw,
-                                                                                                                                                                                                                                        l_current_precinct->ch);
+                                                l_current_precinct->imsbtree = opj_tgt_create(l_current_precinct->cw, l_current_precinct->ch, manager);
                                         }
                                         else {
-                                                l_current_precinct->imsbtree = opj_tgt_init(
-                                                                                                                                                                                                                                l_current_precinct->imsbtree,
-                                                                                                                                                                                                                                l_current_precinct->cw,
-                                                                                                                                                                                                                                l_current_precinct->ch);
+                                                l_current_precinct->imsbtree = opj_tgt_init(l_current_precinct->imsbtree, l_current_precinct->cw, l_current_precinct->ch, manager);
                                         }
 
                                         if (! l_current_precinct->imsbtree) {
-                                                fprintf(stderr, "WARNING: No imsbtree created.\n");
+                                                opj_event_msg(manager, EVT_WARNING, "No imsbtree created.\n");
                                                 /*return OPJ_FALSE;*/
                                         }
 
                                         for (cblkno = 0; cblkno < l_nb_code_blocks; ++cblkno) {
                                                 OPJ_INT32 cblkxstart = tlcblkxstart + (OPJ_INT32)(cblkno % l_current_precinct->cw) * (1 << cblkwidthexpn);
                                                 OPJ_INT32 cblkystart = tlcblkystart + (OPJ_INT32)(cblkno / l_current_precinct->cw) * (1 << cblkheightexpn);
                                                 OPJ_INT32 cblkxend = cblkxstart + (1 << cblkwidthexpn);
                                                 OPJ_INT32 cblkyend = cblkystart + (1 << cblkheightexpn);
                                                 
                                                 if (isEncoder) {
@@ skipping 32 matching lines @@
                         ++l_res;
                         --l_level_no;
                 } /* resno */
                 ++l_tccp;
                 ++l_tilec;
                 ++l_image_comp;
         } /* compno */
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_tcd_init_encode_tile (opj_tcd_t *p_tcd, OPJ_UINT32 p_tile_no)
+OPJ_BOOL opj_tcd_init_encode_tile (opj_tcd_t *p_tcd, OPJ_UINT32 p_tile_no, opj_event_mgr_t* p_manager)
 {
-        return opj_tcd_init_tile(p_tcd, p_tile_no, OPJ_TRUE, 1.0F, sizeof(opj_tcd_cblk_enc_t));
+        return opj_tcd_init_tile(p_tcd, p_tile_no, OPJ_TRUE, 1.0F, sizeof(opj_tcd_cblk_enc_t), p_manager);
 }
 
-OPJ_BOOL opj_tcd_init_decode_tile (opj_tcd_t *p_tcd, OPJ_UINT32 p_tile_no)
+OPJ_BOOL opj_tcd_init_decode_tile (opj_tcd_t *p_tcd, OPJ_UINT32 p_tile_no, opj_event_mgr_t* p_manager)
 {
-        return opj_tcd_init_tile(p_tcd, p_tile_no, OPJ_FALSE, 0.5F, sizeof(opj_tcd_cblk_dec_t));
+        return opj_tcd_init_tile(p_tcd, p_tile_no, OPJ_FALSE, 0.5F, sizeof(opj_tcd_cblk_dec_t), p_manager);
 }
 
 /**
  * Allocates memory for an encoding code block (but not data memory).
  */
 static OPJ_BOOL opj_tcd_code_block_enc_allocate (opj_tcd_cblk_enc_t * p_code_block)
 {
         if (! p_code_block->layers) {
                 /* no memset since data */
                 p_code_block->layers = (opj_tcd_layer_t*) opj_calloc(100, sizeof(opj_tcd_layer_t));
@@ skipping 16 matching lines @@
 static OPJ_BOOL opj_tcd_code_block_enc_allocate_data (opj_tcd_cblk_enc_t * p_code_block)
 {
         OPJ_UINT32 l_data_size;
         
         l_data_size = (OPJ_UINT32)((p_code_block->x1 - p_code_block->x0) * (p_code_block->y1 - p_code_block->y0) * (OPJ_INT32)sizeof(OPJ_UINT32));
         
         if (l_data_size > p_code_block->data_size) {
                 if (p_code_block->data) {
                         opj_free(p_code_block->data - 1); /* again, why -1 */
                 }
-                p_code_block->data = (OPJ_BYTE*) opj_malloc(l_data_size);
+                p_code_block->data = (OPJ_BYTE*) opj_malloc(l_data_size+1);
                 if(! p_code_block->data) {
                         p_code_block->data_size = 0U;
                         return OPJ_FALSE;
                 }
                 p_code_block->data_size = l_data_size;
                 
                 p_code_block->data[0] = 0;
                 p_code_block->data+=1;   /*why +1 ?*/
         }
         return OPJ_TRUE;
@@ skipping 156 matching lines @@
 
         /*---------------CLEAN-------------------*/
 
         return OPJ_TRUE;
 }
 
 OPJ_BOOL opj_tcd_decode_tile(   opj_tcd_t *p_tcd,
                                 OPJ_BYTE *p_src,
                                 OPJ_UINT32 p_max_length,
                                 OPJ_UINT32 p_tile_no,
-                                opj_codestream_index_t *p_cstr_index
+                                opj_codestream_index_t *p_cstr_index,
+                                opj_event_mgr_t *p_manager
                                 )
 {
         OPJ_UINT32 l_data_read;
         p_tcd->tcd_tileno = p_tile_no;
         p_tcd->tcp = &(p_tcd->cp->tcps[p_tile_no]);
 
 #ifdef TODO_MSD /* FIXME */
         /* INDEX >>  */
         if(p_cstr_info) {
                 OPJ_UINT32 resno, compno, numprec = 0;
@@ skipping 12 matching lines @@
                 }
                 p_cstr_info->tile[p_tile_no].packet = (opj_packet_info_t *) opj_malloc(p_cstr_info->numlayers * numprec * sizeof(opj_packet_info_t));
                 p_cstr_info->packno = 0;
         }
         /* << INDEX */
 #endif
 
         /*--------------TIER2------------------*/
         /* FIXME _ProfStart(PGROUP_T2); */
         l_data_read = 0;
-        if (! opj_tcd_t2_decode(p_tcd, p_src, &l_data_read, p_max_length, p_cstr_index))
+        if (! opj_tcd_t2_decode(p_tcd, p_src, &l_data_read, p_max_length, p_cstr_index, p_manager))
         {
                 return OPJ_FALSE;
         }
         /* FIXME _ProfStop(PGROUP_T2); */
 
         /*------------------TIER1-----------------*/
 
         /* FIXME _ProfStart(PGROUP_T1); */
         if
                 (! opj_tcd_t1_decode(p_tcd))
         {
                 return OPJ_FALSE;
         }
         /* FIXME _ProfStop(PGROUP_T1); */
 
         /*----------------DWT---------------------*/
 
         /* FIXME _ProfStart(PGROUP_DWT); */
         if
                 (! opj_tcd_dwt_decode(p_tcd))
         {
                 return OPJ_FALSE;
         }
         /* FIXME _ProfStop(PGROUP_DWT); */
 
         /*----------------MCT-------------------*/
         /* FIXME _ProfStart(PGROUP_MCT); */
         if
-                (! opj_tcd_mct_decode(p_tcd))
+                (! opj_tcd_mct_decode(p_tcd, p_manager))
         {
                 return OPJ_FALSE;
         }
         /* FIXME _ProfStop(PGROUP_MCT); */
 
         /* FIXME _ProfStart(PGROUP_DC_SHIFT); */
         if
                 (! opj_tcd_dc_level_shift_decode(p_tcd))
         {
                 return OPJ_FALSE;
@@ skipping 113 matching lines @@
                 ++l_img_comp;
                 ++l_tilec;
         }
 
         return OPJ_TRUE;
 }
 
 
 
 
-void opj_tcd_free_tile(opj_tcd_t *p_tcd)
+static void opj_tcd_free_tile(opj_tcd_t *p_tcd)
 {
         OPJ_UINT32 compno, resno, bandno, precno;
         opj_tcd_tile_t *l_tile = 00;
         opj_tcd_tilecomp_t *l_tile_comp = 00;
         opj_tcd_resolution_t *l_res = 00;
         opj_tcd_band_t *l_band = 00;
         opj_tcd_precinct_t *l_precinct = 00;
         OPJ_UINT32 l_nb_resolutions, l_nb_precincts;
         void (* l_tcd_code_block_deallocate) (opj_tcd_precinct_t *) = 00;
 
@@ skipping 62 matching lines @@
                 ++l_tile_comp;
         }
 
         opj_free(l_tile->comps);
         l_tile->comps = 00;
         opj_free(p_tcd->tcd_image->tiles);
         p_tcd->tcd_image->tiles = 00;
 }
 
 
-OPJ_BOOL opj_tcd_t2_decode (opj_tcd_t *p_tcd,
+static OPJ_BOOL opj_tcd_t2_decode (opj_tcd_t *p_tcd,
                             OPJ_BYTE * p_src_data,
                             OPJ_UINT32 * p_data_read,
                             OPJ_UINT32 p_max_src_size,
-                            opj_codestream_index_t *p_cstr_index
+                            opj_codestream_index_t *p_cstr_index,
+                            opj_event_mgr_t *p_manager
                             )
 {
         opj_t2_t * l_t2;
 
         l_t2 = opj_t2_create(p_tcd->image, p_tcd->cp);
         if (l_t2 == 00) {
                 return OPJ_FALSE;
         }
 
         if (! opj_t2_decode_packets(
                                         l_t2,
                                         p_tcd->tcd_tileno,
                                         p_tcd->tcd_image->tiles,
                                         p_src_data,
                                         p_data_read,
                                         p_max_src_size,
-                                        p_cstr_index)) {
+                                        p_cstr_index,
+                                        p_manager)) {
                 opj_t2_destroy(l_t2);
                 return OPJ_FALSE;
         }
 
         opj_t2_destroy(l_t2);
 
         /*---------------CLEAN-------------------*/
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_tcd_t1_decode ( opj_tcd_t *p_tcd )
+static OPJ_BOOL opj_tcd_t1_decode ( opj_tcd_t *p_tcd )
 {
         OPJ_UINT32 compno;
         opj_t1_t * l_t1;
         opj_tcd_tile_t * l_tile = p_tcd->tcd_image->tiles;
         opj_tcd_tilecomp_t* l_tile_comp = l_tile->comps;
         opj_tccp_t * l_tccp = p_tcd->tcp->tccps;
 
 
         l_t1 = opj_t1_create(OPJ_FALSE);
         if (l_t1 == 00) {
                 return OPJ_FALSE;
         }
 
         for (compno = 0; compno < l_tile->numcomps; ++compno) {
                 /* The +3 is headroom required by the vectorized DWT */
                 if (OPJ_FALSE == opj_t1_decode_cblks(l_t1, l_tile_comp, l_tccp)) {
                         opj_t1_destroy(l_t1);
                         return OPJ_FALSE;
                 }
                 ++l_tile_comp;
                 ++l_tccp;
         }
 
         opj_t1_destroy(l_t1);
 
         return OPJ_TRUE;
 }
 
 
-OPJ_BOOL opj_tcd_dwt_decode ( opj_tcd_t *p_tcd )
+static OPJ_BOOL opj_tcd_dwt_decode ( opj_tcd_t *p_tcd )
 {
         OPJ_UINT32 compno;
         opj_tcd_tile_t * l_tile = p_tcd->tcd_image->tiles;
         opj_tcd_tilecomp_t * l_tile_comp = l_tile->comps;
         opj_tccp_t * l_tccp = p_tcd->tcp->tccps;
         opj_image_comp_t * l_img_comp = p_tcd->image->comps;
 
         for (compno = 0; compno < l_tile->numcomps; compno++) {
                 /*
                 if (tcd->cp->reduce != 0) {
@@ skipping 19 matching lines @@
                         }
                 }
 
                 ++l_tile_comp;
                 ++l_img_comp;
                 ++l_tccp;
         }
 
         return OPJ_TRUE;
 }
-OPJ_BOOL opj_tcd_mct_decode ( opj_tcd_t *p_tcd )
+static OPJ_BOOL opj_tcd_mct_decode ( opj_tcd_t *p_tcd, opj_event_mgr_t *p_manager)
 {
         opj_tcd_tile_t * l_tile = p_tcd->tcd_image->tiles;
         opj_tcp_t * l_tcp = p_tcd->tcp;
         opj_tcd_tilecomp_t * l_tile_comp = l_tile->comps;
         OPJ_UINT32 l_samples,i;
 
         if (! l_tcp->mct) {
                 return OPJ_TRUE;
         }
 
         l_samples = (OPJ_UINT32)((l_tile_comp->x1 - l_tile_comp->x0) * (l_tile_comp->y1 - l_tile_comp->y0));
 
         if (l_tile->numcomps >= 3 ){
                 /* testcase 1336.pdf.asan.47.376 */
                 if ((l_tile->comps[0].x1 - l_tile->comps[0].x0) * (l_tile->comps[0].y1 - l_tile->comps[0].y0) < (OPJ_INT32)l_samples ||
                     (l_tile->comps[1].x1 - l_tile->comps[1].x0) * (l_tile->comps[1].y1 - l_tile->comps[1].y0) < (OPJ_INT32)l_samples ||
                     (l_tile->comps[2].x1 - l_tile->comps[2].x0) * (l_tile->comps[2].y1 - l_tile->comps[2].y0) < (OPJ_INT32)l_samples) {
-                        fprintf(stderr, "Tiles don't all have the same dimension. Skip the MCT step.\n");
+                        opj_event_msg(p_manager, EVT_ERROR, "Tiles don't all have the same dimension. Skip the MCT step.\n");
                         return OPJ_FALSE;
                 }
                 else if (l_tcp->mct == 2) {
                         OPJ_BYTE ** l_data;
 
                         if (! l_tcp->m_mct_decoding_matrix) {
                                 return OPJ_TRUE;
                         }
 
                         l_data = (OPJ_BYTE **) opj_malloc(l_tile->numcomps*sizeof(OPJ_BYTE*));
@@ skipping 31 matching lines @@
                         }
                         else {
                             opj_mct_decode_real((OPJ_FLOAT32*)l_tile->comps[0].data,
                                                 (OPJ_FLOAT32*)l_tile->comps[1].data,
                                                 (OPJ_FLOAT32*)l_tile->comps[2].data,
                                                 l_samples);
                         }
                 }
         }
         else {
-                /* FIXME need to use opj_event_msg function */
-                fprintf(stderr,"Number of components (%d) is inconsistent with a MCT. Skip the MCT step.\n",l_tile->numcomps);
+                opj_event_msg(p_manager, EVT_ERROR, "Number of components (%d) is inconsistent with a MCT. Skip the MCT step.\n",l_tile->numcomps);
         }
 
         return OPJ_TRUE;
 }
 
 
-OPJ_BOOL opj_tcd_dc_level_shift_decode ( opj_tcd_t *p_tcd )
+static OPJ_BOOL opj_tcd_dc_level_shift_decode ( opj_tcd_t *p_tcd )
 {
         OPJ_UINT32 compno;
         opj_tcd_tilecomp_t * l_tile_comp = 00;
         opj_tccp_t * l_tccp = 00;
         opj_image_comp_t * l_img_comp = 00;
         opj_tcd_resolution_t* l_res = 00;
         opj_tcd_tile_t * l_tile;
         OPJ_UINT32 l_width,l_height,i,j;
         OPJ_INT32 * l_current_ptr;
         OPJ_INT32 l_min, l_max;
@@ skipping 29 matching lines @@
                                         *l_current_ptr = opj_int_clamp(*l_current_ptr + l_tccp->m_dc_level_shift, l_min, l_max);
                                         ++l_current_ptr;
                                 }
                                 l_current_ptr += l_stride;
                         }
                 }
                 else {
                         for (j=0;j<l_height;++j) {
                                 for (i = 0; i < l_width; ++i) {
                                         OPJ_FLOAT32 l_value = *((OPJ_FLOAT32 *) l_current_ptr);
-                                        *l_current_ptr = opj_int_clamp((OPJ_INT32)lrintf(l_value) + l_tccp->m_dc_level_shift, l_min, l_max); ;
+                                        *l_current_ptr = opj_int_clamp((OPJ_INT32)opj_lrintf(l_value) + l_tccp->m_dc_level_shift, l_min, l_max); ;
                                         ++l_current_ptr;
                                 }
                                 l_current_ptr += l_stride;
                         }
                 }
 
                 ++l_img_comp;
                 ++l_tccp;
                 ++l_tile_comp;
         }
 
         return OPJ_TRUE;
 }
 
 
 
 /**
  * Deallocates the encoding data of the given precinct.
  */
-void opj_tcd_code_block_dec_deallocate (opj_tcd_precinct_t * p_precinct)
+static void opj_tcd_code_block_dec_deallocate (opj_tcd_precinct_t * p_precinct)
 {
         OPJ_UINT32 cblkno , l_nb_code_blocks;
 
         opj_tcd_cblk_dec_t * l_code_block = p_precinct->cblks.dec;
         if (l_code_block) {
                 /*fprintf(stderr,"deallocate codeblock:{\n");*/
                 /*fprintf(stderr,"\t x0=%d, y0=%d, x1=%d, y1=%d\n",l_code_block->x0, l_code_block->y0, l_code_block->x1, l_code_block->y1);*/
                 /*fprintf(stderr,"\t numbps=%d, numlenbits=%d, len=%d, numnewpasses=%d, real_num_segs=%d, m_current_max_segs=%d\n ",
                                 l_code_block->numbps, l_code_block->numlenbits, l_code_block->len, l_code_block->numnewpasses, l_code_block->real_num_segs, l_code_block->m_current_max_segs );*/
 
@@ skipping 17 matching lines @@
                 }
 
                 opj_free(p_precinct->cblks.dec);
                 p_precinct->cblks.dec = 00;
         }
 }
 
 /**
  * Deallocates the encoding data of the given precinct.
  */
-void opj_tcd_code_block_enc_deallocate (opj_tcd_precinct_t * p_precinct)
+static void opj_tcd_code_block_enc_deallocate (opj_tcd_precinct_t * p_precinct)
 {       
         OPJ_UINT32 cblkno , l_nb_code_blocks;
 
         opj_tcd_cblk_enc_t * l_code_block = p_precinct->cblks.enc;
         if (l_code_block) {
                 l_nb_code_blocks = p_precinct->block_size / sizeof(opj_tcd_cblk_enc_t);
                 
                 for     (cblkno = 0; cblkno < l_nb_code_blocks; ++cblkno)  {
                         if (l_code_block->data) {
                                 opj_free(l_code_block->data - 1);
@@ skipping 40 matching lines @@
                 }
 
                 l_data_size += l_size_comp * (OPJ_UINT32)((l_tilec->x1 - l_tilec->x0) * (l_tilec->y1 - l_tilec->y0));
                 ++l_img_comp;
                 ++l_tilec;
         }
 
         return l_data_size;
 }
                 
-OPJ_BOOL opj_tcd_dc_level_shift_encode ( opj_tcd_t *p_tcd )
+static OPJ_BOOL opj_tcd_dc_level_shift_encode ( opj_tcd_t *p_tcd )
 {
         OPJ_UINT32 compno;
         opj_tcd_tilecomp_t * l_tile_comp = 00;
         opj_tccp_t * l_tccp = 00;
         opj_image_comp_t * l_img_comp = 00;
         opj_tcd_tile_t * l_tile;
         OPJ_UINT32 l_nb_elem,i;
         OPJ_INT32 * l_current_ptr;
 
         l_tile = p_tcd->tcd_image->tiles;
@@ skipping 19 matching lines @@
                 }
 
                 ++l_img_comp;
                 ++l_tccp;
                 ++l_tile_comp;
         }
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_tcd_mct_encode ( opj_tcd_t *p_tcd )
+static OPJ_BOOL opj_tcd_mct_encode ( opj_tcd_t *p_tcd )
 {
         opj_tcd_tile_t * l_tile = p_tcd->tcd_image->tiles;
         opj_tcd_tilecomp_t * l_tile_comp = p_tcd->tcd_image->tiles->comps;
         OPJ_UINT32 samples = (OPJ_UINT32)((l_tile_comp->x1 - l_tile_comp->x0) * (l_tile_comp->y1 - l_tile_comp->y0));
         OPJ_UINT32 i;
         OPJ_BYTE ** l_data = 00;
         opj_tcp_t * l_tcp = p_tcd->tcp;
 
         if(!p_tcd->tcp->mct) {
                 return OPJ_TRUE;
@@ skipping 34 matching lines @@
         else if (l_tcp->tccps->qmfbid == 0) {
                 opj_mct_encode_real(l_tile->comps[0].data, l_tile->comps[1].data, l_tile->comps[2].data, samples);
         }
         else {
                 opj_mct_encode(l_tile->comps[0].data, l_tile->comps[1].data, l_tile->comps[2].data, samples);
         }
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_tcd_dwt_encode ( opj_tcd_t *p_tcd )
+static OPJ_BOOL opj_tcd_dwt_encode ( opj_tcd_t *p_tcd )
 {
         opj_tcd_tile_t * l_tile = p_tcd->tcd_image->tiles;
         opj_tcd_tilecomp_t * l_tile_comp = p_tcd->tcd_image->tiles->comps;
         opj_tccp_t * l_tccp = p_tcd->tcp->tccps;
         OPJ_UINT32 compno;
 
         for (compno = 0; compno < l_tile->numcomps; ++compno) {
                 if (l_tccp->qmfbid == 1) {
                         if (! opj_dwt_encode(l_tile_comp)) {
                                 return OPJ_FALSE;
                         }
                 }
                 else if (l_tccp->qmfbid == 0) {
                         if (! opj_dwt_encode_real(l_tile_comp)) {
                                 return OPJ_FALSE;
                         }
                 }
 
                 ++l_tile_comp;
                 ++l_tccp;
         }
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_tcd_t1_encode ( opj_tcd_t *p_tcd )
+static OPJ_BOOL opj_tcd_t1_encode ( opj_tcd_t *p_tcd )
 {
         opj_t1_t * l_t1;
         const OPJ_FLOAT64 * l_mct_norms;
         OPJ_UINT32 l_mct_numcomps = 0U;
         opj_tcp_t * l_tcp = p_tcd->tcp;
 
         l_t1 = opj_t1_create(OPJ_TRUE);
         if (l_t1 == 00) {
                 return OPJ_FALSE;
         }
@@ skipping 16 matching lines @@
         if (! opj_t1_encode_cblks(l_t1, p_tcd->tcd_image->tiles , l_tcp, l_mct_norms, l_mct_numcomps)) {
         opj_t1_destroy(l_t1);
                 return OPJ_FALSE;
         }
 
         opj_t1_destroy(l_t1);
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_tcd_t2_encode (opj_tcd_t *p_tcd,
+static OPJ_BOOL opj_tcd_t2_encode (opj_tcd_t *p_tcd,
                                                 OPJ_BYTE * p_dest_data,
                                                 OPJ_UINT32 * p_data_written,
                                                 OPJ_UINT32 p_max_dest_size,
                                                 opj_codestream_info_t *p_cstr_info )
 {
         opj_t2_t * l_t2;
 
         l_t2 = opj_t2_create(p_tcd->image, p_tcd->cp);
         if (l_t2 == 00) {
                 return OPJ_FALSE;
@@ skipping 17 matching lines @@
                 return OPJ_FALSE;
         }
 
         opj_t2_destroy(l_t2);
 
         /*---------------CLEAN-------------------*/
         return OPJ_TRUE;
 }
 
 
-OPJ_BOOL opj_tcd_rate_allocate_encode(  opj_tcd_t *p_tcd,
+static OPJ_BOOL opj_tcd_rate_allocate_encode(  opj_tcd_t *p_tcd,
                                                                             OPJ_BYTE * p_dest_data,
                                                                             OPJ_UINT32 p_max_dest_size,
                                                                             opj_codestream_info_t *p_cstr_info )
 {
         opj_cp_t * l_cp = p_tcd->cp;
         OPJ_UINT32 l_nb_written = 0;
 
         if (p_cstr_info)  {
                 p_cstr_info->index_write = 0;
         }
@@ skipping 96 matching lines @@
                                 }
                                 break;
                 }
 
                 ++l_img_comp;
                 ++l_tilec;
         }
 
         return OPJ_TRUE;
 }