b1e1c294c8f4ef3cc3b7a5cdf7d18e01c67eee35
[pdfium.git] / core / src / fxcodec / fx_libopenjpeg / libopenjpeg20 / openjpeg.h
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) 2010-2011, Kaori Hagihara
17  * Copyright (c) 2011-2012, Centre National d'Etudes Spatiales (CNES), France 
18  * Copyright (c) 2012, CS Systemes d'Information, France
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 OPENJPEG_H
43 #define OPENJPEG_H
44
45
46 /* 
47 ==========================================================
48    Compiler directives
49 ==========================================================
50 */
51
52 /*
53 The inline keyword is supported by C99 but not by C90. 
54 Most compilers implement their own version of this keyword ... 
55 */
56 #ifndef INLINE
57         #if defined(_MSC_VER)
58                 #define INLINE __forceinline
59         #elif defined(__GNUC__)
60                 #define INLINE __inline__
61         #elif defined(__MWERKS__)
62                 #define INLINE inline
63         #else 
64                 /* add other compilers here ... */
65                 #define INLINE 
66         #endif /* defined(<Compiler>) */
67 #endif /* INLINE */
68
69 /* deprecated attribute */
70 #ifdef __GNUC__
71         #define OPJ_DEPRECATED(func) func __attribute__ ((deprecated))
72 #elif defined(_MSC_VER)
73         #define OPJ_DEPRECATED(func) __declspec(deprecated) func
74 #else
75         #pragma message("WARNING: You need to implement DEPRECATED for this compiler")
76         #define OPJ_DEPRECATED(func) func
77 #endif
78
79 // PDFium doesn't need to export any of these methods.
80 #define OPJ_API
81 #define OPJ_LOCAL
82 #define OPJ_CALLCONV
83
84 typedef int OPJ_BOOL;
85 #define OPJ_TRUE 1
86 #define OPJ_FALSE 0
87
88 typedef char          OPJ_CHAR;
89 typedef float         OPJ_FLOAT32;
90 typedef double        OPJ_FLOAT64;
91 typedef unsigned char OPJ_BYTE;
92
93 #include "opj_stdint.h"
94
95 typedef int8_t   OPJ_INT8;
96 typedef uint8_t  OPJ_UINT8;
97 typedef int16_t  OPJ_INT16;
98 typedef uint16_t OPJ_UINT16;
99 typedef int32_t  OPJ_INT32;
100 typedef uint32_t OPJ_UINT32;
101 typedef int64_t  OPJ_INT64;
102 typedef uint64_t OPJ_UINT64;
103
104 typedef int64_t  OPJ_OFF_T; /* 64-bit file offset type */
105
106 #include <stdio.h>
107 typedef size_t   OPJ_SIZE_T;
108
109 /* Avoid compile-time warning because parameter is not used */
110 #define OPJ_ARG_NOT_USED(x) (void)(x)
111
112 /* 
113 ==========================================================
114    Useful constant definitions
115 ==========================================================
116 */
117
118 #define OPJ_PATH_LEN 4096 /**< Maximum allowed size for filenames */
119
120 #define OPJ_J2K_MAXRLVLS 33                                     /**< Number of maximum resolution level authorized */
121 #define OPJ_J2K_MAXBANDS (3*OPJ_J2K_MAXRLVLS-2) /**< Number of maximum sub-band linked to number of resolution level */
122
123 #define OPJ_J2K_DEFAULT_NB_SEGS                         10
124 #define OPJ_J2K_STREAM_CHUNK_SIZE                       0x100000 /** 1 mega by default */
125 #define OPJ_J2K_DEFAULT_HEADER_SIZE                     1000
126 #define OPJ_J2K_MCC_DEFAULT_NB_RECORDS          10
127 #define OPJ_J2K_MCT_DEFAULT_NB_RECORDS          10
128
129 /* UniPG>> */ /* NOT YET USED IN THE V2 VERSION OF OPENJPEG */
130 #define JPWL_MAX_NO_TILESPECS   16 /**< Maximum number of tile parts expected by JPWL: increase at your will */
131 #define JPWL_MAX_NO_PACKSPECS   16 /**< Maximum number of packet parts expected by JPWL: increase at your will */
132 #define JPWL_MAX_NO_MARKERS     512 /**< Maximum number of JPWL markers: increase at your will */
133 #define JPWL_PRIVATEINDEX_NAME "jpwl_index_privatefilename" /**< index file name used when JPWL is on */
134 #define JPWL_EXPECTED_COMPONENTS 3 /**< Expect this number of components, so you'll find better the first EPB */
135 #define JPWL_MAXIMUM_TILES 8192 /**< Expect this maximum number of tiles, to avoid some crashes */
136 #define JPWL_MAXIMUM_HAMMING 2 /**< Expect this maximum number of bit errors in marker id's */
137 #define JPWL_MAXIMUM_EPB_ROOM 65450 /**< Expect this maximum number of bytes for composition of EPBs */
138 /* <<UniPG */
139
140 /**
141  * EXPERIMENTAL FOR THE MOMENT
142  * Supported options about file information used only in j2k_dump
143 */
144 #define OPJ_IMG_INFO            1       /**< Basic image information provided to the user */
145 #define OPJ_J2K_MH_INFO         2       /**< Codestream information based only on the main header */
146 #define OPJ_J2K_TH_INFO         4       /**< Tile information based on the current tile header */
147 #define OPJ_J2K_TCH_INFO        8       /**< Tile/Component information of all tiles */
148 #define OPJ_J2K_MH_IND          16      /**< Codestream index based only on the main header */
149 #define OPJ_J2K_TH_IND          32      /**< Tile index based on the current tile */
150 /*FIXME #define OPJ_J2K_CSTR_IND        48*/    /**<  */
151 #define OPJ_JP2_INFO            128     /**< JP2 file information */
152 #define OPJ_JP2_IND                     256     /**< JP2 file index */
153
154 /**
155  * JPEG 2000 Profiles, see Table A.10 from 15444-1 (updated in various AMD)
156  * These values help chosing the RSIZ value for the J2K codestream.
157  * The RSIZ value triggers various encoding options, as detailed in Table A.10.
158  * If OPJ_PROFILE_PART2 is chosen, it has to be combined with one or more extensions
159  * described hereunder.
160  *   Example: rsiz = OPJ_PROFILE_PART2 | OPJ_EXTENSION_MCT;
161  * For broadcast profiles, the OPJ_PROFILE value has to be combined with the targeted
162  * mainlevel (3-0 LSB, value between 0 and 11):
163  *   Example: rsiz = OPJ_PROFILE_BC_MULTI | 0x0005; (here mainlevel 5)
164  * For IMF profiles, the OPJ_PROFILE value has to be combined with the targeted mainlevel
165  * (3-0 LSB, value between 0 and 11) and sublevel (7-4 LSB, value between 0 and 9):
166  *   Example: rsiz = OPJ_PROFILE_IMF_2K | 0x0040 | 0x0005; (here main 5 and sublevel 4)
167  * */
168 #define OPJ_PROFILE_NONE        0x0000 /** no profile, conform to 15444-1 */
169 #define OPJ_PROFILE_0           0x0001 /** Profile 0 as described in 15444-1,Table A.45 */
170 #define OPJ_PROFILE_1           0x0002 /** Profile 1 as described in 15444-1,Table A.45 */
171 #define OPJ_PROFILE_PART2       0x8000 /** At least 1 extension defined in 15444-2 (Part-2) */
172 #define OPJ_PROFILE_CINEMA_2K   0x0003 /** 2K cinema profile defined in 15444-1 AMD1 */
173 #define OPJ_PROFILE_CINEMA_4K   0x0004 /** 4K cinema profile defined in 15444-1 AMD1 */
174 #define OPJ_PROFILE_CINEMA_S2K  0x0005 /** Scalable 2K cinema profile defined in 15444-1 AMD2 */
175 #define OPJ_PROFILE_CINEMA_S4K  0x0006 /** Scalable 4K cinema profile defined in 15444-1 AMD2 */
176 #define OPJ_PROFILE_CINEMA_LTS  0x0007 /** Long term storage cinema profile defined in 15444-1 AMD2 */
177 #define OPJ_PROFILE_BC_SINGLE   0x0100 /** Single Tile Broadcast profile defined in 15444-1 AMD3 */
178 #define OPJ_PROFILE_BC_MULTI    0x0200 /** Multi Tile Broadcast profile defined in 15444-1 AMD3 */
179 #define OPJ_PROFILE_BC_MULTI_R  0x0300 /** Multi Tile Reversible Broadcast profile defined in 15444-1 AMD3 */
180 #define OPJ_PROFILE_IMF_2K      0x0400 /** 2K Single Tile Lossy IMF profile defined in 15444-1 AMD 8 */
181 #define OPJ_PROFILE_IMF_4K      0x0401 /** 4K Single Tile Lossy IMF profile defined in 15444-1 AMD 8 */
182 #define OPJ_PROFILE_IMF_8K      0x0402 /** 8K Single Tile Lossy IMF profile defined in 15444-1 AMD 8 */
183 #define OPJ_PROFILE_IMF_2K_R    0x0403 /** 2K Single/Multi Tile Reversible IMF profile defined in 15444-1 AMD 8 */
184 #define OPJ_PROFILE_IMF_4K_R    0x0800 /** 4K Single/Multi Tile Reversible IMF profile defined in 15444-1 AMD 8 */
185 #define OPJ_PROFILE_IMF_8K_R    0x0801  /** 8K Single/Multi Tile Reversible IMF profile defined in 15444-1 AMD 8 */
186
187 /**
188  * JPEG 2000 Part-2 extensions
189  * */
190 #define OPJ_EXTENSION_NONE      0x0000 /** No Part-2 extension */
191 #define OPJ_EXTENSION_MCT       0x0100  /** Custom MCT support */
192
193 /**
194  * JPEG 2000 profile macros
195  * */
196 #define OPJ_IS_CINEMA(v)     (((v) >= OPJ_PROFILE_CINEMA_2K)&&((v) <= OPJ_PROFILE_CINEMA_S4K))
197 #define OPJ_IS_STORAGE(v)    ((v) == OPJ_PROFILE_CINEMA_LTS)
198 #define OPJ_IS_BROADCAST(v)  (((v) >= OPJ_PROFILE_BC_SINGLE)&&((v) <= ((OPJ_PROFILE_BC_MULTI_R) | (0x000b))))
199 #define OPJ_IS_IMF(v)        (((v) >= OPJ_PROFILE_IMF_2K)&&((v) <= ((OPJ_PROFILE_IMF_8K_R) | (0x009b))))
200 #define OPJ_IS_PART2(v)      ((v) & OPJ_PROFILE_PART2)
201
202 /**
203  * JPEG 2000 codestream and component size limits in cinema profiles
204  * */
205 #define OPJ_CINEMA_24_CS     1302083    /** Maximum codestream length for 24fps */
206 #define OPJ_CINEMA_48_CS     651041     /** Maximum codestream length for 48fps */
207 #define OPJ_CINEMA_24_COMP   1041666    /** Maximum size per color component for 2K & 4K @ 24fps */
208 #define OPJ_CINEMA_48_COMP   520833             /** Maximum size per color component for 2K @ 48fps */
209
210 /* 
211 ==========================================================
212    enum definitions
213 ==========================================================
214 */
215
216 /**
217  * DEPRECATED: use RSIZ, OPJ_PROFILE_* and OPJ_EXTENSION_* instead
218  * Rsiz Capabilities
219  * */
220 typedef enum RSIZ_CAPABILITIES {
221     OPJ_STD_RSIZ = 0,           /** Standard JPEG2000 profile*/
222     OPJ_CINEMA2K = 3,           /** Profile name for a 2K image*/
223     OPJ_CINEMA4K = 4,           /** Profile name for a 4K image*/
224     OPJ_MCT = 0x8100
225 } OPJ_RSIZ_CAPABILITIES;
226
227 /**
228  * DEPRECATED: use RSIZ, OPJ_PROFILE_* and OPJ_EXTENSION_* instead
229  * Digital cinema operation mode
230  * */
231 typedef enum CINEMA_MODE {
232     OPJ_OFF = 0,                        /** Not Digital Cinema*/
233     OPJ_CINEMA2K_24 = 1,        /** 2K Digital Cinema at 24 fps*/
234     OPJ_CINEMA2K_48 = 2,        /** 2K Digital Cinema at 48 fps*/
235     OPJ_CINEMA4K_24 = 3         /** 4K Digital Cinema at 24 fps*/
236 }OPJ_CINEMA_MODE;
237
238 /** 
239  * Progression order
240  * */
241 typedef enum PROG_ORDER {
242         OPJ_PROG_UNKNOWN = -1,  /**< place-holder */
243         OPJ_LRCP = 0,                   /**< layer-resolution-component-precinct order */
244         OPJ_RLCP = 1,                   /**< resolution-layer-component-precinct order */
245         OPJ_RPCL = 2,                   /**< resolution-precinct-component-layer order */
246         OPJ_PCRL = 3,                   /**< precinct-component-resolution-layer order */
247         OPJ_CPRL = 4                    /**< component-precinct-resolution-layer order */
248 } OPJ_PROG_ORDER;
249
250 /**
251  * Supported image color spaces
252 */
253 typedef enum COLOR_SPACE {
254     OPJ_CLRSPC_UNKNOWN = -1,    /**< not supported by the library */
255     OPJ_CLRSPC_UNSPECIFIED = 0, /**< not specified in the codestream */
256     OPJ_CLRSPC_SRGB = 1,                /**< sRGB */
257     OPJ_CLRSPC_GRAY = 2,                /**< grayscale */
258     OPJ_CLRSPC_SYCC = 3,                /**< YUV */
259     OPJ_CLRSPC_EYCC = 4,        /**< e-YCC */
260     OPJ_CLRSPC_CMYK = 5         /**< CMYK */
261 } OPJ_COLOR_SPACE;
262
263 /**
264  * Supported codec
265 */
266 typedef enum CODEC_FORMAT {
267         OPJ_CODEC_UNKNOWN = -1, /**< place-holder */
268         OPJ_CODEC_J2K  = 0,             /**< JPEG-2000 codestream : read/write */
269         OPJ_CODEC_JPT  = 1,             /**< JPT-stream (JPEG 2000, JPIP) : read only */
270     OPJ_CODEC_JP2  = 2,         /**< JP2 file format : read/write */
271     OPJ_CODEC_JPP  = 3,         /**< JPP-stream (JPEG 2000, JPIP) : to be coded */
272     OPJ_CODEC_JPX  = 4          /**< JPX file format (JPEG 2000 Part-2) : to be coded */
273 } OPJ_CODEC_FORMAT;
274
275
276 /* 
277 ==========================================================
278    event manager typedef definitions
279 ==========================================================
280 */
281
282 /**
283  * Callback function prototype for events
284  * @param msg               Event message
285  * @param client_data       Client object where will be return the event message 
286  * */
287 typedef void (*opj_msg_callback) (const char *msg, void *client_data);
288
289 /* 
290 ==========================================================
291    codec typedef definitions
292 ==========================================================
293 */
294
295 /**
296  * Progression order changes
297  * 
298  */
299 typedef struct opj_poc {
300         /** Resolution num start, Component num start, given by POC */
301         OPJ_UINT32 resno0, compno0;
302         /** Layer num end,Resolution num end, Component num end, given by POC */
303         OPJ_UINT32 layno1, resno1, compno1;
304         /** Layer num start,Precinct num start, Precinct num end */
305         OPJ_UINT32 layno0, precno0, precno1;
306         /** Progression order enum*/
307         OPJ_PROG_ORDER prg1,prg;
308         /** Progression order string*/
309         OPJ_CHAR progorder[5];
310         /** Tile number */
311         OPJ_UINT32 tile;
312         /** Start and end values for Tile width and height*/
313         OPJ_INT32 tx0,tx1,ty0,ty1;
314         /** Start value, initialised in pi_initialise_encode*/
315         OPJ_UINT32 layS, resS, compS, prcS;
316         /** End value, initialised in pi_initialise_encode */
317         OPJ_UINT32 layE, resE, compE, prcE;
318         /** Start and end values of Tile width and height, initialised in pi_initialise_encode*/
319         OPJ_UINT32 txS,txE,tyS,tyE,dx,dy;
320         /** Temporary values for Tile parts, initialised in pi_create_encode */
321         OPJ_UINT32 lay_t, res_t, comp_t, prc_t,tx0_t,ty0_t;
322 } opj_poc_t;
323
324 /**
325  * Compression parameters
326  * */
327 typedef struct opj_cparameters {
328         /** size of tile: tile_size_on = false (not in argument) or = true (in argument) */
329         OPJ_BOOL tile_size_on;
330         /** XTOsiz */
331         int cp_tx0;
332         /** YTOsiz */
333         int cp_ty0;
334         /** XTsiz */
335         int cp_tdx;
336         /** YTsiz */
337         int cp_tdy;
338         /** allocation by rate/distortion */
339         int cp_disto_alloc;
340         /** allocation by fixed layer */
341         int cp_fixed_alloc;
342         /** add fixed_quality */
343         int cp_fixed_quality;
344         /** fixed layer */
345         int *cp_matrice;
346         /** comment for coding */
347         char *cp_comment;
348         /** csty : coding style */
349         int csty;
350         /** progression order (default OPJ_LRCP) */
351         OPJ_PROG_ORDER prog_order;
352         /** progression order changes */
353         opj_poc_t POC[32];
354         /** number of progression order changes (POC), default to 0 */
355         OPJ_UINT32 numpocs;
356         /** number of layers */
357         int tcp_numlayers;
358     /** rates of layers - might be subsequently limited by the max_cs_size field */
359         float tcp_rates[100];
360         /** different psnr for successive layers */
361         float tcp_distoratio[100];
362         /** number of resolutions */
363         int numresolution;
364         /** initial code block width, default to 64 */
365         int cblockw_init;
366         /** initial code block height, default to 64 */
367         int cblockh_init;
368         /** mode switch (cblk_style) */
369         int mode;
370         /** 1 : use the irreversible DWT 9-7, 0 : use lossless compression (default) */
371         int irreversible;
372         /** region of interest: affected component in [0..3], -1 means no ROI */
373         int roi_compno;
374         /** region of interest: upshift value */
375         int roi_shift;
376         /* number of precinct size specifications */
377         int res_spec;
378         /** initial precinct width */
379         int prcw_init[OPJ_J2K_MAXRLVLS];
380         /** initial precinct height */
381         int prch_init[OPJ_J2K_MAXRLVLS];
382
383         /**@name command line encoder parameters (not used inside the library) */
384         /*@{*/
385         /** input file name */
386         char infile[OPJ_PATH_LEN];
387         /** output file name */
388         char outfile[OPJ_PATH_LEN];
389         /** DEPRECATED. Index generation is now handeld with the opj_encode_with_info() function. Set to NULL */
390         int index_on;
391         /** DEPRECATED. Index generation is now handeld with the opj_encode_with_info() function. Set to NULL */
392         char index[OPJ_PATH_LEN];
393         /** subimage encoding: origin image offset in x direction */
394         int image_offset_x0;
395         /** subimage encoding: origin image offset in y direction */
396         int image_offset_y0;
397         /** subsampling value for dx */
398         int subsampling_dx;
399         /** subsampling value for dy */
400         int subsampling_dy;
401         /** input file format 0: PGX, 1: PxM, 2: BMP 3:TIF*/
402         int decod_format;
403         /** output file format 0: J2K, 1: JP2, 2: JPT */
404         int cod_format;
405         /*@}*/
406
407 /* UniPG>> */ /* NOT YET USED IN THE V2 VERSION OF OPENJPEG */
408         /**@name JPWL encoding parameters */
409         /*@{*/
410         /** enables writing of EPC in MH, thus activating JPWL */
411         OPJ_BOOL jpwl_epc_on;
412         /** error protection method for MH (0,1,16,32,37-128) */
413         int jpwl_hprot_MH;
414         /** tile number of header protection specification (>=0) */
415         int jpwl_hprot_TPH_tileno[JPWL_MAX_NO_TILESPECS];
416         /** error protection methods for TPHs (0,1,16,32,37-128) */
417         int jpwl_hprot_TPH[JPWL_MAX_NO_TILESPECS];
418         /** tile number of packet protection specification (>=0) */
419         int jpwl_pprot_tileno[JPWL_MAX_NO_PACKSPECS];
420         /** packet number of packet protection specification (>=0) */
421         int jpwl_pprot_packno[JPWL_MAX_NO_PACKSPECS];
422         /** error protection methods for packets (0,1,16,32,37-128) */
423         int jpwl_pprot[JPWL_MAX_NO_PACKSPECS];
424         /** enables writing of ESD, (0=no/1/2 bytes) */
425         int jpwl_sens_size;
426         /** sensitivity addressing size (0=auto/2/4 bytes) */
427         int jpwl_sens_addr;
428         /** sensitivity range (0-3) */
429         int jpwl_sens_range;
430         /** sensitivity method for MH (-1=no,0-7) */
431         int jpwl_sens_MH;
432         /** tile number of sensitivity specification (>=0) */
433         int jpwl_sens_TPH_tileno[JPWL_MAX_NO_TILESPECS];
434         /** sensitivity methods for TPHs (-1=no,0-7) */
435         int jpwl_sens_TPH[JPWL_MAX_NO_TILESPECS];
436         /*@}*/
437 /* <<UniPG */
438
439     /**
440      * DEPRECATED: use RSIZ, OPJ_PROFILE_* and MAX_COMP_SIZE instead
441      * Digital Cinema compliance 0-not compliant, 1-compliant
442      * */
443     OPJ_CINEMA_MODE cp_cinema;
444     /**
445      * Maximum size (in bytes) for each component.
446      * If == 0, component size limitation is not considered
447      * */
448         int max_comp_size;
449     /**
450      * DEPRECATED: use RSIZ, OPJ_PROFILE_* and OPJ_EXTENSION_* instead
451      * Profile name
452      * */
453     OPJ_RSIZ_CAPABILITIES cp_rsiz;
454         /** Tile part generation*/
455         char tp_on;
456         /** Flag for Tile part generation*/
457         char tp_flag;
458         /** MCT (multiple component transform) */
459         char tcp_mct;
460         /** Enable JPIP indexing*/
461         OPJ_BOOL jpip_on;
462         /** Naive implementation of MCT restricted to a single reversible array based 
463         encoding without offset concerning all the components. */
464         void * mct_data;
465     /**
466      * Maximum size (in bytes) for the whole codestream.
467      * If == 0, codestream size limitation is not considered
468      * If it does not comply with tcp_rates, max_cs_size prevails
469      * and a warning is issued.
470      * */
471     int max_cs_size;
472     /** RSIZ value
473         To be used to combine OPJ_PROFILE_*, OPJ_EXTENSION_* and (sub)levels values. */
474     OPJ_UINT16 rsiz;
475 } opj_cparameters_t;  
476
477 #define OPJ_DPARAMETERS_IGNORE_PCLR_CMAP_CDEF_FLAG      0x0001
478
479 /**
480  * Decompression parameters
481  * */
482 typedef struct opj_dparameters {
483         /** 
484         Set the number of highest resolution levels to be discarded. 
485         The image resolution is effectively divided by 2 to the power of the number of discarded levels. 
486         The reduce factor is limited by the smallest total number of decomposition levels among tiles.
487         if != 0, then original dimension divided by 2^(reduce); 
488         if == 0 or not used, image is decoded to the full resolution 
489         */
490         OPJ_UINT32 cp_reduce;
491         /** 
492         Set the maximum number of quality layers to decode. 
493         If there are less quality layers than the specified number, all the quality layers are decoded.
494         if != 0, then only the first "layer" layers are decoded; 
495         if == 0 or not used, all the quality layers are decoded 
496         */
497         OPJ_UINT32 cp_layer;
498
499         /**@name command line decoder parameters (not used inside the library) */
500         /*@{*/
501         /** input file name */
502         char infile[OPJ_PATH_LEN];
503         /** output file name */
504         char outfile[OPJ_PATH_LEN];
505         /** input file format 0: J2K, 1: JP2, 2: JPT */
506         int decod_format;
507         /** output file format 0: PGX, 1: PxM, 2: BMP */
508         int cod_format;
509
510         /** Decoding area left boundary */
511         OPJ_UINT32 DA_x0;
512         /** Decoding area right boundary */
513         OPJ_UINT32 DA_x1;
514         /** Decoding area up boundary */
515         OPJ_UINT32 DA_y0;
516         /** Decoding area bottom boundary */
517         OPJ_UINT32 DA_y1;
518         /** Verbose mode */
519         OPJ_BOOL m_verbose;
520
521         /** tile number ot the decoded tile*/
522         OPJ_UINT32 tile_index;
523         /** Nb of tile to decode */
524         OPJ_UINT32 nb_tile_to_decode;
525
526         /*@}*/
527
528 /* UniPG>> */ /* NOT YET USED IN THE V2 VERSION OF OPENJPEG */
529         /**@name JPWL decoding parameters */
530         /*@{*/
531         /** activates the JPWL correction capabilities */
532         OPJ_BOOL jpwl_correct;
533         /** expected number of components */
534         int jpwl_exp_comps;
535         /** maximum number of tiles */
536         int jpwl_max_tiles;
537         /*@}*/
538 /* <<UniPG */
539
540         unsigned int flags;
541
542 } opj_dparameters_t;
543
544
545 /**
546  * JPEG2000 codec V2.
547  * */
548 typedef void * opj_codec_t;
549
550 /* 
551 ==========================================================
552    I/O stream typedef definitions
553 ==========================================================
554 */
555
556 /**
557  * Stream open flags.
558  * */
559 /** The stream was opened for reading. */
560 #define OPJ_STREAM_READ OPJ_TRUE
561 /** The stream was opened for writing. */
562 #define OPJ_STREAM_WRITE OPJ_FALSE
563
564 /*
565  * Callback function prototype for read function
566  */
567 typedef OPJ_SIZE_T (* opj_stream_read_fn) (void * p_buffer, OPJ_SIZE_T p_nb_bytes, void * p_user_data) ;
568
569 /*
570  * Callback function prototype for write function
571  */
572 typedef OPJ_SIZE_T (* opj_stream_write_fn) (void * p_buffer, OPJ_SIZE_T p_nb_bytes, void * p_user_data) ;
573
574 /*
575  * Callback function prototype for skip function
576  */
577 typedef OPJ_OFF_T (* opj_stream_skip_fn) (OPJ_OFF_T p_nb_bytes, void * p_user_data) ;
578
579 /*
580  * Callback function prototype for seek function
581  */
582 typedef OPJ_BOOL (* opj_stream_seek_fn) (OPJ_OFF_T p_nb_bytes, void * p_user_data) ;
583
584 /*
585  * Callback function prototype for free user data function
586  */
587 typedef void (* opj_stream_free_user_data_fn) (void * p_user_data) ;
588
589 /*
590  * JPEG2000 Stream.
591  */
592 typedef void * opj_stream_t;
593
594 /* 
595 ==========================================================
596    image typedef definitions
597 ==========================================================
598 */
599
600 /**
601  * Defines a single image component
602  * */
603 typedef struct opj_image_comp {
604         /** XRsiz: horizontal separation of a sample of ith component with respect to the reference grid */
605         OPJ_UINT32 dx;
606         /** YRsiz: vertical separation of a sample of ith component with respect to the reference grid */
607         OPJ_UINT32 dy;
608         /** data width */
609         OPJ_UINT32 w;
610         /** data height */
611         OPJ_UINT32 h;
612         /** x component offset compared to the whole image */
613         OPJ_UINT32 x0;
614         /** y component offset compared to the whole image */
615         OPJ_UINT32 y0;
616         /** precision */
617         OPJ_UINT32 prec;
618         /** image depth in bits */
619         OPJ_UINT32 bpp;
620         /** signed (1) / unsigned (0) */
621         OPJ_UINT32 sgnd;
622         /** number of decoded resolution */
623         OPJ_UINT32 resno_decoded;
624         /** number of division by 2 of the out image compared to the original size of image */
625         OPJ_UINT32 factor;
626         /** image component data */
627         OPJ_INT32 *data;
628   /** alpha channel */
629   OPJ_UINT16 alpha;
630 } opj_image_comp_t;
631
632 /** 
633  * Defines image data and characteristics
634  * */
635 typedef struct opj_image {
636         /** XOsiz: horizontal offset from the origin of the reference grid to the left side of the image area */
637         OPJ_UINT32 x0;
638         /** YOsiz: vertical offset from the origin of the reference grid to the top side of the image area */
639         OPJ_UINT32 y0;
640         /** Xsiz: width of the reference grid */
641         OPJ_UINT32 x1;
642         /** Ysiz: height of the reference grid */
643         OPJ_UINT32 y1;
644         /** number of components in the image */
645         OPJ_UINT32 numcomps;
646         /** color space: sRGB, Greyscale or YUV */
647         OPJ_COLOR_SPACE color_space;
648         /** image components */
649         opj_image_comp_t *comps;
650         /** 'restricted' ICC profile */
651         OPJ_BYTE *icc_profile_buf;
652         /** size of ICC profile */
653         OPJ_UINT32 icc_profile_len;
654 } opj_image_t;
655
656
657 /**
658  * Component parameters structure used by the opj_image_create function
659  * */
660 typedef struct opj_image_comptparm {
661         /** XRsiz: horizontal separation of a sample of ith component with respect to the reference grid */
662         OPJ_UINT32 dx;
663         /** YRsiz: vertical separation of a sample of ith component with respect to the reference grid */
664         OPJ_UINT32 dy;
665         /** data width */
666         OPJ_UINT32 w;
667         /** data height */
668         OPJ_UINT32 h;
669         /** x component offset compared to the whole image */
670         OPJ_UINT32 x0;
671         /** y component offset compared to the whole image */
672         OPJ_UINT32 y0;
673         /** precision */
674         OPJ_UINT32 prec;
675         /** image depth in bits */
676         OPJ_UINT32 bpp;
677         /** signed (1) / unsigned (0) */
678         OPJ_UINT32 sgnd;
679 } opj_image_cmptparm_t;
680
681
682 /* 
683 ==========================================================
684    Information on the JPEG 2000 codestream
685 ==========================================================
686 */
687 /* QUITE EXPERIMENTAL FOR THE MOMENT */
688
689 /**
690  * Index structure : Information concerning a packet inside tile
691  * */
692 typedef struct opj_packet_info {
693         /** packet start position (including SOP marker if it exists) */
694         OPJ_OFF_T start_pos;
695         /** end of packet header position (including EPH marker if it exists)*/
696         OPJ_OFF_T end_ph_pos;
697         /** packet end position */
698         OPJ_OFF_T end_pos;
699         /** packet distorsion */
700         double disto;
701 } opj_packet_info_t;
702
703
704 /* UniPG>> */
705 /**
706  * Marker structure
707  * */
708 typedef struct opj_marker_info {
709         /** marker type */
710         unsigned short int type;
711         /** position in codestream */
712         OPJ_OFF_T pos;
713         /** length, marker val included */
714         int len;
715 } opj_marker_info_t;
716 /* <<UniPG */
717
718 /**
719  * Index structure : Information concerning tile-parts
720 */
721 typedef struct opj_tp_info {
722         /** start position of tile part */
723         int tp_start_pos;
724         /** end position of tile part header */
725         int tp_end_header;
726         /** end position of tile part */
727         int tp_end_pos;
728         /** start packet of tile part */
729         int tp_start_pack;
730         /** number of packets of tile part */
731         int tp_numpacks;
732 } opj_tp_info_t;
733
734 /**
735  * Index structure : information regarding tiles
736 */
737 typedef struct opj_tile_info {
738         /** value of thresh for each layer by tile cfr. Marcela   */
739         double *thresh;
740         /** number of tile */
741         int tileno;
742         /** start position */
743         int start_pos;
744         /** end position of the header */
745         int end_header;
746         /** end position */
747         int end_pos;
748         /** precinct number for each resolution level (width) */
749         int pw[33];
750         /** precinct number for each resolution level (height) */
751         int ph[33];
752         /** precinct size (in power of 2), in X for each resolution level */
753         int pdx[33];
754         /** precinct size (in power of 2), in Y for each resolution level */
755         int pdy[33];
756         /** information concerning packets inside tile */
757         opj_packet_info_t *packet;
758         /** add fixed_quality */
759         int numpix;
760         /** add fixed_quality */
761         double distotile;
762         /** number of markers */
763         int marknum;
764         /** list of markers */
765         opj_marker_info_t *marker;
766         /** actual size of markers array */
767         int maxmarknum;
768         /** number of tile parts */
769         int num_tps;
770         /** information concerning tile parts */
771         opj_tp_info_t *tp;
772 } opj_tile_info_t;
773
774 /**
775  * Index structure of the codestream
776 */
777 typedef struct opj_codestream_info {
778         /** maximum distortion reduction on the whole image (add for Marcela) */
779         double D_max;
780         /** packet number */
781         int packno;
782         /** writing the packet in the index with t2_encode_packets */
783         int index_write;
784         /** image width */
785         int image_w;
786         /** image height */
787         int image_h;
788         /** progression order */
789         OPJ_PROG_ORDER prog;
790         /** tile size in x */
791         int tile_x;
792         /** tile size in y */
793         int tile_y;
794         /** */
795         int tile_Ox;
796         /** */
797         int tile_Oy;
798         /** number of tiles in X */
799         int tw;
800         /** number of tiles in Y */
801         int th;
802         /** component numbers */
803         int numcomps;
804         /** number of layer */
805         int numlayers;
806         /** number of decomposition for each component */
807         int *numdecompos;
808 /* UniPG>> */
809         /** number of markers */
810         int marknum;
811         /** list of markers */
812         opj_marker_info_t *marker;
813         /** actual size of markers array */
814         int maxmarknum;
815 /* <<UniPG */
816         /** main header position */
817         int main_head_start;
818         /** main header position */
819         int main_head_end;
820         /** codestream's size */
821         int codestream_size;
822         /** information regarding tiles inside image */
823         opj_tile_info_t *tile;
824 } opj_codestream_info_t;
825
826 /* <----------------------------------------------------------- */
827 /* new output managment of the codestream information and index */
828
829 /**
830  * Tile-component coding parameters information
831  */
832 typedef struct opj_tccp_info
833 {
834         /** component index */
835         OPJ_UINT32 compno;
836         /** coding style */
837         OPJ_UINT32 csty;
838         /** number of resolutions */
839         OPJ_UINT32 numresolutions;
840         /** code-blocks width */
841         OPJ_UINT32 cblkw;
842         /** code-blocks height */
843         OPJ_UINT32 cblkh;
844         /** code-block coding style */
845         OPJ_UINT32 cblksty;
846         /** discrete wavelet transform identifier */
847         OPJ_UINT32 qmfbid;
848         /** quantisation style */
849         OPJ_UINT32 qntsty;
850         /** stepsizes used for quantization */
851         OPJ_UINT32 stepsizes_mant[OPJ_J2K_MAXBANDS];
852         /** stepsizes used for quantization */
853         OPJ_UINT32 stepsizes_expn[OPJ_J2K_MAXBANDS];
854         /** number of guard bits */
855         OPJ_UINT32 numgbits;
856         /** Region Of Interest shift */
857         OPJ_INT32 roishift;
858         /** precinct width */
859         OPJ_UINT32 prcw[OPJ_J2K_MAXRLVLS];
860         /** precinct height */
861         OPJ_UINT32 prch[OPJ_J2K_MAXRLVLS];
862 }
863 opj_tccp_info_t;
864
865 /**
866  * Tile coding parameters information
867  */
868 typedef struct opj_tile_v2_info {
869
870         /** number (index) of tile */
871         int tileno;
872         /** coding style */
873         OPJ_UINT32 csty;
874         /** progression order */
875         OPJ_PROG_ORDER prg;
876         /** number of layers */
877         OPJ_UINT32 numlayers;
878         /** multi-component transform identifier */
879         OPJ_UINT32 mct;
880
881         /** information concerning tile component parameters*/
882         opj_tccp_info_t *tccp_info;
883
884 } opj_tile_info_v2_t;
885
886 /**
887  * Information structure about the codestream (FIXME should be expand and enhance)
888  */
889 typedef struct opj_codestream_info_v2 {
890         /* Tile info */
891         /** tile origin in x = XTOsiz */
892         OPJ_UINT32 tx0;
893         /** tile origin in y = YTOsiz */
894         OPJ_UINT32 ty0;
895         /** tile size in x = XTsiz */
896         OPJ_UINT32 tdx;
897         /** tile size in y = YTsiz */
898         OPJ_UINT32 tdy;
899         /** number of tiles in X */
900         OPJ_UINT32 tw;
901         /** number of tiles in Y */
902         OPJ_UINT32 th;
903
904         /** number of components*/
905         OPJ_UINT32 nbcomps;
906
907         /** Default information regarding tiles inside image */
908         opj_tile_info_v2_t m_default_tile_info;
909
910         /** information regarding tiles inside image */
911         opj_tile_info_v2_t *tile_info; /* FIXME not used for the moment */
912
913 } opj_codestream_info_v2_t;
914
915
916 /**
917  * Index structure about a tile part
918  */
919 typedef struct opj_tp_index {
920         /** start position */
921         OPJ_OFF_T start_pos;
922         /** end position of the header */
923         OPJ_OFF_T end_header;
924         /** end position */
925         OPJ_OFF_T end_pos;
926
927 } opj_tp_index_t;
928
929 /**
930  * Index structure about a tile
931  */
932 typedef struct opj_tile_index {
933         /** tile index */
934         OPJ_UINT32 tileno;
935
936         /** number of tile parts */
937         OPJ_UINT32 nb_tps;
938         /** current nb of tile part (allocated)*/
939         OPJ_UINT32 current_nb_tps;
940         /** current tile-part index */
941         OPJ_UINT32 current_tpsno;
942         /** information concerning tile parts */
943         opj_tp_index_t *tp_index;
944
945         /* UniPG>> */ /* NOT USED FOR THE MOMENT IN THE V2 VERSION */
946                 /** number of markers */
947                 OPJ_UINT32 marknum;
948                 /** list of markers */
949                 opj_marker_info_t *marker;
950                 /** actual size of markers array */
951                 OPJ_UINT32 maxmarknum;
952         /* <<UniPG */
953
954         /** packet number */
955         OPJ_UINT32 nb_packet;
956         /** information concerning packets inside tile */
957         opj_packet_info_t *packet_index;
958
959 } opj_tile_index_t;
960
961 /**
962  * Index structure of the codestream (FIXME should be expand and enhance)
963  */
964 typedef struct opj_codestream_index {
965         /** main header start position (SOC position) */
966         OPJ_OFF_T main_head_start;
967         /** main header end position (first SOT position) */
968         OPJ_OFF_T main_head_end;
969
970         /** codestream's size */
971         OPJ_UINT64 codestream_size;
972
973 /* UniPG>> */ /* NOT USED FOR THE MOMENT IN THE V2 VERSION */
974         /** number of markers */
975         OPJ_UINT32 marknum;
976         /** list of markers */
977         opj_marker_info_t *marker;
978         /** actual size of markers array */
979         OPJ_UINT32 maxmarknum;
980 /* <<UniPG */
981
982         /** */
983         OPJ_UINT32 nb_of_tiles;
984         /** */
985         opj_tile_index_t *tile_index; /* FIXME not used for the moment */
986
987 }opj_codestream_index_t;
988 /* -----------------------------------------------------------> */
989
990 /*
991 ==========================================================
992    Metadata from the JP2file
993 ==========================================================
994 */
995
996 /**
997  * Info structure of the JP2 file
998  * EXPERIMENTAL FOR THE MOMENT
999  */
1000 typedef struct opj_jp2_metadata {
1001         /** */
1002         OPJ_INT32       not_used;
1003
1004 } opj_jp2_metadata_t;
1005
1006 /**
1007  * Index structure of the JP2 file
1008  * EXPERIMENTAL FOR THE MOMENT
1009  */
1010 typedef struct opj_jp2_index {
1011         /** */
1012         OPJ_INT32       not_used;
1013
1014 } opj_jp2_index_t;
1015
1016
1017 #ifdef __cplusplus
1018 extern "C" {
1019 #endif
1020
1021
1022 /* 
1023 ==========================================================
1024    openjpeg version
1025 ==========================================================
1026 */
1027
1028 /* Get the version of the openjpeg library*/
1029 OPJ_API const char * OPJ_CALLCONV opj_version(void);
1030
1031 /* 
1032 ==========================================================
1033    image functions definitions
1034 ==========================================================
1035 */
1036
1037 /**
1038  * Create an image
1039  *
1040  * @param numcmpts      number of components
1041  * @param cmptparms     components parameters
1042  * @param clrspc        image color space
1043  * @return returns      a new image structure if successful, returns NULL otherwise
1044  * */
1045 OPJ_API opj_image_t* OPJ_CALLCONV opj_image_create(OPJ_UINT32 numcmpts, opj_image_cmptparm_t *cmptparms, OPJ_COLOR_SPACE clrspc);
1046
1047 /**
1048  * Deallocate any resources associated with an image
1049  *
1050  * @param image         image to be destroyed
1051  */
1052 OPJ_API void OPJ_CALLCONV opj_image_destroy(opj_image_t *image);
1053
1054 /**
1055  * Creates an image without allocating memory for the image (used in the new version of the library).
1056  *
1057  * @param       numcmpts    the number of components
1058  * @param       cmptparms   the components parameters
1059  * @param       clrspc      the image color space
1060  *
1061  * @return      a new image structure if successful, NULL otherwise.
1062 */
1063 OPJ_API opj_image_t* OPJ_CALLCONV opj_image_tile_create(OPJ_UINT32 numcmpts, opj_image_cmptparm_t *cmptparms, OPJ_COLOR_SPACE clrspc);
1064
1065 /* 
1066 ==========================================================
1067    stream functions definitions
1068 ==========================================================
1069 */
1070
1071 /**
1072  * Creates an abstract stream. This function does nothing except allocating memory and initializing the abstract stream.
1073  *
1074  * @param       p_is_input              if set to true then the stream will be an input stream, an output stream else.
1075  *
1076  * @return      a stream object.
1077 */
1078 OPJ_API opj_stream_t* OPJ_CALLCONV opj_stream_default_create(OPJ_BOOL p_is_input);
1079
1080 /**
1081  * Creates an abstract stream. This function does nothing except allocating memory and initializing the abstract stream.
1082  *
1083  * @param       p_buffer_size  FIXME DOC
1084  * @param       p_is_input              if set to true then the stream will be an input stream, an output stream else.
1085  *
1086  * @return      a stream object.
1087 */
1088 OPJ_API opj_stream_t* OPJ_CALLCONV opj_stream_create(OPJ_SIZE_T p_buffer_size, OPJ_BOOL p_is_input);
1089
1090 /**
1091  * Destroys a stream created by opj_create_stream. This function does NOT close the abstract stream. If needed the user must
1092  * close its own implementation of the stream.
1093  *
1094  * @param       p_stream        the stream to destroy.
1095  */
1096 OPJ_API void OPJ_CALLCONV opj_stream_destroy(opj_stream_t* p_stream);
1097  
1098 /**
1099  * Sets the given function to be used as a read function.
1100  * @param               p_stream        the stream to modify
1101  * @param               p_function      the function to use a read function.
1102 */
1103 OPJ_API void OPJ_CALLCONV opj_stream_set_read_function(opj_stream_t* p_stream, opj_stream_read_fn p_function);
1104
1105 /**
1106  * Sets the given function to be used as a write function.
1107  * @param               p_stream        the stream to modify
1108  * @param               p_function      the function to use a write function.
1109 */
1110 OPJ_API void OPJ_CALLCONV opj_stream_set_write_function(opj_stream_t* p_stream, opj_stream_write_fn p_function);
1111
1112 /**
1113  * Sets the given function to be used as a skip function.
1114  * @param               p_stream        the stream to modify
1115  * @param               p_function      the function to use a skip function.
1116 */
1117 OPJ_API void OPJ_CALLCONV opj_stream_set_skip_function(opj_stream_t* p_stream, opj_stream_skip_fn p_function);
1118
1119 /**
1120  * Sets the given function to be used as a seek function, the stream is then seekable.
1121  * @param               p_stream        the stream to modify
1122  * @param               p_function      the function to use a skip function.
1123 */
1124 OPJ_API void OPJ_CALLCONV opj_stream_set_seek_function(opj_stream_t* p_stream, opj_stream_seek_fn p_function);
1125
1126 /**
1127  * Sets the given data to be used as a user data for the stream.
1128  * @param               p_stream        the stream to modify
1129  * @param               p_data          the data to set.
1130  * @param               p_function      the function to free p_data when opj_stream_destroy() is called.
1131 */
1132 OPJ_API void OPJ_CALLCONV opj_stream_set_user_data (opj_stream_t* p_stream, void * p_data, opj_stream_free_user_data_fn p_function);
1133
1134 /**
1135  * Sets the length of the user data for the stream.
1136  *
1137  * @param p_stream    the stream to modify
1138  * @param data_length length of the user_data.
1139 */
1140 OPJ_API void OPJ_CALLCONV opj_stream_set_user_data_length(opj_stream_t* p_stream, OPJ_UINT64 data_length);
1141
1142 /**
1143  * Create a stream from a file identified with its filename with default parameters (helper function)
1144  * @param fname             the filename of the file to stream
1145  * @param p_is_read_stream  whether the stream is a read stream (true) or not (false)
1146 */
1147 OPJ_API opj_stream_t* OPJ_CALLCONV opj_stream_create_default_file_stream (const char *fname, OPJ_BOOL p_is_read_stream);
1148  
1149 /** Create a stream from a file identified with its filename with a specific buffer size
1150  * @param fname             the filename of the file to stream
1151  * @param p_buffer_size     size of the chunk used to stream
1152  * @param p_is_read_stream  whether the stream is a read stream (true) or not (false)
1153 */
1154 OPJ_API opj_stream_t* OPJ_CALLCONV opj_stream_create_file_stream (const char *fname,
1155                                                                      OPJ_SIZE_T p_buffer_size,
1156                                                                      OPJ_BOOL p_is_read_stream);
1157  
1158 /* 
1159 ==========================================================
1160    event manager functions definitions
1161 ==========================================================
1162 */
1163 /**
1164  * Set the info handler use by openjpeg.
1165  * @param p_codec       the codec previously initialise
1166  * @param p_callback    the callback function which will be used
1167  * @param p_user_data   client object where will be returned the message
1168 */
1169 OPJ_API OPJ_BOOL OPJ_CALLCONV opj_set_info_handler(opj_codec_t * p_codec, 
1170                                                    opj_msg_callback p_callback,
1171                                                    void * p_user_data);
1172 /**
1173  * Set the warning handler use by openjpeg.
1174  * @param p_codec       the codec previously initialise
1175  * @param p_callback    the callback function which will be used
1176  * @param p_user_data   client object where will be returned the message
1177 */
1178 OPJ_API OPJ_BOOL OPJ_CALLCONV opj_set_warning_handler(opj_codec_t * p_codec,
1179                                                       opj_msg_callback p_callback,
1180                                                       void * p_user_data);
1181 /**
1182  * Set the error handler use by openjpeg.
1183  * @param p_codec       the codec previously initialise
1184  * @param p_callback    the callback function which will be used
1185  * @param p_user_data   client object where will be returned the message
1186 */
1187 OPJ_API OPJ_BOOL OPJ_CALLCONV opj_set_error_handler(opj_codec_t * p_codec, 
1188                                                     opj_msg_callback p_callback,
1189                                                     void * p_user_data);
1190
1191 /* 
1192 ==========================================================
1193    codec functions definitions
1194 ==========================================================
1195 */
1196
1197 /**
1198  * Creates a J2K/JP2 decompression structure
1199  * @param format                Decoder to select
1200  *
1201  * @return Returns a handle to a decompressor if successful, returns NULL otherwise
1202  * */
1203 OPJ_API opj_codec_t* OPJ_CALLCONV opj_create_decompress(OPJ_CODEC_FORMAT format);
1204
1205 /**
1206  * Destroy a decompressor handle
1207  *
1208  * @param       p_codec                 decompressor handle to destroy
1209  */
1210 OPJ_API void OPJ_CALLCONV opj_destroy_codec(opj_codec_t * p_codec);
1211
1212 /**
1213  * Read after the codestream if necessary
1214  * @param       p_codec                 the JPEG2000 codec to read.
1215  * @param       p_stream                the JPEG2000 stream.
1216  */
1217 OPJ_API OPJ_BOOL OPJ_CALLCONV opj_end_decompress (      opj_codec_t *p_codec,
1218                                                                                                         opj_stream_t *p_stream);
1219
1220
1221 /**
1222  * Set decoding parameters to default values
1223  * @param parameters Decompression parameters
1224  */
1225 OPJ_API void OPJ_CALLCONV opj_set_default_decoder_parameters(opj_dparameters_t *parameters);
1226
1227 /**
1228  * Setup the decoder with decompression parameters provided by the user and with the message handler
1229  * provided by the user.
1230  *
1231  * @param p_codec               decompressor handler
1232  * @param parameters    decompression parameters
1233  *
1234  * @return true                 if the decoder is correctly set
1235  */
1236 OPJ_API OPJ_BOOL OPJ_CALLCONV opj_setup_decoder(opj_codec_t *p_codec,
1237                                                                                                 opj_dparameters_t *parameters );
1238
1239 /**
1240  * Decodes an image header.
1241  *
1242  * @param       p_stream                the jpeg2000 stream.
1243  * @param       p_codec                 the jpeg2000 codec to read.
1244  * @param       p_image                 the image structure initialized with the characteristics of encoded image.
1245  *
1246  * @return true                         if the main header of the codestream and the JP2 header is correctly read.
1247  */
1248 OPJ_API OPJ_BOOL OPJ_CALLCONV opj_read_header ( opj_stream_t *p_stream,
1249                                                                                                 opj_codec_t *p_codec,
1250                                                                                                 opj_image_t **p_image);
1251
1252 /**
1253  * Sets the given area to be decoded. This function should be called right after opj_read_header and before any tile header reading.
1254  *
1255  * @param       p_codec                 the jpeg2000 codec.
1256  * @param       p_image         the decoded image previously setted by opj_read_header
1257  * @param       p_start_x               the left position of the rectangle to decode (in image coordinates).
1258  * @param       p_end_x                 the right position of the rectangle to decode (in image coordinates).
1259  * @param       p_start_y               the up position of the rectangle to decode (in image coordinates).
1260  * @param       p_end_y                 the bottom position of the rectangle to decode (in image coordinates).
1261  *
1262  * @return      true                    if the area could be set.
1263  */
1264 OPJ_API OPJ_BOOL OPJ_CALLCONV opj_set_decode_area(      opj_codec_t *p_codec,
1265                                                                                                         opj_image_t* p_image,
1266                                                                                                         OPJ_INT32 p_start_x, OPJ_INT32 p_start_y,
1267                                                                                                         OPJ_INT32 p_end_x, OPJ_INT32 p_end_y );
1268
1269 /**
1270  * Decode an image from a JPEG-2000 codestream
1271  *
1272  * @param p_decompressor        decompressor handle
1273  * @param p_stream                      Input buffer stream
1274  * @param p_image                       the decoded image
1275  * @return                                      true if success, otherwise false
1276  * */
1277 OPJ_API OPJ_BOOL OPJ_CALLCONV opj_decode(   opj_codec_t *p_decompressor,
1278                                             opj_stream_t *p_stream,
1279                                             opj_image_t *p_image);
1280
1281 /**
1282  * Get the decoded tile from the codec
1283  *
1284  * @param       p_codec                 the jpeg2000 codec.
1285  * @param       p_stream                input streamm
1286  * @param       p_image                 output image
1287  * @param       tile_index              index of the tile which will be decode
1288  *
1289  * @return                                      true if success, otherwise false
1290  */
1291 OPJ_API OPJ_BOOL OPJ_CALLCONV opj_get_decoded_tile(     opj_codec_t *p_codec,
1292                                                                                                         opj_stream_t *p_stream,
1293                                                                                                         opj_image_t *p_image,
1294                                                                                                         OPJ_UINT32 tile_index);
1295
1296 /**
1297  * Set the resolution factor of the decoded image
1298  * @param       p_codec                 the jpeg2000 codec.
1299  * @param       res_factor              resolution factor to set
1300  *
1301  * @return                                      true if success, otherwise false
1302  */
1303 OPJ_API OPJ_BOOL OPJ_CALLCONV opj_set_decoded_resolution_factor(opj_codec_t *p_codec, OPJ_UINT32 res_factor);
1304
1305 /**
1306  * Writes a tile with the given data.
1307  *
1308  * @param       p_codec                 the jpeg2000 codec.
1309  * @param       p_tile_index            the index of the tile to write. At the moment, the tiles must be written from 0 to n-1 in sequence.
1310  * @param       p_data                          pointer to the data to write. Data is arranged in sequence, data_comp0, then data_comp1, then ... NO INTERLEAVING should be set.
1311  * @param       p_data_size                     this value os used to make sure the data being written is correct. The size must be equal to the sum for each component of 
1312  *                              tile_width * tile_height * component_size. component_size can be 1,2 or 4 bytes, depending on the precision of the given component.
1313  * @param       p_stream                        the stream to write data to.
1314  *
1315  * @return      true if the data could be written.
1316  */
1317 OPJ_API OPJ_BOOL OPJ_CALLCONV opj_write_tile (  opj_codec_t *p_codec,
1318                                                                                                 OPJ_UINT32 p_tile_index,
1319                                                                                                 OPJ_BYTE * p_data,
1320                                                                                                 OPJ_UINT32 p_data_size,
1321                                                                                                 opj_stream_t *p_stream );
1322
1323 /**
1324  * Reads a tile header. This function is compulsory and allows one to know the size of the tile thta will be decoded.
1325  * The user may need to refer to the image got by opj_read_header to understand the size being taken by the tile.
1326  *
1327  * @param       p_codec                 the jpeg2000 codec.
1328  * @param       p_tile_index    pointer to a value that will hold the index of the tile being decoded, in case of success.
1329  * @param       p_data_size             pointer to a value that will hold the maximum size of the decoded data, in case of success. In case
1330  *                                                      of truncated codestreams, the actual number of bytes decoded may be lower. The computation of the size is the same
1331  *                                                      as depicted in opj_write_tile.
1332  * @param       p_tile_x0               pointer to a value that will hold the x0 pos of the tile (in the image).
1333  * @param       p_tile_y0               pointer to a value that will hold the y0 pos of the tile (in the image).
1334  * @param       p_tile_x1               pointer to a value that will hold the x1 pos of the tile (in the image).
1335  * @param       p_tile_y1               pointer to a value that will hold the y1 pos of the tile (in the image).
1336  * @param       p_nb_comps              pointer to a value that will hold the number of components in the tile.
1337  * @param       p_should_go_on  pointer to a boolean that will hold the fact that the decoding should go on. In case the
1338  *                                                      codestream is over at the time of the call, the value will be set to false. The user should then stop
1339  *                                                      the decoding.
1340  * @param       p_stream                the stream to decode.
1341  * @return      true                    if the tile header could be decoded. In case the decoding should end, the returned value is still true.
1342  *                                                      returning false may be the result of a shortage of memory or an internal error.
1343  */
1344 OPJ_API OPJ_BOOL OPJ_CALLCONV opj_read_tile_header(     opj_codec_t *p_codec,
1345                                                                                                 opj_stream_t * p_stream,
1346                                                                                                 OPJ_UINT32 * p_tile_index,
1347                                                                                                 OPJ_UINT32 * p_data_size,
1348                                                                                                 OPJ_INT32 * p_tile_x0, OPJ_INT32 * p_tile_y0,
1349                                                                                                 OPJ_INT32 * p_tile_x1, OPJ_INT32 * p_tile_y1,
1350                                                                                                 OPJ_UINT32 * p_nb_comps,
1351                                                                                                 OPJ_BOOL * p_should_go_on );
1352
1353 /**
1354  * Reads a tile data. This function is compulsory and allows one to decode tile data. opj_read_tile_header should be called before.
1355  * The user may need to refer to the image got by opj_read_header to understand the size being taken by the tile.
1356  *
1357  * @param       p_codec                 the jpeg2000 codec.
1358  * @param       p_tile_index    the index of the tile being decoded, this should be the value set by opj_read_tile_header.
1359  * @param       p_data                  pointer to a memory block that will hold the decoded data.
1360  * @param       p_data_size             size of p_data. p_data_size should be bigger or equal to the value set by opj_read_tile_header.
1361  * @param       p_stream                the stream to decode.
1362  *
1363  * @return      true                    if the data could be decoded.
1364  */
1365 OPJ_API OPJ_BOOL OPJ_CALLCONV opj_decode_tile_data(     opj_codec_t *p_codec,
1366                                                                                                         OPJ_UINT32 p_tile_index,
1367                                                                                                         OPJ_BYTE * p_data,
1368                                                                                                         OPJ_UINT32 p_data_size,
1369                                                                                                         opj_stream_t *p_stream );
1370
1371 /* COMPRESSION FUNCTIONS*/
1372
1373 /**
1374  * Creates a J2K/JP2 compression structure
1375  * @param       format          Coder to select
1376  * @return                              Returns a handle to a compressor if successful, returns NULL otherwise
1377  */
1378 OPJ_API opj_codec_t* OPJ_CALLCONV opj_create_compress(OPJ_CODEC_FORMAT format);
1379
1380 /**
1381 Set encoding parameters to default values, that means : 
1382 <ul>
1383 <li>Lossless
1384 <li>1 tile
1385 <li>Size of precinct : 2^15 x 2^15 (means 1 precinct)
1386 <li>Size of code-block : 64 x 64
1387 <li>Number of resolutions: 6
1388 <li>No SOP marker in the codestream
1389 <li>No EPH marker in the codestream
1390 <li>No sub-sampling in x or y direction
1391 <li>No mode switch activated
1392 <li>Progression order: LRCP
1393 <li>No index file
1394 <li>No ROI upshifted
1395 <li>No offset of the origin of the image
1396 <li>No offset of the origin of the tiles
1397 <li>Reversible DWT 5-3
1398 </ul>
1399 @param parameters Compression parameters
1400 */
1401 OPJ_API void OPJ_CALLCONV opj_set_default_encoder_parameters(opj_cparameters_t *parameters);
1402
1403 /**
1404  * Setup the encoder parameters using the current image and using user parameters.
1405  * @param p_codec               Compressor handle
1406  * @param parameters    Compression parameters
1407  * @param image                 Input filled image
1408  */
1409 OPJ_API OPJ_BOOL OPJ_CALLCONV opj_setup_encoder(opj_codec_t *p_codec, 
1410                                                                                                 opj_cparameters_t *parameters, 
1411                                                                                                 opj_image_t *image);
1412
1413 /**
1414  * Start to compress the current image.
1415  * @param p_codec               Compressor handle
1416  * @param image             Input filled image
1417  * @param p_stream              Input stgream
1418  */
1419 OPJ_API OPJ_BOOL OPJ_CALLCONV opj_start_compress (      opj_codec_t *p_codec,
1420                                                                                                         opj_image_t * p_image,
1421                                                                                                         opj_stream_t *p_stream);
1422
1423 /**
1424  * End to compress the current image.
1425  * @param p_codec               Compressor handle
1426  * @param p_stream              Input stgream
1427  */
1428 OPJ_API OPJ_BOOL OPJ_CALLCONV opj_end_compress (opj_codec_t *p_codec,
1429                                                                                                 opj_stream_t *p_stream);
1430
1431 /**
1432  * Encode an image into a JPEG-2000 codestream
1433  * @param p_codec               compressor handle
1434  * @param p_stream              Output buffer stream
1435  *
1436  * @return                              Returns true if successful, returns false otherwise
1437  */
1438 OPJ_API OPJ_BOOL OPJ_CALLCONV opj_encode(opj_codec_t *p_codec,
1439                                          opj_stream_t *p_stream);
1440 /*
1441 ==========================================================
1442    codec output functions definitions
1443 ==========================================================
1444 */
1445 /* EXPERIMENTAL FUNCTIONS FOR NOW, USED ONLY IN J2K_DUMP*/
1446
1447 /**
1448 Destroy Codestream information after compression or decompression
1449 @param cstr_info Codestream information structure
1450 */
1451 OPJ_API void OPJ_CALLCONV opj_destroy_cstr_info(opj_codestream_info_v2_t **cstr_info);
1452
1453
1454 /**
1455  * Dump the codec information into the output stream
1456  *
1457  * @param       p_codec                 the jpeg2000 codec.
1458  * @param       info_flag               type of information dump.
1459  * @param       output_stream   output stream where dump the informations get from the codec.
1460  *
1461  */
1462 OPJ_API void OPJ_CALLCONV opj_dump_codec(       opj_codec_t *p_codec,
1463                                                                                         OPJ_INT32 info_flag,
1464                                                                                         FILE* output_stream);
1465
1466 /**
1467  * Get the codestream information from the codec
1468  *
1469  * @param       p_codec                 the jpeg2000 codec.
1470  *
1471  * @return                                      a pointer to a codestream information structure.
1472  *
1473  */
1474 OPJ_API opj_codestream_info_v2_t* OPJ_CALLCONV opj_get_cstr_info(opj_codec_t *p_codec);
1475
1476 /**
1477  * Get the codestream index from the codec
1478  *
1479  * @param       p_codec                 the jpeg2000 codec.
1480  *
1481  * @return                                      a pointer to a codestream index structure.
1482  *
1483  */
1484 OPJ_API opj_codestream_index_t * OPJ_CALLCONV opj_get_cstr_index(opj_codec_t *p_codec);
1485
1486 OPJ_API void OPJ_CALLCONV opj_destroy_cstr_index(opj_codestream_index_t **p_cstr_index);
1487
1488
1489 /**
1490  * Get the JP2 file information from the codec FIXME
1491  *
1492  * @param       p_codec                 the jpeg2000 codec.
1493  *
1494  * @return                                      a pointer to a JP2 metadata structure.
1495  *
1496  */
1497 OPJ_API opj_jp2_metadata_t* OPJ_CALLCONV opj_get_jp2_metadata(opj_codec_t *p_codec);
1498
1499 /**
1500  * Get the JP2 file index from the codec FIXME
1501  *
1502  * @param       p_codec                 the jpeg2000 codec.
1503  *
1504  * @return                                      a pointer to a JP2 index structure.
1505  *
1506  */
1507 OPJ_API opj_jp2_index_t* OPJ_CALLCONV opj_get_jp2_index(opj_codec_t *p_codec);
1508
1509
1510 /*
1511 ==========================================================
1512    MCT functions
1513 ==========================================================
1514 */
1515
1516 /**
1517  * Sets the MCT matrix to use.
1518  *
1519  * @param       parameters              the parameters to change.
1520  * @param       pEncodingMatrix the encoding matrix.
1521  * @param       p_dc_shift              the dc shift coefficients to use.
1522  * @param       pNbComp                 the number of components of the image.
1523  *
1524  * @return      true if the parameters could be set.
1525  */
1526 OPJ_API OPJ_BOOL OPJ_CALLCONV opj_set_MCT( opj_cparameters_t *parameters,
1527                                                    OPJ_FLOAT32 * pEncodingMatrix,
1528                                                    OPJ_INT32 * p_dc_shift,
1529                                                    OPJ_UINT32 pNbComp);
1530
1531
1532
1533 #ifdef __cplusplus
1534 }
1535 #endif
1536
1537 #endif /* OPENJPEG_H */