src/lib/openjp2/j2k.c

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