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