Deleting obsolete files and directories, adding v2-specific files and directories, updating existing files to v2. See README.v2 for more info

1 files changed, 384 insertions, 216 deletions

diff --git a/libopenjpeg/openjpeg.h b/libopenjpeg/openjpeg.h
index ffcaacaf..48d863e1 100644
--- a/libopenjpeg/openjpeg.h
+++ b/libopenjpeg/openjpeg.h
@@ -6,6 +6,7 @@
  * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
  * Copyright (c) 2005, Herve Drolon, FreeImage Team
  * Copyright (c) 2006-2007, Parvatha Elangovan
+ * Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -32,58 +33,59 @@
 #ifndef OPENJPEG_H
 #define OPENJPEG_H
 
-#define OPENJPEG_VERSION "1.3.0"
+#if defined(OPJ_STATIC) || !(defined(WIN32) || defined(__WIN32__))
+	#define OPJ_API
+	#define OPJ_CALLCONV
+#else
+	#define OPJ_CALLCONV __stdcall
+	#ifdef OPJ_EXPORTS
+		#define OPJ_API __declspec(dllexport)
+	#else
+		#define OPJ_API __declspec(dllimport)
+	#endif /* OPJ_EXPORTS */
+#endif /* !OPJ_STATIC || !WIN32 */
 
+#ifndef __cplusplus
+	#if defined(HAVE_STDBOOL_H)
+		#include <stdbool.h>
+	#else
+		#if !defined(bool)
+			#define	bool	int
+		#endif
+		#if !defined(true)
+			#define true	1
+		#endif
+		#if !defined(false)
+			#define	false	0
+		#endif
+	#endif
+#endif /* __cplusplus */
+typedef unsigned int	OPJ_UINT32;
+typedef int		OPJ_INT32;	
+typedef unsigned short	OPJ_UINT16;	
+typedef short		OPJ_INT16;	
+typedef char		OPJ_CHAR;
+typedef unsigned char	OPJ_BYTE;
+typedef unsigned int	OPJ_SIZE_T;
+typedef double		OPJ_FLOAT64;
+typedef float		OPJ_FLOAT32;
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+	typedef __int64		OPJ_INT64;
+#else
+	typedef long long	OPJ_INT64;
+#endif
+
+#define OPENJPEG_VERSION "1.2.0"
 /* 
 ==========================================================
    Compiler directives
 ==========================================================
 */
+#include <stdio.h>
+
+
 
-#if defined(OPJ_STATIC) || !(defined(WIN32) || defined(__WIN32__))
-#define OPJ_API
-#define OPJ_CALLCONV
-#else
-#define OPJ_CALLCONV __stdcall
-/*
-The following ifdef block is the standard way of creating macros which make exporting 
-from a DLL simpler. All files within this DLL are compiled with the OPJ_EXPORTS
-symbol defined on the command line. this symbol should not be defined on any project
-that uses this DLL. This way any other project whose source files include this file see 
-OPJ_API functions as being imported from a DLL, wheras this DLL sees symbols
-defined with this macro as being exported.
-*/
-#ifdef OPJ_EXPORTS
-#define OPJ_API __declspec(dllexport)
-#else
-#define OPJ_API __declspec(dllimport)
-#endif /* OPJ_EXPORTS */
-#endif /* !OPJ_STATIC || !WIN32 */
 
-#ifndef __cplusplus
-#if defined(HAVE_STDBOOL_H)
-/*
-The C language implementation does correctly provide the standard header
-file "stdbool.h".
- */
-#include <stdbool.h>
-#else
-/*
-The C language implementation does not provide the standard header file
-"stdbool.h" as required by ISO/IEC 9899:1999.  Try to compensate for this
-braindamage below.
-*/
-#if !defined(bool)
-#define	bool	int
-#endif
-#if !defined(true)
-#define true	1
-#endif
-#if !defined(false)
-#define	false	0
-#endif
-#endif
-#endif /* __cplusplus */
 
 /* 
 ==========================================================
@@ -91,10 +93,14 @@ braindamage below.
 ==========================================================
 */
 
-#define OPJ_PATH_LEN 4096 /**< Maximum allowed size for filenames */
-
-#define J2K_MAXRLVLS 33					/**< Number of maximum resolution level authorized */
-#define J2K_MAXBANDS (3*J2K_MAXRLVLS-2)	/**< Number of maximum sub-band linked to number of resolution level */
+#define OPJ_PATH_LEN					4096 /**< Maximum allowed size for filenames */
+#define J2K_MAXRLVLS					33					/**< Number of maximum resolution level authorized */
+#define J2K_MAXBANDS					(3*J2K_MAXRLVLS-2)	/**< Number of maximum sub-band linked to number of resolution level */
+#define J2K_DEFAULT_NB_SEGS				10
+#define J2K_STREAM_CHUNK_SIZE			0x100000 /** 1 mega by default */
+#define J2K_DEFAULT_HEADER_SIZE			1000
+#define J2K_MCC_DEFAULT_NB_RECORDS		10
+#define J2K_MCT_DEFAULT_NB_RECORDS		10
 
 /* UniPG>> */
 #define JPWL_MAX_NO_TILESPECS	16 /**< Maximum number of tile parts expected by JPWL: increase at your will */
@@ -118,7 +124,8 @@ Rsiz Capabilities
 typedef enum RSIZ_CAPABILITIES {
 	STD_RSIZ = 0,		/** Standard JPEG2000 profile*/
 	CINEMA2K = 3,		/** Profile name for a 2K image*/
-	CINEMA4K = 4		/** Profile name for a 4K image*/
+	CINEMA4K = 4,		/** Profile name for a 4K image*/
+	MCT = 0x8100
 } OPJ_RSIZ_CAPABILITIES;
 
 /** 
@@ -163,14 +170,8 @@ typedef enum CODEC_FORMAT {
 	CODEC_JP2 = 2		/**< JPEG-2000 file format : read/write */
 } OPJ_CODEC_FORMAT;
 
-/** 
-Limit decoding to certain portions of the codestream. 
-*/
-typedef enum LIMIT_DECODING {
-	NO_LIMITATION = 0,				  /**< No limitation for the decoding. The entire codestream will de decoded */
-	LIMIT_TO_MAIN_HEADER = 1,		/**< The decoding is limited to the Main Header */
-	DECODE_ALL_BUT_PACKETS = 2	/**< Decode everything except the JPEG 2000 packets */
-} OPJ_LIMIT_DECODING;
+
+
 
 /* 
 ==========================================================
@@ -183,25 +184,9 @@ Callback function prototype for events
 @param msg Event message
 @param client_data 
 */
-typedef void (*opj_msg_callback) (const char *msg, void *client_data);
+typedef void (*opj_msg_callback) (const OPJ_CHAR *msg, void *client_data);
+
 
-/**
-Message handler object
-used for 
-<ul>
-<li>Error messages
-<li>Warning messages
-<li>Debugging messages
-</ul>
-*/
-typedef struct opj_event_mgr {
-	/** Error message callback if available, NULL otherwise */
-	opj_msg_callback error_handler;
-	/** Warning message callback if available, NULL otherwise */
-	opj_msg_callback warning_handler;
-	/** Debug message callback if available, NULL otherwise */
-	opj_msg_callback info_handler;
-} opj_event_mgr_t;
 
 
 /* 
@@ -213,29 +198,30 @@ typedef struct opj_event_mgr {
 /**
 Progression order changes
 */
-typedef struct opj_poc {
+typedef struct opj_poc 
+{
 	/** Resolution num start, Component num start, given by POC */
-	int resno0, compno0;
+	OPJ_UINT32 resno0, compno0;
 	/** Layer num end,Resolution num end, Component num end, given by POC */
-	int layno1, resno1, compno1;
+	OPJ_UINT32 layno1, resno1, compno1;
 	/** Layer num start,Precinct num start, Precinct num end */
-	int layno0, precno0, precno1;
+	OPJ_UINT32 layno0, precno0, precno1;
 	/** Progression order enum*/
 	OPJ_PROG_ORDER prg1,prg;
 	/** Progression order string*/
-	char progorder[5];
+	OPJ_CHAR progorder[5];
 	/** Tile number */
-	int tile;
+	OPJ_UINT32 tile;
 	/** Start and end values for Tile width and height*/
-	int tx0,tx1,ty0,ty1;
+	OPJ_INT32 tx0,tx1,ty0,ty1;
 	/** Start value, initialised in pi_initialise_encode*/
-	int layS, resS, compS, prcS;
+	OPJ_UINT32 layS, resS, compS, prcS;
 	/** End value, initialised in pi_initialise_encode */
-	int layE, resE, compE, prcE;
+	OPJ_UINT32 layE, resE, compE, prcE;
 	/** Start and end values of Tile width and height, initialised in pi_initialise_encode*/
-	int txS,txE,tyS,tyE,dx,dy;
+	OPJ_UINT32 txS,txE,tyS,tyE,dx,dy;
 	/** Temporary values for Tile parts, initialised in pi_create_encode */
-	int lay_t, res_t, comp_t, prc_t,tx0_t,ty0_t;
+	OPJ_UINT32 lay_t, res_t, comp_t, prc_t,tx0_t,ty0_t;
 } opj_poc_t;
 
 /**
@@ -365,6 +351,9 @@ typedef struct opj_cparameters {
 	char tp_flag;
 	/** MCT (multiple component transform) */
 	char tcp_mct;
+	/** Naive implementation of MCT restricted to a single reversible array based encoding without offset concerning all the components. */
+	void * mct_data;
+
 } opj_cparameters_t;
 
 /**
@@ -387,6 +376,14 @@ typedef struct opj_dparameters {
 	*/
 	int cp_layer;
 
+	/**
+	 * Restrictive decoding parameters.
+	 */
+	OPJ_INT32 m_decode_start_x;
+	OPJ_INT32 m_decode_start_y ;
+	OPJ_INT32 m_decode_end_x ;
+	OPJ_INT32 m_decode_end_y ;
+
 	/**@name command line encoder parameters (not used inside the library) */
 	/*@{*/
 	/** input file name */
@@ -408,61 +405,19 @@ typedef struct opj_dparameters {
 	int jpwl_exp_comps;
 	/** maximum number of tiles */
 	int jpwl_max_tiles;
+	
+	/** use restrictive decoding ? */
+	OPJ_UINT32 m_use_restrict_decode : 1;
 	/*@}*/
 /* <<UniPG */
 
-	/** 
-	Specify whether the decoding should be done on the entire codestream, or be limited to the main header
-	Limiting the decoding to the main header makes it possible to extract the characteristics of the codestream
-	if == NO_LIMITATION, the entire codestream is decoded; 
-	if == LIMIT_TO_MAIN_HEADER, only the main header is decoded; 
-	*/
-	OPJ_LIMIT_DECODING cp_limit_decoding;
-
 } opj_dparameters_t;
 
-/** Common fields between JPEG-2000 compression and decompression master structs. */
-
-#define opj_common_fields \
-	opj_event_mgr_t *event_mgr;	/**< pointer to the event manager */\
-	void * client_data;			/**< Available for use by application */\
-	bool is_decompressor;		/**< So common code can tell which is which */\
-	OPJ_CODEC_FORMAT codec_format;	/**< selected codec */\
-	void *j2k_handle;			/**< pointer to the J2K codec */\
-	void *jp2_handle;			/**< pointer to the JP2 codec */\
-	void *mj2_handle			/**< pointer to the MJ2 codec */
-	
-/* Routines that are to be used by both halves of the library are declared
- * to receive a pointer to this structure.  There are no actual instances of
- * opj_common_struct_t, only of opj_cinfo_t and opj_dinfo_t.
- */
-typedef struct opj_common_struct {
-  opj_common_fields;		/* Fields common to both master struct types */
-  /* Additional fields follow in an actual opj_cinfo_t or
-   * opj_dinfo_t.  All three structs must agree on these
-   * initial fields!  (This would be a lot cleaner in C++.)
-   */
-} opj_common_struct_t;
-
-typedef opj_common_struct_t * opj_common_ptr;
-
 /**
-Compression context info
-*/
-typedef struct opj_cinfo {
-	/** Fields shared with opj_dinfo_t */
-	opj_common_fields;	
-	/* other specific fields go here */
-} opj_cinfo_t;
+ * J2k codec.
+ */
+typedef void * opj_codec_t;
 
-/**
-Decompression context info
-*/
-typedef struct opj_dinfo {
-	/** Fields shared with opj_cinfo_t */
-	opj_common_fields;	
-	/* other specific fields go here */
-} opj_dinfo_t;
 
 /* 
 ==========================================================
@@ -478,27 +433,14 @@ typedef struct opj_dinfo {
 /** The stream was opened for writing. */
 #define OPJ_STREAM_WRITE 0x0002
 
-/**
-Byte input-output stream (CIO)
-*/
-typedef struct opj_cio {
-	/** codec context */
-	opj_common_ptr cinfo;
 
-	/** open mode (read/write) either OPJ_STREAM_READ or OPJ_STREAM_WRITE */
-	int openmode;
-	/** pointer to the start of the buffer */
-	unsigned char *buffer;
-	/** buffer size in bytes */
-	int length;
+typedef OPJ_UINT32 (* opj_stream_read_fn) (void * p_buffer, OPJ_UINT32 p_nb_bytes, void * p_user_data) ;
+typedef OPJ_UINT32 (* opj_stream_write_fn) (void * p_buffer, OPJ_UINT32 p_nb_bytes, void * p_user_data) ;
+typedef OPJ_SIZE_T (* opj_stream_skip_fn) (OPJ_SIZE_T p_nb_bytes, void * p_user_data) ;
+typedef bool (* opj_stream_seek_fn) (OPJ_SIZE_T p_nb_bytes, void * p_user_data) ;
+
 
-	/** pointer to the start of the stream */
-	unsigned char *start;
-	/** pointer to the end of the stream */
-	unsigned char *end;
-	/** pointer to the current position */
-	unsigned char *bp;
-} opj_cio_t;
+typedef void * opj_stream_t;
 
 /* 
 ==========================================================
@@ -511,45 +453,45 @@ Defines a single image component
 */
 typedef struct opj_image_comp {
 	/** XRsiz: horizontal separation of a sample of ith component with respect to the reference grid */
-	int dx;
+	OPJ_UINT32 dx;
 	/** YRsiz: vertical separation of a sample of ith component with respect to the reference grid */
-	int dy;
+	OPJ_UINT32 dy;
 	/** data width */
-	int w;
+	OPJ_UINT32 w;
 	/** data height */
-	int h;
+	OPJ_UINT32 h;
 	/** x component offset compared to the whole image */
-	int x0;
+	OPJ_INT32 x0;
 	/** y component offset compared to the whole image */
-	int y0;
+	OPJ_INT32 y0;
 	/** precision */
-	int prec;
-	/** image depth in bits */
-	int bpp;
-	/** signed (1) / unsigned (0) */
-	int sgnd;
+	OPJ_UINT32 prec;
 	/** number of decoded resolution */
-	int resno_decoded;
+	OPJ_UINT32 resno_decoded;
 	/** number of division by 2 of the out image compared to the original size of image */
-	int factor;
+	OPJ_UINT32 factor;
 	/** image component data */
 	int *data;
+	/** signed (1) / unsigned (0) */
+	OPJ_UINT32 sgnd : 1;
+	
 } opj_image_comp_t;
 
 /** 
 Defines image data and characteristics
 */
-typedef struct opj_image {
+typedef struct opj_image 
+{
 	/** XOsiz: horizontal offset from the origin of the reference grid to the left side of the image area */
-	int x0;
+	OPJ_INT32 x0;
 	/** YOsiz: vertical offset from the origin of the reference grid to the top side of the image area */
-	int y0;
+	OPJ_INT32 y0;
 	/** Xsiz: width of the reference grid */
-	int x1;
+	OPJ_INT32 x1;
 	/** Ysiz: height of the reference grid */
-	int y1;
+	OPJ_INT32 y1;
 	/** number of components in the image */
-	int numcomps;
+	OPJ_UINT32 numcomps;
 	/** color space: sRGB, Greyscale or YUV */
 	OPJ_COLOR_SPACE color_space;
 	/** image components */
@@ -561,13 +503,13 @@ Component parameters structure used by the opj_image_create function
 */
 typedef struct opj_image_comptparm {
 	/** XRsiz: horizontal separation of a sample of ith component with respect to the reference grid */
-	int dx;
+	unsigned int dx;
 	/** YRsiz: vertical separation of a sample of ith component with respect to the reference grid */
-	int dy;
+	unsigned int dy;
 	/** data width */
-	int w;
+	unsigned int w;
 	/** data height */
-	int h;
+	unsigned int h;
 	/** x component offset compared to the whole image */
 	int x0;
 	/** y component offset compared to the whole image */
@@ -727,7 +669,7 @@ extern "C" {
 ==========================================================
 */
 
-OPJ_API const char * OPJ_CALLCONV opj_version(void);
+OPJ_API const OPJ_CHAR * OPJ_CALLCONV opj_version(void);
 
 /* 
 ==========================================================
@@ -742,7 +684,18 @@ Create an image
 @param clrspc image color space
 @return returns a new image structure if successful, returns NULL otherwise
 */
-OPJ_API opj_image_t* OPJ_CALLCONV opj_image_create(int numcmpts, opj_image_cmptparm_t *cmptparms, OPJ_COLOR_SPACE clrspc);
+OPJ_API opj_image_t* OPJ_CALLCONV opj_image_create(OPJ_UINT32 numcmpts, opj_image_cmptparm_t *cmptparms, OPJ_COLOR_SPACE clrspc);
+
+/**
+ * Creates an image without allocating memory for the image (used in the new version of the library).
+ * 
+ * @param	p_num_cmpts			the number of components
+ * @param	p_cmpt_parms		the components parameters
+ * @param	p_clr_spc			the image color space
+ * 
+ * @return	a new image structure if successful, NULL otherwise.
+*/
+OPJ_API opj_image_t* OPJ_CALLCONV opj_image_tile_create(OPJ_UINT32 numcmpts, opj_image_cmptparm_t *cmptparms, OPJ_COLOR_SPACE clrspc);
 
 /**
 Deallocate any resources associated with an image
@@ -757,44 +710,80 @@ OPJ_API void OPJ_CALLCONV opj_image_destroy(opj_image_t *image);
 */
 
 /**
-Open and allocate a memory stream for read / write. 
-On reading, the user must provide a buffer containing encoded data. The buffer will be 
-wrapped by the returned CIO handle. 
-On writing, buffer parameters must be set to 0: a buffer will be allocated by the library 
-to contain encoded data. 
-@param cinfo Codec context info
-@param buffer Reading: buffer address. Writing: NULL
-@param length Reading: buffer length. Writing: 0
-@return Returns a CIO handle if successful, returns NULL otherwise
+ * Creates an abstract stream. This function does nothing except allocating memory and initializing the abstract stream.
+ *
+ * @param	l_is_reader		if set to true then the stream will be an input stream, an output stream else.
+ * 
+ * @return	a stream object.
 */
-OPJ_API opj_cio_t* OPJ_CALLCONV opj_cio_open(opj_common_ptr cinfo, unsigned char *buffer, int length);
+OPJ_API opj_stream_t* OPJ_CALLCONV opj_stream_default_create(bool p_is_input);
+OPJ_API opj_stream_t* OPJ_CALLCONV opj_stream_create(OPJ_UINT32 p_size,bool p_is_input);
+
+/**
+ * Destroys a stream created by opj_create_stream. This function does NOT close the abstract stream. If needed the user must 
+ * close its own implementation of the stream.
+ * 
+ * @param	p_stream	the stream to destroy.
+ */
+OPJ_API void OPJ_CALLCONV opj_stream_destroy(opj_stream_t* p_stream);
 
 /**
-Close and free a CIO handle
-@param cio CIO handle to free
+ * Sets the given function to be used as a read function.
+ * @param		p_stream	the stream to modify
+ * @param		p_function	the function to use a read function.
 */
-OPJ_API void OPJ_CALLCONV opj_cio_close(opj_cio_t *cio);
+OPJ_API void OPJ_CALLCONV opj_stream_set_read_function(opj_stream_t* p_stream, opj_stream_read_fn p_function);
 
 /**
-Get position in byte stream
-@param cio CIO handle
-@return Returns the position in bytes
+ * Sets the given function to be used as a write function.
+ * @param		p_stream	the stream to modify
+ * @param		p_function	the function to use a write function.
 */
-OPJ_API int OPJ_CALLCONV cio_tell(opj_cio_t *cio);
+OPJ_API void OPJ_CALLCONV opj_stream_set_write_function(opj_stream_t* p_stream, opj_stream_write_fn p_function);
+
+/**
+ * Sets the given function to be used as a skip function.
+ * @param		p_stream	the stream to modify
+ * @param		p_function	the function to use a skip function.
+*/
+OPJ_API void OPJ_CALLCONV opj_stream_set_skip_function(opj_stream_t* p_stream, opj_stream_skip_fn p_function);
+
 /**
-Set position in byte stream
-@param cio CIO handle
-@param pos Position, in number of bytes, from the beginning of the stream
+ * Sets the given function to be used as a seek function, the stream is then seekable.
+ * @param		p_stream	the stream to modify
+ * @param		p_function	the function to use a skip function.
 */
-OPJ_API void OPJ_CALLCONV cio_seek(opj_cio_t *cio, int pos);
+OPJ_API void OPJ_CALLCONV opj_stream_set_seek_function(opj_stream_t* p_stream, opj_stream_seek_fn p_function);
+
+
+/**
+ * Sets the given data to be used as a user data for the stream.
+ * @param		p_stream	the stream to modify
+ * @param		p_data		the data to set.
+*/
+OPJ_API void OPJ_CALLCONV opj_stream_set_user_data (opj_stream_t* p_stream, void * p_data);
+
+/**
+ * Helper function.
+ * Sets the stream to be a file stream. The FILE must have been open previously.
+ * @param		p_stream	the stream to modify
+ * @param		p_file		handler to an already open file.
+*/
+OPJ_API opj_stream_t* OPJ_CALLCONV opj_stream_create_default_file_stream (FILE * p_file,bool p_is_read_stream);
+OPJ_API opj_stream_t* OPJ_CALLCONV opj_stream_create_file_stream (FILE * p_file,OPJ_UINT32 p_buffer_size, bool p_is_read_stream);
+
+
 
 /* 
 ==========================================================
    event manager functions definitions
 ==========================================================
 */
+OPJ_API bool OPJ_CALLCONV opj_set_info_handler(opj_codec_t * p_codec, opj_msg_callback p_callback,void * p_user_data);
+OPJ_API bool OPJ_CALLCONV opj_set_warning_handler(opj_codec_t * p_codec, opj_msg_callback p_callback,void * p_user_data);
+OPJ_API bool OPJ_CALLCONV opj_set_error_handler(opj_codec_t * p_codec, opj_msg_callback p_callback,void * p_user_data);
+
 
-OPJ_API opj_event_mgr_t* OPJ_CALLCONV opj_set_event_mgr(opj_common_ptr cinfo, opj_event_mgr_t *event_mgr, void *context);
 
 /* 
 ==========================================================
@@ -806,31 +795,130 @@ Creates a J2K/JPT/JP2 decompression structure
 @param format Decoder to select
 @return Returns a handle to a decompressor if successful, returns NULL otherwise
 */
-OPJ_API opj_dinfo_t* OPJ_CALLCONV opj_create_decompress(OPJ_CODEC_FORMAT format);
-/**
-Destroy a decompressor handle
-@param dinfo decompressor handle to destroy
-*/
-OPJ_API void OPJ_CALLCONV opj_destroy_decompress(opj_dinfo_t *dinfo);
+OPJ_API opj_codec_t* OPJ_CALLCONV opj_create_decompress(OPJ_CODEC_FORMAT format);
+
 /**
 Set decoding parameters to default values
 @param parameters Decompression parameters
 */
 OPJ_API void OPJ_CALLCONV opj_set_default_decoder_parameters(opj_dparameters_t *parameters);
+
+#ifdef USE_OPJ_DEPRECATED
+#ifdef _MSC_VER
+#pragma message ( "warning, opj_setup_decoder is deprecated")
+#else
+#warning "warning, opj_setup_decoder is deprecated"
+#endif
 /**
 Setup the decoder decoding parameters using user parameters.
 Decoding parameters are returned in j2k->cp. 
 @param dinfo decompressor handle
 @param parameters decompression parameters
 */
-OPJ_API void OPJ_CALLCONV opj_setup_decoder(opj_dinfo_t *dinfo, opj_dparameters_t *parameters);
+OPJ_API bool OPJ_CALLCONV opj_setup_decoder(opj_codec_t *dinfo, opj_dparameters_t *parameters);
+#endif
+
 /**
 Decode an image from a JPEG-2000 codestream 
 @param dinfo decompressor handle
 @param cio Input buffer stream
 @return Returns a decoded image if successful, returns NULL otherwise
 */
-OPJ_API opj_image_t* OPJ_CALLCONV opj_decode(opj_dinfo_t *dinfo, opj_cio_t *cio);
+OPJ_API opj_image_t* OPJ_CALLCONV opj_decode(opj_codec_t *p_decompressor, opj_stream_t * cio);
+
+/**
+ * Writes a tile with the given data.
+ * 
+ * @param	p_compressor		the jpeg2000 codec.
+ * @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.
+ * @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.
+ * @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 tile_width * tile_height * component_size. component_size can be 1,2 or 4 bytes,
+ *								depending on the precision of the given component.
+ * @param	p_stream			the stream to write data to.
+ * 
+ * @return	true if the data could be written.
+ */
+OPJ_API bool OPJ_CALLCONV opj_write_tile (
+					 opj_codec_t *p_codec,
+					 OPJ_UINT32 p_tile_index,
+					 OPJ_BYTE * p_data,
+					 OPJ_UINT32 p_data_size,
+					 opj_stream_t *p_stream
+					);
+
+/**
+ * Reads a tile header. This function is compulsory and allows one to know the size of the tile thta will be decoded.
+ * The user may need to refer to the image got by opj_read_header to understand the size being taken by the tile.
+ *
+ * @param	p_codec			the jpeg2000 codec.
+ * @param	p_tile_index	pointer to a value that will hold the index of the tile being decoded, in case of success.
+ * @param	p_data_size		pointer to a value that will hold the maximum size of the decoded data, in case of success. In case
+ *							of truncated codestreams, the actual number of bytes decoded may be lower. The computation of the size is the same
+ *							as depicted in opj_write_tile.
+ * @param	p_tile_x0		pointer to a value that will hold the x0 pos of the tile (in the image).
+ * @param	p_tile_y0		pointer to a value that will hold the y0 pos of the tile (in the image).
+ * @param	p_tile_x1		pointer to a value that will hold the x1 pos of the tile (in the image).
+ * @param	p_tile_y1		pointer to a value that will hold the y1 pos of the tile (in the image).
+ * @param	p_nb_comps		pointer to a value that will hold the number of components in the tile.
+ * @param	p_should_go_on	pointer to a boolean that will hold the fact that the decoding should go on. In case the
+ *							codestream is over at the time of the call, the value will be set to false. The user should then stop
+ *							the decoding.
+ * @param	p_stream		the stream to decode.
+ * @return	true			if the tile header could be decoded. In case the decoding should end, the returned value is still true.
+ *							returning false may be the result of a shortage of memory or an internal error.
+ */				
+OPJ_API bool OPJ_CALLCONV opj_read_tile_header(
+					opj_codec_t *p_codec,
+					OPJ_UINT32 * p_tile_index,
+					OPJ_UINT32 * p_data_size,
+					OPJ_INT32 * p_tile_x0,
+					OPJ_INT32 * p_tile_y0,
+					OPJ_INT32 * p_tile_x1,
+					OPJ_INT32 * p_tile_y1,
+					OPJ_UINT32 * p_nb_comps,
+					bool * p_should_go_on,
+					opj_stream_t * p_stream);
+
+
+/**
+ * Reads a tile data. This function is compulsory and allows one to decode tile data. opj_read_tile_header should be called before.
+ * The user may need to refer to the image got by opj_read_header to understand the size being taken by the tile.
+ *
+ * @param	p_codec			the jpeg2000 codec.
+ * @param	p_tile_index	the index of the tile being decoded, this should be the value set by opj_read_tile_header.
+ * @param	p_data			pointer to a memory block that will hold the decoded data.
+ * @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.
+ * @param	p_stream		the stream to decode.
+ *
+ * @return	true			if the data could be decoded.
+ */				
+OPJ_API bool OPJ_CALLCONV opj_decode_tile_data(
+					opj_codec_t *p_codec,
+					OPJ_UINT32 p_tile_index,
+					OPJ_BYTE * p_data,
+					OPJ_UINT32 p_data_size,
+					opj_stream_t *p_stream
+					);
+
+/**
+ * Sets the given area to be decoded. This function should be called right after opj_read_header and before any tile header reading.
+ * 
+ * @param	p_codec			the jpeg2000 codec.
+ * @param	p_start_x		the left position of the rectangle to decode (in image coordinates).
+ * @param	p_end_x			the right position of the rectangle to decode (in image coordinates).
+ * @param	p_start_y		the up position of the rectangle to decode (in image coordinates).
+ * @param	p_end_y			the bottom position of the rectangle to decode (in image coordinates).
+ *
+ * @return	true			if the area could be set.
+ */				
+OPJ_API bool OPJ_CALLCONV opj_set_decode_area(
+					opj_codec_t *p_codec,
+					OPJ_INT32 p_start_x,
+					OPJ_INT32 p_start_y,
+					OPJ_INT32 p_end_x,
+					OPJ_INT32 p_end_y
+					);
+
 
 /**
 Decode an image from a JPEG-2000 codestream and extract the codestream information
@@ -839,18 +927,20 @@ Decode an image from a JPEG-2000 codestream and extract the codestream informati
 @param cstr_info Codestream information structure if needed afterwards, NULL otherwise
 @return Returns a decoded image if successful, returns NULL otherwise
 */
-OPJ_API opj_image_t* OPJ_CALLCONV opj_decode_with_info(opj_dinfo_t *dinfo, opj_cio_t *cio, opj_codestream_info_t *cstr_info);
+//OPJ_API opj_image_t* OPJ_CALLCONV opj_decode_with_info(opj_dinfo_t *dinfo, opj_stream_t cio, opj_codestream_info_t *cstr_info);
 /**
 Creates a J2K/JP2 compression structure
 @param format Coder to select
 @return Returns a handle to a compressor if successful, returns NULL otherwise
 */
-OPJ_API opj_cinfo_t* OPJ_CALLCONV opj_create_compress(OPJ_CODEC_FORMAT format);
+OPJ_API opj_codec_t* OPJ_CALLCONV opj_create_compress(OPJ_CODEC_FORMAT format);
+
 /**
-Destroy a compressor handle
-@param cinfo compressor handle to destroy
+Destroy a decompressor handle
+@param dinfo decompressor handle to destroy
 */
-OPJ_API void OPJ_CALLCONV opj_destroy_compress(opj_cinfo_t *cinfo);
+OPJ_API void OPJ_CALLCONV opj_destroy_codec(opj_codec_t * p_codec);
+
 /**
 Set encoding parameters to default values, that means : 
 <ul>
@@ -873,13 +963,70 @@ Set encoding parameters to default values, that means :
 @param parameters Compression parameters
 */
 OPJ_API void OPJ_CALLCONV opj_set_default_encoder_parameters(opj_cparameters_t *parameters);
+
+/**
+ * Sets the MCT matrix to use.
+ * 
+ * @param	parameters		the parameters to change.
+ * @param	pEncodingMatrix	the encoding matrix.
+ * @param	p_dc_shift		the dc shift coefficients to use.
+ * @param	pNbComp			the number of components of the image.
+ *
+ * @return	true if the parameters could be set.
+ */
+OPJ_API bool OPJ_CALLCONV opj_set_MCT(opj_cparameters_t *parameters,OPJ_FLOAT32 * pEncodingMatrix,OPJ_INT32 * p_dc_shift,OPJ_UINT32 pNbComp);
+
+/**
+ * Restricts the decoding to the given image area.
+ * 
+ * @param	parameters		the parameters to update.
+ * @param	p_start_x		the starting x position of the area to decode.
+ * @param	p_start_y		the starting y position of the area to decode.
+ * @param	p_end_x			the x end position of the area to decode. 
+ * @param	p_end_x			the y end position of the area to decode.
+ */
+OPJ_API bool OPJ_CALLCONV opj_restrict_decoding (opj_dparameters_t *parameters,OPJ_INT32 p_start_x,OPJ_INT32 p_start_y,OPJ_INT32 p_end_x,OPJ_INT32 p_end_y);
+
+#ifdef USE_OPJ_DEPRECATED
+#ifdef _MSC_VER
+#pragma message ("warning, opj_setup_encoder is deprecated")
+#else
+#warning "warning, opj_setup_encoder is deprecated"
+#endif
 /**
 Setup the encoder parameters using the current image and using user parameters. 
 @param cinfo Compressor handle
 @param parameters Compression parameters
 @param image Input filled image
 */
-OPJ_API void OPJ_CALLCONV opj_setup_encoder(opj_cinfo_t *cinfo, opj_cparameters_t *parameters, opj_image_t *image);
+OPJ_API bool OPJ_CALLCONV opj_setup_encoder(opj_codec_t *cinfo, opj_cparameters_t *parameters, opj_image_t *image);
+#endif
+
+/**
+ * Decodes an image header.
+ * 
+ * @param	p_codec			codec to use to decode the image.
+ * @param	p_image			pointer to a previously created image.
+ * @param	p_tile_x0		pointer to a value that will hold the reference point x0 of the tiling grid.
+ * @param	p_tile_y0		pointer to a value that will hold the reference point y0 of the tiling grid.
+ * @param	p_tile_width	pointer to a value that will hold the size in x of a tile in the grid.
+ * @param	p_tile_height	pointer to a value that will hold the size in y of a tile in the grid.
+ * @param	p_nb_tiles_x	pointer to a value that will hold the number of tiles in the x direction.
+ * @param	p_nb_tiles_y	pointer to a value that will hold the number of tiles in the y direction.
+ */
+OPJ_API bool OPJ_CALLCONV opj_read_header (
+										opj_codec_t *p_codec,
+										opj_image_t ** p_image,
+										OPJ_INT32 * p_tile_x0,
+										OPJ_INT32 * p_tile_y0,
+										OPJ_UINT32 * p_tile_width,
+										OPJ_UINT32 * p_tile_height,
+										OPJ_UINT32 * p_nb_tiles_x,
+										OPJ_UINT32 * p_nb_tiles_y,
+										opj_stream_t *p_cio);
+
+
+OPJ_API bool OPJ_CALLCONV opj_end_decompress (opj_codec_t *p_codec,opj_stream_t *p_cio);
 /**
 Encode an image into a JPEG-2000 codestream
 @param cinfo compressor handle
@@ -888,7 +1035,11 @@ Encode an image into a JPEG-2000 codestream
 @param index Depreacted -> Set to NULL. To extract index, used opj_encode_wci()
 @return Returns true if successful, returns false otherwise
 */
-OPJ_API bool OPJ_CALLCONV opj_encode(opj_cinfo_t *cinfo, opj_cio_t *cio, opj_image_t *image, char *index);
+OPJ_API bool OPJ_CALLCONV opj_encode(opj_codec_t *cinfo, opj_stream_t * cio);
+
+OPJ_API bool OPJ_CALLCONV opj_start_compress (opj_codec_t *p_codec,opj_image_t * p_image,opj_stream_t *p_cio);
+
+OPJ_API bool OPJ_CALLCONV opj_end_compress (opj_codec_t *p_codec,opj_stream_t *p_cio);
 /**
 Encode an image into a JPEG-2000 codestream and extract the codestream information
 @param cinfo compressor handle
@@ -897,15 +1048,32 @@ Encode an image into a JPEG-2000 codestream and extract the codestream informati
 @param cstr_info Codestream information structure if needed afterwards, NULL otherwise
 @return Returns true if successful, returns false otherwise
 */
-OPJ_API bool OPJ_CALLCONV opj_encode_with_info(opj_cinfo_t *cinfo, opj_cio_t *cio, opj_image_t *image, opj_codestream_info_t *cstr_info);
+//OPJ_API bool OPJ_CALLCONV opj_encode_with_info(opj_cinfo_t *cinfo, opj_stream_t cio, opj_image_t *image, opj_codestream_info_t *cstr_info);
 /**
 Destroy Codestream information after compression or decompression
 @param cstr_info Codestream information structure
 */
 OPJ_API void OPJ_CALLCONV opj_destroy_cstr_info(opj_codestream_info_t *cstr_info);
 
+//==============================================================================
+//==============================================================================
+/** profiling part */
+#ifdef _PROFILE
+void _ProfInit(void);
+void _ProfPrint(void);
+#define PROFINIT() _ProfInit();
+#define PROFSAVE(file) _ProfSave(file);
+#define PROFPRINT() _ProfPrint();
+#else
+#define PROFINIT()
+#define PROFSAVE(file)
+#define PROFPRINT() 
+#endif // !_PROFILE
+
 #ifdef __cplusplus
 }
 #endif
 
 #endif /* OPENJPEG_H */
+
+