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