Revert "OpenJPEG: update to 2.1 from 1.5"
[blender.git] / extern / libopenjpeg / j2k.c
index 881cc72c7336fb1beca3d39275ded92070b5db9c..93e5c9eb80a3389a9496d771590f154a7cc822a0 100644 (file)
@@ -1,21 +1,12 @@
 /*
- * 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) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
  * Copyright (c) 2001-2003, David Janssens
  * Copyright (c) 2002-2003, Yannick Verschueren
- * Copyright (c) 2003-2007, Francois-Olivier Devaux 
- * Copyright (c) 2003-2014, Antonin Descampe
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
  * Copyright (c) 2005, Herve Drolon, FreeImage Team
- * Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
  * Copyright (c) 2006-2007, Parvatha Elangovan
  * Copyright (c) 2010-2011, Kaori Hagihara
- * Copyright (c) 2011-2012, Centre National d'Etudes Spatiales (CNES), France 
- * Copyright (c) 2012, CS Systemes d'Information, France
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -41,6 +32,7 @@
  */
 
 #include "opj_includes.h"
+#include <assert.h>
 
 /** @defgroup J2K J2K - JPEG-2000 codestream reader/writer */
 /*@{*/
 /*@{*/
 
 /**
- * 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);
-
-/**
- * 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.
- *
- * @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.
- */
-static OPJ_BOOL opj_j2k_encoding_validation (   opj_j2k_t * p_j2k,
-                                                opj_stream_private_t *p_stream,
-                                                opj_event_mgr_t * p_manager );
-
-/**
- * The default decoding validation procedure without any extension.
- *
- * @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.
- */
-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);
-
-/**
- * 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);
-
-/**
- * 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);
-
-/**
- * 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.
- */
-static OPJ_BOOL opj_j2k_mct_validation (opj_j2k_t * p_j2k,
-                                        opj_stream_private_t *p_stream,
-                                        opj_event_mgr_t * p_manager );
-
-/**
- * Builds the tcd decoder to use to decode tile.
- */
-static OPJ_BOOL opj_j2k_build_decoder ( opj_j2k_t * p_j2k,
-                                        opj_stream_private_t *p_stream,
-                                        opj_event_mgr_t * p_manager );
-/**
- * Builds the tcd encoder to use to encode tile.
- */
-static OPJ_BOOL opj_j2k_build_encoder ( opj_j2k_t * p_j2k,
-                                        opj_stream_private_t *p_stream,
-                                        opj_event_mgr_t * p_manager );
-
-/**
- * Creates a tile-coder decoder.
- *
- * @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_create_tcd(     opj_j2k_t *p_j2k,
-                                                                    opj_stream_private_t *p_stream,
-                                                                    opj_event_mgr_t * p_manager );
-
-/**
- * Excutes the given procedures on the given codec.
- *
- * @param       p_procedure_list        the list of procedures to execute
- * @param       p_j2k                           the jpeg2000 codec to execute the procedures on.
- * @param       p_stream                        the stream to execute the procedures on.
- * @param       p_manager                       the user manager.
- *
- * @return      true                            if all the procedures were successfully executed.
- */
-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);
-
-/**
- * Updates the rates of the tcp.
- *
- * @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_update_rates(   opj_j2k_t *p_j2k,
-                                                                            opj_stream_private_t *p_stream,
-                                                                            opj_event_mgr_t * p_manager );
-
-/**
- * Copies the decoding tile parameters onto all the tile parameters.
- * Creates also the tile decoder.
- */
-static OPJ_BOOL opj_j2k_copy_default_tcp_and_create_tcd (       opj_j2k_t * p_j2k,
-                                                            opj_stream_private_t *p_stream,
-                                                            opj_event_mgr_t * p_manager );
-
-/**
- * Destroys the memory associated with the decoding of headers.
- */
-static OPJ_BOOL opj_j2k_destroy_header_memory ( opj_j2k_t * p_j2k,
-                                                opj_stream_private_t *p_stream,
-                                                opj_event_mgr_t * p_manager );
-
-/**
- * Reads the lookup table containing all the marker, status and action, and returns the handler associated
- * with the marker value.
- * @param       p_id            Marker value to look up
- *
- * @return      the handler associated with the id.
-*/
-static const struct opj_dec_memory_marker_handler * opj_j2k_get_marker_handler (OPJ_UINT32 p_id);
-
-/**
- * Destroys a tile coding parameter structure.
- *
- * @param       p_tcp           the tile coding parameter to destroy.
- */
-static void opj_j2k_tcp_destroy (opj_tcp_t *p_tcp);
-
-/**
- * Destroys the data inside a tile coding parameter structure.
- *
- * @param       p_tcp           the tile coding parameter which contain data to destroy.
- */
-static void opj_j2k_tcp_data_destroy (opj_tcp_t *p_tcp);
-
-/**
- * Destroys a coding parameter structure.
- *
- * @param       p_cp            the coding parameter to destroy.
- */
-static void opj_j2k_cp_destroy (opj_cp_t *p_cp);
-
-/**
- * Writes a SPCod or SPCoc element, i.e. the coding style of a given component of a tile.
- *
- * @param       p_j2k           J2K codec.
- * @param       p_tile_no       FIXME DOC
- * @param       p_comp_no       the component number to output.
- * @param       p_data          FIXME DOC
- * @param       p_header_size   FIXME DOC
- * @param       p_manager       the user event manager.
- *
- * @return FIXME DOC
-*/
-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,
-                                                                                    opj_event_mgr_t * p_manager );
-
-/**
- * Gets the size taken by writing a SPCod or SPCoc for the given tile and component.
- *
- * @param       p_j2k                   the J2K codec.
- * @param       p_tile_no               the tile index.
- * @param       p_comp_no               the component being outputted.
- *
- * @return      the number of bytes taken by the SPCod element.
- */
-static OPJ_UINT32 opj_j2k_get_SPCod_SPCoc_size (opj_j2k_t *p_j2k,
-                                                                                            OPJ_UINT32 p_tile_no,
-                                                                                            OPJ_UINT32 p_comp_no );
-
-/**
- * Reads a SPCod or SPCoc element, i.e. the coding style of a given component of a tile.
- * @param       p_j2k           the jpeg2000 codec.
- * @param       compno          FIXME DOC
- * @param       p_header_data   the data contained in the COM box.
- * @param       p_header_size   the size of the data contained in the COM marker.
- * @param       p_manager       the user event manager.
-*/
-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 );
-
-/**
- * Gets the size taken by writing SQcd or SQcc element, i.e. the quantization values of a band in the QCD or QCC.
- *
- * @param       p_tile_no               the tile index.
- * @param       p_comp_no               the component being outputted.
- * @param       p_j2k                   the J2K codec.
- *
- * @return      the number of bytes taken by the SPCod element.
- */
-static OPJ_UINT32 opj_j2k_get_SQcd_SQcc_size (  opj_j2k_t *p_j2k,
-                                                                                    OPJ_UINT32 p_tile_no,
-                                                                                    OPJ_UINT32 p_comp_no );
-
-/**
- * Writes a SQcd or SQcc element, i.e. the quantization values of a band in the QCD or QCC.
- *
- * @param       p_tile_no               the tile to output.
- * @param       p_comp_no               the component number to output.
- * @param       p_data                  the data buffer.
- * @param       p_header_size   pointer to the size of the data buffer, it is changed by the function.
- * @param       p_j2k                   J2K codec.
- * @param       p_manager               the user event manager.
- *
-*/
-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,
-                                                                            opj_event_mgr_t * p_manager);
-
-/**
- * Updates the Tile Length Marker.
- */
-static void opj_j2k_update_tlm ( opj_j2k_t * p_j2k, OPJ_UINT32 p_tile_part_size);
-
-/**
- * Reads a SQcd or SQcc element, i.e. the quantization values of a band in the QCD or QCC.
- *
- * @param       p_j2k           J2K codec.
- * @param       compno          the component number to output.
- * @param       p_header_data   the data buffer.
- * @param       p_header_size   pointer to the size of the data buffer, it is changed by the function.
- * @param       p_manager       the user event manager.
- *
-*/
-static OPJ_BOOL opj_j2k_read_SQcd_SQcc( opj_j2k_t *p_j2k,
-                                        OPJ_UINT32 compno,
-                                        OPJ_BYTE * p_header_data,
-                                        OPJ_UINT32 * p_header_size,
-                                        opj_event_mgr_t * p_manager );
-
-/**
- * Copies the tile component parameters of all the component from the first tile component.
- *
- * @param               p_j2k           the J2k codec.
- */
-static void opj_j2k_copy_tile_component_parameters( opj_j2k_t *p_j2k );
-
-/**
- * Copies the tile quantization parameters of all the component from the first tile component.
- *
- * @param               p_j2k           the J2k codec.
- */
-static void opj_j2k_copy_tile_quantization_parameters( opj_j2k_t *p_j2k );
-
-/**
- * Reads the tiles.
- */
-static OPJ_BOOL opj_j2k_decode_tiles (  opj_j2k_t *p_j2k,
-                                        opj_stream_private_t *p_stream,
-                                        opj_event_mgr_t * p_manager);
-
-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 );
-
-static OPJ_BOOL opj_j2k_update_image_data (opj_tcd_t * p_tcd, OPJ_BYTE * p_data, opj_image_t* p_output_image);
-
-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_BYTE * p_data,
-                                                                             OPJ_UINT32 p_data_size,
-                                                                             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_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,
-                                                                                            OPJ_UINT32 * p_data_written,
-                                                                                            OPJ_UINT32 p_total_data_size,
-                                                                                            opj_stream_private_t *p_stream,
-                                                                                            struct opj_event_mgr * p_manager );
-
-/**
- * Gets the offset of the header.
- *
- * @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_get_end_header( opj_j2k_t *p_j2k,
-                                        opj_stream_private_t *p_stream,
-                                        opj_event_mgr_t * p_manager );
-
-static OPJ_BOOL opj_j2k_allocate_tile_element_cstr_index(opj_j2k_t *p_j2k);
-
-/*
- * -----------------------------------------------------------------------
- * -----------------------------------------------------------------------
- * -----------------------------------------------------------------------
- */
-
-/**
- * Writes the SOC marker (Start Of Codestream)
- *
- * @param       p_stream                        the stream to write data to.
- * @param       p_j2k                   J2K codec.
- * @param       p_manager       the user event manager.
+Write the SOC marker (Start Of Codestream)
+@param j2k J2K handle
 */
-static OPJ_BOOL opj_j2k_write_soc(      opj_j2k_t *p_j2k,
-                                                        opj_stream_private_t *p_stream,
-                                                            opj_event_mgr_t * p_manager );
-
+static void j2k_write_soc(opj_j2k_t *j2k);
 /**
- * Reads a SOC marker (Start of Codestream)
- * @param       p_j2k           the jpeg2000 file codec.
- * @param       p_stream        XXX needs data
- * @param       p_manager       the user event manager.
+Read the SOC marker (Start of Codestream)
+@param j2k J2K handle
 */
-static OPJ_BOOL opj_j2k_read_soc(   opj_j2k_t *p_j2k,
-                                    opj_stream_private_t *p_stream,
-                                    opj_event_mgr_t * p_manager );
-
+static void j2k_read_soc(opj_j2k_t *j2k);
 /**
- * Writes the SIZ marker (image and tile size)
- *
- * @param       p_j2k           J2K codec.
- * @param       p_stream        the stream to write data to.
- * @param       p_manager       the user event manager.
+Write the SIZ marker (image and tile size)
+@param j2k J2K handle
 */
-static OPJ_BOOL opj_j2k_write_siz(      opj_j2k_t *p_j2k,
-                                                                opj_stream_private_t *p_stream,
-                                                                opj_event_mgr_t * p_manager );
-
+static void j2k_write_siz(opj_j2k_t *j2k);
 /**
- * Reads a SIZ marker (image and tile size)
- * @param       p_j2k           the jpeg2000 file codec.
- * @param       p_header_data   the data contained in the SIZ box.
- * @param       p_header_size   the size of the data contained in the SIZ marker.
- * @param       p_manager       the user event manager.
+Read the SIZ marker (image and tile size)
+@param j2k J2K handle
 */
-static OPJ_BOOL opj_j2k_read_siz(opj_j2k_t *p_j2k,
-                                 OPJ_BYTE * p_header_data,
-                                 OPJ_UINT32 p_header_size,
-                                 opj_event_mgr_t * p_manager);
-
+static void j2k_read_siz(opj_j2k_t *j2k);
 /**
- * Writes the COM marker (comment)
- *
- * @param       p_stream                        the stream to write data to.
- * @param       p_j2k                   J2K codec.
- * @param       p_manager       the user event manager.
+Write the COM marker (comment)
+@param j2k J2K handle
 */
-static OPJ_BOOL opj_j2k_write_com(      opj_j2k_t *p_j2k,
-                                                                        opj_stream_private_t *p_stream,
-                                                                        opj_event_mgr_t * p_manager );
-
+static void j2k_write_com(opj_j2k_t *j2k);
 /**
- * Reads a COM marker (comments)
- * @param       p_j2k           the jpeg2000 file codec.
- * @param       p_header_data   the data contained in the COM box.
- * @param       p_header_size   the size of the data contained in the COM marker.
- * @param       p_manager       the user event manager.
+Read the COM marker (comment)
+@param j2k J2K handle
 */
-static OPJ_BOOL opj_j2k_read_com (  opj_j2k_t *p_j2k,
-                                    OPJ_BYTE * p_header_data,
-                                    OPJ_UINT32 p_header_size,
-                                    opj_event_mgr_t * p_manager );
+static void j2k_read_com(opj_j2k_t *j2k);
 /**
- * Writes the COD marker (Coding style default)
- *
- * @param       p_stream                        the stream to write data to.
- * @param       p_j2k                   J2K codec.
- * @param       p_manager       the user event manager.
+Write the value concerning the specified component in the marker COD and COC
+@param j2k J2K handle
+@param compno Number of the component concerned by the information written
 */
-static OPJ_BOOL opj_j2k_write_cod(      opj_j2k_t *p_j2k,
-                                                                        opj_stream_private_t *p_stream,
-                                                                        opj_event_mgr_t * p_manager );
-
+static void j2k_write_cox(opj_j2k_t *j2k, int compno);
 /**
- * Reads a COD marker (Coding Styke defaults)
- * @param       p_header_data   the data contained in the COD box.
- * @param       p_j2k                   the jpeg2000 codec.
- * @param       p_header_size   the size of the data contained in the COD marker.
- * @param       p_manager               the user event manager.
+Read the value concerning the specified component in the marker COD and COC
+@param j2k J2K handle
+@param compno Number of the component concerned by the information read
 */
-static OPJ_BOOL opj_j2k_read_cod (  opj_j2k_t *p_j2k,
-                                    OPJ_BYTE * p_header_data,
-                                    OPJ_UINT32 p_header_size,
-                                    opj_event_mgr_t * p_manager);
-
-#if 0
+static void j2k_read_cox(opj_j2k_t *j2k, int compno);
 /**
- * Writes the COC marker (Coding style component)
- *
- * @param       p_j2k       J2K codec.
- * @param       p_comp_no   the index of the component to output.
- * @param       p_stream    the stream to write data to.
- * @param       p_manager   the user event manager.
+Write the COD marker (coding style default)
+@param j2k J2K handle
 */
-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 );
-#endif
-
-#if 0
+static void j2k_write_cod(opj_j2k_t *j2k);
 /**
- * Writes the COC marker (Coding style component)
- *
- * @param       p_j2k                   J2K codec.
- * @param       p_comp_no               the index of the component to output.
- * @param       p_data          FIXME DOC
- * @param       p_data_written  FIXME DOC
- * @param       p_manager               the user event manager.
+Read the COD marker (coding style default)
+@param j2k J2K handle
 */
-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 );
-#endif
-
-/**
- * Gets the maximum size taken by a coc.
- *
- * @param       p_j2k   the jpeg2000 codec to use.
- */
-static OPJ_UINT32 opj_j2k_get_max_coc_size(opj_j2k_t *p_j2k);
-
+static void j2k_read_cod(opj_j2k_t *j2k);
 /**
- * Reads a COC marker (Coding Style Component)
- * @param       p_header_data   the data contained in the COC box.
- * @param       p_j2k                   the jpeg2000 codec.
- * @param       p_header_size   the size of the data contained in the COC marker.
- * @param       p_manager               the user event manager.
+Write the COC marker (coding style component)
+@param j2k J2K handle
+@param compno Number of the component concerned by the information written
 */
-static OPJ_BOOL opj_j2k_read_coc (  opj_j2k_t *p_j2k,
-                                    OPJ_BYTE * p_header_data,
-                                    OPJ_UINT32 p_header_size,
-                                    opj_event_mgr_t * p_manager );
-
+static void j2k_write_coc(opj_j2k_t *j2k, int compno);
 /**
- * Writes the QCD marker (quantization default)
- *
- * @param       p_j2k                   J2K codec.
- * @param       p_stream                the stream to write data to.
- * @param       p_manager               the user event manager.
+Read the COC marker (coding style component)
+@param j2k J2K handle
 */
-static OPJ_BOOL opj_j2k_write_qcd(      opj_j2k_t *p_j2k,
-                                                                        opj_stream_private_t *p_stream,
-                                                                        opj_event_mgr_t * p_manager );
-
+static void j2k_read_coc(opj_j2k_t *j2k);
 /**
- * Reads a QCD marker (Quantization defaults)
- * @param       p_header_data   the data contained in the QCD box.
- * @param       p_j2k                   the jpeg2000 codec.
- * @param       p_header_size   the size of the data contained in the QCD marker.
- * @param       p_manager               the user event manager.
+Write the value concerning the specified component in the marker QCD and QCC
+@param j2k J2K handle
+@param compno Number of the component concerned by the information written
 */
-static OPJ_BOOL opj_j2k_read_qcd (  opj_j2k_t *p_j2k,
-                                    OPJ_BYTE * p_header_data,
-                                    OPJ_UINT32 p_header_size,
-                                    opj_event_mgr_t * p_manager );
-#if 0
+static void j2k_write_qcx(opj_j2k_t *j2k, int compno);
 /**
- * Writes the QCC marker (quantization component)
- *
- * @param       p_comp_no       the index of the component to output.
- * @param       p_stream                the stream to write data to.
- * @param       p_j2k                   J2K codec.
- * @param       p_manager               the user event manager.
+Read the value concerning the specified component in the marker QCD and QCC
+@param j2k J2K handle
+@param compno Number of the component concern by the information read
+@param len Length of the information in the QCX part of the marker QCD/QCC
 */
-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 );
-#endif
-
-#if 0
+static void j2k_read_qcx(opj_j2k_t *j2k, int compno, int len);
 /**
- * Writes the QCC marker (quantization component)
- *
- * @param       p_j2k           J2K codec.
- * @param       p_comp_no       the index of the component to output.
- * @param       p_data          FIXME DOC
- * @param       p_data_written  the stream to write data to.
- * @param       p_manager       the user event manager.
+Write the QCD marker (quantization default)
+@param j2k J2K handle
 */
-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 );
-#endif
-
-/**
- * Gets the maximum size taken by a qcc.
- */
-static OPJ_UINT32 opj_j2k_get_max_qcc_size (opj_j2k_t *p_j2k);
-
+static void j2k_write_qcd(opj_j2k_t *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.
+Read the QCD marker (quantization default)
+@param j2k J2K handle
 */
-static OPJ_BOOL opj_j2k_read_qcc(   opj_j2k_t *p_j2k,
-                                    OPJ_BYTE * p_header_data,
-                                    OPJ_UINT32 p_header_size,
-                                    opj_event_mgr_t * p_manager);
+static void j2k_read_qcd(opj_j2k_t *j2k);
 /**
- * Writes the POC marker (Progression Order Change)
- *
- * @param       p_stream                                the stream to write data to.
- * @param       p_j2k                           J2K codec.
- * @param       p_manager               the user event manager.
+Write the QCC marker (quantization component)
+@param j2k J2K handle
+@param compno Number of the component concerned by the information written
 */
-static OPJ_BOOL opj_j2k_write_poc(      opj_j2k_t *p_j2k,
-                                                                        opj_stream_private_t *p_stream,
-                                                                        opj_event_mgr_t * p_manager );
-/**
- * Writes the POC marker (Progression Order Change)
- *
- * @param       p_j2k          J2K codec.
- * @param       p_data         FIXME DOC
- * @param       p_data_written the stream to write data to.
- * @param       p_manager      the user event manager.
- */
-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 );
-/**
- * Gets the maximum size taken by the writing of a POC.
- */
-static OPJ_UINT32 opj_j2k_get_max_poc_size(opj_j2k_t *p_j2k);
-
+static void j2k_write_qcc(opj_j2k_t *j2k, int compno);
 /**
- * Reads a POC marker (Progression Order Change)
- *
- * @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.
+Read the QCC marker (quantization component)
+@param j2k J2K handle
 */
-static OPJ_BOOL opj_j2k_read_poc (  opj_j2k_t *p_j2k,
-                                    OPJ_BYTE * p_header_data,
-                                    OPJ_UINT32 p_header_size,
-                                    opj_event_mgr_t * p_manager );
-
-/**
- * Gets the maximum size taken by the toc headers of all the tile parts of any given tile.
- */
-static OPJ_UINT32 opj_j2k_get_max_toc_size (opj_j2k_t *p_j2k);
-
-/**
- * Gets the maximum size taken by the headers of the SOT.
- *
- * @param       p_j2k   the jpeg2000 codec to use.
- */
-static OPJ_UINT32 opj_j2k_get_specific_header_sizes(opj_j2k_t *p_j2k);
-
+static void j2k_read_qcc(opj_j2k_t *j2k);
 /**
- * Reads a CRG marker (Component registration)
- *
- * @param       p_header_data   the data contained in the TLM box.
- * @param       p_j2k                   the jpeg2000 codec.
- * @param       p_header_size   the size of the data contained in the TLM marker.
- * @param       p_manager               the user event manager.
+Write the POC marker (progression order change)
+@param j2k J2K handle
 */
-static OPJ_BOOL opj_j2k_read_crg (  opj_j2k_t *p_j2k,
-                                    OPJ_BYTE * p_header_data,
-                                    OPJ_UINT32 p_header_size,
-                                    opj_event_mgr_t * p_manager );
+static void j2k_write_poc(opj_j2k_t *j2k);
 /**
- * Reads a TLM marker (Tile Length Marker)
- *
- * @param       p_header_data   the data contained in the TLM box.
- * @param       p_j2k                   the jpeg2000 codec.
- * @param       p_header_size   the size of the data contained in the TLM marker.
- * @param       p_manager               the user event manager.
+Read the POC marker (progression order change)
+@param j2k J2K handle
 */
-static OPJ_BOOL opj_j2k_read_tlm (  opj_j2k_t *p_j2k,
-                                    OPJ_BYTE * p_header_data,
-                                    OPJ_UINT32 p_header_size,
-                                    opj_event_mgr_t * p_manager);
-
+static void j2k_read_poc(opj_j2k_t *j2k);
 /**
- * Writes the updated tlm.
- *
- * @param       p_stream                the stream to write data to.
- * @param       p_j2k                   J2K codec.
- * @param       p_manager               the user event manager.
+Read the CRG marker (component registration)
+@param j2k J2K handle
 */
-static OPJ_BOOL opj_j2k_write_updated_tlm(      opj_j2k_t *p_j2k,
-                                            opj_stream_private_t *p_stream,
-                                            opj_event_mgr_t * p_manager );
-
+static void j2k_read_crg(opj_j2k_t *j2k);
 /**
- * Reads a PLM marker (Packet length, main header marker)
- *
- * @param       p_header_data   the data contained in the TLM box.
- * @param       p_j2k                   the jpeg2000 codec.
- * @param       p_header_size   the size of the data contained in the TLM marker.
- * @param       p_manager               the user event manager.
+Read the TLM marker (tile-part lengths)
+@param j2k J2K handle
 */
-static OPJ_BOOL opj_j2k_read_plm (  opj_j2k_t *p_j2k,
-                                    OPJ_BYTE * p_header_data,
-                                    OPJ_UINT32 p_header_size,
-                                    opj_event_mgr_t * p_manager);
+static void j2k_read_tlm(opj_j2k_t *j2k);
 /**
- * Reads a PLT marker (Packet length, tile-part header)
- *
- * @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.
+Read the PLM marker (packet length, main header)
+@param j2k J2K handle
 */
-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
+static void j2k_read_plm(opj_j2k_t *j2k);
 /**
- * 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.
+Read the PLT marker (packet length, tile-part header)
+@param j2k J2K handle
 */
-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 void j2k_read_plt(opj_j2k_t *j2k);
 /**
- * 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.
+Read the PPM marker (packet packet headers, main header)
+@param j2k J2K handle
 */
-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 );
+static void j2k_read_ppm(opj_j2k_t *j2k);
 /**
- * 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.
+Read the PPT marker (packet packet headers, tile-part header)
+@param j2k J2K handle
 */
-static OPJ_BOOL opj_j2k_write_tlm(      opj_j2k_t *p_j2k,
-                                                                        opj_stream_private_t *p_stream,
-                                                                        opj_event_mgr_t * p_manager );
-
+static void j2k_read_ppt(opj_j2k_t *j2k);
 /**
- * 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.
+Write the TLM marker (Mainheader)
+@param j2k J2K handle
 */
-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 );
-
+static void j2k_write_tlm(opj_j2k_t *j2k);
 /**
- * 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.
+Write the SOT marker (start of tile-part)
+@param j2k J2K handle
 */
-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 );
+static void j2k_write_sot(opj_j2k_t *j2k);
 /**
- * Writes the SOD marker (Start of data)
- *
- * @param       p_j2k               J2K codec.
- * @param       p_tile_coder        FIXME DOC
- * @param       p_data              FIXME DOC
- * @param       p_data_written      FIXME DOC
- * @param       p_total_data_size   FIXME DOC
- * @param       p_stream            the stream to write data to.
- * @param       p_manager           the user event manager.
+Read the SOT marker (start of tile-part)
+@param j2k J2K handle
 */
-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 );
-
+static void j2k_read_sot(opj_j2k_t *j2k);
 /**
- * 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.
+Write the SOD marker (start of data)
+@param j2k J2K handle
+@param tile_coder Pointer to a TCD handle
 */
-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 )
-{
-        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;
-}
-
+static void j2k_write_sod(opj_j2k_t *j2k, void *tile_coder);
 /**
- * Writes the RGN marker (Region Of Interest)
- *
- * @param       p_tile_no               the tile to output
- * @param       p_comp_no               the component to output
- * @param       nb_comps                the number of components
- * @param       p_stream                the stream to write data to.
- * @param       p_j2k                   J2K codec.
- * @param       p_manager               the user event manager.
+Read the SOD marker (start of data)
+@param j2k J2K handle
 */
-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 );
-
+static void j2k_read_sod(opj_j2k_t *j2k);
 /**
- * Reads a RGN marker (Region Of Interest)
- *
- * @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.
+Write the RGN marker (region-of-interest)
+@param j2k J2K handle
+@param compno Number of the component concerned by the information written
+@param tileno Number of the tile concerned by the information written
 */
-static OPJ_BOOL opj_j2k_read_rgn (opj_j2k_t *p_j2k,
-                                  OPJ_BYTE * p_header_data,
-                                  OPJ_UINT32 p_header_size,
-                                  opj_event_mgr_t * p_manager );
-
+static void j2k_write_rgn(opj_j2k_t *j2k, int compno, int tileno);
 /**
- * Writes the EOC marker (End of Codestream)
- *
- * @param       p_stream                the stream to write data to.
- * @param       p_j2k                   J2K codec.
- * @param       p_manager               the user event manager.
+Read the RGN marker (region-of-interest)
+@param j2k J2K handle
 */
-static OPJ_BOOL opj_j2k_write_eoc(      opj_j2k_t *p_j2k,
-                                    opj_stream_private_t *p_stream,
-                                    opj_event_mgr_t * p_manager );
-
-#if 0
+static void j2k_read_rgn(opj_j2k_t *j2k);
 /**
- * Reads a EOC marker (End Of Codestream)
- *
- * @param       p_j2k                   the jpeg2000 codec.
- * @param       p_stream                FIXME DOC
- * @param       p_manager               the user event manager.
+Write the EOC marker (end of codestream)
+@param j2k J2K handle
 */
-static OPJ_BOOL opj_j2k_read_eoc (      opj_j2k_t *p_j2k,
-                                                                opj_stream_private_t *p_stream,
-                                                                opj_event_mgr_t * p_manager );
-#endif
-
+static void j2k_write_eoc(opj_j2k_t *j2k);
 /**
- * Writes the CBD-MCT-MCC-MCO markers (Multi components transform)
- *
- * @param       p_stream                        the stream to write data to.
- * @param       p_j2k                   J2K codec.
- * @param       p_manager       the user event manager.
+Read the EOC marker (end of codestream)
+@param j2k J2K handle
 */
-static OPJ_BOOL opj_j2k_write_mct_data_group(   opj_j2k_t *p_j2k,
-                                                opj_stream_private_t *p_stream,
-                                                opj_event_mgr_t * p_manager );
-
+static void j2k_read_eoc(opj_j2k_t *j2k);
 /**
- * Inits the Info
- *
- * @param       p_stream                the stream to write data to.
- * @param       p_j2k                   J2K codec.
- * @param       p_manager               the user event manager.
+Read an unknown marker
+@param j2k J2K handle
 */
-static OPJ_BOOL opj_j2k_init_info(      opj_j2k_t *p_j2k,
-                                    opj_stream_private_t *p_stream,
-                                    opj_event_mgr_t * p_manager );
-
+static void j2k_read_unk(opj_j2k_t *j2k);
 /**
 Add main header marker information
-@param cstr_index    Codestream information structure
-@param type         marker type
-@param pos          byte offset of marker segment
-@param len          length of marker segment
- */
-static OPJ_BOOL opj_j2k_add_mhmarker(opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_OFF_T pos, OPJ_UINT32 len) ;
-/**
-Add tile header marker information
-@param tileno       tile index number
-@param cstr_index   Codestream information structure
-@param type         marker type
-@param pos          byte offset of marker segment
-@param len          length of marker segment
- */
-static OPJ_BOOL opj_j2k_add_tlmarker(OPJ_UINT32 tileno, opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_OFF_T pos, OPJ_UINT32 len);
-
-/**
- * Reads an unknown marker
- *
- * @param       p_j2k                   the jpeg2000 codec.
- * @param       p_stream                the stream object to read from.
- * @param       output_marker           FIXME DOC
- * @param       p_manager               the user event manager.
- *
- * @return      true                    if the marker could be deduced.
-*/
-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 );
-
-/**
- * Writes the MCT marker (Multiple Component Transform)
- *
- * @param       p_j2k           J2K codec.
- * @param       p_mct_record    FIXME DOC
- * @param       p_stream        the stream to write data to.
- * @param       p_manager       the user event manager.
-*/
-static OPJ_BOOL opj_j2k_write_mct_record(       opj_j2k_t *p_j2k,
-                                                                                    opj_mct_data_t * p_mct_record,
-                                            opj_stream_private_t *p_stream,
-                                            opj_event_mgr_t * p_manager );
-
-/**
- * Reads a MCT marker (Multiple Component Transform)
- *
- * @param       p_header_data   the data contained in the MCT box.
- * @param       p_j2k                   the jpeg2000 codec.
- * @param       p_header_size   the size of the data contained in the MCT marker.
- * @param       p_manager               the user event manager.
-*/
-static OPJ_BOOL opj_j2k_read_mct (      opj_j2k_t *p_j2k,
-                                                                    OPJ_BYTE * p_header_data,
-                                                                    OPJ_UINT32 p_header_size,
-                                                                    opj_event_mgr_t * p_manager );
-
-/**
- * Writes the MCC marker (Multiple Component Collection)
- *
- * @param       p_j2k                   J2K codec.
- * @param       p_mcc_record            FIXME DOC
- * @param       p_stream                the stream to write data to.
- * @param       p_manager               the user event manager.
-*/
-static OPJ_BOOL opj_j2k_write_mcc_record(   opj_j2k_t *p_j2k,
-                                            opj_simple_mcc_decorrelation_data_t * p_mcc_record,
-                                            opj_stream_private_t *p_stream,
-                                            opj_event_mgr_t * p_manager );
-
-/**
- * Reads a MCC marker (Multiple Component Collection)
- *
- * @param       p_header_data   the data contained in the MCC box.
- * @param       p_j2k                   the jpeg2000 codec.
- * @param       p_header_size   the size of the data contained in the MCC marker.
- * @param       p_manager               the user event manager.
-*/
-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 );
-
-/**
- * Writes the MCO marker (Multiple component transformation ordering)
- *
- * @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_mco(      opj_j2k_t *p_j2k,
-                                    opj_stream_private_t *p_stream,
-                                    opj_event_mgr_t * p_manager );
-
-/**
- * Reads a MCO marker (Multiple Component Transform Ordering)
- *
- * @param       p_header_data   the data contained in the MCO box.
- * @param       p_j2k                   the jpeg2000 codec.
- * @param       p_header_size   the size of the data contained in the MCO marker.
- * @param       p_manager               the user event manager.
-*/
-static OPJ_BOOL opj_j2k_read_mco (      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_add_mct(opj_tcp_t * p_tcp, opj_image_t * p_image, OPJ_UINT32 p_index);
-
-static 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_int32_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);
-static 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_int16_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);
-static 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_float64_to_int32 (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);
-static 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_float (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);
-
-/**
- * Ends the encoding, i.e. frees memory.
- *
- * @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_end_encoding(   opj_j2k_t *p_j2k,
-                                                                            opj_stream_private_t *p_stream,
-                                                                            opj_event_mgr_t * p_manager );
-
-/**
- * Writes the CBD marker (Component bit depth definition)
- *
- * @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_cbd(      opj_j2k_t *p_j2k,
-                                                                    opj_stream_private_t *p_stream,
-                                                                        opj_event_mgr_t * p_manager );
-
-/**
- * Reads a CBD marker (Component bit depth definition)
- * @param       p_header_data   the data contained in the CBD box.
- * @param       p_j2k                   the jpeg2000 codec.
- * @param       p_header_size   the size of the data contained in the CBD marker.
- * @param       p_manager               the user event manager.
-*/
-static OPJ_BOOL opj_j2k_read_cbd (      opj_j2k_t *p_j2k,
-                                                                OPJ_BYTE * p_header_data,
-                                                                OPJ_UINT32 p_header_size,
-                                                                opj_event_mgr_t * p_manager);
-
-#if 0
-/**
- * Writes COC marker for each component.
- *
- * @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_all_coc( opj_j2k_t *p_j2k,
-                                                                        opj_stream_private_t *p_stream,
-                                                                        opj_event_mgr_t * p_manager );
-#endif
-
-#if 0
-/**
- * Writes QCC marker for each component.
- *
- * @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_all_qcc( opj_j2k_t *p_j2k,
-                                                                        opj_stream_private_t *p_stream,
-                                                                        opj_event_mgr_t * p_manager );
-#endif
-
-/**
- * Writes regions of interests.
- *
- * @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_regions(  opj_j2k_t *p_j2k,
-                                                                        opj_stream_private_t *p_stream,
-                                                                        opj_event_mgr_t * p_manager );
-
-/**
- * Writes EPC ????
- *
- * @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_epc(      opj_j2k_t *p_j2k,
-                                                                    opj_stream_private_t *p_stream,
-                                                                    opj_event_mgr_t * p_manager );
-
-/**
- * Checks the progression order changes values. Tells of the poc given as input are valid.
- * A nice message is outputted at errors.
- *
- * @param       p_pocs                  the progression order changes.
- * @param       p_nb_pocs               the number of progression order changes.
- * @param       p_nb_resolutions        the number of resolutions.
- * @param       numcomps                the number of components
- * @param       numlayers               the number of layers.
- * @param       p_manager               the user event manager.
- *
- * @return      true if the pocs are valid.
- */
-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 numcomps,
-                                                                            OPJ_UINT32 numlayers,
-                                                                            opj_event_mgr_t * p_manager);
-
-/**
- * Gets the number of tile parts used for the given change of progression (if any) and the given tile.
- *
- * @param               cp                      the coding parameters.
- * @param               pino            the offset of the given poc (i.e. its position in the coding parameter).
- * @param               tileno          the given tile.
- *
- * @return              the number of tile parts.
- */
-static OPJ_UINT32 opj_j2k_get_num_tp( opj_cp_t *cp, OPJ_UINT32 pino, OPJ_UINT32 tileno);
-
-/**
- * Calculates the total number of tile parts needed by the encoder to
- * encode such an image. If not enough memory is available, then the function return false.
- *
- * @param       p_nb_tiles      pointer that will hold the number of tile parts.
- * @param       cp                      the coding parameters for the image.
- * @param       image           the image to encode.
- * @param       p_j2k                   the p_j2k encoder.
- * @param       p_manager       the user event manager.
- *
- * @return true if the function was successful, false else.
- */
-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);
-
-static void opj_j2k_dump_MH_info(opj_j2k_t* p_j2k, FILE* out_stream);
-
-static void opj_j2k_dump_MH_index(opj_j2k_t* p_j2k, FILE* out_stream);
-
-static opj_codestream_index_t* opj_j2k_create_cstr_index(void);
-
-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);
-
-/*@}*/
-
-/*@}*/
-
-/* ----------------------------------------------------------------------- */
-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[] = {
-        {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 [] =
-{
-        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 [] =
-{
-        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 [] =
-{
-        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 [] =
-{
-  {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_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)
-{
-        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)
-{
-        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)
-{
-        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)
-{
-        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)
-{
-        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)
-{
-        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)
-{
-        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)
-{
-        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)
-{
-        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)
-{
-        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)
-{
-        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)
-{
-        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,
-                                                        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;
-        OPJ_UINT32 step_r = p_num_comps * step_c;
-        OPJ_UINT32 step_l = p_nb_resolutions * step_r;
-        OPJ_BOOL loss = OPJ_FALSE;
-        OPJ_UINT32 layno0 = 0;
-
-        packet_array = (OPJ_UINT32*) opj_calloc(step_l * p_num_layers, sizeof(OPJ_UINT32));
-        if (packet_array == 00) {
-                opj_event_msg(p_manager , EVT_ERROR, "Not enough memory for checking the poc values.\n");
-                return OPJ_FALSE;
-        }
-        memset(packet_array,0,step_l * p_num_layers* sizeof(OPJ_UINT32));
-
-        if (p_nb_pocs == 0) {
-        opj_free(packet_array);
-                return OPJ_TRUE;
-        }
-
-        index = step_r * p_pocs->resno0;
-        /* take each resolution for each poc */
-        for (resno = p_pocs->resno0 ; resno < p_pocs->resno1 ; ++resno)
-        {
-                OPJ_UINT32 res_index = index + p_pocs->compno0 * step_c;
-
-                /* take each comp of each resolution for each poc */
-                for (compno = p_pocs->compno0 ; compno < p_pocs->compno1 ; ++compno) {
-                        OPJ_UINT32 comp_index = res_index + layno0 * step_l;
-
-                        /* and finally take each layer of each res of ... */
-                        for (layno = layno0; layno < p_pocs->layno1 ; ++layno) {
-                                /*index = step_r * resno + step_c * compno + step_l * layno;*/
-                                packet_array[comp_index] = 1;
-                                comp_index += step_l;
-                        }
-
-                        res_index += step_c;
-                }
-
-                index += step_r;
-        }
-        ++p_pocs;
-
-        /* iterate through all the pocs */
-        for (i = 1; i < p_nb_pocs ; ++i) {
-                OPJ_UINT32 l_last_layno1 = (p_pocs-1)->layno1 ;
-
-                layno0 = (p_pocs->layno1 > l_last_layno1)? l_last_layno1 : 0;
-                index = step_r * p_pocs->resno0;
-
-                /* take each resolution for each poc */
-                for (resno = p_pocs->resno0 ; resno < p_pocs->resno1 ; ++resno) {
-                        OPJ_UINT32 res_index = index + p_pocs->compno0 * step_c;
-
-                        /* take each comp of each resolution for each poc */
-                        for (compno = p_pocs->compno0 ; compno < p_pocs->compno1 ; ++compno) {
-                                OPJ_UINT32 comp_index = res_index + layno0 * step_l;
-
-                                /* and finally take each layer of each res of ... */
-                                for (layno = layno0; layno < p_pocs->layno1 ; ++layno) {
-                                        /*index = step_r * resno + step_c * compno + step_l * layno;*/
-                                        packet_array[comp_index] = 1;
-                                        comp_index += step_l;
-                                }
-
-                                res_index += step_c;
-                        }
-
-                        index += step_r;
-                }
-
-                ++p_pocs;
-        }
-
-        index = 0;
-        for (layno = 0; layno < p_num_layers ; ++layno) {
-                for (resno = 0; resno < p_nb_resolutions; ++resno) {
-                        for (compno = 0; compno < p_num_comps; ++compno) {
-                                loss |= (packet_array[index]!=1);
-                                /*index = step_r * resno + step_c * compno + step_l * layno;*/
-                                index += step_c;
-                        }
-                }
-        }
-
-        if (loss) {
-                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)
-{
-        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));
-
-        /* get the given tile coding parameter */
-        tcp = &cp->tcps[tileno];
-        assert(tcp != 00);
-
-        l_current_poc = &(tcp->pocs[pino]);
-        assert(l_current_poc != 0);
-
-        /* get the progression order as a character string */
-        prog = opj_j2k_convert_progression_order(tcp->prg);
-        assert(strlen(prog) > 0);
-
-        if (cp->m_specific_param.m_enc.m_tp_on == 1) {
-                for (i=0;i<4;++i) {
-                        switch (prog[i])
-                        {
-                                /* component wise */
-                                case 'C':
-                                        tpnum *= l_current_poc->compE;
-                                        break;
-                                /* resolution wise */
-                                case 'R':
-                                        tpnum *= l_current_poc->resE;
-                                        break;
-                                /* precinct wise */
-                                case 'P':
-                                        tpnum *= l_current_poc->prcE;
-                                        break;
-                                /* layer wise */
-                                case 'L':
-                                        tpnum *= l_current_poc->layE;
-                                        break;
-                        }
-                        /* whould we split here ? */
-                        if ( cp->m_specific_param.m_enc.m_tp_flag == prog[i] ) {
-                                cp->m_specific_param.m_enc.m_tp_pos=i;
-                                break;
-                        }
-                }
-        }
-        else {
-                tpnum=1;
-        }
-
-        return tpnum;
-}
-
-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;
-
-        /* preconditions */
-        assert(p_nb_tiles != 00);
-        assert(cp != 00);
-        assert(image != 00);
-        assert(p_j2k != 00);
-        assert(p_manager != 00);
-
-        l_nb_tiles = cp->tw * cp->th;
-        * p_nb_tiles = 0;
-        tcp = cp->tcps;
-
-        /* INDEX >> */
-        /* TODO mergeV2: check this part which use cstr_info */
-        /*if (p_j2k->cstr_info) {
-                opj_tile_info_t * l_info_tile_ptr = p_j2k->cstr_info->tile;
-
-                for (tileno = 0; tileno < l_nb_tiles; ++tileno) {
-                        OPJ_UINT32 cur_totnum_tp = 0;
-
-                        opj_pi_update_encoding_parameters(image,cp,tileno);
-
-                        for (pino = 0; pino <= tcp->numpocs; ++pino)
-                        {
-                                OPJ_UINT32 tp_num = opj_j2k_get_num_tp(cp,pino,tileno);
-
-                                *p_nb_tiles = *p_nb_tiles + tp_num;
-
-                                cur_totnum_tp += tp_num;
-                        }
-
-                        tcp->m_nb_tile_parts = cur_totnum_tp;
-
-                        l_info_tile_ptr->tp = (opj_tp_info_t *) opj_malloc(cur_totnum_tp * sizeof(opj_tp_info_t));
-                        if (l_info_tile_ptr->tp == 00) {
-                                return OPJ_FALSE;
-                        }
-
-                        memset(l_info_tile_ptr->tp,0,cur_totnum_tp * sizeof(opj_tp_info_t));
-
-                        l_info_tile_ptr->num_tps = cur_totnum_tp;
-
-                        ++l_info_tile_ptr;
-                        ++tcp;
-                }
-        }
-        else */{
-                for (tileno = 0; tileno < l_nb_tiles; ++tileno) {
-                        OPJ_UINT32 cur_totnum_tp = 0;
-
-                        opj_pi_update_encoding_parameters(image,cp,tileno);
-
-                        for (pino = 0; pino <= tcp->numpocs; ++pino) {
-                                OPJ_UINT32 tp_num = opj_j2k_get_num_tp(cp,pino,tileno);
-
-                                *p_nb_tiles = *p_nb_tiles + tp_num;
-
-                                cur_totnum_tp += tp_num;
-                        }
-                        tcp->m_nb_tile_parts = cur_totnum_tp;
-
-                        ++tcp;
-                }
-        }
-
-        return OPJ_TRUE;
-}
-
-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);
-
-        l_start_stream = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
-
-        /* write SOC identifier */
-        opj_write_bytes(l_start_stream,J2K_MS_SOC,2);
-
-        if (opj_stream_write_data(p_stream,l_start_stream,2,p_manager) != 2) {
-                return OPJ_FALSE;
-        }
-
-/* UniPG>> */
-#ifdef USE_JPWL
-        /* update markers struct */
-/*
-        OPJ_BOOL res = j2k_add_marker(p_j2k->cstr_info, J2K_MS_SOC, p_stream_tell(p_stream) - 2, 2);
-*/
-  assert( 0 && "TODO" );
-#endif /* USE_JPWL */
-/* <<UniPG */
-
-        return OPJ_TRUE;
-}
-
-/**
- * Reads a SOC marker (Start of Codestream)
- * @param       p_j2k           the jpeg2000 file codec.
- * @param       p_stream        FIXME DOC
- * @param       p_manager       the user event manager.
-*/
-static OPJ_BOOL opj_j2k_read_soc(   opj_j2k_t *p_j2k,
-                                    opj_stream_private_t *p_stream,
-                                    opj_event_mgr_t * p_manager
-                                    )
-{
-        OPJ_BYTE l_data [2];
-        OPJ_UINT32 l_marker;
-
-        /* preconditions */
-        assert(p_j2k != 00);
-        assert(p_manager != 00);
-        assert(p_stream != 00);
-
-        if (opj_stream_read_data(p_stream,l_data,2,p_manager) != 2) {
-                return OPJ_FALSE;
-        }
-
-        opj_read_bytes(l_data,&l_marker,2);
-        if (l_marker != J2K_MS_SOC) {
-                return OPJ_FALSE;
-        }
-
-        /* Next marker should be a SIZ marker in the main header */
-        p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_MHSIZ;
-
-        /* FIXME move it in a index structure included in p_j2k*/
-        p_j2k->cstr_index->main_head_start = opj_stream_tell(p_stream) - 2;
-
-        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,
-                                                        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;
-
-        /* preconditions */
-        assert(p_stream != 00);
-        assert(p_j2k != 00);
-        assert(p_manager != 00);
-
-        l_image = p_j2k->m_private_image;
-        cp = &(p_j2k->m_cp);
-        l_size_len = 40 + 3 * l_image->numcomps;
-        l_img_comp = l_image->comps;
-
-        if (l_size_len > 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_size_len);
-                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 for the SIZ 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_size_len;
-        }
-
-        l_current_ptr = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
-
-        /* write SOC identifier */
-        opj_write_bytes(l_current_ptr,J2K_MS_SIZ,2);    /* SIZ */
-        l_current_ptr+=2;
-
-        opj_write_bytes(l_current_ptr,l_size_len-2,2); /* L_SIZ */
-        l_current_ptr+=2;
-
-        opj_write_bytes(l_current_ptr, cp->rsiz, 2);    /* Rsiz (capabilities) */
-        l_current_ptr+=2;
-
-        opj_write_bytes(l_current_ptr, l_image->x1, 4); /* Xsiz */
-        l_current_ptr+=4;
-
-        opj_write_bytes(l_current_ptr, l_image->y1, 4); /* Ysiz */
-        l_current_ptr+=4;
-
-        opj_write_bytes(l_current_ptr, l_image->x0, 4); /* X0siz */
-        l_current_ptr+=4;
-
-        opj_write_bytes(l_current_ptr, l_image->y0, 4); /* Y0siz */
-        l_current_ptr+=4;
-
-        opj_write_bytes(l_current_ptr, cp->tdx, 4);             /* XTsiz */
-        l_current_ptr+=4;
-
-        opj_write_bytes(l_current_ptr, cp->tdy, 4);             /* YTsiz */
-        l_current_ptr+=4;
-
-        opj_write_bytes(l_current_ptr, cp->tx0, 4);             /* XT0siz */
-        l_current_ptr+=4;
-
-        opj_write_bytes(l_current_ptr, cp->ty0, 4);             /* YT0siz */
-        l_current_ptr+=4;
-
-        opj_write_bytes(l_current_ptr, l_image->numcomps, 2);   /* Csiz */
-        l_current_ptr+=2;
-
-        for (i = 0; i < l_image->numcomps; ++i) {
-                /* TODO here with MCT ? */
-                opj_write_bytes(l_current_ptr, l_img_comp->prec - 1 + (l_img_comp->sgnd << 7), 1);      /* Ssiz_i */
-                ++l_current_ptr;
-
-                opj_write_bytes(l_current_ptr, l_img_comp->dx, 1);      /* XRsiz_i */
-                ++l_current_ptr;
-
-                opj_write_bytes(l_current_ptr, l_img_comp->dy, 1);      /* YRsiz_i */
-                ++l_current_ptr;
-
-                ++l_img_comp;
-        }
-
-        if (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_size_len,p_manager) != l_size_len) {
-                return OPJ_FALSE;
-        }
-
-        return OPJ_TRUE;
-}
-
-/**
- * Reads a SIZ marker (image and tile size)
- * @param       p_j2k           the jpeg2000 file codec.
- * @param       p_header_data   the data contained in the SIZ box.
- * @param       p_header_size   the size of the data contained in the SIZ marker.
- * @param       p_manager       the user event manager.
-*/
-static OPJ_BOOL opj_j2k_read_siz(opj_j2k_t *p_j2k,
-                                 OPJ_BYTE * p_header_data,
-                                 OPJ_UINT32 p_header_size,
-                                 opj_event_mgr_t * p_manager
-                                 )
-{
-        OPJ_UINT32 i;
-        OPJ_UINT32 l_nb_comp;
-        OPJ_UINT32 l_nb_comp_remain;
-        OPJ_UINT32 l_remaining_size;
-        OPJ_UINT32 l_nb_tiles;
-        OPJ_UINT32 l_tmp;
-        opj_image_t *l_image = 00;
-        opj_cp_t *l_cp = 00;
-        opj_image_comp_t * l_img_comp = 00;
-        opj_tcp_t * l_current_tile_param = 00;
-
-        /* preconditions */
-        assert(p_j2k != 00);
-        assert(p_manager != 00);
-        assert(p_header_data != 00);
-
-        l_image = p_j2k->m_private_image;
-        l_cp = &(p_j2k->m_cp);
-
-        /* minimum size == 39 - 3 (= minimum component parameter) */
-        if (p_header_size < 36) {
-                opj_event_msg(p_manager, EVT_ERROR, "Error with SIZ marker size\n");
-                return OPJ_FALSE;
-        }
-
-        l_remaining_size = p_header_size - 36;
-        l_nb_comp = l_remaining_size / 3;
-        l_nb_comp_remain = l_remaining_size % 3;
-        if (l_nb_comp_remain != 0){
-                opj_event_msg(p_manager, EVT_ERROR, "Error with SIZ marker size\n");
-                return OPJ_FALSE;
-        }
-
-        opj_read_bytes(p_header_data,&l_tmp ,2);                                                /* Rsiz (capabilities) */
-        p_header_data+=2;
-        l_cp->rsiz = (OPJ_UINT16) l_tmp;
-        opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_image->x1, 4);   /* Xsiz */
-        p_header_data+=4;
-        opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_image->y1, 4);   /* Ysiz */
-        p_header_data+=4;
-        opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_image->x0, 4);   /* X0siz */
-        p_header_data+=4;
-        opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_image->y0, 4);   /* Y0siz */
-        p_header_data+=4;
-        opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_cp->tdx, 4);             /* XTsiz */
-        p_header_data+=4;
-        opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_cp->tdy, 4);             /* YTsiz */
-        p_header_data+=4;
-        opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_cp->tx0, 4);             /* XT0siz */
-        p_header_data+=4;
-        opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_cp->ty0, 4);             /* YT0siz */
-        p_header_data+=4;
-        opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_tmp, 2);                 /* Csiz */
-        p_header_data+=2;
-        if (l_tmp < 16385)
-                l_image->numcomps = (OPJ_UINT16) l_tmp;
-        else {
-                opj_event_msg(p_manager, EVT_ERROR, "Error with SIZ marker: number of component is illegal -> %d\n", l_tmp);
-                return OPJ_FALSE;
-        }
-
-        if (l_image->numcomps != l_nb_comp) {
-                opj_event_msg(p_manager, EVT_ERROR, "Error with SIZ marker: number of component is not compatible with the remaining number of parameters ( %d vs %d)\n", l_image->numcomps, l_nb_comp);
-                return OPJ_FALSE;
-        }
-
-        /* testcase 4035.pdf.SIGSEGV.d8b.3375 */
-        if (l_image->x0 > l_image->x1 || l_image->y0 > l_image->y1) {
-                opj_event_msg(p_manager, EVT_ERROR, "Error with SIZ marker: negative image size (%d x %d)\n", l_image->x1 - l_image->x0, l_image->y1 - l_image->y0);
-                return OPJ_FALSE;
-        }
-        /* testcase 2539.pdf.SIGFPE.706.1712 (also 3622.pdf.SIGFPE.706.2916 and 4008.pdf.SIGFPE.706.3345 and maybe more) */
-        if (!(l_cp->tdx * l_cp->tdy)) {
-                opj_event_msg(p_manager, EVT_ERROR, "Error with SIZ marker: invalid tile size (tdx: %d, tdy: %d)\n", l_cp->tdx, l_cp->tdy);
-                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;
-        }
-
-#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)) {
-                        opj_event_msg(p_manager, EVT_ERROR,
-                                "JPWL: bad image size (%d x %d)\n",
-                                l_image->x1, l_image->y1);
-                        if (!JPWL_ASSUME || JPWL_ASSUME) {
-                                opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n");
-                                return OPJ_FALSE;
-                        }
-                }
-
-        /* FIXME check previously in the function so why keep this piece of code ? Need by the norm ?
-                if (l_image->numcomps != ((len - 38) / 3)) {
-                        opj_event_msg(p_manager, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
-                                "JPWL: Csiz is %d => space in SIZ only for %d comps.!!!\n",
-                                l_image->numcomps, ((len - 38) / 3));
-                        if (!JPWL_ASSUME) {
-                                opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n");
-                                return OPJ_FALSE;
-                        }
-        */              /* we try to correct */
-        /*              opj_event_msg(p_manager, EVT_WARNING, "- trying to adjust this\n");
-                        if (l_image->numcomps < ((len - 38) / 3)) {
-                                len = 38 + 3 * l_image->numcomps;
-                                opj_event_msg(p_manager, EVT_WARNING, "- setting Lsiz to %d => HYPOTHESIS!!!\n",
-                                        len);
-                        } else {
-                                l_image->numcomps = ((len - 38) / 3);
-                                opj_event_msg(p_manager, EVT_WARNING, "- setting Csiz to %d => HYPOTHESIS!!!\n",
-                                        l_image->numcomps);
-                        }
-                }
-        */
-
-                /* update components number in the jpwl_exp_comps filed */
-                l_cp->exp_comps = l_image->numcomps;
-        }
-#endif /* USE_JPWL */
-
-        /* Allocate the resulting image components */
-        l_image->comps = (opj_image_comp_t*) opj_calloc(l_image->numcomps, sizeof(opj_image_comp_t));
-        if (l_image->comps == 00){
-                l_image->numcomps = 0;
-                opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n");
-                return OPJ_FALSE;
-        }
-
-        memset(l_image->comps,0,l_image->numcomps * sizeof(opj_image_comp_t));
-        l_img_comp = l_image->comps;
-
-        /* Read the component information */
-        for (i = 0; i < l_image->numcomps; ++i){
-                OPJ_UINT32 tmp;
-                opj_read_bytes(p_header_data,&tmp,1);   /* Ssiz_i */
-                ++p_header_data;
-                l_img_comp->prec = (tmp & 0x7f) + 1;
-                l_img_comp->sgnd = tmp >> 7;
-                opj_read_bytes(p_header_data,&tmp,1);   /* XRsiz_i */
-                ++p_header_data;
-                l_img_comp->dx = (OPJ_UINT32)tmp; /* should be between 1 and 255 */
-                opj_read_bytes(p_header_data,&tmp,1);   /* YRsiz_i */
-                ++p_header_data;
-                l_img_comp->dy = (OPJ_UINT32)tmp; /* should be between 1 and 255 */
-                if( l_img_comp->dx < 1 || l_img_comp->dx > 255 ||
-                    l_img_comp->dy < 1 || l_img_comp->dy > 255 ) {
-                    opj_event_msg(p_manager, EVT_ERROR,
-                                  "Invalid values for comp = %d : dx=%u dy=%u\n (should be between 1 and 255 according the JPEG2000 norm)",
-                                  i, l_img_comp->dx, l_img_comp->dy);
-                    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, again */
-                        if (!(l_image->comps[i].dx * l_image->comps[i].dy)) {
-                                opj_event_msg(p_manager, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
-                                        "JPWL: bad XRsiz_%d/YRsiz_%d (%d x %d)\n",
-                                        i, i, l_image->comps[i].dx, l_image->comps[i].dy);
-                                if (!JPWL_ASSUME) {
-                                        opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n");
-                                        return OPJ_FALSE;
-                                }
-                                /* we try to correct */
-                                opj_event_msg(p_manager, EVT_WARNING, "- trying to adjust them\n");
-                                if (!l_image->comps[i].dx) {
-                                        l_image->comps[i].dx = 1;
-                                        opj_event_msg(p_manager, EVT_WARNING, "- setting XRsiz_%d to %d => HYPOTHESIS!!!\n",
-                                                i, l_image->comps[i].dx);
-                                }
-                                if (!l_image->comps[i].dy) {
-                                        l_image->comps[i].dy = 1;
-                                        opj_event_msg(p_manager, EVT_WARNING, "- setting YRsiz_%d to %d => HYPOTHESIS!!!\n",
-                                                i, l_image->comps[i].dy);
-                                }
-                        }
-                }
-#endif /* USE_JPWL */
-                l_img_comp->resno_decoded = 0;                                                          /* number of resolution decoded */
-                l_img_comp->factor = l_cp->m_specific_param.m_dec.m_reduce; /* reducing factor per component */
-                ++l_img_comp;
-        }
-
-        /* Compute the number of tiles */
-        l_cp->tw = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)(l_image->x1 - l_cp->tx0), (OPJ_INT32)l_cp->tdx);
-        l_cp->th = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)(l_image->y1 - l_cp->ty0), (OPJ_INT32)l_cp->tdy);
-
-        /* Check that the number of tiles is valid */
-        if (l_cp->tw == 0 || l_cp->th == 0 || l_cp->tw > 65535 / l_cp->th) {
-            opj_event_msg(  p_manager, EVT_ERROR, 
-                            "Invalid number of tiles : %u x %u (maximum fixed by jpeg2000 norm is 65535 tiles)\n",
-                            l_cp->tw, l_cp->th);
-            return OPJ_FALSE;
-        }
-        l_nb_tiles = l_cp->tw * l_cp->th;
-
-        /* Define the tiles which will be decoded */
-        if (p_j2k->m_specific_param.m_decoder.m_discard_tiles) {
-                p_j2k->m_specific_param.m_decoder.m_start_tile_x = (p_j2k->m_specific_param.m_decoder.m_start_tile_x - l_cp->tx0) / l_cp->tdx;
-                p_j2k->m_specific_param.m_decoder.m_start_tile_y = (p_j2k->m_specific_param.m_decoder.m_start_tile_y - l_cp->ty0) / l_cp->tdy;
-                p_j2k->m_specific_param.m_decoder.m_end_tile_x = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)(p_j2k->m_specific_param.m_decoder.m_end_tile_x - l_cp->tx0), (OPJ_INT32)l_cp->tdx);
-                p_j2k->m_specific_param.m_decoder.m_end_tile_y = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)(p_j2k->m_specific_param.m_decoder.m_end_tile_y - l_cp->ty0), (OPJ_INT32)l_cp->tdy);
-        }
-        else {
-                p_j2k->m_specific_param.m_decoder.m_start_tile_x = 0;
-                p_j2k->m_specific_param.m_decoder.m_start_tile_y = 0;
-                p_j2k->m_specific_param.m_decoder.m_end_tile_x = l_cp->tw;
-                p_j2k->m_specific_param.m_decoder.m_end_tile_y = l_cp->th;
-        }
-
-#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_cp->tw < 1) || (l_cp->th < 1) || (l_cp->tw > l_cp->max_tiles) || (l_cp->th > l_cp->max_tiles)) {
-                        opj_event_msg(p_manager, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
-                                "JPWL: bad number of tiles (%d x %d)\n",
-                                l_cp->tw, l_cp->th);
-                        if (!JPWL_ASSUME) {
-                                opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n");
-                                return OPJ_FALSE;
-                        }
-                        /* we try to correct */
-                        opj_event_msg(p_manager, EVT_WARNING, "- trying to adjust them\n");
-                        if (l_cp->tw < 1) {
-                                l_cp->tw= 1;
-                                opj_event_msg(p_manager, EVT_WARNING, "- setting %d tiles in x => HYPOTHESIS!!!\n",
-                                                l_cp->tw);
-                        }
-                        if (l_cp->tw > l_cp->max_tiles) {
-                                l_cp->tw= 1;
-                                opj_event_msg(p_manager, EVT_WARNING, "- too large x, increase expectance of %d\n"
-                                        "- setting %d tiles in x => HYPOTHESIS!!!\n",
-                                        l_cp->max_tiles, l_cp->tw);
-                        }
-                        if (l_cp->th < 1) {
-                                l_cp->th= 1;
-                                opj_event_msg(p_manager, EVT_WARNING, "- setting %d tiles in y => HYPOTHESIS!!!\n",
-                                                l_cp->th);
-                        }
-                        if (l_cp->th > l_cp->max_tiles) {
-                                l_cp->th= 1;
-                                opj_event_msg(p_manager, EVT_WARNING, "- too large y, increase expectance of %d to continue\n",
-                                        "- setting %d tiles in y => HYPOTHESIS!!!\n",
-                                        l_cp->max_tiles, l_cp->th);
-                        }
-                }
-        }
-#endif /* USE_JPWL */
-
-        /* memory allocations */
-        l_cp->tcps = (opj_tcp_t*) opj_calloc(l_nb_tiles, sizeof(opj_tcp_t));
-        if (l_cp->tcps == 00) {
-                opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n");
-                return OPJ_FALSE;
-        }
-        memset(l_cp->tcps,0,l_nb_tiles*sizeof(opj_tcp_t));
-
-#ifdef USE_JPWL
-        if (l_cp->correct) {
-                if (!l_cp->tcps) {
-                        opj_event_msg(p_manager, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
-                                "JPWL: could not alloc tcps field of cp\n");
-                        if (!JPWL_ASSUME || JPWL_ASSUME) {
-                                opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n");
-                                return OPJ_FALSE;
-                        }
-                }
-        }
-#endif /* USE_JPWL */
-
-        p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps =
-                        (opj_tccp_t*) opj_calloc(l_image->numcomps, sizeof(opj_tccp_t));
-        if(p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps  == 00) {
-                opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n");
-                return OPJ_FALSE;
-        }
-        memset(p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps ,0,l_image->numcomps*sizeof(opj_tccp_t));
-
-        p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mct_records =
-                        (opj_mct_data_t*)opj_malloc(OPJ_J2K_MCT_DEFAULT_NB_RECORDS * sizeof(opj_mct_data_t));
-
-        if (! p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mct_records) {
-                opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n");
-                return OPJ_FALSE;
-        }
-        memset(p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mct_records,0,OPJ_J2K_MCT_DEFAULT_NB_RECORDS * sizeof(opj_mct_data_t));
-        p_j2k->m_specific_param.m_decoder.m_default_tcp->m_nb_max_mct_records = OPJ_J2K_MCT_DEFAULT_NB_RECORDS;
-
-        p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mcc_records =
-                        (opj_simple_mcc_decorrelation_data_t*)
-                        opj_malloc(OPJ_J2K_MCC_DEFAULT_NB_RECORDS * sizeof(opj_simple_mcc_decorrelation_data_t));
-
-        if (! p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mcc_records) {
-                opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n");
-                return OPJ_FALSE;
-        }
-        memset(p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mcc_records,0,OPJ_J2K_MCC_DEFAULT_NB_RECORDS * sizeof(opj_simple_mcc_decorrelation_data_t));
-        p_j2k->m_specific_param.m_decoder.m_default_tcp->m_nb_max_mcc_records = OPJ_J2K_MCC_DEFAULT_NB_RECORDS;
-
-        /* set up default dc level shift */
-        for (i=0;i<l_image->numcomps;++i) {
-                if (! l_image->comps[i].sgnd) {
-                        p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps[i].m_dc_level_shift = 1 << (l_image->comps[i].prec - 1);
-                }
-        }
-
-        l_current_tile_param = l_cp->tcps;
-        for     (i = 0; i < l_nb_tiles; ++i) {
-                l_current_tile_param->tccps = (opj_tccp_t*) opj_malloc(l_image->numcomps * sizeof(opj_tccp_t));
-                if (l_current_tile_param->tccps == 00) {
-                        opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n");
-                        return OPJ_FALSE;
-                }
-                memset(l_current_tile_param->tccps,0,l_image->numcomps * sizeof(opj_tccp_t));
-
-                ++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,
-                                                        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 */
-        assert(p_j2k != 00);
-        assert(p_stream != 00);
-        assert(p_manager != 00);
-
-        l_comment = p_j2k->m_cp.comment;
-        l_comment_size = (OPJ_UINT32)strlen(l_comment);
-        l_total_com_size = l_comment_size + 6;
-
-        if (l_total_com_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_total_com_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 the COM 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_total_com_size;
-        }
-
-        l_current_ptr = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
-
-        opj_write_bytes(l_current_ptr,J2K_MS_COM , 2);  /* COM */
-        l_current_ptr+=2;
-
-        opj_write_bytes(l_current_ptr,l_total_com_size - 2 , 2);        /* L_COM */
-        l_current_ptr+=2;
-
-        opj_write_bytes(l_current_ptr,1 , 2);   /* General use (IS 8859-15:1999 (Latin) values) */
-        l_current_ptr+=2;
-
-        memcpy( l_current_ptr,l_comment,l_comment_size);
-
-        if (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_total_com_size,p_manager) != l_total_com_size) {
-                return OPJ_FALSE;
-        }
-
-        return OPJ_TRUE;
-}
-
-/**
- * Reads a COM marker (comments)
- * @param       p_j2k           the jpeg2000 file codec.
- * @param       p_header_data   the data contained in the COM box.
- * @param       p_header_size   the size of the data contained in the COM marker.
- * @param       p_manager               the user event manager.
-*/
-static OPJ_BOOL opj_j2k_read_com (  opj_j2k_t *p_j2k,
-                                    OPJ_BYTE * p_header_data,
-                                    OPJ_UINT32 p_header_size,
-                                    opj_event_mgr_t * p_manager
-                                    )
-{
-        /* 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,
-                                                        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);
-        assert(p_manager != 00);
-        assert(p_stream != 00);
-
-        l_cp = &(p_j2k->m_cp);
-        l_tcp = &l_cp->tcps[p_j2k->m_current_tile_number];
-        l_code_size = 9 + opj_j2k_get_SPCod_SPCoc_size(p_j2k,p_j2k->m_current_tile_number,0);
-        l_remaining_size = l_code_size;
-
-        if (l_code_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_code_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 COD 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_code_size;
-        }
-
-        l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
-
-        opj_write_bytes(l_current_data,J2K_MS_COD,2);           /* COD */
-        l_current_data += 2;
-
-        opj_write_bytes(l_current_data,l_code_size-2,2);        /* L_COD */
-        l_current_data += 2;
-
-        opj_write_bytes(l_current_data,l_tcp->csty,1);          /* Scod */
-        ++l_current_data;
-
-        opj_write_bytes(l_current_data,l_tcp->prg,1);           /* SGcod (A) */
-        ++l_current_data;
-
-        opj_write_bytes(l_current_data,l_tcp->numlayers,2);     /* SGcod (B) */
-        l_current_data+=2;
-
-        opj_write_bytes(l_current_data,l_tcp->mct,1);           /* SGcod (C) */
-        ++l_current_data;
-
-        l_remaining_size -= 9;
-
-        if (! opj_j2k_write_SPCod_SPCoc(p_j2k,p_j2k->m_current_tile_number,0,l_current_data,&l_remaining_size,p_manager)) {
-                opj_event_msg(p_manager, EVT_ERROR, "Error writing COD marker\n");
-                return OPJ_FALSE;
-        }
-
-        if (l_remaining_size != 0) {
-                opj_event_msg(p_manager, EVT_ERROR, "Error writing COD marker\n");
-                return OPJ_FALSE;
-        }
-
-        if (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_code_size,p_manager) != l_code_size) {
-                return OPJ_FALSE;
-        }
-
-        return OPJ_TRUE;
-}
-
-/**
- * Reads a COD marker (Coding Styke defaults)
- * @param       p_header_data   the data contained in the COD box.
- * @param       p_j2k                   the jpeg2000 codec.
- * @param       p_header_size   the size of the data contained in the COD marker.
- * @param       p_manager               the user event manager.
-*/
-static OPJ_BOOL opj_j2k_read_cod (  opj_j2k_t *p_j2k,
-                                    OPJ_BYTE * p_header_data,
-                                    OPJ_UINT32 p_header_size,
-                                    opj_event_mgr_t * p_manager
-                                    )
-{
-        /* loop */
-        OPJ_UINT32 i;
-        OPJ_UINT32 l_tmp;
-        opj_cp_t *l_cp = 00;
-        opj_tcp_t *l_tcp = 00;
-        opj_image_t *l_image = 00;
-
-        /* preconditions */
-        assert(p_header_data != 00);
-        assert(p_j2k != 00);
-        assert(p_manager != 00);
-
-        l_image = p_j2k->m_private_image;
-        l_cp = &(p_j2k->m_cp);
-
-        /* If we are in the first tile-part header of the current tile */
-        l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH) ?
-                                &l_cp->tcps[p_j2k->m_current_tile_number] :
-                                p_j2k->m_specific_param.m_decoder.m_default_tcp;
-
-        /* Make sure room is sufficient */
-        if (p_header_size < 5) {
-                opj_event_msg(p_manager, EVT_ERROR, "Error reading COD marker\n");
-                return OPJ_FALSE;
-        }
-
-        opj_read_bytes(p_header_data,&l_tcp->csty,1);           /* Scod */
-        ++p_header_data;
-        opj_read_bytes(p_header_data,&l_tmp,1);                         /* SGcod (A) */
-        ++p_header_data;
-        l_tcp->prg = (OPJ_PROG_ORDER) l_tmp;
-        opj_read_bytes(p_header_data,&l_tcp->numlayers,2);      /* SGcod (B) */
-        p_header_data+=2;
-
-        /* If user didn't set a number layer to decode take the max specify in the codestream. */
-        if      (l_cp->m_specific_param.m_dec.m_layer) {
-                l_tcp->num_layers_to_decode = l_cp->m_specific_param.m_dec.m_layer;
-        }
-        else {
-                l_tcp->num_layers_to_decode = l_tcp->numlayers;
-        }
-
-        opj_read_bytes(p_header_data,&l_tcp->mct,1);            /* SGcod (C) */
-        ++p_header_data;
-
-        p_header_size -= 5;
-        for     (i = 0; i < l_image->numcomps; ++i) {
-                l_tcp->tccps[i].csty = l_tcp->csty & J2K_CCP_CSTY_PRT;
-        }
-
-        if (! opj_j2k_read_SPCod_SPCoc(p_j2k,0,p_header_data,&p_header_size,p_manager)) {
-                opj_event_msg(p_manager, EVT_ERROR, "Error reading COD marker\n");
-                return OPJ_FALSE;
-        }
-
-        if (p_header_size != 0) {
-                opj_event_msg(p_manager, EVT_ERROR, "Error reading COD marker\n");
-                return OPJ_FALSE;
-        }
-
-        /* Apply the coding style to other components of the current tile or the m_default_tcp*/
-        opj_j2k_copy_tile_component_parameters(p_j2k);
-
-        /* Index */
-#ifdef WIP_REMOVE_MSD
-        if (p_j2k->cstr_info) {
-                /*opj_codestream_info_t *l_cstr_info = p_j2k->cstr_info;*/
-                p_j2k->cstr_info->prog = l_tcp->prg;
-                p_j2k->cstr_info->numlayers = l_tcp->numlayers;
-                p_j2k->cstr_info->numdecompos = (OPJ_INT32*) opj_malloc(l_image->numcomps * sizeof(OPJ_UINT32));
-                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,
-                                                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);
-        assert(p_stream != 00);
-
-        l_comp_room = (p_j2k->m_private_image->numcomps <= 256) ? 1 : 2;
-
-        l_coc_size = 5 + l_comp_room + opj_j2k_get_SPCod_SPCoc_size(p_j2k,p_j2k->m_current_tile_number,p_comp_no);
-
-        if (l_coc_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) {
-                OPJ_BYTE *new_header_tile_data;
-                /*p_j2k->m_specific_param.m_encoder.m_header_tile_data
-                        = (OPJ_BYTE*)opj_realloc(
-                                p_j2k->m_specific_param.m_encoder.m_header_tile_data,
-                                l_coc_size);*/
-
-                new_header_tile_data = (OPJ_BYTE *) opj_realloc(p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_coc_size);
-                if (! new_header_tile_data) {
-                        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 COC 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_coc_size;
-        }
-
-        opj_j2k_write_coc_in_memory(p_j2k,p_comp_no,p_j2k->m_specific_param.m_encoder.m_header_tile_data,&l_remaining_size,p_manager);
-
-        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,
-                                                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;
-        opj_image_t *l_image = 00;
-        OPJ_UINT32 l_comp_room;
-
-        /* preconditions */
-        assert(p_j2k != 00);
-        assert(p_manager != 00);
-
-        l_cp = &(p_j2k->m_cp);
-        l_tcp = &l_cp->tcps[p_j2k->m_current_tile_number];
-        l_image = p_j2k->m_private_image;
-        l_comp_room = (l_image->numcomps <= 256) ? 1 : 2;
-
-        l_coc_size = 5 + l_comp_room + opj_j2k_get_SPCod_SPCoc_size(p_j2k,p_j2k->m_current_tile_number,p_comp_no);
-        l_remaining_size = l_coc_size;
-
-        l_current_data = p_data;
-
-        opj_write_bytes(l_current_data,J2K_MS_COC,2);                           /* COC */
-        l_current_data += 2;
-
-        opj_write_bytes(l_current_data,l_coc_size-2,2);                         /* L_COC */
-        l_current_data += 2;
-
-        opj_write_bytes(l_current_data,p_comp_no, l_comp_room);         /* Ccoc */
-        l_current_data+=l_comp_room;
-
-        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)
-{
-        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;
-
-        for (i=0;i<l_nb_tiles;++i) {
-                for (j=0;j<l_nb_comp;++j) {
-                        l_max = opj_uint_max(l_max,opj_j2k_get_SPCod_SPCoc_size(p_j2k,i,j));
-                }
-        }
-
-        return 6 + l_max;
-}
-
-/**
- * Reads a COC marker (Coding Style Component)
- * @param       p_header_data   the data contained in the COC box.
- * @param       p_j2k                   the jpeg2000 codec.
- * @param       p_header_size   the size of the data contained in the COC marker.
- * @param       p_manager               the user event manager.
-*/
-static OPJ_BOOL opj_j2k_read_coc (  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 = NULL;
-        opj_tcp_t *l_tcp = NULL;
-        opj_image_t *l_image = NULL;
-        OPJ_UINT32 l_comp_room;
-        OPJ_UINT32 l_comp_no;
-
-        /* preconditions */
-        assert(p_header_data != 00);
-        assert(p_j2k != 00);
-        assert(p_manager != 00);
-
-        l_cp = &(p_j2k->m_cp);
-        l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH ) ? /*FIXME J2K_DEC_STATE_TPH*/
-                                &l_cp->tcps[p_j2k->m_current_tile_number] :
-                                p_j2k->m_specific_param.m_decoder.m_default_tcp;
-        l_image = p_j2k->m_private_image;
-
-        l_comp_room = l_image->numcomps <= 256 ? 1 : 2;
-
-        /* make sure room is sufficient*/
-        if (p_header_size < l_comp_room + 1) {
-                opj_event_msg(p_manager, EVT_ERROR, "Error reading COC marker\n");
-                return OPJ_FALSE;
-        }
-        p_header_size -= l_comp_room + 1;
-
-        opj_read_bytes(p_header_data,&l_comp_no,l_comp_room);                   /* Ccoc */
-        p_header_data += l_comp_room;
-        if (l_comp_no >= l_image->numcomps) {
-                opj_event_msg(p_manager, EVT_ERROR, "Error reading COC marker (bad number of components)\n");
-                return OPJ_FALSE;
-        }
-
-        opj_read_bytes(p_header_data,&l_tcp->tccps[l_comp_no].csty,1);                  /* Scoc */
-        ++p_header_data ;
-
-        if (! opj_j2k_read_SPCod_SPCoc(p_j2k,l_comp_no,p_header_data,&p_header_size,p_manager)) {
-                opj_event_msg(p_manager, EVT_ERROR, "Error reading COC marker\n");
-                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,
-                                                        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);
-        assert(p_stream != 00);
-
-        l_qcd_size = 4 + opj_j2k_get_SQcd_SQcc_size(p_j2k,p_j2k->m_current_tile_number,0);
-        l_remaining_size = l_qcd_size;
-
-        if (l_qcd_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_qcd_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 QCD 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_qcd_size;
-        }
-
-        l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
-
-        opj_write_bytes(l_current_data,J2K_MS_QCD,2);           /* QCD */
-        l_current_data += 2;
-
-        opj_write_bytes(l_current_data,l_qcd_size-2,2);         /* L_QCD */
-        l_current_data += 2;
-
-        l_remaining_size -= 4;
-
-        if (! opj_j2k_write_SQcd_SQcc(p_j2k,p_j2k->m_current_tile_number,0,l_current_data,&l_remaining_size,p_manager)) {
-                opj_event_msg(p_manager, EVT_ERROR, "Error writing QCD marker\n");
-                return OPJ_FALSE;
-        }
-
-        if (l_remaining_size != 0) {
-                opj_event_msg(p_manager, EVT_ERROR, "Error writing QCD marker\n");
-                return OPJ_FALSE;
-        }
-
-        if (opj_stream_write_data(p_stream, p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_qcd_size,p_manager) != l_qcd_size) {
-                return OPJ_FALSE;
-        }
-
-        return OPJ_TRUE;
-}
-
-/**
- * Reads a QCD marker (Quantization defaults)
- * @param       p_header_data   the data contained in the QCD box.
- * @param       p_j2k                   the jpeg2000 codec.
- * @param       p_header_size   the size of the data contained in the QCD marker.
- * @param       p_manager               the user event manager.
-*/
-static OPJ_BOOL opj_j2k_read_qcd (  opj_j2k_t *p_j2k,
-                                    OPJ_BYTE * p_header_data,
-                                    OPJ_UINT32 p_header_size,
-                                    opj_event_mgr_t * p_manager
-                                    )
-{
-        /* preconditions */
-        assert(p_header_data != 00);
-        assert(p_j2k != 00);
-        assert(p_manager != 00);
-
-        if (! opj_j2k_read_SQcd_SQcc(p_j2k,0,p_header_data,&p_header_size,p_manager)) {
-                opj_event_msg(p_manager, EVT_ERROR, "Error reading QCD marker\n");
-                return OPJ_FALSE;
-        }
-
-        if (p_header_size != 0) {
-                opj_event_msg(p_manager, EVT_ERROR, "Error reading QCD marker\n");
-                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,
-                                                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);
-        assert(p_stream != 00);
-
-        l_qcc_size = 5 + opj_j2k_get_SQcd_SQcc_size(p_j2k,p_j2k->m_current_tile_number,p_comp_no);
-        l_qcc_size += p_j2k->m_private_image->numcomps <= 256 ? 0:1;
-        l_remaining_size = l_qcc_size;
-
-        if (l_qcc_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_qcc_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 QCC 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_qcc_size;
-        }
-
-        opj_j2k_write_qcc_in_memory(p_j2k,p_comp_no,p_j2k->m_specific_param.m_encoder.m_header_tile_data,&l_remaining_size,p_manager);
-
-        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,
-                                                                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 */
-        assert(p_j2k != 00);
-        assert(p_manager != 00);
-
-        l_qcc_size = 6 + opj_j2k_get_SQcd_SQcc_size(p_j2k,p_j2k->m_current_tile_number,p_comp_no);
-        l_remaining_size = l_qcc_size;
-
-        l_current_data = p_data;
-
-        opj_write_bytes(l_current_data,J2K_MS_QCC,2);           /* QCC */
-        l_current_data += 2;
-
-        if (p_j2k->m_private_image->numcomps <= 256) {
-                --l_qcc_size;
-
-                opj_write_bytes(l_current_data,l_qcc_size-2,2);         /* L_QCC */
-                l_current_data += 2;
-
-                opj_write_bytes(l_current_data, p_comp_no, 1);  /* Cqcc */
-                ++l_current_data;
-
-                /* in the case only one byte is sufficient the last byte allocated is useless -> still do -6 for available */
-                l_remaining_size -= 6;
-        }
-        else {
-                opj_write_bytes(l_current_data,l_qcc_size-2,2);         /* L_QCC */
-                l_current_data += 2;
-
-                opj_write_bytes(l_current_data, p_comp_no, 2);  /* Cqcc */
-                l_current_data+=2;
-
-                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)
-{
-        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.
-*/
-static OPJ_BOOL opj_j2k_read_qcc(   opj_j2k_t *p_j2k,
-                                    OPJ_BYTE * p_header_data,
-                                    OPJ_UINT32 p_header_size,
-                                    opj_event_mgr_t * p_manager
-                                    )
-{
-        OPJ_UINT32 l_num_comp,l_comp_no;
-
-        /* preconditions */
-        assert(p_header_data != 00);
-        assert(p_j2k != 00);
-        assert(p_manager != 00);
-
-        l_num_comp = p_j2k->m_private_image->numcomps;
-
-        if (l_num_comp <= 256) {
-                if (p_header_size < 1) {
-                        opj_event_msg(p_manager, EVT_ERROR, "Error reading QCC marker\n");
-                        return OPJ_FALSE;
-                }
-                opj_read_bytes(p_header_data,&l_comp_no,1);
-                ++p_header_data;
-                --p_header_size;
-        }
-        else {
-                if (p_header_size < 2) {
-                        opj_event_msg(p_manager, EVT_ERROR, "Error reading QCC marker\n");
-                        return OPJ_FALSE;
-                }
-                opj_read_bytes(p_header_data,&l_comp_no,2);
-                p_header_data+=2;
-                p_header_size-=2;
-        }
-
-#ifdef USE_JPWL
-        if (p_j2k->m_cp.correct) {
-
-                static OPJ_UINT32 backup_compno = 0;
-
-                /* compno is negative or larger than the number of components!!! */
-                if (/*(l_comp_no < 0) ||*/ (l_comp_no >= l_num_comp)) {
-                        opj_event_msg(p_manager, EVT_ERROR,
-                                "JPWL: bad component number in QCC (%d out of a maximum of %d)\n",
-                                l_comp_no, l_num_comp);
-                        if (!JPWL_ASSUME) {
-                                opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n");
-                                return OPJ_FALSE;
-                        }
-                        /* we try to correct */
-                        l_comp_no = backup_compno % l_num_comp;
-                        opj_event_msg(p_manager, EVT_WARNING, "- trying to adjust this\n"
-                                "- setting component number to %d\n",
-                                l_comp_no);
-                }
-
-                /* keep your private count of tiles */
-                backup_compno++;
-        };
-#endif /* USE_JPWL */
-
-        if (l_comp_no >= p_j2k->m_private_image->numcomps) {
-                opj_event_msg(p_manager, EVT_ERROR,
-                              "Invalid component number: %d, regarding the number of components %d\n",
-                              l_comp_no, p_j2k->m_private_image->numcomps);
-                return OPJ_FALSE;
-        }
-
-        if (! opj_j2k_read_SQcd_SQcc(p_j2k,l_comp_no,p_header_data,&p_header_size,p_manager)) {
-                opj_event_msg(p_manager, EVT_ERROR, "Error reading QCC marker\n");
-                return OPJ_FALSE;
-        }
-
-        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,
-                                                        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;
-
-        /* 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_nb_comp = p_j2k->m_private_image->numcomps;
-        l_nb_poc = 1 + l_tcp->numpocs;
-
-        if (l_nb_comp <= 256) {
-                l_poc_room = 1;
-        }
-        else {
-                l_poc_room = 2;
-        }
-        l_poc_size = 4 + (5 + 2 * l_poc_room) * l_nb_poc;
-
-        if (l_poc_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_poc_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 POC 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_poc_size;
-        }
-
-        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,
-                                                                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;
-        opj_image_t *l_image = 00;
-        opj_tcp_t *l_tcp = 00;
-        opj_tccp_t *l_tccp = 00;
-        opj_poc_t *l_current_poc = 00;
-        OPJ_UINT32 l_poc_room;
-
-        /* preconditions */
-        assert(p_j2k != 00);
-        assert(p_manager != 00);
-
-        l_tcp = &p_j2k->m_cp.tcps[p_j2k->m_current_tile_number];
-        l_tccp = &l_tcp->tccps[0];
-        l_image = p_j2k->m_private_image;
-        l_nb_comp = l_image->numcomps;
-        l_nb_poc = 1 + l_tcp->numpocs;
-
-        if (l_nb_comp <= 256) {
-                l_poc_room = 1;
-        }
-        else {
-                l_poc_room = 2;
-        }
-
-        l_poc_size = 4 + (5 + 2 * l_poc_room) * l_nb_poc;
-
-        l_current_data = p_data;
-
-        opj_write_bytes(l_current_data,J2K_MS_POC,2);                                   /* POC  */
-        l_current_data += 2;
-
-        opj_write_bytes(l_current_data,l_poc_size-2,2);                                 /* Lpoc */
-        l_current_data += 2;
-
-        l_current_poc =  l_tcp->pocs;
-        for (i = 0; i < l_nb_poc; ++i) {
-                opj_write_bytes(l_current_data,l_current_poc->resno0,1);                                /* RSpoc_i */
-                ++l_current_data;
-
-                opj_write_bytes(l_current_data,l_current_poc->compno0,l_poc_room);              /* CSpoc_i */
-                l_current_data+=l_poc_room;
-
-                opj_write_bytes(l_current_data,l_current_poc->layno1,2);                                /* LYEpoc_i */
-                l_current_data+=2;
-
-                opj_write_bytes(l_current_data,l_current_poc->resno1,1);                                /* REpoc_i */
-                ++l_current_data;
-
-                opj_write_bytes(l_current_data,l_current_poc->compno1,l_poc_room);              /* CEpoc_i */
-                l_current_data+=l_poc_room;
-
-                opj_write_bytes(l_current_data,l_current_poc->prg,1);                                   /* Ppoc_i */
-                ++l_current_data;
-
-                /* change the value of the max layer according to the actual number of layers in the file, components and resolutions*/
-                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)
-{
-        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)
-{
-        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)
-{
-        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);
-                l_nb_bytes += l_nb_comps * l_coc_bytes;
-
-                l_qcc_bytes = opj_j2k_get_max_qcc_size(p_j2k);
-                l_nb_bytes += l_nb_comps * l_qcc_bytes;
-        }
-
-        l_nb_bytes += opj_j2k_get_max_poc_size(p_j2k);
-
-        /*** DEVELOPER CORNER, Add room for your headers ***/
-
-        return l_nb_bytes;
-}
-
-/**
- * Reads a POC marker (Progression Order Change)
- *
- * @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_poc (  opj_j2k_t *p_j2k,
-                                    OPJ_BYTE * p_header_data,
-                                    OPJ_UINT32 p_header_size,
-                                    opj_event_mgr_t * p_manager
-                                    )
-{
-        OPJ_UINT32 i, l_nb_comp, l_tmp;
-        opj_image_t * l_image = 00;
-        OPJ_UINT32 l_old_poc_nb, l_current_poc_nb, l_current_poc_remaining;
-        OPJ_UINT32 l_chunk_size, l_comp_room;
-
-        opj_cp_t *l_cp = 00;
-        opj_tcp_t *l_tcp = 00;
-        opj_poc_t *l_current_poc = 00;
-
-        /* preconditions */
-        assert(p_header_data != 00);
-        assert(p_j2k != 00);
-        assert(p_manager != 00);
-
-        l_image = p_j2k->m_private_image;
-        l_nb_comp = l_image->numcomps;
-        if (l_nb_comp <= 256) {
-                l_comp_room = 1;
-        }
-        else {
-                l_comp_room = 2;
-        }
-        l_chunk_size = 5 + 2 * l_comp_room;
-        l_current_poc_nb = p_header_size / l_chunk_size;
-        l_current_poc_remaining = p_header_size % l_chunk_size;
-
-        if ((l_current_poc_nb <= 0) || (l_current_poc_remaining != 0)) {
-                opj_event_msg(p_manager, EVT_ERROR, "Error reading POC marker\n");
-                return OPJ_FALSE;
-        }
-
-        l_cp = &(p_j2k->m_cp);
-        l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH) ?
-                                &l_cp->tcps[p_j2k->m_current_tile_number] :
-                                p_j2k->m_specific_param.m_decoder.m_default_tcp;
-        l_old_poc_nb = l_tcp->POC ? l_tcp->numpocs + 1 : 0;
-        l_current_poc_nb += l_old_poc_nb;
-
-        if(l_current_poc_nb >= 32)
-          {
-          opj_event_msg(p_manager, EVT_ERROR, "Too many POCs %d\n", l_current_poc_nb);
-          return OPJ_FALSE;
-          }
-        assert(l_current_poc_nb < 32);
-
-        /* now poc is in use.*/
-        l_tcp->POC = 1;
-
-        l_current_poc = &l_tcp->pocs[l_old_poc_nb];
-        for     (i = l_old_poc_nb; i < l_current_poc_nb; ++i) {
-                opj_read_bytes(p_header_data,&(l_current_poc->resno0),1);                               /* RSpoc_i */
-                ++p_header_data;
-                opj_read_bytes(p_header_data,&(l_current_poc->compno0),l_comp_room);    /* CSpoc_i */
-                p_header_data+=l_comp_room;
-                opj_read_bytes(p_header_data,&(l_current_poc->layno1),2);                               /* LYEpoc_i */
-                /* make sure layer end is in acceptable bounds */
-                l_current_poc->layno1 = opj_uint_min(l_current_poc->layno1, l_tcp->numlayers);
-                p_header_data+=2;
-                opj_read_bytes(p_header_data,&(l_current_poc->resno1),1);                               /* REpoc_i */
-                ++p_header_data;
-                opj_read_bytes(p_header_data,&(l_current_poc->compno1),l_comp_room);    /* CEpoc_i */
-                p_header_data+=l_comp_room;
-                opj_read_bytes(p_header_data,&l_tmp,1);                                                                 /* Ppoc_i */
-                ++p_header_data;
-                l_current_poc->prg = (OPJ_PROG_ORDER) l_tmp;
-                /* make sure comp is in acceptable bounds */
-                l_current_poc->compno1 = opj_uint_min(l_current_poc->compno1, l_nb_comp);
-                ++l_current_poc;
-        }
-
-        l_tcp->numpocs = l_current_poc_nb - 1;
-        return OPJ_TRUE;
-}
-
-/**
- * Reads a CRG marker (Component registration)
- *
- * @param       p_header_data   the data contained in the TLM box.
- * @param       p_j2k                   the jpeg2000 codec.
- * @param       p_header_size   the size of the data contained in the TLM marker.
- * @param       p_manager               the user event manager.
-*/
-static OPJ_BOOL opj_j2k_read_crg (  opj_j2k_t *p_j2k,
-                                    OPJ_BYTE * p_header_data,
-                                    OPJ_UINT32 p_header_size,
-                                    opj_event_mgr_t * p_manager
-                                    )
-{
-        OPJ_UINT32 l_nb_comp;
-        /* preconditions */
-        assert(p_header_data != 00);
-        assert(p_j2k != 00);
-        assert(p_manager != 00);
-
-        l_nb_comp = p_j2k->m_private_image->numcomps;
-
-        if (p_header_size != l_nb_comp *4) {
-                opj_event_msg(p_manager, EVT_ERROR, "Error reading CRG marker\n");
-                return OPJ_FALSE;
-        }
-        /* Do not care of this at the moment since only local variables are set here */
-        /*
-        for
-                (i = 0; i < l_nb_comp; ++i)
-        {
-                opj_read_bytes(p_header_data,&l_Xcrg_i,2);                              // Xcrg_i
-                p_header_data+=2;
-                opj_read_bytes(p_header_data,&l_Ycrg_i,2);                              // Xcrg_i
-                p_header_data+=2;
-        }
-        */
-        return OPJ_TRUE;
-}
-
-/**
- * Reads a TLM marker (Tile Length Marker)
- *
- * @param       p_header_data   the data contained in the TLM box.
- * @param       p_j2k                   the jpeg2000 codec.
- * @param       p_header_size   the size of the data contained in the TLM marker.
- * @param       p_manager               the user event manager.
-*/
-static OPJ_BOOL opj_j2k_read_tlm (  opj_j2k_t *p_j2k,
-                                    OPJ_BYTE * p_header_data,
-                                    OPJ_UINT32 p_header_size,
-                                    opj_event_mgr_t * p_manager
-                                    )
-{
-        OPJ_UINT32 l_Ztlm, l_Stlm, l_ST, l_SP, l_tot_num_tp_remaining, l_quotient, l_Ptlm_size;
-        /* preconditions */
-        assert(p_header_data != 00);
-        assert(p_j2k != 00);
-        assert(p_manager != 00);
-
-        if (p_header_size < 2) {
-                opj_event_msg(p_manager, EVT_ERROR, "Error reading TLM marker\n");
-                return OPJ_FALSE;
-        }
-        p_header_size -= 2;
-
-        opj_read_bytes(p_header_data,&l_Ztlm,1);                                /* Ztlm */
-        ++p_header_data;
-        opj_read_bytes(p_header_data,&l_Stlm,1);                                /* Stlm */
-        ++p_header_data;
-
-        l_ST = ((l_Stlm >> 4) & 0x3);
-        l_SP = (l_Stlm >> 6) & 0x1;
-
-        l_Ptlm_size = (l_SP + 1) * 2;
-        l_quotient = l_Ptlm_size + l_ST;
-
-        l_tot_num_tp_remaining = p_header_size % l_quotient;
-
-        if (l_tot_num_tp_remaining != 0) {
-                opj_event_msg(p_manager, EVT_ERROR, "Error reading TLM marker\n");
-                return OPJ_FALSE;
-        }
-        /* FIXME Do not care of this at the moment since only local variables are set here */
-        /*
-        for
-                (i = 0; i < l_tot_num_tp; ++i)
-        {
-                opj_read_bytes(p_header_data,&l_Ttlm_i,l_ST);                           // Ttlm_i
-                p_header_data += l_ST;
-                opj_read_bytes(p_header_data,&l_Ptlm_i,l_Ptlm_size);            // Ptlm_i
-                p_header_data += l_Ptlm_size;
-        }*/
-        return OPJ_TRUE;
-}
-
-/**
- * Reads a PLM marker (Packet length, main header marker)
- *
- * @param       p_header_data   the data contained in the TLM box.
- * @param       p_j2k                   the jpeg2000 codec.
- * @param       p_header_size   the size of the data contained in the TLM marker.
- * @param       p_manager               the user event manager.
-*/
-static OPJ_BOOL opj_j2k_read_plm (  opj_j2k_t *p_j2k,
-                                    OPJ_BYTE * p_header_data,
-                                    OPJ_UINT32 p_header_size,
-                                    opj_event_mgr_t * p_manager
-                                    )
-{
-        /* 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 PLM marker\n");
-                return OPJ_FALSE;
-        }
-        /* Do not care of this at the moment since only local variables are set here */
-        /*
-        opj_read_bytes(p_header_data,&l_Zplm,1);                                        // Zplm
-        ++p_header_data;
-        --p_header_size;
-
-        while
-                (p_header_size > 0)
-        {
-                opj_read_bytes(p_header_data,&l_Nplm,1);                                // Nplm
-                ++p_header_data;
-                p_header_size -= (1+l_Nplm);
-                if
-                        (p_header_size < 0)
-                {
-                        opj_event_msg(p_manager, EVT_ERROR, "Error reading PLM marker\n");
-                        return false;
-                }
-                for
-                        (i = 0; i < l_Nplm; ++i)
-                {
-                        opj_read_bytes(p_header_data,&l_tmp,1);                         // Iplm_ij
-                        ++p_header_data;
-                        // take only the last seven bytes
-                        l_packet_len |= (l_tmp & 0x7f);
-                        if
-                                (l_tmp & 0x80)
-                        {
-                                l_packet_len <<= 7;
-                        }
-                        else
-                        {
-                // store packet length and proceed to next packet
-                                l_packet_len = 0;
-                        }
-                }
-                if
-                        (l_packet_len != 0)
-                {
-                        opj_event_msg(p_manager, EVT_ERROR, "Error reading PLM marker\n");
-                        return false;
-                }
-        }
-        */
-        return OPJ_TRUE;
-}
-
-/**
- * Reads a PLT marker (Packet length, tile-part header)
- *
- * @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
-                                    )
-{
-        OPJ_UINT32 l_Zplt, l_tmp, l_packet_len = 0, i;
-
-        /* 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 PLT marker\n");
-                return OPJ_FALSE;
-        }
-
-        opj_read_bytes(p_header_data,&l_Zplt,1);                /* Zplt */
-        ++p_header_data;
-        --p_header_size;
-
-        for (i = 0; i < p_header_size; ++i) {
-                opj_read_bytes(p_header_data,&l_tmp,1);         /* Iplt_ij */
-                ++p_header_data;
-                /* take only the last seven bytes */
-                l_packet_len |= (l_tmp & 0x7f);
-                if (l_tmp & 0x80) {
-                        l_packet_len <<= 7;
-                }
-                else {
-            /* store packet length and proceed to next packet */
-                        l_packet_len = 0;
-                }
-        }
-
-        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
-                                        )
-{
-
-        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;
-}
-#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
-                                        )
-{
-        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) {
-                /* 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_malloc(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;
-                }
-                memset(l_cp->ppm_data,0,l_cp->ppm_len);
-
-                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)
-                {
-                        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");
-                        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");
-                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;
-}
-
-/**
- * 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;
-
-        /* 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;
-        }
-
-        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;
-
-        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_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);
-        assert(p_stream != 00);
-
-        l_tlm_size = 6 + (5*p_j2k->m_specific_param.m_encoder.m_total_tile_parts);
-
-        if (l_tlm_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_tlm_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 TLM 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_tlm_size;
-        }
-
-        l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
-
-        /* change the way data is written to avoid seeking if possible */
-        /* TODO */
-        p_j2k->m_specific_param.m_encoder.m_tlm_start = opj_stream_tell(p_stream);
-
-        opj_write_bytes(l_current_data,J2K_MS_TLM,2);                                   /* TLM */
-        l_current_data += 2;
-
-        opj_write_bytes(l_current_data,l_tlm_size-2,2);                                 /* Lpoc */
-        l_current_data += 2;
-
-        opj_write_bytes(l_current_data,0,1);                                                    /* Ztlm=0*/
-        ++l_current_data;
-
-        opj_write_bytes(l_current_data,0x50,1);                                                 /* Stlm ST=1(8bits-255 tiles max),SP=1(Ptlm=32bits) */
-        ++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,
-                                                        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);
-
-        opj_write_bytes(p_data,J2K_MS_SOT,2);                                   /* SOT */
-        p_data += 2;
-
-        opj_write_bytes(p_data,10,2);                                                   /* Lsot */
-        p_data += 2;
-
-        opj_write_bytes(p_data, p_j2k->m_current_tile_number,2);                        /* Isot */
-        p_data += 2;
-
-        /* Psot  */
-        p_data += 4;
-
-        opj_write_bytes(p_data, p_j2k->m_specific_param.m_encoder.m_current_tile_part_number,1);                        /* TPsot */
-        ++p_data;
-
-        opj_write_bytes(p_data, p_j2k->m_cp.tcps[p_j2k->m_current_tile_number].m_nb_tile_parts,1);                      /* TNsot */
-        ++p_data;
-
-        /* UniPG>> */
-#ifdef USE_JPWL
-        /* update markers struct */
-/*
-        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,
-                            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) {
-                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;
-
-#ifdef USE_JPWL
-        if (l_cp->correct) {
-
-                OPJ_UINT32 tileno = p_j2k->m_current_tile_number;
-                static OPJ_UINT32 backup_tileno = 0;
-
-                /* tileno is negative or larger than the number of tiles!!! */
-                if (tileno > (l_cp->tw * l_cp->th)) {
-                        opj_event_msg(p_manager, EVT_ERROR,
-                                        "JPWL: bad tile number (%d out of a maximum of %d)\n",
-                                        tileno, (l_cp->tw * l_cp->th));
-                        if (!JPWL_ASSUME) {
-                                opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n");
-                                return OPJ_FALSE;
-                        }
-                        /* we try to correct */
-                        tileno = backup_tileno;
-                        opj_event_msg(p_manager, EVT_WARNING, "- trying to adjust this\n"
-                                        "- setting tile number to %d\n",
-                                        tileno);
-                }
-
-                /* 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);
-                return OPJ_FALSE;
-            }
-        }
-
-#ifdef USE_JPWL
-        if (l_cp->correct) {
-
-                /* totlen is negative or larger than the bytes left!!! */
-                if (/*(l_tot_len < 0) ||*/ (l_tot_len > p_header_size ) ) { /* FIXME it seems correct; for info in V1 -> (p_stream_numbytesleft(p_stream) + 8))) { */
-                        opj_event_msg(p_manager, EVT_ERROR,
-                                        "JPWL: bad tile byte size (%d bytes against %d bytes left)\n",
-                                        l_tot_len, p_header_size ); /* FIXME it seems correct; for info in V1 -> p_stream_numbytesleft(p_stream) + 8); */
-                        if (!JPWL_ASSUME) {
-                                opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n");
-                                return OPJ_FALSE;
-                        }
-                        /* we try to correct */
-                        l_tot_len = 0;
-                        opj_event_msg(p_manager, EVT_WARNING, "- trying to adjust this\n"
-                                        "- setting Psot to %d => assuming it is the last tile\n",
-                                        l_tot_len);
-                }
-                };
-#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 */
-                        /* 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;
-                                }
-                        }
-                        if( l_current_part >= l_num_parts ) {
-                          /* testcase 451.pdf.SIGSEGV.ce9.3723 */
-                          opj_event_msg(p_manager, EVT_ERROR, "In SOT marker, TPSot (%d) is not valid regards to the current "
-                            "number of tile-part (header) (%d), giving up\n", l_current_part, l_num_parts );
-                          p_j2k->m_specific_param.m_decoder.m_last_tile_part = 1;
-                          return OPJ_FALSE;
-                        }
-                        l_tcp->m_nb_tile_parts = l_num_parts;
-                }
-
-                /* If know the number of tile part header we will check if we didn't read the last*/
-                if (l_tcp->m_nb_tile_parts) {
-                        if (l_tcp->m_nb_tile_parts == (l_current_part+1)) {
-                                p_j2k->m_specific_param.m_decoder.m_can_decode = 1; /* Process the last tile-part header*/
-                        }
-                }
-
-                if (!p_j2k->m_specific_param.m_decoder.m_last_tile_part){
-                        /* Keep the size of data to skip after this marker */
-                        p_j2k->m_specific_param.m_decoder.m_sot_length = l_tot_len - 12; /* SOT_marker_size = 12 */
-                }
-                else {
-                        /* FIXME: need to be computed from the number of bytes remaining in the codestream */
-                        p_j2k->m_specific_param.m_decoder.m_sot_length = 0;
-                }
-
-                p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_TPH;
-
-                /* Check if the current tile is outside the area we want decode or not corresponding to the tile index*/
-                if (p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec == -1) {
-                        p_j2k->m_specific_param.m_decoder.m_skip_data =
-                                (l_tile_x < p_j2k->m_specific_param.m_decoder.m_start_tile_x)
-                                ||      (l_tile_x >= p_j2k->m_specific_param.m_decoder.m_end_tile_x)
-                                ||  (l_tile_y < p_j2k->m_specific_param.m_decoder.m_start_tile_y)
-                                ||      (l_tile_y >= p_j2k->m_specific_param.m_decoder.m_end_tile_y);
-                }
-                else {
-                        assert( p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec >= 0 );
-                        p_j2k->m_specific_param.m_decoder.m_skip_data =
-                                (p_j2k->m_current_tile_number != (OPJ_UINT32)p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec);
-                }
-
-                /* Index */
-                if (p_j2k->cstr_index)
-                {
-                        assert(p_j2k->cstr_index->tile_index != 00);
-                        p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tileno = p_j2k->m_current_tile_number;
-                        p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_tpsno = l_current_part;
-
-                        if (l_num_parts != 0){
-                                p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].nb_tps = l_num_parts;
-                                p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps = l_num_parts;
-
-                                if (!p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index) {
-                                        p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index =
-                                                (opj_tp_index_t*)opj_calloc(l_num_parts, sizeof(opj_tp_index_t));
-                                }
-                                else {
-                                        opj_tp_index_t *new_tp_index = (opj_tp_index_t *) opj_realloc(
-                                                        p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index, l_num_parts* sizeof(opj_tp_index_t));
-                                        if (! new_tp_index) {
-                                                opj_free(p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index);
-                                                p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index = NULL;
-                                                opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read PPT marker\n");
-                                                return OPJ_FALSE;
-                                        }
-                                        p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index = new_tp_index;
-                                }
-                        }
-                        else{
-                                /*if (!p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index)*/ {
-
-                                        if (!p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index) {
-                                                p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps = 10;
-                                                p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index =
-                                                        (opj_tp_index_t*)opj_calloc( p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps,
-                                                                        sizeof(opj_tp_index_t));
-                                        }
-
-                                        if ( l_current_part >= p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps ){
-                                                opj_tp_index_t *new_tp_index;
-                                                p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps = l_current_part + 1;
-                                                new_tp_index = (opj_tp_index_t *) opj_realloc(
-                                                                p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index,
-                                                                p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps * sizeof(opj_tp_index_t));
-                                                if (! new_tp_index) {
-                                                        opj_free(p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index);
-                                                        p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index = NULL;
-                                                        p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps = 0;
-                                                        opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read PPT marker\n");
-                                                        return OPJ_FALSE;
-                                                }
-                                                p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index = new_tp_index;
-                                        }
-                                }
-
-                        }
-
-                }
-
-                /* FIXME move this onto a separate method to call before reading any SOT, remove part about main_end header, use a index struct inside p_j2k */
-                /* if (p_j2k->cstr_info) {
-                   if (l_tcp->first) {
-                   if (tileno == 0) {
-                   p_j2k->cstr_info->main_head_end = p_stream_tell(p_stream) - 13;
-                   }
-
-                   p_j2k->cstr_info->tile[tileno].tileno = tileno;
-                   p_j2k->cstr_info->tile[tileno].start_pos = p_stream_tell(p_stream) - 12;
-                   p_j2k->cstr_info->tile[tileno].end_pos = p_j2k->cstr_info->tile[tileno].start_pos + totlen - 1;
-                   p_j2k->cstr_info->tile[tileno].num_tps = numparts;
-
-                   if (numparts) {
-                   p_j2k->cstr_info->tile[tileno].tp = (opj_tp_info_t *) opj_malloc(numparts * sizeof(opj_tp_info_t));
-                   }
-                   else {
-                   p_j2k->cstr_info->tile[tileno].tp = (opj_tp_info_t *) opj_malloc(10 * sizeof(opj_tp_info_t)); // Fixme (10)
-                   }
-                   }
-                   else {
-                   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,
-                                                        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;
-
-        /* preconditions */
-        assert(p_j2k != 00);
-        assert(p_manager != 00);
-        assert(p_stream != 00);
-
-        opj_write_bytes(p_data,J2K_MS_SOD,2);                                   /* SOD */
-        p_data += 2;
-
-        /* make room for the EOF marker */
-        l_remaining_data =  p_total_data_size - 4;
-
-        /* update tile coder */
-        p_tile_coder->tp_num = p_j2k->m_specific_param.m_encoder.m_current_poc_tile_part_number ;
-        p_tile_coder->cur_tp_num = p_j2k->m_specific_param.m_encoder.m_current_tile_part_number;
-
-         /* INDEX >> */
-        /* TODO mergeV2: check this part which use cstr_info */
-        /*l_cstr_info = p_j2k->cstr_info;
-        if (l_cstr_info) {
-                if (!p_j2k->m_specific_param.m_encoder.m_current_tile_part_number ) {
-                        //TODO cstr_info->tile[p_j2k->m_current_tile_number].end_header = p_stream_tell(p_stream) + p_j2k->pos_correction - 1;
-                        l_cstr_info->tile[p_j2k->m_current_tile_number].tileno = p_j2k->m_current_tile_number;
-                }
-                else {*/
-                        /*
-                        TODO
-                        if
-                                (cstr_info->tile[p_j2k->m_current_tile_number].packet[cstr_info->packno - 1].end_pos < p_stream_tell(p_stream))
-                        {
-                                cstr_info->tile[p_j2k->m_current_tile_number].packet[cstr_info->packno].start_pos = p_stream_tell(p_stream);
-                        }*/
-                /*}*/
-                /* UniPG>> */
-#ifdef USE_JPWL
-                /* update markers struct */
-                /*OPJ_BOOL res = j2k_add_marker(p_j2k->cstr_info, J2K_MS_SOD, p_j2k->sod_start, 2);
-*/
-  assert( 0 && "TODO" );
-#endif /* USE_JPWL */
-                /* <<UniPG */
-        /*}*/
-        /* << INDEX */
-
-        if (p_j2k->m_specific_param.m_encoder.m_current_tile_part_number == 0) {
-                p_tile_coder->tcd_image->tiles->packno = 0;
-                if (l_cstr_info) {
-                        l_cstr_info->packno = 0;
-                }
-        }
-
-        *p_data_written = 0;
-
-        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,
-                           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;
-
-        /* 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]);
-
-        if (p_j2k->m_specific_param.m_decoder.m_last_tile_part) {
-                /* opj_stream_get_number_byte_left returns OPJ_OFF_T
-                // but we are in the last tile part,
-                // so its result will fit on OPJ_UINT32 unless we find
-                // a file with a single tile part of more than 4 GB...*/
-                p_j2k->m_specific_param.m_decoder.m_sot_length = (OPJ_UINT32)(opj_stream_get_number_byte_left(p_stream) - 2);
-        }
-        else {
-            /* Check to avoid pass the limit of OPJ_UINT32 */
-            if (p_j2k->m_specific_param.m_decoder.m_sot_length >= 2 )
-                p_j2k->m_specific_param.m_decoder.m_sot_length -= 2;
-            else {
-                /* MSD: case commented to support empty SOT marker (PHR data) */
-            }
-        }
-
-        l_current_data = &(l_tcp->m_data);
-        l_tile_len = &l_tcp->m_data_size;
-
-        /* Patch to support new PHR data */
-        if (p_j2k->m_specific_param.m_decoder.m_sot_length) {
-            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,...).
-                 */
-                *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
-                          function. */
-                }
-                *l_current_data = l_new_current_data;
-            }
-            
-            if (*l_current_data == 00) {
-                opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to decode tile\n");
-                return OPJ_FALSE;
-            }
-        }
-        else {
-            l_sot_length_pb_detected = OPJ_TRUE;
-        }
-
-        /* Index */
-        l_cstr_index = p_j2k->cstr_index;
-        if (l_cstr_index) {
-                OPJ_OFF_T l_current_pos = opj_stream_tell(p_stream) - 2;
-
-                OPJ_UINT32 l_current_tile_part = l_cstr_index->tile_index[p_j2k->m_current_tile_number].current_tpsno;
-                l_cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index[l_current_tile_part].end_header =
-                                l_current_pos;
-                l_cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index[l_current_tile_part].end_pos =
-                                l_current_pos + p_j2k->m_specific_param.m_decoder.m_sot_length + 2;
-
-                if (OPJ_FALSE == opj_j2k_add_tlmarker(p_j2k->m_current_tile_number,
-                                        l_cstr_index,
-                                        J2K_MS_SOD,
-                                        l_current_pos,
-                                        p_j2k->m_specific_param.m_decoder.m_sot_length + 2)) {
-                        opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to add tl marker\n");
-                        return OPJ_FALSE;
-                }
-
-                /*l_cstr_index->packno = 0;*/
-        }
-
-        /* Patch to support new PHR data */
-        if (!l_sot_length_pb_detected) {
-            l_current_read_size = opj_stream_read_data(
-                        p_stream,
-                        *l_current_data + *l_tile_len,
-                        p_j2k->m_specific_param.m_decoder.m_sot_length,
-                        p_manager);
-        }
-        else
-        {
-            l_current_read_size = 0;
-        }
-
-        if (l_current_read_size != p_j2k->m_specific_param.m_decoder.m_sot_length) {
-                p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_NEOC;
-        }
-        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,
-                            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;
-        opj_tcp_t *l_tcp = 00;
-        opj_tccp_t *l_tccp = 00;
-        OPJ_UINT32 l_comp_room;
-
-        /* preconditions */
-        assert(p_j2k != 00);
-        assert(p_manager != 00);
-        assert(p_stream != 00);
-
-        l_cp = &(p_j2k->m_cp);
-        l_tcp = &l_cp->tcps[p_tile_no];
-        l_tccp = &l_tcp->tccps[p_comp_no];
-
-        if (nb_comps <= 256) {
-                l_comp_room = 1;
-        }
-        else {
-                l_comp_room = 2;
-        }
-
-        l_rgn_size = 6 + l_comp_room;
-
-        l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
-
-        opj_write_bytes(l_current_data,J2K_MS_RGN,2);                                   /* RGN  */
-        l_current_data += 2;
-
-        opj_write_bytes(l_current_data,l_rgn_size-2,2);                                 /* Lrgn */
-        l_current_data += 2;
-
-        opj_write_bytes(l_current_data,p_comp_no,l_comp_room);                          /* Crgn */
-        l_current_data+=l_comp_room;
-
-        opj_write_bytes(l_current_data, 0,1);                                           /* Srgn */
-        ++l_current_data;
-
-        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,
-                            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 */
-
-/* UniPG>> */
-#ifdef USE_JPWL
-        /* update markers struct */
-        /*
-        OPJ_BOOL res = j2k_add_marker(p_j2k->cstr_info, J2K_MS_EOC, p_stream_tell(p_stream) - 2, 2);
-*/
-#endif /* USE_JPWL */
-
-        if ( opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,2,p_manager) != 2) {
-                return OPJ_FALSE;
-        }
-
-        if ( ! opj_stream_flush(p_stream,p_manager) ) {
-                return OPJ_FALSE;
-        }
-
-        return OPJ_TRUE;
-}
-
-/**
- * Reads a RGN marker (Region Of Interest)
- *
- * @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_rgn (opj_j2k_t *p_j2k,
-                                  OPJ_BYTE * p_header_data,
-                                  OPJ_UINT32 p_header_size,
-                                  opj_event_mgr_t * p_manager
-                                  )
-{
-        OPJ_UINT32 l_nb_comp;
-        opj_image_t * l_image = 00;
-
-        opj_cp_t *l_cp = 00;
-        opj_tcp_t *l_tcp = 00;
-        OPJ_UINT32 l_comp_room, l_comp_no, l_roi_sty;
-
-        /* preconditions*/
-        assert(p_header_data != 00);
-        assert(p_j2k != 00);
-        assert(p_manager != 00);
-
-        l_image = p_j2k->m_private_image;
-        l_nb_comp = l_image->numcomps;
-
-        if (l_nb_comp <= 256) {
-                l_comp_room = 1; }
-        else {
-                l_comp_room = 2; }
-
-        if (p_header_size != 2 + l_comp_room) {
-                opj_event_msg(p_manager, EVT_ERROR, "Error reading RGN marker\n");
-                return OPJ_FALSE;
-        }
-
-        l_cp = &(p_j2k->m_cp);
-        l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH) ?
-                                &l_cp->tcps[p_j2k->m_current_tile_number] :
-                                p_j2k->m_specific_param.m_decoder.m_default_tcp;
-
-        opj_read_bytes(p_header_data,&l_comp_no,l_comp_room);           /* Crgn */
-        p_header_data+=l_comp_room;
-        opj_read_bytes(p_header_data,&l_roi_sty,1);                                     /* Srgn */
-        ++p_header_data;
-
-#ifdef USE_JPWL
-        if (l_cp->correct) {
-                /* totlen is negative or larger than the bytes left!!! */
-                if (l_comp_room >= l_nb_comp) {
-                        opj_event_msg(p_manager, EVT_ERROR,
-                                "JPWL: bad component number in RGN (%d when there are only %d)\n",
-                                l_comp_room, l_nb_comp);
-                        if (!JPWL_ASSUME || JPWL_ASSUME) {
-                                opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n");
-                                return OPJ_FALSE;
-                        }
-                }
-        };
-#endif /* USE_JPWL */
-
-        /* testcase 3635.pdf.asan.77.2930 */
-        if (l_comp_no >= l_nb_comp) {
-                opj_event_msg(p_manager, EVT_ERROR,
-                        "bad component number in RGN (%d when there are only %d)\n",
-                        l_comp_no, l_nb_comp);
-                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)
-{
-        return (OPJ_FLOAT32) ((p_tcp->m_nb_tile_parts - 1) * 14);
-}
-
-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,
-                                                            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;
-        OPJ_FLOAT32 * l_rates = 0;
-        OPJ_FLOAT32 l_sot_remove;
-        OPJ_UINT32 l_bits_empty, l_size_pixel;
-        OPJ_UINT32 l_tile_size = 0;
-        OPJ_UINT32 l_last_res;
-        OPJ_FLOAT32 (* l_tp_stride_func)(opj_tcp_t *) = 00;
-
-        /* preconditions */
-        assert(p_j2k != 00);
-        assert(p_manager != 00);
-        assert(p_stream != 00);
-
-        l_cp = &(p_j2k->m_cp);
-        l_image = p_j2k->m_private_image;
-        l_tcp = l_cp->tcps;
-
-        l_bits_empty = 8 * l_image->comps->dx * l_image->comps->dy;
-        l_size_pixel = l_image->numcomps * l_image->comps->prec;
-        l_sot_remove = (OPJ_FLOAT32) opj_stream_tell(p_stream) / (OPJ_FLOAT32)(l_cp->th * l_cp->tw);
-
-        if (l_cp->m_specific_param.m_enc.m_tp_on) {
-                l_tp_stride_func = opj_j2k_get_tp_stride;
-        }
-        else {
-                l_tp_stride_func = opj_j2k_get_default_stride;
-        }
-
-        for (i=0;i<l_cp->th;++i) {
-                for (j=0;j<l_cp->tw;++j) {
-                        OPJ_FLOAT32 l_offset = (OPJ_FLOAT32)(*l_tp_stride_func)(l_tcp) / (OPJ_FLOAT32)l_tcp->numlayers;
-
-                        /* 4 borders of the tile rescale on the image if necessary */
-                        l_x0 = opj_int_max((OPJ_INT32)(l_cp->tx0 + j * l_cp->tdx), (OPJ_INT32)l_image->x0);
-                        l_y0 = opj_int_max((OPJ_INT32)(l_cp->ty0 + i * l_cp->tdy), (OPJ_INT32)l_image->y0);
-                        l_x1 = opj_int_min((OPJ_INT32)(l_cp->tx0 + (j + 1) * l_cp->tdx), (OPJ_INT32)l_image->x1);
-                        l_y1 = opj_int_min((OPJ_INT32)(l_cp->ty0 + (i + 1) * l_cp->tdy), (OPJ_INT32)l_image->y1);
-
-                        l_rates = l_tcp->rates;
-
-                        /* Modification of the RATE >> */
-                        if (*l_rates) {
-                                *l_rates =              (( (OPJ_FLOAT32) (l_size_pixel * (OPJ_UINT32)(l_x1 - l_x0) * (OPJ_UINT32)(l_y1 - l_y0)))
-                                                                /
-                                                                ((*l_rates) * (OPJ_FLOAT32)l_bits_empty)
-                                                                )
-                                                                -
-                                                                l_offset;
-                        }
-
-                        ++l_rates;
-
-                        for (k = 1; k < l_tcp->numlayers; ++k) {
-                                if (*l_rates) {
-                                        *l_rates =              (( (OPJ_FLOAT32) (l_size_pixel * (OPJ_UINT32)(l_x1 - l_x0) * (OPJ_UINT32)(l_y1 - l_y0)))
-                                                                        /
-                                                                                ((*l_rates) * (OPJ_FLOAT32)l_bits_empty)
-                                                                        )
-                                                                        -
-                                                                        l_offset;
-                                }
-
-                                ++l_rates;
-                        }
-
-                        ++l_tcp;
-
-                }
-        }
-
-        l_tcp = l_cp->tcps;
-
-        for (i=0;i<l_cp->th;++i) {
-                for     (j=0;j<l_cp->tw;++j) {
-                        l_rates = l_tcp->rates;
-
-                        if (*l_rates) {
-                                *l_rates -= l_sot_remove;
-
-                                if (*l_rates < 30) {
-                                        *l_rates = 30;
-                                }
-                        }
-
-                        ++l_rates;
-
-                        l_last_res = l_tcp->numlayers - 1;
-
-                        for (k = 1; k < l_last_res; ++k) {
-
-                                if (*l_rates) {
-                                        *l_rates -= l_sot_remove;
-
-                                        if (*l_rates < *(l_rates - 1) + 10) {
-                                                *l_rates  = (*(l_rates - 1)) + 20;
-                                        }
-                                }
-
-                                ++l_rates;
-                        }
-
-                        if (*l_rates) {
-                                *l_rates -= (l_sot_remove + 2.f);
-
-                                if (*l_rates < *(l_rates - 1) + 10) {
-                                        *l_rates  = (*(l_rates - 1)) + 20;
-                                }
-                        }
-
-                        ++l_tcp;
-                }
-        }
-
-        l_img_comp = l_image->comps;
-        l_tile_size = 0;
-
-        for (i=0;i<l_image->numcomps;++i) {
-                l_tile_size += (        opj_uint_ceildiv(l_cp->tdx,l_img_comp->dx)
-                                                        *
-                                                        opj_uint_ceildiv(l_cp->tdy,l_img_comp->dy)
-                                                        *
-                                                        l_img_comp->prec
-                                                );
-
-                ++l_img_comp;
-        }
-
-        l_tile_size = (OPJ_UINT32) (l_tile_size * 0.1625); /* 1.3/8 = 0.1625 */
-
-        l_tile_size += opj_j2k_get_specific_header_sizes(p_j2k);
-
-        p_j2k->m_specific_param.m_encoder.m_encoded_tile_size = l_tile_size;
-        p_j2k->m_specific_param.m_encoder.m_encoded_tile_data =
-                        (OPJ_BYTE *) opj_malloc(p_j2k->m_specific_param.m_encoder.m_encoded_tile_size);
-        if (p_j2k->m_specific_param.m_encoder.m_encoded_tile_data == 00) {
-                return OPJ_FALSE;
-        }
-
-        if (OPJ_IS_CINEMA(l_cp->rsiz)) {
-                p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer =
-                                (OPJ_BYTE *) opj_malloc(5*p_j2k->m_specific_param.m_encoder.m_total_tile_parts);
-                if (! p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer) {
-                        return OPJ_FALSE;
-                }
-
-                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,
-                                                        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 */
-        assert(p_j2k != 00);
-        assert(p_manager != 00);
-        assert(p_stream != 00);
-
-        l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
-        l_tcp = p_j2k->m_cp.tcps;
-
-        l_tcd = opj_tcd_create(OPJ_TRUE);
-        if (l_tcd == 00) {
-                opj_event_msg(p_manager, EVT_ERROR, "Cannot decode tile, memory error\n");
-                return OPJ_FALSE;
-        }
-
-        for (i = 0; i < l_nb_tiles; ++i) {
-                if (l_tcp->m_data) {
-                        if (! opj_tcd_init_decode_tile(l_tcd, i)) {
-                                opj_tcd_destroy(l_tcd);
-                                opj_event_msg(p_manager, EVT_ERROR, "Cannot decode tile, memory error\n");
-                                return OPJ_FALSE;
-                        }
-
-                        l_success = opj_tcd_decode_tile(l_tcd, l_tcp->m_data, l_tcp->m_data_size, i, p_j2k->cstr_index);
-                        /* cleanup */
-
-                        if (! l_success) {
-                                p_j2k->m_specific_param.m_decoder.m_state |= J2K_STATE_ERR;
-                                break;
-                        }
-                }
-
-                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,
-                                                        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,
-                                                                        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);
-        assert(p_stream != 00);
-        assert(p_manager != 00);
-
-        if (! opj_j2k_write_cbd(p_j2k,p_stream,p_manager)) {
-                return OPJ_FALSE;
-        }
-
-        l_tcp = &(p_j2k->m_cp.tcps[p_j2k->m_current_tile_number]);
-        l_mct_record = l_tcp->m_mct_records;
-
-        for (i=0;i<l_tcp->m_nb_mct_records;++i) {
-
-                if (! opj_j2k_write_mct_record(p_j2k,l_mct_record,p_stream,p_manager)) {
-                        return OPJ_FALSE;
-                }
-
-                ++l_mct_record;
-        }
-
-        l_mcc_record = l_tcp->m_mcc_records;
-
-        for     (i=0;i<l_tcp->m_nb_mcc_records;++i) {
-
-                if (! opj_j2k_write_mcc_record(p_j2k,l_mcc_record,p_stream,p_manager)) {
-                        return OPJ_FALSE;
-                }
-
-                ++l_mcc_record;
-        }
-
-        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,
-                                                                        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,
-                                                                        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,
-                                                        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)  {
-                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,
-                                                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);
-
-        l_cstr_index = p_j2k->cstr_index;
-        if (l_cstr_index) {
-                l_cstr_index->codestream_size = (OPJ_UINT64)opj_stream_tell(p_stream);
-                /* UniPG>> */
-                /* The following adjustment is done to adjust the codestream size */
-                /* if SOD is not at 0 in the buffer. Useful in case of JP2, where */
-                /* the first bunch of bytes is not in the codestream              */
-                l_cstr_index->codestream_size -= (OPJ_UINT64)l_cstr_index->main_head_start;
-                /* <<UniPG */
-        }
-
-#ifdef USE_JPWL
-        /* preparation of JPWL marker segments */
-#if 0
-        if(cp->epc_on) {
-
-                /* encode according to JPWL */
-                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,
-                                                        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) {
-                /* 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)) {
-
-                        /* Get the marker handler from the marker ID*/
-                        l_marker_handler = opj_j2k_get_marker_handler(l_unknown_marker);
-
-                        if (!(p_j2k->m_specific_param.m_decoder.m_state & l_marker_handler->states)) {
-                                opj_event_msg(p_manager, EVT_ERROR, "Marker is not compliant with its position\n");
-                                return OPJ_FALSE;
-                        }
-                        else {
-                                if (l_marker_handler->id != J2K_MS_UNK) {
-                                        /* Add the marker to the codestream index*/
-                                        if (l_marker_handler->id != J2K_MS_SOT)
-                                        {
-                                                OPJ_BOOL res = opj_j2k_add_mhmarker(p_j2k->cstr_index, J2K_MS_UNK,
-                                                                (OPJ_UINT32) opj_stream_tell(p_stream) - l_size_unk,
-                                                                l_size_unk);
-                                                if (res == OPJ_FALSE) {
-                                                        opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to add mh marker\n");
-                                                        return OPJ_FALSE;
-                                                }
-                                        }
-                                        break; /* next marker is known and well located */
-                                }
-                                else
-                                        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,
-                                                                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);
-        assert(p_manager != 00);
-        assert(p_stream != 00);
-
-        l_mct_size = 10 + p_mct_record->m_data_size;
-
-        if (l_mct_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_mct_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 MCT 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_mct_size;
-        }
-
-        l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
-
-        opj_write_bytes(l_current_data,J2K_MS_MCT,2);                                   /* MCT */
-        l_current_data += 2;
-
-        opj_write_bytes(l_current_data,l_mct_size-2,2);                                 /* Lmct */
-        l_current_data += 2;
-
-        opj_write_bytes(l_current_data,0,2);                                                    /* Zmct */
-        l_current_data += 2;
-
-        /* only one marker atm */
-        l_tmp = (p_mct_record->m_index & 0xff) | (p_mct_record->m_array_type << 8) | (p_mct_record->m_element_type << 10);
-
-        opj_write_bytes(l_current_data,l_tmp,2);
-        l_current_data += 2;
-
-        opj_write_bytes(l_current_data,0,2);                                                    /* Ymct */
-        l_current_data+=2;
-
-        memcpy(l_current_data,p_mct_record->m_data,p_mct_record->m_data_size);
-
-        if (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_mct_size,p_manager) != l_mct_size) {
-                return OPJ_FALSE;
-        }
-
-        return OPJ_TRUE;
-}
-
-/**
- * Reads a MCT marker (Multiple Component Transform)
- *
- * @param       p_header_data   the data contained in the MCT box.
- * @param       p_j2k                   the jpeg2000 codec.
- * @param       p_header_size   the size of the data contained in the MCT marker.
- * @param       p_manager               the user event manager.
-*/
-static OPJ_BOOL opj_j2k_read_mct (      opj_j2k_t *p_j2k,
-                                                                    OPJ_BYTE * p_header_data,
-                                                                    OPJ_UINT32 p_header_size,
-                                                                    opj_event_mgr_t * p_manager
-                                    )
-{
-        OPJ_UINT32 i;
-        opj_tcp_t *l_tcp = 00;
-        OPJ_UINT32 l_tmp;
-        OPJ_UINT32 l_indix;
-        opj_mct_data_t * l_mct_data;
-
-        /* preconditions */
-        assert(p_header_data != 00);
-        assert(p_j2k != 00);
-
-        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 < 2) {
-                opj_event_msg(p_manager, EVT_ERROR, "Error reading MCT marker\n");
-                return OPJ_FALSE;
-        }
-
-        /* first marker */
-        opj_read_bytes(p_header_data,&l_tmp,2);                         /* Zmct */
-        p_header_data += 2;
-        if (l_tmp != 0) {
-                opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge mct data within multiple MCT records\n");
-                return OPJ_TRUE;
-        }
-
-        if(p_header_size <= 6) {
-                opj_event_msg(p_manager, EVT_ERROR, "Error reading MCT marker\n");
-                return OPJ_FALSE;
-        }
-
-        /* Imct -> no need for other values, take the first, type is double with decorrelation x0000 1101 0000 0000*/
-        opj_read_bytes(p_header_data,&l_tmp,2);                         /* Imct */
-        p_header_data += 2;
-
-        l_indix = l_tmp & 0xff;
-        l_mct_data = l_tcp->m_mct_records;
-
-        for (i=0;i<l_tcp->m_nb_mct_records;++i) {
-                if (l_mct_data->m_index == l_indix) {
-                        break;
-                }
-                ++l_mct_data;
-        }
-
-        /* NOT FOUND */
-        if (i == l_tcp->m_nb_mct_records) {
-                if (l_tcp->m_nb_mct_records == l_tcp->m_nb_max_mct_records) {
-                        opj_mct_data_t *new_mct_records;
-                        l_tcp->m_nb_max_mct_records += OPJ_J2K_MCT_DEFAULT_NB_RECORDS;
-
-                        new_mct_records = (opj_mct_data_t *) opj_realloc(l_tcp->m_mct_records, l_tcp->m_nb_max_mct_records * sizeof(opj_mct_data_t));
-                        if (! new_mct_records) {
-                                opj_free(l_tcp->m_mct_records);
-                                l_tcp->m_mct_records = NULL;
-                                l_tcp->m_nb_max_mct_records = 0;
-                                l_tcp->m_nb_mct_records = 0;
-                                opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read MCT marker\n");
-                                return OPJ_FALSE;
-                        }
-                        l_tcp->m_mct_records = new_mct_records;
-                        l_mct_data = l_tcp->m_mct_records + l_tcp->m_nb_mct_records;
-                        memset(l_mct_data ,0,(l_tcp->m_nb_max_mct_records - l_tcp->m_nb_mct_records) * sizeof(opj_mct_data_t));
-                }
-
-                l_mct_data = l_tcp->m_mct_records + l_tcp->m_nb_mct_records;
-        }
-
-        if (l_mct_data->m_data) {
-                opj_free(l_mct_data->m_data);
-                l_mct_data->m_data = 00;
-        }
-
-        l_mct_data->m_index = l_indix;
-        l_mct_data->m_array_type = (J2K_MCT_ARRAY_TYPE)((l_tmp  >> 8) & 3);
-        l_mct_data->m_element_type = (J2K_MCT_ELEMENT_TYPE)((l_tmp  >> 10) & 3);
-
-        opj_read_bytes(p_header_data,&l_tmp,2);                         /* Ymct */
-        p_header_data+=2;
-        if (l_tmp != 0) {
-                opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge multiple MCT markers\n");
-                return OPJ_TRUE;
-        }
-
-        p_header_size -= 6;
-
-        l_mct_data->m_data = (OPJ_BYTE*)opj_malloc(p_header_size);
-        if (! l_mct_data->m_data) {
-                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;
-        ++l_tcp->m_nb_mct_records;
-
-        return OPJ_TRUE;
-}
-
-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;
-
-        /* preconditions */
-        assert(p_j2k != 00);
-        assert(p_manager != 00);
-        assert(p_stream != 00);
-
-        if (p_mcc_record->m_nb_comps > 255 ) {
-        l_nb_bytes_for_comp = 2;
-                l_mask = 0x8000;
-        }
-        else {
-                l_nb_bytes_for_comp = 1;
-                l_mask = 0;
-        }
-
-        l_mcc_size = p_mcc_record->m_nb_comps * 2 * l_nb_bytes_for_comp + 19;
-        if (l_mcc_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_mcc_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 MCC 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_mcc_size;
-        }
-
-        l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
-
-        opj_write_bytes(l_current_data,J2K_MS_MCC,2);                                   /* MCC */
-        l_current_data += 2;
-
-        opj_write_bytes(l_current_data,l_mcc_size-2,2);                                 /* Lmcc */
-        l_current_data += 2;
-
-        /* first marker */
-        opj_write_bytes(l_current_data,0,2);                                    /* Zmcc */
-        l_current_data += 2;
-
-        opj_write_bytes(l_current_data,p_mcc_record->m_index,1);                                        /* Imcc -> no need for other values, take the first */
-        ++l_current_data;
-
-        /* only one marker atm */
-        opj_write_bytes(l_current_data,0,2);                                    /* Ymcc */
-        l_current_data+=2;
-
-        opj_write_bytes(l_current_data,1,2);                                    /* Qmcc -> number of collections -> 1 */
-        l_current_data+=2;
-
-        opj_write_bytes(l_current_data,0x1,1);                                  /* Xmcci type of component transformation -> array based decorrelation */
-        ++l_current_data;
-
-        opj_write_bytes(l_current_data,p_mcc_record->m_nb_comps | l_mask,2);    /* Nmcci number of input components involved and size for each component offset = 8 bits */
-        l_current_data+=2;
-
-        for (i=0;i<p_mcc_record->m_nb_comps;++i) {
-                opj_write_bytes(l_current_data,i,l_nb_bytes_for_comp);                          /* Cmccij Component offset*/
-                l_current_data+=l_nb_bytes_for_comp;
-        }
-
-        opj_write_bytes(l_current_data,p_mcc_record->m_nb_comps|l_mask,2);      /* Mmcci number of output components involved and size for each component offset = 8 bits */
-        l_current_data+=2;
-
-        for (i=0;i<p_mcc_record->m_nb_comps;++i)
-        {
-                opj_write_bytes(l_current_data,i,l_nb_bytes_for_comp);                          /* Wmccij Component offset*/
-                l_current_data+=l_nb_bytes_for_comp;
-        }
-
-        l_tmcc = ((!p_mcc_record->m_is_irreversible)&1)<<16;
-
-        if (p_mcc_record->m_decorrelation_array) {
-                l_tmcc |= p_mcc_record->m_decorrelation_array->m_index;
-        }
-
-        if (p_mcc_record->m_offset_array) {
-                l_tmcc |= ((p_mcc_record->m_offset_array->m_index)<<8);
-        }
-
-        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,
-                                                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;
-        OPJ_UINT32 l_nb_collections;
-        OPJ_UINT32 l_nb_comps;
-        OPJ_UINT32 l_nb_bytes_by_comp;
-
-        /* preconditions */
-        assert(p_header_data != 00);
-        assert(p_j2k != 00);
-        assert(p_manager != 00);
-
-        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 < 2) {
-                opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
-                return OPJ_FALSE;
-        }
-
-        /* first marker */
-        opj_read_bytes(p_header_data,&l_tmp,2);                         /* Zmcc */
-        p_header_data += 2;
-        if (l_tmp != 0) {
-                opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge multiple data spanning\n");
-                return OPJ_TRUE;
-        }
-
-        if (p_header_size < 7) {
-                opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
-                return OPJ_FALSE;
-        }
-
-        opj_read_bytes(p_header_data,&l_indix,1); /* Imcc -> no need for other values, take the first */
-        ++p_header_data;
-
-        l_mcc_record = l_tcp->m_mcc_records;
-
-        for(i=0;i<l_tcp->m_nb_mcc_records;++i) {
-                if (l_mcc_record->m_index == l_indix) {
-                        break;
-                }
-                ++l_mcc_record;
-        }
-
-        /** NOT FOUND */
-        if (i == l_tcp->m_nb_mcc_records) {
-                if (l_tcp->m_nb_mcc_records == l_tcp->m_nb_max_mcc_records) {
-                        opj_simple_mcc_decorrelation_data_t *new_mcc_records;
-                        l_tcp->m_nb_max_mcc_records += OPJ_J2K_MCC_DEFAULT_NB_RECORDS;
-
-                        new_mcc_records = (opj_simple_mcc_decorrelation_data_t *) opj_realloc(
-                                        l_tcp->m_mcc_records, l_tcp->m_nb_max_mcc_records * sizeof(opj_simple_mcc_decorrelation_data_t));
-                        if (! new_mcc_records) {
-                                opj_free(l_tcp->m_mcc_records);
-                                l_tcp->m_mcc_records = NULL;
-                                l_tcp->m_nb_max_mcc_records = 0;
-                                l_tcp->m_nb_mcc_records = 0;
-                                opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read MCC marker\n");
-                                return OPJ_FALSE;
-                        }
-                        l_tcp->m_mcc_records = new_mcc_records;
-                        l_mcc_record = l_tcp->m_mcc_records + l_tcp->m_nb_mcc_records;
-                        memset(l_mcc_record,0,(l_tcp->m_nb_max_mcc_records-l_tcp->m_nb_mcc_records) * sizeof(opj_simple_mcc_decorrelation_data_t));
-                }
-                l_mcc_record = l_tcp->m_mcc_records + l_tcp->m_nb_mcc_records;
-        }
-        l_mcc_record->m_index = l_indix;
-
-        /* only one marker atm */
-        opj_read_bytes(p_header_data,&l_tmp,2);                         /* Ymcc */
-        p_header_data+=2;
-        if (l_tmp != 0) {
-                opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge multiple data spanning\n");
-                return OPJ_TRUE;
-        }
-
-        opj_read_bytes(p_header_data,&l_nb_collections,2);                              /* Qmcc -> number of collections -> 1 */
-        p_header_data+=2;
-
-        if (l_nb_collections > 1) {
-                opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge multiple collections\n");
-                return OPJ_TRUE;
-        }
-
-        p_header_size -= 7;
-
-        for (i=0;i<l_nb_collections;++i) {
-                if (p_header_size < 3) {
-                        opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
-                        return OPJ_FALSE;
-                }
-
-                opj_read_bytes(p_header_data,&l_tmp,1); /* Xmcci type of component transformation -> array based decorrelation */
-                ++p_header_data;
-
-                if (l_tmp != 1) {
-                        opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge collections other than array decorrelation\n");
-                        return OPJ_TRUE;
-                }
-
-                opj_read_bytes(p_header_data,&l_nb_comps,2);
-
-                p_header_data+=2;
-                p_header_size-=3;
-
-                l_nb_bytes_by_comp = 1 + (l_nb_comps>>15);
-                l_mcc_record->m_nb_comps = l_nb_comps & 0x7fff;
-
-                if (p_header_size < (l_nb_bytes_by_comp * l_mcc_record->m_nb_comps + 2)) {
-                        opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
-                        return OPJ_FALSE;
-                }
-
-                p_header_size -= (l_nb_bytes_by_comp * l_mcc_record->m_nb_comps + 2);
-
-                for (j=0;j<l_mcc_record->m_nb_comps;++j) {
-                        opj_read_bytes(p_header_data,&l_tmp,l_nb_bytes_by_comp);        /* Cmccij Component offset*/
-                        p_header_data+=l_nb_bytes_by_comp;
-
-                        if (l_tmp != j) {
-                                opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge collections with indix shuffle\n");
-                                return OPJ_TRUE;
-                        }
-                }
-
-                opj_read_bytes(p_header_data,&l_nb_comps,2);
-                p_header_data+=2;
-
-                l_nb_bytes_by_comp = 1 + (l_nb_comps>>15);
-                l_nb_comps &= 0x7fff;
-
-                if (l_nb_comps != l_mcc_record->m_nb_comps) {
-                        opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge collections without same number of indixes\n");
-                        return OPJ_TRUE;
-                }
-
-                if (p_header_size < (l_nb_bytes_by_comp * l_mcc_record->m_nb_comps + 3)) {
-                        opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
-                        return OPJ_FALSE;
-                }
-
-                p_header_size -= (l_nb_bytes_by_comp * l_mcc_record->m_nb_comps + 3);
-
-                for (j=0;j<l_mcc_record->m_nb_comps;++j) {
-                        opj_read_bytes(p_header_data,&l_tmp,l_nb_bytes_by_comp);        /* Wmccij Component offset*/
-                        p_header_data+=l_nb_bytes_by_comp;
-
-                        if (l_tmp != j) {
-                                opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge collections with indix shuffle\n");
-                                return OPJ_TRUE;
-                        }
-                }
-
-                opj_read_bytes(p_header_data,&l_tmp,3); /* Wmccij Component offset*/
-                p_header_data += 3;
-
-                l_mcc_record->m_is_irreversible = ! ((l_tmp>>16) & 1);
-                l_mcc_record->m_decorrelation_array = 00;
-                l_mcc_record->m_offset_array = 00;
-
-                l_indix = l_tmp & 0xff;
-                if (l_indix != 0) {
-                        l_mct_data = l_tcp->m_mct_records;
-                        for (j=0;j<l_tcp->m_nb_mct_records;++j) {
-                                if (l_mct_data->m_index == l_indix) {
-                                        l_mcc_record->m_decorrelation_array = l_mct_data;
-                                        break;
-                                }
-                                ++l_mct_data;
-                        }
-
-                        if (l_mcc_record->m_decorrelation_array == 00) {
-                                opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
-                                return OPJ_FALSE;
-                        }
-                }
-
-                l_indix = (l_tmp >> 8) & 0xff;
-                if (l_indix != 0) {
-                        l_mct_data = l_tcp->m_mct_records;
-                        for (j=0;j<l_tcp->m_nb_mct_records;++j) {
-                                if (l_mct_data->m_index == l_indix) {
-                                        l_mcc_record->m_offset_array = l_mct_data;
-                                        break;
-                                }
-                                ++l_mct_data;
-                        }
-
-                        if (l_mcc_record->m_offset_array == 00) {
-                                opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
-                                return OPJ_FALSE;
-                        }
-                }
-        }
-
-        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,
-                                                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;
-        }
-
-        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*/
-        ++l_current_data;
-
-        l_mcc_record = l_tcp->m_mcc_records;
-        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;
-}
-
-/**
- * Reads a MCO marker (Multiple Component Transform Ordering)
- *
- * @param       p_header_data   the data contained in the MCO box.
- * @param       p_j2k                   the jpeg2000 codec.
- * @param       p_header_size   the size of the data contained in the MCO marker.
- * @param       p_manager               the user event manager.
-*/
-static OPJ_BOOL opj_j2k_read_mco (      opj_j2k_t *p_j2k,
-                                                                    OPJ_BYTE * p_header_data,
-                                                                    OPJ_UINT32 p_header_size,
-                                                                    opj_event_mgr_t * p_manager
-                                    )
-{
-        OPJ_UINT32 l_tmp, i;
-        OPJ_UINT32 l_nb_stages;
-        opj_tcp_t * l_tcp;
-        opj_tccp_t * l_tccp;
-        opj_image_t * l_image;
-
-        /* preconditions */
-        assert(p_header_data != 00);
-        assert(p_j2k != 00);
-        assert(p_manager != 00);
-
-        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*/
-        ++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;
-        }
-
-        l_tccp = l_tcp->tccps;
-
-        for (i=0;i<l_image->numcomps;++i) {
-                l_tccp->m_dc_level_shift = 0;
-                ++l_tccp;
-        }
-
-        if (l_tcp->m_mct_decoding_matrix) {
-                opj_free(l_tcp->m_mct_decoding_matrix);
-                l_tcp->m_mct_decoding_matrix = 00;
-        }
-
-        for (i=0;i<l_nb_stages;++i) {
-                opj_read_bytes(p_header_data,&l_tmp,1);
-                ++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)
-{
-        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 */
-        assert(p_tcp != 00);
-
-        l_mcc_record = p_tcp->m_mcc_records;
-
-        for (i=0;i<p_tcp->m_nb_mcc_records;++i) {
-                if (l_mcc_record->m_index == p_index) {
-                        break;
-                }
-        }
-
-        if (i==p_tcp->m_nb_mcc_records) {
-                /** element discarded **/
-                return OPJ_TRUE;
-        }
-
-        if (l_mcc_record->m_nb_comps != p_image->numcomps) {
-                /** do not support number of comps != image */
-                return OPJ_TRUE;
-        }
-
-        l_deco_array = l_mcc_record->m_decorrelation_array;
-
-        if (l_deco_array) {
-                l_data_size = MCT_ELEMENT_SIZE[l_deco_array->m_element_type] * p_image->numcomps * p_image->numcomps;
-                if (l_deco_array->m_data_size != l_data_size) {
-                        return OPJ_FALSE;
-                }
-
-                l_nb_elem = p_image->numcomps * p_image->numcomps;
-                l_mct_size = l_nb_elem * (OPJ_UINT32)sizeof(OPJ_FLOAT32);
-                p_tcp->m_mct_decoding_matrix = (OPJ_FLOAT32*)opj_malloc(l_mct_size);
-
-                if (! p_tcp->m_mct_decoding_matrix ) {
-                        return OPJ_FALSE;
-                }
-
-                j2k_mct_read_functions_to_float[l_deco_array->m_element_type](l_deco_array->m_data,p_tcp->m_mct_decoding_matrix,l_nb_elem);
-        }
-
-        l_offset_array = l_mcc_record->m_offset_array;
-
-        if (l_offset_array) {
-                l_data_size = MCT_ELEMENT_SIZE[l_offset_array->m_element_type] * p_image->numcomps;
-                if (l_offset_array->m_data_size != l_data_size) {
-                        return OPJ_FALSE;
-                }
-
-                l_nb_elem = p_image->numcomps;
-                l_offset_size = l_nb_elem * (OPJ_UINT32)sizeof(OPJ_UINT32);
-                l_offset_data = (OPJ_UINT32*)opj_malloc(l_offset_size);
-
-                if (! l_offset_data ) {
-                        return OPJ_FALSE;
-                }
-
-                j2k_mct_read_functions_to_int32[l_offset_array->m_element_type](l_offset_array->m_data,l_offset_data,l_nb_elem);
-
-                l_tccp = p_tcp->tccps;
-                l_current_offset_data = l_offset_data;
-
-                for (i=0;i<p_image->numcomps;++i) {
-                        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,
-                                                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 */
-        assert(p_j2k != 00);
-        assert(p_manager != 00);
-        assert(p_stream != 00);
-
-        l_image = p_j2k->m_private_image;
-        l_cbd_size = 6 + p_j2k->m_private_image->numcomps;
-
-        if (l_cbd_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_cbd_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 CBD 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_cbd_size;
-        }
-
-        l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
-
-        opj_write_bytes(l_current_data,J2K_MS_CBD,2);                   /* CBD */
-        l_current_data += 2;
-
-        opj_write_bytes(l_current_data,l_cbd_size-2,2);                 /* L_CBD */
-        l_current_data += 2;
-
-        opj_write_bytes(l_current_data,l_image->numcomps, 2);           /* Ncbd */
-        l_current_data+=2;
-
-        l_comp = l_image->comps;
-
-        for (i=0;i<l_image->numcomps;++i) {
-                opj_write_bytes(l_current_data, (l_comp->sgnd << 7) | (l_comp->prec - 1), 1);           /* Component bit depth */
-                ++l_current_data;
-
-                ++l_comp;
-        }
-
-        if (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_cbd_size,p_manager) != l_cbd_size) {
-                return OPJ_FALSE;
-        }
-
-        return OPJ_TRUE;
-}
-
-/**
- * Reads a CBD marker (Component bit depth definition)
- * @param       p_header_data   the data contained in the CBD box.
- * @param       p_j2k                   the jpeg2000 codec.
- * @param       p_header_size   the size of the data contained in the CBD marker.
- * @param       p_manager               the user event manager.
-*/
-static OPJ_BOOL opj_j2k_read_cbd (      opj_j2k_t *p_j2k,
-                                                                OPJ_BYTE * p_header_data,
-                                                                OPJ_UINT32 p_header_size,
-                                                                opj_event_mgr_t * p_manager
-                                    )
-{
-        OPJ_UINT32 l_nb_comp,l_num_comp;
-        OPJ_UINT32 l_comp_def;
-        OPJ_UINT32 i;
-        opj_image_comp_t * l_comp = 00;
-
-        /* preconditions */
-        assert(p_header_data != 00);
-        assert(p_j2k != 00);
-        assert(p_manager != 00);
-
-        l_num_comp = p_j2k->m_private_image->numcomps;
-
-        if (p_header_size != (p_j2k->m_private_image->numcomps + 2)) {
-                opj_event_msg(p_manager, EVT_ERROR, "Crror reading CBD marker\n");
-                return OPJ_FALSE;
-        }
-
-        opj_read_bytes(p_header_data,&l_nb_comp,2);                             /* Ncbd */
-        p_header_data+=2;
-
-        if (l_nb_comp != l_num_comp) {
-                opj_event_msg(p_manager, EVT_ERROR, "Crror reading CBD marker\n");
-                return OPJ_FALSE;
-        }
-
-        l_comp = p_j2k->m_private_image->comps;
-        for (i=0;i<l_num_comp;++i) {
-                opj_read_bytes(p_header_data,&l_comp_def,1);                    /* Component bit depth */
-                ++p_header_data;
-        l_comp->sgnd = (l_comp_def>>7) & 1;
-                l_comp->prec = (l_comp_def&0x7f) + 1;
-                ++l_comp;
-        }
-
-        return OPJ_TRUE;
-}
-
-/* ----------------------------------------------------------------------- */
-/* J2K / JPT decoder interface                                             */
-/* ----------------------------------------------------------------------- */
-
-void opj_j2k_setup_decoder(opj_j2k_t *j2k, opj_dparameters_t *parameters)
-{
-        if(j2k && parameters) {
-                j2k->m_cp.m_specific_param.m_dec.m_layer = parameters->cp_layer;
-                j2k->m_cp.m_specific_param.m_dec.m_reduce = parameters->cp_reduce;
-
-#ifdef USE_JPWL
-                j2k->m_cp.correct = parameters->jpwl_correct;
-                j2k->m_cp.exp_comps = parameters->jpwl_exp_comps;
-                j2k->m_cp.max_tiles = parameters->jpwl_max_tiles;
-#endif /* USE_JPWL */
-        }
-}
-
-/* ----------------------------------------------------------------------- */
-/* J2K encoder interface                                                       */
-/* ----------------------------------------------------------------------- */
-
-opj_j2k_t* opj_j2k_create_compress(void)
-{
-        opj_j2k_t *l_j2k = (opj_j2k_t*) opj_malloc(sizeof(opj_j2k_t));
-        if (!l_j2k) {
-                return NULL;
-        }
-
-        memset(l_j2k,0,sizeof(opj_j2k_t));
-
-        l_j2k->m_is_decoder = 0;
-        l_j2k->m_cp.m_is_decoder = 0;
-
-        l_j2k->m_specific_param.m_encoder.m_header_tile_data = (OPJ_BYTE *) opj_malloc(OPJ_J2K_DEFAULT_HEADER_SIZE);
-        if (! l_j2k->m_specific_param.m_encoder.m_header_tile_data) {
-                opj_j2k_destroy(l_j2k);
-                return NULL;
-        }
-
-        l_j2k->m_specific_param.m_encoder.m_header_tile_data_size = OPJ_J2K_DEFAULT_HEADER_SIZE;
-
-        /* validation list creation*/
-        l_j2k->m_validation_list = opj_procedure_list_create();
-        if (! l_j2k->m_validation_list) {
-                opj_j2k_destroy(l_j2k);
-                return NULL;
-        }
-
-        /* 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){
-    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)
-{
-    /* 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 */
-    parameters->tp_flag = 'C';
-    parameters->tp_on = 1;
-
-    /* Tile and Image shall be at (0,0) */
-    parameters->cp_tx0 = 0;
-    parameters->cp_ty0 = 0;
-    parameters->image_offset_x0 = 0;
-    parameters->image_offset_y0 = 0;
-
-    /* Codeblock size= 32*32 */
-    parameters->cblockw_init = 32;
-    parameters->cblockh_init = 32;
-
-    /* Codeblock style: no mode switch enabled */
-    parameters->mode = 0;
-
-    /* No ROI */
-    parameters->roi_compno = -1;
-
-    /* No subsampling */
-    parameters->subsampling_dx = 1;
-    parameters->subsampling_dy = 1;
-
-    /* 9-7 transform */
-    parameters->irreversible = 1;
-
-    /* Number of layers */
-    if (parameters->tcp_numlayers > 1){
-        opj_event_msg(p_manager, EVT_WARNING,
-                "JPEG 2000 Profile-3 and 4 (2k/4k dc profile) requires:\n"
-                "1 single quality layer"
-                "-> Number of layers forced to 1 (rather than %d)\n"
-                "-> Rate of the last layer (%3.1f) will be used",
-                parameters->tcp_numlayers, parameters->tcp_rates[parameters->tcp_numlayers-1]);
-        parameters->tcp_rates[0] = parameters->tcp_rates[parameters->tcp_numlayers-1];
-        parameters->tcp_numlayers = 1;
-    }
-
-    /* Resolution levels */
-    switch (parameters->rsiz){
-    case OPJ_PROFILE_CINEMA_2K:
-        if(parameters->numresolution > 6){
-            opj_event_msg(p_manager, EVT_WARNING,
-                    "JPEG 2000 Profile-3 (2k dc profile) requires:\n"
-                    "Number of decomposition levels <= 5\n"
-                    "-> Number of decomposition levels forced to 5 (rather than %d)\n",
-                    parameters->numresolution+1);
-            parameters->numresolution = 6;
-        }
-        break;
-    case OPJ_PROFILE_CINEMA_4K:
-        if(parameters->numresolution < 2){
-            opj_event_msg(p_manager, EVT_WARNING,
-                    "JPEG 2000 Profile-4 (4k dc profile) requires:\n"
-                    "Number of decomposition levels >= 1 && <= 6\n"
-                    "-> Number of decomposition levels forced to 1 (rather than %d)\n",
-                    parameters->numresolution+1);
-            parameters->numresolution = 1;
-        }else if(parameters->numresolution > 7){
-            opj_event_msg(p_manager, EVT_WARNING,
-                    "JPEG 2000 Profile-4 (4k dc profile) requires:\n"
-                    "Number of decomposition levels >= 1 && <= 6\n"
-                    "-> Number of decomposition levels forced to 6 (rather than %d)\n",
-                    parameters->numresolution+1);
-            parameters->numresolution = 7;
-        }
-        break;
-    default :
-        break;
-    }
-
-    /* Precincts */
-    parameters->csty |= 0x01;
-    parameters->res_spec = parameters->numresolution-1;
-    for (i = 0; i<parameters->res_spec; i++) {
-        parameters->prcw_init[i] = 256;
-        parameters->prch_init[i] = 256;
-    }
-
-    /* The progression order shall be CPRL */
-    parameters->prog_order = OPJ_CPRL;
-
-    /* Progression order changes for 4K, disallowed for 2K */
-    if (parameters->rsiz == OPJ_PROFILE_CINEMA_4K) {
-        parameters->numpocs = (OPJ_UINT32)opj_j2k_initialise_4K_poc(parameters->POC,parameters->numresolution);
-    } else {
-        parameters->numpocs = 0;
-    }
-
-    /* Limited bit-rate */
-    parameters->cp_disto_alloc = 1;
-    if (parameters->max_cs_size <= 0) {
-        /* No rate has been introduced, 24 fps is assumed */
-        parameters->max_cs_size = OPJ_CINEMA_24_CS;
-        opj_event_msg(p_manager, EVT_WARNING,
-                      "JPEG 2000 Profile-3 and 4 (2k/4k dc profile) requires:\n"
-                      "Maximum 1302083 compressed bytes @ 24fps\n"
-                      "As no rate has been given, this limit will be used.\n");
-    } else if (parameters->max_cs_size > OPJ_CINEMA_24_CS) {
-        opj_event_msg(p_manager, EVT_WARNING,
-                      "JPEG 2000 Profile-3 and 4 (2k/4k dc profile) requires:\n"
-                      "Maximum 1302083 compressed bytes @ 24fps\n"
-                      "-> Specified rate exceeds this limit. Rate will be forced to 1302083 bytes.\n");
-        parameters->max_cs_size = OPJ_CINEMA_24_CS;
-    }
-
-    if (parameters->max_comp_size <= 0) {
-        /* No rate has been introduced, 24 fps is assumed */
-        parameters->max_comp_size = OPJ_CINEMA_24_COMP;
-        opj_event_msg(p_manager, EVT_WARNING,
-                      "JPEG 2000 Profile-3 and 4 (2k/4k dc profile) requires:\n"
-                      "Maximum 1041666 compressed bytes @ 24fps\n"
-                      "As no rate has been given, this limit will be used.\n");
-    } else if (parameters->max_comp_size > OPJ_CINEMA_24_COMP) {
-        opj_event_msg(p_manager, EVT_WARNING,
-                      "JPEG 2000 Profile-3 and 4 (2k/4k dc profile) requires:\n"
-                      "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)
-{
-    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",
-                image->numcomps);
-        return OPJ_FALSE;
-    }
-
-    /* Bitdepth */
-    for (i = 0; i < image->numcomps; i++) {
-        if ((image->comps[i].bpp != 12) | (image->comps[i].sgnd)){
-            char signed_str[] = "signed";
-            char unsigned_str[] = "unsigned";
-            char *tmp_str = image->comps[i].sgnd?signed_str:unsigned_str;
-            opj_event_msg(p_manager, EVT_WARNING,
-                    "JPEG 2000 Profile-3 (2k dc profile) requires:\n"
-                    "Precision of each component shall be 12 bits unsigned"
-                    "-> At least component %d of input image (%d bits, %s) is not compliant\n"
-                    "-> Non-profile-3 codestream will be generated\n",
-                    i,image->comps[i].bpp, tmp_str);
-            return OPJ_FALSE;
-        }
-    }
-
-    /* Image size */
-    switch (rsiz){
-    case OPJ_PROFILE_CINEMA_2K:
-        if (((image->comps[0].w > 2048) | (image->comps[0].h > 1080))){
-            opj_event_msg(p_manager, EVT_WARNING,
-                    "JPEG 2000 Profile-3 (2k dc profile) requires:\n"
-                    "width <= 2048 and height <= 1080\n"
-                    "-> Input image size %d x %d is not compliant\n"
-                    "-> Non-profile-3 codestream will be generated\n",
-                    image->comps[0].w,image->comps[0].h);
-            return OPJ_FALSE;
-        }
-        break;
-    case OPJ_PROFILE_CINEMA_4K:
-        if (((image->comps[0].w > 4096) | (image->comps[0].h > 2160))){
-            opj_event_msg(p_manager, EVT_WARNING,
-                    "JPEG 2000 Profile-4 (4k dc profile) requires:\n"
-                    "width <= 4096 and height <= 2160\n"
-                    "-> Image size %d x %d is not compliant\n"
-                    "-> Non-profile-4 codestream will be generated\n",
-                    image->comps[0].w,image->comps[0].h);
-            return OPJ_FALSE;
-        }
-        break;
-    default :
-        break;
-    }
-
-    return OPJ_TRUE;
-}
-
-void opj_j2k_setup_encoder(     opj_j2k_t *p_j2k,
-                                                    opj_cparameters_t *parameters,
-                                                    opj_image_t *image,
-                                                    opj_event_mgr_t * p_manager)
-{
-        OPJ_UINT32 i, j, tileno, numpocs_tile;
-        opj_cp_t *cp = 00;
-
-        if(!p_j2k || !parameters || ! image) {
-                return;
-        }
-
-        /* keep a link to cp so that we can destroy it later in j2k_destroy_compress */
-        cp = &(p_j2k->m_cp);
-
-        /* set default values for cp */
-        cp->tw = 1;
-        cp->th = 1;
-
-        /* FIXME ADE: to be removed once deprecated cp_cinema and cp_rsiz have been removed */
-        if (parameters->rsiz == OPJ_PROFILE_NONE) { /* consider deprecated fields only if RSIZ has not been set */
-            OPJ_BOOL deprecated_used = OPJ_FALSE;
-            switch (parameters->cp_cinema){
-            case OPJ_CINEMA2K_24:
-                parameters->rsiz = OPJ_PROFILE_CINEMA_2K;
-                parameters->max_cs_size = OPJ_CINEMA_24_CS;
-                parameters->max_comp_size = OPJ_CINEMA_24_COMP;
-                deprecated_used = OPJ_TRUE;
-                break;
-            case OPJ_CINEMA2K_48:
-                parameters->rsiz = OPJ_PROFILE_CINEMA_2K;
-                parameters->max_cs_size = OPJ_CINEMA_48_CS;
-                parameters->max_comp_size = OPJ_CINEMA_48_COMP;
-                deprecated_used = OPJ_TRUE;
-                break;
-            case OPJ_CINEMA4K_24:
-                parameters->rsiz = OPJ_PROFILE_CINEMA_4K;
-                parameters->max_cs_size = OPJ_CINEMA_24_CS;
-                parameters->max_comp_size = OPJ_CINEMA_24_COMP;
-                deprecated_used = OPJ_TRUE;
-                break;
-            case OPJ_OFF:
-            default:
-                break;
-            }
-            switch (parameters->cp_rsiz){
-            case OPJ_CINEMA2K:
-                parameters->rsiz = OPJ_PROFILE_CINEMA_2K;
-                deprecated_used = OPJ_TRUE;
-                break;
-            case OPJ_CINEMA4K:
-                parameters->rsiz = OPJ_PROFILE_CINEMA_4K;
-                deprecated_used = OPJ_TRUE;
-                break;
-            case OPJ_MCT:
-                parameters->rsiz = OPJ_PROFILE_PART2 | OPJ_EXTENSION_MCT;
-                deprecated_used = OPJ_TRUE;
-            case OPJ_STD_RSIZ:
-            default:
-                break;
-            }
-            if (deprecated_used) {
-                opj_event_msg(p_manager, EVT_WARNING,
-                        "Deprecated fields cp_cinema or cp_rsiz are used\n"
-                        "Please consider using only the rsiz field\n"
-                        "See openjpeg.h documentation for more details\n");
-            }
-        }
-
-        /* see if max_codestream_size does limit input rate */
-        if (parameters->max_cs_size <= 0) {
-            if (parameters->tcp_rates[parameters->tcp_numlayers-1] > 0) {
-                OPJ_FLOAT32 temp_size;
-                temp_size =(OPJ_FLOAT32)(image->numcomps * image->comps[0].w * image->comps[0].h * image->comps[0].prec)/
-                        (parameters->tcp_rates[parameters->tcp_numlayers-1] * 8 * (OPJ_FLOAT32)image->comps[0].dx * (OPJ_FLOAT32)image->comps[0].dy);
-                parameters->max_cs_size = (int) floor(temp_size);
-            } else {
-                parameters->max_cs_size = 0;
-            }
-        } else {
-            OPJ_FLOAT32 temp_rate;
-            OPJ_BOOL cap = OPJ_FALSE;
-            temp_rate = (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);
-            for (i = 0; i < (OPJ_UINT32) parameters->tcp_numlayers; i++) {
-                if (parameters->tcp_rates[i] < temp_rate) {
-                    parameters->tcp_rates[i] = temp_rate;
-                    cap = OPJ_TRUE;
-                }
-            }
-            if (cap) {
-                opj_event_msg(p_manager, EVT_WARNING,
-                        "The desired maximum codestream size has limited\n"
-                        "at least one of the desired quality layers\n");
-            }
-        }
-
-        /* Manage profiles and applications and set RSIZ */
-        /* set cinema parameters if required */
-        if (OPJ_IS_CINEMA(parameters->rsiz)){
-            if ((parameters->rsiz == OPJ_PROFILE_CINEMA_S2K)
-                    || (parameters->rsiz == OPJ_PROFILE_CINEMA_S4K)){
-                opj_event_msg(p_manager, EVT_WARNING,
-                        "JPEG 2000 Scalable Digital Cinema profiles not yet supported\n");
-                parameters->rsiz = OPJ_PROFILE_NONE;
-            } else {
-                opj_j2k_set_cinema_parameters(parameters,image,p_manager);
-                if (!opj_j2k_is_cinema_compliant(image,parameters->rsiz,p_manager)) {
-                    parameters->rsiz = OPJ_PROFILE_NONE;
-                }
-            }
-        } else if (OPJ_IS_STORAGE(parameters->rsiz)) {
-            opj_event_msg(p_manager, EVT_WARNING,
-                    "JPEG 2000 Long Term Storage profile not yet supported\n");
-            parameters->rsiz = OPJ_PROFILE_NONE;
-        } else if (OPJ_IS_BROADCAST(parameters->rsiz)) {
-            opj_event_msg(p_manager, EVT_WARNING,
-                    "JPEG 2000 Broadcast profiles not yet supported\n");
-            parameters->rsiz = OPJ_PROFILE_NONE;
-        } else if (OPJ_IS_IMF(parameters->rsiz)) {
-            opj_event_msg(p_manager, EVT_WARNING,
-                    "JPEG 2000 IMF profiles not yet supported\n");
-            parameters->rsiz = OPJ_PROFILE_NONE;
-        } else if (OPJ_IS_PART2(parameters->rsiz)) {
-            if (parameters->rsiz == ((OPJ_PROFILE_PART2) | (OPJ_EXTENSION_NONE))) {
-                opj_event_msg(p_manager, EVT_WARNING,
-                              "JPEG 2000 Part-2 profile defined\n"
-                              "but no Part-2 extension enabled.\n"
-                              "Profile set to NONE.\n");
-                parameters->rsiz = OPJ_PROFILE_NONE;
-            } else if (parameters->rsiz != ((OPJ_PROFILE_PART2) | (OPJ_EXTENSION_MCT))) {
-                opj_event_msg(p_manager, EVT_WARNING,
-                              "Unsupported Part-2 extension enabled\n"
-                              "Profile set to NONE.\n");
-                parameters->rsiz = OPJ_PROFILE_NONE;
-            }
-        }
-
-        /*
-        copy user encoding parameters
-        */
-        cp->m_specific_param.m_enc.m_max_comp_size = (OPJ_UINT32)parameters->max_comp_size;
-        cp->rsiz = parameters->rsiz;
-        cp->m_specific_param.m_enc.m_disto_alloc = (OPJ_UINT32)parameters->cp_disto_alloc & 1u;
-        cp->m_specific_param.m_enc.m_fixed_alloc = (OPJ_UINT32)parameters->cp_fixed_alloc & 1u;
-        cp->m_specific_param.m_enc.m_fixed_quality = (OPJ_UINT32)parameters->cp_fixed_quality & 1u;
-
-        /* mod fixed_quality */
-        if (parameters->cp_fixed_alloc && parameters->cp_matrice) {
-                size_t array_size = (size_t)parameters->tcp_numlayers * (size_t)parameters->numresolution * 3 * sizeof(OPJ_INT32);
-                cp->m_specific_param.m_enc.m_matrice = (OPJ_INT32 *) opj_malloc(array_size);
-                memcpy(cp->m_specific_param.m_enc.m_matrice, parameters->cp_matrice, array_size);
-        }
-
-        /* tiles */
-        cp->tdx = (OPJ_UINT32)parameters->cp_tdx;
-        cp->tdy = (OPJ_UINT32)parameters->cp_tdy;
-
-        /* tile offset */
-        cp->tx0 = (OPJ_UINT32)parameters->cp_tx0;
-        cp->ty0 = (OPJ_UINT32)parameters->cp_ty0;
-
-        /* comment string */
-        if(parameters->cp_comment) {
-                cp->comment = (char*)opj_malloc(strlen(parameters->cp_comment) + 1);
-                if(cp->comment) {
-                        strcpy(cp->comment, parameters->cp_comment);
-                }
-        }
-
-        /*
-        calculate other encoding parameters
-        */
-
-        if (parameters->tile_size_on) {
-                cp->tw = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)(image->x1 - cp->tx0), (OPJ_INT32)cp->tdx);
-                cp->th = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)(image->y1 - cp->ty0), (OPJ_INT32)cp->tdy);
-        } else {
-                cp->tdx = image->x1 - cp->tx0;
-                cp->tdy = image->y1 - cp->ty0;
-        }
-
-        if (parameters->tp_on) {
-                cp->m_specific_param.m_enc.m_tp_flag = (OPJ_BYTE)parameters->tp_flag;
-                cp->m_specific_param.m_enc.m_tp_on = 1;
-        }
-
-#ifdef USE_JPWL
-        /*
-        calculate JPWL encoding parameters
-        */
-
-        if (parameters->jpwl_epc_on) {
-                OPJ_INT32 i;
-
-                /* set JPWL on */
-                cp->epc_on = OPJ_TRUE;
-                cp->info_on = OPJ_FALSE; /* no informative technique */
-
-                /* set EPB on */
-                if ((parameters->jpwl_hprot_MH > 0) || (parameters->jpwl_hprot_TPH[0] > 0)) {
-                        cp->epb_on = OPJ_TRUE;
-
-                        cp->hprot_MH = parameters->jpwl_hprot_MH;
-                        for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {
-                                cp->hprot_TPH_tileno[i] = parameters->jpwl_hprot_TPH_tileno[i];
-                                cp->hprot_TPH[i] = parameters->jpwl_hprot_TPH[i];
-                        }
-                        /* if tile specs are not specified, copy MH specs */
-                        if (cp->hprot_TPH[0] == -1) {
-                                cp->hprot_TPH_tileno[0] = 0;
-                                cp->hprot_TPH[0] = parameters->jpwl_hprot_MH;
-                        }
-                        for (i = 0; i < JPWL_MAX_NO_PACKSPECS; i++) {
-                                cp->pprot_tileno[i] = parameters->jpwl_pprot_tileno[i];
-                                cp->pprot_packno[i] = parameters->jpwl_pprot_packno[i];
-                                cp->pprot[i] = parameters->jpwl_pprot[i];
-                        }
-                }
-
-                /* set ESD writing */
-                if ((parameters->jpwl_sens_size == 1) || (parameters->jpwl_sens_size == 2)) {
-                        cp->esd_on = OPJ_TRUE;
-
-                        cp->sens_size = parameters->jpwl_sens_size;
-                        cp->sens_addr = parameters->jpwl_sens_addr;
-                        cp->sens_range = parameters->jpwl_sens_range;
-
-                        cp->sens_MH = parameters->jpwl_sens_MH;
-                        for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {
-                                cp->sens_TPH_tileno[i] = parameters->jpwl_sens_TPH_tileno[i];
-                                cp->sens_TPH[i] = parameters->jpwl_sens_TPH[i];
-                        }
-                }
-
-                /* always set RED writing to false: we are at the encoder */
-                cp->red_on = OPJ_FALSE;
-
-        } else {
-                cp->epc_on = OPJ_FALSE;
-        }
-#endif /* USE_JPWL */
-
-        /* initialize the mutiple tiles */
-        /* ---------------------------- */
-        cp->tcps = (opj_tcp_t*) opj_calloc(cp->tw * cp->th, sizeof(opj_tcp_t));
-        if (parameters->numpocs) {
-                /* initialisation of POC */
-                opj_j2k_check_poc_val(parameters->POC,parameters->numpocs, (OPJ_UINT32)parameters->numresolution, image->numcomps, (OPJ_UINT32)parameters->tcp_numlayers, p_manager);
-                /* TODO MSD use the return value*/
-        }
-
-        for (tileno = 0; tileno < cp->tw * cp->th; tileno++) {
-                opj_tcp_t *tcp = &cp->tcps[tileno];
-                tcp->numlayers = (OPJ_UINT32)parameters->tcp_numlayers;
-
-                for (j = 0; j < tcp->numlayers; j++) {
-                        if(OPJ_IS_CINEMA(cp->rsiz)){
-                                if (cp->m_specific_param.m_enc.m_fixed_quality) {
-                                        tcp->distoratio[j] = parameters->tcp_distoratio[j];
-                                }
-                                tcp->rates[j] = parameters->tcp_rates[j];
-                        }else{
-                                if (cp->m_specific_param.m_enc.m_fixed_quality) {       /* add fixed_quality */
-                                        tcp->distoratio[j] = parameters->tcp_distoratio[j];
-                                } else {
-                                        tcp->rates[j] = parameters->tcp_rates[j];
-                                }
-                        }
-                }
-
-                tcp->csty = (OPJ_UINT32)parameters->csty;
-                tcp->prg = parameters->prog_order;
-                tcp->mct = (OPJ_UINT32)parameters->tcp_mct;
-
-                numpocs_tile = 0;
-                tcp->POC = 0;
-
-                if (parameters->numpocs) {
-                        /* initialisation of POC */
-                        tcp->POC = 1;
-                        for (i = 0; i < parameters->numpocs; i++) {
-                                if (tileno + 1 == parameters->POC[i].tile )  {
-                                        opj_poc_t *tcp_poc = &tcp->pocs[numpocs_tile];
-
-                                        tcp_poc->resno0         = parameters->POC[numpocs_tile].resno0;
-                                        tcp_poc->compno0        = parameters->POC[numpocs_tile].compno0;
-                                        tcp_poc->layno1         = parameters->POC[numpocs_tile].layno1;
-                                        tcp_poc->resno1         = parameters->POC[numpocs_tile].resno1;
-                                        tcp_poc->compno1        = parameters->POC[numpocs_tile].compno1;
-                                        tcp_poc->prg1           = parameters->POC[numpocs_tile].prg1;
-                                        tcp_poc->tile           = parameters->POC[numpocs_tile].tile;
-
-                                        numpocs_tile++;
-                                }
-                        }
-
-                        tcp->numpocs = numpocs_tile -1 ;
-                }else{
-                        tcp->numpocs = 0;
-                }
-
-                tcp->tccps = (opj_tccp_t*) opj_calloc(image->numcomps, sizeof(opj_tccp_t));
-
-                if (parameters->mct_data) {
-                      
-                    OPJ_UINT32 lMctSize = image->numcomps * image->numcomps * (OPJ_UINT32)sizeof(OPJ_FLOAT32);
-                    OPJ_FLOAT32 * lTmpBuf = (OPJ_FLOAT32*)opj_malloc(lMctSize);
-                    OPJ_INT32 * l_dc_shift = (OPJ_INT32 *) ((OPJ_BYTE *) parameters->mct_data + lMctSize);
-
-                    tcp->mct = 2;
-                    tcp->m_mct_coding_matrix = (OPJ_FLOAT32*)opj_malloc(lMctSize);
-                    memcpy(tcp->m_mct_coding_matrix,parameters->mct_data,lMctSize);
-                    memcpy(lTmpBuf,parameters->mct_data,lMctSize);
-
-                    tcp->m_mct_decoding_matrix = (OPJ_FLOAT32*)opj_malloc(lMctSize);
-                    assert(opj_matrix_inversion_f(lTmpBuf,(tcp->m_mct_decoding_matrix),image->numcomps));
-
-                    tcp->mct_norms = (OPJ_FLOAT64*)
-                                    opj_malloc(image->numcomps * sizeof(OPJ_FLOAT64));
-
-                    opj_calculate_norms(tcp->mct_norms,image->numcomps,tcp->m_mct_decoding_matrix);
-                    opj_free(lTmpBuf);
-
-                    for (i = 0; i < image->numcomps; i++) {
-                            opj_tccp_t *tccp = &tcp->tccps[i];
-                            tccp->m_dc_level_shift = l_dc_shift[i];
-                    }
-
-                    opj_j2k_setup_mct_encoding(tcp,image);                        
-                }
-                else {
-                        for (i = 0; i < image->numcomps; i++) {
-                                opj_tccp_t *tccp = &tcp->tccps[i];
-                                opj_image_comp_t * l_comp = &(image->comps[i]);
-
-                                if (! l_comp->sgnd) {
-                                        tccp->m_dc_level_shift = 1 << (l_comp->prec - 1);
-                                }
-                        }
-                }
-
-                for (i = 0; i < image->numcomps; i++) {
-                        opj_tccp_t *tccp = &tcp->tccps[i];
-
-                        tccp->csty = parameters->csty & 0x01;   /* 0 => one precinct || 1 => custom precinct  */
-                        tccp->numresolutions = (OPJ_UINT32)parameters->numresolution;
-                        tccp->cblkw = (OPJ_UINT32)opj_int_floorlog2(parameters->cblockw_init);
-                        tccp->cblkh = (OPJ_UINT32)opj_int_floorlog2(parameters->cblockh_init);
-                        tccp->cblksty = (OPJ_UINT32)parameters->mode;
-                        tccp->qmfbid = parameters->irreversible ? 0 : 1;
-                        tccp->qntsty = parameters->irreversible ? J2K_CCP_QNTSTY_SEQNT : J2K_CCP_QNTSTY_NOQNT;
-                        tccp->numgbits = 2;
-
-                        if ((OPJ_INT32)i == parameters->roi_compno) {
-                                tccp->roishift = parameters->roi_shift;
-                        } else {
-                                tccp->roishift = 0;
-                        }
-
-                                if (parameters->csty & J2K_CCP_CSTY_PRT) {
-                                        OPJ_INT32 p = 0, it_res;
-                                        assert( tccp->numresolutions > 0 );
-                                        for (it_res = (OPJ_INT32)tccp->numresolutions - 1; it_res >= 0; it_res--) {
-                                                if (p < parameters->res_spec) {
-
-                                                        if (parameters->prcw_init[p] < 1) {
-                                                                tccp->prcw[it_res] = 1;
-                                                        } else {
-                                                                tccp->prcw[it_res] = (OPJ_UINT32)opj_int_floorlog2(parameters->prcw_init[p]);
-                                                        }
-
-                                                        if (parameters->prch_init[p] < 1) {
-                                                                tccp->prch[it_res] = 1;
-                                                        }else {
-                                                                tccp->prch[it_res] = (OPJ_UINT32)opj_int_floorlog2(parameters->prch_init[p]);
-                                                        }
-
-                                                } else {
-                                                        OPJ_INT32 res_spec = parameters->res_spec;
-                                                        OPJ_INT32 size_prcw = 0;
-                                                        OPJ_INT32 size_prch = 0;
-
-                                                        assert(res_spec>0); /* issue 189 */
-                                                        size_prcw = parameters->prcw_init[res_spec - 1] >> (p - (res_spec - 1));
-                                                        size_prch = parameters->prch_init[res_spec - 1] >> (p - (res_spec - 1));
-
-
-                                                        if (size_prcw < 1) {
-                                                                tccp->prcw[it_res] = 1;
-                                                        } else {
-                                                                tccp->prcw[it_res] = (OPJ_UINT32)opj_int_floorlog2(size_prcw);
-                                                        }
-
-                                                        if (size_prch < 1) {
-                                                                tccp->prch[it_res] = 1;
-                                                        } else {
-                                                                tccp->prch[it_res] = (OPJ_UINT32)opj_int_floorlog2(size_prch);
-                                                        }
-                                                }
-                                                p++;
-                                                /*printf("\nsize precinct for level %d : %d,%d\n", it_res,tccp->prcw[it_res], tccp->prch[it_res]); */
-                                        }       /*end for*/
-                                } else {
-                                        for (j = 0; j < tccp->numresolutions; j++) {
-                                                tccp->prcw[j] = 15;
-                                                tccp->prch[j] = 15;
-                                        }
-                                }
-
-                        opj_dwt_calc_explicit_stepsizes(tccp, image->comps[i].prec);
-                }
-        }
-
-        if (parameters->mct_data) {
-                opj_free(parameters->mct_data);
-                parameters->mct_data = 00;
-        }
-}
-
-static OPJ_BOOL opj_j2k_add_mhmarker(opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_OFF_T pos, OPJ_UINT32 len)
-{
-        assert(cstr_index != 00);
-
-        /* expand the list? */
-        if ((cstr_index->marknum + 1) > cstr_index->maxmarknum) {
-                opj_marker_info_t *new_marker;
-                cstr_index->maxmarknum = (OPJ_UINT32)(100 + (OPJ_FLOAT32) cstr_index->maxmarknum);
-                new_marker = (opj_marker_info_t *) opj_realloc(cstr_index->marker, cstr_index->maxmarknum *sizeof(opj_marker_info_t));
-                if (! new_marker) {
-                        opj_free(cstr_index->marker);
-                        cstr_index->marker = NULL;
-                        cstr_index->maxmarknum = 0;
-                        cstr_index->marknum = 0;
-                        /* opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to add mh marker\n"); */
-                        return OPJ_FALSE;
-                }
-                cstr_index->marker = new_marker;
-        }
-
-        /* add the marker */
-        cstr_index->marker[cstr_index->marknum].type = (OPJ_UINT16)type;
-        cstr_index->marker[cstr_index->marknum].pos = (OPJ_INT32)pos;
-        cstr_index->marker[cstr_index->marknum].len = (OPJ_INT32)len;
-        cstr_index->marknum++;
-        return OPJ_TRUE;
-}
-
-static OPJ_BOOL opj_j2k_add_tlmarker(OPJ_UINT32 tileno, opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_OFF_T pos, OPJ_UINT32 len)
-{
-        assert(cstr_index != 00);
-        assert(cstr_index->tile_index != 00);
-
-        /* expand the list? */
-        if ((cstr_index->tile_index[tileno].marknum + 1) > cstr_index->tile_index[tileno].maxmarknum) {
-                opj_marker_info_t *new_marker;
-                cstr_index->tile_index[tileno].maxmarknum = (OPJ_UINT32)(100 + (OPJ_FLOAT32) cstr_index->tile_index[tileno].maxmarknum);
-                new_marker = (opj_marker_info_t *) opj_realloc(
-                                cstr_index->tile_index[tileno].marker,
-                                cstr_index->tile_index[tileno].maxmarknum *sizeof(opj_marker_info_t));
-                if (! new_marker) {
-                        opj_free(cstr_index->tile_index[tileno].marker);
-                        cstr_index->tile_index[tileno].marker = NULL;
-                        cstr_index->tile_index[tileno].maxmarknum = 0;
-                        cstr_index->tile_index[tileno].marknum = 0;
-                        /* opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to add tl marker\n"); */
-                        return OPJ_FALSE;
-                }
-                cstr_index->tile_index[tileno].marker = new_marker;
-        }
-
-        /* add the marker */
-        cstr_index->tile_index[tileno].marker[cstr_index->tile_index[tileno].marknum].type = (OPJ_UINT16)type;
-        cstr_index->tile_index[tileno].marker[cstr_index->tile_index[tileno].marknum].pos = (OPJ_INT32)pos;
-        cstr_index->tile_index[tileno].marker[cstr_index->tile_index[tileno].marknum].len = (OPJ_INT32)len;
-        cstr_index->tile_index[tileno].marknum++;
-
-        if (type == J2K_MS_SOT) {
-                OPJ_UINT32 l_current_tile_part = cstr_index->tile_index[tileno].current_tpsno;
-
-                if (cstr_index->tile_index[tileno].tp_index)
-                        cstr_index->tile_index[tileno].tp_index[l_current_tile_part].start_pos = pos;
-
-        }
-        return OPJ_TRUE;
-}
-
-/*
- * -----------------------------------------------------------------------
- * -----------------------------------------------------------------------
- * -----------------------------------------------------------------------
- */
-
-OPJ_BOOL opj_j2k_end_decompress(opj_j2k_t *p_j2k,
-                                opj_stream_private_t *p_stream,
-                                opj_event_mgr_t * p_manager
-                                )
-{
-    (void)p_j2k;
-    (void)p_stream;
-    (void)p_manager;
-    return OPJ_TRUE;
-}
-
-OPJ_BOOL opj_j2k_read_header(   opj_stream_private_t *p_stream,
-                                                            opj_j2k_t* p_j2k,
-                                                            opj_image_t** p_image,
-                                                            opj_event_mgr_t* p_manager )
-{
-        /* preconditions */
-        assert(p_j2k != 00);
-        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);
-
-        /* 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);
-
-        /* 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)
-{
-        /* preconditions*/
-        assert(p_j2k != 00);
-
-        opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_read_header_procedure);
-
-        /* 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);
-
-}
-
-void opj_j2k_setup_decoding_validation (opj_j2k_t *p_j2k)
-{
-        /* preconditions*/
-        assert(p_j2k != 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);
-        /* DEVELOPER CORNER, add your custom validation procedure */
-
-}
-
-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&nbs