src/lib/openjp2/j2k.c

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