src/lib/openjp2/j2k.c

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