Merge to M46: upgrade openjpeg to commit# cf352af

third_party/libopenjpeg20/j2k.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 33 matching lines @@
 
 /** @defgroup J2K J2K - JPEG-2000 codestream reader/writer */
 /*@{*/
 
 /** @name Local static functions */
 /*@{*/
 
 /**
  * Sets up the procedures to do on reading header. Developpers wanting to extend the library can add their own reading procedures.
  */
-static void opj_j2k_setup_header_reading (opj_j2k_t *p_j2k);
+static OPJ_BOOL opj_j2k_setup_header_reading (opj_j2k_t *p_j2k, opj_event_mgr_t * p_manager);
 
 /**
  * The read header procedure.
  */
 static OPJ_BOOL opj_j2k_read_header_procedure(  opj_j2k_t *p_j2k,
                                                 opj_stream_private_t *p_stream,
                                                 opj_event_mgr_t * p_manager);
 
 /**
  * The default encoding validation procedure without any extension.
@@ skipping 18 matching lines @@
  * @return true if the parameters are correct.
  */
 static OPJ_BOOL opj_j2k_decoding_validation (   opj_j2k_t * p_j2k,
                                                 opj_stream_private_t *p_stream,
                                                 opj_event_mgr_t * p_manager );
 
 /**
  * Sets up the validation ,i.e. adds the procedures to lauch to make sure the codec parameters
  * are valid. Developpers wanting to extend the library can add their own validation procedures.
  */
-static void opj_j2k_setup_encoding_validation (opj_j2k_t *p_j2k);
+static OPJ_BOOL opj_j2k_setup_encoding_validation (opj_j2k_t *p_j2k, opj_event_mgr_t * p_manager);
 
 /**
  * Sets up the validation ,i.e. adds the procedures to lauch to make sure the codec parameters
  * are valid. Developpers wanting to extend the library can add their own validation procedures.
  */
-static void opj_j2k_setup_decoding_validation (opj_j2k_t *p_j2k);
+static OPJ_BOOL opj_j2k_setup_decoding_validation (opj_j2k_t *p_j2k, opj_event_mgr_t * p_manager);
 
 /**
  * Sets up the validation ,i.e. adds the procedures to lauch to make sure the codec parameters
  * are valid. Developpers wanting to extend the library can add their own validation procedures.
  */
-static void opj_j2k_setup_end_compress (opj_j2k_t *p_j2k);
+static OPJ_BOOL opj_j2k_setup_end_compress (opj_j2k_t *p_j2k, opj_event_mgr_t * p_manager);
 
 /**
  * The mct encoding validation procedure.
  *
  * @param       p_j2k                   the jpeg2000 codec to validate.
  * @param       p_stream                                the input stream to validate.
  * @param       p_manager               the user event manager.
  *
  * @return true if the parameters are correct.
  */
@@ skipping 237 matching lines @@
 static void opj_j2k_get_tile_data (opj_tcd_t * p_tcd, OPJ_BYTE * p_data);
 
 static OPJ_BOOL opj_j2k_post_write_tile (opj_j2k_t * p_j2k,
                                                                              opj_stream_private_t *p_stream,
                                                                              opj_event_mgr_t * p_manager );
 
 /**
  * Sets up the procedures to do on writing header.
  * Developers wanting to extend the library can add their own writing procedures.
  */
-static void opj_j2k_setup_header_writing (opj_j2k_t *p_j2k);
+static OPJ_BOOL opj_j2k_setup_header_writing (opj_j2k_t *p_j2k, opj_event_mgr_t * p_manager);
 
 static OPJ_BOOL opj_j2k_write_first_tile_part(  opj_j2k_t *p_j2k,
                                                                                             OPJ_BYTE * p_data,
                                                                                             OPJ_UINT32 * p_data_written,
                                                                                             OPJ_UINT32 p_total_data_size,
                                                                                             opj_stream_private_t *p_stream,
                                                                                             struct opj_event_mgr * p_manager );
 
 static OPJ_BOOL opj_j2k_write_all_tile_parts(   opj_j2k_t *p_j2k,
                                                                                             OPJ_BYTE * p_data,
@@ skipping 337 matching lines @@
  * @param       p_header_data   the data contained in the PLT box.
  * @param       p_j2k                   the jpeg2000 codec.
  * @param       p_header_size   the size of the data contained in the PLT marker.
  * @param       p_manager               the user event manager.
 */
 static OPJ_BOOL opj_j2k_read_plt (  opj_j2k_t *p_j2k,
                                     OPJ_BYTE * p_header_data,
                                     OPJ_UINT32 p_header_size,
                                     opj_event_mgr_t * p_manager );
 
-#if 0
 /**
- * Reads a PPM marker (Packed packet headers, main header)
+ * Reads a PPM marker (Packed headers, main header)
  *
  * @param       p_header_data   the data contained in the POC box.
  * @param       p_j2k                   the jpeg2000 codec.
  * @param       p_header_size   the size of the data contained in the POC marker.
  * @param       p_manager               the user event manager.
-*/
-static OPJ_BOOL j2k_read_ppm_v2 (
-                                                opj_j2k_t *p_j2k,
-                                                OPJ_BYTE * p_header_data,
-                                                OPJ_UINT32 p_header_size,
-                                                struct opj_event_mgr * p_manager
-                                        );
-#endif
+ */
 
-static OPJ_BOOL j2k_read_ppm_v3 (
-                                                opj_j2k_t *p_j2k,
-                                                OPJ_BYTE * p_header_data,
-                                                OPJ_UINT32 p_header_size,
-                                                opj_event_mgr_t * p_manager );
+static OPJ_BOOL opj_j2k_read_ppm (
+                                                                                                                                                 opj_j2k_t *p_j2k,
+                                                                                                                                                 OPJ_BYTE * p_header_data,
+                                                                                                                                                 OPJ_UINT32 p_header_size,
+                                                                                                                                                 opj_event_mgr_t * p_manager );
+
+/**
+ * Merges all PPM markers read (Packed headers, main header)
+ *
+ * @param       p_cp      main coding parameters.
+ * @param       p_manager the user event manager.
+ */
+static OPJ_BOOL opj_j2k_merge_ppm ( opj_cp_t *p_cp, opj_event_mgr_t * p_manager );
 
 /**
  * Reads a PPT marker (Packed packet headers, tile-part header)
  *
  * @param       p_header_data   the data contained in the PPT box.
  * @param       p_j2k                   the jpeg2000 codec.
  * @param       p_header_size   the size of the data contained in the PPT marker.
  * @param       p_manager               the user event manager.
 */
 static OPJ_BOOL opj_j2k_read_ppt (  opj_j2k_t *p_j2k,
                                     OPJ_BYTE * p_header_data,
                                     OPJ_UINT32 p_header_size,
                                     opj_event_mgr_t * p_manager );
+
+/**
+ * Merges all PPT markers read (Packed headers, tile-part header)
+ *
+ * @param       p_tcp   the tile.
+ * @param       p_manager               the user event manager.
+ */
+static OPJ_BOOL opj_j2k_merge_ppt (  opj_tcp_t *p_tcp,
+                                                                                                                                           opj_event_mgr_t * p_manager );
+
+
 /**
  * Writes the TLM marker (Tile Length Marker)
  *
  * @param       p_stream                                the stream to write data to.
  * @param       p_j2k                           J2K codec.
  * @param       p_manager               the user event manager.
 */
 static OPJ_BOOL opj_j2k_write_tlm(      opj_j2k_t *p_j2k,
                                                                         opj_stream_private_t *p_stream,
                                                                         opj_event_mgr_t * p_manager );
 
 /**
  * Writes the SOT marker (Start of tile-part)
  *
  * @param       p_j2k            J2K codec.
  * @param       p_data           FIXME DOC
  * @param       p_data_written   FIXME DOC
  * @param       p_stream         the stream to write data to.
  * @param       p_manager        the user event manager.
 */
 static OPJ_BOOL opj_j2k_write_sot(      opj_j2k_t *p_j2k,
                                                                         OPJ_BYTE * p_data,
                                                                         OPJ_UINT32 * p_data_written,
                                                                         const opj_stream_private_t *p_stream,
                                                                         opj_event_mgr_t * p_manager );
 
 /**
- * Reads a PPT marker (Packed packet headers, tile-part header)
+ * Reads values from a SOT marker (Start of tile-part)
  *
- * @param       p_header_data   the data contained in the PPT box.
- * @param       p_j2k                   the jpeg2000 codec.
+ * the j2k decoder state is not affected. No side effects, no checks except for p_header_size.
+ *
+ * @param       p_header_data   the data contained in the SOT marker.
+ * @param       p_header_size   the size of the data contained in the SOT marker.
+ * @param       p_tile_no       Isot.
+ * @param       p_tot_len       Psot.
+ * @param       p_current_part  TPsot.
+ * @param       p_num_parts     TNsot.
+ * @param       p_manager       the user event manager.
+ */
+static OPJ_BOOL opj_j2k_get_sot_values(OPJ_BYTE *  p_header_data,
+                                                                                                                                                         OPJ_UINT32  p_header_size,
+                                                                                                                                                         OPJ_UINT32* p_tile_no,
+                                                                                                                                                         OPJ_UINT32* p_tot_len,
+                                                                                                                                                         OPJ_UINT32* p_current_part,
+                                                                                                                                                         OPJ_UINT32* p_num_parts,
+                                                                                                                                                         opj_event_mgr_t * p_manager );
+/**
+ * Reads a SOT marker (Start of tile-part)
+ *
+ * @param       p_header_data   the data contained in the SOT marker.
+ * @param       p_j2k           the jpeg2000 codec.
  * @param       p_header_size   the size of the data contained in the PPT marker.
- * @param       p_manager               the user event manager.
+ * @param       p_manager       the user event manager.
 */
 static OPJ_BOOL opj_j2k_read_sot (  opj_j2k_t *p_j2k,
                                     OPJ_BYTE * p_header_data,
                                     OPJ_UINT32 p_header_size,
                                     opj_event_mgr_t * p_manager );
 /**
  * Writes the SOD marker (Start of data)
  *
  * @param       p_j2k               J2K codec.
  * @param       p_tile_coder        FIXME DOC
@@ skipping 15 matching lines @@
  * Reads a SOD marker (Start Of Data)
  *
  * @param       p_j2k                   the jpeg2000 codec.
  * @param       p_stream                FIXME DOC
  * @param       p_manager               the user event manager.
 */
 static OPJ_BOOL opj_j2k_read_sod(   opj_j2k_t *p_j2k,
                                     opj_stream_private_t *p_stream,
                                     opj_event_mgr_t * p_manager );
 
-void opj_j2k_update_tlm (opj_j2k_t * p_j2k, OPJ_UINT32 p_tile_part_size )
+static void opj_j2k_update_tlm (opj_j2k_t * p_j2k, OPJ_UINT32 p_tile_part_size )
 {
         opj_write_bytes(p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current,p_j2k->m_current_tile_number,1);            /* PSOT */
         ++p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current;
 
         opj_write_bytes(p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current,p_tile_part_size,4);                                        /* PSOT */
         p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current += 4;
 }
 
 /**
  * Writes the RGN marker (Region Of Interest)
@@ skipping 337 matching lines @@
 static OPJ_FLOAT32 opj_j2k_get_tp_stride (opj_tcp_t * p_tcp);
 
 static OPJ_FLOAT32 opj_j2k_get_default_stride (opj_tcp_t * p_tcp);
 
 static int opj_j2k_initialise_4K_poc(opj_poc_t *POC, int numres);
 
 static void opj_j2k_set_cinema_parameters(opj_cparameters_t *parameters, opj_image_t *image, opj_event_mgr_t *p_manager);
 
 static OPJ_BOOL opj_j2k_is_cinema_compliant(opj_image_t *image, OPJ_UINT16 rsiz, opj_event_mgr_t *p_manager);
 
+/**
+ * Checks for invalid number of tile-parts in SOT marker (TPsot==TNsot). See issue 254.
+ *
+ * @param       p_stream            the stream to read data from.
+ * @param       tile_no             tile number we're looking for.
+ * @param       p_correction_needed output value. if true, non conformant codestream needs TNsot correction.
+ * @param       p_manager       the user event manager.
+ *
+ * @return true if the function was successful, false else.
+ */
+static OPJ_BOOL opj_j2k_need_nb_tile_parts_correction(opj_stream_private_t *p_stream, OPJ_UINT32 tile_no, OPJ_BOOL* p_correction_needed, opj_event_mgr_t * p_manager );
+
 /*@}*/
 
 /*@}*/
 
 /* ----------------------------------------------------------------------- */
 typedef struct j2k_prog_order{
         OPJ_PROG_ORDER enum_prog;
         char str_prog[5];
 }j2k_prog_order_t;
 
-j2k_prog_order_t j2k_prog_order_list[] = {
+static j2k_prog_order_t j2k_prog_order_list[] = {
         {OPJ_CPRL, "CPRL"},
         {OPJ_LRCP, "LRCP"},
         {OPJ_PCRL, "PCRL"},
         {OPJ_RLCP, "RLCP"},
         {OPJ_RPCL, "RPCL"},
         {(OPJ_PROG_ORDER)-1, ""}
 };
 
 /**
  * FIXME DOC
  */
 static const OPJ_UINT32 MCT_ELEMENT_SIZE [] =
 {
         2,
         4,
         4,
         8
 };
 
 typedef void (* opj_j2k_mct_function) (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
 
-const opj_j2k_mct_function j2k_mct_read_functions_to_float [] =
+static const opj_j2k_mct_function j2k_mct_read_functions_to_float [] =
 {
         opj_j2k_read_int16_to_float,
         opj_j2k_read_int32_to_float,
         opj_j2k_read_float32_to_float,
         opj_j2k_read_float64_to_float
 };
 
-const opj_j2k_mct_function j2k_mct_read_functions_to_int32 [] =
+static const opj_j2k_mct_function j2k_mct_read_functions_to_int32 [] =
 {
         opj_j2k_read_int16_to_int32,
         opj_j2k_read_int32_to_int32,
         opj_j2k_read_float32_to_int32,
         opj_j2k_read_float64_to_int32
 };
 
-const opj_j2k_mct_function j2k_mct_write_functions_from_float [] =
+static const opj_j2k_mct_function j2k_mct_write_functions_from_float [] =
 {
         opj_j2k_write_float_to_int16,
         opj_j2k_write_float_to_int32,
         opj_j2k_write_float_to_float,
         opj_j2k_write_float_to_float64
 };
 
 typedef struct opj_dec_memory_marker_handler
 {
         /** marker value */
         OPJ_UINT32 id;
         /** value of the state when the marker can appear */
         OPJ_UINT32 states;
         /** action linked to the marker */
         OPJ_BOOL (*handler) (   opj_j2k_t *p_j2k,
                             OPJ_BYTE * p_header_data,
                             OPJ_UINT32 p_header_size,
                             opj_event_mgr_t * p_manager );
 }
 opj_dec_memory_marker_handler_t;
 
-const opj_dec_memory_marker_handler_t j2k_memory_marker_handler_tab [] =
+static const opj_dec_memory_marker_handler_t j2k_memory_marker_handler_tab [] =
 {
   {J2K_MS_SOT, J2K_STATE_MH | J2K_STATE_TPHSOT, opj_j2k_read_sot},
   {J2K_MS_COD, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_cod},
   {J2K_MS_COC, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_coc},
   {J2K_MS_RGN, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_rgn},
   {J2K_MS_QCD, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_qcd},
   {J2K_MS_QCC, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_qcc},
   {J2K_MS_POC, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_poc},
   {J2K_MS_SIZ, J2K_STATE_MHSIZ, opj_j2k_read_siz},
   {J2K_MS_TLM, J2K_STATE_MH, opj_j2k_read_tlm},
   {J2K_MS_PLM, J2K_STATE_MH, opj_j2k_read_plm},
   {J2K_MS_PLT, J2K_STATE_TPH, opj_j2k_read_plt},
-  {J2K_MS_PPM, J2K_STATE_MH, j2k_read_ppm_v3},
+  {J2K_MS_PPM, J2K_STATE_MH, opj_j2k_read_ppm},
   {J2K_MS_PPT, J2K_STATE_TPH, opj_j2k_read_ppt},
   {J2K_MS_SOP, 0, 0},
   {J2K_MS_CRG, J2K_STATE_MH, opj_j2k_read_crg},
   {J2K_MS_COM, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_com},
   {J2K_MS_MCT, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_mct},
   {J2K_MS_CBD, J2K_STATE_MH , opj_j2k_read_cbd},
   {J2K_MS_MCC, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_mcc},
   {J2K_MS_MCO, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_mco},
 #ifdef USE_JPWL
 #ifdef TODO_MS /* remove these functions which are not commpatible with the v2 API */
   {J2K_MS_EPC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_epc},
   {J2K_MS_EPB, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_epb},
   {J2K_MS_ESD, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_esd},
   {J2K_MS_RED, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_red},
 #endif
 #endif /* USE_JPWL */
 #ifdef USE_JPSEC
   {J2K_MS_SEC, J2K_DEC_STATE_MH, j2k_read_sec},
   {J2K_MS_INSEC, 0, j2k_read_insec}
 #endif /* USE_JPSEC */
   {J2K_MS_UNK, J2K_STATE_MH | J2K_STATE_TPH, 0}/*opj_j2k_read_unk is directly used*/
 };
 
-void  opj_j2k_read_int16_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
+static void  opj_j2k_read_int16_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
 {
         OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
         OPJ_FLOAT32 * l_dest_data = (OPJ_FLOAT32 *) p_dest_data;
         OPJ_UINT32 i;
         OPJ_UINT32 l_temp;
 
         for (i=0;i<p_nb_elem;++i) {
                 opj_read_bytes(l_src_data,&l_temp,2);
 
                 l_src_data+=sizeof(OPJ_INT16);
 
                 *(l_dest_data++) = (OPJ_FLOAT32) l_temp;
         }
 }
 
-void  opj_j2k_read_int32_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
+static void  opj_j2k_read_int32_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
 {
         OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
         OPJ_FLOAT32 * l_dest_data = (OPJ_FLOAT32 *) p_dest_data;
         OPJ_UINT32 i;
         OPJ_UINT32 l_temp;
 
         for (i=0;i<p_nb_elem;++i) {
                 opj_read_bytes(l_src_data,&l_temp,4);
 
                 l_src_data+=sizeof(OPJ_INT32);
 
                 *(l_dest_data++) = (OPJ_FLOAT32) l_temp;
         }
 }
 
-void  opj_j2k_read_float32_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
+static void  opj_j2k_read_float32_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
 {
         OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
         OPJ_FLOAT32 * l_dest_data = (OPJ_FLOAT32 *) p_dest_data;
         OPJ_UINT32 i;
         OPJ_FLOAT32 l_temp;
 
         for (i=0;i<p_nb_elem;++i) {
                 opj_read_float(l_src_data,&l_temp);
 
                 l_src_data+=sizeof(OPJ_FLOAT32);
 
                 *(l_dest_data++) = l_temp;
         }
 }
 
-void  opj_j2k_read_float64_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
+static void  opj_j2k_read_float64_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
 {
         OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
         OPJ_FLOAT32 * l_dest_data = (OPJ_FLOAT32 *) p_dest_data;
         OPJ_UINT32 i;
         OPJ_FLOAT64 l_temp;
 
         for (i=0;i<p_nb_elem;++i) {
                 opj_read_double(l_src_data,&l_temp);
 
                 l_src_data+=sizeof(OPJ_FLOAT64);
 
                 *(l_dest_data++) = (OPJ_FLOAT32) l_temp;
         }
 }
 
-void  opj_j2k_read_int16_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
+static void  opj_j2k_read_int16_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
 {
         OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
         OPJ_INT32 * l_dest_data = (OPJ_INT32 *) p_dest_data;
         OPJ_UINT32 i;
         OPJ_UINT32 l_temp;
 
         for (i=0;i<p_nb_elem;++i) {
                 opj_read_bytes(l_src_data,&l_temp,2);
 
                 l_src_data+=sizeof(OPJ_INT16);
 
                 *(l_dest_data++) = (OPJ_INT32) l_temp;
         }
 }
 
-void  opj_j2k_read_int32_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
+static void  opj_j2k_read_int32_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
 {
         OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
         OPJ_INT32 * l_dest_data = (OPJ_INT32 *) p_dest_data;
         OPJ_UINT32 i;
         OPJ_UINT32 l_temp;
 
         for (i=0;i<p_nb_elem;++i) {
                 opj_read_bytes(l_src_data,&l_temp,4);
 
                 l_src_data+=sizeof(OPJ_INT32);
 
                 *(l_dest_data++) = (OPJ_INT32) l_temp;
         }
 }
 
-void  opj_j2k_read_float32_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
+static void  opj_j2k_read_float32_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
 {
         OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
         OPJ_INT32 * l_dest_data = (OPJ_INT32 *) p_dest_data;
         OPJ_UINT32 i;
         OPJ_FLOAT32 l_temp;
 
         for (i=0;i<p_nb_elem;++i) {
                 opj_read_float(l_src_data,&l_temp);
 
                 l_src_data+=sizeof(OPJ_FLOAT32);
 
                 *(l_dest_data++) = (OPJ_INT32) l_temp;
         }
 }
 
-void  opj_j2k_read_float64_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
+static void  opj_j2k_read_float64_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
 {
         OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
         OPJ_INT32 * l_dest_data = (OPJ_INT32 *) p_dest_data;
         OPJ_UINT32 i;
         OPJ_FLOAT64 l_temp;
 
         for (i=0;i<p_nb_elem;++i) {
                 opj_read_double(l_src_data,&l_temp);
 
                 l_src_data+=sizeof(OPJ_FLOAT64);
 
                 *(l_dest_data++) = (OPJ_INT32) l_temp;
         }
 }
 
-void  opj_j2k_write_float_to_int16 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
+static void  opj_j2k_write_float_to_int16 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
 {
         OPJ_BYTE * l_dest_data = (OPJ_BYTE *) p_dest_data;
         OPJ_FLOAT32 * l_src_data = (OPJ_FLOAT32 *) p_src_data;
         OPJ_UINT32 i;
         OPJ_UINT32 l_temp;
 
         for (i=0;i<p_nb_elem;++i) {
                 l_temp = (OPJ_UINT32) *(l_src_data++);
 
                 opj_write_bytes(l_dest_data,l_temp,sizeof(OPJ_INT16));
 
                 l_dest_data+=sizeof(OPJ_INT16);
         }
 }
 
-void opj_j2k_write_float_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
+static void opj_j2k_write_float_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
 {
         OPJ_BYTE * l_dest_data = (OPJ_BYTE *) p_dest_data;
         OPJ_FLOAT32 * l_src_data = (OPJ_FLOAT32 *) p_src_data;
         OPJ_UINT32 i;
         OPJ_UINT32 l_temp;
 
         for (i=0;i<p_nb_elem;++i) {
                 l_temp = (OPJ_UINT32) *(l_src_data++);
 
                 opj_write_bytes(l_dest_data,l_temp,sizeof(OPJ_INT32));
 
                 l_dest_data+=sizeof(OPJ_INT32);
         }
 }
 
-void  opj_j2k_write_float_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
+static void  opj_j2k_write_float_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
 {
         OPJ_BYTE * l_dest_data = (OPJ_BYTE *) p_dest_data;
         OPJ_FLOAT32 * l_src_data = (OPJ_FLOAT32 *) p_src_data;
         OPJ_UINT32 i;
         OPJ_FLOAT32 l_temp;
 
         for (i=0;i<p_nb_elem;++i) {
                 l_temp = (OPJ_FLOAT32) *(l_src_data++);
 
                 opj_write_float(l_dest_data,l_temp);
 
                 l_dest_data+=sizeof(OPJ_FLOAT32);
         }
 }
 
-void  opj_j2k_write_float_to_float64 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
+static void  opj_j2k_write_float_to_float64 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
 {
         OPJ_BYTE * l_dest_data = (OPJ_BYTE *) p_dest_data;
         OPJ_FLOAT32 * l_src_data = (OPJ_FLOAT32 *) p_src_data;
         OPJ_UINT32 i;
         OPJ_FLOAT64 l_temp;
 
         for (i=0;i<p_nb_elem;++i) {
                 l_temp = (OPJ_FLOAT64) *(l_src_data++);
 
                 opj_write_double(l_dest_data,l_temp);
 
                 l_dest_data+=sizeof(OPJ_FLOAT64);
         }
 }
 
 char *opj_j2k_convert_progression_order(OPJ_PROG_ORDER prg_order){
         j2k_prog_order_t *po;
         for(po = j2k_prog_order_list; po->enum_prog != -1; po++ ){
                 if(po->enum_prog == prg_order){
                         return po->str_prog;
                 }
         }
         return po->str_prog;
 }
 
-OPJ_BOOL opj_j2k_check_poc_val( const opj_poc_t *p_pocs,
+static OPJ_BOOL opj_j2k_check_poc_val( const opj_poc_t *p_pocs,
                                                         OPJ_UINT32 p_nb_pocs,
                                                         OPJ_UINT32 p_nb_resolutions,
                                                         OPJ_UINT32 p_num_comps,
                                                         OPJ_UINT32 p_num_layers,
                                                         opj_event_mgr_t * p_manager)
 {
         OPJ_UINT32* packet_array;
         OPJ_UINT32 index , resno, compno, layno;
         OPJ_UINT32 i;
         OPJ_UINT32 step_c = 1;
@@ skipping 83 matching lines @@
                 opj_event_msg(p_manager , EVT_ERROR, "Missing packets possible loss of data\n");
         }
 
         opj_free(packet_array);
 
         return !loss;
 }
 
 /* ----------------------------------------------------------------------- */
 
-OPJ_UINT32 opj_j2k_get_num_tp(opj_cp_t *cp, OPJ_UINT32 pino, OPJ_UINT32 tileno)
+static OPJ_UINT32 opj_j2k_get_num_tp(opj_cp_t *cp, OPJ_UINT32 pino, OPJ_UINT32 tileno)
 {
         const OPJ_CHAR *prog = 00;
         OPJ_INT32 i;
         OPJ_UINT32 tpnum = 1;
         opj_tcp_t *tcp = 00;
         opj_poc_t * l_current_poc = 00;
 
         /*  preconditions */
         assert(tileno < (cp->tw * cp->th));
         assert(pino < (cp->tcps[tileno].numpocs + 1));
@@ skipping 37 matching lines @@
                         }
                 }
         }
         else {
                 tpnum=1;
         }
 
         return tpnum;
 }
 
-OPJ_BOOL opj_j2k_calculate_tp(  opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_calculate_tp(  opj_j2k_t *p_j2k,
                                                         opj_cp_t *cp,
                                                         OPJ_UINT32 * p_nb_tiles,
                                                         opj_image_t *image,
                                                         opj_event_mgr_t * p_manager
                                 )
 {
         OPJ_UINT32 pino,tileno;
         OPJ_UINT32 l_nb_tiles;
         opj_tcp_t *tcp;
 
@@ skipping 57 matching lines @@
                         }
                         tcp->m_nb_tile_parts = cur_totnum_tp;
 
                         ++tcp;
                 }
         }
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_write_soc(     opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_write_soc(     opj_j2k_t *p_j2k,
                                                 opj_stream_private_t *p_stream,
                                                     opj_event_mgr_t * p_manager )
 {
         /* 2 bytes will be written */
         OPJ_BYTE * l_start_stream = 00;
 
         /* preconditions */
         assert(p_stream != 00);
         assert(p_j2k != 00);
         assert(p_manager != 00);
@@ skipping 57 matching lines @@
         opj_event_msg(p_manager, EVT_INFO, "Start to read j2k main header (%d).\n", p_j2k->cstr_index->main_head_start);
 
         /* Add the marker to the codestream index*/
         if (OPJ_FALSE == opj_j2k_add_mhmarker(p_j2k->cstr_index, J2K_MS_SOC, p_j2k->cstr_index->main_head_start, 2)) {
                 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to add mh marker\n");
                 return OPJ_FALSE;
         }
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_write_siz(     opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_write_siz(     opj_j2k_t *p_j2k,
                                                         opj_stream_private_t *p_stream,
                                                         opj_event_mgr_t * p_manager )
 {
         OPJ_UINT32 i;
         OPJ_UINT32 l_size_len;
         OPJ_BYTE * l_current_ptr;
         opj_image_t * l_image = 00;
         opj_cp_t *cp = 00;
         opj_image_comp_t * l_img_comp = 00;
 
@@ skipping 172 matching lines @@
                 return OPJ_FALSE;
         }
 
         /* testcase 1610.pdf.SIGSEGV.59c.681 */
         if (((OPJ_UINT64)l_image->x1) * ((OPJ_UINT64)l_image->y1) != (l_image->x1 * l_image->y1)) {
                 opj_event_msg(p_manager, EVT_ERROR, "Prevent buffer overflow (x1: %d, y1: %d)\n", l_image->x1, l_image->y1);
                 return OPJ_FALSE;
         }
 
         /* testcase issue427-illegal-tile-offset.jp2 */
-        l_tx1 = l_cp->tx0 + l_cp->tdx;
-        if (l_tx1 < l_cp->tx0) { /* manage overflow */
-                l_tx1 = 0xFFFFFFFFU;
-        }
-        l_ty1 = l_cp->ty0 + l_cp->tdy;
-        if (l_ty1 < l_cp->ty0) { /* manage overflow */
-                l_ty1 = 0xFFFFFFFFU;
-        }
+        l_tx1 = opj_uint_adds(l_cp->tx0, l_cp->tdx); /* manage overflow */
+        l_ty1 = opj_uint_adds(l_cp->ty0, l_cp->tdy); /* manage overflow */
         if ((l_cp->tx0 > l_image->x0) || (l_cp->ty0 > l_image->y0) || (l_tx1 <= l_image->x0) || (l_ty1 <= l_image->y0) ) {
                 opj_event_msg(p_manager, EVT_ERROR, "Error with SIZ marker: illegal tile offset\n");
                 return OPJ_FALSE;
         }
 
 #ifdef USE_JPWL
         if (l_cp->correct) {
                 /* if JPWL is on, we check whether TX errors have damaged
                   too much the SIZ parameters */
                 if (!(l_image->x1 * l_image->y1)) {
@@ skipping 227 matching lines @@
 
                 ++l_current_tile_param;
         }
 
         p_j2k->m_specific_param.m_decoder.m_state =  J2K_STATE_MH; /* FIXME J2K_DEC_STATE_MH; */
         opj_image_comp_header_update(l_image,l_cp);
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_write_com(     opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_write_com(     opj_j2k_t *p_j2k,
                                                         opj_stream_private_t *p_stream,
                                                         opj_event_mgr_t * p_manager
                             )
 {
         OPJ_UINT32 l_comment_size;
         OPJ_UINT32 l_total_com_size;
         const OPJ_CHAR *l_comment;
         OPJ_BYTE * l_current_ptr = 00;
 
         /* preconditions */
@@ skipping 53 matching lines @@
 {
         /* preconditions */
         assert(p_j2k != 00);
         assert(p_manager != 00);
         assert(p_header_data != 00);
   (void)p_header_size;
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_write_cod(     opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_write_cod(     opj_j2k_t *p_j2k,
                                                         opj_stream_private_t *p_stream,
                                                         opj_event_mgr_t * p_manager )
 {
         opj_cp_t *l_cp = 00;
         opj_tcp_t *l_tcp = 00;
         OPJ_UINT32 l_code_size,l_remaining_size;
         OPJ_BYTE * l_current_data = 00;
 
         /* preconditions */
         assert(p_j2k != 00);
@@ skipping 165 matching lines @@
                 for     (i = 0; i < l_image->numcomps; ++i) {
                         p_j2k->cstr_info->numdecompos[i] = l_tcp->tccps[i].numresolutions - 1;
                 }
         }
 #endif
 
         return OPJ_TRUE;
 }
 
 #if 0
-OPJ_BOOL opj_j2k_write_coc( opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_write_coc( opj_j2k_t *p_j2k,
                                                 OPJ_UINT32 p_comp_no,
                                                 opj_stream_private_t *p_stream,
                                                 opj_event_mgr_t * p_manager )
 {
         OPJ_UINT32 l_coc_size,l_remaining_size;
         OPJ_UINT32 l_comp_room;
 
         /* preconditions */
         assert(p_j2k != 00);
         assert(p_manager != 00);
@@ skipping 26 matching lines @@
 
         if (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_coc_size,p_manager) != l_coc_size) {
                 return OPJ_FALSE;
         }
 
         return OPJ_TRUE;
 }
 #endif
 
 #if 0
-void opj_j2k_write_coc_in_memory(   opj_j2k_t *p_j2k,
+static void opj_j2k_write_coc_in_memory(   opj_j2k_t *p_j2k,
                                                 OPJ_UINT32 p_comp_no,
                                                 OPJ_BYTE * p_data,
                                                 OPJ_UINT32 * p_data_written,
                                                 opj_event_mgr_t * p_manager
                                     )
 {
         opj_cp_t *l_cp = 00;
         opj_tcp_t *l_tcp = 00;
         OPJ_UINT32 l_coc_size,l_remaining_size;
         OPJ_BYTE * l_current_data = 00;
@@ skipping 25 matching lines @@
 
         opj_write_bytes(l_current_data, l_tcp->tccps[p_comp_no].csty, 1);               /* Scoc */
         ++l_current_data;
 
         l_remaining_size -= (5 + l_comp_room);
         opj_j2k_write_SPCod_SPCoc(p_j2k,p_j2k->m_current_tile_number,0,l_current_data,&l_remaining_size,p_manager);
         * p_data_written = l_coc_size;
 }
 #endif
 
-OPJ_UINT32 opj_j2k_get_max_coc_size(opj_j2k_t *p_j2k)
+static OPJ_UINT32 opj_j2k_get_max_coc_size(opj_j2k_t *p_j2k)
 {
         OPJ_UINT32 i,j;
         OPJ_UINT32 l_nb_comp;
         OPJ_UINT32 l_nb_tiles;
         OPJ_UINT32 l_max = 0;
 
         /* preconditions */
 
         l_nb_tiles = p_j2k->m_cp.tw * p_j2k->m_cp.th ;
         l_nb_comp = p_j2k->m_private_image->numcomps;
@@ skipping 61 matching lines @@
                 return OPJ_FALSE;
         }
 
         if (p_header_size != 0) {
                 opj_event_msg(p_manager, EVT_ERROR, "Error reading COC marker\n");
                 return OPJ_FALSE;
         }
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_write_qcd(     opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_write_qcd(     opj_j2k_t *p_j2k,
                                                         opj_stream_private_t *p_stream,
                                                         opj_event_mgr_t * p_manager
                             )
 {
         OPJ_UINT32 l_qcd_size,l_remaining_size;
         OPJ_BYTE * l_current_data = 00;
 
         /* preconditions */
         assert(p_j2k != 00);
         assert(p_manager != 00);
@@ skipping 70 matching lines @@
                 return OPJ_FALSE;
         }
 
         /* Apply the quantization parameters to other components of the current tile or the m_default_tcp */
         opj_j2k_copy_tile_quantization_parameters(p_j2k);
 
         return OPJ_TRUE;
 }
 
 #if 0
-OPJ_BOOL opj_j2k_write_qcc(     opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_write_qcc(     opj_j2k_t *p_j2k,
                                                 OPJ_UINT32 p_comp_no,
                                                 opj_stream_private_t *p_stream,
                                                 opj_event_mgr_t * p_manager
                             )
 {
         OPJ_UINT32 l_qcc_size,l_remaining_size;
 
         /* preconditions */
         assert(p_j2k != 00);
         assert(p_manager != 00);
@@ skipping 20 matching lines @@
 
         if (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_qcc_size,p_manager) != l_qcc_size) {
                 return OPJ_FALSE;
         }
 
         return OPJ_TRUE;
 }
 #endif
 
 #if 0
-void opj_j2k_write_qcc_in_memory(   opj_j2k_t *p_j2k,
+static void opj_j2k_write_qcc_in_memory(   opj_j2k_t *p_j2k,
                                                                 OPJ_UINT32 p_comp_no,
                                                                 OPJ_BYTE * p_data,
                                                                 OPJ_UINT32 * p_data_written,
                                                                 opj_event_mgr_t * p_manager
                                     )
 {
         OPJ_UINT32 l_qcc_size,l_remaining_size;
         OPJ_BYTE * l_current_data = 00;
 
         /* preconditions */
@@ skipping 29 matching lines @@
 
                 l_remaining_size -= 6;
         }
 
         opj_j2k_write_SQcd_SQcc(p_j2k,p_j2k->m_current_tile_number,p_comp_no,l_current_data,&l_remaining_size,p_manager);
 
         *p_data_written = l_qcc_size;
 }
 #endif
 
-OPJ_UINT32 opj_j2k_get_max_qcc_size (opj_j2k_t *p_j2k)
+static OPJ_UINT32 opj_j2k_get_max_qcc_size (opj_j2k_t *p_j2k)
 {
         return opj_j2k_get_max_coc_size(p_j2k);
 }
 
 /**
  * Reads a QCC marker (Quantization component)
  * @param       p_header_data   the data contained in the QCC box.
  * @param       p_j2k                   the jpeg2000 codec.
  * @param       p_header_size   the size of the data contained in the QCC marker.
  * @param       p_manager               the user event manager.
@@ skipping 71 matching lines @@
         }
 
         if (p_header_size != 0) {
                 opj_event_msg(p_manager, EVT_ERROR, "Error reading QCC marker\n");
                 return OPJ_FALSE;
         }
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_write_poc(     opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_write_poc(     opj_j2k_t *p_j2k,
                                                         opj_stream_private_t *p_stream,
                                                         opj_event_mgr_t * p_manager
                             )
 {
         OPJ_UINT32 l_nb_comp;
         OPJ_UINT32 l_nb_poc;
         OPJ_UINT32 l_poc_size;
         OPJ_UINT32 l_written_size = 0;
         opj_tcp_t *l_tcp = 00;
         OPJ_UINT32 l_poc_room;
@@ skipping 30 matching lines @@
 
         opj_j2k_write_poc_in_memory(p_j2k,p_j2k->m_specific_param.m_encoder.m_header_tile_data,&l_written_size,p_manager);
 
         if (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_poc_size,p_manager) != l_poc_size) {
                 return OPJ_FALSE;
         }
 
         return OPJ_TRUE;
 }
 
-void opj_j2k_write_poc_in_memory(   opj_j2k_t *p_j2k,
+static void opj_j2k_write_poc_in_memory(   opj_j2k_t *p_j2k,
                                                                 OPJ_BYTE * p_data,
                                                                 OPJ_UINT32 * p_data_written,
                                                                 opj_event_mgr_t * p_manager
                                     )
 {
         OPJ_UINT32 i;
         OPJ_BYTE * l_current_data = 00;
         OPJ_UINT32 l_nb_comp;
         OPJ_UINT32 l_nb_poc;
         OPJ_UINT32 l_poc_size;
@@ skipping 54 matching lines @@
                 l_current_poc->layno1 = (OPJ_UINT32)opj_int_min((OPJ_INT32)l_current_poc->layno1, (OPJ_INT32)l_tcp->numlayers);
                 l_current_poc->resno1 = (OPJ_UINT32)opj_int_min((OPJ_INT32)l_current_poc->resno1, (OPJ_INT32)l_tccp->numresolutions);
                 l_current_poc->compno1 = (OPJ_UINT32)opj_int_min((OPJ_INT32)l_current_poc->compno1, (OPJ_INT32)l_nb_comp);
 
                 ++l_current_poc;
         }
 
         *p_data_written = l_poc_size;
 }
 
-OPJ_UINT32 opj_j2k_get_max_poc_size(opj_j2k_t *p_j2k)
+static OPJ_UINT32 opj_j2k_get_max_poc_size(opj_j2k_t *p_j2k)
 {
         opj_tcp_t * l_tcp = 00;
         OPJ_UINT32 l_nb_tiles = 0;
         OPJ_UINT32 l_max_poc = 0;
         OPJ_UINT32 i;
 
         l_tcp = p_j2k->m_cp.tcps;
         l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
 
         for (i=0;i<l_nb_tiles;++i) {
                 l_max_poc = opj_uint_max(l_max_poc,l_tcp->numpocs);
                 ++l_tcp;
         }
 
         ++l_max_poc;
 
         return 4 + 9 * l_max_poc;
 }
 
-OPJ_UINT32 opj_j2k_get_max_toc_size (opj_j2k_t *p_j2k)
+static OPJ_UINT32 opj_j2k_get_max_toc_size (opj_j2k_t *p_j2k)
 {
         OPJ_UINT32 i;
         OPJ_UINT32 l_nb_tiles;
         OPJ_UINT32 l_max = 0;
         opj_tcp_t * l_tcp = 00;
 
         l_tcp = p_j2k->m_cp.tcps;
         l_nb_tiles = p_j2k->m_cp.tw * p_j2k->m_cp.th ;
 
         for (i=0;i<l_nb_tiles;++i) {
                 l_max = opj_uint_max(l_max,l_tcp->m_nb_tile_parts);
 
                 ++l_tcp;
         }
 
         return 12 * l_max;
 }
 
-OPJ_UINT32 opj_j2k_get_specific_header_sizes(opj_j2k_t *p_j2k)
+static OPJ_UINT32 opj_j2k_get_specific_header_sizes(opj_j2k_t *p_j2k)
 {
         OPJ_UINT32 l_nb_bytes = 0;
         OPJ_UINT32 l_nb_comps;
         OPJ_UINT32 l_coc_bytes,l_qcc_bytes;
 
         l_nb_comps = p_j2k->m_private_image->numcomps - 1;
         l_nb_bytes += opj_j2k_get_max_toc_size(p_j2k);
 
         if (!(OPJ_IS_CINEMA(p_j2k->m_cp.rsiz))) {
                 l_coc_bytes = opj_j2k_get_max_coc_size(p_j2k);
@@ skipping 309 matching lines @@
         }
 
         if (l_packet_len != 0) {
                 opj_event_msg(p_manager, EVT_ERROR, "Error reading PLT marker\n");
                 return OPJ_FALSE;
         }
 
         return OPJ_TRUE;
 }
 
-#if 0
-OPJ_BOOL j2k_read_ppm_v2 (
-                                                opj_j2k_t *p_j2k,
-                                                OPJ_BYTE * p_header_data,
-                                                OPJ_UINT32 p_header_size,
-                                                struct opj_event_mgr * p_manager
-                                        )
+/**
+ * Reads a PPM marker (Packed packet headers, main header)
+ *
+ * @param       p_header_data   the data contained in the POC box.
+ * @param       p_j2k                   the jpeg2000 codec.
+ * @param       p_header_size   the size of the data contained in the POC marker.
+ * @param       p_manager               the user event manager.
+ */
+
+static OPJ_BOOL opj_j2k_read_ppm (
+                                                                                                                                        opj_j2k_t *p_j2k,
+                                                                                                                                        OPJ_BYTE * p_header_data,
+                                                                                                                                        OPJ_UINT32 p_header_size,
+                                                                                                                                        opj_event_mgr_t * p_manager )
 {
-
-        opj_cp_t *l_cp = 00;
-        OPJ_UINT32 l_remaining_data, l_Z_ppm, l_N_ppm;
-
-        /* preconditions */
-        assert(p_header_data != 00);
-        assert(p_j2k != 00);
-        assert(p_manager != 00);
-
-        if (p_header_size < 1) {
-                opj_event_msg(p_manager, EVT_ERROR, "Error reading PPM marker\n");
-                return OPJ_FALSE;
-        }
-
-        l_cp = &(p_j2k->m_cp);
-        l_cp->ppm = 1;
-
-        opj_read_bytes(p_header_data,&l_Z_ppm,1);               /* Z_ppm */
-        ++p_header_data;
-        --p_header_size;
-
-        /* First PPM marker */
-        if (l_Z_ppm == 0) {
-                if (p_header_size < 4) {
-                        opj_event_msg(p_manager, EVT_ERROR, "Error reading PPM marker\n");
-                        return OPJ_FALSE;
-                }
-
-                opj_read_bytes(p_header_data,&l_N_ppm,4);               /* N_ppm */
-                p_header_data+=4;
-                p_header_size-=4;
-
-                /* First PPM marker: Initialization */
-                l_cp->ppm_len = l_N_ppm;
-                l_cp->ppm_data_size = 0;
-
-                l_cp->ppm_buffer = (OPJ_BYTE *) opj_malloc(l_cp->ppm_len);
-                if (l_cp->ppm_buffer == 00) {
-                        opj_event_msg(p_manager, EVT_ERROR, "Not enough memory reading ppm marker\n");
-                        return OPJ_FALSE;
-                }
-                memset(l_cp->ppm_buffer,0,l_cp->ppm_len);
-
-                l_cp->ppm_data = l_cp->ppm_buffer;
-        }
-
-        while (1) {
-                if (l_cp->ppm_data_size == l_cp->ppm_len) {
-                        if (p_header_size >= 4) {
-                                /* read a N_ppm */
-                                opj_read_bytes(p_header_data,&l_N_ppm,4);               /* N_ppm */
-                                p_header_data+=4;
-                                p_header_size-=4;
-                                l_cp->ppm_len += l_N_ppm ;
-
-                                OPJ_BYTE *new_ppm_buffer = (OPJ_BYTE *) opj_realloc(l_cp->ppm_buffer, l_cp->ppm_len);
-                                if (! new_ppm_buffer) {
-                                        opj_free(l_cp->ppm_buffer);
-                                        l_cp->ppm_buffer = NULL;
-                                        l_cp->ppm_len = 0;
-                                        l_cp->ppm_data = NULL;
-                                        opj_event_msg(p_manager, EVT_ERROR, "Not enough memory reading ppm marker\n");
-                                        return OPJ_FALSE;
-                                }
-                                l_cp->ppm_buffer = new_ppm_buffer;
-                                memset(l_cp->ppm_buffer+l_cp->ppm_data_size,0,l_N_ppm);
-                                l_cp->ppm_data = l_cp->ppm_buffer;
-                        }
-                        else {
-                                return OPJ_FALSE;
-                        }
-                }
-
-                l_remaining_data = l_cp->ppm_len - l_cp->ppm_data_size;
-
-                if (l_remaining_data <= p_header_size) {
-                        /* we must store less information than available in the packet */
-                        memcpy(l_cp->ppm_buffer + l_cp->ppm_data_size , p_header_data , l_remaining_data);
-                        l_cp->ppm_data_size = l_cp->ppm_len;
-                        p_header_size -= l_remaining_data;
-                        p_header_data += l_remaining_data;
-                }
-                else {
-                        memcpy(l_cp->ppm_buffer + l_cp->ppm_data_size , p_header_data , p_header_size);
-                        l_cp->ppm_data_size += p_header_size;
-                        p_header_data += p_header_size;
-                        p_header_size = 0;
-                        break;
-                }
-        }
-
-        return OPJ_TRUE;
+        opj_cp_t *l_cp = 00;
+        OPJ_UINT32 l_Z_ppm;
+        
+        /* preconditions */
+        assert(p_header_data != 00);
+        assert(p_j2k != 00);
+        assert(p_manager != 00);
+        
+        /* We need to have the Z_ppm element + 1 byte of Nppm/Ippm at minimum */
+        if (p_header_size < 2) {
+                opj_event_msg(p_manager, EVT_ERROR, "Error reading PPM marker\n");
+                return OPJ_FALSE;
+        }
+        
+        l_cp = &(p_j2k->m_cp);
+        l_cp->ppm = 1;
+        
+        opj_read_bytes(p_header_data,&l_Z_ppm,1);               /* Z_ppm */
+        ++p_header_data;
+        --p_header_size;
+        
+        /* check allocation needed */
+        if (l_cp->ppm_markers == NULL) { /* first PPM marker */
+                OPJ_UINT32 l_newCount = l_Z_ppm + 1U; /* can't overflow, l_Z_ppm is UINT8 */
+                assert(l_cp->ppm_markers_count == 0U);
+                
+                l_cp->ppm_markers = (opj_ppx *) opj_calloc(l_newCount, sizeof(opj_ppx));
+                if (l_cp->ppm_markers == NULL) {
+                        opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read PPM marker\n");
+                        return OPJ_FALSE;
+                }
+                l_cp->ppm_markers_count = l_newCount;
+        } else if (l_cp->ppm_markers_count <= l_Z_ppm) {
+                OPJ_UINT32 l_newCount = l_Z_ppm + 1U; /* can't overflow, l_Z_ppm is UINT8 */
+                opj_ppx *new_ppm_markers;
+                new_ppm_markers = (opj_ppx *) opj_realloc(l_cp->ppm_markers, l_newCount * sizeof(opj_ppx));
+                if (new_ppm_markers == NULL) {
+                        /* clean up to be done on l_cp destruction */
+                        opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read PPM marker\n");
+                        return OPJ_FALSE;
+                }
+                l_cp->ppm_markers = new_ppm_markers;
+                memset(l_cp->ppm_markers + l_cp->ppm_markers_count, 0, (l_newCount - l_cp->ppm_markers_count) * sizeof(opj_ppx));
+                l_cp->ppm_markers_count = l_newCount;
+        }
+        
+        if (l_cp->ppm_markers[l_Z_ppm].m_data != NULL) {
+                /* clean up to be done on l_cp destruction */
+                opj_event_msg(p_manager, EVT_ERROR, "Zppm %u already read\n", l_Z_ppm);
+                return OPJ_FALSE;
+        }
+        
+        l_cp->ppm_markers[l_Z_ppm].m_data = opj_malloc(p_header_size);
+        if (l_cp->ppm_markers[l_Z_ppm].m_data == NULL) {
+                /* clean up to be done on l_cp destruction */
+                opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read PPM marker\n");
+                return OPJ_FALSE;
+        }
+        l_cp->ppm_markers[l_Z_ppm].m_data_size = p_header_size;
+        memcpy(l_cp->ppm_markers[l_Z_ppm].m_data, p_header_data, p_header_size);
+
+        return OPJ_TRUE;
 }
-#endif
-
-OPJ_BOOL j2k_read_ppm_v3 (
-                                                opj_j2k_t *p_j2k,
-                                                OPJ_BYTE * p_header_data,
-                                                OPJ_UINT32 p_header_size,
-                                                struct opj_event_mgr * p_manager
-                                        )
+
+/**
+ * Merges all PPM markers read (Packed headers, main header)
+ *
+ * @param       p_cp      main coding parameters.
+ * @param       p_manager the user event manager.
+ */
+static OPJ_BOOL opj_j2k_merge_ppm ( opj_cp_t *p_cp, opj_event_mgr_t * p_manager )
 {
-        opj_cp_t *l_cp = 00;
-        OPJ_UINT32 l_remaining_data, l_Z_ppm, l_N_ppm;
-
-        /* preconditions */
-        assert(p_header_data != 00);
-        assert(p_j2k != 00);
-        assert(p_manager != 00);
-
-        /* Minimum size of PPM marker is equal to the size of Zppm element */
-        if (p_header_size < 1) {
-                opj_event_msg(p_manager, EVT_ERROR, "Error reading PPM marker\n");
-                return OPJ_FALSE;
-        }
-
-        l_cp = &(p_j2k->m_cp);
-        l_cp->ppm = 1;
-
-        opj_read_bytes(p_header_data,&l_Z_ppm,1);               /* Z_ppm */
-        ++p_header_data;
-        --p_header_size;
-
-        /* First PPM marker */
-        if (l_Z_ppm == 0) {
-                if (l_cp->ppm_data != NULL) {
-                        opj_event_msg(p_manager, EVT_ERROR, "Zppm O already processed. Found twice.\n");
-                        opj_free(l_cp->ppm_data);
-                        l_cp->ppm_data = NULL;
-                        l_cp->ppm_buffer = NULL;
-                        l_cp->ppm = 0; /* do not use PPM */
-                        return OPJ_FALSE;
-                }
-                /* We need now at least the Nppm^0 element */
-                if (p_header_size < 4) {
-                        opj_event_msg(p_manager, EVT_ERROR, "Error reading PPM marker\n");
-                        return OPJ_FALSE;
-                }
-
-                opj_read_bytes(p_header_data,&l_N_ppm,4);               /* First N_ppm */
-                p_header_data+=4;
-                p_header_size-=4;
-
-                /* sanity check: how much bytes is left for Ippm */
-                if( p_header_size < l_N_ppm )
-                  {
-                  opj_event_msg(p_manager, EVT_ERROR, "Not enough bytes (%u) to hold Ippm series (%u), Index (%d)\n", p_header_size, l_N_ppm, l_Z_ppm );
-                  opj_free(l_cp->ppm_data);
-                  l_cp->ppm_data = NULL;
-                  l_cp->ppm_buffer = NULL;
-                  l_cp->ppm = 0; /* do not use PPM */
-                  return OPJ_FALSE;
-                  }
-
-                /* First PPM marker: Initialization */
-                l_cp->ppm_len = l_N_ppm;
-                l_cp->ppm_data_read = 0;
-
-                l_cp->ppm_data = (OPJ_BYTE *) opj_calloc(1,l_cp->ppm_len);
-                l_cp->ppm_buffer = l_cp->ppm_data;
-                if (l_cp->ppm_data == 00) {
-                        opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read ppm marker\n");
-                        return OPJ_FALSE;
-                }
-
-                l_cp->ppm_data_current = l_cp->ppm_data;
-
-                /*l_cp->ppm_data = l_cp->ppm_buffer;*/
-        }
-        else {
-                if (p_header_size < 4) {
-                        opj_event_msg(p_manager, EVT_WARNING, "Empty PPM marker\n");
-                        return OPJ_TRUE;
-                }
-                else {
-                        /* Uncompleted Ippm series in the previous PPM marker?*/
-                        if (l_cp->ppm_data_read < l_cp->ppm_len) {
-                                /* Get the place where add the remaining Ippm series*/
-                                l_cp->ppm_data_current = &(l_cp->ppm_data[l_cp->ppm_data_read]);
-                                l_N_ppm = l_cp->ppm_len - l_cp->ppm_data_read;
-                        }
-                        else {
-                                OPJ_BYTE *new_ppm_data;
-                                opj_read_bytes(p_header_data,&l_N_ppm,4);               /* First N_ppm */
-                                p_header_data+=4;
-                                p_header_size-=4;
-
-                                /* sanity check: how much bytes is left for Ippm */
-                                if( p_header_size < l_N_ppm )
-                                  {
-                                  opj_event_msg(p_manager, EVT_ERROR, "Not enough bytes (%u) to hold Ippm series (%u), Index (%d)\n", p_header_size, l_N_ppm, l_Z_ppm );
-                                  opj_free(l_cp->ppm_data);
-                                  l_cp->ppm_data = NULL;
-                                  l_cp->ppm_buffer = NULL;
-                                  l_cp->ppm = 0; /* do not use PPM */
-                                  return OPJ_FALSE;
-                                  }
-                                /* 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");
-                                new_ppm_data = (OPJ_BYTE *) opj_realloc(l_cp->ppm_data, l_cp->ppm_len + l_N_ppm);
-                                if (! new_ppm_data) {
-                                        opj_free(l_cp->ppm_data);
-                                        l_cp->ppm_data = NULL;
-                                        l_cp->ppm_buffer = NULL;  /* TODO: no need for a new local variable: ppm_buffer and ppm_data are enough */
-                                        l_cp->ppm_len = 0;
-                                        opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to increase the size of ppm_data to add the new Ippm series\n");
-                                        return OPJ_FALSE;
-                                }
-                                l_cp->ppm_data = new_ppm_data;
-                                l_cp->ppm_buffer = l_cp->ppm_data;
-
-                                /* Keep the position of the place where concatenate the new series*/
-                                l_cp->ppm_data_current = &(l_cp->ppm_data[l_cp->ppm_len]);
-                                l_cp->ppm_len += l_N_ppm;
-                        }
-                }
-        }
-
-        l_remaining_data = p_header_size;
-
-        while (l_remaining_data >= l_N_ppm) {
-                /* read a complete Ippm series*/
-                memcpy(l_cp->ppm_data_current, p_header_data, l_N_ppm);
-                p_header_size -= l_N_ppm;
-                p_header_data += l_N_ppm;
-
-                l_cp->ppm_data_read += l_N_ppm; /* Increase the number of data read*/
-
-                if (p_header_size)
-                {
-                        if (p_header_size < 4) {
-                                opj_free(l_cp->ppm_data);
-                                l_cp->ppm_data = NULL;
-                                l_cp->ppm_buffer = NULL;  /* TODO: no need for a new local variable: ppm_buffer and ppm_data are enough */
-                                l_cp->ppm_len = 0;
-                                l_cp->ppm = 0;
-                                opj_event_msg(p_manager, EVT_ERROR, "Error reading PPM marker\n");
-                                return OPJ_FALSE;
-                        }
-                        opj_read_bytes(p_header_data,&l_N_ppm,4);               /* N_ppm^i */
-                        p_header_data+=4;
-                        p_header_size-=4;
-                }
-                else {
-                        l_remaining_data = p_header_size;
-                        break;
-                }
-
-                l_remaining_data = p_header_size;
-
-                /* Next Ippm series is a complete series ?*/
-                if (l_remaining_data >= l_N_ppm) {
-                        OPJ_BYTE *new_ppm_data;
-                        /* 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");
-                        /* Overflow check */
-                        if ((l_cp->ppm_len + l_N_ppm) < l_N_ppm) {
-                                opj_free(l_cp->ppm_data);
-                                l_cp->ppm_data = NULL;
-                                l_cp->ppm_buffer = NULL;  /* TODO: no need for a new local variable: ppm_buffer and ppm_data are enough */
-                                l_cp->ppm_len = 0;
-                                opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to increase the size of ppm_data to add the new (complete) Ippm series\n");
-                                return OPJ_FALSE;
-                        }
-                        new_ppm_data = (OPJ_BYTE *) opj_realloc(l_cp->ppm_data, l_cp->ppm_len + l_N_ppm);
-                        if (! new_ppm_data) {
-                                opj_free(l_cp->ppm_data);
-                                l_cp->ppm_data = NULL;
-                                l_cp->ppm_buffer = NULL;  /* TODO: no need for a new local variable: ppm_buffer and ppm_data are enough */
-                                l_cp->ppm_len = 0;
-                                opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to increase the size of ppm_data to add the new (complete) Ippm series\n");
-                                return OPJ_FALSE;
-                        }
-                        l_cp->ppm_data = new_ppm_data;
-                        l_cp->ppm_buffer = l_cp->ppm_data;
-
-                        /* Keep the position of the place where concatenate the new series */
-                        l_cp->ppm_data_current = &(l_cp->ppm_data[l_cp->ppm_len]);
-                        l_cp->ppm_len += l_N_ppm;
-                }
-
-        }
-
-        /* Need to read an incomplete Ippm series*/
-        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");
-
-                /* Overflow check */
-                if ((l_cp->ppm_len + l_N_ppm) < l_N_ppm) {
-                        opj_free(l_cp->ppm_data);
-                        l_cp->ppm_data = NULL;
-                        l_cp->ppm_buffer = NULL;  /* TODO: no need for a new local variable: ppm_buffer and ppm_data are enough */
-                        l_cp->ppm_len = 0;
-                        opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to increase the size of ppm_data to add the new (complete) Ippm series\n");
-                        return OPJ_FALSE;
-                }
-                new_ppm_data = (OPJ_BYTE *) opj_realloc(l_cp->ppm_data, l_cp->ppm_len + l_N_ppm);
-                if (! new_ppm_data) {
-                        opj_free(l_cp->ppm_data);
-                        l_cp->ppm_data = NULL;
-                        l_cp->ppm_buffer = NULL;  /* TODO: no need for a new local variable: ppm_buffer and ppm_data are enough */
-                        l_cp->ppm_len = 0;
-                        opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to increase the size of ppm_data to add the new (incomplete) Ippm series\n");
-                        return OPJ_FALSE;
-                }
-                l_cp->ppm_data = new_ppm_data;
-                l_cp->ppm_buffer = l_cp->ppm_data;
-
-                /* Keep the position of the place where concatenate the new series*/
-                l_cp->ppm_data_current = &(l_cp->ppm_data[l_cp->ppm_len]);
-                l_cp->ppm_len += l_N_ppm;
-
-                /* Read incomplete Ippm series*/
-                memcpy(l_cp->ppm_data_current, p_header_data, l_remaining_data);
-                p_header_size -= l_remaining_data;
-                p_header_data += l_remaining_data;
-
-                l_cp->ppm_data_read += l_remaining_data; /* Increase the number of data read*/
-        }
-
-#ifdef CLEAN_MSD
-
-                if (l_cp->ppm_data_size == l_cp->ppm_len) {
-                        if (p_header_size >= 4) {
-                                /* read a N_ppm*/
-                                opj_read_bytes(p_header_data,&l_N_ppm,4);               /* N_ppm */
-                                p_header_data+=4;
-                                p_header_size-=4;
-                                l_cp->ppm_len += l_N_ppm ;
-
-                                OPJ_BYTE *new_ppm_buffer = (OPJ_BYTE *) opj_realloc(l_cp->ppm_buffer, l_cp->ppm_len);
-                                if (! new_ppm_buffer) {
-                                        opj_free(l_cp->ppm_buffer);
-                                        l_cp->ppm_buffer = NULL;
-                                        l_cp->ppm_len = 0;
-                                        opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read ppm marker\n");
-                                        return OPJ_FALSE;
-                                }
-                                l_cp->ppm_buffer = new_ppm_buffer;
-                                memset(l_cp->ppm_buffer+l_cp->ppm_data_size,0,l_N_ppm);
-
-                                l_cp->ppm_data = l_cp->ppm_buffer;
-                        }
-                        else {
-                                return OPJ_FALSE;
-                        }
-                }
-
-                l_remaining_data = l_cp->ppm_len - l_cp->ppm_data_size;
-
-                if (l_remaining_data <= p_header_size) {
-                        /* we must store less information than available in the packet */
-                        memcpy(l_cp->ppm_buffer + l_cp->ppm_data_size , p_header_data , l_remaining_data);
-                        l_cp->ppm_data_size = l_cp->ppm_len;
-                        p_header_size -= l_remaining_data;
-                        p_header_data += l_remaining_data;
-                }
-                else {
-                        memcpy(l_cp->ppm_buffer + l_cp->ppm_data_size , p_header_data , p_header_size);
-                        l_cp->ppm_data_size += p_header_size;
-                        p_header_data += p_header_size;
-                        p_header_size = 0;
-                        break;
-                }
-        }
-#endif
-        return OPJ_TRUE;
+        OPJ_UINT32 i, l_ppm_data_size, l_N_ppm_remaining;
+        
+        /* preconditions */
+        assert(p_cp != 00);
+        assert(p_manager != 00);
+        assert(p_cp->ppm_buffer == NULL);
+        
+        if (p_cp->ppm == 0U) {
+                return OPJ_TRUE;
+        }
+        
+        l_ppm_data_size = 0U;
+        l_N_ppm_remaining = 0U;
+        for (i = 0U; i < p_cp->ppm_markers_count; ++i) {
+                if (p_cp->ppm_markers[i].m_data != NULL) { /* standard doesn't seem to require contiguous Zppm */
+                        OPJ_UINT32 l_N_ppm;
+                        OPJ_UINT32 l_data_size = p_cp->ppm_markers[i].m_data_size;
+                        const OPJ_BYTE* l_data = p_cp->ppm_markers[i].m_data;
+                        
+                        if (l_N_ppm_remaining >= l_data_size) {
+                                l_N_ppm_remaining -= l_data_size;
+                                l_data_size = 0U;
+                        } else {
+                                l_data += l_N_ppm_remaining;
+                                l_data_size -= l_N_ppm_remaining;
+                                l_N_ppm_remaining = 0U;
+                        }
+                        
+                        if (l_data_size > 0U) {
+                                do
+                                {
+                                        /* read Nppm */
+                                        if (l_data_size < 4U) {
+                                                /* clean up to be done on l_cp destruction */
+                                                opj_event_msg(p_manager, EVT_ERROR, "Not enough bytes to read Nppm\n");
+                                                return OPJ_FALSE;
+                                        }
+                                        opj_read_bytes(l_data, &l_N_ppm, 4);
+                                        l_data+=4;
+                                        l_data_size-=4;
+                                        l_ppm_data_size += l_N_ppm; /* can't overflow, max 256 markers of max 65536 bytes, that is when PPM markers are not corrupted which is checked elsewhere */
+                                        
+                                        if (l_data_size >= l_N_ppm) {
+                                                l_data_size -= l_N_ppm;
+                                                l_data += l_N_ppm;
+                                        } else {
+                                                l_N_ppm_remaining = l_N_ppm - l_data_size;
+                                                l_data_size = 0U;
+                                        }
+                                } while (l_data_size > 0U);
+                        }
+                }
+        }
+        
+        if (l_N_ppm_remaining != 0U) {
+                /* clean up to be done on l_cp destruction */
+                opj_event_msg(p_manager, EVT_ERROR, "Corrupted PPM markers\n");
+                return OPJ_FALSE;
+        }
+        
+        p_cp->ppm_buffer = (OPJ_BYTE *) opj_malloc(l_ppm_data_size);
+        if (p_cp->ppm_buffer == 00) {
+                opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read PPM marker\n");
+                return OPJ_FALSE;
+        }
+        p_cp->ppm_len = l_ppm_data_size;
+        l_ppm_data_size = 0U;
+        l_N_ppm_remaining = 0U;
+        for (i = 0U; i < p_cp->ppm_markers_count; ++i) {
+                if (p_cp->ppm_markers[i].m_data != NULL) { /* standard doesn't seem to require contiguous Zppm */
+                        OPJ_UINT32 l_N_ppm;
+                        OPJ_UINT32 l_data_size = p_cp->ppm_markers[i].m_data_size;
+                        const OPJ_BYTE* l_data = p_cp->ppm_markers[i].m_data;
+                        
+                        if (l_N_ppm_remaining >= l_data_size) {
+                                memcpy(p_cp->ppm_buffer + l_ppm_data_size, l_data, l_data_size);
+                                l_ppm_data_size += l_data_size;
+                                l_N_ppm_remaining -= l_data_size;
+                                l_data_size = 0U;
+                        } else {
+                                memcpy(p_cp->ppm_buffer + l_ppm_data_size, l_data, l_N_ppm_remaining);
+                                l_ppm_data_size += l_N_ppm_remaining;
+                                l_data += l_N_ppm_remaining;
+                                l_data_size -= l_N_ppm_remaining;
+                                l_N_ppm_remaining = 0U;
+                        }
+
+                        if (l_data_size > 0U) {
+                                do
+                                {
+                                        /* read Nppm */
+                                        if (l_data_size < 4U) {
+                                                /* clean up to be done on l_cp destruction */
+                                                opj_event_msg(p_manager, EVT_ERROR, "Not enough bytes to read Nppm\n");
+                                                return OPJ_FALSE;
+                                        }
+                                        opj_read_bytes(l_data, &l_N_ppm, 4);
+                                        l_data+=4;
+                                        l_data_size-=4;
+                                        
+                                        if (l_data_size >= l_N_ppm) {
+                                                memcpy(p_cp->ppm_buffer + l_ppm_data_size, l_data, l_N_ppm);
+                                                l_ppm_data_size += l_N_ppm;
+                                                l_data_size -= l_N_ppm;
+                                                l_data += l_N_ppm;
+                                        } else {
+                                                memcpy(p_cp->ppm_buffer + l_ppm_data_size, l_data, l_data_size);
+                                                l_ppm_data_size += l_data_size;
+                                                l_N_ppm_remaining = l_N_ppm - l_data_size;
+                                                l_data_size = 0U;
+                                        }
+                                } while (l_data_size > 0U);
+                        }
+                        opj_free(p_cp->ppm_markers[i].m_data);
+                        p_cp->ppm_markers[i].m_data = NULL;
+                        p_cp->ppm_markers[i].m_data_size = 0U;
+                }
+        }
+        
+        p_cp->ppm_data = p_cp->ppm_buffer;
+        p_cp->ppm_data_size = p_cp->ppm_len;
+        
+        p_cp->ppm_markers_count = 0U;
+        opj_free(p_cp->ppm_markers);
+        p_cp->ppm_markers = NULL;
+        
+        return OPJ_TRUE;
 }
 
 /**
  * Reads a PPT marker (Packed packet headers, tile-part header)
  *
  * @param       p_header_data   the data contained in the PPT box.
  * @param       p_j2k                   the jpeg2000 codec.
  * @param       p_header_size   the size of the data contained in the PPT marker.
  * @param       p_manager               the user event manager.
 */
 static OPJ_BOOL opj_j2k_read_ppt (  opj_j2k_t *p_j2k,
                                     OPJ_BYTE * p_header_data,
                                     OPJ_UINT32 p_header_size,
                                     opj_event_mgr_t * p_manager
                                     )
 {
-        opj_cp_t *l_cp = 00;
-        opj_tcp_t *l_tcp = 00;
-        OPJ_UINT32 l_Z_ppt;
+        opj_cp_t *l_cp = 00;
+        opj_tcp_t *l_tcp = 00;
+        OPJ_UINT32 l_Z_ppt;
 
-        /* preconditions */
-        assert(p_header_data != 00);
-        assert(p_j2k != 00);
-        assert(p_manager != 00);
+        /* preconditions */
+        assert(p_header_data != 00);
+        assert(p_j2k != 00);
+        assert(p_manager != 00);
 
-        /* We need to have the Z_ppt element at minimum */
-        if (p_header_size < 1) {
-                opj_event_msg(p_manager, EVT_ERROR, "Error reading PPT marker\n");
-                return OPJ_FALSE;
-        }
+        /* We need to have the Z_ppt element + 1 byte of Ippt at minimum */
+        if (p_header_size < 2) {
+                opj_event_msg(p_manager, EVT_ERROR, "Error reading PPT marker\n");
+                return OPJ_FALSE;
+        }
 
-        l_cp = &(p_j2k->m_cp);
-        if (l_cp->ppm){
-                opj_event_msg(p_manager, EVT_ERROR, "Error reading PPT marker: packet header have been previously found in the main header (PPM marker).\n");
-                return OPJ_FALSE;
-        }
+        l_cp = &(p_j2k->m_cp);
+        if (l_cp->ppm){
+                opj_event_msg(p_manager, EVT_ERROR, "Error reading PPT marker: packet header have been previously found in the main header (PPM marker).\n");
+                return OPJ_FALSE;
+        }
 
-        l_tcp = &(l_cp->tcps[p_j2k->m_current_tile_number]);
-        l_tcp->ppt = 1;
+        l_tcp = &(l_cp->tcps[p_j2k->m_current_tile_number]);
+        l_tcp->ppt = 1;
 
-        opj_read_bytes(p_header_data,&l_Z_ppt,1);               /* Z_ppt */
-        ++p_header_data;
-        --p_header_size;
-
-        /* Allocate buffer to read the packet header */
-        if (l_Z_ppt == 0) {
-                /* First PPT marker */
-                l_tcp->ppt_data_size = 0;
-                l_tcp->ppt_len = p_header_size;
-
-                opj_free(l_tcp->ppt_buffer);
-                l_tcp->ppt_buffer = (OPJ_BYTE *) opj_calloc(l_tcp->ppt_len, sizeof(OPJ_BYTE) );
-                if (l_tcp->ppt_buffer == 00) {
-                        opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read PPT marker\n");
-                        return OPJ_FALSE;
-                }
-                l_tcp->ppt_data = l_tcp->ppt_buffer;
-
-                /* memset(l_tcp->ppt_buffer,0,l_tcp->ppt_len); */
-        }
-        else {
-                OPJ_BYTE *new_ppt_buffer;
-                l_tcp->ppt_len += p_header_size;
-
-                new_ppt_buffer = (OPJ_BYTE *) opj_realloc(l_tcp->ppt_buffer, l_tcp->ppt_len);
-                if (! new_ppt_buffer) {
-                        opj_free(l_tcp->ppt_buffer);
-                        l_tcp->ppt_buffer = NULL;
-                        l_tcp->ppt_len = 0;
-                        opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read PPT marker\n");
-                        return OPJ_FALSE;
-                }
-                l_tcp->ppt_buffer = new_ppt_buffer;
-                l_tcp->ppt_data = l_tcp->ppt_buffer;
-
-                memset(l_tcp->ppt_buffer+l_tcp->ppt_data_size,0,p_header_size);
-        }
-
-        /* Read packet header from buffer */
-        memcpy(l_tcp->ppt_buffer+l_tcp->ppt_data_size,p_header_data,p_header_size);
-
-        l_tcp->ppt_data_size += p_header_size;
-
-        return OPJ_TRUE;
+        opj_read_bytes(p_header_data,&l_Z_ppt,1);               /* Z_ppt */
+        ++p_header_data;
+        --p_header_size;
+        
+        /* check allocation needed */
+        if (l_tcp->ppt_markers == NULL) { /* first PPT marker */
+                OPJ_UINT32 l_newCount = l_Z_ppt + 1U; /* can't overflow, l_Z_ppt is UINT8 */
+                assert(l_tcp->ppt_markers_count == 0U);
+                
+                l_tcp->ppt_markers = (opj_ppx *) opj_calloc(l_newCount, sizeof(opj_ppx));
+                if (l_tcp->ppt_markers == NULL) {
+                        opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read PPT marker\n");
+                        return OPJ_FALSE;
+                }
+                l_tcp->ppt_markers_count = l_newCount;
+        } else if (l_tcp->ppt_markers_count <= l_Z_ppt) {
+                OPJ_UINT32 l_newCount = l_Z_ppt + 1U; /* can't overflow, l_Z_ppt is UINT8 */
+                opj_ppx *new_ppt_markers;
+                new_ppt_markers = (opj_ppx *) opj_realloc(l_tcp->ppt_markers, l_newCount * sizeof(opj_ppx));
+                if (new_ppt_markers == NULL) {
+                        /* clean up to be done on l_tcp destruction */
+                        opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read PPT marker\n");
+                        return OPJ_FALSE;
+                }
+                l_tcp->ppt_markers = new_ppt_markers;
+                memset(l_tcp->ppt_markers + l_tcp->ppt_markers_count, 0, (l_newCount - l_tcp->ppt_markers_count) * sizeof(opj_ppx));
+                l_tcp->ppt_markers_count = l_newCount;
+        }
+        
+        if (l_tcp->ppt_markers[l_Z_ppt].m_data != NULL) {
+                /* clean up to be done on l_tcp destruction */
+                opj_event_msg(p_manager, EVT_ERROR, "Zppt %u already read\n", l_Z_ppt);
+                return OPJ_FALSE;
+        }
+        
+        l_tcp->ppt_markers[l_Z_ppt].m_data = opj_malloc(p_header_size);
+        if (l_tcp->ppt_markers[l_Z_ppt].m_data == NULL) {
+                /* clean up to be done on l_tcp destruction */
+                opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read PPT marker\n");
+                return OPJ_FALSE;
+        }
+        l_tcp->ppt_markers[l_Z_ppt].m_data_size = p_header_size;
+        memcpy(l_tcp->ppt_markers[l_Z_ppt].m_data, p_header_data, p_header_size);
+        return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_write_tlm(     opj_j2k_t *p_j2k,
+/**
+ * Merges all PPT markers read (Packed packet headers, tile-part header)
+ *
+ * @param       p_tcp   the tile.
+ * @param       p_manager               the user event manager.
+ */
+static OPJ_BOOL opj_j2k_merge_ppt(opj_tcp_t *p_tcp, opj_event_mgr_t * p_manager)
+{
+        OPJ_UINT32 i, l_ppt_data_size;
+        /* preconditions */
+        assert(p_tcp != 00);
+        assert(p_manager != 00);
+        assert(p_tcp->ppt_buffer == NULL);
+        
+        if (p_tcp->ppt == 0U) {
+                return OPJ_TRUE;
+        }
+        
+        l_ppt_data_size = 0U;
+        for (i = 0U; i < p_tcp->ppt_markers_count; ++i) {
+                l_ppt_data_size += p_tcp->ppt_markers[i].m_data_size; /* can't overflow, max 256 markers of max 65536 bytes */
+        }
+        
+        p_tcp->ppt_buffer = (OPJ_BYTE *) opj_malloc(l_ppt_data_size);
+        if (p_tcp->ppt_buffer == 00) {
+                opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read PPT marker\n");
+                return OPJ_FALSE;
+        }
+        p_tcp->ppt_len = l_ppt_data_size;
+        l_ppt_data_size = 0U;
+        for (i = 0U; i < p_tcp->ppt_markers_count; ++i) {
+                if (p_tcp->ppt_markers[i].m_data != NULL) { /* standard doesn't seem to require contiguous Zppt */
+                        memcpy(p_tcp->ppt_buffer + l_ppt_data_size, p_tcp->ppt_markers[i].m_data, p_tcp->ppt_markers[i].m_data_size);
+                        l_ppt_data_size += p_tcp->ppt_markers[i].m_data_size; /* can't overflow, max 256 markers of max 65536 bytes */
+                        
+                        opj_free(p_tcp->ppt_markers[i].m_data);
+                        p_tcp->ppt_markers[i].m_data = NULL;
+                        p_tcp->ppt_markers[i].m_data_size = 0U;
+                }
+        }
+        
+        p_tcp->ppt_markers_count = 0U;
+        opj_free(p_tcp->ppt_markers);
+        p_tcp->ppt_markers = NULL;
+        
+        p_tcp->ppt_data = p_tcp->ppt_buffer;
+        p_tcp->ppt_data_size = p_tcp->ppt_len;
+        return OPJ_TRUE;
+}
+
+static OPJ_BOOL opj_j2k_write_tlm(     opj_j2k_t *p_j2k,
                                                         opj_stream_private_t *p_stream,
                                                         opj_event_mgr_t * p_manager
                             )
 {
         OPJ_BYTE * l_current_data = 00;
         OPJ_UINT32 l_tlm_size;
 
         /* preconditions */
         assert(p_j2k != 00);
         assert(p_manager != 00);
@@ skipping 33 matching lines @@
         ++l_current_data;
 
         /* do nothing on the 5 * l_j2k->m_specific_param.m_encoder.m_total_tile_parts remaining data */
         if (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_tlm_size,p_manager) != l_tlm_size) {
                 return OPJ_FALSE;
         }
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_write_sot(     opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_write_sot(     opj_j2k_t *p_j2k,
                                                         OPJ_BYTE * p_data,
                                                         OPJ_UINT32 * p_data_written,
                                                         const opj_stream_private_t *p_stream,
                                                         opj_event_mgr_t * p_manager
                             )
 {
         /* preconditions */
         assert(p_j2k != 00);
         assert(p_manager != 00);
         assert(p_stream != 00);
@@ skipping 23 matching lines @@
         OPJ_BOOL res = j2k_add_marker(p_j2k->cstr_info, J2K_MS_SOT, p_j2k->sot_start, len + 2);
 */
   assert( 0 && "TODO" );
 #endif /* USE_JPWL */
 
         * p_data_written = 12;
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_read_sot ( opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_get_sot_values(OPJ_BYTE *  p_header_data,
+                                                                                                                                                         OPJ_UINT32  p_header_size,
+                                                                                                                                                         OPJ_UINT32* p_tile_no,
+                                                                                                                                                         OPJ_UINT32* p_tot_len,
+                                                                                                                                                         OPJ_UINT32* p_current_part,
+                                                                                                                                                         OPJ_UINT32* p_num_parts,
+                                                                                                                                                         opj_event_mgr_t * p_manager )
+{
+        /* preconditions */
+        assert(p_header_data != 00);
+        assert(p_manager != 00);
+        
+        /* Size of this marker is fixed = 12 (we have already read marker and its size)*/
+        if (p_header_size != 8) {
+                opj_event_msg(p_manager, EVT_ERROR, "Error reading SOT marker\n");
+                return OPJ_FALSE;
+        }
+        
+        opj_read_bytes(p_header_data,p_tile_no,2);      /* Isot */
+        p_header_data+=2;
+        opj_read_bytes(p_header_data,p_tot_len,4);      /* Psot */
+        p_header_data+=4;
+        opj_read_bytes(p_header_data,p_current_part,1); /* TPsot */
+        ++p_header_data;
+        opj_read_bytes(p_header_data,p_num_parts ,1);   /* TNsot */
+        ++p_header_data;
+        return OPJ_TRUE;
+}
+
+static OPJ_BOOL opj_j2k_read_sot ( opj_j2k_t *p_j2k,
                             OPJ_BYTE * p_header_data,
                             OPJ_UINT32 p_header_size,
                             opj_event_mgr_t * p_manager )
 {
         opj_cp_t *l_cp = 00;
         opj_tcp_t *l_tcp = 00;
         OPJ_UINT32 l_tot_len, l_num_parts = 0;
         OPJ_UINT32 l_current_part;
         OPJ_UINT32 l_tile_x,l_tile_y;
 
         /* preconditions */
-        assert(p_header_data != 00);
+        
         assert(p_j2k != 00);
         assert(p_manager != 00);
-
-        /* Size of this marker is fixed = 12 (we have already read marker and its size)*/
-        if (p_header_size != 8) {
+        
+        if (! opj_j2k_get_sot_values(p_header_data, p_header_size, &(p_j2k->m_current_tile_number), &l_tot_len, &l_current_part, &l_num_parts, p_manager)) {
                 opj_event_msg(p_manager, EVT_ERROR, "Error reading SOT marker\n");
                 return OPJ_FALSE;
         }
 
         l_cp = &(p_j2k->m_cp);
-        opj_read_bytes(p_header_data,&(p_j2k->m_current_tile_number),2);                /* Isot */
-        p_header_data+=2;
 
         /* testcase 2.pdf.SIGFPE.706.1112 */
         if (p_j2k->m_current_tile_number >= l_cp->tw * l_cp->th) {
                 opj_event_msg(p_manager, EVT_ERROR, "Invalid tile number %d\n", p_j2k->m_current_tile_number);
                 return OPJ_FALSE;
         }
 
         l_tcp = &l_cp->tcps[p_j2k->m_current_tile_number];
         l_tile_x = p_j2k->m_current_tile_number % l_cp->tw;
         l_tile_y = p_j2k->m_current_tile_number / l_cp->tw;
@@ skipping 22 matching lines @@
 
                 /* keep your private count of tiles */
                 backup_tileno++;
         };
 #endif /* USE_JPWL */
 
         /* look for the tile in the list of already processed tile (in parts). */
         /* Optimization possible here with a more complex data structure and with the removing of tiles */
         /* since the time taken by this function can only grow at the time */
 
-        opj_read_bytes(p_header_data,&l_tot_len,4);             /* Psot */
-        p_header_data+=4;
-
         /* PSot should be equal to zero or >=14 or <= 2^32-1 */
         if ((l_tot_len !=0 ) && (l_tot_len < 14) )
         {
             if (l_tot_len == 12 ) /* MSD: Special case for the PHR data which are read by kakadu*/
             {
                 opj_event_msg(p_manager, EVT_WARNING, "Empty SOT marker detected: Psot=%d.\n", l_tot_len);
             }
             else
             {
                 opj_event_msg(p_manager, EVT_ERROR, "Psot value is not correct regards to the JPEG2000 norm: %d.\n", l_tot_len);
@@ skipping 22 matching lines @@
                 };
 #endif /* USE_JPWL */
 
                 /* Ref A.4.2: Psot could be equal zero if it is the last tile-part of the codestream.*/
                 if (!l_tot_len) {
                         opj_event_msg(p_manager, EVT_INFO, "Psot value of the current tile-part is equal to zero, "
                                         "we assuming it is the last tile-part of the codestream.\n");
                         p_j2k->m_specific_param.m_decoder.m_last_tile_part = 1;
                 }
 
-                opj_read_bytes(p_header_data,&l_current_part ,1);       /* TPsot */
-                ++p_header_data;
-
-                opj_read_bytes(p_header_data,&l_num_parts ,1);          /* TNsot */
-                ++p_header_data;
-
                 if (l_num_parts != 0) { /* Number of tile-part header is provided by this tile-part header */
+                        l_num_parts += p_j2k->m_specific_param.m_decoder.m_nb_tile_parts_correction;
                         /* Useful to manage the case of textGBR.jp2 file because two values of TNSot are allowed: the correct numbers of
                          * tile-parts for that tile and zero (A.4.2 of 15444-1 : 2002). */
                         if (l_tcp->m_nb_tile_parts) {
                                 if (l_current_part >= l_tcp->m_nb_tile_parts){
                                         opj_event_msg(p_manager, EVT_ERROR, "In SOT marker, TPSot (%d) is not valid regards to the current "
                                                         "number of tile-part (%d), giving up\n", l_current_part, l_tcp->m_nb_tile_parts );
                                         p_j2k->m_specific_param.m_decoder.m_last_tile_part = 1;
                                         return OPJ_FALSE;
                                 }
                         }
@@ skipping 129 matching lines @@
                    p_j2k->cstr_info->tile[tileno].end_pos += totlen;
                    }
 
                    p_j2k->cstr_info->tile[tileno].tp[partno].tp_start_pos = p_stream_tell(p_stream) - 12;
                    p_j2k->cstr_info->tile[tileno].tp[partno].tp_end_pos =
                    p_j2k->cstr_info->tile[tileno].tp[partno].tp_start_pos + totlen - 1;
                    }*/
                 return OPJ_TRUE;
         }
 
-OPJ_BOOL opj_j2k_write_sod(     opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_write_sod(     opj_j2k_t *p_j2k,
                                                         opj_tcd_t * p_tile_coder,
                                                         OPJ_BYTE * p_data,
                                                         OPJ_UINT32 * p_data_written,
                                                         OPJ_UINT32 p_total_data_size,
                                                         const opj_stream_private_t *p_stream,
                                                         opj_event_mgr_t * p_manager
                             )
 {
         opj_codestream_info_t *l_cstr_info = 00;
         OPJ_UINT32 l_remaining_data;
@@ skipping 53 matching lines @@
         if (! opj_tcd_encode_tile(p_tile_coder, p_j2k->m_current_tile_number, p_data, p_data_written, l_remaining_data , l_cstr_info)) {
                 opj_event_msg(p_manager, EVT_ERROR, "Cannot encode tile\n");
                 return OPJ_FALSE;
         }
 
         *p_data_written += 2;
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_read_sod (opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_read_sod (opj_j2k_t *p_j2k,
                            opj_stream_private_t *p_stream,
                                                    opj_event_mgr_t * p_manager
                            )
 {
         OPJ_SIZE_T l_current_read_size;
         opj_codestream_index_t * l_cstr_index = 00;
         OPJ_BYTE ** l_current_data = 00;
         opj_tcp_t * l_tcp = 00;
         OPJ_UINT32 * l_tile_len = 00;
         OPJ_BOOL l_sot_length_pb_detected = OPJ_FALSE;
@@ skipping 27 matching lines @@
         /* Patch to support new PHR data */
         if (p_j2k->m_specific_param.m_decoder.m_sot_length) {
             /* If we are here, we'll try to read the data after allocation */
             /* Check enough bytes left in stream before allocation */
             if ((OPJ_OFF_T)p_j2k->m_specific_param.m_decoder.m_sot_length > opj_stream_get_number_byte_left(p_stream)) {
                 opj_event_msg(p_manager, EVT_ERROR, "Tile part length size inconsistent with stream length\n");
                 return OPJ_FALSE;
             }
             if (! *l_current_data) {
                 /* LH: oddly enough, in this path, l_tile_len!=0.
-                 * TODO: If this was consistant, we could simplify the code to only use realloc(), as realloc(0,...) default to malloc(0,...).
+                 * TODO: If this was consistent, we could simplify the code to only use realloc(), as realloc(0,...) default to malloc(0,...).
                  */
                 *l_current_data = (OPJ_BYTE*) opj_malloc(p_j2k->m_specific_param.m_decoder.m_sot_length);
             }
             else {
                 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) {
                         opj_free(*l_current_data);
                         /*nothing more is done as l_current_data will be set to null, and just
                           afterward we enter in the error path
                           and the actual tile_len is updated (committed) at the end of the
@@ skipping 52 matching lines @@
         }
         else {
                 p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_TPHSOT;
         }
 
         *l_tile_len += (OPJ_UINT32)l_current_read_size;
 
         return OPJ_TRUE;
 }
 
- OPJ_BOOL opj_j2k_write_rgn(opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_write_rgn(opj_j2k_t *p_j2k,
                             OPJ_UINT32 p_tile_no,
                             OPJ_UINT32 p_comp_no,
                             OPJ_UINT32 nb_comps,
                             opj_stream_private_t *p_stream,
                             opj_event_mgr_t * p_manager
                             )
 {
         OPJ_BYTE * l_current_data = 00;
         OPJ_UINT32 l_rgn_size;
         opj_cp_t *l_cp = 00;
@@ skipping 36 matching lines @@
         opj_write_bytes(l_current_data, (OPJ_UINT32)l_tccp->roishift,1);                            /* SPrgn */
         ++l_current_data;
 
         if (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_rgn_size,p_manager) != l_rgn_size) {
                 return OPJ_FALSE;
         }
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_write_eoc(     opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_write_eoc(     opj_j2k_t *p_j2k,
                             opj_stream_private_t *p_stream,
                             opj_event_mgr_t * p_manager
                             )
 {
         /* preconditions */
         assert(p_j2k != 00);
         assert(p_manager != 00);
         assert(p_stream != 00);
 
         opj_write_bytes(p_j2k->m_specific_param.m_encoder.m_header_tile_data,J2K_MS_EOC,2);                                     /* EOC */
@@ skipping 89 matching lines @@
                 return OPJ_FALSE;
         }
 
         opj_read_bytes(p_header_data,(OPJ_UINT32 *) (&(l_tcp->tccps[l_comp_no].roishift)),1);   /* SPrgn */
         ++p_header_data;
 
         return OPJ_TRUE;
 
 }
 
-OPJ_FLOAT32 opj_j2k_get_tp_stride (opj_tcp_t * p_tcp)
+static OPJ_FLOAT32 opj_j2k_get_tp_stride (opj_tcp_t * p_tcp)
 {
         return (OPJ_FLOAT32) ((p_tcp->m_nb_tile_parts - 1) * 14);
 }
 
-OPJ_FLOAT32 opj_j2k_get_default_stride (opj_tcp_t * p_tcp)
+static OPJ_FLOAT32 opj_j2k_get_default_stride (opj_tcp_t * p_tcp)
 {
     (void)p_tcp;
     return 0;
 }
 
-OPJ_BOOL opj_j2k_update_rates(  opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_update_rates(  opj_j2k_t *p_j2k,
                                                             opj_stream_private_t *p_stream,
                                                             opj_event_mgr_t * p_manager )
 {
         opj_cp_t * l_cp = 00;
         opj_image_t * l_image = 00;
         opj_tcp_t * l_tcp = 00;
         opj_image_comp_t * l_img_comp = 00;
 
         OPJ_UINT32 i,j,k;
         OPJ_INT32 l_x0,l_y0,l_x1,l_y1;
@@ skipping 142 matching lines @@
                 }
 
                 p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current =
                                 p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer;
         }
 
         return OPJ_TRUE;
 }
 
 #if 0
-OPJ_BOOL opj_j2k_read_eoc (     opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_read_eoc (     opj_j2k_t *p_j2k,
                                                         opj_stream_private_t *p_stream,
                                                         opj_event_mgr_t * p_manager )
 {
         OPJ_UINT32 i;
         opj_tcd_t * l_tcd = 00;
         OPJ_UINT32 l_nb_tiles;
         opj_tcp_t * l_tcp = 00;
         OPJ_BOOL l_success;
 
         /* preconditions */
@@ skipping 29 matching lines @@
 
                 opj_j2k_tcp_destroy(l_tcp);
                 ++l_tcp;
         }
 
         opj_tcd_destroy(l_tcd);
         return OPJ_TRUE;
 }
 #endif
 
-OPJ_BOOL opj_j2k_get_end_header(opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_get_end_header(opj_j2k_t *p_j2k,
                                                         struct opj_stream_private *p_stream,
                                                         struct opj_event_mgr * p_manager )
 {
         /* preconditions */
         assert(p_j2k != 00);
         assert(p_manager != 00);
         assert(p_stream != 00);
 
         p_j2k->cstr_index->main_head_end = opj_stream_tell(p_stream);
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_write_mct_data_group(  opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_write_mct_data_group(  opj_j2k_t *p_j2k,
                                                                         struct opj_stream_private *p_stream,
                                                                         struct opj_event_mgr * p_manager )
 {
         OPJ_UINT32 i;
         opj_simple_mcc_decorrelation_data_t * l_mcc_record;
         opj_mct_data_t * l_mct_record;
         opj_tcp_t * l_tcp;
 
         /* preconditions */
         assert(p_j2k != 00);
@@ skipping 28 matching lines @@
         }
 
         if (! opj_j2k_write_mco(p_j2k,p_stream,p_manager)) {
                 return OPJ_FALSE;
         }
 
         return OPJ_TRUE;
 }
 
 #if 0
-OPJ_BOOL opj_j2k_write_all_coc(opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_write_all_coc(opj_j2k_t *p_j2k,
                                                                         struct opj_stream_private *p_stream,
                                                                         struct opj_event_mgr * p_manager )
 {
         OPJ_UINT32 compno;
 
         /* preconditions */
         assert(p_j2k != 00);
         assert(p_manager != 00);
         assert(p_stream != 00);
 
         for (compno = 0; compno < p_j2k->m_private_image->numcomps; ++compno)
         {
                 if (! opj_j2k_write_coc(p_j2k,compno,p_stream, p_manager)) {
                         return OPJ_FALSE;
                 }
         }
 
         return OPJ_TRUE;
 }
 #endif
 
 #if 0
-OPJ_BOOL opj_j2k_write_all_qcc(opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_write_all_qcc(opj_j2k_t *p_j2k,
                                                                         struct opj_stream_private *p_stream,
                                                                         struct opj_event_mgr * p_manager )
 {
         OPJ_UINT32 compno;
 
         /* preconditions */
         assert(p_j2k != 00);
         assert(p_manager != 00);
         assert(p_stream != 00);
 
         for (compno = 0; compno < p_j2k->m_private_image->numcomps; ++compno)
         {
                 if (! opj_j2k_write_qcc(p_j2k,compno,p_stream, p_manager)) {
                         return OPJ_FALSE;
                 }
         }
 
         return OPJ_TRUE;
 }
 #endif
 
 
-OPJ_BOOL opj_j2k_write_regions( opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_write_regions( opj_j2k_t *p_j2k,
                                                         struct opj_stream_private *p_stream,
                                                         struct opj_event_mgr * p_manager )
 {
         OPJ_UINT32 compno;
         const opj_tccp_t *l_tccp = 00;
 
         /* preconditions */
         assert(p_j2k != 00);
         assert(p_manager != 00);
         assert(p_stream != 00);
 
         l_tccp = p_j2k->m_cp.tcps->tccps;
 
-        for     (compno = 0; compno < p_j2k->m_private_image->numcomps; ++compno)  {
+        for (compno = 0; compno < p_j2k->m_private_image->numcomps; ++compno)  {
                 if (l_tccp->roishift) {
 
                         if (! opj_j2k_write_rgn(p_j2k,0,compno,p_j2k->m_private_image->numcomps,p_stream,p_manager)) {
                                 return OPJ_FALSE;
                         }
                 }
 
                 ++l_tccp;
         }
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_write_epc(     opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_write_epc(     opj_j2k_t *p_j2k,
                                                 struct opj_stream_private *p_stream,
                                                 struct opj_event_mgr * p_manager )
 {
         opj_codestream_index_t * l_cstr_index = 00;
 
         /* preconditions */
         assert(p_j2k != 00);
         assert(p_manager != 00);
         assert(p_stream != 00);
 
@@ skipping 17 matching lines @@
                 jpwl_encode(p_j2k, p_stream, image);
 
         }
 #endif
   assert( 0 && "TODO" );
 #endif /* USE_JPWL */
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_read_unk (     opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_read_unk (     opj_j2k_t *p_j2k,
                                                         opj_stream_private_t *p_stream,
                                                         OPJ_UINT32 *output_marker,
                                                         opj_event_mgr_t * p_manager
                                                         )
 {
         OPJ_UINT32 l_unknown_marker;
         const opj_dec_memory_marker_handler_t * l_marker_handler;
         OPJ_UINT32 l_size_unk = 2;
 
         /* preconditions*/
         assert(p_j2k != 00);
         assert(p_manager != 00);
         assert(p_stream != 00);
 
         opj_event_msg(p_manager, EVT_WARNING, "Unknown marker\n");
 
-        while(1) {
+                for (;;) {
                 /* Try to read 2 bytes (the next marker ID) from stream and copy them into the buffer*/
                 if (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,2,p_manager) != 2) {
                         opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
                         return OPJ_FALSE;
                 }
 
                 /* read 2 bytes as the new marker ID*/
                 opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,&l_unknown_marker,2);
 
                 if (!(l_unknown_marker < 0xff00)) {
@@ skipping 24 matching lines @@
                                         l_size_unk += 2;
                         }
                 }
         }
 
         *output_marker = l_marker_handler->id ;
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_write_mct_record(      opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_write_mct_record(      opj_j2k_t *p_j2k,
                                                                 opj_mct_data_t * p_mct_record,
                                                                 struct opj_stream_private *p_stream,
                                                                 struct opj_event_mgr * p_manager )
 {
         OPJ_UINT32 l_mct_size;
         OPJ_BYTE * l_current_data = 00;
         OPJ_UINT32 l_tmp;
 
         /* preconditions */
         assert(p_j2k != 00);
@@ skipping 151 matching lines @@
                 opj_event_msg(p_manager, EVT_ERROR, "Error reading MCT marker\n");
                 return OPJ_FALSE;
         }
         memcpy(l_mct_data->m_data,p_header_data,p_header_size);
 
         l_mct_data->m_data_size = p_header_size;
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_write_mcc_record(      opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_write_mcc_record(      opj_j2k_t *p_j2k,
                                                                 struct opj_simple_mcc_decorrelation_data * p_mcc_record,
                                                                 struct opj_stream_private *p_stream,
                                                                 struct opj_event_mgr * p_manager )
 {
         OPJ_UINT32 i;
         OPJ_UINT32 l_mcc_size;
         OPJ_BYTE * l_current_data = 00;
         OPJ_UINT32 l_nb_bytes_for_comp;
         OPJ_UINT32 l_mask;
         OPJ_UINT32 l_tmcc;
@@ skipping 82 matching lines @@
         opj_write_bytes(l_current_data,l_tmcc,3);       /* Tmcci : use MCT defined as number 1 and irreversible array based. */
         l_current_data+=3;
 
         if (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_mcc_size,p_manager) != l_mcc_size) {
                 return OPJ_FALSE;
         }
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_read_mcc (     opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_read_mcc (     opj_j2k_t *p_j2k,
                                                 OPJ_BYTE * p_header_data,
                                                 OPJ_UINT32 p_header_size,
                                                 opj_event_mgr_t * p_manager )
 {
         OPJ_UINT32 i,j;
         OPJ_UINT32 l_tmp;
         OPJ_UINT32 l_indix;
         opj_tcp_t * l_tcp;
         opj_simple_mcc_decorrelation_data_t * l_mcc_record;
         opj_mct_data_t * l_mct_data;
@@ skipping 194 matching lines @@
         if (p_header_size != 0) {
                 opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
                 return OPJ_FALSE;
         }
 
         ++l_tcp->m_nb_mcc_records;
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_write_mco(     opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_write_mco(     opj_j2k_t *p_j2k,
                                                 struct opj_stream_private *p_stream,
                                                 struct opj_event_mgr * p_manager
                                   )
 {
         OPJ_BYTE * l_current_data = 00;
         OPJ_UINT32 l_mco_size;
         opj_tcp_t * l_tcp = 00;
         opj_simple_mcc_decorrelation_data_t * l_mcc_record;
         OPJ_UINT32 i;
 
         /* preconditions */
         assert(p_j2k != 00);
         assert(p_manager != 00);
         assert(p_stream != 00);
 
         l_tcp =&(p_j2k->m_cp.tcps[p_j2k->m_current_tile_number]);
-        l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
-
+        
         l_mco_size = 5 + l_tcp->m_nb_mcc_records;
         if (l_mco_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) {
 
                 OPJ_BYTE *new_header_tile_data = (OPJ_BYTE *) opj_realloc(p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_mco_size);
                 if (! new_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_size = 0;
                         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write MCO marker\n");
                         return OPJ_FALSE;
                 }
                 p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data;
                 p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_mco_size;
         }
+        l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
+
 
         opj_write_bytes(l_current_data,J2K_MS_MCO,2);                   /* MCO */
         l_current_data += 2;
 
         opj_write_bytes(l_current_data,l_mco_size-2,2);                 /* Lmco */
         l_current_data += 2;
 
-        opj_write_bytes(l_current_data,l_tcp->m_nb_mcc_records,1);      /* Nmco : only one tranform stage*/
+        opj_write_bytes(l_current_data,l_tcp->m_nb_mcc_records,1);      /* Nmco : only one transform stage*/
         ++l_current_data;
 
         l_mcc_record = l_tcp->m_mcc_records;
-        for     (i=0;i<l_tcp->m_nb_mcc_records;++i) {
+        for (i=0;i<l_tcp->m_nb_mcc_records;++i) {
                 opj_write_bytes(l_current_data,l_mcc_record->m_index,1);/* Imco -> use the mcc indicated by 1*/
                 ++l_current_data;
-
                 ++l_mcc_record;
         }
 
         if (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_mco_size,p_manager) != l_mco_size) {
                 return OPJ_FALSE;
         }
 
         return OPJ_TRUE;
 }
 
@@ skipping 25 matching lines @@
         l_image = p_j2k->m_private_image;
         l_tcp = p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH ?
                         &p_j2k->m_cp.tcps[p_j2k->m_current_tile_number] :
                         p_j2k->m_specific_param.m_decoder.m_default_tcp;
 
         if (p_header_size < 1) {
                 opj_event_msg(p_manager, EVT_ERROR, "Error reading MCO marker\n");
                 return OPJ_FALSE;
         }
 
-        opj_read_bytes(p_header_data,&l_nb_stages,1);                           /* Nmco : only one tranform stage*/
+        opj_read_bytes(p_header_data,&l_nb_stages,1);                           /* Nmco : only one transform stage*/
         ++p_header_data;
 
         if (l_nb_stages > 1) {
                 opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge multiple transformation stages.\n");
                 return OPJ_TRUE;
         }
 
         if (p_header_size != l_nb_stages + 1) {
                 opj_event_msg(p_manager, EVT_WARNING, "Error reading MCO marker\n");
                 return OPJ_FALSE;
@@ skipping 16 matching lines @@
                 ++p_header_data;
 
                 if (! opj_j2k_add_mct(l_tcp,p_j2k->m_private_image,l_tmp)) {
                         return OPJ_FALSE;
                 }
         }
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_add_mct(opj_tcp_t * p_tcp, opj_image_t * p_image, OPJ_UINT32 p_index)
+static OPJ_BOOL opj_j2k_add_mct(opj_tcp_t * p_tcp, opj_image_t * p_image, OPJ_UINT32 p_index)
 {
         OPJ_UINT32 i;
         opj_simple_mcc_decorrelation_data_t * l_mcc_record;
         opj_mct_data_t * l_deco_array, * l_offset_array;
         OPJ_UINT32 l_data_size,l_mct_size, l_offset_size;
         OPJ_UINT32 l_nb_elem;
         OPJ_UINT32 * l_offset_data, * l_current_offset_data;
         opj_tccp_t * l_tccp;
 
         /* preconditions */
@@ skipping 61 matching lines @@
                         l_tccp->m_dc_level_shift = (OPJ_INT32)*(l_current_offset_data++);
                         ++l_tccp;
                 }
 
                 opj_free(l_offset_data);
         }
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_write_cbd( opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_write_cbd( opj_j2k_t *p_j2k,
                                                 struct opj_stream_private *p_stream,
                                                 struct opj_event_mgr * p_manager )
 {
         OPJ_UINT32 i;
         OPJ_UINT32 l_cbd_size;
         OPJ_BYTE * l_current_data = 00;
         opj_image_t *l_image = 00;
         opj_image_comp_t * l_comp = 00;
 
         /* preconditions */
@@ skipping 145 matching lines @@
         /* execution list creation*/
         l_j2k->m_procedure_list = opj_procedure_list_create();
         if (! l_j2k->m_procedure_list) {
                 opj_j2k_destroy(l_j2k);
                 return NULL;
         }
 
         return l_j2k;
 }
 
-int opj_j2k_initialise_4K_poc(opj_poc_t *POC, int numres){
+static int opj_j2k_initialise_4K_poc(opj_poc_t *POC, int numres){
     POC[0].tile  = 1;
     POC[0].resno0  = 0;
     POC[0].compno0 = 0;
     POC[0].layno1  = 1;
     POC[0].resno1  = (OPJ_UINT32)(numres-1);
     POC[0].compno1 = 3;
     POC[0].prg1 = OPJ_CPRL;
     POC[1].tile  = 1;
     POC[1].resno0  = (OPJ_UINT32)(numres-1);
     POC[1].compno0 = 0;
     POC[1].layno1  = 1;
     POC[1].resno1  = (OPJ_UINT32)numres;
     POC[1].compno1 = 3;
     POC[1].prg1 = OPJ_CPRL;
     return 2;
 }
 
-void opj_j2k_set_cinema_parameters(opj_cparameters_t *parameters, opj_image_t *image, opj_event_mgr_t *p_manager)
+static void opj_j2k_set_cinema_parameters(opj_cparameters_t *parameters, opj_image_t *image, opj_event_mgr_t *p_manager)
 {
     /* Configure cinema parameters */
     int i;
 
     /* No tiling */
     parameters->tile_size_on = OPJ_FALSE;
     parameters->cp_tdx=1;
     parameters->cp_tdy=1;
 
     /* One tile part for each component */
@@ skipping 116 matching lines @@
                       "Maximum 1041666 compressed bytes @ 24fps\n"
                       "-> Specified rate exceeds this limit. Rate will be forced to 1041666 bytes.\n");
         parameters->max_comp_size = OPJ_CINEMA_24_COMP;
     }
 
     parameters->tcp_rates[0] = (OPJ_FLOAT32) (image->numcomps * image->comps[0].w * image->comps[0].h * image->comps[0].prec)/
             (OPJ_FLOAT32)(((OPJ_UINT32)parameters->max_cs_size) * 8 * image->comps[0].dx * image->comps[0].dy);
 
 }
 
-OPJ_BOOL opj_j2k_is_cinema_compliant(opj_image_t *image, OPJ_UINT16 rsiz, opj_event_mgr_t *p_manager)
+static OPJ_BOOL opj_j2k_is_cinema_compliant(opj_image_t *image, OPJ_UINT16 rsiz, opj_event_mgr_t *p_manager)
 {
     OPJ_UINT32 i;
 
     /* Number of components */
     if (image->numcomps != 3){
         opj_event_msg(p_manager, EVT_WARNING,
                 "JPEG 2000 Profile-3 (2k dc profile) requires:\n"
                 "3 components"
                 "-> Number of components of input image (%d) is not compliant\n"
                 "-> Non-profile-3 codestream will be generated\n",
@@ skipping 644 matching lines @@
         assert(p_stream != 00);
         assert(p_manager != 00);
 
         /* create an empty image header */
         p_j2k->m_private_image = opj_image_create0();
         if (! p_j2k->m_private_image) {
                 return OPJ_FALSE;
         }
 
         /* customization of the validation */
-        opj_j2k_setup_decoding_validation(p_j2k);
+        if (! opj_j2k_setup_decoding_validation(p_j2k, p_manager)) {
+                opj_image_destroy(p_j2k->m_private_image);
+                p_j2k->m_private_image = NULL;
+                return OPJ_FALSE;
+        }
 
         /* validation of the parameters codec */
         if (! opj_j2k_exec(p_j2k, p_j2k->m_validation_list, p_stream,p_manager)) {
                 opj_image_destroy(p_j2k->m_private_image);
                 p_j2k->m_private_image = NULL;
                 return OPJ_FALSE;
         }
 
         /* customization of the encoding */
-        opj_j2k_setup_header_reading(p_j2k);
+        if (! opj_j2k_setup_header_reading(p_j2k, p_manager)) {
+                opj_image_destroy(p_j2k->m_private_image);
+                p_j2k->m_private_image = NULL;
+                return OPJ_FALSE;
+        }
 
         /* read header */
         if (! opj_j2k_exec (p_j2k,p_j2k->m_procedure_list,p_stream,p_manager)) {
                 opj_image_destroy(p_j2k->m_private_image);
                 p_j2k->m_private_image = NULL;
                 return OPJ_FALSE;
         }
 
         *p_image = opj_image_create0();
         if (! (*p_image)) {
                 return OPJ_FALSE;
         }
 
         /* Copy codestream image information to the output image */
         opj_copy_image_header(p_j2k->m_private_image, *p_image);
 
     /*Allocate and initialize some elements of codestrem index*/
         if (!opj_j2k_allocate_tile_element_cstr_index(p_j2k)){
                 return OPJ_FALSE;
         }
 
         return OPJ_TRUE;
 }
 
-void opj_j2k_setup_header_reading (opj_j2k_t *p_j2k)
+static OPJ_BOOL opj_j2k_setup_header_reading (opj_j2k_t *p_j2k, opj_event_mgr_t * p_manager)
 {
         /* preconditions*/
         assert(p_j2k != 00);
+        assert(p_manager != 00);
 
-        opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_read_header_procedure);
+        if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_read_header_procedure, p_manager)) {
+                return OPJ_FALSE;
+        }
 
         /* DEVELOPER CORNER, add your custom procedures */
-        opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_copy_default_tcp_and_create_tcd);
-
+        if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_copy_default_tcp_and_create_tcd, p_manager))  {
+                return OPJ_FALSE;
+        }
+        
+        return OPJ_TRUE;
 }
 
-void opj_j2k_setup_decoding_validation (opj_j2k_t *p_j2k)
+static OPJ_BOOL opj_j2k_setup_decoding_validation (opj_j2k_t *p_j2k, opj_event_mgr_t * p_manager)
 {
         /* preconditions*/
         assert(p_j2k != 00);
+        assert(p_manager != 00);
 
-        opj_procedure_list_add_procedure(p_j2k->m_validation_list, (opj_procedure)opj_j2k_build_decoder);
-        opj_procedure_list_add_procedure(p_j2k->m_validation_list, (opj_procedure)opj_j2k_decoding_validation);
+        if (! opj_procedure_list_add_procedure(p_j2k->m_validation_list,(opj_procedure)opj_j2k_build_decoder, p_manager)) {
+                return OPJ_FALSE;
+        }
+        if (! opj_procedure_list_add_procedure(p_j2k->m_validation_list,(opj_procedure)opj_j2k_decoding_validation, p_manager)) {
+                return OPJ_FALSE;
+        }
+
         /* DEVELOPER CORNER, add your custom validation procedure */
-
+        return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_mct_validation (       opj_j2k_t * p_j2k,
+static OPJ_BOOL opj_j2k_mct_validation (       opj_j2k_t * p_j2k,
                                                                 opj_stream_private_t *p_stream,
                                                                 opj_event_mgr_t * p_manager )
 {
         OPJ_BOOL l_is_valid = OPJ_TRUE;
         OPJ_UINT32 i,j;
 
         /* preconditions */
         assert(p_j2k != 00);
         assert(p_stream != 00);
         assert(p_manager != 00);
@@ skipping 165 matching lines @@
         l_mcc_data->m_decorrelation_array = l_mct_deco_data;
         l_mcc_data->m_is_irreversible = 1;
         l_mcc_data->m_nb_comps = p_image->numcomps;
         l_mcc_data->m_index = l_indix++;
         l_mcc_data->m_offset_array = l_mct_offset_data;
         ++p_tcp->m_nb_mcc_records;
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_build_decoder (opj_j2k_t * p_j2k,
+static OPJ_BOOL opj_j2k_build_decoder (opj_j2k_t * p_j2k,
                                                             opj_stream_private_t *p_stream,
                                                             opj_event_mgr_t * p_manager )
 {
         /* add here initialization of cp
            copy paste of setup_decoder */
   (void)p_j2k;
   (void)p_stream;
   (void)p_manager;
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_build_encoder (opj_j2k_t * p_j2k,
+static OPJ_BOOL opj_j2k_build_encoder (opj_j2k_t * p_j2k,
                                                         opj_stream_private_t *p_stream,
                                                         opj_event_mgr_t * p_manager )
 {
         /* add here initialization of cp
            copy paste of setup_encoder */
   (void)p_j2k;
   (void)p_stream;
   (void)p_manager;
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_encoding_validation (  opj_j2k_t * p_j2k,
+static OPJ_BOOL opj_j2k_encoding_validation (  opj_j2k_t * p_j2k,
                                                                             opj_stream_private_t *p_stream,
                                                                             opj_event_mgr_t * p_manager )
 {
         OPJ_BOOL l_is_valid = OPJ_TRUE;
 
         /* preconditions */
         assert(p_j2k != 00);
         assert(p_stream != 00);
         assert(p_manager != 00);
 
@@ skipping 22 matching lines @@
 
         if ((p_j2k->m_cp.tdy) < (OPJ_UINT32) (1 << (p_j2k->m_cp.tcps->tccps->numresolutions - 1U))) {
                 opj_event_msg(p_manager, EVT_ERROR, "Number of resolutions is too high in comparison to the size of tiles\n");
                 return OPJ_FALSE;
         }
 
         /* PARAMETER VALIDATION */
         return l_is_valid;
 }
 
-OPJ_BOOL opj_j2k_decoding_validation (  opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_decoding_validation (  opj_j2k_t *p_j2k,
                                         opj_stream_private_t *p_stream,
                                         opj_event_mgr_t * p_manager
                                         )
 {
         OPJ_BOOL l_is_valid = OPJ_TRUE;
 
         /* preconditions*/
         assert(p_j2k != 00);
         assert(p_stream != 00);
         assert(p_manager != 00);
 
         /* STATE checking */
         /* make sure the state is at 0 */
 #ifdef TODO_MSD
         l_is_valid &= (p_j2k->m_specific_param.m_decoder.m_state == J2K_DEC_STATE_NONE);
 #endif
         l_is_valid &= (p_j2k->m_specific_param.m_decoder.m_state == 0x0000);
 
         /* POINTER validation */
         /* make sure a p_j2k codec is present */
         /* make sure a procedure list is present */
         l_is_valid &= (p_j2k->m_procedure_list != 00);
         /* make sure a validation list is present */
         l_is_valid &= (p_j2k->m_validation_list != 00);
 
         /* PARAMETER VALIDATION */
         return l_is_valid;
 }
 
-OPJ_BOOL opj_j2k_read_header_procedure( opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_read_header_procedure( opj_j2k_t *p_j2k,
                                                                             opj_stream_private_t *p_stream,
                                                                             opj_event_mgr_t * p_manager)
 {
         OPJ_UINT32 l_current_marker;
         OPJ_UINT32 l_marker_size;
         const opj_dec_memory_marker_handler_t * l_marker_handler = 00;
         OPJ_BOOL l_has_siz = 0;
         OPJ_BOOL l_has_cod = 0;
         OPJ_BOOL l_has_qcd = 0;
 
@@ skipping 125 matching lines @@
             return OPJ_FALSE;
         }
         if (l_has_cod == 0) {
             opj_event_msg(p_manager, EVT_ERROR, "required COD marker not found in main header\n");
             return OPJ_FALSE;
         }
         if (l_has_qcd == 0) {
             opj_event_msg(p_manager, EVT_ERROR, "required QCD marker not found in main header\n");
             return OPJ_FALSE;
         }
+        
+        if (! opj_j2k_merge_ppm(&(p_j2k->m_cp), p_manager)) {
+            opj_event_msg(p_manager, EVT_ERROR, "Failed to merge PPM data\n");
+            return OPJ_FALSE;
+        }
 
         opj_event_msg(p_manager, EVT_INFO, "Main header has been correctly decoded.\n");
 
         /* Position of the last element if the main header */
         p_j2k->cstr_index->main_head_end = (OPJ_UINT32) opj_stream_tell(p_stream) - 2;
 
         /* Next step: read a tile-part header */
         p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_TPHSOT;
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_exec ( opj_j2k_t * p_j2k,
+static OPJ_BOOL opj_j2k_exec ( opj_j2k_t * p_j2k,
                                         opj_procedure_list_t * p_procedure_list,
                                         opj_stream_private_t *p_stream,
                                         opj_event_mgr_t * p_manager )
 {
         OPJ_BOOL (** l_procedure) (opj_j2k_t * ,opj_stream_private_t *,opj_event_mgr_t *) = 00;
         OPJ_BOOL l_result = OPJ_TRUE;
         OPJ_UINT32 l_nb_proc, i;
 
         /* preconditions*/
         assert(p_procedure_list != 00);
@@ skipping 147 matching lines @@
         if ( !opj_tcd_init(p_j2k->m_tcd, l_image, &(p_j2k->m_cp)) ) {
                 opj_tcd_destroy(p_j2k->m_tcd);
                 p_j2k->m_tcd = 00;
                 opj_event_msg(p_manager, EVT_ERROR, "Cannot decode tile, memory error\n");
                 return OPJ_FALSE;
         }
 
         return OPJ_TRUE;
 }
 
-const opj_dec_memory_marker_handler_t * opj_j2k_get_marker_handler (OPJ_UINT32 p_id)
+static const opj_dec_memory_marker_handler_t * opj_j2k_get_marker_handler (OPJ_UINT32 p_id)
 {
         const opj_dec_memory_marker_handler_t *e;
         for (e = j2k_memory_marker_handler_tab; e->id != 0; ++e) {
                 if (e->id == p_id) {
                         break; /* we find a handler corresponding to the marker ID*/
                 }
         }
         return e;
 }
 
@@ skipping 92 matching lines @@
                         }
 
                         opj_free( p_cstr_ind->tile_index);
                         p_cstr_ind->tile_index = NULL;
                 }
 
                 opj_free(p_cstr_ind);
         }
 }
 
-void opj_j2k_tcp_destroy (opj_tcp_t *p_tcp)
+static void opj_j2k_tcp_destroy (opj_tcp_t *p_tcp)
 {
-        if (p_tcp == 00) {
-                return;
-        }
+        if (p_tcp == 00) {
+                return;
+        }
+        
+        if (p_tcp->ppt_markers != 00) {
+                OPJ_UINT32 i;
+                for (i = 0U; i < p_tcp->ppt_markers_count; ++i) {
+                        if (p_tcp->ppt_markers[i].m_data != NULL) {
+                                opj_free(p_tcp->ppt_markers[i].m_data);
+                        }
+                }
+                p_tcp->ppt_markers_count = 0U;
+                opj_free(p_tcp->ppt_markers);
+                p_tcp->ppt_markers = NULL;
+        }
+        
+        if (p_tcp->ppt_buffer != 00) {
+                opj_free(p_tcp->ppt_buffer);
+                p_tcp->ppt_buffer = 00;
+        }
+        
+        if (p_tcp->tccps != 00) {
+                opj_free(p_tcp->tccps);
+                p_tcp->tccps = 00;
+        }
+        
+        if (p_tcp->m_mct_coding_matrix != 00) {
+                opj_free(p_tcp->m_mct_coding_matrix);
+                p_tcp->m_mct_coding_matrix = 00;
+        }
+        
+        if (p_tcp->m_mct_decoding_matrix != 00) {
+                opj_free(p_tcp->m_mct_decoding_matrix);
+                p_tcp->m_mct_decoding_matrix = 00;
+        }
+        
+        if (p_tcp->m_mcc_records) {
+                opj_free(p_tcp->m_mcc_records);
+                p_tcp->m_mcc_records = 00;
+                p_tcp->m_nb_max_mcc_records = 0;
+                p_tcp->m_nb_mcc_records = 0;
+        }
+        
+        if (p_tcp->m_mct_records) {
+                opj_mct_data_t * l_mct_data = p_tcp->m_mct_records;
+                OPJ_UINT32 i;
+                
+                for (i=0;i<p_tcp->m_nb_mct_records;++i) {
+                        if (l_mct_data->m_data) {
+                                opj_free(l_mct_data->m_data);
+                                l_mct_data->m_data = 00;
+                        }
+                        
+                        ++l_mct_data;
+                }
+                
+                opj_free(p_tcp->m_mct_records);
+                p_tcp->m_mct_records = 00;
+        }
 
-        if (p_tcp->ppt_buffer != 00) {
-                opj_free(p_tcp->ppt_buffer);
-                p_tcp->ppt_buffer = 00;
-        }
+        if (p_tcp->mct_norms != 00) {
+                opj_free(p_tcp->mct_norms);
+                p_tcp->mct_norms = 00;
+        }
 
-        if (p_tcp->tccps != 00) {
-                opj_free(p_tcp->tccps);
-                p_tcp->tccps = 00;
-        }
-
-        if (p_tcp->m_mct_coding_matrix != 00) {
-                opj_free(p_tcp->m_mct_coding_matrix);
-                p_tcp->m_mct_coding_matrix = 00;
-        }
-
-        if (p_tcp->m_mct_decoding_matrix != 00) {
-                opj_free(p_tcp->m_mct_decoding_matrix);
-                p_tcp->m_mct_decoding_matrix = 00;
-        }
-
-        if (p_tcp->m_mcc_records) {
-                opj_free(p_tcp->m_mcc_records);
-                p_tcp->m_mcc_records = 00;
-                p_tcp->m_nb_max_mcc_records = 0;
-                p_tcp->m_nb_mcc_records = 0;
-        }
-
-        if (p_tcp->m_mct_records) {
-                opj_mct_data_t * l_mct_data = p_tcp->m_mct_records;
-                OPJ_UINT32 i;
-
-                for (i=0;i<p_tcp->m_nb_mct_records;++i) {
-                        if (l_mct_data->m_data) {
-                                opj_free(l_mct_data->m_data);
-                                l_mct_data->m_data = 00;
-                        }
-
-                        ++l_mct_data;
-                }
-
-                opj_free(p_tcp->m_mct_records);
-                p_tcp->m_mct_records = 00;
-        }
-
-        if (p_tcp->mct_norms != 00) {
-                opj_free(p_tcp->mct_norms);
-                p_tcp->mct_norms = 00;
-        }
-
-        opj_j2k_tcp_data_destroy(p_tcp);
+        opj_j2k_tcp_data_destroy(p_tcp);
 
 }
 
-void opj_j2k_tcp_data_destroy (opj_tcp_t *p_tcp)
+static void opj_j2k_tcp_data_destroy (opj_tcp_t *p_tcp)
 {
         if (p_tcp->m_data) {
                 opj_free(p_tcp->m_data);
                 p_tcp->m_data = NULL;
                 p_tcp->m_data_size = 0;
         }
 }
 
-void opj_j2k_cp_destroy (opj_cp_t *p_cp)
+static void opj_j2k_cp_destroy (opj_cp_t *p_cp)
 {
-        OPJ_UINT32 l_nb_tiles;
-        opj_tcp_t * l_current_tile = 00;
-        OPJ_UINT32 i;
+        OPJ_UINT32 l_nb_tiles;
+        opj_tcp_t * l_current_tile = 00;
 
-        if (p_cp == 00)
-        {
-                return;
-        }
-        if (p_cp->tcps != 00)
-        {
-                l_current_tile = p_cp->tcps;
-                l_nb_tiles = p_cp->th * p_cp->tw;
+        if (p_cp == 00)
+        {
+                return;
+        }
+        if (p_cp->tcps != 00)
+        {
+                OPJ_UINT32 i;
+                l_current_tile = p_cp->tcps;
+                l_nb_tiles = p_cp->th * p_cp->tw;
+                
+                for (i = 0U; i < l_nb_tiles; ++i)
+                {
+                        opj_j2k_tcp_destroy(l_current_tile);
+                        ++l_current_tile;
+                }
+                opj_free(p_cp->tcps);
+                p_cp->tcps = 00;
+        }
+        if (p_cp->ppm_markers != 00) {
+                OPJ_UINT32 i;
+                for (i = 0U; i < p_cp->ppm_markers_count; ++i) {
+                        if (p_cp->ppm_markers[i].m_data != NULL) {
+                                opj_free(p_cp->ppm_markers[i].m_data);
+                        }
+                }
+                p_cp->ppm_markers_count = 0U;
+                opj_free(p_cp->ppm_markers);
+                p_cp->ppm_markers = NULL;
+        }
+        opj_free(p_cp->ppm_buffer);
+        p_cp->ppm_buffer = 00;
+        p_cp->ppm_data = NULL; /* ppm_data belongs to the allocated buffer pointed by ppm_buffer */
+        opj_free(p_cp->comment);
+        p_cp->comment = 00;
+        if (! p_cp->m_is_decoder)
+        {
+                opj_free(p_cp->m_specific_param.m_enc.m_matrice);
+                p_cp->m_specific_param.m_enc.m_matrice = 00;
+        }
+}
 
-                for (i = 0; i < l_nb_tiles; ++i)
-                {
-                        opj_j2k_tcp_destroy(l_current_tile);
-                        ++l_current_tile;
-                }
-                opj_free(p_cp->tcps);
-                p_cp->tcps = 00;
-        }
-        opj_free(p_cp->ppm_buffer);
-        p_cp->ppm_buffer = 00;
-        p_cp->ppm_data = NULL; /* ppm_data belongs to the allocated buffer pointed by ppm_buffer */
-        opj_free(p_cp->comment);
-        p_cp->comment = 00;
-        if (! p_cp->m_is_decoder)
-        {
-                opj_free(p_cp->m_specific_param.m_enc.m_matrice);
-                p_cp->m_specific_param.m_enc.m_matrice = 00;
-        }
+static OPJ_BOOL opj_j2k_need_nb_tile_parts_correction(opj_stream_private_t *p_stream, OPJ_UINT32 tile_no, OPJ_BOOL* p_correction_needed, opj_event_mgr_t * p_manager )
+{
+        OPJ_BYTE   l_header_data[10];
+        OPJ_OFF_T  l_stream_pos_backup;
+        OPJ_UINT32 l_current_marker;
+        OPJ_UINT32 l_marker_size;
+        OPJ_UINT32 l_tile_no, l_tot_len, l_current_part, l_num_parts;
+        
+        /* initialize to no correction needed */
+        *p_correction_needed = OPJ_FALSE;
+        
+        l_stream_pos_backup = opj_stream_tell(p_stream);
+        if (l_stream_pos_backup == -1) {
+                /* let's do nothing */
+                return OPJ_TRUE;
+        }
+        
+        for (;;) {
+                /* Try to read 2 bytes (the next marker ID) from stream and copy them into the buffer */
+                if (opj_stream_read_data(p_stream,l_header_data, 2, p_manager) != 2) {
+                        /* assume all is OK */
+                        if (! opj_stream_seek(p_stream, l_stream_pos_backup, p_manager)) {
+                                return OPJ_FALSE;
+                        }
+                        return OPJ_TRUE;
+                }
+                
+                /* Read 2 bytes from buffer as the new marker ID */
+                opj_read_bytes(l_header_data, &l_current_marker, 2);
+                
+                if (l_current_marker != J2K_MS_SOT) {
+                        /* assume all is OK */
+                        if (! opj_stream_seek(p_stream, l_stream_pos_backup, p_manager)) {
+                                return OPJ_FALSE;
+                        }
+                        return OPJ_TRUE;
+                }
+                
+                /* Try to read 2 bytes (the marker size) from stream and copy them into the buffer */
+                if (opj_stream_read_data(p_stream, l_header_data, 2, p_manager) != 2) {
+                        opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
+                        return OPJ_FALSE;
+                }
+                
+                /* Read 2 bytes from the buffer as the marker size */
+                opj_read_bytes(l_header_data, &l_marker_size, 2);
+                
+                /* Check marker size for SOT Marker */
+                if (l_marker_size != 10) {
+                        opj_event_msg(p_manager, EVT_ERROR, "Inconsistent marker size\n");
+                        return OPJ_FALSE;
+                }
+                l_marker_size -= 2;
+                
+                if (opj_stream_read_data(p_stream, l_header_data, l_marker_size, p_manager) != l_marker_size) {
+                        opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
+                        return OPJ_FALSE;
+                }
+                
+                if (! opj_j2k_get_sot_values(l_header_data, l_marker_size, &l_tile_no, &l_tot_len, &l_current_part, &l_num_parts, p_manager)) {
+                        return OPJ_FALSE;
+                }
+                
+                if (l_tile_no == tile_no) {
+                        /* we found what we were looking for */
+                        break;
+                }
+                
+                if ((l_tot_len == 0U) || (l_tot_len < 14U)) {
+                        /* last SOT until EOC or invalid Psot value */
+                        /* assume all is OK */
+                        if (! opj_stream_seek(p_stream, l_stream_pos_backup, p_manager)) {
+                                return OPJ_FALSE;
+                        }
+                        return OPJ_TRUE;
+                }
+                l_tot_len -= 12U;
+                /* look for next SOT marker */
+                if (opj_stream_skip(p_stream, (OPJ_OFF_T)(l_tot_len), p_manager) != (OPJ_OFF_T)(l_tot_len)) {
+                        /* assume all is OK */
+                        if (! opj_stream_seek(p_stream, l_stream_pos_backup, p_manager)) {
+                                return OPJ_FALSE;
+                        }
+                        return OPJ_TRUE;
+                }
+        }
+        
+        /* check for correction */
+        if (l_current_part == l_num_parts) {
+                *p_correction_needed = OPJ_TRUE;
+        }
+        
+        if (! opj_stream_seek(p_stream, l_stream_pos_backup, p_manager)) {
+                return OPJ_FALSE;
+        }
+        return OPJ_TRUE;
 }
 
 OPJ_BOOL opj_j2k_read_tile_header(      opj_j2k_t * p_j2k,
                                                                     OPJ_UINT32 * p_tile_index,
                                                                     OPJ_UINT32 * p_data_size,
                                                                     OPJ_INT32 * p_tile_x0, OPJ_INT32 * p_tile_y0,
                                                                     OPJ_INT32 * p_tile_x1, OPJ_INT32 * p_tile_y1,
                                                                     OPJ_UINT32 * p_nb_comps,
                                                                     OPJ_BOOL * p_go_on,
                                                                     opj_stream_private_t *p_stream,
                                                                     opj_event_mgr_t * p_manager )
 {
         OPJ_UINT32 l_current_marker = J2K_MS_SOT;
         OPJ_UINT32 l_marker_size;
         const opj_dec_memory_marker_handler_t * l_marker_handler = 00;
         opj_tcp_t * l_tcp = NULL;
-        OPJ_UINT32 l_nb_tiles;
 
         /* preconditions */
         assert(p_stream != 00);
         assert(p_j2k != 00);
         assert(p_manager != 00);
 
         /* Reach the End Of Codestream ?*/
         if (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_EOC){
                 l_current_marker = J2K_MS_EOC;
         }
@@ skipping 129 matching lines @@
                 if(opj_stream_get_number_byte_left(p_stream) == 0
                     && p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_NEOC)
                     break;
 
                 /* If we didn't skip data before, we need to read the SOD marker*/
                 if (! p_j2k->m_specific_param.m_decoder.m_skip_data) {
                         /* Try to read the SOD marker and skip data ? FIXME */
                         if (! opj_j2k_read_sod(p_j2k, p_stream, p_manager)) {
                                 return OPJ_FALSE;
                         }
+                        if (p_j2k->m_specific_param.m_decoder.m_can_decode && !p_j2k->m_specific_param.m_decoder.m_nb_tile_parts_correction_checked) {
+                                /* Issue 254 */
+                                OPJ_BOOL l_correction_needed;
+                                                                                                        
+                                p_j2k->m_specific_param.m_decoder.m_nb_tile_parts_correction_checked = 1;
+                                if(!opj_j2k_need_nb_tile_parts_correction(p_stream, p_j2k->m_current_tile_number, &l_correction_needed, p_manager)) {
+                                        opj_event_msg(p_manager, EVT_ERROR, "opj_j2k_apply_nb_tile_parts_correction error\n");
+                                        return OPJ_FALSE;
+                                }
+                                if (l_correction_needed) {
+                                        OPJ_UINT32 l_nb_tiles = p_j2k->m_cp.tw * p_j2k->m_cp.th;
+                                        OPJ_UINT32 l_tile_no;
 
+                                        p_j2k->m_specific_param.m_decoder.m_can_decode = 0;
+                                        p_j2k->m_specific_param.m_decoder.m_nb_tile_parts_correction = 1;
+                                        /* correct tiles */
+                                        for (l_tile_no = 0U; l_tile_no < l_nb_tiles; ++l_tile_no) {
+                                                if (p_j2k->m_cp.tcps[l_tile_no].m_nb_tile_parts != 0U) {
+                                                        p_j2k->m_cp.tcps[l_tile_no].m_nb_tile_parts+=1;
+                                                }
+                                        }
+                                        opj_event_msg(p_manager, EVT_WARNING, "Non conformant codestream TPsot==TNsot.\n");
+                                }
+                        }
                         if (! p_j2k->m_specific_param.m_decoder.m_can_decode){
                                 /* Try to read 2 bytes (the next marker ID) from stream and copy them into the buffer */
                                 if (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,2,p_manager) != 2) {
                                         opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
                                         return OPJ_FALSE;
                                 }
 
                                 /* Read 2 bytes from buffer as the new marker ID */
                                 opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,&l_current_marker,2);
                         }
@@ skipping 18 matching lines @@
         /* Current marker is the EOC marker ?*/
         if (l_current_marker == J2K_MS_EOC) {
                 if (p_j2k->m_specific_param.m_decoder.m_state != J2K_STATE_EOC ){
                         p_j2k->m_current_tile_number = 0;
                         p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_EOC;
                 }
         }
 
         /* FIXME DOC ???*/
         if ( ! p_j2k->m_specific_param.m_decoder.m_can_decode) {
+                OPJ_UINT32 l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
                 l_tcp = p_j2k->m_cp.tcps + p_j2k->m_current_tile_number;
-                l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
 
                 while( (p_j2k->m_current_tile_number < l_nb_tiles) && (l_tcp->m_data == 00) ) {
                         ++p_j2k->m_current_tile_number;
                         ++l_tcp;
                 }
 
                 if (p_j2k->m_current_tile_number == l_nb_tiles) {
                         *p_go_on = OPJ_FALSE;
                         return OPJ_TRUE;
                 }
         }
 
+        if (! opj_j2k_merge_ppt(p_j2k->m_cp.tcps + p_j2k->m_current_tile_number, p_manager)) {
+                opj_event_msg(p_manager, EVT_ERROR, "Failed to merge PPT data\n");
+                return OPJ_FALSE;
+        }
         /*FIXME ???*/
-        if (! opj_tcd_init_decode_tile(p_j2k->m_tcd, p_j2k->m_current_tile_number)) {
+        if (! opj_tcd_init_decode_tile(p_j2k->m_tcd, p_j2k->m_current_tile_number, p_manager)) {
                 opj_event_msg(p_manager, EVT_ERROR, "Cannot decode tile, memory error\n");
                 return OPJ_FALSE;
         }
 
         opj_event_msg(p_manager, EVT_INFO, "Header of tile %d / %d has been read.\n",
                         p_j2k->m_current_tile_number+1, (p_j2k->m_cp.th * p_j2k->m_cp.tw));
 
         *p_tile_index = p_j2k->m_current_tile_number;
         *p_go_on = OPJ_TRUE;
         *p_data_size = opj_tcd_get_decoded_tile_size(p_j2k->m_tcd);
@@ skipping 32 matching lines @@
         l_tcp = &(p_j2k->m_cp.tcps[p_tile_index]);
         if (! l_tcp->m_data) {
                 opj_j2k_tcp_destroy(l_tcp);
                 return OPJ_FALSE;
         }
 
         if (! opj_tcd_decode_tile(      p_j2k->m_tcd,
                                                                 l_tcp->m_data,
                                                                 l_tcp->m_data_size,
                                                                 p_tile_index,
-                                                                p_j2k->cstr_index) ) {
+                                                                p_j2k->cstr_index, p_manager) ) {
                 opj_j2k_tcp_destroy(l_tcp);
                 p_j2k->m_specific_param.m_decoder.m_state |= 0x8000;/*FIXME J2K_DEC_STATE_ERR;*/
                 opj_event_msg(p_manager, EVT_ERROR, "Failed to decode.\n");
                 return OPJ_FALSE;
         }
 
         if (! opj_tcd_update_tile_data(p_j2k->m_tcd,p_data,p_data_size)) {
                 return OPJ_FALSE;
         }
 
@@ skipping 31 matching lines @@
                             return OPJ_TRUE;
                         }
                         opj_event_msg(p_manager, EVT_ERROR, "Stream too short, expected SOT\n");
                         return OPJ_FALSE;
                 }
         }
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_update_image_data (opj_tcd_t * p_tcd, OPJ_BYTE * p_data, opj_image_t* p_output_image)
+static OPJ_BOOL opj_j2k_update_image_data (opj_tcd_t * p_tcd, OPJ_BYTE * p_data, opj_image_t* p_output_image)
 {
         OPJ_UINT32 i,j,k = 0;
         OPJ_UINT32 l_width_src,l_height_src;
         OPJ_UINT32 l_width_dest,l_height_dest;
         OPJ_INT32 l_offset_x0_src, l_offset_y0_src, l_offset_x1_src, l_offset_y1_src;
-        OPJ_INT32 l_start_offset_src, l_line_offset_src, l_end_offset_src ;
+        OPJ_SIZE_T l_start_offset_src, l_line_offset_src, l_end_offset_src ;
         OPJ_UINT32 l_start_x_dest , l_start_y_dest;
         OPJ_UINT32 l_x0_dest, l_y0_dest, l_x1_dest, l_y1_dest;
-        OPJ_INT32 l_start_offset_dest, l_line_offset_dest;
+        OPJ_SIZE_T l_start_offset_dest, l_line_offset_dest;
 
         opj_image_comp_t * l_img_comp_src = 00;
         opj_image_comp_t * l_img_comp_dest = 00;
 
         opj_tcd_tilecomp_t * l_tilec = 00;
         opj_image_t * l_image_src = 00;
         OPJ_UINT32 l_size_comp, l_remaining;
         OPJ_INT32 * l_dest_ptr;
         opj_tcd_resolution_t* l_res= 00;
 
         l_tilec = p_tcd->tcd_image->tiles->comps;
         l_image_src = p_tcd->image;
         l_img_comp_src = l_image_src->comps;
 
         l_img_comp_dest = p_output_image->comps;
 
         for (i=0; i<l_image_src->numcomps; i++) {
 
                 /* Allocate output component buffer if necessary */
                 if (!l_img_comp_dest->data) {
                     OPJ_UINT32 width = l_img_comp_dest->w;
                     OPJ_UINT32 height = l_img_comp_dest->h;
                     const OPJ_UINT32 MAX_SIZE = UINT32_MAX / sizeof(OPJ_INT32);
                     if (height == 0 || width > MAX_SIZE / height) {
                         return OPJ_FALSE;
-                    } 
-                    l_img_comp_dest->data = (OPJ_INT32*) opj_calloc(width * height, sizeof(OPJ_INT32));
+                    }
+                    l_img_comp_dest->data = (OPJ_INT32*)opj_calloc(width * height, sizeof(OPJ_INT32));
                     if (!l_img_comp_dest->data) {
                         return OPJ_FALSE;
                     }
                 }
 
                 /* Copy info from decoded comp image to output image */
                 l_img_comp_dest->resno_decoded = l_img_comp_src->resno_decoded;
 
                 /*-----*/
                 /* Compute the precision of the output buffer */
@@ skipping 13 matching lines @@
                 /* Current tile component size*/
                 /*if (i == 0) {
                 fprintf(stdout, "SRC: l_res_x0=%d, l_res_x1=%d, l_res_y0=%d, l_res_y1=%d\n",
                                 l_res->x0, l_res->x1, l_res->y0, l_res->y1);
                 }*/
 
                 l_width_src = (OPJ_UINT32)(l_res->x1 - l_res->x0);
                 l_height_src = (OPJ_UINT32)(l_res->y1 - l_res->y0);
 
                 /* Border of the current output component*/
-                l_x0_dest = (OPJ_UINT32)opj_int_ceildivpow2((OPJ_INT32)l_img_comp_dest->x0, (OPJ_INT32)l_img_comp_dest->factor);
-                l_y0_dest = (OPJ_UINT32)opj_int_ceildivpow2((OPJ_INT32)l_img_comp_dest->y0, (OPJ_INT32)l_img_comp_dest->factor);
-                l_x1_dest = l_x0_dest + l_img_comp_dest->w;
+                l_x0_dest = opj_uint_ceildivpow2(l_img_comp_dest->x0, l_img_comp_dest->factor);
+                l_y0_dest = opj_uint_ceildivpow2(l_img_comp_dest->y0, l_img_comp_dest->factor);
+                l_x1_dest = l_x0_dest + l_img_comp_dest->w; /* can't overflow given that image->x1 is uint32 */
                 l_y1_dest = l_y0_dest + l_img_comp_dest->h;
 
                 /*if (i == 0) {
                 fprintf(stdout, "DEST: l_x0_dest=%d, l_x1_dest=%d, l_y0_dest=%d, l_y1_dest=%d (%d)\n",
                                 l_x0_dest, l_x1_dest, l_y0_dest, l_y1_dest, l_img_comp_dest->factor );
                 }*/
 
                 /*-----*/
                 /* Compute the area (l_offset_x0_src, l_offset_y0_src, l_offset_x1_src, l_offset_y1_src)
                  * of the input buffer (decoded tile component) which will be move
@@ skipping 10 matching lines @@
                         if ( l_x1_dest >= (OPJ_UINT32)l_res->x1 ) {
                                 l_width_dest = l_width_src;
                                 l_offset_x1_src = 0;
                         }
                         else {
                                 l_width_dest = l_x1_dest - (OPJ_UINT32)l_res->x0 ;
                                 l_offset_x1_src = (OPJ_INT32)(l_width_src - l_width_dest);
                         }
                 }
                 else {
-                        l_start_x_dest = 0 ;
+                        l_start_x_dest = 0U;
                         l_offset_x0_src = (OPJ_INT32)l_x0_dest - l_res->x0;
 
                         if ( l_x1_dest >= (OPJ_UINT32)l_res->x1 ) {
                                 l_width_dest = l_width_src - (OPJ_UINT32)l_offset_x0_src;
                                 l_offset_x1_src = 0;
                         }
                         else {
                                 l_width_dest = l_img_comp_dest->w ;
                                 l_offset_x1_src = l_res->x1 - (OPJ_INT32)l_x1_dest;
                         }
                 }
 
                 if ( l_y0_dest < (OPJ_UINT32)l_res->y0 ) {
                         l_start_y_dest = (OPJ_UINT32)l_res->y0 - l_y0_dest;
                         l_offset_y0_src = 0;
 
                         if ( l_y1_dest >= (OPJ_UINT32)l_res->y1 ) {
                                 l_height_dest = l_height_src;
                                 l_offset_y1_src = 0;
                         }
                         else {
                                 l_height_dest = l_y1_dest - (OPJ_UINT32)l_res->y0 ;
                                 l_offset_y1_src =  (OPJ_INT32)(l_height_src - l_height_dest);
                         }
                 }
                 else {
-                        l_start_y_dest = 0 ;
+                        l_start_y_dest = 0U;
                         l_offset_y0_src = (OPJ_INT32)l_y0_dest - l_res->y0;
 
                         if ( l_y1_dest >= (OPJ_UINT32)l_res->y1 ) {
                                 l_height_dest = l_height_src - (OPJ_UINT32)l_offset_y0_src;
                                 l_offset_y1_src = 0;
                         }
                         else {
                                 l_height_dest = l_img_comp_dest->h ;
                                 l_offset_y1_src = l_res->y1 - (OPJ_INT32)l_y1_dest;
                         }
                 }
 
                 if( (l_offset_x0_src < 0 ) || (l_offset_y0_src < 0 ) || (l_offset_x1_src < 0 ) || (l_offset_y1_src < 0 ) ){
                         return OPJ_FALSE;
                 }
                 /* testcase 2977.pdf.asan.67.2198 */
                 if ((OPJ_INT32)l_width_dest < 0 || (OPJ_INT32)l_height_dest < 0) {
                         return OPJ_FALSE;
                 }
                 /*-----*/
 
                 /* Compute the input buffer offset */
-                l_start_offset_src = l_offset_x0_src + l_offset_y0_src * (OPJ_INT32)l_width_src;
-                l_line_offset_src = l_offset_x1_src + l_offset_x0_src;
-                l_end_offset_src = l_offset_y1_src * (OPJ_INT32)l_width_src - l_offset_x0_src;
+                l_start_offset_src = (OPJ_SIZE_T)l_offset_x0_src + (OPJ_SIZE_T)l_offset_y0_src * (OPJ_SIZE_T)l_width_src;
+                l_line_offset_src  = (OPJ_SIZE_T)l_offset_x1_src + (OPJ_SIZE_T)l_offset_x0_src;
+                l_end_offset_src   = (OPJ_SIZE_T)l_offset_y1_src * (OPJ_SIZE_T)l_width_src - (OPJ_SIZE_T)l_offset_x0_src;
 
                 /* Compute the output buffer offset */
-                l_start_offset_dest = (OPJ_INT32)(l_start_x_dest + l_start_y_dest * l_img_comp_dest->w);
-                l_line_offset_dest = (OPJ_INT32)(l_img_comp_dest->w - l_width_dest);
+                l_start_offset_dest = (OPJ_SIZE_T)l_start_x_dest + (OPJ_SIZE_T)l_start_y_dest * (OPJ_SIZE_T)l_img_comp_dest->w;
+                l_line_offset_dest  = (OPJ_SIZE_T)l_img_comp_dest->w - (OPJ_SIZE_T)l_width_dest;
 
                 /* Move the output buffer to the first place where we will write*/
                 l_dest_ptr = l_img_comp_dest->data + l_start_offset_dest;
 
                 /*if (i == 0) {
                         fprintf(stdout, "COMPO[%d]:\n",i);
                         fprintf(stdout, "SRC: l_start_x_src=%d, l_start_y_src=%d, l_width_src=%d, l_height_src=%d\n"
                                         "\t tile offset:%d, %d, %d, %d\n"
                                         "\t buffer offset: %d; %d, %d\n",
                                         l_res->x0, l_res->y0, l_width_src, l_height_src,
@@ skipping 253 matching lines @@
 opj_j2k_t* opj_j2k_create_decompress(void)
 {
         opj_j2k_t *l_j2k = (opj_j2k_t*) opj_calloc(1,sizeof(opj_j2k_t));
         if (!l_j2k) {
                 return 00;
         }
 
         l_j2k->m_is_decoder = 1;
         l_j2k->m_cp.m_is_decoder = 1;
 
+#ifdef OPJ_DISABLE_TPSOT_FIX
+        l_j2k->m_specific_param.m_decoder.m_nb_tile_parts_correction_checked = 1;
+#endif
+
         l_j2k->m_specific_param.m_decoder.m_default_tcp = (opj_tcp_t*) opj_calloc(1,sizeof(opj_tcp_t));
         if (!l_j2k->m_specific_param.m_decoder.m_default_tcp) {
                 opj_j2k_destroy(l_j2k);
                 return 00;
         }
 
         l_j2k->m_specific_param.m_decoder.m_header_data = (OPJ_BYTE *) opj_calloc(1,OPJ_J2K_DEFAULT_HEADER_SIZE);
         if (! l_j2k->m_specific_param.m_decoder.m_header_data) {
                 opj_j2k_destroy(l_j2k);
                 return 00;
@@ skipping 22 matching lines @@
         /* execution list creation */
         l_j2k->m_procedure_list = opj_procedure_list_create();
         if (! l_j2k->m_procedure_list) {
                 opj_j2k_destroy(l_j2k);
                 return 00;
         }
 
         return l_j2k;
 }
 
-opj_codestream_index_t* opj_j2k_create_cstr_index(void)
+static opj_codestream_index_t* opj_j2k_create_cstr_index(void)
 {
         opj_codestream_index_t* cstr_index = (opj_codestream_index_t*)
                         opj_calloc(1,sizeof(opj_codestream_index_t));
         if (!cstr_index)
                 return NULL;
 
         cstr_index->maxmarknum = 100;
         cstr_index->marknum = 0;
         cstr_index->marker = (opj_marker_info_t*)
                         opj_calloc(cstr_index->maxmarknum, sizeof(opj_marker_info_t));
-        if (!cstr_index-> marker)
+        if (!cstr_index-> marker) {
+                opj_free(cstr_index);
                 return NULL;
+        }
 
         cstr_index->tile_index = NULL;
 
         return cstr_index;
 }
 
-OPJ_UINT32 opj_j2k_get_SPCod_SPCoc_size (       opj_j2k_t *p_j2k,
+static OPJ_UINT32 opj_j2k_get_SPCod_SPCoc_size (       opj_j2k_t *p_j2k,
                                                                                 OPJ_UINT32 p_tile_no,
                                                                                 OPJ_UINT32 p_comp_no )
 {
         opj_cp_t *l_cp = 00;
         opj_tcp_t *l_tcp = 00;
         opj_tccp_t *l_tccp = 00;
 
         /* preconditions */
         assert(p_j2k != 00);
 
         l_cp = &(p_j2k->m_cp);
         l_tcp = &l_cp->tcps[p_tile_no];
         l_tccp = &l_tcp->tccps[p_comp_no];
 
         /* preconditions again */
         assert(p_tile_no < (l_cp->tw * l_cp->th));
         assert(p_comp_no < p_j2k->m_private_image->numcomps);
 
         if (l_tccp->csty & J2K_CCP_CSTY_PRT) {
                 return 5 + l_tccp->numresolutions;
         }
         else {
                 return 5;
         }
 }
 
-OPJ_BOOL opj_j2k_write_SPCod_SPCoc(     opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_write_SPCod_SPCoc(     opj_j2k_t *p_j2k,
                                                                     OPJ_UINT32 p_tile_no,
                                                                     OPJ_UINT32 p_comp_no,
                                                                     OPJ_BYTE * p_data,
                                                                     OPJ_UINT32 * p_header_size,
                                                                     struct opj_event_mgr * p_manager )
 {
         OPJ_UINT32 i;
         opj_cp_t *l_cp = 00;
         opj_tcp_t *l_tcp = 00;
         opj_tccp_t *l_tccp = 00;
@@ skipping 45 matching lines @@
                         opj_write_bytes(p_data,l_tccp->prcw[i] + (l_tccp->prch[i] << 4), 1);    /* SPcoc (I_i) */
                         ++p_data;
                 }
 
                 *p_header_size = *p_header_size - l_tccp->numresolutions;
         }
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_read_SPCod_SPCoc(  opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_read_SPCod_SPCoc(  opj_j2k_t *p_j2k,
                                                                 OPJ_UINT32 compno,
                                                                 OPJ_BYTE * p_header_data,
                                                                 OPJ_UINT32 * p_header_size,
                                                                 opj_event_mgr_t * p_manager)
 {
         OPJ_UINT32 i, l_tmp;
         opj_cp_t *l_cp = NULL;
         opj_tcp_t *l_tcp = NULL;
         opj_tccp_t *l_tccp = NULL;
         OPJ_BYTE * l_current_ptr = NULL;
@@ skipping 102 matching lines @@
 
                 memcpy(p_j2k->cstr_info->tile[p_j2k->m_current_tile_number].pdx,l_tccp->prcw, l_data_size);
                 memcpy(p_j2k->cstr_info->tile[p_j2k->m_current_tile_number].pdy,l_tccp->prch, l_data_size);
         }
         /* << INDEX */
 #endif
 
         return OPJ_TRUE;
 }
 
-void opj_j2k_copy_tile_component_parameters( opj_j2k_t *p_j2k )
+static void opj_j2k_copy_tile_component_parameters( opj_j2k_t *p_j2k )
 {
         /* loop */
         OPJ_UINT32 i;
         opj_cp_t *l_cp = NULL;
         opj_tcp_t *l_tcp = NULL;
         opj_tccp_t *l_ref_tccp = NULL, *l_copied_tccp = NULL;
         OPJ_UINT32 l_prc_size;
 
         /* preconditions */
         assert(p_j2k != 00);
@@ skipping 12 matching lines @@
                 l_copied_tccp->cblkw = l_ref_tccp->cblkw;
                 l_copied_tccp->cblkh = l_ref_tccp->cblkh;
                 l_copied_tccp->cblksty = l_ref_tccp->cblksty;
                 l_copied_tccp->qmfbid = l_ref_tccp->qmfbid;
                 memcpy(l_copied_tccp->prcw,l_ref_tccp->prcw,l_prc_size);
                 memcpy(l_copied_tccp->prch,l_ref_tccp->prch,l_prc_size);
                 ++l_copied_tccp;
         }
 }
 
-OPJ_UINT32 opj_j2k_get_SQcd_SQcc_size ( opj_j2k_t *p_j2k,
+static OPJ_UINT32 opj_j2k_get_SQcd_SQcc_size ( opj_j2k_t *p_j2k,
                                                                         OPJ_UINT32 p_tile_no,
                                                                         OPJ_UINT32 p_comp_no )
 {
         OPJ_UINT32 l_num_bands;
 
         opj_cp_t *l_cp = 00;
         opj_tcp_t *l_tcp = 00;
         opj_tccp_t *l_tccp = 00;
 
         /* preconditions */
@@ skipping 10 matching lines @@
         l_num_bands = (l_tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) ? 1 : (l_tccp->numresolutions * 3 - 2);
 
         if (l_tccp->qntsty == J2K_CCP_QNTSTY_NOQNT)  {
                 return 1 + l_num_bands;
         }
         else {
                 return 1 + 2*l_num_bands;
         }
 }
 
-OPJ_BOOL opj_j2k_write_SQcd_SQcc(       opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_write_SQcd_SQcc(       opj_j2k_t *p_j2k,
                                                                 OPJ_UINT32 p_tile_no,
                                                                 OPJ_UINT32 p_comp_no,
                                                                 OPJ_BYTE * p_data,
                                                                 OPJ_UINT32 * p_header_size,
                                                                 struct opj_event_mgr * p_manager )
 {
         OPJ_UINT32 l_header_size;
         OPJ_UINT32 l_band_no, l_num_bands;
         OPJ_UINT32 l_expn,l_mant;
 
@@ skipping 52 matching lines @@
                         opj_write_bytes(p_data, (l_expn << 11) + l_mant, 2);    /* SPqcx_i */
                         p_data += 2;
                 }
         }
 
         *p_header_size = *p_header_size - l_header_size;
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_read_SQcd_SQcc(opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_read_SQcd_SQcc(opj_j2k_t *p_j2k,
                                                             OPJ_UINT32 p_comp_no,
                                                             OPJ_BYTE* p_header_data,
                                                             OPJ_UINT32 * p_header_size,
                                                             opj_event_mgr_t * p_manager
                                                             )
 {
         /* loop*/
         OPJ_UINT32 l_band_no;
         opj_cp_t *l_cp = 00;
         opj_tcp_t *l_tcp = 00;
@@ skipping 96 matching lines @@
                         l_tccp->stepsizes[l_band_no].expn =
                                 ((OPJ_INT32)(l_tccp->stepsizes[0].expn) - (OPJ_INT32)((l_band_no - 1) / 3) > 0) ?
                                         (OPJ_INT32)(l_tccp->stepsizes[0].expn) - (OPJ_INT32)((l_band_no - 1) / 3) : 0;
                         l_tccp->stepsizes[l_band_no].mant = l_tccp->stepsizes[0].mant;
                 }
         }
 
         return OPJ_TRUE;
 }
 
-void opj_j2k_copy_tile_quantization_parameters( opj_j2k_t *p_j2k )
+static void opj_j2k_copy_tile_quantization_parameters( opj_j2k_t *p_j2k )
 {
         OPJ_UINT32 i;
         opj_cp_t *l_cp = NULL;
         opj_tcp_t *l_tcp = NULL;
         opj_tccp_t *l_ref_tccp = NULL;
         opj_tccp_t *l_copied_tccp = NULL;
         OPJ_UINT32 l_size;
 
         /* preconditions */
         assert(p_j2k != 00);
@@ skipping 106 matching lines @@
                 opj_j2k_dump_MH_index(p_j2k, out_stream);
         }
 
         /* Dump the codestream index of the current tile */
         if (flag & OPJ_J2K_TH_IND){
 
         }
 
 }
 
-void opj_j2k_dump_MH_index(opj_j2k_t* p_j2k, FILE* out_stream)
+static void opj_j2k_dump_MH_index(opj_j2k_t* p_j2k, FILE* out_stream)
 {
         opj_codestream_index_t* cstr_index = p_j2k->cstr_index;
         OPJ_UINT32 it_marker, it_tile, it_tile_part;
 
         fprintf(out_stream, "Codestream index from main header: {\n");
 
         fprintf(out_stream, "\t Main header start position=%" PRIi64 "\n"
                                     "\t Main header end position=%" PRIi64 "\n",
                         cstr_index->main_head_start, cstr_index->main_head_end);
 
@@ skipping 48 matching lines @@
                     }
                     fprintf(out_stream,"\t }\n");
         }
         }
 
         fprintf(out_stream,"}\n");
 
 }
 
 
-void opj_j2k_dump_MH_info(opj_j2k_t* p_j2k, FILE* out_stream)
+static void opj_j2k_dump_MH_info(opj_j2k_t* p_j2k, FILE* out_stream)
 {
 
         fprintf(out_stream, "Codestream info from main header: {\n");
 
         fprintf(out_stream, "\t tx0=%d, ty0=%d\n", p_j2k->m_cp.tx0, p_j2k->m_cp.ty0);
         fprintf(out_stream, "\t tdx=%d, tdy=%d\n", p_j2k->m_cp.tdx, p_j2k->m_cp.tdy);
         fprintf(out_stream, "\t tw=%d, th=%d\n", p_j2k->m_cp.tw, p_j2k->m_cp.th);
         opj_j2k_dump_tile_info(p_j2k->m_specific_param.m_decoder.m_default_tcp,(OPJ_INT32)p_j2k->m_private_image->numcomps, out_stream);
         fprintf(out_stream, "}\n");
 }
@@ skipping 219 matching lines @@
                         /* Packet index (NOT USED)*/
                         l_cstr_index->tile_index[it_tile].nb_packet = 0;
                         l_cstr_index->tile_index[it_tile].packet_index = NULL;
 
                 }
         }
 
         return l_cstr_index;
 }
 
-OPJ_BOOL opj_j2k_allocate_tile_element_cstr_index(opj_j2k_t *p_j2k)
+static OPJ_BOOL opj_j2k_allocate_tile_element_cstr_index(opj_j2k_t *p_j2k)
 {
         OPJ_UINT32 it_tile=0;
 
         p_j2k->cstr_index->nb_of_tiles = p_j2k->m_cp.tw * p_j2k->m_cp.th;
         p_j2k->cstr_index->tile_index = (opj_tile_index_t*)opj_calloc(p_j2k->cstr_index->nb_of_tiles, sizeof(opj_tile_index_t));
         if (!p_j2k->cstr_index->tile_index)
                 return OPJ_FALSE;
 
         for (it_tile=0; it_tile < p_j2k->cstr_index->nb_of_tiles; it_tile++){
                 p_j2k->cstr_index->tile_index[it_tile].maxmarknum = 100;
                 p_j2k->cstr_index->tile_index[it_tile].marknum = 0;
                 p_j2k->cstr_index->tile_index[it_tile].marker = (opj_marker_info_t*)
                                 opj_calloc(p_j2k->cstr_index->tile_index[it_tile].maxmarknum, sizeof(opj_marker_info_t));
                 if (!p_j2k->cstr_index->tile_index[it_tile].marker)
                         return OPJ_FALSE;
         }
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_decode_tiles ( opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_decode_tiles ( opj_j2k_t *p_j2k,
                                                             opj_stream_private_t *p_stream,
                                                             opj_event_mgr_t * p_manager)
 {
         OPJ_BOOL l_go_on = OPJ_TRUE;
         OPJ_UINT32 l_current_tile_no;
         OPJ_UINT32 l_data_size,l_max_data_size;
         OPJ_INT32 l_tile_x0,l_tile_y0,l_tile_x1,l_tile_y1;
         OPJ_UINT32 l_nb_comps;
         OPJ_BYTE * l_current_data;
         OPJ_UINT32 nr_tiles = 0;
 
         l_current_data = (OPJ_BYTE*)opj_malloc(1000);
         if (! l_current_data) {
                 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to decode tiles\n");
                 return OPJ_FALSE;
         }
         l_max_data_size = 1000;
 
-        while (OPJ_TRUE) {
+                for (;;) {
                 if (! opj_j2k_read_tile_header( p_j2k,
                                         &l_current_tile_no,
                                         &l_data_size,
                                         &l_tile_x0, &l_tile_y0,
                                         &l_tile_x1, &l_tile_y1,
                                         &l_nb_comps,
                                         &l_go_on,
                                         p_stream,
                                         p_manager)) {
                         opj_free(l_current_data);
@@ skipping 36 matching lines @@
         }
 
         opj_free(l_current_data);
 
         return OPJ_TRUE;
 }
 
 /**
  * Sets up the procedures to do on decoding data. Developpers wanting to extend the library can add their own reading procedures.
  */
-static void opj_j2k_setup_decoding (opj_j2k_t *p_j2k)
+static OPJ_BOOL opj_j2k_setup_decoding (opj_j2k_t *p_j2k, opj_event_mgr_t * p_manager)
 {
         /* preconditions*/
         assert(p_j2k != 00);
+        assert(p_manager != 00);
 
-        opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_decode_tiles);
+        if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_decode_tiles, p_manager)) {
+                return OPJ_FALSE;
+        }
         /* DEVELOPER CORNER, add your custom procedures */
 
+        return OPJ_TRUE;
 }
 
 /*
  * Read and decode one tile.
  */
 static OPJ_BOOL opj_j2k_decode_one_tile (       opj_j2k_t *p_j2k,
                                                                             opj_stream_private_t *p_stream,
                                                                             opj_event_mgr_t * p_manager)
 {
         OPJ_BOOL l_go_on = OPJ_TRUE;
@@ skipping 22 matching lines @@
         /* Move into the codestream to the first SOT used to decode the desired tile */
         l_tile_no_to_dec = (OPJ_UINT32)p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec;
         if (p_j2k->cstr_index->tile_index)
                 if(p_j2k->cstr_index->tile_index->tp_index)
                 {
                         if ( ! p_j2k->cstr_index->tile_index[l_tile_no_to_dec].nb_tps) {
                                 /* the index for this tile has not been built,
                                  *  so move to the last SOT read */
                                 if ( !(opj_stream_read_seek(p_stream, p_j2k->m_specific_param.m_decoder.m_last_sot_read_pos+2, p_manager)) ){
                                         opj_event_msg(p_manager, EVT_ERROR, "Problem with seek function\n");
-                        opj_free(l_current_data);
+                                        opj_free(l_current_data);
                                         return OPJ_FALSE;
                                 }
                         }
                         else{
                                 if ( !(opj_stream_read_seek(p_stream, p_j2k->cstr_index->tile_index[l_tile_no_to_dec].tp_index[0].start_pos+2, p_manager)) ) {
                                         opj_event_msg(p_manager, EVT_ERROR, "Problem with seek function\n");
-                        opj_free(l_current_data);
+                                        opj_free(l_current_data);
                                         return OPJ_FALSE;
                                 }
                         }
                         /* Special case if we have previously read the EOC marker (if the previous tile getted is the last ) */
                         if(p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_EOC)
                                 p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_TPHSOT;
                 }
 
-        while (OPJ_TRUE) {
+                for (;;) {
                 if (! opj_j2k_read_tile_header( p_j2k,
                                         &l_current_tile_no,
                                         &l_data_size,
                                         &l_tile_x0, &l_tile_y0,
                                         &l_tile_x1, &l_tile_y1,
                                         &l_nb_comps,
                                         &l_go_on,
                                         p_stream,
                                         p_manager)) {
                         opj_free(l_current_data);
@@ skipping 28 matching lines @@
                         opj_free(l_current_data);
                         return OPJ_FALSE;
                 }
                 opj_event_msg(p_manager, EVT_INFO, "Image data has been updated with tile %d.\n\n", l_current_tile_no);
 
                 if(l_current_tile_no == l_tile_no_to_dec)
                 {
                         /* move into the codestream to the the first SOT (FIXME or not move?)*/
                         if (!(opj_stream_read_seek(p_stream, p_j2k->cstr_index->main_head_end + 2, p_manager) ) ) {
                                 opj_event_msg(p_manager, EVT_ERROR, "Problem with seek function\n");
+                                opj_free(l_current_data);
                                 return OPJ_FALSE;
                         }
                         break;
                 }
                 else {
                         opj_event_msg(p_manager, EVT_WARNING, "Tile read, decode and updated is not the desired (%d vs %d).\n", l_current_tile_no, l_tile_no_to_dec);
                 }
 
         }
 
         opj_free(l_current_data);
 
         return OPJ_TRUE;
 }
 
 /**
  * Sets up the procedures to do on decoding one tile. Developpers wanting to extend the library can add their own reading procedures.
  */
-static void opj_j2k_setup_decoding_tile (opj_j2k_t *p_j2k)
+static OPJ_BOOL opj_j2k_setup_decoding_tile (opj_j2k_t *p_j2k, opj_event_mgr_t * p_manager)
 {
         /* preconditions*/
         assert(p_j2k != 00);
+        assert(p_manager != 00);
 
-        opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_decode_one_tile);
+        if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_decode_one_tile, p_manager)) {
+                return OPJ_FALSE;
+        }
         /* DEVELOPER CORNER, add your custom procedures */
 
+        return OPJ_TRUE;
 }
 
 OPJ_BOOL opj_j2k_decode(opj_j2k_t * p_j2k,
                                                 opj_stream_private_t * p_stream,
                                                 opj_image_t * p_image,
                                                 opj_event_mgr_t * p_manager)
 {
         OPJ_UINT32 compno;
 
         if (!p_image)
                 return OPJ_FALSE;
-
+        
         p_j2k->m_output_image = opj_image_create0();
         if (! (p_j2k->m_output_image)) {
                 return OPJ_FALSE;
         }
         opj_copy_image_header(p_image, p_j2k->m_output_image);
 
         /* customization of the decoding */
-        opj_j2k_setup_decoding(p_j2k);
+        opj_j2k_setup_decoding(p_j2k, p_manager);
 
         /* Decode the codestream */
         if (! opj_j2k_exec (p_j2k,p_j2k->m_procedure_list,p_stream,p_manager)) {
                 opj_image_destroy(p_j2k->m_private_image);
                 p_j2k->m_private_image = NULL;
                 return OPJ_FALSE;
         }
 
         /* Move data and copy one information from codec to output image*/
         for (compno = 0; compno < p_image->numcomps; compno++) {
@@ skipping 75 matching lines @@
         /* Create the ouput image from the information previously computed*/
         p_j2k->m_output_image = opj_image_create0();
         if (! (p_j2k->m_output_image)) {
                 return OPJ_FALSE;
         }
         opj_copy_image_header(p_image, p_j2k->m_output_image);
 
         p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec = (OPJ_INT32)tile_index;
 
         /* customization of the decoding */
-        opj_j2k_setup_decoding_tile(p_j2k);
+        opj_j2k_setup_decoding_tile(p_j2k, p_manager);
 
         /* Decode the codestream */
         if (! opj_j2k_exec (p_j2k,p_j2k->m_procedure_list,p_stream,p_manager)) {
                 opj_image_destroy(p_j2k->m_private_image);
                 p_j2k->m_private_image = NULL;
                 return OPJ_FALSE;
         }
 
         /* Move data and copy one information from codec to output image*/
         for (compno = 0; compno < p_image->numcomps; compno++) {
@@ skipping 74 matching lines @@
                                                                                                         l_tilec->data  =  l_img_comp->data;
                                                                                                         l_tilec->ownsData = OPJ_FALSE;
                         } else {
                                                                                                         if(! opj_alloc_tile_component_data(l_tilec)) {
                                                                                                                 opj_event_msg(p_manager, EVT_ERROR, "Error allocating tile component data." );
                                                                                                                 if (l_current_data) {
                                                                                                                         opj_free(l_current_data);
                                                                                                                 }
                                                                                                                 return OPJ_FALSE;
                                                                                                         }
-                                                                                                        opj_alloc_tile_component_data(l_tilec);
                         }
                 }
                 l_current_tile_size = opj_tcd_get_encoded_tile_size(p_j2k->m_tcd);
                 if (l_nb_tiles > 1) {
                         if (l_current_tile_size > l_max_tile_size) {
                                                                                                         OPJ_BYTE *l_new_current_data = (OPJ_BYTE *) opj_realloc(l_current_data, l_current_tile_size);
                                                                                                         if (! l_new_current_data) {
                                                                                                                 if (l_current_data) {
                                                                                                                         opj_free(l_current_data);
                                                                                                                 }
                                                                                                                 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to encode all tiles\n");
                                                                                                                 return OPJ_FALSE;
                                                                                                                                 }
                                                                                                                                 l_current_data = l_new_current_data;
                                                                                                                                 l_max_tile_size = l_current_tile_size;
                         }
 
                         /* copy image data (32 bit) to l_current_data as contiguous, all-component, zero offset buffer */
                         /* 32 bit components @ 8 bit precision get converted to 8 bit */
                         /* 32 bit components @ 16 bit precision get converted to 16 bit */
                         opj_j2k_get_tile_data(p_j2k->m_tcd,l_current_data);
 
                         /* now copy this data into the tile component */
                         if (! opj_tcd_copy_tile_data(p_j2k->m_tcd,l_current_data,l_current_tile_size)) {
                                                                                                                                 opj_event_msg(p_manager, EVT_ERROR, "Size mismatch between tile data and sent data." );
+                                                                                                                                opj_free(l_current_data);
                                                                                                                                 return OPJ_FALSE;
                         }
                 }
 
                 if (! opj_j2k_post_write_tile (p_j2k,p_stream,p_manager)) {
+                        if (l_current_data) {
+                                opj_free(l_current_data);
+                        }
                         return OPJ_FALSE;
                 }
         }
 
         if (l_current_data) {
                 opj_free(l_current_data);
         }
         return OPJ_TRUE;
 }
 
 OPJ_BOOL opj_j2k_end_compress(  opj_j2k_t *p_j2k,
                                                         opj_stream_private_t *p_stream,
                                                         opj_event_mgr_t * p_manager)
 {
         /* customization of the encoding */
-        opj_j2k_setup_end_compress(p_j2k);
+        if (! opj_j2k_setup_end_compress(p_j2k, p_manager)) {
+                return OPJ_FALSE;
+        }
 
         if (! opj_j2k_exec (p_j2k, p_j2k->m_procedure_list, p_stream, p_manager))
         {
                 return OPJ_FALSE;
         }
 
         return OPJ_TRUE;
 }
 
 OPJ_BOOL opj_j2k_start_compress(opj_j2k_t *p_j2k,
@@ skipping 19 matching lines @@
                 for (it_comp = 0 ; it_comp < p_image->numcomps; it_comp++) {
                         if (p_image->comps[it_comp].data) {
                                 p_j2k->m_private_image->comps[it_comp].data =p_image->comps[it_comp].data;
                                 p_image->comps[it_comp].data = NULL;
 
                         }
                 }
         }
 
         /* customization of the validation */
-        opj_j2k_setup_encoding_validation (p_j2k);
+        if (! opj_j2k_setup_encoding_validation (p_j2k, p_manager)) {
+                return OPJ_FALSE;
+        }
 
         /* validation of the parameters codec */
         if (! opj_j2k_exec(p_j2k,p_j2k->m_validation_list,p_stream,p_manager)) {
                 return OPJ_FALSE;
         }
 
         /* customization of the encoding */
-        opj_j2k_setup_header_writing(p_j2k);
+        if (! opj_j2k_setup_header_writing(p_j2k, p_manager)) {
+                return OPJ_FALSE;
+        }
 
         /* write header */
         if (! opj_j2k_exec (p_j2k,p_j2k->m_procedure_list,p_stream,p_manager)) {
                 return OPJ_FALSE;
         }
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_pre_write_tile (       opj_j2k_t * p_j2k,
+static OPJ_BOOL opj_j2k_pre_write_tile (       opj_j2k_t * p_j2k,
                                                                 OPJ_UINT32 p_tile_index,
                                                                 opj_stream_private_t *p_stream,
                                                                 opj_event_mgr_t * p_manager )
 {
   (void)p_stream;
         if (p_tile_index != p_j2k->m_current_tile_number) {
                 opj_event_msg(p_manager, EVT_ERROR, "The given tile index does not match." );
                 return OPJ_FALSE;
         }
 
         opj_event_msg(p_manager, EVT_INFO, "tile number %d / %d\n", p_j2k->m_current_tile_number + 1, p_j2k->m_cp.tw * p_j2k->m_cp.th);
 
         p_j2k->m_specific_param.m_encoder.m_current_tile_part_number = 0;
         p_j2k->m_tcd->cur_totnum_tp = p_j2k->m_cp.tcps[p_tile_index].m_nb_tile_parts;
         p_j2k->m_specific_param.m_encoder.m_current_poc_tile_part_number = 0;
 
         /* initialisation before tile encoding  */
-        if (! opj_tcd_init_encode_tile(p_j2k->m_tcd, p_j2k->m_current_tile_number)) {
+        if (! opj_tcd_init_encode_tile(p_j2k->m_tcd, p_j2k->m_current_tile_number, p_manager)) {
                 return OPJ_FALSE;
         }
 
         return OPJ_TRUE;
 }
 
-void opj_get_tile_dimensions(opj_image_t * l_image,
+static void opj_get_tile_dimensions(opj_image_t * l_image,
                              opj_tcd_tilecomp_t * l_tilec,
                              opj_image_comp_t * l_img_comp,
                              OPJ_UINT32* l_size_comp,
                              OPJ_UINT32* l_width,
                              OPJ_UINT32* l_height,
                              OPJ_UINT32* l_offset_x,
                              OPJ_UINT32* l_offset_y,
                              OPJ_UINT32* l_image_width,
                              OPJ_UINT32* l_stride,
                              OPJ_UINT32* l_tile_offset) {
@@ skipping 10 matching lines @@
 
         *l_width  = (OPJ_UINT32)(l_tilec->x1 - l_tilec->x0);
         *l_height = (OPJ_UINT32)(l_tilec->y1 - l_tilec->y0);
         *l_offset_x = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)l_image->x0, (OPJ_INT32)l_img_comp->dx);
         *l_offset_y = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)l_image->y0, (OPJ_INT32)l_img_comp->dy);
         *l_image_width = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)l_image->x1 - (OPJ_INT32)l_image->x0, (OPJ_INT32)l_img_comp->dx);
         *l_stride = *l_image_width - *l_width;
         *l_tile_offset = ((OPJ_UINT32)l_tilec->x0 - *l_offset_x) + ((OPJ_UINT32)l_tilec->y0 - *l_offset_y) * *l_image_width;
 }
 
-void opj_j2k_get_tile_data (opj_tcd_t * p_tcd, OPJ_BYTE * p_data)
+static void opj_j2k_get_tile_data (opj_tcd_t * p_tcd, OPJ_BYTE * p_data)
 {
         OPJ_UINT32 i,j,k = 0;
 
         for (i=0;i<p_tcd->image->numcomps;++i) {
                 opj_image_t * l_image =  p_tcd->image;
                 OPJ_INT32 * l_src_ptr;
                 opj_tcd_tilecomp_t * l_tilec = p_tcd->tcd_image->tiles->comps + i;
                 opj_image_comp_t * l_img_comp = l_image->comps + i;
                 OPJ_UINT32 l_size_comp,l_width,l_height,l_offset_x,l_offset_y, l_image_width,l_stride,l_tile_offset;
 
@@ skipping 72 matching lines @@
                                                 l_src_ptr += l_stride;
                                         }
 
                                         p_data = (OPJ_BYTE*) l_dest_ptr;
                                 }
                                 break;
                 }
         }
 }
 
-OPJ_BOOL opj_j2k_post_write_tile (      opj_j2k_t * p_j2k,
+static OPJ_BOOL opj_j2k_post_write_tile (      opj_j2k_t * p_j2k,
                                                                 opj_stream_private_t *p_stream,
                                                                 opj_event_mgr_t * p_manager )
 {
         OPJ_UINT32 l_nb_bytes_written;
         OPJ_BYTE * l_current_data = 00;
         OPJ_UINT32 l_tile_size = 0;
         OPJ_UINT32 l_available_data;
 
         /* preconditions */
         assert(p_j2k->m_specific_param.m_encoder.m_encoded_tile_data);
@@ skipping 21 matching lines @@
                                                                 p_j2k->m_specific_param.m_encoder.m_encoded_tile_data,
                                                                 l_nb_bytes_written,p_manager) != l_nb_bytes_written) {
                 return OPJ_FALSE;
         }
 
         ++p_j2k->m_current_tile_number;
 
         return OPJ_TRUE;
 }
 
-void opj_j2k_setup_end_compress (opj_j2k_t *p_j2k)
+static OPJ_BOOL opj_j2k_setup_end_compress (opj_j2k_t *p_j2k, opj_event_mgr_t * p_manager)
 {
         /* preconditions */
         assert(p_j2k != 00);
+        assert(p_manager != 00);
 
         /* DEVELOPER CORNER, insert your custom procedures */
-        opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_eoc );
+        if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_eoc, p_manager)) {
+                return OPJ_FALSE;
+        }
 
         if (OPJ_IS_CINEMA(p_j2k->m_cp.rsiz)) {
-                opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_updated_tlm);
+                if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_updated_tlm, p_manager)) {
+                        return OPJ_FALSE;
+                }
         }
 
-        opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_epc );
-        opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_end_encoding );
-        opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_destroy_header_memory);
+        if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_epc, p_manager)) {
+                return OPJ_FALSE;
+        }
+        if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_end_encoding, p_manager)) {
+                return OPJ_FALSE;
+        }
+        if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_destroy_header_memory, p_manager)) {
+                return OPJ_FALSE;
+        }
+        return OPJ_TRUE;
 }
 
-void opj_j2k_setup_encoding_validation (opj_j2k_t *p_j2k)
+static OPJ_BOOL opj_j2k_setup_encoding_validation (opj_j2k_t *p_j2k, opj_event_mgr_t * p_manager)
 {
         /* preconditions */
         assert(p_j2k != 00);
+        assert(p_manager != 00);
 
-        opj_procedure_list_add_procedure(p_j2k->m_validation_list, (opj_procedure)opj_j2k_build_encoder);
-        opj_procedure_list_add_procedure(p_j2k->m_validation_list, (opj_procedure)opj_j2k_encoding_validation);
+        if (! opj_procedure_list_add_procedure(p_j2k->m_validation_list, (opj_procedure)opj_j2k_build_encoder, p_manager)) {
+                return OPJ_FALSE;
+        }
+        if (! opj_procedure_list_add_procedure(p_j2k->m_validation_list, (opj_procedure)opj_j2k_encoding_validation, p_manager)) {
+                return OPJ_FALSE;
+                                }
 
         /* DEVELOPER CORNER, add your custom validation procedure */
-        opj_procedure_list_add_procedure(p_j2k->m_validation_list, (opj_procedure)opj_j2k_mct_validation);
+        if (! opj_procedure_list_add_procedure(p_j2k->m_validation_list, (opj_procedure)opj_j2k_mct_validation, p_manager)) {
+                return OPJ_FALSE;
+        }
+        
+        return OPJ_TRUE;
 }
 
-void opj_j2k_setup_header_writing (opj_j2k_t *p_j2k)
+static OPJ_BOOL opj_j2k_setup_header_writing (opj_j2k_t *p_j2k, opj_event_mgr_t * p_manager)
 {
         /* preconditions */
         assert(p_j2k != 00);
+        assert(p_manager != 00);
 
-        opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_init_info );
-        opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_soc );
-        opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_siz );
-        opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_cod );
-        opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_qcd );
+        if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_init_info, p_manager)) {
+                return OPJ_FALSE;
+        }
+        if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_soc, p_manager)) {
+                return OPJ_FALSE;
+        }
+        if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_siz, p_manager)) {
+                return OPJ_FALSE;
+        }
+        if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_cod, p_manager)) {
+                return OPJ_FALSE;
+        }
+        if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_qcd, p_manager)) {
+                return OPJ_FALSE;
+        }
 
         if (OPJ_IS_CINEMA(p_j2k->m_cp.rsiz)) {
                 /* No need for COC or QCC, QCD and COD are used
-                opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_all_coc );
-                opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_all_qcc );
+                if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_all_coc, p_manager)) {
+                        return OPJ_FALSE;
+                }
+                if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_all_qcc, p_manager)) {
+                        return OPJ_FALSE;
+                }
                 */
-                opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_tlm );
+                if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_tlm, p_manager)) {
+                        return OPJ_FALSE;
+                }
 
                 if (p_j2k->m_cp.rsiz == OPJ_PROFILE_CINEMA_4K) {
-                        opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_poc );
+                        if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_poc, p_manager)) {
+                                return OPJ_FALSE;
+                        }
                 }
         }
 
-        opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_regions);
+        if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_regions, p_manager)) {
+                return OPJ_FALSE;
+        }
 
         if (p_j2k->m_cp.comment != 00)  {
-                opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_com);
+                if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_com, p_manager)) {
+                        return OPJ_FALSE;
+                }
         }
 
         /* DEVELOPER CORNER, insert your custom procedures */
         if (p_j2k->m_cp.rsiz & OPJ_EXTENSION_MCT) {
-                opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_mct_data_group );
+                if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_mct_data_group, p_manager)) {
+                        return OPJ_FALSE;
+                }
         }
         /* End of Developer Corner */
 
         if (p_j2k->cstr_index) {
-                opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_get_end_header );
+                if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_get_end_header, p_manager)) {
+                        return OPJ_FALSE;
+                }
         }
 
-        opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_create_tcd);
-        opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_update_rates);
+        if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_create_tcd, p_manager)) {
+                return OPJ_FALSE;
+        }
+        if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_update_rates, p_manager)) {
+                return OPJ_FALSE;
+        }
+
+        return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_write_first_tile_part (opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_write_first_tile_part (opj_j2k_t *p_j2k,
                                                                         OPJ_BYTE * p_data,
                                                                         OPJ_UINT32 * p_data_written,
                                                                         OPJ_UINT32 p_total_data_size,
                                                                         opj_stream_private_t *p_stream,
                                                                         struct opj_event_mgr * p_manager )
 {
         OPJ_UINT32 l_nb_bytes_written = 0;
         OPJ_UINT32 l_current_nb_bytes_written;
         OPJ_BYTE * l_begin_data = 00;
 
@@ skipping 59 matching lines @@
         /* Writing Psot in SOT marker */
         opj_write_bytes(l_begin_data + 6,l_nb_bytes_written,4);                                 /* PSOT */
 
         if (OPJ_IS_CINEMA(l_cp->rsiz)){
                 opj_j2k_update_tlm(p_j2k,l_nb_bytes_written);
         }
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_write_all_tile_parts(  opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_write_all_tile_parts(  opj_j2k_t *p_j2k,
                                                                         OPJ_BYTE * p_data,
                                                                         OPJ_UINT32 * p_data_written,
                                                                         OPJ_UINT32 p_total_data_size,
                                                                         opj_stream_private_t *p_stream,
                                                                         struct opj_event_mgr * p_manager
                                                                 )
 {
         OPJ_UINT32 tilepartno=0;
         OPJ_UINT32 l_nb_bytes_written = 0;
         OPJ_UINT32 l_current_nb_bytes_written;
@@ skipping 90 matching lines @@
 
                         ++p_j2k->m_specific_param.m_encoder.m_current_tile_part_number;
                 }
         }
 
         *p_data_written = l_nb_bytes_written;
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_write_updated_tlm( opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_write_updated_tlm( opj_j2k_t *p_j2k,
                                                                     struct opj_stream_private *p_stream,
                                                                     struct opj_event_mgr * p_manager )
 {
         OPJ_UINT32 l_tlm_size;
         OPJ_OFF_T l_tlm_position, l_current_position;
 
         /* preconditions */
         assert(p_j2k != 00);
         assert(p_manager != 00);
         assert(p_stream != 00);
@@ skipping 10 matching lines @@
                 return OPJ_FALSE;
         }
 
         if (! opj_stream_seek(p_stream,l_current_position,p_manager)) {
                 return OPJ_FALSE;
         }
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_end_encoding(  opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_end_encoding(  opj_j2k_t *p_j2k,
                                                         struct opj_stream_private *p_stream,
                                                         struct opj_event_mgr * p_manager )
 {
         /* preconditions */
         assert(p_j2k != 00);
         assert(p_manager != 00);
         assert(p_stream != 00);
 
         opj_tcd_destroy(p_j2k->m_tcd);
         p_j2k->m_tcd = 00;
@@ skipping 30 matching lines @@
         if (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 = 0;
         }
 
         p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
 
         return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_init_info(     opj_j2k_t *p_j2k,
+static OPJ_BOOL opj_j2k_init_info(     opj_j2k_t *p_j2k,
                                                 struct opj_stream_private *p_stream,
                                                 struct opj_event_mgr * p_manager )
 {
         opj_codestream_info_t * l_cstr_info = 00;
 
         /* preconditions */
         assert(p_j2k != 00);
         assert(p_manager != 00);
         assert(p_stream != 00);
   (void)l_cstr_info;
@@ skipping 102 matching lines @@
                         return OPJ_FALSE;
                 }
                 if (! opj_j2k_post_write_tile(p_j2k,p_stream,p_manager)) {
                         opj_event_msg(p_manager, EVT_ERROR, "Error while opj_j2k_post_write_tile with tile index = %d\n", p_tile_index);
                         return OPJ_FALSE;
                 }
         }
 
         return OPJ_TRUE;
 }