one more time

41 files changed, 14700 insertions, 0 deletions

diff --git a/libraries/openjpeg-libsl/libopenjpeg/bio.c b/libraries/openjpeg-libsl/libopenjpeg/bio.c
new file mode 100644
index 0000000..2a305a7
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/bio.c
@@ -0,0 +1,187 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "opj_includes.h"
+
+/** @defgroup BIO BIO - Individual bit input-output stream */
+/*@{*/
+
+/** @name Local static functions */
+/*@{*/
+
+/**
+Write a bit
+@param bio BIO handle
+@param b Bit to write (0 or 1)
+*/
+static void bio_putbit(opj_bio_t *bio, int b);
+/**
+Read a bit
+@param bio BIO handle
+@return Returns the read bit
+*/
+static int bio_getbit(opj_bio_t *bio);
+/**
+Write a byte
+@param bio BIO handle
+@return Returns 0 if successful, returns 1 otherwise
+*/
+static int bio_byteout(opj_bio_t *bio);
+/**
+Read a byte
+@param bio BIO handle
+@return Returns 0 if successful, returns 1 otherwise
+*/
+static int bio_bytein(opj_bio_t *bio);
+
+/*@}*/
+
+/*@}*/
+
+/* 
+==========================================================
+   local functions
+==========================================================
+*/
+
+static int bio_byteout(opj_bio_t *bio) {
+        bio->buf = (bio->buf << 8) & 0xffff;
+        bio->ct = bio->buf == 0xff00 ? 7 : 8;
+        if (bio->bp >= bio->end) {
+                return 1;
+        }
+        *bio->bp++ = bio->buf >> 8;
+        return 0;
+}
+
+static int bio_bytein(opj_bio_t *bio) {
+        bio->buf = (bio->buf << 8) & 0xffff;
+        bio->ct = bio->buf == 0xff00 ? 7 : 8;
+        if (bio->bp >= bio->end) {
+                return 1;
+        }
+        bio->buf |= *bio->bp++;
+        return 0;
+}
+
+static void bio_putbit(opj_bio_t *bio, int b) {
+        if (bio->ct == 0) {
+                bio_byteout(bio);
+        }
+        bio->ct--;
+        bio->buf |= b << bio->ct;
+}
+
+static int bio_getbit(opj_bio_t *bio) {
+        if (bio->ct == 0) {
+                bio_bytein(bio);
+        }
+        bio->ct--;
+        return (bio->buf >> bio->ct) & 1;
+}
+
+/* 
+==========================================================
+   Bit Input/Output interface
+==========================================================
+*/
+
+opj_bio_t* bio_create() {
+        opj_bio_t *bio = (opj_bio_t*)opj_malloc(sizeof(opj_bio_t));
+        return bio;
+}
+
+void bio_destroy(opj_bio_t *bio) {
+        if(bio) {
+                opj_free(bio);
+        }
+}
+
+int bio_numbytes(opj_bio_t *bio) {
+        return (bio->bp - bio->start);
+}
+
+void bio_init_enc(opj_bio_t *bio, unsigned char *bp, int len) {
+        bio->start = bp;
+        bio->end = bp + len;
+        bio->bp = bp;
+        bio->buf = 0;
+        bio->ct = 8;
+}
+
+void bio_init_dec(opj_bio_t *bio, unsigned char *bp, int len) {
+        bio->start = bp;
+        bio->end = bp + len;
+        bio->bp = bp;
+        bio->buf = 0;
+        bio->ct = 0;
+}
+
+void bio_write(opj_bio_t *bio, int v, int n) {
+        int i;
+        for (i = n - 1; i >= 0; i--) {
+                bio_putbit(bio, (v >> i) & 1);
+        }
+}
+
+int bio_read(opj_bio_t *bio, int n) {
+        int i, v;
+        v = 0;
+        for (i = n - 1; i >= 0; i--) {
+                v += bio_getbit(bio) << i;
+        }
+        return v;
+}
+
+int bio_flush(opj_bio_t *bio) {
+        bio->ct = 0;
+        if (bio_byteout(bio)) {
+                return 1;
+        }
+        if (bio->ct == 7) {
+                bio->ct = 0;
+                if (bio_byteout(bio)) {
+                        return 1;
+                }
+        }
+        return 0;
+}
+
+int bio_inalign(opj_bio_t *bio) {
+        bio->ct = 0;
+        if ((bio->buf & 0xff) == 0xff) {
+                if (bio_bytein(bio)) {
+                        return 1;
+                }
+                bio->ct = 0;
+        }
+        return 0;
+}
diff --git a/libraries/openjpeg-libsl/libopenjpeg/bio.h b/libraries/openjpeg-libsl/libopenjpeg/bio.h
new file mode 100644
index 0000000..d0a809c
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/bio.h
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __BIO_H
+#define __BIO_H
+/** 
+@file bio.h
+@brief Implementation of an individual bit input-output (BIO)
+
+The functions in BIO.C have for goal to realize an individual bit input - output.
+*/
+
+/** @defgroup BIO BIO - Individual bit input-output stream */
+/*@{*/
+
+/**
+Individual bit input-output stream (BIO)
+*/
+typedef struct opj_bio {
+        /** pointer to the start of the buffer */
+        unsigned char *start;
+        /** pointer to the end of the buffer */
+        unsigned char *end;
+        /** pointer to the present position in the buffer */
+        unsigned char *bp;
+        /** temporary place where each byte is read or written */
+        unsigned int buf;
+        /** coder : number of bits free to write. decoder : number of bits read */
+        int ct;
+} opj_bio_t;
+
+/** @name Exported functions */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+/**
+Create a new BIO handle 
+@return Returns a new BIO handle if successful, returns NULL otherwise
+*/
+opj_bio_t* bio_create();
+/**
+Destroy a previously created BIO handle
+@param bio BIO handle to destroy
+*/
+void bio_destroy(opj_bio_t *bio);
+/**
+Number of bytes written.
+@param bio BIO handle
+@return Returns the number of bytes written
+*/
+int bio_numbytes(opj_bio_t *bio);
+/**
+Init encoder
+@param bio BIO handle
+@param bp Output buffer
+@param len Output buffer length 
+*/
+void bio_init_enc(opj_bio_t *bio, unsigned char *bp, int len);
+/**
+Init decoder
+@param bio BIO handle
+@param bp Input buffer
+@param len Input buffer length 
+*/
+void bio_init_dec(opj_bio_t *bio, unsigned char *bp, int len);
+/**
+Write bits
+@param bio BIO handle
+@param v Value of bits
+@param n Number of bits to write
+*/
+void bio_write(opj_bio_t *bio, int v, int n);
+/**
+Read bits
+@param bio BIO handle
+@param n Number of bits to read 
+@return Returns the corresponding read number
+*/
+int bio_read(opj_bio_t *bio, int n);
+/**
+Flush bits
+@param bio BIO handle
+@return Returns 1 if successful, returns 0 otherwise
+*/
+int bio_flush(opj_bio_t *bio);
+/**
+Passes the ending bits (coming from flushing)
+@param bio BIO handle
+@return Returns 1 if successful, returns 0 otherwise
+*/
+int bio_inalign(opj_bio_t *bio);
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __BIO_H */
+
diff --git a/libraries/openjpeg-libsl/libopenjpeg/cio.c b/libraries/openjpeg-libsl/libopenjpeg/cio.c
new file mode 100644
index 0000000..6082e9b
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/cio.c
@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "opj_includes.h"
+
+/* ----------------------------------------------------------------------- */
+
+opj_cio_t* OPJ_CALLCONV opj_cio_open(opj_common_ptr cinfo, unsigned char *buffer, int length) {
+        opj_cp_t *cp = NULL;
+        opj_cio_t *cio = (opj_cio_t*)opj_malloc(sizeof(opj_cio_t));
+        if(!cio) return NULL;
+        cio->cinfo = cinfo;
+        if(buffer && length) {
+                /* wrap a user buffer containing the encoded image */
+                cio->openmode = OPJ_STREAM_READ;
+                cio->buffer = buffer;
+                cio->length = length;
+        }
+        else if(!buffer && !length && cinfo) {
+                /* allocate a buffer for the encoded image */
+                cio->openmode = OPJ_STREAM_WRITE;
+                switch(cinfo->codec_format) {
+                        case CODEC_J2K:
+                                cp = ((opj_j2k_t*)cinfo->j2k_handle)->cp;
+                                break;
+                        case CODEC_JP2:
+                                cp = ((opj_jp2_t*)cinfo->jp2_handle)->j2k->cp;
+                                break;
+                        default:
+                                opj_free(cio);
+                                return NULL;
+                }
+                cio->length = (int) (1.3 * cp->img_size);
+                cio->buffer = (unsigned char *)opj_malloc(cio->length);
+                if(!cio->buffer) {
+                        opj_free(cio);
+                        return NULL;
+                }
+        }
+        else {
+                opj_free(cio);
+                return NULL;
+        }
+
+        /* Initialize byte IO */
+        cio->start = cio->buffer;
+        cio->end = cio->buffer + cio->length;
+        cio->bp = cio->buffer;
+
+        return cio;
+}
+
+void OPJ_CALLCONV opj_cio_close(opj_cio_t *cio) {
+        if(cio) {
+                if(cio->openmode == OPJ_STREAM_WRITE) {
+                        /* destroy the allocated buffer */
+                        opj_free(cio->buffer);
+                }
+                /* destroy the cio */
+                opj_free(cio);
+        }
+}
+
+
+/* ----------------------------------------------------------------------- */
+
+/*
+ * Get position in byte stream.
+ */
+int OPJ_CALLCONV cio_tell(opj_cio_t *cio) {
+        return cio->bp - cio->start;
+}
+
+/*
+ * Set position in byte stream.
+ *
+ * pos : position, in number of bytes, from the beginning of the stream
+ */
+void OPJ_CALLCONV cio_seek(opj_cio_t *cio, int pos) {
+        cio->bp = cio->start + pos;
+}
+
+/*
+ * Number of bytes left before the end of the stream.
+ */
+int cio_numbytesleft(opj_cio_t *cio) {
+        return cio->end - cio->bp;
+}
+
+/*
+ * Get pointer to the current position in the stream.
+ */
+unsigned char *cio_getbp(opj_cio_t *cio) {
+        return cio->bp;
+}
+
+/*
+ * Write a byte.
+ */
+bool cio_byteout(opj_cio_t *cio, unsigned char v) {
+        if (cio->bp >= cio->end) {
+                opj_event_msg(cio->cinfo, EVT_ERROR, "write error\n");
+                return false;
+        }
+        *cio->bp++ = v;
+        return true;
+}
+
+/*
+ * Read a byte.
+ */
+unsigned char cio_bytein(opj_cio_t *cio) {
+        if (cio->bp >= cio->end) {
+                opj_event_msg(cio->cinfo, EVT_ERROR, "read error\n");
+                return 0;
+        }
+        return *cio->bp++;
+}
+
+/*
+ * Write some bytes.
+ *
+ * v : value to write
+ * n : number of bytes to write
+ */
+unsigned int cio_write(opj_cio_t *cio, unsigned int v, int n) {
+        int i;
+        for (i = n - 1; i >= 0; i--) {
+                if( !cio_byteout(cio, (unsigned char) ((v >> (i << 3)) & 0xff)) )
+                        return 0;
+        }
+        return n;
+}
+
+/*
+ * Read some bytes.
+ *
+ * n : number of bytes to read
+ *
+ * return : value of the n bytes read
+ */
+unsigned int cio_read(opj_cio_t *cio, int n) {
+        int i;
+        unsigned int v;
+        v = 0;
+        for (i = n - 1; i >= 0; i--) {
+                v += cio_bytein(cio) << (i << 3);
+        }
+        return v;
+}
+
+/* 
+ * Skip some bytes.
+ *
+ * n : number of bytes to skip
+ */
+void cio_skip(opj_cio_t *cio, int n) {
+        cio->bp += n;
+}
+
+
+
diff --git a/libraries/openjpeg-libsl/libopenjpeg/cio.h b/libraries/openjpeg-libsl/libopenjpeg/cio.h
new file mode 100644
index 0000000..580bf9c
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/cio.h
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __CIO_H
+#define __CIO_H
+/**
+@file cio.h
+@brief Implementation of a byte input-output process (CIO)
+
+The functions in CIO.C have for goal to realize a byte input / output process.
+*/
+
+/** @defgroup CIO CIO - byte input-output stream */
+/*@{*/
+
+/** @name Exported functions (see also openjpeg.h) */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+/**
+Number of bytes left before the end of the stream
+@param cio CIO handle
+@return Returns the number of bytes before the end of the stream
+*/
+int cio_numbytesleft(opj_cio_t *cio);
+/**
+Get pointer to the current position in the stream
+@param cio CIO handle
+@return Returns a pointer to the current position
+*/
+unsigned char *cio_getbp(opj_cio_t *cio);
+/**
+Write some bytes
+@param cio CIO handle
+@param v Value to write
+@param n Number of bytes to write
+@return Returns the number of bytes written or 0 if an error occured
+*/
+unsigned int cio_write(opj_cio_t *cio, unsigned int v, int n);
+/**
+Read some bytes
+@param cio CIO handle
+@param n Number of bytes to read
+@return Returns the value of the n bytes read
+*/
+unsigned int cio_read(opj_cio_t *cio, int n);
+/**
+Skip some bytes
+@param cio CIO handle
+@param n Number of bytes to skip
+*/
+void cio_skip(opj_cio_t *cio, int n);
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __CIO_H */
+
diff --git a/libraries/openjpeg-libsl/libopenjpeg/dwt.c b/libraries/openjpeg-libsl/libopenjpeg/dwt.c
new file mode 100644
index 0000000..d10de18
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/dwt.c
@@ -0,0 +1,661 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+#include "opj_includes.h"
+
+/** @defgroup DWT DWT - Implementation of a discrete wavelet transform */
+/*@{*/
+
+#define WS(i) v->mem[(i)*2]
+#define WD(i) v->mem[(1+(i)*2)]
+
+/** @name Local data structures */
+/*@{*/
+
+typedef struct dwt_local{
+        int *   mem ;
+        int             dn ;
+        int             sn ;
+        int             cas ;
+        } dwt_t ; 
+
+/*@}*/
+
+/**
+Virtual function type for wavelet transform in 1-D 
+*/
+typedef void (*DWT1DFN)(dwt_t* v);
+
+/** @name Local static functions */
+/*@{*/
+
+/**
+Forward lazy transform (horizontal)
+*/
+static void dwt_deinterleave_h(int *a, int *b, int dn, int sn, int cas);
+/**
+Forward lazy transform (vertical)
+*/
+static void dwt_deinterleave_v(int *a, int *b, int dn, int sn, int x, int cas);
+/**
+Inverse lazy transform (horizontal)
+*/
+static void dwt_interleave_h(dwt_t* h, int *a);
+/**
+Inverse lazy transform (vertical)
+*/
+static void dwt_interleave_v(dwt_t* v, int *a, int x);
+/**
+Forward 5-3 wavelet tranform in 1-D
+*/
+static void dwt_encode_1(int *a, int dn, int sn, int cas);
+/**
+Inverse 5-3 wavelet tranform in 1-D
+*/
+static void dwt_decode_1(dwt_t *v);
+/**
+Forward 9-7 wavelet transform in 1-D
+*/
+static void dwt_encode_1_real(int *a, int dn, int sn, int cas);
+/**
+Inverse 9-7 wavelet transform in 1-D
+*/
+static void dwt_decode_1_real(dwt_t *v);
+/**
+FIXME : comment ???
+*/
+static void dwt_encode_stepsize(int stepsize, int numbps, opj_stepsize_t *bandno_stepsize);
+/**
+Inverse wavelet tranform in 2-D.
+*/
+static void dwt_decode_tile(opj_tcd_tilecomp_t * tilec, int stop , DWT1DFN fn);
+
+/*@}*/
+
+/*@}*/
+
+#define S(i) a[(i)*2]
+#define D(i) a[(1+(i)*2)]
+#define S_(i) ((i)<0?S(0):((i)>=sn?S(sn-1):S(i)))
+#define D_(i) ((i)<0?D(0):((i)>=dn?D(dn-1):D(i)))
+/* new */
+#define SS_(i) ((i)<0?S(0):((i)>=dn?S(dn-1):S(i)))
+#define DD_(i) ((i)<0?D(0):((i)>=sn?D(sn-1):D(i)))
+
+/* <summary>                                                              */
+/* This table contains the norms of the 5-3 wavelets for different bands. */
+/* </summary>                                                             */
+static const double dwt_norms[4][10] = {
+        {1.000, 1.500, 2.750, 5.375, 10.68, 21.34, 42.67, 85.33, 170.7, 341.3},
+        {1.038, 1.592, 2.919, 5.703, 11.33, 22.64, 45.25, 90.48, 180.9},
+        {1.038, 1.592, 2.919, 5.703, 11.33, 22.64, 45.25, 90.48, 180.9},
+        {.7186, .9218, 1.586, 3.043, 6.019, 12.01, 24.00, 47.97, 95.93}
+};
+
+/* <summary>                                                              */
+/* This table contains the norms of the 9-7 wavelets for different bands. */
+/* </summary>                                                             */
+static const double dwt_norms_real[4][10] = {
+        {1.000, 1.965, 4.177, 8.403, 16.90, 33.84, 67.69, 135.3, 270.6, 540.9},
+        {2.022, 3.989, 8.355, 17.04, 34.27, 68.63, 137.3, 274.6, 549.0},
+        {2.022, 3.989, 8.355, 17.04, 34.27, 68.63, 137.3, 274.6, 549.0},
+        {2.080, 3.865, 8.307, 17.18, 34.71, 69.59, 139.3, 278.6, 557.2}
+};
+
+/* 
+==========================================================
+   local functions
+==========================================================
+*/
+
+/* <summary>                                     */
+/* Forward lazy transform (horizontal).  */
+/* </summary>                            */ 
+static void dwt_deinterleave_h(int *a, int *b, int dn, int sn, int cas) {
+        int i;
+    for (i=0; i<sn; i++) b[i]=a[2*i+cas];
+    for (i=0; i<dn; i++) b[sn+i]=a[(2*i+1-cas)];
+}
+
+/* <summary>                             */  
+/* Forward lazy transform (vertical).    */
+/* </summary>                            */ 
+static void dwt_deinterleave_v(int *a, int *b, int dn, int sn, int x, int cas) {
+    int i;
+    for (i=0; i<sn; i++) b[i*x]=a[2*i+cas];
+    for (i=0; i<dn; i++) b[(sn+i)*x]=a[(2*i+1-cas)];
+}
+
+/* <summary>                             */
+/* Inverse lazy transform (horizontal).  */
+/* </summary>                            */
+static void dwt_interleave_h(dwt_t* h, int *a) {
+    int *ai = a;
+    int *bi = h->mem + h->cas;
+    int  i      = h->sn;
+    while( i-- ) {
+      *bi = *(ai++);
+          bi += 2;
+    }
+    ai  = a + h->sn;
+    bi  = h->mem + 1 - h->cas;
+    i   = h->dn ;
+    while( i-- ) {
+      *bi = *(ai++);
+          bi += 2;
+    }
+}
+
+/* <summary>                             */  
+/* Inverse lazy transform (vertical).    */
+/* </summary>                            */ 
+static void dwt_interleave_v(dwt_t* v, int *a, int x) {
+    int *ai = a;
+    int *bi = v->mem + v->cas;
+    int  i = v->sn;
+    while( i-- ) {
+      *bi = *ai;
+          bi += 2;
+          ai += x;
+    }
+    ai = a + (v->sn * x);
+    bi = v->mem + 1 - v->cas;
+    i = v->dn ;
+    while( i-- ) {
+      *bi = *ai;
+          bi += 2;  
+          ai += x;
+    }
+}
+
+
+/* <summary>                            */
+/* Forward 5-3 wavelet tranform in 1-D. */
+/* </summary>                           */
+static void dwt_encode_1(int *a, int dn, int sn, int cas) {
+        int i;
+        
+        if (!cas) {
+                if ((dn > 0) || (sn > 1)) {     /* NEW :  CASE ONE ELEMENT */
+                        for (i = 0; i < dn; i++) D(i) -= (S_(i) + S_(i + 1)) >> 1;
+                        for (i = 0; i < sn; i++) S(i) += (D_(i - 1) + D_(i) + 2) >> 2;
+                }
+        } else {
+                if (!sn && dn == 1)                 /* NEW :  CASE ONE ELEMENT */
+                        S(0) *= 2;
+                else {
+                        for (i = 0; i < dn; i++) S(i) -= (DD_(i) + DD_(i - 1)) >> 1;
+                        for (i = 0; i < sn; i++) D(i) += (SS_(i) + SS_(i + 1) + 2) >> 2;
+                }
+        }
+}
+
+/* <summary>                            */
+/* Inverse 5-3 wavelet tranform in 1-D. */
+/* </summary>                           */ 
+static void dwt_decode_1_(int *a, int dn, int sn, int cas) {
+        int i;
+        
+        if (!cas) {
+                if ((dn > 0) || (sn > 1)) { /* NEW :  CASE ONE ELEMENT */
+                        for (i = 0; i < sn; i++) S(i) -= (D_(i - 1) + D_(i) + 2) >> 2;
+                        for (i = 0; i < dn; i++) D(i) += (S_(i) + S_(i + 1)) >> 1;
+                }
+        } else {
+                if (!sn  && dn == 1)          /* NEW :  CASE ONE ELEMENT */
+                        S(0) /= 2;
+                else {
+                        for (i = 0; i < sn; i++) D(i) -= (SS_(i) + SS_(i + 1) + 2) >> 2;
+                        for (i = 0; i < dn; i++) S(i) += (DD_(i) + DD_(i - 1)) >> 1;
+                }
+        }
+}
+
+/* <summary>                            */
+/* Inverse 5-3 wavelet tranform in 1-D. */
+/* </summary>                           */ 
+static void dwt_decode_1(dwt_t *v) {
+        dwt_decode_1_(v->mem, v->dn, v->sn, v->cas);
+}
+
+/* <summary>                             */
+/* Forward 9-7 wavelet transform in 1-D. */
+/* </summary>                            */
+static void dwt_encode_1_real(int *a, int dn, int sn, int cas) {
+        int i;
+        if (!cas) {
+                if ((dn > 0) || (sn > 1)) {     /* NEW :  CASE ONE ELEMENT */
+                        for (i = 0; i < dn; i++)
+                                D(i) -= fix_mul(S_(i) + S_(i + 1), 12993);
+                        for (i = 0; i < sn; i++)
+                                S(i) -= fix_mul(D_(i - 1) + D_(i), 434);
+                        for (i = 0; i < dn; i++)
+                                D(i) += fix_mul(S_(i) + S_(i + 1), 7233);
+                        for (i = 0; i < sn; i++)
+                                S(i) += fix_mul(D_(i - 1) + D_(i), 3633);
+                        for (i = 0; i < dn; i++)
+                                D(i) = fix_mul(D(i), 5038);     /*5038 */
+                        for (i = 0; i < sn; i++)
+                                S(i) = fix_mul(S(i), 6659);     /*6660 */
+                }
+        } else {
+                if ((sn > 0) || (dn > 1)) {     /* NEW :  CASE ONE ELEMENT */
+                        for (i = 0; i < dn; i++)
+                                S(i) -= fix_mul(DD_(i) + DD_(i - 1), 12993);
+                        for (i = 0; i < sn; i++)
+                                D(i) -= fix_mul(SS_(i) + SS_(i + 1), 434);
+                        for (i = 0; i < dn; i++)
+                                S(i) += fix_mul(DD_(i) + DD_(i - 1), 7233);
+                        for (i = 0; i < sn; i++)
+                                D(i) += fix_mul(SS_(i) + SS_(i + 1), 3633);
+                        for (i = 0; i < dn; i++)
+                                S(i) = fix_mul(S(i), 5038);     /*5038 */
+                        for (i = 0; i < sn; i++)
+                                D(i) = fix_mul(D(i), 6659);     /*6660 */
+                }
+        }
+}
+
+static void dwt_decode_sm(dwt_t* v, int k, int n, int x) {
+        int m = k > n ? n : k;
+        int l = v->mem[1];                      //D(0);
+        int j;
+        int i;
+        for (i = 0; i < m; i++) {
+                j = l;
+                WS(i) -= fix_mul( ( l = WD(i) ) + j , x);
+        }
+        if( i < k ) {
+                l = fix_mul( l + l , x );
+                for (; i < k; i++)
+                        WS(i) -= l;
+        }
+}
+
+static void dwt_decode_sp(dwt_t* v, int k, int n, int x) {
+        int m = k > n ? n : k;
+        int l = v->mem[1];                      //D(0);
+        int j;
+        int i;
+        for (i = 0; i < m; i++) {
+                j = l;
+                WS(i) += fix_mul( ( l = WD(i) ) + j , x);
+        }
+        if( i < k ) {
+                l = fix_mul( l + l , x );
+                for (; i < k; i++)
+                        WS(i) += l;
+        }
+}
+
+static void dwt_decode_dm(dwt_t* v, int k, int n, int x) {
+        int m = k >= n ? n-1 : k;
+        int l = v->mem[0];                              //S(0);
+        int i;
+        int j;
+        for (i = 0; i < m; i++) {
+                j = l;
+                WD(i) -=  fix_mul( ( l = WS(i+1) ) + j , x);
+        }
+        if( i < k ) {
+                l = fix_mul( l + l , x );
+                for (; i < k; i++)
+                        WD(i) -= l;
+        }
+}
+
+static void dwt_decode_dp(dwt_t* v, int k, int n, int x) {
+        int m = k >= n ? n-1 : k;
+        int l = v->mem[0];                              //S(0);
+        int i;
+        int j;
+        for (i = 0; i < m; i++) {
+                j = l;
+                WD(i) +=  fix_mul( ( l = WS(i+1) ) + j , x);
+        }
+
+        if( i < k ) {
+                l = fix_mul( l + l , x );
+                for (; i < k; i++)
+                        WD(i) += l;
+        }
+}
+
+
+/* <summary>                             */
+/* Inverse 9-7 wavelet transform in 1-D. */
+/* </summary>                            */
+static void dwt_decode_1_real(dwt_t* v) {
+        int i;
+        if (!v->cas) {
+                if ((v->dn > 0) || (v->sn > 1)) {       /* NEW :  CASE ONE ELEMENT */
+                        for (i = 0; i < v->sn; i++)
+                                WS(i) = fix_mul(WS(i), 10078);  /* 10076 */
+                        for (i = 0; i < v->dn; i++)
+                                WD(i) = fix_mul(WD(i), 13318);  /* 13320 */
+                        dwt_decode_sm(v, v->sn, v->dn, 3633);
+                        dwt_decode_dm(v, v->dn, v->sn, 7233);
+                        dwt_decode_sp(v, v->sn, v->dn, 434);
+                        dwt_decode_dp(v, v->dn, v->sn, 12994);
+                }
+        } else {
+                if ((v->sn > 0) || (v->dn > 1)) {       /* NEW :  CASE ONE ELEMENT */
+                        for (i = 0; i < v->sn; i++)
+                                WD(i) = fix_mul(WD(i), 10078);  /* 10076 */
+                        for (i = 0; i < v->dn; i++)
+                                WS(i) = fix_mul(WS(i), 13318);  /* 13320 */
+                        dwt_decode_dm(v, v->sn, v->dn, 3633);
+                        dwt_decode_sm(v, v->dn, v->sn, 7233);
+                        dwt_decode_dp(v, v->sn, v->dn, 434);
+                        dwt_decode_sp(v, v->dn, v->sn, 12994);
+                }
+        }
+}
+
+static void dwt_encode_stepsize(int stepsize, int numbps, opj_stepsize_t *bandno_stepsize) {
+        int p, n;
+        p = int_floorlog2(stepsize) - 13;
+        n = 11 - int_floorlog2(stepsize);
+        bandno_stepsize->mant = (n < 0 ? stepsize >> -n : stepsize << n) & 0x7ff;
+        bandno_stepsize->expn = numbps - p;
+}
+
+/* 
+==========================================================
+   DWT interface
+==========================================================
+*/
+
+/* <summary>                            */
+/* Forward 5-3 wavelet tranform in 2-D. */
+/* </summary>                           */
+void dwt_encode(opj_tcd_tilecomp_t * tilec) {
+        int i, j, k;
+        int *a = NULL;
+        int *aj = NULL;
+        int *bj = NULL;
+        int w, l;
+        
+        w = tilec->x1-tilec->x0;
+        l = tilec->numresolutions-1;
+        a = tilec->data;
+        
+        for (i = 0; i < l; i++) {
+                int rw;                 /* width of the resolution level computed                                                           */
+                int rh;                 /* heigth of the resolution level computed                                                          */
+                int rw1;                /* width of the resolution level once lower than computed one                                       */
+                int rh1;                /* height of the resolution level once lower than computed one                                      */
+                int cas_col;    /* 0 = non inversion on horizontal filtering 1 = inversion between low-pass and high-pass filtering */
+                int cas_row;    /* 0 = non inversion on vertical filtering 1 = inversion between low-pass and high-pass filtering   */
+                int dn, sn;
+                
+                rw = tilec->resolutions[l - i].x1 - tilec->resolutions[l - i].x0;
+                rh = tilec->resolutions[l - i].y1 - tilec->resolutions[l - i].y0;
+                rw1= tilec->resolutions[l - i - 1].x1 - tilec->resolutions[l - i - 1].x0;
+                rh1= tilec->resolutions[l - i - 1].y1 - tilec->resolutions[l - i - 1].y0;
+                
+                cas_row = tilec->resolutions[l - i].x0 % 2;
+                cas_col = tilec->resolutions[l - i].y0 % 2;
+        
+                sn = rh1;
+                dn = rh - rh1;
+                bj = (int*)opj_malloc(rh * sizeof(int));
+                for (j = 0; j < rw; j++) {
+                        aj = a + j;
+                        for (k = 0; k < rh; k++)  bj[k] = aj[k*w];
+                        dwt_encode_1(bj, dn, sn, cas_col);
+                        dwt_deinterleave_v(bj, aj, dn, sn, w, cas_col);
+                }
+                opj_free(bj);
+                
+                sn = rw1;
+                dn = rw - rw1;
+                bj = (int*)opj_malloc(rw * sizeof(int));
+                for (j = 0; j < rh; j++) {
+                        aj = a + j * w;
+                        for (k = 0; k < rw; k++)  bj[k] = aj[k];
+                        dwt_encode_1(bj, dn, sn, cas_row);
+                        dwt_deinterleave_h(bj, aj, dn, sn, cas_row);
+                }
+                opj_free(bj);
+        }
+}
+
+
+/* <summary>                            */
+/* Inverse 5-3 wavelet tranform in 2-D. */
+/* </summary>                           */
+void dwt_decode(opj_tcd_tilecomp_t * tilec, int stop) {
+        dwt_decode_tile(tilec, stop, &dwt_decode_1);
+}
+
+
+/* <summary>                          */
+/* Get gain of 5-3 wavelet transform. */
+/* </summary>                         */
+int dwt_getgain(int orient) {
+        if (orient == 0)
+                return 0;
+        if (orient == 1 || orient == 2)
+                return 1;
+        return 2;
+}
+
+/* <summary>                */
+/* Get norm of 5-3 wavelet. */
+/* </summary>               */
+double dwt_getnorm(int level, int orient) {
+        return dwt_norms[orient][level];
+}
+
+/* <summary>                             */
+/* Forward 9-7 wavelet transform in 2-D. */
+/* </summary>                            */
+
+void dwt_encode_real(opj_tcd_tilecomp_t * tilec) {
+        int i, j, k;
+        int *a = NULL;
+        int *aj = NULL;
+        int *bj = NULL;
+        int w, l;
+        
+        w = tilec->x1-tilec->x0;
+        l = tilec->numresolutions-1;
+        a = tilec->data;
+        
+        for (i = 0; i < l; i++) {
+                int rw;                 /* width of the resolution level computed                                                     */
+                int rh;                 /* heigth of the resolution level computed                                                    */
+                int rw1;                /* width of the resolution level once lower than computed one                                 */
+                int rh1;                /* height of the resolution level once lower than computed one                                */
+                int cas_col;    /* 0 = non inversion on horizontal filtering 1 = inversion between low-pass and high-pass filtering */
+                int cas_row;    /* 0 = non inversion on vertical filtering 1 = inversion between low-pass and high-pass filtering   */
+                int dn, sn;
+                
+                rw = tilec->resolutions[l - i].x1 - tilec->resolutions[l - i].x0;
+                rh = tilec->resolutions[l - i].y1 - tilec->resolutions[l - i].y0;
+                rw1= tilec->resolutions[l - i - 1].x1 - tilec->resolutions[l - i - 1].x0;
+                rh1= tilec->resolutions[l - i - 1].y1 - tilec->resolutions[l - i - 1].y0;
+                
+                cas_row = tilec->resolutions[l - i].x0 % 2;
+                cas_col = tilec->resolutions[l - i].y0 % 2;
+                
+                sn = rh1;
+                dn = rh - rh1;
+                bj = (int*)opj_malloc(rh * sizeof(int));
+                for (j = 0; j < rw; j++) {
+                        aj = a + j;
+                        for (k = 0; k < rh; k++)  bj[k] = aj[k*w];
+                        dwt_encode_1_real(bj, dn, sn, cas_col);
+                        dwt_deinterleave_v(bj, aj, dn, sn, w, cas_col);
+                }
+                opj_free(bj);
+                
+                sn = rw1;
+                dn = rw - rw1;
+                bj = (int*)opj_malloc(rw * sizeof(int));
+                for (j = 0; j < rh; j++) {
+                        aj = a + j * w;
+                        for (k = 0; k < rw; k++)  bj[k] = aj[k];
+                        dwt_encode_1_real(bj, dn, sn, cas_row);
+                        dwt_deinterleave_h(bj, aj, dn, sn, cas_row);
+                }
+                opj_free(bj);
+        }
+}
+
+
+/* <summary>                             */
+/* Inverse 9-7 wavelet transform in 2-D. */
+/* </summary>                            */
+void dwt_decode_real(opj_tcd_tilecomp_t * tilec, int stop) {
+        dwt_decode_tile(tilec, stop, dwt_decode_1_real);
+}
+
+
+/* <summary>                          */
+/* Get gain of 9-7 wavelet transform. */
+/* </summary>                         */
+int dwt_getgain_real(int orient) {
+        (void)orient;
+        return 0;
+}
+
+/* <summary>                */
+/* Get norm of 9-7 wavelet. */
+/* </summary>               */
+double dwt_getnorm_real(int level, int orient) {
+        return dwt_norms_real[orient][level];
+}
+
+void dwt_calc_explicit_stepsizes(opj_tccp_t * tccp, int prec) {
+        int numbands, bandno;
+        numbands = 3 * tccp->numresolutions - 2;
+        for (bandno = 0; bandno < numbands; bandno++) {
+                double stepsize;
+                int resno, level, orient, gain;
+
+                resno = (bandno == 0) ? 0 : ((bandno - 1) / 3 + 1);
+                orient = (bandno == 0) ? 0 : ((bandno - 1) % 3 + 1);
+                level = tccp->numresolutions - 1 - resno;
+                gain = (tccp->qmfbid == 0) ? 0 : ((orient == 0) ? 0 : (((orient == 1) || (orient == 2)) ? 1 : 2));
+                if (tccp->qntsty == J2K_CCP_QNTSTY_NOQNT) {
+                        stepsize = 1.0;
+                } else {
+                        double norm = dwt_norms_real[orient][level];
+                        stepsize = (1 << (gain)) / norm;
+                }
+                dwt_encode_stepsize((int) floor(stepsize * 8192.0), prec + gain, &tccp->stepsizes[bandno]);
+        }
+}
+
+
+/* <summary>                             */
+/* Determine maximum computed resolution level for inverse wavelet transform */
+/* </summary>                            */
+static int dwt_decode_max_resolution(opj_tcd_resolution_t* r, int i) {
+        int mr  = 1;
+        int w;
+        while( --i ) {
+                r++;
+                if( mr < ( w = r->x1 - r->x0 ) )
+                        mr = w ;
+                if( mr < ( w = r->y1 - r->y0 ) )
+                        mr = w ;
+        }
+        return mr ;
+}
+
+
+/* <summary>                            */
+/* Inverse wavelet tranform in 2-D.     */
+/* </summary>                           */
+static void dwt_decode_tile(opj_tcd_tilecomp_t * tilec, int stop, DWT1DFN dwt_1D) {
+        opj_tcd_resolution_t* tr;
+        int i, j, k;
+        int *a = NULL;
+        int *aj = NULL;
+        int *m;
+        int w; //, l;
+        int rw;                 /* width of the resolution level computed  */
+        int rh;                 /* heigth of the resolution level computed  */
+        dwt_t h;
+        dwt_t v;
+        
+        if( 1 > ( i = tilec->numresolutions - stop ) )
+                return ;
+
+        tr = tilec->resolutions;
+
+        w = tilec->x1-tilec->x0;
+        a = tilec->data;
+
+        m = (int*)opj_malloc(sizeof(int) * (dwt_decode_max_resolution(tr, i)+5));
+        h.mem = v.mem = (int*)( (unsigned)m + 16 - ( (unsigned)m % 16 ) ) ;
+
+        rw = tr->x1 - tr->x0;
+        rh = tr->y1 - tr->y0;
+
+        while( --i ) {
+                tr++;
+                h.sn = rw;
+                v.sn = rh;
+                h.dn = ( rw = tr->x1 - tr->x0 ) - h.sn;
+                v.dn = ( rh = tr->y1 - tr->y0 ) - v.sn;
+                                
+                h.cas = tr->x0 % 2;
+                v.cas = tr->y0 % 2;
+
+                aj = a;
+                j = rh;
+                while( j-- ) {          
+                        dwt_interleave_h(&h, aj);
+                        (dwt_1D)(&h);
+                        k = rw;
+                        while( k-- )
+                                aj[k] = h.mem[k];
+                        aj += w;
+                }
+
+                aj = a;
+                j = rw;
+                while( j-- ) {
+                        dwt_interleave_v(&v, aj, w);
+                        (dwt_1D)(&v);
+                        k = rh;
+                        while( k-- )
+                                aj[k * w] = v.mem[k];
+                        aj++;
+                }
+        }
+        opj_free(m);
+}
diff --git a/libraries/openjpeg-libsl/libopenjpeg/dwt.h b/libraries/openjpeg-libsl/libopenjpeg/dwt.h
new file mode 100644
index 0000000..5c95c76
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/dwt.h
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DWT_H
+#define __DWT_H
+/**
+@file dwt.h
+@brief Implementation of a discrete wavelet transform (DWT)
+
+The functions in DWT.C have for goal to realize forward and inverse discret wavelet
+transform with filter 5-3 (reversible) and filter 9-7 (irreversible). The functions in
+DWT.C are used by some function in TCD.C.
+*/
+
+/** @defgroup DWT DWT - Implementation of a discrete wavelet transform */
+/*@{*/
+
+
+/** @name Exported functions */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+/**
+Forward 5-3 wavelet tranform in 2-D. 
+Apply a reversible DWT transform to a component of an image.
+@param tilec Tile component information (current tile)
+*/
+void dwt_encode(opj_tcd_tilecomp_t * tilec);
+/**
+Inverse 5-3 wavelet tranform in 2-D.
+Apply a reversible inverse DWT transform to a component of an image.
+@param tilec Tile component information (current tile)
+@param stop FIXME Number of decoded resolution levels ?
+*/
+void dwt_decode(opj_tcd_tilecomp_t * tilec, int stop);
+/**
+Get the gain of a subband for the reversible 5-3 DWT.
+@param orient Number that identifies the subband (0->LL, 1->HL, 2->LH, 3->HH)
+@return Returns 0 if orient = 0, returns 1 if orient = 1 or 2, returns 2 otherwise
+*/
+int dwt_getgain(int orient);
+/**
+Get the norm of a wavelet function of a subband at a specified level for the reversible 5-3 DWT.
+@param level Level of the wavelet function
+@param orient Band of the wavelet function
+@return Returns the norm of the wavelet function
+*/
+double dwt_getnorm(int level, int orient);
+/**
+Forward 9-7 wavelet transform in 2-D. 
+Apply an irreversible DWT transform to a component of an image.
+@param tilec Tile component information (current tile)
+*/
+void dwt_encode_real(opj_tcd_tilecomp_t * tilec);
+/**
+Inverse 9-7 wavelet transform in 2-D. 
+Apply an irreversible inverse DWT transform to a component of an image.
+@param tilec Tile component information (current tile)
+@param stop FIXME Number of decoded resolution levels ?
+*/
+void dwt_decode_real(opj_tcd_tilecomp_t * tilec, int stop);
+/**
+Get the gain of a subband for the irreversible 9-7 DWT.
+@param orient Number that identifies the subband (0->LL, 1->HL, 2->LH, 3->HH)
+@return Returns the gain of the 9-7 wavelet transform
+*/
+int dwt_getgain_real(int orient);
+/**
+Get the norm of a wavelet function of a subband at a specified level for the irreversible 9-7 DWT
+@param level Level of the wavelet function
+@param orient Band of the wavelet function
+@return Returns the norm of the 9-7 wavelet
+*/
+double dwt_getnorm_real(int level, int orient);
+/**
+FIXME : comment ???
+@param tccp
+@param prec
+*/
+void dwt_calc_explicit_stepsizes(opj_tccp_t * tccp, int prec);
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __DWT_H */
diff --git a/libraries/openjpeg-libsl/libopenjpeg/event.c b/libraries/openjpeg-libsl/libopenjpeg/event.c
new file mode 100644
index 0000000..291ff58
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/event.c
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) 2005, Hervé Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "opj_includes.h"
+
+/* ==========================================================
+     Utility functions
+   ==========================================================*/
+
+#if !defined(_MSC_VER) && !defined(__MINGW32__)
+static char*
+i2a(unsigned i, char *a, unsigned r) {
+        if (i/r > 0) a = i2a(i/r,a,r);
+        *a = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[i%r];
+        return a+1;
+}
+
+/** 
+ Transforms integer i into an ascii string and stores the result in a; 
+ string is encoded in the base indicated by r.
+ @param i Number to be converted
+ @param a String result
+ @param r Base of value; must be in the range 2 - 36
+ @return Returns a
+*/
+static char *
+_itoa(int i, char *a, int r) {
+        r = ((r < 2) || (r > 36)) ? 10 : r;
+        if(i < 0) {
+                *a = '-';
+                *i2a(-i, a+1, r) = 0;
+        }
+        else *i2a(i, a, r) = 0;
+        return a;
+}
+
+#endif /* !WIN32 */
+
+/* ----------------------------------------------------------------------- */
+
+opj_event_mgr_t* OPJ_CALLCONV opj_set_event_mgr(opj_common_ptr cinfo, opj_event_mgr_t *event_mgr, void *context) {
+        if(cinfo) {
+                opj_event_mgr_t *previous = cinfo->event_mgr;
+                cinfo->event_mgr = event_mgr;
+                cinfo->client_data = context;
+                return previous;
+        }
+
+        return NULL;
+}
+
+bool opj_event_msg(opj_common_ptr cinfo, int event_type, const char *fmt, ...) {
+#define MSG_SIZE 512 /* 512 bytes should be more than enough for a short message */
+        opj_msg_callback msg_handler = NULL;
+
+        opj_event_mgr_t *event_mgr = cinfo->event_mgr;
+        if(event_mgr != NULL) {
+                switch(event_type) {
+                        case EVT_ERROR:
+                                msg_handler = event_mgr->error_handler;
+                                break;
+                        case EVT_WARNING:
+                                msg_handler = event_mgr->warning_handler;
+                                break;
+                        case EVT_INFO:
+                                msg_handler = event_mgr->info_handler;
+                                break;
+                        default:
+                                break;
+                }
+                if(msg_handler == NULL) {
+                        return false;
+                }
+        } else {
+                return false;
+        }
+
+        if ((fmt != NULL) && (event_mgr != NULL)) {
+                va_list arg;
+                int str_length/*, i, j*/; /* UniPG */
+                char message[MSG_SIZE];
+                memset(message, 0, MSG_SIZE);
+                /* initialize the optional parameter list */
+                va_start(arg, fmt);
+                /* check the length of the format string */
+                str_length = (strlen(fmt) > MSG_SIZE) ? MSG_SIZE : strlen(fmt);
+                /* parse the format string and put the result in 'message' */
+                vsprintf(message, fmt, arg); /* UniPG */
+                /* deinitialize the optional parameter list */
+                va_end(arg);
+
+                /* output the message to the user program */
+                msg_handler(message, cinfo->client_data);
+        }
+
+        return true;
+}
+
diff --git a/libraries/openjpeg-libsl/libopenjpeg/event.h b/libraries/openjpeg-libsl/libopenjpeg/event.h
new file mode 100644
index 0000000..11910b0
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/event.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2005, Hervé Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __EVENT_H
+#define __EVENT_H
+/**
+@file event.h
+@brief Implementation of a event callback system
+
+The functions in EVENT.C have for goal to send output messages (errors, warnings, debug) to the user.
+*/
+
+#define EVT_ERROR       1       /**< Error event type */
+#define EVT_WARNING     2       /**< Warning event type */
+#define EVT_INFO        4       /**< Debug event type */
+
+/** @defgroup EVENT EVENT - Implementation of a event callback system */
+/*@{*/
+
+/** @name Exported functions (see also openjpeg.h) */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+/**
+Write formatted data to a string and send the string to a user callback. 
+@param cinfo Codec context info
+@param event_type Event type or callback to use to send the message
+@param fmt Format-control string (plus optionnal arguments)
+@return Returns true if successful, returns false otherwise
+*/
+bool opj_event_msg(opj_common_ptr cinfo, int event_type, const char *fmt, ...);
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __EVENT_H */
diff --git a/libraries/openjpeg-libsl/libopenjpeg/fix.h b/libraries/openjpeg-libsl/libopenjpeg/fix.h
new file mode 100644
index 0000000..bcb2acb
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/fix.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __FIX_H
+#define __FIX_H
+
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+#define int64 __int64
+#else
+#define int64 long long
+#endif
+
+/**
+@file fix.h
+@brief Implementation of operations of specific multiplication (FIX)
+
+The functions in FIX.H have for goal to realize specific multiplication.
+*/
+
+/** @defgroup FIX FIX - Implementation of operations of specific multiplication */
+/*@{*/
+
+/**
+Multiply two fixed-precision rational numbers.
+@param a
+@param b
+@return Returns a * b
+*/
+static INLINE int fix_mul(int a, int b) {
+    int64 temp = (int64) a * (int64) b ;
+    temp += temp & 4096;
+    return (int) (temp >> 13) ;
+}
+
+/*@}*/
+
+#endif /* __FIX_H */
diff --git a/libraries/openjpeg-libsl/libopenjpeg/image.c b/libraries/openjpeg-libsl/libopenjpeg/image.c
new file mode 100644
index 0000000..84664e9
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/image.c
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2005, Hervé Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "opj_includes.h"
+
+opj_image_t* opj_image_create0() {
+        opj_image_t *image = (opj_image_t*)opj_malloc(sizeof(opj_image_t));
+        return image;
+}
+
+opj_image_t* OPJ_CALLCONV opj_image_create(int numcmpts, opj_image_cmptparm_t *cmptparms, OPJ_COLOR_SPACE clrspc) {
+        int compno;
+        opj_image_t *image = NULL;
+
+        image = (opj_image_t*)opj_malloc(sizeof(opj_image_t));
+        if(image) {
+                image->color_space = clrspc;
+                image->numcomps = numcmpts;
+                /* allocate memory for the per-component information */
+                image->comps = (opj_image_comp_t*)opj_malloc(image->numcomps * sizeof(opj_image_comp_t));
+                if(!image->comps) {
+                        opj_image_destroy(image);
+                        return NULL;
+                }
+                /* create the individual image components */
+                for(compno = 0; compno < numcmpts; compno++) {
+                        opj_image_comp_t *comp = &image->comps[compno];
+                        comp->dx = cmptparms[compno].dx;
+                        comp->dy = cmptparms[compno].dy;
+                        comp->w = cmptparms[compno].w;
+                        comp->h = cmptparms[compno].h;
+                        comp->x0 = cmptparms[compno].x0;
+                        comp->y0 = cmptparms[compno].y0;
+                        comp->prec = cmptparms[compno].prec;
+                        comp->bpp = cmptparms[compno].bpp;
+                        comp->sgnd = cmptparms[compno].sgnd;
+                        comp->data = (int*)opj_malloc(comp->w * comp->h * sizeof(int));
+                        if(!comp->data) {
+                                opj_image_destroy(image);
+                                return NULL;
+                        }
+                }
+        }
+
+        return image;
+}
+
+void OPJ_CALLCONV opj_image_destroy(opj_image_t *image) {
+        int i;
+        if(image) {
+                if(image->comps) {
+                        /* image components */
+                        for(i = 0; i < image->numcomps; i++) {
+                                opj_image_comp_t *image_comp = &image->comps[i];
+                                if(image_comp->data) {
+                                        opj_free(image_comp->data);
+                                }
+                        }
+                        opj_free(image->comps);
+                }
+                opj_free(image);
+        }
+}
+
diff --git a/libraries/openjpeg-libsl/libopenjpeg/image.h b/libraries/openjpeg-libsl/libopenjpeg/image.h
new file mode 100644
index 0000000..b56de4a
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/image.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2005, Hervé Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __IMAGE_H
+#define __IMAGE_H
+/**
+@file image.h
+@brief Implementation of operations on images (IMAGE)
+
+The functions in IMAGE.C have for goal to realize operations on images.
+*/
+
+/** @defgroup IMAGE IMAGE - Implementation of operations on images */
+/*@{*/
+
+/**
+Create an empty image
+@todo this function should be removed
+@return returns an empty image if successful, returns NULL otherwise
+*/
+opj_image_t* opj_image_create0();
+
+/*@}*/
+
+#endif /* __IMAGE_H */
+
diff --git a/libraries/openjpeg-libsl/libopenjpeg/int.h b/libraries/openjpeg-libsl/libopenjpeg/int.h
new file mode 100644
index 0000000..4e5fe08
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/int.h
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __INT_H
+#define __INT_H
+/**
+@file int.h
+@brief Implementation of operations on integers (INT)
+
+The functions in INT.H have for goal to realize operations on integers.
+*/
+
+/** @defgroup INT INT - Implementation of operations on integers */
+/*@{*/
+
+/** @name Exported functions (see also openjpeg.h) */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+/**
+Get the minimum of two integers
+@return Returns a if a < b else b
+*/
+static INLINE int int_min(int a, int b) {
+        return a < b ? a : b;
+}
+/**
+Get the maximum of two integers
+@return Returns a if a > b else b
+*/
+static INLINE int int_max(int a, int b) {
+        return (a > b) ? a : b;
+}
+/**
+Clamp an integer inside an interval
+@return
+<ul>
+<li>Returns a if (min < a < max)
+<li>Returns max if (a > max)
+<li>Returns min if (a < min) 
+</ul>
+*/
+static INLINE int int_clamp(int a, int min, int max) {
+        if (a < min)
+                return min;
+        if (a > max)
+                return max;
+        return a;
+}
+/**
+@return Get absolute value of integer
+*/
+static INLINE int int_abs(int a) {
+        return a < 0 ? -a : a;
+}
+/**
+Divide an integer and round upwards
+@return Returns a divided by b
+*/
+static INLINE int int_ceildiv(int a, int b) {
+        return (a + b - 1) / b;
+}
+/**
+Divide an integer by a power of 2 and round upwards
+@return Returns a divided by 2^b
+*/
+static INLINE int int_ceildivpow2(int a, int b) {
+        return (a + (1 << b) - 1) >> b;
+}
+/**
+Divide an integer by a power of 2 and round downwards
+@return Returns a divided by 2^b
+*/
+static INLINE int int_floordivpow2(int a, int b) {
+        return a >> b;
+}
+/**
+Get logarithm of an integer and round downwards
+@return Returns log2(a)
+*/
+static INLINE int int_floorlog2(int a) {
+        int l;
+        for (l = 0; a > 1; l++) {
+                a >>= 1;
+        }
+        return l;
+}
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif
diff --git a/libraries/openjpeg-libsl/libopenjpeg/j2k.c b/libraries/openjpeg-libsl/libopenjpeg/j2k.c
new file mode 100644
index 0000000..1ef653e
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/j2k.c
@@ -0,0 +1,2630 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * Copyright (c) 2006-2007, Parvatha Elangovan
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "opj_includes.h"
+
+/** @defgroup J2K J2K - JPEG-2000 codestream reader/writer */
+/*@{*/
+
+/** @name Local static functions */
+/*@{*/
+
+/**
+Write the SOC marker (Start Of Codestream)
+@param j2k J2K handle
+*/
+static void j2k_write_soc(opj_j2k_t *j2k);
+/**
+Read the SOC marker (Start of Codestream)
+@param j2k J2K handle
+*/
+static void j2k_read_soc(opj_j2k_t *j2k);
+/**
+Write the SIZ marker (image and tile size)
+@param j2k J2K handle
+*/
+static void j2k_write_siz(opj_j2k_t *j2k);
+/**
+Read the SIZ marker (image and tile size)
+@param j2k J2K handle
+*/
+static void j2k_read_siz(opj_j2k_t *j2k);
+/**
+Write the COM marker (comment)
+@param j2k J2K handle
+*/
+static void j2k_write_com(opj_j2k_t *j2k);
+/**
+Read the COM marker (comment)
+@param j2k J2K handle
+*/
+static void j2k_read_com(opj_j2k_t *j2k);
+/**
+Write the value concerning the specified component in the marker COD and COC
+@param j2k J2K handle
+@param compno Number of the component concerned by the information written
+*/
+static void j2k_write_cox(opj_j2k_t *j2k, int compno);
+/**
+Read the value concerning the specified component in the marker COD and COC
+@param j2k J2K handle
+@param compno Number of the component concerned by the information read
+*/
+static void j2k_read_cox(opj_j2k_t *j2k, int compno);
+/**
+Write the COD marker (coding style default)
+@param j2k J2K handle
+*/
+static void j2k_write_cod(opj_j2k_t *j2k);
+/**
+Read the COD marker (coding style default)
+@param j2k J2K handle
+*/
+static void j2k_read_cod(opj_j2k_t *j2k);
+/**
+Write the COC marker (coding style component)
+@param j2k J2K handle
+@param compno Number of the component concerned by the information written
+*/
+static void j2k_write_coc(opj_j2k_t *j2k, int compno);
+/**
+Read the COC marker (coding style component)
+@param j2k J2K handle
+*/
+static void j2k_read_coc(opj_j2k_t *j2k);
+/**
+Write the value concerning the specified component in the marker QCD and QCC
+@param j2k J2K handle
+@param compno Number of the component concerned by the information written
+*/
+static void j2k_write_qcx(opj_j2k_t *j2k, int compno);
+/**
+Read the value concerning the specified component in the marker QCD and QCC
+@param j2k J2K handle
+@param compno Number of the component concern by the information read
+@param len Length of the information in the QCX part of the marker QCD/QCC
+*/
+static void j2k_read_qcx(opj_j2k_t *j2k, int compno, int len);
+/**
+Write the QCD marker (quantization default)
+@param j2k J2K handle
+*/
+static void j2k_write_qcd(opj_j2k_t *j2k);
+/**
+Read the QCD marker (quantization default)
+@param j2k J2K handle
+*/
+static void j2k_read_qcd(opj_j2k_t *j2k);
+/**
+Write the QCC marker (quantization component)
+@param j2k J2K handle
+@param compno Number of the component concerned by the information written
+*/
+static void j2k_write_qcc(opj_j2k_t *j2k, int compno);
+/**
+Read the QCC marker (quantization component)
+@param j2k J2K handle
+*/
+static void j2k_read_qcc(opj_j2k_t *j2k);
+/**
+Write the POC marker (progression order change)
+@param j2k J2K handle
+*/
+static void j2k_write_poc(opj_j2k_t *j2k);
+/**
+Read the POC marker (progression order change)
+@param j2k J2K handle
+*/
+static void j2k_read_poc(opj_j2k_t *j2k);
+/**
+Read the CRG marker (component registration)
+@param j2k J2K handle
+*/
+static void j2k_read_crg(opj_j2k_t *j2k);
+/**
+Read the TLM marker (tile-part lengths)
+@param j2k J2K handle
+*/
+static void j2k_read_tlm(opj_j2k_t *j2k);
+/**
+Read the PLM marker (packet length, main header)
+@param j2k J2K handle
+*/
+static void j2k_read_plm(opj_j2k_t *j2k);
+/**
+Read the PLT marker (packet length, tile-part header)
+@param j2k J2K handle
+*/
+static void j2k_read_plt(opj_j2k_t *j2k);
+/**
+Read the PPM marker (packet packet headers, main header)
+@param j2k J2K handle
+*/
+static void j2k_read_ppm(opj_j2k_t *j2k);
+/**
+Read the PPT marker (packet packet headers, tile-part header)
+@param j2k J2K handle
+*/
+static void j2k_read_ppt(opj_j2k_t *j2k);
+/**
+Write the TLM marker (Mainheader)
+@param j2k J2K handle
+*/
+static void j2k_write_tlm(opj_j2k_t *j2k);
+/**
+Write the SOT marker (start of tile-part)
+@param j2k J2K handle
+*/
+static void j2k_write_sot(opj_j2k_t *j2k);
+/**
+Read the SOT marker (start of tile-part)
+@param j2k J2K handle
+*/
+static void j2k_read_sot(opj_j2k_t *j2k);
+/**
+Write the SOD marker (start of data)
+@param j2k J2K handle
+@param tile_coder Pointer to a TCD handle
+*/
+static void j2k_write_sod(opj_j2k_t *j2k, void *tile_coder);
+/**
+Read the SOD marker (start of data)
+@param j2k J2K handle
+*/
+static void j2k_read_sod(opj_j2k_t *j2k);
+/**
+Write the RGN marker (region-of-interest)
+@param j2k J2K handle
+@param compno Number of the component concerned by the information written
+@param tileno Number of the tile concerned by the information written
+*/
+static void j2k_write_rgn(opj_j2k_t *j2k, int compno, int tileno);
+/**
+Read the RGN marker (region-of-interest)
+@param j2k J2K handle
+*/
+static void j2k_read_rgn(opj_j2k_t *j2k);
+/**
+Write the EOC marker (end of codestream)
+@param j2k J2K handle
+*/
+static void j2k_write_eoc(opj_j2k_t *j2k);
+/**
+Read the EOC marker (end of codestream)
+@param j2k J2K handle
+*/
+static void j2k_read_eoc(opj_j2k_t *j2k);
+/**
+Read an unknown marker
+@param j2k J2K handle
+*/
+static void j2k_read_unk(opj_j2k_t *j2k);
+
+/*@}*/
+
+/*@}*/
+
+/* ----------------------------------------------------------------------- */
+typedef struct j2k_prog_order{
+        OPJ_PROG_ORDER enum_prog;
+        char str_prog[4];
+}j2k_prog_order_t;
+
+j2k_prog_order_t j2k_prog_order_list[] = {
+        {CPRL, "CPRL"},
+        {LRCP, "LRCP"},
+        {PCRL, "PCRL"},
+        {RLCP, "RLCP"},
+        {RPCL, "RPCL"},
+        {-1, ""}
+};
+
+char *j2k_convert_progression_order(OPJ_PROG_ORDER prg_order){
+        j2k_prog_order_t *po;
+        for(po = j2k_prog_order_list; po->enum_prog != -1; po++ ){
+                if(po->enum_prog == prg_order){
+                        break;
+                }
+        }
+        return po->str_prog;
+}
+
+static void j2k_check_poc_val(opj_cparameters_t *parameters, int numcomps, int numlayers){
+        int index, resno, compno, layno, i;
+        char loss = 0;
+        int step_c = 1;
+        int step_r = numcomps * step_c;
+        int step_l = parameters->numresolution * step_r;
+        int array_size = step_l * numlayers * sizeof(int);
+        int *packet_array = (int *) opj_malloc(array_size);
+        
+        for (i = 0; i < parameters->numpocs ; i++) {
+                int layno0 = 0;
+                if(i > 0)
+                        layno0 = (parameters->POC[i].layno1 > parameters->POC[i-1].layno1 )? parameters->POC[i-1].layno1 : 0;
+                for (resno = parameters->POC[i].resno0 ; resno < parameters->POC[i].resno1 ; resno++) {
+                        for (compno = parameters->POC[i].compno0 ; compno < parameters->POC[i].compno1 ; compno++) {
+                                for (layno = layno0; layno < parameters->POC[i].layno1 ; layno++) {
+                                        index = step_r * resno + step_c * compno + step_l * layno;
+                                        packet_array[index]= 1;
+                                }
+                        }
+                }
+        }
+        for (resno = 0; resno < parameters->numresolution; resno++) {
+                for (compno = 0; compno < numcomps; compno++) {
+                        for (layno = 0; layno < numlayers ; layno++) {
+                                index = step_r * resno + step_c * compno + step_l * layno;
+                                if(!(   packet_array[index]== 1)){
+                                        loss = 1;
+                                }
+                        }
+                }
+        }
+        if(loss == 1)
+                fprintf(stdout,"Missing packets possible loss of data\n");
+        opj_free(packet_array);
+}
+
+void j2k_dump_image(FILE *fd, opj_image_t * img) {
+        int compno;
+        fprintf(fd, "image {\n");
+        fprintf(fd, "  x0=%d, y0=%d, x1=%d, y1=%d\n", img->x0, img->y0, img->x1, img->y1);
+        fprintf(fd, "  numcomps=%d\n", img->numcomps);
+        for (compno = 0; compno < img->numcomps; compno++) {
+                opj_image_comp_t *comp = &img->comps[compno];
+                fprintf(fd, "  comp %d {\n", compno);
+                fprintf(fd, "    dx=%d, dy=%d\n", comp->dx, comp->dy);
+                fprintf(fd, "    prec=%d\n", comp->prec);
+                fprintf(fd, "    sgnd=%d\n", comp->sgnd);
+                fprintf(fd, "  }\n");
+        }
+        fprintf(fd, "}\n");
+}
+
+void j2k_dump_cp(FILE *fd, opj_image_t * img, opj_cp_t * cp) {
+        int tileno, compno, layno, bandno, resno, numbands;
+        fprintf(fd, "coding parameters {\n");
+        fprintf(fd, "  tx0=%d, ty0=%d\n", cp->tx0, cp->ty0);
+        fprintf(fd, "  tdx=%d, tdy=%d\n", cp->tdx, cp->tdy);
+        fprintf(fd, "  tw=%d, th=%d\n", cp->tw, cp->th);
+        for (tileno = 0; tileno < cp->tw * cp->th; tileno++) {
+                opj_tcp_t *tcp = &cp->tcps[tileno];
+                fprintf(fd, "  tile %d {\n", tileno);
+                fprintf(fd, "    csty=%x\n", tcp->csty);
+                fprintf(fd, "    prg=%d\n", tcp->prg);
+                fprintf(fd, "    numlayers=%d\n", tcp->numlayers);
+                fprintf(fd, "    mct=%d\n", tcp->mct);
+                fprintf(fd, "    rates=");
+                for (layno = 0; layno < tcp->numlayers; layno++) {
+                        fprintf(fd, "%.1f ", tcp->rates[layno]);
+                }
+                fprintf(fd, "\n");
+                for (compno = 0; compno < img->numcomps; compno++) {
+                        opj_tccp_t *tccp = &tcp->tccps[compno];
+                        fprintf(fd, "    comp %d {\n", compno);
+                        fprintf(fd, "      csty=%x\n", tccp->csty);
+                        fprintf(fd, "      numresolutions=%d\n", tccp->numresolutions);
+                        fprintf(fd, "      cblkw=%d\n", tccp->cblkw);
+                        fprintf(fd, "      cblkh=%d\n", tccp->cblkh);
+                        fprintf(fd, "      cblksty=%x\n", tccp->cblksty);
+                        fprintf(fd, "      qmfbid=%d\n", tccp->qmfbid);
+                        fprintf(fd, "      qntsty=%d\n", tccp->qntsty);
+                        fprintf(fd, "      numgbits=%d\n", tccp->numgbits);
+                        fprintf(fd, "      roishift=%d\n", tccp->roishift);
+                        fprintf(fd, "      stepsizes=");
+                        numbands = tccp->qntsty == J2K_CCP_QNTSTY_SIQNT ? 1 : tccp->numresolutions * 3 - 2;
+                        for (bandno = 0; bandno < numbands; bandno++) {
+                                fprintf(fd, "(%d,%d) ", tccp->stepsizes[bandno].mant,
+                                        tccp->stepsizes[bandno].expn);
+                        }
+                        fprintf(fd, "\n");
+                        
+                        if (tccp->csty & J2K_CCP_CSTY_PRT) {
+                                fprintf(fd, "      prcw=");
+                                for (resno = 0; resno < tccp->numresolutions; resno++) {
+                                        fprintf(fd, "%d ", tccp->prcw[resno]);
+                                }
+                                fprintf(fd, "\n");
+                                fprintf(fd, "      prch=");
+                                for (resno = 0; resno < tccp->numresolutions; resno++) {
+                                        fprintf(fd, "%d ", tccp->prch[resno]);
+                                }
+                                fprintf(fd, "\n");
+                        }
+                        fprintf(fd, "    }\n");
+                }
+                fprintf(fd, "  }\n");
+        }
+        fprintf(fd, "}\n");
+}
+
+/* ----------------------------------------------------------------------- */
+static int j2k_get_num_tp(opj_cp_t *cp,int pino,int tileno){
+        char *prog;
+        int i;
+        int tpnum=1,tpend=0;
+        opj_tcp_t *tcp = &cp->tcps[tileno];
+        prog = j2k_convert_progression_order(tcp->prg);
+        
+        if(cp->tp_on == 1){
+                for(i=0;i<4;i++){
+                        if(tpend!=1){
+                                if( cp->tp_flag == prog[i] ){
+                                        tpend=1;cp->tp_pos=i;
+                                }
+                                switch(prog[i]){
+                                case 'C':
+                                        tpnum= tpnum * tcp->pocs[pino].compE;
+                                        break;
+                                case 'R':
+                                        tpnum= tpnum * tcp->pocs[pino].resE;
+                                        break;
+                                case 'P':
+                                        tpnum= tpnum * tcp->pocs[pino].prcE;
+                                        break;
+                                case 'L':
+                                        tpnum= tpnum * tcp->pocs[pino].layE;
+                                        break;
+                                }
+                        }
+                }
+        }else{
+                tpnum=1;
+        }
+        return tpnum;
+}
+
+/**     mem allocation for TLM marker*/
+int j2k_calculate_tp(opj_cp_t *cp,int img_numcomp,opj_image_t *image,opj_j2k_t *j2k ){
+        int pino,tileno,maxres=0,totnum_tp=0;
+        j2k->cur_totnum_tp = (int *) opj_malloc(cp->tw * cp->th * sizeof(int));
+        for (tileno = 0; tileno < cp->tw * cp->th; tileno++) {
+                int cur_totnum_tp = 0;
+                opj_tcp_t *tcp = &cp->tcps[tileno];
+                for(pino = 0; pino <= tcp->numpocs; pino++) {
+                        int tp_num=0;
+                        opj_pi_iterator_t *pi = pi_initialise_encode(image, cp, tileno,FINAL_PASS);
+                        if(!pi) { return -1;}
+                        tp_num = j2k_get_num_tp(cp,pino,tileno);
+                        totnum_tp = totnum_tp + tp_num;
+                        cur_totnum_tp = cur_totnum_tp + tp_num;
+                        pi_destroy(pi, cp, tileno);
+                }
+                j2k->cur_totnum_tp[tileno] = cur_totnum_tp;
+        }
+        return totnum_tp;
+}
+
+static void j2k_write_soc(opj_j2k_t *j2k) {
+        opj_cio_t *cio = j2k->cio;
+        cio_write(cio, J2K_MS_SOC, 2);
+}
+
+static void j2k_read_soc(opj_j2k_t *j2k) {
+        j2k->state = J2K_STATE_MHSIZ;
+}
+
+static void j2k_write_siz(opj_j2k_t *j2k) {
+        int i;
+        int lenp, len;
+
+        opj_cio_t *cio = j2k->cio;
+        opj_image_t *image = j2k->image;
+        opj_cp_t *cp = j2k->cp;
+        
+        cio_write(cio, J2K_MS_SIZ, 2);  /* SIZ */
+        lenp = cio_tell(cio);
+        cio_skip(cio, 2);
+        cio_write(cio, cp->rsiz, 2);                    /* Rsiz (capabilities) */
+        cio_write(cio, image->x1, 4);   /* Xsiz */
+        cio_write(cio, image->y1, 4);   /* Ysiz */
+        cio_write(cio, image->x0, 4);   /* X0siz */
+        cio_write(cio, image->y0, 4);   /* Y0siz */
+        cio_write(cio, cp->tdx, 4);             /* XTsiz */
+        cio_write(cio, cp->tdy, 4);             /* YTsiz */
+        cio_write(cio, cp->tx0, 4);             /* XT0siz */
+        cio_write(cio, cp->ty0, 4);             /* YT0siz */
+        cio_write(cio, image->numcomps, 2);     /* Csiz */
+        for (i = 0; i < image->numcomps; i++) {
+                cio_write(cio, image->comps[i].prec - 1 + (image->comps[i].sgnd << 7), 1);      /* Ssiz_i */
+                cio_write(cio, image->comps[i].dx, 1);  /* XRsiz_i */
+                cio_write(cio, image->comps[i].dy, 1);  /* YRsiz_i */
+        }
+        len = cio_tell(cio) - lenp;
+        cio_seek(cio, lenp);
+        cio_write(cio, len, 2);         /* Lsiz */
+        cio_seek(cio, lenp + len);
+}
+
+static void j2k_read_siz(opj_j2k_t *j2k) {
+        int len, i;
+        
+        opj_cio_t *cio = j2k->cio;
+        opj_image_t *image = j2k->image;
+        opj_cp_t *cp = j2k->cp;
+        
+        len = cio_read(cio, 2);                 /* Lsiz */
+        cio_read(cio, 2);                               /* Rsiz (capabilities) */
+        image->x1 = cio_read(cio, 4);   /* Xsiz */
+        image->y1 = cio_read(cio, 4);   /* Ysiz */
+        image->x0 = cio_read(cio, 4);   /* X0siz */
+        image->y0 = cio_read(cio, 4);   /* Y0siz */
+        cp->tdx = cio_read(cio, 4);             /* XTsiz */
+        cp->tdy = cio_read(cio, 4);             /* YTsiz */
+        cp->tx0 = cio_read(cio, 4);             /* XT0siz */
+        cp->ty0 = cio_read(cio, 4);             /* YT0siz */
+        
+        image->numcomps = cio_read(cio, 2);     /* Csiz */
+
+#ifdef USE_JPWL
+        if (j2k->cp->correct) {
+                /* if JPWL is on, we check whether TX errors have damaged
+                  too much the SIZ parameters */
+                if (!(image->x1 * image->y1)) {
+                        opj_event_msg(j2k->cinfo, EVT_ERROR,
+                                "JPWL: bad image size (%d x %d)\n",
+                                image->x1, image->y1);
+                        if (!JPWL_ASSUME || JPWL_ASSUME) {
+                                opj_event_msg(j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
+                                return;
+                        }
+                }
+                if (image->numcomps != ((len - 38) / 3)) {
+                        opj_event_msg(j2k->cinfo, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
+                                "JPWL: Csiz is %d => space in SIZ only for %d comps.!!!\n",
+                                image->numcomps, ((len - 38) / 3));
+                        if (!JPWL_ASSUME) {
+                                opj_event_msg(j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
+                                return;
+                        }
+                        /* we try to correct */
+                        opj_event_msg(j2k->cinfo, EVT_WARNING, "- trying to adjust this\n");
+                        if (image->numcomps < ((len - 38) / 3)) {
+                                len = 38 + 3 * image->numcomps;
+                                opj_event_msg(j2k->cinfo, EVT_WARNING, "- setting Lsiz to %d => HYPOTHESIS!!!\n",
+                                        len);                           
+                        } else {
+                                image->numcomps = ((len - 38) / 3);
+                                opj_event_msg(j2k->cinfo, EVT_WARNING, "- setting Csiz to %d => HYPOTHESIS!!!\n",
+                                        image->numcomps);                               
+                        }
+                }
+
+                /* update components number in the jpwl_exp_comps filed */
+                cp->exp_comps = image->numcomps;
+        }
+#endif /* USE_JPWL */
+
+        image->comps = (opj_image_comp_t *) opj_malloc(image->numcomps * sizeof(opj_image_comp_t));
+        for (i = 0; i < image->numcomps; i++) {
+                int tmp, w, h;
+                tmp = cio_read(cio, 1);         /* Ssiz_i */
+                image->comps[i].prec = (tmp & 0x7f) + 1;
+                image->comps[i].sgnd = tmp >> 7;
+                image->comps[i].dx = cio_read(cio, 1);  /* XRsiz_i */
+                image->comps[i].dy = cio_read(cio, 1);  /* YRsiz_i */
+                
+#ifdef USE_JPWL
+                if (j2k->cp->correct) {
+                /* if JPWL is on, we check whether TX errors have damaged
+                        too much the SIZ parameters, again */
+                        if (!(image->comps[i].dx * image->comps[i].dy)) {
+                                opj_event_msg(j2k->cinfo, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
+                                        "JPWL: bad XRsiz_%d/YRsiz_%d (%d x %d)\n",
+                                        i, i, image->comps[i].dx, image->comps[i].dy);
+                                if (!JPWL_ASSUME) {
+                                        opj_event_msg(j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
+                                        return;
+                                }
+                                /* we try to correct */
+                                opj_event_msg(j2k->cinfo, EVT_WARNING, "- trying to adjust them\n");
+                                if (!image->comps[i].dx) {
+                                        image->comps[i].dx = 1;
+                                        opj_event_msg(j2k->cinfo, EVT_WARNING, "- setting XRsiz_%d to %d => HYPOTHESIS!!!\n",
+                                                i, image->comps[i].dx);
+                                }
+                                if (!image->comps[i].dy) {
+                                        image->comps[i].dy = 1;
+                                        opj_event_msg(j2k->cinfo, EVT_WARNING, "- setting YRsiz_%d to %d => HYPOTHESIS!!!\n",
+                                                i, image->comps[i].dy);
+                                }
+                        }
+                        
+                }
+#endif /* USE_JPWL */
+
+
+                /* TODO: unused ? */
+                w = int_ceildiv(image->x1 - image->x0, image->comps[i].dx);
+                h = int_ceildiv(image->y1 - image->y0, image->comps[i].dy);
+
+                image->comps[i].resno_decoded = 0;      /* number of resolution decoded */
+                image->comps[i].factor = 0;                     /* reducing factor per component */
+        }
+        
+        cp->tw = int_ceildiv(image->x1 - cp->tx0, cp->tdx);
+        cp->th = int_ceildiv(image->y1 - cp->ty0, cp->tdy);
+
+#ifdef USE_JPWL
+        if (j2k->cp->correct) {
+                /* if JPWL is on, we check whether TX errors have damaged
+                  too much the SIZ parameters */
+                if ((cp->tw < 1) || (cp->th < 1) || (cp->tw > cp->max_tiles) || (cp->th > cp->max_tiles)) {
+                        opj_event_msg(j2k->cinfo, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
+                                "JPWL: bad number of tiles (%d x %d)\n",
+                                cp->tw, cp->th);
+                        if (!JPWL_ASSUME) {
+                                opj_event_msg(j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
+                                return;
+                        }
+                        /* we try to correct */
+                        opj_event_msg(j2k->cinfo, EVT_WARNING, "- trying to adjust them\n");
+                        if (cp->tw < 1) {
+                                cp->tw= 1;
+                                opj_event_msg(j2k->cinfo, EVT_WARNING, "- setting %d tiles in x => HYPOTHESIS!!!\n",
+                                        cp->tw);
+                        }
+                        if (cp->tw > cp->max_tiles) {
+                                cp->tw= 1;
+                                opj_event_msg(j2k->cinfo, EVT_WARNING, "- too large x, increase expectance of %d\n"
+                                        "- setting %d tiles in x => HYPOTHESIS!!!\n",
+                                        cp->max_tiles, cp->tw);
+                        }
+                        if (cp->th < 1) {
+                                cp->th= 1;
+                                opj_event_msg(j2k->cinfo, EVT_WARNING, "- setting %d tiles in y => HYPOTHESIS!!!\n",
+                                        cp->th);
+                        }
+                        if (cp->th > cp->max_tiles) {
+                                cp->th= 1;
+                                opj_event_msg(j2k->cinfo, EVT_WARNING, "- too large y, increase expectance of %d to continue\n",
+                                        "- setting %d tiles in y => HYPOTHESIS!!!\n",
+                                        cp->max_tiles, cp->th);
+                        }
+                }
+        }
+#endif /* USE_JPWL */
+
+        cp->tcps = (opj_tcp_t *) opj_malloc(cp->tw * cp->th * sizeof(opj_tcp_t));
+        cp->tileno = (int *) opj_malloc(cp->tw * cp->th * sizeof(int));
+        cp->tileno_size = 0;
+        
+#ifdef USE_JPWL
+        if (j2k->cp->correct) {
+                if (!cp->tcps) {
+                        opj_event_msg(j2k->cinfo, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
+                                "JPWL: could not alloc tcps field of cp\n");
+                        if (!JPWL_ASSUME || JPWL_ASSUME) {
+                                opj_event_msg(j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
+                                return;
+                        }
+                }
+        }
+#endif /* USE_JPWL */
+
+        for (i = 0; i < cp->tw * cp->th; i++) {
+                cp->tcps[i].POC = 0;
+                cp->tcps[i].numpocs = 0;
+                cp->tcps[i].first = 1;
+        }
+        
+        /* Initialization for PPM marker */
+        cp->ppm = 0;
+        cp->ppm_data = NULL;
+        cp->ppm_data_first = NULL;
+        cp->ppm_previous = 0;
+        cp->ppm_store = 0;
+        
+        j2k->default_tcp->tccps = (opj_tccp_t *) opj_malloc(sizeof(opj_tccp_t) * image->numcomps);
+        for (i = 0; i < cp->tw * cp->th; i++) {
+                cp->tcps[i].tccps = (opj_tccp_t *) opj_malloc(sizeof(opj_tccp_t) * image->numcomps);
+        }
+        j2k->tile_data = (unsigned char **) opj_malloc(cp->tw * cp->th * sizeof(unsigned char *));
+        j2k->tile_len = (int *) opj_malloc(cp->tw * cp->th * sizeof(int));
+        j2k->state = J2K_STATE_MH;
+}
+
+static void j2k_write_com(opj_j2k_t *j2k) {
+        unsigned int i;
+        int lenp, len;
+
+        if(j2k->cp->comment) {
+                opj_cio_t *cio = j2k->cio;
+                char *comment = j2k->cp->comment;
+
+                cio_write(cio, J2K_MS_COM, 2);
+                lenp = cio_tell(cio);
+                cio_skip(cio, 2);
+                cio_write(cio, 0, 2);
+                for (i = 0; i < strlen(comment); i++) {
+                        cio_write(cio, comment[i], 1);
+                }
+                len = cio_tell(cio) - lenp;
+                cio_seek(cio, lenp);
+                cio_write(cio, len, 2);
+                cio_seek(cio, lenp + len);
+        }
+}
+
+static void j2k_read_com(opj_j2k_t *j2k) {
+        int len;
+        
+        opj_cio_t *cio = j2k->cio;
+
+        len = cio_read(cio, 2);
+        cio_skip(cio, len - 2);  
+}
+
+static void j2k_write_cox(opj_j2k_t *j2k, int compno) {
+        int i;
+
+        opj_cp_t *cp = j2k->cp;
+        opj_tcp_t *tcp = &cp->tcps[j2k->curtileno];
+        opj_tccp_t *tccp = &tcp->tccps[compno];
+        opj_cio_t *cio = j2k->cio;
+        
+        cio_write(cio, tccp->numresolutions - 1, 1);    /* SPcox (D) */
+        cio_write(cio, tccp->cblkw - 2, 1);                             /* SPcox (E) */
+        cio_write(cio, tccp->cblkh - 2, 1);                             /* SPcox (F) */
+        cio_write(cio, tccp->cblksty, 1);                               /* SPcox (G) */
+        cio_write(cio, tccp->qmfbid, 1);                                /* SPcox (H) */
+        
+        if (tccp->csty & J2K_CCP_CSTY_PRT) {
+                for (i = 0; i < tccp->numresolutions; i++) {
+                        cio_write(cio, tccp->prcw[i] + (tccp->prch[i] << 4), 1);        /* SPcox (I_i) */
+                }
+        }
+}
+
+static void j2k_read_cox(opj_j2k_t *j2k, int compno) {
+        int i;
+
+        opj_cp_t *cp = j2k->cp;
+        opj_tcp_t *tcp = j2k->state == J2K_STATE_TPH ? &cp->tcps[j2k->curtileno] : j2k->default_tcp;
+        opj_tccp_t *tccp = &tcp->tccps[compno];
+        opj_cio_t *cio = j2k->cio;
+
+        tccp->numresolutions = cio_read(cio, 1) + 1;    /* SPcox (D) */
+
+        /* check the reduce value */
+        cp->reduce = int_min((tccp->numresolutions)-1, cp->reduce);
+        tccp->cblkw = cio_read(cio, 1) + 2;     /* SPcox (E) */
+        tccp->cblkh = cio_read(cio, 1) + 2;     /* SPcox (F) */
+        tccp->cblksty = cio_read(cio, 1);       /* SPcox (G) */
+        tccp->qmfbid = cio_read(cio, 1);        /* SPcox (H) */
+        if (tccp->csty & J2K_CP_CSTY_PRT) {
+                for (i = 0; i < tccp->numresolutions; i++) {
+                        int tmp = cio_read(cio, 1);     /* SPcox (I_i) */
+                        tccp->prcw[i] = tmp & 0xf;
+                        tccp->prch[i] = tmp >> 4;
+                }
+        }
+}
+
+static void j2k_write_cod(opj_j2k_t *j2k) {
+        opj_cp_t *cp = NULL;
+        opj_tcp_t *tcp = NULL;
+        int lenp, len;
+
+        opj_cio_t *cio = j2k->cio;
+        
+        cio_write(cio, J2K_MS_COD, 2);  /* COD */
+        
+        lenp = cio_tell(cio);
+        cio_skip(cio, 2);
+        
+        cp = j2k->cp;
+        tcp = &cp->tcps[j2k->curtileno];
+
+        cio_write(cio, tcp->csty, 1);           /* Scod */
+        cio_write(cio, tcp->prg, 1);            /* SGcod (A) */
+        cio_write(cio, tcp->numlayers, 2);      /* SGcod (B) */
+        cio_write(cio, tcp->mct, 1);            /* SGcod (C) */
+        
+        j2k_write_cox(j2k, 0);
+        len = cio_tell(cio) - lenp;
+        cio_seek(cio, lenp);
+        cio_write(cio, len, 2);         /* Lcod */
+        cio_seek(cio, lenp + len);
+}
+
+static void j2k_read_cod(opj_j2k_t *j2k) {
+        int len, i, pos;
+        
+        opj_cio_t *cio = j2k->cio;
+        opj_cp_t *cp = j2k->cp;
+        opj_tcp_t *tcp = j2k->state == J2K_STATE_TPH ? &cp->tcps[j2k->curtileno] : j2k->default_tcp;
+        opj_image_t *image = j2k->image;
+        
+        len = cio_read(cio, 2);                         /* Lcod */
+        tcp->csty = cio_read(cio, 1);           /* Scod */
+        tcp->prg = (OPJ_PROG_ORDER)cio_read(cio, 1);            /* SGcod (A) */
+        tcp->numlayers = cio_read(cio, 2);      /* SGcod (B) */
+        tcp->mct = cio_read(cio, 1);            /* SGcod (C) */
+        
+        pos = cio_tell(cio);
+        for (i = 0; i < image->numcomps; i++) {
+                tcp->tccps[i].csty = tcp->csty & J2K_CP_CSTY_PRT;
+                cio_seek(cio, pos);
+                j2k_read_cox(j2k, i);
+        }
+}
+
+static void j2k_write_coc(opj_j2k_t *j2k, int compno) {
+        int lenp, len;
+
+        opj_cp_t *cp = j2k->cp;
+        opj_tcp_t *tcp = &cp->tcps[j2k->curtileno];
+        opj_image_t *image = j2k->image;
+        opj_cio_t *cio = j2k->cio;
+        
+        cio_write(cio, J2K_MS_COC, 2);  /* COC */
+        lenp = cio_tell(cio);
+        cio_skip(cio, 2);
+        cio_write(cio, compno, image->numcomps <= 256 ? 1 : 2); /* Ccoc */
+        cio_write(cio, tcp->tccps[compno].csty, 1);     /* Scoc */
+        j2k_write_cox(j2k, compno);
+        len = cio_tell(cio) - lenp;
+        cio_seek(cio, lenp);
+        cio_write(cio, len, 2);                 /* Lcoc */
+        cio_seek(cio, lenp + len);
+}
+
+static void j2k_read_coc(opj_j2k_t *j2k) {
+        int len, compno;
+
+        opj_cp_t *cp = j2k->cp;
+        opj_tcp_t *tcp = j2k->state == J2K_STATE_TPH ? &cp->tcps[j2k->curtileno] : j2k->default_tcp;
+        opj_image_t *image = j2k->image;
+        opj_cio_t *cio = j2k->cio;
+        
+        len = cio_read(cio, 2);         /* Lcoc */
+        compno = cio_read(cio, image->numcomps <= 256 ? 1 : 2); /* Ccoc */
+        tcp->tccps[compno].csty = cio_read(cio, 1);     /* Scoc */
+        j2k_read_cox(j2k, compno);
+}
+
+static void j2k_write_qcx(opj_j2k_t *j2k, int compno) {
+        int bandno, numbands;
+        int expn, mant;
+        
+        opj_cp_t *cp = j2k->cp;
+        opj_tcp_t *tcp = &cp->tcps[j2k->curtileno];
+        opj_tccp_t *tccp = &tcp->tccps[compno];
+        opj_cio_t *cio = j2k->cio;
+        
+        cio_write(cio, tccp->qntsty + (tccp->numgbits << 5), 1);        /* Sqcx */
+        numbands = tccp->qntsty == J2K_CCP_QNTSTY_SIQNT ? 1 : tccp->numresolutions * 3 - 2;
+        
+        for (bandno = 0; bandno < numbands; bandno++) {
+                expn = tccp->stepsizes[bandno].expn;
+                mant = tccp->stepsizes[bandno].mant;
+                
+                if (tccp->qntsty == J2K_CCP_QNTSTY_NOQNT) {
+                        cio_write(cio, expn << 3, 1);   /* SPqcx_i */
+                } else {
+                        cio_write(cio, (expn << 11) + mant, 2); /* SPqcx_i */
+                }
+        }
+}
+
+static void j2k_read_qcx(opj_j2k_t *j2k, int compno, int len) {
+        int tmp;
+        int bandno, numbands;
+
+        opj_cp_t *cp = j2k->cp;
+        opj_tcp_t *tcp = j2k->state == J2K_STATE_TPH ? &cp->tcps[j2k->curtileno] : j2k->default_tcp;
+        opj_tccp_t *tccp = &tcp->tccps[compno];
+        opj_cio_t *cio = j2k->cio;
+
+        tmp = cio_read(cio, 1);         /* Sqcx */
+        tccp->qntsty = tmp & 0x1f;
+        tccp->numgbits = tmp >> 5;
+        numbands = (tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) ? 
+                1 : ((tccp->qntsty == J2K_CCP_QNTSTY_NOQNT) ? len - 1 : (len - 1) / 2);
+
+#ifdef USE_JPWL
+        if (j2k->cp->correct) {
+
+                /* if JPWL is on, we check whether there are too many subbands */
+                if ((numbands < 0) || (numbands >= J2K_MAXBANDS)) {
+                        opj_event_msg(j2k->cinfo, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
+                                "JPWL: bad number of subbands in Sqcx (%d)\n",
+                                numbands);
+                        if (!JPWL_ASSUME) {
+                                opj_event_msg(j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
+                                return;
+                        }
+                        /* we try to correct */
+                        numbands = 1;
+                        opj_event_msg(j2k->cinfo, EVT_WARNING, "- trying to adjust them\n"
+                                "- setting number of bands to %d => HYPOTHESIS!!!\n",
+                                numbands);
+                };
+
+        };
+#endif /* USE_JPWL */
+
+        for (bandno = 0; bandno < numbands; bandno++) {
+                int expn, mant;
+                if (tccp->qntsty == J2K_CCP_QNTSTY_NOQNT) {
+                        expn = cio_read(cio, 1) >> 3;   /* SPqcx_i */
+                        mant = 0;
+                } else {
+                        tmp = cio_read(cio, 2); /* SPqcx_i */
+                        expn = tmp >> 11;
+                        mant = tmp & 0x7ff;
+                }
+                tccp->stepsizes[bandno].expn = expn;
+                tccp->stepsizes[bandno].mant = mant;
+        }
+        
+        /* Add Antonin : if scalar_derived -> compute other stepsizes */
+        if (tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) {
+                for (bandno = 1; bandno < J2K_MAXBANDS; bandno++) {
+                        tccp->stepsizes[bandno].expn = 
+                                ((tccp->stepsizes[0].expn) - ((bandno - 1) / 3) > 0) ? 
+                                        (tccp->stepsizes[0].expn) - ((bandno - 1) / 3) : 0;
+                        tccp->stepsizes[bandno].mant = tccp->stepsizes[0].mant;
+                }
+        }
+        /* ddA */
+}
+
+static void j2k_write_qcd(opj_j2k_t *j2k) {
+        int lenp, len;
+
+        opj_cio_t *cio = j2k->cio;
+        
+        cio_write(cio, J2K_MS_QCD, 2);  /* QCD */
+        lenp = cio_tell(cio);
+        cio_skip(cio, 2);
+        j2k_write_qcx(j2k, 0);
+        len = cio_tell(cio) - lenp;
+        cio_seek(cio, lenp);
+        cio_write(cio, len, 2);                 /* Lqcd */
+        cio_seek(cio, lenp + len);
+}
+
+static void j2k_read_qcd(opj_j2k_t *j2k) {
+        int len, i, pos;
+
+        opj_cio_t *cio = j2k->cio;
+        opj_image_t *image = j2k->image;
+        
+        len = cio_read(cio, 2);         /* Lqcd */
+        pos = cio_tell(cio);
+        for (i = 0; i < image->numcomps; i++) {
+                cio_seek(cio, pos);
+                j2k_read_qcx(j2k, i, len - 2);
+        }
+}
+
+static void j2k_write_qcc(opj_j2k_t *j2k, int compno) {
+        int lenp, len;
+
+        opj_cio_t *cio = j2k->cio;
+        
+        cio_write(cio, J2K_MS_QCC, 2);  /* QCC */
+        lenp = cio_tell(cio);
+        cio_skip(cio, 2);
+        cio_write(cio, compno, j2k->image->numcomps <= 256 ? 1 : 2);    /* Cqcc */
+        j2k_write_qcx(j2k, compno);
+        len = cio_tell(cio) - lenp;
+        cio_seek(cio, lenp);
+        cio_write(cio, len, 2);                 /* Lqcc */
+        cio_seek(cio, lenp + len);
+}
+
+static void j2k_read_qcc(opj_j2k_t *j2k) {
+        int len, compno;
+        int numcomp = j2k->image->numcomps;
+        opj_cio_t *cio = j2k->cio;
+        
+        len = cio_read(cio, 2); /* Lqcc */
+        compno = cio_read(cio, numcomp <= 256 ? 1 : 2); /* Cqcc */
+
+#ifdef USE_JPWL
+        if (j2k->cp->correct) {
+
+                static int backup_compno = 0;
+
+                /* compno is negative or larger than the number of components!!! */
+                if ((compno < 0) || (compno >= numcomp)) {
+                        opj_event_msg(j2k->cinfo, EVT_ERROR,
+                                "JPWL: bad component number in QCC (%d out of a maximum of %d)\n",
+                                compno, numcomp);
+                        if (!JPWL_ASSUME) {
+                                opj_event_msg(j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
+                                return;
+                        }
+                        /* we try to correct */
+                        compno = backup_compno % numcomp;
+                        opj_event_msg(j2k->cinfo, EVT_WARNING, "- trying to adjust this\n"
+                                "- setting component number to %d\n",
+                                compno);
+                }
+
+                /* keep your private count of tiles */
+                backup_compno++;
+        };
+#endif /* USE_JPWL */
+
+        j2k_read_qcx(j2k, compno, len - 2 - (numcomp <= 256 ? 1 : 2));
+}
+
+static void j2k_write_poc(opj_j2k_t *j2k) {
+        int len, numpchgs, i;
+
+        int numcomps = j2k->image->numcomps;
+        
+        opj_cp_t *cp = j2k->cp;
+        opj_tcp_t *tcp = &cp->tcps[j2k->curtileno];
+        opj_tccp_t *tccp = &tcp->tccps[0];
+        opj_cio_t *cio = j2k->cio;
+
+        numpchgs = 1 + tcp->numpocs;
+        cio_write(cio, J2K_MS_POC, 2);  /* POC  */
+        len = 2 + (5 + 2 * (numcomps <= 256 ? 1 : 2)) * numpchgs;
+        cio_write(cio, len, 2);         /* Lpoc */
+        for (i = 0; i < numpchgs; i++) {
+                opj_poc_t *poc = &tcp->pocs[i];
+                cio_write(cio, poc->resno0, 1); /* RSpoc_i */
+                cio_write(cio, poc->compno0, (numcomps <= 256 ? 1 : 2));        /* CSpoc_i */
+                cio_write(cio, poc->layno1, 2); /* LYEpoc_i */
+                poc->layno1 = int_min(poc->layno1, tcp->numlayers);
+                cio_write(cio, poc->resno1, 1); /* REpoc_i */
+                poc->resno1 = int_min(poc->resno1, tccp->numresolutions);
+                cio_write(cio, poc->compno1, (numcomps <= 256 ? 1 : 2));        /* CEpoc_i */
+                poc->compno1 = int_min(poc->compno1, numcomps);
+                cio_write(cio, poc->prg, 1);    /* Ppoc_i */
+        }
+}
+
+static void j2k_read_poc(opj_j2k_t *j2k) {
+        int len, numpchgs, i, old_poc;
+
+        int numcomps = j2k->image->numcomps;
+        
+        opj_cp_t *cp = j2k->cp;
+        opj_tcp_t *tcp = j2k->state == J2K_STATE_TPH ? &cp->tcps[j2k->curtileno] : j2k->default_tcp;
+        opj_tccp_t *tccp = &tcp->tccps[0];
+        opj_cio_t *cio = j2k->cio;
+        
+        old_poc = tcp->POC ? tcp->numpocs + 1 : 0;
+        tcp->POC = 1;
+        len = cio_read(cio, 2);         /* Lpoc */
+        numpchgs = (len - 2) / (5 + 2 * (numcomps <= 256 ? 1 : 2));
+        
+        for (i = old_poc; i < numpchgs + old_poc; i++) {
+                opj_poc_t *poc;
+                poc = &tcp->pocs[i];
+                poc->resno0 = cio_read(cio, 1); /* RSpoc_i */
+                poc->compno0 = cio_read(cio, numcomps <= 256 ? 1 : 2);  /* CSpoc_i */
+                poc->layno1 = cio_read(cio, 2);    /* LYEpoc_i */
+                poc->resno1 = cio_read(cio, 1);    /* REpoc_i */
+                poc->compno1 = int_min(
+                        cio_read(cio, numcomps <= 256 ? 1 : 2), (unsigned int) numcomps);       /* CEpoc_i */
+                poc->prg = (OPJ_PROG_ORDER)cio_read(cio, 1);    /* Ppoc_i */
+        }
+        
+        tcp->numpocs = numpchgs + old_poc - 1;
+}
+
+static void j2k_read_crg(opj_j2k_t *j2k) {
+        int len, i, Xcrg_i, Ycrg_i;
+        
+        opj_cio_t *cio = j2k->cio;
+        int numcomps = j2k->image->numcomps;
+        
+        len = cio_read(cio, 2);                 /* Lcrg */
+        for (i = 0; i < numcomps; i++) {
+                Xcrg_i = cio_read(cio, 2);      /* Xcrg_i */
+                Ycrg_i = cio_read(cio, 2);      /* Ycrg_i */
+        }
+}
+
+static void j2k_read_tlm(opj_j2k_t *j2k) {
+        int len, Ztlm, Stlm, ST, SP, tile_tlm, i;
+        long int Ttlm_i, Ptlm_i;
+
+        opj_cio_t *cio = j2k->cio;
+        
+        len = cio_read(cio, 2);         /* Ltlm */
+        Ztlm = cio_read(cio, 1);        /* Ztlm */
+        Stlm = cio_read(cio, 1);        /* Stlm */
+        ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
+        SP = (Stlm >> 6) & 0x01;
+        tile_tlm = (len - 4) / ((SP + 1) * 2 + ST);
+        for (i = 0; i < tile_tlm; i++) {
+                Ttlm_i = cio_read(cio, ST);     /* Ttlm_i */
+                Ptlm_i = cio_read(cio, SP ? 4 : 2);     /* Ptlm_i */
+        }
+}
+
+static void j2k_read_plm(opj_j2k_t *j2k) {
+        int len, i, Zplm, Nplm, add, packet_len = 0;
+        
+        opj_cio_t *cio = j2k->cio;
+
+        len = cio_read(cio, 2);         /* Lplm */
+        Zplm = cio_read(cio, 1);        /* Zplm */
+        len -= 3;
+        while (len > 0) {
+                Nplm = cio_read(cio, 4);                /* Nplm */
+                len -= 4;
+                for (i = Nplm; i > 0; i--) {
+                        add = cio_read(cio, 1);
+                        len--;
+                        packet_len = (packet_len << 7) + add;   /* Iplm_ij */
+                        if ((add & 0x80) == 0) {
+                                /* New packet */
+                                packet_len = 0;
+                        }
+                        if (len <= 0)
+                                break;
+                }
+        }
+}
+
+static void j2k_read_plt(opj_j2k_t *j2k) {
+        int len, i, Zplt, packet_len = 0, add;
+        
+        opj_cio_t *cio = j2k->cio;
+        
+        len = cio_read(cio, 2);         /* Lplt */
+        Zplt = cio_read(cio, 1);        /* Zplt */
+        for (i = len - 3; i > 0; i--) {
+                add = cio_read(cio, 1);
+                packet_len = (packet_len << 7) + add;   /* Iplt_i */
+                if ((add & 0x80) == 0) {
+                        /* New packet */
+                        packet_len = 0;
+                }
+        }
+}
+
+static void j2k_read_ppm(opj_j2k_t *j2k) {
+        int len, Z_ppm, i, j;
+        int N_ppm;
+
+        opj_cp_t *cp = j2k->cp;
+        opj_cio_t *cio = j2k->cio;
+        
+        len = cio_read(cio, 2);
+        cp->ppm = 1;
+        
+        Z_ppm = cio_read(cio, 1);       /* Z_ppm */
+        len -= 3;
+        while (len > 0) {
+                if (cp->ppm_previous == 0) {
+                        N_ppm = cio_read(cio, 4);       /* N_ppm */
+                        len -= 4;
+                } else {
+                        N_ppm = cp->ppm_previous;
+                }
+                j = cp->ppm_store;
+                if (Z_ppm == 0) {       /* First PPM marker */
+                        cp->ppm_data = (unsigned char *) opj_malloc(N_ppm * sizeof(unsigned char));
+                        cp->ppm_data_first = cp->ppm_data;
+                        cp->ppm_len = N_ppm;
+                } else {                        /* NON-first PPM marker */
+                        cp->ppm_data = (unsigned char *) opj_realloc(cp->ppm_data, (N_ppm +     cp->ppm_store) * sizeof(unsigned char));
+
+#ifdef USE_JPWL
+                        /* this memory allocation check could be done even in non-JPWL cases */
+                        if (cp->correct) {
+                                if (!cp->ppm_data) {
+                                        opj_event_msg(j2k->cinfo, EVT_ERROR,
+                                                "JPWL: failed memory allocation during PPM marker parsing (pos. %x)\n",
+                                                cio_tell(cio));
+                                        if (!JPWL_ASSUME || JPWL_ASSUME) {
+                                                free(cp->ppm_data);
+                                                opj_event_msg(j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
+                                                return;
+                                        }
+                                }
+                        }
+#endif
+
+                        cp->ppm_data_first = cp->ppm_data;
+                        cp->ppm_len = N_ppm + cp->ppm_store;
+                }
+                for (i = N_ppm; i > 0; i--) {   /* Read packet header */
+                        cp->ppm_data[j] = cio_read(cio, 1);
+                        j++;
+                        len--;
+                        if (len == 0)
+                                break;                  /* Case of non-finished packet header in present marker but finished in next one */
+                }
+                cp->ppm_previous = i - 1;
+                cp->ppm_store = j;
+        }
+}
+
+static void j2k_read_ppt(opj_j2k_t *j2k) {
+        int len, Z_ppt, i, j = 0;
+
+        opj_cp_t *cp = j2k->cp;
+        opj_tcp_t *tcp = cp->tcps + j2k->curtileno;
+        opj_cio_t *cio = j2k->cio;
+
+        len = cio_read(cio, 2);
+        Z_ppt = cio_read(cio, 1);
+        tcp->ppt = 1;
+        if (Z_ppt == 0) {               /* First PPT marker */
+                tcp->ppt_data = (unsigned char *) opj_malloc((len - 3) * sizeof(unsigned char));
+                tcp->ppt_data_first = tcp->ppt_data;
+                tcp->ppt_store = 0;
+                tcp->ppt_len = len - 3;
+        } else {                        /* NON-first PPT marker */
+                tcp->ppt_data = (unsigned char *) opj_realloc(tcp->ppt_data, (len - 3 + tcp->ppt_store) * sizeof(unsigned char));
+                tcp->ppt_data_first = tcp->ppt_data;
+                tcp->ppt_len = len - 3 + tcp->ppt_store;
+        }
+        j = tcp->ppt_store;
+        for (i = len - 3; i > 0; i--) {
+                tcp->ppt_data[j] = cio_read(cio, 1);
+                j++;
+        }
+        tcp->ppt_store = j;
+}
+
+static void j2k_write_tlm(opj_j2k_t *j2k){
+        int lenp;
+        opj_cio_t *cio = j2k->cio;
+        j2k->tlm_start = cio_tell(cio);
+        cio_write(cio, J2K_MS_TLM, 2);/* TLM */
+        lenp = 4 + (5*j2k->totnum_tp);
+        cio_write(cio,lenp,2);                          /* Ltlm */
+        cio_write(cio, 0,1);                                    /* Ztlm=0*/
+        cio_write(cio,80,1);                                    /* Stlm ST=1(8bits-255 tiles max),SP=1(Ptlm=32bits) */
+        cio_skip(cio,5*j2k->totnum_tp);
+}
+
+static void j2k_write_sot(opj_j2k_t *j2k) {
+        int lenp, len;
+
+        opj_cio_t *cio = j2k->cio;
+
+        j2k->sot_start = cio_tell(cio);
+        cio_write(cio, J2K_MS_SOT, 2);          /* SOT */
+        lenp = cio_tell(cio);
+        cio_skip(cio, 2);                                       /* Lsot (further) */
+        cio_write(cio, j2k->curtileno, 2);      /* Isot */
+        cio_skip(cio, 4);                                       /* Psot (further in j2k_write_sod) */
+        cio_write(cio, j2k->cur_tp_num , 1);    /* TPsot */
+        cio_write(cio, j2k->cur_totnum_tp[j2k->curtileno], 1);          /* TNsot */
+        len = cio_tell(cio) - lenp;
+        cio_seek(cio, lenp);
+        cio_write(cio, len, 2);                         /* Lsot */
+        cio_seek(cio, lenp + len);
+}
+
+static void j2k_read_sot(opj_j2k_t *j2k) {
+        int len, tileno, totlen, partno, numparts, i;
+        opj_tcp_t *tcp = NULL;
+        char status = 0;
+
+        opj_cp_t *cp = j2k->cp;
+        opj_cio_t *cio = j2k->cio;
+        
+        len = cio_read(cio, 2);
+        tileno = cio_read(cio, 2);
+
+#ifdef USE_JPWL
+        if (j2k->cp->correct) {
+
+                static int backup_tileno = 0;
+
+                /* tileno is negative or larger than the number of tiles!!! */
+                if ((tileno < 0) || (tileno > (cp->tw * cp->th))) {
+                        opj_event_msg(j2k->cinfo, EVT_ERROR,
+                                "JPWL: bad tile number (%d out of a maximum of %d)\n",
+                                tileno, (cp->tw * cp->th));
+                        if (!JPWL_ASSUME) {
+                                opj_event_msg(j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
+                                return;
+                        }
+                        /* we try to correct */
+                        tileno = backup_tileno;
+                        opj_event_msg(j2k->cinfo, EVT_WARNING, "- trying to adjust this\n"
+                                "- setting tile number to %d\n",
+                                tileno);
+                }
+
+                /* keep your private count of tiles */
+                backup_tileno++;
+        };
+#endif /* USE_JPWL */
+
+        
+        if (cp->tileno_size == 0) {
+                cp->tileno[cp->tileno_size] = tileno;
+                cp->tileno_size++;
+        } else {
+                i = 0;
+                while (i < cp->tileno_size && status == 0) {
+                        status = cp->tileno[i] == tileno ? 1 : 0;
+                        i++;
+                }
+                if (status == 0) {
+                        cp->tileno[cp->tileno_size] = tileno;
+                        cp->tileno_size++;
+                }
+        }
+        
+        totlen = cio_read(cio, 4);
+
+#ifdef USE_JPWL
+        if (j2k->cp->correct) {
+
+                /* totlen is negative or larger than the bytes left!!! */
+                if ((totlen < 0) || (totlen > (cio_numbytesleft(cio) + 8))) {
+                        opj_event_msg(j2k->cinfo, EVT_ERROR,
+                                "JPWL: bad tile byte size (%d bytes against %d bytes left)\n",
+                                totlen, cio_numbytesleft(cio) + 8);
+                        if (!JPWL_ASSUME) {
+                                opj_event_msg(j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
+                                return;
+                        }
+                        /* we try to correct */
+                        totlen = 0;
+                        opj_event_msg(j2k->cinfo, EVT_WARNING, "- trying to adjust this\n"
+                                "- setting Psot to %d => assuming it is the last tile\n",
+                                totlen);
+                }
+
+        };
+#endif /* USE_JPWL */
+
+        if (!totlen)
+                totlen = cio_numbytesleft(cio) + 8;
+        
+        partno = cio_read(cio, 1);
+        numparts = cio_read(cio, 1);
+        
+        j2k->curtileno = tileno;
+        j2k->eot = cio_getbp(cio) - 12 + totlen;
+        j2k->state = J2K_STATE_TPH;
+        tcp = &cp->tcps[j2k->curtileno];
+        
+        if (tcp->first == 1) {
+                
+                /* Initialization PPT */
+                opj_tccp_t *tmp = tcp->tccps;
+                memcpy(tcp, j2k->default_tcp, sizeof(opj_tcp_t));
+                tcp->ppt = 0;
+                tcp->ppt_data = NULL;
+                tcp->ppt_data_first = NULL;
+                tcp->tccps = tmp;
+
+                for (i = 0; i < j2k->image->numcomps; i++) {
+                        tcp->tccps[i] = j2k->default_tcp->tccps[i];
+                }
+                cp->tcps[j2k->curtileno].first = 0;
+        }
+}
+
+static void j2k_write_sod(opj_j2k_t *j2k, void *tile_coder) {
+        int l, layno;
+        int totlen;
+        opj_tcp_t *tcp = NULL;
+        opj_image_info_t *image_info = NULL;
+        
+        opj_tcd_t *tcd = (opj_tcd_t*)tile_coder;        /* cast is needed because of conflicts in header inclusions */
+        opj_cp_t *cp = j2k->cp;
+        opj_cio_t *cio = j2k->cio;
+
+        tcd->tp_num = j2k->tp_num ;
+        tcd->cur_tp_num = j2k->cur_tp_num;
+        tcd->cur_totnum_tp = j2k->cur_totnum_tp[j2k->curtileno];
+        
+        cio_write(cio, J2K_MS_SOD, 2);
+        if (j2k->curtileno == 0) {
+                j2k->sod_start = cio_tell(cio) + j2k->pos_correction;
+        }
+        
+        /* INDEX >> */
+        image_info = j2k->image_info;
+        if (image_info && image_info->index_on) {
+                image_info->tile[j2k->curtileno].end_header = cio_tell(cio) + j2k->pos_correction - 1;
+        }
+        /* << INDEX */
+        
+        tcp = &cp->tcps[j2k->curtileno];
+        for (layno = 0; layno < tcp->numlayers; layno++) {
+                tcp->rates[layno] -= tcp->rates[layno] ? (j2k->sod_start / (cp->th * cp->tw)) : 0;
+        }
+        if(image_info) {
+                image_info->num = 0;
+        }
+        
+        l = tcd_encode_tile(tcd, j2k->curtileno, cio_getbp(cio), cio_numbytesleft(cio) - 2, image_info);
+        
+        /* Writing Psot in SOT marker */
+        totlen = cio_tell(cio) + l - j2k->sot_start;
+        cio_seek(cio, j2k->sot_start + 6);
+        cio_write(cio, totlen, 4);
+        cio_seek(cio, j2k->sot_start + totlen);
+        /* Writing Ttlm and Ptlm in TLM marker */
+        if(cp->cinema){
+                cio_seek(cio, j2k->tlm_start + 6 + (5*j2k->cur_tp_num));
+                cio_write(cio, j2k->curtileno, 1);
+                cio_write(cio, totlen, 4);
+        }
+        cio_seek(cio, j2k->sot_start + totlen);
+}
+
+static void j2k_read_sod(opj_j2k_t *j2k) {
+        int len, truncate = 0, i;
+        unsigned char *data = NULL, *data_ptr = NULL;
+
+        opj_cio_t *cio = j2k->cio;
+        int curtileno = j2k->curtileno;
+        
+        len = int_min(j2k->eot - cio_getbp(cio), cio_numbytesleft(cio) + 1);
+        
+        if (len == cio_numbytesleft(cio) + 1) {
+                truncate = 1;           /* Case of a truncate codestream */
+        }
+        
+        data = (unsigned char *) opj_malloc((j2k->tile_len[curtileno] + len) * sizeof(unsigned char));
+
+        for (i = 0; i < j2k->tile_len[curtileno]; i++) {
+                data[i] = j2k->tile_data[curtileno][i];
+        }
+
+        data_ptr = data + j2k->tile_len[curtileno];
+        for (i = 0; i < len; i++) {
+                data_ptr[i] = cio_read(cio, 1);
+        }
+        
+        j2k->tile_len[curtileno] += len;
+        opj_free(j2k->tile_data[curtileno]);
+        j2k->tile_data[curtileno] = data;
+        
+        if (!truncate) {
+                j2k->state = J2K_STATE_TPHSOT;
+        } else {
+                j2k->state = J2K_STATE_NEOC;    /* RAJOUTE !! */
+        }
+}
+
+static void j2k_write_rgn(opj_j2k_t *j2k, int compno, int tileno) {
+        
+        opj_cp_t *cp = j2k->cp;
+        opj_tcp_t *tcp = &cp->tcps[tileno];
+        opj_cio_t *cio = j2k->cio;
+        int numcomps = j2k->image->numcomps;
+        
+        cio_write(cio, J2K_MS_RGN, 2);                                          /* RGN  */
+        cio_write(cio, numcomps <= 256 ? 5 : 6, 2);                     /* Lrgn */
+        cio_write(cio, compno, numcomps <= 256 ? 1 : 2);        /* Crgn */
+        cio_write(cio, 0, 1);                                                           /* Srgn */
+        cio_write(cio, tcp->tccps[compno].roishift, 1);         /* SPrgn */
+}
+
+static void j2k_read_rgn(opj_j2k_t *j2k) {
+        int len, compno, roisty;
+
+        opj_cp_t *cp = j2k->cp;
+        opj_tcp_t *tcp = j2k->state == J2K_STATE_TPH ? &cp->tcps[j2k->curtileno] : j2k->default_tcp;
+        opj_cio_t *cio = j2k->cio;
+        int numcomps = j2k->image->numcomps;
+
+        len = cio_read(cio, 2);                                                                         /* Lrgn */
+        compno = cio_read(cio, numcomps <= 256 ? 1 : 2);                        /* Crgn */
+        roisty = cio_read(cio, 1);                                                                      /* Srgn */
+
+#ifdef USE_JPWL
+        if (j2k->cp->correct) {
+                /* totlen is negative or larger than the bytes left!!! */
+                if (compno >= numcomps) {
+                        opj_event_msg(j2k->cinfo, EVT_ERROR,
+                                "JPWL: bad component number in RGN (%d when there are only %d)\n",
+                                compno, numcomps);
+                        if (!JPWL_ASSUME || JPWL_ASSUME) {
+                                opj_event_msg(j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
+                                return;
+                        }
+                }
+        };
+#endif /* USE_JPWL */
+
+        tcp->tccps[compno].roishift = cio_read(cio, 1);                         /* SPrgn */
+}
+
+static void j2k_write_eoc(opj_j2k_t *j2k) {
+        opj_cio_t *cio = j2k->cio;
+        /* opj_event_msg(j2k->cinfo, "%.8x: EOC\n", cio_tell(cio) + j2k->pos_correction); */
+        cio_write(cio, J2K_MS_EOC, 2);
+}
+
+static void j2k_read_eoc(opj_j2k_t *j2k) {
+        int i, tileno;
+
+        /* if packets should be decoded */
+        if (j2k->cp->limit_decoding != DECODE_ALL_BUT_PACKETS) {
+                opj_tcd_t *tcd = tcd_create(j2k->cinfo);
+                tcd_malloc_decode(tcd, j2k->image, j2k->cp);
+                for (i = 0; i < j2k->cp->tileno_size; i++) {
+                        tileno = j2k->cp->tileno[i];
+                        tcd_decode_tile(tcd, j2k->tile_data[tileno], j2k->tile_len[tileno], tileno);
+                        opj_free(j2k->tile_data[tileno]);
+                        j2k->tile_data[tileno] = NULL;
+                }
+                tcd_free_decode(tcd);
+                tcd_destroy(tcd);
+        }
+        /* if packets should not be decoded  */
+        else {
+                for (i = 0; i < j2k->cp->tileno_size; i++) {
+                        tileno = j2k->cp->tileno[i];
+                        opj_free(j2k->tile_data[tileno]);
+                        j2k->tile_data[tileno] = NULL;
+                }
+        }
+        
+        j2k->state = J2K_STATE_MT;
+}
+
+typedef struct opj_dec_mstabent {
+        /** marker value */
+        int id;
+        /** value of the state when the marker can appear */
+        int states;
+        /** action linked to the marker */
+        void (*handler) (opj_j2k_t *j2k);
+} opj_dec_mstabent_t;
+
+opj_dec_mstabent_t j2k_dec_mstab[] = {
+  {J2K_MS_SOC, J2K_STATE_MHSOC, j2k_read_soc},
+  {J2K_MS_SOT, J2K_STATE_MH | J2K_STATE_TPHSOT, j2k_read_sot},
+  {J2K_MS_SOD, J2K_STATE_TPH, j2k_read_sod},
+  {J2K_MS_EOC, J2K_STATE_TPHSOT, j2k_read_eoc},
+  {J2K_MS_SIZ, J2K_STATE_MHSIZ, j2k_read_siz},
+  {J2K_MS_COD, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_cod},
+  {J2K_MS_COC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_coc},
+  {J2K_MS_RGN, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_rgn},
+  {J2K_MS_QCD, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_qcd},
+  {J2K_MS_QCC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_qcc},
+  {J2K_MS_POC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_poc},
+  {J2K_MS_TLM, J2K_STATE_MH, j2k_read_tlm},
+  {J2K_MS_PLM, J2K_STATE_MH, j2k_read_plm},
+  {J2K_MS_PLT, J2K_STATE_TPH, j2k_read_plt},
+  {J2K_MS_PPM, J2K_STATE_MH, j2k_read_ppm},
+  {J2K_MS_PPT, J2K_STATE_TPH, j2k_read_ppt},
+  {J2K_MS_SOP, 0, 0},
+  {J2K_MS_CRG, J2K_STATE_MH, j2k_read_crg},
+  {J2K_MS_COM, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_com},
+
+#ifdef USE_JPWL
+  {J2K_MS_EPC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_epc},
+  {J2K_MS_EPB, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_epb},
+  {J2K_MS_ESD, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_esd},
+  {J2K_MS_RED, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_red},
+#endif /* USE_JPWL */
+
+  {0, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_unk}
+};
+
+static void j2k_read_unk(opj_j2k_t *j2k) {
+        opj_event_msg(j2k->cinfo, EVT_WARNING, "Unknown marker\n");
+
+#ifdef USE_JPWL
+        if (j2k->cp->correct) {
+                int m = 0, id, i;
+                int min_id = 0, min_dist = 17, cur_dist = 0, tmp_id;
+                cio_seek(j2k->cio, cio_tell(j2k->cio) - 2);
+                id = cio_read(j2k->cio, 2);
+                opj_event_msg(j2k->cinfo, EVT_ERROR,
+                        "JPWL: really don't know this marker %x\n",
+                        id);
+                if (!JPWL_ASSUME) {
+                        opj_event_msg(j2k->cinfo, EVT_ERROR,
+                                "- possible synch loss due to uncorrectable codestream errors => giving up\n");
+                        return;
+                }
+                /* OK, activate this at your own risk!!! */
+                /* we look for the marker at the minimum hamming distance from this */
+                while (j2k_dec_mstab[m].id) {
+                        
+                        /* 1's where they differ */
+                        tmp_id = j2k_dec_mstab[m].id ^ id;
+
+                        /* compute the hamming distance between our id and the current */
+                        cur_dist = 0;
+                        for (i = 0; i < 16; i++) {
+                                if ((tmp_id >> i) & 0x0001) {
+                                        cur_dist++;
+                                }
+                        }
+
+                        /* if current distance is smaller, set the minimum */
+                        if (cur_dist < min_dist) {
+                                min_dist = cur_dist;
+                                min_id = j2k_dec_mstab[m].id;
+                        }
+                        
+                        /* jump to the next marker */
+                        m++;
+                }
+
+                /* do we substitute the marker? */
+                if (min_dist < JPWL_MAXIMUM_HAMMING) {
+                        opj_event_msg(j2k->cinfo, EVT_ERROR,
+                                "- marker %x is at distance %d from the read %x\n",
+                                min_id, min_dist, id);
+                        opj_event_msg(j2k->cinfo, EVT_ERROR,
+                                "- trying to substitute in place and crossing fingers!\n");
+                        cio_seek(j2k->cio, cio_tell(j2k->cio) - 2);
+                        cio_write(j2k->cio, min_id, 2);
+
+                        /* rewind */
+                        cio_seek(j2k->cio, cio_tell(j2k->cio) - 2);
+
+                }
+
+        };
+#endif /* USE_JPWL */
+
+}
+
+/**
+Read the lookup table containing all the marker, status and action
+@param id Marker value
+*/
+static opj_dec_mstabent_t *j2k_dec_mstab_lookup(int id) {
+        opj_dec_mstabent_t *e;
+        for (e = j2k_dec_mstab; e->id != 0; e++) {
+                if (e->id == id) {
+                        break;
+                }
+        }
+        return e;
+}
+
+/* ----------------------------------------------------------------------- */
+/* J2K / JPT decoder interface                                             */
+/* ----------------------------------------------------------------------- */
+
+opj_j2k_t* j2k_create_decompress(opj_common_ptr cinfo) {
+        opj_j2k_t *j2k = (opj_j2k_t*)opj_malloc(sizeof(opj_j2k_t));
+        if(j2k) {
+                j2k->cinfo = cinfo;
+                j2k->default_tcp = (opj_tcp_t*)opj_malloc(sizeof(opj_tcp_t));
+                if(!j2k->default_tcp) {
+                        opj_free(j2k);
+                        return NULL;
+                }
+        }
+        return j2k;
+}
+
+void j2k_destroy_decompress(opj_j2k_t *j2k) {
+        int i = 0;
+
+        if(j2k->tile_len != NULL) {
+                opj_free(j2k->tile_len);
+        }
+        if(j2k->tile_data != NULL) {
+                opj_free(j2k->tile_data);
+        }
+        if(j2k->default_tcp != NULL) {
+                opj_tcp_t *default_tcp = j2k->default_tcp;
+                if(default_tcp->ppt_data_first != NULL) {
+                        opj_free(default_tcp->ppt_data_first);
+                }
+                if(j2k->default_tcp->tccps != NULL) {
+                        opj_free(j2k->default_tcp->tccps);
+                }
+                opj_free(j2k->default_tcp);
+        }
+        if(j2k->cp != NULL) {
+                opj_cp_t *cp = j2k->cp;
+                if(cp->tcps != NULL) {
+                        for(i = 0; i < cp->tw * cp->th; i++) {
+                                if(cp->tcps[i].ppt_data_first != NULL) {
+                                        opj_free(cp->tcps[i].ppt_data_first);
+                                }
+                                if(cp->tcps[i].tccps != NULL) {
+                                        opj_free(cp->tcps[i].tccps);
+                                }
+                        }
+                        opj_free(cp->tcps);
+                }
+                if(cp->ppm_data_first != NULL) {
+                        opj_free(cp->ppm_data_first);
+                }
+                if(cp->tileno != NULL) {
+                        opj_free(cp->tileno);  
+                }
+                if(cp->comment != NULL) {
+                        opj_free(cp->comment);
+                }
+
+                opj_free(cp);
+        }
+
+        opj_free(j2k);
+}
+
+void j2k_setup_decoder(opj_j2k_t *j2k, opj_dparameters_t *parameters) {
+        if(j2k && parameters) {
+                /* create and initialize the coding parameters structure */
+                opj_cp_t *cp = (opj_cp_t*)opj_malloc(sizeof(opj_cp_t));
+                cp->reduce = parameters->cp_reduce;     
+                cp->layer = parameters->cp_layer;
+                cp->limit_decoding = parameters->cp_limit_decoding;
+
+#ifdef USE_JPWL
+                cp->correct = parameters->jpwl_correct;
+                cp->exp_comps = parameters->jpwl_exp_comps;
+                cp->max_tiles = parameters->jpwl_max_tiles;
+#endif /* USE_JPWL */
+
+
+                /* keep a link to cp so that we can destroy it later in j2k_destroy_decompress */
+                j2k->cp = cp;
+        }
+}
+
+opj_image_t* j2k_decode(opj_j2k_t *j2k, opj_cio_t *cio) {
+        opj_image_t *image = NULL;
+
+        opj_common_ptr cinfo = j2k->cinfo;
+
+        j2k->cio = cio;
+
+        /* create an empty image */
+        image = opj_image_create0();
+        j2k->image = image;
+
+        j2k->state = J2K_STATE_MHSOC;
+
+        for (;;) {
+                opj_dec_mstabent_t *e;
+                int id = cio_read(cio, 2);
+
+
+#ifdef USE_JPWL
+                /* we try to honor JPWL correction power */
+                if (j2k->cp->correct) {
+
+                        int orig_pos = cio_tell(cio);
+                        bool status;
+
+                        /* call the corrector */
+                        status = jpwl_correct(j2k);
+
+                        /* go back to where you were */
+                        cio_seek(cio, orig_pos - 2);
+
+                        /* re-read the marker */
+                        id = cio_read(cio, 2);
+
+                        /* check whether it begins with ff */
+                        if (id >> 8 != 0xff) {
+                                opj_event_msg(cinfo, EVT_ERROR,
+                                        "JPWL: possible bad marker %x at %d\n",
+                                        id, cio_tell(cio) - 2);
+                                if (!JPWL_ASSUME) {
+                                        opj_image_destroy(image);
+                                        opj_event_msg(cinfo, EVT_ERROR, "JPWL: giving up\n");
+                                        return 0;
+                                }
+                                /* we try to correct */
+                                id = id | 0xff00;
+                                cio_seek(cio, cio_tell(cio) - 2);
+                                cio_write(cio, id, 2);
+                                opj_event_msg(cinfo, EVT_WARNING, "- trying to adjust this\n"
+                                        "- setting marker to %x\n",
+                                        id);
+                        }
+
+                }
+#endif /* USE_JPWL */
+
+                if (id >> 8 != 0xff) {
+                        opj_image_destroy(image);
+                        opj_event_msg(cinfo, EVT_ERROR, "%.8x: expected a marker instead of %x\n", cio_tell(cio) - 2, id);
+                        return 0;
+                }
+                e = j2k_dec_mstab_lookup(id);
+                // Check if the marker is known
+                if (!(j2k->state & e->states)) {
+                        opj_image_destroy(image);
+                        opj_event_msg(cinfo, EVT_ERROR, "%.8x: unexpected marker %x\n", cio_tell(cio) - 2, id);
+                        return 0;
+                }
+                // Check if the decoding is limited to the main header
+                if (e->id == J2K_MS_SOT && j2k->cp->limit_decoding == LIMIT_TO_MAIN_HEADER) {
+                        opj_event_msg(cinfo, EVT_INFO, "Main Header decoded.\n");
+                        return image;
+                }               
+
+                if (e->handler) {
+                        (*e->handler)(j2k);
+                }
+                if (j2k->state == J2K_STATE_MT) {
+                        break;
+                }
+                if (j2k->state == J2K_STATE_NEOC) {
+                        break;
+                }
+        }
+        if (j2k->state == J2K_STATE_NEOC) {
+                j2k_read_eoc(j2k);
+        }
+
+        if (j2k->state != J2K_STATE_MT) {
+                opj_event_msg(cinfo, EVT_WARNING, "Incomplete bitstream\n");
+        }
+
+        return image;
+}
+
+/*
+* Read a JPT-stream and decode file
+*
+*/
+opj_image_t* j2k_decode_jpt_stream(opj_j2k_t *j2k, opj_cio_t *cio) {
+        opj_image_t *image = NULL;
+        opj_jpt_msg_header_t header;
+        int position;
+
+        opj_common_ptr cinfo = j2k->cinfo;
+        
+        j2k->cio = cio;
+
+        /* create an empty image */
+        image = opj_image_create0();
+
+        j2k->state = J2K_STATE_MHSOC;
+        
+        /* Initialize the header */
+        jpt_init_msg_header(&header);
+        /* Read the first header of the message */
+        jpt_read_msg_header(cinfo, cio, &header);
+        
+        position = cio_tell(cio);
+        if (header.Class_Id != 6) {     /* 6 : Main header data-bin message */
+                opj_image_destroy(image);
+                opj_event_msg(cinfo, EVT_ERROR, "[JPT-stream] : Expecting Main header first [class_Id %d] !\n", header.Class_Id);
+                return 0;
+        }
+        
+        for (;;) {
+                opj_dec_mstabent_t *e = NULL;
+                int id;
+                
+                if (!cio_numbytesleft(cio)) {
+                        j2k_read_eoc(j2k);
+                        return image;
+                }
+                /* data-bin read -> need to read a new header */
+                if ((unsigned int) (cio_tell(cio) - position) == header.Msg_length) {
+                        jpt_read_msg_header(cinfo, cio, &header);
+                        position = cio_tell(cio);
+                        if (header.Class_Id != 4) {     /* 4 : Tile data-bin message */
+                                opj_image_destroy(image);
+                                opj_event_msg(cinfo, EVT_ERROR, "[JPT-stream] : Expecting Tile info !\n");
+                                return 0;
+                        }
+                }
+                
+                id = cio_read(cio, 2);
+                if (id >> 8 != 0xff) {
+                        opj_image_destroy(image);
+                        opj_event_msg(cinfo, EVT_ERROR, "%.8x: expected a marker instead of %x\n", cio_tell(cio) - 2, id);
+                        return 0;
+                }
+                e = j2k_dec_mstab_lookup(id);
+                if (!(j2k->state & e->states)) {
+                        opj_image_destroy(image);
+                        opj_event_msg(cinfo, EVT_ERROR, "%.8x: unexpected marker %x\n", cio_tell(cio) - 2, id);
+                        return 0;
+                }
+                if (e->handler) {
+                        (*e->handler)(j2k);
+                }
+                if (j2k->state == J2K_STATE_MT) {
+                        break;
+                }
+                if (j2k->state == J2K_STATE_NEOC) {
+                        break;
+                }
+        }
+        if (j2k->state == J2K_STATE_NEOC) {
+                j2k_read_eoc(j2k);
+        }
+        
+        if (j2k->state != J2K_STATE_MT) {
+                opj_event_msg(cinfo, EVT_WARNING, "Incomplete bitstream\n");
+        }
+
+        return image;
+}
+
+/* ----------------------------------------------------------------------- */
+/* J2K encoder interface                                                       */
+/* ----------------------------------------------------------------------- */
+
+opj_j2k_t* j2k_create_compress(opj_common_ptr cinfo) {
+        opj_j2k_t *j2k = (opj_j2k_t*)opj_malloc(sizeof(opj_j2k_t));
+        if(j2k) {
+                j2k->cinfo = cinfo;
+        }
+        return j2k;
+}
+
+void j2k_destroy_compress(opj_j2k_t *j2k) {
+        int tileno;
+
+        if(!j2k) return;
+
+        if(j2k->image_info != NULL) {
+                opj_image_info_t *image_info = j2k->image_info;
+                if (image_info->index_on && j2k->cp) {
+                        opj_cp_t *cp = j2k->cp;
+                        for (tileno = 0; tileno < cp->tw * cp->th; tileno++) {
+                                opj_tile_info_t *tile_info = &image_info->tile[tileno];
+                                opj_free(tile_info->thresh);
+                                opj_free(tile_info->packet);
+                        }
+                        opj_free(image_info->tile);
+                }
+                opj_free(image_info);
+        }
+        if(j2k->cp != NULL) {
+                opj_cp_t *cp = j2k->cp;
+
+                if(cp->comment) {
+                        opj_free(cp->comment);
+                }
+                if(cp->matrice) {
+                        opj_free(cp->matrice);
+                }
+                for (tileno = 0; tileno < cp->tw * cp->th; tileno++) {
+                        opj_free(cp->tcps[tileno].tccps);
+                }
+                opj_free(cp->tcps);
+                opj_free(cp);
+        }
+
+        opj_free(j2k);
+}
+
+void j2k_setup_encoder(opj_j2k_t *j2k, opj_cparameters_t *parameters, opj_image_t *image) {
+        int i, j, tileno, numpocs_tile;
+        opj_cp_t *cp = NULL;
+
+        if(!j2k || !parameters || ! image) {
+                return;
+        }
+
+        /* create and initialize the coding parameters structure */
+        cp = (opj_cp_t*)opj_malloc(sizeof(opj_cp_t));
+
+        /* keep a link to cp so that we can destroy it later in j2k_destroy_compress */
+        j2k->cp = cp;
+
+        /* set default values for cp */
+        cp->tw = 1;
+        cp->th = 1;
+
+        /* 
+        copy user encoding parameters 
+        */
+        cp->cinema = parameters->cp_cinema;
+        cp->max_comp_size =     parameters->max_comp_size;
+        cp->rsiz   = parameters->cp_rsiz;
+        cp->disto_alloc = parameters->cp_disto_alloc;
+        cp->fixed_alloc = parameters->cp_fixed_alloc;
+        cp->fixed_quality = parameters->cp_fixed_quality;
+
+        /* mod fixed_quality */
+        if(parameters->cp_matrice) {
+                size_t array_size = parameters->tcp_numlayers * parameters->numresolution * 3 * sizeof(int);
+                cp->matrice = (int *) opj_malloc(array_size);
+                memcpy(cp->matrice, parameters->cp_matrice, array_size);
+        }
+
+        /* creation of an index file ? */
+        cp->index_on = parameters->index_on;
+        if(cp->index_on) {
+                j2k->image_info = (opj_image_info_t*)opj_malloc(sizeof(opj_image_info_t));
+        }
+
+        /* tiles */
+        cp->tdx = parameters->cp_tdx;
+        cp->tdy = parameters->cp_tdy;
+
+        /* tile offset */
+        cp->tx0 = parameters->cp_tx0;
+        cp->ty0 = parameters->cp_ty0;
+
+        /* comment string */
+        if(parameters->cp_comment) {
+                cp->comment = (char*)opj_malloc(strlen(parameters->cp_comment) + 1);
+                if(cp->comment) {
+                        strcpy(cp->comment, parameters->cp_comment);
+                }
+        }
+
+        /*
+        calculate other encoding parameters
+        */
+
+        if (parameters->tile_size_on) {
+                cp->tw = int_ceildiv(image->x1 - cp->tx0, cp->tdx);
+                cp->th = int_ceildiv(image->y1 - cp->ty0, cp->tdy);
+        } else {
+                cp->tdx = image->x1 - cp->tx0;
+                cp->tdy = image->y1 - cp->ty0;
+        }
+
+        if(parameters->tp_on){
+                cp->tp_flag = parameters->tp_flag;
+                cp->tp_on = 1;
+        }
+        
+        cp->img_size = 0;
+        for(i=0;i<image->numcomps ;i++){
+        cp->img_size += (image->comps[i].w *image->comps[i].h * image->comps[i].prec);
+        }
+
+
+#ifdef USE_JPWL
+        /*
+        calculate JPWL encoding parameters
+        */
+
+        if (parameters->jpwl_epc_on) {
+                int i;
+
+                /* set JPWL on */
+                cp->epc_on = true;
+                cp->info_on = false; /* no informative technique */
+
+                /* set EPB on */
+                if ((parameters->jpwl_hprot_MH > 0) || (parameters->jpwl_hprot_TPH[0] > 0)) {
+                        cp->epb_on = true;
+                        
+                        cp->hprot_MH = parameters->jpwl_hprot_MH;
+                        for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {
+                                cp->hprot_TPH_tileno[i] = parameters->jpwl_hprot_TPH_tileno[i];
+                                cp->hprot_TPH[i] = parameters->jpwl_hprot_TPH[i];
+                        }
+                        /* if tile specs are not specified, copy MH specs */
+                        if (cp->hprot_TPH[0] == -1) {
+                                cp->hprot_TPH_tileno[0] = 0;
+                                cp->hprot_TPH[0] = parameters->jpwl_hprot_MH;
+                        }
+                        for (i = 0; i < JPWL_MAX_NO_PACKSPECS; i++) {
+                                cp->pprot_tileno[i] = parameters->jpwl_pprot_tileno[i];
+                                cp->pprot_packno[i] = parameters->jpwl_pprot_packno[i];
+                                cp->pprot[i] = parameters->jpwl_pprot[i];
+                        }
+                }
+
+                /* set ESD writing */
+                if ((parameters->jpwl_sens_size == 1) || (parameters->jpwl_sens_size == 2)) {
+                        cp->esd_on = true;
+
+                        cp->sens_size = parameters->jpwl_sens_size;
+                        cp->sens_addr = parameters->jpwl_sens_addr;
+                        cp->sens_range = parameters->jpwl_sens_range;
+
+                        cp->sens_MH = parameters->jpwl_sens_MH;
+                        for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {
+                                cp->sens_TPH_tileno[i] = parameters->jpwl_sens_TPH_tileno[i];
+                                cp->sens_TPH[i] = parameters->jpwl_sens_TPH[i];
+                        }
+                }
+
+                /* always set RED writing to false: we are at the encoder */
+                cp->red_on = false;
+
+        } else {
+                cp->epc_on = false;
+        }
+#endif /* USE_JPWL */
+
+
+        /* initialize the mutiple tiles */
+        /* ---------------------------- */
+        cp->tcps = (opj_tcp_t *) opj_malloc(cp->tw * cp->th * sizeof(opj_tcp_t));
+
+        for (tileno = 0; tileno < cp->tw * cp->th; tileno++) {
+                opj_tcp_t *tcp = &cp->tcps[tileno];
+                tcp->numlayers = parameters->tcp_numlayers;
+                for (j = 0; j < tcp->numlayers; j++) {
+                        if(cp->cinema){
+                                if (cp->fixed_quality) {
+                                        tcp->distoratio[j] = parameters->tcp_distoratio[j];
+                                }
+                                tcp->rates[j] = parameters->tcp_rates[j];
+                        }else{
+                                if (cp->fixed_quality) {        /* add fixed_quality */
+                                        tcp->distoratio[j] = parameters->tcp_distoratio[j];
+                                } else {
+                                        tcp->rates[j] = parameters->tcp_rates[j];
+                                }
+                        }
+                }
+                tcp->csty = parameters->csty;
+                tcp->prg = parameters->prog_order;
+                tcp->mct = parameters->tcp_mct; 
+
+                numpocs_tile = 0;
+                tcp->POC = 0;
+                if (parameters->numpocs) {
+                        /* initialisation of POC */
+                        tcp->POC = 1;
+                        j2k_check_poc_val(parameters, image->numcomps, tcp->numlayers);
+                        for (i = 0; i < parameters->numpocs; i++) {
+                                if((tileno == parameters->POC[i].tile - 1) || (parameters->POC[i].tile == -1)) {
+                                        opj_poc_t *tcp_poc = &tcp->pocs[numpocs_tile];
+                                        tcp_poc->resno0         = parameters->POC[numpocs_tile].resno0;
+                                        tcp_poc->compno0        = parameters->POC[numpocs_tile].compno0;
+                                        tcp_poc->layno1         = parameters->POC[numpocs_tile].layno1;
+                                        tcp_poc->resno1         = parameters->POC[numpocs_tile].resno1;
+                                        tcp_poc->compno1        = parameters->POC[numpocs_tile].compno1;
+                                        tcp_poc->prg1           = parameters->POC[numpocs_tile].prg1;
+                                        tcp_poc->tile           = parameters->POC[numpocs_tile].tile;
+                                        numpocs_tile++;
+                                }
+                        }
+                        tcp->numpocs = numpocs_tile -1 ;
+                }else{ 
+                        tcp->numpocs = 0;
+                }
+
+                tcp->tccps = (opj_tccp_t *) opj_malloc(image->numcomps * sizeof(opj_tccp_t));
+                
+                for (i = 0; i < image->numcomps; i++) {
+                        opj_tccp_t *tccp = &tcp->tccps[i];
+                        tccp->csty = parameters->csty & 0x01;   /* 0 => one precinct || 1 => custom precinct  */
+                        tccp->numresolutions = parameters->numresolution;
+                        tccp->cblkw = int_floorlog2(parameters->cblockw_init);
+                        tccp->cblkh = int_floorlog2(parameters->cblockh_init);
+                        tccp->cblksty = parameters->mode;
+                        tccp->qmfbid = parameters->irreversible ? 0 : 1;
+                        tccp->qntsty = parameters->irreversible ? J2K_CCP_QNTSTY_SEQNT : J2K_CCP_QNTSTY_NOQNT;
+                        tccp->numgbits = 2;
+                        if (i == parameters->roi_compno) {
+                                tccp->roishift = parameters->roi_shift;
+                        } else {
+                                tccp->roishift = 0;
+                        }
+
+                        if(parameters->cp_cinema)
+                        {
+                                //Precinct size for lowest frequency subband=128
+                                tccp->prcw[0] = 7;
+                                tccp->prch[0] = 7;
+                                //Precinct size at all other resolutions = 256
+                                for (j = 1; j < tccp->numresolutions; j++) {
+                                        tccp->prcw[j] = 8;
+                                        tccp->prch[j] = 8;
+                                }
+                        }else{
+                                if (parameters->csty & J2K_CCP_CSTY_PRT) {
+                                        int p = 0;
+                                        for (j = tccp->numresolutions - 1; j >= 0; j--) {
+                                                if (p < parameters->res_spec) {
+                                                        
+                                                        if (parameters->prcw_init[p] < 1) {
+                                                                tccp->prcw[j] = 1;
+                                                        } else {
+                                                                tccp->prcw[j] = int_floorlog2(parameters->prcw_init[p]);
+                                                        }
+                                                        
+                                                        if (parameters->prch_init[p] < 1) {
+                                                                tccp->prch[j] = 1;
+                                                        }else {
+                                                                tccp->prch[j] = int_floorlog2(parameters->prch_init[p]);
+                                                        }
+
+                                                } else {
+                                                        int res_spec = parameters->res_spec;
+                                                        int size_prcw = parameters->prcw_init[res_spec - 1] >> (p - (res_spec - 1));
+                                                        int size_prch = parameters->prch_init[res_spec - 1] >> (p - (res_spec - 1));
+                                                        
+                                                        if (size_prcw < 1) {
+                                                                tccp->prcw[j] = 1;
+                                                        } else {
+                                                                tccp->prcw[j] = int_floorlog2(size_prcw);
+                                                        }
+                                                        
+                                                        if (size_prch < 1) {
+                                                                tccp->prch[j] = 1;
+                                                        } else {
+                                                                tccp->prch[j] = int_floorlog2(size_prch);
+                                                        }
+                                                }
+                                                p++;
+                                                /*printf("\nsize precinct for level %d : %d,%d\n", j,tccp->prcw[j], tccp->prch[j]); */
+                                        }       //end for
+                                } else {
+                                        for (j = 0; j < tccp->numresolutions; j++) {
+                                                tccp->prcw[j] = 15;
+                                                tccp->prch[j] = 15;
+                                        }
+                                }
+                        }
+
+                        dwt_calc_explicit_stepsizes(tccp, image->comps[i].prec);
+                }
+        }
+}
+
+/**
+Create an index file
+@param j2k
+@param cio
+@param image_info
+@param index Index filename
+@return Returns 1 if successful, returns 0 otherwise
+*/
+static int j2k_create_index(opj_j2k_t *j2k, opj_cio_t *cio, opj_image_info_t *image_info, char *index) {
+        int tileno, compno, layno, resno, precno, pack_nb, x, y;
+        FILE *stream = NULL;
+        double total_disto = 0;
+
+        image_info->codestream_size = cio_tell(cio) + j2k->pos_correction;      /* Correction 14/4/03 suite rmq de Patrick */
+
+
+#ifdef USE_JPWL
+        /* if JPWL is enabled and the name coincides with our own set
+           then discard the creation of the file: this was just done to
+           enable indexing, we do not want an index file
+        */
+        if (j2k->cp->epc_on && !strcmp(index, JPWL_PRIVATEINDEX_NAME))
+                return 1;
+#endif /* USE_JPWL */
+
+
+        stream = fopen(index, "w");
+        if (!stream) {
+                opj_event_msg(j2k->cinfo, EVT_ERROR, "failed to open %s for writing\n", index);
+                return 0;
+        }
+        
+        fprintf(stream, "%d %d\n", image_info->image_w, image_info->image_h);
+        fprintf(stream, "%d\n", image_info->prog);
+        fprintf(stream, "%d %d\n", image_info->tile_x, image_info->tile_y);
+        fprintf(stream, "%d %d\n", image_info->tw, image_info->th);
+        fprintf(stream, "%d\n", image_info->comp);
+        fprintf(stream, "%d\n", image_info->layer);
+        fprintf(stream, "%d\n", image_info->decomposition);
+        
+        for (resno = image_info->decomposition; resno >= 0; resno--) {
+                fprintf(stream, "[%d,%d] ", 
+                        (1 << image_info->tile[0].pdx[resno]), (1 << image_info->tile[0].pdx[resno]));  /* based on tile 0 */
+        }
+        fprintf(stream, "\n");
+        fprintf(stream, "%d\n", image_info->main_head_end);
+        fprintf(stream, "%d\n", image_info->codestream_size);
+        
+        for (tileno = 0; tileno < image_info->tw * image_info->th; tileno++) {
+                fprintf(stream, "%4d %9d %9d %9d %9e %9d %9e\n",
+                        image_info->tile[tileno].num_tile,
+                        image_info->tile[tileno].start_pos,
+                        image_info->tile[tileno].end_header,
+                        image_info->tile[tileno].end_pos,
+                        image_info->tile[tileno].distotile, image_info->tile[tileno].nbpix,
+                        image_info->tile[tileno].distotile / image_info->tile[tileno].nbpix);
+        }
+        
+        for (tileno = 0; tileno < image_info->tw * image_info->th; tileno++) {
+                int start_pos, end_pos;
+                double disto = 0;
+                pack_nb = 0;
+                
+                /*
+                fprintf(stream, "pkno tileno layerno resno compno precno start_pos   end_pos       deltaSE        \n");
+                */
+                
+                if (image_info->prog == LRCP) { /* LRCP */
+                        /*
+                        fprintf(stream, "pack_nb tileno layno resno compno precno start_pos  end_pos   disto");
+                        */
+                        for (layno = 0; layno < image_info->layer; layno++) {
+                                for (resno = 0; resno < image_info->decomposition + 1; resno++) {
+                                        for (compno = 0; compno < image_info->comp; compno++) {
+                                                int prec_max = image_info->tile[tileno].pw[resno] * image_info->tile[tileno].ph[resno];
+                                                for (precno = 0; precno < prec_max; precno++) {
+                                                        start_pos = image_info->tile[tileno].packet[pack_nb].start_pos;
+                                                        end_pos = image_info->tile[tileno].packet[pack_nb].end_pos;
+                                                        disto = image_info->tile[tileno].packet[pack_nb].disto;
+                                                        fprintf(stream, "%4d %6d %7d %5d %6d %6d %9d %9d %8e\n",
+                                                                pack_nb, tileno, layno, resno, compno, precno, start_pos, end_pos, disto);
+                                                        total_disto += disto;
+                                                        pack_nb++;
+                                                }
+                                        }
+                                }
+                        }
+                } /* LRCP */
+                else if (image_info->prog == RLCP) {    /* RLCP */
+                        /*
+                        fprintf(stream, "pack_nb tileno resno layno compno precno start_pos  end_pos   disto");
+                        */
+                        for (resno = 0; resno < image_info->decomposition + 1; resno++) {
+                                for (layno = 0; layno < image_info->layer; layno++) {
+                                        for (compno = 0; compno < image_info->comp; compno++) {
+                                                int prec_max = image_info->tile[tileno].pw[resno] * image_info->tile[tileno].ph[resno];
+                                                for (precno = 0; precno < prec_max; precno++) {
+                                                        start_pos = image_info->tile[tileno].packet[pack_nb].start_pos;
+                                                        end_pos = image_info->tile[tileno].packet[pack_nb].end_pos;
+                                                        disto = image_info->tile[tileno].packet[pack_nb].disto;
+                                                        fprintf(stream, "%4d %6d %5d %7d %6d %6d %9d %9d %8e\n",
+                                                                pack_nb, tileno, resno, layno, compno, precno, start_pos, end_pos, disto);
+                                                        total_disto += disto;
+                                                        pack_nb++;
+                                                }
+                                        }
+                                }
+                        }
+                } /* RLCP */
+                else if (image_info->prog == RPCL) {    /* RPCL */
+                        /*
+                        fprintf(stream, "\npack_nb tileno resno precno compno layno start_pos  end_pos   disto\n"); 
+                        */
+                        for (resno = 0; resno < image_info->decomposition + 1; resno++) {
+                                /* I suppose components have same XRsiz, YRsiz */
+                                int x0 = image_info->tile_Ox + tileno - (int)floor( (float)tileno/(float)image_info->tw ) * image_info->tw * image_info->tile_x;
+                                int y0 = image_info->tile_Ox + (int)floor( (float)tileno/(float)image_info->tw ) * image_info->tile_y;
+                                int x1 = x0 + image_info->tile_x;
+                                int y1 = y0 + image_info->tile_y;
+                                for(y = y0; y < y1; y++) {
+                                        for(x = x0; x < x1; x++) {
+                                                for (compno = 0; compno < image_info->comp; compno++) {
+                                                        int prec_max = image_info->tile[tileno].pw[resno] * image_info->tile[tileno].ph[resno];
+                                                        for (precno = 0; precno < prec_max; precno++) {
+                                                                int pcnx = image_info->tile[tileno].pw[resno];
+                                                                int pcx = (int) pow( 2, image_info->tile[tileno].pdx[resno] + image_info->decomposition - resno );
+                                                                int pcy = (int) pow( 2, image_info->tile[tileno].pdy[resno] + image_info->decomposition - resno );
+                                                                int precno_x = precno - (int) floor( (float)precno/(float)pcnx ) * pcnx;
+                                                                int precno_y = (int) floor( (float)precno/(float)pcnx );
+                                                                if (precno_y*pcy == y ) {
+                                                                        if (precno_x*pcx == x ) {
+                                                                                for (layno = 0; layno < image_info->layer; layno++) {
+                                                                                        start_pos = image_info->tile[tileno].packet[pack_nb].start_pos;
+                                                                                        end_pos = image_info->tile[tileno].packet[pack_nb].end_pos;
+                                                                                        disto = image_info->tile[tileno].packet[pack_nb].disto;
+                                                                                        fprintf(stream, "%4d %6d %5d %6d %6d %7d %9d %9d %8e\n",
+                                                                                                pack_nb, tileno, resno, precno, compno, layno, start_pos, end_pos, disto); 
+                                                                                        total_disto += disto;
+                                                                                        pack_nb++; 
+                                                                                }
+                                                                        }
+                                                                }
+                                                        } /* precno */
+                                                } /* compno */
+                                        } /* x = x0..x1 */
+                                } /* y = y0..y1 */
+                        } /* resno */
+                } /* RPCL */
+                else if (image_info->prog == PCRL) {    /* PCRL */
+                        /* I suppose components have same XRsiz, YRsiz */
+                        int x0 = image_info->tile_Ox + tileno - (int)floor( (float)tileno/(float)image_info->tw ) * image_info->tw * image_info->tile_x;
+                        int y0 = image_info->tile_Ox + (int)floor( (float)tileno/(float)image_info->tw ) * image_info->tile_y;
+                        int x1 = x0 + image_info->tile_x;
+                        int y1 = y0 + image_info->tile_y;
+                        /*
+                        fprintf(stream, "\npack_nb tileno precno compno resno layno start_pos  end_pos   disto\n"); 
+                        */
+                        for(y = y0; y < y1; y++) {
+                                for(x = x0; x < x1; x++) {
+                                        for (compno = 0; compno < image_info->comp; compno++) {
+                                                for (resno = 0; resno < image_info->decomposition + 1; resno++) {
+                                                        int prec_max = image_info->tile[tileno].pw[resno] * image_info->tile[tileno].ph[resno];
+                                                        for (precno = 0; precno < prec_max; precno++) {
+                                                                int pcnx = image_info->tile[tileno].pw[resno];
+                                                                int pcx = (int) pow( 2, image_info->tile[tileno].pdx[resno] + image_info->decomposition - resno );
+                                                                int pcy = (int) pow( 2, image_info->tile[tileno].pdy[resno] + image_info->decomposition - resno );
+                                                                int precno_x = precno - (int) floor( (float)precno/(float)pcnx ) * pcnx;
+                                                                int precno_y = (int) floor( (float)precno/(float)pcnx );
+                                                                if (precno_y*pcy == y ) {
+                                                                        if (precno_x*pcx == x ) {
+                                                                                for (layno = 0; layno < image_info->layer; layno++) {
+                                                                                        start_pos = image_info->tile[tileno].packet[pack_nb].start_pos;
+                                                                                        end_pos = image_info->tile[tileno].packet[pack_nb].end_pos;
+                                                                                        disto = image_info->tile[tileno].packet[pack_nb].disto;
+                                                                                        fprintf(stream, "%4d %6d %6d %6d %5d %7d %9d %9d %8e\n",
+                                                                                                pack_nb, tileno, precno, compno, resno, layno, start_pos, end_pos, disto); 
+                                                                                        total_disto += disto;
+                                                                                        pack_nb++; 
+                                                                                }
+                                                                        }
+                                                                }
+                                                        } /* precno */
+                                                } /* resno */
+                                        } /* compno */
+                                } /* x = x0..x1 */
+                        } /* y = y0..y1 */
+                } /* PCRL */
+                else {  /* CPRL */
+                        /*
+                        fprintf(stream, "\npack_nb tileno compno precno resno layno start_pos  end_pos   disto\n"); 
+                        */
+                        for (compno = 0; compno < image_info->comp; compno++) {
+                                /* I suppose components have same XRsiz, YRsiz */
+                                int x0 = image_info->tile_Ox + tileno - (int)floor( (float)tileno/(float)image_info->tw ) * image_info->tw * image_info->tile_x;
+                                int y0 = image_info->tile_Ox + (int)floor( (float)tileno/(float)image_info->tw ) * image_info->tile_y;
+                                int x1 = x0 + image_info->tile_x;
+                                int y1 = y0 + image_info->tile_y;
+                                for(y = y0; y < y1; y++) {
+                                        for(x = x0; x < x1; x++) {
+                                                for (resno = 0; resno < image_info->decomposition + 1; resno++) {
+                                                        int prec_max = image_info->tile[tileno].pw[resno] * image_info->tile[tileno].ph[resno];
+                                                        for (precno = 0; precno < prec_max; precno++) {
+                                                                int pcnx = image_info->tile[tileno].pw[resno];
+                                                                int pcx = (int) pow( 2, image_info->tile[tileno].pdx[resno] + image_info->decomposition - resno );
+                                                                int pcy = (int) pow( 2, image_info->tile[tileno].pdy[resno] + image_info->decomposition - resno );
+                                                                int precno_x = precno - (int) floor( (float)precno/(float)pcnx ) * pcnx;
+                                                                int precno_y = (int) floor( (float)precno/(float)pcnx );
+                                                                if (precno_y*pcy == y ) {
+                                                                        if (precno_x*pcx == x ) {
+                                                                                for (layno = 0; layno < image_info->layer; layno++) {
+                                                                                        start_pos = image_info->tile[tileno].packet[pack_nb].start_pos;
+                                                                                        end_pos = image_info->tile[tileno].packet[pack_nb].end_pos;
+                                                                                        disto = image_info->tile[tileno].packet[pack_nb].disto;
+                                                                                        fprintf(stream, "%4d %6d %6d %6d %5d %7d %9d %9d %8e\n",
+                                                                                                pack_nb, tileno, compno, precno, resno, layno, start_pos, end_pos, disto); 
+                                                                                        total_disto += disto;
+                                                                                        pack_nb++; 
+                                                                                }
+                                                                        }
+                                                                }
+                                                        } /* precno */
+                                                } /* resno */
+                                        } /* x = x0..x1 */
+                                } /* y = y0..y1 */
+                        } /* comno */
+                } /* CPRL */   
+        } /* tileno */
+        
+        fprintf(stream, "%8e\n", image_info->D_max); /* SE max */
+        fprintf(stream, "%.8e\n", total_disto); /* SE totale */
+        fclose(stream);
+
+        return 1;
+}
+
+bool j2k_encode(opj_j2k_t *j2k, opj_cio_t *cio, opj_image_t *image, char *index) {
+        int tileno, compno;
+        opj_image_info_t *image_info = NULL;
+        opj_cp_t *cp = NULL;
+
+        opj_tcd_t *tcd = NULL;  /* TCD component */
+
+        j2k->cio = cio; 
+        j2k->image = image;
+
+        cp = j2k->cp;
+
+        /* j2k_dump_cp(stdout, image, cp); */
+
+        /* INDEX >> */
+        image_info = j2k->image_info;
+        if (image_info && cp->index_on) {
+                image_info->index_on = cp->index_on;
+                image_info->tile = (opj_tile_info_t *) opj_malloc(cp->tw * cp->th * sizeof(opj_tile_info_t));
+                image_info->image_w = image->x1 - image->x0;
+                image_info->image_h = image->y1 - image->y0;
+                image_info->prog = (&cp->tcps[0])->prg;
+                image_info->tw = cp->tw;
+                image_info->th = cp->th;
+                image_info->tile_x = cp->tdx;   /* new version parser */
+                image_info->tile_y = cp->tdy;   /* new version parser */
+                image_info->tile_Ox = cp->tx0;  /* new version parser */
+                image_info->tile_Oy = cp->ty0;  /* new version parser */
+                image_info->comp = image->numcomps;
+                image_info->layer = (&cp->tcps[0])->numlayers;
+                image_info->decomposition = (&cp->tcps[0])->tccps->numresolutions - 1;
+                image_info->D_max = 0;          /* ADD Marcela */
+        }
+        /* << INDEX */
+        
+        j2k_write_soc(j2k);
+        j2k_write_siz(j2k);
+        j2k_write_cod(j2k);
+        j2k_write_qcd(j2k);
+        
+        if(cp->cinema){
+                for (compno = 1; compno < image->numcomps; compno++) {
+                        j2k_write_coc(j2k, compno);
+                        j2k_write_qcc(j2k, compno);
+                }
+        }
+
+        for (compno = 0; compno < image->numcomps; compno++) {
+                opj_tcp_t *tcp = &cp->tcps[0];
+                if (tcp->tccps[compno].roishift)
+                        j2k_write_rgn(j2k, compno, 0);
+        }
+        if (cp->comment != NULL) {
+                j2k_write_com(j2k);
+        }
+        /* INDEX >> */
+        if(image_info && image_info->index_on) {
+                image_info->main_head_end = cio_tell(cio) - 1;
+        }
+        /* << INDEX */
+
+        j2k->totnum_tp = j2k_calculate_tp(cp,image->numcomps,image,j2k);
+        /*       TLM Marker*/
+        if(cp->cinema){
+                j2k_write_tlm(j2k);
+                if (cp->cinema == CINEMA4K_24) {
+                        j2k_write_poc(j2k);
+                }
+        }
+        /**** Main Header ENDS here ***/
+        
+        /* create the tile encoder */
+        tcd = tcd_create(j2k->cinfo);
+
+        /* encode each tile */
+
+        for (tileno = 0; tileno < cp->tw * cp->th; tileno++) {
+                int pino;
+                int tilepartno=0;
+
+                opj_tcp_t *tcp = &cp->tcps[tileno];
+                opj_event_msg(j2k->cinfo, EVT_INFO, "tile number %d / %d\n", tileno + 1, cp->tw * cp->th);
+                
+                j2k->curtileno = tileno;
+                j2k->cur_tp_num = 0;
+
+                /* initialisation before tile encoding  */
+                if (tileno == 0) {
+                        tcd_malloc_encode(tcd, image, cp, j2k->curtileno);
+                } else {
+                        tcd_init_encode(tcd, image, cp, j2k->curtileno);
+                }
+                
+                /* INDEX >> */
+                if(image_info && image_info->index_on) {
+                        image_info->tile[j2k->curtileno].num_tile = j2k->curtileno;
+                        image_info->tile[j2k->curtileno].start_pos = cio_tell(cio) + j2k->pos_correction;
+                }
+                /* << INDEX */
+
+                for(pino = 0; pino <= tcp->numpocs; pino++) {
+                        int tot_num_tp;
+                        tcd->cur_pino=pino;
+                        
+                        /*Get number of tile parts*/
+                        tot_num_tp = j2k_get_num_tp(cp,pino,tileno);
+                        tcd->tp_pos = cp->tp_pos;
+
+                        for(tilepartno = 0; tilepartno < tot_num_tp ; tilepartno++){
+                                j2k->tp_num = tilepartno;
+                                j2k_write_sot(j2k);
+
+                                if(j2k->cur_tp_num == 0 && cp->cinema == 0){
+                                        for (compno = 1; compno < image->numcomps; compno++) {
+                                                j2k_write_coc(j2k, compno);
+                                                j2k_write_qcc(j2k, compno);
+                                        }
+                                        if (cp->tcps[tileno].numpocs) {
+                                                j2k_write_poc(j2k);
+                                        }
+                                }
+
+                                j2k_write_sod(j2k, tcd);
+                                j2k->cur_tp_num ++;
+                        }
+                        
+                }
+                /* INDEX >> */
+                if(image_info && image_info->index_on) {
+                        image_info->tile[j2k->curtileno].end_pos = cio_tell(cio) + j2k->pos_correction - 1;
+                }
+                /* << INDEX */
+                
+                
+                /*
+                if (tile->PPT) { // BAD PPT !!! 
+                        FILE *PPT_file;
+                        int i;
+                        PPT_file=fopen("PPT","rb");
+                        fprintf(stderr,"%c%c%c%c",255,97,tile->len_ppt/256,tile->len_ppt%256);
+                        for (i=0;i<tile->len_ppt;i++) {
+                                unsigned char elmt;
+                                fread(&elmt, 1, 1, PPT_file);
+                                fwrite(&elmt,1,1,f);
+                        }
+                        fclose(PPT_file);
+                        unlink("PPT");
+                }
+                */
+                
+        }
+        
+        /* destroy the tile encoder */
+        tcd_free_encode(tcd);
+        tcd_destroy(tcd);
+
+        j2k_write_eoc(j2k);
+        
+        /* Creation of the index file */
+        if(image_info && image_info->index_on) {
+                if(!j2k_create_index(j2k, cio, image_info, index)) {
+                        opj_event_msg(j2k->cinfo, EVT_ERROR, "failed to create index file %s\n", index);
+                        return false;
+                }
+        }
+
+
+#ifdef USE_JPWL
+        /*
+        preparation of JPWL marker segments: can be finalized only when the whole
+        codestream is known
+        */
+        if(image_info && image_info->index_on && cp->epc_on) {
+
+                /* let's begin creating a marker list, according to user wishes */
+                jpwl_prepare_marks(j2k, cio, image);
+
+                /* now we dump the JPWL markers on the codestream */
+                jpwl_dump_marks(j2k, cio, image);
+
+                /* do not know exactly what is this for,
+                but it gets called during index creation */
+                j2k->pos_correction = 0;
+
+                /* Re-creation of the index file, with updated info */
+                if(image_info && image_info->index_on) {
+                        if(!j2k_create_index(j2k, cio, image_info, index)) {
+                                opj_event_msg(j2k->cinfo, EVT_ERROR, "failed to re-create index file %s\n", index);
+                                return false;
+                        }
+                }
+
+                /* now we finalize the marker contents */
+                /*jpwl_finalize_marks(j2k, cio, image);*/
+
+        }
+#endif /* USE_JPWL */
+
+        
+        return true;
+}
+
diff --git a/libraries/openjpeg-libsl/libopenjpeg/j2k.h b/libraries/openjpeg-libsl/libopenjpeg/j2k.h
new file mode 100644
index 0000000..c18f4cd
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/j2k.h
@@ -0,0 +1,525 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * Copyright (c) 2006-2007, Parvatha Elangovan
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __J2K_H
+#define __J2K_H
+/**
+@file j2k.h
+@brief The JPEG-2000 Codestream Reader/Writer (J2K)
+
+The functions in J2K.C have for goal to read/write the several parts of the codestream: markers and data.
+*/
+
+/** @defgroup J2K J2K - JPEG-2000 codestream reader/writer */
+/*@{*/
+
+#define J2K_CP_CSTY_PRT 0x01
+#define J2K_CP_CSTY_SOP 0x02
+#define J2K_CP_CSTY_EPH 0x04
+#define J2K_CCP_CSTY_PRT 0x01
+#define J2K_CCP_CBLKSTY_LAZY 0x01
+#define J2K_CCP_CBLKSTY_RESET 0x02
+#define J2K_CCP_CBLKSTY_TERMALL 0x04
+#define J2K_CCP_CBLKSTY_VSC 0x08
+#define J2K_CCP_CBLKSTY_PTERM 0x10
+#define J2K_CCP_CBLKSTY_SEGSYM 0x20
+#define J2K_CCP_QNTSTY_NOQNT 0
+#define J2K_CCP_QNTSTY_SIQNT 1
+#define J2K_CCP_QNTSTY_SEQNT 2
+
+/* ----------------------------------------------------------------------- */
+
+#define J2K_MS_SOC 0xff4f       /**< SOC marker value */
+#define J2K_MS_SOT 0xff90       /**< SOT marker value */
+#define J2K_MS_SOD 0xff93       /**< SOD marker value */
+#define J2K_MS_EOC 0xffd9       /**< EOC marker value */
+#define J2K_MS_SIZ 0xff51       /**< SIZ marker value */
+#define J2K_MS_COD 0xff52       /**< COD marker value */
+#define J2K_MS_COC 0xff53       /**< COC marker value */
+#define J2K_MS_RGN 0xff5e       /**< RGN marker value */
+#define J2K_MS_QCD 0xff5c       /**< QCD marker value */
+#define J2K_MS_QCC 0xff5d       /**< QCC marker value */
+#define J2K_MS_POC 0xff5f       /**< POC marker value */
+#define J2K_MS_TLM 0xff55       /**< TLM marker value */
+#define J2K_MS_PLM 0xff57       /**< PLM marker value */
+#define J2K_MS_PLT 0xff58       /**< PLT marker value */
+#define J2K_MS_PPM 0xff60       /**< PPM marker value */
+#define J2K_MS_PPT 0xff61       /**< PPT marker value */
+#define J2K_MS_SOP 0xff91       /**< SOP marker value */
+#define J2K_MS_EPH 0xff92       /**< EPH marker value */
+#define J2K_MS_CRG 0xff63       /**< CRG marker value */
+#define J2K_MS_COM 0xff64       /**< COM marker value */
+/* UniPG>> */
+#ifdef USE_JPWL
+#define J2K_MS_EPC 0xff68       /**< EPC marker value (Part11) */
+#define J2K_MS_EPB 0xff66       /**< EPB marker value (Part11) */ 
+#define J2K_MS_ESD 0xff67       /**< ESD marker value (Part11) */ 
+#define J2K_MS_RED 0xff69       /**< RED marker value (Part11) */
+#endif /* USE_JPWL */
+/* <<UniPG */
+
+/* ----------------------------------------------------------------------- */
+
+/**
+Values that specify the status of the decoding process when decoding the main header. 
+These values may be combined with a | operator. 
+*/
+typedef enum J2K_STATUS {
+        J2K_STATE_MHSOC  = 0x0001, /**< a SOC marker is expected */
+        J2K_STATE_MHSIZ  = 0x0002, /**< a SIZ marker is expected */
+        J2K_STATE_MH     = 0x0004, /**< the decoding process is in the main header */
+        J2K_STATE_TPHSOT = 0x0008, /**< the decoding process is in a tile part header and expects a SOT marker */
+        J2K_STATE_TPH    = 0x0010, /**< the decoding process is in a tile part header */
+        J2K_STATE_MT     = 0x0020, /**< the EOC marker has just been read */
+        J2K_STATE_NEOC   = 0x0040  /**< the decoding process must not expect a EOC marker because the codestream is truncated */
+} J2K_STATUS;
+
+/* ----------------------------------------------------------------------- */
+
+/** 
+T2 encoding mode 
+*/
+typedef enum T2_MODE {
+        THRESH_CALC = 0,        /** Function called in Rate allocation process*/
+        FINAL_PASS = 1          /** Function called in Tier 2 process*/
+}J2K_T2_MODE;
+
+/**
+Quantization stepsize
+*/
+typedef struct opj_stepsize {
+        /** exponent */
+        int expn;
+        /** mantissa */
+        int mant;
+} opj_stepsize_t;
+
+/**
+Tile-component coding parameters
+*/
+typedef struct opj_tccp {
+        /** coding style */
+        int csty;
+        /** number of resolutions */
+        int numresolutions;
+        /** code-blocks width */
+        int cblkw;
+        /** code-blocks height */
+        int cblkh;
+        /** code-block coding style */
+        int cblksty;
+        /** discrete wavelet transform identifier */
+        int qmfbid;
+        /** quantisation style */
+        int qntsty;
+        /** stepsizes used for quantization */
+        opj_stepsize_t stepsizes[J2K_MAXBANDS];
+        /** number of guard bits */
+        int numgbits;
+        /** Region Of Interest shift */
+        int roishift;
+        /** precinct width */
+        int prcw[J2K_MAXRLVLS];
+        /** precinct height */
+        int prch[J2K_MAXRLVLS]; 
+} opj_tccp_t;
+
+/**
+Tile coding parameters : 
+this structure is used to store coding/decoding parameters common to all
+tiles (information like COD, COC in main header)
+*/
+typedef struct opj_tcp {
+        /** 1 : first part-tile of a tile */
+        int first;
+        /** coding style */
+        int csty;
+        /** progression order */
+        OPJ_PROG_ORDER prg;
+        /** number of layers */
+        int numlayers;
+        /** multi-component transform identifier */
+        int mct;
+        /** rates of layers */
+        float rates[100];
+        /** number of progression order changes */
+        int numpocs;
+        /** indicates if a POC marker has been used O:NO, 1:YES */
+        int POC;
+        /** progression order changes */
+        opj_poc_t pocs[32];
+        /** packet header store there for futur use in t2_decode_packet */
+        unsigned char *ppt_data;
+        /** pointer remaining on the first byte of the first header if ppt is used */
+        unsigned char *ppt_data_first;
+        /** If ppt == 1 --> there was a PPT marker for the present tile */
+        int ppt;
+        /** used in case of multiple marker PPT (number of info already stored) */
+        int ppt_store;
+        /** ppmbug1 */
+        int ppt_len;
+        /** add fixed_quality */
+        float distoratio[100];
+        /** tile-component coding parameters */
+        opj_tccp_t *tccps;
+} opj_tcp_t;
+
+/**
+Coding parameters
+*/
+typedef struct opj_cp {
+        /** Digital cinema profile*/
+        OPJ_CINEMA_MODE cinema;
+        /** Maximum rate for each component. If == 0, component size limitation is not considered */
+        int max_comp_size;
+        /** Size of the image in bits*/
+        int img_size;
+        /** Rsiz*/
+        OPJ_RSIZ_CAPABILITIES rsiz;
+        /** Enabling Tile part generation*/
+        char tp_on;
+        /** Flag determining tile part generation*/
+        char tp_flag;
+        /** Position of tile part flag in progression order*/
+        int tp_pos;
+        /** allocation by rate/distortion */
+        int disto_alloc;
+        /** allocation by fixed layer */
+        int fixed_alloc;
+        /** add fixed_quality */
+        int fixed_quality;
+        /** if != 0, then original dimension divided by 2^(reduce); if == 0 or not used, image is decoded to the full resolution */
+        int reduce;
+        /** if != 0, then only the first "layer" layers are decoded; if == 0 or not used, all the quality layers are decoded */
+        int layer;
+        /** if == NO_LIMITATION, decode entire codestream; if == LIMIT_TO_MAIN_HEADER then only decode the main header */
+        OPJ_LIMIT_DECODING limit_decoding;
+        /** 0 = no index || 1 = index */
+        int index_on;
+        /** XTOsiz */
+        int tx0;
+        /** YTOsiz */
+        int ty0;
+        /** XTsiz */
+        int tdx;
+        /** YTsiz */
+        int tdy;
+        /** comment for coding */
+        char *comment;
+        /** number of tiles in width */
+        int tw;
+        /** number of tiles in heigth */
+        int th;
+        /** ID number of the tiles present in the codestream */
+        int *tileno;
+        /** size of the vector tileno */
+        int tileno_size;
+        /** packet header store there for futur use in t2_decode_packet */
+        unsigned char *ppm_data;
+        /** pointer remaining on the first byte of the first header if ppm is used */
+        unsigned char *ppm_data_first;
+        /** if ppm == 1 --> there was a PPM marker for the present tile */
+        int ppm;
+        /** use in case of multiple marker PPM (number of info already store) */
+        int ppm_store;
+        /** use in case of multiple marker PPM (case on non-finished previous info) */
+        int ppm_previous;
+        /** ppmbug1 */
+        int ppm_len;
+        /** tile coding parameters */
+        opj_tcp_t *tcps;
+        /** fixed layer */
+        int *matrice;
+/* UniPG>> */
+#ifdef USE_JPWL
+        /** enables writing of EPC in MH, thus activating JPWL */
+        bool epc_on;
+        /** enables writing of EPB, in case of activated JPWL */
+        bool epb_on;
+        /** enables writing of ESD, in case of activated JPWL */
+        bool esd_on;
+        /** enables writing of informative techniques of ESD, in case of activated JPWL */
+        bool info_on;
+        /** enables writing of RED, in case of activated JPWL */
+        bool red_on;
+        /** error protection method for MH (0,1,16,32,37-128) */
+        int hprot_MH;
+        /** tile number of header protection specification (>=0) */
+        int hprot_TPH_tileno[JPWL_MAX_NO_TILESPECS];
+        /** error protection methods for TPHs (0,1,16,32,37-128) */
+        int hprot_TPH[JPWL_MAX_NO_TILESPECS];
+        /** tile number of packet protection specification (>=0) */
+        int pprot_tileno[JPWL_MAX_NO_PACKSPECS];
+        /** packet number of packet protection specification (>=0) */
+        int pprot_packno[JPWL_MAX_NO_PACKSPECS];
+        /** error protection methods for packets (0,1,16,32,37-128) */
+        int pprot[JPWL_MAX_NO_PACKSPECS];
+        /** enables writing of ESD, (0/2/4 bytes) */
+        int sens_size;
+        /** sensitivity addressing size (0=auto/2/4 bytes) */
+        int sens_addr;
+        /** sensitivity range (0-3) */
+        int sens_range;
+        /** sensitivity method for MH (-1,0-7) */
+        int sens_MH;
+        /** tile number of sensitivity specification (>=0) */
+        int sens_TPH_tileno[JPWL_MAX_NO_TILESPECS];
+        /** sensitivity methods for TPHs (-1,0-7) */
+        int sens_TPH[JPWL_MAX_NO_TILESPECS];
+        /** enables JPWL correction at the decoder */
+        bool correct;
+        /** expected number of components at the decoder */
+        int exp_comps;
+        /** maximum number of tiles at the decoder */
+        int max_tiles;
+#endif /* USE_JPWL */
+/* <<UniPG */
+} opj_cp_t;
+
+/**
+Information concerning a packet inside tile
+*/
+typedef struct opj_packet_info {
+        /** start position */
+        int start_pos;
+        /** end position */
+        int end_pos;
+        /** ADD for Marcela */
+        double disto;
+} opj_packet_info_t;
+
+/**
+Index structure : information regarding tiles inside image
+*/
+typedef struct opj_tile_info {
+        /** value of thresh for each layer by tile cfr. Marcela   */
+        double *thresh;
+        /** number of tile */
+        int num_tile;
+        /** start position */
+        int start_pos;
+        /** end position of the header */
+        int end_header;
+        /** end position */
+        int end_pos;
+        /** precinct number for each resolution level (width) */
+        int pw[33];
+        /** precinct number for each resolution level (height) */
+        int ph[33];
+        /** precinct size (in power of 2), in X for each resolution level */
+        int pdx[33];
+        /** precinct size (in power of 2), in Y for each resolution level */
+        int pdy[33];
+        /** information concerning packets inside tile */
+        opj_packet_info_t *packet;
+        /** add fixed_quality */
+        int nbpix;
+        /** add fixed_quality */
+        double distotile;
+} opj_tile_info_t;
+
+/**
+Index structure
+*/
+typedef struct opj_image_info {
+        /** 0 = no index || 1 = index */
+        int index_on;
+        /** maximum distortion reduction on the whole image (add for Marcela) */
+        double D_max;
+        /** packet number */
+        int num;
+        /** writing the packet in the index with t2_encode_packets */
+        int index_write;
+        /** image width */
+        int image_w;
+        /** image height */
+        int image_h;
+        /** progression order */
+        OPJ_PROG_ORDER prog;
+        /** tile size in x */
+        int tile_x;
+        /** tile size in y */
+        int tile_y;
+        /** */
+        int tile_Ox;
+        /** */
+        int tile_Oy;
+        /** number of tiles in X */
+        int tw;
+        /** number of tiles in Y */
+        int th;
+        /** component numbers */
+        int comp;
+        /** number of layer */
+        int layer;
+        /** number of decomposition */
+        int decomposition;
+        /** main header position */
+        int main_head_end;
+        /** codestream's size */
+        int codestream_size;
+        /** information regarding tiles inside image */
+        opj_tile_info_t *tile;
+} opj_image_info_t;
+
+/**
+JPEG-2000 codestream reader/writer
+*/
+typedef struct opj_j2k {
+        /** codec context */
+        opj_common_ptr cinfo;
+
+        /** locate in which part of the codestream the decoder is (main header, tile header, end) */
+        int state;
+        /** number of the tile curently concern by coding/decoding */
+        int curtileno;
+        /** Tile part number*/
+        int tp_num;
+        /** Tilepart number currently coding*/
+        int cur_tp_num;
+        /** Total number of tileparts of the current tile*/
+        int *cur_totnum_tp;
+        /**
+        locate the start position of the TLM marker  
+        after encoding the tilepart, a jump (in j2k_write_sod) is done to the TLM marker to store the value of its length. 
+        */
+        int tlm_start;
+        /** Total num of tile parts in whole image = num tiles* num tileparts in each tile*/
+        /** used in TLMmarker*/
+        int totnum_tp;  
+        /** 
+        locate the position of the end of the tile in the codestream, 
+        used to detect a truncated codestream (in j2k_read_sod)
+        */
+        unsigned char *eot;
+        /**
+        locate the start position of the SOT marker of the current coded tile:  
+        after encoding the tile, a jump (in j2k_write_sod) is done to the SOT marker to store the value of its length. 
+        */
+        int sot_start;
+        int sod_start;
+        /**
+        as the J2K-file is written in several parts during encoding, 
+        it enables to make the right correction in position return by cio_tell
+        */
+        int pos_correction;
+        /** array used to store the data of each tile */
+        unsigned char **tile_data;
+        /** array used to store the length of each tile */
+        int *tile_len;
+        /** 
+        decompression only : 
+        store decoding parameters common to all tiles (information like COD, COC in main header)
+        */
+        opj_tcp_t *default_tcp;
+        /** pointer to the encoded / decoded image */
+        opj_image_t *image;
+        /** pointer to the coding parameters */
+        opj_cp_t *cp;
+        /** helper used to write the index file */
+        opj_image_info_t *image_info;
+        /** pointer to the byte i/o stream */
+        opj_cio_t *cio;
+} opj_j2k_t;
+
+/** @name Exported functions */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+/**
+Creates a J2K decompression structure
+@param cinfo Codec context info
+@return Returns a handle to a J2K decompressor if successful, returns NULL otherwise
+*/
+opj_j2k_t* j2k_create_decompress(opj_common_ptr cinfo);
+/**
+Destroy a J2K decompressor handle
+@param j2k J2K decompressor handle to destroy
+*/
+void j2k_destroy_decompress(opj_j2k_t *j2k);
+/**
+Setup the decoder decoding parameters using user parameters.
+Decoding parameters are returned in j2k->cp. 
+@param j2k J2K decompressor handle
+@param parameters decompression parameters
+*/
+void j2k_setup_decoder(opj_j2k_t *j2k, opj_dparameters_t *parameters);
+/**
+Decode an image from a JPEG-2000 codestream
+@param j2k J2K decompressor handle
+@param cio Input buffer stream
+@return Returns a decoded image if successful, returns NULL otherwise
+*/
+opj_image_t* j2k_decode(opj_j2k_t *j2k, opj_cio_t *cio);
+/**
+Decode an image form a JPT-stream (JPEG 2000, JPIP)
+@param j2k J2K decompressor handle
+@param cio Input buffer stream
+@return Returns a decoded image if successful, returns NULL otherwise
+*/
+opj_image_t* j2k_decode_jpt_stream(opj_j2k_t *j2k, opj_cio_t *cio);
+/**
+Creates a J2K compression structure
+@param cinfo Codec context info
+@return Returns a handle to a J2K compressor if successful, returns NULL otherwise
+*/
+opj_j2k_t* j2k_create_compress(opj_common_ptr cinfo);
+/**
+Destroy a J2K compressor handle
+@param j2k J2K compressor handle to destroy
+*/
+void j2k_destroy_compress(opj_j2k_t *j2k);
+/**
+Setup the encoder parameters using the current image and using user parameters. 
+Coding parameters are returned in j2k->cp. 
+@param j2k J2K compressor handle
+@param parameters compression parameters
+@param image input filled image
+*/
+void j2k_setup_encoder(opj_j2k_t *j2k, opj_cparameters_t *parameters, opj_image_t *image);
+/**
+Converts an enum type progression order to string type
+*/
+char *j2k_convert_progression_order(OPJ_PROG_ORDER prg_order);
+/**
+Encode an image into a JPEG-2000 codestream
+@param j2k J2K compressor handle
+@param cio Output buffer stream
+@param image Image to encode
+@param index Name of the index file if required, NULL otherwise
+@return Returns true if successful, returns false otherwise
+*/
+bool j2k_encode(opj_j2k_t *j2k, opj_cio_t *cio, opj_image_t *image, char *index);
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __J2K_H */
diff --git a/libraries/openjpeg-libsl/libopenjpeg/j2k_lib.c b/libraries/openjpeg-libsl/libopenjpeg/j2k_lib.c
new file mode 100644
index 0000000..69444a7
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/j2k_lib.c
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2005, Hervé Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifdef WIN32
+#include <windows.h>
+#else
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <sys/times.h>
+#endif /* WIN32 */
+#include "opj_includes.h"
+
+double opj_clock() {
+#ifdef WIN32
+        /* WIN32: use QueryPerformance (very accurate) */
+    LARGE_INTEGER freq , t ;
+    /* freq is the clock speed of the CPU */
+    QueryPerformanceFrequency(&freq) ;
+        /* cout << "freq = " << ((double) freq.QuadPart) << endl; */
+    /* t is the high resolution performance counter (see MSDN) */
+    QueryPerformanceCounter ( & t ) ;
+    return ( t.QuadPart /(double) freq.QuadPart ) ;
+#else
+        /* Unix or Linux: use resource usage */
+    struct rusage t;
+    double procTime;
+    /* (1) Get the rusage data structure at this moment (man getrusage) */
+    getrusage(0,&t);
+    /* (2) What is the elapsed time ? - CPU time = User time + System time */
+        /* (2a) Get the seconds */
+    procTime = t.ru_utime.tv_sec + t.ru_stime.tv_sec;
+    /* (2b) More precisely! Get the microseconds part ! */
+    return ( procTime + (t.ru_utime.tv_usec + t.ru_stime.tv_usec) * 1e-6 ) ;
+#endif
+}
+
+void* opj_malloc( size_t size ) {
+        void *memblock = malloc(size);
+        if(memblock) {
+                memset(memblock, 0, size);
+        }
+        return memblock;
+}
+
+void* opj_realloc( void *memblock, size_t size ) {
+        return realloc(memblock, size);
+}
+
+void opj_free( void *memblock ) {
+        free(memblock);
+}
+
+
diff --git a/libraries/openjpeg-libsl/libopenjpeg/j2k_lib.h b/libraries/openjpeg-libsl/libopenjpeg/j2k_lib.h
new file mode 100644
index 0000000..3d1b53c
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/j2k_lib.h
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2005, Hervé Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __J2K_LIB_H
+#define __J2K_LIB_H
+/**
+@file j2k_lib.h
+@brief Internal functions
+
+The functions in J2K_LIB.C are internal utilities mainly used for memory management.
+*/
+
+/** @defgroup MISC MISC - Miscellaneous internal functions */
+/*@{*/
+
+/** @name Exported functions */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+
+/**
+Difference in successive opj_clock() calls tells you the elapsed time
+@return Returns time in seconds
+*/
+double opj_clock();
+
+/**
+Allocate a memory block with elements initialized to 0
+@param size Bytes to allocate
+@return Returns a void pointer to the allocated space, or NULL if there is insufficient memory available
+*/
+void* opj_malloc( size_t size );
+
+/**
+Reallocate memory blocks.
+@param memblock Pointer to previously allocated memory block
+@param size New size in bytes
+@return Returns a void pointer to the reallocated (and possibly moved) memory block
+*/
+void* opj_realloc( void *memblock, size_t size );
+
+/**
+Deallocates or frees a memory block.
+@param memblock Previously allocated memory block to be freed
+*/
+void opj_free( void *memblock );
+
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __J2K_LIB_H */
+
diff --git a/libraries/openjpeg-libsl/libopenjpeg/jp2.c b/libraries/openjpeg-libsl/libopenjpeg/jp2.c
new file mode 100644
index 0000000..d102349
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/jp2.c
@@ -0,0 +1,700 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "opj_includes.h"
+
+/** @defgroup JP2 JP2 - JPEG-2000 file format reader/writer */
+/*@{*/
+
+/** @name Local static functions */
+/*@{*/
+
+/**
+Read box headers
+@param cinfo Codec context info
+@param cio Input stream
+@param box
+@return Returns true if successful, returns false otherwise
+*/
+static bool jp2_read_boxhdr(opj_common_ptr cinfo, opj_cio_t *cio, opj_jp2_box_t *box);
+/*static void jp2_write_url(opj_cio_t *cio, char *Idx_file);*/
+/**
+Read the IHDR box - Image Header box
+@param jp2 JP2 handle
+@param cio Input buffer stream
+@return Returns true if successful, returns false otherwise
+*/
+static bool jp2_read_ihdr(opj_jp2_t *jp2, opj_cio_t *cio);
+static void jp2_write_ihdr(opj_jp2_t *jp2, opj_cio_t *cio);
+static void jp2_write_bpcc(opj_jp2_t *jp2, opj_cio_t *cio);
+static bool jp2_read_bpcc(opj_jp2_t *jp2, opj_cio_t *cio);
+static void jp2_write_colr(opj_jp2_t *jp2, opj_cio_t *cio);
+static bool jp2_read_colr(opj_jp2_t *jp2, opj_cio_t *cio);
+/**
+Write the FTYP box - File type box
+@param jp2 JP2 handle
+@param cio Output buffer stream
+*/
+static void jp2_write_ftyp(opj_jp2_t *jp2, opj_cio_t *cio);
+/**
+Read the FTYP box - File type box
+@param jp2 JP2 handle
+@param cio Input buffer stream
+@return Returns true if successful, returns false otherwise
+*/
+static bool jp2_read_ftyp(opj_jp2_t *jp2, opj_cio_t *cio);
+static int jp2_write_jp2c(opj_jp2_t *jp2, opj_cio_t *cio, opj_image_t *image, char *index);
+static bool jp2_read_jp2c(opj_jp2_t *jp2, opj_cio_t *cio, unsigned int *j2k_codestream_length, unsigned int *j2k_codestream_offset);
+static void jp2_write_jp(opj_cio_t *cio);
+/**
+Read the JP box - JPEG 2000 signature
+@param jp2 JP2 handle
+@param cio Input buffer stream
+@return Returns true if successful, returns false otherwise
+*/
+static bool jp2_read_jp(opj_jp2_t *jp2, opj_cio_t *cio);
+/**
+Decode the structure of a JP2 file
+@param jp2 JP2 handle
+@param cio Input buffer stream
+@return Returns true if successful, returns false otherwise
+*/
+static bool jp2_read_struct(opj_jp2_t *jp2, opj_cio_t *cio);
+
+/*@}*/
+
+/*@}*/
+
+/* ----------------------------------------------------------------------- */
+
+static bool jp2_read_boxhdr(opj_common_ptr cinfo, opj_cio_t *cio, opj_jp2_box_t *box) {
+        box->init_pos = cio_tell(cio);
+        box->length = cio_read(cio, 4);
+        box->type = cio_read(cio, 4);
+        if (box->length == 1) {
+                if (cio_read(cio, 4) != 0) {
+                        opj_event_msg(cinfo, EVT_ERROR, "Cannot handle box sizes higher than 2^32\n");
+                        return false;
+                }
+                box->length = cio_read(cio, 4);
+                if (box->length == 0) 
+                        box->length = cio_numbytesleft(cio) + 12;
+        }
+        else if (box->length == 0) {
+                box->length = cio_numbytesleft(cio) + 8;
+        }
+        
+        return true;
+}
+
+#if 0
+static void jp2_write_url(opj_cio_t *cio, char *Idx_file) {
+        unsigned int i;
+        opj_jp2_box_t box;
+
+        box.init_pos = cio_tell(cio);
+        cio_skip(cio, 4);
+        cio_write(cio, JP2_URL, 4);     /* DBTL */
+        cio_write(cio, 0, 1);           /* VERS */
+        cio_write(cio, 0, 3);           /* FLAG */
+
+        if(Idx_file) {
+                for (i = 0; i < strlen(Idx_file); i++) {
+                        cio_write(cio, Idx_file[i], 1);
+                }
+        }
+
+        box.length = cio_tell(cio) - box.init_pos;
+        cio_seek(cio, box.init_pos);
+        cio_write(cio, box.length, 4);  /* L */
+        cio_seek(cio, box.init_pos + box.length);
+}
+#endif
+
+static bool jp2_read_ihdr(opj_jp2_t *jp2, opj_cio_t *cio) {
+        opj_jp2_box_t box;
+
+        opj_common_ptr cinfo = jp2->cinfo;
+
+        jp2_read_boxhdr(cinfo, cio, &box);
+        if (JP2_IHDR != box.type) {
+                opj_event_msg(cinfo, EVT_ERROR, "Expected IHDR Marker\n");
+                return false;
+        }
+
+        jp2->h = cio_read(cio, 4);                      /* HEIGHT */
+        jp2->w = cio_read(cio, 4);                      /* WIDTH */
+        jp2->numcomps = cio_read(cio, 2);       /* NC */
+        jp2->comps = (opj_jp2_comps_t*) opj_malloc(jp2->numcomps * sizeof(opj_jp2_comps_t));
+
+        jp2->bpc = cio_read(cio, 1);            /* BPC */
+
+        jp2->C = cio_read(cio, 1);                      /* C */
+        jp2->UnkC = cio_read(cio, 1);           /* UnkC */
+        jp2->IPR = cio_read(cio, 1);            /* IPR */
+
+        if (cio_tell(cio) - box.init_pos != box.length) {
+                opj_event_msg(cinfo, EVT_ERROR, "Error with IHDR Box\n");
+                return false;
+        }
+
+        return true;
+}
+
+static void jp2_write_ihdr(opj_jp2_t *jp2, opj_cio_t *cio) {
+        opj_jp2_box_t box;
+
+        box.init_pos = cio_tell(cio);
+        cio_skip(cio, 4);
+        cio_write(cio, JP2_IHDR, 4);            /* IHDR */
+
+        cio_write(cio, jp2->h, 4);                      /* HEIGHT */
+        cio_write(cio, jp2->w, 4);                      /* WIDTH */
+        cio_write(cio, jp2->numcomps, 2);       /* NC */
+
+        cio_write(cio, jp2->bpc, 1);            /* BPC */
+
+        cio_write(cio, jp2->C, 1);                      /* C : Always 7 */
+        cio_write(cio, jp2->UnkC, 1);           /* UnkC, colorspace unknown */
+        cio_write(cio, jp2->IPR, 1);            /* IPR, no intellectual property */
+
+        box.length = cio_tell(cio) - box.init_pos;
+        cio_seek(cio, box.init_pos);
+        cio_write(cio, box.length, 4);  /* L */
+        cio_seek(cio, box.init_pos + box.length);
+}
+
+static void jp2_write_bpcc(opj_jp2_t *jp2, opj_cio_t *cio) {
+        unsigned int i;
+        opj_jp2_box_t box;
+
+        box.init_pos = cio_tell(cio);
+        cio_skip(cio, 4);
+        cio_write(cio, JP2_BPCC, 4);    /* BPCC */
+
+        for (i = 0; i < jp2->numcomps; i++) {
+                cio_write(cio, jp2->comps[i].bpcc, 1);
+        }
+
+        box.length = cio_tell(cio) - box.init_pos;
+        cio_seek(cio, box.init_pos);
+        cio_write(cio, box.length, 4);  /* L */
+        cio_seek(cio, box.init_pos + box.length);
+}
+
+
+static bool jp2_read_bpcc(opj_jp2_t *jp2, opj_cio_t *cio) {
+        unsigned int i;
+        opj_jp2_box_t box;
+
+        opj_common_ptr cinfo = jp2->cinfo;
+
+        jp2_read_boxhdr(cinfo, cio, &box);
+        if (JP2_BPCC != box.type) {
+                opj_event_msg(cinfo, EVT_ERROR, "Expected BPCC Marker\n");
+                return false;
+        }
+
+        for (i = 0; i < jp2->numcomps; i++) {
+                jp2->comps[i].bpcc = cio_read(cio, 1);
+        }
+
+        if (cio_tell(cio) - box.init_pos != box.length) {
+                opj_event_msg(cinfo, EVT_ERROR, "Error with BPCC Box\n");
+                return false;
+        }
+
+        return true;
+}
+
+static void jp2_write_colr(opj_jp2_t *jp2, opj_cio_t *cio) {
+        opj_jp2_box_t box;
+
+        box.init_pos = cio_tell(cio);
+        cio_skip(cio, 4);
+        cio_write(cio, JP2_COLR, 4);            /* COLR */
+
+        cio_write(cio, jp2->meth, 1);           /* METH */
+        cio_write(cio, jp2->precedence, 1);     /* PRECEDENCE */
+        cio_write(cio, jp2->approx, 1);         /* APPROX */
+
+        if (jp2->meth == 1) {
+                cio_write(cio, jp2->enumcs, 4); /* EnumCS */
+        } else {
+                cio_write(cio, 0, 1);                   /* PROFILE (??) */
+        }
+
+        box.length = cio_tell(cio) - box.init_pos;
+        cio_seek(cio, box.init_pos);
+        cio_write(cio, box.length, 4);  /* L */
+        cio_seek(cio, box.init_pos + box.length);
+}
+
+static bool jp2_read_colr(opj_jp2_t *jp2, opj_cio_t *cio) {
+        opj_jp2_box_t box;
+        int skip_len;
+
+        opj_common_ptr cinfo = jp2->cinfo;
+
+        jp2_read_boxhdr(cinfo, cio, &box);
+        do {
+                if (JP2_COLR != box.type) {
+                        cio_skip(cio, box.length - 8);
+                        jp2_read_boxhdr(cinfo, cio, &box);
+                }
+        } while(JP2_COLR != box.type);
+
+        jp2->meth = cio_read(cio, 1);           /* METH */
+        jp2->precedence = cio_read(cio, 1);     /* PRECEDENCE */
+        jp2->approx = cio_read(cio, 1);         /* APPROX */
+
+        if (jp2->meth == 1) {
+                jp2->enumcs = cio_read(cio, 4); /* EnumCS */
+        } else {
+                /* skip PROFILE */
+                skip_len = box.init_pos + box.length - cio_tell(cio);
+                if (skip_len < 0) {
+                        opj_event_msg(cinfo, EVT_ERROR, "Error with JP2H box size\n");
+                        return false;
+                }
+                cio_skip(cio, box.init_pos + box.length - cio_tell(cio));
+        }
+
+        if (cio_tell(cio) - box.init_pos != box.length) {
+                opj_event_msg(cinfo, EVT_ERROR, "Error with BPCC Box\n");
+                return false;
+        }
+        return true;
+}
+
+void jp2_write_jp2h(opj_jp2_t *jp2, opj_cio_t *cio) {
+        opj_jp2_box_t box;
+
+        box.init_pos = cio_tell(cio);
+        cio_skip(cio, 4);
+        cio_write(cio, JP2_JP2H, 4);    /* JP2H */
+
+        jp2_write_ihdr(jp2, cio);
+
+        if (jp2->bpc == 255) {
+                jp2_write_bpcc(jp2, cio);
+        }
+        jp2_write_colr(jp2, cio);
+
+        box.length = cio_tell(cio) - box.init_pos;
+        cio_seek(cio, box.init_pos);
+        cio_write(cio, box.length, 4);  /* L */
+        cio_seek(cio, box.init_pos + box.length);
+}
+
+bool jp2_read_jp2h(opj_jp2_t *jp2, opj_cio_t *cio) {
+        opj_jp2_box_t box;
+        int skip_len;
+
+        opj_common_ptr cinfo = jp2->cinfo;
+
+        jp2_read_boxhdr(cinfo, cio, &box);
+        do {
+                if (JP2_JP2H != box.type) {
+                        if (box.type == JP2_JP2C) {
+                                opj_event_msg(cinfo, EVT_ERROR, "Expected JP2H Marker\n");
+                                return false;
+                        }
+                        cio_skip(cio, box.length - 8);
+                        jp2_read_boxhdr(cinfo, cio, &box);
+                }
+        } while(JP2_JP2H != box.type);
+
+        if (!jp2_read_ihdr(jp2, cio))
+                return false;
+
+        if (jp2->bpc == 255) {
+                if (!jp2_read_bpcc(jp2, cio))
+                        return false;
+        }
+        if (!jp2_read_colr(jp2, cio))
+                return false;
+
+        skip_len = box.init_pos + box.length - cio_tell(cio);
+        if (skip_len < 0) {
+                opj_event_msg(cinfo, EVT_ERROR, "Error with JP2H Box\n");
+                return false;
+        }
+        cio_skip(cio, box.init_pos + box.length - cio_tell(cio));
+
+        return true;
+}
+
+static void jp2_write_ftyp(opj_jp2_t *jp2, opj_cio_t *cio) {
+        unsigned int i;
+        opj_jp2_box_t box;
+
+        box.init_pos = cio_tell(cio);
+        cio_skip(cio, 4);
+        cio_write(cio, JP2_FTYP, 4);            /* FTYP */
+
+        cio_write(cio, jp2->brand, 4);          /* BR */
+        cio_write(cio, jp2->minversion, 4);     /* MinV */
+
+        for (i = 0; i < jp2->numcl; i++) {
+                cio_write(cio, jp2->cl[i], 4);  /* CL */
+        }
+
+        box.length = cio_tell(cio) - box.init_pos;
+        cio_seek(cio, box.init_pos);
+        cio_write(cio, box.length, 4);  /* L */
+        cio_seek(cio, box.init_pos + box.length);
+}
+
+static bool jp2_read_ftyp(opj_jp2_t *jp2, opj_cio_t *cio) {
+        int i;
+        opj_jp2_box_t box;
+
+        opj_common_ptr cinfo = jp2->cinfo;
+
+        jp2_read_boxhdr(cinfo, cio, &box);
+
+        if (JP2_FTYP != box.type) {
+                opj_event_msg(cinfo, EVT_ERROR, "Expected FTYP Marker\n");
+                return false;
+        }
+
+        jp2->brand = cio_read(cio, 4);          /* BR */
+        jp2->minversion = cio_read(cio, 4);     /* MinV */
+        jp2->numcl = (box.length - 16) / 4;
+        jp2->cl = (unsigned int *) opj_malloc(jp2->numcl * sizeof(unsigned int));
+
+        for (i = 0; i < (int)jp2->numcl; i++) {
+                jp2->cl[i] = cio_read(cio, 4);  /* CLi */
+        }
+
+        if (cio_tell(cio) - box.init_pos != box.length) {
+                opj_event_msg(cinfo, EVT_ERROR, "Error with FTYP Box\n");
+                return false;
+        }
+
+        return true;
+}
+
+static int jp2_write_jp2c(opj_jp2_t *jp2, opj_cio_t *cio, opj_image_t *image, char *index) {
+        unsigned int j2k_codestream_offset, j2k_codestream_length;
+        opj_jp2_box_t box;
+
+        opj_j2k_t *j2k = jp2->j2k;
+
+        box.init_pos = cio_tell(cio);
+        cio_skip(cio, 4);
+        cio_write(cio, JP2_JP2C, 4);    /* JP2C */
+
+        /* J2K encoding */
+        j2k_codestream_offset = cio_tell(cio);
+        if(!j2k_encode(j2k, cio, image, index)) {
+                opj_event_msg(j2k->cinfo, EVT_ERROR, "Failed to encode image\n");
+                return 0;
+        }
+        j2k_codestream_length = cio_tell(cio) - j2k_codestream_offset;
+
+        jp2->j2k_codestream_offset = j2k_codestream_offset;
+        jp2->j2k_codestream_length = j2k_codestream_length;
+
+        box.length = 8 + jp2->j2k_codestream_length;
+        cio_seek(cio, box.init_pos);
+        cio_write(cio, box.length, 4);  /* L */
+        cio_seek(cio, box.init_pos + box.length);
+
+        return box.length;
+}
+
+static bool jp2_read_jp2c(opj_jp2_t *jp2, opj_cio_t *cio, unsigned int *j2k_codestream_length, unsigned int *j2k_codestream_offset) {
+        opj_jp2_box_t box;
+
+        opj_common_ptr cinfo = jp2->cinfo;
+
+        jp2_read_boxhdr(cinfo, cio, &box);
+        do {
+                if(JP2_JP2C != box.type) {
+                        cio_skip(cio, box.length - 8);
+                        jp2_read_boxhdr(cinfo, cio, &box);
+                }
+        } while(JP2_JP2C != box.type);
+
+        *j2k_codestream_offset = cio_tell(cio);
+        *j2k_codestream_length = box.length - 8;
+
+        return true;
+}
+
+static void jp2_write_jp(opj_cio_t *cio) {
+        opj_jp2_box_t box;
+
+        box.init_pos = cio_tell(cio);
+        cio_skip(cio, 4);
+        cio_write(cio, JP2_JP, 4);              /* JP2 signature */
+        cio_write(cio, 0x0d0a870a, 4);
+
+        box.length = cio_tell(cio) - box.init_pos;
+        cio_seek(cio, box.init_pos);
+        cio_write(cio, box.length, 4);  /* L */
+        cio_seek(cio, box.init_pos + box.length);
+}
+
+static bool jp2_read_jp(opj_jp2_t *jp2, opj_cio_t *cio) {
+        opj_jp2_box_t box;
+
+        opj_common_ptr cinfo = jp2->cinfo;
+
+        jp2_read_boxhdr(cinfo, cio, &box);
+        if (JP2_JP != box.type) {
+                opj_event_msg(cinfo, EVT_ERROR, "Expected JP Marker\n");
+                return false;
+        }
+        if (0x0d0a870a != cio_read(cio, 4)) {
+                opj_event_msg(cinfo, EVT_ERROR, "Error with JP Marker\n");
+                return false;
+        }
+        if (cio_tell(cio) - box.init_pos != box.length) {
+                opj_event_msg(cinfo, EVT_ERROR, "Error with JP Box size\n");
+                return false;
+        }
+
+        return true;
+}
+
+
+static bool jp2_read_struct(opj_jp2_t *jp2, opj_cio_t *cio) {
+        if (!jp2_read_jp(jp2, cio))
+                return false;
+        if (!jp2_read_ftyp(jp2, cio))
+                return false;
+        if (!jp2_read_jp2h(jp2, cio))
+                return false;
+        if (!jp2_read_jp2c(jp2, cio, &jp2->j2k_codestream_length, &jp2->j2k_codestream_offset))
+                return false;
+        
+        return true;
+}
+
+/* ----------------------------------------------------------------------- */
+/* JP2 decoder interface                                             */
+/* ----------------------------------------------------------------------- */
+
+opj_jp2_t* jp2_create_decompress(opj_common_ptr cinfo) {
+        opj_jp2_t *jp2 = (opj_jp2_t*)opj_malloc(sizeof(opj_jp2_t));
+        if(jp2) {
+                jp2->cinfo = cinfo;
+                /* create the J2K codec */
+                jp2->j2k = j2k_create_decompress(cinfo);
+                if(jp2->j2k == NULL) {
+                        jp2_destroy_decompress(jp2);
+                        return NULL;
+                }
+        }
+        return jp2;
+}
+
+void jp2_destroy_decompress(opj_jp2_t *jp2) {
+        if(jp2) {
+                /* destroy the J2K codec */
+                j2k_destroy_decompress(jp2->j2k);
+
+                if(jp2->comps) {
+                        opj_free(jp2->comps);
+                }
+                if(jp2->cl) {
+                        opj_free(jp2->cl);
+                }
+                opj_free(jp2);
+        }
+}
+
+void jp2_setup_decoder(opj_jp2_t *jp2, opj_dparameters_t *parameters) {
+        /* setup the J2K codec */
+        j2k_setup_decoder(jp2->j2k, parameters);
+        /* further JP2 initializations go here */
+}
+
+opj_image_t* jp2_decode(opj_jp2_t *jp2, opj_cio_t *cio) {
+        opj_common_ptr cinfo;
+        opj_image_t *image = NULL;
+
+        if(!jp2 || !cio) {
+                return NULL;
+        }
+
+        cinfo = jp2->cinfo;
+
+        /* JP2 decoding */
+        if(!jp2_read_struct(jp2, cio)) {
+                opj_event_msg(cinfo, EVT_ERROR, "Failed to decode jp2 structure\n");
+                return NULL;
+        }
+
+        /* J2K decoding */
+        image = j2k_decode(jp2->j2k, cio);
+        if(!image) {
+                opj_event_msg(cinfo, EVT_ERROR, "Failed to decode J2K image\n");
+        }
+
+        return image;
+}
+
+/* ----------------------------------------------------------------------- */
+/* JP2 encoder interface                                             */
+/* ----------------------------------------------------------------------- */
+
+opj_jp2_t* jp2_create_compress(opj_common_ptr cinfo) {
+        opj_jp2_t *jp2 = (opj_jp2_t*)opj_malloc(sizeof(opj_jp2_t));
+        if(jp2) {
+                jp2->cinfo = cinfo;
+                /* create the J2K codec */
+                jp2->j2k = j2k_create_compress(cinfo);
+                if(jp2->j2k == NULL) {
+                        jp2_destroy_compress(jp2);
+                        return NULL;
+                }
+        }
+        return jp2;
+}
+
+void jp2_destroy_compress(opj_jp2_t *jp2) {
+        if(jp2) {
+                /* destroy the J2K codec */
+                j2k_destroy_compress(jp2->j2k);
+
+                if(jp2->comps) {
+                        opj_free(jp2->comps);
+                }
+                if(jp2->cl) {
+                        opj_free(jp2->cl);
+                }
+                opj_free(jp2);
+        }
+}
+
+void jp2_setup_encoder(opj_jp2_t *jp2, opj_cparameters_t *parameters, opj_image_t *image) {
+        int i;
+        int depth_0, sign;
+
+        if(!jp2 || !parameters || !image)
+                return;
+
+        /* setup the J2K codec */
+        /* ------------------- */
+
+        /* Check if number of components respects standard */
+        if (image->numcomps < 1 || image->numcomps > 16384) {
+                opj_event_msg(jp2->cinfo, EVT_ERROR, "Invalid number of components specified while setting up JP2 encoder\n");
+                return;
+        }
+
+        j2k_setup_encoder(jp2->j2k, parameters, image);
+
+        /* setup the JP2 codec */
+        /* ------------------- */
+        
+        /* Profile box */
+
+        jp2->brand = JP2_JP2;   /* BR */
+        jp2->minversion = 0;    /* MinV */
+        jp2->numcl = 1;
+        jp2->cl = (unsigned int*) opj_malloc(jp2->numcl * sizeof(unsigned int));
+        jp2->cl[0] = JP2_JP2;   /* CL0 : JP2 */
+
+        /* Image Header box */
+
+        jp2->numcomps = image->numcomps;        /* NC */
+        jp2->comps = (opj_jp2_comps_t*) opj_malloc(jp2->numcomps * sizeof(opj_jp2_comps_t));
+        jp2->h = image->y1 - image->y0;         /* HEIGHT */
+        jp2->w = image->x1 - image->x0;         /* WIDTH */
+        /* BPC */
+        depth_0 = image->comps[0].prec - 1;
+        sign = image->comps[0].sgnd;
+        jp2->bpc = depth_0 + (sign << 7);
+        for (i = 1; i < image->numcomps; i++) {
+                int depth = image->comps[i].prec - 1;
+                sign = image->comps[i].sgnd;
+                if (depth_0 != depth)
+                        jp2->bpc = 255;
+        }
+        jp2->C = 7;                     /* C : Always 7 */
+        jp2->UnkC = 0;          /* UnkC, colorspace specified in colr box */
+        jp2->IPR = 0;           /* IPR, no intellectual property */
+        
+        /* BitsPerComponent box */
+
+        for (i = 0; i < image->numcomps; i++) {
+                jp2->comps[i].bpcc = image->comps[i].prec - 1 + (image->comps[i].sgnd << 7);
+        }
+
+        /* Colour Specification box */
+
+        if ((image->numcomps == 1 || image->numcomps == 3) && (jp2->bpc != 255)) {
+                jp2->meth = 1;  /* METH: Enumerated colourspace */
+        } else {
+                jp2->meth = 2;  /* METH: Restricted ICC profile */
+        }
+        if (jp2->meth == 1) {
+                if (image->color_space == 1)
+                        jp2->enumcs = 16;       /* sRGB as defined by IEC 61966–2–1 */
+                else if (image->color_space == 2)
+                        jp2->enumcs = 17;       /* greyscale */
+                else if (image->color_space == 3)
+                        jp2->enumcs = 18;       /* YUV */
+        } else {
+                jp2->enumcs = 0;                /* PROFILE (??) */
+        }
+        jp2->precedence = 0;    /* PRECEDENCE */
+        jp2->approx = 0;                /* APPROX */
+
+}
+
+bool jp2_encode(opj_jp2_t *jp2, opj_cio_t *cio, opj_image_t *image, char *index) {
+
+        /* JP2 encoding */
+
+        /* JPEG 2000 Signature box */
+        jp2_write_jp(cio);
+        /* File Type box */
+        jp2_write_ftyp(jp2, cio);
+        /* JP2 Header box */
+        jp2_write_jp2h(jp2, cio);
+
+        /* J2K encoding */
+
+        if(!jp2_write_jp2c(jp2, cio, image, index)) {
+                opj_event_msg(jp2->cinfo, EVT_ERROR, "Failed to encode image\n");
+                return false;
+        }
+
+        return true;
+}
+
+
diff --git a/libraries/openjpeg-libsl/libopenjpeg/jp2.h b/libraries/openjpeg-libsl/libopenjpeg/jp2.h
new file mode 100644
index 0000000..61fc1e4
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/jp2.h
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __JP2_H
+#define __JP2_H
+/**
+@file jp2.h
+@brief The JPEG-2000 file format Reader/Writer (JP2)
+
+*/
+
+/** @defgroup JP2 JP2 - JPEG-2000 file format reader/writer */
+/*@{*/
+
+#define JPIP_JPIP 0x6a706970
+
+#define JP2_JP   0x6a502020             /**< JPEG 2000 signature box */
+#define JP2_FTYP 0x66747970             /**< File type box */
+#define JP2_JP2H 0x6a703268             /**< JP2 header box */
+#define JP2_IHDR 0x69686472             /**< Image header box */
+#define JP2_COLR 0x636f6c72             /**< Colour specification box */
+#define JP2_JP2C 0x6a703263             /**< Contiguous codestream box */
+#define JP2_URL  0x75726c20             /**< URL box */
+#define JP2_DBTL 0x6474626c             /**< ??? */
+#define JP2_BPCC 0x62706363             /**< Bits per component box */
+#define JP2_JP2  0x6a703220             /**< File type fields */
+
+/* ----------------------------------------------------------------------- */
+
+/** 
+JP2 component
+*/
+typedef struct opj_jp2_comps {
+  int depth;              
+  int sgnd;                
+  int bpcc;
+} opj_jp2_comps_t;
+
+/**
+JPEG-2000 file format reader/writer
+*/
+typedef struct opj_jp2 {
+        /** codec context */
+        opj_common_ptr cinfo;
+        /** handle to the J2K codec  */
+        opj_j2k_t *j2k;
+        unsigned int w;
+        unsigned int h;
+        unsigned int numcomps;
+        unsigned int bpc;
+        unsigned int C;
+        unsigned int UnkC;
+        unsigned int IPR;
+        unsigned int meth;
+        unsigned int approx;
+        unsigned int enumcs;
+        unsigned int precedence;
+        unsigned int brand;
+        unsigned int minversion;
+        unsigned int numcl;
+        unsigned int *cl;
+        opj_jp2_comps_t *comps;
+        unsigned int j2k_codestream_offset;
+        unsigned int j2k_codestream_length;
+} opj_jp2_t;
+
+/**
+JP2 Box
+*/
+typedef struct opj_jp2_box {
+  int length;
+  int type;
+  int init_pos;
+} opj_jp2_box_t;
+
+/** @name Exported functions */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+/**
+Write the JP2H box - JP2 Header box (used in MJ2)
+@param jp2 JP2 handle
+@param cio Output buffer stream
+*/
+void jp2_write_jp2h(opj_jp2_t *jp2, opj_cio_t *cio);
+/**
+Read the JP2H box - JP2 Header box (used in MJ2)
+@param jp2 JP2 handle
+@param cio Input buffer stream
+@return Returns true if successful, returns false otherwise
+*/
+bool jp2_read_jp2h(opj_jp2_t *jp2, opj_cio_t *cio);
+/**
+Creates a JP2 decompression structure
+@param cinfo Codec context info
+@return Returns a handle to a JP2 decompressor if successful, returns NULL otherwise
+*/
+opj_jp2_t* jp2_create_decompress(opj_common_ptr cinfo);
+/**
+Destroy a JP2 decompressor handle
+@param jp2 JP2 decompressor handle to destroy
+*/
+void jp2_destroy_decompress(opj_jp2_t *jp2);
+/**
+Setup the decoder decoding parameters using user parameters.
+Decoding parameters are returned in jp2->j2k->cp. 
+@param jp2 JP2 decompressor handle
+@param parameters decompression parameters
+*/
+void jp2_setup_decoder(opj_jp2_t *jp2, opj_dparameters_t *parameters);
+/**
+Decode an image from a JPEG-2000 file stream
+@param jp2 JP2 decompressor handle
+@param cio Input buffer stream
+@return Returns a decoded image if successful, returns NULL otherwise
+*/
+opj_image_t* jp2_decode(opj_jp2_t *jp2, opj_cio_t *cio);
+/**
+Creates a JP2 compression structure
+@param cinfo Codec context info
+@return Returns a handle to a JP2 compressor if successful, returns NULL otherwise
+*/
+opj_jp2_t* jp2_create_compress(opj_common_ptr cinfo);
+/**
+Destroy a JP2 compressor handle
+@param jp2 JP2 compressor handle to destroy
+*/
+void jp2_destroy_compress(opj_jp2_t *jp2);
+/**
+Setup the encoder parameters using the current image and using user parameters. 
+Coding parameters are returned in jp2->j2k->cp. 
+@param jp2 JP2 compressor handle
+@param parameters compression parameters
+@param image input filled image
+*/
+void jp2_setup_encoder(opj_jp2_t *jp2, opj_cparameters_t *parameters, opj_image_t *image);
+/**
+Encode an image into a JPEG-2000 file stream
+@param jp2 JP2 compressor handle
+@param cio Output buffer stream
+@param image Image to encode
+@param index Name of the index file if required, NULL otherwise
+@return Returns true if successful, returns false otherwise
+*/
+bool jp2_encode(opj_jp2_t *jp2, opj_cio_t *cio, opj_image_t *image, char *index);
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __JP2_H */
+
diff --git a/libraries/openjpeg-libsl/libopenjpeg/jpt.c b/libraries/openjpeg-libsl/libopenjpeg/jpt.c
new file mode 100644
index 0000000..a2566ea
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/jpt.c
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "opj_includes.h"
+
+/*
+ * Read the information contains in VBAS [JPP/JPT stream message header]
+ * Store information (7 bits) in value
+ *
+ */
+unsigned int jpt_read_VBAS_info(opj_cio_t *cio, unsigned int value) {
+        unsigned char elmt;
+
+        elmt = cio_read(cio, 1);
+        while ((elmt >> 7) == 1) {
+                value = (value << 7);
+                value |= (elmt & 0x7f);
+                elmt = cio_read(cio, 1);
+        }
+        value = (value << 7);
+        value |= (elmt & 0x7f);
+
+        return value;
+}
+
+/*
+ * Initialize the value of the message header structure 
+ *
+ */
+void jpt_init_msg_header(opj_jpt_msg_header_t * header) {
+        header->Id = 0;         /* In-class Identifier    */
+        header->last_byte = 0;  /* Last byte information  */
+        header->Class_Id = 0;           /* Class Identifier       */
+        header->CSn_Id = 0;             /* CSn : index identifier */
+        header->Msg_offset = 0; /* Message offset         */
+        header->Msg_length = 0; /* Message length         */
+        header->Layer_nb = 0;           /* Auxiliary for JPP case */
+}
+
+/*
+ * Re-initialize the value of the message header structure
+ *
+ * Only parameters always present in message header
+ *
+ */
+void jpt_reinit_msg_header(opj_jpt_msg_header_t * header) {
+        header->Id = 0;         /* In-class Identifier    */
+        header->last_byte = 0;  /* Last byte information  */
+        header->Msg_offset = 0; /* Message offset         */
+        header->Msg_length = 0; /* Message length         */
+}
+
+/*
+ * Read the message header for a JPP/JPT - stream
+ *
+ */
+void jpt_read_msg_header(opj_common_ptr cinfo, opj_cio_t *cio, opj_jpt_msg_header_t *header) {
+        unsigned char elmt, Class = 0, CSn = 0;
+        jpt_reinit_msg_header(header);
+
+        /* ------------- */
+        /* VBAS : Bin-ID */
+        /* ------------- */
+        elmt = cio_read(cio, 1);
+
+        /* See for Class and CSn */
+        switch ((elmt >> 5) & 0x03) {
+                case 0:
+                        opj_event_msg(cinfo, EVT_ERROR, "Forbidden value encounter in message header !!\n");
+                        break;
+                case 1:
+                        Class = 0;
+                        CSn = 0;
+                        break;
+                case 2:
+                        Class = 1;
+                        CSn = 0;
+                        break;
+                case 3:
+                        Class = 1;
+                        CSn = 1;
+                        break;
+                default:
+                        break;
+        }
+
+        /* see information on bits 'c' [p 10 : A.2.1 general, ISO/IEC FCD 15444-9] */
+        if (((elmt >> 4) & 0x01) == 1)
+                header->last_byte = 1;
+
+        /* In-class identifier */
+        header->Id |= (elmt & 0x0f);
+        if ((elmt >> 7) == 1)
+                header->Id = jpt_read_VBAS_info(cio, header->Id);
+
+        /* ------------ */
+        /* VBAS : Class */
+        /* ------------ */
+        if (Class == 1) {
+                header->Class_Id = 0;
+                header->Class_Id = jpt_read_VBAS_info(cio, header->Class_Id);
+        }
+
+        /* ---------- */
+        /* VBAS : CSn */
+        /* ---------- */
+        if (CSn == 1) {
+                header->CSn_Id = 0;
+                header->CSn_Id = jpt_read_VBAS_info(cio, header->CSn_Id);
+        }
+
+        /* ----------------- */
+        /* VBAS : Msg_offset */
+        /* ----------------- */
+        header->Msg_offset = jpt_read_VBAS_info(cio, header->Msg_offset);
+
+        /* ----------------- */
+        /* VBAS : Msg_length */
+        /* ----------------- */
+        header->Msg_length = jpt_read_VBAS_info(cio, header->Msg_length);
+
+        /* ---------- */
+        /* VBAS : Aux */
+        /* ---------- */
+        if ((header->Class_Id & 0x01) == 1) {
+                header->Layer_nb = 0;
+                header->Layer_nb = jpt_read_VBAS_info(cio, header->Layer_nb);
+        }
+}
diff --git a/libraries/openjpeg-libsl/libopenjpeg/jpt.h b/libraries/openjpeg-libsl/libopenjpeg/jpt.h
new file mode 100644
index 0000000..eb01f98
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/jpt.h
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __JPT_H
+#define __JPT_H
+/**
+@file jpt.h
+@brief JPT-stream reader (JPEG 2000, JPIP)
+
+JPT-stream functions are implemented in J2K.C. 
+*/
+
+/**
+Message Header JPT stream structure
+*/
+typedef struct opj_jpt_msg_header {
+        /** In-class Identifier */
+        unsigned int Id;
+        /** Last byte information */
+        unsigned int last_byte; 
+        /** Class Identifier */
+        unsigned int Class_Id;  
+        /** CSn : index identifier */
+        unsigned int CSn_Id;
+        /** Message offset */
+        unsigned int Msg_offset;
+        /** Message length */
+        unsigned int Msg_length;
+        /** Auxiliary for JPP case */
+        unsigned int Layer_nb;
+} opj_jpt_msg_header_t;
+
+/* ----------------------------------------------------------------------- */
+
+/**
+Initialize the value of the message header structure 
+@param header Message header structure
+*/
+void jpt_init_msg_header(opj_jpt_msg_header_t * header);
+
+/**
+Read the message header for a JPP/JPT - stream
+@param cinfo Codec context info
+@param cio CIO handle
+@param header Message header structure
+*/
+void jpt_read_msg_header(opj_common_ptr cinfo, opj_cio_t *cio, opj_jpt_msg_header_t *header);
+
+#endif
diff --git a/libraries/openjpeg-libsl/libopenjpeg/mct.c b/libraries/openjpeg-libsl/libopenjpeg/mct.c
new file mode 100644
index 0000000..fad9355
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/mct.c
@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "opj_includes.h"
+
+/* <summary> */
+/* This table contains the norms of the basis function of the reversible MCT. */
+/* </summary> */
+static const double mct_norms[3] = { 1.732, .8292, .8292 };
+
+/* <summary> */
+/* This table contains the norms of the basis function of the irreversible MCT. */
+/* </summary> */
+static const double mct_norms_real[3] = { 1.732, 1.805, 1.573 };
+
+/* <summary> */
+/* Foward reversible MCT. */
+/* </summary> */
+void mct_encode(int *c0, int *c1, int *c2, int n) {
+        int i;
+        for (i = 0; i < n; i++) {
+                int r, g, b, y, u, v;
+                r = c0[i];
+                g = c1[i];
+                b = c2[i];
+                y = (r + (g << 1) + b) >> 2;
+                u = b - g;
+                v = r - g;
+                c0[i] = y;
+                c1[i] = u;
+                c2[i] = v;
+        }
+}
+
+/* <summary> */
+/* Inverse reversible MCT. */
+/* </summary> */
+void mct_decode(int *c0, int *c1, int *c2, int n) {
+        int i;
+        for (i = 0; i < n; i++) {
+                int y, u, v, r, g, b;
+                y = c0[i];
+                u = c1[i];
+                v = c2[i];
+                g = y - ((u + v) >> 2);
+                r = v + g;
+                b = u + g;
+                c0[i] = r;
+                c1[i] = g;
+                c2[i] = b;
+        }
+}
+
+/* <summary> */
+/* Get norm of basis function of reversible MCT. */
+/* </summary> */
+double mct_getnorm(int compno) {
+        return mct_norms[compno];
+}
+
+/* <summary> */
+/* Foward irreversible MCT. */
+/* </summary> */
+void mct_encode_real(int *c0, int *c1, int *c2, int n) {
+        int i;
+        for (i = 0; i < n; i++) {
+                int r, g, b, y, u, v;
+                r = c0[i];
+                g = c1[i];
+                b = c2[i];
+                y = fix_mul(r, 2449) + fix_mul(g, 4809) + fix_mul(b, 934);
+                u = -fix_mul(r, 1382) - fix_mul(g, 2714) + fix_mul(b, 4096);
+                v = fix_mul(r, 4096) - fix_mul(g, 3430) - fix_mul(b, 666);
+                c0[i] = y;
+                c1[i] = u;
+                c2[i] = v;
+        }
+}
+
+/* <summary> */
+/* Inverse irreversible MCT. */
+/* </summary> */
+void mct_decode_real(int *c0, int *c1, int *c2, int n) {
+        int i;
+        for (i = 0; i < n; i++) {
+                int y, u, v, r, g, b;
+                y = c0[i];
+                u = c1[i];
+                v = c2[i];
+                r = y + fix_mul(v, 11485);
+                g = y - fix_mul(u, 2819) - fix_mul(v, 5850);
+                b = y + fix_mul(u, 14516);
+                c0[i] = r;
+                c1[i] = g;
+                c2[i] = b;
+        }
+}
+
+/* <summary> */
+/* Get norm of basis function of irreversible MCT. */
+/* </summary> */
+double mct_getnorm_real(int compno) {
+        return mct_norms_real[compno];
+}
diff --git a/libraries/openjpeg-libsl/libopenjpeg/mct.h b/libraries/openjpeg-libsl/libopenjpeg/mct.h
new file mode 100644
index 0000000..7596187
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/mct.h
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __MCT_H
+#define __MCT_H
+/**
+@file mct.h
+@brief Implementation of a multi-component transforms (MCT)
+
+The functions in MCT.C have for goal to realize reversible and irreversible multicomponent
+transform. The functions in MCT.C are used by some function in TCD.C.
+*/
+
+/** @defgroup MCT MCT - Implementation of a multi-component transform */
+/*@{*/
+
+/** @name Exported functions */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+/**
+Apply a reversible multi-component transform to an image
+@param c0 Samples for red component
+@param c1 Samples for green component
+@param c2 Samples blue component
+@param n Number of samples for each component
+*/
+void mct_encode(int *c0, int *c1, int *c2, int n);
+/**
+Apply a reversible multi-component inverse transform to an image
+@param c0 Samples for luminance component
+@param c1 Samples for red chrominance component
+@param c2 Samples for blue chrominance component
+@param n Number of samples for each component
+*/
+void mct_decode(int *c0, int *c1, int *c2, int n);
+/**
+Get norm of the basis function used for the reversible multi-component transform
+@param compno Number of the component (0->Y, 1->U, 2->V)
+@return 
+*/
+double mct_getnorm(int compno);
+
+/**
+Apply an irreversible multi-component transform to an image
+@param c0 Samples for red component
+@param c1 Samples for green component
+@param c2 Samples blue component
+@param n Number of samples for each component
+*/
+void mct_encode_real(int *c0, int *c1, int *c2, int n);
+/**
+Apply an irreversible multi-component inverse transform to an image
+@param c0 Samples for luminance component
+@param c1 Samples for red chrominance component
+@param c2 Samples for blue chrominance component
+@param n Number of samples for each component
+*/
+void mct_decode_real(int *c0, int *c1, int *c2, int n);
+/**
+Get norm of the basis function used for the irreversible multi-component transform
+@param compno Number of the component (0->Y, 1->U, 2->V)
+@return 
+*/
+double mct_getnorm_real(int compno);
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __MCT_H */
diff --git a/libraries/openjpeg-libsl/libopenjpeg/mqc.c b/libraries/openjpeg-libsl/libopenjpeg/mqc.c
new file mode 100644
index 0000000..e6dd007
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/mqc.c
@@ -0,0 +1,542 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "opj_includes.h"
+
+/** @defgroup MQC MQC - Implementation of an MQ-Coder */
+/*@{*/
+
+/** @name Local static functions */
+/*@{*/
+
+/**
+Output a byte, doing bit-stuffing if necessary.
+After a 0xff byte, the next byte must be smaller than 0x90.
+@param mqc MQC handle
+*/
+static void mqc_byteout(opj_mqc_t *mqc);
+/**
+Renormalize mqc->a and mqc->c while encoding, so that mqc->a stays between 0x8000 and 0x10000
+@param mqc MQC handle
+*/
+static void mqc_renorme(opj_mqc_t *mqc);
+/**
+Encode the most probable symbol
+@param mqc MQC handle
+*/
+static void mqc_codemps(opj_mqc_t *mqc);
+/**
+Encode the most least symbol
+@param mqc MQC handle
+*/
+static void mqc_codelps(opj_mqc_t *mqc);
+/**
+Fill mqc->c with 1's for flushing
+@param mqc MQC handle
+*/
+static void mqc_setbits(opj_mqc_t *mqc);
+/**
+FIXME: documentation ???
+@param mqc MQC handle
+@return 
+*/
+static int mqc_mpsexchange(opj_mqc_t *mqc);
+/**
+FIXME: documentation ???
+@param mqc MQC handle
+@return 
+*/
+static int mqc_lpsexchange(opj_mqc_t *mqc);
+/**
+Input a byte
+@param mqc MQC handle
+*/
+static void mqc_bytein(opj_mqc_t *mqc);
+/**
+Renormalize mqc->a and mqc->c while decoding
+@param mqc MQC handle
+*/
+static void mqc_renormd(opj_mqc_t *mqc);
+
+/*@}*/
+
+/*@}*/
+
+/* <summary> */
+/* This array defines all the possible states for a context. */
+/* </summary> */
+static opj_mqc_state_t mqc_states[47 * 2] = {
+        {0x5601, 0, &mqc_states[2], &mqc_states[3]},
+        {0x5601, 1, &mqc_states[3], &mqc_states[2]},
+        {0x3401, 0, &mqc_states[4], &mqc_states[12]},
+        {0x3401, 1, &mqc_states[5], &mqc_states[13]},
+        {0x1801, 0, &mqc_states[6], &mqc_states[18]},
+        {0x1801, 1, &mqc_states[7], &mqc_states[19]},
+        {0x0ac1, 0, &mqc_states[8], &mqc_states[24]},
+        {0x0ac1, 1, &mqc_states[9], &mqc_states[25]},
+        {0x0521, 0, &mqc_states[10], &mqc_states[58]},
+        {0x0521, 1, &mqc_states[11], &mqc_states[59]},
+        {0x0221, 0, &mqc_states[76], &mqc_states[66]},
+        {0x0221, 1, &mqc_states[77], &mqc_states[67]},
+        {0x5601, 0, &mqc_states[14], &mqc_states[13]},
+        {0x5601, 1, &mqc_states[15], &mqc_states[12]},
+        {0x5401, 0, &mqc_states[16], &mqc_states[28]},
+        {0x5401, 1, &mqc_states[17], &mqc_states[29]},
+        {0x4801, 0, &mqc_states[18], &mqc_states[28]},
+        {0x4801, 1, &mqc_states[19], &mqc_states[29]},
+        {0x3801, 0, &mqc_states[20], &mqc_states[28]},
+        {0x3801, 1, &mqc_states[21], &mqc_states[29]},
+        {0x3001, 0, &mqc_states[22], &mqc_states[34]},
+        {0x3001, 1, &mqc_states[23], &mqc_states[35]},
+        {0x2401, 0, &mqc_states[24], &mqc_states[36]},
+        {0x2401, 1, &mqc_states[25], &mqc_states[37]},
+        {0x1c01, 0, &mqc_states[26], &mqc_states[40]},
+        {0x1c01, 1, &mqc_states[27], &mqc_states[41]},
+        {0x1601, 0, &mqc_states[58], &mqc_states[42]},
+        {0x1601, 1, &mqc_states[59], &mqc_states[43]},
+        {0x5601, 0, &mqc_states[30], &mqc_states[29]},
+        {0x5601, 1, &mqc_states[31], &mqc_states[28]},
+        {0x5401, 0, &mqc_states[32], &mqc_states[28]},
+        {0x5401, 1, &mqc_states[33], &mqc_states[29]},
+        {0x5101, 0, &mqc_states[34], &mqc_states[30]},
+        {0x5101, 1, &mqc_states[35], &mqc_states[31]},
+        {0x4801, 0, &mqc_states[36], &mqc_states[32]},
+        {0x4801, 1, &mqc_states[37], &mqc_states[33]},
+        {0x3801, 0, &mqc_states[38], &mqc_states[34]},
+        {0x3801, 1, &mqc_states[39], &mqc_states[35]},
+        {0x3401, 0, &mqc_states[40], &mqc_states[36]},
+        {0x3401, 1, &mqc_states[41], &mqc_states[37]},
+        {0x3001, 0, &mqc_states[42], &mqc_states[38]},
+        {0x3001, 1, &mqc_states[43], &mqc_states[39]},
+        {0x2801, 0, &mqc_states[44], &mqc_states[38]},
+        {0x2801, 1, &mqc_states[45], &mqc_states[39]},
+        {0x2401, 0, &mqc_states[46], &mqc_states[40]},
+        {0x2401, 1, &mqc_states[47], &mqc_states[41]},
+        {0x2201, 0, &mqc_states[48], &mqc_states[42]},
+        {0x2201, 1, &mqc_states[49], &mqc_states[43]},
+        {0x1c01, 0, &mqc_states[50], &mqc_states[44]},
+        {0x1c01, 1, &mqc_states[51], &mqc_states[45]},
+        {0x1801, 0, &mqc_states[52], &mqc_states[46]},
+        {0x1801, 1, &mqc_states[53], &mqc_states[47]},
+        {0x1601, 0, &mqc_states[54], &mqc_states[48]},
+        {0x1601, 1, &mqc_states[55], &mqc_states[49]},
+        {0x1401, 0, &mqc_states[56], &mqc_states[50]},
+        {0x1401, 1, &mqc_states[57], &mqc_states[51]},
+        {0x1201, 0, &mqc_states[58], &mqc_states[52]},
+        {0x1201, 1, &mqc_states[59], &mqc_states[53]},
+        {0x1101, 0, &mqc_states[60], &mqc_states[54]},
+        {0x1101, 1, &mqc_states[61], &mqc_states[55]},
+        {0x0ac1, 0, &mqc_states[62], &mqc_states[56]},
+        {0x0ac1, 1, &mqc_states[63], &mqc_states[57]},
+        {0x09c1, 0, &mqc_states[64], &mqc_states[58]},
+        {0x09c1, 1, &mqc_states[65], &mqc_states[59]},
+        {0x08a1, 0, &mqc_states[66], &mqc_states[60]},
+        {0x08a1, 1, &mqc_states[67], &mqc_states[61]},
+        {0x0521, 0, &mqc_states[68], &mqc_states[62]},
+        {0x0521, 1, &mqc_states[69], &mqc_states[63]},
+        {0x0441, 0, &mqc_states[70], &mqc_states[64]},
+        {0x0441, 1, &mqc_states[71], &mqc_states[65]},
+        {0x02a1, 0, &mqc_states[72], &mqc_states[66]},
+        {0x02a1, 1, &mqc_states[73], &mqc_states[67]},
+        {0x0221, 0, &mqc_states[74], &mqc_states[68]},
+        {0x0221, 1, &mqc_states[75], &mqc_states[69]},
+        {0x0141, 0, &mqc_states[76], &mqc_states[70]},
+        {0x0141, 1, &mqc_states[77], &mqc_states[71]},
+        {0x0111, 0, &mqc_states[78], &mqc_states[72]},
+        {0x0111, 1, &mqc_states[79], &mqc_states[73]},
+        {0x0085, 0, &mqc_states[80], &mqc_states[74]},
+        {0x0085, 1, &mqc_states[81], &mqc_states[75]},
+        {0x0049, 0, &mqc_states[82], &mqc_states[76]},
+        {0x0049, 1, &mqc_states[83], &mqc_states[77]},
+        {0x0025, 0, &mqc_states[84], &mqc_states[78]},
+        {0x0025, 1, &mqc_states[85], &mqc_states[79]},
+        {0x0015, 0, &mqc_states[86], &mqc_states[80]},
+        {0x0015, 1, &mqc_states[87], &mqc_states[81]},
+        {0x0009, 0, &mqc_states[88], &mqc_states[82]},
+        {0x0009, 1, &mqc_states[89], &mqc_states[83]},
+        {0x0005, 0, &mqc_states[90], &mqc_states[84]},
+        {0x0005, 1, &mqc_states[91], &mqc_states[85]},
+        {0x0001, 0, &mqc_states[90], &mqc_states[86]},
+        {0x0001, 1, &mqc_states[91], &mqc_states[87]},
+        {0x5601, 0, &mqc_states[92], &mqc_states[92]},
+        {0x5601, 1, &mqc_states[93], &mqc_states[93]},
+};
+
+/* 
+==========================================================
+   local functions
+==========================================================
+*/
+
+static void mqc_byteout(opj_mqc_t *mqc) {
+        if (*mqc->bp == 0xff) {
+                mqc->bp++;
+                *mqc->bp = mqc->c >> 20;
+                mqc->c &= 0xfffff;
+                mqc->ct = 7;
+        } else {
+                if ((mqc->c & 0x8000000) == 0) {        /* ((mqc->c&0x8000000)==0) CHANGE */
+                        mqc->bp++;
+                        *mqc->bp = mqc->c >> 19;
+                        mqc->c &= 0x7ffff;
+                        mqc->ct = 8;
+                } else {
+                        (*mqc->bp)++;
+                        if (*mqc->bp == 0xff) {
+                                mqc->c &= 0x7ffffff;
+                                mqc->bp++;
+                                *mqc->bp = mqc->c >> 20;
+                                mqc->c &= 0xfffff;
+                                mqc->ct = 7;
+                        } else {
+                                mqc->bp++;
+                                *mqc->bp = mqc->c >> 19;
+                                mqc->c &= 0x7ffff;
+                                mqc->ct = 8;
+                        }
+                }
+        }
+}
+
+static void mqc_renorme(opj_mqc_t *mqc) {
+        do {
+                mqc->a <<= 1;
+                mqc->c <<= 1;
+                mqc->ct--;
+                if (mqc->ct == 0) {
+                        mqc_byteout(mqc);
+                }
+        } while ((mqc->a & 0x8000) == 0);
+}
+
+static void mqc_codemps(opj_mqc_t *mqc) {
+        mqc->a -= (*mqc->curctx)->qeval;
+        if ((mqc->a & 0x8000) == 0) {
+                if (mqc->a < (*mqc->curctx)->qeval) {
+                        mqc->a = (*mqc->curctx)->qeval;
+                } else {
+                        mqc->c += (*mqc->curctx)->qeval;
+                }
+                *mqc->curctx = (*mqc->curctx)->nmps;
+                mqc_renorme(mqc);
+        } else {
+                mqc->c += (*mqc->curctx)->qeval;
+        }
+}
+
+static void mqc_codelps(opj_mqc_t *mqc) {
+        mqc->a -= (*mqc->curctx)->qeval;
+        if (mqc->a < (*mqc->curctx)->qeval) {
+                mqc->c += (*mqc->curctx)->qeval;
+        } else {
+                mqc->a = (*mqc->curctx)->qeval;
+        }
+        *mqc->curctx = (*mqc->curctx)->nlps;
+        mqc_renorme(mqc);
+}
+
+static void mqc_setbits(opj_mqc_t *mqc) {
+        unsigned int tempc = mqc->c + mqc->a;
+        mqc->c |= 0xffff;
+        if (mqc->c >= tempc) {
+                mqc->c -= 0x8000;
+        }
+}
+
+static int mqc_mpsexchange(opj_mqc_t *mqc) {
+        int d;
+        if (mqc->a < (*mqc->curctx)->qeval) {
+                d = 1 - (*mqc->curctx)->mps;
+                *mqc->curctx = (*mqc->curctx)->nlps;
+        } else {
+                d = (*mqc->curctx)->mps;
+                *mqc->curctx = (*mqc->curctx)->nmps;
+        }
+        
+        return d;
+}
+
+static int mqc_lpsexchange(opj_mqc_t *mqc) {
+        int d;
+        if (mqc->a < (*mqc->curctx)->qeval) {
+                mqc->a = (*mqc->curctx)->qeval;
+                d = (*mqc->curctx)->mps;
+                *mqc->curctx = (*mqc->curctx)->nmps;
+        } else {
+                mqc->a = (*mqc->curctx)->qeval;
+                d = 1 - (*mqc->curctx)->mps;
+                *mqc->curctx = (*mqc->curctx)->nlps;
+        }
+        
+        return d;
+}
+
+static void mqc_bytein(opj_mqc_t *mqc) {
+        if (mqc->bp != mqc->end) {
+                unsigned int c;
+                if (mqc->bp + 1 != mqc->end) {
+                        c = *(mqc->bp + 1);
+                } else {
+                        c = 0xff;
+                }
+                if (*mqc->bp == 0xff) {
+                        if (c > 0x8f) {
+                                mqc->c += 0xff00;
+                                mqc->ct = 8;
+                        } else {
+                                mqc->bp++;
+                                mqc->c += c << 9;
+                                mqc->ct = 7;
+                        }
+                } else {
+                        mqc->bp++;
+                        mqc->c += c << 8;
+                        mqc->ct = 8;
+                }
+        } else {
+                mqc->c += 0xff00;
+                mqc->ct = 8;
+        }
+}
+
+static void mqc_renormd(opj_mqc_t *mqc) {
+        do {
+                if (mqc->ct == 0) {
+                        mqc_bytein(mqc);
+                }
+                mqc->a <<= 1;
+                mqc->c <<= 1;
+                mqc->ct--;
+        } while (mqc->a < 0x8000);
+}
+
+/* 
+==========================================================
+   MQ-Coder interface
+==========================================================
+*/
+
+opj_mqc_t* mqc_create() {
+        opj_mqc_t *mqc = (opj_mqc_t*)opj_malloc(sizeof(opj_mqc_t));
+        return mqc;
+}
+
+void mqc_destroy(opj_mqc_t *mqc) {
+        if(mqc) {
+                opj_free(mqc);
+        }
+}
+
+int mqc_numbytes(opj_mqc_t *mqc) {
+        return mqc->bp - mqc->start;
+}
+
+void mqc_init_enc(opj_mqc_t *mqc, unsigned char *bp) {
+        mqc_setcurctx(mqc, 0);
+        mqc->a = 0x8000;
+        mqc->c = 0;
+        mqc->bp = bp - 1;
+        mqc->ct = 12;
+        if (*mqc->bp == 0xff) {
+                mqc->ct = 13;
+        }
+        mqc->start = bp;
+}
+
+void mqc_setcurctx(opj_mqc_t *mqc, int ctxno) {
+        mqc->curctx = &mqc->ctxs[ctxno];
+}
+
+void mqc_encode(opj_mqc_t *mqc, int d) {
+        if ((*mqc->curctx)->mps == d) {
+                mqc_codemps(mqc);
+        } else {
+                mqc_codelps(mqc);
+        }
+}
+
+void mqc_flush(opj_mqc_t *mqc) {
+        mqc_setbits(mqc);
+        mqc->c <<= mqc->ct;
+        mqc_byteout(mqc);
+        mqc->c <<= mqc->ct;
+        mqc_byteout(mqc);
+        
+        if (*mqc->bp != 0xff) {
+                mqc->bp++;
+        }
+}
+
+void mqc_bypass_init_enc(opj_mqc_t *mqc) {
+        mqc->c = 0;
+        mqc->ct = 8;
+        /*if (*mqc->bp == 0xff) {
+        mqc->ct = 7;
+     } */
+}
+
+void mqc_bypass_enc(opj_mqc_t *mqc, int d) {
+        mqc->ct--;
+        mqc->c = mqc->c + (d << mqc->ct);
+        if (mqc->ct == 0) {
+                mqc->bp++;
+                *mqc->bp = mqc->c;
+                mqc->ct = 8;
+                if (*mqc->bp == 0xff) {
+                        mqc->ct = 7;
+                }
+                mqc->c = 0;
+        }
+}
+
+int mqc_bypass_flush_enc(opj_mqc_t *mqc) {
+        unsigned char bit_padding;
+        
+        bit_padding = 0;
+        
+        if (mqc->ct != 0) {
+                while (mqc->ct > 0) {
+                        mqc->ct--;
+                        mqc->c += bit_padding << mqc->ct;
+                        bit_padding = (bit_padding + 1) & 0x01;
+                }
+                mqc->bp++;
+                *mqc->bp = mqc->c;
+                mqc->ct = 8;
+                mqc->c = 0;
+        }
+        
+        return 1;
+}
+
+void mqc_reset_enc(opj_mqc_t *mqc) {
+        mqc_resetstates(mqc);
+        mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
+        mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
+        mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
+}
+
+int mqc_restart_enc(opj_mqc_t *mqc) {
+        int correction = 1;
+        
+        /* <flush part> */
+        int n = 27 - 15 - mqc->ct;
+        mqc->c <<= mqc->ct;
+        while (n > 0) {
+                mqc_byteout(mqc);
+                n -= mqc->ct;
+                mqc->c <<= mqc->ct;
+        }
+        mqc_byteout(mqc);
+        
+        return correction;
+}
+
+void mqc_restart_init_enc(opj_mqc_t *mqc) {
+        /* <Re-init part> */
+        mqc_setcurctx(mqc, 0);
+        mqc->a = 0x8000;
+        mqc->c = 0;
+        mqc->ct = 12;
+        mqc->bp--;
+        if (*mqc->bp == 0xff) {
+                mqc->ct = 13;
+        }
+}
+
+void mqc_erterm_enc(opj_mqc_t *mqc) {
+        int k = 11 - mqc->ct + 1;
+        
+        while (k > 0) {
+                mqc->c <<= mqc->ct;
+                mqc->ct = 0;
+                mqc_byteout(mqc);
+                k -= mqc->ct;
+        }
+        
+        if (*mqc->bp != 0xff) {
+                mqc_byteout(mqc);
+        }
+}
+
+void mqc_segmark_enc(opj_mqc_t *mqc) {
+        int i;
+        mqc_setcurctx(mqc, 18);
+        
+        for (i = 1; i < 5; i++) {
+                mqc_encode(mqc, i % 2);
+        }
+}
+
+void mqc_init_dec(opj_mqc_t *mqc, unsigned char *bp, int len) {
+        mqc_setcurctx(mqc, 0);
+        mqc->start = bp;
+        mqc->end = bp + len;
+        mqc->bp = bp;
+        if (len==0) mqc->c = 0xff << 16;
+        else mqc->c = *mqc->bp << 16;
+        mqc_bytein(mqc);
+        mqc->c <<= 7;
+        mqc->ct -= 7;
+        mqc->a = 0x8000;
+}
+
+int mqc_decode(opj_mqc_t *mqc) {
+        int d;
+        mqc->a -= (*mqc->curctx)->qeval;
+        if ((mqc->c >> 16) < (*mqc->curctx)->qeval) {
+                d = mqc_lpsexchange(mqc);
+                mqc_renormd(mqc);
+        } else {
+                mqc->c -= (*mqc->curctx)->qeval << 16;
+                if ((mqc->a & 0x8000) == 0) {
+                        d = mqc_mpsexchange(mqc);
+                        mqc_renormd(mqc);
+                } else {
+                        d = (*mqc->curctx)->mps;
+                }
+        }
+
+        return d;
+}
+
+void mqc_resetstates(opj_mqc_t *mqc) {
+        int i;
+        for (i = 0; i < MQC_NUMCTXS; i++) {
+                mqc->ctxs[i] = mqc_states;
+        }
+}
+
+void mqc_setstate(opj_mqc_t *mqc, int ctxno, int msb, int prob) {
+        mqc->ctxs[ctxno] = &mqc_states[msb + (prob << 1)];
+}
+
+
diff --git a/libraries/openjpeg-libsl/libopenjpeg/mqc.h b/libraries/openjpeg-libsl/libopenjpeg/mqc.h
new file mode 100644
index 0000000..67f38c1
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/mqc.h
@@ -0,0 +1,197 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __MQC_H
+#define __MQC_H
+/**
+@file mqc.h
+@brief Implementation of an MQ-Coder (MQC)
+
+The functions in MQC.C have for goal to realize the MQ-coder operations. The functions
+in MQC.C are used by some function in T1.C.
+*/
+
+/** @defgroup MQC MQC - Implementation of an MQ-Coder */
+/*@{*/
+
+/**
+This struct defines the state of a context.
+*/
+typedef struct opj_mqc_state {
+        /** the probability of the Least Probable Symbol (0.75->0x8000, 1.5->0xffff) */
+        unsigned int qeval;
+        /** the Most Probable Symbol (0 or 1) */
+        int mps;
+        /** next state if the next encoded symbol is the MPS */
+        struct opj_mqc_state *nmps;
+        /** next state if the next encoded symbol is the LPS */
+        struct opj_mqc_state *nlps;
+} opj_mqc_state_t;
+
+#define MQC_NUMCTXS 32
+
+/**
+MQ coder
+*/
+typedef struct opj_mqc {
+        unsigned int c;
+        unsigned int a;
+        unsigned int ct;
+        unsigned char *bp;
+        unsigned char *start;
+        unsigned char *end;
+        opj_mqc_state_t *ctxs[MQC_NUMCTXS];
+        opj_mqc_state_t **curctx;
+} opj_mqc_t;
+
+/** @name Exported functions */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+/**
+Create a new MQC handle 
+@return Returns a new MQC handle if successful, returns NULL otherwise
+*/
+opj_mqc_t* mqc_create();
+/**
+Destroy a previously created MQC handle
+@param mqc MQC handle to destroy
+*/
+void mqc_destroy(opj_mqc_t *mqc);
+/**
+Return the number of bytes written/read since initialisation
+@param mqc MQC handle
+@return Returns the number of bytes already encoded
+*/
+int mqc_numbytes(opj_mqc_t *mqc);
+/**
+Reset the states of all the context of the coder/decoder 
+(each context is set to a state where 0 and 1 are more or less equiprobable)
+@param mqc MQC handle
+*/
+void mqc_resetstates(opj_mqc_t *mqc);
+/**
+Set the state of a particular context
+@param mqc MQC handle
+@param ctxno Number that identifies the context
+@param msb The MSB of the new state of the context
+@param prob Number that identifies the probability of the symbols for the new state of the context
+*/
+void mqc_setstate(opj_mqc_t *mqc, int ctxno, int msb, int prob);
+/**
+Initialize the encoder
+@param mqc MQC handle
+@param bp Pointer to the start of the buffer where the bytes will be written
+*/
+void mqc_init_enc(opj_mqc_t *mqc, unsigned char *bp);
+/**
+Set the current context used for coding/decoding
+@param mqc MQC handle
+@param ctxno Number that identifies the context
+*/
+void mqc_setcurctx(opj_mqc_t *mqc, int ctxno);
+/**
+Encode a symbol using the MQ-coder
+@param mqc MQC handle
+@param d The symbol to be encoded (0 or 1)
+*/
+void mqc_encode(opj_mqc_t *mqc, int d);
+/**
+Flush the encoder, so that all remaining data is written
+@param mqc MQC handle
+*/
+void mqc_flush(opj_mqc_t *mqc);
+/**
+BYPASS mode switch, initialization operation. 
+JPEG 2000 p 505. 
+<h2>Not fully implemented and tested !!</h2>
+@param mqc MQC handle
+*/
+void mqc_bypass_init_enc(opj_mqc_t *mqc);
+/**
+BYPASS mode switch, coding operation. 
+JPEG 2000 p 505. 
+<h2>Not fully implemented and tested !!</h2>
+@param mqc MQC handle
+@param d The symbol to be encoded (0 or 1)
+*/
+void mqc_bypass_enc(opj_mqc_t *mqc, int d);
+/**
+BYPASS mode switch, flush operation
+<h2>Not fully implemented and tested !!</h2>
+@param mqc MQC handle
+@return Returns 1 (always)
+*/
+int mqc_bypass_flush_enc(opj_mqc_t *mqc);
+/**
+RESET mode switch
+@param mqc MQC handle
+*/
+void mqc_reset_enc(opj_mqc_t *mqc);
+/**
+RESTART mode switch (TERMALL)
+@param mqc MQC handle
+@return Returns 1 (always)
+*/
+int mqc_restart_enc(opj_mqc_t *mqc);
+/**
+RESTART mode switch (TERMALL) reinitialisation
+@param mqc MQC handle
+*/
+void mqc_restart_init_enc(opj_mqc_t *mqc);
+/**
+ERTERM mode switch (PTERM)
+@param mqc MQC handle
+*/
+void mqc_erterm_enc(opj_mqc_t *mqc);
+/**
+SEGMARK mode switch (SEGSYM)
+@param mqc MQC handle
+*/
+void mqc_segmark_enc(opj_mqc_t *mqc);
+/**
+Initialize the decoder
+@param mqc MQC handle
+@param bp Pointer to the start of the buffer from which the bytes will be read
+@param len Length of the input buffer
+*/
+void mqc_init_dec(opj_mqc_t *mqc, unsigned char *bp, int len);
+/**
+Decode a symbol
+@param mqc MQC handle
+@return Returns the decoded symbol (0 or 1)
+*/
+int mqc_decode(opj_mqc_t *mqc);
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __MQC_H */
diff --git a/libraries/openjpeg-libsl/libopenjpeg/openjpeg.c b/libraries/openjpeg-libsl/libopenjpeg/openjpeg.c
new file mode 100644
index 0000000..6f12ff0
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/openjpeg.c
@@ -0,0 +1,307 @@
+/*
+ * Copyright (c) 2005, Hervé Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifdef WIN32
+#include <windows.h>
+#endif /* WIN32 */
+
+#include "opj_includes.h"
+
+/* ---------------------------------------------------------------------- */
+#ifdef WIN32
+#ifndef OPJ_STATIC
+BOOL APIENTRY
+DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
+        switch (ul_reason_for_call) {
+                case DLL_PROCESS_ATTACH :
+                        break;
+                case DLL_PROCESS_DETACH :
+                        break;
+                case DLL_THREAD_ATTACH :
+                case DLL_THREAD_DETACH :
+                        break;
+    }
+
+    return TRUE;
+}
+#endif /* OPJ_STATIC */
+#endif /* WIN32 */
+
+/* ---------------------------------------------------------------------- */
+
+
+const char* OPJ_CALLCONV opj_version() {
+    return OPENJPEG_VERSION;
+}
+
+opj_dinfo_t* OPJ_CALLCONV opj_create_decompress(OPJ_CODEC_FORMAT format) {
+        opj_dinfo_t *dinfo = (opj_dinfo_t*)opj_malloc(sizeof(opj_dinfo_t));
+        if(!dinfo) return NULL;
+        dinfo->is_decompressor = true;
+        switch(format) {
+                case CODEC_J2K:
+                case CODEC_JPT:
+                        /* get a J2K decoder handle */
+                        dinfo->j2k_handle = (void*)j2k_create_decompress((opj_common_ptr)dinfo);
+                        if(!dinfo->j2k_handle) {
+                                opj_free(dinfo);
+                                return NULL;
+                        }
+                        break;
+                case CODEC_JP2:
+                        /* get a JP2 decoder handle */
+                        dinfo->jp2_handle = (void*)jp2_create_decompress((opj_common_ptr)dinfo);
+                        if(!dinfo->jp2_handle) {
+                                opj_free(dinfo);
+                                return NULL;
+                        }
+                        break;
+                case CODEC_UNKNOWN:
+                default:
+                        opj_free(dinfo);
+                        return NULL;
+        }
+
+        dinfo->codec_format = format;
+
+        return dinfo;
+}
+
+void OPJ_CALLCONV opj_destroy_decompress(opj_dinfo_t *dinfo) {
+        if(dinfo) {
+                /* destroy the codec */
+                switch(dinfo->codec_format) {
+                        case CODEC_J2K:
+                        case CODEC_JPT:
+                                j2k_destroy_decompress((opj_j2k_t*)dinfo->j2k_handle);
+                                break;
+                        case CODEC_JP2:
+                                jp2_destroy_decompress((opj_jp2_t*)dinfo->jp2_handle);
+                                break;
+                        case CODEC_UNKNOWN:
+                        default:
+                                break;
+                }
+                /* destroy the decompressor */
+                opj_free(dinfo);
+        }
+}
+
+void OPJ_CALLCONV opj_set_default_decoder_parameters(opj_dparameters_t *parameters) {
+        if(parameters) {
+                memset(parameters, 0, sizeof(opj_dparameters_t));
+                /* default decoding parameters */
+                parameters->cp_layer = 0;
+                parameters->cp_reduce = 0;
+                parameters->cp_limit_decoding = NO_LIMITATION;
+
+                parameters->decod_format = -1;
+                parameters->cod_format = -1;
+/* UniPG>> */
+#ifdef USE_JPWL
+                parameters->jpwl_correct = false;
+                parameters->jpwl_exp_comps = JPWL_EXPECTED_COMPONENTS;
+                parameters->jpwl_max_tiles = JPWL_MAXIMUM_TILES;
+#endif /* USE_JPWL */
+/* <<UniPG */
+        }
+}
+
+void OPJ_CALLCONV opj_setup_decoder(opj_dinfo_t *dinfo, opj_dparameters_t *parameters) {
+        if(dinfo && parameters) {
+                switch(dinfo->codec_format) {
+                        case CODEC_J2K:
+                        case CODEC_JPT:
+                                j2k_setup_decoder((opj_j2k_t*)dinfo->j2k_handle, parameters);
+                                break;
+                        case CODEC_JP2:
+                                jp2_setup_decoder((opj_jp2_t*)dinfo->jp2_handle, parameters);
+                                break;
+                        case CODEC_UNKNOWN:
+                        default:
+                                break;
+                }
+        }
+}
+
+opj_image_t* OPJ_CALLCONV opj_decode(opj_dinfo_t *dinfo, opj_cio_t *cio) {
+        if(dinfo && cio) {
+                switch(dinfo->codec_format) {
+                        case CODEC_J2K:
+                                return j2k_decode((opj_j2k_t*)dinfo->j2k_handle, cio);
+                        case CODEC_JPT:
+                                return j2k_decode_jpt_stream((opj_j2k_t*)dinfo->j2k_handle, cio);
+                        case CODEC_JP2:
+                                return jp2_decode((opj_jp2_t*)dinfo->jp2_handle, cio);
+                        case CODEC_UNKNOWN:
+                        default:
+                                break;
+                }
+        }
+
+        return NULL;
+}
+
+opj_cinfo_t* OPJ_CALLCONV opj_create_compress(OPJ_CODEC_FORMAT format) {
+        opj_cinfo_t *cinfo = (opj_cinfo_t*)opj_malloc(sizeof(opj_cinfo_t));
+        if(!cinfo) return NULL;
+        cinfo->is_decompressor = false;
+        switch(format) {
+                case CODEC_J2K:
+                        /* get a J2K coder handle */
+                        cinfo->j2k_handle = (void*)j2k_create_compress((opj_common_ptr)cinfo);
+                        if(!cinfo->j2k_handle) {
+                                opj_free(cinfo);
+                                return NULL;
+                        }
+                        break;
+                case CODEC_JP2:
+                        /* get a JP2 coder handle */
+                        cinfo->jp2_handle = (void*)jp2_create_compress((opj_common_ptr)cinfo);
+                        if(!cinfo->jp2_handle) {
+                                opj_free(cinfo);
+                                return NULL;
+                        }
+                        break;
+                case CODEC_JPT:
+                case CODEC_UNKNOWN:
+                default:
+                        opj_free(cinfo);
+                        return NULL;
+        }
+
+        cinfo->codec_format = format;
+
+        return cinfo;
+}
+
+void OPJ_CALLCONV opj_destroy_compress(opj_cinfo_t *cinfo) {
+        if(cinfo) {
+                /* destroy the codec */
+                switch(cinfo->codec_format) {
+                        case CODEC_J2K:
+                                j2k_destroy_decompress((opj_j2k_t*)cinfo->j2k_handle);
+                                break;
+                        case CODEC_JP2:
+                                jp2_destroy_decompress((opj_jp2_t*)cinfo->jp2_handle);
+                                break;
+                        case CODEC_JPT:
+                        case CODEC_UNKNOWN:
+                        default:
+                                break;
+                }
+                /* destroy the decompressor */
+                opj_free(cinfo);
+        }
+}
+
+void OPJ_CALLCONV opj_set_default_encoder_parameters(opj_cparameters_t *parameters) {
+        if(parameters) {
+                memset(parameters, 0, sizeof(opj_cparameters_t));
+                /* default coding parameters */
+                parameters->cp_cinema = OFF; 
+                parameters->max_comp_size = 0;
+                parameters->numresolution = 6;
+                parameters->cp_rsiz = STD_RSIZ;
+                parameters->cblockw_init = 64;
+                parameters->cblockh_init = 64;
+                parameters->prog_order = LRCP;
+                parameters->roi_compno = -1;            /* no ROI */
+                parameters->subsampling_dx = 1;
+                parameters->subsampling_dy = 1;
+                parameters->tp_on = 0;
+                parameters->decod_format = -1;
+                parameters->cod_format = -1;
+/* UniPG>> */
+#ifdef USE_JPWL
+                parameters->jpwl_epc_on = false;
+                parameters->jpwl_hprot_MH = -1; /* -1 means unassigned */
+                {
+                        int i;
+                        for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {
+                                parameters->jpwl_hprot_TPH_tileno[i] = -1; /* unassigned */
+                                parameters->jpwl_hprot_TPH[i] = 0; /* absent */
+                        }
+                };
+                {
+                        int i;
+                        for (i = 0; i < JPWL_MAX_NO_PACKSPECS; i++) {
+                                parameters->jpwl_pprot_tileno[i] = -1; /* unassigned */
+                                parameters->jpwl_pprot_packno[i] = -1; /* unassigned */
+                                parameters->jpwl_pprot[i] = 0; /* absent */
+                        }
+                };
+                parameters->jpwl_sens_size = 0; /* 0 means no ESD */
+                parameters->jpwl_sens_addr = 0; /* 0 means auto */
+                parameters->jpwl_sens_range = 0; /* 0 means packet */
+                parameters->jpwl_sens_MH = -1; /* -1 means unassigned */
+                {
+                        int i;
+                        for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {
+                                parameters->jpwl_sens_TPH_tileno[i] = -1; /* unassigned */
+                                parameters->jpwl_sens_TPH[i] = -1; /* absent */
+                        }
+                };
+#endif /* USE_JPWL */
+/* <<UniPG */
+        }
+}
+
+void OPJ_CALLCONV opj_setup_encoder(opj_cinfo_t *cinfo, opj_cparameters_t *parameters, opj_image_t *image) {
+        if(cinfo && parameters && image) {
+                switch(cinfo->codec_format) {
+                        case CODEC_J2K:
+                                j2k_setup_encoder((opj_j2k_t*)cinfo->j2k_handle, parameters, image);
+                                break;
+                        case CODEC_JP2:
+                                jp2_setup_encoder((opj_jp2_t*)cinfo->jp2_handle, parameters, image);
+                                break;
+                        case CODEC_JPT:
+                        case CODEC_UNKNOWN:
+                        default:
+                                break;
+                }
+        }
+}
+
+bool OPJ_CALLCONV opj_encode(opj_cinfo_t *cinfo, opj_cio_t *cio, opj_image_t *image, char *index) {
+        if(cinfo && cio && image) {
+                switch(cinfo->codec_format) {
+                        case CODEC_J2K:
+                                return j2k_encode((opj_j2k_t*)cinfo->j2k_handle, cio, image, index);
+                        case CODEC_JP2:
+                                return jp2_encode((opj_jp2_t*)cinfo->jp2_handle, cio, image, index);
+                        case CODEC_JPT:
+                        case CODEC_UNKNOWN:
+                        default:
+                                break;
+                }
+        }
+
+        return false;
+}
+
+
diff --git a/libraries/openjpeg-libsl/libopenjpeg/openjpeg.h b/libraries/openjpeg-libsl/libopenjpeg/openjpeg.h
new file mode 100644
index 0000000..e74c90e
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/openjpeg.h
@@ -0,0 +1,751 @@
+ /*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * Copyright (c) 2006-2007, Parvatha Elangovan
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef OPENJPEG_H
+#define OPENJPEG_H
+
+#define OPENJPEG_VERSION "1.2.0"
+
+/* 
+==========================================================
+   Compiler directives
+==========================================================
+*/
+
+#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 */
+
+/* 
+==========================================================
+   Useful constant definitions
+==========================================================
+*/
+
+#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 */
+
+/* UniPG>> */
+#define JPWL_MAX_NO_TILESPECS   16 /**< Maximum number of tile parts expected by JPWL: increase at your will */
+#define JPWL_MAX_NO_PACKSPECS   16 /**< Maximum number of packet parts expected by JPWL: increase at your will */
+#define JPWL_MAX_NO_MARKERS     512 /**< Maximum number of JPWL markers: increase at your will */
+#define JPWL_PRIVATEINDEX_NAME "jpwl_index_privatefilename" /**< index file name used when JPWL is on */
+#define JPWL_EXPECTED_COMPONENTS 3 /**< Expect this number of components, so you'll find better the first EPB */
+#define JPWL_MAXIMUM_TILES 8192 /**< Expect this maximum number of tiles, to avoid some crashes */
+#define JPWL_MAXIMUM_HAMMING 2 /**< Expect this maximum number of bit errors in marker id's */
+/* <<UniPG */
+
+/* 
+==========================================================
+   enum definitions
+==========================================================
+*/
+/** 
+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*/
+} OPJ_RSIZ_CAPABILITIES;
+
+/** 
+Digital cinema operation mode 
+*/
+typedef enum CINEMA_MODE {
+        OFF = 0,                                        /** Not Digital Cinema*/
+        CINEMA2K_24 = 1,        /** 2K Digital Cinema at 24 fps*/
+        CINEMA2K_48 = 2,        /** 2K Digital Cinema at 48 fps*/
+        CINEMA4K_24 = 3         /** 4K Digital Cinema at 24 fps*/
+}OPJ_CINEMA_MODE;
+
+/** 
+Progression order 
+*/
+typedef enum PROG_ORDER {
+        PROG_UNKNOWN = -1,      /**< place-holder */
+        LRCP = 0,               /**< layer-resolution-component-precinct order */
+        RLCP = 1,               /**< resolution-layer-component-precinct order */
+        RPCL = 2,               /**< resolution-precinct-component-layer order */
+        PCRL = 3,               /**< precinct-component-resolution-layer order */
+        CPRL = 4                /**< component-precinct-resolution-layer order */
+} OPJ_PROG_ORDER;
+
+/**
+Supported image color spaces
+*/
+typedef enum COLOR_SPACE {
+        CLRSPC_UNKNOWN = -1,    /**< place-holder */
+        CLRSPC_SRGB = 1,                /**< sRGB */
+        CLRSPC_GRAY = 2,                /**< grayscale */
+        CLRSPC_SYCC = 3                 /**< YUV */
+} OPJ_COLOR_SPACE;
+
+/**
+Supported codec
+*/
+typedef enum CODEC_FORMAT {
+        CODEC_UNKNOWN = -1,     /**< place-holder */
+        CODEC_J2K = 0,          /**< JPEG-2000 codestream : read/write */
+        CODEC_JPT = 1,          /**< JPT-stream (JPEG 2000, JPIP) : read only */
+        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;
+
+/* 
+==========================================================
+   event manager typedef definitions
+==========================================================
+*/
+
+/**
+Callback function prototype for events
+@param msg Event message
+@param client_data 
+*/
+typedef void (*opj_msg_callback) (const 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;
+
+
+/* 
+==========================================================
+   codec typedef definitions
+==========================================================
+*/
+
+/**
+Progression order changes
+*/
+typedef struct opj_poc {
+        /** Resolution num start, Component num start, given by POC */
+        int resno0, compno0;
+        /** Layer num end,Resolution num end, Component num end, given by POC */
+        int layno1, resno1, compno1;
+        /** Layer num start,Precinct num start, Precinct num end */
+        int layno0, precno0, precno1;
+        /** Progression order enum*/
+        OPJ_PROG_ORDER prg1,prg;
+        /** Progression order string*/
+        char progorder[5];
+        /** Tile number */
+        int tile;
+        /** Start and end values for Tile width and height*/
+        int tx0,tx1,ty0,ty1;
+        /** Start value, initialised in pi_initialise_encode*/
+        int layS, resS, compS, prcS;
+        /** End value, initialised in pi_initialise_encode */
+        int 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;
+        /** Temporary values for Tile parts, initialised in pi_create_encode */
+        int lay_t, res_t, comp_t, prc_t,tx0_t,ty0_t;
+} opj_poc_t;
+
+/**
+Compression parameters
+*/
+typedef struct opj_cparameters {
+        /** size of tile: tile_size_on = false (not in argument) or = true (in argument) */
+        bool tile_size_on;
+        /** XTOsiz */
+        int cp_tx0;
+        /** YTOsiz */
+        int cp_ty0;
+        /** XTsiz */
+        int cp_tdx;
+        /** YTsiz */
+        int cp_tdy;
+        /** allocation by rate/distortion */
+        int cp_disto_alloc;
+        /** allocation by fixed layer */
+        int cp_fixed_alloc;
+        /** add fixed_quality */
+        int cp_fixed_quality;
+        /** fixed layer */
+        int *cp_matrice;
+        /** comment for coding */
+        char *cp_comment;
+        /** csty : coding style */
+        int csty;
+        /** progression order (default LRCP) */
+        OPJ_PROG_ORDER prog_order;
+        /** progression order changes */
+        opj_poc_t POC[32];
+        /** number of progression order changes (POC), default to 0 */
+        int numpocs;
+        /** number of layers */
+        int tcp_numlayers;
+        /** rates of layers */
+        float tcp_rates[100];
+        /** different psnr for successive layers */
+        float tcp_distoratio[100];
+        /** number of resolutions */
+        int numresolution;
+        /** initial code block width, default to 64 */
+        int cblockw_init;
+        /** initial code block height, default to 64 */
+        int cblockh_init;
+        /** mode switch (cblk_style) */
+        int mode;
+        /** 1 : use the irreversible DWT 9-7, 0 : use lossless compression (default) */
+        int irreversible;
+        /** region of interest: affected component in [0..3], -1 means no ROI */
+        int roi_compno;
+        /** region of interest: upshift value */
+        int roi_shift;
+        /* number of precinct size specifications */
+        int res_spec;
+        /** initial precinct width */
+        int prcw_init[J2K_MAXRLVLS];
+        /** initial precinct height */
+        int prch_init[J2K_MAXRLVLS];
+
+        /**@name command line encoder parameters (not used inside the library) */
+        /*@{*/
+        /** input file name */
+        char infile[OPJ_PATH_LEN];
+        /** output file name */
+        char outfile[OPJ_PATH_LEN];
+        /** creation of an index file, default to 0 (false) */
+        int index_on;
+        /** index file name */
+        char index[OPJ_PATH_LEN];
+        /** subimage encoding: origin image offset in x direction */
+        int image_offset_x0;
+        /** subimage encoding: origin image offset in y direction */
+        int image_offset_y0;
+        /** subsampling value for dx */
+        int subsampling_dx;
+        /** subsampling value for dy */
+        int subsampling_dy;
+        /** input file format 0: PGX, 1: PxM, 2: BMP 3:TIF*/
+        int decod_format;
+        /** output file format 0: J2K, 1: JP2, 2: JPT */
+        int cod_format;
+        /*@}*/
+
+/* UniPG>> */
+        /**@name JPWL encoding parameters */
+        /*@{*/
+        /** enables writing of EPC in MH, thus activating JPWL */
+        bool jpwl_epc_on;
+        /** error protection method for MH (0,1,16,32,37-128) */
+        int jpwl_hprot_MH;
+        /** tile number of header protection specification (>=0) */
+        int jpwl_hprot_TPH_tileno[JPWL_MAX_NO_TILESPECS];
+        /** error protection methods for TPHs (0,1,16,32,37-128) */
+        int jpwl_hprot_TPH[JPWL_MAX_NO_TILESPECS];
+        /** tile number of packet protection specification (>=0) */
+        int jpwl_pprot_tileno[JPWL_MAX_NO_PACKSPECS];
+        /** packet number of packet protection specification (>=0) */
+        int jpwl_pprot_packno[JPWL_MAX_NO_PACKSPECS];
+        /** error protection methods for packets (0,1,16,32,37-128) */
+        int jpwl_pprot[JPWL_MAX_NO_PACKSPECS];
+        /** enables writing of ESD, (0=no/1/2 bytes) */
+        int jpwl_sens_size;
+        /** sensitivity addressing size (0=auto/2/4 bytes) */
+        int jpwl_sens_addr;
+        /** sensitivity range (0-3) */
+        int jpwl_sens_range;
+        /** sensitivity method for MH (-1=no,0-7) */
+        int jpwl_sens_MH;
+        /** tile number of sensitivity specification (>=0) */
+        int jpwl_sens_TPH_tileno[JPWL_MAX_NO_TILESPECS];
+        /** sensitivity methods for TPHs (-1=no,0-7) */
+        int jpwl_sens_TPH[JPWL_MAX_NO_TILESPECS];
+        /*@}*/
+/* <<UniPG */
+
+        /** Digital Cinema compliance 0-not compliant, 1-compliant*/
+        OPJ_CINEMA_MODE cp_cinema;
+        /** Maximum rate for each component. If == 0, component size limitation is not considered */
+        int max_comp_size;
+        /** Profile name*/
+        OPJ_RSIZ_CAPABILITIES cp_rsiz;
+        /** Tile part generation*/
+        char tp_on;
+        /** Flag for Tile part generation*/
+        char tp_flag;
+        /** MCT (multiple component transform) */
+        char tcp_mct;
+} opj_cparameters_t;
+
+/**
+Decompression parameters
+*/
+typedef struct opj_dparameters {
+        /** 
+        Set the number of highest resolution levels to be discarded. 
+        The image resolution is effectively divided by 2 to the power of the number of discarded levels. 
+        The reduce factor is limited by the smallest total number of decomposition levels among tiles.
+        if != 0, then original dimension divided by 2^(reduce); 
+        if == 0 or not used, image is decoded to the full resolution 
+        */
+        int cp_reduce;
+        /** 
+        Set the maximum number of quality layers to decode. 
+        If there are less quality layers than the specified number, all the quality layers are decoded.
+        if != 0, then only the first "layer" layers are decoded; 
+        if == 0 or not used, all the quality layers are decoded 
+        */
+        int cp_layer;
+
+        /**@name command line encoder parameters (not used inside the library) */
+        /*@{*/
+        /** input file name */
+        char infile[OPJ_PATH_LEN];
+        /** output file name */
+        char outfile[OPJ_PATH_LEN];
+        /** input file format 0: J2K, 1: JP2, 2: JPT */
+        int decod_format;
+        /** output file format 0: PGX, 1: PxM, 2: BMP */
+        int cod_format;
+        /*@}*/
+
+/* UniPG>> */
+        /**@name JPWL decoding parameters */
+        /*@{*/
+        /** activates the JPWL correction capabilities */
+        bool jpwl_correct;
+        /** expected number of components */
+        int jpwl_exp_comps;
+        /** maximum number of tiles */
+        int jpwl_max_tiles;
+        /*@}*/
+/* <<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;
+
+/**
+Decompression context info
+*/
+typedef struct opj_dinfo {
+        /** Fields shared with opj_cinfo_t */
+        opj_common_fields;      
+        /* other specific fields go here */
+} opj_dinfo_t;
+
+/* 
+==========================================================
+   I/O stream typedef definitions
+==========================================================
+*/
+
+/*
+ * Stream open flags.
+ */
+/** The stream was opened for reading. */
+#define OPJ_STREAM_READ 0x0001
+/** 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;
+
+        /** 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;
+
+/* 
+==========================================================
+   image typedef definitions
+==========================================================
+*/
+
+/**
+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;
+        /** YRsiz: vertical separation of a sample of ith component with respect to the reference grid */
+        int dy;
+        /** data width */
+        int w;
+        /** data height */
+        int h;
+        /** x component offset compared to the whole image */
+        int x0;
+        /** y component offset compared to the whole image */
+        int y0;
+        /** precision */
+        int prec;
+        /** image depth in bits */
+        int bpp;
+        /** signed (1) / unsigned (0) */
+        int sgnd;
+        /** number of decoded resolution */
+        int resno_decoded;
+        /** number of division by 2 of the out image compared to the original size of image */
+        int factor;
+        /** image component data */
+        int *data;
+} opj_image_comp_t;
+
+/** 
+Defines image data and characteristics
+*/
+typedef struct opj_image {
+        /** XOsiz: horizontal offset from the origin of the reference grid to the left side of the image area */
+        int x0;
+        /** YOsiz: vertical offset from the origin of the reference grid to the top side of the image area */
+        int y0;
+        /** Xsiz: width of the reference grid */
+        int x1;
+        /** Ysiz: height of the reference grid */
+        int y1;
+        /** number of components in the image */
+        int numcomps;
+        /** color space: sRGB, Greyscale or YUV */
+        OPJ_COLOR_SPACE color_space;
+        /** image components */
+        opj_image_comp_t *comps;
+} opj_image_t;
+
+/**
+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;
+        /** YRsiz: vertical separation of a sample of ith component with respect to the reference grid */
+        int dy;
+        /** data width */
+        int w;
+        /** data height */
+        int h;
+        /** x component offset compared to the whole image */
+        int x0;
+        /** y component offset compared to the whole image */
+        int y0;
+        /** precision */
+        int prec;
+        /** image depth in bits */
+        int bpp;
+        /** signed (1) / unsigned (0) */
+        int sgnd;
+} opj_image_cmptparm_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* 
+==========================================================
+   openjpeg version
+==========================================================
+*/
+
+OPJ_API const char * OPJ_CALLCONV opj_version();
+
+/* 
+==========================================================
+   image functions definitions
+==========================================================
+*/
+
+/**
+Create an image
+@param numcmpts number of components
+@param cmptparms components parameters
+@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);
+
+/**
+Deallocate any resources associated with an image
+@param image image to be destroyed
+*/
+OPJ_API void OPJ_CALLCONV opj_image_destroy(opj_image_t *image);
+
+/* 
+==========================================================
+   stream functions definitions
+==========================================================
+*/
+
+/**
+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
+*/
+OPJ_API opj_cio_t* OPJ_CALLCONV opj_cio_open(opj_common_ptr cinfo, unsigned char *buffer, int length);
+
+/**
+Close and free a CIO handle
+@param cio CIO handle to free
+*/
+OPJ_API void OPJ_CALLCONV opj_cio_close(opj_cio_t *cio);
+
+/**
+Get position in byte stream
+@param cio CIO handle
+@return Returns the position in bytes
+*/
+OPJ_API int OPJ_CALLCONV cio_tell(opj_cio_t *cio);
+/**
+Set position in byte stream
+@param cio CIO handle
+@param pos Position, in number of bytes, from the beginning of the stream
+*/
+OPJ_API void OPJ_CALLCONV cio_seek(opj_cio_t *cio, int pos);
+
+/* 
+==========================================================
+   event manager functions definitions
+==========================================================
+*/
+
+OPJ_API opj_event_mgr_t* OPJ_CALLCONV opj_set_event_mgr(opj_common_ptr cinfo, opj_event_mgr_t *event_mgr, void *context);
+
+/* 
+==========================================================
+   codec functions definitions
+==========================================================
+*/
+/**
+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);
+/**
+Set decoding parameters to default values
+@param parameters Decompression parameters
+*/
+OPJ_API void OPJ_CALLCONV opj_set_default_decoder_parameters(opj_dparameters_t *parameters);
+/**
+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);
+/**
+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);
+/**
+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);
+/**
+Destroy a compressor handle
+@param cinfo compressor handle to destroy
+*/
+OPJ_API void OPJ_CALLCONV opj_destroy_compress(opj_cinfo_t *cinfo);
+/**
+Set encoding parameters to default values, that means : 
+<ul>
+<li>Lossless
+<li>1 tile
+<li>Size of precinct : 2^15 x 2^15 (means 1 precinct)
+<li>Size of code-block : 64 x 64
+<li>Number of resolutions: 6
+<li>No SOP marker in the codestream
+<li>No EPH marker in the codestream
+<li>No sub-sampling in x or y direction
+<li>No mode switch activated
+<li>Progression order: LRCP
+<li>No index file
+<li>No ROI upshifted
+<li>No offset of the origin of the image
+<li>No offset of the origin of the tiles
+<li>Reversible DWT 5-3
+</ul>
+@param parameters Compression parameters
+*/
+OPJ_API void OPJ_CALLCONV opj_set_default_encoder_parameters(opj_cparameters_t *parameters);
+/**
+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);
+/**
+Encode an image into a JPEG-2000 codestream
+@param cinfo compressor handle
+@param cio Output buffer stream
+@param image Image to encode
+@param index Name of the index file if required, NULL otherwise
+@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);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* OPENJPEG_H */
diff --git a/libraries/openjpeg-libsl/libopenjpeg/opj_includes.h b/libraries/openjpeg-libsl/libopenjpeg/opj_includes.h
new file mode 100644
index 0000000..72152a5
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/opj_includes.h
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2005, Hervé Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef OPJ_INCLUDES_H
+#define OPJ_INCLUDES_H
+
+/*
+ ==========================================================
+   Standard includes used by the library
+ ==========================================================
+*/
+#include <memory.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <float.h>
+#include <time.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <ctype.h>
+
+/*
+ ==========================================================
+   OpenJPEG interface
+ ==========================================================
+ */
+#include "openjpeg.h"
+
+/*
+ ==========================================================
+   OpenJPEG modules
+ ==========================================================
+*/
+
+/*
+The inline keyword is supported by C99 but not by C90. 
+Most compilers implement their own version of this keyword ... 
+*/
+#ifndef INLINE
+        #if defined(_MSC_VER)
+                #define INLINE __inline
+        #elif defined(__GNUC__)
+                #define INLINE __inline__
+        #elif defined(__MWERKS__)
+                #define INLINE inline
+        #else 
+                /* add other compilers here ... */
+                #define INLINE 
+        #endif /* defined(<Compiler>) */
+#endif /* INLINE */
+
+#include "j2k_lib.h"
+#include "event.h"
+#include "cio.h"
+
+#include "image.h"
+#include "j2k.h"
+#include "jp2.h"
+#include "jpt.h"
+
+#include "mqc.h"
+#include "raw.h"
+#include "bio.h"
+#include "tgt.h"
+#include "pi.h"
+#include "tcd.h"
+#include "t1.h"
+#include "dwt.h"
+#include "t2.h"
+#include "mct.h"
+#include "int.h"
+#include "fix.h"
+
+/* JPWL>> */
+#ifdef USE_JPWL
+#include "../jpwl/jpwl.h"
+#endif /* USE_JPWL */
+/* <<JPWL */
+
+#endif /* OPJ_INCLUDES_H */
diff --git a/libraries/openjpeg-libsl/libopenjpeg/pi.c b/libraries/openjpeg-libsl/libopenjpeg/pi.c
new file mode 100644
index 0000000..a012f51
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/pi.c
@@ -0,0 +1,1078 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * Copyright (c) 2006-2007, Parvatha Elangovan
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "opj_includes.h"
+
+/** @defgroup PI PI - Implementation of a packet iterator */
+/*@{*/
+
+/** @name Local static functions */
+/*@{*/
+
+/**
+Get next packet in layer-resolution-component-precinct order.
+@param pi packet iterator to modify
+@return returns false if pi pointed to the last packet or else returns true 
+*/
+static bool pi_next_lrcp(opj_pi_iterator_t * pi);
+/**
+Get next packet in resolution-layer-component-precinct order.
+@param pi packet iterator to modify
+@return returns false if pi pointed to the last packet or else returns true 
+*/
+static bool pi_next_rlcp(opj_pi_iterator_t * pi);
+/**
+Get next packet in resolution-precinct-component-layer order.
+@param pi packet iterator to modify
+@return returns false if pi pointed to the last packet or else returns true 
+*/
+static bool pi_next_rpcl(opj_pi_iterator_t * pi);
+/**
+Get next packet in precinct-component-resolution-layer order.
+@param pi packet iterator to modify
+@return returns false if pi pointed to the last packet or else returns true 
+*/
+static bool pi_next_pcrl(opj_pi_iterator_t * pi);
+/**
+Get next packet in component-precinct-resolution-layer order.
+@param pi packet iterator to modify
+@return returns false if pi pointed to the last packet or else returns true 
+*/
+static bool pi_next_cprl(opj_pi_iterator_t * pi);
+
+/*@}*/
+
+/*@}*/
+
+/* 
+==========================================================
+   local functions
+==========================================================
+*/
+
+static bool pi_next_lrcp(opj_pi_iterator_t * pi) {
+        opj_pi_comp_t *comp = NULL;
+        opj_pi_resolution_t *res = NULL;
+        long index = 0;
+        
+        if (!pi->first) {
+                comp = &pi->comps[pi->compno];
+                res = &comp->resolutions[pi->resno];
+                goto LABEL_SKIP;
+        } else {
+                pi->first = 0;
+        }
+
+        for (pi->layno = pi->poc.layno0; pi->layno < pi->poc.layno1; pi->layno++) {
+                for (pi->resno = pi->poc.resno0; pi->resno < pi->poc.resno1;
+                pi->resno++) {
+                        for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1; pi->compno++) {
+                                comp = &pi->comps[pi->compno];
+                                if (pi->resno >= comp->numresolutions) {
+                                        continue;
+                                }
+                                res = &comp->resolutions[pi->resno];
+                                if (!pi->tp_on){
+                                        pi->poc.precno1 = res->pw * res->ph;
+                                }
+                                for (pi->precno = pi->poc.precno0; pi->precno < pi->poc.precno1; pi->precno++) {
+                                        index = pi->layno * pi->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p;
+                                        if (!pi->include[index]) {
+                                                pi->include[index] = 1;
+                                                return true;
+                                        }
+LABEL_SKIP:;
+                                }
+                        }
+                }
+        }
+        
+        return false;
+}
+
+static bool pi_next_rlcp(opj_pi_iterator_t * pi) {
+        opj_pi_comp_t *comp = NULL;
+        opj_pi_resolution_t *res = NULL;
+        long index = 0;
+
+        if (!pi->first) {
+                comp = &pi->comps[pi->compno];
+                res = &comp->resolutions[pi->resno];
+                goto LABEL_SKIP;
+        } else {
+                pi->first = 0;
+        }
+
+        for (pi->resno = pi->poc.resno0; pi->resno < pi->poc.resno1; pi->resno++) {
+                for (pi->layno = pi->poc.layno0; pi->layno < pi->poc.layno1; pi->layno++) {
+                        for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1; pi->compno++) {
+                                comp = &pi->comps[pi->compno];
+                                if (pi->resno >= comp->numresolutions) {
+                                        continue;
+                                }
+                                res = &comp->resolutions[pi->resno];
+                                if(!pi->tp_on){
+                                        pi->poc.precno1 = res->pw * res->ph;
+                                }
+                                for (pi->precno = pi->poc.precno0; pi->precno < pi->poc.precno1; pi->precno++) {
+                                        index = pi->layno * pi->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p;
+                                        if (!pi->include[index]) {
+                                                pi->include[index] = 1;
+                                                return true;
+                                        }
+LABEL_SKIP:;
+                                }
+                        }
+                }
+        }
+        
+        return false;
+}
+
+static bool pi_next_rpcl(opj_pi_iterator_t * pi) {
+        opj_pi_comp_t *comp = NULL;
+        opj_pi_resolution_t *res = NULL;
+        long index = 0;
+
+        if (!pi->first) {
+                goto LABEL_SKIP;
+        } else {
+                int compno, resno;
+                pi->first = 0;
+                pi->dx = 0;
+                pi->dy = 0;
+                for (compno = 0; compno < pi->numcomps; compno++) {
+                        comp = &pi->comps[compno];
+                        for (resno = 0; resno < comp->numresolutions; resno++) {
+                                int dx, dy;
+                                res = &comp->resolutions[resno];
+                                dx = comp->dx * (1 << (res->pdx + comp->numresolutions - 1 - resno));
+                                dy = comp->dy * (1 << (res->pdy + comp->numresolutions - 1 - resno));
+                                pi->dx = !pi->dx ? dx : int_min(pi->dx, dx);
+                                pi->dy = !pi->dy ? dy : int_min(pi->dy, dy);
+                        }
+                }
+        }
+if (!pi->tp_on){
+                        pi->poc.ty0 = pi->ty0;
+                        pi->poc.tx0 = pi->tx0;
+                        pi->poc.ty1 = pi->ty1;
+                        pi->poc.tx1 = pi->tx1;
+                }
+        for (pi->resno = pi->poc.resno0; pi->resno < pi->poc.resno1; pi->resno++) {
+                for (pi->y = pi->poc.ty0; pi->y < pi->poc.ty1; pi->y += pi->dy - (pi->y % pi->dy)) {
+                        for (pi->x = pi->poc.tx0; pi->x < pi->poc.tx1; pi->x += pi->dx - (pi->x % pi->dx)) {
+                                for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1; pi->compno++) {
+                                        int levelno;
+                                        int trx0, try0;
+                                        int trx1, try1;
+                                        int rpx, rpy;
+                                        int prci, prcj;
+                                        comp = &pi->comps[pi->compno];
+                                        if (pi->resno >= comp->numresolutions) {
+                                                continue;
+                                        }
+                                        res = &comp->resolutions[pi->resno];
+                                        levelno = comp->numresolutions - 1 - pi->resno;
+                                        trx0 = int_ceildiv(pi->tx0, comp->dx << levelno);
+                                        try0 = int_ceildiv(pi->ty0, comp->dy << levelno);
+                                        trx1 = int_ceildiv(pi->tx1, comp->dx << levelno);
+                                        try1 = int_ceildiv(pi->ty1, comp->dy << levelno);
+                                        rpx = res->pdx + levelno;
+                                        rpy = res->pdy + levelno;
+                                        if (!((pi->y % (comp->dy << rpy) == 0) || ((pi->y == pi->ty0) && ((try0 << levelno) % (1 << rpx))))){
+                                                continue;       
+                                        }
+                                        if (!((pi->x % (comp->dx << rpx) == 0) || ((pi->x == pi->tx0) && ((trx0 << levelno) % (1 << rpx))))){
+                                                continue; 
+                                        }
+                                        
+                                        if ((res->pw==0)||(res->pw==0)) continue;
+                                        
+                                        if ((trx0==trx1)||(try0==try1)) continue;
+                                        
+                                        prci = int_floordivpow2(int_ceildiv(pi->x, comp->dx << levelno), res->pdx) 
+                                                 - int_floordivpow2(trx0, res->pdx);
+                                        prcj = int_floordivpow2(int_ceildiv(pi->y, comp->dy << levelno), res->pdy) 
+                                                 - int_floordivpow2(try0, res->pdy);
+                                        pi->precno = prci + prcj * res->pw;
+                                        for (pi->layno = pi->poc.layno0; pi->layno < pi->poc.layno1; pi->layno++) {
+                                                index = pi->layno * pi->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p;
+                                                if (!pi->include[index]) {
+                                                        pi->include[index] = 1;
+                                                        return true;
+                                                }
+LABEL_SKIP:;
+                                        }
+                                }
+                        }
+                }
+        }
+        
+        return false;
+}
+
+static bool pi_next_pcrl(opj_pi_iterator_t * pi) {
+        opj_pi_comp_t *comp = NULL;
+        opj_pi_resolution_t *res = NULL;
+        long index = 0;
+
+        if (!pi->first) {
+                comp = &pi->comps[pi->compno];
+                goto LABEL_SKIP;
+        } else {
+                int compno, resno;
+                pi->first = 0;
+                pi->dx = 0;
+                pi->dy = 0;
+                for (compno = 0; compno < pi->numcomps; compno++) {
+                        comp = &pi->comps[compno];
+                        for (resno = 0; resno < comp->numresolutions; resno++) {
+                                int dx, dy;
+                                res = &comp->resolutions[resno];
+                                dx = comp->dx * (1 << (res->pdx + comp->numresolutions - 1 - resno));
+                                dy = comp->dy * (1 << (res->pdy + comp->numresolutions - 1 - resno));
+                                pi->dx = !pi->dx ? dx : int_min(pi->dx, dx);
+                                pi->dy = !pi->dy ? dy : int_min(pi->dy, dy);
+                        }
+                }
+        }
+        if (!pi->tp_on){
+                        pi->poc.ty0 = pi->ty0;
+                        pi->poc.tx0 = pi->tx0;
+                        pi->poc.ty1 = pi->ty1;
+                        pi->poc.tx1 = pi->tx1;
+                }
+        for (pi->y = pi->poc.ty0; pi->y < pi->poc.ty1; pi->y += pi->dy - (pi->y % pi->dy)) {
+                for (pi->x = pi->poc.tx0; pi->x < pi->poc.tx1; pi->x += pi->dx - (pi->x % pi->dx)) {
+                        for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1; pi->compno++) {
+                                comp = &pi->comps[pi->compno];
+                                for (pi->resno = pi->poc.resno0; pi->resno < int_min(pi->poc.resno1, comp->numresolutions); pi->resno++) {
+                                        int levelno;
+                                        int trx0, try0;
+                                        int trx1, try1;
+                                        int rpx, rpy;
+                                        int prci, prcj;
+                                        res = &comp->resolutions[pi->resno];
+                                        levelno = comp->numresolutions - 1 - pi->resno;
+                                        trx0 = int_ceildiv(pi->tx0, comp->dx << levelno);
+                                        try0 = int_ceildiv(pi->ty0, comp->dy << levelno);
+                                        trx1 = int_ceildiv(pi->tx1, comp->dx << levelno);
+                                        try1 = int_ceildiv(pi->ty1, comp->dy << levelno);
+                                        rpx = res->pdx + levelno;
+                                        rpy = res->pdy + levelno;
+                                        if (!((pi->y % (comp->dy << rpy) == 0) || ((pi->y == pi->ty0) && ((try0 << levelno) % (1 << rpx))))){
+                                                continue;       
+                                        }
+                                        if (!((pi->x % (comp->dx << rpx) == 0) || ((pi->x == pi->tx0) && ((trx0 << levelno) % (1 << rpx))))){
+                                                continue; 
+                                        }
+                                        
+                                        if ((res->pw==0)||(res->pw==0)) continue;
+                                        
+                                        if ((trx0==trx1)||(try0==try1)) continue;
+                                        
+                                        prci = int_floordivpow2(int_ceildiv(pi->x, comp->dx << levelno), res->pdx) 
+                                                 - int_floordivpow2(trx0, res->pdx);
+                                        prcj = int_floordivpow2(int_ceildiv(pi->y, comp->dy << levelno), res->pdy) 
+                                                 - int_floordivpow2(try0, res->pdy);
+                                        pi->precno = prci + prcj * res->pw;
+                                        for (pi->layno = pi->poc.layno0; pi->layno < pi->poc.layno1; pi->layno++) {
+                                                index = pi->layno * pi->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p;
+                                                if (!pi->include[index]) {
+                                                        pi->include[index] = 1;
+                                                        return true;
+                                                }       
+LABEL_SKIP:;
+                                        }
+                                }
+                        }
+                }
+        }
+        
+        return false;
+}
+
+static bool pi_next_cprl(opj_pi_iterator_t * pi) {
+        opj_pi_comp_t *comp = NULL;
+        opj_pi_resolution_t *res = NULL;
+        long index = 0;
+
+        if (!pi->first) {
+                comp = &pi->comps[pi->compno];
+                goto LABEL_SKIP;
+        } else {
+                pi->first = 0;
+        }
+
+        for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1; pi->compno++) {
+                int resno;
+                comp = &pi->comps[pi->compno];
+                pi->dx = 0;
+                pi->dy = 0;
+                for (resno = 0; resno < comp->numresolutions; resno++) {
+                        int dx, dy;
+                        res = &comp->resolutions[resno];
+                        dx = comp->dx * (1 << (res->pdx + comp->numresolutions - 1 - resno));
+                        dy = comp->dy * (1 << (res->pdy + comp->numresolutions - 1 - resno));
+                        pi->dx = !pi->dx ? dx : int_min(pi->dx, dx);
+                        pi->dy = !pi->dy ? dy : int_min(pi->dy, dy);
+                }
+                if (!pi->tp_on){
+                        pi->poc.ty0 = pi->ty0;
+                        pi->poc.tx0 = pi->tx0;
+                        pi->poc.ty1 = pi->ty1;
+                        pi->poc.tx1 = pi->tx1;
+                }
+                for (pi->y = pi->poc.ty0; pi->y < pi->poc.ty1; pi->y += pi->dy - (pi->y % pi->dy)) {
+                        for (pi->x = pi->poc.tx0; pi->x < pi->poc.tx1; pi->x += pi->dx - (pi->x % pi->dx)) {
+                                for (pi->resno = pi->poc.resno0; pi->resno < int_min(pi->poc.resno1, comp->numresolutions); pi->resno++) {
+                                        int levelno;
+                                        int trx0, try0;
+                                        int trx1, try1;
+                                        int rpx, rpy;
+                                        int prci, prcj;
+                                        res = &comp->resolutions[pi->resno];
+                                        levelno = comp->numresolutions - 1 - pi->resno;
+                                        trx0 = int_ceildiv(pi->tx0, comp->dx << levelno);
+                                        try0 = int_ceildiv(pi->ty0, comp->dy << levelno);
+                                        trx1 = int_ceildiv(pi->tx1, comp->dx << levelno);
+                                        try1 = int_ceildiv(pi->ty1, comp->dy << levelno);
+                                        rpx = res->pdx + levelno;
+                                        rpy = res->pdy + levelno;
+                                        if (!((pi->y % (comp->dy << rpy) == 0) || ((pi->y == pi->ty0) && ((try0 << levelno) % (1 << rpx))))){
+                                                continue;       
+                                        }
+                                        if (!((pi->x % (comp->dx << rpx) == 0) || ((pi->x == pi->tx0) && ((trx0 << levelno) % (1 << rpx))))){
+                                                continue; 
+                                        }
+                                        
+                                        if ((res->pw==0)||(res->pw==0)) continue;
+                                        
+                                        if ((trx0==trx1)||(try0==try1)) continue;
+                                        
+                                        prci = int_floordivpow2(int_ceildiv(pi->x, comp->dx << levelno), res->pdx) 
+                                                 - int_floordivpow2(trx0, res->pdx);
+                                        prcj = int_floordivpow2(int_ceildiv(pi->y, comp->dy << levelno), res->pdy) 
+                                                 - int_floordivpow2(try0, res->pdy);
+                                        pi->precno = prci + prcj * res->pw;
+                                        for (pi->layno = pi->poc.layno0; pi->layno < pi->poc.layno1; pi->layno++) {
+                                                index = pi->layno * pi->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p;
+                                                if (!pi->include[index]) {
+                                                        pi->include[index] = 1;
+                                                        return true;
+                                                }
+LABEL_SKIP:;
+                                        }
+                                }
+                        }
+                }
+        }
+        
+        return false;
+}
+
+/* 
+==========================================================
+   Packet iterator interface
+==========================================================
+*/
+
+opj_pi_iterator_t *pi_create_decode(opj_image_t *image, opj_cp_t *cp, int tileno) {
+        int p, q;
+        int compno, resno, pino;
+        opj_pi_iterator_t *pi = NULL;
+        opj_tcp_t *tcp = NULL;
+        opj_tccp_t *tccp = NULL;
+        size_t array_size;
+        
+        tcp = &cp->tcps[tileno];
+
+        array_size = (tcp->numpocs + 1) * sizeof(opj_pi_iterator_t);
+        pi = (opj_pi_iterator_t *) opj_malloc(array_size);
+        if(!pi) {
+                /* TODO: throw an error */
+                return NULL;
+        }
+        
+        for (pino = 0; pino < tcp->numpocs + 1; pino++) {       /* change */
+                int maxres = 0;
+                int maxprec = 0;
+                p = tileno % cp->tw;
+                q = tileno / cp->tw;
+
+                pi[pino].tx0 = int_max(cp->tx0 + p * cp->tdx, image->x0);
+                pi[pino].ty0 = int_max(cp->ty0 + q * cp->tdy, image->y0);
+                pi[pino].tx1 = int_min(cp->tx0 + (p + 1) * cp->tdx, image->x1);
+                pi[pino].ty1 = int_min(cp->ty0 + (q + 1) * cp->tdy, image->y1);
+                pi[pino].numcomps = image->numcomps;
+
+                array_size = image->numcomps * sizeof(opj_pi_comp_t);
+                pi[pino].comps = (opj_pi_comp_t *) opj_malloc(array_size);
+                if(!pi[pino].comps) {
+                        /* TODO: throw an error */
+                        pi_destroy(pi, cp, tileno);
+                        return NULL;
+                }
+                memset(pi[pino].comps, 0, array_size);
+                
+                for (compno = 0; compno < pi->numcomps; compno++) {
+                        int tcx0, tcy0, tcx1, tcy1;
+                        opj_pi_comp_t *comp = &pi[pino].comps[compno];
+                        tccp = &tcp->tccps[compno];
+                        comp->dx = image->comps[compno].dx;
+                        comp->dy = image->comps[compno].dy;
+                        comp->numresolutions = tccp->numresolutions;
+
+                        array_size = comp->numresolutions * sizeof(opj_pi_resolution_t);
+                        comp->resolutions =     (opj_pi_resolution_t *) opj_malloc(array_size);
+                        if(!comp->resolutions) {
+                                /* TODO: throw an error */
+                                pi_destroy(pi, cp, tileno);
+                                return NULL;
+                        }
+
+                        tcx0 = int_ceildiv(pi->tx0, comp->dx);
+                        tcy0 = int_ceildiv(pi->ty0, comp->dy);
+                        tcx1 = int_ceildiv(pi->tx1, comp->dx);
+                        tcy1 = int_ceildiv(pi->ty1, comp->dy);
+                        if (comp->numresolutions > maxres) {
+                                maxres = comp->numresolutions;
+                        }
+
+                        for (resno = 0; resno < comp->numresolutions; resno++) {
+                                int levelno;
+                                int rx0, ry0, rx1, ry1;
+                                int px0, py0, px1, py1;
+                                opj_pi_resolution_t *res = &comp->resolutions[resno];
+                                if (tccp->csty & J2K_CCP_CSTY_PRT) {
+                                        res->pdx = tccp->prcw[resno];
+                                        res->pdy = tccp->prch[resno];
+                                } else {
+                                        res->pdx = 15;
+                                        res->pdy = 15;
+                                }
+                                levelno = comp->numresolutions - 1 - resno;
+                                rx0 = int_ceildivpow2(tcx0, levelno);
+                                ry0 = int_ceildivpow2(tcy0, levelno);
+                                rx1 = int_ceildivpow2(tcx1, levelno);
+                                ry1 = int_ceildivpow2(tcy1, levelno);
+                                px0 = int_floordivpow2(rx0, res->pdx) << res->pdx;
+                                py0 = int_floordivpow2(ry0, res->pdy) << res->pdy;
+                                px1 = int_ceildivpow2(rx1, res->pdx) << res->pdx;
+                                py1 = int_ceildivpow2(ry1, res->pdy) << res->pdy;
+                                res->pw = (rx0==rx1)?0:((px1 - px0) >> res->pdx);
+                                res->ph = (ry0==ry1)?0:((py1 - py0) >> res->pdy);
+                                
+                                if (res->pw*res->ph > maxprec) {
+                                        maxprec = res->pw*res->ph;
+                                }
+                                
+                        }
+                }
+                
+                tccp = &tcp->tccps[0];
+                pi[pino].step_p = 1;
+                pi[pino].step_c = maxprec * pi[pino].step_p;
+                pi[pino].step_r = image->numcomps * pi[pino].step_c;
+                pi[pino].step_l = maxres * pi[pino].step_r;
+                
+                if (pino == 0) {
+                        array_size = image->numcomps * maxres * tcp->numlayers * maxprec * sizeof(short int);
+                        pi[pino].include = (short int *) opj_malloc(array_size);
+                        if(!pi[pino].include) {
+                                /* TODO: throw an error */
+                                pi_destroy(pi, cp, tileno);
+                                return NULL;
+                        }
+                }
+                else {
+                        pi[pino].include = pi[pino - 1].include;
+                }
+                
+                if (tcp->POC == 0) {
+                        pi[pino].first = 1;
+                        pi[pino].poc.resno0 = 0;
+                        pi[pino].poc.compno0 = 0;
+                        pi[pino].poc.layno1 = tcp->numlayers;
+                        pi[pino].poc.resno1 = maxres;
+                        pi[pino].poc.compno1 = image->numcomps;
+                        pi[pino].poc.prg = tcp->prg;
+                } else {
+                        pi[pino].first = 1;
+                        pi[pino].poc.resno0 = tcp->pocs[pino].resno0;
+                        pi[pino].poc.compno0 = tcp->pocs[pino].compno0;
+                        pi[pino].poc.layno1 = tcp->pocs[pino].layno1;
+                        pi[pino].poc.resno1 = tcp->pocs[pino].resno1;
+                        pi[pino].poc.compno1 = tcp->pocs[pino].compno1;
+                        pi[pino].poc.prg = tcp->pocs[pino].prg;
+                }
+                pi[pino].poc.layno0  = 0;
+                pi[pino].poc.precno0 = 0; 
+                pi[pino].poc.precno1 = maxprec;
+                        
+        }
+        
+        return pi;
+}
+
+
+opj_pi_iterator_t *pi_initialise_encode(opj_image_t *image, opj_cp_t *cp, int tileno, J2K_T2_MODE t2_mode){ 
+        int p, q, pino;
+        int compno, resno;
+        int maxres = 0;
+        int maxprec = 0;
+        opj_pi_iterator_t *pi = NULL;
+        opj_tcp_t *tcp = NULL;
+        opj_tccp_t *tccp = NULL;
+        size_t array_size;
+        
+        tcp = &cp->tcps[tileno];
+
+        array_size = (tcp->numpocs + 1) * sizeof(opj_pi_iterator_t);
+        pi = (opj_pi_iterator_t *) opj_malloc(array_size);
+        if(!pi) {       return NULL;}
+        pi->tp_on = cp->tp_on;
+        
+        for(pino = 0;pino < tcp->numpocs+1 ; pino ++){
+                p = tileno % cp->tw;
+                q = tileno / cp->tw;
+
+                pi[pino].tx0 = int_max(cp->tx0 + p * cp->tdx, image->x0);
+                pi[pino].ty0 = int_max(cp->ty0 + q * cp->tdy, image->y0);
+                pi[pino].tx1 = int_min(cp->tx0 + (p + 1) * cp->tdx, image->x1);
+                pi[pino].ty1 = int_min(cp->ty0 + (q + 1) * cp->tdy, image->y1);
+                pi[pino].numcomps = image->numcomps;
+                
+                array_size = image->numcomps * sizeof(opj_pi_comp_t);
+                pi[pino].comps = (opj_pi_comp_t *) opj_malloc(array_size);
+                if(!pi[pino].comps) {
+                        pi_destroy(pi, cp, tileno);
+                        return NULL;
+                }
+                memset(pi[pino].comps, 0, array_size);
+                
+                for (compno = 0; compno < pi[pino].numcomps; compno++) {
+                        int tcx0, tcy0, tcx1, tcy1;
+                        opj_pi_comp_t *comp = &pi[pino].comps[compno];
+                        tccp = &tcp->tccps[compno];
+                        comp->dx = image->comps[compno].dx;
+                        comp->dy = image->comps[compno].dy;
+                        comp->numresolutions = tccp->numresolutions;
+
+                        array_size = comp->numresolutions * sizeof(opj_pi_resolution_t);
+                        comp->resolutions =     (opj_pi_resolution_t *) opj_malloc(array_size);
+                        if(!comp->resolutions) {
+                                pi_destroy(pi, cp, tileno);
+                                return NULL;
+                        }
+
+                        tcx0 = int_ceildiv(pi[pino].tx0, comp->dx);
+                        tcy0 = int_ceildiv(pi[pino].ty0, comp->dy);
+                        tcx1 = int_ceildiv(pi[pino].tx1, comp->dx);
+                        tcy1 = int_ceildiv(pi[pino].ty1, comp->dy);
+                        if (comp->numresolutions > maxres) {
+                                maxres = comp->numresolutions;
+                        }
+
+                        for (resno = 0; resno < comp->numresolutions; resno++) {
+                                int levelno;
+                                int rx0, ry0, rx1, ry1;
+                                int px0, py0, px1, py1;
+                                opj_pi_resolution_t *res = &comp->resolutions[resno];
+                                if (tccp->csty & J2K_CCP_CSTY_PRT) {
+                                        res->pdx = tccp->prcw[resno];
+                                        res->pdy = tccp->prch[resno];
+                                } else {
+                                        res->pdx = 15;
+                                        res->pdy = 15;
+                                }
+                                levelno = comp->numresolutions - 1 - resno;
+                                rx0 = int_ceildivpow2(tcx0, levelno);
+                                ry0 = int_ceildivpow2(tcy0, levelno);
+                                rx1 = int_ceildivpow2(tcx1, levelno);
+                                ry1 = int_ceildivpow2(tcy1, levelno);
+                                px0 = int_floordivpow2(rx0, res->pdx) << res->pdx;
+                                py0 = int_floordivpow2(ry0, res->pdy) << res->pdy;
+                                px1 = int_ceildivpow2(rx1, res->pdx) << res->pdx;
+                                py1 = int_ceildivpow2(ry1, res->pdy) << res->pdy;
+                                res->pw = (rx0==rx1)?0:((px1 - px0) >> res->pdx);
+                                res->ph = (ry0==ry1)?0:((py1 - py0) >> res->pdy);
+
+                                if (res->pw*res->ph > maxprec) {
+                                        maxprec = res->pw * res->ph;
+                                }
+                        }
+                }
+                
+                tccp = &tcp->tccps[0];
+                pi[pino].step_p = 1;
+                pi[pino].step_c = maxprec * pi[pino].step_p;
+                pi[pino].step_r = image->numcomps * pi[pino].step_c;
+                pi[pino].step_l = maxres * pi[pino].step_r;
+                
+                for (compno = 0; compno < pi->numcomps; compno++) {
+                        opj_pi_comp_t *comp = &pi->comps[compno];
+                        for (resno = 0; resno < comp->numresolutions; resno++) {
+                                int dx, dy;
+                                opj_pi_resolution_t *res = &comp->resolutions[resno];
+                                dx = comp->dx * (1 << (res->pdx + comp->numresolutions - 1 - resno));
+                                dy = comp->dy * (1 << (res->pdy + comp->numresolutions - 1 - resno));
+                                pi[pino].dx = !pi->dx ? dx : int_min(pi->dx, dx);
+                                pi[pino].dy = !pi->dy ? dy : int_min(pi->dy, dy);
+                        }
+                }
+
+                if (pino == 0) {
+                        array_size = tcp->numlayers * pi[pino].step_l * sizeof(short int);
+                        pi[pino].include = (short int *) opj_malloc(array_size);
+                        if(!pi[pino].include) {
+                                pi_destroy(pi, cp, tileno);
+                                return NULL;
+                        }
+                }
+                else {
+                        pi[pino].include = pi[pino - 1].include;
+                }
+                
+                /* Generation of boundaries for each prog flag*/
+                        if(tcp->POC & (t2_mode == FINAL_PASS)){
+                                tcp->pocs[pino].compS= tcp->pocs[pino].compno0;
+                                tcp->pocs[pino].compE= tcp->pocs[pino].compno1;
+                                tcp->pocs[pino].resS = tcp->pocs[pino].resno0;
+                                tcp->pocs[pino].resE = tcp->pocs[pino].resno1;
+                                tcp->pocs[pino].layE = tcp->pocs[pino].layno1;
+                                tcp->pocs[pino].prg  = tcp->pocs[pino].prg1;
+                                if (pino > 0)
+                                        tcp->pocs[pino].layS = (tcp->pocs[pino].layE > tcp->pocs[pino - 1].layE) ? tcp->pocs[pino - 1].layE : 0;
+                        }else {
+                                tcp->pocs[pino].compS= 0;
+                                tcp->pocs[pino].compE= image->numcomps;
+                                tcp->pocs[pino].resS = 0;
+                                tcp->pocs[pino].resE = maxres;
+                                tcp->pocs[pino].layS = 0;
+                                tcp->pocs[pino].layE = tcp->numlayers;
+                                tcp->pocs[pino].prg  = tcp->prg;
+                        }
+                        tcp->pocs[pino].prcS = 0;
+                        tcp->pocs[pino].prcE = maxprec;;
+                        tcp->pocs[pino].txS = pi[pino].tx0;
+                        tcp->pocs[pino].txE = pi[pino].tx1;
+                        tcp->pocs[pino].tyS = pi[pino].ty0;
+                        tcp->pocs[pino].tyE = pi[pino].ty1;
+                        tcp->pocs[pino].dx = pi[pino].dx;
+                        tcp->pocs[pino].dy = pi[pino].dy;
+                }
+                        return pi;
+        }
+
+
+
+void pi_destroy(opj_pi_iterator_t *pi, opj_cp_t *cp, int tileno) {
+        int compno, pino;
+        opj_tcp_t *tcp = &cp->tcps[tileno];
+        if(pi) {
+                for (pino = 0; pino < tcp->numpocs + 1; pino++) {       
+                        if(pi[pino].comps) {
+                                for (compno = 0; compno < pi->numcomps; compno++) {
+                                        opj_pi_comp_t *comp = &pi[pino].comps[compno];
+                                        if(comp->resolutions) {
+                                                opj_free(comp->resolutions);
+                                        }
+                                }
+                                opj_free(pi[pino].comps);
+                        }
+                }
+                if(pi->include) {
+                        opj_free(pi->include);
+                }
+                opj_free(pi);
+        }
+}
+
+bool pi_next(opj_pi_iterator_t * pi) {
+        switch (pi->poc.prg) {
+                case LRCP:
+                        return pi_next_lrcp(pi);
+                case RLCP:
+                        return pi_next_rlcp(pi);
+                case RPCL:
+                        return pi_next_rpcl(pi);
+                case PCRL:
+                        return pi_next_pcrl(pi);
+                case CPRL:
+                        return pi_next_cprl(pi);
+                case PROG_UNKNOWN:
+                        return false;
+        }
+        
+        return false;
+}
+
+int pi_check_next_level(int pos,opj_cp_t *cp,int tileno, int pino, char *prog){
+        int i,l;
+        opj_tcp_t *tcps =&cp->tcps[tileno];
+        opj_poc_t *tcp = &tcps->pocs[pino];
+        if(pos>=0){
+                for(i=pos;pos>=0;i--){
+                        switch(prog[i]){
+                case 'R':
+                        if(tcp->res_t==tcp->resE){
+                                l=pi_check_next_level(pos-1,cp,tileno,pino,prog);
+                                if(l==1){
+                                        return 1;
+                                }else{
+                                        return 0;
+                                }
+                        }else{
+                                return 1;
+                        }
+                        break;
+                case 'C':
+                        if(tcp->comp_t==tcp->compE){
+                                l=pi_check_next_level(pos-1,cp,tileno,pino,prog);
+                                if(l==1){
+                                        return 1;
+                                }else{
+                                        return 0;
+                                }
+                        }else{
+                                return 1;
+                        }
+                        break;
+                case 'L':
+                        if(tcp->lay_t==tcp->layE){
+                                l=pi_check_next_level(pos-1,cp,tileno,pino,prog);
+                                if(l==1){
+                                        return 1;
+                                }else{
+                                        return 0;
+                                }
+                        }else{
+                                return 1;
+                        }
+                        break;
+                case 'P':
+                        switch(tcp->prg){
+                                case LRCP||RLCP:
+                                        if(tcp->prc_t == tcp->prcE){
+                                                l=pi_check_next_level(i-1,cp,tileno,pino,prog);
+                                                if(l==1){
+                                                        return 1;
+                                                }else{
+                                                        return 0;
+                                                }
+                                        }else{
+                                                return 1;
+                                        }
+                                        break;
+                        default:
+                                if(tcp->tx0_t == tcp->txE){
+                                        //TY 
+                                        if(tcp->ty0_t == tcp->tyE){
+                                                l=pi_check_next_level(i-1,cp,tileno,pino,prog);
+                                                if(l==1){
+                                                        return 1;
+                                                }else{
+                                                        return 0;
+                                                }
+                                        }else{
+                                                return 1;
+                                        }//TY
+                                }else{
+                                        return 1;
+                                }
+                                break;
+                        }//end case P
+                }//end switch
+                }//end for
+        }//end if
+        return 0;
+}
+
+
+void pi_create_encode( opj_pi_iterator_t *pi, opj_cp_t *cp,int tileno, int pino,int tpnum, int tppos){
+        char *prog;
+        int i,l;
+        int incr_top=1,resetX=0;
+        opj_tcp_t *tcps =&cp->tcps[tileno];
+        opj_poc_t *tcp= &tcps->pocs[pino];
+        prog = j2k_convert_progression_order(tcp->prg);
+
+        pi[pino].first = 1;
+        pi[pino].poc.prg = tcp->prg;    
+        
+        if(!(cp->tp_on)){
+                pi[pino].poc.resno0 = tcp->resS;
+                pi[pino].poc.resno1 = tcp->resE;
+                pi[pino].poc.compno0 = tcp->compS;
+                pi[pino].poc.compno1 = tcp->compE;
+                pi[pino].poc.layno0 = tcp->layS;
+                pi[pino].poc.layno1 = tcp->layE;
+                pi[pino].poc.precno0 = tcp->prcS;
+                pi[pino].poc.precno1 = tcp->prcE;
+                pi[pino].poc.tx0 = tcp->txS;
+                pi[pino].poc.ty0 = tcp->tyS;
+                pi[pino].poc.tx1 = tcp->txE;
+                pi[pino].poc.ty1 = tcp->tyE;
+        }else {
+                for(i=tppos+1;i<4;i++){
+                        switch(prog[i]){
+                        case 'R':
+                                pi[pino].poc.resno0 = tcp->resS;
+                                pi[pino].poc.resno1 = tcp->resE;
+                                break;
+                        case 'C':
+                                pi[pino].poc.compno0 = tcp->compS;
+                                pi[pino].poc.compno1 = tcp->compE;
+                                break;
+                        case 'L':
+                                pi[pino].poc.layno0 = tcp->layS;
+                                pi[pino].poc.layno1 = tcp->layE;
+                                break;
+                        case 'P':
+                                switch(tcp->prg){
+                                        case LRCP:
+                                        case RLCP:
+                                                pi[pino].poc.precno0 = tcp->prcS;
+                                                pi[pino].poc.precno1 = tcp->prcE;
+                                                break;
+                                        default:
+                                                pi[pino].poc.tx0 = tcp->txS;
+                                                pi[pino].poc.ty0 = tcp->tyS;
+                                                pi[pino].poc.tx1 = tcp->txE;
+                                                pi[pino].poc.ty1 = tcp->tyE;
+                                                break;
+                                }
+                                break;
+                        }
+                }
+
+                if(tpnum==0){
+                        for(i=tppos;i>=0;i--){
+                                switch(prog[i]){
+                                                case 'C':
+                                                        tcp->comp_t = tcp->compS;
+                                                        pi[pino].poc.compno0 = tcp->comp_t;
+                                                        pi[pino].poc.compno1 = tcp->comp_t+1;
+                                                        tcp->comp_t+=1;
+                                                        break;
+                                                case 'R':
+                                                        tcp->res_t = tcp->resS;
+                                                        pi[pino].poc.resno0 = tcp->res_t;
+                                                        pi[pino].poc.resno1 = tcp->res_t+1;
+                                                        tcp->res_t+=1;
+                                                        break;
+                                                case 'L':
+                                                        tcp->lay_t = tcp->layS;
+                                                        pi[pino].poc.layno0 = tcp->lay_t;
+                                                        pi[pino].poc.layno1 = tcp->lay_t+1;
+                                                        tcp->lay_t+=1;
+                                                        break;
+                                                case 'P':
+                                                        switch(tcp->prg){
+                                                                case LRCP:
+                                                                case RLCP:
+                                                                        tcp->prc_t = tcp->prcS;
+                                                                        pi[pino].poc.precno0 = tcp->prc_t;
+                                                                        pi[pino].poc.precno1 = tcp->prc_t+1;
+                                                                        tcp->prc_t+=1; 
+                                                                        break;
+                                                                default:
+                                                                        tcp->tx0_t = tcp->txS;
+                                                                        tcp->ty0_t = tcp->tyS;
+                                                                        pi[pino].poc.tx0 = tcp->tx0_t;
+                                                                        pi[pino].poc.tx1 = tcp->tx0_t + tcp->dx - (tcp->tx0_t % tcp->dx);
+                                                                        pi[pino].poc.ty0 = tcp->ty0_t;
+                                                                        pi[pino].poc.ty1 = tcp->ty0_t + tcp->dy - (tcp->ty0_t % tcp->dy);
+                                                                        tcp->tx0_t = pi[pino].poc.tx1;
+                                                                        tcp->ty0_t = pi[pino].poc.ty1;
+                                                                        break;
+                                                        }
+                                                        break;
+                                }
+                        }
+                        incr_top=1;
+                }else{
+                        for(i=tppos;i>=0;i--){
+                                switch(prog[i]){
+                                                case 'C':
+                                                        pi[pino].poc.compno0 = tcp->comp_t-1;
+                                                        pi[pino].poc.compno1 = tcp->comp_t;
+                                                        break;
+                                                case 'R':
+                                                        pi[pino].poc.resno0 = tcp->res_t-1;
+                                                        pi[pino].poc.resno1 = tcp->res_t;
+                                                        break;
+                                                case 'L':
+                                                        pi[pino].poc.layno0 = tcp->lay_t-1;
+                                                        pi[pino].poc.layno1 = tcp->lay_t;
+                                                        break;
+                                                case 'P':
+                                                        switch(tcp->prg){
+                                                                case LRCP:
+                                                                case RLCP:
+                                                                        pi[pino].poc.precno0 = tcp->prc_t-1;
+                                                                        pi[pino].poc.precno1 = tcp->prc_t;
+                                                                        break;
+                                                                default:
+                                                                        pi[pino].poc.tx0 = tcp->tx0_t - tcp->dx - (tcp->tx0_t % tcp->dx);
+                                                                        pi[pino].poc.tx1 = tcp->tx0_t ;
+                                                                        pi[pino].poc.ty0 = tcp->ty0_t - tcp->dy - (tcp->ty0_t % tcp->dy);
+                                                                        pi[pino].poc.ty1 = tcp->ty0_t ;
+                                                                        break;
+                                                        }
+                                                        break;
+                                }
+                                if(incr_top==1){
+                                        switch(prog[i]){
+                                                        case 'R':
+                                                                if(tcp->res_t==tcp->resE){
+                                                                        l=pi_check_next_level(i-1,cp,tileno,pino,prog);
+                                                                        if(l==1){
+                                                                                tcp->res_t = tcp->resS;
+                                                                                pi[pino].poc.resno0 = tcp->res_t;
+                                                                                pi[pino].poc.resno1 = tcp->res_t+1;
+                                                                                tcp->res_t+=1;
+                                                                                incr_top=1;
+                                                                        }else{
+                                                                                incr_top=0;
+                                                                        }
+                                                                }else{
+                                                                        pi[pino].poc.resno0 = tcp->res_t;
+                                                                        pi[pino].poc.resno1 = tcp->res_t+1;
+                                                                        tcp->res_t+=1;
+                                                                        incr_top=0;
+                                                                }
+                                                                break;
+                                                        case 'C':
+                                                                if(tcp->comp_t ==tcp->compE){
+                                                                        l=pi_check_next_level(i-1,cp,tileno,pino,prog);
+                                                                        if(l==1){
+                                                                                tcp->comp_t = tcp->compS;
+                                                                                pi[pino].poc.compno0 = tcp->comp_t;
+                                                                                pi[pino].poc.compno1 = tcp->comp_t+1;
+                                                                                tcp->comp_t+=1;
+                                                                                incr_top=1;
+                                                                        }else{
+                                                                                incr_top=0;
+                                                                        }
+                                                                }else{
+                                                                        pi[pino].poc.compno0 = tcp->comp_t;
+                                                                        pi[pino].poc.compno1 = tcp->comp_t+1;
+                                                                        tcp->comp_t+=1;
+                                                                        incr_top=0;
+                                                                }
+                                                                break;  
+                                                        case 'L':
+                                                                if(tcp->lay_t == tcp->layE){
+                                                                        l=pi_check_next_level(i-1,cp,tileno,pino,prog);
+                                                                        if(l==1){
+                                                                                tcp->lay_t = tcp->layS;
+                                                                                pi[pino].poc.layno0 = tcp->lay_t;
+                                                                                pi[pino].poc.layno1 = tcp->lay_t+1;
+                                                                                tcp->lay_t+=1;
+                                                                                incr_top=1;
+                                                                        }else{
+                                                                                incr_top=0;
+                                                                        }
+                                                                }else{
+                                                                        pi[pino].poc.layno0 = tcp->lay_t;
+                                                                        pi[pino].poc.layno1 = tcp->lay_t+1;
+                                                                        tcp->lay_t+=1;
+                                                                        incr_top=0;
+                                                                }
+                                                                break;
+                                                        case 'P':
+                                                                switch(tcp->prg){
+                                                                        case LRCP:
+                                                                        case RLCP:
+                                                                                if(tcp->prc_t == tcp->prcE){
+                                                                                        l=pi_check_next_level(i-1,cp,tileno,pino,prog);
+                                                                                        if(l==1){
+                                                                                                tcp->prc_t = tcp->prcS;
+                                                                                                pi[pino].poc.precno0 = tcp->prc_t;
+                                                                                                pi[pino].poc.precno1 = tcp->prc_t+1;
+                                                                                                tcp->prc_t+=1;
+                                                                                                incr_top=1;
+                                                                                        }else{
+                                                                                                incr_top=0;
+                                                                                        }
+                                                                                }else{
+                                                                                        pi[pino].poc.precno0 = tcp->prc_t;
+                                                                                        pi[pino].poc.precno1 = tcp->prc_t+1;
+                                                                                        tcp->prc_t+=1;
+                                                                                        incr_top=0;
+                                                                                }
+                                                                                break;
+                                                                        default:
+                                                                                if(tcp->tx0_t >= tcp->txE){
+                                                                                        if(tcp->ty0_t >= tcp->tyE){
+                                                                                                l=pi_check_next_level(i-1,cp,tileno,pino,prog);
+                                                                                                if(l==1){
+                                                                                                        tcp->ty0_t = tcp->tyS;
+                                                                                                        pi[pino].poc.ty0 = tcp->ty0_t;
+                                                                                                        pi[pino].poc.ty1 = tcp->ty0_t + tcp->dy - (tcp->ty0_t % tcp->dy);
+                                                                                                        tcp->ty0_t = pi[pino].poc.ty1;
+                                                                                                        incr_top=1;resetX=1;
+                                                                                                }else{
+                                                                                                        incr_top=0;resetX=0;
+                                                                                                }
+                                                                                        }else{
+                                                                                                pi[pino].poc.ty0 = tcp->ty0_t;
+                                                                                                pi[pino].poc.ty1 = tcp->ty0_t + tcp->dy - (tcp->ty0_t % tcp->dy);
+                                                                                                tcp->ty0_t = pi[pino].poc.ty1;
+                                                                                                incr_top=0;resetX=1;
+                                                                                        }
+                                                                                        if(resetX==1){
+                                                                                                tcp->tx0_t = tcp->txS;
+                                                                                                pi[pino].poc.tx0 = tcp->tx0_t;
+                                                                                                pi[pino].poc.tx1 = tcp->tx0_t + tcp->dx- (tcp->tx0_t % tcp->dx);
+                                                                                                tcp->tx0_t = pi[pino].poc.tx1;
+                                                                                        }
+                                                                                }else{
+                                                                                        pi[pino].poc.tx0 = tcp->tx0_t;
+                                                                                        pi[pino].poc.tx1 = tcp->tx0_t + tcp->dx- (tcp->tx0_t % tcp->dx);
+                                                                                        tcp->tx0_t = pi[pino].poc.tx1;
+                                                                                        incr_top=0;
+                                                                                }
+                                                                                break;
+                                                                }
+                                                                break;
+                                        }
+                                }
+                        }
+                }
+        }
+}
+
+
diff --git a/libraries/openjpeg-libsl/libopenjpeg/pi.h b/libraries/openjpeg-libsl/libopenjpeg/pi.h
new file mode 100644
index 0000000..fc99329
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/pi.h
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __PI_H
+#define __PI_H
+/**
+@file pi.h
+@brief Implementation of a packet iterator (PI)
+
+The functions in PI.C have for goal to realize a packet iterator that permits to get the next
+packet following the progression order and change of it. The functions in PI.C are used
+by some function in T2.C.
+*/
+
+/** @defgroup PI PI - Implementation of a packet iterator */
+/*@{*/
+
+/**
+FIXME: documentation
+*/
+typedef struct opj_pi_resolution {
+  int pdx, pdy;
+  int pw, ph;
+} opj_pi_resolution_t;
+
+/**
+FIXME: documentation
+*/
+typedef struct opj_pi_comp {
+  int dx, dy;
+  /** number of resolution levels */
+  int numresolutions;
+  opj_pi_resolution_t *resolutions;
+} opj_pi_comp_t;
+
+/** 
+Packet iterator 
+*/
+typedef struct opj_pi_iterator {
+        /** Enabling Tile part generation*/
+        char tp_on;
+        /** precise if the packet has been already used (usefull for progression order change) */
+        short int *include;
+        /** layer step used to localize the packet in the include vector */
+        int step_l;
+        /** resolution step used to localize the packet in the include vector */
+        int step_r;     
+        /** component step used to localize the packet in the include vector */
+        int step_c;     
+        /** precinct step used to localize the packet in the include vector */
+        int step_p;     
+        /** component that identify the packet */
+        int compno;
+        /** resolution that identify the packet */
+        int resno;
+        /** precinct that identify the packet */
+        int precno;
+        /** layer that identify the packet */
+        int layno;   
+        /** 0 if the first packet */
+        int first;
+        /** progression order change information */
+        opj_poc_t poc;
+        /** number of components in the image */
+        int numcomps;
+        /** Components*/
+        opj_pi_comp_t *comps;
+        int tx0, ty0, tx1, ty1;
+        int x, y, dx, dy;
+} opj_pi_iterator_t;
+
+/** @name Exported functions */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+/**
+Create a packet iterator for Encoder
+@param image Raw image for which the packets will be listed
+@param cp Coding parameters
+@param tileno Number that identifies the tile for which to list the packets
+@param t2_mode If == 0 In Threshold calculation ,If == 1 Final pass
+@return Returns a packet iterator that points to the first packet of the tile
+@see pi_destroy
+*/
+opj_pi_iterator_t *pi_initialise_encode(opj_image_t *image, opj_cp_t *cp, int tileno,J2K_T2_MODE t2_mode);
+/**
+Modify the packet iterator for enabling tile part generation
+@param pi Handle to the packet iterator generated in pi_initialise_encode  
+@param cp Coding parameters
+@param tileno Number that identifies the tile for which to list the packets
+@param tpnum Tile part number of the current tile
+@param tppos The position of the tile part flag in the progression order
+*/
+void pi_create_encode( opj_pi_iterator_t *pi, opj_cp_t *cp,int tileno, int pino,int tpnum, int tppos);
+/**
+Create a packet iterator for Decoder
+@param image Raw image for which the packets will be listed
+@param cp Coding parameters
+@param tileno Number that identifies the tile for which to list the packets
+@return Returns a packet iterator that points to the first packet of the tile
+@see pi_destroy
+*/
+opj_pi_iterator_t *pi_create_decode(opj_image_t * image, opj_cp_t * cp, int tileno);
+
+/**
+Destroy a packet iterator
+@param pi Previously created packet iterator
+@param cp Coding parameters
+@param tileno Number that identifies the tile for which the packets were listed
+@see pi_create
+*/
+void pi_destroy(opj_pi_iterator_t *pi, opj_cp_t *cp, int tileno);
+
+/**
+Modify the packet iterator to point to the next packet
+@param pi Packet iterator to modify
+@return Returns false if pi pointed to the last packet or else returns true 
+*/
+bool pi_next(opj_pi_iterator_t * pi);
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __PI_H */
diff --git a/libraries/openjpeg-libsl/libopenjpeg/raw.c b/libraries/openjpeg-libsl/libopenjpeg/raw.c
new file mode 100644
index 0000000..808a468
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/raw.c
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "opj_includes.h"
+
+/* 
+==========================================================
+   local functions
+==========================================================
+*/
+
+
+/* 
+==========================================================
+   RAW encoding interface
+==========================================================
+*/
+
+opj_raw_t* raw_create() {
+        opj_raw_t *raw = (opj_raw_t*)opj_malloc(sizeof(opj_raw_t));
+        return raw;
+}
+
+void raw_destroy(opj_raw_t *raw) {
+        if(raw) {
+                opj_free(raw);
+        }
+}
+
+int raw_numbytes(opj_raw_t *raw) {
+        return raw->bp - raw->start;
+}
+
+void raw_init_dec(opj_raw_t *raw, unsigned char *bp, int len) {
+        raw->start = bp;
+        raw->lenmax = len;
+        raw->len = 0;
+        raw->c = 0;
+        raw->ct = 0;
+}
+
+int raw_decode(opj_raw_t *raw) {
+        int d;
+        if (raw->ct == 0) {
+                raw->ct = 8;
+                if (raw->len == raw->lenmax) {
+                        raw->c = 0xff;
+                } else {
+                        if (raw->c == 0xff) {
+                                raw->ct = 7;
+                        }
+                        raw->c = *(raw->start + raw->len);
+                        raw->len++;
+                }
+        }
+        raw->ct--;
+        d = (raw->c >> raw->ct) & 0x01;
+        
+        return d;
+}
+
diff --git a/libraries/openjpeg-libsl/libopenjpeg/raw.h b/libraries/openjpeg-libsl/libopenjpeg/raw.h
new file mode 100644
index 0000000..c4ff9b3
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/raw.h
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __RAW_H
+#define __RAW_H
+/**
+@file raw.h
+@brief Implementation of operations for raw encoding (RAW)
+
+The functions in RAW.C have for goal to realize the operation of raw encoding linked
+with the corresponding mode switch.
+*/
+
+/** @defgroup RAW RAW - Implementation of operations for raw encoding */
+/*@{*/
+
+/**
+RAW encoding operations
+*/
+typedef struct opj_raw {
+        /** temporary buffer where bits are coded or decoded */
+        unsigned char c;
+        /** number of bits already read or free to write */
+        unsigned int ct;
+        /** maximum length to decode */
+        unsigned int lenmax;
+        /** length decoded */
+        unsigned int len;
+        /** pointer to the current position in the buffer */
+        unsigned char *bp;
+        /** pointer to the start of the buffer */
+        unsigned char *start;
+        /** pointer to the end of the buffer */
+        unsigned char *end;
+} opj_raw_t;
+
+/** @name Exported functions */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+/**
+Create a new RAW handle 
+@return Returns a new RAW handle if successful, returns NULL otherwise
+*/
+opj_raw_t* raw_create();
+/**
+Destroy a previously created RAW handle
+@param raw RAW handle to destroy
+*/
+void raw_destroy(opj_raw_t *raw);
+/**
+Return the number of bytes written/read since initialisation
+@param raw RAW handle to destroy
+@return Returns the number of bytes already encoded
+*/
+int raw_numbytes(opj_raw_t *raw);
+/**
+Initialize the decoder
+@param raw RAW handle
+@param bp Pointer to the start of the buffer from which the bytes will be read
+@param len Length of the input buffer
+*/
+void raw_init_dec(opj_raw_t *raw, unsigned char *bp, int len);
+/**
+Decode a symbol using raw-decoder. Cfr p.506 TAUBMAN
+@param raw RAW handle
+@return Returns the decoded symbol (0 or 1)
+*/
+int raw_decode(opj_raw_t *raw);
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __RAW_H */
diff --git a/libraries/openjpeg-libsl/libopenjpeg/t1.c b/libraries/openjpeg-libsl/libopenjpeg/t1.c
new file mode 100644
index 0000000..b5d9599
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/t1.c
@@ -0,0 +1,1210 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * Copyright (c) 2007, Callum Lerwick <seg@haxxed.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "opj_includes.h"
+#include "t1_luts.h"
+
+/** @defgroup T1 T1 - Implementation of the tier-1 coding */
+/*@{*/
+
+/** @name Local static functions */
+/*@{*/
+
+static char t1_getctxno_zc(int f, int orient);
+static char t1_getctxno_sc(int f);
+static char t1_getctxno_mag(int f);
+static char t1_getspb(int f);
+static short t1_getnmsedec_sig(int x, int bitpos);
+static short t1_getnmsedec_ref(int x, int bitpos);
+static void t1_updateflags(flag_t *flagsp, int s, int stride);
+/**
+Encode significant pass
+*/
+static void t1_enc_sigpass_step(
+                opj_t1_t *t1,
+                flag_t *flagsp,
+                int *datap,
+                int orient,
+                int bpno,
+                int one,
+                int *nmsedec,
+                char type,
+                int vsc);
+/**
+Decode significant pass
+*/
+static void t1_dec_sigpass_step(
+                opj_t1_t *t1,
+                flag_t *flagsp,
+                int *datap,
+                int orient,
+                int oneplushalf,
+                char type,
+                int vsc);
+/**
+Encode significant pass
+*/
+static void t1_enc_sigpass(
+                opj_t1_t *t1,
+                int bpno,
+                int orient,
+                int *nmsedec,
+                char type,
+                int cblksty);
+/**
+Decode significant pass
+*/
+static void t1_dec_sigpass(
+                opj_t1_t *t1,
+                int bpno,
+                int orient,
+                char type,
+                int cblksty);
+/**
+Encode refinement pass
+*/
+static void t1_enc_refpass_step(
+                opj_t1_t *t1,
+                flag_t *flagsp,
+                int *datap,
+                int bpno,
+                int one,
+                int *nmsedec,
+                char type,
+                int vsc);
+/**
+Decode refinement pass
+*/
+static void t1_dec_refpass_step(
+                opj_t1_t *t1,
+                flag_t *flagsp,
+                int *datap,
+                int poshalf,
+                int neghalf,
+                char type,
+                int vsc);
+/**
+Encode refinement pass
+*/
+static void t1_enc_refpass(
+                opj_t1_t *t1,
+                int bpno,
+                int *nmsedec,
+                char type,
+                int cblksty);
+/**
+Decode refinement pass
+*/
+static void t1_dec_refpass(
+                opj_t1_t *t1,
+                int bpno,
+                char type,
+                int cblksty);
+/**
+Encode clean-up pass
+*/
+static void t1_enc_clnpass_step(
+                opj_t1_t *t1,
+                flag_t *flagsp,
+                int *datap,
+                int orient,
+                int bpno,
+                int one,
+                int *nmsedec,
+                int partial,
+                int vsc);
+/**
+Decode clean-up pass
+*/
+static void t1_dec_clnpass_step(
+                opj_t1_t *t1,
+                flag_t *flagsp,
+                int *datap,
+                int orient,
+                int oneplushalf,
+                int partial,
+                int vsc);
+/**
+Encode clean-up pass
+*/
+static void t1_enc_clnpass(
+                opj_t1_t *t1,
+                int bpno,
+                int orient,
+                int *nmsedec,
+                int cblksty);
+/**
+Decode clean-up pass
+*/
+static void t1_dec_clnpass(
+                opj_t1_t *t1,
+                int bpno,
+                int orient,
+                int cblksty);
+static double t1_getwmsedec(
+                int nmsedec,
+                int compno,
+                int level,
+                int orient,
+                int bpno,
+                int qmfbid,
+                double stepsize,
+                int numcomps);
+/**
+Encode 1 code-block
+@param t1 T1 handle
+@param cblk Code-block coding parameters
+@param orient
+@param compno Component number
+@param level
+@param qmfbid
+@param stepsize
+@param cblksty Code-block style
+@param numcomps
+@param tile
+*/
+static void t1_encode_cblk(
+                opj_t1_t *t1,
+                opj_tcd_cblk_t * cblk,
+                int orient,
+                int compno,
+                int level,
+                int qmfbid,
+                double stepsize,
+                int cblksty,
+                int numcomps,
+                opj_tcd_tile_t * tile);
+/**
+Decode 1 code-block
+@param t1 T1 handle
+@param cblk Code-block coding parameters
+@param orient
+@param roishift Region of interest shifting value
+@param cblksty Code-block style
+*/
+static void t1_decode_cblk(
+                opj_t1_t *t1,
+                opj_tcd_cblk_t * cblk,
+                int orient,
+                int roishift,
+                int cblksty);
+
+/*@}*/
+
+/*@}*/
+
+/* ----------------------------------------------------------------------- */
+
+static char t1_getctxno_zc(int f, int orient) {
+        return lut_ctxno_zc[(orient << 8) | (f & T1_SIG_OTH)];
+}
+
+static char t1_getctxno_sc(int f) {
+        return lut_ctxno_sc[(f & (T1_SIG_PRIM | T1_SGN)) >> 4];
+}
+
+static char t1_getctxno_mag(int f) {
+        return lut_ctxno_mag[(f & T1_SIG_OTH) | (((f & T1_REFINE) != 0) << 11)];
+}
+
+static char t1_getspb(int f) {
+        return lut_spb[(f & (T1_SIG_PRIM | T1_SGN)) >> 4];
+}
+
+static short t1_getnmsedec_sig(int x, int bitpos) {
+        if (bitpos > T1_NMSEDEC_FRACBITS) {
+                return lut_nmsedec_sig[(x >> (bitpos - T1_NMSEDEC_FRACBITS)) & ((1 << T1_NMSEDEC_BITS) - 1)];
+        }
+        
+        return lut_nmsedec_sig0[x & ((1 << T1_NMSEDEC_BITS) - 1)];
+}
+
+static short t1_getnmsedec_ref(int x, int bitpos) {
+        if (bitpos > T1_NMSEDEC_FRACBITS) {
+                return lut_nmsedec_ref[(x >> (bitpos - T1_NMSEDEC_FRACBITS)) & ((1 << T1_NMSEDEC_BITS) - 1)];
+        }
+
+    return lut_nmsedec_ref0[x & ((1 << T1_NMSEDEC_BITS) - 1)];
+}
+
+static void t1_updateflags(flag_t *flagsp, int s, int stride) {
+        flag_t *np = flagsp - stride;
+        flag_t *sp = flagsp + stride;
+
+        static const flag_t mod[] = {
+                T1_SIG_S,            T1_SIG_N,            T1_SIG_E,            T1_SIG_W,
+                T1_SIG_S | T1_SGN_S, T1_SIG_N | T1_SGN_N, T1_SIG_E | T1_SGN_E, T1_SIG_W | T1_SGN_W
+        };
+
+        s <<= 2;
+
+        np[-1] |= T1_SIG_SE;
+        np[0]  |= mod[s];
+        np[1]  |= T1_SIG_SW;
+
+        flagsp[-1] |= mod[s+2];
+        flagsp[1]  |= mod[s+3];
+
+        sp[-1] |= T1_SIG_NE;
+        sp[0]  |= mod[s+1];
+        sp[1]  |= T1_SIG_NW;
+}
+
+static void t1_enc_sigpass_step(
+                opj_t1_t *t1,
+                flag_t *flagsp,
+                int *datap,
+                int orient,
+                int bpno,
+                int one,
+                int *nmsedec,
+                char type,
+                int vsc)
+{
+        int v, flag;
+        
+        opj_mqc_t *mqc = t1->mqc;       /* MQC component */
+        
+        flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
+        if ((flag & T1_SIG_OTH) && !(flag & (T1_SIG | T1_VISIT))) {
+                v = int_abs(*datap) & one ? 1 : 0;
+                if (type == T1_TYPE_RAW) {      /* BYPASS/LAZY MODE */
+                        mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));       /* ESSAI */
+                        mqc_bypass_enc(mqc, v);
+                } else {
+                        mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));
+                        mqc_encode(mqc, v);
+                }
+                if (v) {
+                        v = *datap < 0 ? 1 : 0;
+                        *nmsedec +=     t1_getnmsedec_sig(int_abs(*datap), bpno + T1_NMSEDEC_FRACBITS);
+                        if (type == T1_TYPE_RAW) {      /* BYPASS/LAZY MODE */
+                                mqc_setcurctx(mqc, t1_getctxno_sc(flag));       /* ESSAI */
+                                mqc_bypass_enc(mqc, v);
+                        } else {
+                                mqc_setcurctx(mqc, t1_getctxno_sc(flag));
+                                mqc_encode(mqc, v ^ t1_getspb(flag));
+                        }
+                        t1_updateflags(flagsp, v, t1->flags_stride);
+                        *flagsp |= T1_SIG;
+                }
+                *flagsp |= T1_VISIT;
+        }
+}
+
+static void t1_dec_sigpass_step(
+                opj_t1_t *t1,
+                flag_t *flagsp,
+                int *datap,
+                int orient,
+                int oneplushalf,
+                char type,
+                int vsc)
+{
+        int v, flag;
+        
+        opj_raw_t *raw = t1->raw;       /* RAW component */
+        opj_mqc_t *mqc = t1->mqc;       /* MQC component */
+        
+        flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
+        if ((flag & T1_SIG_OTH) && !(flag & (T1_SIG | T1_VISIT))) {
+                if (type == T1_TYPE_RAW) {
+                        if (raw_decode(raw)) {
+                                v = raw_decode(raw);    /* ESSAI */
+                                *datap = v ? -oneplushalf : oneplushalf;
+                                t1_updateflags(flagsp, v, t1->flags_stride);
+                                *flagsp |= T1_SIG;
+                        }
+                } else {
+                        mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));
+                        if (mqc_decode(mqc)) {
+                                mqc_setcurctx(mqc, t1_getctxno_sc(flag));
+                                v = mqc_decode(mqc) ^ t1_getspb(flag);
+                                *datap = v ? -oneplushalf : oneplushalf;
+                                t1_updateflags(flagsp, v, t1->flags_stride);
+                                *flagsp |= T1_SIG;
+                        }
+                }
+                *flagsp |= T1_VISIT;
+        }
+}                               /* VSC and  BYPASS by Antonin */
+
+static void t1_enc_sigpass(
+                opj_t1_t *t1,
+                int bpno,
+                int orient,
+                int *nmsedec,
+                char type,
+                int cblksty)
+{
+        int i, j, k, one, vsc;
+        *nmsedec = 0;
+        one = 1 << (bpno + T1_NMSEDEC_FRACBITS);
+        for (k = 0; k < t1->h; k += 4) {
+                for (i = 0; i < t1->w; ++i) {
+                        for (j = k; j < k + 4 && j < t1->h; ++j) {
+                                vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
+                                t1_enc_sigpass_step(
+                                                t1,
+                                                &t1->flags[((j+1) * t1->flags_stride) + i + 1],
+                                                &t1->data[(j * t1->w) + i],
+                                                orient,
+                                                bpno,
+                                                one,
+                                                nmsedec,
+                                                type,
+                                                vsc);
+                        }
+                }
+        }
+}
+
+static void t1_dec_sigpass(
+                opj_t1_t *t1,
+                int bpno,
+                int orient,
+                char type,
+                int cblksty)
+{
+        int i, j, k, one, half, oneplushalf, vsc;
+        one = 1 << bpno;
+        half = one >> 1;
+        oneplushalf = one | half;
+        for (k = 0; k < t1->h; k += 4) {
+                for (i = 0; i < t1->w; ++i) {
+                        for (j = k; j < k + 4 && j < t1->h; ++j) {
+                                vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
+                                t1_dec_sigpass_step(
+                                                t1,
+                                                &t1->flags[((j+1) * t1->flags_stride) + i + 1],
+                                                &t1->data[(j * t1->w) + i],
+                                                orient,
+                                                oneplushalf,
+                                                type,
+                                                vsc);
+                        }
+                }
+        }
+}                               /* VSC and  BYPASS by Antonin */
+
+static void t1_enc_refpass_step(
+                opj_t1_t *t1,
+                flag_t *flagsp,
+                int *datap,
+                int bpno,
+                int one,
+                int *nmsedec,
+                char type,
+                int vsc)
+{
+        int v, flag;
+        
+        opj_mqc_t *mqc = t1->mqc;       /* MQC component */
+        
+        flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
+        if ((flag & (T1_SIG | T1_VISIT)) == T1_SIG) {
+                *nmsedec += t1_getnmsedec_ref(int_abs(*datap), bpno + T1_NMSEDEC_FRACBITS);
+                v = int_abs(*datap) & one ? 1 : 0;
+                if (type == T1_TYPE_RAW) {      /* BYPASS/LAZY MODE */
+                        mqc_setcurctx(mqc, t1_getctxno_mag(flag));      /* ESSAI */
+                        mqc_bypass_enc(mqc, v);
+                } else {
+                        mqc_setcurctx(mqc, t1_getctxno_mag(flag));
+                        mqc_encode(mqc, v);
+                }
+                *flagsp |= T1_REFINE;
+        }
+}
+
+static void t1_dec_refpass_step(
+                opj_t1_t *t1,
+                flag_t *flagsp,
+                int *datap,
+                int poshalf,
+                int neghalf,
+                char type,
+                int vsc)
+{
+        int v, t, flag;
+        
+        opj_mqc_t *mqc = t1->mqc;       /* MQC component */
+        opj_raw_t *raw = t1->raw;       /* RAW component */
+        
+        flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
+        if ((flag & (T1_SIG | T1_VISIT)) == T1_SIG) {
+                if (type == T1_TYPE_RAW) {
+                        mqc_setcurctx(mqc, t1_getctxno_mag(flag));      /* ESSAI */
+                        v = raw_decode(raw);
+                } else {
+                        mqc_setcurctx(mqc, t1_getctxno_mag(flag));
+                        v = mqc_decode(mqc);
+                }
+                t = v ? poshalf : neghalf;
+                *datap += *datap < 0 ? -t : t;
+                *flagsp |= T1_REFINE;
+        }
+}                               /* VSC and  BYPASS by Antonin  */
+
+static void t1_enc_refpass(
+                opj_t1_t *t1,
+                int bpno,
+                int *nmsedec,
+                char type,
+                int cblksty)
+{
+        int i, j, k, one, vsc;
+        *nmsedec = 0;
+        one = 1 << (bpno + T1_NMSEDEC_FRACBITS);
+        for (k = 0; k < t1->h; k += 4) {
+                for (i = 0; i < t1->w; ++i) {
+                        for (j = k; j < k + 4 && j < t1->h; ++j) {
+                                vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
+                                t1_enc_refpass_step(
+                                                t1,
+                                                &t1->flags[((j+1) * t1->flags_stride) + i + 1],
+                                                &t1->data[(j * t1->w) + i],
+                                                bpno,
+                                                one,
+                                                nmsedec,
+                                                type,
+                                                vsc);
+                        }
+                }
+        }
+}
+
+static void t1_dec_refpass(
+                opj_t1_t *t1,
+                int bpno,
+                char type,
+                int cblksty)
+{
+        int i, j, k, one, poshalf, neghalf;
+        int vsc;
+        one = 1 << bpno;
+        poshalf = one >> 1;
+        neghalf = bpno > 0 ? -poshalf : -1;
+        for (k = 0; k < t1->h; k += 4) {
+                for (i = 0; i < t1->w; ++i) {
+                        for (j = k; j < k + 4 && j < t1->h; ++j) {
+                                vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
+                                t1_dec_refpass_step(
+                                                t1,
+                                                &t1->flags[((j+1) * t1->flags_stride) + i + 1],
+                                                &t1->data[(j * t1->w) + i],
+                                                poshalf,
+                                                neghalf,
+                                                type,
+                                                vsc);
+                        }
+                }
+        }
+}                               /* VSC and  BYPASS by Antonin */
+
+static void t1_enc_clnpass_step(
+                opj_t1_t *t1,
+                flag_t *flagsp,
+                int *datap,
+                int orient,
+                int bpno,
+                int one,
+                int *nmsedec,
+                int partial,
+                int vsc)
+{
+        int v, flag;
+        
+        opj_mqc_t *mqc = t1->mqc;       /* MQC component */
+        
+        flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
+        if (partial) {
+                goto LABEL_PARTIAL;
+        }
+        if (!(*flagsp & (T1_SIG | T1_VISIT))) {
+                mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));
+                v = int_abs(*datap) & one ? 1 : 0;
+                mqc_encode(mqc, v);
+                if (v) {
+LABEL_PARTIAL:
+                        *nmsedec += t1_getnmsedec_sig(int_abs(*datap), bpno + T1_NMSEDEC_FRACBITS);
+                        mqc_setcurctx(mqc, t1_getctxno_sc(flag));
+                        v = *datap < 0 ? 1 : 0;
+                        mqc_encode(mqc, v ^ t1_getspb(flag));
+                        t1_updateflags(flagsp, v, t1->flags_stride);
+                        *flagsp |= T1_SIG;
+                }
+        }
+        *flagsp &= ~T1_VISIT;
+}
+
+static void t1_dec_clnpass_step(
+                opj_t1_t *t1,
+                flag_t *flagsp,
+                int *datap,
+                int orient,
+                int oneplushalf,
+                int partial,
+                int vsc)
+{
+        int v, flag;
+        
+        opj_mqc_t *mqc = t1->mqc;       /* MQC component */
+        
+        flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
+        if (partial) {
+                goto LABEL_PARTIAL;
+        }
+        if (!(flag & (T1_SIG | T1_VISIT))) {
+                mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));
+                if (mqc_decode(mqc)) {
+LABEL_PARTIAL:
+                        mqc_setcurctx(mqc, t1_getctxno_sc(flag));
+                        v = mqc_decode(mqc) ^ t1_getspb(flag);
+                        *datap = v ? -oneplushalf : oneplushalf;
+                        t1_updateflags(flagsp, v, t1->flags_stride);
+                        *flagsp |= T1_SIG;
+                }
+        }
+        *flagsp &= ~T1_VISIT;
+}                               /* VSC and  BYPASS by Antonin */
+
+static void t1_enc_clnpass(
+                opj_t1_t *t1,
+                int bpno,
+                int orient,
+                int *nmsedec,
+                int cblksty)
+{
+        int i, j, k, one, agg, runlen, vsc;
+        
+        opj_mqc_t *mqc = t1->mqc;       /* MQC component */
+        
+        *nmsedec = 0;
+        one = 1 << (bpno + T1_NMSEDEC_FRACBITS);
+        for (k = 0; k < t1->h; k += 4) {
+                for (i = 0; i < t1->w; ++i) {
+                        if (k + 3 < t1->h) {
+                                if (cblksty & J2K_CCP_CBLKSTY_VSC) {
+                                        agg = !(MACRO_t1_flags(1 + k,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
+                                                || MACRO_t1_flags(1 + k + 1,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
+                                                || MACRO_t1_flags(1 + k + 2,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
+                                                || (MACRO_t1_flags(1 + k + 3,1 + i) 
+                                                & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) & (T1_SIG | T1_VISIT | T1_SIG_OTH));
+                                } else {
+                                        agg = !(MACRO_t1_flags(1 + k,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
+                                                || MACRO_t1_flags(1 + k + 1,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
+                                                || MACRO_t1_flags(1 + k + 2,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
+                                                || MACRO_t1_flags(1 + k + 3,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH));
+                                }
+                        } else {
+                                agg = 0;
+                        }
+                        if (agg) {
+                                for (runlen = 0; runlen < 4; ++runlen) {
+                                        if (int_abs(t1->data[((k + runlen)*t1->w) + i]) & one)
+                                                break;
+                                }
+                                mqc_setcurctx(mqc, T1_CTXNO_AGG);
+                                mqc_encode(mqc, runlen != 4);
+                                if (runlen == 4) {
+                                        continue;
+                                }
+                                mqc_setcurctx(mqc, T1_CTXNO_UNI);
+                                mqc_encode(mqc, runlen >> 1);
+                                mqc_encode(mqc, runlen & 1);
+                        } else {
+                                runlen = 0;
+                        }
+                        for (j = k + runlen; j < k + 4 && j < t1->h; ++j) {
+                                vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
+                                t1_enc_clnpass_step(
+                                                t1,
+                                                &t1->flags[((j+1) * t1->flags_stride) + i + 1],
+                                                &t1->data[(j * t1->w) + i],
+                                                orient,
+                                                bpno,
+                                                one,
+                                                nmsedec,
+                                                agg && (j == k + runlen),
+                                                vsc);
+                        }
+                }
+        }
+}
+
+static void t1_dec_clnpass(
+                opj_t1_t *t1,
+                int bpno,
+                int orient,
+                int cblksty)
+{
+        int i, j, k, one, half, oneplushalf, agg, runlen, vsc;
+        int segsym = cblksty & J2K_CCP_CBLKSTY_SEGSYM;
+        
+        opj_mqc_t *mqc = t1->mqc;       /* MQC component */
+        
+        one = 1 << bpno;
+        half = one >> 1;
+        oneplushalf = one | half;
+        for (k = 0; k < t1->h; k += 4) {
+                for (i = 0; i < t1->w; ++i) {
+                        if (k + 3 < t1->h) {
+                                if (cblksty & J2K_CCP_CBLKSTY_VSC) {
+                                        agg = !(MACRO_t1_flags(1 + k,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
+                                                || MACRO_t1_flags(1 + k + 1,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
+                                                || MACRO_t1_flags(1 + k + 2,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
+                                                || (MACRO_t1_flags(1 + k + 3,1 + i) 
+                                                & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) & (T1_SIG | T1_VISIT | T1_SIG_OTH));
+                                } else {
+                                        agg = !(MACRO_t1_flags(1 + k,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
+                                                || MACRO_t1_flags(1 + k + 1,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
+                                                || MACRO_t1_flags(1 + k + 2,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
+                                                || MACRO_t1_flags(1 + k + 3,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH));
+                                }
+                        } else {
+                                agg = 0;
+                        }
+                        if (agg) {
+                                mqc_setcurctx(mqc, T1_CTXNO_AGG);
+                                if (!mqc_decode(mqc)) {
+                                        continue;
+                                }
+                                mqc_setcurctx(mqc, T1_CTXNO_UNI);
+                                runlen = mqc_decode(mqc);
+                                runlen = (runlen << 1) | mqc_decode(mqc);
+                        } else {
+                                runlen = 0;
+                        }
+                        for (j = k + runlen; j < k + 4 && j < t1->h; ++j) {
+                                vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
+                                t1_dec_clnpass_step(
+                                                t1,
+                                                &t1->flags[((j+1) * t1->flags_stride) + i + 1],
+                                                &t1->data[(j * t1->w) + i],
+                                                orient,
+                                                oneplushalf,
+                                                agg && (j == k + runlen),
+                                                vsc);
+                        }
+                }
+        }
+        if (segsym) {
+                int v = 0;
+                mqc_setcurctx(mqc, T1_CTXNO_UNI);
+                v = mqc_decode(mqc);
+                v = (v << 1) | mqc_decode(mqc);
+                v = (v << 1) | mqc_decode(mqc);
+                v = (v << 1) | mqc_decode(mqc);
+                /*
+                if (v!=0xa) {
+                        opj_event_msg(t1->cinfo, EVT_WARNING, "Bad segmentation symbol %x\n", v);
+                } 
+                */
+        }
+}                               /* VSC and  BYPASS by Antonin */
+
+
+/** mod fixed_quality */
+static double t1_getwmsedec(
+                int nmsedec,
+                int compno,
+                int level,
+                int orient,
+                int bpno,
+                int qmfbid,
+                double stepsize,
+                int numcomps)
+{
+        double w1, w2, wmsedec;
+        if (qmfbid == 1) {
+                w1 = (numcomps > 1) ? mct_getnorm(compno) : 1.0;
+                w2 = dwt_getnorm(level, orient);
+        } else {                        /* if (qmfbid == 0) */
+                w1 = (numcomps > 1) ? mct_getnorm_real(compno) : 1.0;
+                w2 = dwt_getnorm_real(level, orient);
+        }
+        wmsedec = w1 * w2 * stepsize * (1 << bpno);
+        wmsedec *= wmsedec * nmsedec / 8192.0;
+        
+        return wmsedec;
+}
+
+static void allocate_buffers(
+                opj_t1_t *t1,
+                int w,
+                int h)
+{
+        int datasize;
+        int flagssize;
+
+        datasize=w * h;
+        //fprintf(stderr,"w=%i h=%i datasize=%i flagssize=%i\n",w,h,datasize,flagssize);
+
+        if(datasize > t1->datasize){
+                //fprintf(stderr,"Allocating t1->data: datasize=%i\n",datasize);
+                free(t1->data);
+                t1->data=malloc(datasize * sizeof(int));
+                if(!t1->data){
+                        return;
+                }
+                t1->datasize=datasize;
+        }
+        //memset(t1->data,0xff,t1->datasize);
+        memset(t1->data,0,datasize * sizeof(int));
+
+        t1->flags_stride=w+2;
+        flagssize=t1->flags_stride * (h+2);
+
+        if(flagssize > t1->flagssize){
+                //fprintf(stderr,"Allocating t1->flags: flagssize=%i\n",flagssize);
+                free(t1->flags);
+                t1->flags=malloc(flagssize * sizeof(flag_t));
+                if(!t1->flags){
+                        fprintf(stderr,"Allocating t1->flags FAILED!\n");
+                        return;
+                }
+                t1->flagssize=flagssize;
+        }
+        //memset(t1->flags,0xff,t1->flagssize);
+        memset(t1->flags,0,flagssize * sizeof(flag_t));
+
+        t1->w=w;
+        t1->h=h;
+}
+
+/** mod fixed_quality */
+static void t1_encode_cblk(
+                opj_t1_t *t1,
+                opj_tcd_cblk_t * cblk,
+                int orient,
+                int compno,
+                int level,
+                int qmfbid,
+                double stepsize,
+                int cblksty,
+                int numcomps,
+                opj_tcd_tile_t * tile)
+{
+        int i, j;
+        int passno;
+        int bpno, passtype;
+        int max;
+        int nmsedec = 0;
+        double cumwmsedec = 0.0;
+        char type = T1_TYPE_MQ;
+        
+        opj_mqc_t *mqc = t1->mqc;       /* MQC component */
+        
+        max = 0;
+        for (j = 0; j < t1->h; ++j) {
+                for (i = 0; i < t1->w; ++i) {
+                        max = int_max(max, int_abs(t1->data[(j * t1->w) + i]));
+                }
+        }
+        
+        cblk->numbps = max ? (int_floorlog2(max) + 1) - T1_NMSEDEC_FRACBITS : 0;
+        
+        bpno = cblk->numbps - 1;
+        passtype = 2;
+        
+        mqc_resetstates(mqc);
+        mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
+        mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
+        mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
+        mqc_init_enc(mqc, cblk->data);
+        
+        for (passno = 0; bpno >= 0; ++passno) {
+                opj_tcd_pass_t *pass = &cblk->passes[passno];
+                int correction = 3;
+                type = ((bpno < (cblk->numbps - 4)) && (passtype < 2) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
+                
+                switch (passtype) {
+                        case 0:
+                                t1_enc_sigpass(t1, bpno, orient, &nmsedec, type, cblksty);
+                                break;
+                        case 1:
+                                t1_enc_refpass(t1, bpno, &nmsedec, type, cblksty);
+                                break;
+                        case 2:
+                                t1_enc_clnpass(t1, bpno, orient, &nmsedec, cblksty);
+                                /* code switch SEGMARK (i.e. SEGSYM) */
+                                if (cblksty & J2K_CCP_CBLKSTY_SEGSYM)
+                                        mqc_segmark_enc(mqc);
+                                break;
+                }
+                
+                /* fixed_quality */
+                cumwmsedec += t1_getwmsedec(nmsedec, compno, level, orient, bpno, qmfbid, stepsize, numcomps);
+                tile->distotile += t1_getwmsedec(nmsedec, compno, level, orient, bpno, qmfbid, stepsize, numcomps);
+                
+                /* Code switch "RESTART" (i.e. TERMALL) */
+                if ((cblksty & J2K_CCP_CBLKSTY_TERMALL) && !((passtype == 2) && (bpno - 1 < 0))) {
+                        if (type == T1_TYPE_RAW) {
+                                mqc_flush(mqc);
+                                correction = 1;
+                                /* correction = mqc_bypass_flush_enc(); */
+                        } else {                        /* correction = mqc_restart_enc(); */
+                                mqc_flush(mqc);
+                                correction = 1;
+                        }
+                        pass->term = 1;
+                } else {
+                        if (((bpno < (cblk->numbps - 4) && (passtype > 0)) 
+                                || ((bpno == (cblk->numbps - 4)) && (passtype == 2))) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) {
+                                if (type == T1_TYPE_RAW) {
+                                        mqc_flush(mqc);
+                                        correction = 1;
+                                        /* correction = mqc_bypass_flush_enc(); */
+                                } else {                /* correction = mqc_restart_enc(); */
+                                        mqc_flush(mqc);
+                                        correction = 1;
+                                }
+                                pass->term = 1;
+                        } else {
+                                pass->term = 0;
+                        }
+                }
+                
+                if (++passtype == 3) {
+                        passtype = 0;
+                        bpno--;
+                }
+                
+                if (pass->term && bpno > 0) {
+                        type = ((bpno < (cblk->numbps - 4)) && (passtype < 2) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
+                        if (type == T1_TYPE_RAW)
+                                mqc_bypass_init_enc(mqc);
+                        else
+                                mqc_restart_init_enc(mqc);
+                }
+                
+                pass->distortiondec = cumwmsedec;
+                pass->rate = mqc_numbytes(mqc) + correction;    /* FIXME */
+                
+                /* Code-switch "RESET" */
+                if (cblksty & J2K_CCP_CBLKSTY_RESET)
+                        mqc_reset_enc(mqc);
+        }
+        
+        /* Code switch "ERTERM" (i.e. PTERM) */
+        if (cblksty & J2K_CCP_CBLKSTY_PTERM)
+                mqc_erterm_enc(mqc);
+        else /* Default coding */ if (!(cblksty & J2K_CCP_CBLKSTY_LAZY))
+                mqc_flush(mqc);
+        
+        cblk->totalpasses = passno;
+
+        for (passno = 0; passno<cblk->totalpasses; passno++) {
+                opj_tcd_pass_t *pass = &cblk->passes[passno];
+                if (pass->rate > mqc_numbytes(mqc))
+                        pass->rate = mqc_numbytes(mqc);
+                /*Preventing generation of FF as last data byte of a pass*/
+                if((pass->rate>1) && (cblk->data[pass->rate - 1] == 0xFF)){
+                        pass->rate--;
+                }
+                pass->len = pass->rate - (passno == 0 ? 0 : cblk->passes[passno - 1].rate);             
+        }
+}
+
+static void t1_decode_cblk(
+                opj_t1_t *t1,
+                opj_tcd_cblk_t * cblk,
+                int orient,
+                int roishift,
+                int cblksty)
+{
+        int bpno, passtype;
+        int segno, passno;
+        char type = T1_TYPE_MQ; /* BYPASS mode */
+        
+        opj_raw_t *raw = t1->raw;       /* RAW component */
+        opj_mqc_t *mqc = t1->mqc;       /* MQC component */
+        
+        allocate_buffers(
+                        t1,
+                        cblk->x1 - cblk->x0,
+                        cblk->y1 - cblk->y0);
+        
+        bpno = roishift + cblk->numbps - 1;
+        passtype = 2;
+        
+        mqc_resetstates(mqc);
+        mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
+        mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
+        mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
+        
+        for (segno = 0; segno < cblk->numsegs; ++segno) {
+                opj_tcd_seg_t *seg = &cblk->segs[segno];
+                
+                /* BYPASS mode */
+                type = ((bpno <= (cblk->numbps - 1) - 4) && (passtype < 2) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
+                if (type == T1_TYPE_RAW) {
+                        raw_init_dec(raw, seg->data, seg->len);
+                } else {
+                        mqc_init_dec(mqc, seg->data, seg->len);
+                }
+                
+                for (passno = 0; passno < seg->numpasses; ++passno) {
+                        switch (passtype) {
+                                case 0:
+                                        t1_dec_sigpass(t1, bpno+1, orient, type, cblksty);
+                                        break;
+                                case 1:
+                                        t1_dec_refpass(t1, bpno+1, type, cblksty);
+                                        break;
+                                case 2:
+                                        t1_dec_clnpass(t1, bpno+1, orient, cblksty);
+                                        break;
+                        }
+                        
+                        if ((cblksty & J2K_CCP_CBLKSTY_RESET) && type == T1_TYPE_MQ) {
+                                mqc_resetstates(mqc);
+                                mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);                         
+                                mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
+                                mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
+                        }
+                        if (++passtype == 3) {
+                                passtype = 0;
+                                bpno--;
+                        }
+                }
+        }
+}
+
+/* ----------------------------------------------------------------------- */
+
+opj_t1_t* t1_create(opj_common_ptr cinfo) {
+        opj_t1_t *t1 = (opj_t1_t*) malloc(sizeof(opj_t1_t));
+        if(!t1)
+                return NULL;
+
+                t1->cinfo = cinfo;
+                /* create MQC and RAW handles */
+                t1->mqc = mqc_create();
+                t1->raw = raw_create();
+
+        t1->datasize=0;
+        t1->data=NULL;
+        t1->flagssize=0;
+        t1->flags=NULL;
+
+        return t1;
+}
+
+void t1_destroy(opj_t1_t *t1) {
+        if(t1) {
+                /* destroy MQC and RAW handles */
+                mqc_destroy(t1->mqc);
+                raw_destroy(t1->raw);
+                free(t1->data);
+                free(t1->flags);
+                free(t1);
+        }
+}
+
+void t1_encode_cblks(
+                opj_t1_t *t1,
+                opj_tcd_tile_t *tile,
+                opj_tcp_t *tcp)
+{
+        int compno, resno, bandno, precno, cblkno;
+
+        tile->distotile = 0;            /* fixed_quality */
+
+        for (compno = 0; compno < tile->numcomps; ++compno) {
+                opj_tcd_tilecomp_t *tilec = &tile->comps[compno];
+
+                for (resno = 0; resno < tilec->numresolutions; ++resno) {
+                        opj_tcd_resolution_t *res = &tilec->resolutions[resno];
+
+                        for (bandno = 0; bandno < res->numbands; ++bandno) {
+                                opj_tcd_band_t *band = &res->bands[bandno];
+
+                                for (precno = 0; precno < res->pw * res->ph; ++precno) {
+                                        opj_tcd_precinct_t *prc = &band->precincts[precno];
+
+                                        for (cblkno = 0; cblkno < prc->cw * prc->ch; ++cblkno) {
+                                                int x, y, w, i, j, orient;
+                                                opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
+
+                                                x = cblk->x0 - band->x0;
+                                                y = cblk->y0 - band->y0;
+                                                if (band->bandno & 1) {
+                                                        opj_tcd_resolution_t *pres = &tilec->resolutions[resno - 1];
+                                                        x += pres->x1 - pres->x0;
+                                                }
+                                                if (band->bandno & 2) {
+                                                        opj_tcd_resolution_t *pres = &tilec->resolutions[resno - 1];
+                                                        y += pres->y1 - pres->y0;
+                                                }
+
+                                                allocate_buffers(
+                                                                t1,
+                                                                cblk->x1 - cblk->x0,
+                                                                cblk->y1 - cblk->y0);
+
+                                                w = tilec->x1 - tilec->x0;
+                                                if (tcp->tccps[compno].qmfbid == 1) {
+                                                        for (j = 0; j < t1->h; ++j) {
+                                                                for (i = 0; i < t1->w; ++i) {
+                                                                        t1->data[(j * t1->w) + i] =
+                                                                                tilec->data[(x + i) + (y + j) * w] << T1_NMSEDEC_FRACBITS;
+                                                                }
+                                                        }
+                                                } else {                /* if (tcp->tccps[compno].qmfbid == 0) */
+                                                        for (j = 0; j < t1->h; ++j) {
+                                                                for (i = 0; i < t1->w; ++i) {
+                                                                        t1->data[(j * t1->w) + i] = 
+                                                                                fix_mul(
+                                                                                tilec->data[x + i + (y + j) * w],
+                                                                                8192 * 8192 / ((int) floor(band->stepsize * 8192))) >> (11 - T1_NMSEDEC_FRACBITS);
+                                                                }
+                                                        }
+                                                }
+                                                orient = band->bandno;  /* FIXME */
+                                                if (orient == 2) {
+                                                        orient = 1;
+                                                } else if (orient == 1) {
+                                                        orient = 2;
+                                                }
+
+                                                t1_encode_cblk(
+                                                                t1,
+                                                                cblk,
+                                                                orient,
+                                                                compno,
+                                                                tilec->numresolutions - 1 - resno,
+                                                                tcp->tccps[compno].qmfbid,
+                                                                band->stepsize,
+                                                                tcp->tccps[compno].cblksty,
+                                                                tile->numcomps,
+                                                                tile);
+
+                                        } /* cblkno */
+                                } /* precno */
+                        } /* bandno */
+                } /* resno  */
+        } /* compno  */
+}
+
+void t1_decode_cblks(
+                opj_t1_t *t1,
+                opj_tcd_tile_t *tile,
+                opj_tcp_t *tcp)
+{
+        int compno, resno, bandno, precno, cblkno;
+
+        for (compno = 0; compno < tile->numcomps; ++compno) {
+                opj_tcd_tilecomp_t *tilec = &tile->comps[compno];
+
+                for (resno = 0; resno < tilec->numresolutions; ++resno) {
+                        opj_tcd_resolution_t *res = &tilec->resolutions[resno];
+
+                        for (bandno = 0; bandno < res->numbands; ++bandno) {
+                                opj_tcd_band_t *band = &res->bands[bandno];
+
+                                for (precno = 0; precno < res->pw * res->ph; ++precno) {
+                                        opj_tcd_precinct_t *prc = &band->precincts[precno];
+
+                                        for (cblkno = 0; cblkno < prc->cw * prc->ch; ++cblkno) {
+                                                int x, y, w, i, j, orient, cblk_w, cblk_h;
+                                                opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
+
+                                                orient = band->bandno;  /* FIXME */
+                                                if (orient == 2) {
+                                                        orient = 1;
+                                                } else if (orient == 1) {
+                                                        orient = 2;
+                                                }
+                                                
+                                                t1_decode_cblk(
+                                                                t1,
+                                                                cblk,
+                                                                orient,
+                                                                tcp->tccps[compno].roishift,
+                                                                tcp->tccps[compno].cblksty);
+
+                                                x = cblk->x0 - band->x0;
+                                                y = cblk->y0 - band->y0;
+                                                if (band->bandno & 1) {
+                                                        opj_tcd_resolution_t *pres = &tilec->resolutions[resno - 1];
+                                                        x += pres->x1 - pres->x0;
+                                                }
+                                                if (band->bandno & 2) {
+                                                        opj_tcd_resolution_t *pres = &tilec->resolutions[resno - 1];
+                                                        y += pres->y1 - pres->y0;
+                                                }
+
+                                                cblk_w = cblk->x1 - cblk->x0;
+                                                cblk_h = cblk->y1 - cblk->y0;
+
+                                                if (tcp->tccps[compno].roishift) {
+                                                        int thresh = 1 << tcp->tccps[compno].roishift;
+                                                        for (j = 0; j < cblk_h; ++j) {
+                                                                for (i = 0; i < cblk_w; ++i) {
+                                                                        int val = t1->data[(j * t1->w) + i];
+                                                                        int mag = int_abs(val);
+                                                                        if (mag >= thresh) {
+                                                                                mag >>= tcp->tccps[compno].roishift;
+                                                                                t1->data[(j * t1->w) + i] = val < 0 ? -mag : mag;
+                                                                        }
+                                                                }
+                                                        }
+                                                }
+                                                
+                                                w = tilec->x1 - tilec->x0;
+                                                if (tcp->tccps[compno].qmfbid == 1) {
+                                                        for (j = 0; j < cblk_h; ++j) {
+                                                                for (i = 0; i < cblk_w; ++i) {
+                                                                        tilec->data[x + i + (y + j) * w] = t1->data[(j * t1->w) + i]/2;
+                                                                }
+                                                        }
+                                                } else {                /* if (tcp->tccps[compno].qmfbid == 0) */
+                                                        for (j = 0; j < cblk_h; ++j) {
+                                                                for (i = 0; i < cblk_w; ++i) {
+                                                                        if (t1->data[(j * t1->w) + i] >> 1 == 0) {
+                                                                                tilec->data[x + i + (y + j) * w] = 0;
+                                                                        } else {
+                                                                                double tmp = (double)(t1->data[(j * t1->w) + i] * band->stepsize * 4096.0);
+                                                                                int tmp2 = ((int) (floor(fabs(tmp)))) + ((int) floor(fabs(tmp*2))%2);                                                                   
+                                                                                tilec->data[x + i + (y + j) * w] = ((tmp<0)?-tmp2:tmp2);
+                                                                        }
+                                                                }
+                                                        }
+                                                }
+                                        } /* cblkno */
+                                } /* precno */
+                        } /* bandno */
+                } /* resno */
+        } /* compno */
+}
+
diff --git a/libraries/openjpeg-libsl/libopenjpeg/t1.h b/libraries/openjpeg-libsl/libopenjpeg/t1.h
new file mode 100644
index 0000000..1b6cdb7
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/t1.h
@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __T1_H
+#define __T1_H
+/**
+@file t1.h
+@brief Implementation of the tier-1 coding (coding of code-block coefficients) (T1)
+
+The functions in T1.C have for goal to realize the tier-1 coding operation. The functions
+in T1.C are used by some function in TCD.C.
+*/
+
+/** @defgroup T1 T1 - Implementation of the tier-1 coding */
+/*@{*/
+
+/* ----------------------------------------------------------------------- */
+#define T1_NMSEDEC_BITS 7
+
+#define T1_SIG_NE 0x0001        /**< Context orientation : North-East direction */
+#define T1_SIG_SE 0x0002        /**< Context orientation : South-East direction */
+#define T1_SIG_SW 0x0004        /**< Context orientation : South-West direction */
+#define T1_SIG_NW 0x0008        /**< Context orientation : North-West direction */
+#define T1_SIG_N 0x0010         /**< Context orientation : North direction */
+#define T1_SIG_E 0x0020         /**< Context orientation : East direction */
+#define T1_SIG_S 0x0040         /**< Context orientation : South direction */
+#define T1_SIG_W 0x0080         /**< Context orientation : West direction */
+#define T1_SIG_OTH (T1_SIG_N|T1_SIG_NE|T1_SIG_E|T1_SIG_SE|T1_SIG_S|T1_SIG_SW|T1_SIG_W|T1_SIG_NW)
+#define T1_SIG_PRIM (T1_SIG_N|T1_SIG_E|T1_SIG_S|T1_SIG_W)
+
+#define T1_SGN_N 0x0100
+#define T1_SGN_E 0x0200
+#define T1_SGN_S 0x0400
+#define T1_SGN_W 0x0800
+#define T1_SGN (T1_SGN_N|T1_SGN_E|T1_SGN_S|T1_SGN_W)
+
+#define T1_SIG 0x1000
+#define T1_REFINE 0x2000
+#define T1_VISIT 0x4000
+
+#define T1_NUMCTXS_ZC 9
+#define T1_NUMCTXS_SC 5
+#define T1_NUMCTXS_MAG 3
+#define T1_NUMCTXS_AGG 1
+#define T1_NUMCTXS_UNI 1
+
+#define T1_CTXNO_ZC 0
+#define T1_CTXNO_SC (T1_CTXNO_ZC+T1_NUMCTXS_ZC)
+#define T1_CTXNO_MAG (T1_CTXNO_SC+T1_NUMCTXS_SC)
+#define T1_CTXNO_AGG (T1_CTXNO_MAG+T1_NUMCTXS_MAG)
+#define T1_CTXNO_UNI (T1_CTXNO_AGG+T1_NUMCTXS_AGG)
+#define T1_NUMCTXS (T1_CTXNO_UNI+T1_NUMCTXS_UNI)
+
+#define T1_NMSEDEC_FRACBITS (T1_NMSEDEC_BITS-1)
+
+#define T1_TYPE_MQ 0    /**< Normal coding using entropy coder */
+#define T1_TYPE_RAW 1   /**< No encoding the information is store under raw format in codestream (mode switch RAW)*/
+
+/* ----------------------------------------------------------------------- */
+
+typedef short flag_t;
+
+/**
+Tier-1 coding (coding of code-block coefficients)
+*/
+typedef struct opj_t1 {
+        /** codec context */
+        opj_common_ptr cinfo;
+
+        /** MQC component */
+        opj_mqc_t *mqc;
+        /** RAW component */
+        opj_raw_t *raw;
+
+        int *data;
+        flag_t *flags;
+        int w;
+        int h;
+        int datasize;
+        int flagssize;
+        int flags_stride;
+} opj_t1_t;
+
+#define MACRO_t1_flags(x,y) t1->flags[((x)*(t1->flags_stride))+(y)]
+
+/** @name Exported functions */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+/**
+Create a new T1 handle 
+and initialize the look-up tables of the Tier-1 coder/decoder
+@return Returns a new T1 handle if successful, returns NULL otherwise
+@see t1_init_luts
+*/
+opj_t1_t* t1_create(opj_common_ptr cinfo);
+/**
+Destroy a previously created T1 handle
+@param t1 T1 handle to destroy
+*/
+void t1_destroy(opj_t1_t *t1);
+/**
+Encode the code-blocks of a tile
+@param t1 T1 handle
+@param tile The tile to encode
+@param tcp Tile coding parameters
+*/
+void t1_encode_cblks(opj_t1_t *t1, opj_tcd_tile_t *tile, opj_tcp_t *tcp);
+/**
+Decode the code-blocks of a tile
+@param t1 T1 handle
+@param tile The tile to decode
+@param tcp Tile coding parameters
+*/
+void t1_decode_cblks(opj_t1_t *t1, opj_tcd_tile_t *tile, opj_tcp_t *tcp);
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __T1_H */
diff --git a/libraries/openjpeg-libsl/libopenjpeg/t1_generate_luts.c b/libraries/openjpeg-libsl/libopenjpeg/t1_generate_luts.c
new file mode 100644
index 0000000..62cb158
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/t1_generate_luts.c
@@ -0,0 +1,295 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * Copyright (c) 2007, Callum Lerwick <seg@haxxed.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "opj_includes.h"
+#include <math.h>
+
+static int t1_init_ctxno_zc(int f, int orient) {
+        int h, v, d, n, t, hv;
+        n = 0;
+        h = ((f & T1_SIG_W) != 0) + ((f & T1_SIG_E) != 0);
+        v = ((f & T1_SIG_N) != 0) + ((f & T1_SIG_S) != 0);
+        d = ((f & T1_SIG_NW) != 0) + ((f & T1_SIG_NE) != 0) + ((f & T1_SIG_SE) != 0) + ((f & T1_SIG_SW) != 0);
+
+        switch (orient) {
+                case 2:
+                        t = h;
+                        h = v;
+                        v = t;
+                case 0:
+                case 1:
+                        if (!h) {
+                                if (!v) {
+                                        if (!d)
+                                                n = 0;
+                                        else if (d == 1)
+                                                n = 1;
+                                        else
+                                                n = 2;
+                                } else if (v == 1) {
+                                        n = 3;
+                                } else {
+                                        n = 4;
+                                }
+                        } else if (h == 1) {
+                                if (!v) {
+                                        if (!d)
+                                                n = 5;
+                                        else
+                                                n = 6;
+                                } else {
+                                        n = 7;
+                                }
+                        } else
+                                n = 8;
+                        break;
+                case 3:
+                        hv = h + v;
+                        if (!d) {
+                                if (!hv) {
+                                        n = 0;
+                                } else if (hv == 1) {
+                                        n = 1;
+                                } else {
+                                        n = 2;
+                                }
+                        } else if (d == 1) {
+                                if (!hv) {
+                                        n = 3;
+                                } else if (hv == 1) {
+                                        n = 4;
+                                } else {
+                                        n = 5;
+                                }
+                        } else if (d == 2) {
+                                if (!hv) {
+                                        n = 6;
+                                } else {
+                                        n = 7;
+                                }
+                        } else {
+                                n = 8;
+                        }
+                        break;
+        }
+
+        return (T1_CTXNO_ZC + n);
+}
+
+static int t1_init_ctxno_sc(int f) {
+        int hc, vc, n;
+        n = 0;
+
+        hc = int_min(((f & (T1_SIG_E | T1_SGN_E)) ==
+                                T1_SIG_E) + ((f & (T1_SIG_W | T1_SGN_W)) == T1_SIG_W),
+                        1) - int_min(((f & (T1_SIG_E | T1_SGN_E)) ==
+                                        (T1_SIG_E | T1_SGN_E)) +
+                                ((f & (T1_SIG_W | T1_SGN_W)) ==
+                                 (T1_SIG_W | T1_SGN_W)), 1);
+
+        vc = int_min(((f & (T1_SIG_N | T1_SGN_N)) ==
+                                T1_SIG_N) + ((f & (T1_SIG_S | T1_SGN_S)) == T1_SIG_S),
+                        1) - int_min(((f & (T1_SIG_N | T1_SGN_N)) ==
+                                        (T1_SIG_N | T1_SGN_N)) +
+                                ((f & (T1_SIG_S | T1_SGN_S)) ==
+                                 (T1_SIG_S | T1_SGN_S)), 1);
+
+        if (hc < 0) {
+                hc = -hc;
+                vc = -vc;
+        }
+        if (!hc) {
+                if (vc == -1)
+                        n = 1;
+                else if (!vc)
+                        n = 0;
+                else
+                        n = 1;
+        } else if (hc == 1) {
+                if (vc == -1)
+                        n = 2;
+                else if (!vc)
+                        n = 3;
+                else
+                        n = 4;
+        }
+
+        return (T1_CTXNO_SC + n);
+}
+
+static int t1_init_ctxno_mag(int f) {
+        int n;
+        if (!(f & T1_REFINE))
+                n = (f & (T1_SIG_OTH)) ? 1 : 0;
+        else
+                n = 2;
+
+        return (T1_CTXNO_MAG + n);
+}
+
+static int t1_init_spb(int f) {
+        int hc, vc, n;
+
+        hc = int_min(((f & (T1_SIG_E | T1_SGN_E)) ==
+                                T1_SIG_E) + ((f & (T1_SIG_W | T1_SGN_W)) == T1_SIG_W),
+                        1) - int_min(((f & (T1_SIG_E | T1_SGN_E)) ==
+                                        (T1_SIG_E | T1_SGN_E)) +
+                                ((f & (T1_SIG_W | T1_SGN_W)) ==
+                                 (T1_SIG_W | T1_SGN_W)), 1);
+
+        vc = int_min(((f & (T1_SIG_N | T1_SGN_N)) ==
+                                T1_SIG_N) + ((f & (T1_SIG_S | T1_SGN_S)) == T1_SIG_S),
+                        1) - int_min(((f & (T1_SIG_N | T1_SGN_N)) ==
+                                        (T1_SIG_N | T1_SGN_N)) +
+                                ((f & (T1_SIG_S | T1_SGN_S)) ==
+                                 (T1_SIG_S | T1_SGN_S)), 1);
+
+        if (!hc && !vc)
+                n = 0;
+        else
+                n = (!(hc > 0 || (!hc && vc > 0)));
+
+        return n;
+}
+
+void dump_array16(int array[],int size){
+        int i;
+        --size;
+        for (i = 0; i < size; ++i) {
+                printf("0x%04x, ", array[i]);
+                if(!((i+1)&0x7))
+                        printf("\n  ");
+        }
+        printf("0x%04x\n};\n\n", array[size]);
+}
+
+int main(){
+        int i, j;
+        double u, v, t;
+
+        int lut_ctxno_zc[1024];
+        int lut_ctxno_mag[4096];
+        int lut_nmsedec_sig[1 << T1_NMSEDEC_BITS];
+        int lut_nmsedec_sig0[1 << T1_NMSEDEC_BITS];
+        int lut_nmsedec_ref[1 << T1_NMSEDEC_BITS];
+        int lut_nmsedec_ref0[1 << T1_NMSEDEC_BITS];
+
+        printf("/* This file was automatically generated by t1_generate_luts.c */\n\n");
+
+        // lut_ctxno_zc
+        for (j = 0; j < 4; ++j) {
+                for (i = 0; i < 256; ++i) {
+                        lut_ctxno_zc[(j << 8) | i] = t1_init_ctxno_zc(i, j);
+                }
+        }
+
+        printf("static int8_t lut_ctxno_zc[1024] = {\n  ");
+        for (i = 0; i < 1023; ++i) {
+                printf("%i, ", lut_ctxno_zc[i]);
+                if(!((i+1)&0x1f))
+                        printf("\n  ");
+        }
+        printf("%i\n};\n\n", lut_ctxno_zc[1023]);
+
+        // lut_ctxno_sc
+        printf("static int8_t lut_ctxno_sc[256] = {\n  ");
+        for (i = 0; i < 255; ++i) {
+                printf("0x%x, ", t1_init_ctxno_sc(i << 4));
+                if(!((i+1)&0xf))
+                        printf("\n  ");
+        }
+        printf("0x%x\n};\n\n", t1_init_ctxno_sc(255 << 4));
+
+        // lut_ctxno_mag
+        for (j = 0; j < 2; ++j) {
+                for (i = 0; i < 2048; ++i) {
+                        lut_ctxno_mag[(j << 11) + i] = t1_init_ctxno_mag((j ? T1_REFINE : 0) | i);
+                }
+        }
+
+        printf("static int8_t lut_ctxno_mag[4096] = {\n  ");
+        for (i = 0; i < 4095; ++i) {
+                printf("%i, ", lut_ctxno_mag[i]);
+                if(!((i+1)&0xf))
+                        printf("\n  ");
+        }
+        printf("%i\n};\n\n", lut_ctxno_mag[4095]);
+
+        // lut_spb
+        printf("static int8_t lut_spb[256] = {\n  ");
+        for (i = 0; i < 255; ++i) {
+                printf("%i, ", t1_init_spb(i << 4));
+                if(!((i+1)&0x1f))
+                        printf("\n  ");
+        }
+        printf("%i\n};\n\n", t1_init_spb(255 << 4));
+
+        /* FIXME FIXME FIXME */
+        /* fprintf(stdout,"nmsedec luts:\n"); */
+        for (i = 0; i < (1 << T1_NMSEDEC_BITS); ++i) {
+                t = i / pow(2, T1_NMSEDEC_FRACBITS);
+                u = t;
+                v = t - 1.5;
+                lut_nmsedec_sig[i] = 
+                        int_max(0, 
+                                        (int) (floor((u * u - v * v) * pow(2, T1_NMSEDEC_FRACBITS) + 0.5) / pow(2, T1_NMSEDEC_FRACBITS) * 8192.0));
+                lut_nmsedec_sig0[i] =
+                        int_max(0,
+                                        (int) (floor((u * u) * pow(2, T1_NMSEDEC_FRACBITS) + 0.5) / pow(2, T1_NMSEDEC_FRACBITS) * 8192.0));
+                u = t - 1.0;
+                if (i & (1 << (T1_NMSEDEC_BITS - 1))) {
+                        v = t - 1.5;
+                } else {
+                        v = t - 0.5;
+                }
+                lut_nmsedec_ref[i] =
+                        int_max(0,
+                                        (int) (floor((u * u - v * v) * pow(2, T1_NMSEDEC_FRACBITS) + 0.5) / pow(2, T1_NMSEDEC_FRACBITS) * 8192.0));
+                lut_nmsedec_ref0[i] =
+                        int_max(0,
+                                        (int) (floor((u * u) * pow(2, T1_NMSEDEC_FRACBITS) + 0.5) / pow(2, T1_NMSEDEC_FRACBITS) * 8192.0));
+        }
+
+        printf("static int16_t lut_nmsedec_sig[1 << T1_NMSEDEC_BITS] = {\n  ");
+        dump_array16(&lut_nmsedec_sig, 1 << T1_NMSEDEC_BITS);
+
+        printf("static int16_t lut_nmsedec_sig0[1 << T1_NMSEDEC_BITS] = {\n  ");
+        dump_array16(&lut_nmsedec_sig0, 1 << T1_NMSEDEC_BITS);
+
+        printf("static int16_t lut_nmsedec_ref[1 << T1_NMSEDEC_BITS] = {\n  ");
+        dump_array16(&lut_nmsedec_ref, 1 << T1_NMSEDEC_BITS);
+
+        printf("static int16_t lut_nmsedec_ref0[1 << T1_NMSEDEC_BITS] = {\n  ");
+        dump_array16(&lut_nmsedec_ref0, 1 << T1_NMSEDEC_BITS);
+
+        return 0;
+}
diff --git a/libraries/openjpeg-libsl/libopenjpeg/t1_luts.h b/libraries/openjpeg-libsl/libopenjpeg/t1_luts.h
new file mode 100644
index 0000000..3f957f3
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/t1_luts.h
@@ -0,0 +1,402 @@
+/* This file was automatically generated by t1_generate_luts.c */
+
+static char lut_ctxno_zc[1024] = {
+  0, 1, 1, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 
+  5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
+  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
+  7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
+  5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
+  8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+  7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
+  8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+  0, 1, 1, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 
+  5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
+  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
+  7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
+  5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
+  8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+  7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
+  8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+  0, 1, 1, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 
+  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
+  5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+  7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
+  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
+  7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+  7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+  0, 3, 3, 6, 3, 6, 6, 8, 3, 6, 6, 8, 6, 8, 8, 8, 1, 4, 4, 7, 4, 7, 7, 8, 4, 7, 7, 8, 7, 8, 8, 8, 
+  1, 4, 4, 7, 4, 7, 7, 8, 4, 7, 7, 8, 7, 8, 8, 8, 2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8, 
+  1, 4, 4, 7, 4, 7, 7, 8, 4, 7, 7, 8, 7, 8, 8, 8, 2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8, 
+  2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8, 2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8, 
+  1, 4, 4, 7, 4, 7, 7, 8, 4, 7, 7, 8, 7, 8, 8, 8, 2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8, 
+  2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8, 2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8, 
+  2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8, 2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8, 
+  2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8, 2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8
+};
+
+static char lut_ctxno_sc[256] = {
+  0x9, 0xa, 0xc, 0xd, 0xa, 0xa, 0xd, 0xd, 0xc, 0xd, 0xc, 0xd, 0xd, 0xd, 0xd, 0xd, 
+  0x9, 0xa, 0xc, 0xb, 0xa, 0x9, 0xd, 0xc, 0xc, 0xb, 0xc, 0xb, 0xd, 0xc, 0xd, 0xc, 
+  0x9, 0xa, 0xc, 0xb, 0xa, 0xa, 0xb, 0xb, 0xc, 0xd, 0x9, 0xa, 0xd, 0xd, 0xa, 0xa, 
+  0x9, 0xa, 0xc, 0xd, 0xa, 0x9, 0xb, 0xc, 0xc, 0xb, 0x9, 0xa, 0xd, 0xc, 0xa, 0x9, 
+  0x9, 0xa, 0xc, 0xd, 0xa, 0x9, 0xb, 0xc, 0xc, 0xd, 0xc, 0xd, 0xb, 0xc, 0xb, 0xc, 
+  0x9, 0xa, 0xc, 0xb, 0xa, 0xa, 0xb, 0xb, 0xc, 0xb, 0xc, 0xb, 0xb, 0xb, 0xb, 0xb, 
+  0x9, 0xa, 0xc, 0xb, 0xa, 0x9, 0xd, 0xc, 0xc, 0xd, 0x9, 0xa, 0xb, 0xc, 0xa, 0x9, 
+  0x9, 0xa, 0xc, 0xd, 0xa, 0xa, 0xd, 0xd, 0xc, 0xb, 0x9, 0xa, 0xb, 0xb, 0xa, 0xa, 
+  0x9, 0xa, 0xc, 0xd, 0xa, 0xa, 0xd, 0xd, 0xc, 0xb, 0x9, 0xa, 0xb, 0xb, 0xa, 0xa, 
+  0x9, 0xa, 0xc, 0xb, 0xa, 0x9, 0xd, 0xc, 0xc, 0xd, 0x9, 0xa, 0xb, 0xc, 0xa, 0x9, 
+  0x9, 0xa, 0xc, 0xb, 0xa, 0xa, 0xb, 0xb, 0xc, 0xb, 0xc, 0xb, 0xb, 0xb, 0xb, 0xb, 
+  0x9, 0xa, 0xc, 0xd, 0xa, 0x9, 0xb, 0xc, 0xc, 0xd, 0xc, 0xd, 0xb, 0xc, 0xb, 0xc, 
+  0x9, 0xa, 0xc, 0xd, 0xa, 0x9, 0xb, 0xc, 0xc, 0xb, 0x9, 0xa, 0xd, 0xc, 0xa, 0x9, 
+  0x9, 0xa, 0xc, 0xb, 0xa, 0xa, 0xb, 0xb, 0xc, 0xd, 0x9, 0xa, 0xd, 0xd, 0xa, 0xa, 
+  0x9, 0xa, 0xc, 0xb, 0xa, 0x9, 0xd, 0xc, 0xc, 0xb, 0xc, 0xb, 0xd, 0xc, 0xd, 0xc, 
+  0x9, 0xa, 0xc, 0xd, 0xa, 0xa, 0xd, 0xd, 0xc, 0xd, 0xc, 0xd, 0xd, 0xd, 0xd, 0xd
+};
+
+static char lut_ctxno_mag[4096] = {
+  14, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  14, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  14, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  14, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  14, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  14, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  14, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  14, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16
+};
+
+static char lut_spb[256] = {
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 
+  0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 
+  0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 
+  0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
+  0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 
+  0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
+};
+
+static short lut_nmsedec_sig[1 << T1_NMSEDEC_BITS] = {
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+  0x0000, 0x0180, 0x0300, 0x0480, 0x0600, 0x0780, 0x0900, 0x0a80, 
+  0x0c00, 0x0d80, 0x0f00, 0x1080, 0x1200, 0x1380, 0x1500, 0x1680, 
+  0x1800, 0x1980, 0x1b00, 0x1c80, 0x1e00, 0x1f80, 0x2100, 0x2280, 
+  0x2400, 0x2580, 0x2700, 0x2880, 0x2a00, 0x2b80, 0x2d00, 0x2e80, 
+  0x3000, 0x3180, 0x3300, 0x3480, 0x3600, 0x3780, 0x3900, 0x3a80, 
+  0x3c00, 0x3d80, 0x3f00, 0x4080, 0x4200, 0x4380, 0x4500, 0x4680, 
+  0x4800, 0x4980, 0x4b00, 0x4c80, 0x4e00, 0x4f80, 0x5100, 0x5280, 
+  0x5400, 0x5580, 0x5700, 0x5880, 0x5a00, 0x5b80, 0x5d00, 0x5e80, 
+  0x6000, 0x6180, 0x6300, 0x6480, 0x6600, 0x6780, 0x6900, 0x6a80, 
+  0x6c00, 0x6d80, 0x6f00, 0x7080, 0x7200, 0x7380, 0x7500, 0x7680
+};
+
+static short lut_nmsedec_sig0[1 << T1_NMSEDEC_BITS] = {
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0080, 0x0080, 
+  0x0080, 0x0080, 0x0100, 0x0100, 0x0100, 0x0180, 0x0180, 0x0200, 
+  0x0200, 0x0280, 0x0280, 0x0300, 0x0300, 0x0380, 0x0400, 0x0400, 
+  0x0480, 0x0500, 0x0580, 0x0580, 0x0600, 0x0680, 0x0700, 0x0780, 
+  0x0800, 0x0880, 0x0900, 0x0980, 0x0a00, 0x0a80, 0x0b80, 0x0c00, 
+  0x0c80, 0x0d00, 0x0e00, 0x0e80, 0x0f00, 0x1000, 0x1080, 0x1180, 
+  0x1200, 0x1300, 0x1380, 0x1480, 0x1500, 0x1600, 0x1700, 0x1780, 
+  0x1880, 0x1980, 0x1a80, 0x1b00, 0x1c00, 0x1d00, 0x1e00, 0x1f00, 
+  0x2000, 0x2100, 0x2200, 0x2300, 0x2400, 0x2500, 0x2680, 0x2780, 
+  0x2880, 0x2980, 0x2b00, 0x2c00, 0x2d00, 0x2e80, 0x2f80, 0x3100, 
+  0x3200, 0x3380, 0x3480, 0x3600, 0x3700, 0x3880, 0x3a00, 0x3b00, 
+  0x3c80, 0x3e00, 0x3f80, 0x4080, 0x4200, 0x4380, 0x4500, 0x4680, 
+  0x4800, 0x4980, 0x4b00, 0x4c80, 0x4e00, 0x4f80, 0x5180, 0x5300, 
+  0x5480, 0x5600, 0x5800, 0x5980, 0x5b00, 0x5d00, 0x5e80, 0x6080, 
+  0x6200, 0x6400, 0x6580, 0x6780, 0x6900, 0x6b00, 0x6d00, 0x6e80, 
+  0x7080, 0x7280, 0x7480, 0x7600, 0x7800, 0x7a00, 0x7c00, 0x7e00
+};
+
+static short lut_nmsedec_ref[1 << T1_NMSEDEC_BITS] = {
+  0x1800, 0x1780, 0x1700, 0x1680, 0x1600, 0x1580, 0x1500, 0x1480, 
+  0x1400, 0x1380, 0x1300, 0x1280, 0x1200, 0x1180, 0x1100, 0x1080, 
+  0x1000, 0x0f80, 0x0f00, 0x0e80, 0x0e00, 0x0d80, 0x0d00, 0x0c80, 
+  0x0c00, 0x0b80, 0x0b00, 0x0a80, 0x0a00, 0x0980, 0x0900, 0x0880, 
+  0x0800, 0x0780, 0x0700, 0x0680, 0x0600, 0x0580, 0x0500, 0x0480, 
+  0x0400, 0x0380, 0x0300, 0x0280, 0x0200, 0x0180, 0x0100, 0x0080, 
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+  0x0000, 0x0080, 0x0100, 0x0180, 0x0200, 0x0280, 0x0300, 0x0380, 
+  0x0400, 0x0480, 0x0500, 0x0580, 0x0600, 0x0680, 0x0700, 0x0780, 
+  0x0800, 0x0880, 0x0900, 0x0980, 0x0a00, 0x0a80, 0x0b00, 0x0b80, 
+  0x0c00, 0x0c80, 0x0d00, 0x0d80, 0x0e00, 0x0e80, 0x0f00, 0x0f80, 
+  0x1000, 0x1080, 0x1100, 0x1180, 0x1200, 0x1280, 0x1300, 0x1380, 
+  0x1400, 0x1480, 0x1500, 0x1580, 0x1600, 0x1680, 0x1700, 0x1780
+};
+
+static short lut_nmsedec_ref0[1 << T1_NMSEDEC_BITS] = {
+  0x2000, 0x1f00, 0x1e00, 0x1d00, 0x1c00, 0x1b00, 0x1a80, 0x1980, 
+  0x1880, 0x1780, 0x1700, 0x1600, 0x1500, 0x1480, 0x1380, 0x1300, 
+  0x1200, 0x1180, 0x1080, 0x1000, 0x0f00, 0x0e80, 0x0e00, 0x0d00, 
+  0x0c80, 0x0c00, 0x0b80, 0x0a80, 0x0a00, 0x0980, 0x0900, 0x0880, 
+  0x0800, 0x0780, 0x0700, 0x0680, 0x0600, 0x0580, 0x0580, 0x0500, 
+  0x0480, 0x0400, 0x0400, 0x0380, 0x0300, 0x0300, 0x0280, 0x0280, 
+  0x0200, 0x0200, 0x0180, 0x0180, 0x0100, 0x0100, 0x0100, 0x0080, 
+  0x0080, 0x0080, 0x0080, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0080, 0x0080, 
+  0x0080, 0x0080, 0x0100, 0x0100, 0x0100, 0x0180, 0x0180, 0x0200, 
+  0x0200, 0x0280, 0x0280, 0x0300, 0x0300, 0x0380, 0x0400, 0x0400, 
+  0x0480, 0x0500, 0x0580, 0x0580, 0x0600, 0x0680, 0x0700, 0x0780, 
+  0x0800, 0x0880, 0x0900, 0x0980, 0x0a00, 0x0a80, 0x0b80, 0x0c00, 
+  0x0c80, 0x0d00, 0x0e00, 0x0e80, 0x0f00, 0x1000, 0x1080, 0x1180, 
+  0x1200, 0x1300, 0x1380, 0x1480, 0x1500, 0x1600, 0x1700, 0x1780, 
+  0x1880, 0x1980, 0x1a80, 0x1b00, 0x1c00, 0x1d00, 0x1e00, 0x1f00
+};
+
diff --git a/libraries/openjpeg-libsl/libopenjpeg/t2.c b/libraries/openjpeg-libsl/libopenjpeg/t2.c
new file mode 100644
index 0000000..dc8e24e
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/t2.c
@@ -0,0 +1,721 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "opj_includes.h"
+
+/** @defgroup T2 T2 - Implementation of a tier-2 coding */
+/*@{*/
+
+/** @name Local static functions */
+/*@{*/
+
+static void t2_putcommacode(opj_bio_t *bio, int n);
+static int t2_getcommacode(opj_bio_t *bio);
+/**
+Variable length code for signalling delta Zil (truncation point)
+@param bio Bit Input/Output component
+@param n delta Zil
+*/
+static void t2_putnumpasses(opj_bio_t *bio, int n);
+static int t2_getnumpasses(opj_bio_t *bio);
+/**
+Encode a packet of a tile to a destination buffer
+@param tile Tile for which to write the packets
+@param tcp Tile coding parameters
+@param pi Packet identity
+@param dest Destination buffer
+@param len Length of the destination buffer
+@param image_info Structure to create an index file
+@param tileno Number of the tile encoded
+@return 
+*/
+static int t2_encode_packet(opj_tcd_tile_t *tile, opj_tcp_t *tcp, opj_pi_iterator_t *pi, unsigned char *dest, int len, opj_image_info_t *image_info, int tileno);
+/**
+@param seg
+@param cblksty
+@param first
+*/
+static void t2_init_seg(opj_tcd_seg_t *seg, int cblksty, int first);
+/**
+Decode a packet of a tile from a source buffer
+@param t2 T2 handle
+@param src Source buffer
+@param len Length of the source buffer
+@param tile Tile for which to write the packets
+@param tcp Tile coding parameters
+@param pi Packet identity
+@return 
+*/
+static int t2_decode_packet(opj_t2_t* t2, unsigned char *src, int len, opj_tcd_tile_t *tile, opj_tcp_t *tcp, opj_pi_iterator_t *pi);
+
+/*@}*/
+
+/*@}*/
+
+/* ----------------------------------------------------------------------- */
+
+/* #define RESTART 0x04 */
+
+static void t2_putcommacode(opj_bio_t *bio, int n) {
+        while (--n >= 0) {
+                bio_write(bio, 1, 1);
+        }
+        bio_write(bio, 0, 1);
+}
+
+static int t2_getcommacode(opj_bio_t *bio) {
+        int n;
+        for (n = 0; bio_read(bio, 1); n++) {
+                ;
+        }
+        return n;
+}
+
+static void t2_putnumpasses(opj_bio_t *bio, int n) {
+        if (n == 1) {
+                bio_write(bio, 0, 1);
+        } else if (n == 2) {
+                bio_write(bio, 2, 2);
+        } else if (n <= 5) {
+                bio_write(bio, 0xc | (n - 3), 4);
+        } else if (n <= 36) {
+                bio_write(bio, 0x1e0 | (n - 6), 9);
+        } else if (n <= 164) {
+                bio_write(bio, 0xff80 | (n - 37), 16);
+        }
+}
+
+static int t2_getnumpasses(opj_bio_t *bio) {
+        int n;
+        if (!bio_read(bio, 1))
+                return 1;
+        if (!bio_read(bio, 1))
+                return 2;
+        if ((n = bio_read(bio, 2)) != 3)
+                return (3 + n);
+        if ((n = bio_read(bio, 5)) != 31)
+                return (6 + n);
+        return (37 + bio_read(bio, 7));
+}
+
+static int t2_encode_packet(opj_tcd_tile_t * tile, opj_tcp_t * tcp, opj_pi_iterator_t *pi, unsigned char *dest, int length, opj_image_info_t * image_info, int tileno) {
+        int bandno, cblkno;
+        unsigned char *sop = 0, *eph = 0;
+        unsigned char *c = dest;
+
+        int compno = pi->compno;        /* component value */
+        int resno  = pi->resno;         /* resolution level value */
+        int precno = pi->precno;        /* precinct value */
+        int layno  = pi->layno;         /* quality layer value */
+
+        opj_tcd_tilecomp_t *tilec = &tile->comps[compno];
+        opj_tcd_resolution_t *res = &tilec->resolutions[resno];
+        
+        opj_bio_t *bio = NULL;  /* BIO component */
+        
+        /* <SOP 0xff91> */
+        if (tcp->csty & J2K_CP_CSTY_SOP) {
+                sop = (unsigned char *) opj_malloc(6 * sizeof(unsigned char));
+                sop[0] = 255;
+                sop[1] = 145;
+                sop[2] = 0;
+                sop[3] = 4;
+                sop[4] = (image_info->num % 65536) / 256;
+                sop[5] = (image_info->num % 65536) % 256;
+                memcpy(c, sop, 6);
+                opj_free(sop);
+                c += 6;
+        }
+        /* </SOP> */
+        
+        if (!layno) {
+                for (bandno = 0; bandno < res->numbands; bandno++) {
+                        opj_tcd_band_t *band = &res->bands[bandno];
+                        opj_tcd_precinct_t *prc = &band->precincts[precno];
+                        tgt_reset(prc->incltree);
+                        tgt_reset(prc->imsbtree);
+                        for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
+                                opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
+                                cblk->numpasses = 0;
+                                tgt_setvalue(prc->imsbtree, cblkno, band->numbps - cblk->numbps);
+                        }
+                }
+        }
+        
+        bio = bio_create();
+        bio_init_enc(bio, c, length);
+        bio_write(bio, 1, 1);           /* Empty header bit */
+        
+        /* Writing Packet header */
+        for (bandno = 0; bandno < res->numbands; bandno++) {
+                opj_tcd_band_t *band = &res->bands[bandno];
+                opj_tcd_precinct_t *prc = &band->precincts[precno];
+                for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
+                        opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
+                        opj_tcd_layer_t *layer = &cblk->layers[layno];
+                        if (!cblk->numpasses && layer->numpasses) {
+                                tgt_setvalue(prc->incltree, cblkno, layno);
+                        }
+                }
+                for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
+                        opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
+                        opj_tcd_layer_t *layer = &cblk->layers[layno];
+                        int increment = 0;
+                        int nump = 0;
+                        int len = 0, passno;
+                        /* cblk inclusion bits */
+                        if (!cblk->numpasses) {
+                                tgt_encode(bio, prc->incltree, cblkno, layno + 1);
+                        } else {
+                                bio_write(bio, layer->numpasses != 0, 1);
+                        }
+                        /* if cblk not included, go to the next cblk  */
+                        if (!layer->numpasses) {
+                                continue;
+                        }
+                        /* if first instance of cblk --> zero bit-planes information */
+                        if (!cblk->numpasses) {
+                                cblk->numlenbits = 3;
+                                tgt_encode(bio, prc->imsbtree, cblkno, 999);
+                        }
+                        /* number of coding passes included */
+                        t2_putnumpasses(bio, layer->numpasses);
+                        
+                        /* computation of the increase of the length indicator and insertion in the header     */
+                        for (passno = cblk->numpasses; passno < cblk->numpasses + layer->numpasses; passno++) {
+                                opj_tcd_pass_t *pass = &cblk->passes[passno];
+                                nump++;
+                                len += pass->len;
+                                if (pass->term || passno == (cblk->numpasses + layer->numpasses) - 1) {
+                                        increment = int_max(increment, int_floorlog2(len) + 1 - (cblk->numlenbits + int_floorlog2(nump)));
+                                        len = 0;
+                                        nump = 0;
+                                }
+                        }
+                        t2_putcommacode(bio, increment);
+
+                        /* computation of the new Length indicator */
+                        cblk->numlenbits += increment;
+
+                        /* insertion of the codeword segment length */
+                        for (passno = cblk->numpasses; passno < cblk->numpasses + layer->numpasses; passno++) {
+                                opj_tcd_pass_t *pass = &cblk->passes[passno];
+                                nump++;
+                                len += pass->len;
+                                if (pass->term || passno == (cblk->numpasses + layer->numpasses) - 1) {
+                                        bio_write(bio, len, cblk->numlenbits + int_floorlog2(nump));
+                                        len = 0;
+                                        nump = 0;
+                                }
+                        }
+                }
+        }
+        
+        if (bio_flush(bio)) {
+                return -999;            /* modified to eliminate longjmp !! */
+        }
+        
+        c += bio_numbytes(bio);
+
+        bio_destroy(bio);
+        
+        /* <EPH 0xff92> */
+        if (tcp->csty & J2K_CP_CSTY_EPH) {
+                eph = (unsigned char *) opj_malloc(2 * sizeof(unsigned char));
+                eph[0] = 255;
+                eph[1] = 146;
+                memcpy(c, eph, 2);
+                opj_free(eph);
+                c += 2;
+        }
+        /* </EPH> */
+        
+        /* Writing the packet body */
+        
+        for (bandno = 0; bandno < res->numbands; bandno++) {
+                opj_tcd_band_t *band = &res->bands[bandno];
+                opj_tcd_precinct_t *prc = &band->precincts[precno];
+                for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
+                        opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
+                        opj_tcd_layer_t *layer = &cblk->layers[layno];
+                        if (!layer->numpasses) {
+                                continue;
+                        }
+                        if (c + layer->len > dest + length) {
+                                return -999;
+                        }
+                        
+                        memcpy(c, layer->data, layer->len);
+                        cblk->numpasses += layer->numpasses;
+                        c += layer->len;
+                        /* ADD for index Cfr. Marcela --> delta disto by packet */
+                        if(image_info && image_info->index_write && image_info->index_on) {
+                                opj_tile_info_t *info_TL = &image_info->tile[tileno];
+                                opj_packet_info_t *info_PK = &info_TL->packet[image_info->num];
+                                info_PK->disto += layer->disto;
+                                if (image_info->D_max < info_PK->disto) {
+                                        image_info->D_max = info_PK->disto;
+                                }
+                        }
+                        /* </ADD> */
+                }
+        }
+        
+        return (c - dest);
+}
+
+static void t2_init_seg(opj_tcd_seg_t * seg, int cblksty, int first) {
+        seg->numpasses = 0;
+        seg->len = 0;
+        if (cblksty & J2K_CCP_CBLKSTY_TERMALL) {
+                seg->maxpasses = 1;
+        }
+        else if (cblksty & J2K_CCP_CBLKSTY_LAZY) {
+                if (first) {
+                        seg->maxpasses = 10;
+                } else {
+                        seg->maxpasses = (((seg - 1)->maxpasses == 1) || ((seg - 1)->maxpasses == 10)) ? 2 : 1;
+                }
+        } else {
+                seg->maxpasses = 109;
+        }
+}
+
+static int t2_decode_packet(opj_t2_t* t2, unsigned char *src, int len, opj_tcd_tile_t *tile, opj_tcp_t *tcp, opj_pi_iterator_t *pi) {
+        int bandno, cblkno;
+        unsigned char *c = src;
+
+        opj_cp_t *cp = t2->cp;
+
+        int compno = pi->compno;        /* component value */
+        int resno  = pi->resno;         /* resolution level value */
+        int precno = pi->precno;        /* precinct value */
+        int layno  = pi->layno;         /* quality layer value */
+
+        opj_tcd_tilecomp_t *tilec = &tile->comps[compno];
+        opj_tcd_resolution_t *res = &tilec->resolutions[resno];
+        
+        unsigned char *hd = NULL;
+        int present;
+        
+        opj_bio_t *bio = NULL;  /* BIO component */
+        
+        if (layno == 0) {
+                for (bandno = 0; bandno < res->numbands; bandno++) {
+                        opj_tcd_band_t *band = &res->bands[bandno];
+                        opj_tcd_precinct_t *prc = &band->precincts[precno];
+                        
+                        if ((band->x1-band->x0 == 0)||(band->y1-band->y0 == 0)) continue;
+                        
+                        tgt_reset(prc->incltree);
+                        tgt_reset(prc->imsbtree);
+                        for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
+                                opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
+                                cblk->numsegs = 0;
+                        }
+                }
+        }
+        
+        /* SOP markers */
+        
+        if (tcp->csty & J2K_CP_CSTY_SOP) {
+                if ((*c) != 0xff || (*(c + 1) != 0x91)) {
+                        opj_event_msg(t2->cinfo, EVT_WARNING, "Expected SOP marker\n");
+                } else {
+                        c += 6;
+                }
+                
+                /** TODO : check the Nsop value */
+        }
+        
+        /* 
+        When the marker PPT/PPM is used the packet header are store in PPT/PPM marker
+        This part deal with this caracteristic
+        step 1: Read packet header in the saved structure
+        step 2: Return to codestream for decoding 
+        */
+
+        bio = bio_create();
+        
+        if (cp->ppm == 1) {             /* PPM */
+                hd = cp->ppm_data;
+                bio_init_dec(bio, hd, cp->ppm_len);
+        } else if (tcp->ppt == 1) {     /* PPT */
+                hd = tcp->ppt_data;
+                bio_init_dec(bio, hd, tcp->ppt_len);
+        } else {                        /* Normal Case */
+                hd = c;
+                bio_init_dec(bio, hd, src+len-hd);
+        }
+        
+        present = bio_read(bio, 1);
+        
+        if (!present) {
+                bio_inalign(bio);
+                hd += bio_numbytes(bio);
+                bio_destroy(bio);
+                
+                /* EPH markers */
+                
+                if (tcp->csty & J2K_CP_CSTY_EPH) {
+                        if ((*hd) != 0xff || (*(hd + 1) != 0x92)) {
+                                printf("Error : expected EPH marker\n");
+                        } else {
+                                hd += 2;
+                        }
+                }
+                
+                if (cp->ppm == 1) {             /* PPM case */
+                        cp->ppm_len += cp->ppm_data-hd;
+                        cp->ppm_data = hd;
+                        return (c - src);
+                }
+                if (tcp->ppt == 1) {    /* PPT case */
+                        tcp->ppt_len+=tcp->ppt_data-hd;
+                        tcp->ppt_data = hd;
+                        return (c - src);
+                }
+                
+                return (hd - src);
+        }
+        
+        for (bandno = 0; bandno < res->numbands; bandno++) {
+                opj_tcd_band_t *band = &res->bands[bandno];
+                opj_tcd_precinct_t *prc = &band->precincts[precno];
+                
+                if ((band->x1-band->x0 == 0)||(band->y1-band->y0 == 0)) continue;
+                
+                for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
+                        int included, increment, n;
+                        opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
+                        opj_tcd_seg_t *seg = NULL;
+                        /* if cblk not yet included before --> inclusion tagtree */
+                        if (!cblk->numsegs) {
+                                included = tgt_decode(bio, prc->incltree, cblkno, layno + 1);
+                                /* else one bit */
+                        } else {
+                                included = bio_read(bio, 1);
+                        }
+                        /* if cblk not included */
+                        if (!included) {
+                                cblk->numnewpasses = 0;
+                                continue;
+                        }
+                        /* if cblk not yet included --> zero-bitplane tagtree */
+                        if (!cblk->numsegs) {
+                                int i, numimsbs;
+                                for (i = 0; !tgt_decode(bio, prc->imsbtree, cblkno, i); i++) {
+                                        ;
+                                }
+                                numimsbs = i - 1;
+                                cblk->numbps = band->numbps - numimsbs;
+                                cblk->numlenbits = 3;
+                        }
+                        /* number of coding passes */
+                        cblk->numnewpasses = t2_getnumpasses(bio);
+                        increment = t2_getcommacode(bio);
+                        /* length indicator increment */
+                        cblk->numlenbits += increment;
+                        if (!cblk->numsegs) {
+                                seg = &cblk->segs[0];
+                                t2_init_seg(seg, tcp->tccps[compno].cblksty, 1);
+                        } else {
+                                seg = &cblk->segs[cblk->numsegs - 1];
+                                if (seg->numpasses == seg->maxpasses) {
+                                        t2_init_seg(++seg, tcp->tccps[compno].cblksty, 0);
+                                }
+                        }
+                        n = cblk->numnewpasses;
+                        
+                        do {
+                                seg->numnewpasses = int_min(seg->maxpasses - seg->numpasses, n);
+                                seg->newlen = bio_read(bio, cblk->numlenbits + int_floorlog2(seg->numnewpasses));
+                                n -= seg->numnewpasses;
+                                if (n > 0) {
+                                        t2_init_seg(++seg, tcp->tccps[compno].cblksty, 0);
+                                }
+                        } while (n > 0);
+                }
+        }
+        
+        if (bio_inalign(bio)) {
+                bio_destroy(bio);
+                return -999;
+        }
+        
+        hd += bio_numbytes(bio);
+        bio_destroy(bio);
+        
+        /* EPH markers */
+        if (tcp->csty & J2K_CP_CSTY_EPH) {
+                if ((*hd) != 0xff || (*(hd + 1) != 0x92)) {
+                        opj_event_msg(t2->cinfo, EVT_ERROR, "Expected EPH marker\n");
+                } else {
+                        hd += 2;
+                }
+        }
+        
+        if (cp->ppm==1) {
+                cp->ppm_len+=cp->ppm_data-hd;
+                cp->ppm_data = hd;
+        } else if (tcp->ppt == 1) {
+                tcp->ppt_len+=tcp->ppt_data-hd;
+                tcp->ppt_data = hd;
+        } else {
+                c=hd;
+        }
+        
+        for (bandno = 0; bandno < res->numbands; bandno++) {
+                opj_tcd_band_t *band = &res->bands[bandno];
+                opj_tcd_precinct_t *prc = &band->precincts[precno];
+                
+                if ((band->x1-band->x0 == 0)||(band->y1-band->y0 == 0)) continue;
+                
+                for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
+                        opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
+                        opj_tcd_seg_t *seg = NULL;
+                        if (!cblk->numnewpasses)
+                                continue;
+                        if (!cblk->numsegs) {
+                                seg = &cblk->segs[0];
+                                cblk->numsegs++;
+                                cblk->len = 0;
+                        } else {
+                                seg = &cblk->segs[cblk->numsegs - 1];
+                                if (seg->numpasses == seg->maxpasses) {
+                                        seg++;
+                                        cblk->numsegs++;
+                                }
+                        }
+                        
+                        do {
+                                if (c + seg->newlen > src + len) {
+                                        return -999;
+                                }
+
+#ifdef USE_JPWL
+                        /* we need here a j2k handle to verify if making a check to
+                        the validity of cblocks parameters is selected from user (-W) */
+
+                                /* let's check that we are not exceeding */
+                                if ((cblk->len + seg->newlen) > 8192) {
+                                        opj_event_msg(t2->cinfo, EVT_WARNING,
+                                                "JPWL: segment too long (%d) for codeblock %d (p=%d, b=%d, r=%d, c=%d)\n",
+                                                seg->newlen, cblkno, precno, bandno, resno, compno);
+                                        if (!JPWL_ASSUME) {
+                                                opj_event_msg(t2->cinfo, EVT_ERROR, "JPWL: giving up\n");
+                                                return -999;
+                                        }
+                                        seg->newlen = 8192 - cblk->len;
+                                        opj_event_msg(t2->cinfo, EVT_WARNING, "      - truncating segment to %d\n", seg->newlen);
+                                        break;
+                                };
+
+#endif /* USE_JPWL */
+                                
+                                memcpy(cblk->data + cblk->len, c, seg->newlen);
+                                if (seg->numpasses == 0) {
+                                        seg->data = cblk->data + cblk->len;
+                                }
+                                c += seg->newlen;
+                                cblk->len += seg->newlen;
+                                seg->len += seg->newlen;
+                                seg->numpasses += seg->numnewpasses;
+                                cblk->numnewpasses -= seg->numnewpasses;
+                                if (cblk->numnewpasses > 0) {
+                                        seg++;
+                                        cblk->numsegs++;
+                                }
+                        } while (cblk->numnewpasses > 0);
+                }
+        }
+        
+        return (c - src);
+}
+
+/* ----------------------------------------------------------------------- */
+
+int t2_encode_packets(opj_t2_t* t2,int tileno, opj_tcd_tile_t *tile, int maxlayers, unsigned char *dest, int len, opj_image_info_t *image_info,int tpnum, int tppos,int pino, J2K_T2_MODE t2_mode){
+        unsigned char *c = dest;
+        int e = 0;
+        int compno;
+        int comp_len = 0;
+        opj_pi_iterator_t *pi = NULL;
+        int poc;
+        opj_image_t *image = t2->image;
+        opj_cp_t *cp = t2->cp;
+        int pocno = cp->cinema == CINEMA4K_24? 2: 1;
+        int maxcomp = cp->max_comp_size > 0 ? image->numcomps : 1;
+        
+        pi = pi_initialise_encode(image, cp, tileno, t2_mode);
+        if(!pi) {
+                /* TODO: throw an error */
+                return -999;
+        }
+        
+        if(image_info) {
+                image_info->num = 0;
+        }
+        
+        if(t2_mode == THRESH_CALC ){
+                for(compno = 0; compno < maxcomp; compno++ ){
+                        for(poc = 0; poc < pocno ; poc++){
+                                int comp_len = 0;
+                                int tpnum = compno;
+                                pi_create_encode(pi, cp,tileno,poc,tpnum,tppos); 
+                                while (pi_next(&pi[poc])) {
+                                        if (pi[poc].layno < maxlayers) {
+                                                e = t2_encode_packet(tile, &cp->tcps[tileno], &pi[poc], c, dest + len - c, image_info, tileno);
+                                                comp_len = comp_len + e;
+                                                if (e == -999) {
+                                                        break;
+                                                } else {
+                                                        c += e;
+                                                }
+                                        }
+                                }
+                                if (e == -999) break;
+                                if (cp->max_comp_size){
+                                        if (comp_len > cp->max_comp_size){
+                                                                e = -999;
+                                                                break;
+                                        }
+                                }
+                        }
+                        if (e == -999)  break;
+                }
+        }else{
+                pi_create_encode(pi, cp,tileno,pino,tpnum,tppos); 
+                while (pi_next(&pi[pino])) {
+                        if (pi[pino].layno < maxlayers) {
+                                e = t2_encode_packet(tile, &cp->tcps[tileno], &pi[pino], c, dest + len - c, image_info, tileno);
+                                if (e == -999) {
+                                        break;
+                                } else {
+                                        c += e;
+                                }
+                        }
+                }
+        }
+
+                /* INDEX >> */
+                if(image_info && image_info->index_on) {
+                                if(image_info->index_write) {
+                                        opj_tile_info_t *info_TL = &image_info->tile[tileno];
+                                        opj_packet_info_t *info_PK = &info_TL->packet[image_info->num];
+                                        if (!image_info->num) {
+                                                info_PK->start_pos = info_TL->end_header + 1;
+                                        } else {
+                                                info_PK->start_pos = info_TL->packet[image_info->num - 1].end_pos + 1;
+                                        }
+                                        info_PK->end_pos = info_PK->start_pos + e - 1;
+                                }
+
+                                image_info->num++;
+                        }
+                /* << INDEX */
+                pi_destroy(pi, cp, tileno);
+        
+        if (e == -999) {
+                return e;
+        }
+
+    return (c - dest);
+}
+
+int t2_decode_packets(opj_t2_t *t2, unsigned char *src, int len, int tileno, opj_tcd_tile_t *tile) {
+        unsigned char *c = src;
+        opj_pi_iterator_t *pi;
+        int pino, e = 0;
+        int n = 0;
+
+        opj_image_t *image = t2->image;
+        opj_cp_t *cp = t2->cp;
+        
+        /* create a packet iterator */
+        pi = pi_create_decode(image, cp, tileno);
+        if(!pi) {
+                /* TODO: throw an error */
+                return -999;
+        }
+        
+        for (pino = 0; pino <= cp->tcps[tileno].numpocs; pino++) {
+                while (pi_next(&pi[pino])) {
+                        if ((cp->layer==0) || (cp->layer>=((pi[pino].layno)+1))) {
+                                e = t2_decode_packet(t2, c, src + len - c, tile, &cp->tcps[tileno], &pi[pino]);
+                        } else {
+                                e = 0;
+                        }
+                        
+                        /* progression in resolution */
+                        image->comps[pi[pino].compno].resno_decoded =   
+                                (e > 0) ? 
+                                int_max(pi[pino].resno, image->comps[pi[pino].compno].resno_decoded) 
+                                : image->comps[pi[pino].compno].resno_decoded;
+                        n++;
+                        
+                        if (e == -999) {                /* ADD */
+                                break;
+                        } else {
+                                c += e;
+                        }
+                }
+        }
+
+        /* don't forget to release pi */
+        pi_destroy(pi, cp, tileno);
+        
+        if (e == -999) {
+                return e;
+        }
+        
+    return (c - src);
+}
+
+/* ----------------------------------------------------------------------- */
+
+opj_t2_t* t2_create(opj_common_ptr cinfo, opj_image_t *image, opj_cp_t *cp) {
+        /* create the tcd structure */
+        opj_t2_t *t2 = (opj_t2_t*)opj_malloc(sizeof(opj_t2_t));
+        if(!t2) return NULL;
+        t2->cinfo = cinfo;
+        t2->image = image;
+        t2->cp = cp;
+
+        return t2;
+}
+
+void t2_destroy(opj_t2_t *t2) {
+        if(t2) {
+                opj_free(t2);
+        }
+}
+
diff --git a/libraries/openjpeg-libsl/libopenjpeg/t2.h b/libraries/openjpeg-libsl/libopenjpeg/t2.h
new file mode 100644
index 0000000..87ed2d2
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/t2.h
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __T2_H
+#define __T2_H
+/**
+@file t2.h
+@brief Implementation of a tier-2 coding (packetization of code-block data) (T2)
+
+*/
+
+/** @defgroup T2 T2 - Implementation of a tier-2 coding */
+/*@{*/
+
+/**
+Tier-2 coding
+*/
+typedef struct opj_t2 {
+        /** codec context */
+        opj_common_ptr cinfo;
+
+        /** Encoding: pointer to the src image. Decoding: pointer to the dst image. */
+        opj_image_t *image;
+        /** pointer to the image coding parameters */
+        opj_cp_t *cp;
+} opj_t2_t;
+
+/** @name Exported functions */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+
+/**
+Encode the packets of a tile to a destination buffer
+@param t2 T2 handle
+@param tileno number of the tile encoded
+@param tile the tile for which to write the packets
+@param maxlayers maximum number of layers
+@param dest the destination buffer
+@param len the length of the destination buffer
+@param image_info structure to create an index file
+@param tpnum Tile part number of the current tile
+@param tppos The position of the tile part flag in the progression order
+@param t2_mode If == 0 In Threshold calculation ,If == 1 Final pass
+*/
+int t2_encode_packets(opj_t2_t* t2,int tileno, opj_tcd_tile_t *tile, int maxlayers, unsigned char *dest, int len, opj_image_info_t *image_info,int tpnum, int tppos,int pino,J2K_T2_MODE t2_mode);
+/**
+Decode the packets of a tile from a source buffer
+@param t2 T2 handle
+@param src the source buffer
+@param len length of the source buffer
+@param tileno number that identifies the tile for which to decode the packets
+@param tile tile for which to decode the packets
+ */
+int t2_decode_packets(opj_t2_t *t2, unsigned char *src, int len, int tileno, opj_tcd_tile_t *tile);
+
+/**
+Create a T2 handle
+@param cinfo Codec context info
+@param image Source or destination image
+@param cp Image coding parameters
+@return Returns a new T2 handle if successful, returns NULL otherwise
+*/
+opj_t2_t* t2_create(opj_common_ptr cinfo, opj_image_t *image, opj_cp_t *cp);
+/**
+Destroy a T2 handle
+@param t2 T2 handle to destroy
+*/
+void t2_destroy(opj_t2_t *t2);
+
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __T2_H */
diff --git a/libraries/openjpeg-libsl/libopenjpeg/tcd.c b/libraries/openjpeg-libsl/libopenjpeg/tcd.c
new file mode 100644
index 0000000..525ec91
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/tcd.c
@@ -0,0 +1,1409 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * Copyright (c) 2006-2007, Parvatha Elangovan
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "opj_includes.h"
+
+void tcd_dump(FILE *fd, opj_tcd_t *tcd, opj_tcd_image_t * img) {
+        int tileno, compno, resno, bandno, precno, cblkno;
+
+        fprintf(fd, "image {\n");
+        fprintf(fd, "  tw=%d, th=%d x0=%d x1=%d y0=%d y1=%d\n", 
+                img->tw, img->th, tcd->image->x0, tcd->image->x1, tcd->image->y0, tcd->image->y1);
+
+        for (tileno = 0; tileno < img->th * img->tw; tileno++) {
+                opj_tcd_tile_t *tile = &tcd->tcd_image->tiles[tileno];
+                fprintf(fd, "  tile {\n");
+                fprintf(fd, "    x0=%d, y0=%d, x1=%d, y1=%d, numcomps=%d\n",
+                        tile->x0, tile->y0, tile->x1, tile->y1, tile->numcomps);
+                for (compno = 0; compno < tile->numcomps; compno++) {
+                        opj_tcd_tilecomp_t *tilec = &tile->comps[compno];
+                        fprintf(fd, "    tilec {\n");
+                        fprintf(fd,
+                                "      x0=%d, y0=%d, x1=%d, y1=%d, numresolutions=%d\n",
+                                tilec->x0, tilec->y0, tilec->x1, tilec->y1, tilec->numresolutions);
+                        for (resno = 0; resno < tilec->numresolutions; resno++) {
+                                opj_tcd_resolution_t *res = &tilec->resolutions[resno];
+                                fprintf(fd, "\n   res {\n");
+                                fprintf(fd,
+                                        "          x0=%d, y0=%d, x1=%d, y1=%d, pw=%d, ph=%d, numbands=%d\n",
+                                        res->x0, res->y0, res->x1, res->y1, res->pw, res->ph, res->numbands);
+                                for (bandno = 0; bandno < res->numbands; bandno++) {
+                                        opj_tcd_band_t *band = &res->bands[bandno];
+                                        fprintf(fd, "        band {\n");
+                                        fprintf(fd,
+                                                "          x0=%d, y0=%d, x1=%d, y1=%d, stepsize=%f, numbps=%d\n",
+                                                band->x0, band->y0, band->x1, band->y1, band->stepsize, band->numbps);
+                                        for (precno = 0; precno < res->pw * res->ph; precno++) {
+                                                opj_tcd_precinct_t *prec = &band->precincts[precno];
+                                                fprintf(fd, "          prec {\n");
+                                                fprintf(fd,
+                                                        "            x0=%d, y0=%d, x1=%d, y1=%d, cw=%d, ch=%d\n",
+                                                        prec->x0, prec->y0, prec->x1, prec->y1, prec->cw, prec->ch);
+                                                for (cblkno = 0; cblkno < prec->cw * prec->ch; cblkno++) {
+                                                        opj_tcd_cblk_t *cblk = &prec->cblks[cblkno];
+                                                        fprintf(fd, "            cblk {\n");
+                                                        fprintf(fd,
+                                                                "              x0=%d, y0=%d, x1=%d, y1=%d\n",
+                                                                cblk->x0, cblk->y0, cblk->x1, cblk->y1);
+                                                        fprintf(fd, "            }\n");
+                                                }
+                                                fprintf(fd, "          }\n");
+                                        }
+                                        fprintf(fd, "        }\n");
+                                }
+                                fprintf(fd, "      }\n");
+                        }
+                        fprintf(fd, "    }\n");
+                }
+                fprintf(fd, "  }\n");
+        }
+        fprintf(fd, "}\n");
+}
+
+/* ----------------------------------------------------------------------- */
+
+/**
+Create a new TCD handle
+*/
+opj_tcd_t* tcd_create(opj_common_ptr cinfo) {
+        /* create the tcd structure */
+        opj_tcd_t *tcd = (opj_tcd_t*)opj_malloc(sizeof(opj_tcd_t));
+        if(!tcd) return NULL;
+        tcd->cinfo = cinfo;
+        tcd->tcd_image = (opj_tcd_image_t*)opj_malloc(sizeof(opj_tcd_image_t));
+        if(!tcd->tcd_image) {
+                opj_free(tcd);
+                return NULL;
+        }
+
+        return tcd;
+}
+
+/**
+Destroy a previously created TCD handle
+*/
+void tcd_destroy(opj_tcd_t *tcd) {
+        if(tcd) {
+                opj_free(tcd->tcd_image);
+                opj_free(tcd);
+        }
+}
+
+/* ----------------------------------------------------------------------- */
+
+void tcd_malloc_encode(opj_tcd_t *tcd, opj_image_t * image, opj_cp_t * cp, int curtileno) {
+        int tileno, compno, resno, bandno, precno, cblkno;
+
+        tcd->image = image;
+        tcd->cp = cp;
+        tcd->tcd_image->tw = cp->tw;
+        tcd->tcd_image->th = cp->th;
+        tcd->tcd_image->tiles = (opj_tcd_tile_t *) opj_malloc(sizeof(opj_tcd_tile_t));
+        
+        for (tileno = 0; tileno < 1; tileno++) {
+                opj_tcp_t *tcp = &cp->tcps[curtileno];
+                int j;
+
+                /* cfr p59 ISO/IEC FDIS15444-1 : 2000 (18 august 2000) */
+                int p = curtileno % cp->tw;     /* si numerotation matricielle .. */
+                int q = curtileno / cp->tw;     /* .. coordonnees de la tile (q,p) q pour ligne et p pour colonne */
+
+                /* opj_tcd_tile_t *tile=&tcd->tcd_image->tiles[tileno]; */
+                opj_tcd_tile_t *tile = tcd->tcd_image->tiles;
+
+                /* 4 borders of the tile rescale on the image if necessary */
+                tile->x0 = int_max(cp->tx0 + p * cp->tdx, image->x0);
+                tile->y0 = int_max(cp->ty0 + q * cp->tdy, image->y0);
+                tile->x1 = int_min(cp->tx0 + (p + 1) * cp->tdx, image->x1);
+                tile->y1 = int_min(cp->ty0 + (q + 1) * cp->tdy, image->y1);
+                tile->numcomps = image->numcomps;
+                /* tile->PPT=image->PPT;  */
+
+                /* Modification of the RATE >> */
+                for (j = 0; j < tcp->numlayers; j++) {
+                        tcp->rates[j] = tcp->rates[j] ? 
+                                ((float) (tile->numcomps 
+                                        * (tile->x1 - tile->x0) 
+                                        * (tile->y1 - tile->y0) 
+                                        * image->comps[0].prec))/ 
+                                        (tcp->rates[j] * 8 * image->comps[0].dx * image->comps[0].dy)
+                                        : 0;
+
+                        if (tcp->rates[j]) {
+                                if (j && tcp->rates[j] < tcp->rates[j - 1] + 10) {
+                                        tcp->rates[j] = tcp->rates[j - 1] + 20;
+                                } else {
+                                        if (!j && tcp->rates[j] < 30)
+                                                tcp->rates[j] = 30;
+                                }
+                        }
+                }
+                /* << Modification of the RATE */
+                
+                tile->comps = (opj_tcd_tilecomp_t *) opj_malloc(image->numcomps * sizeof(opj_tcd_tilecomp_t));
+                for (compno = 0; compno < tile->numcomps; compno++) {
+                        opj_tccp_t *tccp = &tcp->tccps[compno];
+
+                        opj_tcd_tilecomp_t *tilec = &tile->comps[compno];
+
+                        /* border of each tile component (global) */
+                        tilec->x0 = int_ceildiv(tile->x0, image->comps[compno].dx);
+                        tilec->y0 = int_ceildiv(tile->y0, image->comps[compno].dy);
+                        tilec->x1 = int_ceildiv(tile->x1, image->comps[compno].dx);
+                        tilec->y1 = int_ceildiv(tile->y1, image->comps[compno].dy);
+                        
+                        tilec->data = (int *) opj_malloc((tilec->x1 - tilec->x0) * (tilec->y1 - tilec->y0) * sizeof(int));
+                        tilec->numresolutions = tccp->numresolutions;
+
+                        tilec->resolutions = (opj_tcd_resolution_t *) opj_malloc(tilec->numresolutions * sizeof(opj_tcd_resolution_t));
+                        
+                        for (resno = 0; resno < tilec->numresolutions; resno++) {
+                                int pdx, pdy;
+                                int levelno = tilec->numresolutions - 1 - resno;
+                                int tlprcxstart, tlprcystart, brprcxend, brprcyend;
+                                int tlcbgxstart, tlcbgystart, brcbgxend, brcbgyend;
+                                int cbgwidthexpn, cbgheightexpn;
+                                int cblkwidthexpn, cblkheightexpn;
+
+                                opj_tcd_resolution_t *res = &tilec->resolutions[resno];
+                                
+                                /* border for each resolution level (global) */
+                                res->x0 = int_ceildivpow2(tilec->x0, levelno);
+                                res->y0 = int_ceildivpow2(tilec->y0, levelno);
+                                res->x1 = int_ceildivpow2(tilec->x1, levelno);
+                                res->y1 = int_ceildivpow2(tilec->y1, levelno);
+                                
+                                res->numbands = resno == 0 ? 1 : 3;
+                                /* p. 35, table A-23, ISO/IEC FDIS154444-1 : 2000 (18 august 2000) */
+                                if (tccp->csty & J2K_CCP_CSTY_PRT) {
+                                        pdx = tccp->prcw[resno];
+                                        pdy = tccp->prch[resno];
+                                } else {
+                                        pdx = 15;
+                                        pdy = 15;
+                                }
+                                /* p. 64, B.6, ISO/IEC FDIS15444-1 : 2000 (18 august 2000)  */
+                                tlprcxstart = int_floordivpow2(res->x0, pdx) << pdx;
+                                tlprcystart = int_floordivpow2(res->y0, pdy) << pdy;
+                                
+                                brprcxend = int_ceildivpow2(res->x1, pdx) << pdx;
+                                brprcyend = int_ceildivpow2(res->y1, pdy) << pdy;
+                                
+                                res->pw = (brprcxend - tlprcxstart) >> pdx;
+                                res->ph = (brprcyend - tlprcystart) >> pdy;
+                                
+                                if (resno == 0) {
+                                        tlcbgxstart = tlprcxstart;
+                                        tlcbgystart = tlprcystart;
+                                        brcbgxend = brprcxend;
+                                        brcbgyend = brprcyend;
+                                        cbgwidthexpn = pdx;
+                                        cbgheightexpn = pdy;
+                                } else {
+                                        tlcbgxstart = int_ceildivpow2(tlprcxstart, 1);
+                                        tlcbgystart = int_ceildivpow2(tlprcystart, 1);
+                                        brcbgxend = int_ceildivpow2(brprcxend, 1);
+                                        brcbgyend = int_ceildivpow2(brprcyend, 1);
+                                        cbgwidthexpn = pdx - 1;
+                                        cbgheightexpn = pdy - 1;
+                                }
+                                
+                                cblkwidthexpn = int_min(tccp->cblkw, cbgwidthexpn);
+                                cblkheightexpn = int_min(tccp->cblkh, cbgheightexpn);
+                                
+                                for (bandno = 0; bandno < res->numbands; bandno++) {
+                                        int x0b, y0b, i;
+                                        int gain, numbps;
+                                        opj_stepsize_t *ss = NULL;
+
+                                        opj_tcd_band_t *band = &res->bands[bandno];
+
+                                        band->bandno = resno == 0 ? 0 : bandno + 1;
+                                        x0b = (band->bandno == 1) || (band->bandno == 3) ? 1 : 0;
+                                        y0b = (band->bandno == 2) || (band->bandno == 3) ? 1 : 0;
+                                        
+                                        if (band->bandno == 0) {
+                                                /* band border (global) */
+                                                band->x0 = int_ceildivpow2(tilec->x0, levelno);
+                                                band->y0 = int_ceildivpow2(tilec->y0, levelno);
+                                                band->x1 = int_ceildivpow2(tilec->x1, levelno);
+                                                band->y1 = int_ceildivpow2(tilec->y1, levelno);
+                                        } else {
+                                                /* band border (global) */
+                                                band->x0 = int_ceildivpow2(tilec->x0 - (1 << levelno) * x0b, levelno + 1);
+                                                band->y0 = int_ceildivpow2(tilec->y0 - (1 << levelno) * y0b, levelno + 1);
+                                                band->x1 = int_ceildivpow2(tilec->x1 - (1 << levelno) * x0b, levelno + 1);
+                                                band->y1 = int_ceildivpow2(tilec->y1 - (1 << levelno) * y0b, levelno + 1);
+                                        }
+                                        
+                                        ss = &tccp->stepsizes[resno == 0 ? 0 : 3 * (resno - 1) + bandno + 1];
+                                        gain = tccp->qmfbid == 0 ? dwt_getgain_real(band->bandno) : dwt_getgain(band->bandno);                                  
+                                        numbps = image->comps[compno].prec + gain;
+                                        
+                                        band->stepsize = (float)((1.0 + ss->mant / 2048.0) * pow(2.0, numbps - ss->expn));
+                                        band->numbps = ss->expn + tccp->numgbits - 1;   /* WHY -1 ? */
+                                        
+                                        band->precincts = (opj_tcd_precinct_t *) opj_malloc(3 * res->pw * res->ph * sizeof(opj_tcd_precinct_t));
+                                        
+                                        for (i = 0; i < res->pw * res->ph * 3; i++) {
+                                                band->precincts[i].imsbtree = NULL;
+                                                band->precincts[i].incltree = NULL;
+                                        }
+                                        
+                                        for (precno = 0; precno < res->pw * res->ph; precno++) {
+                                                int tlcblkxstart, tlcblkystart, brcblkxend, brcblkyend;
+
+                                                int cbgxstart = tlcbgxstart + (precno % res->pw) * (1 << cbgwidthexpn);
+                                                int cbgystart = tlcbgystart + (precno / res->pw) * (1 << cbgheightexpn);
+                                                int cbgxend = cbgxstart + (1 << cbgwidthexpn);
+                                                int cbgyend = cbgystart + (1 << cbgheightexpn);
+
+                                                opj_tcd_precinct_t *prc = &band->precincts[precno];
+
+                                                /* precinct size (global) */
+                                                prc->x0 = int_max(cbgxstart, band->x0);
+                                                prc->y0 = int_max(cbgystart, band->y0);
+                                                prc->x1 = int_min(cbgxend, band->x1);
+                                                prc->y1 = int_min(cbgyend, band->y1);
+
+                                                tlcblkxstart = int_floordivpow2(prc->x0, cblkwidthexpn) << cblkwidthexpn;
+                                                tlcblkystart = int_floordivpow2(prc->y0, cblkheightexpn) << cblkheightexpn;
+                                                brcblkxend = int_ceildivpow2(prc->x1, cblkwidthexpn) << cblkwidthexpn;
+                                                brcblkyend = int_ceildivpow2(prc->y1, cblkheightexpn) << cblkheightexpn;
+                                                prc->cw = (brcblkxend - tlcblkxstart) >> cblkwidthexpn;
+                                                prc->ch = (brcblkyend - tlcblkystart) >> cblkheightexpn;
+
+                                                prc->cblks = (opj_tcd_cblk_t *) opj_malloc((prc->cw * prc->ch) * sizeof(opj_tcd_cblk_t));
+                                                prc->incltree = tgt_create(prc->cw, prc->ch);
+                                                prc->imsbtree = tgt_create(prc->cw, prc->ch);
+                                                
+                                                for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
+                                                        int cblkxstart = tlcblkxstart + (cblkno % prc->cw) * (1 << cblkwidthexpn);
+                                                        int cblkystart = tlcblkystart + (cblkno / prc->cw) * (1 << cblkheightexpn);
+                                                        int cblkxend = cblkxstart + (1 << cblkwidthexpn);
+                                                        int cblkyend = cblkystart + (1 << cblkheightexpn);
+                                                        
+                                                        opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
+
+                                                        /* code-block size (global) */
+                                                        cblk->x0 = int_max(cblkxstart, prc->x0);
+                                                        cblk->y0 = int_max(cblkystart, prc->y0);
+                                                        cblk->x1 = int_min(cblkxend, prc->x1);
+                                                        cblk->y1 = int_min(cblkyend, prc->y1);
+                                                }
+                                        }
+                                }
+                        }
+                }
+        }
+        
+        /* tcd_dump(stdout, tcd, &tcd->tcd_image); */
+}
+
+void tcd_free_encode(opj_tcd_t *tcd) {
+        int tileno, compno, resno, bandno, precno;
+
+        for (tileno = 0; tileno < 1; tileno++) {
+                opj_tcd_tile_t *tile = tcd->tcd_image->tiles;
+
+                for (compno = 0; compno < tile->numcomps; compno++) {
+                        opj_tcd_tilecomp_t *tilec = &tile->comps[compno];
+
+                        for (resno = 0; resno < tilec->numresolutions; resno++) {
+                                opj_tcd_resolution_t *res = &tilec->resolutions[resno];
+
+                                for (bandno = 0; bandno < res->numbands; bandno++) {
+                                        opj_tcd_band_t *band = &res->bands[bandno];
+
+                                        for (precno = 0; precno < res->pw * res->ph; precno++) {
+                                                opj_tcd_precinct_t *prc = &band->precincts[precno];
+
+                                                if (prc->incltree != NULL) {
+                                                        tgt_destroy(prc->incltree);
+                                                        prc->incltree = NULL;
+                                                }
+                                                if (prc->imsbtree != NULL) {
+                                                        tgt_destroy(prc->imsbtree);     
+                                                        prc->imsbtree = NULL;
+                                                }
+                                                opj_free(prc->cblks);
+                                                prc->cblks = NULL;
+                                        } /* for (precno */
+                                        opj_free(band->precincts);
+                                        band->precincts = NULL;
+                                } /* for (bandno */
+                        } /* for (resno */
+                        opj_free(tilec->resolutions);
+                        tilec->resolutions = NULL;
+                } /* for (compno */
+                opj_free(tile->comps);
+                tile->comps = NULL;
+        } /* for (tileno */
+        opj_free(tcd->tcd_image->tiles);
+        tcd->tcd_image->tiles = NULL;
+}
+
+void tcd_init_encode(opj_tcd_t *tcd, opj_image_t * image, opj_cp_t * cp, int curtileno) {
+        int tileno, compno, resno, bandno, precno, cblkno;
+
+        for (tileno = 0; tileno < 1; tileno++) {
+                opj_tcp_t *tcp = &cp->tcps[curtileno];
+                int j;
+                /* cfr p59 ISO/IEC FDIS15444-1 : 2000 (18 august 2000) */
+                int p = curtileno % cp->tw;
+                int q = curtileno / cp->tw;
+
+                opj_tcd_tile_t *tile = tcd->tcd_image->tiles;
+                
+                /* 4 borders of the tile rescale on the image if necessary */
+                tile->x0 = int_max(cp->tx0 + p * cp->tdx, image->x0);
+                tile->y0 = int_max(cp->ty0 + q * cp->tdy, image->y0);
+                tile->x1 = int_min(cp->tx0 + (p + 1) * cp->tdx, image->x1);
+                tile->y1 = int_min(cp->ty0 + (q + 1) * cp->tdy, image->y1);
+                
+                tile->numcomps = image->numcomps;
+                /* tile->PPT=image->PPT; */
+
+                /* Modification of the RATE >> */
+                for (j = 0; j < tcp->numlayers; j++) {
+                        tcp->rates[j] = tcp->rates[j] ? 
+                                                ((float) (tile->numcomps 
+                                                                * (tile->x1 - tile->x0) 
+                                                                * (tile->y1 - tile->y0) 
+                                                                * image->comps[0].prec))/ 
+                                                (tcp->rates[j] * 8 * image->comps[0].dx * image->comps[0].dy) 
+                                                : 0;
+
+                        if (tcp->rates[j]) {
+                                if (j && tcp->rates[j] < tcp->rates[j - 1] + 10) {
+                                        tcp->rates[j] = tcp->rates[j - 1] + 20;
+                                } else {
+                                        if (!j && tcp->rates[j] < 30)
+                                                tcp->rates[j] = 30;
+                                }
+                        }
+                }
+                /* << Modification of the RATE */
+
+                /* tile->comps=(opj_tcd_tilecomp_t*)opj_realloc(tile->comps,image->numcomps*sizeof(opj_tcd_tilecomp_t)); */
+                for (compno = 0; compno < tile->numcomps; compno++) {
+                        opj_tccp_t *tccp = &tcp->tccps[compno];
+                        
+                        opj_tcd_tilecomp_t *tilec = &tile->comps[compno];
+
+                        /* border of each tile component (global) */
+                        tilec->x0 = int_ceildiv(tile->x0, image->comps[compno].dx);
+                        tilec->y0 = int_ceildiv(tile->y0, image->comps[compno].dy);
+                        tilec->x1 = int_ceildiv(tile->x1, image->comps[compno].dx);
+                        tilec->y1 = int_ceildiv(tile->y1, image->comps[compno].dy);
+                        
+                        tilec->data = (int *) opj_malloc((tilec->x1 - tilec->x0) * (tilec->y1 - tilec->y0) * sizeof(int));
+                        tilec->numresolutions = tccp->numresolutions;
+                        /* tilec->resolutions=(opj_tcd_resolution_t*)opj_realloc(tilec->resolutions,tilec->numresolutions*sizeof(opj_tcd_resolution_t)); */
+                        for (resno = 0; resno < tilec->numresolutions; resno++) {
+                                int pdx, pdy;
+
+                                int levelno = tilec->numresolutions - 1 - resno;
+                                int tlprcxstart, tlprcystart, brprcxend, brprcyend;
+                                int tlcbgxstart, tlcbgystart, brcbgxend, brcbgyend;
+                                int cbgwidthexpn, cbgheightexpn;
+                                int cblkwidthexpn, cblkheightexpn;
+                                
+                                opj_tcd_resolution_t *res = &tilec->resolutions[resno];
+
+                                /* border for each resolution level (global) */
+                                res->x0 = int_ceildivpow2(tilec->x0, levelno);
+                                res->y0 = int_ceildivpow2(tilec->y0, levelno);
+                                res->x1 = int_ceildivpow2(tilec->x1, levelno);
+                                res->y1 = int_ceildivpow2(tilec->y1, levelno);  
+                                res->numbands = resno == 0 ? 1 : 3;
+
+                                /* p. 35, table A-23, ISO/IEC FDIS154444-1 : 2000 (18 august 2000) */
+                                if (tccp->csty & J2K_CCP_CSTY_PRT) {
+                                        pdx = tccp->prcw[resno];
+                                        pdy = tccp->prch[resno];
+                                } else {
+                                        pdx = 15;
+                                        pdy = 15;
+                                }
+                                /* p. 64, B.6, ISO/IEC FDIS15444-1 : 2000 (18 august 2000)  */
+                                tlprcxstart = int_floordivpow2(res->x0, pdx) << pdx;
+                                tlprcystart = int_floordivpow2(res->y0, pdy) << pdy;
+                                brprcxend = int_ceildivpow2(res->x1, pdx) << pdx;
+                                brprcyend = int_ceildivpow2(res->y1, pdy) << pdy;
+                                
+                                res->pw = (brprcxend - tlprcxstart) >> pdx;
+                                res->ph = (brprcyend - tlprcystart) >> pdy;
+                                
+                                if (resno == 0) {
+                                        tlcbgxstart = tlprcxstart;
+                                        tlcbgystart = tlprcystart;
+                                        brcbgxend = brprcxend;
+                                        brcbgyend = brprcyend;
+                                        cbgwidthexpn = pdx;
+                                        cbgheightexpn = pdy;
+                                } else {
+                                        tlcbgxstart = int_ceildivpow2(tlprcxstart, 1);
+                                        tlcbgystart = int_ceildivpow2(tlprcystart, 1);
+                                        brcbgxend = int_ceildivpow2(brprcxend, 1);
+                                        brcbgyend = int_ceildivpow2(brprcyend, 1);
+                                        cbgwidthexpn = pdx - 1;
+                                        cbgheightexpn = pdy - 1;
+                                }
+                                
+                                cblkwidthexpn = int_min(tccp->cblkw, cbgwidthexpn);
+                                cblkheightexpn = int_min(tccp->cblkh, cbgheightexpn);
+                                
+                                for (bandno = 0; bandno < res->numbands; bandno++) {
+                                        int x0b, y0b;
+                                        int gain, numbps;
+                                        opj_stepsize_t *ss = NULL;
+
+                                        opj_tcd_band_t *band = &res->bands[bandno];
+
+                                        band->bandno = resno == 0 ? 0 : bandno + 1;
+                                        x0b = (band->bandno == 1) || (band->bandno == 3) ? 1 : 0;
+                                        y0b = (band->bandno == 2) || (band->bandno == 3) ? 1 : 0;
+                                        
+                                        if (band->bandno == 0) {
+                                                /* band border */
+                                                band->x0 = int_ceildivpow2(tilec->x0, levelno);
+                                                band->y0 = int_ceildivpow2(tilec->y0, levelno);
+                                                band->x1 = int_ceildivpow2(tilec->x1, levelno);
+                                                band->y1 = int_ceildivpow2(tilec->y1, levelno);
+                                        } else {
+                                                band->x0 = int_ceildivpow2(tilec->x0 - (1 << levelno) * x0b, levelno + 1);
+                                                band->y0 = int_ceildivpow2(tilec->y0 - (1 << levelno) * y0b, levelno + 1);
+                                                band->x1 = int_ceildivpow2(tilec->x1 - (1 << levelno) * x0b, levelno + 1);
+                                                band->y1 = int_ceildivpow2(tilec->y1 - (1 << levelno) * y0b, levelno + 1);
+                                        }
+                                        
+                                        ss = &tccp->stepsizes[resno == 0 ? 0 : 3 * (resno - 1) + bandno + 1];
+                                        gain = tccp->qmfbid == 0 ? dwt_getgain_real(band->bandno) : dwt_getgain(band->bandno);
+                                        numbps = image->comps[compno].prec + gain;
+                                        band->stepsize = (float)((1.0 + ss->mant / 2048.0) * pow(2.0, numbps - ss->expn));
+                                        band->numbps = ss->expn + tccp->numgbits - 1;   /* WHY -1 ? */
+                                        
+                                        for (precno = 0; precno < res->pw * res->ph; precno++) {
+                                                int tlcblkxstart, tlcblkystart, brcblkxend, brcblkyend;
+
+                                                int cbgxstart = tlcbgxstart + (precno % res->pw) * (1 << cbgwidthexpn);
+                                                int cbgystart = tlcbgystart + (precno / res->pw) * (1 << cbgheightexpn);
+                                                int cbgxend = cbgxstart + (1 << cbgwidthexpn);
+                                                int cbgyend = cbgystart + (1 << cbgheightexpn);
+                                                
+                                                opj_tcd_precinct_t *prc = &band->precincts[precno];
+
+                                                /* precinct size (global) */
+                                                prc->x0 = int_max(cbgxstart, band->x0);
+                                                prc->y0 = int_max(cbgystart, band->y0);
+                                                prc->x1 = int_min(cbgxend, band->x1);
+                                                prc->y1 = int_min(cbgyend, band->y1);
+
+                                                tlcblkxstart = int_floordivpow2(prc->x0, cblkwidthexpn) << cblkwidthexpn;
+                                                tlcblkystart = int_floordivpow2(prc->y0, cblkheightexpn) << cblkheightexpn;
+                                                brcblkxend = int_ceildivpow2(prc->x1, cblkwidthexpn) << cblkwidthexpn;
+                                                brcblkyend = int_ceildivpow2(prc->y1, cblkheightexpn) << cblkheightexpn;
+                                                prc->cw = (brcblkxend - tlcblkxstart) >> cblkwidthexpn;
+                                                prc->ch = (brcblkyend - tlcblkystart) >> cblkheightexpn;
+
+                                                opj_free(prc->cblks);
+                                                prc->cblks = (opj_tcd_cblk_t *) opj_malloc(prc->cw * prc->ch * sizeof(opj_tcd_cblk_t));
+
+                                                if (prc->incltree != NULL) {
+                                                        tgt_destroy(prc->incltree);
+                                                }
+                                                if (prc->imsbtree != NULL) {
+                                                        tgt_destroy(prc->imsbtree);
+                                                }
+                                                
+                                                prc->incltree = tgt_create(prc->cw, prc->ch);
+                                                prc->imsbtree = tgt_create(prc->cw, prc->ch);
+
+                                                for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
+                                                        int cblkxstart = tlcblkxstart + (cblkno % prc->cw) * (1 << cblkwidthexpn);
+                                                        int cblkystart = tlcblkystart + (cblkno / prc->cw) * (1 << cblkheightexpn);
+                                                        int cblkxend = cblkxstart + (1 << cblkwidthexpn);
+                                                        int cblkyend = cblkystart + (1 << cblkheightexpn);
+
+                                                        opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
+                                                        
+                                                        /* code-block size (global) */
+                                                        cblk->x0 = int_max(cblkxstart, prc->x0);
+                                                        cblk->y0 = int_max(cblkystart, prc->y0);
+                                                        cblk->x1 = int_min(cblkxend, prc->x1);
+                                                        cblk->y1 = int_min(cblkyend, prc->y1);
+                                                }
+                                        } /* precno */
+                                } /* bandno */
+                        } /* resno */
+                } /* compno */
+        } /* tileno */
+
+        /* tcd_dump(stdout, tcd, &tcd->tcd_image); */
+}
+
+void tcd_malloc_decode(opj_tcd_t *tcd, opj_image_t * image, opj_cp_t * cp) {
+        int tileno, compno, resno, bandno, precno, cblkno, i, j, p, q;
+        unsigned int x0 = 0, y0 = 0, x1 = 0, y1 = 0, w, h;
+
+        tcd->image = image;
+        tcd->cp = cp;
+        tcd->tcd_image->tw = cp->tw;
+        tcd->tcd_image->th = cp->th;
+        tcd->tcd_image->tiles = (opj_tcd_tile_t *) opj_malloc(cp->tw * cp->th * sizeof(opj_tcd_tile_t));
+        
+        for (i = 0; i < cp->tileno_size; i++) {
+                opj_tcp_t *tcp = &(cp->tcps[cp->tileno[i]]);
+                opj_tcd_tile_t *tile = &(tcd->tcd_image->tiles[cp->tileno[i]]);
+        
+                /* cfr p59 ISO/IEC FDIS15444-1 : 2000 (18 august 2000) */
+                tileno = cp->tileno[i];
+                p = tileno % cp->tw;    /* si numerotation matricielle .. */
+                q = tileno / cp->tw;    /* .. coordonnees de la tile (q,p) q pour ligne et p pour colonne */
+
+                /* 4 borders of the tile rescale on the image if necessary */
+                tile->x0 = int_max(cp->tx0 + p * cp->tdx, image->x0);
+                tile->y0 = int_max(cp->ty0 + q * cp->tdy, image->y0);
+                tile->x1 = int_min(cp->tx0 + (p + 1) * cp->tdx, image->x1);
+                tile->y1 = int_min(cp->ty0 + (q + 1) * cp->tdy, image->y1);
+                
+                tile->numcomps = image->numcomps;
+                tile->comps = (opj_tcd_tilecomp_t *) opj_malloc(image->numcomps * sizeof(opj_tcd_tilecomp_t));
+                for (compno = 0; compno < tile->numcomps; compno++) {
+                        opj_tccp_t *tccp = &tcp->tccps[compno];
+                        opj_tcd_tilecomp_t *tilec = &tile->comps[compno];
+
+                        /* border of each tile component (global) */
+                        tilec->x0 = int_ceildiv(tile->x0, image->comps[compno].dx);
+                        tilec->y0 = int_ceildiv(tile->y0, image->comps[compno].dy);
+                        tilec->x1 = int_ceildiv(tile->x1, image->comps[compno].dx);
+                        tilec->y1 = int_ceildiv(tile->y1, image->comps[compno].dy);
+                        
+                        tilec->data = (int *) opj_malloc((tilec->x1 - tilec->x0) * (tilec->y1 - tilec->y0) * sizeof(int));
+                        tilec->numresolutions = tccp->numresolutions;
+                        tilec->resolutions = (opj_tcd_resolution_t *) opj_malloc(tilec->numresolutions * sizeof(opj_tcd_resolution_t));
+
+                        for (resno = 0; resno < tilec->numresolutions; resno++) {
+                                int pdx, pdy;
+                                int levelno = tilec->numresolutions - 1 - resno;
+                                int tlprcxstart, tlprcystart, brprcxend, brprcyend;
+                                int tlcbgxstart, tlcbgystart, brcbgxend, brcbgyend;
+                                int cbgwidthexpn, cbgheightexpn;
+                                int cblkwidthexpn, cblkheightexpn;
+
+                                opj_tcd_resolution_t *res = &tilec->resolutions[resno];
+                                
+                                /* border for each resolution level (global) */
+                                res->x0 = int_ceildivpow2(tilec->x0, levelno);
+                                res->y0 = int_ceildivpow2(tilec->y0, levelno);
+                                res->x1 = int_ceildivpow2(tilec->x1, levelno);
+                                res->y1 = int_ceildivpow2(tilec->y1, levelno);
+                                res->numbands = resno == 0 ? 1 : 3;
+                                
+                                /* p. 35, table A-23, ISO/IEC FDIS154444-1 : 2000 (18 august 2000) */
+                                if (tccp->csty & J2K_CCP_CSTY_PRT) {
+                                        pdx = tccp->prcw[resno];
+                                        pdy = tccp->prch[resno];
+                                } else {
+                                        pdx = 15;
+                                        pdy = 15;
+                                }
+                                
+                                /* p. 64, B.6, ISO/IEC FDIS15444-1 : 2000 (18 august 2000)  */
+                                tlprcxstart = int_floordivpow2(res->x0, pdx) << pdx;
+                                tlprcystart = int_floordivpow2(res->y0, pdy) << pdy;
+                                brprcxend = int_ceildivpow2(res->x1, pdx) << pdx;
+                                brprcyend = int_ceildivpow2(res->y1, pdy) << pdy;
+
+                                res->pw = (res->x0 == res->x1) ? 0 : ((brprcxend - tlprcxstart) >> pdx);
+                                res->ph = (res->y0 == res->y1) ? 0 : ((brprcyend - tlprcystart) >> pdy);
+                                
+                                if (resno == 0) {
+                                        tlcbgxstart = tlprcxstart;
+                                        tlcbgystart = tlprcystart;
+                                        brcbgxend = brprcxend;
+                                        brcbgyend = brprcyend;
+                                        cbgwidthexpn = pdx;
+                                        cbgheightexpn = pdy;
+                                } else {
+                                        tlcbgxstart = int_ceildivpow2(tlprcxstart, 1);
+                                        tlcbgystart = int_ceildivpow2(tlprcystart, 1);
+                                        brcbgxend = int_ceildivpow2(brprcxend, 1);
+                                        brcbgyend = int_ceildivpow2(brprcyend, 1);
+                                        cbgwidthexpn = pdx - 1;
+                                        cbgheightexpn = pdy - 1;
+                                }
+                                
+                                cblkwidthexpn = int_min(tccp->cblkw, cbgwidthexpn);
+                                cblkheightexpn = int_min(tccp->cblkh, cbgheightexpn);
+                                
+                                for (bandno = 0; bandno < res->numbands; bandno++) {
+                                        int x0b, y0b;
+                                        int gain, numbps;
+                                        opj_stepsize_t *ss = NULL;
+
+                                        opj_tcd_band_t *band = &res->bands[bandno];
+                                        band->bandno = resno == 0 ? 0 : bandno + 1;
+                                        x0b = (band->bandno == 1) || (band->bandno == 3) ? 1 : 0;
+                                        y0b = (band->bandno == 2) || (band->bandno == 3) ? 1 : 0;
+                                        
+                                        if (band->bandno == 0) {
+                                                /* band border (global) */
+                                                band->x0 = int_ceildivpow2(tilec->x0, levelno);
+                                                band->y0 = int_ceildivpow2(tilec->y0, levelno);
+                                                band->x1 = int_ceildivpow2(tilec->x1, levelno);
+                                                band->y1 = int_ceildivpow2(tilec->y1, levelno);
+                                        } else {
+                                                /* band border (global) */
+                                                band->x0 = int_ceildivpow2(tilec->x0 - (1 << levelno) * x0b, levelno + 1);
+                                                band->y0 = int_ceildivpow2(tilec->y0 - (1 << levelno) * y0b, levelno + 1);
+                                                band->x1 = int_ceildivpow2(tilec->x1 - (1 << levelno) * x0b, levelno + 1);
+                                                band->y1 = int_ceildivpow2(tilec->y1 - (1 << levelno) * y0b, levelno + 1);
+                                        }
+                                        
+                                        ss = &tccp->stepsizes[resno == 0 ? 0 : 3 * (resno - 1) + bandno + 1];
+                                        gain = tccp->qmfbid == 0 ? dwt_getgain_real(band->bandno) : dwt_getgain(band->bandno);
+                                        numbps = image->comps[compno].prec + gain;
+                                        band->stepsize = (float)((1.0 + ss->mant / 2048.0) * pow(2.0, numbps - ss->expn));
+                                        band->numbps = ss->expn + tccp->numgbits - 1;   /* WHY -1 ? */
+                                        
+                                        band->precincts = (opj_tcd_precinct_t *) opj_malloc(res->pw * res->ph * sizeof(opj_tcd_precinct_t));
+                                        
+                                        for (precno = 0; precno < res->pw * res->ph; precno++) {
+                                                int tlcblkxstart, tlcblkystart, brcblkxend, brcblkyend;
+                                                int cbgxstart = tlcbgxstart + (precno % res->pw) * (1 << cbgwidthexpn);
+                                                int cbgystart = tlcbgystart + (precno / res->pw) * (1 << cbgheightexpn);
+                                                int cbgxend = cbgxstart + (1 << cbgwidthexpn);
+                                                int cbgyend = cbgystart + (1 << cbgheightexpn);
+
+                                                opj_tcd_precinct_t *prc = &band->precincts[precno];
+                                                /* precinct size (global) */
+                                                prc->x0 = int_max(cbgxstart, band->x0);
+                                                prc->y0 = int_max(cbgystart, band->y0);
+                                                prc->x1 = int_min(cbgxend, band->x1);
+                                                prc->y1 = int_min(cbgyend, band->y1);
+                                                
+                                                tlcblkxstart = int_floordivpow2(prc->x0, cblkwidthexpn) << cblkwidthexpn;
+                                                tlcblkystart = int_floordivpow2(prc->y0, cblkheightexpn) << cblkheightexpn;
+                                                brcblkxend = int_ceildivpow2(prc->x1, cblkwidthexpn) << cblkwidthexpn;
+                                                brcblkyend = int_ceildivpow2(prc->y1, cblkheightexpn) << cblkheightexpn;
+                                                prc->cw = (brcblkxend - tlcblkxstart) >> cblkwidthexpn;
+                                                prc->ch = (brcblkyend - tlcblkystart) >> cblkheightexpn;
+                                                
+                                                prc->cblks = (opj_tcd_cblk_t *) opj_malloc(prc->cw * prc->ch * sizeof(opj_tcd_cblk_t));
+                                                
+                                                prc->incltree = tgt_create(prc->cw, prc->ch);
+                                                prc->imsbtree = tgt_create(prc->cw, prc->ch);
+                                                
+                                                for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
+                                                        int cblkxstart = tlcblkxstart + (cblkno % prc->cw) * (1 << cblkwidthexpn);
+                                                        int cblkystart = tlcblkystart + (cblkno / prc->cw) * (1 << cblkheightexpn);
+                                                        int cblkxend = cblkxstart + (1 << cblkwidthexpn);
+                                                        int cblkyend = cblkystart + (1 << cblkheightexpn);                                      
+                                                        
+                                                        /* code-block size (global) */
+                                                        opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
+                                                        cblk->x0 = int_max(cblkxstart, prc->x0);
+                                                        cblk->y0 = int_max(cblkystart, prc->y0);
+                                                        cblk->x1 = int_min(cblkxend, prc->x1);
+                                                        cblk->y1 = int_min(cblkyend, prc->y1);
+                                                }
+                                        } /* precno */
+                                } /* bandno */
+                        } /* resno */
+                } /* compno */
+        } /* i = 0..cp->tileno_size */
+
+        /* tcd_dump(stdout, tcd, &tcd->tcd_image); */
+
+        /* 
+        Allocate place to store the decoded data = final image
+        Place limited by the tile really present in the codestream 
+        */
+        
+        for (i = 0; i < image->numcomps; i++) {
+                for (j = 0; j < cp->tileno_size; j++) {
+                        tileno = cp->tileno[j];
+                        x0 = j == 0 ? tcd->tcd_image->tiles[tileno].comps[i].x0 : int_min(x0,
+                                (unsigned int) tcd->tcd_image->tiles[tileno].comps[i].x0);
+                        y0 = j == 0 ? tcd->tcd_image->tiles[tileno].comps[i].y0 : int_min(y0,
+                                (unsigned int) tcd->tcd_image->tiles[tileno].comps[i].y0);
+                        x1 = j == 0 ? tcd->tcd_image->tiles[tileno].comps[i].x1 : int_max(x1,
+                                (unsigned int) tcd->tcd_image->tiles[tileno].comps[i].x1);
+                        y1 = j == 0 ? tcd->tcd_image->tiles[tileno].comps[i].y1 : int_max(y1, 
+                                (unsigned int) tcd->tcd_image->tiles[tileno].comps[i].y1);
+                }
+                
+                w = x1 - x0;
+                h = y1 - y0;
+                
+                image->comps[i].data = (int *) opj_malloc(w * h * sizeof(int));
+                image->comps[i].w = w;
+                image->comps[i].h = h;
+                image->comps[i].x0 = x0;
+                image->comps[i].y0 = y0;
+        }
+}
+
+void tcd_makelayer_fixed(opj_tcd_t *tcd, int layno, int final) {
+        int compno, resno, bandno, precno, cblkno;
+        int value;                      /*, matrice[tcd_tcp->numlayers][tcd_tile->comps[0].numresolutions][3]; */
+        int matrice[10][10][3];
+        int i, j, k;
+
+        opj_cp_t *cp = tcd->cp;
+        opj_tcd_tile_t *tcd_tile = tcd->tcd_tile;
+        opj_tcp_t *tcd_tcp = tcd->tcp;
+
+        /*matrice=(int*)opj_malloc(tcd_tcp->numlayers*tcd_tile->comps[0].numresolutions*3*sizeof(int)); */
+        
+        for (compno = 0; compno < tcd_tile->numcomps; compno++) {
+                opj_tcd_tilecomp_t *tilec = &tcd_tile->comps[compno];
+                for (i = 0; i < tcd_tcp->numlayers; i++) {
+                        for (j = 0; j < tilec->numresolutions; j++) {
+                                for (k = 0; k < 3; k++) {
+                                        matrice[i][j][k] =
+                                                (int) (cp->matrice[i * tilec->numresolutions * 3 + j * 3 + k] 
+                                                * (float) (tcd->image->comps[compno].prec / 16.0));
+                                }
+                        }
+                }
+        
+                for (resno = 0; resno < tilec->numresolutions; resno++) {
+                        opj_tcd_resolution_t *res = &tilec->resolutions[resno];
+                        for (bandno = 0; bandno < res->numbands; bandno++) {
+                                opj_tcd_band_t *band = &res->bands[bandno];
+                                for (precno = 0; precno < res->pw * res->ph; precno++) {
+                                        opj_tcd_precinct_t *prc = &band->precincts[precno];
+                                        for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
+                                                opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
+                                                opj_tcd_layer_t *layer = &cblk->layers[layno];
+                                                int n;
+                                                int imsb = tcd->image->comps[compno].prec - cblk->numbps;       /* number of bit-plan equal to zero */
+                                                /* Correction of the matrix of coefficient to include the IMSB information */
+                                                if (layno == 0) {
+                                                        value = matrice[layno][resno][bandno];
+                                                        if (imsb >= value) {
+                                                                value = 0;
+                                                        } else {
+                                                                value -= imsb;
+                                                        }
+                                                } else {
+                                                        value = matrice[layno][resno][bandno] - matrice[layno - 1][resno][bandno];
+                                                        if (imsb >= matrice[layno - 1][resno][bandno]) {
+                                                                value -= (imsb - matrice[layno - 1][resno][bandno]);
+                                                                if (value < 0) {
+                                                                        value = 0;
+                                                                }
+                                                        }
+                                                }
+                                                
+                                                if (layno == 0) {
+                                                        cblk->numpassesinlayers = 0;
+                                                }
+                                                
+                                                n = cblk->numpassesinlayers;
+                                                if (cblk->numpassesinlayers == 0) {
+                                                        if (value != 0) {
+                                                                n = 3 * value - 2 + cblk->numpassesinlayers;
+                                                        } else {
+                                                                n = cblk->numpassesinlayers;
+                                                        }
+                                                } else {
+                                                        n = 3 * value + cblk->numpassesinlayers;
+                                                }
+                                                
+                                                layer->numpasses = n - cblk->numpassesinlayers;
+                                                
+                                                if (!layer->numpasses)
+                                                        continue;
+                                                
+                                                if (cblk->numpassesinlayers == 0) {
+                                                        layer->len = cblk->passes[n - 1].rate;
+                                                        layer->data = cblk->data;
+                                                } else {
+                                                        layer->len = cblk->passes[n - 1].rate - cblk->passes[cblk->numpassesinlayers - 1].rate;
+                                                        layer->data = cblk->data + cblk->passes[cblk->numpassesinlayers - 1].rate;
+                                                }
+                                                if (final)
+                                                        cblk->numpassesinlayers = n;
+                                        }
+                                }
+                        }
+                }
+        }
+}
+
+void tcd_rateallocate_fixed(opj_tcd_t *tcd) {
+        int layno;
+        for (layno = 0; layno < tcd->tcp->numlayers; layno++) {
+                tcd_makelayer_fixed(tcd, layno, 1);
+        }
+}
+
+void tcd_makelayer(opj_tcd_t *tcd, int layno, double thresh, int final) {
+        int compno, resno, bandno, precno, cblkno, passno;
+        
+        opj_tcd_tile_t *tcd_tile = tcd->tcd_tile;
+
+        tcd_tile->distolayer[layno] = 0;        /* fixed_quality */
+        
+        for (compno = 0; compno < tcd_tile->numcomps; compno++) {
+                opj_tcd_tilecomp_t *tilec = &tcd_tile->comps[compno];
+                for (resno = 0; resno < tilec->numresolutions; resno++) {
+                        opj_tcd_resolution_t *res = &tilec->resolutions[resno];
+                        for (bandno = 0; bandno < res->numbands; bandno++) {
+                                opj_tcd_band_t *band = &res->bands[bandno];
+                                for (precno = 0; precno < res->pw * res->ph; precno++) {
+                                        opj_tcd_precinct_t *prc = &band->precincts[precno];
+                                        for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
+                                                opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
+                                                opj_tcd_layer_t *layer = &cblk->layers[layno];
+                                                
+                                                int n;
+                                                if (layno == 0) {
+                                                        cblk->numpassesinlayers = 0;
+                                                }
+                                                n = cblk->numpassesinlayers;
+                                                for (passno = cblk->numpassesinlayers; passno < cblk->totalpasses; passno++) {
+                                                        int dr;
+                                                        double dd;
+                                                        opj_tcd_pass_t *pass = &cblk->passes[passno];
+                                                        if (n == 0) {
+                                                                dr = pass->rate;
+                                                                dd = pass->distortiondec;
+                                                        } else {
+                                                                dr = pass->rate - cblk->passes[n - 1].rate;
+                                                                dd = pass->distortiondec - cblk->passes[n - 1].distortiondec;
+                                                        }
+                                                        if (!dr) {
+                                                                if (dd != 0)
+                                                                        n = passno + 1;
+                                                                continue;
+                                                        }
+                                                        if (dd / dr >= thresh)
+                                                                n = passno + 1;
+                                                }
+                                                layer->numpasses = n - cblk->numpassesinlayers;
+                                                
+                                                if (!layer->numpasses) {
+                                                        layer->disto = 0;
+                                                        continue;
+                                                }
+                                                if (cblk->numpassesinlayers == 0) {
+                                                        layer->len = cblk->passes[n - 1].rate;
+                                                        layer->data = cblk->data;
+                                                        layer->disto = cblk->passes[n - 1].distortiondec;
+                                                } else {
+                                                        layer->len = cblk->passes[n - 1].rate - cblk->passes[cblk->numpassesinlayers - 1].rate;
+                                                        layer->data = cblk->data + cblk->passes[cblk->numpassesinlayers - 1].rate;
+                                                        layer->disto = cblk->passes[n - 1].distortiondec - cblk->passes[cblk->numpassesinlayers - 1].distortiondec;
+                                                }
+                                                
+                                                tcd_tile->distolayer[layno] += layer->disto;    /* fixed_quality */
+                                                
+                                                if (final)
+                                                        cblk->numpassesinlayers = n;
+                                        }
+                                }
+                        }
+                }
+        }
+}
+
+bool tcd_rateallocate(opj_tcd_t *tcd, unsigned char *dest, int len, opj_image_info_t * image_info) {
+        int compno, resno, bandno, precno, cblkno, passno, layno;
+        double min, max;
+        double cumdisto[100];   /* fixed_quality */
+        const double K = 1;             /* 1.1; fixed_quality */
+        double maxSE = 0;
+
+        opj_cp_t *cp = tcd->cp;
+        opj_tcd_tile_t *tcd_tile = tcd->tcd_tile;
+        opj_tcp_t *tcd_tcp = tcd->tcp;
+
+        min = DBL_MAX;
+        max = 0;
+        
+        tcd_tile->nbpix = 0;            /* fixed_quality */
+        
+        for (compno = 0; compno < tcd_tile->numcomps; compno++) {
+                opj_tcd_tilecomp_t *tilec = &tcd_tile->comps[compno];
+                tilec->nbpix = 0;
+
+                for (resno = 0; resno < tilec->numresolutions; resno++) {
+                        opj_tcd_resolution_t *res = &tilec->resolutions[resno];
+
+                        for (bandno = 0; bandno < res->numbands; bandno++) {
+                                opj_tcd_band_t *band = &res->bands[bandno];
+
+                                for (precno = 0; precno < res->pw * res->ph; precno++) {
+                                        opj_tcd_precinct_t *prc = &band->precincts[precno];
+
+                                        for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
+                                                opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
+
+                                                for (passno = 0; passno < cblk->totalpasses; passno++) {
+                                                        opj_tcd_pass_t *pass = &cblk->passes[passno];
+                                                        int dr;
+                                                        double dd, rdslope;
+                                                        if (passno == 0) {
+                                                                dr = pass->rate;
+                                                                dd = pass->distortiondec;
+                                                        } else {
+                                                                dr = pass->rate - cblk->passes[passno - 1].rate;
+                                                                dd = pass->distortiondec - cblk->passes[passno - 1].distortiondec;
+                                                        }
+                                                        if (dr == 0) {
+                                                                continue;
+                                                        }
+                                                        rdslope = dd / dr;
+                                                        if (rdslope < min) {
+                                                                min = rdslope;
+                                                        }
+                                                        if (rdslope > max) {
+                                                                max = rdslope;
+                                                        }
+                                                } /* passno */
+                                                
+                                                /* fixed_quality */
+                                                tcd_tile->nbpix += ((cblk->x1 - cblk->x0) * (cblk->y1 - cblk->y0));
+                                                tilec->nbpix += ((cblk->x1 - cblk->x0) * (cblk->y1 - cblk->y0));
+                                        } /* cbklno */
+                                } /* precno */
+                        } /* bandno */
+                } /* resno */
+                
+                maxSE += (((double)(1 << tcd->image->comps[compno].prec) - 1.0) 
+                        * ((double)(1 << tcd->image->comps[compno].prec) -1.0)) 
+                        * ((double)(tilec->nbpix));
+        } /* compno */
+        
+        /* index file */
+        if(image_info && image_info->index_on) {
+                opj_tile_info_t *tile_info = &image_info->tile[tcd->tcd_tileno];
+                tile_info->nbpix = tcd_tile->nbpix;
+                tile_info->distotile = tcd_tile->distotile;
+                tile_info->thresh = (double *) opj_malloc(tcd_tcp->numlayers * sizeof(double));
+        }
+        
+        for (layno = 0; layno < tcd_tcp->numlayers; layno++) {
+                double lo = min;
+                double hi = max;
+                int success = 0;
+                /* TODO: remove maxlen */
+                int maxlen = tcd_tcp->rates[layno] ? int_min(((int) ceil(tcd_tcp->rates[layno])), len) : len;
+                double goodthresh = 0;
+                double stable_thresh = 0;
+                int i;
+                double distotarget;             /* fixed_quality */
+                
+                /* fixed_quality */
+                distotarget = tcd_tile->distotile - ((K * maxSE) / pow((float)10, tcd_tcp->distoratio[layno] / 10));
+        
+                if ((tcd_tcp->rates[layno]) || (cp->disto_alloc == 0)) {
+                        opj_t2_t *t2 = t2_create(tcd->cinfo, tcd->image, cp);
+
+                        for (i = 0; i < 32; i++) {
+                                double thresh = (lo + hi) / 2;
+                                int l = 0;
+                                double distoachieved = 0;       /* fixed_quality */
+                                
+                                tcd_makelayer(tcd, layno, thresh, 0);
+                                
+                                if (cp->fixed_quality) {        /* fixed_quality */
+                                        if(cp->cinema){
+                                                l = t2_encode_packets(t2,tcd->tcd_tileno, tcd_tile, layno + 1, dest, maxlen, image_info,tcd->cur_tp_num,tcd->tp_pos,tcd->cur_pino,THRESH_CALC);
+                                                if (l == -999) {
+                                                        lo = thresh;
+                                                        continue;
+                                                }else{
+                        distoachieved = layno == 0 ? 
+                                                        tcd_tile->distolayer[0] : cumdisto[layno - 1] + tcd_tile->distolayer[layno];
+                                                        if (distoachieved < distotarget) {
+                                                                hi=thresh; 
+                                                                stable_thresh = thresh;
+                                                                continue;
+                                                        }else{
+                                                                lo=thresh;
+                                                        }
+                                                }
+                                        }else{
+                                                distoachieved = (layno == 0) ? 
+                                                        tcd_tile->distolayer[0] : (cumdisto[layno - 1] + tcd_tile->distolayer[layno]);
+                                                if (distoachieved < distotarget) {
+                                                        hi = thresh;
+                                                        stable_thresh = thresh;
+                                                        continue;
+                                                }
+                                                lo = thresh;
+                                        }
+                                } else {
+                                        l = t2_encode_packets(t2, tcd->tcd_tileno, tcd_tile, layno + 1, dest, maxlen, image_info,tcd->cur_tp_num,tcd->tp_pos,tcd->cur_pino,THRESH_CALC);
+                                        /* TODO: what to do with l ??? seek / tell ??? */
+                                        /* opj_event_msg(tcd->cinfo, EVT_INFO, "rate alloc: len=%d, max=%d\n", l, maxlen); */
+                                        if (l == -999) {
+                                                lo = thresh;
+                                                continue;
+                                        }
+                                        hi = thresh;
+                                        stable_thresh = thresh;
+                                }
+                        }
+                        success = 1;
+                        goodthresh = stable_thresh;
+                        t2_destroy(t2);
+                } else {
+                        success = 1;
+                        goodthresh = min;
+                }
+                
+                if (!success) {
+                        return false;
+                }
+                
+                if(image_info && image_info->index_on) {        /* Threshold for Marcela Index */
+                        image_info->tile[tcd->tcd_tileno].thresh[layno] = goodthresh;
+                }
+                tcd_makelayer(tcd, layno, goodthresh, 1);
+        
+                /* fixed_quality */
+                cumdisto[layno] = (layno == 0) ? tcd_tile->distolayer[0] : (cumdisto[layno - 1] + tcd_tile->distolayer[layno]); 
+        }
+
+        return true;
+}
+
+int tcd_encode_tile(opj_tcd_t *tcd, int tileno, unsigned char *dest, int len, opj_image_info_t * image_info) {
+        int compno;
+        int l, i, npck = 0;
+        opj_tcd_tile_t *tile = NULL;
+        opj_tcp_t *tcd_tcp = NULL;
+        opj_cp_t *cp = NULL;
+
+        opj_tcp_t *tcp = &tcd->cp->tcps[0];
+        opj_tccp_t *tccp = &tcp->tccps[0];
+        opj_image_t *image = tcd->image;
+        
+        opj_t1_t *t1 = NULL;            /* T1 component */
+        opj_t2_t *t2 = NULL;            /* T2 component */
+
+        tcd->tcd_tileno = tileno;
+        tcd->tcd_tile = tcd->tcd_image->tiles;
+        tcd->tcp = &tcd->cp->tcps[tileno];
+
+        tile = tcd->tcd_tile;
+        tcd_tcp = tcd->tcp;
+        cp = tcd->cp;
+
+        if(tcd->cur_tp_num == 0){
+                tcd->encoding_time = opj_clock();       /* time needed to encode a tile */
+                /* INDEX >> "Precinct_nb_X et Precinct_nb_Y" */
+                if(image_info && image_info->index_on) {
+                        opj_tcd_tilecomp_t *tilec_idx = &tile->comps[0];        /* based on component 0 */
+                        for (i = 0; i < tilec_idx->numresolutions; i++) {
+                                opj_tcd_resolution_t *res_idx = &tilec_idx->resolutions[i];
+                                
+                                image_info->tile[tileno].pw[i] = res_idx->pw;
+                                image_info->tile[tileno].ph[i] = res_idx->ph;
+                                
+                                npck += res_idx->pw * res_idx->ph;
+                                
+                                image_info->tile[tileno].pdx[i] = tccp->prcw[i];
+                                image_info->tile[tileno].pdy[i] = tccp->prch[i];
+                        }
+                        image_info->tile[tileno].packet = (opj_packet_info_t *) opj_malloc(image_info->comp * image_info->layer * npck * sizeof(opj_packet_info_t));
+                }
+                /* << INDEX */
+                
+                /*---------------TILE-------------------*/
+                
+                for (compno = 0; compno < tile->numcomps; compno++) {
+                        int x, y;
+                        
+                        int adjust = image->comps[compno].sgnd ? 0 : 1 << (image->comps[compno].prec - 1);
+                        int offset_x = int_ceildiv(image->x0, image->comps[compno].dx);
+                        int offset_y = int_ceildiv(image->y0, image->comps[compno].dy);
+                        
+                        opj_tcd_tilecomp_t *tilec = &tile->comps[compno];
+                        int tw = tilec->x1 - tilec->x0;
+                        int w = int_ceildiv(image->x1 - image->x0, image->comps[compno].dx);
+                        
+                        /* extract tile data */
+                        
+                        if (tcd_tcp->tccps[compno].qmfbid == 1) {
+                                for (y = tilec->y0; y < tilec->y1; y++) {
+                                        /* start of the src tile scanline */
+                                        int *data = &image->comps[compno].data[(tilec->x0 - offset_x) + (y - offset_y) * w];
+                                        /* start of the dst tile scanline */
+                                        int *tile_data = &tilec->data[(y - tilec->y0) * tw];
+                                        for (x = tilec->x0; x < tilec->x1; x++) {
+                                                *tile_data++ = *data++ - adjust;
+                                        }
+                                }
+                        } else if (tcd_tcp->tccps[compno].qmfbid == 0) {
+                                for (y = tilec->y0; y < tilec->y1; y++) {
+                                        /* start of the src tile scanline */
+                                        int *data = &image->comps[compno].data[(tilec->x0 - offset_x) + (y - offset_y) * w];
+                                        /* start of the dst tile scanline */
+                                        int *tile_data = &tilec->data[(y - tilec->y0) * tw];
+                                        for (x = tilec->x0; x < tilec->x1; x++) {
+                                                *tile_data++ = (*data++ - adjust) << 11;
+                                        }
+                                        
+                                }
+                        }
+                }
+                
+                /*----------------MCT-------------------*/
+                if (tcd_tcp->mct) {
+                        int samples = (tile->comps[0].x1 - tile->comps[0].x0) * (tile->comps[0].y1 - tile->comps[0].y0);
+                        if (tcd_tcp->tccps[0].qmfbid == 0) {
+                                mct_encode_real(tile->comps[0].data, tile->comps[1].data, tile->comps[2].data, samples);
+                        } else {
+                                mct_encode(tile->comps[0].data, tile->comps[1].data, tile->comps[2].data, samples);
+                        }
+                }
+                
+                /*----------------DWT---------------------*/
+                
+                for (compno = 0; compno < tile->numcomps; compno++) {
+                        opj_tcd_tilecomp_t *tilec = &tile->comps[compno];
+                        if (tcd_tcp->tccps[compno].qmfbid == 1) {
+                                dwt_encode(tilec);
+                        } else if (tcd_tcp->tccps[compno].qmfbid == 0) {
+                                dwt_encode_real(tilec);
+                        }
+                }
+                
+                /*------------------TIER1-----------------*/
+                t1 = t1_create(tcd->cinfo);
+                t1_encode_cblks(t1, tile, tcd_tcp);
+                t1_destroy(t1);
+                
+                /*-----------RATE-ALLOCATE------------------*/
+                
+                /* INDEX */
+                if(image_info) {
+                        image_info->index_write = 0;
+                }
+                if (cp->disto_alloc || cp->fixed_quality) {     /* fixed_quality */
+                        /* Normal Rate/distortion allocation */
+                        tcd_rateallocate(tcd, dest, len, image_info);
+                } else {
+                        /* Fixed layer allocation */
+                        tcd_rateallocate_fixed(tcd);
+                }
+        }
+        /*--------------TIER2------------------*/
+
+        /* INDEX */
+        if(image_info) {
+                image_info->index_write = 1;
+        }
+
+        t2 = t2_create(tcd->cinfo, image, cp);
+        l = t2_encode_packets(t2,tileno, tile, tcd_tcp->numlayers, dest, len, image_info,tcd->tp_num,tcd->tp_pos,tcd->cur_pino,FINAL_PASS);
+        t2_destroy(t2);
+        
+        /*---------------CLEAN-------------------*/
+
+        
+        if(tcd->cur_tp_num == tcd->cur_totnum_tp - 1){
+                tcd->encoding_time = opj_clock() - tcd->encoding_time;
+                opj_event_msg(tcd->cinfo, EVT_INFO, "- tile encoded in %f s\n", tcd->encoding_time);
+        
+                /* cleaning memory */
+                for (compno = 0; compno < tile->numcomps; compno++) {
+                        opj_tcd_tilecomp_t *tilec = &tile->comps[compno];
+                        opj_free(tilec->data);
+                }
+        }
+        
+        return l;
+}
+
+bool tcd_decode_tile(opj_tcd_t *tcd, unsigned char *src, int len, int tileno) {
+        int l;
+        int compno;
+        int eof = 0;
+        double tile_time, t1_time, dwt_time;
+        opj_tcd_tile_t *tile = NULL;
+
+        opj_t1_t *t1 = NULL;            /* T1 component */
+        opj_t2_t *t2 = NULL;            /* T2 component */
+        
+        tcd->tcd_tileno = tileno;
+        tcd->tcd_tile = &(tcd->tcd_image->tiles[tileno]);
+        tcd->tcp = &(tcd->cp->tcps[tileno]);
+        tile = tcd->tcd_tile;
+        
+        tile_time = opj_clock();        /* time needed to decode a tile */
+        opj_event_msg(tcd->cinfo, EVT_INFO, "tile %d of %d\n", tileno + 1, tcd->cp->tw * tcd->cp->th);
+        
+        /*--------------TIER2------------------*/
+        
+        t2 = t2_create(tcd->cinfo, tcd->image, tcd->cp);
+        l = t2_decode_packets(t2, src, len, tileno, tile);
+        t2_destroy(t2);
+
+        if (l == -999) {
+                eof = 1;
+                opj_event_msg(tcd->cinfo, EVT_ERROR, "tcd_decode: incomplete bistream\n");
+        }
+        
+        /*------------------TIER1-----------------*/
+        
+        t1_time = opj_clock();  /* time needed to decode a tile */
+        t1 = t1_create(tcd->cinfo);
+        t1_decode_cblks(t1, tile, tcd->tcp);
+        t1_destroy(t1);
+        t1_time = opj_clock() - t1_time;
+        opj_event_msg(tcd->cinfo, EVT_INFO, "- tiers-1 took %f s\n", t1_time);
+        
+        /*----------------DWT---------------------*/
+
+        dwt_time = opj_clock(); /* time needed to decode a tile */
+        for (compno = 0; compno < tile->numcomps; compno++) {
+                opj_tcd_tilecomp_t *tilec = &tile->comps[compno];
+                if (tcd->cp->reduce != 0) {
+                        tcd->image->comps[compno].resno_decoded =
+                                tile->comps[compno].numresolutions - tcd->cp->reduce - 1;
+                }
+        
+                if (tcd->tcp->tccps[compno].qmfbid == 1) {
+                        dwt_decode(tilec, tilec->numresolutions - 1 - tcd->image->comps[compno].resno_decoded);
+                } else {
+                        dwt_decode_real(tilec, tilec->numresolutions - 1 - tcd->image->comps[compno].resno_decoded);
+                }
+
+                if (tile->comps[compno].numresolutions > 0) {
+                        tcd->image->comps[compno].factor = tile->comps[compno].numresolutions - (tcd->image->comps[compno].resno_decoded + 1);
+                }
+        }
+        dwt_time = opj_clock() - dwt_time;
+        opj_event_msg(tcd->cinfo, EVT_INFO, "- dwt took %f s\n", dwt_time);
+        
+        /*----------------MCT-------------------*/
+        
+        if (tcd->tcp->mct) {
+                if (tcd->tcp->tccps[0].qmfbid == 1) {
+                        mct_decode(tile->comps[0].data, tile->comps[1].data, tile->comps[2].data, 
+                                (tile->comps[0].x1 - tile->comps[0].x0) * (tile->comps[0].y1 - tile->comps[0].y0));
+                } else {
+                        mct_decode_real(tile->comps[0].data, tile->comps[1].data, tile->comps[2].data, 
+                                (tile->comps[0].x1 - tile->comps[0].x0) * (tile->comps[0].y1 - tile->comps[0].y0));
+                }
+        }
+        
+        /*---------------TILE-------------------*/
+        
+        for (compno = 0; compno < tile->numcomps; compno++) {
+                opj_tcd_tilecomp_t *tilec = &tile->comps[compno];
+                opj_tcd_resolution_t *res =     &tilec->resolutions[tcd->image->comps[compno].resno_decoded];
+                int adjust = tcd->image->comps[compno].sgnd ? 0 : 1 << (tcd->image->comps[compno].prec - 1);
+                int min = tcd->image->comps[compno].sgnd ? 
+                        -(1 << (tcd->image->comps[compno].prec - 1)) : 0;
+                int max = tcd->image->comps[compno].sgnd ? 
+                        (1 << (tcd->image->comps[compno].prec - 1)) - 1 : (1 << tcd->image->comps[compno].prec) - 1;
+                
+                int tw = tilec->x1 - tilec->x0;
+                int w = tcd->image->comps[compno].w;
+                
+                int i, j;
+                int offset_x = int_ceildivpow2(tcd->image->comps[compno].x0, tcd->image->comps[compno].factor);
+                int offset_y = int_ceildivpow2(tcd->image->comps[compno].y0, tcd->image->comps[compno].factor);
+                
+                for (j = res->y0; j < res->y1; j++) {
+                        for (i = res->x0; i < res->x1; i++) {
+                                int v;
+                                float tmp = (float)((tilec->data[i - res->x0 + (j - res->y0) * tw]) / 8192.0);
+
+                                if (tcd->tcp->tccps[compno].qmfbid == 1) {
+                                        v = tilec->data[i - res->x0 + (j - res->y0) * tw];
+                                } else {
+                                        int tmp2 = ((int) (floor(fabs(tmp)))) + ((int) floor(fabs(tmp*2))%2);
+                                        v = ((tmp < 0) ? -tmp2:tmp2);
+                                }
+                                v += adjust;
+                                
+                                tcd->image->comps[compno].data[(i - offset_x) + (j - offset_y) * w] = int_clamp(v, min, max);
+                        }
+                }
+        }
+        
+        tile_time = opj_clock() - tile_time;    /* time needed to decode a tile */
+        opj_event_msg(tcd->cinfo, EVT_INFO, "- tile decoded in %f s\n", tile_time);
+                
+        for (compno = 0; compno < tile->numcomps; compno++) {
+                opj_free(tcd->tcd_image->tiles[tileno].comps[compno].data);
+                tcd->tcd_image->tiles[tileno].comps[compno].data = NULL;
+        }
+        
+        if (eof) {
+                return false;
+        }
+        
+        return true;
+}
+
+void tcd_free_decode(opj_tcd_t *tcd) {
+        int tileno,compno,resno,bandno,precno;
+
+        opj_tcd_image_t *tcd_image = tcd->tcd_image;
+        
+        for (tileno = 0; tileno < tcd_image->tw * tcd_image->th; tileno++) {
+                opj_tcd_tile_t *tile = &tcd_image->tiles[tileno];
+                for (compno = 0; compno < tile->numcomps; compno++) {
+                        opj_tcd_tilecomp_t *tilec = &tile->comps[compno];
+                        for (resno = 0; resno < tilec->numresolutions; resno++) {
+                                opj_tcd_resolution_t *res = &tilec->resolutions[resno];
+                                for (bandno = 0; bandno < res->numbands; bandno++) {
+                                        opj_tcd_band_t *band = &res->bands[bandno];
+                                        for (precno = 0; precno < res->ph * res->pw; precno++) {
+                                                opj_tcd_precinct_t *prec = &band->precincts[precno];
+                                                if (prec->cblks != NULL) opj_free(prec->cblks);
+                                                if (prec->imsbtree != NULL) tgt_destroy(prec->imsbtree);
+                                                if (prec->incltree != NULL) tgt_destroy(prec->incltree);
+                                        }
+                                        if (band->precincts != NULL) opj_free(band->precincts);
+                                }
+                        }
+                        if (tilec->resolutions != NULL) opj_free(tilec->resolutions);
+                }
+                if (tile->comps != NULL) opj_free(tile->comps);
+        }
+
+        if (tcd_image->tiles != NULL) opj_free(tcd_image->tiles);
+}
+
diff --git a/libraries/openjpeg-libsl/libopenjpeg/tcd.h b/libraries/openjpeg-libsl/libopenjpeg/tcd.h
new file mode 100644
index 0000000..ae66709
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/tcd.h
@@ -0,0 +1,270 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __TCD_H
+#define __TCD_H
+/**
+@file tcd.h
+@brief Implementation of a tile coder/decoder (TCD)
+
+The functions in TCD.C have for goal to encode or decode each tile independently from
+each other. The functions in TCD.C are used by some function in J2K.C.
+*/
+
+/** @defgroup TCD TCD - Implementation of a tile coder/decoder */
+/*@{*/
+
+/**
+FIXME: documentation
+*/
+typedef struct opj_tcd_seg {
+  int numpasses;
+  int len;
+  unsigned char *data;
+  int maxpasses;
+  int numnewpasses;
+  int newlen;
+} opj_tcd_seg_t;
+
+/**
+FIXME: documentation
+*/
+typedef struct opj_tcd_pass {
+  int rate;
+  double distortiondec;
+  int term, len;
+} opj_tcd_pass_t;
+
+/**
+FIXME: documentation
+*/
+typedef struct opj_tcd_layer {
+  int numpasses;                /* Number of passes in the layer */
+  int len;                      /* len of information */
+  double disto;                 /* add for index (Cfr. Marcela) */
+  unsigned char *data;          /* data */
+} opj_tcd_layer_t;
+
+/**
+FIXME: documentation
+*/
+typedef struct opj_tcd_cblk {
+  int x0, y0, x1, y1;           /* dimension of the code-blocks : left upper corner (x0, y0) right low corner (x1,y1) */
+  int numbps;
+  int numlenbits;
+  int len;                      /* length */
+  int numpasses;                /* number of pass already done for the code-blocks */
+  int numnewpasses;             /* number of pass added to the code-blocks */
+  int numsegs;                  /* number of segments */
+  opj_tcd_seg_t segs[100];              /* segments informations */
+  unsigned char data[8192];     /* Data */
+  int numpassesinlayers;        /* number of passes in the layer */
+  opj_tcd_layer_t layers[100];  /* layer information */
+  int totalpasses;              /* total number of passes */
+  opj_tcd_pass_t passes[100];   /* information about the passes */
+} opj_tcd_cblk_t;
+
+/**
+FIXME: documentation
+*/
+typedef struct opj_tcd_precinct {
+  int x0, y0, x1, y1;           /* dimension of the precinct : left upper corner (x0, y0) right low corner (x1,y1) */
+  int cw, ch;                   /* number of precinct in width and heigth */
+  opj_tcd_cblk_t *cblks;                /* code-blocks informations */
+  opj_tgt_tree_t *incltree;             /* inclusion tree */
+  opj_tgt_tree_t *imsbtree;             /* IMSB tree */
+} opj_tcd_precinct_t;
+
+/**
+FIXME: documentation
+*/
+typedef struct opj_tcd_band {
+  int x0, y0, x1, y1;           /* dimension of the subband : left upper corner (x0, y0) right low corner (x1,y1) */
+  int bandno;
+  opj_tcd_precinct_t *precincts;        /* precinct information */
+  int numbps;
+  float stepsize;
+} opj_tcd_band_t;
+
+/**
+FIXME: documentation
+*/
+typedef struct opj_tcd_resolution {
+  int x0, y0, x1, y1;           /* dimension of the resolution level : left upper corner (x0, y0) right low corner (x1,y1) */
+  int pw, ph;
+  int numbands;                 /* number sub-band for the resolution level */
+  opj_tcd_band_t bands[3];              /* subband information */
+} opj_tcd_resolution_t;
+
+/**
+FIXME: documentation
+*/
+typedef struct opj_tcd_tilecomp {
+  int x0, y0, x1, y1;           /* dimension of component : left upper corner (x0, y0) right low corner (x1,y1) */
+  int numresolutions;           /* number of resolutions level */
+  opj_tcd_resolution_t *resolutions;    /* resolutions information */
+  int *data;                    /* data of the component */
+  int nbpix;                    /* add fixed_quality */
+} opj_tcd_tilecomp_t;
+
+/**
+FIXME: documentation
+*/
+typedef struct opj_tcd_tile {
+  int x0, y0, x1, y1;           /* dimension of the tile : left upper corner (x0, y0) right low corner (x1,y1) */
+  int numcomps;                 /* number of components in tile */
+  opj_tcd_tilecomp_t *comps;    /* Components information */
+  int nbpix;                    /* add fixed_quality */
+  double distotile;             /* add fixed_quality */
+  double distolayer[100];       /* add fixed_quality */
+} opj_tcd_tile_t;
+
+/**
+FIXME: documentation
+*/
+typedef struct opj_tcd_image {
+  int tw, th;                   /* number of tiles in width and heigth */
+  opj_tcd_tile_t *tiles;                /* Tiles information */
+} opj_tcd_image_t;
+
+/**
+Tile coder/decoder
+*/
+typedef struct opj_tcd {
+        /** Position of the tilepart flag in Progression order*/
+        int tp_pos;
+        /** Tile part number*/
+        int tp_num;
+        /** Current tile part number*/
+        int cur_tp_num;
+        /** Total number of tileparts of the current tile*/
+        int cur_totnum_tp;
+        /** Current Packet iterator number */
+        int cur_pino;
+        /** codec context */
+        opj_common_ptr cinfo;
+
+        /** info on each image tile */
+        opj_tcd_image_t *tcd_image;
+        /** image */
+        opj_image_t *image;
+        /** coding parameters */
+        opj_cp_t *cp;
+        /** pointer to the current encoded/decoded tile */
+        opj_tcd_tile_t *tcd_tile;
+        /** coding/decoding parameters common to all tiles */
+        opj_tcp_t *tcp;
+        /** current encoded/decoded tile */
+        int tcd_tileno;
+        /** Time taken to encode a tile*/
+        double encoding_time;
+} opj_tcd_t;
+
+/** @name Exported functions */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+
+/**
+Dump the content of a tcd structure
+*/
+void tcd_dump(FILE *fd, opj_tcd_t *tcd, opj_tcd_image_t *img);
+/**
+Create a new TCD handle
+@param cinfo Codec context info
+@return Returns a new TCD handle if successful returns NULL otherwise
+*/
+opj_tcd_t* tcd_create(opj_common_ptr cinfo);
+/**
+Destroy a previously created TCD handle
+@param tcd TCD handle to destroy
+*/
+void tcd_destroy(opj_tcd_t *tcd);
+/**
+Initialize the tile coder (allocate the memory)
+@param tcd TCD handle
+@param image Raw image
+@param cp Coding parameters
+@param curtileno Number that identifies the tile that will be encoded
+*/
+void tcd_malloc_encode(opj_tcd_t *tcd, opj_image_t * image, opj_cp_t * cp, int curtileno);
+/**
+Free the memory allocated for encoding
+@param tcd TCD handle
+*/
+void tcd_free_encode(opj_tcd_t *tcd);
+/**
+Initialize the tile coder (reuses the memory allocated by tcd_malloc_encode)
+@param tcd TCD handle
+@param image Raw image
+@param cp Coding parameters
+@param curtileno Number that identifies the tile that will be encoded
+*/
+void tcd_init_encode(opj_tcd_t *tcd, opj_image_t * image, opj_cp_t * cp, int curtileno);
+/**
+Initialize the tile decoder
+@param tcd TCD handle
+@param image Raw image
+@param cp Coding parameters
+*/
+void tcd_malloc_decode(opj_tcd_t *tcd, opj_image_t * image, opj_cp_t * cp);
+void tcd_makelayer_fixed(opj_tcd_t *tcd, int layno, int final);
+void tcd_rateallocate_fixed(opj_tcd_t *tcd);
+void tcd_makelayer(opj_tcd_t *tcd, int layno, double thresh, int final);
+bool tcd_rateallocate(opj_tcd_t *tcd, unsigned char *dest, int len, opj_image_info_t * image_info);
+/**
+Encode a tile from the raw image into a buffer
+@param tcd TCD handle
+@param tileno Number that identifies one of the tiles to be encoded
+@param dest Destination buffer
+@param len Length of destination buffer
+@param image_info Creation of index file
+@return 
+*/
+int tcd_encode_tile(opj_tcd_t *tcd, int tileno, unsigned char *dest, int len, opj_image_info_t * image_info);
+/**
+Decode a tile from a buffer into a raw image
+@param tcd TCD handle
+@param src Source buffer
+@param len Length of source buffer
+@param tileno Number that identifies one of the tiles to be decoded
+*/
+bool tcd_decode_tile(opj_tcd_t *tcd, unsigned char *src, int len, int tileno);
+/**
+Free the memory allocated for decoding
+@param tcd TCD handle
+*/
+void tcd_free_decode(opj_tcd_t *tcd);
+
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __TCD_H */
diff --git a/libraries/openjpeg-libsl/libopenjpeg/tgt.c b/libraries/openjpeg-libsl/libopenjpeg/tgt.c
new file mode 100644
index 0000000..30b0aee
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/tgt.c
@@ -0,0 +1,213 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "opj_includes.h"
+
+/* 
+==========================================================
+   Tag-tree coder interface
+==========================================================
+*/
+
+opj_tgt_tree_t *tgt_create(int numleafsh, int numleafsv) {
+        int nplh[32];
+        int nplv[32];
+        opj_tgt_node_t *node = NULL;
+        opj_tgt_node_t *parentnode = NULL;
+        opj_tgt_node_t *parentnode0 = NULL;
+        opj_tgt_tree_t *tree = NULL;
+        int i, j, k;
+        int numlvls;
+        int n;
+
+        tree = (opj_tgt_tree_t *) opj_malloc(sizeof(opj_tgt_tree_t));
+        if(!tree) return NULL;
+        tree->numleafsh = numleafsh;
+        tree->numleafsv = numleafsv;
+
+        numlvls = 0;
+        nplh[0] = numleafsh;
+        nplv[0] = numleafsv;
+        tree->numnodes = 0;
+        do {
+                n = nplh[numlvls] * nplv[numlvls];
+                nplh[numlvls + 1] = (nplh[numlvls] + 1) / 2;
+                nplv[numlvls + 1] = (nplv[numlvls] + 1) / 2;
+                tree->numnodes += n;
+                ++numlvls;
+        } while (n > 1);
+        
+        /* ADD */
+        if (tree->numnodes == 0) {
+                opj_free(tree);
+                return NULL;
+        }
+
+        tree->nodes = (opj_tgt_node_t *) opj_malloc(tree->numnodes * sizeof(opj_tgt_node_t));
+        if(!tree->nodes) {
+                opj_free(tree);
+                return NULL;
+        }
+
+        node = tree->nodes;
+        parentnode = &tree->nodes[tree->numleafsh * tree->numleafsv];
+        parentnode0 = parentnode;
+        
+        for (i = 0; i < numlvls - 1; ++i) {
+                for (j = 0; j < nplv[i]; ++j) {
+                        k = nplh[i];
+                        while (--k >= 0) {
+                                node->parent = parentnode;
+                                ++node;
+                                if (--k >= 0) {
+                                        node->parent = parentnode;
+                                        ++node;
+                                }
+                                ++parentnode;
+                        }
+                        if ((j & 1) || j == nplv[i] - 1) {
+                                parentnode0 = parentnode;
+                        } else {
+                                parentnode = parentnode0;
+                                parentnode0 += nplh[i];
+                        }
+                }
+        }
+        node->parent = 0;
+        
+        tgt_reset(tree);
+        
+        return tree;
+}
+
+void tgt_destroy(opj_tgt_tree_t *tree) {
+        opj_free(tree->nodes);
+        opj_free(tree);
+}
+
+void tgt_reset(opj_tgt_tree_t *tree) {
+        int i;
+
+        if (NULL == tree)
+                return;
+        
+        for (i = 0; i < tree->numnodes; i++) {
+                tree->nodes[i].value = 999;
+                tree->nodes[i].low = 0;
+                tree->nodes[i].known = 0;
+        }
+}
+
+void tgt_setvalue(opj_tgt_tree_t *tree, int leafno, int value) {
+        opj_tgt_node_t *node;
+        node = &tree->nodes[leafno];
+        while (node && node->value > value) {
+                node->value = value;
+                node = node->parent;
+        }
+}
+
+void tgt_encode(opj_bio_t *bio, opj_tgt_tree_t *tree, int leafno, int threshold) {
+        opj_tgt_node_t *stk[31];
+        opj_tgt_node_t **stkptr;
+        opj_tgt_node_t *node;
+        int low;
+
+        stkptr = stk;
+        node = &tree->nodes[leafno];
+        while (node->parent) {
+                *stkptr++ = node;
+                node = node->parent;
+        }
+        
+        low = 0;
+        for (;;) {
+                if (low > node->low) {
+                        node->low = low;
+                } else {
+                        low = node->low;
+                }
+                
+                while (low < threshold) {
+                        if (low >= node->value) {
+                                if (!node->known) {
+                                        bio_write(bio, 1, 1);
+                                        node->known = 1;
+                                }
+                                break;
+                        }
+                        bio_write(bio, 0, 1);
+                        ++low;
+                }
+                
+                node->low = low;
+                if (stkptr == stk)
+                        break;
+                node = *--stkptr;
+        }
+}
+
+int tgt_decode(opj_bio_t *bio, opj_tgt_tree_t *tree, int leafno, int threshold) {
+        opj_tgt_node_t *stk[31];
+        opj_tgt_node_t **stkptr;
+        opj_tgt_node_t *node;
+        int low;
+
+        stkptr = stk;
+        node = &tree->nodes[leafno];
+        while (node->parent) {
+                *stkptr++ = node;
+                node = node->parent;
+        }
+        
+        low = 0;
+        for (;;) {
+                if (low > node->low) {
+                        node->low = low;
+                } else {
+                        low = node->low;
+                }
+                while (low < threshold && low < node->value) {
+                        if (bio_read(bio, 1)) {
+                                node->value = low;
+                        } else {
+                                ++low;
+                        }
+                }
+                node->low = low;
+                if (stkptr == stk) {
+                        break;
+                }
+                node = *--stkptr;
+        }
+        
+        return (node->value < threshold) ? 1 : 0;
+}
diff --git a/libraries/openjpeg-libsl/libopenjpeg/tgt.h b/libraries/openjpeg-libsl/libopenjpeg/tgt.h
new file mode 100644
index 0000000..c08c8da
--- /dev/null
+++ b/libraries/openjpeg-libsl/libopenjpeg/tgt.h
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __TGT_H
+#define __TGT_H
+/**
+@file tgt.h
+@brief Implementation of a tag-tree coder (TGT)
+
+The functions in TGT.C have for goal to realize a tag-tree coder. The functions in TGT.C
+are used by some function in T2.C.
+*/
+
+/** @defgroup TGT TGT - Implementation of a tag-tree coder */
+/*@{*/
+
+/**
+Tag node
+*/
+typedef struct opj_tgt_node {
+  struct opj_tgt_node *parent;
+  int value;
+  int low;
+  int known;
+} opj_tgt_node_t;
+
+/**
+Tag tree
+*/
+typedef struct opj_tgt_tree {
+  int numleafsh;
+  int numleafsv;
+  int numnodes;
+  opj_tgt_node_t *nodes;
+} opj_tgt_tree_t;
+
+/** @name Exported functions */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+/**
+Create a tag-tree
+@param numleafsh Width of the array of leafs of the tree
+@param numleafsv Height of the array of leafs of the tree
+@return Returns a new tag-tree if successful, returns NULL otherwise
+*/
+opj_tgt_tree_t *tgt_create(int numleafsh, int numleafsv);
+/**
+Destroy a tag-tree, liberating memory
+@param tree Tag-tree to destroy
+*/
+void tgt_destroy(opj_tgt_tree_t *tree);
+/**
+Reset a tag-tree (set all leaves to 0)
+@param tree Tag-tree to reset
+*/
+void tgt_reset(opj_tgt_tree_t *tree);
+/**
+Set the value of a leaf of a tag-tree
+@param tree Tag-tree to modify
+@param leafno Number that identifies the leaf to modify
+@param value New value of the leaf
+*/
+void tgt_setvalue(opj_tgt_tree_t *tree, int leafno, int value);
+/**
+Encode the value of a leaf of the tag-tree up to a given threshold
+@param bio Pointer to a BIO handle
+@param tree Tag-tree to modify
+@param leafno Number that identifies the leaf to encode
+@param threshold Threshold to use when encoding value of the leaf
+*/
+void tgt_encode(opj_bio_t *bio, opj_tgt_tree_t *tree, int leafno, int threshold);
+/**
+Decode the value of a leaf of the tag-tree up to a given threshold
+@param bio Pointer to a BIO handle
+@param tree Tag-tree to decode
+@param leafno Number that identifies the leaf to decode
+@param threshold Threshold to use when decoding value of the leaf
+@return Returns 1 if the node's value < threshold, returns 0 otherwise
+*/
+int tgt_decode(opj_bio_t *bio, opj_tgt_tree_t *tree, int leafno, int threshold);
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __TGT_H */