upgrade openjpeg to commit# cf352af

third_party/libopenjpeg20/t2.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 79 matching lines @@
 
 @return  FIXME DOC
 */
 static OPJ_BOOL opj_t2_decode_packet(   opj_t2_t* t2,
                                         opj_tcd_tile_t *tile,
                                         opj_tcp_t *tcp,
                                         opj_pi_iterator_t *pi,
                                         OPJ_BYTE *src,
                                         OPJ_UINT32 * data_read,
                                         OPJ_UINT32 max_length,
-                                        opj_packet_info_t *pack_info);
+                                        opj_packet_info_t *pack_info,
+                                        opj_event_mgr_t *p_manager);
 
 static OPJ_BOOL opj_t2_skip_packet( opj_t2_t* p_t2,
                                     opj_tcd_tile_t *p_tile,
                                     opj_tcp_t *p_tcp,
                                     opj_pi_iterator_t *p_pi,
                                     OPJ_BYTE *p_src,
                                     OPJ_UINT32 * p_data_read,
                                     OPJ_UINT32 p_max_length,
-                                    opj_packet_info_t *p_pack_info);
+                                    opj_packet_info_t *p_pack_info,
+                                    opj_event_mgr_t *p_manager);
 
 static OPJ_BOOL opj_t2_read_packet_header(  opj_t2_t* p_t2,
                                             opj_tcd_tile_t *p_tile,
                                             opj_tcp_t *p_tcp,
                                             opj_pi_iterator_t *p_pi,
                                             OPJ_BOOL * p_is_data_present,
                                             OPJ_BYTE *p_src_data,
                                             OPJ_UINT32 * p_data_read,
                                             OPJ_UINT32 p_max_length,
-                                            opj_packet_info_t *p_pack_info);
+                                            opj_packet_info_t *p_pack_info,
+                                            opj_event_mgr_t *p_manager);
 
 static OPJ_BOOL opj_t2_read_packet_data(opj_t2_t* p_t2,
                                         opj_tcd_tile_t *p_tile,
                                         opj_pi_iterator_t *p_pi,
                                         OPJ_BYTE *p_src_data,
                                         OPJ_UINT32 * p_data_read,
                                         OPJ_UINT32 p_max_length,
-                                        opj_packet_info_t *pack_info);
+                                        opj_packet_info_t *pack_info,
+                                        opj_event_mgr_t *p_manager);
 
 static OPJ_BOOL opj_t2_skip_packet_data(opj_t2_t* p_t2,
                                         opj_tcd_tile_t *p_tile,
                                         opj_pi_iterator_t *p_pi,
                                         OPJ_UINT32 * p_data_read,
                                         OPJ_UINT32 p_max_length,
-                                        opj_packet_info_t *pack_info);
+                                        opj_packet_info_t *pack_info,
+                                        opj_event_mgr_t *p_manager);
 
 /**
 @param cblk
 @param index
 @param cblksty
 @param first
 */
 static OPJ_BOOL opj_t2_init_seg(    opj_tcd_cblk_dec_t* cblk,
                                     OPJ_UINT32 index,
                                     OPJ_UINT32 cblksty,
                                     OPJ_UINT32 first);
 
 /*@}*/
 
 /*@}*/
 
 /* ----------------------------------------------------------------------- */
 
 /* #define RESTART 0x04 */
 static void opj_t2_putcommacode(opj_bio_t *bio, OPJ_INT32 n) {
         while (--n >= 0) {
                 opj_bio_write(bio, 1, 1);
         }
         opj_bio_write(bio, 0, 1);
 }
 
-OPJ_UINT32 opj_t2_getcommacode(opj_bio_t *bio) 
+static OPJ_UINT32 opj_t2_getcommacode(opj_bio_t *bio)
 {
     OPJ_UINT32 n = 0;
     while (opj_bio_read(bio, 1)) {
             ++n;
     }
     return n;
 }
 
-void opj_t2_putnumpasses(opj_bio_t *bio, OPJ_UINT32 n) {
+static void opj_t2_putnumpasses(opj_bio_t *bio, OPJ_UINT32 n) {
         if (n == 1) {
                 opj_bio_write(bio, 0, 1);
         } else if (n == 2) {
                 opj_bio_write(bio, 2, 2);
         } else if (n <= 5) {
                 opj_bio_write(bio, 0xc | (n - 3), 4);
         } else if (n <= 36) {
                 opj_bio_write(bio, 0x1e0 | (n - 6), 9);
         } else if (n <= 164) {
                 opj_bio_write(bio, 0xff80 | (n - 37), 16);
         }
 }
 
-OPJ_UINT32 opj_t2_getnumpasses(opj_bio_t *bio) {
+static OPJ_UINT32 opj_t2_getnumpasses(opj_bio_t *bio) {
         OPJ_UINT32 n;
         if (!opj_bio_read(bio, 1))
                 return 1;
         if (!opj_bio_read(bio, 1))
                 return 2;
         if ((n = opj_bio_read(bio, 2)) != 3)
                 return (3 + n);
         if ((n = opj_bio_read(bio, 5)) != 31)
                 return (6 + n);
         return (37 + opj_bio_read(bio, 7));
@@ skipping 143 matching lines @@
 }
 #define JAS_FPRINTF opj_null_jas_fprintf
 #endif
 
 OPJ_BOOL opj_t2_decode_packets( opj_t2_t *p_t2,
                                 OPJ_UINT32 p_tile_no,
                                 opj_tcd_tile_t *p_tile,
                                 OPJ_BYTE *p_src,
                                 OPJ_UINT32 * p_data_read,
                                 OPJ_UINT32 p_max_len,
-                                opj_codestream_index_t *p_cstr_index)
+                                opj_codestream_index_t *p_cstr_index,
+                                opj_event_mgr_t *p_manager)
 {
         OPJ_BYTE *l_current_data = p_src;
         opj_pi_iterator_t *l_pi = 00;
         OPJ_UINT32 pino;
         opj_image_t *l_image = p_t2->image;
         opj_cp_t *l_cp = p_t2->cp;
         opj_tcp_t *l_tcp = &(p_t2->cp->tcps[p_tile_no]);
         OPJ_UINT32 l_nb_bytes_read;
         OPJ_UINT32 l_nb_pocs = l_tcp->numpocs + 1;
         opj_pi_iterator_t *l_current_pi = 00;
@@ skipping 47 matching lines @@
                 while (opj_pi_next(l_current_pi)) {
                   JAS_FPRINTF( stderr, "packet offset=00000166 prg=%d cmptno=%02d rlvlno=%02d prcno=%03d lyrno=%02d\n\n",
                     l_current_pi->poc.prg1, l_current_pi->compno, l_current_pi->resno, l_current_pi->precno, l_current_pi->layno );
 
                         if (l_tcp->num_layers_to_decode > l_current_pi->layno
                                         && l_current_pi->resno < p_tile->comps[l_current_pi->compno].minimum_num_resolutions) {
                                 l_nb_bytes_read = 0;
 
                                 first_pass_failed[l_current_pi->compno] = OPJ_FALSE;
 
-                                if (! opj_t2_decode_packet(p_t2,p_tile,l_tcp,l_current_pi,l_current_data,&l_nb_bytes_read,p_max_len,l_pack_info)) {
+                                if (! opj_t2_decode_packet(p_t2,p_tile,l_tcp,l_current_pi,l_current_data,&l_nb_bytes_read,p_max_len,l_pack_info, p_manager)) {
                                         opj_pi_destroy(l_pi,l_nb_pocs);
                                         opj_free(first_pass_failed);
                                         return OPJ_FALSE;
                                 }
 
                                 l_img_comp = &(l_image->comps[l_current_pi->compno]);
                                 l_img_comp->resno_decoded = opj_uint_max(l_current_pi->resno, l_img_comp->resno_decoded);
                         }
                         else {
                                 l_nb_bytes_read = 0;
-                                if (! opj_t2_skip_packet(p_t2,p_tile,l_tcp,l_current_pi,l_current_data,&l_nb_bytes_read,p_max_len,l_pack_info)) {
+                                if (! opj_t2_skip_packet(p_t2,p_tile,l_tcp,l_current_pi,l_current_data,&l_nb_bytes_read,p_max_len,l_pack_info, p_manager)) {
                                         opj_pi_destroy(l_pi,l_nb_pocs);
                                         opj_free(first_pass_failed);
                                         return OPJ_FALSE;
                                 }
                         }
 
                         if (first_pass_failed[l_current_pi->compno]) {
                                 l_img_comp = &(l_image->comps[l_current_pi->compno]);
                                 if (l_img_comp->resno_decoded == 0)
                                         l_img_comp->resno_decoded = p_tile->comps[l_current_pi->compno].minimum_num_resolutions - 1;
@@ skipping 66 matching lines @@
 
         return l_t2;
 }
 
 void opj_t2_destroy(opj_t2_t *t2) {
         if(t2) {
                 opj_free(t2);
         }
 }
 
-OPJ_BOOL opj_t2_decode_packet(  opj_t2_t* p_t2,
+static OPJ_BOOL opj_t2_decode_packet(  opj_t2_t* p_t2,
                                 opj_tcd_tile_t *p_tile,
                                 opj_tcp_t *p_tcp,
                                 opj_pi_iterator_t *p_pi,
                                 OPJ_BYTE *p_src,
                                 OPJ_UINT32 * p_data_read,
                                 OPJ_UINT32 p_max_length,
-                                opj_packet_info_t *p_pack_info)
+                                opj_packet_info_t *p_pack_info,
+                                opj_event_mgr_t *p_manager)
 {
         OPJ_BOOL l_read_data;
         OPJ_UINT32 l_nb_bytes_read = 0;
         OPJ_UINT32 l_nb_total_bytes_read = 0;
 
         *p_data_read = 0;
 
-        if (! opj_t2_read_packet_header(p_t2,p_tile,p_tcp,p_pi,&l_read_data,p_src,&l_nb_bytes_read,p_max_length,p_pack_info)) {
+        if (! opj_t2_read_packet_header(p_t2,p_tile,p_tcp,p_pi,&l_read_data,p_src,&l_nb_bytes_read,p_max_length,p_pack_info, p_manager)) {
                 return OPJ_FALSE;
         }
 
         p_src += l_nb_bytes_read;
         l_nb_total_bytes_read += l_nb_bytes_read;
         p_max_length -= l_nb_bytes_read;
 
         /* we should read data for the packet */
         if (l_read_data) {
                 l_nb_bytes_read = 0;
 
-                if (! opj_t2_read_packet_data(p_t2,p_tile,p_pi,p_src,&l_nb_bytes_read,p_max_length,p_pack_info)) {
+                if (! opj_t2_read_packet_data(p_t2,p_tile,p_pi,p_src,&l_nb_bytes_read,p_max_length,p_pack_info, p_manager)) {
                         return OPJ_FALSE;
                 }
 
                 l_nb_total_bytes_read += l_nb_bytes_read;
         }
 
         *p_data_read = l_nb_total_bytes_read;
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_t2_encode_packet(  OPJ_UINT32 tileno,
+static OPJ_BOOL opj_t2_encode_packet(  OPJ_UINT32 tileno,
                                 opj_tcd_tile_t * tile,
                                 opj_tcp_t * tcp,
                                 opj_pi_iterator_t *pi,
                                 OPJ_BYTE *dest,
                                 OPJ_UINT32 * p_data_written,
                                 OPJ_UINT32 length,
                                 opj_codestream_info_t *cstr_info)
 {
         OPJ_UINT32 bandno, cblkno;
         OPJ_BYTE* c = dest;
@@ skipping 222 matching lines @@
         return OPJ_TRUE;
 }
 
 static OPJ_BOOL opj_t2_skip_packet( opj_t2_t* p_t2,
                                     opj_tcd_tile_t *p_tile,
                                     opj_tcp_t *p_tcp,
                                     opj_pi_iterator_t *p_pi,
                                     OPJ_BYTE *p_src,
                                     OPJ_UINT32 * p_data_read,
                                     OPJ_UINT32 p_max_length,
-                                    opj_packet_info_t *p_pack_info)
+                                    opj_packet_info_t *p_pack_info,
+                                    opj_event_mgr_t *p_manager)
 {
         OPJ_BOOL l_read_data;
         OPJ_UINT32 l_nb_bytes_read = 0;
         OPJ_UINT32 l_nb_total_bytes_read = 0;
 
         *p_data_read = 0;
 
-        if (! opj_t2_read_packet_header(p_t2,p_tile,p_tcp,p_pi,&l_read_data,p_src,&l_nb_bytes_read,p_max_length,p_pack_info)) {
+        if (! opj_t2_read_packet_header(p_t2,p_tile,p_tcp,p_pi,&l_read_data,p_src,&l_nb_bytes_read,p_max_length,p_pack_info, p_manager)) {
                 return OPJ_FALSE;
         }
 
         p_src += l_nb_bytes_read;
         l_nb_total_bytes_read += l_nb_bytes_read;
         p_max_length -= l_nb_bytes_read;
 
         /* we should read data for the packet */
         if (l_read_data) {
                 l_nb_bytes_read = 0;
 
-                if (! opj_t2_skip_packet_data(p_t2,p_tile,p_pi,&l_nb_bytes_read,p_max_length,p_pack_info)) {
+                if (! opj_t2_skip_packet_data(p_t2,p_tile,p_pi,&l_nb_bytes_read,p_max_length,p_pack_info, p_manager)) {
                         return OPJ_FALSE;
                 }
 
                 l_nb_total_bytes_read += l_nb_bytes_read;
         }
         *p_data_read = l_nb_total_bytes_read;
 
         return OPJ_TRUE;
 }
 
 
-OPJ_BOOL opj_t2_read_packet_header( opj_t2_t* p_t2,
+static OPJ_BOOL opj_t2_read_packet_header( opj_t2_t* p_t2,
                                     opj_tcd_tile_t *p_tile,
                                     opj_tcp_t *p_tcp,
                                     opj_pi_iterator_t *p_pi,
                                     OPJ_BOOL * p_is_data_present,
                                     OPJ_BYTE *p_src_data,
                                     OPJ_UINT32 * p_data_read,
                                     OPJ_UINT32 p_max_length,
-                                    opj_packet_info_t *p_pack_info)
+                                    opj_packet_info_t *p_pack_info,
+                                    opj_event_mgr_t *p_manager)
 
 {
         /* loop */
         OPJ_UINT32 bandno, cblkno;
         OPJ_UINT32 l_nb_code_blocks;
         OPJ_UINT32 l_remaining_length;
         OPJ_UINT32 l_header_length;
         OPJ_UINT32 * l_modified_length_ptr = 00;
         OPJ_BYTE *l_current_data = p_src_data;
         opj_cp_t *l_cp = p_t2->cp;
@@ skipping 28 matching lines @@
                         }
 
                         ++l_band;
                 }
         }
 
         /* SOP markers */
 
         if (p_tcp->csty & J2K_CP_CSTY_SOP) {
                 if (p_max_length < 6) {
-                        /* TODO opj_event_msg(p_t2->cinfo->event_mgr, EVT_WARNING, "Not enough space for expected SOP marker\n"); */
-                        fprintf(stderr, "Not enough space for expected SOP marker\n");
+                                                                                                opj_event_msg(p_manager, EVT_WARNING, "Not enough space for expected SOP marker\n");
                 } else if ((*l_current_data) != 0xff || (*(l_current_data + 1) != 0x91)) {
-                        /* TODO opj_event_msg(p_t2->cinfo->event_mgr, EVT_WARNING, "Expected SOP marker\n"); */
-                        fprintf(stderr, "Warning: expected SOP marker\n");
+                        opj_event_msg(p_manager, EVT_WARNING, "Expected SOP marker\n");
                 } else {
                         l_current_data += 6;
                 }
 
                 /** TODO : check the Nsop value */
         }
 
         /*
         When the marker PPT/PPM is used the packet header are store in PPT/PPM marker
         This part deal with this caracteristic
@@ skipping 30 matching lines @@
         JAS_FPRINTF(stderr, "present=%d \n", l_present );
         if (!l_present) {
             /* TODO MSD: no test to control the output of this function*/
                 opj_bio_inalign(l_bio);
                 l_header_data += opj_bio_numbytes(l_bio);
                 opj_bio_destroy(l_bio);
 
                 /* EPH markers */
                 if (p_tcp->csty & J2K_CP_CSTY_EPH) {
                         if ((*l_modified_length_ptr - (OPJ_UINT32)(l_header_data - *l_header_data_start)) < 2U) {
-                                fprintf(stderr, "Not enough space for expected EPH marker\n");
+                                opj_event_msg(p_manager, EVT_WARNING, "Not enough space for expected EPH marker\n");
                         } else if ((*l_header_data) != 0xff || (*(l_header_data + 1) != 0x92)) {
-                                fprintf(stderr, "Error : expected EPH marker\n");
+                                opj_event_msg(p_manager, EVT_WARNING, "Expected EPH marker\n");
                         } else {
                                 l_header_data += 2;
                         }
                 }
 
                 l_header_length = (OPJ_UINT32)(l_header_data - *l_header_data_start);
                 *l_modified_length_ptr -= l_header_length;
                 *l_header_data_start += l_header_length;
 
                 /* << INDEX */
@@ skipping 30 matching lines @@
                                 /* else one bit */
                         }
                         else {
                                 l_included = opj_bio_read(l_bio, 1);
                         }
 
                         /* if cblk not included */
                         if (!l_included) {
                                 l_cblk->numnewpasses = 0;
                                 ++l_cblk;
-        JAS_FPRINTF(stderr, "included=%d \n", l_included);
+                                JAS_FPRINTF(stderr, "included=%d \n", l_included);
                                 continue;
                         }
 
                         /* if cblk not yet included --> zero-bitplane tagtree */
                         if (!l_cblk->numsegs) {
                                 OPJ_UINT32 i = 0;
 
                                 while (!opj_tgt_decode(l_bio, l_prc->imsbtree, cblkno, (OPJ_INT32)i)) {
                                         ++i;
                                 }
@@ skipping 54 matching lines @@
                 opj_bio_destroy(l_bio);
                 return OPJ_FALSE;
         }
 
         l_header_data += opj_bio_numbytes(l_bio);
         opj_bio_destroy(l_bio);
 
         /* EPH markers */
         if (p_tcp->csty & J2K_CP_CSTY_EPH) {
                 if ((*l_modified_length_ptr - (OPJ_UINT32)(l_header_data - *l_header_data_start)) < 2U) {
-                        fprintf(stderr, "Not enough space for expected EPH marker\n");
+                        opj_event_msg(p_manager, EVT_WARNING, "Not enough space for expected EPH marker\n");
                 } else if ((*l_header_data) != 0xff || (*(l_header_data + 1) != 0x92)) {
-                        /* TODO opj_event_msg(t2->cinfo->event_mgr, EVT_ERROR, "Expected EPH marker\n"); */
-                        fprintf(stderr, "Error : expected EPH marker\n");
+                        opj_event_msg(p_manager, EVT_WARNING, "Expected EPH marker\n");
                 } else {
                         l_header_data += 2;
                 }
         }
 
         l_header_length = (OPJ_UINT32)(l_header_data - *l_header_data_start);
         JAS_FPRINTF( stderr, "hdrlen=%d \n", l_header_length );
         JAS_FPRINTF( stderr, "packet body\n");
         *l_modified_length_ptr -= l_header_length;
         *l_header_data_start += l_header_length;
 
         /* << INDEX */
         /* End of packet header position. Currently only represents the distance to start of packet
          Will be updated later by incrementing with packet start value */
         if (p_pack_info) {
                 p_pack_info->end_ph_pos = (OPJ_INT32)(l_current_data - p_src_data);
         }
         /* INDEX >> */
 
         *p_is_data_present = OPJ_TRUE;
         *p_data_read = (OPJ_UINT32)(l_current_data - p_src_data);
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_t2_read_packet_data(   opj_t2_t* p_t2,
+static OPJ_BOOL opj_t2_read_packet_data(   opj_t2_t* p_t2,
                                     opj_tcd_tile_t *p_tile,
                                     opj_pi_iterator_t *p_pi,
                                     OPJ_BYTE *p_src_data,
                                     OPJ_UINT32 * p_data_read,
                                     OPJ_UINT32 p_max_length,
-                                    opj_packet_info_t *pack_info)
+                                    opj_packet_info_t *pack_info,
+                                    opj_event_mgr_t* p_manager)
 {
         OPJ_UINT32 bandno, cblkno;
         OPJ_UINT32 l_nb_code_blocks;
         OPJ_BYTE *l_current_data = p_src_data;
         opj_tcd_band_t *l_band = 00;
         opj_tcd_cblk_dec_t* l_cblk = 00;
         opj_tcd_resolution_t* l_res = &p_tile->comps[p_pi->compno].resolutions[p_pi->resno];
 
         OPJ_ARG_NOT_USED(p_t2);
         OPJ_ARG_NOT_USED(pack_info);
@@ skipping 29 matching lines @@
 
                                 if (l_seg->numpasses == l_seg->maxpasses) {
                                         ++l_seg;
                                         ++l_cblk->numsegs;
                                 }
                         }
 
                         do {
                                 /* Check possible overflow (on l_current_data only, assumes input args already checked) then size */
                                 if ((((OPJ_SIZE_T)l_current_data + (OPJ_SIZE_T)l_seg->newlen) < (OPJ_SIZE_T)l_current_data) || (l_current_data + l_seg->newlen > p_src_data + p_max_length)) {
-                                        fprintf(stderr, "read: segment too long (%d) with max (%d) for codeblock %d (p=%d, b=%d, r=%d, c=%d)\n",
-                                                l_seg->newlen, p_max_length, cblkno, p_pi->precno, bandno, p_pi->resno, p_pi->compno);
+                                        opj_event_msg(p_manager, EVT_ERROR, "read: segment too long (%d) with max (%d) for codeblock %d (p=%d, b=%d, r=%d, c=%d)\n",
+                                                                                                                                                                                                l_seg->newlen, p_max_length, cblkno, p_pi->precno, bandno, p_pi->resno, p_pi->compno);
                                         return OPJ_FALSE;
                                 }
 
 #ifdef USE_JPWL
                         /* we need here a j2k handle to verify if making a check to
                         the validity of cblocks parameters is selected from user (-W) */
 
                                 /* let's check that we are not exceeding */
                                 if ((l_cblk->len + l_seg->newlen) > 8192) {
-                                        opj_event_msg(p_t2->cinfo, EVT_WARNING,
+                                        opj_event_msg(p_manager, EVT_WARNING,
                                                 "JPWL: segment too long (%d) for codeblock %d (p=%d, b=%d, r=%d, c=%d)\n",
                                                 l_seg->newlen, cblkno, p_pi->precno, bandno, p_pi->resno, p_pi->compno);
                                         if (!JPWL_ASSUME) {
-                                                opj_event_msg(p_t2->cinfo, EVT_ERROR, "JPWL: giving up\n");
+                                                opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n");
                                                 return OPJ_FALSE;
                                         }
                                         l_seg->newlen = 8192 - l_cblk->len;
-                                        opj_event_msg(p_t2->cinfo, EVT_WARNING, "      - truncating segment to %d\n", l_seg->newlen);
+                                        opj_event_msg(p_manager, EVT_WARNING, "      - truncating segment to %d\n", l_seg->newlen);
                                         break;
                                 };
 
 #endif /* USE_JPWL */
                                 /* Check possible overflow on size */
                                 if ((l_cblk->data_current_size + l_seg->newlen) < l_cblk->data_current_size) {
-                                        fprintf(stderr, "read: segment too long (%d) with current size (%d > %d) for codeblock %d (p=%d, b=%d, r=%d, c=%d)\n",
+                                        opj_event_msg(p_manager, EVT_ERROR, "read: segment too long (%d) with current size (%d > %d) for codeblock %d (p=%d, b=%d, r=%d, c=%d)\n",
                                                 l_seg->newlen, l_cblk->data_current_size, 0xFFFFFFFF - l_seg->newlen, cblkno, p_pi->precno, bandno, p_pi->resno, p_pi->compno);
                                         return OPJ_FALSE;
                                 }
                                 /* Check if the cblk->data have allocated enough memory */
                                 if ((l_cblk->data_current_size + l_seg->newlen) > l_cblk->data_max_size) {
                                     OPJ_BYTE* new_cblk_data = (OPJ_BYTE*) opj_realloc(l_cblk->data, l_cblk->data_current_size + l_seg->newlen);
                                     if(! new_cblk_data) {
                                         opj_free(l_cblk->data);
                                         l_cblk->data = NULL;
                                         l_cblk->data_max_size = 0;
@@ skipping 31 matching lines @@
 
                 ++l_band;
         }
 
         *(p_data_read) = (OPJ_UINT32)(l_current_data - p_src_data);
 
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_t2_skip_packet_data(   opj_t2_t* p_t2,
+static OPJ_BOOL opj_t2_skip_packet_data(   opj_t2_t* p_t2,
                                     opj_tcd_tile_t *p_tile,
                                     opj_pi_iterator_t *p_pi,
                                     OPJ_UINT32 * p_data_read,
                                     OPJ_UINT32 p_max_length,
-                                    opj_packet_info_t *pack_info)
+                                    opj_packet_info_t *pack_info,
+                                    opj_event_mgr_t *p_manager)
 {
         OPJ_UINT32 bandno, cblkno;
         OPJ_UINT32 l_nb_code_blocks;
         opj_tcd_band_t *l_band = 00;
         opj_tcd_cblk_dec_t* l_cblk = 00;
         opj_tcd_resolution_t* l_res = &p_tile->comps[p_pi->compno].resolutions[p_pi->resno];
 
         OPJ_ARG_NOT_USED(p_t2);
         OPJ_ARG_NOT_USED(pack_info);
 
@@ skipping 30 matching lines @@
 
                                 if (l_seg->numpasses == l_seg->maxpasses) {
                                         ++l_seg;
                                         ++l_cblk->numsegs;
                                 }
                         }
 
                         do {
                                 /* Check possible overflow then size */
                                 if (((*p_data_read + l_seg->newlen) < (*p_data_read)) || ((*p_data_read + l_seg->newlen) > p_max_length)) {
-                                        fprintf(stderr, "skip: segment too long (%d) with max (%d) for codeblock %d (p=%d, b=%d, r=%d, c=%d)\n",
+                                        opj_event_msg(p_manager, EVT_ERROR, "skip: segment too long (%d) with max (%d) for codeblock %d (p=%d, b=%d, r=%d, c=%d)\n",
                                                 l_seg->newlen, p_max_length, cblkno, p_pi->precno, bandno, p_pi->resno, p_pi->compno);
                                         return OPJ_FALSE;
                                 }
 
 #ifdef USE_JPWL
                         /* we need here a j2k handle to verify if making a check to
                         the validity of cblocks parameters is selected from user (-W) */
 
                                 /* let's check that we are not exceeding */
                                 if ((l_cblk->len + l_seg->newlen) > 8192) {
-                                        opj_event_msg(p_t2->cinfo, EVT_WARNING,
+                                        opj_event_msg(p_manager, EVT_WARNING,
                                                 "JPWL: segment too long (%d) for codeblock %d (p=%d, b=%d, r=%d, c=%d)\n",
                                                 l_seg->newlen, cblkno, p_pi->precno, bandno, p_pi->resno, p_pi->compno);
                                         if (!JPWL_ASSUME) {
-                                                opj_event_msg(p_t2->cinfo, EVT_ERROR, "JPWL: giving up\n");
+                                                opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n");
                                                 return -999;
                                         }
                                         l_seg->newlen = 8192 - l_cblk->len;
-                                        opj_event_msg(p_t2->cinfo, EVT_WARNING, "      - truncating segment to %d\n", l_seg->newlen);
+                                        opj_event_msg(p_manager, EVT_WARNING, "      - truncating segment to %d\n", l_seg->newlen);
                                         break;
                                 };
 
 #endif /* USE_JPWL */
                                         JAS_FPRINTF(stderr, "p_data_read (%d) newlen (%d) \n", *p_data_read, l_seg->newlen );
                                 *(p_data_read) += l_seg->newlen;
 
                                 l_seg->numpasses += l_seg->numnewpasses;
                                 l_cblk->numnewpasses -= l_seg->numnewpasses;
                                 if (l_cblk->numnewpasses > 0)
@@ skipping 47 matching lines @@
                         seg->maxpasses = 10;
                 } else {
                         seg->maxpasses = (((seg - 1)->maxpasses == 1) || ((seg - 1)->maxpasses == 10)) ? 2 : 1;
                 }
         } else {
                 seg->maxpasses = 109;
         }
 
         return OPJ_TRUE;
 }