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 __J2K_H 43 #define __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_QNTSTY_NOQNT 0 65 #define J2K_CCP_QNTSTY_SIQNT 1 66 #define J2K_CCP_QNTSTY_SEQNT 2 67 68 #define OPJ_J2K_DEFAULT_CBLK_DATA_SIZE 8192 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_SIZ 0xff51 /**< SIZ marker value */ 77 #define J2K_MS_COD 0xff52 /**< COD marker value */ 78 #define J2K_MS_COC 0xff53 /**< COC marker value */ 79 #define J2K_MS_RGN 0xff5e /**< RGN marker value */ 80 #define J2K_MS_QCD 0xff5c /**< QCD marker value */ 81 #define J2K_MS_QCC 0xff5d /**< QCC marker value */ 82 #define J2K_MS_POC 0xff5f /**< POC marker value */ 83 #define J2K_MS_TLM 0xff55 /**< TLM marker value */ 84 #define J2K_MS_PLM 0xff57 /**< PLM marker value */ 85 #define J2K_MS_PLT 0xff58 /**< PLT marker value */ 86 #define J2K_MS_PPM 0xff60 /**< PPM marker value */ 87 #define J2K_MS_PPT 0xff61 /**< PPT marker value */ 88 #define J2K_MS_SOP 0xff91 /**< SOP marker value */ 89 #define J2K_MS_EPH 0xff92 /**< EPH marker value */ 90 #define J2K_MS_CRG 0xff63 /**< CRG marker value */ 91 #define J2K_MS_COM 0xff64 /**< COM marker value */ 92 #define J2K_MS_CBD 0xff78 /**< CBD marker value */ 93 #define J2K_MS_MCC 0xff75 /**< MCC marker value */ 94 #define J2K_MS_MCT 0xff74 /**< MCT marker value */ 95 #define J2K_MS_MCO 0xff77 /**< MCO marker value */ 96 97 #define J2K_MS_UNK 0 /**< UNKNOWN marker value */ 98 99 /* UniPG>> */ 100 #ifdef USE_JPWL 101 #define J2K_MS_EPC 0xff68 /**< EPC marker value (Part 11: JPEG 2000 for Wireless) */ 102 #define J2K_MS_EPB 0xff66 /**< EPB marker value (Part 11: JPEG 2000 for Wireless) */ 103 #define J2K_MS_ESD 0xff67 /**< ESD marker value (Part 11: JPEG 2000 for Wireless) */ 104 #define J2K_MS_RED 0xff69 /**< RED marker value (Part 11: JPEG 2000 for Wireless) */ 105 #endif /* USE_JPWL */ 106 #ifdef USE_JPSEC 107 #define J2K_MS_SEC 0xff65 /**< SEC marker value (Part 8: Secure JPEG 2000) */ 108 #define J2K_MS_INSEC 0xff94 /**< INSEC marker value (Part 8: Secure JPEG 2000) */ 109 #endif /* USE_JPSEC */ 110 /* <<UniPG */ 111 112 /* ----------------------------------------------------------------------- */ 113 114 /** 115 * Values that specify the status of the decoding process when decoding the main header. 116 * These values may be combined with a | operator. 117 * */ 118 typedef enum J2K_STATUS { 119 J2K_STATE_NONE = 0x0000, /**< a SOC marker is expected */ 120 J2K_STATE_MHSOC = 0x0001, /**< a SOC marker is expected */ 121 J2K_STATE_MHSIZ = 0x0002, /**< a SIZ marker is expected */ 122 J2K_STATE_MH = 0x0004, /**< the decoding process is in the main header */ 123 J2K_STATE_TPHSOT = 0x0008, /**< the decoding process is in a tile part header and expects a SOT marker */ 124 J2K_STATE_TPH = 0x0010, /**< the decoding process is in a tile part header */ 125 J2K_STATE_MT = 0x0020, /**< the EOC marker has just been read */ 126 J2K_STATE_NEOC = 0x0040, /**< the decoding process must not expect a EOC marker because the codestream is truncated */ 127 128 J2K_STATE_EOC = 0x0100, /**< the decoding process has encountered the EOC marker */ 129 J2K_STATE_ERR = 0x8000 /**< the decoding process has encountered an error (FIXME warning V1 = 0x0080)*/ 130 } J2K_STATUS; 131 132 /** 133 * Type of elements storing in the MCT data 134 */ 135 typedef enum MCT_ELEMENT_TYPE 136 { 137 MCT_TYPE_INT16 = 0, /** MCT data is stored as signed shorts*/ 138 MCT_TYPE_INT32 = 1, /** MCT data is stored as signed integers*/ 139 MCT_TYPE_FLOAT = 2, /** MCT data is stored as floats*/ 140 MCT_TYPE_DOUBLE = 3 /** MCT data is stored as doubles*/ 141 } J2K_MCT_ELEMENT_TYPE; 142 143 /** 144 * Type of MCT array 145 */ 146 typedef enum MCT_ARRAY_TYPE 147 { 148 MCT_TYPE_DEPENDENCY = 0, 149 MCT_TYPE_DECORRELATION = 1, 150 MCT_TYPE_OFFSET = 2 151 } J2K_MCT_ARRAY_TYPE; 152 153 /* ----------------------------------------------------------------------- */ 154 155 /** 156 T2 encoding mode 157 */ 158 typedef enum T2_MODE { 159 THRESH_CALC = 0, /** Function called in Rate allocation process*/ 160 FINAL_PASS = 1 /** Function called in Tier 2 process*/ 161 }J2K_T2_MODE; 162 163 /** 164 * Quantization stepsize 165 */ 166 typedef struct opj_stepsize { 167 /** exponent */ 168 OPJ_INT32 expn; 169 /** mantissa */ 170 OPJ_INT32 mant; 171 } opj_stepsize_t; 172 173 /** 174 Tile-component coding parameters 175 */ 176 typedef struct opj_tccp 177 { 178 /** coding style */ 179 OPJ_UINT32 csty; 180 /** number of resolutions */ 181 OPJ_UINT32 numresolutions; 182 /** code-blocks width */ 183 OPJ_UINT32 cblkw; 184 /** code-blocks height */ 185 OPJ_UINT32 cblkh; 186 /** code-block coding style */ 187 OPJ_UINT32 cblksty; 188 /** discrete wavelet transform identifier */ 189 OPJ_UINT32 qmfbid; 190 /** quantisation style */ 191 OPJ_UINT32 qntsty; 192 /** stepsizes used for quantization */ 193 opj_stepsize_t stepsizes[OPJ_J2K_MAXBANDS]; 194 /** number of guard bits */ 195 OPJ_UINT32 numgbits; 196 /** Region Of Interest shift */ 197 OPJ_INT32 roishift; 198 /** precinct width */ 199 OPJ_UINT32 prcw[OPJ_J2K_MAXRLVLS]; 200 /** precinct height */ 201 OPJ_UINT32 prch[OPJ_J2K_MAXRLVLS]; 202 /** the dc_level_shift **/ 203 OPJ_INT32 m_dc_level_shift; 204 } 205 opj_tccp_t; 206 207 208 209 /** 210 * FIXME DOC 211 */ 212 typedef struct opj_mct_data 213 { 214 J2K_MCT_ELEMENT_TYPE m_element_type; 215 J2K_MCT_ARRAY_TYPE m_array_type; 216 OPJ_UINT32 m_index; 217 OPJ_BYTE * m_data; 218 OPJ_UINT32 m_data_size; 219 } 220 opj_mct_data_t; 221 222 /** 223 * FIXME DOC 224 */ 225 typedef struct opj_simple_mcc_decorrelation_data 226 { 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_UINT32 m_is_irreversible : 1; 232 } 233 opj_simple_mcc_decorrelation_data_t; 234 235 /** 236 Tile coding parameters : 237 this structure is used to store coding/decoding parameters common to all 238 tiles (information like COD, COC in main header) 239 */ 240 typedef struct opj_tcp 241 { 242 /** coding style */ 243 OPJ_UINT32 csty; 244 /** progression order */ 245 OPJ_PROG_ORDER prg; 246 /** number of layers */ 247 OPJ_UINT32 numlayers; 248 OPJ_UINT32 num_layers_to_decode; 249 /** multi-component transform identifier */ 250 OPJ_UINT32 mct; 251 /** rates of layers */ 252 OPJ_FLOAT32 rates[100]; 253 /** number of progression order changes */ 254 OPJ_UINT32 numpocs; 255 /** progression order changes */ 256 opj_poc_t pocs[32]; 257 /** packet header store there for futur use in t2_decode_packet */ 258 OPJ_BYTE *ppt_data; 259 /** used to keep a track of the allocated memory */ 260 OPJ_BYTE *ppt_buffer; 261 /** Number of bytes stored inside ppt_data*/ 262 OPJ_UINT32 ppt_data_size; 263 /** size of ppt_data*/ 264 OPJ_UINT32 ppt_len; 265 /** add fixed_quality */ 266 OPJ_FLOAT32 distoratio[100]; 267 /** tile-component coding parameters */ 268 opj_tccp_t *tccps; 269 /** number of tile parts for the tile. */ 270 OPJ_UINT32 m_nb_tile_parts; 271 /** data for the tile */ 272 OPJ_BYTE * m_data; 273 /** size of data */ 274 OPJ_UINT32 m_data_size; 275 /** encoding norms */ 276 OPJ_FLOAT64 * mct_norms; 277 /** the mct decoding matrix */ 278 OPJ_FLOAT32 * m_mct_decoding_matrix; 279 /** the mct coding matrix */ 280 OPJ_FLOAT32 * m_mct_coding_matrix; 281 /** mct records */ 282 opj_mct_data_t * m_mct_records; 283 /** the number of mct records. */ 284 OPJ_UINT32 m_nb_mct_records; 285 /** the max number of mct records. */ 286 OPJ_UINT32 m_nb_max_mct_records; 287 /** mcc records */ 288 opj_simple_mcc_decorrelation_data_t * m_mcc_records; 289 /** the number of mct records. */ 290 OPJ_UINT32 m_nb_mcc_records; 291 /** the max number of mct records. */ 292 OPJ_UINT32 m_nb_max_mcc_records; 293 294 295 /***** FLAGS *******/ 296 /** If ppt == 1 --> there was a PPT marker for the present tile */ 297 OPJ_UINT32 ppt : 1; 298 /** indicates if a POC marker has been used O:NO, 1:YES */ 299 OPJ_UINT32 POC : 1; 300 } opj_tcp_t; 301 302 303 304 305 typedef struct opj_encoding_param 306 { 307 /** Digital cinema profile*/ 308 OPJ_CINEMA_MODE m_cinema; 309 /** Maximum rate for each component. If == 0, component size limitation is not considered */ 310 OPJ_UINT32 m_max_comp_size; 311 /** Position of tile part flag in progression order*/ 312 OPJ_INT32 m_tp_pos; 313 /** fixed layer */ 314 OPJ_INT32 *m_matrice; 315 /** Flag determining tile part generation*/ 316 OPJ_BYTE m_tp_flag; 317 /** allocation by rate/distortion */ 318 OPJ_UINT32 m_disto_alloc : 1; 319 /** allocation by fixed layer */ 320 OPJ_UINT32 m_fixed_alloc : 1; 321 /** add fixed_quality */ 322 OPJ_UINT32 m_fixed_quality : 1; 323 /** Enabling Tile part generation*/ 324 OPJ_UINT32 m_tp_on : 1; 325 } 326 opj_encoding_param_t; 327 328 typedef struct opj_decoding_param 329 { 330 /** if != 0, then original dimension divided by 2^(reduce); if == 0 or not used, image is decoded to the full resolution */ 331 OPJ_UINT32 m_reduce; 332 /** if != 0, then only the first "layer" layers are decoded; if == 0 or not used, all the quality layers are decoded */ 333 OPJ_UINT32 m_layer; 334 } 335 opj_decoding_param_t; 336 337 338 /** 339 * Coding parameters 340 */ 341 typedef struct opj_cp 342 { 343 /** Size of the image in bits*/ 344 /*int img_size;*/ 345 /** Rsiz*/ 346 OPJ_RSIZ_CAPABILITIES rsiz; 347 /** XTOsiz */ 348 OPJ_UINT32 tx0; /* MSD see norm */ 349 /** YTOsiz */ 350 OPJ_UINT32 ty0; /* MSD see norm */ 351 /** XTsiz */ 352 OPJ_UINT32 tdx; 353 /** YTsiz */ 354 OPJ_UINT32 tdy; 355 /** comment */ 356 OPJ_CHAR *comment; 357 /** number of tiles in width */ 358 OPJ_UINT32 tw; 359 /** number of tiles in heigth */ 360 OPJ_UINT32 th; 361 362 /** packet header store there for futur use in t2_decode_packet */ 363 OPJ_BYTE *ppm_data; 364 /** size of the ppm_data*/ 365 OPJ_UINT32 ppm_len; 366 /** size of the ppm_data*/ 367 OPJ_UINT32 ppm_data_read; 368 369 OPJ_BYTE *ppm_data_current; 370 371 /** packet header storage original buffer */ 372 OPJ_BYTE *ppm_buffer; 373 /** pointer remaining on the first byte of the first header if ppm is used */ 374 OPJ_BYTE *ppm_data_first; 375 /** Number of bytes actually stored inside the ppm_data */ 376 OPJ_UINT32 ppm_data_size; 377 /** use in case of multiple marker PPM (number of info already store) */ 378 OPJ_INT32 ppm_store; 379 /** use in case of multiple marker PPM (case on non-finished previous info) */ 380 OPJ_INT32 ppm_previous; 381 382 /** tile coding parameters */ 383 opj_tcp_t *tcps; 384 385 union 386 { 387 opj_decoding_param_t m_dec; 388 opj_encoding_param_t m_enc; 389 } 390 m_specific_param; 391 392 393 /* UniPG>> */ 394 #ifdef USE_JPWL 395 /** enables writing of EPC in MH, thus activating JPWL */ 396 OPJ_BOOL epc_on; 397 /** enables writing of EPB, in case of activated JPWL */ 398 OPJ_BOOL epb_on; 399 /** enables writing of ESD, in case of activated JPWL */ 400 OPJ_BOOL esd_on; 401 /** enables writing of informative techniques of ESD, in case of activated JPWL */ 402 OPJ_BOOL info_on; 403 /** enables writing of RED, in case of activated JPWL */ 404 OPJ_BOOL red_on; 405 /** error protection method for MH (0,1,16,32,37-128) */ 406 int hprot_MH; 407 /** tile number of header protection specification (>=0) */ 408 int hprot_TPH_tileno[JPWL_MAX_NO_TILESPECS]; 409 /** error protection methods for TPHs (0,1,16,32,37-128) */ 410 int hprot_TPH[JPWL_MAX_NO_TILESPECS]; 411 /** tile number of packet protection specification (>=0) */ 412 int pprot_tileno[JPWL_MAX_NO_PACKSPECS]; 413 /** packet number of packet protection specification (>=0) */ 414 int pprot_packno[JPWL_MAX_NO_PACKSPECS]; 415 /** error protection methods for packets (0,1,16,32,37-128) */ 416 int pprot[JPWL_MAX_NO_PACKSPECS]; 417 /** enables writing of ESD, (0/2/4 bytes) */ 418 int sens_size; 419 /** sensitivity addressing size (0=auto/2/4 bytes) */ 420 int sens_addr; 421 /** sensitivity range (0-3) */ 422 int sens_range; 423 /** sensitivity method for MH (-1,0-7) */ 424 int sens_MH; 425 /** tile number of sensitivity specification (>=0) */ 426 int sens_TPH_tileno[JPWL_MAX_NO_TILESPECS]; 427 /** sensitivity methods for TPHs (-1,0-7) */ 428 int sens_TPH[JPWL_MAX_NO_TILESPECS]; 429 /** enables JPWL correction at the decoder */ 430 OPJ_BOOL correct; 431 /** expected number of components at the decoder */ 432 int exp_comps; 433 /** maximum number of tiles at the decoder */ 434 OPJ_UINT32 max_tiles; 435 #endif /* USE_JPWL */ 436 437 /******** FLAGS *********/ 438 /** if ppm == 1 --> there was a PPM marker*/ 439 OPJ_UINT32 ppm : 1; 440 /** tells if the parameter is a coding or decoding one */ 441 OPJ_UINT32 m_is_decoder : 1; 442 /* <<UniPG */ 443 } opj_cp_t; 444 445 446 typedef struct opj_j2k_dec 447 { 448 /** locate in which part of the codestream the decoder is (main header, tile header, end) */ 449 OPJ_UINT32 m_state; 450 /** 451 * store decoding parameters common to all tiles (information like COD, COC in main header) 452 */ 453 opj_tcp_t *m_default_tcp; 454 OPJ_BYTE *m_header_data; 455 OPJ_UINT32 m_header_data_size; 456 /** to tell the tile part length */ 457 OPJ_UINT32 m_sot_length; 458 /** Only tiles index in the correct range will be decoded.*/ 459 OPJ_UINT32 m_start_tile_x; 460 OPJ_UINT32 m_start_tile_y; 461 OPJ_UINT32 m_end_tile_x; 462 OPJ_UINT32 m_end_tile_y; 463 /** 464 * Decoded area set by the user 465 */ 466 OPJ_UINT32 m_DA_x0; 467 OPJ_UINT32 m_DA_y0; 468 OPJ_UINT32 m_DA_x1; 469 OPJ_UINT32 m_DA_y1; 470 471 /** Index of the tile to decode (used in get_tile) */ 472 OPJ_INT32 m_tile_ind_to_dec; 473 /** Position of the last SOT marker read */ 474 OPJ_OFF_T m_last_sot_read_pos; 475 476 /** 477 * Indicate that the current tile-part is assume as the last tile part of the codestream. 478 * It is useful in the case of PSot is equal to zero. The sot length will be compute in the 479 * SOD reader function. FIXME NOT USED for the moment 480 */ 481 OPJ_BOOL m_last_tile_part; 482 /** to tell that a tile can be decoded. */ 483 OPJ_UINT32 m_can_decode : 1; 484 OPJ_UINT32 m_discard_tiles : 1; 485 OPJ_UINT32 m_skip_data : 1; 486 487 } opj_j2k_dec_t; 488 489 typedef struct opj_j2k_enc 490 { 491 /** Tile part number, regardless of poc, for each new poc, tp is reset to 1*/ 492 OPJ_UINT32 m_current_poc_tile_part_number; /* tp_num */ 493 494 /** 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.*/ 495 OPJ_UINT32 m_current_tile_part_number; /*cur_tp_num */ 496 497 /** 498 locate the start position of the TLM marker 499 after encoding the tilepart, a jump (in j2k_write_sod) is done to the TLM marker to store the value of its length. 500 */ 501 OPJ_OFF_T m_tlm_start; 502 /** 503 * Stores the sizes of the tlm. 504 */ 505 OPJ_BYTE * m_tlm_sot_offsets_buffer; 506 /** 507 * The current offset of the tlm buffer. 508 */ 509 OPJ_BYTE * m_tlm_sot_offsets_current; 510 511 /** Total num of tile parts in whole image = num tiles* num tileparts in each tile*/ 512 /** used in TLMmarker*/ 513 OPJ_UINT32 m_total_tile_parts; /* totnum_tp */ 514 515 /* encoded data for a tile */ 516 OPJ_BYTE * m_encoded_tile_data; 517 518 /* size of the encoded_data */ 519 OPJ_UINT32 m_encoded_tile_size; 520 521 /* encoded data for a tile */ 522 OPJ_BYTE * m_header_tile_data; 523 524 /* size of the encoded_data */ 525 OPJ_UINT32 m_header_tile_data_size; 526 527 528 } opj_j2k_enc_t; 529 530 531 532 struct opj_tcd; 533 /** 534 JPEG-2000 codestream reader/writer 535 */ 536 typedef struct opj_j2k 537 { 538 /* J2K codestream is decoded*/ 539 OPJ_BOOL m_is_decoder; 540 541 /* FIXME DOC*/ 542 union 543 { 544 opj_j2k_dec_t m_decoder; 545 opj_j2k_enc_t m_encoder; 546 } 547 m_specific_param; 548 549 /** pointer to the internal/private encoded / decoded image */ 550 opj_image_t* m_private_image; 551 552 /* pointer to the output image (decoded)*/ 553 opj_image_t* m_output_image; 554 555 /** Coding parameters */ 556 opj_cp_t m_cp; 557 558 /** the list of procedures to exec **/ 559 opj_procedure_list_t * m_procedure_list; 560 561 /** the list of validation procedures to follow to make sure the code is valid **/ 562 opj_procedure_list_t * m_validation_list; 563 564 /** helper used to write the index file */ 565 opj_codestream_index_t *cstr_index; 566 567 /** number of the tile curently concern by coding/decoding */ 568 OPJ_UINT32 m_current_tile_number; 569 570 /** the current tile coder/decoder **/ 571 struct opj_tcd * m_tcd; 572 573 } 574 opj_j2k_t; 575 576 577 578 579 /** @name Exported functions */ 580 /*@{*/ 581 /* ----------------------------------------------------------------------- */ 582 583 /** 584 Setup the decoder decoding parameters using user parameters. 585 Decoding parameters are returned in j2k->cp. 586 @param j2k J2K decompressor handle 587 @param parameters decompression parameters 588 */ 589 void opj_j2k_setup_decoder(opj_j2k_t *j2k, opj_dparameters_t *parameters); 590 591 /** 592 * Creates a J2K compression structure 593 * 594 * @return Returns a handle to a J2K compressor if successful, returns NULL otherwise 595 */ 596 opj_j2k_t* opj_j2k_create_compress(void); 597 598 599 void opj_j2k_setup_encoder( opj_j2k_t *p_j2k, 600 opj_cparameters_t *parameters, 601 opj_image_t *image, 602 opj_event_mgr_t * p_manager); 603 604 /** 605 Converts an enum type progression order to string type 606 */ 607 char *opj_j2k_convert_progression_order(OPJ_PROG_ORDER prg_order); 608 609 /* ----------------------------------------------------------------------- */ 610 /*@}*/ 611 612 /*@}*/ 613 614 /** 615 * Ends the decompression procedures and possibiliy add data to be read after the 616 * codestream. 617 */ 618 OPJ_BOOL opj_j2k_end_decompress(opj_j2k_t *j2k, 619 opj_stream_private_t *p_stream, 620 opj_event_mgr_t * p_manager); 621 622 /** 623 * Reads a jpeg2000 codestream header structure. 624 * 625 * @param p_stream the stream to read data from. 626 * @param p_j2k the jpeg2000 codec. 627 * @param p_image FIXME DOC 628 * @param p_manager the user event manager. 629 * 630 * @return true if the box is valid. 631 */ 632 OPJ_BOOL opj_j2k_read_header( opj_stream_private_t *p_stream, 633 opj_j2k_t* p_j2k, 634 opj_image_t** p_image, 635 opj_event_mgr_t* p_manager ); 636 637 638 /** 639 * Destroys a jpeg2000 codec. 640 * 641 * @param p_j2k the jpeg20000 structure to destroy. 642 */ 643 void opj_j2k_destroy (opj_j2k_t *p_j2k); 644 645 /** 646 * Destroys a codestream index structure. 647 * 648 * @param p_cstr_ind the codestream index parameter to destroy. 649 */ 650 void j2k_destroy_cstr_index (opj_codestream_index_t *p_cstr_ind); 651 652 /** 653 * Decode tile data. 654 * @param p_j2k the jpeg2000 codec. 655 * @param p_tile_index 656 * @param p_data FIXME DOC 657 * @param p_data_size FIXME DOC 658 * @param p_stream the stream to write data to. 659 * @param p_manager the user event manager. 660 */ 661 OPJ_BOOL opj_j2k_decode_tile ( opj_j2k_t * p_j2k, 662 OPJ_UINT32 p_tile_index, 663 OPJ_BYTE * p_data, 664 OPJ_UINT32 p_data_size, 665 opj_stream_private_t *p_stream, 666 opj_event_mgr_t * p_manager ); 667 668 /** 669 * Reads a tile header. 670 * @param p_j2k the jpeg2000 codec. 671 * @param p_tile_index FIXME DOC 672 * @param p_data_size FIXME DOC 673 * @param p_tile_x0 FIXME DOC 674 * @param p_tile_y0 FIXME DOC 675 * @param p_tile_x1 FIXME DOC 676 * @param p_tile_y1 FIXME DOC 677 * @param p_nb_comps FIXME DOC 678 * @param p_go_on FIXME DOC 679 * @param p_stream the stream to write data to. 680 * @param p_manager the user event manager. 681 */ 682 OPJ_BOOL opj_j2k_read_tile_header ( opj_j2k_t * p_j2k, 683 OPJ_UINT32 * p_tile_index, 684 OPJ_UINT32 * p_data_size, 685 OPJ_INT32 * p_tile_x0, 686 OPJ_INT32 * p_tile_y0, 687 OPJ_INT32 * p_tile_x1, 688 OPJ_INT32 * p_tile_y1, 689 OPJ_UINT32 * p_nb_comps, 690 OPJ_BOOL * p_go_on, 691 opj_stream_private_t *p_stream, 692 opj_event_mgr_t * p_manager ); 693 694 695 /** 696 * Sets the given area to be decoded. This function should be called right after opj_read_header and before any tile header reading. 697 * 698 * @param p_j2k the jpeg2000 codec. 699 * @param p_image FIXME DOC 700 * @param p_start_x the left position of the rectangle to decode (in image coordinates). 701 * @param p_start_y the up position of the rectangle to decode (in image coordinates). 702 * @param p_end_x the right position of the rectangle to decode (in image coordinates). 703 * @param p_end_y the bottom position of the rectangle to decode (in image coordinates). 704 * @param p_manager the user event manager 705 * 706 * @return true if the area could be set. 707 */ 708 OPJ_BOOL opj_j2k_set_decode_area( opj_j2k_t *p_j2k, 709 opj_image_t* p_image, 710 OPJ_INT32 p_start_x, OPJ_INT32 p_start_y, 711 OPJ_INT32 p_end_x, OPJ_INT32 p_end_y, 712 opj_event_mgr_t * p_manager ); 713 714 /** 715 * Creates a J2K decompression structure. 716 * 717 * @return a handle to a J2K decompressor if successful, NULL otherwise. 718 */ 719 opj_j2k_t* opj_j2k_create_decompress(void); 720 721 722 /** 723 * Dump some elements from the J2K decompression structure . 724 * 725 *@param p_j2k the jpeg2000 codec. 726 *@param flag flag to describe what elments are dump. 727 *@param out_stream output stream where dump the elements. 728 * 729 */ 730 void j2k_dump (opj_j2k_t* p_j2k, OPJ_INT32 flag, FILE* out_stream); 731 732 733 734 /** 735 * Dump an image header structure. 736 * 737 *@param image the image header to dump. 738 *@param dev_dump_flag flag to describe if we are in the case of this function is use outside j2k_dump function 739 *@param out_stream output stream where dump the elements. 740 */ 741 void j2k_dump_image_header(opj_image_t* image, OPJ_BOOL dev_dump_flag, FILE* out_stream); 742 743 /** 744 * Dump a component image header structure. 745 * 746 *@param comp the component image header to dump. 747 *@param dev_dump_flag flag to describe if we are in the case of this function is use outside j2k_dump function 748 *@param out_stream output stream where dump the elements. 749 */ 750 void j2k_dump_image_comp_header(opj_image_comp_t* comp, OPJ_BOOL dev_dump_flag, FILE* out_stream); 751 752 /** 753 * Get the codestream info from a JPEG2000 codec. 754 * 755 *@param p_j2k the component image header to dump. 756 * 757 *@return the codestream information extract from the jpg2000 codec 758 */ 759 opj_codestream_info_v2_t* j2k_get_cstr_info(opj_j2k_t* p_j2k); 760 761 /** 762 * Get the codestream index from a JPEG2000 codec. 763 * 764 *@param p_j2k the component image header to dump. 765 * 766 *@return the codestream index extract from the jpg2000 codec 767 */ 768 opj_codestream_index_t* j2k_get_cstr_index(opj_j2k_t* p_j2k); 769 770 /** 771 * Decode an image from a JPEG-2000 codestream 772 * @param j2k J2K decompressor handle 773 * @param p_stream FIXME DOC 774 * @param p_image FIXME DOC 775 * @param p_manager FIXME DOC 776 * @return FIXME DOC 777 */ 778 OPJ_BOOL opj_j2k_decode(opj_j2k_t *j2k, 779 opj_stream_private_t *p_stream, 780 opj_image_t *p_image, 781 opj_event_mgr_t *p_manager); 782 783 784 OPJ_BOOL opj_j2k_get_tile( opj_j2k_t *p_j2k, 785 opj_stream_private_t *p_stream, 786 opj_image_t* p_image, 787 opj_event_mgr_t * p_manager, 788 OPJ_UINT32 tile_index ); 789 790 OPJ_BOOL opj_j2k_set_decoded_resolution_factor(opj_j2k_t *p_j2k, 791 OPJ_UINT32 res_factor, 792 opj_event_mgr_t * p_manager); 793 794 795 /** 796 * Writes a tile. 797 * @param p_j2k the jpeg2000 codec. 798 * @param p_tile_index FIXME DOC 799 * @param p_data FIXME DOC 800 * @param p_data_size FIXME DOC 801 * @param p_stream the stream to write data to. 802 * @param p_manager the user event manager. 803 */ 804 OPJ_BOOL opj_j2k_write_tile ( opj_j2k_t * p_j2k, 805 OPJ_UINT32 p_tile_index, 806 OPJ_BYTE * p_data, 807 OPJ_UINT32 p_data_size, 808 opj_stream_private_t *p_stream, 809 opj_event_mgr_t * p_manager ); 810 811 /** 812 * Encodes an image into a JPEG-2000 codestream 813 */ 814 OPJ_BOOL opj_j2k_encode( opj_j2k_t * p_j2k, 815 opj_stream_private_t *cio, 816 opj_event_mgr_t * p_manager ); 817 818 /** 819 * Starts a compression scheme, i.e. validates the codec parameters, writes the header. 820 * 821 * @param p_j2k the jpeg2000 codec. 822 * @param p_stream the stream object. 823 * @param p_image FIXME DOC 824 * @param p_manager the user event manager. 825 * 826 * @return true if the codec is valid. 827 */ 828 OPJ_BOOL opj_j2k_start_compress(opj_j2k_t *p_j2k, 829 opj_stream_private_t *p_stream, 830 opj_image_t * p_image, 831 opj_event_mgr_t * p_manager); 832 833 /** 834 * Ends the compression procedures and possibiliy add data to be read after the 835 * codestream. 836 */ 837 OPJ_BOOL opj_j2k_end_compress( opj_j2k_t *p_j2k, 838 opj_stream_private_t *cio, 839 opj_event_mgr_t * p_manager); 840 841 OPJ_BOOL opj_j2k_setup_mct_encoding (opj_tcp_t * p_tcp, opj_image_t * p_image); 842 843 844 #endif /* __J2K_H */ 845