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