src/lib/openjp2/j2k.c

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