libopenjpeg/j2k.c

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