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     if (parameters->cp_disto_alloc) {
6812         /* Emit warnings if tcp_rates are not decreasing */
6813         for (i = 1; i < (OPJ_UINT32) parameters->tcp_numlayers; i++) {
6814             OPJ_FLOAT32 rate_i_corr = parameters->tcp_rates[i];
6815             OPJ_FLOAT32 rate_i_m_1_corr = parameters->tcp_rates[i - 1];
6816             if (rate_i_corr <= 1.0) {
6817                 rate_i_corr = 1.0;
6818             }
6819             if (rate_i_m_1_corr <= 1.0) {
6820                 rate_i_m_1_corr = 1.0;
6821             }
6822             if (rate_i_corr >= rate_i_m_1_corr) {
6823                 if (rate_i_corr != parameters->tcp_rates[i] &&
6824                         rate_i_m_1_corr != parameters->tcp_rates[i - 1]) {
6825                     opj_event_msg(p_manager, EVT_WARNING,
6826                                   "tcp_rates[%d]=%f (corrected as %f) should be strictly lesser "
6827                                   "than tcp_rates[%d]=%f (corrected as %f)\n",
6828                                   i, parameters->tcp_rates[i], rate_i_corr,
6829                                   i - 1, parameters->tcp_rates[i - 1], rate_i_m_1_corr);
6830                 } else if (rate_i_corr != parameters->tcp_rates[i]) {
6831                     opj_event_msg(p_manager, EVT_WARNING,
6832                                   "tcp_rates[%d]=%f (corrected as %f) should be strictly lesser "
6833                                   "than tcp_rates[%d]=%f\n",
6834                                   i, parameters->tcp_rates[i], rate_i_corr,
6835                                   i - 1, parameters->tcp_rates[i - 1]);
6836                 } else if (rate_i_m_1_corr != parameters->tcp_rates[i - 1]) {
6837                     opj_event_msg(p_manager, EVT_WARNING,
6838                                   "tcp_rates[%d]=%f should be strictly lesser "
6839                                   "than tcp_rates[%d]=%f (corrected as %f)\n",
6840                                   i, parameters->tcp_rates[i],
6841                                   i - 1, parameters->tcp_rates[i - 1], rate_i_m_1_corr);
6842                 } else {
6843                     opj_event_msg(p_manager, EVT_WARNING,
6844                                   "tcp_rates[%d]=%f should be strictly lesser "
6845                                   "than tcp_rates[%d]=%f\n",
6846                                   i, parameters->tcp_rates[i],
6847                                   i - 1, parameters->tcp_rates[i - 1]);
6848                 }
6849             }
6850         }
6851     } else if (parameters->cp_fixed_quality) {
6852         /* Emit warnings if tcp_distoratio are not increasing */
6853         for (i = 1; i < (OPJ_UINT32) parameters->tcp_numlayers; i++) {
6854             if (parameters->tcp_distoratio[i] < parameters->tcp_distoratio[i - 1] &&
6855                     !(i == (OPJ_UINT32)parameters->tcp_numlayers - 1 &&
6856                       parameters->tcp_distoratio[i] == 0)) {
6857                 opj_event_msg(p_manager, EVT_WARNING,
6858                               "tcp_distoratio[%d]=%f should be strictly greater "
6859                               "than tcp_distoratio[%d]=%f\n",
6860                               i, parameters->tcp_distoratio[i], i - 1,
6861                               parameters->tcp_distoratio[i - 1]);
6862             }
6863         }
6864     }
6865
6866     /* see if max_codestream_size does limit input rate */
6867     if (parameters->max_cs_size <= 0) {
6868         if (parameters->tcp_rates[parameters->tcp_numlayers - 1] > 0) {
6869             OPJ_FLOAT32 temp_size;
6870             temp_size = (OPJ_FLOAT32)(((double)image->numcomps * image->comps[0].w *
6871                                        image->comps[0].h * image->comps[0].prec) /
6872                                       ((double)parameters->tcp_rates[parameters->tcp_numlayers - 1] * 8 *
6873                                        image->comps[0].dx * image->comps[0].dy));
6874             if (temp_size > INT_MAX) {
6875                 parameters->max_cs_size = INT_MAX;
6876             } else {
6877                 parameters->max_cs_size = (int) floor(temp_size);
6878             }
6879         } else {
6880             parameters->max_cs_size = 0;
6881         }
6882     } else {
6883         OPJ_FLOAT32 temp_rate;
6884         OPJ_BOOL cap = OPJ_FALSE;
6885         temp_rate = (OPJ_FLOAT32)(((double)image->numcomps * image->comps[0].w *
6886                                    image->comps[0].h * image->comps[0].prec) /
6887                                   (((double)parameters->max_cs_size) * 8 * image->comps[0].dx *
6888                                    image->comps[0].dy));
6889         for (i = 0; i < (OPJ_UINT32) parameters->tcp_numlayers; i++) {
6890             if (parameters->tcp_rates[i] < temp_rate) {
6891                 parameters->tcp_rates[i] = temp_rate;
6892                 cap = OPJ_TRUE;
6893             }
6894         }
6895         if (cap) {
6896             opj_event_msg(p_manager, EVT_WARNING,
6897                           "The desired maximum codestream size has limited\n"
6898                           "at least one of the desired quality layers\n");
6899         }
6900     }
6901
6902     /* Manage profiles and applications and set RSIZ */
6903     /* set cinema parameters if required */
6904     if (OPJ_IS_CINEMA(parameters->rsiz)) {
6905         if ((parameters->rsiz == OPJ_PROFILE_CINEMA_S2K)
6906                 || (parameters->rsiz == OPJ_PROFILE_CINEMA_S4K)) {
6907             opj_event_msg(p_manager, EVT_WARNING,
6908                           "JPEG 2000 Scalable Digital Cinema profiles not yet supported\n");
6909             parameters->rsiz = OPJ_PROFILE_NONE;
6910         } else {
6911             opj_j2k_set_cinema_parameters(parameters, image, p_manager);
6912             if (!opj_j2k_is_cinema_compliant(image, parameters->rsiz, p_manager)) {
6913                 parameters->rsiz = OPJ_PROFILE_NONE;
6914             }
6915         }
6916     } else if (OPJ_IS_STORAGE(parameters->rsiz)) {
6917         opj_event_msg(p_manager, EVT_WARNING,
6918                       "JPEG 2000 Long Term Storage profile not yet supported\n");
6919         parameters->rsiz = OPJ_PROFILE_NONE;
6920     } else if (OPJ_IS_BROADCAST(parameters->rsiz)) {
6921         opj_event_msg(p_manager, EVT_WARNING,
6922                       "JPEG 2000 Broadcast profiles not yet supported\n");
6923         parameters->rsiz = OPJ_PROFILE_NONE;
6924     } else if (OPJ_IS_IMF(parameters->rsiz)) {
6925         opj_event_msg(p_manager, EVT_WARNING,
6926                       "JPEG 2000 IMF profiles not yet supported\n");
6927         parameters->rsiz = OPJ_PROFILE_NONE;
6928     } else if (OPJ_IS_PART2(parameters->rsiz)) {
6929         if (parameters->rsiz == ((OPJ_PROFILE_PART2) | (OPJ_EXTENSION_NONE))) {
6930             opj_event_msg(p_manager, EVT_WARNING,
6931                           "JPEG 2000 Part-2 profile defined\n"
6932                           "but no Part-2 extension enabled.\n"
6933                           "Profile set to NONE.\n");
6934             parameters->rsiz = OPJ_PROFILE_NONE;
6935         } else if (parameters->rsiz != ((OPJ_PROFILE_PART2) | (OPJ_EXTENSION_MCT))) {
6936             opj_event_msg(p_manager, EVT_WARNING,
6937                           "Unsupported Part-2 extension enabled\n"
6938                           "Profile set to NONE.\n");
6939             parameters->rsiz = OPJ_PROFILE_NONE;
6940         }
6941     }
6942
6943     /*
6944     copy user encoding parameters
6945     */
6946     cp->m_specific_param.m_enc.m_max_comp_size = (OPJ_UINT32)
6947             parameters->max_comp_size;
6948     cp->rsiz = parameters->rsiz;
6949     cp->m_specific_param.m_enc.m_disto_alloc = (OPJ_UINT32)
6950             parameters->cp_disto_alloc & 1u;
6951     cp->m_specific_param.m_enc.m_fixed_alloc = (OPJ_UINT32)
6952             parameters->cp_fixed_alloc & 1u;
6953     cp->m_specific_param.m_enc.m_fixed_quality = (OPJ_UINT32)
6954             parameters->cp_fixed_quality & 1u;
6955
6956     /* mod fixed_quality */
6957     if (parameters->cp_fixed_alloc && parameters->cp_matrice) {
6958         size_t array_size = (size_t)parameters->tcp_numlayers *
6959                             (size_t)parameters->numresolution * 3 * sizeof(OPJ_INT32);
6960         cp->m_specific_param.m_enc.m_matrice = (OPJ_INT32 *) opj_malloc(array_size);
6961         if (!cp->m_specific_param.m_enc.m_matrice) {
6962             opj_event_msg(p_manager, EVT_ERROR,
6963                           "Not enough memory to allocate copy of user encoding parameters matrix \n");
6964             return OPJ_FALSE;
6965         }
6966         memcpy(cp->m_specific_param.m_enc.m_matrice, parameters->cp_matrice,
6967                array_size);
6968     }
6969
6970     /* tiles */
6971     cp->tdx = (OPJ_UINT32)parameters->cp_tdx;
6972     cp->tdy = (OPJ_UINT32)parameters->cp_tdy;
6973
6974     /* tile offset */
6975     cp->tx0 = (OPJ_UINT32)parameters->cp_tx0;
6976     cp->ty0 = (OPJ_UINT32)parameters->cp_ty0;
6977
6978     /* comment string */
6979     if (parameters->cp_comment) {
6980         cp->comment = (char*)opj_malloc(strlen(parameters->cp_comment) + 1U);
6981         if (!cp->comment) {
6982             opj_event_msg(p_manager, EVT_ERROR,
6983                           "Not enough memory to allocate copy of comment string\n");
6984             return OPJ_FALSE;
6985         }
6986         strcpy(cp->comment, parameters->cp_comment);
6987     } else {
6988         /* Create default comment for codestream */
6989         const char comment[] = "Created by OpenJPEG version ";
6990         const size_t clen = strlen(comment);
6991         const char *version = opj_version();
6992
6993         /* UniPG>> */
6994 #ifdef USE_JPWL
6995         cp->comment = (char*)opj_malloc(clen + strlen(version) + 11);
6996         if (!cp->comment) {
6997             opj_event_msg(p_manager, EVT_ERROR,
6998                           "Not enough memory to allocate comment string\n");
6999             return OPJ_FALSE;
7000         }
7001         sprintf(cp->comment, "%s%s with JPWL", comment, version);
7002 #else
7003         cp->comment = (char*)opj_malloc(clen + strlen(version) + 1);
7004         if (!cp->comment) {
7005             opj_event_msg(p_manager, EVT_ERROR,
7006                           "Not enough memory to allocate comment string\n");
7007             return OPJ_FALSE;
7008         }
7009         sprintf(cp->comment, "%s%s", comment, version);
7010 #endif
7011         /* <<UniPG */
7012     }
7013
7014     /*
7015     calculate other encoding parameters
7016     */
7017
7018     if (parameters->tile_size_on) {
7019         cp->tw = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)(image->x1 - cp->tx0),
7020                                              (OPJ_INT32)cp->tdx);
7021         cp->th = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)(image->y1 - cp->ty0),
7022                                              (OPJ_INT32)cp->tdy);
7023     } else {
7024         cp->tdx = image->x1 - cp->tx0;
7025         cp->tdy = image->y1 - cp->ty0;
7026     }
7027
7028     if (parameters->tp_on) {
7029         cp->m_specific_param.m_enc.m_tp_flag = (OPJ_BYTE)parameters->tp_flag;
7030         cp->m_specific_param.m_enc.m_tp_on = 1;
7031     }
7032
7033 #ifdef USE_JPWL
7034     /*
7035     calculate JPWL encoding parameters
7036     */
7037
7038     if (parameters->jpwl_epc_on) {
7039         OPJ_INT32 i;
7040
7041         /* set JPWL on */
7042         cp->epc_on = OPJ_TRUE;
7043         cp->info_on = OPJ_FALSE; /* no informative technique */
7044
7045         /* set EPB on */
7046         if ((parameters->jpwl_hprot_MH > 0) || (parameters->jpwl_hprot_TPH[0] > 0)) {
7047             cp->epb_on = OPJ_TRUE;
7048
7049             cp->hprot_MH = parameters->jpwl_hprot_MH;
7050             for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {
7051                 cp->hprot_TPH_tileno[i] = parameters->jpwl_hprot_TPH_tileno[i];
7052                 cp->hprot_TPH[i] = parameters->jpwl_hprot_TPH[i];
7053             }
7054             /* if tile specs are not specified, copy MH specs */
7055             if (cp->hprot_TPH[0] == -1) {
7056                 cp->hprot_TPH_tileno[0] = 0;
7057                 cp->hprot_TPH[0] = parameters->jpwl_hprot_MH;
7058             }
7059             for (i = 0; i < JPWL_MAX_NO_PACKSPECS; i++) {
7060                 cp->pprot_tileno[i] = parameters->jpwl_pprot_tileno[i];
7061                 cp->pprot_packno[i] = parameters->jpwl_pprot_packno[i];
7062                 cp->pprot[i] = parameters->jpwl_pprot[i];
7063             }
7064         }
7065
7066         /* set ESD writing */
7067         if ((parameters->jpwl_sens_size == 1) || (parameters->jpwl_sens_size == 2)) {
7068             cp->esd_on = OPJ_TRUE;
7069
7070             cp->sens_size = parameters->jpwl_sens_size;
7071             cp->sens_addr = parameters->jpwl_sens_addr;
7072             cp->sens_range = parameters->jpwl_sens_range;
7073
7074             cp->sens_MH = parameters->jpwl_sens_MH;
7075             for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {
7076                 cp->sens_TPH_tileno[i] = parameters->jpwl_sens_TPH_tileno[i];
7077                 cp->sens_TPH[i] = parameters->jpwl_sens_TPH[i];
7078             }
7079         }
7080
7081         /* always set RED writing to false: we are at the encoder */
7082         cp->red_on = OPJ_FALSE;
7083
7084     } else {
7085         cp->epc_on = OPJ_FALSE;
7086     }
7087 #endif /* USE_JPWL */
7088
7089     /* initialize the mutiple tiles */
7090     /* ---------------------------- */
7091     cp->tcps = (opj_tcp_t*) opj_calloc(cp->tw * cp->th, sizeof(opj_tcp_t));
7092     if (!cp->tcps) {
7093         opj_event_msg(p_manager, EVT_ERROR,
7094                       "Not enough memory to allocate tile coding parameters\n");
7095         return OPJ_FALSE;
7096     }
7097     if (parameters->numpocs) {
7098         /* initialisation of POC */
7099         opj_j2k_check_poc_val(parameters->POC, parameters->numpocs,
7100                               (OPJ_UINT32)parameters->numresolution, image->numcomps,
7101                               (OPJ_UINT32)parameters->tcp_numlayers, p_manager);
7102         /* TODO MSD use the return value*/
7103     }
7104
7105     for (tileno = 0; tileno < cp->tw * cp->th; tileno++) {
7106         opj_tcp_t *tcp = &cp->tcps[tileno];
7107         tcp->numlayers = (OPJ_UINT32)parameters->tcp_numlayers;
7108
7109         for (j = 0; j < tcp->numlayers; j++) {
7110             if (OPJ_IS_CINEMA(cp->rsiz)) {
7111                 if (cp->m_specific_param.m_enc.m_fixed_quality) {
7112                     tcp->distoratio[j] = parameters->tcp_distoratio[j];
7113                 }
7114                 tcp->rates[j] = parameters->tcp_rates[j];
7115             } else {
7116                 if (cp->m_specific_param.m_enc.m_fixed_quality) {       /* add fixed_quality */
7117                     tcp->distoratio[j] = parameters->tcp_distoratio[j];
7118                 } else {
7119                     tcp->rates[j] = parameters->tcp_rates[j];
7120                 }
7121             }
7122             if (!cp->m_specific_param.m_enc.m_fixed_quality &&
7123                     tcp->rates[j] <= 1.0) {
7124                 tcp->rates[j] = 0.0;    /* force lossless */
7125             }
7126         }
7127
7128         tcp->csty = (OPJ_UINT32)parameters->csty;
7129         tcp->prg = parameters->prog_order;
7130         tcp->mct = (OPJ_UINT32)parameters->tcp_mct;
7131
7132         numpocs_tile = 0;
7133         tcp->POC = 0;
7134
7135         if (parameters->numpocs) {
7136             /* initialisation of POC */
7137             tcp->POC = 1;
7138             for (i = 0; i < parameters->numpocs; i++) {
7139                 if (tileno + 1 == parameters->POC[i].tile)  {
7140                     opj_poc_t *tcp_poc = &tcp->pocs[numpocs_tile];
7141
7142                     tcp_poc->resno0         = parameters->POC[numpocs_tile].resno0;
7143                     tcp_poc->compno0        = parameters->POC[numpocs_tile].compno0;
7144                     tcp_poc->layno1         = parameters->POC[numpocs_tile].layno1;
7145                     tcp_poc->resno1         = parameters->POC[numpocs_tile].resno1;
7146                     tcp_poc->compno1        = parameters->POC[numpocs_tile].compno1;
7147                     tcp_poc->prg1           = parameters->POC[numpocs_tile].prg1;
7148                     tcp_poc->tile           = parameters->POC[numpocs_tile].tile;
7149
7150                     numpocs_tile++;
7151                 }
7152             }
7153
7154             tcp->numpocs = numpocs_tile - 1 ;
7155         } else {
7156             tcp->numpocs = 0;
7157         }
7158
7159         tcp->tccps = (opj_tccp_t*) opj_calloc(image->numcomps, sizeof(opj_tccp_t));
7160         if (!tcp->tccps) {
7161             opj_event_msg(p_manager, EVT_ERROR,
7162                           "Not enough memory to allocate tile component coding parameters\n");
7163             return OPJ_FALSE;
7164         }
7165         if (parameters->mct_data) {
7166
7167             OPJ_UINT32 lMctSize = image->numcomps * image->numcomps * (OPJ_UINT32)sizeof(
7168                                       OPJ_FLOAT32);
7169             OPJ_FLOAT32 * lTmpBuf = (OPJ_FLOAT32*)opj_malloc(lMctSize);
7170             OPJ_INT32 * l_dc_shift = (OPJ_INT32 *)((OPJ_BYTE *) parameters->mct_data +
7171                                                    lMctSize);
7172
7173             if (!lTmpBuf) {
7174                 opj_event_msg(p_manager, EVT_ERROR,
7175                               "Not enough memory to allocate temp buffer\n");
7176                 return OPJ_FALSE;
7177             }
7178
7179             tcp->mct = 2;
7180             tcp->m_mct_coding_matrix = (OPJ_FLOAT32*)opj_malloc(lMctSize);
7181             if (! tcp->m_mct_coding_matrix) {
7182                 opj_free(lTmpBuf);
7183                 lTmpBuf = NULL;
7184                 opj_event_msg(p_manager, EVT_ERROR,
7185                               "Not enough memory to allocate encoder MCT coding matrix \n");
7186                 return OPJ_FALSE;
7187             }
7188             memcpy(tcp->m_mct_coding_matrix, parameters->mct_data, lMctSize);
7189             memcpy(lTmpBuf, parameters->mct_data, lMctSize);
7190
7191             tcp->m_mct_decoding_matrix = (OPJ_FLOAT32*)opj_malloc(lMctSize);
7192             if (! tcp->m_mct_decoding_matrix) {
7193                 opj_free(lTmpBuf);
7194                 lTmpBuf = NULL;
7195                 opj_event_msg(p_manager, EVT_ERROR,
7196                               "Not enough memory to allocate encoder MCT decoding matrix \n");
7197                 return OPJ_FALSE;
7198             }
7199             if (opj_matrix_inversion_f(lTmpBuf, (tcp->m_mct_decoding_matrix),
7200                                        image->numcomps) == OPJ_FALSE) {
7201                 opj_free(lTmpBuf);
7202                 lTmpBuf = NULL;
7203                 opj_event_msg(p_manager, EVT_ERROR,
7204                               "Failed to inverse encoder MCT decoding matrix \n");
7205                 return OPJ_FALSE;
7206             }
7207
7208             tcp->mct_norms = (OPJ_FLOAT64*)
7209                              opj_malloc(image->numcomps * sizeof(OPJ_FLOAT64));
7210             if (! tcp->mct_norms) {
7211                 opj_free(lTmpBuf);
7212                 lTmpBuf = NULL;
7213                 opj_event_msg(p_manager, EVT_ERROR,
7214                               "Not enough memory to allocate encoder MCT norms \n");
7215                 return OPJ_FALSE;
7216             }
7217             opj_calculate_norms(tcp->mct_norms, image->numcomps,
7218                                 tcp->m_mct_decoding_matrix);
7219             opj_free(lTmpBuf);
7220
7221             for (i = 0; i < image->numcomps; i++) {
7222                 opj_tccp_t *tccp = &tcp->tccps[i];
7223                 tccp->m_dc_level_shift = l_dc_shift[i];
7224             }
7225
7226             if (opj_j2k_setup_mct_encoding(tcp, image) == OPJ_FALSE) {
7227                 /* free will be handled by opj_j2k_destroy */
7228                 opj_event_msg(p_manager, EVT_ERROR, "Failed to setup j2k mct encoding\n");
7229                 return OPJ_FALSE;
7230             }
7231         } else {
7232             if (tcp->mct == 1 && image->numcomps >= 3) { /* RGB->YCC MCT is enabled */
7233                 if ((image->comps[0].dx != image->comps[1].dx) ||
7234                         (image->comps[0].dx != image->comps[2].dx) ||
7235                         (image->comps[0].dy != image->comps[1].dy) ||
7236                         (image->comps[0].dy != image->comps[2].dy)) {
7237                     opj_event_msg(p_manager, EVT_WARNING,
7238                                   "Cannot perform MCT on components with different sizes. Disabling MCT.\n");
7239                     tcp->mct = 0;
7240                 }
7241             }
7242             for (i = 0; i < image->numcomps; i++) {
7243                 opj_tccp_t *tccp = &tcp->tccps[i];
7244                 opj_image_comp_t * l_comp = &(image->comps[i]);
7245
7246                 if (! l_comp->sgnd) {
7247                     tccp->m_dc_level_shift = 1 << (l_comp->prec - 1);
7248                 }
7249             }
7250         }
7251
7252         for (i = 0; i < image->numcomps; i++) {
7253             opj_tccp_t *tccp = &tcp->tccps[i];
7254
7255             tccp->csty = parameters->csty &
7256                          0x01;   /* 0 => one precinct || 1 => custom precinct  */
7257             tccp->numresolutions = (OPJ_UINT32)parameters->numresolution;
7258             tccp->cblkw = (OPJ_UINT32)opj_int_floorlog2(parameters->cblockw_init);
7259             tccp->cblkh = (OPJ_UINT32)opj_int_floorlog2(parameters->cblockh_init);
7260             tccp->cblksty = (OPJ_UINT32)parameters->mode;
7261             tccp->qmfbid = parameters->irreversible ? 0 : 1;
7262             tccp->qntsty = parameters->irreversible ? J2K_CCP_QNTSTY_SEQNT :
7263                            J2K_CCP_QNTSTY_NOQNT;
7264             tccp->numgbits = 2;
7265
7266             if ((OPJ_INT32)i == parameters->roi_compno) {
7267                 tccp->roishift = parameters->roi_shift;
7268             } else {
7269                 tccp->roishift = 0;
7270             }
7271
7272             if (parameters->csty & J2K_CCP_CSTY_PRT) {
7273                 OPJ_INT32 p = 0, it_res;
7274                 assert(tccp->numresolutions > 0);
7275                 for (it_res = (OPJ_INT32)tccp->numresolutions - 1; it_res >= 0; it_res--) {
7276                     if (p < parameters->res_spec) {
7277
7278                         if (parameters->prcw_init[p] < 1) {
7279                             tccp->prcw[it_res] = 1;
7280                         } else {
7281                             tccp->prcw[it_res] = (OPJ_UINT32)opj_int_floorlog2(parameters->prcw_init[p]);
7282                         }
7283
7284                         if (parameters->prch_init[p] < 1) {
7285                             tccp->prch[it_res] = 1;
7286                         } else {
7287                             tccp->prch[it_res] = (OPJ_UINT32)opj_int_floorlog2(parameters->prch_init[p]);
7288                         }
7289
7290                     } else {
7291                         OPJ_INT32 res_spec = parameters->res_spec;
7292                         OPJ_INT32 size_prcw = 0;
7293                         OPJ_INT32 size_prch = 0;
7294
7295                         assert(res_spec > 0); /* issue 189 */
7296                         size_prcw = parameters->prcw_init[res_spec - 1] >> (p - (res_spec - 1));
7297                         size_prch = parameters->prch_init[res_spec - 1] >> (p - (res_spec - 1));
7298
7299
7300                         if (size_prcw < 1) {
7301                             tccp->prcw[it_res] = 1;
7302                         } else {
7303                             tccp->prcw[it_res] = (OPJ_UINT32)opj_int_floorlog2(size_prcw);
7304                         }
7305
7306                         if (size_prch < 1) {
7307                             tccp->prch[it_res] = 1;
7308                         } else {
7309                             tccp->prch[it_res] = (OPJ_UINT32)opj_int_floorlog2(size_prch);
7310                         }
7311                     }
7312                     p++;
7313                     /*printf("\nsize precinct for level %d : %d,%d\n", it_res,tccp->prcw[it_res], tccp->prch[it_res]); */
7314                 }       /*end for*/
7315             } else {
7316                 for (j = 0; j < tccp->numresolutions; j++) {
7317                     tccp->prcw[j] = 15;
7318                     tccp->prch[j] = 15;
7319                 }
7320             }
7321
7322             opj_dwt_calc_explicit_stepsizes(tccp, image->comps[i].prec);
7323         }
7324     }
7325
7326     if (parameters->mct_data) {
7327         opj_free(parameters->mct_data);
7328         parameters->mct_data = 00;
7329     }
7330     return OPJ_TRUE;
7331 }
7332
7333 static OPJ_BOOL opj_j2k_add_mhmarker(opj_codestream_index_t *cstr_index,
7334                                      OPJ_UINT32 type, OPJ_OFF_T pos, OPJ_UINT32 len)
7335 {
7336     assert(cstr_index != 00);
7337
7338     /* expand the list? */
7339     if ((cstr_index->marknum + 1) > cstr_index->maxmarknum) {
7340         opj_marker_info_t *new_marker;
7341         cstr_index->maxmarknum = (OPJ_UINT32)(100 + (OPJ_FLOAT32)
7342                                               cstr_index->maxmarknum);
7343         new_marker = (opj_marker_info_t *) opj_realloc(cstr_index->marker,
7344                      cstr_index->maxmarknum * sizeof(opj_marker_info_t));
7345         if (! new_marker) {
7346             opj_free(cstr_index->marker);
7347             cstr_index->marker = NULL;
7348             cstr_index->maxmarknum = 0;
7349             cstr_index->marknum = 0;
7350             /* opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to add mh marker\n"); */
7351             return OPJ_FALSE;
7352         }
7353         cstr_index->marker = new_marker;
7354     }
7355
7356     /* add the marker */
7357     cstr_index->marker[cstr_index->marknum].type = (OPJ_UINT16)type;
7358     cstr_index->marker[cstr_index->marknum].pos = (OPJ_INT32)pos;
7359     cstr_index->marker[cstr_index->marknum].len = (OPJ_INT32)len;
7360     cstr_index->marknum++;
7361     return OPJ_TRUE;
7362 }
7363
7364 static OPJ_BOOL opj_j2k_add_tlmarker(OPJ_UINT32 tileno,
7365                                      opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_OFF_T pos,
7366                                      OPJ_UINT32 len)
7367 {
7368     assert(cstr_index != 00);
7369     assert(cstr_index->tile_index != 00);
7370
7371     /* expand the list? */
7372     if ((cstr_index->tile_index[tileno].marknum + 1) >
7373             cstr_index->tile_index[tileno].maxmarknum) {
7374         opj_marker_info_t *new_marker;
7375         cstr_index->tile_index[tileno].maxmarknum = (OPJ_UINT32)(100 +
7376                 (OPJ_FLOAT32) cstr_index->tile_index[tileno].maxmarknum);
7377         new_marker = (opj_marker_info_t *) opj_realloc(
7378                          cstr_index->tile_index[tileno].marker,
7379                          cstr_index->tile_index[tileno].maxmarknum * sizeof(opj_marker_info_t));
7380         if (! new_marker) {
7381             opj_free(cstr_index->tile_index[tileno].marker);
7382             cstr_index->tile_index[tileno].marker = NULL;
7383             cstr_index->tile_index[tileno].maxmarknum = 0;
7384             cstr_index->tile_index[tileno].marknum = 0;
7385             /* opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to add tl marker\n"); */
7386             return OPJ_FALSE;
7387         }
7388         cstr_index->tile_index[tileno].marker = new_marker;
7389     }
7390
7391     /* add the marker */
7392     cstr_index->tile_index[tileno].marker[cstr_index->tile_index[tileno].marknum].type
7393         = (OPJ_UINT16)type;
7394     cstr_index->tile_index[tileno].marker[cstr_index->tile_index[tileno].marknum].pos
7395         = (OPJ_INT32)pos;
7396     cstr_index->tile_index[tileno].marker[cstr_index->tile_index[tileno].marknum].len
7397         = (OPJ_INT32)len;
7398     cstr_index->tile_index[tileno].marknum++;
7399
7400     if (type == J2K_MS_SOT) {
7401         OPJ_UINT32 l_current_tile_part = cstr_index->tile_index[tileno].current_tpsno;
7402
7403         if (cstr_index->tile_index[tileno].tp_index) {
7404             cstr_index->tile_index[tileno].tp_index[l_current_tile_part].start_pos = pos;
7405         }
7406
7407     }
7408     return OPJ_TRUE;
7409 }
7410
7411 /*
7412  * -----------------------------------------------------------------------
7413  * -----------------------------------------------------------------------
7414  * -----------------------------------------------------------------------
7415  */
7416
7417 OPJ_BOOL opj_j2k_end_decompress(opj_j2k_t *p_j2k,
7418                                 opj_stream_private_t *p_stream,
7419                                 opj_event_mgr_t * p_manager
7420                                )
7421 {
7422     (void)p_j2k;
7423     (void)p_stream;
7424     (void)p_manager;
7425     return OPJ_TRUE;
7426 }
7427
7428 OPJ_BOOL opj_j2k_read_header(opj_stream_private_t *p_stream,
7429                              opj_j2k_t* p_j2k,
7430                              opj_image_t** p_image,
7431                              opj_event_mgr_t* p_manager)
7432 {
7433     /* preconditions */
7434     assert(p_j2k != 00);
7435     assert(p_stream != 00);
7436     assert(p_manager != 00);
7437
7438     /* create an empty image header */
7439     p_j2k->m_private_image = opj_image_create0();
7440     if (! p_j2k->m_private_image) {
7441         return OPJ_FALSE;
7442     }
7443
7444     /* customization of the validation */
7445     if (! opj_j2k_setup_decoding_validation(p_j2k, p_manager)) {
7446         opj_image_destroy(p_j2k->m_private_image);
7447         p_j2k->m_private_image = NULL;
7448         return OPJ_FALSE;
7449     }
7450
7451     /* validation of the parameters codec */
7452     if (! opj_j2k_exec(p_j2k, p_j2k->m_validation_list, p_stream, p_manager)) {
7453         opj_image_destroy(p_j2k->m_private_image);
7454         p_j2k->m_private_image = NULL;
7455         return OPJ_FALSE;
7456     }
7457
7458     /* customization of the encoding */
7459     if (! opj_j2k_setup_header_reading(p_j2k, p_manager)) {
7460         opj_image_destroy(p_j2k->m_private_image);
7461         p_j2k->m_private_image = NULL;
7462         return OPJ_FALSE;
7463     }
7464
7465     /* read header */
7466     if (! opj_j2k_exec(p_j2k, p_j2k->m_procedure_list, p_stream, p_manager)) {
7467         opj_image_destroy(p_j2k->m_private_image);
7468         p_j2k->m_private_image = NULL;
7469         return OPJ_FALSE;
7470     }
7471
7472     *p_image = opj_image_create0();
7473     if (!(*p_image)) {
7474         return OPJ_FALSE;
7475     }
7476
7477     /* Copy codestream image information to the output image */
7478     opj_copy_image_header(p_j2k->m_private_image, *p_image);
7479
7480     /*Allocate and initialize some elements of codestrem index*/
7481     if (!opj_j2k_allocate_tile_element_cstr_index(p_j2k)) {
7482         return OPJ_FALSE;
7483     }
7484
7485     return OPJ_TRUE;
7486 }
7487
7488 static OPJ_BOOL opj_j2k_setup_header_reading(opj_j2k_t *p_j2k,
7489         opj_event_mgr_t * p_manager)
7490 {
7491     /* preconditions*/
7492     assert(p_j2k != 00);
7493     assert(p_manager != 00);
7494
7495     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
7496                                            (opj_procedure)opj_j2k_read_header_procedure, p_manager)) {
7497         return OPJ_FALSE;
7498     }
7499
7500     /* DEVELOPER CORNER, add your custom procedures */
7501     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
7502                                            (opj_procedure)opj_j2k_copy_default_tcp_and_create_tcd, p_manager))  {
7503         return OPJ_FALSE;
7504     }
7505
7506     return OPJ_TRUE;
7507 }
7508
7509 static OPJ_BOOL opj_j2k_setup_decoding_validation(opj_j2k_t *p_j2k,
7510         opj_event_mgr_t * p_manager)
7511 {
7512     /* preconditions*/
7513     assert(p_j2k != 00);
7514     assert(p_manager != 00);
7515
7516     if (! opj_procedure_list_add_procedure(p_j2k->m_validation_list,
7517                                            (opj_procedure)opj_j2k_build_decoder, p_manager)) {
7518         return OPJ_FALSE;
7519     }
7520     if (! opj_procedure_list_add_procedure(p_j2k->m_validation_list,
7521                                            (opj_procedure)opj_j2k_decoding_validation, p_manager)) {
7522         return OPJ_FALSE;
7523     }
7524
7525     /* DEVELOPER CORNER, add your custom validation procedure */
7526     return OPJ_TRUE;
7527 }
7528
7529 static OPJ_BOOL opj_j2k_mct_validation(opj_j2k_t * p_j2k,
7530                                        opj_stream_private_t *p_stream,
7531                                        opj_event_mgr_t * p_manager)
7532 {
7533     OPJ_BOOL l_is_valid = OPJ_TRUE;
7534     OPJ_UINT32 i, j;
7535
7536     /* preconditions */
7537     assert(p_j2k != 00);
7538     assert(p_stream != 00);
7539     assert(p_manager != 00);
7540
7541     OPJ_UNUSED(p_stream);
7542     OPJ_UNUSED(p_manager);
7543
7544     if ((p_j2k->m_cp.rsiz & 0x8200) == 0x8200) {
7545         OPJ_UINT32 l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
7546         opj_tcp_t * l_tcp = p_j2k->m_cp.tcps;
7547
7548         for (i = 0; i < l_nb_tiles; ++i) {
7549             if (l_tcp->mct == 2) {
7550                 opj_tccp_t * l_tccp = l_tcp->tccps;
7551                 l_is_valid &= (l_tcp->m_mct_coding_matrix != 00);
7552
7553                 for (j = 0; j < p_j2k->m_private_image->numcomps; ++j) {
7554                     l_is_valid &= !(l_tccp->qmfbid & 1);
7555                     ++l_tccp;
7556                 }
7557             }
7558             ++l_tcp;
7559         }
7560     }
7561
7562     return l_is_valid;
7563 }
7564
7565 OPJ_BOOL opj_j2k_setup_mct_encoding(opj_tcp_t * p_tcp, opj_image_t * p_image)
7566 {
7567     OPJ_UINT32 i;
7568     OPJ_UINT32 l_indix = 1;
7569     opj_mct_data_t * l_mct_deco_data = 00, * l_mct_offset_data = 00;
7570     opj_simple_mcc_decorrelation_data_t * l_mcc_data;
7571     OPJ_UINT32 l_mct_size, l_nb_elem;
7572     OPJ_FLOAT32 * l_data, * l_current_data;
7573     opj_tccp_t * l_tccp;
7574
7575     /* preconditions */
7576     assert(p_tcp != 00);
7577
7578     if (p_tcp->mct != 2) {
7579         return OPJ_TRUE;
7580     }
7581
7582     if (p_tcp->m_mct_decoding_matrix) {
7583         if (p_tcp->m_nb_mct_records == p_tcp->m_nb_max_mct_records) {
7584             opj_mct_data_t *new_mct_records;
7585             p_tcp->m_nb_max_mct_records += OPJ_J2K_MCT_DEFAULT_NB_RECORDS;
7586
7587             new_mct_records = (opj_mct_data_t *) opj_realloc(p_tcp->m_mct_records,
7588                               p_tcp->m_nb_max_mct_records * sizeof(opj_mct_data_t));
7589             if (! new_mct_records) {
7590                 opj_free(p_tcp->m_mct_records);
7591                 p_tcp->m_mct_records = NULL;
7592                 p_tcp->m_nb_max_mct_records = 0;
7593                 p_tcp->m_nb_mct_records = 0;
7594                 /* opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to setup mct encoding\n"); */
7595                 return OPJ_FALSE;
7596             }
7597             p_tcp->m_mct_records = new_mct_records;
7598             l_mct_deco_data = p_tcp->m_mct_records + p_tcp->m_nb_mct_records;
7599
7600             memset(l_mct_deco_data, 0,
7601                    (p_tcp->m_nb_max_mct_records - p_tcp->m_nb_mct_records) * sizeof(
7602                        opj_mct_data_t));
7603         }
7604         l_mct_deco_data = p_tcp->m_mct_records + p_tcp->m_nb_mct_records;
7605
7606         if (l_mct_deco_data->m_data) {
7607             opj_free(l_mct_deco_data->m_data);
7608             l_mct_deco_data->m_data = 00;
7609         }
7610
7611         l_mct_deco_data->m_index = l_indix++;
7612         l_mct_deco_data->m_array_type = MCT_TYPE_DECORRELATION;
7613         l_mct_deco_data->m_element_type = MCT_TYPE_FLOAT;
7614         l_nb_elem = p_image->numcomps * p_image->numcomps;
7615         l_mct_size = l_nb_elem * MCT_ELEMENT_SIZE[l_mct_deco_data->m_element_type];
7616         l_mct_deco_data->m_data = (OPJ_BYTE*)opj_malloc(l_mct_size);
7617
7618         if (! l_mct_deco_data->m_data) {
7619             return OPJ_FALSE;
7620         }
7621
7622         j2k_mct_write_functions_from_float[l_mct_deco_data->m_element_type](
7623             p_tcp->m_mct_decoding_matrix, l_mct_deco_data->m_data, l_nb_elem);
7624
7625         l_mct_deco_data->m_data_size = l_mct_size;
7626         ++p_tcp->m_nb_mct_records;
7627     }
7628
7629     if (p_tcp->m_nb_mct_records == p_tcp->m_nb_max_mct_records) {
7630         opj_mct_data_t *new_mct_records;
7631         p_tcp->m_nb_max_mct_records += OPJ_J2K_MCT_DEFAULT_NB_RECORDS;
7632         new_mct_records = (opj_mct_data_t *) opj_realloc(p_tcp->m_mct_records,
7633                           p_tcp->m_nb_max_mct_records * sizeof(opj_mct_data_t));
7634         if (! new_mct_records) {
7635             opj_free(p_tcp->m_mct_records);
7636             p_tcp->m_mct_records = NULL;
7637             p_tcp->m_nb_max_mct_records = 0;
7638             p_tcp->m_nb_mct_records = 0;
7639             /* opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to setup mct encoding\n"); */
7640             return OPJ_FALSE;
7641         }
7642         p_tcp->m_mct_records = new_mct_records;
7643         l_mct_offset_data = p_tcp->m_mct_records + p_tcp->m_nb_mct_records;
7644
7645         memset(l_mct_offset_data, 0,
7646                (p_tcp->m_nb_max_mct_records - p_tcp->m_nb_mct_records) * sizeof(
7647                    opj_mct_data_t));
7648
7649         if (l_mct_deco_data) {
7650             l_mct_deco_data = l_mct_offset_data - 1;
7651         }
7652     }
7653
7654     l_mct_offset_data = p_tcp->m_mct_records + p_tcp->m_nb_mct_records;
7655
7656     if (l_mct_offset_data->m_data) {
7657         opj_free(l_mct_offset_data->m_data);
7658         l_mct_offset_data->m_data = 00;
7659     }
7660
7661     l_mct_offset_data->m_index = l_indix++;
7662     l_mct_offset_data->m_array_type = MCT_TYPE_OFFSET;
7663     l_mct_offset_data->m_element_type = MCT_TYPE_FLOAT;
7664     l_nb_elem = p_image->numcomps;
7665     l_mct_size = l_nb_elem * MCT_ELEMENT_SIZE[l_mct_offset_data->m_element_type];
7666     l_mct_offset_data->m_data = (OPJ_BYTE*)opj_malloc(l_mct_size);
7667
7668     if (! l_mct_offset_data->m_data) {
7669         return OPJ_FALSE;
7670     }
7671
7672     l_data = (OPJ_FLOAT32*)opj_malloc(l_nb_elem * sizeof(OPJ_FLOAT32));
7673     if (! l_data) {
7674         opj_free(l_mct_offset_data->m_data);
7675         l_mct_offset_data->m_data = 00;
7676         return OPJ_FALSE;
7677     }
7678
7679     l_tccp = p_tcp->tccps;
7680     l_current_data = l_data;
7681
7682     for (i = 0; i < l_nb_elem; ++i) {
7683         *(l_current_data++) = (OPJ_FLOAT32)(l_tccp->m_dc_level_shift);
7684         ++l_tccp;
7685     }
7686
7687     j2k_mct_write_functions_from_float[l_mct_offset_data->m_element_type](l_data,
7688             l_mct_offset_data->m_data, l_nb_elem);
7689
7690     opj_free(l_data);
7691
7692     l_mct_offset_data->m_data_size = l_mct_size;
7693
7694     ++p_tcp->m_nb_mct_records;
7695
7696     if (p_tcp->m_nb_mcc_records == p_tcp->m_nb_max_mcc_records) {
7697         opj_simple_mcc_decorrelation_data_t *new_mcc_records;
7698         p_tcp->m_nb_max_mcc_records += OPJ_J2K_MCT_DEFAULT_NB_RECORDS;
7699         new_mcc_records = (opj_simple_mcc_decorrelation_data_t *) opj_realloc(
7700                               p_tcp->m_mcc_records, p_tcp->m_nb_max_mcc_records * sizeof(
7701                                   opj_simple_mcc_decorrelation_data_t));
7702         if (! new_mcc_records) {
7703             opj_free(p_tcp->m_mcc_records);
7704             p_tcp->m_mcc_records = NULL;
7705             p_tcp->m_nb_max_mcc_records = 0;
7706             p_tcp->m_nb_mcc_records = 0;
7707             /* opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to setup mct encoding\n"); */
7708             return OPJ_FALSE;
7709         }
7710         p_tcp->m_mcc_records = new_mcc_records;
7711         l_mcc_data = p_tcp->m_mcc_records + p_tcp->m_nb_mcc_records;
7712         memset(l_mcc_data, 0, (p_tcp->m_nb_max_mcc_records - p_tcp->m_nb_mcc_records) *
7713                sizeof(opj_simple_mcc_decorrelation_data_t));
7714
7715     }
7716
7717     l_mcc_data = p_tcp->m_mcc_records + p_tcp->m_nb_mcc_records;
7718     l_mcc_data->m_decorrelation_array = l_mct_deco_data;
7719     l_mcc_data->m_is_irreversible = 1;
7720     l_mcc_data->m_nb_comps = p_image->numcomps;
7721     l_mcc_data->m_index = l_indix++;
7722     l_mcc_data->m_offset_array = l_mct_offset_data;
7723     ++p_tcp->m_nb_mcc_records;
7724
7725     return OPJ_TRUE;
7726 }
7727
7728 static OPJ_BOOL opj_j2k_build_decoder(opj_j2k_t * p_j2k,
7729                                       opj_stream_private_t *p_stream,
7730                                       opj_event_mgr_t * p_manager)
7731 {
7732     /* add here initialization of cp
7733        copy paste of setup_decoder */
7734     (void)p_j2k;
7735     (void)p_stream;
7736     (void)p_manager;
7737     return OPJ_TRUE;
7738 }
7739
7740 static OPJ_BOOL opj_j2k_build_encoder(opj_j2k_t * p_j2k,
7741                                       opj_stream_private_t *p_stream,
7742                                       opj_event_mgr_t * p_manager)
7743 {
7744     /* add here initialization of cp
7745        copy paste of setup_encoder */
7746     (void)p_j2k;
7747     (void)p_stream;
7748     (void)p_manager;
7749     return OPJ_TRUE;
7750 }
7751
7752 static OPJ_BOOL opj_j2k_encoding_validation(opj_j2k_t * p_j2k,
7753         opj_stream_private_t *p_stream,
7754         opj_event_mgr_t * p_manager)
7755 {
7756     OPJ_BOOL l_is_valid = OPJ_TRUE;
7757
7758     /* preconditions */
7759     assert(p_j2k != 00);
7760     assert(p_stream != 00);
7761     assert(p_manager != 00);
7762
7763     OPJ_UNUSED(p_stream);
7764
7765     /* STATE checking */
7766     /* make sure the state is at 0 */
7767     l_is_valid &= (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_NONE);
7768
7769     /* POINTER validation */
7770     /* make sure a p_j2k codec is present */
7771     l_is_valid &= (p_j2k->m_procedure_list != 00);
7772     /* make sure a validation list is present */
7773     l_is_valid &= (p_j2k->m_validation_list != 00);
7774
7775     /* ISO 15444-1:2004 states between 1 & 33 (0 -> 32) */
7776     /* 33 (32) would always fail the check below (if a cast to 64bits was done) */
7777     /* FIXME Shall we change OPJ_J2K_MAXRLVLS to 32 ? */
7778     if ((p_j2k->m_cp.tcps->tccps->numresolutions <= 0) ||
7779             (p_j2k->m_cp.tcps->tccps->numresolutions > 32)) {
7780         opj_event_msg(p_manager, EVT_ERROR,
7781                       "Number of resolutions is too high in comparison to the size of tiles\n");
7782         return OPJ_FALSE;
7783     }
7784
7785     if ((p_j2k->m_cp.tdx) < (OPJ_UINT32)(1 <<
7786                                          (p_j2k->m_cp.tcps->tccps->numresolutions - 1U))) {
7787         opj_event_msg(p_manager, EVT_ERROR,
7788                       "Number of resolutions is too high in comparison to the size of tiles\n");
7789         return OPJ_FALSE;
7790     }
7791
7792     if ((p_j2k->m_cp.tdy) < (OPJ_UINT32)(1 <<
7793                                          (p_j2k->m_cp.tcps->tccps->numresolutions - 1U))) {
7794         opj_event_msg(p_manager, EVT_ERROR,
7795                       "Number of resolutions is too high in comparison to the size of tiles\n");
7796         return OPJ_FALSE;
7797     }
7798
7799     /* PARAMETER VALIDATION */
7800     return l_is_valid;
7801 }
7802
7803 static OPJ_BOOL opj_j2k_decoding_validation(opj_j2k_t *p_j2k,
7804         opj_stream_private_t *p_stream,
7805         opj_event_mgr_t * p_manager
7806                                            )
7807 {
7808     OPJ_BOOL l_is_valid = OPJ_TRUE;
7809
7810     /* preconditions*/
7811     assert(p_j2k != 00);
7812     assert(p_stream != 00);
7813     assert(p_manager != 00);
7814
7815     OPJ_UNUSED(p_stream);
7816     OPJ_UNUSED(p_manager);
7817
7818     /* STATE checking */
7819     /* make sure the state is at 0 */
7820 #ifdef TODO_MSD
7821     l_is_valid &= (p_j2k->m_specific_param.m_decoder.m_state == J2K_DEC_STATE_NONE);
7822 #endif
7823     l_is_valid &= (p_j2k->m_specific_param.m_decoder.m_state == 0x0000);
7824
7825     /* POINTER validation */
7826     /* make sure a p_j2k codec is present */
7827     /* make sure a procedure list is present */
7828     l_is_valid &= (p_j2k->m_procedure_list != 00);
7829     /* make sure a validation list is present */
7830     l_is_valid &= (p_j2k->m_validation_list != 00);
7831
7832     /* PARAMETER VALIDATION */
7833     return l_is_valid;
7834 }
7835
7836 static OPJ_BOOL opj_j2k_read_header_procedure(opj_j2k_t *p_j2k,
7837         opj_stream_private_t *p_stream,
7838         opj_event_mgr_t * p_manager)
7839 {
7840     OPJ_UINT32 l_current_marker;
7841     OPJ_UINT32 l_marker_size;
7842     const opj_dec_memory_marker_handler_t * l_marker_handler = 00;
7843     OPJ_BOOL l_has_siz = 0;
7844     OPJ_BOOL l_has_cod = 0;
7845     OPJ_BOOL l_has_qcd = 0;
7846
7847     /* preconditions */
7848     assert(p_stream != 00);
7849     assert(p_j2k != 00);
7850     assert(p_manager != 00);
7851
7852     /*  We enter in the main header */
7853     p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_MHSOC;
7854
7855     /* Try to read the SOC marker, the codestream must begin with SOC marker */
7856     if (! opj_j2k_read_soc(p_j2k, p_stream, p_manager)) {
7857         opj_event_msg(p_manager, EVT_ERROR, "Expected a SOC marker \n");
7858         return OPJ_FALSE;
7859     }
7860
7861     /* Try to read 2 bytes (the next marker ID) from stream and copy them into the buffer */
7862     if (opj_stream_read_data(p_stream,
7863                              p_j2k->m_specific_param.m_decoder.m_header_data, 2, p_manager) != 2) {
7864         opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
7865         return OPJ_FALSE;
7866     }
7867
7868     /* Read 2 bytes as the new marker ID */
7869     opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,
7870                    &l_current_marker, 2);
7871
7872     /* Try to read until the SOT is detected */
7873     while (l_current_marker != J2K_MS_SOT) {
7874
7875         /* Check if the current marker ID is valid */
7876         if (l_current_marker < 0xff00) {
7877             opj_event_msg(p_manager, EVT_ERROR,
7878                           "A marker ID was expected (0xff--) instead of %.8x\n", l_current_marker);
7879             return OPJ_FALSE;
7880         }
7881
7882         /* Get the marker handler from the marker ID */
7883         l_marker_handler = opj_j2k_get_marker_handler(l_current_marker);
7884
7885         /* Manage case where marker is unknown */
7886         if (l_marker_handler->id == J2K_MS_UNK) {
7887             if (! opj_j2k_read_unk(p_j2k, p_stream, &l_current_marker, p_manager)) {
7888                 opj_event_msg(p_manager, EVT_ERROR,
7889                               "Unknow marker have been detected and generated error.\n");
7890                 return OPJ_FALSE;
7891             }
7892
7893             if (l_current_marker == J2K_MS_SOT) {
7894                 break;    /* SOT marker is detected main header is completely read */
7895             } else { /* Get the marker handler from the marker ID */
7896                 l_marker_handler = opj_j2k_get_marker_handler(l_current_marker);
7897             }
7898         }
7899
7900         if (l_marker_handler->id == J2K_MS_SIZ) {
7901             /* Mark required SIZ marker as found */
7902             l_has_siz = 1;
7903         }
7904         if (l_marker_handler->id == J2K_MS_COD) {
7905             /* Mark required COD marker as found */
7906             l_has_cod = 1;
7907         }
7908         if (l_marker_handler->id == J2K_MS_QCD) {
7909             /* Mark required QCD marker as found */
7910             l_has_qcd = 1;
7911         }
7912
7913         /* Check if the marker is known and if it is the right place to find it */
7914         if (!(p_j2k->m_specific_param.m_decoder.m_state & l_marker_handler->states)) {
7915             opj_event_msg(p_manager, EVT_ERROR,
7916                           "Marker is not compliant with its position\n");
7917             return OPJ_FALSE;
7918         }
7919
7920         /* Try to read 2 bytes (the marker size) from stream and copy them into the buffer */
7921         if (opj_stream_read_data(p_stream,
7922                                  p_j2k->m_specific_param.m_decoder.m_header_data, 2, p_manager) != 2) {
7923             opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
7924             return OPJ_FALSE;
7925         }
7926
7927         /* read 2 bytes as the marker size */
7928         opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data, &l_marker_size,
7929                        2);
7930         if (l_marker_size < 2) {
7931             opj_event_msg(p_manager, EVT_ERROR, "Invalid marker size\n");
7932             return OPJ_FALSE;
7933         }
7934         l_marker_size -= 2; /* Subtract the size of the marker ID already read */
7935
7936         /* Check if the marker size is compatible with the header data size */
7937         if (l_marker_size > p_j2k->m_specific_param.m_decoder.m_header_data_size) {
7938             OPJ_BYTE *new_header_data = (OPJ_BYTE *) opj_realloc(
7939                                             p_j2k->m_specific_param.m_decoder.m_header_data, l_marker_size);
7940             if (! new_header_data) {
7941                 opj_free(p_j2k->m_specific_param.m_decoder.m_header_data);
7942                 p_j2k->m_specific_param.m_decoder.m_header_data = NULL;
7943                 p_j2k->m_specific_param.m_decoder.m_header_data_size = 0;
7944                 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read header\n");
7945                 return OPJ_FALSE;
7946             }
7947             p_j2k->m_specific_param.m_decoder.m_header_data = new_header_data;
7948             p_j2k->m_specific_param.m_decoder.m_header_data_size = l_marker_size;
7949         }
7950
7951         /* Try to read the rest of the marker segment from stream and copy them into the buffer */
7952         if (opj_stream_read_data(p_stream,
7953                                  p_j2k->m_specific_param.m_decoder.m_header_data, l_marker_size,
7954                                  p_manager) != l_marker_size) {
7955             opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
7956             return OPJ_FALSE;
7957         }
7958
7959         /* Read the marker segment with the correct marker handler */
7960         if (!(*(l_marker_handler->handler))(p_j2k,
7961                                             p_j2k->m_specific_param.m_decoder.m_header_data, l_marker_size, p_manager)) {
7962             opj_event_msg(p_manager, EVT_ERROR,
7963                           "Marker handler function failed to read the marker segment\n");
7964             return OPJ_FALSE;
7965         }
7966
7967         /* Add the marker to the codestream index*/
7968         if (OPJ_FALSE == opj_j2k_add_mhmarker(
7969                     p_j2k->cstr_index,
7970                     l_marker_handler->id,
7971                     (OPJ_UINT32) opj_stream_tell(p_stream) - l_marker_size - 4,
7972                     l_marker_size + 4)) {
7973             opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to add mh marker\n");
7974             return OPJ_FALSE;
7975         }
7976
7977         /* Try to read 2 bytes (the next marker ID) from stream and copy them into the buffer */
7978         if (opj_stream_read_data(p_stream,
7979                                  p_j2k->m_specific_param.m_decoder.m_header_data, 2, p_manager) != 2) {
7980             opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
7981             return OPJ_FALSE;
7982         }
7983
7984         /* read 2 bytes as the new marker ID */
7985         opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,
7986                        &l_current_marker, 2);
7987     }
7988
7989     if (l_has_siz == 0) {
7990         opj_event_msg(p_manager, EVT_ERROR,
7991                       "required SIZ marker not found in main header\n");
7992         return OPJ_FALSE;
7993     }
7994     if (l_has_cod == 0) {
7995         opj_event_msg(p_manager, EVT_ERROR,
7996                       "required COD marker not found in main header\n");
7997         return OPJ_FALSE;
7998     }
7999     if (l_has_qcd == 0) {
8000         opj_event_msg(p_manager, EVT_ERROR,
8001                       "required QCD marker not found in main header\n");
8002         return OPJ_FALSE;
8003     }
8004
8005     if (! opj_j2k_merge_ppm(&(p_j2k->m_cp), p_manager)) {
8006         opj_event_msg(p_manager, EVT_ERROR, "Failed to merge PPM data\n");
8007         return OPJ_FALSE;
8008     }
8009
8010     opj_event_msg(p_manager, EVT_INFO, "Main header has been correctly decoded.\n");
8011
8012     /* Position of the last element if the main header */
8013     p_j2k->cstr_index->main_head_end = (OPJ_UINT32) opj_stream_tell(p_stream) - 2;
8014
8015     /* Next step: read a tile-part header */
8016     p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_TPHSOT;
8017
8018     return OPJ_TRUE;
8019 }
8020
8021 static OPJ_BOOL opj_j2k_exec(opj_j2k_t * p_j2k,
8022                              opj_procedure_list_t * p_procedure_list,
8023                              opj_stream_private_t *p_stream,
8024                              opj_event_mgr_t * p_manager)
8025 {
8026     OPJ_BOOL(** l_procedure)(opj_j2k_t *, opj_stream_private_t *,
8027                              opj_event_mgr_t *) = 00;
8028     OPJ_BOOL l_result = OPJ_TRUE;
8029     OPJ_UINT32 l_nb_proc, i;
8030
8031     /* preconditions*/
8032     assert(p_procedure_list != 00);
8033     assert(p_j2k != 00);
8034     assert(p_stream != 00);
8035     assert(p_manager != 00);
8036
8037     l_nb_proc = opj_procedure_list_get_nb_procedures(p_procedure_list);
8038     l_procedure = (OPJ_BOOL(**)(opj_j2k_t *, opj_stream_private_t *,
8039                                 opj_event_mgr_t *)) opj_procedure_list_get_first_procedure(p_procedure_list);
8040
8041     for (i = 0; i < l_nb_proc; ++i) {
8042         l_result = l_result && ((*l_procedure)(p_j2k, p_stream, p_manager));
8043         ++l_procedure;
8044     }
8045
8046     /* and clear the procedure list at the end.*/
8047     opj_procedure_list_clear(p_procedure_list);
8048     return l_result;
8049 }
8050
8051 /* FIXME DOC*/
8052 static OPJ_BOOL opj_j2k_copy_default_tcp_and_create_tcd(opj_j2k_t * p_j2k,
8053         opj_stream_private_t *p_stream,
8054         opj_event_mgr_t * p_manager
8055                                                        )
8056 {
8057     opj_tcp_t * l_tcp = 00;
8058     opj_tcp_t * l_default_tcp = 00;
8059     OPJ_UINT32 l_nb_tiles;
8060     OPJ_UINT32 i, j;
8061     opj_tccp_t *l_current_tccp = 00;
8062     OPJ_UINT32 l_tccp_size;
8063     OPJ_UINT32 l_mct_size;
8064     opj_image_t * l_image;
8065     OPJ_UINT32 l_mcc_records_size, l_mct_records_size;
8066     opj_mct_data_t * l_src_mct_rec, *l_dest_mct_rec;
8067     opj_simple_mcc_decorrelation_data_t * l_src_mcc_rec, *l_dest_mcc_rec;
8068     OPJ_UINT32 l_offset;
8069
8070     /* preconditions */
8071     assert(p_j2k != 00);
8072     assert(p_stream != 00);
8073     assert(p_manager != 00);
8074
8075     OPJ_UNUSED(p_stream);
8076
8077     l_image = p_j2k->m_private_image;
8078     l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
8079     l_tcp = p_j2k->m_cp.tcps;
8080     l_tccp_size = l_image->numcomps * (OPJ_UINT32)sizeof(opj_tccp_t);
8081     l_default_tcp = p_j2k->m_specific_param.m_decoder.m_default_tcp;
8082     l_mct_size = l_image->numcomps * l_image->numcomps * (OPJ_UINT32)sizeof(
8083                      OPJ_FLOAT32);
8084
8085     /* For each tile */
8086     for (i = 0; i < l_nb_tiles; ++i) {
8087         /* keep the tile-compo coding parameters pointer of the current tile coding parameters*/
8088         l_current_tccp = l_tcp->tccps;
8089         /*Copy default coding parameters into the current tile coding parameters*/
8090         memcpy(l_tcp, l_default_tcp, sizeof(opj_tcp_t));
8091         /* Initialize some values of the current tile coding parameters*/
8092         l_tcp->cod = 0;
8093         l_tcp->ppt = 0;
8094         l_tcp->ppt_data = 00;
8095         l_tcp->m_current_tile_part_number = -1;
8096         /* Remove memory not owned by this tile in case of early error return. */
8097         l_tcp->m_mct_decoding_matrix = 00;
8098         l_tcp->m_nb_max_mct_records = 0;
8099         l_tcp->m_mct_records = 00;
8100         l_tcp->m_nb_max_mcc_records = 0;
8101         l_tcp->m_mcc_records = 00;
8102         /* Reconnect the tile-compo coding parameters pointer to the current tile coding parameters*/
8103         l_tcp->tccps = l_current_tccp;
8104
8105         /* Get the mct_decoding_matrix of the dflt_tile_cp and copy them into the current tile cp*/
8106         if (l_default_tcp->m_mct_decoding_matrix) {
8107             l_tcp->m_mct_decoding_matrix = (OPJ_FLOAT32*)opj_malloc(l_mct_size);
8108             if (! l_tcp->m_mct_decoding_matrix) {
8109                 return OPJ_FALSE;
8110             }
8111             memcpy(l_tcp->m_mct_decoding_matrix, l_default_tcp->m_mct_decoding_matrix,
8112                    l_mct_size);
8113         }
8114
8115         /* Get the mct_record of the dflt_tile_cp and copy them into the current tile cp*/
8116         l_mct_records_size = l_default_tcp->m_nb_max_mct_records * (OPJ_UINT32)sizeof(
8117                                  opj_mct_data_t);
8118         l_tcp->m_mct_records = (opj_mct_data_t*)opj_malloc(l_mct_records_size);
8119         if (! l_tcp->m_mct_records) {
8120             return OPJ_FALSE;
8121         }
8122         memcpy(l_tcp->m_mct_records, l_default_tcp->m_mct_records, l_mct_records_size);
8123
8124         /* Copy the mct record data from dflt_tile_cp to the current tile*/
8125         l_src_mct_rec = l_default_tcp->m_mct_records;
8126         l_dest_mct_rec = l_tcp->m_mct_records;
8127
8128         for (j = 0; j < l_default_tcp->m_nb_mct_records; ++j) {
8129
8130             if (l_src_mct_rec->m_data) {
8131
8132                 l_dest_mct_rec->m_data = (OPJ_BYTE*) opj_malloc(l_src_mct_rec->m_data_size);
8133                 if (! l_dest_mct_rec->m_data) {
8134                     return OPJ_FALSE;
8135                 }
8136                 memcpy(l_dest_mct_rec->m_data, l_src_mct_rec->m_data,
8137                        l_src_mct_rec->m_data_size);
8138             }
8139
8140             ++l_src_mct_rec;
8141             ++l_dest_mct_rec;
8142             /* Update with each pass to free exactly what has been allocated on early return. */
8143             l_tcp->m_nb_max_mct_records += 1;
8144         }
8145
8146         /* Get the mcc_record of the dflt_tile_cp and copy them into the current tile cp*/
8147         l_mcc_records_size = l_default_tcp->m_nb_max_mcc_records * (OPJ_UINT32)sizeof(
8148                                  opj_simple_mcc_decorrelation_data_t);
8149         l_tcp->m_mcc_records = (opj_simple_mcc_decorrelation_data_t*) opj_malloc(
8150                                    l_mcc_records_size);
8151         if (! l_tcp->m_mcc_records) {
8152             return OPJ_FALSE;
8153         }
8154         memcpy(l_tcp->m_mcc_records, l_default_tcp->m_mcc_records, l_mcc_records_size);
8155         l_tcp->m_nb_max_mcc_records = l_default_tcp->m_nb_max_mcc_records;
8156
8157         /* Copy the mcc record data from dflt_tile_cp to the current tile*/
8158         l_src_mcc_rec = l_default_tcp->m_mcc_records;
8159         l_dest_mcc_rec = l_tcp->m_mcc_records;
8160
8161         for (j = 0; j < l_default_tcp->m_nb_max_mcc_records; ++j) {
8162
8163             if (l_src_mcc_rec->m_decorrelation_array) {
8164                 l_offset = (OPJ_UINT32)(l_src_mcc_rec->m_decorrelation_array -
8165                                         l_default_tcp->m_mct_records);
8166                 l_dest_mcc_rec->m_decorrelation_array = l_tcp->m_mct_records + l_offset;
8167             }
8168
8169             if (l_src_mcc_rec->m_offset_array) {
8170                 l_offset = (OPJ_UINT32)(l_src_mcc_rec->m_offset_array -
8171                                         l_default_tcp->m_mct_records);
8172                 l_dest_mcc_rec->m_offset_array = l_tcp->m_mct_records + l_offset;
8173             }
8174
8175             ++l_src_mcc_rec;
8176             ++l_dest_mcc_rec;
8177         }
8178
8179         /* Copy all the dflt_tile_compo_cp to the current tile cp */
8180         memcpy(l_current_tccp, l_default_tcp->tccps, l_tccp_size);
8181
8182         /* Move to next tile cp*/
8183         ++l_tcp;
8184     }
8185
8186     /* Create the current tile decoder*/
8187     p_j2k->m_tcd = opj_tcd_create(OPJ_TRUE);
8188     if (! p_j2k->m_tcd) {
8189         return OPJ_FALSE;
8190     }
8191
8192     if (!opj_tcd_init(p_j2k->m_tcd, l_image, &(p_j2k->m_cp), p_j2k->m_tp)) {
8193         opj_tcd_destroy(p_j2k->m_tcd);
8194         p_j2k->m_tcd = 00;
8195         opj_event_msg(p_manager, EVT_ERROR, "Cannot decode tile, memory error\n");
8196         return OPJ_FALSE;
8197     }
8198
8199     return OPJ_TRUE;
8200 }
8201
8202 static const opj_dec_memory_marker_handler_t * opj_j2k_get_marker_handler(
8203     OPJ_UINT32 p_id)
8204 {
8205     const opj_dec_memory_marker_handler_t *e;
8206     for (e = j2k_memory_marker_handler_tab; e->id != 0; ++e) {
8207         if (e->id == p_id) {
8208             break; /* we find a handler corresponding to the marker ID*/
8209         }
8210     }
8211     return e;
8212 }
8213
8214 void opj_j2k_destroy(opj_j2k_t *p_j2k)
8215 {
8216     if (p_j2k == 00) {
8217         return;
8218     }
8219
8220     if (p_j2k->m_is_decoder) {
8221
8222         if (p_j2k->m_specific_param.m_decoder.m_default_tcp != 00) {
8223             opj_j2k_tcp_destroy(p_j2k->m_specific_param.m_decoder.m_default_tcp);
8224             opj_free(p_j2k->m_specific_param.m_decoder.m_default_tcp);
8225             p_j2k->m_specific_param.m_decoder.m_default_tcp = 00;
8226         }
8227
8228         if (p_j2k->m_specific_param.m_decoder.m_header_data != 00) {
8229             opj_free(p_j2k->m_specific_param.m_decoder.m_header_data);
8230             p_j2k->m_specific_param.m_decoder.m_header_data = 00;
8231             p_j2k->m_specific_param.m_decoder.m_header_data_size = 0;
8232         }
8233     } else {
8234
8235         if (p_j2k->m_specific_param.m_encoder.m_encoded_tile_data) {
8236             opj_free(p_j2k->m_specific_param.m_encoder.m_encoded_tile_data);
8237             p_j2k->m_specific_param.m_encoder.m_encoded_tile_data = 00;
8238         }
8239
8240         if (p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer) {
8241             opj_free(p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer);
8242             p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer = 00;
8243             p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current = 00;
8244         }
8245
8246         if (p_j2k->m_specific_param.m_encoder.m_header_tile_data) {
8247             opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
8248             p_j2k->m_specific_param.m_encoder.m_header_tile_data = 00;
8249             p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
8250         }
8251     }
8252
8253     opj_tcd_destroy(p_j2k->m_tcd);
8254
8255     opj_j2k_cp_destroy(&(p_j2k->m_cp));
8256     memset(&(p_j2k->m_cp), 0, sizeof(opj_cp_t));
8257
8258     opj_procedure_list_destroy(p_j2k->m_procedure_list);
8259     p_j2k->m_procedure_list = 00;
8260
8261     opj_procedure_list_destroy(p_j2k->m_validation_list);
8262     p_j2k->m_procedure_list = 00;
8263
8264     j2k_destroy_cstr_index(p_j2k->cstr_index);
8265     p_j2k->cstr_index = NULL;
8266
8267     opj_image_destroy(p_j2k->m_private_image);
8268     p_j2k->m_private_image = NULL;
8269
8270     opj_image_destroy(p_j2k->m_output_image);
8271     p_j2k->m_output_image = NULL;
8272
8273     opj_thread_pool_destroy(p_j2k->m_tp);
8274     p_j2k->m_tp = NULL;
8275
8276     opj_free(p_j2k);
8277 }
8278
8279 void j2k_destroy_cstr_index(opj_codestream_index_t *p_cstr_ind)
8280 {
8281     if (p_cstr_ind) {
8282
8283         if (p_cstr_ind->marker) {
8284             opj_free(p_cstr_ind->marker);
8285             p_cstr_ind->marker = NULL;
8286         }
8287
8288         if (p_cstr_ind->tile_index) {
8289             OPJ_UINT32 it_tile = 0;
8290
8291             for (it_tile = 0; it_tile < p_cstr_ind->nb_of_tiles; it_tile++) {
8292
8293                 if (p_cstr_ind->tile_index[it_tile].packet_index) {
8294                     opj_free(p_cstr_ind->tile_index[it_tile].packet_index);
8295                     p_cstr_ind->tile_index[it_tile].packet_index = NULL;
8296                 }
8297
8298                 if (p_cstr_ind->tile_index[it_tile].tp_index) {
8299                     opj_free(p_cstr_ind->tile_index[it_tile].tp_index);
8300                     p_cstr_ind->tile_index[it_tile].tp_index = NULL;
8301                 }
8302
8303                 if (p_cstr_ind->tile_index[it_tile].marker) {
8304                     opj_free(p_cstr_ind->tile_index[it_tile].marker);
8305                     p_cstr_ind->tile_index[it_tile].marker = NULL;
8306
8307                 }
8308             }
8309
8310             opj_free(p_cstr_ind->tile_index);
8311             p_cstr_ind->tile_index = NULL;
8312         }
8313
8314         opj_free(p_cstr_ind);
8315     }
8316 }
8317
8318 static void opj_j2k_tcp_destroy(opj_tcp_t *p_tcp)
8319 {
8320     if (p_tcp == 00) {
8321         return;
8322     }
8323
8324     if (p_tcp->ppt_markers != 00) {
8325         OPJ_UINT32 i;
8326         for (i = 0U; i < p_tcp->ppt_markers_count; ++i) {
8327             if (p_tcp->ppt_markers[i].m_data != NULL) {
8328                 opj_free(p_tcp->ppt_markers[i].m_data);
8329             }
8330         }
8331         p_tcp->ppt_markers_count = 0U;
8332         opj_free(p_tcp->ppt_markers);
8333         p_tcp->ppt_markers = NULL;
8334     }
8335
8336     if (p_tcp->ppt_buffer != 00) {
8337         opj_free(p_tcp->ppt_buffer);
8338         p_tcp->ppt_buffer = 00;
8339     }
8340
8341     if (p_tcp->tccps != 00) {
8342         opj_free(p_tcp->tccps);
8343         p_tcp->tccps = 00;
8344     }
8345
8346     if (p_tcp->m_mct_coding_matrix != 00) {
8347         opj_free(p_tcp->m_mct_coding_matrix);
8348         p_tcp->m_mct_coding_matrix = 00;
8349     }
8350
8351     if (p_tcp->m_mct_decoding_matrix != 00) {
8352         opj_free(p_tcp->m_mct_decoding_matrix);
8353         p_tcp->m_mct_decoding_matrix = 00;
8354     }
8355
8356     if (p_tcp->m_mcc_records) {
8357         opj_free(p_tcp->m_mcc_records);
8358         p_tcp->m_mcc_records = 00;
8359         p_tcp->m_nb_max_mcc_records = 0;
8360         p_tcp->m_nb_mcc_records = 0;
8361     }
8362
8363     if (p_tcp->m_mct_records) {
8364         opj_mct_data_t * l_mct_data = p_tcp->m_mct_records;
8365         OPJ_UINT32 i;
8366
8367         for (i = 0; i < p_tcp->m_nb_mct_records; ++i) {
8368             if (l_mct_data->m_data) {
8369                 opj_free(l_mct_data->m_data);
8370                 l_mct_data->m_data = 00;
8371             }
8372
8373             ++l_mct_data;
8374         }
8375
8376         opj_free(p_tcp->m_mct_records);
8377         p_tcp->m_mct_records = 00;
8378     }
8379
8380     if (p_tcp->mct_norms != 00) {
8381         opj_free(p_tcp->mct_norms);
8382         p_tcp->mct_norms = 00;
8383     }
8384
8385     opj_j2k_tcp_data_destroy(p_tcp);
8386
8387 }
8388
8389 static void opj_j2k_tcp_data_destroy(opj_tcp_t *p_tcp)
8390 {
8391     if (p_tcp->m_data) {
8392         opj_free(p_tcp->m_data);
8393         p_tcp->m_data = NULL;
8394         p_tcp->m_data_size = 0;
8395     }
8396 }
8397
8398 static void opj_j2k_cp_destroy(opj_cp_t *p_cp)
8399 {
8400     OPJ_UINT32 l_nb_tiles;
8401     opj_tcp_t * l_current_tile = 00;
8402
8403     if (p_cp == 00) {
8404         return;
8405     }
8406     if (p_cp->tcps != 00) {
8407         OPJ_UINT32 i;
8408         l_current_tile = p_cp->tcps;
8409         l_nb_tiles = p_cp->th * p_cp->tw;
8410
8411         for (i = 0U; i < l_nb_tiles; ++i) {
8412             opj_j2k_tcp_destroy(l_current_tile);
8413             ++l_current_tile;
8414         }
8415         opj_free(p_cp->tcps);
8416         p_cp->tcps = 00;
8417     }
8418     if (p_cp->ppm_markers != 00) {
8419         OPJ_UINT32 i;
8420         for (i = 0U; i < p_cp->ppm_markers_count; ++i) {
8421             if (p_cp->ppm_markers[i].m_data != NULL) {
8422                 opj_free(p_cp->ppm_markers[i].m_data);
8423             }
8424         }
8425         p_cp->ppm_markers_count = 0U;
8426         opj_free(p_cp->ppm_markers);
8427         p_cp->ppm_markers = NULL;
8428     }
8429     opj_free(p_cp->ppm_buffer);
8430     p_cp->ppm_buffer = 00;
8431     p_cp->ppm_data =
8432         NULL; /* ppm_data belongs to the allocated buffer pointed by ppm_buffer */
8433     opj_free(p_cp->comment);
8434     p_cp->comment = 00;
8435     if (! p_cp->m_is_decoder) {
8436         opj_free(p_cp->m_specific_param.m_enc.m_matrice);
8437         p_cp->m_specific_param.m_enc.m_matrice = 00;
8438     }
8439 }
8440
8441 static OPJ_BOOL opj_j2k_need_nb_tile_parts_correction(opj_stream_private_t
8442         *p_stream, OPJ_UINT32 tile_no, OPJ_BOOL* p_correction_needed,
8443         opj_event_mgr_t * p_manager)
8444 {
8445     OPJ_BYTE   l_header_data[10];
8446     OPJ_OFF_T  l_stream_pos_backup;
8447     OPJ_UINT32 l_current_marker;
8448     OPJ_UINT32 l_marker_size;
8449     OPJ_UINT32 l_tile_no, l_tot_len, l_current_part, l_num_parts;
8450
8451     /* initialize to no correction needed */
8452     *p_correction_needed = OPJ_FALSE;
8453
8454     if (!opj_stream_has_seek(p_stream)) {
8455         /* We can't do much in this case, seek is needed */
8456         return OPJ_TRUE;
8457     }
8458
8459     l_stream_pos_backup = opj_stream_tell(p_stream);
8460     if (l_stream_pos_backup == -1) {
8461         /* let's do nothing */
8462         return OPJ_TRUE;
8463     }
8464
8465     for (;;) {
8466         /* Try to read 2 bytes (the next marker ID) from stream and copy them into the buffer */
8467         if (opj_stream_read_data(p_stream, l_header_data, 2, p_manager) != 2) {
8468             /* assume all is OK */
8469             if (! opj_stream_seek(p_stream, l_stream_pos_backup, p_manager)) {
8470                 return OPJ_FALSE;
8471             }
8472             return OPJ_TRUE;
8473         }
8474
8475         /* Read 2 bytes from buffer as the new marker ID */
8476         opj_read_bytes(l_header_data, &l_current_marker, 2);
8477
8478         if (l_current_marker != J2K_MS_SOT) {
8479             /* assume all is OK */
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         /* Try to read 2 bytes (the marker size) from stream and copy them into the buffer */
8487         if (opj_stream_read_data(p_stream, l_header_data, 2, p_manager) != 2) {
8488             opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
8489             return OPJ_FALSE;
8490         }
8491
8492         /* Read 2 bytes from the buffer as the marker size */
8493         opj_read_bytes(l_header_data, &l_marker_size, 2);
8494
8495         /* Check marker size for SOT Marker */
8496         if (l_marker_size != 10) {
8497             opj_event_msg(p_manager, EVT_ERROR, "Inconsistent marker size\n");
8498             return OPJ_FALSE;
8499         }
8500         l_marker_size -= 2;
8501
8502         if (opj_stream_read_data(p_stream, l_header_data, l_marker_size,
8503                                  p_manager) != l_marker_size) {
8504             opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
8505             return OPJ_FALSE;
8506         }
8507
8508         if (! opj_j2k_get_sot_values(l_header_data, l_marker_size, &l_tile_no,
8509                                      &l_tot_len, &l_current_part, &l_num_parts, p_manager)) {
8510             return OPJ_FALSE;
8511         }
8512
8513         if (l_tile_no == tile_no) {
8514             /* we found what we were looking for */
8515             break;
8516         }
8517
8518         if ((l_tot_len == 0U) || (l_tot_len < 14U)) {
8519             /* last SOT until EOC or invalid Psot value */
8520             /* assume all is OK */
8521             if (! opj_stream_seek(p_stream, l_stream_pos_backup, p_manager)) {
8522                 return OPJ_FALSE;
8523             }
8524             return OPJ_TRUE;
8525         }
8526         l_tot_len -= 12U;
8527         /* look for next SOT marker */
8528         if (opj_stream_skip(p_stream, (OPJ_OFF_T)(l_tot_len),
8529                             p_manager) != (OPJ_OFF_T)(l_tot_len)) {
8530             /* assume all is OK */
8531             if (! opj_stream_seek(p_stream, l_stream_pos_backup, p_manager)) {
8532                 return OPJ_FALSE;
8533             }
8534             return OPJ_TRUE;
8535         }
8536     }
8537
8538     /* check for correction */
8539     if (l_current_part == l_num_parts) {
8540         *p_correction_needed = OPJ_TRUE;
8541     }
8542
8543     if (! opj_stream_seek(p_stream, l_stream_pos_backup, p_manager)) {
8544         return OPJ_FALSE;
8545     }
8546     return OPJ_TRUE;
8547 }
8548
8549 OPJ_BOOL opj_j2k_read_tile_header(opj_j2k_t * p_j2k,
8550                                   OPJ_UINT32 * p_tile_index,
8551                                   OPJ_UINT32 * p_data_size,
8552                                   OPJ_INT32 * p_tile_x0, OPJ_INT32 * p_tile_y0,
8553                                   OPJ_INT32 * p_tile_x1, OPJ_INT32 * p_tile_y1,
8554                                   OPJ_UINT32 * p_nb_comps,
8555                                   OPJ_BOOL * p_go_on,
8556                                   opj_stream_private_t *p_stream,
8557                                   opj_event_mgr_t * p_manager)
8558 {
8559     OPJ_UINT32 l_current_marker = J2K_MS_SOT;
8560     OPJ_UINT32 l_marker_size;
8561     const opj_dec_memory_marker_handler_t * l_marker_handler = 00;
8562     opj_tcp_t * l_tcp = NULL;
8563
8564     /* preconditions */
8565     assert(p_stream != 00);
8566     assert(p_j2k != 00);
8567     assert(p_manager != 00);
8568
8569     /* Reach the End Of Codestream ?*/
8570     if (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_EOC) {
8571         l_current_marker = J2K_MS_EOC;
8572     }
8573     /* We need to encounter a SOT marker (a new tile-part header) */
8574     else if (p_j2k->m_specific_param.m_decoder.m_state != J2K_STATE_TPHSOT) {
8575         return OPJ_FALSE;
8576     }
8577
8578     /* Read into the codestream until reach the EOC or ! can_decode ??? FIXME */
8579     while ((!p_j2k->m_specific_param.m_decoder.m_can_decode) &&
8580             (l_current_marker != J2K_MS_EOC)) {
8581
8582         /* Try to read until the Start Of Data is detected */
8583         while (l_current_marker != J2K_MS_SOD) {
8584
8585             if (opj_stream_get_number_byte_left(p_stream) == 0) {
8586                 p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_NEOC;
8587                 break;
8588             }
8589
8590             /* Try to read 2 bytes (the marker size) from stream and copy them into the buffer */
8591             if (opj_stream_read_data(p_stream,
8592                                      p_j2k->m_specific_param.m_decoder.m_header_data, 2, p_manager) != 2) {
8593                 opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
8594                 return OPJ_FALSE;
8595             }
8596
8597             /* Read 2 bytes from the buffer as the marker size */
8598             opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data, &l_marker_size,
8599                            2);
8600
8601             /* Check marker size (does not include marker ID but includes marker size) */
8602             if (l_marker_size < 2) {
8603                 opj_event_msg(p_manager, EVT_ERROR, "Inconsistent marker size\n");
8604                 return OPJ_FALSE;
8605             }
8606
8607             /* cf. https://code.google.com/p/openjpeg/issues/detail?id=226 */
8608             if (l_current_marker == 0x8080 &&
8609                     opj_stream_get_number_byte_left(p_stream) == 0) {
8610                 p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_NEOC;
8611                 break;
8612             }
8613
8614             /* Why this condition? FIXME */
8615             if (p_j2k->m_specific_param.m_decoder.m_state & J2K_STATE_TPH) {
8616                 p_j2k->m_specific_param.m_decoder.m_sot_length -= (l_marker_size + 2);
8617             }
8618             l_marker_size -= 2; /* Subtract the size of the marker ID already read */
8619
8620             /* Get the marker handler from the marker ID */
8621             l_marker_handler = opj_j2k_get_marker_handler(l_current_marker);
8622
8623             /* Check if the marker is known and if it is the right place to find it */
8624             if (!(p_j2k->m_specific_param.m_decoder.m_state & l_marker_handler->states)) {
8625                 opj_event_msg(p_manager, EVT_ERROR,
8626                               "Marker is not compliant with its position\n");
8627                 return OPJ_FALSE;
8628             }
8629             /* FIXME manage case of unknown marker as in the main header ? */
8630
8631             /* Check if the marker size is compatible with the header data size */
8632             if (l_marker_size > p_j2k->m_specific_param.m_decoder.m_header_data_size) {
8633                 OPJ_BYTE *new_header_data = NULL;
8634                 /* If we are here, this means we consider this marker as known & we will read it */
8635                 /* Check enough bytes left in stream before allocation */
8636                 if ((OPJ_OFF_T)l_marker_size >  opj_stream_get_number_byte_left(p_stream)) {
8637                     opj_event_msg(p_manager, EVT_ERROR,
8638                                   "Marker size inconsistent with stream length\n");
8639                     return OPJ_FALSE;
8640                 }
8641                 new_header_data = (OPJ_BYTE *) opj_realloc(
8642                                       p_j2k->m_specific_param.m_decoder.m_header_data, l_marker_size);
8643                 if (! new_header_data) {
8644                     opj_free(p_j2k->m_specific_param.m_decoder.m_header_data);
8645                     p_j2k->m_specific_param.m_decoder.m_header_data = NULL;
8646                     p_j2k->m_specific_param.m_decoder.m_header_data_size = 0;
8647                     opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read header\n");
8648                     return OPJ_FALSE;
8649                 }
8650                 p_j2k->m_specific_param.m_decoder.m_header_data = new_header_data;
8651                 p_j2k->m_specific_param.m_decoder.m_header_data_size = l_marker_size;
8652             }
8653
8654             /* Try to read the rest of the marker segment from stream and copy them into the buffer */
8655             if (opj_stream_read_data(p_stream,
8656                                      p_j2k->m_specific_param.m_decoder.m_header_data, l_marker_size,
8657                                      p_manager) != l_marker_size) {
8658                 opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
8659                 return OPJ_FALSE;
8660             }
8661
8662             if (!l_marker_handler->handler) {
8663                 /* See issue #175 */
8664                 opj_event_msg(p_manager, EVT_ERROR, "Not sure how that happened.\n");
8665                 return OPJ_FALSE;
8666             }
8667             /* Read the marker segment with the correct marker handler */
8668             if (!(*(l_marker_handler->handler))(p_j2k,
8669                                                 p_j2k->m_specific_param.m_decoder.m_header_data, l_marker_size, p_manager)) {
8670                 opj_event_msg(p_manager, EVT_ERROR,
8671                               "Fail to read the current marker segment (%#x)\n", l_current_marker);
8672                 return OPJ_FALSE;
8673             }
8674
8675             /* Add the marker to the codestream index*/
8676             if (OPJ_FALSE == opj_j2k_add_tlmarker(p_j2k->m_current_tile_number,
8677                                                   p_j2k->cstr_index,
8678                                                   l_marker_handler->id,
8679                                                   (OPJ_UINT32) opj_stream_tell(p_stream) - l_marker_size - 4,
8680                                                   l_marker_size + 4)) {
8681                 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to add tl marker\n");
8682                 return OPJ_FALSE;
8683             }
8684
8685             /* Keep the position of the last SOT marker read */
8686             if (l_marker_handler->id == J2K_MS_SOT) {
8687                 OPJ_UINT32 sot_pos = (OPJ_UINT32) opj_stream_tell(p_stream) - l_marker_size - 4
8688                                      ;
8689                 if (sot_pos > p_j2k->m_specific_param.m_decoder.m_last_sot_read_pos) {
8690                     p_j2k->m_specific_param.m_decoder.m_last_sot_read_pos = sot_pos;
8691                 }
8692             }
8693
8694             if (p_j2k->m_specific_param.m_decoder.m_skip_data) {
8695                 /* Skip the rest of the tile part header*/
8696                 if (opj_stream_skip(p_stream, p_j2k->m_specific_param.m_decoder.m_sot_length,
8697                                     p_manager) != p_j2k->m_specific_param.m_decoder.m_sot_length) {
8698                     opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
8699                     return OPJ_FALSE;
8700                 }
8701                 l_current_marker = J2K_MS_SOD; /* Normally we reached a SOD */
8702             } else {
8703                 /* Try to read 2 bytes (the next marker ID) from stream and copy them into the buffer*/
8704                 if (opj_stream_read_data(p_stream,
8705                                          p_j2k->m_specific_param.m_decoder.m_header_data, 2, p_manager) != 2) {
8706                     opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
8707                     return OPJ_FALSE;
8708                 }
8709                 /* Read 2 bytes from the buffer as the new marker ID */
8710                 opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,
8711                                &l_current_marker, 2);
8712             }
8713         }
8714         if (opj_stream_get_number_byte_left(p_stream) == 0
8715                 && p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_NEOC) {
8716             break;
8717         }
8718
8719         /* If we didn't skip data before, we need to read the SOD marker*/
8720         if (! p_j2k->m_specific_param.m_decoder.m_skip_data) {
8721             /* Try to read the SOD marker and skip data ? FIXME */
8722             if (! opj_j2k_read_sod(p_j2k, p_stream, p_manager)) {
8723                 return OPJ_FALSE;
8724             }
8725             if (p_j2k->m_specific_param.m_decoder.m_can_decode &&
8726                     !p_j2k->m_specific_param.m_decoder.m_nb_tile_parts_correction_checked) {
8727                 /* Issue 254 */
8728                 OPJ_BOOL l_correction_needed;
8729
8730                 p_j2k->m_specific_param.m_decoder.m_nb_tile_parts_correction_checked = 1;
8731                 if (!opj_j2k_need_nb_tile_parts_correction(p_stream,
8732                         p_j2k->m_current_tile_number, &l_correction_needed, p_manager)) {
8733                     opj_event_msg(p_manager, EVT_ERROR,
8734                                   "opj_j2k_apply_nb_tile_parts_correction error\n");
8735                     return OPJ_FALSE;
8736                 }
8737                 if (l_correction_needed) {
8738                     OPJ_UINT32 l_nb_tiles = p_j2k->m_cp.tw * p_j2k->m_cp.th;
8739                     OPJ_UINT32 l_tile_no;
8740
8741                     p_j2k->m_specific_param.m_decoder.m_can_decode = 0;
8742                     p_j2k->m_specific_param.m_decoder.m_nb_tile_parts_correction = 1;
8743                     /* correct tiles */
8744                     for (l_tile_no = 0U; l_tile_no < l_nb_tiles; ++l_tile_no) {
8745                         if (p_j2k->m_cp.tcps[l_tile_no].m_nb_tile_parts != 0U) {
8746                             p_j2k->m_cp.tcps[l_tile_no].m_nb_tile_parts += 1;
8747                         }
8748                     }
8749                     opj_event_msg(p_manager, EVT_WARNING,
8750                                   "Non conformant codestream TPsot==TNsot.\n");
8751                 }
8752             }
8753             if (! p_j2k->m_specific_param.m_decoder.m_can_decode) {
8754                 /* Try to read 2 bytes (the next marker ID) from stream and copy them into the buffer */
8755                 if (opj_stream_read_data(p_stream,
8756                                          p_j2k->m_specific_param.m_decoder.m_header_data, 2, p_manager) != 2) {
8757                     opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
8758                     return OPJ_FALSE;
8759                 }
8760
8761                 /* Read 2 bytes from buffer as the new marker ID */
8762                 opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,
8763                                &l_current_marker, 2);
8764             }
8765         } else {
8766             /* Indicate we will try to read a new tile-part header*/
8767             p_j2k->m_specific_param.m_decoder.m_skip_data = 0;
8768             p_j2k->m_specific_param.m_decoder.m_can_decode = 0;
8769             p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_TPHSOT;
8770
8771             /* Try to read 2 bytes (the next marker ID) from stream and copy them into the buffer */
8772             if (opj_stream_read_data(p_stream,
8773                                      p_j2k->m_specific_param.m_decoder.m_header_data, 2, p_manager) != 2) {
8774                 opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
8775                 return OPJ_FALSE;
8776             }
8777
8778             /* Read 2 bytes from buffer as the new marker ID */
8779             opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,
8780                            &l_current_marker, 2);
8781         }
8782     }
8783
8784     /* Current marker is the EOC marker ?*/
8785     if (l_current_marker == J2K_MS_EOC) {
8786         p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_EOC;
8787     }
8788
8789     /* FIXME DOC ???*/
8790     if (! p_j2k->m_specific_param.m_decoder.m_can_decode) {
8791         OPJ_UINT32 l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
8792         l_tcp = p_j2k->m_cp.tcps + p_j2k->m_current_tile_number;
8793
8794         while ((p_j2k->m_current_tile_number < l_nb_tiles) && (l_tcp->m_data == 00)) {
8795             ++p_j2k->m_current_tile_number;
8796             ++l_tcp;
8797         }
8798
8799         if (p_j2k->m_current_tile_number == l_nb_tiles) {
8800             *p_go_on = OPJ_FALSE;
8801             return OPJ_TRUE;
8802         }
8803     }
8804
8805     if (! opj_j2k_merge_ppt(p_j2k->m_cp.tcps + p_j2k->m_current_tile_number,
8806                             p_manager)) {
8807         opj_event_msg(p_manager, EVT_ERROR, "Failed to merge PPT data\n");
8808         return OPJ_FALSE;
8809     }
8810     /*FIXME ???*/
8811     if (! opj_tcd_init_decode_tile(p_j2k->m_tcd, p_j2k->m_current_tile_number,
8812                                    p_manager)) {
8813         opj_event_msg(p_manager, EVT_ERROR, "Cannot decode tile, memory error\n");
8814         return OPJ_FALSE;
8815     }
8816
8817     opj_event_msg(p_manager, EVT_INFO, "Header of tile %d / %d has been read.\n",
8818                   p_j2k->m_current_tile_number + 1, (p_j2k->m_cp.th * p_j2k->m_cp.tw));
8819
8820     *p_tile_index = p_j2k->m_current_tile_number;
8821     *p_go_on = OPJ_TRUE;
8822     *p_data_size = opj_tcd_get_decoded_tile_size(p_j2k->m_tcd);
8823     if (*p_data_size == UINT_MAX) {
8824         return OPJ_FALSE;
8825     }
8826     *p_tile_x0 = p_j2k->m_tcd->tcd_image->tiles->x0;
8827     *p_tile_y0 = p_j2k->m_tcd->tcd_image->tiles->y0;
8828     *p_tile_x1 = p_j2k->m_tcd->tcd_image->tiles->x1;
8829     *p_tile_y1 = p_j2k->m_tcd->tcd_image->tiles->y1;
8830     *p_nb_comps = p_j2k->m_tcd->tcd_image->tiles->numcomps;
8831
8832     p_j2k->m_specific_param.m_decoder.m_state |= J2K_STATE_DATA;
8833
8834     return OPJ_TRUE;
8835 }
8836
8837 OPJ_BOOL opj_j2k_decode_tile(opj_j2k_t * p_j2k,
8838                              OPJ_UINT32 p_tile_index,
8839                              OPJ_BYTE * p_data,
8840                              OPJ_UINT32 p_data_size,
8841                              opj_stream_private_t *p_stream,
8842                              opj_event_mgr_t * p_manager)
8843 {
8844     OPJ_UINT32 l_current_marker;
8845     OPJ_BYTE l_data [2];
8846     opj_tcp_t * l_tcp;
8847     opj_image_t* l_image_for_bounds;
8848
8849     /* preconditions */
8850     assert(p_stream != 00);
8851     assert(p_j2k != 00);
8852     assert(p_manager != 00);
8853
8854     if (!(p_j2k->m_specific_param.m_decoder.m_state & J2K_STATE_DATA)
8855             || (p_tile_index != p_j2k->m_current_tile_number)) {
8856         return OPJ_FALSE;
8857     }
8858
8859     l_tcp = &(p_j2k->m_cp.tcps[p_tile_index]);
8860     if (! l_tcp->m_data) {
8861         opj_j2k_tcp_destroy(l_tcp);
8862         return OPJ_FALSE;
8863     }
8864
8865     /* When using the opj_read_tile_header / opj_decode_tile_data API */
8866     /* such as in test_tile_decoder, m_output_image is NULL, so fall back */
8867     /* to the full image dimension. This is a bit surprising that */
8868     /* opj_set_decode_area() is only used to determinte intersecting tiles, */
8869     /* but full tile decoding is done */
8870     l_image_for_bounds = p_j2k->m_output_image ? p_j2k->m_output_image :
8871                          p_j2k->m_private_image;
8872     if (! opj_tcd_decode_tile(p_j2k->m_tcd,
8873                               l_image_for_bounds->x0,
8874                               l_image_for_bounds->y0,
8875                               l_image_for_bounds->x1,
8876                               l_image_for_bounds->y1,
8877                               l_tcp->m_data,
8878                               l_tcp->m_data_size,
8879                               p_tile_index,
8880                               p_j2k->cstr_index, p_manager)) {
8881         opj_j2k_tcp_destroy(l_tcp);
8882         p_j2k->m_specific_param.m_decoder.m_state |= J2K_STATE_ERR;
8883         opj_event_msg(p_manager, EVT_ERROR, "Failed to decode.\n");
8884         return OPJ_FALSE;
8885     }
8886
8887     /* p_data can be set to NULL when the call will take care of using */
8888     /* itself the TCD data. This is typically the case for whole single */
8889     /* tile decoding optimization. */
8890     if (p_data != NULL) {
8891         if (! opj_tcd_update_tile_data(p_j2k->m_tcd, p_data, p_data_size)) {
8892             return OPJ_FALSE;
8893         }
8894
8895         /* To avoid to destroy the tcp which can be useful when we try to decode a tile decoded before (cf j2k_random_tile_access)
8896         * we destroy just the data which will be re-read in read_tile_header*/
8897         /*opj_j2k_tcp_destroy(l_tcp);
8898         p_j2k->m_tcd->tcp = 0;*/
8899         opj_j2k_tcp_data_destroy(l_tcp);
8900     }
8901
8902     p_j2k->m_specific_param.m_decoder.m_can_decode = 0;
8903     p_j2k->m_specific_param.m_decoder.m_state &= (~(OPJ_UINT32)J2K_STATE_DATA);
8904
8905     if (opj_stream_get_number_byte_left(p_stream) == 0
8906             && p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_NEOC) {
8907         return OPJ_TRUE;
8908     }
8909
8910     if (p_j2k->m_specific_param.m_decoder.m_state != J2K_STATE_EOC) {
8911         if (opj_stream_read_data(p_stream, l_data, 2, p_manager) != 2) {
8912             opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
8913             return OPJ_FALSE;
8914         }
8915
8916         opj_read_bytes(l_data, &l_current_marker, 2);
8917
8918         if (l_current_marker == J2K_MS_EOC) {
8919             p_j2k->m_current_tile_number = 0;
8920             p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_EOC;
8921         } else if (l_current_marker != J2K_MS_SOT) {
8922             if (opj_stream_get_number_byte_left(p_stream) == 0) {
8923                 p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_NEOC;
8924                 opj_event_msg(p_manager, EVT_WARNING, "Stream does not end with EOC\n");
8925                 return OPJ_TRUE;
8926             }
8927             opj_event_msg(p_manager, EVT_ERROR, "Stream too short, expected SOT\n");
8928             return OPJ_FALSE;
8929         }
8930     }
8931
8932     return OPJ_TRUE;
8933 }
8934
8935 static OPJ_BOOL opj_j2k_update_image_data(opj_tcd_t * p_tcd, OPJ_BYTE * p_data,
8936         opj_image_t* p_output_image)
8937 {
8938     OPJ_UINT32 i, j, k = 0;
8939     OPJ_UINT32 l_width_src, l_height_src;
8940     OPJ_UINT32 l_width_dest, l_height_dest;
8941     OPJ_INT32 l_offset_x0_src, l_offset_y0_src, l_offset_x1_src, l_offset_y1_src;
8942     OPJ_SIZE_T l_start_offset_src, l_line_offset_src, l_end_offset_src ;
8943     OPJ_UINT32 l_start_x_dest, l_start_y_dest;
8944     OPJ_UINT32 l_x0_dest, l_y0_dest, l_x1_dest, l_y1_dest;
8945     OPJ_SIZE_T l_start_offset_dest, l_line_offset_dest;
8946
8947     opj_image_comp_t * l_img_comp_src = 00;
8948     opj_image_comp_t * l_img_comp_dest = 00;
8949
8950     opj_tcd_tilecomp_t * l_tilec = 00;
8951     opj_image_t * l_image_src = 00;
8952     OPJ_UINT32 l_size_comp, l_remaining;
8953     OPJ_INT32 * l_dest_ptr;
8954     opj_tcd_resolution_t* l_res = 00;
8955
8956     l_tilec = p_tcd->tcd_image->tiles->comps;
8957     l_image_src = p_tcd->image;
8958     l_img_comp_src = l_image_src->comps;
8959
8960     l_img_comp_dest = p_output_image->comps;
8961
8962     for (i = 0; i < l_image_src->numcomps; i++) {
8963
8964         /* Allocate output component buffer if necessary */
8965         if (!l_img_comp_dest->data) {
8966             OPJ_SIZE_T l_width = l_img_comp_dest->w;
8967             OPJ_SIZE_T l_height = l_img_comp_dest->h;
8968
8969             if ((l_height == 0U) || (l_width > (SIZE_MAX / l_height)) ||
8970                     l_width * l_height > SIZE_MAX / sizeof(OPJ_INT32)) {
8971                 /* would overflow */
8972                 return OPJ_FALSE;
8973             }
8974             l_img_comp_dest->data = (OPJ_INT32*) opj_image_data_alloc(l_width * l_height *
8975                                     sizeof(OPJ_INT32));
8976             if (! l_img_comp_dest->data) {
8977                 return OPJ_FALSE;
8978             }
8979             /* Do we really need this memset ? */
8980             memset(l_img_comp_dest->data, 0, l_width * l_height * sizeof(OPJ_INT32));
8981         }
8982
8983         /* Copy info from decoded comp image to output image */
8984         l_img_comp_dest->resno_decoded = l_img_comp_src->resno_decoded;
8985
8986         /*-----*/
8987         /* Compute the precision of the output buffer */
8988         l_size_comp = l_img_comp_src->prec >> 3; /*(/ 8)*/
8989         l_remaining = l_img_comp_src->prec & 7;  /* (%8) */
8990         l_res = l_tilec->resolutions + l_img_comp_src->resno_decoded;
8991
8992         if (l_remaining) {
8993             ++l_size_comp;
8994         }
8995
8996         if (l_size_comp == 3) {
8997             l_size_comp = 4;
8998         }
8999         /*-----*/
9000
9001         /* Current tile component size*/
9002         /*if (i == 0) {
9003         fprintf(stdout, "SRC: l_res_x0=%d, l_res_x1=%d, l_res_y0=%d, l_res_y1=%d\n",
9004                         l_res->x0, l_res->x1, l_res->y0, l_res->y1);
9005         }*/
9006
9007         l_width_src = (OPJ_UINT32)(l_res->x1 - l_res->x0);
9008         l_height_src = (OPJ_UINT32)(l_res->y1 - l_res->y0);
9009
9010         /* Border of the current output component*/
9011         l_x0_dest = opj_uint_ceildivpow2(l_img_comp_dest->x0, l_img_comp_dest->factor);
9012         l_y0_dest = opj_uint_ceildivpow2(l_img_comp_dest->y0, l_img_comp_dest->factor);
9013         l_x1_dest = l_x0_dest +
9014                     l_img_comp_dest->w; /* can't overflow given that image->x1 is uint32 */
9015         l_y1_dest = l_y0_dest + l_img_comp_dest->h;
9016
9017         /*if (i == 0) {
9018         fprintf(stdout, "DEST: l_x0_dest=%d, l_x1_dest=%d, l_y0_dest=%d, l_y1_dest=%d (%d)\n",
9019                         l_x0_dest, l_x1_dest, l_y0_dest, l_y1_dest, l_img_comp_dest->factor );
9020         }*/
9021
9022         /*-----*/
9023         /* Compute the area (l_offset_x0_src, l_offset_y0_src, l_offset_x1_src, l_offset_y1_src)
9024          * of the input buffer (decoded tile component) which will be move
9025          * in the output buffer. Compute the area of the output buffer (l_start_x_dest,
9026          * l_start_y_dest, l_width_dest, l_height_dest)  which will be modified
9027          * by this input area.
9028          * */
9029         assert(l_res->x0 >= 0);
9030         assert(l_res->x1 >= 0);
9031         if (l_x0_dest < (OPJ_UINT32)l_res->x0) {
9032             l_start_x_dest = (OPJ_UINT32)l_res->x0 - l_x0_dest;
9033             l_offset_x0_src = 0;
9034
9035             if (l_x1_dest >= (OPJ_UINT32)l_res->x1) {
9036                 l_width_dest = l_width_src;
9037                 l_offset_x1_src = 0;
9038             } else {
9039                 l_width_dest = l_x1_dest - (OPJ_UINT32)l_res->x0 ;
9040                 l_offset_x1_src = (OPJ_INT32)(l_width_src - l_width_dest);
9041             }
9042         } else {
9043             l_start_x_dest = 0U;
9044             l_offset_x0_src = (OPJ_INT32)l_x0_dest - l_res->x0;
9045
9046             if (l_x1_dest >= (OPJ_UINT32)l_res->x1) {
9047                 l_width_dest = l_width_src - (OPJ_UINT32)l_offset_x0_src;
9048                 l_offset_x1_src = 0;
9049             } else {
9050                 l_width_dest = l_img_comp_dest->w ;
9051                 l_offset_x1_src = l_res->x1 - (OPJ_INT32)l_x1_dest;
9052             }
9053         }
9054
9055         if (l_y0_dest < (OPJ_UINT32)l_res->y0) {
9056             l_start_y_dest = (OPJ_UINT32)l_res->y0 - l_y0_dest;
9057             l_offset_y0_src = 0;
9058
9059             if (l_y1_dest >= (OPJ_UINT32)l_res->y1) {
9060                 l_height_dest = l_height_src;
9061                 l_offset_y1_src = 0;
9062             } else {
9063                 l_height_dest = l_y1_dest - (OPJ_UINT32)l_res->y0 ;
9064                 l_offset_y1_src = (OPJ_INT32)(l_height_src - l_height_dest);
9065             }
9066         } else {
9067             l_start_y_dest = 0U;
9068             l_offset_y0_src = (OPJ_INT32)l_y0_dest - l_res->y0;
9069
9070             if (l_y1_dest >= (OPJ_UINT32)l_res->y1) {
9071                 l_height_dest = l_height_src - (OPJ_UINT32)l_offset_y0_src;
9072                 l_offset_y1_src = 0;
9073             } else {
9074                 l_height_dest = l_img_comp_dest->h ;
9075                 l_offset_y1_src = l_res->y1 - (OPJ_INT32)l_y1_dest;
9076             }
9077         }
9078
9079         if ((l_offset_x0_src < 0) || (l_offset_y0_src < 0) || (l_offset_x1_src < 0) ||
9080                 (l_offset_y1_src < 0)) {
9081             return OPJ_FALSE;
9082         }
9083         /* testcase 2977.pdf.asan.67.2198 */
9084         if ((OPJ_INT32)l_width_dest < 0 || (OPJ_INT32)l_height_dest < 0) {
9085             return OPJ_FALSE;
9086         }
9087         /*-----*/
9088
9089         /* Compute the input buffer offset */
9090         l_start_offset_src = (OPJ_SIZE_T)l_offset_x0_src + (OPJ_SIZE_T)l_offset_y0_src
9091                              * (OPJ_SIZE_T)l_width_src;
9092         l_line_offset_src  = (OPJ_SIZE_T)l_offset_x1_src + (OPJ_SIZE_T)l_offset_x0_src;
9093         l_end_offset_src   = (OPJ_SIZE_T)l_offset_y1_src * (OPJ_SIZE_T)l_width_src -
9094                              (OPJ_SIZE_T)l_offset_x0_src;
9095
9096         /* Compute the output buffer offset */
9097         l_start_offset_dest = (OPJ_SIZE_T)l_start_x_dest + (OPJ_SIZE_T)l_start_y_dest
9098                               * (OPJ_SIZE_T)l_img_comp_dest->w;
9099         l_line_offset_dest  = (OPJ_SIZE_T)l_img_comp_dest->w - (OPJ_SIZE_T)l_width_dest;
9100
9101         /* Move the output buffer to the first place where we will write*/
9102         l_dest_ptr = l_img_comp_dest->data + l_start_offset_dest;
9103
9104         /*if (i == 0) {
9105                 fprintf(stdout, "COMPO[%d]:\n",i);
9106                 fprintf(stdout, "SRC: l_start_x_src=%d, l_start_y_src=%d, l_width_src=%d, l_height_src=%d\n"
9107                                 "\t tile offset:%d, %d, %d, %d\n"
9108                                 "\t buffer offset: %d; %d, %d\n",
9109                                 l_res->x0, l_res->y0, l_width_src, l_height_src,
9110                                 l_offset_x0_src, l_offset_y0_src, l_offset_x1_src, l_offset_y1_src,
9111                                 l_start_offset_src, l_line_offset_src, l_end_offset_src);
9112
9113                 fprintf(stdout, "DEST: l_start_x_dest=%d, l_start_y_dest=%d, l_width_dest=%d, l_height_dest=%d\n"
9114                                 "\t start offset: %d, line offset= %d\n",
9115                                 l_start_x_dest, l_start_y_dest, l_width_dest, l_height_dest, l_start_offset_dest, l_line_offset_dest);
9116         }*/
9117
9118         switch (l_size_comp) {
9119         case 1: {
9120             OPJ_CHAR * l_src_ptr = (OPJ_CHAR*) p_data;
9121             l_src_ptr += l_start_offset_src; /* Move to the first place where we will read*/
9122
9123             if (l_img_comp_src->sgnd) {
9124                 for (j = 0 ; j < l_height_dest ; ++j) {
9125                     for (k = 0 ; k < l_width_dest ; ++k) {
9126                         *(l_dest_ptr++) = (OPJ_INT32)(*
9127                                                       (l_src_ptr++));  /* Copy only the data needed for the output image */
9128                     }
9129
9130                     l_dest_ptr +=
9131                         l_line_offset_dest; /* Move to the next place where we will write */
9132                     l_src_ptr += l_line_offset_src ; /* Move to the next place where we will read */
9133                 }
9134             } else {
9135                 for (j = 0 ; j < l_height_dest ; ++j) {
9136                     for (k = 0 ; k < l_width_dest ; ++k) {
9137                         *(l_dest_ptr++) = (OPJ_INT32)((*(l_src_ptr++)) & 0xff);
9138                     }
9139
9140                     l_dest_ptr += l_line_offset_dest;
9141                     l_src_ptr += l_line_offset_src;
9142                 }
9143             }
9144
9145             l_src_ptr +=
9146                 l_end_offset_src; /* Move to the end of this component-part of the input buffer */
9147             p_data = (OPJ_BYTE*)
9148                      l_src_ptr; /* Keep the current position for the next component-part */
9149         }
9150         break;
9151         case 2: {
9152             OPJ_INT16 * l_src_ptr = (OPJ_INT16 *) p_data;
9153             l_src_ptr += l_start_offset_src;
9154
9155             if (l_img_comp_src->sgnd) {
9156                 for (j = 0; j < l_height_dest; ++j) {
9157                     for (k = 0; k < l_width_dest; ++k) {
9158                         OPJ_INT16 val;
9159                         memcpy(&val, l_src_ptr, sizeof(val));
9160                         l_src_ptr ++;
9161                         *(l_dest_ptr++) = val;
9162                     }
9163
9164                     l_dest_ptr += l_line_offset_dest;
9165                     l_src_ptr += l_line_offset_src ;
9166                 }
9167             } else {
9168                 for (j = 0; j < l_height_dest; ++j) {
9169                     for (k = 0; k < l_width_dest; ++k) {
9170                         OPJ_INT16 val;
9171                         memcpy(&val, l_src_ptr, sizeof(val));
9172                         l_src_ptr ++;
9173                         *(l_dest_ptr++) = val & 0xffff;
9174                     }
9175
9176                     l_dest_ptr += l_line_offset_dest;
9177                     l_src_ptr += l_line_offset_src ;
9178                 }
9179             }
9180
9181             l_src_ptr += l_end_offset_src;
9182             p_data = (OPJ_BYTE*) l_src_ptr;
9183         }
9184         break;
9185         case 4: {
9186             OPJ_INT32 * l_src_ptr = (OPJ_INT32 *) p_data;
9187             l_src_ptr += l_start_offset_src;
9188
9189             for (j = 0; j < l_height_dest; ++j) {
9190                 memcpy(l_dest_ptr, l_src_ptr, l_width_dest * sizeof(OPJ_INT32));
9191                 l_dest_ptr += l_width_dest + l_line_offset_dest;
9192                 l_src_ptr += l_width_dest + l_line_offset_src ;
9193             }
9194
9195             l_src_ptr += l_end_offset_src;
9196             p_data = (OPJ_BYTE*) l_src_ptr;
9197         }
9198         break;
9199         }
9200
9201         ++l_img_comp_dest;
9202         ++l_img_comp_src;
9203         ++l_tilec;
9204     }
9205
9206     return OPJ_TRUE;
9207 }
9208
9209 static OPJ_BOOL opj_j2k_update_image_dimensions(opj_image_t* p_image,
9210         opj_event_mgr_t * p_manager)
9211 {
9212     OPJ_UINT32 it_comp;
9213     OPJ_INT32 l_comp_x1, l_comp_y1;
9214     opj_image_comp_t* l_img_comp = NULL;
9215
9216     l_img_comp = p_image->comps;
9217     for (it_comp = 0; it_comp < p_image->numcomps; ++it_comp) {
9218         OPJ_INT32 l_h, l_w;
9219
9220         l_img_comp->x0 = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)p_image->x0,
9221                          (OPJ_INT32)l_img_comp->dx);
9222         l_img_comp->y0 = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)p_image->y0,
9223                          (OPJ_INT32)l_img_comp->dy);
9224         l_comp_x1 = opj_int_ceildiv((OPJ_INT32)p_image->x1, (OPJ_INT32)l_img_comp->dx);
9225         l_comp_y1 = opj_int_ceildiv((OPJ_INT32)p_image->y1, (OPJ_INT32)l_img_comp->dy);
9226
9227         l_w = opj_int_ceildivpow2(l_comp_x1, (OPJ_INT32)l_img_comp->factor)
9228               - opj_int_ceildivpow2((OPJ_INT32)l_img_comp->x0, (OPJ_INT32)l_img_comp->factor);
9229         if (l_w < 0) {
9230             opj_event_msg(p_manager, EVT_ERROR,
9231                           "Size x of the decoded component image is incorrect (comp[%d].w=%d).\n",
9232                           it_comp, l_w);
9233             return OPJ_FALSE;
9234         }
9235         l_img_comp->w = (OPJ_UINT32)l_w;
9236
9237         l_h = opj_int_ceildivpow2(l_comp_y1, (OPJ_INT32)l_img_comp->factor)
9238               - opj_int_ceildivpow2((OPJ_INT32)l_img_comp->y0, (OPJ_INT32)l_img_comp->factor);
9239         if (l_h < 0) {
9240             opj_event_msg(p_manager, EVT_ERROR,
9241                           "Size y of the decoded component image is incorrect (comp[%d].h=%d).\n",
9242                           it_comp, l_h);
9243             return OPJ_FALSE;
9244         }
9245         l_img_comp->h = (OPJ_UINT32)l_h;
9246
9247         l_img_comp++;
9248     }
9249
9250     return OPJ_TRUE;
9251 }
9252
9253
9254 OPJ_BOOL opj_j2k_set_decode_area(opj_j2k_t *p_j2k,
9255                                  opj_image_t* p_image,
9256                                  OPJ_INT32 p_start_x, OPJ_INT32 p_start_y,
9257                                  OPJ_INT32 p_end_x, OPJ_INT32 p_end_y,
9258                                  opj_event_mgr_t * p_manager)
9259 {
9260     opj_cp_t * l_cp = &(p_j2k->m_cp);
9261     opj_image_t * l_image = p_j2k->m_private_image;
9262     OPJ_BOOL ret;
9263     OPJ_UINT32 it_comp;
9264
9265     /* Check if we are read the main header */
9266     if (p_j2k->m_specific_param.m_decoder.m_state != J2K_STATE_TPHSOT) {
9267         opj_event_msg(p_manager, EVT_ERROR,
9268                       "Need to decode the main header before begin to decode the remaining codestream");
9269         return OPJ_FALSE;
9270     }
9271
9272     /* Update the comps[].factor member of the output image with the one */
9273     /* of m_reduce */
9274     for (it_comp = 0; it_comp < p_image->numcomps; ++it_comp) {
9275         p_image->comps[it_comp].factor = p_j2k->m_cp.m_specific_param.m_dec.m_reduce;
9276     }
9277
9278     if (!p_start_x && !p_start_y && !p_end_x && !p_end_y) {
9279         opj_event_msg(p_manager, EVT_INFO,
9280                       "No decoded area parameters, set the decoded area to the whole image\n");
9281
9282         p_j2k->m_specific_param.m_decoder.m_start_tile_x = 0;
9283         p_j2k->m_specific_param.m_decoder.m_start_tile_y = 0;
9284         p_j2k->m_specific_param.m_decoder.m_end_tile_x = l_cp->tw;
9285         p_j2k->m_specific_param.m_decoder.m_end_tile_y = l_cp->th;
9286
9287         p_image->x0 = l_image->x0;
9288         p_image->y0 = l_image->y0;
9289         p_image->x1 = l_image->x1;
9290         p_image->y1 = l_image->y1;
9291
9292         return opj_j2k_update_image_dimensions(p_image, p_manager);
9293     }
9294
9295     /* ----- */
9296     /* Check if the positions provided by the user are correct */
9297
9298     /* Left */
9299     if (p_start_x < 0) {
9300         opj_event_msg(p_manager, EVT_ERROR,
9301                       "Left position of the decoded area (region_x0=%d) should be >= 0.\n",
9302                       p_start_x);
9303         return OPJ_FALSE;
9304     } else if ((OPJ_UINT32)p_start_x > l_image->x1) {
9305         opj_event_msg(p_manager, EVT_ERROR,
9306                       "Left position of the decoded area (region_x0=%d) is outside the image area (Xsiz=%d).\n",
9307                       p_start_x, l_image->x1);
9308         return OPJ_FALSE;
9309     } else if ((OPJ_UINT32)p_start_x < l_image->x0) {
9310         opj_event_msg(p_manager, EVT_WARNING,
9311                       "Left position of the decoded area (region_x0=%d) is outside the image area (XOsiz=%d).\n",
9312                       p_start_x, l_image->x0);
9313         p_j2k->m_specific_param.m_decoder.m_start_tile_x = 0;
9314         p_image->x0 = l_image->x0;
9315     } else {
9316         p_j2k->m_specific_param.m_decoder.m_start_tile_x = ((OPJ_UINT32)p_start_x -
9317                 l_cp->tx0) / l_cp->tdx;
9318         p_image->x0 = (OPJ_UINT32)p_start_x;
9319     }
9320
9321     /* Up */
9322     if (p_start_x < 0) {
9323         opj_event_msg(p_manager, EVT_ERROR,
9324                       "Up position of the decoded area (region_y0=%d) should be >= 0.\n",
9325                       p_start_y);
9326         return OPJ_FALSE;
9327     } else if ((OPJ_UINT32)p_start_y > l_image->y1) {
9328         opj_event_msg(p_manager, EVT_ERROR,
9329                       "Up position of the decoded area (region_y0=%d) is outside the image area (Ysiz=%d).\n",
9330                       p_start_y, l_image->y1);
9331         return OPJ_FALSE;
9332     } else if ((OPJ_UINT32)p_start_y < l_image->y0) {
9333         opj_event_msg(p_manager, EVT_WARNING,
9334                       "Up position of the decoded area (region_y0=%d) is outside the image area (YOsiz=%d).\n",
9335                       p_start_y, l_image->y0);
9336         p_j2k->m_specific_param.m_decoder.m_start_tile_y = 0;
9337         p_image->y0 = l_image->y0;
9338     } else {
9339         p_j2k->m_specific_param.m_decoder.m_start_tile_y = ((OPJ_UINT32)p_start_y -
9340                 l_cp->ty0) / l_cp->tdy;
9341         p_image->y0 = (OPJ_UINT32)p_start_y;
9342     }
9343
9344     /* Right */
9345     if (p_end_x <= 0) {
9346         opj_event_msg(p_manager, EVT_ERROR,
9347                       "Right position of the decoded area (region_x1=%d) should be > 0.\n",
9348                       p_end_x);
9349         return OPJ_FALSE;
9350     } else if ((OPJ_UINT32)p_end_x < l_image->x0) {
9351         opj_event_msg(p_manager, EVT_ERROR,
9352                       "Right position of the decoded area (region_x1=%d) is outside the image area (XOsiz=%d).\n",
9353                       p_end_x, l_image->x0);
9354         return OPJ_FALSE;
9355     } else if ((OPJ_UINT32)p_end_x > l_image->x1) {
9356         opj_event_msg(p_manager, EVT_WARNING,
9357                       "Right position of the decoded area (region_x1=%d) is outside the image area (Xsiz=%d).\n",
9358                       p_end_x, l_image->x1);
9359         p_j2k->m_specific_param.m_decoder.m_end_tile_x = l_cp->tw;
9360         p_image->x1 = l_image->x1;
9361     } else {
9362         p_j2k->m_specific_param.m_decoder.m_end_tile_x = (OPJ_UINT32)opj_int_ceildiv(
9363                     p_end_x - (OPJ_INT32)l_cp->tx0, (OPJ_INT32)l_cp->tdx);
9364         p_image->x1 = (OPJ_UINT32)p_end_x;
9365     }
9366
9367     /* Bottom */
9368     if (p_end_y <= 0) {
9369         opj_event_msg(p_manager, EVT_ERROR,
9370                       "Bottom position of the decoded area (region_y1=%d) should be > 0.\n",
9371                       p_end_y);
9372         return OPJ_FALSE;
9373     } else if ((OPJ_UINT32)p_end_y < l_image->y0) {
9374         opj_event_msg(p_manager, EVT_ERROR,
9375                       "Bottom position of the decoded area (region_y1=%d) is outside the image area (YOsiz=%d).\n",
9376                       p_end_y, l_image->y0);
9377         return OPJ_FALSE;
9378     }
9379     if ((OPJ_UINT32)p_end_y > l_image->y1) {
9380         opj_event_msg(p_manager, EVT_WARNING,
9381                       "Bottom position of the decoded area (region_y1=%d) is outside the image area (Ysiz=%d).\n",
9382                       p_end_y, l_image->y1);
9383         p_j2k->m_specific_param.m_decoder.m_end_tile_y = l_cp->th;
9384         p_image->y1 = l_image->y1;
9385     } else {
9386         p_j2k->m_specific_param.m_decoder.m_end_tile_y = (OPJ_UINT32)opj_int_ceildiv(
9387                     p_end_y - (OPJ_INT32)l_cp->ty0, (OPJ_INT32)l_cp->tdy);
9388         p_image->y1 = (OPJ_UINT32)p_end_y;
9389     }
9390     /* ----- */
9391
9392     p_j2k->m_specific_param.m_decoder.m_discard_tiles = 1;
9393
9394     ret = opj_j2k_update_image_dimensions(p_image, p_manager);
9395
9396     if (ret) {
9397         opj_event_msg(p_manager, EVT_INFO, "Setting decoding area to %d,%d,%d,%d\n",
9398                       p_image->x0, p_image->y0, p_image->x1, p_image->y1);
9399     }
9400
9401     return ret;
9402 }
9403
9404 opj_j2k_t* opj_j2k_create_decompress(void)
9405 {
9406     opj_j2k_t *l_j2k = (opj_j2k_t*) opj_calloc(1, sizeof(opj_j2k_t));
9407     if (!l_j2k) {
9408         return 00;
9409     }
9410
9411     l_j2k->m_is_decoder = 1;
9412     l_j2k->m_cp.m_is_decoder = 1;
9413     /* in the absence of JP2 boxes, consider different bit depth / sign */
9414     /* per component is allowed */
9415     l_j2k->m_cp.allow_different_bit_depth_sign = 1;
9416
9417 #ifdef OPJ_DISABLE_TPSOT_FIX
9418     l_j2k->m_specific_param.m_decoder.m_nb_tile_parts_correction_checked = 1;
9419 #endif
9420
9421     l_j2k->m_specific_param.m_decoder.m_default_tcp = (opj_tcp_t*) opj_calloc(1,
9422             sizeof(opj_tcp_t));
9423     if (!l_j2k->m_specific_param.m_decoder.m_default_tcp) {
9424         opj_j2k_destroy(l_j2k);
9425         return 00;
9426     }
9427
9428     l_j2k->m_specific_param.m_decoder.m_header_data = (OPJ_BYTE *) opj_calloc(1,
9429             OPJ_J2K_DEFAULT_HEADER_SIZE);
9430     if (! l_j2k->m_specific_param.m_decoder.m_header_data) {
9431         opj_j2k_destroy(l_j2k);
9432         return 00;
9433     }
9434
9435     l_j2k->m_specific_param.m_decoder.m_header_data_size =
9436         OPJ_J2K_DEFAULT_HEADER_SIZE;
9437
9438     l_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec = -1 ;
9439
9440     l_j2k->m_specific_param.m_decoder.m_last_sot_read_pos = 0 ;
9441
9442     /* codestream index creation */
9443     l_j2k->cstr_index = opj_j2k_create_cstr_index();
9444     if (!l_j2k->cstr_index) {
9445         opj_j2k_destroy(l_j2k);
9446         return 00;
9447     }
9448
9449     /* validation list creation */
9450     l_j2k->m_validation_list = opj_procedure_list_create();
9451     if (! l_j2k->m_validation_list) {
9452         opj_j2k_destroy(l_j2k);
9453         return 00;
9454     }
9455
9456     /* execution list creation */
9457     l_j2k->m_procedure_list = opj_procedure_list_create();
9458     if (! l_j2k->m_procedure_list) {
9459         opj_j2k_destroy(l_j2k);
9460         return 00;
9461     }
9462
9463     l_j2k->m_tp = opj_thread_pool_create(opj_j2k_get_default_thread_count());
9464     if (!l_j2k->m_tp) {
9465         l_j2k->m_tp = opj_thread_pool_create(0);
9466     }
9467     if (!l_j2k->m_tp) {
9468         opj_j2k_destroy(l_j2k);
9469         return NULL;
9470     }
9471
9472     return l_j2k;
9473 }
9474
9475 static opj_codestream_index_t* opj_j2k_create_cstr_index(void)
9476 {
9477     opj_codestream_index_t* cstr_index = (opj_codestream_index_t*)
9478                                          opj_calloc(1, sizeof(opj_codestream_index_t));
9479     if (!cstr_index) {
9480         return NULL;
9481     }
9482
9483     cstr_index->maxmarknum = 100;
9484     cstr_index->marknum = 0;
9485     cstr_index->marker = (opj_marker_info_t*)
9486                          opj_calloc(cstr_index->maxmarknum, sizeof(opj_marker_info_t));
9487     if (!cstr_index-> marker) {
9488         opj_free(cstr_index);
9489         return NULL;
9490     }
9491
9492     cstr_index->tile_index = NULL;
9493
9494     return cstr_index;
9495 }
9496
9497 static OPJ_UINT32 opj_j2k_get_SPCod_SPCoc_size(opj_j2k_t *p_j2k,
9498         OPJ_UINT32 p_tile_no,
9499         OPJ_UINT32 p_comp_no)
9500 {
9501     opj_cp_t *l_cp = 00;
9502     opj_tcp_t *l_tcp = 00;
9503     opj_tccp_t *l_tccp = 00;
9504
9505     /* preconditions */
9506     assert(p_j2k != 00);
9507
9508     l_cp = &(p_j2k->m_cp);
9509     l_tcp = &l_cp->tcps[p_tile_no];
9510     l_tccp = &l_tcp->tccps[p_comp_no];
9511
9512     /* preconditions again */
9513     assert(p_tile_no < (l_cp->tw * l_cp->th));
9514     assert(p_comp_no < p_j2k->m_private_image->numcomps);
9515
9516     if (l_tccp->csty & J2K_CCP_CSTY_PRT) {
9517         return 5 + l_tccp->numresolutions;
9518     } else {
9519         return 5;
9520     }
9521 }
9522
9523 static OPJ_BOOL opj_j2k_compare_SPCod_SPCoc(opj_j2k_t *p_j2k,
9524         OPJ_UINT32 p_tile_no, OPJ_UINT32 p_first_comp_no, OPJ_UINT32 p_second_comp_no)
9525 {
9526     OPJ_UINT32 i;
9527     opj_cp_t *l_cp = NULL;
9528     opj_tcp_t *l_tcp = NULL;
9529     opj_tccp_t *l_tccp0 = NULL;
9530     opj_tccp_t *l_tccp1 = NULL;
9531
9532     /* preconditions */
9533     assert(p_j2k != 00);
9534
9535     l_cp = &(p_j2k->m_cp);
9536     l_tcp = &l_cp->tcps[p_tile_no];
9537     l_tccp0 = &l_tcp->tccps[p_first_comp_no];
9538     l_tccp1 = &l_tcp->tccps[p_second_comp_no];
9539
9540     if (l_tccp0->numresolutions != l_tccp1->numresolutions) {
9541         return OPJ_FALSE;
9542     }
9543     if (l_tccp0->cblkw != l_tccp1->cblkw) {
9544         return OPJ_FALSE;
9545     }
9546     if (l_tccp0->cblkh != l_tccp1->cblkh) {
9547         return OPJ_FALSE;
9548     }
9549     if (l_tccp0->cblksty != l_tccp1->cblksty) {
9550         return OPJ_FALSE;
9551     }
9552     if (l_tccp0->qmfbid != l_tccp1->qmfbid) {
9553         return OPJ_FALSE;
9554     }
9555     if ((l_tccp0->csty & J2K_CCP_CSTY_PRT) != (l_tccp1->csty & J2K_CCP_CSTY_PRT)) {
9556         return OPJ_FALSE;
9557     }
9558
9559     for (i = 0U; i < l_tccp0->numresolutions; ++i) {
9560         if (l_tccp0->prcw[i] != l_tccp1->prcw[i]) {
9561             return OPJ_FALSE;
9562         }
9563         if (l_tccp0->prch[i] != l_tccp1->prch[i]) {
9564             return OPJ_FALSE;
9565         }
9566     }
9567     return OPJ_TRUE;
9568 }
9569
9570 static OPJ_BOOL opj_j2k_write_SPCod_SPCoc(opj_j2k_t *p_j2k,
9571         OPJ_UINT32 p_tile_no,
9572         OPJ_UINT32 p_comp_no,
9573         OPJ_BYTE * p_data,
9574         OPJ_UINT32 * p_header_size,
9575         struct opj_event_mgr * p_manager)
9576 {
9577     OPJ_UINT32 i;
9578     opj_cp_t *l_cp = 00;
9579     opj_tcp_t *l_tcp = 00;
9580     opj_tccp_t *l_tccp = 00;
9581
9582     /* preconditions */
9583     assert(p_j2k != 00);
9584     assert(p_header_size != 00);
9585     assert(p_manager != 00);
9586     assert(p_data != 00);
9587
9588     l_cp = &(p_j2k->m_cp);
9589     l_tcp = &l_cp->tcps[p_tile_no];
9590     l_tccp = &l_tcp->tccps[p_comp_no];
9591
9592     /* preconditions again */
9593     assert(p_tile_no < (l_cp->tw * l_cp->th));
9594     assert(p_comp_no < (p_j2k->m_private_image->numcomps));
9595
9596     if (*p_header_size < 5) {
9597         opj_event_msg(p_manager, EVT_ERROR, "Error writing SPCod SPCoc element\n");
9598         return OPJ_FALSE;
9599     }
9600
9601     opj_write_bytes(p_data, l_tccp->numresolutions - 1, 1); /* SPcoc (D) */
9602     ++p_data;
9603
9604     opj_write_bytes(p_data, l_tccp->cblkw - 2, 1);                  /* SPcoc (E) */
9605     ++p_data;
9606
9607     opj_write_bytes(p_data, l_tccp->cblkh - 2, 1);                  /* SPcoc (F) */
9608     ++p_data;
9609
9610     opj_write_bytes(p_data, l_tccp->cblksty,
9611                     1);                            /* SPcoc (G) */
9612     ++p_data;
9613
9614     opj_write_bytes(p_data, l_tccp->qmfbid,
9615                     1);                             /* SPcoc (H) */
9616     ++p_data;
9617
9618     *p_header_size = *p_header_size - 5;
9619
9620     if (l_tccp->csty & J2K_CCP_CSTY_PRT) {
9621
9622         if (*p_header_size < l_tccp->numresolutions) {
9623             opj_event_msg(p_manager, EVT_ERROR, "Error writing SPCod SPCoc element\n");
9624             return OPJ_FALSE;
9625         }
9626
9627         for (i = 0; i < l_tccp->numresolutions; ++i) {
9628             opj_write_bytes(p_data, l_tccp->prcw[i] + (l_tccp->prch[i] << 4),
9629                             1);   /* SPcoc (I_i) */
9630             ++p_data;
9631         }
9632
9633         *p_header_size = *p_header_size - l_tccp->numresolutions;
9634     }
9635
9636     return OPJ_TRUE;
9637 }
9638
9639 static OPJ_BOOL opj_j2k_read_SPCod_SPCoc(opj_j2k_t *p_j2k,
9640         OPJ_UINT32 compno,
9641         OPJ_BYTE * p_header_data,
9642         OPJ_UINT32 * p_header_size,
9643         opj_event_mgr_t * p_manager)
9644 {
9645     OPJ_UINT32 i, l_tmp;
9646     opj_cp_t *l_cp = NULL;
9647     opj_tcp_t *l_tcp = NULL;
9648     opj_tccp_t *l_tccp = NULL;
9649     OPJ_BYTE * l_current_ptr = NULL;
9650
9651     /* preconditions */
9652     assert(p_j2k != 00);
9653     assert(p_manager != 00);
9654     assert(p_header_data != 00);
9655
9656     l_cp = &(p_j2k->m_cp);
9657     l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH) ?
9658             &l_cp->tcps[p_j2k->m_current_tile_number] :
9659             p_j2k->m_specific_param.m_decoder.m_default_tcp;
9660
9661     /* precondition again */
9662     assert(compno < p_j2k->m_private_image->numcomps);
9663
9664     l_tccp = &l_tcp->tccps[compno];
9665     l_current_ptr = p_header_data;
9666
9667     /* make sure room is sufficient */
9668     if (*p_header_size < 5) {
9669         opj_event_msg(p_manager, EVT_ERROR, "Error reading SPCod SPCoc element\n");
9670         return OPJ_FALSE;
9671     }
9672
9673     opj_read_bytes(l_current_ptr, &l_tccp->numresolutions,
9674                    1);              /* SPcox (D) */
9675     ++l_tccp->numresolutions;                                                                               /* tccp->numresolutions = read() + 1 */
9676     if (l_tccp->numresolutions > OPJ_J2K_MAXRLVLS) {
9677         opj_event_msg(p_manager, EVT_ERROR,
9678                       "Invalid value for numresolutions : %d, max value is set in openjpeg.h at %d\n",
9679                       l_tccp->numresolutions, OPJ_J2K_MAXRLVLS);
9680         return OPJ_FALSE;
9681     }
9682     ++l_current_ptr;
9683
9684     /* If user wants to remove more resolutions than the codestream contains, return error */
9685     if (l_cp->m_specific_param.m_dec.m_reduce >= l_tccp->numresolutions) {
9686         opj_event_msg(p_manager, EVT_ERROR,
9687                       "Error decoding component %d.\nThe number of resolutions "
9688                       "to remove (%d) is greater or equal than the number "
9689                       "of resolutions of this component (%d)\nModify the cp_reduce parameter.\n\n",
9690                       compno, l_cp->m_specific_param.m_dec.m_reduce, l_tccp->numresolutions);
9691         p_j2k->m_specific_param.m_decoder.m_state |=
9692             0x8000;/* FIXME J2K_DEC_STATE_ERR;*/
9693         return OPJ_FALSE;
9694     }
9695
9696     opj_read_bytes(l_current_ptr, &l_tccp->cblkw, 1);               /* SPcoc (E) */
9697     ++l_current_ptr;
9698     l_tccp->cblkw += 2;
9699
9700     opj_read_bytes(l_current_ptr, &l_tccp->cblkh, 1);               /* SPcoc (F) */
9701     ++l_current_ptr;
9702     l_tccp->cblkh += 2;
9703
9704     if ((l_tccp->cblkw > 10) || (l_tccp->cblkh > 10) ||
9705             ((l_tccp->cblkw + l_tccp->cblkh) > 12)) {
9706         opj_event_msg(p_manager, EVT_ERROR,
9707                       "Error reading SPCod SPCoc element, Invalid cblkw/cblkh combination\n");
9708         return OPJ_FALSE;
9709     }
9710
9711
9712     opj_read_bytes(l_current_ptr, &l_tccp->cblksty, 1);             /* SPcoc (G) */
9713     ++l_current_ptr;
9714     if (l_tccp->cblksty & 0xC0U) { /* 2 msb are reserved, assume we can't read */
9715         opj_event_msg(p_manager, EVT_ERROR,
9716                       "Error reading SPCod SPCoc element, Invalid code-block style found\n");
9717         return OPJ_FALSE;
9718     }
9719
9720     opj_read_bytes(l_current_ptr, &l_tccp->qmfbid, 1);              /* SPcoc (H) */
9721     ++l_current_ptr;
9722
9723     *p_header_size = *p_header_size - 5;
9724
9725     /* use custom precinct size ? */
9726     if (l_tccp->csty & J2K_CCP_CSTY_PRT) {
9727         if (*p_header_size < l_tccp->numresolutions) {
9728             opj_event_msg(p_manager, EVT_ERROR, "Error reading SPCod SPCoc element\n");
9729             return OPJ_FALSE;
9730         }
9731
9732         for (i = 0; i < l_tccp->numresolutions; ++i) {
9733             opj_read_bytes(l_current_ptr, &l_tmp, 1);               /* SPcoc (I_i) */
9734             ++l_current_ptr;
9735             /* Precinct exponent 0 is only allowed for lowest resolution level (Table A.21) */
9736             if ((i != 0) && (((l_tmp & 0xf) == 0) || ((l_tmp >> 4) == 0))) {
9737                 opj_event_msg(p_manager, EVT_ERROR, "Invalid precinct size\n");
9738                 return OPJ_FALSE;
9739             }
9740             l_tccp->prcw[i] = l_tmp & 0xf;
9741             l_tccp->prch[i] = l_tmp >> 4;
9742         }
9743
9744         *p_header_size = *p_header_size - l_tccp->numresolutions;
9745     } else {
9746         /* set default size for the precinct width and height */
9747         for (i = 0; i < l_tccp->numresolutions; ++i) {
9748             l_tccp->prcw[i] = 15;
9749             l_tccp->prch[i] = 15;
9750         }
9751     }
9752
9753 #ifdef WIP_REMOVE_MSD
9754     /* INDEX >> */
9755     if (p_j2k->cstr_info && compno == 0) {
9756         OPJ_UINT32 l_data_size = l_tccp->numresolutions * sizeof(OPJ_UINT32);
9757
9758         p_j2k->cstr_info->tile[p_j2k->m_current_tile_number].tccp_info[compno].cblkh =
9759             l_tccp->cblkh;
9760         p_j2k->cstr_info->tile[p_j2k->m_current_tile_number].tccp_info[compno].cblkw =
9761             l_tccp->cblkw;
9762         p_j2k->cstr_info->tile[p_j2k->m_current_tile_number].tccp_info[compno].numresolutions
9763             = l_tccp->numresolutions;
9764         p_j2k->cstr_info->tile[p_j2k->m_current_tile_number].tccp_info[compno].cblksty =
9765             l_tccp->cblksty;
9766         p_j2k->cstr_info->tile[p_j2k->m_current_tile_number].tccp_info[compno].qmfbid =
9767             l_tccp->qmfbid;
9768
9769         memcpy(p_j2k->cstr_info->tile[p_j2k->m_current_tile_number].pdx, l_tccp->prcw,
9770                l_data_size);
9771         memcpy(p_j2k->cstr_info->tile[p_j2k->m_current_tile_number].pdy, l_tccp->prch,
9772                l_data_size);
9773     }
9774     /* << INDEX */
9775 #endif
9776
9777     return OPJ_TRUE;
9778 }
9779
9780 static void opj_j2k_copy_tile_component_parameters(opj_j2k_t *p_j2k)
9781 {
9782     /* loop */
9783     OPJ_UINT32 i;
9784     opj_cp_t *l_cp = NULL;
9785     opj_tcp_t *l_tcp = NULL;
9786     opj_tccp_t *l_ref_tccp = NULL, *l_copied_tccp = NULL;
9787     OPJ_UINT32 l_prc_size;
9788
9789     /* preconditions */
9790     assert(p_j2k != 00);
9791
9792     l_cp = &(p_j2k->m_cp);
9793     l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH)
9794             ?
9795             &l_cp->tcps[p_j2k->m_current_tile_number] :
9796             p_j2k->m_specific_param.m_decoder.m_default_tcp;
9797
9798     l_ref_tccp = &l_tcp->tccps[0];
9799     l_copied_tccp = l_ref_tccp + 1;
9800     l_prc_size = l_ref_tccp->numresolutions * (OPJ_UINT32)sizeof(OPJ_UINT32);
9801
9802     for (i = 1; i < p_j2k->m_private_image->numcomps; ++i) {
9803         l_copied_tccp->numresolutions = l_ref_tccp->numresolutions;
9804         l_copied_tccp->cblkw = l_ref_tccp->cblkw;
9805         l_copied_tccp->cblkh = l_ref_tccp->cblkh;
9806         l_copied_tccp->cblksty = l_ref_tccp->cblksty;
9807         l_copied_tccp->qmfbid = l_ref_tccp->qmfbid;
9808         memcpy(l_copied_tccp->prcw, l_ref_tccp->prcw, l_prc_size);
9809         memcpy(l_copied_tccp->prch, l_ref_tccp->prch, l_prc_size);
9810         ++l_copied_tccp;
9811     }
9812 }
9813
9814 static OPJ_UINT32 opj_j2k_get_SQcd_SQcc_size(opj_j2k_t *p_j2k,
9815         OPJ_UINT32 p_tile_no,
9816         OPJ_UINT32 p_comp_no)
9817 {
9818     OPJ_UINT32 l_num_bands;
9819
9820     opj_cp_t *l_cp = 00;
9821     opj_tcp_t *l_tcp = 00;
9822     opj_tccp_t *l_tccp = 00;
9823
9824     /* preconditions */
9825     assert(p_j2k != 00);
9826
9827     l_cp = &(p_j2k->m_cp);
9828     l_tcp = &l_cp->tcps[p_tile_no];
9829     l_tccp = &l_tcp->tccps[p_comp_no];
9830
9831     /* preconditions again */
9832     assert(p_tile_no < l_cp->tw * l_cp->th);
9833     assert(p_comp_no < p_j2k->m_private_image->numcomps);
9834
9835     l_num_bands = (l_tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) ? 1 :
9836                   (l_tccp->numresolutions * 3 - 2);
9837
9838     if (l_tccp->qntsty == J2K_CCP_QNTSTY_NOQNT)  {
9839         return 1 + l_num_bands;
9840     } else {
9841         return 1 + 2 * l_num_bands;
9842     }
9843 }
9844
9845 static OPJ_BOOL opj_j2k_compare_SQcd_SQcc(opj_j2k_t *p_j2k,
9846         OPJ_UINT32 p_tile_no, OPJ_UINT32 p_first_comp_no, OPJ_UINT32 p_second_comp_no)
9847 {
9848     opj_cp_t *l_cp = NULL;
9849     opj_tcp_t *l_tcp = NULL;
9850     opj_tccp_t *l_tccp0 = NULL;
9851     opj_tccp_t *l_tccp1 = NULL;
9852     OPJ_UINT32 l_band_no, l_num_bands;
9853
9854     /* preconditions */
9855     assert(p_j2k != 00);
9856
9857     l_cp = &(p_j2k->m_cp);
9858     l_tcp = &l_cp->tcps[p_tile_no];
9859     l_tccp0 = &l_tcp->tccps[p_first_comp_no];
9860     l_tccp1 = &l_tcp->tccps[p_second_comp_no];
9861
9862     if (l_tccp0->qntsty != l_tccp1->qntsty) {
9863         return OPJ_FALSE;
9864     }
9865     if (l_tccp0->numgbits != l_tccp1->numgbits) {
9866         return OPJ_FALSE;
9867     }
9868     if (l_tccp0->qntsty == J2K_CCP_QNTSTY_SIQNT) {
9869         l_num_bands = 1U;
9870     } else {
9871         l_num_bands = l_tccp0->numresolutions * 3U - 2U;
9872         if (l_num_bands != (l_tccp1->numresolutions * 3U - 2U)) {
9873             return OPJ_FALSE;
9874         }
9875     }
9876
9877     for (l_band_no = 0; l_band_no < l_num_bands; ++l_band_no) {
9878         if (l_tccp0->stepsizes[l_band_no].expn != l_tccp1->stepsizes[l_band_no].expn) {
9879             return OPJ_FALSE;
9880         }
9881     }
9882     if (l_tccp0->qntsty != J2K_CCP_QNTSTY_NOQNT) {
9883         for (l_band_no = 0; l_band_no < l_num_bands; ++l_band_no) {
9884             if (l_tccp0->stepsizes[l_band_no].mant != l_tccp1->stepsizes[l_band_no].mant) {
9885                 return OPJ_FALSE;
9886             }
9887         }
9888     }
9889     return OPJ_TRUE;
9890 }
9891
9892
9893 static OPJ_BOOL opj_j2k_write_SQcd_SQcc(opj_j2k_t *p_j2k,
9894                                         OPJ_UINT32 p_tile_no,
9895                                         OPJ_UINT32 p_comp_no,
9896                                         OPJ_BYTE * p_data,
9897                                         OPJ_UINT32 * p_header_size,
9898                                         struct opj_event_mgr * p_manager)
9899 {
9900     OPJ_UINT32 l_header_size;
9901     OPJ_UINT32 l_band_no, l_num_bands;
9902     OPJ_UINT32 l_expn, l_mant;
9903
9904     opj_cp_t *l_cp = 00;
9905     opj_tcp_t *l_tcp = 00;
9906     opj_tccp_t *l_tccp = 00;
9907
9908     /* preconditions */
9909     assert(p_j2k != 00);
9910     assert(p_header_size != 00);
9911     assert(p_manager != 00);
9912     assert(p_data != 00);
9913
9914     l_cp = &(p_j2k->m_cp);
9915     l_tcp = &l_cp->tcps[p_tile_no];
9916     l_tccp = &l_tcp->tccps[p_comp_no];
9917
9918     /* preconditions again */
9919     assert(p_tile_no < l_cp->tw * l_cp->th);
9920     assert(p_comp_no < p_j2k->m_private_image->numcomps);
9921
9922     l_num_bands = (l_tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) ? 1 :
9923                   (l_tccp->numresolutions * 3 - 2);
9924
9925     if (l_tccp->qntsty == J2K_CCP_QNTSTY_NOQNT)  {
9926         l_header_size = 1 + l_num_bands;
9927
9928         if (*p_header_size < l_header_size) {
9929             opj_event_msg(p_manager, EVT_ERROR, "Error writing SQcd SQcc element\n");
9930             return OPJ_FALSE;
9931         }
9932
9933         opj_write_bytes(p_data, l_tccp->qntsty + (l_tccp->numgbits << 5),
9934                         1);   /* Sqcx */
9935         ++p_data;
9936
9937         for (l_band_no = 0; l_band_no < l_num_bands; ++l_band_no) {
9938             l_expn = (OPJ_UINT32)l_tccp->stepsizes[l_band_no].expn;
9939             opj_write_bytes(p_data, l_expn << 3, 1);        /* SPqcx_i */
9940             ++p_data;
9941         }
9942     } else {
9943         l_header_size = 1 + 2 * l_num_bands;
9944
9945         if (*p_header_size < l_header_size) {
9946             opj_event_msg(p_manager, EVT_ERROR, "Error writing SQcd SQcc element\n");
9947             return OPJ_FALSE;
9948         }
9949
9950         opj_write_bytes(p_data, l_tccp->qntsty + (l_tccp->numgbits << 5),
9951                         1);   /* Sqcx */
9952         ++p_data;
9953
9954         for (l_band_no = 0; l_band_no < l_num_bands; ++l_band_no) {
9955             l_expn = (OPJ_UINT32)l_tccp->stepsizes[l_band_no].expn;
9956             l_mant = (OPJ_UINT32)l_tccp->stepsizes[l_band_no].mant;
9957
9958             opj_write_bytes(p_data, (l_expn << 11) + l_mant, 2);    /* SPqcx_i */
9959             p_data += 2;
9960         }
9961     }
9962
9963     *p_header_size = *p_header_size - l_header_size;
9964
9965     return OPJ_TRUE;
9966 }
9967
9968 static OPJ_BOOL opj_j2k_read_SQcd_SQcc(opj_j2k_t *p_j2k,
9969                                        OPJ_UINT32 p_comp_no,
9970                                        OPJ_BYTE* p_header_data,
9971                                        OPJ_UINT32 * p_header_size,
9972                                        opj_event_mgr_t * p_manager
9973                                       )
9974 {
9975     /* loop*/
9976     OPJ_UINT32 l_band_no;
9977     opj_cp_t *l_cp = 00;
9978     opj_tcp_t *l_tcp = 00;
9979     opj_tccp_t *l_tccp = 00;
9980     OPJ_BYTE * l_current_ptr = 00;
9981     OPJ_UINT32 l_tmp, l_num_band;
9982
9983     /* preconditions*/
9984     assert(p_j2k != 00);
9985     assert(p_manager != 00);
9986     assert(p_header_data != 00);
9987
9988     l_cp = &(p_j2k->m_cp);
9989     /* come from tile part header or main header ?*/
9990     l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH)
9991             ?
9992             &l_cp->tcps[p_j2k->m_current_tile_number] :
9993             p_j2k->m_specific_param.m_decoder.m_default_tcp;
9994
9995     /* precondition again*/
9996     assert(p_comp_no <  p_j2k->m_private_image->numcomps);
9997
9998     l_tccp = &l_tcp->tccps[p_comp_no];
9999     l_current_ptr = p_header_data;
10000
10001     if (*p_header_size < 1) {
10002         opj_event_msg(p_manager, EVT_ERROR, "Error reading SQcd or SQcc element\n");
10003         return OPJ_FALSE;
10004     }
10005     *p_header_size -= 1;
10006
10007     opj_read_bytes(l_current_ptr, &l_tmp, 1);                       /* Sqcx */
10008     ++l_current_ptr;
10009
10010     l_tccp->qntsty = l_tmp & 0x1f;
10011     l_tccp->numgbits = l_tmp >> 5;
10012     if (l_tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) {
10013         l_num_band = 1;
10014     } else {
10015         l_num_band = (l_tccp->qntsty == J2K_CCP_QNTSTY_NOQNT) ?
10016                      (*p_header_size) :
10017                      (*p_header_size) / 2;
10018
10019         if (l_num_band > OPJ_J2K_MAXBANDS) {
10020             opj_event_msg(p_manager, EVT_WARNING,
10021                           "While reading CCP_QNTSTY element inside QCD or QCC marker segment, "
10022                           "number of subbands (%d) is greater to OPJ_J2K_MAXBANDS (%d). So we limit the number of elements stored to "
10023                           "OPJ_J2K_MAXBANDS (%d) and skip the rest. \n", l_num_band, OPJ_J2K_MAXBANDS,
10024                           OPJ_J2K_MAXBANDS);
10025             /*return OPJ_FALSE;*/
10026         }
10027     }
10028
10029 #ifdef USE_JPWL
10030     if (l_cp->correct) {
10031
10032         /* if JPWL is on, we check whether there are too many subbands */
10033         if (/*(l_num_band < 0) ||*/ (l_num_band >= OPJ_J2K_MAXBANDS)) {
10034             opj_event_msg(p_manager, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
10035                           "JPWL: bad number of subbands in Sqcx (%d)\n",
10036                           l_num_band);
10037             if (!JPWL_ASSUME) {
10038                 opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n");
10039                 return OPJ_FALSE;
10040             }
10041             /* we try to correct */
10042             l_num_band = 1;
10043             opj_event_msg(p_manager, EVT_WARNING, "- trying to adjust them\n"
10044                           "- setting number of bands to %d => HYPOTHESIS!!!\n",
10045                           l_num_band);
10046         };
10047
10048     };
10049 #endif /* USE_JPWL */
10050
10051     if (l_tccp->qntsty == J2K_CCP_QNTSTY_NOQNT) {
10052         for (l_band_no = 0; l_band_no < l_num_band; l_band_no++) {
10053             opj_read_bytes(l_current_ptr, &l_tmp, 1);                       /* SPqcx_i */
10054             ++l_current_ptr;
10055             if (l_band_no < OPJ_J2K_MAXBANDS) {
10056                 l_tccp->stepsizes[l_band_no].expn = (OPJ_INT32)(l_tmp >> 3);
10057                 l_tccp->stepsizes[l_band_no].mant = 0;
10058             }
10059         }
10060         *p_header_size = *p_header_size - l_num_band;
10061     } else {
10062         for (l_band_no = 0; l_band_no < l_num_band; l_band_no++) {
10063             opj_read_bytes(l_current_ptr, &l_tmp, 2);                       /* SPqcx_i */
10064             l_current_ptr += 2;
10065             if (l_band_no < OPJ_J2K_MAXBANDS) {
10066                 l_tccp->stepsizes[l_band_no].expn = (OPJ_INT32)(l_tmp >> 11);
10067                 l_tccp->stepsizes[l_band_no].mant = l_tmp & 0x7ff;
10068             }
10069         }
10070         *p_header_size = *p_header_size - 2 * l_num_band;
10071     }
10072
10073     /* Add Antonin : if scalar_derived -> compute other stepsizes */
10074     if (l_tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) {
10075         for (l_band_no = 1; l_band_no < OPJ_J2K_MAXBANDS; l_band_no++) {
10076             l_tccp->stepsizes[l_band_no].expn =
10077                 ((OPJ_INT32)(l_tccp->stepsizes[0].expn) - (OPJ_INT32)((l_band_no - 1) / 3) > 0)
10078                 ?
10079                 (OPJ_INT32)(l_tccp->stepsizes[0].expn) - (OPJ_INT32)((l_band_no - 1) / 3) : 0;
10080             l_tccp->stepsizes[l_band_no].mant = l_tccp->stepsizes[0].mant;
10081         }
10082     }
10083
10084     return OPJ_TRUE;
10085 }
10086
10087 static void opj_j2k_copy_tile_quantization_parameters(opj_j2k_t *p_j2k)
10088 {
10089     OPJ_UINT32 i;
10090     opj_cp_t *l_cp = NULL;
10091     opj_tcp_t *l_tcp = NULL;
10092     opj_tccp_t *l_ref_tccp = NULL;
10093     opj_tccp_t *l_copied_tccp = NULL;
10094     OPJ_UINT32 l_size;
10095
10096     /* preconditions */
10097     assert(p_j2k != 00);
10098
10099     l_cp = &(p_j2k->m_cp);
10100     l_tcp = p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH ?
10101             &l_cp->tcps[p_j2k->m_current_tile_number] :
10102             p_j2k->m_specific_param.m_decoder.m_default_tcp;
10103
10104     l_ref_tccp = &l_tcp->tccps[0];
10105     l_copied_tccp = l_ref_tccp + 1;
10106     l_size = OPJ_J2K_MAXBANDS * sizeof(opj_stepsize_t);
10107
10108     for (i = 1; i < p_j2k->m_private_image->numcomps; ++i) {
10109         l_copied_tccp->qntsty = l_ref_tccp->qntsty;
10110         l_copied_tccp->numgbits = l_ref_tccp->numgbits;
10111         memcpy(l_copied_tccp->stepsizes, l_ref_tccp->stepsizes, l_size);
10112         ++l_copied_tccp;
10113     }
10114 }
10115
10116 static void opj_j2k_dump_tile_info(opj_tcp_t * l_default_tile,
10117                                    OPJ_INT32 numcomps, FILE* out_stream)
10118 {
10119     if (l_default_tile) {
10120         OPJ_INT32 compno;
10121
10122         fprintf(out_stream, "\t default tile {\n");
10123         fprintf(out_stream, "\t\t csty=%#x\n", l_default_tile->csty);
10124         fprintf(out_stream, "\t\t prg=%#x\n", l_default_tile->prg);
10125         fprintf(out_stream, "\t\t numlayers=%d\n", l_default_tile->numlayers);
10126         fprintf(out_stream, "\t\t mct=%x\n", l_default_tile->mct);
10127
10128         for (compno = 0; compno < numcomps; compno++) {
10129             opj_tccp_t *l_tccp = &(l_default_tile->tccps[compno]);
10130             OPJ_UINT32 resno;
10131             OPJ_INT32 bandno, numbands;
10132
10133             /* coding style*/
10134             fprintf(out_stream, "\t\t comp %d {\n", compno);
10135             fprintf(out_stream, "\t\t\t csty=%#x\n", l_tccp->csty);
10136             fprintf(out_stream, "\t\t\t numresolutions=%d\n", l_tccp->numresolutions);
10137             fprintf(out_stream, "\t\t\t cblkw=2^%d\n", l_tccp->cblkw);
10138             fprintf(out_stream, "\t\t\t cblkh=2^%d\n", l_tccp->cblkh);
10139             fprintf(out_stream, "\t\t\t cblksty=%#x\n", l_tccp->cblksty);
10140             fprintf(out_stream, "\t\t\t qmfbid=%d\n", l_tccp->qmfbid);
10141
10142             fprintf(out_stream, "\t\t\t preccintsize (w,h)=");
10143             for (resno = 0; resno < l_tccp->numresolutions; resno++) {
10144                 fprintf(out_stream, "(%d,%d) ", l_tccp->prcw[resno], l_tccp->prch[resno]);
10145             }
10146             fprintf(out_stream, "\n");
10147
10148             /* quantization style*/
10149             fprintf(out_stream, "\t\t\t qntsty=%d\n", l_tccp->qntsty);
10150             fprintf(out_stream, "\t\t\t numgbits=%d\n", l_tccp->numgbits);
10151             fprintf(out_stream, "\t\t\t stepsizes (m,e)=");
10152             numbands = (l_tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) ? 1 :
10153                        (OPJ_INT32)l_tccp->numresolutions * 3 - 2;
10154             for (bandno = 0; bandno < numbands; bandno++) {
10155                 fprintf(out_stream, "(%d,%d) ", l_tccp->stepsizes[bandno].mant,
10156                         l_tccp->stepsizes[bandno].expn);
10157             }
10158             fprintf(out_stream, "\n");
10159
10160             /* RGN value*/
10161             fprintf(out_stream, "\t\t\t roishift=%d\n", l_tccp->roishift);
10162
10163             fprintf(out_stream, "\t\t }\n");
10164         } /*end of component of default tile*/
10165         fprintf(out_stream, "\t }\n"); /*end of default tile*/
10166     }
10167 }
10168
10169 void j2k_dump(opj_j2k_t* p_j2k, OPJ_INT32 flag, FILE* out_stream)
10170 {
10171     /* Check if the flag is compatible with j2k file*/
10172     if ((flag & OPJ_JP2_INFO) || (flag & OPJ_JP2_IND)) {
10173         fprintf(out_stream, "Wrong flag\n");
10174         return;
10175     }
10176
10177     /* Dump the image_header */
10178     if (flag & OPJ_IMG_INFO) {
10179         if (p_j2k->m_private_image) {
10180             j2k_dump_image_header(p_j2k->m_private_image, 0, out_stream);
10181         }
10182     }
10183
10184     /* Dump the codestream info from main header */
10185     if (flag & OPJ_J2K_MH_INFO) {
10186         if (p_j2k->m_private_image) {
10187             opj_j2k_dump_MH_info(p_j2k, out_stream);
10188         }
10189     }
10190     /* Dump all tile/codestream info */
10191     if (flag & OPJ_J2K_TCH_INFO) {
10192         OPJ_UINT32 l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
10193         OPJ_UINT32 i;
10194         opj_tcp_t * l_tcp = p_j2k->m_cp.tcps;
10195         if (p_j2k->m_private_image) {
10196             for (i = 0; i < l_nb_tiles; ++i) {
10197                 opj_j2k_dump_tile_info(l_tcp, (OPJ_INT32)p_j2k->m_private_image->numcomps,
10198                                        out_stream);
10199                 ++l_tcp;
10200             }
10201         }
10202     }
10203
10204     /* Dump the codestream info of the current tile */
10205     if (flag & OPJ_J2K_TH_INFO) {
10206
10207     }
10208
10209     /* Dump the codestream index from main header */
10210     if (flag & OPJ_J2K_MH_IND) {
10211         opj_j2k_dump_MH_index(p_j2k, out_stream);
10212     }
10213
10214     /* Dump the codestream index of the current tile */
10215     if (flag & OPJ_J2K_TH_IND) {
10216
10217     }
10218
10219 }
10220
10221 static void opj_j2k_dump_MH_index(opj_j2k_t* p_j2k, FILE* out_stream)
10222 {
10223     opj_codestream_index_t* cstr_index = p_j2k->cstr_index;
10224     OPJ_UINT32 it_marker, it_tile, it_tile_part;
10225
10226     fprintf(out_stream, "Codestream index from main header: {\n");
10227
10228     fprintf(out_stream, "\t Main header start position=%" PRIi64 "\n"
10229             "\t Main header end position=%" PRIi64 "\n",
10230             cstr_index->main_head_start, cstr_index->main_head_end);
10231
10232     fprintf(out_stream, "\t Marker list: {\n");
10233
10234     if (cstr_index->marker) {
10235         for (it_marker = 0; it_marker < cstr_index->marknum ; it_marker++) {
10236             fprintf(out_stream, "\t\t type=%#x, pos=%" PRIi64 ", len=%d\n",
10237                     cstr_index->marker[it_marker].type,
10238                     cstr_index->marker[it_marker].pos,
10239                     cstr_index->marker[it_marker].len);
10240         }
10241     }
10242
10243     fprintf(out_stream, "\t }\n");
10244
10245     if (cstr_index->tile_index) {
10246
10247         /* Simple test to avoid to write empty information*/
10248         OPJ_UINT32 l_acc_nb_of_tile_part = 0;
10249         for (it_tile = 0; it_tile < cstr_index->nb_of_tiles ; it_tile++) {
10250             l_acc_nb_of_tile_part += cstr_index->tile_index[it_tile].nb_tps;
10251         }
10252
10253         if (l_acc_nb_of_tile_part) {
10254             fprintf(out_stream, "\t Tile index: {\n");
10255
10256             for (it_tile = 0; it_tile < cstr_index->nb_of_tiles ; it_tile++) {
10257                 OPJ_UINT32 nb_of_tile_part = cstr_index->tile_index[it_tile].nb_tps;
10258
10259                 fprintf(out_stream, "\t\t nb of tile-part in tile [%d]=%d\n", it_tile,
10260                         nb_of_tile_part);
10261
10262                 if (cstr_index->tile_index[it_tile].tp_index) {
10263                     for (it_tile_part = 0; it_tile_part < nb_of_tile_part; it_tile_part++) {
10264                         fprintf(out_stream, "\t\t\t tile-part[%d]: star_pos=%" PRIi64 ", end_header=%"
10265                                 PRIi64 ", end_pos=%" PRIi64 ".\n",
10266                                 it_tile_part,
10267                                 cstr_index->tile_index[it_tile].tp_index[it_tile_part].start_pos,
10268                                 cstr_index->tile_index[it_tile].tp_index[it_tile_part].end_header,
10269                                 cstr_index->tile_index[it_tile].tp_index[it_tile_part].end_pos);
10270                     }
10271                 }
10272
10273                 if (cstr_index->tile_index[it_tile].marker) {
10274                     for (it_marker = 0; it_marker < cstr_index->tile_index[it_tile].marknum ;
10275                             it_marker++) {
10276                         fprintf(out_stream, "\t\t type=%#x, pos=%" PRIi64 ", len=%d\n",
10277                                 cstr_index->tile_index[it_tile].marker[it_marker].type,
10278                                 cstr_index->tile_index[it_tile].marker[it_marker].pos,
10279                                 cstr_index->tile_index[it_tile].marker[it_marker].len);
10280                     }
10281                 }
10282             }
10283             fprintf(out_stream, "\t }\n");
10284         }
10285     }
10286
10287     fprintf(out_stream, "}\n");
10288
10289 }
10290
10291
10292 static void opj_j2k_dump_MH_info(opj_j2k_t* p_j2k, FILE* out_stream)
10293 {
10294
10295     fprintf(out_stream, "Codestream info from main header: {\n");
10296
10297     fprintf(out_stream, "\t tx0=%d, ty0=%d\n", p_j2k->m_cp.tx0, p_j2k->m_cp.ty0);
10298     fprintf(out_stream, "\t tdx=%d, tdy=%d\n", p_j2k->m_cp.tdx, p_j2k->m_cp.tdy);
10299     fprintf(out_stream, "\t tw=%d, th=%d\n", p_j2k->m_cp.tw, p_j2k->m_cp.th);
10300     opj_j2k_dump_tile_info(p_j2k->m_specific_param.m_decoder.m_default_tcp,
10301                            (OPJ_INT32)p_j2k->m_private_image->numcomps, out_stream);
10302     fprintf(out_stream, "}\n");
10303 }
10304
10305 void j2k_dump_image_header(opj_image_t* img_header, OPJ_BOOL dev_dump_flag,
10306                            FILE* out_stream)
10307 {
10308     char tab[2];
10309
10310     if (dev_dump_flag) {
10311         fprintf(stdout, "[DEV] Dump an image_header struct {\n");
10312         tab[0] = '\0';
10313     } else {
10314         fprintf(out_stream, "Image info {\n");
10315         tab[0] = '\t';
10316         tab[1] = '\0';
10317     }
10318
10319     fprintf(out_stream, "%s x0=%d, y0=%d\n", tab, img_header->x0, img_header->y0);
10320     fprintf(out_stream,     "%s x1=%d, y1=%d\n", tab, img_header->x1,
10321             img_header->y1);
10322     fprintf(out_stream, "%s numcomps=%d\n", tab, img_header->numcomps);
10323
10324     if (img_header->comps) {
10325         OPJ_UINT32 compno;
10326         for (compno = 0; compno < img_header->numcomps; compno++) {
10327             fprintf(out_stream, "%s\t component %d {\n", tab, compno);
10328             j2k_dump_image_comp_header(&(img_header->comps[compno]), dev_dump_flag,
10329                                        out_stream);
10330             fprintf(out_stream, "%s}\n", tab);
10331         }
10332     }
10333
10334     fprintf(out_stream, "}\n");
10335 }
10336
10337 void j2k_dump_image_comp_header(opj_image_comp_t* comp_header,
10338                                 OPJ_BOOL dev_dump_flag, FILE* out_stream)
10339 {
10340     char tab[3];
10341
10342     if (dev_dump_flag) {
10343         fprintf(stdout, "[DEV] Dump an image_comp_header struct {\n");
10344         tab[0] = '\0';
10345     }       else {
10346         tab[0] = '\t';
10347         tab[1] = '\t';
10348         tab[2] = '\0';
10349     }
10350
10351     fprintf(out_stream, "%s dx=%d, dy=%d\n", tab, comp_header->dx, comp_header->dy);
10352     fprintf(out_stream, "%s prec=%d\n", tab, comp_header->prec);
10353     fprintf(out_stream, "%s sgnd=%d\n", tab, comp_header->sgnd);
10354
10355     if (dev_dump_flag) {
10356         fprintf(out_stream, "}\n");
10357     }
10358 }
10359
10360 opj_codestream_info_v2_t* j2k_get_cstr_info(opj_j2k_t* p_j2k)
10361 {
10362     OPJ_UINT32 compno;
10363     OPJ_UINT32 numcomps = p_j2k->m_private_image->numcomps;
10364     opj_tcp_t *l_default_tile;
10365     opj_codestream_info_v2_t* cstr_info = (opj_codestream_info_v2_t*) opj_calloc(1,
10366                                           sizeof(opj_codestream_info_v2_t));
10367     if (!cstr_info) {
10368         return NULL;
10369     }
10370
10371     cstr_info->nbcomps = p_j2k->m_private_image->numcomps;
10372
10373     cstr_info->tx0 = p_j2k->m_cp.tx0;
10374     cstr_info->ty0 = p_j2k->m_cp.ty0;
10375     cstr_info->tdx = p_j2k->m_cp.tdx;
10376     cstr_info->tdy = p_j2k->m_cp.tdy;
10377     cstr_info->tw = p_j2k->m_cp.tw;
10378     cstr_info->th = p_j2k->m_cp.th;
10379
10380     cstr_info->tile_info = NULL; /* Not fill from the main header*/
10381
10382     l_default_tile = p_j2k->m_specific_param.m_decoder.m_default_tcp;
10383
10384     cstr_info->m_default_tile_info.csty = l_default_tile->csty;
10385     cstr_info->m_default_tile_info.prg = l_default_tile->prg;
10386     cstr_info->m_default_tile_info.numlayers = l_default_tile->numlayers;
10387     cstr_info->m_default_tile_info.mct = l_default_tile->mct;
10388
10389     cstr_info->m_default_tile_info.tccp_info = (opj_tccp_info_t*) opj_calloc(
10390                 cstr_info->nbcomps, sizeof(opj_tccp_info_t));
10391     if (!cstr_info->m_default_tile_info.tccp_info) {
10392         opj_destroy_cstr_info(&cstr_info);
10393         return NULL;
10394     }
10395
10396     for (compno = 0; compno < numcomps; compno++) {
10397         opj_tccp_t *l_tccp = &(l_default_tile->tccps[compno]);
10398         opj_tccp_info_t *l_tccp_info = &
10399                                        (cstr_info->m_default_tile_info.tccp_info[compno]);
10400         OPJ_INT32 bandno, numbands;
10401
10402         /* coding style*/
10403         l_tccp_info->csty = l_tccp->csty;
10404         l_tccp_info->numresolutions = l_tccp->numresolutions;
10405         l_tccp_info->cblkw = l_tccp->cblkw;
10406         l_tccp_info->cblkh = l_tccp->cblkh;
10407         l_tccp_info->cblksty = l_tccp->cblksty;
10408         l_tccp_info->qmfbid = l_tccp->qmfbid;
10409         if (l_tccp->numresolutions < OPJ_J2K_MAXRLVLS) {
10410             memcpy(l_tccp_info->prch, l_tccp->prch, l_tccp->numresolutions);
10411             memcpy(l_tccp_info->prcw, l_tccp->prcw, l_tccp->numresolutions);
10412         }
10413
10414         /* quantization style*/
10415         l_tccp_info->qntsty = l_tccp->qntsty;
10416         l_tccp_info->numgbits = l_tccp->numgbits;
10417
10418         numbands = (l_tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) ? 1 :
10419                    (OPJ_INT32)l_tccp->numresolutions * 3 - 2;
10420         if (numbands < OPJ_J2K_MAXBANDS) {
10421             for (bandno = 0; bandno < numbands; bandno++) {
10422                 l_tccp_info->stepsizes_mant[bandno] = (OPJ_UINT32)
10423                                                       l_tccp->stepsizes[bandno].mant;
10424                 l_tccp_info->stepsizes_expn[bandno] = (OPJ_UINT32)
10425                                                       l_tccp->stepsizes[bandno].expn;
10426             }
10427         }
10428
10429         /* RGN value*/
10430         l_tccp_info->roishift = l_tccp->roishift;
10431     }
10432
10433     return cstr_info;
10434 }
10435
10436 opj_codestream_index_t* j2k_get_cstr_index(opj_j2k_t* p_j2k)
10437 {
10438     opj_codestream_index_t* l_cstr_index = (opj_codestream_index_t*)
10439                                            opj_calloc(1, sizeof(opj_codestream_index_t));
10440     if (!l_cstr_index) {
10441         return NULL;
10442     }
10443
10444     l_cstr_index->main_head_start = p_j2k->cstr_index->main_head_start;
10445     l_cstr_index->main_head_end = p_j2k->cstr_index->main_head_end;
10446     l_cstr_index->codestream_size = p_j2k->cstr_index->codestream_size;
10447
10448     l_cstr_index->marknum = p_j2k->cstr_index->marknum;
10449     l_cstr_index->marker = (opj_marker_info_t*)opj_malloc(l_cstr_index->marknum *
10450                            sizeof(opj_marker_info_t));
10451     if (!l_cstr_index->marker) {
10452         opj_free(l_cstr_index);
10453         return NULL;
10454     }
10455
10456     if (p_j2k->cstr_index->marker) {
10457         memcpy(l_cstr_index->marker, p_j2k->cstr_index->marker,
10458                l_cstr_index->marknum * sizeof(opj_marker_info_t));
10459     } else {
10460         opj_free(l_cstr_index->marker);
10461         l_cstr_index->marker = NULL;
10462     }
10463
10464     l_cstr_index->nb_of_tiles = p_j2k->cstr_index->nb_of_tiles;
10465     l_cstr_index->tile_index = (opj_tile_index_t*)opj_calloc(
10466                                    l_cstr_index->nb_of_tiles, sizeof(opj_tile_index_t));
10467     if (!l_cstr_index->tile_index) {
10468         opj_free(l_cstr_index->marker);
10469         opj_free(l_cstr_index);
10470         return NULL;
10471     }
10472
10473     if (!p_j2k->cstr_index->tile_index) {
10474         opj_free(l_cstr_index->tile_index);
10475         l_cstr_index->tile_index = NULL;
10476     } else {
10477         OPJ_UINT32 it_tile = 0;
10478         for (it_tile = 0; it_tile < l_cstr_index->nb_of_tiles; it_tile++) {
10479
10480             /* Tile Marker*/
10481             l_cstr_index->tile_index[it_tile].marknum =
10482                 p_j2k->cstr_index->tile_index[it_tile].marknum;
10483
10484             l_cstr_index->tile_index[it_tile].marker =
10485                 (opj_marker_info_t*)opj_malloc(l_cstr_index->tile_index[it_tile].marknum *
10486                                                sizeof(opj_marker_info_t));
10487
10488             if (!l_cstr_index->tile_index[it_tile].marker) {
10489                 OPJ_UINT32 it_tile_free;
10490
10491                 for (it_tile_free = 0; it_tile_free < it_tile; it_tile_free++) {
10492                     opj_free(l_cstr_index->tile_index[it_tile_free].marker);
10493                 }
10494
10495                 opj_free(l_cstr_index->tile_index);
10496                 opj_free(l_cstr_index->marker);
10497                 opj_free(l_cstr_index);
10498                 return NULL;
10499             }
10500
10501             if (p_j2k->cstr_index->tile_index[it_tile].marker)
10502                 memcpy(l_cstr_index->tile_index[it_tile].marker,
10503                        p_j2k->cstr_index->tile_index[it_tile].marker,
10504                        l_cstr_index->tile_index[it_tile].marknum * sizeof(opj_marker_info_t));
10505             else {
10506                 opj_free(l_cstr_index->tile_index[it_tile].marker);
10507                 l_cstr_index->tile_index[it_tile].marker = NULL;
10508             }
10509
10510             /* Tile part index*/
10511             l_cstr_index->tile_index[it_tile].nb_tps =
10512                 p_j2k->cstr_index->tile_index[it_tile].nb_tps;
10513
10514             l_cstr_index->tile_index[it_tile].tp_index =
10515                 (opj_tp_index_t*)opj_malloc(l_cstr_index->tile_index[it_tile].nb_tps * sizeof(
10516                                                 opj_tp_index_t));
10517
10518             if (!l_cstr_index->tile_index[it_tile].tp_index) {
10519                 OPJ_UINT32 it_tile_free;
10520
10521                 for (it_tile_free = 0; it_tile_free < it_tile; it_tile_free++) {
10522                     opj_free(l_cstr_index->tile_index[it_tile_free].marker);
10523                     opj_free(l_cstr_index->tile_index[it_tile_free].tp_index);
10524                 }
10525
10526                 opj_free(l_cstr_index->tile_index);
10527                 opj_free(l_cstr_index->marker);
10528                 opj_free(l_cstr_index);
10529                 return NULL;
10530             }
10531
10532             if (p_j2k->cstr_index->tile_index[it_tile].tp_index) {
10533                 memcpy(l_cstr_index->tile_index[it_tile].tp_index,
10534                        p_j2k->cstr_index->tile_index[it_tile].tp_index,
10535                        l_cstr_index->tile_index[it_tile].nb_tps * sizeof(opj_tp_index_t));
10536             } else {
10537                 opj_free(l_cstr_index->tile_index[it_tile].tp_index);
10538                 l_cstr_index->tile_index[it_tile].tp_index = NULL;
10539             }
10540
10541             /* Packet index (NOT USED)*/
10542             l_cstr_index->tile_index[it_tile].nb_packet = 0;
10543             l_cstr_index->tile_index[it_tile].packet_index = NULL;
10544
10545         }
10546     }
10547
10548     return l_cstr_index;
10549 }
10550
10551 static OPJ_BOOL opj_j2k_allocate_tile_element_cstr_index(opj_j2k_t *p_j2k)
10552 {
10553     OPJ_UINT32 it_tile = 0;
10554
10555     p_j2k->cstr_index->nb_of_tiles = p_j2k->m_cp.tw * p_j2k->m_cp.th;
10556     p_j2k->cstr_index->tile_index = (opj_tile_index_t*)opj_calloc(
10557                                         p_j2k->cstr_index->nb_of_tiles, sizeof(opj_tile_index_t));
10558     if (!p_j2k->cstr_index->tile_index) {
10559         return OPJ_FALSE;
10560     }
10561
10562     for (it_tile = 0; it_tile < p_j2k->cstr_index->nb_of_tiles; it_tile++) {
10563         p_j2k->cstr_index->tile_index[it_tile].maxmarknum = 100;
10564         p_j2k->cstr_index->tile_index[it_tile].marknum = 0;
10565         p_j2k->cstr_index->tile_index[it_tile].marker = (opj_marker_info_t*)
10566                 opj_calloc(p_j2k->cstr_index->tile_index[it_tile].maxmarknum,
10567                            sizeof(opj_marker_info_t));
10568         if (!p_j2k->cstr_index->tile_index[it_tile].marker) {
10569             return OPJ_FALSE;
10570         }
10571     }
10572
10573     return OPJ_TRUE;
10574 }
10575
10576 static OPJ_BOOL opj_j2k_decode_tiles(opj_j2k_t *p_j2k,
10577                                      opj_stream_private_t *p_stream,
10578                                      opj_event_mgr_t * p_manager)
10579 {
10580     OPJ_BOOL l_go_on = OPJ_TRUE;
10581     OPJ_UINT32 l_current_tile_no;
10582     OPJ_UINT32 l_data_size, l_max_data_size;
10583     OPJ_INT32 l_tile_x0, l_tile_y0, l_tile_x1, l_tile_y1;
10584     OPJ_UINT32 l_nb_comps;
10585     OPJ_BYTE * l_current_data;
10586     OPJ_UINT32 nr_tiles = 0;
10587
10588     /* Particular case for whole single tile decoding */
10589     /* We can avoid allocating intermediate tile buffers */
10590     if (p_j2k->m_cp.tw == 1 && p_j2k->m_cp.th == 1 &&
10591             p_j2k->m_cp.tx0 == 0 && p_j2k->m_cp.ty0 == 0 &&
10592             p_j2k->m_output_image->x0 == 0 &&
10593             p_j2k->m_output_image->y0 == 0 &&
10594             p_j2k->m_output_image->x1 == p_j2k->m_cp.tdx &&
10595             p_j2k->m_output_image->y1 == p_j2k->m_cp.tdy &&
10596             p_j2k->m_output_image->comps[0].factor == 0) {
10597         OPJ_UINT32 i;
10598         if (! opj_j2k_read_tile_header(p_j2k,
10599                                        &l_current_tile_no,
10600                                        &l_data_size,
10601                                        &l_tile_x0, &l_tile_y0,
10602                                        &l_tile_x1, &l_tile_y1,
10603                                        &l_nb_comps,
10604                                        &l_go_on,
10605                                        p_stream,
10606                                        p_manager)) {
10607             return OPJ_FALSE;
10608         }
10609
10610         if (! opj_j2k_decode_tile(p_j2k, l_current_tile_no, NULL, 0,
10611                                   p_stream, p_manager)) {
10612             opj_event_msg(p_manager, EVT_ERROR, "Failed to decode tile 1/1\n");
10613             return OPJ_FALSE;
10614         }
10615
10616         /* Transfer TCD data to output image data */
10617         for (i = 0; i < p_j2k->m_output_image->numcomps; i++) {
10618             opj_image_data_free(p_j2k->m_output_image->comps[i].data);
10619             p_j2k->m_output_image->comps[i].data =
10620                 p_j2k->m_tcd->tcd_image->tiles->comps[i].data;
10621             p_j2k->m_output_image->comps[i].resno_decoded =
10622                 p_j2k->m_tcd->image->comps[i].resno_decoded;
10623             p_j2k->m_tcd->tcd_image->tiles->comps[i].data = NULL;
10624         }
10625
10626         return OPJ_TRUE;
10627     }
10628
10629     l_current_data = (OPJ_BYTE*)opj_malloc(1000);
10630     if (! l_current_data) {
10631         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to decode tiles\n");
10632         return OPJ_FALSE;
10633     }
10634     l_max_data_size = 1000;
10635
10636     for (;;) {
10637         if (! opj_j2k_read_tile_header(p_j2k,
10638                                        &l_current_tile_no,
10639                                        &l_data_size,
10640                                        &l_tile_x0, &l_tile_y0,
10641                                        &l_tile_x1, &l_tile_y1,
10642                                        &l_nb_comps,
10643                                        &l_go_on,
10644                                        p_stream,
10645                                        p_manager)) {
10646             opj_free(l_current_data);
10647             return OPJ_FALSE;
10648         }
10649
10650         if (! l_go_on) {
10651             break;
10652         }
10653
10654         if (l_data_size > l_max_data_size) {
10655             OPJ_BYTE *l_new_current_data = (OPJ_BYTE *) opj_realloc(l_current_data,
10656                                            l_data_size);
10657             if (! l_new_current_data) {
10658                 opj_free(l_current_data);
10659                 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to decode tile %d/%d\n",
10660                               l_current_tile_no + 1, p_j2k->m_cp.th * p_j2k->m_cp.tw);
10661                 return OPJ_FALSE;
10662             }
10663             l_current_data = l_new_current_data;
10664             l_max_data_size = l_data_size;
10665         }
10666
10667         if (! opj_j2k_decode_tile(p_j2k, l_current_tile_no, l_current_data, l_data_size,
10668                                   p_stream, p_manager)) {
10669             opj_free(l_current_data);
10670             opj_event_msg(p_manager, EVT_ERROR, "Failed to decode tile %d/%d\n",
10671                           l_current_tile_no + 1, p_j2k->m_cp.th * p_j2k->m_cp.tw);
10672             return OPJ_FALSE;
10673         }
10674         opj_event_msg(p_manager, EVT_INFO, "Tile %d/%d has been decoded.\n",
10675                       l_current_tile_no + 1, p_j2k->m_cp.th * p_j2k->m_cp.tw);
10676
10677         if (! opj_j2k_update_image_data(p_j2k->m_tcd, l_current_data,
10678                                         p_j2k->m_output_image)) {
10679             opj_free(l_current_data);
10680             return OPJ_FALSE;
10681         }
10682         opj_event_msg(p_manager, EVT_INFO,
10683                       "Image data has been updated with tile %d.\n\n", l_current_tile_no + 1);
10684
10685         if (opj_stream_get_number_byte_left(p_stream) == 0
10686                 && p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_NEOC) {
10687             break;
10688         }
10689         if (++nr_tiles ==  p_j2k->m_cp.th * p_j2k->m_cp.tw) {
10690             break;
10691         }
10692     }
10693
10694     opj_free(l_current_data);
10695
10696     return OPJ_TRUE;
10697 }
10698
10699 /**
10700  * Sets up the procedures to do on decoding data. Developpers wanting to extend the library can add their own reading procedures.
10701  */
10702 static OPJ_BOOL opj_j2k_setup_decoding(opj_j2k_t *p_j2k,
10703                                        opj_event_mgr_t * p_manager)
10704 {
10705     /* preconditions*/
10706     assert(p_j2k != 00);
10707     assert(p_manager != 00);
10708
10709     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
10710                                            (opj_procedure)opj_j2k_decode_tiles, p_manager)) {
10711         return OPJ_FALSE;
10712     }
10713     /* DEVELOPER CORNER, add your custom procedures */
10714
10715     return OPJ_TRUE;
10716 }
10717
10718 /*
10719  * Read and decode one tile.
10720  */
10721 static OPJ_BOOL opj_j2k_decode_one_tile(opj_j2k_t *p_j2k,
10722                                         opj_stream_private_t *p_stream,
10723                                         opj_event_mgr_t * p_manager)
10724 {
10725     OPJ_BOOL l_go_on = OPJ_TRUE;
10726     OPJ_UINT32 l_current_tile_no;
10727     OPJ_UINT32 l_tile_no_to_dec;
10728     OPJ_UINT32 l_data_size, l_max_data_size;
10729     OPJ_INT32 l_tile_x0, l_tile_y0, l_tile_x1, l_tile_y1;
10730     OPJ_UINT32 l_nb_comps;
10731     OPJ_BYTE * l_current_data;
10732     OPJ_UINT32 l_nb_tiles;
10733     OPJ_UINT32 i;
10734
10735     l_current_data = (OPJ_BYTE*)opj_malloc(1000);
10736     if (! l_current_data) {
10737         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to decode one tile\n");
10738         return OPJ_FALSE;
10739     }
10740     l_max_data_size = 1000;
10741
10742     /*Allocate and initialize some elements of codestrem index if not already done*/
10743     if (!p_j2k->cstr_index->tile_index) {
10744         if (!opj_j2k_allocate_tile_element_cstr_index(p_j2k)) {
10745             opj_free(l_current_data);
10746             return OPJ_FALSE;
10747         }
10748     }
10749     /* Move into the codestream to the first SOT used to decode the desired tile */
10750     l_tile_no_to_dec = (OPJ_UINT32)
10751                        p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec;
10752     if (p_j2k->cstr_index->tile_index)
10753         if (p_j2k->cstr_index->tile_index->tp_index) {
10754             if (! p_j2k->cstr_index->tile_index[l_tile_no_to_dec].nb_tps) {
10755                 /* the index for this tile has not been built,
10756                  *  so move to the last SOT read */
10757                 if (!(opj_stream_read_seek(p_stream,
10758                                            p_j2k->m_specific_param.m_decoder.m_last_sot_read_pos + 2, p_manager))) {
10759                     opj_event_msg(p_manager, EVT_ERROR, "Problem with seek function\n");
10760                     opj_free(l_current_data);
10761                     return OPJ_FALSE;
10762                 }
10763             } else {
10764                 if (!(opj_stream_read_seek(p_stream,
10765                                            p_j2k->cstr_index->tile_index[l_tile_no_to_dec].tp_index[0].start_pos + 2,
10766                                            p_manager))) {
10767                     opj_event_msg(p_manager, EVT_ERROR, "Problem with seek function\n");
10768                     opj_free(l_current_data);
10769                     return OPJ_FALSE;
10770                 }
10771             }
10772             /* Special case if we have previously read the EOC marker (if the previous tile getted is the last ) */
10773             if (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_EOC) {
10774                 p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_TPHSOT;
10775             }
10776         }
10777
10778     /* Reset current tile part number for all tiles, and not only the one */
10779     /* of interest. */
10780     /* Not completely sure this is always correct but required for */
10781     /* ./build/bin/j2k_random_tile_access ./build/tests/tte1.j2k */
10782     l_nb_tiles = p_j2k->m_cp.tw * p_j2k->m_cp.th;
10783     for (i = 0; i < l_nb_tiles; ++i) {
10784         p_j2k->m_cp.tcps[i].m_current_tile_part_number = -1;
10785     }
10786
10787     for (;;) {
10788         if (! opj_j2k_read_tile_header(p_j2k,
10789                                        &l_current_tile_no,
10790                                        &l_data_size,
10791                                        &l_tile_x0, &l_tile_y0,
10792                                        &l_tile_x1, &l_tile_y1,
10793                                        &l_nb_comps,
10794                                        &l_go_on,
10795                                        p_stream,
10796                                        p_manager)) {
10797             opj_free(l_current_data);
10798             return OPJ_FALSE;
10799         }
10800
10801         if (! l_go_on) {
10802             break;
10803         }
10804
10805         if (l_data_size > l_max_data_size) {
10806             OPJ_BYTE *l_new_current_data = (OPJ_BYTE *) opj_realloc(l_current_data,
10807                                            l_data_size);
10808             if (! l_new_current_data) {
10809                 opj_free(l_current_data);
10810                 l_current_data = NULL;
10811                 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to decode tile %d/%d\n",
10812                               l_current_tile_no + 1, p_j2k->m_cp.th * p_j2k->m_cp.tw);
10813                 return OPJ_FALSE;
10814             }
10815             l_current_data = l_new_current_data;
10816             l_max_data_size = l_data_size;
10817         }
10818
10819         if (! opj_j2k_decode_tile(p_j2k, l_current_tile_no, l_current_data, l_data_size,
10820                                   p_stream, p_manager)) {
10821             opj_free(l_current_data);
10822             return OPJ_FALSE;
10823         }
10824         opj_event_msg(p_manager, EVT_INFO, "Tile %d/%d has been decoded.\n",
10825                       l_current_tile_no + 1, p_j2k->m_cp.th * p_j2k->m_cp.tw);
10826
10827         if (! opj_j2k_update_image_data(p_j2k->m_tcd, l_current_data,
10828                                         p_j2k->m_output_image)) {
10829             opj_free(l_current_data);
10830             return OPJ_FALSE;
10831         }
10832         opj_event_msg(p_manager, EVT_INFO,
10833                       "Image data has been updated with tile %d.\n\n", l_current_tile_no + 1);
10834
10835         if (l_current_tile_no == l_tile_no_to_dec) {
10836             /* move into the codestream to the first SOT (FIXME or not move?)*/
10837             if (!(opj_stream_read_seek(p_stream, p_j2k->cstr_index->main_head_end + 2,
10838                                        p_manager))) {
10839                 opj_event_msg(p_manager, EVT_ERROR, "Problem with seek function\n");
10840                 opj_free(l_current_data);
10841                 return OPJ_FALSE;
10842             }
10843             break;
10844         } else {
10845             opj_event_msg(p_manager, EVT_WARNING,
10846                           "Tile read, decoded and updated is not the desired one (%d vs %d).\n",
10847                           l_current_tile_no + 1, l_tile_no_to_dec + 1);
10848         }
10849
10850     }
10851
10852     opj_free(l_current_data);
10853
10854     return OPJ_TRUE;
10855 }
10856
10857 /**
10858  * Sets up the procedures to do on decoding one tile. Developpers wanting to extend the library can add their own reading procedures.
10859  */
10860 static OPJ_BOOL opj_j2k_setup_decoding_tile(opj_j2k_t *p_j2k,
10861         opj_event_mgr_t * p_manager)
10862 {
10863     /* preconditions*/
10864     assert(p_j2k != 00);
10865     assert(p_manager != 00);
10866
10867     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
10868                                            (opj_procedure)opj_j2k_decode_one_tile, p_manager)) {
10869         return OPJ_FALSE;
10870     }
10871     /* DEVELOPER CORNER, add your custom procedures */
10872
10873     return OPJ_TRUE;
10874 }
10875
10876 OPJ_BOOL opj_j2k_decode(opj_j2k_t * p_j2k,
10877                         opj_stream_private_t * p_stream,
10878                         opj_image_t * p_image,
10879                         opj_event_mgr_t * p_manager)
10880 {
10881     OPJ_UINT32 compno;
10882
10883     if (!p_image) {
10884         return OPJ_FALSE;
10885     }
10886
10887     /* Heuristics to detect sequence opj_read_header(), opj_set_decoded_resolution_factor() */
10888     /* and finally opj_decode_image() without manual setting of comps[].factor */
10889     /* We could potentially always execute it, if we don't allow people to do */
10890     /* opj_read_header(), modify x0,y0,x1,y1 of returned image an call opj_decode_image() */
10891     if (p_j2k->m_cp.m_specific_param.m_dec.m_reduce > 0 &&
10892             p_j2k->m_private_image != NULL &&
10893             p_j2k->m_private_image->numcomps > 0 &&
10894             p_j2k->m_private_image->comps[0].factor ==
10895             p_j2k->m_cp.m_specific_param.m_dec.m_reduce &&
10896             p_image->numcomps > 0 &&
10897             p_image->comps[0].factor == 0 &&
10898             /* Don't mess with image dimension if the user has allocated it */
10899             p_image->comps[0].data == NULL) {
10900         OPJ_UINT32 it_comp;
10901
10902         /* Update the comps[].factor member of the output image with the one */
10903         /* of m_reduce */
10904         for (it_comp = 0; it_comp < p_image->numcomps; ++it_comp) {
10905             p_image->comps[it_comp].factor = p_j2k->m_cp.m_specific_param.m_dec.m_reduce;
10906         }
10907         if (!opj_j2k_update_image_dimensions(p_image, p_manager)) {
10908             return OPJ_FALSE;
10909         }
10910     }
10911
10912     p_j2k->m_output_image = opj_image_create0();
10913     if (!(p_j2k->m_output_image)) {
10914         return OPJ_FALSE;
10915     }
10916     opj_copy_image_header(p_image, p_j2k->m_output_image);
10917
10918     /* customization of the decoding */
10919     if (!opj_j2k_setup_decoding(p_j2k, p_manager)) {
10920         return OPJ_FALSE;
10921     }
10922
10923     /* Decode the codestream */
10924     if (! opj_j2k_exec(p_j2k, p_j2k->m_procedure_list, p_stream, p_manager)) {
10925         opj_image_destroy(p_j2k->m_private_image);
10926         p_j2k->m_private_image = NULL;
10927         return OPJ_FALSE;
10928     }
10929
10930     /* Move data and copy one information from codec to output image*/
10931     for (compno = 0; compno < p_image->numcomps; compno++) {
10932         p_image->comps[compno].resno_decoded =
10933             p_j2k->m_output_image->comps[compno].resno_decoded;
10934         p_image->comps[compno].data = p_j2k->m_output_image->comps[compno].data;
10935 #if 0
10936         char fn[256];
10937         sprintf(fn, "/tmp/%d.raw", compno);
10938         FILE *debug = fopen(fn, "wb");
10939         fwrite(p_image->comps[compno].data, sizeof(OPJ_INT32),
10940                p_image->comps[compno].w * p_image->comps[compno].h, debug);
10941         fclose(debug);
10942 #endif
10943         p_j2k->m_output_image->comps[compno].data = NULL;
10944     }
10945
10946     return OPJ_TRUE;
10947 }
10948
10949 OPJ_BOOL opj_j2k_get_tile(opj_j2k_t *p_j2k,
10950                           opj_stream_private_t *p_stream,
10951                           opj_image_t* p_image,
10952                           opj_event_mgr_t * p_manager,
10953                           OPJ_UINT32 tile_index)
10954 {
10955     OPJ_UINT32 compno;
10956     OPJ_UINT32 l_tile_x, l_tile_y;
10957     opj_image_comp_t* l_img_comp;
10958
10959     if (!p_image) {
10960         opj_event_msg(p_manager, EVT_ERROR, "We need an image previously created.\n");
10961         return OPJ_FALSE;
10962     }
10963
10964     if (/*(tile_index < 0) &&*/ (tile_index >= p_j2k->m_cp.tw * p_j2k->m_cp.th)) {
10965         opj_event_msg(p_manager, EVT_ERROR,
10966                       "Tile index provided by the user is incorrect %d (max = %d) \n", tile_index,
10967                       (p_j2k->m_cp.tw * p_j2k->m_cp.th) - 1);
10968         return OPJ_FALSE;
10969     }
10970
10971     /* Compute the dimension of the desired tile*/
10972     l_tile_x = tile_index % p_j2k->m_cp.tw;
10973     l_tile_y = tile_index / p_j2k->m_cp.tw;
10974
10975     p_image->x0 = l_tile_x * p_j2k->m_cp.tdx + p_j2k->m_cp.tx0;
10976     if (p_image->x0 < p_j2k->m_private_image->x0) {
10977         p_image->x0 = p_j2k->m_private_image->x0;
10978     }
10979     p_image->x1 = (l_tile_x + 1) * p_j2k->m_cp.tdx + p_j2k->m_cp.tx0;
10980     if (p_image->x1 > p_j2k->m_private_image->x1) {
10981         p_image->x1 = p_j2k->m_private_image->x1;
10982     }
10983
10984     p_image->y0 = l_tile_y * p_j2k->m_cp.tdy + p_j2k->m_cp.ty0;
10985     if (p_image->y0 < p_j2k->m_private_image->y0) {
10986         p_image->y0 = p_j2k->m_private_image->y0;
10987     }
10988     p_image->y1 = (l_tile_y + 1) * p_j2k->m_cp.tdy + p_j2k->m_cp.ty0;
10989     if (p_image->y1 > p_j2k->m_private_image->y1) {
10990         p_image->y1 = p_j2k->m_private_image->y1;
10991     }
10992
10993     l_img_comp = p_image->comps;
10994     for (compno = 0; compno < p_image->numcomps; ++compno) {
10995         OPJ_INT32 l_comp_x1, l_comp_y1;
10996
10997         l_img_comp->factor = p_j2k->m_private_image->comps[compno].factor;
10998
10999         l_img_comp->x0 = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)p_image->x0,
11000                          (OPJ_INT32)l_img_comp->dx);
11001         l_img_comp->y0 = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)p_image->y0,
11002                          (OPJ_INT32)l_img_comp->dy);
11003         l_comp_x1 = opj_int_ceildiv((OPJ_INT32)p_image->x1, (OPJ_INT32)l_img_comp->dx);
11004         l_comp_y1 = opj_int_ceildiv((OPJ_INT32)p_image->y1, (OPJ_INT32)l_img_comp->dy);
11005
11006         l_img_comp->w = (OPJ_UINT32)(opj_int_ceildivpow2(l_comp_x1,
11007                                      (OPJ_INT32)l_img_comp->factor) - opj_int_ceildivpow2((OPJ_INT32)l_img_comp->x0,
11008                                              (OPJ_INT32)l_img_comp->factor));
11009         l_img_comp->h = (OPJ_UINT32)(opj_int_ceildivpow2(l_comp_y1,
11010                                      (OPJ_INT32)l_img_comp->factor) - opj_int_ceildivpow2((OPJ_INT32)l_img_comp->y0,
11011                                              (OPJ_INT32)l_img_comp->factor));
11012
11013         l_img_comp++;
11014     }
11015
11016     /* Destroy the previous output image*/
11017     if (p_j2k->m_output_image) {
11018         opj_image_destroy(p_j2k->m_output_image);
11019     }
11020
11021     /* Create the ouput image from the information previously computed*/
11022     p_j2k->m_output_image = opj_image_create0();
11023     if (!(p_j2k->m_output_image)) {
11024         return OPJ_FALSE;
11025     }
11026     opj_copy_image_header(p_image, p_j2k->m_output_image);
11027
11028     p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec = (OPJ_INT32)tile_index;
11029
11030     /* customization of the decoding */
11031     if (!opj_j2k_setup_decoding_tile(p_j2k, p_manager)) {
11032         return OPJ_FALSE;
11033     }
11034
11035     /* Decode the codestream */
11036     if (! opj_j2k_exec(p_j2k, p_j2k->m_procedure_list, p_stream, p_manager)) {
11037         opj_image_destroy(p_j2k->m_private_image);
11038         p_j2k->m_private_image = NULL;
11039         return OPJ_FALSE;
11040     }
11041
11042     /* Move data and copy one information from codec to output image*/
11043     for (compno = 0; compno < p_image->numcomps; compno++) {
11044         p_image->comps[compno].resno_decoded =
11045             p_j2k->m_output_image->comps[compno].resno_decoded;
11046
11047         if (p_image->comps[compno].data) {
11048             opj_image_data_free(p_image->comps[compno].data);
11049         }
11050
11051         p_image->comps[compno].data = p_j2k->m_output_image->comps[compno].data;
11052
11053         p_j2k->m_output_image->comps[compno].data = NULL;
11054     }
11055
11056     return OPJ_TRUE;
11057 }
11058
11059 OPJ_BOOL opj_j2k_set_decoded_resolution_factor(opj_j2k_t *p_j2k,
11060         OPJ_UINT32 res_factor,
11061         opj_event_mgr_t * p_manager)
11062 {
11063     OPJ_UINT32 it_comp;
11064
11065     p_j2k->m_cp.m_specific_param.m_dec.m_reduce = res_factor;
11066
11067     if (p_j2k->m_private_image) {
11068         if (p_j2k->m_private_image->comps) {
11069             if (p_j2k->m_specific_param.m_decoder.m_default_tcp) {
11070                 if (p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps) {
11071                     for (it_comp = 0 ; it_comp < p_j2k->m_private_image->numcomps; it_comp++) {
11072                         OPJ_UINT32 max_res =
11073                             p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps[it_comp].numresolutions;
11074                         if (res_factor >= max_res) {
11075                             opj_event_msg(p_manager, EVT_ERROR,
11076                                           "Resolution factor is greater than the maximum resolution in the component.\n");
11077                             return OPJ_FALSE;
11078                         }
11079                         p_j2k->m_private_image->comps[it_comp].factor = res_factor;
11080                     }
11081                     return OPJ_TRUE;
11082                 }
11083             }
11084         }
11085     }
11086
11087     return OPJ_FALSE;
11088 }
11089
11090 OPJ_BOOL opj_j2k_encode(opj_j2k_t * p_j2k,
11091                         opj_stream_private_t *p_stream,
11092                         opj_event_mgr_t * p_manager)
11093 {
11094     OPJ_UINT32 i, j;
11095     OPJ_UINT32 l_nb_tiles;
11096     OPJ_UINT32 l_max_tile_size = 0, l_current_tile_size;
11097     OPJ_BYTE * l_current_data = 00;
11098     OPJ_BOOL l_reuse_data = OPJ_FALSE;
11099     opj_tcd_t* p_tcd = 00;
11100
11101     /* preconditions */
11102     assert(p_j2k != 00);
11103     assert(p_stream != 00);
11104     assert(p_manager != 00);
11105
11106     p_tcd = p_j2k->m_tcd;
11107
11108     l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
11109     if (l_nb_tiles == 1) {
11110         l_reuse_data = OPJ_TRUE;
11111 #ifdef __SSE__
11112         for (j = 0; j < p_j2k->m_tcd->image->numcomps; ++j) {
11113             opj_image_comp_t * l_img_comp = p_tcd->image->comps + j;
11114             if (((size_t)l_img_comp->data & 0xFU) !=
11115                     0U) { /* tile data shall be aligned on 16 bytes */
11116                 l_reuse_data = OPJ_FALSE;
11117             }
11118         }
11119 #endif
11120     }
11121     for (i = 0; i < l_nb_tiles; ++i) {
11122         if (! opj_j2k_pre_write_tile(p_j2k, i, p_stream, p_manager)) {
11123             if (l_current_data) {
11124                 opj_free(l_current_data);
11125             }
11126             return OPJ_FALSE;
11127         }
11128
11129         /* if we only have one tile, then simply set tile component data equal to image component data */
11130         /* otherwise, allocate the data */
11131         for (j = 0; j < p_j2k->m_tcd->image->numcomps; ++j) {
11132             opj_tcd_tilecomp_t* l_tilec = p_tcd->tcd_image->tiles->comps + j;
11133             if (l_reuse_data) {
11134                 opj_image_comp_t * l_img_comp = p_tcd->image->comps + j;
11135                 l_tilec->data  =  l_img_comp->data;
11136                 l_tilec->ownsData = OPJ_FALSE;
11137             } else {
11138                 if (! opj_alloc_tile_component_data(l_tilec)) {
11139                     opj_event_msg(p_manager, EVT_ERROR, "Error allocating tile component data.");
11140                     if (l_current_data) {
11141                         opj_free(l_current_data);
11142                     }
11143                     return OPJ_FALSE;
11144                 }
11145             }
11146         }
11147         l_current_tile_size = opj_tcd_get_encoded_tile_size(p_j2k->m_tcd);
11148         if (!l_reuse_data) {
11149             if (l_current_tile_size > l_max_tile_size) {
11150                 OPJ_BYTE *l_new_current_data = (OPJ_BYTE *) opj_realloc(l_current_data,
11151                                                l_current_tile_size);
11152                 if (! l_new_current_data) {
11153                     if (l_current_data) {
11154                         opj_free(l_current_data);
11155                     }
11156                     opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to encode all tiles\n");
11157                     return OPJ_FALSE;
11158                 }
11159                 l_current_data = l_new_current_data;
11160                 l_max_tile_size = l_current_tile_size;
11161             }
11162
11163             /* copy image data (32 bit) to l_current_data as contiguous, all-component, zero offset buffer */
11164             /* 32 bit components @ 8 bit precision get converted to 8 bit */
11165             /* 32 bit components @ 16 bit precision get converted to 16 bit */
11166             opj_j2k_get_tile_data(p_j2k->m_tcd, l_current_data);
11167
11168             /* now copy this data into the tile component */
11169             if (! opj_tcd_copy_tile_data(p_j2k->m_tcd, l_current_data,
11170                                          l_current_tile_size)) {
11171                 opj_event_msg(p_manager, EVT_ERROR,
11172                               "Size mismatch between tile data and sent data.");
11173                 opj_free(l_current_data);
11174                 return OPJ_FALSE;
11175             }
11176         }
11177
11178         if (! opj_j2k_post_write_tile(p_j2k, p_stream, p_manager)) {
11179             if (l_current_data) {
11180                 opj_free(l_current_data);
11181             }
11182             return OPJ_FALSE;
11183         }
11184     }
11185
11186     if (l_current_data) {
11187         opj_free(l_current_data);
11188     }
11189     return OPJ_TRUE;
11190 }
11191
11192 OPJ_BOOL opj_j2k_end_compress(opj_j2k_t *p_j2k,
11193                               opj_stream_private_t *p_stream,
11194                               opj_event_mgr_t * p_manager)
11195 {
11196     /* customization of the encoding */
11197     if (! opj_j2k_setup_end_compress(p_j2k, p_manager)) {
11198         return OPJ_FALSE;
11199     }
11200
11201     if (! opj_j2k_exec(p_j2k, p_j2k->m_procedure_list, p_stream, p_manager)) {
11202         return OPJ_FALSE;
11203     }
11204
11205     return OPJ_TRUE;
11206 }
11207
11208 OPJ_BOOL opj_j2k_start_compress(opj_j2k_t *p_j2k,
11209                                 opj_stream_private_t *p_stream,
11210                                 opj_image_t * p_image,
11211                                 opj_event_mgr_t * p_manager)
11212 {
11213     /* preconditions */
11214     assert(p_j2k != 00);
11215     assert(p_stream != 00);
11216     assert(p_manager != 00);
11217
11218     p_j2k->m_private_image = opj_image_create0();
11219     if (! p_j2k->m_private_image) {
11220         opj_event_msg(p_manager, EVT_ERROR, "Failed to allocate image header.");
11221         return OPJ_FALSE;
11222     }
11223     opj_copy_image_header(p_image, p_j2k->m_private_image);
11224
11225     /* TODO_MSD: Find a better way */
11226     if (p_image->comps) {
11227         OPJ_UINT32 it_comp;
11228         for (it_comp = 0 ; it_comp < p_image->numcomps; it_comp++) {
11229             if (p_image->comps[it_comp].data) {
11230                 p_j2k->m_private_image->comps[it_comp].data = p_image->comps[it_comp].data;
11231                 p_image->comps[it_comp].data = NULL;
11232
11233             }
11234         }
11235     }
11236
11237     /* customization of the validation */
11238     if (! opj_j2k_setup_encoding_validation(p_j2k, p_manager)) {
11239         return OPJ_FALSE;
11240     }
11241
11242     /* validation of the parameters codec */
11243     if (! opj_j2k_exec(p_j2k, p_j2k->m_validation_list, p_stream, p_manager)) {
11244         return OPJ_FALSE;
11245     }
11246
11247     /* customization of the encoding */
11248     if (! opj_j2k_setup_header_writing(p_j2k, p_manager)) {
11249         return OPJ_FALSE;
11250     }
11251
11252     /* write header */
11253     if (! opj_j2k_exec(p_j2k, p_j2k->m_procedure_list, p_stream, p_manager)) {
11254         return OPJ_FALSE;
11255     }
11256
11257     return OPJ_TRUE;
11258 }
11259
11260 static OPJ_BOOL opj_j2k_pre_write_tile(opj_j2k_t * p_j2k,
11261                                        OPJ_UINT32 p_tile_index,
11262                                        opj_stream_private_t *p_stream,
11263                                        opj_event_mgr_t * p_manager)
11264 {
11265     (void)p_stream;
11266     if (p_tile_index != p_j2k->m_current_tile_number) {
11267         opj_event_msg(p_manager, EVT_ERROR, "The given tile index does not match.");
11268         return OPJ_FALSE;
11269     }
11270
11271     opj_event_msg(p_manager, EVT_INFO, "tile number %d / %d\n",
11272                   p_j2k->m_current_tile_number + 1, p_j2k->m_cp.tw * p_j2k->m_cp.th);
11273
11274     p_j2k->m_specific_param.m_encoder.m_current_tile_part_number = 0;
11275     p_j2k->m_tcd->cur_totnum_tp = p_j2k->m_cp.tcps[p_tile_index].m_nb_tile_parts;
11276     p_j2k->m_specific_param.m_encoder.m_current_poc_tile_part_number = 0;
11277
11278     /* initialisation before tile encoding  */
11279     if (! opj_tcd_init_encode_tile(p_j2k->m_tcd, p_j2k->m_current_tile_number,
11280                                    p_manager)) {
11281         return OPJ_FALSE;
11282     }
11283
11284     return OPJ_TRUE;
11285 }
11286
11287 static void opj_get_tile_dimensions(opj_image_t * l_image,
11288                                     opj_tcd_tilecomp_t * l_tilec,
11289                                     opj_image_comp_t * l_img_comp,
11290                                     OPJ_UINT32* l_size_comp,
11291                                     OPJ_UINT32* l_width,
11292                                     OPJ_UINT32* l_height,
11293                                     OPJ_UINT32* l_offset_x,
11294                                     OPJ_UINT32* l_offset_y,
11295                                     OPJ_UINT32* l_image_width,
11296                                     OPJ_UINT32* l_stride,
11297                                     OPJ_UINT32* l_tile_offset)
11298 {
11299     OPJ_UINT32 l_remaining;
11300     *l_size_comp = l_img_comp->prec >> 3; /* (/8) */
11301     l_remaining = l_img_comp->prec & 7;  /* (%8) */
11302     if (l_remaining) {
11303         *l_size_comp += 1;
11304     }
11305
11306     if (*l_size_comp == 3) {
11307         *l_size_comp = 4;
11308     }
11309
11310     *l_width  = (OPJ_UINT32)(l_tilec->x1 - l_tilec->x0);
11311     *l_height = (OPJ_UINT32)(l_tilec->y1 - l_tilec->y0);
11312     *l_offset_x = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)l_image->x0,
11313                   (OPJ_INT32)l_img_comp->dx);
11314     *l_offset_y = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)l_image->y0,
11315                   (OPJ_INT32)l_img_comp->dy);
11316     *l_image_width = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)l_image->x1 -
11317                      (OPJ_INT32)l_image->x0, (OPJ_INT32)l_img_comp->dx);
11318     *l_stride = *l_image_width - *l_width;
11319     *l_tile_offset = ((OPJ_UINT32)l_tilec->x0 - *l_offset_x) + ((
11320                          OPJ_UINT32)l_tilec->y0 - *l_offset_y) * *l_image_width;
11321 }
11322
11323 static void opj_j2k_get_tile_data(opj_tcd_t * p_tcd, OPJ_BYTE * p_data)
11324 {
11325     OPJ_UINT32 i, j, k = 0;
11326
11327     for (i = 0; i < p_tcd->image->numcomps; ++i) {
11328         opj_image_t * l_image =  p_tcd->image;
11329         OPJ_INT32 * l_src_ptr;
11330         opj_tcd_tilecomp_t * l_tilec = p_tcd->tcd_image->tiles->comps + i;
11331         opj_image_comp_t * l_img_comp = l_image->comps + i;
11332         OPJ_UINT32 l_size_comp, l_width, l_height, l_offset_x, l_offset_y,
11333                    l_image_width, l_stride, l_tile_offset;
11334
11335         opj_get_tile_dimensions(l_image,
11336                                 l_tilec,
11337                                 l_img_comp,
11338                                 &l_size_comp,
11339                                 &l_width,
11340                                 &l_height,
11341                                 &l_offset_x,
11342                                 &l_offset_y,
11343                                 &l_image_width,
11344                                 &l_stride,
11345                                 &l_tile_offset);
11346
11347         l_src_ptr = l_img_comp->data + l_tile_offset;
11348
11349         switch (l_size_comp) {
11350         case 1: {
11351             OPJ_CHAR * l_dest_ptr = (OPJ_CHAR*) p_data;
11352             if (l_img_comp->sgnd) {
11353                 for (j = 0; j < l_height; ++j) {
11354                     for (k = 0; k < l_width; ++k) {
11355                         *(l_dest_ptr) = (OPJ_CHAR)(*l_src_ptr);
11356                         ++l_dest_ptr;
11357                         ++l_src_ptr;
11358                     }
11359                     l_src_ptr += l_stride;
11360                 }
11361             } else {
11362                 for (j = 0; j < l_height; ++j) {
11363                     for (k = 0; k < l_width; ++k) {
11364                         *(l_dest_ptr) = (OPJ_CHAR)((*l_src_ptr) & 0xff);
11365                         ++l_dest_ptr;
11366                         ++l_src_ptr;
11367                     }
11368                     l_src_ptr += l_stride;
11369                 }
11370             }
11371
11372             p_data = (OPJ_BYTE*) l_dest_ptr;
11373         }
11374         break;
11375         case 2: {
11376             OPJ_INT16 * l_dest_ptr = (OPJ_INT16 *) p_data;
11377             if (l_img_comp->sgnd) {
11378                 for (j = 0; j < l_height; ++j) {
11379                     for (k = 0; k < l_width; ++k) {
11380                         *(l_dest_ptr++) = (OPJ_INT16)(*(l_src_ptr++));
11381                     }
11382                     l_src_ptr += l_stride;
11383                 }
11384             } else {
11385                 for (j = 0; j < l_height; ++j) {
11386                     for (k = 0; k < l_width; ++k) {
11387                         *(l_dest_ptr++) = (OPJ_INT16)((*(l_src_ptr++)) & 0xffff);
11388                     }
11389                     l_src_ptr += l_stride;
11390                 }
11391             }
11392
11393             p_data = (OPJ_BYTE*) l_dest_ptr;
11394         }
11395         break;
11396         case 4: {
11397             OPJ_INT32 * l_dest_ptr = (OPJ_INT32 *) p_data;
11398             for (j = 0; j < l_height; ++j) {
11399                 for (k = 0; k < l_width; ++k) {
11400                     *(l_dest_ptr++) = *(l_src_ptr++);
11401                 }
11402                 l_src_ptr += l_stride;
11403             }
11404
11405             p_data = (OPJ_BYTE*) l_dest_ptr;
11406         }
11407         break;
11408         }
11409     }
11410 }
11411
11412 static OPJ_BOOL opj_j2k_post_write_tile(opj_j2k_t * p_j2k,
11413                                         opj_stream_private_t *p_stream,
11414                                         opj_event_mgr_t * p_manager)
11415 {
11416     OPJ_UINT32 l_nb_bytes_written;
11417     OPJ_BYTE * l_current_data = 00;
11418     OPJ_UINT32 l_tile_size = 0;
11419     OPJ_UINT32 l_available_data;
11420
11421     /* preconditions */
11422     assert(p_j2k->m_specific_param.m_encoder.m_encoded_tile_data);
11423
11424     l_tile_size = p_j2k->m_specific_param.m_encoder.m_encoded_tile_size;
11425     l_available_data = l_tile_size;
11426     l_current_data = p_j2k->m_specific_param.m_encoder.m_encoded_tile_data;
11427
11428     l_nb_bytes_written = 0;
11429     if (! opj_j2k_write_first_tile_part(p_j2k, l_current_data, &l_nb_bytes_written,
11430                                         l_available_data, p_stream, p_manager)) {
11431         return OPJ_FALSE;
11432     }
11433     l_current_data += l_nb_bytes_written;
11434     l_available_data -= l_nb_bytes_written;
11435
11436     l_nb_bytes_written = 0;
11437     if (! opj_j2k_write_all_tile_parts(p_j2k, l_current_data, &l_nb_bytes_written,
11438                                        l_available_data, p_stream, p_manager)) {
11439         return OPJ_FALSE;
11440     }
11441
11442     l_available_data -= l_nb_bytes_written;
11443     l_nb_bytes_written = l_tile_size - l_available_data;
11444
11445     if (opj_stream_write_data(p_stream,
11446                               p_j2k->m_specific_param.m_encoder.m_encoded_tile_data,
11447                               l_nb_bytes_written, p_manager) != l_nb_bytes_written) {
11448         return OPJ_FALSE;
11449     }
11450
11451     ++p_j2k->m_current_tile_number;
11452
11453     return OPJ_TRUE;
11454 }
11455
11456 static OPJ_BOOL opj_j2k_setup_end_compress(opj_j2k_t *p_j2k,
11457         opj_event_mgr_t * p_manager)
11458 {
11459     /* preconditions */
11460     assert(p_j2k != 00);
11461     assert(p_manager != 00);
11462
11463     /* DEVELOPER CORNER, insert your custom procedures */
11464     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
11465                                            (opj_procedure)opj_j2k_write_eoc, p_manager)) {
11466         return OPJ_FALSE;
11467     }
11468
11469     if (OPJ_IS_CINEMA(p_j2k->m_cp.rsiz)) {
11470         if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
11471                                                (opj_procedure)opj_j2k_write_updated_tlm, p_manager)) {
11472             return OPJ_FALSE;
11473         }
11474     }
11475
11476     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
11477                                            (opj_procedure)opj_j2k_write_epc, p_manager)) {
11478         return OPJ_FALSE;
11479     }
11480     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
11481                                            (opj_procedure)opj_j2k_end_encoding, p_manager)) {
11482         return OPJ_FALSE;
11483     }
11484     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
11485                                            (opj_procedure)opj_j2k_destroy_header_memory, p_manager)) {
11486         return OPJ_FALSE;
11487     }
11488     return OPJ_TRUE;
11489 }
11490
11491 static OPJ_BOOL opj_j2k_setup_encoding_validation(opj_j2k_t *p_j2k,
11492         opj_event_mgr_t * p_manager)
11493 {
11494     /* preconditions */
11495     assert(p_j2k != 00);
11496     assert(p_manager != 00);
11497
11498     if (! opj_procedure_list_add_procedure(p_j2k->m_validation_list,
11499                                            (opj_procedure)opj_j2k_build_encoder, p_manager)) {
11500         return OPJ_FALSE;
11501     }
11502     if (! opj_procedure_list_add_procedure(p_j2k->m_validation_list,
11503                                            (opj_procedure)opj_j2k_encoding_validation, p_manager)) {
11504         return OPJ_FALSE;
11505     }
11506
11507     /* DEVELOPER CORNER, add your custom validation procedure */
11508     if (! opj_procedure_list_add_procedure(p_j2k->m_validation_list,
11509                                            (opj_procedure)opj_j2k_mct_validation, p_manager)) {
11510         return OPJ_FALSE;
11511     }
11512
11513     return OPJ_TRUE;
11514 }
11515
11516 static OPJ_BOOL opj_j2k_setup_header_writing(opj_j2k_t *p_j2k,
11517         opj_event_mgr_t * p_manager)
11518 {
11519     /* preconditions */
11520     assert(p_j2k != 00);
11521     assert(p_manager != 00);
11522
11523     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
11524                                            (opj_procedure)opj_j2k_init_info, p_manager)) {
11525         return OPJ_FALSE;
11526     }
11527     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
11528                                            (opj_procedure)opj_j2k_write_soc, p_manager)) {
11529         return OPJ_FALSE;
11530     }
11531     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
11532                                            (opj_procedure)opj_j2k_write_siz, p_manager)) {
11533         return OPJ_FALSE;
11534     }
11535     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
11536                                            (opj_procedure)opj_j2k_write_cod, p_manager)) {
11537         return OPJ_FALSE;
11538     }
11539     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
11540                                            (opj_procedure)opj_j2k_write_qcd, p_manager)) {
11541         return OPJ_FALSE;
11542     }
11543     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
11544                                            (opj_procedure)opj_j2k_write_all_coc, p_manager)) {
11545         return OPJ_FALSE;
11546     }
11547     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
11548                                            (opj_procedure)opj_j2k_write_all_qcc, p_manager)) {
11549         return OPJ_FALSE;
11550     }
11551
11552     if (OPJ_IS_CINEMA(p_j2k->m_cp.rsiz)) {
11553         if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
11554                                                (opj_procedure)opj_j2k_write_tlm, p_manager)) {
11555             return OPJ_FALSE;
11556         }
11557
11558         if (p_j2k->m_cp.rsiz == OPJ_PROFILE_CINEMA_4K) {
11559             if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
11560                                                    (opj_procedure)opj_j2k_write_poc, p_manager)) {
11561                 return OPJ_FALSE;
11562             }
11563         }
11564     }
11565
11566     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
11567                                            (opj_procedure)opj_j2k_write_regions, p_manager)) {
11568         return OPJ_FALSE;
11569     }
11570
11571     if (p_j2k->m_cp.comment != 00)  {
11572         if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
11573                                                (opj_procedure)opj_j2k_write_com, p_manager)) {
11574             return OPJ_FALSE;
11575         }
11576     }
11577
11578     /* DEVELOPER CORNER, insert your custom procedures */
11579     if (p_j2k->m_cp.rsiz & OPJ_EXTENSION_MCT) {
11580         if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
11581                                                (opj_procedure)opj_j2k_write_mct_data_group, p_manager)) {
11582             return OPJ_FALSE;
11583         }
11584     }
11585     /* End of Developer Corner */
11586
11587     if (p_j2k->cstr_index) {
11588         if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
11589                                                (opj_procedure)opj_j2k_get_end_header, p_manager)) {
11590             return OPJ_FALSE;
11591         }
11592     }
11593
11594     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
11595                                            (opj_procedure)opj_j2k_create_tcd, p_manager)) {
11596         return OPJ_FALSE;
11597     }
11598     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
11599                                            (opj_procedure)opj_j2k_update_rates, p_manager)) {
11600         return OPJ_FALSE;
11601     }
11602
11603     return OPJ_TRUE;
11604 }
11605
11606 static OPJ_BOOL opj_j2k_write_first_tile_part(opj_j2k_t *p_j2k,
11607         OPJ_BYTE * p_data,
11608         OPJ_UINT32 * p_data_written,
11609         OPJ_UINT32 p_total_data_size,
11610         opj_stream_private_t *p_stream,
11611         struct opj_event_mgr * p_manager)
11612 {
11613     OPJ_UINT32 l_nb_bytes_written = 0;
11614     OPJ_UINT32 l_current_nb_bytes_written;
11615     OPJ_BYTE * l_begin_data = 00;
11616
11617     opj_tcd_t * l_tcd = 00;
11618     opj_cp_t * l_cp = 00;
11619
11620     l_tcd = p_j2k->m_tcd;
11621     l_cp = &(p_j2k->m_cp);
11622
11623     l_tcd->cur_pino = 0;
11624
11625     /*Get number of tile parts*/
11626     p_j2k->m_specific_param.m_encoder.m_current_poc_tile_part_number = 0;
11627
11628     /* INDEX >> */
11629     /* << INDEX */
11630
11631     l_current_nb_bytes_written = 0;
11632     l_begin_data = p_data;
11633     if (! opj_j2k_write_sot(p_j2k, p_data, p_total_data_size,
11634                             &l_current_nb_bytes_written, p_stream,
11635                             p_manager)) {
11636         return OPJ_FALSE;
11637     }
11638
11639     l_nb_bytes_written += l_current_nb_bytes_written;
11640     p_data += l_current_nb_bytes_written;
11641     p_total_data_size -= l_current_nb_bytes_written;
11642
11643     if (!OPJ_IS_CINEMA(l_cp->rsiz)) {
11644 #if 0
11645         for (compno = 1; compno < p_j2k->m_private_image->numcomps; compno++) {
11646             l_current_nb_bytes_written = 0;
11647             opj_j2k_write_coc_in_memory(p_j2k, compno, p_data, &l_current_nb_bytes_written,
11648                                         p_manager);
11649             l_nb_bytes_written += l_current_nb_bytes_written;
11650             p_data += l_current_nb_bytes_written;
11651             p_total_data_size -= l_current_nb_bytes_written;
11652
11653             l_current_nb_bytes_written = 0;
11654             opj_j2k_write_qcc_in_memory(p_j2k, compno, p_data, &l_current_nb_bytes_written,
11655                                         p_manager);
11656             l_nb_bytes_written += l_current_nb_bytes_written;
11657             p_data += l_current_nb_bytes_written;
11658             p_total_data_size -= l_current_nb_bytes_written;
11659         }
11660 #endif
11661         if (l_cp->tcps[p_j2k->m_current_tile_number].numpocs) {
11662             l_current_nb_bytes_written = 0;
11663             opj_j2k_write_poc_in_memory(p_j2k, p_data, &l_current_nb_bytes_written,
11664                                         p_manager);
11665             l_nb_bytes_written += l_current_nb_bytes_written;
11666             p_data += l_current_nb_bytes_written;
11667             p_total_data_size -= l_current_nb_bytes_written;
11668         }
11669     }
11670
11671     l_current_nb_bytes_written = 0;
11672     if (! opj_j2k_write_sod(p_j2k, l_tcd, p_data, &l_current_nb_bytes_written,
11673                             p_total_data_size, p_stream, p_manager)) {
11674         return OPJ_FALSE;
11675     }
11676
11677     l_nb_bytes_written += l_current_nb_bytes_written;
11678     * p_data_written = l_nb_bytes_written;
11679
11680     /* Writing Psot in SOT marker */
11681     opj_write_bytes(l_begin_data + 6, l_nb_bytes_written,
11682                     4);                                 /* PSOT */
11683
11684     if (OPJ_IS_CINEMA(l_cp->rsiz)) {
11685         opj_j2k_update_tlm(p_j2k, l_nb_bytes_written);
11686     }
11687
11688     return OPJ_TRUE;
11689 }
11690
11691 static OPJ_BOOL opj_j2k_write_all_tile_parts(opj_j2k_t *p_j2k,
11692         OPJ_BYTE * p_data,
11693         OPJ_UINT32 * p_data_written,
11694         OPJ_UINT32 p_total_data_size,
11695         opj_stream_private_t *p_stream,
11696         struct opj_event_mgr * p_manager
11697                                             )
11698 {
11699     OPJ_UINT32 tilepartno = 0;
11700     OPJ_UINT32 l_nb_bytes_written = 0;
11701     OPJ_UINT32 l_current_nb_bytes_written;
11702     OPJ_UINT32 l_part_tile_size;
11703     OPJ_UINT32 tot_num_tp;
11704     OPJ_UINT32 pino;
11705
11706     OPJ_BYTE * l_begin_data;
11707     opj_tcp_t *l_tcp = 00;
11708     opj_tcd_t * l_tcd = 00;
11709     opj_cp_t * l_cp = 00;
11710
11711     l_tcd = p_j2k->m_tcd;
11712     l_cp = &(p_j2k->m_cp);
11713     l_tcp = l_cp->tcps + p_j2k->m_current_tile_number;
11714
11715     /*Get number of tile parts*/
11716     tot_num_tp = opj_j2k_get_num_tp(l_cp, 0, p_j2k->m_current_tile_number);
11717
11718     /* start writing remaining tile parts */
11719     ++p_j2k->m_specific_param.m_encoder.m_current_tile_part_number;
11720     for (tilepartno = 1; tilepartno < tot_num_tp ; ++tilepartno) {
11721         p_j2k->m_specific_param.m_encoder.m_current_poc_tile_part_number = tilepartno;
11722         l_current_nb_bytes_written = 0;
11723         l_part_tile_size = 0;
11724         l_begin_data = p_data;
11725
11726         if (! opj_j2k_write_sot(p_j2k, p_data,
11727                                 p_total_data_size,
11728                                 &l_current_nb_bytes_written,
11729                                 p_stream,
11730                                 p_manager)) {
11731             return OPJ_FALSE;
11732         }
11733
11734         l_nb_bytes_written += l_current_nb_bytes_written;
11735         p_data += l_current_nb_bytes_written;
11736         p_total_data_size -= l_current_nb_bytes_written;
11737         l_part_tile_size += l_current_nb_bytes_written;
11738
11739         l_current_nb_bytes_written = 0;
11740         if (! opj_j2k_write_sod(p_j2k, l_tcd, p_data, &l_current_nb_bytes_written,
11741                                 p_total_data_size, p_stream, p_manager)) {
11742             return OPJ_FALSE;
11743         }
11744
11745         p_data += l_current_nb_bytes_written;
11746         l_nb_bytes_written += l_current_nb_bytes_written;
11747         p_total_data_size -= l_current_nb_bytes_written;
11748         l_part_tile_size += l_current_nb_bytes_written;
11749
11750         /* Writing Psot in SOT marker */
11751         opj_write_bytes(l_begin_data + 6, l_part_tile_size,
11752                         4);                                   /* PSOT */
11753
11754         if (OPJ_IS_CINEMA(l_cp->rsiz)) {
11755             opj_j2k_update_tlm(p_j2k, l_part_tile_size);
11756         }
11757
11758         ++p_j2k->m_specific_param.m_encoder.m_current_tile_part_number;
11759     }
11760
11761     for (pino = 1; pino <= l_tcp->numpocs; ++pino) {
11762         l_tcd->cur_pino = pino;
11763
11764         /*Get number of tile parts*/
11765         tot_num_tp = opj_j2k_get_num_tp(l_cp, pino, p_j2k->m_current_tile_number);
11766         for (tilepartno = 0; tilepartno < tot_num_tp ; ++tilepartno) {
11767             p_j2k->m_specific_param.m_encoder.m_current_poc_tile_part_number = tilepartno;
11768             l_current_nb_bytes_written = 0;
11769             l_part_tile_size = 0;
11770             l_begin_data = p_data;
11771
11772             if (! opj_j2k_write_sot(p_j2k, p_data,
11773                                     p_total_data_size,
11774                                     &l_current_nb_bytes_written, p_stream,
11775                                     p_manager)) {
11776                 return OPJ_FALSE;
11777             }
11778
11779             l_nb_bytes_written += l_current_nb_bytes_written;
11780             p_data += l_current_nb_bytes_written;
11781             p_total_data_size -= l_current_nb_bytes_written;
11782             l_part_tile_size += l_current_nb_bytes_written;
11783
11784             l_current_nb_bytes_written = 0;
11785
11786             if (! opj_j2k_write_sod(p_j2k, l_tcd, p_data, &l_current_nb_bytes_written,
11787                                     p_total_data_size, p_stream, p_manager)) {
11788                 return OPJ_FALSE;
11789             }
11790
11791             l_nb_bytes_written += l_current_nb_bytes_written;
11792             p_data += l_current_nb_bytes_written;
11793             p_total_data_size -= l_current_nb_bytes_written;
11794             l_part_tile_size += l_current_nb_bytes_written;
11795
11796             /* Writing Psot in SOT marker */
11797             opj_write_bytes(l_begin_data + 6, l_part_tile_size,
11798                             4);                                   /* PSOT */
11799
11800             if (OPJ_IS_CINEMA(l_cp->rsiz)) {
11801                 opj_j2k_update_tlm(p_j2k, l_part_tile_size);
11802             }
11803
11804             ++p_j2k->m_specific_param.m_encoder.m_current_tile_part_number;
11805         }
11806     }
11807
11808     *p_data_written = l_nb_bytes_written;
11809
11810     return OPJ_TRUE;
11811 }
11812
11813 static OPJ_BOOL opj_j2k_write_updated_tlm(opj_j2k_t *p_j2k,
11814         struct opj_stream_private *p_stream,
11815         struct opj_event_mgr * p_manager)
11816 {
11817     OPJ_UINT32 l_tlm_size;
11818     OPJ_OFF_T l_tlm_position, l_current_position;
11819
11820     /* preconditions */
11821     assert(p_j2k != 00);
11822     assert(p_manager != 00);
11823     assert(p_stream != 00);
11824
11825     l_tlm_size = 5 * p_j2k->m_specific_param.m_encoder.m_total_tile_parts;
11826     l_tlm_position = 6 + p_j2k->m_specific_param.m_encoder.m_tlm_start;
11827     l_current_position = opj_stream_tell(p_stream);
11828
11829     if (! opj_stream_seek(p_stream, l_tlm_position, p_manager)) {
11830         return OPJ_FALSE;
11831     }
11832
11833     if (opj_stream_write_data(p_stream,
11834                               p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer, l_tlm_size,
11835                               p_manager) != l_tlm_size) {
11836         return OPJ_FALSE;
11837     }
11838
11839     if (! opj_stream_seek(p_stream, l_current_position, p_manager)) {
11840         return OPJ_FALSE;
11841     }
11842
11843     return OPJ_TRUE;
11844 }
11845
11846 static OPJ_BOOL opj_j2k_end_encoding(opj_j2k_t *p_j2k,
11847                                      struct opj_stream_private *p_stream,
11848                                      struct opj_event_mgr * p_manager)
11849 {
11850     /* preconditions */
11851     assert(p_j2k != 00);
11852     assert(p_manager != 00);
11853     assert(p_stream != 00);
11854
11855     OPJ_UNUSED(p_stream);
11856     OPJ_UNUSED(p_manager);
11857
11858     opj_tcd_destroy(p_j2k->m_tcd);
11859     p_j2k->m_tcd = 00;
11860
11861     if (p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer) {
11862         opj_free(p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer);
11863         p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer = 0;
11864         p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current = 0;
11865     }
11866
11867     if (p_j2k->m_specific_param.m_encoder.m_encoded_tile_data) {
11868         opj_free(p_j2k->m_specific_param.m_encoder.m_encoded_tile_data);
11869         p_j2k->m_specific_param.m_encoder.m_encoded_tile_data = 0;
11870     }
11871
11872     p_j2k->m_specific_param.m_encoder.m_encoded_tile_size = 0;
11873
11874     return OPJ_TRUE;
11875 }
11876
11877 /**
11878  * Destroys the memory associated with the decoding of headers.
11879  */
11880 static OPJ_BOOL opj_j2k_destroy_header_memory(opj_j2k_t * p_j2k,
11881         opj_stream_private_t *p_stream,
11882         opj_event_mgr_t * p_manager
11883                                              )
11884 {
11885     /* preconditions */
11886     assert(p_j2k != 00);
11887     assert(p_stream != 00);
11888     assert(p_manager != 00);
11889
11890     OPJ_UNUSED(p_stream);
11891     OPJ_UNUSED(p_manager);
11892
11893     if (p_j2k->m_specific_param.m_encoder.m_header_tile_data) {
11894         opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
11895         p_j2k->m_specific_param.m_encoder.m_header_tile_data = 0;
11896     }
11897
11898     p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
11899
11900     return OPJ_TRUE;
11901 }
11902
11903 static OPJ_BOOL opj_j2k_init_info(opj_j2k_t *p_j2k,
11904                                   struct opj_stream_private *p_stream,
11905                                   struct opj_event_mgr * p_manager)
11906 {
11907     opj_codestream_info_t * l_cstr_info = 00;
11908
11909     /* preconditions */
11910     assert(p_j2k != 00);
11911     assert(p_manager != 00);
11912     assert(p_stream != 00);
11913     (void)l_cstr_info;
11914
11915     OPJ_UNUSED(p_stream);
11916
11917     /* TODO mergeV2: check this part which use cstr_info */
11918     /*l_cstr_info = p_j2k->cstr_info;
11919
11920     if (l_cstr_info)  {
11921             OPJ_UINT32 compno;
11922             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));
11923
11924             l_cstr_info->image_w = p_j2k->m_image->x1 - p_j2k->m_image->x0;
11925             l_cstr_info->image_h = p_j2k->m_image->y1 - p_j2k->m_image->y0;
11926
11927             l_cstr_info->prog = (&p_j2k->m_cp.tcps[0])->prg;
11928
11929             l_cstr_info->tw = p_j2k->m_cp.tw;
11930             l_cstr_info->th = p_j2k->m_cp.th;
11931
11932             l_cstr_info->tile_x = p_j2k->m_cp.tdx;*/        /* new version parser */
11933     /*l_cstr_info->tile_y = p_j2k->m_cp.tdy;*/      /* new version parser */
11934     /*l_cstr_info->tile_Ox = p_j2k->m_cp.tx0;*/     /* new version parser */
11935     /*l_cstr_info->tile_Oy = p_j2k->m_cp.ty0;*/     /* new version parser */
11936
11937     /*l_cstr_info->numcomps = p_j2k->m_image->numcomps;
11938
11939     l_cstr_info->numlayers = (&p_j2k->m_cp.tcps[0])->numlayers;
11940
11941     l_cstr_info->numdecompos = (OPJ_INT32*) opj_malloc(p_j2k->m_image->numcomps * sizeof(OPJ_INT32));
11942
11943     for (compno=0; compno < p_j2k->m_image->numcomps; compno++) {
11944             l_cstr_info->numdecompos[compno] = (&p_j2k->m_cp.tcps[0])->tccps->numresolutions - 1;
11945     }
11946
11947     l_cstr_info->D_max = 0.0;       */      /* ADD Marcela */
11948
11949     /*l_cstr_info->main_head_start = opj_stream_tell(p_stream);*/ /* position of SOC */
11950
11951     /*l_cstr_info->maxmarknum = 100;
11952     l_cstr_info->marker = (opj_marker_info_t *) opj_malloc(l_cstr_info->maxmarknum * sizeof(opj_marker_info_t));
11953     l_cstr_info->marknum = 0;
11954     }*/
11955
11956     return opj_j2k_calculate_tp(p_j2k, &(p_j2k->m_cp),
11957                                 &p_j2k->m_specific_param.m_encoder.m_total_tile_parts, p_j2k->m_private_image,
11958                                 p_manager);
11959 }
11960
11961 /**
11962  * Creates a tile-coder encoder.
11963  *
11964  * @param       p_stream                the stream to write data to.
11965  * @param       p_j2k                   J2K codec.
11966  * @param       p_manager               the user event manager.
11967 */
11968 static OPJ_BOOL opj_j2k_create_tcd(opj_j2k_t *p_j2k,
11969                                    opj_stream_private_t *p_stream,
11970                                    opj_event_mgr_t * p_manager
11971                                   )
11972 {
11973     /* preconditions */
11974     assert(p_j2k != 00);
11975     assert(p_manager != 00);
11976     assert(p_stream != 00);
11977
11978     OPJ_UNUSED(p_stream);
11979
11980     p_j2k->m_tcd = opj_tcd_create(OPJ_FALSE);
11981
11982     if (! p_j2k->m_tcd) {
11983         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to create Tile Coder\n");
11984         return OPJ_FALSE;
11985     }
11986
11987     if (!opj_tcd_init(p_j2k->m_tcd, p_j2k->m_private_image, &p_j2k->m_cp,
11988                       p_j2k->m_tp)) {
11989         opj_tcd_destroy(p_j2k->m_tcd);
11990         p_j2k->m_tcd = 00;
11991         return OPJ_FALSE;
11992     }
11993
11994     return OPJ_TRUE;
11995 }
11996
11997 OPJ_BOOL opj_j2k_write_tile(opj_j2k_t * p_j2k,
11998                             OPJ_UINT32 p_tile_index,
11999                             OPJ_BYTE * p_data,
12000                             OPJ_UINT32 p_data_size,
12001                             opj_stream_private_t *p_stream,
12002                             opj_event_mgr_t * p_manager)
12003 {
12004     if (! opj_j2k_pre_write_tile(p_j2k, p_tile_index, p_stream, p_manager)) {
12005         opj_event_msg(p_manager, EVT_ERROR,
12006                       "Error while opj_j2k_pre_write_tile with tile index = %d\n", p_tile_index);
12007         return OPJ_FALSE;
12008     } else {
12009         OPJ_UINT32 j;
12010         /* Allocate data */
12011         for (j = 0; j < p_j2k->m_tcd->image->numcomps; ++j) {
12012             opj_tcd_tilecomp_t* l_tilec = p_j2k->m_tcd->tcd_image->tiles->comps + j;
12013
12014             if (! opj_alloc_tile_component_data(l_tilec)) {
12015                 opj_event_msg(p_manager, EVT_ERROR, "Error allocating tile component data.");
12016                 return OPJ_FALSE;
12017             }
12018         }
12019
12020         /* now copy data into the tile component */
12021         if (! opj_tcd_copy_tile_data(p_j2k->m_tcd, p_data, p_data_size)) {
12022             opj_event_msg(p_manager, EVT_ERROR,
12023                           "Size mismatch between tile data and sent data.");
12024             return OPJ_FALSE;
12025         }
12026         if (! opj_j2k_post_write_tile(p_j2k, p_stream, p_manager)) {
12027             opj_event_msg(p_manager, EVT_ERROR,
12028                           "Error while opj_j2k_post_write_tile with tile index = %d\n", p_tile_index);
12029             return OPJ_FALSE;
12030         }
12031     }
12032
12033     return OPJ_TRUE;
12034 }