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