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