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