1 /* 2 * The copyright in this software is being made available under the 2-clauses 3 * BSD License, included below. This software may be subject to other third 4 * party and contributor rights, including patent rights, and no such rights 5 * are granted under this license. 6 * 7 * Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium 8 * Copyright (c) 2002-2014, Professor Benoit Macq 9 * Copyright (c) 2001-2003, David Janssens 10 * Copyright (c) 2002-2003, Yannick Verschueren 11 * Copyright (c) 2003-2007, Francois-Olivier Devaux 12 * Copyright (c) 2003-2014, Antonin Descampe 13 * Copyright (c) 2005, Herve Drolon, FreeImage Team 14 * Copyright (c) 2006-2007, Parvatha Elangovan 15 * Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr> 16 * Copyright (c) 2011-2012, Centre National d'Etudes Spatiales (CNES), France 17 * Copyright (c) 2012, CS Systemes d'Information, France 18 * 19 * All rights reserved. 20 * 21 * Redistribution and use in source and binary forms, with or without 22 * modification, are permitted provided that the following conditions 23 * are met: 24 * 1. Redistributions of source code must retain the above copyright 25 * notice, this list of conditions and the following disclaimer. 26 * 2. Redistributions in binary form must reproduce the above copyright 27 * notice, this list of conditions and the following disclaimer in the 28 * documentation and/or other materials provided with the distribution. 29 * 30 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS' 31 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 32 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 33 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 34 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 35 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 36 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 37 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 38 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 39 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 40 * POSSIBILITY OF SUCH DAMAGE. 41 */ 42 #ifndef OPJ_J2K_H 43 #define OPJ_J2K_H 44 /** 45 @file j2k.h 46 @brief The JPEG-2000 Codestream Reader/Writer (J2K) 47 48 The functions in J2K.C have for goal to read/write the several parts of the codestream: markers and data. 49 */ 50 51 /** @defgroup J2K J2K - JPEG-2000 codestream reader/writer */ 52 /*@{*/ 53 54 #define J2K_CP_CSTY_PRT 0x01 55 #define J2K_CP_CSTY_SOP 0x02 56 #define J2K_CP_CSTY_EPH 0x04 57 #define J2K_CCP_CSTY_PRT 0x01 58 #define J2K_CCP_CBLKSTY_LAZY 0x01 /**< Selective arithmetic coding bypass */ 59 #define J2K_CCP_CBLKSTY_RESET 0x02 /**< Reset context probabilities on coding pass boundaries */ 60 #define J2K_CCP_CBLKSTY_TERMALL 0x04 /**< Termination on each coding pass */ 61 #define J2K_CCP_CBLKSTY_VSC 0x08 /**< Vertically stripe causal context */ 62 #define J2K_CCP_CBLKSTY_PTERM 0x10 /**< Predictable termination */ 63 #define J2K_CCP_CBLKSTY_SEGSYM 0x20 /**< Segmentation symbols are used */ 64 #define J2K_CCP_CBLKSTY_HT 0x40 /**< (high throughput) HT codeblocks */ 65 #define J2K_CCP_CBLKSTY_HTMIXED 0x80 /**< MIXED mode HT codeblocks */ 66 #define J2K_CCP_QNTSTY_NOQNT 0 67 #define J2K_CCP_QNTSTY_SIQNT 1 68 #define J2K_CCP_QNTSTY_SEQNT 2 69 70 /* ----------------------------------------------------------------------- */ 71 72 #define J2K_MS_SOC 0xff4f /**< SOC marker value */ 73 #define J2K_MS_SOT 0xff90 /**< SOT marker value */ 74 #define J2K_MS_SOD 0xff93 /**< SOD marker value */ 75 #define J2K_MS_EOC 0xffd9 /**< EOC marker value */ 76 #define J2K_MS_CAP 0xff50 /**< CAP marker value */ 77 #define J2K_MS_SIZ 0xff51 /**< SIZ marker value */ 78 #define J2K_MS_COD 0xff52 /**< COD marker value */ 79 #define J2K_MS_COC 0xff53 /**< COC marker value */ 80 #define J2K_MS_CPF 0xff59 /**< CPF marker value */ 81 #define J2K_MS_RGN 0xff5e /**< RGN marker value */ 82 #define J2K_MS_QCD 0xff5c /**< QCD marker value */ 83 #define J2K_MS_QCC 0xff5d /**< QCC marker value */ 84 #define J2K_MS_POC 0xff5f /**< POC marker value */ 85 #define J2K_MS_TLM 0xff55 /**< TLM marker value */ 86 #define J2K_MS_PLM 0xff57 /**< PLM marker value */ 87 #define J2K_MS_PLT 0xff58 /**< PLT marker value */ 88 #define J2K_MS_PPM 0xff60 /**< PPM marker value */ 89 #define J2K_MS_PPT 0xff61 /**< PPT marker value */ 90 #define J2K_MS_SOP 0xff91 /**< SOP marker value */ 91 #define J2K_MS_EPH 0xff92 /**< EPH marker value */ 92 #define J2K_MS_CRG 0xff63 /**< CRG marker value */ 93 #define J2K_MS_COM 0xff64 /**< COM marker value */ 94 #define J2K_MS_CBD 0xff78 /**< CBD marker value */ 95 #define J2K_MS_MCC 0xff75 /**< MCC marker value */ 96 #define J2K_MS_MCT 0xff74 /**< MCT marker value */ 97 #define J2K_MS_MCO 0xff77 /**< MCO marker value */ 98 99 #define J2K_MS_UNK 0 /**< UNKNOWN marker value */ 100 101 /* UniPG>> */ 102 #ifdef USE_JPWL 103 #define J2K_MS_EPC 0xff68 /**< EPC marker value (Part 11: JPEG 2000 for Wireless) */ 104 #define J2K_MS_EPB 0xff66 /**< EPB marker value (Part 11: JPEG 2000 for Wireless) */ 105 #define J2K_MS_ESD 0xff67 /**< ESD marker value (Part 11: JPEG 2000 for Wireless) */ 106 #define J2K_MS_RED 0xff69 /**< RED marker value (Part 11: JPEG 2000 for Wireless) */ 107 #endif /* USE_JPWL */ 108 #ifdef USE_JPSEC 109 #define J2K_MS_SEC 0xff65 /**< SEC marker value (Part 8: Secure JPEG 2000) */ 110 #define J2K_MS_INSEC 0xff94 /**< INSEC marker value (Part 8: Secure JPEG 2000) */ 111 #endif /* USE_JPSEC */ 112 /* <<UniPG */ 113 114 #define J2K_MAX_POCS 32 /**< Maximum number of POCs */ 115 116 /* ----------------------------------------------------------------------- */ 117 118 /** 119 * Values that specify the status of the decoding process when decoding the main header. 120 * These values may be combined with a | operator. 121 * */ 122 typedef enum J2K_STATUS { 123 J2K_STATE_NONE = 0x0000, /**< a SOC marker is expected */ 124 J2K_STATE_MHSOC = 0x0001, /**< a SOC marker is expected */ 125 J2K_STATE_MHSIZ = 0x0002, /**< a SIZ marker is expected */ 126 J2K_STATE_MH = 0x0004, /**< the decoding process is in the main header */ 127 J2K_STATE_TPHSOT = 0x0008, /**< the decoding process is in a tile part header and expects a SOT marker */ 128 J2K_STATE_TPH = 0x0010, /**< the decoding process is in a tile part header */ 129 J2K_STATE_MT = 0x0020, /**< the EOC marker has just been read */ 130 J2K_STATE_NEOC = 0x0040, /**< the decoding process must not expect a EOC marker because the codestream is truncated */ 131 J2K_STATE_DATA = 0x0080, /**< a tile header has been successfully read and codestream is expected */ 132 133 J2K_STATE_EOC = 0x0100, /**< the decoding process has encountered the EOC marker */ 134 J2K_STATE_ERR = 0x8000 /**< the decoding process has encountered an error (FIXME warning V1 = 0x0080)*/ 135 } J2K_STATUS; 136 137 /** 138 * Type of elements storing in the MCT data 139 */ 140 typedef enum MCT_ELEMENT_TYPE { 141 MCT_TYPE_INT16 = 0, /** MCT data is stored as signed shorts*/ 142 MCT_TYPE_INT32 = 1, /** MCT data is stored as signed integers*/ 143 MCT_TYPE_FLOAT = 2, /** MCT data is stored as floats*/ 144 MCT_TYPE_DOUBLE = 3 /** MCT data is stored as doubles*/ 145 } J2K_MCT_ELEMENT_TYPE; 146 147 /** 148 * Type of MCT array 149 */ 150 typedef enum MCT_ARRAY_TYPE { 151 MCT_TYPE_DEPENDENCY = 0, 152 MCT_TYPE_DECORRELATION = 1, 153 MCT_TYPE_OFFSET = 2 154 } J2K_MCT_ARRAY_TYPE; 155 156 /* ----------------------------------------------------------------------- */ 157 158 /** 159 T2 encoding mode 160 */ 161 typedef enum T2_MODE { 162 THRESH_CALC = 0, /** Function called in Rate allocation process*/ 163 FINAL_PASS = 1 /** Function called in Tier 2 process*/ 164 } J2K_T2_MODE; 165 166 /** 167 * Quantization stepsize 168 */ 169 typedef struct opj_stepsize { 170 /** exponent */ 171 OPJ_INT32 expn; 172 /** mantissa */ 173 OPJ_INT32 mant; 174 } opj_stepsize_t; 175 176 /** 177 Tile-component coding parameters 178 */ 179 typedef struct opj_tccp { 180 /** coding style */ 181 OPJ_UINT32 csty; 182 /** number of resolutions */ 183 OPJ_UINT32 numresolutions; 184 /** code-blocks width */ 185 OPJ_UINT32 cblkw; 186 /** code-blocks height */ 187 OPJ_UINT32 cblkh; 188 /** code-block coding style */ 189 OPJ_UINT32 cblksty; 190 /** discrete wavelet transform identifier */ 191 OPJ_UINT32 qmfbid; 192 /** quantisation style */ 193 OPJ_UINT32 qntsty; 194 /** stepsizes used for quantization */ 195 opj_stepsize_t stepsizes[OPJ_J2K_MAXBANDS]; 196 /** number of guard bits */ 197 OPJ_UINT32 numgbits; 198 /** Region Of Interest shift */ 199 OPJ_INT32 roishift; 200 /** precinct width */ 201 OPJ_UINT32 prcw[OPJ_J2K_MAXRLVLS]; 202 /** precinct height */ 203 OPJ_UINT32 prch[OPJ_J2K_MAXRLVLS]; 204 /** the dc_level_shift **/ 205 OPJ_INT32 m_dc_level_shift; 206 } 207 opj_tccp_t; 208 209 210 211 /** 212 * FIXME DOC 213 */ 214 typedef struct opj_mct_data { 215 J2K_MCT_ELEMENT_TYPE m_element_type; 216 J2K_MCT_ARRAY_TYPE m_array_type; 217 OPJ_UINT32 m_index; 218 OPJ_BYTE * m_data; 219 OPJ_UINT32 m_data_size; 220 } 221 opj_mct_data_t; 222 223 /** 224 * FIXME DOC 225 */ 226 typedef struct opj_simple_mcc_decorrelation_data { 227 OPJ_UINT32 m_index; 228 OPJ_UINT32 m_nb_comps; 229 opj_mct_data_t * m_decorrelation_array; 230 opj_mct_data_t * m_offset_array; 231 OPJ_BITFIELD m_is_irreversible : 1; 232 } 233 opj_simple_mcc_decorrelation_data_t; 234 235 typedef struct opj_ppx_struct { 236 OPJ_BYTE* m_data; /* m_data == NULL => Zppx not read yet */ 237 OPJ_UINT32 m_data_size; 238 } opj_ppx; 239 240 /** 241 Tile coding parameters : 242 this structure is used to store coding/decoding parameters common to all 243 tiles (information like COD, COC in main header) 244 */ 245 typedef struct opj_tcp { 246 /** coding style */ 247 OPJ_UINT32 csty; 248 /** progression order */ 249 OPJ_PROG_ORDER prg; 250 /** number of layers */ 251 OPJ_UINT32 numlayers; 252 OPJ_UINT32 num_layers_to_decode; 253 /** multi-component transform identifier */ 254 OPJ_UINT32 mct; 255 /** rates of layers */ 256 OPJ_FLOAT32 rates[100]; 257 /** number of progression order changes */ 258 OPJ_UINT32 numpocs; 259 /** progression order changes */ 260 opj_poc_t pocs[J2K_MAX_POCS]; 261 262 /** number of ppt markers (reserved size) */ 263 OPJ_UINT32 ppt_markers_count; 264 /** ppt markers data (table indexed by Zppt) */ 265 opj_ppx* ppt_markers; 266 267 /** packet header store there for future use in t2_decode_packet */ 268 OPJ_BYTE *ppt_data; 269 /** used to keep a track of the allocated memory */ 270 OPJ_BYTE *ppt_buffer; 271 /** Number of bytes stored inside ppt_data*/ 272 OPJ_UINT32 ppt_data_size; 273 /** size of ppt_data*/ 274 OPJ_UINT32 ppt_len; 275 /** add fixed_quality */ 276 OPJ_FLOAT32 distoratio[100]; 277 /** tile-component coding parameters */ 278 opj_tccp_t *tccps; 279 /** current tile part number or -1 if first time into this tile */ 280 OPJ_INT32 m_current_tile_part_number; 281 /** number of tile parts for the tile. */ 282 OPJ_UINT32 m_nb_tile_parts; 283 /** data for the tile */ 284 OPJ_BYTE * m_data; 285 /** size of data */ 286 OPJ_UINT32 m_data_size; 287 /** encoding norms */ 288 OPJ_FLOAT64 * mct_norms; 289 /** the mct decoding matrix */ 290 OPJ_FLOAT32 * m_mct_decoding_matrix; 291 /** the mct coding matrix */ 292 OPJ_FLOAT32 * m_mct_coding_matrix; 293 /** mct records */ 294 opj_mct_data_t * m_mct_records; 295 /** the number of mct records. */ 296 OPJ_UINT32 m_nb_mct_records; 297 /** the max number of mct records. */ 298 OPJ_UINT32 m_nb_max_mct_records; 299 /** mcc records */ 300 opj_simple_mcc_decorrelation_data_t * m_mcc_records; 301 /** the number of mct records. */ 302 OPJ_UINT32 m_nb_mcc_records; 303 /** the max number of mct records. */ 304 OPJ_UINT32 m_nb_max_mcc_records; 305 306 307 /***** FLAGS *******/ 308 /** If cod == 1 --> there was a COD marker for the present tile */ 309 OPJ_BITFIELD cod : 1; 310 /** If ppt == 1 --> there was a PPT marker for the present tile */ 311 OPJ_BITFIELD ppt : 1; 312 /** indicates if a POC marker has been used O:NO, 1:YES */ 313 OPJ_BITFIELD POC : 1; 314 } opj_tcp_t; 315 316 317 318 319 typedef struct opj_encoding_param { 320 /** Maximum rate for each component. If == 0, component size limitation is not considered */ 321 OPJ_UINT32 m_max_comp_size; 322 /** Position of tile part flag in progression order*/ 323 OPJ_INT32 m_tp_pos; 324 /** fixed layer */ 325 OPJ_INT32 *m_matrice; 326 /** Flag determining tile part generation*/ 327 OPJ_BYTE m_tp_flag; 328 /** allocation by rate/distortion */ 329 OPJ_BITFIELD m_disto_alloc : 1; 330 /** allocation by fixed layer */ 331 OPJ_BITFIELD m_fixed_alloc : 1; 332 /** add fixed_quality */ 333 OPJ_BITFIELD m_fixed_quality : 1; 334 /** Enabling Tile part generation*/ 335 OPJ_BITFIELD m_tp_on : 1; 336 } 337 opj_encoding_param_t; 338 339 typedef struct opj_decoding_param { 340 /** if != 0, then original dimension divided by 2^(reduce); if == 0 or not used, image is decoded to the full resolution */ 341 OPJ_UINT32 m_reduce; 342 /** if != 0, then only the first "layer" layers are decoded; if == 0 or not used, all the quality layers are decoded */ 343 OPJ_UINT32 m_layer; 344 } 345 opj_decoding_param_t; 346 347 348 /** 349 * Coding parameters 350 */ 351 typedef struct opj_cp { 352 /** Size of the image in bits*/ 353 /*int img_size;*/ 354 /** Rsiz*/ 355 OPJ_UINT16 rsiz; 356 /** XTOsiz */ 357 OPJ_UINT32 tx0; /* MSD see norm */ 358 /** YTOsiz */ 359 OPJ_UINT32 ty0; /* MSD see norm */ 360 /** XTsiz */ 361 OPJ_UINT32 tdx; 362 /** YTsiz */ 363 OPJ_UINT32 tdy; 364 /** comment */ 365 OPJ_CHAR *comment; 366 /** number of tiles in width */ 367 OPJ_UINT32 tw; 368 /** number of tiles in height */ 369 OPJ_UINT32 th; 370 371 /** number of ppm markers (reserved size) */ 372 OPJ_UINT32 ppm_markers_count; 373 /** ppm markers data (table indexed by Zppm) */ 374 opj_ppx* ppm_markers; 375 376 /** packet header store there for future use in t2_decode_packet */ 377 OPJ_BYTE *ppm_data; 378 /** size of the ppm_data*/ 379 OPJ_UINT32 ppm_len; 380 /** size of the ppm_data*/ 381 OPJ_UINT32 ppm_data_read; 382 383 OPJ_BYTE *ppm_data_current; 384 385 /** packet header storage original buffer */ 386 OPJ_BYTE *ppm_buffer; 387 /** pointer remaining on the first byte of the first header if ppm is used */ 388 OPJ_BYTE *ppm_data_first; 389 /** Number of bytes actually stored inside the ppm_data */ 390 OPJ_UINT32 ppm_data_size; 391 /** use in case of multiple marker PPM (number of info already store) */ 392 OPJ_INT32 ppm_store; 393 /** use in case of multiple marker PPM (case on non-finished previous info) */ 394 OPJ_INT32 ppm_previous; 395 396 /** tile coding parameters */ 397 opj_tcp_t *tcps; 398 399 union { 400 opj_decoding_param_t m_dec; 401 opj_encoding_param_t m_enc; 402 } 403 m_specific_param; 404 405 /** OPJ_TRUE if entire bit stream must be decoded, OPJ_FALSE if partial bitstream decoding allowed */ 406 OPJ_BOOL strict; 407 408 /* UniPG>> */ 409 #ifdef USE_JPWL 410 /** enables writing of EPC in MH, thus activating JPWL */ 411 OPJ_BOOL epc_on; 412 /** enables writing of EPB, in case of activated JPWL */ 413 OPJ_BOOL epb_on; 414 /** enables writing of ESD, in case of activated JPWL */ 415 OPJ_BOOL esd_on; 416 /** enables writing of informative techniques of ESD, in case of activated JPWL */ 417 OPJ_BOOL info_on; 418 /** enables writing of RED, in case of activated JPWL */ 419 OPJ_BOOL red_on; 420 /** error protection method for MH (0,1,16,32,37-128) */ 421 int hprot_MH; 422 /** tile number of header protection specification (>=0) */ 423 int hprot_TPH_tileno[JPWL_MAX_NO_TILESPECS]; 424 /** error protection methods for TPHs (0,1,16,32,37-128) */ 425 int hprot_TPH[JPWL_MAX_NO_TILESPECS]; 426 /** tile number of packet protection specification (>=0) */ 427 int pprot_tileno[JPWL_MAX_NO_PACKSPECS]; 428 /** packet number of packet protection specification (>=0) */ 429 int pprot_packno[JPWL_MAX_NO_PACKSPECS]; 430 /** error protection methods for packets (0,1,16,32,37-128) */ 431 int pprot[JPWL_MAX_NO_PACKSPECS]; 432 /** enables writing of ESD, (0/2/4 bytes) */ 433 int sens_size; 434 /** sensitivity addressing size (0=auto/2/4 bytes) */ 435 int sens_addr; 436 /** sensitivity range (0-3) */ 437 int sens_range; 438 /** sensitivity method for MH (-1,0-7) */ 439 int sens_MH; 440 /** tile number of sensitivity specification (>=0) */ 441 int sens_TPH_tileno[JPWL_MAX_NO_TILESPECS]; 442 /** sensitivity methods for TPHs (-1,0-7) */ 443 int sens_TPH[JPWL_MAX_NO_TILESPECS]; 444 /** enables JPWL correction at the decoder */ 445 OPJ_BOOL correct; 446 /** expected number of components at the decoder */ 447 int exp_comps; 448 /** maximum number of tiles at the decoder */ 449 OPJ_UINT32 max_tiles; 450 #endif /* USE_JPWL */ 451 452 /******** FLAGS *********/ 453 /** if ppm == 1 --> there was a PPM marker*/ 454 OPJ_BITFIELD ppm : 1; 455 /** tells if the parameter is a coding or decoding one */ 456 OPJ_BITFIELD m_is_decoder : 1; 457 /** whether different bit depth or sign per component is allowed. Decoder only for ow */ 458 OPJ_BITFIELD allow_different_bit_depth_sign : 1; 459 /* <<UniPG */ 460 } opj_cp_t; 461 462 463 typedef struct opj_j2k_dec { 464 /** locate in which part of the codestream the decoder is (main header, tile header, end) */ 465 OPJ_UINT32 m_state; 466 /** 467 * store decoding parameters common to all tiles (information like COD, COC in main header) 468 */ 469 opj_tcp_t *m_default_tcp; 470 OPJ_BYTE *m_header_data; 471 OPJ_UINT32 m_header_data_size; 472 /** to tell the tile part length */ 473 OPJ_UINT32 m_sot_length; 474 /** Only tiles index in the correct range will be decoded.*/ 475 OPJ_UINT32 m_start_tile_x; 476 OPJ_UINT32 m_start_tile_y; 477 OPJ_UINT32 m_end_tile_x; 478 OPJ_UINT32 m_end_tile_y; 479 480 /** Index of the tile to decode (used in get_tile) */ 481 OPJ_INT32 m_tile_ind_to_dec; 482 /** Position of the last SOT marker read */ 483 OPJ_OFF_T m_last_sot_read_pos; 484 485 /** 486 * Indicate that the current tile-part is assume as the last tile part of the codestream. 487 * It is useful in the case of PSot is equal to zero. The sot length will be compute in the 488 * SOD reader function. FIXME NOT USED for the moment 489 */ 490 OPJ_BOOL m_last_tile_part; 491 492 OPJ_UINT32 m_numcomps_to_decode; 493 OPJ_UINT32 *m_comps_indices_to_decode; 494 495 /** to tell that a tile can be decoded. */ 496 OPJ_BITFIELD m_can_decode : 1; 497 OPJ_BITFIELD m_discard_tiles : 1; 498 OPJ_BITFIELD m_skip_data : 1; 499 /** TNsot correction : see issue 254 **/ 500 OPJ_BITFIELD m_nb_tile_parts_correction_checked : 1; 501 OPJ_BITFIELD m_nb_tile_parts_correction : 1; 502 503 } opj_j2k_dec_t; 504 505 typedef struct opj_j2k_enc { 506 /** Tile part number, regardless of poc, for each new poc, tp is reset to 1*/ 507 OPJ_UINT32 m_current_poc_tile_part_number; /* tp_num */ 508 509 /** Tile part number currently coding, taking into account POC. m_current_tile_part_number holds the total number of tile parts while encoding the last tile part.*/ 510 OPJ_UINT32 m_current_tile_part_number; /*cur_tp_num */ 511 512 /* whether to generate TLM markers */ 513 OPJ_BOOL m_TLM; 514 515 /* whether the Ttlmi field in a TLM marker is a byte (otherwise a uint16) */ 516 OPJ_BOOL m_Ttlmi_is_byte; 517 518 /** 519 locate the start position of the TLM marker 520 after encoding the tilepart, a jump (in j2k_write_sod) is done to the TLM marker to store the value of its length. 521 */ 522 OPJ_OFF_T m_tlm_start; 523 /** 524 * Stores the sizes of the tlm. 525 */ 526 OPJ_BYTE * m_tlm_sot_offsets_buffer; 527 /** 528 * The current offset of the tlm buffer. 529 */ 530 OPJ_BYTE * m_tlm_sot_offsets_current; 531 532 /** Total num of tile parts in whole image = num tiles* num tileparts in each tile*/ 533 /** used in TLMmarker*/ 534 OPJ_UINT32 m_total_tile_parts; /* totnum_tp */ 535 536 /* encoded data for a tile */ 537 OPJ_BYTE * m_encoded_tile_data; 538 539 /* size of the encoded_data */ 540 OPJ_UINT32 m_encoded_tile_size; 541 542 /* encoded data for a tile */ 543 OPJ_BYTE * m_header_tile_data; 544 545 /* size of the encoded_data */ 546 547 OPJ_UINT32 m_header_tile_data_size; 548 549 /* whether to generate PLT markers */ 550 OPJ_BOOL m_PLT; 551 552 /* reserved bytes in m_encoded_tile_size for PLT markers */ 553 OPJ_UINT32 m_reserved_bytes_for_PLT; 554 555 /** Number of components */ 556 OPJ_UINT32 m_nb_comps; 557 558 } opj_j2k_enc_t; 559 560 561 562 struct opj_tcd; 563 /** 564 JPEG-2000 codestream reader/writer 565 */ 566 typedef struct opj_j2k { 567 /* J2K codestream is decoded*/ 568 OPJ_BOOL m_is_decoder; 569 570 /* FIXME DOC*/ 571 union { 572 opj_j2k_dec_t m_decoder; 573 opj_j2k_enc_t m_encoder; 574 } 575 m_specific_param; 576 577 /** pointer to the internal/private encoded / decoded image */ 578 opj_image_t* m_private_image; 579 580 /* pointer to the output image (decoded)*/ 581 opj_image_t* m_output_image; 582 583 /** Coding parameters */ 584 opj_cp_t m_cp; 585 586 /** the list of procedures to exec **/ 587 opj_procedure_list_t * m_procedure_list; 588 589 /** the list of validation procedures to follow to make sure the code is valid **/ 590 opj_procedure_list_t * m_validation_list; 591 592 /** helper used to write the index file */ 593 opj_codestream_index_t *cstr_index; 594 595 /** number of the tile currently concern by coding/decoding */ 596 OPJ_UINT32 m_current_tile_number; 597 598 /** the current tile coder/decoder **/ 599 struct opj_tcd * m_tcd; 600 601 /** Thread pool */ 602 opj_thread_pool_t* m_tp; 603 604 /** Image width coming from JP2 IHDR box. 0 from a pure codestream */ 605 OPJ_UINT32 ihdr_w; 606 607 /** Image height coming from JP2 IHDR box. 0 from a pure codestream */ 608 OPJ_UINT32 ihdr_h; 609 610 /** Set to 1 by the decoder initialization if OPJ_DPARAMETERS_DUMP_FLAG is set */ 611 unsigned int dump_state; 612 } 613 opj_j2k_t; 614 615 616 617 618 /** @name Exported functions */ 619 /*@{*/ 620 /* ----------------------------------------------------------------------- */ 621 622 /** 623 Setup the decoder decoding parameters using user parameters. 624 Decoding parameters are returned in j2k->cp. 625 @param j2k J2K decompressor handle 626 @param parameters decompression parameters 627 */ 628 void opj_j2k_setup_decoder(opj_j2k_t *j2k, opj_dparameters_t *parameters); 629 630 void opj_j2k_decoder_set_strict_mode(opj_j2k_t *j2k, OPJ_BOOL strict); 631 632 OPJ_BOOL opj_j2k_set_threads(opj_j2k_t *j2k, OPJ_UINT32 num_threads); 633 634 /** 635 * Creates a J2K compression structure 636 * 637 * @return Returns a handle to a J2K compressor if successful, returns NULL otherwise 638 */ 639 opj_j2k_t* opj_j2k_create_compress(void); 640 641 642 OPJ_BOOL opj_j2k_setup_encoder(opj_j2k_t *p_j2k, 643 opj_cparameters_t *parameters, 644 opj_image_t *image, 645 opj_event_mgr_t * p_manager); 646 647 /** 648 Converts an enum type progression order to string type 649 */ 650 const char *opj_j2k_convert_progression_order(OPJ_PROG_ORDER prg_order); 651 652 /* ----------------------------------------------------------------------- */ 653 /*@}*/ 654 655 /*@}*/ 656 657 /** 658 * Ends the decompression procedures and possibiliy add data to be read after the 659 * codestream. 660 */ 661 OPJ_BOOL opj_j2k_end_decompress(opj_j2k_t *j2k, 662 opj_stream_private_t *p_stream, 663 opj_event_mgr_t * p_manager); 664 665 /** 666 * Reads a jpeg2000 codestream header structure. 667 * 668 * @param p_stream the stream to read data from. 669 * @param p_j2k the jpeg2000 codec. 670 * @param p_image FIXME DOC 671 * @param p_manager the user event manager. 672 * 673 * @return true if the box is valid. 674 */ 675 OPJ_BOOL opj_j2k_read_header(opj_stream_private_t *p_stream, 676 opj_j2k_t* p_j2k, 677 opj_image_t** p_image, 678 opj_event_mgr_t* p_manager); 679 680 681 /** 682 * Destroys a jpeg2000 codec. 683 * 684 * @param p_j2k the jpeg20000 structure to destroy. 685 */ 686 void opj_j2k_destroy(opj_j2k_t *p_j2k); 687 688 /** 689 * Destroys a codestream index structure. 690 * 691 * @param p_cstr_ind the codestream index parameter to destroy. 692 */ 693 void j2k_destroy_cstr_index(opj_codestream_index_t *p_cstr_ind); 694 695 /** 696 * Decode tile data. 697 * @param p_j2k the jpeg2000 codec. 698 * @param p_tile_index 699 * @param p_data FIXME DOC 700 * @param p_data_size FIXME DOC 701 * @param p_stream the stream to write data to. 702 * @param p_manager the user event manager. 703 */ 704 OPJ_BOOL opj_j2k_decode_tile(opj_j2k_t * p_j2k, 705 OPJ_UINT32 p_tile_index, 706 OPJ_BYTE * p_data, 707 OPJ_UINT32 p_data_size, 708 opj_stream_private_t *p_stream, 709 opj_event_mgr_t * p_manager); 710 711 /** 712 * Reads a tile header. 713 * @param p_j2k the jpeg2000 codec. 714 * @param p_tile_index FIXME DOC 715 * @param p_data_size FIXME DOC 716 * @param p_tile_x0 FIXME DOC 717 * @param p_tile_y0 FIXME DOC 718 * @param p_tile_x1 FIXME DOC 719 * @param p_tile_y1 FIXME DOC 720 * @param p_nb_comps FIXME DOC 721 * @param p_go_on FIXME DOC 722 * @param p_stream the stream to write data to. 723 * @param p_manager the user event manager. 724 */ 725 OPJ_BOOL opj_j2k_read_tile_header(opj_j2k_t * p_j2k, 726 OPJ_UINT32 * p_tile_index, 727 OPJ_UINT32 * p_data_size, 728 OPJ_INT32 * p_tile_x0, 729 OPJ_INT32 * p_tile_y0, 730 OPJ_INT32 * p_tile_x1, 731 OPJ_INT32 * p_tile_y1, 732 OPJ_UINT32 * p_nb_comps, 733 OPJ_BOOL * p_go_on, 734 opj_stream_private_t *p_stream, 735 opj_event_mgr_t * p_manager); 736 737 738 /** Sets the indices of the components to decode. 739 * 740 * @param p_j2k the jpeg2000 codec. 741 * @param numcomps Number of components to decode. 742 * @param comps_indices Array of num_compts indices (numbering starting at 0) 743 * corresponding to the components to decode. 744 * @param p_manager Event manager 745 * 746 * @return OPJ_TRUE in case of success. 747 */ 748 OPJ_BOOL opj_j2k_set_decoded_components(opj_j2k_t *p_j2k, 749 OPJ_UINT32 numcomps, 750 const OPJ_UINT32* comps_indices, 751 opj_event_mgr_t * p_manager); 752 753 /** 754 * Sets the given area to be decoded. This function should be called right after opj_read_header and before any tile header reading. 755 * 756 * @param p_j2k the jpeg2000 codec. 757 * @param p_image FIXME DOC 758 * @param p_start_x the left position of the rectangle to decode (in image coordinates). 759 * @param p_start_y the up position of the rectangle to decode (in image coordinates). 760 * @param p_end_x the right position of the rectangle to decode (in image coordinates). 761 * @param p_end_y the bottom position of the rectangle to decode (in image coordinates). 762 * @param p_manager the user event manager 763 * 764 * @return true if the area could be set. 765 */ 766 OPJ_BOOL opj_j2k_set_decode_area(opj_j2k_t *p_j2k, 767 opj_image_t* p_image, 768 OPJ_INT32 p_start_x, OPJ_INT32 p_start_y, 769 OPJ_INT32 p_end_x, OPJ_INT32 p_end_y, 770 opj_event_mgr_t * p_manager); 771 772 /** 773 * Creates a J2K decompression structure. 774 * 775 * @return a handle to a J2K decompressor if successful, NULL otherwise. 776 */ 777 opj_j2k_t* opj_j2k_create_decompress(void); 778 779 780 /** 781 * Dump some elements from the J2K decompression structure . 782 * 783 *@param p_j2k the jpeg2000 codec. 784 *@param flag flag to describe what elements are dump. 785 *@param out_stream output stream where dump the elements. 786 * 787 */ 788 void j2k_dump(opj_j2k_t* p_j2k, OPJ_INT32 flag, FILE* out_stream); 789 790 791 792 /** 793 * Dump an image header structure. 794 * 795 *@param image the image header to dump. 796 *@param dev_dump_flag flag to describe if we are in the case of this function is use outside j2k_dump function 797 *@param out_stream output stream where dump the elements. 798 */ 799 void j2k_dump_image_header(opj_image_t* image, OPJ_BOOL dev_dump_flag, 800 FILE* out_stream); 801 802 /** 803 * Dump a component image header structure. 804 * 805 *@param comp the component image header to dump. 806 *@param dev_dump_flag flag to describe if we are in the case of this function is use outside j2k_dump function 807 *@param out_stream output stream where dump the elements. 808 */ 809 void j2k_dump_image_comp_header(opj_image_comp_t* comp, OPJ_BOOL dev_dump_flag, 810 FILE* out_stream); 811 812 /** 813 * Get the codestream info from a JPEG2000 codec. 814 * 815 *@param p_j2k the component image header to dump. 816 * 817 *@return the codestream information extract from the jpg2000 codec 818 */ 819 opj_codestream_info_v2_t* j2k_get_cstr_info(opj_j2k_t* p_j2k); 820 821 /** 822 * Get the codestream index from a JPEG2000 codec. 823 * 824 *@param p_j2k the component image header to dump. 825 * 826 *@return the codestream index extract from the jpg2000 codec 827 */ 828 opj_codestream_index_t* j2k_get_cstr_index(opj_j2k_t* p_j2k); 829 830 /** 831 * Decode an image from a JPEG-2000 codestream 832 * @param j2k J2K decompressor handle 833 * @param p_stream FIXME DOC 834 * @param p_image FIXME DOC 835 * @param p_manager FIXME DOC 836 * @return FIXME DOC 837 */ 838 OPJ_BOOL opj_j2k_decode(opj_j2k_t *j2k, 839 opj_stream_private_t *p_stream, 840 opj_image_t *p_image, 841 opj_event_mgr_t *p_manager); 842 843 844 OPJ_BOOL opj_j2k_get_tile(opj_j2k_t *p_j2k, 845 opj_stream_private_t *p_stream, 846 opj_image_t* p_image, 847 opj_event_mgr_t * p_manager, 848 OPJ_UINT32 tile_index); 849 850 OPJ_BOOL opj_j2k_set_decoded_resolution_factor(opj_j2k_t *p_j2k, 851 OPJ_UINT32 res_factor, 852 opj_event_mgr_t * p_manager); 853 854 /** 855 * Specify extra options for the encoder. 856 * 857 * @param p_j2k the jpeg2000 codec. 858 * @param p_options options 859 * @param p_manager the user event manager 860 * 861 * @see opj_encoder_set_extra_options() for more details. 862 */ 863 OPJ_BOOL opj_j2k_encoder_set_extra_options( 864 opj_j2k_t *p_j2k, 865 const char* const* p_options, 866 opj_event_mgr_t * p_manager); 867 868 /** 869 * Writes a tile. 870 * @param p_j2k the jpeg2000 codec. 871 * @param p_tile_index FIXME DOC 872 * @param p_data FIXME DOC 873 * @param p_data_size FIXME DOC 874 * @param p_stream the stream to write data to. 875 * @param p_manager the user event manager. 876 */ 877 OPJ_BOOL opj_j2k_write_tile(opj_j2k_t * p_j2k, 878 OPJ_UINT32 p_tile_index, 879 OPJ_BYTE * p_data, 880 OPJ_UINT32 p_data_size, 881 opj_stream_private_t *p_stream, 882 opj_event_mgr_t * p_manager); 883 884 /** 885 * Encodes an image into a JPEG-2000 codestream 886 */ 887 OPJ_BOOL opj_j2k_encode(opj_j2k_t * p_j2k, 888 opj_stream_private_t *cio, 889 opj_event_mgr_t * p_manager); 890 891 /** 892 * Starts a compression scheme, i.e. validates the codec parameters, writes the header. 893 * 894 * @param p_j2k the jpeg2000 codec. 895 * @param p_stream the stream object. 896 * @param p_image FIXME DOC 897 * @param p_manager the user event manager. 898 * 899 * @return true if the codec is valid. 900 */ 901 OPJ_BOOL opj_j2k_start_compress(opj_j2k_t *p_j2k, 902 opj_stream_private_t *p_stream, 903 opj_image_t * p_image, 904 opj_event_mgr_t * p_manager); 905 906 /** 907 * Ends the compression procedures and possibiliy add data to be read after the 908 * codestream. 909 */ 910 OPJ_BOOL opj_j2k_end_compress(opj_j2k_t *p_j2k, 911 opj_stream_private_t *cio, 912 opj_event_mgr_t * p_manager); 913 914 OPJ_BOOL opj_j2k_setup_mct_encoding(opj_tcp_t * p_tcp, opj_image_t * p_image); 915 916 917 #endif /* OPJ_J2K_H */ 918