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 /**
  53  * Sets up the procedures to do on reading header. Developers wanting to extend the library can add their own reading procedures.
  54  */
  55 static OPJ_BOOL opj_j2k_setup_header_reading(opj_j2k_t *p_j2k,
  56         opj_event_mgr_t * p_manager);
  57
  58 /**
  59  * The read header procedure.
  60  */
  61 static OPJ_BOOL opj_j2k_read_header_procedure(opj_j2k_t *p_j2k,
  62         opj_stream_private_t *p_stream,
  63         opj_event_mgr_t * p_manager);
  64
  65 /**
  66  * The default encoding validation procedure without any extension.
  67  *
  68  * @param       p_j2k                   the jpeg2000 codec to validate.
  69  * @param       p_stream                the input stream to validate.
  70  * @param       p_manager               the user event manager.
  71  *
  72  * @return true if the parameters are correct.
  73  */
  74 static OPJ_BOOL opj_j2k_encoding_validation(opj_j2k_t * p_j2k,
  75         opj_stream_private_t *p_stream,
  76         opj_event_mgr_t * p_manager);
  77
  78 /**
  79  * The default decoding validation procedure without any extension.
  80  *
  81  * @param       p_j2k                   the jpeg2000 codec to validate.
  82  * @param       p_stream                                the input stream to validate.
  83  * @param       p_manager               the user event manager.
  84  *
  85  * @return true if the parameters are correct.
  86  */
  87 static OPJ_BOOL opj_j2k_decoding_validation(opj_j2k_t * p_j2k,
  88         opj_stream_private_t *p_stream,
  89         opj_event_mgr_t * p_manager);
  90
  91 /**
  92  * Sets up the validation ,i.e. adds the procedures to launch to make sure the codec parameters
  93  * are valid. Developers wanting to extend the library can add their own validation procedures.
  94  */
  95 static OPJ_BOOL opj_j2k_setup_encoding_validation(opj_j2k_t *p_j2k,
  96         opj_event_mgr_t * p_manager);
  97
  98 /**
  99  * Sets up the validation ,i.e. adds the procedures to launch to make sure the codec parameters
 100  * are valid. Developers wanting to extend the library can add their own validation procedures.
 101  */
 102 static OPJ_BOOL opj_j2k_setup_decoding_validation(opj_j2k_t *p_j2k,
 103         opj_event_mgr_t * p_manager);
 104
 105 /**
 106  * Sets up the validation ,i.e. adds the procedures to launch to make sure the codec parameters
 107  * are valid. Developers wanting to extend the library can add their own validation procedures.
 108  */
 109 static OPJ_BOOL opj_j2k_setup_end_compress(opj_j2k_t *p_j2k,
 110         opj_event_mgr_t * p_manager);
 111
 112 /**
 113  * The mct encoding validation procedure.
 114  *
 115  * @param       p_j2k                   the jpeg2000 codec to validate.
 116  * @param       p_stream                                the input stream to validate.
 117  * @param       p_manager               the user event manager.
 118  *
 119  * @return true if the parameters are correct.
 120  */
 121 static OPJ_BOOL opj_j2k_mct_validation(opj_j2k_t * p_j2k,
 122                                        opj_stream_private_t *p_stream,
 123                                        opj_event_mgr_t * p_manager);
 124
 125 /**
 126  * Builds the tcd decoder to use to decode tile.
 127  */
 128 static OPJ_BOOL opj_j2k_build_decoder(opj_j2k_t * p_j2k,
 129                                       opj_stream_private_t *p_stream,
 130                                       opj_event_mgr_t * p_manager);
 131 /**
 132  * Builds the tcd encoder to use to encode tile.
 133  */
 134 static OPJ_BOOL opj_j2k_build_encoder(opj_j2k_t * p_j2k,
 135                                       opj_stream_private_t *p_stream,
 136                                       opj_event_mgr_t * p_manager);
 137
 138 /**
 139  * Creates a tile-coder encoder.
 140  *
 141  * @param       p_stream                        the stream to write data to.
 142  * @param       p_j2k                           J2K codec.
 143  * @param       p_manager                   the user event manager.
 144 */
 145 static OPJ_BOOL opj_j2k_create_tcd(opj_j2k_t *p_j2k,
 146                                    opj_stream_private_t *p_stream,
 147                                    opj_event_mgr_t * p_manager);
 148
 149 /**
 150  * Executes the given procedures on the given codec.
 151  *
 152  * @param       p_procedure_list        the list of procedures to execute
 153  * @param       p_j2k                           the jpeg2000 codec to execute the procedures on.
 154  * @param       p_stream                        the stream to execute the procedures on.
 155  * @param       p_manager                       the user manager.
 156  *
 157  * @return      true                            if all the procedures were successfully executed.
 158  */
 159 static OPJ_BOOL opj_j2k_exec(opj_j2k_t * p_j2k,
 160                              opj_procedure_list_t * p_procedure_list,
 161                              opj_stream_private_t *p_stream,
 162                              opj_event_mgr_t * p_manager);
 163
 164 /**
 165  * Updates the rates of the tcp.
 166  *
 167  * @param       p_stream                                the stream to write data to.
 168  * @param       p_j2k                           J2K codec.
 169  * @param       p_manager               the user event manager.
 170 */
 171 static OPJ_BOOL opj_j2k_update_rates(opj_j2k_t *p_j2k,
 172                                      opj_stream_private_t *p_stream,
 173                                      opj_event_mgr_t * p_manager);
 174
 175 /**
 176  * Copies the decoding tile parameters onto all the tile parameters.
 177  * Creates also the tile decoder.
 178  */
 179 static OPJ_BOOL opj_j2k_copy_default_tcp_and_create_tcd(opj_j2k_t * p_j2k,
 180         opj_stream_private_t *p_stream,
 181         opj_event_mgr_t * p_manager);
 182
 183 /**
 184  * Destroys the memory associated with the decoding of headers.
 185  */
 186 static OPJ_BOOL opj_j2k_destroy_header_memory(opj_j2k_t * p_j2k,
 187         opj_stream_private_t *p_stream,
 188         opj_event_mgr_t * p_manager);
 189
 190 /**
 191  * Reads the lookup table containing all the marker, status and action, and returns the handler associated
 192  * with the marker value.
 193  * @param       p_id            Marker value to look up
 194  *
 195  * @return      the handler associated with the id.
 196 */
 197 static const struct opj_dec_memory_marker_handler * opj_j2k_get_marker_handler(
 198     OPJ_UINT32 p_id);
 199
 200 /**
 201  * Destroys a tile coding parameter structure.
 202  *
 203  * @param       p_tcp           the tile coding parameter to destroy.
 204  */
 205 static void opj_j2k_tcp_destroy(opj_tcp_t *p_tcp);
 206
 207 /**
 208  * Destroys the data inside a tile coding parameter structure.
 209  *
 210  * @param       p_tcp           the tile coding parameter which contain data to destroy.
 211  */
 212 static void opj_j2k_tcp_data_destroy(opj_tcp_t *p_tcp);
 213
 214 /**
 215  * Destroys a coding parameter structure.
 216  *
 217  * @param       p_cp            the coding parameter to destroy.
 218  */
 219 static void opj_j2k_cp_destroy(opj_cp_t *p_cp);
 220
 221 /**
 222  * Compare 2 a SPCod/ SPCoc elements, i.e. the coding style of a given component of a tile.
 223  *
 224  * @param       p_j2k            J2K codec.
 225  * @param       p_tile_no        Tile number
 226  * @param       p_first_comp_no  The 1st component number to compare.
 227  * @param       p_second_comp_no The 1st component number to compare.
 228  *
 229  * @return OPJ_TRUE if SPCdod are equals.
 230  */
 231 static OPJ_BOOL opj_j2k_compare_SPCod_SPCoc(opj_j2k_t *p_j2k,
 232         OPJ_UINT32 p_tile_no, OPJ_UINT32 p_first_comp_no, OPJ_UINT32 p_second_comp_no);
 233
 234 /**
 235  * Writes a SPCod or SPCoc element, i.e. the coding style of a given component of a tile.
 236  *
 237  * @param       p_j2k           J2K codec.
 238  * @param       p_tile_no       FIXME DOC
 239  * @param       p_comp_no       the component number to output.
 240  * @param       p_data          FIXME DOC
 241  * @param       p_header_size   FIXME DOC
 242  * @param       p_manager       the user event manager.
 243  *
 244  * @return FIXME DOC
 245 */
 246 static OPJ_BOOL opj_j2k_write_SPCod_SPCoc(opj_j2k_t *p_j2k,
 247         OPJ_UINT32 p_tile_no,
 248         OPJ_UINT32 p_comp_no,
 249         OPJ_BYTE * p_data,
 250         OPJ_UINT32 * p_header_size,
 251         opj_event_mgr_t * p_manager);
 252
 253 /**
 254  * Gets the size taken by writing a SPCod or SPCoc for the given tile and component.
 255  *
 256  * @param       p_j2k                   the J2K codec.
 257  * @param       p_tile_no               the tile index.
 258  * @param       p_comp_no               the component being outputted.
 259  *
 260  * @return      the number of bytes taken by the SPCod element.
 261  */
 262 static OPJ_UINT32 opj_j2k_get_SPCod_SPCoc_size(opj_j2k_t *p_j2k,
 263         OPJ_UINT32 p_tile_no,
 264         OPJ_UINT32 p_comp_no);
 265
 266 /**
 267  * Reads a SPCod or SPCoc element, i.e. the coding style of a given component of a tile.
 268  * @param       p_j2k           the jpeg2000 codec.
 269  * @param       compno          FIXME DOC
 270  * @param       p_header_data   the data contained in the COM box.
 271  * @param       p_header_size   the size of the data contained in the COM marker.
 272  * @param       p_manager       the user event manager.
 273 */
 274 static OPJ_BOOL opj_j2k_read_SPCod_SPCoc(opj_j2k_t *p_j2k,
 275         OPJ_UINT32 compno,
 276         OPJ_BYTE * p_header_data,
 277         OPJ_UINT32 * p_header_size,
 278         opj_event_mgr_t * p_manager);
 279
 280 /**
 281  * Gets the size taken by writing SQcd or SQcc element, i.e. the quantization values of a band in the QCD or QCC.
 282  *
 283  * @param       p_tile_no               the tile index.
 284  * @param       p_comp_no               the component being outputted.
 285  * @param       p_j2k                   the J2K codec.
 286  *
 287  * @return      the number of bytes taken by the SPCod element.
 288  */
 289 static OPJ_UINT32 opj_j2k_get_SQcd_SQcc_size(opj_j2k_t *p_j2k,
 290         OPJ_UINT32 p_tile_no,
 291         OPJ_UINT32 p_comp_no);
 292
 293 /**
 294  * Compares 2 SQcd or SQcc element, i.e. the quantization values of a band in the QCD or QCC.
 295  *
 296  * @param       p_j2k                   J2K codec.
 297  * @param       p_tile_no               the tile to output.
 298  * @param       p_first_comp_no         the first component number to compare.
 299  * @param       p_second_comp_no        the second component number to compare.
 300  *
 301  * @return OPJ_TRUE if equals.
 302  */
 303 static OPJ_BOOL opj_j2k_compare_SQcd_SQcc(opj_j2k_t *p_j2k,
 304         OPJ_UINT32 p_tile_no, OPJ_UINT32 p_first_comp_no, OPJ_UINT32 p_second_comp_no);
 305
 306
 307 /**
 308  * Writes a SQcd or SQcc element, i.e. the quantization values of a band in the QCD or QCC.
 309  *
 310  * @param       p_tile_no               the tile to output.
 311  * @param       p_comp_no               the component number to output.
 312  * @param       p_data                  the data buffer.
 313  * @param       p_header_size   pointer to the size of the data buffer, it is changed by the function.
 314  * @param       p_j2k                   J2K codec.
 315  * @param       p_manager               the user event manager.
 316  *
 317 */
 318 static OPJ_BOOL opj_j2k_write_SQcd_SQcc(opj_j2k_t *p_j2k,
 319                                         OPJ_UINT32 p_tile_no,
 320                                         OPJ_UINT32 p_comp_no,
 321                                         OPJ_BYTE * p_data,
 322                                         OPJ_UINT32 * p_header_size,
 323                                         opj_event_mgr_t * p_manager);
 324
 325 /**
 326  * Updates the Tile Length Marker.
 327  */
 328 static void opj_j2k_update_tlm(opj_j2k_t * p_j2k, OPJ_UINT32 p_tile_part_size);
 329
 330 /**
 331  * Reads a SQcd or SQcc element, i.e. the quantization values of a band in the QCD or QCC.
 332  *
 333  * @param       p_j2k           J2K codec.
 334  * @param       compno          the component number to output.
 335  * @param       p_header_data   the data buffer.
 336  * @param       p_header_size   pointer to the size of the data buffer, it is changed by the function.
 337  * @param       p_manager       the user event manager.
 338  *
 339 */
 340 static OPJ_BOOL opj_j2k_read_SQcd_SQcc(opj_j2k_t *p_j2k,
 341                                        OPJ_UINT32 compno,
 342                                        OPJ_BYTE * p_header_data,
 343                                        OPJ_UINT32 * p_header_size,
 344                                        opj_event_mgr_t * p_manager);
 345
 346 /**
 347  * Copies the tile component parameters of all the component from the first tile component.
 348  *
 349  * @param               p_j2k           the J2k codec.
 350  */
 351 static void opj_j2k_copy_tile_component_parameters(opj_j2k_t *p_j2k);
 352
 353 /**
 354  * Copies the tile quantization parameters of all the component from the first tile component.
 355  *
 356  * @param               p_j2k           the J2k codec.
 357  */
 358 static void opj_j2k_copy_tile_quantization_parameters(opj_j2k_t *p_j2k);
 359
 360 /**
 361  * Reads the tiles.
 362  */
 363 static OPJ_BOOL opj_j2k_decode_tiles(opj_j2k_t *p_j2k,
 364                                      opj_stream_private_t *p_stream,
 365                                      opj_event_mgr_t * p_manager);
 366
 367 static OPJ_BOOL opj_j2k_pre_write_tile(opj_j2k_t * p_j2k,
 368                                        OPJ_UINT32 p_tile_index,
 369                                        opj_stream_private_t *p_stream,
 370                                        opj_event_mgr_t * p_manager);
 371
 372 static OPJ_BOOL opj_j2k_update_image_data(opj_tcd_t * p_tcd,
 373         opj_image_t* p_output_image);
 374
 375 static void opj_get_tile_dimensions(opj_image_t * l_image,
 376                                     opj_tcd_tilecomp_t * l_tilec,
 377                                     opj_image_comp_t * l_img_comp,
 378                                     OPJ_UINT32* l_size_comp,
 379                                     OPJ_UINT32* l_width,
 380                                     OPJ_UINT32* l_height,
 381                                     OPJ_UINT32* l_offset_x,
 382                                     OPJ_UINT32* l_offset_y,
 383                                     OPJ_UINT32* l_image_width,
 384                                     OPJ_UINT32* l_stride,
 385                                     OPJ_UINT32* l_tile_offset);
 386
 387 static void opj_j2k_get_tile_data(opj_tcd_t * p_tcd, OPJ_BYTE * p_data);
 388
 389 static OPJ_BOOL opj_j2k_post_write_tile(opj_j2k_t * p_j2k,
 390                                         opj_stream_private_t *p_stream,
 391                                         opj_event_mgr_t * p_manager);
 392
 393 /**
 394  * Sets up the procedures to do on writing header.
 395  * Developers wanting to extend the library can add their own writing procedures.
 396  */
 397 static OPJ_BOOL opj_j2k_setup_header_writing(opj_j2k_t *p_j2k,
 398         opj_event_mgr_t * p_manager);
 399
 400 static OPJ_BOOL opj_j2k_write_first_tile_part(opj_j2k_t *p_j2k,
 401         OPJ_BYTE * p_data,
 402         OPJ_UINT32 * p_data_written,
 403         OPJ_UINT32 total_data_size,
 404         opj_stream_private_t *p_stream,
 405         struct opj_event_mgr * p_manager);
 406
 407 static OPJ_BOOL opj_j2k_write_all_tile_parts(opj_j2k_t *p_j2k,
 408         OPJ_BYTE * p_data,
 409         OPJ_UINT32 * p_data_written,
 410         OPJ_UINT32 total_data_size,
 411         opj_stream_private_t *p_stream,
 412         struct opj_event_mgr * p_manager);
 413
 414 /**
 415  * Gets the offset of the header.
 416  *
 417  * @param       p_stream                the stream to write data to.
 418  * @param       p_j2k                   J2K codec.
 419  * @param       p_manager               the user event manager.
 420 */
 421 static OPJ_BOOL opj_j2k_get_end_header(opj_j2k_t *p_j2k,
 422                                        opj_stream_private_t *p_stream,
 423                                        opj_event_mgr_t * p_manager);
 424
 425 static OPJ_BOOL opj_j2k_allocate_tile_element_cstr_index(opj_j2k_t *p_j2k);
 426
 427 /*
 428  * -----------------------------------------------------------------------
 429  * -----------------------------------------------------------------------
 430  * -----------------------------------------------------------------------
 431  */
 432
 433 /**
 434  * Writes the SOC marker (Start Of Codestream)
 435  *
 436  * @param       p_stream                        the stream to write data to.
 437  * @param       p_j2k                   J2K codec.
 438  * @param       p_manager       the user event manager.
 439 */
 440 static OPJ_BOOL opj_j2k_write_soc(opj_j2k_t *p_j2k,
 441                                   opj_stream_private_t *p_stream,
 442                                   opj_event_mgr_t * p_manager);
 443
 444 /**
 445  * Reads a SOC marker (Start of Codestream)
 446  * @param       p_j2k           the jpeg2000 file codec.
 447  * @param       p_stream        XXX needs data
 448  * @param       p_manager       the user event manager.
 449 */
 450 static OPJ_BOOL opj_j2k_read_soc(opj_j2k_t *p_j2k,
 451                                  opj_stream_private_t *p_stream,
 452                                  opj_event_mgr_t * p_manager);
 453
 454 /**
 455  * Writes the SIZ marker (image and tile size)
 456  *
 457  * @param       p_j2k           J2K codec.
 458  * @param       p_stream        the stream to write data to.
 459  * @param       p_manager       the user event manager.
 460 */
 461 static OPJ_BOOL opj_j2k_write_siz(opj_j2k_t *p_j2k,
 462                                   opj_stream_private_t *p_stream,
 463                                   opj_event_mgr_t * p_manager);
 464
 465 /**
 466  * Reads a SIZ marker (image and tile size)
 467  * @param       p_j2k           the jpeg2000 file codec.
 468  * @param       p_header_data   the data contained in the SIZ box.
 469  * @param       p_header_size   the size of the data contained in the SIZ marker.
 470  * @param       p_manager       the user event manager.
 471 */
 472 static OPJ_BOOL opj_j2k_read_siz(opj_j2k_t *p_j2k,
 473                                  OPJ_BYTE * p_header_data,
 474                                  OPJ_UINT32 p_header_size,
 475                                  opj_event_mgr_t * p_manager);
 476
 477 /**
 478  * Writes the COM marker (comment)
 479  *
 480  * @param       p_stream                        the stream to write data to.
 481  * @param       p_j2k                   J2K codec.
 482  * @param       p_manager       the user event manager.
 483 */
 484 static OPJ_BOOL opj_j2k_write_com(opj_j2k_t *p_j2k,
 485                                   opj_stream_private_t *p_stream,
 486                                   opj_event_mgr_t * p_manager);
 487
 488 /**
 489  * Reads a COM marker (comments)
 490  * @param       p_j2k           the jpeg2000 file codec.
 491  * @param       p_header_data   the data contained in the COM box.
 492  * @param       p_header_size   the size of the data contained in the COM marker.
 493  * @param       p_manager       the user event manager.
 494 */
 495 static OPJ_BOOL opj_j2k_read_com(opj_j2k_t *p_j2k,
 496                                  OPJ_BYTE * p_header_data,
 497                                  OPJ_UINT32 p_header_size,
 498                                  opj_event_mgr_t * p_manager);
 499 /**
 500  * Writes the COD marker (Coding style default)
 501  *
 502  * @param       p_stream                        the stream to write data to.
 503  * @param       p_j2k                   J2K codec.
 504  * @param       p_manager       the user event manager.
 505 */
 506 static OPJ_BOOL opj_j2k_write_cod(opj_j2k_t *p_j2k,
 507                                   opj_stream_private_t *p_stream,
 508                                   opj_event_mgr_t * p_manager);
 509
 510 /**
 511  * Reads a COD marker (Coding style defaults)
 512  * @param       p_header_data   the data contained in the COD box.
 513  * @param       p_j2k                   the jpeg2000 codec.
 514  * @param       p_header_size   the size of the data contained in the COD marker.
 515  * @param       p_manager               the user event manager.
 516 */
 517 static OPJ_BOOL opj_j2k_read_cod(opj_j2k_t *p_j2k,
 518                                  OPJ_BYTE * p_header_data,
 519                                  OPJ_UINT32 p_header_size,
 520                                  opj_event_mgr_t * p_manager);
 521
 522 /**
 523  * Compares 2 COC markers (Coding style component)
 524  *
 525  * @param       p_j2k            J2K codec.
 526  * @param       p_first_comp_no  the index of the first component to compare.
 527  * @param       p_second_comp_no the index of the second component to compare.
 528  *
 529  * @return      OPJ_TRUE if equals
 530  */
 531 static OPJ_BOOL opj_j2k_compare_coc(opj_j2k_t *p_j2k,
 532                                     OPJ_UINT32 p_first_comp_no, OPJ_UINT32 p_second_comp_no);
 533
 534 /**
 535  * Writes the COC marker (Coding style component)
 536  *
 537  * @param       p_j2k       J2K codec.
 538  * @param       p_comp_no   the index of the component to output.
 539  * @param       p_stream    the stream to write data to.
 540  * @param       p_manager   the user event manager.
 541 */
 542 static OPJ_BOOL opj_j2k_write_coc(opj_j2k_t *p_j2k,
 543                                   OPJ_UINT32 p_comp_no,
 544                                   opj_stream_private_t *p_stream,
 545                                   opj_event_mgr_t * p_manager);
 546
 547 /**
 548  * Writes the COC marker (Coding style component)
 549  *
 550  * @param       p_j2k                   J2K codec.
 551  * @param       p_comp_no               the index of the component to output.
 552  * @param       p_data          FIXME DOC
 553  * @param       p_data_written  FIXME DOC
 554  * @param       p_manager               the user event manager.
 555 */
 556 static void opj_j2k_write_coc_in_memory(opj_j2k_t *p_j2k,
 557                                         OPJ_UINT32 p_comp_no,
 558                                         OPJ_BYTE * p_data,
 559                                         OPJ_UINT32 * p_data_written,
 560                                         opj_event_mgr_t * p_manager);
 561
 562 /**
 563  * Gets the maximum size taken by a coc.
 564  *
 565  * @param       p_j2k   the jpeg2000 codec to use.
 566  */
 567 static OPJ_UINT32 opj_j2k_get_max_coc_size(opj_j2k_t *p_j2k);
 568
 569 /**
 570  * Reads a COC marker (Coding Style Component)
 571  * @param       p_header_data   the data contained in the COC box.
 572  * @param       p_j2k                   the jpeg2000 codec.
 573  * @param       p_header_size   the size of the data contained in the COC marker.
 574  * @param       p_manager               the user event manager.
 575 */
 576 static OPJ_BOOL opj_j2k_read_coc(opj_j2k_t *p_j2k,
 577                                  OPJ_BYTE * p_header_data,
 578                                  OPJ_UINT32 p_header_size,
 579                                  opj_event_mgr_t * p_manager);
 580
 581 /**
 582  * Writes the QCD marker (quantization default)
 583  *
 584  * @param       p_j2k                   J2K codec.
 585  * @param       p_stream                the stream to write data to.
 586  * @param       p_manager               the user event manager.
 587 */
 588 static OPJ_BOOL opj_j2k_write_qcd(opj_j2k_t *p_j2k,
 589                                   opj_stream_private_t *p_stream,
 590                                   opj_event_mgr_t * p_manager);
 591
 592 /**
 593  * Reads a QCD marker (Quantization defaults)
 594  * @param       p_header_data   the data contained in the QCD box.
 595  * @param       p_j2k                   the jpeg2000 codec.
 596  * @param       p_header_size   the size of the data contained in the QCD marker.
 597  * @param       p_manager               the user event manager.
 598 */
 599 static OPJ_BOOL opj_j2k_read_qcd(opj_j2k_t *p_j2k,
 600                                  OPJ_BYTE * p_header_data,
 601                                  OPJ_UINT32 p_header_size,
 602                                  opj_event_mgr_t * p_manager);
 603
 604 /**
 605  * Compare QCC markers (quantization component)
 606  *
 607  * @param       p_j2k                 J2K codec.
 608  * @param       p_first_comp_no       the index of the first component to compare.
 609  * @param       p_second_comp_no      the index of the second component to compare.
 610  *
 611  * @return OPJ_TRUE if equals.
 612  */
 613 static OPJ_BOOL opj_j2k_compare_qcc(opj_j2k_t *p_j2k,
 614                                     OPJ_UINT32 p_first_comp_no, OPJ_UINT32 p_second_comp_no);
 615
 616 /**
 617  * Writes the QCC marker (quantization component)
 618  *
 619  * @param       p_comp_no       the index of the component to output.
 620  * @param       p_stream                the stream to write data to.
 621  * @param       p_j2k                   J2K codec.
 622  * @param       p_manager               the user event manager.
 623 */
 624 static OPJ_BOOL opj_j2k_write_qcc(opj_j2k_t *p_j2k,
 625                                   OPJ_UINT32 p_comp_no,
 626                                   opj_stream_private_t *p_stream,
 627                                   opj_event_mgr_t * p_manager);
 628
 629 /**
 630  * Writes the QCC marker (quantization component)
 631  *
 632  * @param       p_j2k           J2K codec.
 633  * @param       p_comp_no       the index of the component to output.
 634  * @param       p_data          FIXME DOC
 635  * @param       p_data_written  the stream to write data to.
 636  * @param       p_manager       the user event manager.
 637 */
 638 static void opj_j2k_write_qcc_in_memory(opj_j2k_t *p_j2k,
 639                                         OPJ_UINT32 p_comp_no,
 640                                         OPJ_BYTE * p_data,
 641                                         OPJ_UINT32 * p_data_written,
 642                                         opj_event_mgr_t * p_manager);
 643
 644 /**
 645  * Gets the maximum size taken by a qcc.
 646  */
 647 static OPJ_UINT32 opj_j2k_get_max_qcc_size(opj_j2k_t *p_j2k);
 648
 649 /**
 650  * Reads a QCC marker (Quantization component)
 651  * @param       p_header_data   the data contained in the QCC box.
 652  * @param       p_j2k                   the jpeg2000 codec.
 653  * @param       p_header_size   the size of the data contained in the QCC marker.
 654  * @param       p_manager               the user event manager.
 655 */
 656 static OPJ_BOOL opj_j2k_read_qcc(opj_j2k_t *p_j2k,
 657                                  OPJ_BYTE * p_header_data,
 658                                  OPJ_UINT32 p_header_size,
 659                                  opj_event_mgr_t * p_manager);
 660 /**
 661  * Writes the POC marker (Progression Order Change)
 662  *
 663  * @param       p_stream                                the stream to write data to.
 664  * @param       p_j2k                           J2K codec.
 665  * @param       p_manager               the user event manager.
 666 */
 667 static OPJ_BOOL opj_j2k_write_poc(opj_j2k_t *p_j2k,
 668                                   opj_stream_private_t *p_stream,
 669                                   opj_event_mgr_t * p_manager);
 670 /**
 671  * Writes the POC marker (Progression Order Change)
 672  *
 673  * @param       p_j2k          J2K codec.
 674  * @param       p_data         FIXME DOC
 675  * @param       p_data_written the stream to write data to.
 676  * @param       p_manager      the user event manager.
 677  */
 678 static void opj_j2k_write_poc_in_memory(opj_j2k_t *p_j2k,
 679                                         OPJ_BYTE * p_data,
 680                                         OPJ_UINT32 * p_data_written,
 681                                         opj_event_mgr_t * p_manager);
 682 /**
 683  * Gets the maximum size taken by the writing of a POC.
 684  */
 685 static OPJ_UINT32 opj_j2k_get_max_poc_size(opj_j2k_t *p_j2k);
 686
 687 /**
 688  * Reads a POC marker (Progression Order Change)
 689  *
 690  * @param       p_header_data   the data contained in the POC box.
 691  * @param       p_j2k                   the jpeg2000 codec.
 692  * @param       p_header_size   the size of the data contained in the POC marker.
 693  * @param       p_manager               the user event manager.
 694 */
 695 static OPJ_BOOL opj_j2k_read_poc(opj_j2k_t *p_j2k,
 696                                  OPJ_BYTE * p_header_data,
 697                                  OPJ_UINT32 p_header_size,
 698                                  opj_event_mgr_t * p_manager);
 699
 700 /**
 701  * Gets the maximum size taken by the toc headers of all the tile parts of any given tile.
 702  */
 703 static OPJ_UINT32 opj_j2k_get_max_toc_size(opj_j2k_t *p_j2k);
 704
 705 /**
 706  * Gets the maximum size taken by the headers of the SOT.
 707  *
 708  * @param       p_j2k   the jpeg2000 codec to use.
 709  */
 710 static OPJ_UINT32 opj_j2k_get_specific_header_sizes(opj_j2k_t *p_j2k);
 711
 712 /**
 713  * Reads a CRG marker (Component registration)
 714  *
 715  * @param       p_header_data   the data contained in the TLM box.
 716  * @param       p_j2k                   the jpeg2000 codec.
 717  * @param       p_header_size   the size of the data contained in the TLM marker.
 718  * @param       p_manager               the user event manager.
 719 */
 720 static OPJ_BOOL opj_j2k_read_crg(opj_j2k_t *p_j2k,
 721                                  OPJ_BYTE * p_header_data,
 722                                  OPJ_UINT32 p_header_size,
 723                                  opj_event_mgr_t * p_manager);
 724 /**
 725  * Reads a TLM marker (Tile Length Marker)
 726  *
 727  * @param       p_header_data   the data contained in the TLM box.
 728  * @param       p_j2k                   the jpeg2000 codec.
 729  * @param       p_header_size   the size of the data contained in the TLM marker.
 730  * @param       p_manager               the user event manager.
 731 */
 732 static OPJ_BOOL opj_j2k_read_tlm(opj_j2k_t *p_j2k,
 733                                  OPJ_BYTE * p_header_data,
 734                                  OPJ_UINT32 p_header_size,
 735                                  opj_event_mgr_t * p_manager);
 736
 737 /**
 738  * Writes the updated tlm.
 739  *
 740  * @param       p_stream                the stream to write data to.
 741  * @param       p_j2k                   J2K codec.
 742  * @param       p_manager               the user event manager.
 743 */
 744 static OPJ_BOOL opj_j2k_write_updated_tlm(opj_j2k_t *p_j2k,
 745         opj_stream_private_t *p_stream,
 746         opj_event_mgr_t * p_manager);
 747
 748 /**
 749  * Reads a PLM marker (Packet length, main header marker)
 750  *
 751  * @param       p_header_data   the data contained in the TLM box.
 752  * @param       p_j2k                   the jpeg2000 codec.
 753  * @param       p_header_size   the size of the data contained in the TLM marker.
 754  * @param       p_manager               the user event manager.
 755 */
 756 static OPJ_BOOL opj_j2k_read_plm(opj_j2k_t *p_j2k,
 757                                  OPJ_BYTE * p_header_data,
 758                                  OPJ_UINT32 p_header_size,
 759                                  opj_event_mgr_t * p_manager);
 760 /**
 761  * Reads a PLT marker (Packet length, tile-part header)
 762  *
 763  * @param       p_header_data   the data contained in the PLT box.
 764  * @param       p_j2k                   the jpeg2000 codec.
 765  * @param       p_header_size   the size of the data contained in the PLT marker.
 766  * @param       p_manager               the user event manager.
 767 */
 768 static OPJ_BOOL opj_j2k_read_plt(opj_j2k_t *p_j2k,
 769                                  OPJ_BYTE * p_header_data,
 770                                  OPJ_UINT32 p_header_size,
 771                                  opj_event_mgr_t * p_manager);
 772
 773 /**
 774  * Reads a PPM marker (Packed headers, main header)
 775  *
 776  * @param       p_header_data   the data contained in the POC box.
 777  * @param       p_j2k                   the jpeg2000 codec.
 778  * @param       p_header_size   the size of the data contained in the POC marker.
 779  * @param       p_manager               the user event manager.
 780  */
 781
 782 static OPJ_BOOL opj_j2k_read_ppm(
 783     opj_j2k_t *p_j2k,
 784     OPJ_BYTE * p_header_data,
 785     OPJ_UINT32 p_header_size,
 786     opj_event_mgr_t * p_manager);
 787
 788 /**
 789  * Merges all PPM markers read (Packed headers, main header)
 790  *
 791  * @param       p_cp      main coding parameters.
 792  * @param       p_manager the user event manager.
 793  */
 794 static OPJ_BOOL opj_j2k_merge_ppm(opj_cp_t *p_cp, opj_event_mgr_t * p_manager);
 795
 796 /**
 797  * Reads a PPT marker (Packed packet headers, tile-part header)
 798  *
 799  * @param       p_header_data   the data contained in the PPT box.
 800  * @param       p_j2k                   the jpeg2000 codec.
 801  * @param       p_header_size   the size of the data contained in the PPT marker.
 802  * @param       p_manager               the user event manager.
 803 */
 804 static OPJ_BOOL opj_j2k_read_ppt(opj_j2k_t *p_j2k,
 805                                  OPJ_BYTE * p_header_data,
 806                                  OPJ_UINT32 p_header_size,
 807                                  opj_event_mgr_t * p_manager);
 808
 809 /**
 810  * Merges all PPT markers read (Packed headers, tile-part header)
 811  *
 812  * @param       p_tcp   the tile.
 813  * @param       p_manager               the user event manager.
 814  */
 815 static OPJ_BOOL opj_j2k_merge_ppt(opj_tcp_t *p_tcp,
 816                                   opj_event_mgr_t * p_manager);
 817
 818
 819 /**
 820  * Writes the TLM marker (Tile Length Marker)
 821  *
 822  * @param       p_stream                                the stream to write data to.
 823  * @param       p_j2k                           J2K codec.
 824  * @param       p_manager               the user event manager.
 825 */
 826 static OPJ_BOOL opj_j2k_write_tlm(opj_j2k_t *p_j2k,
 827                                   opj_stream_private_t *p_stream,
 828                                   opj_event_mgr_t * p_manager);
 829
 830 /**
 831  * Writes the SOT marker (Start of tile-part)
 832  *
 833  * @param       p_j2k            J2K codec.
 834  * @param       p_data           Output buffer
 835  * @param       total_data_size  Output buffer size
 836  * @param       p_data_written   Number of bytes written into stream
 837  * @param       p_stream         the stream to write data to.
 838  * @param       p_manager        the user event manager.
 839 */
 840 static OPJ_BOOL opj_j2k_write_sot(opj_j2k_t *p_j2k,
 841                                   OPJ_BYTE * p_data,
 842                                   OPJ_UINT32 total_data_size,
 843                                   OPJ_UINT32 * p_data_written,
 844                                   const opj_stream_private_t *p_stream,
 845                                   opj_event_mgr_t * p_manager);
 846
 847 /**
 848  * Reads values from a SOT marker (Start of tile-part)
 849  *
 850  * the j2k decoder state is not affected. No side effects, no checks except for p_header_size.
 851  *
 852  * @param       p_header_data   the data contained in the SOT marker.
 853  * @param       p_header_size   the size of the data contained in the SOT marker.
 854  * @param       p_tile_no       Isot.
 855  * @param       p_tot_len       Psot.
 856  * @param       p_current_part  TPsot.
 857  * @param       p_num_parts     TNsot.
 858  * @param       p_manager       the user event manager.
 859  */
 860 static OPJ_BOOL opj_j2k_get_sot_values(OPJ_BYTE *  p_header_data,
 861                                        OPJ_UINT32  p_header_size,
 862                                        OPJ_UINT32* p_tile_no,
 863                                        OPJ_UINT32* p_tot_len,
 864                                        OPJ_UINT32* p_current_part,
 865                                        OPJ_UINT32* p_num_parts,
 866                                        opj_event_mgr_t * p_manager);
 867 /**
 868  * Reads a SOT marker (Start of tile-part)
 869  *
 870  * @param       p_header_data   the data contained in the SOT marker.
 871  * @param       p_j2k           the jpeg2000 codec.
 872  * @param       p_header_size   the size of the data contained in the PPT marker.
 873  * @param       p_manager       the user event manager.
 874 */
 875 static OPJ_BOOL opj_j2k_read_sot(opj_j2k_t *p_j2k,
 876                                  OPJ_BYTE * p_header_data,
 877                                  OPJ_UINT32 p_header_size,
 878                                  opj_event_mgr_t * p_manager);
 879 /**
 880  * Writes the SOD marker (Start of data)
 881  *
 882  * This also writes optional PLT markers (before SOD)
 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       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 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     if (p_j2k->m_specific_param.m_encoder.m_Ttlmi_is_byte) {
 914         opj_write_bytes(p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current,
 915                         p_j2k->m_current_tile_number, 1);
 916         p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current += 1;
 917     } else {
 918         opj_write_bytes(p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current,
 919                         p_j2k->m_current_tile_number, 2);
 920         p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current += 2;
 921     }
 922
 923     opj_write_bytes(p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current,
 924                     p_tile_part_size, 4);                                       /* PSOT */
 925     p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current += 4;
 926 }
 927
 928 /**
 929  * Writes the RGN marker (Region Of Interest)
 930  *
 931  * @param       p_tile_no               the tile to output
 932  * @param       p_comp_no               the component to output
 933  * @param       nb_comps                the number of components
 934  * @param       p_stream                the stream to write data to.
 935  * @param       p_j2k                   J2K codec.
 936  * @param       p_manager               the user event manager.
 937 */
 938 static OPJ_BOOL opj_j2k_write_rgn(opj_j2k_t *p_j2k,
 939                                   OPJ_UINT32 p_tile_no,
 940                                   OPJ_UINT32 p_comp_no,
 941                                   OPJ_UINT32 nb_comps,
 942                                   opj_stream_private_t *p_stream,
 943                                   opj_event_mgr_t * p_manager);
 944
 945 /**
 946  * Reads a RGN marker (Region Of Interest)
 947  *
 948  * @param       p_header_data   the data contained in the POC box.
 949  * @param       p_j2k                   the jpeg2000 codec.
 950  * @param       p_header_size   the size of the data contained in the POC marker.
 951  * @param       p_manager               the user event manager.
 952 */
 953 static OPJ_BOOL opj_j2k_read_rgn(opj_j2k_t *p_j2k,
 954                                  OPJ_BYTE * p_header_data,
 955                                  OPJ_UINT32 p_header_size,
 956                                  opj_event_mgr_t * p_manager);
 957
 958 /**
 959  * Writes the EOC marker (End of Codestream)
 960  *
 961  * @param       p_stream                the stream to write data to.
 962  * @param       p_j2k                   J2K codec.
 963  * @param       p_manager               the user event manager.
 964 */
 965 static OPJ_BOOL opj_j2k_write_eoc(opj_j2k_t *p_j2k,
 966                                   opj_stream_private_t *p_stream,
 967                                   opj_event_mgr_t * p_manager);
 968
 969 #if 0
 970 /**
 971  * Reads a EOC marker (End Of Codestream)
 972  *
 973  * @param       p_j2k                   the jpeg2000 codec.
 974  * @param       p_stream                FIXME DOC
 975  * @param       p_manager               the user event manager.
 976 */
 977 static OPJ_BOOL opj_j2k_read_eoc(opj_j2k_t *p_j2k,
 978                                  opj_stream_private_t *p_stream,
 979                                  opj_event_mgr_t * p_manager);
 980 #endif
 981
 982 /**
 983  * Writes the CBD-MCT-MCC-MCO markers (Multi components transform)
 984  *
 985  * @param       p_stream                        the stream to write data to.
 986  * @param       p_j2k                   J2K codec.
 987  * @param       p_manager       the user event manager.
 988 */
 989 static OPJ_BOOL opj_j2k_write_mct_data_group(opj_j2k_t *p_j2k,
 990         opj_stream_private_t *p_stream,
 991         opj_event_mgr_t * p_manager);
 992
 993 /**
 994  * Inits the Info
 995  *
 996  * @param       p_stream                the stream to write data to.
 997  * @param       p_j2k                   J2K codec.
 998  * @param       p_manager               the user event manager.
 999 */
1000 static OPJ_BOOL opj_j2k_init_info(opj_j2k_t *p_j2k,
1001                                   opj_stream_private_t *p_stream,
1002                                   opj_event_mgr_t * p_manager);
1003
1004 /**
1005 Add main header marker information
1006 @param cstr_index    Codestream information structure
1007 @param type         marker type
1008 @param pos          byte offset of marker segment
1009 @param len          length of marker segment
1010  */
1011 static OPJ_BOOL opj_j2k_add_mhmarker(opj_codestream_index_t *cstr_index,
1012                                      OPJ_UINT32 type, OPJ_OFF_T pos, OPJ_UINT32 len) ;
1013 /**
1014 Add tile header marker information
1015 @param tileno       tile index number
1016 @param cstr_index   Codestream information structure
1017 @param type         marker type
1018 @param pos          byte offset of marker segment
1019 @param len          length of marker segment
1020  */
1021 static OPJ_BOOL opj_j2k_add_tlmarker(OPJ_UINT32 tileno,
1022                                      opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_OFF_T pos,
1023                                      OPJ_UINT32 len);
1024
1025 /**
1026  * Reads an unknown marker
1027  *
1028  * @param       p_j2k                   the jpeg2000 codec.
1029  * @param       p_stream                the stream object to read from.
1030  * @param       output_marker           FIXME DOC
1031  * @param       p_manager               the user event manager.
1032  *
1033  * @return      true                    if the marker could be deduced.
1034 */
1035 static OPJ_BOOL opj_j2k_read_unk(opj_j2k_t *p_j2k,
1036                                  opj_stream_private_t *p_stream,
1037                                  OPJ_UINT32 *output_marker,
1038                                  opj_event_mgr_t * p_manager);
1039
1040 /**
1041  * Writes the MCT marker (Multiple Component Transform)
1042  *
1043  * @param       p_j2k           J2K codec.
1044  * @param       p_mct_record    FIXME DOC
1045  * @param       p_stream        the stream to write data to.
1046  * @param       p_manager       the user event manager.
1047 */
1048 static OPJ_BOOL opj_j2k_write_mct_record(opj_j2k_t *p_j2k,
1049         opj_mct_data_t * p_mct_record,
1050         opj_stream_private_t *p_stream,
1051         opj_event_mgr_t * p_manager);
1052
1053 /**
1054  * Reads a MCT marker (Multiple Component Transform)
1055  *
1056  * @param       p_header_data   the data contained in the MCT box.
1057  * @param       p_j2k                   the jpeg2000 codec.
1058  * @param       p_header_size   the size of the data contained in the MCT marker.
1059  * @param       p_manager               the user event manager.
1060 */
1061 static OPJ_BOOL opj_j2k_read_mct(opj_j2k_t *p_j2k,
1062                                  OPJ_BYTE * p_header_data,
1063                                  OPJ_UINT32 p_header_size,
1064                                  opj_event_mgr_t * p_manager);
1065
1066 /**
1067  * Writes the MCC marker (Multiple Component Collection)
1068  *
1069  * @param       p_j2k                   J2K codec.
1070  * @param       p_mcc_record            FIXME DOC
1071  * @param       p_stream                the stream to write data to.
1072  * @param       p_manager               the user event manager.
1073 */
1074 static OPJ_BOOL opj_j2k_write_mcc_record(opj_j2k_t *p_j2k,
1075         opj_simple_mcc_decorrelation_data_t * p_mcc_record,
1076         opj_stream_private_t *p_stream,
1077         opj_event_mgr_t * p_manager);
1078
1079 /**
1080  * Reads a MCC marker (Multiple Component Collection)
1081  *
1082  * @param       p_header_data   the data contained in the MCC box.
1083  * @param       p_j2k                   the jpeg2000 codec.
1084  * @param       p_header_size   the size of the data contained in the MCC marker.
1085  * @param       p_manager               the user event manager.
1086 */
1087 static OPJ_BOOL opj_j2k_read_mcc(opj_j2k_t *p_j2k,
1088                                  OPJ_BYTE * p_header_data,
1089                                  OPJ_UINT32 p_header_size,
1090                                  opj_event_mgr_t * p_manager);
1091
1092 /**
1093  * Writes the MCO marker (Multiple component transformation ordering)
1094  *
1095  * @param       p_stream                                the stream to write data to.
1096  * @param       p_j2k                           J2K codec.
1097  * @param       p_manager               the user event manager.
1098 */
1099 static OPJ_BOOL opj_j2k_write_mco(opj_j2k_t *p_j2k,
1100                                   opj_stream_private_t *p_stream,
1101                                   opj_event_mgr_t * p_manager);
1102
1103 /**
1104  * Reads a MCO marker (Multiple Component Transform Ordering)
1105  *
1106  * @param       p_header_data   the data contained in the MCO box.
1107  * @param       p_j2k                   the jpeg2000 codec.
1108  * @param       p_header_size   the size of the data contained in the MCO marker.
1109  * @param       p_manager               the user event manager.
1110 */
1111 static OPJ_BOOL opj_j2k_read_mco(opj_j2k_t *p_j2k,
1112                                  OPJ_BYTE * p_header_data,
1113                                  OPJ_UINT32 p_header_size,
1114                                  opj_event_mgr_t * p_manager);
1115
1116 static OPJ_BOOL opj_j2k_add_mct(opj_tcp_t * p_tcp, opj_image_t * p_image,
1117                                 OPJ_UINT32 p_index);
1118
1119 static void  opj_j2k_read_int16_to_float(const void * p_src_data,
1120         void * p_dest_data, OPJ_UINT32 p_nb_elem);
1121 static void  opj_j2k_read_int32_to_float(const void * p_src_data,
1122         void * p_dest_data, OPJ_UINT32 p_nb_elem);
1123 static void  opj_j2k_read_float32_to_float(const void * p_src_data,
1124         void * p_dest_data, OPJ_UINT32 p_nb_elem);
1125 static void  opj_j2k_read_float64_to_float(const void * p_src_data,
1126         void * p_dest_data, OPJ_UINT32 p_nb_elem);
1127
1128 static void  opj_j2k_read_int16_to_int32(const void * p_src_data,
1129         void * p_dest_data, OPJ_UINT32 p_nb_elem);
1130 static void  opj_j2k_read_int32_to_int32(const void * p_src_data,
1131         void * p_dest_data, OPJ_UINT32 p_nb_elem);
1132 static void  opj_j2k_read_float32_to_int32(const void * p_src_data,
1133         void * p_dest_data, OPJ_UINT32 p_nb_elem);
1134 static void  opj_j2k_read_float64_to_int32(const void * p_src_data,
1135         void * p_dest_data, OPJ_UINT32 p_nb_elem);
1136
1137 static void  opj_j2k_write_float_to_int16(const void * p_src_data,
1138         void * p_dest_data, OPJ_UINT32 p_nb_elem);
1139 static void  opj_j2k_write_float_to_int32(const void * p_src_data,
1140         void * p_dest_data, OPJ_UINT32 p_nb_elem);
1141 static void  opj_j2k_write_float_to_float(const void * p_src_data,
1142         void * p_dest_data, OPJ_UINT32 p_nb_elem);
1143 static void  opj_j2k_write_float_to_float64(const void * p_src_data,
1144         void * p_dest_data, OPJ_UINT32 p_nb_elem);
1145
1146 /**
1147  * Ends the encoding, i.e. frees memory.
1148  *
1149  * @param       p_stream                the stream to write data to.
1150  * @param       p_j2k                   J2K codec.
1151  * @param       p_manager               the user event manager.
1152 */
1153 static OPJ_BOOL opj_j2k_end_encoding(opj_j2k_t *p_j2k,
1154                                      opj_stream_private_t *p_stream,
1155                                      opj_event_mgr_t * p_manager);
1156
1157 /**
1158  * Writes the CBD marker (Component bit depth definition)
1159  *
1160  * @param       p_stream                                the stream to write data to.
1161  * @param       p_j2k                           J2K codec.
1162  * @param       p_manager               the user event manager.
1163 */
1164 static OPJ_BOOL opj_j2k_write_cbd(opj_j2k_t *p_j2k,
1165                                   opj_stream_private_t *p_stream,
1166                                   opj_event_mgr_t * p_manager);
1167
1168 /**
1169  * Reads a CBD marker (Component bit depth definition)
1170  * @param       p_header_data   the data contained in the CBD box.
1171  * @param       p_j2k                   the jpeg2000 codec.
1172  * @param       p_header_size   the size of the data contained in the CBD marker.
1173  * @param       p_manager               the user event manager.
1174 */
1175 static OPJ_BOOL opj_j2k_read_cbd(opj_j2k_t *p_j2k,
1176                                  OPJ_BYTE * p_header_data,
1177                                  OPJ_UINT32 p_header_size,
1178                                  opj_event_mgr_t * p_manager);
1179
1180 /**
1181  * Reads a CAP marker (extended capabilities definition). Empty implementation.
1182  * Found in HTJ2K files
1183  *
1184  * @param       p_header_data   the data contained in the CAP box.
1185  * @param       p_j2k                   the jpeg2000 codec.
1186  * @param       p_header_size   the size of the data contained in the CAP marker.
1187  * @param       p_manager               the user event manager.
1188 */
1189 static OPJ_BOOL opj_j2k_read_cap(opj_j2k_t *p_j2k,
1190                                  OPJ_BYTE * p_header_data,
1191                                  OPJ_UINT32 p_header_size,
1192                                  opj_event_mgr_t * p_manager);
1193
1194 /**
1195  * Reads a CPF marker (corresponding profile). Empty implementation. Found in HTJ2K files
1196  * @param       p_header_data   the data contained in the CPF box.
1197  * @param       p_j2k                   the jpeg2000 codec.
1198  * @param       p_header_size   the size of the data contained in the CPF marker.
1199  * @param       p_manager               the user event manager.
1200 */
1201 static OPJ_BOOL opj_j2k_read_cpf(opj_j2k_t *p_j2k,
1202                                  OPJ_BYTE * p_header_data,
1203                                  OPJ_UINT32 p_header_size,
1204                                  opj_event_mgr_t * p_manager);
1205
1206
1207 /**
1208  * Writes COC marker for each component.
1209  *
1210  * @param       p_stream                the stream to write data to.
1211  * @param       p_j2k                   J2K codec.
1212  * @param       p_manager               the user event manager.
1213 */
1214 static OPJ_BOOL opj_j2k_write_all_coc(opj_j2k_t *p_j2k,
1215                                       opj_stream_private_t *p_stream,
1216                                       opj_event_mgr_t * p_manager);
1217
1218 /**
1219  * Writes QCC marker for each component.
1220  *
1221  * @param       p_stream                the stream to write data to.
1222  * @param       p_j2k                   J2K codec.
1223  * @param       p_manager               the user event manager.
1224 */
1225 static OPJ_BOOL opj_j2k_write_all_qcc(opj_j2k_t *p_j2k,
1226                                       opj_stream_private_t *p_stream,
1227                                       opj_event_mgr_t * p_manager);
1228
1229 /**
1230  * Writes regions of interests.
1231  *
1232  * @param       p_stream                the stream to write data to.
1233  * @param       p_j2k                   J2K codec.
1234  * @param       p_manager               the user event manager.
1235 */
1236 static OPJ_BOOL opj_j2k_write_regions(opj_j2k_t *p_j2k,
1237                                       opj_stream_private_t *p_stream,
1238                                       opj_event_mgr_t * p_manager);
1239
1240 /**
1241  * Writes EPC ????
1242  *
1243  * @param       p_stream                the stream to write data to.
1244  * @param       p_j2k                   J2K codec.
1245  * @param       p_manager               the user event manager.
1246 */
1247 static OPJ_BOOL opj_j2k_write_epc(opj_j2k_t *p_j2k,
1248                                   opj_stream_private_t *p_stream,
1249                                   opj_event_mgr_t * p_manager);
1250
1251 /**
1252  * Checks the progression order changes values. Tells of the poc given as input are valid.
1253  * A nice message is outputted at errors.
1254  *
1255  * @param       p_pocs                  the progression order changes.
1256  * @param       tileno                  the tile number of interest
1257  * @param       p_nb_pocs               the number of progression order changes.
1258  * @param       p_nb_resolutions        the number of resolutions.
1259  * @param       numcomps                the number of components
1260  * @param       numlayers               the number of layers.
1261  * @param       p_manager               the user event manager.
1262  *
1263  * @return      true if the pocs are valid.
1264  */
1265 static OPJ_BOOL opj_j2k_check_poc_val(const opj_poc_t *p_pocs,
1266                                       OPJ_UINT32 tileno,
1267                                       OPJ_UINT32 p_nb_pocs,
1268                                       OPJ_UINT32 p_nb_resolutions,
1269                                       OPJ_UINT32 numcomps,
1270                                       OPJ_UINT32 numlayers,
1271                                       opj_event_mgr_t * p_manager);
1272
1273 /**
1274  * Gets the number of tile parts used for the given change of progression (if any) and the given tile.
1275  *
1276  * @param               cp                      the coding parameters.
1277  * @param               pino            the offset of the given poc (i.e. its position in the coding parameter).
1278  * @param               tileno          the given tile.
1279  *
1280  * @return              the number of tile parts.
1281  */
1282 static OPJ_UINT32 opj_j2k_get_num_tp(opj_cp_t *cp, OPJ_UINT32 pino,
1283                                      OPJ_UINT32 tileno);
1284
1285 /**
1286  * Calculates the total number of tile parts needed by the encoder to
1287  * encode such an image. If not enough memory is available, then the function return false.
1288  *
1289  * @param       p_nb_tiles      pointer that will hold the number of tile parts.
1290  * @param       cp                      the coding parameters for the image.
1291  * @param       image           the image to encode.
1292  * @param       p_j2k                   the p_j2k encoder.
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_calculate_tp(opj_j2k_t *p_j2k,
1298                                      opj_cp_t *cp,
1299                                      OPJ_UINT32 * p_nb_tiles,
1300                                      opj_image_t *image,
1301                                      opj_event_mgr_t * p_manager);
1302
1303 static void opj_j2k_dump_MH_info(opj_j2k_t* p_j2k, FILE* out_stream);
1304
1305 static void opj_j2k_dump_MH_index(opj_j2k_t* p_j2k, FILE* out_stream);
1306
1307 static opj_codestream_index_t* opj_j2k_create_cstr_index(void);
1308
1309 static OPJ_FLOAT32 opj_j2k_get_tp_stride(opj_tcp_t * p_tcp);
1310
1311 static OPJ_FLOAT32 opj_j2k_get_default_stride(opj_tcp_t * p_tcp);
1312
1313 static int opj_j2k_initialise_4K_poc(opj_poc_t *POC, int numres);
1314
1315 static void opj_j2k_set_cinema_parameters(opj_cparameters_t *parameters,
1316         opj_image_t *image, opj_event_mgr_t *p_manager);
1317
1318 static OPJ_BOOL opj_j2k_is_cinema_compliant(opj_image_t *image, OPJ_UINT16 rsiz,
1319         opj_event_mgr_t *p_manager);
1320
1321 static void opj_j2k_set_imf_parameters(opj_cparameters_t *parameters,
1322                                        opj_image_t *image, opj_event_mgr_t *p_manager);
1323
1324 static OPJ_BOOL opj_j2k_is_imf_compliant(opj_cparameters_t *parameters,
1325         opj_image_t *image,
1326         opj_event_mgr_t *p_manager);
1327
1328 /**
1329  * Checks for invalid number of tile-parts in SOT marker (TPsot==TNsot). See issue 254.
1330  *
1331  * @param       p_stream            the stream to read data from.
1332  * @param       tile_no             tile number we're looking for.
1333  * @param       p_correction_needed output value. if true, non conformant codestream needs TNsot correction.
1334  * @param       p_manager       the user event manager.
1335  *
1336  * @return true if the function was successful, false else.
1337  */
1338 static OPJ_BOOL opj_j2k_need_nb_tile_parts_correction(opj_stream_private_t
1339         *p_stream, OPJ_UINT32 tile_no, OPJ_BOOL* p_correction_needed,
1340         opj_event_mgr_t * p_manager);
1341
1342 /*@}*/
1343
1344 /*@}*/
1345
1346 /* ----------------------------------------------------------------------- */
1347 typedef struct j2k_prog_order {
1348     OPJ_PROG_ORDER enum_prog;
1349     char str_prog[5];
1350 } j2k_prog_order_t;
1351
1352 static const j2k_prog_order_t j2k_prog_order_list[] = {
1353     {OPJ_CPRL, "CPRL"},
1354     {OPJ_LRCP, "LRCP"},
1355     {OPJ_PCRL, "PCRL"},
1356     {OPJ_RLCP, "RLCP"},
1357     {OPJ_RPCL, "RPCL"},
1358     {(OPJ_PROG_ORDER) - 1, ""}
1359 };
1360
1361 /**
1362  * FIXME DOC
1363  */
1364 static const OPJ_UINT32 MCT_ELEMENT_SIZE [] = {
1365     2,
1366     4,
1367     4,
1368     8
1369 };
1370
1371 typedef void (* opj_j2k_mct_function)(const void * p_src_data,
1372                                       void * p_dest_data, OPJ_UINT32 p_nb_elem);
1373
1374 static const opj_j2k_mct_function j2k_mct_read_functions_to_float [] = {
1375     opj_j2k_read_int16_to_float,
1376     opj_j2k_read_int32_to_float,
1377     opj_j2k_read_float32_to_float,
1378     opj_j2k_read_float64_to_float
1379 };
1380
1381 static const opj_j2k_mct_function j2k_mct_read_functions_to_int32 [] = {
1382     opj_j2k_read_int16_to_int32,
1383     opj_j2k_read_int32_to_int32,
1384     opj_j2k_read_float32_to_int32,
1385     opj_j2k_read_float64_to_int32
1386 };
1387
1388 static const opj_j2k_mct_function j2k_mct_write_functions_from_float [] = {
1389     opj_j2k_write_float_to_int16,
1390     opj_j2k_write_float_to_int32,
1391     opj_j2k_write_float_to_float,
1392     opj_j2k_write_float_to_float64
1393 };
1394
1395 typedef struct opj_dec_memory_marker_handler {
1396     /** marker value */
1397     OPJ_UINT32 id;
1398     /** value of the state when the marker can appear */
1399     OPJ_UINT32 states;
1400     /** action linked to the marker */
1401     OPJ_BOOL(*handler)(opj_j2k_t *p_j2k,
1402                        OPJ_BYTE * p_header_data,
1403                        OPJ_UINT32 p_header_size,
1404                        opj_event_mgr_t * p_manager);
1405 }
1406 opj_dec_memory_marker_handler_t;
1407
1408 static const opj_dec_memory_marker_handler_t j2k_memory_marker_handler_tab [] =
1409 {
1410     {J2K_MS_SOT, J2K_STATE_MH | J2K_STATE_TPHSOT, opj_j2k_read_sot},
1411     {J2K_MS_COD, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_cod},
1412     {J2K_MS_COC, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_coc},
1413     {J2K_MS_RGN, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_rgn},
1414     {J2K_MS_QCD, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_qcd},
1415     {J2K_MS_QCC, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_qcc},
1416     {J2K_MS_POC, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_poc},
1417     {J2K_MS_SIZ, J2K_STATE_MHSIZ, opj_j2k_read_siz},
1418     {J2K_MS_TLM, J2K_STATE_MH, opj_j2k_read_tlm},
1419     {J2K_MS_PLM, J2K_STATE_MH, opj_j2k_read_plm},
1420     {J2K_MS_PLT, J2K_STATE_TPH, opj_j2k_read_plt},
1421     {J2K_MS_PPM, J2K_STATE_MH, opj_j2k_read_ppm},
1422     {J2K_MS_PPT, J2K_STATE_TPH, opj_j2k_read_ppt},
1423     {J2K_MS_SOP, 0, 0},
1424     {J2K_MS_CRG, J2K_STATE_MH, opj_j2k_read_crg},
1425     {J2K_MS_COM, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_com},
1426     {J2K_MS_MCT, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_mct},
1427     {J2K_MS_CBD, J2K_STATE_MH, opj_j2k_read_cbd},
1428     {J2K_MS_CAP, J2K_STATE_MH, opj_j2k_read_cap},
1429     {J2K_MS_CPF, J2K_STATE_MH, opj_j2k_read_cpf},
1430     {J2K_MS_MCC, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_mcc},
1431     {J2K_MS_MCO, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_mco},
1432 #ifdef USE_JPWL
1433 #ifdef TODO_MS /* remove these functions which are not compatible with the v2 API */
1434     {J2K_MS_EPC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_epc},
1435     {J2K_MS_EPB, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_epb},
1436     {J2K_MS_ESD, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_esd},
1437     {J2K_MS_RED, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_red},
1438 #endif
1439 #endif /* USE_JPWL */
1440 #ifdef USE_JPSEC
1441     {J2K_MS_SEC, J2K_DEC_STATE_MH, j2k_read_sec},
1442     {J2K_MS_INSEC, 0, j2k_read_insec}
1443 #endif /* USE_JPSEC */
1444     {J2K_MS_UNK, J2K_STATE_MH | J2K_STATE_TPH, 0}/*opj_j2k_read_unk is directly used*/
1445 };
1446
1447 static void  opj_j2k_read_int16_to_float(const void * p_src_data,
1448         void * p_dest_data, OPJ_UINT32 p_nb_elem)
1449 {
1450     OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
1451     OPJ_FLOAT32 * l_dest_data = (OPJ_FLOAT32 *) p_dest_data;
1452     OPJ_UINT32 i;
1453     OPJ_UINT32 l_temp;
1454
1455     for (i = 0; i < p_nb_elem; ++i) {
1456         opj_read_bytes(l_src_data, &l_temp, 2);
1457
1458         l_src_data += sizeof(OPJ_INT16);
1459
1460         *(l_dest_data++) = (OPJ_FLOAT32) l_temp;
1461     }
1462 }
1463
1464 static void  opj_j2k_read_int32_to_float(const void * p_src_data,
1465         void * p_dest_data, OPJ_UINT32 p_nb_elem)
1466 {
1467     OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
1468     OPJ_FLOAT32 * l_dest_data = (OPJ_FLOAT32 *) p_dest_data;
1469     OPJ_UINT32 i;
1470     OPJ_UINT32 l_temp;
1471
1472     for (i = 0; i < p_nb_elem; ++i) {
1473         opj_read_bytes(l_src_data, &l_temp, 4);
1474
1475         l_src_data += sizeof(OPJ_INT32);
1476
1477         *(l_dest_data++) = (OPJ_FLOAT32) l_temp;
1478     }
1479 }
1480
1481 static void  opj_j2k_read_float32_to_float(const void * p_src_data,
1482         void * p_dest_data, OPJ_UINT32 p_nb_elem)
1483 {
1484     OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
1485     OPJ_FLOAT32 * l_dest_data = (OPJ_FLOAT32 *) p_dest_data;
1486     OPJ_UINT32 i;
1487     OPJ_FLOAT32 l_temp;
1488
1489     for (i = 0; i < p_nb_elem; ++i) {
1490         opj_read_float(l_src_data, &l_temp);
1491
1492         l_src_data += sizeof(OPJ_FLOAT32);
1493
1494         *(l_dest_data++) = l_temp;
1495     }
1496 }
1497
1498 static void  opj_j2k_read_float64_to_float(const void * p_src_data,
1499         void * p_dest_data, OPJ_UINT32 p_nb_elem)
1500 {
1501     OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
1502     OPJ_FLOAT32 * l_dest_data = (OPJ_FLOAT32 *) p_dest_data;
1503     OPJ_UINT32 i;
1504     OPJ_FLOAT64 l_temp;
1505
1506     for (i = 0; i < p_nb_elem; ++i) {
1507         opj_read_double(l_src_data, &l_temp);
1508
1509         l_src_data += sizeof(OPJ_FLOAT64);
1510
1511         *(l_dest_data++) = (OPJ_FLOAT32) l_temp;
1512     }
1513 }
1514
1515 static void  opj_j2k_read_int16_to_int32(const void * p_src_data,
1516         void * p_dest_data, OPJ_UINT32 p_nb_elem)
1517 {
1518     OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
1519     OPJ_INT32 * l_dest_data = (OPJ_INT32 *) p_dest_data;
1520     OPJ_UINT32 i;
1521     OPJ_UINT32 l_temp;
1522
1523     for (i = 0; i < p_nb_elem; ++i) {
1524         opj_read_bytes(l_src_data, &l_temp, 2);
1525
1526         l_src_data += sizeof(OPJ_INT16);
1527
1528         *(l_dest_data++) = (OPJ_INT32) l_temp;
1529     }
1530 }
1531
1532 static void  opj_j2k_read_int32_to_int32(const void * p_src_data,
1533         void * p_dest_data, OPJ_UINT32 p_nb_elem)
1534 {
1535     OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
1536     OPJ_INT32 * l_dest_data = (OPJ_INT32 *) p_dest_data;
1537     OPJ_UINT32 i;
1538     OPJ_UINT32 l_temp;
1539
1540     for (i = 0; i < p_nb_elem; ++i) {
1541         opj_read_bytes(l_src_data, &l_temp, 4);
1542
1543         l_src_data += sizeof(OPJ_INT32);
1544
1545         *(l_dest_data++) = (OPJ_INT32) l_temp;
1546     }
1547 }
1548
1549 static void  opj_j2k_read_float32_to_int32(const void * p_src_data,
1550         void * p_dest_data, OPJ_UINT32 p_nb_elem)
1551 {
1552     OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
1553     OPJ_INT32 * l_dest_data = (OPJ_INT32 *) p_dest_data;
1554     OPJ_UINT32 i;
1555     OPJ_FLOAT32 l_temp;
1556
1557     for (i = 0; i < p_nb_elem; ++i) {
1558         opj_read_float(l_src_data, &l_temp);
1559
1560         l_src_data += sizeof(OPJ_FLOAT32);
1561
1562         *(l_dest_data++) = (OPJ_INT32) l_temp;
1563     }
1564 }
1565
1566 static void  opj_j2k_read_float64_to_int32(const void * p_src_data,
1567         void * p_dest_data, OPJ_UINT32 p_nb_elem)
1568 {
1569     OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
1570     OPJ_INT32 * l_dest_data = (OPJ_INT32 *) p_dest_data;
1571     OPJ_UINT32 i;
1572     OPJ_FLOAT64 l_temp;
1573
1574     for (i = 0; i < p_nb_elem; ++i) {
1575         opj_read_double(l_src_data, &l_temp);
1576
1577         l_src_data += sizeof(OPJ_FLOAT64);
1578
1579         *(l_dest_data++) = (OPJ_INT32) l_temp;
1580     }
1581 }
1582
1583 static void  opj_j2k_write_float_to_int16(const void * p_src_data,
1584         void * p_dest_data, OPJ_UINT32 p_nb_elem)
1585 {
1586     OPJ_BYTE * l_dest_data = (OPJ_BYTE *) p_dest_data;
1587     OPJ_FLOAT32 * l_src_data = (OPJ_FLOAT32 *) p_src_data;
1588     OPJ_UINT32 i;
1589     OPJ_UINT32 l_temp;
1590
1591     for (i = 0; i < p_nb_elem; ++i) {
1592         l_temp = (OPJ_UINT32) * (l_src_data++);
1593
1594         opj_write_bytes(l_dest_data, l_temp, sizeof(OPJ_INT16));
1595
1596         l_dest_data += sizeof(OPJ_INT16);
1597     }
1598 }
1599
1600 static void opj_j2k_write_float_to_int32(const void * p_src_data,
1601         void * p_dest_data, OPJ_UINT32 p_nb_elem)
1602 {
1603     OPJ_BYTE * l_dest_data = (OPJ_BYTE *) p_dest_data;
1604     OPJ_FLOAT32 * l_src_data = (OPJ_FLOAT32 *) p_src_data;
1605     OPJ_UINT32 i;
1606     OPJ_UINT32 l_temp;
1607
1608     for (i = 0; i < p_nb_elem; ++i) {
1609         l_temp = (OPJ_UINT32) * (l_src_data++);
1610
1611         opj_write_bytes(l_dest_data, l_temp, sizeof(OPJ_INT32));
1612
1613         l_dest_data += sizeof(OPJ_INT32);
1614     }
1615 }
1616
1617 static void  opj_j2k_write_float_to_float(const void * p_src_data,
1618         void * p_dest_data, OPJ_UINT32 p_nb_elem)
1619 {
1620     OPJ_BYTE * l_dest_data = (OPJ_BYTE *) p_dest_data;
1621     OPJ_FLOAT32 * l_src_data = (OPJ_FLOAT32 *) p_src_data;
1622     OPJ_UINT32 i;
1623     OPJ_FLOAT32 l_temp;
1624
1625     for (i = 0; i < p_nb_elem; ++i) {
1626         l_temp = (OPJ_FLOAT32) * (l_src_data++);
1627
1628         opj_write_float(l_dest_data, l_temp);
1629
1630         l_dest_data += sizeof(OPJ_FLOAT32);
1631     }
1632 }
1633
1634 static void  opj_j2k_write_float_to_float64(const void * p_src_data,
1635         void * p_dest_data, OPJ_UINT32 p_nb_elem)
1636 {
1637     OPJ_BYTE * l_dest_data = (OPJ_BYTE *) p_dest_data;
1638     OPJ_FLOAT32 * l_src_data = (OPJ_FLOAT32 *) p_src_data;
1639     OPJ_UINT32 i;
1640     OPJ_FLOAT64 l_temp;
1641
1642     for (i = 0; i < p_nb_elem; ++i) {
1643         l_temp = (OPJ_FLOAT64) * (l_src_data++);
1644
1645         opj_write_double(l_dest_data, l_temp);
1646
1647         l_dest_data += sizeof(OPJ_FLOAT64);
1648     }
1649 }
1650
1651 const char *opj_j2k_convert_progression_order(OPJ_PROG_ORDER prg_order)
1652 {
1653     const j2k_prog_order_t *po;
1654     for (po = j2k_prog_order_list; po->enum_prog != -1; po++) {
1655         if (po->enum_prog == prg_order) {
1656             return po->str_prog;
1657         }
1658     }
1659     return po->str_prog;
1660 }
1661
1662 static OPJ_BOOL opj_j2k_check_poc_val(const opj_poc_t *p_pocs,
1663                                       OPJ_UINT32 tileno,
1664                                       OPJ_UINT32 p_nb_pocs,
1665                                       OPJ_UINT32 p_nb_resolutions,
1666                                       OPJ_UINT32 p_num_comps,
1667                                       OPJ_UINT32 p_num_layers,
1668                                       opj_event_mgr_t * p_manager)
1669 {
1670     OPJ_UINT32* packet_array;
1671     OPJ_UINT32 index, resno, compno, layno;
1672     OPJ_UINT32 i;
1673     OPJ_UINT32 step_c = 1;
1674     OPJ_UINT32 step_r = p_num_comps * step_c;
1675     OPJ_UINT32 step_l = p_nb_resolutions * step_r;
1676     OPJ_BOOL loss = OPJ_FALSE;
1677
1678     assert(p_nb_pocs > 0);
1679
1680     packet_array = (OPJ_UINT32*) opj_calloc((size_t)step_l * p_num_layers,
1681                                             sizeof(OPJ_UINT32));
1682     if (packet_array == 00) {
1683         opj_event_msg(p_manager, EVT_ERROR,
1684                       "Not enough memory for checking the poc values.\n");
1685         return OPJ_FALSE;
1686     }
1687
1688     /* iterate through all the pocs that match our tile of interest. */
1689     for (i = 0; i < p_nb_pocs; ++i) {
1690         const opj_poc_t *poc = &p_pocs[i];
1691         if (tileno + 1 == poc->tile) {
1692             index = step_r * poc->resno0;
1693
1694             /* take each resolution for each poc */
1695             for (resno = poc->resno0 ;
1696                     resno < opj_uint_min(poc->resno1, p_nb_resolutions); ++resno) {
1697                 OPJ_UINT32 res_index = index + poc->compno0 * step_c;
1698
1699                 /* take each comp of each resolution for each poc */
1700                 for (compno = poc->compno0 ;
1701                         compno < opj_uint_min(poc->compno1, p_num_comps); ++compno) {
1702                     /* The layer index always starts at zero for every progression. */
1703                     const OPJ_UINT32 layno0 = 0;
1704                     OPJ_UINT32 comp_index = res_index + layno0 * step_l;
1705
1706                     /* and finally take each layer of each res of ... */
1707                     for (layno = layno0; layno < opj_uint_min(poc->layno1, p_num_layers);
1708                             ++layno) {
1709                         packet_array[comp_index] = 1;
1710                         comp_index += step_l;
1711                     }
1712
1713                     res_index += step_c;
1714                 }
1715
1716                 index += step_r;
1717             }
1718         }
1719     }
1720
1721     index = 0;
1722     for (layno = 0; layno < p_num_layers ; ++layno) {
1723         for (resno = 0; resno < p_nb_resolutions; ++resno) {
1724             for (compno = 0; compno < p_num_comps; ++compno) {
1725                 loss |= (packet_array[index] != 1);
1726 #ifdef DEBUG_VERBOSE
1727                 if (packet_array[index] != 1) {
1728                     fprintf(stderr,
1729                             "Missing packet in POC: layno=%d resno=%d compno=%d\n",
1730                             layno, resno, compno);
1731                 }
1732 #endif
1733                 index += step_c;
1734             }
1735         }
1736     }
1737
1738     if (loss) {
1739         opj_event_msg(p_manager, EVT_ERROR, "Missing packets possible loss of data\n");
1740     }
1741
1742     opj_free(packet_array);
1743
1744     return !loss;
1745 }
1746
1747 /* ----------------------------------------------------------------------- */
1748
1749 static OPJ_UINT32 opj_j2k_get_num_tp(opj_cp_t *cp, OPJ_UINT32 pino,
1750                                      OPJ_UINT32 tileno)
1751 {
1752     const OPJ_CHAR *prog = 00;
1753     OPJ_INT32 i;
1754     OPJ_UINT32 tpnum = 1;
1755     opj_tcp_t *tcp = 00;
1756     opj_poc_t * l_current_poc = 00;
1757
1758     /*  preconditions */
1759     assert(tileno < (cp->tw * cp->th));
1760     assert(pino < (cp->tcps[tileno].numpocs + 1));
1761
1762     /* get the given tile coding parameter */
1763     tcp = &cp->tcps[tileno];
1764     assert(tcp != 00);
1765
1766     l_current_poc = &(tcp->pocs[pino]);
1767     assert(l_current_poc != 0);
1768
1769     /* get the progression order as a character string */
1770     prog = opj_j2k_convert_progression_order(tcp->prg);
1771     assert(strlen(prog) > 0);
1772
1773     if (cp->m_specific_param.m_enc.m_tp_on == 1) {
1774         for (i = 0; i < 4; ++i) {
1775             switch (prog[i]) {
1776             /* component wise */
1777             case 'C':
1778                 tpnum *= l_current_poc->compE;
1779                 break;
1780             /* resolution wise */
1781             case 'R':
1782                 tpnum *= l_current_poc->resE;
1783                 break;
1784             /* precinct wise */
1785             case 'P':
1786                 tpnum *= l_current_poc->prcE;
1787                 break;
1788             /* layer wise */
1789             case 'L':
1790                 tpnum *= l_current_poc->layE;
1791                 break;
1792             }
1793             /* would we split here ? */
1794             if (cp->m_specific_param.m_enc.m_tp_flag == prog[i]) {
1795                 cp->m_specific_param.m_enc.m_tp_pos = i;
1796                 break;
1797             }
1798         }
1799     } else {
1800         tpnum = 1;
1801     }
1802
1803     return tpnum;
1804 }
1805
1806 static OPJ_BOOL opj_j2k_calculate_tp(opj_j2k_t *p_j2k,
1807                                      opj_cp_t *cp,
1808                                      OPJ_UINT32 * p_nb_tiles,
1809                                      opj_image_t *image,
1810                                      opj_event_mgr_t * p_manager
1811                                     )
1812 {
1813     OPJ_UINT32 pino, tileno;
1814     OPJ_UINT32 l_nb_tiles;
1815     opj_tcp_t *tcp;
1816
1817     /* preconditions */
1818     assert(p_nb_tiles != 00);
1819     assert(cp != 00);
1820     assert(image != 00);
1821     assert(p_j2k != 00);
1822     assert(p_manager != 00);
1823
1824     OPJ_UNUSED(p_j2k);
1825     OPJ_UNUSED(p_manager);
1826
1827     l_nb_tiles = cp->tw * cp->th;
1828     * p_nb_tiles = 0;
1829     tcp = cp->tcps;
1830
1831     /* INDEX >> */
1832     /* TODO mergeV2: check this part which use cstr_info */
1833     /*if (p_j2k->cstr_info) {
1834             opj_tile_info_t * l_info_tile_ptr = p_j2k->cstr_info->tile;
1835
1836             for (tileno = 0; tileno < l_nb_tiles; ++tileno) {
1837                     OPJ_UINT32 cur_totnum_tp = 0;
1838
1839                     opj_pi_update_encoding_parameters(image,cp,tileno);
1840
1841                     for (pino = 0; pino <= tcp->numpocs; ++pino)
1842                     {
1843                             OPJ_UINT32 tp_num = opj_j2k_get_num_tp(cp,pino,tileno);
1844
1845                             *p_nb_tiles = *p_nb_tiles + tp_num;
1846
1847                             cur_totnum_tp += tp_num;
1848                     }
1849
1850                     tcp->m_nb_tile_parts = cur_totnum_tp;
1851
1852                     l_info_tile_ptr->tp = (opj_tp_info_t *) opj_malloc(cur_totnum_tp * sizeof(opj_tp_info_t));
1853                     if (l_info_tile_ptr->tp == 00) {
1854                             return OPJ_FALSE;
1855                     }
1856
1857                     memset(l_info_tile_ptr->tp,0,cur_totnum_tp * sizeof(opj_tp_info_t));
1858
1859                     l_info_tile_ptr->num_tps = cur_totnum_tp;
1860
1861                     ++l_info_tile_ptr;
1862                     ++tcp;
1863             }
1864     }
1865     else */{
1866         for (tileno = 0; tileno < l_nb_tiles; ++tileno) {
1867             OPJ_UINT32 cur_totnum_tp = 0;
1868
1869             opj_pi_update_encoding_parameters(image, cp, tileno);
1870
1871             for (pino = 0; pino <= tcp->numpocs; ++pino) {
1872                 OPJ_UINT32 tp_num = opj_j2k_get_num_tp(cp, pino, tileno);
1873
1874                 *p_nb_tiles = *p_nb_tiles + tp_num;
1875
1876                 cur_totnum_tp += tp_num;
1877             }
1878             tcp->m_nb_tile_parts = cur_totnum_tp;
1879
1880             ++tcp;
1881         }
1882     }
1883
1884     return OPJ_TRUE;
1885 }
1886
1887 static OPJ_BOOL opj_j2k_write_soc(opj_j2k_t *p_j2k,
1888                                   opj_stream_private_t *p_stream,
1889                                   opj_event_mgr_t * p_manager)
1890 {
1891     /* 2 bytes will be written */
1892     OPJ_BYTE * l_start_stream = 00;
1893
1894     /* preconditions */
1895     assert(p_stream != 00);
1896     assert(p_j2k != 00);
1897     assert(p_manager != 00);
1898
1899     l_start_stream = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
1900
1901     /* write SOC identifier */
1902     opj_write_bytes(l_start_stream, J2K_MS_SOC, 2);
1903
1904     if (opj_stream_write_data(p_stream, l_start_stream, 2, p_manager) != 2) {
1905         return OPJ_FALSE;
1906     }
1907
1908     /* UniPG>> */
1909 #ifdef USE_JPWL
1910     /* update markers struct */
1911     /*
1912             OPJ_BOOL res = j2k_add_marker(p_j2k->cstr_info, J2K_MS_SOC, p_stream_tell(p_stream) - 2, 2);
1913     */
1914     assert(0 && "TODO");
1915 #endif /* USE_JPWL */
1916     /* <<UniPG */
1917
1918     return OPJ_TRUE;
1919 }
1920
1921 /**
1922  * Reads a SOC marker (Start of Codestream)
1923  * @param       p_j2k           the jpeg2000 file codec.
1924  * @param       p_stream        FIXME DOC
1925  * @param       p_manager       the user event manager.
1926 */
1927 static OPJ_BOOL opj_j2k_read_soc(opj_j2k_t *p_j2k,
1928                                  opj_stream_private_t *p_stream,
1929                                  opj_event_mgr_t * p_manager
1930                                 )
1931 {
1932     OPJ_BYTE l_data [2];
1933     OPJ_UINT32 l_marker;
1934
1935     /* preconditions */
1936     assert(p_j2k != 00);
1937     assert(p_manager != 00);
1938     assert(p_stream != 00);
1939
1940     if (opj_stream_read_data(p_stream, l_data, 2, p_manager) != 2) {
1941         return OPJ_FALSE;
1942     }
1943
1944     opj_read_bytes(l_data, &l_marker, 2);
1945     if (l_marker != J2K_MS_SOC) {
1946         return OPJ_FALSE;
1947     }
1948
1949     /* Next marker should be a SIZ marker in the main header */
1950     p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_MHSIZ;
1951
1952     /* FIXME move it in a index structure included in p_j2k*/
1953     p_j2k->cstr_index->main_head_start = opj_stream_tell(p_stream) - 2;
1954
1955     opj_event_msg(p_manager, EVT_INFO,
1956                   "Start to read j2k main header (%" PRId64 ").\n",
1957                   p_j2k->cstr_index->main_head_start);
1958
1959     /* Add the marker to the codestream index*/
1960     if (OPJ_FALSE == opj_j2k_add_mhmarker(p_j2k->cstr_index, J2K_MS_SOC,
1961                                           p_j2k->cstr_index->main_head_start, 2)) {
1962         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to add mh marker\n");
1963         return OPJ_FALSE;
1964     }
1965     return OPJ_TRUE;
1966 }
1967
1968 static OPJ_BOOL opj_j2k_write_siz(opj_j2k_t *p_j2k,
1969                                   opj_stream_private_t *p_stream,
1970                                   opj_event_mgr_t * p_manager)
1971 {
1972     OPJ_UINT32 i;
1973     OPJ_UINT32 l_size_len;
1974     OPJ_BYTE * l_current_ptr;
1975     opj_image_t * l_image = 00;
1976     opj_cp_t *cp = 00;
1977     opj_image_comp_t * l_img_comp = 00;
1978
1979     /* preconditions */
1980     assert(p_stream != 00);
1981     assert(p_j2k != 00);
1982     assert(p_manager != 00);
1983
1984     l_image = p_j2k->m_private_image;
1985     cp = &(p_j2k->m_cp);
1986     l_size_len = 40 + 3 * l_image->numcomps;
1987     l_img_comp = l_image->comps;
1988
1989     if (l_size_len > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) {
1990
1991         OPJ_BYTE *new_header_tile_data = (OPJ_BYTE *) opj_realloc(
1992                                              p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_size_len);
1993         if (! new_header_tile_data) {
1994             opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
1995             p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL;
1996             p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
1997             opj_event_msg(p_manager, EVT_ERROR, "Not enough memory for the SIZ marker\n");
1998             return OPJ_FALSE;
1999         }
2000         p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data;
2001         p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_size_len;
2002     }
2003
2004     l_current_ptr = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
2005
2006     /* write SOC identifier */
2007     opj_write_bytes(l_current_ptr, J2K_MS_SIZ, 2);  /* SIZ */
2008     l_current_ptr += 2;
2009
2010     opj_write_bytes(l_current_ptr, l_size_len - 2, 2); /* L_SIZ */
2011     l_current_ptr += 2;
2012
2013     opj_write_bytes(l_current_ptr, cp->rsiz, 2);    /* Rsiz (capabilities) */
2014     l_current_ptr += 2;
2015
2016     opj_write_bytes(l_current_ptr, l_image->x1, 4); /* Xsiz */
2017     l_current_ptr += 4;
2018
2019     opj_write_bytes(l_current_ptr, l_image->y1, 4); /* Ysiz */
2020     l_current_ptr += 4;
2021
2022     opj_write_bytes(l_current_ptr, l_image->x0, 4); /* X0siz */
2023     l_current_ptr += 4;
2024
2025     opj_write_bytes(l_current_ptr, l_image->y0, 4); /* Y0siz */
2026     l_current_ptr += 4;
2027
2028     opj_write_bytes(l_current_ptr, cp->tdx, 4);             /* XTsiz */
2029     l_current_ptr += 4;
2030
2031     opj_write_bytes(l_current_ptr, cp->tdy, 4);             /* YTsiz */
2032     l_current_ptr += 4;
2033
2034     opj_write_bytes(l_current_ptr, cp->tx0, 4);             /* XT0siz */
2035     l_current_ptr += 4;
2036
2037     opj_write_bytes(l_current_ptr, cp->ty0, 4);             /* YT0siz */
2038     l_current_ptr += 4;
2039
2040     opj_write_bytes(l_current_ptr, l_image->numcomps, 2);   /* Csiz */
2041     l_current_ptr += 2;
2042
2043     for (i = 0; i < l_image->numcomps; ++i) {
2044         /* TODO here with MCT ? */
2045         opj_write_bytes(l_current_ptr, l_img_comp->prec - 1 + (l_img_comp->sgnd << 7),
2046                         1);      /* Ssiz_i */
2047         ++l_current_ptr;
2048
2049         opj_write_bytes(l_current_ptr, l_img_comp->dx, 1);      /* XRsiz_i */
2050         ++l_current_ptr;
2051
2052         opj_write_bytes(l_current_ptr, l_img_comp->dy, 1);      /* YRsiz_i */
2053         ++l_current_ptr;
2054
2055         ++l_img_comp;
2056     }
2057
2058     if (opj_stream_write_data(p_stream,
2059                               p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_size_len,
2060                               p_manager) != l_size_len) {
2061         return OPJ_FALSE;
2062     }
2063
2064     return OPJ_TRUE;
2065 }
2066
2067 /**
2068  * Reads a SIZ marker (image and tile size)
2069  * @param       p_j2k           the jpeg2000 file codec.
2070  * @param       p_header_data   the data contained in the SIZ box.
2071  * @param       p_header_size   the size of the data contained in the SIZ marker.
2072  * @param       p_manager       the user event manager.
2073 */
2074 static OPJ_BOOL opj_j2k_read_siz(opj_j2k_t *p_j2k,
2075                                  OPJ_BYTE * p_header_data,
2076                                  OPJ_UINT32 p_header_size,
2077                                  opj_event_mgr_t * p_manager
2078                                 )
2079 {
2080     OPJ_UINT32 i;
2081     OPJ_UINT32 l_nb_comp;
2082     OPJ_UINT32 l_nb_comp_remain;
2083     OPJ_UINT32 l_remaining_size;
2084     OPJ_UINT32 l_nb_tiles;
2085     OPJ_UINT32 l_tmp, l_tx1, l_ty1;
2086     OPJ_UINT32 l_prec0, l_sgnd0;
2087     opj_image_t *l_image = 00;
2088     opj_cp_t *l_cp = 00;
2089     opj_image_comp_t * l_img_comp = 00;
2090     opj_tcp_t * l_current_tile_param = 00;
2091
2092     /* preconditions */
2093     assert(p_j2k != 00);
2094     assert(p_manager != 00);
2095     assert(p_header_data != 00);
2096
2097     l_image = p_j2k->m_private_image;
2098     l_cp = &(p_j2k->m_cp);
2099
2100     /* minimum size == 39 - 3 (= minimum component parameter) */
2101     if (p_header_size < 36) {
2102         opj_event_msg(p_manager, EVT_ERROR, "Error with SIZ marker size\n");
2103         return OPJ_FALSE;
2104     }
2105
2106     l_remaining_size = p_header_size - 36;
2107     l_nb_comp = l_remaining_size / 3;
2108     l_nb_comp_remain = l_remaining_size % 3;
2109     if (l_nb_comp_remain != 0) {
2110         opj_event_msg(p_manager, EVT_ERROR, "Error with SIZ marker size\n");
2111         return OPJ_FALSE;
2112     }
2113
2114     opj_read_bytes(p_header_data, &l_tmp,
2115                    2);                                                /* Rsiz (capabilities) */
2116     p_header_data += 2;
2117     l_cp->rsiz = (OPJ_UINT16) l_tmp;
2118     opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_image->x1, 4);   /* Xsiz */
2119     p_header_data += 4;
2120     opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_image->y1, 4);   /* Ysiz */
2121     p_header_data += 4;
2122     opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_image->x0, 4);   /* X0siz */
2123     p_header_data += 4;
2124     opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_image->y0, 4);   /* Y0siz */
2125     p_header_data += 4;
2126     opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_cp->tdx,
2127                    4);             /* XTsiz */
2128     p_header_data += 4;
2129     opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_cp->tdy,
2130                    4);             /* YTsiz */
2131     p_header_data += 4;
2132     opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_cp->tx0,
2133                    4);             /* XT0siz */
2134     p_header_data += 4;
2135     opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_cp->ty0,
2136                    4);             /* YT0siz */
2137     p_header_data += 4;
2138     opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_tmp,
2139                    2);                 /* Csiz */
2140     p_header_data += 2;
2141     if (l_tmp < 16385) {
2142         l_image->numcomps = (OPJ_UINT16) l_tmp;
2143     } else {
2144         opj_event_msg(p_manager, EVT_ERROR,
2145                       "Error with SIZ marker: number of component is illegal -> %d\n", l_tmp);
2146         return OPJ_FALSE;
2147     }
2148
2149     if (l_image->numcomps != l_nb_comp) {
2150         opj_event_msg(p_manager, EVT_ERROR,
2151                       "Error with SIZ marker: number of component is not compatible with the remaining number of parameters ( %d vs %d)\n",
2152                       l_image->numcomps, l_nb_comp);
2153         return OPJ_FALSE;
2154     }
2155
2156     /* testcase 4035.pdf.SIGSEGV.d8b.3375 */
2157     /* testcase issue427-null-image-size.jp2 */
2158     if ((l_image->x0 >= l_image->x1) || (l_image->y0 >= l_image->y1)) {
2159         opj_event_msg(p_manager, EVT_ERROR,
2160                       "Error with SIZ marker: negative or zero image size (%" PRId64 " x %" PRId64
2161                       ")\n", (OPJ_INT64)l_image->x1 - l_image->x0,
2162                       (OPJ_INT64)l_image->y1 - l_image->y0);
2163         return OPJ_FALSE;
2164     }
2165     /* testcase 2539.pdf.SIGFPE.706.1712 (also 3622.pdf.SIGFPE.706.2916 and 4008.pdf.SIGFPE.706.3345 and maybe more) */
2166     if ((l_cp->tdx == 0U) || (l_cp->tdy == 0U)) {
2167         opj_event_msg(p_manager, EVT_ERROR,
2168                       "Error with SIZ marker: invalid tile size (tdx: %d, tdy: %d)\n", l_cp->tdx,
2169                       l_cp->tdy);
2170         return OPJ_FALSE;
2171     }
2172
2173     /* testcase issue427-illegal-tile-offset.jp2 */
2174     l_tx1 = opj_uint_adds(l_cp->tx0, l_cp->tdx); /* manage overflow */
2175     l_ty1 = opj_uint_adds(l_cp->ty0, l_cp->tdy); /* manage overflow */
2176     if ((l_cp->tx0 > l_image->x0) || (l_cp->ty0 > l_image->y0) ||
2177             (l_tx1 <= l_image->x0) || (l_ty1 <= l_image->y0)) {
2178         opj_event_msg(p_manager, EVT_ERROR,
2179                       "Error with SIZ marker: illegal tile offset\n");
2180         return OPJ_FALSE;
2181     }
2182     if (!p_j2k->dump_state) {
2183         OPJ_UINT32 siz_w, siz_h;
2184
2185         siz_w = l_image->x1 - l_image->x0;
2186         siz_h = l_image->y1 - l_image->y0;
2187
2188         if (p_j2k->ihdr_w > 0 && p_j2k->ihdr_h > 0
2189                 && (p_j2k->ihdr_w != siz_w || p_j2k->ihdr_h != siz_h)) {
2190             opj_event_msg(p_manager, EVT_ERROR,
2191                           "Error with SIZ marker: IHDR w(%u) h(%u) vs. SIZ w(%u) h(%u)\n", p_j2k->ihdr_w,
2192                           p_j2k->ihdr_h, siz_w, siz_h);
2193             return OPJ_FALSE;
2194         }
2195     }
2196 #ifdef USE_JPWL
2197     if (l_cp->correct) {
2198         /* if JPWL is on, we check whether TX errors have damaged
2199           too much the SIZ parameters */
2200         if (!(l_image->x1 * l_image->y1)) {
2201             opj_event_msg(p_manager, EVT_ERROR,
2202                           "JPWL: bad image size (%d x %d)\n",
2203                           l_image->x1, l_image->y1);
2204             if (!JPWL_ASSUME) {
2205                 opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n");
2206                 return OPJ_FALSE;
2207             }
2208         }
2209
2210         /* FIXME check previously in the function so why keep this piece of code ? Need by the norm ?
2211                 if (l_image->numcomps != ((len - 38) / 3)) {
2212                         opj_event_msg(p_manager, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
2213                                 "JPWL: Csiz is %d => space in SIZ only for %d comps.!!!\n",
2214                                 l_image->numcomps, ((len - 38) / 3));
2215                         if (!JPWL_ASSUME) {
2216                                 opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n");
2217                                 return OPJ_FALSE;
2218                         }
2219         */              /* we try to correct */
2220         /*              opj_event_msg(p_manager, EVT_WARNING, "- trying to adjust this\n");
2221                         if (l_image->numcomps < ((len - 38) / 3)) {
2222                                 len = 38 + 3 * l_image->numcomps;
2223                                 opj_event_msg(p_manager, EVT_WARNING, "- setting Lsiz to %d => HYPOTHESIS!!!\n",
2224                                         len);
2225                         } else {
2226                                 l_image->numcomps = ((len - 38) / 3);
2227                                 opj_event_msg(p_manager, EVT_WARNING, "- setting Csiz to %d => HYPOTHESIS!!!\n",
2228                                         l_image->numcomps);
2229                         }
2230                 }
2231         */
2232
2233         /* update components number in the jpwl_exp_comps filed */
2234         l_cp->exp_comps = l_image->numcomps;
2235     }
2236 #endif /* USE_JPWL */
2237
2238     /* Allocate the resulting image components */
2239     l_image->comps = (opj_image_comp_t*) opj_calloc(l_image->numcomps,
2240                      sizeof(opj_image_comp_t));
2241     if (l_image->comps == 00) {
2242         l_image->numcomps = 0;
2243         opj_event_msg(p_manager, EVT_ERROR,
2244                       "Not enough memory to take in charge SIZ marker\n");
2245         return OPJ_FALSE;
2246     }
2247
2248     l_img_comp = l_image->comps;
2249
2250     l_prec0 = 0;
2251     l_sgnd0 = 0;
2252     /* Read the component information */
2253     for (i = 0; i < l_image->numcomps; ++i) {
2254         OPJ_UINT32 tmp;
2255         opj_read_bytes(p_header_data, &tmp, 1); /* Ssiz_i */
2256         ++p_header_data;
2257         l_img_comp->prec = (tmp & 0x7f) + 1;
2258         l_img_comp->sgnd = tmp >> 7;
2259
2260         if (p_j2k->dump_state == 0) {
2261             if (i == 0) {
2262                 l_prec0 = l_img_comp->prec;
2263                 l_sgnd0 = l_img_comp->sgnd;
2264             } else if (!l_cp->allow_different_bit_depth_sign
2265                        && (l_img_comp->prec != l_prec0 || l_img_comp->sgnd != l_sgnd0)) {
2266                 opj_event_msg(p_manager, EVT_WARNING,
2267                               "Despite JP2 BPC!=255, precision and/or sgnd values for comp[%d] is different than comp[0]:\n"
2268                               "        [0] prec(%d) sgnd(%d) [%d] prec(%d) sgnd(%d)\n", i, l_prec0, l_sgnd0,
2269                               i, l_img_comp->prec, l_img_comp->sgnd);
2270             }
2271             /* TODO: we should perhaps also check against JP2 BPCC values */
2272         }
2273         opj_read_bytes(p_header_data, &tmp, 1); /* XRsiz_i */
2274         ++p_header_data;
2275         l_img_comp->dx = (OPJ_UINT32)tmp; /* should be between 1 and 255 */
2276         opj_read_bytes(p_header_data, &tmp, 1); /* YRsiz_i */
2277         ++p_header_data;
2278         l_img_comp->dy = (OPJ_UINT32)tmp; /* should be between 1 and 255 */
2279         if (l_img_comp->dx < 1 || l_img_comp->dx > 255 ||
2280                 l_img_comp->dy < 1 || l_img_comp->dy > 255) {
2281             opj_event_msg(p_manager, EVT_ERROR,
2282                           "Invalid values for comp = %d : dx=%u dy=%u (should be between 1 and 255 according to the JPEG2000 norm)\n",
2283                           i, l_img_comp->dx, l_img_comp->dy);
2284             return OPJ_FALSE;
2285         }
2286         /* Avoids later undefined shift in computation of */
2287         /* p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps[i].m_dc_level_shift = 1
2288                     << (l_image->comps[i].prec - 1); */
2289         if (l_img_comp->prec > 31) {
2290             opj_event_msg(p_manager, EVT_ERROR,
2291                           "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",
2292                           i, l_img_comp->prec);
2293             return OPJ_FALSE;
2294         }
2295 #ifdef USE_JPWL
2296         if (l_cp->correct) {
2297             /* if JPWL is on, we check whether TX errors have damaged
2298                     too much the SIZ parameters, again */
2299             if (!(l_image->comps[i].dx * l_image->comps[i].dy)) {
2300                 opj_event_msg(p_manager, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
2301                               "JPWL: bad XRsiz_%d/YRsiz_%d (%d x %d)\n",
2302                               i, i, l_image->comps[i].dx, l_image->comps[i].dy);
2303                 if (!JPWL_ASSUME) {
2304                     opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n");
2305                     return OPJ_FALSE;
2306                 }
2307                 /* we try to correct */
2308                 opj_event_msg(p_manager, EVT_WARNING, "- trying to adjust them\n");
2309                 if (!l_image->comps[i].dx) {
2310                     l_image->comps[i].dx = 1;
2311                     opj_event_msg(p_manager, EVT_WARNING,
2312                                   "- setting XRsiz_%d to %d => HYPOTHESIS!!!\n",
2313                                   i, l_image->comps[i].dx);
2314                 }
2315                 if (!l_image->comps[i].dy) {
2316                     l_image->comps[i].dy = 1;
2317                     opj_event_msg(p_manager, EVT_WARNING,
2318                                   "- setting YRsiz_%d to %d => HYPOTHESIS!!!\n",
2319                                   i, l_image->comps[i].dy);
2320                 }
2321             }
2322         }
2323 #endif /* USE_JPWL */
2324         l_img_comp->resno_decoded =
2325             0;                                                          /* number of resolution decoded */
2326         l_img_comp->factor =
2327             l_cp->m_specific_param.m_dec.m_reduce; /* reducing factor per component */
2328         ++l_img_comp;
2329     }
2330
2331     if (l_cp->tdx == 0 || l_cp->tdy == 0) {
2332         return OPJ_FALSE;
2333     }
2334
2335     /* Compute the number of tiles */
2336     l_cp->tw = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)(l_image->x1 - l_cp->tx0),
2337                                            (OPJ_INT32)l_cp->tdx);
2338     l_cp->th = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)(l_image->y1 - l_cp->ty0),
2339                                            (OPJ_INT32)l_cp->tdy);
2340
2341     /* Check that the number of tiles is valid */
2342     if (l_cp->tw == 0 || l_cp->th == 0 || l_cp->tw > 65535 / l_cp->th) {
2343         opj_event_msg(p_manager, EVT_ERROR,
2344                       "Invalid number of tiles : %u x %u (maximum fixed by jpeg2000 norm is 65535 tiles)\n",
2345                       l_cp->tw, l_cp->th);
2346         return OPJ_FALSE;
2347     }
2348     l_nb_tiles = l_cp->tw * l_cp->th;
2349
2350     /* Define the tiles which will be decoded */
2351     if (p_j2k->m_specific_param.m_decoder.m_discard_tiles) {
2352         p_j2k->m_specific_param.m_decoder.m_start_tile_x =
2353             (p_j2k->m_specific_param.m_decoder.m_start_tile_x - l_cp->tx0) / l_cp->tdx;
2354         p_j2k->m_specific_param.m_decoder.m_start_tile_y =
2355             (p_j2k->m_specific_param.m_decoder.m_start_tile_y - l_cp->ty0) / l_cp->tdy;
2356         p_j2k->m_specific_param.m_decoder.m_end_tile_x = (OPJ_UINT32)opj_int_ceildiv((
2357                     OPJ_INT32)(p_j2k->m_specific_param.m_decoder.m_end_tile_x - l_cp->tx0),
2358                 (OPJ_INT32)l_cp->tdx);
2359         p_j2k->m_specific_param.m_decoder.m_end_tile_y = (OPJ_UINT32)opj_int_ceildiv((
2360                     OPJ_INT32)(p_j2k->m_specific_param.m_decoder.m_end_tile_y - l_cp->ty0),
2361                 (OPJ_INT32)l_cp->tdy);
2362     } else {
2363         p_j2k->m_specific_param.m_decoder.m_start_tile_x = 0;
2364         p_j2k->m_specific_param.m_decoder.m_start_tile_y = 0;
2365         p_j2k->m_specific_param.m_decoder.m_end_tile_x = l_cp->tw;
2366         p_j2k->m_specific_param.m_decoder.m_end_tile_y = l_cp->th;
2367     }
2368
2369 #ifdef USE_JPWL
2370     if (l_cp->correct) {
2371         /* if JPWL is on, we check whether TX errors have damaged
2372           too much the SIZ parameters */
2373         if ((l_cp->tw < 1) || (l_cp->th < 1) || (l_cp->tw > l_cp->max_tiles) ||
2374                 (l_cp->th > l_cp->max_tiles)) {
2375             opj_event_msg(p_manager, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
2376                           "JPWL: bad number of tiles (%d x %d)\n",
2377                           l_cp->tw, l_cp->th);
2378             if (!JPWL_ASSUME) {
2379                 opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n");
2380                 return OPJ_FALSE;
2381             }
2382             /* we try to correct */
2383             opj_event_msg(p_manager, EVT_WARNING, "- trying to adjust them\n");
2384             if (l_cp->tw < 1) {
2385                 l_cp->tw = 1;
2386                 opj_event_msg(p_manager, EVT_WARNING,
2387                               "- setting %d tiles in x => HYPOTHESIS!!!\n",
2388                               l_cp->tw);
2389             }
2390             if (l_cp->tw > l_cp->max_tiles) {
2391                 l_cp->tw = 1;
2392                 opj_event_msg(p_manager, EVT_WARNING,
2393                               "- too large x, increase expectance of %d\n"
2394                               "- setting %d tiles in x => HYPOTHESIS!!!\n",
2395                               l_cp->max_tiles, l_cp->tw);
2396             }
2397             if (l_cp->th < 1) {
2398                 l_cp->th = 1;
2399                 opj_event_msg(p_manager, EVT_WARNING,
2400                               "- setting %d tiles in y => HYPOTHESIS!!!\n",
2401                               l_cp->th);
2402             }
2403             if (l_cp->th > l_cp->max_tiles) {
2404                 l_cp->th = 1;
2405                 opj_event_msg(p_manager, EVT_WARNING,
2406                               "- too large y, increase expectance of %d to continue\n",
2407                               "- setting %d tiles in y => HYPOTHESIS!!!\n",
2408                               l_cp->max_tiles, l_cp->th);
2409             }
2410         }
2411     }
2412 #endif /* USE_JPWL */
2413
2414     /* memory allocations */
2415     l_cp->tcps = (opj_tcp_t*) opj_calloc(l_nb_tiles, sizeof(opj_tcp_t));
2416     if (l_cp->tcps == 00) {
2417         opj_event_msg(p_manager, EVT_ERROR,
2418                       "Not enough memory to take in charge SIZ marker\n");
2419         return OPJ_FALSE;
2420     }
2421
2422 #ifdef USE_JPWL
2423     if (l_cp->correct) {
2424         if (!l_cp->tcps) {
2425             opj_event_msg(p_manager, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
2426                           "JPWL: could not alloc tcps field of cp\n");
2427             if (!JPWL_ASSUME) {
2428                 opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n");
2429                 return OPJ_FALSE;
2430             }
2431         }
2432     }
2433 #endif /* USE_JPWL */
2434
2435     p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps =
2436         (opj_tccp_t*) opj_calloc(l_image->numcomps, sizeof(opj_tccp_t));
2437     if (p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps  == 00) {
2438         opj_event_msg(p_manager, EVT_ERROR,
2439                       "Not enough memory to take in charge SIZ marker\n");
2440         return OPJ_FALSE;
2441     }
2442
2443     p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mct_records =
2444         (opj_mct_data_t*)opj_calloc(OPJ_J2K_MCT_DEFAULT_NB_RECORDS,
2445                                     sizeof(opj_mct_data_t));
2446
2447     if (! p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mct_records) {
2448         opj_event_msg(p_manager, EVT_ERROR,
2449                       "Not enough memory to take in charge SIZ marker\n");
2450         return OPJ_FALSE;
2451     }
2452     p_j2k->m_specific_param.m_decoder.m_default_tcp->m_nb_max_mct_records =
2453         OPJ_J2K_MCT_DEFAULT_NB_RECORDS;
2454
2455     p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mcc_records =
2456         (opj_simple_mcc_decorrelation_data_t*)
2457         opj_calloc(OPJ_J2K_MCC_DEFAULT_NB_RECORDS,
2458                    sizeof(opj_simple_mcc_decorrelation_data_t));
2459
2460     if (! p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mcc_records) {
2461         opj_event_msg(p_manager, EVT_ERROR,
2462                       "Not enough memory to take in charge SIZ marker\n");
2463         return OPJ_FALSE;
2464     }
2465     p_j2k->m_specific_param.m_decoder.m_default_tcp->m_nb_max_mcc_records =
2466         OPJ_J2K_MCC_DEFAULT_NB_RECORDS;
2467
2468     /* set up default dc level shift */
2469     for (i = 0; i < l_image->numcomps; ++i) {
2470         if (! l_image->comps[i].sgnd) {
2471             p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps[i].m_dc_level_shift = 1
2472                     << (l_image->comps[i].prec - 1);
2473         }
2474     }
2475
2476     l_current_tile_param = l_cp->tcps;
2477     for (i = 0; i < l_nb_tiles; ++i) {
2478         l_current_tile_param->tccps = (opj_tccp_t*) opj_calloc(l_image->numcomps,
2479                                       sizeof(opj_tccp_t));
2480         if (l_current_tile_param->tccps == 00) {
2481             opj_event_msg(p_manager, EVT_ERROR,
2482                           "Not enough memory to take in charge SIZ marker\n");
2483             return OPJ_FALSE;
2484         }
2485
2486         ++l_current_tile_param;
2487     }
2488
2489     p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_MH;
2490     opj_image_comp_header_update(l_image, l_cp);
2491
2492     return OPJ_TRUE;
2493 }
2494
2495 static OPJ_BOOL opj_j2k_write_com(opj_j2k_t *p_j2k,
2496                                   opj_stream_private_t *p_stream,
2497                                   opj_event_mgr_t * p_manager
2498                                  )
2499 {
2500     OPJ_UINT32 l_comment_size;
2501     OPJ_UINT32 l_total_com_size;
2502     const OPJ_CHAR *l_comment;
2503     OPJ_BYTE * l_current_ptr = 00;
2504
2505     /* preconditions */
2506     assert(p_j2k != 00);
2507     assert(p_stream != 00);
2508     assert(p_manager != 00);
2509
2510     l_comment = p_j2k->m_cp.comment;
2511     l_comment_size = (OPJ_UINT32)strlen(l_comment);
2512     l_total_com_size = l_comment_size + 6;
2513
2514     if (l_total_com_size >
2515             p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) {
2516         OPJ_BYTE *new_header_tile_data = (OPJ_BYTE *) opj_realloc(
2517                                              p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_total_com_size);
2518         if (! new_header_tile_data) {
2519             opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
2520             p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL;
2521             p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
2522             opj_event_msg(p_manager, EVT_ERROR,
2523                           "Not enough memory to write the COM marker\n");
2524             return OPJ_FALSE;
2525         }
2526         p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data;
2527         p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_total_com_size;
2528     }
2529
2530     l_current_ptr = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
2531
2532     opj_write_bytes(l_current_ptr, J2K_MS_COM, 2);  /* COM */
2533     l_current_ptr += 2;
2534
2535     opj_write_bytes(l_current_ptr, l_total_com_size - 2, 2);        /* L_COM */
2536     l_current_ptr += 2;
2537
2538     opj_write_bytes(l_current_ptr, 1,
2539                     2);   /* General use (IS 8859-15:1999 (Latin) values) */
2540     l_current_ptr += 2;
2541
2542     memcpy(l_current_ptr, l_comment, l_comment_size);
2543
2544     if (opj_stream_write_data(p_stream,
2545                               p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_total_com_size,
2546                               p_manager) != l_total_com_size) {
2547         return OPJ_FALSE;
2548     }
2549
2550     return OPJ_TRUE;
2551 }
2552
2553 /**
2554  * Reads a COM marker (comments)
2555  * @param       p_j2k           the jpeg2000 file codec.
2556  * @param       p_header_data   the data contained in the COM box.
2557  * @param       p_header_size   the size of the data contained in the COM marker.
2558  * @param       p_manager               the user event manager.
2559 */
2560 static OPJ_BOOL opj_j2k_read_com(opj_j2k_t *p_j2k,
2561                                  OPJ_BYTE * p_header_data,
2562                                  OPJ_UINT32 p_header_size,
2563                                  opj_event_mgr_t * p_manager
2564                                 )
2565 {
2566     /* preconditions */
2567     assert(p_j2k != 00);
2568     assert(p_manager != 00);
2569     assert(p_header_data != 00);
2570
2571     OPJ_UNUSED(p_j2k);
2572     OPJ_UNUSED(p_header_data);
2573     OPJ_UNUSED(p_header_size);
2574     OPJ_UNUSED(p_manager);
2575
2576     return OPJ_TRUE;
2577 }
2578
2579 static OPJ_BOOL opj_j2k_write_cod(opj_j2k_t *p_j2k,
2580                                   opj_stream_private_t *p_stream,
2581                                   opj_event_mgr_t * p_manager)
2582 {
2583     opj_cp_t *l_cp = 00;
2584     opj_tcp_t *l_tcp = 00;
2585     OPJ_UINT32 l_code_size, l_remaining_size;
2586     OPJ_BYTE * l_current_data = 00;
2587
2588     /* preconditions */
2589     assert(p_j2k != 00);
2590     assert(p_manager != 00);
2591     assert(p_stream != 00);
2592
2593     l_cp = &(p_j2k->m_cp);
2594     l_tcp = &l_cp->tcps[p_j2k->m_current_tile_number];
2595     l_code_size = 9 + opj_j2k_get_SPCod_SPCoc_size(p_j2k,
2596                   p_j2k->m_current_tile_number, 0);
2597     l_remaining_size = l_code_size;
2598
2599     if (l_code_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) {
2600         OPJ_BYTE *new_header_tile_data = (OPJ_BYTE *) opj_realloc(
2601                                              p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_code_size);
2602         if (! new_header_tile_data) {
2603             opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
2604             p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL;
2605             p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
2606             opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write COD marker\n");
2607             return OPJ_FALSE;
2608         }
2609         p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data;
2610         p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_code_size;
2611     }
2612
2613     l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
2614
2615     opj_write_bytes(l_current_data, J2K_MS_COD, 2);           /* COD */
2616     l_current_data += 2;
2617
2618     opj_write_bytes(l_current_data, l_code_size - 2, 2);      /* L_COD */
2619     l_current_data += 2;
2620
2621     opj_write_bytes(l_current_data, l_tcp->csty, 1);          /* Scod */
2622     ++l_current_data;
2623
2624     opj_write_bytes(l_current_data, (OPJ_UINT32)l_tcp->prg, 1); /* SGcod (A) */
2625     ++l_current_data;
2626
2627     opj_write_bytes(l_current_data, l_tcp->numlayers, 2);     /* SGcod (B) */
2628     l_current_data += 2;
2629
2630     opj_write_bytes(l_current_data, l_tcp->mct, 1);           /* SGcod (C) */
2631     ++l_current_data;
2632
2633     l_remaining_size -= 9;
2634
2635     if (! opj_j2k_write_SPCod_SPCoc(p_j2k, p_j2k->m_current_tile_number, 0,
2636                                     l_current_data, &l_remaining_size, p_manager)) {
2637         opj_event_msg(p_manager, EVT_ERROR, "Error writing COD marker\n");
2638         return OPJ_FALSE;
2639     }
2640
2641     if (l_remaining_size != 0) {
2642         opj_event_msg(p_manager, EVT_ERROR, "Error writing COD marker\n");
2643         return OPJ_FALSE;
2644     }
2645
2646     if (opj_stream_write_data(p_stream,
2647                               p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_code_size,
2648                               p_manager) != l_code_size) {
2649         return OPJ_FALSE;
2650     }
2651
2652     return OPJ_TRUE;
2653 }
2654
2655 /**
2656  * Reads a COD marker (Coding style defaults)
2657  * @param       p_header_data   the data contained in the COD box.
2658  * @param       p_j2k                   the jpeg2000 codec.
2659  * @param       p_header_size   the size of the data contained in the COD marker.
2660  * @param       p_manager               the user event manager.
2661 */
2662 static OPJ_BOOL opj_j2k_read_cod(opj_j2k_t *p_j2k,
2663                                  OPJ_BYTE * p_header_data,
2664                                  OPJ_UINT32 p_header_size,
2665                                  opj_event_mgr_t * p_manager
2666                                 )
2667 {
2668     /* loop */
2669     OPJ_UINT32 i;
2670     OPJ_UINT32 l_tmp;
2671     opj_cp_t *l_cp = 00;
2672     opj_tcp_t *l_tcp = 00;
2673     opj_image_t *l_image = 00;
2674
2675     /* preconditions */
2676     assert(p_header_data != 00);
2677     assert(p_j2k != 00);
2678     assert(p_manager != 00);
2679
2680     l_image = p_j2k->m_private_image;
2681     l_cp = &(p_j2k->m_cp);
2682
2683     /* If we are in the first tile-part header of the current tile */
2684     l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH) ?
2685             &l_cp->tcps[p_j2k->m_current_tile_number] :
2686             p_j2k->m_specific_param.m_decoder.m_default_tcp;
2687
2688 #if 0
2689     /* This check was added per https://github.com/uclouvain/openjpeg/commit/daed8cc9195555e101ab708a501af2dfe6d5e001 */
2690     /* but this is no longer necessary to handle issue476.jp2 */
2691     /* and this actually cause issues on legit files. See https://github.com/uclouvain/openjpeg/issues/1043 */
2692     /* Only one COD per tile */
2693     if (l_tcp->cod) {
2694         opj_event_msg(p_manager, EVT_ERROR,
2695                       "COD marker already read. No more than one COD marker per tile.\n");
2696         return OPJ_FALSE;
2697     }
2698 #endif
2699     l_tcp->cod = 1;
2700
2701     /* Make sure room is sufficient */
2702     if (p_header_size < 5) {
2703         opj_event_msg(p_manager, EVT_ERROR, "Error reading COD marker\n");
2704         return OPJ_FALSE;
2705     }
2706
2707     opj_read_bytes(p_header_data, &l_tcp->csty, 1);         /* Scod */
2708     ++p_header_data;
2709     /* Make sure we know how to decode this */
2710     if ((l_tcp->csty & ~(OPJ_UINT32)(J2K_CP_CSTY_PRT | J2K_CP_CSTY_SOP |
2711                                      J2K_CP_CSTY_EPH)) != 0U) {
2712         opj_event_msg(p_manager, EVT_ERROR, "Unknown Scod value in COD marker\n");
2713         return OPJ_FALSE;
2714     }
2715     opj_read_bytes(p_header_data, &l_tmp, 1);                       /* SGcod (A) */
2716     ++p_header_data;
2717     l_tcp->prg = (OPJ_PROG_ORDER) l_tmp;
2718     /* Make sure progression order is valid */
2719     if (l_tcp->prg > OPJ_CPRL) {
2720         opj_event_msg(p_manager, EVT_ERROR,
2721                       "Unknown progression order in COD marker\n");
2722         l_tcp->prg = OPJ_PROG_UNKNOWN;
2723     }
2724     opj_read_bytes(p_header_data, &l_tcp->numlayers, 2);    /* SGcod (B) */
2725     p_header_data += 2;
2726
2727     if ((l_tcp->numlayers < 1U) || (l_tcp->numlayers > 65535U)) {
2728         opj_event_msg(p_manager, EVT_ERROR,
2729                       "Invalid number of layers in COD marker : %d not in range [1-65535]\n",
2730                       l_tcp->numlayers);
2731         return OPJ_FALSE;
2732     }
2733
2734     /* If user didn't set a number layer to decode take the max specify in the codestream. */
2735     if (l_cp->m_specific_param.m_dec.m_layer) {
2736         l_tcp->num_layers_to_decode = l_cp->m_specific_param.m_dec.m_layer;
2737     } else {
2738         l_tcp->num_layers_to_decode = l_tcp->numlayers;
2739     }
2740
2741     opj_read_bytes(p_header_data, &l_tcp->mct, 1);          /* SGcod (C) */
2742     ++p_header_data;
2743
2744     if (l_tcp->mct > 1) {
2745         opj_event_msg(p_manager, EVT_ERROR,
2746                       "Invalid multiple component transformation\n");
2747         return OPJ_FALSE;
2748     }
2749
2750     p_header_size -= 5;
2751     for (i = 0; i < l_image->numcomps; ++i) {
2752         l_tcp->tccps[i].csty = l_tcp->csty & J2K_CCP_CSTY_PRT;
2753     }
2754
2755     if (! opj_j2k_read_SPCod_SPCoc(p_j2k, 0, p_header_data, &p_header_size,
2756                                    p_manager)) {
2757         opj_event_msg(p_manager, EVT_ERROR, "Error reading COD marker\n");
2758         return OPJ_FALSE;
2759     }
2760
2761     if (p_header_size != 0) {
2762         opj_event_msg(p_manager, EVT_ERROR, "Error reading COD marker\n");
2763         return OPJ_FALSE;
2764     }
2765
2766     /* Apply the coding style to other components of the current tile or the m_default_tcp*/
2767     opj_j2k_copy_tile_component_parameters(p_j2k);
2768
2769     /* Index */
2770 #ifdef WIP_REMOVE_MSD
2771     if (p_j2k->cstr_info) {
2772         /*opj_codestream_info_t *l_cstr_info = p_j2k->cstr_info;*/
2773         p_j2k->cstr_info->prog = l_tcp->prg;
2774         p_j2k->cstr_info->numlayers = l_tcp->numlayers;
2775         p_j2k->cstr_info->numdecompos = (OPJ_INT32*) opj_malloc(
2776                                             l_image->numcomps * sizeof(OPJ_UINT32));
2777         if (!p_j2k->cstr_info->numdecompos) {
2778             return OPJ_FALSE;
2779         }
2780         for (i = 0; i < l_image->numcomps; ++i) {
2781             p_j2k->cstr_info->numdecompos[i] = l_tcp->tccps[i].numresolutions - 1;
2782         }
2783     }
2784 #endif
2785
2786     return OPJ_TRUE;
2787 }
2788
2789 static OPJ_BOOL opj_j2k_write_coc(opj_j2k_t *p_j2k,
2790                                   OPJ_UINT32 p_comp_no,
2791                                   opj_stream_private_t *p_stream,
2792                                   opj_event_mgr_t * p_manager)
2793 {
2794     OPJ_UINT32 l_coc_size, l_remaining_size;
2795     OPJ_UINT32 l_comp_room;
2796
2797     /* preconditions */
2798     assert(p_j2k != 00);
2799     assert(p_manager != 00);
2800     assert(p_stream != 00);
2801
2802     l_comp_room = (p_j2k->m_private_image->numcomps <= 256) ? 1 : 2;
2803
2804     l_coc_size = 5 + l_comp_room + opj_j2k_get_SPCod_SPCoc_size(p_j2k,
2805                  p_j2k->m_current_tile_number, p_comp_no);
2806
2807     if (l_coc_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) {
2808         OPJ_BYTE *new_header_tile_data;
2809         /*p_j2k->m_specific_param.m_encoder.m_header_tile_data
2810                 = (OPJ_BYTE*)opj_realloc(
2811                         p_j2k->m_specific_param.m_encoder.m_header_tile_data,
2812                         l_coc_size);*/
2813
2814         new_header_tile_data = (OPJ_BYTE *) opj_realloc(
2815                                    p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_coc_size);
2816         if (! new_header_tile_data) {
2817             opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
2818             p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL;
2819             p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
2820             opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write COC marker\n");
2821             return OPJ_FALSE;
2822         }
2823         p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data;
2824         p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_coc_size;
2825     }
2826
2827     opj_j2k_write_coc_in_memory(p_j2k, p_comp_no,
2828                                 p_j2k->m_specific_param.m_encoder.m_header_tile_data, &l_remaining_size,
2829                                 p_manager);
2830
2831     if (opj_stream_write_data(p_stream,
2832                               p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_coc_size,
2833                               p_manager) != l_coc_size) {
2834         return OPJ_FALSE;
2835     }
2836
2837     return OPJ_TRUE;
2838 }
2839
2840 static OPJ_BOOL opj_j2k_compare_coc(opj_j2k_t *p_j2k,
2841                                     OPJ_UINT32 p_first_comp_no, OPJ_UINT32 p_second_comp_no)
2842 {
2843     opj_cp_t *l_cp = NULL;
2844     opj_tcp_t *l_tcp = NULL;
2845
2846     /* preconditions */
2847     assert(p_j2k != 00);
2848
2849     l_cp = &(p_j2k->m_cp);
2850     l_tcp = &l_cp->tcps[p_j2k->m_current_tile_number];
2851
2852     if (l_tcp->tccps[p_first_comp_no].csty != l_tcp->tccps[p_second_comp_no].csty) {
2853         return OPJ_FALSE;
2854     }
2855
2856
2857     return opj_j2k_compare_SPCod_SPCoc(p_j2k, p_j2k->m_current_tile_number,
2858                                        p_first_comp_no, p_second_comp_no);
2859 }
2860
2861 static void opj_j2k_write_coc_in_memory(opj_j2k_t *p_j2k,
2862                                         OPJ_UINT32 p_comp_no,
2863                                         OPJ_BYTE * p_data,
2864                                         OPJ_UINT32 * p_data_written,
2865                                         opj_event_mgr_t * p_manager
2866                                        )
2867 {
2868     opj_cp_t *l_cp = 00;
2869     opj_tcp_t *l_tcp = 00;
2870     OPJ_UINT32 l_coc_size, l_remaining_size;
2871     OPJ_BYTE * l_current_data = 00;
2872     opj_image_t *l_image = 00;
2873     OPJ_UINT32 l_comp_room;
2874
2875     /* preconditions */
2876     assert(p_j2k != 00);
2877     assert(p_manager != 00);
2878
2879     l_cp = &(p_j2k->m_cp);
2880     l_tcp = &l_cp->tcps[p_j2k->m_current_tile_number];
2881     l_image = p_j2k->m_private_image;
2882     l_comp_room = (l_image->numcomps <= 256) ? 1 : 2;
2883
2884     l_coc_size = 5 + l_comp_room + opj_j2k_get_SPCod_SPCoc_size(p_j2k,
2885                  p_j2k->m_current_tile_number, p_comp_no);
2886     l_remaining_size = l_coc_size;
2887
2888     l_current_data = p_data;
2889
2890     opj_write_bytes(l_current_data, J2K_MS_COC,
2891                     2);                         /* COC */
2892     l_current_data += 2;
2893
2894     opj_write_bytes(l_current_data, l_coc_size - 2,
2895                     2);                     /* L_COC */
2896     l_current_data += 2;
2897
2898     opj_write_bytes(l_current_data, p_comp_no, l_comp_room);        /* Ccoc */
2899     l_current_data += l_comp_room;
2900
2901     opj_write_bytes(l_current_data, l_tcp->tccps[p_comp_no].csty,
2902                     1);               /* Scoc */
2903     ++l_current_data;
2904
2905     l_remaining_size -= (5 + l_comp_room);
2906     opj_j2k_write_SPCod_SPCoc(p_j2k, p_j2k->m_current_tile_number, 0,
2907                               l_current_data, &l_remaining_size, p_manager);
2908     * p_data_written = l_coc_size;
2909 }
2910
2911 static OPJ_UINT32 opj_j2k_get_max_coc_size(opj_j2k_t *p_j2k)
2912 {
2913     OPJ_UINT32 i, j;
2914     OPJ_UINT32 l_nb_comp;
2915     OPJ_UINT32 l_nb_tiles;
2916     OPJ_UINT32 l_max = 0;
2917
2918     /* preconditions */
2919
2920     l_nb_tiles = p_j2k->m_cp.tw * p_j2k->m_cp.th ;
2921     l_nb_comp = p_j2k->m_private_image->numcomps;
2922
2923     for (i = 0; i < l_nb_tiles; ++i) {
2924         for (j = 0; j < l_nb_comp; ++j) {
2925             l_max = opj_uint_max(l_max, opj_j2k_get_SPCod_SPCoc_size(p_j2k, i, j));
2926         }
2927     }
2928
2929     return 6 + l_max;
2930 }
2931
2932 /**
2933  * Reads a COC marker (Coding Style Component)
2934  * @param       p_header_data   the data contained in the COC box.
2935  * @param       p_j2k                   the jpeg2000 codec.
2936  * @param       p_header_size   the size of the data contained in the COC marker.
2937  * @param       p_manager               the user event manager.
2938 */
2939 static OPJ_BOOL opj_j2k_read_coc(opj_j2k_t *p_j2k,
2940                                  OPJ_BYTE * p_header_data,
2941                                  OPJ_UINT32 p_header_size,
2942                                  opj_event_mgr_t * p_manager
2943                                 )
2944 {
2945     opj_cp_t *l_cp = NULL;
2946     opj_tcp_t *l_tcp = NULL;
2947     opj_image_t *l_image = NULL;
2948     OPJ_UINT32 l_comp_room;
2949     OPJ_UINT32 l_comp_no;
2950
2951     /* preconditions */
2952     assert(p_header_data != 00);
2953     assert(p_j2k != 00);
2954     assert(p_manager != 00);
2955
2956     l_cp = &(p_j2k->m_cp);
2957     l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH)
2958             ?
2959             &l_cp->tcps[p_j2k->m_current_tile_number] :
2960             p_j2k->m_specific_param.m_decoder.m_default_tcp;
2961     l_image = p_j2k->m_private_image;
2962
2963     l_comp_room = l_image->numcomps <= 256 ? 1 : 2;
2964
2965     /* make sure room is sufficient*/
2966     if (p_header_size < l_comp_room + 1) {
2967         opj_event_msg(p_manager, EVT_ERROR, "Error reading COC marker\n");
2968         return OPJ_FALSE;
2969     }
2970     p_header_size -= l_comp_room + 1;
2971
2972     opj_read_bytes(p_header_data, &l_comp_no,
2973                    l_comp_room);                 /* Ccoc */
2974     p_header_data += l_comp_room;
2975     if (l_comp_no >= l_image->numcomps) {
2976         opj_event_msg(p_manager, EVT_ERROR,
2977                       "Error reading COC marker (bad number of components)\n");
2978         return OPJ_FALSE;
2979     }
2980
2981     opj_read_bytes(p_header_data, &l_tcp->tccps[l_comp_no].csty,
2982                    1);                  /* Scoc */
2983     ++p_header_data ;
2984
2985     if (! opj_j2k_read_SPCod_SPCoc(p_j2k, l_comp_no, p_header_data, &p_header_size,
2986                                    p_manager)) {
2987         opj_event_msg(p_manager, EVT_ERROR, "Error reading COC marker\n");
2988         return OPJ_FALSE;
2989     }
2990
2991     if (p_header_size != 0) {
2992         opj_event_msg(p_manager, EVT_ERROR, "Error reading COC marker\n");
2993         return OPJ_FALSE;
2994     }
2995     return OPJ_TRUE;
2996 }
2997
2998 static OPJ_BOOL opj_j2k_write_qcd(opj_j2k_t *p_j2k,
2999                                   opj_stream_private_t *p_stream,
3000                                   opj_event_mgr_t * p_manager
3001                                  )
3002 {
3003     OPJ_UINT32 l_qcd_size, l_remaining_size;
3004     OPJ_BYTE * l_current_data = 00;
3005
3006     /* preconditions */
3007     assert(p_j2k != 00);
3008     assert(p_manager != 00);
3009     assert(p_stream != 00);
3010
3011     l_qcd_size = 4 + opj_j2k_get_SQcd_SQcc_size(p_j2k, p_j2k->m_current_tile_number,
3012                  0);
3013     l_remaining_size = l_qcd_size;
3014
3015     if (l_qcd_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) {
3016         OPJ_BYTE *new_header_tile_data = (OPJ_BYTE *) opj_realloc(
3017                                              p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_qcd_size);
3018         if (! new_header_tile_data) {
3019             opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
3020             p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL;
3021             p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
3022             opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write QCD marker\n");
3023             return OPJ_FALSE;
3024         }
3025         p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data;
3026         p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_qcd_size;
3027     }
3028
3029     l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
3030
3031     opj_write_bytes(l_current_data, J2K_MS_QCD, 2);         /* QCD */
3032     l_current_data += 2;
3033
3034     opj_write_bytes(l_current_data, l_qcd_size - 2, 2);     /* L_QCD */
3035     l_current_data += 2;
3036
3037     l_remaining_size -= 4;
3038
3039     if (! opj_j2k_write_SQcd_SQcc(p_j2k, p_j2k->m_current_tile_number, 0,
3040                                   l_current_data, &l_remaining_size, p_manager)) {
3041         opj_event_msg(p_manager, EVT_ERROR, "Error writing QCD marker\n");
3042         return OPJ_FALSE;
3043     }
3044
3045     if (l_remaining_size != 0) {
3046         opj_event_msg(p_manager, EVT_ERROR, "Error writing QCD marker\n");
3047         return OPJ_FALSE;
3048     }
3049
3050     if (opj_stream_write_data(p_stream,
3051                               p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_qcd_size,
3052                               p_manager) != l_qcd_size) {
3053         return OPJ_FALSE;
3054     }
3055
3056     return OPJ_TRUE;
3057 }
3058
3059 /**
3060  * Reads a QCD marker (Quantization defaults)
3061  * @param       p_header_data   the data contained in the QCD box.
3062  * @param       p_j2k                   the jpeg2000 codec.
3063  * @param       p_header_size   the size of the data contained in the QCD marker.
3064  * @param       p_manager               the user event manager.
3065 */
3066 static OPJ_BOOL opj_j2k_read_qcd(opj_j2k_t *p_j2k,
3067                                  OPJ_BYTE * p_header_data,
3068                                  OPJ_UINT32 p_header_size,
3069                                  opj_event_mgr_t * p_manager
3070                                 )
3071 {
3072     /* preconditions */
3073     assert(p_header_data != 00);
3074     assert(p_j2k != 00);
3075     assert(p_manager != 00);
3076
3077     if (! opj_j2k_read_SQcd_SQcc(p_j2k, 0, p_header_data, &p_header_size,
3078                                  p_manager)) {
3079         opj_event_msg(p_manager, EVT_ERROR, "Error reading QCD marker\n");
3080         return OPJ_FALSE;
3081     }
3082
3083     if (p_header_size != 0) {
3084         opj_event_msg(p_manager, EVT_ERROR, "Error reading QCD marker\n");
3085         return OPJ_FALSE;
3086     }
3087
3088     /* Apply the quantization parameters to other components of the current tile or the m_default_tcp */
3089     opj_j2k_copy_tile_quantization_parameters(p_j2k);
3090
3091     return OPJ_TRUE;
3092 }
3093
3094 static OPJ_BOOL opj_j2k_write_qcc(opj_j2k_t *p_j2k,
3095                                   OPJ_UINT32 p_comp_no,
3096                                   opj_stream_private_t *p_stream,
3097                                   opj_event_mgr_t * p_manager
3098                                  )
3099 {
3100     OPJ_UINT32 l_qcc_size, l_remaining_size;
3101
3102     /* preconditions */
3103     assert(p_j2k != 00);
3104     assert(p_manager != 00);
3105     assert(p_stream != 00);
3106
3107     l_qcc_size = 5 + opj_j2k_get_SQcd_SQcc_size(p_j2k, p_j2k->m_current_tile_number,
3108                  p_comp_no);
3109     l_qcc_size += p_j2k->m_private_image->numcomps <= 256 ? 0 : 1;
3110     l_remaining_size = l_qcc_size;
3111
3112     if (l_qcc_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) {
3113         OPJ_BYTE *new_header_tile_data = (OPJ_BYTE *) opj_realloc(
3114                                              p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_qcc_size);
3115         if (! new_header_tile_data) {
3116             opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
3117             p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL;
3118             p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
3119             opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write QCC marker\n");
3120             return OPJ_FALSE;
3121         }
3122         p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data;
3123         p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_qcc_size;
3124     }
3125
3126     opj_j2k_write_qcc_in_memory(p_j2k, p_comp_no,
3127                                 p_j2k->m_specific_param.m_encoder.m_header_tile_data, &l_remaining_size,
3128                                 p_manager);
3129
3130     if (opj_stream_write_data(p_stream,
3131                               p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_qcc_size,
3132                               p_manager) != l_qcc_size) {
3133         return OPJ_FALSE;
3134     }
3135
3136     return OPJ_TRUE;
3137 }
3138
3139 static OPJ_BOOL opj_j2k_compare_qcc(opj_j2k_t *p_j2k,
3140                                     OPJ_UINT32 p_first_comp_no, OPJ_UINT32 p_second_comp_no)
3141 {
3142     return opj_j2k_compare_SQcd_SQcc(p_j2k, p_j2k->m_current_tile_number,
3143                                      p_first_comp_no, p_second_comp_no);
3144 }
3145
3146 static void opj_j2k_write_qcc_in_memory(opj_j2k_t *p_j2k,
3147                                         OPJ_UINT32 p_comp_no,
3148                                         OPJ_BYTE * p_data,
3149                                         OPJ_UINT32 * p_data_written,
3150                                         opj_event_mgr_t * p_manager
3151                                        )
3152 {
3153     OPJ_UINT32 l_qcc_size, l_remaining_size;
3154     OPJ_BYTE * l_current_data = 00;
3155
3156     /* preconditions */
3157     assert(p_j2k != 00);
3158     assert(p_manager != 00);
3159
3160     l_qcc_size = 6 + opj_j2k_get_SQcd_SQcc_size(p_j2k, p_j2k->m_current_tile_number,
3161                  p_comp_no);
3162     l_remaining_size = l_qcc_size;
3163
3164     l_current_data = p_data;
3165
3166     opj_write_bytes(l_current_data, J2K_MS_QCC, 2);         /* QCC */
3167     l_current_data += 2;
3168
3169     if (p_j2k->m_private_image->numcomps <= 256) {
3170         --l_qcc_size;
3171
3172         opj_write_bytes(l_current_data, l_qcc_size - 2, 2);     /* L_QCC */
3173         l_current_data += 2;
3174
3175         opj_write_bytes(l_current_data, p_comp_no, 1);  /* Cqcc */
3176         ++l_current_data;
3177
3178         /* in the case only one byte is sufficient the last byte allocated is useless -> still do -6 for available */
3179         l_remaining_size -= 6;
3180     } else {
3181         opj_write_bytes(l_current_data, l_qcc_size - 2, 2);     /* L_QCC */
3182         l_current_data += 2;
3183
3184         opj_write_bytes(l_current_data, p_comp_no, 2);  /* Cqcc */
3185         l_current_data += 2;
3186
3187         l_remaining_size -= 6;
3188     }
3189
3190     opj_j2k_write_SQcd_SQcc(p_j2k, p_j2k->m_current_tile_number, p_comp_no,
3191                             l_current_data, &l_remaining_size, p_manager);
3192
3193     *p_data_written = l_qcc_size;
3194 }
3195
3196 static OPJ_UINT32 opj_j2k_get_max_qcc_size(opj_j2k_t *p_j2k)
3197 {
3198     return opj_j2k_get_max_coc_size(p_j2k);
3199 }
3200
3201 /**
3202  * Reads a QCC marker (Quantization component)
3203  * @param       p_header_data   the data contained in the QCC box.
3204  * @param       p_j2k                   the jpeg2000 codec.
3205  * @param       p_header_size   the size of the data contained in the QCC marker.
3206  * @param       p_manager               the user event manager.
3207 */
3208 static OPJ_BOOL opj_j2k_read_qcc(opj_j2k_t *p_j2k,
3209                                  OPJ_BYTE * p_header_data,
3210                                  OPJ_UINT32 p_header_size,
3211                                  opj_event_mgr_t * p_manager
3212                                 )
3213 {
3214     OPJ_UINT32 l_num_comp, l_comp_no;
3215
3216     /* preconditions */
3217     assert(p_header_data != 00);
3218     assert(p_j2k != 00);
3219     assert(p_manager != 00);
3220
3221     l_num_comp = p_j2k->m_private_image->numcomps;
3222
3223     if (l_num_comp <= 256) {
3224         if (p_header_size < 1) {
3225             opj_event_msg(p_manager, EVT_ERROR, "Error reading QCC marker\n");
3226             return OPJ_FALSE;
3227         }
3228         opj_read_bytes(p_header_data, &l_comp_no, 1);
3229         ++p_header_data;
3230         --p_header_size;
3231     } else {
3232         if (p_header_size < 2) {
3233             opj_event_msg(p_manager, EVT_ERROR, "Error reading QCC marker\n");
3234             return OPJ_FALSE;
3235         }
3236         opj_read_bytes(p_header_data, &l_comp_no, 2);
3237         p_header_data += 2;
3238         p_header_size -= 2;
3239     }
3240
3241 #ifdef USE_JPWL
3242     if (p_j2k->m_cp.correct) {
3243
3244         static OPJ_UINT32 backup_compno = 0;
3245
3246         /* compno is negative or larger than the number of components!!! */
3247         if (/*(l_comp_no < 0) ||*/ (l_comp_no >= l_num_comp)) {
3248             opj_event_msg(p_manager, EVT_ERROR,
3249                           "JPWL: bad component number in QCC (%d out of a maximum of %d)\n",
3250                           l_comp_no, l_num_comp);
3251             if (!JPWL_ASSUME) {
3252                 opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n");
3253                 return OPJ_FALSE;
3254             }
3255             /* we try to correct */
3256             l_comp_no = backup_compno % l_num_comp;
3257             opj_event_msg(p_manager, EVT_WARNING, "- trying to adjust this\n"
3258                           "- setting component number to %d\n",
3259                           l_comp_no);
3260         }
3261
3262         /* keep your private count of tiles */
3263         backup_compno++;
3264     };
3265 #endif /* USE_JPWL */
3266
3267     if (l_comp_no >= p_j2k->m_private_image->numcomps) {
3268         opj_event_msg(p_manager, EVT_ERROR,
3269                       "Invalid component number: %d, regarding the number of components %d\n",
3270                       l_comp_no, p_j2k->m_private_image->numcomps);
3271         return OPJ_FALSE;
3272     }
3273
3274     if (! opj_j2k_read_SQcd_SQcc(p_j2k, l_comp_no, p_header_data, &p_header_size,
3275                                  p_manager)) {
3276         opj_event_msg(p_manager, EVT_ERROR, "Error reading QCC marker\n");
3277         return OPJ_FALSE;
3278     }
3279
3280     if (p_header_size != 0) {
3281         opj_event_msg(p_manager, EVT_ERROR, "Error reading QCC marker\n");
3282         return OPJ_FALSE;
3283     }
3284
3285     return OPJ_TRUE;
3286 }
3287
3288 static OPJ_BOOL opj_j2k_write_poc(opj_j2k_t *p_j2k,
3289                                   opj_stream_private_t *p_stream,
3290                                   opj_event_mgr_t * p_manager
3291                                  )
3292 {
3293     OPJ_UINT32 l_nb_comp;
3294     OPJ_UINT32 l_nb_poc;
3295     OPJ_UINT32 l_poc_size;
3296     OPJ_UINT32 l_written_size = 0;
3297     opj_tcp_t *l_tcp = 00;
3298     OPJ_UINT32 l_poc_room;
3299
3300     /* preconditions */
3301     assert(p_j2k != 00);
3302     assert(p_manager != 00);
3303     assert(p_stream != 00);
3304
3305     l_tcp = &p_j2k->m_cp.tcps[p_j2k->m_current_tile_number];
3306     l_nb_comp = p_j2k->m_private_image->numcomps;
3307     l_nb_poc = 1 + l_tcp->numpocs;
3308
3309     if (l_nb_comp <= 256) {
3310         l_poc_room = 1;
3311     } else {
3312         l_poc_room = 2;
3313     }
3314     l_poc_size = 4 + (5 + 2 * l_poc_room) * l_nb_poc;
3315
3316     if (l_poc_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) {
3317         OPJ_BYTE *new_header_tile_data = (OPJ_BYTE *) opj_realloc(
3318                                              p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_poc_size);
3319         if (! new_header_tile_data) {
3320             opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
3321             p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL;
3322             p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
3323             opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write POC marker\n");
3324             return OPJ_FALSE;
3325         }
3326         p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data;
3327         p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_poc_size;
3328     }
3329
3330     opj_j2k_write_poc_in_memory(p_j2k,
3331                                 p_j2k->m_specific_param.m_encoder.m_header_tile_data, &l_written_size,
3332                                 p_manager);
3333
3334     if (opj_stream_write_data(p_stream,
3335                               p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_poc_size,
3336                               p_manager) != l_poc_size) {
3337         return OPJ_FALSE;
3338     }
3339
3340     return OPJ_TRUE;
3341 }
3342
3343 static void opj_j2k_write_poc_in_memory(opj_j2k_t *p_j2k,
3344                                         OPJ_BYTE * p_data,
3345                                         OPJ_UINT32 * p_data_written,
3346                                         opj_event_mgr_t * p_manager
3347                                        )
3348 {
3349     OPJ_UINT32 i;
3350     OPJ_BYTE * l_current_data = 00;
3351     OPJ_UINT32 l_nb_comp;
3352     OPJ_UINT32 l_nb_poc;
3353     OPJ_UINT32 l_poc_size;
3354     opj_image_t *l_image = 00;
3355     opj_tcp_t *l_tcp = 00;
3356     opj_tccp_t *l_tccp = 00;
3357     opj_poc_t *l_current_poc = 00;
3358     OPJ_UINT32 l_poc_room;
3359
3360     /* preconditions */
3361     assert(p_j2k != 00);
3362     assert(p_manager != 00);
3363
3364     OPJ_UNUSED(p_manager);
3365
3366     l_tcp = &p_j2k->m_cp.tcps[p_j2k->m_current_tile_number];
3367     l_tccp = &l_tcp->tccps[0];
3368     l_image = p_j2k->m_private_image;
3369     l_nb_comp = l_image->numcomps;
3370     l_nb_poc = 1 + l_tcp->numpocs;
3371
3372     if (l_nb_comp <= 256) {
3373         l_poc_room = 1;
3374     } else {
3375         l_poc_room = 2;
3376     }
3377
3378     l_poc_size = 4 + (5 + 2 * l_poc_room) * l_nb_poc;
3379
3380     l_current_data = p_data;
3381
3382     opj_write_bytes(l_current_data, J2K_MS_POC,
3383                     2);                                   /* POC  */
3384     l_current_data += 2;
3385
3386     opj_write_bytes(l_current_data, l_poc_size - 2,
3387                     2);                                 /* Lpoc */
3388     l_current_data += 2;
3389
3390     l_current_poc =  l_tcp->pocs;
3391     for (i = 0; i < l_nb_poc; ++i) {
3392         opj_write_bytes(l_current_data, l_current_poc->resno0,
3393                         1);                                /* RSpoc_i */
3394         ++l_current_data;
3395
3396         opj_write_bytes(l_current_data, l_current_poc->compno0,
3397                         l_poc_room);              /* CSpoc_i */
3398         l_current_data += l_poc_room;
3399
3400         opj_write_bytes(l_current_data, l_current_poc->layno1,
3401                         2);                                /* LYEpoc_i */
3402         l_current_data += 2;
3403
3404         opj_write_bytes(l_current_data, l_current_poc->resno1,
3405                         1);                                /* REpoc_i */
3406         ++l_current_data;
3407
3408         opj_write_bytes(l_current_data, l_current_poc->compno1,
3409                         l_poc_room);              /* CEpoc_i */
3410         l_current_data += l_poc_room;
3411
3412         opj_write_bytes(l_current_data, (OPJ_UINT32)l_current_poc->prg,
3413                         1);   /* Ppoc_i */
3414         ++l_current_data;
3415
3416         /* change the value of the max layer according to the actual number of layers in the file, components and resolutions*/
3417         l_current_poc->layno1 = (OPJ_UINT32)opj_int_min((OPJ_INT32)
3418                                 l_current_poc->layno1, (OPJ_INT32)l_tcp->numlayers);
3419         l_current_poc->resno1 = (OPJ_UINT32)opj_int_min((OPJ_INT32)
3420                                 l_current_poc->resno1, (OPJ_INT32)l_tccp->numresolutions);
3421         l_current_poc->compno1 = (OPJ_UINT32)opj_int_min((OPJ_INT32)
3422                                  l_current_poc->compno1, (OPJ_INT32)l_nb_comp);
3423
3424         ++l_current_poc;
3425     }
3426
3427     *p_data_written = l_poc_size;
3428 }
3429
3430 static OPJ_UINT32 opj_j2k_get_max_poc_size(opj_j2k_t *p_j2k)
3431 {
3432     opj_tcp_t * l_tcp = 00;
3433     OPJ_UINT32 l_nb_tiles = 0;
3434     OPJ_UINT32 l_max_poc = 0;
3435     OPJ_UINT32 i;
3436
3437     l_tcp = p_j2k->m_cp.tcps;
3438     l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
3439
3440     for (i = 0; i < l_nb_tiles; ++i) {
3441         l_max_poc = opj_uint_max(l_max_poc, l_tcp->numpocs);
3442         ++l_tcp;
3443     }
3444
3445     ++l_max_poc;
3446
3447     return 4 + 9 * l_max_poc;
3448 }
3449
3450 static OPJ_UINT32 opj_j2k_get_max_toc_size(opj_j2k_t *p_j2k)
3451 {
3452     OPJ_UINT32 i;
3453     OPJ_UINT32 l_nb_tiles;
3454     OPJ_UINT32 l_max = 0;
3455     opj_tcp_t * l_tcp = 00;
3456
3457     l_tcp = p_j2k->m_cp.tcps;
3458     l_nb_tiles = p_j2k->m_cp.tw * p_j2k->m_cp.th ;
3459
3460     for (i = 0; i < l_nb_tiles; ++i) {
3461         l_max = opj_uint_max(l_max, l_tcp->m_nb_tile_parts);
3462
3463         ++l_tcp;
3464     }
3465
3466     return 12 * l_max;
3467 }
3468
3469 static OPJ_UINT32 opj_j2k_get_specific_header_sizes(opj_j2k_t *p_j2k)
3470 {
3471     OPJ_UINT32 l_nb_bytes = 0;
3472     OPJ_UINT32 l_nb_comps;
3473     OPJ_UINT32 l_coc_bytes, l_qcc_bytes;
3474
3475     l_nb_comps = p_j2k->m_private_image->numcomps - 1;
3476     l_nb_bytes += opj_j2k_get_max_toc_size(p_j2k);
3477
3478     if (!(OPJ_IS_CINEMA(p_j2k->m_cp.rsiz))) {
3479         l_coc_bytes = opj_j2k_get_max_coc_size(p_j2k);
3480         l_nb_bytes += l_nb_comps * l_coc_bytes;
3481
3482         l_qcc_bytes = opj_j2k_get_max_qcc_size(p_j2k);
3483         l_nb_bytes += l_nb_comps * l_qcc_bytes;
3484     }
3485
3486     l_nb_bytes += opj_j2k_get_max_poc_size(p_j2k);
3487
3488     if (p_j2k->m_specific_param.m_encoder.m_PLT) {
3489         /* Reserve space for PLT markers */
3490
3491         OPJ_UINT32 i;
3492         const opj_cp_t * l_cp = &(p_j2k->m_cp);
3493         OPJ_UINT32 l_max_packet_count = 0;
3494         for (i = 0; i < l_cp->th * l_cp->tw; ++i) {
3495             l_max_packet_count = opj_uint_max(l_max_packet_count,
3496                                               opj_get_encoding_packet_count(p_j2k->m_private_image, l_cp, i));
3497         }
3498         /* Minimum 6 bytes per PLT marker, and at a minimum (taking a pessimistic */
3499         /* estimate of 4 bytes for a packet size), one can write */
3500         /* (65536-6) / 4 = 16382 paquet sizes per PLT marker */
3501         p_j2k->m_specific_param.m_encoder.m_reserved_bytes_for_PLT =
3502             6 * opj_uint_ceildiv(l_max_packet_count, 16382);
3503         /* Maximum 5 bytes per packet to encode a full UINT32 */
3504         p_j2k->m_specific_param.m_encoder.m_reserved_bytes_for_PLT +=
3505             l_nb_bytes += 5 * l_max_packet_count;
3506         p_j2k->m_specific_param.m_encoder.m_reserved_bytes_for_PLT += 1;
3507         l_nb_bytes += p_j2k->m_specific_param.m_encoder.m_reserved_bytes_for_PLT;
3508     }
3509
3510     /*** DEVELOPER CORNER, Add room for your headers ***/
3511
3512     return l_nb_bytes;
3513 }
3514
3515 /**
3516  * Reads a POC marker (Progression Order Change)
3517  *
3518  * @param       p_header_data   the data contained in the POC box.
3519  * @param       p_j2k                   the jpeg2000 codec.
3520  * @param       p_header_size   the size of the data contained in the POC marker.
3521  * @param       p_manager               the user event manager.
3522 */
3523 static OPJ_BOOL opj_j2k_read_poc(opj_j2k_t *p_j2k,
3524                                  OPJ_BYTE * p_header_data,
3525                                  OPJ_UINT32 p_header_size,
3526                                  opj_event_mgr_t * p_manager
3527                                 )
3528 {
3529     OPJ_UINT32 i, l_nb_comp, l_tmp;
3530     opj_image_t * l_image = 00;
3531     OPJ_UINT32 l_old_poc_nb, l_current_poc_nb, l_current_poc_remaining;
3532     OPJ_UINT32 l_chunk_size, l_comp_room;
3533
3534     opj_cp_t *l_cp = 00;
3535     opj_tcp_t *l_tcp = 00;
3536     opj_poc_t *l_current_poc = 00;
3537
3538     /* preconditions */
3539     assert(p_header_data != 00);
3540     assert(p_j2k != 00);
3541     assert(p_manager != 00);
3542
3543     l_image = p_j2k->m_private_image;
3544     l_nb_comp = l_image->numcomps;
3545     if (l_nb_comp <= 256) {
3546         l_comp_room = 1;
3547     } else {
3548         l_comp_room = 2;
3549     }
3550     l_chunk_size = 5 + 2 * l_comp_room;
3551     l_current_poc_nb = p_header_size / l_chunk_size;
3552     l_current_poc_remaining = p_header_size % l_chunk_size;
3553
3554     if ((l_current_poc_nb <= 0) || (l_current_poc_remaining != 0)) {
3555         opj_event_msg(p_manager, EVT_ERROR, "Error reading POC marker\n");
3556         return OPJ_FALSE;
3557     }
3558
3559     l_cp = &(p_j2k->m_cp);
3560     l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH) ?
3561             &l_cp->tcps[p_j2k->m_current_tile_number] :
3562             p_j2k->m_specific_param.m_decoder.m_default_tcp;
3563     l_old_poc_nb = l_tcp->POC ? l_tcp->numpocs + 1 : 0;
3564     l_current_poc_nb += l_old_poc_nb;
3565
3566     if (l_current_poc_nb >= J2K_MAX_POCS) {
3567         opj_event_msg(p_manager, EVT_ERROR, "Too many POCs %d\n", l_current_poc_nb);
3568         return OPJ_FALSE;
3569     }
3570
3571     /* now poc is in use.*/
3572     l_tcp->POC = 1;
3573
3574     l_current_poc = &l_tcp->pocs[l_old_poc_nb];
3575     for (i = l_old_poc_nb; i < l_current_poc_nb; ++i) {
3576         opj_read_bytes(p_header_data, &(l_current_poc->resno0),
3577                        1);                               /* RSpoc_i */
3578         ++p_header_data;
3579         opj_read_bytes(p_header_data, &(l_current_poc->compno0),
3580                        l_comp_room);  /* CSpoc_i */
3581         p_header_data += l_comp_room;
3582         opj_read_bytes(p_header_data, &(l_current_poc->layno1),
3583                        2);                               /* LYEpoc_i */
3584         /* make sure layer end is in acceptable bounds */
3585         l_current_poc->layno1 = opj_uint_min(l_current_poc->layno1, l_tcp->numlayers);
3586         p_header_data += 2;
3587         opj_read_bytes(p_header_data, &(l_current_poc->resno1),
3588                        1);                               /* REpoc_i */
3589         ++p_header_data;
3590         opj_read_bytes(p_header_data, &(l_current_poc->compno1),
3591                        l_comp_room);  /* CEpoc_i */
3592         p_header_data += l_comp_room;
3593         opj_read_bytes(p_header_data, &l_tmp,
3594                        1);                                                                 /* Ppoc_i */
3595         ++p_header_data;
3596         l_current_poc->prg = (OPJ_PROG_ORDER) l_tmp;
3597         /* make sure comp is in acceptable bounds */
3598         l_current_poc->compno1 = opj_uint_min(l_current_poc->compno1, l_nb_comp);
3599         ++l_current_poc;
3600     }
3601
3602     l_tcp->numpocs = l_current_poc_nb - 1;
3603     return OPJ_TRUE;
3604 }
3605
3606 /**
3607  * Reads a CRG marker (Component registration)
3608  *
3609  * @param       p_header_data   the data contained in the TLM box.
3610  * @param       p_j2k                   the jpeg2000 codec.
3611  * @param       p_header_size   the size of the data contained in the TLM marker.
3612  * @param       p_manager               the user event manager.
3613 */
3614 static OPJ_BOOL opj_j2k_read_crg(opj_j2k_t *p_j2k,
3615                                  OPJ_BYTE * p_header_data,
3616                                  OPJ_UINT32 p_header_size,
3617                                  opj_event_mgr_t * p_manager
3618                                 )
3619 {
3620     OPJ_UINT32 l_nb_comp;
3621     /* preconditions */
3622     assert(p_header_data != 00);
3623     assert(p_j2k != 00);
3624     assert(p_manager != 00);
3625
3626     OPJ_UNUSED(p_header_data);
3627
3628     l_nb_comp = p_j2k->m_private_image->numcomps;
3629
3630     if (p_header_size != l_nb_comp * 4) {
3631         opj_event_msg(p_manager, EVT_ERROR, "Error reading CRG marker\n");
3632         return OPJ_FALSE;
3633     }
3634     /* Do not care of this at the moment since only local variables are set here */
3635     /*
3636     for
3637             (i = 0; i < l_nb_comp; ++i)
3638     {
3639             opj_read_bytes(p_header_data,&l_Xcrg_i,2);                              // Xcrg_i
3640             p_header_data+=2;
3641             opj_read_bytes(p_header_data,&l_Ycrg_i,2);                              // Xcrg_i
3642             p_header_data+=2;
3643     }
3644     */
3645     return OPJ_TRUE;
3646 }
3647
3648 /**
3649  * Reads a TLM marker (Tile Length Marker)
3650  *
3651  * @param       p_header_data   the data contained in the TLM box.
3652  * @param       p_j2k                   the jpeg2000 codec.
3653  * @param       p_header_size   the size of the data contained in the TLM marker.
3654  * @param       p_manager               the user event manager.
3655 */
3656 static OPJ_BOOL opj_j2k_read_tlm(opj_j2k_t *p_j2k,
3657                                  OPJ_BYTE * p_header_data,
3658                                  OPJ_UINT32 p_header_size,
3659                                  opj_event_mgr_t * p_manager
3660                                 )
3661 {
3662     OPJ_UINT32 l_Ztlm, l_Stlm, l_ST, l_SP, l_tot_num_tp_remaining, l_quotient,
3663                l_Ptlm_size;
3664     /* preconditions */
3665     assert(p_header_data != 00);
3666     assert(p_j2k != 00);
3667     assert(p_manager != 00);
3668
3669     OPJ_UNUSED(p_j2k);
3670
3671     if (p_header_size < 2) {
3672         opj_event_msg(p_manager, EVT_ERROR, "Error reading TLM marker\n");
3673         return OPJ_FALSE;
3674     }
3675     p_header_size -= 2;
3676
3677     opj_read_bytes(p_header_data, &l_Ztlm,
3678                    1);                              /* Ztlm */
3679     ++p_header_data;
3680     opj_read_bytes(p_header_data, &l_Stlm,
3681                    1);                              /* Stlm */
3682     ++p_header_data;
3683
3684     l_ST = ((l_Stlm >> 4) & 0x3);
3685     l_SP = (l_Stlm >> 6) & 0x1;
3686
3687     l_Ptlm_size = (l_SP + 1) * 2;
3688     l_quotient = l_Ptlm_size + l_ST;
3689
3690     l_tot_num_tp_remaining = p_header_size % l_quotient;
3691
3692     if (l_tot_num_tp_remaining != 0) {
3693         opj_event_msg(p_manager, EVT_ERROR, "Error reading TLM marker\n");
3694         return OPJ_FALSE;
3695     }
3696     /* FIXME Do not care of this at the moment since only local variables are set here */
3697     /*
3698     for
3699             (i = 0; i < l_tot_num_tp; ++i)
3700     {
3701             opj_read_bytes(p_header_data,&l_Ttlm_i,l_ST);                           // Ttlm_i
3702             p_header_data += l_ST;
3703             opj_read_bytes(p_header_data,&l_Ptlm_i,l_Ptlm_size);            // Ptlm_i
3704             p_header_data += l_Ptlm_size;
3705     }*/
3706     return OPJ_TRUE;
3707 }
3708
3709 /**
3710  * Reads a PLM marker (Packet length, main header marker)
3711  *
3712  * @param       p_header_data   the data contained in the TLM box.
3713  * @param       p_j2k                   the jpeg2000 codec.
3714  * @param       p_header_size   the size of the data contained in the TLM marker.
3715  * @param       p_manager               the user event manager.
3716 */
3717 static OPJ_BOOL opj_j2k_read_plm(opj_j2k_t *p_j2k,
3718                                  OPJ_BYTE * p_header_data,
3719                                  OPJ_UINT32 p_header_size,
3720                                  opj_event_mgr_t * p_manager
3721                                 )
3722 {
3723     /* preconditions */
3724     assert(p_header_data != 00);
3725     assert(p_j2k != 00);
3726     assert(p_manager != 00);
3727
3728     OPJ_UNUSED(p_j2k);
3729     OPJ_UNUSED(p_header_data);
3730
3731     if (p_header_size < 1) {
3732         opj_event_msg(p_manager, EVT_ERROR, "Error reading PLM marker\n");
3733         return OPJ_FALSE;
3734     }
3735     /* Do not care of this at the moment since only local variables are set here */
3736     /*
3737     opj_read_bytes(p_header_data,&l_Zplm,1);                                        // Zplm
3738     ++p_header_data;
3739     --p_header_size;
3740
3741     while
3742             (p_header_size > 0)
3743     {
3744             opj_read_bytes(p_header_data,&l_Nplm,1);                                // Nplm
3745             ++p_header_data;
3746             p_header_size -= (1+l_Nplm);
3747             if
3748                     (p_header_size < 0)
3749             {
3750                     opj_event_msg(p_manager, EVT_ERROR, "Error reading PLM marker\n");
3751                     return false;
3752             }
3753             for
3754                     (i = 0; i < l_Nplm; ++i)
3755             {
3756                     opj_read_bytes(p_header_data,&l_tmp,1);                         // Iplm_ij
3757                     ++p_header_data;
3758                     // take only the last seven bytes
3759                     l_packet_len |= (l_tmp & 0x7f);
3760                     if
3761                             (l_tmp & 0x80)
3762                     {
3763                             l_packet_len <<= 7;
3764                     }
3765                     else
3766                     {
3767             // store packet length and proceed to next packet
3768                             l_packet_len = 0;
3769                     }
3770             }
3771             if
3772                     (l_packet_len != 0)
3773             {
3774                     opj_event_msg(p_manager, EVT_ERROR, "Error reading PLM marker\n");
3775                     return false;
3776             }
3777     }
3778     */
3779     return OPJ_TRUE;
3780 }
3781
3782 /**
3783  * Reads a PLT marker (Packet length, tile-part header)
3784  *
3785  * @param       p_header_data   the data contained in the PLT box.
3786  * @param       p_j2k                   the jpeg2000 codec.
3787  * @param       p_header_size   the size of the data contained in the PLT marker.
3788  * @param       p_manager               the user event manager.
3789 */
3790 static OPJ_BOOL opj_j2k_read_plt(opj_j2k_t *p_j2k,
3791                                  OPJ_BYTE * p_header_data,
3792                                  OPJ_UINT32 p_header_size,
3793                                  opj_event_mgr_t * p_manager
3794                                 )
3795 {
3796     OPJ_UINT32 l_Zplt, l_tmp, l_packet_len = 0, i;
3797
3798     /* preconditions */
3799     assert(p_header_data != 00);
3800     assert(p_j2k != 00);
3801     assert(p_manager != 00);
3802
3803     OPJ_UNUSED(p_j2k);
3804
3805     if (p_header_size < 1) {
3806         opj_event_msg(p_manager, EVT_ERROR, "Error reading PLT marker\n");
3807         return OPJ_FALSE;
3808     }
3809
3810     opj_read_bytes(p_header_data, &l_Zplt, 1);              /* Zplt */
3811     ++p_header_data;
3812     --p_header_size;
3813
3814     for (i = 0; i < p_header_size; ++i) {
3815         opj_read_bytes(p_header_data, &l_tmp, 1);       /* Iplt_ij */
3816         ++p_header_data;
3817         /* take only the last seven bytes */
3818         l_packet_len |= (l_tmp & 0x7f);
3819         if (l_tmp & 0x80) {
3820             l_packet_len <<= 7;
3821         } else {
3822             /* store packet length and proceed to next packet */
3823             l_packet_len = 0;
3824         }
3825     }
3826
3827     if (l_packet_len != 0) {
3828         opj_event_msg(p_manager, EVT_ERROR, "Error reading PLT marker\n");
3829         return OPJ_FALSE;
3830     }
3831
3832     return OPJ_TRUE;
3833 }
3834
3835 /**
3836  * Reads a PPM marker (Packed packet headers, main header)
3837  *
3838  * @param       p_header_data   the data contained in the POC box.
3839  * @param       p_j2k                   the jpeg2000 codec.
3840  * @param       p_header_size   the size of the data contained in the POC marker.
3841  * @param       p_manager               the user event manager.
3842  */
3843
3844 static OPJ_BOOL opj_j2k_read_ppm(
3845     opj_j2k_t *p_j2k,
3846     OPJ_BYTE * p_header_data,
3847     OPJ_UINT32 p_header_size,
3848     opj_event_mgr_t * p_manager)
3849 {
3850     opj_cp_t *l_cp = 00;
3851     OPJ_UINT32 l_Z_ppm;
3852
3853     /* preconditions */
3854     assert(p_header_data != 00);
3855     assert(p_j2k != 00);
3856     assert(p_manager != 00);
3857
3858     /* We need to have the Z_ppm element + 1 byte of Nppm/Ippm at minimum */
3859     if (p_header_size < 2) {
3860         opj_event_msg(p_manager, EVT_ERROR, "Error reading PPM marker\n");
3861         return OPJ_FALSE;
3862     }
3863
3864     l_cp = &(p_j2k->m_cp);
3865     l_cp->ppm = 1;
3866
3867     opj_read_bytes(p_header_data, &l_Z_ppm, 1);             /* Z_ppm */
3868     ++p_header_data;
3869     --p_header_size;
3870
3871     /* check allocation needed */
3872     if (l_cp->ppm_markers == NULL) { /* first PPM marker */
3873         OPJ_UINT32 l_newCount = l_Z_ppm + 1U; /* can't overflow, l_Z_ppm is UINT8 */
3874         assert(l_cp->ppm_markers_count == 0U);
3875
3876         l_cp->ppm_markers = (opj_ppx *) opj_calloc(l_newCount, sizeof(opj_ppx));
3877         if (l_cp->ppm_markers == NULL) {
3878             opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read PPM marker\n");
3879             return OPJ_FALSE;
3880         }
3881         l_cp->ppm_markers_count = l_newCount;
3882     } else if (l_cp->ppm_markers_count <= l_Z_ppm) {
3883         OPJ_UINT32 l_newCount = l_Z_ppm + 1U; /* can't overflow, l_Z_ppm is UINT8 */
3884         opj_ppx *new_ppm_markers;
3885         new_ppm_markers = (opj_ppx *) opj_realloc(l_cp->ppm_markers,
3886                           l_newCount * sizeof(opj_ppx));
3887         if (new_ppm_markers == NULL) {
3888             /* clean up to be done on l_cp destruction */
3889             opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read PPM marker\n");
3890             return OPJ_FALSE;
3891         }
3892         l_cp->ppm_markers = new_ppm_markers;
3893         memset(l_cp->ppm_markers + l_cp->ppm_markers_count, 0,
3894                (l_newCount - l_cp->ppm_markers_count) * sizeof(opj_ppx));
3895         l_cp->ppm_markers_count = l_newCount;
3896     }
3897
3898     if (l_cp->ppm_markers[l_Z_ppm].m_data != NULL) {
3899         /* clean up to be done on l_cp destruction */
3900         opj_event_msg(p_manager, EVT_ERROR, "Zppm %u already read\n", l_Z_ppm);
3901         return OPJ_FALSE;
3902     }
3903
3904     l_cp->ppm_markers[l_Z_ppm].m_data = (OPJ_BYTE *) opj_malloc(p_header_size);
3905     if (l_cp->ppm_markers[l_Z_ppm].m_data == NULL) {
3906         /* clean up to be done on l_cp destruction */
3907         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read PPM marker\n");
3908         return OPJ_FALSE;
3909     }
3910     l_cp->ppm_markers[l_Z_ppm].m_data_size = p_header_size;
3911     memcpy(l_cp->ppm_markers[l_Z_ppm].m_data, p_header_data, p_header_size);
3912
3913     return OPJ_TRUE;
3914 }
3915
3916 /**
3917  * Merges all PPM markers read (Packed headers, main header)
3918  *
3919  * @param       p_cp      main coding parameters.
3920  * @param       p_manager the user event manager.
3921  */
3922 static OPJ_BOOL opj_j2k_merge_ppm(opj_cp_t *p_cp, opj_event_mgr_t * p_manager)
3923 {
3924     OPJ_UINT32 i, l_ppm_data_size, l_N_ppm_remaining;
3925
3926     /* preconditions */
3927     assert(p_cp != 00);
3928     assert(p_manager != 00);
3929     assert(p_cp->ppm_buffer == NULL);
3930
3931     if (p_cp->ppm == 0U) {
3932         return OPJ_TRUE;
3933     }
3934
3935     l_ppm_data_size = 0U;
3936     l_N_ppm_remaining = 0U;
3937     for (i = 0U; i < p_cp->ppm_markers_count; ++i) {
3938         if (p_cp->ppm_markers[i].m_data !=
3939                 NULL) { /* standard doesn't seem to require contiguous Zppm */
3940             OPJ_UINT32 l_N_ppm;
3941             OPJ_UINT32 l_data_size = p_cp->ppm_markers[i].m_data_size;
3942             const OPJ_BYTE* l_data = p_cp->ppm_markers[i].m_data;
3943
3944             if (l_N_ppm_remaining >= l_data_size) {
3945                 l_N_ppm_remaining -= l_data_size;
3946                 l_data_size = 0U;
3947             } else {
3948                 l_data += l_N_ppm_remaining;
3949                 l_data_size -= l_N_ppm_remaining;
3950                 l_N_ppm_remaining = 0U;
3951             }
3952
3953             if (l_data_size > 0U) {
3954                 do {
3955                     /* read Nppm */
3956                     if (l_data_size < 4U) {
3957                         /* clean up to be done on l_cp destruction */
3958                         opj_event_msg(p_manager, EVT_ERROR, "Not enough bytes to read Nppm\n");
3959                         return OPJ_FALSE;
3960                     }
3961                     opj_read_bytes(l_data, &l_N_ppm, 4);
3962                     l_data += 4;
3963                     l_data_size -= 4;
3964                     l_ppm_data_size +=
3965                         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 */
3966
3967                     if (l_data_size >= l_N_ppm) {
3968                         l_data_size -= l_N_ppm;
3969                         l_data += l_N_ppm;
3970                     } else {
3971                         l_N_ppm_remaining = l_N_ppm - l_data_size;
3972                         l_data_size = 0U;
3973                     }
3974                 } while (l_data_size > 0U);
3975             }
3976         }
3977     }
3978
3979     if (l_N_ppm_remaining != 0U) {
3980         /* clean up to be done on l_cp destruction */
3981         opj_event_msg(p_manager, EVT_ERROR, "Corrupted PPM markers\n");
3982         return OPJ_FALSE;
3983     }
3984
3985     p_cp->ppm_buffer = (OPJ_BYTE *) opj_malloc(l_ppm_data_size);
3986     if (p_cp->ppm_buffer == 00) {
3987         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read PPM marker\n");
3988         return OPJ_FALSE;
3989     }
3990     p_cp->ppm_len = l_ppm_data_size;
3991     l_ppm_data_size = 0U;
3992     l_N_ppm_remaining = 0U;
3993     for (i = 0U; i < p_cp->ppm_markers_count; ++i) {
3994         if (p_cp->ppm_markers[i].m_data !=
3995                 NULL) { /* standard doesn't seem to require contiguous Zppm */
3996             OPJ_UINT32 l_N_ppm;
3997             OPJ_UINT32 l_data_size = p_cp->ppm_markers[i].m_data_size;
3998             const OPJ_BYTE* l_data = p_cp->ppm_markers[i].m_data;
3999
4000             if (l_N_ppm_remaining >= l_data_size) {
4001                 memcpy(p_cp->ppm_buffer + l_ppm_data_size, l_data, l_data_size);
4002                 l_ppm_data_size += l_data_size;
4003                 l_N_ppm_remaining -= l_data_size;
4004                 l_data_size = 0U;
4005             } else {
4006                 memcpy(p_cp->ppm_buffer + l_ppm_data_size, l_data, l_N_ppm_remaining);
4007                 l_ppm_data_size += l_N_ppm_remaining;
4008                 l_data += l_N_ppm_remaining;
4009                 l_data_size -= l_N_ppm_remaining;
4010                 l_N_ppm_remaining = 0U;
4011             }
4012
4013             if (l_data_size > 0U) {
4014                 do {
4015                     /* read Nppm */
4016                     if (l_data_size < 4U) {
4017                         /* clean up to be done on l_cp destruction */
4018                         opj_event_msg(p_manager, EVT_ERROR, "Not enough bytes to read Nppm\n");
4019                         return OPJ_FALSE;
4020                     }
4021                     opj_read_bytes(l_data, &l_N_ppm, 4);
4022                     l_data += 4;
4023                     l_data_size -= 4;
4024
4025                     if (l_data_size >= l_N_ppm) {
4026                         memcpy(p_cp->ppm_buffer + l_ppm_data_size, l_data, l_N_ppm);
4027                         l_ppm_data_size += l_N_ppm;
4028                         l_data_size -= l_N_ppm;
4029                         l_data += l_N_ppm;
4030                     } else {
4031                         memcpy(p_cp->ppm_buffer + l_ppm_data_size, l_data, l_data_size);
4032                         l_ppm_data_size += l_data_size;
4033                         l_N_ppm_remaining = l_N_ppm - l_data_size;
4034                         l_data_size = 0U;
4035                     }
4036                 } while (l_data_size > 0U);
4037             }
4038             opj_free(p_cp->ppm_markers[i].m_data);
4039             p_cp->ppm_markers[i].m_data = NULL;
4040             p_cp->ppm_markers[i].m_data_size = 0U;
4041         }
4042     }
4043
4044     p_cp->ppm_data = p_cp->ppm_buffer;
4045     p_cp->ppm_data_size = p_cp->ppm_len;
4046
4047     p_cp->ppm_markers_count = 0U;
4048     opj_free(p_cp->ppm_markers);
4049     p_cp->ppm_markers = NULL;
4050
4051     return OPJ_TRUE;
4052 }
4053
4054 /**
4055  * Reads a PPT marker (Packed packet headers, tile-part header)
4056  *
4057  * @param       p_header_data   the data contained in the PPT box.
4058  * @param       p_j2k                   the jpeg2000 codec.
4059  * @param       p_header_size   the size of the data contained in the PPT marker.
4060  * @param       p_manager               the user event manager.
4061 */
4062 static OPJ_BOOL opj_j2k_read_ppt(opj_j2k_t *p_j2k,
4063                                  OPJ_BYTE * p_header_data,
4064                                  OPJ_UINT32 p_header_size,
4065                                  opj_event_mgr_t * p_manager
4066                                 )
4067 {
4068     opj_cp_t *l_cp = 00;
4069     opj_tcp_t *l_tcp = 00;
4070     OPJ_UINT32 l_Z_ppt;
4071
4072     /* preconditions */
4073     assert(p_header_data != 00);
4074     assert(p_j2k != 00);
4075     assert(p_manager != 00);
4076
4077     /* We need to have the Z_ppt element + 1 byte of Ippt at minimum */
4078     if (p_header_size < 2) {
4079         opj_event_msg(p_manager, EVT_ERROR, "Error reading PPT marker\n");
4080         return OPJ_FALSE;
4081     }
4082
4083     l_cp = &(p_j2k->m_cp);
4084     if (l_cp->ppm) {
4085         opj_event_msg(p_manager, EVT_ERROR,
4086                       "Error reading PPT marker: packet header have been previously found in the main header (PPM marker).\n");
4087         return OPJ_FALSE;
4088     }
4089
4090     l_tcp = &(l_cp->tcps[p_j2k->m_current_tile_number]);
4091     l_tcp->ppt = 1;
4092
4093     opj_read_bytes(p_header_data, &l_Z_ppt, 1);             /* Z_ppt */
4094     ++p_header_data;
4095     --p_header_size;
4096
4097     /* check allocation needed */
4098     if (l_tcp->ppt_markers == NULL) { /* first PPT marker */
4099         OPJ_UINT32 l_newCount = l_Z_ppt + 1U; /* can't overflow, l_Z_ppt is UINT8 */
4100         assert(l_tcp->ppt_markers_count == 0U);
4101
4102         l_tcp->ppt_markers = (opj_ppx *) opj_calloc(l_newCount, sizeof(opj_ppx));
4103         if (l_tcp->ppt_markers == NULL) {
4104             opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read PPT marker\n");
4105             return OPJ_FALSE;
4106         }
4107         l_tcp->ppt_markers_count = l_newCount;
4108     } else if (l_tcp->ppt_markers_count <= l_Z_ppt) {
4109         OPJ_UINT32 l_newCount = l_Z_ppt + 1U; /* can't overflow, l_Z_ppt is UINT8 */
4110         opj_ppx *new_ppt_markers;
4111         new_ppt_markers = (opj_ppx *) opj_realloc(l_tcp->ppt_markers,
4112                           l_newCount * sizeof(opj_ppx));
4113         if (new_ppt_markers == NULL) {
4114             /* clean up to be done on l_tcp destruction */
4115             opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read PPT marker\n");
4116             return OPJ_FALSE;
4117         }
4118         l_tcp->ppt_markers = new_ppt_markers;
4119         memset(l_tcp->ppt_markers + l_tcp->ppt_markers_count, 0,
4120                (l_newCount - l_tcp->ppt_markers_count) * sizeof(opj_ppx));
4121         l_tcp->ppt_markers_count = l_newCount;
4122     }
4123
4124     if (l_tcp->ppt_markers[l_Z_ppt].m_data != NULL) {
4125         /* clean up to be done on l_tcp destruction */
4126         opj_event_msg(p_manager, EVT_ERROR, "Zppt %u already read\n", l_Z_ppt);
4127         return OPJ_FALSE;
4128     }
4129
4130     l_tcp->ppt_markers[l_Z_ppt].m_data = (OPJ_BYTE *) opj_malloc(p_header_size);
4131     if (l_tcp->ppt_markers[l_Z_ppt].m_data == NULL) {
4132         /* clean up to be done on l_tcp destruction */
4133         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read PPT marker\n");
4134         return OPJ_FALSE;
4135     }
4136     l_tcp->ppt_markers[l_Z_ppt].m_data_size = p_header_size;
4137     memcpy(l_tcp->ppt_markers[l_Z_ppt].m_data, p_header_data, p_header_size);
4138     return OPJ_TRUE;
4139 }
4140
4141 /**
4142  * Merges all PPT markers read (Packed packet headers, tile-part header)
4143  *
4144  * @param       p_tcp   the tile.
4145  * @param       p_manager               the user event manager.
4146  */
4147 static OPJ_BOOL opj_j2k_merge_ppt(opj_tcp_t *p_tcp, opj_event_mgr_t * p_manager)
4148 {
4149     OPJ_UINT32 i, l_ppt_data_size;
4150     /* preconditions */
4151     assert(p_tcp != 00);
4152     assert(p_manager != 00);
4153
4154     if (p_tcp->ppt_buffer != NULL) {
4155         opj_event_msg(p_manager, EVT_ERROR,
4156                       "opj_j2k_merge_ppt() has already been called\n");
4157         return OPJ_FALSE;
4158     }
4159
4160     if (p_tcp->ppt == 0U) {
4161         return OPJ_TRUE;
4162     }
4163
4164     l_ppt_data_size = 0U;
4165     for (i = 0U; i < p_tcp->ppt_markers_count; ++i) {
4166         l_ppt_data_size +=
4167             p_tcp->ppt_markers[i].m_data_size; /* can't overflow, max 256 markers of max 65536 bytes */
4168     }
4169
4170     p_tcp->ppt_buffer = (OPJ_BYTE *) opj_malloc(l_ppt_data_size);
4171     if (p_tcp->ppt_buffer == 00) {
4172         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read PPT marker\n");
4173         return OPJ_FALSE;
4174     }
4175     p_tcp->ppt_len = l_ppt_data_size;
4176     l_ppt_data_size = 0U;
4177     for (i = 0U; i < p_tcp->ppt_markers_count; ++i) {
4178         if (p_tcp->ppt_markers[i].m_data !=
4179                 NULL) { /* standard doesn't seem to require contiguous Zppt */
4180             memcpy(p_tcp->ppt_buffer + l_ppt_data_size, p_tcp->ppt_markers[i].m_data,
4181                    p_tcp->ppt_markers[i].m_data_size);
4182             l_ppt_data_size +=
4183                 p_tcp->ppt_markers[i].m_data_size; /* can't overflow, max 256 markers of max 65536 bytes */
4184
4185             opj_free(p_tcp->ppt_markers[i].m_data);
4186             p_tcp->ppt_markers[i].m_data = NULL;
4187             p_tcp->ppt_markers[i].m_data_size = 0U;
4188         }
4189     }
4190
4191     p_tcp->ppt_markers_count = 0U;
4192     opj_free(p_tcp->ppt_markers);
4193     p_tcp->ppt_markers = NULL;
4194
4195     p_tcp->ppt_data = p_tcp->ppt_buffer;
4196     p_tcp->ppt_data_size = p_tcp->ppt_len;
4197     return OPJ_TRUE;
4198 }
4199
4200 static OPJ_BOOL opj_j2k_write_tlm(opj_j2k_t *p_j2k,
4201                                   opj_stream_private_t *p_stream,
4202                                   opj_event_mgr_t * p_manager
4203                                  )
4204 {
4205     OPJ_BYTE * l_current_data = 00;
4206     OPJ_UINT32 l_tlm_size;
4207     OPJ_UINT32 size_per_tile_part;
4208
4209     /* preconditions */
4210     assert(p_j2k != 00);
4211     assert(p_manager != 00);
4212     assert(p_stream != 00);
4213
4214     /* 10921 = (65535 - header_size) / size_per_tile_part where */
4215     /* header_size = 4 and size_per_tile_part = 6 */
4216     if (p_j2k->m_specific_param.m_encoder.m_total_tile_parts > 10921) {
4217         /* We could do more but it would require writing several TLM markers */
4218         opj_event_msg(p_manager, EVT_ERROR,
4219                       "A maximum of 10921 tile-parts are supported currently "
4220                       "when writing TLM marker\n");
4221         return OPJ_FALSE;
4222     }
4223
4224     if (p_j2k->m_specific_param.m_encoder.m_total_tile_parts <= 255) {
4225         size_per_tile_part = 5;
4226         p_j2k->m_specific_param.m_encoder.m_Ttlmi_is_byte = OPJ_TRUE;
4227     } else {
4228         size_per_tile_part = 6;
4229         p_j2k->m_specific_param.m_encoder.m_Ttlmi_is_byte = OPJ_FALSE;
4230     }
4231
4232     l_tlm_size = 2 + 4 + (size_per_tile_part *
4233                           p_j2k->m_specific_param.m_encoder.m_total_tile_parts);
4234
4235     if (l_tlm_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) {
4236         OPJ_BYTE *new_header_tile_data = (OPJ_BYTE *) opj_realloc(
4237                                              p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_tlm_size);
4238         if (! new_header_tile_data) {
4239             opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
4240             p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL;
4241             p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
4242             opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write TLM marker\n");
4243             return OPJ_FALSE;
4244         }
4245         p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data;
4246         p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_tlm_size;
4247     }
4248     memset(p_j2k->m_specific_param.m_encoder.m_header_tile_data, 0, l_tlm_size);
4249
4250     l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
4251
4252     /* change the way data is written to avoid seeking if possible */
4253     /* TODO */
4254     p_j2k->m_specific_param.m_encoder.m_tlm_start = opj_stream_tell(p_stream);
4255
4256     opj_write_bytes(l_current_data, J2K_MS_TLM,
4257                     2);                                   /* TLM */
4258     l_current_data += 2;
4259
4260     opj_write_bytes(l_current_data, l_tlm_size - 2,
4261                     2);                                 /* Lpoc */
4262     l_current_data += 2;
4263
4264     opj_write_bytes(l_current_data, 0,
4265                     1);                                                    /* Ztlm=0*/
4266     ++l_current_data;
4267
4268     /* Stlm 0x50= ST=1(8bits-255 tiles max),SP=1(Ptlm=32bits) */
4269     /* Stlm 0x60= ST=2(16bits-65535 tiles max),SP=1(Ptlm=32bits) */
4270     opj_write_bytes(l_current_data,
4271                     size_per_tile_part == 5 ? 0x50 : 0x60,
4272                     1);
4273     ++l_current_data;
4274
4275     /* do nothing on the size_per_tile_part * l_j2k->m_specific_param.m_encoder.m_total_tile_parts remaining data */
4276     if (opj_stream_write_data(p_stream,
4277                               p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_tlm_size,
4278                               p_manager) != l_tlm_size) {
4279         return OPJ_FALSE;
4280     }
4281
4282     return OPJ_TRUE;
4283 }
4284
4285 static OPJ_BOOL opj_j2k_write_sot(opj_j2k_t *p_j2k,
4286                                   OPJ_BYTE * p_data,
4287                                   OPJ_UINT32 total_data_size,
4288                                   OPJ_UINT32 * p_data_written,
4289                                   const opj_stream_private_t *p_stream,
4290                                   opj_event_mgr_t * p_manager
4291                                  )
4292 {
4293     /* preconditions */
4294     assert(p_j2k != 00);
4295     assert(p_manager != 00);
4296     assert(p_stream != 00);
4297
4298     OPJ_UNUSED(p_stream);
4299
4300     if (total_data_size < 12) {
4301         opj_event_msg(p_manager, EVT_ERROR,
4302                       "Not enough bytes in output buffer to write SOT marker\n");
4303         return OPJ_FALSE;
4304     }
4305
4306     opj_write_bytes(p_data, J2K_MS_SOT,
4307                     2);                                 /* SOT */
4308     p_data += 2;
4309
4310     opj_write_bytes(p_data, 10,
4311                     2);                                                   /* Lsot */
4312     p_data += 2;
4313
4314     opj_write_bytes(p_data, p_j2k->m_current_tile_number,
4315                     2);                        /* Isot */
4316     p_data += 2;
4317
4318     /* Psot  */
4319     p_data += 4;
4320
4321     opj_write_bytes(p_data,
4322                     p_j2k->m_specific_param.m_encoder.m_current_tile_part_number,
4323                     1);                        /* TPsot */
4324     ++p_data;
4325
4326     opj_write_bytes(p_data,
4327                     p_j2k->m_cp.tcps[p_j2k->m_current_tile_number].m_nb_tile_parts,
4328                     1);                      /* TNsot */
4329     ++p_data;
4330
4331     /* UniPG>> */
4332 #ifdef USE_JPWL
4333     /* update markers struct */
4334     /*
4335             OPJ_BOOL res = j2k_add_marker(p_j2k->cstr_info, J2K_MS_SOT, p_j2k->sot_start, len + 2);
4336     */
4337     assert(0 && "TODO");
4338 #endif /* USE_JPWL */
4339
4340     * p_data_written = 12;
4341
4342     return OPJ_TRUE;
4343 }
4344
4345 static OPJ_BOOL opj_j2k_get_sot_values(OPJ_BYTE *  p_header_data,
4346                                        OPJ_UINT32  p_header_size,
4347                                        OPJ_UINT32* p_tile_no,
4348                                        OPJ_UINT32* p_tot_len,
4349                                        OPJ_UINT32* p_current_part,
4350                                        OPJ_UINT32* p_num_parts,
4351                                        opj_event_mgr_t * p_manager)
4352 {
4353     /* preconditions */
4354     assert(p_header_data != 00);
4355     assert(p_manager != 00);
4356
4357     /* Size of this marker is fixed = 12 (we have already read marker and its size)*/
4358     if (p_header_size != 8) {
4359         opj_event_msg(p_manager, EVT_ERROR, "Error reading SOT marker\n");
4360         return OPJ_FALSE;
4361     }
4362
4363     opj_read_bytes(p_header_data, p_tile_no, 2);    /* Isot */
4364     p_header_data += 2;
4365     opj_read_bytes(p_header_data, p_tot_len, 4);    /* Psot */
4366     p_header_data += 4;
4367     opj_read_bytes(p_header_data, p_current_part, 1); /* TPsot */
4368     ++p_header_data;
4369     opj_read_bytes(p_header_data, p_num_parts, 1);  /* TNsot */
4370     ++p_header_data;
4371     return OPJ_TRUE;
4372 }
4373
4374 static OPJ_BOOL opj_j2k_read_sot(opj_j2k_t *p_j2k,
4375                                  OPJ_BYTE * p_header_data,
4376                                  OPJ_UINT32 p_header_size,
4377                                  opj_event_mgr_t * p_manager)
4378 {
4379     opj_cp_t *l_cp = 00;
4380     opj_tcp_t *l_tcp = 00;
4381     OPJ_UINT32 l_tot_len, l_num_parts = 0;
4382     OPJ_UINT32 l_current_part;
4383     OPJ_UINT32 l_tile_x, l_tile_y;
4384
4385     /* preconditions */
4386
4387     assert(p_j2k != 00);
4388     assert(p_manager != 00);
4389
4390     if (! opj_j2k_get_sot_values(p_header_data, p_header_size,
4391                                  &(p_j2k->m_current_tile_number), &l_tot_len, &l_current_part, &l_num_parts,
4392                                  p_manager)) {
4393         opj_event_msg(p_manager, EVT_ERROR, "Error reading SOT marker\n");
4394         return OPJ_FALSE;
4395     }
4396 #ifdef DEBUG_VERBOSE
4397     fprintf(stderr, "SOT %d %d %d %d\n",
4398             p_j2k->m_current_tile_number, l_tot_len, l_current_part, l_num_parts);
4399 #endif
4400
4401     l_cp = &(p_j2k->m_cp);
4402
4403     /* testcase 2.pdf.SIGFPE.706.1112 */
4404     if (p_j2k->m_current_tile_number >= l_cp->tw * l_cp->th) {
4405         opj_event_msg(p_manager, EVT_ERROR, "Invalid tile number %d\n",
4406                       p_j2k->m_current_tile_number);
4407         return OPJ_FALSE;
4408     }
4409
4410     l_tcp = &l_cp->tcps[p_j2k->m_current_tile_number];
4411     l_tile_x = p_j2k->m_current_tile_number % l_cp->tw;
4412     l_tile_y = p_j2k->m_current_tile_number / l_cp->tw;
4413
4414     if (p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec < 0 ||
4415             p_j2k->m_current_tile_number == (OPJ_UINT32)
4416             p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec) {
4417         /* Do only this check if we decode all tile part headers, or if */
4418         /* we decode one precise tile. Otherwise the m_current_tile_part_number */
4419         /* might not be valid */
4420         /* Fixes issue with id_000020,sig_06,src_001958,op_flip4,pos_149 */
4421         /* of https://github.com/uclouvain/openjpeg/issues/939 */
4422         /* We must avoid reading twice the same tile part number for a given tile */
4423         /* so as to avoid various issues, like opj_j2k_merge_ppt being called */
4424         /* several times. */
4425         /* ISO 15444-1 A.4.2 Start of tile-part (SOT) mandates that tile parts */
4426         /* should appear in increasing order. */
4427         if (l_tcp->m_current_tile_part_number + 1 != (OPJ_INT32)l_current_part) {
4428             opj_event_msg(p_manager, EVT_ERROR,
4429                           "Invalid tile part index for tile number %d. "
4430                           "Got %d, expected %d\n",
4431                           p_j2k->m_current_tile_number,
4432                           l_current_part,
4433                           l_tcp->m_current_tile_part_number + 1);
4434             return OPJ_FALSE;
4435         }
4436     }
4437
4438     l_tcp->m_current_tile_part_number = (OPJ_INT32) l_current_part;
4439
4440 #ifdef USE_JPWL
4441     if (l_cp->correct) {
4442
4443         OPJ_UINT32 tileno = p_j2k->m_current_tile_number;
4444         static OPJ_UINT32 backup_tileno = 0;
4445
4446         /* tileno is negative or larger than the number of tiles!!! */
4447         if (tileno > (l_cp->tw * l_cp->th)) {
4448             opj_event_msg(p_manager, EVT_ERROR,
4449                           "JPWL: bad tile number (%d out of a maximum of %d)\n",
4450                           tileno, (l_cp->tw * l_cp->th));
4451             if (!JPWL_ASSUME) {
4452                 opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n");
4453                 return OPJ_FALSE;
4454             }
4455             /* we try to correct */
4456             tileno = backup_tileno;
4457             opj_event_msg(p_manager, EVT_WARNING, "- trying to adjust this\n"
4458                           "- setting tile number to %d\n",
4459                           tileno);
4460         }
4461
4462         /* keep your private count of tiles */
4463         backup_tileno++;
4464     };
4465 #endif /* USE_JPWL */
4466
4467     /* look for the tile in the list of already processed tile (in parts). */
4468     /* Optimization possible here with a more complex data structure and with the removing of tiles */
4469     /* since the time taken by this function can only grow at the time */
4470
4471     /* PSot should be equal to zero or >=14 or <= 2^32-1 */
4472     if ((l_tot_len != 0) && (l_tot_len < 14)) {
4473         if (l_tot_len ==
4474                 12) { /* MSD: Special case for the PHR data which are read by kakadu*/
4475             opj_event_msg(p_manager, EVT_WARNING, "Empty SOT marker detected: Psot=%d.\n",
4476                           l_tot_len);
4477         } else {
4478             opj_event_msg(p_manager, EVT_ERROR,
4479                           "Psot value is not correct regards to the JPEG2000 norm: %d.\n", l_tot_len);
4480             return OPJ_FALSE;
4481         }
4482     }
4483
4484 #ifdef USE_JPWL
4485     if (l_cp->correct) {
4486
4487         /* totlen is negative or larger than the bytes left!!! */
4488         if (/*(l_tot_len < 0) ||*/ (l_tot_len >
4489                                     p_header_size)) {   /* FIXME it seems correct; for info in V1 -> (p_stream_numbytesleft(p_stream) + 8))) { */
4490             opj_event_msg(p_manager, EVT_ERROR,
4491                           "JPWL: bad tile byte size (%d bytes against %d bytes left)\n",
4492                           l_tot_len,
4493                           p_header_size);  /* FIXME it seems correct; for info in V1 -> p_stream_numbytesleft(p_stream) + 8); */
4494             if (!JPWL_ASSUME) {
4495                 opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n");
4496                 return OPJ_FALSE;
4497             }
4498             /* we try to correct */
4499             l_tot_len = 0;
4500             opj_event_msg(p_manager, EVT_WARNING, "- trying to adjust this\n"
4501                           "- setting Psot to %d => assuming it is the last tile\n",
4502                           l_tot_len);
4503         }
4504     };
4505 #endif /* USE_JPWL */
4506
4507     /* Ref A.4.2: Psot could be equal zero if it is the last tile-part of the codestream.*/
4508     if (!l_tot_len) {
4509         opj_event_msg(p_manager, EVT_INFO,
4510                       "Psot value of the current tile-part is equal to zero, "
4511                       "we assuming it is the last tile-part of the codestream.\n");
4512         p_j2k->m_specific_param.m_decoder.m_last_tile_part = 1;
4513     }
4514
4515     if (l_tcp->m_nb_tile_parts != 0 && l_current_part >= l_tcp->m_nb_tile_parts) {
4516         /* Fixes https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=2851 */
4517         opj_event_msg(p_manager, EVT_ERROR,
4518                       "In SOT marker, TPSot (%d) is not valid regards to the previous "
4519                       "number of tile-part (%d), giving up\n", l_current_part,
4520                       l_tcp->m_nb_tile_parts);
4521         p_j2k->m_specific_param.m_decoder.m_last_tile_part = 1;
4522         return OPJ_FALSE;
4523     }
4524
4525     if (l_num_parts !=
4526             0) { /* Number of tile-part header is provided by this tile-part header */
4527         l_num_parts += p_j2k->m_specific_param.m_decoder.m_nb_tile_parts_correction;
4528         /* Useful to manage the case of textGBR.jp2 file because two values of TNSot are allowed: the correct numbers of
4529          * tile-parts for that tile and zero (A.4.2 of 15444-1 : 2002). */
4530         if (l_tcp->m_nb_tile_parts) {
4531             if (l_current_part >= l_tcp->m_nb_tile_parts) {
4532                 opj_event_msg(p_manager, EVT_ERROR,
4533                               "In SOT marker, TPSot (%d) is not valid regards to the current "
4534                               "number of tile-part (%d), giving up\n", l_current_part,
4535                               l_tcp->m_nb_tile_parts);
4536                 p_j2k->m_specific_param.m_decoder.m_last_tile_part = 1;
4537                 return OPJ_FALSE;
4538             }
4539         }
4540         if (l_current_part >= l_num_parts) {
4541             /* testcase 451.pdf.SIGSEGV.ce9.3723 */
4542             opj_event_msg(p_manager, EVT_ERROR,
4543                           "In SOT marker, TPSot (%d) is not valid regards to the current "
4544                           "number of tile-part (header) (%d), giving up\n", l_current_part, l_num_parts);
4545             p_j2k->m_specific_param.m_decoder.m_last_tile_part = 1;
4546             return OPJ_FALSE;
4547         }
4548         l_tcp->m_nb_tile_parts = l_num_parts;
4549     }
4550
4551     /* If know the number of tile part header we will check if we didn't read the last*/
4552     if (l_tcp->m_nb_tile_parts) {
4553         if (l_tcp->m_nb_tile_parts == (l_current_part + 1)) {
4554             p_j2k->m_specific_param.m_decoder.m_can_decode =
4555                 1; /* Process the last tile-part header*/
4556         }
4557     }
4558
4559     if (!p_j2k->m_specific_param.m_decoder.m_last_tile_part) {
4560         /* Keep the size of data to skip after this marker */
4561         p_j2k->m_specific_param.m_decoder.m_sot_length = l_tot_len -
4562                 12; /* SOT_marker_size = 12 */
4563     } else {
4564         /* FIXME: need to be computed from the number of bytes remaining in the codestream */
4565         p_j2k->m_specific_param.m_decoder.m_sot_length = 0;
4566     }
4567
4568     p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_TPH;
4569
4570     /* Check if the current tile is outside the area we want decode or not corresponding to the tile index*/
4571     if (p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec == -1) {
4572         p_j2k->m_specific_param.m_decoder.m_skip_data =
4573             (l_tile_x < p_j2k->m_specific_param.m_decoder.m_start_tile_x)
4574             || (l_tile_x >= p_j2k->m_specific_param.m_decoder.m_end_tile_x)
4575             || (l_tile_y < p_j2k->m_specific_param.m_decoder.m_start_tile_y)
4576             || (l_tile_y >= p_j2k->m_specific_param.m_decoder.m_end_tile_y);
4577     } else {
4578         assert(p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec >= 0);
4579         p_j2k->m_specific_param.m_decoder.m_skip_data =
4580             (p_j2k->m_current_tile_number != (OPJ_UINT32)
4581              p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec);
4582     }
4583
4584     /* Index */
4585     if (p_j2k->cstr_index) {
4586         assert(p_j2k->cstr_index->tile_index != 00);
4587         p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tileno =
4588             p_j2k->m_current_tile_number;
4589         p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_tpsno =
4590             l_current_part;
4591
4592         if (l_num_parts != 0) {
4593             p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].nb_tps =
4594                 l_num_parts;
4595             p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps =
4596                 l_num_parts;
4597
4598             if (!p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index) {
4599                 p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index =
4600                     (opj_tp_index_t*)opj_calloc(l_num_parts, sizeof(opj_tp_index_t));
4601                 if (!p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index) {
4602                     opj_event_msg(p_manager, EVT_ERROR,
4603                                   "Not enough memory to read SOT marker. Tile index allocation failed\n");
4604                     return OPJ_FALSE;
4605                 }
4606             } else {
4607                 opj_tp_index_t *new_tp_index = (opj_tp_index_t *) opj_realloc(
4608                                                    p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index,
4609                                                    l_num_parts * sizeof(opj_tp_index_t));
4610                 if (! new_tp_index) {
4611                     opj_free(p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index);
4612                     p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index = NULL;
4613                     opj_event_msg(p_manager, EVT_ERROR,
4614                                   "Not enough memory to read SOT marker. Tile index allocation failed\n");
4615                     return OPJ_FALSE;
4616                 }
4617                 p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index =
4618                     new_tp_index;
4619             }
4620         } else {
4621             /*if (!p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index)*/ {
4622
4623                 if (!p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index) {
4624                     p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps = 10;
4625                     p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index =
4626                         (opj_tp_index_t*)opj_calloc(
4627                             p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps,
4628                             sizeof(opj_tp_index_t));
4629                     if (!p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index) {
4630                         p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps = 0;
4631                         opj_event_msg(p_manager, EVT_ERROR,
4632                                       "Not enough memory to read SOT marker. Tile index allocation failed\n");
4633                         return OPJ_FALSE;
4634                     }
4635                 }
4636
4637                 if (l_current_part >=
4638                         p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps) {
4639                     opj_tp_index_t *new_tp_index;
4640                     p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps =
4641                         l_current_part + 1;
4642                     new_tp_index = (opj_tp_index_t *) opj_realloc(
4643                                        p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index,
4644                                        p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps *
4645                                        sizeof(opj_tp_index_t));
4646                     if (! new_tp_index) {
4647                         opj_free(p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index);
4648                         p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index = NULL;
4649                         p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps = 0;
4650                         opj_event_msg(p_manager, EVT_ERROR,
4651                                       "Not enough memory to read SOT marker. Tile index allocation failed\n");
4652                         return OPJ_FALSE;
4653                     }
4654                     p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index =
4655                         new_tp_index;
4656                 }
4657             }
4658
4659         }
4660
4661     }
4662
4663     /* 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 */
4664     /* if (p_j2k->cstr_info) {
4665        if (l_tcp->first) {
4666        if (tileno == 0) {
4667        p_j2k->cstr_info->main_head_end = p_stream_tell(p_stream) - 13;
4668        }
4669
4670        p_j2k->cstr_info->tile[tileno].tileno = tileno;
4671        p_j2k->cstr_info->tile[tileno].start_pos = p_stream_tell(p_stream) - 12;
4672        p_j2k->cstr_info->tile[tileno].end_pos = p_j2k->cstr_info->tile[tileno].start_pos + totlen - 1;
4673        p_j2k->cstr_info->tile[tileno].num_tps = numparts;
4674
4675        if (numparts) {
4676        p_j2k->cstr_info->tile[tileno].tp = (opj_tp_info_t *) opj_malloc(numparts * sizeof(opj_tp_info_t));
4677        }
4678        else {
4679        p_j2k->cstr_info->tile[tileno].tp = (opj_tp_info_t *) opj_malloc(10 * sizeof(opj_tp_info_t)); // Fixme (10)
4680        }
4681        }
4682        else {
4683        p_j2k->cstr_info->tile[tileno].end_pos += totlen;
4684        }
4685
4686        p_j2k->cstr_info->tile[tileno].tp[partno].tp_start_pos = p_stream_tell(p_stream) - 12;
4687        p_j2k->cstr_info->tile[tileno].tp[partno].tp_end_pos =
4688        p_j2k->cstr_info->tile[tileno].tp[partno].tp_start_pos + totlen - 1;
4689        }*/
4690     return OPJ_TRUE;
4691 }
4692
4693 /**
4694  * Write one or more PLT markers in the provided buffer
4695  */
4696 static OPJ_BOOL opj_j2k_write_plt_in_memory(opj_j2k_t *p_j2k,
4697         opj_tcd_marker_info_t* marker_info,
4698         OPJ_BYTE * p_data,
4699         OPJ_UINT32 * p_data_written,
4700         opj_event_mgr_t * p_manager)
4701 {
4702     OPJ_BYTE Zplt = 0;
4703     OPJ_UINT16 Lplt;
4704     OPJ_BYTE* p_data_start = p_data;
4705     OPJ_BYTE* p_data_Lplt = p_data + 2;
4706     OPJ_UINT32 i;
4707
4708     OPJ_UNUSED(p_j2k);
4709
4710     opj_write_bytes(p_data, J2K_MS_PLT, 2);
4711     p_data += 2;
4712
4713     /* Reserve space for Lplt */
4714     p_data += 2;
4715
4716     opj_write_bytes(p_data, Zplt, 1);
4717     p_data += 1;
4718
4719     Lplt = 3;
4720
4721     for (i = 0; i < marker_info->packet_count; i++) {
4722         OPJ_BYTE var_bytes[5];
4723         OPJ_UINT8 var_bytes_size = 0;
4724         OPJ_UINT32 packet_size = marker_info->p_packet_size[i];
4725
4726         /* Packet size written in variable-length way, starting with LSB */
4727         var_bytes[var_bytes_size] = (OPJ_BYTE)(packet_size & 0x7f);
4728         var_bytes_size ++;
4729         packet_size >>= 7;
4730         while (packet_size > 0) {
4731             var_bytes[var_bytes_size] = (OPJ_BYTE)((packet_size & 0x7f) | 0x80);
4732             var_bytes_size ++;
4733             packet_size >>= 7;
4734         }
4735
4736         /* Check if that can fit in the current PLT marker. If not, finish */
4737         /* current one, and start a new one */
4738         if (Lplt + var_bytes_size > 65535) {
4739             if (Zplt == 255) {
4740                 opj_event_msg(p_manager, EVT_ERROR,
4741                               "More than 255 PLT markers would be needed for current tile-part !\n");
4742                 return OPJ_FALSE;
4743             }
4744
4745             /* Patch Lplt */
4746             opj_write_bytes(p_data_Lplt, Lplt, 2);
4747
4748             /* Start new segment */
4749             opj_write_bytes(p_data, J2K_MS_PLT, 2);
4750             p_data += 2;
4751
4752             /* Reserve space for Lplt */
4753             p_data_Lplt = p_data;
4754             p_data += 2;
4755
4756             Zplt ++;
4757             opj_write_bytes(p_data, Zplt, 1);
4758             p_data += 1;
4759
4760             Lplt = 3;
4761         }
4762
4763         Lplt = (OPJ_UINT16)(Lplt + var_bytes_size);
4764
4765         /* Serialize variable-length packet size, starting with MSB */
4766         for (; var_bytes_size > 0; --var_bytes_size) {
4767             opj_write_bytes(p_data, var_bytes[var_bytes_size - 1], 1);
4768             p_data += 1;
4769         }
4770     }
4771
4772     *p_data_written = (OPJ_UINT32)(p_data - p_data_start);
4773
4774     /* Patch Lplt */
4775     opj_write_bytes(p_data_Lplt, Lplt, 2);
4776
4777     return OPJ_TRUE;
4778 }
4779
4780 static OPJ_BOOL opj_j2k_write_sod(opj_j2k_t *p_j2k,
4781                                   opj_tcd_t * p_tile_coder,
4782                                   OPJ_BYTE * p_data,
4783                                   OPJ_UINT32 * p_data_written,
4784                                   OPJ_UINT32 total_data_size,
4785                                   const opj_stream_private_t *p_stream,
4786                                   opj_event_mgr_t * p_manager
4787                                  )
4788 {
4789     opj_codestream_info_t *l_cstr_info = 00;
4790     OPJ_UINT32 l_remaining_data;
4791     opj_tcd_marker_info_t* marker_info = NULL;
4792
4793     /* preconditions */
4794     assert(p_j2k != 00);
4795     assert(p_manager != 00);
4796     assert(p_stream != 00);
4797
4798     OPJ_UNUSED(p_stream);
4799
4800     if (total_data_size < 4) {
4801         opj_event_msg(p_manager, EVT_ERROR,
4802                       "Not enough bytes in output buffer to write SOD marker\n");
4803         return OPJ_FALSE;
4804     }
4805
4806     opj_write_bytes(p_data, J2K_MS_SOD,
4807                     2);                                 /* SOD */
4808
4809     /* make room for the EOF marker */
4810     l_remaining_data =  total_data_size - 4;
4811
4812     /* update tile coder */
4813     p_tile_coder->tp_num =
4814         p_j2k->m_specific_param.m_encoder.m_current_poc_tile_part_number ;
4815     p_tile_coder->cur_tp_num =
4816         p_j2k->m_specific_param.m_encoder.m_current_tile_part_number;
4817
4818     /* INDEX >> */
4819     /* TODO mergeV2: check this part which use cstr_info */
4820     /*l_cstr_info = p_j2k->cstr_info;
4821     if (l_cstr_info) {
4822             if (!p_j2k->m_specific_param.m_encoder.m_current_tile_part_number ) {
4823                     //TODO cstr_info->tile[p_j2k->m_current_tile_number].end_header = p_stream_tell(p_stream) + p_j2k->pos_correction - 1;
4824                     l_cstr_info->tile[p_j2k->m_current_tile_number].tileno = p_j2k->m_current_tile_number;
4825             }
4826             else {*/
4827     /*
4828     TODO
4829     if
4830             (cstr_info->tile[p_j2k->m_current_tile_number].packet[cstr_info->packno - 1].end_pos < p_stream_tell(p_stream))
4831     {
4832             cstr_info->tile[p_j2k->m_current_tile_number].packet[cstr_info->packno].start_pos = p_stream_tell(p_stream);
4833     }*/
4834     /*}*/
4835     /* UniPG>> */
4836 #ifdef USE_JPWL
4837     /* update markers struct */
4838     /*OPJ_BOOL res = j2k_add_marker(p_j2k->cstr_info, J2K_MS_SOD, p_j2k->sod_start, 2);
4839     */
4840     assert(0 && "TODO");
4841 #endif /* USE_JPWL */
4842     /* <<UniPG */
4843     /*}*/
4844     /* << INDEX */
4845
4846     if (p_j2k->m_specific_param.m_encoder.m_current_tile_part_number == 0) {
4847         p_tile_coder->tcd_image->tiles->packno = 0;
4848 #ifdef deadcode
4849         if (l_cstr_info) {
4850             l_cstr_info->packno = 0;
4851         }
4852 #endif
4853     }
4854
4855     *p_data_written = 0;
4856
4857     if (p_j2k->m_specific_param.m_encoder.m_PLT) {
4858         marker_info = opj_tcd_marker_info_create(
4859                           p_j2k->m_specific_param.m_encoder.m_PLT);
4860         if (marker_info == NULL) {
4861             opj_event_msg(p_manager, EVT_ERROR,
4862                           "Cannot encode tile: opj_tcd_marker_info_create() failed\n");
4863             return OPJ_FALSE;
4864         }
4865     }
4866
4867     if (l_remaining_data <
4868             p_j2k->m_specific_param.m_encoder.m_reserved_bytes_for_PLT) {
4869         opj_event_msg(p_manager, EVT_ERROR,
4870                       "Not enough bytes in output buffer to write SOD marker\n");
4871         opj_tcd_marker_info_destroy(marker_info);
4872         return OPJ_FALSE;
4873     }
4874     l_remaining_data -= p_j2k->m_specific_param.m_encoder.m_reserved_bytes_for_PLT;
4875
4876     if (! opj_tcd_encode_tile(p_tile_coder, p_j2k->m_current_tile_number,
4877                               p_data + 2,
4878                               p_data_written, l_remaining_data, l_cstr_info,
4879                               marker_info,
4880                               p_manager)) {
4881         opj_event_msg(p_manager, EVT_ERROR, "Cannot encode tile\n");
4882         opj_tcd_marker_info_destroy(marker_info);
4883         return OPJ_FALSE;
4884     }
4885
4886     /* For SOD */
4887     *p_data_written += 2;
4888
4889     if (p_j2k->m_specific_param.m_encoder.m_PLT) {
4890         OPJ_UINT32 l_data_written_PLT = 0;
4891         OPJ_BYTE* p_PLT_buffer = (OPJ_BYTE*)opj_malloc(
4892                                      p_j2k->m_specific_param.m_encoder.m_reserved_bytes_for_PLT);
4893         if (!p_PLT_buffer) {
4894             opj_event_msg(p_manager, EVT_ERROR, "Cannot allocate memory\n");
4895             opj_tcd_marker_info_destroy(marker_info);
4896             return OPJ_FALSE;
4897         }
4898         if (!opj_j2k_write_plt_in_memory(p_j2k,
4899                                          marker_info,
4900                                          p_PLT_buffer,
4901                                          &l_data_written_PLT,
4902                                          p_manager)) {
4903             opj_tcd_marker_info_destroy(marker_info);
4904             opj_free(p_PLT_buffer);
4905             return OPJ_FALSE;
4906         }
4907
4908         assert(l_data_written_PLT <=
4909                p_j2k->m_specific_param.m_encoder.m_reserved_bytes_for_PLT);
4910
4911         /* Move PLT marker(s) before SOD */
4912         memmove(p_data + l_data_written_PLT, p_data, *p_data_written);
4913         memcpy(p_data, p_PLT_buffer, l_data_written_PLT);
4914         opj_free(p_PLT_buffer);
4915         *p_data_written += l_data_written_PLT;
4916     }
4917
4918     opj_tcd_marker_info_destroy(marker_info);
4919
4920     return OPJ_TRUE;
4921 }
4922
4923 static OPJ_BOOL opj_j2k_read_sod(opj_j2k_t *p_j2k,
4924                                  opj_stream_private_t *p_stream,
4925                                  opj_event_mgr_t * p_manager
4926                                 )
4927 {
4928     OPJ_SIZE_T l_current_read_size;
4929     opj_codestream_index_t * l_cstr_index = 00;
4930     OPJ_BYTE ** l_current_data = 00;
4931     opj_tcp_t * l_tcp = 00;
4932     OPJ_UINT32 * l_tile_len = 00;
4933     OPJ_BOOL l_sot_length_pb_detected = OPJ_FALSE;
4934
4935     /* preconditions */
4936     assert(p_j2k != 00);
4937     assert(p_manager != 00);
4938     assert(p_stream != 00);
4939
4940     l_tcp = &(p_j2k->m_cp.tcps[p_j2k->m_current_tile_number]);
4941
4942     if (p_j2k->m_specific_param.m_decoder.m_last_tile_part) {
4943         /* opj_stream_get_number_byte_left returns OPJ_OFF_T
4944         // but we are in the last tile part,
4945         // so its result will fit on OPJ_UINT32 unless we find
4946         // a file with a single tile part of more than 4 GB...*/
4947         p_j2k->m_specific_param.m_decoder.m_sot_length = (OPJ_UINT32)(
4948                     opj_stream_get_number_byte_left(p_stream) - 2);
4949     } else {
4950         /* Check to avoid pass the limit of OPJ_UINT32 */
4951         if (p_j2k->m_specific_param.m_decoder.m_sot_length >= 2) {
4952             p_j2k->m_specific_param.m_decoder.m_sot_length -= 2;
4953         } else {
4954             /* MSD: case commented to support empty SOT marker (PHR data) */
4955         }
4956     }
4957
4958     l_current_data = &(l_tcp->m_data);
4959     l_tile_len = &l_tcp->m_data_size;
4960
4961     /* Patch to support new PHR data */
4962     if (p_j2k->m_specific_param.m_decoder.m_sot_length) {
4963         /* If we are here, we'll try to read the data after allocation */
4964         /* Check enough bytes left in stream before allocation */
4965         if ((OPJ_OFF_T)p_j2k->m_specific_param.m_decoder.m_sot_length >
4966                 opj_stream_get_number_byte_left(p_stream)) {
4967             if (p_j2k->m_cp.strict) {
4968                 opj_event_msg(p_manager, EVT_ERROR,
4969                               "Tile part length size inconsistent with stream length\n");
4970                 return OPJ_FALSE;
4971             } else {
4972                 opj_event_msg(p_manager, EVT_WARNING,
4973                               "Tile part length size inconsistent with stream length\n");
4974             }
4975         }
4976         if (p_j2k->m_specific_param.m_decoder.m_sot_length >
4977                 UINT_MAX - OPJ_COMMON_CBLK_DATA_EXTRA) {
4978             opj_event_msg(p_manager, EVT_ERROR,
4979                           "p_j2k->m_specific_param.m_decoder.m_sot_length > "
4980                           "UINT_MAX - OPJ_COMMON_CBLK_DATA_EXTRA");
4981             return OPJ_FALSE;
4982         }
4983         /* Add a margin of OPJ_COMMON_CBLK_DATA_EXTRA to the allocation we */
4984         /* do so that opj_mqc_init_dec_common() can safely add a synthetic */
4985         /* 0xFFFF marker. */
4986         if (! *l_current_data) {
4987             /* LH: oddly enough, in this path, l_tile_len!=0.
4988              * TODO: If this was consistent, we could simplify the code to only use realloc(), as realloc(0,...) default to malloc(0,...).
4989              */
4990             *l_current_data = (OPJ_BYTE*) opj_malloc(
4991                                   p_j2k->m_specific_param.m_decoder.m_sot_length + OPJ_COMMON_CBLK_DATA_EXTRA);
4992         } else {
4993             OPJ_BYTE *l_new_current_data;
4994             if (*l_tile_len > UINT_MAX - OPJ_COMMON_CBLK_DATA_EXTRA -
4995                     p_j2k->m_specific_param.m_decoder.m_sot_length) {
4996                 opj_event_msg(p_manager, EVT_ERROR,
4997                               "*l_tile_len > UINT_MAX - OPJ_COMMON_CBLK_DATA_EXTRA - "
4998                               "p_j2k->m_specific_param.m_decoder.m_sot_length");
4999                 return OPJ_FALSE;
5000             }
5001
5002             l_new_current_data = (OPJ_BYTE *) opj_realloc(*l_current_data,
5003                                  *l_tile_len + p_j2k->m_specific_param.m_decoder.m_sot_length +
5004                                  OPJ_COMMON_CBLK_DATA_EXTRA);
5005             if (! l_new_current_data) {
5006                 opj_free(*l_current_data);
5007                 /*nothing more is done as l_current_data will be set to null, and just
5008                   afterward we enter in the error path
5009                   and the actual tile_len is updated (committed) at the end of the
5010                   function. */
5011             }
5012             *l_current_data = l_new_current_data;
5013         }
5014
5015         if (*l_current_data == 00) {
5016             opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to decode tile\n");
5017             return OPJ_FALSE;
5018         }
5019     } else {
5020         l_sot_length_pb_detected = OPJ_TRUE;
5021     }
5022
5023     /* Index */
5024     l_cstr_index = p_j2k->cstr_index;
5025     if (l_cstr_index) {
5026         OPJ_OFF_T l_current_pos = opj_stream_tell(p_stream) - 2;
5027
5028         OPJ_UINT32 l_current_tile_part =
5029             l_cstr_index->tile_index[p_j2k->m_current_tile_number].current_tpsno;
5030         l_cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index[l_current_tile_part].end_header
5031             =
5032                 l_current_pos;
5033         l_cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index[l_current_tile_part].end_pos
5034             =
5035                 l_current_pos + p_j2k->m_specific_param.m_decoder.m_sot_length + 2;
5036
5037         if (OPJ_FALSE == opj_j2k_add_tlmarker(p_j2k->m_current_tile_number,
5038                                               l_cstr_index,
5039                                               J2K_MS_SOD,
5040                                               l_current_pos,
5041                                               p_j2k->m_specific_param.m_decoder.m_sot_length + 2)) {
5042             opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to add tl marker\n");
5043             return OPJ_FALSE;
5044         }
5045
5046         /*l_cstr_index->packno = 0;*/
5047     }
5048
5049     /* Patch to support new PHR data */
5050     if (!l_sot_length_pb_detected) {
5051         l_current_read_size = opj_stream_read_data(
5052                                   p_stream,
5053                                   *l_current_data + *l_tile_len,
5054                                   p_j2k->m_specific_param.m_decoder.m_sot_length,
5055                                   p_manager);
5056     } else {
5057         l_current_read_size = 0;
5058     }
5059
5060     if (l_current_read_size != p_j2k->m_specific_param.m_decoder.m_sot_length) {
5061         p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_NEOC;
5062     } else {
5063         p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_TPHSOT;
5064     }
5065
5066     *l_tile_len += (OPJ_UINT32)l_current_read_size;
5067
5068     return OPJ_TRUE;
5069 }
5070
5071 static OPJ_BOOL opj_j2k_write_rgn(opj_j2k_t *p_j2k,
5072                                   OPJ_UINT32 p_tile_no,
5073                                   OPJ_UINT32 p_comp_no,
5074                                   OPJ_UINT32 nb_comps,
5075                                   opj_stream_private_t *p_stream,
5076                                   opj_event_mgr_t * p_manager
5077                                  )
5078 {
5079     OPJ_BYTE * l_current_data = 00;
5080     OPJ_UINT32 l_rgn_size;
5081     opj_cp_t *l_cp = 00;
5082     opj_tcp_t *l_tcp = 00;
5083     opj_tccp_t *l_tccp = 00;
5084     OPJ_UINT32 l_comp_room;
5085
5086     /* preconditions */
5087     assert(p_j2k != 00);
5088     assert(p_manager != 00);
5089     assert(p_stream != 00);
5090
5091     l_cp = &(p_j2k->m_cp);
5092     l_tcp = &l_cp->tcps[p_tile_no];
5093     l_tccp = &l_tcp->tccps[p_comp_no];
5094
5095     if (nb_comps <= 256) {
5096         l_comp_room = 1;
5097     } else {
5098         l_comp_room = 2;
5099     }
5100
5101     l_rgn_size = 6 + l_comp_room;
5102
5103     l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
5104
5105     opj_write_bytes(l_current_data, J2K_MS_RGN,
5106                     2);                                   /* RGN  */
5107     l_current_data += 2;
5108
5109     opj_write_bytes(l_current_data, l_rgn_size - 2,
5110                     2);                                 /* Lrgn */
5111     l_current_data += 2;
5112
5113     opj_write_bytes(l_current_data, p_comp_no,
5114                     l_comp_room);                          /* Crgn */
5115     l_current_data += l_comp_room;
5116
5117     opj_write_bytes(l_current_data, 0,
5118                     1);                                           /* Srgn */
5119     ++l_current_data;
5120
5121     opj_write_bytes(l_current_data, (OPJ_UINT32)l_tccp->roishift,
5122                     1);                            /* SPrgn */
5123     ++l_current_data;
5124
5125     if (opj_stream_write_data(p_stream,
5126                               p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_rgn_size,
5127                               p_manager) != l_rgn_size) {
5128         return OPJ_FALSE;
5129     }
5130
5131     return OPJ_TRUE;
5132 }
5133
5134 static OPJ_BOOL opj_j2k_write_eoc(opj_j2k_t *p_j2k,
5135                                   opj_stream_private_t *p_stream,
5136                                   opj_event_mgr_t * p_manager
5137                                  )
5138 {
5139     /* preconditions */
5140     assert(p_j2k != 00);
5141     assert(p_manager != 00);
5142     assert(p_stream != 00);
5143
5144     opj_write_bytes(p_j2k->m_specific_param.m_encoder.m_header_tile_data,
5145                     J2K_MS_EOC, 2);                                    /* EOC */
5146
5147     /* UniPG>> */
5148 #ifdef USE_JPWL
5149     /* update markers struct */
5150     /*
5151     OPJ_BOOL res = j2k_add_marker(p_j2k->cstr_info, J2K_MS_EOC, p_stream_tell(p_stream) - 2, 2);
5152     */
5153 #endif /* USE_JPWL */
5154
5155     if (opj_stream_write_data(p_stream,
5156                               p_j2k->m_specific_param.m_encoder.m_header_tile_data, 2, p_manager) != 2) {
5157         return OPJ_FALSE;
5158     }
5159
5160     if (! opj_stream_flush(p_stream, p_manager)) {
5161         return OPJ_FALSE;
5162     }
5163
5164     return OPJ_TRUE;
5165 }
5166
5167 /**
5168  * Reads a RGN marker (Region Of Interest)
5169  *
5170  * @param       p_header_data   the data contained in the POC box.
5171  * @param       p_j2k                   the jpeg2000 codec.
5172  * @param       p_header_size   the size of the data contained in the POC marker.
5173  * @param       p_manager               the user event manager.
5174 */
5175 static OPJ_BOOL opj_j2k_read_rgn(opj_j2k_t *p_j2k,
5176                                  OPJ_BYTE * p_header_data,
5177                                  OPJ_UINT32 p_header_size,
5178                                  opj_event_mgr_t * p_manager
5179                                 )
5180 {
5181     OPJ_UINT32 l_nb_comp;
5182     opj_image_t * l_image = 00;
5183
5184     opj_cp_t *l_cp = 00;
5185     opj_tcp_t *l_tcp = 00;
5186     OPJ_UINT32 l_comp_room, l_comp_no, l_roi_sty;
5187
5188     /* preconditions*/
5189     assert(p_header_data != 00);
5190     assert(p_j2k != 00);
5191     assert(p_manager != 00);
5192
5193     l_image = p_j2k->m_private_image;
5194     l_nb_comp = l_image->numcomps;
5195
5196     if (l_nb_comp <= 256) {
5197         l_comp_room = 1;
5198     } else {
5199         l_comp_room = 2;
5200     }
5201
5202     if (p_header_size != 2 + l_comp_room) {
5203         opj_event_msg(p_manager, EVT_ERROR, "Error reading RGN marker\n");
5204         return OPJ_FALSE;
5205     }
5206
5207     l_cp = &(p_j2k->m_cp);
5208     l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH) ?
5209             &l_cp->tcps[p_j2k->m_current_tile_number] :
5210             p_j2k->m_specific_param.m_decoder.m_default_tcp;
5211
5212     opj_read_bytes(p_header_data, &l_comp_no, l_comp_room);         /* Crgn */
5213     p_header_data += l_comp_room;
5214     opj_read_bytes(p_header_data, &l_roi_sty,
5215                    1);                                     /* Srgn */
5216     ++p_header_data;
5217
5218 #ifdef USE_JPWL
5219     if (l_cp->correct) {
5220         /* totlen is negative or larger than the bytes left!!! */
5221         if (l_comp_room >= l_nb_comp) {
5222             opj_event_msg(p_manager, EVT_ERROR,
5223                           "JPWL: bad component number in RGN (%d when there are only %d)\n",
5224                           l_comp_room, l_nb_comp);
5225             if (!JPWL_ASSUME) {
5226                 opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n");
5227                 return OPJ_FALSE;
5228             }
5229         }
5230     };
5231 #endif /* USE_JPWL */
5232
5233     /* testcase 3635.pdf.asan.77.2930 */
5234     if (l_comp_no >= l_nb_comp) {
5235         opj_event_msg(p_manager, EVT_ERROR,
5236                       "bad component number in RGN (%d when there are only %d)\n",
5237                       l_comp_no, l_nb_comp);
5238         return OPJ_FALSE;
5239     }
5240
5241     opj_read_bytes(p_header_data,
5242                    (OPJ_UINT32 *)(&(l_tcp->tccps[l_comp_no].roishift)), 1);  /* SPrgn */
5243     ++p_header_data;
5244
5245     return OPJ_TRUE;
5246
5247 }
5248
5249 static OPJ_FLOAT32 opj_j2k_get_tp_stride(opj_tcp_t * p_tcp)
5250 {
5251     return (OPJ_FLOAT32)((p_tcp->m_nb_tile_parts - 1) * 14);
5252 }
5253
5254 static OPJ_FLOAT32 opj_j2k_get_default_stride(opj_tcp_t * p_tcp)
5255 {
5256     (void)p_tcp;
5257     return 0;
5258 }
5259
5260 static OPJ_BOOL opj_j2k_update_rates(opj_j2k_t *p_j2k,
5261                                      opj_stream_private_t *p_stream,
5262                                      opj_event_mgr_t * p_manager)
5263 {
5264     opj_cp_t * l_cp = 00;
5265     opj_image_t * l_image = 00;
5266     opj_tcp_t * l_tcp = 00;
5267     opj_image_comp_t * l_img_comp = 00;
5268
5269     OPJ_UINT32 i, j, k;
5270     OPJ_INT32 l_x0, l_y0, l_x1, l_y1;
5271     OPJ_FLOAT32 * l_rates = 0;
5272     OPJ_FLOAT32 l_sot_remove;
5273     OPJ_UINT32 l_bits_empty, l_size_pixel;
5274     OPJ_UINT64 l_tile_size = 0;
5275     OPJ_UINT32 l_last_res;
5276     OPJ_FLOAT32(* l_tp_stride_func)(opj_tcp_t *) = 00;
5277
5278     /* preconditions */
5279     assert(p_j2k != 00);
5280     assert(p_manager != 00);
5281     assert(p_stream != 00);
5282
5283     OPJ_UNUSED(p_manager);
5284
5285     l_cp = &(p_j2k->m_cp);
5286     l_image = p_j2k->m_private_image;
5287     l_tcp = l_cp->tcps;
5288
5289     l_bits_empty = 8 * l_image->comps->dx * l_image->comps->dy;
5290     l_size_pixel = l_image->numcomps * l_image->comps->prec;
5291     l_sot_remove = (OPJ_FLOAT32) opj_stream_tell(p_stream) / (OPJ_FLOAT32)(
5292                        l_cp->th * l_cp->tw);
5293
5294     if (l_cp->m_specific_param.m_enc.m_tp_on) {
5295         l_tp_stride_func = opj_j2k_get_tp_stride;
5296     } else {
5297         l_tp_stride_func = opj_j2k_get_default_stride;
5298     }
5299
5300     for (i = 0; i < l_cp->th; ++i) {
5301         for (j = 0; j < l_cp->tw; ++j) {
5302             OPJ_FLOAT32 l_offset = (OPJ_FLOAT32)(*l_tp_stride_func)(l_tcp) /
5303                                    (OPJ_FLOAT32)l_tcp->numlayers;
5304
5305             /* 4 borders of the tile rescale on the image if necessary */
5306             l_x0 = opj_int_max((OPJ_INT32)(l_cp->tx0 + j * l_cp->tdx),
5307                                (OPJ_INT32)l_image->x0);
5308             l_y0 = opj_int_max((OPJ_INT32)(l_cp->ty0 + i * l_cp->tdy),
5309                                (OPJ_INT32)l_image->y0);
5310             l_x1 = opj_int_min((OPJ_INT32)(l_cp->tx0 + (j + 1) * l_cp->tdx),
5311                                (OPJ_INT32)l_image->x1);
5312             l_y1 = opj_int_min((OPJ_INT32)(l_cp->ty0 + (i + 1) * l_cp->tdy),
5313                                (OPJ_INT32)l_image->y1);
5314
5315             l_rates = l_tcp->rates;
5316
5317             /* Modification of the RATE >> */
5318             for (k = 0; k < l_tcp->numlayers; ++k) {
5319                 if (*l_rates > 0.0f) {
5320                     *l_rates = (OPJ_FLOAT32)(((OPJ_FLOAT64)l_size_pixel * (OPJ_UINT32)(
5321                                                   l_x1 - l_x0) *
5322                                               (OPJ_UINT32)(l_y1 - l_y0))
5323                                              / ((*l_rates) * (OPJ_FLOAT32)l_bits_empty))
5324                                -
5325                                l_offset;
5326                 }
5327
5328                 ++l_rates;
5329             }
5330
5331             ++l_tcp;
5332
5333         }
5334     }
5335
5336     l_tcp = l_cp->tcps;
5337
5338     for (i = 0; i < l_cp->th; ++i) {
5339         for (j = 0; j < l_cp->tw; ++j) {
5340             l_rates = l_tcp->rates;
5341
5342             if (*l_rates > 0.0f) {
5343                 *l_rates -= l_sot_remove;
5344
5345                 if (*l_rates < 30.0f) {
5346                     *l_rates = 30.0f;
5347                 }
5348             }
5349
5350             ++l_rates;
5351
5352             l_last_res = l_tcp->numlayers - 1;
5353
5354             for (k = 1; k < l_last_res; ++k) {
5355
5356                 if (*l_rates > 0.0f) {
5357                     *l_rates -= l_sot_remove;
5358
5359                     if (*l_rates < * (l_rates - 1) + 10.0f) {
5360                         *l_rates  = (*(l_rates - 1)) + 20.0f;
5361                     }
5362                 }
5363
5364                 ++l_rates;
5365             }
5366
5367             if (*l_rates > 0.0f) {
5368                 *l_rates -= (l_sot_remove + 2.f);
5369
5370                 if (*l_rates < * (l_rates - 1) + 10.0f) {
5371                     *l_rates  = (*(l_rates - 1)) + 20.0f;
5372                 }
5373             }
5374
5375             ++l_tcp;
5376         }
5377     }
5378
5379     l_img_comp = l_image->comps;
5380     l_tile_size = 0;
5381
5382     for (i = 0; i < l_image->numcomps; ++i) {
5383         l_tile_size += (OPJ_UINT64)opj_uint_ceildiv(l_cp->tdx, l_img_comp->dx)
5384                        *
5385                        opj_uint_ceildiv(l_cp->tdy, l_img_comp->dy)
5386                        *
5387                        l_img_comp->prec;
5388
5389         ++l_img_comp;
5390     }
5391
5392     /* TODO: where does this magic value come from ? */
5393     /* This used to be 1.3 / 8, but with random data and very small code */
5394     /* block sizes, this is not enough. For example with */
5395     /* bin/test_tile_encoder 1 256 256 32 32 8 0 reversible_with_precinct.j2k 4 4 3 0 0 1 16 16 */
5396     /* TODO revise this to take into account the overhead linked to the */
5397     /* number of packets and number of code blocks in packets */
5398     l_tile_size = (OPJ_UINT64)((double)l_tile_size * 1.4 / 8);
5399
5400     /* Arbitrary amount to make the following work: */
5401     /* bin/test_tile_encoder 1 256 256 17 16 8 0 reversible_no_precinct.j2k 4 4 3 0 0 1 */
5402     l_tile_size += 500;
5403
5404     l_tile_size += opj_j2k_get_specific_header_sizes(p_j2k);
5405
5406     if (l_tile_size > UINT_MAX) {
5407         l_tile_size = UINT_MAX;
5408     }
5409
5410     p_j2k->m_specific_param.m_encoder.m_encoded_tile_size = (OPJ_UINT32)l_tile_size;
5411     p_j2k->m_specific_param.m_encoder.m_encoded_tile_data =
5412         (OPJ_BYTE *) opj_malloc(p_j2k->m_specific_param.m_encoder.m_encoded_tile_size);
5413     if (p_j2k->m_specific_param.m_encoder.m_encoded_tile_data == 00) {
5414         opj_event_msg(p_manager, EVT_ERROR,
5415                       "Not enough memory to allocate m_encoded_tile_data. %u MB required\n",
5416                       (OPJ_UINT32)(l_tile_size / 1024 / 1024));
5417         return OPJ_FALSE;
5418     }
5419
5420     if (p_j2k->m_specific_param.m_encoder.m_TLM) {
5421         p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer =
5422             (OPJ_BYTE *) opj_malloc(6 *
5423                                     p_j2k->m_specific_param.m_encoder.m_total_tile_parts);
5424         if (! p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer) {
5425             return OPJ_FALSE;
5426         }
5427
5428         p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current =
5429             p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer;
5430     }
5431
5432     return OPJ_TRUE;
5433 }
5434
5435 #if 0
5436 static OPJ_BOOL opj_j2k_read_eoc(opj_j2k_t *p_j2k,
5437                                  opj_stream_private_t *p_stream,
5438                                  opj_event_mgr_t * p_manager)
5439 {
5440     OPJ_UINT32 i;
5441     opj_tcd_t * l_tcd = 00;
5442     OPJ_UINT32 l_nb_tiles;
5443     opj_tcp_t * l_tcp = 00;
5444     OPJ_BOOL l_success;
5445
5446     /* preconditions */
5447     assert(p_j2k != 00);
5448     assert(p_manager != 00);
5449     assert(p_stream != 00);
5450
5451     l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
5452     l_tcp = p_j2k->m_cp.tcps;
5453
5454     l_tcd = opj_tcd_create(OPJ_TRUE);
5455     if (l_tcd == 00) {
5456         opj_event_msg(p_manager, EVT_ERROR, "Cannot decode tile, memory error\n");
5457         return OPJ_FALSE;
5458     }
5459
5460     for (i = 0; i < l_nb_tiles; ++i) {
5461         if (l_tcp->m_data) {
5462             if (! opj_tcd_init_decode_tile(l_tcd, i)) {
5463                 opj_tcd_destroy(l_tcd);
5464                 opj_event_msg(p_manager, EVT_ERROR, "Cannot decode tile, memory error\n");
5465                 return OPJ_FALSE;
5466             }
5467
5468             l_success = opj_tcd_decode_tile(l_tcd, l_tcp->m_data, l_tcp->m_data_size, i,
5469                                             p_j2k->cstr_index);
5470             /* cleanup */
5471
5472             if (! l_success) {
5473                 p_j2k->m_specific_param.m_decoder.m_state |= J2K_STATE_ERR;
5474                 break;
5475             }
5476         }
5477
5478         opj_j2k_tcp_destroy(l_tcp);
5479         ++l_tcp;
5480     }
5481
5482     opj_tcd_destroy(l_tcd);
5483     return OPJ_TRUE;
5484 }
5485 #endif
5486
5487 static OPJ_BOOL opj_j2k_get_end_header(opj_j2k_t *p_j2k,
5488                                        struct opj_stream_private *p_stream,
5489                                        struct opj_event_mgr * p_manager)
5490 {
5491     /* preconditions */
5492     assert(p_j2k != 00);
5493     assert(p_manager != 00);
5494     assert(p_stream != 00);
5495
5496     OPJ_UNUSED(p_manager);
5497
5498     p_j2k->cstr_index->main_head_end = opj_stream_tell(p_stream);
5499
5500     return OPJ_TRUE;
5501 }
5502
5503 static OPJ_BOOL opj_j2k_write_mct_data_group(opj_j2k_t *p_j2k,
5504         struct opj_stream_private *p_stream,
5505         struct opj_event_mgr * p_manager)
5506 {
5507     OPJ_UINT32 i;
5508     opj_simple_mcc_decorrelation_data_t * l_mcc_record;
5509     opj_mct_data_t * l_mct_record;
5510     opj_tcp_t * l_tcp;
5511
5512     /* preconditions */
5513     assert(p_j2k != 00);
5514     assert(p_stream != 00);
5515     assert(p_manager != 00);
5516
5517     if (! opj_j2k_write_cbd(p_j2k, p_stream, p_manager)) {
5518         return OPJ_FALSE;
5519     }
5520
5521     l_tcp = &(p_j2k->m_cp.tcps[p_j2k->m_current_tile_number]);
5522     l_mct_record = l_tcp->m_mct_records;
5523
5524     for (i = 0; i < l_tcp->m_nb_mct_records; ++i) {
5525
5526         if (! opj_j2k_write_mct_record(p_j2k, l_mct_record, p_stream, p_manager)) {
5527             return OPJ_FALSE;
5528         }
5529
5530         ++l_mct_record;
5531     }
5532
5533     l_mcc_record = l_tcp->m_mcc_records;
5534
5535     for (i = 0; i < l_tcp->m_nb_mcc_records; ++i) {
5536
5537         if (! opj_j2k_write_mcc_record(p_j2k, l_mcc_record, p_stream, p_manager)) {
5538             return OPJ_FALSE;
5539         }
5540
5541         ++l_mcc_record;
5542     }
5543
5544     if (! opj_j2k_write_mco(p_j2k, p_stream, p_manager)) {
5545         return OPJ_FALSE;
5546     }
5547
5548     return OPJ_TRUE;
5549 }
5550
5551 static OPJ_BOOL opj_j2k_write_all_coc(
5552     opj_j2k_t *p_j2k,
5553     struct opj_stream_private *p_stream,
5554     struct opj_event_mgr * p_manager)
5555 {
5556     OPJ_UINT32 compno;
5557
5558     /* preconditions */
5559     assert(p_j2k != 00);
5560     assert(p_manager != 00);
5561     assert(p_stream != 00);
5562
5563     for (compno = 1; compno < p_j2k->m_private_image->numcomps; ++compno) {
5564         /* cod is first component of first tile */
5565         if (! opj_j2k_compare_coc(p_j2k, 0, compno)) {
5566             if (! opj_j2k_write_coc(p_j2k, compno, p_stream, p_manager)) {
5567                 return OPJ_FALSE;
5568             }
5569         }
5570     }
5571
5572     return OPJ_TRUE;
5573 }
5574
5575 static OPJ_BOOL opj_j2k_write_all_qcc(
5576     opj_j2k_t *p_j2k,
5577     struct opj_stream_private *p_stream,
5578     struct opj_event_mgr * p_manager)
5579 {
5580     OPJ_UINT32 compno;
5581
5582     /* preconditions */
5583     assert(p_j2k != 00);
5584     assert(p_manager != 00);
5585     assert(p_stream != 00);
5586
5587     for (compno = 1; compno < p_j2k->m_private_image->numcomps; ++compno) {
5588         /* qcd is first component of first tile */
5589         if (! opj_j2k_compare_qcc(p_j2k, 0, compno)) {
5590             if (! opj_j2k_write_qcc(p_j2k, compno, p_stream, p_manager)) {
5591                 return OPJ_FALSE;
5592             }
5593         }
5594     }
5595     return OPJ_TRUE;
5596 }
5597
5598 static OPJ_BOOL opj_j2k_write_regions(opj_j2k_t *p_j2k,
5599                                       struct opj_stream_private *p_stream,
5600                                       struct opj_event_mgr * p_manager)
5601 {
5602     OPJ_UINT32 compno;
5603     const opj_tccp_t *l_tccp = 00;
5604
5605     /* preconditions */
5606     assert(p_j2k != 00);
5607     assert(p_manager != 00);
5608     assert(p_stream != 00);
5609
5610     l_tccp = p_j2k->m_cp.tcps->tccps;
5611
5612     for (compno = 0; compno < p_j2k->m_private_image->numcomps; ++compno)  {
5613         if (l_tccp->roishift) {
5614
5615             if (! opj_j2k_write_rgn(p_j2k, 0, compno, p_j2k->m_private_image->numcomps,
5616                                     p_stream, p_manager)) {
5617                 return OPJ_FALSE;
5618             }
5619         }
5620
5621         ++l_tccp;
5622     }
5623
5624     return OPJ_TRUE;
5625 }
5626
5627 static OPJ_BOOL opj_j2k_write_epc(opj_j2k_t *p_j2k,
5628                                   struct opj_stream_private *p_stream,
5629                                   struct opj_event_mgr * p_manager)
5630 {
5631     opj_codestream_index_t * l_cstr_index = 00;
5632
5633     /* preconditions */
5634     assert(p_j2k != 00);
5635     assert(p_manager != 00);
5636     assert(p_stream != 00);
5637
5638     OPJ_UNUSED(p_manager);
5639
5640     l_cstr_index = p_j2k->cstr_index;
5641     if (l_cstr_index) {
5642         l_cstr_index->codestream_size = (OPJ_UINT64)opj_stream_tell(p_stream);
5643         /* UniPG>> */
5644         /* The following adjustment is done to adjust the codestream size */
5645         /* if SOD is not at 0 in the buffer. Useful in case of JP2, where */
5646         /* the first bunch of bytes is not in the codestream              */
5647         l_cstr_index->codestream_size -= (OPJ_UINT64)l_cstr_index->main_head_start;
5648         /* <<UniPG */
5649     }
5650
5651 #ifdef USE_JPWL
5652     /* preparation of JPWL marker segments */
5653 #if 0
5654     if (cp->epc_on) {
5655
5656         /* encode according to JPWL */
5657         jpwl_encode(p_j2k, p_stream, image);
5658
5659     }
5660 #endif
5661     assert(0 && "TODO");
5662 #endif /* USE_JPWL */
5663
5664     return OPJ_TRUE;
5665 }
5666
5667 static OPJ_BOOL opj_j2k_read_unk(opj_j2k_t *p_j2k,
5668                                  opj_stream_private_t *p_stream,
5669                                  OPJ_UINT32 *output_marker,
5670                                  opj_event_mgr_t * p_manager
5671                                 )
5672 {
5673     OPJ_UINT32 l_unknown_marker;
5674     const opj_dec_memory_marker_handler_t * l_marker_handler;
5675     OPJ_UINT32 l_size_unk = 2;
5676
5677     /* preconditions*/
5678     assert(p_j2k != 00);
5679     assert(p_manager != 00);
5680     assert(p_stream != 00);
5681
5682     opj_event_msg(p_manager, EVT_WARNING, "Unknown marker\n");
5683
5684     for (;;) {
5685         /* Try to read 2 bytes (the next marker ID) from stream and copy them into the buffer*/
5686         if (opj_stream_read_data(p_stream,
5687                                  p_j2k->m_specific_param.m_decoder.m_header_data, 2, p_manager) != 2) {
5688             opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
5689             return OPJ_FALSE;
5690         }
5691
5692         /* read 2 bytes as the new marker ID*/
5693         opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,
5694                        &l_unknown_marker, 2);
5695
5696         if (!(l_unknown_marker < 0xff00)) {
5697
5698             /* Get the marker handler from the marker ID*/
5699             l_marker_handler = opj_j2k_get_marker_handler(l_unknown_marker);
5700
5701             if (!(p_j2k->m_specific_param.m_decoder.m_state & l_marker_handler->states)) {
5702                 opj_event_msg(p_manager, EVT_ERROR,
5703                               "Marker is not compliant with its position\n");
5704                 return OPJ_FALSE;
5705             } else {
5706                 if (l_marker_handler->id != J2K_MS_UNK) {
5707                     /* Add the marker to the codestream index*/
5708                     if (l_marker_handler->id != J2K_MS_SOT) {
5709                         OPJ_BOOL res = opj_j2k_add_mhmarker(p_j2k->cstr_index, J2K_MS_UNK,
5710                                                             (OPJ_UINT32) opj_stream_tell(p_stream) - l_size_unk,
5711                                                             l_size_unk);
5712                         if (res == OPJ_FALSE) {
5713                             opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to add mh marker\n");
5714                             return OPJ_FALSE;
5715                         }
5716                     }
5717                     break; /* next marker is known and well located */
5718                 } else {
5719                     l_size_unk += 2;
5720                 }
5721             }
5722         }
5723     }
5724
5725     *output_marker = l_marker_handler->id ;
5726
5727     return OPJ_TRUE;
5728 }
5729
5730 static OPJ_BOOL opj_j2k_write_mct_record(opj_j2k_t *p_j2k,
5731         opj_mct_data_t * p_mct_record,
5732         struct opj_stream_private *p_stream,
5733         struct opj_event_mgr * p_manager)
5734 {
5735     OPJ_UINT32 l_mct_size;
5736     OPJ_BYTE * l_current_data = 00;
5737     OPJ_UINT32 l_tmp;
5738
5739     /* preconditions */
5740     assert(p_j2k != 00);
5741     assert(p_manager != 00);
5742     assert(p_stream != 00);
5743
5744     l_mct_size = 10 + p_mct_record->m_data_size;
5745
5746     if (l_mct_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) {
5747         OPJ_BYTE *new_header_tile_data = (OPJ_BYTE *) opj_realloc(
5748                                              p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_mct_size);
5749         if (! new_header_tile_data) {
5750             opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
5751             p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL;
5752             p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
5753             opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write MCT marker\n");
5754             return OPJ_FALSE;
5755         }
5756         p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data;
5757         p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_mct_size;
5758     }
5759
5760     l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
5761
5762     opj_write_bytes(l_current_data, J2K_MS_MCT,
5763                     2);                                   /* MCT */
5764     l_current_data += 2;
5765
5766     opj_write_bytes(l_current_data, l_mct_size - 2,
5767                     2);                                 /* Lmct */
5768     l_current_data += 2;
5769
5770     opj_write_bytes(l_current_data, 0,
5771                     2);                                                    /* Zmct */
5772     l_current_data += 2;
5773
5774     /* only one marker atm */
5775     l_tmp = (p_mct_record->m_index & 0xff) | (p_mct_record->m_array_type << 8) |
5776             (p_mct_record->m_element_type << 10);
5777
5778     opj_write_bytes(l_current_data, l_tmp, 2);
5779     l_current_data += 2;
5780
5781     opj_write_bytes(l_current_data, 0,
5782                     2);                                                    /* Ymct */
5783     l_current_data += 2;
5784
5785     memcpy(l_current_data, p_mct_record->m_data, p_mct_record->m_data_size);
5786
5787     if (opj_stream_write_data(p_stream,
5788                               p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_mct_size,
5789                               p_manager) != l_mct_size) {
5790         return OPJ_FALSE;
5791     }
5792
5793     return OPJ_TRUE;
5794 }
5795
5796 /**
5797  * Reads a MCT marker (Multiple Component Transform)
5798  *
5799  * @param       p_header_data   the data contained in the MCT box.
5800  * @param       p_j2k                   the jpeg2000 codec.
5801  * @param       p_header_size   the size of the data contained in the MCT marker.
5802  * @param       p_manager               the user event manager.
5803 */
5804 static OPJ_BOOL opj_j2k_read_mct(opj_j2k_t *p_j2k,
5805                                  OPJ_BYTE * p_header_data,
5806                                  OPJ_UINT32 p_header_size,
5807                                  opj_event_mgr_t * p_manager
5808                                 )
5809 {
5810     OPJ_UINT32 i;
5811     opj_tcp_t *l_tcp = 00;
5812     OPJ_UINT32 l_tmp;
5813     OPJ_UINT32 l_indix;
5814     opj_mct_data_t * l_mct_data;
5815
5816     /* preconditions */
5817     assert(p_header_data != 00);
5818     assert(p_j2k != 00);
5819
5820     l_tcp = p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH ?
5821             &p_j2k->m_cp.tcps[p_j2k->m_current_tile_number] :
5822             p_j2k->m_specific_param.m_decoder.m_default_tcp;
5823
5824     if (p_header_size < 2) {
5825         opj_event_msg(p_manager, EVT_ERROR, "Error reading MCT marker\n");
5826         return OPJ_FALSE;
5827     }
5828
5829     /* first marker */
5830     opj_read_bytes(p_header_data, &l_tmp, 2);                       /* Zmct */
5831     p_header_data += 2;
5832     if (l_tmp != 0) {
5833         opj_event_msg(p_manager, EVT_WARNING,
5834                       "Cannot take in charge mct data within multiple MCT records\n");
5835         return OPJ_TRUE;
5836     }
5837
5838     if (p_header_size <= 6) {
5839         opj_event_msg(p_manager, EVT_ERROR, "Error reading MCT marker\n");
5840         return OPJ_FALSE;
5841     }
5842
5843     /* Imct -> no need for other values, take the first, type is double with decorrelation x0000 1101 0000 0000*/
5844     opj_read_bytes(p_header_data, &l_tmp, 2);                       /* Imct */
5845     p_header_data += 2;
5846
5847     l_indix = l_tmp & 0xff;
5848     l_mct_data = l_tcp->m_mct_records;
5849
5850     for (i = 0; i < l_tcp->m_nb_mct_records; ++i) {
5851         if (l_mct_data->m_index == l_indix) {
5852             break;
5853         }
5854         ++l_mct_data;
5855     }
5856
5857     /* NOT FOUND */
5858     if (i == l_tcp->m_nb_mct_records) {
5859         if (l_tcp->m_nb_mct_records == l_tcp->m_nb_max_mct_records) {
5860             opj_mct_data_t *new_mct_records;
5861             l_tcp->m_nb_max_mct_records += OPJ_J2K_MCT_DEFAULT_NB_RECORDS;
5862
5863             new_mct_records = (opj_mct_data_t *) opj_realloc(l_tcp->m_mct_records,
5864                               l_tcp->m_nb_max_mct_records * sizeof(opj_mct_data_t));
5865             if (! new_mct_records) {
5866                 opj_free(l_tcp->m_mct_records);
5867                 l_tcp->m_mct_records = NULL;
5868                 l_tcp->m_nb_max_mct_records = 0;
5869                 l_tcp->m_nb_mct_records = 0;
5870                 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read MCT marker\n");
5871                 return OPJ_FALSE;
5872             }
5873
5874             /* Update m_mcc_records[].m_offset_array and m_decorrelation_array
5875              * to point to the new addresses */
5876             if (new_mct_records != l_tcp->m_mct_records) {
5877                 for (i = 0; i < l_tcp->m_nb_mcc_records; ++i) {
5878                     opj_simple_mcc_decorrelation_data_t* l_mcc_record =
5879                         &(l_tcp->m_mcc_records[i]);
5880                     if (l_mcc_record->m_decorrelation_array) {
5881                         l_mcc_record->m_decorrelation_array =
5882                             new_mct_records +
5883                             (l_mcc_record->m_decorrelation_array -
5884                              l_tcp->m_mct_records);
5885                     }
5886                     if (l_mcc_record->m_offset_array) {
5887                         l_mcc_record->m_offset_array =
5888                             new_mct_records +
5889                             (l_mcc_record->m_offset_array -
5890                              l_tcp->m_mct_records);
5891                     }
5892                 }
5893             }
5894
5895             l_tcp->m_mct_records = new_mct_records;
5896             l_mct_data = l_tcp->m_mct_records + l_tcp->m_nb_mct_records;
5897             memset(l_mct_data, 0, (l_tcp->m_nb_max_mct_records - l_tcp->m_nb_mct_records) *
5898                    sizeof(opj_mct_data_t));
5899         }
5900
5901         l_mct_data = l_tcp->m_mct_records + l_tcp->m_nb_mct_records;
5902         ++l_tcp->m_nb_mct_records;
5903     }
5904
5905     if (l_mct_data->m_data) {
5906         opj_free(l_mct_data->m_data);
5907         l_mct_data->m_data = 00;
5908         l_mct_data->m_data_size = 0;
5909     }
5910
5911     l_mct_data->m_index = l_indix;
5912     l_mct_data->m_array_type = (J2K_MCT_ARRAY_TYPE)((l_tmp  >> 8) & 3);
5913     l_mct_data->m_element_type = (J2K_MCT_ELEMENT_TYPE)((l_tmp  >> 10) & 3);
5914
5915     opj_read_bytes(p_header_data, &l_tmp, 2);                       /* Ymct */
5916     p_header_data += 2;
5917     if (l_tmp != 0) {
5918         opj_event_msg(p_manager, EVT_WARNING,
5919                       "Cannot take in charge multiple MCT markers\n");
5920         return OPJ_TRUE;
5921     }
5922
5923     p_header_size -= 6;
5924
5925     l_mct_data->m_data = (OPJ_BYTE*)opj_malloc(p_header_size);
5926     if (! l_mct_data->m_data) {
5927         opj_event_msg(p_manager, EVT_ERROR, "Error reading MCT marker\n");
5928         return OPJ_FALSE;
5929     }
5930     memcpy(l_mct_data->m_data, p_header_data, p_header_size);
5931
5932     l_mct_data->m_data_size = p_header_size;
5933
5934     return OPJ_TRUE;
5935 }
5936
5937 static OPJ_BOOL opj_j2k_write_mcc_record(opj_j2k_t *p_j2k,
5938         struct opj_simple_mcc_decorrelation_data * p_mcc_record,
5939         struct opj_stream_private *p_stream,
5940         struct opj_event_mgr * p_manager)
5941 {
5942     OPJ_UINT32 i;
5943     OPJ_UINT32 l_mcc_size;
5944     OPJ_BYTE * l_current_data = 00;
5945     OPJ_UINT32 l_nb_bytes_for_comp;
5946     OPJ_UINT32 l_mask;
5947     OPJ_UINT32 l_tmcc;
5948
5949     /* preconditions */
5950     assert(p_j2k != 00);
5951     assert(p_manager != 00);
5952     assert(p_stream != 00);
5953
5954     if (p_mcc_record->m_nb_comps > 255) {
5955         l_nb_bytes_for_comp = 2;
5956         l_mask = 0x8000;
5957     } else {
5958         l_nb_bytes_for_comp = 1;
5959         l_mask = 0;
5960     }
5961
5962     l_mcc_size = p_mcc_record->m_nb_comps * 2 * l_nb_bytes_for_comp + 19;
5963     if (l_mcc_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) {
5964         OPJ_BYTE *new_header_tile_data = (OPJ_BYTE *) opj_realloc(
5965                                              p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_mcc_size);
5966         if (! new_header_tile_data) {
5967             opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
5968             p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL;
5969             p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
5970             opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write MCC marker\n");
5971             return OPJ_FALSE;
5972         }
5973         p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data;
5974         p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_mcc_size;
5975     }
5976
5977     l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
5978
5979     opj_write_bytes(l_current_data, J2K_MS_MCC,
5980                     2);                                   /* MCC */
5981     l_current_data += 2;
5982
5983     opj_write_bytes(l_current_data, l_mcc_size - 2,
5984                     2);                                 /* Lmcc */
5985     l_current_data += 2;
5986
5987     /* first marker */
5988     opj_write_bytes(l_current_data, 0,
5989                     2);                                  /* Zmcc */
5990     l_current_data += 2;
5991
5992     opj_write_bytes(l_current_data, p_mcc_record->m_index,
5993                     1);                                        /* Imcc -> no need for other values, take the first */
5994     ++l_current_data;
5995
5996     /* only one marker atm */
5997     opj_write_bytes(l_current_data, 0,
5998                     2);                                  /* Ymcc */
5999     l_current_data += 2;
6000
6001     opj_write_bytes(l_current_data, 1,
6002                     2);                                  /* Qmcc -> number of collections -> 1 */
6003     l_current_data += 2;
6004
6005     opj_write_bytes(l_current_data, 0x1,
6006                     1);                                /* Xmcci type of component transformation -> array based decorrelation */
6007     ++l_current_data;
6008
6009     opj_write_bytes(l_current_data, p_mcc_record->m_nb_comps | l_mask,
6010                     2);  /* Nmcci number of input components involved and size for each component offset = 8 bits */
6011     l_current_data += 2;
6012
6013     for (i = 0; i < p_mcc_record->m_nb_comps; ++i) {
6014         opj_write_bytes(l_current_data, i,
6015                         l_nb_bytes_for_comp);                          /* Cmccij Component offset*/
6016         l_current_data += l_nb_bytes_for_comp;
6017     }
6018
6019     opj_write_bytes(l_current_data, p_mcc_record->m_nb_comps | l_mask,
6020                     2);  /* Mmcci number of output components involved and size for each component offset = 8 bits */
6021     l_current_data += 2;
6022
6023     for (i = 0; i < p_mcc_record->m_nb_comps; ++i) {
6024         opj_write_bytes(l_current_data, i,
6025                         l_nb_bytes_for_comp);                          /* Wmccij Component offset*/
6026         l_current_data += l_nb_bytes_for_comp;
6027     }
6028
6029     l_tmcc = ((!p_mcc_record->m_is_irreversible) & 1U) << 16;
6030
6031     if (p_mcc_record->m_decorrelation_array) {
6032         l_tmcc |= p_mcc_record->m_decorrelation_array->m_index;
6033     }
6034
6035     if (p_mcc_record->m_offset_array) {
6036         l_tmcc |= ((p_mcc_record->m_offset_array->m_index) << 8);
6037     }
6038
6039     opj_write_bytes(l_current_data, l_tmcc,
6040                     3);     /* Tmcci : use MCT defined as number 1 and irreversible array based. */
6041     l_current_data += 3;
6042
6043     if (opj_stream_write_data(p_stream,
6044                               p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_mcc_size,
6045                               p_manager) != l_mcc_size) {
6046         return OPJ_FALSE;
6047     }
6048
6049     return OPJ_TRUE;
6050 }
6051
6052 static OPJ_BOOL opj_j2k_read_mcc(opj_j2k_t *p_j2k,
6053                                  OPJ_BYTE * p_header_data,
6054                                  OPJ_UINT32 p_header_size,
6055                                  opj_event_mgr_t * p_manager)
6056 {
6057     OPJ_UINT32 i, j;
6058     OPJ_UINT32 l_tmp;
6059     OPJ_UINT32 l_indix;
6060     opj_tcp_t * l_tcp;
6061     opj_simple_mcc_decorrelation_data_t * l_mcc_record;
6062     opj_mct_data_t * l_mct_data;
6063     OPJ_UINT32 l_nb_collections;
6064     OPJ_UINT32 l_nb_comps;
6065     OPJ_UINT32 l_nb_bytes_by_comp;
6066     OPJ_BOOL l_new_mcc = OPJ_FALSE;
6067
6068     /* preconditions */
6069     assert(p_header_data != 00);
6070     assert(p_j2k != 00);
6071     assert(p_manager != 00);
6072
6073     l_tcp = p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH ?
6074             &p_j2k->m_cp.tcps[p_j2k->m_current_tile_number] :
6075             p_j2k->m_specific_param.m_decoder.m_default_tcp;
6076
6077     if (p_header_size < 2) {
6078         opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
6079         return OPJ_FALSE;
6080     }
6081
6082     /* first marker */
6083     opj_read_bytes(p_header_data, &l_tmp, 2);                       /* Zmcc */
6084     p_header_data += 2;
6085     if (l_tmp != 0) {
6086         opj_event_msg(p_manager, EVT_WARNING,
6087                       "Cannot take in charge multiple data spanning\n");
6088         return OPJ_TRUE;
6089     }
6090
6091     if (p_header_size < 7) {
6092         opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
6093         return OPJ_FALSE;
6094     }
6095
6096     opj_read_bytes(p_header_data, &l_indix,
6097                    1); /* Imcc -> no need for other values, take the first */
6098     ++p_header_data;
6099
6100     l_mcc_record = l_tcp->m_mcc_records;
6101
6102     for (i = 0; i < l_tcp->m_nb_mcc_records; ++i) {
6103         if (l_mcc_record->m_index == l_indix) {
6104             break;
6105         }
6106         ++l_mcc_record;
6107     }
6108
6109     /** NOT FOUND */
6110     if (i == l_tcp->m_nb_mcc_records) {
6111         if (l_tcp->m_nb_mcc_records == l_tcp->m_nb_max_mcc_records) {
6112             opj_simple_mcc_decorrelation_data_t *new_mcc_records;
6113             l_tcp->m_nb_max_mcc_records += OPJ_J2K_MCC_DEFAULT_NB_RECORDS;
6114
6115             new_mcc_records = (opj_simple_mcc_decorrelation_data_t *) opj_realloc(
6116                                   l_tcp->m_mcc_records, l_tcp->m_nb_max_mcc_records * sizeof(
6117                                       opj_simple_mcc_decorrelation_data_t));
6118             if (! new_mcc_records) {
6119                 opj_free(l_tcp->m_mcc_records);
6120                 l_tcp->m_mcc_records = NULL;
6121                 l_tcp->m_nb_max_mcc_records = 0;
6122                 l_tcp->m_nb_mcc_records = 0;
6123                 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read MCC marker\n");
6124                 return OPJ_FALSE;
6125             }
6126             l_tcp->m_mcc_records = new_mcc_records;
6127             l_mcc_record = l_tcp->m_mcc_records + l_tcp->m_nb_mcc_records;
6128             memset(l_mcc_record, 0, (l_tcp->m_nb_max_mcc_records - l_tcp->m_nb_mcc_records)
6129                    * sizeof(opj_simple_mcc_decorrelation_data_t));
6130         }
6131         l_mcc_record = l_tcp->m_mcc_records + l_tcp->m_nb_mcc_records;
6132         l_new_mcc = OPJ_TRUE;
6133     }
6134     l_mcc_record->m_index = l_indix;
6135
6136     /* only one marker atm */
6137     opj_read_bytes(p_header_data, &l_tmp, 2);                       /* Ymcc */
6138     p_header_data += 2;
6139     if (l_tmp != 0) {
6140         opj_event_msg(p_manager, EVT_WARNING,
6141                       "Cannot take in charge multiple data spanning\n");
6142         return OPJ_TRUE;
6143     }
6144
6145     opj_read_bytes(p_header_data, &l_nb_collections,
6146                    2);                              /* Qmcc -> number of collections -> 1 */
6147     p_header_data += 2;
6148
6149     if (l_nb_collections > 1) {
6150         opj_event_msg(p_manager, EVT_WARNING,
6151                       "Cannot take in charge multiple collections\n");
6152         return OPJ_TRUE;
6153     }
6154
6155     p_header_size -= 7;
6156
6157     for (i = 0; i < l_nb_collections; ++i) {
6158         if (p_header_size < 3) {
6159             opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
6160             return OPJ_FALSE;
6161         }
6162
6163         opj_read_bytes(p_header_data, &l_tmp,
6164                        1); /* Xmcci type of component transformation -> array based decorrelation */
6165         ++p_header_data;
6166
6167         if (l_tmp != 1) {
6168             opj_event_msg(p_manager, EVT_WARNING,
6169                           "Cannot take in charge collections other than array decorrelation\n");
6170             return OPJ_TRUE;
6171         }
6172
6173         opj_read_bytes(p_header_data, &l_nb_comps, 2);
6174
6175         p_header_data += 2;
6176         p_header_size -= 3;
6177
6178         l_nb_bytes_by_comp = 1 + (l_nb_comps >> 15);
6179         l_mcc_record->m_nb_comps = l_nb_comps & 0x7fff;
6180
6181         if (p_header_size < (l_nb_bytes_by_comp * l_mcc_record->m_nb_comps + 2)) {
6182             opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
6183             return OPJ_FALSE;
6184         }
6185
6186         p_header_size -= (l_nb_bytes_by_comp * l_mcc_record->m_nb_comps + 2);
6187
6188         for (j = 0; j < l_mcc_record->m_nb_comps; ++j) {
6189             opj_read_bytes(p_header_data, &l_tmp,
6190                            l_nb_bytes_by_comp);      /* Cmccij Component offset*/
6191             p_header_data += l_nb_bytes_by_comp;
6192
6193             if (l_tmp != j) {
6194                 opj_event_msg(p_manager, EVT_WARNING,
6195                               "Cannot take in charge collections with indix shuffle\n");
6196                 return OPJ_TRUE;
6197             }
6198         }
6199
6200         opj_read_bytes(p_header_data, &l_nb_comps, 2);
6201         p_header_data += 2;
6202
6203         l_nb_bytes_by_comp = 1 + (l_nb_comps >> 15);
6204         l_nb_comps &= 0x7fff;
6205
6206         if (l_nb_comps != l_mcc_record->m_nb_comps) {
6207             opj_event_msg(p_manager, EVT_WARNING,
6208                           "Cannot take in charge collections without same number of indixes\n");
6209             return OPJ_TRUE;
6210         }
6211
6212         if (p_header_size < (l_nb_bytes_by_comp * l_mcc_record->m_nb_comps + 3)) {
6213             opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
6214             return OPJ_FALSE;
6215         }
6216
6217         p_header_size -= (l_nb_bytes_by_comp * l_mcc_record->m_nb_comps + 3);
6218
6219         for (j = 0; j < l_mcc_record->m_nb_comps; ++j) {
6220             opj_read_bytes(p_header_data, &l_tmp,
6221                            l_nb_bytes_by_comp);      /* Wmccij Component offset*/
6222             p_header_data += l_nb_bytes_by_comp;
6223
6224             if (l_tmp != j) {
6225                 opj_event_msg(p_manager, EVT_WARNING,
6226                               "Cannot take in charge collections with indix shuffle\n");
6227                 return OPJ_TRUE;
6228             }
6229         }
6230
6231         opj_read_bytes(p_header_data, &l_tmp, 3); /* Wmccij Component offset*/
6232         p_header_data += 3;
6233
6234         l_mcc_record->m_is_irreversible = !((l_tmp >> 16) & 1);
6235         l_mcc_record->m_decorrelation_array = 00;
6236         l_mcc_record->m_offset_array = 00;
6237
6238         l_indix = l_tmp & 0xff;
6239         if (l_indix != 0) {
6240             l_mct_data = l_tcp->m_mct_records;
6241             for (j = 0; j < l_tcp->m_nb_mct_records; ++j) {
6242                 if (l_mct_data->m_index == l_indix) {
6243                     l_mcc_record->m_decorrelation_array = l_mct_data;
6244                     break;
6245                 }
6246                 ++l_mct_data;
6247             }
6248
6249             if (l_mcc_record->m_decorrelation_array == 00) {
6250                 opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
6251                 return OPJ_FALSE;
6252             }
6253         }
6254
6255         l_indix = (l_tmp >> 8) & 0xff;
6256         if (l_indix != 0) {
6257             l_mct_data = l_tcp->m_mct_records;
6258             for (j = 0; j < l_tcp->m_nb_mct_records; ++j) {
6259                 if (l_mct_data->m_index == l_indix) {
6260                     l_mcc_record->m_offset_array = l_mct_data;
6261                     break;
6262                 }
6263                 ++l_mct_data;
6264             }
6265
6266             if (l_mcc_record->m_offset_array == 00) {
6267                 opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
6268                 return OPJ_FALSE;
6269             }
6270         }
6271     }
6272
6273     if (p_header_size != 0) {
6274         opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
6275         return OPJ_FALSE;
6276     }
6277
6278     if (l_new_mcc) {
6279         ++l_tcp->m_nb_mcc_records;
6280     }
6281
6282     return OPJ_TRUE;
6283 }
6284
6285 static OPJ_BOOL opj_j2k_write_mco(opj_j2k_t *p_j2k,
6286                                   struct opj_stream_private *p_stream,
6287                                   struct opj_event_mgr * p_manager
6288                                  )
6289 {
6290     OPJ_BYTE * l_current_data = 00;
6291     OPJ_UINT32 l_mco_size;
6292     opj_tcp_t * l_tcp = 00;
6293     opj_simple_mcc_decorrelation_data_t * l_mcc_record;
6294     OPJ_UINT32 i;
6295
6296     /* preconditions */
6297     assert(p_j2k != 00);
6298     assert(p_manager != 00);
6299     assert(p_stream != 00);
6300
6301     l_tcp = &(p_j2k->m_cp.tcps[p_j2k->m_current_tile_number]);
6302
6303     l_mco_size = 5 + l_tcp->m_nb_mcc_records;
6304     if (l_mco_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) {
6305
6306         OPJ_BYTE *new_header_tile_data = (OPJ_BYTE *) opj_realloc(
6307                                              p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_mco_size);
6308         if (! new_header_tile_data) {
6309             opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
6310             p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL;
6311             p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
6312             opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write MCO marker\n");
6313             return OPJ_FALSE;
6314         }
6315         p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data;
6316         p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_mco_size;
6317     }
6318     l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
6319
6320
6321     opj_write_bytes(l_current_data, J2K_MS_MCO, 2);                 /* MCO */
6322     l_current_data += 2;
6323
6324     opj_write_bytes(l_current_data, l_mco_size - 2, 2);             /* Lmco */
6325     l_current_data += 2;
6326
6327     opj_write_bytes(l_current_data, l_tcp->m_nb_mcc_records,
6328                     1);    /* Nmco : only one transform stage*/
6329     ++l_current_data;
6330
6331     l_mcc_record = l_tcp->m_mcc_records;
6332     for (i = 0; i < l_tcp->m_nb_mcc_records; ++i) {
6333         opj_write_bytes(l_current_data, l_mcc_record->m_index,
6334                         1); /* Imco -> use the mcc indicated by 1*/
6335         ++l_current_data;
6336         ++l_mcc_record;
6337     }
6338
6339     if (opj_stream_write_data(p_stream,
6340                               p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_mco_size,
6341                               p_manager) != l_mco_size) {
6342         return OPJ_FALSE;
6343     }
6344
6345     return OPJ_TRUE;
6346 }
6347
6348 /**
6349  * Reads a MCO marker (Multiple Component Transform Ordering)
6350  *
6351  * @param       p_header_data   the data contained in the MCO box.
6352  * @param       p_j2k                   the jpeg2000 codec.
6353  * @param       p_header_size   the size of the data contained in the MCO marker.
6354  * @param       p_manager               the user event manager.
6355 */
6356 static OPJ_BOOL opj_j2k_read_mco(opj_j2k_t *p_j2k,
6357                                  OPJ_BYTE * p_header_data,
6358                                  OPJ_UINT32 p_header_size,
6359                                  opj_event_mgr_t * p_manager
6360                                 )
6361 {
6362     OPJ_UINT32 l_tmp, i;
6363     OPJ_UINT32 l_nb_stages;
6364     opj_tcp_t * l_tcp;
6365     opj_tccp_t * l_tccp;
6366     opj_image_t * l_image;
6367
6368     /* preconditions */
6369     assert(p_header_data != 00);
6370     assert(p_j2k != 00);
6371     assert(p_manager != 00);
6372
6373     l_image = p_j2k->m_private_image;
6374     l_tcp = p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH ?
6375             &p_j2k->m_cp.tcps[p_j2k->m_current_tile_number] :
6376             p_j2k->m_specific_param.m_decoder.m_default_tcp;
6377
6378     if (p_header_size < 1) {
6379         opj_event_msg(p_manager, EVT_ERROR, "Error reading MCO marker\n");
6380         return OPJ_FALSE;
6381     }
6382
6383     opj_read_bytes(p_header_data, &l_nb_stages,
6384                    1);                         /* Nmco : only one transform stage*/
6385     ++p_header_data;
6386
6387     if (l_nb_stages > 1) {
6388         opj_event_msg(p_manager, EVT_WARNING,
6389                       "Cannot take in charge multiple transformation stages.\n");
6390         return OPJ_TRUE;
6391     }
6392
6393     if (p_header_size != l_nb_stages + 1) {
6394         opj_event_msg(p_manager, EVT_WARNING, "Error reading MCO marker\n");
6395         return OPJ_FALSE;
6396     }
6397
6398     l_tccp = l_tcp->tccps;
6399
6400     for (i = 0; i < l_image->numcomps; ++i) {
6401         l_tccp->m_dc_level_shift = 0;
6402         ++l_tccp;
6403     }
6404
6405     if (l_tcp->m_mct_decoding_matrix) {
6406         opj_free(l_tcp->m_mct_decoding_matrix);
6407         l_tcp->m_mct_decoding_matrix = 00;
6408     }
6409
6410     for (i = 0; i < l_nb_stages; ++i) {
6411         opj_read_bytes(p_header_data, &l_tmp, 1);
6412         ++p_header_data;
6413
6414         if (! opj_j2k_add_mct(l_tcp, p_j2k->m_private_image, l_tmp)) {
6415             return OPJ_FALSE;
6416         }
6417     }
6418
6419     return OPJ_TRUE;
6420 }
6421
6422 static OPJ_BOOL opj_j2k_add_mct(opj_tcp_t * p_tcp, opj_image_t * p_image,
6423                                 OPJ_UINT32 p_index)
6424 {
6425     OPJ_UINT32 i;
6426     opj_simple_mcc_decorrelation_data_t * l_mcc_record;
6427     opj_mct_data_t * l_deco_array, * l_offset_array;
6428     OPJ_UINT32 l_data_size, l_mct_size, l_offset_size;
6429     OPJ_UINT32 l_nb_elem;
6430     OPJ_UINT32 * l_offset_data, * l_current_offset_data;
6431     opj_tccp_t * l_tccp;
6432
6433     /* preconditions */
6434     assert(p_tcp != 00);
6435
6436     l_mcc_record = p_tcp->m_mcc_records;
6437
6438     for (i = 0; i < p_tcp->m_nb_mcc_records; ++i) {
6439         if (l_mcc_record->m_index == p_index) {
6440             break;
6441         }
6442     }
6443
6444     if (i == p_tcp->m_nb_mcc_records) {
6445         /** element discarded **/
6446         return OPJ_TRUE;
6447     }
6448
6449     if (l_mcc_record->m_nb_comps != p_image->numcomps) {
6450         /** do not support number of comps != image */
6451         return OPJ_TRUE;
6452     }
6453
6454     l_deco_array = l_mcc_record->m_decorrelation_array;
6455
6456     if (l_deco_array) {
6457         l_data_size = MCT_ELEMENT_SIZE[l_deco_array->m_element_type] * p_image->numcomps
6458                       * p_image->numcomps;
6459         if (l_deco_array->m_data_size != l_data_size) {
6460             return OPJ_FALSE;
6461         }
6462
6463         l_nb_elem = p_image->numcomps * p_image->numcomps;
6464         l_mct_size = l_nb_elem * (OPJ_UINT32)sizeof(OPJ_FLOAT32);
6465         p_tcp->m_mct_decoding_matrix = (OPJ_FLOAT32*)opj_malloc(l_mct_size);
6466
6467         if (! p_tcp->m_mct_decoding_matrix) {
6468             return OPJ_FALSE;
6469         }
6470
6471         j2k_mct_read_functions_to_float[l_deco_array->m_element_type](
6472             l_deco_array->m_data, p_tcp->m_mct_decoding_matrix, l_nb_elem);
6473     }
6474
6475     l_offset_array = l_mcc_record->m_offset_array;
6476
6477     if (l_offset_array) {
6478         l_data_size = MCT_ELEMENT_SIZE[l_offset_array->m_element_type] *
6479                       p_image->numcomps;
6480         if (l_offset_array->m_data_size != l_data_size) {
6481             return OPJ_FALSE;
6482         }
6483
6484         l_nb_elem = p_image->numcomps;
6485         l_offset_size = l_nb_elem * (OPJ_UINT32)sizeof(OPJ_UINT32);
6486         l_offset_data = (OPJ_UINT32*)opj_malloc(l_offset_size);
6487
6488         if (! l_offset_data) {
6489             return OPJ_FALSE;
6490         }
6491
6492         j2k_mct_read_functions_to_int32[l_offset_array->m_element_type](
6493             l_offset_array->m_data, l_offset_data, l_nb_elem);
6494
6495         l_tccp = p_tcp->tccps;
6496         l_current_offset_data = l_offset_data;
6497
6498         for (i = 0; i < p_image->numcomps; ++i) {
6499             l_tccp->m_dc_level_shift = (OPJ_INT32) * (l_current_offset_data++);
6500             ++l_tccp;
6501         }
6502
6503         opj_free(l_offset_data);
6504     }
6505
6506     return OPJ_TRUE;
6507 }
6508
6509 static OPJ_BOOL opj_j2k_write_cbd(opj_j2k_t *p_j2k,
6510                                   struct opj_stream_private *p_stream,
6511                                   struct opj_event_mgr * p_manager)
6512 {
6513     OPJ_UINT32 i;
6514     OPJ_UINT32 l_cbd_size;
6515     OPJ_BYTE * l_current_data = 00;
6516     opj_image_t *l_image = 00;
6517     opj_image_comp_t * l_comp = 00;
6518
6519     /* preconditions */
6520     assert(p_j2k != 00);
6521     assert(p_manager != 00);
6522     assert(p_stream != 00);
6523
6524     l_image = p_j2k->m_private_image;
6525     l_cbd_size = 6 + p_j2k->m_private_image->numcomps;
6526
6527     if (l_cbd_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) {
6528         OPJ_BYTE *new_header_tile_data = (OPJ_BYTE *) opj_realloc(
6529                                              p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_cbd_size);
6530         if (! new_header_tile_data) {
6531             opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
6532             p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL;
6533             p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
6534             opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write CBD marker\n");
6535             return OPJ_FALSE;
6536         }
6537         p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data;
6538         p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_cbd_size;
6539     }
6540
6541     l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
6542
6543     opj_write_bytes(l_current_data, J2K_MS_CBD, 2);                 /* CBD */
6544     l_current_data += 2;
6545
6546     opj_write_bytes(l_current_data, l_cbd_size - 2, 2);             /* L_CBD */
6547     l_current_data += 2;
6548
6549     opj_write_bytes(l_current_data, l_image->numcomps, 2);          /* Ncbd */
6550     l_current_data += 2;
6551
6552     l_comp = l_image->comps;
6553
6554     for (i = 0; i < l_image->numcomps; ++i) {
6555         opj_write_bytes(l_current_data, (l_comp->sgnd << 7) | (l_comp->prec - 1),
6556                         1);           /* Component bit depth */
6557         ++l_current_data;
6558
6559         ++l_comp;
6560     }
6561
6562     if (opj_stream_write_data(p_stream,
6563                               p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_cbd_size,
6564                               p_manager) != l_cbd_size) {
6565         return OPJ_FALSE;
6566     }
6567
6568     return OPJ_TRUE;
6569 }
6570
6571 /**
6572  * Reads a CBD marker (Component bit depth definition)
6573  * @param       p_header_data   the data contained in the CBD box.
6574  * @param       p_j2k                   the jpeg2000 codec.
6575  * @param       p_header_size   the size of the data contained in the CBD marker.
6576  * @param       p_manager               the user event manager.
6577 */
6578 static OPJ_BOOL opj_j2k_read_cbd(opj_j2k_t *p_j2k,
6579                                  OPJ_BYTE * p_header_data,
6580                                  OPJ_UINT32 p_header_size,
6581                                  opj_event_mgr_t * p_manager
6582                                 )
6583 {
6584     OPJ_UINT32 l_nb_comp, l_num_comp;
6585     OPJ_UINT32 l_comp_def;
6586     OPJ_UINT32 i;
6587     opj_image_comp_t * l_comp = 00;
6588
6589     /* preconditions */
6590     assert(p_header_data != 00);
6591     assert(p_j2k != 00);
6592     assert(p_manager != 00);
6593
6594     l_num_comp = p_j2k->m_private_image->numcomps;
6595
6596     if (p_header_size != (p_j2k->m_private_image->numcomps + 2)) {
6597         opj_event_msg(p_manager, EVT_ERROR, "Crror reading CBD marker\n");
6598         return OPJ_FALSE;
6599     }
6600
6601     opj_read_bytes(p_header_data, &l_nb_comp,
6602                    2);                           /* Ncbd */
6603     p_header_data += 2;
6604
6605     if (l_nb_comp != l_num_comp) {
6606         opj_event_msg(p_manager, EVT_ERROR, "Crror reading CBD marker\n");
6607         return OPJ_FALSE;
6608     }
6609
6610     l_comp = p_j2k->m_private_image->comps;
6611     for (i = 0; i < l_num_comp; ++i) {
6612         opj_read_bytes(p_header_data, &l_comp_def,
6613                        1);                  /* Component bit depth */
6614         ++p_header_data;
6615         l_comp->sgnd = (l_comp_def >> 7) & 1;
6616         l_comp->prec = (l_comp_def & 0x7f) + 1;
6617
6618         if (l_comp->prec > 31) {
6619             opj_event_msg(p_manager, EVT_ERROR,
6620                           "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",
6621                           i, l_comp->prec);
6622             return OPJ_FALSE;
6623         }
6624         ++l_comp;
6625     }
6626
6627     return OPJ_TRUE;
6628 }
6629
6630 /**
6631  * Reads a CAP marker (extended capabilities definition). Empty implementation.
6632  * Found in HTJ2K files.
6633  *
6634  * @param       p_header_data   the data contained in the CAP box.
6635  * @param       p_j2k                   the jpeg2000 codec.
6636  * @param       p_header_size   the size of the data contained in the CAP marker.
6637  * @param       p_manager               the user event manager.
6638 */
6639 static OPJ_BOOL opj_j2k_read_cap(opj_j2k_t *p_j2k,
6640                                  OPJ_BYTE * p_header_data,
6641                                  OPJ_UINT32 p_header_size,
6642                                  opj_event_mgr_t * p_manager
6643                                 )
6644 {
6645     /* preconditions */
6646     assert(p_header_data != 00);
6647     assert(p_j2k != 00);
6648     assert(p_manager != 00);
6649
6650     (void)p_j2k;
6651     (void)p_header_data;
6652     (void)p_header_size;
6653     (void)p_manager;
6654
6655     return OPJ_TRUE;
6656 }
6657
6658 /**
6659  * Reads a CPF marker (corresponding profile). Empty implementation. Found in HTJ2K files
6660  * @param       p_header_data   the data contained in the CPF box.
6661  * @param       p_j2k                   the jpeg2000 codec.
6662  * @param       p_header_size   the size of the data contained in the CPF marker.
6663  * @param       p_manager               the user event manager.
6664 */
6665 static OPJ_BOOL opj_j2k_read_cpf(opj_j2k_t *p_j2k,
6666                                  OPJ_BYTE * p_header_data,
6667                                  OPJ_UINT32 p_header_size,
6668                                  opj_event_mgr_t * p_manager
6669                                 )
6670 {
6671     /* preconditions */
6672     assert(p_header_data != 00);
6673     assert(p_j2k != 00);
6674     assert(p_manager != 00);
6675
6676     (void)p_j2k;
6677     (void)p_header_data;
6678     (void)p_header_size;
6679     (void)p_manager;
6680
6681     return OPJ_TRUE;
6682 }
6683
6684 /* ----------------------------------------------------------------------- */
6685 /* J2K / JPT decoder interface                                             */
6686 /* ----------------------------------------------------------------------- */
6687
6688 void opj_j2k_setup_decoder(opj_j2k_t *j2k, opj_dparameters_t *parameters)
6689 {
6690     if (j2k && parameters) {
6691         j2k->m_cp.m_specific_param.m_dec.m_layer = parameters->cp_layer;
6692         j2k->m_cp.m_specific_param.m_dec.m_reduce = parameters->cp_reduce;
6693
6694         j2k->dump_state = (parameters->flags & OPJ_DPARAMETERS_DUMP_FLAG);
6695 #ifdef USE_JPWL
6696         j2k->m_cp.correct = parameters->jpwl_correct;
6697         j2k->m_cp.exp_comps = parameters->jpwl_exp_comps;
6698         j2k->m_cp.max_tiles = parameters->jpwl_max_tiles;
6699 #endif /* USE_JPWL */
6700     }
6701 }
6702
6703 void opj_j2k_decoder_set_strict_mode(opj_j2k_t *j2k, OPJ_BOOL strict)
6704 {
6705     if (j2k) {
6706         j2k->m_cp.strict = strict;
6707     }
6708 }
6709
6710 OPJ_BOOL opj_j2k_set_threads(opj_j2k_t *j2k, OPJ_UINT32 num_threads)
6711 {
6712     /* Currently we pass the thread-pool to the tcd, so we cannot re-set it */
6713     /* afterwards */
6714     if (opj_has_thread_support() && j2k->m_tcd == NULL) {
6715         opj_thread_pool_destroy(j2k->m_tp);
6716         j2k->m_tp = NULL;
6717         if (num_threads <= (OPJ_UINT32)INT_MAX) {
6718             j2k->m_tp = opj_thread_pool_create((int)num_threads);
6719         }
6720         if (j2k->m_tp == NULL) {
6721             j2k->m_tp = opj_thread_pool_create(0);
6722             return OPJ_FALSE;
6723         }
6724         return OPJ_TRUE;
6725     }
6726     return OPJ_FALSE;
6727 }
6728
6729 static int opj_j2k_get_default_thread_count(void)
6730 {
6731     const char* num_threads_str = getenv("OPJ_NUM_THREADS");
6732     int num_cpus;
6733     int num_threads;
6734
6735     if (num_threads_str == NULL || !opj_has_thread_support()) {
6736         return 0;
6737     }
6738     num_cpus = opj_get_num_cpus();
6739     if (strcmp(num_threads_str, "ALL_CPUS") == 0) {
6740         return num_cpus;
6741     }
6742     if (num_cpus == 0) {
6743         num_cpus = 32;
6744     }
6745     num_threads = atoi(num_threads_str);
6746     if (num_threads < 0) {
6747         num_threads = 0;
6748     } else if (num_threads > 2 * num_cpus) {
6749         num_threads = 2 * num_cpus;
6750     }
6751     return num_threads;
6752 }
6753
6754 /* ----------------------------------------------------------------------- */
6755 /* J2K encoder interface                                                       */
6756 /* ----------------------------------------------------------------------- */
6757
6758 opj_j2k_t* opj_j2k_create_compress(void)
6759 {
6760     opj_j2k_t *l_j2k = (opj_j2k_t*) opj_calloc(1, sizeof(opj_j2k_t));
6761     if (!l_j2k) {
6762         return NULL;
6763     }
6764
6765
6766     l_j2k->m_is_decoder = 0;
6767     l_j2k->m_cp.m_is_decoder = 0;
6768
6769     l_j2k->m_specific_param.m_encoder.m_header_tile_data = (OPJ_BYTE *) opj_malloc(
6770                 OPJ_J2K_DEFAULT_HEADER_SIZE);
6771     if (! l_j2k->m_specific_param.m_encoder.m_header_tile_data) {
6772         opj_j2k_destroy(l_j2k);
6773         return NULL;
6774     }
6775
6776     l_j2k->m_specific_param.m_encoder.m_header_tile_data_size =
6777         OPJ_J2K_DEFAULT_HEADER_SIZE;
6778
6779     /* validation list creation*/
6780     l_j2k->m_validation_list = opj_procedure_list_create();
6781     if (! l_j2k->m_validation_list) {
6782         opj_j2k_destroy(l_j2k);
6783         return NULL;
6784     }
6785
6786     /* execution list creation*/
6787     l_j2k->m_procedure_list = opj_procedure_list_create();
6788     if (! l_j2k->m_procedure_list) {
6789         opj_j2k_destroy(l_j2k);
6790         return NULL;
6791     }
6792
6793     l_j2k->m_tp = opj_thread_pool_create(opj_j2k_get_default_thread_count());
6794     if (!l_j2k->m_tp) {
6795         l_j2k->m_tp = opj_thread_pool_create(0);
6796     }
6797     if (!l_j2k->m_tp) {
6798         opj_j2k_destroy(l_j2k);
6799         return NULL;
6800     }
6801
6802     return l_j2k;
6803 }
6804
6805 static int opj_j2k_initialise_4K_poc(opj_poc_t *POC, int numres)
6806 {
6807     POC[0].tile  = 1;
6808     POC[0].resno0  = 0;
6809     POC[0].compno0 = 0;
6810     POC[0].layno1  = 1;
6811     POC[0].resno1  = (OPJ_UINT32)(numres - 1);
6812     POC[0].compno1 = 3;
6813     POC[0].prg1 = OPJ_CPRL;
6814     POC[1].tile  = 1;
6815     POC[1].resno0  = (OPJ_UINT32)(numres - 1);
6816     POC[1].compno0 = 0;
6817     POC[1].layno1  = 1;
6818     POC[1].resno1  = (OPJ_UINT32)numres;
6819     POC[1].compno1 = 3;
6820     POC[1].prg1 = OPJ_CPRL;
6821     return 2;
6822 }
6823
6824 static void opj_j2k_set_cinema_parameters(opj_cparameters_t *parameters,
6825         opj_image_t *image, opj_event_mgr_t *p_manager)
6826 {
6827     /* Configure cinema parameters */
6828     int i;
6829
6830     /* No tiling */
6831     parameters->tile_size_on = OPJ_FALSE;
6832     parameters->cp_tdx = 1;
6833     parameters->cp_tdy = 1;
6834
6835     /* One tile part for each component */
6836     parameters->tp_flag = 'C';
6837     parameters->tp_on = 1;
6838
6839     /* Tile and Image shall be at (0,0) */
6840     parameters->cp_tx0 = 0;
6841     parameters->cp_ty0 = 0;
6842     parameters->image_offset_x0 = 0;
6843     parameters->image_offset_y0 = 0;
6844
6845     /* Codeblock size= 32*32 */
6846     parameters->cblockw_init = 32;
6847     parameters->cblockh_init = 32;
6848
6849     /* Codeblock style: no mode switch enabled */
6850     parameters->mode = 0;
6851
6852     /* No ROI */
6853     parameters->roi_compno = -1;
6854
6855     /* No subsampling */
6856     parameters->subsampling_dx = 1;
6857     parameters->subsampling_dy = 1;
6858
6859     /* 9-7 transform */
6860     parameters->irreversible = 1;
6861
6862     /* Number of layers */
6863     if (parameters->tcp_numlayers > 1) {
6864         opj_event_msg(p_manager, EVT_WARNING,
6865                       "JPEG 2000 Profile-3 and 4 (2k/4k dc profile) requires:\n"
6866                       "1 single quality layer"
6867                       "-> Number of layers forced to 1 (rather than %d)\n"
6868                       "-> Rate of the last layer (%3.1f) will be used",
6869                       parameters->tcp_numlayers,
6870                       parameters->tcp_rates[parameters->tcp_numlayers - 1]);
6871         parameters->tcp_rates[0] = parameters->tcp_rates[parameters->tcp_numlayers - 1];
6872         parameters->tcp_numlayers = 1;
6873     }
6874
6875     /* Resolution levels */
6876     switch (parameters->rsiz) {
6877     case OPJ_PROFILE_CINEMA_2K:
6878         if (parameters->numresolution > 6) {
6879             opj_event_msg(p_manager, EVT_WARNING,
6880                           "JPEG 2000 Profile-3 (2k dc profile) requires:\n"
6881                           "Number of decomposition levels <= 5\n"
6882                           "-> Number of decomposition levels forced to 5 (rather than %d)\n",
6883                           parameters->numresolution + 1);
6884             parameters->numresolution = 6;
6885         }
6886         break;
6887     case OPJ_PROFILE_CINEMA_4K:
6888         if (parameters->numresolution < 2) {
6889             opj_event_msg(p_manager, EVT_WARNING,
6890                           "JPEG 2000 Profile-4 (4k dc profile) requires:\n"
6891                           "Number of decomposition levels >= 1 && <= 6\n"
6892                           "-> Number of decomposition levels forced to 1 (rather than %d)\n",
6893                           parameters->numresolution + 1);
6894             parameters->numresolution = 1;
6895         } else if (parameters->numresolution > 7) {
6896             opj_event_msg(p_manager, EVT_WARNING,
6897                           "JPEG 2000 Profile-4 (4k dc profile) requires:\n"
6898                           "Number of decomposition levels >= 1 && <= 6\n"
6899                           "-> Number of decomposition levels forced to 6 (rather than %d)\n",
6900                           parameters->numresolution + 1);
6901             parameters->numresolution = 7;
6902         }
6903         break;
6904     default :
6905         break;
6906     }
6907
6908     /* Precincts */
6909     parameters->csty |= J2K_CP_CSTY_PRT;
6910     if (parameters->numresolution == 1) {
6911         parameters->res_spec = 1;
6912         parameters->prcw_init[0] = 128;
6913         parameters->prch_init[0] = 128;
6914     } else {
6915         parameters->res_spec = parameters->numresolution - 1;
6916         for (i = 0; i < parameters->res_spec; i++) {
6917             parameters->prcw_init[i] = 256;
6918             parameters->prch_init[i] = 256;
6919         }
6920     }
6921
6922     /* The progression order shall be CPRL */
6923     parameters->prog_order = OPJ_CPRL;
6924
6925     /* Progression order changes for 4K, disallowed for 2K */
6926     if (parameters->rsiz == OPJ_PROFILE_CINEMA_4K) {
6927         parameters->numpocs = (OPJ_UINT32)opj_j2k_initialise_4K_poc(parameters->POC,
6928                               parameters->numresolution);
6929     } else {
6930         parameters->numpocs = 0;
6931     }
6932
6933     /* Limited bit-rate */
6934     parameters->cp_disto_alloc = 1;
6935     if (parameters->max_cs_size <= 0) {
6936         /* No rate has been introduced, 24 fps is assumed */
6937         parameters->max_cs_size = OPJ_CINEMA_24_CS;
6938         opj_event_msg(p_manager, EVT_WARNING,
6939                       "JPEG 2000 Profile-3 and 4 (2k/4k dc profile) requires:\n"
6940                       "Maximum 1302083 compressed bytes @ 24fps\n"
6941                       "As no rate has been given, this limit will be used.\n");
6942     } else if (parameters->max_cs_size > OPJ_CINEMA_24_CS) {
6943         opj_event_msg(p_manager, EVT_WARNING,
6944                       "JPEG 2000 Profile-3 and 4 (2k/4k dc profile) requires:\n"
6945                       "Maximum 1302083 compressed bytes @ 24fps\n"
6946                       "-> Specified rate exceeds this limit. Rate will be forced to 1302083 bytes.\n");
6947         parameters->max_cs_size = OPJ_CINEMA_24_CS;
6948     }
6949
6950     if (parameters->max_comp_size <= 0) {
6951         /* No rate has been introduced, 24 fps is assumed */
6952         parameters->max_comp_size = OPJ_CINEMA_24_COMP;
6953         opj_event_msg(p_manager, EVT_WARNING,
6954                       "JPEG 2000 Profile-3 and 4 (2k/4k dc profile) requires:\n"
6955                       "Maximum 1041666 compressed bytes @ 24fps\n"
6956                       "As no rate has been given, this limit will be used.\n");
6957     } else if (parameters->max_comp_size > OPJ_CINEMA_24_COMP) {
6958         opj_event_msg(p_manager, EVT_WARNING,
6959                       "JPEG 2000 Profile-3 and 4 (2k/4k dc profile) requires:\n"
6960                       "Maximum 1041666 compressed bytes @ 24fps\n"
6961                       "-> Specified rate exceeds this limit. Rate will be forced to 1041666 bytes.\n");
6962         parameters->max_comp_size = OPJ_CINEMA_24_COMP;
6963     }
6964
6965     parameters->tcp_rates[0] = (OPJ_FLOAT32)(image->numcomps * image->comps[0].w *
6966                                image->comps[0].h * image->comps[0].prec) /
6967                                (OPJ_FLOAT32)(((OPJ_UINT32)parameters->max_cs_size) * 8 * image->comps[0].dx *
6968                                        image->comps[0].dy);
6969
6970 }
6971
6972 static OPJ_BOOL opj_j2k_is_cinema_compliant(opj_image_t *image, OPJ_UINT16 rsiz,
6973         opj_event_mgr_t *p_manager)
6974 {
6975     OPJ_UINT32 i;
6976
6977     /* Number of components */
6978     if (image->numcomps != 3) {
6979         opj_event_msg(p_manager, EVT_WARNING,
6980                       "JPEG 2000 Profile-3 (2k dc profile) requires:\n"
6981                       "3 components"
6982                       "-> Number of components of input image (%d) is not compliant\n"
6983                       "-> Non-profile-3 codestream will be generated\n",
6984                       image->numcomps);
6985         return OPJ_FALSE;
6986     }
6987
6988     /* Bitdepth */
6989     for (i = 0; i < image->numcomps; i++) {
6990         if ((image->comps[i].prec != 12) | (image->comps[i].sgnd)) {
6991             char signed_str[] = "signed";
6992             char unsigned_str[] = "unsigned";
6993             char *tmp_str = image->comps[i].sgnd ? signed_str : unsigned_str;
6994             opj_event_msg(p_manager, EVT_WARNING,
6995                           "JPEG 2000 Profile-3 (2k dc profile) requires:\n"
6996                           "Precision of each component shall be 12 bits unsigned"
6997                           "-> At least component %d of input image (%d bits, %s) is not compliant\n"
6998                           "-> Non-profile-3 codestream will be generated\n",
6999                           i, image->comps[i].prec, tmp_str);
7000             return OPJ_FALSE;
7001         }
7002     }
7003
7004     /* Image size */
7005     switch (rsiz) {
7006     case OPJ_PROFILE_CINEMA_2K:
7007         if (((image->comps[0].w > 2048) | (image->comps[0].h > 1080))) {
7008             opj_event_msg(p_manager, EVT_WARNING,
7009                           "JPEG 2000 Profile-3 (2k dc profile) requires:\n"
7010                           "width <= 2048 and height <= 1080\n"
7011                           "-> Input image size %d x %d is not compliant\n"
7012                           "-> Non-profile-3 codestream will be generated\n",
7013                           image->comps[0].w, image->comps[0].h);
7014             return OPJ_FALSE;
7015         }
7016         break;
7017     case OPJ_PROFILE_CINEMA_4K:
7018         if (((image->comps[0].w > 4096) | (image->comps[0].h > 2160))) {
7019             opj_event_msg(p_manager, EVT_WARNING,
7020                           "JPEG 2000 Profile-4 (4k dc profile) requires:\n"
7021                           "width <= 4096 and height <= 2160\n"
7022                           "-> Image size %d x %d is not compliant\n"
7023                           "-> Non-profile-4 codestream will be generated\n",
7024                           image->comps[0].w, image->comps[0].h);
7025             return OPJ_FALSE;
7026         }
7027         break;
7028     default :
7029         break;
7030     }
7031
7032     return OPJ_TRUE;
7033 }
7034
7035 static int opj_j2k_get_imf_max_NL(opj_cparameters_t *parameters,
7036                                   opj_image_t *image)
7037 {
7038     /* Decomposition levels */
7039     const OPJ_UINT16 rsiz = parameters->rsiz;
7040     const OPJ_UINT16 profile = OPJ_GET_IMF_PROFILE(rsiz);
7041     const OPJ_UINT32 XTsiz = parameters->tile_size_on ? (OPJ_UINT32)
7042                              parameters->cp_tdx : image->x1;
7043     switch (profile) {
7044     case OPJ_PROFILE_IMF_2K:
7045         return 5;
7046     case OPJ_PROFILE_IMF_4K:
7047         return 6;
7048     case OPJ_PROFILE_IMF_8K:
7049         return 7;
7050     case OPJ_PROFILE_IMF_2K_R: {
7051         if (XTsiz >= 2048) {
7052             return 5;
7053         } else if (XTsiz >= 1024) {
7054             return 4;
7055         }
7056         break;
7057     }
7058     case OPJ_PROFILE_IMF_4K_R: {
7059         if (XTsiz >= 4096) {
7060             return 6;
7061         } else if (XTsiz >= 2048) {
7062             return 5;
7063         } else if (XTsiz >= 1024) {
7064             return 4;
7065         }
7066         break;
7067     }
7068     case OPJ_PROFILE_IMF_8K_R: {
7069         if (XTsiz >= 8192) {
7070             return 7;
7071         } else if (XTsiz >= 4096) {
7072             return 6;
7073         } else if (XTsiz >= 2048) {
7074             return 5;
7075         } else if (XTsiz >= 1024) {
7076             return 4;
7077         }
7078         break;
7079     }
7080     default:
7081         break;
7082     }
7083     return -1;
7084 }
7085
7086 static void opj_j2k_set_imf_parameters(opj_cparameters_t *parameters,
7087                                        opj_image_t *image, opj_event_mgr_t *p_manager)
7088 {
7089     const OPJ_UINT16 rsiz = parameters->rsiz;
7090     const OPJ_UINT16 profile = OPJ_GET_IMF_PROFILE(rsiz);
7091
7092     OPJ_UNUSED(p_manager);
7093
7094     /* Override defaults set by opj_set_default_encoder_parameters */
7095     if (parameters->cblockw_init == OPJ_COMP_PARAM_DEFAULT_CBLOCKW &&
7096             parameters->cblockh_init == OPJ_COMP_PARAM_DEFAULT_CBLOCKH) {
7097         parameters->cblockw_init = 32;
7098         parameters->cblockh_init = 32;
7099     }
7100
7101     /* One tile part for each component */
7102     parameters->tp_flag = 'C';
7103     parameters->tp_on = 1;
7104
7105     if (parameters->prog_order == OPJ_COMP_PARAM_DEFAULT_PROG_ORDER) {
7106         parameters->prog_order = OPJ_CPRL;
7107     }
7108
7109     if (profile == OPJ_PROFILE_IMF_2K ||
7110             profile == OPJ_PROFILE_IMF_4K ||
7111             profile == OPJ_PROFILE_IMF_8K) {
7112         /* 9-7 transform */
7113         parameters->irreversible = 1;
7114     }
7115
7116     /* Adjust the number of resolutions if set to its defaults */
7117     if (parameters->numresolution == OPJ_COMP_PARAM_DEFAULT_NUMRESOLUTION &&
7118             image->x0 == 0 &&
7119             image->y0 == 0) {
7120         const int max_NL = opj_j2k_get_imf_max_NL(parameters, image);
7121         if (max_NL >= 0 && parameters->numresolution > max_NL) {
7122             parameters->numresolution = max_NL + 1;
7123         }
7124
7125         /* Note: below is generic logic */
7126         if (!parameters->tile_size_on) {
7127             while (parameters->numresolution > 0) {
7128                 if (image->x1 < (1U << ((OPJ_UINT32)parameters->numresolution - 1U))) {
7129                     parameters->numresolution --;
7130                     continue;
7131                 }
7132                 if (image->y1 < (1U << ((OPJ_UINT32)parameters->numresolution - 1U))) {
7133                     parameters->numresolution --;
7134                     continue;
7135                 }
7136                 break;
7137             }
7138         }
7139     }
7140
7141     /* Set defaults precincts */
7142     if (parameters->csty == 0) {
7143         parameters->csty |= J2K_CP_CSTY_PRT;
7144         if (parameters->numresolution == 1) {
7145             parameters->res_spec = 1;
7146             parameters->prcw_init[0] = 128;
7147             parameters->prch_init[0] = 128;
7148         } else {
7149             int i;
7150             parameters->res_spec = parameters->numresolution - 1;
7151             for (i = 0; i < parameters->res_spec; i++) {
7152                 parameters->prcw_init[i] = 256;
7153                 parameters->prch_init[i] = 256;
7154             }
7155         }
7156     }
7157 }
7158
7159 /* Table A.53 from JPEG2000 standard */
7160 static const OPJ_UINT16 tabMaxSubLevelFromMainLevel[] = {
7161     15, /* unspecified */
7162     1,
7163     1,
7164     1,
7165     2,
7166     3,
7167     4,
7168     5,
7169     6,
7170     7,
7171     8,
7172     9
7173 };
7174
7175 static OPJ_BOOL opj_j2k_is_imf_compliant(opj_cparameters_t *parameters,
7176         opj_image_t *image,
7177         opj_event_mgr_t *p_manager)
7178 {
7179     OPJ_UINT32 i;
7180     const OPJ_UINT16 rsiz = parameters->rsiz;
7181     const OPJ_UINT16 profile = OPJ_GET_IMF_PROFILE(rsiz);
7182     const OPJ_UINT16 mainlevel = OPJ_GET_IMF_MAINLEVEL(rsiz);
7183     const OPJ_UINT16 sublevel = OPJ_GET_IMF_SUBLEVEL(rsiz);
7184     const int NL = parameters->numresolution - 1;
7185     const OPJ_UINT32 XTsiz = parameters->tile_size_on ? (OPJ_UINT32)
7186                              parameters->cp_tdx : image->x1;
7187     OPJ_BOOL ret = OPJ_TRUE;
7188
7189     /* Validate mainlevel */
7190     if (mainlevel > OPJ_IMF_MAINLEVEL_MAX) {
7191         opj_event_msg(p_manager, EVT_WARNING,
7192                       "IMF profile require mainlevel <= 11.\n"
7193                       "-> %d is thus not compliant\n"
7194                       "-> Non-IMF codestream will be generated\n",
7195                       mainlevel);
7196         ret = OPJ_FALSE;
7197     } else {
7198         /* Validate sublevel */
7199         assert(sizeof(tabMaxSubLevelFromMainLevel) ==
7200                (OPJ_IMF_MAINLEVEL_MAX + 1) * sizeof(tabMaxSubLevelFromMainLevel[0]));
7201         if (sublevel > tabMaxSubLevelFromMainLevel[mainlevel]) {
7202             opj_event_msg(p_manager, EVT_WARNING,
7203                           "IMF profile require sublevel <= %d for mainlevel = %d.\n"
7204                           "-> %d is thus not compliant\n"
7205                           "-> Non-IMF codestream will be generated\n",
7206                           tabMaxSubLevelFromMainLevel[mainlevel],
7207                           mainlevel,
7208                           sublevel);
7209             ret = OPJ_FALSE;
7210         }
7211     }
7212
7213     /* Number of components */
7214     if (image->numcomps > 3) {
7215         opj_event_msg(p_manager, EVT_WARNING,
7216                       "IMF profiles require at most 3 components.\n"
7217                       "-> Number of components of input image (%d) is not compliant\n"
7218                       "-> Non-IMF codestream will be generated\n",
7219                       image->numcomps);
7220         ret = OPJ_FALSE;
7221     }
7222
7223     if (image->x0 != 0 || image->y0 != 0) {
7224         opj_event_msg(p_manager, EVT_WARNING,
7225                       "IMF profiles require image origin to be at 0,0.\n"
7226                       "-> %d,%d is not compliant\n"
7227                       "-> Non-IMF codestream will be generated\n",
7228                       image->x0, image->y0 != 0);
7229         ret = OPJ_FALSE;
7230     }
7231
7232     if (parameters->cp_tx0 != 0 || parameters->cp_ty0 != 0) {
7233         opj_event_msg(p_manager, EVT_WARNING,
7234                       "IMF profiles require tile origin to be at 0,0.\n"
7235                       "-> %d,%d is not compliant\n"
7236                       "-> Non-IMF codestream will be generated\n",
7237                       parameters->cp_tx0, parameters->cp_ty0);
7238         ret = OPJ_FALSE;
7239     }
7240
7241     if (parameters->tile_size_on) {
7242         if (profile == OPJ_PROFILE_IMF_2K ||
7243                 profile == OPJ_PROFILE_IMF_4K ||
7244                 profile == OPJ_PROFILE_IMF_8K) {
7245             if ((OPJ_UINT32)parameters->cp_tdx < image->x1 ||
7246                     (OPJ_UINT32)parameters->cp_tdy < image->y1) {
7247                 opj_event_msg(p_manager, EVT_WARNING,
7248                               "IMF 2K/4K/8K single tile profiles require tile to be greater or equal to image size.\n"
7249                               "-> %d,%d is lesser than %d,%d\n"
7250                               "-> Non-IMF codestream will be generated\n",
7251                               parameters->cp_tdx,
7252                               parameters->cp_tdy,
7253                               image->x1,
7254                               image->y1);
7255                 ret = OPJ_FALSE;
7256             }
7257         } else {
7258             if ((OPJ_UINT32)parameters->cp_tdx >= image->x1 &&
7259                     (OPJ_UINT32)parameters->cp_tdy >= image->y1) {
7260                 /* ok */
7261             } else if (parameters->cp_tdx == 1024 &&
7262                        parameters->cp_tdy == 1024) {
7263                 /* ok */
7264             } else if (parameters->cp_tdx == 2048 &&
7265                        parameters->cp_tdy == 2048 &&
7266                        (profile == OPJ_PROFILE_IMF_4K ||
7267                         profile == OPJ_PROFILE_IMF_8K)) {
7268                 /* ok */
7269             } else if (parameters->cp_tdx == 4096 &&
7270                        parameters->cp_tdy == 4096 &&
7271                        profile == OPJ_PROFILE_IMF_8K) {
7272                 /* ok */
7273             } else {
7274                 opj_event_msg(p_manager, EVT_WARNING,
7275                               "IMF 2K_R/4K_R/8K_R single/multiple tile profiles "
7276                               "require tile to be greater or equal to image size,\n"
7277                               "or to be (1024,1024), or (2048,2048) for 4K_R/8K_R "
7278                               "or (4096,4096) for 8K_R.\n"
7279                               "-> %d,%d is non conformant\n"
7280                               "-> Non-IMF codestream will be generated\n",
7281                               parameters->cp_tdx,
7282                               parameters->cp_tdy);
7283                 ret = OPJ_FALSE;
7284             }
7285         }
7286     }
7287
7288     /* Bitdepth */
7289     for (i = 0; i < image->numcomps; i++) {
7290         if (!(image->comps[i].prec >= 8 && image->comps[i].prec <= 16) ||
7291                 (image->comps[i].sgnd)) {
7292             char signed_str[] = "signed";
7293             char unsigned_str[] = "unsigned";
7294             char *tmp_str = image->comps[i].sgnd ? signed_str : unsigned_str;
7295             opj_event_msg(p_manager, EVT_WARNING,
7296                           "IMF profiles require precision of each component to b in [8-16] bits unsigned"
7297                           "-> At least component %d of input image (%d bits, %s) is not compliant\n"
7298                           "-> Non-IMF codestream will be generated\n",
7299                           i, image->comps[i].prec, tmp_str);
7300             ret = OPJ_FALSE;
7301         }
7302     }
7303
7304     /* Sub-sampling */
7305     for (i = 0; i < image->numcomps; i++) {
7306         if (i == 0 && image->comps[i].dx != 1) {
7307             opj_event_msg(p_manager, EVT_WARNING,
7308                           "IMF profiles require XRSiz1 == 1. Here it is set to %d.\n"
7309                           "-> Non-IMF codestream will be generated\n",
7310                           image->comps[i].dx);
7311             ret = OPJ_FALSE;
7312         }
7313         if (i == 1 && image->comps[i].dx != 1 && image->comps[i].dx != 2) {
7314             opj_event_msg(p_manager, EVT_WARNING,
7315                           "IMF profiles require XRSiz2 == 1 or 2. Here it is set to %d.\n"
7316                           "-> Non-IMF codestream will be generated\n",
7317                           image->comps[i].dx);
7318             ret = OPJ_FALSE;
7319         }
7320         if (i > 1 && image->comps[i].dx != image->comps[i - 1].dx) {
7321             opj_event_msg(p_manager, EVT_WARNING,
7322                           "IMF profiles require XRSiz%d to be the same as XRSiz2. "
7323                           "Here it is set to %d instead of %d.\n"
7324                           "-> Non-IMF codestream will be generated\n",
7325                           i + 1, image->comps[i].dx, image->comps[i - 1].dx);
7326             ret = OPJ_FALSE;
7327         }
7328         if (image->comps[i].dy != 1) {
7329             opj_event_msg(p_manager, EVT_WARNING,
7330                           "IMF profiles require YRsiz == 1. "
7331                           "Here it is set to %d for component %d.\n"
7332                           "-> Non-IMF codestream will be generated\n",
7333                           image->comps[i].dy, i);
7334             ret = OPJ_FALSE;
7335         }
7336     }
7337
7338     /* Image size */
7339     switch (profile) {
7340     case OPJ_PROFILE_IMF_2K:
7341     case OPJ_PROFILE_IMF_2K_R:
7342         if (((image->comps[0].w > 2048) | (image->comps[0].h > 1556))) {
7343             opj_event_msg(p_manager, EVT_WARNING,
7344                           "IMF 2K/2K_R profile require:\n"
7345                           "width <= 2048 and height <= 1556\n"
7346                           "-> Input image size %d x %d is not compliant\n"
7347                           "-> Non-IMF codestream will be generated\n",
7348                           image->comps[0].w, image->comps[0].h);
7349             ret = OPJ_FALSE;
7350         }
7351         break;
7352     case OPJ_PROFILE_IMF_4K:
7353     case OPJ_PROFILE_IMF_4K_R:
7354         if (((image->comps[0].w > 4096) | (image->comps[0].h > 3112))) {
7355             opj_event_msg(p_manager, EVT_WARNING,
7356                           "IMF 4K/4K_R profile require:\n"
7357                           "width <= 4096 and height <= 3112\n"
7358                           "-> Input image size %d x %d is not compliant\n"
7359                           "-> Non-IMF codestream will be generated\n",
7360                           image->comps[0].w, image->comps[0].h);
7361             ret = OPJ_FALSE;
7362         }
7363         break;
7364     case OPJ_PROFILE_IMF_8K:
7365     case OPJ_PROFILE_IMF_8K_R:
7366         if (((image->comps[0].w > 8192) | (image->comps[0].h > 6224))) {
7367             opj_event_msg(p_manager, EVT_WARNING,
7368                           "IMF 8K/8K_R profile require:\n"
7369                           "width <= 8192 and height <= 6224\n"
7370                           "-> Input image size %d x %d is not compliant\n"
7371                           "-> Non-IMF codestream will be generated\n",
7372                           image->comps[0].w, image->comps[0].h);
7373             ret = OPJ_FALSE;
7374         }
7375         break;
7376     default :
7377         assert(0);
7378         return OPJ_FALSE;
7379     }
7380
7381     if (parameters->roi_compno != -1) {
7382         opj_event_msg(p_manager, EVT_WARNING,
7383                       "IMF profile forbid RGN / region of interest marker.\n"
7384                       "-> Compression parameters specify a ROI\n"
7385                       "-> Non-IMF codestream will be generated\n");
7386         ret = OPJ_FALSE;
7387     }
7388
7389     if (parameters->cblockw_init != 32 || parameters->cblockh_init != 32) {
7390         opj_event_msg(p_manager, EVT_WARNING,
7391                       "IMF profile require code block size to be 32x32.\n"
7392                       "-> Compression parameters set it to %dx%d.\n"
7393                       "-> Non-IMF codestream will be generated\n",
7394                       parameters->cblockw_init,
7395                       parameters->cblockh_init);
7396         ret = OPJ_FALSE;
7397     }
7398
7399     if (parameters->prog_order != OPJ_CPRL) {
7400         opj_event_msg(p_manager, EVT_WARNING,
7401                       "IMF profile require progression order to be CPRL.\n"
7402                       "-> Compression parameters set it to %d.\n"
7403                       "-> Non-IMF codestream will be generated\n",
7404                       parameters->prog_order);
7405         ret = OPJ_FALSE;
7406     }
7407
7408     if (parameters->numpocs != 0) {
7409         opj_event_msg(p_manager, EVT_WARNING,
7410                       "IMF profile forbid POC markers.\n"
7411                       "-> Compression parameters set %d POC.\n"
7412                       "-> Non-IMF codestream will be generated\n",
7413                       parameters->numpocs);
7414         ret = OPJ_FALSE;
7415     }
7416
7417     /* Codeblock style: no mode switch enabled */
7418     if (parameters->mode != 0) {
7419         opj_event_msg(p_manager, EVT_WARNING,
7420                       "IMF profile forbid mode switch in code block style.\n"
7421                       "-> Compression parameters set code block style to %d.\n"
7422                       "-> Non-IMF codestream will be generated\n",
7423                       parameters->mode);
7424         ret = OPJ_FALSE;
7425     }
7426
7427     if (profile == OPJ_PROFILE_IMF_2K ||
7428             profile == OPJ_PROFILE_IMF_4K ||
7429             profile == OPJ_PROFILE_IMF_8K) {
7430         /* Expect 9-7 transform */
7431         if (parameters->irreversible != 1) {
7432             opj_event_msg(p_manager, EVT_WARNING,
7433                           "IMF 2K/4K/8K profiles require 9-7 Irreversible Transform.\n"
7434                           "-> Compression parameters set it to reversible.\n"
7435                           "-> Non-IMF codestream will be generated\n");
7436             ret = OPJ_FALSE;
7437         }
7438     } else {
7439         /* Expect 5-3 transform */
7440         if (parameters->irreversible != 0) {
7441             opj_event_msg(p_manager, EVT_WARNING,
7442                           "IMF 2K/4K/8K profiles require 5-3 reversible Transform.\n"
7443                           "-> Compression parameters set it to irreversible.\n"
7444                           "-> Non-IMF codestream will be generated\n");
7445             ret = OPJ_FALSE;
7446         }
7447     }
7448
7449     /* Number of layers */
7450     if (parameters->tcp_numlayers != 1) {
7451         opj_event_msg(p_manager, EVT_WARNING,
7452                       "IMF 2K/4K/8K profiles require 1 single quality layer.\n"
7453                       "-> Number of layers is %d.\n"
7454                       "-> Non-IMF codestream will be generated\n",
7455                       parameters->tcp_numlayers);
7456         ret = OPJ_FALSE;
7457     }
7458
7459     /* Decomposition levels */
7460     switch (profile) {
7461     case OPJ_PROFILE_IMF_2K:
7462         if (!(NL >= 1 && NL <= 5)) {
7463             opj_event_msg(p_manager, EVT_WARNING,
7464                           "IMF 2K profile requires 1 <= NL <= 5:\n"
7465                           "-> Number of decomposition levels is %d.\n"
7466                           "-> Non-IMF codestream will be generated\n",
7467                           NL);
7468             ret = OPJ_FALSE;
7469         }
7470         break;
7471     case OPJ_PROFILE_IMF_4K:
7472         if (!(NL >= 1 && NL <= 6)) {
7473             opj_event_msg(p_manager, EVT_WARNING,
7474                           "IMF 4K profile requires 1 <= NL <= 6:\n"
7475                           "-> Number of decomposition levels is %d.\n"
7476                           "-> Non-IMF codestream will be generated\n",
7477                           NL);
7478             ret = OPJ_FALSE;
7479         }
7480         break;
7481     case OPJ_PROFILE_IMF_8K:
7482         if (!(NL >= 1 && NL <= 7)) {
7483             opj_event_msg(p_manager, EVT_WARNING,
7484                           "IMF 8K profile requires 1 <= NL <= 7:\n"
7485                           "-> Number of decomposition levels is %d.\n"
7486                           "-> Non-IMF codestream will be generated\n",
7487                           NL);
7488             ret = OPJ_FALSE;
7489         }
7490         break;
7491     case OPJ_PROFILE_IMF_2K_R: {
7492         if (XTsiz >= 2048) {
7493             if (!(NL >= 1 && NL <= 5)) {
7494                 opj_event_msg(p_manager, EVT_WARNING,
7495                               "IMF 2K_R profile requires 1 <= NL <= 5 for XTsiz >= 2048:\n"
7496                               "-> Number of decomposition levels is %d.\n"
7497                               "-> Non-IMF codestream will be generated\n",
7498                               NL);
7499                 ret = OPJ_FALSE;
7500             }
7501         } else if (XTsiz >= 1024) {
7502             if (!(NL >= 1 && NL <= 4)) {
7503                 opj_event_msg(p_manager, EVT_WARNING,
7504                               "IMF 2K_R profile requires 1 <= NL <= 4 for XTsiz in [1024,2048[:\n"
7505                               "-> Number of decomposition levels is %d.\n"
7506                               "-> Non-IMF codestream will be generated\n",
7507                               NL);
7508                 ret = OPJ_FALSE;
7509             }
7510         }
7511         break;
7512     }
7513     case OPJ_PROFILE_IMF_4K_R: {
7514         if (XTsiz >= 4096) {
7515             if (!(NL >= 1 && NL <= 6)) {
7516                 opj_event_msg(p_manager, EVT_WARNING,
7517                               "IMF 4K_R profile requires 1 <= NL <= 6 for XTsiz >= 4096:\n"
7518                               "-> Number of decomposition levels is %d.\n"
7519                               "-> Non-IMF codestream will be generated\n",
7520                               NL);
7521                 ret = OPJ_FALSE;
7522             }
7523         } else if (XTsiz >= 2048) {
7524             if (!(NL >= 1 && NL <= 5)) {
7525                 opj_event_msg(p_manager, EVT_WARNING,
7526                               "IMF 4K_R profile requires 1 <= NL <= 5 for XTsiz in [2048,4096[:\n"
7527                               "-> Number of decomposition levels is %d.\n"
7528                               "-> Non-IMF codestream will be generated\n",
7529                               NL);
7530                 ret = OPJ_FALSE;
7531             }
7532         } else if (XTsiz >= 1024) {
7533             if (!(NL >= 1 && NL <= 4)) {
7534                 opj_event_msg(p_manager, EVT_WARNING,
7535                               "IMF 4K_R profile requires 1 <= NL <= 4 for XTsiz in [1024,2048[:\n"
7536                               "-> Number of decomposition levels is %d.\n"
7537                               "-> Non-IMF codestream will be generated\n",
7538                               NL);
7539                 ret = OPJ_FALSE;
7540             }
7541         }
7542         break;
7543     }
7544     case OPJ_PROFILE_IMF_8K_R: {
7545         if (XTsiz >= 8192) {
7546             if (!(NL >= 1 && NL <= 7)) {
7547                 opj_event_msg(p_manager, EVT_WARNING,
7548                               "IMF 4K_R profile requires 1 <= NL <= 7 for XTsiz >= 8192:\n"
7549                               "-> Number of decomposition levels is %d.\n"
7550                               "-> Non-IMF codestream will be generated\n",
7551                               NL);
7552                 ret = OPJ_FALSE;
7553             }
7554         } else if (XTsiz >= 4096) {
7555             if (!(NL >= 1 && NL <= 6)) {
7556                 opj_event_msg(p_manager, EVT_WARNING,
7557                               "IMF 4K_R profile requires 1 <= NL <= 6 for XTsiz in [4096,8192[:\n"
7558                               "-> Number of decomposition levels is %d.\n"
7559                               "-> Non-IMF codestream will be generated\n",
7560                               NL);
7561                 ret = OPJ_FALSE;
7562             }
7563         } else if (XTsiz >= 2048) {
7564             if (!(NL >= 1 && NL <= 5)) {
7565                 opj_event_msg(p_manager, EVT_WARNING,
7566                               "IMF 4K_R profile requires 1 <= NL <= 5 for XTsiz in [2048,4096[:\n"
7567                               "-> Number of decomposition levels is %d.\n"
7568                               "-> Non-IMF codestream will be generated\n",
7569                               NL);
7570                 ret = OPJ_FALSE;
7571             }
7572         } else if (XTsiz >= 1024) {
7573             if (!(NL >= 1 && NL <= 4)) {
7574                 opj_event_msg(p_manager, EVT_WARNING,
7575                               "IMF 4K_R profile requires 1 <= NL <= 4 for XTsiz in [1024,2048[:\n"
7576                               "-> Number of decomposition levels is %d.\n"
7577                               "-> Non-IMF codestream will be generated\n",
7578                               NL);
7579                 ret = OPJ_FALSE;
7580             }
7581         }
7582         break;
7583     }
7584     default:
7585         break;
7586     }
7587
7588     if (parameters->numresolution == 1) {
7589         if (parameters->res_spec != 1 ||
7590                 parameters->prcw_init[0] != 128 ||
7591                 parameters->prch_init[0] != 128) {
7592             opj_event_msg(p_manager, EVT_WARNING,
7593                           "IMF profiles require PPx = PPy = 7 for NLLL band, else 8.\n"
7594                           "-> Supplied values are different from that.\n"
7595                           "-> Non-IMF codestream will be generated\n");
7596             ret = OPJ_FALSE;
7597         }
7598     } else {
7599         int i;
7600         for (i = 0; i < parameters->res_spec; i++) {
7601             if (parameters->prcw_init[i] != 256 ||
7602                     parameters->prch_init[i] != 256) {
7603                 opj_event_msg(p_manager, EVT_WARNING,
7604                               "IMF profiles require PPx = PPy = 7 for NLLL band, else 8.\n"
7605                               "-> Supplied values are different from that.\n"
7606                               "-> Non-IMF codestream will be generated\n");
7607                 ret = OPJ_FALSE;
7608             }
7609         }
7610     }
7611
7612     return ret;
7613 }
7614
7615
7616 OPJ_BOOL opj_j2k_setup_encoder(opj_j2k_t *p_j2k,
7617                                opj_cparameters_t *parameters,
7618                                opj_image_t *image,
7619                                opj_event_mgr_t * p_manager)
7620 {
7621     OPJ_UINT32 i, j, tileno, numpocs_tile;
7622     opj_cp_t *cp = 00;
7623     OPJ_UINT32 cblkw, cblkh;
7624
7625     if (!p_j2k || !parameters || ! image) {
7626         return OPJ_FALSE;
7627     }
7628
7629     if ((parameters->numresolution <= 0) ||
7630             (parameters->numresolution > OPJ_J2K_MAXRLVLS)) {
7631         opj_event_msg(p_manager, EVT_ERROR,
7632                       "Invalid number of resolutions : %d not in range [1,%d]\n",
7633                       parameters->numresolution, OPJ_J2K_MAXRLVLS);
7634         return OPJ_FALSE;
7635     }
7636
7637     if (parameters->cblockw_init < 4 || parameters->cblockw_init > 1024) {
7638         opj_event_msg(p_manager, EVT_ERROR,
7639                       "Invalid value for cblockw_init: %d not a power of 2 in range [4,1024]\n",
7640                       parameters->cblockw_init);
7641         return OPJ_FALSE;
7642     }
7643     if (parameters->cblockh_init < 4 || parameters->cblockh_init > 1024) {
7644         opj_event_msg(p_manager, EVT_ERROR,
7645                       "Invalid value for cblockh_init: %d not a power of 2 not in range [4,1024]\n",
7646                       parameters->cblockh_init);
7647         return OPJ_FALSE;
7648     }
7649     if (parameters->cblockw_init * parameters->cblockh_init > 4096) {
7650         opj_event_msg(p_manager, EVT_ERROR,
7651                       "Invalid value for cblockw_init * cblockh_init: should be <= 4096\n");
7652         return OPJ_FALSE;
7653     }
7654     cblkw = (OPJ_UINT32)opj_int_floorlog2(parameters->cblockw_init);
7655     cblkh = (OPJ_UINT32)opj_int_floorlog2(parameters->cblockh_init);
7656     if (parameters->cblockw_init != (1 << cblkw)) {
7657         opj_event_msg(p_manager, EVT_ERROR,
7658                       "Invalid value for cblockw_init: %d not a power of 2 in range [4,1024]\n",
7659                       parameters->cblockw_init);
7660         return OPJ_FALSE;
7661     }
7662     if (parameters->cblockh_init != (1 << cblkh)) {
7663         opj_event_msg(p_manager, EVT_ERROR,
7664                       "Invalid value for cblockw_init: %d not a power of 2 in range [4,1024]\n",
7665                       parameters->cblockh_init);
7666         return OPJ_FALSE;
7667     }
7668
7669     if (parameters->cp_fixed_alloc) {
7670         if (parameters->cp_matrice == NULL) {
7671             opj_event_msg(p_manager, EVT_ERROR,
7672                           "cp_fixed_alloc set, but cp_matrice missing\n");
7673             return OPJ_FALSE;
7674         }
7675
7676         if (parameters->tcp_numlayers > J2K_TCD_MATRIX_MAX_LAYER_COUNT) {
7677             opj_event_msg(p_manager, EVT_ERROR,
7678                           "tcp_numlayers when cp_fixed_alloc set should not exceed %d\n",
7679                           J2K_TCD_MATRIX_MAX_LAYER_COUNT);
7680             return OPJ_FALSE;
7681         }
7682         if (parameters->numresolution > J2K_TCD_MATRIX_MAX_RESOLUTION_COUNT) {
7683             opj_event_msg(p_manager, EVT_ERROR,
7684                           "numresolution when cp_fixed_alloc set should not exceed %d\n",
7685                           J2K_TCD_MATRIX_MAX_RESOLUTION_COUNT);
7686             return OPJ_FALSE;
7687         }
7688     }
7689
7690     p_j2k->m_specific_param.m_encoder.m_nb_comps = image->numcomps;
7691
7692     /* keep a link to cp so that we can destroy it later in j2k_destroy_compress */
7693     cp = &(p_j2k->m_cp);
7694
7695     /* set default values for cp */
7696     cp->tw = 1;
7697     cp->th = 1;
7698
7699     /* FIXME ADE: to be removed once deprecated cp_cinema and cp_rsiz have been removed */
7700     if (parameters->rsiz ==
7701             OPJ_PROFILE_NONE) { /* consider deprecated fields only if RSIZ has not been set */
7702         OPJ_BOOL deprecated_used = OPJ_FALSE;
7703         switch (parameters->cp_cinema) {
7704         case OPJ_CINEMA2K_24:
7705             parameters->rsiz = OPJ_PROFILE_CINEMA_2K;
7706             parameters->max_cs_size = OPJ_CINEMA_24_CS;
7707             parameters->max_comp_size = OPJ_CINEMA_24_COMP;
7708             deprecated_used = OPJ_TRUE;
7709             break;
7710         case OPJ_CINEMA2K_48:
7711             parameters->rsiz = OPJ_PROFILE_CINEMA_2K;
7712             parameters->max_cs_size = OPJ_CINEMA_48_CS;
7713             parameters->max_comp_size = OPJ_CINEMA_48_COMP;
7714             deprecated_used = OPJ_TRUE;
7715             break;
7716         case OPJ_CINEMA4K_24:
7717             parameters->rsiz = OPJ_PROFILE_CINEMA_4K;
7718             parameters->max_cs_size = OPJ_CINEMA_24_CS;
7719             parameters->max_comp_size = OPJ_CINEMA_24_COMP;
7720             deprecated_used = OPJ_TRUE;
7721             break;
7722         case OPJ_OFF:
7723         default:
7724             break;
7725         }
7726         switch (parameters->cp_rsiz) {
7727         case OPJ_CINEMA2K:
7728             parameters->rsiz = OPJ_PROFILE_CINEMA_2K;
7729             deprecated_used = OPJ_TRUE;
7730             break;
7731         case OPJ_CINEMA4K:
7732             parameters->rsiz = OPJ_PROFILE_CINEMA_4K;
7733             deprecated_used = OPJ_TRUE;
7734             break;
7735         case OPJ_MCT:
7736             parameters->rsiz = OPJ_PROFILE_PART2 | OPJ_EXTENSION_MCT;
7737             deprecated_used = OPJ_TRUE;
7738         case OPJ_STD_RSIZ:
7739         default:
7740             break;
7741         }
7742         if (deprecated_used) {
7743             opj_event_msg(p_manager, EVT_WARNING,
7744                           "Deprecated fields cp_cinema or cp_rsiz are used\n"
7745                           "Please consider using only the rsiz field\n"
7746                           "See openjpeg.h documentation for more details\n");
7747         }
7748     }
7749
7750     /* If no explicit layers are provided, use lossless settings */
7751     if (parameters->tcp_numlayers == 0) {
7752         parameters->tcp_numlayers = 1;
7753         parameters->cp_disto_alloc = 1;
7754         parameters->tcp_rates[0] = 0;
7755     }
7756
7757     if (parameters->cp_disto_alloc) {
7758         /* Emit warnings if tcp_rates are not decreasing */
7759         for (i = 1; i < (OPJ_UINT32) parameters->tcp_numlayers; i++) {
7760             OPJ_FLOAT32 rate_i_corr = parameters->tcp_rates[i];
7761             OPJ_FLOAT32 rate_i_m_1_corr = parameters->tcp_rates[i - 1];
7762             if (rate_i_corr <= 1.0) {
7763                 rate_i_corr = 1.0;
7764             }
7765             if (rate_i_m_1_corr <= 1.0) {
7766                 rate_i_m_1_corr = 1.0;
7767             }
7768             if (rate_i_corr >= rate_i_m_1_corr) {
7769                 if (rate_i_corr != parameters->tcp_rates[i] &&
7770                         rate_i_m_1_corr != parameters->tcp_rates[i - 1]) {
7771                     opj_event_msg(p_manager, EVT_WARNING,
7772                                   "tcp_rates[%d]=%f (corrected as %f) should be strictly lesser "
7773                                   "than tcp_rates[%d]=%f (corrected as %f)\n",
7774                                   i, parameters->tcp_rates[i], rate_i_corr,
7775                                   i - 1, parameters->tcp_rates[i - 1], rate_i_m_1_corr);
7776                 } else if (rate_i_corr != parameters->tcp_rates[i]) {
7777                     opj_event_msg(p_manager, EVT_WARNING,
7778                                   "tcp_rates[%d]=%f (corrected as %f) should be strictly lesser "
7779                                   "than tcp_rates[%d]=%f\n",
7780                                   i, parameters->tcp_rates[i], rate_i_corr,
7781                                   i - 1, parameters->tcp_rates[i - 1]);
7782                 } else if (rate_i_m_1_corr != parameters->tcp_rates[i - 1]) {
7783                     opj_event_msg(p_manager, EVT_WARNING,
7784                                   "tcp_rates[%d]=%f should be strictly lesser "
7785                                   "than tcp_rates[%d]=%f (corrected as %f)\n",
7786                                   i, parameters->tcp_rates[i],
7787                                   i - 1, parameters->tcp_rates[i - 1], rate_i_m_1_corr);
7788                 } else {
7789                     opj_event_msg(p_manager, EVT_WARNING,
7790                                   "tcp_rates[%d]=%f should be strictly lesser "
7791                                   "than tcp_rates[%d]=%f\n",
7792                                   i, parameters->tcp_rates[i],
7793                                   i - 1, parameters->tcp_rates[i - 1]);
7794                 }
7795             }
7796         }
7797     } else if (parameters->cp_fixed_quality) {
7798         /* Emit warnings if tcp_distoratio are not increasing */
7799         for (i = 1; i < (OPJ_UINT32) parameters->tcp_numlayers; i++) {
7800             if (parameters->tcp_distoratio[i] < parameters->tcp_distoratio[i - 1] &&
7801                     !(i == (OPJ_UINT32)parameters->tcp_numlayers - 1 &&
7802                       parameters->tcp_distoratio[i] == 0)) {
7803                 opj_event_msg(p_manager, EVT_WARNING,
7804                               "tcp_distoratio[%d]=%f should be strictly greater "
7805                               "than tcp_distoratio[%d]=%f\n",
7806                               i, parameters->tcp_distoratio[i], i - 1,
7807                               parameters->tcp_distoratio[i - 1]);
7808             }
7809         }
7810     }
7811
7812     /* see if max_codestream_size does limit input rate */
7813     if (parameters->max_cs_size <= 0) {
7814         if (parameters->tcp_rates[parameters->tcp_numlayers - 1] > 0) {
7815             OPJ_FLOAT32 temp_size;
7816             temp_size = (OPJ_FLOAT32)(((double)image->numcomps * image->comps[0].w *
7817                                        image->comps[0].h * image->comps[0].prec) /
7818                                       ((double)parameters->tcp_rates[parameters->tcp_numlayers - 1] * 8 *
7819                                        image->comps[0].dx * image->comps[0].dy));
7820             if (temp_size > INT_MAX) {
7821                 parameters->max_cs_size = INT_MAX;
7822             } else {
7823                 parameters->max_cs_size = (int) floor(temp_size);
7824             }
7825         } else {
7826             parameters->max_cs_size = 0;
7827         }
7828     } else {
7829         OPJ_FLOAT32 temp_rate;
7830         OPJ_BOOL cap = OPJ_FALSE;
7831
7832         if (OPJ_IS_IMF(parameters->rsiz) && parameters->max_cs_size > 0 &&
7833                 parameters->tcp_numlayers == 1 && parameters->tcp_rates[0] == 0) {
7834             parameters->tcp_rates[0] = (OPJ_FLOAT32)(image->numcomps * image->comps[0].w *
7835                                        image->comps[0].h * image->comps[0].prec) /
7836                                        (OPJ_FLOAT32)(((OPJ_UINT32)parameters->max_cs_size) * 8 * image->comps[0].dx *
7837                                                image->comps[0].dy);
7838         }
7839
7840         temp_rate = (OPJ_FLOAT32)(((double)image->numcomps * image->comps[0].w *
7841                                    image->comps[0].h * image->comps[0].prec) /
7842                                   (((double)parameters->max_cs_size) * 8 * image->comps[0].dx *
7843                                    image->comps[0].dy));
7844         for (i = 0; i < (OPJ_UINT32) parameters->tcp_numlayers; i++) {
7845             if (parameters->tcp_rates[i] < temp_rate) {
7846                 parameters->tcp_rates[i] = temp_rate;
7847                 cap = OPJ_TRUE;
7848             }
7849         }
7850         if (cap) {
7851             opj_event_msg(p_manager, EVT_WARNING,
7852                           "The desired maximum codestream size has limited\n"
7853                           "at least one of the desired quality layers\n");
7854         }
7855     }
7856
7857     if (OPJ_IS_CINEMA(parameters->rsiz) || OPJ_IS_IMF(parameters->rsiz)) {
7858         p_j2k->m_specific_param.m_encoder.m_TLM = OPJ_TRUE;
7859     }
7860
7861     /* Manage profiles and applications and set RSIZ */
7862     /* set cinema parameters if required */
7863     if (OPJ_IS_CINEMA(parameters->rsiz)) {
7864         if ((parameters->rsiz == OPJ_PROFILE_CINEMA_S2K)
7865                 || (parameters->rsiz == OPJ_PROFILE_CINEMA_S4K)) {
7866             opj_event_msg(p_manager, EVT_WARNING,
7867                           "JPEG 2000 Scalable Digital Cinema profiles not yet supported\n");
7868             parameters->rsiz = OPJ_PROFILE_NONE;
7869         } else {
7870             opj_j2k_set_cinema_parameters(parameters, image, p_manager);
7871             if (!opj_j2k_is_cinema_compliant(image, parameters->rsiz, p_manager)) {
7872                 parameters->rsiz = OPJ_PROFILE_NONE;
7873             }
7874         }
7875     } else if (OPJ_IS_STORAGE(parameters->rsiz)) {
7876         opj_event_msg(p_manager, EVT_WARNING,
7877                       "JPEG 2000 Long Term Storage profile not yet supported\n");
7878         parameters->rsiz = OPJ_PROFILE_NONE;
7879     } else if (OPJ_IS_BROADCAST(parameters->rsiz)) {
7880         opj_event_msg(p_manager, EVT_WARNING,
7881                       "JPEG 2000 Broadcast profiles not yet supported\n");
7882         parameters->rsiz = OPJ_PROFILE_NONE;
7883     } else if (OPJ_IS_IMF(parameters->rsiz)) {
7884         opj_j2k_set_imf_parameters(parameters, image, p_manager);
7885         if (!opj_j2k_is_imf_compliant(parameters, image, p_manager)) {
7886             parameters->rsiz = OPJ_PROFILE_NONE;
7887         }
7888     } else if (OPJ_IS_PART2(parameters->rsiz)) {
7889         if (parameters->rsiz == ((OPJ_PROFILE_PART2) | (OPJ_EXTENSION_NONE))) {
7890             opj_event_msg(p_manager, EVT_WARNING,
7891                           "JPEG 2000 Part-2 profile defined\n"
7892                           "but no Part-2 extension enabled.\n"
7893                           "Profile set to NONE.\n");
7894             parameters->rsiz = OPJ_PROFILE_NONE;
7895         } else if (parameters->rsiz != ((OPJ_PROFILE_PART2) | (OPJ_EXTENSION_MCT))) {
7896             opj_event_msg(p_manager, EVT_WARNING,
7897                           "Unsupported Part-2 extension enabled\n"
7898                           "Profile set to NONE.\n");
7899             parameters->rsiz = OPJ_PROFILE_NONE;
7900         }
7901     }
7902
7903     /*
7904     copy user encoding parameters
7905     */
7906     cp->m_specific_param.m_enc.m_max_comp_size = (OPJ_UINT32)
7907             parameters->max_comp_size;
7908     cp->rsiz = parameters->rsiz;
7909     if (parameters->cp_fixed_alloc) {
7910         cp->m_specific_param.m_enc.m_quality_layer_alloc_strategy = FIXED_LAYER;
7911     } else if (parameters->cp_fixed_quality) {
7912         cp->m_specific_param.m_enc.m_quality_layer_alloc_strategy =
7913             FIXED_DISTORTION_RATIO;
7914     } else {
7915         cp->m_specific_param.m_enc.m_quality_layer_alloc_strategy =
7916             RATE_DISTORTION_RATIO;
7917     }
7918
7919     if (parameters->cp_fixed_alloc) {
7920         size_t array_size = (size_t)parameters->tcp_numlayers *
7921                             (size_t)parameters->numresolution * 3 * sizeof(OPJ_INT32);
7922         cp->m_specific_param.m_enc.m_matrice = (OPJ_INT32 *) opj_malloc(array_size);
7923         if (!cp->m_specific_param.m_enc.m_matrice) {
7924             opj_event_msg(p_manager, EVT_ERROR,
7925                           "Not enough memory to allocate copy of user encoding parameters matrix \n");
7926             return OPJ_FALSE;
7927         }
7928         memcpy(cp->m_specific_param.m_enc.m_matrice, parameters->cp_matrice,
7929                array_size);
7930     }
7931
7932     /* tiles */
7933     cp->tdx = (OPJ_UINT32)parameters->cp_tdx;
7934     cp->tdy = (OPJ_UINT32)parameters->cp_tdy;
7935
7936     /* tile offset */
7937     cp->tx0 = (OPJ_UINT32)parameters->cp_tx0;
7938     cp->ty0 = (OPJ_UINT32)parameters->cp_ty0;
7939
7940     /* comment string */
7941     if (parameters->cp_comment) {
7942         cp->comment = (char*)opj_malloc(strlen(parameters->cp_comment) + 1U);
7943         if (!cp->comment) {
7944             opj_event_msg(p_manager, EVT_ERROR,
7945                           "Not enough memory to allocate copy of comment string\n");
7946             return OPJ_FALSE;
7947         }
7948         strcpy(cp->comment, parameters->cp_comment);
7949     } else {
7950         /* Create default comment for codestream */
7951         const char comment[] = "Created by OpenJPEG version ";
7952         const size_t clen = strlen(comment);
7953         const char *version = opj_version();
7954
7955         /* UniPG>> */
7956 #ifdef USE_JPWL
7957         const size_t cp_comment_buf_size = clen + strlen(version) + 11;
7958         cp->comment = (char*)opj_malloc(cp_comment_buf_size);
7959         if (!cp->comment) {
7960             opj_event_msg(p_manager, EVT_ERROR,
7961                           "Not enough memory to allocate comment string\n");
7962             return OPJ_FALSE;
7963         }
7964         snprintf(cp->comment, cp_comment_buf_size, "%s%s with JPWL",
7965                  comment, version);
7966 #else
7967         const size_t cp_comment_buf_size = clen + strlen(version) + 1;
7968         cp->comment = (char*)opj_malloc(cp_comment_buf_size);
7969         if (!cp->comment) {
7970             opj_event_msg(p_manager, EVT_ERROR,
7971                           "Not enough memory to allocate comment string\n");
7972             return OPJ_FALSE;
7973         }
7974         snprintf(cp->comment, cp_comment_buf_size, "%s%s", comment, version);
7975 #endif
7976         /* <<UniPG */
7977     }
7978
7979     /*
7980     calculate other encoding parameters
7981     */
7982
7983     if (parameters->tile_size_on) {
7984         if (cp->tdx == 0) {
7985             opj_event_msg(p_manager, EVT_ERROR, "Invalid tile width\n");
7986             return OPJ_FALSE;
7987         }
7988         if (cp->tdy == 0) {
7989             opj_event_msg(p_manager, EVT_ERROR, "Invalid tile height\n");
7990             return OPJ_FALSE;
7991         }
7992         cp->tw = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)(image->x1 - cp->tx0),
7993                                              (OPJ_INT32)cp->tdx);
7994         cp->th = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)(image->y1 - cp->ty0),
7995                                              (OPJ_INT32)cp->tdy);
7996         /* Check that the number of tiles is valid */
7997         if (cp->tw > 65535 / cp->th) {
7998             opj_event_msg(p_manager, EVT_ERROR,
7999                           "Invalid number of tiles : %u x %u (maximum fixed by jpeg2000 norm is 65535 tiles)\n",
8000                           cp->tw, cp->th);
8001             return OPJ_FALSE;
8002         }
8003     } else {
8004         cp->tdx = image->x1 - cp->tx0;
8005         cp->tdy = image->y1 - cp->ty0;
8006     }
8007
8008     if (parameters->tp_on) {
8009         cp->m_specific_param.m_enc.m_tp_flag = (OPJ_BYTE)parameters->tp_flag;
8010         cp->m_specific_param.m_enc.m_tp_on = 1;
8011     }
8012
8013 #ifdef USE_JPWL
8014     /*
8015     calculate JPWL encoding parameters
8016     */
8017
8018     if (parameters->jpwl_epc_on) {
8019         OPJ_INT32 i;
8020
8021         /* set JPWL on */
8022         cp->epc_on = OPJ_TRUE;
8023         cp->info_on = OPJ_FALSE; /* no informative technique */
8024
8025         /* set EPB on */
8026         if ((parameters->jpwl_hprot_MH > 0) || (parameters->jpwl_hprot_TPH[0] > 0)) {
8027             cp->epb_on = OPJ_TRUE;
8028
8029             cp->hprot_MH = parameters->jpwl_hprot_MH;
8030             for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {
8031                 cp->hprot_TPH_tileno[i] = parameters->jpwl_hprot_TPH_tileno[i];
8032                 cp->hprot_TPH[i] = parameters->jpwl_hprot_TPH[i];
8033             }
8034             /* if tile specs are not specified, copy MH specs */
8035             if (cp->hprot_TPH[0] == -1) {
8036                 cp->hprot_TPH_tileno[0] = 0;
8037                 cp->hprot_TPH[0] = parameters->jpwl_hprot_MH;
8038             }
8039             for (i = 0; i < JPWL_MAX_NO_PACKSPECS; i++) {
8040                 cp->pprot_tileno[i] = parameters->jpwl_pprot_tileno[i];
8041                 cp->pprot_packno[i] = parameters->jpwl_pprot_packno[i];
8042                 cp->pprot[i] = parameters->jpwl_pprot[i];
8043             }
8044         }
8045
8046         /* set ESD writing */
8047         if ((parameters->jpwl_sens_size == 1) || (parameters->jpwl_sens_size == 2)) {
8048             cp->esd_on = OPJ_TRUE;
8049
8050             cp->sens_size = parameters->jpwl_sens_size;
8051             cp->sens_addr = parameters->jpwl_sens_addr;
8052             cp->sens_range = parameters->jpwl_sens_range;
8053
8054             cp->sens_MH = parameters->jpwl_sens_MH;
8055             for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {
8056                 cp->sens_TPH_tileno[i] = parameters->jpwl_sens_TPH_tileno[i];
8057                 cp->sens_TPH[i] = parameters->jpwl_sens_TPH[i];
8058             }
8059         }
8060
8061         /* always set RED writing to false: we are at the encoder */
8062         cp->red_on = OPJ_FALSE;
8063
8064     } else {
8065         cp->epc_on = OPJ_FALSE;
8066     }
8067 #endif /* USE_JPWL */
8068
8069     /* initialize the multiple tiles */
8070     /* ---------------------------- */
8071     cp->tcps = (opj_tcp_t*) opj_calloc(cp->tw * cp->th, sizeof(opj_tcp_t));
8072     if (!cp->tcps) {
8073         opj_event_msg(p_manager, EVT_ERROR,
8074                       "Not enough memory to allocate tile coding parameters\n");
8075         return OPJ_FALSE;
8076     }
8077
8078     for (tileno = 0; tileno < cp->tw * cp->th; tileno++) {
8079         opj_tcp_t *tcp = &cp->tcps[tileno];
8080         const OPJ_BOOL fixed_distoratio =
8081             cp->m_specific_param.m_enc.m_quality_layer_alloc_strategy ==
8082             FIXED_DISTORTION_RATIO;
8083         tcp->numlayers = (OPJ_UINT32)parameters->tcp_numlayers;
8084
8085         for (j = 0; j < tcp->numlayers; j++) {
8086             if (OPJ_IS_CINEMA(cp->rsiz) || OPJ_IS_IMF(cp->rsiz)) {
8087                 if (fixed_distoratio) {
8088                     tcp->distoratio[j] = parameters->tcp_distoratio[j];
8089                 }
8090                 tcp->rates[j] = parameters->tcp_rates[j];
8091             } else {
8092                 if (fixed_distoratio) {
8093                     tcp->distoratio[j] = parameters->tcp_distoratio[j];
8094                 } else {
8095                     tcp->rates[j] = parameters->tcp_rates[j];
8096                 }
8097             }
8098             if (!fixed_distoratio &&
8099                     tcp->rates[j] <= 1.0) {
8100                 tcp->rates[j] = 0.0;    /* force lossless */
8101             }
8102         }
8103
8104         tcp->csty = (OPJ_UINT32)parameters->csty;
8105         tcp->prg = parameters->prog_order;
8106         tcp->mct = (OPJ_UINT32)parameters->tcp_mct;
8107
8108         numpocs_tile = 0;
8109         tcp->POC = 0;
8110
8111         if (parameters->numpocs) {
8112             /* initialisation of POC */
8113             for (i = 0; i < parameters->numpocs; i++) {
8114                 if (tileno + 1 == parameters->POC[i].tile)  {
8115                     opj_poc_t *tcp_poc = &tcp->pocs[numpocs_tile];
8116
8117                     if (parameters->POC[numpocs_tile].compno0 >= image->numcomps) {
8118                         opj_event_msg(p_manager, EVT_ERROR,
8119                                       "Invalid compno0 for POC %d\n", i);
8120                         return OPJ_FALSE;
8121                     }
8122
8123                     tcp_poc->resno0         = parameters->POC[numpocs_tile].resno0;
8124                     tcp_poc->compno0        = parameters->POC[numpocs_tile].compno0;
8125                     tcp_poc->layno1         = parameters->POC[numpocs_tile].layno1;
8126                     tcp_poc->resno1         = parameters->POC[numpocs_tile].resno1;
8127                     tcp_poc->compno1        = opj_uint_min(parameters->POC[numpocs_tile].compno1,
8128                                                            image->numcomps);
8129                     tcp_poc->prg1           = parameters->POC[numpocs_tile].prg1;
8130                     tcp_poc->tile           = parameters->POC[numpocs_tile].tile;
8131
8132                     numpocs_tile++;
8133                 }
8134             }
8135
8136             if (numpocs_tile) {
8137
8138                 /* TODO MSD use the return value*/
8139                 opj_j2k_check_poc_val(parameters->POC, tileno, parameters->numpocs,
8140                                       (OPJ_UINT32)parameters->numresolution, image->numcomps,
8141                                       (OPJ_UINT32)parameters->tcp_numlayers, p_manager);
8142
8143                 tcp->POC = 1;
8144                 tcp->numpocs = numpocs_tile - 1 ;
8145             }
8146         } else {
8147             tcp->numpocs = 0;
8148         }
8149
8150         tcp->tccps = (opj_tccp_t*) opj_calloc(image->numcomps, sizeof(opj_tccp_t));
8151         if (!tcp->tccps) {
8152             opj_event_msg(p_manager, EVT_ERROR,
8153                           "Not enough memory to allocate tile component coding parameters\n");
8154             return OPJ_FALSE;
8155         }
8156         if (parameters->mct_data) {
8157
8158             OPJ_UINT32 lMctSize = image->numcomps * image->numcomps * (OPJ_UINT32)sizeof(
8159                                       OPJ_FLOAT32);
8160             OPJ_FLOAT32 * lTmpBuf = (OPJ_FLOAT32*)opj_malloc(lMctSize);
8161             OPJ_INT32 * l_dc_shift = (OPJ_INT32 *)((OPJ_BYTE *) parameters->mct_data +
8162                                                    lMctSize);
8163
8164             if (!lTmpBuf) {
8165                 opj_event_msg(p_manager, EVT_ERROR,
8166                               "Not enough memory to allocate temp buffer\n");
8167                 return OPJ_FALSE;
8168             }
8169
8170             tcp->mct = 2;
8171             tcp->m_mct_coding_matrix = (OPJ_FLOAT32*)opj_malloc(lMctSize);
8172             if (! tcp->m_mct_coding_matrix) {
8173                 opj_free(lTmpBuf);
8174                 lTmpBuf = NULL;
8175                 opj_event_msg(p_manager, EVT_ERROR,
8176                               "Not enough memory to allocate encoder MCT coding matrix \n");
8177                 return OPJ_FALSE;
8178             }
8179             memcpy(tcp->m_mct_coding_matrix, parameters->mct_data, lMctSize);
8180             memcpy(lTmpBuf, parameters->mct_data, lMctSize);
8181
8182             tcp->m_mct_decoding_matrix = (OPJ_FLOAT32*)opj_malloc(lMctSize);
8183             if (! tcp->m_mct_decoding_matrix) {
8184                 opj_free(lTmpBuf);
8185                 lTmpBuf = NULL;
8186                 opj_event_msg(p_manager, EVT_ERROR,
8187                               "Not enough memory to allocate encoder MCT decoding matrix \n");
8188                 return OPJ_FALSE;
8189             }
8190             if (opj_matrix_inversion_f(lTmpBuf, (tcp->m_mct_decoding_matrix),
8191                                        image->numcomps) == OPJ_FALSE) {
8192                 opj_free(lTmpBuf);
8193                 lTmpBuf = NULL;
8194                 opj_event_msg(p_manager, EVT_ERROR,
8195                               "Failed to inverse encoder MCT decoding matrix \n");
8196                 return OPJ_FALSE;
8197             }
8198
8199             tcp->mct_norms = (OPJ_FLOAT64*)
8200                              opj_malloc(image->numcomps * sizeof(OPJ_FLOAT64));
8201             if (! tcp->mct_norms) {
8202                 opj_free(lTmpBuf);
8203                 lTmpBuf = NULL;
8204                 opj_event_msg(p_manager, EVT_ERROR,
8205                               "Not enough memory to allocate encoder MCT norms \n");
8206                 return OPJ_FALSE;
8207             }
8208             opj_calculate_norms(tcp->mct_norms, image->numcomps,
8209                                 tcp->m_mct_decoding_matrix);
8210             opj_free(lTmpBuf);
8211
8212             for (i = 0; i < image->numcomps; i++) {
8213                 opj_tccp_t *tccp = &tcp->tccps[i];
8214                 tccp->m_dc_level_shift = l_dc_shift[i];
8215             }
8216
8217             if (opj_j2k_setup_mct_encoding(tcp, image) == OPJ_FALSE) {
8218                 /* free will be handled by opj_j2k_destroy */
8219                 opj_event_msg(p_manager, EVT_ERROR, "Failed to setup j2k mct encoding\n");
8220                 return OPJ_FALSE;
8221             }
8222         } else {
8223             if (tcp->mct == 1 && image->numcomps >= 3) { /* RGB->YCC MCT is enabled */
8224                 if ((image->comps[0].dx != image->comps[1].dx) ||
8225                         (image->comps[0].dx != image->comps[2].dx) ||
8226                         (image->comps[0].dy != image->comps[1].dy) ||
8227                         (image->comps[0].dy != image->comps[2].dy)) {
8228                     opj_event_msg(p_manager, EVT_WARNING,
8229                                   "Cannot perform MCT on components with different sizes. Disabling MCT.\n");
8230                     tcp->mct = 0;
8231                 }
8232             }
8233             for (i = 0; i < image->numcomps; i++) {
8234                 opj_tccp_t *tccp = &tcp->tccps[i];
8235                 opj_image_comp_t * l_comp = &(image->comps[i]);
8236
8237                 if (! l_comp->sgnd) {
8238                     tccp->m_dc_level_shift = 1 << (l_comp->prec - 1);
8239                 }
8240             }
8241         }
8242
8243         for (i = 0; i < image->numcomps; i++) {
8244             opj_tccp_t *tccp = &tcp->tccps[i];
8245
8246             tccp->csty = parameters->csty &
8247                          0x01;   /* 0 => one precinct || 1 => custom precinct  */
8248             tccp->numresolutions = (OPJ_UINT32)parameters->numresolution;
8249             tccp->cblkw = (OPJ_UINT32)opj_int_floorlog2(parameters->cblockw_init);
8250             tccp->cblkh = (OPJ_UINT32)opj_int_floorlog2(parameters->cblockh_init);
8251             tccp->cblksty = (OPJ_UINT32)parameters->mode;
8252             tccp->qmfbid = parameters->irreversible ? 0 : 1;
8253             tccp->qntsty = parameters->irreversible ? J2K_CCP_QNTSTY_SEQNT :
8254                            J2K_CCP_QNTSTY_NOQNT;
8255             tccp->numgbits = 2;
8256
8257             if ((OPJ_INT32)i == parameters->roi_compno) {
8258                 tccp->roishift = parameters->roi_shift;
8259             } else {
8260                 tccp->roishift = 0;
8261             }
8262
8263             if (parameters->csty & J2K_CCP_CSTY_PRT) {
8264                 OPJ_INT32 p = 0, it_res;
8265                 assert(tccp->numresolutions > 0);
8266                 for (it_res = (OPJ_INT32)tccp->numresolutions - 1; it_res >= 0; it_res--) {
8267                     if (p < parameters->res_spec) {
8268
8269                         if (parameters->prcw_init[p] < 1) {
8270                             tccp->prcw[it_res] = 1;
8271                         } else {
8272                             tccp->prcw[it_res] = (OPJ_UINT32)opj_int_floorlog2(parameters->prcw_init[p]);
8273                         }
8274
8275                         if (parameters->prch_init[p] < 1) {
8276                             tccp->prch[it_res] = 1;
8277                         } else {
8278                             tccp->prch[it_res] = (OPJ_UINT32)opj_int_floorlog2(parameters->prch_init[p]);
8279                         }
8280
8281                     } else {
8282                         OPJ_INT32 res_spec = parameters->res_spec;
8283                         OPJ_INT32 size_prcw = 0;
8284                         OPJ_INT32 size_prch = 0;
8285
8286                         assert(res_spec > 0); /* issue 189 */
8287                         size_prcw = parameters->prcw_init[res_spec - 1] >> (p - (res_spec - 1));
8288                         size_prch = parameters->prch_init[res_spec - 1] >> (p - (res_spec - 1));
8289
8290
8291                         if (size_prcw < 1) {
8292                             tccp->prcw[it_res] = 1;
8293                         } else {
8294                             tccp->prcw[it_res] = (OPJ_UINT32)opj_int_floorlog2(size_prcw);
8295                         }
8296
8297                         if (size_prch < 1) {
8298                             tccp->prch[it_res] = 1;
8299                         } else {
8300                             tccp->prch[it_res] = (OPJ_UINT32)opj_int_floorlog2(size_prch);
8301                         }
8302                     }
8303                     p++;
8304                     /*printf("\nsize precinct for level %d : %d,%d\n", it_res,tccp->prcw[it_res], tccp->prch[it_res]); */
8305                 }       /*end for*/
8306             } else {
8307                 for (j = 0; j < tccp->numresolutions; j++) {
8308                     tccp->prcw[j] = 15;
8309                     tccp->prch[j] = 15;
8310                 }
8311             }
8312
8313             opj_dwt_calc_explicit_stepsizes(tccp, image->comps[i].prec);
8314         }
8315     }
8316
8317     if (parameters->mct_data) {
8318         opj_free(parameters->mct_data);
8319         parameters->mct_data = 00;
8320     }
8321     return OPJ_TRUE;
8322 }
8323
8324 static OPJ_BOOL opj_j2k_add_mhmarker(opj_codestream_index_t *cstr_index,
8325                                      OPJ_UINT32 type, OPJ_OFF_T pos, OPJ_UINT32 len)
8326 {
8327     assert(cstr_index != 00);
8328
8329     /* expand the list? */
8330     if ((cstr_index->marknum + 1) > cstr_index->maxmarknum) {
8331         opj_marker_info_t *new_marker;
8332         cstr_index->maxmarknum = (OPJ_UINT32)(100 + (OPJ_FLOAT32)
8333                                               cstr_index->maxmarknum);
8334         new_marker = (opj_marker_info_t *) opj_realloc(cstr_index->marker,
8335                      cstr_index->maxmarknum * sizeof(opj_marker_info_t));
8336         if (! new_marker) {
8337             opj_free(cstr_index->marker);
8338             cstr_index->marker = NULL;
8339             cstr_index->maxmarknum = 0;
8340             cstr_index->marknum = 0;
8341             /* opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to add mh marker\n"); */
8342             return OPJ_FALSE;
8343         }
8344         cstr_index->marker = new_marker;
8345     }
8346
8347     /* add the marker */
8348     cstr_index->marker[cstr_index->marknum].type = (OPJ_UINT16)type;
8349     cstr_index->marker[cstr_index->marknum].pos = (OPJ_INT32)pos;
8350     cstr_index->marker[cstr_index->marknum].len = (OPJ_INT32)len;
8351     cstr_index->marknum++;
8352     return OPJ_TRUE;
8353 }
8354
8355 static OPJ_BOOL opj_j2k_add_tlmarker(OPJ_UINT32 tileno,
8356                                      opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_OFF_T pos,
8357                                      OPJ_UINT32 len)
8358 {
8359     assert(cstr_index != 00);
8360     assert(cstr_index->tile_index != 00);
8361
8362     /* expand the list? */
8363     if ((cstr_index->tile_index[tileno].marknum + 1) >
8364             cstr_index->tile_index[tileno].maxmarknum) {
8365         opj_marker_info_t *new_marker;
8366         cstr_index->tile_index[tileno].maxmarknum = (OPJ_UINT32)(100 +
8367                 (OPJ_FLOAT32) cstr_index->tile_index[tileno].maxmarknum);
8368         new_marker = (opj_marker_info_t *) opj_realloc(
8369                          cstr_index->tile_index[tileno].marker,
8370                          cstr_index->tile_index[tileno].maxmarknum * sizeof(opj_marker_info_t));
8371         if (! new_marker) {
8372             opj_free(cstr_index->tile_index[tileno].marker);
8373             cstr_index->tile_index[tileno].marker = NULL;
8374             cstr_index->tile_index[tileno].maxmarknum = 0;
8375             cstr_index->tile_index[tileno].marknum = 0;
8376             /* opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to add tl marker\n"); */
8377             return OPJ_FALSE;
8378         }
8379         cstr_index->tile_index[tileno].marker = new_marker;
8380     }
8381
8382     /* add the marker */
8383     cstr_index->tile_index[tileno].marker[cstr_index->tile_index[tileno].marknum].type
8384         = (OPJ_UINT16)type;
8385     cstr_index->tile_index[tileno].marker[cstr_index->tile_index[tileno].marknum].pos
8386         = (OPJ_INT32)pos;
8387     cstr_index->tile_index[tileno].marker[cstr_index->tile_index[tileno].marknum].len
8388         = (OPJ_INT32)len;
8389     cstr_index->tile_index[tileno].marknum++;
8390
8391     if (type == J2K_MS_SOT) {
8392         OPJ_UINT32 l_current_tile_part = cstr_index->tile_index[tileno].current_tpsno;
8393
8394         if (cstr_index->tile_index[tileno].tp_index) {
8395             cstr_index->tile_index[tileno].tp_index[l_current_tile_part].start_pos = pos;
8396         }
8397
8398     }
8399     return OPJ_TRUE;
8400 }
8401
8402 /*
8403  * -----------------------------------------------------------------------
8404  * -----------------------------------------------------------------------
8405  * -----------------------------------------------------------------------
8406  */
8407
8408 OPJ_BOOL opj_j2k_end_decompress(opj_j2k_t *p_j2k,
8409                                 opj_stream_private_t *p_stream,
8410                                 opj_event_mgr_t * p_manager
8411                                )
8412 {
8413     (void)p_j2k;
8414     (void)p_stream;
8415     (void)p_manager;
8416     return OPJ_TRUE;
8417 }
8418
8419 OPJ_BOOL opj_j2k_read_header(opj_stream_private_t *p_stream,
8420                              opj_j2k_t* p_j2k,
8421                              opj_image_t** p_image,
8422                              opj_event_mgr_t* p_manager)
8423 {
8424     /* preconditions */
8425     assert(p_j2k != 00);
8426     assert(p_stream != 00);
8427     assert(p_manager != 00);
8428
8429     /* create an empty image header */
8430     p_j2k->m_private_image = opj_image_create0();
8431     if (! p_j2k->m_private_image) {
8432         return OPJ_FALSE;
8433     }
8434
8435     /* customization of the validation */
8436     if (! opj_j2k_setup_decoding_validation(p_j2k, p_manager)) {
8437         opj_image_destroy(p_j2k->m_private_image);
8438         p_j2k->m_private_image = NULL;
8439         return OPJ_FALSE;
8440     }
8441
8442     /* validation of the parameters codec */
8443     if (! opj_j2k_exec(p_j2k, p_j2k->m_validation_list, p_stream, p_manager)) {
8444         opj_image_destroy(p_j2k->m_private_image);
8445         p_j2k->m_private_image = NULL;
8446         return OPJ_FALSE;
8447     }
8448
8449     /* customization of the encoding */
8450     if (! opj_j2k_setup_header_reading(p_j2k, p_manager)) {
8451         opj_image_destroy(p_j2k->m_private_image);
8452         p_j2k->m_private_image = NULL;
8453         return OPJ_FALSE;
8454     }
8455
8456     /* read header */
8457     if (! opj_j2k_exec(p_j2k, p_j2k->m_procedure_list, p_stream, p_manager)) {
8458         opj_image_destroy(p_j2k->m_private_image);
8459         p_j2k->m_private_image = NULL;
8460         return OPJ_FALSE;
8461     }
8462
8463     *p_image = opj_image_create0();
8464     if (!(*p_image)) {
8465         return OPJ_FALSE;
8466     }
8467
8468     /* Copy codestream image information to the output image */
8469     opj_copy_image_header(p_j2k->m_private_image, *p_image);
8470
8471     /*Allocate and initialize some elements of codestrem index*/
8472     if (!opj_j2k_allocate_tile_element_cstr_index(p_j2k)) {
8473         opj_image_destroy(*p_image);
8474         *p_image = NULL;
8475         return OPJ_FALSE;
8476     }
8477
8478     return OPJ_TRUE;
8479 }
8480
8481 static OPJ_BOOL opj_j2k_setup_header_reading(opj_j2k_t *p_j2k,
8482         opj_event_mgr_t * p_manager)
8483 {
8484     /* preconditions*/
8485     assert(p_j2k != 00);
8486     assert(p_manager != 00);
8487
8488     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
8489                                            (opj_procedure)opj_j2k_read_header_procedure, p_manager)) {
8490         return OPJ_FALSE;
8491     }
8492
8493     /* DEVELOPER CORNER, add your custom procedures */
8494     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
8495                                            (opj_procedure)opj_j2k_copy_default_tcp_and_create_tcd, p_manager))  {
8496         return OPJ_FALSE;
8497     }
8498
8499     return OPJ_TRUE;
8500 }
8501
8502 static OPJ_BOOL opj_j2k_setup_decoding_validation(opj_j2k_t *p_j2k,
8503         opj_event_mgr_t * p_manager)
8504 {
8505     /* preconditions*/
8506     assert(p_j2k != 00);
8507     assert(p_manager != 00);
8508
8509     if (! opj_procedure_list_add_procedure(p_j2k->m_validation_list,
8510                                            (opj_procedure)opj_j2k_build_decoder, p_manager)) {
8511         return OPJ_FALSE;
8512     }
8513     if (! opj_procedure_list_add_procedure(p_j2k->m_validation_list,
8514                                            (opj_procedure)opj_j2k_decoding_validation, p_manager)) {
8515         return OPJ_FALSE;
8516     }
8517
8518     /* DEVELOPER CORNER, add your custom validation procedure */
8519     return OPJ_TRUE;
8520 }
8521
8522 static OPJ_BOOL opj_j2k_mct_validation(opj_j2k_t * p_j2k,
8523                                        opj_stream_private_t *p_stream,
8524                                        opj_event_mgr_t * p_manager)
8525 {
8526     OPJ_BOOL l_is_valid = OPJ_TRUE;
8527     OPJ_UINT32 i, j;
8528
8529     /* preconditions */
8530     assert(p_j2k != 00);
8531     assert(p_stream != 00);
8532     assert(p_manager != 00);
8533
8534     OPJ_UNUSED(p_stream);
8535     OPJ_UNUSED(p_manager);
8536
8537     if ((p_j2k->m_cp.rsiz & 0x8200) == 0x8200) {
8538         OPJ_UINT32 l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
8539         opj_tcp_t * l_tcp = p_j2k->m_cp.tcps;
8540
8541         for (i = 0; i < l_nb_tiles; ++i) {
8542             if (l_tcp->mct == 2) {
8543                 opj_tccp_t * l_tccp = l_tcp->tccps;
8544                 l_is_valid &= (l_tcp->m_mct_coding_matrix != 00);
8545
8546                 for (j = 0; j < p_j2k->m_private_image->numcomps; ++j) {
8547                     l_is_valid &= !(l_tccp->qmfbid & 1);
8548                     ++l_tccp;
8549                 }
8550             }
8551             ++l_tcp;
8552         }
8553     }
8554
8555     return l_is_valid;
8556 }
8557
8558 OPJ_BOOL opj_j2k_setup_mct_encoding(opj_tcp_t * p_tcp, opj_image_t * p_image)
8559 {
8560     OPJ_UINT32 i;
8561     OPJ_UINT32 l_indix = 1;
8562     opj_mct_data_t * l_mct_deco_data = 00, * l_mct_offset_data = 00;
8563     opj_simple_mcc_decorrelation_data_t * l_mcc_data;
8564     OPJ_UINT32 l_mct_size, l_nb_elem;
8565     OPJ_FLOAT32 * l_data, * l_current_data;
8566     opj_tccp_t * l_tccp;
8567
8568     /* preconditions */
8569     assert(p_tcp != 00);
8570
8571     if (p_tcp->mct != 2) {
8572         return OPJ_TRUE;
8573     }
8574
8575     if (p_tcp->m_mct_decoding_matrix) {
8576         if (p_tcp->m_nb_mct_records == p_tcp->m_nb_max_mct_records) {
8577             opj_mct_data_t *new_mct_records;
8578             p_tcp->m_nb_max_mct_records += OPJ_J2K_MCT_DEFAULT_NB_RECORDS;
8579
8580             new_mct_records = (opj_mct_data_t *) opj_realloc(p_tcp->m_mct_records,
8581                               p_tcp->m_nb_max_mct_records * sizeof(opj_mct_data_t));
8582             if (! new_mct_records) {
8583                 opj_free(p_tcp->m_mct_records);
8584                 p_tcp->m_mct_records = NULL;
8585                 p_tcp->m_nb_max_mct_records = 0;
8586                 p_tcp->m_nb_mct_records = 0;
8587                 /* opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to setup mct encoding\n"); */
8588                 return OPJ_FALSE;
8589             }
8590             p_tcp->m_mct_records = new_mct_records;
8591             l_mct_deco_data = p_tcp->m_mct_records + p_tcp->m_nb_mct_records;
8592
8593             memset(l_mct_deco_data, 0,
8594                    (p_tcp->m_nb_max_mct_records - p_tcp->m_nb_mct_records) * sizeof(
8595                        opj_mct_data_t));
8596         }
8597         l_mct_deco_data = p_tcp->m_mct_records + p_tcp->m_nb_mct_records;
8598
8599         if (l_mct_deco_data->m_data) {
8600             opj_free(l_mct_deco_data->m_data);
8601             l_mct_deco_data->m_data = 00;
8602         }
8603
8604         l_mct_deco_data->m_index = l_indix++;
8605         l_mct_deco_data->m_array_type = MCT_TYPE_DECORRELATION;
8606         l_mct_deco_data->m_element_type = MCT_TYPE_FLOAT;
8607         l_nb_elem = p_image->numcomps * p_image->numcomps;
8608         l_mct_size = l_nb_elem * MCT_ELEMENT_SIZE[l_mct_deco_data->m_element_type];
8609         l_mct_deco_data->m_data = (OPJ_BYTE*)opj_malloc(l_mct_size);
8610
8611         if (! l_mct_deco_data->m_data) {
8612             return OPJ_FALSE;
8613         }
8614
8615         j2k_mct_write_functions_from_float[l_mct_deco_data->m_element_type](
8616             p_tcp->m_mct_decoding_matrix, l_mct_deco_data->m_data, l_nb_elem);
8617
8618         l_mct_deco_data->m_data_size = l_mct_size;
8619         ++p_tcp->m_nb_mct_records;
8620     }
8621
8622     if (p_tcp->m_nb_mct_records == p_tcp->m_nb_max_mct_records) {
8623         opj_mct_data_t *new_mct_records;
8624         p_tcp->m_nb_max_mct_records += OPJ_J2K_MCT_DEFAULT_NB_RECORDS;
8625         new_mct_records = (opj_mct_data_t *) opj_realloc(p_tcp->m_mct_records,
8626                           p_tcp->m_nb_max_mct_records * sizeof(opj_mct_data_t));
8627         if (! new_mct_records) {
8628             opj_free(p_tcp->m_mct_records);
8629             p_tcp->m_mct_records = NULL;
8630             p_tcp->m_nb_max_mct_records = 0;
8631             p_tcp->m_nb_mct_records = 0;
8632             /* opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to setup mct encoding\n"); */
8633             return OPJ_FALSE;
8634         }
8635         p_tcp->m_mct_records = new_mct_records;
8636         l_mct_offset_data = p_tcp->m_mct_records + p_tcp->m_nb_mct_records;
8637
8638         memset(l_mct_offset_data, 0,
8639                (p_tcp->m_nb_max_mct_records - p_tcp->m_nb_mct_records) * sizeof(
8640                    opj_mct_data_t));
8641
8642         if (l_mct_deco_data) {
8643             l_mct_deco_data = l_mct_offset_data - 1;
8644         }
8645     }
8646
8647     l_mct_offset_data = p_tcp->m_mct_records + p_tcp->m_nb_mct_records;
8648
8649     if (l_mct_offset_data->m_data) {
8650         opj_free(l_mct_offset_data->m_data);
8651         l_mct_offset_data->m_data = 00;
8652     }
8653
8654     l_mct_offset_data->m_index = l_indix++;
8655     l_mct_offset_data->m_array_type = MCT_TYPE_OFFSET;
8656     l_mct_offset_data->m_element_type = MCT_TYPE_FLOAT;
8657     l_nb_elem = p_image->numcomps;
8658     l_mct_size = l_nb_elem * MCT_ELEMENT_SIZE[l_mct_offset_data->m_element_type];
8659     l_mct_offset_data->m_data = (OPJ_BYTE*)opj_malloc(l_mct_size);
8660
8661     if (! l_mct_offset_data->m_data) {
8662         return OPJ_FALSE;
8663     }
8664
8665     l_data = (OPJ_FLOAT32*)opj_malloc(l_nb_elem * sizeof(OPJ_FLOAT32));
8666     if (! l_data) {
8667         opj_free(l_mct_offset_data->m_data);
8668         l_mct_offset_data->m_data = 00;
8669         return OPJ_FALSE;
8670     }
8671
8672     l_tccp = p_tcp->tccps;
8673     l_current_data = l_data;
8674
8675     for (i = 0; i < l_nb_elem; ++i) {
8676         *(l_current_data++) = (OPJ_FLOAT32)(l_tccp->m_dc_level_shift);
8677         ++l_tccp;
8678     }
8679
8680     j2k_mct_write_functions_from_float[l_mct_offset_data->m_element_type](l_data,
8681             l_mct_offset_data->m_data, l_nb_elem);
8682
8683     opj_free(l_data);
8684
8685     l_mct_offset_data->m_data_size = l_mct_size;
8686
8687     ++p_tcp->m_nb_mct_records;
8688
8689     if (p_tcp->m_nb_mcc_records == p_tcp->m_nb_max_mcc_records) {
8690         opj_simple_mcc_decorrelation_data_t *new_mcc_records;
8691         p_tcp->m_nb_max_mcc_records += OPJ_J2K_MCT_DEFAULT_NB_RECORDS;
8692         new_mcc_records = (opj_simple_mcc_decorrelation_data_t *) opj_realloc(
8693                               p_tcp->m_mcc_records, p_tcp->m_nb_max_mcc_records * sizeof(
8694                                   opj_simple_mcc_decorrelation_data_t));
8695         if (! new_mcc_records) {
8696             opj_free(p_tcp->m_mcc_records);
8697             p_tcp->m_mcc_records = NULL;
8698             p_tcp->m_nb_max_mcc_records = 0;
8699             p_tcp->m_nb_mcc_records = 0;
8700             /* opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to setup mct encoding\n"); */
8701             return OPJ_FALSE;
8702         }
8703         p_tcp->m_mcc_records = new_mcc_records;
8704         l_mcc_data = p_tcp->m_mcc_records + p_tcp->m_nb_mcc_records;
8705         memset(l_mcc_data, 0, (p_tcp->m_nb_max_mcc_records - p_tcp->m_nb_mcc_records) *
8706                sizeof(opj_simple_mcc_decorrelation_data_t));
8707
8708     }
8709
8710     l_mcc_data = p_tcp->m_mcc_records + p_tcp->m_nb_mcc_records;
8711     l_mcc_data->m_decorrelation_array = l_mct_deco_data;
8712     l_mcc_data->m_is_irreversible = 1;
8713     l_mcc_data->m_nb_comps = p_image->numcomps;
8714     l_mcc_data->m_index = l_indix++;
8715     l_mcc_data->m_offset_array = l_mct_offset_data;
8716     ++p_tcp->m_nb_mcc_records;
8717
8718     return OPJ_TRUE;
8719 }
8720
8721 static OPJ_BOOL opj_j2k_build_decoder(opj_j2k_t * p_j2k,
8722                                       opj_stream_private_t *p_stream,
8723                                       opj_event_mgr_t * p_manager)
8724 {
8725     /* add here initialization of cp
8726        copy paste of setup_decoder */
8727     (void)p_j2k;
8728     (void)p_stream;
8729     (void)p_manager;
8730     return OPJ_TRUE;
8731 }
8732
8733 static OPJ_BOOL opj_j2k_build_encoder(opj_j2k_t * p_j2k,
8734                                       opj_stream_private_t *p_stream,
8735                                       opj_event_mgr_t * p_manager)
8736 {
8737     /* add here initialization of cp
8738        copy paste of setup_encoder */
8739     (void)p_j2k;
8740     (void)p_stream;
8741     (void)p_manager;
8742     return OPJ_TRUE;
8743 }
8744
8745 static OPJ_BOOL opj_j2k_encoding_validation(opj_j2k_t * p_j2k,
8746         opj_stream_private_t *p_stream,
8747         opj_event_mgr_t * p_manager)
8748 {
8749     OPJ_BOOL l_is_valid = OPJ_TRUE;
8750
8751     /* preconditions */
8752     assert(p_j2k != 00);
8753     assert(p_stream != 00);
8754     assert(p_manager != 00);
8755
8756     OPJ_UNUSED(p_stream);
8757
8758     /* STATE checking */
8759     /* make sure the state is at 0 */
8760     l_is_valid &= (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_NONE);
8761
8762     /* POINTER validation */
8763     /* make sure a p_j2k codec is present */
8764     l_is_valid &= (p_j2k->m_procedure_list != 00);
8765     /* make sure a validation list is present */
8766     l_is_valid &= (p_j2k->m_validation_list != 00);
8767
8768     /* ISO 15444-1:2004 states between 1 & 33 (0 -> 32) */
8769     /* 33 (32) would always fail the check below (if a cast to 64bits was done) */
8770     /* FIXME Shall we change OPJ_J2K_MAXRLVLS to 32 ? */
8771     if ((p_j2k->m_cp.tcps->tccps->numresolutions <= 0) ||
8772             (p_j2k->m_cp.tcps->tccps->numresolutions > 32)) {
8773         opj_event_msg(p_manager, EVT_ERROR,
8774                       "Number of resolutions is too high in comparison to the size of tiles\n");
8775         return OPJ_FALSE;
8776     }
8777
8778     if ((p_j2k->m_cp.tdx) < (OPJ_UINT32)(1 <<
8779                                          (p_j2k->m_cp.tcps->tccps->numresolutions - 1U))) {
8780         opj_event_msg(p_manager, EVT_ERROR,
8781                       "Number of resolutions is too high in comparison to the size of tiles\n");
8782         return OPJ_FALSE;
8783     }
8784
8785     if ((p_j2k->m_cp.tdy) < (OPJ_UINT32)(1 <<
8786                                          (p_j2k->m_cp.tcps->tccps->numresolutions - 1U))) {
8787         opj_event_msg(p_manager, EVT_ERROR,
8788                       "Number of resolutions is too high in comparison to the size of tiles\n");
8789         return OPJ_FALSE;
8790     }
8791
8792     /* PARAMETER VALIDATION */
8793     return l_is_valid;
8794 }
8795
8796 static OPJ_BOOL opj_j2k_decoding_validation(opj_j2k_t *p_j2k,
8797         opj_stream_private_t *p_stream,
8798         opj_event_mgr_t * p_manager
8799                                            )
8800 {
8801     OPJ_BOOL l_is_valid = OPJ_TRUE;
8802
8803     /* preconditions*/
8804     assert(p_j2k != 00);
8805     assert(p_stream != 00);
8806     assert(p_manager != 00);
8807
8808     OPJ_UNUSED(p_stream);
8809     OPJ_UNUSED(p_manager);
8810
8811     /* STATE checking */
8812     /* make sure the state is at 0 */
8813 #ifdef TODO_MSD
8814     l_is_valid &= (p_j2k->m_specific_param.m_decoder.m_state == J2K_DEC_STATE_NONE);
8815 #endif
8816     l_is_valid &= (p_j2k->m_specific_param.m_decoder.m_state == 0x0000);
8817
8818     /* POINTER validation */
8819     /* make sure a p_j2k codec is present */
8820     /* make sure a procedure list is present */
8821     l_is_valid &= (p_j2k->m_procedure_list != 00);
8822     /* make sure a validation list is present */
8823     l_is_valid &= (p_j2k->m_validation_list != 00);
8824
8825     /* PARAMETER VALIDATION */
8826     return l_is_valid;
8827 }
8828
8829 static OPJ_BOOL opj_j2k_read_header_procedure(opj_j2k_t *p_j2k,
8830         opj_stream_private_t *p_stream,
8831         opj_event_mgr_t * p_manager)
8832 {
8833     OPJ_UINT32 l_current_marker;
8834     OPJ_UINT32 l_marker_size;
8835     const opj_dec_memory_marker_handler_t * l_marker_handler = 00;
8836     OPJ_BOOL l_has_siz = 0;
8837     OPJ_BOOL l_has_cod = 0;
8838     OPJ_BOOL l_has_qcd = 0;
8839
8840     /* preconditions */
8841     assert(p_stream != 00);
8842     assert(p_j2k != 00);
8843     assert(p_manager != 00);
8844
8845     /*  We enter in the main header */
8846     p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_MHSOC;
8847
8848     /* Try to read the SOC marker, the codestream must begin with SOC marker */
8849     if (! opj_j2k_read_soc(p_j2k, p_stream, p_manager)) {
8850         opj_event_msg(p_manager, EVT_ERROR, "Expected a SOC marker \n");
8851         return OPJ_FALSE;
8852     }
8853
8854     /* Try to read 2 bytes (the next marker ID) from stream and copy them into the buffer */
8855     if (opj_stream_read_data(p_stream,
8856                              p_j2k->m_specific_param.m_decoder.m_header_data, 2, p_manager) != 2) {
8857         opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
8858         return OPJ_FALSE;
8859     }
8860
8861     /* Read 2 bytes as the new marker ID */
8862     opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,
8863                    &l_current_marker, 2);
8864
8865     /* Try to read until the SOT is detected */
8866     while (l_current_marker != J2K_MS_SOT) {
8867
8868         /* Check if the current marker ID is valid */
8869         if (l_current_marker < 0xff00) {
8870             opj_event_msg(p_manager, EVT_ERROR,
8871                           "A marker ID was expected (0xff--) instead of %.8x\n", l_current_marker);
8872             return OPJ_FALSE;
8873         }
8874
8875         /* Get the marker handler from the marker ID */
8876         l_marker_handler = opj_j2k_get_marker_handler(l_current_marker);
8877
8878         /* Manage case where marker is unknown */
8879         if (l_marker_handler->id == J2K_MS_UNK) {
8880             if (! opj_j2k_read_unk(p_j2k, p_stream, &l_current_marker, p_manager)) {
8881                 opj_event_msg(p_manager, EVT_ERROR,
8882                               "Unknown marker has been detected and generated error.\n");
8883                 return OPJ_FALSE;
8884             }
8885
8886             if (l_current_marker == J2K_MS_SOT) {
8887                 break;    /* SOT marker is detected main header is completely read */
8888             } else { /* Get the marker handler from the marker ID */
8889                 l_marker_handler = opj_j2k_get_marker_handler(l_current_marker);
8890             }
8891         }
8892
8893         if (l_marker_handler->id == J2K_MS_SIZ) {
8894             /* Mark required SIZ marker as found */
8895             l_has_siz = 1;
8896         }
8897         if (l_marker_handler->id == J2K_MS_COD) {
8898             /* Mark required COD marker as found */
8899             l_has_cod = 1;
8900         }
8901         if (l_marker_handler->id == J2K_MS_QCD) {
8902             /* Mark required QCD marker as found */
8903             l_has_qcd = 1;
8904         }
8905
8906         /* Check if the marker is known and if it is the right place to find it */
8907         if (!(p_j2k->m_specific_param.m_decoder.m_state & l_marker_handler->states)) {
8908             opj_event_msg(p_manager, EVT_ERROR,
8909                           "Marker is not compliant with its position\n");
8910             return OPJ_FALSE;
8911         }
8912
8913         /* Try to read 2 bytes (the marker size) from stream and copy them into the buffer */
8914         if (opj_stream_read_data(p_stream,
8915                                  p_j2k->m_specific_param.m_decoder.m_header_data, 2, p_manager) != 2) {
8916             opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
8917             return OPJ_FALSE;
8918         }
8919
8920         /* read 2 bytes as the marker size */
8921         opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data, &l_marker_size,
8922                        2);
8923         if (l_marker_size < 2) {
8924             opj_event_msg(p_manager, EVT_ERROR, "Invalid marker size\n");
8925             return OPJ_FALSE;
8926         }
8927         l_marker_size -= 2; /* Subtract the size of the marker ID already read */
8928
8929         /* Check if the marker size is compatible with the header data size */
8930         if (l_marker_size > p_j2k->m_specific_param.m_decoder.m_header_data_size) {
8931             OPJ_BYTE *new_header_data = (OPJ_BYTE *) opj_realloc(
8932                                             p_j2k->m_specific_param.m_decoder.m_header_data, l_marker_size);
8933             if (! new_header_data) {
8934                 opj_free(p_j2k->m_specific_param.m_decoder.m_header_data);
8935                 p_j2k->m_specific_param.m_decoder.m_header_data = NULL;
8936                 p_j2k->m_specific_param.m_decoder.m_header_data_size = 0;
8937                 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read header\n");
8938                 return OPJ_FALSE;
8939             }
8940             p_j2k->m_specific_param.m_decoder.m_header_data = new_header_data;
8941             p_j2k->m_specific_param.m_decoder.m_header_data_size = l_marker_size;
8942         }
8943
8944         /* Try to read the rest of the marker segment from stream and copy them into the buffer */
8945         if (opj_stream_read_data(p_stream,
8946                                  p_j2k->m_specific_param.m_decoder.m_header_data, l_marker_size,
8947                                  p_manager) != l_marker_size) {
8948             opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
8949             return OPJ_FALSE;
8950         }
8951
8952         /* Read the marker segment with the correct marker handler */
8953         if (!(*(l_marker_handler->handler))(p_j2k,
8954                                             p_j2k->m_specific_param.m_decoder.m_header_data, l_marker_size, p_manager)) {
8955             opj_event_msg(p_manager, EVT_ERROR,
8956                           "Marker handler function failed to read the marker segment\n");
8957             return OPJ_FALSE;
8958         }
8959
8960         /* Add the marker to the codestream index*/
8961         if (OPJ_FALSE == opj_j2k_add_mhmarker(
8962                     p_j2k->cstr_index,
8963                     l_marker_handler->id,
8964                     (OPJ_UINT32) opj_stream_tell(p_stream) - l_marker_size - 4,
8965                     l_marker_size + 4)) {
8966             opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to add mh marker\n");
8967             return OPJ_FALSE;
8968         }
8969
8970         /* Try to read 2 bytes (the next marker ID) from stream and copy them into the buffer */
8971         if (opj_stream_read_data(p_stream,
8972                                  p_j2k->m_specific_param.m_decoder.m_header_data, 2, p_manager) != 2) {
8973             opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
8974             return OPJ_FALSE;
8975         }
8976
8977         /* read 2 bytes as the new marker ID */
8978         opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,
8979                        &l_current_marker, 2);
8980     }
8981
8982     if (l_has_siz == 0) {
8983         opj_event_msg(p_manager, EVT_ERROR,
8984                       "required SIZ marker not found in main header\n");
8985         return OPJ_FALSE;
8986     }
8987     if (l_has_cod == 0) {
8988         opj_event_msg(p_manager, EVT_ERROR,
8989                       "required COD marker not found in main header\n");
8990         return OPJ_FALSE;
8991     }
8992     if (l_has_qcd == 0) {
8993         opj_event_msg(p_manager, EVT_ERROR,
8994                       "required QCD marker not found in main header\n");
8995         return OPJ_FALSE;
8996     }
8997
8998     if (! opj_j2k_merge_ppm(&(p_j2k->m_cp), p_manager)) {
8999         opj_event_msg(p_manager, EVT_ERROR, "Failed to merge PPM data\n");
9000         return OPJ_FALSE;
9001     }
9002
9003     opj_event_msg(p_manager, EVT_INFO, "Main header has been correctly decoded.\n");
9004
9005     /* Position of the last element if the main header */
9006     p_j2k->cstr_index->main_head_end = (OPJ_UINT32) opj_stream_tell(p_stream) - 2;
9007
9008     /* Next step: read a tile-part header */
9009     p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_TPHSOT;
9010
9011     return OPJ_TRUE;
9012 }
9013
9014 static OPJ_BOOL opj_j2k_exec(opj_j2k_t * p_j2k,
9015                              opj_procedure_list_t * p_procedure_list,
9016                              opj_stream_private_t *p_stream,
9017                              opj_event_mgr_t * p_manager)
9018 {
9019     OPJ_BOOL(** l_procedure)(opj_j2k_t *, opj_stream_private_t *,
9020                              opj_event_mgr_t *) = 00;
9021     OPJ_BOOL l_result = OPJ_TRUE;
9022     OPJ_UINT32 l_nb_proc, i;
9023
9024     /* preconditions*/
9025     assert(p_procedure_list != 00);
9026     assert(p_j2k != 00);
9027     assert(p_stream != 00);
9028     assert(p_manager != 00);
9029
9030     l_nb_proc = opj_procedure_list_get_nb_procedures(p_procedure_list);
9031     l_procedure = (OPJ_BOOL(**)(opj_j2k_t *, opj_stream_private_t *,
9032                                 opj_event_mgr_t *)) opj_procedure_list_get_first_procedure(p_procedure_list);
9033
9034     for (i = 0; i < l_nb_proc; ++i) {
9035         l_result = l_result && ((*l_procedure)(p_j2k, p_stream, p_manager));
9036         ++l_procedure;
9037     }
9038
9039     /* and clear the procedure list at the end.*/
9040     opj_procedure_list_clear(p_procedure_list);
9041     return l_result;
9042 }
9043
9044 /* FIXME DOC*/
9045 static OPJ_BOOL opj_j2k_copy_default_tcp_and_create_tcd(opj_j2k_t * p_j2k,
9046         opj_stream_private_t *p_stream,
9047         opj_event_mgr_t * p_manager
9048                                                        )
9049 {
9050     opj_tcp_t * l_tcp = 00;
9051     opj_tcp_t * l_default_tcp = 00;
9052     OPJ_UINT32 l_nb_tiles;
9053     OPJ_UINT32 i, j;
9054     opj_tccp_t *l_current_tccp = 00;
9055     OPJ_UINT32 l_tccp_size;
9056     OPJ_UINT32 l_mct_size;
9057     opj_image_t * l_image;
9058     OPJ_UINT32 l_mcc_records_size, l_mct_records_size;
9059     opj_mct_data_t * l_src_mct_rec, *l_dest_mct_rec;
9060     opj_simple_mcc_decorrelation_data_t * l_src_mcc_rec, *l_dest_mcc_rec;
9061     OPJ_UINT32 l_offset;
9062
9063     /* preconditions */
9064     assert(p_j2k != 00);
9065     assert(p_stream != 00);
9066     assert(p_manager != 00);
9067
9068     OPJ_UNUSED(p_stream);
9069
9070     l_image = p_j2k->m_private_image;
9071     l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
9072     l_tcp = p_j2k->m_cp.tcps;
9073     l_tccp_size = l_image->numcomps * (OPJ_UINT32)sizeof(opj_tccp_t);
9074     l_default_tcp = p_j2k->m_specific_param.m_decoder.m_default_tcp;
9075     l_mct_size = l_image->numcomps * l_image->numcomps * (OPJ_UINT32)sizeof(
9076                      OPJ_FLOAT32);
9077
9078     /* For each tile */
9079     for (i = 0; i < l_nb_tiles; ++i) {
9080         /* keep the tile-compo coding parameters pointer of the current tile coding parameters*/
9081         l_current_tccp = l_tcp->tccps;
9082         /*Copy default coding parameters into the current tile coding parameters*/
9083         memcpy(l_tcp, l_default_tcp, sizeof(opj_tcp_t));
9084         /* Initialize some values of the current tile coding parameters*/
9085         l_tcp->cod = 0;
9086         l_tcp->ppt = 0;
9087         l_tcp->ppt_data = 00;
9088         l_tcp->m_current_tile_part_number = -1;
9089         /* Remove memory not owned by this tile in case of early error return. */
9090         l_tcp->m_mct_decoding_matrix = 00;
9091         l_tcp->m_nb_max_mct_records = 0;
9092         l_tcp->m_mct_records = 00;
9093         l_tcp->m_nb_max_mcc_records = 0;
9094         l_tcp->m_mcc_records = 00;
9095         /* Reconnect the tile-compo coding parameters pointer to the current tile coding parameters*/
9096         l_tcp->tccps = l_current_tccp;
9097
9098         /* Get the mct_decoding_matrix of the dflt_tile_cp and copy them into the current tile cp*/
9099         if (l_default_tcp->m_mct_decoding_matrix) {
9100             l_tcp->m_mct_decoding_matrix = (OPJ_FLOAT32*)opj_malloc(l_mct_size);
9101             if (! l_tcp->m_mct_decoding_matrix) {
9102                 return OPJ_FALSE;
9103             }
9104             memcpy(l_tcp->m_mct_decoding_matrix, l_default_tcp->m_mct_decoding_matrix,
9105                    l_mct_size);
9106         }
9107
9108         /* Get the mct_record of the dflt_tile_cp and copy them into the current tile cp*/
9109         l_mct_records_size = l_default_tcp->m_nb_max_mct_records * (OPJ_UINT32)sizeof(
9110                                  opj_mct_data_t);
9111         l_tcp->m_mct_records = (opj_mct_data_t*)opj_malloc(l_mct_records_size);
9112         if (! l_tcp->m_mct_records) {
9113             return OPJ_FALSE;
9114         }
9115         memcpy(l_tcp->m_mct_records, l_default_tcp->m_mct_records, l_mct_records_size);
9116
9117         /* Copy the mct record data from dflt_tile_cp to the current tile*/
9118         l_src_mct_rec = l_default_tcp->m_mct_records;
9119         l_dest_mct_rec = l_tcp->m_mct_records;
9120
9121         for (j = 0; j < l_default_tcp->m_nb_mct_records; ++j) {
9122
9123             if (l_src_mct_rec->m_data) {
9124
9125                 l_dest_mct_rec->m_data = (OPJ_BYTE*) opj_malloc(l_src_mct_rec->m_data_size);
9126                 if (! l_dest_mct_rec->m_data) {
9127                     return OPJ_FALSE;
9128                 }
9129                 memcpy(l_dest_mct_rec->m_data, l_src_mct_rec->m_data,
9130                        l_src_mct_rec->m_data_size);
9131             }
9132
9133             ++l_src_mct_rec;
9134             ++l_dest_mct_rec;
9135             /* Update with each pass to free exactly what has been allocated on early return. */
9136             l_tcp->m_nb_max_mct_records += 1;
9137         }
9138
9139         /* Get the mcc_record of the dflt_tile_cp and copy them into the current tile cp*/
9140         l_mcc_records_size = l_default_tcp->m_nb_max_mcc_records * (OPJ_UINT32)sizeof(
9141                                  opj_simple_mcc_decorrelation_data_t);
9142         l_tcp->m_mcc_records = (opj_simple_mcc_decorrelation_data_t*) opj_malloc(
9143                                    l_mcc_records_size);
9144         if (! l_tcp->m_mcc_records) {
9145             return OPJ_FALSE;
9146         }
9147         memcpy(l_tcp->m_mcc_records, l_default_tcp->m_mcc_records, l_mcc_records_size);
9148         l_tcp->m_nb_max_mcc_records = l_default_tcp->m_nb_max_mcc_records;
9149
9150         /* Copy the mcc record data from dflt_tile_cp to the current tile*/
9151         l_src_mcc_rec = l_default_tcp->m_mcc_records;
9152         l_dest_mcc_rec = l_tcp->m_mcc_records;
9153
9154         for (j = 0; j < l_default_tcp->m_nb_max_mcc_records; ++j) {
9155
9156             if (l_src_mcc_rec->m_decorrelation_array) {
9157                 l_offset = (OPJ_UINT32)(l_src_mcc_rec->m_decorrelation_array -
9158                                         l_default_tcp->m_mct_records);
9159                 l_dest_mcc_rec->m_decorrelation_array = l_tcp->m_mct_records + l_offset;
9160             }
9161
9162             if (l_src_mcc_rec->m_offset_array) {
9163                 l_offset = (OPJ_UINT32)(l_src_mcc_rec->m_offset_array -
9164                                         l_default_tcp->m_mct_records);
9165                 l_dest_mcc_rec->m_offset_array = l_tcp->m_mct_records + l_offset;
9166             }
9167
9168             ++l_src_mcc_rec;
9169             ++l_dest_mcc_rec;
9170         }
9171
9172         /* Copy all the dflt_tile_compo_cp to the current tile cp */
9173         memcpy(l_current_tccp, l_default_tcp->tccps, l_tccp_size);
9174
9175         /* Move to next tile cp*/
9176         ++l_tcp;
9177     }
9178
9179     /* Create the current tile decoder*/
9180     p_j2k->m_tcd = opj_tcd_create(OPJ_TRUE);
9181     if (! p_j2k->m_tcd) {
9182         return OPJ_FALSE;
9183     }
9184
9185     if (!opj_tcd_init(p_j2k->m_tcd, l_image, &(p_j2k->m_cp), p_j2k->m_tp)) {
9186         opj_tcd_destroy(p_j2k->m_tcd);
9187         p_j2k->m_tcd = 00;
9188         opj_event_msg(p_manager, EVT_ERROR, "Cannot decode tile, memory error\n");
9189         return OPJ_FALSE;
9190     }
9191
9192     return OPJ_TRUE;
9193 }
9194
9195 static const opj_dec_memory_marker_handler_t * opj_j2k_get_marker_handler(
9196     OPJ_UINT32 p_id)
9197 {
9198     const opj_dec_memory_marker_handler_t *e;
9199     for (e = j2k_memory_marker_handler_tab; e->id != 0; ++e) {
9200         if (e->id == p_id) {
9201             break; /* we find a handler corresponding to the marker ID*/
9202         }
9203     }
9204     return e;
9205 }
9206
9207 void opj_j2k_destroy(opj_j2k_t *p_j2k)
9208 {
9209     if (p_j2k == 00) {
9210         return;
9211     }
9212
9213     if (p_j2k->m_is_decoder) {
9214
9215         if (p_j2k->m_specific_param.m_decoder.m_default_tcp != 00) {
9216             opj_j2k_tcp_destroy(p_j2k->m_specific_param.m_decoder.m_default_tcp);
9217             opj_free(p_j2k->m_specific_param.m_decoder.m_default_tcp);
9218             p_j2k->m_specific_param.m_decoder.m_default_tcp = 00;
9219         }
9220
9221         if (p_j2k->m_specific_param.m_decoder.m_header_data != 00) {
9222             opj_free(p_j2k->m_specific_param.m_decoder.m_header_data);
9223             p_j2k->m_specific_param.m_decoder.m_header_data = 00;
9224             p_j2k->m_specific_param.m_decoder.m_header_data_size = 0;
9225         }
9226
9227         opj_free(p_j2k->m_specific_param.m_decoder.m_comps_indices_to_decode);
9228         p_j2k->m_specific_param.m_decoder.m_comps_indices_to_decode = 00;
9229         p_j2k->m_specific_param.m_decoder.m_numcomps_to_decode = 0;
9230
9231     } else {
9232
9233         if (p_j2k->m_specific_param.m_encoder.m_encoded_tile_data) {
9234             opj_free(p_j2k->m_specific_param.m_encoder.m_encoded_tile_data);
9235             p_j2k->m_specific_param.m_encoder.m_encoded_tile_data = 00;
9236         }
9237
9238         if (p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer) {
9239             opj_free(p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer);
9240             p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer = 00;
9241             p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current = 00;
9242         }
9243
9244         if (p_j2k->m_specific_param.m_encoder.m_header_tile_data) {
9245             opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
9246             p_j2k->m_specific_param.m_encoder.m_header_tile_data = 00;
9247             p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
9248         }
9249     }
9250
9251     opj_tcd_destroy(p_j2k->m_tcd);
9252
9253     opj_j2k_cp_destroy(&(p_j2k->m_cp));
9254     memset(&(p_j2k->m_cp), 0, sizeof(opj_cp_t));
9255
9256     opj_procedure_list_destroy(p_j2k->m_procedure_list);
9257     p_j2k->m_procedure_list = 00;
9258
9259     opj_procedure_list_destroy(p_j2k->m_validation_list);
9260     p_j2k->m_procedure_list = 00;
9261
9262     j2k_destroy_cstr_index(p_j2k->cstr_index);
9263     p_j2k->cstr_index = NULL;
9264
9265     opj_image_destroy(p_j2k->m_private_image);
9266     p_j2k->m_private_image = NULL;
9267
9268     opj_image_destroy(p_j2k->m_output_image);
9269     p_j2k->m_output_image = NULL;
9270
9271     opj_thread_pool_destroy(p_j2k->m_tp);
9272     p_j2k->m_tp = NULL;
9273
9274     opj_free(p_j2k);
9275 }
9276
9277 void j2k_destroy_cstr_index(opj_codestream_index_t *p_cstr_ind)
9278 {
9279     if (p_cstr_ind) {
9280
9281         if (p_cstr_ind->marker) {
9282             opj_free(p_cstr_ind->marker);
9283             p_cstr_ind->marker = NULL;
9284         }
9285
9286         if (p_cstr_ind->tile_index) {
9287             OPJ_UINT32 it_tile = 0;
9288
9289             for (it_tile = 0; it_tile < p_cstr_ind->nb_of_tiles; it_tile++) {
9290
9291                 if (p_cstr_ind->tile_index[it_tile].packet_index) {
9292                     opj_free(p_cstr_ind->tile_index[it_tile].packet_index);
9293                     p_cstr_ind->tile_index[it_tile].packet_index = NULL;
9294                 }
9295
9296                 if (p_cstr_ind->tile_index[it_tile].tp_index) {
9297                     opj_free(p_cstr_ind->tile_index[it_tile].tp_index);
9298                     p_cstr_ind->tile_index[it_tile].tp_index = NULL;
9299                 }
9300
9301                 if (p_cstr_ind->tile_index[it_tile].marker) {
9302                     opj_free(p_cstr_ind->tile_index[it_tile].marker);
9303                     p_cstr_ind->tile_index[it_tile].marker = NULL;
9304
9305                 }
9306             }
9307
9308             opj_free(p_cstr_ind->tile_index);
9309             p_cstr_ind->tile_index = NULL;
9310         }
9311
9312         opj_free(p_cstr_ind);
9313     }
9314 }
9315
9316 static void opj_j2k_tcp_destroy(opj_tcp_t *p_tcp)
9317 {
9318     if (p_tcp == 00) {
9319         return;
9320     }
9321
9322     if (p_tcp->ppt_markers != 00) {
9323         OPJ_UINT32 i;
9324         for (i = 0U; i < p_tcp->ppt_markers_count; ++i) {
9325             if (p_tcp->ppt_markers[i].m_data != NULL) {
9326                 opj_free(p_tcp->ppt_markers[i].m_data);
9327             }
9328         }
9329         p_tcp->ppt_markers_count = 0U;
9330         opj_free(p_tcp->ppt_markers);
9331         p_tcp->ppt_markers = NULL;
9332     }
9333
9334     if (p_tcp->ppt_buffer != 00) {
9335         opj_free(p_tcp->ppt_buffer);
9336         p_tcp->ppt_buffer = 00;
9337     }
9338
9339     if (p_tcp->tccps != 00) {
9340         opj_free(p_tcp->tccps);
9341         p_tcp->tccps = 00;
9342     }
9343
9344     if (p_tcp->m_mct_coding_matrix != 00) {
9345         opj_free(p_tcp->m_mct_coding_matrix);
9346         p_tcp->m_mct_coding_matrix = 00;
9347     }
9348
9349     if (p_tcp->m_mct_decoding_matrix != 00) {
9350         opj_free(p_tcp->m_mct_decoding_matrix);
9351         p_tcp->m_mct_decoding_matrix = 00;
9352     }
9353
9354     if (p_tcp->m_mcc_records) {
9355         opj_free(p_tcp->m_mcc_records);
9356         p_tcp->m_mcc_records = 00;
9357         p_tcp->m_nb_max_mcc_records = 0;
9358         p_tcp->m_nb_mcc_records = 0;
9359     }
9360
9361     if (p_tcp->m_mct_records) {
9362         opj_mct_data_t * l_mct_data = p_tcp->m_mct_records;
9363         OPJ_UINT32 i;
9364
9365         for (i = 0; i < p_tcp->m_nb_mct_records; ++i) {
9366             if (l_mct_data->m_data) {
9367                 opj_free(l_mct_data->m_data);
9368                 l_mct_data->m_data = 00;
9369             }
9370
9371             ++l_mct_data;
9372         }
9373
9374         opj_free(p_tcp->m_mct_records);
9375         p_tcp->m_mct_records = 00;
9376     }
9377
9378     if (p_tcp->mct_norms != 00) {
9379         opj_free(p_tcp->mct_norms);
9380         p_tcp->mct_norms = 00;
9381     }
9382
9383     opj_j2k_tcp_data_destroy(p_tcp);
9384
9385 }
9386
9387 static void opj_j2k_tcp_data_destroy(opj_tcp_t *p_tcp)
9388 {
9389     if (p_tcp->m_data) {
9390         opj_free(p_tcp->m_data);
9391         p_tcp->m_data = NULL;
9392         p_tcp->m_data_size = 0;
9393     }
9394 }
9395
9396 static void opj_j2k_cp_destroy(opj_cp_t *p_cp)
9397 {
9398     OPJ_UINT32 l_nb_tiles;
9399     opj_tcp_t * l_current_tile = 00;
9400
9401     if (p_cp == 00) {
9402         return;
9403     }
9404     if (p_cp->tcps != 00) {
9405         OPJ_UINT32 i;
9406         l_current_tile = p_cp->tcps;
9407         l_nb_tiles = p_cp->th * p_cp->tw;
9408
9409         for (i = 0U; i < l_nb_tiles; ++i) {
9410             opj_j2k_tcp_destroy(l_current_tile);
9411             ++l_current_tile;
9412         }
9413         opj_free(p_cp->tcps);
9414         p_cp->tcps = 00;
9415     }
9416     if (p_cp->ppm_markers != 00) {
9417         OPJ_UINT32 i;
9418         for (i = 0U; i < p_cp->ppm_markers_count; ++i) {
9419             if (p_cp->ppm_markers[i].m_data != NULL) {
9420                 opj_free(p_cp->ppm_markers[i].m_data);
9421             }
9422         }
9423         p_cp->ppm_markers_count = 0U;
9424         opj_free(p_cp->ppm_markers);
9425         p_cp->ppm_markers = NULL;
9426     }
9427     opj_free(p_cp->ppm_buffer);
9428     p_cp->ppm_buffer = 00;
9429     p_cp->ppm_data =
9430         NULL; /* ppm_data belongs to the allocated buffer pointed by ppm_buffer */
9431     opj_free(p_cp->comment);
9432     p_cp->comment = 00;
9433     if (! p_cp->m_is_decoder) {
9434         opj_free(p_cp->m_specific_param.m_enc.m_matrice);
9435         p_cp->m_specific_param.m_enc.m_matrice = 00;
9436     }
9437 }
9438
9439 static OPJ_BOOL opj_j2k_need_nb_tile_parts_correction(opj_stream_private_t
9440         *p_stream, OPJ_UINT32 tile_no, OPJ_BOOL* p_correction_needed,
9441         opj_event_mgr_t * p_manager)
9442 {
9443     OPJ_BYTE   l_header_data[10];
9444     OPJ_OFF_T  l_stream_pos_backup;
9445     OPJ_UINT32 l_current_marker;
9446     OPJ_UINT32 l_marker_size;
9447     OPJ_UINT32 l_tile_no, l_tot_len, l_current_part, l_num_parts;
9448
9449     /* initialize to no correction needed */
9450     *p_correction_needed = OPJ_FALSE;
9451
9452     if (!opj_stream_has_seek(p_stream)) {
9453         /* We can't do much in this case, seek is needed */
9454         return OPJ_TRUE;
9455     }
9456
9457     l_stream_pos_backup = opj_stream_tell(p_stream);
9458     if (l_stream_pos_backup == -1) {
9459         /* let's do nothing */
9460         return OPJ_TRUE;
9461     }
9462
9463     for (;;) {
9464         /* Try to read 2 bytes (the next marker ID) from stream and copy them into the buffer */
9465         if (opj_stream_read_data(p_stream, l_header_data, 2, p_manager) != 2) {
9466             /* assume all is OK */
9467             if (! opj_stream_seek(p_stream, l_stream_pos_backup, p_manager)) {
9468                 return OPJ_FALSE;
9469             }
9470             return OPJ_TRUE;
9471         }
9472
9473         /* Read 2 bytes from buffer as the new marker ID */
9474         opj_read_bytes(l_header_data, &l_current_marker, 2);
9475
9476         if (l_current_marker != J2K_MS_SOT) {
9477             /* assume all is OK */
9478             if (! opj_stream_seek(p_stream, l_stream_pos_backup, p_manager)) {
9479                 return OPJ_FALSE;
9480             }
9481             return OPJ_TRUE;
9482         }
9483
9484         /* Try to read 2 bytes (the marker size) from stream and copy them into the buffer */
9485         if (opj_stream_read_data(p_stream, l_header_data, 2, p_manager) != 2) {
9486             opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
9487             return OPJ_FALSE;
9488         }
9489
9490         /* Read 2 bytes from the buffer as the marker size */
9491         opj_read_bytes(l_header_data, &l_marker_size, 2);
9492
9493         /* Check marker size for SOT Marker */
9494         if (l_marker_size != 10) {
9495             opj_event_msg(p_manager, EVT_ERROR, "Inconsistent marker size\n");
9496             return OPJ_FALSE;
9497         }
9498         l_marker_size -= 2;
9499
9500         if (opj_stream_read_data(p_stream, l_header_data, l_marker_size,
9501                                  p_manager) != l_marker_size) {
9502             opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
9503             return OPJ_FALSE;
9504         }
9505
9506         if (! opj_j2k_get_sot_values(l_header_data, l_marker_size, &l_tile_no,
9507                                      &l_tot_len, &l_current_part, &l_num_parts, p_manager)) {
9508             return OPJ_FALSE;
9509         }
9510
9511         if (l_tile_no == tile_no) {
9512             /* we found what we were looking for */
9513             break;
9514         }
9515
9516         if (l_tot_len < 14U) {
9517             /* last SOT until EOC or invalid Psot value */
9518             /* assume all is OK */
9519             if (! opj_stream_seek(p_stream, l_stream_pos_backup, p_manager)) {
9520                 return OPJ_FALSE;
9521             }
9522             return OPJ_TRUE;
9523         }
9524         l_tot_len -= 12U;
9525         /* look for next SOT marker */
9526         if (opj_stream_skip(p_stream, (OPJ_OFF_T)(l_tot_len),
9527                             p_manager) != (OPJ_OFF_T)(l_tot_len)) {
9528             /* assume all is OK */
9529             if (! opj_stream_seek(p_stream, l_stream_pos_backup, p_manager)) {
9530                 return OPJ_FALSE;
9531             }
9532             return OPJ_TRUE;
9533         }
9534     }
9535
9536     /* check for correction */
9537     if (l_current_part == l_num_parts) {
9538         *p_correction_needed = OPJ_TRUE;
9539     }
9540
9541     if (! opj_stream_seek(p_stream, l_stream_pos_backup, p_manager)) {
9542         return OPJ_FALSE;
9543     }
9544     return OPJ_TRUE;
9545 }
9546
9547 OPJ_BOOL opj_j2k_read_tile_header(opj_j2k_t * p_j2k,
9548                                   OPJ_UINT32 * p_tile_index,
9549                                   OPJ_UINT32 * p_data_size,
9550                                   OPJ_INT32 * p_tile_x0, OPJ_INT32 * p_tile_y0,
9551                                   OPJ_INT32 * p_tile_x1, OPJ_INT32 * p_tile_y1,
9552                                   OPJ_UINT32 * p_nb_comps,
9553                                   OPJ_BOOL * p_go_on,
9554                                   opj_stream_private_t *p_stream,
9555                                   opj_event_mgr_t * p_manager)
9556 {
9557     OPJ_UINT32 l_current_marker = J2K_MS_SOT;
9558     OPJ_UINT32 l_marker_size;
9559     const opj_dec_memory_marker_handler_t * l_marker_handler = 00;
9560     opj_tcp_t * l_tcp = NULL;
9561     const OPJ_UINT32 l_nb_tiles = p_j2k->m_cp.tw * p_j2k->m_cp.th;
9562
9563     /* preconditions */
9564     assert(p_stream != 00);
9565     assert(p_j2k != 00);
9566     assert(p_manager != 00);
9567
9568     /* Reach the End Of Codestream ?*/
9569     if (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_EOC) {
9570         l_current_marker = J2K_MS_EOC;
9571     }
9572     /* We need to encounter a SOT marker (a new tile-part header) */
9573     else if (p_j2k->m_specific_param.m_decoder.m_state != J2K_STATE_TPHSOT) {
9574         return OPJ_FALSE;
9575     }
9576
9577     /* Read into the codestream until reach the EOC or ! can_decode ??? FIXME */
9578     while ((!p_j2k->m_specific_param.m_decoder.m_can_decode) &&
9579             (l_current_marker != J2K_MS_EOC)) {
9580
9581         /* Try to read until the Start Of Data is detected */
9582         while (l_current_marker != J2K_MS_SOD) {
9583
9584             if (opj_stream_get_number_byte_left(p_stream) == 0) {
9585                 p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_NEOC;
9586                 break;
9587             }
9588
9589             /* Try to read 2 bytes (the marker size) from stream and copy them into the buffer */
9590             if (opj_stream_read_data(p_stream,
9591                                      p_j2k->m_specific_param.m_decoder.m_header_data, 2, p_manager) != 2) {
9592                 opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
9593                 return OPJ_FALSE;
9594             }
9595
9596             /* Read 2 bytes from the buffer as the marker size */
9597             opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data, &l_marker_size,
9598                            2);
9599
9600             /* Check marker size (does not include marker ID but includes marker size) */
9601             if (l_marker_size < 2) {
9602                 opj_event_msg(p_manager, EVT_ERROR, "Inconsistent marker size\n");
9603                 return OPJ_FALSE;
9604             }
9605
9606             /* cf. https://code.google.com/p/openjpeg/issues/detail?id=226 */
9607             if (l_current_marker == 0x8080 &&
9608                     opj_stream_get_number_byte_left(p_stream) == 0) {
9609                 p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_NEOC;
9610                 break;
9611             }
9612
9613             /* Why this condition? FIXME */
9614             if (p_j2k->m_specific_param.m_decoder.m_state & J2K_STATE_TPH) {
9615                 p_j2k->m_specific_param.m_decoder.m_sot_length -= (l_marker_size + 2);
9616             }
9617             l_marker_size -= 2; /* Subtract the size of the marker ID already read */
9618
9619             /* Get the marker handler from the marker ID */
9620             l_marker_handler = opj_j2k_get_marker_handler(l_current_marker);
9621
9622             /* Check if the marker is known and if it is the right place to find it */
9623             if (!(p_j2k->m_specific_param.m_decoder.m_state & l_marker_handler->states)) {
9624                 opj_event_msg(p_manager, EVT_ERROR,
9625                               "Marker is not compliant with its position\n");
9626                 return OPJ_FALSE;
9627             }
9628             /* FIXME manage case of unknown marker as in the main header ? */
9629
9630             /* Check if the marker size is compatible with the header data size */
9631             if (l_marker_size > p_j2k->m_specific_param.m_decoder.m_header_data_size) {
9632                 OPJ_BYTE *new_header_data = NULL;
9633                 /* If we are here, this means we consider this marker as known & we will read it */
9634                 /* Check enough bytes left in stream before allocation */
9635                 if ((OPJ_OFF_T)l_marker_size >  opj_stream_get_number_byte_left(p_stream)) {
9636                     opj_event_msg(p_manager, EVT_ERROR,
9637                                   "Marker size inconsistent with stream length\n");
9638                     return OPJ_FALSE;
9639                 }
9640                 new_header_data = (OPJ_BYTE *) opj_realloc(
9641                                       p_j2k->m_specific_param.m_decoder.m_header_data, l_marker_size);
9642                 if (! new_header_data) {
9643                     opj_free(p_j2k->m_specific_param.m_decoder.m_header_data);
9644                     p_j2k->m_specific_param.m_decoder.m_header_data = NULL;
9645                     p_j2k->m_specific_param.m_decoder.m_header_data_size = 0;
9646                     opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read header\n");
9647                     return OPJ_FALSE;
9648                 }
9649                 p_j2k->m_specific_param.m_decoder.m_header_data = new_header_data;
9650                 p_j2k->m_specific_param.m_decoder.m_header_data_size = l_marker_size;
9651             }
9652
9653             /* Try to read the rest of the marker segment from stream and copy them into the buffer */
9654             if (opj_stream_read_data(p_stream,
9655                                      p_j2k->m_specific_param.m_decoder.m_header_data, l_marker_size,
9656                                      p_manager) != l_marker_size) {
9657                 opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
9658                 return OPJ_FALSE;
9659             }
9660
9661             if (!l_marker_handler->handler) {
9662                 /* See issue #175 */
9663                 opj_event_msg(p_manager, EVT_ERROR, "Not sure how that happened.\n");
9664                 return OPJ_FALSE;
9665             }
9666             /* Read the marker segment with the correct marker handler */
9667             if (!(*(l_marker_handler->handler))(p_j2k,
9668                                                 p_j2k->m_specific_param.m_decoder.m_header_data, l_marker_size, p_manager)) {
9669                 opj_event_msg(p_manager, EVT_ERROR,
9670                               "Fail to read the current marker segment (%#x)\n", l_current_marker);
9671                 return OPJ_FALSE;
9672             }
9673
9674             /* Add the marker to the codestream index*/
9675             if (OPJ_FALSE == opj_j2k_add_tlmarker(p_j2k->m_current_tile_number,
9676                                                   p_j2k->cstr_index,
9677                                                   l_marker_handler->id,
9678                                                   (OPJ_UINT32) opj_stream_tell(p_stream) - l_marker_size - 4,
9679                                                   l_marker_size + 4)) {
9680                 opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to add tl marker\n");
9681                 return OPJ_FALSE;
9682             }
9683
9684             /* Keep the position of the last SOT marker read */
9685             if (l_marker_handler->id == J2K_MS_SOT) {
9686                 OPJ_UINT32 sot_pos = (OPJ_UINT32) opj_stream_tell(p_stream) - l_marker_size - 4
9687                                      ;
9688                 if (sot_pos > p_j2k->m_specific_param.m_decoder.m_last_sot_read_pos) {
9689                     p_j2k->m_specific_param.m_decoder.m_last_sot_read_pos = sot_pos;
9690                 }
9691             }
9692
9693             if (p_j2k->m_specific_param.m_decoder.m_skip_data) {
9694                 /* Skip the rest of the tile part header*/
9695                 if (opj_stream_skip(p_stream, p_j2k->m_specific_param.m_decoder.m_sot_length,
9696                                     p_manager) != p_j2k->m_specific_param.m_decoder.m_sot_length) {
9697                     opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
9698                     return OPJ_FALSE;
9699                 }
9700                 l_current_marker = J2K_MS_SOD; /* Normally we reached a SOD */
9701             } else {
9702                 /* Try to read 2 bytes (the next marker ID) from stream and copy them into the buffer*/
9703                 if (opj_stream_read_data(p_stream,
9704                                          p_j2k->m_specific_param.m_decoder.m_header_data, 2, p_manager) != 2) {
9705                     opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
9706                     return OPJ_FALSE;
9707                 }
9708                 /* Read 2 bytes from the buffer as the new marker ID */
9709                 opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,
9710                                &l_current_marker, 2);
9711             }
9712         }
9713         if (opj_stream_get_number_byte_left(p_stream) == 0
9714                 && p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_NEOC) {
9715             break;
9716         }
9717
9718         /* If we didn't skip data before, we need to read the SOD marker*/
9719         if (! p_j2k->m_specific_param.m_decoder.m_skip_data) {
9720             /* Try to read the SOD marker and skip data ? FIXME */
9721             if (! opj_j2k_read_sod(p_j2k, p_stream, p_manager)) {
9722                 return OPJ_FALSE;
9723             }
9724             if (p_j2k->m_specific_param.m_decoder.m_can_decode &&
9725                     !p_j2k->m_specific_param.m_decoder.m_nb_tile_parts_correction_checked) {
9726                 /* Issue 254 */
9727                 OPJ_BOOL l_correction_needed;
9728
9729                 p_j2k->m_specific_param.m_decoder.m_nb_tile_parts_correction_checked = 1;
9730                 if (!opj_j2k_need_nb_tile_parts_correction(p_stream,
9731                         p_j2k->m_current_tile_number, &l_correction_needed, p_manager)) {
9732                     opj_event_msg(p_manager, EVT_ERROR,
9733                                   "opj_j2k_apply_nb_tile_parts_correction error\n");
9734                     return OPJ_FALSE;
9735                 }
9736                 if (l_correction_needed) {
9737                     OPJ_UINT32 l_tile_no;
9738
9739                     p_j2k->m_specific_param.m_decoder.m_can_decode = 0;
9740                     p_j2k->m_specific_param.m_decoder.m_nb_tile_parts_correction = 1;
9741                     /* correct tiles */
9742                     for (l_tile_no = 0U; l_tile_no < l_nb_tiles; ++l_tile_no) {
9743                         if (p_j2k->m_cp.tcps[l_tile_no].m_nb_tile_parts != 0U) {
9744                             p_j2k->m_cp.tcps[l_tile_no].m_nb_tile_parts += 1;
9745                         }
9746                     }
9747                     opj_event_msg(p_manager, EVT_WARNING,
9748                                   "Non conformant codestream TPsot==TNsot.\n");
9749                 }
9750             }
9751         } else {
9752             /* Indicate we will try to read a new tile-part header*/
9753             p_j2k->m_specific_param.m_decoder.m_skip_data = 0;
9754             p_j2k->m_specific_param.m_decoder.m_can_decode = 0;
9755             p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_TPHSOT;
9756         }
9757
9758         if (! p_j2k->m_specific_param.m_decoder.m_can_decode) {
9759             /* Try to read 2 bytes (the next marker ID) from stream and copy them into the buffer */
9760             if (opj_stream_read_data(p_stream,
9761                                      p_j2k->m_specific_param.m_decoder.m_header_data, 2, p_manager) != 2) {
9762
9763                 /* Deal with likely non conformant SPOT6 files, where the last */
9764                 /* row of tiles have TPsot == 0 and TNsot == 0, and missing EOC, */
9765                 /* but no other tile-parts were found. */
9766                 if (p_j2k->m_current_tile_number + 1 == l_nb_tiles) {
9767                     OPJ_UINT32 l_tile_no;
9768                     for (l_tile_no = 0U; l_tile_no < l_nb_tiles; ++l_tile_no) {
9769                         if (p_j2k->m_cp.tcps[l_tile_no].m_current_tile_part_number == 0 &&
9770                                 p_j2k->m_cp.tcps[l_tile_no].m_nb_tile_parts == 0) {
9771                             break;
9772                         }
9773                     }
9774                     if (l_tile_no < l_nb_tiles) {
9775                         opj_event_msg(p_manager, EVT_INFO,
9776                                       "Tile %u has TPsot == 0 and TNsot == 0, "
9777                                       "but no other tile-parts were found. "
9778                                       "EOC is also missing.\n",
9779                                       l_tile_no);
9780                         p_j2k->m_current_tile_number = l_tile_no;
9781                         l_current_marker = J2K_MS_EOC;
9782                         p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_EOC;
9783                         break;
9784                     }
9785                 }
9786
9787                 opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
9788                 return OPJ_FALSE;
9789             }
9790
9791             /* Read 2 bytes from buffer as the new marker ID */
9792             opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,
9793                            &l_current_marker, 2);
9794         }
9795     }
9796
9797     /* Current marker is the EOC marker ?*/
9798     if (l_current_marker == J2K_MS_EOC) {
9799         if (p_j2k->m_specific_param.m_decoder.m_state != J2K_STATE_EOC) {
9800             p_j2k->m_current_tile_number = 0;
9801             p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_EOC;
9802         }
9803     }
9804
9805     /* Deal with tiles that have a single tile-part with TPsot == 0 and TNsot == 0 */
9806     if (! p_j2k->m_specific_param.m_decoder.m_can_decode) {
9807         l_tcp = p_j2k->m_cp.tcps + p_j2k->m_current_tile_number;
9808
9809         while ((p_j2k->m_current_tile_number < l_nb_tiles) && (l_tcp->m_data == 00)) {
9810             ++p_j2k->m_current_tile_number;
9811             ++l_tcp;
9812         }
9813
9814         if (p_j2k->m_current_tile_number == l_nb_tiles) {
9815             *p_go_on = OPJ_FALSE;
9816             return OPJ_TRUE;
9817         }
9818     }
9819
9820     if (! opj_j2k_merge_ppt(p_j2k->m_cp.tcps + p_j2k->m_current_tile_number,
9821                             p_manager)) {
9822         opj_event_msg(p_manager, EVT_ERROR, "Failed to merge PPT data\n");
9823         return OPJ_FALSE;
9824     }
9825     /*FIXME ???*/
9826     if (! opj_tcd_init_decode_tile(p_j2k->m_tcd, p_j2k->m_current_tile_number,
9827                                    p_manager)) {
9828         opj_event_msg(p_manager, EVT_ERROR, "Cannot decode tile, memory error\n");
9829         return OPJ_FALSE;
9830     }
9831
9832     opj_event_msg(p_manager, EVT_INFO, "Header of tile %d / %d has been read.\n",
9833                   p_j2k->m_current_tile_number + 1, (p_j2k->m_cp.th * p_j2k->m_cp.tw));
9834
9835     *p_tile_index = p_j2k->m_current_tile_number;
9836     *p_go_on = OPJ_TRUE;
9837     if (p_data_size) {
9838         /* For internal use in j2k.c, we don't need this */
9839         /* This is just needed for folks using the opj_read_tile_header() / opj_decode_tile_data() combo */
9840         *p_data_size = opj_tcd_get_decoded_tile_size(p_j2k->m_tcd, OPJ_FALSE);
9841         if (*p_data_size == UINT_MAX) {
9842             return OPJ_FALSE;
9843         }
9844     }
9845     *p_tile_x0 = p_j2k->m_tcd->tcd_image->tiles->x0;
9846     *p_tile_y0 = p_j2k->m_tcd->tcd_image->tiles->y0;
9847     *p_tile_x1 = p_j2k->m_tcd->tcd_image->tiles->x1;
9848     *p_tile_y1 = p_j2k->m_tcd->tcd_image->tiles->y1;
9849     *p_nb_comps = p_j2k->m_tcd->tcd_image->tiles->numcomps;
9850
9851     p_j2k->m_specific_param.m_decoder.m_state |= J2K_STATE_DATA;
9852
9853     return OPJ_TRUE;
9854 }
9855
9856 OPJ_BOOL opj_j2k_decode_tile(opj_j2k_t * p_j2k,
9857                              OPJ_UINT32 p_tile_index,
9858                              OPJ_BYTE * p_data,
9859                              OPJ_UINT32 p_data_size,
9860                              opj_stream_private_t *p_stream,
9861                              opj_event_mgr_t * p_manager)
9862 {
9863     OPJ_UINT32 l_current_marker;
9864     OPJ_BYTE l_data [2];
9865     opj_tcp_t * l_tcp;
9866     opj_image_t* l_image_for_bounds;
9867
9868     /* preconditions */
9869     assert(p_stream != 00);
9870     assert(p_j2k != 00);
9871     assert(p_manager != 00);
9872
9873     if (!(p_j2k->m_specific_param.m_decoder.m_state & J2K_STATE_DATA)
9874             || (p_tile_index != p_j2k->m_current_tile_number)) {
9875         return OPJ_FALSE;
9876     }
9877
9878     l_tcp = &(p_j2k->m_cp.tcps[p_tile_index]);
9879     if (! l_tcp->m_data) {
9880         opj_j2k_tcp_destroy(l_tcp);
9881         return OPJ_FALSE;
9882     }
9883
9884     /* When using the opj_read_tile_header / opj_decode_tile_data API */
9885     /* such as in test_tile_decoder, m_output_image is NULL, so fall back */
9886     /* to the full image dimension. This is a bit surprising that */
9887     /* opj_set_decode_area() is only used to determine intersecting tiles, */
9888     /* but full tile decoding is done */
9889     l_image_for_bounds = p_j2k->m_output_image ? p_j2k->m_output_image :
9890                          p_j2k->m_private_image;
9891     if (! opj_tcd_decode_tile(p_j2k->m_tcd,
9892                               l_image_for_bounds->x0,
9893                               l_image_for_bounds->y0,
9894                               l_image_for_bounds->x1,
9895                               l_image_for_bounds->y1,
9896                               p_j2k->m_specific_param.m_decoder.m_numcomps_to_decode,
9897                               p_j2k->m_specific_param.m_decoder.m_comps_indices_to_decode,
9898                               l_tcp->m_data,
9899                               l_tcp->m_data_size,
9900                               p_tile_index,
9901                               p_j2k->cstr_index, p_manager)) {
9902         opj_j2k_tcp_destroy(l_tcp);
9903         p_j2k->m_specific_param.m_decoder.m_state |= J2K_STATE_ERR;
9904         opj_event_msg(p_manager, EVT_ERROR, "Failed to decode.\n");
9905         return OPJ_FALSE;
9906     }
9907
9908     /* p_data can be set to NULL when the call will take care of using */
9909     /* itself the TCD data. This is typically the case for whole single */
9910     /* tile decoding optimization. */
9911     if (p_data != NULL) {
9912         if (! opj_tcd_update_tile_data(p_j2k->m_tcd, p_data, p_data_size)) {
9913             return OPJ_FALSE;
9914         }
9915
9916         /* To avoid to destroy the tcp which can be useful when we try to decode a tile decoded before (cf j2k_random_tile_access)
9917         * we destroy just the data which will be re-read in read_tile_header*/
9918         /*opj_j2k_tcp_destroy(l_tcp);
9919         p_j2k->m_tcd->tcp = 0;*/
9920         opj_j2k_tcp_data_destroy(l_tcp);
9921     }
9922
9923     p_j2k->m_specific_param.m_decoder.m_can_decode = 0;
9924     p_j2k->m_specific_param.m_decoder.m_state &= (~(OPJ_UINT32)J2K_STATE_DATA);
9925
9926     if (opj_stream_get_number_byte_left(p_stream) == 0
9927             && p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_NEOC) {
9928         return OPJ_TRUE;
9929     }
9930
9931     if (p_j2k->m_specific_param.m_decoder.m_state != J2K_STATE_EOC) {
9932         if (opj_stream_read_data(p_stream, l_data, 2, p_manager) != 2) {
9933             opj_event_msg(p_manager, p_j2k->m_cp.strict ? EVT_ERROR : EVT_WARNING,
9934                           "Stream too short\n");
9935             return p_j2k->m_cp.strict ? OPJ_FALSE : OPJ_TRUE;
9936         }
9937         opj_read_bytes(l_data, &l_current_marker, 2);
9938
9939         if (l_current_marker == J2K_MS_EOC) {
9940             p_j2k->m_current_tile_number = 0;
9941             p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_EOC;
9942         } else if (l_current_marker != J2K_MS_SOT) {
9943             if (opj_stream_get_number_byte_left(p_stream) == 0) {
9944                 p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_NEOC;
9945                 opj_event_msg(p_manager, EVT_WARNING, "Stream does not end with EOC\n");
9946                 return OPJ_TRUE;
9947             }
9948             opj_event_msg(p_manager, EVT_ERROR, "Stream too short, expected SOT\n");
9949             return OPJ_FALSE;
9950         }
9951     }
9952
9953     return OPJ_TRUE;
9954 }
9955
9956 static OPJ_BOOL opj_j2k_update_image_data(opj_tcd_t * p_tcd,
9957         opj_image_t* p_output_image)
9958 {
9959     OPJ_UINT32 i, j;
9960     OPJ_UINT32 l_width_src, l_height_src;
9961     OPJ_UINT32 l_width_dest, l_height_dest;
9962     OPJ_INT32 l_offset_x0_src, l_offset_y0_src, l_offset_x1_src, l_offset_y1_src;
9963     OPJ_SIZE_T l_start_offset_src;
9964     OPJ_UINT32 l_start_x_dest, l_start_y_dest;
9965     OPJ_UINT32 l_x0_dest, l_y0_dest, l_x1_dest, l_y1_dest;
9966     OPJ_SIZE_T l_start_offset_dest;
9967
9968     opj_image_comp_t * l_img_comp_src = 00;
9969     opj_image_comp_t * l_img_comp_dest = 00;
9970
9971     opj_tcd_tilecomp_t * l_tilec = 00;
9972     opj_image_t * l_image_src = 00;
9973     OPJ_INT32 * l_dest_ptr;
9974
9975     l_tilec = p_tcd->tcd_image->tiles->comps;
9976     l_image_src = p_tcd->image;
9977     l_img_comp_src = l_image_src->comps;
9978
9979     l_img_comp_dest = p_output_image->comps;
9980
9981     for (i = 0; i < l_image_src->numcomps;
9982             i++, ++l_img_comp_dest, ++l_img_comp_src,  ++l_tilec) {
9983         OPJ_INT32 res_x0, res_x1, res_y0, res_y1;
9984         OPJ_UINT32 src_data_stride;
9985         const OPJ_INT32* p_src_data;
9986
9987         /* Copy info from decoded comp image to output image */
9988         l_img_comp_dest->resno_decoded = l_img_comp_src->resno_decoded;
9989
9990         if (p_tcd->whole_tile_decoding) {
9991             opj_tcd_resolution_t* l_res = l_tilec->resolutions +
9992                                           l_img_comp_src->resno_decoded;
9993             res_x0 = l_res->x0;
9994             res_y0 = l_res->y0;
9995             res_x1 = l_res->x1;
9996             res_y1 = l_res->y1;
9997             src_data_stride = (OPJ_UINT32)(
9998                                   l_tilec->resolutions[l_tilec->minimum_num_resolutions - 1].x1 -
9999                                   l_tilec->resolutions[l_tilec->minimum_num_resolutions - 1].x0);
10000             p_src_data = l_tilec->data;
10001         } else {
10002             opj_tcd_resolution_t* l_res = l_tilec->resolutions +
10003                                           l_img_comp_src->resno_decoded;
10004             res_x0 = (OPJ_INT32)l_res->win_x0;
10005             res_y0 = (OPJ_INT32)l_res->win_y0;
10006             res_x1 = (OPJ_INT32)l_res->win_x1;
10007             res_y1 = (OPJ_INT32)l_res->win_y1;
10008             src_data_stride = l_res->win_x1 - l_res->win_x0;
10009             p_src_data = l_tilec->data_win;
10010         }
10011
10012         if (p_src_data == NULL) {
10013             /* Happens for partial component decoding */
10014             continue;
10015         }
10016
10017         l_width_src = (OPJ_UINT32)(res_x1 - res_x0);
10018         l_height_src = (OPJ_UINT32)(res_y1 - res_y0);
10019
10020
10021         /* Current tile component size*/
10022         /*if (i == 0) {
10023         fprintf(stdout, "SRC: l_res_x0=%d, l_res_x1=%d, l_res_y0=%d, l_res_y1=%d\n",
10024                         res_x0, res_x1, res_y0, res_y1);
10025         }*/
10026
10027
10028         /* Border of the current output component*/
10029         l_x0_dest = opj_uint_ceildivpow2(l_img_comp_dest->x0, l_img_comp_dest->factor);
10030         l_y0_dest = opj_uint_ceildivpow2(l_img_comp_dest->y0, l_img_comp_dest->factor);
10031         l_x1_dest = l_x0_dest +
10032                     l_img_comp_dest->w; /* can't overflow given that image->x1 is uint32 */
10033         l_y1_dest = l_y0_dest + l_img_comp_dest->h;
10034
10035         /*if (i == 0) {
10036         fprintf(stdout, "DEST: l_x0_dest=%d, l_x1_dest=%d, l_y0_dest=%d, l_y1_dest=%d (%d)\n",
10037                         l_x0_dest, l_x1_dest, l_y0_dest, l_y1_dest, l_img_comp_dest->factor );
10038         }*/
10039
10040         /*-----*/
10041         /* Compute the area (l_offset_x0_src, l_offset_y0_src, l_offset_x1_src, l_offset_y1_src)
10042          * of the input buffer (decoded tile component) which will be move
10043          * in the output buffer. Compute the area of the output buffer (l_start_x_dest,
10044          * l_start_y_dest, l_width_dest, l_height_dest)  which will be modified
10045          * by this input area.
10046          * */
10047         assert(res_x0 >= 0);
10048         assert(res_x1 >= 0);
10049         if (l_x0_dest < (OPJ_UINT32)res_x0) {
10050             l_start_x_dest = (OPJ_UINT32)res_x0 - l_x0_dest;
10051             l_offset_x0_src = 0;
10052
10053             if (l_x1_dest >= (OPJ_UINT32)res_x1) {
10054                 l_width_dest = l_width_src;
10055                 l_offset_x1_src = 0;
10056             } else {
10057                 l_width_dest = l_x1_dest - (OPJ_UINT32)res_x0 ;
10058                 l_offset_x1_src = (OPJ_INT32)(l_width_src - l_width_dest);
10059             }
10060         } else {
10061             l_start_x_dest = 0U;
10062             l_offset_x0_src = (OPJ_INT32)l_x0_dest - res_x0;
10063
10064             if (l_x1_dest >= (OPJ_UINT32)res_x1) {
10065                 l_width_dest = l_width_src - (OPJ_UINT32)l_offset_x0_src;
10066                 l_offset_x1_src = 0;
10067             } else {
10068                 l_width_dest = l_img_comp_dest->w ;
10069                 l_offset_x1_src = res_x1 - (OPJ_INT32)l_x1_dest;
10070             }
10071         }
10072
10073         if (l_y0_dest < (OPJ_UINT32)res_y0) {
10074             l_start_y_dest = (OPJ_UINT32)res_y0 - l_y0_dest;
10075             l_offset_y0_src = 0;
10076
10077             if (l_y1_dest >= (OPJ_UINT32)res_y1) {
10078                 l_height_dest = l_height_src;
10079                 l_offset_y1_src = 0;
10080             } else {
10081                 l_height_dest = l_y1_dest - (OPJ_UINT32)res_y0 ;
10082                 l_offset_y1_src = (OPJ_INT32)(l_height_src - l_height_dest);
10083             }
10084         } else {
10085             l_start_y_dest = 0U;
10086             l_offset_y0_src = (OPJ_INT32)l_y0_dest - res_y0;
10087
10088             if (l_y1_dest >= (OPJ_UINT32)res_y1) {
10089                 l_height_dest = l_height_src - (OPJ_UINT32)l_offset_y0_src;
10090                 l_offset_y1_src = 0;
10091             } else {
10092                 l_height_dest = l_img_comp_dest->h ;
10093                 l_offset_y1_src = res_y1 - (OPJ_INT32)l_y1_dest;
10094             }
10095         }
10096
10097         if ((l_offset_x0_src < 0) || (l_offset_y0_src < 0) || (l_offset_x1_src < 0) ||
10098                 (l_offset_y1_src < 0)) {
10099             return OPJ_FALSE;
10100         }
10101         /* testcase 2977.pdf.asan.67.2198 */
10102         if ((OPJ_INT32)l_width_dest < 0 || (OPJ_INT32)l_height_dest < 0) {
10103             return OPJ_FALSE;
10104         }
10105         /*-----*/
10106
10107         /* Compute the input buffer offset */
10108         l_start_offset_src = (OPJ_SIZE_T)l_offset_x0_src + (OPJ_SIZE_T)l_offset_y0_src
10109                              * (OPJ_SIZE_T)src_data_stride;
10110
10111         /* Compute the output buffer offset */
10112         l_start_offset_dest = (OPJ_SIZE_T)l_start_x_dest + (OPJ_SIZE_T)l_start_y_dest
10113                               * (OPJ_SIZE_T)l_img_comp_dest->w;
10114
10115         /* Allocate output component buffer if necessary */
10116         if (l_img_comp_dest->data == NULL &&
10117                 l_start_offset_src == 0 && l_start_offset_dest == 0 &&
10118                 src_data_stride == l_img_comp_dest->w &&
10119                 l_width_dest == l_img_comp_dest->w &&
10120                 l_height_dest == l_img_comp_dest->h) {
10121             /* If the final image matches the tile buffer, then borrow it */
10122             /* directly to save a copy */
10123             if (p_tcd->whole_tile_decoding) {
10124                 l_img_comp_dest->data = l_tilec->data;
10125                 l_tilec->data = NULL;
10126             } else {
10127                 l_img_comp_dest->data = l_tilec->data_win;
10128                 l_tilec->data_win = NULL;
10129             }
10130             continue;
10131         } else if (l_img_comp_dest->data == NULL) {
10132             OPJ_SIZE_T l_width = l_img_comp_dest->w;
10133             OPJ_SIZE_T l_height = l_img_comp_dest->h;
10134
10135             if ((l_height == 0U) || (l_width > (SIZE_MAX / l_height)) ||
10136                     l_width * l_height > SIZE_MAX / sizeof(OPJ_INT32)) {
10137                 /* would overflow */
10138                 return OPJ_FALSE;
10139             }
10140             l_img_comp_dest->data = (OPJ_INT32*) opj_image_data_alloc(l_width * l_height *
10141                                     sizeof(OPJ_INT32));
10142             if (! l_img_comp_dest->data) {
10143                 return OPJ_FALSE;
10144             }
10145
10146             if (l_img_comp_dest->w != l_width_dest ||
10147                     l_img_comp_dest->h != l_height_dest) {
10148                 memset(l_img_comp_dest->data, 0,
10149                        (OPJ_SIZE_T)l_img_comp_dest->w * l_img_comp_dest->h * sizeof(OPJ_INT32));
10150             }
10151         }
10152
10153         /* Move the output buffer to the first place where we will write*/
10154         l_dest_ptr = l_img_comp_dest->data + l_start_offset_dest;
10155
10156         {
10157             const OPJ_INT32 * l_src_ptr = p_src_data;
10158             l_src_ptr += l_start_offset_src;
10159
10160             for (j = 0; j < l_height_dest; ++j) {
10161                 memcpy(l_dest_ptr, l_src_ptr, l_width_dest * sizeof(OPJ_INT32));
10162                 l_dest_ptr += l_img_comp_dest->w;
10163                 l_src_ptr += src_data_stride;
10164             }
10165         }
10166
10167
10168     }
10169
10170     return OPJ_TRUE;
10171 }
10172
10173 static OPJ_BOOL opj_j2k_update_image_dimensions(opj_image_t* p_image,
10174         opj_event_mgr_t * p_manager)
10175 {
10176     OPJ_UINT32 it_comp;
10177     OPJ_INT32 l_comp_x1, l_comp_y1;
10178     opj_image_comp_t* l_img_comp = NULL;
10179
10180     l_img_comp = p_image->comps;
10181     for (it_comp = 0; it_comp < p_image->numcomps; ++it_comp) {
10182         OPJ_INT32 l_h, l_w;
10183         if (p_image->x0 > (OPJ_UINT32)INT_MAX ||
10184                 p_image->y0 > (OPJ_UINT32)INT_MAX ||
10185                 p_image->x1 > (OPJ_UINT32)INT_MAX ||
10186                 p_image->y1 > (OPJ_UINT32)INT_MAX) {
10187             opj_event_msg(p_manager, EVT_ERROR,
10188                           "Image coordinates above INT_MAX are not supported\n");
10189             return OPJ_FALSE;
10190         }
10191
10192         l_img_comp->x0 = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)p_image->x0,
10193                          (OPJ_INT32)l_img_comp->dx);
10194         l_img_comp->y0 = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)p_image->y0,
10195                          (OPJ_INT32)l_img_comp->dy);
10196         l_comp_x1 = opj_int_ceildiv((OPJ_INT32)p_image->x1, (OPJ_INT32)l_img_comp->dx);
10197         l_comp_y1 = opj_int_ceildiv((OPJ_INT32)p_image->y1, (OPJ_INT32)l_img_comp->dy);
10198
10199         l_w = opj_int_ceildivpow2(l_comp_x1, (OPJ_INT32)l_img_comp->factor)
10200               - opj_int_ceildivpow2((OPJ_INT32)l_img_comp->x0, (OPJ_INT32)l_img_comp->factor);
10201         if (l_w < 0) {
10202             opj_event_msg(p_manager, EVT_ERROR,
10203                           "Size x of the decoded component image is incorrect (comp[%d].w=%d).\n",
10204                           it_comp, l_w);
10205             return OPJ_FALSE;
10206         }
10207         l_img_comp->w = (OPJ_UINT32)l_w;
10208
10209         l_h = opj_int_ceildivpow2(l_comp_y1, (OPJ_INT32)l_img_comp->factor)
10210               - opj_int_ceildivpow2((OPJ_INT32)l_img_comp->y0, (OPJ_INT32)l_img_comp->factor);
10211         if (l_h < 0) {
10212             opj_event_msg(p_manager, EVT_ERROR,
10213                           "Size y of the decoded component image is incorrect (comp[%d].h=%d).\n",
10214                           it_comp, l_h);
10215             return OPJ_FALSE;
10216         }
10217         l_img_comp->h = (OPJ_UINT32)l_h;
10218
10219         l_img_comp++;
10220     }
10221
10222     return OPJ_TRUE;
10223 }
10224
10225 OPJ_BOOL opj_j2k_set_decoded_components(opj_j2k_t *p_j2k,
10226                                         OPJ_UINT32 numcomps,
10227                                         const OPJ_UINT32* comps_indices,
10228                                         opj_event_mgr_t * p_manager)
10229 {
10230     OPJ_UINT32 i;
10231     OPJ_BOOL* already_mapped;
10232
10233     if (p_j2k->m_private_image == NULL) {
10234         opj_event_msg(p_manager, EVT_ERROR,
10235                       "opj_read_header() should be called before "
10236                       "opj_set_decoded_components().\n");
10237         return OPJ_FALSE;
10238     }
10239
10240     already_mapped = (OPJ_BOOL*) opj_calloc(sizeof(OPJ_BOOL),
10241                                             p_j2k->m_private_image->numcomps);
10242     if (already_mapped == NULL) {
10243         return OPJ_FALSE;
10244     }
10245
10246     for (i = 0; i < numcomps; i++) {
10247         if (comps_indices[i] >= p_j2k->m_private_image->numcomps) {
10248             opj_event_msg(p_manager, EVT_ERROR,
10249                           "Invalid component index: %u\n",
10250                           comps_indices[i]);
10251             opj_free(already_mapped);
10252             return OPJ_FALSE;
10253         }
10254         if (already_mapped[comps_indices[i]]) {
10255             opj_event_msg(p_manager, EVT_ERROR,
10256                           "Component index %u used several times\n",
10257                           comps_indices[i]);
10258             opj_free(already_mapped);
10259             return OPJ_FALSE;
10260         }
10261         already_mapped[comps_indices[i]] = OPJ_TRUE;
10262     }
10263     opj_free(already_mapped);
10264
10265     opj_free(p_j2k->m_specific_param.m_decoder.m_comps_indices_to_decode);
10266     if (numcomps) {
10267         p_j2k->m_specific_param.m_decoder.m_comps_indices_to_decode =
10268             (OPJ_UINT32*) opj_malloc(numcomps * sizeof(OPJ_UINT32));
10269         if (p_j2k->m_specific_param.m_decoder.m_comps_indices_to_decode == NULL) {
10270             p_j2k->m_specific_param.m_decoder.m_numcomps_to_decode = 0;
10271             return OPJ_FALSE;
10272         }
10273         memcpy(p_j2k->m_specific_param.m_decoder.m_comps_indices_to_decode,
10274                comps_indices,
10275                numcomps * sizeof(OPJ_UINT32));
10276     } else {
10277         p_j2k->m_specific_param.m_decoder.m_comps_indices_to_decode = NULL;
10278     }
10279     p_j2k->m_specific_param.m_decoder.m_numcomps_to_decode = numcomps;
10280
10281     return OPJ_TRUE;
10282 }
10283
10284
10285 OPJ_BOOL opj_j2k_set_decode_area(opj_j2k_t *p_j2k,
10286                                  opj_image_t* p_image,
10287                                  OPJ_INT32 p_start_x, OPJ_INT32 p_start_y,
10288                                  OPJ_INT32 p_end_x, OPJ_INT32 p_end_y,
10289                                  opj_event_mgr_t * p_manager)
10290 {
10291     opj_cp_t * l_cp = &(p_j2k->m_cp);
10292     opj_image_t * l_image = p_j2k->m_private_image;
10293     OPJ_BOOL ret;
10294     OPJ_UINT32 it_comp;
10295
10296     if (p_j2k->m_cp.tw == 1 && p_j2k->m_cp.th == 1 &&
10297             p_j2k->m_cp.tcps[0].m_data != NULL) {
10298         /* In the case of a single-tiled image whose codestream we have already */
10299         /* ingested, go on */
10300     }
10301     /* Check if we are read the main header */
10302     else if (p_j2k->m_specific_param.m_decoder.m_state != J2K_STATE_TPHSOT) {
10303         opj_event_msg(p_manager, EVT_ERROR,
10304                       "Need to decode the main header before begin to decode the remaining codestream.\n");
10305         return OPJ_FALSE;
10306     }
10307
10308     /* Update the comps[].factor member of the output image with the one */
10309     /* of m_reduce */
10310     for (it_comp = 0; it_comp < p_image->numcomps; ++it_comp) {
10311         p_image->comps[it_comp].factor = p_j2k->m_cp.m_specific_param.m_dec.m_reduce;
10312     }
10313
10314     if (!p_start_x && !p_start_y && !p_end_x && !p_end_y) {
10315         opj_event_msg(p_manager, EVT_INFO,
10316                       "No decoded area parameters, set the decoded area to the whole image\n");
10317
10318         p_j2k->m_specific_param.m_decoder.m_start_tile_x = 0;
10319         p_j2k->m_specific_param.m_decoder.m_start_tile_y = 0;
10320         p_j2k->m_specific_param.m_decoder.m_end_tile_x = l_cp->tw;
10321         p_j2k->m_specific_param.m_decoder.m_end_tile_y = l_cp->th;
10322
10323         p_image->x0 = l_image->x0;
10324         p_image->y0 = l_image->y0;
10325         p_image->x1 = l_image->x1;
10326         p_image->y1 = l_image->y1;
10327
10328         return opj_j2k_update_image_dimensions(p_image, p_manager);
10329     }
10330
10331     /* ----- */
10332     /* Check if the positions provided by the user are correct */
10333
10334     /* Left */
10335     if (p_start_x < 0) {
10336         opj_event_msg(p_manager, EVT_ERROR,
10337                       "Left position of the decoded area (region_x0=%d) should be >= 0.\n",
10338                       p_start_x);
10339         return OPJ_FALSE;
10340     } else if ((OPJ_UINT32)p_start_x > l_image->x1) {
10341         opj_event_msg(p_manager, EVT_ERROR,
10342                       "Left position of the decoded area (region_x0=%d) is outside the image area (Xsiz=%d).\n",
10343                       p_start_x, l_image->x1);
10344         return OPJ_FALSE;
10345     } else if ((OPJ_UINT32)p_start_x < l_image->x0) {
10346         opj_event_msg(p_manager, EVT_WARNING,
10347                       "Left position of the decoded area (region_x0=%d) is outside the image area (XOsiz=%d).\n",
10348                       p_start_x, l_image->x0);
10349         p_j2k->m_specific_param.m_decoder.m_start_tile_x = 0;
10350         p_image->x0 = l_image->x0;
10351     } else {
10352         p_j2k->m_specific_param.m_decoder.m_start_tile_x = ((OPJ_UINT32)p_start_x -
10353                 l_cp->tx0) / l_cp->tdx;
10354         p_image->x0 = (OPJ_UINT32)p_start_x;
10355     }
10356
10357     /* Up */
10358     if (p_start_y < 0) {
10359         opj_event_msg(p_manager, EVT_ERROR,
10360                       "Up position of the decoded area (region_y0=%d) should be >= 0.\n",
10361                       p_start_y);
10362         return OPJ_FALSE;
10363     } else if ((OPJ_UINT32)p_start_y > l_image->y1) {
10364         opj_event_msg(p_manager, EVT_ERROR,
10365                       "Up position of the decoded area (region_y0=%d) is outside the image area (Ysiz=%d).\n",
10366                       p_start_y, l_image->y1);
10367         return OPJ_FALSE;
10368     } else if ((OPJ_UINT32)p_start_y < l_image->y0) {
10369         opj_event_msg(p_manager, EVT_WARNING,
10370                       "Up position of the decoded area (region_y0=%d) is outside the image area (YOsiz=%d).\n",
10371                       p_start_y, l_image->y0);
10372         p_j2k->m_specific_param.m_decoder.m_start_tile_y = 0;
10373         p_image->y0 = l_image->y0;
10374     } else {
10375         p_j2k->m_specific_param.m_decoder.m_start_tile_y = ((OPJ_UINT32)p_start_y -
10376                 l_cp->ty0) / l_cp->tdy;
10377         p_image->y0 = (OPJ_UINT32)p_start_y;
10378     }
10379
10380     /* Right */
10381     if (p_end_x <= 0) {
10382         opj_event_msg(p_manager, EVT_ERROR,
10383                       "Right position of the decoded area (region_x1=%d) should be > 0.\n",
10384                       p_end_x);
10385         return OPJ_FALSE;
10386     } else if ((OPJ_UINT32)p_end_x < l_image->x0) {
10387         opj_event_msg(p_manager, EVT_ERROR,
10388                       "Right position of the decoded area (region_x1=%d) is outside the image area (XOsiz=%d).\n",
10389                       p_end_x, l_image->x0);
10390         return OPJ_FALSE;
10391     } else if ((OPJ_UINT32)p_end_x > l_image->x1) {
10392         opj_event_msg(p_manager, EVT_WARNING,
10393                       "Right position of the decoded area (region_x1=%d) is outside the image area (Xsiz=%d).\n",
10394                       p_end_x, l_image->x1);
10395         p_j2k->m_specific_param.m_decoder.m_end_tile_x = l_cp->tw;
10396         p_image->x1 = l_image->x1;
10397     } else {
10398         p_j2k->m_specific_param.m_decoder.m_end_tile_x = (OPJ_UINT32)opj_int_ceildiv(
10399                     p_end_x - (OPJ_INT32)l_cp->tx0, (OPJ_INT32)l_cp->tdx);
10400         p_image->x1 = (OPJ_UINT32)p_end_x;
10401     }
10402
10403     /* Bottom */
10404     if (p_end_y <= 0) {
10405         opj_event_msg(p_manager, EVT_ERROR,
10406                       "Bottom position of the decoded area (region_y1=%d) should be > 0.\n",
10407                       p_end_y);
10408         return OPJ_FALSE;
10409     } else if ((OPJ_UINT32)p_end_y < l_image->y0) {
10410         opj_event_msg(p_manager, EVT_ERROR,
10411                       "Bottom position of the decoded area (region_y1=%d) is outside the image area (YOsiz=%d).\n",
10412                       p_end_y, l_image->y0);
10413         return OPJ_FALSE;
10414     }
10415     if ((OPJ_UINT32)p_end_y > l_image->y1) {
10416         opj_event_msg(p_manager, EVT_WARNING,
10417                       "Bottom position of the decoded area (region_y1=%d) is outside the image area (Ysiz=%d).\n",
10418                       p_end_y, l_image->y1);
10419         p_j2k->m_specific_param.m_decoder.m_end_tile_y = l_cp->th;
10420         p_image->y1 = l_image->y1;
10421     } else {
10422         p_j2k->m_specific_param.m_decoder.m_end_tile_y = (OPJ_UINT32)opj_int_ceildiv(
10423                     p_end_y - (OPJ_INT32)l_cp->ty0, (OPJ_INT32)l_cp->tdy);
10424         p_image->y1 = (OPJ_UINT32)p_end_y;
10425     }
10426     /* ----- */
10427
10428     p_j2k->m_specific_param.m_decoder.m_discard_tiles = 1;
10429
10430     ret = opj_j2k_update_image_dimensions(p_image, p_manager);
10431
10432     if (ret) {
10433         opj_event_msg(p_manager, EVT_INFO, "Setting decoding area to %d,%d,%d,%d\n",
10434                       p_image->x0, p_image->y0, p_image->x1, p_image->y1);
10435     }
10436
10437     return ret;
10438 }
10439
10440 opj_j2k_t* opj_j2k_create_decompress(void)
10441 {
10442     opj_j2k_t *l_j2k = (opj_j2k_t*) opj_calloc(1, sizeof(opj_j2k_t));
10443     if (!l_j2k) {
10444         return 00;
10445     }
10446
10447     l_j2k->m_is_decoder = 1;
10448     l_j2k->m_cp.m_is_decoder = 1;
10449     /* in the absence of JP2 boxes, consider different bit depth / sign */
10450     /* per component is allowed */
10451     l_j2k->m_cp.allow_different_bit_depth_sign = 1;
10452
10453     /* Default to using strict mode. */
10454     l_j2k->m_cp.strict = OPJ_TRUE;
10455
10456 #ifdef OPJ_DISABLE_TPSOT_FIX
10457     l_j2k->m_specific_param.m_decoder.m_nb_tile_parts_correction_checked = 1;
10458 #endif
10459
10460     l_j2k->m_specific_param.m_decoder.m_default_tcp = (opj_tcp_t*) opj_calloc(1,
10461             sizeof(opj_tcp_t));
10462     if (!l_j2k->m_specific_param.m_decoder.m_default_tcp) {
10463         opj_j2k_destroy(l_j2k);
10464         return 00;
10465     }
10466
10467     l_j2k->m_specific_param.m_decoder.m_header_data = (OPJ_BYTE *) opj_calloc(1,
10468             OPJ_J2K_DEFAULT_HEADER_SIZE);
10469     if (! l_j2k->m_specific_param.m_decoder.m_header_data) {
10470         opj_j2k_destroy(l_j2k);
10471         return 00;
10472     }
10473
10474     l_j2k->m_specific_param.m_decoder.m_header_data_size =
10475         OPJ_J2K_DEFAULT_HEADER_SIZE;
10476
10477     l_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec = -1 ;
10478
10479     l_j2k->m_specific_param.m_decoder.m_last_sot_read_pos = 0 ;
10480
10481     /* codestream index creation */
10482     l_j2k->cstr_index = opj_j2k_create_cstr_index();
10483     if (!l_j2k->cstr_index) {
10484         opj_j2k_destroy(l_j2k);
10485         return 00;
10486     }
10487
10488     /* validation list creation */
10489     l_j2k->m_validation_list = opj_procedure_list_create();
10490     if (! l_j2k->m_validation_list) {
10491         opj_j2k_destroy(l_j2k);
10492         return 00;
10493     }
10494
10495     /* execution list creation */
10496     l_j2k->m_procedure_list = opj_procedure_list_create();
10497     if (! l_j2k->m_procedure_list) {
10498         opj_j2k_destroy(l_j2k);
10499         return 00;
10500     }
10501
10502     l_j2k->m_tp = opj_thread_pool_create(opj_j2k_get_default_thread_count());
10503     if (!l_j2k->m_tp) {
10504         l_j2k->m_tp = opj_thread_pool_create(0);
10505     }
10506     if (!l_j2k->m_tp) {
10507         opj_j2k_destroy(l_j2k);
10508         return NULL;
10509     }
10510
10511     return l_j2k;
10512 }
10513
10514 static opj_codestream_index_t* opj_j2k_create_cstr_index(void)
10515 {
10516     opj_codestream_index_t* cstr_index = (opj_codestream_index_t*)
10517                                          opj_calloc(1, sizeof(opj_codestream_index_t));
10518     if (!cstr_index) {
10519         return NULL;
10520     }
10521
10522     cstr_index->maxmarknum = 100;
10523     cstr_index->marknum = 0;
10524     cstr_index->marker = (opj_marker_info_t*)
10525                          opj_calloc(cstr_index->maxmarknum, sizeof(opj_marker_info_t));
10526     if (!cstr_index-> marker) {
10527         opj_free(cstr_index);
10528         return NULL;
10529     }
10530
10531     cstr_index->tile_index = NULL;
10532
10533     return cstr_index;
10534 }
10535
10536 static OPJ_UINT32 opj_j2k_get_SPCod_SPCoc_size(opj_j2k_t *p_j2k,
10537         OPJ_UINT32 p_tile_no,
10538         OPJ_UINT32 p_comp_no)
10539 {
10540     opj_cp_t *l_cp = 00;
10541     opj_tcp_t *l_tcp = 00;
10542     opj_tccp_t *l_tccp = 00;
10543
10544     /* preconditions */
10545     assert(p_j2k != 00);
10546
10547     l_cp = &(p_j2k->m_cp);
10548     l_tcp = &l_cp->tcps[p_tile_no];
10549     l_tccp = &l_tcp->tccps[p_comp_no];
10550
10551     /* preconditions again */
10552     assert(p_tile_no < (l_cp->tw * l_cp->th));
10553     assert(p_comp_no < p_j2k->m_private_image->numcomps);
10554
10555     if (l_tccp->csty & J2K_CCP_CSTY_PRT) {
10556         return 5 + l_tccp->numresolutions;
10557     } else {
10558         return 5;
10559     }
10560 }
10561
10562 static OPJ_BOOL opj_j2k_compare_SPCod_SPCoc(opj_j2k_t *p_j2k,
10563         OPJ_UINT32 p_tile_no, OPJ_UINT32 p_first_comp_no, OPJ_UINT32 p_second_comp_no)
10564 {
10565     OPJ_UINT32 i;
10566     opj_cp_t *l_cp = NULL;
10567     opj_tcp_t *l_tcp = NULL;
10568     opj_tccp_t *l_tccp0 = NULL;
10569     opj_tccp_t *l_tccp1 = NULL;
10570
10571     /* preconditions */
10572     assert(p_j2k != 00);
10573
10574     l_cp = &(p_j2k->m_cp);
10575     l_tcp = &l_cp->tcps[p_tile_no];
10576     l_tccp0 = &l_tcp->tccps[p_first_comp_no];
10577     l_tccp1 = &l_tcp->tccps[p_second_comp_no];
10578
10579     if (l_tccp0->numresolutions != l_tccp1->numresolutions) {
10580         return OPJ_FALSE;
10581     }
10582     if (l_tccp0->cblkw != l_tccp1->cblkw) {
10583         return OPJ_FALSE;
10584     }
10585     if (l_tccp0->cblkh != l_tccp1->cblkh) {
10586         return OPJ_FALSE;
10587     }
10588     if (l_tccp0->cblksty != l_tccp1->cblksty) {
10589         return OPJ_FALSE;
10590     }
10591     if (l_tccp0->qmfbid != l_tccp1->qmfbid) {
10592         return OPJ_FALSE;
10593     }
10594     if ((l_tccp0->csty & J2K_CCP_CSTY_PRT) != (l_tccp1->csty & J2K_CCP_CSTY_PRT)) {
10595         return OPJ_FALSE;
10596     }
10597
10598     for (i = 0U; i < l_tccp0->numresolutions; ++i) {
10599         if (l_tccp0->prcw[i] != l_tccp1->prcw[i]) {
10600             return OPJ_FALSE;
10601         }
10602         if (l_tccp0->prch[i] != l_tccp1->prch[i]) {
10603             return OPJ_FALSE;
10604         }
10605     }
10606     return OPJ_TRUE;
10607 }
10608
10609 static OPJ_BOOL opj_j2k_write_SPCod_SPCoc(opj_j2k_t *p_j2k,
10610         OPJ_UINT32 p_tile_no,
10611         OPJ_UINT32 p_comp_no,
10612         OPJ_BYTE * p_data,
10613         OPJ_UINT32 * p_header_size,
10614         struct opj_event_mgr * p_manager)
10615 {
10616     OPJ_UINT32 i;
10617     opj_cp_t *l_cp = 00;
10618     opj_tcp_t *l_tcp = 00;
10619     opj_tccp_t *l_tccp = 00;
10620
10621     /* preconditions */
10622     assert(p_j2k != 00);
10623     assert(p_header_size != 00);
10624     assert(p_manager != 00);
10625     assert(p_data != 00);
10626
10627     l_cp = &(p_j2k->m_cp);
10628     l_tcp = &l_cp->tcps[p_tile_no];
10629     l_tccp = &l_tcp->tccps[p_comp_no];
10630
10631     /* preconditions again */
10632     assert(p_tile_no < (l_cp->tw * l_cp->th));
10633     assert(p_comp_no < (p_j2k->m_private_image->numcomps));
10634
10635     if (*p_header_size < 5) {
10636         opj_event_msg(p_manager, EVT_ERROR, "Error writing SPCod SPCoc element\n");
10637         return OPJ_FALSE;
10638     }
10639
10640     opj_write_bytes(p_data, l_tccp->numresolutions - 1, 1); /* SPcoc (D) */
10641     ++p_data;
10642
10643     opj_write_bytes(p_data, l_tccp->cblkw - 2, 1);                  /* SPcoc (E) */
10644     ++p_data;
10645
10646     opj_write_bytes(p_data, l_tccp->cblkh - 2, 1);                  /* SPcoc (F) */
10647     ++p_data;
10648
10649     opj_write_bytes(p_data, l_tccp->cblksty,
10650                     1);                            /* SPcoc (G) */
10651     ++p_data;
10652
10653     opj_write_bytes(p_data, l_tccp->qmfbid,
10654                     1);                             /* SPcoc (H) */
10655     ++p_data;
10656
10657     *p_header_size = *p_header_size - 5;
10658
10659     if (l_tccp->csty & J2K_CCP_CSTY_PRT) {
10660
10661         if (*p_header_size < l_tccp->numresolutions) {
10662             opj_event_msg(p_manager, EVT_ERROR, "Error writing SPCod SPCoc element\n");
10663             return OPJ_FALSE;
10664         }
10665
10666         for (i = 0; i < l_tccp->numresolutions; ++i) {
10667             opj_write_bytes(p_data, l_tccp->prcw[i] + (l_tccp->prch[i] << 4),
10668                             1);   /* SPcoc (I_i) */
10669             ++p_data;
10670         }
10671
10672         *p_header_size = *p_header_size - l_tccp->numresolutions;
10673     }
10674
10675     return OPJ_TRUE;
10676 }
10677
10678 static OPJ_BOOL opj_j2k_read_SPCod_SPCoc(opj_j2k_t *p_j2k,
10679         OPJ_UINT32 compno,
10680         OPJ_BYTE * p_header_data,
10681         OPJ_UINT32 * p_header_size,
10682         opj_event_mgr_t * p_manager)
10683 {
10684     OPJ_UINT32 i, l_tmp;
10685     opj_cp_t *l_cp = NULL;
10686     opj_tcp_t *l_tcp = NULL;
10687     opj_tccp_t *l_tccp = NULL;
10688     OPJ_BYTE * l_current_ptr = NULL;
10689
10690     /* preconditions */
10691     assert(p_j2k != 00);
10692     assert(p_manager != 00);
10693     assert(p_header_data != 00);
10694
10695     l_cp = &(p_j2k->m_cp);
10696     l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH) ?
10697             &l_cp->tcps[p_j2k->m_current_tile_number] :
10698             p_j2k->m_specific_param.m_decoder.m_default_tcp;
10699
10700     /* precondition again */
10701     assert(compno < p_j2k->m_private_image->numcomps);
10702
10703     l_tccp = &l_tcp->tccps[compno];
10704     l_current_ptr = p_header_data;
10705
10706     /* make sure room is sufficient */
10707     if (*p_header_size < 5) {
10708         opj_event_msg(p_manager, EVT_ERROR, "Error reading SPCod SPCoc element\n");
10709         return OPJ_FALSE;
10710     }
10711
10712     /* SPcod (D) / SPcoc (A) */
10713     opj_read_bytes(l_current_ptr, &l_tccp->numresolutions, 1);
10714     ++l_tccp->numresolutions;  /* tccp->numresolutions = read() + 1 */
10715     if (l_tccp->numresolutions > OPJ_J2K_MAXRLVLS) {
10716         opj_event_msg(p_manager, EVT_ERROR,
10717                       "Invalid value for numresolutions : %d, max value is set in openjpeg.h at %d\n",
10718                       l_tccp->numresolutions, OPJ_J2K_MAXRLVLS);
10719         return OPJ_FALSE;
10720     }
10721     ++l_current_ptr;
10722
10723     /* If user wants to remove more resolutions than the codestream contains, return error */
10724     if (l_cp->m_specific_param.m_dec.m_reduce >= l_tccp->numresolutions) {
10725         opj_event_msg(p_manager, EVT_ERROR,
10726                       "Error decoding component %d.\nThe number of resolutions "
10727                       "to remove (%d) is greater or equal than the number "
10728                       "of resolutions of this component (%d)\nModify the cp_reduce parameter.\n\n",
10729                       compno, l_cp->m_specific_param.m_dec.m_reduce, l_tccp->numresolutions);
10730         p_j2k->m_specific_param.m_decoder.m_state |=
10731             0x8000;/* FIXME J2K_DEC_STATE_ERR;*/
10732         return OPJ_FALSE;
10733     }
10734
10735     /* SPcod (E) / SPcoc (B) */
10736     opj_read_bytes(l_current_ptr, &l_tccp->cblkw, 1);
10737     ++l_current_ptr;
10738     l_tccp->cblkw += 2;
10739
10740     /* SPcod (F) / SPcoc (C) */
10741     opj_read_bytes(l_current_ptr, &l_tccp->cblkh, 1);
10742     ++l_current_ptr;
10743     l_tccp->cblkh += 2;
10744
10745     if ((l_tccp->cblkw > 10) || (l_tccp->cblkh > 10) ||
10746             ((l_tccp->cblkw + l_tccp->cblkh) > 12)) {
10747         opj_event_msg(p_manager, EVT_ERROR,
10748                       "Error reading SPCod SPCoc element, Invalid cblkw/cblkh combination\n");
10749         return OPJ_FALSE;
10750     }
10751
10752     /* SPcod (G) / SPcoc (D) */
10753     opj_read_bytes(l_current_ptr, &l_tccp->cblksty, 1);
10754     ++l_current_ptr;
10755     if ((l_tccp->cblksty & J2K_CCP_CBLKSTY_HTMIXED) != 0) {
10756         /* We do not support HT mixed mode yet.  For conformance, it should be supported.*/
10757         opj_event_msg(p_manager, EVT_ERROR,
10758                       "Error reading SPCod SPCoc element. Unsupported Mixed HT code-block style found\n");
10759         return OPJ_FALSE;
10760     }
10761
10762     /* SPcod (H) / SPcoc (E) */
10763     opj_read_bytes(l_current_ptr, &l_tccp->qmfbid, 1);
10764     ++l_current_ptr;
10765
10766     if (l_tccp->qmfbid > 1) {
10767         opj_event_msg(p_manager, EVT_ERROR,
10768                       "Error reading SPCod SPCoc element, Invalid transformation found\n");
10769         return OPJ_FALSE;
10770     }
10771
10772     *p_header_size = *p_header_size - 5;
10773
10774     /* use custom precinct size ? */
10775     if (l_tccp->csty & J2K_CCP_CSTY_PRT) {
10776         if (*p_header_size < l_tccp->numresolutions) {
10777             opj_event_msg(p_manager, EVT_ERROR, "Error reading SPCod SPCoc element\n");
10778             return OPJ_FALSE;
10779         }
10780
10781         /* SPcod (I_i) / SPcoc (F_i) */
10782         for (i = 0; i < l_tccp->numresolutions; ++i) {
10783             opj_read_bytes(l_current_ptr, &l_tmp, 1);
10784             ++l_current_ptr;
10785             /* Precinct exponent 0 is only allowed for lowest resolution level (Table A.21) */
10786             if ((i != 0) && (((l_tmp & 0xf) == 0) || ((l_tmp >> 4) == 0))) {
10787                 opj_event_msg(p_manager, EVT_ERROR, "Invalid precinct size\n");
10788                 return OPJ_FALSE;
10789             }
10790             l_tccp->prcw[i] = l_tmp & 0xf;
10791             l_tccp->prch[i] = l_tmp >> 4;
10792         }
10793
10794         *p_header_size = *p_header_size - l_tccp->numresolutions;
10795     } else {
10796         /* set default size for the precinct width and height */
10797         for (i = 0; i < l_tccp->numresolutions; ++i) {
10798             l_tccp->prcw[i] = 15;
10799             l_tccp->prch[i] = 15;
10800         }
10801     }
10802
10803 #ifdef WIP_REMOVE_MSD
10804     /* INDEX >> */
10805     if (p_j2k->cstr_info && compno == 0) {
10806         OPJ_UINT32 l_data_size = l_tccp->numresolutions * sizeof(OPJ_UINT32);
10807
10808         p_j2k->cstr_info->tile[p_j2k->m_current_tile_number].tccp_info[compno].cblkh =
10809             l_tccp->cblkh;
10810         p_j2k->cstr_info->tile[p_j2k->m_current_tile_number].tccp_info[compno].cblkw =
10811             l_tccp->cblkw;
10812         p_j2k->cstr_info->tile[p_j2k->m_current_tile_number].tccp_info[compno].numresolutions
10813             = l_tccp->numresolutions;
10814         p_j2k->cstr_info->tile[p_j2k->m_current_tile_number].tccp_info[compno].cblksty =
10815             l_tccp->cblksty;
10816         p_j2k->cstr_info->tile[p_j2k->m_current_tile_number].tccp_info[compno].qmfbid =
10817             l_tccp->qmfbid;
10818
10819         memcpy(p_j2k->cstr_info->tile[p_j2k->m_current_tile_number].pdx, l_tccp->prcw,
10820                l_data_size);
10821         memcpy(p_j2k->cstr_info->tile[p_j2k->m_current_tile_number].pdy, l_tccp->prch,
10822                l_data_size);
10823     }
10824     /* << INDEX */
10825 #endif
10826
10827     return OPJ_TRUE;
10828 }
10829
10830 static void opj_j2k_copy_tile_component_parameters(opj_j2k_t *p_j2k)
10831 {
10832     /* loop */
10833     OPJ_UINT32 i;
10834     opj_cp_t *l_cp = NULL;
10835     opj_tcp_t *l_tcp = NULL;
10836     opj_tccp_t *l_ref_tccp = NULL, *l_copied_tccp = NULL;
10837     OPJ_UINT32 l_prc_size;
10838
10839     /* preconditions */
10840     assert(p_j2k != 00);
10841
10842     l_cp = &(p_j2k->m_cp);
10843     l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH)
10844             ?
10845             &l_cp->tcps[p_j2k->m_current_tile_number] :
10846             p_j2k->m_specific_param.m_decoder.m_default_tcp;
10847
10848     l_ref_tccp = &l_tcp->tccps[0];
10849     l_copied_tccp = l_ref_tccp + 1;
10850     l_prc_size = l_ref_tccp->numresolutions * (OPJ_UINT32)sizeof(OPJ_UINT32);
10851
10852     for (i = 1; i < p_j2k->m_private_image->numcomps; ++i) {
10853         l_copied_tccp->numresolutions = l_ref_tccp->numresolutions;
10854         l_copied_tccp->cblkw = l_ref_tccp->cblkw;
10855         l_copied_tccp->cblkh = l_ref_tccp->cblkh;
10856         l_copied_tccp->cblksty = l_ref_tccp->cblksty;
10857         l_copied_tccp->qmfbid = l_ref_tccp->qmfbid;
10858         memcpy(l_copied_tccp->prcw, l_ref_tccp->prcw, l_prc_size);
10859         memcpy(l_copied_tccp->prch, l_ref_tccp->prch, l_prc_size);
10860         ++l_copied_tccp;
10861     }
10862 }
10863
10864 static OPJ_UINT32 opj_j2k_get_SQcd_SQcc_size(opj_j2k_t *p_j2k,
10865         OPJ_UINT32 p_tile_no,
10866         OPJ_UINT32 p_comp_no)
10867 {
10868     OPJ_UINT32 l_num_bands;
10869
10870     opj_cp_t *l_cp = 00;
10871     opj_tcp_t *l_tcp = 00;
10872     opj_tccp_t *l_tccp = 00;
10873
10874     /* preconditions */
10875     assert(p_j2k != 00);
10876
10877     l_cp = &(p_j2k->m_cp);
10878     l_tcp = &l_cp->tcps[p_tile_no];
10879     l_tccp = &l_tcp->tccps[p_comp_no];
10880
10881     /* preconditions again */
10882     assert(p_tile_no < l_cp->tw * l_cp->th);
10883     assert(p_comp_no < p_j2k->m_private_image->numcomps);
10884
10885     l_num_bands = (l_tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) ? 1 :
10886                   (l_tccp->numresolutions * 3 - 2);
10887
10888     if (l_tccp->qntsty == J2K_CCP_QNTSTY_NOQNT)  {
10889         return 1 + l_num_bands;
10890     } else {
10891         return 1 + 2 * l_num_bands;
10892     }
10893 }
10894
10895 static OPJ_BOOL opj_j2k_compare_SQcd_SQcc(opj_j2k_t *p_j2k,
10896         OPJ_UINT32 p_tile_no, OPJ_UINT32 p_first_comp_no, OPJ_UINT32 p_second_comp_no)
10897 {
10898     opj_cp_t *l_cp = NULL;
10899     opj_tcp_t *l_tcp = NULL;
10900     opj_tccp_t *l_tccp0 = NULL;
10901     opj_tccp_t *l_tccp1 = NULL;
10902     OPJ_UINT32 l_band_no, l_num_bands;
10903
10904     /* preconditions */
10905     assert(p_j2k != 00);
10906
10907     l_cp = &(p_j2k->m_cp);
10908     l_tcp = &l_cp->tcps[p_tile_no];
10909     l_tccp0 = &l_tcp->tccps[p_first_comp_no];
10910     l_tccp1 = &l_tcp->tccps[p_second_comp_no];
10911
10912     if (l_tccp0->qntsty != l_tccp1->qntsty) {
10913         return OPJ_FALSE;
10914     }
10915     if (l_tccp0->numgbits != l_tccp1->numgbits) {
10916         return OPJ_FALSE;
10917     }
10918     if (l_tccp0->qntsty == J2K_CCP_QNTSTY_SIQNT) {
10919         l_num_bands = 1U;
10920     } else {
10921         l_num_bands = l_tccp0->numresolutions * 3U - 2U;
10922         if (l_num_bands != (l_tccp1->numresolutions * 3U - 2U)) {
10923             return OPJ_FALSE;
10924         }
10925     }
10926
10927     for (l_band_no = 0; l_band_no < l_num_bands; ++l_band_no) {
10928         if (l_tccp0->stepsizes[l_band_no].expn != l_tccp1->stepsizes[l_band_no].expn) {
10929             return OPJ_FALSE;
10930         }
10931     }
10932     if (l_tccp0->qntsty != J2K_CCP_QNTSTY_NOQNT) {
10933         for (l_band_no = 0; l_band_no < l_num_bands; ++l_band_no) {
10934             if (l_tccp0->stepsizes[l_band_no].mant != l_tccp1->stepsizes[l_band_no].mant) {
10935                 return OPJ_FALSE;
10936             }
10937         }
10938     }
10939     return OPJ_TRUE;
10940 }
10941
10942
10943 static OPJ_BOOL opj_j2k_write_SQcd_SQcc(opj_j2k_t *p_j2k,
10944                                         OPJ_UINT32 p_tile_no,
10945                                         OPJ_UINT32 p_comp_no,
10946                                         OPJ_BYTE * p_data,
10947                                         OPJ_UINT32 * p_header_size,
10948                                         struct opj_event_mgr * p_manager)
10949 {
10950     OPJ_UINT32 l_header_size;
10951     OPJ_UINT32 l_band_no, l_num_bands;
10952     OPJ_UINT32 l_expn, l_mant;
10953
10954     opj_cp_t *l_cp = 00;
10955     opj_tcp_t *l_tcp = 00;
10956     opj_tccp_t *l_tccp = 00;
10957
10958     /* preconditions */
10959     assert(p_j2k != 00);
10960     assert(p_header_size != 00);
10961     assert(p_manager != 00);
10962     assert(p_data != 00);
10963
10964     l_cp = &(p_j2k->m_cp);
10965     l_tcp = &l_cp->tcps[p_tile_no];
10966     l_tccp = &l_tcp->tccps[p_comp_no];
10967
10968     /* preconditions again */
10969     assert(p_tile_no < l_cp->tw * l_cp->th);
10970     assert(p_comp_no < p_j2k->m_private_image->numcomps);
10971
10972     l_num_bands = (l_tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) ? 1 :
10973                   (l_tccp->numresolutions * 3 - 2);
10974
10975     if (l_tccp->qntsty == J2K_CCP_QNTSTY_NOQNT)  {
10976         l_header_size = 1 + l_num_bands;
10977
10978         if (*p_header_size < l_header_size) {
10979             opj_event_msg(p_manager, EVT_ERROR, "Error writing SQcd SQcc element\n");
10980             return OPJ_FALSE;
10981         }
10982
10983         opj_write_bytes(p_data, l_tccp->qntsty + (l_tccp->numgbits << 5),
10984                         1);   /* Sqcx */
10985         ++p_data;
10986
10987         for (l_band_no = 0; l_band_no < l_num_bands; ++l_band_no) {
10988             l_expn = (OPJ_UINT32)l_tccp->stepsizes[l_band_no].expn;
10989             opj_write_bytes(p_data, l_expn << 3, 1);        /* SPqcx_i */
10990             ++p_data;
10991         }
10992     } else {
10993         l_header_size = 1 + 2 * l_num_bands;
10994
10995         if (*p_header_size < l_header_size) {
10996             opj_event_msg(p_manager, EVT_ERROR, "Error writing SQcd SQcc element\n");
10997             return OPJ_FALSE;
10998         }
10999
11000         opj_write_bytes(p_data, l_tccp->qntsty + (l_tccp->numgbits << 5),
11001                         1);   /* Sqcx */
11002         ++p_data;
11003
11004         for (l_band_no = 0; l_band_no < l_num_bands; ++l_band_no) {
11005             l_expn = (OPJ_UINT32)l_tccp->stepsizes[l_band_no].expn;
11006             l_mant = (OPJ_UINT32)l_tccp->stepsizes[l_band_no].mant;
11007
11008             opj_write_bytes(p_data, (l_expn << 11) + l_mant, 2);    /* SPqcx_i */
11009             p_data += 2;
11010         }
11011     }
11012
11013     *p_header_size = *p_header_size - l_header_size;
11014
11015     return OPJ_TRUE;
11016 }
11017
11018 static OPJ_BOOL opj_j2k_read_SQcd_SQcc(opj_j2k_t *p_j2k,
11019                                        OPJ_UINT32 p_comp_no,
11020                                        OPJ_BYTE* p_header_data,
11021                                        OPJ_UINT32 * p_header_size,
11022                                        opj_event_mgr_t * p_manager
11023                                       )
11024 {
11025     /* loop*/
11026     OPJ_UINT32 l_band_no;
11027     opj_cp_t *l_cp = 00;
11028     opj_tcp_t *l_tcp = 00;
11029     opj_tccp_t *l_tccp = 00;
11030     OPJ_BYTE * l_current_ptr = 00;
11031     OPJ_UINT32 l_tmp, l_num_band;
11032
11033     /* preconditions*/
11034     assert(p_j2k != 00);
11035     assert(p_manager != 00);
11036     assert(p_header_data != 00);
11037
11038     l_cp = &(p_j2k->m_cp);
11039     /* come from tile part header or main header ?*/
11040     l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH)
11041             ?
11042             &l_cp->tcps[p_j2k->m_current_tile_number] :
11043             p_j2k->m_specific_param.m_decoder.m_default_tcp;
11044
11045     /* precondition again*/
11046     assert(p_comp_no <  p_j2k->m_private_image->numcomps);
11047
11048     l_tccp = &l_tcp->tccps[p_comp_no];
11049     l_current_ptr = p_header_data;
11050
11051     if (*p_header_size < 1) {
11052         opj_event_msg(p_manager, EVT_ERROR, "Error reading SQcd or SQcc element\n");
11053         return OPJ_FALSE;
11054     }
11055     *p_header_size -= 1;
11056
11057     opj_read_bytes(l_current_ptr, &l_tmp, 1);                       /* Sqcx */
11058     ++l_current_ptr;
11059
11060     l_tccp->qntsty = l_tmp & 0x1f;
11061     l_tccp->numgbits = l_tmp >> 5;
11062     if (l_tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) {
11063         l_num_band = 1;
11064     } else {
11065         l_num_band = (l_tccp->qntsty == J2K_CCP_QNTSTY_NOQNT) ?
11066                      (*p_header_size) :
11067                      (*p_header_size) / 2;
11068
11069         if (l_num_band > OPJ_J2K_MAXBANDS) {
11070             opj_event_msg(p_manager, EVT_WARNING,
11071                           "While reading CCP_QNTSTY element inside QCD or QCC marker segment, "
11072                           "number of subbands (%d) is greater to OPJ_J2K_MAXBANDS (%d). So we limit the number of elements stored to "
11073                           "OPJ_J2K_MAXBANDS (%d) and skip the rest. \n", l_num_band, OPJ_J2K_MAXBANDS,
11074                           OPJ_J2K_MAXBANDS);
11075             /*return OPJ_FALSE;*/
11076         }
11077     }
11078
11079 #ifdef USE_JPWL
11080     if (l_cp->correct) {
11081
11082         /* if JPWL is on, we check whether there are too many subbands */
11083         if (/*(l_num_band < 0) ||*/ (l_num_band >= OPJ_J2K_MAXBANDS)) {
11084             opj_event_msg(p_manager, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
11085                           "JPWL: bad number of subbands in Sqcx (%d)\n",
11086                           l_num_band);
11087             if (!JPWL_ASSUME) {
11088                 opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n");
11089                 return OPJ_FALSE;
11090             }
11091             /* we try to correct */
11092             l_num_band = 1;
11093             opj_event_msg(p_manager, EVT_WARNING, "- trying to adjust them\n"
11094                           "- setting number of bands to %d => HYPOTHESIS!!!\n",
11095                           l_num_band);
11096         };
11097
11098     };
11099 #endif /* USE_JPWL */
11100
11101     if (l_tccp->qntsty == J2K_CCP_QNTSTY_NOQNT) {
11102         for (l_band_no = 0; l_band_no < l_num_band; l_band_no++) {
11103             opj_read_bytes(l_current_ptr, &l_tmp, 1);                       /* SPqcx_i */
11104             ++l_current_ptr;
11105             if (l_band_no < OPJ_J2K_MAXBANDS) {
11106                 l_tccp->stepsizes[l_band_no].expn = (OPJ_INT32)(l_tmp >> 3);
11107                 l_tccp->stepsizes[l_band_no].mant = 0;
11108             }
11109         }
11110         *p_header_size = *p_header_size - l_num_band;
11111     } else {
11112         for (l_band_no = 0; l_band_no < l_num_band; l_band_no++) {
11113             opj_read_bytes(l_current_ptr, &l_tmp, 2);                       /* SPqcx_i */
11114             l_current_ptr += 2;
11115             if (l_band_no < OPJ_J2K_MAXBANDS) {
11116                 l_tccp->stepsizes[l_band_no].expn = (OPJ_INT32)(l_tmp >> 11);
11117                 l_tccp->stepsizes[l_band_no].mant = l_tmp & 0x7ff;
11118             }
11119         }
11120         *p_header_size = *p_header_size - 2 * l_num_band;
11121     }
11122
11123     /* Add Antonin : if scalar_derived -> compute other stepsizes */
11124     if (l_tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) {
11125         for (l_band_no = 1; l_band_no < OPJ_J2K_MAXBANDS; l_band_no++) {
11126             l_tccp->stepsizes[l_band_no].expn =
11127                 ((OPJ_INT32)(l_tccp->stepsizes[0].expn) - (OPJ_INT32)((l_band_no - 1) / 3) > 0)
11128                 ?
11129                 (OPJ_INT32)(l_tccp->stepsizes[0].expn) - (OPJ_INT32)((l_band_no - 1) / 3) : 0;
11130             l_tccp->stepsizes[l_band_no].mant = l_tccp->stepsizes[0].mant;
11131         }
11132     }
11133
11134     return OPJ_TRUE;
11135 }
11136
11137 static void opj_j2k_copy_tile_quantization_parameters(opj_j2k_t *p_j2k)
11138 {
11139     OPJ_UINT32 i;
11140     opj_cp_t *l_cp = NULL;
11141     opj_tcp_t *l_tcp = NULL;
11142     opj_tccp_t *l_ref_tccp = NULL;
11143     opj_tccp_t *l_copied_tccp = NULL;
11144     OPJ_UINT32 l_size;
11145
11146     /* preconditions */
11147     assert(p_j2k != 00);
11148
11149     l_cp = &(p_j2k->m_cp);
11150     l_tcp = p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH ?
11151             &l_cp->tcps[p_j2k->m_current_tile_number] :
11152             p_j2k->m_specific_param.m_decoder.m_default_tcp;
11153
11154     l_ref_tccp = &l_tcp->tccps[0];
11155     l_copied_tccp = l_ref_tccp + 1;
11156     l_size = OPJ_J2K_MAXBANDS * sizeof(opj_stepsize_t);
11157
11158     for (i = 1; i < p_j2k->m_private_image->numcomps; ++i) {
11159         l_copied_tccp->qntsty = l_ref_tccp->qntsty;
11160         l_copied_tccp->numgbits = l_ref_tccp->numgbits;
11161         memcpy(l_copied_tccp->stepsizes, l_ref_tccp->stepsizes, l_size);
11162         ++l_copied_tccp;
11163     }
11164 }
11165
11166 static void opj_j2k_dump_tile_info(opj_tcp_t * l_default_tile,
11167                                    OPJ_INT32 numcomps, FILE* out_stream)
11168 {
11169     if (l_default_tile) {
11170         OPJ_INT32 compno;
11171
11172         fprintf(out_stream, "\t default tile {\n");
11173         fprintf(out_stream, "\t\t csty=%#x\n", l_default_tile->csty);
11174         fprintf(out_stream, "\t\t prg=%#x\n", l_default_tile->prg);
11175         fprintf(out_stream, "\t\t numlayers=%d\n", l_default_tile->numlayers);
11176         fprintf(out_stream, "\t\t mct=%x\n", l_default_tile->mct);
11177
11178         for (compno = 0; compno < numcomps; compno++) {
11179             opj_tccp_t *l_tccp = &(l_default_tile->tccps[compno]);
11180             OPJ_UINT32 resno;
11181             OPJ_INT32 bandno, numbands;
11182
11183             /* coding style*/
11184             fprintf(out_stream, "\t\t comp %d {\n", compno);
11185             fprintf(out_stream, "\t\t\t csty=%#x\n", l_tccp->csty);
11186             fprintf(out_stream, "\t\t\t numresolutions=%d\n", l_tccp->numresolutions);
11187             fprintf(out_stream, "\t\t\t cblkw=2^%d\n", l_tccp->cblkw);
11188             fprintf(out_stream, "\t\t\t cblkh=2^%d\n", l_tccp->cblkh);
11189             fprintf(out_stream, "\t\t\t cblksty=%#x\n", l_tccp->cblksty);
11190             fprintf(out_stream, "\t\t\t qmfbid=%d\n", l_tccp->qmfbid);
11191
11192             fprintf(out_stream, "\t\t\t preccintsize (w,h)=");
11193             for (resno = 0; resno < l_tccp->numresolutions; resno++) {
11194                 fprintf(out_stream, "(%d,%d) ", l_tccp->prcw[resno], l_tccp->prch[resno]);
11195             }
11196             fprintf(out_stream, "\n");
11197
11198             /* quantization style*/
11199             fprintf(out_stream, "\t\t\t qntsty=%d\n", l_tccp->qntsty);
11200             fprintf(out_stream, "\t\t\t numgbits=%d\n", l_tccp->numgbits);
11201             fprintf(out_stream, "\t\t\t stepsizes (m,e)=");
11202             numbands = (l_tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) ? 1 :
11203                        (OPJ_INT32)l_tccp->numresolutions * 3 - 2;
11204             for (bandno = 0; bandno < numbands; bandno++) {
11205                 fprintf(out_stream, "(%d,%d) ", l_tccp->stepsizes[bandno].mant,
11206                         l_tccp->stepsizes[bandno].expn);
11207             }
11208             fprintf(out_stream, "\n");
11209
11210             /* RGN value*/
11211             fprintf(out_stream, "\t\t\t roishift=%d\n", l_tccp->roishift);
11212
11213             fprintf(out_stream, "\t\t }\n");
11214         } /*end of component of default tile*/
11215         fprintf(out_stream, "\t }\n"); /*end of default tile*/
11216     }
11217 }
11218
11219 void j2k_dump(opj_j2k_t* p_j2k, OPJ_INT32 flag, FILE* out_stream)
11220 {
11221     /* Check if the flag is compatible with j2k file*/
11222     if ((flag & OPJ_JP2_INFO) || (flag & OPJ_JP2_IND)) {
11223         fprintf(out_stream, "Wrong flag\n");
11224         return;
11225     }
11226
11227     /* Dump the image_header */
11228     if (flag & OPJ_IMG_INFO) {
11229         if (p_j2k->m_private_image) {
11230             j2k_dump_image_header(p_j2k->m_private_image, 0, out_stream);
11231         }
11232     }
11233
11234     /* Dump the codestream info from main header */
11235     if (flag & OPJ_J2K_MH_INFO) {
11236         if (p_j2k->m_private_image) {
11237             opj_j2k_dump_MH_info(p_j2k, out_stream);
11238         }
11239     }
11240     /* Dump all tile/codestream info */
11241     if (flag & OPJ_J2K_TCH_INFO) {
11242         OPJ_UINT32 l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
11243         OPJ_UINT32 i;
11244         opj_tcp_t * l_tcp = p_j2k->m_cp.tcps;
11245         if (p_j2k->m_private_image) {
11246             for (i = 0; i < l_nb_tiles; ++i) {
11247                 opj_j2k_dump_tile_info(l_tcp, (OPJ_INT32)p_j2k->m_private_image->numcomps,
11248                                        out_stream);
11249                 ++l_tcp;
11250             }
11251         }
11252     }
11253
11254     /* Dump the codestream info of the current tile */
11255     if (flag & OPJ_J2K_TH_INFO) {
11256
11257     }
11258
11259     /* Dump the codestream index from main header */
11260     if (flag & OPJ_J2K_MH_IND) {
11261         opj_j2k_dump_MH_index(p_j2k, out_stream);
11262     }
11263
11264     /* Dump the codestream index of the current tile */
11265     if (flag & OPJ_J2K_TH_IND) {
11266
11267     }
11268
11269 }
11270
11271 static void opj_j2k_dump_MH_index(opj_j2k_t* p_j2k, FILE* out_stream)
11272 {
11273     opj_codestream_index_t* cstr_index = p_j2k->cstr_index;
11274     OPJ_UINT32 it_marker, it_tile, it_tile_part;
11275
11276     fprintf(out_stream, "Codestream index from main header: {\n");
11277
11278     fprintf(out_stream, "\t Main header start position=%" PRIi64 "\n"
11279             "\t Main header end position=%" PRIi64 "\n",
11280             cstr_index->main_head_start, cstr_index->main_head_end);
11281
11282     fprintf(out_stream, "\t Marker list: {\n");
11283
11284     if (cstr_index->marker) {
11285         for (it_marker = 0; it_marker < cstr_index->marknum ; it_marker++) {
11286             fprintf(out_stream, "\t\t type=%#x, pos=%" PRIi64 ", len=%d\n",
11287                     cstr_index->marker[it_marker].type,
11288                     cstr_index->marker[it_marker].pos,
11289                     cstr_index->marker[it_marker].len);
11290         }
11291     }
11292
11293     fprintf(out_stream, "\t }\n");
11294
11295     if (cstr_index->tile_index) {
11296
11297         /* Simple test to avoid to write empty information*/
11298         OPJ_UINT32 l_acc_nb_of_tile_part = 0;
11299         for (it_tile = 0; it_tile < cstr_index->nb_of_tiles ; it_tile++) {
11300             l_acc_nb_of_tile_part += cstr_index->tile_index[it_tile].nb_tps;
11301         }
11302
11303         if (l_acc_nb_of_tile_part) {
11304             fprintf(out_stream, "\t Tile index: {\n");
11305
11306             for (it_tile = 0; it_tile < cstr_index->nb_of_tiles ; it_tile++) {
11307                 OPJ_UINT32 nb_of_tile_part = cstr_index->tile_index[it_tile].nb_tps;
11308
11309                 fprintf(out_stream, "\t\t nb of tile-part in tile [%d]=%d\n", it_tile,
11310                         nb_of_tile_part);
11311
11312                 if (cstr_index->tile_index[it_tile].tp_index) {
11313                     for (it_tile_part = 0; it_tile_part < nb_of_tile_part; it_tile_part++) {
11314                         fprintf(out_stream, "\t\t\t tile-part[%d]: star_pos=%" PRIi64 ", end_header=%"
11315                                 PRIi64 ", end_pos=%" PRIi64 ".\n",
11316                                 it_tile_part,
11317                                 cstr_index->tile_index[it_tile].tp_index[it_tile_part].start_pos,
11318                                 cstr_index->tile_index[it_tile].tp_index[it_tile_part].end_header,
11319                                 cstr_index->tile_index[it_tile].tp_index[it_tile_part].end_pos);
11320                     }
11321                 }
11322
11323                 if (cstr_index->tile_index[it_tile].marker) {
11324                     for (it_marker = 0; it_marker < cstr_index->tile_index[it_tile].marknum ;
11325                             it_marker++) {
11326                         fprintf(out_stream, "\t\t type=%#x, pos=%" PRIi64 ", len=%d\n",
11327                                 cstr_index->tile_index[it_tile].marker[it_marker].type,
11328                                 cstr_index->tile_index[it_tile].marker[it_marker].pos,
11329                                 cstr_index->tile_index[it_tile].marker[it_marker].len);
11330                     }
11331                 }
11332             }
11333             fprintf(out_stream, "\t }\n");
11334         }
11335     }
11336
11337     fprintf(out_stream, "}\n");
11338
11339 }
11340
11341
11342 static void opj_j2k_dump_MH_info(opj_j2k_t* p_j2k, FILE* out_stream)
11343 {
11344
11345     fprintf(out_stream, "Codestream info from main header: {\n");
11346
11347     fprintf(out_stream, "\t tx0=%d, ty0=%d\n", p_j2k->m_cp.tx0, p_j2k->m_cp.ty0);
11348     fprintf(out_stream, "\t tdx=%d, tdy=%d\n", p_j2k->m_cp.tdx, p_j2k->m_cp.tdy);
11349     fprintf(out_stream, "\t tw=%d, th=%d\n", p_j2k->m_cp.tw, p_j2k->m_cp.th);
11350     opj_j2k_dump_tile_info(p_j2k->m_specific_param.m_decoder.m_default_tcp,
11351                            (OPJ_INT32)p_j2k->m_private_image->numcomps, out_stream);
11352     fprintf(out_stream, "}\n");
11353 }
11354
11355 void j2k_dump_image_header(opj_image_t* img_header, OPJ_BOOL dev_dump_flag,
11356                            FILE* out_stream)
11357 {
11358     char tab[2];
11359
11360     if (dev_dump_flag) {
11361         fprintf(stdout, "[DEV] Dump an image_header struct {\n");
11362         tab[0] = '\0';
11363     } else {
11364         fprintf(out_stream, "Image info {\n");
11365         tab[0] = '\t';
11366         tab[1] = '\0';
11367     }
11368
11369     fprintf(out_stream, "%s x0=%d, y0=%d\n", tab, img_header->x0, img_header->y0);
11370     fprintf(out_stream,     "%s x1=%d, y1=%d\n", tab, img_header->x1,
11371             img_header->y1);
11372     fprintf(out_stream, "%s numcomps=%d\n", tab, img_header->numcomps);
11373
11374     if (img_header->comps) {
11375         OPJ_UINT32 compno;
11376         for (compno = 0; compno < img_header->numcomps; compno++) {
11377             fprintf(out_stream, "%s\t component %d {\n", tab, compno);
11378             j2k_dump_image_comp_header(&(img_header->comps[compno]), dev_dump_flag,
11379                                        out_stream);
11380             fprintf(out_stream, "%s}\n", tab);
11381         }
11382     }
11383
11384     fprintf(out_stream, "}\n");
11385 }
11386
11387 void j2k_dump_image_comp_header(opj_image_comp_t* comp_header,
11388                                 OPJ_BOOL dev_dump_flag, FILE* out_stream)
11389 {
11390     char tab[3];
11391
11392     if (dev_dump_flag) {
11393         fprintf(stdout, "[DEV] Dump an image_comp_header struct {\n");
11394         tab[0] = '\0';
11395     }       else {
11396         tab[0] = '\t';
11397         tab[1] = '\t';
11398         tab[2] = '\0';
11399     }
11400
11401     fprintf(out_stream, "%s dx=%d, dy=%d\n", tab, comp_header->dx, comp_header->dy);
11402     fprintf(out_stream, "%s prec=%d\n", tab, comp_header->prec);
11403     fprintf(out_stream, "%s sgnd=%d\n", tab, comp_header->sgnd);
11404
11405     if (dev_dump_flag) {
11406         fprintf(out_stream, "}\n");
11407     }
11408 }
11409
11410 opj_codestream_info_v2_t* j2k_get_cstr_info(opj_j2k_t* p_j2k)
11411 {
11412     OPJ_UINT32 compno;
11413     OPJ_UINT32 numcomps = p_j2k->m_private_image->numcomps;
11414     opj_tcp_t *l_default_tile;
11415     opj_codestream_info_v2_t* cstr_info = (opj_codestream_info_v2_t*) opj_calloc(1,
11416                                           sizeof(opj_codestream_info_v2_t));
11417     if (!cstr_info) {
11418         return NULL;
11419     }
11420
11421     cstr_info->nbcomps = p_j2k->m_private_image->numcomps;
11422
11423     cstr_info->tx0 = p_j2k->m_cp.tx0;
11424     cstr_info->ty0 = p_j2k->m_cp.ty0;
11425     cstr_info->tdx = p_j2k->m_cp.tdx;
11426     cstr_info->tdy = p_j2k->m_cp.tdy;
11427     cstr_info->tw = p_j2k->m_cp.tw;
11428     cstr_info->th = p_j2k->m_cp.th;
11429
11430     cstr_info->tile_info = NULL; /* Not fill from the main header*/
11431
11432     l_default_tile = p_j2k->m_specific_param.m_decoder.m_default_tcp;
11433
11434     cstr_info->m_default_tile_info.csty = l_default_tile->csty;
11435     cstr_info->m_default_tile_info.prg = l_default_tile->prg;
11436     cstr_info->m_default_tile_info.numlayers = l_default_tile->numlayers;
11437     cstr_info->m_default_tile_info.mct = l_default_tile->mct;
11438
11439     cstr_info->m_default_tile_info.tccp_info = (opj_tccp_info_t*) opj_calloc(
11440                 cstr_info->nbcomps, sizeof(opj_tccp_info_t));
11441     if (!cstr_info->m_default_tile_info.tccp_info) {
11442         opj_destroy_cstr_info(&cstr_info);
11443         return NULL;
11444     }
11445
11446     for (compno = 0; compno < numcomps; compno++) {
11447         opj_tccp_t *l_tccp = &(l_default_tile->tccps[compno]);
11448         opj_tccp_info_t *l_tccp_info = &
11449                                        (cstr_info->m_default_tile_info.tccp_info[compno]);
11450         OPJ_INT32 bandno, numbands;
11451
11452         /* coding style*/
11453         l_tccp_info->csty = l_tccp->csty;
11454         l_tccp_info->numresolutions = l_tccp->numresolutions;
11455         l_tccp_info->cblkw = l_tccp->cblkw;
11456         l_tccp_info->cblkh = l_tccp->cblkh;
11457         l_tccp_info->cblksty = l_tccp->cblksty;
11458         l_tccp_info->qmfbid = l_tccp->qmfbid;
11459         if (l_tccp->numresolutions < OPJ_J2K_MAXRLVLS) {
11460             memcpy(l_tccp_info->prch, l_tccp->prch, l_tccp->numresolutions);
11461             memcpy(l_tccp_info->prcw, l_tccp->prcw, l_tccp->numresolutions);
11462         }
11463
11464         /* quantization style*/
11465         l_tccp_info->qntsty = l_tccp->qntsty;
11466         l_tccp_info->numgbits = l_tccp->numgbits;
11467
11468         numbands = (l_tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) ? 1 :
11469                    (OPJ_INT32)l_tccp->numresolutions * 3 - 2;
11470         if (numbands < OPJ_J2K_MAXBANDS) {
11471             for (bandno = 0; bandno < numbands; bandno++) {
11472                 l_tccp_info->stepsizes_mant[bandno] = (OPJ_UINT32)
11473                                                       l_tccp->stepsizes[bandno].mant;
11474                 l_tccp_info->stepsizes_expn[bandno] = (OPJ_UINT32)
11475                                                       l_tccp->stepsizes[bandno].expn;
11476             }
11477         }
11478
11479         /* RGN value*/
11480         l_tccp_info->roishift = l_tccp->roishift;
11481     }
11482
11483     return cstr_info;
11484 }
11485
11486 opj_codestream_index_t* j2k_get_cstr_index(opj_j2k_t* p_j2k)
11487 {
11488     opj_codestream_index_t* l_cstr_index = (opj_codestream_index_t*)
11489                                            opj_calloc(1, sizeof(opj_codestream_index_t));
11490     if (!l_cstr_index) {
11491         return NULL;
11492     }
11493
11494     l_cstr_index->main_head_start = p_j2k->cstr_index->main_head_start;
11495     l_cstr_index->main_head_end = p_j2k->cstr_index->main_head_end;
11496     l_cstr_index->codestream_size = p_j2k->cstr_index->codestream_size;
11497
11498     l_cstr_index->marknum = p_j2k->cstr_index->marknum;
11499     l_cstr_index->marker = (opj_marker_info_t*)opj_malloc(l_cstr_index->marknum *
11500                            sizeof(opj_marker_info_t));
11501     if (!l_cstr_index->marker) {
11502         opj_free(l_cstr_index);
11503         return NULL;
11504     }
11505
11506     if (p_j2k->cstr_index->marker) {
11507         memcpy(l_cstr_index->marker, p_j2k->cstr_index->marker,
11508                l_cstr_index->marknum * sizeof(opj_marker_info_t));
11509     } else {
11510         opj_free(l_cstr_index->marker);
11511         l_cstr_index->marker = NULL;
11512     }
11513
11514     l_cstr_index->nb_of_tiles = p_j2k->cstr_index->nb_of_tiles;
11515     l_cstr_index->tile_index = (opj_tile_index_t*)opj_calloc(
11516                                    l_cstr_index->nb_of_tiles, sizeof(opj_tile_index_t));
11517     if (!l_cstr_index->tile_index) {
11518         opj_free(l_cstr_index->marker);
11519         opj_free(l_cstr_index);
11520         return NULL;
11521     }
11522
11523     if (!p_j2k->cstr_index->tile_index) {
11524         opj_free(l_cstr_index->tile_index);
11525         l_cstr_index->tile_index = NULL;
11526     } else {
11527         OPJ_UINT32 it_tile = 0;
11528         for (it_tile = 0; it_tile < l_cstr_index->nb_of_tiles; it_tile++) {
11529
11530             /* Tile Marker*/
11531             l_cstr_index->tile_index[it_tile].marknum =
11532                 p_j2k->cstr_index->tile_index[it_tile].marknum;
11533
11534             l_cstr_index->tile_index[it_tile].marker =
11535                 (opj_marker_info_t*)opj_malloc(l_cstr_index->tile_index[it_tile].marknum *
11536                                                sizeof(opj_marker_info_t));
11537
11538             if (!l_cstr_index->tile_index[it_tile].marker) {
11539                 OPJ_UINT32 it_tile_free;
11540
11541                 for (it_tile_free = 0; it_tile_free < it_tile; it_tile_free++) {
11542                     opj_free(l_cstr_index->tile_index[it_tile_free].marker);
11543                 }
11544
11545                 opj_free(l_cstr_index->tile_index);
11546                 opj_free(l_cstr_index->marker);
11547                 opj_free(l_cstr_index);
11548                 return NULL;
11549             }
11550
11551             if (p_j2k->cstr_index->tile_index[it_tile].marker)
11552                 memcpy(l_cstr_index->tile_index[it_tile].marker,
11553                        p_j2k->cstr_index->tile_index[it_tile].marker,
11554                        l_cstr_index->tile_index[it_tile].marknum * sizeof(opj_marker_info_t));
11555             else {
11556                 opj_free(l_cstr_index->tile_index[it_tile].marker);
11557                 l_cstr_index->tile_index[it_tile].marker = NULL;
11558             }
11559
11560             /* Tile part index*/
11561             l_cstr_index->tile_index[it_tile].nb_tps =
11562                 p_j2k->cstr_index->tile_index[it_tile].nb_tps;
11563
11564             l_cstr_index->tile_index[it_tile].tp_index =
11565                 (opj_tp_index_t*)opj_malloc(l_cstr_index->tile_index[it_tile].nb_tps * sizeof(
11566                                                 opj_tp_index_t));
11567
11568             if (!l_cstr_index->tile_index[it_tile].tp_index) {
11569                 OPJ_UINT32 it_tile_free;
11570
11571                 for (it_tile_free = 0; it_tile_free < it_tile; it_tile_free++) {
11572                     opj_free(l_cstr_index->tile_index[it_tile_free].marker);
11573                     opj_free(l_cstr_index->tile_index[it_tile_free].tp_index);
11574                 }
11575
11576                 opj_free(l_cstr_index->tile_index);
11577                 opj_free(l_cstr_index->marker);
11578                 opj_free(l_cstr_index);
11579                 return NULL;
11580             }
11581
11582             if (p_j2k->cstr_index->tile_index[it_tile].tp_index) {
11583                 memcpy(l_cstr_index->tile_index[it_tile].tp_index,
11584                        p_j2k->cstr_index->tile_index[it_tile].tp_index,
11585                        l_cstr_index->tile_index[it_tile].nb_tps * sizeof(opj_tp_index_t));
11586             } else {
11587                 opj_free(l_cstr_index->tile_index[it_tile].tp_index);
11588                 l_cstr_index->tile_index[it_tile].tp_index = NULL;
11589             }
11590
11591             /* Packet index (NOT USED)*/
11592             l_cstr_index->tile_index[it_tile].nb_packet = 0;
11593             l_cstr_index->tile_index[it_tile].packet_index = NULL;
11594
11595         }
11596     }
11597
11598     return l_cstr_index;
11599 }
11600
11601 static OPJ_BOOL opj_j2k_allocate_tile_element_cstr_index(opj_j2k_t *p_j2k)
11602 {
11603     OPJ_UINT32 it_tile = 0;
11604
11605     p_j2k->cstr_index->nb_of_tiles = p_j2k->m_cp.tw * p_j2k->m_cp.th;
11606     p_j2k->cstr_index->tile_index = (opj_tile_index_t*)opj_calloc(
11607                                         p_j2k->cstr_index->nb_of_tiles, sizeof(opj_tile_index_t));
11608     if (!p_j2k->cstr_index->tile_index) {
11609         return OPJ_FALSE;
11610     }
11611
11612     for (it_tile = 0; it_tile < p_j2k->cstr_index->nb_of_tiles; it_tile++) {
11613         p_j2k->cstr_index->tile_index[it_tile].maxmarknum = 100;
11614         p_j2k->cstr_index->tile_index[it_tile].marknum = 0;
11615         p_j2k->cstr_index->tile_index[it_tile].marker = (opj_marker_info_t*)
11616                 opj_calloc(p_j2k->cstr_index->tile_index[it_tile].maxmarknum,
11617                            sizeof(opj_marker_info_t));
11618         if (!p_j2k->cstr_index->tile_index[it_tile].marker) {
11619             return OPJ_FALSE;
11620         }
11621     }
11622
11623     return OPJ_TRUE;
11624 }
11625
11626 static OPJ_BOOL opj_j2k_are_all_used_components_decoded(opj_j2k_t *p_j2k,
11627         opj_event_mgr_t * p_manager)
11628 {
11629     OPJ_UINT32 compno;
11630     OPJ_BOOL decoded_all_used_components = OPJ_TRUE;
11631
11632     if (p_j2k->m_specific_param.m_decoder.m_numcomps_to_decode) {
11633         for (compno = 0;
11634                 compno < p_j2k->m_specific_param.m_decoder.m_numcomps_to_decode; compno++) {
11635             OPJ_UINT32 dec_compno =
11636                 p_j2k->m_specific_param.m_decoder.m_comps_indices_to_decode[compno];
11637             if (p_j2k->m_output_image->comps[dec_compno].data == NULL) {
11638                 opj_event_msg(p_manager, EVT_WARNING, "Failed to decode component %d\n",
11639                               dec_compno);
11640                 decoded_all_used_components = OPJ_FALSE;
11641             }
11642         }
11643     } else {
11644         for (compno = 0; compno < p_j2k->m_output_image->numcomps; compno++) {
11645             if (p_j2k->m_output_image->comps[compno].data == NULL) {
11646                 opj_event_msg(p_manager, EVT_WARNING, "Failed to decode component %d\n",
11647                               compno);
11648                 decoded_all_used_components = OPJ_FALSE;
11649             }
11650         }
11651     }
11652
11653     if (decoded_all_used_components == OPJ_FALSE) {
11654         opj_event_msg(p_manager, EVT_ERROR, "Failed to decode all used components\n");
11655         return OPJ_FALSE;
11656     }
11657
11658     return OPJ_TRUE;
11659 }
11660
11661
11662 static OPJ_BOOL opj_j2k_decode_tiles(opj_j2k_t *p_j2k,
11663                                      opj_stream_private_t *p_stream,
11664                                      opj_event_mgr_t * p_manager)
11665 {
11666     OPJ_BOOL l_go_on = OPJ_TRUE;
11667     OPJ_UINT32 l_current_tile_no;
11668     OPJ_INT32 l_tile_x0, l_tile_y0, l_tile_x1, l_tile_y1;
11669     OPJ_UINT32 l_nb_comps;
11670     OPJ_UINT32 nr_tiles = 0;
11671
11672     /* Particular case for whole single tile decoding */
11673     /* We can avoid allocating intermediate tile buffers */
11674     if (p_j2k->m_cp.tw == 1 && p_j2k->m_cp.th == 1 &&
11675             p_j2k->m_cp.tx0 == 0 && p_j2k->m_cp.ty0 == 0 &&
11676             p_j2k->m_output_image->x0 == 0 &&
11677             p_j2k->m_output_image->y0 == 0 &&
11678             p_j2k->m_output_image->x1 == p_j2k->m_cp.tdx &&
11679             p_j2k->m_output_image->y1 == p_j2k->m_cp.tdy) {
11680         OPJ_UINT32 i;
11681         if (! opj_j2k_read_tile_header(p_j2k,
11682                                        &l_current_tile_no,
11683                                        NULL,
11684                                        &l_tile_x0, &l_tile_y0,
11685                                        &l_tile_x1, &l_tile_y1,
11686                                        &l_nb_comps,
11687                                        &l_go_on,
11688                                        p_stream,
11689                                        p_manager)) {
11690             return OPJ_FALSE;
11691         }
11692
11693         if (! opj_j2k_decode_tile(p_j2k, l_current_tile_no, NULL, 0,
11694                                   p_stream, p_manager)) {
11695             opj_event_msg(p_manager, EVT_ERROR, "Failed to decode tile 1/1\n");
11696             return OPJ_FALSE;
11697         }
11698
11699         /* Transfer TCD data to output image data */
11700         for (i = 0; i < p_j2k->m_output_image->numcomps; i++) {
11701             opj_image_data_free(p_j2k->m_output_image->comps[i].data);
11702             p_j2k->m_output_image->comps[i].data =
11703                 p_j2k->m_tcd->tcd_image->tiles->comps[i].data;
11704             p_j2k->m_output_image->comps[i].resno_decoded =
11705                 p_j2k->m_tcd->image->comps[i].resno_decoded;
11706             p_j2k->m_tcd->tcd_image->tiles->comps[i].data = NULL;
11707         }
11708
11709         return OPJ_TRUE;
11710     }
11711
11712     for (;;) {
11713         if (p_j2k->m_cp.tw == 1 && p_j2k->m_cp.th == 1 &&
11714                 p_j2k->m_cp.tcps[0].m_data != NULL) {
11715             l_current_tile_no = 0;
11716             p_j2k->m_current_tile_number = 0;
11717             p_j2k->m_specific_param.m_decoder.m_state |= J2K_STATE_DATA;
11718         } else {
11719             if (! opj_j2k_read_tile_header(p_j2k,
11720                                            &l_current_tile_no,
11721                                            NULL,
11722                                            &l_tile_x0, &l_tile_y0,
11723                                            &l_tile_x1, &l_tile_y1,
11724                                            &l_nb_comps,
11725                                            &l_go_on,
11726                                            p_stream,
11727                                            p_manager)) {
11728                 return OPJ_FALSE;
11729             }
11730
11731             if (! l_go_on) {
11732                 break;
11733             }
11734         }
11735
11736         if (! opj_j2k_decode_tile(p_j2k, l_current_tile_no, NULL, 0,
11737                                   p_stream, p_manager)) {
11738             opj_event_msg(p_manager, EVT_ERROR, "Failed to decode tile %d/%d\n",
11739                           l_current_tile_no + 1, p_j2k->m_cp.th * p_j2k->m_cp.tw);
11740             return OPJ_FALSE;
11741         }
11742
11743         opj_event_msg(p_manager, EVT_INFO, "Tile %d/%d has been decoded.\n",
11744                       l_current_tile_no + 1, p_j2k->m_cp.th * p_j2k->m_cp.tw);
11745
11746         if (! opj_j2k_update_image_data(p_j2k->m_tcd,
11747                                         p_j2k->m_output_image)) {
11748             return OPJ_FALSE;
11749         }
11750
11751         if (p_j2k->m_cp.tw == 1 && p_j2k->m_cp.th == 1 &&
11752                 !(p_j2k->m_output_image->x0 == p_j2k->m_private_image->x0 &&
11753                   p_j2k->m_output_image->y0 == p_j2k->m_private_image->y0 &&
11754                   p_j2k->m_output_image->x1 == p_j2k->m_private_image->x1 &&
11755                   p_j2k->m_output_image->y1 == p_j2k->m_private_image->y1)) {
11756             /* Keep current tcp data */
11757         } else {
11758             opj_j2k_tcp_data_destroy(&p_j2k->m_cp.tcps[l_current_tile_no]);
11759         }
11760
11761         opj_event_msg(p_manager, EVT_INFO,
11762                       "Image data has been updated with tile %d.\n\n", l_current_tile_no + 1);
11763
11764         if (opj_stream_get_number_byte_left(p_stream) == 0
11765                 && p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_NEOC) {
11766             break;
11767         }
11768         if (++nr_tiles ==  p_j2k->m_cp.th * p_j2k->m_cp.tw) {
11769             break;
11770         }
11771     }
11772
11773     if (! opj_j2k_are_all_used_components_decoded(p_j2k, p_manager)) {
11774         return OPJ_FALSE;
11775     }
11776
11777     return OPJ_TRUE;
11778 }
11779
11780 /**
11781  * Sets up the procedures to do on decoding data. Developers wanting to extend the library can add their own reading procedures.
11782  */
11783 static OPJ_BOOL opj_j2k_setup_decoding(opj_j2k_t *p_j2k,
11784                                        opj_event_mgr_t * p_manager)
11785 {
11786     /* preconditions*/
11787     assert(p_j2k != 00);
11788     assert(p_manager != 00);
11789
11790     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
11791                                            (opj_procedure)opj_j2k_decode_tiles, p_manager)) {
11792         return OPJ_FALSE;
11793     }
11794     /* DEVELOPER CORNER, add your custom procedures */
11795
11796     return OPJ_TRUE;
11797 }
11798
11799 /*
11800  * Read and decode one tile.
11801  */
11802 static OPJ_BOOL opj_j2k_decode_one_tile(opj_j2k_t *p_j2k,
11803                                         opj_stream_private_t *p_stream,
11804                                         opj_event_mgr_t * p_manager)
11805 {
11806     OPJ_BOOL l_go_on = OPJ_TRUE;
11807     OPJ_UINT32 l_current_tile_no;
11808     OPJ_UINT32 l_tile_no_to_dec;
11809     OPJ_INT32 l_tile_x0, l_tile_y0, l_tile_x1, l_tile_y1;
11810     OPJ_UINT32 l_nb_comps;
11811     OPJ_UINT32 l_nb_tiles;
11812     OPJ_UINT32 i;
11813
11814     /*Allocate and initialize some elements of codestrem index if not already done*/
11815     if (!p_j2k->cstr_index->tile_index) {
11816         if (!opj_j2k_allocate_tile_element_cstr_index(p_j2k)) {
11817             return OPJ_FALSE;
11818         }
11819     }
11820     /* Move into the codestream to the first SOT used to decode the desired tile */
11821     l_tile_no_to_dec = (OPJ_UINT32)
11822                        p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec;
11823     if (p_j2k->cstr_index->tile_index)
11824         if (p_j2k->cstr_index->tile_index->tp_index) {
11825             if (! p_j2k->cstr_index->tile_index[l_tile_no_to_dec].nb_tps) {
11826                 /* the index for this tile has not been built,
11827                  *  so move to the last SOT read */
11828                 if (!(opj_stream_read_seek(p_stream,
11829                                            p_j2k->m_specific_param.m_decoder.m_last_sot_read_pos + 2, p_manager))) {
11830                     opj_event_msg(p_manager, EVT_ERROR, "Problem with seek function\n");
11831                     return OPJ_FALSE;
11832                 }
11833             } else {
11834                 if (!(opj_stream_read_seek(p_stream,
11835                                            p_j2k->cstr_index->tile_index[l_tile_no_to_dec].tp_index[0].start_pos + 2,
11836                                            p_manager))) {
11837                     opj_event_msg(p_manager, EVT_ERROR, "Problem with seek function\n");
11838                     return OPJ_FALSE;
11839                 }
11840             }
11841             /* Special case if we have previously read the EOC marker (if the previous tile getted is the last ) */
11842             if (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_EOC) {
11843                 p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_TPHSOT;
11844             }
11845         }
11846
11847     /* Reset current tile part number for all tiles, and not only the one */
11848     /* of interest. */
11849     /* Not completely sure this is always correct but required for */
11850     /* ./build/bin/j2k_random_tile_access ./build/tests/tte1.j2k */
11851     l_nb_tiles = p_j2k->m_cp.tw * p_j2k->m_cp.th;
11852     for (i = 0; i < l_nb_tiles; ++i) {
11853         p_j2k->m_cp.tcps[i].m_current_tile_part_number = -1;
11854     }
11855
11856     for (;;) {
11857         if (! opj_j2k_read_tile_header(p_j2k,
11858                                        &l_current_tile_no,
11859                                        NULL,
11860                                        &l_tile_x0, &l_tile_y0,
11861                                        &l_tile_x1, &l_tile_y1,
11862                                        &l_nb_comps,
11863                                        &l_go_on,
11864                                        p_stream,
11865                                        p_manager)) {
11866             return OPJ_FALSE;
11867         }
11868
11869         if (! l_go_on) {
11870             break;
11871         }
11872
11873         if (! opj_j2k_decode_tile(p_j2k, l_current_tile_no, NULL, 0,
11874                                   p_stream, p_manager)) {
11875             return OPJ_FALSE;
11876         }
11877         opj_event_msg(p_manager, EVT_INFO, "Tile %d/%d has been decoded.\n",
11878                       l_current_tile_no + 1, p_j2k->m_cp.th * p_j2k->m_cp.tw);
11879
11880         if (! opj_j2k_update_image_data(p_j2k->m_tcd,
11881                                         p_j2k->m_output_image)) {
11882             return OPJ_FALSE;
11883         }
11884         opj_j2k_tcp_data_destroy(&p_j2k->m_cp.tcps[l_current_tile_no]);
11885
11886         opj_event_msg(p_manager, EVT_INFO,
11887                       "Image data has been updated with tile %d.\n\n", l_current_tile_no + 1);
11888
11889         if (l_current_tile_no == l_tile_no_to_dec) {
11890             /* move into the codestream to the first SOT (FIXME or not move?)*/
11891             if (!(opj_stream_read_seek(p_stream, p_j2k->cstr_index->main_head_end + 2,
11892                                        p_manager))) {
11893                 opj_event_msg(p_manager, EVT_ERROR, "Problem with seek function\n");
11894                 return OPJ_FALSE;
11895             }
11896             break;
11897         } else {
11898             opj_event_msg(p_manager, EVT_WARNING,
11899                           "Tile read, decoded and updated is not the desired one (%d vs %d).\n",
11900                           l_current_tile_no + 1, l_tile_no_to_dec + 1);
11901         }
11902
11903     }
11904
11905     if (! opj_j2k_are_all_used_components_decoded(p_j2k, p_manager)) {
11906         return OPJ_FALSE;
11907     }
11908
11909     return OPJ_TRUE;
11910 }
11911
11912 /**
11913  * Sets up the procedures to do on decoding one tile. Developers wanting to extend the library can add their own reading procedures.
11914  */
11915 static OPJ_BOOL opj_j2k_setup_decoding_tile(opj_j2k_t *p_j2k,
11916         opj_event_mgr_t * p_manager)
11917 {
11918     /* preconditions*/
11919     assert(p_j2k != 00);
11920     assert(p_manager != 00);
11921
11922     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
11923                                            (opj_procedure)opj_j2k_decode_one_tile, p_manager)) {
11924         return OPJ_FALSE;
11925     }
11926     /* DEVELOPER CORNER, add your custom procedures */
11927
11928     return OPJ_TRUE;
11929 }
11930
11931 static OPJ_BOOL opj_j2k_move_data_from_codec_to_output_image(opj_j2k_t * p_j2k,
11932         opj_image_t * p_image)
11933 {
11934     OPJ_UINT32 compno;
11935
11936     /* Move data and copy one information from codec to output image*/
11937     if (p_j2k->m_specific_param.m_decoder.m_numcomps_to_decode > 0) {
11938         opj_image_comp_t* newcomps =
11939             (opj_image_comp_t*) opj_malloc(
11940                 p_j2k->m_specific_param.m_decoder.m_numcomps_to_decode *
11941                 sizeof(opj_image_comp_t));
11942         if (newcomps == NULL) {
11943             opj_image_destroy(p_j2k->m_private_image);
11944             p_j2k->m_private_image = NULL;
11945             return OPJ_FALSE;
11946         }
11947         for (compno = 0; compno < p_image->numcomps; compno++) {
11948             opj_image_data_free(p_image->comps[compno].data);
11949             p_image->comps[compno].data = NULL;
11950         }
11951         for (compno = 0;
11952                 compno < p_j2k->m_specific_param.m_decoder.m_numcomps_to_decode; compno++) {
11953             OPJ_UINT32 src_compno =
11954                 p_j2k->m_specific_param.m_decoder.m_comps_indices_to_decode[compno];
11955             memcpy(&(newcomps[compno]),
11956                    &(p_j2k->m_output_image->comps[src_compno]),
11957                    sizeof(opj_image_comp_t));
11958             newcomps[compno].resno_decoded =
11959                 p_j2k->m_output_image->comps[src_compno].resno_decoded;
11960             newcomps[compno].data = p_j2k->m_output_image->comps[src_compno].data;
11961             p_j2k->m_output_image->comps[src_compno].data = NULL;
11962         }
11963         for (compno = 0; compno < p_image->numcomps; compno++) {
11964             assert(p_j2k->m_output_image->comps[compno].data == NULL);
11965             opj_image_data_free(p_j2k->m_output_image->comps[compno].data);
11966             p_j2k->m_output_image->comps[compno].data = NULL;
11967         }
11968         p_image->numcomps = p_j2k->m_specific_param.m_decoder.m_numcomps_to_decode;
11969         opj_free(p_image->comps);
11970         p_image->comps = newcomps;
11971     } else {
11972         for (compno = 0; compno < p_image->numcomps; compno++) {
11973             p_image->comps[compno].resno_decoded =
11974                 p_j2k->m_output_image->comps[compno].resno_decoded;
11975             opj_image_data_free(p_image->comps[compno].data);
11976             p_image->comps[compno].data = p_j2k->m_output_image->comps[compno].data;
11977 #if 0
11978             char fn[256];
11979             snprintf(fn, sizeof fn, "/tmp/%d.raw", compno);
11980             FILE *debug = fopen(fn, "wb");
11981             fwrite(p_image->comps[compno].data, sizeof(OPJ_INT32),
11982                    p_image->comps[compno].w * p_image->comps[compno].h, debug);
11983             fclose(debug);
11984 #endif
11985             p_j2k->m_output_image->comps[compno].data = NULL;
11986         }
11987     }
11988     return OPJ_TRUE;
11989 }
11990
11991 OPJ_BOOL opj_j2k_decode(opj_j2k_t * p_j2k,
11992                         opj_stream_private_t * p_stream,
11993                         opj_image_t * p_image,
11994                         opj_event_mgr_t * p_manager)
11995 {
11996     if (!p_image) {
11997         return OPJ_FALSE;
11998     }
11999
12000     /* Heuristics to detect sequence opj_read_header(), opj_set_decoded_resolution_factor() */
12001     /* and finally opj_decode_image() without manual setting of comps[].factor */
12002     /* We could potentially always execute it, if we don't allow people to do */
12003     /* opj_read_header(), modify x0,y0,x1,y1 of returned image an call opj_decode_image() */
12004     if (p_j2k->m_cp.m_specific_param.m_dec.m_reduce > 0 &&
12005             p_j2k->m_private_image != NULL &&
12006             p_j2k->m_private_image->numcomps > 0 &&
12007             p_j2k->m_private_image->comps[0].factor ==
12008             p_j2k->m_cp.m_specific_param.m_dec.m_reduce &&
12009             p_image->numcomps > 0 &&
12010             p_image->comps[0].factor == 0 &&
12011             /* Don't mess with image dimension if the user has allocated it */
12012             p_image->comps[0].data == NULL) {
12013         OPJ_UINT32 it_comp;
12014
12015         /* Update the comps[].factor member of the output image with the one */
12016         /* of m_reduce */
12017         for (it_comp = 0; it_comp < p_image->numcomps; ++it_comp) {
12018             p_image->comps[it_comp].factor = p_j2k->m_cp.m_specific_param.m_dec.m_reduce;
12019         }
12020         if (!opj_j2k_update_image_dimensions(p_image, p_manager)) {
12021             return OPJ_FALSE;
12022         }
12023     }
12024
12025     if (p_j2k->m_output_image == NULL) {
12026         p_j2k->m_output_image = opj_image_create0();
12027         if (!(p_j2k->m_output_image)) {
12028             return OPJ_FALSE;
12029         }
12030     }
12031     opj_copy_image_header(p_image, p_j2k->m_output_image);
12032
12033     /* customization of the decoding */
12034     if (!opj_j2k_setup_decoding(p_j2k, p_manager)) {
12035         return OPJ_FALSE;
12036     }
12037
12038     /* Decode the codestream */
12039     if (! opj_j2k_exec(p_j2k, p_j2k->m_procedure_list, p_stream, p_manager)) {
12040         opj_image_destroy(p_j2k->m_private_image);
12041         p_j2k->m_private_image = NULL;
12042         return OPJ_FALSE;
12043     }
12044
12045     /* Move data and copy one information from codec to output image*/
12046     return opj_j2k_move_data_from_codec_to_output_image(p_j2k, p_image);
12047 }
12048
12049 OPJ_BOOL opj_j2k_get_tile(opj_j2k_t *p_j2k,
12050                           opj_stream_private_t *p_stream,
12051                           opj_image_t* p_image,
12052                           opj_event_mgr_t * p_manager,
12053                           OPJ_UINT32 tile_index)
12054 {
12055     OPJ_UINT32 compno;
12056     OPJ_UINT32 l_tile_x, l_tile_y;
12057     opj_image_comp_t* l_img_comp;
12058
12059     if (!p_image) {
12060         opj_event_msg(p_manager, EVT_ERROR, "We need an image previously created.\n");
12061         return OPJ_FALSE;
12062     }
12063
12064     if (p_image->numcomps < p_j2k->m_private_image->numcomps) {
12065         opj_event_msg(p_manager, EVT_ERROR,
12066                       "Image has less components than codestream.\n");
12067         return OPJ_FALSE;
12068     }
12069
12070     if (/*(tile_index < 0) &&*/ (tile_index >= p_j2k->m_cp.tw * p_j2k->m_cp.th)) {
12071         opj_event_msg(p_manager, EVT_ERROR,
12072                       "Tile index provided by the user is incorrect %d (max = %d) \n", tile_index,
12073                       (p_j2k->m_cp.tw * p_j2k->m_cp.th) - 1);
12074         return OPJ_FALSE;
12075     }
12076
12077     /* Compute the dimension of the desired tile*/
12078     l_tile_x = tile_index % p_j2k->m_cp.tw;
12079     l_tile_y = tile_index / p_j2k->m_cp.tw;
12080
12081     p_image->x0 = l_tile_x * p_j2k->m_cp.tdx + p_j2k->m_cp.tx0;
12082     if (p_image->x0 < p_j2k->m_private_image->x0) {
12083         p_image->x0 = p_j2k->m_private_image->x0;
12084     }
12085     p_image->x1 = (l_tile_x + 1) * p_j2k->m_cp.tdx + p_j2k->m_cp.tx0;
12086     if (p_image->x1 > p_j2k->m_private_image->x1) {
12087         p_image->x1 = p_j2k->m_private_image->x1;
12088     }
12089
12090     p_image->y0 = l_tile_y * p_j2k->m_cp.tdy + p_j2k->m_cp.ty0;
12091     if (p_image->y0 < p_j2k->m_private_image->y0) {
12092         p_image->y0 = p_j2k->m_private_image->y0;
12093     }
12094     p_image->y1 = (l_tile_y + 1) * p_j2k->m_cp.tdy + p_j2k->m_cp.ty0;
12095     if (p_image->y1 > p_j2k->m_private_image->y1) {
12096         p_image->y1 = p_j2k->m_private_image->y1;
12097     }
12098
12099     l_img_comp = p_image->comps;
12100     for (compno = 0; compno < p_j2k->m_private_image->numcomps; ++compno) {
12101         OPJ_INT32 l_comp_x1, l_comp_y1;
12102
12103         l_img_comp->factor = p_j2k->m_private_image->comps[compno].factor;
12104
12105         l_img_comp->x0 = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)p_image->x0,
12106                          (OPJ_INT32)l_img_comp->dx);
12107         l_img_comp->y0 = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)p_image->y0,
12108                          (OPJ_INT32)l_img_comp->dy);
12109         l_comp_x1 = opj_int_ceildiv((OPJ_INT32)p_image->x1, (OPJ_INT32)l_img_comp->dx);
12110         l_comp_y1 = opj_int_ceildiv((OPJ_INT32)p_image->y1, (OPJ_INT32)l_img_comp->dy);
12111
12112         l_img_comp->w = (OPJ_UINT32)(opj_int_ceildivpow2(l_comp_x1,
12113                                      (OPJ_INT32)l_img_comp->factor) - opj_int_ceildivpow2((OPJ_INT32)l_img_comp->x0,
12114                                              (OPJ_INT32)l_img_comp->factor));
12115         l_img_comp->h = (OPJ_UINT32)(opj_int_ceildivpow2(l_comp_y1,
12116                                      (OPJ_INT32)l_img_comp->factor) - opj_int_ceildivpow2((OPJ_INT32)l_img_comp->y0,
12117                                              (OPJ_INT32)l_img_comp->factor));
12118
12119         l_img_comp++;
12120     }
12121
12122     if (p_image->numcomps > p_j2k->m_private_image->numcomps) {
12123         /* Can happen when calling repeatdly opj_get_decoded_tile() on an
12124          * image with a color palette, where color palette expansion is done
12125          * later in jp2.c */
12126         for (compno = p_j2k->m_private_image->numcomps; compno < p_image->numcomps;
12127                 ++compno) {
12128             opj_image_data_free(p_image->comps[compno].data);
12129             p_image->comps[compno].data = NULL;
12130         }
12131         p_image->numcomps = p_j2k->m_private_image->numcomps;
12132     }
12133
12134     /* Destroy the previous output image*/
12135     if (p_j2k->m_output_image) {
12136         opj_image_destroy(p_j2k->m_output_image);
12137     }
12138
12139     /* Create the output image from the information previously computed*/
12140     p_j2k->m_output_image = opj_image_create0();
12141     if (!(p_j2k->m_output_image)) {
12142         return OPJ_FALSE;
12143     }
12144     opj_copy_image_header(p_image, p_j2k->m_output_image);
12145
12146     p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec = (OPJ_INT32)tile_index;
12147
12148     /* customization of the decoding */
12149     if (!opj_j2k_setup_decoding_tile(p_j2k, p_manager)) {
12150         return OPJ_FALSE;
12151     }
12152
12153     /* Decode the codestream */
12154     if (! opj_j2k_exec(p_j2k, p_j2k->m_procedure_list, p_stream, p_manager)) {
12155         opj_image_destroy(p_j2k->m_private_image);
12156         p_j2k->m_private_image = NULL;
12157         return OPJ_FALSE;
12158     }
12159
12160     /* Move data and copy one information from codec to output image*/
12161     return opj_j2k_move_data_from_codec_to_output_image(p_j2k, p_image);
12162 }
12163
12164 OPJ_BOOL opj_j2k_set_decoded_resolution_factor(opj_j2k_t *p_j2k,
12165         OPJ_UINT32 res_factor,
12166         opj_event_mgr_t * p_manager)
12167 {
12168     OPJ_UINT32 it_comp;
12169
12170     p_j2k->m_cp.m_specific_param.m_dec.m_reduce = res_factor;
12171
12172     if (p_j2k->m_private_image) {
12173         if (p_j2k->m_private_image->comps) {
12174             if (p_j2k->m_specific_param.m_decoder.m_default_tcp) {
12175                 if (p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps) {
12176                     for (it_comp = 0 ; it_comp < p_j2k->m_private_image->numcomps; it_comp++) {
12177                         OPJ_UINT32 max_res =
12178                             p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps[it_comp].numresolutions;
12179                         if (res_factor >= max_res) {
12180                             opj_event_msg(p_manager, EVT_ERROR,
12181                                           "Resolution factor is greater than the maximum resolution in the component.\n");
12182                             return OPJ_FALSE;
12183                         }
12184                         p_j2k->m_private_image->comps[it_comp].factor = res_factor;
12185                     }
12186                     return OPJ_TRUE;
12187                 }
12188             }
12189         }
12190     }
12191
12192     return OPJ_FALSE;
12193 }
12194
12195 /* ----------------------------------------------------------------------- */
12196
12197 OPJ_BOOL opj_j2k_encoder_set_extra_options(
12198     opj_j2k_t *p_j2k,
12199     const char* const* p_options,
12200     opj_event_mgr_t * p_manager)
12201 {
12202     const char* const* p_option_iter;
12203
12204     if (p_options == NULL) {
12205         return OPJ_TRUE;
12206     }
12207
12208     for (p_option_iter = p_options; *p_option_iter != NULL; ++p_option_iter) {
12209         if (strncmp(*p_option_iter, "PLT=", 4) == 0) {
12210             if (strcmp(*p_option_iter, "PLT=YES") == 0) {
12211                 p_j2k->m_specific_param.m_encoder.m_PLT = OPJ_TRUE;
12212             } else if (strcmp(*p_option_iter, "PLT=NO") == 0) {
12213                 p_j2k->m_specific_param.m_encoder.m_PLT = OPJ_FALSE;
12214             } else {
12215                 opj_event_msg(p_manager, EVT_ERROR,
12216                               "Invalid value for option: %s.\n", *p_option_iter);
12217                 return OPJ_FALSE;
12218             }
12219         } else if (strncmp(*p_option_iter, "TLM=", 4) == 0) {
12220             if (strcmp(*p_option_iter, "TLM=YES") == 0) {
12221                 p_j2k->m_specific_param.m_encoder.m_TLM = OPJ_TRUE;
12222             } else if (strcmp(*p_option_iter, "TLM=NO") == 0) {
12223                 p_j2k->m_specific_param.m_encoder.m_TLM = OPJ_FALSE;
12224             } else {
12225                 opj_event_msg(p_manager, EVT_ERROR,
12226                               "Invalid value for option: %s.\n", *p_option_iter);
12227                 return OPJ_FALSE;
12228             }
12229         } else if (strncmp(*p_option_iter, "GUARD_BITS=", strlen("GUARD_BITS=")) == 0) {
12230             OPJ_UINT32 tileno;
12231             opj_cp_t *cp = cp = &(p_j2k->m_cp);
12232
12233             int numgbits = atoi(*p_option_iter + strlen("GUARD_BITS="));
12234             if (numgbits < 0 || numgbits > 7) {
12235                 opj_event_msg(p_manager, EVT_ERROR,
12236                               "Invalid value for option: %s. Should be in [0,7]\n", *p_option_iter);
12237                 return OPJ_FALSE;
12238             }
12239
12240             for (tileno = 0; tileno < cp->tw * cp->th; tileno++) {
12241                 OPJ_UINT32 i;
12242                 opj_tcp_t *tcp = &cp->tcps[tileno];
12243                 for (i = 0; i < p_j2k->m_specific_param.m_encoder.m_nb_comps; i++) {
12244                     opj_tccp_t *tccp = &tcp->tccps[i];
12245                     tccp->numgbits = (OPJ_UINT32)numgbits;
12246                 }
12247             }
12248         } else {
12249             opj_event_msg(p_manager, EVT_ERROR,
12250                           "Invalid option: %s.\n", *p_option_iter);
12251             return OPJ_FALSE;
12252         }
12253     }
12254
12255     return OPJ_TRUE;
12256 }
12257
12258 /* ----------------------------------------------------------------------- */
12259
12260 OPJ_BOOL opj_j2k_encode(opj_j2k_t * p_j2k,
12261                         opj_stream_private_t *p_stream,
12262                         opj_event_mgr_t * p_manager)
12263 {
12264     OPJ_UINT32 i, j;
12265     OPJ_UINT32 l_nb_tiles;
12266     OPJ_SIZE_T l_max_tile_size = 0, l_current_tile_size;
12267     OPJ_BYTE * l_current_data = 00;
12268     OPJ_BOOL l_reuse_data = OPJ_FALSE;
12269     opj_tcd_t* p_tcd = 00;
12270
12271     /* preconditions */
12272     assert(p_j2k != 00);
12273     assert(p_stream != 00);
12274     assert(p_manager != 00);
12275
12276     p_tcd = p_j2k->m_tcd;
12277
12278     l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
12279     if (l_nb_tiles == 1) {
12280         l_reuse_data = OPJ_TRUE;
12281 #ifdef __SSE__
12282         for (j = 0; j < p_j2k->m_tcd->image->numcomps; ++j) {
12283             opj_image_comp_t * l_img_comp = p_tcd->image->comps + j;
12284             if (((size_t)l_img_comp->data & 0xFU) !=
12285                     0U) { /* tile data shall be aligned on 16 bytes */
12286                 l_reuse_data = OPJ_FALSE;
12287             }
12288         }
12289 #endif
12290     }
12291     for (i = 0; i < l_nb_tiles; ++i) {
12292         if (! opj_j2k_pre_write_tile(p_j2k, i, p_stream, p_manager)) {
12293             if (l_current_data) {
12294                 opj_free(l_current_data);
12295             }
12296             return OPJ_FALSE;
12297         }
12298
12299         /* if we only have one tile, then simply set tile component data equal to image component data */
12300         /* otherwise, allocate the data */
12301         for (j = 0; j < p_j2k->m_tcd->image->numcomps; ++j) {
12302             opj_tcd_tilecomp_t* l_tilec = p_tcd->tcd_image->tiles->comps + j;
12303             if (l_reuse_data) {
12304                 opj_image_comp_t * l_img_comp = p_tcd->image->comps + j;
12305                 l_tilec->data  =  l_img_comp->data;
12306                 l_tilec->ownsData = OPJ_FALSE;
12307             } else {
12308                 if (! opj_alloc_tile_component_data(l_tilec)) {
12309                     opj_event_msg(p_manager, EVT_ERROR, "Error allocating tile component data.");
12310                     if (l_current_data) {
12311                         opj_free(l_current_data);
12312                     }
12313                     return OPJ_FALSE;
12314                 }
12315             }
12316         }
12317         l_current_tile_size = opj_tcd_get_encoder_input_buffer_size(p_j2k->m_tcd);
12318         if (!l_reuse_data) {
12319             if (l_current_tile_size > l_max_tile_size) {
12320                 OPJ_BYTE *l_new_current_data = (OPJ_BYTE *) opj_realloc(l_current_data,
12321                                                l_current_tile_size);
12322                 if (! l_new_current_data) {
12323                     if (l_current_data) {
12324                         opj_free(l_current_data);
12325                     }
12326                     opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to encode all tiles\n");
12327                     return OPJ_FALSE;
12328                 }
12329                 l_current_data = l_new_current_data;
12330                 l_max_tile_size = l_current_tile_size;
12331             }
12332             if (l_current_data == NULL) {
12333                 /* Should not happen in practice, but will avoid Coverity to */
12334                 /* complain about a null pointer dereference */
12335                 assert(0);
12336                 return OPJ_FALSE;
12337             }
12338
12339             /* copy image data (32 bit) to l_current_data as contiguous, all-component, zero offset buffer */
12340             /* 32 bit components @ 8 bit precision get converted to 8 bit */
12341             /* 32 bit components @ 16 bit precision get converted to 16 bit */
12342             opj_j2k_get_tile_data(p_j2k->m_tcd, l_current_data);
12343
12344             /* now copy this data into the tile component */
12345             if (! opj_tcd_copy_tile_data(p_j2k->m_tcd, l_current_data,
12346                                          l_current_tile_size)) {
12347                 opj_event_msg(p_manager, EVT_ERROR,
12348                               "Size mismatch between tile data and sent data.");
12349                 opj_free(l_current_data);
12350                 return OPJ_FALSE;
12351             }
12352         }
12353
12354         if (! opj_j2k_post_write_tile(p_j2k, p_stream, p_manager)) {
12355             if (l_current_data) {
12356                 opj_free(l_current_data);
12357             }
12358             return OPJ_FALSE;
12359         }
12360     }
12361
12362     if (l_current_data) {
12363         opj_free(l_current_data);
12364     }
12365     return OPJ_TRUE;
12366 }
12367
12368 OPJ_BOOL opj_j2k_end_compress(opj_j2k_t *p_j2k,
12369                               opj_stream_private_t *p_stream,
12370                               opj_event_mgr_t * p_manager)
12371 {
12372     /* customization of the encoding */
12373     if (! opj_j2k_setup_end_compress(p_j2k, p_manager)) {
12374         return OPJ_FALSE;
12375     }
12376
12377     if (! opj_j2k_exec(p_j2k, p_j2k->m_procedure_list, p_stream, p_manager)) {
12378         return OPJ_FALSE;
12379     }
12380
12381     return OPJ_TRUE;
12382 }
12383
12384 OPJ_BOOL opj_j2k_start_compress(opj_j2k_t *p_j2k,
12385                                 opj_stream_private_t *p_stream,
12386                                 opj_image_t * p_image,
12387                                 opj_event_mgr_t * p_manager)
12388 {
12389     /* preconditions */
12390     assert(p_j2k != 00);
12391     assert(p_stream != 00);
12392     assert(p_manager != 00);
12393
12394     p_j2k->m_private_image = opj_image_create0();
12395     if (! p_j2k->m_private_image) {
12396         opj_event_msg(p_manager, EVT_ERROR, "Failed to allocate image header.");
12397         return OPJ_FALSE;
12398     }
12399     opj_copy_image_header(p_image, p_j2k->m_private_image);
12400
12401     /* TODO_MSD: Find a better way */
12402     if (p_image->comps) {
12403         OPJ_UINT32 it_comp;
12404         for (it_comp = 0 ; it_comp < p_image->numcomps; it_comp++) {
12405             if (p_image->comps[it_comp].data) {
12406                 p_j2k->m_private_image->comps[it_comp].data = p_image->comps[it_comp].data;
12407                 p_image->comps[it_comp].data = NULL;
12408
12409             }
12410         }
12411     }
12412
12413     /* customization of the validation */
12414     if (! opj_j2k_setup_encoding_validation(p_j2k, p_manager)) {
12415         return OPJ_FALSE;
12416     }
12417
12418     /* validation of the parameters codec */
12419     if (! opj_j2k_exec(p_j2k, p_j2k->m_validation_list, p_stream, p_manager)) {
12420         return OPJ_FALSE;
12421     }
12422
12423     /* customization of the encoding */
12424     if (! opj_j2k_setup_header_writing(p_j2k, p_manager)) {
12425         return OPJ_FALSE;
12426     }
12427
12428     /* write header */
12429     if (! opj_j2k_exec(p_j2k, p_j2k->m_procedure_list, p_stream, p_manager)) {
12430         return OPJ_FALSE;
12431     }
12432
12433     return OPJ_TRUE;
12434 }
12435
12436 static OPJ_BOOL opj_j2k_pre_write_tile(opj_j2k_t * p_j2k,
12437                                        OPJ_UINT32 p_tile_index,
12438                                        opj_stream_private_t *p_stream,
12439                                        opj_event_mgr_t * p_manager)
12440 {
12441     (void)p_stream;
12442     if (p_tile_index != p_j2k->m_current_tile_number) {
12443         opj_event_msg(p_manager, EVT_ERROR, "The given tile index does not match.");
12444         return OPJ_FALSE;
12445     }
12446
12447     opj_event_msg(p_manager, EVT_INFO, "tile number %d / %d\n",
12448                   p_j2k->m_current_tile_number + 1, p_j2k->m_cp.tw * p_j2k->m_cp.th);
12449
12450     p_j2k->m_specific_param.m_encoder.m_current_tile_part_number = 0;
12451     p_j2k->m_tcd->cur_totnum_tp = p_j2k->m_cp.tcps[p_tile_index].m_nb_tile_parts;
12452     p_j2k->m_specific_param.m_encoder.m_current_poc_tile_part_number = 0;
12453
12454     /* initialisation before tile encoding  */
12455     if (! opj_tcd_init_encode_tile(p_j2k->m_tcd, p_j2k->m_current_tile_number,
12456                                    p_manager)) {
12457         return OPJ_FALSE;
12458     }
12459
12460     return OPJ_TRUE;
12461 }
12462
12463 static void opj_get_tile_dimensions(opj_image_t * l_image,
12464                                     opj_tcd_tilecomp_t * l_tilec,
12465                                     opj_image_comp_t * l_img_comp,
12466                                     OPJ_UINT32* l_size_comp,
12467                                     OPJ_UINT32* l_width,
12468                                     OPJ_UINT32* l_height,
12469                                     OPJ_UINT32* l_offset_x,
12470                                     OPJ_UINT32* l_offset_y,
12471                                     OPJ_UINT32* l_image_width,
12472                                     OPJ_UINT32* l_stride,
12473                                     OPJ_UINT32* l_tile_offset)
12474 {
12475     OPJ_UINT32 l_remaining;
12476     *l_size_comp = l_img_comp->prec >> 3; /* (/8) */
12477     l_remaining = l_img_comp->prec & 7;  /* (%8) */
12478     if (l_remaining) {
12479         *l_size_comp += 1;
12480     }
12481
12482     if (*l_size_comp == 3) {
12483         *l_size_comp = 4;
12484     }
12485
12486     *l_width  = (OPJ_UINT32)(l_tilec->x1 - l_tilec->x0);
12487     *l_height = (OPJ_UINT32)(l_tilec->y1 - l_tilec->y0);
12488     *l_offset_x = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)l_image->x0,
12489                   (OPJ_INT32)l_img_comp->dx);
12490     *l_offset_y = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)l_image->y0,
12491                   (OPJ_INT32)l_img_comp->dy);
12492     *l_image_width = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)l_image->x1 -
12493                      (OPJ_INT32)l_image->x0, (OPJ_INT32)l_img_comp->dx);
12494     *l_stride = *l_image_width - *l_width;
12495     *l_tile_offset = ((OPJ_UINT32)l_tilec->x0 - *l_offset_x) + ((
12496                          OPJ_UINT32)l_tilec->y0 - *l_offset_y) * *l_image_width;
12497 }
12498
12499 static void opj_j2k_get_tile_data(opj_tcd_t * p_tcd, OPJ_BYTE * p_data)
12500 {
12501     OPJ_UINT32 i, j, k = 0;
12502
12503     for (i = 0; i < p_tcd->image->numcomps; ++i) {
12504         opj_image_t * l_image =  p_tcd->image;
12505         OPJ_INT32 * l_src_ptr;
12506         opj_tcd_tilecomp_t * l_tilec = p_tcd->tcd_image->tiles->comps + i;
12507         opj_image_comp_t * l_img_comp = l_image->comps + i;
12508         OPJ_UINT32 l_size_comp, l_width, l_height, l_offset_x, l_offset_y,
12509                    l_image_width, l_stride, l_tile_offset;
12510
12511         opj_get_tile_dimensions(l_image,
12512                                 l_tilec,
12513                                 l_img_comp,
12514                                 &l_size_comp,
12515                                 &l_width,
12516                                 &l_height,
12517                                 &l_offset_x,
12518                                 &l_offset_y,
12519                                 &l_image_width,
12520                                 &l_stride,
12521                                 &l_tile_offset);
12522
12523         l_src_ptr = l_img_comp->data + l_tile_offset;
12524
12525         switch (l_size_comp) {
12526         case 1: {
12527             OPJ_CHAR * l_dest_ptr = (OPJ_CHAR*) p_data;
12528             if (l_img_comp->sgnd) {
12529                 for (j = 0; j < l_height; ++j) {
12530                     for (k = 0; k < l_width; ++k) {
12531                         *(l_dest_ptr) = (OPJ_CHAR)(*l_src_ptr);
12532                         ++l_dest_ptr;
12533                         ++l_src_ptr;
12534                     }
12535                     l_src_ptr += l_stride;
12536                 }
12537             } else {
12538                 for (j = 0; j < l_height; ++j) {
12539                     for (k = 0; k < l_width; ++k) {
12540                         *(l_dest_ptr) = (OPJ_CHAR)((*l_src_ptr) & 0xff);
12541                         ++l_dest_ptr;
12542                         ++l_src_ptr;
12543                     }
12544                     l_src_ptr += l_stride;
12545                 }
12546             }
12547
12548             p_data = (OPJ_BYTE*) l_dest_ptr;
12549         }
12550         break;
12551         case 2: {
12552             OPJ_INT16 * l_dest_ptr = (OPJ_INT16 *) p_data;
12553             if (l_img_comp->sgnd) {
12554                 for (j = 0; j < l_height; ++j) {
12555                     for (k = 0; k < l_width; ++k) {
12556                         *(l_dest_ptr++) = (OPJ_INT16)(*(l_src_ptr++));
12557                     }
12558                     l_src_ptr += l_stride;
12559                 }
12560             } else {
12561                 for (j = 0; j < l_height; ++j) {
12562                     for (k = 0; k < l_width; ++k) {
12563                         *(l_dest_ptr++) = (OPJ_INT16)((*(l_src_ptr++)) & 0xffff);
12564                     }
12565                     l_src_ptr += l_stride;
12566                 }
12567             }
12568
12569             p_data = (OPJ_BYTE*) l_dest_ptr;
12570         }
12571         break;
12572         case 4: {
12573             OPJ_INT32 * l_dest_ptr = (OPJ_INT32 *) p_data;
12574             for (j = 0; j < l_height; ++j) {
12575                 for (k = 0; k < l_width; ++k) {
12576                     *(l_dest_ptr++) = *(l_src_ptr++);
12577                 }
12578                 l_src_ptr += l_stride;
12579             }
12580
12581             p_data = (OPJ_BYTE*) l_dest_ptr;
12582         }
12583         break;
12584         }
12585     }
12586 }
12587
12588 static OPJ_BOOL opj_j2k_post_write_tile(opj_j2k_t * p_j2k,
12589                                         opj_stream_private_t *p_stream,
12590                                         opj_event_mgr_t * p_manager)
12591 {
12592     OPJ_UINT32 l_nb_bytes_written;
12593     OPJ_BYTE * l_current_data = 00;
12594     OPJ_UINT32 l_tile_size = 0;
12595     OPJ_UINT32 l_available_data;
12596
12597     /* preconditions */
12598     assert(p_j2k->m_specific_param.m_encoder.m_encoded_tile_data);
12599
12600     l_tile_size = p_j2k->m_specific_param.m_encoder.m_encoded_tile_size;
12601     l_available_data = l_tile_size;
12602     l_current_data = p_j2k->m_specific_param.m_encoder.m_encoded_tile_data;
12603
12604     l_nb_bytes_written = 0;
12605     if (! opj_j2k_write_first_tile_part(p_j2k, l_current_data, &l_nb_bytes_written,
12606                                         l_available_data, p_stream, p_manager)) {
12607         return OPJ_FALSE;
12608     }
12609     l_current_data += l_nb_bytes_written;
12610     l_available_data -= l_nb_bytes_written;
12611
12612     l_nb_bytes_written = 0;
12613     if (! opj_j2k_write_all_tile_parts(p_j2k, l_current_data, &l_nb_bytes_written,
12614                                        l_available_data, p_stream, p_manager)) {
12615         return OPJ_FALSE;
12616     }
12617
12618     l_available_data -= l_nb_bytes_written;
12619     l_nb_bytes_written = l_tile_size - l_available_data;
12620
12621     if (opj_stream_write_data(p_stream,
12622                               p_j2k->m_specific_param.m_encoder.m_encoded_tile_data,
12623                               l_nb_bytes_written, p_manager) != l_nb_bytes_written) {
12624         return OPJ_FALSE;
12625     }
12626
12627     ++p_j2k->m_current_tile_number;
12628
12629     return OPJ_TRUE;
12630 }
12631
12632 static OPJ_BOOL opj_j2k_setup_end_compress(opj_j2k_t *p_j2k,
12633         opj_event_mgr_t * p_manager)
12634 {
12635     /* preconditions */
12636     assert(p_j2k != 00);
12637     assert(p_manager != 00);
12638
12639     /* DEVELOPER CORNER, insert your custom procedures */
12640     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
12641                                            (opj_procedure)opj_j2k_write_eoc, p_manager)) {
12642         return OPJ_FALSE;
12643     }
12644
12645     if (p_j2k->m_specific_param.m_encoder.m_TLM) {
12646         if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
12647                                                (opj_procedure)opj_j2k_write_updated_tlm, p_manager)) {
12648             return OPJ_FALSE;
12649         }
12650     }
12651
12652     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
12653                                            (opj_procedure)opj_j2k_write_epc, p_manager)) {
12654         return OPJ_FALSE;
12655     }
12656     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
12657                                            (opj_procedure)opj_j2k_end_encoding, p_manager)) {
12658         return OPJ_FALSE;
12659     }
12660     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
12661                                            (opj_procedure)opj_j2k_destroy_header_memory, p_manager)) {
12662         return OPJ_FALSE;
12663     }
12664     return OPJ_TRUE;
12665 }
12666
12667 static OPJ_BOOL opj_j2k_setup_encoding_validation(opj_j2k_t *p_j2k,
12668         opj_event_mgr_t * p_manager)
12669 {
12670     /* preconditions */
12671     assert(p_j2k != 00);
12672     assert(p_manager != 00);
12673
12674     if (! opj_procedure_list_add_procedure(p_j2k->m_validation_list,
12675                                            (opj_procedure)opj_j2k_build_encoder, p_manager)) {
12676         return OPJ_FALSE;
12677     }
12678     if (! opj_procedure_list_add_procedure(p_j2k->m_validation_list,
12679                                            (opj_procedure)opj_j2k_encoding_validation, p_manager)) {
12680         return OPJ_FALSE;
12681     }
12682
12683     /* DEVELOPER CORNER, add your custom validation procedure */
12684     if (! opj_procedure_list_add_procedure(p_j2k->m_validation_list,
12685                                            (opj_procedure)opj_j2k_mct_validation, p_manager)) {
12686         return OPJ_FALSE;
12687     }
12688
12689     return OPJ_TRUE;
12690 }
12691
12692 static OPJ_BOOL opj_j2k_setup_header_writing(opj_j2k_t *p_j2k,
12693         opj_event_mgr_t * p_manager)
12694 {
12695     /* preconditions */
12696     assert(p_j2k != 00);
12697     assert(p_manager != 00);
12698
12699     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
12700                                            (opj_procedure)opj_j2k_init_info, p_manager)) {
12701         return OPJ_FALSE;
12702     }
12703     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
12704                                            (opj_procedure)opj_j2k_write_soc, p_manager)) {
12705         return OPJ_FALSE;
12706     }
12707     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
12708                                            (opj_procedure)opj_j2k_write_siz, p_manager)) {
12709         return OPJ_FALSE;
12710     }
12711     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
12712                                            (opj_procedure)opj_j2k_write_cod, p_manager)) {
12713         return OPJ_FALSE;
12714     }
12715     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
12716                                            (opj_procedure)opj_j2k_write_qcd, p_manager)) {
12717         return OPJ_FALSE;
12718     }
12719     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
12720                                            (opj_procedure)opj_j2k_write_all_coc, p_manager)) {
12721         return OPJ_FALSE;
12722     }
12723     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
12724                                            (opj_procedure)opj_j2k_write_all_qcc, p_manager)) {
12725         return OPJ_FALSE;
12726     }
12727
12728     if (p_j2k->m_specific_param.m_encoder.m_TLM) {
12729         if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
12730                                                (opj_procedure)opj_j2k_write_tlm, p_manager)) {
12731             return OPJ_FALSE;
12732         }
12733
12734         if (p_j2k->m_cp.rsiz == OPJ_PROFILE_CINEMA_4K) {
12735             if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
12736                                                    (opj_procedure)opj_j2k_write_poc, p_manager)) {
12737                 return OPJ_FALSE;
12738             }
12739         }
12740     }
12741
12742     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
12743                                            (opj_procedure)opj_j2k_write_regions, p_manager)) {
12744         return OPJ_FALSE;
12745     }
12746
12747     if (p_j2k->m_cp.comment != 00)  {
12748         if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
12749                                                (opj_procedure)opj_j2k_write_com, p_manager)) {
12750             return OPJ_FALSE;
12751         }
12752     }
12753
12754     /* DEVELOPER CORNER, insert your custom procedures */
12755     if ((p_j2k->m_cp.rsiz & (OPJ_PROFILE_PART2 | OPJ_EXTENSION_MCT)) ==
12756             (OPJ_PROFILE_PART2 | OPJ_EXTENSION_MCT)) {
12757         if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
12758                                                (opj_procedure)opj_j2k_write_mct_data_group, p_manager)) {
12759             return OPJ_FALSE;
12760         }
12761     }
12762     /* End of Developer Corner */
12763
12764     if (p_j2k->cstr_index) {
12765         if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
12766                                                (opj_procedure)opj_j2k_get_end_header, p_manager)) {
12767             return OPJ_FALSE;
12768         }
12769     }
12770
12771     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
12772                                            (opj_procedure)opj_j2k_create_tcd, p_manager)) {
12773         return OPJ_FALSE;
12774     }
12775     if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
12776                                            (opj_procedure)opj_j2k_update_rates, p_manager)) {
12777         return OPJ_FALSE;
12778     }
12779
12780     return OPJ_TRUE;
12781 }
12782
12783 static OPJ_BOOL opj_j2k_write_first_tile_part(opj_j2k_t *p_j2k,
12784         OPJ_BYTE * p_data,
12785         OPJ_UINT32 * p_data_written,
12786         OPJ_UINT32 total_data_size,
12787         opj_stream_private_t *p_stream,
12788         struct opj_event_mgr * p_manager)
12789 {
12790     OPJ_UINT32 l_nb_bytes_written = 0;
12791     OPJ_UINT32 l_current_nb_bytes_written;
12792     OPJ_BYTE * l_begin_data = 00;
12793
12794     opj_tcd_t * l_tcd = 00;
12795     opj_cp_t * l_cp = 00;
12796
12797     l_tcd = p_j2k->m_tcd;
12798     l_cp = &(p_j2k->m_cp);
12799
12800     l_tcd->cur_pino = 0;
12801
12802     /*Get number of tile parts*/
12803     p_j2k->m_specific_param.m_encoder.m_current_poc_tile_part_number = 0;
12804
12805     /* INDEX >> */
12806     /* << INDEX */
12807
12808     l_current_nb_bytes_written = 0;
12809     l_begin_data = p_data;
12810     if (! opj_j2k_write_sot(p_j2k, p_data, total_data_size,
12811                             &l_current_nb_bytes_written, p_stream,
12812                             p_manager)) {
12813         return OPJ_FALSE;
12814     }
12815
12816     l_nb_bytes_written += l_current_nb_bytes_written;
12817     p_data += l_current_nb_bytes_written;
12818     total_data_size -= l_current_nb_bytes_written;
12819
12820     if (!OPJ_IS_CINEMA(l_cp->rsiz)) {
12821 #if 0
12822         for (compno = 1; compno < p_j2k->m_private_image->numcomps; compno++) {
12823             l_current_nb_bytes_written = 0;
12824             opj_j2k_write_coc_in_memory(p_j2k, compno, p_data, &l_current_nb_bytes_written,
12825                                         p_manager);
12826             l_nb_bytes_written += l_current_nb_bytes_written;
12827             p_data += l_current_nb_bytes_written;
12828             total_data_size -= l_current_nb_bytes_written;
12829
12830             l_current_nb_bytes_written = 0;
12831             opj_j2k_write_qcc_in_memory(p_j2k, compno, p_data, &l_current_nb_bytes_written,
12832                                         p_manager);
12833             l_nb_bytes_written += l_current_nb_bytes_written;
12834             p_data += l_current_nb_bytes_written;
12835             total_data_size -= l_current_nb_bytes_written;
12836         }
12837 #endif
12838         if (l_cp->tcps[p_j2k->m_current_tile_number].POC) {
12839             l_current_nb_bytes_written = 0;
12840             opj_j2k_write_poc_in_memory(p_j2k, p_data, &l_current_nb_bytes_written,
12841                                         p_manager);
12842             l_nb_bytes_written += l_current_nb_bytes_written;
12843             p_data += l_current_nb_bytes_written;
12844             total_data_size -= l_current_nb_bytes_written;
12845         }
12846     }
12847
12848     l_current_nb_bytes_written = 0;
12849     if (! opj_j2k_write_sod(p_j2k, l_tcd, p_data, &l_current_nb_bytes_written,
12850                             total_data_size, p_stream, p_manager)) {
12851         return OPJ_FALSE;
12852     }
12853
12854     l_nb_bytes_written += l_current_nb_bytes_written;
12855     * p_data_written = l_nb_bytes_written;
12856
12857     /* Writing Psot in SOT marker */
12858     opj_write_bytes(l_begin_data + 6, l_nb_bytes_written,
12859                     4);                                 /* PSOT */
12860
12861     if (p_j2k->m_specific_param.m_encoder.m_TLM) {
12862         opj_j2k_update_tlm(p_j2k, l_nb_bytes_written);
12863     }
12864
12865     return OPJ_TRUE;
12866 }
12867
12868 static OPJ_BOOL opj_j2k_write_all_tile_parts(opj_j2k_t *p_j2k,
12869         OPJ_BYTE * p_data,
12870         OPJ_UINT32 * p_data_written,
12871         OPJ_UINT32 total_data_size,
12872         opj_stream_private_t *p_stream,
12873         struct opj_event_mgr * p_manager
12874                                             )
12875 {
12876     OPJ_UINT32 tilepartno = 0;
12877     OPJ_UINT32 l_nb_bytes_written = 0;
12878     OPJ_UINT32 l_current_nb_bytes_written;
12879     OPJ_UINT32 l_part_tile_size;
12880     OPJ_UINT32 tot_num_tp;
12881     OPJ_UINT32 pino;
12882
12883     OPJ_BYTE * l_begin_data;
12884     opj_tcp_t *l_tcp = 00;
12885     opj_tcd_t * l_tcd = 00;
12886     opj_cp_t * l_cp = 00;
12887
12888     l_tcd = p_j2k->m_tcd;
12889     l_cp = &(p_j2k->m_cp);
12890     l_tcp = l_cp->tcps + p_j2k->m_current_tile_number;
12891
12892     /*Get number of tile parts*/
12893     tot_num_tp = opj_j2k_get_num_tp(l_cp, 0, p_j2k->m_current_tile_number);
12894
12895     /* start writing remaining tile parts */
12896     ++p_j2k->m_specific_param.m_encoder.m_current_tile_part_number;
12897     for (tilepartno = 1; tilepartno < tot_num_tp ; ++tilepartno) {
12898         p_j2k->m_specific_param.m_encoder.m_current_poc_tile_part_number = tilepartno;
12899         l_current_nb_bytes_written = 0;
12900         l_part_tile_size = 0;
12901         l_begin_data = p_data;
12902
12903         if (! opj_j2k_write_sot(p_j2k, p_data,
12904                                 total_data_size,
12905                                 &l_current_nb_bytes_written,
12906                                 p_stream,
12907                                 p_manager)) {
12908             return OPJ_FALSE;
12909         }
12910
12911         l_nb_bytes_written += l_current_nb_bytes_written;
12912         p_data += l_current_nb_bytes_written;
12913         total_data_size -= l_current_nb_bytes_written;
12914         l_part_tile_size += l_current_nb_bytes_written;
12915
12916         l_current_nb_bytes_written = 0;
12917         if (! opj_j2k_write_sod(p_j2k, l_tcd, p_data, &l_current_nb_bytes_written,
12918                                 total_data_size, p_stream, p_manager)) {
12919             return OPJ_FALSE;
12920         }
12921
12922         p_data += l_current_nb_bytes_written;
12923         l_nb_bytes_written += l_current_nb_bytes_written;
12924         total_data_size -= l_current_nb_bytes_written;
12925         l_part_tile_size += l_current_nb_bytes_written;
12926
12927         /* Writing Psot in SOT marker */
12928         opj_write_bytes(l_begin_data + 6, l_part_tile_size,
12929                         4);                                   /* PSOT */
12930
12931         if (p_j2k->m_specific_param.m_encoder.m_TLM) {
12932             opj_j2k_update_tlm(p_j2k, l_part_tile_size);
12933         }
12934
12935         ++p_j2k->m_specific_param.m_encoder.m_current_tile_part_number;
12936     }
12937
12938     for (pino = 1; pino <= l_tcp->numpocs; ++pino) {
12939         l_tcd->cur_pino = pino;
12940
12941         /*Get number of tile parts*/
12942         tot_num_tp = opj_j2k_get_num_tp(l_cp, pino, p_j2k->m_current_tile_number);
12943         for (tilepartno = 0; tilepartno < tot_num_tp ; ++tilepartno) {
12944             p_j2k->m_specific_param.m_encoder.m_current_poc_tile_part_number = tilepartno;
12945             l_current_nb_bytes_written = 0;
12946             l_part_tile_size = 0;
12947             l_begin_data = p_data;
12948
12949             if (! opj_j2k_write_sot(p_j2k, p_data,
12950                                     total_data_size,
12951                                     &l_current_nb_bytes_written, p_stream,
12952                                     p_manager)) {
12953                 return OPJ_FALSE;
12954             }
12955
12956             l_nb_bytes_written += l_current_nb_bytes_written;
12957             p_data += l_current_nb_bytes_written;
12958             total_data_size -= l_current_nb_bytes_written;
12959             l_part_tile_size += l_current_nb_bytes_written;
12960
12961             l_current_nb_bytes_written = 0;
12962
12963             if (! opj_j2k_write_sod(p_j2k, l_tcd, p_data, &l_current_nb_bytes_written,
12964                                     total_data_size, p_stream, p_manager)) {
12965                 return OPJ_FALSE;
12966             }
12967
12968             l_nb_bytes_written += l_current_nb_bytes_written;
12969             p_data += l_current_nb_bytes_written;
12970             total_data_size -= l_current_nb_bytes_written;
12971             l_part_tile_size += l_current_nb_bytes_written;
12972
12973             /* Writing Psot in SOT marker */
12974             opj_write_bytes(l_begin_data + 6, l_part_tile_size,
12975                             4);                                   /* PSOT */
12976
12977             if (p_j2k->m_specific_param.m_encoder.m_TLM) {
12978                 opj_j2k_update_tlm(p_j2k, l_part_tile_size);
12979             }
12980
12981             ++p_j2k->m_specific_param.m_encoder.m_current_tile_part_number;
12982         }
12983     }
12984
12985     *p_data_written = l_nb_bytes_written;
12986
12987     return OPJ_TRUE;
12988 }
12989
12990 static OPJ_BOOL opj_j2k_write_updated_tlm(opj_j2k_t *p_j2k,
12991         struct opj_stream_private *p_stream,
12992         struct opj_event_mgr * p_manager)
12993 {
12994     OPJ_UINT32 l_tlm_size;
12995     OPJ_OFF_T l_tlm_position, l_current_position;
12996     OPJ_UINT32 size_per_tile_part;
12997
12998     /* preconditions */
12999     assert(p_j2k != 00);
13000     assert(p_manager != 00);
13001     assert(p_stream != 00);
13002
13003     size_per_tile_part = p_j2k->m_specific_param.m_encoder.m_Ttlmi_is_byte ? 5 : 6;
13004     l_tlm_size = size_per_tile_part *
13005                  p_j2k->m_specific_param.m_encoder.m_total_tile_parts;
13006     l_tlm_position = 6 + p_j2k->m_specific_param.m_encoder.m_tlm_start;
13007     l_current_position = opj_stream_tell(p_stream);
13008
13009     if (! opj_stream_seek(p_stream, l_tlm_position, p_manager)) {
13010         return OPJ_FALSE;
13011     }
13012
13013     if (opj_stream_write_data(p_stream,
13014                               p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer, l_tlm_size,
13015                               p_manager) != l_tlm_size) {
13016         return OPJ_FALSE;
13017     }
13018
13019     if (! opj_stream_seek(p_stream, l_current_position, p_manager)) {
13020         return OPJ_FALSE;
13021     }
13022
13023     return OPJ_TRUE;
13024 }
13025
13026 static OPJ_BOOL opj_j2k_end_encoding(opj_j2k_t *p_j2k,
13027                                      struct opj_stream_private *p_stream,
13028                                      struct opj_event_mgr * p_manager)
13029 {
13030     /* preconditions */
13031     assert(p_j2k != 00);
13032     assert(p_manager != 00);
13033     assert(p_stream != 00);
13034
13035     OPJ_UNUSED(p_stream);
13036     OPJ_UNUSED(p_manager);
13037
13038     opj_tcd_destroy(p_j2k->m_tcd);
13039     p_j2k->m_tcd = 00;
13040
13041     if (p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer) {
13042         opj_free(p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer);
13043         p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer = 0;
13044         p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current = 0;
13045     }
13046
13047     if (p_j2k->m_specific_param.m_encoder.m_encoded_tile_data) {
13048         opj_free(p_j2k->m_specific_param.m_encoder.m_encoded_tile_data);
13049         p_j2k->m_specific_param.m_encoder.m_encoded_tile_data = 0;
13050     }
13051
13052     p_j2k->m_specific_param.m_encoder.m_encoded_tile_size = 0;
13053
13054     return OPJ_TRUE;
13055 }
13056
13057 /**
13058  * Destroys the memory associated with the decoding of headers.
13059  */
13060 static OPJ_BOOL opj_j2k_destroy_header_memory(opj_j2k_t * p_j2k,
13061         opj_stream_private_t *p_stream,
13062         opj_event_mgr_t * p_manager
13063                                              )
13064 {
13065     /* preconditions */
13066     assert(p_j2k != 00);
13067     assert(p_stream != 00);
13068     assert(p_manager != 00);
13069
13070     OPJ_UNUSED(p_stream);
13071     OPJ_UNUSED(p_manager);
13072
13073     if (p_j2k->m_specific_param.m_encoder.m_header_tile_data) {
13074         opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
13075         p_j2k->m_specific_param.m_encoder.m_header_tile_data = 0;
13076     }
13077
13078     p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
13079
13080     return OPJ_TRUE;
13081 }
13082
13083 static OPJ_BOOL opj_j2k_init_info(opj_j2k_t *p_j2k,
13084                                   struct opj_stream_private *p_stream,
13085                                   struct opj_event_mgr * p_manager)
13086 {
13087     opj_codestream_info_t * l_cstr_info = 00;
13088
13089     /* preconditions */
13090     assert(p_j2k != 00);
13091     assert(p_manager != 00);
13092     assert(p_stream != 00);
13093     (void)l_cstr_info;
13094
13095     OPJ_UNUSED(p_stream);
13096
13097     /* TODO mergeV2: check this part which use cstr_info */
13098     /*l_cstr_info = p_j2k->cstr_info;
13099
13100     if (l_cstr_info)  {
13101             OPJ_UINT32 compno;
13102             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));
13103
13104             l_cstr_info->image_w = p_j2k->m_image->x1 - p_j2k->m_image->x0;
13105             l_cstr_info->image_h = p_j2k->m_image->y1 - p_j2k->m_image->y0;
13106
13107             l_cstr_info->prog = (&p_j2k->m_cp.tcps[0])->prg;
13108
13109             l_cstr_info->tw = p_j2k->m_cp.tw;
13110             l_cstr_info->th = p_j2k->m_cp.th;
13111
13112             l_cstr_info->tile_x = p_j2k->m_cp.tdx;*/        /* new version parser */
13113     /*l_cstr_info->tile_y = p_j2k->m_cp.tdy;*/      /* new version parser */
13114     /*l_cstr_info->tile_Ox = p_j2k->m_cp.tx0;*/     /* new version parser */
13115     /*l_cstr_info->tile_Oy = p_j2k->m_cp.ty0;*/     /* new version parser */
13116
13117     /*l_cstr_info->numcomps = p_j2k->m_image->numcomps;
13118
13119     l_cstr_info->numlayers = (&p_j2k->m_cp.tcps[0])->numlayers;
13120
13121     l_cstr_info->numdecompos = (OPJ_INT32*) opj_malloc(p_j2k->m_image->numcomps * sizeof(OPJ_INT32));
13122
13123     for (compno=0; compno < p_j2k->m_image->numcomps; compno++) {
13124             l_cstr_info->numdecompos[compno] = (&p_j2k->m_cp.tcps[0])->tccps->numresolutions - 1;
13125     }
13126
13127     l_cstr_info->D_max = 0.0;       */      /* ADD Marcela */
13128
13129     /*l_cstr_info->main_head_start = opj_stream_tell(p_stream);*/ /* position of SOC */
13130
13131     /*l_cstr_info->maxmarknum = 100;
13132     l_cstr_info->marker = (opj_marker_info_t *) opj_malloc(l_cstr_info->maxmarknum * sizeof(opj_marker_info_t));
13133     l_cstr_info->marknum = 0;
13134     }*/
13135
13136     return opj_j2k_calculate_tp(p_j2k, &(p_j2k->m_cp),
13137                                 &p_j2k->m_specific_param.m_encoder.m_total_tile_parts, p_j2k->m_private_image,
13138                                 p_manager);
13139 }
13140
13141 /**
13142  * Creates a tile-coder encoder.
13143  *
13144  * @param       p_stream                the stream to write data to.
13145  * @param       p_j2k                   J2K codec.
13146  * @param       p_manager               the user event manager.
13147 */
13148 static OPJ_BOOL opj_j2k_create_tcd(opj_j2k_t *p_j2k,
13149                                    opj_stream_private_t *p_stream,
13150                                    opj_event_mgr_t * p_manager
13151                                   )
13152 {
13153     /* preconditions */
13154     assert(p_j2k != 00);
13155     assert(p_manager != 00);
13156     assert(p_stream != 00);
13157
13158     OPJ_UNUSED(p_stream);
13159
13160     p_j2k->m_tcd = opj_tcd_create(OPJ_FALSE);
13161
13162     if (! p_j2k->m_tcd) {
13163         opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to create Tile Coder\n");
13164         return OPJ_FALSE;
13165     }
13166
13167     if (!opj_tcd_init(p_j2k->m_tcd, p_j2k->m_private_image, &p_j2k->m_cp,
13168                       p_j2k->m_tp)) {
13169         opj_tcd_destroy(p_j2k->m_tcd);
13170         p_j2k->m_tcd = 00;
13171         return OPJ_FALSE;
13172     }
13173
13174     return OPJ_TRUE;
13175 }
13176
13177 OPJ_BOOL opj_j2k_write_tile(opj_j2k_t * p_j2k,
13178                             OPJ_UINT32 p_tile_index,
13179                             OPJ_BYTE * p_data,
13180                             OPJ_UINT32 p_data_size,
13181                             opj_stream_private_t *p_stream,
13182                             opj_event_mgr_t * p_manager)
13183 {
13184     if (! opj_j2k_pre_write_tile(p_j2k, p_tile_index, p_stream, p_manager)) {
13185         opj_event_msg(p_manager, EVT_ERROR,
13186                       "Error while opj_j2k_pre_write_tile with tile index = %d\n", p_tile_index);
13187         return OPJ_FALSE;
13188     } else {
13189         OPJ_UINT32 j;
13190         /* Allocate data */
13191         for (j = 0; j < p_j2k->m_tcd->image->numcomps; ++j) {
13192             opj_tcd_tilecomp_t* l_tilec = p_j2k->m_tcd->tcd_image->tiles->comps + j;
13193
13194             if (! opj_alloc_tile_component_data(l_tilec)) {
13195                 opj_event_msg(p_manager, EVT_ERROR, "Error allocating tile component data.");
13196                 return OPJ_FALSE;
13197             }
13198         }
13199
13200         /* now copy data into the tile component */
13201         if (! opj_tcd_copy_tile_data(p_j2k->m_tcd, p_data, p_data_size)) {
13202             opj_event_msg(p_manager, EVT_ERROR,
13203                           "Size mismatch between tile data and sent data.");
13204             return OPJ_FALSE;
13205         }
13206         if (! opj_j2k_post_write_tile(p_j2k, p_stream, p_manager)) {
13207             opj_event_msg(p_manager, EVT_ERROR,
13208                           "Error while opj_j2k_post_write_tile with tile index = %d\n", p_tile_index);
13209             return OPJ_FALSE;
13210         }
13211     }
13212
13213     return OPJ_TRUE;
13214 }