src/lib/openjp2/j2k.c

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