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