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