--- /dev/null
+CC = gcc
+
+LDFLAGS = -lm
+CFLAGS = -Wall
+
+all: index_create
+
+
+bio.o : bio.c bio.h
+cio.o : cio.c cio.h
+int.o : int.c
+pi.o : pi.c pi.h int.h
+index_create.o : index_create.c j2k.h cio.h tcd.h int.h
+t2.o : t2.c t2.h tcd.h bio.h j2k.h pi.h tgt.h int.h cio.h
+tgt.o : tgt.c bio.h tgt.h
+tcd.o : tcd.c tcd.h t2.h int.h
+jpip.o : jpip.c j2k.h cio.h tcd.h int.h
+jp2.o : jp2.c j2k.h cio.h tcd.h int.h
+
+index_create : bio.o cio.o int.o pi.o t2.o tgt.o tcd.o index_create.o jpip.o jp2.o
+
+clean:
+ rm -rf *.o *.*~ *~ core.*
--- /dev/null
+/*
+ * Copyright (c) 2001-2002, David Janssens
+ * Copyright (c) 2003, Yannick Verschueren
+ * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "bio.h"
+#include <setjmp.h>
+
+static unsigned char *bio_start, *bio_end, *bio_bp;
+static unsigned int bio_buf;
+static int bio_ct;
+
+extern jmp_buf j2k_error;
+
+/// <summary>
+/// Number of bytes written.
+/// </summary>
+int bio_numbytes() {
+ return bio_bp-bio_start;
+}
+
+/// <summary>
+/// Init encoder.
+/// </summary>
+/// <param name="bp">Output buffer</param>
+/// <param name="len">Output buffer length</param>
+void bio_init_enc(unsigned char *bp, int len) {
+ bio_start=bp;
+ bio_end=bp+len;
+ bio_bp=bp;
+ bio_buf=0;
+ bio_ct=8;
+}
+
+/// <summary>
+/// Init decoder.
+/// </summary>
+/// <param name="bp">Input buffer</param>
+/// <param name="len">Input buffer length</param>
+void bio_init_dec(unsigned char *bp, int len) {
+ bio_start=bp;
+ bio_end=bp+len;
+ bio_bp=bp;
+ bio_buf=0;
+ bio_ct=0;
+}
+
+/// <summary>
+/// Write byte.
+/// </summary>
+int bio_byteout() {
+ bio_buf=(bio_buf<<8)&0xffff;
+ bio_ct=bio_buf==0xff00?7:8;
+ if (bio_bp>=bio_end) return 1; //longjmp(j2k_error, 1);
+ *bio_bp++=bio_buf>>8;
+ return 0;
+}
+
+/// <summary>
+/// Read byte.
+/// </summary>
+int bio_bytein() {
+ bio_buf=(bio_buf<<8)&0xffff;
+ bio_ct=bio_buf==0xff00?7:8;
+ if (bio_bp>=bio_end) return 1; //longjmp(j2k_error, 1);
+ bio_buf|=*bio_bp++;
+ return 0;
+}
+
+/// <summary>
+/// Write bit.
+/// </summary>
+/// <param name="b">Bit to write (0 or 1)</param>
+void bio_putbit(int b) {
+ if (bio_ct==0) {
+ bio_byteout();
+ }
+ bio_ct--;
+ bio_buf|=b<<bio_ct;
+}
+
+/// <summary>
+/// Read bit.
+/// </summary>
+int bio_getbit() {
+ if (bio_ct==0) {
+ bio_bytein();
+ }
+ bio_ct--;
+ return (bio_buf>>bio_ct)&1;
+}
+
+/// <summary>
+/// Write bits.
+/// </summary>
+/// <param name="v">Value of bits</param>
+/// <param name="n">Number of bits to write</param>
+void bio_write(int v, int n) {
+ int i;
+ for (i=n-1; i>=0; i--) {
+ bio_putbit((v>>i)&1);
+ }
+}
+
+/// <summary>
+/// Read bits.
+/// </summary>
+/// <param name="n">Number of bits to read</param>
+int bio_read(int n) {
+ int i, v;
+ v=0;
+ for (i=n-1; i>=0; i--) {
+ v+=bio_getbit()<<i;
+ }
+ return v;
+}
+
+/// <summary>
+/// Flush bits.
+/// </summary>
+int bio_flush() {
+ bio_ct=0;
+ bio_byteout();
+ if (bio_ct==7) {
+ bio_ct=0;
+ if ( bio_byteout()) return 1;;
+ }
+ return 0;
+}
+
+/// <summary>
+/// </summary>
+int bio_inalign() {
+ bio_ct=0;
+ if ((bio_buf&0xff)==0xff) {
+ if( bio_bytein()) return 1;
+ bio_ct=0;
+ }
+ return 0;
+}
--- /dev/null
+/*
+ * Copyright (c) 2001-2002, David Janssens
+ * Copyright (c) 2003, Yannick Verschueren
+ * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __BIO_H
+#define __BIO_H
+
+int bio_numbytes();
+void bio_init_enc(unsigned char *bp, int len);
+void bio_init_dec(unsigned char *bp, int len);
+void bio_write(int v, int n);
+int bio_read(int n);
+int bio_flush();
+int bio_inalign();
+
+#endif
--- /dev/null
+/*
+ * Copyright (c) 2001-2002, David Janssens
+ * Copyright (c) 2003, Yannick Verschueren
+ * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "cio.h"
+#include <setjmp.h>
+
+static unsigned char *cio_start, *cio_end, *cio_bp;
+
+extern jmp_buf j2k_error;
+
+/// <summary>
+/// Number of bytes written.
+/// </summary>
+int cio_numbytes() {
+ return cio_bp-cio_start;
+}
+
+/// <summary>
+/// Get position in byte stream.
+/// </summary>
+int cio_tell() {
+ return cio_bp-cio_start;
+}
+
+/// <summary>
+/// Set position in byte stream.
+/// </summary>
+void cio_seek(int pos) {
+ cio_bp=cio_start+pos;
+}
+
+/// <summary>
+/// Number of bytes left before the end of the stream.
+/// </summary>
+int cio_numbytesleft() {
+ return cio_end-cio_bp;
+}
+
+/// <summary>
+/// Get pointer to the current position in the stream.
+/// </summary>
+unsigned char *cio_getbp() {
+ return cio_bp;
+}
+
+/// <summary>
+/// Initialize byte IO.
+/// </summary>
+void cio_init(unsigned char *bp, int len) {
+ cio_start=bp;
+ cio_end=bp+len;
+ cio_bp=bp;
+}
+
+/// <summary>
+/// Write a byte.
+/// </summary>
+void cio_byteout(unsigned char v) {
+ if (cio_bp>=cio_end) longjmp(j2k_error, 1);
+ *cio_bp++=v;
+
+}
+
+/// <summary>
+/// Read a byte.
+/// </summary>
+unsigned char cio_bytein() {
+ if (cio_bp>=cio_end) longjmp(j2k_error, 1);
+ return *cio_bp++;
+}
+
+/// <summary>
+/// Write a byte.
+/// </summary>
+//void cio_write(unsigned int v, int n) {
+void cio_write(long long v, int n) {
+ int i;
+ for (i=n-1; i>=0; i--)
+ {
+ cio_byteout((unsigned char)((v>>(i<<3))&0xff));
+ }
+}
+
+/// <summary>
+/// Read some bytes.
+/// </summary>
+unsigned int cio_read(int n) {
+ int i;
+ unsigned int v;
+ v=0;
+ for (i=n-1; i>=0; i--) {
+ v+=cio_bytein()<<(i<<3);
+ }
+ return v;
+}
+
+/// <summary>
+/// Write some bytes.
+/// </summary>
+void cio_skip(int n) {
+ cio_bp+=n;
+}
--- /dev/null
+/*
+ * Copyright (c) 2001-2002, David Janssens
+ * Copyright (c) 2003, Yannick Verschueren
+ * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __CIO_H
+#define __CIO_H
+
+int cio_tell();
+void cio_seek(int pos);
+int cio_numbytes();
+int cio_numbytesleft();
+unsigned char *cio_getbp();
+void cio_init(unsigned char *bp, int len);
+//void cio_write(unsigned int v, int n);
+void cio_write(long long v, int n);
+unsigned int cio_read(int n);
+void cio_skip(int n);
+
+#endif
--- /dev/null
+/*
+ * Copyright (c) 2001-2002, David Janssens
+ * Copyright (c) 2003, Yannick Verschueren
+ * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "fix.h"
+
+#ifdef WIN32
+#define int64 __int64
+#else
+#define int64 long long
+#endif
+
+/// <summary>
+/// Multiply two fixed-precision rational numbers.
+/// </summary>
+int fix_mul(int a, int b) {
+ return (int)((int64)a*(int64)b>>13);
+}
--- /dev/null
+/*
+ * Copyright (c) 2001-2002, David Janssens
+ * Copyright (c) 2003, Yannick Verschueren
+ * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __FIX_H
+#define __FIX_H
+
+int fix_mul(int a, int b);
+
+#endif
--- /dev/null
+/*
+ * Copyright (c) 2001-2002, David Janssens
+ * Copyright (c) 2003, Yannick Verschueren
+ * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <setjmp.h>
+#include <math.h>
+#include <unistd.h>
+
+#include "j2k.h"
+#include "cio.h"
+#include "tcd.h"
+#include "int.h"
+#include "jpip.h"
+#include "jp2.h"
+
+#define J2K_MS_SOC 0xff4f
+#define J2K_MS_SOT 0xff90
+#define J2K_MS_SOD 0xff93
+#define J2K_MS_EOC 0xffd9
+#define J2K_MS_SIZ 0xff51
+#define J2K_MS_COD 0xff52
+#define J2K_MS_COC 0xff53
+#define J2K_MS_RGN 0xff5e
+#define J2K_MS_QCD 0xff5c
+#define J2K_MS_QCC 0xff5d
+#define J2K_MS_POC 0xff5f
+#define J2K_MS_TLM 0xff55
+#define J2K_MS_PLM 0xff57
+#define J2K_MS_PLT 0xff58
+#define J2K_MS_PPM 0xff60
+#define J2K_MS_PPT 0xff61
+#define J2K_MS_SOP 0xff91
+#define J2K_MS_EPH 0xff92
+#define J2K_MS_CRG 0xff63
+#define J2K_MS_COM 0xff64
+
+#define J2K_STATE_MHSOC 0x0001
+#define J2K_STATE_MHSIZ 0x0002
+#define J2K_STATE_MH 0x0004
+#define J2K_STATE_TPHSOT 0x0008
+#define J2K_STATE_TPH 0x0010
+#define J2K_STATE_MT 0x0020
+
+jmp_buf j2k_error;
+
+static int j2k_state;
+static int j2k_curtileno;
+static j2k_tcp_t j2k_default_tcp;
+static unsigned char *j2k_eot;
+
+static j2k_image_t *j2k_img;
+static j2k_cp_t *j2k_cp;
+
+static unsigned char **j2k_tile_data;
+static int *j2k_tile_len;
+
+static info_image_t img;
+
+void j2k_clean() {
+ int tileno = 0;
+ int compno, resno, precno;
+
+ tcd_free(j2k_img,j2k_cp);
+
+ for (tileno=0;tileno<j2k_cp->tw*j2k_cp->th;tileno++) {
+ info_tile_t *tile_Idx = &img.tile[tileno];
+
+ for (compno=0;compno<img.Comp;compno++)
+ {
+ info_compo_t *compo_Idx = &tile_Idx->compo[compno];
+
+ for(resno=0;resno<img.Decomposition+1;resno++)
+ {
+ info_reso_t *reso_Idx = &compo_Idx->reso[resno];
+ for (precno=0;precno<img.tile[tileno].pw*img.tile[tileno].ph;precno++)
+ {
+ info_prec_t *prec_Idx = &reso_Idx->prec[precno];
+ free(prec_Idx->layer);
+ }
+ free(reso_Idx->prec);
+ }
+ free(compo_Idx->reso);
+ }
+ free(tile_Idx->compo);
+ }
+ free(img.tile);
+ free(img.marker);
+}
+
+void j2k_read_soc() {
+ j2k_state=J2K_STATE_MHSIZ;
+}
+
+void j2k_read_siz() {
+ int len, i;
+ len=cio_read(2);
+
+ // <INDEX>
+ img.marker[img.num_marker].type=J2K_MS_SIZ;
+ img.marker[img.num_marker].start_pos=cio_tell()-2;
+ img.marker[img.num_marker].len=len;
+ img.num_marker++;
+ // </INDEX>
+
+
+ cio_read(2); // Rsiz (capabilities)
+ j2k_img->x1=cio_read(4); // Xsiz
+ j2k_img->y1=cio_read(4); // Ysiz
+ j2k_img->x0=cio_read(4); // X0siz
+ j2k_img->y0=cio_read(4); // Y0siz
+ j2k_cp->tdx=cio_read(4); // XTsiz
+ j2k_cp->tdy=cio_read(4); // YTsiz
+ j2k_cp->tx0=cio_read(4); // XT0siz
+ j2k_cp->ty0=cio_read(4); // YTOsiz
+ j2k_img->numcomps=cio_read(2); // Csiz
+ j2k_img->comps=(j2k_comp_t*)malloc(j2k_img->numcomps*sizeof(j2k_comp_t));
+ for (i=0; i<j2k_img->numcomps; i++) {
+ int tmp, w, h;
+ tmp=cio_read(1);
+ j2k_img->comps[i].prec=(tmp&0x7f)+1;
+ j2k_img->comps[i].sgnd=tmp>>7;
+ j2k_img->comps[i].dx=cio_read(1);
+ j2k_img->comps[i].dy=cio_read(1);
+ w=int_ceildiv(j2k_img->x1-j2k_img->x0, j2k_img->comps[i].dx);
+ h=int_ceildiv(j2k_img->y1-j2k_img->y0, j2k_img->comps[i].dy);
+ j2k_img->comps[i].data=(int*)malloc(sizeof(int)*w*h);
+ }
+ j2k_cp->tw=int_ceildiv(j2k_img->x1-j2k_img->x0, j2k_cp->tdx);
+ j2k_cp->th=int_ceildiv(j2k_img->y1-j2k_img->y0, j2k_cp->tdy);
+
+ j2k_cp->tcps=(j2k_tcp_t*)calloc(sizeof(j2k_tcp_t), j2k_cp->tw*j2k_cp->th);
+ j2k_default_tcp.tccps=(j2k_tccp_t*)calloc(sizeof(j2k_tccp_t), j2k_img->numcomps);
+ for (i=0; i<j2k_cp->tw*j2k_cp->th; i++) {
+ j2k_cp->tcps[i].tccps=(j2k_tccp_t*)calloc(sizeof(j2k_tccp_t), j2k_img->numcomps);
+ }
+ j2k_tile_data=(unsigned char**)calloc(j2k_cp->tw*j2k_cp->th, sizeof(char*));
+ j2k_tile_len=(int*)calloc(j2k_cp->tw*j2k_cp->th, sizeof(int));
+ j2k_state=J2K_STATE_MH;
+
+ // <INDEX>
+ img.Im_w=j2k_img->x1-j2k_img->x0;
+ img.Im_h=j2k_img->y1-j2k_img->y0;
+ img.Tile_x=j2k_cp->tdx;
+ img.Tile_y=j2k_cp->tdy;
+ img.Comp=j2k_img->numcomps;
+ img.tw=j2k_cp->tw;
+ img.th=j2k_cp->th;
+ img.tile=(info_tile_t*)malloc((img.tw*img.th)*sizeof(info_tile_t));
+ //</INDEX>
+
+
+ }
+
+void j2k_read_com() {
+ int len;
+ len=cio_read(2);
+
+ // <INDEX>
+ if (j2k_state==J2K_STATE_MH)
+ {
+ if (!img.marker_mul.num_COM)
+ img.marker_mul.COM=(info_marker_t*)malloc(sizeof(info_marker_t));
+ else
+ img.marker_mul.COM=realloc(img.marker_mul.COM,(1+img.marker_mul.num_COM)*sizeof(info_marker_t));
+ img.marker_mul.COM[img.marker_mul.num_COM].type=J2K_MS_COM;
+ img.marker_mul.COM[img.marker_mul.num_COM].start_pos=cio_tell()-2;
+ img.marker_mul.COM[img.marker_mul.num_COM].len=len;
+ img.marker_mul.num_COM++;
+ }
+ // </INDEX>
+
+ cio_skip(len-2);
+}
+
+void j2k_read_cox(int compno) {
+ int i;
+ j2k_tcp_t *tcp;
+ j2k_tccp_t *tccp;
+ tcp=j2k_state==J2K_STATE_TPH?&j2k_cp->tcps[j2k_curtileno]:&j2k_default_tcp;
+ tccp=&tcp->tccps[compno];
+ tccp->numresolutions=cio_read(1)+1;
+
+ img.Decomposition=tccp->numresolutions-1; // <INDEX>
+
+ tccp->cblkw=cio_read(1)+2;
+ tccp->cblkh=cio_read(1)+2;
+ tccp->cblksty=cio_read(1);
+ tccp->qmfbid=cio_read(1);
+ if (tccp->csty&J2K_CP_CSTY_PRT) {
+ for (i=0; i<tccp->numresolutions; i++) {
+ int tmp=cio_read(1);
+ tccp->prcw[i]=tmp&0xf;
+ tccp->prch[i]=tmp>>4;
+ }
+ }
+}
+
+void j2k_read_cod() {
+ int len, i, pos;
+ j2k_tcp_t *tcp;
+ tcp=j2k_state==J2K_STATE_TPH?&j2k_cp->tcps[j2k_curtileno]:&j2k_default_tcp;
+ len=cio_read(2);
+
+ // <INDEX>
+ if (j2k_state==J2K_STATE_MH)
+ {
+ if (!img.marker_mul.num_COD)
+ img.marker_mul.COD=(info_marker_t*)malloc(sizeof(info_marker_t));
+ else
+ img.marker_mul.COD=realloc(img.marker_mul.COD,(1+img.marker_mul.num_COD)*sizeof(info_marker_t));
+ img.marker_mul.COD[img.marker_mul.num_COD].type=J2K_MS_COD;
+ img.marker_mul.COD[img.marker_mul.num_COD].start_pos=cio_tell()-2;
+ img.marker_mul.COD[img.marker_mul.num_COD].len=len;
+ img.marker_mul.num_COD++;
+ }
+ // </INDEX>
+
+
+ tcp->csty=cio_read(1);
+ tcp->prg=cio_read(1);
+ tcp->numlayers=cio_read(2);
+ tcp->mct=cio_read(1);
+ pos=cio_tell();
+ for (i=0; i<j2k_img->numcomps; i++) {
+ tcp->tccps[i].csty=tcp->csty&J2K_CP_CSTY_PRT;
+ cio_seek(pos);
+ j2k_read_cox(i);
+ }
+ //<INDEX>
+ img.Prog=tcp->prg;
+ img.Layer=tcp->numlayers;
+ //</INDEX>
+}
+
+void j2k_read_coc() {
+ int len, compno;
+ j2k_tcp_t *tcp;
+ tcp=j2k_state==J2K_STATE_TPH?&j2k_cp->tcps[j2k_curtileno]:&j2k_default_tcp;
+ len=cio_read(2);
+ // <INDEX>
+ if (j2k_state==J2K_STATE_MH)
+ {
+ if (!img.marker_mul.num_COC)
+ img.marker_mul.COC=(info_marker_t*)malloc(sizeof(info_marker_t));
+ else
+ img.marker_mul.COC=realloc(img.marker_mul.COC,(1+img.marker_mul.num_COC)*sizeof(info_marker_t));
+ img.marker_mul.COC[img.marker_mul.num_COC].type=J2K_MS_COC;
+ img.marker_mul.COC[img.marker_mul.num_COC].start_pos=cio_tell()-2;
+ img.marker_mul.COC[img.marker_mul.num_COC].len=len;
+ img.marker_mul.num_COC++;
+ }
+ // </INDEX>
+
+
+ compno=cio_read(j2k_img->numcomps<=256?1:2);
+ tcp->tccps[compno].csty=cio_read(1);
+ j2k_read_cox(compno);
+}
+
+void j2k_read_qcx(int compno, int len) {
+ int tmp;
+ j2k_tcp_t *tcp;
+ j2k_tccp_t *tccp;
+ int bandno, numbands;
+ tcp=j2k_state==J2K_STATE_TPH?&j2k_cp->tcps[j2k_curtileno]:&j2k_default_tcp;
+ tccp=&tcp->tccps[compno];
+ tmp=cio_read(1);
+ tccp->qntsty=tmp&0x1f;
+ tccp->numgbits=tmp>>5;
+ numbands=tccp->qntsty==J2K_CCP_QNTSTY_SIQNT?1:(tccp->qntsty==J2K_CCP_QNTSTY_NOQNT?len-1:(len-1)/2);
+ for (bandno=0; bandno<numbands; bandno++) {
+ int expn, mant;
+ if (tccp->qntsty==J2K_CCP_QNTSTY_NOQNT) { // WHY STEPSIZES WHEN NOQNT ?
+ expn=cio_read(1)>>3;
+ mant=0;
+ } else {
+ tmp=cio_read(2);
+ expn=tmp>>11;
+ mant=tmp&0x7ff;
+ }
+ tccp->stepsizes[bandno].expn=expn;
+ tccp->stepsizes[bandno].mant=mant;
+ }
+}
+
+void j2k_read_qcd() {
+ int len, i, pos;
+ len=cio_read(2);
+
+ // <INDEX>
+ if (j2k_state==J2K_STATE_MH)
+ {
+ img.marker[img.num_marker].type=J2K_MS_QCD;
+ img.marker[img.num_marker].start_pos=cio_tell()-2;
+ img.marker[img.num_marker].len=len;
+ img.num_marker++;
+ }
+ // </INDEX>
+
+
+ pos=cio_tell();
+ for (i=0; i<j2k_img->numcomps; i++) {
+ cio_seek(pos);
+ j2k_read_qcx(i, len-2);
+ }
+}
+
+void j2k_read_qcc() {
+ int len, compno;
+ len=cio_read(2);
+
+ // <INDEX>
+ if (j2k_state==J2K_STATE_MH)
+ {
+ if (!img.marker_mul.num_QCC)
+ img.marker_mul.QCC=(info_marker_t*)malloc(sizeof(info_marker_t));
+ else
+ img.marker_mul.QCC=realloc(img.marker_mul.QCC,(1+img.marker_mul.num_QCC)*sizeof(info_marker_t));
+ img.marker_mul.QCC[img.marker_mul.num_QCC].type=J2K_MS_QCC;
+ img.marker_mul.QCC[img.marker_mul.num_QCC].start_pos=cio_tell()-2;
+ img.marker_mul.QCC[img.marker_mul.num_QCC].len=len;
+ img.marker_mul.num_QCC++;
+ }
+ // </INDEX>
+
+
+ compno=cio_read(j2k_img->numcomps<=256?1:2);
+ j2k_read_qcx(compno, len-2-(j2k_img->numcomps<=256?1:2));
+}
+
+void j2k_read_poc() {
+ int len, numpchgs, i;
+ j2k_tcp_t *tcp;
+ fprintf(stderr, "WARNING: POC marker segment processing not fully implemented\n");
+ tcp=j2k_state==J2K_STATE_TPH?&j2k_cp->tcps[j2k_curtileno]:&j2k_default_tcp;
+ len=cio_read(2);
+
+ // <INDEX>
+ if (j2k_state==J2K_STATE_MH)
+ {
+ img.marker[img.num_marker].type=J2K_MS_POC;
+ img.marker[img.num_marker].start_pos=cio_tell()-2;
+ img.marker[img.num_marker].len=len;
+ img.num_marker++;
+ }
+ // </INDEX>
+
+
+ numpchgs=(len-2)/(5+2*(j2k_img->numcomps<=256?1:2));
+ for (i=0; i<numpchgs; i++) {
+ j2k_poc_t *poc;
+ poc=&tcp->pocs[i];
+ poc->resno0=cio_read(1);
+ poc->compno0=cio_read(j2k_img->numcomps<=256?1:2);
+ poc->layno1=cio_read(2);
+ poc->resno1=cio_read(1);
+ poc->compno1=cio_read(j2k_img->numcomps<=256?1:2);
+ poc->prg=cio_read(1);
+ }
+}
+
+void j2k_read_crg() {
+ int len;
+ len=cio_read(2);
+
+ // <INDEX>
+ if (j2k_state==J2K_STATE_MH)
+ {
+ img.marker[img.num_marker].type=J2K_MS_CRG;
+ img.marker[img.num_marker].start_pos=cio_tell()-2;
+ img.marker[img.num_marker].len=len;
+ img.num_marker++;
+ }
+ // </INDEX>
+
+ fprintf(stderr, "WARNING: CRG marker segment processing not implemented\n");
+ cio_skip(len-2);
+}
+
+void j2k_read_tlm() {
+ int len;
+ len=cio_read(2);
+
+ // <INDEX>
+ if (j2k_state==J2K_STATE_MH)
+ {
+ if (!img.marker_mul.num_TLM)
+ img.marker_mul.TLM=(info_marker_t*)malloc(sizeof(info_marker_t));
+ else
+ img.marker_mul.TLM=realloc(img.marker_mul.TLM,(1+img.marker_mul.num_TLM)*sizeof(info_marker_t));
+ img.marker_mul.TLM[img.marker_mul.num_TLM].type=J2K_MS_TLM;
+ img.marker_mul.TLM[img.marker_mul.num_TLM].start_pos=cio_tell()-2;
+ img.marker_mul.TLM[img.marker_mul.num_TLM].len=len;
+ img.marker_mul.num_TLM++;
+ }
+ // </INDEX>
+
+ fprintf(stderr, "WARNING: TLM marker segment processing not implemented\n");
+ cio_skip(len-2);
+}
+
+void j2k_read_plm() {
+ int len;
+ len=cio_read(2);
+
+ // <INDEX>
+ if (j2k_state==J2K_STATE_MH)
+ {
+ if (!img.marker_mul.num_PLM)
+ img.marker_mul.PLM=(info_marker_t*)malloc(sizeof(info_marker_t));
+ else
+ img.marker_mul.PLM=realloc(img.marker_mul.PLM,(1+img.marker_mul.num_PLM)*sizeof(info_marker_t));
+ img.marker_mul.PLM[img.marker_mul.num_PLM].type=J2K_MS_PLM;
+ img.marker_mul.PLM[img.marker_mul.num_PLM].start_pos=cio_tell()-2;
+ img.marker_mul.PLM[img.marker_mul.num_PLM].len=len;
+ img.marker_mul.num_PLM++;
+ }
+ // </INDEX>
+
+ fprintf(stderr, "WARNING: PLM marker segment processing not implemented\n");
+ cio_skip(len-2);
+}
+
+void j2k_read_plt() {
+ int len;
+ len=cio_read(2);
+ fprintf(stderr, "WARNING: PLT marker segment processing not implemented\n");
+ cio_skip(len-2);
+}
+
+void j2k_read_ppm() {
+ int len;
+ len=cio_read(2);
+ // <INDEX>
+ if (j2k_state==J2K_STATE_MH)
+ {
+ img.marker[img.num_marker].type=J2K_MS_PPM;
+ img.marker[img.num_marker].start_pos=cio_tell()-2;
+ img.marker[img.num_marker].len=len;
+ img.num_marker++;
+ }
+ // </INDEX>
+
+ fprintf(stderr, "WARNING: PPM marker segment processing not implemented\n");
+ cio_skip(len-2);
+}
+
+void j2k_read_ppt() {
+ int len;
+ len=cio_read(2);
+ fprintf(stderr, "WARNING: PPT marker segment processing not implemented\n");
+ cio_skip(len-2);
+}
+
+void j2k_read_sot() {
+ int len, tileno, totlen, partno, numparts, i;
+ j2k_tcp_t *tcp;
+ j2k_tccp_t *tmp;
+ len=cio_read(2);
+ tileno=cio_read(2);
+ //<INDEX>
+ if (!tileno) img.Main_head_end=cio_tell()-6; // Correction End = First byte of first SOT
+ img.tile[tileno].start_pos=cio_tell()-6;
+ img.tile[tileno].num_tile=tileno;
+ // </INDEX>
+ totlen=cio_read(4);
+ if (!totlen) totlen = cio_numbytesleft() + 8;
+
+ img.tile[tileno].end_pos=totlen+img.tile[tileno].start_pos; // <INDEX>
+
+ partno=cio_read(1);
+ numparts=cio_read(1);
+ j2k_curtileno=tileno;
+ j2k_eot=cio_getbp()-12+totlen;
+ j2k_state=J2K_STATE_TPH;
+ tcp=&j2k_cp->tcps[j2k_curtileno];
+ tmp=tcp->tccps;
+ *tcp=j2k_default_tcp;
+ tcp->tccps=tmp;
+ for (i=0; i<j2k_img->numcomps; i++) {
+ tcp->tccps[i]=j2k_default_tcp.tccps[i];
+ }
+}
+
+void j2k_read_sod() {
+ int len;
+ unsigned char *data;
+ img.tile[j2k_curtileno].end_header=cio_tell()-1; //<INDEX>
+ len=int_min(j2k_eot-cio_getbp(), cio_numbytesleft());
+ j2k_tile_len[j2k_curtileno]+=len;
+ data=(unsigned char*)realloc(j2k_tile_data[j2k_curtileno], j2k_tile_len[j2k_curtileno]);
+ memcpy(data, cio_getbp(), len);
+ j2k_tile_data[j2k_curtileno]=data;
+ cio_skip(len);
+ j2k_state=J2K_STATE_TPHSOT;
+
+}
+
+void j2k_read_rgn() {
+ int len, compno, roisty;
+ j2k_tcp_t *tcp;
+ tcp=j2k_state==J2K_STATE_TPH?&j2k_cp->tcps[j2k_curtileno]:&j2k_default_tcp;
+ len=cio_read(2);
+
+ // <INDEX>
+ if (j2k_state==J2K_STATE_MH)
+ {
+ if (!img.marker_mul.num_RGN)
+ img.marker_mul.RGN=(info_marker_t*)malloc(sizeof(info_marker_t));
+ else
+ img.marker_mul.RGN=realloc(img.marker_mul.RGN,(1+img.marker_mul.num_RGN)*sizeof(info_marker_t));
+ img.marker_mul.RGN[img.marker_mul.num_RGN].type=J2K_MS_RGN;
+ img.marker_mul.RGN[img.marker_mul.num_RGN].start_pos=cio_tell()-2;
+ img.marker_mul.RGN[img.marker_mul.num_RGN].len=len;
+ img.marker_mul.num_RGN++;
+ }
+ // </INDEX>
+
+
+ compno=cio_read(j2k_img->numcomps<=256?1:2);
+ roisty=cio_read(1);
+ tcp->tccps[compno].roishift=cio_read(1);
+}
+
+void j2k_read_eoc() {
+ int tileno;
+ tcd_init(j2k_img, j2k_cp, &img);
+ for (tileno=0; tileno<j2k_cp->tw*j2k_cp->th; tileno++) {
+ tcd_decode_tile(j2k_tile_data[tileno], j2k_tile_len[tileno], tileno, &img);
+ }
+
+ j2k_state=J2K_STATE_MT;
+ longjmp(j2k_error, 1);
+
+}
+
+void j2k_read_unk() {
+ fprintf(stderr, "warning: unknown marker\n");
+}
+
+int j2k_index_JPIP(char *Idx_file, char *J2K_file, int len){
+ FILE *dest;
+ char *index;
+ int pos_iptr, end_pos;
+ int len_cidx, pos_cidx;
+ int len_jp2c, pos_jp2c;
+ int len_fidx, pos_fidx;
+
+ dest=fopen(Idx_file, "wb");
+ if (!dest) {
+ fprintf(stderr,"Failed to open %s for reading !!\n",Idx_file);
+ return 0;
+ }
+
+ // INDEX MODE JPIP
+ index=(char*)malloc(len);
+ cio_init(index, len);
+ jp2_write_jp();
+ jp2_write_ftyp();
+
+ jp2_write_jp2h(j2k_img);
+ jp2_write_dbtl(Idx_file);
+
+ pos_iptr=cio_tell();
+ cio_skip(24); // IPTR further !
+
+ pos_jp2c=cio_tell();
+ len_jp2c=jp2_write_jp2c(J2K_file);
+
+ pos_cidx=cio_tell();
+ len_cidx=jpip_write_cidx(pos_jp2c+8,img, j2k_cp); // Correction len_jp2C --> pos_jp2c+8
+
+ pos_fidx=cio_tell();
+ len_fidx=jpip_write_fidx(pos_jp2c, len_jp2c, pos_cidx, len_cidx);
+
+ end_pos=cio_tell();
+ cio_seek(pos_iptr);
+ jpip_write_iptr(pos_fidx,len_fidx);
+ cio_seek(end_pos);
+
+ fwrite(index, 1, cio_tell(), dest);
+ free(index);
+
+ fclose(dest);
+ return 1;
+}
+
+
+
+typedef struct {
+ int id;
+ int states;
+ void (*handler)();
+} j2k_dec_mstabent_t;
+
+j2k_dec_mstabent_t j2k_dec_mstab[]={
+ {J2K_MS_SOC, J2K_STATE_MHSOC, j2k_read_soc},
+ {J2K_MS_SOT, J2K_STATE_MH|J2K_STATE_TPHSOT, j2k_read_sot},
+ {J2K_MS_SOD, J2K_STATE_TPH, j2k_read_sod},
+ {J2K_MS_EOC, J2K_STATE_TPHSOT, j2k_read_eoc},
+ {J2K_MS_SIZ, J2K_STATE_MHSIZ, j2k_read_siz},
+ {J2K_MS_COD, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_cod},
+ {J2K_MS_COC, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_coc},
+ {J2K_MS_RGN, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_rgn},
+ {J2K_MS_QCD, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_qcd},
+ {J2K_MS_QCC, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_qcc},
+ {J2K_MS_POC, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_poc},
+ {J2K_MS_TLM, J2K_STATE_MH, j2k_read_tlm},
+ {J2K_MS_PLM, J2K_STATE_MH, j2k_read_plm},
+ {J2K_MS_PLT, J2K_STATE_TPH, j2k_read_plt},
+ {J2K_MS_PPM, J2K_STATE_MH, j2k_read_ppm},
+ {J2K_MS_PPT, J2K_STATE_TPH, j2k_read_ppt},
+ {J2K_MS_SOP, 0, 0},
+ {J2K_MS_CRG, J2K_STATE_MH, j2k_read_crg},
+ {J2K_MS_COM, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_com},
+ {0, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_unk}
+};
+
+j2k_dec_mstabent_t *j2k_dec_mstab_lookup(int id) {
+ j2k_dec_mstabent_t *e;
+ for (e=j2k_dec_mstab; e->id!=0; e++) {
+ if (e->id==id) {
+ break;
+ }
+ }
+ return e;
+}
+
+LIBJ2K_API int j2k_decode(unsigned char *src, int len, j2k_image_t **image, j2k_cp_t **cp) {
+ if (setjmp(j2k_error)) {
+ if (j2k_state!=J2K_STATE_MT) {
+ fprintf(stderr, "WARNING: incomplete bitstream\n");
+ return 0;
+ }
+ return cio_numbytes();
+ }
+ j2k_img=(j2k_image_t*)malloc(sizeof(j2k_image_t));
+ j2k_cp=(j2k_cp_t*)malloc(sizeof(j2k_cp_t));
+ *image=j2k_img;
+ *cp=j2k_cp;
+ j2k_state=J2K_STATE_MHSOC;
+ cio_init(src, len);
+ for (;;) {
+ j2k_dec_mstabent_t *e;
+ int id=cio_read(2);
+ if (id>>8!=0xff) {
+ fprintf(stderr, "%.8x: expected a marker instead of %x\n", cio_tell()-2, id);
+ return 0;
+ }
+ e=j2k_dec_mstab_lookup(id);
+ if (!(j2k_state & e->states)) {
+ fprintf(stderr, "%.8x: unexpected marker %x\n", cio_tell()-2, id);
+ return 0;
+ }
+ if (e->handler) {
+ (*e->handler)();
+ }
+ }
+
+}
+
+#ifdef WIN32
+#include <windows.h>
+
+BOOL APIENTRY DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
+ switch (ul_reason_for_call) {
+ case DLL_PROCESS_ATTACH:
+ case DLL_THREAD_ATTACH:
+ case DLL_THREAD_DETACH:
+ case DLL_PROCESS_DETACH:
+ break;
+ }
+ return TRUE;
+}
+#endif
+
+
+extern info_image_t img;
+
+
+int main(int argc, char **argv)
+{
+ FILE *src;
+ int totlen;
+ char *j2kfile;
+ j2k_image_t *imgg;
+ j2k_cp_t *cp;
+
+ if (argc!=3)
+ {
+ fprintf(stderr,"\nERROR in entry : index_create J2K-file Idx-file\n\n");
+ return 0;
+ }
+
+ src=fopen(argv[1], "rb");
+ if (!src) {
+ fprintf(stderr,"Failed to open %s for reading !!\n",argv[1]);
+ return 0;
+ }
+
+ // length of the codestream
+ fseek(src, 0, SEEK_END);
+ totlen=ftell(src);
+ fseek(src, 0, SEEK_SET);
+
+ j2kfile=(char*)malloc(totlen);
+ fread(j2kfile, 1, totlen, src);
+
+ img.marker=(info_marker_t*)malloc(32*sizeof(info_marker_t));
+ img.num_marker=0;
+ img.marker_mul.num_COD=0;
+ img.marker_mul.num_COC=0;
+ img.marker_mul.num_RGN=0;
+ img.marker_mul.num_QCC=0;
+ img.marker_mul.num_TLM=0;
+ img.marker_mul.num_PLM=0;
+ img.marker_mul.num_COM=0;
+
+ // decode
+
+ if (!j2k_decode(j2kfile, totlen, &imgg, &cp)) {
+ fprintf(stderr, "Index_creator: failed to decode image!\n");
+ return 1;
+ }
+
+ free(j2kfile);
+
+ fseek(src, 0, SEEK_SET);
+ img.codestream_size=totlen;
+
+ j2k_index_JPIP(argv[2],argv[1],totlen*2>30000?totlen*2:30000);
+
+ fclose(src);
+
+ j2k_clean();
+ return 1;
+}
--- /dev/null
+/*
+ * Copyright (c) 2001-2002, David Janssens
+ * Copyright (c) 2003, Yannick Verschueren
+ * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/// <summary>
+/// Get the minimum of two integers.
+/// </summary>
+int int_min(int a, int b) {
+ return a<b?a:b;
+}
+
+/// <summary>
+/// Get the maximum of two integers.
+/// </summary>
+int int_max(int a, int b) {
+ return a>b?a:b;
+}
+
+/// <summary>
+/// Clamp an integer inside an interval.
+/// </summary>
+int int_clamp(int a, int min, int max) {
+ if (a<min) return min;
+ if (a>max) return max;
+ return a;
+}
+
+/// <summary>
+/// Get absolute value of integer.
+/// </summary>
+int int_abs(int a) {
+ return a<0?-a:a;
+}
+
+/// <summary>
+/// Divide an integer and round upwards.
+/// </summary>
+int int_ceildiv(int a, int b) {
+ return (a+b-1)/b;
+}
+
+/// <summary>
+/// Divide an integer by a power of 2 and round upwards.
+/// </summary>
+int int_ceildivpow2(int a, int b) {
+ return (a+(1<<b)-1)>>b;
+}
+
+/// <summary>
+/// Divide an integer by a power of 2 and round downwards.
+/// </summary>
+int int_floordivpow2(int a, int b) {
+ return a>>b;
+}
+
+/// <summary>
+/// Get logarithm of an integer and round downwards.
+/// </summary>
+int int_floorlog2(int a) {
+ int l;
+ for (l=0; a>1; l++) {
+ a>>=1;
+ }
+ return l;
+}
--- /dev/null
+/*
+ * Copyright (c) 2001-2002, David Janssens
+ * Copyright (c) 2003, Yannick Verschueren
+ * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __INT_H
+#define __INT_H
+
+int int_min(int a, int b);
+int int_max(int a, int b);
+int int_clamp(int a, int min, int max);
+int int_abs(int a);
+int int_ceildiv(int a, int b);
+int int_ceildivpow2(int a, int b);
+int int_floordivpow2(int a, int b);
+int int_floorlog2(int a);
+
+#endif
--- /dev/null
+/*
+ * Copyright (c) 2001-2002, David Janssens
+ * Copyright (c) 2003, Yannick Verschueren
+ * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#define VERSION "0.0.8"
+
+#ifdef WIN32
+#ifdef LIBJ2K_EXPORTS
+#define LIBJ2K_API __declspec(dllexport)
+#else
+#define LIBJ2K_API __declspec(dllimport)
+#endif
+#else
+#define LIBJ2K_API
+#endif
+
+#ifndef __J2K_H
+#define __J2K_H
+
+#define J2K_MAXRLVLS 33
+#define J2K_MAXBANDS (3*J2K_MAXRLVLS+1)
+
+#define J2K_CP_CSTY_PRT 0x01
+#define J2K_CP_CSTY_SOP 0x02
+#define J2K_CP_CSTY_EPH 0x04
+#define J2K_CCP_CSTY_PRT 0x01
+#define J2K_CCP_CBLKSTY_LAZY 0x01
+#define J2K_CCP_CBLKSTY_RESET 0x02
+#define J2K_CCP_CBLKSTY_TERMALL 0x04
+#define J2K_CCP_CBLKSTY_VSC 0x08
+#define J2K_CCP_CBLKSTY_PTERM 0x10
+#define J2K_CCP_CBLKSTY_SEGSYM 0x20
+#define J2K_CCP_QNTSTY_NOQNT 0
+#define J2K_CCP_QNTSTY_SIQNT 1
+#define J2K_CCP_QNTSTY_SEQNT 2
+
+typedef struct
+{
+ int dx, dy; // XRsiz, YRsiz
+ int prec; // precision
+ int bpp; // deapth of image in bits
+ int sgnd; // signed
+ int *data; // image-component data
+} j2k_comp_t;
+
+typedef struct {
+ int x0, y0; // XOsiz, YOsiz
+ int x1, y1; // Xsiz, Ysiz
+ int numcomps; // number of components
+ int index_on; // 0 = no index || 1 = index
+ //int PPT;
+ j2k_comp_t *comps; // image-components
+} j2k_image_t;
+
+typedef struct {
+ int expn; // exponent
+ int mant; // mantissa
+} j2k_stepsize_t;
+
+typedef struct {
+ int csty; // coding style
+ int numresolutions; // number of resolutions
+ int cblkw; // width of code-blocks
+ int cblkh; // height of code-blocks
+ int cblksty; // code-block coding style
+ int qmfbid; // discrete wavelet transform identifier
+ int qntsty; // quantisation style
+ j2k_stepsize_t stepsizes[J2K_MAXBANDS]; // stepsizes used for quantisation
+ int numgbits; // number of guard bits
+ int roishift; // Region Of Interest shift
+ int prcw[J2K_MAXRLVLS]; // Precinct width
+ int prch[J2K_MAXRLVLS]; // Precinct height
+} j2k_tccp_t;
+
+typedef struct {
+ int resno0, compno0;
+ int layno1, resno1, compno1;
+ int prg;
+ int tile;
+ char progorder[4];
+} j2k_poc_t;
+
+typedef struct {
+ int csty; // coding style
+ int prg; // progression order
+ int numlayers; // number of layers
+ int mct; // multi-component transform identifier
+ int rates[100]; // rates of layers
+ int numpocs; // number of progression order changes
+ j2k_poc_t pocs[32]; // progression order changes
+ j2k_tccp_t *tccps; // tile-component coding parameters
+} j2k_tcp_t;
+
+typedef struct {
+ int tx0, ty0; // XTOsiz, YTOsiz
+ int tdx, tdy; // XTsiz, YTsiz
+ int tw, th;
+ j2k_tcp_t *tcps; // tile coding parameters
+} j2k_cp_t;
+
+typedef struct {
+ int len;
+ int len_header;
+ int offset;
+} info_layer_t;
+
+typedef struct {
+ info_layer_t *layer;
+} info_prec_t;
+
+typedef struct {
+ info_prec_t *prec;
+} info_reso_t;
+
+typedef struct {
+ info_reso_t *reso;
+} info_compo_t;
+
+typedef struct {
+ int num_tile; // Number of Tile
+ int start_pos; // Start position
+ int end_header; // End position of the header
+ int end_pos; // End position
+ int pw, ph; // number of precinct by tile
+ int num_packet; // number of packet in the tile
+ info_compo_t *compo; // component [packet]
+} info_tile_t; // index struct
+
+typedef struct {
+ int type; // type of marker [SIZ, QCD, POC, PPM, CRG] appearing only once
+ int start_pos; // Start position of the marker
+ int len; // Length of the marker
+} info_marker_t; // index struct
+
+typedef struct{
+ info_marker_t *COD;
+ int num_COD;
+ info_marker_t *COC;
+ int num_COC;
+ info_marker_t *RGN;
+ int num_RGN;
+ info_marker_t *QCC;
+ int num_QCC;
+ info_marker_t *TLM;
+ int num_TLM;
+ info_marker_t *PLM;
+ int num_PLM;
+ info_marker_t *PPM;
+ int num_PPM;
+ info_marker_t *COM;
+ int num_COM;
+} info_marker_mul_t; // index struct
+
+typedef struct {
+ int index_on;
+ int num; // numero of packet
+ int index_write; // writing the packet inthe index with t2_encode_packets
+ int Im_w, Im_h; // Image width and Height
+ int Prog; // progression order
+ int Tile_x, Tile_y; // Number of Tile in X and Y
+ int tw, th;
+ int Comp; // Component numbers
+ int Layer; // number of layer
+ int Decomposition; // number of decomposition
+ int pw, ph; // nombre precinct in X and Y
+ int pdx, pdy; // size of precinct in X and Y
+ int Main_head_end; // Main header position
+ int codestream_size; // codestream's size
+ info_tile_t *tile; // information concerning tiles inside image
+ info_marker_t *marker; // information concerning markers inside image [only one apparition]
+ info_marker_mul_t marker_mul; // information concerning markers inside image [multiple apparition]
+ int num_marker; // number of marker
+ int num_packet_max; // MAximum number of packet
+} info_image_t; // index struct
+
+
+
+/*
+ * Encode an image into a JPEG-2000 codestream
+ * i: image to encode
+ * cp: coding parameters
+ * dest: destination buffer
+ * len: length of destination buffer
+ * index : index file name
+ */
+LIBJ2K_API int j2k_encode(j2k_image_t *i, j2k_cp_t *cp,char *outfile, int len,char *index);
+
+//LIBJ2K_API int j2k_encode(j2k_image_t *i, j2k_cp_t *cp,unsigned char *dest, int len);
+/*
+ * Decode an image from a JPEG-2000 codestream
+ * src: source buffer
+ * len: length of source buffer
+ * i: decode image
+ * cp: coding parameters that were used to encode the image
+ */
+LIBJ2K_API int j2k_decode(unsigned char *src, int len, j2k_image_t **i, j2k_cp_t **cp);
+
+#endif
--- /dev/null
+/*
+ * Copyright (c) 2003, Yannick Verschueren
+ * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <setjmp.h>
+#include <math.h>
+#include <unistd.h>
+
+#include "j2k.h"
+#include "cio.h"
+#include "tcd.h"
+#include "int.h"
+
+#define JPIP_JPIP 0x6a706970
+
+#define JP2_JP 0x6a502020
+#define JP2_FTYP 0x66747970
+#define JP2_JP2H 0x6a703268
+#define JP2_IHDR 0x69686472
+#define JP2_COLR 0x636f6c72
+#define JP2_JP2C 0x6a703263
+#define JP2_URL 0x75726c20
+#define JP2_DBTL 0x6474626c
+#define JP2_BPCC 0x62706363
+#define JP2 0x6a703220
+
+
+void jp2_write_url(char *Idx_file)
+{
+ int len, lenp, i;
+ char str[256];
+
+ sprintf(str, "%s", Idx_file);
+ lenp=cio_tell();
+ cio_skip(4);
+ cio_write(JP2_URL, 4); // DBTL
+ cio_write(0,1); // VERS
+ cio_write(0,3); // FLAG
+
+ for (i=0; i<strlen(str); i++) {
+ cio_write(str[i], 1);
+ }
+
+ len=cio_tell()-lenp;
+ cio_seek(lenp);
+ cio_write(len,4); // L
+ cio_seek(lenp+len);
+}
+
+void jp2_write_dbtl(char *Idx_file)
+{
+ int len, lenp;
+
+ lenp=cio_tell();
+ cio_skip(4);
+ cio_write(JP2_DBTL, 4); // DBTL
+ cio_write(1,2); // NDR : Only 1
+
+ jp2_write_url(Idx_file); // URL Box
+
+ len=cio_tell()-lenp;
+ cio_seek(lenp);
+ cio_write(len,4); // L
+ cio_seek(lenp+len);
+}
+
+int jp2_write_ihdr(j2k_image_t *j2k_img)
+{
+ int len, lenp,i;
+ int depth_0,depth, sign, BPC_ok=1;
+
+ lenp=cio_tell();
+ cio_skip(4);
+ cio_write(JP2_IHDR, 4); // IHDR
+
+ cio_write(j2k_img->y1-j2k_img->x0,4); // HEIGHT
+ cio_write(j2k_img->x1-j2k_img->x0,4); // WIDTH
+ cio_write(j2k_img->numcomps,2); // NC
+
+ depth_0=j2k_img->comps[0].prec-1;
+ sign=j2k_img->comps[0].sgnd;
+
+ for(i=1;i<j2k_img->numcomps;i++)
+ {
+ depth=j2k_img->comps[i].prec-1;
+ sign=j2k_img->comps[i].sgnd;
+ if(depth_0!=depth) BPC_ok=0;
+ }
+
+ if (BPC_ok)
+ cio_write(depth_0+(sign<<7),1);
+ else
+ cio_write(255,1);
+
+ cio_write(7,1); // C : Always 7
+ cio_write(1,1); // UnkC, colorspace unknow
+ cio_write(0,1); // IPR, no intellectual property
+
+ len=cio_tell()-lenp;
+ cio_seek(lenp);
+ cio_write(len,4); // L
+ cio_seek(lenp+len);
+
+ return BPC_ok;
+}
+
+void jp2_write_bpcc(j2k_image_t *j2k_img)
+{
+ int len, lenp, i;
+
+ lenp=cio_tell();
+ cio_skip(4);
+ cio_write(JP2_BPCC, 4); // BPCC
+
+ for(i=0;i<j2k_img->numcomps;i++)
+ cio_write(j2k_img->comps[i].prec-1+(j2k_img->comps[i].sgnd<<7),1);
+
+ len=cio_tell()-lenp;
+ cio_seek(lenp);
+ cio_write(len,4); // L
+ cio_seek(lenp+len);
+}
+
+void jp2_write_colr(int BPC_ok, j2k_image_t *j2k_img)
+{
+ int len, lenp, meth;
+
+ lenp=cio_tell();
+ cio_skip(4);
+ cio_write(JP2_COLR, 4); // COLR
+
+ if ((j2k_img->numcomps==1 || j2k_img->numcomps==3) && (BPC_ok && j2k_img->comps[0].prec==8))
+ meth=1;
+ else
+ meth=2;
+
+ cio_write(meth,1); // METH
+ cio_write(0,1); // PREC
+ cio_write(0,1); // APPROX
+
+ if (meth==1)
+ cio_write(j2k_img->numcomps>1?16:17,4); // EnumCS
+
+ if (meth==2)
+ cio_write(0,1); // PROFILE (??)
+
+ len=cio_tell()-lenp;
+ cio_seek(lenp);
+ cio_write(len,4); // L
+ cio_seek(lenp+len);
+}
+
+void jp2_write_jp2h(j2k_image_t *j2k_img)
+{
+ int len, lenp, BPC_ok;
+
+ lenp=cio_tell();
+ cio_skip(4);
+ cio_write(JP2_JP2H, 4); // JP2H
+
+ BPC_ok=jp2_write_ihdr(j2k_img);
+
+ if (!BPC_ok)
+ jp2_write_bpcc(j2k_img);
+ jp2_write_colr(BPC_ok, j2k_img);
+
+ len=cio_tell()-lenp;
+ cio_seek(lenp);
+ cio_write(len,4); // L
+ cio_seek(lenp+len);
+}
+
+void jp2_write_ftyp()
+{
+ int len, lenp;
+
+ lenp=cio_tell();
+ cio_skip(4);
+ cio_write(JP2_FTYP, 4); // FTYP
+
+ cio_write(JP2,4); // BR
+ cio_write(0,4); // MinV
+ cio_write(JP2,4); // CL0 : JP2
+ cio_write(JPIP_JPIP,4); // CL1 : JPIP
+
+ len=cio_tell()-lenp;
+ cio_seek(lenp);
+ cio_write(len,4); // L
+ cio_seek(lenp+len);
+}
+
+int jp2_write_jp2c(char *J2K_file)
+{
+ int len, lenp, totlen, i;
+ FILE *src;
+ char *j2kfile;
+
+ lenp=cio_tell();
+ cio_skip(4);
+ cio_write(JP2_JP2C, 4); // JP2C
+
+ src=fopen(J2K_file, "rb");
+ fseek(src, 0, SEEK_END);
+ totlen=ftell(src);
+ fseek(src, 0, SEEK_SET);
+
+ j2kfile=(char*)malloc(totlen);
+ fread(j2kfile, 1, totlen, src);
+ fclose(src);
+
+ for (i=0;i<totlen;i++)
+ cio_write(j2kfile[i],1);
+
+ len=cio_tell()-lenp;
+ cio_seek(lenp);
+ cio_write(len,4); // L
+ cio_seek(lenp+len);
+ return lenp;
+}
+
+void jp2_write_jp()
+{
+ int len, lenp;
+
+ lenp=cio_tell();
+ cio_skip(4);
+ cio_write(JP2_JP, 4); // JP
+ cio_write(0x0d0a870a,4);
+ len=cio_tell()-lenp;
+ cio_seek(lenp);
+ cio_write(len,4); // L
+ cio_seek(lenp+len);
+}
--- /dev/null
+/*
+ * Copyright (c) 2003, Yannick Verschueren
+ * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "j2k.h"
+
+void jp2_write_url(char *Idx_file);
+
+void jp2_write_dbtl(char *Idx_file);
+
+void jp2_write_jp2h(j2k_image_t *j2k_img);
+
+void jp2_write_ftyp();
+
+int jp2_write_jp2c(char *J2K_file);
+
+void jp2_write_jp();
--- /dev/null
+/*
+ * Copyright (c) 2003, Yannick Verschueren
+ * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <setjmp.h>
+#include <math.h>
+#include <unistd.h>
+
+#include "j2k.h"
+#include "cio.h"
+#include "tcd.h"
+#include "int.h"
+
+#define JPIP_CIDX 0x63696478
+#define JPIP_CPTR 0x63707472
+#define JPIP_MANF 0x6d616e66
+#define JPIP_FAIX 0x66616978
+#define JPIP_MHIX 0x6d686978
+#define JPIP_TPIX 0x74706978
+#define JPIP_THIX 0x74686978
+#define JPIP_PPIX 0x70706978
+#define JPIP_PHIX 0x70686978
+#define JPIP_FIDX 0x66696478
+#define JPIP_FPTR 0x66707472
+#define JPIP_PRXY 0x70727879
+#define JPIP_IPTR 0x69707472
+
+#define JP2C 0x6a703263
+
+static info_marker_t marker_jpip[32], marker_local_jpip[32]; // SIZE to precise !
+static int num_marker_jpip, num_marker_local_jpip;
+
+void jpip_write_cptr(int offset, info_image_t img) // Codestream finder box (box)
+{
+ int len, lenp;
+
+ lenp=cio_tell();
+ cio_skip(4); // L [at the end]
+ cio_write(JPIP_CPTR,4); // T
+ cio_write(0,2); // DR A PRECISER !!
+ cio_write(0,2); // CONT
+ cio_write(offset,8); // COFF A PRECISER !!
+ cio_write(img.codestream_size,8); // CLEN
+ len=cio_tell()-lenp;
+ cio_seek(lenp);
+ cio_write(len, 4); // L
+ cio_seek(lenp+len);
+}
+
+void jpip_write_manf(int second, int v, info_marker_t *marker) // Manifest box (box)
+{
+ int len, lenp, i;
+ lenp=cio_tell();
+ cio_skip(4); // L [at the end]
+ cio_write(JPIP_MANF,4); // T
+
+ if (second) // Write only during the second pass
+ {
+ for(i=0;i<v;i++)
+ {
+ cio_write(marker[i].len,4);
+ cio_write(marker[i].type,4);
+ }
+ }
+
+ len=cio_tell()-lenp;
+ cio_seek(lenp);
+ cio_write(len, 4); // L
+ cio_seek(lenp+len);
+}
+
+int jpip_write_mhix(info_image_t img) // Main Header Index Table (box)
+{
+ int len, lenp, i;
+ lenp=cio_tell();
+ cio_skip(4); // L [at the end]
+ cio_write(JPIP_MHIX, 4); // CIDX
+
+ cio_write(img.Main_head_end,8); // TLEN
+
+ for(i=0;i<img.num_marker;i++) // Marker restricted to 1 apparition
+ {
+ cio_write(img.marker[i].type,2);
+ cio_write(0,2);
+ cio_write(img.marker[i].start_pos,8);
+ cio_write(img.marker[i].len,2);
+ }
+
+ // Marker NOT restricted to 1 apparition
+ for(i=img.marker_mul.num_COD-1;i>=0;i--) // COD
+ {
+ cio_write(img.marker_mul.COD[i].type,2);
+ cio_write(i,2);
+ cio_write(img.marker_mul.COD[i].start_pos,8);
+ cio_write(img.marker_mul.COD[i].len,2);
+ }
+
+ for(i=img.marker_mul.num_COC-1;i>=0;i--) // COC
+ {
+ cio_write(img.marker_mul.COC[i].type,2);
+ cio_write(i,2);
+ cio_write(img.marker_mul.COC[i].start_pos,8);
+ cio_write(img.marker_mul.COC[i].len,2);
+ }
+
+ for(i=img.marker_mul.num_RGN-1;i>=0;i--) // RGN
+ {
+ cio_write(img.marker_mul.RGN[i].type,2);
+ cio_write(i,2);
+ cio_write(img.marker_mul.RGN[i].start_pos,8);
+ cio_write(img.marker_mul.RGN[i].len,2);
+ }
+
+ for(i=img.marker_mul.num_QCC-1;i>=0;i--) // QCC
+ {
+ cio_write(img.marker_mul.QCC[i].type,2);
+ cio_write(i,2);
+ cio_write(img.marker_mul.QCC[i].start_pos,8);
+ cio_write(img.marker_mul.QCC[i].len,2);
+ }
+
+ for(i=img.marker_mul.num_TLM-1;i>=0;i--) // TLM
+ {
+ cio_write(img.marker_mul.TLM[i].type,2);
+ cio_write(i,2);
+ cio_write(img.marker_mul.TLM[i].start_pos,8);
+ cio_write(img.marker_mul.TLM[i].len,2);
+ }
+
+ for(i=img.marker_mul.num_PLM-1;i>=0;i--) // PLM
+ {
+ cio_write(img.marker_mul.PLM[i].type,2);
+ cio_write(i,2);
+ cio_write(img.marker_mul.PLM[i].start_pos,8);
+ cio_write(img.marker_mul.PLM[i].len,2);
+ }
+
+ for(i=img.marker_mul.num_COM-1;i>=0;i--) // COM
+ {
+ cio_write(img.marker_mul.COM[i].type,2);
+ cio_write(i,2);
+ cio_write(img.marker_mul.COM[i].start_pos,8);
+ cio_write(img.marker_mul.COM[i].len,2);
+ }
+
+ len=cio_tell()-lenp;
+ cio_seek(lenp);
+ cio_write(len, 4); // L
+ cio_seek(lenp+len);
+
+ return len;
+}
+
+int jpip_write_faix(int v, int compno, info_image_t img, j2k_cp_t *j2k_cp) // Fragment array Index box
+{
+ int len, lenp, i;
+ int version = 0;
+ int tileno, resno, precno, layno, num_packet=0;
+
+ lenp=cio_tell();
+ cio_skip(4); // L [at the end]
+ cio_write(JPIP_FAIX, 4); // MHIX
+ cio_write(version,1); // Version 0 = 4 bytes
+
+ switch(v)
+ {
+ case 0: // TPIX
+ cio_write(1,version?8:4); // NMAX
+ cio_write(img.tw*img.th,version?8:4); // M
+ for (i=0;i<img.tw*img.th;i++)
+ {
+ cio_write(img.tile[i].start_pos,version?8:4);
+ cio_write(img.tile[i].end_pos-img.tile[i].start_pos,version?8:4);
+ }
+ break;
+
+ case 1: // THIX
+ cio_write(1,version?8:4); // NMAX
+ cio_write(img.tw*img.th,version?8:4); // M
+ for (i=0;i<img.tw*img.th;i++)
+ {
+ cio_write(img.tile[i].start_pos,version?8:4);
+ cio_write(img.tile[i].end_header-img.tile[i].start_pos,version?8:4);
+ }
+ break;
+
+ case 2: // PPIX NOT FINISHED !!
+ cio_write(img.num_packet_max,version?8:4); // NMAX
+ cio_write(img.tw*img.th,version?8:4); // M
+ for(tileno=0;tileno<img.tw*img.th;tileno++)
+ {
+ info_tile_t *tile_Idx = &img.tile[tileno];
+ info_compo_t *compo_Idx = &tile_Idx->compo[compno];
+ int correction;
+ if(j2k_cp->tcps[tileno].csty&J2K_CP_CSTY_EPH)
+ correction=3;
+ else
+ correction=1;
+ for(resno=0;resno<img.Decomposition+1;resno++)
+ {
+ info_reso_t *reso_Idx = &compo_Idx->reso[resno];
+ for (precno=0;precno<img.tile[tileno].pw*img.tile[tileno].ph;precno++)
+ {
+ info_prec_t *prec_Idx = &reso_Idx->prec[precno];
+ for(layno=0;layno<img.Layer;layno++)
+ {
+ info_layer_t *layer_Idx = &prec_Idx->layer[layno];
+ cio_write(layer_Idx->offset,version?8:4);
+ cio_write((layer_Idx->len_header-correction)?0:layer_Idx->len,version?8:4);
+ num_packet++;
+ }
+ }
+ }
+ }
+ // PADDING
+ while (num_packet<img.num_packet_max)
+ {
+ cio_write(0,version?8:4);
+ cio_write(0,version?8:4);
+ num_packet++;
+ }
+ break;
+
+ case 3: // PHIX NOT FINISHED !!
+ cio_write(img.num_packet_max,version?8:4); // NMAX
+ cio_write(img.tw*img.th,version?8:4); // M
+ for(tileno=0;tileno<img.tw*img.th;tileno++)
+ {
+ info_tile_t *tile_Idx = &img.tile[tileno];
+ info_compo_t *compo_Idx = &tile_Idx->compo[compno];
+ int correction;
+ if(j2k_cp->tcps[tileno].csty&J2K_CP_CSTY_EPH)
+ correction=3;
+ else
+ correction=1;
+ for(resno=0;resno<img.Decomposition+1;resno++)
+ {
+ info_reso_t *reso_Idx = &compo_Idx->reso[resno];
+ for (precno=0;precno<img.tile[tileno].pw*img.tile[tileno].ph;precno++)
+ {
+ info_prec_t *prec_Idx = &reso_Idx->prec[precno];
+ for(layno=0;layno<img.Layer;layno++)
+ {
+ info_layer_t *layer_Idx = &prec_Idx->layer[layno];
+ cio_write(layer_Idx->offset,version?8:4);
+ cio_write((layer_Idx->len_header-correction)?0:layer_Idx->len_header,version?8:4);
+ num_packet++;
+ }
+ }
+ }
+ }
+ // PADDING
+ while (num_packet<img.num_packet_max)
+ {
+ cio_write(0,version?8:4);
+ cio_write(0,version?8:4);
+ num_packet++;
+ }
+ break;
+ }
+
+ len=cio_tell()-lenp;
+ cio_seek(lenp);
+ cio_write(len, 4); // L
+ cio_seek(lenp+len);
+
+ return len;
+}
+
+int jpip_write_tpix(info_image_t img, j2k_cp_t *j2k_cp) // Tile-part Index Table box (superbox)
+{
+ int len, lenp;
+ lenp=cio_tell();
+ cio_skip(4); // L [at the end]
+ cio_write(JPIP_TPIX, 4); // TPIX
+
+ jpip_write_faix(0,0,img, j2k_cp);
+
+ len=cio_tell()-lenp;
+ cio_seek(lenp);
+ cio_write(len, 4); // L
+ cio_seek(lenp+len);
+
+ return len;
+}
+
+int jpip_write_thix(info_image_t img, j2k_cp_t *j2k_cp) // Tile header Index Table box (superbox)
+{
+ int len, lenp;
+ lenp=cio_tell();
+ cio_skip(4); // L [at the end]
+ cio_write(JPIP_THIX, 4); // THIX
+
+ jpip_write_faix(1,0,img, j2k_cp);
+
+ len=cio_tell()-lenp;
+ cio_seek(lenp);
+ cio_write(len, 4); // L
+ cio_seek(lenp+len);
+
+ return len;
+}
+
+int jpip_write_ppix(info_image_t img,j2k_cp_t *j2k_cp) // Precinct Packet Index Table box (superbox)
+{
+ int len, lenp, compno, i;
+
+ for (i=0;i<2;i++)
+ {
+ if (i) cio_seek(lenp);
+
+ lenp=cio_tell();
+ cio_skip(4); // L [at the end]
+ cio_write(JPIP_PPIX, 4); // PPIX
+ jpip_write_manf(i,img.Comp,marker_local_jpip);
+
+ num_marker_local_jpip=img.Comp;
+
+ for (compno=0; compno<img.Comp; compno++)
+ {
+ marker_local_jpip[compno].len=jpip_write_faix(2,compno,img, j2k_cp);
+ marker_local_jpip[compno].type=JPIP_FAIX;
+ }
+
+ len=cio_tell()-lenp;
+ cio_seek(lenp);
+ cio_write(len, 4); // L
+ cio_seek(lenp+len);
+ }
+ return len;
+}
+
+int jpip_write_phix(info_image_t img, j2k_cp_t *j2k_cp) // Packet Header Index Table Box (superbox)
+{
+ int len, lenp=0, compno, i;
+
+ for (i=0;i<2;i++)
+ {
+ if (i) cio_seek(lenp);
+
+ lenp=cio_tell();
+ cio_skip(4); // L [at the end]
+ cio_write(JPIP_PHIX, 4); // PHIX
+
+ jpip_write_manf(i,img.Comp,marker_local_jpip);
+
+ for (compno=0; compno<img.Comp; compno++)
+ {
+ marker_local_jpip[compno].len=jpip_write_faix(3,compno,img, j2k_cp);
+ marker_local_jpip[compno].type=JPIP_FAIX;
+ }
+
+ len=cio_tell()-lenp;
+ cio_seek(lenp);
+ cio_write(len, 4); // L
+ cio_seek(lenp+len);
+ }
+ return len;
+}
+
+int jpip_write_cidx(int offset, info_image_t img, j2k_cp_t *j2k_cp) // Codestream index box (superbox)
+{
+ int len, lenp=0, i;
+ num_marker_jpip=0;
+
+ for (i=0;i<2;i++)
+ {
+ if(i)
+ cio_seek(lenp);
+
+ lenp=cio_tell();
+
+ cio_skip(4); // L [at the end]
+ cio_write(JPIP_CIDX, 4); // CIDX
+ jpip_write_cptr(offset, img);
+ jpip_write_manf(i,num_marker_jpip, marker_jpip); // A definir
+
+ num_marker_jpip=0;
+ marker_jpip[num_marker_jpip].len=jpip_write_mhix(img);
+ marker_jpip[num_marker_jpip].type=JPIP_MHIX;
+ num_marker_jpip++;
+
+ marker_jpip[num_marker_jpip].len=jpip_write_tpix(img, j2k_cp);
+ marker_jpip[num_marker_jpip].type=JPIP_TPIX;
+ num_marker_jpip++;
+
+ marker_jpip[num_marker_jpip].len=jpip_write_thix(img, j2k_cp);
+ marker_jpip[num_marker_jpip].type=JPIP_THIX;
+ num_marker_jpip++;
+
+ marker_jpip[num_marker_jpip].len=jpip_write_ppix(img, j2k_cp);
+ marker_jpip[num_marker_jpip].type=JPIP_PPIX;
+ num_marker_jpip++;
+
+ marker_jpip[num_marker_jpip].len=jpip_write_phix(img, j2k_cp);
+ marker_jpip[num_marker_jpip].type=JPIP_PHIX;
+ num_marker_jpip++;
+
+ len=cio_tell()-lenp;
+ cio_seek(lenp);
+ cio_write(len, 4); // L
+ cio_seek(lenp+len);
+ }
+
+ return len;
+
+}
+
+void jpip_write_iptr(int offset, int length)
+{
+ int len, lenp;
+ lenp=cio_tell();
+ cio_skip(4); // L [at the end]
+ cio_write(JPIP_IPTR, 4); // IPTR
+
+ cio_write(offset,8);
+ cio_write(length,8);
+
+ len=cio_tell()-lenp;
+ cio_seek(lenp);
+ cio_write(len, 4); // L
+ cio_seek(lenp+len);
+}
+
+void jpip_write_prxy(int offset_jp2c, int length_jp2c, int offset_idx, int length_idx)
+{
+ int len, lenp;
+ lenp=cio_tell();
+ cio_skip(4); // L [at the end]
+ cio_write(JPIP_PRXY, 4); // IPTR
+
+ cio_write(offset_jp2c,8); // OOFF
+ cio_write(length_jp2c,4); // OBH part 1
+ cio_write(JP2C,4); // OBH part 2
+
+ cio_write(1,1); // NI
+
+ cio_write(offset_idx,8); // IOFF
+ cio_write(length_idx,4); // IBH part 1
+ cio_write(JPIP_CIDX,4); // IBH part 2
+
+ len=cio_tell()-lenp;
+ cio_seek(lenp);
+ cio_write(len, 4); // L
+ cio_seek(lenp+len);
+}
+
+int jpip_write_fidx(int offset_jp2c, int length_jp2c, int offset_idx, int length_idx)
+{
+ int len, lenp;
+ lenp=cio_tell();
+ cio_skip(4); // L [at the end]
+ cio_write(JPIP_FIDX, 4); // IPTR
+
+ jpip_write_prxy(offset_jp2c, length_jp2c, offset_idx, offset_jp2c);
+
+ len=cio_tell()-lenp;
+ cio_seek(lenp);
+ cio_write(len, 4); // L
+ cio_seek(lenp+len);
+
+ return len;
+}
--- /dev/null
+/*
+ * Copyright (c) 2003, Yannick Verschueren
+ * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "j2k.h"
+
+// Codestream index box (superbox)
+int jpip_write_cidx(int offset, info_image_t img, j2k_cp_t *j2k_cp);
+
+// Index Finder Box
+void jpip_write_iptr(int offset, int length);
+
+// File Index Box
+int jpip_write_fidx(int offset_jp2c, int length_jp2c, int offset_idx, int length_idx);
--- /dev/null
+/*
+ * Copyright (c) 2001-2002, David Janssens
+ * Copyright (c) 2003, Yannick Verschueren
+ * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "pi.h"
+#include "int.h"
+#include <stdlib.h>
+#include <stdio.h>
+
+
+/// <summary>
+/// Create a packet iterator.
+/// </summary>
+pi_iterator_t *pi_create(j2k_image_t *img, j2k_cp_t *cp, int tileno) {
+ int p, q;
+ int compno, resno,pino, layno, precno;
+ int maxres=0;
+ pi_iterator_t *pi;
+ j2k_tcp_t *tcp;
+ j2k_tccp_t *tccp;
+
+ tcp=&cp->tcps[tileno];
+ pi=(pi_iterator_t*)malloc((tcp->numpocs+1)*sizeof(pi_iterator_t));
+
+ for (pino=0;pino<tcp->numpocs+1;pino++) // change
+ {
+ p=tileno%cp->tw;
+ q=tileno/cp->tw;
+
+ pi[pino].tx0=int_max(cp->tx0+p*cp->tdx, img->x0);
+ pi[pino].ty0=int_max(cp->ty0+q*cp->tdy, img->y0);
+ pi[pino].tx1=int_min(cp->tx0+(p+1)*cp->tdx, img->x1);
+ pi[pino].ty1=int_min(cp->ty0+(q+1)*cp->tdy, img->y1);
+ pi[pino].numcomps=img->numcomps;
+ pi[pino].comps=(pi_comp_t*)malloc(img->numcomps*sizeof(pi_comp_t));
+
+ for (compno=0; compno<pi->numcomps; compno++)
+ {
+ int tcx0, tcy0, tcx1, tcy1;
+ pi_comp_t *comp=&pi[pino].comps[compno];
+
+ tccp=&tcp->tccps[compno];
+ comp->dx=img->comps[compno].dx;
+ comp->dy=img->comps[compno].dy;
+ comp->numresolutions=tccp->numresolutions;
+ comp->resolutions=(pi_resolution_t*)malloc(comp->numresolutions*sizeof(pi_resolution_t));
+ tcx0=int_ceildiv(pi->tx0, comp->dx);
+ tcy0=int_ceildiv(pi->ty0, comp->dy);
+ tcx1=int_ceildiv(pi->tx1, comp->dx);
+ tcy1=int_ceildiv(pi->ty1, comp->dy);
+ if (comp->numresolutions>maxres) {
+ maxres=comp->numresolutions;
+ }
+ for (resno=0; resno<comp->numresolutions; resno++)
+ {
+ int levelno;
+ int rx0, ry0, rx1, ry1;
+ int px0, py0, px1, py1;
+ pi_resolution_t *res=&comp->resolutions[resno];
+ if (tccp->csty&J2K_CCP_CSTY_PRT) {
+ res->pdx=tccp->prcw[resno];
+ res->pdy=tccp->prch[resno];
+ } else {
+ res->pdx=15;
+ res->pdy=15;
+ }
+ levelno=comp->numresolutions-1-resno;
+ rx0=int_ceildivpow2(tcx0, levelno);
+ ry0=int_ceildivpow2(tcy0, levelno);
+ rx1=int_ceildivpow2(tcx1, levelno);
+ ry1=int_ceildivpow2(tcy1, levelno);
+ px0=int_floordivpow2(rx0, res->pdx)<<res->pdx;
+ py0=int_floordivpow2(ry0, res->pdy)<<res->pdy;
+ px1=int_ceildivpow2(rx1, res->pdx)<<res->pdx;
+ py1=int_ceildivpow2(ry1, res->pdy)<<res->pdy;
+ res->pw=(px1-px0)>>res->pdx;
+ res->ph=(py1-py0)>>res->pdy;
+ }
+ }
+
+ for (layno=0; layno<10; layno++)
+ {
+ for (resno=0; resno<10; resno++)
+ {
+ for (compno=0; compno<3; compno++)
+ {
+ for (precno=0; precno<99; precno++)
+ {
+ pi[pino].include[layno][resno][compno][precno]=0;
+ }
+ }
+ }
+ }
+
+ if (pino==tcp->numpocs)
+ {
+ pi[pino].first=1;
+ pi[pino].poc.resno0=0;
+ pi[pino].poc.compno0=0;
+ pi[pino].poc.layno1=tcp->numlayers;
+ pi[pino].poc.resno1=maxres;
+ pi[pino].poc.compno1=img->numcomps;
+ pi[pino].poc.prg=tcp->prg;
+ } else
+ {
+ pi[pino].first=1;
+ pi[pino].poc.resno0=tcp->pocs[pino].resno0;
+ pi[pino].poc.compno0=tcp->pocs[pino].compno0;
+ pi[pino].poc.layno1=tcp->pocs[pino].layno1;
+ pi[pino].poc.resno1=tcp->pocs[pino].resno1;
+ pi[pino].poc.compno1=tcp->pocs[pino].compno1;
+ pi[pino].poc.prg=tcp->pocs[pino].prg;
+ }
+ }
+ return pi;
+}
+
+/// <summary>
+/// Get next packet in layer=resolution-component-precinct order.
+/// </summary>
+int pi_next_lrcp(pi_iterator_t *pi) {
+ pi_comp_t *comp;
+ pi_resolution_t *res;
+
+ if (!pi->first)
+ {
+ comp=&pi->comps[pi->compno];
+ res=&comp->resolutions[pi->resno];
+ goto skip;
+ } else {
+ pi->first=0;
+ }
+ for (pi->layno=0; pi->layno<pi->poc.layno1; pi->layno++)
+ {
+ for (pi->resno=pi->poc.resno0; pi->resno<pi->poc.resno1; pi->resno++)
+ {
+ for (pi->compno=pi->poc.compno0; pi->compno<pi->poc.compno1; pi->compno++)
+ {
+
+ comp=&pi->comps[pi->compno];
+ if (pi->resno>=comp->numresolutions)
+ {
+
+ continue;
+ }
+ res=&comp->resolutions[pi->resno];
+
+ for (pi->precno=0; pi->precno<res->pw*res->ph; pi->precno++)
+ {
+
+ if (!pi->include[pi->layno][pi->resno][pi->compno][pi->precno])
+ {
+ pi->include[pi->layno][pi->resno][pi->compno][pi->precno]=1;
+ return 1;
+ }
+ skip: ;
+ }
+ }
+ }
+ }
+ return 0;
+}
+
+/// <summary>
+/// Get next packet in resolution-layer-component-precinct order.
+/// </summary>
+int pi_next_rlcp(pi_iterator_t *pi) {
+ pi_comp_t *comp;
+ pi_resolution_t *res;
+ if (!pi->first) {
+ comp=&pi->comps[pi->compno];
+ res=&comp->resolutions[pi->resno];
+ goto skip;
+ } else {
+ pi->first=0;
+ }
+ for (pi->resno=pi->poc.resno0; pi->resno<pi->poc.resno1; pi->resno++) {
+ for (pi->layno=0; pi->layno<pi->poc.layno1; pi->layno++) {
+ for (pi->compno=pi->poc.compno0; pi->compno<pi->poc.compno1; pi->compno++) {
+ comp=&pi->comps[pi->compno];
+ if (pi->resno>=comp->numresolutions) {
+ continue;
+ }
+ res=&comp->resolutions[pi->resno];
+ for (pi->precno=0; pi->precno<res->pw*res->ph; pi->precno++) {
+ if (!pi->include[pi->layno][pi->resno][pi->compno][pi->precno])
+ {
+ pi->include[pi->layno][pi->resno][pi->compno][pi->precno]=1;
+ return 1;
+ }
+ skip: ;
+ }
+ }
+ }
+ }
+ return 0;
+}
+
+/// <summary>
+/// Get next packet in resolution-precinct-component-layer order.
+/// </summary>
+int pi_next_rpcl(pi_iterator_t *pi) {
+ pi_comp_t *comp;
+ pi_resolution_t *res;
+ if (!pi->first) {
+ goto skip;
+ } else {
+ int compno, resno;
+ pi->first=0;
+ pi->dx=0;
+ pi->dy=0;
+ for (compno=0; compno<pi->numcomps; compno++) {
+ comp=&pi->comps[compno];
+ for (resno=0; resno<comp->numresolutions; resno++) {
+ int dx, dy;
+ res=&comp->resolutions[resno];
+ dx=comp->dx*(1<<(res->pdx+comp->numresolutions-1-resno));
+ dy=comp->dy*(1<<(res->pdy+comp->numresolutions-1-resno));
+ pi->dx=!pi->dx?dx:int_min(pi->dx, dx);
+ pi->dy=!pi->dy?dy:int_min(pi->dy, dy);
+ }
+ }
+ }
+ for (pi->resno=pi->poc.resno0; pi->resno<pi->poc.resno1; pi->resno++) {
+ for (pi->y=pi->ty0; pi->y<pi->ty1; pi->y+=pi->dy-(pi->y%pi->dy)) {
+ for (pi->x=pi->tx0; pi->x<pi->tx1; pi->x+=pi->dx-(pi->x%pi->dx)) {
+ for (pi->compno=pi->poc.compno0; pi->compno<pi->poc.compno1; pi->compno++) {
+ int levelno;
+ int trx0, try0;
+ int rpx, rpy;
+ int prci, prcj;
+ comp=&pi->comps[pi->compno];
+ if (pi->resno>=comp->numresolutions) {
+ continue;
+ }
+ res=&comp->resolutions[pi->resno];
+ levelno=comp->numresolutions-1-pi->resno;
+ trx0=int_ceildiv(pi->tx0, comp->dx<<levelno);
+ try0=int_ceildiv(pi->ty0, comp->dy<<levelno);
+ rpx=res->pdx+levelno;
+ rpy=res->pdy+levelno;
+ if (!(pi->x%(comp->dx<<rpx)==0||(pi->x==pi->tx0&&(trx0<<levelno)%(1<<rpx)))) {
+ continue;
+ }
+ if (!(pi->y%(comp->dy<<rpy)==0||(pi->y==pi->ty0&&(try0<<levelno)%(1<<rpx)))) {
+ continue;
+ }
+ prci=int_floordivpow2(int_ceildiv(pi->x, comp->dx<<levelno), res->pdx)-int_floordivpow2(trx0, res->pdx);
+ prcj=int_floordivpow2(int_ceildiv(pi->y, comp->dy<<levelno), res->pdy)-int_floordivpow2(try0, res->pdy);
+ pi->precno=prci+prcj*res->pw;
+ for (pi->layno=0; pi->layno<pi->poc.layno1; pi->layno++) {
+ if (!pi->include[pi->layno][pi->resno][pi->compno][pi->precno])
+ {
+ pi->include[pi->layno][pi->resno][pi->compno][pi->precno]=1;
+ return 1;
+ }
+ skip: ;
+ }
+ }
+ }
+ }
+ }
+ return 0;
+}
+
+/// <summary>
+/// Get next packet in precinct-component-resolution-layer order.
+/// </summary>
+int pi_next_pcrl(pi_iterator_t *pi) {
+ pi_comp_t *comp;
+ pi_resolution_t *res;
+ if (!pi->first) {
+ comp=&pi->comps[pi->compno];
+ goto skip;
+ } else {
+ int compno, resno;
+ pi->first=0;
+ pi->dx=0;
+ pi->dy=0;
+ for (compno=0; compno<pi->numcomps; compno++) {
+ comp=&pi->comps[compno];
+ for (resno=0; resno<comp->numresolutions; resno++) {
+ int dx, dy;
+ res=&comp->resolutions[resno];
+ dx=comp->dx*(1<<(res->pdx+comp->numresolutions-1-resno));
+ dy=comp->dy*(1<<(res->pdy+comp->numresolutions-1-resno));
+ pi->dx=!pi->dx?dx:int_min(pi->dx, dx);
+ pi->dy=!pi->dy?dy:int_min(pi->dy, dy);
+ }
+ }
+ }
+ for (pi->y=pi->ty0; pi->y<pi->ty1; pi->y+=pi->dy-(pi->y%pi->dy)) {
+ for (pi->x=pi->tx0; pi->x<pi->tx1; pi->x+=pi->dx-(pi->x%pi->dx)) {
+ for (pi->compno=pi->poc.compno0; pi->compno<pi->poc.compno1; pi->compno++) {
+ comp=&pi->comps[pi->compno];
+ for (pi->resno=pi->poc.resno0; pi->resno<int_min(pi->poc.resno1, comp->numresolutions); pi->resno++) {
+ int levelno;
+ int trx0, try0;
+ int rpx, rpy;
+ int prci, prcj;
+ res=&comp->resolutions[pi->resno];
+ levelno=comp->numresolutions-1-pi->resno;
+ trx0=int_ceildiv(pi->tx0, comp->dx<<levelno);
+ try0=int_ceildiv(pi->ty0, comp->dy<<levelno);
+ rpx=res->pdx+levelno;
+ rpy=res->pdy+levelno;
+ if (!(pi->x%(comp->dx<<rpx)==0||(pi->x==pi->tx0&&(trx0<<levelno)%(1<<rpx)))) {
+ continue;
+ }
+ if (!(pi->y%(comp->dy<<rpy)==0||(pi->y==pi->ty0&&(try0<<levelno)%(1<<rpx)))) {
+ continue;
+ }
+ prci=int_floordivpow2(int_ceildiv(pi->x, comp->dx<<levelno), res->pdx)-int_floordivpow2(trx0, res->pdx);
+ prcj=int_floordivpow2(int_ceildiv(pi->y, comp->dy<<levelno), res->pdy)-int_floordivpow2(try0, res->pdy);
+ pi->precno=prci+prcj*res->pw;
+ for (pi->layno=0; pi->layno<pi->poc.layno1; pi->layno++) {
+ if (!pi->include[pi->layno][pi->resno][pi->compno][pi->precno])
+ {
+ pi->include[pi->layno][pi->resno][pi->compno][pi->precno]=1;
+ return 1;
+ }
+ skip: ;
+ }
+ }
+ }
+ }
+ }
+ return 0;
+}
+
+/// <summary>
+/// Get next packet in component-precinct-resolution-layer order.
+/// </summary>
+int pi_next_cprl(pi_iterator_t *pi) {
+ pi_comp_t *comp;
+ pi_resolution_t *res;
+ if (!pi->first) {
+ comp=&pi->comps[pi->compno];
+ goto skip;
+ } else {
+ pi->first=0;
+ }
+ for (pi->compno=pi->poc.compno0; pi->compno<pi->poc.compno1; pi->compno++) {
+ int resno;
+ comp=&pi->comps[pi->compno];
+ pi->dx=0;
+ pi->dy=0;
+ for (resno=0; resno<comp->numresolutions; resno++) {
+ int dx, dy;
+ res=&comp->resolutions[resno];
+ dx=comp->dx*(1<<(res->pdx+comp->numresolutions-1-resno));
+ dy=comp->dy*(1<<(res->pdy+comp->numresolutions-1-resno));
+ pi->dx=!pi->dx?dx:int_min(pi->dx, dx);
+ pi->dy=!pi->dy?dy:int_min(pi->dy, dy);
+ }
+ for (pi->y=pi->ty0; pi->y<pi->ty1; pi->y+=pi->dy-(pi->y%pi->dy)) {
+ for (pi->x=pi->tx0; pi->x<pi->tx1; pi->x+=pi->dx-(pi->x%pi->dx)) {
+ for (pi->resno=pi->poc.resno0; pi->resno<int_min(pi->poc.resno1, comp->numresolutions); pi->resno++) {
+ int levelno;
+ int trx0, try0;
+ int rpx, rpy;
+ int prci, prcj;
+ res=&comp->resolutions[pi->resno];
+ levelno=comp->numresolutions-1-pi->resno;
+ trx0=int_ceildiv(pi->tx0, comp->dx<<levelno);
+ try0=int_ceildiv(pi->ty0, comp->dy<<levelno);
+ rpx=res->pdx+levelno;
+ rpy=res->pdy+levelno;
+ if (!(pi->x%(comp->dx<<rpx)==0||(pi->x==pi->tx0&&(trx0<<levelno)%(1<<rpx)))) {
+ continue;
+ }
+ if (!(pi->y%(comp->dy<<rpy)==0||(pi->y==pi->ty0&&(try0<<levelno)%(1<<rpx)))) {
+ continue;
+ }
+ prci=int_floordivpow2(int_ceildiv(pi->x, comp->dx<<levelno), res->pdx)-int_floordivpow2(trx0, res->pdx);
+ prcj=int_floordivpow2(int_ceildiv(pi->y, comp->dy<<levelno), res->pdy)-int_floordivpow2(try0, res->pdy);
+ pi->precno=prci+prcj*res->pw;
+ for (pi->layno=0; pi->layno<pi->poc.layno1; pi->layno++) {
+ if (!pi->include[pi->layno][pi->resno][pi->compno][pi->precno])
+ {
+ pi->include[pi->layno][pi->resno][pi->compno][pi->precno]=1;
+ return 1;
+ }
+ skip: ;
+ }
+ }
+ }
+ }
+ }
+ return 0;
+}
+
+/// <summary>
+/// Get next packet.
+/// </summary>
+int pi_next(pi_iterator_t *pi) {
+ switch (pi->poc.prg) {
+ case 0:
+ return pi_next_lrcp(pi);
+ case 1:
+ return pi_next_rlcp(pi);
+ case 2:
+ return pi_next_rpcl(pi);
+ case 3:
+ return pi_next_pcrl(pi);
+ case 4:
+ return pi_next_cprl(pi);
+ }
+ return 0;
+}
--- /dev/null
+/*
+ * Copyright (c) 2001-2002, David Janssens
+ * Copyright (c) 2003, Yannick Verschueren
+ * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __PI_H
+#define __PI_H
+
+#include "j2k.h"
+#include "tcd.h"
+
+typedef struct {
+ int pdx, pdy;
+ int pw, ph;
+} pi_resolution_t;
+
+typedef struct {
+ int dx, dy;
+ int numresolutions;
+ pi_resolution_t *resolutions;
+} pi_comp_t;
+
+typedef struct {
+ int include[10][10][3][99];
+ int compno, resno, precno, layno; // component, resolution, precinct and layer that indentify the packet
+ int first;
+ j2k_poc_t poc;
+ int numcomps;
+ pi_comp_t *comps;
+ int tx0, ty0, tx1, ty1;
+ int x, y, dx, dy;
+} pi_iterator_t; // packet iterator
+
+/*
+ * Create a packet iterator
+ * img: raw image for which the packets will be listed
+ * cp: coding paremeters
+ * tileno: number that identifies the tile for which to list the packets
+ * return value: returns a packet iterator that points to the first packet of the tile
+ */
+pi_iterator_t *pi_create(j2k_image_t *img, j2k_cp_t *cp, int tileno);
+
+/*
+ * Modify the packet iterator to point to the next packet
+ * pi: packet iterator to modify
+ * return value: returns 0 if pi pointed to the last packet or else returns 1
+ */
+int pi_next(pi_iterator_t *pi);
+
+#endif
--- /dev/null
+/*
+ * Copyright (c) 2001-2002, David Janssens
+ * Copyright (c) 2003, Yannick Verschueren
+ * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "t2.h"
+#include "tcd.h"
+#include "bio.h"
+#include "j2k.h"
+#include "pi.h"
+#include "tgt.h"
+#include "int.h"
+#include "cio.h"
+#include <stdio.h>
+#include <setjmp.h>
+#include <string.h>
+#include <stdlib.h>
+
+#define RESTART 0x04
+
+extern jmp_buf j2k_error;
+
+int t2_getcommacode() {
+ int n;
+ for (n=0; bio_read(1); n++) {}
+ return n;
+}
+
+int t2_getnumpasses()
+{
+ int n;
+ if (!bio_read(1)) return 1;
+ if (!bio_read(1)) return 2;
+ if ((n=bio_read(2))!=3) return 3+n;
+ if ((n=bio_read(5))!=31) return 6+n;
+ return 37+bio_read(7);
+}
+
+void t2_init_seg(tcd_seg_t *seg, int cblksty) {
+ seg->numpasses=0;
+ seg->len=0;
+ seg->maxpasses=cblksty&J2K_CCP_CBLKSTY_TERMALL?1:100;
+}
+
+int t2_decode_packet(unsigned char *src, int len, tcd_tile_t *tile, j2k_tcp_t *tcp, int compno, int resno, int precno, int layno, info_layer_t *layer_Idx) {
+ int bandno, cblkno;
+ tcd_tilecomp_t *tilec=&tile->comps[compno];
+ tcd_resolution_t *res=&tilec->resolutions[resno];
+ unsigned char *c=src;
+ unsigned char *d=c;
+ int e;
+ int present;
+
+ if (layno==0) {
+ for (bandno=0; bandno<res->numbands; bandno++) {
+ tcd_band_t *band=&res->bands[bandno];
+ tcd_precinct_t *prc=&band->precincts[precno];
+ tgt_reset(prc->incltree);
+ tgt_reset(prc->imsbtree);
+ for (cblkno=0; cblkno<prc->cw*prc->ch; cblkno++) {
+ tcd_cblk_t *cblk=&prc->cblks[cblkno];
+ cblk->numsegs=0;
+ }
+ }
+ }
+
+ if (tcp->csty&J2K_CP_CSTY_SOP) {
+ c+=6;
+ }
+ bio_init_dec(c, src+len-c);
+ present=bio_read(1);
+ if (!present) {
+ bio_inalign();
+ c+=bio_numbytes();
+ return c-src;
+ }
+ for (bandno=0; bandno<res->numbands; bandno++) {
+ tcd_band_t *band=&res->bands[bandno];
+ tcd_precinct_t *prc=&band->precincts[precno];
+ for (cblkno=0; cblkno<prc->cw*prc->ch; cblkno++) {
+ int included, increment, n;
+ tcd_cblk_t *cblk=&prc->cblks[cblkno];
+ tcd_seg_t *seg;
+ if (!cblk->numsegs) {
+ included=tgt_decode(prc->incltree, cblkno, layno+1);
+ } else {
+ included=bio_read(1);
+ }
+ if (!included) {
+ cblk->numnewpasses=0;
+ continue;
+ }
+ if (!cblk->numsegs) {
+ int i, numimsbs;
+ for (i=0; !tgt_decode(prc->imsbtree, cblkno, i); i++) {}
+ numimsbs=i-1;
+ cblk->numbps=band->numbps-numimsbs;
+ cblk->numlenbits=3;
+ }
+ cblk->numnewpasses=t2_getnumpasses();
+ increment=t2_getcommacode();
+ cblk->numlenbits+=increment;
+ if (!cblk->numsegs) {
+ seg=&cblk->segs[0];
+ t2_init_seg(seg, tcp->tccps[compno].cblksty);
+ } else {
+ seg=&cblk->segs[cblk->numsegs-1];
+ if (seg->numpasses==seg->maxpasses) {
+ t2_init_seg(++seg, tcp->tccps[compno].cblksty);
+ }
+ }
+ n=cblk->numnewpasses;
+ do {
+ seg->numnewpasses=int_min(seg->maxpasses-seg->numpasses, n);
+ seg->newlen=bio_read(cblk->numlenbits+int_floorlog2(seg->numnewpasses));
+ n-=seg->numnewpasses;
+ if (n>0) {
+ t2_init_seg(++seg, tcp->tccps[compno].cblksty);
+ }
+ } while (n>0);
+ }
+ }
+ if(bio_inalign()) return -999;
+ c+=bio_numbytes();
+ if (tcp->csty&J2K_CP_CSTY_EPH) {
+ c+=2;
+ }
+
+ // INDEX
+ layer_Idx->len_header=c-d;
+ if (tcp->csty&J2K_CP_CSTY_SOP)
+ layer_Idx->len_header-=6;
+ // \INDEX --> END OF HEADER !!
+
+ for (bandno=0; bandno<res->numbands; bandno++) {
+ tcd_band_t *band=&res->bands[bandno];
+ tcd_precinct_t *prc=&band->precincts[precno];
+ for (cblkno=0; cblkno<prc->cw*prc->ch; cblkno++) {
+ tcd_cblk_t *cblk=&prc->cblks[cblkno];
+ tcd_seg_t *seg;
+ if (!cblk->numnewpasses) continue;
+ if (!cblk->numsegs) {
+ seg=&cblk->segs[cblk->numsegs++];
+ cblk->len=0;
+ } else {
+ seg=&cblk->segs[cblk->numsegs-1];
+ if (seg->numpasses==seg->maxpasses) {
+ seg++;
+ cblk->numsegs++;
+ }
+ }
+ do {
+ if (c+seg->newlen>src+len) return -999;
+ memcpy(cblk->data+cblk->len, c, seg->newlen);
+ if (seg->numpasses==0) {
+ seg->data=cblk->data+cblk->len;
+ }
+ c+=seg->newlen;
+ cblk->len+=seg->newlen;
+ seg->len+=seg->newlen;
+ seg->numpasses+=seg->numnewpasses;
+ cblk->numnewpasses-=seg->numnewpasses;
+ if (cblk->numnewpasses>0) {
+ seg++;
+ cblk->numsegs++;
+ }
+ } while (cblk->numnewpasses>0);
+ }
+ }
+ //<INDEX>
+ e=c-d;
+ layer_Idx->len=e;
+ //</INDEX>
+
+ return c-src;
+}
+
+int t2_decode_packets(unsigned char *src, int len, j2k_image_t *img, j2k_cp_t *cp, int tileno, tcd_tile_t *tile, info_image_t *imgg) {
+ unsigned char *c=src;
+ pi_iterator_t *pi;
+ int pino, compno,e;
+ int position=imgg->tile[tileno].end_header+1;
+ info_tile_t *tile_Idx;
+ info_compo_t *compo_Idx;
+ info_reso_t *reso_Idx;
+ info_prec_t *prec_Idx;
+ info_layer_t *layer_Idx;
+
+ tile_Idx=&imgg->tile[tileno];
+ tile_Idx->num_packet=0;
+ pi=pi_create(img, cp, tileno);
+
+ for (pino=0; pino<=cp->tcps[tileno].numpocs;pino++)
+ {
+
+ while (pi_next(&pi[pino])) {
+ compo_Idx=&tile_Idx->compo[pi[pino].compno];
+ reso_Idx=&compo_Idx->reso[pi[pino].resno];
+ prec_Idx=&reso_Idx->prec[pi[pino].precno];
+ layer_Idx=&prec_Idx->layer[pi[pino].layno];
+
+ layer_Idx->offset=position;
+
+ e=t2_decode_packet(c, src+len-c, tile, &cp->tcps[tileno], pi[pino].compno, pi[pino].resno, pi[pino].precno, pi[pino].layno,layer_Idx);
+
+ if (e==-999)
+ {
+ break;
+ } else
+ c+=e;
+ position+=e;
+ tile_Idx->num_packet++;
+ }
+
+ // FREE space memory taken by pi
+ for (compno=0; compno<pi[pino].numcomps; compno++)
+ {
+ free(pi[pino].comps[compno].resolutions);
+ }
+ free(pi[pino].comps);
+ }
+ free(pi);
+
+ if (e==-999)
+ return e;
+ else
+ {
+ imgg->num_packet_max=int_max(imgg->num_packet_max,tile_Idx->num_packet);
+ return c-src;
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2001-2002, David Janssens
+ * Copyright (c) 2003, Yannick Verschueren
+ * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __T2_H
+#define __T2_H
+
+#include "tcd.h"
+#include "j2k.h"
+
+/*
+ * Decode the packets of a tile from a source buffer
+ * src: the source buffer
+ * len: length of the source buffer
+ * img: destination image
+ * cp: image coding parameters
+ * tileno: number that identifies the tile for which to decode the packets
+ * tile: tile for which to decode the packets
+ */
+int t2_decode_packets(unsigned char *src, int len, j2k_image_t *img, j2k_cp_t *cp, int tileno, tcd_tile_t *tile, info_image_t *imgg);
+
+#endif
--- /dev/null
+/*
+ * Copyright (c) 2001-2002, David Janssens
+ * Copyright (c) 2003, Yannick Verschueren
+ * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "tcd.h"
+#include "int.h"
+#include "t2.h"
+#include <setjmp.h>
+#include <float.h>
+#include <stdio.h>
+#include <time.h>
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+
+static tcd_image_t tcd_image;
+
+static j2k_image_t *tcd_img;
+static j2k_cp_t *tcd_cp;
+
+static tcd_tile_t *tcd_tile;
+static j2k_tcp_t *tcd_tcp;
+static int tcd_tileno;
+
+extern jmp_buf j2k_error;
+
+void tcd_init(j2k_image_t *img, j2k_cp_t *cp, info_image_t *imgg) {
+ int tileno, compno, resno, bandno, precno, cblkno;
+ tcd_img=img;
+ tcd_cp=cp;
+ tcd_image.tw=cp->tw;
+ tcd_image.th=cp->th;
+ tcd_image.tiles=(tcd_tile_t*)malloc(cp->tw*cp->th*sizeof(tcd_tile_t));
+ for (tileno=0; tileno<cp->tw*cp->th; tileno++) {
+ j2k_tcp_t *tcp=&cp->tcps[tileno];
+ tcd_tile_t *tile=&tcd_image.tiles[tileno];
+ // cfr p59 ISO/IEC FDIS15444-1 : 2000 (18 august 2000)
+ int p=tileno%cp->tw; // si numerotation matricielle ..
+ int q=tileno/cp->tw; // .. coordonnees de la tile (q,p) q pour ligne et p pour colonne
+ info_tile_t *tile_Idx=&imgg->tile[tileno]; // INDEX
+
+ // 4 borders of the tile rescale on the image if necessary
+ tile->x0=int_max(cp->tx0+p*cp->tdx, img->x0);
+ tile->y0=int_max(cp->ty0+q*cp->tdy, img->y0);
+ tile->x1=int_min(cp->tx0+(p+1)*cp->tdx, img->x1);
+ tile->y1=int_min(cp->ty0+(q+1)*cp->tdy, img->y1);
+
+ tile->numcomps=img->numcomps;
+ tile->comps=(tcd_tilecomp_t*)malloc(img->numcomps*sizeof(tcd_tilecomp_t));
+ tile_Idx->compo=(info_compo_t*)malloc(img->numcomps*sizeof(info_compo_t)); // INDEX
+ for (compno=0; compno<tile->numcomps; compno++) {
+ j2k_tccp_t *tccp=&tcp->tccps[compno];
+ tcd_tilecomp_t *tilec=&tile->comps[compno];
+ info_compo_t *compo_Idx=&tile_Idx->compo[compno]; // INDEX
+
+ // border of each tile component (global)
+ tilec->x0=int_ceildiv(tile->x0, img->comps[compno].dx);
+ tilec->y0=int_ceildiv(tile->y0, img->comps[compno].dy);
+ tilec->x1=int_ceildiv(tile->x1, img->comps[compno].dx);
+ tilec->y1=int_ceildiv(tile->y1, img->comps[compno].dy);
+
+ tilec->data=(int*)malloc(sizeof(int)*(tilec->x1-tilec->x0)*(tilec->y1-tilec->y0));
+ tilec->numresolutions=tccp->numresolutions;
+ tilec->resolutions=(tcd_resolution_t*)malloc(tilec->numresolutions*sizeof(tcd_resolution_t));
+ compo_Idx->reso=(info_reso_t*)malloc(tilec->numresolutions*sizeof(info_reso_t)); // INDEX
+ for (resno=0; resno<tilec->numresolutions; resno++) {
+ int pdx, pdy;
+ int levelno=tilec->numresolutions-1-resno;
+ int tlprcxstart, tlprcystart, brprcxend, brprcyend;
+ int tlcbgxstart, tlcbgystart, brcbgxend, brcbgyend;
+ int cbgwidthexpn, cbgheightexpn;
+ int cblkwidthexpn, cblkheightexpn;
+ tcd_resolution_t *res=&tilec->resolutions[resno];
+ info_reso_t *res_Idx=&compo_Idx->reso[resno]; // INDEX
+ int precno_Idx; // INDEX
+
+ // border for each resolution level (global)
+ res->x0=int_ceildivpow2(tilec->x0, levelno);
+ res->y0=int_ceildivpow2(tilec->y0, levelno);
+ res->x1=int_ceildivpow2(tilec->x1, levelno);
+ res->y1=int_ceildivpow2(tilec->y1, levelno);
+
+ res->numbands=resno==0?1:3;
+ // p. 35, table A-23, ISO/IEC FDIS154444-1 : 2000 (18 august 2000)
+ if (tccp->csty&J2K_CCP_CSTY_PRT) {
+ pdx=tccp->prcw[resno];
+ pdy=tccp->prch[resno];
+ } else {
+ pdx=15;
+ pdy=15;
+ }
+ // p. 64, B.6, ISO/IEC FDIS15444-1 : 2000 (18 august 2000)
+ tlprcxstart=int_floordivpow2(res->x0, pdx)<<pdx;
+ tlprcystart=int_floordivpow2(res->y0, pdy)<<pdy;
+ brprcxend=int_ceildivpow2(res->x1, pdx)<<pdx;
+ brprcyend=int_ceildivpow2(res->y1, pdy)<<pdy;
+ res->pw=(brprcxend-tlprcxstart)>>pdx;
+ res->ph=(brprcyend-tlprcystart)>>pdy;
+
+ // <INDEX>
+ imgg->tile[tileno].pw=res->pw;
+ imgg->tile[tileno].ph=res->ph;
+
+ res_Idx->prec=(info_prec_t*)malloc(res->pw*res->ph*sizeof(info_prec_t));
+ for (precno_Idx=0;precno_Idx<res->pw*res->ph;precno_Idx++)
+ {
+ info_prec_t *prec_Idx = &res_Idx->prec[precno_Idx];
+ prec_Idx->layer=(info_layer_t*)malloc(imgg->Layer*sizeof(info_layer_t));
+ }
+
+ imgg->pw=res->pw; // old parser version
+ imgg->ph=res->ph; // old parser version
+ imgg->pdx=1<<pdx;
+ imgg->pdy=1<<pdy;
+ // </INDEX>
+
+ if (resno==0) {
+ tlcbgxstart=tlprcxstart;
+ tlcbgystart=tlprcystart;
+ brcbgxend=brprcxend;
+ brcbgyend=brprcyend;
+ cbgwidthexpn=pdx;
+ cbgheightexpn=pdy;
+ } else {
+ tlcbgxstart=int_ceildivpow2(tlprcxstart, 1);
+ tlcbgystart=int_ceildivpow2(tlprcystart, 1);
+ brcbgxend=int_ceildivpow2(brprcxend, 1);
+ brcbgyend=int_ceildivpow2(brprcyend, 1);
+ cbgwidthexpn=pdx-1;
+ cbgheightexpn=pdy-1;
+ }
+
+ cblkwidthexpn=int_min(tccp->cblkw, cbgwidthexpn);
+ cblkheightexpn=int_min(tccp->cblkh, cbgheightexpn);
+
+ for (bandno=0; bandno<res->numbands; bandno++) {
+ int x0b, y0b;
+ tcd_band_t *band=&res->bands[bandno];
+ band->bandno=resno==0?0:bandno+1;
+ x0b=(band->bandno==1)||(band->bandno==3)?1:0;
+ y0b=(band->bandno==2)||(band->bandno==3)?1:0;
+
+ if (band->bandno==0) {
+ // band border (global)
+ band->x0=int_ceildivpow2(tilec->x0, levelno);
+ band->y0=int_ceildivpow2(tilec->y0, levelno);
+ band->x1=int_ceildivpow2(tilec->x1, levelno);
+ band->y1=int_ceildivpow2(tilec->y1, levelno);
+ } else {
+ // band border (global)
+ band->x0=int_ceildivpow2(tilec->x0-(1<<levelno)*x0b, levelno+1);
+ band->y0=int_ceildivpow2(tilec->y0-(1<<levelno)*y0b, levelno+1);
+ band->x1=int_ceildivpow2(tilec->x1-(1<<levelno)*x0b, levelno+1);
+ band->y1=int_ceildivpow2(tilec->y1-(1<<levelno)*y0b, levelno+1);
+ }
+
+ band->precincts=(tcd_precinct_t*)malloc(res->pw*res->ph*sizeof(tcd_precinct_t));
+
+ for (precno=0; precno<res->pw*res->ph; precno++) {
+ int tlcblkxstart, tlcblkystart, brcblkxend, brcblkyend;
+ int cbgxstart=tlcbgxstart+(precno%res->pw)*(1<<cbgwidthexpn);
+ int cbgystart=tlcbgystart+(precno/res->pw)*(1<<cbgheightexpn);
+ int cbgxend=cbgxstart+(1<<cbgwidthexpn);
+ int cbgyend=cbgystart+(1<<cbgheightexpn);
+ tcd_precinct_t *prc=&band->precincts[precno];
+ // precinct size (global)
+ prc->x0=int_max(cbgxstart, band->x0);
+ prc->y0=int_max(cbgystart, band->y0);
+ prc->x1=int_min(cbgxend, band->x1);
+ prc->y1=int_min(cbgyend, band->y1);
+
+ tlcblkxstart=int_floordivpow2(prc->x0, cblkwidthexpn)<<cblkwidthexpn;
+ tlcblkystart=int_floordivpow2(prc->y0, cblkheightexpn)<<cblkheightexpn;
+ brcblkxend=int_ceildivpow2(prc->x1, cblkwidthexpn)<<cblkwidthexpn;
+ brcblkyend=int_ceildivpow2(prc->y1, cblkheightexpn)<<cblkheightexpn;
+ prc->cw=(brcblkxend-tlcblkxstart)>>cblkwidthexpn;
+ prc->ch=(brcblkyend-tlcblkystart)>>cblkheightexpn;
+
+ prc->cblks=(tcd_cblk_t*)malloc(prc->cw*prc->ch*sizeof(tcd_cblk_t));
+
+ prc->incltree=tgt_create(prc->cw, prc->ch);
+ prc->imsbtree=tgt_create(prc->cw, prc->ch);
+
+ for (cblkno=0; cblkno<prc->cw*prc->ch; cblkno++) {
+ int cblkxstart=tlcblkxstart+(cblkno%prc->cw)*(1<<cblkwidthexpn);
+ int cblkystart=tlcblkystart+(cblkno/prc->cw)*(1<<cblkheightexpn);
+ int cblkxend=cblkxstart+(1<<cblkwidthexpn);
+ int cblkyend=cblkystart+(1<<cblkheightexpn);
+ tcd_cblk_t *cblk=&prc->cblks[cblkno];
+ // code-block size (global)
+ cblk->x0=int_max(cblkxstart, prc->x0);
+ cblk->y0=int_max(cblkystart, prc->y0);
+ cblk->x1=int_min(cblkxend, prc->x1);
+ cblk->y1=int_min(cblkyend, prc->y1);
+ }
+ }
+ }
+ }
+ }
+ }
+}
+
+
+void tcd_free(j2k_image_t *img, j2k_cp_t *cp) {
+ int tileno, compno, resno, bandno, precno;
+ tcd_img=img;
+ tcd_cp=cp;
+ tcd_image.tw=cp->tw;
+ tcd_image.th=cp->th;
+ for (tileno=0; tileno<tcd_image.tw*tcd_image.th; tileno++)
+ {
+ // j2k_tcp_t *tcp=&cp->tcps[curtileno];
+ tcd_tile_t *tile=&tcd_image.tiles[tileno];
+ for (compno=0; compno<tile->numcomps; compno++)
+ {
+ tcd_tilecomp_t *tilec=&tile->comps[compno];
+ for (resno=0; resno<tilec->numresolutions; resno++)
+ {
+ tcd_resolution_t *res=&tilec->resolutions[resno];
+ for (bandno=0; bandno<res->numbands; bandno++)
+ {
+ tcd_band_t *band=&res->bands[bandno];
+ for (precno=0; precno<res->pw*res->ph; precno++)
+ {
+ tcd_precinct_t *prc=&band->precincts[precno];
+
+ if (prc->incltree!=NULL)
+ tgt_destroy(prc->incltree);
+ if (prc->imsbtree!=NULL)
+ tgt_destroy(prc->imsbtree);
+ free(prc->cblks);
+ } // for (precno
+ free(band->precincts);
+ } // for (bandno
+ } // for (resno
+ free(tilec->resolutions);
+ } // for (compno
+ free(tile->comps);
+ } // for (tileno
+ free(tcd_image.tiles);
+}
+
+
+int tcd_decode_tile(unsigned char *src, int len, int tileno, info_image_t *imgg) {
+ int l;
+ int eof=0;
+
+ tcd_tile_t *tile;
+ tcd_tileno=tileno;
+ tcd_tile=&tcd_image.tiles[tileno];
+ tcd_tcp=&tcd_cp->tcps[tileno];
+ tile=tcd_tile;
+
+ l=t2_decode_packets(src, len, tcd_img, tcd_cp, tileno, tile, imgg);
+
+ if (l==-999)
+ {
+ eof=1;
+ fprintf(stderr, "tcd_decode: incomplete bistream\n");
+ }
+
+ if (eof) {
+ longjmp(j2k_error, 1);
+ }
+
+ l=1;
+ return l;
+}
--- /dev/null
+/*
+ * Copyright (c) 2001-2002, David Janssens
+ * Copyright (c) 2003, Yannick Verschueren
+ * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __TCD_H
+#define __TCD_H
+
+#include "j2k.h"
+#include "tgt.h"
+
+typedef struct {
+ int numpasses;
+ int len;
+ unsigned char *data;
+ int maxpasses;
+ int numnewpasses;
+ int newlen;
+} tcd_seg_t;
+
+typedef struct {
+ int rate;
+ double distortiondec;
+} tcd_pass_t;
+
+typedef struct {
+ int numpasses;
+ int len;
+ unsigned char *data;
+} tcd_layer_t;
+
+typedef struct {
+ int x0, y0, x1, y1;
+ int numbps;
+ int numlenbits;
+ int len;
+ int numpasses;
+ int numnewpasses;
+ int numsegs;
+ tcd_seg_t segs[100];
+ unsigned char data[8192];
+ int numpassesinlayers;
+ tcd_layer_t layers[100];
+ int totalpasses;
+ tcd_pass_t passes[100];
+} tcd_cblk_t;
+
+typedef struct {
+ int x0, y0, x1, y1;
+ int cw, ch;
+ tcd_cblk_t *cblks;
+ tgt_tree_t *incltree;
+ tgt_tree_t *imsbtree;
+} tcd_precinct_t;
+
+typedef struct {
+ int x0, y0, x1, y1;
+ int bandno;
+ tcd_precinct_t *precincts;
+ int numbps;
+ int stepsize;
+} tcd_band_t;
+
+typedef struct {
+ int x0, y0, x1, y1;
+ int previous_x0, previous_y0, previous_x1, previous_y1; // usefull for the DWT
+ int cas_col, cas_row; // usefull for the DWT
+ int pw, ph;
+ int numbands;
+ tcd_band_t bands[3];
+} tcd_resolution_t;
+
+typedef struct {
+ int x0, y0, x1, y1;
+ int previous_row, previous_col; // usefull for the DWT
+ int numresolutions;
+ tcd_resolution_t *resolutions;
+ int *data;
+} tcd_tilecomp_t;
+
+typedef struct {
+ int x0, y0, x1, y1;
+ int numcomps;
+ //int PPT;
+ //int len_ppt;
+ tcd_tilecomp_t *comps;
+} tcd_tile_t;
+
+typedef struct {
+ int tw, th;
+ tcd_tile_t *tiles;
+} tcd_image_t;
+
+/*
+ * Initialize the tile coder/decoder
+ * img: raw image
+ * cp: coding parameters
+ * imgg: creation of index file
+ */
+
+void tcd_init(j2k_image_t *img, j2k_cp_t *cp, info_image_t *imgg);
+
+void tcd_free(j2k_image_t *img, j2k_cp_t *cp);
+
+/*
+ * Decode a tile from a buffer into a raw image
+ * src: source buffer
+ * len: length of the source buffer
+ * tileno: number that identifies the tile that will be decoded
+ * imgg : Structure for index file
+ */
+int tcd_decode_tile(unsigned char *src, int len, int tileno, info_image_t *imgg);
+
+#endif
--- /dev/null
+/*
+ * Copyright (c) 2001-2002, David Janssens
+ * Copyright (c) 2003, Yannick Verschueren
+ * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "tgt.h"
+#include "bio.h"
+#include <stdlib.h>
+#include <stdio.h>
+
+/// <summary>
+/// Reset tag-tree.
+/// </summary>
+void tgt_reset(tgt_tree_t *tree)
+{
+ int i;
+ for (i=0; i<tree->numnodes; i++) {
+ tree->nodes[i].value=999;
+ tree->nodes[i].low=0;
+ tree->nodes[i].known=0;
+ }
+}
+
+/// <summary>
+/// Create tag-tree.
+/// </summary>
+tgt_tree_t *tgt_create(int numleafsh, int numleafsv)
+{
+ int nplh[32];
+ int nplv[32];
+ tgt_node_t *node;
+ tgt_node_t *parentnode;
+ tgt_node_t *parentnode0;
+ tgt_tree_t *tree;
+ int i, j, k;
+ int numlvls;
+ int n;
+
+ tree=(tgt_tree_t*)malloc(sizeof(tgt_tree_t));
+ tree->numleafsh=numleafsh;
+ tree->numleafsv=numleafsv;
+
+ numlvls=0;
+ nplh[0]=numleafsh;
+ nplv[0]=numleafsv;
+ tree->numnodes=0;
+ do {
+ n=nplh[numlvls]*nplv[numlvls];
+ nplh[numlvls+1]=(nplh[numlvls]+1)/2;
+ nplv[numlvls+1]=(nplv[numlvls]+1)/2;
+ tree->numnodes+=n;
+ ++numlvls;
+ } while (n>1);
+
+ tree->nodes=(tgt_node_t*)malloc(tree->numnodes*sizeof(tgt_node_t));
+
+ node=tree->nodes;
+ parentnode=&tree->nodes[tree->numleafsh*tree->numleafsv];
+ parentnode0=parentnode;
+
+ for (i=0; i<numlvls-1; ++i) {
+ for (j=0; j<nplv[i]; ++j) {
+ k=nplh[i];
+ while (--k>=0) {
+ node->parent=parentnode;
+ ++node;
+ if (--k >= 0) {
+ node->parent=parentnode;
+ ++node;
+ }
+ ++parentnode;
+ }
+ if ((j&1)||j==nplv[i]-1) {
+ parentnode0=parentnode;
+ } else {
+ parentnode=parentnode0;
+ parentnode0+=nplh[i];
+ }
+ }
+ }
+ node->parent=0;
+
+ tgt_reset(tree);
+
+ return tree;
+}
+
+/// <summary>
+/// Destroy tag-tree.
+/// </summary>
+void tgt_destroy(tgt_tree_t *t) {
+ free(t->nodes);
+ free(t);
+}
+
+/// <summary>
+/// Set the value of a leaf of the tag-tree.
+/// </summary>
+void tgt_setvalue(tgt_tree_t *tree, int leafno, int value) {
+ tgt_node_t *node;
+ node=&tree->nodes[leafno];
+ while (node && node->value>value) {
+ node->value=value;
+ node=node->parent;
+ }
+}
+
+/// <summary>
+/// Decode the value of a leaf of the tag-tree.
+/// </summary>
+int tgt_decode(tgt_tree_t *tree, int leafno, int threshold)
+{
+ tgt_node_t *stk[31];
+ tgt_node_t **stkptr;
+ tgt_node_t *node;
+ int low;
+
+ stkptr=stk;
+ node=&tree->nodes[leafno];
+ while (node->parent) {
+ *stkptr++=node;
+ node=node->parent;
+ }
+
+ low=0;
+ for (;;) {
+ if (low>node->low) {
+ node->low=low;
+ } else {
+ low=node->low;
+ }
+ while (low<threshold && low<node->value) {
+ if (bio_read(1)) {
+ node->value=low;
+ } else {
+ ++low;
+ }
+ }
+ node->low=low;
+ if (stkptr==stk) {
+ break;
+ }
+ node=*--stkptr;
+ }
+
+ return (node->value<threshold)?1:0;
+}
--- /dev/null
+/*
+ * Copyright (c) 2001-2002, David Janssens
+ * Copyright (c) 2003, Yannick Verschueren
+ * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __TGT_H
+#define __TGT_H
+
+typedef struct tgt_node {
+ struct tgt_node *parent;
+ int value;
+ int low;
+ int known;
+} tgt_node_t;
+
+typedef struct {
+ int numleafsh;
+ int numleafsv;
+ int numnodes;
+ tgt_node_t *nodes;
+} tgt_tree_t;
+
+/*
+ * Create a tag-tree
+ * numleafsh: width of the array of leafs of the tree
+ * numleafsv: height of the array of leafs of the tree
+ */
+tgt_tree_t *tgt_create(int numleafsh, int numleafsv);
+
+/*
+ * Reset a tag-tree (set all leafs to 0)
+ * tree: tag-tree to reset
+ */
+void tgt_reset(tgt_tree_t *tree);
+
+/*
+ * Destroy a tag-tree, liberating memory
+ * tree: tag-tree to destroy
+ */
+void tgt_destroy(tgt_tree_t *tree);
+
+/*
+ * Set the value of a leaf of a tag-tree
+ * tree: tag-tree to modify
+ * leafno: number that identifies the leaf to modify
+ * value: new value of the leaf
+ */
+void tgt_setvalue(tgt_tree_t *tree, int leafno, int value);
+
+/*
+ * Decode the value of a leaf of the tag-tree up to a given threshold
+ * leafno: number that identifies the leaf to decode
+ * threshold: threshold to use when decoding value of the leaf
+ */
+int tgt_decode(tgt_tree_t *tree, int leafno, int threshold);
+
+#endif
projects / openjpeg.git / commitdiff