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