xref: /aosp_15_r20/external/pdfium/third_party/libopenjpeg/j2k.h (revision 3ac0a46f773bac49fa9476ec2b1cf3f8da5ec3a4)
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 p_j2k->cp.
625  @param p_j2k J2K decompressor handle
626  @param parameters decompression parameters
627  */
628  void opj_j2k_setup_decoder(void *p_j2k, opj_dparameters_t *parameters);
629  
630  void opj_j2k_decoder_set_strict_mode(void *j2k, OPJ_BOOL strict);
631  
632  OPJ_BOOL opj_j2k_set_threads(void *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(void *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(void *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 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                               void* 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   j2k   the jpeg20000 structure to destroy.
685   */
686  void opj_j2k_destroy(void *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   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(void * 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   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(void * 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 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(void *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   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(void *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 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(void* 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    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(void* j2k);
820  
821  /**
822   * Get the codestream index from a JPEG2000 codec.
823   *
824   *@param    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(void* 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(void *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(void *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(void *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  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      void *j2k,
865      const char* const* p_options,
866      opj_event_mgr_t * p_manager);
867  
868  /**
869   * Writes a tile.
870   * @param   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(void * 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(void * 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   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(void *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(void *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