--- /dev/null
+/*\r
+ * Copyright (c) 2001-2002, David Janssens\r
+ * Copyright (c) 2003, Yannick Verschueren\r
+ * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium\r
+ *\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ ***/ \r
+\r
+#include "bio.h"\r
+#include <stdio.h>\r
+#include <setjmp.h>\r
+\r
+static unsigned char *bio_start; /* pointer to the start of the buffer */\r
+static unsigned char *bio_end; /* pointer to the end of the buffer */\r
+static unsigned char *bio_bp; /* pointer to the present position in the buffer */\r
+static unsigned int bio_buf; /* temporary place where each byte is read or written */\r
+static int bio_ct; /* coder : number of bits free to write // decoder : number of bits read */\r
+\r
+extern jmp_buf j2k_error;\r
+\r
+/*\r
+ * Number of bytes written.\r
+ */\r
+int bio_numbytes()\r
+{\r
+ return bio_bp - bio_start;\r
+}\r
+\r
+/*\r
+ * Init encoder.\r
+ *\r
+ * bp : Output buffer\r
+ * len : Output buffer length \r
+ */\r
+void bio_init_enc(unsigned char *bp, int len)\r
+{\r
+ bio_start = bp;\r
+ bio_end = bp + len;\r
+ bio_bp = bp;\r
+ bio_buf = 0;\r
+ bio_ct = 8;\r
+}\r
+\r
+/*\r
+ * Init decoder.\r
+ * \r
+ * bp : Input buffer\r
+ * len : Input buffer length \r
+ */\r
+void bio_init_dec(unsigned char *bp, int len)\r
+{\r
+ bio_start = bp;\r
+ bio_end = bp + len;\r
+ bio_bp = bp;\r
+ bio_buf = 0;\r
+ bio_ct = 0;\r
+}\r
+\r
+/*\r
+ * Write byte. --> function modified to eliminate longjmp !!! \r
+ *\r
+ */\r
+int bio_byteout()\r
+{\r
+ bio_buf = (bio_buf << 8) & 0xffff;\r
+ bio_ct = bio_buf == 0xff00 ? 7 : 8;\r
+ if (bio_bp >= bio_end)\r
+ return 1;\r
+ *bio_bp++ = bio_buf >> 8;\r
+ return 0;\r
+}\r
+\r
+/*\r
+ * Read byte. --> function modified to eliminate longjmp !!\r
+ *\r
+ */\r
+int bio_bytein()\r
+{\r
+ bio_buf = (bio_buf << 8) & 0xffff;\r
+ bio_ct = bio_buf == 0xff00 ? 7 : 8;\r
+ if (bio_bp >= bio_end)\r
+ return 1;\r
+ bio_buf |= *bio_bp++;\r
+ return 0;\r
+}\r
+\r
+/*\r
+ * Write bit.\r
+ *\r
+ * b : Bit to write (0 or 1)\r
+ */\r
+void bio_putbit(int b)\r
+{\r
+ if (bio_ct == 0) {\r
+ bio_byteout();\r
+ }\r
+ bio_ct--;\r
+ bio_buf |= b << bio_ct;\r
+}\r
+\r
+/*\r
+ * Read bit.\r
+ *\r
+ */\r
+int bio_getbit()\r
+{\r
+ if (bio_ct == 0) {\r
+ bio_bytein();\r
+ }\r
+ bio_ct--;\r
+ return (bio_buf >> bio_ct) & 1;\r
+}\r
+\r
+/*\r
+ * Write bits.\r
+ *\r
+ * v : Value of bits\r
+ * n : Number of bits to write \r
+ */\r
+void bio_write(int v, int n)\r
+{\r
+ int i;\r
+ for (i = n - 1; i >= 0; i--) {\r
+ bio_putbit((v >> i) & 1);\r
+ }\r
+}\r
+\r
+/*\r
+ * Read bits.\r
+ * \r
+ * n : Number of bits to read\r
+ */\r
+int bio_read(int n)\r
+{\r
+ int i, v;\r
+ v = 0;\r
+ for (i = n - 1; i >= 0; i--) {\r
+ v += bio_getbit() << i;\r
+ }\r
+ return v;\r
+}\r
+\r
+/*\r
+ * Flush bits. Modified to eliminate longjmp !!\r
+ *\r
+ */\r
+int bio_flush()\r
+{\r
+ bio_ct = 0;\r
+ if (bio_byteout())\r
+ return 1;\r
+ if (bio_ct == 7) {\r
+ bio_ct = 0;\r
+\r
+ if (bio_byteout())\r
+ return 1;\r
+ }\r
+ return 0;\r
+}\r
+\r
+/*\r
+ * Passes the ending bits (coming from flushing)\r
+ */\r
+int bio_inalign()\r
+{\r
+ bio_ct = 0;\r
+ if ((bio_buf & 0xff) == 0xff) {\r
+ if (bio_bytein())\r
+ return 1;\r
+ bio_ct = 0;\r
+ }\r
+ return 0;\r
+}\r
--- /dev/null
+/*\r
+ * Copyright (c) 2001-2002, David Janssens\r
+ * Copyright (c) 2003, Yannick Verschueren\r
+ * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+#ifndef __BIO_H\r
+#define __BIO_H\r
+\r
+/*\r
+ * Number of bytes written.\r
+ */\r
+int bio_numbytes();\r
+\r
+/*\r
+ * Init encoder.\r
+ *\r
+ * bp : Output buffer\r
+ * len : Output buffer length \r
+ */\r
+void bio_init_enc(unsigned char *bp, int len);\r
+\r
+/*\r
+ * Init decoder.\r
+ *\r
+ * bp : Input buffer\r
+ * len : Input buffer length\r
+ */\r
+void bio_init_dec(unsigned char *bp, int len);\r
+\r
+/*\r
+ * Write bits.\r
+ *\r
+ * v : Value of bits\r
+ * n : Number of bits to write\r
+ */\r
+void bio_write(int v, int n);\r
+\r
+/*\r
+ * Read bits. \r
+ *\r
+ * n : Number of bits to read \r
+ */\r
+int bio_read(int n);\r
+\r
+/*\r
+ * Flush bits. Modified to eliminate longjmp !!\r
+ */\r
+int bio_flush();\r
+\r
+int bio_inalign(); /* modified to eliminated longjmp !! */\r
+\r
+#endif\r
--- /dev/null
+/*\r
+ * Copyright (c) 2001-2002, David Janssens\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+#include "cio.h"\r
+#include <setjmp.h>\r
+#include <memory.h>\r
+\r
+static unsigned char *cio_start; /* pointer to the start of the stream */\r
+static unsigned char *cio_end; /* pointer to the end of the stream */\r
+static unsigned char *cio_bp; /* pointer to the present position */\r
+\r
+extern jmp_buf j2k_error;\r
+\r
+/* \r
+ * Number of bytes written.\r
+ */\r
+int cio_numbytes()\r
+{\r
+ return cio_bp - cio_start;\r
+}\r
+\r
+/*\r
+ * Get position in byte stream.\r
+ */\r
+int cio_tell()\r
+{\r
+ return cio_bp - cio_start;\r
+}\r
+\r
+/*\r
+ * Set position in byte stream.\r
+ *\r
+ * pos : position, in number of bytes, from the beginning of the stream\r
+ */\r
+void cio_seek(int pos)\r
+{\r
+ cio_bp = cio_start + pos;\r
+}\r
+\r
+/*\r
+ * Number of bytes left before the end of the stream.\r
+ */\r
+int cio_numbytesleft()\r
+{\r
+ return cio_end - cio_bp;\r
+}\r
+\r
+/*\r
+ * Get pointer to the current position in the stream.\r
+ */\r
+unsigned char *cio_getbp()\r
+{\r
+ return cio_bp;\r
+}\r
+\r
+/* \r
+ * Initialize byte IO\r
+ *\r
+ * bp : destination/source stream\r
+ * len : length of the stream\r
+ */\r
+void cio_init(unsigned char *bp, int len)\r
+{\r
+ cio_start = bp;\r
+ cio_end = bp + len;\r
+ cio_bp = bp;\r
+}\r
+\r
+/*\r
+ * Write a byte.\r
+ */\r
+void cio_byteout(unsigned char v)\r
+{\r
+ if (cio_bp >= cio_end)\r
+ longjmp(j2k_error, 1);\r
+ *cio_bp++ = v;\r
+\r
+}\r
+\r
+/*\r
+ * Read a byte.\r
+ */\r
+unsigned char cio_bytein()\r
+{\r
+ if (cio_bp >= cio_end)\r
+ longjmp(j2k_error, 1);\r
+ return *cio_bp++;\r
+}\r
+\r
+/*\r
+ * Write some bytes.\r
+ *\r
+ * v : value to write\r
+ * n : number of bytes to write\r
+ */\r
+void cio_write(unsigned int v, int n)\r
+{\r
+ int i;\r
+ for (i = n - 1; i >= 0; i--) {\r
+ cio_byteout((unsigned char) ((v >> (i << 3)) & 0xff));\r
+ }\r
+}\r
+\r
+/*\r
+ * Read some bytes.\r
+ *\r
+ * n : number of bytes to read\r
+ *\r
+ * return : value of the n bytes read\r
+ */\r
+unsigned int cio_read(int n)\r
+{\r
+ int i;\r
+ unsigned int v;\r
+ v = 0;\r
+ for (i = n - 1; i >= 0; i--) {\r
+ v += cio_bytein() << (i << 3);\r
+ }\r
+ return v;\r
+}\r
+\r
+/* \r
+ * Skip some bytes.\r
+ *\r
+ * n : number of bytes to skip\r
+ */\r
+void cio_skip(int n)\r
+{\r
+ cio_bp += n;\r
+}\r
+\r
+/* \r
+ * Read n bytes, copy to buffer\r
+ *\r
+ * n : number of bytes to transfer\r
+ */\r
+void cio_read_to_buf(unsigned char* src_buf, int n)/* Glenn adds */\r
+{\r
+ if (cio_bp + n > cio_end)\r
+ longjmp(j2k_error, 1);\r
+ memcpy(cio_bp, src_buf, n);\r
+ cio_bp += n;\r
+}\r
+\r
+/* \r
+ * Write n bytes, copy from buffer\r
+ *\r
+ * n : number of bytes to transfer\r
+ */\r
+void cio_write_from_buf(unsigned char* dest_buf, int n)/* Glenn adds */\r
+{\r
+ if (cio_bp + n > cio_end)\r
+ longjmp(j2k_error, 1);\r
+ memcpy(dest_buf, cio_bp, n);\r
+ cio_bp += n;\r
+}
\ No newline at end of file
--- /dev/null
+/*\r
+ * Copyright (c) 2001-2002, David Janssens\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+#ifndef __CIO_H\r
+#define __CIO_H\r
+\r
+/* \r
+ * Number of bytes written.\r
+ *\r
+ * returns number of bytes written\r
+ */\r
+int cio_numbytes();\r
+\r
+/*\r
+ * Get position in byte stream.\r
+ *\r
+ * return position in bytes\r
+ */\r
+int cio_tell();\r
+\r
+/*\r
+ * Set position in byte stream.\r
+ *\r
+ * pos : position, in number of bytes, from the beginning of the stream\r
+ */\r
+void cio_seek(int pos);\r
+\r
+/*\r
+ * Number of bytes left before the end of the stream.\r
+ *\r
+ * Returns the number of bytes before the end of the stream \r
+ */\r
+int cio_numbytesleft();\r
+\r
+/*\r
+ * Get pointer to the current position in the stream.\r
+ *\r
+ * return : pointer to the position\r
+ */\r
+unsigned char *cio_getbp();\r
+\r
+/* \r
+ * Initialize byte IO\r
+ *\r
+ * bp : destination/source stream\r
+ * len : length of the stream\r
+ */\r
+void cio_init(unsigned char *bp, int len);\r
+\r
+/*\r
+ * Write some bytes.\r
+ *\r
+ * v : value to write\r
+ * n : number of bytes to write\r
+ */\r
+void cio_write(unsigned int v, int n);\r
+\r
+/*\r
+ * Read some bytes.\r
+ *\r
+ * n : number of bytes to read\r
+ *\r
+ * return : value of the n bytes read\r
+ */\r
+unsigned int cio_read(int n);\r
+\r
+/* \r
+ * Skip some bytes.\r
+ *\r
+ * n : number of bytes to skip\r
+ */\r
+void cio_skip(int n);\r
+\r
+/*\r
+ * Read n bytes, copy to buffer\r
+ */\r
+void cio_read_to_buf(unsigned char* src_buf, int n);/* Glenn Pearson adds */\r
+\r
+/*\r
+ * Write n bytes, copy from buffer\r
+ */\r
+void cio_write_from_buf(unsigned char* dest_buf, int n);/* Glenn Pearson adds */\r
+\r
+#endif\r
--- /dev/null
+/*\r
+ * Copyright (c) 2001-2002, David Janssens\r
+ * Copyright (c) 2002-2004, Yannick Verschueren\r
+ * Copyright (c) 2002-2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium\r
+ * Copyright (c) 2005, Reiner Wahler\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+/*\r
+ * NOTE:\r
+ * This is a modified version of the openjpeg dwt.c file.\r
+ * Average speed improvement compared to the original file (measured on\r
+ * my own machine, a P4 running at 3.0 GHz):\r
+ * 5x3 wavelets about 2 times faster\r
+ * 9x7 wavelets about 3 times faster\r
+ * for both, encoding and decoding.\r
+ *\r
+ * The better performance is caused by doing the 1-dimensional DWT\r
+ * within a temporary buffer where the data can be accessed sequential\r
+ * for both directions, horizontal and vertical. The 2d vertical DWT was\r
+ * the major bottleneck in the former version.\r
+ *\r
+ * I have also removed the "Add Patrick" part because it is not longer\r
+ * needed. \r
+ *\r
+ * 6/6/2005\r
+ * -Ive (aka Reiner Wahler)\r
+ * mail: ive@lilysoft.com\r
+ */\r
+\r
+\r
+#include "dwt.h"\r
+#include "int.h"\r
+#include "fix.h"\r
+#include "tcd.h"\r
+#include <stdlib.h>\r
+\r
+#define S(i) a[(i)*2]\r
+#define D(i) a[(1+(i)*2)]\r
+#define S_(i) ((i)<0?S(0):((i)>=sn?S(sn-1):S(i)))\r
+#define D_(i) ((i)<0?D(0):((i)>=dn?D(dn-1):D(i)))\r
+/* new */\r
+#define SS_(i) ((i)<0?S(0):((i)>=dn?S(dn-1):S(i)))\r
+#define DD_(i) ((i)<0?D(0):((i)>=sn?D(sn-1):D(i)))\r
+\r
+/* <summary> */\r
+/* This table contains the norms of the 5-3 wavelets for different bands. */\r
+/* </summary> */\r
+double dwt_norms[4][10] = {\r
+ {1.000, 1.500, 2.750, 5.375, 10.68, 21.34, 42.67, 85.33, 170.7, 341.3},\r
+ {1.038, 1.592, 2.919, 5.703, 11.33, 22.64, 45.25, 90.48, 180.9},\r
+ {1.038, 1.592, 2.919, 5.703, 11.33, 22.64, 45.25, 90.48, 180.9},\r
+ {.7186, .9218, 1.586, 3.043, 6.019, 12.01, 24.00, 47.97, 95.93}\r
+};\r
+\r
+/* <summary> */\r
+/* This table contains the norms of the 9-7 wavelets for different bands. */\r
+/* </summary> */\r
+double dwt_norms_real[4][10] = {\r
+ {1.000, 1.965, 4.177, 8.403, 16.90, 33.84, 67.69, 135.3, 270.6, 540.9},\r
+ {2.022, 3.989, 8.355, 17.04, 34.27, 68.63, 137.3, 274.6, 549.0},\r
+ {2.022, 3.989, 8.355, 17.04, 34.27, 68.63, 137.3, 274.6, 549.0},\r
+ {2.080, 3.865, 8.307, 17.18, 34.71, 69.59, 139.3, 278.6, 557.2}\r
+};\r
+\r
+\r
+/* <summary> */\r
+/* Forward lazy transform (horizontal). */\r
+/* </summary> */ \r
+void dwt_deinterleave_h(int *a, int *b, int dn, int sn, int cas) {\r
+ int i;\r
+ for (i=0; i<sn; i++) b[i]=a[2*i+cas];\r
+ for (i=0; i<dn; i++) b[sn+i]=a[(2*i+1-cas)];\r
+}\r
+\r
+/* <summary> */ \r
+/* Forward lazy transform (vertical). */\r
+/* </summary> */ \r
+void dwt_deinterleave_v(int *a, int *b, int dn, int sn, int x, int cas) {\r
+ int i;\r
+ for (i=0; i<sn; i++) b[i*x]=a[2*i+cas];\r
+ for (i=0; i<dn; i++) b[(sn+i)*x]=a[(2*i+1-cas)];\r
+}\r
+\r
+/* <summary> */\r
+/* Inverse lazy transform (horizontal). */\r
+/* </summary> */\r
+void dwt_interleave_h(int *a, int *b, int dn, int sn, int cas) {\r
+ int i;\r
+/* for (i=0; i<sn; i++) b[2*i+cas]=a[i];*/\r
+/* for (i=0; i<dn; i++) b[2*i+1-cas]=a[(sn+i)];*/\r
+ int* ai;\r
+ int* bi;\r
+ ai=a;\r
+ bi=b+cas;\r
+ for (i=0; i<sn; i++) {\r
+ *bi = *ai; bi+=2; ai++;\r
+ }\r
+ ai=a+sn;\r
+ bi=b+1-cas;\r
+ for (i=0; i<dn; i++) {\r
+ *bi = *ai; bi+=2; ai++;\r
+ }\r
+}\r
+\r
+/* <summary> */ \r
+/* Inverse lazy transform (vertical). */\r
+/* </summary> */ \r
+void dwt_interleave_v(int *a, int *b, int dn, int sn, int x, int cas) {\r
+ int i;\r
+/* for (i=0; i<sn; i++) b[2*i+cas]=a[i*x];*/\r
+/* for (i=0; i<dn; i++) b[2*i+1-cas]=a[(sn+i)*x];*/\r
+ int* ai;\r
+ int* bi;\r
+ ai=a;\r
+ bi=b+cas;\r
+ for (i=0; i<sn; i++) {\r
+ *bi = *ai; bi+=2; ai+=x;\r
+ }\r
+ ai=a+(sn*x);\r
+ bi=b+1-cas;\r
+ for (i=0; i<dn; i++) {\r
+ *bi = *ai; bi+=2; ai+=x;\r
+ }\r
+}\r
+\r
+\r
+/* <summary> */\r
+/* Forward 5-3 wavelet tranform in 1-D. */\r
+/* </summary> */\r
+void dwt_encode_1(int *a, int dn, int sn, int cas)\r
+{\r
+ int i;\r
+\r
+ if (!cas) {\r
+ if ((dn > 0) || (sn > 1)) { /* NEW : CASE ONE ELEMENT */\r
+ for (i = 0; i < dn; i++) D(i) -= (S_(i) + S_(i + 1)) >> 1;\r
+ for (i = 0; i < sn; i++) S(i) += (D_(i - 1) + D_(i) + 2) >> 2;\r
+ }\r
+ } else {\r
+ if (!sn && dn == 1) /* NEW : CASE ONE ELEMENT */\r
+ S(0) *= 2;\r
+ else {\r
+ for (i = 0; i < dn; i++) S(i) -= (DD_(i) + DD_(i - 1)) >> 1;\r
+ for (i = 0; i < sn; i++) D(i) += (SS_(i) + SS_(i + 1) + 2) >> 2;\r
+ }\r
+\r
+ }\r
+}\r
+\r
+/* <summary> */\r
+/* Inverse 5-3 wavelet tranform in 1-D. */\r
+/* </summary> */ \r
+void dwt_decode_1(int *a, int dn, int sn, int cas) \r
+{\r
+ int i;\r
+\r
+ if (!cas) {\r
+ if ((dn > 0) || (sn > 1)) { /* NEW : CASE ONE ELEMENT */\r
+ for (i = 0; i < sn; i++) S(i) -= (D_(i - 1) + D_(i) + 2) >> 2;\r
+ for (i = 0; i < dn; i++) D(i) += (S_(i) + S_(i + 1)) >> 1;\r
+ }\r
+ } else {\r
+ if (!sn && dn == 1) /* NEW : CASE ONE ELEMENT */\r
+ S(0) /= 2;\r
+ else {\r
+ for (i = 0; i < sn; i++) D(i) -= (SS_(i) + SS_(i + 1) + 2) >> 2;\r
+ for (i = 0; i < dn; i++) S(i) += (DD_(i) + DD_(i - 1)) >> 1;\r
+ }\r
+ }\r
+}\r
+\r
+\r
+/* <summary> */\r
+/* Forward 5-3 wavelet tranform in 2-D. */\r
+/* </summary> */\r
+void dwt_encode(tcd_tilecomp_t * tilec)\r
+{\r
+ int i, j, k;\r
+ int* a;\r
+ int* aj;\r
+ int* bj;\r
+ int w, l;\r
+\r
+ w = tilec->x1-tilec->x0;\r
+ l = tilec->numresolutions-1;\r
+ a = tilec->data;\r
+\r
+ for (i = 0; i < l; i++) {\r
+ int rw; /* width of the resolution level computed */\r
+ int rh; /* heigth of the resolution level computed */\r
+ int rw1; /* width of the resolution level once lower than computed one */\r
+ int rh1; /* height of the resolution level once lower than computed one */\r
+ int cas_col; /* 0 = non inversion on horizontal filtering 1 = inversion between low-pass and high-pass filtering */\r
+ int cas_row; /* 0 = non inversion on vertical filtering 1 = inversion between low-pass and high-pass filtering */\r
+ int dn, sn;\r
+\r
+ rw = tilec->resolutions[l - i].x1 - tilec->resolutions[l - i].x0;\r
+ rh = tilec->resolutions[l - i].y1 - tilec->resolutions[l - i].y0;\r
+ rw1= tilec->resolutions[l - i - 1].x1 - tilec->resolutions[l - i - 1].x0;\r
+ rh1= tilec->resolutions[l - i - 1].y1 - tilec->resolutions[l - i - 1].y0;\r
+\r
+ cas_row = tilec->resolutions[l - i].x0 % 2;\r
+ cas_col = tilec->resolutions[l - i].y0 % 2;\r
+\r
+\r
+ sn = rh1;\r
+ dn = rh - rh1;\r
+ bj=(int*)malloc(rh*sizeof(int));\r
+ for (j=0; j<rw; j++) {\r
+ aj=a+j;\r
+ for (k=0; k<rh; k++) bj[k]=aj[k*w];\r
+ dwt_encode_1(bj, dn, sn, cas_col);\r
+ dwt_deinterleave_v(bj, aj, dn, sn, w, cas_col);\r
+ }\r
+ free(bj);\r
+\r
+ sn = rw1;\r
+ dn = rw - rw1;\r
+ bj=(int*)malloc(rw*sizeof(int));\r
+ for (j=0; j<rh; j++) {\r
+ aj=a+j*w;\r
+ for (k=0; k<rw; k++) bj[k]=aj[k];\r
+ dwt_encode_1(bj, dn, sn, cas_row);\r
+ dwt_deinterleave_h(bj, aj, dn, sn, cas_row);\r
+ }\r
+ free(bj);\r
+ }\r
+}\r
+\r
+\r
+/* <summary> */\r
+/* Inverse 5-3 wavelet tranform in 2-D. */\r
+/* </summary> */\r
+void dwt_decode(tcd_tilecomp_t * tilec, int stop)\r
+{\r
+ int i, j, k;\r
+ int* a;\r
+ int* aj;\r
+ int* bj;\r
+ int w, l;\r
+\r
+ w = tilec->x1-tilec->x0;\r
+ l = tilec->numresolutions-1;\r
+ a = tilec->data;\r
+\r
+ for (i = l - 1; i >= stop; i--) {\r
+ int rw; /* width of the resolution level computed */\r
+ int rh; /* heigth of the resolution level computed */\r
+ int rw1; /* width of the resolution level once lower than computed one */\r
+ int rh1; /* height of the resolution level once lower than computed one */\r
+ int cas_col; /* 0 = non inversion on horizontal filtering 1 = inversion between low-pass and high-pass filtering */\r
+ int cas_row; /* 0 = non inversion on vertical filtering 1 = inversion between low-pass and high-pass filtering */\r
+ int dn, sn;\r
+\r
+ rw = tilec->resolutions[l - i].x1 - tilec->resolutions[l - i].x0;\r
+ rh = tilec->resolutions[l - i].y1 - tilec->resolutions[l - i].y0;\r
+ rw1= tilec->resolutions[l - i - 1].x1 - tilec->resolutions[l - i - 1].x0;\r
+ rh1= tilec->resolutions[l - i - 1].y1 - tilec->resolutions[l - i - 1].y0;\r
+\r
+ cas_row = tilec->resolutions[l - i].x0 % 2;\r
+ cas_col = tilec->resolutions[l - i].y0 % 2;\r
+\r
+ sn = rw1;\r
+ dn = rw - rw1;\r
+ bj=(int*)malloc(rw*sizeof(int));\r
+ for (j = 0; j < rh; j++) {\r
+ aj = a+j*w;\r
+ dwt_interleave_h(aj, bj, dn, sn, cas_row);\r
+ dwt_decode_1(bj, dn, sn, cas_row);\r
+ for (k = 0; k < rw; k++) aj[k] = bj[k];\r
+ }\r
+ free(bj);\r
+\r
+ sn = rh1;\r
+ dn = rh - rh1;\r
+ bj=(int*)malloc(rh*sizeof(int));\r
+ for (j = 0; j < rw; j++) {\r
+ aj = a+j;\r
+ dwt_interleave_v(aj, bj, dn, sn, w, cas_col);\r
+ dwt_decode_1(bj, dn, sn, cas_col);\r
+ for (k = 0; k < rh; k++) aj[k * w] = bj[k];\r
+ }\r
+ free(bj);\r
+\r
+ }\r
+}\r
+\r
+\r
+/* <summary> */\r
+/* Get gain of 5-3 wavelet transform. */\r
+/* </summary> */\r
+int dwt_getgain(int orient)\r
+{\r
+ if (orient == 0)\r
+ return 0;\r
+ if (orient == 1 || orient == 2)\r
+ return 1;\r
+ return 2;\r
+}\r
+\r
+/* <summary> */\r
+/* Get norm of 5-3 wavelet. */\r
+/* </summary> */\r
+double dwt_getnorm(int level, int orient)\r
+{\r
+ return dwt_norms[orient][level];\r
+}\r
+\r
+/* <summary> */\r
+/* Forward 9-7 wavelet transform in 1-D. */\r
+/* </summary> */\r
+void dwt_encode_1_real(int *a, int dn, int sn, int cas)\r
+{\r
+ int i;\r
+ if (!cas) {\r
+ if ((dn > 0) || (sn > 1)) { /* NEW : CASE ONE ELEMENT */\r
+ for (i = 0; i < dn; i++)\r
+ D(i) -= fix_mul(S_(i) + S_(i + 1), 12993);\r
+ for (i = 0; i < sn; i++)\r
+ S(i) -= fix_mul(D_(i - 1) + D_(i), 434);\r
+ for (i = 0; i < dn; i++)\r
+ D(i) += fix_mul(S_(i) + S_(i + 1), 7233);\r
+ for (i = 0; i < sn; i++)\r
+ S(i) += fix_mul(D_(i - 1) + D_(i), 3633);\r
+ for (i = 0; i < dn; i++)\r
+ D(i) = fix_mul(D(i), 5038); /*5038 */\r
+ for (i = 0; i < sn; i++)\r
+ S(i) = fix_mul(S(i), 6659); /*6660 */\r
+ }\r
+ } else {\r
+ if ((sn > 0) || (dn > 1)) { /* NEW : CASE ONE ELEMENT */\r
+ for (i = 0; i < dn; i++)\r
+ S(i) -= fix_mul(DD_(i) + DD_(i - 1), 12993);\r
+ for (i = 0; i < sn; i++)\r
+ D(i) -= fix_mul(SS_(i) + SS_(i + 1), 434);\r
+ for (i = 0; i < dn; i++)\r
+ S(i) += fix_mul(DD_(i) + DD_(i - 1), 7233);\r
+ for (i = 0; i < sn; i++)\r
+ D(i) += fix_mul(SS_(i) + SS_(i + 1), 3633);\r
+ for (i = 0; i < dn; i++)\r
+ S(i) = fix_mul(S(i), 5038); /*5038 */\r
+ for (i = 0; i < sn; i++)\r
+ D(i) = fix_mul(D(i), 6659); /*6660 */\r
+ }\r
+ }\r
+}\r
+\r
+/* <summary> */\r
+/* Inverse 9-7 wavelet transform in 1-D. */\r
+/* </summary> */\r
+void dwt_decode_1_real(int *a, int dn, int sn, int cas)\r
+{\r
+ int i;\r
+ if (!cas) {\r
+ if ((dn > 0) || (sn > 1)) { /* NEW : CASE ONE ELEMENT */\r
+ for (i = 0; i < sn; i++)\r
+ S(i) = fix_mul(S(i), 10078); /* 10076 */\r
+ for (i = 0; i < dn; i++)\r
+ D(i) = fix_mul(D(i), 13318); /* 13320 */\r
+ for (i = 0; i < sn; i++)\r
+ S(i) -= fix_mul(D_(i - 1) + D_(i), 3633);\r
+ for (i = 0; i < dn; i++)\r
+ D(i) -= fix_mul(S_(i) + S_(i + 1), 7233);\r
+ for (i = 0; i < sn; i++)\r
+ S(i) += fix_mul(D_(i - 1) + D_(i), 434);\r
+ for (i = 0; i < dn; i++)\r
+ D(i) += fix_mul(S_(i) + S_(i + 1), 12994); /* 12993 */\r
+ }\r
+ } else {\r
+ if ((sn > 0) || (dn > 1)) { /* NEW : CASE ONE ELEMENT */\r
+ for (i = 0; i < sn; i++)\r
+ D(i) = fix_mul(D(i), 10078); /* 10076 */\r
+ for (i = 0; i < dn; i++)\r
+ S(i) = fix_mul(S(i), 13318); /* 13320 */\r
+ for (i = 0; i < sn; i++)\r
+ D(i) -= fix_mul(SS_(i) + SS_(i + 1), 3633);\r
+ for (i = 0; i < dn; i++)\r
+ S(i) -= fix_mul(DD_(i) + DD_(i - 1), 7233);\r
+ for (i = 0; i < sn; i++)\r
+ D(i) += fix_mul(SS_(i) + SS_(i + 1), 434);\r
+ for (i = 0; i < dn; i++)\r
+ S(i) += fix_mul(DD_(i) + DD_(i - 1), 12994); /* 12993 */\r
+ }\r
+ }\r
+}\r
+\r
+/* <summary> */\r
+/* Forward 9-7 wavelet transform in 2-D. */\r
+/* </summary> */\r
+\r
+void dwt_encode_real(tcd_tilecomp_t * tilec)\r
+{\r
+ int i, j, k;\r
+ int* a;\r
+ int* aj;\r
+ int* bj;\r
+ int w, l;\r
+\r
+ w = tilec->x1-tilec->x0;\r
+ l = tilec->numresolutions-1;\r
+ a = tilec->data;\r
+\r
+ for (i = 0; i < l; i++) {\r
+ int rw; /* width of the resolution level computed */\r
+ int rh; /* heigth of the resolution level computed */\r
+ int rw1; /* width of the resolution level once lower than computed one */\r
+ int rh1; /* height of the resolution level once lower than computed one */\r
+ int cas_col; /* 0 = non inversion on horizontal filtering 1 = inversion between low-pass and high-pass filtering */\r
+ int cas_row; /* 0 = non inversion on vertical filtering 1 = inversion between low-pass and high-pass filtering */\r
+ int dn, sn;\r
+\r
+ rw = tilec->resolutions[l - i].x1 - tilec->resolutions[l - i].x0;\r
+ rh = tilec->resolutions[l - i].y1 - tilec->resolutions[l - i].y0;\r
+ rw1= tilec->resolutions[l - i - 1].x1 - tilec->resolutions[l - i - 1].x0;\r
+ rh1= tilec->resolutions[l - i - 1].y1 - tilec->resolutions[l - i - 1].y0;\r
+\r
+ cas_row = tilec->resolutions[l - i].x0 % 2;\r
+ cas_col = tilec->resolutions[l - i].y0 % 2;\r
+\r
+ sn = rh1;\r
+ dn = rh - rh1;\r
+ bj=(int*)malloc(rh*sizeof(int));\r
+ for (j = 0; j < rw; j++) {\r
+ aj = a + j;\r
+ for (k = 0; k < rh; k++) bj[k] = aj[k*w];\r
+ dwt_encode_1_real(bj, dn, sn, cas_col);\r
+ dwt_deinterleave_v(bj, aj, dn, sn, w, cas_col);\r
+ }\r
+ free(bj);\r
+\r
+ sn = rw1;\r
+ dn = rw - rw1;\r
+ bj=(int*)malloc(rw*sizeof(int));\r
+ for (j = 0; j < rh; j++) {\r
+ aj = a + j * w;\r
+ for (k = 0; k < rw; k++) bj[k] = aj[k];\r
+ dwt_encode_1_real(bj, dn, sn, cas_row);\r
+ dwt_deinterleave_h(bj, aj, dn, sn, cas_row);\r
+ }\r
+ free(bj);\r
+ }\r
+}\r
+\r
+\r
+/* <summary> */\r
+/* Inverse 9-7 wavelet transform in 2-D. */\r
+/* </summary> */\r
+void dwt_decode_real(tcd_tilecomp_t * tilec, int stop)\r
+{\r
+\r
+ int i, j, k;\r
+ int* a;\r
+ int* aj;\r
+ int* bj;\r
+ int w, l;\r
+\r
+ w = tilec->x1-tilec->x0;\r
+ l = tilec->numresolutions-1;\r
+ a = tilec->data;\r
+\r
+ for (i = l-1; i >= stop; i--) {\r
+ int rw; /* width of the resolution level computed */\r
+ int rh; /* heigth of the resolution level computed */\r
+ int rw1; /* width of the resolution level once lower than computed one */\r
+ int rh1; /* height of the resolution level once lower than computed one */\r
+ int cas_col; /* 0 = non inversion on horizontal filtering 1 = inversion between low-pass and high-pass filtering */\r
+ int cas_row; /* 0 = non inversion on vertical filtering 1 = inversion between low-pass and high-pass filtering */\r
+ int dn, sn;\r
+\r
+ rw = tilec->resolutions[l - i].x1 - tilec->resolutions[l - i].x0;\r
+ rh = tilec->resolutions[l - i].y1 - tilec->resolutions[l - i].y0;\r
+ rw1= tilec->resolutions[l - i - 1].x1 - tilec->resolutions[l - i - 1].x0;\r
+ rh1= tilec->resolutions[l - i - 1].y1 - tilec->resolutions[l - i - 1].y0;\r
+\r
+ cas_col = tilec->resolutions[l - i].x0 % 2; /* 0 = non inversion on horizontal filtering 1 = inversion between low-pass and high-pass filtering */\r
+ cas_row = tilec->resolutions[l - i].y0 % 2; /* 0 = non inversion on vertical filtering 1 = inversion between low-pass and high-pass filtering */\r
+\r
+ sn = rw1;\r
+ dn = rw-rw1;\r
+ bj = (int*)malloc(rw * sizeof(int));\r
+ for (j = 0; j < rh; j++) {\r
+ aj = a+j*w;\r
+ dwt_interleave_h(aj, bj, dn, sn, cas_col);\r
+ dwt_decode_1_real(bj, dn, sn, cas_col);\r
+ for (k = 0; k < rw; k++) aj[k] = bj[k];\r
+ }\r
+ free(bj);\r
+\r
+ sn = rh1;\r
+ dn = rh-rh1;\r
+ bj = (int*)malloc(rh * sizeof(int));\r
+ for (j=0; j<rw; j++) {\r
+ aj = a+j;\r
+ dwt_interleave_v(aj, bj, dn, sn, w, cas_row);\r
+ dwt_decode_1_real(bj, dn, sn, cas_row);\r
+ for (k = 0; k < rh; k++) aj[k * w] = bj[k];\r
+ }\r
+ free(bj);\r
+ }\r
+}\r
+\r
+\r
+/* <summary> */\r
+/* Get gain of 9-7 wavelet transform. */\r
+/* </summary> */\r
+int dwt_getgain_real(int orient)\r
+{\r
+ (void)orient;\r
+ return 0;\r
+}\r
+\r
+/* <summary> */\r
+/* Get norm of 9-7 wavelet. */\r
+/* </summary> */\r
+double dwt_getnorm_real(int level, int orient)\r
+{\r
+ return dwt_norms_real[orient][level];\r
+}\r
--- /dev/null
+/*\r
+ * Copyright (c) 2001-2002, David Janssens\r
+ * Copyright (c) 2002-2003, Yannick Verschueren\r
+ * Copyright (c) 2002-2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+#include "tcd.h"\r
+\r
+#ifndef __DWT_H\r
+#define __DWT_H\r
+\r
+/*\r
+ * Apply a reversible DWT transform to a component of an image \r
+ * tilec : tile component information (present tile)\r
+ */\r
+/* void dwt_encode(int* a, int w, int h, int l); */\r
+void dwt_encode(tcd_tilecomp_t * tilec);\r
+/*\r
+ * Apply a reversible inverse DWT transform to a component of an image \r
+ * tilec : tile component information (present tile)\r
+ */\r
+void dwt_decode(tcd_tilecomp_t * tilec, int stop);\r
+\r
+/*\r
+ * Get the gain of a subband for the reversible DWT\r
+ * orient: number that identifies the subband (0->LL, 1->HL, 2->LH, 3->HH)\r
+ */\r
+int dwt_getgain(int orient);\r
+\r
+/*\r
+ * Get the norm of a wavelet function of a subband at a specified level for the reversible DWT\r
+ * level: level of the wavelet function\r
+ * orient: band of the wavelet function\r
+ */\r
+double dwt_getnorm(int level, int orient);\r
+\r
+/*\r
+ * Apply an irreversible DWT transform to a component of an image \r
+ */\r
+void dwt_encode_real(tcd_tilecomp_t * tilec);\r
+\r
+/*\r
+ * Apply an irreversible inverse DWT transform to a component of an image \r
+ */\r
+void dwt_decode_real(tcd_tilecomp_t * tilec, int stop);\r
+/*\r
+ * Get the gain of a subband for the irreversible DWT\r
+ * orient: number that identifies the subband (0->LL, 1->HL, 2->LH, 3->HH)\r
+ */\r
+int dwt_getgain_real(int orient);\r
+\r
+/*\r
+ * Get the norm of a wavelet function of a subband at a specified level for the irreversible DWT\r
+ * level: level of the wavelet function\r
+ * orient: band of the wavelet function\r
+ */\r
+double dwt_getnorm_real(int level, int orient);\r
+\r
+#endif\r
--- /dev/null
+/*\r
+ * Copyright (c) 2001-2002, David Janssens\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+#include "fix.h"\r
+#include <math.h> /*Add Antonin : multbug1*/\r
+\r
+#ifdef WIN32\r
+#define int64 __int64\r
+#else\r
+#define int64 long long\r
+#endif\r
+\r
+/*\r
+ * Multiply two fixed-precision rational numbers.\r
+ */\r
+\r
+/*int fix_mul(int a, int b)\r
+{\r
+ return (int) ((int64) a * (int64) b >> 13);\r
+}*/\r
+\r
+\r
+/*Mod Antonin : multbug1*/\r
+/*\r
+int fix_mul(int a, int b)\r
+{\r
+ double tmp= (double) ((int64) a * (int64) b);\r
+ int64 v = (int64) ((fabs(tmp/8192.0)>=floor(fabs(tmp/8192.0))+0.5)?fabs(tmp/8192.0)+1.0:fabs(tmp/8192.0));\r
+ v = (tmp<0)?-v:v;\r
+ return (int) v;\r
+}\r
+*/\r
+/*doM*/\r
+\r
+int fix_mul(int a, int b) /* Luke Lee optimized : 11/16/2004*/\r
+{\r
+ int64 temp = (int64) a * (int64) b >> 12;\r
+ return (int) ((temp >> 1) + (temp & 1)) ;\r
+}\r
+\r
--- /dev/null
+/*\r
+ * Copyright (c) 2001-2002, David Janssens\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+\r
+#ifndef __FIX_H\r
+#define __FIX_H\r
+\r
+int fix_mul(int a, int b);\r
+\r
+#endif\r
--- /dev/null
+/*\r
+ * Copyright (c) 2001-2002, David Janssens\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+#include "int.h"\r
+\r
+/*\r
+ * Get the minimum of two integers.\r
+ *\r
+ * returns a if a < b else b\r
+ */\r
+int int_min(int a, int b)\r
+{\r
+ return a < b ? a : b;\r
+}\r
+\r
+/*\r
+ * Get the maximum of two integers.\r
+ *\r
+ * returns a if a > b else b\r
+ */\r
+int int_max(int a, int b)\r
+{\r
+ return a > b ? a : b;\r
+}\r
+\r
+/*\r
+ * Clamp an integer inside an interval.\r
+ *\r
+ * return a if (min < a < max)\r
+ * return max if (a > max)\r
+ * return min if (a < min) \r
+ */\r
+int int_clamp(int a, int min, int max)\r
+{\r
+ if (a < min)\r
+ return min;\r
+ if (a > max)\r
+ return max;\r
+ return a;\r
+}\r
+\r
+/*\r
+ * Get absolute value of integer.\r
+ */\r
+int int_abs(int a)\r
+{\r
+ return a < 0 ? -a : a;\r
+}\r
+\r
+/*\r
+ * Divide an integer and round upwards.\r
+ *\r
+ * a divided by b\r
+ */\r
+int int_ceildiv(int a, int b)\r
+{\r
+ return (a + b - 1) / b;\r
+}\r
+\r
+/*\r
+ * Divide an integer by a power of 2 and round upwards.\r
+ *\r
+ * a divided by 2^b\r
+ */\r
+int int_ceildivpow2(int a, int b)\r
+{\r
+ return (a + (1 << b) - 1) >> b;\r
+}\r
+\r
+/*\r
+ * Divide an integer by a power of 2 and round downwards.\r
+ *\r
+ * a divided by 2^b\r
+ */\r
+int int_floordivpow2(int a, int b)\r
+{\r
+ return a >> b;\r
+}\r
+\r
+/*\r
+ * Get logarithm of an integer and round downwards.\r
+ *\r
+ * log2(a)\r
+ */\r
+int int_floorlog2(int a)\r
+{\r
+ int l;\r
+ for (l = 0; a > 1; l++) {\r
+ a >>= 1;\r
+ }\r
+ return l;\r
+}\r
--- /dev/null
+/*\r
+ * Copyright (c) 2001-2002, David Janssens\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+#include "j2k.h"\r
+\r
+#ifndef __INT_H\r
+#define __INT_H\r
+\r
+/*\r
+ * Get the minimum of two integers.\r
+ *\r
+ * returns a if a < b else b\r
+ */\r
+int int_min(int a, int b);\r
+\r
+/*\r
+ * Get the maximum of two integers.\r
+ *\r
+ * returns a if a > b else b\r
+ */\r
+int int_max(int a, int b);\r
+\r
+/*\r
+ * Clamp an integer inside an interval.\r
+ *\r
+ * return a if (min < a < max)\r
+ * return max if (a > max)\r
+ * return min if (a < min) \r
+ */\r
+int int_clamp(int a, int min, int max);\r
+\r
+/*\r
+ * Get absolute value of integer.\r
+ */\r
+int int_abs(int a);\r
+\r
+/*\r
+ * Divide an integer and round upwards.\r
+ *\r
+ * a divided by b\r
+ */\r
+int int_ceildiv(int a, int b);\r
+\r
+/*\r
+ * Divide an integer by a power of 2 and round upwards.\r
+ *\r
+ * a divided by 2^b\r
+ */\r
+LIBJ2K_API int int_ceildivpow2(int a, int b);\r
+\r
+/*\r
+ * Divide an integer by a power of 2 and round downwards.\r
+ *\r
+ * a divided by 2^b\r
+ */\r
+LIBJ2K_API int int_floordivpow2(int a, int b);\r
+\r
+/*\r
+ * Get logarithm of an integer and round downwards.\r
+ *\r
+ * log2(a)\r
+ */\r
+int int_floorlog2(int a);\r
+\r
+#endif\r
--- /dev/null
+/*\r
+* Copyright (c) 2001-2002, David Janssens\r
+* Copyright (c) 2002-2004, Yannick Verschueren\r
+* Copyright (c) 2002-2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium\r
+* All rights reserved.\r
+*\r
+* Redistribution and use in source and binary forms, with or without\r
+* modification, are permitted provided that the following conditions\r
+* are met:\r
+* 1. Redistributions of source code must retain the above copyright\r
+* notice, this list of conditions and the following disclaimer.\r
+* 2. Redistributions in binary form must reproduce the above copyright\r
+* notice, this list of conditions and the following disclaimer in the\r
+* documentation and/or other materials provided with the distribution.\r
+*\r
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+* POSSIBILITY OF SUCH DAMAGE.\r
+*/\r
+\r
+#include <stdio.h>\r
+#include <stdlib.h>\r
+#include <string.h>\r
+#include <setjmp.h>\r
+#include <math.h>\r
+\r
+#include "j2k.h"\r
+#include "cio.h"\r
+#include "tcd.h"\r
+#include "dwt.h"\r
+#include "int.h"\r
+#include "jpt.h"\r
+\r
+#define J2K_MS_SOC 0xff4f\r
+#define J2K_MS_SOT 0xff90\r
+#define J2K_MS_SOD 0xff93\r
+#define J2K_MS_EOC 0xffd9\r
+#define J2K_MS_SIZ 0xff51\r
+#define J2K_MS_COD 0xff52\r
+#define J2K_MS_COC 0xff53\r
+#define J2K_MS_RGN 0xff5e\r
+#define J2K_MS_QCD 0xff5c\r
+#define J2K_MS_QCC 0xff5d\r
+#define J2K_MS_POC 0xff5f\r
+#define J2K_MS_TLM 0xff55\r
+#define J2K_MS_PLM 0xff57\r
+#define J2K_MS_PLT 0xff58\r
+#define J2K_MS_PPM 0xff60\r
+#define J2K_MS_PPT 0xff61\r
+#define J2K_MS_SOP 0xff91\r
+#define J2K_MS_EPH 0xff92\r
+#define J2K_MS_CRG 0xff63\r
+#define J2K_MS_COM 0xff64\r
+\r
+#define J2K_STATE_MHSOC 0x0001\r
+#define J2K_STATE_MHSIZ 0x0002\r
+#define J2K_STATE_MH 0x0004\r
+#define J2K_STATE_TPHSOT 0x0008\r
+#define J2K_STATE_TPH 0x0010\r
+#define J2K_STATE_MT 0x0020\r
+#define J2K_STATE_NEOC 0x0040\r
+\r
+\r
+jmp_buf j2k_error;\r
+\r
+static int j2k_state;\r
+static int j2k_curtileno;\r
+j2k_tcp_t j2k_default_tcp;\r
+static unsigned char *j2k_eot;\r
+static int j2k_sot_start;\r
+static int pos_correction;\r
+\r
+static j2k_image_t *j2k_img;\r
+static j2k_cp_t *j2k_cp;\r
+\r
+static unsigned char **j2k_tile_data;\r
+static int *j2k_tile_len;\r
+\r
+static info_image info_IM;\r
+\r
+/* Add Patrick */\r
+void j2k_clean()\r
+{\r
+ int tileno = 0;\r
+#ifndef NO_PACKETS_DECODING\r
+ tcd_free_encode(j2k_img, j2k_cp, j2k_curtileno);\r
+#endif\r
+ \r
+ if (info_IM.index_on) {\r
+ for (tileno = 0; tileno < j2k_cp->tw * j2k_cp->th; tileno++) {\r
+ free(info_IM.tile[tileno].packet);\r
+ }\r
+ free(info_IM.tile);\r
+ }\r
+}\r
+\r
+/* \Add Patrick */\r
+\r
+void j2k_dump_image(j2k_image_t * img)\r
+{\r
+ int compno;\r
+ fprintf(stdout, "image {\n");\r
+ fprintf(stdout, " x0=%d, y0=%d, x1=%d, y1=%d\n", img->x0, img->y0,\r
+ img->x1, img->y1);\r
+ fprintf(stdout, " numcomps=%d\n", img->numcomps);\r
+ for (compno = 0; compno < img->numcomps; compno++) {\r
+ j2k_comp_t *comp = &img->comps[compno];\r
+ fprintf(stdout, " comp %d {\n", compno);\r
+ fprintf(stdout, " dx=%d, dy=%d\n", comp->dx, comp->dy);\r
+ fprintf(stdout, " prec=%d\n", comp->prec);\r
+ fprintf(stdout, " sgnd=%d\n", comp->sgnd);\r
+ fprintf(stdout, " }\n");\r
+ }\r
+ fprintf(stdout, "}\n");\r
+}\r
+\r
+void j2k_dump_cp(j2k_image_t * img, j2k_cp_t * cp)\r
+{\r
+ int tileno, compno, layno, bandno, resno, numbands;\r
+ fprintf(stdout, "coding parameters {\n");\r
+ fprintf(stdout, " tx0=%d, ty0=%d\n", cp->tx0, cp->ty0);\r
+ fprintf(stdout, " tdx=%d, tdy=%d\n", cp->tdx, cp->tdy);\r
+ fprintf(stdout, " tw=%d, th=%d\n", cp->tw, cp->th);\r
+ for (tileno = 0; tileno < cp->tw * cp->th; tileno++) {\r
+ j2k_tcp_t *tcp = &cp->tcps[tileno];\r
+ fprintf(stdout, " tile %d {\n", tileno);\r
+ fprintf(stdout, " csty=%x\n", tcp->csty);\r
+ fprintf(stdout, " prg=%d\n", tcp->prg);\r
+ fprintf(stdout, " numlayers=%d\n", tcp->numlayers);\r
+ fprintf(stdout, " mct=%d\n", tcp->mct);\r
+ fprintf(stdout, " rates=");\r
+ for (layno = 0; layno < tcp->numlayers; layno++) {\r
+ fprintf(stdout, "%d ", tcp->rates[layno]);\r
+ }\r
+ fprintf(stdout, "\n");\r
+ for (compno = 0; compno < img->numcomps; compno++) {\r
+ j2k_tccp_t *tccp = &tcp->tccps[compno];\r
+ fprintf(stdout, " comp %d {\n", compno);\r
+ fprintf(stdout, " csty=%x\n", tccp->csty);\r
+ fprintf(stdout, " numresolutions=%d\n", tccp->numresolutions);\r
+ fprintf(stdout, " cblkw=%d\n", tccp->cblkw);\r
+ fprintf(stdout, " cblkh=%d\n", tccp->cblkh);\r
+ fprintf(stdout, " cblksty=%x\n", tccp->cblksty);\r
+ fprintf(stdout, " qmfbid=%d\n", tccp->qmfbid);\r
+ fprintf(stdout, " qntsty=%d\n", tccp->qntsty);\r
+ fprintf(stdout, " numgbits=%d\n", tccp->numgbits);\r
+ fprintf(stdout, " roishift=%d\n", tccp->roishift);\r
+ fprintf(stdout, " stepsizes=");\r
+ numbands =\r
+ tccp->qntsty ==\r
+ J2K_CCP_QNTSTY_SIQNT ? 1 : tccp->numresolutions * 3 - 2;\r
+ for (bandno = 0; bandno < numbands; bandno++) {\r
+ fprintf(stdout, "(%d,%d) ", tccp->stepsizes[bandno].mant,\r
+ tccp->stepsizes[bandno].expn);\r
+ }\r
+ fprintf(stdout, "\n");\r
+ \r
+ if (tccp->csty & J2K_CCP_CSTY_PRT) {\r
+ fprintf(stdout, " prcw=");\r
+ for (resno = 0; resno < tccp->numresolutions; resno++) {\r
+ fprintf(stdout, "%d ", tccp->prcw[resno]);\r
+ }\r
+ fprintf(stdout, "\n");\r
+ fprintf(stdout, " prch=");\r
+ for (resno = 0; resno < tccp->numresolutions; resno++) {\r
+ fprintf(stdout, "%d ", tccp->prch[resno]);\r
+ }\r
+ fprintf(stdout, "\n");\r
+ }\r
+ fprintf(stdout, " }\n");\r
+ }\r
+ fprintf(stdout, " }\n");\r
+ }\r
+ fprintf(stdout, "}\n");\r
+}\r
+\r
+void j2k_write_soc()\r
+{\r
+ cio_write(J2K_MS_SOC, 2);\r
+}\r
+\r
+void j2k_read_soc()\r
+{\r
+ j2k_state = J2K_STATE_MHSIZ;\r
+}\r
+\r
+void j2k_write_siz()\r
+{\r
+ int i;\r
+ int lenp, len;\r
+ \r
+ cio_write(J2K_MS_SIZ, 2); /* SIZ */\r
+ lenp = cio_tell();\r
+ cio_skip(2);\r
+ cio_write(0, 2); /* Rsiz (capabilities) */\r
+ cio_write(j2k_img->x1, 4); /* Xsiz */\r
+ cio_write(j2k_img->y1, 4); /* Ysiz */\r
+ cio_write(j2k_img->x0, 4); /* X0siz */\r
+ cio_write(j2k_img->y0, 4); /* Y0siz */\r
+ cio_write(j2k_cp->tdx, 4); /* XTsiz */\r
+ cio_write(j2k_cp->tdy, 4); /* YTsiz */\r
+ cio_write(j2k_cp->tx0, 4); /* XT0siz */\r
+ cio_write(j2k_cp->ty0, 4); /* YT0siz */\r
+ cio_write(j2k_img->numcomps, 2); /* Csiz */\r
+ for (i = 0; i < j2k_img->numcomps; i++) {\r
+ cio_write(j2k_img->comps[i].prec - 1 + (j2k_img->comps[i].sgnd << 7), 1); /* Ssiz_i */\r
+ cio_write(j2k_img->comps[i].dx, 1); /* XRsiz_i */\r
+ cio_write(j2k_img->comps[i].dy, 1); /* YRsiz_i */\r
+ }\r
+ len = cio_tell() - lenp;\r
+ cio_seek(lenp);\r
+ cio_write(len, 2); /* Lsiz */\r
+ cio_seek(lenp + len);\r
+ \r
+}\r
+\r
+void j2k_read_siz()\r
+{\r
+ int len, i;\r
+ \r
+ len = cio_read(2); /* Lsiz */\r
+ cio_read(2); /* Rsiz (capabilities) */\r
+ j2k_img->x1 = cio_read(4); /* Xsiz */\r
+ j2k_img->y1 = cio_read(4); /* Ysiz */\r
+ j2k_img->x0 = cio_read(4); /* X0siz */\r
+ j2k_img->y0 = cio_read(4); /* Y0siz */\r
+ j2k_cp->tdx = cio_read(4); /* XTsiz */\r
+ j2k_cp->tdy = cio_read(4); /* YTsiz */\r
+ j2k_cp->tx0 = cio_read(4); /* XT0siz */\r
+ j2k_cp->ty0 = cio_read(4); /* YT0siz */\r
+ \r
+ j2k_img->numcomps = cio_read(2); /* Csiz */\r
+ j2k_img->comps =\r
+ (j2k_comp_t *) malloc(j2k_img->numcomps * sizeof(j2k_comp_t));\r
+ for (i = 0; i < j2k_img->numcomps; i++) {\r
+ int tmp, w, h;\r
+ tmp = cio_read(1); /* Ssiz_i */\r
+ j2k_img->comps[i].prec = (tmp & 0x7f) + 1;\r
+ j2k_img->comps[i].sgnd = tmp >> 7;\r
+ j2k_img->comps[i].dx = cio_read(1); /* XRsiz_i */\r
+ j2k_img->comps[i].dy = cio_read(1); /* YRsiz_i */\r
+ w = int_ceildiv(j2k_img->x1 - j2k_img->x0, j2k_img->comps[i].dx);\r
+ h = int_ceildiv(j2k_img->y1 - j2k_img->y0, j2k_img->comps[i].dy);\r
+ j2k_img->comps[i].resno_decoded = 0; /* number of resolution decoded */\r
+ j2k_img->comps[i].factor = 0; /* reducing factor by component */\r
+ }\r
+ \r
+ j2k_cp->tw = int_ceildiv(j2k_img->x1 - j2k_cp->tx0, j2k_cp->tdx);\r
+ j2k_cp->th = int_ceildiv(j2k_img->y1 - j2k_cp->ty0, j2k_cp->tdy);\r
+ j2k_cp->tcps =\r
+ (j2k_tcp_t *) calloc(j2k_cp->tw * j2k_cp->th, sizeof(j2k_tcp_t));\r
+ j2k_cp->tileno = (int *) calloc(j2k_cp->tw * j2k_cp->th, sizeof(int));\r
+ j2k_cp->tileno_size = 0;\r
+ \r
+ for (i = 0; i < j2k_cp->tw * j2k_cp->th; i++) {\r
+ j2k_cp->tcps[i].POC = 0;\r
+ j2k_cp->tcps[i].numpocs = 0;\r
+ j2k_cp->tcps[i].first = 1;\r
+ }\r
+ \r
+ /* Initialization for PPM marker */\r
+ j2k_cp->ppm = 0;\r
+ j2k_cp->ppm_data = NULL;\r
+ j2k_cp->ppm_data_first = NULL;\r
+ j2k_cp->ppm_previous = 0;\r
+ j2k_cp->ppm_store = 0;\r
+ \r
+ j2k_default_tcp.tccps =\r
+ (j2k_tccp_t *) calloc(sizeof(j2k_tccp_t), j2k_img->numcomps);\r
+ for (i = 0; i < j2k_cp->tw * j2k_cp->th; i++) {\r
+ j2k_cp->tcps[i].tccps =\r
+ (j2k_tccp_t *) calloc(sizeof(j2k_tccp_t), j2k_img->numcomps);\r
+ }\r
+ j2k_tile_data =\r
+ (unsigned char **) calloc(j2k_cp->tw * j2k_cp->th, sizeof(char *));\r
+ j2k_tile_len = (int *) calloc(j2k_cp->tw * j2k_cp->th, sizeof(int));\r
+ j2k_state = J2K_STATE_MH;\r
+ \r
+ \r
+}\r
+\r
+void j2k_write_com()\r
+{\r
+ unsigned int i;\r
+ int lenp, len;\r
+ char str[256];\r
+ sprintf(str, "%s", j2k_cp->comment);\r
+ \r
+ cio_write(J2K_MS_COM, 2);\r
+ lenp = cio_tell();\r
+ cio_skip(2);\r
+ cio_write(0, 2);\r
+ for (i = 0; i < strlen(str); i++) {\r
+ cio_write(str[i], 1);\r
+ }\r
+ len = cio_tell() - lenp;\r
+ cio_seek(lenp);\r
+ cio_write(len, 2);\r
+ cio_seek(lenp + len);\r
+ \r
+}\r
+\r
+void j2k_read_com()\r
+{\r
+ int len;\r
+ \r
+ len = cio_read(2);\r
+ cio_skip(len - 2);\r
+ \r
+}\r
+\r
+void j2k_write_cox(int compno)\r
+{\r
+ int i;\r
+ j2k_tcp_t *tcp;\r
+ j2k_tccp_t *tccp;\r
+ tcp = &j2k_cp->tcps[j2k_curtileno];\r
+ tccp = &tcp->tccps[compno];\r
+ \r
+ cio_write(tccp->numresolutions - 1, 1); /* SPcox (D) */\r
+ cio_write(tccp->cblkw - 2, 1); /* SPcox (E) */\r
+ cio_write(tccp->cblkh - 2, 1); /* SPcox (F) */\r
+ cio_write(tccp->cblksty, 1); /* SPcox (G) */\r
+ cio_write(tccp->qmfbid, 1); /* SPcox (H) */\r
+ \r
+ if (tccp->csty & J2K_CCP_CSTY_PRT) {\r
+ for (i = 0; i < tccp->numresolutions; i++) {\r
+ cio_write(tccp->prcw[i] + (tccp->prch[i] << 4), 1); /* SPcox (I_i) */\r
+ }\r
+ }\r
+}\r
+\r
+void j2k_read_cox(int compno)\r
+{\r
+ int i;\r
+ j2k_tcp_t *tcp;\r
+ j2k_tccp_t *tccp;\r
+ tcp =\r
+ j2k_state ==\r
+ J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp;\r
+ tccp = &tcp->tccps[compno];\r
+ tccp->numresolutions = cio_read(1) + 1; /* SPcox (D) */\r
+ /*Check the reduce value*/\r
+ j2k_cp->reduce=int_min((tccp->numresolutions)-1,j2k_cp->reduce);\r
+ tccp->cblkw = cio_read(1) + 2; /* SPcox (E) */\r
+ tccp->cblkh = cio_read(1) + 2; /* SPcox (F) */\r
+ tccp->cblksty = cio_read(1); /* SPcox (G) */\r
+ tccp->qmfbid = cio_read(1); /* SPcox (H) */\r
+ if (tccp->csty & J2K_CP_CSTY_PRT) {\r
+ for (i = 0; i < tccp->numresolutions; i++) {\r
+ int tmp = cio_read(1); /* SPcox (I_i) */\r
+ tccp->prcw[i] = tmp & 0xf;\r
+ tccp->prch[i] = tmp >> 4;\r
+ }\r
+ }\r
+}\r
+\r
+void j2k_write_cod()\r
+{\r
+ j2k_tcp_t *tcp;\r
+ int lenp, len;\r
+ \r
+ cio_write(J2K_MS_COD, 2); /* COD */\r
+ \r
+ lenp = cio_tell();\r
+ cio_skip(2);\r
+ \r
+ tcp = &j2k_cp->tcps[j2k_curtileno];\r
+ cio_write(tcp->csty, 1); /* Scod */\r
+ cio_write(tcp->prg, 1); /* SGcod (A) */\r
+ cio_write(tcp->numlayers, 2); /* SGcod (B) */\r
+ cio_write(tcp->mct, 1); /* SGcod (C) */\r
+ \r
+ j2k_write_cox(0);\r
+ len = cio_tell() - lenp;\r
+ cio_seek(lenp);\r
+ cio_write(len, 2); /* Lcod */\r
+ cio_seek(lenp + len);\r
+}\r
+\r
+void j2k_read_cod()\r
+{\r
+ int len, i, pos;\r
+ j2k_tcp_t *tcp;\r
+ \r
+ tcp =\r
+ j2k_state ==\r
+ J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp;\r
+ len = cio_read(2); /* Lcod */\r
+ tcp->csty = cio_read(1); /* Scod */\r
+ tcp->prg = cio_read(1); /* SGcod (A) */\r
+ tcp->numlayers = cio_read(2); /* SGcod (B) */\r
+ tcp->mct = cio_read(1); /* SGcod (C) */\r
+ \r
+ pos = cio_tell();\r
+ for (i = 0; i < j2k_img->numcomps; i++) {\r
+ tcp->tccps[i].csty = tcp->csty & J2K_CP_CSTY_PRT;\r
+ cio_seek(pos);\r
+ j2k_read_cox(i);\r
+ }\r
+}\r
+\r
+void j2k_write_coc(int compno)\r
+{\r
+ j2k_tcp_t *tcp;\r
+ int lenp, len;\r
+ \r
+ cio_write(J2K_MS_COC, 2); /* COC */\r
+ lenp = cio_tell();\r
+ cio_skip(2);\r
+ tcp = &j2k_cp->tcps[j2k_curtileno];\r
+ cio_write(compno, j2k_img->numcomps <= 256 ? 1 : 2); /* Ccoc */\r
+ cio_write(tcp->tccps[compno].csty, 1); /* Scoc */\r
+ j2k_write_cox(compno);\r
+ len = cio_tell() - lenp;\r
+ cio_seek(lenp);\r
+ cio_write(len, 2); /* Lcoc */\r
+ cio_seek(lenp + len);\r
+}\r
+\r
+void j2k_read_coc()\r
+{\r
+ int len, compno;\r
+ j2k_tcp_t *tcp;\r
+ \r
+ tcp =\r
+ j2k_state ==\r
+ J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp;\r
+ len = cio_read(2); /* Lcoc */\r
+ compno = cio_read(j2k_img->numcomps <= 256 ? 1 : 2); /* Ccoc */\r
+ tcp->tccps[compno].csty = cio_read(1); /* Scoc */\r
+ j2k_read_cox(compno);\r
+}\r
+\r
+void j2k_write_qcx(int compno)\r
+{\r
+ j2k_tcp_t *tcp;\r
+ j2k_tccp_t *tccp;\r
+ int bandno, numbands;\r
+ int expn, mant;\r
+ \r
+ tcp = &j2k_cp->tcps[j2k_curtileno];\r
+ tccp = &tcp->tccps[compno];\r
+ \r
+ cio_write(tccp->qntsty + (tccp->numgbits << 5), 1); /* Sqcx */\r
+ numbands =\r
+ tccp->qntsty ==\r
+ J2K_CCP_QNTSTY_SIQNT ? 1 : tccp->numresolutions * 3 - 2;\r
+ \r
+ for (bandno = 0; bandno < numbands; bandno++) {\r
+ expn = tccp->stepsizes[bandno].expn;\r
+ mant = tccp->stepsizes[bandno].mant;\r
+ \r
+ if (tccp->qntsty == J2K_CCP_QNTSTY_NOQNT) {\r
+ cio_write(expn << 3, 1); /* SPqcx_i */\r
+ } else {\r
+ cio_write((expn << 11) + mant, 2); /* SPqcx_i */\r
+ }\r
+ }\r
+ \r
+}\r
+\r
+void j2k_read_qcx(int compno, int len)\r
+{\r
+ int tmp;\r
+ j2k_tcp_t *tcp;\r
+ j2k_tccp_t *tccp;\r
+ int bandno, numbands;\r
+ \r
+ tcp =\r
+ j2k_state ==\r
+ J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp;\r
+ tccp = &tcp->tccps[compno];\r
+ tmp = cio_read(1); /* Sqcx */\r
+ tccp->qntsty = tmp & 0x1f;\r
+ tccp->numgbits = tmp >> 5;\r
+ numbands =\r
+ tccp->qntsty == J2K_CCP_QNTSTY_SIQNT ? 1 : (tccp->qntsty ==\r
+ J2K_CCP_QNTSTY_NOQNT ?\r
+ len - 1 : (len - 1) / 2);\r
+ for (bandno = 0; bandno < numbands; bandno++) {\r
+ int expn, mant;\r
+ if (tccp->qntsty == J2K_CCP_QNTSTY_NOQNT) {\r
+ expn = cio_read(1) >> 3; /* SPqcx_i */\r
+ mant = 0;\r
+ } else {\r
+ tmp = cio_read(2); /* SPqcx_i */\r
+ expn = tmp >> 11;\r
+ mant = tmp & 0x7ff;\r
+ }\r
+ tccp->stepsizes[bandno].expn = expn;\r
+ tccp->stepsizes[bandno].mant = mant;\r
+ }\r
+ \r
+ \r
+ \r
+ /* Add Antonin : if scalar_derived -> compute other stepsizes */\r
+ \r
+ \r
+ \r
+ if (tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) {\r
+ \r
+ for (bandno = 1; bandno < J2K_MAXBANDS; bandno++) {\r
+ \r
+ tccp->stepsizes[bandno].expn =\r
+ ((tccp->stepsizes[0].expn) - ((bandno - 1) / 3) >\r
+ 0) ? (tccp->stepsizes[0].expn) - ((bandno - 1) / 3) : 0;\r
+ \r
+ tccp->stepsizes[bandno].mant = tccp->stepsizes[0].mant;\r
+ \r
+ }\r
+ \r
+ }\r
+ \r
+ \r
+ \r
+ /* ddA */\r
+}\r
+\r
+void j2k_write_qcd()\r
+{\r
+ int lenp, len;\r
+ \r
+ cio_write(J2K_MS_QCD, 2); /* QCD */\r
+ lenp = cio_tell();\r
+ cio_skip(2);\r
+ j2k_write_qcx(0);\r
+ len = cio_tell() - lenp;\r
+ cio_seek(lenp);\r
+ cio_write(len, 2); /* Lqcd */\r
+ cio_seek(lenp + len);\r
+}\r
+\r
+void j2k_read_qcd()\r
+{\r
+ int len, i, pos;\r
+ \r
+ len = cio_read(2); /* Lqcd */\r
+ pos = cio_tell();\r
+ for (i = 0; i < j2k_img->numcomps; i++) {\r
+ cio_seek(pos);\r
+ j2k_read_qcx(i, len - 2);\r
+ }\r
+}\r
+\r
+void j2k_write_qcc(int compno)\r
+{\r
+ int lenp, len;\r
+ \r
+ cio_write(J2K_MS_QCC, 2); /* QCC */\r
+ lenp = cio_tell();\r
+ cio_skip(2);\r
+ cio_write(compno, j2k_img->numcomps <= 256 ? 1 : 2); /* Cqcc */\r
+ j2k_write_qcx(compno);\r
+ len = cio_tell() - lenp;\r
+ cio_seek(lenp);\r
+ cio_write(len, 2); /* Lqcc */\r
+ cio_seek(lenp + len);\r
+}\r
+\r
+void j2k_read_qcc()\r
+{\r
+ int len, compno;\r
+ \r
+ len = cio_read(2); /* Lqcc */\r
+ compno = cio_read(j2k_img->numcomps <= 256 ? 1 : 2); /* Cqcc */\r
+ j2k_read_qcx(compno, len - 2 - (j2k_img->numcomps <= 256 ? 1 : 2));\r
+}\r
+\r
+void j2k_write_poc()\r
+{\r
+ int len, numpchgs, i;\r
+ j2k_tcp_t *tcp;\r
+ j2k_tccp_t *tccp;\r
+ \r
+ tcp = &j2k_cp->tcps[j2k_curtileno];\r
+ tccp = &tcp->tccps[0];\r
+ numpchgs = tcp->numpocs;\r
+ cio_write(J2K_MS_POC, 2); /* POC */\r
+ len = 2 + (5 + 2 * (j2k_img->numcomps <= 256 ? 1 : 2)) * numpchgs;\r
+ cio_write(len, 2); /* Lpoc */\r
+ for (i = 0; i < numpchgs; i++) {\r
+ /* MODIF*/\r
+ j2k_poc_t *poc;\r
+ poc = &tcp->pocs[i];\r
+ cio_write(poc->resno0, 1); /* RSpoc_i */\r
+ cio_write(poc->compno0, (j2k_img->numcomps <= 256 ? 1 : 2)); /* CSpoc_i */\r
+ cio_write(poc->layno1, 2); /* LYEpoc_i */\r
+ poc->layno1 = int_min(poc->layno1, tcp->numlayers);\r
+ cio_write(poc->resno1, 1); /* REpoc_i */\r
+ poc->resno1 = int_min(poc->resno1, tccp->numresolutions);\r
+ cio_write(poc->compno1, (j2k_img->numcomps <= 256 ? 1 : 2)); /* CEpoc_i */\r
+ poc->compno1 = int_min(poc->compno1, j2k_img->numcomps);\r
+ cio_write(poc->prg, 1); /* Ppoc_i */\r
+ }\r
+}\r
+\r
+void j2k_read_poc()\r
+{\r
+ int len, numpchgs, i, old_poc;\r
+ j2k_tcp_t *tcp;\r
+ j2k_tccp_t *tccp;\r
+ \r
+ tcp =\r
+ j2k_state ==\r
+ J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp;\r
+ \r
+ old_poc = tcp->POC ? tcp->numpocs + 1 : 0;\r
+ tcp->POC = 1;\r
+ tccp = &tcp->tccps[0];\r
+ len = cio_read(2); /* Lpoc */\r
+ numpchgs = (len - 2) / (5 + 2 * (j2k_img->numcomps <= 256 ? 1 : 2));\r
+ \r
+ for (i = old_poc; i < numpchgs + old_poc; i++) {\r
+ j2k_poc_t *poc;\r
+ poc = &tcp->pocs[i];\r
+ poc->resno0 = cio_read(1); /* RSpoc_i */\r
+ poc->compno0 = cio_read(j2k_img->numcomps <= 256 ? 1 : 2); /* CSpoc_i */\r
+ poc->layno1 = int_min(cio_read(2), (unsigned int) tcp->numlayers); /* LYEpoc_i */\r
+ poc->resno1 = int_min(cio_read(1), (unsigned int) tccp->numresolutions); /* REpoc_i */\r
+ poc->compno1 = int_min(cio_read(j2k_img->numcomps <= 256 ? 1 : 2), (unsigned int) j2k_img->numcomps); /* CEpoc_i */\r
+ poc->prg = cio_read(1); /* Ppoc_i */\r
+ }\r
+ \r
+ tcp->numpocs = numpchgs + old_poc - 1;\r
+}\r
+\r
+void j2k_read_crg()\r
+{\r
+ int len, i, Xcrg_i, Ycrg_i;\r
+ \r
+ len = cio_read(2); /* Lcrg */\r
+ for (i = 0; i < j2k_img->numcomps; i++) {\r
+ Xcrg_i = cio_read(2); /* Xcrg_i */\r
+ Ycrg_i = cio_read(2); /* Ycrg_i */\r
+ }\r
+}\r
+\r
+void j2k_read_tlm()\r
+{\r
+ int len, Ztlm, Stlm, ST, SP, tile_tlm, i;\r
+ long int Ttlm_i, Ptlm_i;\r
+ \r
+ len = cio_read(2); /* Ltlm */\r
+ Ztlm = cio_read(1); /* Ztlm */\r
+ Stlm = cio_read(1); /* Stlm */\r
+ ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);\r
+ SP = (Stlm >> 6) & 0x01;\r
+ tile_tlm = (len - 4) / ((SP + 1) * 2 + ST);\r
+ for (i = 0; i < tile_tlm; i++) {\r
+ Ttlm_i = cio_read(ST); /* Ttlm_i */\r
+ Ptlm_i = cio_read(SP ? 4 : 2); /* Ptlm_i */\r
+ }\r
+}\r
+\r
+void j2k_read_plm()\r
+{\r
+ int len, i, Zplm, Nplm, add, packet_len = 0;\r
+ \r
+ len = cio_read(2); /* Lplm */\r
+ Zplm = cio_read(1); /* Zplm */\r
+ len -= 3;\r
+ while (len > 0) {\r
+ Nplm = cio_read(4); /* Nplm */\r
+ len -= 4;\r
+ for (i = Nplm; i > 0; i--) {\r
+ add = cio_read(1);\r
+ len--;\r
+ packet_len = (packet_len << 7) + add; /* Iplm_ij */\r
+ if ((add & 0x80) == 0) {\r
+ /* New packet */\r
+ packet_len = 0;\r
+ }\r
+ if (len <= 0)\r
+ break;\r
+ }\r
+ }\r
+}\r
+\r
+void j2k_read_plt()\r
+{\r
+ int len, i, Zplt, packet_len = 0, add;\r
+ \r
+ len = cio_read(2); /* Lplt */\r
+ Zplt = cio_read(1); /* Zplt */\r
+ for (i = len - 3; i > 0; i--) {\r
+ add = cio_read(1);\r
+ packet_len = (packet_len << 7) + add; /* Iplt_i */\r
+ if ((add & 0x80) == 0) {\r
+ /* New packet */\r
+ packet_len = 0;\r
+ }\r
+ }\r
+}\r
+\r
+void j2k_read_ppm()\r
+{\r
+ int len, Z_ppm, i, j;\r
+ int N_ppm;\r
+ \r
+ len = cio_read(2);\r
+ j2k_cp->ppm = 1;\r
+ \r
+ Z_ppm = cio_read(1); /* Z_ppm */\r
+ len -= 3;\r
+ while (len > 0) {\r
+ if (j2k_cp->ppm_previous == 0) {\r
+ N_ppm = cio_read(4); /* N_ppm */\r
+ len -= 4;\r
+ } else {\r
+ N_ppm = j2k_cp->ppm_previous;\r
+ }\r
+ \r
+ j = j2k_cp->ppm_store;\r
+ if (Z_ppm == 0) { /* First PPM marker */\r
+ j2k_cp->ppm_data =\r
+ (unsigned char *) calloc(N_ppm, sizeof(unsigned char));\r
+ j2k_cp->ppm_data_first = j2k_cp->ppm_data;\r
+ \r
+ j2k_cp->ppm_len = N_ppm; /*Add antonin : ppmbug1*/\r
+ \r
+ } else { /* NON-first PPM marker */\r
+ j2k_cp->ppm_data =\r
+ (unsigned char *) realloc(j2k_cp->ppm_data,\r
+ (N_ppm +\r
+ j2k_cp->ppm_store) *\r
+ sizeof(unsigned char));\r
+ j2k_cp->ppm_data_first = j2k_cp->ppm_data;\r
+ \r
+ j2k_cp->ppm_len = N_ppm + j2k_cp->ppm_store; /*Add antonin : ppmbug1*/\r
+ \r
+ }\r
+ \r
+ for (i = N_ppm; i > 0; i--) { /* Read packet header */\r
+ j2k_cp->ppm_data[j] = cio_read(1);\r
+ j++;\r
+ len--;\r
+ if (len == 0)\r
+ break; /* Case of non-finished packet header in present marker but finished in next one */\r
+ }\r
+ \r
+ j2k_cp->ppm_previous = i - 1;\r
+ j2k_cp->ppm_store = j;\r
+ }\r
+}\r
+\r
+void j2k_read_ppt()\r
+{\r
+ int len, Z_ppt, i, j = 0;\r
+ j2k_tcp_t *tcp;\r
+ \r
+ len = cio_read(2);\r
+ Z_ppt = cio_read(1);\r
+ tcp = &j2k_cp->tcps[j2k_curtileno];\r
+ tcp->ppt = 1;\r
+ if (Z_ppt == 0) { /* First PPT marker */\r
+ tcp->ppt_data =\r
+ (unsigned char *) calloc(len - 3, sizeof(unsigned char));\r
+ tcp->ppt_data_first = tcp->ppt_data;\r
+ tcp->ppt_store = 0;\r
+ \r
+ tcp->ppt_len = len - 3; /*Add antonin : ppmbug1*/\r
+ } else { /* NON-first PPT marker */\r
+ tcp->ppt_data =\r
+ (unsigned char *) realloc(tcp->ppt_data,\r
+ (len - 3 +\r
+ tcp->ppt_store) * sizeof(unsigned char));\r
+ tcp->ppt_data_first = tcp->ppt_data;\r
+ \r
+ tcp->ppt_len = len - 3 + tcp->ppt_store; /*Add antonin : ppmbug1*/\r
+ \r
+ }\r
+ \r
+ j = tcp->ppt_store;\r
+ for (i = len - 3; i > 0; i--) {\r
+ tcp->ppt_data[j] = cio_read(1);\r
+ j++;\r
+ }\r
+ tcp->ppt_store = j;\r
+}\r
+\r
+void j2k_write_sot()\r
+{\r
+ int lenp, len;\r
+ \r
+ j2k_sot_start = cio_tell();\r
+ cio_write(J2K_MS_SOT, 2); /* SOT */\r
+ lenp = cio_tell();\r
+ cio_skip(2); /* Lsot (further) */\r
+ cio_write(j2k_curtileno, 2); /* Isot */\r
+ cio_skip(4); /* Psot (further in j2k_write_sod) */\r
+ cio_write(0, 1); /* TPsot */\r
+ cio_write(1, 1); /* TNsot */\r
+ len = cio_tell() - lenp;\r
+ cio_seek(lenp);\r
+ cio_write(len, 2); /* Lsot */\r
+ cio_seek(lenp + len);\r
+}\r
+\r
+void j2k_read_sot()\r
+{\r
+ int len, tileno, totlen, partno, numparts, i;\r
+ j2k_tcp_t *tcp;\r
+ j2k_tccp_t *tmp;\r
+ char status = 0;\r
+ \r
+ len = cio_read(2);\r
+ tileno = cio_read(2);\r
+ \r
+ if (j2k_cp->tileno_size == 0) {\r
+ j2k_cp->tileno[j2k_cp->tileno_size] = tileno;\r
+ j2k_cp->tileno_size++;\r
+ } else {\r
+ i = 0;\r
+ while (i < j2k_cp->tileno_size && status == 0) {\r
+ status = j2k_cp->tileno[i] == tileno ? 1 : 0;\r
+ i++;\r
+ }\r
+ if (status == 0) {\r
+ j2k_cp->tileno[j2k_cp->tileno_size] = tileno;\r
+ j2k_cp->tileno_size++;\r
+ }\r
+ }\r
+ \r
+ totlen = cio_read(4);\r
+ if (!totlen)\r
+ totlen = cio_numbytesleft() + 8;\r
+ \r
+ partno = cio_read(1);\r
+ numparts = cio_read(1);\r
+ \r
+ j2k_curtileno = tileno;\r
+ j2k_eot = cio_getbp() - 12 + totlen;\r
+ j2k_state = J2K_STATE_TPH;\r
+ tcp = &j2k_cp->tcps[j2k_curtileno];\r
+ \r
+ if (tcp->first == 1) {\r
+ tmp = tcp->tccps;\r
+ *tcp = j2k_default_tcp;\r
+ \r
+ /* Initialization PPT */\r
+ tcp->ppt = 0;\r
+ tcp->ppt_data = NULL;\r
+ tcp->ppt_data_first = NULL;\r
+ \r
+ tcp->tccps = tmp;\r
+ for (i = 0; i < j2k_img->numcomps; i++) {\r
+ tcp->tccps[i] = j2k_default_tcp.tccps[i];\r
+ }\r
+ j2k_cp->tcps[j2k_curtileno].first = 0;\r
+ }\r
+}\r
+\r
+void j2k_write_sod()\r
+{\r
+ int l, layno;\r
+ int totlen;\r
+ j2k_tcp_t *tcp;\r
+ static int j2k_sod_start;\r
+ \r
+ cio_write(J2K_MS_SOD, 2);\r
+ if (j2k_curtileno == 0) {\r
+ j2k_sod_start = cio_tell() + pos_correction;\r
+ }\r
+ \r
+ /* INDEX >> */\r
+ if (info_IM.index_on) {\r
+ info_IM.tile[j2k_curtileno].end_header =\r
+ cio_tell() + pos_correction - 1;\r
+ }\r
+ /* << INDEX */\r
+ \r
+ tcp = &j2k_cp->tcps[j2k_curtileno];\r
+ for (layno = 0; layno < tcp->numlayers; layno++) {\r
+ tcp->rates[layno] -= tcp->rates[layno] ? (j2k_sod_start / (j2k_cp->th * j2k_cp->tw)) : 0; /*Mod antonin losslessbug*/\r
+ }\r
+ \r
+ info_IM.num = 0;\r
+ if (j2k_cp->decod_format != PGX_DFMT)\r
+ l = tcd_encode_tile_pxm(j2k_curtileno, cio_getbp(),\r
+ cio_numbytesleft() - 2, &info_IM);\r
+ else\r
+ l = tcd_encode_tile_pgx(j2k_curtileno, cio_getbp(),\r
+ cio_numbytesleft() - 2, &info_IM);\r
+ \r
+ /* Writing Psot in SOT marker */\r
+ totlen = cio_tell() + l - j2k_sot_start;\r
+ cio_seek(j2k_sot_start + 6);\r
+ cio_write(totlen, 4);\r
+ cio_seek(j2k_sot_start + totlen);\r
+}\r
+\r
+void j2k_read_sod()\r
+{\r
+ int len, truncate = 0, i;\r
+ unsigned char *data;\r
+ \r
+ len = int_min(j2k_eot - cio_getbp(), cio_numbytesleft() + 1);\r
+ \r
+ if (len == cio_numbytesleft() + 1)\r
+ truncate = 1; /* Case of a truncate codestream */\r
+ \r
+ data =\r
+ (unsigned char *) malloc((j2k_tile_len[j2k_curtileno] + len) *\r
+ sizeof(unsigned char));\r
+ for (i = 0; i < j2k_tile_len[j2k_curtileno]; i++)\r
+ data[i] = j2k_tile_data[j2k_curtileno][i];\r
+ for (i = 0; i < len; i++)\r
+ data[i + j2k_tile_len[j2k_curtileno]] = cio_read(1);\r
+ \r
+ j2k_tile_len[j2k_curtileno] += len;\r
+ free(j2k_tile_data[j2k_curtileno]);\r
+ j2k_tile_data[j2k_curtileno] = data;\r
+ data = NULL;\r
+ \r
+ if (!truncate)\r
+ j2k_state = J2K_STATE_TPHSOT;\r
+ else\r
+ j2k_state = J2K_STATE_NEOC; /* RAJOUTE !! */\r
+}\r
+\r
+void j2k_write_rgn(int compno, int tileno)\r
+{\r
+ j2k_tcp_t *tcp = &j2k_cp->tcps[tileno];\r
+ \r
+ cio_write(J2K_MS_RGN, 2); /* RGN */\r
+ cio_write(j2k_img->numcomps <= 256 ? 5 : 6, 2); /* Lrgn */\r
+ cio_write(compno, j2k_img->numcomps <= 256 ? 1 : 2); /* Crgn */\r
+ cio_write(0, 1); /* Srgn */\r
+ cio_write(tcp->tccps[compno].roishift, 1); /* SPrgn */\r
+}\r
+\r
+void j2k_read_rgn()\r
+{\r
+ int len, compno, roisty;\r
+ j2k_tcp_t *tcp;\r
+ \r
+ tcp =\r
+ j2k_state ==\r
+ J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp;\r
+ len = cio_read(2); /* Lrgn */\r
+ compno = cio_read(j2k_img->numcomps <= 256 ? 1 : 2); /* Crgn */\r
+ roisty = cio_read(1); /* Srgn */\r
+ tcp->tccps[compno].roishift = cio_read(1); /* SPrgn */\r
+}\r
+\r
+void j2k_write_eoc()\r
+{\r
+ /* fprintf(stderr, "%.8x: EOC\n", cio_tell() + pos_correction); */\r
+ cio_write(J2K_MS_EOC, 2);\r
+}\r
+\r
+void j2k_read_eoc()\r
+{\r
+ int i, tileno;\r
+\r
+#ifndef NO_PACKETS_DECODING \r
+ tcd_init(j2k_img, j2k_cp);\r
+#endif\r
+ \r
+ for (i = 0; i < j2k_cp->tileno_size; i++) {\r
+ tileno = j2k_cp->tileno[i];\r
+#ifndef NO_PACKETS_DECODING \r
+ tcd_decode_tile(j2k_tile_data[tileno], j2k_tile_len[tileno], tileno);\r
+#endif\r
+ free(j2k_tile_data[tileno]);\r
+ }\r
+ \r
+ j2k_state = J2K_STATE_MT;\r
+ longjmp(j2k_error, 1);\r
+}\r
+\r
+void j2k_read_unk()\r
+{\r
+ fprintf(stderr, "warning: unknown marker\n");\r
+}\r
+\r
+LIBJ2K_API int\r
+j2k_encode(j2k_image_t * img, j2k_cp_t * cp, char *output,\r
+ int len, char *index)\r
+{\r
+ int tileno, compno, layno, resno, precno, pack_nb, x, y;\r
+ unsigned char *dest = NULL;\r
+ FILE *INDEX = NULL;\r
+ FILE *f = NULL;\r
+ \r
+ if (setjmp(j2k_error)) {\r
+ return 0;\r
+ }\r
+ \r
+ if (cp->intermed_file == 1) {\r
+ f = fopen(output, "wb");\r
+ if (!f) {\r
+ fprintf(stderr, "failed to open %s for writing\n", output);\r
+ return 1;\r
+ }\r
+ dest = (unsigned char *) malloc(len);\r
+ cio_init(dest, len);\r
+ }\r
+ \r
+ j2k_img = img;\r
+ j2k_cp = cp;\r
+ /* j2k_dump_cp(j2k_img, j2k_cp); */\r
+ \r
+ /* INDEX >> */\r
+ info_IM.index_on = j2k_cp->index_on;\r
+ if (info_IM.index_on) {\r
+ info_IM.tile =\r
+ (info_tile *) malloc(j2k_cp->tw * j2k_cp->th * sizeof(info_tile));\r
+ info_IM.Im_w = j2k_img->x1 - j2k_img->x0;\r
+ info_IM.Im_h = j2k_img->y1 - j2k_img->y0;\r
+ info_IM.Prog = (&j2k_cp->tcps[0])->prg;\r
+ info_IM.tw = j2k_cp->tw;\r
+ info_IM.th = j2k_cp->th;\r
+ info_IM.Tile_x = j2k_cp->tdx; /* new version parser */\r
+ info_IM.Tile_y = j2k_cp->tdy; /* new version parser */\r
+ info_IM.Tile_Ox = j2k_cp->tx0; /* new version parser */\r
+ info_IM.Tile_Oy = j2k_cp->ty0; /* new version parser */\r
+ info_IM.Comp = j2k_img->numcomps;\r
+ info_IM.Layer = (&j2k_cp->tcps[0])->numlayers;\r
+ info_IM.Decomposition = (&j2k_cp->tcps[0])->tccps->numresolutions - 1;\r
+ info_IM.D_max = 0; /* ADD Marcela */\r
+ }\r
+ /* << INDEX */\r
+ \r
+ j2k_write_soc();\r
+ j2k_write_siz();\r
+ j2k_write_cod();\r
+ j2k_write_qcd();\r
+ for (compno = 0; compno < j2k_img->numcomps; compno++) {\r
+ j2k_tcp_t *tcp = &j2k_cp->tcps[0];\r
+ if (tcp->tccps[compno].roishift)\r
+ j2k_write_rgn(compno, 0);\r
+ }\r
+ if (j2k_cp->comment != NULL)\r
+ j2k_write_com();\r
+ \r
+ if (cp->intermed_file == 1) {\r
+ /* Writing the main header */\r
+ pos_correction = cio_tell();\r
+ fwrite(dest, 1, cio_tell(), f);\r
+ }\r
+ \r
+ /* INDEX >> */\r
+ if (info_IM.index_on) {\r
+ info_IM.Main_head_end = cio_tell() - 1;\r
+ }\r
+ /* << INDEX */\r
+ \r
+ \r
+ for (tileno = 0; tileno < cp->tw * cp->th; tileno++) {\r
+ fprintf(stdout, "Tile number %d / %d ", tileno + 1, cp->tw * cp->th);\r
+ \r
+ if (cp->intermed_file == 1) {\r
+ /* new dest for each tile */\r
+ free(dest);\r
+ dest = (unsigned char *) malloc(len);\r
+ cio_init(dest, len);\r
+ }\r
+ j2k_curtileno = tileno;\r
+ /* initialisation before tile encoding */\r
+ \r
+ if (tileno == 0) {\r
+ tcd_malloc_encode(j2k_img, j2k_cp, j2k_curtileno);\r
+ } else {\r
+ tcd_init_encode(j2k_img, j2k_cp, j2k_curtileno);\r
+ }\r
+ \r
+ /* INDEX >> */\r
+ if (info_IM.index_on) {\r
+ info_IM.tile[j2k_curtileno].num_tile = j2k_curtileno;\r
+ info_IM.tile[j2k_curtileno].start_pos = cio_tell() + pos_correction;\r
+ }\r
+ /* << INDEX */\r
+ j2k_write_sot();\r
+ \r
+ for (compno = 1; compno < img->numcomps; compno++) {\r
+ j2k_write_coc(compno);\r
+ j2k_write_qcc(compno);\r
+ }\r
+ \r
+ if (cp->tcps[tileno].numpocs)\r
+ j2k_write_poc();\r
+ j2k_write_sod();\r
+ \r
+ /* INDEX >> */\r
+ if (info_IM.index_on) {\r
+ info_IM.tile[j2k_curtileno].end_pos =\r
+ cio_tell() + pos_correction - 1;\r
+ }\r
+ /* << INDEX */\r
+ \r
+ /*\r
+ if (tile->PPT) BAD PPT !!!\r
+ {\r
+ FILE *PPT_file;\r
+ \r
+ int i;\r
+ PPT_file=fopen("PPT","rb");\r
+ fprintf(stderr,"%c%c%c%c",255,97,tile->len_ppt/256,tile->len_ppt%256);\r
+ for (i=0;i<tile->len_ppt;i++)\r
+ {\r
+ unsigned char elmt;\r
+ fread(&elmt, 1, 1, PPT_file);\r
+ fwrite(&elmt,1,1,f);\r
+ }\r
+ fclose(PPT_file);\r
+ unlink("PPT");\r
+ }\r
+ */\r
+ if (cp->intermed_file == 1) {\r
+ fwrite(dest, 1, cio_tell(), f);\r
+ pos_correction = cio_tell() + pos_correction;\r
+ }\r
+ }\r
+ \r
+ if (cp->intermed_file == 1) {\r
+ free(dest);\r
+ dest = (unsigned char *) malloc(len);\r
+ cio_init(dest, len);\r
+ }\r
+ \r
+ j2k_write_eoc();\r
+ \r
+ if (cp->intermed_file == 1) {\r
+ fwrite(dest, 1, 2, f);\r
+ free(dest);\r
+ /* closing file *.j2k */\r
+ fclose(f);\r
+ }\r
+ \r
+ /* Creation of the index file */\r
+ \r
+ if (info_IM.index_on) {\r
+ \r
+ double DistoTotal = 0;\r
+ \r
+ info_IM.codestream_size = cio_tell() + pos_correction; /* Correction 14/4/03 suite rmq de Patrick */\r
+ \r
+ INDEX = fopen(index, "w");\r
+ \r
+ \r
+ \r
+ if (!INDEX) {\r
+ \r
+ fprintf(stderr, "failed to open %s for writing\n", index);\r
+ \r
+ return 1;\r
+ \r
+ }\r
+ \r
+ fprintf(INDEX, "%d %d\n", info_IM.Im_w, info_IM.Im_h);\r
+\r
+ fprintf(INDEX, "%d\n", info_IM.Prog);\r
+\r
+ fprintf(INDEX, "%d %d\n", info_IM.Tile_x, info_IM.Tile_y);\r
+\r
+ fprintf(INDEX, "%d %d\n", info_IM.tw, info_IM.th);\r
+\r
+ fprintf(INDEX, "%d\n", info_IM.Comp);\r
+\r
+ fprintf(INDEX, "%d\n", info_IM.Layer);\r
+\r
+ fprintf(INDEX, "%d\n", info_IM.Decomposition);\r
+\r
+ for (resno = info_IM.Decomposition; resno >= 0; resno--) {\r
+\r
+ fprintf(INDEX, "[%d,%d] ", (1 << info_IM.tile[0].pdx[resno]), (1 << info_IM.tile[0].pdx[resno])); /*based on tile 0*/\r
+\r
+ }\r
+\r
+ fprintf(INDEX, "\n");\r
+\r
+ fprintf(INDEX, "%d\n", info_IM.Main_head_end);\r
+\r
+ fprintf(INDEX, "%d\n", info_IM.codestream_size);\r
+\r
+ for (tileno = 0; tileno < info_IM.tw * info_IM.th; tileno++) {\r
+\r
+ fprintf(INDEX, "%4d %9d %9d %9d %9e %9d %9e\n",\r
+ info_IM.tile[tileno].num_tile,\r
+ info_IM.tile[tileno].start_pos,\r
+ info_IM.tile[tileno].end_header,\r
+ info_IM.tile[tileno].end_pos,\r
+ info_IM.tile[tileno].distotile, info_IM.tile[tileno].nbpix,\r
+ info_IM.tile[tileno].distotile / info_IM.tile[tileno].nbpix);\r
+\r
+ }\r
+\r
+ for (tileno = 0; tileno < info_IM.tw * info_IM.th; tileno++) {\r
+\r
+ int start_pos, end_pos;\r
+\r
+ double disto = 0;\r
+\r
+ pack_nb = 0;\r
+\r
+ /* fprintf(INDEX,\r
+\r
+ "pkno tileno layerno resno compno precno start_pos end_pos deltaSE \n"); */\r
+ \r
+ if (info_IM.Prog == 0) { /* LRCP */\r
+ /*fprintf(INDEX, "pack_nb tileno layno resno compno precno start_pos end_pos disto");*/\r
+ for (layno = 0; layno < info_IM.Layer; layno++) {\r
+ for (resno = 0; resno < info_IM.Decomposition + 1; resno++) {\r
+ for (compno = 0; compno < info_IM.Comp; compno++) {\r
+ for (precno = 0;\r
+ precno <\r
+ info_IM.tile[tileno].pw[resno] * info_IM.tile[tileno].ph[resno];\r
+ precno++) {\r
+ start_pos = info_IM.tile[tileno].packet[pack_nb].start_pos;\r
+ end_pos = info_IM.tile[tileno].packet[pack_nb].end_pos;\r
+ disto = info_IM.tile[tileno].packet[pack_nb].disto;\r
+ fprintf(INDEX, "%4d %6d %7d %5d %6d %6d %9d %9d %8e\n",\r
+ pack_nb, tileno, layno, resno, compno, precno,\r
+ start_pos, end_pos, disto);\r
+ DistoTotal += disto;\r
+ pack_nb++;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ } else if (info_IM.Prog == 1) { /* RLCP */\r
+ /*fprintf(INDEX, "pack_nb tileno resno layno compno precno start_pos end_pos disto");*/\r
+ for (resno = 0; resno < info_IM.Decomposition + 1; resno++) {\r
+ for (layno = 0; layno < info_IM.Layer; layno++) {\r
+ for (compno = 0; compno < info_IM.Comp; compno++) {\r
+ for (precno = 0; precno < info_IM.tile[tileno].pw[resno] * info_IM.tile[tileno].ph[resno]; precno++) {\r
+ start_pos = info_IM.tile[tileno].packet[pack_nb].start_pos;\r
+ end_pos = info_IM.tile[tileno].packet[pack_nb].end_pos;\r
+ disto = info_IM.tile[tileno].packet[pack_nb].disto;\r
+ fprintf(INDEX, "%4d %6d %5d %7d %6d %6d %9d %9d %8e\n",\r
+ pack_nb, tileno, resno, layno, compno, precno,\r
+ start_pos, end_pos, disto);\r
+ DistoTotal += disto;\r
+ pack_nb++;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ } else if (info_IM.Prog == 2) { /* RPCL */\r
+ /*fprintf(INDEX, "\npack_nb tileno resno precno compno layno start_pos end_pos disto\n"); */\r
+ for (resno = 0; resno < info_IM.Decomposition + 1; resno++) {\r
+ /* I suppose components have same XRsiz, YRsiz */\r
+ int x0 = info_IM.Tile_Ox + tileno - (int)floor( tileno/info_IM.tw ) * info_IM.tw * info_IM.Tile_x;\r
+ int y0 = info_IM.Tile_Ox + (int)floor( tileno/info_IM.tw ) * info_IM.Tile_y;\r
+ int x1 = x0 + info_IM.Tile_x;\r
+ int y1 = y0 + info_IM.Tile_y;\r
+ for (y=y0; y<y1; y++) {\r
+ for (x=x0; x<x1; x++) {\r
+ for (compno = 0; compno < info_IM.Comp; compno++) {\r
+ int prec_max = info_IM.tile[tileno].pw[resno] * info_IM.tile[tileno].ph[resno];\r
+ for (precno = 0; precno < prec_max; precno++) {\r
+ int pcnx = info_IM.tile[tileno].pw[resno];\r
+ int pcx = (int) pow( 2, info_IM.tile[tileno].pdx[resno] + info_IM.Decomposition - resno );\r
+ int pcy = (int) pow( 2, info_IM.tile[tileno].pdy[resno] + info_IM.Decomposition - resno );\r
+ int precno_x = precno - (int) floor( precno/pcnx ) * pcnx;\r
+ int precno_y = (int) floor( precno/pcnx ); \r
+ if (precno_y*pcy == y ) {\r
+ if (precno_x*pcx == x ) {\r
+ for (layno = 0; layno < info_IM.Layer; layno++) {\r
+ start_pos = info_IM.tile[tileno].packet[pack_nb].start_pos;\r
+ end_pos = info_IM.tile[tileno].packet[pack_nb].end_pos;\r
+ disto = info_IM.tile[tileno].packet[pack_nb].disto;\r
+ fprintf(INDEX, "%4d %6d %5d %6d %6d %7d %9d %9d %8e\n",\r
+ pack_nb, tileno, resno, precno, compno, layno,\r
+ start_pos, end_pos, disto); \r
+ DistoTotal += disto;\r
+ pack_nb++; \r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ } else if (info_IM.Prog == 3) { /* PCRL */\r
+ /* I suppose components have same XRsiz, YRsiz*/ \r
+ int x0 = info_IM.Tile_Ox + tileno - (int)floor( tileno/info_IM.tw ) * info_IM.tw * info_IM.Tile_x;\r
+ int y0 = info_IM.Tile_Ox + (int)floor( tileno/info_IM.tw ) * info_IM.Tile_y;\r
+ int x1 = x0 + info_IM.Tile_x;\r
+ int y1 = y0 + info_IM.Tile_y;\r
+ \r
+ /*fprintf(INDEX, "\npack_nb tileno precno compno resno layno start_pos end_pos disto\n"); */\r
+ for (y=y0; y<y1; y++) {\r
+ for (x=x0; x<x1; x++) {\r
+ for (compno = 0; compno < info_IM.Comp; compno++) {\r
+ for (resno = 0; resno < info_IM.Decomposition + 1; resno++) {\r
+ int prec_max = info_IM.tile[tileno].pw[resno] * info_IM.tile[tileno].ph[resno];\r
+ for (precno = 0; precno < prec_max; precno++) {\r
+ int pcnx = info_IM.tile[tileno].pw[resno];\r
+ int pcx = (int) pow( 2, info_IM.tile[tileno].pdx[resno] + info_IM.Decomposition - resno );\r
+ int pcy = (int) pow( 2, info_IM.tile[tileno].pdy[resno] + info_IM.Decomposition - resno );\r
+ int precno_x = precno - (int) floor( precno/pcnx ) * pcnx;\r
+ int precno_y = (int) floor( precno/pcnx ); \r
+ if (precno_y*pcy == y ) {\r
+ if (precno_x*pcx == x ) {\r
+ for (layno = 0; layno < info_IM.Layer; layno++) {\r
+ start_pos = info_IM.tile[tileno].packet[pack_nb].start_pos;\r
+ end_pos = info_IM.tile[tileno].packet[pack_nb].end_pos;\r
+ disto = info_IM.tile[tileno].packet[pack_nb].disto;\r
+ fprintf(INDEX, "%4d %6d %6d %6d %5d %7d %9d %9d %8e\n",\r
+ pack_nb, tileno, precno, compno, resno, layno,\r
+ start_pos, end_pos, disto); \r
+ DistoTotal += disto;\r
+ pack_nb++; \r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ } else { /* CPRL */\r
+ /*fprintf(INDEX, "\npack_nb tileno compno precno resno layno start_pos end_pos disto\n"); */\r
+ for (compno = 0; compno < info_IM.Comp; compno++) {\r
+ /* I suppose components have same XRsiz, YRsiz */\r
+ int x0 = info_IM.Tile_Ox + tileno - (int)floor( tileno/info_IM.tw ) * info_IM.tw * info_IM.Tile_x;\r
+ int y0 = info_IM.Tile_Ox + (int)floor( tileno/info_IM.tw ) * info_IM.Tile_y;\r
+ int x1 = x0 + info_IM.Tile_x;\r
+ int y1 = y0 + info_IM.Tile_y;\r
+ for (y=y0; y<y1; y++) {\r
+ for (x=x0; x<x1; x++) {\r
+ for (resno = 0; resno < info_IM.Decomposition + 1; resno++) {\r
+ int prec_max = info_IM.tile[tileno].pw[resno] * info_IM.tile[tileno].ph[resno];\r
+ for (precno = 0; precno < prec_max; precno++) {\r
+ int pcnx = info_IM.tile[tileno].pw[resno];\r
+ int pcx = (int) pow( 2, info_IM.tile[tileno].pdx[resno] + info_IM.Decomposition - resno );\r
+ int pcy = (int) pow( 2, info_IM.tile[tileno].pdy[resno] + info_IM.Decomposition - resno );\r
+ int precno_x = precno - (int) floor( precno/pcnx ) * pcnx;\r
+ int precno_y = (int) floor( precno/pcnx ); \r
+ if (precno_y*pcy == y ) {\r
+ if (precno_x*pcx == x ) {\r
+ for (layno = 0; layno < info_IM.Layer; layno++) {\r
+ start_pos = info_IM.tile[tileno].packet[pack_nb].start_pos;\r
+ end_pos = info_IM.tile[tileno].packet[pack_nb].end_pos;\r
+ disto = info_IM.tile[tileno].packet[pack_nb].disto;\r
+ fprintf(INDEX, "%4d %6d %6d %6d %5d %7d %9d %9d %8e\n",\r
+ pack_nb, tileno, compno, precno, resno, layno, start_pos, end_pos, disto); \r
+ DistoTotal += disto;\r
+ pack_nb++; \r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ } \r
+ }\r
+ \r
+ fprintf(INDEX, "%8e\n", info_IM.D_max); /*SE max*/\r
+ \r
+ fprintf(INDEX, "%.8e\n", DistoTotal); /* SE totale*/\r
+ \r
+ fclose(INDEX);\r
+ \r
+ }\r
+ \r
+ j2k_clean();\r
+ \r
+ return cio_tell();\r
+}\r
+\r
+typedef struct {\r
+ int id;\r
+ int states;\r
+ void (*handler) ();\r
+} j2k_dec_mstabent_t;\r
+\r
+j2k_dec_mstabent_t j2k_dec_mstab[] = {\r
+ {J2K_MS_SOC, J2K_STATE_MHSOC, j2k_read_soc},\r
+ {J2K_MS_SOT, J2K_STATE_MH | J2K_STATE_TPHSOT, j2k_read_sot},\r
+ {J2K_MS_SOD, J2K_STATE_TPH, j2k_read_sod},\r
+ {J2K_MS_EOC, J2K_STATE_TPHSOT, j2k_read_eoc},\r
+ {J2K_MS_SIZ, J2K_STATE_MHSIZ, j2k_read_siz},\r
+ {J2K_MS_COD, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_cod},\r
+ {J2K_MS_COC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_coc},\r
+ {J2K_MS_RGN, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_rgn},\r
+ {J2K_MS_QCD, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_qcd},\r
+ {J2K_MS_QCC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_qcc},\r
+ {J2K_MS_POC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_poc},\r
+ {J2K_MS_TLM, J2K_STATE_MH, j2k_read_tlm},\r
+ {J2K_MS_PLM, J2K_STATE_MH, j2k_read_plm},\r
+ {J2K_MS_PLT, J2K_STATE_TPH, j2k_read_plt},\r
+ {J2K_MS_PPM, J2K_STATE_MH, j2k_read_ppm},\r
+ {J2K_MS_PPT, J2K_STATE_TPH, j2k_read_ppt},\r
+ {J2K_MS_SOP, 0, 0},\r
+ {J2K_MS_CRG, J2K_STATE_MH, j2k_read_crg},\r
+ {J2K_MS_COM, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_com},\r
+ {0, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_unk}\r
+};\r
+\r
+j2k_dec_mstabent_t *j2k_dec_mstab_lookup(int id)\r
+{\r
+ j2k_dec_mstabent_t *e;\r
+ for (e = j2k_dec_mstab; e->id != 0; e++) {\r
+ if (e->id == id) {\r
+ break;\r
+ }\r
+ }\r
+ return e;\r
+}\r
+\r
+\r
+\r
+LIBJ2K_API int\r
+j2k_decode(unsigned char *src, int len, j2k_image_t * img, j2k_cp_t * cp)\r
+{\r
+ \r
+ if (setjmp(j2k_error)) {\r
+ if (j2k_state != J2K_STATE_MT) {\r
+ fprintf(stderr, "WARNING: incomplete bitstream\n");\r
+ return 0;\r
+ }\r
+ j2k_clean();\r
+ return cio_numbytes(); /* Correct way of ending j2k_decode */\r
+ }\r
+ \r
+ j2k_img = img;\r
+ \r
+ j2k_cp = cp;\r
+ \r
+ j2k_state = J2K_STATE_MHSOC;\r
+ cio_init(src, len);\r
+ \r
+ for (;;) {\r
+ \r
+ \r
+ j2k_dec_mstabent_t *e;\r
+ int id = cio_read(2);\r
+ if (id >> 8 != 0xff) {\r
+ fprintf(stderr, "%.8x: expected a marker instead of %x\n",\r
+ cio_tell() - 2, id);\r
+ return 0;\r
+ }\r
+ e = j2k_dec_mstab_lookup(id);\r
+ if (!(j2k_state & e->states)) {\r
+ fprintf(stderr, "%.8x: unexpected marker %x\n", cio_tell() - 2, id);\r
+ return 0;\r
+ }\r
+ if (e->handler) {\r
+ (*e->handler) ();\r
+ }\r
+ \r
+ \r
+ if (j2k_state == J2K_STATE_NEOC)\r
+ break; /* RAJOUTE */\r
+ }\r
+ if (j2k_state == J2K_STATE_NEOC)\r
+ j2k_read_eoc(); /* RAJOUTE */\r
+ \r
+ return 0;\r
+}\r
+\r
+/*\r
+* Read a JPT-stream and decode file\r
+*\r
+*/\r
+int\r
+j2k_decode_jpt_stream(unsigned char *src, int len, j2k_image_t * img,\r
+ j2k_cp_t * cp)\r
+{\r
+ jpt_msg_header_struct_t header;\r
+ int position;\r
+ \r
+ if (setjmp(j2k_error)) {\r
+ if (j2k_state != J2K_STATE_MT) {\r
+ fprintf(stderr, "WARNING: incomplete bitstream\n");\r
+ return 0;\r
+ }\r
+ return cio_numbytes();\r
+ }\r
+ \r
+ j2k_img = img;\r
+ \r
+ j2k_cp = cp;\r
+ \r
+ j2k_state = J2K_STATE_MHSOC;\r
+ cio_init(src, len);\r
+ \r
+ /* Initialize the header */\r
+ jpt_init_Msg_Header(&header);\r
+ /* Read the first header of the message */\r
+ jpt_read_Msg_Header(&header);\r
+ \r
+ position = cio_tell();\r
+ if (header.Class_Id != 6) { /* 6 : Main header data-bin message */\r
+ fprintf(stderr,\r
+ "[JPT-stream] : Expecting Main header first [class_Id %d] !\n",\r
+ header.Class_Id);\r
+ return 0;\r
+ }\r
+ \r
+ for (;;) {\r
+ j2k_dec_mstabent_t *e;\r
+ int id;\r
+ \r
+ if (!cio_numbytesleft()) {\r
+ j2k_read_eoc();\r
+ return 0;\r
+ }\r
+ /* data-bin read -> need to read a new header */\r
+ if ((unsigned int) (cio_tell() - position) == header.Msg_length) {\r
+ jpt_read_Msg_Header(&header);\r
+ position = cio_tell();\r
+ if (header.Class_Id != 4) { /* 4 : Tile data-bin message */\r
+ fprintf(stderr, "[JPT-stream] : Expecting Tile info !\n");\r
+ return 0;\r
+ }\r
+ }\r
+ \r
+ id = cio_read(2);\r
+ if (id >> 8 != 0xff) {\r
+ fprintf(stderr, "%.8x: expected a marker instead of %x\n",\r
+ cio_tell() - 2, id);\r
+ return 0;\r
+ }\r
+ e = j2k_dec_mstab_lookup(id);\r
+ if (!(j2k_state & e->states)) {\r
+ fprintf(stderr, "%.8x: unexpected marker %x\n", cio_tell() - 2, id);\r
+ return 0;\r
+ }\r
+ if (e->handler) {\r
+ (*e->handler) ();\r
+ }\r
+ if (j2k_state == J2K_STATE_NEOC)\r
+ break; /* RAJOUTE */\r
+ }\r
+ if (j2k_state == J2K_STATE_NEOC)\r
+ j2k_read_eoc(); /* RAJOUTE */\r
+ \r
+ return 0;\r
+}\r
+\r
+\r
+\r
+void j2k_dec_release()\r
+\r
+{\r
+ \r
+ int i=0;\r
+ \r
+ \r
+ \r
+ /*tcd_dec_release();*/\r
+ \r
+ \r
+ \r
+ if (j2k_tile_len!=NULL) free(j2k_tile_len);\r
+ \r
+ if (j2k_tile_data!=NULL) free(j2k_tile_data);\r
+ \r
+ if (j2k_default_tcp.ppt_data_first!=NULL) free(j2k_default_tcp.ppt_data_first);\r
+ \r
+ if (j2k_default_tcp.tccps!=NULL) free(j2k_default_tcp.tccps);\r
+ \r
+ for (i=0;i<j2k_cp->tw*j2k_cp->th;i++) {\r
+ \r
+ if (j2k_cp->tcps[i].ppt_data_first!=NULL) free(j2k_cp->tcps[i].ppt_data_first);\r
+ \r
+ if (j2k_cp->tcps[i].tccps!=NULL) free(j2k_cp->tcps[i].tccps);\r
+ \r
+ }\r
+ \r
+ if (j2k_cp->ppm_data_first!=NULL) free(j2k_cp->ppm_data_first);\r
+ \r
+ if (j2k_cp->tcps!=NULL) free(j2k_cp->tcps);\r
+ \r
+ if (j2k_img->comps!=NULL) free(j2k_img->comps);\r
+ \r
+ if (j2k_cp->tileno!=NULL) free(j2k_cp->tileno);\r
+ \r
+}\r
+\r
+#ifdef WIN32\r
+#include <windows.h>\r
+\r
+BOOL APIENTRY\r
+DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)\r
+{\r
+ switch (ul_reason_for_call) {\r
+ case DLL_PROCESS_ATTACH:\r
+ case DLL_THREAD_ATTACH:\r
+ case DLL_THREAD_DETACH:\r
+ case DLL_PROCESS_DETACH:\r
+ break;\r
+ }\r
+ return TRUE;\r
+}\r
+#endif\r
--- /dev/null
+/*\r
+ * Copyright (c) 2001-2002, David Janssens\r
+ * Copyright (c) 2002-2003, Yannick Verschueren\r
+ * Copyright (c) 2002-2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium\r
+ * All rights reserved. \r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+#define VERSION "0.0.8"\r
+\r
+#if defined(_WIN32) && defined (OPENJPEGDLL)\r
+#ifdef gdcmopenjpeg_EXPORTS /*LIBJ2K_EXPORTS*/\r
+#define LIBJ2K_API __declspec(dllexport)\r
+#else\r
+#define LIBJ2K_API __declspec(dllimport)\r
+#endif\r
+#else\r
+#ifdef OPENJPEGSTATIC\r
+#define LIBJ2K_API extern\r
+#else\r
+#define LIBJ2K_API\r
+#endif\r
+#endif\r
+\r
+\r
+#ifndef __J2K_H\r
+#define __J2K_H\r
+\r
+#define J2K_MAXRLVLS 33 /* Number of maximum resolution level authorized */\r
+#define J2K_MAXBANDS (3*J2K_MAXRLVLS-2) /* Number of maximum sub-band linked to number of resolution level */\r
+#define J2K_CFMT 0\r
+#define JP2_CFMT 1\r
+#define JPT_CFMT 2\r
+#define MJ2_CFMT 3\r
+#define PXM_DFMT 0\r
+#define PGX_DFMT 1\r
+#define BMP_DFMT 2\r
+#define YUV_DFMT 3\r
+\r
+#define J2K_CP_CSTY_PRT 0x01\r
+#define J2K_CP_CSTY_SOP 0x02\r
+#define J2K_CP_CSTY_EPH 0x04\r
+#define J2K_CCP_CSTY_PRT 0x01\r
+#define J2K_CCP_CBLKSTY_LAZY 0x01\r
+#define J2K_CCP_CBLKSTY_RESET 0x02\r
+#define J2K_CCP_CBLKSTY_TERMALL 0x04\r
+#define J2K_CCP_CBLKSTY_VSC 0x08\r
+#define J2K_CCP_CBLKSTY_PTERM 0x10\r
+#define J2K_CCP_CBLKSTY_SEGSYM 0x20\r
+#define J2K_CCP_QNTSTY_NOQNT 0\r
+#define J2K_CCP_QNTSTY_SIQNT 1\r
+#define J2K_CCP_QNTSTY_SEQNT 2\r
+\r
+typedef struct {\r
+ int dx, dy; /* XRsiz, YRsiz */\r
+ int w, h; /* width and height of data */\r
+ int x0, y0; /* offset of the component compare to the whole image */\r
+ int prec; /* precision */\r
+ int bpp; /* deapth of image in bits */\r
+ int sgnd; /* signed */\r
+ int resno_decoded; /* number of decoded resolution */\r
+ int factor; /* number of division by 2 of the out image compare to the original size of image */\r
+ int *data; /* image-component data */\r
+} j2k_comp_t;\r
+\r
+typedef struct {\r
+ int x0, y0; /* XOsiz, YOsiz */\r
+ int x1, y1; /* Xsiz, Ysiz */\r
+ int numcomps; /* number of components */\r
+ int color_space; /* sRGB, Greyscale or YUV */\r
+ j2k_comp_t *comps; /* image-components */\r
+} j2k_image_t;\r
+\r
+typedef struct {\r
+ int expn; /* exponent */\r
+ int mant; /* mantissa */\r
+} j2k_stepsize_t;\r
+\r
+typedef struct {\r
+ int csty; /* coding style */\r
+ int numresolutions; /* number of resolutions */\r
+ int cblkw; /* width of code-blocks */\r
+ int cblkh; /* height of code-blocks */\r
+ int cblksty; /* code-block coding style */\r
+ int qmfbid; /* discrete wavelet transform identifier */\r
+ int qntsty; /* quantisation style */\r
+ j2k_stepsize_t stepsizes[J2K_MAXBANDS]; /* stepsizes used for quantization */\r
+ int numgbits; /* number of guard bits */\r
+ int roishift; /* Region Of Interest shift */\r
+ int prcw[J2K_MAXRLVLS]; /* Precinct width */\r
+ int prch[J2K_MAXRLVLS]; /* Precinct height */\r
+} j2k_tccp_t;\r
+\r
+typedef struct {\r
+ int resno0, compno0;\r
+ int layno1, resno1, compno1;\r
+ int prg;\r
+ int tile;\r
+ char progorder[4];\r
+} j2k_poc_t;\r
+\r
+typedef struct {\r
+ int first; /* 1 : first part-tile of a tile */\r
+ int csty; /* coding style */\r
+ int prg; /* progression order */\r
+ int numlayers; /* number of layers */\r
+ int mct; /* multi-component transform identifier */\r
+ int rates[100]; /* rates of layers */\r
+ int numpocs; /* number of progression order changes */\r
+ int POC; /* Precise if a POC marker has been used O:NO, 1:YES */\r
+ j2k_poc_t pocs[32]; /* progression order changes */\r
+ unsigned char *ppt_data; /* packet header store there for futur use in t2_decode_packet */\r
+ unsigned char *ppt_data_first; /* pointer remaining on the first byte of the first header if ppt is used */\r
+ int ppt; /* If ppt == 1 --> there was a PPT marker for the present tile */\r
+ int ppt_store; /* Use in case of multiple marker PPT (number of info already store) */\r
+ int ppt_len; /* ppmbug1 */\r
+ float distoratio[100]; /* add fixed_quality */\r
+ j2k_tccp_t *tccps; /* tile-component coding parameters */\r
+} j2k_tcp_t;\r
+\r
+typedef struct {\r
+ int intermed_file; /* 1: Store each encoded tile one by one in the output file (for mega-Images)*/\r
+ int decod_format; /* 0: PGX, 1: PxM, 2: BMP */\r
+ int cod_format; /* 0: J2K, 1: JP2, 2: JPT */\r
+ int disto_alloc; /* Allocation by rate/distortion */\r
+ int fixed_alloc; /* Allocation by fixed layer */\r
+ int fixed_quality; /* add fixed_quality */\r
+ int reduce; /* if != 0, then original dimension divided by 2^(reduce); if == 0 or not used, image is decoded to the full resolution */\r
+ int layer; /* if != 0, then only the first "layer" layers are decoded; if == 0 or not used, all the quality layers are decoded */\r
+ int index_on; /* 0 = no index || 1 = index */\r
+ int tx0, ty0; /* XTOsiz, YTOsiz */\r
+ int tdx, tdy; /* XTsiz, YTsiz */\r
+ char *comment; /* comment for coding */\r
+ int tw, th; /* number of tiles in width and heigth */\r
+ int *tileno; /* ID number of the tiles present in the codestream */\r
+ int tileno_size; /* size of the vector tileno */\r
+ unsigned char *ppm_data; /* packet header store there for futur use in t2_decode_packet */\r
+ unsigned char *ppm_data_first; /* pointer remaining on the first byte of the first header if ppm is used */\r
+ int ppm; /* If ppm == 1 --> there was a PPM marker for the present tile */\r
+ int ppm_store; /* Use in case of multiple marker PPM (number of info already store) */\r
+ int ppm_previous; /* Use in case of multiple marker PPM (case on non-finished previous info) */\r
+ int ppm_len; /* ppmbug1 */\r
+ j2k_tcp_t *tcps; /* tile coding parameters */\r
+ int *matrice; /* Fixed layer */\r
+} j2k_cp_t;\r
+\r
+typedef struct {\r
+ int start_pos, end_pos; /* start and end position */\r
+ double disto; /* ADD for Marcela */\r
+} info_packet; /* Index struct */\r
+\r
+typedef struct {\r
+ double *thresh; /* value of thresh for each layer by tile cfr. Marcela */\r
+ int num_tile; /* Number of Tile */\r
+ int start_pos; /* Start position */\r
+ int end_header; /* End position of the header */\r
+ int end_pos; /* End position */\r
+ int pw[33], ph[33]; /* precinct number for each resolution level */\r
+\r
+ int pdx[33], pdy[33]; /* precinct size (in power of 2), in X and Y for each resolution level */\r
+ info_packet *packet; /* information concerning packets inside tile */\r
+ int nbpix; /* add fixed_quality */\r
+ double distotile; /* add fixed_quality */\r
+} info_tile; /* index struct */\r
+\r
+typedef struct {\r
+ int index_on;\r
+ double D_max; /* ADD for Marcela */\r
+ int num; /* numero of packet */\r
+ int index_write; /* writing the packet inthe index with t2_encode_packets */\r
+ int Im_w, Im_h; /* Image width and Height */\r
+ int Prog; /* progression order */\r
+ int Tile_x, Tile_y; /* Tile size in x and y */\r
+ int Tile_Ox, Tile_Oy;\r
+ int tw, th; /* Number of Tile in X and Y */\r
+ int Comp; /* Component numbers */\r
+ int Layer; /* number of layer */\r
+ int Decomposition; /* number of decomposition */\r
+ int Main_head_end; /* Main header position */\r
+ int codestream_size; /* codestream's size */\r
+ info_tile *tile; /* information concerning tiles inside image */\r
+} info_image; /* index struct */\r
+\r
+/* \r
+ * Encode an image into a JPEG-2000 codestream\r
+ * i: image to encode\r
+ * cp: coding parameters\r
+ * output: destination buffer or name of the output file when cp->intermed_file==1\r
+ * len: length of destination buffer\r
+ * index : index file name\r
+ */\r
+LIBJ2K_API int j2k_encode(j2k_image_t * i, j2k_cp_t * cp, char *output,\r
+ int len, char *index);\r
+\r
+/* LIBJ2K_API int j2k_encode(j2k_image_t *i, j2k_cp_t *cp,unsigned char *dest, int len); */\r
+/*\r
+ * Decode an image from a JPEG-2000 codestream\r
+ * src: source buffer\r
+ * len: length of source buffer\r
+ * i: decode image\r
+ * cp: coding parameters that were used to encode the image\r
+ */\r
+\r
+LIBJ2K_API int j2k_decode(unsigned char *src, int len, j2k_image_t * img,\r
+ j2k_cp_t * cp);\r
+\r
+\r
+/*\r
+ * Decode an image form a JPT-stream (JPEG 2000, JPIP)\r
+ * src: source buffer\r
+ * len: length of source buffer\r
+ * i: decode image\r
+ * cp: coding parameters that were used to encode the image\r
+ *\r
+ */\r
+int j2k_decode_jpt_stream(unsigned char *src, int len, j2k_image_t * img,\r
+ j2k_cp_t * cp);\r
+\r
+LIBJ2K_API void j2k_dec_release();/*antonin*/\r
+\r
+#endif\r
--- /dev/null
+/*\r
+* Copyright (c) 2003-2004, Yannick Verschueren\r
+* Copyright (c) 2003-2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium\r
+* All rights reserved.\r
+*\r
+* Redistribution and use in source and binary forms, with or without\r
+* modification, are permitted provided that the following conditions\r
+* are met:\r
+* 1. Redistributions of source code must retain the above copyright\r
+* notice, this list of conditions and the following disclaimer.\r
+* 2. Redistributions in binary form must reproduce the above copyright\r
+* notice, this list of conditions and the following disclaimer in the\r
+* documentation and/or other materials provided with the distribution.\r
+*\r
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+* POSSIBILITY OF SUCH DAMAGE.\r
+*/\r
+\r
+#include <stdio.h>\r
+#include <stdlib.h>\r
+#include <string.h>\r
+\r
+#include "j2k.h"\r
+#include "jp2.h"\r
+#include "cio.h"\r
+\r
+#define JPIP_JPIP 0x6a706970\r
+\r
+#define JP2_JP 0x6a502020\r
+#define JP2_FTYP 0x66747970\r
+#define JP2_JP2H 0x6a703268\r
+#define JP2_IHDR 0x69686472\r
+#define JP2_COLR 0x636f6c72\r
+#define JP2_JP2C 0x6a703263\r
+#define JP2_URL 0x75726c20\r
+#define JP2_DBTL 0x6474626c\r
+#define JP2_BPCC 0x62706363\r
+#define JP2_JP2 0x6a703220\r
+\r
+/*\r
+* \r
+* Read box headers\r
+*\r
+*/\r
+\r
+int jp2_read_boxhdr(jp2_box_t * box)\r
+{\r
+ box->init_pos = cio_tell();\r
+ box->length = cio_read(4);\r
+ box->type = cio_read(4);\r
+ if (box->length == 1) {\r
+ if (cio_read(4) != 0) {\r
+ fprintf(stderr, "Error: Cannot handle box sizes higher than 2^32\n");\r
+ return 1;\r
+ }\r
+ box->length = cio_read(4);\r
+ if (box->length == 0)\r
+ box->length = cio_numbytesleft() + 12;\r
+ } else if (box->length == 0) {\r
+ box->length = cio_numbytesleft() + 8;\r
+ }\r
+ return 0;\r
+}\r
+\r
+/*\r
+* \r
+* Initialisation of a Standard JP2 structure\r
+*/\r
+\r
+int jp2_init_stdjp2(jp2_struct_t * jp2_struct)\r
+{\r
+\r
+ jp2_struct->comps =\r
+ (jp2_comps_t *) malloc(jp2_struct->numcomps * sizeof(jp2_comps_t));\r
+\r
+ jp2_struct->precedence = 0; /* PRECEDENCE*/\r
+ jp2_struct->approx = 0; /* APPROX*/\r
+\r
+ jp2_struct->brand = JP2_JP2; /* BR */\r
+ jp2_struct->minversion = 0; /* MinV */\r
+ jp2_struct->numcl = 1;\r
+ jp2_struct->cl = (unsigned int *) malloc(jp2_struct->numcl * sizeof(int));\r
+ jp2_struct->cl[0] = JP2_JP2; /* CL0 : JP2 */\r
+\r
+ jp2_struct->C = 7; /* C : Always 7*/\r
+ jp2_struct->UnkC = 0; /* UnkC, colorspace specified in colr box*/\r
+ jp2_struct->IPR = 0; /* IPR, no intellectual property*/\r
+\r
+ return 0;\r
+}\r
+\r
+\r
+void jp2_write_url(char *Idx_file)\r
+{\r
+ unsigned int i;\r
+ char str[256];\r
+ jp2_box_t box;\r
+\r
+ sprintf(str, "%s", Idx_file);\r
+\r
+\r
+ box.init_pos = cio_tell();\r
+ cio_skip(4);\r
+ cio_write(JP2_URL, 4); /* DBTL*/\r
+ cio_write(0, 1); /* VERS*/\r
+ cio_write(0, 3); /* FLAG*/\r
+\r
+ for (i = 0; i < strlen(str); i++) {\r
+ cio_write(str[i], 1);\r
+ }\r
+\r
+ box.length = cio_tell() - box.init_pos;\r
+ cio_seek(box.init_pos);\r
+ cio_write(box.length, 4); /* L */\r
+ cio_seek(box.init_pos + box.length);\r
+}\r
+\r
+/*\r
+* Read the IHDR box\r
+*\r
+* Image Header box\r
+*\r
+*/\r
+int jp2_read_ihdr(jp2_struct_t * jp2_struct)\r
+{\r
+ jp2_box_t box;\r
+\r
+ jp2_read_boxhdr(&box);\r
+ if (JP2_IHDR != box.type) {\r
+ fprintf(stderr, "Error: Expected IHDR Marker\n");\r
+ return 1;\r
+ }\r
+\r
+ jp2_struct->h = cio_read(4); /* HEIGHT*/\r
+ jp2_struct->w = cio_read(4); /* WIDTH*/\r
+ jp2_struct->numcomps = cio_read(2); /* NC*/\r
+\r
+ jp2_struct->bpc = cio_read(1); /* BPC*/\r
+\r
+ jp2_struct->C = cio_read(1); /* C */\r
+ jp2_struct->UnkC = cio_read(1); /* UnkC*/\r
+ jp2_struct->IPR = cio_read(1); /* IPR*/\r
+\r
+ if (cio_tell() - box.init_pos != box.length) {\r
+ fprintf(stderr, "Error with IHDR Box\n");\r
+ return 1;\r
+ }\r
+ return 0;\r
+}\r
+\r
+void jp2_write_ihdr(jp2_struct_t * jp2_struct)\r
+{\r
+ jp2_box_t box;\r
+\r
+ box.init_pos = cio_tell();\r
+ cio_skip(4);\r
+ cio_write(JP2_IHDR, 4); /* IHDR*/\r
+\r
+ cio_write(jp2_struct->h, 4); /* HEIGHT*/\r
+ cio_write(jp2_struct->w, 4); /* WIDTH*/\r
+ cio_write(jp2_struct->numcomps, 2); /* NC*/\r
+\r
+ cio_write(jp2_struct->bpc, 1); /* BPC */\r
+\r
+ cio_write(jp2_struct->C, 1); /* C : Always 7*/\r
+ cio_write(jp2_struct->UnkC, 1); /* UnkC, colorspace unknow*/\r
+ cio_write(jp2_struct->IPR, 1); /* IPR, no intellectual property*/\r
+\r
+ box.length = cio_tell() - box.init_pos;\r
+ cio_seek(box.init_pos);\r
+ cio_write(box.length, 4); /* L */\r
+ cio_seek(box.init_pos + box.length);\r
+}\r
+\r
+\r
+void jp2_write_bpcc(jp2_struct_t * jp2_struct)\r
+{\r
+ unsigned int i;\r
+ jp2_box_t box;\r
+\r
+ box.init_pos = cio_tell();\r
+ cio_skip(4);\r
+ cio_write(JP2_BPCC, 4); /* BPCC*/\r
+\r
+ for (i = 0; i < jp2_struct->numcomps; i++)\r
+ cio_write(jp2_struct->comps[i].bpcc, 1);\r
+\r
+ box.length = cio_tell() - box.init_pos;\r
+ cio_seek(box.init_pos);\r
+ cio_write(box.length, 4); /* L */\r
+ cio_seek(box.init_pos + box.length);\r
+}\r
+\r
+\r
+int jp2_read_bpcc(jp2_struct_t * jp2_struct)\r
+{\r
+ unsigned int i;\r
+ jp2_box_t box;\r
+\r
+ jp2_read_boxhdr(&box);\r
+ if (JP2_BPCC != box.type) {\r
+ fprintf(stderr, "Error: Expected BPCC Marker\n");\r
+ return 1;\r
+ }\r
+\r
+ for (i = 0; i < jp2_struct->numcomps; i++)\r
+ jp2_struct->comps[i].bpcc = cio_read(1);\r
+\r
+ if (cio_tell() - box.init_pos != box.length) {\r
+ fprintf(stderr, "Error with BPCC Box\n");\r
+ return 1;\r
+ }\r
+ return 0;\r
+}\r
+\r
+void jp2_write_colr(jp2_struct_t * jp2_struct)\r
+{\r
+ jp2_box_t box;\r
+\r
+ box.init_pos = cio_tell();\r
+ cio_skip(4);\r
+ cio_write(JP2_COLR, 4); /* COLR*/\r
+\r
+ cio_write(jp2_struct->meth, 1); /* METH*/\r
+ cio_write(jp2_struct->precedence, 1); /* PRECEDENCE*/\r
+ cio_write(jp2_struct->approx, 1); /* APPROX*/\r
+\r
+ if (jp2_struct->meth == 1)\r
+ cio_write(jp2_struct->enumcs, 4); /* EnumCS*/\r
+ else\r
+ cio_write(0, 1); /* PROFILE (??)*/\r
+\r
+ box.length = cio_tell() - box.init_pos;\r
+ cio_seek(box.init_pos);\r
+ cio_write(box.length, 4); /* L */\r
+ cio_seek(box.init_pos + box.length);\r
+}\r
+\r
+int jp2_read_colr(jp2_struct_t * jp2_struct)\r
+{\r
+ jp2_box_t box;\r
+ int skip_len;\r
+\r
+ jp2_read_boxhdr(&box);\r
+ do {\r
+ if (JP2_COLR != box.type) {\r
+ cio_skip(box.length - 8);\r
+ jp2_read_boxhdr(&box);\r
+ }\r
+ } while (JP2_COLR != box.type);\r
+\r
+ jp2_struct->meth = cio_read(1); /* METH*/\r
+ jp2_struct->precedence = cio_read(1); /* PRECEDENCE*/\r
+ jp2_struct->approx = cio_read(1); /* APPROX*/\r
+\r
+ if (jp2_struct->meth == 1)\r
+ jp2_struct->enumcs = cio_read(4); /* EnumCS*/\r
+ else {\r
+ /* SKIP PROFILE */\r
+ skip_len = box.init_pos + box.length - cio_tell();\r
+ if (skip_len < 0) {\r
+ fprintf(stderr, "Error with JP2H box size\n");\r
+ return 1;\r
+ }\r
+ cio_skip(box.init_pos + box.length - cio_tell());\r
+ }\r
+\r
+ if (cio_tell() - box.init_pos != box.length) {\r
+ fprintf(stderr, "Error with BPCC Box\n");\r
+ return 1;\r
+ }\r
+ return 0;\r
+}\r
+\r
+/*\r
+* Write the JP2H box\r
+*\r
+* JP2 Header box\r
+*\r
+*/\r
+void jp2_write_jp2h(jp2_struct_t * jp2_struct)\r
+{\r
+ jp2_box_t box;\r
+\r
+ box.init_pos = cio_tell();\r
+ cio_skip(4);;\r
+ cio_write(JP2_JP2H, 4); /* JP2H */\r
+\r
+ jp2_write_ihdr(jp2_struct);\r
+\r
+ if (jp2_struct->bpc == 255)\r
+ jp2_write_bpcc(jp2_struct);\r
+ jp2_write_colr(jp2_struct);\r
+\r
+ box.length = cio_tell() - box.init_pos;\r
+ cio_seek(box.init_pos);\r
+ cio_write(box.length, 4); /* L */\r
+ cio_seek(box.init_pos + box.length);\r
+}\r
+\r
+\r
+/*\r
+* Read the JP2H box\r
+*\r
+* JP2 Header box\r
+*\r
+*/\r
+int jp2_read_jp2h(jp2_struct_t * jp2_struct)\r
+{\r
+ jp2_box_t box;\r
+ int skip_len;\r
+\r
+ jp2_read_boxhdr(&box);\r
+ do {\r
+ if (JP2_JP2H != box.type) {\r
+ if (box.type == JP2_JP2C) {\r
+ fprintf(stderr, "Error: Expected JP2H Marker\n");\r
+ return 1;\r
+ }\r
+ cio_skip(box.length - 8);\r
+ jp2_read_boxhdr(&box);\r
+ }\r
+ } while (JP2_JP2H != box.type);\r
+\r
+ if (jp2_read_ihdr(jp2_struct))\r
+ return 1;\r
+\r
+ if (jp2_struct->bpc == 255) {\r
+ if (jp2_read_bpcc(jp2_struct))\r
+ return 1;\r
+ }\r
+\r
+ if (jp2_read_colr(jp2_struct))\r
+ return 1;\r
+\r
+ skip_len = box.init_pos + box.length - cio_tell();\r
+ if (skip_len < 0) {\r
+ fprintf(stderr, "Error with JP2H box size\n");\r
+ return 1;\r
+ }\r
+ cio_skip(box.init_pos + box.length - cio_tell());\r
+\r
+ return 0;\r
+}\r
+\r
+/*\r
+* Write the FTYP box\r
+*\r
+* File type box\r
+*\r
+*/\r
+void jp2_write_ftyp(jp2_struct_t * jp2_struct)\r
+{\r
+ unsigned int i;\r
+ jp2_box_t box;\r
+\r
+ box.init_pos = cio_tell();\r
+ cio_skip(4);\r
+ cio_write(JP2_FTYP, 4); /* FTYP */\r
+\r
+ cio_write(jp2_struct->brand, 4); /* BR */\r
+ cio_write(jp2_struct->minversion, 4); /* MinV */\r
+\r
+ for (i = 0; i < jp2_struct->numcl; i++)\r
+ cio_write(jp2_struct->cl[i], 4); /* CL */\r
+\r
+ box.length = cio_tell() - box.init_pos;\r
+ cio_seek(box.init_pos);\r
+ cio_write(box.length, 4); /* L */\r
+ cio_seek(box.init_pos + box.length);\r
+}\r
+\r
+/*\r
+* Read the FTYP box\r
+*\r
+* File type box\r
+*\r
+*/\r
+int jp2_read_ftyp(jp2_struct_t * jp2_struct)\r
+{\r
+ int i;\r
+ jp2_box_t box;\r
+\r
+ jp2_read_boxhdr(&box);\r
+\r
+ if (JP2_FTYP != box.type) {\r
+ fprintf(stderr, "Error: Excpected FTYP Marker\n");\r
+ return 1;\r
+ }\r
+\r
+ jp2_struct->brand = cio_read(4); /* BR */\r
+ jp2_struct->minversion = cio_read(4); /* MinV */\r
+ jp2_struct->numcl = (box.length - 16) / 4;\r
+ jp2_struct->cl =\r
+ (unsigned int *) malloc(jp2_struct->numcl * sizeof(unsigned int));\r
+\r
+ for (i = 0; i < (int) jp2_struct->numcl; i++)\r
+ jp2_struct->cl[i] = cio_read(4); /* CLi */\r
+\r
+ if (cio_tell() - box.init_pos != box.length) {\r
+ fprintf(stderr, "Error with FTYP Box\n");\r
+ return 1;\r
+ }\r
+ return 0;\r
+}\r
+\r
+int jp2_write_jp2c(int j2k_codestream_len, int *j2k_codestream_offset,\r
+ char *j2k_codestream)\r
+{\r
+ jp2_box_t box;\r
+\r
+ box.init_pos = cio_tell();\r
+ cio_skip(4);\r
+ cio_write(JP2_JP2C, 4); /* JP2C*/\r
+\r
+ *j2k_codestream_offset = cio_tell();\r
+ memcpy(cio_getbp(), j2k_codestream, j2k_codestream_len);\r
+\r
+ box.length = 8 + j2k_codestream_len;\r
+ cio_seek(box.init_pos);\r
+ cio_write(box.length, 4); /* L */\r
+ cio_seek(box.init_pos + box.length);\r
+\r
+ return box.length;\r
+}\r
+\r
+\r
+int jp2_read_jp2c(unsigned int *j2k_codestream_len,\r
+ unsigned int *j2k_codestream_offset)\r
+{\r
+ jp2_box_t box;\r
+\r
+ jp2_read_boxhdr(&box);\r
+ do {\r
+ if (JP2_JP2C != box.type) {\r
+ cio_skip(box.length - 8);\r
+ jp2_read_boxhdr(&box);\r
+ }\r
+ } while (JP2_JP2C != box.type);\r
+\r
+ *j2k_codestream_offset = cio_tell();\r
+ *j2k_codestream_len = box.length - 8;\r
+\r
+ return 0;\r
+}\r
+\r
+void jp2_write_jp()\r
+{\r
+ jp2_box_t box;\r
+\r
+ box.init_pos = cio_tell();\r
+ cio_skip(4);\r
+ cio_write(JP2_JP, 4); /* JP*/\r
+ cio_write(0x0d0a870a, 4);\r
+\r
+ box.length = cio_tell() - box.init_pos;\r
+ cio_seek(box.init_pos);\r
+ cio_write(box.length, 4); /* L */\r
+ cio_seek(box.init_pos + box.length);\r
+}\r
+\r
+/*\r
+* Read the JP box\r
+*\r
+* JPEG 2000 signature\r
+*\r
+* return 1 if error else 0\r
+*/\r
+int jp2_read_jp()\r
+{\r
+ jp2_box_t box;\r
+\r
+ jp2_read_boxhdr(&box);\r
+ if (JP2_JP != box.type) {\r
+ fprintf(stderr, "Error: Expected JP Marker\n");\r
+ return 1;\r
+ }\r
+ if (0x0d0a870a != cio_read(4)) {\r
+ fprintf(stderr, "Error with JP Marker\n");\r
+ return 1;\r
+ }\r
+ if (cio_tell() - box.init_pos != box.length) {\r
+ fprintf(stderr, "Error with JP Box size\n");\r
+ return 1;\r
+ }\r
+ return 0;\r
+\r
+}\r
+\r
+\r
+int jp2_read_struct(unsigned char *src, jp2_struct_t * jp2_struct, int len)\r
+{\r
+ cio_init(src, len);\r
+\r
+ if (jp2_read_jp())\r
+ return 1;\r
+ if (jp2_read_ftyp(jp2_struct))\r
+ return 1;\r
+ if (jp2_read_jp2h(jp2_struct))\r
+ return 1;\r
+ if (jp2_read_jp2c\r
+ (&jp2_struct->j2k_codestream_len,\r
+ &jp2_struct->j2k_codestream_offset))\r
+ return 1;\r
+ return 0;\r
+}\r
+\r
+int jp2_wrap_j2k(jp2_struct_t * jp2_struct, char *j2k_codestream,\r
+ char *output)\r
+{\r
+ (void)output;\r
+ jp2_write_jp();\r
+ jp2_write_ftyp(jp2_struct);\r
+ jp2_write_jp2h(jp2_struct);\r
+\r
+ jp2_write_jp2c(jp2_struct->j2k_codestream_len,\r
+ &jp2_struct->j2k_codestream_offset, j2k_codestream);\r
+\r
+ return cio_tell();\r
+}\r
--- /dev/null
+/*\r
+ * Copyright (c) 2003, Yannick Verschueren\r
+ * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+#ifndef __JP2_H\r
+#define __JP2_H\r
+\r
+#include "j2k.h"\r
+\r
+typedef struct {\r
+ int depth; \r
+ int sgnd; \r
+ int bpcc;\r
+} jp2_comps_t;\r
+\r
+typedef struct {\r
+ unsigned int w;\r
+ unsigned int h;\r
+ unsigned int numcomps;\r
+ unsigned int bpc;\r
+ unsigned int C;\r
+ unsigned int UnkC;\r
+ unsigned int IPR;\r
+ unsigned int meth;\r
+ unsigned int approx;\r
+ unsigned int enumcs;\r
+ unsigned int precedence;\r
+ unsigned int brand;\r
+ unsigned int minversion;\r
+ unsigned int numcl;\r
+ unsigned int *cl;\r
+ jp2_comps_t *comps;\r
+ j2k_image_t *image;\r
+ unsigned int j2k_codestream_offset;\r
+ unsigned int j2k_codestream_len;\r
+} jp2_struct_t;\r
+\r
+typedef struct {\r
+ int length;\r
+ int type;\r
+ int init_pos;\r
+} jp2_box_t;\r
+\r
+/* int jp2_init_stdjp2(jp2_struct_t * jp2_struct, j2k_image_t * img); \r
+ *\r
+ * Create a standard jp2_structure\r
+ * jp2_struct: the structure you are creating\r
+ * img: a j2k_image_t wich will help you to create the jp2_structure\r
+ */\r
+int jp2_init_stdjp2(jp2_struct_t * jp2_struct);\r
+\r
+/* int jp2_write_jp2c(int j2k_len, int *j2k_codestream_offset, char *j2k_codestream)\r
+ *\r
+ * Write the jp2c codestream box \r
+ * j2k_len: the j2k codestream length\r
+ * j2k_codestream_offset: the function will return the j2k codestream offset\r
+ * j2k_codestream: the j2k codestream to include in jp2 file\r
+ */\r
+int jp2_write_jp2c(int j2k_len, int *j2k_codestream_offset, char *j2k_codestream);\r
+\r
+/* int jp2_write_jp2h(jp2_struct_t * jp2_struct);\r
+ *\r
+ * Write the jp2h header box \r
+ * jp2_struct: the jp2 structure you are working with\r
+ */\r
+void jp2_write_jp2h(jp2_struct_t * jp2_struct);\r
+\r
+/* int jp2_read_jp2h(jp2_struct_t * jp2_struct);\r
+ *\r
+ * Read the jp2h header box \r
+ * jp2_struct: the jp2 structure you are working with\r
+ */\r
+int jp2_read_jp2h(jp2_struct_t * jp2_struct);\r
+\r
+/* int jp2_wrap_j2k(jp2_struct_t * jp2_struct, char *j2k_codestream, \r
+ int j2k_len, char *output)\r
+ *\r
+ * Wrap a J2K codestream in a JP2 file\r
+ * jp2_struct: the jp2 structure used to create jp2 boxes\r
+ * j2k_codestream: the j2k codestream to include in jp2 file\r
+ * output: pointer to jp2 codestream that will be created\r
+ */\r
+int jp2_wrap_j2k(jp2_struct_t * jp2_struct, char *j2k_codestream, \r
+ char *output);\r
+\r
+\r
+/* int jp2_read_struct(unsigned char *src, jp2_struct_t * jp2_struct);\r
+ *\r
+ * Decode the structure of a JP2 file\r
+ * src: pointer to memory where compressed data is stored\r
+ * jp2_struct: the jp2 structure that will be created \r
+ * len: length of jp2 codestream\r
+ */\r
+int jp2_read_struct(unsigned char *src, jp2_struct_t * jp2_struct, int len);\r
+\r
+#endif\r
--- /dev/null
+/*\r
+ * Copyright (c) 2004, Yannick Verschueren\r
+ * Copyright (c) 2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+#include <stdio.h>\r
+#include <stdlib.h>\r
+\r
+#include "jpt.h"\r
+#include "j2k.h"\r
+#include "cio.h"\r
+\r
+\r
+/*\r
+ * Read the information contains in VBAS [JPP/JPT stream message header]\r
+ * Store information (7 bits) in value\r
+ *\r
+ */\r
+unsigned int jpt_read_VBAS_info(unsigned int value)\r
+{\r
+ unsigned char elmt;\r
+\r
+ elmt = cio_read(1);\r
+ while ((elmt >> 7) == 1) {\r
+ value = (value << 7);\r
+ value |= (elmt & 0x7f);\r
+ elmt = cio_read(1);\r
+ }\r
+ value = (value << 7);\r
+ value |= (elmt & 0x7f);\r
+\r
+ return value;\r
+}\r
+\r
+/*\r
+ * Initialize the value of the message header structure \r
+ *\r
+ */\r
+void jpt_init_Msg_Header(jpt_msg_header_struct_t * header)\r
+{\r
+ header->Id = 0; /* In-class Identifier */\r
+ header->last_byte = 0; /* Last byte information */\r
+ header->Class_Id = 0; /* Class Identifier */\r
+ header->CSn_Id = 0; /* CSn : index identifier */\r
+ header->Msg_offset = 0; /* Message offset */\r
+ header->Msg_length = 0; /* Message length */\r
+ header->Layer_nb = 0; /* Auxiliary for JPP case */\r
+}\r
+\r
+/*\r
+ * Re-initialize the value of the message header structure\r
+ *\r
+ * Only parameters always present in message header\r
+ *\r
+ */\r
+void jpt_reinit_Msg_Header(jpt_msg_header_struct_t * header)\r
+{\r
+ header->Id = 0; /* In-class Identifier */\r
+ header->last_byte = 0; /* Last byte information */\r
+ header->Msg_offset = 0; /* Message offset */\r
+ header->Msg_length = 0; /* Message length */\r
+}\r
+\r
+/*\r
+ * Read the message header for a JPP/JPT - stream\r
+ *\r
+ */\r
+void jpt_read_Msg_Header(jpt_msg_header_struct_t * header)\r
+{\r
+ unsigned char elmt, Class = 0, CSn = 0;\r
+ jpt_reinit_Msg_Header(header);\r
+\r
+ /* ------------- */\r
+ /* VBAS : Bin-ID */\r
+ /* ------------- */\r
+ elmt = cio_read(1);\r
+\r
+ /* See for Class and CSn */\r
+ switch ((elmt >> 5) & 0x03) {\r
+ case 0:\r
+ fprintf(stderr, "Forbidden value encounter in message header !!\n");\r
+ break;\r
+ case 1:\r
+ Class = 0;\r
+ CSn = 0;\r
+ break;\r
+ case 2:\r
+ Class = 1;\r
+ CSn = 0;\r
+ break;\r
+ case 3:\r
+ Class = 1;\r
+ CSn = 1;\r
+ break;\r
+ default:\r
+ break;\r
+ }\r
+\r
+ /* see information on bits 'c' [p 10 : A.2.1 general, ISO/IEC FCD 15444-9] */\r
+ if (((elmt >> 4) & 0x01) == 1)\r
+ header->last_byte = 1;\r
+\r
+ /* In-class identifier */\r
+ header->Id |= (elmt & 0x0f);\r
+ if ((elmt >> 7) == 1)\r
+ header->Id = jpt_read_VBAS_info(header->Id);\r
+\r
+ /* ------------ */\r
+ /* VBAS : Class */\r
+ /* ------------ */\r
+ if (Class == 1) {\r
+ header->Class_Id = 0;\r
+ header->Class_Id = jpt_read_VBAS_info(header->Class_Id);\r
+ }\r
+\r
+ /* ---------- */\r
+ /* VBAS : CSn */\r
+ /* ---------- */\r
+ if (CSn == 1) {\r
+ header->CSn_Id = 0;\r
+ header->CSn_Id = jpt_read_VBAS_info(header->CSn_Id);\r
+ }\r
+\r
+ /* ----------------- */\r
+ /* VBAS : Msg_offset */\r
+ /* ----------------- */\r
+ header->Msg_offset = jpt_read_VBAS_info(header->Msg_offset);\r
+\r
+ /* ----------------- */\r
+ /* VBAS : Msg_length */\r
+ /* ----------------- */\r
+ header->Msg_length = jpt_read_VBAS_info(header->Msg_length);\r
+\r
+ /* ---------- */\r
+ /* VBAS : Aux */\r
+ /* ---------- */\r
+ if ((header->Class_Id & 0x01) == 1) {\r
+ header->Layer_nb = 0;\r
+ header->Layer_nb = jpt_read_VBAS_info(header->Layer_nb);\r
+ }\r
+}\r
--- /dev/null
+/*\r
+ * Copyright (c) 2004, Yannick Verschueren\r
+ * Copyright (c) 2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+/*\r
+ * Message Header JPT_stream Structure \r
+ *\r
+ */\r
+typedef struct {\r
+ unsigned int Id; /* In-class Identifier */\r
+ unsigned int last_byte; /* Last byte information */\r
+ unsigned int Class_Id; /* Class Identifier */\r
+ unsigned int CSn_Id; /* CSn : index identifier */\r
+ unsigned int Msg_offset; /* Message offset */\r
+ unsigned int Msg_length; /* Message length */\r
+ unsigned int Layer_nb; /* Auxiliary for JPP case */\r
+} jpt_msg_header_struct_t;\r
+\r
+/*\r
+ * Initialize the value of the message header structure \r
+ *\r
+ * header : Message header structure\r
+ *\r
+ */\r
+void jpt_init_Msg_Header(jpt_msg_header_struct_t * header);\r
+\r
+/*\r
+ * Read the message header for a JPP/JPT - stream\r
+ *\r
+ * header : Message header structure\r
+ *\r
+ */\r
+void jpt_read_Msg_Header(jpt_msg_header_struct_t * header);\r
--- /dev/null
+/*\r
+ * Copyright (c) 2001-2002, David Janssens\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+#include "mct.h"\r
+#include "fix.h"\r
+\r
+/* <summary> */\r
+/* This table contains the norms of the basis function of the reversible MCT. */\r
+/* </summary> */\r
+double mct_norms[3] = { 1.732, .8292, .8292 };\r
+\r
+/* <summary> */\r
+/* This table contains the norms of the basis function of the irreversible MCT. */\r
+/* </summary> */\r
+double mct_norms_real[3] = { 1.732, 1.805, 1.573 };\r
+\r
+/* <summary> */\r
+/* Foward reversible MCT. */\r
+/* </summary> */\r
+void mct_encode(int *c0, int *c1, int *c2, int n)\r
+{\r
+ int i;\r
+ for (i = 0; i < n; i++) {\r
+ int r, g, b, y, u, v;\r
+ r = c0[i];\r
+ g = c1[i];\r
+ b = c2[i];\r
+ y = (r + (g << 1) + b) >> 2;\r
+ u = b - g;\r
+ v = r - g;\r
+ c0[i] = y;\r
+ c1[i] = u;\r
+ c2[i] = v;\r
+ }\r
+}\r
+\r
+/* <summary> */\r
+/* Inverse reversible MCT. */\r
+/* </summary> */\r
+void mct_decode(int *c0, int *c1, int *c2, int n)\r
+{\r
+ int i;\r
+ for (i = 0; i < n; i++) {\r
+ int y, u, v, r, g, b;\r
+ y = c0[i];\r
+ u = c1[i];\r
+ v = c2[i];\r
+ g = y - ((u + v) >> 2);\r
+ r = v + g;\r
+ b = u + g;\r
+ c0[i] = r;\r
+ c1[i] = g;\r
+ c2[i] = b;\r
+ }\r
+}\r
+\r
+/* <summary> */\r
+/* Get norm of basis function of reversible MCT. */\r
+/* </summary> */\r
+double mct_getnorm(int compno)\r
+{\r
+ return mct_norms[compno];\r
+}\r
+\r
+/* <summary> */\r
+/* Foward irreversible MCT. */\r
+/* </summary> */\r
+void mct_encode_real(int *c0, int *c1, int *c2, int n)\r
+{\r
+ int i;\r
+ for (i = 0; i < n; i++) {\r
+ int r, g, b, y, u, v;\r
+ r = c0[i];\r
+ g = c1[i];\r
+ b = c2[i];\r
+ y = fix_mul(r, 2449) + fix_mul(g, 4809) + fix_mul(b, 934);\r
+ u = -fix_mul(r, 1382) - fix_mul(g, 2714) + fix_mul(b, 4096);\r
+ v = fix_mul(r, 4096) - fix_mul(g, 3430) - fix_mul(b, 666);\r
+ c0[i] = y;\r
+ c1[i] = u;\r
+ c2[i] = v;\r
+ }\r
+}\r
+\r
+/* <summary> */\r
+/* Inverse irreversible MCT. */\r
+/* </summary> */\r
+void mct_decode_real(int *c0, int *c1, int *c2, int n)\r
+{\r
+ int i;\r
+ for (i = 0; i < n; i++) {\r
+ int y, u, v, r, g, b;\r
+ y = c0[i];\r
+ u = c1[i];\r
+ v = c2[i];\r
+ r = y + fix_mul(v, 11485);\r
+ g = y - fix_mul(u, 2819) - fix_mul(v, 5850);\r
+ b = y + fix_mul(u, 14516);\r
+ c0[i] = r;\r
+ c1[i] = g;\r
+ c2[i] = b;\r
+ }\r
+}\r
+\r
+/* <summary> */\r
+/* Get norm of basis function of irreversible MCT. */\r
+/* </summary> */\r
+double mct_getnorm_real(int compno)\r
+{\r
+ return mct_norms_real[compno];\r
+}\r
--- /dev/null
+/*\r
+ * Copyright (c) 2001-2002, David Janssens\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+#ifndef __MCT_H\r
+#define __MCT_H\r
+\r
+/*\r
+ * Apply a reversible multi-component transform to an image\r
+ * R: samples for red component\r
+ * G: samples for green component\r
+ * B: samples blue component\r
+ * n: number of samples for each component\r
+ */\r
+void mct_encode(int *R, int *G, int *B, int n);\r
+/*\r
+ * Apply a reversible multi-component inverse transform to an image\r
+ * Y: samples for luminance component\r
+ * U: samples for red chrominance component\r
+ * V: samples for blue chrominance component\r
+ * n: number of samples for each component\r
+ */\r
+void mct_decode(int *V, int *U, int *Y, int n);\r
+/*\r
+ * Get norm of the basis function used for the reversible multi-component transform\r
+ * compno: number of the component (0->Y, 1->U, 2->V)\r
+ */\r
+double mct_getnorm(int compno);\r
+\r
+/*\r
+ * Apply an irreversible multi-component transform to an image\r
+ * R: samples for red component\r
+ * G: samples for green component\r
+ * B: samples blue component\r
+ * n: number of samples for each component\r
+ */\r
+void mct_encode_real(int *c0, int *c1, int *c2, int n);\r
+/*\r
+ * Apply an irreversible multi-component inverse transform to an image\r
+ * Y: samples for luminance component\r
+ * U: samples for red chrominance component\r
+ * V: samples for blue chrominance component\r
+ * n: number of samples for each component\r
+ */\r
+void mct_decode_real(int *c0, int *c1, int *c2, int n);\r
+/*\r
+ * Get norm of the basis function used for the irreversible multi-component transform\r
+ * compno: number of the component (0->Y, 1->U, 2->V)\r
+ */\r
+double mct_getnorm_real(int compno);\r
+\r
+#endif\r
--- /dev/null
+/*\r
+ * Copyright (c) 2001-2002, David Janssens\r
+ * Copyright (c) 2002-2003, Yannick Verschueren\r
+ * Copyright (c) 2002-2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+#include "mqc.h"\r
+#include <stdio.h>\r
+\r
+/* <summary> */\r
+/* This struct defines the state of a context. */\r
+/* </summary> */\r
+typedef struct mqc_state_s {\r
+ unsigned int qeval; /* the probability of the Least Probable Symbol (0.75->0x8000, 1.5->0xffff) */\r
+ int mps; /* the Most Probable Symbol (0 or 1) */\r
+ struct mqc_state_s *nmps; /* next state if the next encoded symbol is the MPS */\r
+ struct mqc_state_s *nlps; /* next state if the next encoded symbol is the LPS */\r
+} mqc_state_t;\r
+\r
+/* <summary> */\r
+/* This array defines all the possible states for a context. */\r
+/* </summary> */\r
+mqc_state_t mqc_states[47 * 2] = {\r
+ {0x5601, 0, &mqc_states[2], &mqc_states[3]},\r
+ {0x5601, 1, &mqc_states[3], &mqc_states[2]},\r
+ {0x3401, 0, &mqc_states[4], &mqc_states[12]},\r
+ {0x3401, 1, &mqc_states[5], &mqc_states[13]},\r
+ {0x1801, 0, &mqc_states[6], &mqc_states[18]},\r
+ {0x1801, 1, &mqc_states[7], &mqc_states[19]},\r
+ {0x0ac1, 0, &mqc_states[8], &mqc_states[24]},\r
+ {0x0ac1, 1, &mqc_states[9], &mqc_states[25]},\r
+ {0x0521, 0, &mqc_states[10], &mqc_states[58]},\r
+ {0x0521, 1, &mqc_states[11], &mqc_states[59]},\r
+ {0x0221, 0, &mqc_states[76], &mqc_states[66]},\r
+ {0x0221, 1, &mqc_states[77], &mqc_states[67]},\r
+ {0x5601, 0, &mqc_states[14], &mqc_states[13]},\r
+ {0x5601, 1, &mqc_states[15], &mqc_states[12]},\r
+ {0x5401, 0, &mqc_states[16], &mqc_states[28]},\r
+ {0x5401, 1, &mqc_states[17], &mqc_states[29]},\r
+ {0x4801, 0, &mqc_states[18], &mqc_states[28]},\r
+ {0x4801, 1, &mqc_states[19], &mqc_states[29]},\r
+ {0x3801, 0, &mqc_states[20], &mqc_states[28]},\r
+ {0x3801, 1, &mqc_states[21], &mqc_states[29]},\r
+ {0x3001, 0, &mqc_states[22], &mqc_states[34]},\r
+ {0x3001, 1, &mqc_states[23], &mqc_states[35]},\r
+ {0x2401, 0, &mqc_states[24], &mqc_states[36]},\r
+ {0x2401, 1, &mqc_states[25], &mqc_states[37]},\r
+ {0x1c01, 0, &mqc_states[26], &mqc_states[40]},\r
+ {0x1c01, 1, &mqc_states[27], &mqc_states[41]},\r
+ {0x1601, 0, &mqc_states[58], &mqc_states[42]},\r
+ {0x1601, 1, &mqc_states[59], &mqc_states[43]},\r
+ {0x5601, 0, &mqc_states[30], &mqc_states[29]},\r
+ {0x5601, 1, &mqc_states[31], &mqc_states[28]},\r
+ {0x5401, 0, &mqc_states[32], &mqc_states[28]},\r
+ {0x5401, 1, &mqc_states[33], &mqc_states[29]},\r
+ {0x5101, 0, &mqc_states[34], &mqc_states[30]},\r
+ {0x5101, 1, &mqc_states[35], &mqc_states[31]},\r
+ {0x4801, 0, &mqc_states[36], &mqc_states[32]},\r
+ {0x4801, 1, &mqc_states[37], &mqc_states[33]},\r
+ {0x3801, 0, &mqc_states[38], &mqc_states[34]},\r
+ {0x3801, 1, &mqc_states[39], &mqc_states[35]},\r
+ {0x3401, 0, &mqc_states[40], &mqc_states[36]},\r
+ {0x3401, 1, &mqc_states[41], &mqc_states[37]},\r
+ {0x3001, 0, &mqc_states[42], &mqc_states[38]},\r
+ {0x3001, 1, &mqc_states[43], &mqc_states[39]},\r
+ {0x2801, 0, &mqc_states[44], &mqc_states[38]},\r
+ {0x2801, 1, &mqc_states[45], &mqc_states[39]},\r
+ {0x2401, 0, &mqc_states[46], &mqc_states[40]},\r
+ {0x2401, 1, &mqc_states[47], &mqc_states[41]},\r
+ {0x2201, 0, &mqc_states[48], &mqc_states[42]},\r
+ {0x2201, 1, &mqc_states[49], &mqc_states[43]},\r
+ {0x1c01, 0, &mqc_states[50], &mqc_states[44]},\r
+ {0x1c01, 1, &mqc_states[51], &mqc_states[45]},\r
+ {0x1801, 0, &mqc_states[52], &mqc_states[46]},\r
+ {0x1801, 1, &mqc_states[53], &mqc_states[47]},\r
+ {0x1601, 0, &mqc_states[54], &mqc_states[48]},\r
+ {0x1601, 1, &mqc_states[55], &mqc_states[49]},\r
+ {0x1401, 0, &mqc_states[56], &mqc_states[50]},\r
+ {0x1401, 1, &mqc_states[57], &mqc_states[51]},\r
+ {0x1201, 0, &mqc_states[58], &mqc_states[52]},\r
+ {0x1201, 1, &mqc_states[59], &mqc_states[53]},\r
+ {0x1101, 0, &mqc_states[60], &mqc_states[54]},\r
+ {0x1101, 1, &mqc_states[61], &mqc_states[55]},\r
+ {0x0ac1, 0, &mqc_states[62], &mqc_states[56]},\r
+ {0x0ac1, 1, &mqc_states[63], &mqc_states[57]},\r
+ {0x09c1, 0, &mqc_states[64], &mqc_states[58]},\r
+ {0x09c1, 1, &mqc_states[65], &mqc_states[59]},\r
+ {0x08a1, 0, &mqc_states[66], &mqc_states[60]},\r
+ {0x08a1, 1, &mqc_states[67], &mqc_states[61]},\r
+ {0x0521, 0, &mqc_states[68], &mqc_states[62]},\r
+ {0x0521, 1, &mqc_states[69], &mqc_states[63]},\r
+ {0x0441, 0, &mqc_states[70], &mqc_states[64]},\r
+ {0x0441, 1, &mqc_states[71], &mqc_states[65]},\r
+ {0x02a1, 0, &mqc_states[72], &mqc_states[66]},\r
+ {0x02a1, 1, &mqc_states[73], &mqc_states[67]},\r
+ {0x0221, 0, &mqc_states[74], &mqc_states[68]},\r
+ {0x0221, 1, &mqc_states[75], &mqc_states[69]},\r
+ {0x0141, 0, &mqc_states[76], &mqc_states[70]},\r
+ {0x0141, 1, &mqc_states[77], &mqc_states[71]},\r
+ {0x0111, 0, &mqc_states[78], &mqc_states[72]},\r
+ {0x0111, 1, &mqc_states[79], &mqc_states[73]},\r
+ {0x0085, 0, &mqc_states[80], &mqc_states[74]},\r
+ {0x0085, 1, &mqc_states[81], &mqc_states[75]},\r
+ {0x0049, 0, &mqc_states[82], &mqc_states[76]},\r
+ {0x0049, 1, &mqc_states[83], &mqc_states[77]},\r
+ {0x0025, 0, &mqc_states[84], &mqc_states[78]},\r
+ {0x0025, 1, &mqc_states[85], &mqc_states[79]},\r
+ {0x0015, 0, &mqc_states[86], &mqc_states[80]},\r
+ {0x0015, 1, &mqc_states[87], &mqc_states[81]},\r
+ {0x0009, 0, &mqc_states[88], &mqc_states[82]},\r
+ {0x0009, 1, &mqc_states[89], &mqc_states[83]},\r
+ {0x0005, 0, &mqc_states[90], &mqc_states[84]},\r
+ {0x0005, 1, &mqc_states[91], &mqc_states[85]},\r
+ {0x0001, 0, &mqc_states[90], &mqc_states[86]},\r
+ {0x0001, 1, &mqc_states[91], &mqc_states[87]},\r
+ {0x5601, 0, &mqc_states[92], &mqc_states[92]},\r
+ {0x5601, 1, &mqc_states[93], &mqc_states[93]},\r
+};\r
+\r
+#define MQC_NUMCTXS 32\r
+\r
+unsigned int mqc_c;\r
+unsigned int mqc_a;\r
+unsigned int mqc_ct;\r
+unsigned char *mqc_bp;\r
+unsigned char *mqc_start;\r
+unsigned char *mqc_end;\r
+mqc_state_t *mqc_ctxs[MQC_NUMCTXS];\r
+mqc_state_t **mqc_curctx;\r
+\r
+/* <summary> */\r
+/* Return the number of bytes already encoded. */\r
+/* </summary> */\r
+int mqc_numbytes()\r
+{\r
+ return mqc_bp - mqc_start;\r
+}\r
+\r
+/* <summary> */\r
+/* Output a byte, doing bit-stuffing if necessary. */\r
+/* After a 0xff byte, the next byte must be smaller than 0x90 */\r
+/* </summary> */\r
+void mqc_byteout()\r
+{\r
+ if (*mqc_bp == 0xff) {\r
+ mqc_bp++;\r
+ *mqc_bp = mqc_c >> 20;\r
+ mqc_c &= 0xfffff;\r
+ mqc_ct = 7;\r
+ } else {\r
+ if ((mqc_c & 0x8000000) == 0) { /* ((mqc_c&0x8000000)==0) CHANGE */\r
+ mqc_bp++;\r
+ *mqc_bp = mqc_c >> 19;\r
+ mqc_c &= 0x7ffff;\r
+ mqc_ct = 8;\r
+ } else {\r
+ (*mqc_bp)++;\r
+ if (*mqc_bp == 0xff) {\r
+ mqc_c &= 0x7ffffff;\r
+ mqc_bp++;\r
+ *mqc_bp = mqc_c >> 20;\r
+ mqc_c &= 0xfffff;\r
+ mqc_ct = 7;\r
+ } else {\r
+ mqc_bp++;\r
+ *mqc_bp = mqc_c >> 19;\r
+ mqc_c &= 0x7ffff;\r
+ mqc_ct = 8;\r
+ }\r
+ }\r
+ }\r
+}\r
+\r
+/* <summary> */\r
+/* Renormalize mqc_a and mqc_c while encoding, so that mqc_a stays between 0x8000 and 0x10000 */\r
+/* </summary> */\r
+void mqc_renorme()\r
+{\r
+ do {\r
+ mqc_a <<= 1;\r
+ mqc_c <<= 1;\r
+ mqc_ct--;\r
+ if (mqc_ct == 0) {\r
+ mqc_byteout();\r
+ }\r
+ } while ((mqc_a & 0x8000) == 0);\r
+}\r
+\r
+/* <summary> */\r
+/* Encode the most probable symbol. */\r
+/* </summary> */\r
+void mqc_codemps()\r
+{\r
+ mqc_a -= (*mqc_curctx)->qeval;\r
+ if ((mqc_a & 0x8000) == 0) {\r
+ if (mqc_a < (*mqc_curctx)->qeval) {\r
+ mqc_a = (*mqc_curctx)->qeval;\r
+ } else {\r
+ mqc_c += (*mqc_curctx)->qeval;\r
+ }\r
+ *mqc_curctx = (*mqc_curctx)->nmps;\r
+ mqc_renorme();\r
+ } else {\r
+ mqc_c += (*mqc_curctx)->qeval;\r
+ }\r
+}\r
+\r
+/* <summary> */\r
+/* Encode the most least symbol. */\r
+/* </summary> */\r
+void mqc_codelps()\r
+{\r
+ mqc_a -= (*mqc_curctx)->qeval;\r
+ if (mqc_a < (*mqc_curctx)->qeval) {\r
+ mqc_c += (*mqc_curctx)->qeval;\r
+ } else {\r
+ mqc_a = (*mqc_curctx)->qeval;\r
+ }\r
+ *mqc_curctx = (*mqc_curctx)->nlps;\r
+ mqc_renorme();\r
+}\r
+\r
+/* <summary> */\r
+/* Initialize encoder. */\r
+/* </summary> */\r
+/* <param name="bp">Output buffer.</param> */\r
+void mqc_init_enc(unsigned char *bp)\r
+{\r
+ mqc_setcurctx(0);\r
+ mqc_a = 0x8000;\r
+ mqc_c = 0;\r
+ mqc_bp = bp - 1;\r
+ mqc_ct = 12;\r
+ if (*mqc_bp == 0xff) {\r
+ mqc_ct = 13;\r
+ }\r
+ mqc_start = bp;\r
+}\r
+\r
+/* <summary> */\r
+/* Set current context. */\r
+/* </summary> */\r
+/* <param name="ctxno">Context number.</param> */\r
+void mqc_setcurctx(int ctxno)\r
+{\r
+ mqc_curctx = &mqc_ctxs[ctxno];\r
+}\r
+\r
+/* <summary> */\r
+/* Encode a symbol using the MQ-coder. */\r
+/* </summary> */\r
+/* <param name="d"> The symbol to be encoded (0 or 1).</param> */\r
+void mqc_encode(int d)\r
+{\r
+ if ((*mqc_curctx)->mps == d) {\r
+ mqc_codemps();\r
+ } else {\r
+ mqc_codelps();\r
+ }\r
+}\r
+\r
+/* <summary> */\r
+/* Fill mqc_c with 1's for flushing */\r
+/* </summary> */\r
+void mqc_setbits()\r
+{\r
+ unsigned int tempc = mqc_c + mqc_a;\r
+ mqc_c |= 0xffff;\r
+ if (mqc_c >= tempc) {\r
+ mqc_c -= 0x8000;\r
+ }\r
+}\r
+\r
+/* <summary> */\r
+/* Flush encoded data. */\r
+/* </summary> */\r
+void mqc_flush()\r
+{\r
+ mqc_setbits();\r
+ mqc_c <<= mqc_ct;\r
+ mqc_byteout();\r
+ mqc_c <<= mqc_ct;\r
+ mqc_byteout();\r
+\r
+ if (*mqc_bp != 0xff) {\r
+ mqc_bp++;\r
+ }\r
+}\r
+\r
+/* <summary> */\r
+/* not fully implemented and tested !! */\r
+/* BYPASS mode switch, initialization operation */\r
+/* JPEG 2000 p 505 */\r
+/* </summary> */\r
+void mqc_bypass_init_enc()\r
+{\r
+ mqc_c = 0;\r
+ mqc_ct = 8;\r
+ /*if (*mqc_bp == 0xff) {\r
+ mqc_ct = 7;\r
+ } */\r
+}\r
+\r
+/* <summary> */\r
+/* not fully implemented and tested !! */\r
+/* BYPASS mode switch, coding operation */\r
+/* JPEG 2000 p 505 */\r
+/* </summary> */\r
+void mqc_bypass_enc(int d)\r
+{\r
+ mqc_ct--;\r
+ mqc_c = mqc_c + (d << mqc_ct);\r
+ if (mqc_ct == 0) {\r
+ mqc_bp++;\r
+ *mqc_bp = mqc_c;\r
+ mqc_ct = 8;\r
+ if (*mqc_bp == 0xff) {\r
+ mqc_ct = 7;\r
+ }\r
+ mqc_c = 0;\r
+ }\r
+}\r
+\r
+/* <summary> */\r
+/* not fully implemented and tested !! */\r
+/* BYPASS mode switch, flush operation */\r
+/* </summary> */\r
+int mqc_bypass_flush_enc()\r
+{\r
+ unsigned char bit_padding;\r
+\r
+ bit_padding = 0;\r
+\r
+ if (mqc_ct != 0) {\r
+ while (mqc_ct > 0) {\r
+ mqc_ct--;\r
+ mqc_c += bit_padding << mqc_ct;\r
+ bit_padding = (bit_padding + 1) & 0x01;\r
+ }\r
+ mqc_bp++;\r
+ *mqc_bp = mqc_c;\r
+ mqc_ct = 8;\r
+ mqc_c = 0;\r
+ }\r
+\r
+ return 1;\r
+}\r
+\r
+/* <summary> */\r
+/* RESET mode switch */\r
+/* </summary> */\r
+void mqc_reset_enc()\r
+{\r
+ mqc_resetstates();\r
+ mqc_setstate(18, 0, 46);\r
+ mqc_setstate(0, 0, 3);\r
+ mqc_setstate(1, 0, 4);\r
+}\r
+\r
+/* <summary> */\r
+/* mode switch RESTART (TERMALL) */\r
+/* </summary> */\r
+int mqc_restart_enc()\r
+{\r
+ int correction = 1;\r
+\r
+ /* <flush part> */\r
+ int n = 27 - 15 - mqc_ct;\r
+ mqc_c <<= mqc_ct;\r
+ while (n > 0) {\r
+ mqc_byteout();\r
+ n -= mqc_ct;\r
+ mqc_c <<= mqc_ct;\r
+ }\r
+ mqc_byteout();\r
+\r
+ return correction;\r
+}\r
+\r
+/* <summary> */\r
+/* mode switch RESTART (TERMALL) reinitialisation */\r
+/* </summary> */\r
+void mqc_restart_init_enc()\r
+{\r
+ /* <Re-init part> */\r
+ mqc_setcurctx(0);\r
+ mqc_a = 0x8000;\r
+ mqc_c = 0;\r
+ mqc_ct = 12;\r
+ mqc_bp--;\r
+ if (*mqc_bp == 0xff) {\r
+ mqc_ct = 13;\r
+ }\r
+}\r
+\r
+\r
+/* <summary> */\r
+/* ERTERM mode switch */\r
+/* </summary> */\r
+void mqc_erterm_enc()\r
+{\r
+ int k = 11 - mqc_ct + 1;\r
+\r
+ while (k > 0) {\r
+ mqc_c <<= mqc_ct;\r
+ mqc_ct = 0;\r
+ mqc_byteout();\r
+ k -= mqc_ct;\r
+ }\r
+\r
+ if (*mqc_bp != 0xff) {\r
+ mqc_byteout();\r
+ }\r
+}\r
+\r
+/* <summary> */\r
+/* SEGMARK mode switch (SEGSYM) */\r
+/* </summary> */\r
+void mqc_segmark_enc()\r
+{\r
+ int i;\r
+ mqc_setcurctx(18);\r
+\r
+ for (i = 1; i < 5; i++) {\r
+ mqc_encode(i % 2);\r
+ }\r
+}\r
+\r
+/* <summary> */\r
+/* </summary> */\r
+int mqc_mpsexchange()\r
+{\r
+ int d;\r
+ if (mqc_a < (*mqc_curctx)->qeval) {\r
+ d = 1 - (*mqc_curctx)->mps;\r
+ *mqc_curctx = (*mqc_curctx)->nlps;\r
+ } else {\r
+ d = (*mqc_curctx)->mps;\r
+ *mqc_curctx = (*mqc_curctx)->nmps;\r
+ }\r
+ return d;\r
+}\r
+\r
+/* <summary> */\r
+/* </summary> */\r
+int mqc_lpsexchange()\r
+{\r
+ int d;\r
+ if (mqc_a < (*mqc_curctx)->qeval) {\r
+ mqc_a = (*mqc_curctx)->qeval;\r
+ d = (*mqc_curctx)->mps;\r
+ *mqc_curctx = (*mqc_curctx)->nmps;\r
+ } else {\r
+ mqc_a = (*mqc_curctx)->qeval;\r
+ d = 1 - (*mqc_curctx)->mps;\r
+ *mqc_curctx = (*mqc_curctx)->nlps;\r
+ }\r
+ return d;\r
+}\r
+\r
+/* <summary> */\r
+/* Input a byte. */\r
+/* </summary> */\r
+void mqc_bytein()\r
+{\r
+ if (mqc_bp != mqc_end) {\r
+ unsigned int c;\r
+ if (mqc_bp + 1 != mqc_end) {\r
+ c = *(mqc_bp + 1);\r
+ } else {\r
+ c = 0xff;\r
+ }\r
+ if (*mqc_bp == 0xff) {\r
+ if (c > 0x8f) {\r
+ mqc_c += 0xff00;\r
+ mqc_ct = 8;\r
+ } else {\r
+ mqc_bp++;\r
+ mqc_c += c << 9;\r
+ mqc_ct = 7;\r
+ }\r
+ } else {\r
+ mqc_bp++;\r
+ mqc_c += c << 8;\r
+ mqc_ct = 8;\r
+ }\r
+ } else {\r
+ mqc_c += 0xff00;\r
+ mqc_ct = 8;\r
+ }\r
+}\r
+\r
+/* <summary> */\r
+/* Renormalize mqc_a and mqc_c while decoding. */\r
+/* </summary> */\r
+void mqc_renormd()\r
+{\r
+ do {\r
+ if (mqc_ct == 0) {\r
+ mqc_bytein();\r
+ }\r
+ mqc_a <<= 1;\r
+ mqc_c <<= 1;\r
+ mqc_ct--;\r
+ } while (mqc_a < 0x8000);\r
+}\r
+\r
+/* <summary> */\r
+/* Initialize decoder. */\r
+/* </summary> */\r
+void mqc_init_dec(unsigned char *bp, int len)\r
+{\r
+ mqc_setcurctx(0);\r
+ mqc_start = bp;\r
+ mqc_end = bp + len;\r
+ mqc_bp = bp;\r
+ /*add antonin initbug1*/\r
+ if (len==0) mqc_c = 0xff << 16;\r
+ else mqc_c = *mqc_bp << 16;\r
+ /*dda*/\r
+ mqc_bytein();\r
+ mqc_c <<= 7;\r
+ mqc_ct -= 7;\r
+ mqc_a = 0x8000;\r
+}\r
+\r
+/* <summary> */\r
+/* Decode a symbol. */\r
+/* </summary> */\r
+int mqc_decode()\r
+{\r
+ int d;\r
+ mqc_a -= (*mqc_curctx)->qeval;\r
+ if ((mqc_c >> 16) < (*mqc_curctx)->qeval) {\r
+ d = mqc_lpsexchange();\r
+ mqc_renormd();\r
+ } else {\r
+ mqc_c -= (*mqc_curctx)->qeval << 16;\r
+ if ((mqc_a & 0x8000) == 0) {\r
+ d = mqc_mpsexchange();\r
+ mqc_renormd();\r
+ } else {\r
+ d = (*mqc_curctx)->mps;\r
+ }\r
+ }\r
+ return d;\r
+}\r
+\r
+/* <summary> */\r
+/* Reset states of all contexts. */\r
+/* </summary> */\r
+void mqc_resetstates()\r
+{\r
+ int i;\r
+ for (i = 0; i < MQC_NUMCTXS; i++) {\r
+ mqc_ctxs[i] = mqc_states;\r
+ }\r
+}\r
+\r
+/* <summary> */\r
+/* Set the state for a context. */\r
+/* </summary> */\r
+/* <param name="ctxno">Context number</param> */\r
+/* <param name="msb">Most significant bit</param> */\r
+/* <param name="prob">Index to the probability of symbols</param> */\r
+void mqc_setstate(int ctxno, int msb, int prob)\r
+{\r
+ mqc_ctxs[ctxno] = &mqc_states[msb + (prob << 1)];\r
+}\r
--- /dev/null
+/*\r
+ * Copyright (c) 2001-2002, David Janssens\r
+ * Copyright (c) 2002-2003, Yannick Verschueren\r
+ * Copyright (c) 2002-2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+#ifndef __MQC_H\r
+#define __MQC_H\r
+\r
+/*\r
+ * Return the number of bytes written/read since initialisation\r
+ */\r
+int mqc_numbytes();\r
+\r
+/*\r
+ * Reset the states of all the context of the coder/decoder\r
+ * (each context is set to a state where 0 and 1 are more or less equiprobable)\r
+ */\r
+void mqc_resetstates();\r
+\r
+/*\r
+ * Set the state of a particular context\r
+ * ctxno: number that identifies the context\r
+ * msb: the MSB of the new state of the context\r
+ * prob: number that identifies the probability of the symbols for the new state of the context\r
+ */\r
+void mqc_setstate(int ctxno, int msb, int prob);\r
+\r
+/*\r
+ * Initialize the encoder\r
+ * bp: pointer to the start of the buffer where the bytes will be written\r
+ */\r
+void mqc_init_enc(unsigned char *bp);\r
+\r
+/*\r
+ * Set the current context used for coding/decoding\r
+ * ctxno: number that identifies the context\r
+ */\r
+void mqc_setcurctx(int ctxno);\r
+\r
+/*\r
+ * Encode a bit\r
+ * d: bit to encode (0 or 1)\r
+ */\r
+void mqc_encode(int d);\r
+\r
+/*\r
+ * Flush the encoder, so that all remaining data is written\r
+ */\r
+void mqc_flush();\r
+\r
+/*\r
+ * BYPASS mode switch\r
+ */\r
+void mqc_bypass_init_enc();\r
+\r
+/*\r
+ * BYPASS mode switch\r
+ */\r
+void mqc_bypass_enc(int d);\r
+\r
+/*\r
+ * BYPASS mode switch\r
+ */\r
+int mqc_bypass_flush_enc();\r
+\r
+/*\r
+ * RESET mode switch\r
+ */\r
+void mqc_reset_enc();\r
+\r
+/*\r
+ * RESTART mode switch (TERMALL)\r
+ */\r
+int mqc_restart_enc();\r
+\r
+/*\r
+ * RESTART mode switch (TERMALL)\r
+ */\r
+void mqc_restart_init_enc();\r
+\r
+/*\r
+ * ERTERM mode switch (PTERM)\r
+ */\r
+void mqc_erterm_enc();\r
+\r
+/*\r
+ * SEGMARK mode switch (SEGSYM)\r
+ */\r
+void mqc_segmark_enc();\r
+\r
+\r
+/*\r
+ * Initialize the decoder\r
+ * bp: pointer to the start of the buffer from which the bytes will be read\r
+ * len: length of the input buffer\r
+ */\r
+void mqc_init_dec(unsigned char *bp, int len);\r
+\r
+/*\r
+ * Decode a bit (returns 0 or 1)\r
+ */\r
+int mqc_decode();\r
+\r
+#endif\r
--- /dev/null
+/*\r
+ * Copyright (c) 2001-2002, David Janssens\r
+ * Copyright (c) 2003, Yannick Verschueren\r
+ * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+#ifndef __OPENJPEG_H\r
+#define __OPENJPEG_H\r
+\r
+#include <j2k.h>\r
+#include <tcd.h>\r
+#include <jp2.h>\r
+\r
+#include <bio.h>\r
+#include <cio.h>\r
+#include <dwt.h>\r
+#include <fix.h>\r
+#include <int.h>\r
+#include <mct.h>\r
+#include <mqc.h>\r
+#include <pi.h>\r
+#include <raw.h>\r
+#include <t1.h>\r
+#include <t2.h>\r
+#include <tgt.h>\r
+\r
+#endif\r
--- /dev/null
+/*\r
+ * Copyright (c) 2001-2002, David Janssens\r
+ * Copyright (c) 2003-2004, Yannick Verschueren\r
+ * Copyright (c) 2003-2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+#include "pi.h"\r
+#include "int.h"\r
+#include <stdlib.h>\r
+#include <stdio.h>\r
+\r
+/* <summary>\r
+ * Create a packet iterator.\r
+ * </summary> */\r
+pi_iterator_t *pi_create(j2k_image_t * img, j2k_cp_t * cp, int tileno)\r
+{\r
+ int p, q, i;\r
+ int compno, resno, pino;\r
+ int maxres = 0;\r
+ pi_iterator_t *pi;\r
+ j2k_tcp_t *tcp;\r
+ j2k_tccp_t *tccp;\r
+\r
+ tcp = &cp->tcps[tileno];\r
+ pi = (pi_iterator_t *) malloc((tcp->numpocs + 1) *\r
+ sizeof(pi_iterator_t));\r
+\r
+ for (pino = 0; pino < tcp->numpocs + 1; pino++) { /* change */\r
+ p = tileno % cp->tw;\r
+ q = tileno / cp->tw;\r
+\r
+ pi[pino].tx0 = int_max(cp->tx0 + p * cp->tdx, img->x0);\r
+ pi[pino].ty0 = int_max(cp->ty0 + q * cp->tdy, img->y0);\r
+ pi[pino].tx1 = int_min(cp->tx0 + (p + 1) * cp->tdx, img->x1);\r
+ pi[pino].ty1 = int_min(cp->ty0 + (q + 1) * cp->tdy, img->y1);\r
+ pi[pino].numcomps = img->numcomps;\r
+ pi[pino].comps =\r
+ (pi_comp_t *) malloc(img->numcomps * sizeof(pi_comp_t));\r
+\r
+ for (compno = 0; compno < pi->numcomps; compno++) {\r
+ int tcx0, tcy0, tcx1, tcy1;\r
+ pi_comp_t *comp = &pi[pino].comps[compno];\r
+ tccp = &tcp->tccps[compno];\r
+ comp->dx = img->comps[compno].dx;\r
+ comp->dy = img->comps[compno].dy;\r
+ comp->numresolutions = tccp->numresolutions;\r
+ comp->resolutions =\r
+ (pi_resolution_t *) malloc(comp->numresolutions *\r
+ sizeof(pi_resolution_t));\r
+ tcx0 = int_ceildiv(pi->tx0, comp->dx);\r
+ tcy0 = int_ceildiv(pi->ty0, comp->dy);\r
+ tcx1 = int_ceildiv(pi->tx1, comp->dx);\r
+ tcy1 = int_ceildiv(pi->ty1, comp->dy);\r
+ if (comp->numresolutions > maxres) {\r
+ maxres = comp->numresolutions;\r
+ }\r
+ for (resno = 0; resno < comp->numresolutions; resno++) {\r
+ int levelno;\r
+ int rx0, ry0, rx1, ry1;\r
+ int px0, py0, px1, py1;\r
+ pi_resolution_t *res = &comp->resolutions[resno];\r
+ if (tccp->csty & J2K_CCP_CSTY_PRT) {\r
+ res->pdx = tccp->prcw[resno];\r
+ res->pdy = tccp->prch[resno];\r
+ } else {\r
+ res->pdx = 15;\r
+ res->pdy = 15;\r
+ }\r
+ levelno = comp->numresolutions - 1 - resno;\r
+ rx0 = int_ceildivpow2(tcx0, levelno);\r
+ ry0 = int_ceildivpow2(tcy0, levelno);\r
+ rx1 = int_ceildivpow2(tcx1, levelno);\r
+ ry1 = int_ceildivpow2(tcy1, levelno);\r
+ px0 = int_floordivpow2(rx0, res->pdx) << res->pdx;\r
+ py0 = int_floordivpow2(ry0, res->pdy) << res->pdy;\r
+ px1 = int_ceildivpow2(rx1, res->pdx) << res->pdx;\r
+ py1 = int_ceildivpow2(ry1, res->pdy) << res->pdy;\r
+ res->pw = (rx0==rx1)?0:((px1 - px0) >> res->pdx); /*Mod Antonin : sizebug1*/\r
+ res->ph = (ry0==ry1)?0:((py1 - py0) >> res->pdy); /*Mod Antonin : sizebug1*/\r
+ }\r
+ }\r
+\r
+ tccp = &tcp->tccps[0];\r
+ pi[pino].step_p = 1;\r
+ pi[pino].step_c = 100 * pi[pino].step_p;\r
+ pi[pino].step_r = img->numcomps * pi[pino].step_c;\r
+ pi[pino].step_l = maxres * pi[pino].step_r;\r
+\r
+ if (pino == 0) {\r
+ pi[pino].include =\r
+ (short int *) malloc(img->numcomps * maxres *\r
+ tcp->numlayers * 100 * sizeof(short int));\r
+ for (i = 0; i < img->numcomps * maxres * tcp->numlayers * 100; i++)\r
+ pi[pino].include[i] = 0;\r
+ }\r
+ /* pi[pino].include=(short int*)calloc(img->numcomps*maxres*tcp->numlayers*1000,sizeof(short int)); */\r
+ else\r
+ pi[pino].include = pi[pino - 1].include;\r
+\r
+ if (tcp->POC == 0) {\r
+ pi[pino].first = 1;\r
+ pi[pino].poc.resno0 = 0;\r
+ pi[pino].poc.compno0 = 0;\r
+ pi[pino].poc.layno1 = tcp->numlayers;\r
+ pi[pino].poc.resno1 = maxres;\r
+ pi[pino].poc.compno1 = img->numcomps;\r
+ pi[pino].poc.prg = tcp->prg;\r
+ } else {\r
+ pi[pino].first = 1;\r
+ pi[pino].poc.resno0 = tcp->pocs[pino].resno0;\r
+ pi[pino].poc.compno0 = tcp->pocs[pino].compno0;\r
+ pi[pino].poc.layno1 = tcp->pocs[pino].layno1;\r
+ pi[pino].poc.resno1 = tcp->pocs[pino].resno1;\r
+ pi[pino].poc.compno1 = tcp->pocs[pino].compno1;\r
+ pi[pino].poc.prg = tcp->pocs[pino].prg;\r
+ }\r
+ }\r
+ return pi;\r
+}\r
+\r
+/* <summary>\r
+ * Get next packet in layer-resolution-component-precinct order.\r
+ * \r
+ * pi: packet iterator to modify\r
+ * </summary> */\r
+int pi_next_lrcp(pi_iterator_t * pi)\r
+{\r
+ pi_comp_t *comp;\r
+ pi_resolution_t *res;\r
+\r
+ if (!pi->first) {\r
+ comp = &pi->comps[pi->compno];\r
+ res = &comp->resolutions[pi->resno];\r
+ goto skip;\r
+ } else {\r
+ pi->first = 0;\r
+ }\r
+ for (pi->layno = 0; pi->layno < pi->poc.layno1; pi->layno++) {\r
+ for (pi->resno = pi->poc.resno0; pi->resno < pi->poc.resno1;\r
+ pi->resno++) {\r
+ for (pi->compno = pi->poc.compno0;\r
+ pi->compno < pi->poc.compno1; pi->compno++) {\r
+ comp = &pi->comps[pi->compno];\r
+ if (pi->resno >= comp->numresolutions) {\r
+ continue;\r
+ }\r
+ res = &comp->resolutions[pi->resno];\r
+ for (pi->precno = 0; pi->precno < res->pw * res->ph; pi->precno++) {\r
+ if (!pi->\r
+ include[pi->layno * pi->step_l +\r
+ pi->resno * pi->step_r +\r
+ pi->compno * pi->step_c + pi->precno * pi->step_p]) {\r
+ pi->include[pi->layno * pi->step_l +\r
+ pi->resno * pi->step_r +\r
+ pi->compno * pi->step_c +\r
+ pi->precno * pi->step_p] = 1;\r
+ return 1;\r
+ }\r
+ skip:;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ return 0;\r
+}\r
+\r
+/* <summary>\r
+ * Get next packet in resolution-layer-component-precinct order.\r
+ *\r
+ * pi: packet iterator to modify\r
+ * </summary> */\r
+int pi_next_rlcp(pi_iterator_t * pi)\r
+{\r
+ pi_comp_t *comp;\r
+ pi_resolution_t *res;\r
+ if (!pi->first) {\r
+ comp = &pi->comps[pi->compno];\r
+ res = &comp->resolutions[pi->resno];\r
+ goto skip;\r
+ } else {\r
+ pi->first = 0;\r
+ }\r
+ for (pi->resno = pi->poc.resno0; pi->resno < pi->poc.resno1; pi->resno++) {\r
+ for (pi->layno = 0; pi->layno < pi->poc.layno1; pi->layno++) {\r
+ for (pi->compno = pi->poc.compno0;\r
+ pi->compno < pi->poc.compno1; pi->compno++) {\r
+ comp = &pi->comps[pi->compno];\r
+ if (pi->resno >= comp->numresolutions) {\r
+ continue;\r
+ }\r
+ res = &comp->resolutions[pi->resno];\r
+ for (pi->precno = 0; pi->precno < res->pw * res->ph; pi->precno++) {\r
+ if (!pi->\r
+ include[pi->layno * pi->step_l +\r
+ pi->resno * pi->step_r +\r
+ pi->compno * pi->step_c + pi->precno * pi->step_p]) {\r
+ pi->include[pi->layno * pi->step_l +\r
+ pi->resno * pi->step_r +\r
+ pi->compno * pi->step_c +\r
+ pi->precno * pi->step_p] = 1;\r
+ return 1;\r
+ }\r
+ skip:;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ return 0;\r
+}\r
+\r
+/* <summary>\r
+ * Get next packet in resolution-precinct-component-layer order.\r
+ *\r
+ * pi: packet iterator to modify\r
+ * </summary> */\r
+int pi_next_rpcl(pi_iterator_t * pi)\r
+{\r
+ pi_comp_t *comp;\r
+ pi_resolution_t *res;\r
+ if (!pi->first) {\r
+ goto skip;\r
+ } else {\r
+ int compno, resno;\r
+ pi->first = 0;\r
+ pi->dx = 0;\r
+ pi->dy = 0;\r
+ for (compno = 0; compno < pi->numcomps; compno++) {\r
+ comp = &pi->comps[compno];\r
+ for (resno = 0; resno < comp->numresolutions; resno++) {\r
+ int dx, dy;\r
+ res = &comp->resolutions[resno];\r
+ dx = comp->dx *\r
+ (1 << (res->pdx + comp->numresolutions - 1 - resno));\r
+ dy = comp->dy *\r
+ (1 << (res->pdy + comp->numresolutions - 1 - resno));\r
+ pi->dx = !pi->dx ? dx : int_min(pi->dx, dx);\r
+ pi->dy = !pi->dy ? dy : int_min(pi->dy, dy);\r
+ }\r
+ }\r
+ }\r
+ for (pi->resno = pi->poc.resno0; pi->resno < pi->poc.resno1; pi->resno++) {\r
+ for (pi->y = pi->ty0; pi->y < pi->ty1;\r
+ pi->y += pi->dy - (pi->y % pi->dy)) {\r
+ for (pi->x = pi->tx0; pi->x < pi->tx1;\r
+ pi->x += pi->dx - (pi->x % pi->dx)) {\r
+ for (pi->compno = pi->poc.compno0;\r
+ pi->compno < pi->poc.compno1; pi->compno++) {\r
+ int levelno;\r
+ int trx0, try0;\r
+ int trx1, try1;/* Add antonin pcrl*/\r
+ int rpx, rpy;\r
+ int prci, prcj;\r
+ comp = &pi->comps[pi->compno];\r
+ if (pi->resno >= comp->numresolutions) {\r
+ continue;\r
+ }\r
+ res = &comp->resolutions[pi->resno];\r
+ levelno = comp->numresolutions - 1 - pi->resno;\r
+ trx0 = int_ceildiv(pi->tx0, comp->dx << levelno);\r
+ try0 = int_ceildiv(pi->ty0, comp->dy << levelno);\r
+ trx1 = int_ceildiv(pi->tx1, comp->dx << levelno);/* Add antonin pcrl*/\r
+ try1 = int_ceildiv(pi->ty1, comp->dy << levelno);/* Add antonin pcrl*/\r
+ rpx = res->pdx + levelno;\r
+ rpy = res->pdy + levelno;\r
+ if (!\r
+ (pi->x % (comp->dx << rpx) == 0\r
+ || (pi->x == pi->tx0 && (trx0 << levelno) % (1 << rpx)))) {\r
+ continue;\r
+ }\r
+ if (!\r
+ (pi->y % (comp->dy << rpy) == 0\r
+ || (pi->y == pi->ty0 && (try0 << levelno) % (1 << rpx)))) {\r
+ continue;\r
+ }\r
+\r
+ /*Add Antonin : sizebug1*/\r
+ if ((res->pw==0)||(res->pw==0)) continue;\r
+ /*ddA*/\r
+\r
+ /*Add Antonin : pcrl*/\r
+ if ((trx0==trx1)||(try0==try1)) continue;\r
+ /*ddA*/\r
+\r
+ prci =\r
+ int_floordivpow2(int_ceildiv\r
+ (pi->x, comp->dx << levelno),\r
+ res->pdx) - int_floordivpow2(trx0, res->pdx);\r
+ prcj =\r
+ int_floordivpow2(int_ceildiv\r
+ (pi->y, comp->dy << levelno),\r
+ res->pdy) - int_floordivpow2(try0, res->pdy);\r
+ pi->precno = prci + prcj * res->pw;\r
+ for (pi->layno = 0; pi->layno < pi->poc.layno1; pi->layno++) {\r
+ if (!pi->\r
+ include[pi->layno * pi->step_l +\r
+ pi->resno * pi->step_r +\r
+ pi->compno * pi->step_c +\r
+ pi->precno * pi->step_p]) {\r
+ pi->include[pi->layno * pi->step_l +\r
+ pi->resno * pi->step_r +\r
+ pi->compno * pi->step_c +\r
+ pi->precno * pi->step_p] = 1;\r
+ return 1;\r
+ }\r
+ skip:;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ return 0;\r
+}\r
+\r
+/* <summary>\r
+ * Get next packet in precinct-component-resolution-layer order.\r
+ *\r
+ * pi: packet iterator to modify\r
+ * </summary> */\r
+int pi_next_pcrl(pi_iterator_t * pi)\r
+{\r
+ pi_comp_t *comp;\r
+ pi_resolution_t *res;\r
+ if (!pi->first) {\r
+ comp = &pi->comps[pi->compno];\r
+ goto skip;\r
+ } else {\r
+ int compno, resno;\r
+ pi->first = 0;\r
+ pi->dx = 0;\r
+ pi->dy = 0;\r
+ for (compno = 0; compno < pi->numcomps; compno++) {\r
+ comp = &pi->comps[compno];\r
+ for (resno = 0; resno < comp->numresolutions; resno++) {\r
+ int dx, dy;\r
+ res = &comp->resolutions[resno];\r
+ dx = comp->dx *\r
+ (1 << (res->pdx + comp->numresolutions - 1 - resno));\r
+ dy = comp->dy *\r
+ (1 << (res->pdy + comp->numresolutions - 1 - resno));\r
+ pi->dx = !pi->dx ? dx : int_min(pi->dx, dx);\r
+ pi->dy = !pi->dy ? dy : int_min(pi->dy, dy);\r
+ }\r
+ }\r
+ }\r
+ for (pi->y = pi->ty0; pi->y < pi->ty1;\r
+ pi->y += pi->dy - (pi->y % pi->dy)) {\r
+ for (pi->x = pi->tx0; pi->x < pi->tx1;\r
+ pi->x += pi->dx - (pi->x % pi->dx)) {\r
+ for (pi->compno = pi->poc.compno0;\r
+ pi->compno < pi->poc.compno1; pi->compno++) {\r
+ comp = &pi->comps[pi->compno];\r
+ for (pi->resno = pi->poc.resno0;\r
+ pi->resno < int_min(pi->poc.resno1,\r
+ comp->numresolutions); pi->resno++) {\r
+ int levelno;\r
+ int trx0, try0;\r
+ int trx1, try1;/* Add antonin pcrl*/\r
+ int rpx, rpy;\r
+ int prci, prcj;\r
+ res = &comp->resolutions[pi->resno];\r
+ levelno = comp->numresolutions - 1 - pi->resno;\r
+ trx0 = int_ceildiv(pi->tx0, comp->dx << levelno);\r
+ try0 = int_ceildiv(pi->ty0, comp->dy << levelno);\r
+ trx1 = int_ceildiv(pi->tx1, comp->dx << levelno);/* Add antonin pcrl*/\r
+ try1 = int_ceildiv(pi->ty1, comp->dy << levelno);/* Add antonin pcrl*/\r
+ rpx = res->pdx + levelno;\r
+ rpy = res->pdy + levelno;\r
+ if (!\r
+ (pi->x % (comp->dx << rpx) == 0\r
+ || (pi->x == pi->tx0 && (trx0 << levelno) % (1 << rpx)))) {\r
+ continue;\r
+ }\r
+ if (!\r
+ (pi->y % (comp->dy << rpy) == 0\r
+ || (pi->y == pi->ty0 && (try0 << levelno) % (1 << rpx)))) {\r
+ continue;\r
+ }\r
+ \r
+ /*Add Antonin : sizebug1*/\r
+ if ((res->pw==0)||(res->pw==0)) continue;\r
+ /*ddA*/\r
+\r
+ /*Add Antonin : pcrl*/\r
+ if ((trx0==trx1)||(try0==try1)) continue;\r
+ /*ddA*/\r
+ \r
+ prci =\r
+ int_floordivpow2(int_ceildiv\r
+ (pi->x, comp->dx << levelno),\r
+ res->pdx) - int_floordivpow2(trx0, res->pdx);\r
+ prcj =\r
+ int_floordivpow2(int_ceildiv\r
+ (pi->y, comp->dy << levelno),\r
+ res->pdy) - int_floordivpow2(try0, res->pdy);\r
+ pi->precno = prci + prcj * res->pw;\r
+ for (pi->layno = 0; pi->layno < pi->poc.layno1; pi->layno++) {\r
+ if (!pi->\r
+ include[pi->layno * pi->step_l +\r
+ pi->resno * pi->step_r +\r
+ pi->compno * pi->step_c +\r
+ pi->precno * pi->step_p]) {\r
+ pi->include[pi->layno * pi->step_l +\r
+ pi->resno * pi->step_r +\r
+ pi->compno * pi->step_c +\r
+ pi->precno * pi->step_p] = 1;\r
+ return 1;\r
+ }\r
+skip:;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ return 0;\r
+}\r
+\r
+/* <summary>\r
+ * Get next packet in component-precinct-resolution-layer order.\r
+ *\r
+ * pi: packet iterator to modify\r
+ * </summary> */\r
+int pi_next_cprl(pi_iterator_t * pi)\r
+{\r
+ pi_comp_t *comp;\r
+ pi_resolution_t *res;\r
+ if (!pi->first) {\r
+ comp = &pi->comps[pi->compno];\r
+ goto skip;\r
+ } else {\r
+ pi->first = 0;\r
+ }\r
+ for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1;\r
+ pi->compno++) {\r
+ int resno;\r
+ comp = &pi->comps[pi->compno];\r
+ pi->dx = 0;\r
+ pi->dy = 0;\r
+ for (resno = 0; resno < comp->numresolutions; resno++) {\r
+ int dx, dy;\r
+ res = &comp->resolutions[resno];\r
+ dx = comp->dx * (1 << (res->pdx + comp->numresolutions - 1 - resno));\r
+ dy = comp->dy * (1 << (res->pdy + comp->numresolutions - 1 - resno));\r
+ pi->dx = !pi->dx ? dx : int_min(pi->dx, dx);\r
+ pi->dy = !pi->dy ? dy : int_min(pi->dy, dy);\r
+ }\r
+ for (pi->y = pi->ty0; pi->y < pi->ty1;\r
+ pi->y += pi->dy - (pi->y % pi->dy)) {\r
+ for (pi->x = pi->tx0; pi->x < pi->tx1;\r
+ pi->x += pi->dx - (pi->x % pi->dx)) {\r
+ for (pi->resno = pi->poc.resno0;\r
+ pi->resno < int_min(pi->poc.resno1,\r
+ comp->numresolutions); pi->resno++) {\r
+ int levelno;\r
+ int trx0, try0;\r
+ int trx1, try1;/* Add antonin pcrl*/\r
+ int rpx, rpy;\r
+ int prci, prcj;\r
+ res = &comp->resolutions[pi->resno];\r
+ levelno = comp->numresolutions - 1 - pi->resno;\r
+ trx0 = int_ceildiv(pi->tx0, comp->dx << levelno);\r
+ try0 = int_ceildiv(pi->ty0, comp->dy << levelno);\r
+ trx1 = int_ceildiv(pi->tx1, comp->dx << levelno);/* Add antonin pcrl*/\r
+ try1 = int_ceildiv(pi->ty1, comp->dy << levelno);/* Add antonin pcrl*/\r
+ rpx = res->pdx + levelno;\r
+ rpy = res->pdy + levelno;\r
+ if (!\r
+ (pi->x % (comp->dx << rpx) == 0\r
+ || (pi->x == pi->tx0 && (trx0 << levelno) % (1 << rpx)))) {\r
+ continue;\r
+ }\r
+ if (!\r
+ (pi->y % (comp->dy << rpy) == 0\r
+ || (pi->y == pi->ty0 && (try0 << levelno) % (1 << rpx)))) {\r
+ continue;\r
+ }\r
+\r
+ /*Add Antonin : sizebug1*/\r
+ if ((res->pw==0)||(res->pw==0)) continue;\r
+ /*ddA*/\r
+\r
+ /*Add Antonin : pcrl*/\r
+ if ((trx0==trx1)||(try0==try1)) continue;\r
+ /*ddA*/\r
+\r
+ prci =\r
+ int_floordivpow2(int_ceildiv\r
+ (pi->x, comp->dx << levelno),\r
+ res->pdx) - int_floordivpow2(trx0, res->pdx);\r
+ prcj =\r
+ int_floordivpow2(int_ceildiv\r
+ (pi->y, comp->dy << levelno),\r
+ res->pdy) - int_floordivpow2(try0, res->pdy);\r
+ pi->precno = prci + prcj * res->pw;\r
+ for (pi->layno = 0; pi->layno < pi->poc.layno1; pi->layno++) {\r
+ if (!pi->\r
+ include[pi->layno * pi->step_l +\r
+ pi->resno * pi->step_r +\r
+ pi->compno * pi->step_c +\r
+ pi->precno * pi->step_p]) {\r
+ pi->include[pi->layno * pi->step_l +\r
+ pi->resno * pi->step_r +\r
+ pi->compno * pi->step_c +\r
+ pi->precno * pi->step_p] = 1;\r
+ return 1;\r
+ }\r
+ skip:;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ return 0;\r
+}\r
+\r
+/* <summary>\r
+ * Get next packet.\r
+ *\r
+ * pi: packet iterator to modify\r
+ * </summary> */\r
+int pi_next(pi_iterator_t * pi)\r
+{\r
+ switch (pi->poc.prg) {\r
+ case 0:\r
+ return pi_next_lrcp(pi);\r
+ case 1:\r
+ return pi_next_rlcp(pi);\r
+ case 2:\r
+ return pi_next_rpcl(pi);\r
+ case 3:\r
+ return pi_next_pcrl(pi);\r
+ case 4:\r
+ return pi_next_cprl(pi);\r
+ }\r
+ return 0;\r
+}\r
--- /dev/null
+/*\r
+ * Copyright (c) 2001-2002, David Janssens\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+#ifndef __PI_H\r
+#define __PI_H\r
+\r
+#include "j2k.h"\r
+#include "tcd.h"\r
+\r
+typedef struct {\r
+ int pdx, pdy;\r
+ int pw, ph;\r
+} pi_resolution_t;\r
+\r
+typedef struct {\r
+ int dx, dy;\r
+ int numresolutions;\r
+ pi_resolution_t *resolutions;\r
+} pi_comp_t;\r
+\r
+typedef struct {\r
+ short int *include; /* precise if the packet has been already used (usefull for progression order change) */\r
+ int step_l, step_r, step_c, step_p; /* different steps (layer, resolution, component, precinct) to localize the packet in the include vector */\r
+ int compno, resno, precno, layno; /* component, resolution, precinct and layer that indentify the packet */\r
+ int first; /* 0 if the first packet */\r
+ j2k_poc_t poc;\r
+ int numcomps;\r
+ pi_comp_t *comps;\r
+ int tx0, ty0, tx1, ty1;\r
+ int x, y, dx, dy;\r
+} pi_iterator_t; /* packet iterator */\r
+\r
+/*\r
+ * Create a packet iterator\r
+ * img: raw image for which the packets will be listed\r
+ * cp: coding paremeters\r
+ * tileno: number that identifies the tile for which to list the packets\r
+ * return value: returns a packet iterator that points to the first packet of the tile\r
+ */\r
+pi_iterator_t *pi_create(j2k_image_t * img, j2k_cp_t * cp, int tileno);\r
+\r
+/* \r
+ * Modify the packet iterator to point to the next packet\r
+ * pi: packet iterator to modify\r
+ * return value: returns 0 if pi pointed to the last packet or else returns 1 \r
+ */\r
+int pi_next(pi_iterator_t * pi);\r
+\r
+#endif\r
--- /dev/null
+/*\r
+ * Copyright (c) 2002-2003, Antonin Descampe\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+#include "raw.h"\r
+\r
+\r
+unsigned char raw_c; /* temporary buffer where bits are coded or decoded */\r
+unsigned int raw_ct; /* number of bits already read or free to write */\r
+unsigned int raw_lenmax; /* maximum length to decode */\r
+unsigned int raw_len; /* length decoded */\r
+unsigned char *raw_bp; /* pointer to the current position in the buffer */\r
+unsigned char *raw_start; /* pointer to the start of the buffer */\r
+unsigned char *raw_end; /* pointer to the end of the buffer */\r
+\r
+/*\r
+ * Return the number of bytes already encoded.\r
+ */\r
+int raw_numbytes()\r
+{\r
+ return raw_bp - raw_start;\r
+}\r
+\r
+/*\r
+ * Initialize raw-decoder.\r
+ *\r
+ * bp : pointer to the start of the buffer from which the bytes will be read\r
+ * len : length of the input buffer\r
+ */\r
+void raw_init_dec(unsigned char *bp, int len)\r
+{\r
+ raw_start = bp;\r
+ raw_lenmax = len;\r
+ raw_len = 0;\r
+ raw_c = 0;\r
+ raw_ct = 0;\r
+}\r
+\r
+/*\r
+ * Decode a symbol using raw-decoder. Cfr p.506 TAUBMAN\r
+ */\r
+int raw_decode()\r
+{\r
+ int d;\r
+ if (raw_ct == 0) {\r
+ raw_ct = 8;\r
+ if (raw_len == raw_lenmax)\r
+ raw_c = 0xff;\r
+ else {\r
+ if (raw_c == 0xff)\r
+ raw_ct = 7;\r
+ raw_c = *(raw_start + raw_len);\r
+ raw_len++;\r
+ }\r
+ }\r
+ raw_ct--;\r
+ d = (raw_c >> raw_ct) & 0x01;\r
+ return d;\r
+}\r
--- /dev/null
+/*\r
+ * Copyright (c) 2002-2003, Antonin Descampe\r
+ * Copyright (c) 2002-2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+#ifndef __RAW_H\r
+#define __RAW_H\r
+\r
+/*\r
+ * Return the number of bytes written/read since initialisation\r
+ */\r
+int raw_numbytes();\r
+\r
+/*\r
+ * Initialize the decoder\r
+ * bp: pointer to the start of the buffer from which the bytes will be read\r
+ * len: length of the input buffer\r
+ */\r
+void raw_init_dec(unsigned char *bp, int len);\r
+\r
+/*\r
+ * Decode a bit (returns 0 or 1)\r
+ */\r
+int raw_decode();\r
+\r
+#endif\r
--- /dev/null
+/*\r
+ * Copyright (c) 2001-2002, David Janssens\r
+ * Copyright (c) 2002-2003, Yannick Verschueren\r
+ * Copyright (c) 2002-2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+#include "t1.h"\r
+#include "j2k.h"\r
+#include "mqc.h"\r
+#include "raw.h" /* Antonin */\r
+#include "int.h"\r
+#include "mct.h"\r
+#include "dwt.h"\r
+#include "fix.h"\r
+#include <stdio.h>\r
+#include <math.h>\r
+#include <stdlib.h>\r
+\r
+#define T1_MAXCBLKW 1024\r
+#define T1_MAXCBLKH 1024\r
+\r
+#define T1_SIG_NE 0x0001\r
+#define T1_SIG_SE 0x0002\r
+#define T1_SIG_SW 0x0004\r
+#define T1_SIG_NW 0x0008\r
+#define T1_SIG_N 0x0010\r
+#define T1_SIG_E 0x0020\r
+#define T1_SIG_S 0x0040\r
+#define T1_SIG_W 0x0080\r
+#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)\r
+#define T1_SIG_PRIM (T1_SIG_N|T1_SIG_E|T1_SIG_S|T1_SIG_W)\r
+\r
+#define T1_SGN_N 0x0100\r
+#define T1_SGN_E 0x0200\r
+#define T1_SGN_S 0x0400\r
+#define T1_SGN_W 0x0800\r
+#define T1_SGN (T1_SGN_N|T1_SGN_E|T1_SGN_S|T1_SGN_W)\r
+\r
+#define T1_SIG 0x1000\r
+#define T1_REFINE 0x2000\r
+#define T1_VISIT 0x4000\r
+\r
+#define T1_NUMCTXS_AGG 1\r
+#define T1_NUMCTXS_ZC 9\r
+#define T1_NUMCTXS_MAG 3\r
+#define T1_NUMCTXS_SC 5\r
+#define T1_NUMCTXS_UNI 1\r
+\r
+#define T1_CTXNO_AGG 0\r
+#define T1_CTXNO_ZC (T1_CTXNO_AGG+T1_NUMCTXS_AGG)\r
+#define T1_CTXNO_MAG (T1_CTXNO_ZC+T1_NUMCTXS_ZC)\r
+#define T1_CTXNO_SC (T1_CTXNO_MAG+T1_NUMCTXS_MAG)\r
+#define T1_CTXNO_UNI (T1_CTXNO_SC+T1_NUMCTXS_SC)\r
+#define T1_NUMCTXS (T1_CTXNO_UNI+T1_NUMCTXS_UNI)\r
+\r
+#define T1_NMSEDEC_BITS 7\r
+#define T1_NMSEDEC_FRACBITS (T1_NMSEDEC_BITS-1)\r
+\r
+/* add TONY */\r
+#define T1_TYPE_MQ 0\r
+#define T1_TYPE_RAW 1\r
+/* dda */\r
+\r
+static int t1_lut_ctxno_zc[1024];\r
+static int t1_lut_ctxno_sc[256];\r
+static int t1_lut_ctxno_mag[4096];\r
+static int t1_lut_spb[256];\r
+static int t1_lut_nmsedec_sig[1 << T1_NMSEDEC_BITS];\r
+static int t1_lut_nmsedec_sig0[1 << T1_NMSEDEC_BITS];\r
+static int t1_lut_nmsedec_ref[1 << T1_NMSEDEC_BITS];\r
+static int t1_lut_nmsedec_ref0[1 << T1_NMSEDEC_BITS];\r
+\r
+static int t1_data[T1_MAXCBLKH][T1_MAXCBLKW];\r
+static int t1_flags[T1_MAXCBLKH + 2][T1_MAXCBLKH + 2];\r
+\r
+int t1_getctxno_zc(int f, int orient)\r
+{\r
+ return t1_lut_ctxno_zc[(orient << 8) | (f & T1_SIG_OTH)];\r
+}\r
+\r
+int t1_getctxno_sc(int f)\r
+{\r
+ return t1_lut_ctxno_sc[(f & (T1_SIG_PRIM | T1_SGN)) >> 4];\r
+}\r
+\r
+int t1_getctxno_mag(int f)\r
+{\r
+ return t1_lut_ctxno_mag[(f & T1_SIG_OTH) |\r
+ (((f & T1_REFINE) != 0) << 11)];\r
+}\r
+\r
+int t1_getspb(int f)\r
+{\r
+ return t1_lut_spb[(f & (T1_SIG_PRIM | T1_SGN)) >> 4];\r
+}\r
+\r
+int t1_getnmsedec_sig(int x, int bitpos)\r
+{\r
+ if (bitpos > T1_NMSEDEC_FRACBITS)\r
+ return t1_lut_nmsedec_sig[(x >> (bitpos - T1_NMSEDEC_FRACBITS)) &\r
+ ((1 << T1_NMSEDEC_BITS) - 1)];\r
+ else\r
+ return t1_lut_nmsedec_sig0[x & ((1 << T1_NMSEDEC_BITS) - 1)];\r
+}\r
+\r
+int t1_getnmsedec_ref(int x, int bitpos)\r
+{\r
+ if (bitpos > T1_NMSEDEC_FRACBITS)\r
+ return t1_lut_nmsedec_ref[(x >> (bitpos - T1_NMSEDEC_FRACBITS)) &\r
+ ((1 << T1_NMSEDEC_BITS) - 1)];\r
+ else\r
+ return t1_lut_nmsedec_ref0[x & ((1 << T1_NMSEDEC_BITS) - 1)];\r
+}\r
+\r
+void t1_updateflags(int *fp, int s)\r
+{\r
+ int *np = fp - (T1_MAXCBLKW + 2);\r
+ int *sp = fp + (T1_MAXCBLKW + 2);\r
+ np[-1] |= T1_SIG_SE;\r
+ np[1] |= T1_SIG_SW;\r
+ sp[-1] |= T1_SIG_NE;\r
+ sp[1] |= T1_SIG_NW;\r
+ *np |= T1_SIG_S;\r
+ *sp |= T1_SIG_N;\r
+ fp[-1] |= T1_SIG_E;\r
+ fp[1] |= T1_SIG_W;\r
+ if (s) {\r
+ *np |= T1_SGN_S;\r
+ *sp |= T1_SGN_N;\r
+ fp[-1] |= T1_SGN_E;\r
+ fp[1] |= T1_SGN_W;\r
+ }\r
+}\r
+\r
+void t1_enc_sigpass_step(int *fp, int *dp, int orient, int bpno, int one,\r
+ int *nmsedec, char type, int vsc)\r
+{\r
+ int v, flag;\r
+ flag = vsc ? ((*fp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S)))\r
+ : (*fp);\r
+ if ((flag & T1_SIG_OTH) && !(flag & (T1_SIG | T1_VISIT))) {\r
+ v = int_abs(*dp) & one ? 1 : 0;\r
+ if (type == T1_TYPE_RAW) { /* BYPASS/LAZY MODE */\r
+ mqc_setcurctx(t1_getctxno_zc(flag, orient)); /* ESSAI */\r
+ mqc_bypass_enc(v);\r
+ } else {\r
+ mqc_setcurctx(t1_getctxno_zc(flag, orient));\r
+ mqc_encode(v);\r
+ }\r
+ if (v) {\r
+ v = *dp < 0 ? 1 : 0;\r
+ *nmsedec +=\r
+ t1_getnmsedec_sig(int_abs(*dp), bpno + T1_NMSEDEC_FRACBITS);\r
+ if (type == T1_TYPE_RAW) { /* BYPASS/LAZY MODE */\r
+ mqc_setcurctx(t1_getctxno_sc(flag)); /* ESSAI */\r
+ mqc_bypass_enc(v);\r
+ } else {\r
+ mqc_setcurctx(t1_getctxno_sc(flag));\r
+ mqc_encode(v ^ t1_getspb(flag));\r
+ }\r
+ t1_updateflags(fp, v);\r
+ *fp |= T1_SIG;\r
+ }\r
+ *fp |= T1_VISIT;\r
+ }\r
+}\r
+\r
+\r
+\r
+void t1_dec_sigpass_step(int *fp, int *dp, int orient, int oneplushalf,\r
+ char type, int vsc)\r
+{\r
+ int v, flag;\r
+ flag = vsc ? ((*fp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S)))\r
+ : (*fp);\r
+ if ((flag & T1_SIG_OTH) && !(flag & (T1_SIG | T1_VISIT))) {\r
+ if (type == T1_TYPE_RAW) {\r
+ if (raw_decode()) {\r
+ v = raw_decode(); /* ESSAI */\r
+ *dp = v ? -oneplushalf : oneplushalf;\r
+ t1_updateflags(fp, v);\r
+ *fp |= T1_SIG;\r
+ }\r
+ } else {\r
+ mqc_setcurctx(t1_getctxno_zc(flag, orient));\r
+ if (mqc_decode()) {\r
+ mqc_setcurctx(t1_getctxno_sc(flag));\r
+ v = mqc_decode() ^ t1_getspb(flag);\r
+ *dp = v ? -oneplushalf : oneplushalf;\r
+ t1_updateflags(fp, v);\r
+ *fp |= T1_SIG;\r
+ }\r
+ }\r
+ *fp |= T1_VISIT;\r
+ }\r
+} /* VSC and BYPASS by Antonin */\r
+\r
+void t1_enc_sigpass(int w, int h, int bpno, int orient, int *nmsedec,\r
+ char type, int cblksty)\r
+{\r
+ int i, j, k, one, vsc;\r
+ *nmsedec = 0;\r
+ one = 1 << (bpno + T1_NMSEDEC_FRACBITS);\r
+ for (k = 0; k < h; k += 4) {\r
+ for (i = 0; i < w; i++) {\r
+ for (j = k; j < k + 4 && j < h; j++) {\r
+ vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC)\r
+ && (j == k + 3 || j == h - 1)) ? 1 : 0;\r
+ t1_enc_sigpass_step(&t1_flags[1 + j][1 + i],\r
+ &t1_data[j][i], orient, bpno, one,\r
+ nmsedec, type, vsc);\r
+ }\r
+ }\r
+ }\r
+}\r
+\r
+void t1_dec_sigpass(int w, int h, int bpno, int orient, char type,\r
+ int cblksty)\r
+{\r
+ int i, j, k, one, half, oneplushalf, vsc;\r
+ one = 1 << bpno;\r
+ half = one >> 1;\r
+ oneplushalf = one | half;\r
+ for (k = 0; k < h; k += 4) {\r
+ for (i = 0; i < w; i++) {\r
+ for (j = k; j < k + 4 && j < h; j++) {\r
+ vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC)\r
+ && (j == k + 3 || j == h - 1)) ? 1 : 0;\r
+ t1_dec_sigpass_step(&t1_flags[1 + j][1 + i],\r
+ &t1_data[j][i], \r
+\r
+ orient, \r
+\r
+ oneplushalf,\r
+ type, vsc);\r
+ }\r
+ }\r
+ }\r
+} /* VSC and BYPASS by Antonin */\r
+\r
+void t1_enc_refpass_step(int *fp, int *dp, int bpno, int one, int *nmsedec,\r
+ char type, int vsc)\r
+{\r
+ int v, flag;\r
+ flag = vsc ? ((*fp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S)))\r
+ : (*fp);\r
+ if ((flag & (T1_SIG | T1_VISIT)) == T1_SIG) {\r
+ *nmsedec +=\r
+ t1_getnmsedec_ref(int_abs(*dp), bpno + T1_NMSEDEC_FRACBITS);\r
+ v = int_abs(*dp) & one ? 1 : 0;\r
+ if (type == T1_TYPE_RAW) { /* BYPASS/LAZY MODE */\r
+ mqc_setcurctx(t1_getctxno_mag(flag)); /* ESSAI */\r
+ mqc_bypass_enc(v);\r
+ } else {\r
+ mqc_setcurctx(t1_getctxno_mag(flag));\r
+ mqc_encode(v);\r
+ }\r
+ *fp |= T1_REFINE;\r
+ }\r
+}\r
+\r
+\r
+\r
+void t1_dec_refpass_step(int *fp, int *dp, int poshalf, int neghalf,\r
+ char type, int vsc)\r
+{\r
+ int v, t, flag;\r
+ flag = vsc ? ((*fp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S)))\r
+ : (*fp);\r
+ if ((flag & (T1_SIG | T1_VISIT)) == T1_SIG) {\r
+ if (type == T1_TYPE_RAW) {\r
+ mqc_setcurctx(t1_getctxno_mag(flag)); /* ESSAI */\r
+ v = raw_decode();\r
+ } else {\r
+ mqc_setcurctx(t1_getctxno_mag(flag));\r
+ v = mqc_decode();\r
+ }\r
+ t = v ? poshalf : neghalf;\r
+ *dp += *dp < 0 ? -t : t;\r
+ *fp |= T1_REFINE;\r
+ }\r
+} /* VSC and BYPASS by Antonin */\r
+\r
+void t1_enc_refpass(int w, int h, int bpno, int *nmsedec, char type,\r
+ int cblksty)\r
+{\r
+ int i, j, k, one, vsc;\r
+ *nmsedec = 0;\r
+ one = 1 << (bpno + T1_NMSEDEC_FRACBITS);\r
+ for (k = 0; k < h; k += 4) {\r
+ for (i = 0; i < w; i++) {\r
+ for (j = k; j < k + 4 && j < h; j++) {\r
+ vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC)\r
+ && (j == k + 3 || j == h - 1)) ? 1 : 0;\r
+ t1_enc_refpass_step(&t1_flags[1 + j][1 + i],\r
+ &t1_data[j][i], bpno, one, nmsedec, type, vsc);\r
+ }\r
+ }\r
+ }\r
+}\r
+\r
+void t1_dec_refpass(int w, int h, int bpno, char type, int cblksty)\r
+{\r
+ int i, j, k, one, poshalf, neghalf;\r
+ int vsc;\r
+ one = 1 << bpno;\r
+ poshalf = one >> 1;\r
+ neghalf = bpno > 0 ? -poshalf : -1;\r
+ for (k = 0; k < h; k += 4) {\r
+ for (i = 0; i < w; i++) {\r
+ for (j = k; j < k + 4 && j < h; j++) {\r
+ vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC)\r
+ && (j == k + 3 || j == h - 1)) ? 1 : 0;\r
+ t1_dec_refpass_step(&t1_flags[1 + j][1 + i],\r
+ &t1_data[j][i], \r
+\r
+ poshalf, \r
+\r
+ neghalf, \r
+\r
+ type, vsc);\r
+ }\r
+ }\r
+ }\r
+} /* VSC and BYPASS by Antonin */\r
+\r
+void t1_enc_clnpass_step(int *fp, int *dp, int orient, int bpno, int one,\r
+ int *nmsedec, int partial, int vsc)\r
+{\r
+ int v, flag;\r
+ flag = vsc ? ((*fp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S)))\r
+ : (*fp);\r
+ if (partial)\r
+ goto label_partial;\r
+ if (!(*fp & (T1_SIG | T1_VISIT))) {\r
+ mqc_setcurctx(t1_getctxno_zc(flag, orient));\r
+ v = int_abs(*dp) & one ? 1 : 0;\r
+ mqc_encode(v);\r
+ if (v) {\r
+ label_partial:\r
+ *nmsedec +=\r
+ t1_getnmsedec_sig(int_abs(*dp), bpno + T1_NMSEDEC_FRACBITS);\r
+ mqc_setcurctx(t1_getctxno_sc(flag));\r
+ v = *dp < 0 ? 1 : 0;\r
+ mqc_encode(v ^ t1_getspb(flag));\r
+ t1_updateflags(fp, v);\r
+ *fp |= T1_SIG;\r
+ }\r
+ }\r
+ *fp &= ~T1_VISIT;\r
+}\r
+\r
+\r
+\r
+\r
+void t1_dec_clnpass_step(int *fp, int *dp, int orient, int oneplushalf,\r
+ int partial, int vsc)\r
+{\r
+ int v, flag;\r
+ flag = vsc ? ((*fp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S)))\r
+ : (*fp);\r
+ if (partial)\r
+ goto label_partial;\r
+ if (!(flag & (T1_SIG | T1_VISIT))) {\r
+ mqc_setcurctx(t1_getctxno_zc(flag, orient));\r
+ if (mqc_decode()) {\r
+ label_partial:\r
+ mqc_setcurctx(t1_getctxno_sc(flag));\r
+ v = mqc_decode() ^ t1_getspb(flag);\r
+ *dp = v ? -oneplushalf : oneplushalf;\r
+ t1_updateflags(fp, v);\r
+ *fp |= T1_SIG;\r
+ }\r
+ }\r
+ *fp &= ~T1_VISIT;\r
+} /* VSC and BYPASS by Antonin */\r
+\r
+void t1_enc_clnpass(int w, int h, int bpno, int orient, int *nmsedec,\r
+ int cblksty)\r
+{\r
+ int i, j, k, one, agg, runlen, vsc;\r
+ *nmsedec = 0;\r
+ one = 1 << (bpno + T1_NMSEDEC_FRACBITS);\r
+ for (k = 0; k < h; k += 4) {\r
+ for (i = 0; i < w; i++) {\r
+ if (k + 3 < h) {\r
+ if (cblksty & J2K_CCP_CBLKSTY_VSC) {\r
+ agg = !(t1_flags[1 + k][1 + i] & (T1_SIG | T1_VISIT | T1_SIG_OTH)\r
+ || t1_flags[1 + k + 1][1 +\r
+ i] & (T1_SIG | T1_VISIT |\r
+ T1_SIG_OTH)\r
+ || t1_flags[1 + k + 2][1 +\r
+ i] & (T1_SIG | T1_VISIT |\r
+ T1_SIG_OTH)\r
+ || (t1_flags[1 + k + 3][1 + i] &\r
+ (~\r
+ (T1_SIG_S | T1_SIG_SE | T1_SIG_SW |\r
+ T1_SGN_S))) & (T1_SIG | T1_VISIT | T1_SIG_OTH));\r
+ } else {\r
+ agg = !(t1_flags[1 + k][1 + i] & (T1_SIG | T1_VISIT | T1_SIG_OTH)\r
+ || t1_flags[1 + k + 1][1 +\r
+ i] & (T1_SIG | T1_VISIT |\r
+ T1_SIG_OTH)\r
+ || t1_flags[1 + k + 2][1 +\r
+ i] & (T1_SIG | T1_VISIT |\r
+ T1_SIG_OTH)\r
+ || t1_flags[1 + k + 3][1 +\r
+ i] & (T1_SIG | T1_VISIT |\r
+ T1_SIG_OTH));\r
+ }\r
+ } else {\r
+ agg = 0;\r
+ }\r
+ if (agg) {\r
+ for (runlen = 0; runlen < 4; runlen++) {\r
+ if (int_abs(t1_data[k + runlen][i]) & one)\r
+ break;\r
+ }\r
+ mqc_setcurctx(T1_CTXNO_AGG);\r
+ mqc_encode(runlen != 4);\r
+ if (runlen == 4) {\r
+ continue;\r
+ }\r
+ mqc_setcurctx(T1_CTXNO_UNI);\r
+ mqc_encode(runlen >> 1);\r
+ mqc_encode(runlen & 1);\r
+ } else {\r
+ runlen = 0;\r
+ }\r
+ for (j = k + runlen; j < k + 4 && j < h; j++) {\r
+ vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC)\r
+ && (j == k + 3 || j == h - 1)) ? 1 : 0;\r
+ t1_enc_clnpass_step(&t1_flags[1 + j][1 + i],\r
+ &t1_data[j][i], orient, bpno, one,\r
+ nmsedec, agg && (j == k + runlen), vsc);\r
+ }\r
+ }\r
+ }\r
+}\r
+\r
+void t1_dec_clnpass(int w, int h, int bpno, int orient, int cblksty)\r
+{\r
+ int i, j, k, one, half, oneplushalf, agg, runlen, vsc;\r
+ int segsym = cblksty & J2K_CCP_CBLKSTY_SEGSYM;\r
+ one = 1 << bpno;\r
+ half = one >> 1;\r
+ oneplushalf = one | half;\r
+ for (k = 0; k < h; k += 4) {\r
+ for (i = 0; i < w; i++) {\r
+ if (k + 3 < h) {\r
+ if (cblksty & J2K_CCP_CBLKSTY_VSC) {\r
+ agg = !(t1_flags[1 + k][1 + i] & (T1_SIG | T1_VISIT | T1_SIG_OTH)\r
+ || t1_flags[1 + k + 1][1 +\r
+ i] & (T1_SIG | T1_VISIT |\r
+ T1_SIG_OTH)\r
+ || t1_flags[1 + k + 2][1 +\r
+ i] & (T1_SIG | T1_VISIT |\r
+ T1_SIG_OTH)\r
+ || (t1_flags[1 + k + 3][1 + i] &\r
+ (~\r
+ (T1_SIG_S | T1_SIG_SE | T1_SIG_SW |\r
+ T1_SGN_S))) & (T1_SIG | T1_VISIT | T1_SIG_OTH));\r
+ } else {\r
+ agg = !(t1_flags[1 + k][1 + i] & (T1_SIG | T1_VISIT | T1_SIG_OTH)\r
+ || t1_flags[1 + k + 1][1 +\r
+ i] & (T1_SIG | T1_VISIT |\r
+ T1_SIG_OTH)\r
+ || t1_flags[1 + k + 2][1 +\r
+ i] & (T1_SIG | T1_VISIT |\r
+ T1_SIG_OTH)\r
+ || t1_flags[1 + k + 3][1 +\r
+ i] & (T1_SIG | T1_VISIT |\r
+ T1_SIG_OTH));\r
+ }\r
+ } else {\r
+ agg = 0;\r
+ }\r
+ if (agg) {\r
+ mqc_setcurctx(T1_CTXNO_AGG);\r
+ if (!mqc_decode()) {\r
+ continue;\r
+ }\r
+ mqc_setcurctx(T1_CTXNO_UNI);\r
+ runlen = mqc_decode();\r
+ runlen = (runlen << 1) | mqc_decode();\r
+ } else {\r
+ runlen = 0;\r
+ }\r
+ for (j = k + runlen; j < k + 4 && j < h; j++) {\r
+ vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC)\r
+ && (j == k + 3 || j == h - 1)) ? 1 : 0;\r
+ t1_dec_clnpass_step(&t1_flags[1 + j][1 + i],\r
+ &t1_data[j][i], \r
+\r
+ orient, \r
+\r
+ oneplushalf,\r
+ agg && (j == k + runlen), vsc);\r
+ }\r
+ }\r
+ }\r
+ if (segsym) {\r
+ int v = 0;\r
+ mqc_setcurctx(T1_CTXNO_UNI);\r
+ v = mqc_decode();\r
+ v = (v << 1) | mqc_decode();\r
+ v = (v << 1) | mqc_decode();\r
+ v = (v << 1) | mqc_decode();\r
+ /* if (v!=0xa) \r
+ {\r
+ fprintf(stderr, "warning: bad segmentation symbol %x\n",v);\r
+ } */\r
+ }\r
+} /* VSC and BYPASS by Antonin */\r
+\r
+double t1_getwmsedec(int nmsedec, int compno, int level, int orient, int bpno, int qmfbid, float stepsize, int numcomps) /*mod fixed_quality*/\r
+{\r
+ double w1, w2, wmsedec;\r
+ if (qmfbid == 1) {\r
+ w1 = (numcomps > 1) ? mct_getnorm(compno) : 1;\r
+ w2 = dwt_getnorm(level, orient);\r
+ } else { /* if (qmfbid == 0) */\r
+ w1 = (numcomps > 1) ? mct_getnorm_real(compno) : 1;\r
+ w2 = dwt_getnorm_real(level, orient);\r
+ }\r
+ wmsedec = w1 * w2 * (stepsize / 8192.0) * (1 << bpno);\r
+ wmsedec *= wmsedec * nmsedec / 8192.0;\r
+ return wmsedec;\r
+}\r
+\r
+void t1_encode_cblk(tcd_cblk_t * cblk, int orient, int compno, int level, int qmfbid, float stepsize, int cblksty, int numcomps, tcd_tile_t * tile) /*mod fixed_quality*/\r
+{\r
+ int i, j;\r
+ int w, h;\r
+ int passno;\r
+ int bpno, passtype;\r
+ int max;\r
+ int nmsedec;\r
+ double cumwmsedec = 0;\r
+ char type = T1_TYPE_MQ;\r
+\r
+ w = cblk->x1 - cblk->x0;\r
+ h = cblk->y1 - cblk->y0;\r
+\r
+ max = 0;\r
+ for (j = 0; j < h; j++) {\r
+ for (i = 0; i < w; i++) {\r
+ max = int_max(max, int_abs(t1_data[j][i]));\r
+ }\r
+ }\r
+\r
+ cblk->numbps = max ? (int_floorlog2(max) + 1) - T1_NMSEDEC_FRACBITS : 0;\r
+\r
+ /* Changed by Dmitry Kolyadin */\r
+ for (i = 0; i <= w; i++)\r
+ for (j = 0; j <= h; j++){\r
+ t1_flags[j][i] = 0;\r
+ }\r
+\r
+ bpno = cblk->numbps - 1;\r
+ passtype = 2;\r
+\r
+ mqc_resetstates();\r
+ mqc_setstate(T1_CTXNO_UNI, 0, 46);\r
+ mqc_setstate(T1_CTXNO_AGG, 0, 3);\r
+ mqc_setstate(T1_CTXNO_ZC, 0, 4);\r
+ mqc_init_enc(cblk->data);\r
+\r
+ for (passno = 0; bpno >= 0; passno++) {\r
+ tcd_pass_t *pass = &cblk->passes[passno];\r
+ int correction = 3;\r
+ type = ((bpno < (cblk->numbps - 4)) && (passtype < 2)\r
+ && (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW :\r
+ T1_TYPE_MQ;\r
+\r
+ switch (passtype) {\r
+ case 0:\r
+ t1_enc_sigpass(w, h, bpno, orient, &nmsedec, type, cblksty);\r
+ break;\r
+ case 1:\r
+ t1_enc_refpass(w, h, bpno, &nmsedec, type, cblksty);\r
+ break;\r
+ case 2:\r
+ t1_enc_clnpass(w, h, bpno, orient, &nmsedec, cblksty);\r
+ /* code switch SEGMARK (i.e. SEGSYM) */\r
+ if (cblksty & J2K_CCP_CBLKSTY_SEGSYM)\r
+ mqc_segmark_enc();\r
+ break;\r
+ }\r
+\r
+ cumwmsedec += t1_getwmsedec(nmsedec, compno, level, orient, bpno, qmfbid, stepsize, numcomps); /*mod fixed_quality*/\r
+ tile->distotile += t1_getwmsedec(nmsedec, compno, level, orient, bpno, qmfbid, stepsize, numcomps); /*add antonin quality*/\r
+\r
+\r
+ /* Code switch "RESTART" (i.e. TERMALL) */\r
+ if ((cblksty & J2K_CCP_CBLKSTY_TERMALL)\r
+ && !((passtype == 2) && (bpno - 1 < 0))) {\r
+ if (type == T1_TYPE_RAW) {\r
+ mqc_flush();\r
+ correction = 1;\r
+ /* correction = mqc_bypass_flush_enc(); */\r
+ } else { /* correction = mqc_restart_enc(); */\r
+ mqc_flush();\r
+ correction = 1;\r
+ }\r
+ pass->term = 1;\r
+ } else {\r
+ if (((bpno < (cblk->numbps - 4) && (passtype > 0))\r
+ || ((bpno == (cblk->numbps - 4)) && (passtype == 2)))\r
+ && (cblksty & J2K_CCP_CBLKSTY_LAZY)) {\r
+ if (type == T1_TYPE_RAW) {\r
+ mqc_flush();\r
+ correction = 1;\r
+ /* correction = mqc_bypass_flush_enc(); */\r
+ } else { /* correction = mqc_restart_enc(); */\r
+ mqc_flush();\r
+ correction = 1;\r
+ }\r
+ pass->term = 1;\r
+ } else {\r
+ pass->term = 0;\r
+ }\r
+ }\r
+\r
+ if (++passtype == 3) {\r
+ passtype = 0;\r
+ bpno--;\r
+ }\r
+\r
+ if (pass->term && bpno > 0) {\r
+ type = ((bpno < (cblk->numbps - 4)) && (passtype < 2)\r
+ && (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW :\r
+ T1_TYPE_MQ;\r
+ if (type == T1_TYPE_RAW)\r
+ mqc_bypass_init_enc();\r
+ else\r
+ mqc_restart_init_enc();\r
+ }\r
+\r
+ pass->distortiondec = cumwmsedec;\r
+ pass->rate = mqc_numbytes() + correction; /* FIXME */\r
+ pass->len =\r
+ pass->rate - (passno == 0 ? 0 : cblk->passes[passno - 1].rate);\r
+\r
+ /* Code-switch "RESET" */\r
+ if (cblksty & J2K_CCP_CBLKSTY_RESET)\r
+ mqc_reset_enc();\r
+ }\r
+\r
+ /* Code switch "ERTERM" (i.e. PTERM) */\r
+ if (cblksty & J2K_CCP_CBLKSTY_PTERM)\r
+ mqc_erterm_enc();\r
+ else /* Default coding */ if (!(cblksty & J2K_CCP_CBLKSTY_LAZY))\r
+ mqc_flush();\r
+\r
+ cblk->totalpasses = passno;\r
+}\r
+\r
+void t1_decode_cblk(tcd_cblk_t * cblk, int orient, int roishift,\r
+ int cblksty)\r
+{\r
+ int i, j, w, h;\r
+ int bpno, passtype;\r
+ int segno, passno;\r
+ char type = T1_TYPE_MQ; /*BYPASS mode*/\r
+ \r
+ w = cblk->x1 - cblk->x0;\r
+ h = cblk->y1 - cblk->y0;\r
+ \r
+ /* Changed by Dmitry Kolyadin */\r
+ for (j = 0; j <= h; j++){\r
+ for (i = 0; i <= w; i++) {\r
+ t1_flags[j][i] = 0;\r
+ }\r
+ }\r
+ \r
+ /* Changed by Dmitry Kolyadin */\r
+ for (i = 0; i < w; i++) {\r
+ for (j = 0; j < h; j++){\r
+ t1_data[j][i] = 0;\r
+ }\r
+ }\r
+ \r
+ bpno = roishift + cblk->numbps - 1;\r
+ passtype = 2;\r
+\r
+ mqc_resetstates();\r
+ mqc_setstate(T1_CTXNO_UNI, 0, 46);\r
+ mqc_setstate(T1_CTXNO_AGG, 0, 3);\r
+ mqc_setstate(T1_CTXNO_ZC, 0, 4);\r
+\r
+ for (segno = 0; segno < cblk->numsegs; segno++) {\r
+ tcd_seg_t *seg = &cblk->segs[segno];\r
+ \r
+ /* Add BYPASS mode */\r
+ type = ((bpno <= (cblk->numbps - 1) - 4) && (passtype < 2)\r
+ && (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW :\r
+ T1_TYPE_MQ;\r
+ if (type == T1_TYPE_RAW) \r
+ raw_init_dec(seg->data, seg->len);\r
+ else\r
+ mqc_init_dec(seg->data, seg->len);\r
+ /* ddA */\r
+ \r
+ for (passno = 0; passno < seg->numpasses; passno++) {\r
+ switch (passtype) {\r
+ case 0:\r
+ t1_dec_sigpass(w, h, bpno+1, orient, type, cblksty);\r
+ break;\r
+ case 1:\r
+ t1_dec_refpass(w, h, bpno+1, type, cblksty);\r
+ break;\r
+ case 2:\r
+ t1_dec_clnpass(w, h, bpno+1, orient, cblksty);\r
+ break;\r
+ }\r
+ \r
+ if ((cblksty & J2K_CCP_CBLKSTY_RESET) && type == T1_TYPE_MQ) {\r
+ mqc_resetstates();\r
+\r
+ mqc_setstate(T1_CTXNO_UNI, 0, 46);\r
+\r
+ mqc_setstate(T1_CTXNO_AGG, 0, 3);\r
+\r
+ mqc_setstate(T1_CTXNO_ZC, 0, 4);\r
+\r
+ }\r
+ \r
+ if (++passtype == 3) {\r
+ passtype = 0;\r
+ bpno--;\r
+ }\r
+ }\r
+ }\r
+}\r
+\r
+void t1_encode_cblks(tcd_tile_t * tile, j2k_tcp_t * tcp)\r
+{\r
+ int compno, resno, bandno, precno, cblkno;\r
+ int x, y, i, j, orient;\r
+ tcd_tilecomp_t *tilec;\r
+ tcd_resolution_t *res;\r
+ tcd_band_t *band;\r
+ tcd_precinct_t *prc;\r
+ tcd_cblk_t *cblk;\r
+\r
+ tile->distotile = 0; /*add fixed_quality*/\r
+\r
+ for (compno = 0; compno < tile->numcomps; compno++) {\r
+ tilec = &tile->comps[compno];\r
+ for (resno = 0; resno < tilec->numresolutions; resno++) {\r
+ res = &tilec->resolutions[resno];\r
+ for (bandno = 0; bandno < res->numbands; bandno++) {\r
+ band = &res->bands[bandno];\r
+ for (precno = 0; precno < res->pw * res->ph; precno++) {\r
+ prc = &band->precincts[precno];\r
+ for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {\r
+ cblk = &prc->cblks[cblkno];\r
+\r
+ if (band->bandno == 0) {\r
+ x = cblk->x0 - band->x0;\r
+ y = cblk->y0 - band->y0;\r
+ } else if (band->bandno == 1) {\r
+ tcd_resolution_t *pres = &tilec->resolutions[resno - 1];\r
+ x = pres->x1 - pres->x0 + cblk->x0 - band->x0;\r
+ y = cblk->y0 - band->y0;\r
+ } else if (band->bandno == 2) {\r
+ tcd_resolution_t *pres = &tilec->resolutions[resno - 1];\r
+ x = cblk->x0 - band->x0;\r
+ y = pres->y1 - pres->y0 + cblk->y0 - band->y0;\r
+ } else { /* if (band->bandno == 3) */\r
+ tcd_resolution_t *pres = &tilec->resolutions[resno - 1];\r
+ x = pres->x1 - pres->x0 + cblk->x0 - band->x0;\r
+ y = pres->y1 - pres->y0 + cblk->y0 - band->y0;\r
+ }\r
+\r
+ if (tcp->tccps[compno].qmfbid == 1) {\r
+\r
+ for (j = 0; j < cblk->y1 - cblk->y0; j++) {\r
+ for (i = 0; i < cblk->x1 - cblk->x0; i++) {\r
+ t1_data[j][i] =\r
+ tilec->data[(x + i) +\r
+ (y + j) * (tilec->x1 -\r
+ tilec->\r
+ x0)] << T1_NMSEDEC_FRACBITS;\r
+ }\r
+ }\r
+ } else if (tcp->tccps[compno].qmfbid == 0) {\r
+ for (j = 0; j < cblk->y1 - cblk->y0; j++) {\r
+ for (i = 0; i < cblk->x1 - cblk->x0; i++) {\r
+ t1_data[j][i] =\r
+ fix_mul(tilec->\r
+ data[x + i +\r
+ (y + j) * (tilec->x1 -\r
+ tilec->\r
+ x0)],\r
+ 8192 * 8192 /\r
+ ((int) floor(band->stepsize * 8192))) >> (13 - T1_NMSEDEC_FRACBITS);\r
+ }\r
+ }\r
+ }\r
+ orient = band->bandno; /* FIXME */\r
+ if (orient == 2) {\r
+ orient = 1;\r
+ } else if (orient == 1) {\r
+ orient = 2;\r
+ }\r
+ t1_encode_cblk(cblk, orient, compno, tilec->numresolutions - 1 - resno, tcp->tccps[compno].qmfbid, band->stepsize, tcp->tccps[compno].cblksty, tile->numcomps, tile); /*mod fixed_quality*/\r
+ } /* cblkno */\r
+ } /* precno */\r
+ } /* bandno */\r
+ } /* resno */\r
+ } /* compo */\r
+}\r
+\r
+\r
+void t1_decode_cblks(tcd_tile_t * tile, j2k_tcp_t * tcp)\r
+{\r
+ int compno, resno, bandno, precno, cblkno;\r
+\r
+ for (compno = 0; compno < tile->numcomps; compno++) {\r
+ tcd_tilecomp_t *tilec = &tile->comps[compno];\r
+ for (resno = 0; resno < tilec->numresolutions; resno++) {\r
+ tcd_resolution_t *res = &tilec->resolutions[resno];\r
+ for (bandno = 0; bandno < res->numbands; bandno++) {\r
+ tcd_band_t *band = &res->bands[bandno];\r
+ for (precno = 0; precno < res->pw * res->ph; precno++) {\r
+ tcd_precinct_t *prc = &band->precincts[precno];\r
+ for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {\r
+ int x, y, i, j, orient;\r
+ tcd_cblk_t *cblk = &prc->cblks[cblkno];\r
+ orient = band->bandno; /* FIXME */\r
+ if (orient == 2)\r
+ orient = 1;\r
+ else if (orient == 1)\r
+ orient = 2;\r
+ t1_decode_cblk(cblk, orient,\r
+ tcp->tccps[compno].roishift,\r
+ tcp->tccps[compno].cblksty);\r
+ if (band->bandno == 0) {\r
+ x = cblk->x0 - band->x0;\r
+ y = cblk->y0 - band->y0;\r
+ } else if (band->bandno == 1) {\r
+ tcd_resolution_t *pres = &tilec->resolutions[resno - 1];\r
+ x = pres->x1 - pres->x0 + cblk->x0 - band->x0;\r
+ y = cblk->y0 - band->y0;\r
+ } else if (band->bandno == 2) {\r
+ tcd_resolution_t *pres = &tilec->resolutions[resno - 1];\r
+ x = cblk->x0 - band->x0;\r
+ y = pres->y1 - pres->y0 + cblk->y0 - band->y0;\r
+ } else { /* if (band->bandno == 3) */\r
+ tcd_resolution_t *pres = &tilec->resolutions[resno - 1];\r
+ x = pres->x1 - pres->x0 + cblk->x0 - band->x0;\r
+ y = pres->y1 - pres->y0 + cblk->y0 - band->y0;\r
+ }\r
+\r
+ if (tcp->tccps[compno].roishift) {\r
+ int thresh, val, mag;\r
+ thresh = 1 << tcp->tccps[compno].roishift;\r
+ for (j = 0; j < cblk->y1 - cblk->y0; j++) {\r
+ for (i = 0; i < cblk->x1 - cblk->x0; i++) {\r
+ val = t1_data[j][i];\r
+ mag = int_abs(val);\r
+ if (mag >= thresh) {\r
+ mag >>= tcp->tccps[compno].roishift;\r
+ t1_data[j][i] = val < 0 ? -mag : mag;\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ if (tcp->tccps[compno].qmfbid == 1) {\r
+ for (j = 0; j < cblk->y1 - cblk->y0; j++) {\r
+ for (i = 0; i < cblk->x1 - cblk->x0; i++) {\r
+ int tmp=t1_data[j][i];\r
+ if (tmp>>1==0) tilec->data[x + i + (y + j) * (tilec->x1 - tilec->x0)] = 0;\r
+ else tilec->data[x + i + (y + j) * (tilec->x1 - tilec->x0)] = tmp<0?(tmp>>1)+1:(tmp>>1);\r
+ }\r
+ }\r
+ } else { /* if (tcp->tccps[compno].qmfbid == 0) */\r
+\r
+ for (j = 0; j < cblk->y1 - cblk->y0; j++) {\r
+ for (i = 0; i < cblk->x1 - cblk->x0; i++) {\r
+ double tmp=t1_data[j][i] * band->stepsize * 4096.0;\r
+ int tmp2;\r
+ if (t1_data[j][i]>>1 == 0) {\r
+ tilec->data[x + i + (y + j) * (tilec->x1 - tilec->x0)] = 0;\r
+ } else {\r
+ tmp2=((int) (floor(fabs(tmp)))) + ((int) floor(fabs(tmp*2))%2);\r
+ tilec->data[x + i + (y + j) * (tilec->x1 - tilec->x0)] = ((tmp<0)?-tmp2:tmp2); \r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+}\r
+\r
+int t1_init_ctxno_zc(int f, int orient)\r
+{\r
+ int h, v, d, n, t, hv;\r
+ n = 0;\r
+ h = ((f & T1_SIG_W) != 0) + ((f & T1_SIG_E) != 0);\r
+ v = ((f & T1_SIG_N) != 0) + ((f & T1_SIG_S) != 0);\r
+ d = ((f & T1_SIG_NW) != 0) + ((f & T1_SIG_NE) !=\r
+ 0) + ((f & T1_SIG_SE) !=\r
+ 0) + ((f & T1_SIG_SW) != 0);\r
+ switch (orient) {\r
+ case 2:\r
+ t = h;\r
+ h = v;\r
+ v = t;\r
+ case 0:\r
+ case 1:\r
+ if (!h) {\r
+ if (!v) {\r
+ if (!d)\r
+ n = 0;\r
+ else if (d == 1)\r
+ n = 1;\r
+ else\r
+ n = 2;\r
+ } else if (v == 1)\r
+ n = 3;\r
+ else\r
+ n = 4;\r
+ } else if (h == 1) {\r
+ if (!v) {\r
+ if (!d)\r
+ n = 5;\r
+ else\r
+ n = 6;\r
+ } else\r
+ n = 7;\r
+ } else\r
+ n = 8;\r
+ break;\r
+ case 3:\r
+ hv = h + v;\r
+ if (!d) {\r
+ if (!hv)\r
+ n = 0;\r
+ else if (hv == 1)\r
+ n = 1;\r
+ else\r
+ n = 2;\r
+ } else if (d == 1) {\r
+ if (!hv)\r
+ n = 3;\r
+ else if (hv == 1)\r
+ n = 4;\r
+ else\r
+ n = 5;\r
+ } else if (d == 2) {\r
+ if (!hv)\r
+ n = 6;\r
+ else\r
+ n = 7;\r
+ } else\r
+ n = 8;\r
+ break;\r
+ }\r
+ return T1_CTXNO_ZC + n;\r
+}\r
+\r
+int t1_init_ctxno_sc(int f)\r
+{\r
+ int hc, vc, n;\r
+ n = 0;\r
+ hc = int_min(((f & (T1_SIG_E | T1_SGN_E)) ==\r
+ T1_SIG_E) + ((f & (T1_SIG_W | T1_SGN_W)) == T1_SIG_W),\r
+ 1) - int_min(((f & (T1_SIG_E | T1_SGN_E)) ==\r
+ (T1_SIG_E | T1_SGN_E)) +\r
+ ((f & (T1_SIG_W | T1_SGN_W)) ==\r
+ (T1_SIG_W | T1_SGN_W)), 1);\r
+ vc = int_min(((f & (T1_SIG_N | T1_SGN_N)) ==\r
+ T1_SIG_N) + ((f & (T1_SIG_S | T1_SGN_S)) == T1_SIG_S),\r
+ 1) - int_min(((f & (T1_SIG_N | T1_SGN_N)) ==\r
+ (T1_SIG_N | T1_SGN_N)) +\r
+ ((f & (T1_SIG_S | T1_SGN_S)) ==\r
+ (T1_SIG_S | T1_SGN_S)), 1);\r
+ if (hc < 0) {\r
+ hc = -hc;\r
+ vc = -vc;\r
+ }\r
+ if (!hc) {\r
+ if (vc == -1)\r
+ n = 1;\r
+ else if (!vc)\r
+ n = 0;\r
+ else\r
+ n = 1;\r
+ } else if (hc == 1) {\r
+ if (vc == -1)\r
+ n = 2;\r
+ else if (!vc)\r
+ n = 3;\r
+ else\r
+ n = 4;\r
+ }\r
+ return T1_CTXNO_SC + n;\r
+}\r
+\r
+int t1_init_ctxno_mag(int f)\r
+{\r
+ int n;\r
+ if (!(f & T1_REFINE))\r
+ n = (f & (T1_SIG_OTH)) ? 1 : 0;\r
+ else\r
+ n = 2;\r
+ return T1_CTXNO_MAG + n;\r
+}\r
+\r
+int t1_init_spb(int f)\r
+{\r
+ int hc, vc, n;\r
+ hc = int_min(((f & (T1_SIG_E | T1_SGN_E)) ==\r
+ T1_SIG_E) + ((f & (T1_SIG_W | T1_SGN_W)) == T1_SIG_W),\r
+ 1) - int_min(((f & (T1_SIG_E | T1_SGN_E)) ==\r
+ (T1_SIG_E | T1_SGN_E)) +\r
+ ((f & (T1_SIG_W | T1_SGN_W)) ==\r
+ (T1_SIG_W | T1_SGN_W)), 1);\r
+ vc = int_min(((f & (T1_SIG_N | T1_SGN_N)) ==\r
+ T1_SIG_N) + ((f & (T1_SIG_S | T1_SGN_S)) == T1_SIG_S),\r
+ 1) - int_min(((f & (T1_SIG_N | T1_SGN_N)) ==\r
+ (T1_SIG_N | T1_SGN_N)) +\r
+ ((f & (T1_SIG_S | T1_SGN_S)) ==\r
+ (T1_SIG_S | T1_SGN_S)), 1);\r
+ if (!hc && !vc)\r
+ n = 0;\r
+ else\r
+ n = (!(hc > 0 || (!hc && vc > 0)));\r
+ return n;\r
+}\r
+\r
+void t1_init_luts()\r
+{\r
+ int i, j;\r
+ double u, v, t;\r
+ for (j = 0; j < 4; j++) {\r
+ for (i = 0; i < 256; ++i) {\r
+ t1_lut_ctxno_zc[(j << 8) | i] = t1_init_ctxno_zc(i, j);\r
+ }\r
+ }\r
+ for (i = 0; i < 256; i++) {\r
+ t1_lut_ctxno_sc[i] = t1_init_ctxno_sc(i << 4);\r
+ }\r
+ for (j = 0; j < 2; j++) {\r
+ for (i = 0; i < 2048; ++i) {\r
+ t1_lut_ctxno_mag[(j << 11) + i] =\r
+ t1_init_ctxno_mag((j ? T1_REFINE : 0) | i);\r
+ }\r
+ }\r
+ for (i = 0; i < 256; ++i) {\r
+ t1_lut_spb[i] = t1_init_spb(i << 4);\r
+ }\r
+ /* FIXME FIXME FIXME */\r
+ /* fprintf(stdout,"nmsedec luts:\n"); */\r
+ for (i = 0; i < (1 << T1_NMSEDEC_BITS); i++) {\r
+ t = i / pow(2, T1_NMSEDEC_FRACBITS);\r
+ u = t;\r
+ v = t - 1.5;\r
+ t1_lut_nmsedec_sig[i] =\r
+ int_max(0,\r
+ (int) (floor\r
+ ((u * u - v * v) * pow(2,\r
+ T1_NMSEDEC_FRACBITS) +\r
+ 0.5) / pow(2, T1_NMSEDEC_FRACBITS) * 8192.0));\r
+ t1_lut_nmsedec_sig0[i] =\r
+ int_max(0,\r
+ (int) (floor\r
+ ((u * u) * pow(2, T1_NMSEDEC_FRACBITS) +\r
+ 0.5) / pow(2, T1_NMSEDEC_FRACBITS) * 8192.0));\r
+ u = t - 1.0;\r
+ if (i & (1 << (T1_NMSEDEC_BITS - 1))) {\r
+ v = t - 1.5;\r
+ } else {\r
+ v = t - 0.5;\r
+ }\r
+ t1_lut_nmsedec_ref[i] =\r
+ int_max(0,\r
+ (int) (floor\r
+ ((u * u - v * v) * pow(2,\r
+ T1_NMSEDEC_FRACBITS) +\r
+ 0.5) / pow(2, T1_NMSEDEC_FRACBITS) * 8192.0));\r
+ t1_lut_nmsedec_ref0[i] =\r
+ int_max(0,\r
+ (int) (floor\r
+ ((u * u) * pow(2, T1_NMSEDEC_FRACBITS) +\r
+ 0.5) / pow(2, T1_NMSEDEC_FRACBITS) * 8192.0));\r
+ }\r
+}\r
--- /dev/null
+/*\r
+ * Copyright (c) 2001-2002, David Janssens\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+#ifndef __T1_H\r
+#define __T1_H\r
+\r
+#include "tcd.h"\r
+#include "j2k.h"\r
+\r
+/*\r
+ * Initialize the look-up tables of the Tier-1 coder/decoder\r
+ */\r
+void t1_init_luts();\r
+\r
+/*\r
+ * Encode the code-blocks of a tile\r
+ * tile: the tile to encode\r
+ * tcp: tile coding parameters\r
+ */\r
+void t1_encode_cblks(tcd_tile_t * tile, j2k_tcp_t * tcp);\r
+\r
+/*\r
+ * Decode the code-blocks of a tile\r
+ * tile: the tile to encode\r
+ * tcp: tile coding parameters\r
+ */\r
+void t1_decode_cblks(tcd_tile_t * tile, j2k_tcp_t * tcp);\r
+\r
+#endif\r
--- /dev/null
+/*\r
+ * Copyright (c) 2001-2002, David Janssens\r
+ * Copyright (c) 2002-2004, Yannick Verschueren\r
+ * Copyright (c) 2002-2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+#include "t2.h"\r
+#include "tcd.h"\r
+#include "bio.h"\r
+#include "j2k.h"\r
+#include "pi.h"\r
+#include "tgt.h"\r
+#include "int.h"\r
+#include "cio.h"\r
+#include <stdio.h>\r
+#include <setjmp.h>\r
+#include <string.h>\r
+#include <stdlib.h>\r
+\r
+#define RESTART 0x04\r
+\r
+extern jmp_buf j2k_error;\r
+\r
+void t2_putcommacode(int n)\r
+{\r
+ while (--n >= 0) {\r
+ bio_write(1, 1);\r
+ }\r
+ bio_write(0, 1);\r
+}\r
+\r
+int t2_getcommacode()\r
+{\r
+ int n;\r
+ for (n = 0; bio_read(1); n++) {\r
+ }\r
+ return n;\r
+}\r
+\r
+/* <summary> */\r
+/* Variable length code for signalling delta Zil (truncation point) */\r
+/* <val> n : delta Zil */\r
+/* <\summary> */\r
+void t2_putnumpasses(int n)\r
+{\r
+ if (n == 1) {\r
+ bio_write(0, 1);\r
+ } else if (n == 2) {\r
+ bio_write(2, 2);\r
+ } else if (n <= 5) {\r
+ bio_write(0xc | (n - 3), 4);\r
+ } else if (n <= 36) {\r
+ bio_write(0x1e0 | (n - 6), 9);\r
+ } else if (n <= 164) {\r
+ bio_write(0xff80 | (n - 37), 16);\r
+ }\r
+}\r
+\r
+int t2_getnumpasses()\r
+{\r
+ int n;\r
+ if (!bio_read(1))\r
+ return 1;\r
+ if (!bio_read(1))\r
+ return 2;\r
+ if ((n = bio_read(2)) != 3)\r
+ return 3 + n;\r
+ if ((n = bio_read(5)) != 31)\r
+ return 6 + n;\r
+ return 37 + bio_read(7);\r
+}\r
+\r
+/*\r
+ * Encode a packet of a tile to a destination buffer\r
+ *\r
+ * Tile : the tile for which to write the packets\r
+ * tcp : the tile coding parameters\r
+ * compno : Identity of the packet --> component value\r
+ * resno : Identity of the packet --> resolution level value\r
+ * precno : Identity of the packet --> precinct value\r
+ * layno : Identity of the packet --> quality layer value\r
+ * dest : the destination buffer\r
+ * len : the length of the destination buffer\r
+ * info_IM : structure to create an index file\r
+ * tileno : number of the tile encoded\r
+*/\r
+int t2_encode_packet(tcd_tile_t * tile, j2k_tcp_t * tcp, int compno,\r
+ int resno, int precno, int layno, unsigned char *dest,\r
+ int len, info_image * info_IM, int tileno)\r
+{\r
+ int bandno, cblkno;\r
+ unsigned char *sop = 0, *eph = 0;\r
+ tcd_tilecomp_t *tilec = &tile->comps[compno];\r
+ tcd_resolution_t *res = &tilec->resolutions[resno];\r
+ unsigned char *c = dest;\r
+\r
+ /* <SOP 0xff91> */\r
+ if (tcp->csty & J2K_CP_CSTY_SOP) {\r
+ sop = (unsigned char *) malloc(6 * sizeof(unsigned char));\r
+ sop[0] = 255;\r
+ sop[1] = 145;\r
+ sop[2] = 0;\r
+ sop[3] = 4;\r
+ sop[4] = (info_IM->num % 65536) / 256;\r
+ sop[5] = (info_IM->num % 65536) % 256;\r
+ memcpy(c, sop, 6);\r
+ free(sop);\r
+ c += 6;\r
+ }\r
+ /* </SOP> */\r
+\r
+ if (!layno) {\r
+ for (bandno = 0; bandno < res->numbands; bandno++) {\r
+ tcd_band_t *band = &res->bands[bandno];\r
+ tcd_precinct_t *prc = &band->precincts[precno];\r
+ tgt_reset(prc->incltree);\r
+ tgt_reset(prc->imsbtree);\r
+ for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {\r
+ tcd_cblk_t *cblk = &prc->cblks[cblkno];\r
+ cblk->numpasses = 0;\r
+ tgt_setvalue(prc->imsbtree, cblkno, band->numbps - cblk->numbps);\r
+ }\r
+ }\r
+ }\r
+\r
+ bio_init_enc(c, len);\r
+ bio_write(1, 1); /* Empty header bit */\r
+\r
+ /* Writing Packet header */\r
+ for (bandno = 0; bandno < res->numbands; bandno++) {\r
+ tcd_band_t *band = &res->bands[bandno];\r
+ tcd_precinct_t *prc = &band->precincts[precno];\r
+ for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {\r
+ tcd_cblk_t *cblk = &prc->cblks[cblkno];\r
+ tcd_layer_t *layer = &cblk->layers[layno];\r
+ if (!cblk->numpasses && layer->numpasses) {\r
+ tgt_setvalue(prc->incltree, cblkno, layno);\r
+ }\r
+ }\r
+ for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {\r
+ tcd_cblk_t *cblk = &prc->cblks[cblkno];\r
+ tcd_layer_t *layer = &cblk->layers[layno];\r
+ int increment = 0;\r
+ int nump = 0;\r
+ int len = 0, passno;\r
+ /* cblk inclusion bits */\r
+ if (!cblk->numpasses) {\r
+ tgt_encode(prc->incltree, cblkno, layno + 1);\r
+ } else {\r
+ bio_write(layer->numpasses != 0, 1);\r
+ }\r
+ /* if cblk not included, go to the next cblk */\r
+ if (!layer->numpasses) {\r
+ continue;\r
+ }\r
+ /* if first instance of cblk --> zero bit-planes information */\r
+ if (!cblk->numpasses) {\r
+ cblk->numlenbits = 3;\r
+ tgt_encode(prc->imsbtree, cblkno, 999);\r
+ }\r
+ /* number of coding passes included */\r
+ t2_putnumpasses(layer->numpasses);\r
+\r
+ /* computation of the increase of the length indicator and insertion in the header */\r
+ for (passno = cblk->numpasses;\r
+ passno < cblk->numpasses + layer->numpasses; passno++) {\r
+ tcd_pass_t *pass = &cblk->passes[passno];\r
+ nump++;\r
+ len += pass->len;\r
+ if (pass->term\r
+ || passno == (cblk->numpasses + layer->numpasses) - 1) {\r
+ increment =\r
+ int_max(increment,\r
+ int_floorlog2(len) + 1 -\r
+ (cblk->numlenbits + int_floorlog2(nump)));\r
+ len = 0;\r
+ nump = 0;\r
+ }\r
+ }\r
+ t2_putcommacode(increment);\r
+ /* computation of the new Length indicator */\r
+ cblk->numlenbits += increment;\r
+ /* insertion of the codeword segment length */\r
+\r
+ for (passno = cblk->numpasses;\r
+ passno < cblk->numpasses + layer->numpasses; passno++) {\r
+ tcd_pass_t *pass = &cblk->passes[passno];\r
+ nump++;\r
+ len += pass->len;\r
+ if (pass->term\r
+ || passno == (cblk->numpasses + layer->numpasses) - 1) {\r
+ bio_write(len, cblk->numlenbits + int_floorlog2(nump));\r
+ len = 0;\r
+ nump = 0;\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ if (bio_flush())\r
+ return -999; /* modified to eliminate longjmp !! */\r
+\r
+ c += bio_numbytes();\r
+\r
+ /* <EPH 0xff92> */\r
+ if (tcp->csty & J2K_CP_CSTY_EPH) {\r
+ eph = (unsigned char *) malloc(2 * sizeof(unsigned char));\r
+ eph[0] = 255;\r
+ eph[1] = 146;\r
+ memcpy(c, eph, 2);\r
+ free(eph);\r
+ c += 2;\r
+ }\r
+ /* </EPH> */\r
+\r
+ /* Writing the packet body */\r
+\r
+ for (bandno = 0; bandno < res->numbands; bandno++) {\r
+ tcd_band_t *band = &res->bands[bandno];\r
+ tcd_precinct_t *prc = &band->precincts[precno];\r
+ for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {\r
+ tcd_cblk_t *cblk = &prc->cblks[cblkno];\r
+ tcd_layer_t *layer = &cblk->layers[layno];\r
+ if (!layer->numpasses) {\r
+ continue;\r
+ }\r
+ if (c + layer->len > dest + len) {\r
+ return -999;\r
+ }\r
+\r
+ memcpy(c, layer->data, layer->len);\r
+ cblk->numpasses += layer->numpasses;\r
+ c += layer->len;\r
+ /* ADD for index Cfr. Marcela --> delta disto by packet */\r
+ if (info_IM->index_write && info_IM->index_on) {\r
+ info_tile *info_TL = &info_IM->tile[tileno];\r
+ info_packet *info_PK = &info_TL->packet[info_IM->num];\r
+ info_PK->disto += layer->disto;\r
+ if (info_IM->D_max < info_PK->disto)\r
+ info_IM->D_max = info_PK->disto;\r
+ } /* </ADD> */\r
+ }\r
+ }\r
+ return c - dest;\r
+}\r
+\r
+void t2_init_seg(tcd_seg_t * seg, int cblksty, int first)\r
+{\r
+ seg->numpasses = 0;\r
+ seg->len = 0;\r
+ if (cblksty & J2K_CCP_CBLKSTY_TERMALL)\r
+ seg->maxpasses = 1;\r
+ else if (cblksty & J2K_CCP_CBLKSTY_LAZY) {\r
+ if (first)\r
+ seg->maxpasses = 10;\r
+ else\r
+ seg->maxpasses = (((seg - 1)->maxpasses == 1)\r
+ || ((seg - 1)->maxpasses == 10)) ? 2 : 1;\r
+ } else\r
+ seg->maxpasses = 109;\r
+}\r
+\r
+/* \r
+ * Decode a packet of a tile from a source buffer\r
+ *\r
+ * src : the source buffer\r
+ * len : the length of the source buffer\r
+ * tile : the tile for which to write the packets\r
+ * cp : the image coding parameters\r
+ * tcp : the tile coding parameters\r
+ * compno : Identity of the packet --> component value\r
+ * resno : Identity of the packet --> resolution level value\r
+ * precno : Identity of the packet --> precinct value\r
+ * layno : Identity of the packet --> quality layer value\r
+ */\r
+int t2_decode_packet(unsigned char *src, int len, tcd_tile_t * tile,\r
+ j2k_cp_t * cp, j2k_tcp_t * tcp, int compno, int resno,\r
+ int precno, int layno)\r
+{\r
+ int bandno, cblkno;\r
+ tcd_tilecomp_t *tilec = &tile->comps[compno];\r
+ tcd_resolution_t *res = &tilec->resolutions[resno];\r
+ unsigned char *c = src;\r
+\r
+ unsigned char *hd = NULL;\r
+ int present;\r
+\r
+ if (layno == 0) {\r
+ for (bandno = 0; bandno < res->numbands; bandno++) {\r
+ tcd_band_t *band = &res->bands[bandno];\r
+ tcd_precinct_t *prc = &band->precincts[precno];\r
+\r
+ \r
+\r
+ /*Add Antonin : sizebug1*/\r
+\r
+ if ((band->x1-band->x0 == 0)||(band->y1-band->y0 == 0)) continue;\r
+\r
+ /*ddA*/\r
+\r
+ \r
+ tgt_reset(prc->incltree);\r
+ tgt_reset(prc->imsbtree);\r
+ for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {\r
+ tcd_cblk_t *cblk = &prc->cblks[cblkno];\r
+ cblk->numsegs = 0;\r
+ }\r
+ }\r
+ }\r
+\r
+ \r
+\r
+ /* SOP markers*/\r
+\r
+ if (tcp->csty & J2K_CP_CSTY_SOP) {\r
+\r
+ if ((*c) != 0xff || (*(c + 1) != 0x91)) {\r
+\r
+ fprintf(stderr,"Warning : expected SOP marker\n");\r
+\r
+ } else {\r
+\r
+ c += 6;\r
+\r
+ }\r
+\r
+ /*TODO : check the Nsop value*/\r
+\r
+ }\r
+\r
+ /* When the marker PPT/PPM is used the packet header are store in PPT/PPM marker\r
+ This part deal with this caracteristic\r
+ step 1: Read packet header in the saved structure\r
+ step 2: Return to codestream for decoding */\r
+\r
+\r
+ if (cp->ppm == 1) { /* PPM */\r
+ hd = cp->ppm_data;\r
+ bio_init_dec(hd, cp->ppm_len); /*Mod Antonin : ppmbug1*/\r
+ } else if (tcp->ppt == 1) { /* PPT */\r
+ hd = tcp->ppt_data;\r
+ bio_init_dec(hd, tcp->ppt_len); /*Mod Antonin : ppmbug1*/\r
+ } else { /* Normal Case */\r
+\r
+ hd = c;\r
+\r
+ bio_init_dec(hd, src+len-hd);\r
+\r
+ }\r
+ \r
+ present = bio_read(1);\r
+\r
+ if (!present) {\r
+ bio_inalign();\r
+\r
+ hd += bio_numbytes();\r
+\r
+\r
+\r
+ /* EPH markers*/\r
+\r
+ if (tcp->csty & J2K_CP_CSTY_EPH) {\r
+\r
+ if ((*hd) != 0xff || (*(hd + 1) != 0x92)) {\r
+\r
+ printf("Error : expected EPH marker\n");\r
+\r
+ } else {\r
+\r
+ hd += 2;\r
+\r
+ }\r
+\r
+ }\r
+\r
+ if (cp->ppm == 1) { /* PPM case */\r
+\r
+ cp->ppm_len+=cp->ppm_data-hd;\r
+ cp->ppm_data = hd;\r
+ return c - src;\r
+ }\r
+ if (tcp->ppt == 1) { /* PPT case */\r
+\r
+ tcp->ppt_len+=tcp->ppt_data-hd;\r
+ tcp->ppt_data = hd;\r
+ return c - src;\r
+ }\r
+\r
+\r
+ return hd - src;\r
+ }\r
+\r
+\r
+ for (bandno = 0; bandno < res->numbands; bandno++) {\r
+ tcd_band_t *band = &res->bands[bandno];\r
+ tcd_precinct_t *prc = &band->precincts[precno];\r
+\r
+\r
+\r
+ /*Add Antonin : sizebug1*/\r
+\r
+ if ((band->x1-band->x0 == 0)||(band->y1-band->y0 == 0)) continue;\r
+\r
+ /*ddA*/\r
+\r
+\r
+ for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {\r
+ int included, increment, n;\r
+ tcd_cblk_t *cblk = &prc->cblks[cblkno];\r
+ tcd_seg_t *seg;\r
+ /* if cblk not yet included before --> inclusion tagtree */\r
+ if (!cblk->numsegs) {\r
+ included = tgt_decode(prc->incltree, cblkno, layno + 1);\r
+ /* else one bit */\r
+ } else {\r
+ included = bio_read(1);\r
+ }\r
+ /* if cblk not included */\r
+ if (!included) {\r
+ cblk->numnewpasses = 0;\r
+ continue;\r
+ }\r
+ /* if cblk not yet included --> zero-bitplane tagtree */\r
+ if (!cblk->numsegs) {\r
+ int i, numimsbs;\r
+ for (i = 0; !tgt_decode(prc->imsbtree, cblkno, i); i++) {\r
+ }\r
+ numimsbs = i - 1;\r
+ cblk->numbps = band->numbps - numimsbs;\r
+ cblk->numlenbits = 3;\r
+ }\r
+ /* number of coding passes */\r
+ cblk->numnewpasses = t2_getnumpasses();\r
+ increment = t2_getcommacode();\r
+ /* length indicator increment */\r
+ cblk->numlenbits += increment;\r
+ if (!cblk->numsegs) {\r
+ seg = &cblk->segs[0];\r
+ t2_init_seg(seg, tcp->tccps[compno].cblksty, 1);\r
+ } else {\r
+ seg = &cblk->segs[cblk->numsegs - 1];\r
+ if (seg->numpasses == seg->maxpasses) {\r
+ t2_init_seg(++seg, tcp->tccps[compno].cblksty, 0);\r
+ }\r
+ }\r
+ n = cblk->numnewpasses;\r
+\r
+ do {\r
+ seg->numnewpasses = int_min(seg->maxpasses - seg->numpasses, n);\r
+ seg->newlen =\r
+ bio_read(cblk->numlenbits + int_floorlog2(seg->numnewpasses));\r
+ n -= seg->numnewpasses;\r
+ if (n > 0) {\r
+ t2_init_seg(++seg, tcp->tccps[compno].cblksty, 0);\r
+ }\r
+ } while (n > 0);\r
+ }\r
+ }\r
+ if (bio_inalign())\r
+ return -999;\r
+\r
+ hd += bio_numbytes();\r
+\r
+\r
+ /* EPH markers*/\r
+ if (tcp->csty & J2K_CP_CSTY_EPH) {\r
+ if ((*hd) != 0xff || (*(hd + 1) != 0x92)) {\r
+ fprintf(stderr,"Error : expected EPH marker\n");\r
+ } else {\r
+ hd += 2;\r
+\r
+ }\r
+ }\r
+\r
+\r
+\r
+ if (cp->ppm==1) {\r
+\r
+ cp->ppm_len+=cp->ppm_data-hd;\r
+\r
+ cp->ppm_data = hd;\r
+\r
+ } else if (tcp->ppt == 1) {\r
+\r
+ tcp->ppt_len+=tcp->ppt_data-hd;\r
+\r
+ tcp->ppt_data = hd;\r
+\r
+ } else {\r
+\r
+ c=hd;\r
+\r
+ }\r
+\r
+ for (bandno = 0; bandno < res->numbands; bandno++) {\r
+ tcd_band_t *band = &res->bands[bandno];\r
+ tcd_precinct_t *prc = &band->precincts[precno];\r
+\r
+\r
+\r
+ /*Add Antonin : sizebug1*/\r
+\r
+ if ((band->x1-band->x0 == 0)||(band->y1-band->y0 == 0)) continue;\r
+\r
+ /*ddA*/\r
+\r
+\r
+ for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {\r
+ tcd_cblk_t *cblk = &prc->cblks[cblkno];\r
+ tcd_seg_t *seg;\r
+ if (!cblk->numnewpasses)\r
+ continue;\r
+ if (!cblk->numsegs) {\r
+ seg = &cblk->segs[0];\r
+\r
+ cblk->numsegs++;\r
+ cblk->len = 0;\r
+ } else {\r
+ seg = &cblk->segs[cblk->numsegs - 1];\r
+ if (seg->numpasses == seg->maxpasses) {\r
+ seg++;\r
+ cblk->numsegs++;\r
+ }\r
+ }\r
+ do {\r
+ if (c + seg->newlen > src + len) {\r
+ return -999;\r
+ }\r
+\r
+ memcpy(cblk->data + cblk->len, c, seg->newlen);\r
+ if (seg->numpasses == 0) {\r
+ seg->data = cblk->data + cblk->len;\r
+ }\r
+ c += seg->newlen;\r
+ cblk->len += seg->newlen;\r
+ seg->len += seg->newlen;\r
+ seg->numpasses += seg->numnewpasses;\r
+ cblk->numnewpasses -= seg->numnewpasses;\r
+ if (cblk->numnewpasses > 0) {\r
+ seg++;\r
+ cblk->numsegs++;\r
+ }\r
+ } while (cblk->numnewpasses > 0);\r
+ }\r
+ }\r
+\r
+ return c - src;\r
+}\r
+\r
+\r
+\r
+/*\r
+ * Encode the packets of a tile to a destination buffer\r
+ *\r
+ * img : the source image\r
+ * cp : the image coding parameters\r
+ * tileno : number of the tile encoded\r
+ * tile : the tile for which to write the packets\r
+ * maxlayers : maximum number of layers\r
+ * dest : the destination buffer\r
+ * len : the length of the destination buffer\r
+ * info_IM : structure to create an index file\r
+ */\r
+int t2_encode_packets(j2k_image_t * img, j2k_cp_t * cp, int tileno,\r
+ tcd_tile_t * tile, int maxlayers,\r
+ unsigned char *dest, int len, info_image * info_IM)\r
+{\r
+ unsigned char *c = dest;\r
+ int e = 0;\r
+ pi_iterator_t *pi;\r
+ int pino, compno;\r
+\r
+ pi = pi_create(img, cp, tileno);\r
+\r
+ for (pino = 0; pino <= cp->tcps[tileno].numpocs; pino++) {\r
+ while (pi_next(&pi[pino])) {\r
+ if (pi[pino].layno < maxlayers) {\r
+ e = t2_encode_packet(tile, &cp->tcps[tileno],\r
+ pi[pino].compno, pi[pino].resno,\r
+ pi[pino].precno, pi[pino].layno, c,\r
+ dest + len - c, info_IM, tileno);\r
+ if (e == -999) {\r
+ break;\r
+ } else\r
+ c += e;\r
+ /* INDEX >> */\r
+ if (info_IM->index_write && info_IM->index_on) {\r
+ info_tile *info_TL = &info_IM->tile[tileno];\r
+ info_packet *info_PK = &info_TL->packet[info_IM->num];\r
+ if (!info_IM->num) {\r
+ info_PK->start_pos = info_TL->end_header + 1;\r
+ } else {\r
+ info_PK->start_pos =\r
+ info_TL->packet[info_IM->num - 1].end_pos + 1;\r
+ }\r
+ info_PK->end_pos = info_PK->start_pos + e - 1;\r
+\r
+ }\r
+ /* << INDEX */\r
+ if ((info_IM->index_write\r
+ && cp->tcps[tileno].csty & J2K_CP_CSTY_SOP)\r
+ || (info_IM->index_write && info_IM->index_on)) {\r
+ info_IM->num++;\r
+ }\r
+ }\r
+\r
+ }\r
+\r
+ /* FREE space memory taken by pi */\r
+ for (compno = 0; compno < pi[pino].numcomps; compno++) {\r
+ free(pi[pino].comps[compno].resolutions);\r
+ }\r
+ free(pi[pino].comps);\r
+ }\r
+ free(pi[0].include);\r
+ free(pi);\r
+ if (e == -999)\r
+ return e;\r
+ else\r
+ return c - dest;\r
+}\r
+\r
+\r
+\r
+/*\r
+ * Decode the packets of a tile from a source buffer\r
+ *\r
+ * src: the source buffer\r
+ * len: length of the source buffer\r
+ * img: destination image\r
+ * cp: image coding parameters\r
+ * tileno: number that identifies the tile for which to decode the packets\r
+ * tile: tile for which to decode the packets\r
+ */\r
+int t2_decode_packets(unsigned char *src, int len, j2k_image_t * img,\r
+ j2k_cp_t * cp, int tileno, tcd_tile_t * tile)\r
+{\r
+ unsigned char *c = src;\r
+ pi_iterator_t *pi;\r
+ int pino, compno, e = 0;\r
+ int n = 0;\r
+\r
+ pi = pi_create(img, cp, tileno);\r
+\r
+ for (pino = 0; pino <= cp->tcps[tileno].numpocs; pino++) {\r
+ while (pi_next(&pi[pino])) {\r
+ \r
+ if ((cp->layer==0) || (cp->layer>=((pi[pino].layno)+1))) {\r
+ e = t2_decode_packet(c, src + len - c, tile, cp,\r
+ &cp->tcps[tileno], pi[pino].compno,\r
+ pi[pino].resno, pi[pino].precno,\r
+ pi[pino].layno);\r
+ } else {\r
+ e = 0;\r
+ }\r
+ \r
+ /* progression in resolution */\r
+ img->comps[pi[pino].compno].resno_decoded =\r
+ e > 0 ? int_max(pi[pino].resno,\r
+ img->comps[pi[pino].compno].\r
+ resno_decoded) : img->comps[pi[pino].\r
+ compno].resno_decoded;\r
+ n++;\r
+ \r
+ if (e == -999) { /* ADD */\r
+ break;\r
+ } else {\r
+ c += e;\r
+ }\r
+ }\r
+\r
+ /* FREE space memory taken by pi */\r
+ for (compno = 0; compno < pi[pino].numcomps; compno++) {\r
+ free(pi[pino].comps[compno].resolutions);\r
+ }\r
+ free(pi[pino].comps);\r
+ }\r
+ free(pi[0].include);\r
+ free(pi);\r
+\r
+ if (e == -999)\r
+ return e;\r
+ else\r
+ return c - src;\r
+}\r
--- /dev/null
+/*\r
+ * Copyright (c) 2001-2002, David Janssens\r
+ * Copyright (c) 2002-2003, Yannick Verschueren\r
+ * Copyright (c) 2002-2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+#ifndef __T2_H\r
+#define __T2_H\r
+\r
+#include "tcd.h"\r
+#include "j2k.h"\r
+\r
+/*\r
+ * Encode the packets of a tile to a destination buffer\r
+ *\r
+ * img : the source image\r
+ * cp : the image coding parameters\r
+ * tileno : number of the tile encoded\r
+ * tile : the tile for which to write the packets\r
+ * maxlayers : maximum number of layers\r
+ * dest : the destination buffer\r
+ * len : the length of the destination buffer\r
+ * info_IM : structure to create an index file\r
+ */\r
+int t2_encode_packets(j2k_image_t * img, j2k_cp_t * cp, int tileno,\r
+ tcd_tile_t * tile, int maxlayers,\r
+ unsigned char *dest, int len, info_image * info_IM);\r
+\r
+/*\r
+ * Decode the packets of a tile from a source buffer\r
+ *\r
+ * src: the source buffer\r
+ * len: length of the source buffer\r
+ * img: destination image\r
+ * cp: image coding parameters\r
+ * tileno: number that identifies the tile for which to decode the packets\r
+ * tile: tile for which to decode the packets\r
+ */\r
+int t2_decode_packets(unsigned char *src, int len, j2k_image_t * img,\r
+ j2k_cp_t * cp, int tileno, tcd_tile_t * tile);\r
+\r
+#endif\r
--- /dev/null
+/*\r
+ * Copyright (c) 2001-2002, David Janssens\r
+ * Copyright (c) 2002-2004, Yannick Verschueren\r
+ * Copyright (c) 2002-2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+#include "tcd.h"\r
+#include "int.h"\r
+#include "t1.h"\r
+#include "t2.h"\r
+#include "dwt.h"\r
+#include "mct.h"\r
+#include <setjmp.h>\r
+#include <float.h>\r
+#include <stdio.h>\r
+#include <time.h>\r
+#include <math.h>\r
+#include <stdlib.h>\r
+#include <string.h>\r
+\r
+static tcd_image_t tcd_image;\r
+\r
+static j2k_image_t *tcd_img;\r
+static j2k_cp_t *tcd_cp;\r
+\r
+static tcd_tile_t *tcd_tile;\r
+static j2k_tcp_t *tcd_tcp;\r
+static int tcd_tileno;\r
+\r
+static tcd_tile_t *tile;\r
+static tcd_tilecomp_t *tilec;\r
+static tcd_resolution_t *res;\r
+static tcd_band_t *band;\r
+static tcd_precinct_t *prc;\r
+static tcd_cblk_t *cblk;\r
+\r
+extern jmp_buf j2k_error;\r
+\r
+void tcd_dump(tcd_image_t * img, int curtileno)\r
+{\r
+ int tileno, compno, resno, bandno, precno, cblkno;\r
+ (void)curtileno;\r
+ fprintf(stdout, "image {\n");\r
+ fprintf(stdout, " tw=%d, th=%d x0=%d x1=%d y0=%d y1=%d\n", img->tw,\r
+ img->th, tcd_img->x0, tcd_img->x1, tcd_img->y0, tcd_img->y1);\r
+ for (tileno = 0; tileno < img->th * img->tw; tileno++) {\r
+ tcd_tile_t *tile = &tcd_image.tiles[tileno];\r
+ fprintf(stdout, " tile {\n");\r
+ fprintf(stdout, " x0=%d, y0=%d, x1=%d, y1=%d, numcomps=%d\n",\r
+ tile->x0, tile->y0, tile->x1, tile->y1, tile->numcomps);\r
+ for (compno = 0; compno < tile->numcomps; compno++) {\r
+ tcd_tilecomp_t *tilec = &tile->comps[compno];\r
+ fprintf(stdout, " tilec {\n");\r
+ fprintf(stdout,\r
+ " x0=%d, y0=%d, x1=%d, y1=%d, numresolutions=%d\n",\r
+ tilec->x0, tilec->y0, tilec->x1, tilec->y1,\r
+ tilec->numresolutions);\r
+ for (resno = 0; resno < tilec->numresolutions; resno++) {\r
+ tcd_resolution_t *res = &tilec->resolutions[resno];\r
+ fprintf(stdout, "\n res {\n");\r
+ fprintf(stdout,\r
+ " x0=%d, y0=%d, x1=%d, y1=%d, pw=%d, ph=%d, numbands=%d\n",\r
+ res->x0, res->y0, res->x1, res->y1, res->pw, res->ph,\r
+ res->numbands);\r
+ for (bandno = 0; bandno < res->numbands; bandno++) {\r
+ tcd_band_t *band = &res->bands[bandno];\r
+ fprintf(stdout, " band {\n");\r
+ fprintf(stdout,\r
+ " x0=%d, y0=%d, x1=%d, y1=%d, stepsize=%f, numbps=%d\n",\r
+ band->x0, band->y0, band->x1, band->y1,\r
+ band->stepsize, band->numbps);\r
+ for (precno = 0; precno < res->pw * res->ph; precno++) {\r
+ tcd_precinct_t *prec = &band->precincts[precno];\r
+ fprintf(stdout, " prec {\n");\r
+ fprintf(stdout,\r
+ " x0=%d, y0=%d, x1=%d, y1=%d, cw=%d, ch=%d\n",\r
+ prec->x0, prec->y0, prec->x1, prec->y1,\r
+ prec->cw, prec->ch);\r
+ for (cblkno = 0; cblkno < prec->cw * prec->ch; cblkno++) {\r
+ tcd_cblk_t *cblk = &prec->cblks[cblkno];\r
+ fprintf(stdout, " cblk {\n");\r
+ fprintf(stdout,\r
+ " x0=%d, y0=%d, x1=%d, y1=%d\n",\r
+ cblk->x0, cblk->y0, cblk->x1, cblk->y1);\r
+ fprintf(stdout, " }\n");\r
+ }\r
+ fprintf(stdout, " }\n");\r
+ }\r
+ fprintf(stdout, " }\n");\r
+ }\r
+ fprintf(stdout, " }\n");\r
+ }\r
+ fprintf(stdout, " }\n");\r
+ }\r
+ fprintf(stdout, " }\n");\r
+ }\r
+ fprintf(stdout, "}\n");\r
+}\r
+\r
+void tcd_malloc_encode(j2k_image_t * img, j2k_cp_t * cp, int curtileno)\r
+{\r
+ int tileno, compno, resno, bandno, precno, cblkno;\r
+ tcd_img = img;\r
+ tcd_cp = cp;\r
+ tcd_image.tw = cp->tw;\r
+ tcd_image.th = cp->th;\r
+ tcd_image.tiles = (tcd_tile_t *) malloc(sizeof(tcd_tile_t));\r
+\r
+ for (tileno = 0; tileno < 1; tileno++) {\r
+ j2k_tcp_t *tcp = &cp->tcps[curtileno];\r
+ int j;\r
+ /* cfr p59 ISO/IEC FDIS15444-1 : 2000 (18 august 2000) */\r
+ int p = curtileno % cp->tw; /* si numerotation matricielle .. */\r
+ int q = curtileno / cp->tw; /* .. coordonnees de la tile (q,p) q pour ligne et p pour colonne */\r
+ /* tcd_tile_t *tile=&tcd_image.tiles[tileno]; */\r
+ tile = tcd_image.tiles;\r
+ /* 4 borders of the tile rescale on the image if necessary */\r
+ tile->x0 = int_max(cp->tx0 + p * cp->tdx, img->x0);\r
+ tile->y0 = int_max(cp->ty0 + q * cp->tdy, img->y0);\r
+ tile->x1 = int_min(cp->tx0 + (p + 1) * cp->tdx, img->x1);\r
+ tile->y1 = int_min(cp->ty0 + (q + 1) * cp->tdy, img->y1);\r
+ tile->numcomps = img->numcomps;\r
+ /* tile->PPT=img->PPT; */\r
+ /* Modification of the RATE >> */\r
+ for (j = 0; j < tcp->numlayers; j++) {\r
+ tcp->rates[j] = tcp->rates[j] ? int_ceildiv(tile->numcomps * (tile->x1 - tile->x0) * (tile->y1 - tile->y0) * img->comps[0].prec, (tcp->rates[j] * 8 * img->comps[0].dx * img->comps[0].dy)) : 0; /*Mod antonin losslessbug*/\r
+ if (tcp->rates[j]) {\r
+ if (j && tcp->rates[j] < tcp->rates[j - 1] + 10) {\r
+ tcp->rates[j] = tcp->rates[j - 1] + 20;\r
+ } else {\r
+ if (!j && tcp->rates[j] < 30)\r
+ tcp->rates[j] = 30;\r
+ }\r
+ }\r
+ }\r
+ /* << Modification of the RATE */\r
+\r
+ tile->comps =\r
+ (tcd_tilecomp_t *) malloc(img->numcomps * sizeof(tcd_tilecomp_t));\r
+ for (compno = 0; compno < tile->numcomps; compno++) {\r
+ j2k_tccp_t *tccp = &tcp->tccps[compno];\r
+ /* tcd_tilecomp_t *tilec=&tile->comps[compno]; */\r
+ tilec = &tile->comps[compno];\r
+ /* border of each tile component (global) */\r
+ tilec->x0 = int_ceildiv(tile->x0, img->comps[compno].dx);\r
+\r
+ tilec->y0 = int_ceildiv(tile->y0, img->comps[compno].dy);\r
+ tilec->x1 = int_ceildiv(tile->x1, img->comps[compno].dx);\r
+ tilec->y1 = int_ceildiv(tile->y1, img->comps[compno].dy);\r
+\r
+ tilec->data =\r
+ (int *) malloc((tilec->x1 - tilec->x0) *\r
+ (tilec->y1 - tilec->y0) * sizeof(int));\r
+ tilec->numresolutions = tccp->numresolutions;\r
+\r
+ tilec->resolutions =\r
+ (tcd_resolution_t *) malloc(tilec->numresolutions *\r
+ sizeof(tcd_resolution_t));\r
+\r
+ for (resno = 0; resno < tilec->numresolutions; resno++) {\r
+ int pdx, pdy;\r
+ int levelno = tilec->numresolutions - 1 - resno;\r
+ int tlprcxstart, tlprcystart, brprcxend, brprcyend;\r
+ int tlcbgxstart, tlcbgystart, brcbgxend, brcbgyend;\r
+ int cbgwidthexpn, cbgheightexpn;\r
+ int cblkwidthexpn, cblkheightexpn;\r
+ /* tcd_resolution_t *res=&tilec->resolutions[resno]; */\r
+\r
+ res = &tilec->resolutions[resno];\r
+\r
+ /* border for each resolution level (global) */\r
+ res->x0 = int_ceildivpow2(tilec->x0, levelno);\r
+ res->y0 = int_ceildivpow2(tilec->y0, levelno);\r
+ res->x1 = int_ceildivpow2(tilec->x1, levelno);\r
+ res->y1 = int_ceildivpow2(tilec->y1, levelno);\r
+\r
+ res->numbands = resno == 0 ? 1 : 3;\r
+ /* p. 35, table A-23, ISO/IEC FDIS154444-1 : 2000 (18 august 2000) */\r
+ if (tccp->csty & J2K_CCP_CSTY_PRT) {\r
+ pdx = tccp->prcw[resno];\r
+ pdy = tccp->prch[resno];\r
+ } else {\r
+ pdx = 15;\r
+ pdy = 15;\r
+ }\r
+ /* p. 64, B.6, ISO/IEC FDIS15444-1 : 2000 (18 august 2000) */\r
+ tlprcxstart = int_floordivpow2(res->x0, pdx) << pdx;\r
+ tlprcystart = int_floordivpow2(res->y0, pdy) << pdy;\r
+ brprcxend = int_ceildivpow2(res->x1, pdx) << pdx;\r
+ brprcyend = int_ceildivpow2(res->y1, pdy) << pdy;\r
+\r
+ res->pw = (brprcxend - tlprcxstart) >> pdx;\r
+ res->ph = (brprcyend - tlprcystart) >> pdy;\r
+\r
+ if (resno == 0) {\r
+ tlcbgxstart = tlprcxstart;\r
+ tlcbgystart = tlprcystart;\r
+ brcbgxend = brprcxend;\r
+ brcbgyend = brprcyend;\r
+ cbgwidthexpn = pdx;\r
+ cbgheightexpn = pdy;\r
+ } else {\r
+ tlcbgxstart = int_ceildivpow2(tlprcxstart, 1);\r
+ tlcbgystart = int_ceildivpow2(tlprcystart, 1);\r
+ brcbgxend = int_ceildivpow2(brprcxend, 1);\r
+ brcbgyend = int_ceildivpow2(brprcyend, 1);\r
+ cbgwidthexpn = pdx - 1;\r
+ cbgheightexpn = pdy - 1;\r
+ }\r
+\r
+ cblkwidthexpn = int_min(tccp->cblkw, cbgwidthexpn);\r
+ cblkheightexpn = int_min(tccp->cblkh, cbgheightexpn);\r
+\r
+ for (bandno = 0; bandno < res->numbands; bandno++) {\r
+ int x0b, y0b, i;\r
+ int gain, numbps;\r
+ j2k_stepsize_t *ss;\r
+ band = &res->bands[bandno];\r
+ band->bandno = resno == 0 ? 0 : bandno + 1;\r
+ x0b = (band->bandno == 1) || (band->bandno == 3) ? 1 : 0;\r
+ y0b = (band->bandno == 2) || (band->bandno == 3) ? 1 : 0;\r
+\r
+ if (band->bandno == 0) {\r
+ /* band border (global) */\r
+ band->x0 = int_ceildivpow2(tilec->x0, levelno);\r
+ band->y0 = int_ceildivpow2(tilec->y0, levelno);\r
+ band->x1 = int_ceildivpow2(tilec->x1, levelno);\r
+ band->y1 = int_ceildivpow2(tilec->y1, levelno);\r
+ } else {\r
+ /* band border (global) */\r
+ band->x0 =\r
+ int_ceildivpow2(tilec->x0 -\r
+ (1 << levelno) * x0b, levelno + 1);\r
+ band->y0 =\r
+ int_ceildivpow2(tilec->y0 -\r
+ (1 << levelno) * y0b, levelno + 1);\r
+ band->x1 =\r
+ int_ceildivpow2(tilec->x1 -\r
+ (1 << levelno) * x0b, levelno + 1);\r
+ band->y1 =\r
+ int_ceildivpow2(tilec->y1 -\r
+ (1 << levelno) * y0b, levelno + 1);\r
+\r
+ }\r
+\r
+ ss = &tccp->stepsizes[resno ==\r
+ 0 ? 0 : 3 * (resno - 1) + bandno + 1];\r
+ gain =\r
+ tccp->qmfbid ==\r
+ 0 ? dwt_getgain_real(band->bandno) : dwt_getgain(band->bandno);\r
+ numbps = img->comps[compno].prec + gain;\r
+ band->stepsize = (float)((1.0 + ss->mant / 2048.0) * pow(2.0, numbps - ss->expn));\r
+ band->numbps = ss->expn + tccp->numgbits - 1; /* WHY -1 ? */\r
+\r
+ band->precincts =\r
+ (tcd_precinct_t *) malloc(3 * res->pw * res->ph *\r
+ sizeof(tcd_precinct_t));\r
+\r
+ for (i = 0; i < res->pw * res->ph * 3; i++) {\r
+ band->precincts[i].imsbtree = NULL;\r
+ band->precincts[i].incltree = NULL;\r
+ }\r
+\r
+ for (precno = 0; precno < res->pw * res->ph; precno++) {\r
+ int tlcblkxstart, tlcblkystart, brcblkxend, brcblkyend;\r
+ int cbgxstart =\r
+ tlcbgxstart + (precno % res->pw) * (1 << cbgwidthexpn);\r
+ int cbgystart =\r
+ tlcbgystart + (precno / res->pw) * (1 << cbgheightexpn);\r
+ int cbgxend = cbgxstart + (1 << cbgwidthexpn);\r
+ int cbgyend = cbgystart + (1 << cbgheightexpn);\r
+ /* tcd_precinct_t *prc=&band->precincts[precno]; */\r
+ prc = &band->precincts[precno];\r
+ /* precinct size (global) */\r
+ prc->x0 = int_max(cbgxstart, band->x0);\r
+ prc->y0 = int_max(cbgystart, band->y0);\r
+ prc->x1 = int_min(cbgxend, band->x1);\r
+ prc->y1 = int_min(cbgyend, band->y1);\r
+\r
+ tlcblkxstart =\r
+ int_floordivpow2(prc->x0, cblkwidthexpn) << cblkwidthexpn;\r
+ tlcblkystart =\r
+ int_floordivpow2(prc->y0, cblkheightexpn) << cblkheightexpn;\r
+ brcblkxend =\r
+ int_ceildivpow2(prc->x1, cblkwidthexpn) << cblkwidthexpn;\r
+ brcblkyend =\r
+ int_ceildivpow2(prc->y1, cblkheightexpn) << cblkheightexpn;\r
+ prc->cw = (brcblkxend - tlcblkxstart) >> cblkwidthexpn;\r
+ prc->ch = (brcblkyend - tlcblkystart) >> cblkheightexpn;\r
+\r
+ prc->cblks =\r
+ (tcd_cblk_t *) malloc((prc->cw * prc->ch) *\r
+ sizeof(tcd_cblk_t));\r
+ prc->incltree = tgt_create(prc->cw, prc->ch);\r
+ prc->imsbtree = tgt_create(prc->cw, prc->ch);\r
+\r
+ for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {\r
+ int cblkxstart =\r
+ tlcblkxstart + (cblkno % prc->cw) * (1 << cblkwidthexpn);\r
+ int cblkystart =\r
+ tlcblkystart + (cblkno / prc->cw) * (1 << cblkheightexpn);\r
+ int cblkxend = cblkxstart + (1 << cblkwidthexpn);\r
+ int cblkyend = cblkystart + (1 << cblkheightexpn);\r
+\r
+ cblk = &prc->cblks[cblkno];\r
+ /* code-block size (global) */\r
+ cblk->x0 = int_max(cblkxstart, prc->x0);\r
+ cblk->y0 = int_max(cblkystart, prc->y0);\r
+ cblk->x1 = int_min(cblkxend, prc->x1);\r
+ cblk->y1 = int_min(cblkyend, prc->y1);\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ /* tcd_dump(&tcd_image,curtileno); */\r
+}\r
+\r
+void tcd_free_encode(j2k_image_t * img, j2k_cp_t * cp, int curtileno)\r
+{\r
+ int tileno, compno, resno, bandno, precno;\r
+ (void)curtileno;\r
+ tcd_img = img;\r
+ tcd_cp = cp;\r
+ tcd_image.tw = cp->tw;\r
+ tcd_image.th = cp->th;\r
+ for (tileno = 0; tileno < 1; tileno++) {\r
+ /* j2k_tcp_t *tcp=&cp->tcps[curtileno]; */\r
+ tile = tcd_image.tiles;\r
+ for (compno = 0; compno < tile->numcomps; compno++) {\r
+ tilec = &tile->comps[compno];\r
+ for (resno = 0; resno < tilec->numresolutions; resno++) {\r
+ res = &tilec->resolutions[resno];\r
+ for (bandno = 0; bandno < res->numbands; bandno++) {\r
+ band = &res->bands[bandno];\r
+ for (precno = 0; precno < res->pw * res->ph; precno++) {\r
+ prc = &band->precincts[precno];\r
+\r
+ if (prc->incltree != NULL)\r
+ tgt_destroy(prc->incltree);\r
+ if (prc->imsbtree != NULL)\r
+ tgt_destroy(prc->imsbtree);\r
+ free(prc->cblks);\r
+ } /* for (precno */\r
+ free(band->precincts);\r
+ } /* for (bandno */\r
+ } /* for (resno */\r
+ free(tilec->resolutions);\r
+ } /* for (compno */\r
+ free(tile->comps);\r
+ } /* for (tileno */\r
+ free(tcd_image.tiles);\r
+}\r
+\r
+void tcd_init_encode(j2k_image_t * img, j2k_cp_t * cp, int curtileno)\r
+{\r
+ int tileno, compno, resno, bandno, precno, cblkno;\r
+\r
+ for (tileno = 0; tileno < 1; tileno++) {\r
+ j2k_tcp_t *tcp = &cp->tcps[curtileno];\r
+ int j;\r
+ /* int previous_x0, previous_x1, previous_y0, previous_y1;*/\r
+ /* cfr p59 ISO/IEC FDIS15444-1 : 2000 (18 august 2000) */\r
+ int p = curtileno % cp->tw;\r
+ int q = curtileno / cp->tw;\r
+ tile = tcd_image.tiles;\r
+\r
+ /* 4 borders of the tile rescale on the image if necessary */\r
+ tile->x0 = int_max(cp->tx0 + p * cp->tdx, img->x0);\r
+ tile->y0 = int_max(cp->ty0 + q * cp->tdy, img->y0);\r
+ tile->x1 = int_min(cp->tx0 + (p + 1) * cp->tdx, img->x1);\r
+ tile->y1 = int_min(cp->ty0 + (q + 1) * cp->tdy, img->y1);\r
+\r
+ tile->numcomps = img->numcomps;\r
+ /* tile->PPT=img->PPT; */\r
+ /* Modification of the RATE >> */\r
+ for (j = 0; j < tcp->numlayers; j++) {\r
+ tcp->rates[j] = tcp->rates[j] ? int_ceildiv(tile->numcomps * (tile->x1 - tile->x0) * (tile->y1 - tile->y0) * img->comps[0].prec, (tcp->rates[j] * 8 * img->comps[0].dx * img->comps[0].dy)) : 0; /*Mod antonin losslessbug*/\r
+ if (tcp->rates[j]) {\r
+ if (j && tcp->rates[j] < tcp->rates[j - 1] + 10) {\r
+ tcp->rates[j] = tcp->rates[j - 1] + 20;\r
+ } else {\r
+ if (!j && tcp->rates[j] < 30)\r
+ tcp->rates[j] = 30;\r
+ }\r
+ }\r
+ }\r
+ /* << Modification of the RATE */\r
+ /* tile->comps=(tcd_tilecomp_t*)realloc(tile->comps,img->numcomps*sizeof(tcd_tilecomp_t)); */\r
+ for (compno = 0; compno < tile->numcomps; compno++) {\r
+ j2k_tccp_t *tccp = &tcp->tccps[compno];\r
+ /* int realloc_op; */\r
+\r
+ tilec = &tile->comps[compno];\r
+ /* border of each tile component (global) */\r
+ tilec->x0 = int_ceildiv(tile->x0, img->comps[compno].dx);\r
+ tilec->y0 = int_ceildiv(tile->y0, img->comps[compno].dy);\r
+ tilec->x1 = int_ceildiv(tile->x1, img->comps[compno].dx);\r
+ tilec->y1 = int_ceildiv(tile->y1, img->comps[compno].dy);\r
+\r
+ tilec->data =\r
+ (int *) malloc((tilec->x1 - tilec->x0) *\r
+ (tilec->y1 - tilec->y0) * sizeof(int));\r
+ tilec->numresolutions = tccp->numresolutions;\r
+ /* tilec->resolutions=(tcd_resolution_t*)realloc(tilec->resolutions,tilec->numresolutions*sizeof(tcd_resolution_t)); */\r
+ for (resno = 0; resno < tilec->numresolutions; resno++) {\r
+ int pdx, pdy;\r
+ int levelno = tilec->numresolutions - 1 - resno;\r
+ int tlprcxstart, tlprcystart, brprcxend, brprcyend;\r
+ int tlcbgxstart, tlcbgystart, brcbgxend, brcbgyend;\r
+ int cbgwidthexpn, cbgheightexpn;\r
+ int cblkwidthexpn, cblkheightexpn;\r
+\r
+ res = &tilec->resolutions[resno];\r
+ /* border for each resolution level (global) */\r
+ res->x0 = int_ceildivpow2(tilec->x0, levelno);\r
+ res->y0 = int_ceildivpow2(tilec->y0, levelno);\r
+ res->x1 = int_ceildivpow2(tilec->x1, levelno);\r
+ res->y1 = int_ceildivpow2(tilec->y1, levelno);\r
+\r
+ res->numbands = resno == 0 ? 1 : 3;\r
+ /* p. 35, table A-23, ISO/IEC FDIS154444-1 : 2000 (18 august 2000) */\r
+ if (tccp->csty & J2K_CCP_CSTY_PRT) {\r
+ pdx = tccp->prcw[resno];\r
+ pdy = tccp->prch[resno];\r
+ } else {\r
+ pdx = 15;\r
+ pdy = 15;\r
+ }\r
+ /* p. 64, B.6, ISO/IEC FDIS15444-1 : 2000 (18 august 2000) */\r
+ tlprcxstart = int_floordivpow2(res->x0, pdx) << pdx;\r
+ tlprcystart = int_floordivpow2(res->y0, pdy) << pdy;\r
+ brprcxend = int_ceildivpow2(res->x1, pdx) << pdx;\r
+ brprcyend = int_ceildivpow2(res->y1, pdy) << pdy;\r
+\r
+ res->pw = (brprcxend - tlprcxstart) >> pdx;\r
+ res->ph = (brprcyend - tlprcystart) >> pdy;\r
+\r
+ if (resno == 0) {\r
+ tlcbgxstart = tlprcxstart;\r
+ tlcbgystart = tlprcystart;\r
+ brcbgxend = brprcxend;\r
+ brcbgyend = brprcyend;\r
+ cbgwidthexpn = pdx;\r
+ cbgheightexpn = pdy;\r
+ } else {\r
+ tlcbgxstart = int_ceildivpow2(tlprcxstart, 1);\r
+ tlcbgystart = int_ceildivpow2(tlprcystart, 1);\r
+ brcbgxend = int_ceildivpow2(brprcxend, 1);\r
+ brcbgyend = int_ceildivpow2(brprcyend, 1);\r
+ cbgwidthexpn = pdx - 1;\r
+ cbgheightexpn = pdy - 1;\r
+ }\r
+\r
+ cblkwidthexpn = int_min(tccp->cblkw, cbgwidthexpn);\r
+ cblkheightexpn = int_min(tccp->cblkh, cbgheightexpn);\r
+\r
+ for (bandno = 0; bandno < res->numbands; bandno++) {\r
+ int x0b, y0b;\r
+ int gain, numbps;\r
+ j2k_stepsize_t *ss;\r
+ band = &res->bands[bandno];\r
+ band->bandno = resno == 0 ? 0 : bandno + 1;\r
+ x0b = (band->bandno == 1) || (band->bandno == 3) ? 1 : 0;\r
+ y0b = (band->bandno == 2) || (band->bandno == 3) ? 1 : 0;\r
+\r
+ if (band->bandno == 0) {\r
+ /* band border */\r
+ band->x0 = int_ceildivpow2(tilec->x0, levelno);\r
+ band->y0 = int_ceildivpow2(tilec->y0, levelno);\r
+ band->x1 = int_ceildivpow2(tilec->x1, levelno);\r
+ band->y1 = int_ceildivpow2(tilec->y1, levelno);\r
+ } else {\r
+ band->x0 =\r
+ int_ceildivpow2(tilec->x0 -\r
+ (1 << levelno) * x0b, levelno + 1);\r
+ band->y0 =\r
+ int_ceildivpow2(tilec->y0 -\r
+ (1 << levelno) * y0b, levelno + 1);\r
+ band->x1 =\r
+ int_ceildivpow2(tilec->x1 -\r
+ (1 << levelno) * x0b, levelno + 1);\r
+ band->y1 =\r
+ int_ceildivpow2(tilec->y1 -\r
+ (1 << levelno) * y0b, levelno + 1);\r
+ }\r
+\r
+ ss = &tccp->stepsizes[resno ==\r
+ 0 ? 0 : 3 * (resno - 1) + bandno + 1];\r
+ gain =\r
+ tccp->qmfbid ==\r
+ 0 ? dwt_getgain_real(band->bandno) : dwt_getgain(band->bandno);\r
+ numbps = img->comps[compno].prec + gain;\r
+ band->stepsize = (float)((1.0 + ss->mant / 2048.0) * pow(2.0, numbps - ss->expn));\r
+ band->numbps = ss->expn + tccp->numgbits - 1; /* WHY -1 ? */\r
+\r
+ for (precno = 0; precno < res->pw * res->ph; precno++) {\r
+ int tlcblkxstart, tlcblkystart, brcblkxend, brcblkyend;\r
+ int cbgxstart =\r
+ tlcbgxstart + (precno % res->pw) * (1 << cbgwidthexpn);\r
+ int cbgystart =\r
+ tlcbgystart + (precno / res->pw) * (1 << cbgheightexpn);\r
+ int cbgxend = cbgxstart + (1 << cbgwidthexpn);\r
+ int cbgyend = cbgystart + (1 << cbgheightexpn);\r
+\r
+ prc = &band->precincts[precno];\r
+ /* precinct size (global) */\r
+ prc->x0 = int_max(cbgxstart, band->x0);\r
+ prc->y0 = int_max(cbgystart, band->y0);\r
+ prc->x1 = int_min(cbgxend, band->x1);\r
+ prc->y1 = int_min(cbgyend, band->y1);\r
+\r
+ tlcblkxstart =\r
+ int_floordivpow2(prc->x0, cblkwidthexpn) << cblkwidthexpn;\r
+ tlcblkystart =\r
+ int_floordivpow2(prc->y0, cblkheightexpn) << cblkheightexpn;\r
+ brcblkxend =\r
+ int_ceildivpow2(prc->x1, cblkwidthexpn) << cblkwidthexpn;\r
+ brcblkyend =\r
+ int_ceildivpow2(prc->y1, cblkheightexpn) << cblkheightexpn;\r
+ prc->cw = (brcblkxend - tlcblkxstart) >> cblkwidthexpn;\r
+ prc->ch = (brcblkyend - tlcblkystart) >> cblkheightexpn;\r
+\r
+ free(prc->cblks);\r
+ prc->cblks =\r
+ (tcd_cblk_t *) malloc(prc->cw * prc->ch *\r
+ sizeof(tcd_cblk_t));\r
+\r
+ if (prc->incltree != NULL)\r
+ tgt_destroy(prc->incltree);\r
+ if (prc->imsbtree != NULL)\r
+ tgt_destroy(prc->imsbtree);\r
+\r
+ prc->incltree = tgt_create(prc->cw, prc->ch);\r
+ prc->imsbtree = tgt_create(prc->cw, prc->ch);\r
+\r
+ for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {\r
+ int cblkxstart =\r
+ tlcblkxstart + (cblkno % prc->cw) * (1 << cblkwidthexpn);\r
+ int cblkystart =\r
+ tlcblkystart + (cblkno / prc->cw) * (1 << cblkheightexpn);\r
+ int cblkxend = cblkxstart + (1 << cblkwidthexpn);\r
+ int cblkyend = cblkystart + (1 << cblkheightexpn);\r
+ cblk = &prc->cblks[cblkno];\r
+\r
+ /* code-block size (global) */\r
+ cblk->x0 = int_max(cblkxstart, prc->x0);\r
+ cblk->y0 = int_max(cblkystart, prc->y0);\r
+ cblk->x1 = int_min(cblkxend, prc->x1);\r
+ cblk->y1 = int_min(cblkyend, prc->y1);\r
+\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ /* tcd_dump(&tcd_image,0); */\r
+}\r
+\r
+void tcd_init(j2k_image_t * img, j2k_cp_t * cp)\r
+{\r
+ int tileno, compno, resno, bandno, precno, cblkno, i, j, p, q;\r
+ unsigned int x0 = 0, y0 = 0, x1 = 0, y1 = 0, w, h;\r
+ tcd_img = img;\r
+ tcd_cp = cp;\r
+ tcd_image.tw = cp->tw;\r
+ tcd_image.th = cp->th;\r
+ tcd_image.tiles =\r
+ (tcd_tile_t *) malloc(cp->tw * cp->th * sizeof(tcd_tile_t));\r
+\r
+ /*for (tileno = 0; tileno < cp->tw * cp->th; tileno++) {\r
+ j2k_tcp_t *tcp = &cp->tcps[tileno];\r
+ tcd_tile_t *tile = &tcd_image.tiles[tileno]; */\r
+\r
+ for (i = 0; i < cp->tileno_size; i++) {\r
+ j2k_tcp_t *tcp = &cp->tcps[cp->tileno[i]];\r
+ tcd_tile_t *tile = &tcd_image.tiles[cp->tileno[i]];\r
+ tileno = cp->tileno[i];\r
+\r
+\r
+ /* int previous_x0, previous_x1, previous_y0, previous_y1;*/\r
+ /* cfr p59 ISO/IEC FDIS15444-1 : 2000 (18 august 2000) */\r
+ p = tileno % cp->tw; /* si numerotation matricielle .. */\r
+ q = tileno / cp->tw; /* .. coordonnees de la tile (q,p) q pour ligne et p pour colonne */\r
+\r
+ /* 4 borders of the tile rescale on the image if necessary */\r
+ tile->x0 = int_max(cp->tx0 + p * cp->tdx, img->x0);\r
+ tile->y0 = int_max(cp->ty0 + q * cp->tdy, img->y0);\r
+ tile->x1 = int_min(cp->tx0 + (p + 1) * cp->tdx, img->x1);\r
+ tile->y1 = int_min(cp->ty0 + (q + 1) * cp->tdy, img->y1);\r
+\r
+ tile->numcomps = img->numcomps;\r
+ tile->comps =\r
+ (tcd_tilecomp_t *) malloc(img->numcomps * sizeof(tcd_tilecomp_t));\r
+ for (compno = 0; compno < tile->numcomps; compno++) {\r
+ j2k_tccp_t *tccp = &tcp->tccps[compno];\r
+ tcd_tilecomp_t *tilec = &tile->comps[compno];\r
+ /* border of each tile component (global) */\r
+ tilec->x0 = int_ceildiv(tile->x0, img->comps[compno].dx);\r
+ tilec->y0 = int_ceildiv(tile->y0, img->comps[compno].dy);\r
+ tilec->x1 = int_ceildiv(tile->x1, img->comps[compno].dx);\r
+ tilec->y1 = int_ceildiv(tile->y1, img->comps[compno].dy);\r
+\r
+ tilec->data =\r
+ (int *) malloc((tilec->x1 - tilec->x0) *\r
+ (tilec->y1 - tilec->y0) * sizeof(int));\r
+ tilec->numresolutions = tccp->numresolutions;\r
+ tilec->resolutions =\r
+ (tcd_resolution_t *) malloc(tilec->numresolutions *\r
+ sizeof(tcd_resolution_t));\r
+ for (resno = 0; resno < tilec->numresolutions; resno++) {\r
+ int pdx, pdy;\r
+ int levelno = tilec->numresolutions - 1 - resno;\r
+ int tlprcxstart, tlprcystart, brprcxend, brprcyend;\r
+ int tlcbgxstart, tlcbgystart, brcbgxend, brcbgyend;\r
+ int cbgwidthexpn, cbgheightexpn;\r
+ int cblkwidthexpn, cblkheightexpn;\r
+ tcd_resolution_t *res = &tilec->resolutions[resno];\r
+\r
+ /* border for each resolution level (global) */\r
+ res->x0 = int_ceildivpow2(tilec->x0, levelno);\r
+ res->y0 = int_ceildivpow2(tilec->y0, levelno);\r
+ res->x1 = int_ceildivpow2(tilec->x1, levelno);\r
+ res->y1 = int_ceildivpow2(tilec->y1, levelno);\r
+\r
+ res->numbands = resno == 0 ? 1 : 3;\r
+ /* p. 35, table A-23, ISO/IEC FDIS154444-1 : 2000 (18 august 2000) */\r
+ if (tccp->csty & J2K_CCP_CSTY_PRT) {\r
+ pdx = tccp->prcw[resno];\r
+ pdy = tccp->prch[resno];\r
+ } else {\r
+ pdx = 15;\r
+ pdy = 15;\r
+ }\r
+ /* p. 64, B.6, ISO/IEC FDIS15444-1 : 2000 (18 august 2000) */\r
+ tlprcxstart = int_floordivpow2(res->x0, pdx) << pdx;\r
+ tlprcystart = int_floordivpow2(res->y0, pdy) << pdy;\r
+ brprcxend = int_ceildivpow2(res->x1, pdx) << pdx;\r
+ brprcyend = int_ceildivpow2(res->y1, pdy) << pdy;\r
+ res->pw = (res->x0 == res->x1) ? 0 : ((brprcxend - tlprcxstart) >> pdx); /* Mod Antonin : sizebug1*/\r
+ res->ph = (res->y0 == res->y1) ? 0 : ((brprcyend - tlprcystart) >> pdy); /* Mod Antonin : sizebug1*/\r
+\r
+ if (resno == 0) {\r
+ tlcbgxstart = tlprcxstart;\r
+ tlcbgystart = tlprcystart;\r
+ brcbgxend = brprcxend;\r
+ brcbgyend = brprcyend;\r
+ cbgwidthexpn = pdx;\r
+ cbgheightexpn = pdy;\r
+ } else {\r
+ tlcbgxstart = int_ceildivpow2(tlprcxstart, 1);\r
+ tlcbgystart = int_ceildivpow2(tlprcystart, 1);\r
+ brcbgxend = int_ceildivpow2(brprcxend, 1);\r
+ brcbgyend = int_ceildivpow2(brprcyend, 1);\r
+ cbgwidthexpn = pdx - 1;\r
+ cbgheightexpn = pdy - 1;\r
+ }\r
+\r
+ cblkwidthexpn = int_min(tccp->cblkw, cbgwidthexpn);\r
+ cblkheightexpn = int_min(tccp->cblkh, cbgheightexpn);\r
+\r
+ for (bandno = 0; bandno < res->numbands; bandno++) {\r
+ int x0b, y0b;\r
+ int gain, numbps;\r
+ j2k_stepsize_t *ss;\r
+ tcd_band_t *band = &res->bands[bandno];\r
+ band->bandno = resno == 0 ? 0 : bandno + 1;\r
+ x0b = (band->bandno == 1) || (band->bandno == 3) ? 1 : 0;\r
+ y0b = (band->bandno == 2) || (band->bandno == 3) ? 1 : 0;\r
+\r
+ if (band->bandno == 0) {\r
+ /* band border (global) */\r
+ band->x0 = int_ceildivpow2(tilec->x0, levelno);\r
+ band->y0 = int_ceildivpow2(tilec->y0, levelno);\r
+ band->x1 = int_ceildivpow2(tilec->x1, levelno);\r
+ band->y1 = int_ceildivpow2(tilec->y1, levelno);\r
+ } else {\r
+ /* band border (global) */\r
+ band->x0 =\r
+ int_ceildivpow2(tilec->x0 -\r
+ (1 << levelno) * x0b, levelno + 1);\r
+ band->y0 =\r
+ int_ceildivpow2(tilec->y0 -\r
+ (1 << levelno) * y0b, levelno + 1);\r
+ band->x1 =\r
+ int_ceildivpow2(tilec->x1 -\r
+ (1 << levelno) * x0b, levelno + 1);\r
+ band->y1 =\r
+ int_ceildivpow2(tilec->y1 -\r
+ (1 << levelno) * y0b, levelno + 1);\r
+ }\r
+\r
+ ss = &tccp->stepsizes[resno ==\r
+ 0 ? 0 : 3 * (resno - 1) + bandno + 1];\r
+ gain =\r
+ tccp->qmfbid ==\r
+ 0 ? dwt_getgain_real(band->bandno) : dwt_getgain(band->bandno);\r
+ numbps = img->comps[compno].prec + gain;\r
+ band->stepsize = (float)((1.0 + ss->mant / 2048.0) * pow(2.0, numbps - ss->expn));\r
+ band->numbps = ss->expn + tccp->numgbits - 1; /* WHY -1 ? */\r
+\r
+ band->precincts =\r
+ (tcd_precinct_t *) malloc(res->pw * res->ph *\r
+ sizeof(tcd_precinct_t));\r
+\r
+ for (precno = 0; precno < res->pw * res->ph; precno++) {\r
+ int tlcblkxstart, tlcblkystart, brcblkxend, brcblkyend;\r
+ int cbgxstart =\r
+ tlcbgxstart + (precno % res->pw) * (1 << cbgwidthexpn);\r
+ int cbgystart =\r
+ tlcbgystart + (precno / res->pw) * (1 << cbgheightexpn);\r
+ int cbgxend = cbgxstart + (1 << cbgwidthexpn);\r
+ int cbgyend = cbgystart + (1 << cbgheightexpn);\r
+ tcd_precinct_t *prc = &band->precincts[precno];\r
+ /* precinct size (global) */\r
+ prc->x0 = int_max(cbgxstart, band->x0);\r
+ prc->y0 = int_max(cbgystart, band->y0);\r
+ prc->x1 = int_min(cbgxend, band->x1);\r
+ prc->y1 = int_min(cbgyend, band->y1);\r
+\r
+ tlcblkxstart =\r
+ int_floordivpow2(prc->x0, cblkwidthexpn) << cblkwidthexpn;\r
+ tlcblkystart =\r
+ int_floordivpow2(prc->y0, cblkheightexpn) << cblkheightexpn;\r
+ brcblkxend =\r
+ int_ceildivpow2(prc->x1, cblkwidthexpn) << cblkwidthexpn;\r
+ brcblkyend =\r
+ int_ceildivpow2(prc->y1, cblkheightexpn) << cblkheightexpn;\r
+ prc->cw = (brcblkxend - tlcblkxstart) >> cblkwidthexpn;\r
+ prc->ch = (brcblkyend - tlcblkystart) >> cblkheightexpn;\r
+\r
+ prc->cblks =\r
+ (tcd_cblk_t *) malloc(prc->cw * prc->ch *\r
+ sizeof(tcd_cblk_t));\r
+\r
+ prc->incltree = tgt_create(prc->cw, prc->ch);\r
+ prc->imsbtree = tgt_create(prc->cw, prc->ch);\r
+\r
+ for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {\r
+ int cblkxstart =\r
+ tlcblkxstart + (cblkno % prc->cw) * (1 << cblkwidthexpn);\r
+ int cblkystart =\r
+ tlcblkystart + (cblkno / prc->cw) * (1 << cblkheightexpn);\r
+ int cblkxend = cblkxstart + (1 << cblkwidthexpn);\r
+ int cblkyend = cblkystart + (1 << cblkheightexpn);\r
+ tcd_cblk_t *cblk = &prc->cblks[cblkno];\r
+ /* code-block size (global) */\r
+ cblk->x0 = int_max(cblkxstart, prc->x0);\r
+ cblk->y0 = int_max(cblkystart, prc->y0);\r
+ cblk->x1 = int_min(cblkxend, prc->x1);\r
+ cblk->y1 = int_min(cblkyend, prc->y1);\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ /*tcd_dump(&tcd_image,0);*/\r
+\r
+\r
+ /* Allocate place to store the data decoded = final image */\r
+ /* Place limited by the tile really present in the codestream */\r
+\r
+\r
+ for (i = 0; i < img->numcomps; i++) {\r
+ for (j = 0; j < cp->tileno_size; j++) {\r
+ tileno = cp->tileno[j];\r
+ x0 = j == 0 ? tcd_image.tiles[tileno].comps[i].x0 : int_min(x0,\r
+ (unsigned int) \r
+ tcd_image.\r
+ tiles\r
+ [tileno].\r
+ comps\r
+ [i].x0);\r
+ y0 =\r
+ j == 0 ? tcd_image.tiles[tileno].comps[i].y0 : int_min(y0,\r
+ (unsigned int) \r
+ tcd_image.\r
+ tiles\r
+ [tileno].\r
+ comps[i].\r
+ y0);\r
+ x1 =\r
+ j == 0 ? tcd_image.tiles[tileno].comps[i].x1 : int_max(x1,\r
+ (unsigned int) \r
+ tcd_image.\r
+ tiles\r
+ [tileno].\r
+ comps[i].\r
+ x1);\r
+ y1 =\r
+ j == 0 ? tcd_image.tiles[tileno].comps[i].y1 : int_max(y1,\r
+ (unsigned int) \r
+ tcd_image.\r
+ tiles\r
+ [tileno].\r
+ comps[i].\r
+ y1);\r
+ }\r
+\r
+ w = x1 - x0;\r
+\r
+ h = y1 - y0;\r
+ img->comps[i].data = (int *) calloc(w * h, sizeof(int));\r
+ img->comps[i].w = w;\r
+ img->comps[i].h = h;\r
+ img->comps[i].x0 = x0;\r
+ img->comps[i].y0 = y0;\r
+ }\r
+}\r
+\r
+void tcd_makelayer_fixed(int layno, int final)\r
+{\r
+ int compno, resno, bandno, precno, cblkno;\r
+ int value; /*, matrice[tcd_tcp->numlayers][tcd_tile->comps[0].numresolutions][3];*/\r
+ int matrice[10][10][3];\r
+ int i, j, k;\r
+\r
+ /*matrice=(int*)malloc(tcd_tcp->numlayers*tcd_tile->comps[0].numresolutions*3*sizeof(int)); */\r
+\r
+ for (compno = 0; compno < tcd_tile->numcomps; compno++) {\r
+ tcd_tilecomp_t *tilec = &tcd_tile->comps[compno];\r
+ for (i = 0; i < tcd_tcp->numlayers; i++) {\r
+ for (j = 0; j < tilec->numresolutions; j++) {\r
+ for (k = 0; k < 3; k++) {\r
+ matrice[i][j][k] =\r
+ (int) (tcd_cp->\r
+ matrice[i * tilec->numresolutions * 3 +\r
+ j * 3 +\r
+ k] *\r
+ (float) (tcd_img->comps[compno].prec / 16.0));\r
+ }\r
+ }\r
+ }\r
+\r
+ for (resno = 0; resno < tilec->numresolutions; resno++) {\r
+ tcd_resolution_t *res = &tilec->resolutions[resno];\r
+ for (bandno = 0; bandno < res->numbands; bandno++) {\r
+ tcd_band_t *band = &res->bands[bandno];\r
+ for (precno = 0; precno < res->pw * res->ph; precno++) {\r
+ tcd_precinct_t *prc = &band->precincts[precno];\r
+ for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {\r
+ tcd_cblk_t *cblk = &prc->cblks[cblkno];\r
+ tcd_layer_t *layer = &cblk->layers[layno];\r
+ int n;\r
+ int imsb = tcd_img->comps[compno].prec - cblk->numbps; /* number of bit-plan equal to zero */\r
+ /* Correction of the matrix of coefficient to include the IMSB information */\r
+\r
+ if (layno == 0) {\r
+ value = matrice[layno][resno][bandno];\r
+ if (imsb >= value)\r
+ value = 0;\r
+ else\r
+ value -= imsb;\r
+ } else {\r
+ value =\r
+ matrice[layno][resno][bandno] -\r
+ matrice[layno - 1][resno][bandno];\r
+ if (imsb >= matrice[layno - 1][resno][bandno]) {\r
+ value -= (imsb - matrice[layno - 1][resno][bandno]);\r
+ if (value < 0)\r
+ value = 0;\r
+ }\r
+ }\r
+\r
+ if (layno == 0)\r
+ cblk->numpassesinlayers = 0;\r
+\r
+ n = cblk->numpassesinlayers;\r
+ if (cblk->numpassesinlayers == 0) {\r
+ if (value != 0)\r
+ n = 3 * value - 2 + cblk->numpassesinlayers;\r
+ else\r
+ n = cblk->numpassesinlayers;\r
+ } else\r
+ n = 3 * value + cblk->numpassesinlayers;\r
+\r
+ layer->numpasses = n - cblk->numpassesinlayers;\r
+\r
+ if (!layer->numpasses)\r
+ continue;\r
+\r
+ if (cblk->numpassesinlayers == 0) {\r
+ layer->len = cblk->passes[n - 1].rate;\r
+ layer->data = cblk->data;\r
+ } else {\r
+ layer->len =\r
+ cblk->passes[n - 1].rate -\r
+ cblk->passes[cblk->numpassesinlayers - 1].rate;\r
+ layer->data =\r
+ cblk->data +\r
+ cblk->passes[cblk->numpassesinlayers - 1].rate;\r
+ }\r
+ if (final)\r
+ cblk->numpassesinlayers = n;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+}\r
+\r
+void tcd_rateallocate_fixed()\r
+{\r
+ int layno;\r
+\r
+ for (layno = 0; layno < tcd_tcp->numlayers; layno++) {\r
+ tcd_makelayer_fixed(layno, 1);\r
+ }\r
+}\r
+\r
+void tcd_makelayer(int layno, double thresh, int final)\r
+{\r
+ int compno, resno, bandno, precno, cblkno, passno;\r
+\r
+ tcd_tile->distolayer[layno] = 0; /*add fixed_quality*/\r
+\r
+ for (compno = 0; compno < tcd_tile->numcomps; compno++) {\r
+ tcd_tilecomp_t *tilec = &tcd_tile->comps[compno];\r
+ for (resno = 0; resno < tilec->numresolutions; resno++) {\r
+ tcd_resolution_t *res = &tilec->resolutions[resno];\r
+ for (bandno = 0; bandno < res->numbands; bandno++) {\r
+ tcd_band_t *band = &res->bands[bandno];\r
+ for (precno = 0; precno < res->pw * res->ph; precno++) {\r
+ tcd_precinct_t *prc = &band->precincts[precno];\r
+ for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {\r
+ tcd_cblk_t *cblk = &prc->cblks[cblkno];\r
+ tcd_layer_t *layer = &cblk->layers[layno];\r
+ int n;\r
+\r
+ if (layno == 0) {\r
+ cblk->numpassesinlayers = 0;\r
+ }\r
+ n = cblk->numpassesinlayers;\r
+ for (passno = cblk->numpassesinlayers;\r
+ passno < cblk->totalpasses; passno++) {\r
+ int dr;\r
+ double dd;\r
+ tcd_pass_t *pass = &cblk->passes[passno];\r
+ if (n == 0) {\r
+ dr = pass->rate;\r
+ dd = pass->distortiondec;\r
+ } else {\r
+ dr = pass->rate - cblk->passes[n - 1].rate;\r
+ dd = pass->distortiondec - cblk->passes[n -\r
+ 1].distortiondec;\r
+ }\r
+ if (!dr) {\r
+ if (dd)\r
+ n = passno + 1;\r
+ continue;\r
+ }\r
+\r
+ if (dd / dr >= thresh)\r
+ n = passno + 1;\r
+ }\r
+ layer->numpasses = n - cblk->numpassesinlayers;\r
+\r
+ if (!layer->numpasses) {\r
+ layer->disto = 0;\r
+ continue;\r
+ }\r
+\r
+ if (cblk->numpassesinlayers == 0) {\r
+ layer->len = cblk->passes[n - 1].rate;\r
+ layer->data = cblk->data;\r
+ layer->disto = cblk->passes[n - 1].distortiondec;\r
+ } else {\r
+ layer->len = cblk->passes[n - 1].rate -\r
+ cblk->passes[cblk->numpassesinlayers - 1].rate;\r
+ layer->data =\r
+ cblk->data +\r
+ cblk->passes[cblk->numpassesinlayers - 1].rate;\r
+ layer->disto =\r
+ cblk->passes[n - 1].distortiondec -\r
+ cblk->passes[cblk->numpassesinlayers - 1].distortiondec;\r
+ }\r
+\r
+ tcd_tile->distolayer[layno] += layer->disto; /*add fixed_quality*/\r
+\r
+ if (final)\r
+ cblk->numpassesinlayers = n;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+}\r
+\r
+void tcd_rateallocate(unsigned char *dest, int len, info_image * info_IM)\r
+{\r
+ int compno, resno, bandno, precno, cblkno, passno, layno;\r
+ double min, max;\r
+ double cumdisto[100]; /*add fixed_quality*/\r
+ const double K = 1; /* 1.1; //add fixed_quality*/\r
+\r
+ double maxSE = 0;\r
+ min = DBL_MAX;\r
+ max = 0;\r
+\r
+ tcd_tile->nbpix = 0; /*add fixed_quality*/\r
+\r
+ for (compno = 0; compno < tcd_tile->numcomps; compno++) {\r
+ tcd_tilecomp_t *tilec = &tcd_tile->comps[compno];\r
+\r
+ tilec->nbpix = 0;\r
+ for (resno = 0; resno < tilec->numresolutions; resno++) {\r
+ tcd_resolution_t *res = &tilec->resolutions[resno];\r
+ for (bandno = 0; bandno < res->numbands; bandno++) {\r
+ tcd_band_t *band = &res->bands[bandno];\r
+ for (precno = 0; precno < res->pw * res->ph; precno++) {\r
+ tcd_precinct_t *prc = &band->precincts[precno];\r
+ for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {\r
+ tcd_cblk_t *cblk = &prc->cblks[cblkno];\r
+ for (passno = 0; passno < cblk->totalpasses; passno++) {\r
+ tcd_pass_t *pass = &cblk->passes[passno];\r
+ int dr;\r
+ double dd, rdslope;\r
+ if (passno == 0) {\r
+ dr = pass->rate;\r
+ dd = pass->distortiondec;\r
+ } else {\r
+ dr = pass->rate - cblk->passes[passno - 1].rate;\r
+ dd = pass->distortiondec -\r
+ cblk->passes[passno - 1].distortiondec;\r
+ }\r
+ if (dr == 0) {\r
+ continue;\r
+ }\r
+\r
+ rdslope = dd / dr;\r
+\r
+ if (rdslope < min) {\r
+ min = rdslope;\r
+ }\r
+ if (rdslope > max) {\r
+ max = rdslope;\r
+ }\r
+ } /* passno */\r
+\r
+ tcd_tile->nbpix += ((cblk->x1 - cblk->x0) * (cblk->y1 - cblk->y0)); /*add fixed_quality*/\r
+\r
+ tilec->nbpix += ((cblk->x1 - cblk->x0) * (cblk->y1 - cblk->y0)); /*add fixed_quality*/\r
+\r
+ } /* cbklno */\r
+ } /* precno */\r
+ } /* bandno */\r
+ } /* resno */\r
+ maxSE += (((double)(1 << tcd_img->comps[compno].prec) - 1.0) * ((double)(1 << tcd_img->comps[compno].prec) -1.0)) * ((double)(tilec->nbpix));\r
+ } /* compno */\r
+\r
+ /* add antonin index */\r
+ if (info_IM->index_on) {\r
+ info_tile *info_TL = &info_IM->tile[tcd_tileno];\r
+ info_TL->nbpix = tcd_tile->nbpix;\r
+ info_TL->distotile = tcd_tile->distotile;\r
+ info_TL->thresh =\r
+ (double *) malloc(tcd_tcp->numlayers * sizeof(double));\r
+ }\r
+ /* dda */\r
+\r
+ for (layno = 0; layno < tcd_tcp->numlayers; layno++) {\r
+ volatile double lo = min;\r
+ volatile double hi = max;\r
+ volatile int success = 0;\r
+ volatile int maxlen = tcd_tcp->rates[layno] ? int_min(tcd_tcp->rates[layno], len) : len; /*Mod antonin losslessbug*/\r
+ volatile double goodthresh;\r
+ volatile int i;\r
+ double distotarget; /*add fixed_quality*/\r
+\r
+ distotarget = tcd_tile->distotile - ((K * maxSE) / pow(10, tcd_tcp->distoratio[layno] / 10)); /* add fixed_quality*/\r
+ \r
+ if ((tcd_tcp->rates[layno]) || (tcd_cp->disto_alloc==0)) {\r
+ for (i = 0; i < 32; i++) {\r
+ volatile double thresh = (lo + hi) / 2;\r
+ int l = 0;\r
+ double distoachieved = 0; /* add fixed_quality*/\r
+\r
+ tcd_makelayer(layno, thresh, 0);\r
+\r
+ if (tcd_cp->fixed_quality) { /* add fixed_quality*/\r
+ distoachieved =\r
+ layno ==\r
+ 0 ? tcd_tile->distolayer[0] : cumdisto[layno - 1] +\r
+ tcd_tile->distolayer[layno];\r
+ if (distoachieved < distotarget) {\r
+ hi = thresh;\r
+ continue;\r
+ }\r
+ lo = thresh;\r
+ } else {\r
+ l =\r
+ t2_encode_packets(tcd_img, tcd_cp, tcd_tileno, tcd_tile,\r
+ layno + 1, dest, maxlen, info_IM);\r
+ /* fprintf(stderr, "rate alloc: len=%d, max=%d\n", l, maxlen); */\r
+ if (l == -999) {\r
+ lo = thresh;\r
+ continue;\r
+ }\r
+ hi = thresh;\r
+ }\r
+\r
+ success = 1;\r
+ goodthresh = thresh;\r
+ }\r
+ } else {\r
+ success = 1;\r
+ goodthresh = min;\r
+ }\r
+\r
+ if (!success) {\r
+ longjmp(j2k_error, 1);\r
+ }\r
+\r
+ if (info_IM->index_on) { /* Threshold for Marcela Index */\r
+ info_IM->tile[tcd_tileno].thresh[layno] = goodthresh;\r
+ }\r
+ tcd_makelayer(layno, goodthresh, 1);\r
+\r
+ cumdisto[layno] = layno == 0 ? tcd_tile->distolayer[0] : cumdisto[layno - 1] + tcd_tile->distolayer[layno]; /* add fixed_quality*/\r
+ }\r
+}\r
+\r
+int\r
+tcd_encode_tile_pxm(int tileno, unsigned char *dest, int len,\r
+ info_image * info_IM)\r
+{\r
+ int compno;\r
+ int l, i, npck=0;\r
+ clock_t time7;\r
+ tcd_tile_t *tile;\r
+ j2k_tcp_t *tcp = &tcd_cp->tcps[0];\r
+ j2k_tccp_t *tccp = &tcp->tccps[0];\r
+ \r
+ tcd_tileno = tileno;\r
+ tcd_tile = tcd_image.tiles;\r
+ tcd_tcp = &tcd_cp->tcps[tileno];\r
+ tile = tcd_tile;\r
+ /* INDEX >> "Precinct_nb_X et Precinct_nb_Y" */\r
+ if (info_IM->index_on) {\r
+ tcd_tilecomp_t *tilec_idx = &tile->comps[0]; /*Based on Component 0*/\r
+ \r
+ for (i = 0; i < tilec_idx->numresolutions; i++) {\r
+ \r
+ tcd_resolution_t *res_idx = &tilec_idx->resolutions[i];\r
+ \r
+ info_IM->tile[tileno].pw[i] = res_idx->pw;\r
+ info_IM->tile[tileno].ph[i] = res_idx->ph;\r
+ \r
+ npck+=res_idx->pw * res_idx->ph;\r
+ \r
+ info_IM->tile[tileno].pdx[i] = tccp->prcw[i];\r
+ info_IM->tile[tileno].pdy[i] = tccp->prch[i];\r
+ \r
+ }\r
+ info_IM->tile[tileno].packet = (info_packet *) calloc(info_IM->Comp * info_IM->Layer * npck, sizeof(info_packet));\r
+ }\r
+ /* << INDEX */\r
+\r
+/*---------------TILE-------------------*/\r
+\r
+ time7 = clock();\r
+\r
+ for (compno = 0; compno < tile->numcomps; compno++) {\r
+ FILE *src;\r
+ char tmp[256];\r
+ int k;\r
+ unsigned char elmt;\r
+ int i, j;\r
+ int tw, w;\r
+ tcd_tilecomp_t *tilec = &tile->comps[compno];\r
+ int adjust =\r
+ tcd_img->comps[compno].sgnd ? 0 : 1 << (tcd_img->comps[compno].\r
+ prec - 1);\r
+ int offset_x, offset_y;\r
+\r
+ offset_x = int_ceildiv(tcd_img->x0, tcd_img->comps[compno].dx);\r
+ offset_y = int_ceildiv(tcd_img->y0, tcd_img->comps[compno].dy);\r
+ tw = tilec->x1 - tilec->x0;\r
+ w = int_ceildiv(tcd_img->x1 - tcd_img->x0, tcd_img->comps[compno].dx);\r
+ sprintf(tmp, "Compo%d", compno); /* component file */\r
+ src = fopen(tmp, "rb");\r
+ if (!src) {\r
+ fprintf(stderr, "failed to open %s for reading\n", tmp);\r
+ return 1;\r
+ }\r
+\r
+ /* read the Compo file to extract data of the tile */\r
+ k = 0;\r
+ fseek(src, (tilec->x0 - offset_x) + (tilec->y0 - offset_y) * w,\r
+ SEEK_SET);\r
+ k = (tilec->x0 - offset_x) + (tilec->y0 - offset_y) * w;\r
+ for (j = tilec->y0; j < tilec->y1; j++) {\r
+ for (i = tilec->x0; i < tilec->x1; i++) {\r
+ if (tcd_tcp->tccps[compno].qmfbid == 1) {\r
+ elmt = fgetc(src);\r
+ tilec->data[i - tilec->x0 + (j - tilec->y0) * tw] =\r
+ elmt - adjust;\r
+ k++;\r
+ } else if (tcd_tcp->tccps[compno].qmfbid == 0) {\r
+ elmt = fgetc(src);\r
+ tilec->data[i - tilec->x0 + (j - tilec->y0) * tw] =\r
+ (elmt - adjust) << 13;\r
+ k++;\r
+ }\r
+ }\r
+ fseek(src, (tilec->x0 - offset_x) + (j + 1 - offset_y) * w - k,\r
+ SEEK_CUR);\r
+ k = tilec->x0 - offset_x + (j + 1 - offset_y) * w;\r
+\r
+ }\r
+ fclose(src);\r
+ }\r
+\r
+/*----------------MCT-------------------*/\r
+\r
+ if (tcd_tcp->mct) {\r
+ if (tcd_tcp->tccps[0].qmfbid == 0) {\r
+ mct_encode_real(tile->comps[0].data, tile->comps[1].data,\r
+ tile->comps[2].data,\r
+ (tile->comps[0].x1 -\r
+ tile->comps[0].x0) * (tile->comps[0].y1 -\r
+ tile->comps[0].y0));\r
+ } else {\r
+ mct_encode(tile->comps[0].data, tile->comps[1].data,\r
+ tile->comps[2].data,\r
+ (tile->comps[0].x1 -\r
+ tile->comps[0].x0) * (tile->comps[0].y1 -\r
+ tile->comps[0].y0));\r
+ }\r
+ }\r
+/*----------------DWT---------------------*/\r
+\r
+/* mod Ive*/\r
+for (compno = 0; compno < tile->numcomps; compno++) {\r
+ tcd_tilecomp_t *tilec = &tile->comps[compno];\r
+ if (tcd_tcp->tccps[compno].qmfbid == 1) {\r
+ dwt_encode(tilec);\r
+ } else if (tcd_tcp->tccps[compno].qmfbid == 0) {\r
+ dwt_encode_real(tilec);\r
+ }\r
+}\r
+/* /mod Ive*/\r
+/*------------------TIER1-----------------*/\r
+\r
+ t1_init_luts();\r
+ t1_encode_cblks(tile, tcd_tcp);\r
+\r
+/*-----------RATE-ALLOCATE------------------*/\r
+ info_IM->index_write = 0; /* INDEX */\r
+\r
+ if (tcd_cp->disto_alloc || tcd_cp->fixed_quality) /* mod fixed_quality*/\r
+ /* Normal Rate/distortion allocation */\r
+ tcd_rateallocate(dest, len, info_IM);\r
+ else\r
+ /* Fixed layer allocation */\r
+ tcd_rateallocate_fixed();\r
+\r
+/*--------------TIER2------------------*/\r
+ info_IM->index_write = 1; /* INDEX */\r
+ l = t2_encode_packets(tcd_img, tcd_cp, tileno, tile,\r
+ tcd_tcp->numlayers, dest, len, info_IM);\r
+/*---------------CLEAN-------------------*/\r
+\r
+ time7 = clock() - time7;\r
+ fprintf(stdout,"total: %ld.%.3ld s\n", time7 / CLOCKS_PER_SEC,\r
+ (time7 % (int)CLOCKS_PER_SEC) * 1000 / CLOCKS_PER_SEC);\r
+\r
+ /* cleaning memory */\r
+ for (compno = 0; compno < tile->numcomps; compno++) {\r
+ tilec = &tile->comps[compno];\r
+ free(tilec->data);\r
+ }\r
+\r
+ return l;\r
+}\r
+\r
+int\r
+tcd_encode_tile_pgx(int tileno, unsigned char *dest, int len,\r
+ info_image * info_IM)\r
+{\r
+ int compno;\r
+ int l, i, npck=0;\r
+ clock_t time;\r
+ tcd_tile_t *tile;\r
+ j2k_tcp_t *tcp = &tcd_cp->tcps[0];\r
+ j2k_tccp_t *tccp = &tcp->tccps[0];\r
+ \r
+ tcd_tileno = tileno;\r
+ tcd_tile = tcd_image.tiles;\r
+ tcd_tcp = &tcd_cp->tcps[tileno];\r
+ tile = tcd_tile;\r
+ /* INDEX >> "Precinct_nb_X et Precinct_nb_Y" */\r
+ if (info_IM->index_on) {\r
+ tcd_tilecomp_t *tilec_idx = &tile->comps[0]; /*Based on Component 0*/\r
+ \r
+ for (i = 0; i < tilec_idx->numresolutions; i++) {\r
+ \r
+ tcd_resolution_t *res_idx = &tilec_idx->resolutions[i];\r
+ \r
+ info_IM->tile[tileno].pw[i] = res_idx->pw;\r
+ info_IM->tile[tileno].ph[i] = res_idx->ph;\r
+ \r
+ npck+=res_idx->pw * res_idx->ph;\r
+ \r
+ info_IM->tile[tileno].pdx[i] = tccp->prcw[i];\r
+ info_IM->tile[tileno].pdy[i] = tccp->prch[i];\r
+ \r
+ }\r
+ info_IM->tile[tileno].packet = (info_packet *) calloc(info_IM->Comp * info_IM->Layer * npck, sizeof(info_packet));\r
+ }\r
+ /* << INDEX */\r
+/*---------------TILE-------------------*/\r
+ time = clock();\r
+\r
+ for (compno = 0; compno < tile->numcomps; compno++) {\r
+ FILE *src;\r
+ char tmp[256];\r
+ int k;\r
+ int elmt;\r
+ int i, j;\r
+ int tw, w;\r
+ tcd_tilecomp_t *tilec = &tile->comps[compno];\r
+ int adjust =\r
+ tcd_img->comps[compno].sgnd ? 0 : 1 << (tcd_img->comps[compno].\r
+ prec - 1);\r
+ int offset_x, offset_y;\r
+\r
+ offset_x = int_ceildiv(tcd_img->x0, tcd_img->comps[compno].dx);\r
+ offset_y = int_ceildiv(tcd_img->y0, tcd_img->comps[compno].dy);\r
+ tw = tilec->x1 - tilec->x0;\r
+ w = int_ceildiv(tcd_img->x1 - tcd_img->x0, tcd_img->comps[compno].dx);\r
+ sprintf(tmp, "bandtile%d", tileno / tcd_cp->tw + 1); /* bandtile file opening */\r
+ src = fopen(tmp, "rb");\r
+ if (!src) {\r
+ fprintf(stderr, "failed to open %s for reading\n", tmp);\r
+ return 1;\r
+ }\r
+ /* Extract data from bandtile file limited to the current tile */\r
+ k = 0;\r
+ while (k < tilec->x0 - offset_x) {\r
+ k++;\r
+ fscanf(src, "%d", &elmt);\r
+ }\r
+\r
+ for (j = 0; j < tilec->y1 - tilec->y0; j++) {\r
+ for (i = tilec->x0; i < tilec->x1; i++) {\r
+ if (tcd_tcp->tccps[compno].qmfbid == 1) {\r
+ fscanf(src, "%d", &elmt);\r
+ tilec->data[i - tilec->x0 + (j) * tw] = elmt - adjust;\r
+ k++;\r
+ } else if (tcd_tcp->tccps[compno].qmfbid == 0) {\r
+ fscanf(src, "%d", &elmt);\r
+ tilec->data[i - tilec->x0 + (j) * tw] = (elmt - adjust) << 13;\r
+ k++;\r
+ }\r
+ }\r
+ while (k < tilec->x0 - offset_x + (j + 1) * w) {\r
+ k++;\r
+ fscanf(src, "%d", &elmt);\r
+ }\r
+ }\r
+ fclose(src);\r
+ }\r
+\r
+/*----------------MCT-------------------*/\r
+\r
+ if (tcd_tcp->mct) {\r
+ if (tcd_tcp->tccps[0].qmfbid == 0) {\r
+ mct_encode_real(tile->comps[0].data, tile->comps[1].data,\r
+ tile->comps[2].data,\r
+ (tile->comps[0].x1 -\r
+ tile->comps[0].x0) * (tile->comps[0].y1 -\r
+ tile->comps[0].y0));\r
+ } else {\r
+ mct_encode(tile->comps[0].data, tile->comps[1].data,\r
+ tile->comps[2].data,\r
+ (tile->comps[0].x1 -\r
+ tile->comps[0].x0) * (tile->comps[0].y1 -\r
+ tile->comps[0].y0));\r
+ }\r
+ }\r
+\r
+/*----------------DWT---------------------*/\r
+\r
+/* mod Ive*/\r
+for (compno = 0; compno < tile->numcomps; compno++) {\r
+ tcd_tilecomp_t *tilec = &tile->comps[compno];\r
+ if (tcd_tcp->tccps[compno].qmfbid == 1) {\r
+ dwt_encode(tilec);\r
+ } else if (tcd_tcp->tccps[compno].qmfbid == 0) {\r
+ dwt_encode_real(tilec);\r
+ }\r
+}\r
+/* /mod Ive*/\r
+\r
+/*------------------TIER1-----------------*/\r
+\r
+ t1_init_luts();\r
+ t1_encode_cblks(tile, tcd_tcp);\r
+\r
+/*-----------RATE-ALLOCATE------------------*/\r
+\r
+ info_IM->index_write = 0; /* INDEX */\r
+\r
+ if (tcd_cp->disto_alloc || tcd_cp->fixed_quality) /* mod fixed_quality*/\r
+\r
+ /* Normal Rate/distortion allocation */\r
+\r
+ tcd_rateallocate(dest, len, info_IM);\r
+\r
+ else\r
+ /* Fixed layer allocation */\r
+\r
+ tcd_rateallocate_fixed();\r
+\r
+/*--------------TIER2------------------*/\r
+ info_IM->index_write = 1; /* INDEX */\r
+\r
+ l = t2_encode_packets(tcd_img, tcd_cp, tileno, tile,\r
+ tcd_tcp->numlayers, dest, len, info_IM);\r
+\r
+ /*---------------CLEAN-------------------*/\r
+ time = clock() - time;\r
+ fprintf(stdout,"total: %ld.%.3ld s\n", time / CLOCKS_PER_SEC,\r
+ (time % (int)CLOCKS_PER_SEC) * 1000 / CLOCKS_PER_SEC);\r
+\r
+ for (compno = 0; compno < tile->numcomps; compno++) {\r
+ tilec = &tile->comps[compno];\r
+ free(tilec->data);\r
+ }\r
+\r
+ return l;\r
+}\r
+\r
+\r
+int tcd_decode_tile(unsigned char *src, int len, int tileno)\r
+{\r
+ int l;\r
+ int compno;\r
+ int eof = 0;\r
+ clock_t time;\r
+ tcd_tile_t *tile;\r
+\r
+ tcd_tileno = tileno;\r
+ tcd_tile = &tcd_image.tiles[tileno];\r
+ tcd_tcp = &tcd_cp->tcps[tileno];\r
+ tile = tcd_tile;\r
+\r
+ time = clock();\r
+\r
+ fprintf(stdout, "Tile %d of %d decoded in ", tileno + 1,\r
+ tcd_cp->tw * tcd_cp->th);\r
+\r
+ /*--------------TIER2------------------*/\r
+\r
+ l = t2_decode_packets(src, len, tcd_img, tcd_cp, tileno, tile);\r
+\r
+ if (l == -999) {\r
+ eof = 1;\r
+ fprintf(stderr, "tcd_decode: incomplete bistream\n");\r
+ }\r
+\r
+ /*------------------TIER1-----------------*/\r
+ t1_init_luts();\r
+ t1_decode_cblks(tile, tcd_tcp);\r
+\r
+ /*----------------DWT---------------------*/\r
+\r
+ for (compno = 0; compno < tile->numcomps; compno++) {\r
+ tcd_tilecomp_t *tilec = &tile->comps[compno];\r
+ if (tcd_cp->reduce != 0) {\r
+ tcd_img->comps[compno].resno_decoded =\r
+ tile->comps[compno].numresolutions - tcd_cp->reduce - 1;\r
+ }\r
+\r
+\r
+ /* mod Ive */\r
+ if (tcd_tcp->tccps[compno].qmfbid == 1) {\r
+ dwt_decode(tilec, \r
+ tilec->numresolutions - 1 - \r
+ tcd_img->comps[compno].resno_decoded);\r
+ } else {\r
+ dwt_decode_real(tilec,\r
+ tilec->numresolutions - 1 -\r
+ tcd_img->comps[compno].resno_decoded);\r
+ }\r
+ /* /mod Ive*/\r
+ \r
+ if (tile->comps[compno].numresolutions > 0)\r
+ tcd_img->comps[compno].factor =\r
+ tile->comps[compno].numresolutions -\r
+ (tcd_img->comps[compno].resno_decoded + 1);\r
+ }\r
+\r
+ /*----------------MCT-------------------*/\r
+\r
+ if (tcd_tcp->mct) {\r
+ if (tcd_tcp->tccps[0].qmfbid == 1) {\r
+ mct_decode(tile->comps[0].data, tile->comps[1].data,\r
+ tile->comps[2].data,\r
+ (tile->comps[0].x1 -\r
+ tile->comps[0].x0) * (tile->comps[0].y1 -\r
+ tile->comps[0].y0));\r
+ } else {\r
+ mct_decode_real(tile->comps[0].data, tile->comps[1].data,\r
+ tile->comps[2].data,\r
+ (tile->comps[0].x1 -\r
+ tile->comps[0].x0) * (tile->comps[0].y1 -\r
+ tile->comps[0].y0));\r
+ }\r
+ }\r
+\r
+ /*---------------TILE-------------------*/\r
+\r
+ for (compno = 0; compno < tile->numcomps; compno++) {\r
+ tcd_tilecomp_t *tilec = &tile->comps[compno];\r
+ tcd_resolution_t *res =\r
+ &tilec->resolutions[tcd_img->comps[compno].resno_decoded];\r
+ int adjust =\r
+ tcd_img->comps[compno].sgnd ? 0 : 1 << (tcd_img->comps[compno].\r
+ prec - 1);\r
+ int min =\r
+ tcd_img->comps[compno].\r
+ sgnd ? -(1 << (tcd_img->comps[compno].prec - 1)) : 0;\r
+ int max =\r
+ tcd_img->comps[compno].\r
+ sgnd ? (1 << (tcd_img->comps[compno].prec - 1)) -\r
+ 1 : (1 << tcd_img->comps[compno].prec) - 1;\r
+\r
+ int tw = tilec->x1 - tilec->x0;\r
+ int w = tcd_img->comps[compno].w;\r
+\r
+ int i, j;\r
+ int offset_x = int_ceildivpow2(tcd_img->comps[compno].x0,\r
+ tcd_img->comps[compno].factor);\r
+ int offset_y = int_ceildivpow2(tcd_img->comps[compno].y0,\r
+ tcd_img->comps[compno].factor);\r
+\r
+ for (j = res->y0; j < res->y1; j++) {\r
+ for (i = res->x0; i < res->x1; i++) {\r
+\r
+ int v;\r
+ double tmp = (tilec->data[i - res->x0 + (j - res->y0) * tw])/8192.0;\r
+ int tmp2;\r
+ \r
+ if (tcd_tcp->tccps[compno].qmfbid == 1) {\r
+ v = tilec->data[i - res->x0 + (j - res->y0) * tw];\r
+ } else {\r
+ tmp2=((int) (floor(fabs(tmp)))) + ((int) floor(fabs(tmp*2))%2);\r
+ v = ((tmp<0)?-tmp2:tmp2);\r
+ }\r
+ \r
+ v += adjust;\r
+\r
+ tcd_img->comps[compno].data[(i - offset_x) +\r
+ (j - offset_y) * w] =\r
+ int_clamp(v, min, max);\r
+ }\r
+ }\r
+ }\r
+\r
+ time = clock() - time;\r
+ fprintf(stdout, "%ld.%.3ld s\n", time / CLOCKS_PER_SEC,\r
+ (time % (int)CLOCKS_PER_SEC) * 1000 / CLOCKS_PER_SEC);\r
+\r
+\r
+\r
+ for (compno = 0; compno < tile->numcomps; compno++) {\r
+ free(tcd_image.tiles[tileno].comps[compno].data);\r
+ }\r
+\r
+ if (eof) {\r
+ longjmp(j2k_error, 1);\r
+ }\r
+\r
+ return l;\r
+}\r
+\r
+\r
+\r
+void tcd_dec_release()\r
+\r
+{\r
+\r
+ int tileno,compno,resno,bandno,precno;\r
+\r
+ for (tileno=0;tileno<tcd_image.tw*tcd_image.th;tileno++) {\r
+\r
+ tcd_tile_t tile=tcd_image.tiles[tileno];\r
+\r
+ for (compno=0;compno<tile.numcomps;compno++) {\r
+\r
+ tcd_tilecomp_t tilec=tile.comps[compno];\r
+\r
+ for (resno=0;resno<tilec.numresolutions;resno++) {\r
+\r
+ tcd_resolution_t res=tilec.resolutions[resno];\r
+\r
+ for (bandno=0;bandno<res.numbands;bandno++) {\r
+\r
+ tcd_band_t band=res.bands[bandno];\r
+\r
+ for (precno=0;precno<res.ph*res.pw;precno++) {\r
+\r
+ tcd_precinct_t prec=band.precincts[precno];\r
+\r
+ if (prec.cblks!=NULL) free(prec.cblks);\r
+\r
+ if (prec.imsbtree!=NULL) free(prec.imsbtree);\r
+\r
+ if (prec.incltree!=NULL) free(prec.incltree);\r
+\r
+ }\r
+\r
+ if (band.precincts!=NULL) free(band.precincts);\r
+\r
+ }\r
+\r
+ }\r
+\r
+ if (tilec.resolutions!=NULL) free(tilec.resolutions);\r
+\r
+ }\r
+\r
+ if (tile.comps!=NULL) free(tile.comps);\r
+\r
+ }\r
+\r
+ if (tcd_image.tiles!=NULL) free(tcd_image.tiles);\r
+\r
+}\r
--- /dev/null
+/*\r
+ * Copyright (c) 2001-2002, David Janssens \r
+ * Copyright (c) 2002-2003, Yannick Verschueren\r
+ * Copyright (c) 2002-2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+#ifndef __TCD_H\r
+#define __TCD_H\r
+\r
+#include "j2k.h"\r
+#include "tgt.h"\r
+\r
+typedef struct {\r
+ int numpasses;\r
+ int len;\r
+ unsigned char *data;\r
+ int maxpasses;\r
+ int numnewpasses;\r
+ int newlen;\r
+} tcd_seg_t;\r
+\r
+typedef struct {\r
+ int rate;\r
+ double distortiondec;\r
+ int term, len;\r
+} tcd_pass_t;\r
+\r
+typedef struct {\r
+ int numpasses; /* Number of passes in the layer */\r
+ int len; /* len of information */\r
+ double disto; /* add for index (Cfr. Marcela) */\r
+ unsigned char *data; /* data */\r
+} tcd_layer_t;\r
+\r
+typedef struct {\r
+ int x0, y0, x1, y1; /* dimension of the code-blocks : left upper corner (x0, y0) right low corner (x1,y1) */\r
+ int numbps;\r
+ int numlenbits;\r
+ int len; /* length */\r
+ int numpasses; /* number of pass already done for the code-blocks */\r
+ int numnewpasses; /* number of pass added to the code-blocks */\r
+ int numsegs; /* number of segments */\r
+ tcd_seg_t segs[100]; /* segments informations */\r
+ unsigned char data[8192]; /* Data */\r
+ int numpassesinlayers; /* number of passes in the layer */\r
+ tcd_layer_t layers[100]; /* layer information */\r
+ int totalpasses; /* total number of passes */\r
+ tcd_pass_t passes[100]; /* information about the passes */\r
+} tcd_cblk_t;\r
+\r
+typedef struct {\r
+ int x0, y0, x1, y1; /* dimension of the precinct : left upper corner (x0, y0) right low corner (x1,y1) */\r
+ int cw, ch; /* number of precinct in width and heigth */\r
+ tcd_cblk_t *cblks; /* code-blocks informations */\r
+ tgt_tree_t *incltree; /* inclusion tree */\r
+ tgt_tree_t *imsbtree; /* IMSB tree */\r
+} tcd_precinct_t;\r
+\r
+typedef struct {\r
+ int x0, y0, x1, y1; /* dimension of the subband : left upper corner (x0, y0) right low corner (x1,y1) */\r
+ int bandno;\r
+ tcd_precinct_t *precincts; /* precinct information */\r
+ int numbps;\r
+ float stepsize;\r
+} tcd_band_t;\r
+\r
+typedef struct {\r
+ int x0, y0, x1, y1; /* dimension of the resolution level : left upper corner (x0, y0) right low corner (x1,y1) */\r
+ int pw, ph;\r
+ int numbands; /* number sub-band for the resolution level */\r
+ tcd_band_t bands[3]; /* subband information */\r
+} tcd_resolution_t;\r
+\r
+typedef struct {\r
+ int x0, y0, x1, y1; /* dimension of component : left upper corner (x0, y0) right low corner (x1,y1) */\r
+ int numresolutions; /* number of resolutions level */\r
+ tcd_resolution_t *resolutions; /* resolutions information */\r
+ int *data; /* data of the component */\r
+ int nbpix; /* add fixed_quality */\r
+} tcd_tilecomp_t;\r
+\r
+typedef struct {\r
+ int x0, y0, x1, y1; /* dimension of the tile : left upper corner (x0, y0) right low corner (x1,y1) */\r
+ int numcomps; /* number of components in tile */\r
+ tcd_tilecomp_t *comps; /* Components information */\r
+ int nbpix; /* add fixed_quality */\r
+ double distotile; /* add fixed_quality */\r
+ double distolayer[100]; /* add fixed_quality */\r
+} tcd_tile_t;\r
+\r
+typedef struct {\r
+ int tw, th; /* number of tiles in width and heigth */\r
+ tcd_tile_t *tiles; /* Tiles information */\r
+} tcd_image_t;\r
+\r
+/*\r
+ * Initialize the tile coder (reuses the memory allocated by tcd_malloc_encode)\r
+ * img: raw image\r
+ * cp: coding parameters\r
+ * curtileno : number that identifies the tile that will be encoded\r
+ */\r
+void tcd_init_encode(j2k_image_t * img, j2k_cp_t * cp, int curtileno);\r
+\r
+\r
+/*\r
+ * Initialize the tile coder (allocate the memory)\r
+ * img: raw image\r
+ * cp: coding parameters\r
+ * curtileno : number that identifies the tile that will be encoded\r
+ */\r
+void tcd_malloc_encode(j2k_image_t * img, j2k_cp_t * cp, int curtileno);\r
+\r
+\r
+/*\r
+ * Initialize the tile decoder\r
+ * img: raw image\r
+ * cp: coding parameters\r
+ */\r
+void tcd_init(j2k_image_t * img, j2k_cp_t * cp);\r
+\r
+\r
+/*\r
+ * Free the memory allocated for encoding\r
+ * img: raw image\r
+ * cp: coding parameters\r
+ * curtileno : number that identifies the tile that will be encoded\r
+ */\r
+void tcd_free_encode(j2k_image_t * img, j2k_cp_t * cp, int curtileno);\r
+\r
+/*\r
+ * Encode a tile from the raw image into a buffer, format pnm, pgm or ppm\r
+ * tileno: number that identifies one of the tiles to be encoded\r
+ * dest: destination buffer\r
+ * len: length of destination buffer\r
+ * info_IM: creation of index file\r
+ */\r
+int tcd_encode_tile_pxm(int tileno, unsigned char *dest, int len,\r
+ info_image * info_IM);\r
+\r
+\r
+/*\r
+ * Encode a tile from the raw image into a buffer, format pgx\r
+ * tileno: number that identifies one of the tiles to be encoded\r
+ * dest: destination buffer\r
+ * len: length of destination buffer\r
+ * info_IM: creation of index file\r
+ */\r
+int tcd_encode_tile_pgx(int tileno, unsigned char *dest, int len,\r
+ info_image * info_IM);\r
+\r
+/*\r
+ * Decode a tile from a buffer into a raw image\r
+ * src: source buffer\r
+ * len: length of the source buffer\r
+ * tileno: number that identifies the tile that will be decoded\r
+ */\r
+int tcd_decode_tile(unsigned char *src, int len, int tileno);\r
+\r
+void tcd_dec_release();\r
+\r
+#endif\r
--- /dev/null
+/*\r
+ * Copyright (c) 2001-2002, David Janssens\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+#include "tgt.h"\r
+#include "bio.h"\r
+#include <stdlib.h>\r
+#include <stdio.h>\r
+\r
+/* <summary> */\r
+/* Reset tag-tree. */\r
+/* </summary> */\r
+void tgt_reset(tgt_tree_t * tree)\r
+{\r
+ int i;\r
+ /* new */\r
+ if (!tree || tree == NULL)\r
+ return;\r
+\r
+ for (i = 0; i < tree->numnodes; i++) {\r
+ tree->nodes[i].value = 999;\r
+ tree->nodes[i].low = 0;\r
+ tree->nodes[i].known = 0;\r
+ }\r
+}\r
+\r
+/* <summary> */\r
+/* Create tag-tree. */\r
+/* </summary> */\r
+tgt_tree_t *tgt_create(int numleafsh, int numleafsv)\r
+{\r
+ int nplh[32];\r
+ int nplv[32];\r
+ tgt_node_t *node;\r
+ tgt_node_t *parentnode;\r
+ tgt_node_t *parentnode0;\r
+ tgt_tree_t *tree;\r
+ int i, j, k;\r
+ int numlvls;\r
+ int n;\r
+\r
+ tree = (tgt_tree_t *) malloc(sizeof(tgt_tree_t));\r
+ tree->numleafsh = numleafsh;\r
+ tree->numleafsv = numleafsv;\r
+\r
+ numlvls = 0;\r
+ nplh[0] = numleafsh;\r
+ nplv[0] = numleafsv;\r
+ tree->numnodes = 0;\r
+ do {\r
+ n = nplh[numlvls] * nplv[numlvls];\r
+ nplh[numlvls + 1] = (nplh[numlvls] + 1) / 2;\r
+ nplv[numlvls + 1] = (nplv[numlvls] + 1) / 2;\r
+ tree->numnodes += n;\r
+ ++numlvls;\r
+ } while (n > 1);\r
+\r
+ /* ADD */\r
+ if (tree->numnodes == 0) {\r
+ free(tree);\r
+ return NULL;\r
+ }\r
+\r
+ tree->nodes = (tgt_node_t *) malloc(tree->numnodes * sizeof(tgt_node_t));\r
+\r
+ node = tree->nodes;\r
+ parentnode = &tree->nodes[tree->numleafsh * tree->numleafsv];\r
+ parentnode0 = parentnode;\r
+\r
+ for (i = 0; i < numlvls - 1; ++i) {\r
+ for (j = 0; j < nplv[i]; ++j) {\r
+ k = nplh[i];\r
+ while (--k >= 0) {\r
+ node->parent = parentnode;\r
+ ++node;\r
+ if (--k >= 0) {\r
+ node->parent = parentnode;\r
+ ++node;\r
+ }\r
+ ++parentnode;\r
+ }\r
+ if ((j & 1) || j == nplv[i] - 1) {\r
+ parentnode0 = parentnode;\r
+ } else {\r
+ parentnode = parentnode0;\r
+ parentnode0 += nplh[i];\r
+ }\r
+ }\r
+ }\r
+ node->parent = 0;\r
+\r
+ tgt_reset(tree);\r
+\r
+ return tree;\r
+}\r
+\r
+/* <summary> */\r
+/* Destroy tag-tree. */\r
+/* </summary> */\r
+void tgt_destroy(tgt_tree_t * t)\r
+{\r
+ free(t->nodes);\r
+ free(t);\r
+}\r
+\r
+/* <summary> */\r
+/* Set the value of a leaf of the tag-tree. */\r
+/* </summary> */\r
+void tgt_setvalue(tgt_tree_t * tree, int leafno, int value)\r
+{\r
+ tgt_node_t *node;\r
+ node = &tree->nodes[leafno];\r
+ while (node && node->value > value) {\r
+ node->value = value;\r
+ node = node->parent;\r
+ }\r
+}\r
+\r
+/* <summary> */\r
+/* Encode the value of a leaf of the tag-tree. */\r
+/* </summary> */\r
+void tgt_encode(tgt_tree_t * tree, int leafno, int threshold)\r
+{\r
+ tgt_node_t *stk[31];\r
+ tgt_node_t **stkptr;\r
+ tgt_node_t *node;\r
+ int low;\r
+\r
+ stkptr = stk;\r
+ node = &tree->nodes[leafno];\r
+ while (node->parent) {\r
+ *stkptr++ = node;\r
+ node = node->parent;\r
+ }\r
+\r
+ low = 0;\r
+ for (;;) {\r
+ if (low > node->low) {\r
+ node->low = low;\r
+ } else {\r
+ low = node->low;\r
+ }\r
+\r
+ while (low < threshold) {\r
+ if (low >= node->value) {\r
+ if (!node->known) {\r
+ bio_write(1, 1);\r
+ node->known = 1;\r
+ }\r
+ break;\r
+ }\r
+ bio_write(0, 1);\r
+ ++low;\r
+ }\r
+\r
+ node->low = low;\r
+ if (stkptr == stk)\r
+ break;\r
+ node = *--stkptr;\r
+ }\r
+\r
+}\r
+\r
+/* <summary> */\r
+/* Decode the value of a leaf of the tag-tree. */\r
+/* </summary> */\r
+int tgt_decode(tgt_tree_t * tree, int leafno, int threshold)\r
+{\r
+ tgt_node_t *stk[31];\r
+ tgt_node_t **stkptr;\r
+ tgt_node_t *node;\r
+ int low;\r
+\r
+ stkptr = stk;\r
+ node = &tree->nodes[leafno];\r
+ while (node->parent) {\r
+ *stkptr++ = node;\r
+ node = node->parent;\r
+ }\r
+\r
+ low = 0;\r
+ for (;;) {\r
+ if (low > node->low) {\r
+ node->low = low;\r
+ } else {\r
+ low = node->low;\r
+ }\r
+ while (low < threshold && low < node->value) {\r
+ if (bio_read(1)) {\r
+ node->value = low;\r
+ } else {\r
+ ++low;\r
+ }\r
+ }\r
+ node->low = low;\r
+ if (stkptr == stk) {\r
+ break;\r
+ }\r
+ node = *--stkptr;\r
+ }\r
+\r
+ return (node->value < threshold) ? 1 : 0;\r
+}\r
--- /dev/null
+/*\r
+ * Copyright (c) 2001-2002, David Janssens\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+#ifndef __TGT_H\r
+#define __TGT_H\r
+\r
+typedef struct tgt_node {\r
+ struct tgt_node *parent;\r
+ int value;\r
+ int low;\r
+ int known;\r
+} tgt_node_t;\r
+\r
+typedef struct {\r
+ int numleafsh;\r
+ int numleafsv;\r
+ int numnodes;\r
+ tgt_node_t *nodes;\r
+} tgt_tree_t;\r
+\r
+\r
+\r
+/*\r
+ * Reset a tag-tree (set all leaves to 0)\r
+ * tree: tag-tree to reset\r
+ */\r
+void tgt_reset(tgt_tree_t * tree);\r
+\r
+/*\r
+ * Create a tag-tree\r
+ * numleafsh: width of the array of leafs of the tree\r
+ * numleafsv: height of the array of leafs of the tree\r
+ */\r
+tgt_tree_t *tgt_create(int numleafsh, int numleafsv);\r
+\r
+/*\r
+ * Destroy a tag-tree, liberating memory\r
+ * tree: tag-tree to destroy\r
+ */\r
+void tgt_destroy(tgt_tree_t * tree);\r
+\r
+/*\r
+ * Set the value of a leaf of a tag-tree\r
+ * tree: tag-tree to modify\r
+ * leafno: number that identifies the leaf to modify\r
+ * value: new value of the leaf\r
+ */\r
+void tgt_setvalue(tgt_tree_t * tree, int leafno, int value);\r
+\r
+/*\r
+ * Encode the value of a leaf of the tag-tree up to a given threshold\r
+ * leafno: number that identifies the leaf to encode\r
+ * threshold: threshold to use when encoding value of the leaf\r
+ */\r
+void tgt_encode(tgt_tree_t * tree, int leafno, int threshold);\r
+\r
+/*\r
+ * Decode the value of a leaf of the tag-tree up to a given threshold\r
+ * leafno: number that identifies the leaf to decode\r
+ * threshold: threshold to use when decoding value of the leaf\r
+ */\r
+int tgt_decode(tgt_tree_t * tree, int leafno, int threshold);\r
+\r
+#endif\r
projects / openjpeg.git / commitdiff