src/lib/openjp2/j2k.c

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