src/lib/openjp2/j2k.c

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