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