src/lib/openjp2/j2k.c

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