src/lib/openjp2/j2k.c

   1 /*
   2  * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
   3  * Copyright (c) 2002-2007, Professor Benoit Macq
   4  * Copyright (c) 2001-2003, David Janssens
   5  * Copyright (c) 2002-2003, Yannick Verschueren
   6  * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
   7  * Copyright (c) 2005, Herve Drolon, FreeImage Team
   8  * Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
   9  * Copyright (c) 2006-2007, Parvatha Elangovan
  10  * Copyright (c) 2010-2011, Kaori Hagihara
  11  * Copyright (c) 2011-2012, Centre National d'Etudes Spatiales (CNES), France
  12  * Copyright (c) 2012, CS Systemes d'Information, France
  13  * All rights reserved.
  14  *
  15  * Redistribution and use in source and binary forms, with or without
  16  * modification, are permitted provided that the following conditions
  17  * are met:
  18  * 1. Redistributions of source code must retain the above copyright
  19  *    notice, this list of conditions and the following disclaimer.
  20  * 2. Redistributions in binary form must reproduce the above copyright
  21  *    notice, this list of conditions and the following disclaimer in the
  22  *    documentation and/or other materials provided with the distribution.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
  25  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  28  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  29  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  30  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  31  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  32  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  33  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  34  * POSSIBILITY OF SUCH DAMAGE.
  35  */
  36
  37 #include "opj_includes.h"
  38
  39 /** @defgroup J2K J2K - JPEG-2000 codestream reader/writer */
  40 /*@{*/
  41
  42 /** @name Local static functions */
  43 /*@{*/
  44
  45 /**
  46  * Sets up the procedures to do on reading header. Developpers wanting to extend the library can add their own reading procedures.
  47  */
  48 static void opj_j2k_setup_header_reading (opj_j2k_t *p_j2k);
  49
  50 /**
  51  * The read header procedure.
  52  */
  53 static OPJ_BOOL opj_j2k_read_header_procedure(  opj_j2k_t *p_j2k,
  54                                                 opj_stream_private_t *p_stream,
  55                                                 opj_event_mgr_t * p_manager);
  56
  57 /**
  58  * The default encoding validation procedure without any extension.
  59  *
  60  * @param       p_j2k                   the jpeg2000 codec to validate.
  61  * @param       p_stream                the input stream to validate.
  62  * @param       p_manager               the user event manager.
  63  *
  64  * @return true if the parameters are correct.
  65  */
  66 static OPJ_BOOL opj_j2k_encoding_validation (   opj_j2k_t * p_j2k,
  67                                                 opj_stream_private_t *p_stream,
  68                                                 opj_event_mgr_t * p_manager );
  69
  70 /**
  71  * The default decoding validation procedure without any extension.
  72  *
  73  * @param       p_j2k                   the jpeg2000 codec to validate.
  74  * @param       p_stream                                the input stream to validate.
  75  * @param       p_manager               the user event manager.
  76  *
  77  * @return true if the parameters are correct.
  78  */
  79 static OPJ_BOOL opj_j2k_decoding_validation (   opj_j2k_t * p_j2k,
  80                                                 opj_stream_private_t *p_stream,
  81                                                 opj_event_mgr_t * p_manager );
  82
  83 /**
  84  * Sets up the validation ,i.e. adds the procedures to lauch to make sure the codec parameters
  85  * are valid. Developpers wanting to extend the library can add their own validation procedures.
  86  */
  87 static void opj_j2k_setup_encoding_validation (opj_j2k_t *p_j2k);
  88
  89 /**
  90  * Sets up the validation ,i.e. adds the procedures to lauch to make sure the codec parameters
  91  * are valid. Developpers wanting to extend the library can add their own validation procedures.
  92  */
  93 static void opj_j2k_setup_decoding_validation (opj_j2k_t *p_j2k);
  94
  95 /**
  96  * Sets up the validation ,i.e. adds the procedures to lauch to make sure the codec parameters
  97  * are valid. Developpers wanting to extend the library can add their own validation procedures.
  98  */
  99 static void opj_j2k_setup_end_compress (opj_j2k_t *p_j2k);
 100
 101 /**
 102  * The mct encoding validation procedure.
 103  *
 104  * @param       p_j2k                   the jpeg2000 codec to validate.
 105  * @param       p_stream                                the input stream to validate.
 106  * @param       p_manager               the user event manager.
 107  *
 108  * @return true if the parameters are correct.
 109  */
 110 static OPJ_BOOL opj_j2k_mct_validation (opj_j2k_t * p_j2k,
 111                                         opj_stream_private_t *p_stream,
 112                                         opj_event_mgr_t * p_manager );
 113
 114 /**
 115  * Builds the tcd decoder to use to decode tile.
 116  */
 117 static OPJ_BOOL opj_j2k_build_decoder ( opj_j2k_t * p_j2k,
 118                                         opj_stream_private_t *p_stream,
 119                                         opj_event_mgr_t * p_manager );
 120 /**
 121  * Builds the tcd encoder to use to encode tile.
 122  */
 123 static OPJ_BOOL opj_j2k_build_encoder ( opj_j2k_t * p_j2k,
 124                                         opj_stream_private_t *p_stream,
 125                                         opj_event_mgr_t * p_manager );
 126
 127 /**
 128  * Creates a tile-coder decoder.
 129  *
 130  * @param       p_stream                        the stream to write data to.
 131  * @param       p_j2k                           J2K codec.
 132  * @param       p_manager                   the user event manager.
 133 */
 134 static OPJ_BOOL opj_j2k_create_tcd(     opj_j2k_t *p_j2k,
 135                                                                     opj_stream_private_t *p_stream,
 136                                                                     opj_event_mgr_t * p_manager );
 137
 138 /**
 139  * Excutes the given procedures on the given codec.
 140  *
 141  * @param       p_procedure_list        the list of procedures to execute
 142  * @param       p_j2k                           the jpeg2000 codec to execute the procedures on.
 143  * @param       p_stream                        the stream to execute the procedures on.
 144  * @param       p_manager                       the user manager.
 145  *
 146  * @return      true                            if all the procedures were successfully executed.
 147  */
 148 static OPJ_BOOL opj_j2k_exec (  opj_j2k_t * p_j2k,
 149                             opj_procedure_list_t * p_procedure_list,
 150                             opj_stream_private_t *p_stream,
 151                             opj_event_mgr_t * p_manager);
 152
 153 /**
 154  * Updates the rates of the tcp.
 155  *
 156  * @param       p_stream                                the stream to write data to.
 157  * @param       p_j2k                           J2K codec.
 158  * @param       p_manager               the user event manager.
 159 */
 160 static OPJ_BOOL opj_j2k_update_rates(   opj_j2k_t *p_j2k,
 161                                                                             opj_stream_private_t *p_stream,
 162                                                                             opj_event_mgr_t * p_manager );
 163
 164 /**
 165  * Copies the decoding tile parameters onto all the tile parameters.
 166  * Creates also the tile decoder.
 167  */
 168 static OPJ_BOOL opj_j2k_copy_default_tcp_and_create_tcd (       opj_j2k_t * p_j2k,
 169                                                             opj_stream_private_t *p_stream,
 170                                                             opj_event_mgr_t * p_manager );
 171
 172 /**
 173  * Destroys the memory associated with the decoding of headers.
 174  */
 175 static OPJ_BOOL opj_j2k_destroy_header_memory ( opj_j2k_t * p_j2k,
 176                                                 opj_stream_private_t *p_stream,
 177                                                 opj_event_mgr_t * p_manager );
 178
 179 /**
 180  * Reads the lookup table containing all the marker, status and action, and returns the handler associated
 181  * with the marker value.
 182  * @param       p_id            Marker value to look up
 183  *
 184  * @return      the handler associated with the id.
 185 */
 186 static const struct opj_dec_memory_marker_handler * opj_j2k_get_marker_handler (OPJ_UINT32 p_id);
 187
 188 /**
 189  * Destroys a tile coding parameter structure.
 190  *
 191  * @param       p_tcp           the tile coding parameter to destroy.
 192  */
 193 static void opj_j2k_tcp_destroy (opj_tcp_t *p_tcp);
 194
 195 /**
 196  * Destroys the data inside a tile coding parameter structure.
 197  *
 198  * @param       p_tcp           the tile coding parameter which contain data to destroy.
 199  */
 200 static void opj_j2k_tcp_data_destroy (opj_tcp_t *p_tcp);
 201
 202 /**
 203  * Destroys a coding parameter structure.
 204  *
 205  * @param       p_cp            the coding parameter to destroy.
 206  */
 207 static void opj_j2k_cp_destroy (opj_cp_t *p_cp);
 208
 209 /**
 210  * Writes a SPCod or SPCoc element, i.e. the coding style of a given component of a tile.
 211  *
 212  * @param       p_j2k           J2K codec.
 213  * @param       p_tile_no       FIXME DOC
 214  * @param       p_comp_no       the component number to output.
 215  * @param       p_data          FIXME DOC
 216  * @param       p_header_size   FIXME DOC
 217  * @param       p_manager       the user event manager.
 218  *
 219  * @return FIXME DOC
 220 */
 221 static OPJ_BOOL opj_j2k_write_SPCod_SPCoc(      opj_j2k_t *p_j2k,
 222                                                                                     OPJ_UINT32 p_tile_no,
 223                                                                                     OPJ_UINT32 p_comp_no,
 224                                                                                     OPJ_BYTE * p_data,
 225                                                                                     OPJ_UINT32 * p_header_size,
 226                                                                                     opj_event_mgr_t * p_manager );
 227
 228 /**
 229  * Gets the size taken by writing a SPCod or SPCoc for the given tile and component.
 230  *
 231  * @param       p_j2k                   the J2K codec.
 232  * @param       p_tile_no               the tile index.
 233  * @param       p_comp_no               the component being outputted.
 234  *
 235  * @return      the number of bytes taken by the SPCod element.
 236  */
 237 static OPJ_UINT32 opj_j2k_get_SPCod_SPCoc_size (opj_j2k_t *p_j2k,
 238                                                                                             OPJ_UINT32 p_tile_no,
 239                                                                                             OPJ_UINT32 p_comp_no );
 240
 241 /**
 242  * Reads a SPCod or SPCoc element, i.e. the coding style of a given component of a tile.
 243  * @param       p_j2k           the jpeg2000 codec.
 244  * @param       compno          FIXME DOC
 245  * @param       p_header_data   the data contained in the COM box.
 246  * @param       p_header_size   the size of the data contained in the COM marker.
 247  * @param       p_manager       the user event manager.
 248 */
 249 static OPJ_BOOL opj_j2k_read_SPCod_SPCoc(   opj_j2k_t *p_j2k,
 250                                             OPJ_UINT32 compno,
 251                                             OPJ_BYTE * p_header_data,
 252                                             OPJ_UINT32 * p_header_size,
 253                                             opj_event_mgr_t * p_manager );
 254
 255 /**
 256  * Gets the size taken by writing SQcd or SQcc element, i.e. the quantization values of a band in the QCD or QCC.
 257  *
 258  * @param       p_tile_no               the tile index.
 259  * @param       p_comp_no               the component being outputted.
 260  * @param       p_j2k                   the J2K codec.
 261  *
 262  * @return      the number of bytes taken by the SPCod element.
 263  */
 264 static OPJ_UINT32 opj_j2k_get_SQcd_SQcc_size (  opj_j2k_t *p_j2k,
 265                                                                                     OPJ_UINT32 p_tile_no,
 266                                                                                     OPJ_UINT32 p_comp_no );
 267
 268 /**
 269  * Writes a SQcd or SQcc element, i.e. the quantization values of a band in the QCD or QCC.
 270  *
 271  * @param       p_tile_no               the tile to output.
 272  * @param       p_comp_no               the component number to output.
 273  * @param       p_data                  the data buffer.
 274  * @param       p_header_size   pointer to the size of the data buffer, it is changed by the function.
 275  * @param       p_j2k                   J2K codec.
 276  * @param       p_manager               the user event manager.
 277  *
 278 */
 279 static OPJ_BOOL opj_j2k_write_SQcd_SQcc(opj_j2k_t *p_j2k,
 280                                                                             OPJ_UINT32 p_tile_no,
 281                                                                             OPJ_UINT32 p_comp_no,
 282                                                                             OPJ_BYTE * p_data,
 283                                                                             OPJ_UINT32 * p_header_size,
 284                                                                             opj_event_mgr_t * p_manager);
 285
 286 /**
 287  * Updates the Tile Length Marker.
 288  */
 289 static void opj_j2k_update_tlm ( opj_j2k_t * p_j2k, OPJ_UINT32 p_tile_part_size);
 290
 291 /**
 292  * Reads a SQcd or SQcc element, i.e. the quantization values of a band in the QCD or QCC.
 293  *
 294  * @param       p_j2k           J2K codec.
 295  * @param       compno          the component number to output.
 296  * @param       p_header_data   the data buffer.
 297  * @param       p_header_size   pointer to the size of the data buffer, it is changed by the function.
 298  * @param       p_manager       the user event manager.
 299  *
 300 */
 301 static OPJ_BOOL opj_j2k_read_SQcd_SQcc( opj_j2k_t *p_j2k,
 302                                         OPJ_UINT32 compno,
 303                                         OPJ_BYTE * p_header_data,
 304                                         OPJ_UINT32 * p_header_size,
 305                                         opj_event_mgr_t * p_manager );
 306
 307 /**
 308  * Copies the tile component parameters of all the component from the first tile component.
 309  *
 310  * @param               p_j2k           the J2k codec.
 311  */
 312 static void opj_j2k_copy_tile_component_parameters( opj_j2k_t *p_j2k );
 313
 314 /**
 315  * Copies the tile quantization parameters of all the component from the first tile component.
 316  *
 317  * @param               p_j2k           the J2k codec.
 318  */
 319 static void opj_j2k_copy_tile_quantization_parameters( opj_j2k_t *p_j2k );
 320
 321 /**
 322  * Reads the tiles.
 323  */
 324 static OPJ_BOOL opj_j2k_decode_tiles (  opj_j2k_t *p_j2k,
 325                                         opj_stream_private_t *p_stream,
 326                                         opj_event_mgr_t * p_manager);
 327
 328 static OPJ_BOOL opj_j2k_pre_write_tile ( opj_j2k_t * p_j2k,
 329                                                                              OPJ_UINT32 p_tile_index,
 330                                                                              opj_stream_private_t *p_stream,
 331                                                                              opj_event_mgr_t * p_manager );
 332
 333 static OPJ_BOOL opj_j2k_update_image_data (opj_tcd_t * p_tcd, OPJ_BYTE * p_data, opj_image_t* p_output_image);
 334
 335 static void opj_j2k_get_tile_data (opj_tcd_t * p_tcd, OPJ_BYTE * p_data);
 336
 337 static OPJ_BOOL opj_j2k_post_write_tile (opj_j2k_t * p_j2k,
 338                                                                              OPJ_BYTE * p_data,
 339                                                                              OPJ_UINT32 p_data_size,
 340                                                                              opj_stream_private_t *p_stream,
 341                                                                              opj_event_mgr_t * p_manager );
 342
 343 /**
 344  * Sets up the procedures to do on writing header.
 345  * Developers wanting to extend the library can add their own writing procedures.
 346  */
 347 static void opj_j2k_setup_header_writing (opj_j2k_t *p_j2k);
 348
 349 static OPJ_BOOL opj_j2k_write_first_tile_part(  opj_j2k_t *p_j2k,
 350                                                                                             OPJ_BYTE * p_data,
 351                                                                                             OPJ_UINT32 * p_data_written,
 352                                                                                             OPJ_UINT32 p_total_data_size,
 353                                                                                             opj_stream_private_t *p_stream,
 354                                                                                             struct opj_event_mgr * p_manager );
 355
 356 static OPJ_BOOL opj_j2k_write_all_tile_parts(   opj_j2k_t *p_j2k,
 357                                                                                             OPJ_BYTE * p_data,
 358                                                                                             OPJ_UINT32 * p_data_written,
 359                                                                                             OPJ_UINT32 p_total_data_size,
 360                                                                                             opj_stream_private_t *p_stream,
 361                                                                                             struct opj_event_mgr * p_manager );
 362
 363 /**
 364  * Gets the offset of the header.
 365  *
 366  * @param       p_stream                the stream to write data to.
 367  * @param       p_j2k                   J2K codec.
 368  * @param       p_manager               the user event manager.
 369 */
 370 static OPJ_BOOL opj_j2k_get_end_header( opj_j2k_t *p_j2k,
 371                                         opj_stream_private_t *p_stream,
 372                                         opj_event_mgr_t * p_manager );
 373
 374 static OPJ_BOOL opj_j2k_allocate_tile_element_cstr_index(opj_j2k_t *p_j2k);
 375
 376 /*
 377  * -----------------------------------------------------------------------
 378  * -----------------------------------------------------------------------
 379  * -----------------------------------------------------------------------
 380  */
 381
 382 /**
 383  * Writes the SOC marker (Start Of Codestream)
 384  *
 385  * @param       p_stream                        the stream to write data to.
 386  * @param       p_j2k                   J2K codec.
 387  * @param       p_manager       the user event manager.
 388 */
 389 static OPJ_BOOL opj_j2k_write_soc(      opj_j2k_t *p_j2k,
 390                                                         opj_stream_private_t *p_stream,
 391                                                             opj_event_mgr_t * p_manager );
 392
 393 /**
 394  * Reads a SOC marker (Start of Codestream)
 395  * @param       p_j2k           the jpeg2000 file codec.
 396  * @param       p_stream        XXX needs data
 397  * @param       p_manager       the user event manager.
 398 */
 399 static OPJ_BOOL opj_j2k_read_soc(   opj_j2k_t *p_j2k,
 400                                     opj_stream_private_t *p_stream,
 401                                     opj_event_mgr_t * p_manager );
 402
 403 /**
 404  * Writes the SIZ marker (image and tile size)
 405  *
 406  * @param       p_j2k           J2K codec.
 407  * @param       p_stream        the stream to write data to.
 408  * @param       p_manager       the user event manager.
 409 */
 410 static OPJ_BOOL opj_j2k_write_siz(      opj_j2k_t *p_j2k,
 411                                                                 opj_stream_private_t *p_stream,
 412                                                                 opj_event_mgr_t * p_manager );
 413
 414 /**
 415  * Reads a SIZ marker (image and tile size)
 416  * @param       p_j2k           the jpeg2000 file codec.
 417  * @param       p_header_data   the data contained in the SIZ box.
 418  * @param       p_header_size   the size of the data contained in the SIZ marker.
 419  * @param       p_manager       the user event manager.
 420 */
 421 static OPJ_BOOL opj_j2k_read_siz(opj_j2k_t *p_j2k,
 422                                  OPJ_BYTE * p_header_data,
 423                                  OPJ_UINT32 p_header_size,
 424                                  opj_event_mgr_t * p_manager);
 425
 426 /**
 427  * Writes the COM marker (comment)
 428  *
 429  * @param       p_stream                        the stream to write data to.
 430  * @param       p_j2k                   J2K codec.
 431  * @param       p_manager       the user event manager.
 432 */
 433 static OPJ_BOOL opj_j2k_write_com(      opj_j2k_t *p_j2k,
 434                                                                         opj_stream_private_t *p_stream,
 435                                                                         opj_event_mgr_t * p_manager );
 436
 437 /**
 438  * Reads a COM marker (comments)
 439  * @param       p_j2k           the jpeg2000 file codec.
 440  * @param       p_header_data   the data contained in the COM box.
 441  * @param       p_header_size   the size of the data contained in the COM marker.
 442  * @param       p_manager       the user event manager.
 443 */
 444 static OPJ_BOOL opj_j2k_read_com (  opj_j2k_t *p_j2k,
 445                                     OPJ_BYTE * p_header_data,
 446                                     OPJ_UINT32 p_header_size,
 447                                     opj_event_mgr_t * p_manager );
 448 /**
 449  * Writes the COD marker (Coding style default)
 450  *
 451  * @param       p_stream                        the stream to write data to.
 452  * @param       p_j2k                   J2K codec.
 453  * @param       p_manager       the user event manager.
 454 */
 455 static OPJ_BOOL opj_j2k_write_cod(      opj_j2k_t *p_j2k,
 456                                                                         opj_stream_private_t *p_stream,
 457                                                                         opj_event_mgr_t * p_manager );
 458
 459 /**
 460  * Reads a COD marker (Coding Styke defaults)
 461  * @param       p_header_data   the data contained in the COD box.
 462  * @param       p_j2k                   the jpeg2000 codec.
 463  * @param       p_header_size   the size of the data contained in the COD marker.
 464  * @param       p_manager               the user event manager.
 465 */
 466 static OPJ_BOOL opj_j2k_read_cod (  opj_j2k_t *p_j2k,
 467                                     OPJ_BYTE * p_header_data,
 468                                     OPJ_UINT32 p_header_size,
 469                                     opj_event_mgr_t * p_manager);
 470
 471 /**
 472  * Writes the COC marker (Coding style component)
 473  *
 474  * @param       p_j2k       J2K codec.
 475  * @param       p_comp_no   the index of the component to output.
 476  * @param       p_stream    the stream to write data to.
 477  * @param       p_manager   the user event manager.
 478 */
 479 static OPJ_BOOL opj_j2k_write_coc(  opj_j2k_t *p_j2k,
 480                                                                 OPJ_UINT32 p_comp_no,
 481                                                                 opj_stream_private_t *p_stream,
 482                                                                 opj_event_mgr_t * p_manager );
 483 /**
 484  * Writes the COC marker (Coding style component)
 485  *
 486  * @param       p_j2k                   J2K codec.
 487  * @param       p_comp_no               the index of the component to output.
 488  * @param       p_data          FIXME DOC
 489  * @param       p_data_written  FIXME DOC
 490  * @param       p_manager               the user event manager.
 491 */
 492 static void opj_j2k_write_coc_in_memory(opj_j2k_t *p_j2k,
 493                                                                             OPJ_UINT32 p_comp_no,
 494                                                                             OPJ_BYTE * p_data,
 495                                                                             OPJ_UINT32 * p_data_written,
 496                                                                             opj_event_mgr_t * p_manager );
 497
 498 /**
 499  * Gets the maximum size taken by a coc.
 500  *
 501  * @param       p_j2k   the jpeg2000 codec to use.
 502  */
 503 static OPJ_UINT32 opj_j2k_get_max_coc_size(opj_j2k_t *p_j2k);
 504
 505 /**
 506  * Reads a COC marker (Coding Style Component)
 507  * @param       p_header_data   the data contained in the COC box.
 508  * @param       p_j2k                   the jpeg2000 codec.
 509  * @param       p_header_size   the size of the data contained in the COC marker.
 510  * @param       p_manager               the user event manager.
 511 */
 512 static OPJ_BOOL opj_j2k_read_coc (  opj_j2k_t *p_j2k,
 513                                     OPJ_BYTE * p_header_data,
 514                                     OPJ_UINT32 p_header_size,
 515                                     opj_event_mgr_t * p_manager );
 516
 517 /**
 518  * Writes the QCD marker (quantization default)
 519  *
 520  * @param       p_j2k                   J2K codec.
 521  * @param       p_stream                the stream to write data to.
 522  * @param       p_manager               the user event manager.
 523 */
 524 static OPJ_BOOL opj_j2k_write_qcd(      opj_j2k_t *p_j2k,
 525                                                                         opj_stream_private_t *p_stream,
 526                                                                         opj_event_mgr_t * p_manager );
 527
 528 /**
 529  * Reads a QCD marker (Quantization defaults)
 530  * @param       p_header_data   the data contained in the QCD box.
 531  * @param       p_j2k                   the jpeg2000 codec.
 532  * @param       p_header_size   the size of the data contained in the QCD marker.
 533  * @param       p_manager               the user event manager.
 534 */
 535 static OPJ_BOOL opj_j2k_read_qcd (  opj_j2k_t *p_j2k,
 536                                     OPJ_BYTE * p_header_data,
 537                                     OPJ_UINT32 p_header_size,
 538                                     opj_event_mgr_t * p_manager );
 539 /**
 540  * Writes the QCC marker (quantization component)
 541  *
 542  * @param       p_comp_no       the index of the component to output.
 543  * @param       p_stream                the stream to write data to.
 544  * @param       p_j2k                   J2K codec.
 545  * @param       p_manager               the user event manager.
 546 */
 547 static OPJ_BOOL opj_j2k_write_qcc(      opj_j2k_t *p_j2k,
 548                                                                         OPJ_UINT32 p_comp_no,
 549                                                                         opj_stream_private_t *p_stream,
 550                                                                         opj_event_mgr_t * p_manager );
 551
 552 /**
 553  * Writes the QCC marker (quantization component)
 554  *
 555  * @param       p_j2k           J2K codec.
 556  * @param       p_comp_no       the index of the component to output.
 557  * @param       p_data          FIXME DOC
 558  * @param       p_data_written  the stream to write data to.
 559  * @param       p_manager       the user event manager.
 560 */
 561 static void opj_j2k_write_qcc_in_memory(opj_j2k_t *p_j2k,
 562                                                                             OPJ_UINT32 p_comp_no,
 563                                                                             OPJ_BYTE * p_data,
 564                                                                             OPJ_UINT32 * p_data_written,
 565                                                                             opj_event_mgr_t * p_manager );
 566
 567 /**
 568  * Gets the maximum size taken by a qcc.
 569  */
 570 static OPJ_UINT32 opj_j2k_get_max_qcc_size (opj_j2k_t *p_j2k);
 571
 572 /**
 573  * Reads a QCC marker (Quantization component)
 574  * @param       p_header_data   the data contained in the QCC box.
 575  * @param       p_j2k                   the jpeg2000 codec.
 576  * @param       p_header_size   the size of the data contained in the QCC marker.
 577  * @param       p_manager               the user event manager.
 578 */
 579 static OPJ_BOOL opj_j2k_read_qcc(   opj_j2k_t *p_j2k,
 580                                     OPJ_BYTE * p_header_data,
 581                                     OPJ_UINT32 p_header_size,
 582                                     opj_event_mgr_t * p_manager);
 583 /**
 584  * Writes the POC marker (Progression Order Change)
 585  *
 586  * @param       p_stream                                the stream to write data to.
 587  * @param       p_j2k                           J2K codec.
 588  * @param       p_manager               the user event manager.
 589 */
 590 static OPJ_BOOL opj_j2k_write_poc(      opj_j2k_t *p_j2k,
 591                                                                         opj_stream_private_t *p_stream,
 592                                                                         opj_event_mgr_t * p_manager );
 593 /**
 594  * Writes the POC marker (Progression Order Change)
 595  *
 596  * @param       p_j2k          J2K codec.
 597  * @param       p_data         FIXME DOC
 598  * @param       p_data_written the stream to write data to.
 599  * @param       p_manager      the user event manager.
 600  */
 601 static void opj_j2k_write_poc_in_memory(opj_j2k_t *p_j2k,
 602                                                                             OPJ_BYTE * p_data,
 603                                                                             OPJ_UINT32 * p_data_written,
 604                                                                             opj_event_mgr_t * p_manager );
 605 /**
 606  * Gets the maximum size taken by the writing of a POC.
 607  */
 608 static OPJ_UINT32 opj_j2k_get_max_poc_size(opj_j2k_t *p_j2k);
 609
 610 /**
 611  * Reads a POC marker (Progression Order Change)
 612  *
 613  * @param       p_header_data   the data contained in the POC box.
 614  * @param       p_j2k                   the jpeg2000 codec.
 615  * @param       p_header_size   the size of the data contained in the POC marker.
 616  * @param       p_manager               the user event manager.
 617 */
 618 static OPJ_BOOL opj_j2k_read_poc (  opj_j2k_t *p_j2k,
 619                                     OPJ_BYTE * p_header_data,
 620                                     OPJ_UINT32 p_header_size,
 621                                     opj_event_mgr_t * p_manager );
 622
 623 /**
 624  * Gets the maximum size taken by the toc headers of all the tile parts of any given tile.
 625  */
 626 static OPJ_UINT32 opj_j2k_get_max_toc_size (opj_j2k_t *p_j2k);
 627
 628 /**
 629  * Gets the maximum size taken by the headers of the SOT.
 630  *
 631  * @param       p_j2k   the jpeg2000 codec to use.
 632  */
 633 static OPJ_UINT32 opj_j2k_get_specific_header_sizes(opj_j2k_t *p_j2k);
 634
 635 /**
 636  * Reads a CRG marker (Component registration)
 637  *
 638  * @param       p_header_data   the data contained in the TLM box.
 639  * @param       p_j2k                   the jpeg2000 codec.
 640  * @param       p_header_size   the size of the data contained in the TLM marker.
 641  * @param       p_manager               the user event manager.
 642 */
 643 static OPJ_BOOL opj_j2k_read_crg (  opj_j2k_t *p_j2k,
 644                                     OPJ_BYTE * p_header_data,
 645                                     OPJ_UINT32 p_header_size,
 646                                     opj_event_mgr_t * p_manager );
 647 /**
 648  * Reads a TLM marker (Tile Length Marker)
 649  *
 650  * @param       p_header_data   the data contained in the TLM box.
 651  * @param       p_j2k                   the jpeg2000 codec.
 652  * @param       p_header_size   the size of the data contained in the TLM marker.
 653  * @param       p_manager               the user event manager.
 654 */
 655 static OPJ_BOOL opj_j2k_read_tlm (  opj_j2k_t *p_j2k,
 656                                     OPJ_BYTE * p_header_data,
 657                                     OPJ_UINT32 p_header_size,
 658                                     opj_event_mgr_t * p_manager);
 659
 660 /**
 661  * Writes the updated tlm.
 662  *
 663  * @param       p_stream                the stream to write data to.
 664  * @param       p_j2k                   J2K codec.
 665  * @param       p_manager               the user event manager.
 666 */
 667 static OPJ_BOOL opj_j2k_write_updated_tlm(      opj_j2k_t *p_j2k,
 668                                             opj_stream_private_t *p_stream,
 669                                             opj_event_mgr_t * p_manager );
 670
 671 /**
 672  * Reads a PLM marker (Packet length, main header marker)
 673  *
 674  * @param       p_header_data   the data contained in the TLM box.
 675  * @param       p_j2k                   the jpeg2000 codec.
 676  * @param       p_header_size   the size of the data contained in the TLM marker.
 677  * @param       p_manager               the user event manager.
 678 */
 679 static OPJ_BOOL opj_j2k_read_plm (  opj_j2k_t *p_j2k,
 680                                     OPJ_BYTE * p_header_data,
 681                                     OPJ_UINT32 p_header_size,
 682                                     opj_event_mgr_t * p_manager);
 683 /**
 684  * Reads a PLT marker (Packet length, tile-part header)
 685  *
 686  * @param       p_header_data   the data contained in the PLT box.
 687  * @param       p_j2k                   the jpeg2000 codec.
 688  * @param       p_header_size   the size of the data contained in the PLT marker.
 689  * @param       p_manager               the user event manager.
 690 */
 691 static OPJ_BOOL opj_j2k_read_plt (  opj_j2k_t *p_j2k,
 692                                     OPJ_BYTE * p_header_data,
 693                                     OPJ_UINT32 p_header_size,
 694                                     opj_event_mgr_t * p_manager );
 695
 696 #if 0
 697 /**
 698  * Reads a PPM marker (Packed packet headers, main header)
 699  *
 700  * @param       p_header_data   the data contained in the POC box.
 701  * @param       p_j2k                   the jpeg2000 codec.
 702  * @param       p_header_size   the size of the data contained in the POC marker.
 703  * @param       p_manager               the user event manager.
 704 */
 705 static OPJ_BOOL j2k_read_ppm_v2 (
 706                                                 opj_j2k_t *p_j2k,
 707                                                 OPJ_BYTE * p_header_data,
 708                                                 OPJ_UINT32 p_header_size,
 709                                                 struct opj_event_mgr * p_manager
 710                                         );
 711 #endif
 712
 713 static OPJ_BOOL j2k_read_ppm_v3 (
 714                                                 opj_j2k_t *p_j2k,
 715                                                 OPJ_BYTE * p_header_data,
 716                                                 OPJ_UINT32 p_header_size,
 717                                                 opj_event_mgr_t * p_manager );
 718
 719 /**
 720  * Reads a PPT marker (Packed packet headers, tile-part header)
 721  *
 722  * @param       p_header_data   the data contained in the PPT box.
 723  * @param       p_j2k                   the jpeg2000 codec.
 724  * @param       p_header_size   the size of the data contained in the PPT marker.
 725  * @param       p_manager               the user event manager.
 726 */
 727 static OPJ_BOOL opj_j2k_read_ppt (  opj_j2k_t *p_j2k,
 728                                     OPJ_BYTE * p_header_data,
 729                                     OPJ_UINT32 p_header_size,
 730                                     opj_event_mgr_t * p_manager );
 731 /**
 732  * Writes the TLM marker (Tile Length Marker)
 733  *
 734  * @param       p_stream                                the stream to write data to.
 735  * @param       p_j2k                           J2K codec.
 736  * @param       p_manager               the user event manager.
 737 */
 738 static OPJ_BOOL opj_j2k_write_tlm(      opj_j2k_t *p_j2k,
 739                                                                         opj_stream_private_t *p_stream,
 740                                                                         opj_event_mgr_t * p_manager );
 741
 742 /**
 743  * Writes the SOT marker (Start of tile-part)
 744  *
 745  * @param       p_j2k            J2K codec.
 746  * @param       p_data           FIXME DOC
 747  * @param       p_data_written   FIXME DOC
 748  * @param       p_stream         the stream to write data to.
 749  * @param       p_manager        the user event manager.
 750 */
 751 static OPJ_BOOL opj_j2k_write_sot(      opj_j2k_t *p_j2k,
 752                                                                         OPJ_BYTE * p_data,
 753                                                                         OPJ_UINT32 * p_data_written,
 754                                                                         const opj_stream_private_t *p_stream,
 755                                                                         opj_event_mgr_t * p_manager );
 756
 757 /**
 758  * Reads a PPT marker (Packed packet headers, tile-part header)
 759  *
 760  * @param       p_header_data   the data contained in the PPT box.
 761  * @param       p_j2k                   the jpeg2000 codec.
 762  * @param       p_header_size   the size of the data contained in the PPT marker.
 763  * @param       p_manager               the user event manager.
 764 */
 765 static OPJ_BOOL opj_j2k_read_sot (  opj_j2k_t *p_j2k,
 766                                     OPJ_BYTE * p_header_data,
 767                                     OPJ_UINT32 p_header_size,
 768                                     opj_event_mgr_t * p_manager );
 769 /**
 770  * Writes the SOD marker (Start of data)
 771  *
 772  * @param       p_j2k               J2K codec.
 773  * @param       p_tile_coder        FIXME DOC
 774  * @param       p_data              FIXME DOC
 775  * @param       p_data_written      FIXME DOC
 776  * @param       p_total_data_size   FIXME DOC
 777  * @param       p_stream            the stream to write data to.
 778  * @param       p_manager           the user event manager.
 779 */
 780 static OPJ_BOOL opj_j2k_write_sod(      opj_j2k_t *p_j2k,
 781                                                                         opj_tcd_t * p_tile_coder,
 782                                                                         OPJ_BYTE * p_data,
 783                                                                         OPJ_UINT32 * p_data_written,
 784                                                                         OPJ_UINT32 p_total_data_size,
 785                                                                         const opj_stream_private_t *p_stream,
 786                                                                         opj_event_mgr_t * p_manager );
 787
 788 /**
 789  * Reads a SOD marker (Start Of Data)
 790  *
 791  * @param       p_j2k                   the jpeg2000 codec.
 792  * @param       p_stream                FIXME DOC
 793  * @param       p_manager               the user event manager.
 794 */
 795 static OPJ_BOOL opj_j2k_read_sod(   opj_j2k_t *p_j2k,
 796                                     opj_stream_private_t *p_stream,
 797                                     opj_event_mgr_t * p_manager );
 798
 799 void opj_j2k_update_tlm (opj_j2k_t * p_j2k, OPJ_UINT32 p_tile_part_size )
 800 {
 801         opj_write_bytes(p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current,p_j2k->m_current_tile_number,1);            /* PSOT */
 802         ++p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current;
 803
 804         opj_write_bytes(p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current,p_tile_part_size,4);                                        /* PSOT */
 805         p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current += 4;
 806 }
 807
 808 /**
 809  * Writes the RGN marker (Region Of Interest)
 810  *
 811  * @param       p_tile_no               the tile to output
 812  * @param       p_comp_no               the component to output
 813  * @param       nb_comps                the number of components
 814  * @param       p_stream                the stream to write data to.
 815  * @param       p_j2k                   J2K codec.
 816  * @param       p_manager               the user event manager.
 817 */
 818 static OPJ_BOOL opj_j2k_write_rgn(  opj_j2k_t *p_j2k,
 819                                     OPJ_UINT32 p_tile_no,
 820                                     OPJ_UINT32 p_comp_no,
 821                                     OPJ_UINT32 nb_comps,
 822                                     opj_stream_private_t *p_stream,
 823                                     opj_event_mgr_t * p_manager );
 824
 825 /**
 826  * Reads a RGN marker (Region Of Interest)
 827  *
 828  * @param       p_header_data   the data contained in the POC box.
 829  * @param       p_j2k                   the jpeg2000 codec.
 830  * @param       p_header_size   the size of the data contained in the POC marker.
 831  * @param       p_manager               the user event manager.
 832 */
 833 static OPJ_BOOL opj_j2k_read_rgn (opj_j2k_t *p_j2k,
 834                                   OPJ_BYTE * p_header_data,
 835                                   OPJ_UINT32 p_header_size,
 836                                   opj_event_mgr_t * p_manager );
 837
 838 /**
 839  * Writes the EOC marker (End of Codestream)
 840  *
 841  * @param       p_stream                the stream to write data to.
 842  * @param       p_j2k                   J2K codec.
 843  * @param       p_manager               the user event manager.
 844 */
 845 static OPJ_BOOL opj_j2k_write_eoc(      opj_j2k_t *p_j2k,
 846                                     opj_stream_private_t *p_stream,
 847                                     opj_event_mgr_t * p_manager );
 848
 849 /**
 850  * Reads a EOC marker (End Of Codestream)
 851  *
 852  * @param       p_j2k                   the jpeg2000 codec.
 853  * @param       p_stream                FIXME DOC
 854  * @param       p_manager               the user event manager.
 855 */
 856 static OPJ_BOOL opj_j2k_read_eoc (      opj_j2k_t *p_j2k,
 857                                                                 opj_stream_private_t *p_stream,
 858                                                                 opj_event_mgr_t * p_manager );
 859
 860 /**
 861  * Writes the CBD-MCT-MCC-MCO markers (Multi components transform)
 862  *
 863  * @param       p_stream                        the stream to write data to.
 864  * @param       p_j2k                   J2K codec.
 865  * @param       p_manager       the user event manager.
 866 */
 867 static OPJ_BOOL opj_j2k_write_mct_data_group(   opj_j2k_t *p_j2k,
 868                                                 opj_stream_private_t *p_stream,
 869                                                 opj_event_mgr_t * p_manager );
 870
 871 /**
 872  * Inits the Info
 873  *
 874  * @param       p_stream                the stream to write data to.
 875  * @param       p_j2k                   J2K codec.
 876  * @param       p_manager               the user event manager.
 877 */
 878 static OPJ_BOOL opj_j2k_init_info(      opj_j2k_t *p_j2k,
 879                                     opj_stream_private_t *p_stream,
 880                                     opj_event_mgr_t * p_manager );
 881
 882 /**
 883 Add main header marker information
 884 @param cstr_index    Codestream information structure
 885 @param type         marker type
 886 @param pos          byte offset of marker segment
 887 @param len          length of marker segment
 888  */
 889 static OPJ_BOOL opj_j2k_add_mhmarker(opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_OFF_T pos, OPJ_UINT32 len) ;
 890 /**
 891 Add tile header marker information
 892 @param tileno       tile index number
 893 @param cstr_index   Codestream information structure
 894 @param type         marker type
 895 @param pos          byte offset of marker segment
 896 @param len          length of marker segment
 897  */
 898 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);
 899
 900 /**
 901  * Reads an unknown marker
 902  *
 903  * @param       p_j2k                   the jpeg2000 codec.
 904  * @param       p_stream                the stream object to read from.
 905  * @param       output_marker           FIXME DOC
 906  * @param       p_manager               the user event manager.
 907  *
 908  * @return      true                    if the marker could be deduced.
 909 */
 910 static OPJ_BOOL opj_j2k_read_unk( opj_j2k_t *p_j2k,
 911                                   opj_stream_private_t *p_stream,
 912                                   OPJ_UINT32 *output_marker,
 913                                   opj_event_mgr_t * p_manager );
 914
 915 /**
 916  * Writes the MCT marker (Multiple Component Transform)
 917  *
 918  * @param       p_j2k           J2K codec.
 919  * @param       p_mct_record    FIXME DOC
 920  * @param       p_stream        the stream to write data to.
 921  * @param       p_manager       the user event manager.
 922 */
 923 static OPJ_BOOL opj_j2k_write_mct_record(       opj_j2k_t *p_j2k,
 924                                                                                     opj_mct_data_t * p_mct_record,
 925                                             opj_stream_private_t *p_stream,
 926                                             opj_event_mgr_t * p_manager );
 927
 928 /**
 929  * Reads a MCT marker (Multiple Component Transform)
 930  *
 931  * @param       p_header_data   the data contained in the MCT box.
 932  * @param       p_j2k                   the jpeg2000 codec.
 933  * @param       p_header_size   the size of the data contained in the MCT marker.
 934  * @param       p_manager               the user event manager.
 935 */
 936 static OPJ_BOOL opj_j2k_read_mct (      opj_j2k_t *p_j2k,
 937                                                                     OPJ_BYTE * p_header_data,
 938                                                                     OPJ_UINT32 p_header_size,
 939                                                                     opj_event_mgr_t * p_manager );
 940
 941 /**
 942  * Writes the MCC marker (Multiple Component Collection)
 943  *
 944  * @param       p_j2k                   J2K codec.
 945  * @param       p_mcc_record            FIXME DOC
 946  * @param       p_stream                the stream to write data to.
 947  * @param       p_manager               the user event manager.
 948 */
 949 static OPJ_BOOL opj_j2k_write_mcc_record(   opj_j2k_t *p_j2k,
 950                                             opj_simple_mcc_decorrelation_data_t * p_mcc_record,
 951                                             opj_stream_private_t *p_stream,
 952                                             opj_event_mgr_t * p_manager );
 953
 954 /**
 955  * Reads a MCC marker (Multiple Component Collection)
 956  *
 957  * @param       p_header_data   the data contained in the MCC box.
 958  * @param       p_j2k                   the jpeg2000 codec.
 959  * @param       p_header_size   the size of the data contained in the MCC marker.
 960  * @param       p_manager               the user event manager.
 961 */
 962 static OPJ_BOOL opj_j2k_read_mcc (      opj_j2k_t *p_j2k,
 963                                                                     OPJ_BYTE * p_header_data,
 964                                                                     OPJ_UINT32 p_header_size,
 965                                                                     opj_event_mgr_t * p_manager );
 966
 967 /**
 968  * Writes the MCO marker (Multiple component transformation ordering)
 969  *
 970  * @param       p_stream                                the stream to write data to.
 971  * @param       p_j2k                           J2K codec.
 972  * @param       p_manager               the user event manager.
 973 */
 974 static OPJ_BOOL opj_j2k_write_mco(      opj_j2k_t *p_j2k,
 975                                     opj_stream_private_t *p_stream,
 976                                     opj_event_mgr_t * p_manager );
 977
 978 /**
 979  * Reads a MCO marker (Multiple Component Transform Ordering)
 980  *
 981  * @param       p_header_data   the data contained in the MCO box.
 982  * @param       p_j2k                   the jpeg2000 codec.
 983  * @param       p_header_size   the size of the data contained in the MCO marker.
 984  * @param       p_manager               the user event manager.
 985 */
 986 static OPJ_BOOL opj_j2k_read_mco (      opj_j2k_t *p_j2k,
 987                                                                     OPJ_BYTE * p_header_data,
 988                                                                     OPJ_UINT32 p_header_size,
 989                                                                     opj_event_mgr_t * p_manager );
 990
 991 static OPJ_BOOL opj_j2k_add_mct(opj_tcp_t * p_tcp, opj_image_t * p_image, OPJ_UINT32 p_index);
 992
 993 static void  opj_j2k_read_int16_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
 994 static void  opj_j2k_read_int32_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
 995 static void  opj_j2k_read_float32_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
 996 static void  opj_j2k_read_float64_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
 997
 998 static void  opj_j2k_read_int16_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
 999 static void  opj_j2k_read_int32_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
1000 static void  opj_j2k_read_float32_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
1001 static void  opj_j2k_read_float64_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
1002
1003 static void  opj_j2k_write_float_to_int16 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
1004 static void  opj_j2k_write_float_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
1005 static void  opj_j2k_write_float_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
1006 static void  opj_j2k_write_float_to_float64 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
1007
1008 /**
1009  * Ends the encoding, i.e. frees memory.
1010  *
1011  * @param       p_stream                the stream to write data to.
1012  * @param       p_j2k                   J2K codec.
1013  * @param       p_manager               the user event manager.
1014 */
1015 static OPJ_BOOL opj_j2k_end_encoding(   opj_j2k_t *p_j2k,
1016                                                                             opj_stream_private_t *p_stream,
1017                                                                             opj_event_mgr_t * p_manager );
1018
1019 /**
1020  * Writes the CBD marker (Component bit depth definition)
1021  *
1022  * @param       p_stream                                the stream to write data to.
1023  * @param       p_j2k                           J2K codec.
1024  * @param       p_manager               the user event manager.
1025 */
1026 static OPJ_BOOL opj_j2k_write_cbd(      opj_j2k_t *p_j2k,
1027                                                                     opj_stream_private_t *p_stream,
1028                                                                         opj_event_mgr_t * p_manager );
1029
1030 /**
1031  * Reads a CBD marker (Component bit depth definition)
1032  * @param       p_header_data   the data contained in the CBD box.
1033  * @param       p_j2k                   the jpeg2000 codec.
1034  * @param       p_header_size   the size of the data contained in the CBD marker.
1035  * @param       p_manager               the user event manager.
1036 */
1037 static OPJ_BOOL opj_j2k_read_cbd (      opj_j2k_t *p_j2k,
1038                                                                 OPJ_BYTE * p_header_data,
1039                                                                 OPJ_UINT32 p_header_size,
1040                                                                 opj_event_mgr_t * p_manager);
1041
1042 /**
1043  * Writes the image components.
1044  *
1045  * @param       p_stream                the stream to write data to.
1046  * @param       p_j2k                   J2K codec.
1047  * @param       p_manager               the user event manager.
1048 */
1049 static OPJ_BOOL opj_j2k_write_image_components( opj_j2k_t *p_j2k,
1050                                                                         opj_stream_private_t *p_stream,
1051                                                                         opj_event_mgr_t * p_manager );
1052
1053 /**
1054  * Writes regions of interests.
1055  *
1056  * @param       p_stream                the stream to write data to.
1057  * @param       p_j2k                   J2K codec.
1058  * @param       p_manager               the user event manager.
1059 */
1060 static OPJ_BOOL opj_j2k_write_regions(  opj_j2k_t *p_j2k,
1061                                                                         opj_stream_private_t *p_stream,
1062                                                                         opj_event_mgr_t * p_manager );
1063
1064 /**
1065  * Writes EPC ????
1066  *
1067  * @param       p_stream                the stream to write data to.
1068  * @param       p_j2k                   J2K codec.
1069  * @param       p_manager               the user event manager.
1070 */
1071 static OPJ_BOOL opj_j2k_write_epc(      opj_j2k_t *p_j2k,
1072                                                                     opj_stream_private_t *p_stream,
1073                                                                     opj_event_mgr_t * p_manager );
1074
1075 /**
1076  * Checks the progression order changes values. Tells of the poc given as input are valid.
1077  * A nice message is outputted at errors.
1078  *
1079  * @param       p_pocs                  the progression order changes.
1080  * @param       p_nb_pocs               the number of progression order changes.
1081  * @param       p_nb_resolutions        the number of resolutions.
1082  * @param       numcomps                the number of components
1083  * @param       numlayers               the number of layers.
1084  * @param       p_manager               the user event manager.
1085  *
1086  * @return      true if the pocs are valid.
1087  */
1088 static OPJ_BOOL opj_j2k_check_poc_val(  const opj_poc_t *p_pocs,
1089                                                                             OPJ_UINT32 p_nb_pocs,
1090                                                                             OPJ_UINT32 p_nb_resolutions,
1091                                                                             OPJ_UINT32 numcomps,
1092                                                                             OPJ_UINT32 numlayers,
1093                                                                             opj_event_mgr_t * p_manager);
1094
1095 /**
1096  * Gets the number of tile parts used for the given change of progression (if any) and the given tile.
1097  *
1098  * @param               cp                      the coding parameters.
1099  * @param               pino            the offset of the given poc (i.e. its position in the coding parameter).
1100  * @param               tileno          the given tile.
1101  *
1102  * @return              the number of tile parts.
1103  */
1104 static OPJ_UINT32 opj_j2k_get_num_tp( opj_cp_t *cp, OPJ_UINT32 pino, OPJ_UINT32 tileno);
1105
1106 /**
1107  * Calculates the total number of tile parts needed by the encoder to
1108  * encode such an image. If not enough memory is available, then the function return false.
1109  *
1110  * @param       p_nb_tiles      pointer that will hold the number of tile parts.
1111  * @param       cp                      the coding parameters for the image.
1112  * @param       image           the image to encode.
1113  * @param       p_j2k                   the p_j2k encoder.
1114  * @param       p_manager       the user event manager.
1115  *
1116  * @return true if the function was successful, false else.
1117  */
1118 static OPJ_BOOL opj_j2k_calculate_tp(   opj_j2k_t *p_j2k,
1119                                                                             opj_cp_t *cp,
1120                                                                             OPJ_UINT32 * p_nb_tiles,
1121                                                                             opj_image_t *image,
1122                                                                             opj_event_mgr_t * p_manager);
1123
1124 static void opj_j2k_dump_MH_info(opj_j2k_t* p_j2k, FILE* out_stream);
1125
1126 static void opj_j2k_dump_MH_index(opj_j2k_t* p_j2k, FILE* out_stream);
1127
1128 static opj_codestream_index_t* opj_j2k_create_cstr_index(void);
1129
1130 static OPJ_FLOAT32 opj_j2k_get_tp_stride (opj_tcp_t * p_tcp);
1131
1132 static OPJ_FLOAT32 opj_j2k_get_default_stride (opj_tcp_t * p_tcp);
1133
1134 /*@}*/
1135
1136 /*@}*/
1137
1138 /* ----------------------------------------------------------------------- */
1139 typedef struct j2k_prog_order{
1140         OPJ_PROG_ORDER enum_prog;
1141         char str_prog[5];
1142 }j2k_prog_order_t;
1143
1144 j2k_prog_order_t j2k_prog_order_list[] = {
1145         {OPJ_CPRL, "CPRL"},
1146         {OPJ_LRCP, "LRCP"},
1147         {OPJ_PCRL, "PCRL"},
1148         {OPJ_RLCP, "RLCP"},
1149         {OPJ_RPCL, "RPCL"},
1150         {(OPJ_PROG_ORDER)-1, ""}
1151 };
1152
1153 /**
1154  * FIXME DOC
1155  */
1156 static const OPJ_UINT32 MCT_ELEMENT_SIZE [] =
1157 {
1158         2,
1159         4,
1160         4,
1161         8
1162 };
1163
1164 typedef void (* opj_j2k_mct_function) (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
1165
1166 const opj_j2k_mct_function j2k_mct_read_functions_to_float [] =
1167 {
1168         opj_j2k_read_int16_to_float,
1169         opj_j2k_read_int32_to_float,
1170         opj_j2k_read_float32_to_float,
1171         opj_j2k_read_float64_to_float
1172 };
1173
1174 const opj_j2k_mct_function j2k_mct_read_functions_to_int32 [] =
1175 {
1176         opj_j2k_read_int16_to_int32,
1177         opj_j2k_read_int32_to_int32,
1178         opj_j2k_read_float32_to_int32,
1179         opj_j2k_read_float64_to_int32
1180 };
1181
1182 const opj_j2k_mct_function j2k_mct_write_functions_from_float [] =
1183 {
1184         opj_j2k_write_float_to_int16,
1185         opj_j2k_write_float_to_int32,
1186         opj_j2k_write_float_to_float,
1187         opj_j2k_write_float_to_float64
1188 };
1189
1190 typedef struct opj_dec_memory_marker_handler
1191 {
1192         /** marker value */
1193         OPJ_UINT32 id;
1194         /** value of the state when the marker can appear */
1195         OPJ_UINT32 states;
1196         /** action linked to the marker */
1197         OPJ_BOOL (*handler) (   opj_j2k_t *p_j2k,
1198                             OPJ_BYTE * p_header_data,
1199                             OPJ_UINT32 p_header_size,
1200                             opj_event_mgr_t * p_manager );
1201 }
1202 opj_dec_memory_marker_handler_t;
1203
1204 const opj_dec_memory_marker_handler_t j2k_memory_marker_handler_tab [] =
1205 {
1206   {J2K_MS_SOT, J2K_STATE_MH | J2K_STATE_TPHSOT, opj_j2k_read_sot},
1207   {J2K_MS_COD, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_cod},
1208   {J2K_MS_COC, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_coc},
1209   {J2K_MS_RGN, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_rgn},
1210   {J2K_MS_QCD, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_qcd},
1211   {J2K_MS_QCC, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_qcc},
1212   {J2K_MS_POC, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_poc},
1213   {J2K_MS_SIZ, J2K_STATE_MHSIZ, opj_j2k_read_siz},
1214   {J2K_MS_TLM, J2K_STATE_MH, opj_j2k_read_tlm},
1215   {J2K_MS_PLM, J2K_STATE_MH, opj_j2k_read_plm},
1216   {J2K_MS_PLT, J2K_STATE_TPH, opj_j2k_read_plt},
1217   {J2K_MS_PPM, J2K_STATE_MH, j2k_read_ppm_v3},
1218   {J2K_MS_PPT, J2K_STATE_TPH, opj_j2k_read_ppt},
1219   {J2K_MS_SOP, 0, 0},
1220   {J2K_MS_CRG, J2K_STATE_MH, opj_j2k_read_crg},
1221   {J2K_MS_COM, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_com},
1222   {J2K_MS_MCT, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_mct},
1223   {J2K_MS_CBD, J2K_STATE_MH , opj_j2k_read_cbd},
1224   {J2K_MS_MCC, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_mcc},
1225   {J2K_MS_MCO, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_mco},
1226 #ifdef USE_JPWL
1227 #ifdef TODO_MS /* remove these functions which are not commpatible with the v2 API */
1228   {J2K_MS_EPC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_epc},
1229   {J2K_MS_EPB, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_epb},
1230   {J2K_MS_ESD, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_esd},
1231   {J2K_MS_RED, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_red},
1232 #endif
1233 #endif /* USE_JPWL */
1234 #ifdef USE_JPSEC
1235   {J2K_MS_SEC, J2K_DEC_STATE_MH, j2k_read_sec},
1236   {J2K_MS_INSEC, 0, j2k_read_insec}
1237 #endif /* USE_JPSEC */
1238   {J2K_MS_UNK, J2K_STATE_MH | J2K_STATE_TPH, 0}/*opj_j2k_read_unk is directly used*/
1239 };
1240
1241 void  opj_j2k_read_int16_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
1242 {
1243         OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
1244         OPJ_FLOAT32 * l_dest_data = (OPJ_FLOAT32 *) p_dest_data;
1245         OPJ_UINT32 i;
1246         OPJ_UINT32 l_temp;
1247
1248         for (i=0;i<p_nb_elem;++i) {
1249                 opj_read_bytes(l_src_data,&l_temp,2);
1250
1251                 l_src_data+=sizeof(OPJ_INT16);
1252
1253                 *(l_dest_data++) = (OPJ_FLOAT32) l_temp;
1254         }
1255 }
1256
1257 void  opj_j2k_read_int32_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
1258 {
1259         OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
1260         OPJ_FLOAT32 * l_dest_data = (OPJ_FLOAT32 *) p_dest_data;
1261         OPJ_UINT32 i;
1262         OPJ_UINT32 l_temp;
1263
1264         for (i=0;i<p_nb_elem;++i) {
1265                 opj_read_bytes(l_src_data,&l_temp,4);
1266
1267                 l_src_data+=sizeof(OPJ_INT32);
1268
1269                 *(l_dest_data++) = (OPJ_FLOAT32) l_temp;
1270         }
1271 }
1272
1273 void  opj_j2k_read_float32_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
1274 {
1275         OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
1276         OPJ_FLOAT32 * l_dest_data = (OPJ_FLOAT32 *) p_dest_data;
1277         OPJ_UINT32 i;
1278         OPJ_FLOAT32 l_temp;
1279
1280         for (i=0;i<p_nb_elem;++i) {
1281                 opj_read_float(l_src_data,&l_temp);
1282
1283                 l_src_data+=sizeof(OPJ_FLOAT32);
1284
1285                 *(l_dest_data++) = l_temp;
1286         }
1287 }
1288
1289 void  opj_j2k_read_float64_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
1290 {
1291         OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
1292         OPJ_FLOAT32 * l_dest_data = (OPJ_FLOAT32 *) p_dest_data;
1293         OPJ_UINT32 i;
1294         OPJ_FLOAT64 l_temp;
1295
1296         for (i=0;i<p_nb_elem;++i) {
1297                 opj_read_double(l_src_data,&l_temp);
1298
1299                 l_src_data+=sizeof(OPJ_FLOAT64);
1300
1301                 *(l_dest_data++) = (OPJ_FLOAT32) l_temp;
1302         }
1303 }
1304
1305 void  opj_j2k_read_int16_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
1306 {
1307         OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
1308         OPJ_INT32 * l_dest_data = (OPJ_INT32 *) p_dest_data;
1309         OPJ_UINT32 i;
1310         OPJ_UINT32 l_temp;
1311
1312         for (i=0;i<p_nb_elem;++i) {
1313                 opj_read_bytes(l_src_data,&l_temp,2);
1314
1315                 l_src_data+=sizeof(OPJ_INT16);
1316
1317                 *(l_dest_data++) = (OPJ_INT32) l_temp;
1318         }
1319 }
1320
1321 void  opj_j2k_read_int32_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
1322 {
1323         OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
1324         OPJ_INT32 * l_dest_data = (OPJ_INT32 *) p_dest_data;
1325         OPJ_UINT32 i;
1326         OPJ_UINT32 l_temp;
1327
1328         for (i=0;i<p_nb_elem;++i) {
1329                 opj_read_bytes(l_src_data,&l_temp,4);
1330
1331                 l_src_data+=sizeof(OPJ_INT32);
1332
1333                 *(l_dest_data++) = (OPJ_INT32) l_temp;
1334         }
1335 }
1336
1337 void  opj_j2k_read_float32_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
1338 {
1339         OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
1340         OPJ_INT32 * l_dest_data = (OPJ_INT32 *) p_dest_data;
1341         OPJ_UINT32 i;
1342         OPJ_FLOAT32 l_temp;
1343
1344         for (i=0;i<p_nb_elem;++i) {
1345                 opj_read_float(l_src_data,&l_temp);
1346
1347                 l_src_data+=sizeof(OPJ_FLOAT32);
1348
1349                 *(l_dest_data++) = (OPJ_INT32) l_temp;
1350         }
1351 }
1352
1353 void  opj_j2k_read_float64_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
1354 {
1355         OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
1356         OPJ_INT32 * l_dest_data = (OPJ_INT32 *) p_dest_data;
1357         OPJ_UINT32 i;
1358         OPJ_FLOAT64 l_temp;
1359
1360         for (i=0;i<p_nb_elem;++i) {
1361                 opj_read_double(l_src_data,&l_temp);
1362
1363                 l_src_data+=sizeof(OPJ_FLOAT64);
1364
1365                 *(l_dest_data++) = (OPJ_INT32) l_temp;
1366         }
1367 }
1368
1369 void  opj_j2k_write_float_to_int16 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
1370 {
1371         OPJ_BYTE * l_dest_data = (OPJ_BYTE *) p_dest_data;
1372         OPJ_FLOAT32 * l_src_data = (OPJ_FLOAT32 *) p_src_data;
1373         OPJ_UINT32 i;
1374         OPJ_UINT32 l_temp;
1375
1376         for (i=0;i<p_nb_elem;++i) {
1377                 l_temp = (OPJ_UINT32) *(l_src_data++);
1378
1379                 opj_write_bytes(l_dest_data,l_temp,sizeof(OPJ_INT16));
1380
1381                 l_dest_data+=sizeof(OPJ_INT16);
1382         }
1383 }
1384
1385 void opj_j2k_write_float_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
1386 {
1387         OPJ_BYTE * l_dest_data = (OPJ_BYTE *) p_dest_data;
1388         OPJ_FLOAT32 * l_src_data = (OPJ_FLOAT32 *) p_src_data;
1389         OPJ_UINT32 i;
1390         OPJ_UINT32 l_temp;
1391
1392         for (i=0;i<p_nb_elem;++i) {
1393                 l_temp = (OPJ_UINT32) *(l_src_data++);
1394
1395                 opj_write_bytes(l_dest_data,l_temp,sizeof(OPJ_INT32));
1396
1397                 l_dest_data+=sizeof(OPJ_INT32);
1398         }
1399 }
1400
1401 void  opj_j2k_write_float_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
1402 {
1403         OPJ_BYTE * l_dest_data = (OPJ_BYTE *) p_dest_data;
1404         OPJ_FLOAT32 * l_src_data = (OPJ_FLOAT32 *) p_src_data;
1405         OPJ_UINT32 i;
1406         OPJ_FLOAT32 l_temp;
1407
1408         for (i=0;i<p_nb_elem;++i) {
1409                 l_temp = (OPJ_FLOAT32) *(l_src_data++);
1410
1411                 opj_write_float(l_dest_data,l_temp);
1412
1413                 l_dest_data+=sizeof(OPJ_FLOAT32);
1414         }
1415 }
1416
1417 void  opj_j2k_write_float_to_float64 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
1418 {
1419         OPJ_BYTE * l_dest_data = (OPJ_BYTE *) p_dest_data;
1420         OPJ_FLOAT32 * l_src_data = (OPJ_FLOAT32 *) p_src_data;
1421         OPJ_UINT32 i;
1422         OPJ_FLOAT64 l_temp;
1423
1424         for (i=0;i<p_nb_elem;++i) {
1425                 l_temp = (OPJ_FLOAT64) *(l_src_data++);
1426
1427                 opj_write_double(l_dest_data,l_temp);
1428
1429                 l_dest_data+=sizeof(OPJ_FLOAT64);
1430         }
1431 }
1432
1433 char *opj_j2k_convert_progression_order(OPJ_PROG_ORDER prg_order){
1434         j2k_prog_order_t *po;
1435         for(po = j2k_prog_order_list; po->enum_prog != -1; po++ ){
1436                 if(po->enum_prog == prg_order){
1437                         return po->str_prog;
1438                 }
1439         }
1440         return po->str_prog;
1441 }
1442
1443 OPJ_BOOL opj_j2k_check_poc_val( const opj_poc_t *p_pocs,
1444                                                         OPJ_UINT32 p_nb_pocs,
1445                                                         OPJ_UINT32 p_nb_resolutions,
1446                                                         OPJ_UINT32 p_num_comps,
1447                                                         OPJ_UINT32 p_num_layers,
1448                                                         opj_event_mgr_t * p_manager)
1449 {
1450         OPJ_UINT32* packet_array;
1451         OPJ_UINT32 index , resno, compno, layno;
1452         OPJ_UINT32 i;
1453         OPJ_UINT32 step_c = 1;
1454         OPJ_UINT32 step_r = p_num_comps * step_c;
1455         OPJ_UINT32 step_l = p_nb_resolutions * step_r;
1456         OPJ_BOOL loss = OPJ_FALSE;
1457         OPJ_UINT32 layno0 = 0;
1458
1459         packet_array = (OPJ_UINT32*) opj_calloc(step_l * p_num_layers, sizeof(OPJ_UINT32));
1460         if (packet_array == 00) {
1461                 opj_event_msg(p_manager , EVT_ERROR, "Not enough memory for checking the poc values.\n");
1462                 return OPJ_FALSE;
1463         }
1464         memset(packet_array,0,step_l * p_num_layers* sizeof(OPJ_UINT32));
1465
1466         if (p_nb_pocs == 0) {
1467                 return OPJ_TRUE;
1468         }
1469
1470         index = step_r * p_pocs->resno0;
1471         /* take each resolution for each poc */
1472         for (resno = p_pocs->resno0 ; resno < p_pocs->resno1 ; ++resno)
1473         {
1474                 OPJ_UINT32 res_index = index + p_pocs->compno0 * step_c;
1475
1476                 /* take each comp of each resolution for each poc */
1477                 for (compno = p_pocs->compno0 ; compno < p_pocs->compno1 ; ++compno) {
1478                         OPJ_UINT32 comp_index = res_index + layno0 * step_l;
1479
1480                         /* and finally take each layer of each res of ... */
1481                         for (layno = layno0; layno < p_pocs->layno1 ; ++layno) {
1482                                 /*index = step_r * resno + step_c * compno + step_l * layno;*/
1483                                 packet_array[comp_index] = 1;
1484                                 comp_index += step_l;
1485                         }
1486
1487                         res_index += step_c;
1488                 }
1489
1490                 index += step_r;
1491         }
1492         ++p_pocs;
1493
1494         /* iterate through all the pocs */
1495         for (i = 1; i < p_nb_pocs ; ++i) {
1496                 OPJ_UINT32 l_last_layno1 = (p_pocs-1)->layno1 ;
1497
1498                 layno0 = (p_pocs->layno1 > l_last_layno1)? l_last_layno1 : 0;
1499                 index = step_r * p_pocs->resno0;
1500
1501                 /* take each resolution for each poc */
1502                 for (resno = p_pocs->resno0 ; resno < p_pocs->resno1 ; ++resno) {
1503                         OPJ_UINT32 res_index = index + p_pocs->compno0 * step_c;
1504
1505                         /* take each comp of each resolution for each poc */
1506                         for (compno = p_pocs->compno0 ; compno < p_pocs->compno1 ; ++compno) {
1507                                 OPJ_UINT32 comp_index = res_index + layno0 * step_l;
1508
1509                                 /* and finally take each layer of each res of ... */
1510                                 for (layno = layno0; layno < p_pocs->layno1 ; ++layno) {
1511                                         /*index = step_r * resno + step_c * compno + step_l * layno;*/
1512                                         packet_array[comp_index] = 1;
1513                                         comp_index += step_l;
1514                                 }
1515
1516                                 res_index += step_c;
1517                         }
1518
1519                         index += step_r;
1520                 }
1521
1522                 ++p_pocs;
1523         }
1524
1525         index = 0;
1526         for (layno = 0; layno < p_num_layers ; ++layno) {
1527                 for (resno = 0; resno < p_nb_resolutions; ++resno) {
1528                         for (compno = 0; compno < p_num_comps; ++compno) {
1529                                 loss |= (packet_array[index]!=1);
1530                                 /*index = step_r * resno + step_c * compno + step_l * layno;*/
1531                                 index += step_c;
1532                         }
1533                 }
1534         }
1535
1536         if (loss) {
1537                 opj_event_msg(p_manager , EVT_ERROR, "Missing packets possible loss of data\n");
1538         }
1539
1540         opj_free(packet_array);
1541
1542         return !loss;
1543 }
1544
1545 /* ----------------------------------------------------------------------- */
1546
1547 OPJ_UINT32 opj_j2k_get_num_tp(opj_cp_t *cp, OPJ_UINT32 pino, OPJ_UINT32 tileno)
1548 {
1549         const OPJ_CHAR *prog = 00;
1550         OPJ_UINT32 i;
1551         OPJ_UINT32 tpnum = 1;
1552         opj_tcp_t *tcp = 00;
1553         opj_poc_t * l_current_poc = 00;
1554
1555         /*  preconditions */
1556         assert(tileno < (cp->tw * cp->th));
1557         assert(pino < (cp->tcps[tileno].numpocs + 1));
1558
1559         /* get the given tile coding parameter */
1560         tcp = &cp->tcps[tileno];
1561         assert(tcp != 00);
1562
1563         l_current_poc = &(tcp->pocs[pino]);
1564         assert(l_current_poc != 0);
1565
1566         /* get the progression order as a character string */
1567         prog = opj_j2k_convert_progression_order(tcp->prg);
1568         assert(strlen(prog) > 0);
1569
1570         if (cp->m_specific_param.m_enc.m_tp_on == 1) {
1571                 for (i=0;i<4;++i) {
1572                         switch (prog[i])
1573                         {
1574                                 /* component wise */
1575                                 case 'C':
1576                                         tpnum *= l_current_poc->compE;
1577                                         break;
1578                                 /* resolution wise */
1579                                 case 'R':
1580                                         tpnum *= l_current_poc->resE;
1581                                         break;
1582                                 /* precinct wise */
1583                                 case 'P':
1584                                         tpnum *= l_current_poc->prcE;
1585                                         break;
1586                                 /* layer wise */
1587                                 case 'L':
1588                                         tpnum *= l_current_poc->layE;
1589                                         break;
1590                         }
1591                         /* whould we split here ? */
1592                         if ( cp->m_specific_param.m_enc.m_tp_flag == prog[i] ) {
1593                                 cp->m_specific_param.m_enc.m_tp_pos=i;
1594                                 break;
1595                         }
1596                 }
1597         }
1598         else {
1599                 tpnum=1;
1600         }
1601
1602         return tpnum;
1603 }
1604
1605 OPJ_BOOL opj_j2k_calculate_tp(  opj_j2k_t *p_j2k,
1606                                                         opj_cp_t *cp,
1607                                                         OPJ_UINT32 * p_nb_tiles,
1608                                                         opj_image_t *image,
1609                                                         opj_event_mgr_t * p_manager
1610                                 )
1611 {
1612         OPJ_UINT32 pino,tileno;
1613         OPJ_UINT32 l_nb_tiles;
1614         opj_tcp_t *tcp;
1615
1616         /* preconditions */
1617         assert(p_nb_tiles != 00);
1618         assert(cp != 00);
1619         assert(image != 00);
1620         assert(p_j2k != 00);
1621         assert(p_manager != 00);
1622
1623         l_nb_tiles = cp->tw * cp->th;
1624         * p_nb_tiles = 0;
1625         tcp = cp->tcps;
1626
1627         /* INDEX >> */
1628         /* TODO mergeV2: check this part which use cstr_info */
1629         /*if (p_j2k->cstr_info) {
1630                 opj_tile_info_t * l_info_tile_ptr = p_j2k->cstr_info->tile;
1631
1632                 for (tileno = 0; tileno < l_nb_tiles; ++tileno) {
1633                         OPJ_UINT32 cur_totnum_tp = 0;
1634
1635                         opj_pi_update_encoding_parameters(image,cp,tileno);
1636
1637                         for (pino = 0; pino <= tcp->numpocs; ++pino)
1638                         {
1639                                 OPJ_UINT32 tp_num = opj_j2k_get_num_tp(cp,pino,tileno);
1640
1641                                 *p_nb_tiles = *p_nb_tiles + tp_num;
1642
1643                                 cur_totnum_tp += tp_num;
1644                         }
1645
1646                         tcp->m_nb_tile_parts = cur_totnum_tp;
1647
1648                         l_info_tile_ptr->tp = (opj_tp_info_t *) opj_malloc(cur_totnum_tp * sizeof(opj_tp_info_t));
1649                         if (l_info_tile_ptr->tp == 00) {
1650                                 return OPJ_FALSE;
1651                         }
1652
1653                         memset(l_info_tile_ptr->tp,0,cur_totnum_tp * sizeof(opj_tp_info_t));
1654
1655                         l_info_tile_ptr->num_tps = cur_totnum_tp;
1656
1657                         ++l_info_tile_ptr;
1658                         ++tcp;
1659                 }
1660         }
1661         else */{
1662                 for (tileno = 0; tileno < l_nb_tiles; ++tileno) {
1663                         OPJ_UINT32 cur_totnum_tp = 0;
1664
1665                         opj_pi_update_encoding_parameters(image,cp,tileno);
1666
1667                         for (pino = 0; pino <= tcp->numpocs; ++pino) {
1668                                 OPJ_UINT32 tp_num = opj_j2k_get_num_tp(cp,pino,tileno);
1669
1670                                 *p_nb_tiles = *p_nb_tiles + tp_num;
1671
1672                                 cur_totnum_tp += tp_num;
1673                         }
1674                         tcp->m_nb_tile_parts = cur_totnum_tp;
1675
1676                         ++tcp;
1677                 }
1678         }
1679
1680         return OPJ_TRUE;
1681 }
1682
1683 OPJ_BOOL opj_j2k_write_soc(     opj_j2k_t *p_j2k,
1684                                                 opj_stream_private_t *p_stream,
1685                                                     opj_event_mgr_t * p_manager )
1686 {
1687         /* 2 bytes will be written */
1688         OPJ_BYTE * l_start_stream = 00;
1689
1690         /* preconditions */
1691         assert(p_stream != 00);
1692         assert(p_j2k != 00);
1693         assert(p_manager != 00);
1694
1695         l_start_stream = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
1696
1697         /* write SOC identifier */
1698         opj_write_bytes(l_start_stream,J2K_MS_SOC,2);
1699
1700         if (opj_stream_write_data(p_stream,l_start_stream,2,p_manager) != 2) {
1701                 return OPJ_FALSE;
1702         }
1703
1704 /* UniPG>> */
1705 #ifdef USE_JPWL
1706         /* update markers struct */
1707 /*
1708         OPJ_BOOL res = j2k_add_marker(p_j2k->cstr_info, J2K_MS_SOC, p_stream_tell(p_stream) - 2, 2);
1709 */
1710   assert( 0 && "TODO" );
1711 #endif /* USE_JPWL */
1712 /* <<UniPG */
1713
1714         return OPJ_TRUE;
1715 }
1716
1717 /**
1718  * Reads a SOC marker (Start of Codestream)
1719  * @param       p_j2k           the jpeg2000 file codec.
1720  * @param       p_stream        FIXME DOC
1721  * @param       p_manager       the user event manager.
1722 */
1723 static OPJ_BOOL opj_j2k_read_soc(   opj_j2k_t *p_j2k,
1724                                     opj_stream_private_t *p_stream,
1725                                     opj_event_mgr_t * p_manager
1726                                     )
1727 {
1728         OPJ_BYTE l_data [2];
1729         OPJ_UINT32 l_marker;
1730
1731         /* preconditions */
1732         assert(p_j2k != 00);
1733         assert(p_manager != 00);
1734         assert(p_stream != 00);
1735
1736         if (opj_stream_read_data(p_stream,l_data,2,p_manager) != 2) {
1737                 return OPJ_FALSE;
1738         }
1739
1740         opj_read_bytes(l_data,&l_marker,2);
1741         if (l_marker != J2K_MS_SOC) {
1742                 return OPJ_FALSE;
1743         }
1744
1745         /* Next marker should be a SIZ marker in the main header */
1746         p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_MHSIZ;
1747
1748         /* FIXME move it in a index structure included in p_j2k*/
1749         p_j2k->cstr_index->main_head_start = opj_stream_tell(p_stream) - 2;
1750
1751         opj_event_msg(p_manager, EVT_INFO, "Start to read j2k main header (%d).\n", p_j2k->cstr_index->main_head_start);
1752
1753         /* Add the marker to the codestream index*/
1754         if (OPJ_FALSE == opj_j2k_add_mhmarker(p_j2k->cstr_index, J2K_MS_SOC, p_j2k->cstr_index->main_head_start, 2)) {
1755                 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to add mh marker\n");
1756                 return OPJ_FALSE;
1757         }
1758         return OPJ_TRUE;
1759 }
1760
1761 OPJ_BOOL opj_j2k_write_siz(     opj_j2k_t *p_j2k,
1762                                                         opj_stream_private_t *p_stream,
1763                                                         opj_event_mgr_t * p_manager )
1764 {
1765         OPJ_UINT32 i;
1766         OPJ_UINT32 l_size_len;
1767         OPJ_BYTE * l_current_ptr;
1768         opj_image_t * l_image = 00;
1769         opj_cp_t *cp = 00;
1770         opj_image_comp_t * l_img_comp = 00;
1771
1772         /* preconditions */
1773         assert(p_stream != 00);
1774         assert(p_j2k != 00);
1775         assert(p_manager != 00);
1776
1777         l_image = p_j2k->m_private_image;
1778         cp = &(p_j2k->m_cp);
1779         l_size_len = 40 + 3 * l_image->numcomps;
1780         l_img_comp = l_image->comps;
1781
1782         if (l_size_len > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) {
1783
1784                 OPJ_BYTE *new_header_tile_data = (OPJ_BYTE *) opj_realloc(p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_size_len);
1785                 if (! new_header_tile_data) {
1786                         opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
1787                         p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL;
1788                         p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
1789                         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory for the SIZ marker\n");
1790                         return OPJ_FALSE;
1791                 }
1792                 p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data;
1793                 p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_size_len;
1794         }
1795
1796         l_current_ptr = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
1797
1798         /* write SOC identifier */
1799         opj_write_bytes(l_current_ptr,J2K_MS_SIZ,2);    /* SIZ */
1800         l_current_ptr+=2;
1801
1802         opj_write_bytes(l_current_ptr,l_size_len-2,2); /* L_SIZ */
1803         l_current_ptr+=2;
1804
1805         opj_write_bytes(l_current_ptr, cp->rsiz, 2);    /* Rsiz (capabilities) */
1806         l_current_ptr+=2;
1807
1808         opj_write_bytes(l_current_ptr, l_image->x1, 4); /* Xsiz */
1809         l_current_ptr+=4;
1810
1811         opj_write_bytes(l_current_ptr, l_image->y1, 4); /* Ysiz */
1812         l_current_ptr+=4;
1813
1814         opj_write_bytes(l_current_ptr, l_image->x0, 4); /* X0siz */
1815         l_current_ptr+=4;
1816
1817         opj_write_bytes(l_current_ptr, l_image->y0, 4); /* Y0siz */
1818         l_current_ptr+=4;
1819
1820         opj_write_bytes(l_current_ptr, cp->tdx, 4);             /* XTsiz */
1821         l_current_ptr+=4;
1822
1823         opj_write_bytes(l_current_ptr, cp->tdy, 4);             /* YTsiz */
1824         l_current_ptr+=4;
1825
1826         opj_write_bytes(l_current_ptr, cp->tx0, 4);             /* XT0siz */
1827         l_current_ptr+=4;
1828
1829         opj_write_bytes(l_current_ptr, cp->ty0, 4);             /* YT0siz */
1830         l_current_ptr+=4;
1831
1832         opj_write_bytes(l_current_ptr, l_image->numcomps, 2);   /* Csiz */
1833         l_current_ptr+=2;
1834
1835         for (i = 0; i < l_image->numcomps; ++i) {
1836                 /* TODO here with MCT ? */
1837                 opj_write_bytes(l_current_ptr, l_img_comp->prec - 1 + (l_img_comp->sgnd << 7), 1);      /* Ssiz_i */
1838                 ++l_current_ptr;
1839
1840                 opj_write_bytes(l_current_ptr, l_img_comp->dx, 1);      /* XRsiz_i */
1841                 ++l_current_ptr;
1842
1843                 opj_write_bytes(l_current_ptr, l_img_comp->dy, 1);      /* YRsiz_i */
1844                 ++l_current_ptr;
1845
1846                 ++l_img_comp;
1847         }
1848
1849         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) {
1850                 return OPJ_FALSE;
1851         }
1852
1853         return OPJ_TRUE;
1854 }
1855
1856 /**
1857  * Reads a SIZ marker (image and tile size)
1858  * @param       p_j2k           the jpeg2000 file codec.
1859  * @param       p_header_data   the data contained in the SIZ box.
1860  * @param       p_header_size   the size of the data contained in the SIZ marker.
1861  * @param       p_manager       the user event manager.
1862 */
1863 static OPJ_BOOL opj_j2k_read_siz(opj_j2k_t *p_j2k,
1864                                  OPJ_BYTE * p_header_data,
1865                                  OPJ_UINT32 p_header_size,
1866                                  opj_event_mgr_t * p_manager
1867                                  )
1868 {
1869         OPJ_UINT32 i;
1870         OPJ_UINT32 l_nb_comp;
1871         OPJ_UINT32 l_nb_comp_remain;
1872         OPJ_UINT32 l_remaining_size;
1873         OPJ_UINT32 l_nb_tiles;
1874         OPJ_UINT32 l_tmp;
1875         opj_image_t *l_image = 00;
1876         opj_cp_t *l_cp = 00;
1877         opj_image_comp_t * l_img_comp = 00;
1878         opj_tcp_t * l_current_tile_param = 00;
1879
1880         /* preconditions */
1881         assert(p_j2k != 00);
1882         assert(p_manager != 00);
1883         assert(p_header_data != 00);
1884
1885         l_image = p_j2k->m_private_image;
1886         l_cp = &(p_j2k->m_cp);
1887
1888         /* minimum size == 39 - 3 (= minimum component parameter) */
1889         if (p_header_size < 36) {
1890                 opj_event_msg(p_manager, EVT_ERROR, "Error with SIZ marker size\n");
1891                 return OPJ_FALSE;
1892         }
1893
1894         l_remaining_size = p_header_size - 36;
1895         l_nb_comp = l_remaining_size / 3;
1896         l_nb_comp_remain = l_remaining_size % 3;
1897         if (l_nb_comp_remain != 0){
1898                 opj_event_msg(p_manager, EVT_ERROR, "Error with SIZ marker size\n");
1899                 return OPJ_FALSE;
1900         }
1901
1902         opj_read_bytes(p_header_data,&l_tmp ,2);                                                /* Rsiz (capabilities) */
1903         p_header_data+=2;
1904         l_cp->rsiz = (OPJ_RSIZ_CAPABILITIES) l_tmp;
1905         opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_image->x1, 4);   /* Xsiz */
1906         p_header_data+=4;
1907         opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_image->y1, 4);   /* Ysiz */
1908         p_header_data+=4;
1909         opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_image->x0, 4);   /* X0siz */
1910         p_header_data+=4;
1911         opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_image->y0, 4);   /* Y0siz */
1912         p_header_data+=4;
1913         opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_cp->tdx, 4);             /* XTsiz */
1914         p_header_data+=4;
1915         opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_cp->tdy, 4);             /* YTsiz */
1916         p_header_data+=4;
1917         opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_cp->tx0, 4);             /* XT0siz */
1918         p_header_data+=4;
1919         opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_cp->ty0, 4);             /* YT0siz */
1920         p_header_data+=4;
1921         opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_tmp, 2);                 /* Csiz */
1922         p_header_data+=2;
1923         if (l_tmp < 16385)
1924                 l_image->numcomps = (OPJ_UINT16) l_tmp;
1925         else {
1926                 opj_event_msg(p_manager, EVT_ERROR, "Error with SIZ marker: number of component is illegal -> %d\n", l_tmp);
1927                 return OPJ_FALSE;
1928         }
1929
1930         if (l_image->numcomps != l_nb_comp) {
1931                 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);
1932                 return OPJ_FALSE;
1933         }
1934
1935 #ifdef USE_JPWL
1936         if (l_cp->correct) {
1937                 /* if JPWL is on, we check whether TX errors have damaged
1938                   too much the SIZ parameters */
1939                 if (!(l_image->x1 * l_image->y1)) {
1940                         opj_event_msg(p_manager, EVT_ERROR,
1941                                 "JPWL: bad image size (%d x %d)\n",
1942                                 l_image->x1, l_image->y1);
1943                         if (!JPWL_ASSUME || JPWL_ASSUME) {
1944                                 opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n");
1945                                 return OPJ_FALSE;
1946                         }
1947                 }
1948
1949         /* FIXME check previously in the function so why keep this piece of code ? Need by the norm ?
1950                 if (l_image->numcomps != ((len - 38) / 3)) {
1951                         opj_event_msg(p_manager, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
1952                                 "JPWL: Csiz is %d => space in SIZ only for %d comps.!!!\n",
1953                                 l_image->numcomps, ((len - 38) / 3));
1954                         if (!JPWL_ASSUME) {
1955                                 opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n");
1956                                 return OPJ_FALSE;
1957                         }
1958         */              /* we try to correct */
1959         /*              opj_event_msg(p_manager, EVT_WARNING, "- trying to adjust this\n");
1960                         if (l_image->numcomps < ((len - 38) / 3)) {
1961                                 len = 38 + 3 * l_image->numcomps;
1962                                 opj_event_msg(p_manager, EVT_WARNING, "- setting Lsiz to %d => HYPOTHESIS!!!\n",
1963                                         len);
1964                         } else {
1965                                 l_image->numcomps = ((len - 38) / 3);
1966                                 opj_event_msg(p_manager, EVT_WARNING, "- setting Csiz to %d => HYPOTHESIS!!!\n",
1967                                         l_image->numcomps);
1968                         }
1969                 }
1970         */
1971
1972                 /* update components number in the jpwl_exp_comps filed */
1973                 l_cp->exp_comps = l_image->numcomps;
1974         }
1975 #endif /* USE_JPWL */
1976
1977         /* Allocate the resulting image components */
1978         l_image->comps = (opj_image_comp_t*) opj_calloc(l_image->numcomps, sizeof(opj_image_comp_t));
1979         if (l_image->comps == 00){
1980                 l_image->numcomps = 0;
1981                 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n");
1982                 return OPJ_FALSE;
1983         }
1984
1985         memset(l_image->comps,0,l_image->numcomps * sizeof(opj_image_comp_t));
1986         l_img_comp = l_image->comps;
1987
1988         /* Read the component information */
1989         for (i = 0; i < l_image->numcomps; ++i){
1990                 OPJ_UINT32 tmp;
1991                 opj_read_bytes(p_header_data,&tmp,1);   /* Ssiz_i */
1992                 ++p_header_data;
1993                 l_img_comp->prec = (tmp & 0x7f) + 1;
1994                 l_img_comp->sgnd = tmp >> 7;
1995                 opj_read_bytes(p_header_data,&tmp,1);   /* XRsiz_i */
1996                 ++p_header_data;
1997                 l_img_comp->dx = (OPJ_INT32)tmp; /* should be between 1 and 255 */
1998                 opj_read_bytes(p_header_data,&tmp,1);   /* YRsiz_i */
1999                 ++p_header_data;
2000                 l_img_comp->dy = (OPJ_INT32)tmp; /* should be between 1 and 255 */
2001                 if( l_img_comp->dx < 1 || l_img_comp->dx > 255 ||
2002                     l_img_comp->dy < 1 || l_img_comp->dy > 255 ) {
2003                     opj_event_msg(p_manager, EVT_ERROR,
2004                                   "Invalid values for comp = %d : dx=%u dy=%u\n (should be between 1 and 255 according the JPEG2000 norm)",
2005                                   i, l_img_comp->dx, l_img_comp->dy);
2006                     return OPJ_FALSE;
2007                 }
2008
2009 #ifdef USE_JPWL
2010                 if (l_cp->correct) {
2011                 /* if JPWL is on, we check whether TX errors have damaged
2012                         too much the SIZ parameters, again */
2013                         if (!(l_image->comps[i].dx * l_image->comps[i].dy)) {
2014                                 opj_event_msg(p_manager, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
2015                                         "JPWL: bad XRsiz_%d/YRsiz_%d (%d x %d)\n",
2016                                         i, i, l_image->comps[i].dx, l_image->comps[i].dy);
2017                                 if (!JPWL_ASSUME) {
2018                                         opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n");
2019                                         return OPJ_FALSE;
2020                                 }
2021                                 /* we try to correct */
2022                                 opj_event_msg(p_manager, EVT_WARNING, "- trying to adjust them\n");
2023                                 if (!l_image->comps[i].dx) {
2024                                         l_image->comps[i].dx = 1;
2025                                         opj_event_msg(p_manager, EVT_WARNING, "- setting XRsiz_%d to %d => HYPOTHESIS!!!\n",
2026                                                 i, l_image->comps[i].dx);
2027                                 }
2028                                 if (!l_image->comps[i].dy) {
2029                                         l_image->comps[i].dy = 1;
2030                                         opj_event_msg(p_manager, EVT_WARNING, "- setting YRsiz_%d to %d => HYPOTHESIS!!!\n",
2031                                                 i, l_image->comps[i].dy);
2032                                 }
2033                         }
2034                 }
2035 #endif /* USE_JPWL */
2036                 l_img_comp->resno_decoded = 0;                                                          /* number of resolution decoded */
2037                 l_img_comp->factor = l_cp->m_specific_param.m_dec.m_reduce; /* reducing factor per component */
2038                 ++l_img_comp;
2039         }
2040
2041         /* Compute the number of tiles */
2042         l_cp->tw = opj_int_ceildiv(l_image->x1 - l_cp->tx0, l_cp->tdx);
2043         l_cp->th = opj_int_ceildiv(l_image->y1 - l_cp->ty0, l_cp->tdy);
2044
2045         /* Check that the number of tiles is valid */
2046         if (l_cp->tw == 0 || l_cp->th == 0 || l_cp->tw > 65535 / l_cp->th) {
2047             opj_event_msg(  p_manager, EVT_ERROR,
2048                             "Invalid number of tiles : %u x %u (maximum fixed by jpeg2000 norm is 65535 tiles)\n",
2049                             l_cp->tw, l_cp->th);
2050             return OPJ_FALSE;
2051         }
2052         l_nb_tiles = l_cp->tw * l_cp->th;
2053
2054         /* Define the tiles which will be decoded */
2055         if (p_j2k->m_specific_param.m_decoder.m_discard_tiles) {
2056                 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;
2057                 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;
2058                 p_j2k->m_specific_param.m_decoder.m_end_tile_x = opj_int_ceildiv((p_j2k->m_specific_param.m_decoder.m_end_tile_x - l_cp->tx0), l_cp->tdx);
2059                 p_j2k->m_specific_param.m_decoder.m_end_tile_y = opj_int_ceildiv((p_j2k->m_specific_param.m_decoder.m_end_tile_y - l_cp->ty0), l_cp->tdy);
2060         }
2061         else {
2062                 p_j2k->m_specific_param.m_decoder.m_start_tile_x = 0;
2063                 p_j2k->m_specific_param.m_decoder.m_start_tile_y = 0;
2064                 p_j2k->m_specific_param.m_decoder.m_end_tile_x = l_cp->tw;
2065                 p_j2k->m_specific_param.m_decoder.m_end_tile_y = l_cp->th;
2066         }
2067
2068 #ifdef USE_JPWL
2069         if (l_cp->correct) {
2070                 /* if JPWL is on, we check whether TX errors have damaged
2071                   too much the SIZ parameters */
2072                 if ((l_cp->tw < 1) || (l_cp->th < 1) || (l_cp->tw > l_cp->max_tiles) || (l_cp->th > l_cp->max_tiles)) {
2073                         opj_event_msg(p_manager, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
2074                                 "JPWL: bad number of tiles (%d x %d)\n",
2075                                 l_cp->tw, l_cp->th);
2076                         if (!JPWL_ASSUME) {
2077                                 opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n");
2078                                 return OPJ_FALSE;
2079                         }
2080                         /* we try to correct */
2081                         opj_event_msg(p_manager, EVT_WARNING, "- trying to adjust them\n");
2082                         if (l_cp->tw < 1) {
2083                                 l_cp->tw= 1;
2084                                 opj_event_msg(p_manager, EVT_WARNING, "- setting %d tiles in x => HYPOTHESIS!!!\n",
2085                                                 l_cp->tw);
2086                         }
2087                         if (l_cp->tw > l_cp->max_tiles) {
2088                                 l_cp->tw= 1;
2089                                 opj_event_msg(p_manager, EVT_WARNING, "- too large x, increase expectance of %d\n"
2090                                         "- setting %d tiles in x => HYPOTHESIS!!!\n",
2091                                         l_cp->max_tiles, l_cp->tw);
2092                         }
2093                         if (l_cp->th < 1) {
2094                                 l_cp->th= 1;
2095                                 opj_event_msg(p_manager, EVT_WARNING, "- setting %d tiles in y => HYPOTHESIS!!!\n",
2096                                                 l_cp->th);
2097                         }
2098                         if (l_cp->th > l_cp->max_tiles) {
2099                                 l_cp->th= 1;
2100                                 opj_event_msg(p_manager, EVT_WARNING, "- too large y, increase expectance of %d to continue\n",
2101                                         "- setting %d tiles in y => HYPOTHESIS!!!\n",
2102                                         l_cp->max_tiles, l_cp->th);
2103                         }
2104                 }
2105         }
2106 #endif /* USE_JPWL */
2107
2108         /* memory allocations */
2109         l_cp->tcps = (opj_tcp_t*) opj_calloc(l_nb_tiles, sizeof(opj_tcp_t));
2110         if (l_cp->tcps == 00) {
2111                 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n");
2112                 return OPJ_FALSE;
2113         }
2114         memset(l_cp->tcps,0,l_nb_tiles*sizeof(opj_tcp_t));
2115
2116 #ifdef USE_JPWL
2117         if (l_cp->correct) {
2118                 if (!l_cp->tcps) {
2119                         opj_event_msg(p_manager, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
2120                                 "JPWL: could not alloc tcps field of cp\n");
2121                         if (!JPWL_ASSUME || JPWL_ASSUME) {
2122                                 opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n");
2123                                 return OPJ_FALSE;
2124                         }
2125                 }
2126         }
2127 #endif /* USE_JPWL */
2128
2129         p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps =
2130                         (opj_tccp_t*) opj_calloc(l_image->numcomps, sizeof(opj_tccp_t));
2131         if(p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps  == 00) {
2132                 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n");
2133                 return OPJ_FALSE;
2134         }
2135         memset(p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps ,0,l_image->numcomps*sizeof(opj_tccp_t));
2136
2137         p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mct_records =
2138                         (opj_mct_data_t*)opj_malloc(OPJ_J2K_MCT_DEFAULT_NB_RECORDS * sizeof(opj_mct_data_t));
2139
2140         if (! p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mct_records) {
2141                 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n");
2142                 return OPJ_FALSE;
2143         }
2144         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));
2145         p_j2k->m_specific_param.m_decoder.m_default_tcp->m_nb_max_mct_records = OPJ_J2K_MCT_DEFAULT_NB_RECORDS;
2146
2147         p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mcc_records =
2148                         (opj_simple_mcc_decorrelation_data_t*)
2149                         opj_malloc(OPJ_J2K_MCC_DEFAULT_NB_RECORDS * sizeof(opj_simple_mcc_decorrelation_data_t));
2150
2151         if (! p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mcc_records) {
2152                 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n");
2153                 return OPJ_FALSE;
2154         }
2155         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));
2156         p_j2k->m_specific_param.m_decoder.m_default_tcp->m_nb_max_mcc_records = OPJ_J2K_MCC_DEFAULT_NB_RECORDS;
2157
2158         /* set up default dc level shift */
2159         for (i=0;i<l_image->numcomps;++i) {
2160                 if (! l_image->comps[i].sgnd) {
2161                         p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps[i].m_dc_level_shift = 1 << (l_image->comps[i].prec - 1);
2162                 }
2163         }
2164
2165         l_current_tile_param = l_cp->tcps;
2166         for     (i = 0; i < l_nb_tiles; ++i) {
2167                 l_current_tile_param->tccps = (opj_tccp_t*) opj_malloc(l_image->numcomps * sizeof(opj_tccp_t));
2168                 if (l_current_tile_param->tccps == 00) {
2169                         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n");
2170                         return OPJ_FALSE;
2171                 }
2172                 memset(l_current_tile_param->tccps,0,l_image->numcomps * sizeof(opj_tccp_t));
2173
2174                 ++l_current_tile_param;
2175         }
2176
2177         p_j2k->m_specific_param.m_decoder.m_state =  J2K_STATE_MH; /* FIXME J2K_DEC_STATE_MH; */
2178         opj_image_comp_header_update(l_image,l_cp);
2179
2180         return OPJ_TRUE;
2181 }
2182
2183 OPJ_BOOL opj_j2k_write_com(     opj_j2k_t *p_j2k,
2184                                                         opj_stream_private_t *p_stream,
2185                                                         opj_event_mgr_t * p_manager
2186                             )
2187 {
2188         OPJ_UINT32 l_comment_size;
2189         OPJ_UINT32 l_total_com_size;
2190         const OPJ_CHAR *l_comment;
2191         OPJ_BYTE * l_current_ptr = 00;
2192
2193         /* preconditions */
2194         assert(p_j2k != 00);
2195         assert(p_stream != 00);
2196         assert(p_manager != 00);
2197
2198         l_comment = p_j2k->m_cp.comment;
2199         l_comment_size = strlen(l_comment);
2200         l_total_com_size = l_comment_size + 6;
2201
2202         if (l_total_com_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) {
2203                 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);
2204                 if (! new_header_tile_data) {
2205                         opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
2206                         p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL;
2207                         p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
2208                         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write the COM marker\n");
2209                         return OPJ_FALSE;
2210                 }
2211                 p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data;
2212                 p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_total_com_size;
2213         }
2214
2215         l_current_ptr = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
2216
2217         opj_write_bytes(l_current_ptr,J2K_MS_COM , 2);  /* COM */
2218         l_current_ptr+=2;
2219
2220         opj_write_bytes(l_current_ptr,l_total_com_size - 2 , 2);        /* L_COM */
2221         l_current_ptr+=2;
2222
2223         opj_write_bytes(l_current_ptr,1 , 2);   /* General use (IS 8859-15:1999 (Latin) values) */
2224         l_current_ptr+=2;
2225
2226         memcpy( l_current_ptr,l_comment,l_comment_size);
2227
2228         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) {
2229                 return OPJ_FALSE;
2230         }
2231
2232         return OPJ_TRUE;
2233 }
2234
2235 /**
2236  * Reads a COM marker (comments)
2237  * @param       p_j2k           the jpeg2000 file codec.
2238  * @param       p_header_data   the data contained in the COM box.
2239  * @param       p_header_size   the size of the data contained in the COM marker.
2240  * @param       p_manager               the user event manager.
2241 */
2242 static OPJ_BOOL opj_j2k_read_com (  opj_j2k_t *p_j2k,
2243                                     OPJ_BYTE * p_header_data,
2244                                     OPJ_UINT32 p_header_size,
2245                                     opj_event_mgr_t * p_manager
2246                                     )
2247 {
2248         /* preconditions */
2249         assert(p_j2k != 00);
2250         assert(p_manager != 00);
2251         assert(p_header_data != 00);
2252   (void)p_header_size;
2253
2254         return OPJ_TRUE;
2255 }
2256
2257 OPJ_BOOL opj_j2k_write_cod(     opj_j2k_t *p_j2k,
2258                                                         opj_stream_private_t *p_stream,
2259                                                         opj_event_mgr_t * p_manager )
2260 {
2261         opj_cp_t *l_cp = 00;
2262         opj_tcp_t *l_tcp = 00;
2263         OPJ_UINT32 l_code_size,l_remaining_size;
2264         OPJ_BYTE * l_current_data = 00;
2265
2266         /* preconditions */
2267         assert(p_j2k != 00);
2268         assert(p_manager != 00);
2269         assert(p_stream != 00);
2270
2271         l_cp = &(p_j2k->m_cp);
2272         l_tcp = &l_cp->tcps[p_j2k->m_current_tile_number];
2273         l_code_size = 9 + opj_j2k_get_SPCod_SPCoc_size(p_j2k,p_j2k->m_current_tile_number,0);
2274         l_remaining_size = l_code_size;
2275
2276         if (l_code_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) {
2277                 OPJ_BYTE *new_header_tile_data = (OPJ_BYTE *) opj_realloc(p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_code_size);
2278                 if (! new_header_tile_data) {
2279                         opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
2280                         p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL;
2281                         p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
2282                         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write COD marker\n");
2283                         return OPJ_FALSE;
2284                 }
2285                 p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data;
2286                 p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_code_size;
2287         }
2288
2289         l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
2290
2291         opj_write_bytes(l_current_data,J2K_MS_COD,2);           /* COD */
2292         l_current_data += 2;
2293
2294         opj_write_bytes(l_current_data,l_code_size-2,2);        /* L_COD */
2295         l_current_data += 2;
2296
2297         opj_write_bytes(l_current_data,l_tcp->csty,1);          /* Scod */
2298         ++l_current_data;
2299
2300         opj_write_bytes(l_current_data,l_tcp->prg,1);           /* SGcod (A) */
2301         ++l_current_data;
2302
2303         opj_write_bytes(l_current_data,l_tcp->numlayers,2);     /* SGcod (B) */
2304         l_current_data+=2;
2305
2306         opj_write_bytes(l_current_data,l_tcp->mct,1);           /* SGcod (C) */
2307         ++l_current_data;
2308
2309         l_remaining_size -= 9;
2310
2311         if (! opj_j2k_write_SPCod_SPCoc(p_j2k,p_j2k->m_current_tile_number,0,l_current_data,&l_remaining_size,p_manager)) {
2312                 opj_event_msg(p_manager, EVT_ERROR, "Error writing COD marker\n");
2313                 return OPJ_FALSE;
2314         }
2315
2316         if (l_remaining_size != 0) {
2317                 opj_event_msg(p_manager, EVT_ERROR, "Error writing COD marker\n");
2318                 return OPJ_FALSE;
2319         }
2320
2321         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) {
2322                 return OPJ_FALSE;
2323         }
2324
2325         return OPJ_TRUE;
2326 }
2327
2328 /**
2329  * Reads a COD marker (Coding Styke defaults)
2330  * @param       p_header_data   the data contained in the COD box.
2331  * @param       p_j2k                   the jpeg2000 codec.
2332  * @param       p_header_size   the size of the data contained in the COD marker.
2333  * @param       p_manager               the user event manager.
2334 */
2335 static OPJ_BOOL opj_j2k_read_cod (  opj_j2k_t *p_j2k,
2336                                     OPJ_BYTE * p_header_data,
2337                                     OPJ_UINT32 p_header_size,
2338                                     opj_event_mgr_t * p_manager
2339                                     )
2340 {
2341         /* loop */
2342         OPJ_UINT32 i;
2343         OPJ_UINT32 l_tmp;
2344         opj_cp_t *l_cp = 00;
2345         opj_tcp_t *l_tcp = 00;
2346         opj_image_t *l_image = 00;
2347
2348         /* preconditions */
2349         assert(p_header_data != 00);
2350         assert(p_j2k != 00);
2351         assert(p_manager != 00);
2352
2353         l_image = p_j2k->m_private_image;
2354         l_cp = &(p_j2k->m_cp);
2355
2356         /* If we are in the first tile-part header of the current tile */
2357         l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH) ?
2358                                 &l_cp->tcps[p_j2k->m_current_tile_number] :
2359                                 p_j2k->m_specific_param.m_decoder.m_default_tcp;
2360
2361         /* Make sure room is sufficient */
2362         if (p_header_size < 5) {
2363                 opj_event_msg(p_manager, EVT_ERROR, "Error reading COD marker\n");
2364                 return OPJ_FALSE;
2365         }
2366
2367         opj_read_bytes(p_header_data,&l_tcp->csty,1);           /* Scod */
2368         ++p_header_data;
2369         opj_read_bytes(p_header_data,&l_tmp,1);                         /* SGcod (A) */
2370         ++p_header_data;
2371         l_tcp->prg = (OPJ_PROG_ORDER) l_tmp;
2372         opj_read_bytes(p_header_data,&l_tcp->numlayers,2);      /* SGcod (B) */
2373         p_header_data+=2;
2374
2375         /* If user didn't set a number layer to decode take the max specify in the codestream. */
2376         if      (l_cp->m_specific_param.m_dec.m_layer) {
2377                 l_tcp->num_layers_to_decode = l_cp->m_specific_param.m_dec.m_layer;
2378         }
2379         else {
2380                 l_tcp->num_layers_to_decode = l_tcp->numlayers;
2381         }
2382
2383         opj_read_bytes(p_header_data,&l_tcp->mct,1);            /* SGcod (C) */
2384         ++p_header_data;
2385
2386         p_header_size -= 5;
2387         for     (i = 0; i < l_image->numcomps; ++i) {
2388                 l_tcp->tccps[i].csty = l_tcp->csty & J2K_CCP_CSTY_PRT;
2389         }
2390
2391         if (! opj_j2k_read_SPCod_SPCoc(p_j2k,0,p_header_data,&p_header_size,p_manager)) {
2392                 opj_event_msg(p_manager, EVT_ERROR, "Error reading COD marker\n");
2393                 return OPJ_FALSE;
2394         }
2395
2396         if (p_header_size != 0) {
2397                 opj_event_msg(p_manager, EVT_ERROR, "Error reading COD marker\n");
2398                 return OPJ_FALSE;
2399         }
2400
2401         /* Apply the coding style to other components of the current tile or the m_default_tcp*/
2402         opj_j2k_copy_tile_component_parameters(p_j2k);
2403
2404         /* Index */
2405 #ifdef WIP_REMOVE_MSD
2406         if (p_j2k->cstr_info) {
2407                 /*opj_codestream_info_t *l_cstr_info = p_j2k->cstr_info;*/
2408                 p_j2k->cstr_info->prog = l_tcp->prg;
2409                 p_j2k->cstr_info->numlayers = l_tcp->numlayers;
2410                 p_j2k->cstr_info->numdecompos = (OPJ_INT32*) opj_malloc(l_image->numcomps * sizeof(OPJ_UINT32));
2411                 for     (i = 0; i < l_image->numcomps; ++i) {
2412                         p_j2k->cstr_info->numdecompos[i] = l_tcp->tccps[i].numresolutions - 1;
2413                 }
2414         }
2415 #endif
2416
2417         return OPJ_TRUE;
2418 }
2419
2420 OPJ_BOOL opj_j2k_write_coc( opj_j2k_t *p_j2k,
2421                                                 OPJ_UINT32 p_comp_no,
2422                                                 opj_stream_private_t *p_stream,
2423                                                 opj_event_mgr_t * p_manager )
2424 {
2425         OPJ_UINT32 l_coc_size,l_remaining_size;
2426         OPJ_UINT32 l_comp_room;
2427
2428         /* preconditions */
2429         assert(p_j2k != 00);
2430         assert(p_manager != 00);
2431         assert(p_stream != 00);
2432
2433         l_comp_room = (p_j2k->m_private_image->numcomps <= 256) ? 1 : 2;
2434
2435         l_coc_size = 5 + l_comp_room + opj_j2k_get_SPCod_SPCoc_size(p_j2k,p_j2k->m_current_tile_number,p_comp_no);
2436
2437         if (l_coc_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) {
2438                 OPJ_BYTE *new_header_tile_data;
2439                 /*p_j2k->m_specific_param.m_encoder.m_header_tile_data
2440                         = (OPJ_BYTE*)opj_realloc(
2441                                 p_j2k->m_specific_param.m_encoder.m_header_tile_data,
2442                                 l_coc_size);*/
2443
2444                 new_header_tile_data = (OPJ_BYTE *) opj_realloc(p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_coc_size);
2445                 if (! new_header_tile_data) {
2446                         opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
2447                         p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL;
2448                         p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
2449                         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write COC marker\n");
2450                         return OPJ_FALSE;
2451                 }
2452                 p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data;
2453                 p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_coc_size;
2454         }
2455
2456         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);
2457
2458         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) {
2459                 return OPJ_FALSE;
2460         }
2461
2462         return OPJ_TRUE;
2463 }
2464
2465 void opj_j2k_write_coc_in_memory(   opj_j2k_t *p_j2k,
2466                                                 OPJ_UINT32 p_comp_no,
2467                                                 OPJ_BYTE * p_data,
2468                                                 OPJ_UINT32 * p_data_written,
2469                                                 opj_event_mgr_t * p_manager
2470                                     )
2471 {
2472         opj_cp_t *l_cp = 00;
2473         opj_tcp_t *l_tcp = 00;
2474         OPJ_UINT32 l_coc_size,l_remaining_size;
2475         OPJ_BYTE * l_current_data = 00;
2476         opj_image_t *l_image = 00;
2477         OPJ_UINT32 l_comp_room;
2478
2479         /* preconditions */
2480         assert(p_j2k != 00);
2481         assert(p_manager != 00);
2482
2483         l_cp = &(p_j2k->m_cp);
2484         l_tcp = &l_cp->tcps[p_j2k->m_current_tile_number];
2485         l_image = p_j2k->m_private_image;
2486         l_comp_room = (l_image->numcomps <= 256) ? 1 : 2;
2487
2488         l_coc_size = 5 + l_comp_room + opj_j2k_get_SPCod_SPCoc_size(p_j2k,p_j2k->m_current_tile_number,p_comp_no);
2489         l_remaining_size = l_coc_size;
2490
2491         l_current_data = p_data;
2492
2493         opj_write_bytes(l_current_data,J2K_MS_COC,2);                           /* COC */
2494         l_current_data += 2;
2495
2496         opj_write_bytes(l_current_data,l_coc_size-2,2);                         /* L_COC */
2497         l_current_data += 2;
2498
2499         opj_write_bytes(l_current_data,p_comp_no, l_comp_room);         /* Ccoc */
2500         l_current_data+=l_comp_room;
2501
2502         opj_write_bytes(l_current_data, l_tcp->tccps[p_comp_no].csty, 1);               /* Scoc */
2503         ++l_current_data;
2504
2505         l_remaining_size -= (5 + l_comp_room);
2506         opj_j2k_write_SPCod_SPCoc(p_j2k,p_j2k->m_current_tile_number,0,l_current_data,&l_remaining_size,p_manager);
2507         * p_data_written = l_coc_size;
2508 }
2509
2510 OPJ_UINT32 opj_j2k_get_max_coc_size(opj_j2k_t *p_j2k)
2511 {
2512         OPJ_UINT32 i,j;
2513         OPJ_UINT32 l_nb_comp;
2514         OPJ_UINT32 l_nb_tiles;
2515         OPJ_UINT32 l_max = 0;
2516
2517         /* preconditions */
2518
2519         l_nb_tiles = p_j2k->m_cp.tw * p_j2k->m_cp.th ;
2520         l_nb_comp = p_j2k->m_private_image->numcomps;
2521
2522         for (i=0;i<l_nb_tiles;++i) {
2523                 for (j=0;j<l_nb_comp;++j) {
2524                         l_max = opj_uint_max(l_max,opj_j2k_get_SPCod_SPCoc_size(p_j2k,i,j));
2525                 }
2526         }
2527
2528         return 6 + l_max;
2529 }
2530
2531 /**
2532  * Reads a COC marker (Coding Style Component)
2533  * @param       p_header_data   the data contained in the COC box.
2534  * @param       p_j2k                   the jpeg2000 codec.
2535  * @param       p_header_size   the size of the data contained in the COC marker.
2536  * @param       p_manager               the user event manager.
2537 */
2538 static OPJ_BOOL opj_j2k_read_coc (  opj_j2k_t *p_j2k,
2539                                     OPJ_BYTE * p_header_data,
2540                                     OPJ_UINT32 p_header_size,
2541                                     opj_event_mgr_t * p_manager
2542                                     )
2543 {
2544         opj_cp_t *l_cp = NULL;
2545         opj_tcp_t *l_tcp = NULL;
2546         opj_image_t *l_image = NULL;
2547         OPJ_UINT32 l_comp_room;
2548         OPJ_UINT32 l_comp_no;
2549
2550         /* preconditions */
2551         assert(p_header_data != 00);
2552         assert(p_j2k != 00);
2553         assert(p_manager != 00);
2554
2555         l_cp = &(p_j2k->m_cp);
2556         l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH ) ? /*FIXME J2K_DEC_STATE_TPH*/
2557                                 &l_cp->tcps[p_j2k->m_current_tile_number] :
2558                                 p_j2k->m_specific_param.m_decoder.m_default_tcp;
2559         l_image = p_j2k->m_private_image;
2560
2561         l_comp_room = l_image->numcomps <= 256 ? 1 : 2;
2562
2563         /* make sure room is sufficient*/
2564         if (p_header_size < l_comp_room + 1) {
2565                 opj_event_msg(p_manager, EVT_ERROR, "Error reading COC marker\n");
2566                 return OPJ_FALSE;
2567         }
2568         p_header_size -= l_comp_room + 1;
2569
2570         opj_read_bytes(p_header_data,&l_comp_no,l_comp_room);                   /* Ccoc */
2571         p_header_data += l_comp_room;
2572         if (l_comp_no >= l_image->numcomps) {
2573                 opj_event_msg(p_manager, EVT_ERROR, "Error reading COC marker (bad number of components)\n");
2574                 return OPJ_FALSE;
2575         }
2576
2577         opj_read_bytes(p_header_data,&l_tcp->tccps[l_comp_no].csty,1);                  /* Scoc */
2578         ++p_header_data ;
2579
2580         if (! opj_j2k_read_SPCod_SPCoc(p_j2k,l_comp_no,p_header_data,&p_header_size,p_manager)) {
2581                 opj_event_msg(p_manager, EVT_ERROR, "Error reading COC marker\n");
2582                 return OPJ_FALSE;
2583         }
2584
2585         if (p_header_size != 0) {
2586                 opj_event_msg(p_manager, EVT_ERROR, "Error reading COC marker\n");
2587                 return OPJ_FALSE;
2588         }
2589         return OPJ_TRUE;
2590 }
2591
2592 OPJ_BOOL opj_j2k_write_qcd(     opj_j2k_t *p_j2k,
2593                                                         opj_stream_private_t *p_stream,
2594                                                         opj_event_mgr_t * p_manager
2595                             )
2596 {
2597         OPJ_UINT32 l_qcd_size,l_remaining_size;
2598         OPJ_BYTE * l_current_data = 00;
2599
2600         /* preconditions */
2601         assert(p_j2k != 00);
2602         assert(p_manager != 00);
2603         assert(p_stream != 00);
2604
2605         l_qcd_size = 4 + opj_j2k_get_SQcd_SQcc_size(p_j2k,p_j2k->m_current_tile_number,0);
2606         l_remaining_size = l_qcd_size;
2607
2608         if (l_qcd_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) {
2609                 OPJ_BYTE *new_header_tile_data = (OPJ_BYTE *) opj_realloc(p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_qcd_size);
2610                 if (! new_header_tile_data) {
2611                         opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
2612                         p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL;
2613                         p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
2614                         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write QCD marker\n");
2615                         return OPJ_FALSE;
2616                 }
2617                 p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data;
2618                 p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_qcd_size;
2619         }
2620
2621         l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
2622
2623         opj_write_bytes(l_current_data,J2K_MS_QCD,2);           /* QCD */
2624         l_current_data += 2;
2625
2626         opj_write_bytes(l_current_data,l_qcd_size-2,2);         /* L_QCD */
2627         l_current_data += 2;
2628
2629         l_remaining_size -= 4;
2630
2631         if (! opj_j2k_write_SQcd_SQcc(p_j2k,p_j2k->m_current_tile_number,0,l_current_data,&l_remaining_size,p_manager)) {
2632                 opj_event_msg(p_manager, EVT_ERROR, "Error writing QCD marker\n");
2633                 return OPJ_FALSE;
2634         }
2635
2636         if (l_remaining_size != 0) {
2637                 opj_event_msg(p_manager, EVT_ERROR, "Error writing QCD marker\n");
2638                 return OPJ_FALSE;
2639         }
2640
2641         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) {
2642                 return OPJ_FALSE;
2643         }
2644
2645         return OPJ_TRUE;
2646 }
2647
2648 /**
2649  * Reads a QCD marker (Quantization defaults)
2650  * @param       p_header_data   the data contained in the QCD box.
2651  * @param       p_j2k                   the jpeg2000 codec.
2652  * @param       p_header_size   the size of the data contained in the QCD marker.
2653  * @param       p_manager               the user event manager.
2654 */
2655 static OPJ_BOOL opj_j2k_read_qcd (  opj_j2k_t *p_j2k,
2656                                     OPJ_BYTE * p_header_data,
2657                                     OPJ_UINT32 p_header_size,
2658                                     opj_event_mgr_t * p_manager
2659                                     )
2660 {
2661         /* preconditions */
2662         assert(p_header_data != 00);
2663         assert(p_j2k != 00);
2664         assert(p_manager != 00);
2665
2666         if (! opj_j2k_read_SQcd_SQcc(p_j2k,0,p_header_data,&p_header_size,p_manager)) {
2667                 opj_event_msg(p_manager, EVT_ERROR, "Error reading QCD marker\n");
2668                 return OPJ_FALSE;
2669         }
2670
2671         if (p_header_size != 0) {
2672                 opj_event_msg(p_manager, EVT_ERROR, "Error reading QCD marker\n");
2673                 return OPJ_FALSE;
2674         }
2675
2676         /* Apply the quantization parameters to other components of the current tile or the m_default_tcp */
2677         opj_j2k_copy_tile_quantization_parameters(p_j2k);
2678
2679         return OPJ_TRUE;
2680 }
2681
2682 OPJ_BOOL opj_j2k_write_qcc(     opj_j2k_t *p_j2k,
2683                                                 OPJ_UINT32 p_comp_no,
2684                                                 opj_stream_private_t *p_stream,
2685                                                 opj_event_mgr_t * p_manager
2686                             )
2687 {
2688         OPJ_UINT32 l_qcc_size,l_remaining_size;
2689
2690         /* preconditions */
2691         assert(p_j2k != 00);
2692         assert(p_manager != 00);
2693         assert(p_stream != 00);
2694
2695         l_qcc_size = 5 + opj_j2k_get_SQcd_SQcc_size(p_j2k,p_j2k->m_current_tile_number,p_comp_no);
2696         l_qcc_size += p_j2k->m_private_image->numcomps <= 256 ? 0:1;
2697         l_remaining_size = l_qcc_size;
2698
2699         if (l_qcc_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) {
2700                 OPJ_BYTE *new_header_tile_data = (OPJ_BYTE *) opj_realloc(p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_qcc_size);
2701                 if (! new_header_tile_data) {
2702                         opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
2703                         p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL;
2704                         p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
2705                         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write QCC marker\n");
2706                         return OPJ_FALSE;
2707                 }
2708                 p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data;
2709                 p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_qcc_size;
2710         }
2711
2712         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);
2713
2714         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) {
2715                 return OPJ_FALSE;
2716         }
2717
2718         return OPJ_TRUE;
2719 }
2720
2721 void opj_j2k_write_qcc_in_memory(   opj_j2k_t *p_j2k,
2722                                                                 OPJ_UINT32 p_comp_no,
2723                                                                 OPJ_BYTE * p_data,
2724                                                                 OPJ_UINT32 * p_data_written,
2725                                                                 opj_event_mgr_t * p_manager
2726                                     )
2727 {
2728         OPJ_UINT32 l_qcc_size,l_remaining_size;
2729         OPJ_BYTE * l_current_data = 00;
2730
2731         /* preconditions */
2732         assert(p_j2k != 00);
2733         assert(p_manager != 00);
2734
2735         l_qcc_size = 6 + opj_j2k_get_SQcd_SQcc_size(p_j2k,p_j2k->m_current_tile_number,p_comp_no);
2736         l_remaining_size = l_qcc_size;
2737
2738         l_current_data = p_data;
2739
2740         opj_write_bytes(l_current_data,J2K_MS_QCC,2);           /* QCC */
2741         l_current_data += 2;
2742
2743         if (p_j2k->m_private_image->numcomps <= 256) {
2744                 --l_qcc_size;
2745
2746                 opj_write_bytes(l_current_data,l_qcc_size-2,2);         /* L_QCC */
2747                 l_current_data += 2;
2748
2749                 opj_write_bytes(l_current_data, p_comp_no, 1);  /* Cqcc */
2750                 ++l_current_data;
2751
2752                 /* in the case only one byte is sufficient the last byte allocated is useless -> still do -6 for available */
2753                 l_remaining_size -= 6;
2754         }
2755         else {
2756                 opj_write_bytes(l_current_data,l_qcc_size-2,2);         /* L_QCC */
2757                 l_current_data += 2;
2758
2759                 opj_write_bytes(l_current_data, p_comp_no, 2);  /* Cqcc */
2760                 l_current_data+=2;
2761
2762                 l_remaining_size -= 6;
2763         }
2764
2765         opj_j2k_write_SQcd_SQcc(p_j2k,p_j2k->m_current_tile_number,p_comp_no,l_current_data,&l_remaining_size,p_manager);
2766
2767         *p_data_written = l_qcc_size;
2768 }
2769
2770 OPJ_UINT32 opj_j2k_get_max_qcc_size (opj_j2k_t *p_j2k)
2771 {
2772         return opj_j2k_get_max_coc_size(p_j2k);
2773 }
2774
2775 /**
2776  * Reads a QCC marker (Quantization component)
2777  * @param       p_header_data   the data contained in the QCC box.
2778  * @param       p_j2k                   the jpeg2000 codec.
2779  * @param       p_header_size   the size of the data contained in the QCC marker.
2780  * @param       p_manager               the user event manager.
2781 */
2782 static OPJ_BOOL opj_j2k_read_qcc(   opj_j2k_t *p_j2k,
2783                                     OPJ_BYTE * p_header_data,
2784                                     OPJ_UINT32 p_header_size,
2785                                     opj_event_mgr_t * p_manager
2786                                     )
2787 {
2788         OPJ_UINT32 l_num_comp,l_comp_no;
2789
2790         /* preconditions */
2791         assert(p_header_data != 00);
2792         assert(p_j2k != 00);
2793         assert(p_manager != 00);
2794
2795         l_num_comp = p_j2k->m_private_image->numcomps;
2796
2797         if (l_num_comp <= 256) {
2798                 if (p_header_size < 1) {
2799                         opj_event_msg(p_manager, EVT_ERROR, "Error reading QCC marker\n");
2800                         return OPJ_FALSE;
2801                 }
2802                 opj_read_bytes(p_header_data,&l_comp_no,1);
2803                 ++p_header_data;
2804                 --p_header_size;
2805         }
2806         else {
2807                 if (p_header_size < 2) {
2808                         opj_event_msg(p_manager, EVT_ERROR, "Error reading QCC marker\n");
2809                         return OPJ_FALSE;
2810                 }
2811                 opj_read_bytes(p_header_data,&l_comp_no,2);
2812                 p_header_data+=2;
2813                 p_header_size-=2;
2814         }
2815
2816 #ifdef USE_JPWL
2817         if (p_j2k->m_cp.correct) {
2818
2819                 static OPJ_UINT32 backup_compno = 0;
2820
2821                 /* compno is negative or larger than the number of components!!! */
2822                 if (/*(l_comp_no < 0) ||*/ (l_comp_no >= l_num_comp)) {
2823                         opj_event_msg(p_manager, EVT_ERROR,
2824                                 "JPWL: bad component number in QCC (%d out of a maximum of %d)\n",
2825                                 l_comp_no, l_num_comp);
2826                         if (!JPWL_ASSUME) {
2827                                 opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n");
2828                                 return OPJ_FALSE;
2829                         }
2830                         /* we try to correct */
2831                         l_comp_no = backup_compno % l_num_comp;
2832                         opj_event_msg(p_manager, EVT_WARNING, "- trying to adjust this\n"
2833                                 "- setting component number to %d\n",
2834                                 l_comp_no);
2835                 }
2836
2837                 /* keep your private count of tiles */
2838                 backup_compno++;
2839         };
2840 #endif /* USE_JPWL */
2841
2842         if (l_comp_no >= p_j2k->m_private_image->numcomps) {
2843                 opj_event_msg(p_manager, EVT_ERROR,
2844                               "Invalid component number: %d, regarding the number of components %d\n",
2845                               l_comp_no, p_j2k->m_private_image->numcomps);
2846                 return OPJ_FALSE;
2847         }
2848
2849         if (! opj_j2k_read_SQcd_SQcc(p_j2k,l_comp_no,p_header_data,&p_header_size,p_manager)) {
2850                 opj_event_msg(p_manager, EVT_ERROR, "Error reading QCC marker\n");
2851                 return OPJ_FALSE;
2852         }
2853
2854         if (p_header_size != 0) {
2855                 opj_event_msg(p_manager, EVT_ERROR, "Error reading QCC marker\n");
2856                 return OPJ_FALSE;
2857         }
2858
2859         return OPJ_TRUE;
2860 }
2861
2862 OPJ_BOOL opj_j2k_write_poc(     opj_j2k_t *p_j2k,
2863                                                         opj_stream_private_t *p_stream,
2864                                                         opj_event_mgr_t * p_manager
2865                             )
2866 {
2867         OPJ_UINT32 l_nb_comp;
2868         OPJ_UINT32 l_nb_poc;
2869         OPJ_UINT32 l_poc_size;
2870         OPJ_UINT32 l_written_size = 0;
2871         opj_tcp_t *l_tcp = 00;
2872         OPJ_UINT32 l_poc_room;
2873
2874         /* preconditions */
2875         assert(p_j2k != 00);
2876         assert(p_manager != 00);
2877         assert(p_stream != 00);
2878
2879         l_tcp = &p_j2k->m_cp.tcps[p_j2k->m_current_tile_number];
2880         l_nb_comp = p_j2k->m_private_image->numcomps;
2881         l_nb_poc = 1 + l_tcp->numpocs;
2882
2883         if (l_nb_comp <= 256) {
2884                 l_poc_room = 1;
2885         }
2886         else {
2887                 l_poc_room = 2;
2888         }
2889         l_poc_size = 4 + (5 + 2 * l_poc_room) * l_nb_poc;
2890
2891         if (l_poc_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) {
2892                 OPJ_BYTE *new_header_tile_data = (OPJ_BYTE *) opj_realloc(p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_poc_size);
2893                 if (! new_header_tile_data) {
2894                         opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
2895                         p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL;
2896                         p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
2897                         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write POC marker\n");
2898                         return OPJ_FALSE;
2899                 }
2900                 p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data;
2901                 p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_poc_size;
2902         }
2903
2904         opj_j2k_write_poc_in_memory(p_j2k,p_j2k->m_specific_param.m_encoder.m_header_tile_data,&l_written_size,p_manager);
2905
2906         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) {
2907                 return OPJ_FALSE;
2908         }
2909
2910         return OPJ_TRUE;
2911 }
2912
2913 void opj_j2k_write_poc_in_memory(   opj_j2k_t *p_j2k,
2914                                                                 OPJ_BYTE * p_data,
2915                                                                 OPJ_UINT32 * p_data_written,
2916                                                                 opj_event_mgr_t * p_manager
2917                                     )
2918 {
2919         OPJ_UINT32 i;
2920         OPJ_BYTE * l_current_data = 00;
2921         OPJ_UINT32 l_nb_comp;
2922         OPJ_UINT32 l_nb_poc;
2923         OPJ_UINT32 l_poc_size;
2924         opj_image_t *l_image = 00;
2925         opj_tcp_t *l_tcp = 00;
2926         opj_tccp_t *l_tccp = 00;
2927         opj_poc_t *l_current_poc = 00;
2928         OPJ_UINT32 l_poc_room;
2929
2930         /* preconditions */
2931         assert(p_j2k != 00);
2932         assert(p_manager != 00);
2933
2934         l_tcp = &p_j2k->m_cp.tcps[p_j2k->m_current_tile_number];
2935         l_tccp = &l_tcp->tccps[0];
2936         l_image = p_j2k->m_private_image;
2937         l_nb_comp = l_image->numcomps;
2938         l_nb_poc = 1 + l_tcp->numpocs;
2939
2940         if (l_nb_comp <= 256) {
2941                 l_poc_room = 1;
2942         }
2943         else {
2944                 l_poc_room = 2;
2945         }
2946
2947         l_poc_size = 4 + (5 + 2 * l_poc_room) * l_nb_poc;
2948
2949         l_current_data = p_data;
2950
2951         opj_write_bytes(l_current_data,J2K_MS_POC,2);                                   /* POC  */
2952         l_current_data += 2;
2953
2954         opj_write_bytes(l_current_data,l_poc_size-2,2);                                 /* Lpoc */
2955         l_current_data += 2;
2956
2957         l_current_poc =  l_tcp->pocs;
2958         for (i = 0; i < l_nb_poc; ++i) {
2959                 opj_write_bytes(l_current_data,l_current_poc->resno0,1);                                /* RSpoc_i */
2960                 ++l_current_data;
2961
2962                 opj_write_bytes(l_current_data,l_current_poc->compno0,l_poc_room);              /* CSpoc_i */
2963                 l_current_data+=l_poc_room;
2964
2965                 opj_write_bytes(l_current_data,l_current_poc->layno1,2);                                /* LYEpoc_i */
2966                 l_current_data+=2;
2967
2968                 opj_write_bytes(l_current_data,l_current_poc->resno1,1);                                /* REpoc_i */
2969                 ++l_current_data;
2970
2971                 opj_write_bytes(l_current_data,l_current_poc->compno1,l_poc_room);              /* CEpoc_i */
2972                 l_current_data+=l_poc_room;
2973
2974                 opj_write_bytes(l_current_data,l_current_poc->prg,1);                                   /* Ppoc_i */
2975                 ++l_current_data;
2976
2977                 /* change the value of the max layer according to the actual number of layers in the file, components and resolutions*/
2978                 l_current_poc->layno1 = opj_int_min(l_current_poc->layno1, l_tcp->numlayers);
2979                 l_current_poc->resno1 = opj_int_min(l_current_poc->resno1, l_tccp->numresolutions);
2980                 l_current_poc->compno1 = opj_int_min(l_current_poc->compno1, l_nb_comp);
2981
2982                 ++l_current_poc;
2983         }
2984
2985         *p_data_written = l_poc_size;
2986 }
2987
2988 OPJ_UINT32 opj_j2k_get_max_poc_size(opj_j2k_t *p_j2k)
2989 {
2990         opj_tcp_t * l_tcp = 00;
2991         OPJ_UINT32 l_nb_tiles = 0;
2992         OPJ_UINT32 l_max_poc = 0;
2993         OPJ_UINT32 i;
2994
2995         l_tcp = p_j2k->m_cp.tcps;
2996         l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
2997
2998         for (i=0;i<l_nb_tiles;++i) {
2999                 l_max_poc = opj_uint_max(l_max_poc,l_tcp->numpocs);
3000                 ++l_tcp;
3001         }
3002
3003         ++l_max_poc;
3004
3005         return 4 + 9 * l_max_poc;
3006 }
3007
3008 OPJ_UINT32 opj_j2k_get_max_toc_size (opj_j2k_t *p_j2k)
3009 {
3010         OPJ_UINT32 i;
3011         OPJ_UINT32 l_nb_tiles;
3012         OPJ_UINT32 l_max = 0;
3013         opj_tcp_t * l_tcp = 00;
3014
3015         l_tcp = p_j2k->m_cp.tcps;
3016         l_nb_tiles = p_j2k->m_cp.tw * p_j2k->m_cp.th ;
3017
3018         for (i=0;i<l_nb_tiles;++i) {
3019                 l_max = opj_uint_max(l_max,l_tcp->m_nb_tile_parts);
3020
3021                 ++l_tcp;
3022         }
3023
3024         return 12 * l_max;
3025 }
3026
3027 OPJ_UINT32 opj_j2k_get_specific_header_sizes(opj_j2k_t *p_j2k)
3028 {
3029         OPJ_UINT32 l_nb_bytes = 0;
3030         OPJ_UINT32 l_nb_comps;
3031         OPJ_UINT32 l_coc_bytes,l_qcc_bytes;
3032
3033         l_nb_comps = p_j2k->m_private_image->numcomps - 1;
3034         l_nb_bytes += opj_j2k_get_max_toc_size(p_j2k);
3035
3036         if (p_j2k->m_cp.m_specific_param.m_enc.m_cinema == 0) {
3037                 l_coc_bytes = opj_j2k_get_max_coc_size(p_j2k);
3038                 l_nb_bytes += l_nb_comps * l_coc_bytes;
3039
3040                 l_qcc_bytes = opj_j2k_get_max_qcc_size(p_j2k);
3041                 l_nb_bytes += l_nb_comps * l_qcc_bytes;
3042         }
3043
3044         l_nb_bytes += opj_j2k_get_max_poc_size(p_j2k);
3045
3046         /*** DEVELOPER CORNER, Add room for your headers ***/
3047
3048         return l_nb_bytes;
3049 }
3050
3051 /**
3052  * Reads a POC marker (Progression Order Change)
3053  *
3054  * @param       p_header_data   the data contained in the POC box.
3055  * @param       p_j2k                   the jpeg2000 codec.
3056  * @param       p_header_size   the size of the data contained in the POC marker.
3057  * @param       p_manager               the user event manager.
3058 */
3059 static OPJ_BOOL opj_j2k_read_poc (  opj_j2k_t *p_j2k,
3060                                     OPJ_BYTE * p_header_data,
3061                                     OPJ_UINT32 p_header_size,
3062                                     opj_event_mgr_t * p_manager
3063                                     )
3064 {
3065         OPJ_UINT32 i, l_nb_comp, l_tmp;
3066         opj_image_t * l_image = 00;
3067         OPJ_UINT32 l_old_poc_nb, l_current_poc_nb, l_current_poc_remaining;
3068         OPJ_UINT32 l_chunk_size, l_comp_room;
3069
3070         opj_cp_t *l_cp = 00;
3071         opj_tcp_t *l_tcp = 00;
3072         opj_poc_t *l_current_poc = 00;
3073
3074         /* preconditions */
3075         assert(p_header_data != 00);
3076         assert(p_j2k != 00);
3077         assert(p_manager != 00);
3078
3079         l_image = p_j2k->m_private_image;
3080         l_nb_comp = l_image->numcomps;
3081         if (l_nb_comp <= 256) {
3082                 l_comp_room = 1;
3083         }
3084         else {
3085                 l_comp_room = 2;
3086         }
3087         l_chunk_size = 5 + 2 * l_comp_room;
3088         l_current_poc_nb = p_header_size / l_chunk_size;
3089         l_current_poc_remaining = p_header_size % l_chunk_size;
3090
3091         if ((l_current_poc_nb <= 0) || (l_current_poc_remaining != 0)) {
3092                 opj_event_msg(p_manager, EVT_ERROR, "Error reading POC marker\n");
3093                 return OPJ_FALSE;
3094         }
3095
3096         l_cp = &(p_j2k->m_cp);
3097         l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH) ?
3098                                 &l_cp->tcps[p_j2k->m_current_tile_number] :
3099                                 p_j2k->m_specific_param.m_decoder.m_default_tcp;
3100         l_old_poc_nb = l_tcp->POC ? l_tcp->numpocs + 1 : 0;
3101         l_current_poc_nb += l_old_poc_nb;
3102
3103         assert(l_current_poc_nb < 32);
3104
3105         /* now poc is in use.*/
3106         l_tcp->POC = 1;
3107
3108         l_current_poc = &l_tcp->pocs[l_old_poc_nb];
3109         for     (i = l_old_poc_nb; i < l_current_poc_nb; ++i) {
3110                 opj_read_bytes(p_header_data,&(l_current_poc->resno0),1);                               /* RSpoc_i */
3111                 ++p_header_data;
3112                 opj_read_bytes(p_header_data,&(l_current_poc->compno0),l_comp_room);    /* CSpoc_i */
3113                 p_header_data+=l_comp_room;
3114                 opj_read_bytes(p_header_data,&(l_current_poc->layno1),2);                               /* LYEpoc_i */
3115                 p_header_data+=2;
3116                 opj_read_bytes(p_header_data,&(l_current_poc->resno1),1);                               /* REpoc_i */
3117                 ++p_header_data;
3118                 opj_read_bytes(p_header_data,&(l_current_poc->compno1),l_comp_room);    /* CEpoc_i */
3119                 p_header_data+=l_comp_room;
3120                 opj_read_bytes(p_header_data,&l_tmp,1);                                                                 /* Ppoc_i */
3121                 ++p_header_data;
3122                 l_current_poc->prg = (OPJ_PROG_ORDER) l_tmp;
3123                 /* make sure comp is in acceptable bounds */
3124                 l_current_poc->compno1 = opj_uint_min(l_current_poc->compno1, l_nb_comp);
3125                 ++l_current_poc;
3126         }
3127
3128         l_tcp->numpocs = l_current_poc_nb - 1;
3129         return OPJ_TRUE;
3130 }
3131
3132 /**
3133  * Reads a CRG marker (Component registration)
3134  *
3135  * @param       p_header_data   the data contained in the TLM box.
3136  * @param       p_j2k                   the jpeg2000 codec.
3137  * @param       p_header_size   the size of the data contained in the TLM marker.
3138  * @param       p_manager               the user event manager.
3139 */
3140 static OPJ_BOOL opj_j2k_read_crg (  opj_j2k_t *p_j2k,
3141                                     OPJ_BYTE * p_header_data,
3142                                     OPJ_UINT32 p_header_size,
3143                                     opj_event_mgr_t * p_manager
3144                                     )
3145 {
3146         OPJ_UINT32 l_nb_comp;
3147         /* preconditions */
3148         assert(p_header_data != 00);
3149         assert(p_j2k != 00);
3150         assert(p_manager != 00);
3151
3152         l_nb_comp = p_j2k->m_private_image->numcomps;
3153
3154         if (p_header_size != l_nb_comp *4) {
3155                 opj_event_msg(p_manager, EVT_ERROR, "Error reading CRG marker\n");
3156                 return OPJ_FALSE;
3157         }
3158         /* Do not care of this at the moment since only local variables are set here */
3159         /*
3160         for
3161                 (i = 0; i < l_nb_comp; ++i)
3162         {
3163                 opj_read_bytes(p_header_data,&l_Xcrg_i,2);                              // Xcrg_i
3164                 p_header_data+=2;
3165                 opj_read_bytes(p_header_data,&l_Ycrg_i,2);                              // Xcrg_i
3166                 p_header_data+=2;
3167         }
3168         */
3169         return OPJ_TRUE;
3170 }
3171
3172 /**
3173  * Reads a TLM marker (Tile Length Marker)
3174  *
3175  * @param       p_header_data   the data contained in the TLM box.
3176  * @param       p_j2k                   the jpeg2000 codec.
3177  * @param       p_header_size   the size of the data contained in the TLM marker.
3178  * @param       p_manager               the user event manager.
3179 */
3180 static OPJ_BOOL opj_j2k_read_tlm (  opj_j2k_t *p_j2k,
3181                                     OPJ_BYTE * p_header_data,
3182                                     OPJ_UINT32 p_header_size,
3183                                     opj_event_mgr_t * p_manager
3184                                     )
3185 {
3186         OPJ_UINT32 l_Ztlm, l_Stlm, l_ST, l_SP, l_tot_num_tp_remaining, l_quotient, l_Ptlm_size;
3187         /* preconditions */
3188         assert(p_header_data != 00);
3189         assert(p_j2k != 00);
3190         assert(p_manager != 00);
3191
3192         if (p_header_size < 2) {
3193                 opj_event_msg(p_manager, EVT_ERROR, "Error reading TLM marker\n");
3194                 return OPJ_FALSE;
3195         }
3196         p_header_size -= 2;
3197
3198         opj_read_bytes(p_header_data,&l_Ztlm,1);                                /* Ztlm */
3199         ++p_header_data;
3200         opj_read_bytes(p_header_data,&l_Stlm,1);                                /* Stlm */
3201         ++p_header_data;
3202
3203         l_ST = ((l_Stlm >> 4) & 0x3);
3204         l_SP = (l_Stlm >> 6) & 0x1;
3205
3206         l_Ptlm_size = (l_SP + 1) * 2;
3207         l_quotient = l_Ptlm_size + l_ST;
3208
3209         l_tot_num_tp_remaining = p_header_size % l_quotient;
3210
3211         if (l_tot_num_tp_remaining != 0) {
3212                 opj_event_msg(p_manager, EVT_ERROR, "Error reading TLM marker\n");
3213                 return OPJ_FALSE;
3214         }
3215         /* FIXME Do not care of this at the moment since only local variables are set here */
3216         /*
3217         for
3218                 (i = 0; i < l_tot_num_tp; ++i)
3219         {
3220                 opj_read_bytes(p_header_data,&l_Ttlm_i,l_ST);                           // Ttlm_i
3221                 p_header_data += l_ST;
3222                 opj_read_bytes(p_header_data,&l_Ptlm_i,l_Ptlm_size);            // Ptlm_i
3223                 p_header_data += l_Ptlm_size;
3224         }*/
3225         return OPJ_TRUE;
3226 }
3227
3228 /**
3229  * Reads a PLM marker (Packet length, main header marker)
3230  *
3231  * @param       p_header_data   the data contained in the TLM box.
3232  * @param       p_j2k                   the jpeg2000 codec.
3233  * @param       p_header_size   the size of the data contained in the TLM marker.
3234  * @param       p_manager               the user event manager.
3235 */
3236 static OPJ_BOOL opj_j2k_read_plm (  opj_j2k_t *p_j2k,
3237                                     OPJ_BYTE * p_header_data,
3238                                     OPJ_UINT32 p_header_size,
3239                                     opj_event_mgr_t * p_manager
3240                                     )
3241 {
3242         /* preconditions */
3243         assert(p_header_data != 00);
3244         assert(p_j2k != 00);
3245         assert(p_manager != 00);
3246
3247         if (p_header_size < 1) {
3248                 opj_event_msg(p_manager, EVT_ERROR, "Error reading PLM marker\n");
3249                 return OPJ_FALSE;
3250         }
3251         /* Do not care of this at the moment since only local variables are set here */
3252         /*
3253         opj_read_bytes(p_header_data,&l_Zplm,1);                                        // Zplm
3254         ++p_header_data;
3255         --p_header_size;
3256
3257         while
3258                 (p_header_size > 0)
3259         {
3260                 opj_read_bytes(p_header_data,&l_Nplm,1);                                // Nplm
3261                 ++p_header_data;
3262                 p_header_size -= (1+l_Nplm);
3263                 if
3264                         (p_header_size < 0)
3265                 {
3266                         opj_event_msg(p_manager, EVT_ERROR, "Error reading PLM marker\n");
3267                         return false;
3268                 }
3269                 for
3270                         (i = 0; i < l_Nplm; ++i)
3271                 {
3272                         opj_read_bytes(p_header_data,&l_tmp,1);                         // Iplm_ij
3273                         ++p_header_data;
3274                         // take only the last seven bytes
3275                         l_packet_len |= (l_tmp & 0x7f);
3276                         if
3277                                 (l_tmp & 0x80)
3278                         {
3279                                 l_packet_len <<= 7;
3280                         }
3281                         else
3282                         {
3283                 // store packet length and proceed to next packet
3284                                 l_packet_len = 0;
3285                         }
3286                 }
3287                 if
3288                         (l_packet_len != 0)
3289                 {
3290                         opj_event_msg(p_manager, EVT_ERROR, "Error reading PLM marker\n");
3291                         return false;
3292                 }
3293         }
3294         */
3295         return OPJ_TRUE;
3296 }
3297
3298 /**
3299  * Reads a PLT marker (Packet length, tile-part header)
3300  *
3301  * @param       p_header_data   the data contained in the PLT box.
3302  * @param       p_j2k                   the jpeg2000 codec.
3303  * @param       p_header_size   the size of the data contained in the PLT marker.
3304  * @param       p_manager               the user event manager.
3305 */
3306 static OPJ_BOOL opj_j2k_read_plt (  opj_j2k_t *p_j2k,
3307                                     OPJ_BYTE * p_header_data,
3308                                     OPJ_UINT32 p_header_size,
3309                                     opj_event_mgr_t * p_manager
3310                                     )
3311 {
3312         OPJ_UINT32 l_Zplt, l_tmp, l_packet_len = 0, i;
3313
3314         /* preconditions */
3315         assert(p_header_data != 00);
3316         assert(p_j2k != 00);
3317         assert(p_manager != 00);
3318
3319         if (p_header_size < 1) {
3320                 opj_event_msg(p_manager, EVT_ERROR, "Error reading PLT marker\n");
3321                 return OPJ_FALSE;
3322         }
3323
3324         opj_read_bytes(p_header_data,&l_Zplt,1);                /* Zplt */
3325         ++p_header_data;
3326         --p_header_size;
3327
3328         for (i = 0; i < p_header_size; ++i) {
3329                 opj_read_bytes(p_header_data,&l_tmp,1);         /* Iplt_ij */
3330                 ++p_header_data;
3331                 /* take only the last seven bytes */
3332                 l_packet_len |= (l_tmp & 0x7f);
3333                 if (l_tmp & 0x80) {
3334                         l_packet_len <<= 7;
3335                 }
3336                 else {
3337             /* store packet length and proceed to next packet */
3338                         l_packet_len = 0;
3339                 }
3340         }
3341
3342         if (l_packet_len != 0) {
3343                 opj_event_msg(p_manager, EVT_ERROR, "Error reading PLT marker\n");
3344                 return OPJ_FALSE;
3345         }
3346
3347         return OPJ_TRUE;
3348 }
3349
3350 #if 0
3351 OPJ_BOOL j2k_read_ppm_v2 (
3352                                                 opj_j2k_t *p_j2k,
3353                                                 OPJ_BYTE * p_header_data,
3354                                                 OPJ_UINT32 p_header_size,
3355                                                 struct opj_event_mgr * p_manager
3356                                         )
3357 {
3358
3359         opj_cp_t *l_cp = 00;
3360         OPJ_UINT32 l_remaining_data, l_Z_ppm, l_N_ppm;
3361
3362         /* preconditions */
3363         assert(p_header_data != 00);
3364         assert(p_j2k != 00);
3365         assert(p_manager != 00);
3366
3367         if (p_header_size < 1) {
3368                 opj_event_msg(p_manager, EVT_ERROR, "Error reading PPM marker\n");
3369                 return OPJ_FALSE;
3370         }
3371
3372         l_cp = &(p_j2k->m_cp);
3373         l_cp->ppm = 1;
3374
3375         opj_read_bytes(p_header_data,&l_Z_ppm,1);               /* Z_ppm */
3376         ++p_header_data;
3377         --p_header_size;
3378
3379         /* First PPM marker */
3380         if (l_Z_ppm == 0) {
3381                 if (p_header_size < 4) {
3382                         opj_event_msg(p_manager, EVT_ERROR, "Error reading PPM marker\n");
3383                         return OPJ_FALSE;
3384                 }
3385
3386                 opj_read_bytes(p_header_data,&l_N_ppm,4);               /* N_ppm */
3387                 p_header_data+=4;
3388                 p_header_size-=4;
3389
3390                 /* First PPM marker: Initialization */
3391                 l_cp->ppm_len = l_N_ppm;
3392                 l_cp->ppm_data_size = 0;
3393
3394                 l_cp->ppm_buffer = (OPJ_BYTE *) opj_malloc(l_cp->ppm_len);
3395                 if (l_cp->ppm_buffer == 00) {
3396                         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory reading ppm marker\n");
3397                         return OPJ_FALSE;
3398                 }
3399                 memset(l_cp->ppm_buffer,0,l_cp->ppm_len);
3400
3401                 l_cp->ppm_data = l_cp->ppm_buffer;
3402         }
3403
3404         while (1) {
3405                 if (l_cp->ppm_data_size == l_cp->ppm_len) {
3406                         if (p_header_size >= 4) {
3407                                 /* read a N_ppm */
3408                                 opj_read_bytes(p_header_data,&l_N_ppm,4);               /* N_ppm */
3409                                 p_header_data+=4;
3410                                 p_header_size-=4;
3411                                 l_cp->ppm_len += l_N_ppm ;
3412
3413                                 OPJ_BYTE *new_ppm_buffer = (OPJ_BYTE *) opj_realloc(l_cp->ppm_buffer, l_cp->ppm_len);
3414                                 if (! new_ppm_buffer) {
3415                                         opj_free(l_cp->ppm_buffer);
3416                                         l_cp->ppm_buffer = NULL;
3417                                         l_cp->ppm_len = 0;
3418                                         l_cp->ppm_data = NULL;
3419                                         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory reading ppm marker\n");
3420                                         return OPJ_FALSE;
3421                                 }
3422                                 l_cp->ppm_buffer = new_ppm_buffer;
3423                                 memset(l_cp->ppm_buffer+l_cp->ppm_data_size,0,l_N_ppm);
3424                                 l_cp->ppm_data = l_cp->ppm_buffer;
3425                         }
3426                         else {
3427                                 return OPJ_FALSE;
3428                         }
3429                 }
3430
3431                 l_remaining_data = l_cp->ppm_len - l_cp->ppm_data_size;
3432
3433                 if (l_remaining_data <= p_header_size) {
3434                         /* we must store less information than available in the packet */
3435                         memcpy(l_cp->ppm_buffer + l_cp->ppm_data_size , p_header_data , l_remaining_data);
3436                         l_cp->ppm_data_size = l_cp->ppm_len;
3437                         p_header_size -= l_remaining_data;
3438                         p_header_data += l_remaining_data;
3439                 }
3440                 else {
3441                         memcpy(l_cp->ppm_buffer + l_cp->ppm_data_size , p_header_data , p_header_size);
3442                         l_cp->ppm_data_size += p_header_size;
3443                         p_header_data += p_header_size;
3444                         p_header_size = 0;
3445                         break;
3446                 }
3447         }
3448
3449         return OPJ_TRUE;
3450 }
3451 #endif
3452
3453 OPJ_BOOL j2k_read_ppm_v3 (
3454                                                 opj_j2k_t *p_j2k,
3455                                                 OPJ_BYTE * p_header_data,
3456                                                 OPJ_UINT32 p_header_size,
3457                                                 struct opj_event_mgr * p_manager
3458                                         )
3459 {
3460         opj_cp_t *l_cp = 00;
3461         OPJ_UINT32 l_remaining_data, l_Z_ppm, l_N_ppm;
3462
3463         /* preconditions */
3464         assert(p_header_data != 00);
3465         assert(p_j2k != 00);
3466         assert(p_manager != 00);
3467
3468         /* Minimum size of PPM marker is equal to the size of Zppm element */
3469         if (p_header_size < 1) {
3470                 opj_event_msg(p_manager, EVT_ERROR, "Error reading PPM marker\n");
3471                 return OPJ_FALSE;
3472         }
3473
3474         l_cp = &(p_j2k->m_cp);
3475         l_cp->ppm = 1;
3476
3477         opj_read_bytes(p_header_data,&l_Z_ppm,1);               /* Z_ppm */
3478         ++p_header_data;
3479         --p_header_size;
3480
3481         /* First PPM marker */
3482         if (l_Z_ppm == 0) {
3483                 /* We need now at least the Nppm^0 element */
3484                 if (p_header_size < 4) {
3485                         opj_event_msg(p_manager, EVT_ERROR, "Error reading PPM marker\n");
3486                         return OPJ_FALSE;
3487                 }
3488
3489                 opj_read_bytes(p_header_data,&l_N_ppm,4);               /* First N_ppm */
3490                 p_header_data+=4;
3491                 p_header_size-=4;
3492
3493                 /* First PPM marker: Initialization */
3494                 l_cp->ppm_len = l_N_ppm;
3495                 l_cp->ppm_data_read = 0;
3496
3497                 l_cp->ppm_data = (OPJ_BYTE *) opj_malloc(l_cp->ppm_len);
3498                 l_cp->ppm_buffer = l_cp->ppm_data;
3499                 if (l_cp->ppm_data == 00) {
3500                         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read ppm marker\n");
3501                         return OPJ_FALSE;
3502                 }
3503                 memset(l_cp->ppm_data,0,l_cp->ppm_len);
3504
3505                 l_cp->ppm_data_current = l_cp->ppm_data;
3506
3507                 /*l_cp->ppm_data = l_cp->ppm_buffer;*/
3508         }
3509         else {
3510                 if (p_header_size < 4) {
3511                         opj_event_msg(p_manager, EVT_WARNING, "Empty PPM marker\n");
3512                         return OPJ_TRUE;
3513                 }
3514                 else {
3515                         /* Uncompleted Ippm series in the previous PPM marker?*/
3516                         if (l_cp->ppm_data_read < l_cp->ppm_len) {
3517                                 /* Get the place where add the remaining Ippm series*/
3518                                 l_cp->ppm_data_current = &(l_cp->ppm_data[l_cp->ppm_data_read]);
3519                                 l_N_ppm = l_cp->ppm_len - l_cp->ppm_data_read;
3520                         }
3521                         else {
3522                                 OPJ_BYTE *new_ppm_data;
3523                                 opj_read_bytes(p_header_data,&l_N_ppm,4);               /* First N_ppm */
3524                                 p_header_data+=4;
3525                                 p_header_size-=4;
3526
3527                                 /* Increase the size of ppm_data to add the new Ippm series*/
3528                                 assert(l_cp->ppm_data == l_cp->ppm_buffer && "We need ppm_data and ppm_buffer to be the same when reallocating");
3529                                 new_ppm_data = (OPJ_BYTE *) opj_realloc(l_cp->ppm_data, l_cp->ppm_len + l_N_ppm);
3530                                 if (! new_ppm_data) {
3531                                         opj_free(l_cp->ppm_data);
3532                                         l_cp->ppm_data = NULL;
3533                                         l_cp->ppm_buffer = NULL;  /* TODO: no need for a new local variable: ppm_buffer and ppm_data are enough */
3534                                         l_cp->ppm_len = 0;
3535                                         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to increase the size of ppm_data to add the new Ippm series\n");
3536                                         return OPJ_FALSE;
3537                                 }
3538                                 l_cp->ppm_data = new_ppm_data;
3539                                 l_cp->ppm_buffer = l_cp->ppm_data;
3540
3541                                 /* Keep the position of the place where concatenate the new series*/
3542                                 l_cp->ppm_data_current = &(l_cp->ppm_data[l_cp->ppm_len]);
3543                                 l_cp->ppm_len += l_N_ppm;
3544                         }
3545                 }
3546         }
3547
3548         l_remaining_data = p_header_size;
3549
3550         while (l_remaining_data >= l_N_ppm) {
3551                 /* read a complete Ippm series*/
3552                 memcpy(l_cp->ppm_data_current, p_header_data, l_N_ppm);
3553                 p_header_size -= l_N_ppm;
3554                 p_header_data += l_N_ppm;
3555
3556                 l_cp->ppm_data_read += l_N_ppm; /* Increase the number of data read*/
3557
3558                 if (p_header_size)
3559                 {
3560                         opj_read_bytes(p_header_data,&l_N_ppm,4);               /* N_ppm^i */
3561                         p_header_data+=4;
3562                         p_header_size-=4;
3563                 }
3564                 else {
3565                         l_remaining_data = p_header_size;
3566                         break;
3567                 }
3568
3569                 l_remaining_data = p_header_size;
3570
3571                 /* Next Ippm series is a complete series ?*/
3572                 if (l_remaining_data > l_N_ppm) {
3573                         OPJ_BYTE *new_ppm_data;
3574                         /* Increase the size of ppm_data to add the new Ippm series*/
3575                         assert(l_cp->ppm_data == l_cp->ppm_buffer && "We need ppm_data and ppm_buffer to be the same when reallocating");
3576                         new_ppm_data = (OPJ_BYTE *) opj_realloc(l_cp->ppm_data, l_cp->ppm_len + l_N_ppm);
3577                         if (! new_ppm_data) {
3578                                 opj_free(l_cp->ppm_data);
3579                                 l_cp->ppm_data = NULL;
3580                                 l_cp->ppm_buffer = NULL;  /* TODO: no need for a new local variable: ppm_buffer and ppm_data are enough */
3581                                 l_cp->ppm_len = 0;
3582                                 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");
3583                                 return OPJ_FALSE;
3584                         }
3585                         l_cp->ppm_data = new_ppm_data;
3586                         l_cp->ppm_buffer = l_cp->ppm_data;
3587
3588                         /* Keep the position of the place where concatenate the new series */
3589                         l_cp->ppm_data_current = &(l_cp->ppm_data[l_cp->ppm_len]);
3590                         l_cp->ppm_len += l_N_ppm;
3591                 }
3592
3593         }
3594
3595         /* Need to read an incomplete Ippm series*/
3596         if (l_remaining_data) {
3597                 OPJ_BYTE *new_ppm_data;
3598                 assert(l_cp->ppm_data == l_cp->ppm_buffer && "We need ppm_data and ppm_buffer to be the same when reallocating");
3599                 new_ppm_data = (OPJ_BYTE *) opj_realloc(l_cp->ppm_data, l_cp->ppm_len + l_N_ppm);
3600                 if (! new_ppm_data) {
3601                         opj_free(l_cp->ppm_data);
3602                         l_cp->ppm_data = NULL;
3603                         l_cp->ppm_buffer = NULL;  /* TODO: no need for a new local variable: ppm_buffer and ppm_data are enough */
3604                         l_cp->ppm_len = 0;
3605                         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");
3606                         return OPJ_FALSE;
3607                 }
3608                 l_cp->ppm_data = new_ppm_data;
3609                 l_cp->ppm_buffer = l_cp->ppm_data;
3610
3611                 /* Keep the position of the place where concatenate the new series*/
3612                 l_cp->ppm_data_current = &(l_cp->ppm_data[l_cp->ppm_len]);
3613                 l_cp->ppm_len += l_N_ppm;
3614
3615                 /* Read incomplete Ippm series*/
3616                 memcpy(l_cp->ppm_data_current, p_header_data, l_remaining_data);
3617                 p_header_size -= l_remaining_data;
3618                 p_header_data += l_remaining_data;
3619
3620                 l_cp->ppm_data_read += l_remaining_data; /* Increase the number of data read*/
3621         }
3622
3623 #ifdef CLEAN_MSD
3624
3625                 if (l_cp->ppm_data_size == l_cp->ppm_len) {
3626                         if (p_header_size >= 4) {
3627                                 /* read a N_ppm*/
3628                                 opj_read_bytes(p_header_data,&l_N_ppm,4);               /* N_ppm */
3629                                 p_header_data+=4;
3630                                 p_header_size-=4;
3631                                 l_cp->ppm_len += l_N_ppm ;
3632
3633                                 OPJ_BYTE *new_ppm_buffer = (OPJ_BYTE *) opj_realloc(l_cp->ppm_buffer, l_cp->ppm_len);
3634                                 if (! new_ppm_buffer) {
3635                                         opj_free(l_cp->ppm_buffer);
3636                                         l_cp->ppm_buffer = NULL;
3637                                         l_cp->ppm_len = 0;
3638                                         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read ppm marker\n");
3639                                         return OPJ_FALSE;
3640                                 }
3641                                 l_cp->ppm_buffer = new_ppm_buffer;
3642                                 memset(l_cp->ppm_buffer+l_cp->ppm_data_size,0,l_N_ppm);
3643
3644                                 l_cp->ppm_data = l_cp->ppm_buffer;
3645                         }
3646                         else {
3647                                 return OPJ_FALSE;
3648                         }
3649                 }
3650
3651                 l_remaining_data = l_cp->ppm_len - l_cp->ppm_data_size;
3652
3653                 if (l_remaining_data <= p_header_size) {
3654                         /* we must store less information than available in the packet */
3655                         memcpy(l_cp->ppm_buffer + l_cp->ppm_data_size , p_header_data , l_remaining_data);
3656                         l_cp->ppm_data_size = l_cp->ppm_len;
3657                         p_header_size -= l_remaining_data;
3658                         p_header_data += l_remaining_data;
3659                 }
3660                 else {
3661                         memcpy(l_cp->ppm_buffer + l_cp->ppm_data_size , p_header_data , p_header_size);
3662                         l_cp->ppm_data_size += p_header_size;
3663                         p_header_data += p_header_size;
3664                         p_header_size = 0;
3665                         break;
3666                 }
3667         }
3668 #endif
3669         return OPJ_TRUE;
3670 }
3671
3672 /**
3673  * Reads a PPT marker (Packed packet headers, tile-part header)
3674  *
3675  * @param       p_header_data   the data contained in the PPT box.
3676  * @param       p_j2k                   the jpeg2000 codec.
3677  * @param       p_header_size   the size of the data contained in the PPT marker.
3678  * @param       p_manager               the user event manager.
3679 */
3680 static OPJ_BOOL opj_j2k_read_ppt (  opj_j2k_t *p_j2k,
3681                                     OPJ_BYTE * p_header_data,
3682                                     OPJ_UINT32 p_header_size,
3683                                     opj_event_mgr_t * p_manager
3684                                     )
3685 {
3686         opj_cp_t *l_cp = 00;
3687         opj_tcp_t *l_tcp = 00;
3688         OPJ_UINT32 l_Z_ppt;
3689
3690         /* preconditions */
3691         assert(p_header_data != 00);
3692         assert(p_j2k != 00);
3693         assert(p_manager != 00);
3694
3695         /* We need to have the Z_ppt element at minimum */
3696         if (p_header_size < 1) {
3697                 opj_event_msg(p_manager, EVT_ERROR, "Error reading PPT marker\n");
3698                 return OPJ_FALSE;
3699         }
3700
3701         l_cp = &(p_j2k->m_cp);
3702         if (l_cp->ppm){
3703                 opj_event_msg(p_manager, EVT_ERROR, "Error reading PPT marker: packet header have been previously found in the main header (PPM marker).\n");
3704                 return OPJ_FALSE;
3705         }
3706
3707         l_tcp = &(l_cp->tcps[p_j2k->m_current_tile_number]);
3708         l_tcp->ppt = 1;
3709
3710         opj_read_bytes(p_header_data,&l_Z_ppt,1);               /* Z_ppt */
3711         ++p_header_data;
3712         --p_header_size;
3713
3714         /* Allocate buffer to read the packet header */
3715         if (l_Z_ppt == 0) {
3716                 /* First PPT marker */
3717                 l_tcp->ppt_data_size = 0;
3718                 l_tcp->ppt_len = p_header_size;
3719
3720                 l_tcp->ppt_buffer = (OPJ_BYTE *) opj_calloc(l_tcp->ppt_len, sizeof(OPJ_BYTE) );
3721                 if (l_tcp->ppt_buffer == 00) {
3722                         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read PPT marker\n");
3723                         return OPJ_FALSE;
3724                 }
3725                 l_tcp->ppt_data = l_tcp->ppt_buffer;
3726
3727                 /* memset(l_tcp->ppt_buffer,0,l_tcp->ppt_len); */
3728         }
3729         else {
3730                 OPJ_BYTE *new_ppt_buffer;
3731                 l_tcp->ppt_len += p_header_size;
3732
3733                 new_ppt_buffer = (OPJ_BYTE *) opj_realloc(l_tcp->ppt_buffer, l_tcp->ppt_len);
3734                 if (! new_ppt_buffer) {
3735                         opj_free(l_tcp->ppt_buffer);
3736                         l_tcp->ppt_buffer = NULL;
3737                         l_tcp->ppt_len = 0;
3738                         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read PPT marker\n");
3739                         return OPJ_FALSE;
3740                 }
3741                 l_tcp->ppt_buffer = new_ppt_buffer;
3742                 l_tcp->ppt_data = l_tcp->ppt_buffer;
3743
3744                 memset(l_tcp->ppt_buffer+l_tcp->ppt_data_size,0,p_header_size);
3745         }
3746
3747         /* Read packet header from buffer */
3748         memcpy(l_tcp->ppt_buffer+l_tcp->ppt_data_size,p_header_data,p_header_size);
3749
3750         l_tcp->ppt_data_size += p_header_size;
3751
3752         return OPJ_TRUE;
3753 }
3754
3755 OPJ_BOOL opj_j2k_write_tlm(     opj_j2k_t *p_j2k,
3756                                                         opj_stream_private_t *p_stream,
3757                                                         opj_event_mgr_t * p_manager
3758                             )
3759 {
3760         OPJ_BYTE * l_current_data = 00;
3761         OPJ_UINT32 l_tlm_size;
3762
3763         /* preconditions */
3764         assert(p_j2k != 00);
3765         assert(p_manager != 00);
3766         assert(p_stream != 00);
3767
3768         l_tlm_size = 6 + (5*p_j2k->m_specific_param.m_encoder.m_total_tile_parts);
3769
3770         if (l_tlm_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) {
3771                 OPJ_BYTE *new_header_tile_data = (OPJ_BYTE *) opj_realloc(p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_tlm_size);
3772                 if (! new_header_tile_data) {
3773                         opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
3774                         p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL;
3775                         p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
3776                         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write TLM marker\n");
3777                         return OPJ_FALSE;
3778                 }
3779                 p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data;
3780                 p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_tlm_size;
3781         }
3782
3783         l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
3784
3785         /* change the way data is written to avoid seeking if possible */
3786         /* TODO */
3787         p_j2k->m_specific_param.m_encoder.m_tlm_start = opj_stream_tell(p_stream);
3788
3789         opj_write_bytes(l_current_data,J2K_MS_TLM,2);                                   /* TLM */
3790         l_current_data += 2;
3791
3792         opj_write_bytes(l_current_data,l_tlm_size-2,2);                                 /* Lpoc */
3793         l_current_data += 2;
3794
3795         opj_write_bytes(l_current_data,0,1);                                                    /* Ztlm=0*/
3796         ++l_current_data;
3797
3798         opj_write_bytes(l_current_data,0x50,1);                                                 /* Stlm ST=1(8bits-255 tiles max),SP=1(Ptlm=32bits) */
3799         ++l_current_data;
3800
3801         /* do nothing on the 5 * l_j2k->m_specific_param.m_encoder.m_total_tile_parts remaining data */
3802         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) {
3803                 return OPJ_FALSE;
3804         }
3805
3806         return OPJ_TRUE;
3807 }
3808
3809 OPJ_BOOL opj_j2k_write_sot(     opj_j2k_t *p_j2k,
3810                                                         OPJ_BYTE * p_data,
3811                                                         OPJ_UINT32 * p_data_written,
3812                                                         const opj_stream_private_t *p_stream,
3813                                                         opj_event_mgr_t * p_manager
3814                             )
3815 {
3816         /* preconditions */
3817         assert(p_j2k != 00);
3818         assert(p_manager != 00);
3819         assert(p_stream != 00);
3820
3821         opj_write_bytes(p_data,J2K_MS_SOT,2);                                   /* SOT */
3822         p_data += 2;
3823
3824         opj_write_bytes(p_data,10,2);                                                   /* Lsot */
3825         p_data += 2;
3826
3827         opj_write_bytes(p_data, p_j2k->m_current_tile_number,2);                        /* Isot */
3828         p_data += 2;
3829
3830         /* Psot  */
3831         p_data += 4;
3832
3833         opj_write_bytes(p_data, p_j2k->m_specific_param.m_encoder.m_current_tile_part_number,1);                        /* TPsot */
3834         ++p_data;
3835
3836         opj_write_bytes(p_data, p_j2k->m_cp.tcps[p_j2k->m_current_tile_number].m_nb_tile_parts,1);                      /* TNsot */
3837         ++p_data;
3838
3839         /* UniPG>> */
3840 #ifdef USE_JPWL
3841         /* update markers struct */
3842 /*
3843         OPJ_BOOL res = j2k_add_marker(p_j2k->cstr_info, J2K_MS_SOT, p_j2k->sot_start, len + 2);
3844 */
3845   assert( 0 && "TODO" );
3846 #endif /* USE_JPWL */
3847
3848         * p_data_written = 12;
3849
3850         return OPJ_TRUE;
3851 }
3852
3853 OPJ_BOOL opj_j2k_read_sot ( opj_j2k_t *p_j2k,
3854                             OPJ_BYTE * p_header_data,
3855                             OPJ_UINT32 p_header_size,
3856                             opj_event_mgr_t * p_manager )
3857 {
3858         opj_cp_t *l_cp = 00;
3859         opj_tcp_t *l_tcp = 00;
3860         OPJ_UINT32 l_tot_len, l_num_parts = 0;
3861         OPJ_UINT32 l_current_part;
3862         OPJ_UINT32 l_tile_x,l_tile_y;
3863
3864         /* preconditions */
3865         assert(p_header_data != 00);
3866         assert(p_j2k != 00);
3867         assert(p_manager != 00);
3868
3869         /* Size of this marker is fixed = 12 (we have already read marker and its size)*/
3870         if (p_header_size != 8) {
3871                 opj_event_msg(p_manager, EVT_ERROR, "Error reading SOT marker\n");
3872                 return OPJ_FALSE;
3873         }
3874
3875         l_cp = &(p_j2k->m_cp);
3876         opj_read_bytes(p_header_data,&(p_j2k->m_current_tile_number),2);                /* Isot */
3877         p_header_data+=2;
3878
3879         l_tcp = &l_cp->tcps[p_j2k->m_current_tile_number];
3880         l_tile_x = p_j2k->m_current_tile_number % l_cp->tw;
3881         l_tile_y = p_j2k->m_current_tile_number / l_cp->tw;
3882
3883 #ifdef USE_JPWL
3884         if (l_cp->correct) {
3885
3886                 OPJ_UINT32 tileno = p_j2k->m_current_tile_number;
3887                 static OPJ_UINT32 backup_tileno = 0;
3888
3889                 /* tileno is negative or larger than the number of tiles!!! */
3890                 if (tileno > (l_cp->tw * l_cp->th)) {
3891                         opj_event_msg(p_manager, EVT_ERROR,
3892                                         "JPWL: bad tile number (%d out of a maximum of %d)\n",
3893                                         tileno, (l_cp->tw * l_cp->th));
3894                         if (!JPWL_ASSUME) {
3895                                 opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n");
3896                                 return OPJ_FALSE;
3897                         }
3898                         /* we try to correct */
3899                         tileno = backup_tileno;
3900                         opj_event_msg(p_manager, EVT_WARNING, "- trying to adjust this\n"
3901                                         "- setting tile number to %d\n",
3902                                         tileno);
3903                 }
3904
3905                 /* keep your private count of tiles */
3906                 backup_tileno++;
3907         };
3908 #endif /* USE_JPWL */
3909
3910         /* look for the tile in the list of already processed tile (in parts). */
3911         /* Optimization possible here with a more complex data structure and with the removing of tiles */
3912         /* since the time taken by this function can only grow at the time */
3913
3914         opj_read_bytes(p_header_data,&l_tot_len,4);             /* Psot */
3915         p_header_data+=4;
3916
3917         /* PSot should be equal to zero or >=14 or <= 2^32-1 */
3918         if ((l_tot_len !=0 ) && (l_tot_len < 14) )
3919         {
3920             if (l_tot_len == 12 ) /* MSD: Special case for the PHR data which are read by kakadu*/
3921             {
3922                 opj_event_msg(p_manager, EVT_WARNING, "Empty SOT marker detected: Psot=%d.\n", l_tot_len);
3923             }
3924             else
3925             {
3926                 opj_event_msg(p_manager, EVT_ERROR, "Psot value is not correct regards to the JPEG2000 norm: %d.\n", l_tot_len);
3927                 return OPJ_FALSE;
3928             }
3929         }
3930
3931 #ifdef USE_JPWL
3932         if (l_cp->correct) {
3933
3934                 /* totlen is negative or larger than the bytes left!!! */
3935                 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))) { */
3936                         opj_event_msg(p_manager, EVT_ERROR,
3937                                         "JPWL: bad tile byte size (%d bytes against %d bytes left)\n",
3938                                         l_tot_len, p_header_size ); /* FIXME it seems correct; for info in V1 -> p_stream_numbytesleft(p_stream) + 8); */
3939                         if (!JPWL_ASSUME) {
3940                                 opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n");
3941                                 return OPJ_FALSE;
3942                         }
3943                         /* we try to correct */
3944                         l_tot_len = 0;
3945                         opj_event_msg(p_manager, EVT_WARNING, "- trying to adjust this\n"
3946                                         "- setting Psot to %d => assuming it is the last tile\n",
3947                                         l_tot_len);
3948                 }
3949                 };
3950 #endif /* USE_JPWL */
3951
3952                 /* Ref A.4.2: Psot could be equal zero if it is the last tile-part of the codestream.*/
3953                 if (!l_tot_len) {
3954                         opj_event_msg(p_manager, EVT_INFO, "Psot value of the current tile-part is equal to zero, "
3955                                         "we assuming it is the last tile-part of the codestream.\n");
3956                         p_j2k->m_specific_param.m_decoder.m_last_tile_part = 1;
3957                 }
3958
3959                 opj_read_bytes(p_header_data,&l_current_part ,1);       /* TPsot */
3960                 ++p_header_data;
3961
3962                 opj_read_bytes(p_header_data,&l_num_parts ,1);          /* TNsot */
3963                 ++p_header_data;
3964
3965                 if (l_num_parts != 0) { /* Number of tile-part header is provided by this tile-part header */
3966                         /* Useful to manage the case of textGBR.jp2 file because two values of TNSot are allowed: the correct numbers of
3967                          * tile-parts for that tile and zero (A.4.2 of 15444-1 : 2002). */
3968                         if (l_tcp->m_nb_tile_parts) {
3969                                 if (l_current_part >= l_tcp->m_nb_tile_parts){
3970                                         opj_event_msg(p_manager, EVT_ERROR, "In SOT marker, TPSot (%d) is not valid regards to the current "
3971                                                         "number of tile-part (%d), giving up\n", l_current_part, l_tcp->m_nb_tile_parts );
3972                                         p_j2k->m_specific_param.m_decoder.m_last_tile_part = 1;
3973                                         return OPJ_FALSE;
3974                                 }
3975                         }
3976                         l_tcp->m_nb_tile_parts = l_num_parts;
3977                 }
3978
3979                 /* If know the number of tile part header we will check if we didn't read the last*/
3980                 if (l_tcp->m_nb_tile_parts) {
3981                         if (l_tcp->m_nb_tile_parts == (l_current_part + 1)) {
3982                                 p_j2k->m_specific_param.m_decoder.m_can_decode = 1; /* Process the last tile-part header*/
3983                         }
3984                 }
3985
3986                 if (!p_j2k->m_specific_param.m_decoder.m_last_tile_part){
3987                         /* Keep the size of data to skip after this marker */
3988                         p_j2k->m_specific_param.m_decoder.m_sot_length = l_tot_len - 12; /* SOT_marker_size = 12 */
3989                 }
3990                 else {
3991                         /* FIXME: need to be computed from the number of bytes remaining in the codestream */
3992                         p_j2k->m_specific_param.m_decoder.m_sot_length = 0;
3993                 }
3994
3995                 p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_TPH;
3996
3997                 /* Check if the current tile is outside the area we want decode or not corresponding to the tile index*/
3998                 if (p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec == -1) {
3999                         p_j2k->m_specific_param.m_decoder.m_skip_data =
4000                                 (l_tile_x < p_j2k->m_specific_param.m_decoder.m_start_tile_x)
4001                                 ||      (l_tile_x >= p_j2k->m_specific_param.m_decoder.m_end_tile_x)
4002                                 ||  (l_tile_y < p_j2k->m_specific_param.m_decoder.m_start_tile_y)
4003                                 ||      (l_tile_y >= p_j2k->m_specific_param.m_decoder.m_end_tile_y);
4004                 }
4005                 else {
4006                         assert( p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec >= 0 );
4007                         p_j2k->m_specific_param.m_decoder.m_skip_data =
4008                                 (p_j2k->m_current_tile_number != (OPJ_UINT32)p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec);
4009                 }
4010
4011                 /* Index */
4012                 if (p_j2k->cstr_index)
4013                 {
4014                         assert(p_j2k->cstr_index->tile_index != 00);
4015                         p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tileno = p_j2k->m_current_tile_number;
4016                         p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_tpsno = l_current_part;
4017
4018                         if (l_num_parts != 0){
4019                                 p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].nb_tps = l_num_parts;
4020                                 p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps = l_num_parts;
4021
4022                                 if (!p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index) {
4023                                         p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index =
4024                                                 (opj_tp_index_t*)opj_calloc(l_num_parts, sizeof(opj_tp_index_t));
4025                                 }
4026                                 else {
4027                                         opj_tp_index_t *new_tp_index = (opj_tp_index_t *) opj_realloc(
4028                                                         p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index, l_num_parts* sizeof(opj_tp_index_t));
4029                                         if (! new_tp_index) {
4030                                                 opj_free(p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index);
4031                                                 p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index = NULL;
4032                                                 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read PPT marker\n");
4033                                                 return OPJ_FALSE;
4034                                         }
4035                                         p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index = new_tp_index;
4036                                 }
4037                         }
4038                         else{
4039                                 /*if (!p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index)*/ {
4040
4041                                         if (!p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index) {
4042                                                 p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps = 10;
4043                                                 p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index =
4044                                                         (opj_tp_index_t*)opj_calloc( p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps,
4045                                                                         sizeof(opj_tp_index_t));
4046                                         }
4047
4048                                         if ( l_current_part >= p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps ){
4049                                                 opj_tp_index_t *new_tp_index;
4050                                                 p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps += 10;
4051                                                 new_tp_index = (opj_tp_index_t *) opj_realloc(
4052                                                                 p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index,
4053                                                                 p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps * sizeof(opj_tp_index_t));
4054                                                 if (! new_tp_index) {
4055                                                         opj_free(p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index);
4056                                                         p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index = NULL;
4057                                                         p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps = 0;
4058                                                         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read PPT marker\n");
4059                                                         return OPJ_FALSE;
4060                                                 }
4061                                                 p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index = new_tp_index;
4062                                         }
4063                                 }
4064
4065                         }
4066
4067                 }
4068
4069                 /* 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 */
4070                 /* if (p_j2k->cstr_info) {
4071                    if (l_tcp->first) {
4072                    if (tileno == 0) {
4073                    p_j2k->cstr_info->main_head_end = p_stream_tell(p_stream) - 13;
4074                    }
4075
4076                    p_j2k->cstr_info->tile[tileno].tileno = tileno;
4077                    p_j2k->cstr_info->tile[tileno].start_pos = p_stream_tell(p_stream) - 12;
4078                    p_j2k->cstr_info->tile[tileno].end_pos = p_j2k->cstr_info->tile[tileno].start_pos + totlen - 1;
4079                    p_j2k->cstr_info->tile[tileno].num_tps = numparts;
4080
4081                    if (numparts) {
4082                    p_j2k->cstr_info->tile[tileno].tp = (opj_tp_info_t *) opj_malloc(numparts * sizeof(opj_tp_info_t));
4083                    }
4084                    else {
4085                    p_j2k->cstr_info->tile[tileno].tp = (opj_tp_info_t *) opj_malloc(10 * sizeof(opj_tp_info_t)); // Fixme (10)
4086                    }
4087                    }
4088                    else {
4089                    p_j2k->cstr_info->tile[tileno].end_pos += totlen;
4090                    }
4091
4092                    p_j2k->cstr_info->tile[tileno].tp[partno].tp_start_pos = p_stream_tell(p_stream) - 12;
4093                    p_j2k->cstr_info->tile[tileno].tp[partno].tp_end_pos =
4094                    p_j2k->cstr_info->tile[tileno].tp[partno].tp_start_pos + totlen - 1;
4095                    }*/
4096                 return OPJ_TRUE;
4097         }
4098
4099 OPJ_BOOL opj_j2k_write_sod(     opj_j2k_t *p_j2k,
4100                                                         opj_tcd_t * p_tile_coder,
4101                                                         OPJ_BYTE * p_data,
4102                                                         OPJ_UINT32 * p_data_written,
4103                                                         OPJ_UINT32 p_total_data_size,
4104                                                         const opj_stream_private_t *p_stream,
4105                                                         opj_event_mgr_t * p_manager
4106                             )
4107 {
4108         opj_codestream_info_t *l_cstr_info = 00;
4109         OPJ_UINT32 l_remaining_data;
4110
4111         /* preconditions */
4112         assert(p_j2k != 00);
4113         assert(p_manager != 00);
4114         assert(p_stream != 00);
4115
4116         opj_write_bytes(p_data,J2K_MS_SOD,2);                                   /* SOD */
4117         p_data += 2;
4118
4119         /* make room for the EOF marker */
4120         l_remaining_data =  p_total_data_size - 4;
4121
4122         /* update tile coder */
4123         p_tile_coder->tp_num = p_j2k->m_specific_param.m_encoder.m_current_poc_tile_part_number ;
4124         p_tile_coder->cur_tp_num = p_j2k->m_specific_param.m_encoder.m_current_tile_part_number;
4125
4126          /* INDEX >> */
4127         /* TODO mergeV2: check this part which use cstr_info */
4128         /*l_cstr_info = p_j2k->cstr_info;
4129         if (l_cstr_info) {
4130                 if (!p_j2k->m_specific_param.m_encoder.m_current_tile_part_number ) {
4131                         //TODO cstr_info->tile[p_j2k->m_current_tile_number].end_header = p_stream_tell(p_stream) + p_j2k->pos_correction - 1;
4132                         l_cstr_info->tile[p_j2k->m_current_tile_number].tileno = p_j2k->m_current_tile_number;
4133                 }
4134                 else {*/
4135                         /*
4136                         TODO
4137                         if
4138                                 (cstr_info->tile[p_j2k->m_current_tile_number].packet[cstr_info->packno - 1].end_pos < p_stream_tell(p_stream))
4139                         {
4140                                 cstr_info->tile[p_j2k->m_current_tile_number].packet[cstr_info->packno].start_pos = p_stream_tell(p_stream);
4141                         }*/
4142                 /*}*/
4143                 /* UniPG>> */
4144 #ifdef USE_JPWL
4145                 /* update markers struct */
4146                 /*OPJ_BOOL res = j2k_add_marker(p_j2k->cstr_info, J2K_MS_SOD, p_j2k->sod_start, 2);
4147 */
4148   assert( 0 && "TODO" );
4149 #endif /* USE_JPWL */
4150                 /* <<UniPG */
4151         /*}*/
4152         /* << INDEX */
4153
4154         if (p_j2k->m_specific_param.m_encoder.m_current_tile_part_number == 0) {
4155                 p_tile_coder->tcd_image->tiles->packno = 0;
4156                 if (l_cstr_info) {
4157                         l_cstr_info->packno = 0;
4158                 }
4159         }
4160
4161         *p_data_written = 0;
4162
4163         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)) {
4164                 opj_event_msg(p_manager, EVT_ERROR, "Cannot encode tile\n");
4165                 return OPJ_FALSE;
4166         }
4167
4168         *p_data_written += 2;
4169
4170         return OPJ_TRUE;
4171 }
4172
4173 OPJ_BOOL opj_j2k_read_sod (opj_j2k_t *p_j2k,
4174                            opj_stream_private_t *p_stream,
4175                                                    opj_event_mgr_t * p_manager
4176                            )
4177 {
4178         OPJ_UINT32 l_current_read_size;
4179         opj_codestream_index_t * l_cstr_index = 00;
4180         OPJ_BYTE ** l_current_data = 00;
4181         opj_tcp_t * l_tcp = 00;
4182         OPJ_UINT32 * l_tile_len = 00;
4183         OPJ_BOOL l_sot_length_pb_detected = OPJ_FALSE;
4184
4185         /* preconditions */
4186         assert(p_j2k != 00);
4187         assert(p_manager != 00);
4188         assert(p_stream != 00);
4189
4190         l_tcp = &(p_j2k->m_cp.tcps[p_j2k->m_current_tile_number]);
4191
4192         if (p_j2k->m_specific_param.m_decoder.m_last_tile_part) {
4193                 /* opj_stream_get_number_byte_left returns OPJ_OFF_T
4194                 // but we are in the last tile part,
4195                 // so its result will fit on OPJ_UINT32 unless we find
4196                 // a file with a single tile part of more than 4 GB...*/
4197                 p_j2k->m_specific_param.m_decoder.m_sot_length = (OPJ_UINT32)(opj_stream_get_number_byte_left(p_stream) - 2);
4198         }
4199         else {
4200             /* Check to avoid pass the limit of OPJ_UINT32 */
4201             if (p_j2k->m_specific_param.m_decoder.m_sot_length >= 2 )
4202                 p_j2k->m_specific_param.m_decoder.m_sot_length -= 2;
4203             else {
4204                 /* MSD: case commented to support empty SOT marker (PHR data) */
4205             }
4206         }
4207
4208         l_current_data = &(l_tcp->m_data);
4209         l_tile_len = &l_tcp->m_data_size;
4210
4211         /* Patch to support new PHR data */
4212         if (p_j2k->m_specific_param.m_decoder.m_sot_length) {
4213             if (! *l_current_data) {
4214                 /* LH: oddly enough, in this path, l_tile_len!=0.
4215                  * TODO: If this was consistant, we could simplify the code to only use realloc(), as realloc(0,...) default to malloc(0,...).
4216                  */
4217                 *l_current_data = (OPJ_BYTE*) opj_malloc(p_j2k->m_specific_param.m_decoder.m_sot_length);
4218             }
4219             else {
4220                 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);
4221                 if (! l_new_current_data) {
4222                         opj_free(*l_current_data);
4223                         /*nothing more is done as l_current_data will be set to null, and just
4224                           afterward we enter in the error path
4225                           and the actual tile_len is updated (committed) at the end of the
4226                           function. */
4227                 }
4228                 *l_current_data = l_new_current_data;
4229             }
4230
4231             if (*l_current_data == 00) {
4232                 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to decode tile\n");
4233                 return OPJ_FALSE;
4234             }
4235         }
4236         else {
4237             l_sot_length_pb_detected = OPJ_TRUE;
4238         }
4239
4240         /* Index */
4241         l_cstr_index = p_j2k->cstr_index;
4242         if (l_cstr_index) {
4243                 OPJ_OFF_T l_current_pos = opj_stream_tell(p_stream) - 2;
4244
4245                 OPJ_UINT32 l_current_tile_part = l_cstr_index->tile_index[p_j2k->m_current_tile_number].current_tpsno;
4246                 l_cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index[l_current_tile_part].end_header =
4247                                 l_current_pos;
4248                 l_cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index[l_current_tile_part].end_pos =
4249                                 l_current_pos + p_j2k->m_specific_param.m_decoder.m_sot_length + 2;
4250
4251                 if (OPJ_FALSE == opj_j2k_add_tlmarker(p_j2k->m_current_tile_number,
4252                                         l_cstr_index,
4253                                         J2K_MS_SOD,
4254                                         l_current_pos,
4255                                         p_j2k->m_specific_param.m_decoder.m_sot_length + 2)) {
4256                         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to add tl marker\n");
4257                         return OPJ_FALSE;
4258                 }
4259
4260                 /*l_cstr_index->packno = 0;*/
4261         }
4262
4263         /* Patch to support new PHR data */
4264         if (!l_sot_length_pb_detected) {
4265             l_current_read_size = opj_stream_read_data(
4266                         p_stream,
4267                         *l_current_data + *l_tile_len,
4268                         p_j2k->m_specific_param.m_decoder.m_sot_length,
4269                         p_manager);
4270         }
4271         else
4272         {
4273             l_current_read_size = 0;
4274         }
4275
4276         if (l_current_read_size != p_j2k->m_specific_param.m_decoder.m_sot_length) {
4277                 p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_NEOC;
4278         }
4279         else {
4280                 p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_TPHSOT;
4281         }
4282
4283         *l_tile_len +=  l_current_read_size;
4284
4285         return OPJ_TRUE;
4286 }
4287
4288  OPJ_BOOL opj_j2k_write_rgn(opj_j2k_t *p_j2k,
4289                             OPJ_UINT32 p_tile_no,
4290                             OPJ_UINT32 p_comp_no,
4291                             OPJ_UINT32 nb_comps,
4292                             opj_stream_private_t *p_stream,
4293                             opj_event_mgr_t * p_manager
4294                             )
4295 {
4296         OPJ_BYTE * l_current_data = 00;
4297         OPJ_UINT32 l_rgn_size;
4298         opj_cp_t *l_cp = 00;
4299         opj_tcp_t *l_tcp = 00;
4300         opj_tccp_t *l_tccp = 00;
4301         OPJ_UINT32 l_comp_room;
4302
4303         /* preconditions */
4304         assert(p_j2k != 00);
4305         assert(p_manager != 00);
4306         assert(p_stream != 00);
4307
4308         l_cp = &(p_j2k->m_cp);
4309         l_tcp = &l_cp->tcps[p_tile_no];
4310         l_tccp = &l_tcp->tccps[p_comp_no];
4311
4312         if (nb_comps <= 256) {
4313                 l_comp_room = 1;
4314         }
4315         else {
4316                 l_comp_room = 2;
4317         }
4318
4319         l_rgn_size = 6 + l_comp_room;
4320
4321         l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
4322
4323         opj_write_bytes(l_current_data,J2K_MS_RGN,2);                                   /* RGN  */
4324         l_current_data += 2;
4325
4326         opj_write_bytes(l_current_data,l_rgn_size-2,2);                                 /* Lrgn */
4327         l_current_data += 2;
4328
4329         opj_write_bytes(l_current_data,p_comp_no,l_comp_room);                          /* Crgn */
4330         l_current_data+=l_comp_room;
4331
4332         opj_write_bytes(l_current_data, 0,1);                                           /* Srgn */
4333         ++l_current_data;
4334
4335         opj_write_bytes(l_current_data, l_tccp->roishift,1);                            /* SPrgn */
4336         ++l_current_data;
4337
4338         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) {
4339                 return OPJ_FALSE;
4340         }
4341
4342         return OPJ_TRUE;
4343 }
4344
4345 OPJ_BOOL opj_j2k_write_eoc(     opj_j2k_t *p_j2k,
4346                             opj_stream_private_t *p_stream,
4347                             opj_event_mgr_t * p_manager
4348                             )
4349 {
4350         /* preconditions */
4351         assert(p_j2k != 00);
4352         assert(p_manager != 00);
4353         assert(p_stream != 00);
4354
4355         opj_write_bytes(p_j2k->m_specific_param.m_encoder.m_header_tile_data,J2K_MS_EOC,2);                                     /* EOC */
4356
4357 /* UniPG>> */
4358 #ifdef USE_JPWL
4359         /* update markers struct */
4360         /*
4361         OPJ_BOOL res = j2k_add_marker(p_j2k->cstr_info, J2K_MS_EOC, p_stream_tell(p_stream) - 2, 2);
4362 */
4363 #endif /* USE_JPWL */
4364
4365         if ( opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,2,p_manager) != 2) {
4366                 return OPJ_FALSE;
4367         }
4368
4369         if ( ! opj_stream_flush(p_stream,p_manager) ) {
4370                 return OPJ_FALSE;
4371         }
4372
4373         return OPJ_TRUE;
4374 }
4375
4376 /**
4377  * Reads a RGN marker (Region Of Interest)
4378  *
4379  * @param       p_header_data   the data contained in the POC box.
4380  * @param       p_j2k                   the jpeg2000 codec.
4381  * @param       p_header_size   the size of the data contained in the POC marker.
4382  * @param       p_manager               the user event manager.
4383 */
4384 static OPJ_BOOL opj_j2k_read_rgn (opj_j2k_t *p_j2k,
4385                                   OPJ_BYTE * p_header_data,
4386                                   OPJ_UINT32 p_header_size,
4387                                   opj_event_mgr_t * p_manager
4388                                   )
4389 {
4390         OPJ_UINT32 l_nb_comp;
4391         opj_image_t * l_image = 00;
4392
4393         opj_cp_t *l_cp = 00;
4394         opj_tcp_t *l_tcp = 00;
4395         OPJ_UINT32 l_comp_room, l_comp_no, l_roi_sty;
4396
4397         /* preconditions*/
4398         assert(p_header_data != 00);
4399         assert(p_j2k != 00);
4400         assert(p_manager != 00);
4401
4402         l_image = p_j2k->m_private_image;
4403         l_nb_comp = l_image->numcomps;
4404
4405         if (l_nb_comp <= 256) {
4406                 l_comp_room = 1; }
4407         else {
4408                 l_comp_room = 2; }
4409
4410         if (p_header_size != 2 + l_comp_room) {
4411                 opj_event_msg(p_manager, EVT_ERROR, "Error reading RGN marker\n");
4412                 return OPJ_FALSE;
4413         }
4414
4415         l_cp = &(p_j2k->m_cp);
4416         l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH) ?
4417                                 &l_cp->tcps[p_j2k->m_current_tile_number] :
4418                                 p_j2k->m_specific_param.m_decoder.m_default_tcp;
4419
4420         opj_read_bytes(p_header_data,&l_comp_no,l_comp_room);           /* Crgn */
4421         p_header_data+=l_comp_room;
4422         opj_read_bytes(p_header_data,&l_roi_sty,1);                                     /* Srgn */
4423         ++p_header_data;
4424
4425 #ifdef USE_JPWL
4426         if (l_cp->correct) {
4427                 /* totlen is negative or larger than the bytes left!!! */
4428                 if (l_comp_room >= l_nb_comp) {
4429                         opj_event_msg(p_manager, EVT_ERROR,
4430                                 "JPWL: bad component number in RGN (%d when there are only %d)\n",
4431                                 l_comp_room, l_nb_comp);
4432                         if (!JPWL_ASSUME || JPWL_ASSUME) {
4433                                 opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n");
4434                                 return OPJ_FALSE;
4435                         }
4436                 }
4437         };
4438 #endif /* USE_JPWL */
4439
4440         opj_read_bytes(p_header_data,(OPJ_UINT32 *) (&(l_tcp->tccps[l_comp_no].roishift)),1);   /* SPrgn */
4441         ++p_header_data;
4442
4443         return OPJ_TRUE;
4444
4445 }
4446
4447 OPJ_FLOAT32 opj_j2k_get_tp_stride (opj_tcp_t * p_tcp)
4448 {
4449         return (OPJ_FLOAT32) ((p_tcp->m_nb_tile_parts - 1) * 14);
4450 }
4451
4452 OPJ_FLOAT32 opj_j2k_get_default_stride (opj_tcp_t * p_tcp)
4453 {
4454     (void)p_tcp;
4455     return 0;
4456 }
4457
4458 OPJ_BOOL opj_j2k_update_rates(  opj_j2k_t *p_j2k,
4459                                                             opj_stream_private_t *p_stream,
4460                                                             opj_event_mgr_t * p_manager )
4461 {
4462         opj_cp_t * l_cp = 00;
4463         opj_image_t * l_image = 00;
4464         opj_tcp_t * l_tcp = 00;
4465         opj_image_comp_t * l_img_comp = 00;
4466
4467         OPJ_UINT32 i,j,k;
4468         OPJ_INT32 l_x0,l_y0,l_x1,l_y1;
4469         OPJ_FLOAT32 * l_rates = 0;
4470         OPJ_FLOAT32 l_sot_remove;
4471         OPJ_UINT32 l_bits_empty, l_size_pixel;
4472         OPJ_UINT32 l_tile_size = 0;
4473         OPJ_UINT32 l_last_res;
4474         OPJ_FLOAT32 (* l_tp_stride_func)(opj_tcp_t *) = 00;
4475
4476         /* preconditions */
4477         assert(p_j2k != 00);
4478         assert(p_manager != 00);
4479         assert(p_stream != 00);
4480
4481         l_cp = &(p_j2k->m_cp);
4482         l_image = p_j2k->m_private_image;
4483         l_tcp = l_cp->tcps;
4484
4485         l_bits_empty = 8 * l_image->comps->dx * l_image->comps->dy;
4486         l_size_pixel = l_image->numcomps * l_image->comps->prec;
4487         l_sot_remove = ((OPJ_FLOAT32) opj_stream_tell(p_stream)) / (l_cp->th * l_cp->tw);
4488
4489         if (l_cp->m_specific_param.m_enc.m_tp_on) {
4490                 l_tp_stride_func = opj_j2k_get_tp_stride;
4491         }
4492         else {
4493                 l_tp_stride_func = opj_j2k_get_default_stride;
4494         }
4495
4496         for (i=0;i<l_cp->th;++i) {
4497                 for (j=0;j<l_cp->tw;++j) {
4498                         OPJ_FLOAT32 l_offset = ((*l_tp_stride_func)(l_tcp)) / l_tcp->numlayers;
4499
4500                         /* 4 borders of the tile rescale on the image if necessary */
4501                         l_x0 = opj_int_max(l_cp->tx0 + j * l_cp->tdx, l_image->x0);
4502                         l_y0 = opj_int_max(l_cp->ty0 + i * l_cp->tdy, l_image->y0);
4503                         l_x1 = opj_int_min(l_cp->tx0 + (j + 1) * l_cp->tdx, l_image->x1);
4504                         l_y1 = opj_int_min(l_cp->ty0 + (i + 1) * l_cp->tdy, l_image->y1);
4505
4506                         l_rates = l_tcp->rates;
4507
4508                         /* Modification of the RATE >> */
4509                         if (*l_rates) {
4510                                 *l_rates =              (( (OPJ_FLOAT32) (l_size_pixel * (l_x1 - l_x0) * (l_y1 - l_y0)))
4511                                                                 /
4512                                                                 ((*l_rates) * l_bits_empty)
4513                                                                 )
4514                                                                 -
4515                                                                 l_offset;
4516                         }
4517
4518                         ++l_rates;
4519
4520                         for (k = 1; k < l_tcp->numlayers; ++k) {
4521                                 if (*l_rates) {
4522                                         *l_rates =              (( (OPJ_FLOAT32) (l_size_pixel * (l_x1 - l_x0) * (l_y1 - l_y0)))
4523                                                                         /
4524                                                                                 ((*l_rates) * l_bits_empty)
4525                                                                         )
4526                                                                         -
4527                                                                         l_offset;
4528                                 }
4529
4530                                 ++l_rates;
4531                         }
4532
4533                         ++l_tcp;
4534
4535                 }
4536         }
4537
4538         l_tcp = l_cp->tcps;
4539
4540         for (i=0;i<l_cp->th;++i) {
4541                 for     (j=0;j<l_cp->tw;++j) {
4542                         l_rates = l_tcp->rates;
4543
4544                         if (*l_rates) {
4545                                 *l_rates -= l_sot_remove;
4546
4547                                 if (*l_rates < 30) {
4548                                         *l_rates = 30;
4549                                 }
4550                         }
4551
4552                         ++l_rates;
4553
4554                         l_last_res = l_tcp->numlayers - 1;
4555
4556                         for (k = 1; k < l_last_res; ++k) {
4557
4558                                 if (*l_rates) {
4559                                         *l_rates -= l_sot_remove;
4560
4561                                         if (*l_rates < *(l_rates - 1) + 10) {
4562                                                 *l_rates  = (*(l_rates - 1)) + 20;
4563                                         }
4564                                 }
4565
4566                                 ++l_rates;
4567                         }
4568
4569                         if (*l_rates) {
4570                                 *l_rates -= (l_sot_remove + 2.f);
4571
4572                                 if (*l_rates < *(l_rates - 1) + 10) {
4573                                         *l_rates  = (*(l_rates - 1)) + 20;
4574                                 }
4575                         }
4576
4577                         ++l_tcp;
4578                 }
4579         }
4580
4581         l_img_comp = l_image->comps;
4582         l_tile_size = 0;
4583
4584         for (i=0;i<l_image->numcomps;++i) {
4585                 l_tile_size += (        opj_uint_ceildiv(l_cp->tdx,l_img_comp->dx)
4586                                                         *
4587                                                         opj_uint_ceildiv(l_cp->tdy,l_img_comp->dy)
4588                                                         *
4589                                                         l_img_comp->prec
4590                                                 );
4591
4592                 ++l_img_comp;
4593         }
4594
4595         l_tile_size = (OPJ_UINT32) (l_tile_size * 0.1625); /* 1.3/8 = 0.1625 */
4596
4597         l_tile_size += opj_j2k_get_specific_header_sizes(p_j2k);
4598
4599         p_j2k->m_specific_param.m_encoder.m_encoded_tile_size = l_tile_size;
4600         p_j2k->m_specific_param.m_encoder.m_encoded_tile_data =
4601                         (OPJ_BYTE *) opj_malloc(p_j2k->m_specific_param.m_encoder.m_encoded_tile_size);
4602         if (p_j2k->m_specific_param.m_encoder.m_encoded_tile_data == 00) {
4603                 return OPJ_FALSE;
4604         }
4605
4606         if (l_cp->m_specific_param.m_enc.m_cinema) {
4607                 p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer =
4608                                 (OPJ_BYTE *) opj_malloc(5*p_j2k->m_specific_param.m_encoder.m_total_tile_parts);
4609                 if (! p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer) {
4610                         return OPJ_FALSE;
4611                 }
4612
4613                 p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current =
4614                                 p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer;
4615         }
4616
4617         return OPJ_TRUE;
4618 }
4619
4620 OPJ_BOOL opj_j2k_read_eoc (     opj_j2k_t *p_j2k,
4621                                                         opj_stream_private_t *p_stream,
4622                                                         opj_event_mgr_t * p_manager )
4623 {
4624         OPJ_UINT32 i;
4625         opj_tcd_t * l_tcd = 00;
4626         OPJ_UINT32 l_nb_tiles;
4627         opj_tcp_t * l_tcp = 00;
4628         OPJ_BOOL l_success;
4629
4630         /* preconditions */
4631         assert(p_j2k != 00);
4632         assert(p_manager != 00);
4633         assert(p_stream != 00);
4634
4635         l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
4636         l_tcp = p_j2k->m_cp.tcps;
4637
4638         l_tcd = opj_tcd_create(OPJ_TRUE);
4639         if (l_tcd == 00) {
4640                 opj_event_msg(p_manager, EVT_ERROR, "Cannot decode tile, memory error\n");
4641                 return OPJ_FALSE;
4642         }
4643
4644         for (i = 0; i < l_nb_tiles; ++i) {
4645                 if (l_tcp->m_data) {
4646                         if (! opj_tcd_init_decode_tile(l_tcd, i)) {
4647                                 opj_tcd_destroy(l_tcd);
4648                                 opj_event_msg(p_manager, EVT_ERROR, "Cannot decode tile, memory error\n");
4649                                 return OPJ_FALSE;
4650                         }
4651
4652                         l_success = opj_tcd_decode_tile(l_tcd, l_tcp->m_data, l_tcp->m_data_size, i, p_j2k->cstr_index);
4653                         /* cleanup */
4654
4655                         if (! l_success) {
4656                                 p_j2k->m_specific_param.m_decoder.m_state |= J2K_STATE_ERR;
4657                                 break;
4658                         }
4659                 }
4660
4661                 opj_j2k_tcp_destroy(l_tcp);
4662                 ++l_tcp;
4663         }
4664
4665         opj_tcd_destroy(l_tcd);
4666         return OPJ_TRUE;
4667 }
4668
4669 OPJ_BOOL opj_j2k_get_end_header(opj_j2k_t *p_j2k,
4670                                                         struct opj_stream_private *p_stream,
4671                                                         struct opj_event_mgr * p_manager )
4672 {
4673         /* preconditions */
4674         assert(p_j2k != 00);
4675         assert(p_manager != 00);
4676         assert(p_stream != 00);
4677
4678         p_j2k->cstr_index->main_head_end = opj_stream_tell(p_stream);
4679
4680         return OPJ_TRUE;
4681 }
4682
4683 OPJ_BOOL opj_j2k_write_mct_data_group(  opj_j2k_t *p_j2k,
4684                                                                         struct opj_stream_private *p_stream,
4685                                                                         struct opj_event_mgr * p_manager )
4686 {
4687         OPJ_UINT32 i;
4688         opj_simple_mcc_decorrelation_data_t * l_mcc_record;
4689         opj_mct_data_t * l_mct_record;
4690         opj_tcp_t * l_tcp;
4691
4692         /* preconditions */
4693         assert(p_j2k != 00);
4694         assert(p_stream != 00);
4695         assert(p_manager != 00);
4696
4697         if (! opj_j2k_write_cbd(p_j2k,p_stream,p_manager)) {
4698                 return OPJ_FALSE;
4699         }
4700
4701         l_tcp = &(p_j2k->m_cp.tcps[p_j2k->m_current_tile_number]);
4702         l_mct_record = l_tcp->m_mct_records;
4703
4704         for (i=0;i<l_tcp->m_nb_mct_records;++i) {
4705
4706                 if (! opj_j2k_write_mct_record(p_j2k,l_mct_record,p_stream,p_manager)) {
4707                         return OPJ_FALSE;
4708                 }
4709
4710                 ++l_mct_record;
4711         }
4712
4713         l_mcc_record = l_tcp->m_mcc_records;
4714
4715         for     (i=0;i<l_tcp->m_nb_mcc_records;++i) {
4716
4717                 if (! opj_j2k_write_mcc_record(p_j2k,l_mcc_record,p_stream,p_manager)) {
4718                         return OPJ_FALSE;
4719                 }
4720
4721                 ++l_mcc_record;
4722         }
4723
4724         if (! opj_j2k_write_mco(p_j2k,p_stream,p_manager)) {
4725                 return OPJ_FALSE;
4726         }
4727
4728         return OPJ_TRUE;
4729 }
4730
4731 OPJ_BOOL opj_j2k_write_image_components(opj_j2k_t *p_j2k,
4732                                                                         struct opj_stream_private *p_stream,
4733                                                                         struct opj_event_mgr * p_manager )
4734 {
4735         OPJ_UINT32 compno;
4736
4737         /* preconditions */
4738         assert(p_j2k != 00);
4739         assert(p_manager != 00);
4740         assert(p_stream != 00);
4741
4742         for (compno = 1; compno < p_j2k->m_private_image->numcomps; ++compno)
4743         {
4744                 if (! opj_j2k_write_coc(p_j2k,compno,p_stream, p_manager)) {
4745                         return OPJ_FALSE;
4746                 }
4747
4748                 if (! opj_j2k_write_qcc(p_j2k,compno,p_stream, p_manager)) {
4749                         return OPJ_FALSE;
4750                 }
4751         }
4752
4753         return OPJ_TRUE;
4754 }
4755
4756 OPJ_BOOL opj_j2k_write_regions( opj_j2k_t *p_j2k,
4757                                                         struct opj_stream_private *p_stream,
4758                                                         struct opj_event_mgr * p_manager )
4759 {
4760         OPJ_UINT32 compno;
4761         const opj_tccp_t *l_tccp = 00;
4762
4763         /* preconditions */
4764         assert(p_j2k != 00);
4765         assert(p_manager != 00);
4766         assert(p_stream != 00);
4767
4768         l_tccp = p_j2k->m_cp.tcps->tccps;
4769
4770         for     (compno = 0; compno < p_j2k->m_private_image->numcomps; ++compno)  {
4771                 if (l_tccp->roishift) {
4772
4773                         if (! opj_j2k_write_rgn(p_j2k,0,compno,p_j2k->m_private_image->numcomps,p_stream,p_manager)) {
4774                                 return OPJ_FALSE;
4775                         }
4776                 }
4777
4778                 ++l_tccp;
4779         }
4780
4781         return OPJ_TRUE;
4782 }
4783
4784 OPJ_BOOL opj_j2k_write_epc(     opj_j2k_t *p_j2k,
4785                                                 struct opj_stream_private *p_stream,
4786                                                 struct opj_event_mgr * p_manager )
4787 {
4788         opj_codestream_index_t * l_cstr_index = 00;
4789
4790         /* preconditions */
4791         assert(p_j2k != 00);
4792         assert(p_manager != 00);
4793         assert(p_stream != 00);
4794
4795         l_cstr_index = p_j2k->cstr_index;
4796         if (l_cstr_index) {
4797                 l_cstr_index->codestream_size = opj_stream_tell(p_stream);
4798                 /* UniPG>> */
4799                 /* The following adjustment is done to adjust the codestream size */
4800                 /* if SOD is not at 0 in the buffer. Useful in case of JP2, where */
4801                 /* the first bunch of bytes is not in the codestream              */
4802                 l_cstr_index->codestream_size -= l_cstr_index->main_head_start;
4803                 /* <<UniPG */
4804         }
4805
4806 #ifdef USE_JPWL
4807         /* preparation of JPWL marker segments */
4808 #if 0
4809         if(cp->epc_on) {
4810
4811                 /* encode according to JPWL */
4812                 jpwl_encode(p_j2k, p_stream, image);
4813
4814         }
4815 #endif
4816   assert( 0 && "TODO" );
4817 #endif /* USE_JPWL */
4818
4819         return OPJ_TRUE;
4820 }
4821
4822 OPJ_BOOL opj_j2k_read_unk (     opj_j2k_t *p_j2k,
4823                                                         opj_stream_private_t *p_stream,
4824                                                         OPJ_UINT32 *output_marker,
4825                                                         opj_event_mgr_t * p_manager
4826                                                         )
4827 {
4828         OPJ_UINT32 l_unknown_marker;
4829         const opj_dec_memory_marker_handler_t * l_marker_handler;
4830         OPJ_UINT32 l_size_unk = 2;
4831
4832         /* preconditions*/
4833         assert(p_j2k != 00);
4834         assert(p_manager != 00);
4835         assert(p_stream != 00);
4836
4837         opj_event_msg(p_manager, EVT_WARNING, "Unknown marker\n");
4838
4839         while(1) {
4840                 /* Try to read 2 bytes (the next marker ID) from stream and copy them into the buffer*/
4841                 if (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,2,p_manager) != 2) {
4842                         opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
4843                         return OPJ_FALSE;
4844                 }
4845
4846                 /* read 2 bytes as the new marker ID*/
4847                 opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,&l_unknown_marker,2);
4848
4849                 if (!(l_unknown_marker < 0xff00)) {
4850
4851                         /* Get the marker handler from the marker ID*/
4852                         l_marker_handler = opj_j2k_get_marker_handler(l_unknown_marker);
4853
4854                         if (!(p_j2k->m_specific_param.m_decoder.m_state & l_marker_handler->states)) {
4855                                 opj_event_msg(p_manager, EVT_ERROR, "Marker is not compliant with its position\n");
4856                                 return OPJ_FALSE;
4857                         }
4858                         else {
4859                                 if (l_marker_handler->id != J2K_MS_UNK) {
4860                                         /* Add the marker to the codestream index*/
4861                                         if (l_marker_handler->id != J2K_MS_SOT)
4862                                         {
4863                                                 OPJ_BOOL res = opj_j2k_add_mhmarker(p_j2k->cstr_index, J2K_MS_UNK,
4864                                                                 (OPJ_UINT32) opj_stream_tell(p_stream) - l_size_unk,
4865                                                                 l_size_unk);
4866                                                 if (res == OPJ_FALSE) {
4867                                                         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to add mh marker\n");
4868                                                         return OPJ_FALSE;
4869                                                 }
4870                                         }
4871                                         break; /* next marker is known and well located */
4872                                 }
4873                                 else
4874                                         l_size_unk += 2;
4875                         }
4876                 }
4877         }
4878
4879         *output_marker = l_marker_handler->id ;
4880
4881         return OPJ_TRUE;
4882 }
4883
4884 OPJ_BOOL opj_j2k_write_mct_record(      opj_j2k_t *p_j2k,
4885                                                                 opj_mct_data_t * p_mct_record,
4886                                                                 struct opj_stream_private *p_stream,
4887                                                                 struct opj_event_mgr * p_manager )
4888 {
4889         OPJ_UINT32 l_mct_size;
4890         OPJ_BYTE * l_current_data = 00;
4891         OPJ_UINT32 l_tmp;
4892
4893         /* preconditions */
4894         assert(p_j2k != 00);
4895         assert(p_manager != 00);
4896         assert(p_stream != 00);
4897
4898         l_mct_size = 10 + p_mct_record->m_data_size;
4899
4900         if (l_mct_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) {
4901                 OPJ_BYTE *new_header_tile_data = (OPJ_BYTE *) opj_realloc(p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_mct_size);
4902                 if (! new_header_tile_data) {
4903                         opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
4904                         p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL;
4905                         p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
4906                         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write MCT marker\n");
4907                         return OPJ_FALSE;
4908                 }
4909                 p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data;
4910                 p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_mct_size;
4911         }
4912
4913         l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
4914
4915         opj_write_bytes(l_current_data,J2K_MS_MCT,2);                                   /* MCT */
4916         l_current_data += 2;
4917
4918         opj_write_bytes(l_current_data,l_mct_size-2,2);                                 /* Lmct */
4919         l_current_data += 2;
4920
4921         opj_write_bytes(l_current_data,0,2);                                                    /* Zmct */
4922         l_current_data += 2;
4923
4924         /* only one marker atm */
4925         l_tmp = (p_mct_record->m_index & 0xff) | (p_mct_record->m_array_type << 8) | (p_mct_record->m_element_type << 10);
4926
4927         opj_write_bytes(l_current_data,l_tmp,2);
4928         l_current_data += 2;
4929
4930         opj_write_bytes(l_current_data,0,2);                                                    /* Ymct */
4931         l_current_data+=2;
4932
4933         memcpy(l_current_data,p_mct_record->m_data,p_mct_record->m_data_size);
4934
4935         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) {
4936                 return OPJ_FALSE;
4937         }
4938
4939         return OPJ_TRUE;
4940 }
4941
4942 /**
4943  * Reads a MCT marker (Multiple Component Transform)
4944  *
4945  * @param       p_header_data   the data contained in the MCT box.
4946  * @param       p_j2k                   the jpeg2000 codec.
4947  * @param       p_header_size   the size of the data contained in the MCT marker.
4948  * @param       p_manager               the user event manager.
4949 */
4950 static OPJ_BOOL opj_j2k_read_mct (      opj_j2k_t *p_j2k,
4951                                                                     OPJ_BYTE * p_header_data,
4952                                                                     OPJ_UINT32 p_header_size,
4953                                                                     opj_event_mgr_t * p_manager
4954                                     )
4955 {
4956         OPJ_UINT32 i;
4957         opj_tcp_t *l_tcp = 00;
4958         OPJ_UINT32 l_tmp;
4959         OPJ_UINT32 l_indix;
4960         opj_mct_data_t * l_mct_data;
4961
4962         /* preconditions */
4963         assert(p_header_data != 00);
4964         assert(p_j2k != 00);
4965
4966         l_tcp = p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH ?
4967                         &p_j2k->m_cp.tcps[p_j2k->m_current_tile_number] :
4968                         p_j2k->m_specific_param.m_decoder.m_default_tcp;
4969
4970         if (p_header_size < 2) {
4971                 opj_event_msg(p_manager, EVT_ERROR, "Error reading MCT marker\n");
4972                 return OPJ_FALSE;
4973         }
4974
4975         /* first marker */
4976         opj_read_bytes(p_header_data,&l_tmp,2);                         /* Zmct */
4977         p_header_data += 2;
4978         if (l_tmp != 0) {
4979                 opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge mct data within multiple MCT records\n");
4980                 return OPJ_TRUE;
4981         }
4982
4983         if(p_header_size <= 6) {
4984                 opj_event_msg(p_manager, EVT_ERROR, "Error reading MCT marker\n");
4985                 return OPJ_FALSE;
4986         }
4987
4988         /* Imct -> no need for other values, take the first, type is double with decorrelation x0000 1101 0000 0000*/
4989         opj_read_bytes(p_header_data,&l_tmp,2);                         /* Imct */
4990         p_header_data += 2;
4991
4992         l_indix = l_tmp & 0xff;
4993         l_mct_data = l_tcp->m_mct_records;
4994
4995         for (i=0;i<l_tcp->m_nb_mct_records;++i) {
4996                 if (l_mct_data->m_index == l_indix) {
4997                         break;
4998                 }
4999                 ++l_mct_data;
5000         }
5001
5002         /* NOT FOUND */
5003         if (i == l_tcp->m_nb_mct_records) {
5004                 if (l_tcp->m_nb_mct_records == l_tcp->m_nb_max_mct_records) {
5005                         opj_mct_data_t *new_mct_records;
5006                         l_tcp->m_nb_max_mct_records += OPJ_J2K_MCT_DEFAULT_NB_RECORDS;
5007
5008                         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));
5009                         if (! new_mct_records) {
5010                                 opj_free(l_tcp->m_mct_records);
5011                                 l_tcp->m_mct_records = NULL;
5012                                 l_tcp->m_nb_max_mct_records = 0;
5013                                 l_tcp->m_nb_mct_records = 0;
5014                                 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read MCT marker\n");
5015                                 return OPJ_FALSE;
5016                         }
5017                         l_tcp->m_mct_records = new_mct_records;
5018                         l_mct_data = l_tcp->m_mct_records + l_tcp->m_nb_mct_records;
5019                         memset(l_mct_data ,0,(l_tcp->m_nb_max_mct_records - l_tcp->m_nb_mct_records) * sizeof(opj_mct_data_t));
5020                 }
5021
5022                 l_mct_data = l_tcp->m_mct_records + l_tcp->m_nb_mct_records;
5023         }
5024
5025         if (l_mct_data->m_data) {
5026                 opj_free(l_mct_data->m_data);
5027                 l_mct_data->m_data = 00;
5028         }
5029
5030         l_mct_data->m_index = l_indix;
5031         l_mct_data->m_array_type = (J2K_MCT_ARRAY_TYPE)((l_tmp  >> 8) & 3);
5032         l_mct_data->m_element_type = (J2K_MCT_ELEMENT_TYPE)((l_tmp  >> 10) & 3);
5033
5034         opj_read_bytes(p_header_data,&l_tmp,2);                         /* Ymct */
5035         p_header_data+=2;
5036         if (l_tmp != 0) {
5037                 opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge multiple MCT markers\n");
5038                 return OPJ_TRUE;
5039         }
5040
5041         p_header_size -= 6;
5042
5043         l_mct_data->m_data = (OPJ_BYTE*)opj_malloc(p_header_size);
5044         if (! l_mct_data->m_data) {
5045                 opj_event_msg(p_manager, EVT_ERROR, "Error reading MCT marker\n");
5046                 return OPJ_FALSE;
5047         }
5048         memcpy(l_mct_data->m_data,p_header_data,p_header_size);
5049
5050         l_mct_data->m_data_size = p_header_size;
5051         ++l_tcp->m_nb_mct_records;
5052
5053         return OPJ_TRUE;
5054 }
5055
5056 OPJ_BOOL opj_j2k_write_mcc_record(      opj_j2k_t *p_j2k,
5057                                                                 struct opj_simple_mcc_decorrelation_data * p_mcc_record,
5058                                                                 struct opj_stream_private *p_stream,
5059                                                                 struct opj_event_mgr * p_manager )
5060 {
5061         OPJ_UINT32 i;
5062         OPJ_UINT32 l_mcc_size;
5063         OPJ_BYTE * l_current_data = 00;
5064         OPJ_UINT32 l_nb_bytes_for_comp;
5065         OPJ_UINT32 l_mask;
5066         OPJ_UINT32 l_tmcc;
5067
5068         /* preconditions */
5069         assert(p_j2k != 00);
5070         assert(p_manager != 00);
5071         assert(p_stream != 00);
5072
5073         if (p_mcc_record->m_nb_comps > 255 ) {
5074         l_nb_bytes_for_comp = 2;
5075                 l_mask = 0x8000;
5076         }
5077         else {
5078                 l_nb_bytes_for_comp = 1;
5079                 l_mask = 0;
5080         }
5081
5082         l_mcc_size = p_mcc_record->m_nb_comps * 2 * l_nb_bytes_for_comp + 19;
5083         if (l_mcc_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size)
5084         {
5085                 OPJ_BYTE *new_header_tile_data = (OPJ_BYTE *) opj_realloc(p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_mcc_size);
5086                 if (! new_header_tile_data) {
5087                         opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
5088                         p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL;
5089                         p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
5090                         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write MCC marker\n");
5091                         return OPJ_FALSE;
5092                 }
5093                 p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data;
5094                 p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_mcc_size;
5095         }
5096
5097         l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
5098
5099         opj_write_bytes(l_current_data,J2K_MS_MCC,2);                                   /* MCC */
5100         l_current_data += 2;
5101
5102         opj_write_bytes(l_current_data,l_mcc_size-2,2);                                 /* Lmcc */
5103         l_current_data += 2;
5104
5105         /* first marker */
5106         opj_write_bytes(l_current_data,0,2);                                    /* Zmcc */
5107         l_current_data += 2;
5108
5109         opj_write_bytes(l_current_data,p_mcc_record->m_index,1);                                        /* Imcc -> no need for other values, take the first */
5110         ++l_current_data;
5111
5112         /* only one marker atm */
5113         opj_write_bytes(l_current_data,0,2);                                    /* Ymcc */
5114         l_current_data+=2;
5115
5116         opj_write_bytes(l_current_data,1,2);                                    /* Qmcc -> number of collections -> 1 */
5117         l_current_data+=2;
5118
5119         opj_write_bytes(l_current_data,0x1,1);                                  /* Xmcci type of component transformation -> array based decorrelation */
5120         ++l_current_data;
5121
5122         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 */
5123         l_current_data+=2;
5124
5125         for (i=0;i<p_mcc_record->m_nb_comps;++i) {
5126                 opj_write_bytes(l_current_data,i,l_nb_bytes_for_comp);                          /* Cmccij Component offset*/
5127                 l_current_data+=l_nb_bytes_for_comp;
5128         }
5129
5130         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 */
5131         l_current_data+=2;
5132
5133         for (i=0;i<p_mcc_record->m_nb_comps;++i)
5134         {
5135                 opj_write_bytes(l_current_data,i,l_nb_bytes_for_comp);                          /* Wmccij Component offset*/
5136                 l_current_data+=l_nb_bytes_for_comp;
5137         }
5138
5139         l_tmcc = ((!p_mcc_record->m_is_irreversible)&1)<<16;
5140
5141         if (p_mcc_record->m_decorrelation_array) {
5142                 l_tmcc |= p_mcc_record->m_decorrelation_array->m_index;
5143         }
5144
5145         if (p_mcc_record->m_offset_array) {
5146                 l_tmcc |= ((p_mcc_record->m_offset_array->m_index)<<8);
5147         }
5148
5149         opj_write_bytes(l_current_data,l_tmcc,3);       /* Tmcci : use MCT defined as number 1 and irreversible array based. */
5150         l_current_data+=3;
5151
5152         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) {
5153                 return OPJ_FALSE;
5154         }
5155
5156         return OPJ_TRUE;
5157 }
5158
5159 OPJ_BOOL opj_j2k_read_mcc (     opj_j2k_t *p_j2k,
5160                                                 OPJ_BYTE * p_header_data,
5161                                                 OPJ_UINT32 p_header_size,
5162                                                 opj_event_mgr_t * p_manager )
5163 {
5164         OPJ_UINT32 i,j;
5165         OPJ_UINT32 l_tmp;
5166         OPJ_UINT32 l_indix;
5167         opj_tcp_t * l_tcp;
5168         opj_simple_mcc_decorrelation_data_t * l_mcc_record;
5169         opj_mct_data_t * l_mct_data;
5170         OPJ_UINT32 l_nb_collections;
5171         OPJ_UINT32 l_nb_comps;
5172         OPJ_UINT32 l_nb_bytes_by_comp;
5173
5174         /* preconditions */
5175         assert(p_header_data != 00);
5176         assert(p_j2k != 00);
5177         assert(p_manager != 00);
5178
5179         l_tcp = p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH ?
5180                         &p_j2k->m_cp.tcps[p_j2k->m_current_tile_number] :
5181                         p_j2k->m_specific_param.m_decoder.m_default_tcp;
5182
5183         if (p_header_size < 2) {
5184                 opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
5185                 return OPJ_FALSE;
5186         }
5187
5188         /* first marker */
5189         opj_read_bytes(p_header_data,&l_tmp,2);                         /* Zmcc */
5190         p_header_data += 2;
5191         if (l_tmp != 0) {
5192                 opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge multiple data spanning\n");
5193                 return OPJ_TRUE;
5194         }
5195
5196         if (p_header_size < 7) {
5197                 opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
5198                 return OPJ_FALSE;
5199         }
5200
5201         opj_read_bytes(p_header_data,&l_indix,1); /* Imcc -> no need for other values, take the first */
5202         ++p_header_data;
5203
5204         l_mcc_record = l_tcp->m_mcc_records;
5205
5206         for(i=0;i<l_tcp->m_nb_mcc_records;++i) {
5207                 if (l_mcc_record->m_index == l_indix) {
5208                         break;
5209                 }
5210                 ++l_mcc_record;
5211         }
5212
5213         /** NOT FOUND */
5214         if (i == l_tcp->m_nb_mcc_records) {
5215                 if (l_tcp->m_nb_mcc_records == l_tcp->m_nb_max_mcc_records) {
5216                         opj_simple_mcc_decorrelation_data_t *new_mcc_records;
5217                         l_tcp->m_nb_max_mcc_records += OPJ_J2K_MCC_DEFAULT_NB_RECORDS;
5218
5219                         new_mcc_records = (opj_simple_mcc_decorrelation_data_t *) opj_realloc(
5220                                         l_tcp->m_mcc_records, l_tcp->m_nb_max_mcc_records * sizeof(opj_simple_mcc_decorrelation_data_t));
5221                         if (! new_mcc_records) {
5222                                 opj_free(l_tcp->m_mcc_records);
5223                                 l_tcp->m_mcc_records = NULL;
5224                                 l_tcp->m_nb_max_mcc_records = 0;
5225                                 l_tcp->m_nb_mcc_records = 0;
5226                                 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read MCC marker\n");
5227                                 return OPJ_FALSE;
5228                         }
5229                         l_tcp->m_mcc_records = new_mcc_records;
5230                         l_mcc_record = l_tcp->m_mcc_records + l_tcp->m_nb_mcc_records;
5231                         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));
5232                 }
5233                 l_mcc_record = l_tcp->m_mcc_records + l_tcp->m_nb_mcc_records;
5234         }
5235         l_mcc_record->m_index = l_indix;
5236
5237         /* only one marker atm */
5238         opj_read_bytes(p_header_data,&l_tmp,2);                         /* Ymcc */
5239         p_header_data+=2;
5240         if (l_tmp != 0) {
5241                 opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge multiple data spanning\n");
5242                 return OPJ_TRUE;
5243         }
5244
5245         opj_read_bytes(p_header_data,&l_nb_collections,2);                              /* Qmcc -> number of collections -> 1 */
5246         p_header_data+=2;
5247
5248         if (l_nb_collections > 1) {
5249                 opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge multiple collections\n");
5250                 return OPJ_TRUE;
5251         }
5252
5253         p_header_size -= 7;
5254
5255         for (i=0;i<l_nb_collections;++i) {
5256                 if (p_header_size < 3) {
5257                         opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
5258                         return OPJ_FALSE;
5259                 }
5260
5261                 opj_read_bytes(p_header_data,&l_tmp,1); /* Xmcci type of component transformation -> array based decorrelation */
5262                 ++p_header_data;
5263
5264                 if (l_tmp != 1) {
5265                         opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge collections other than array decorrelation\n");
5266                         return OPJ_TRUE;
5267                 }
5268
5269                 opj_read_bytes(p_header_data,&l_nb_comps,2);
5270
5271                 p_header_data+=2;
5272                 p_header_size-=3;
5273
5274                 l_nb_bytes_by_comp = 1 + (l_nb_comps>>15);
5275                 l_mcc_record->m_nb_comps = l_nb_comps & 0x7fff;
5276
5277                 if (p_header_size < (l_nb_bytes_by_comp * l_mcc_record->m_nb_comps + 2)) {
5278                         opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
5279                         return OPJ_FALSE;
5280                 }
5281
5282                 p_header_size -= (l_nb_bytes_by_comp * l_mcc_record->m_nb_comps + 2);
5283
5284                 for (j=0;j<l_mcc_record->m_nb_comps;++j) {
5285                         opj_read_bytes(p_header_data,&l_tmp,l_nb_bytes_by_comp);        /* Cmccij Component offset*/
5286                         p_header_data+=l_nb_bytes_by_comp;
5287
5288                         if (l_tmp != j) {
5289                                 opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge collections with indix shuffle\n");
5290                                 return OPJ_TRUE;
5291                         }
5292                 }
5293
5294                 opj_read_bytes(p_header_data,&l_nb_comps,2);
5295                 p_header_data+=2;
5296
5297                 l_nb_bytes_by_comp = 1 + (l_nb_comps>>15);
5298                 l_nb_comps &= 0x7fff;
5299
5300                 if (l_nb_comps != l_mcc_record->m_nb_comps) {
5301                         opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge collections without same number of indixes\n");
5302                         return OPJ_TRUE;
5303                 }
5304
5305                 if (p_header_size < (l_nb_bytes_by_comp * l_mcc_record->m_nb_comps + 3)) {
5306                         opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
5307                         return OPJ_FALSE;
5308                 }
5309
5310                 p_header_size -= (l_nb_bytes_by_comp * l_mcc_record->m_nb_comps + 3);
5311
5312                 for (j=0;j<l_mcc_record->m_nb_comps;++j) {
5313                         opj_read_bytes(p_header_data,&l_tmp,l_nb_bytes_by_comp);        /* Wmccij Component offset*/
5314                         p_header_data+=l_nb_bytes_by_comp;
5315
5316                         if (l_tmp != j) {
5317                                 opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge collections with indix shuffle\n");
5318                                 return OPJ_TRUE;
5319                         }
5320                 }
5321
5322                 opj_read_bytes(p_header_data,&l_tmp,3); /* Wmccij Component offset*/
5323                 p_header_data += 3;
5324
5325                 l_mcc_record->m_is_irreversible = ! ((l_tmp>>16) & 1);
5326                 l_mcc_record->m_decorrelation_array = 00;
5327                 l_mcc_record->m_offset_array = 00;
5328
5329                 l_indix = l_tmp & 0xff;
5330                 if (l_indix != 0) {
5331                         l_mct_data = l_tcp->m_mct_records;
5332                         for (j=0;j<l_tcp->m_nb_mct_records;++j) {
5333                                 if (l_mct_data->m_index == l_indix) {
5334                                         l_mcc_record->m_decorrelation_array = l_mct_data;
5335                                         break;
5336                                 }
5337                                 ++l_mct_data;
5338                         }
5339
5340                         if (l_mcc_record->m_decorrelation_array == 00) {
5341                                 opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
5342                                 return OPJ_FALSE;
5343                         }
5344                 }
5345
5346                 l_indix = (l_tmp >> 8) & 0xff;
5347                 if (l_indix != 0) {
5348                         l_mct_data = l_tcp->m_mct_records;
5349                         for (j=0;j<l_tcp->m_nb_mct_records;++j) {
5350                                 if (l_mct_data->m_index == l_indix) {
5351                                         l_mcc_record->m_offset_array = l_mct_data;
5352                                         break;
5353                                 }
5354                                 ++l_mct_data;
5355                         }
5356
5357                         if (l_mcc_record->m_offset_array == 00) {
5358                                 opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
5359                                 return OPJ_FALSE;
5360                         }
5361                 }
5362         }
5363
5364         if (p_header_size != 0) {
5365                 opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
5366                 return OPJ_FALSE;
5367         }
5368
5369         ++l_tcp->m_nb_mcc_records;
5370
5371         return OPJ_TRUE;
5372 }
5373
5374 OPJ_BOOL opj_j2k_write_mco(     opj_j2k_t *p_j2k,
5375                                                 struct opj_stream_private *p_stream,
5376                                                 struct opj_event_mgr * p_manager
5377                                   )
5378 {
5379         OPJ_BYTE * l_current_data = 00;
5380         OPJ_UINT32 l_mco_size;
5381         opj_tcp_t * l_tcp = 00;
5382         opj_simple_mcc_decorrelation_data_t * l_mcc_record;
5383         OPJ_UINT32 i;
5384
5385         /* preconditions */
5386         assert(p_j2k != 00);
5387         assert(p_manager != 00);
5388         assert(p_stream != 00);
5389
5390         l_tcp =&(p_j2k->m_cp.tcps[p_j2k->m_current_tile_number]);
5391         l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
5392
5393         l_mco_size = 5 + l_tcp->m_nb_mcc_records;
5394         if (l_mco_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) {
5395
5396                 OPJ_BYTE *new_header_tile_data = (OPJ_BYTE *) opj_realloc(p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_mco_size);
5397                 if (! new_header_tile_data) {
5398                         opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
5399                         p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL;
5400                         p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
5401                         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write MCO marker\n");
5402                         return OPJ_FALSE;
5403                 }
5404                 p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data;
5405                 p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_mco_size;
5406         }
5407
5408         opj_write_bytes(l_current_data,J2K_MS_MCO,2);                   /* MCO */
5409         l_current_data += 2;
5410
5411         opj_write_bytes(l_current_data,l_mco_size-2,2);                 /* Lmco */
5412         l_current_data += 2;
5413
5414         opj_write_bytes(l_current_data,l_tcp->m_nb_mcc_records,1);      /* Nmco : only one tranform stage*/
5415         ++l_current_data;
5416
5417         l_mcc_record = l_tcp->m_mcc_records;
5418         for     (i=0;i<l_tcp->m_nb_mcc_records;++i) {
5419                 opj_write_bytes(l_current_data,l_mcc_record->m_index,1);/* Imco -> use the mcc indicated by 1*/
5420                 ++l_current_data;
5421
5422                 ++l_mcc_record;
5423         }
5424
5425         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) {
5426                 return OPJ_FALSE;
5427         }
5428
5429         return OPJ_TRUE;
5430 }
5431
5432 /**
5433  * Reads a MCO marker (Multiple Component Transform Ordering)
5434  *
5435  * @param       p_header_data   the data contained in the MCO box.
5436  * @param       p_j2k                   the jpeg2000 codec.
5437  * @param       p_header_size   the size of the data contained in the MCO marker.
5438  * @param       p_manager               the user event manager.
5439 */
5440 static OPJ_BOOL opj_j2k_read_mco (      opj_j2k_t *p_j2k,
5441                                                                     OPJ_BYTE * p_header_data,
5442                                                                     OPJ_UINT32 p_header_size,
5443                                                                     opj_event_mgr_t * p_manager
5444                                     )
5445 {
5446         OPJ_UINT32 l_tmp, i;
5447         OPJ_UINT32 l_nb_stages;
5448         opj_tcp_t * l_tcp;
5449         opj_tccp_t * l_tccp;
5450         opj_image_t * l_image;
5451
5452         /* preconditions */
5453         assert(p_header_data != 00);
5454         assert(p_j2k != 00);
5455         assert(p_manager != 00);
5456
5457         l_image = p_j2k->m_private_image;
5458         l_tcp = p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH ?
5459                         &p_j2k->m_cp.tcps[p_j2k->m_current_tile_number] :
5460                         p_j2k->m_specific_param.m_decoder.m_default_tcp;
5461
5462         if (p_header_size < 1) {
5463                 opj_event_msg(p_manager, EVT_ERROR, "Error reading MCO marker\n");
5464                 return OPJ_FALSE;
5465         }
5466
5467         opj_read_bytes(p_header_data,&l_nb_stages,1);                           /* Nmco : only one tranform stage*/
5468         ++p_header_data;
5469
5470         if (l_nb_stages > 1) {
5471                 opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge multiple transformation stages.\n");
5472                 return OPJ_TRUE;
5473         }
5474
5475         if (p_header_size != l_nb_stages + 1) {
5476                 opj_event_msg(p_manager, EVT_WARNING, "Error reading MCO marker\n");
5477                 return OPJ_FALSE;
5478         }
5479
5480         l_tccp = l_tcp->tccps;
5481
5482         for (i=0;i<l_image->numcomps;++i) {
5483                 l_tccp->m_dc_level_shift = 0;
5484                 ++l_tccp;
5485         }
5486
5487         if (l_tcp->m_mct_decoding_matrix) {
5488                 opj_free(l_tcp->m_mct_decoding_matrix);
5489                 l_tcp->m_mct_decoding_matrix = 00;
5490         }
5491
5492         for (i=0;i<l_nb_stages;++i) {
5493                 opj_read_bytes(p_header_data,&l_tmp,1);
5494                 ++p_header_data;
5495
5496                 if (! opj_j2k_add_mct(l_tcp,p_j2k->m_private_image,l_tmp)) {
5497                         return OPJ_FALSE;
5498                 }
5499         }
5500
5501         return OPJ_TRUE;
5502 }
5503
5504 OPJ_BOOL opj_j2k_add_mct(opj_tcp_t * p_tcp, opj_image_t * p_image, OPJ_UINT32 p_index)
5505 {
5506         OPJ_UINT32 i;
5507         opj_simple_mcc_decorrelation_data_t * l_mcc_record;
5508         opj_mct_data_t * l_deco_array, * l_offset_array;
5509         OPJ_UINT32 l_data_size,l_mct_size, l_offset_size;
5510         OPJ_UINT32 l_nb_elem;
5511         OPJ_UINT32 * l_offset_data, * l_current_offset_data;
5512         opj_tccp_t * l_tccp;
5513
5514         /* preconditions */
5515         assert(p_tcp != 00);
5516
5517         l_mcc_record = p_tcp->m_mcc_records;
5518
5519         for (i=0;i<p_tcp->m_nb_mcc_records;++i) {
5520                 if (l_mcc_record->m_index == p_index) {
5521                         break;
5522                 }
5523         }
5524
5525         if (i==p_tcp->m_nb_mcc_records) {
5526                 /** element discarded **/
5527                 return OPJ_TRUE;
5528         }
5529
5530         if (l_mcc_record->m_nb_comps != p_image->numcomps) {
5531                 /** do not support number of comps != image */
5532                 return OPJ_TRUE;
5533         }
5534
5535         l_deco_array = l_mcc_record->m_decorrelation_array;
5536
5537         if (l_deco_array) {
5538                 l_data_size = MCT_ELEMENT_SIZE[l_deco_array->m_element_type] * p_image->numcomps * p_image->numcomps;
5539                 if (l_deco_array->m_data_size != l_data_size) {
5540                         return OPJ_FALSE;
5541                 }
5542
5543                 l_nb_elem = p_image->numcomps * p_image->numcomps;
5544                 l_mct_size = l_nb_elem * sizeof(OPJ_FLOAT32);
5545                 p_tcp->m_mct_decoding_matrix = (OPJ_FLOAT32*)opj_malloc(l_mct_size);
5546
5547                 if (! p_tcp->m_mct_decoding_matrix ) {
5548                         return OPJ_FALSE;
5549                 }
5550
5551                 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);
5552         }
5553
5554         l_offset_array = l_mcc_record->m_offset_array;
5555
5556         if (l_offset_array) {
5557                 l_data_size = MCT_ELEMENT_SIZE[l_offset_array->m_element_type] * p_image->numcomps;
5558                 if (l_offset_array->m_data_size != l_data_size) {
5559                         return OPJ_FALSE;
5560                 }
5561
5562                 l_nb_elem = p_image->numcomps;
5563                 l_offset_size = l_nb_elem * sizeof(OPJ_UINT32);
5564                 l_offset_data = (OPJ_UINT32*)opj_malloc(l_offset_size);
5565
5566                 if (! l_offset_data ) {
5567                         return OPJ_FALSE;
5568                 }
5569
5570                 j2k_mct_read_functions_to_int32[l_offset_array->m_element_type](l_offset_array->m_data,l_offset_data,l_nb_elem);
5571
5572                 l_tccp = p_tcp->tccps;
5573                 l_current_offset_data = l_offset_data;
5574
5575                 for (i=0;i<p_image->numcomps;++i) {
5576                         l_tccp->m_dc_level_shift = *(l_current_offset_data++);
5577                         ++l_tccp;
5578                 }
5579
5580                 opj_free(l_offset_data);
5581         }
5582
5583         return OPJ_TRUE;
5584 }
5585
5586 OPJ_BOOL opj_j2k_write_cbd( opj_j2k_t *p_j2k,
5587                                                 struct opj_stream_private *p_stream,
5588                                                 struct opj_event_mgr * p_manager )
5589 {
5590         OPJ_UINT32 i;
5591         OPJ_UINT32 l_cbd_size;
5592         OPJ_BYTE * l_current_data = 00;
5593         opj_image_t *l_image = 00;
5594         opj_image_comp_t * l_comp = 00;
5595
5596         /* preconditions */
5597         assert(p_j2k != 00);
5598         assert(p_manager != 00);
5599         assert(p_stream != 00);
5600
5601         l_image = p_j2k->m_private_image;
5602         l_cbd_size = 6 + p_j2k->m_private_image->numcomps;
5603
5604         if (l_cbd_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) {
5605                 OPJ_BYTE *new_header_tile_data = (OPJ_BYTE *) opj_realloc(p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_cbd_size);
5606                 if (! new_header_tile_data) {
5607                         opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
5608                         p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL;
5609                         p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
5610                         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write CBD marker\n");
5611                         return OPJ_FALSE;
5612                 }
5613                 p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data;
5614                 p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_cbd_size;
5615         }
5616
5617         l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
5618
5619         opj_write_bytes(l_current_data,J2K_MS_CBD,2);                   /* CBD */
5620         l_current_data += 2;
5621
5622         opj_write_bytes(l_current_data,l_cbd_size-2,2);                 /* L_CBD */
5623         l_current_data += 2;
5624
5625         opj_write_bytes(l_current_data,l_image->numcomps, 2);           /* Ncbd */
5626         l_current_data+=2;
5627
5628         l_comp = l_image->comps;
5629
5630         for (i=0;i<l_image->numcomps;++i) {
5631                 opj_write_bytes(l_current_data, (l_comp->sgnd << 7) | (l_comp->prec - 1), 1);           /* Component bit depth */
5632                 ++l_current_data;
5633
5634                 ++l_comp;
5635         }
5636
5637         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) {
5638                 return OPJ_FALSE;
5639         }
5640
5641         return OPJ_TRUE;
5642 }
5643
5644 /**
5645  * Reads a CBD marker (Component bit depth definition)
5646  * @param       p_header_data   the data contained in the CBD box.
5647  * @param       p_j2k                   the jpeg2000 codec.
5648  * @param       p_header_size   the size of the data contained in the CBD marker.
5649  * @param       p_manager               the user event manager.
5650 */
5651 static OPJ_BOOL opj_j2k_read_cbd (      opj_j2k_t *p_j2k,
5652                                                                 OPJ_BYTE * p_header_data,
5653                                                                 OPJ_UINT32 p_header_size,
5654                                                                 opj_event_mgr_t * p_manager
5655                                     )
5656 {
5657         OPJ_UINT32 l_nb_comp,l_num_comp;
5658         OPJ_UINT32 l_comp_def;
5659         OPJ_UINT32 i;
5660         opj_image_comp_t * l_comp = 00;
5661
5662         /* preconditions */
5663         assert(p_header_data != 00);
5664         assert(p_j2k != 00);
5665         assert(p_manager != 00);
5666
5667         l_num_comp = p_j2k->m_private_image->numcomps;
5668
5669         if (p_header_size != (p_j2k->m_private_image->numcomps + 2)) {
5670                 opj_event_msg(p_manager, EVT_ERROR, "Crror reading CBD marker\n");
5671                 return OPJ_FALSE;
5672         }
5673
5674         opj_read_bytes(p_header_data,&l_nb_comp,2);                             /* Ncbd */
5675         p_header_data+=2;
5676
5677         if (l_nb_comp != l_num_comp) {
5678                 opj_event_msg(p_manager, EVT_ERROR, "Crror reading CBD marker\n");
5679                 return OPJ_FALSE;
5680         }
5681
5682         l_comp = p_j2k->m_private_image->comps;
5683         for (i=0;i<l_num_comp;++i) {
5684                 opj_read_bytes(p_header_data,&l_comp_def,1);                    /* Component bit depth */
5685                 ++p_header_data;
5686         l_comp->sgnd = (l_comp_def>>7) & 1;
5687                 l_comp->prec = (l_comp_def&0x7f) + 1;
5688                 ++l_comp;
5689         }
5690
5691         return OPJ_TRUE;
5692 }
5693
5694 /* ----------------------------------------------------------------------- */
5695 /* J2K / JPT decoder interface                                             */
5696 /* ----------------------------------------------------------------------- */
5697
5698 void opj_j2k_setup_decoder(opj_j2k_t *j2k, opj_dparameters_t *parameters)
5699 {
5700         if(j2k && parameters) {
5701                 j2k->m_cp.m_specific_param.m_dec.m_layer = parameters->cp_layer;
5702                 j2k->m_cp.m_specific_param.m_dec.m_reduce = parameters->cp_reduce;
5703
5704 #ifdef USE_JPWL
5705                 j2k->m_cp.correct = parameters->jpwl_correct;
5706                 j2k->m_cp.exp_comps = parameters->jpwl_exp_comps;
5707                 j2k->m_cp.max_tiles = parameters->jpwl_max_tiles;
5708 #endif /* USE_JPWL */
5709         }
5710 }
5711
5712 /* ----------------------------------------------------------------------- */
5713 /* J2K encoder interface                                                       */
5714 /* ----------------------------------------------------------------------- */
5715
5716 opj_j2k_t* opj_j2k_create_compress(void)
5717 {
5718         opj_j2k_t *l_j2k = (opj_j2k_t*) opj_malloc(sizeof(opj_j2k_t));
5719         if (!l_j2k) {
5720                 return NULL;
5721         }
5722
5723         memset(l_j2k,0,sizeof(opj_j2k_t));
5724
5725         l_j2k->m_is_decoder = 0;
5726         l_j2k->m_cp.m_is_decoder = 0;
5727
5728         l_j2k->m_specific_param.m_encoder.m_header_tile_data = (OPJ_BYTE *) opj_malloc(OPJ_J2K_DEFAULT_HEADER_SIZE);
5729         if (! l_j2k->m_specific_param.m_encoder.m_header_tile_data) {
5730                 opj_j2k_destroy(l_j2k);
5731                 return NULL;
5732         }
5733
5734         l_j2k->m_specific_param.m_encoder.m_header_tile_data_size = OPJ_J2K_DEFAULT_HEADER_SIZE;
5735
5736         /* validation list creation*/
5737         l_j2k->m_validation_list = opj_procedure_list_create();
5738         if (! l_j2k->m_validation_list) {
5739                 opj_j2k_destroy(l_j2k);
5740                 return NULL;
5741         }
5742
5743         /* execution list creation*/
5744         l_j2k->m_procedure_list = opj_procedure_list_create();
5745         if (! l_j2k->m_procedure_list) {
5746                 opj_j2k_destroy(l_j2k);
5747                 return NULL;
5748         }
5749
5750         return l_j2k;
5751 }
5752
5753 void opj_j2k_setup_encoder(     opj_j2k_t *p_j2k,
5754                                                     opj_cparameters_t *parameters,
5755                                                     opj_image_t *image,
5756                                                     opj_event_mgr_t * p_manager)
5757 {
5758         OPJ_UINT32 i, j, tileno, numpocs_tile;
5759         opj_cp_t *cp = 00;
5760
5761         if(!p_j2k || !parameters || ! image) {
5762                 return;
5763         }
5764
5765         /* keep a link to cp so that we can destroy it later in j2k_destroy_compress */
5766         cp = &(p_j2k->m_cp);
5767
5768         /* set default values for cp */
5769         cp->tw = 1;
5770         cp->th = 1;
5771
5772         /*
5773         copy user encoding parameters
5774         */
5775         cp->m_specific_param.m_enc.m_cinema = parameters->cp_cinema;
5776         cp->m_specific_param.m_enc.m_max_comp_size =    parameters->max_comp_size;
5777         cp->rsiz   = parameters->cp_rsiz;
5778         cp->m_specific_param.m_enc.m_disto_alloc = parameters->cp_disto_alloc;
5779         cp->m_specific_param.m_enc.m_fixed_alloc = parameters->cp_fixed_alloc;
5780         cp->m_specific_param.m_enc.m_fixed_quality = parameters->cp_fixed_quality;
5781
5782         /* mod fixed_quality */
5783         if (parameters->cp_matrice) {
5784                 size_t array_size = parameters->tcp_numlayers * parameters->numresolution * 3 * sizeof(OPJ_INT32);
5785                 cp->m_specific_param.m_enc.m_matrice = (OPJ_INT32 *) opj_malloc(array_size);
5786                 memcpy(cp->m_specific_param.m_enc.m_matrice, parameters->cp_matrice, array_size);
5787         }
5788
5789         /* tiles */
5790         cp->tdx = parameters->cp_tdx;
5791         cp->tdy = parameters->cp_tdy;
5792
5793         /* tile offset */
5794         cp->tx0 = parameters->cp_tx0;
5795         cp->ty0 = parameters->cp_ty0;
5796
5797         /* comment string */
5798         if(parameters->cp_comment) {
5799                 cp->comment = (char*)opj_malloc(strlen(parameters->cp_comment) + 1);
5800                 if(cp->comment) {
5801                         strcpy(cp->comment, parameters->cp_comment);
5802                 }
5803         }
5804
5805         /*
5806         calculate other encoding parameters
5807         */
5808
5809         if (parameters->tile_size_on) {
5810                 cp->tw = opj_int_ceildiv(image->x1 - cp->tx0, cp->tdx);
5811                 cp->th = opj_int_ceildiv(image->y1 - cp->ty0, cp->tdy);
5812         } else {
5813                 cp->tdx = image->x1 - cp->tx0;
5814                 cp->tdy = image->y1 - cp->ty0;
5815         }
5816
5817         if (parameters->tp_on) {
5818                 cp->m_specific_param.m_enc.m_tp_flag = parameters->tp_flag;
5819                 cp->m_specific_param.m_enc.m_tp_on = 1;
5820         }
5821
5822 #ifdef USE_JPWL
5823         /*
5824         calculate JPWL encoding parameters
5825         */
5826
5827         if (parameters->jpwl_epc_on) {
5828                 OPJ_INT32 i;
5829
5830                 /* set JPWL on */
5831                 cp->epc_on = OPJ_TRUE;
5832                 cp->info_on = OPJ_FALSE; /* no informative technique */
5833
5834                 /* set EPB on */
5835                 if ((parameters->jpwl_hprot_MH > 0) || (parameters->jpwl_hprot_TPH[0] > 0)) {
5836                         cp->epb_on = OPJ_TRUE;
5837
5838                         cp->hprot_MH = parameters->jpwl_hprot_MH;
5839                         for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {
5840                                 cp->hprot_TPH_tileno[i] = parameters->jpwl_hprot_TPH_tileno[i];
5841                                 cp->hprot_TPH[i] = parameters->jpwl_hprot_TPH[i];
5842                         }
5843                         /* if tile specs are not specified, copy MH specs */
5844                         if (cp->hprot_TPH[0] == -1) {
5845                                 cp->hprot_TPH_tileno[0] = 0;
5846                                 cp->hprot_TPH[0] = parameters->jpwl_hprot_MH;
5847                         }
5848                         for (i = 0; i < JPWL_MAX_NO_PACKSPECS; i++) {
5849                                 cp->pprot_tileno[i] = parameters->jpwl_pprot_tileno[i];
5850                                 cp->pprot_packno[i] = parameters->jpwl_pprot_packno[i];
5851                                 cp->pprot[i] = parameters->jpwl_pprot[i];
5852                         }
5853                 }
5854
5855                 /* set ESD writing */
5856                 if ((parameters->jpwl_sens_size == 1) || (parameters->jpwl_sens_size == 2)) {
5857                         cp->esd_on = OPJ_TRUE;
5858
5859                         cp->sens_size = parameters->jpwl_sens_size;
5860                         cp->sens_addr = parameters->jpwl_sens_addr;
5861                         cp->sens_range = parameters->jpwl_sens_range;
5862
5863                         cp->sens_MH = parameters->jpwl_sens_MH;
5864                         for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {
5865                                 cp->sens_TPH_tileno[i] = parameters->jpwl_sens_TPH_tileno[i];
5866                                 cp->sens_TPH[i] = parameters->jpwl_sens_TPH[i];
5867                         }
5868                 }
5869
5870                 /* always set RED writing to false: we are at the encoder */
5871                 cp->red_on = OPJ_FALSE;
5872
5873         } else {
5874                 cp->epc_on = OPJ_FALSE;
5875         }
5876 #endif /* USE_JPWL */
5877
5878         /* initialize the mutiple tiles */
5879         /* ---------------------------- */
5880         cp->tcps = (opj_tcp_t*) opj_calloc(cp->tw * cp->th, sizeof(opj_tcp_t));
5881         if (parameters->numpocs) {
5882                 /* initialisation of POC */
5883                 opj_j2k_check_poc_val(parameters->POC,parameters->numpocs, parameters->numresolution, image->numcomps, parameters->tcp_numlayers, p_manager);
5884                 /* TODO MSD use the return value*/
5885         }
5886
5887         for (tileno = 0; tileno < cp->tw * cp->th; tileno++) {
5888                 opj_tcp_t *tcp = &cp->tcps[tileno];
5889                 tcp->numlayers = parameters->tcp_numlayers;
5890
5891                 for (j = 0; j < tcp->numlayers; j++) {
5892                         if(cp->m_specific_param.m_enc.m_cinema){
5893                                 if (cp->m_specific_param.m_enc.m_fixed_quality) {
5894                                         tcp->distoratio[j] = parameters->tcp_distoratio[j];
5895                                 }
5896                                 tcp->rates[j] = parameters->tcp_rates[j];
5897                         }else{
5898                                 if (cp->m_specific_param.m_enc.m_fixed_quality) {       /* add fixed_quality */
5899                                         tcp->distoratio[j] = parameters->tcp_distoratio[j];
5900                                 } else {
5901                                         tcp->rates[j] = parameters->tcp_rates[j];
5902                                 }
5903                         }
5904                 }
5905
5906                 tcp->csty = parameters->csty;
5907                 tcp->prg = parameters->prog_order;
5908                 tcp->mct = parameters->tcp_mct;
5909
5910                 numpocs_tile = 0;
5911                 tcp->POC = 0;
5912
5913                 if (parameters->numpocs) {
5914                         /* initialisation of POC */
5915                         tcp->POC = 1;
5916                         for (i = 0; i < parameters->numpocs; i++) {
5917                                 if (tileno + 1 == parameters->POC[i].tile )  {
5918                                         opj_poc_t *tcp_poc = &tcp->pocs[numpocs_tile];
5919
5920                                         tcp_poc->resno0         = parameters->POC[numpocs_tile].resno0;
5921                                         tcp_poc->compno0        = parameters->POC[numpocs_tile].compno0;
5922                                         tcp_poc->layno1         = parameters->POC[numpocs_tile].layno1;
5923                                         tcp_poc->resno1         = parameters->POC[numpocs_tile].resno1;
5924                                         tcp_poc->compno1        = parameters->POC[numpocs_tile].compno1;
5925                                         tcp_poc->prg1           = parameters->POC[numpocs_tile].prg1;
5926                                         tcp_poc->tile           = parameters->POC[numpocs_tile].tile;
5927
5928                                         numpocs_tile++;
5929                                 }
5930                         }
5931
5932                         tcp->numpocs = numpocs_tile -1 ;
5933                 }else{
5934                         tcp->numpocs = 0;
5935                 }
5936
5937                 tcp->tccps = (opj_tccp_t*) opj_calloc(image->numcomps, sizeof(opj_tccp_t));
5938
5939                 if (parameters->mct_data) {
5940
5941                     OPJ_UINT32 lMctSize = image->numcomps * image->numcomps * sizeof(OPJ_FLOAT32);
5942                     OPJ_FLOAT32 * lTmpBuf = (OPJ_FLOAT32*)opj_malloc(lMctSize);
5943                     OPJ_INT32 * l_dc_shift = (OPJ_INT32 *) ((OPJ_BYTE *) parameters->mct_data + lMctSize);
5944
5945                     tcp->mct = 2;
5946                     tcp->m_mct_coding_matrix = (OPJ_FLOAT32*)opj_malloc(lMctSize);
5947                     memcpy(tcp->m_mct_coding_matrix,parameters->mct_data,lMctSize);
5948                     memcpy(lTmpBuf,parameters->mct_data,lMctSize);
5949
5950                     tcp->m_mct_decoding_matrix = (OPJ_FLOAT32*)opj_malloc(lMctSize);
5951                     assert(opj_matrix_inversion_f(lTmpBuf,(tcp->m_mct_decoding_matrix),image->numcomps));
5952
5953                     tcp->mct_norms = (OPJ_FLOAT64*)
5954                                     opj_malloc(image->numcomps * sizeof(OPJ_FLOAT64));
5955
5956                     opj_calculate_norms(tcp->mct_norms,image->numcomps,tcp->m_mct_decoding_matrix);
5957                     opj_free(lTmpBuf);
5958
5959                     for (i = 0; i < image->numcomps; i++) {
5960                             opj_tccp_t *tccp = &tcp->tccps[i];
5961                             tccp->m_dc_level_shift = l_dc_shift[i];
5962                     }
5963
5964                     opj_j2k_setup_mct_encoding(tcp,image);
5965                 }
5966                 else {
5967                         for (i = 0; i < image->numcomps; i++) {
5968                                 opj_tccp_t *tccp = &tcp->tccps[i];
5969                                 opj_image_comp_t * l_comp = &(image->comps[i]);
5970
5971                                 if (! l_comp->sgnd) {
5972                                         tccp->m_dc_level_shift = 1 << (l_comp->prec - 1);
5973                                 }
5974                         }
5975                 }
5976
5977                 for (i = 0; i < image->numcomps; i++) {
5978                         opj_tccp_t *tccp = &tcp->tccps[i];
5979
5980                         tccp->csty = parameters->csty & 0x01;   /* 0 => one precinct || 1 => custom precinct  */
5981                         tccp->numresolutions = parameters->numresolution;
5982                         tccp->cblkw = opj_int_floorlog2(parameters->cblockw_init);
5983                         tccp->cblkh = opj_int_floorlog2(parameters->cblockh_init);
5984                         tccp->cblksty = parameters->mode;
5985                         tccp->qmfbid = parameters->irreversible ? 0 : 1;
5986                         tccp->qntsty = parameters->irreversible ? J2K_CCP_QNTSTY_SEQNT : J2K_CCP_QNTSTY_NOQNT;
5987                         tccp->numgbits = 2;
5988
5989                         if ((OPJ_INT32)i == parameters->roi_compno) {
5990                                 tccp->roishift = parameters->roi_shift;
5991                         } else {
5992                                 tccp->roishift = 0;
5993                         }
5994
5995                         if(parameters->cp_cinema) {
5996                                 /*Precinct size for lowest frequency subband=128*/
5997                                 tccp->prcw[0] = 7;
5998                                 tccp->prch[0] = 7;
5999                                 /*Precinct size at all other resolutions = 256*/
6000                                 for (j = 1; j < tccp->numresolutions; j++) {
6001                                         tccp->prcw[j] = 8;
6002                                         tccp->prch[j] = 8;
6003                                 }
6004                         }else{
6005                                 if (parameters->csty & J2K_CCP_CSTY_PRT) {
6006                                         OPJ_INT32 p = 0, it_res;
6007                                         for (it_res = tccp->numresolutions - 1; it_res >= 0; it_res--) {
6008                                                 if (p < parameters->res_spec) {
6009
6010                                                         if (parameters->prcw_init[p] < 1) {
6011                                                                 tccp->prcw[it_res] = 1;
6012                                                         } else {
6013                                                                 tccp->prcw[it_res] = opj_int_floorlog2(parameters->prcw_init[p]);
6014                                                         }
6015
6016                                                         if (parameters->prch_init[p] < 1) {
6017                                                                 tccp->prch[it_res] = 1;
6018                                                         }else {
6019                                                                 tccp->prch[it_res] = opj_int_floorlog2(parameters->prch_init[p]);
6020                                                         }
6021
6022                                                 } else {
6023                                                         OPJ_INT32 res_spec = parameters->res_spec;
6024                                                         OPJ_INT32 size_prcw = 0;
6025                                                         OPJ_INT32 size_prch = 0;
6026
6027                                                         assert(res_spec>0); /* issue 189 */
6028                                                         size_prcw = parameters->prcw_init[res_spec - 1] >> (p - (res_spec - 1));
6029                                                         size_prch = parameters->prch_init[res_spec - 1] >> (p - (res_spec - 1));
6030
6031
6032                                                         if (size_prcw < 1) {
6033                                                                 tccp->prcw[it_res] = 1;
6034                                                         } else {
6035                                                                 tccp->prcw[it_res] = opj_int_floorlog2(size_prcw);
6036                                                         }
6037
6038                                                         if (size_prch < 1) {
6039                                                                 tccp->prch[it_res] = 1;
6040                                                         } else {
6041                                                                 tccp->prch[it_res] = opj_int_floorlog2(size_prch);
6042                                                         }
6043                                                 }
6044                                                 p++;
6045                                                 /*printf("\nsize precinct for level %d : %d,%d\n", it_res,tccp->prcw[it_res], tccp->prch[it_res]); */
6046                                         }       /*end for*/
6047                                 } else {
6048                                         for (j = 0; j < tccp->numresolutions; j++) {
6049                                                 tccp->prcw[j] = 15;
6050                                                 tccp->prch[j] = 15;
6051                                         }
6052                                 }
6053                         }
6054
6055                         opj_dwt_calc_explicit_stepsizes(tccp, image->comps[i].prec);
6056                 }
6057         }
6058
6059         if (parameters->mct_data) {
6060                 opj_free(parameters->mct_data);
6061                 parameters->mct_data = 00;
6062         }
6063 }
6064
6065 static OPJ_BOOL opj_j2k_add_mhmarker(opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_OFF_T pos, OPJ_UINT32 len)
6066 {
6067         assert(cstr_index != 00);
6068
6069         /* expand the list? */
6070         if ((cstr_index->marknum + 1) > cstr_index->maxmarknum) {
6071                 opj_marker_info_t *new_marker;
6072                 cstr_index->maxmarknum = 100 + (OPJ_INT32) ((OPJ_FLOAT32) cstr_index->maxmarknum * 1.0F);
6073                 new_marker = (opj_marker_info_t *) opj_realloc(cstr_index->marker, cstr_index->maxmarknum *sizeof(opj_marker_info_t));
6074                 if (! new_marker) {
6075                         opj_free(cstr_index->marker);
6076                         cstr_index->marker = NULL;
6077                         cstr_index->maxmarknum = 0;
6078                         cstr_index->marknum = 0;
6079                         /* opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to add mh marker\n"); */
6080                         return OPJ_FALSE;
6081                 }
6082                 cstr_index->marker = new_marker;
6083         }
6084
6085         /* add the marker */
6086         cstr_index->marker[cstr_index->marknum].type = (OPJ_UINT16)type;
6087         cstr_index->marker[cstr_index->marknum].pos = (OPJ_INT32)pos;
6088         cstr_index->marker[cstr_index->marknum].len = (OPJ_INT32)len;
6089         cstr_index->marknum++;
6090         return OPJ_TRUE;
6091 }
6092
6093 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)
6094 {
6095         assert(cstr_index != 00);
6096         assert(cstr_index->tile_index != 00);
6097
6098         /* expand the list? */
6099         if ((cstr_index->tile_index[tileno].marknum + 1) > cstr_index->tile_index[tileno].maxmarknum) {
6100                 opj_marker_info_t *new_marker;
6101                 cstr_index->tile_index[tileno].maxmarknum = 100 + (OPJ_INT32) ((OPJ_FLOAT32) cstr_index->tile_index[tileno].maxmarknum * 1.0F);
6102                 new_marker = (opj_marker_info_t *) opj_realloc(
6103                                 cstr_index->tile_index[tileno].marker,
6104                                 cstr_index->tile_index[tileno].maxmarknum *sizeof(opj_marker_info_t));
6105                 if (! new_marker) {
6106                         opj_free(cstr_index->tile_index[tileno].marker);
6107                         cstr_index->tile_index[tileno].marker = NULL;
6108                         cstr_index->tile_index[tileno].maxmarknum = 0;
6109                         cstr_index->tile_index[tileno].marknum = 0;
6110                         /* opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to add tl marker\n"); */
6111                         return OPJ_FALSE;
6112                 }
6113                 cstr_index->tile_index[tileno].marker = new_marker;
6114         }
6115
6116         /* add the marker */
6117         cstr_index->tile_index[tileno].marker[cstr_index->tile_index[tileno].marknum].type = (OPJ_UINT16)type;
6118         cstr_index->tile_index[tileno].marker[cstr_index->tile_index[tileno].marknum].pos = (OPJ_INT32)pos;
6119         cstr_index->tile_index[tileno].marker[cstr_index->tile_index[tileno].marknum].len = (OPJ_INT32)len;
6120         cstr_index->tile_index[tileno].marknum++;
6121
6122         if (type == J2K_MS_SOT) {
6123                 OPJ_UINT32 l_current_tile_part = cstr_index->tile_index[tileno].current_tpsno;
6124
6125                 if (cstr_index->tile_index[tileno].tp_index)
6126                         cstr_index->tile_index[tileno].tp_index[l_current_tile_part].start_pos = pos;
6127
6128         }
6129         return OPJ_TRUE;
6130 }
6131
6132 /*
6133  * -----------------------------------------------------------------------
6134  * -----------------------------------------------------------------------
6135  * -----------------------------------------------------------------------
6136  */
6137
6138 OPJ_BOOL opj_j2k_end_decompress(opj_j2k_t *p_j2k,
6139                                 opj_stream_private_t *p_stream,
6140                                 opj_event_mgr_t * p_manager
6141                                 )
6142 {
6143     (void)p_j2k;
6144     (void)p_stream;
6145     (void)p_manager;
6146     return OPJ_TRUE;
6147 }
6148
6149 OPJ_BOOL opj_j2k_read_header(   opj_stream_private_t *p_stream,
6150                                                             opj_j2k_t* p_j2k,
6151                                                             opj_image_t** p_image,
6152                                                             opj_event_mgr_t* p_manager )
6153 {
6154         /* preconditions */
6155         assert(p_j2k != 00);
6156         assert(p_stream != 00);
6157         assert(p_manager != 00);
6158
6159         /* create an empty image header */
6160         p_j2k->m_private_image = opj_image_create0();
6161         if (! p_j2k->m_private_image) {
6162                 return OPJ_FALSE;
6163         }
6164
6165         /* customization of the validation */
6166         opj_j2k_setup_decoding_validation(p_j2k);
6167
6168         /* validation of the parameters codec */
6169         if (! opj_j2k_exec(p_j2k, p_j2k->m_validation_list, p_stream,p_manager)) {
6170                 opj_image_destroy(p_j2k->m_private_image);
6171                 p_j2k->m_private_image = NULL;
6172                 return OPJ_FALSE;
6173         }
6174
6175         /* customization of the encoding */
6176         opj_j2k_setup_header_reading(p_j2k);
6177
6178         /* read header */
6179         if (! opj_j2k_exec (p_j2k,p_j2k->m_procedure_list,p_stream,p_manager)) {
6180                 opj_image_destroy(p_j2k->m_private_image);
6181                 p_j2k->m_private_image = NULL;
6182                 return OPJ_FALSE;
6183         }
6184
6185         *p_image = opj_image_create0();
6186         if (! (*p_image)) {
6187                 return OPJ_FALSE;
6188         }
6189
6190         /* Copy codestream image information to the output image */
6191         opj_copy_image_header(p_j2k->m_private_image, *p_image);
6192
6193     /*Allocate and initialize some elements of codestrem index*/
6194         if (!opj_j2k_allocate_tile_element_cstr_index(p_j2k)){
6195                 return OPJ_FALSE;
6196         }
6197
6198         return OPJ_TRUE;
6199 }
6200
6201 void opj_j2k_setup_header_reading (opj_j2k_t *p_j2k)
6202 {
6203         /* preconditions*/
6204         assert(p_j2k != 00);
6205
6206         opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_read_header_procedure);
6207
6208         /* DEVELOPER CORNER, add your custom procedures */
6209         opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_copy_default_tcp_and_create_tcd);
6210
6211 }
6212
6213 void opj_j2k_setup_decoding_validation (opj_j2k_t *p_j2k)
6214 {
6215         /* preconditions*/
6216         assert(p_j2k != 00);
6217
6218         opj_procedure_list_add_procedure(p_j2k->m_validation_list, (opj_procedure)opj_j2k_build_decoder);
6219         opj_procedure_list_add_procedure(p_j2k->m_validation_list, (opj_procedure)opj_j2k_decoding_validation);
6220         /* DEVELOPER CORNER, add your custom validation procedure */
6221
6222 }
6223
6224 OPJ_BOOL opj_j2k_mct_validation (       opj_j2k_t * p_j2k,
6225                                                                 opj_stream_private_t *p_stream,
6226                                                                 opj_event_mgr_t * p_manager )
6227 {
6228         OPJ_BOOL l_is_valid = OPJ_TRUE;
6229         OPJ_UINT32 i,j;
6230
6231         /* preconditions */
6232         assert(p_j2k != 00);
6233         assert(p_stream != 00);
6234         assert(p_manager != 00);
6235
6236         if ((p_j2k->m_cp.rsiz & 0x8200) == 0x8200) {
6237                 OPJ_UINT32 l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
6238                 opj_tcp_t * l_tcp = p_j2k->m_cp.tcps;
6239
6240                 for (i=0;i<l_nb_tiles;++i) {
6241                         if (l_tcp->mct == 2) {
6242                                 opj_tccp_t * l_tccp = l_tcp->tccps;
6243                                 l_is_valid &= (l_tcp->m_mct_coding_matrix != 00);
6244
6245                                 for (j=0;j<p_j2k->m_private_image->numcomps;++j) {
6246                                         l_is_valid &= ! (l_tccp->qmfbid & 1);
6247                                         ++l_tccp;
6248                                 }
6249                         }
6250                         ++l_tcp;
6251                 }
6252         }
6253
6254         return l_is_valid;
6255 }
6256
6257 OPJ_BOOL opj_j2k_setup_mct_encoding(opj_tcp_t * p_tcp, opj_image_t * p_image)
6258 {
6259         OPJ_UINT32 i;
6260         OPJ_UINT32 l_indix = 1;
6261         opj_mct_data_t * l_mct_deco_data = 00,* l_mct_offset_data = 00;
6262         opj_simple_mcc_decorrelation_data_t * l_mcc_data;
6263         OPJ_UINT32 l_mct_size,l_nb_elem;
6264         OPJ_FLOAT32 * l_data, * l_current_data;
6265         opj_tccp_t * l_tccp;
6266
6267         /* preconditions */
6268         assert(p_tcp != 00);
6269
6270         if (p_tcp->mct != 2) {
6271                 return OPJ_TRUE;
6272         }
6273
6274         if (p_tcp->m_mct_decoding_matrix) {
6275                 if (p_tcp->m_nb_mct_records == p_tcp->m_nb_max_mct_records) {
6276                         opj_mct_data_t *new_mct_records;
6277                         p_tcp->m_nb_max_mct_records += OPJ_J2K_MCT_DEFAULT_NB_RECORDS;
6278
6279                         new_mct_records = (opj_mct_data_t *) opj_realloc(p_tcp->m_mct_records, p_tcp->m_nb_max_mct_records * sizeof(opj_mct_data_t));
6280                         if (! new_mct_records) {
6281                                 opj_free(p_tcp->m_mct_records);
6282                                 p_tcp->m_mct_records = NULL;
6283                                 p_tcp->m_nb_max_mct_records = 0;
6284                                 p_tcp->m_nb_mct_records = 0;
6285                                 /* opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to setup mct encoding\n"); */
6286                                 return OPJ_FALSE;
6287                         }
6288                         p_tcp->m_mct_records = new_mct_records;
6289                         l_mct_deco_data = p_tcp->m_mct_records + p_tcp->m_nb_mct_records;
6290
6291                         memset(l_mct_deco_data ,0,(p_tcp->m_nb_max_mct_records - p_tcp->m_nb_mct_records) * sizeof(opj_mct_data_t));
6292                 }
6293                 l_mct_deco_data = p_tcp->m_mct_records + p_tcp->m_nb_mct_records;
6294
6295                 if (l_mct_deco_data->m_data) {
6296                         opj_free(l_mct_deco_data->m_data);
6297                         l_mct_deco_data->m_data = 00;
6298                 }
6299
6300                 l_mct_deco_data->m_index = l_indix++;
6301                 l_mct_deco_data->m_array_type = MCT_TYPE_DECORRELATION;
6302                 l_mct_deco_data->m_element_type = MCT_TYPE_FLOAT;
6303                 l_nb_elem = p_image->numcomps * p_image->numcomps;
6304                 l_mct_size = l_nb_elem * MCT_ELEMENT_SIZE[l_mct_deco_data->m_element_type];
6305                 l_mct_deco_data->m_data = (OPJ_BYTE*)opj_malloc(l_mct_size );
6306
6307                 if (! l_mct_deco_data->m_data) {
6308                         return OPJ_FALSE;
6309                 }
6310
6311                 j2k_mct_write_functions_from_float[l_mct_deco_data->m_element_type](p_tcp->m_mct_decoding_matrix,l_mct_deco_data->m_data,l_nb_elem);
6312
6313                 l_mct_deco_data->m_data_size = l_mct_size;
6314                 ++p_tcp->m_nb_mct_records;
6315         }
6316
6317         if (p_tcp->m_nb_mct_records == p_tcp->m_nb_max_mct_records) {
6318                 opj_mct_data_t *new_mct_records;
6319                 p_tcp->m_nb_max_mct_records += OPJ_J2K_MCT_DEFAULT_NB_RECORDS;
6320                 new_mct_records = (opj_mct_data_t *) opj_realloc(p_tcp->m_mct_records, p_tcp->m_nb_max_mct_records * sizeof(opj_mct_data_t));
6321                 if (! new_mct_records) {
6322                         opj_free(p_tcp->m_mct_records);
6323                         p_tcp->m_mct_records = NULL;
6324                         p_tcp->m_nb_max_mct_records = 0;
6325                         p_tcp->m_nb_mct_records = 0;
6326                         /* opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to setup mct encoding\n"); */
6327                         return OPJ_FALSE;
6328                 }
6329                 p_tcp->m_mct_records = new_mct_records;
6330                 l_mct_offset_data = p_tcp->m_mct_records + p_tcp->m_nb_mct_records;
6331
6332                 memset(l_mct_offset_data ,0,(p_tcp->m_nb_max_mct_records - p_tcp->m_nb_mct_records) * sizeof(opj_mct_data_t));
6333
6334                 if (l_mct_deco_data) {
6335                         l_mct_deco_data = l_mct_offset_data - 1;
6336                 }
6337         }
6338
6339         l_mct_offset_data = p_tcp->m_mct_records + p_tcp->m_nb_mct_records;
6340
6341         if (l_mct_offset_data->m_data) {
6342                 opj_free(l_mct_offset_data->m_data);
6343                 l_mct_offset_data->m_data = 00;
6344         }
6345
6346         l_mct_offset_data->m_index = l_indix++;
6347         l_mct_offset_data->m_array_type = MCT_TYPE_OFFSET;
6348         l_mct_offset_data->m_element_type = MCT_TYPE_FLOAT;
6349         l_nb_elem = p_image->numcomps;
6350         l_mct_size = l_nb_elem * MCT_ELEMENT_SIZE[l_mct_offset_data->m_element_type];
6351         l_mct_offset_data->m_data = (OPJ_BYTE*)opj_malloc(l_mct_size );
6352
6353         if (! l_mct_offset_data->m_data) {
6354                 return OPJ_FALSE;
6355         }
6356
6357         l_data = (OPJ_FLOAT32*)opj_malloc(l_nb_elem * sizeof(OPJ_FLOAT32));
6358         if (! l_data) {
6359                 opj_free(l_mct_offset_data->m_data);
6360                 l_mct_offset_data->m_data = 00;
6361                 return OPJ_FALSE;
6362         }
6363
6364         l_tccp = p_tcp->tccps;
6365         l_current_data = l_data;
6366
6367         for (i=0;i<l_nb_elem;++i) {
6368                 *(l_current_data++) = (OPJ_FLOAT32) (l_tccp->m_dc_level_shift);
6369                 ++l_tccp;
6370         }
6371
6372         j2k_mct_write_functions_from_float[l_mct_offset_data->m_element_type](l_data,l_mct_offset_data->m_data,l_nb_elem);
6373
6374         opj_free(l_data);
6375
6376         l_mct_offset_data->m_data_size = l_mct_size;
6377
6378         ++p_tcp->m_nb_mct_records;
6379
6380         if (p_tcp->m_nb_mcc_records == p_tcp->m_nb_max_mcc_records) {
6381                 opj_simple_mcc_decorrelation_data_t *new_mcc_records;
6382                 p_tcp->m_nb_max_mcc_records += OPJ_J2K_MCT_DEFAULT_NB_RECORDS;
6383                 new_mcc_records = (opj_simple_mcc_decorrelation_data_t *) opj_realloc(
6384                                 p_tcp->m_mcc_records, p_tcp->m_nb_max_mcc_records * sizeof(opj_simple_mcc_decorrelation_data_t));
6385                 if (! new_mcc_records) {
6386                         opj_free(p_tcp->m_mcc_records);
6387                         p_tcp->m_mcc_records = NULL;
6388                         p_tcp->m_nb_max_mcc_records = 0;
6389                         p_tcp->m_nb_mcc_records = 0;
6390                         /* opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to setup mct encoding\n"); */
6391                         return OPJ_FALSE;
6392                 }
6393                 p_tcp->m_mcc_records = new_mcc_records;
6394                 l_mcc_data = p_tcp->m_mcc_records + p_tcp->m_nb_mcc_records;
6395                 memset(l_mcc_data ,0,(p_tcp->m_nb_max_mcc_records - p_tcp->m_nb_mcc_records) * sizeof(opj_simple_mcc_decorrelation_data_t));
6396
6397         }
6398
6399         l_mcc_data = p_tcp->m_mcc_records + p_tcp->m_nb_mcc_records;
6400         l_mcc_data->m_decorrelation_array = l_mct_deco_data;
6401         l_mcc_data->m_is_irreversible = 1;
6402         l_mcc_data->m_nb_comps = p_image->numcomps;
6403         l_mcc_data->m_index = l_indix++;
6404         l_mcc_data->m_offset_array = l_mct_offset_data;
6405         ++p_tcp->m_nb_mcc_records;
6406
6407         return OPJ_TRUE;
6408 }
6409
6410 OPJ_BOOL opj_j2k_build_decoder (opj_j2k_t * p_j2k,
6411                                                             opj_stream_private_t *p_stream,
6412                                                             opj_event_mgr_t * p_manager )
6413 {
6414         /* add here initialization of cp
6415            copy paste of setup_decoder */
6416   (void)p_j2k;
6417   (void)p_stream;
6418   (void)p_manager;
6419         return OPJ_TRUE;
6420 }
6421
6422 OPJ_BOOL opj_j2k_build_encoder (opj_j2k_t * p_j2k,
6423                                                         opj_stream_private_t *p_stream,
6424                                                         opj_event_mgr_t * p_manager )
6425 {
6426         /* add here initialization of cp
6427            copy paste of setup_encoder */
6428   (void)p_j2k;
6429   (void)p_stream;
6430   (void)p_manager;
6431         return OPJ_TRUE;
6432 }
6433
6434 OPJ_BOOL opj_j2k_encoding_validation (  opj_j2k_t * p_j2k,
6435                                                                             opj_stream_private_t *p_stream,
6436                                                                             opj_event_mgr_t * p_manager )
6437 {
6438         OPJ_BOOL l_is_valid = OPJ_TRUE;
6439
6440         /* preconditions */
6441         assert(p_j2k != 00);
6442         assert(p_stream != 00);
6443         assert(p_manager != 00);
6444
6445         /* STATE checking */
6446         /* make sure the state is at 0 */
6447         l_is_valid &= (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_NONE);
6448
6449         /* POINTER validation */
6450         /* make sure a p_j2k codec is present */
6451         l_is_valid &= (p_j2k->m_procedure_list != 00);
6452         /* make sure a validation list is present */
6453         l_is_valid &= (p_j2k->m_validation_list != 00);
6454
6455         if ((p_j2k->m_cp.tdx) < (OPJ_UINT32) (1 << p_j2k->m_cp.tcps->tccps->numresolutions)) {
6456                 opj_event_msg(p_manager, EVT_ERROR, "Number of resolutions is too high in comparison to the size of tiles\n");
6457                 return OPJ_FALSE;
6458         }
6459
6460         if ((p_j2k->m_cp.tdy) < (OPJ_UINT32) (1 << p_j2k->m_cp.tcps->tccps->numresolutions)) {
6461                 opj_event_msg(p_manager, EVT_ERROR, "Number of resolutions is too high in comparison to the size of tiles\n");
6462                 return OPJ_FALSE;
6463         }
6464
6465         /* PARAMETER VALIDATION */
6466         return l_is_valid;
6467 }
6468
6469 OPJ_BOOL opj_j2k_decoding_validation (  opj_j2k_t *p_j2k,
6470                                         opj_stream_private_t *p_stream,
6471                                         opj_event_mgr_t * p_manager
6472                                         )
6473 {
6474         OPJ_BOOL l_is_valid = OPJ_TRUE;
6475
6476         /* preconditions*/
6477         assert(p_j2k != 00);
6478         assert(p_stream != 00);
6479         assert(p_manager != 00);
6480
6481         /* STATE checking */
6482         /* make sure the state is at 0 */
6483 #ifdef TODO_MSD
6484         l_is_valid &= (p_j2k->m_specific_param.m_decoder.m_state == J2K_DEC_STATE_NONE);
6485 #endif
6486         l_is_valid &= (p_j2k->m_specific_param.m_decoder.m_state == 0x0000);
6487
6488         /* POINTER validation */
6489         /* make sure a p_j2k codec is present */
6490         /* make sure a procedure list is present */
6491         l_is_valid &= (p_j2k->m_procedure_list != 00);
6492         /* make sure a validation list is present */
6493         l_is_valid &= (p_j2k->m_validation_list != 00);
6494
6495         /* PARAMETER VALIDATION */
6496         return l_is_valid;
6497 }
6498
6499 OPJ_BOOL opj_j2k_read_header_procedure( opj_j2k_t *p_j2k,
6500                                                                             opj_stream_private_t *p_stream,
6501                                                                             opj_event_mgr_t * p_manager)
6502 {
6503         OPJ_UINT32 l_current_marker;
6504         OPJ_UINT32 l_marker_size;
6505         const opj_dec_memory_marker_handler_t * l_marker_handler = 00;
6506
6507         /* preconditions */
6508         assert(p_stream != 00);
6509         assert(p_j2k != 00);
6510         assert(p_manager != 00);
6511
6512         /*  We enter in the main header */
6513         p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_MHSOC;
6514
6515         /* Try to read the SOC marker, the codestream must begin with SOC marker */
6516         if (! opj_j2k_read_soc(p_j2k,p_stream,p_manager)) {
6517                 opj_event_msg(p_manager, EVT_ERROR, "Expected a SOC marker \n");
6518                 return OPJ_FALSE;
6519         }
6520
6521         /* Try to read 2 bytes (the next marker ID) from stream and copy them into the buffer */
6522         if (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,2,p_manager) != 2) {
6523                 opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
6524                 return OPJ_FALSE;
6525         }
6526
6527         /* Read 2 bytes as the new marker ID */
6528         opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,&l_current_marker,2);
6529
6530         /* Try to read until the SOT is detected */
6531         while (l_current_marker != J2K_MS_SOT) {
6532
6533                 /* Check if the current marker ID is valid */
6534                 if (l_current_marker < 0xff00) {
6535                         opj_event_msg(p_manager, EVT_ERROR, "We expected read a marker ID (0xff--) instead of %.8x\n", l_current_marker);
6536                         return OPJ_FALSE;
6537                 }
6538
6539                 /* Get the marker handler from the marker ID */
6540                 l_marker_handler = opj_j2k_get_marker_handler(l_current_marker);
6541
6542                 /* Manage case where marker is unknown */
6543                 if (l_marker_handler->id == J2K_MS_UNK) {
6544                         if (! opj_j2k_read_unk(p_j2k, p_stream, &l_current_marker, p_manager)){
6545                                 opj_event_msg(p_manager, EVT_ERROR, "Unknow marker have been detected and generated error.\n");
6546                                 return OPJ_FALSE;
6547                         }
6548
6549                         if (l_current_marker == J2K_MS_SOT)
6550                                 break; /* SOT marker is detected main header is completely read */
6551                         else    /* Get the marker handler from the marker ID */
6552                                 l_marker_handler = opj_j2k_get_marker_handler(l_current_marker);
6553                 }
6554
6555                 /* Check if the marker is known and if it is the right place to find it */
6556                 if (! (p_j2k->m_specific_param.m_decoder.m_state & l_marker_handler->states) ) {
6557                         opj_event_msg(p_manager, EVT_ERROR, "Marker is not compliant with its position\n");
6558                         return OPJ_FALSE;
6559                 }
6560
6561                 /* Try to read 2 bytes (the marker size) from stream and copy them into the buffer */
6562                 if (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,2,p_manager) != 2) {
6563                         opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
6564                         return OPJ_FALSE;
6565                 }
6566
6567                 /* read 2 bytes as the marker size */
6568                 opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,&l_marker_size,2);
6569                 l_marker_size -= 2; /* Subtract the size of the marker ID already read */
6570
6571                 /* Check if the marker size is compatible with the header data size */
6572                 if (l_marker_size > p_j2k->m_specific_param.m_decoder.m_header_data_size) {
6573                         OPJ_BYTE *new_header_data = (OPJ_BYTE *) opj_realloc(p_j2k->m_specific_param.m_decoder.m_header_data, l_marker_size);
6574                         if (! new_header_data) {
6575                                 opj_free(p_j2k->m_specific_param.m_decoder.m_header_data);
6576                                 p_j2k->m_specific_param.m_decoder.m_header_data = NULL;
6577                                 p_j2k->m_specific_param.m_decoder.m_header_data_size = 0;
6578                                 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read header\n");
6579                                 return OPJ_FALSE;
6580                         }
6581                         p_j2k->m_specific_param.m_decoder.m_header_data = new_header_data;
6582                         p_j2k->m_specific_param.m_decoder.m_header_data_size = l_marker_size;
6583                 }
6584
6585                 /* Try to read the rest of the marker segment from stream and copy them into the buffer */
6586                 if (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,l_marker_size,p_manager) != l_marker_size) {
6587                         opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
6588                         return OPJ_FALSE;
6589                 }
6590
6591                 /* Read the marker segment with the correct marker handler */
6592                 if (! (*(l_marker_handler->handler))(p_j2k,p_j2k->m_specific_param.m_decoder.m_header_data,l_marker_size,p_manager)) {
6593                         opj_event_msg(p_manager, EVT_ERROR, "Marker handler function failed to read the marker segment\n");
6594                         return OPJ_FALSE;
6595                 }
6596
6597                 /* Add the marker to the codestream index*/
6598                 if (OPJ_FALSE == opj_j2k_add_mhmarker(
6599                                         p_j2k->cstr_index,
6600                                         l_marker_handler->id,
6601                                         (OPJ_UINT32) opj_stream_tell(p_stream) - l_marker_size - 4,
6602                                         l_marker_size + 4 )) {
6603                         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to add mh marker\n");
6604                         return OPJ_FALSE;
6605                 }
6606
6607                 /* Try to read 2 bytes (the next marker ID) from stream and copy them into the buffer */
6608                 if (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,2,p_manager) != 2) {
6609                         opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
6610                         return OPJ_FALSE;
6611                 }
6612
6613                 /* read 2 bytes as the new marker ID */
6614                 opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,&l_current_marker,2);
6615         }
6616
6617         opj_event_msg(p_manager, EVT_INFO, "Main header has been correctly decoded.\n");
6618
6619         /* Position of the last element if the main header */
6620         p_j2k->cstr_index->main_head_end = (OPJ_UINT32) opj_stream_tell(p_stream) - 2;
6621
6622         /* Next step: read a tile-part header */
6623         p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_TPHSOT;
6624
6625         return OPJ_TRUE;
6626 }
6627
6628 OPJ_BOOL opj_j2k_exec ( opj_j2k_t * p_j2k,
6629                                         opj_procedure_list_t * p_procedure_list,
6630                                         opj_stream_private_t *p_stream,
6631                                         opj_event_mgr_t * p_manager )
6632 {
6633         OPJ_BOOL (** l_procedure) (opj_j2k_t * ,opj_stream_private_t *,opj_event_mgr_t *) = 00;
6634         OPJ_BOOL l_result = OPJ_TRUE;
6635         OPJ_UINT32 l_nb_proc, i;
6636
6637         /* preconditions*/
6638         assert(p_procedure_list != 00);
6639         assert(p_j2k != 00);
6640         assert(p_stream != 00);
6641         assert(p_manager != 00);
6642
6643         l_nb_proc = opj_procedure_list_get_nb_procedures(p_procedure_list);
6644         l_procedure = (OPJ_BOOL (**) (opj_j2k_t * ,opj_stream_private_t *,opj_event_mgr_t *)) opj_procedure_list_get_first_procedure(p_procedure_list);
6645
6646         for     (i=0;i<l_nb_proc;++i) {
6647                 l_result = l_result && ((*l_procedure) (p_j2k,p_stream,p_manager));
6648                 ++l_procedure;
6649         }
6650
6651         /* and clear the procedure list at the end.*/
6652         opj_procedure_list_clear(p_procedure_list);
6653         return l_result;
6654 }
6655
6656 /* FIXME DOC*/
6657 static OPJ_BOOL opj_j2k_copy_default_tcp_and_create_tcd (       opj_j2k_t * p_j2k,
6658                                                             opj_stream_private_t *p_stream,
6659                                                             opj_event_mgr_t * p_manager
6660                                                             )
6661 {
6662         opj_tcp_t * l_tcp = 00;
6663         opj_tcp_t * l_default_tcp = 00;
6664         OPJ_UINT32 l_nb_tiles;
6665         OPJ_UINT32 i,j;
6666         opj_tccp_t *l_current_tccp = 00;
6667         OPJ_UINT32 l_tccp_size;
6668         OPJ_UINT32 l_mct_size;
6669         opj_image_t * l_image;
6670         OPJ_UINT32 l_mcc_records_size,l_mct_records_size;
6671         opj_mct_data_t * l_src_mct_rec, *l_dest_mct_rec;
6672         opj_simple_mcc_decorrelation_data_t * l_src_mcc_rec, *l_dest_mcc_rec;
6673         OPJ_UINT32 l_offset;
6674
6675         /* preconditions */
6676         assert(p_j2k != 00);
6677         assert(p_stream != 00);
6678         assert(p_manager != 00);
6679
6680         l_image = p_j2k->m_private_image;
6681         l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
6682         l_tcp = p_j2k->m_cp.tcps;
6683         l_tccp_size = l_image->numcomps * sizeof(opj_tccp_t);
6684         l_default_tcp = p_j2k->m_specific_param.m_decoder.m_default_tcp;
6685         l_mct_size = l_image->numcomps * l_image->numcomps * sizeof(OPJ_FLOAT32);
6686
6687         /* For each tile */
6688         for (i=0; i<l_nb_tiles; ++i) {
6689                 /* keep the tile-compo coding parameters pointer of the current tile coding parameters*/
6690                 l_current_tccp = l_tcp->tccps;
6691                 /*Copy default coding parameters into the current tile coding parameters*/
6692                 memcpy(l_tcp, l_default_tcp, sizeof(opj_tcp_t));
6693                 /* Initialize some values of the current tile coding parameters*/
6694                 l_tcp->ppt = 0;
6695                 l_tcp->ppt_data = 00;
6696                 /* Reconnect the tile-compo coding parameters pointer to the current tile coding parameters*/
6697                 l_tcp->tccps = l_current_tccp;
6698
6699                 /* Get the mct_decoding_matrix of the dflt_tile_cp and copy them into the current tile cp*/
6700                 if (l_default_tcp->m_mct_decoding_matrix) {
6701                         l_tcp->m_mct_decoding_matrix = (OPJ_FLOAT32*)opj_malloc(l_mct_size);
6702                         if (! l_tcp->m_mct_decoding_matrix ) {
6703                                 return OPJ_FALSE;
6704                         }
6705                         memcpy(l_tcp->m_mct_decoding_matrix,l_default_tcp->m_mct_decoding_matrix,l_mct_size);
6706                 }
6707
6708                 /* Get the mct_record of the dflt_tile_cp and copy them into the current tile cp*/
6709                 l_mct_records_size = l_default_tcp->m_nb_max_mct_records * sizeof(opj_mct_data_t);
6710                 l_tcp->m_mct_records = (opj_mct_data_t*)opj_malloc(l_mct_records_size);
6711                 if (! l_tcp->m_mct_records) {
6712                         return OPJ_FALSE;
6713                 }
6714                 memcpy(l_tcp->m_mct_records, l_default_tcp->m_mct_records,l_mct_records_size);
6715
6716                 /* Copy the mct record data from dflt_tile_cp to the current tile*/
6717                 l_src_mct_rec = l_default_tcp->m_mct_records;
6718                 l_dest_mct_rec = l_tcp->m_mct_records;
6719
6720                 for (j=0;j<l_default_tcp->m_nb_mct_records;++j) {
6721
6722                         if (l_src_mct_rec->m_data) {
6723
6724                                 l_dest_mct_rec->m_data = (OPJ_BYTE*) opj_malloc(l_src_mct_rec->m_data_size);
6725                                 if(! l_dest_mct_rec->m_data) {
6726                                         return OPJ_FALSE;
6727                                 }
6728                                 memcpy(l_dest_mct_rec->m_data,l_src_mct_rec->m_data,l_src_mct_rec->m_data_size);
6729                         }
6730
6731                         ++l_src_mct_rec;
6732                         ++l_dest_mct_rec;
6733                 }
6734
6735                 /* Get the mcc_record of the dflt_tile_cp and copy them into the current tile cp*/
6736                 l_mcc_records_size = l_default_tcp->m_nb_max_mcc_records * sizeof(opj_simple_mcc_decorrelation_data_t);
6737                 l_tcp->m_mcc_records = (opj_simple_mcc_decorrelation_data_t*) opj_malloc(l_mcc_records_size);
6738                 if (! l_tcp->m_mcc_records) {
6739                         return OPJ_FALSE;
6740                 }
6741                 memcpy(l_tcp->m_mcc_records,l_default_tcp->m_mcc_records,l_mcc_records_size);
6742
6743                 /* Copy the mcc record data from dflt_tile_cp to the current tile*/
6744                 l_src_mcc_rec = l_default_tcp->m_mcc_records;
6745                 l_dest_mcc_rec = l_tcp->m_mcc_records;
6746
6747                 for (j=0;j<l_default_tcp->m_nb_max_mcc_records;++j) {
6748
6749                         if (l_src_mcc_rec->m_decorrelation_array) {
6750                                 l_offset = l_src_mcc_rec->m_decorrelation_array - l_default_tcp->m_mct_records;
6751                                 l_dest_mcc_rec->m_decorrelation_array = l_tcp->m_mct_records + l_offset;
6752                         }
6753
6754                         if (l_src_mcc_rec->m_offset_array) {
6755                                 l_offset = l_src_mcc_rec->m_offset_array - l_default_tcp->m_mct_records;
6756                                 l_dest_mcc_rec->m_offset_array = l_tcp->m_mct_records + l_offset;
6757                         }
6758
6759                         ++l_src_mcc_rec;
6760                         ++l_dest_mcc_rec;
6761                 }
6762
6763                 /* Copy all the dflt_tile_compo_cp to the current tile cp */
6764                 memcpy(l_current_tccp,l_default_tcp->tccps,l_tccp_size);
6765
6766                 /* Move to next tile cp*/
6767                 ++l_tcp;
6768         }
6769
6770         /* Create the current tile decoder*/
6771         p_j2k->m_tcd = (opj_tcd_t*)opj_tcd_create(OPJ_TRUE); /* FIXME why a cast ? */
6772         if (! p_j2k->m_tcd ) {
6773                 return OPJ_FALSE;
6774         }
6775
6776         if ( !opj_tcd_init(p_j2k->m_tcd, l_image, &(p_j2k->m_cp)) ) {
6777                 opj_tcd_destroy(p_j2k->m_tcd);
6778                 p_j2k->m_tcd = 00;
6779                 opj_event_msg(p_manager, EVT_ERROR, "Cannot decode tile, memory error\n");
6780                 return OPJ_FALSE;
6781         }
6782
6783         return OPJ_TRUE;
6784 }
6785
6786 const opj_dec_memory_marker_handler_t * opj_j2k_get_marker_handler (OPJ_UINT32 p_id)
6787 {
6788         const opj_dec_memory_marker_handler_t *e;
6789         for (e = j2k_memory_marker_handler_tab; e->id != 0; ++e) {
6790                 if (e->id == p_id) {
6791                         break; /* we find a handler corresponding to the marker ID*/
6792                 }
6793         }
6794         return e;
6795 }
6796
6797 void opj_j2k_destroy (opj_j2k_t *p_j2k)
6798 {
6799         if (p_j2k == 00) {
6800                 return;
6801         }
6802
6803         if (p_j2k->m_is_decoder) {
6804
6805                 if (p_j2k->m_specific_param.m_decoder.m_default_tcp != 00) {
6806                         opj_j2k_tcp_destroy(p_j2k->m_specific_param.m_decoder.m_default_tcp);
6807                         opj_free(p_j2k->m_specific_param.m_decoder.m_default_tcp);
6808                         p_j2k->m_specific_param.m_decoder.m_default_tcp = 00;
6809                 }
6810
6811                 if (p_j2k->m_specific_param.m_decoder.m_header_data != 00) {
6812                         opj_free(p_j2k->m_specific_param.m_decoder.m_header_data);
6813                         p_j2k->m_specific_param.m_decoder.m_header_data = 00;
6814                         p_j2k->m_specific_param.m_decoder.m_header_data_size = 0;
6815                 }
6816         }
6817         else {
6818
6819                 if (p_j2k->m_specific_param.m_encoder.m_encoded_tile_data) {
6820                         opj_free(p_j2k->m_specific_param.m_encoder.m_encoded_tile_data);
6821                         p_j2k->m_specific_param.m_encoder.m_encoded_tile_data = 00;
6822                 }
6823
6824                 if (p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer) {
6825                         opj_free(p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer);
6826                         p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer = 00;
6827                         p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current = 00;
6828                 }
6829
6830                 if (p_j2k->m_specific_param.m_encoder.m_header_tile_data) {
6831                         opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
6832                         p_j2k->m_specific_param.m_encoder.m_header_tile_data = 00;
6833                         p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
6834                 }
6835         }
6836
6837         opj_tcd_destroy(p_j2k->m_tcd);
6838
6839         opj_j2k_cp_destroy(&(p_j2k->m_cp));
6840         memset(&(p_j2k->m_cp),0,sizeof(opj_cp_t));
6841
6842         opj_procedure_list_destroy(p_j2k->m_procedure_list);
6843         p_j2k->m_procedure_list = 00;
6844
6845         opj_procedure_list_destroy(p_j2k->m_validation_list);
6846         p_j2k->m_procedure_list = 00;
6847
6848         j2k_destroy_cstr_index(p_j2k->cstr_index);
6849         p_j2k->cstr_index = NULL;
6850
6851         opj_image_destroy(p_j2k->m_private_image);
6852         p_j2k->m_private_image = NULL;
6853
6854         opj_image_destroy(p_j2k->m_output_image);
6855         p_j2k->m_output_image = NULL;
6856
6857         opj_free(p_j2k);
6858 }
6859
6860 void j2k_destroy_cstr_index (opj_codestream_index_t *p_cstr_ind)
6861 {
6862         if (p_cstr_ind) {
6863
6864                 if (p_cstr_ind->marker) {
6865                         opj_free(p_cstr_ind->marker);
6866                         p_cstr_ind->marker = NULL;
6867                 }
6868
6869                 if (p_cstr_ind->tile_index) {
6870                         OPJ_UINT32 it_tile = 0;
6871
6872                         for (it_tile=0; it_tile < p_cstr_ind->nb_of_tiles; it_tile++) {
6873
6874                                 if(p_cstr_ind->tile_index[it_tile].packet_index) {
6875                                         opj_free(p_cstr_ind->tile_index[it_tile].packet_index);
6876                                         p_cstr_ind->tile_index[it_tile].packet_index = NULL;
6877                                 }
6878
6879                                 if(p_cstr_ind->tile_index[it_tile].tp_index){
6880                                         opj_free(p_cstr_ind->tile_index[it_tile].tp_index);
6881                                         p_cstr_ind->tile_index[it_tile].tp_index = NULL;
6882                                 }
6883
6884                                 if(p_cstr_ind->tile_index[it_tile].marker){
6885                                         opj_free(p_cstr_ind->tile_index[it_tile].marker);
6886                                         p_cstr_ind->tile_index[it_tile].marker = NULL;
6887
6888                                 }
6889                         }
6890
6891                         opj_free( p_cstr_ind->tile_index);
6892                         p_cstr_ind->tile_index = NULL;
6893                 }
6894
6895                 opj_free(p_cstr_ind);
6896         }
6897 }
6898
6899 void opj_j2k_tcp_destroy (opj_tcp_t *p_tcp)
6900 {
6901         if (p_tcp == 00) {
6902                 return;
6903         }
6904
6905         if (p_tcp->ppt_buffer != 00) {
6906                 opj_free(p_tcp->ppt_buffer);
6907                 p_tcp->ppt_buffer = 00;
6908         }
6909
6910         if (p_tcp->tccps != 00) {
6911                 opj_free(p_tcp->tccps);
6912                 p_tcp->tccps = 00;
6913         }
6914
6915         if (p_tcp->m_mct_coding_matrix != 00) {
6916                 opj_free(p_tcp->m_mct_coding_matrix);
6917                 p_tcp->m_mct_coding_matrix = 00;
6918         }
6919
6920         if (p_tcp->m_mct_decoding_matrix != 00) {
6921                 opj_free(p_tcp->m_mct_decoding_matrix);
6922                 p_tcp->m_mct_decoding_matrix = 00;
6923         }
6924
6925         if (p_tcp->m_mcc_records) {
6926                 opj_free(p_tcp->m_mcc_records);
6927                 p_tcp->m_mcc_records = 00;
6928                 p_tcp->m_nb_max_mcc_records = 0;
6929                 p_tcp->m_nb_mcc_records = 0;
6930         }
6931
6932         if (p_tcp->m_mct_records) {
6933                 opj_mct_data_t * l_mct_data = p_tcp->m_mct_records;
6934                 OPJ_UINT32 i;
6935
6936                 for (i=0;i<p_tcp->m_nb_mct_records;++i) {
6937                         if (l_mct_data->m_data) {
6938                                 opj_free(l_mct_data->m_data);
6939                                 l_mct_data->m_data = 00;
6940                         }
6941
6942                         ++l_mct_data;
6943                 }
6944
6945                 opj_free(p_tcp->m_mct_records);
6946                 p_tcp->m_mct_records = 00;
6947         }
6948
6949         if (p_tcp->mct_norms != 00) {
6950                 opj_free(p_tcp->mct_norms);
6951                 p_tcp->mct_norms = 00;
6952         }
6953
6954         opj_j2k_tcp_data_destroy(p_tcp);
6955
6956 }
6957
6958 void opj_j2k_tcp_data_destroy (opj_tcp_t *p_tcp)
6959 {
6960         if (p_tcp->m_data) {
6961                 opj_free(p_tcp->m_data);
6962                 p_tcp->m_data = NULL;
6963                 p_tcp->m_data_size = 0;
6964         }
6965 }
6966
6967 void opj_j2k_cp_destroy (opj_cp_t *p_cp)
6968 {
6969         OPJ_UINT32 l_nb_tiles;
6970         opj_tcp_t * l_current_tile = 00;
6971         OPJ_UINT32 i;
6972
6973         if (p_cp == 00)
6974         {
6975                 return;
6976         }
6977         if (p_cp->tcps != 00)
6978         {
6979                 l_current_tile = p_cp->tcps;
6980                 l_nb_tiles = p_cp->th * p_cp->tw;
6981
6982                 for (i = 0; i < l_nb_tiles; ++i)
6983                 {
6984                         opj_j2k_tcp_destroy(l_current_tile);
6985                         ++l_current_tile;
6986                 }
6987                 opj_free(p_cp->tcps);
6988                 p_cp->tcps = 00;
6989         }
6990         opj_free(p_cp->ppm_buffer);
6991         p_cp->ppm_buffer = 00;
6992         p_cp->ppm_data = NULL; /* ppm_data belongs to the allocated buffer pointed by ppm_buffer */
6993         opj_free(p_cp->comment);
6994         p_cp->comment = 00;
6995         if (! p_cp->m_is_decoder)
6996         {
6997                 opj_free(p_cp->m_specific_param.m_enc.m_matrice);
6998                 p_cp->m_specific_param.m_enc.m_matrice = 00;
6999         }
7000 }
7001
7002 OPJ_BOOL opj_j2k_read_tile_header(      opj_j2k_t * p_j2k,
7003                                                                     OPJ_UINT32 * p_tile_index,
7004                                                                     OPJ_UINT32 * p_data_size,
7005                                                                     OPJ_INT32 * p_tile_x0, OPJ_INT32 * p_tile_y0,
7006                                                                     OPJ_INT32 * p_tile_x1, OPJ_INT32 * p_tile_y1,
7007                                                                     OPJ_UINT32 * p_nb_comps,
7008                                                                     OPJ_BOOL * p_go_on,
7009                                                                     opj_stream_private_t *p_stream,
7010                                                                     opj_event_mgr_t * p_manager )
7011 {
7012         OPJ_UINT32 l_current_marker = J2K_MS_SOT;
7013         OPJ_UINT32 l_marker_size;
7014         const opj_dec_memory_marker_handler_t * l_marker_handler = 00;
7015         opj_tcp_t * l_tcp = NULL;
7016         OPJ_UINT32 l_nb_tiles;
7017
7018         /* preconditions */
7019         assert(p_stream != 00);
7020         assert(p_j2k != 00);
7021         assert(p_manager != 00);
7022
7023         /* Reach the End Of Codestream ?*/
7024         if (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_EOC){
7025                 l_current_marker = J2K_MS_EOC;
7026         }
7027         /* We need to encounter a SOT marker (a new tile-part header) */
7028         else if (p_j2k->m_specific_param.m_decoder.m_state != J2K_STATE_TPHSOT){
7029                 return OPJ_FALSE;
7030         }
7031
7032         /* Read into the codestream until reach the EOC or ! can_decode ??? FIXME */
7033         while ( (!p_j2k->m_specific_param.m_decoder.m_can_decode) && (l_current_marker != J2K_MS_EOC) ) {
7034
7035                 /* Try to read until the Start Of Data is detected */
7036                 while (l_current_marker != J2K_MS_SOD) {
7037
7038                     if(opj_stream_get_number_byte_left(p_stream) == 0)
7039                     {
7040                         p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_NEOC;
7041                         break;
7042                     }
7043
7044                         /* Try to read 2 bytes (the marker size) from stream and copy them into the buffer */
7045                         if (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,2,p_manager) != 2) {
7046                                 opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
7047                                 return OPJ_FALSE;
7048                         }
7049
7050                         /* Read 2 bytes from the buffer as the marker size */
7051                         opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,&l_marker_size,2);
7052
7053                         /* Why this condition? FIXME */
7054                         if (p_j2k->m_specific_param.m_decoder.m_state & J2K_STATE_TPH){
7055                                 p_j2k->m_specific_param.m_decoder.m_sot_length -= (l_marker_size + 2);
7056                         }
7057                         l_marker_size -= 2; /* Subtract the size of the marker ID already read */
7058
7059                         /* Get the marker handler from the marker ID */
7060                         l_marker_handler = opj_j2k_get_marker_handler(l_current_marker);
7061
7062                         /* Check if the marker is known and if it is the right place to find it */
7063                         if (! (p_j2k->m_specific_param.m_decoder.m_state & l_marker_handler->states) ) {
7064                                 opj_event_msg(p_manager, EVT_ERROR, "Marker is not compliant with its position\n");
7065                                 return OPJ_FALSE;
7066                         }
7067 /* FIXME manage case of unknown marker as in the main header ? */
7068
7069                         /* Check if the marker size is compatible with the header data size */
7070                         if (l_marker_size > p_j2k->m_specific_param.m_decoder.m_header_data_size) {
7071                                 OPJ_BYTE *new_header_data = (OPJ_BYTE *) opj_realloc(p_j2k->m_specific_param.m_decoder.m_header_data, l_marker_size);
7072                                 if (! new_header_data) {
7073                                         opj_free(p_j2k->m_specific_param.m_decoder.m_header_data);
7074                                         p_j2k->m_specific_param.m_decoder.m_header_data = NULL;
7075                                         p_j2k->m_specific_param.m_decoder.m_header_data_size = 0;
7076                                         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read header\n");
7077                                         return OPJ_FALSE;
7078                                 }
7079                                 p_j2k->m_specific_param.m_decoder.m_header_data = new_header_data;
7080                                 p_j2k->m_specific_param.m_decoder.m_header_data_size = l_marker_size;
7081                         }
7082
7083                         /* Try to read the rest of the marker segment from stream and copy them into the buffer */
7084                         if (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,l_marker_size,p_manager) != l_marker_size) {
7085                                 opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
7086                                 return OPJ_FALSE;
7087                         }
7088
7089                         if (!l_marker_handler->handler) {
7090                                 /* See issue #175 */
7091                                 opj_event_msg(p_manager, EVT_ERROR, "Not sure how that happened.\n");
7092                                 return OPJ_FALSE;
7093                         }
7094                         /* Read the marker segment with the correct marker handler */
7095                         if (! (*(l_marker_handler->handler))(p_j2k,p_j2k->m_specific_param.m_decoder.m_header_data,l_marker_size,p_manager)) {
7096                                 opj_event_msg(p_manager, EVT_ERROR, "Fail to read the current marker segment (%#x)\n", l_current_marker);
7097                                 return OPJ_FALSE;
7098                         }
7099
7100                         /* Add the marker to the codestream index*/
7101                         if (OPJ_FALSE == opj_j2k_add_tlmarker(p_j2k->m_current_tile_number,
7102                                                 p_j2k->cstr_index,
7103                                                 l_marker_handler->id,
7104                                                 (OPJ_UINT32) opj_stream_tell(p_stream) - l_marker_size - 4,
7105                                                 l_marker_size + 4 )) {
7106                                 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to add tl marker\n");
7107                                 return OPJ_FALSE;
7108                         }
7109
7110                         /* Keep the position of the last SOT marker read */
7111                         if ( l_marker_handler->id == J2K_MS_SOT ) {
7112                                 OPJ_UINT32 sot_pos = (OPJ_UINT32) opj_stream_tell(p_stream) - l_marker_size - 4 ;
7113                                 if (sot_pos > p_j2k->m_specific_param.m_decoder.m_last_sot_read_pos)
7114                                 {
7115                                         p_j2k->m_specific_param.m_decoder.m_last_sot_read_pos = sot_pos;
7116                                 }
7117                         }
7118
7119                         if (p_j2k->m_specific_param.m_decoder.m_skip_data) {
7120                                 /* Skip the rest of the tile part header*/
7121                                 if (opj_stream_skip(p_stream,p_j2k->m_specific_param.m_decoder.m_sot_length,p_manager) != p_j2k->m_specific_param.m_decoder.m_sot_length) {
7122                                         opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
7123                                         return OPJ_FALSE;
7124                                 }
7125                                 l_current_marker = J2K_MS_SOD; /* Normally we reached a SOD */
7126                         }
7127                         else {
7128                                 /* Try to read 2 bytes (the next marker ID) from stream and copy them into the buffer*/
7129                                 if (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,2,p_manager) != 2) {
7130                                         opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
7131                                         return OPJ_FALSE;
7132                                 }
7133                                 /* Read 2 bytes from the buffer as the new marker ID */
7134                                 opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,&l_current_marker,2);
7135                         }
7136                 }
7137                 if(opj_stream_get_number_byte_left(p_stream) == 0
7138                     && p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_NEOC)
7139                     break;
7140
7141                 /* If we didn't skip data before, we need to read the SOD marker*/
7142                 if (! p_j2k->m_specific_param.m_decoder.m_skip_data) {
7143                         /* Try to read the SOD marker and skip data ? FIXME */
7144                         if (! opj_j2k_read_sod(p_j2k, p_stream, p_manager)) {
7145                                 return OPJ_FALSE;
7146                         }
7147
7148                         if (! p_j2k->m_specific_param.m_decoder.m_can_decode){
7149                                 /* Try to read 2 bytes (the next marker ID) from stream and copy them into the buffer */
7150                                 if (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,2,p_manager) != 2) {
7151                                         opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
7152                                         return OPJ_FALSE;
7153                                 }
7154
7155                                 /* Read 2 bytes from buffer as the new marker ID */
7156                                 opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,&l_current_marker,2);
7157                         }
7158                 }
7159                 else {
7160                         /* Indicate we will try to read a new tile-part header*/
7161                         p_j2k->m_specific_param.m_decoder.m_skip_data = 0;
7162                         p_j2k->m_specific_param.m_decoder.m_can_decode = 0;
7163                         p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_TPHSOT;
7164
7165                         /* Try to read 2 bytes (the next marker ID) from stream and copy them into the buffer */
7166                         if (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,2,p_manager) != 2) {
7167                                 opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
7168                                 return OPJ_FALSE;
7169                         }
7170
7171                         /* Read 2 bytes from buffer as the new marker ID */
7172                         opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,&l_current_marker,2);
7173                 }
7174         }
7175
7176         /* Current marker is the EOC marker ?*/
7177         if (l_current_marker == J2K_MS_EOC) {
7178                 if (p_j2k->m_specific_param.m_decoder.m_state != J2K_STATE_EOC ){
7179                         p_j2k->m_current_tile_number = 0;
7180                         p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_EOC;
7181                 }
7182         }
7183
7184         /* FIXME DOC ???*/
7185         if ( ! p_j2k->m_specific_param.m_decoder.m_can_decode) {
7186                 l_tcp = p_j2k->m_cp.tcps + p_j2k->m_current_tile_number;
7187                 l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
7188
7189                 while( (p_j2k->m_current_tile_number < l_nb_tiles) && (l_tcp->m_data == 00) ) {
7190                         ++p_j2k->m_current_tile_number;
7191                         ++l_tcp;
7192                 }
7193
7194                 if (p_j2k->m_current_tile_number == l_nb_tiles) {
7195                         *p_go_on = OPJ_FALSE;
7196                         return OPJ_TRUE;
7197                 }
7198         }
7199
7200         /*FIXME ???*/
7201         if (! opj_tcd_init_decode_tile(p_j2k->m_tcd, p_j2k->m_current_tile_number)) {
7202                 opj_event_msg(p_manager, EVT_ERROR, "Cannot decode tile, memory error\n");
7203                 return OPJ_FALSE;
7204         }
7205
7206         opj_event_msg(p_manager, EVT_INFO, "Header of tile %d / %d has been read.\n",
7207                         p_j2k->m_current_tile_number, (p_j2k->m_cp.th * p_j2k->m_cp.tw) - 1);
7208
7209         *p_tile_index = p_j2k->m_current_tile_number;
7210         *p_go_on = OPJ_TRUE;
7211         *p_data_size = opj_tcd_get_decoded_tile_size(p_j2k->m_tcd);
7212         *p_tile_x0 = p_j2k->m_tcd->tcd_image->tiles->x0;
7213         *p_tile_y0 = p_j2k->m_tcd->tcd_image->tiles->y0;
7214         *p_tile_x1 = p_j2k->m_tcd->tcd_image->tiles->x1;
7215         *p_tile_y1 = p_j2k->m_tcd->tcd_image->tiles->y1;
7216         *p_nb_comps = p_j2k->m_tcd->tcd_image->tiles->numcomps;
7217
7218          p_j2k->m_specific_param.m_decoder.m_state |= 0x0080;/* FIXME J2K_DEC_STATE_DATA;*/
7219
7220         return OPJ_TRUE;
7221 }
7222
7223 OPJ_BOOL opj_j2k_decode_tile (  opj_j2k_t * p_j2k,
7224                                                         OPJ_UINT32 p_tile_index,
7225                                                         OPJ_BYTE * p_data,
7226                                                         OPJ_UINT32 p_data_size,
7227                                                         opj_stream_private_t *p_stream,
7228                                                         opj_event_mgr_t * p_manager )
7229 {
7230         OPJ_UINT32 l_current_marker;
7231         OPJ_BYTE l_data [2];
7232         opj_tcp_t * l_tcp;
7233
7234         /* preconditions */
7235         assert(p_stream != 00);
7236         assert(p_j2k != 00);
7237         assert(p_manager != 00);
7238
7239         if ( !(p_j2k->m_specific_param.m_decoder.m_state & 0x0080/*FIXME J2K_DEC_STATE_DATA*/)
7240                 || (p_tile_index != p_j2k->m_current_tile_number) ) {
7241                 return OPJ_FALSE;
7242         }
7243
7244         l_tcp = &(p_j2k->m_cp.tcps[p_tile_index]);
7245         if (! l_tcp->m_data) {
7246                 opj_j2k_tcp_destroy(l_tcp);
7247                 return OPJ_FALSE;
7248         }
7249
7250         if (! opj_tcd_decode_tile(      p_j2k->m_tcd,
7251                                                                 l_tcp->m_data,
7252                                                                 l_tcp->m_data_size,
7253                                                                 p_tile_index,
7254                                                                 p_j2k->cstr_index) ) {
7255                 opj_j2k_tcp_destroy(l_tcp);
7256                 p_j2k->m_specific_param.m_decoder.m_state |= 0x8000;/*FIXME J2K_DEC_STATE_ERR;*/
7257                 return OPJ_FALSE;
7258         }
7259
7260         if (! opj_tcd_update_tile_data(p_j2k->m_tcd,p_data,p_data_size)) {
7261                 return OPJ_FALSE;
7262         }
7263
7264         /* To avoid to destroy the tcp which can be useful when we try to decode a tile decoded before (cf j2k_random_tile_access)
7265          * we destroy just the data which will be re-read in read_tile_header*/
7266         /*opj_j2k_tcp_destroy(l_tcp);
7267         p_j2k->m_tcd->tcp = 0;*/
7268         opj_j2k_tcp_data_destroy(l_tcp);
7269
7270         p_j2k->m_specific_param.m_decoder.m_can_decode = 0;
7271         p_j2k->m_specific_param.m_decoder.m_state &= (~ (0x0080));/* FIXME J2K_DEC_STATE_DATA);*/
7272
7273         if(opj_stream_get_number_byte_left(p_stream) == 0
7274             && p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_NEOC){
7275             return OPJ_TRUE;
7276         }
7277
7278         if (p_j2k->m_specific_param.m_decoder.m_state != 0x0100){ /*FIXME J2K_DEC_STATE_EOC)*/
7279                 if (opj_stream_read_data(p_stream,l_data,2,p_manager) != 2) {
7280                         opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
7281                         return OPJ_FALSE;
7282                 }
7283
7284                 opj_read_bytes(l_data,&l_current_marker,2);
7285
7286                 if (l_current_marker == J2K_MS_EOC) {
7287                         p_j2k->m_current_tile_number = 0;
7288                         p_j2k->m_specific_param.m_decoder.m_state =  0x0100;/*FIXME J2K_DEC_STATE_EOC;*/
7289                 }
7290                 else if (l_current_marker != J2K_MS_SOT)
7291                 {
7292                         opj_event_msg(p_manager, EVT_ERROR, "Stream too short, expected SOT\n");
7293
7294                         if(opj_stream_get_number_byte_left(p_stream) == 0) {
7295                             p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_NEOC;
7296                             return OPJ_TRUE;
7297                         }
7298                         return OPJ_FALSE;
7299                 }
7300         }
7301
7302         return OPJ_TRUE;
7303 }
7304
7305 OPJ_BOOL opj_j2k_update_image_data (opj_tcd_t * p_tcd, OPJ_BYTE * p_data, opj_image_t* p_output_image)
7306 {
7307         OPJ_UINT32 i,j,k = 0;
7308         OPJ_UINT32 l_width_src,l_height_src;
7309         OPJ_UINT32 l_width_dest,l_height_dest;
7310         OPJ_INT32 l_offset_x0_src, l_offset_y0_src, l_offset_x1_src, l_offset_y1_src;
7311         OPJ_INT32 l_start_offset_src, l_line_offset_src, l_end_offset_src ;
7312         OPJ_UINT32 l_start_x_dest , l_start_y_dest;
7313         OPJ_UINT32 l_x0_dest, l_y0_dest, l_x1_dest, l_y1_dest;
7314         OPJ_INT32 l_start_offset_dest, l_line_offset_dest;
7315
7316         opj_image_comp_t * l_img_comp_src = 00;
7317         opj_image_comp_t * l_img_comp_dest = 00;
7318
7319         opj_tcd_tilecomp_t * l_tilec = 00;
7320         opj_image_t * l_image_src = 00;
7321         OPJ_UINT32 l_size_comp, l_remaining;
7322         OPJ_INT32 * l_dest_ptr;
7323         opj_tcd_resolution_t* l_res= 00;
7324
7325         l_tilec = p_tcd->tcd_image->tiles->comps;
7326         l_image_src = p_tcd->image;
7327         l_img_comp_src = l_image_src->comps;
7328
7329         l_img_comp_dest = p_output_image->comps;
7330
7331         for (i=0; i<l_image_src->numcomps; i++) {
7332
7333                 /* Allocate output component buffer if necessary */
7334                 if (!l_img_comp_dest->data) {
7335
7336                         l_img_comp_dest->data = (OPJ_INT32*) opj_calloc(l_img_comp_dest->w * l_img_comp_dest->h, sizeof(OPJ_INT32));
7337                         if (! l_img_comp_dest->data) {
7338                                 return OPJ_FALSE;
7339                         }
7340                 }
7341
7342                 /* Copy info from decoded comp image to output image */
7343                 l_img_comp_dest->resno_decoded = l_img_comp_src->resno_decoded;
7344
7345                 /*-----*/
7346                 /* Compute the precision of the output buffer */
7347                 l_size_comp = l_img_comp_src->prec >> 3; /*(/ 8)*/
7348                 l_remaining = l_img_comp_src->prec & 7;  /* (%8) */
7349                 l_res = l_tilec->resolutions + l_img_comp_src->resno_decoded;
7350
7351                 if (l_remaining) {
7352                         ++l_size_comp;
7353                 }
7354
7355                 if (l_size_comp == 3) {
7356                         l_size_comp = 4;
7357                 }
7358                 /*-----*/
7359
7360                 /* Current tile component size*/
7361                 /*if (i == 0) {
7362                 fprintf(stdout, "SRC: l_res_x0=%d, l_res_x1=%d, l_res_y0=%d, l_res_y1=%d\n",
7363                                 l_res->x0, l_res->x1, l_res->y0, l_res->y1);
7364                 }*/
7365
7366                 l_width_src = (l_res->x1 - l_res->x0);
7367                 l_height_src = (l_res->y1 - l_res->y0);
7368
7369                 /* Border of the current output component*/
7370                 l_x0_dest = opj_int_ceildivpow2(l_img_comp_dest->x0, l_img_comp_dest->factor);
7371                 l_y0_dest = opj_int_ceildivpow2(l_img_comp_dest->y0, l_img_comp_dest->factor);
7372                 l_x1_dest = l_x0_dest + l_img_comp_dest->w;
7373                 l_y1_dest = l_y0_dest + l_img_comp_dest->h;
7374
7375                 /*if (i == 0) {
7376                 fprintf(stdout, "DEST: l_x0_dest=%d, l_x1_dest=%d, l_y0_dest=%d, l_y1_dest=%d (%d)\n",
7377                                 l_x0_dest, l_x1_dest, l_y0_dest, l_y1_dest, l_img_comp_dest->factor );
7378                 }*/
7379
7380                 /*-----*/
7381                 /* Compute the area (l_offset_x0_src, l_offset_y0_src, l_offset_x1_src, l_offset_y1_src)
7382                  * of the input buffer (decoded tile component) which will be move
7383                  * in the output buffer. Compute the area of the output buffer (l_start_x_dest,
7384                  * l_start_y_dest, l_width_dest, l_height_dest)  which will be modified
7385                  * by this input area.
7386                  * */
7387                 assert( l_res->x0 >= 0);
7388                 assert( l_res->x1 >= 0);
7389                 if ( l_x0_dest < (OPJ_UINT32)l_res->x0 ) {
7390                         l_start_x_dest = l_res->x0 - l_x0_dest;
7391                         l_offset_x0_src = 0;
7392
7393                         if ( l_x1_dest >= (OPJ_UINT32)l_res->x1 ) {
7394                                 l_width_dest = l_width_src;
7395                                 l_offset_x1_src = 0;
7396                         }
7397                         else {
7398                                 l_width_dest = l_x1_dest - l_res->x0 ;
7399                                 l_offset_x1_src = l_width_src - l_width_dest;
7400                         }
7401                 }
7402                 else {
7403                         l_start_x_dest = 0 ;
7404                         l_offset_x0_src = l_x0_dest - l_res->x0;
7405
7406                         if ( l_x1_dest >= (OPJ_UINT32)l_res->x1 ) {
7407                                 l_width_dest = l_width_src - l_offset_x0_src;
7408                                 l_offset_x1_src = 0;
7409                         }
7410                         else {
7411                                 l_width_dest = l_img_comp_dest->w ;
7412                                 l_offset_x1_src = l_res->x1 - l_x1_dest;
7413                         }
7414                 }
7415
7416                 if ( l_y0_dest < (OPJ_UINT32)l_res->y0 ) {
7417                         l_start_y_dest = l_res->y0 - l_y0_dest;
7418                         l_offset_y0_src = 0;
7419
7420                         if ( l_y1_dest >= (OPJ_UINT32)l_res->y1 ) {
7421                                 l_height_dest = l_height_src;
7422                                 l_offset_y1_src = 0;
7423                         }
7424                         else {
7425                                 l_height_dest = l_y1_dest - l_res->y0 ;
7426                                 l_offset_y1_src =  l_height_src - l_height_dest;
7427                         }
7428                 }
7429                 else {
7430                         l_start_y_dest = 0 ;
7431                         l_offset_y0_src = l_y0_dest - l_res->y0;
7432
7433                         if ( l_y1_dest >= (OPJ_UINT32)l_res->y1 ) {
7434                                 l_height_dest = l_height_src - l_offset_y0_src;
7435                                 l_offset_y1_src = 0;
7436                         }
7437                         else {
7438                                 l_height_dest = l_img_comp_dest->h ;
7439                                 l_offset_y1_src = l_res->y1 - l_y1_dest;
7440                         }
7441                 }
7442
7443                 if( (l_offset_x0_src < 0 ) || (l_offset_y0_src < 0 ) || (l_offset_x1_src < 0 ) || (l_offset_y1_src < 0 ) ){
7444                         return OPJ_FALSE;
7445                 }
7446                 /*-----*/
7447
7448                 /* Compute the input buffer offset */
7449                 l_start_offset_src = l_offset_x0_src + l_offset_y0_src * l_width_src;
7450                 l_line_offset_src = l_offset_x1_src + l_offset_x0_src;
7451                 l_end_offset_src = l_offset_y1_src * l_width_src - l_offset_x0_src;
7452
7453                 /* Compute the output buffer offset */
7454                 l_start_offset_dest = l_start_x_dest + l_start_y_dest * l_img_comp_dest->w;
7455                 l_line_offset_dest = l_img_comp_dest->w - l_width_dest;
7456
7457                 /* Move the output buffer to the first place where we will write*/
7458                 l_dest_ptr = l_img_comp_dest->data + l_start_offset_dest;
7459
7460                 /*if (i == 0) {
7461                         fprintf(stdout, "COMPO[%d]:\n",i);
7462                         fprintf(stdout, "SRC: l_start_x_src=%d, l_start_y_src=%d, l_width_src=%d, l_height_src=%d\n"
7463                                         "\t tile offset:%d, %d, %d, %d\n"
7464                                         "\t buffer offset: %d; %d, %d\n",
7465                                         l_res->x0, l_res->y0, l_width_src, l_height_src,
7466                                         l_offset_x0_src, l_offset_y0_src, l_offset_x1_src, l_offset_y1_src,
7467                                         l_start_offset_src, l_line_offset_src, l_end_offset_src);
7468
7469                         fprintf(stdout, "DEST: l_start_x_dest=%d, l_start_y_dest=%d, l_width_dest=%d, l_height_dest=%d\n"
7470                                         "\t start offset: %d, line offset= %d\n",
7471                                         l_start_x_dest, l_start_y_dest, l_width_dest, l_height_dest, l_start_offset_dest, l_line_offset_dest);
7472                 }*/
7473
7474                 switch (l_size_comp) {
7475                         case 1:
7476                                 {
7477                                         OPJ_CHAR * l_src_ptr = (OPJ_CHAR*) p_data;
7478                                         l_src_ptr += l_start_offset_src; /* Move to the first place where we will read*/
7479
7480                                         if (l_img_comp_src->sgnd) {
7481                                                 for (j = 0 ; j < l_height_dest ; ++j) {
7482                                                         for ( k = 0 ; k < l_width_dest ; ++k) {
7483                                                                 *(l_dest_ptr++) = (OPJ_INT32) (*(l_src_ptr++)); /* Copy only the data needed for the output image */
7484                                                         }
7485
7486                                                         l_dest_ptr+= l_line_offset_dest; /* Move to the next place where we will write */
7487                                                         l_src_ptr += l_line_offset_src ; /* Move to the next place where we will read */
7488                                                 }
7489                                         }
7490                                         else {
7491                                                 for ( j = 0 ; j < l_height_dest ; ++j ) {
7492                                                         for ( k = 0 ; k < l_width_dest ; ++k) {
7493                                                                 *(l_dest_ptr++) = (OPJ_INT32) ((*(l_src_ptr++))&0xff);
7494                                                         }
7495
7496                                                         l_dest_ptr+= l_line_offset_dest;
7497                                                         l_src_ptr += l_line_offset_src;
7498                                                 }
7499                                         }
7500
7501                                         l_src_ptr += l_end_offset_src; /* Move to the end of this component-part of the input buffer */
7502                                         p_data = (OPJ_BYTE*) l_src_ptr; /* Keep the current position for the next component-part */
7503                                 }
7504                                 break;
7505                         case 2:
7506                                 {
7507                                         OPJ_INT16 * l_src_ptr = (OPJ_INT16 *) p_data;
7508                                         l_src_ptr += l_start_offset_src;
7509
7510                                         if (l_img_comp_src->sgnd) {
7511                                                 for (j=0;j<l_height_dest;++j) {
7512                                                         for (k=0;k<l_width_dest;++k) {
7513                                                                 *(l_dest_ptr++) = *(l_src_ptr++);
7514                                                         }
7515
7516                                                         l_dest_ptr+= l_line_offset_dest;
7517                                                         l_src_ptr += l_line_offset_src ;
7518                                                 }
7519                                         }
7520                                         else {
7521                                                 for (j=0;j<l_height_dest;++j) {
7522                                                         for (k=0;k<l_width_dest;++k) {
7523                                                                 *(l_dest_ptr++) = (*(l_src_ptr++))&0xffff;
7524                                                         }
7525
7526                                                         l_dest_ptr+= l_line_offset_dest;
7527                                                         l_src_ptr += l_line_offset_src ;
7528                                                 }
7529                                         }
7530
7531                                         l_src_ptr += l_end_offset_src;
7532                                         p_data = (OPJ_BYTE*) l_src_ptr;
7533                                 }
7534                                 break;
7535                         case 4:
7536                                 {
7537                                         OPJ_INT32 * l_src_ptr = (OPJ_INT32 *) p_data;
7538                                         l_src_ptr += l_start_offset_src;
7539
7540                                         for (j=0;j<l_height_dest;++j) {
7541                                                 for (k=0;k<l_width_dest;++k) {
7542                                                         *(l_dest_ptr++) = (*(l_src_ptr++));
7543                                                 }
7544
7545                                                 l_dest_ptr+= l_line_offset_dest;
7546                                                 l_src_ptr += l_line_offset_src ;
7547                                         }
7548
7549                                         l_src_ptr += l_end_offset_src;
7550                                         p_data = (OPJ_BYTE*) l_src_ptr;
7551                                 }
7552                                 break;
7553                 }
7554
7555                 ++l_img_comp_dest;
7556                 ++l_img_comp_src;
7557                 ++l_tilec;
7558         }
7559
7560         return OPJ_TRUE;
7561 }
7562
7563 OPJ_BOOL opj_j2k_set_decode_area(       opj_j2k_t *p_j2k,
7564                                                                     opj_image_t* p_image,
7565                                                                     OPJ_INT32 p_start_x, OPJ_INT32 p_start_y,
7566                                                                     OPJ_INT32 p_end_x, OPJ_INT32 p_end_y,
7567                                                                     opj_event_mgr_t * p_manager )
7568 {
7569         opj_cp_t * l_cp = &(p_j2k->m_cp);
7570         opj_image_t * l_image = p_j2k->m_private_image;
7571
7572         OPJ_UINT32 it_comp;
7573         OPJ_INT32 l_comp_x1, l_comp_y1;
7574         opj_image_comp_t* l_img_comp = NULL;
7575
7576         /* Check if we are read the main header */
7577         if (p_j2k->m_specific_param.m_decoder.m_state != J2K_STATE_TPHSOT) { /* FIXME J2K_DEC_STATE_TPHSOT)*/
7578                 opj_event_msg(p_manager, EVT_ERROR, "Need to decode the main header before begin to decode the remaining codestream");
7579                 return OPJ_FALSE;
7580         }
7581
7582         if ( !p_start_x && !p_start_y && !p_end_x && !p_end_y){
7583                 opj_event_msg(p_manager, EVT_INFO, "No decoded area parameters, set the decoded area to the whole image\n");
7584
7585                 p_j2k->m_specific_param.m_decoder.m_start_tile_x = 0;
7586                 p_j2k->m_specific_param.m_decoder.m_start_tile_y = 0;
7587                 p_j2k->m_specific_param.m_decoder.m_end_tile_x = l_cp->tw;
7588                 p_j2k->m_specific_param.m_decoder.m_end_tile_y = l_cp->th;
7589
7590                 return OPJ_TRUE;
7591         }
7592
7593         /* ----- */
7594         /* Check if the positions provided by the user are correct */
7595
7596         /* Left */
7597         assert(p_start_x >= 0 );
7598         assert(p_start_y >= 0 );
7599
7600         if ((OPJ_UINT32)p_start_x > l_image->x1 ) {
7601                 opj_event_msg(p_manager, EVT_ERROR,
7602                         "Left position of the decoded area (region_x0=%d) is outside the image area (Xsiz=%d).\n",
7603                         p_start_x, l_image->x1);
7604                 return OPJ_FALSE;
7605         }
7606         else if ((OPJ_UINT32)p_start_x < l_image->x0){
7607                 opj_event_msg(p_manager, EVT_WARNING,
7608                                 "Left position of the decoded area (region_x0=%d) is outside the image area (XOsiz=%d).\n",
7609                                 p_start_x, l_image->x0);
7610                 p_j2k->m_specific_param.m_decoder.m_start_tile_x = 0;
7611                 p_image->x0 = l_image->x0;
7612         }
7613         else {
7614                 p_j2k->m_specific_param.m_decoder.m_start_tile_x = (p_start_x - l_cp->tx0) / l_cp->tdx;
7615                 p_image->x0 = p_start_x;
7616         }
7617
7618         /* Up */
7619         if ((OPJ_UINT32)p_start_y > l_image->y1){
7620                 opj_event_msg(p_manager, EVT_ERROR,
7621                                 "Up position of the decoded area (region_y0=%d) is outside the image area (Ysiz=%d).\n",
7622                                 p_start_y, l_image->y1);
7623                 return OPJ_FALSE;
7624         }
7625         else if ((OPJ_UINT32)p_start_y < l_image->y0){
7626                 opj_event_msg(p_manager, EVT_WARNING,
7627                                 "Up position of the decoded area (region_y0=%d) is outside the image area (YOsiz=%d).\n",
7628                                 p_start_y, l_image->y0);
7629                 p_j2k->m_specific_param.m_decoder.m_start_tile_y = 0;
7630                 p_image->y0 = l_image->y0;
7631         }
7632         else {
7633                 p_j2k->m_specific_param.m_decoder.m_start_tile_y = (p_start_y - l_cp->ty0) / l_cp->tdy;
7634                 p_image->y0 = p_start_y;
7635         }
7636
7637         /* Right */
7638         assert((OPJ_UINT32)p_end_x > 0);
7639         assert((OPJ_UINT32)p_end_y > 0);
7640         if ((OPJ_UINT32)p_end_x < l_image->x0) {
7641                 opj_event_msg(p_manager, EVT_ERROR,
7642                         "Right position of the decoded area (region_x1=%d) is outside the image area (XOsiz=%d).\n",
7643                         p_end_x, l_image->x0);
7644                 return OPJ_FALSE;
7645         }
7646         else if ((OPJ_UINT32)p_end_x > l_image->x1) {
7647                 opj_event_msg(p_manager, EVT_WARNING,
7648                         "Right position of the decoded area (region_x1=%d) is outside the image area (Xsiz=%d).\n",
7649                         p_end_x, l_image->x1);
7650                 p_j2k->m_specific_param.m_decoder.m_end_tile_x = l_cp->tw;
7651                 p_image->x1 = l_image->x1;
7652         }
7653         else {
7654                 p_j2k->m_specific_param.m_decoder.m_end_tile_x = opj_int_ceildiv((p_end_x - l_cp->tx0), l_cp->tdx);
7655                 p_image->x1 = p_end_x;
7656         }
7657
7658         /* Bottom */
7659         if ((OPJ_UINT32)p_end_y < l_image->y0) {
7660                 opj_event_msg(p_manager, EVT_ERROR,
7661                         "Bottom position of the decoded area (region_y1=%d) is outside the image area (YOsiz=%d).\n",
7662                         p_end_y, l_image->y0);
7663                 return OPJ_FALSE;
7664         }
7665         if ((OPJ_UINT32)p_end_y > l_image->y1){
7666                 opj_event_msg(p_manager, EVT_WARNING,
7667                         "Bottom position of the decoded area (region_y1=%d) is outside the image area (Ysiz=%d).\n",
7668                         p_end_y, l_image->y1);
7669                 p_j2k->m_specific_param.m_decoder.m_end_tile_y = l_cp->th;
7670                 p_image->y1 = l_image->y1;
7671         }
7672         else{
7673                 p_j2k->m_specific_param.m_decoder.m_end_tile_y = opj_int_ceildiv((p_end_y - l_cp->ty0), l_cp->tdy);
7674                 p_image->y1 = p_end_y;
7675         }
7676         /* ----- */
7677
7678         p_j2k->m_specific_param.m_decoder.m_discard_tiles = 1;
7679
7680         l_img_comp = p_image->comps;
7681         for (it_comp=0; it_comp < p_image->numcomps; ++it_comp)
7682         {
7683                 OPJ_INT32 l_h,l_w;
7684
7685                 l_img_comp->x0 = opj_int_ceildiv(p_image->x0, l_img_comp->dx);
7686                 l_img_comp->y0 = opj_int_ceildiv(p_image->y0, l_img_comp->dy);
7687                 l_comp_x1 = opj_int_ceildiv(p_image->x1, l_img_comp->dx);
7688                 l_comp_y1 = opj_int_ceildiv(p_image->y1, l_img_comp->dy);
7689
7690                 l_w = opj_int_ceildivpow2(l_comp_x1, l_img_comp->factor)
7691                                 - opj_int_ceildivpow2(l_img_comp->x0, l_img_comp->factor);
7692                 if (l_w < 0){
7693                         opj_event_msg(p_manager, EVT_ERROR,
7694                                 "Size x of the decoded component image is incorrect (comp[%d].w=%d).\n",
7695                                 it_comp, l_w);
7696                         return OPJ_FALSE;
7697                 }
7698                 l_img_comp->w = l_w;
7699
7700                 l_h = opj_int_ceildivpow2(l_comp_y1, l_img_comp->factor)
7701                                 - opj_int_ceildivpow2(l_img_comp->y0, l_img_comp->factor);
7702                 if (l_h < 0){
7703                         opj_event_msg(p_manager, EVT_ERROR,
7704                                 "Size y of the decoded component image is incorrect (comp[%d].h=%d).\n",
7705                                 it_comp, l_h);
7706                         return OPJ_FALSE;
7707                 }
7708                 l_img_comp->h = l_h;
7709
7710                 l_img_comp++;
7711         }
7712
7713         opj_event_msg( p_manager, EVT_INFO,"Setting decoding area to %d,%d,%d,%d\n",
7714                         p_image->x0, p_image->y0, p_image->x1, p_image->y1);
7715
7716         return OPJ_TRUE;
7717 }
7718
7719 opj_j2k_t* opj_j2k_create_decompress(void)
7720 {
7721         opj_j2k_t *l_j2k = (opj_j2k_t*) opj_malloc(sizeof(opj_j2k_t));
7722         if (!l_j2k) {
7723                 return 00;
7724         }
7725         memset(l_j2k,0,sizeof(opj_j2k_t));
7726
7727         l_j2k->m_is_decoder = 1;
7728         l_j2k->m_cp.m_is_decoder = 1;
7729
7730         l_j2k->m_specific_param.m_decoder.m_default_tcp = (opj_tcp_t*) opj_malloc(sizeof(opj_tcp_t));
7731         if (!l_j2k->m_specific_param.m_decoder.m_default_tcp) {
7732                 opj_j2k_destroy(l_j2k);
7733                 return 00;
7734         }
7735         memset(l_j2k->m_specific_param.m_decoder.m_default_tcp,0,sizeof(opj_tcp_t));
7736
7737         l_j2k->m_specific_param.m_decoder.m_header_data = (OPJ_BYTE *) opj_malloc(OPJ_J2K_DEFAULT_HEADER_SIZE);
7738         if (! l_j2k->m_specific_param.m_decoder.m_header_data) {
7739                 opj_j2k_destroy(l_j2k);
7740                 return 00;
7741         }
7742
7743         l_j2k->m_specific_param.m_decoder.m_header_data_size = OPJ_J2K_DEFAULT_HEADER_SIZE;
7744
7745         l_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec = -1 ;
7746
7747         l_j2k->m_specific_param.m_decoder.m_last_sot_read_pos = 0 ;
7748
7749         /* codestream index creation */
7750         l_j2k->cstr_index = opj_j2k_create_cstr_index();
7751
7752                         /*(opj_codestream_index_t*) opj_malloc(sizeof(opj_codestream_index_t));
7753         if (!l_j2k->cstr_index){
7754                 opj_j2k_destroy(l_j2k);
7755                 return NULL;
7756         }
7757
7758         l_j2k->cstr_index->marker = (opj_marker_info_t*) opj_malloc(100 * sizeof(opj_marker_info_t));
7759 */
7760
7761         /* validation list creation */
7762         l_j2k->m_validation_list = opj_procedure_list_create();
7763         if (! l_j2k->m_validation_list) {
7764                 opj_j2k_destroy(l_j2k);
7765                 return 00;
7766         }
7767
7768         /* execution list creation */
7769         l_j2k->m_procedure_list = opj_procedure_list_create();
7770         if (! l_j2k->m_procedure_list) {
7771                 opj_j2k_destroy(l_j2k);
7772                 return 00;
7773         }
7774
7775         return l_j2k;
7776 }
7777
7778 opj_codestream_index_t* opj_j2k_create_cstr_index(void)
7779 {
7780         opj_codestream_index_t* cstr_index = (opj_codestream_index_t*)
7781                         opj_calloc(1,sizeof(opj_codestream_index_t));
7782         if (!cstr_index)
7783                 return NULL;
7784
7785         cstr_index->maxmarknum = 100;
7786         cstr_index->marknum = 0;
7787         cstr_index->marker = (opj_marker_info_t*)
7788                         opj_calloc(cstr_index->maxmarknum, sizeof(opj_marker_info_t));
7789         if (!cstr_index-> marker)
7790                 return NULL;
7791
7792         cstr_index->tile_index = NULL;
7793
7794         return cstr_index;
7795 }
7796
7797 OPJ_UINT32 opj_j2k_get_SPCod_SPCoc_size (       opj_j2k_t *p_j2k,
7798                                                                                 OPJ_UINT32 p_tile_no,
7799                                                                                 OPJ_UINT32 p_comp_no )
7800 {
7801         opj_cp_t *l_cp = 00;
7802         opj_tcp_t *l_tcp = 00;
7803         opj_tccp_t *l_tccp = 00;
7804
7805         /* preconditions */
7806         assert(p_j2k != 00);
7807
7808         l_cp = &(p_j2k->m_cp);
7809         l_tcp = &l_cp->tcps[p_tile_no];
7810         l_tccp = &l_tcp->tccps[p_comp_no];
7811
7812         /* preconditions again */
7813         assert(p_tile_no < (l_cp->tw * l_cp->th));
7814         assert(p_comp_no < p_j2k->m_private_image->numcomps);
7815
7816         if (l_tccp->csty & J2K_CCP_CSTY_PRT) {
7817                 return 5 + l_tccp->numresolutions;
7818         }
7819         else {
7820                 return 5;
7821         }
7822 }
7823
7824 OPJ_BOOL opj_j2k_write_SPCod_SPCoc(     opj_j2k_t *p_j2k,
7825                                                                     OPJ_UINT32 p_tile_no,
7826                                                                     OPJ_UINT32 p_comp_no,
7827                                                                     OPJ_BYTE * p_data,
7828                                                                     OPJ_UINT32 * p_header_size,
7829                                                                     struct opj_event_mgr * p_manager )
7830 {
7831         OPJ_UINT32 i;
7832         opj_cp_t *l_cp = 00;
7833         opj_tcp_t *l_tcp = 00;
7834         opj_tccp_t *l_tccp = 00;
7835
7836         /* preconditions */
7837         assert(p_j2k != 00);
7838         assert(p_header_size != 00);
7839         assert(p_manager != 00);
7840         assert(p_data != 00);
7841
7842         l_cp = &(p_j2k->m_cp);
7843         l_tcp = &l_cp->tcps[p_tile_no];
7844         l_tccp = &l_tcp->tccps[p_comp_no];
7845
7846         /* preconditions again */
7847         assert(p_tile_no < (l_cp->tw * l_cp->th));
7848         assert(p_comp_no <(p_j2k->m_private_image->numcomps));
7849
7850         if (*p_header_size < 5) {
7851                 opj_event_msg(p_manager, EVT_ERROR, "Error writing SPCod SPCoc element\n");
7852                 return OPJ_FALSE;
7853         }
7854
7855         opj_write_bytes(p_data,l_tccp->numresolutions - 1, 1);  /* SPcoc (D) */
7856         ++p_data;
7857
7858         opj_write_bytes(p_data,l_tccp->cblkw - 2, 1);                   /* SPcoc (E) */
7859         ++p_data;
7860
7861         opj_write_bytes(p_data,l_tccp->cblkh - 2, 1);                   /* SPcoc (F) */
7862         ++p_data;
7863
7864         opj_write_bytes(p_data,l_tccp->cblksty, 1);                             /* SPcoc (G) */
7865         ++p_data;
7866
7867         opj_write_bytes(p_data,l_tccp->qmfbid, 1);                              /* SPcoc (H) */
7868         ++p_data;
7869
7870         *p_header_size = *p_header_size - 5;
7871
7872         if (l_tccp->csty & J2K_CCP_CSTY_PRT) {
7873
7874                 if (*p_header_size < l_tccp->numresolutions) {
7875                         opj_event_msg(p_manager, EVT_ERROR, "Error writing SPCod SPCoc element\n");
7876                         return OPJ_FALSE;
7877                 }
7878
7879                 for (i = 0; i < l_tccp->numresolutions; ++i) {
7880                         opj_write_bytes(p_data,l_tccp->prcw[i] + (l_tccp->prch[i] << 4), 1);    /* SPcoc (I_i) */
7881                         ++p_data;
7882                 }
7883
7884                 *p_header_size = *p_header_size - l_tccp->numresolutions;
7885         }
7886
7887         return OPJ_TRUE;
7888 }
7889
7890 OPJ_BOOL opj_j2k_read_SPCod_SPCoc(  opj_j2k_t *p_j2k,
7891                                                                 OPJ_UINT32 compno,
7892                                                                 OPJ_BYTE * p_header_data,
7893                                                                 OPJ_UINT32 * p_header_size,
7894                                                                 opj_event_mgr_t * p_manager)
7895 {
7896         OPJ_UINT32 i, l_tmp;
7897         opj_cp_t *l_cp = NULL;
7898         opj_tcp_t *l_tcp = NULL;
7899         opj_tccp_t *l_tccp = NULL;
7900         OPJ_BYTE * l_current_ptr = NULL;
7901
7902         /* preconditions */
7903         assert(p_j2k != 00);
7904         assert(p_manager != 00);
7905         assert(p_header_data != 00);
7906
7907         l_cp = &(p_j2k->m_cp);
7908         l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH) ?
7909                                 &l_cp->tcps[p_j2k->m_current_tile_number] :
7910                                 p_j2k->m_specific_param.m_decoder.m_default_tcp;
7911
7912         /* precondition again */
7913         assert(compno < p_j2k->m_private_image->numcomps);
7914
7915         l_tccp = &l_tcp->tccps[compno];
7916         l_current_ptr = p_header_data;
7917
7918         /* make sure room is sufficient */
7919         if (*p_header_size < 5) {
7920                 opj_event_msg(p_manager, EVT_ERROR, "Error reading SPCod SPCoc element\n");
7921                 return OPJ_FALSE;
7922         }
7923
7924         opj_read_bytes(l_current_ptr, &l_tccp->numresolutions ,1);              /* SPcox (D) */
7925         ++l_tccp->numresolutions;                                                                               /* tccp->numresolutions = read() + 1 */
7926         if (l_tccp->numresolutions > OPJ_J2K_MAXRLVLS) {
7927                 opj_event_msg(p_manager, EVT_ERROR,
7928                               "Invalid value for numresolutions : %d, max value is set in openjpeg.h at %d\n",
7929                               l_tccp->numresolutions, OPJ_J2K_MAXRLVLS);
7930                 return OPJ_FALSE;
7931         }
7932         ++l_current_ptr;
7933
7934         /* If user wants to remove more resolutions than the codestream contains, return error */
7935         if (l_cp->m_specific_param.m_dec.m_reduce >= l_tccp->numresolutions) {
7936                 opj_event_msg(p_manager, EVT_ERROR, "Error decoding component %d.\nThe number of resolutions to remove is higher than the number "
7937                                         "of resolutions of this component\nModify the cp_reduce parameter.\n\n", compno);
7938                 p_j2k->m_specific_param.m_decoder.m_state |= 0x8000;/* FIXME J2K_DEC_STATE_ERR;*/
7939                 return OPJ_FALSE;
7940         }
7941
7942         opj_read_bytes(l_current_ptr,&l_tccp->cblkw ,1);                /* SPcoc (E) */
7943         ++l_current_ptr;
7944         l_tccp->cblkw += 2;
7945
7946         opj_read_bytes(l_current_ptr,&l_tccp->cblkh ,1);                /* SPcoc (F) */
7947         ++l_current_ptr;
7948         l_tccp->cblkh += 2;
7949
7950         opj_read_bytes(l_current_ptr,&l_tccp->cblksty ,1);              /* SPcoc (G) */
7951         ++l_current_ptr;
7952
7953         opj_read_bytes(l_current_ptr,&l_tccp->qmfbid ,1);               /* SPcoc (H) */
7954         ++l_current_ptr;
7955
7956         *p_header_size = *p_header_size - 5;
7957
7958         /* use custom precinct size ? */
7959         if (l_tccp->csty & J2K_CCP_CSTY_PRT) {
7960                 if (*p_header_size < l_tccp->numresolutions) {
7961                         opj_event_msg(p_manager, EVT_ERROR, "Error reading SPCod SPCoc element\n");
7962                         return OPJ_FALSE;
7963                 }
7964
7965                 for     (i = 0; i < l_tccp->numresolutions; ++i) {
7966                         opj_read_bytes(l_current_ptr,&l_tmp ,1);                /* SPcoc (I_i) */
7967                         ++l_current_ptr;
7968                         l_tccp->prcw[i] = l_tmp & 0xf;
7969                         l_tccp->prch[i] = l_tmp >> 4;
7970                 }
7971
7972                 *p_header_size = *p_header_size - l_tccp->numresolutions;
7973         }
7974         else {
7975                 /* set default size for the precinct width and height */
7976                 for     (i = 0; i < l_tccp->numresolutions; ++i) {
7977                         l_tccp->prcw[i] = 15;
7978                         l_tccp->prch[i] = 15;
7979                 }
7980         }
7981
7982 #ifdef WIP_REMOVE_MSD
7983         /* INDEX >> */
7984         if (p_j2k->cstr_info && compno == 0) {
7985                 OPJ_UINT32 l_data_size = l_tccp->numresolutions * sizeof(OPJ_UINT32);
7986
7987                 p_j2k->cstr_info->tile[p_j2k->m_current_tile_number].tccp_info[compno].cblkh = l_tccp->cblkh;
7988                 p_j2k->cstr_info->tile[p_j2k->m_current_tile_number].tccp_info[compno].cblkw = l_tccp->cblkw;
7989                 p_j2k->cstr_info->tile[p_j2k->m_current_tile_number].tccp_info[compno].numresolutions = l_tccp->numresolutions;
7990                 p_j2k->cstr_info->tile[p_j2k->m_current_tile_number].tccp_info[compno].cblksty = l_tccp->cblksty;
7991                 p_j2k->cstr_info->tile[p_j2k->m_current_tile_number].tccp_info[compno].qmfbid = l_tccp->qmfbid;
7992
7993                 memcpy(p_j2k->cstr_info->tile[p_j2k->m_current_tile_number].pdx,l_tccp->prcw, l_data_size);
7994                 memcpy(p_j2k->cstr_info->tile[p_j2k->m_current_tile_number].pdy,l_tccp->prch, l_data_size);
7995         }
7996         /* << INDEX */
7997 #endif
7998
7999         return OPJ_TRUE;
8000 }
8001
8002 void opj_j2k_copy_tile_component_parameters( opj_j2k_t *p_j2k )
8003 {
8004         /* loop */
8005         OPJ_UINT32 i;
8006         opj_cp_t *l_cp = NULL;
8007         opj_tcp_t *l_tcp = NULL;
8008         opj_tccp_t *l_ref_tccp = NULL, *l_copied_tccp = NULL;
8009         OPJ_UINT32 l_prc_size;
8010
8011         /* preconditions */
8012         assert(p_j2k != 00);
8013
8014         l_cp = &(p_j2k->m_cp);
8015         l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH) ? /* FIXME J2K_DEC_STATE_TPH*/
8016                                 &l_cp->tcps[p_j2k->m_current_tile_number] :
8017                                 p_j2k->m_specific_param.m_decoder.m_default_tcp;
8018
8019         l_ref_tccp = &l_tcp->tccps[0];
8020         l_copied_tccp = l_ref_tccp + 1;
8021         l_prc_size = l_ref_tccp->numresolutions * sizeof(OPJ_UINT32);
8022
8023         for     (i=1; i<p_j2k->m_private_image->numcomps; ++i) {
8024                 l_copied_tccp->numresolutions = l_ref_tccp->numresolutions;
8025                 l_copied_tccp->cblkw = l_ref_tccp->cblkw;
8026                 l_copied_tccp->cblkh = l_ref_tccp->cblkh;
8027                 l_copied_tccp->cblksty = l_ref_tccp->cblksty;
8028                 l_copied_tccp->qmfbid = l_ref_tccp->qmfbid;
8029                 memcpy(l_copied_tccp->prcw,l_ref_tccp->prcw,l_prc_size);
8030                 memcpy(l_copied_tccp->prch,l_ref_tccp->prch,l_prc_size);
8031                 ++l_copied_tccp;
8032         }
8033 }
8034
8035 OPJ_UINT32 opj_j2k_get_SQcd_SQcc_size ( opj_j2k_t *p_j2k,
8036                                                                         OPJ_UINT32 p_tile_no,
8037                                                                         OPJ_UINT32 p_comp_no )
8038 {
8039         OPJ_UINT32 l_num_bands;
8040
8041         opj_cp_t *l_cp = 00;
8042         opj_tcp_t *l_tcp = 00;
8043         opj_tccp_t *l_tccp = 00;
8044
8045         /* preconditions */
8046         assert(p_j2k != 00);
8047
8048         l_cp = &(p_j2k->m_cp);
8049         l_tcp = &l_cp->tcps[p_tile_no];
8050         l_tccp = &l_tcp->tccps[p_comp_no];
8051
8052         /* preconditions again */
8053         assert(p_tile_no < l_cp->tw * l_cp->th);
8054         assert(p_comp_no < p_j2k->m_private_image->numcomps);
8055
8056         l_num_bands = (l_tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) ? 1 : (l_tccp->numresolutions * 3 - 2);
8057
8058         if (l_tccp->qntsty == J2K_CCP_QNTSTY_NOQNT)  {
8059                 return 1 + l_num_bands;
8060         }
8061         else {
8062                 return 1 + 2*l_num_bands;
8063         }
8064 }
8065
8066 OPJ_BOOL opj_j2k_write_SQcd_SQcc(       opj_j2k_t *p_j2k,
8067                                                                 OPJ_UINT32 p_tile_no,
8068                                                                 OPJ_UINT32 p_comp_no,
8069                                                                 OPJ_BYTE * p_data,
8070                                                                 OPJ_UINT32 * p_header_size,
8071                                                                 struct opj_event_mgr * p_manager )
8072 {
8073         OPJ_UINT32 l_header_size;
8074         OPJ_UINT32 l_band_no, l_num_bands;
8075         OPJ_UINT32 l_expn,l_mant;
8076
8077         opj_cp_t *l_cp = 00;
8078         opj_tcp_t *l_tcp = 00;
8079         opj_tccp_t *l_tccp = 00;
8080
8081         /* preconditions */
8082         assert(p_j2k != 00);
8083         assert(p_header_size != 00);
8084         assert(p_manager != 00);
8085         assert(p_data != 00);
8086
8087         l_cp = &(p_j2k->m_cp);
8088         l_tcp = &l_cp->tcps[p_tile_no];
8089         l_tccp = &l_tcp->tccps[p_comp_no];
8090
8091         /* preconditions again */
8092         assert(p_tile_no < l_cp->tw * l_cp->th);
8093         assert(p_comp_no <p_j2k->m_private_image->numcomps);
8094
8095         l_num_bands = (l_tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) ? 1 : (l_tccp->numresolutions * 3 - 2);
8096
8097         if (l_tccp->qntsty == J2K_CCP_QNTSTY_NOQNT)  {
8098                 l_header_size = 1 + l_num_bands;
8099
8100                 if (*p_header_size < l_header_size) {
8101                         opj_event_msg(p_manager, EVT_ERROR, "Error writing SQcd SQcc element\n");
8102                         return OPJ_FALSE;
8103                 }
8104
8105                 opj_write_bytes(p_data,l_tccp->qntsty + (l_tccp->numgbits << 5), 1);    /* Sqcx */
8106                 ++p_data;
8107
8108                 for (l_band_no = 0; l_band_no < l_num_bands; ++l_band_no) {
8109                         l_expn = l_tccp->stepsizes[l_band_no].expn;
8110                         opj_write_bytes(p_data, l_expn << 3, 1);        /* SPqcx_i */
8111                         ++p_data;
8112                 }
8113         }
8114         else {
8115                 l_header_size = 1 + 2*l_num_bands;
8116
8117                 if (*p_header_size < l_header_size) {
8118                         opj_event_msg(p_manager, EVT_ERROR, "Error writing SQcd SQcc element\n");
8119                         return OPJ_FALSE;
8120                 }
8121
8122                 opj_write_bytes(p_data,l_tccp->qntsty + (l_tccp->numgbits << 5), 1);    /* Sqcx */
8123                 ++p_data;
8124
8125                 for (l_band_no = 0; l_band_no < l_num_bands; ++l_band_no) {
8126                         l_expn = l_tccp->stepsizes[l_band_no].expn;
8127                         l_mant = l_tccp->stepsizes[l_band_no].mant;
8128
8129                         opj_write_bytes(p_data, (l_expn << 11) + l_mant, 2);    /* SPqcx_i */
8130                         p_data += 2;
8131                 }
8132         }
8133
8134         *p_header_size = *p_header_size - l_header_size;
8135
8136         return OPJ_TRUE;
8137 }
8138
8139 OPJ_BOOL opj_j2k_read_SQcd_SQcc(opj_j2k_t *p_j2k,
8140                                                             OPJ_UINT32 p_comp_no,
8141                                                             OPJ_BYTE* p_header_data,
8142                                                             OPJ_UINT32 * p_header_size,
8143                                                             opj_event_mgr_t * p_manager
8144                                                             )
8145 {
8146         /* loop*/
8147         OPJ_UINT32 l_band_no;
8148         opj_cp_t *l_cp = 00;
8149         opj_tcp_t *l_tcp = 00;
8150         opj_tccp_t *l_tccp = 00;
8151         OPJ_BYTE * l_current_ptr = 00;
8152         OPJ_UINT32 l_tmp, l_num_band;
8153
8154         /* preconditions*/
8155         assert(p_j2k != 00);
8156         assert(p_manager != 00);
8157         assert(p_header_data != 00);
8158
8159         l_cp = &(p_j2k->m_cp);
8160         /* come from tile part header or main header ?*/
8161         l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH) ? /*FIXME J2K_DEC_STATE_TPH*/
8162                                 &l_cp->tcps[p_j2k->m_current_tile_number] :
8163                                 p_j2k->m_specific_param.m_decoder.m_default_tcp;
8164
8165         /* precondition again*/
8166         assert(p_comp_no <  p_j2k->m_private_image->numcomps);
8167
8168         l_tccp = &l_tcp->tccps[p_comp_no];
8169         l_current_ptr = p_header_data;
8170
8171         if (*p_header_size < 1) {
8172                 opj_event_msg(p_manager, EVT_ERROR, "Error reading SQcd or SQcc element\n");
8173                 return OPJ_FALSE;
8174         }
8175         *p_header_size -= 1;
8176
8177         opj_read_bytes(l_current_ptr, &l_tmp ,1);                       /* Sqcx */
8178         ++l_current_ptr;
8179
8180         l_tccp->qntsty = l_tmp & 0x1f;
8181         l_tccp->numgbits = l_tmp >> 5;
8182         if (l_tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) {
8183         l_num_band = 1;
8184         }
8185         else {
8186                 l_num_band = (l_tccp->qntsty == J2K_CCP_QNTSTY_NOQNT) ?
8187                         (*p_header_size) :
8188                         (*p_header_size) / 2;
8189
8190                 if( l_num_band > OPJ_J2K_MAXBANDS ) {
8191                         opj_event_msg(p_manager, EVT_WARNING, "While reading CCP_QNTSTY element inside QCD or QCC marker segment, "
8192                                 "number of subbands (%d) is greater to OPJ_J2K_MAXBANDS (%d). So we limit the number of elements stored to "
8193                                 "OPJ_J2K_MAXBANDS (%d) and skip the rest. \n", l_num_band, OPJ_J2K_MAXBANDS, OPJ_J2K_MAXBANDS);
8194                         /*return OPJ_FALSE;*/
8195                 }
8196         }
8197
8198 #ifdef USE_JPWL
8199         if (l_cp->correct) {
8200
8201                 /* if JPWL is on, we check whether there are too many subbands */
8202                 if (/*(l_num_band < 0) ||*/ (l_num_band >= OPJ_J2K_MAXBANDS)) {
8203                         opj_event_msg(p_manager, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
8204                                 "JPWL: bad number of subbands in Sqcx (%d)\n",
8205                                 l_num_band);
8206                         if (!JPWL_ASSUME) {
8207                                 opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n");
8208                                 return OPJ_FALSE;
8209                         }
8210                         /* we try to correct */
8211                         l_num_band = 1;
8212                         opj_event_msg(p_manager, EVT_WARNING, "- trying to adjust them\n"
8213                                 "- setting number of bands to %d => HYPOTHESIS!!!\n",
8214                                 l_num_band);
8215                 };
8216
8217         };
8218 #endif /* USE_JPWL */
8219
8220         if (l_tccp->qntsty == J2K_CCP_QNTSTY_NOQNT) {
8221                 for     (l_band_no = 0; l_band_no < l_num_band; l_band_no++) {
8222                         opj_read_bytes(l_current_ptr, &l_tmp ,1);                       /* SPqcx_i */
8223                         ++l_current_ptr;
8224                         if (l_band_no < OPJ_J2K_MAXBANDS){
8225                                 l_tccp->stepsizes[l_band_no].expn = l_tmp>>3;
8226                                 l_tccp->stepsizes[l_band_no].mant = 0;
8227                         }
8228                 }
8229                 *p_header_size = *p_header_size - l_num_band;
8230         }
8231         else {
8232                 for     (l_band_no = 0; l_band_no < l_num_band; l_band_no++) {
8233                         opj_read_bytes(l_current_ptr, &l_tmp ,2);                       /* SPqcx_i */
8234                         l_current_ptr+=2;
8235                         if (l_band_no < OPJ_J2K_MAXBANDS){
8236                                 l_tccp->stepsizes[l_band_no].expn = l_tmp >> 11;
8237                                 l_tccp->stepsizes[l_band_no].mant = l_tmp & 0x7ff;
8238                         }
8239                 }
8240                 *p_header_size = *p_header_size - 2*l_num_band;
8241         }
8242
8243         /* Add Antonin : if scalar_derived -> compute other stepsizes */
8244         if (l_tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) {
8245                 for (l_band_no = 1; l_band_no < OPJ_J2K_MAXBANDS; l_band_no++) {
8246                         l_tccp->stepsizes[l_band_no].expn =
8247                                 ((l_tccp->stepsizes[0].expn) - ((l_band_no - 1) / 3) > 0) ?
8248                                         (l_tccp->stepsizes[0].expn) - ((l_band_no - 1) / 3) : 0;
8249                         l_tccp->stepsizes[l_band_no].mant = l_tccp->stepsizes[0].mant;
8250                 }
8251         }
8252
8253         return OPJ_TRUE;
8254 }
8255
8256 void opj_j2k_copy_tile_quantization_parameters( opj_j2k_t *p_j2k )
8257 {
8258         OPJ_UINT32 i;
8259         opj_cp_t *l_cp = NULL;
8260         opj_tcp_t *l_tcp = NULL;
8261         opj_tccp_t *l_ref_tccp = NULL;
8262         opj_tccp_t *l_copied_tccp = NULL;
8263         OPJ_UINT32 l_size;
8264
8265         /* preconditions */
8266         assert(p_j2k != 00);
8267
8268         l_cp = &(p_j2k->m_cp);
8269         l_tcp = p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH ?
8270                         &l_cp->tcps[p_j2k->m_current_tile_number] :
8271                         p_j2k->m_specific_param.m_decoder.m_default_tcp;
8272
8273         l_ref_tccp = &l_tcp->tccps[0];
8274         l_copied_tccp = l_ref_tccp + 1;
8275         l_size = OPJ_J2K_MAXBANDS * sizeof(opj_stepsize_t);
8276
8277         for     (i=1;i<p_j2k->m_private_image->numcomps;++i) {
8278                 l_copied_tccp->qntsty = l_ref_tccp->qntsty;
8279                 l_copied_tccp->numgbits = l_ref_tccp->numgbits;
8280                 memcpy(l_copied_tccp->stepsizes,l_ref_tccp->stepsizes,l_size);
8281                 ++l_copied_tccp;
8282         }
8283 }
8284
8285 void j2k_dump (opj_j2k_t* p_j2k, OPJ_INT32 flag, FILE* out_stream)
8286 {
8287         /* Check if the flag is compatible with j2k file*/
8288         if ( (flag & OPJ_JP2_INFO) || (flag & OPJ_JP2_IND)){
8289                 fprintf(out_stream, "Wrong flag\n");
8290                 return;
8291         }
8292
8293         /* Dump the image_header */
8294         if (flag & OPJ_IMG_INFO){
8295                 if (p_j2k->m_private_image)
8296                         j2k_dump_image_header(p_j2k->m_private_image, 0, out_stream);
8297         }
8298
8299         /* Dump the codestream info from main header */
8300         if (flag & OPJ_J2K_MH_INFO){
8301                 opj_j2k_dump_MH_info(p_j2k, out_stream);
8302         }
8303
8304         /* Dump the codestream info of the current tile */
8305         if (flag & OPJ_J2K_TH_INFO){
8306
8307         }
8308
8309         /* Dump the codestream index from main header */
8310         if (flag & OPJ_J2K_MH_IND){
8311                 opj_j2k_dump_MH_index(p_j2k, out_stream);
8312         }
8313
8314         /* Dump the codestream index of the current tile */
8315         if (flag & OPJ_J2K_TH_IND){
8316
8317         }
8318
8319 }
8320
8321 void opj_j2k_dump_MH_index(opj_j2k_t* p_j2k, FILE* out_stream)
8322 {
8323         opj_codestream_index_t* cstr_index = p_j2k->cstr_index;
8324         OPJ_UINT32 it_marker, it_tile, it_tile_part;
8325
8326         fprintf(out_stream, "Codestream index from main header: {\n");
8327
8328         fprintf(out_stream, "\t Main header start position=%" PRIi64 "\n"
8329                                     "\t Main header end position=%" PRIi64 "\n",
8330                         cstr_index->main_head_start, cstr_index->main_head_end);
8331
8332         fprintf(out_stream, "\t Marker list: {\n");
8333
8334         if (cstr_index->marker){
8335                 for (it_marker=0; it_marker < cstr_index->marknum ; it_marker++){
8336                         fprintf(out_stream, "\t\t type=%#x, pos=%" PRIi64 ", len=%d\n",
8337                                         cstr_index->marker[it_marker].type,
8338                                         cstr_index->marker[it_marker].pos,
8339                                         cstr_index->marker[it_marker].len );
8340                 }
8341         }
8342
8343         fprintf(out_stream, "\t }\n");
8344
8345         if (cstr_index->tile_index){
8346
8347         /* Simple test to avoid to write empty information*/
8348         OPJ_UINT32 l_acc_nb_of_tile_part = 0;
8349         for (it_tile=0; it_tile < cstr_index->nb_of_tiles ; it_tile++){
8350                         l_acc_nb_of_tile_part += cstr_index->tile_index[it_tile].nb_tps;
8351         }
8352
8353         if (l_acc_nb_of_tile_part)
8354         {
8355             fprintf(out_stream, "\t Tile index: {\n");
8356
8357                     for (it_tile=0; it_tile < cstr_index->nb_of_tiles ; it_tile++){
8358                             OPJ_UINT32 nb_of_tile_part = cstr_index->tile_index[it_tile].nb_tps;
8359
8360                             fprintf(out_stream, "\t\t nb of tile-part in tile [%d]=%d\n", it_tile, nb_of_tile_part);
8361
8362                             if (cstr_index->tile_index[it_tile].tp_index){
8363                                     for (it_tile_part =0; it_tile_part < nb_of_tile_part; it_tile_part++){
8364                                             fprintf(out_stream, "\t\t\t tile-part[%d]: star_pos=%" PRIi64 ", end_header=%" PRIi64 ", end_pos=%" PRIi64 ".\n",
8365                                                             it_tile_part,
8366                                                             cstr_index->tile_index[it_tile].tp_index[it_tile_part].start_pos,
8367                                                             cstr_index->tile_index[it_tile].tp_index[it_tile_part].end_header,
8368                                                             cstr_index->tile_index[it_tile].tp_index[it_tile_part].end_pos);
8369                                     }
8370                             }
8371
8372                             if (cstr_index->tile_index[it_tile].marker){
8373                                     for (it_marker=0; it_marker < cstr_index->tile_index[it_tile].marknum ; it_marker++){
8374                                             fprintf(out_stream, "\t\t type=%#x, pos=%" PRIi64 ", len=%d\n",
8375                                                             cstr_index->tile_index[it_tile].marker[it_marker].type,
8376                                                             cstr_index->tile_index[it_tile].marker[it_marker].pos,
8377                                                             cstr_index->tile_index[it_tile].marker[it_marker].len );
8378                                     }
8379                             }
8380                     }
8381                     fprintf(out_stream,"\t }\n");
8382         }
8383         }
8384
8385         fprintf(out_stream,"}\n");
8386
8387 }
8388
8389 void opj_j2k_dump_MH_info(opj_j2k_t* p_j2k, FILE* out_stream)
8390 {
8391         opj_tcp_t * l_default_tile=NULL;
8392
8393         fprintf(out_stream, "Codestream info from main header: {\n");
8394
8395         fprintf(out_stream, "\t tx0=%d, ty0=%d\n", p_j2k->m_cp.tx0, p_j2k->m_cp.ty0);
8396         fprintf(out_stream, "\t tdx=%d, tdy=%d\n", p_j2k->m_cp.tdx, p_j2k->m_cp.tdy);
8397         fprintf(out_stream, "\t tw=%d, th=%d\n", p_j2k->m_cp.tw, p_j2k->m_cp.th);
8398
8399         l_default_tile = p_j2k->m_specific_param.m_decoder.m_default_tcp;
8400         if (l_default_tile)
8401         {
8402                 OPJ_INT32 compno;
8403                 OPJ_INT32 numcomps = p_j2k->m_private_image->numcomps;
8404
8405                 fprintf(out_stream, "\t default tile {\n");
8406                 fprintf(out_stream, "\t\t csty=%#x\n", l_default_tile->csty);
8407                 fprintf(out_stream, "\t\t prg=%#x\n", l_default_tile->prg);
8408                 fprintf(out_stream, "\t\t numlayers=%d\n", l_default_tile->numlayers);
8409                 fprintf(out_stream, "\t\t mct=%x\n", l_default_tile->mct);
8410
8411                 for (compno = 0; compno < numcomps; compno++) {
8412                         opj_tccp_t *l_tccp = &(l_default_tile->tccps[compno]);
8413                         OPJ_UINT32 resno;
8414       OPJ_INT32 bandno, numbands;
8415
8416                         /* coding style*/
8417                         fprintf(out_stream, "\t\t comp %d {\n", compno);
8418                         fprintf(out_stream, "\t\t\t csty=%#x\n", l_tccp->csty);
8419                         fprintf(out_stream, "\t\t\t numresolutions=%d\n", l_tccp->numresolutions);
8420                         fprintf(out_stream, "\t\t\t cblkw=2^%d\n", l_tccp->cblkw);
8421                         fprintf(out_stream, "\t\t\t cblkh=2^%d\n", l_tccp->cblkh);
8422                         fprintf(out_stream, "\t\t\t cblksty=%#x\n", l_tccp->cblksty);
8423                         fprintf(out_stream, "\t\t\t qmfbid=%d\n", l_tccp->qmfbid);
8424
8425                         fprintf(out_stream, "\t\t\t preccintsize (w,h)=");
8426                         for (resno = 0; resno < l_tccp->numresolutions; resno++) {
8427                                 fprintf(out_stream, "(%d,%d) ", l_tccp->prcw[resno], l_tccp->prch[resno]);
8428                         }
8429                         fprintf(out_stream, "\n");
8430
8431                         /* quantization style*/
8432                         fprintf(out_stream, "\t\t\t qntsty=%d\n", l_tccp->qntsty);
8433                         fprintf(out_stream, "\t\t\t numgbits=%d\n", l_tccp->numgbits);
8434                         fprintf(out_stream, "\t\t\t stepsizes (m,e)=");
8435                         numbands = (l_tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) ? 1 : l_tccp->numresolutions * 3 - 2;
8436                         for (bandno = 0; bandno < numbands; bandno++) {
8437                                 fprintf(out_stream, "(%d,%d) ", l_tccp->stepsizes[bandno].mant,
8438                                         l_tccp->stepsizes[bandno].expn);
8439                         }
8440                         fprintf(out_stream, "\n");
8441
8442                         /* RGN value*/
8443                         fprintf(out_stream, "\t\t\t roishift=%d\n", l_tccp->roishift);
8444
8445                         fprintf(out_stream, "\t\t }\n");
8446                 } /*end of component of default tile*/
8447                 fprintf(out_stream, "\t }\n"); /*end of default tile*/
8448
8449         }
8450
8451         fprintf(out_stream, "}\n");
8452
8453 }
8454
8455 void j2k_dump_image_header(opj_image_t* img_header, OPJ_BOOL dev_dump_flag, FILE* out_stream)
8456 {
8457         char tab[2];
8458
8459         if (dev_dump_flag){
8460                 fprintf(stdout, "[DEV] Dump an image_header struct {\n");
8461                 tab[0] = '\0';
8462         }
8463         else {
8464                 fprintf(out_stream, "Image info {\n");
8465                 tab[0] = '\t';tab[1] = '\0';
8466         }
8467
8468         fprintf(out_stream, "%s x0=%d, y0=%d\n", tab, img_header->x0, img_header->y0);
8469         fprintf(out_stream,     "%s x1=%d, y1=%d\n", tab, img_header->x1, img_header->y1);
8470         fprintf(out_stream, "%s numcomps=%d\n", tab, img_header->numcomps);
8471
8472         if (img_header->comps){
8473                 OPJ_UINT32 compno;
8474                 for (compno = 0; compno < img_header->numcomps; compno++) {
8475                         fprintf(out_stream, "%s\t component %d {\n", tab, compno);
8476                         j2k_dump_image_comp_header(&(img_header->comps[compno]), dev_dump_flag, out_stream);
8477                         fprintf(out_stream,"%s}\n",tab);
8478                 }
8479         }
8480
8481         fprintf(out_stream, "}\n");
8482 }
8483
8484 void j2k_dump_image_comp_header(opj_image_comp_t* comp_header, OPJ_BOOL dev_dump_flag, FILE* out_stream)
8485 {
8486         char tab[3];
8487
8488         if (dev_dump_flag){
8489                 fprintf(stdout, "[DEV] Dump an image_comp_header struct {\n");
8490                 tab[0] = '\0';
8491         }       else {
8492                 tab[0] = '\t';tab[1] = '\t';tab[2] = '\0';
8493         }
8494
8495         fprintf(out_stream, "%s dx=%d, dy=%d\n", tab, comp_header->dx, comp_header->dy);
8496         fprintf(out_stream, "%s prec=%d\n", tab, comp_header->prec);
8497         fprintf(out_stream, "%s sgnd=%d\n", tab, comp_header->sgnd);
8498
8499         if (dev_dump_flag)
8500                 fprintf(out_stream, "}\n");
8501 }
8502
8503 opj_codestream_info_v2_t* j2k_get_cstr_info(opj_j2k_t* p_j2k)
8504 {
8505         OPJ_UINT32 compno;
8506         OPJ_UINT32 numcomps = p_j2k->m_private_image->numcomps;
8507         opj_tcp_t *l_default_tile;
8508         opj_codestream_info_v2_t* cstr_info = (opj_codestream_info_v2_t*) opj_calloc(1,sizeof(opj_codestream_info_v2_t));
8509                 if (!cstr_info)
8510                         return NULL;
8511
8512         cstr_info->nbcomps = p_j2k->m_private_image->numcomps;
8513
8514         cstr_info->tx0 = p_j2k->m_cp.tx0;
8515         cstr_info->ty0 = p_j2k->m_cp.ty0;
8516         cstr_info->tdx = p_j2k->m_cp.tdx;
8517         cstr_info->tdy = p_j2k->m_cp.tdy;
8518         cstr_info->tw = p_j2k->m_cp.tw;
8519         cstr_info->th = p_j2k->m_cp.th;
8520
8521         cstr_info->tile_info = NULL; /* Not fill from the main header*/
8522
8523         l_default_tile = p_j2k->m_specific_param.m_decoder.m_default_tcp;
8524
8525         cstr_info->m_default_tile_info.csty = l_default_tile->csty;
8526         cstr_info->m_default_tile_info.prg = l_default_tile->prg;
8527         cstr_info->m_default_tile_info.numlayers = l_default_tile->numlayers;
8528         cstr_info->m_default_tile_info.mct = l_default_tile->mct;
8529
8530         cstr_info->m_default_tile_info.tccp_info = (opj_tccp_info_t*) opj_calloc(cstr_info->nbcomps, sizeof(opj_tccp_info_t));
8531                 if (!cstr_info->m_default_tile_info.tccp_info)
8532                 {
8533                         opj_destroy_cstr_info(&cstr_info);
8534                         return NULL;
8535                 }
8536
8537         for (compno = 0; compno < numcomps; compno++) {
8538                 opj_tccp_t *l_tccp = &(l_default_tile->tccps[compno]);
8539                 opj_tccp_info_t *l_tccp_info = &(cstr_info->m_default_tile_info.tccp_info[compno]);
8540                 OPJ_INT32 bandno, numbands;
8541
8542                 /* coding style*/
8543                 l_tccp_info->csty = l_tccp->csty;
8544                 l_tccp_info->numresolutions = l_tccp->numresolutions;
8545                 l_tccp_info->cblkw = l_tccp->cblkw;
8546                 l_tccp_info->cblkh = l_tccp->cblkh;
8547                 l_tccp_info->cblksty = l_tccp->cblksty;
8548                 l_tccp_info->qmfbid = l_tccp->qmfbid;
8549                 if (l_tccp->numresolutions < OPJ_J2K_MAXRLVLS)
8550                 {
8551                         memcpy(l_tccp_info->prch, l_tccp->prch, l_tccp->numresolutions);
8552                         memcpy(l_tccp_info->prcw, l_tccp->prcw, l_tccp->numresolutions);
8553                 }
8554
8555                 /* quantization style*/
8556                 l_tccp_info->qntsty = l_tccp->qntsty;
8557                 l_tccp_info->numgbits = l_tccp->numgbits;
8558
8559                 numbands = (l_tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) ? 1 : l_tccp->numresolutions * 3 - 2;
8560                 if (numbands < OPJ_J2K_MAXBANDS) {
8561                         for (bandno = 0; bandno < numbands; bandno++) {
8562                                 l_tccp_info->stepsizes_mant[bandno] = l_tccp->stepsizes[bandno].mant;
8563                                 l_tccp_info->stepsizes_expn[bandno] = l_tccp->stepsizes[bandno].expn;
8564                         }
8565                 }
8566
8567                 /* RGN value*/
8568                 l_tccp_info->roishift = l_tccp->roishift;
8569         }
8570
8571         return cstr_info;
8572 }
8573
8574 opj_codestream_index_t* j2k_get_cstr_index(opj_j2k_t* p_j2k)
8575 {
8576         opj_codestream_index_t* l_cstr_index = (opj_codestream_index_t*)
8577                         opj_calloc(1,sizeof(opj_codestream_index_t));
8578         if (!l_cstr_index)
8579                 return NULL;
8580
8581         l_cstr_index->main_head_start = p_j2k->cstr_index->main_head_start;
8582         l_cstr_index->main_head_end = p_j2k->cstr_index->main_head_end;
8583         l_cstr_index->codestream_size = p_j2k->cstr_index->codestream_size;
8584
8585         l_cstr_index->marknum = p_j2k->cstr_index->marknum;
8586         l_cstr_index->marker = (opj_marker_info_t*)opj_malloc(l_cstr_index->marknum*sizeof(opj_marker_info_t));
8587         if (!l_cstr_index->marker){
8588                 opj_free( l_cstr_index);
8589                 return NULL;
8590         }
8591
8592         if (p_j2k->cstr_index->marker)
8593                 memcpy(l_cstr_index->marker, p_j2k->cstr_index->marker, l_cstr_index->marknum * sizeof(opj_marker_info_t) );
8594         else{
8595                 opj_free(l_cstr_index->marker);
8596                 l_cstr_index->marker = NULL;
8597         }
8598
8599         l_cstr_index->nb_of_tiles = p_j2k->cstr_index->nb_of_tiles;
8600         l_cstr_index->tile_index = (opj_tile_index_t*)opj_calloc(l_cstr_index->nb_of_tiles, sizeof(opj_tile_index_t) );
8601         if (!l_cstr_index->tile_index){
8602                 opj_free( l_cstr_index->marker);
8603                 opj_free( l_cstr_index);
8604                 return NULL;
8605         }
8606
8607         if (!p_j2k->cstr_index->tile_index){
8608                 opj_free(l_cstr_index->tile_index);
8609                 l_cstr_index->tile_index = NULL;
8610         }
8611         else {
8612                 OPJ_UINT32 it_tile = 0;
8613                 for (it_tile = 0; it_tile < l_cstr_index->nb_of_tiles; it_tile++ ){
8614
8615                         /* Tile Marker*/
8616                         l_cstr_index->tile_index[it_tile].marknum = p_j2k->cstr_index->tile_index[it_tile].marknum;
8617
8618                         l_cstr_index->tile_index[it_tile].marker =
8619                                 (opj_marker_info_t*)opj_malloc(l_cstr_index->tile_index[it_tile].marknum*sizeof(opj_marker_info_t));
8620
8621                         if (!l_cstr_index->tile_index[it_tile].marker) {
8622                                 OPJ_UINT32 it_tile_free;
8623
8624                                 for (it_tile_free=0; it_tile_free < it_tile; it_tile_free++){
8625                                         opj_free(l_cstr_index->tile_index[it_tile_free].marker);
8626                                 }
8627
8628                                 opj_free( l_cstr_index->tile_index);
8629                                 opj_free( l_cstr_index->marker);
8630                                 opj_free( l_cstr_index);
8631                                 return NULL;
8632                         }
8633
8634                         if (p_j2k->cstr_index->tile_index[it_tile].marker)
8635                                 memcpy( l_cstr_index->tile_index[it_tile].marker,
8636                                                 p_j2k->cstr_index->tile_index[it_tile].marker,
8637                                                 l_cstr_index->tile_index[it_tile].marknum * sizeof(opj_marker_info_t) );
8638                         else{
8639                                 opj_free(l_cstr_index->tile_index[it_tile].marker);
8640                                 l_cstr_index->tile_index[it_tile].marker = NULL;
8641                         }
8642
8643                         /* Tile part index*/
8644                         l_cstr_index->tile_index[it_tile].nb_tps = p_j2k->cstr_index->tile_index[it_tile].nb_tps;
8645
8646                         l_cstr_index->tile_index[it_tile].tp_index =
8647                                 (opj_tp_index_t*)opj_malloc(l_cstr_index->tile_index[it_tile].nb_tps*sizeof(opj_tp_index_t));
8648
8649                         if(!l_cstr_index->tile_index[it_tile].tp_index){
8650                                 OPJ_UINT32 it_tile_free;
8651
8652                                 for (it_tile_free=0; it_tile_free < it_tile; it_tile_free++){
8653                                         opj_free(l_cstr_index->tile_index[it_tile_free].marker);
8654                                         opj_free(l_cstr_index->tile_index[it_tile_free].tp_index);
8655                                 }
8656
8657                                 opj_free( l_cstr_index->tile_index);
8658                                 opj_free( l_cstr_index->marker);
8659                                 opj_free( l_cstr_index);
8660                                 return NULL;
8661                         }
8662
8663                         if (p_j2k->cstr_index->tile_index[it_tile].tp_index){
8664                                 memcpy( l_cstr_index->tile_index[it_tile].tp_index,
8665                                                 p_j2k->cstr_index->tile_index[it_tile].tp_index,
8666                                                 l_cstr_index->tile_index[it_tile].nb_tps * sizeof(opj_tp_index_t) );
8667                         }
8668                         else{
8669                                 opj_free(l_cstr_index->tile_index[it_tile].tp_index);
8670                                 l_cstr_index->tile_index[it_tile].tp_index = NULL;
8671                         }
8672
8673                         /* Packet index (NOT USED)*/
8674                         l_cstr_index->tile_index[it_tile].nb_packet = 0;
8675                         l_cstr_index->tile_index[it_tile].packet_index = NULL;
8676
8677                 }
8678         }
8679
8680         return l_cstr_index;
8681 }
8682
8683 OPJ_BOOL opj_j2k_allocate_tile_element_cstr_index(opj_j2k_t *p_j2k)
8684 {
8685         OPJ_UINT32 it_tile=0;
8686
8687         p_j2k->cstr_index->nb_of_tiles = p_j2k->m_cp.tw * p_j2k->m_cp.th;
8688         p_j2k->cstr_index->tile_index = (opj_tile_index_t*)opj_calloc(p_j2k->cstr_index->nb_of_tiles, sizeof(opj_tile_index_t));
8689         if (!p_j2k->cstr_index->tile_index)
8690                 return OPJ_FALSE;
8691
8692         for (it_tile=0; it_tile < p_j2k->cstr_index->nb_of_tiles; it_tile++){
8693                 p_j2k->cstr_index->tile_index[it_tile].maxmarknum = 100;
8694                 p_j2k->cstr_index->tile_index[it_tile].marknum = 0;
8695                 p_j2k->cstr_index->tile_index[it_tile].marker = (opj_marker_info_t*)
8696                                 opj_calloc(p_j2k->cstr_index->tile_index[it_tile].maxmarknum, sizeof(opj_marker_info_t));
8697                 if (!p_j2k->cstr_index->tile_index[it_tile].marker)
8698                         return OPJ_FALSE;
8699         }
8700
8701         return OPJ_TRUE;
8702 }
8703
8704 OPJ_BOOL opj_j2k_decode_tiles ( opj_j2k_t *p_j2k,
8705                                                             opj_stream_private_t *p_stream,
8706                                                             opj_event_mgr_t * p_manager)
8707 {
8708         OPJ_BOOL l_go_on = OPJ_TRUE;
8709         OPJ_UINT32 l_current_tile_no;
8710         OPJ_UINT32 l_data_size,l_max_data_size;
8711         OPJ_INT32 l_tile_x0,l_tile_y0,l_tile_x1,l_tile_y1;
8712         OPJ_UINT32 l_nb_comps;
8713         OPJ_BYTE * l_current_data;
8714         OPJ_UINT32 nr_tiles = 0;
8715
8716         l_current_data = (OPJ_BYTE*)opj_malloc(1000);
8717         if (! l_current_data) {
8718                 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to decode tiles\n");
8719                 return OPJ_FALSE;
8720         }
8721         l_max_data_size = 1000;
8722
8723         while (OPJ_TRUE) {
8724                 if (! opj_j2k_read_tile_header( p_j2k,
8725                                         &l_current_tile_no,
8726                                         &l_data_size,
8727                                         &l_tile_x0, &l_tile_y0,
8728                                         &l_tile_x1, &l_tile_y1,
8729                                         &l_nb_comps,
8730                                         &l_go_on,
8731                                         p_stream,
8732                                         p_manager)) {
8733                         opj_free(l_current_data);
8734                         return OPJ_FALSE;
8735                 }
8736
8737                 if (! l_go_on) {
8738                         break;
8739                 }
8740
8741                 if (l_data_size > l_max_data_size) {
8742                         OPJ_BYTE *l_new_current_data = (OPJ_BYTE *) opj_realloc(l_current_data, l_data_size);
8743                         if (! l_new_current_data) {
8744                                 opj_free(l_current_data);
8745                                 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to decode tile %d/%d\n", l_current_tile_no +1, p_j2k->m_cp.th * p_j2k->m_cp.tw);
8746                                 return OPJ_FALSE;
8747                         }
8748                         l_current_data = l_new_current_data;
8749                         l_max_data_size = l_data_size;
8750                 }
8751
8752                 if (! opj_j2k_decode_tile(p_j2k,l_current_tile_no,l_current_data,l_data_size,p_stream,p_manager)) {
8753                         opj_free(l_current_data);
8754                         return OPJ_FALSE;
8755                 }
8756                 opj_event_msg(p_manager, EVT_INFO, "Tile %d/%d has been decoded.\n", l_current_tile_no +1, p_j2k->m_cp.th * p_j2k->m_cp.tw);
8757
8758                 if (! opj_j2k_update_image_data(p_j2k->m_tcd,l_current_data, p_j2k->m_output_image)) {
8759                         opj_free(l_current_data);
8760                         return OPJ_FALSE;
8761                 }
8762                 opj_event_msg(p_manager, EVT_INFO, "Image data has been updated with tile %d.\n\n", l_current_tile_no + 1);
8763
8764                 if(opj_stream_get_number_byte_left(p_stream) == 0
8765                     && p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_NEOC)
8766                     break;
8767                 if(++nr_tiles ==  p_j2k->m_cp.th * p_j2k->m_cp.tw)
8768                     break;
8769         }
8770
8771         opj_free(l_current_data);
8772
8773         return OPJ_TRUE;
8774 }
8775
8776 /**
8777  * Sets up the procedures to do on decoding data. Developpers wanting to extend the library can add their own reading procedures.
8778  */
8779 static void opj_j2k_setup_decoding (opj_j2k_t *p_j2k)
8780 {
8781         /* preconditions*/
8782         assert(p_j2k != 00);
8783
8784         opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_decode_tiles);
8785         /* DEVELOPER CORNER, add your custom procedures */
8786
8787 }
8788
8789 /*
8790  * Read and decode one tile.
8791  */
8792 static OPJ_BOOL opj_j2k_decode_one_tile (       opj_j2k_t *p_j2k,
8793                                                                             opj_stream_private_t *p_stream,
8794                                                                             opj_event_mgr_t * p_manager)
8795 {
8796         OPJ_BOOL l_go_on = OPJ_TRUE;
8797         OPJ_UINT32 l_current_tile_no;
8798         OPJ_UINT32 l_tile_no_to_dec;
8799         OPJ_UINT32 l_data_size,l_max_data_size;
8800         OPJ_INT32 l_tile_x0,l_tile_y0,l_tile_x1,l_tile_y1;
8801         OPJ_UINT32 l_nb_comps;
8802         OPJ_BYTE * l_current_data;
8803
8804         l_current_data = (OPJ_BYTE*)opj_malloc(1000);
8805         if (! l_current_data) {
8806                 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to decode one tile\n");
8807                 return OPJ_FALSE;
8808         }
8809         l_max_data_size = 1000;
8810
8811         /*Allocate and initialize some elements of codestrem index if not already done*/
8812         if( !p_j2k->cstr_index->tile_index)
8813         {
8814                 if (!opj_j2k_allocate_tile_element_cstr_index(p_j2k)){
8815                         opj_free(l_current_data);
8816                         return OPJ_FALSE;
8817                 }
8818         }
8819         /* Move into the codestream to the first SOT used to decode the desired tile */
8820         l_tile_no_to_dec = p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec;
8821         if (p_j2k->cstr_index->tile_index)
8822                 if(p_j2k->cstr_index->tile_index->tp_index)
8823                 {
8824                         if ( ! p_j2k->cstr_index->tile_index[l_tile_no_to_dec].nb_tps) {
8825                                 /* the index for this tile has not been built,
8826                                  *  so move to the last SOT read */
8827                                 if ( !(opj_stream_read_seek(p_stream, p_j2k->m_specific_param.m_decoder.m_last_sot_read_pos+2, p_manager)) ){
8828                                         opj_event_msg(p_manager, EVT_ERROR, "Problem with seek function\n");
8829                                         return OPJ_FALSE;
8830                                 }
8831                         }
8832                         else{
8833                                 if ( !(opj_stream_read_seek(p_stream, p_j2k->cstr_index->tile_index[l_tile_no_to_dec].tp_index[0].start_pos+2, p_manager)) ) {
8834                                         opj_event_msg(p_manager, EVT_ERROR, "Problem with seek function\n");
8835                                         return OPJ_FALSE;
8836                                 }
8837                         }
8838                         /* Special case if we have previously read the EOC marker (if the previous tile getted is the last ) */
8839                         if(p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_EOC)
8840                                 p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_TPHSOT;
8841                 }
8842
8843         while (OPJ_TRUE) {
8844                 if (! opj_j2k_read_tile_header( p_j2k,
8845                                         &l_current_tile_no,
8846                                         &l_data_size,
8847                                         &l_tile_x0, &l_tile_y0,
8848                                         &l_tile_x1, &l_tile_y1,
8849                                         &l_nb_comps,
8850                                         &l_go_on,
8851                                         p_stream,
8852                                         p_manager)) {
8853                         opj_free(l_current_data);
8854                         return OPJ_FALSE;
8855                 }
8856
8857                 if (! l_go_on) {
8858                         break;
8859                 }
8860
8861                 if (l_data_size > l_max_data_size) {
8862                         OPJ_BYTE *l_new_current_data = (OPJ_BYTE *) opj_realloc(l_current_data, l_data_size);
8863                         if (! l_new_current_data) {
8864                                 opj_free(l_current_data);
8865                                 l_current_data = NULL;
8866                                 /* TODO: LH: why tile numbering policy used in messages differs from
8867                                    the one used in opj_j2k_decode_tiles() ? */
8868                                 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to decode tile %d/%d\n", l_current_tile_no, (p_j2k->m_cp.th * p_j2k->m_cp.tw) - 1);
8869                                 return OPJ_FALSE;
8870                         }
8871                         l_current_data = l_new_current_data;
8872                         l_max_data_size = l_data_size;
8873                 }
8874
8875                 if (! opj_j2k_decode_tile(p_j2k,l_current_tile_no,l_current_data,l_data_size,p_stream,p_manager)) {
8876                         opj_free(l_current_data);
8877                         return OPJ_FALSE;
8878                 }
8879                 opj_event_msg(p_manager, EVT_INFO, "Tile %d/%d has been decoded.\n", l_current_tile_no, (p_j2k->m_cp.th * p_j2k->m_cp.tw) - 1);
8880
8881                 if (! opj_j2k_update_image_data(p_j2k->m_tcd,l_current_data, p_j2k->m_output_image)) {
8882                         opj_free(l_current_data);
8883                         return OPJ_FALSE;
8884                 }
8885                 opj_event_msg(p_manager, EVT_INFO, "Image data has been updated with tile %d.\n\n", l_current_tile_no);
8886
8887                 if(l_current_tile_no == l_tile_no_to_dec)
8888                 {
8889                         /* move into the codestream to the the first SOT (FIXME or not move?)*/
8890                         if (!(opj_stream_read_seek(p_stream, p_j2k->cstr_index->main_head_end + 2, p_manager) ) ) {
8891                                 opj_event_msg(p_manager, EVT_ERROR, "Problem with seek function\n");
8892                                 return OPJ_FALSE;
8893                         }
8894                         break;
8895                 }
8896                 else {
8897                         opj_event_msg(p_manager, EVT_WARNING, "Tile read, decode and updated is not the desired (%d vs %d).\n", l_current_tile_no, l_tile_no_to_dec);
8898                 }
8899
8900         }
8901
8902         opj_free(l_current_data);
8903
8904         return OPJ_TRUE;
8905 }
8906
8907 /**
8908  * Sets up the procedures to do on decoding one tile. Developpers wanting to extend the library can add their own reading procedures.
8909  */
8910 static void opj_j2k_setup_decoding_tile (opj_j2k_t *p_j2k)
8911 {
8912         /* preconditions*/
8913         assert(p_j2k != 00);
8914
8915         opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_decode_one_tile);
8916         /* DEVELOPER CORNER, add your custom procedures */
8917
8918 }
8919
8920 OPJ_BOOL opj_j2k_decode(opj_j2k_t * p_j2k,
8921                                                 opj_stream_private_t * p_stream,
8922                                                 opj_image_t * p_image,
8923                                                 opj_event_mgr_t * p_manager)
8924 {
8925         OPJ_UINT32 compno;
8926
8927         if (!p_image)
8928                 return OPJ_FALSE;
8929
8930         p_j2k->m_output_image = opj_image_create0();
8931         if (! (p_j2k->m_output_image)) {
8932                 return OPJ_FALSE;
8933         }
8934         opj_copy_image_header(p_image, p_j2k->m_output_image);
8935
8936         /* customization of the decoding */
8937         opj_j2k_setup_decoding(p_j2k);
8938
8939         /* Decode the codestream */
8940         if (! opj_j2k_exec (p_j2k,p_j2k->m_procedure_list,p_stream,p_manager)) {
8941                 opj_image_destroy(p_j2k->m_private_image);
8942                 p_j2k->m_private_image = NULL;
8943                 return OPJ_FALSE;
8944         }
8945
8946         /* Move data and copy one information from codec to output image*/
8947         for (compno = 0; compno < p_image->numcomps; compno++) {
8948                 p_image->comps[compno].resno_decoded = p_j2k->m_output_image->comps[compno].resno_decoded;
8949                 p_image->comps[compno].data = p_j2k->m_output_image->comps[compno].data;
8950                 p_j2k->m_output_image->comps[compno].data = NULL;
8951         }
8952
8953         return OPJ_TRUE;
8954 }
8955
8956 OPJ_BOOL opj_j2k_get_tile(      opj_j2k_t *p_j2k,
8957                                                     opj_stream_private_t *p_stream,
8958                                                     opj_image_t* p_image,
8959                                                     opj_event_mgr_t * p_manager,
8960                                                     OPJ_UINT32 tile_index )
8961 {
8962         OPJ_UINT32 compno;
8963         OPJ_UINT32 l_tile_x, l_tile_y;
8964         opj_image_comp_t* l_img_comp;
8965
8966         if (!p_image) {
8967                 opj_event_msg(p_manager, EVT_ERROR, "We need an image previously created.\n");
8968                 return OPJ_FALSE;
8969         }
8970
8971         if ( /*(tile_index < 0) &&*/ (tile_index >= p_j2k->m_cp.tw * p_j2k->m_cp.th) ){
8972                 opj_event_msg(p_manager, EVT_ERROR, "Tile index provided by the user is incorrect %d (max = %d) \n", tile_index, (p_j2k->m_cp.tw * p_j2k->m_cp.th) - 1);
8973                 return OPJ_FALSE;
8974         }
8975
8976         /* Compute the dimension of the desired tile*/
8977         l_tile_x = tile_index % p_j2k->m_cp.tw;
8978         l_tile_y = tile_index / p_j2k->m_cp.tw;
8979
8980         p_image->x0 = l_tile_x * p_j2k->m_cp.tdx + p_j2k->m_cp.tx0;
8981         if (p_image->x0 < p_j2k->m_private_image->x0)
8982                 p_image->x0 = p_j2k->m_private_image->x0;
8983         p_image->x1 = (l_tile_x + 1) * p_j2k->m_cp.tdx + p_j2k->m_cp.tx0;
8984         if (p_image->x1 > p_j2k->m_private_image->x1)
8985                 p_image->x1 = p_j2k->m_private_image->x1;
8986
8987         p_image->y0 = l_tile_y * p_j2k->m_cp.tdy + p_j2k->m_cp.ty0;
8988         if (p_image->y0 < p_j2k->m_private_image->y0)
8989                 p_image->y0 = p_j2k->m_private_image->y0;
8990         p_image->y1 = (l_tile_y + 1) * p_j2k->m_cp.tdy + p_j2k->m_cp.ty0;
8991         if (p_image->y1 > p_j2k->m_private_image->y1)
8992                 p_image->y1 = p_j2k->m_private_image->y1;
8993
8994         l_img_comp = p_image->comps;
8995         for (compno=0; compno < p_image->numcomps; ++compno)
8996         {
8997                 OPJ_INT32 l_comp_x1, l_comp_y1;
8998
8999                 l_img_comp->factor = p_j2k->m_private_image->comps[compno].factor;
9000
9001                 l_img_comp->x0 = opj_int_ceildiv(p_image->x0, l_img_comp->dx);
9002                 l_img_comp->y0 = opj_int_ceildiv(p_image->y0, l_img_comp->dy);
9003                 l_comp_x1 = opj_int_ceildiv(p_image->x1, l_img_comp->dx);
9004                 l_comp_y1 = opj_int_ceildiv(p_image->y1, l_img_comp->dy);
9005
9006                 l_img_comp->w = opj_int_ceildivpow2(l_comp_x1, l_img_comp->factor) - opj_int_ceildivpow2(l_img_comp->x0, l_img_comp->factor);
9007                 l_img_comp->h = opj_int_ceildivpow2(l_comp_y1, l_img_comp->factor) - opj_int_ceildivpow2(l_img_comp->y0, l_img_comp->factor);
9008
9009                 l_img_comp++;
9010         }
9011
9012         /* Destroy the previous output image*/
9013         if (p_j2k->m_output_image)
9014                 opj_image_destroy(p_j2k->m_output_image);
9015
9016         /* Create the ouput image from the information previously computed*/
9017         p_j2k->m_output_image = opj_image_create0();
9018         if (! (p_j2k->m_output_image)) {
9019                 return OPJ_FALSE;
9020         }
9021         opj_copy_image_header(p_image, p_j2k->m_output_image);
9022
9023         p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec = tile_index;
9024
9025         /* customization of the decoding */
9026         opj_j2k_setup_decoding_tile(p_j2k);
9027
9028         /* Decode the codestream */
9029         if (! opj_j2k_exec (p_j2k,p_j2k->m_procedure_list,p_stream,p_manager)) {
9030                 opj_image_destroy(p_j2k->m_private_image);
9031                 p_j2k->m_private_image = NULL;
9032                 return OPJ_FALSE;
9033         }
9034
9035         /* Move data and copy one information from codec to output image*/
9036         for (compno = 0; compno < p_image->numcomps; compno++) {
9037                 p_image->comps[compno].resno_decoded = p_j2k->m_output_image->comps[compno].resno_decoded;
9038
9039                 if (p_image->comps[compno].data)
9040                         opj_free(p_image->comps[compno].data);
9041
9042                 p_image->comps[compno].data = p_j2k->m_output_image->comps[compno].data;
9043
9044                 p_j2k->m_output_image->comps[compno].data = NULL;
9045         }
9046
9047         return OPJ_TRUE;
9048 }
9049
9050 OPJ_BOOL opj_j2k_set_decoded_resolution_factor(opj_j2k_t *p_j2k,
9051                                                OPJ_UINT32 res_factor,
9052                                                opj_event_mgr_t * p_manager)
9053 {
9054         OPJ_UINT32 it_comp;
9055
9056         p_j2k->m_cp.m_specific_param.m_dec.m_reduce = res_factor;
9057
9058         if (p_j2k->m_private_image) {
9059                 if (p_j2k->m_private_image->comps) {
9060                         if (p_j2k->m_specific_param.m_decoder.m_default_tcp) {
9061                                 if (p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps) {
9062                                         for (it_comp = 0 ; it_comp < p_j2k->m_private_image->numcomps; it_comp++) {
9063                                                 OPJ_UINT32 max_res = p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps[it_comp].numresolutions;
9064                                                 if ( res_factor >= max_res){
9065                                                         opj_event_msg(p_manager, EVT_ERROR, "Resolution factor is greater than the maximum resolution in the component.\n");
9066                                                         return OPJ_FALSE;
9067                                                 }
9068                                                 p_j2k->m_private_image->comps[it_comp].factor = res_factor;
9069                                         }
9070                                         return OPJ_TRUE;
9071                                 }
9072                         }
9073                 }
9074         }
9075
9076         return OPJ_FALSE;
9077 }
9078
9079 OPJ_BOOL opj_j2k_encode(opj_j2k_t * p_j2k,
9080                         opj_stream_private_t *p_stream,
9081                         opj_event_mgr_t * p_manager )
9082 {
9083         OPJ_UINT32 i;
9084         OPJ_UINT32 l_nb_tiles;
9085         OPJ_UINT32 l_max_tile_size, l_current_tile_size;
9086         OPJ_BYTE * l_current_data;
9087
9088         /* preconditions */
9089         assert(p_j2k != 00);
9090         assert(p_stream != 00);
9091         assert(p_manager != 00);
9092
9093         l_current_data = (OPJ_BYTE*)opj_malloc(1000);
9094         if (! l_current_data) {
9095                 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to encode all tiles\n");
9096                 return OPJ_FALSE;
9097         }
9098         l_max_tile_size = 1000;
9099
9100         l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
9101         for (i=0;i<l_nb_tiles;++i) {
9102                 if (! opj_j2k_pre_write_tile(p_j2k,i,p_stream,p_manager)) {
9103                         opj_free(l_current_data);
9104                         return OPJ_FALSE;
9105                 }
9106
9107                 l_current_tile_size = opj_tcd_get_encoded_tile_size(p_j2k->m_tcd);
9108                 if (l_current_tile_size > l_max_tile_size) {
9109                         OPJ_BYTE *l_new_current_data = (OPJ_BYTE *) opj_realloc(l_current_data, l_current_tile_size);
9110                         if (! l_new_current_data) {
9111                                 opj_free(l_current_data);
9112                                 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to encode all tiles\n");
9113                                 return OPJ_FALSE;
9114                         }
9115                         l_current_data = l_new_current_data;
9116                         l_max_tile_size = l_current_tile_size;
9117                 }
9118
9119                 opj_j2k_get_tile_data(p_j2k->m_tcd,l_current_data);
9120
9121                 if (! opj_j2k_post_write_tile (p_j2k,l_current_data,l_current_tile_size,p_stream,p_manager)) {
9122                         return OPJ_FALSE;
9123                 }
9124         }
9125
9126         opj_free(l_current_data);
9127         return OPJ_TRUE;
9128 }
9129
9130 OPJ_BOOL opj_j2k_end_compress(  opj_j2k_t *p_j2k,
9131                                                         opj_stream_private_t *p_stream,
9132                                                         opj_event_mgr_t * p_manager)
9133 {
9134         /* customization of the encoding */
9135         opj_j2k_setup_end_compress(p_j2k);
9136
9137         if (! opj_j2k_exec (p_j2k, p_j2k->m_procedure_list, p_stream, p_manager))
9138         {
9139                 return OPJ_FALSE;
9140         }
9141
9142         return OPJ_TRUE;
9143 }
9144
9145 OPJ_BOOL opj_j2k_start_compress(opj_j2k_t *p_j2k,
9146                                                             opj_stream_private_t *p_stream,
9147                                                             opj_image_t * p_image,
9148                                                             opj_event_mgr_t * p_manager)
9149 {
9150         /* preconditions */
9151         assert(p_j2k != 00);
9152         assert(p_stream != 00);
9153         assert(p_manager != 00);
9154
9155         p_j2k->m_private_image = opj_image_create0();
9156         opj_copy_image_header(p_image, p_j2k->m_private_image);
9157
9158         /* TODO_MSD: Find a better way */
9159         if (p_image->comps) {
9160                 OPJ_UINT32 it_comp;
9161                 for (it_comp = 0 ; it_comp < p_image->numcomps; it_comp++) {
9162                         if (p_image->comps[it_comp].data) {
9163                                 p_j2k->m_private_image->comps[it_comp].data =p_image->comps[it_comp].data;
9164                                 p_image->comps[it_comp].data = NULL;
9165
9166                         }
9167                 }
9168         }
9169
9170         /* customization of the validation */
9171         opj_j2k_setup_encoding_validation (p_j2k);
9172
9173         /* validation of the parameters codec */
9174         if (! opj_j2k_exec(p_j2k,p_j2k->m_validation_list,p_stream,p_manager)) {
9175                 return OPJ_FALSE;
9176         }
9177
9178         /* customization of the encoding */
9179         opj_j2k_setup_header_writing(p_j2k);
9180
9181         /* write header */
9182         if (! opj_j2k_exec (p_j2k,p_j2k->m_procedure_list,p_stream,p_manager)) {
9183                 return OPJ_FALSE;
9184         }
9185
9186         return OPJ_TRUE;
9187 }
9188
9189 OPJ_BOOL opj_j2k_pre_write_tile (       opj_j2k_t * p_j2k,
9190                                                                 OPJ_UINT32 p_tile_index,
9191                                                                 opj_stream_private_t *p_stream,
9192                                                                 opj_event_mgr_t * p_manager )
9193 {
9194   (void)p_stream;
9195         if (p_tile_index != p_j2k->m_current_tile_number) {
9196                 opj_event_msg(p_manager, EVT_ERROR, "The given tile index does not match." );
9197                 return OPJ_FALSE;
9198         }
9199
9200         opj_event_msg(p_manager, EVT_INFO, "tile number %d / %d\n", p_j2k->m_current_tile_number + 1, p_j2k->m_cp.tw * p_j2k->m_cp.th);
9201
9202         p_j2k->m_specific_param.m_encoder.m_current_tile_part_number = 0;
9203         p_j2k->m_tcd->cur_totnum_tp = p_j2k->m_cp.tcps[p_tile_index].m_nb_tile_parts;
9204         p_j2k->m_specific_param.m_encoder.m_current_poc_tile_part_number = 0;
9205
9206         /* initialisation before tile encoding  */
9207         if (! opj_tcd_init_encode_tile(p_j2k->m_tcd, p_j2k->m_current_tile_number)) {
9208                 return OPJ_FALSE;
9209         }
9210
9211         return OPJ_TRUE;
9212 }
9213
9214 void opj_j2k_get_tile_data (opj_tcd_t * p_tcd, OPJ_BYTE * p_data)
9215 {
9216         OPJ_UINT32 i,j,k = 0;
9217         OPJ_UINT32 l_width,l_height,l_stride, l_offset_x,l_offset_y, l_image_width;
9218         opj_image_comp_t * l_img_comp = 00;
9219         opj_tcd_tilecomp_t * l_tilec = 00;
9220         opj_image_t * l_image = 00;
9221         OPJ_UINT32 l_size_comp, l_remaining;
9222         OPJ_INT32 * l_src_ptr;
9223         l_tilec = p_tcd->tcd_image->tiles->comps;
9224         l_image = p_tcd->image;
9225         l_img_comp = l_image->comps;
9226
9227         for (i=0;i<p_tcd->image->numcomps;++i) {
9228                 l_size_comp = l_img_comp->prec >> 3; /* (/8) */
9229                 l_remaining = l_img_comp->prec & 7;  /* (%8) */
9230                 if (l_remaining) {
9231                         ++l_size_comp;
9232                 }
9233
9234                 if (l_size_comp == 3) {
9235                         l_size_comp = 4;
9236                 }
9237
9238                 l_width = (l_tilec->x1 - l_tilec->x0);
9239                 l_height = (l_tilec->y1 - l_tilec->y0);
9240                 l_offset_x = opj_int_ceildiv(l_image->x0, l_img_comp->dx);
9241                 l_offset_y = opj_int_ceildiv(l_image->y0, l_img_comp->dy);
9242                 l_image_width = opj_int_ceildiv(l_image->x1 - l_image->x0, l_img_comp->dx);
9243                 l_stride = l_image_width - l_width;
9244                 l_src_ptr = l_img_comp->data + (l_tilec->x0 - l_offset_x) + (l_tilec->y0 - l_offset_y) * l_image_width;
9245
9246                 switch (l_size_comp) {
9247                         case 1:
9248                                 {
9249                                         OPJ_CHAR * l_dest_ptr = (OPJ_CHAR*) p_data;
9250                                         if (l_img_comp->sgnd) {
9251                                                 for     (j=0;j<l_height;++j) {
9252                                                         for (k=0;k<l_width;++k) {
9253                                                                 *(l_dest_ptr) = (OPJ_CHAR) (*l_src_ptr);
9254                                                                 ++l_dest_ptr;
9255                                                                 ++l_src_ptr;
9256                                                         }
9257                                                         l_src_ptr += l_stride;
9258                                                 }
9259                                         }
9260                                         else {
9261                                                 for (j=0;j<l_height;++j) {
9262                                                         for (k=0;k<l_width;++k) {
9263                                                                 *(l_dest_ptr) = (*l_src_ptr)&0xff;
9264                                                                 ++l_dest_ptr;
9265                                                                 ++l_src_ptr;
9266                                                         }
9267                                                         l_src_ptr += l_stride;
9268                                                 }
9269                                         }
9270
9271                                         p_data = (OPJ_BYTE*) l_dest_ptr;
9272                                 }
9273                                 break;
9274                         case 2:
9275                                 {
9276                                         OPJ_INT16 * l_dest_ptr = (OPJ_INT16 *) p_data;
9277                                         if (l_img_comp->sgnd) {
9278                                                 for (j=0;j<l_height;++j) {
9279                                                         for (k=0;k<l_width;++k) {
9280                                                                 *(l_dest_ptr++) = (OPJ_INT16) (*(l_src_ptr++));
9281                                                         }
9282                                                         l_src_ptr += l_stride;
9283                                                 }
9284                                         }
9285                                         else {
9286                                                 for (j=0;j<l_height;++j) {
9287                                                         for (k=0;k<l_width;++k) {
9288                                                                 *(l_dest_ptr++) = (*(l_src_ptr++))&0xffff;
9289                                                         }
9290                                                         l_src_ptr += l_stride;
9291                                                 }
9292                                         }
9293
9294                                         p_data = (OPJ_BYTE*) l_dest_ptr;
9295                                 }
9296                                 break;
9297                         case 4:
9298                                 {
9299                                         OPJ_INT32 * l_dest_ptr = (OPJ_INT32 *) p_data;
9300                                         for (j=0;j<l_height;++j) {
9301                                                 for (k=0;k<l_width;++k) {
9302                                                         *(l_dest_ptr++) = *(l_src_ptr++);
9303                                                 }
9304                                                 l_src_ptr += l_stride;
9305                                         }
9306
9307                                         p_data = (OPJ_BYTE*) l_dest_ptr;
9308                                 }
9309                                 break;
9310                 }
9311
9312                 ++l_img_comp;
9313                 ++l_tilec;
9314         }
9315 }
9316
9317 OPJ_BOOL opj_j2k_post_write_tile (      opj_j2k_t * p_j2k,
9318                                                                 OPJ_BYTE * p_data,
9319                                                                 OPJ_UINT32 p_data_size,
9320                                                                 opj_stream_private_t *p_stream,
9321                                                                 opj_event_mgr_t * p_manager )
9322 {
9323         opj_tcd_t * l_tcd = 00;
9324         OPJ_UINT32 l_nb_bytes_written;
9325         OPJ_BYTE * l_current_data = 00;
9326         OPJ_UINT32 l_tile_size = 0;
9327         OPJ_UINT32 l_available_data;
9328
9329         /* preconditions */
9330         assert(p_j2k->m_specific_param.m_encoder.m_encoded_tile_data);
9331
9332         l_tcd = p_j2k->m_tcd;
9333
9334         l_tile_size = p_j2k->m_specific_param.m_encoder.m_encoded_tile_size;
9335         l_available_data = l_tile_size;
9336         l_current_data = p_j2k->m_specific_param.m_encoder.m_encoded_tile_data;
9337
9338         if (! opj_tcd_copy_tile_data(l_tcd,p_data,p_data_size)) {
9339                 opj_event_msg(p_manager, EVT_ERROR, "Size mismatch between tile data and sent data." );
9340                 return OPJ_FALSE;
9341         }
9342
9343         l_nb_bytes_written = 0;
9344         if (! opj_j2k_write_first_tile_part(p_j2k,l_current_data,&l_nb_bytes_written,l_available_data,p_stream,p_manager)) {
9345                 return OPJ_FALSE;
9346         }
9347         l_current_data += l_nb_bytes_written;
9348         l_available_data -= l_nb_bytes_written;
9349
9350         l_nb_bytes_written = 0;
9351         if (! opj_j2k_write_all_tile_parts(p_j2k,l_current_data,&l_nb_bytes_written,l_available_data,p_stream,p_manager)) {
9352                 return OPJ_FALSE;
9353         }
9354
9355         l_available_data -= l_nb_bytes_written;
9356         l_nb_bytes_written = l_tile_size - l_available_data;
9357
9358         if ( opj_stream_write_data(     p_stream,
9359                                                                 p_j2k->m_specific_param.m_encoder.m_encoded_tile_data,
9360                                                                 l_nb_bytes_written,p_manager) != l_nb_bytes_written) {
9361                 return OPJ_FALSE;
9362         }
9363
9364         ++p_j2k->m_current_tile_number;
9365
9366         return OPJ_TRUE;
9367 }
9368
9369 void opj_j2k_setup_end_compress (opj_j2k_t *p_j2k)
9370 {
9371         /* preconditions */
9372         assert(p_j2k != 00);
9373
9374         /* DEVELOPER CORNER, insert your custom procedures */
9375         opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_eoc );
9376
9377         if (p_j2k->m_cp.m_specific_param.m_enc.m_cinema) {
9378                 opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_updated_tlm);
9379         }
9380
9381         opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_epc );
9382         opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_end_encoding );
9383         opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_destroy_header_memory);
9384 }
9385
9386 void opj_j2k_setup_encoding_validation (opj_j2k_t *p_j2k)
9387 {
9388         /* preconditions */
9389         assert(p_j2k != 00);
9390
9391         opj_procedure_list_add_procedure(p_j2k->m_validation_list, (opj_procedure)opj_j2k_build_encoder);
9392         opj_procedure_list_add_procedure(p_j2k->m_validation_list, (opj_procedure)opj_j2k_encoding_validation);
9393
9394         /* DEVELOPER CORNER, add your custom validation procedure */
9395         opj_procedure_list_add_procedure(p_j2k->m_validation_list, (opj_procedure)opj_j2k_mct_validation);
9396 }
9397
9398 void opj_j2k_setup_header_writing (opj_j2k_t *p_j2k)
9399 {
9400         /* preconditions */
9401         assert(p_j2k != 00);
9402
9403         opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_init_info );
9404         opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_soc );
9405         opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_siz );
9406         opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_cod );
9407         opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_qcd );
9408
9409         if (p_j2k->m_cp.m_specific_param.m_enc.m_cinema) {
9410                 opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_image_components );
9411                 opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_tlm );
9412
9413                 if (p_j2k->m_cp.m_specific_param.m_enc.m_cinema == OPJ_CINEMA4K_24) {
9414                         opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_poc );
9415                 }
9416         }
9417
9418         opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_regions);
9419
9420         if (p_j2k->m_cp.comment != 00)  {
9421                 opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_com);
9422         }
9423
9424         /* DEVELOPER CORNER, insert your custom procedures */
9425         if (p_j2k->m_cp.rsiz & OPJ_MCT) {
9426                 opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_mct_data_group );
9427         }
9428         /* End of Developer Corner */
9429
9430         if (p_j2k->cstr_index) {
9431                 opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_get_end_header );
9432         }
9433
9434         opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_create_tcd);
9435         opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_update_rates);
9436 }
9437
9438 OPJ_BOOL opj_j2k_write_first_tile_part (opj_j2k_t *p_j2k,
9439                                                                         OPJ_BYTE * p_data,
9440                                                                         OPJ_UINT32 * p_data_written,
9441                                                                         OPJ_UINT32 p_total_data_size,
9442                                                                         opj_stream_private_t *p_stream,
9443                                                                         struct opj_event_mgr * p_manager )
9444 {
9445         OPJ_UINT32 compno;
9446         OPJ_UINT32 l_nb_bytes_written = 0;
9447         OPJ_UINT32 l_current_nb_bytes_written;
9448         OPJ_BYTE * l_begin_data = 00;
9449
9450         opj_tcd_t * l_tcd = 00;
9451         opj_cp_t * l_cp = 00;
9452
9453         l_tcd = p_j2k->m_tcd;
9454         l_cp = &(p_j2k->m_cp);
9455
9456         l_tcd->cur_pino = 0;
9457
9458         /*Get number of tile parts*/
9459         p_j2k->m_specific_param.m_encoder.m_current_poc_tile_part_number = 0;
9460
9461         /* INDEX >> */
9462         /* << INDEX */
9463
9464         l_current_nb_bytes_written = 0;
9465         l_begin_data = p_data;
9466         if (! opj_j2k_write_sot(p_j2k,p_data,&l_current_nb_bytes_written,p_stream,p_manager))
9467         {
9468                 return OPJ_FALSE;
9469         }
9470
9471         l_nb_bytes_written += l_current_nb_bytes_written;
9472         p_data += l_current_nb_bytes_written;
9473         p_total_data_size -= l_current_nb_bytes_written;
9474
9475         if (l_cp->m_specific_param.m_enc.m_cinema == 0) {
9476                 for (compno = 1; compno < p_j2k->m_private_image->numcomps; compno++) {
9477                         l_current_nb_bytes_written = 0;
9478                         opj_j2k_write_coc_in_memory(p_j2k,compno,p_data,&l_current_nb_bytes_written,p_manager);
9479                         l_nb_bytes_written += l_current_nb_bytes_written;
9480                         p_data += l_current_nb_bytes_written;
9481                         p_total_data_size -= l_current_nb_bytes_written;
9482
9483                         l_current_nb_bytes_written = 0;
9484                         opj_j2k_write_qcc_in_memory(p_j2k,compno,p_data,&l_current_nb_bytes_written,p_manager);
9485                         l_nb_bytes_written += l_current_nb_bytes_written;
9486                         p_data += l_current_nb_bytes_written;
9487                         p_total_data_size -= l_current_nb_bytes_written;
9488                 }
9489
9490                 if (l_cp->tcps[p_j2k->m_current_tile_number].numpocs) {
9491                         l_current_nb_bytes_written = 0;
9492                         opj_j2k_write_poc_in_memory(p_j2k,p_data,&l_current_nb_bytes_written,p_manager);
9493                         l_nb_bytes_written += l_current_nb_bytes_written;
9494                         p_data += l_current_nb_bytes_written;
9495                         p_total_data_size -= l_current_nb_bytes_written;
9496                 }
9497         }
9498
9499         l_current_nb_bytes_written = 0;
9500         if (! opj_j2k_write_sod(p_j2k,l_tcd,p_data,&l_current_nb_bytes_written,p_total_data_size,p_stream,p_manager)) {
9501                 return OPJ_FALSE;
9502         }
9503
9504         l_nb_bytes_written += l_current_nb_bytes_written;
9505         * p_data_written = l_nb_bytes_written;
9506
9507         /* Writing Psot in SOT marker */
9508         opj_write_bytes(l_begin_data + 6,l_nb_bytes_written,4);                                 /* PSOT */
9509
9510         if (l_cp->m_specific_param.m_enc.m_cinema){
9511                 opj_j2k_update_tlm(p_j2k,l_nb_bytes_written);
9512         }
9513
9514         return OPJ_TRUE;
9515 }
9516
9517 OPJ_BOOL opj_j2k_write_all_tile_parts(  opj_j2k_t *p_j2k,
9518                                                                         OPJ_BYTE * p_data,
9519                                                                         OPJ_UINT32 * p_data_written,
9520                                                                         OPJ_UINT32 p_total_data_size,
9521                                                                         opj_stream_private_t *p_stream,
9522                                                                         struct opj_event_mgr * p_manager
9523                                                                 )
9524 {
9525         OPJ_UINT32 tilepartno=0;
9526         OPJ_UINT32 l_nb_bytes_written = 0;
9527         OPJ_UINT32 l_current_nb_bytes_written;
9528         OPJ_UINT32 l_part_tile_size;
9529         OPJ_UINT32 tot_num_tp;
9530         OPJ_UINT32 pino;
9531
9532         OPJ_BYTE * l_begin_data;
9533         opj_tcp_t *l_tcp = 00;
9534         opj_tcd_t * l_tcd = 00;
9535         opj_cp_t * l_cp = 00;
9536
9537         l_tcd = p_j2k->m_tcd;
9538         l_cp = &(p_j2k->m_cp);
9539         l_tcp = l_cp->tcps + p_j2k->m_current_tile_number;
9540
9541         /*Get number of tile parts*/
9542         tot_num_tp = opj_j2k_get_num_tp(l_cp,0,p_j2k->m_current_tile_number);
9543
9544         /* start writing remaining tile parts */
9545         ++p_j2k->m_specific_param.m_encoder.m_current_tile_part_number;
9546         for (tilepartno = 1; tilepartno < tot_num_tp ; ++tilepartno) {
9547                 p_j2k->m_specific_param.m_encoder.m_current_poc_tile_part_number = tilepartno;
9548                 l_current_nb_bytes_written = 0;
9549                 l_part_tile_size = 0;
9550                 l_begin_data = p_data;
9551
9552                 if (! opj_j2k_write_sot(p_j2k,p_data,&l_current_nb_bytes_written,p_stream,p_manager)) {
9553                         return OPJ_FALSE;
9554                 }
9555
9556                 l_nb_bytes_written += l_current_nb_bytes_written;
9557                 p_data += l_current_nb_bytes_written;
9558                 p_total_data_size -= l_current_nb_bytes_written;
9559                 l_part_tile_size += l_current_nb_bytes_written;
9560
9561                 l_current_nb_bytes_written = 0;
9562                 if (! opj_j2k_write_sod(p_j2k,l_tcd,p_data,&l_current_nb_bytes_written,p_total_data_size,p_stream,p_manager)) {
9563                         return OPJ_FALSE;
9564                 }
9565
9566                 p_data += l_current_nb_bytes_written;
9567                 l_nb_bytes_written += l_current_nb_bytes_written;
9568                 p_total_data_size -= l_current_nb_bytes_written;
9569                 l_part_tile_size += l_current_nb_bytes_written;
9570
9571                 /* Writing Psot in SOT marker */
9572                 opj_write_bytes(l_begin_data + 6,l_part_tile_size,4);                                   /* PSOT */
9573
9574                 if (l_cp->m_specific_param.m_enc.m_cinema) {
9575                         opj_j2k_update_tlm(p_j2k,l_part_tile_size);
9576                 }
9577
9578                 ++p_j2k->m_specific_param.m_encoder.m_current_tile_part_number;
9579         }
9580
9581         for (pino = 1; pino <= l_tcp->numpocs; ++pino) {
9582                 l_tcd->cur_pino = pino;
9583
9584                 /*Get number of tile parts*/
9585                 tot_num_tp = opj_j2k_get_num_tp(l_cp,pino,p_j2k->m_current_tile_number);
9586                 for (tilepartno = 0; tilepartno < tot_num_tp ; ++tilepartno) {
9587                         p_j2k->m_specific_param.m_encoder.m_current_poc_tile_part_number = tilepartno;
9588                         l_current_nb_bytes_written = 0;
9589                         l_part_tile_size = 0;
9590                         l_begin_data = p_data;
9591
9592                         if (! opj_j2k_write_sot(p_j2k,p_data,&l_current_nb_bytes_written,p_stream,p_manager)) {
9593                                 return OPJ_FALSE;
9594                         }
9595
9596                         l_nb_bytes_written += l_current_nb_bytes_written;
9597                         p_data += l_current_nb_bytes_written;
9598                         p_total_data_size -= l_current_nb_bytes_written;
9599                         l_part_tile_size += l_current_nb_bytes_written;
9600
9601                         l_current_nb_bytes_written = 0;
9602
9603                         if (! opj_j2k_write_sod(p_j2k,l_tcd,p_data,&l_current_nb_bytes_written,p_total_data_size,p_stream,p_manager)) {
9604                                 return OPJ_FALSE;
9605                         }
9606
9607                         l_nb_bytes_written += l_current_nb_bytes_written;
9608                         p_data += l_current_nb_bytes_written;
9609                         p_total_data_size -= l_current_nb_bytes_written;
9610                         l_part_tile_size += l_current_nb_bytes_written;
9611
9612                         /* Writing Psot in SOT marker */
9613                         opj_write_bytes(l_begin_data + 6,l_part_tile_size,4);                                   /* PSOT */
9614
9615                         if (l_cp->m_specific_param.m_enc.m_cinema) {
9616                                 opj_j2k_update_tlm(p_j2k,l_part_tile_size);
9617                         }
9618
9619                         ++p_j2k->m_specific_param.m_encoder.m_current_tile_part_number;
9620                 }
9621         }
9622
9623         *p_data_written = l_nb_bytes_written;
9624
9625         return OPJ_TRUE;
9626 }
9627
9628 OPJ_BOOL opj_j2k_write_updated_tlm( opj_j2k_t *p_j2k,
9629                                                                     struct opj_stream_private *p_stream,
9630                                                                     struct opj_event_mgr * p_manager )
9631 {
9632         OPJ_UINT32 l_tlm_size;
9633         OPJ_OFF_T l_tlm_position, l_current_position;
9634
9635         /* preconditions */
9636         assert(p_j2k != 00);
9637         assert(p_manager != 00);
9638         assert(p_stream != 00);
9639
9640         l_tlm_size = 5 * p_j2k->m_specific_param.m_encoder.m_total_tile_parts;
9641         l_tlm_position = 6 + p_j2k->m_specific_param.m_encoder.m_tlm_start;
9642         l_current_position = opj_stream_tell(p_stream);
9643
9644         if (! opj_stream_seek(p_stream,l_tlm_position,p_manager)) {
9645                 return OPJ_FALSE;
9646         }
9647
9648         if (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer,l_tlm_size,p_manager) != l_tlm_size) {
9649                 return OPJ_FALSE;
9650         }
9651
9652         if (! opj_stream_seek(p_stream,l_current_position,p_manager)) {
9653                 return OPJ_FALSE;
9654         }
9655
9656         return OPJ_TRUE;
9657 }
9658
9659 OPJ_BOOL opj_j2k_end_encoding(  opj_j2k_t *p_j2k,
9660                                                         struct opj_stream_private *p_stream,
9661                                                         struct opj_event_mgr * p_manager )
9662 {
9663         /* preconditions */
9664         assert(p_j2k != 00);
9665         assert(p_manager != 00);
9666         assert(p_stream != 00);
9667
9668         opj_tcd_destroy(p_j2k->m_tcd);
9669         p_j2k->m_tcd = 00;
9670
9671         if (p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer) {
9672                 opj_free(p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer);
9673                 p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer = 0;
9674                 p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current = 0;
9675         }
9676
9677         if (p_j2k->m_specific_param.m_encoder.m_encoded_tile_data) {
9678                 opj_free(p_j2k->m_specific_param.m_encoder.m_encoded_tile_data);
9679                 p_j2k->m_specific_param.m_encoder.m_encoded_tile_data = 0;
9680         }
9681
9682         p_j2k->m_specific_param.m_encoder.m_encoded_tile_size = 0;
9683
9684         return OPJ_TRUE;
9685 }
9686
9687 /**
9688  * Destroys the memory associated with the decoding of headers.
9689  */
9690 static OPJ_BOOL opj_j2k_destroy_header_memory ( opj_j2k_t * p_j2k,
9691                                                 opj_stream_private_t *p_stream,
9692                                                 opj_event_mgr_t * p_manager
9693                                                 )
9694 {
9695         /* preconditions */
9696         assert(p_j2k != 00);
9697         assert(p_stream != 00);
9698         assert(p_manager != 00);
9699
9700         if (p_j2k->m_specific_param.m_encoder.m_header_tile_data) {
9701                 opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
9702                 p_j2k->m_specific_param.m_encoder.m_header_tile_data = 0;
9703         }
9704
9705         p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
9706
9707         return OPJ_TRUE;
9708 }
9709
9710 OPJ_BOOL opj_j2k_init_info(     opj_j2k_t *p_j2k,
9711                                                 struct opj_stream_private *p_stream,
9712                                                 struct opj_event_mgr * p_manager )
9713 {
9714         opj_codestream_info_t * l_cstr_info = 00;
9715
9716         /* preconditions */
9717         assert(p_j2k != 00);
9718         assert(p_manager != 00);
9719         assert(p_stream != 00);
9720   (void)l_cstr_info;
9721
9722         /* TODO mergeV2: check this part which use cstr_info */
9723         /*l_cstr_info = p_j2k->cstr_info;
9724
9725         if (l_cstr_info)  {
9726                 OPJ_UINT32 compno;
9727                 l_cstr_info->tile = (opj_tile_info_t *) opj_malloc(p_j2k->m_cp.tw * p_j2k->m_cp.th * sizeof(opj_tile_info_t));
9728
9729                 l_cstr_info->image_w = p_j2k->m_image->x1 - p_j2k->m_image->x0;
9730                 l_cstr_info->image_h = p_j2k->m_image->y1 - p_j2k->m_image->y0;
9731
9732                 l_cstr_info->prog = (&p_j2k->m_cp.tcps[0])->prg;
9733
9734                 l_cstr_info->tw = p_j2k->m_cp.tw;
9735                 l_cstr_info->th = p_j2k->m_cp.th;
9736
9737                 l_cstr_info->tile_x = p_j2k->m_cp.tdx;*/        /* new version parser */
9738                 /*l_cstr_info->tile_y = p_j2k->m_cp.tdy;*/      /* new version parser */
9739                 /*l_cstr_info->tile_Ox = p_j2k->m_cp.tx0;*/     /* new version parser */
9740                 /*l_cstr_info->tile_Oy = p_j2k->m_cp.ty0;*/     /* new version parser */
9741
9742                 /*l_cstr_info->numcomps = p_j2k->m_image->numcomps;
9743
9744                 l_cstr_info->numlayers = (&p_j2k->m_cp.tcps[0])->numlayers;
9745
9746                 l_cstr_info->numdecompos = (OPJ_INT32*) opj_malloc(p_j2k->m_image->numcomps * sizeof(OPJ_INT32));
9747
9748                 for (compno=0; compno < p_j2k->m_image->numcomps; compno++) {
9749                         l_cstr_info->numdecompos[compno] = (&p_j2k->m_cp.tcps[0])->tccps->numresolutions - 1;
9750                 }
9751
9752                 l_cstr_info->D_max = 0.0;       */      /* ADD Marcela */
9753
9754                 /*l_cstr_info->main_head_start = opj_stream_tell(p_stream);*/ /* position of SOC */
9755
9756                 /*l_cstr_info->maxmarknum = 100;
9757                 l_cstr_info->marker = (opj_marker_info_t *) opj_malloc(l_cstr_info->maxmarknum * sizeof(opj_marker_info_t));
9758                 l_cstr_info->marknum = 0;
9759         }*/
9760
9761         return opj_j2k_calculate_tp(p_j2k,&(p_j2k->m_cp),&p_j2k->m_specific_param.m_encoder.m_total_tile_parts,p_j2k->m_private_image,p_manager);
9762 }
9763
9764 /**
9765  * Creates a tile-coder decoder.
9766  *
9767  * @param       p_stream                the stream to write data to.
9768  * @param       p_j2k                   J2K codec.
9769  * @param       p_manager               the user event manager.
9770 */
9771 static OPJ_BOOL opj_j2k_create_tcd(     opj_j2k_t *p_j2k,
9772                                                                     opj_stream_private_t *p_stream,
9773                                                                     opj_event_mgr_t * p_manager
9774                                     )
9775 {
9776         /* preconditions */
9777         assert(p_j2k != 00);
9778         assert(p_manager != 00);
9779         assert(p_stream != 00);
9780
9781         p_j2k->m_tcd = opj_tcd_create(OPJ_FALSE);
9782
9783         if (! p_j2k->m_tcd) {
9784                 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to create Tile Coder\n");
9785                 return OPJ_FALSE;
9786         }
9787
9788         if (!opj_tcd_init(p_j2k->m_tcd,p_j2k->m_private_image,&p_j2k->m_cp)) {
9789                 opj_tcd_destroy(p_j2k->m_tcd);
9790                 p_j2k->m_tcd = 00;
9791                 return OPJ_FALSE;
9792         }
9793
9794         return OPJ_TRUE;
9795 }
9796
9797 OPJ_BOOL opj_j2k_write_tile (opj_j2k_t * p_j2k,
9798                                                  OPJ_UINT32 p_tile_index,
9799                                                  OPJ_BYTE * p_data,
9800                                                  OPJ_UINT32 p_data_size,
9801                                                  opj_stream_private_t *p_stream,
9802                                                  opj_event_mgr_t * p_manager )
9803 {
9804         if (! opj_j2k_pre_write_tile(p_j2k,p_tile_index,p_stream,p_manager)) {
9805                 opj_event_msg(p_manager, EVT_ERROR, "Error while opj_j2k_pre_write_tile with tile index = %d\n", p_tile_index);
9806                 return OPJ_FALSE;
9807         }
9808         else {
9809                 if (! opj_j2k_post_write_tile(p_j2k,p_data,p_data_size,p_stream,p_manager)) {
9810                         opj_event_msg(p_manager, EVT_ERROR, "Error while opj_j2k_post_write_tile with tile index = %d\n", p_tile_index);
9811                         return OPJ_FALSE;
9812                 }
9813         }
9814
9815         return OPJ_TRUE;
9816 }