diff --git a/applications/jpip/CHANGES b/applications/jpip/CHANGES
index cf68b81b..0e3bf44a 100644
--- a/applications/jpip/CHANGES
+++ b/applications/jpip/CHANGES
@@ -6,6 +6,7 @@ What's New for OpenJPIP
 + : added
 
 August 26, 2011
+! [kaori] indexer using the latest openjpeg library
 * [antonin] fixed cmake and autotools files to reflect recent changes in JPIP
 ! [kaori] fixed Makefile.nix to load openjpeg library from this archive
 
diff --git a/applications/jpip/README b/applications/jpip/README
index 28410745..0f053189 100644
--- a/applications/jpip/README
+++ b/applications/jpip/README
@@ -132,7 +132,7 @@ An example to encode a TIF image "copenhague1.tif" at resolution 4780x4050, 8bit
     % ./kdu_compress -i copenhague1.tif -o copenhague1.j2k Corder=RPCL  ORGtparts=R Stiles={256,256}
 
  2. JP2 encoding with embedding indexing data
-    % ./index_create copenhague1.j2k copenhague1.jp2 2
+    % ./j2k_to_idxjp2 copenhague1.j2k copenhague1.jp2
 
 <Option>
  3. Embed metadata into JP2 file
diff --git a/applications/jpip/opj_client/opj_dec_server/Makefile.nix b/applications/jpip/opj_client/opj_dec_server/Makefile.nix
index eee95fb3..dd8e06cf 100644
--- a/applications/jpip/opj_client/opj_dec_server/Makefile.nix
+++ b/applications/jpip/opj_client/opj_dec_server/Makefile.nix
@@ -1,9 +1,8 @@
 J2KINCDIR = ../../../../libopenjpeg
-J2KCNFDIR = ../../../..
 J2KLIBDIR = $(J2KINCDIR)/.libs
 JPIPLIBDIR = ../../libopenjpip
 LIBFNAME = $(JPIPLIBDIR)/libopenjpip_local.a $(J2KLIBDIR)/libopenjpeg.a
-CFLAGS  = -O3 -Wall -I$(JPIPLIBDIR) -I$(J2KINCDIR) -I$(J2KCNFDIR)
+CFLAGS  = -O3 -Wall -I$(JPIPLIBDIR) -I$(J2KINCDIR)
 LDFLAGS = -L$(JPIPLIBDIR) -L$(J2KLIBDIR) -lm -lopenjpip_local
 #-lws2_32
 
diff --git a/applications/jpip/tools/indexer/CMakeLists.txt b/applications/jpip/tools/indexer/CMakeLists.txt
deleted file mode 100644
index 43422e50..00000000
--- a/applications/jpip/tools/indexer/CMakeLists.txt
+++ /dev/null
@@ -1,26 +0,0 @@
-SET(INDEXER_SRCS
-${CMAKE_CURRENT_SOURCE_DIR}/bio.c
-${CMAKE_CURRENT_SOURCE_DIR}/cio.c
-${CMAKE_CURRENT_SOURCE_DIR}/index_create.c
-${CMAKE_CURRENT_SOURCE_DIR}/int.c
-${CMAKE_CURRENT_SOURCE_DIR}/jp2.c
-${CMAKE_CURRENT_SOURCE_DIR}/jpip.c
-${CMAKE_CURRENT_SOURCE_DIR}/pi.c
-${CMAKE_CURRENT_SOURCE_DIR}/t2.c
-${CMAKE_CURRENT_SOURCE_DIR}/tcd.c
-${CMAKE_CURRENT_SOURCE_DIR}/tgt.c
-)
-
-# Build executable
-
-ADD_EXECUTABLE(index_create ${INDEXER_SRCS})
-
-# On unix you need to link to the math library:
-IF(UNIX)
-  TARGET_LINK_LIBRARIES(index_create m)
-ENDIF(UNIX)
-# Install exe
-INSTALL(TARGETS index_create
-  EXPORT OpenJPEGTargets
-  DESTINATION ${OPENJPEG_INSTALL_BIN_DIR} COMPONENT Applications
-)
\ No newline at end of file
diff --git a/applications/jpip/tools/indexer/Makefile.am b/applications/jpip/tools/indexer/Makefile.am
deleted file mode 100644
index c0803e90..00000000
--- a/applications/jpip/tools/indexer/Makefile.am
+++ /dev/null
@@ -1,34 +0,0 @@
-MAINTAINERCLEANFILES = Makefile.in
-
-bin_PROGRAMS = index_create
-
-index_create_CPPFLAGS = \
--I. \
--I$(top_srcdir)/applications/libopenjpip/tools/indexer \
--I$(top_builddir)/applications/libopenjpip/tools/indexer
-index_create_CFLAGS = 
-index_create_LDADD = -lm
-index_create_SOURCES = \
-bio.c \
-bio.h \
-cio.c \
-cio.h \
-index_create.c \
-int.c \
-int.h \
-j2k.h \
-jp2.c \
-jp2.h \
-jpip.c \
-jpip.h \
-pi.c \
-pi.h \
-t2.c \
-t2.h \
-tcd.c \
-tcd.h \
-tgt.c \
-tgt.h
-
-install-data-hook:
-	@echo -e " (B)\t$(bindir)/index_create$(EXEEXT)" >> $(top_builddir)/report.txt
diff --git a/applications/jpip/tools/indexer/Makefile.nix b/applications/jpip/tools/indexer/Makefile.nix
index 1003cb61..4ea2b8c6 100644
--- a/applications/jpip/tools/indexer/Makefile.nix
+++ b/applications/jpip/tools/indexer/Makefile.nix
@@ -1,23 +1,14 @@
-CC = gcc
+INCDIR = ../../../../libopenjpeg
+LIBDIR = $(INCDIR)/.libs
+LIBFNAME = $(LIBDIR)/libopenjpeg.a
+CFLAGS  = -O3 -Wall -I$(INCDIR)
+LDFLAGS = -L$(LIBDIR) -lm 
 
-LDFLAGS = -lm
-CFLAGS = -Wall
+ALL = j2k_to_idxjp2
 
-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
+all: $(ALL)
 
+j2k_to_idxjp2: j2k_to_idxjp2.o event_mgr_handler.o idxjp2_manager.o j2k_decoder.o cidx_manager.o cio_ext.o tpix_manager.o thix_manager.o ppix_manager.o phix_manager.o $(LIBFNAME)
+	$(CC) $(CFLAGS) $< event_mgr_handler.o idxjp2_manager.o j2k_decoder.o cidx_manager.o cio_ext.o tpix_manager.o thix_manager.o ppix_manager.o phix_manager.o $(LDFLAGS) $(LIBFNAME) -o $@
 clean:
-	rm -rf index_create *.o *.*~ *~ core.*
+	rm -f $(ALL) *.o *~
diff --git a/applications/jpip/tools/indexer/bio.c b/applications/jpip/tools/indexer/bio.c
deleted file mode 100644
index 2c989e56..00000000
--- a/applications/jpip/tools/indexer/bio.c
+++ /dev/null
@@ -1,125 +0,0 @@
-/*
- * 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 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;
-}
-
-int bio_byteout()
-{
-	bio_buf = (bio_buf << 8) & 0xffff;
-	bio_ct = bio_buf == 0xff00 ? 7 : 8;
-	if (bio_bp >= bio_end)
-		return 1;
-	*bio_bp++ = bio_buf >> 8;
-	return 0;
-}
-
-/// <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>
-/// Read bit.
-/// </summary>
-int bio_getbit() {
-    if (bio_ct==0) {
-        bio_bytein();
-    }
-    bio_ct--;
-    return (bio_buf>>bio_ct)&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;
-}
diff --git a/applications/jpip/tools/indexer/cidx_manager.c b/applications/jpip/tools/indexer/cidx_manager.c
new file mode 100644
index 00000000..b8112da5
--- /dev/null
+++ b/applications/jpip/tools/indexer/cidx_manager.c
@@ -0,0 +1,213 @@
+/*
+ * $Id$
+ *
+ * Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2011, Professor Benoit Macq
+ * Copyright (c) 2003-2004, Yannick Verschueren
+ * Copyright (c) 2010-2011, Kaori Hagihara
+ * 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 "cidx_manager.h"
+#include "indexbox_manager.h"
+#include "cio_ext.h"
+#include "cio.h"
+
+
+/* 
+ * Write CPTR Codestream finder box
+ *
+ * @param[in] coff offset of j2k codestream
+ * @param[in] clen length of j2k codestream
+ * @param[in] cio  file output handle
+ */
+void write_cptr(int coff, int clen, opj_cio_t *cio);
+
+
+/* 
+ * Write main header index table (box)
+ *
+ * @param[in] cstr_info codestream information
+ * @param[in] cio  file output handle
+ * @return         length of mainmhix box
+ */
+int write_mainmhix( opj_codestream_info_t cstr_info, opj_cio_t *cio);
+
+
+/* 
+ * Check if EPH option is used
+ *
+ * @param[in] coff    offset of j2k codestream
+ * @param[in] markers marker information
+ * @param[in] marknum number of markers
+ * @param[in] cio     file output handle
+ * @return            true if EPH is used
+ */
+opj_bool check_EPHuse( int coff, opj_marker_info_t *markers, int marknum, opj_cio_t *cio);
+
+
+int write_cidx( int offset, opj_cio_t *cio, opj_image_t *image, opj_codestream_info_t cstr_info, int j2klen)
+{
+  int len, i, lenp;
+  opj_jp2_box_t *box;
+  int num_box = 0;
+  opj_bool  EPHused;
+
+  box = (opj_jp2_box_t *)calloc( 32, sizeof(opj_jp2_box_t));
+
+  for (i=0;i<2;i++){
+  
+    if(i)
+      cio_seek( cio, lenp);
+
+    lenp = cio_tell( cio);
+
+    cio_skip( cio, 4);              /* L [at the end] */
+    cio_write( cio, JPIP_CIDX, 4);  /* CIDX           */
+    write_cptr( offset, cstr_info.codestream_size, cio);
+
+    write_manf( i, num_box, box, cio);
+    
+    num_box = 0;
+    box[num_box].length = write_mainmhix( cstr_info, cio);
+    box[num_box].type = JPIP_MHIX;
+    num_box++;
+
+    box[num_box].length = write_tpix( cstr_info, j2klen, cio);
+    box[num_box].type = JPIP_TPIX;
+    num_box++;
+      
+    box[num_box].length = write_thix( offset, cstr_info, cio);
+    box[num_box].type = JPIP_THIX;
+    num_box++;
+
+    EPHused = check_EPHuse( offset, cstr_info.marker, cstr_info.marknum, cio);
+      
+    box[num_box].length = write_ppix( cstr_info, EPHused, j2klen, cio);
+    box[num_box].type = JPIP_PPIX;
+    num_box++;
+      
+    box[num_box].length = write_phix( cstr_info, EPHused, j2klen, cio);
+    box[num_box].type = JPIP_PHIX;
+    num_box++;
+      
+    len = cio_tell( cio)-lenp;
+    cio_seek( cio, lenp);
+    cio_write( cio, len, 4);        /* L             */
+    cio_seek( cio, lenp+len);
+  }
+
+  free( box);
+  
+  return len;
+}
+
+void write_cptr(int coff, int clen, opj_cio_t *cio)
+{
+  int len, lenp;
+
+  lenp = cio_tell( cio);
+  cio_skip( cio, 4);               /* L [at the end]     */
+  cio_write( cio, JPIP_CPTR, 4);   /* T                  */
+  cio_write( cio, 0, 2);           /* DR  A PRECISER !!  */
+  cio_write( cio, 0, 2);           /* CONT               */
+  cio_ext_write( cio, coff, 8);    /* COFF A PRECISER !! */
+  cio_ext_write( cio, clen, 8);    /* CLEN               */
+  len = cio_tell( cio) - lenp;
+  cio_seek( cio, lenp);
+  cio_write( cio, len, 4);         /* L                  */
+  cio_seek( cio, lenp+len);
+}
+
+void write_manf(int second, int v, opj_jp2_box_t *box, opj_cio_t *cio)
+{
+  int len, lenp, i;
+  
+  lenp = cio_tell( cio); 
+  cio_skip( cio, 4);                         /* L [at the end]                    */
+  cio_write( cio, JPIP_MANF,4);              /* T                                 */
+
+  if (second){                          /* Write only during the second pass */
+    for( i=0; i<v; i++){
+      cio_write( cio, box[i].length, 4);  /* Box length                     */ 
+      cio_write( cio, box[i].type, 4); /* Box type                       */
+    }
+  }
+
+  len = cio_tell( cio) - lenp;
+  cio_seek( cio, lenp);
+  cio_write( cio, len, 4);                   /* L                                 */
+  cio_seek( cio, lenp+len);
+}
+
+int write_mainmhix( opj_codestream_info_t cstr_info, opj_cio_t *cio)
+{
+  int i;
+  int len, lenp;
+  
+  lenp = cio_tell( cio);
+  cio_skip( cio, 4);                               /* L [at the end]                    */
+  cio_write( cio, JPIP_MHIX, 4);                   /* MHIX                              */
+
+  cio_ext_write( cio, cstr_info.main_head_end-cstr_info.main_head_start+1, 8);        /* TLEN                              */
+
+  for(i = 1; i < cstr_info.marknum; i++){    /* Marker restricted to 1 apparition, skip SOC marker */
+    cio_write( cio, cstr_info.marker[i].type, 2);
+    cio_write( cio, 0, 2);
+    cio_ext_write( cio, cstr_info.marker[i].pos, 8);
+    cio_write( cio, cstr_info.marker[i].len, 2);
+  }
+
+  len = cio_tell( cio) - lenp;
+  cio_seek( cio, lenp);
+  cio_write( cio, len, 4);        /* L           */
+  cio_seek( cio, lenp+len);
+  
+  return len;
+}
+
+opj_bool check_EPHuse( int coff, opj_marker_info_t *markers, int marknum, opj_cio_t *cio)
+{
+  opj_bool EPHused = OPJ_FALSE;
+  int i=0;
+  int org_pos;
+  unsigned int Scod;
+
+  for(i = 0; i < marknum; i++){
+    if( markers[i].type == J2K_MS_COD){
+      org_pos = cio_tell( cio);
+      cio_seek( cio, coff+markers[i].pos+2);
+      
+      Scod = cio_read( cio, 1);
+      if( ((Scod >> 2) & 1))
+	EPHused = OPJ_TRUE;
+      cio_seek( cio, org_pos);
+
+      break;
+    }
+  }    
+  return EPHused;
+}
diff --git a/applications/jpip/tools/indexer/cio.h b/applications/jpip/tools/indexer/cidx_manager.h
similarity index 62%
rename from applications/jpip/tools/indexer/cio.h
rename to applications/jpip/tools/indexer/cidx_manager.h
index 3e297897..f83a9802 100644
--- a/applications/jpip/tools/indexer/cio.h
+++ b/applications/jpip/tools/indexer/cidx_manager.h
@@ -1,7 +1,10 @@
 /*
- * Copyright (c) 2001-2002, David Janssens
+ * $Id$
+ *
+ * Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2011, Professor Benoit Macq
  * Copyright (c) 2003-2004, Yannick Verschueren
- * Copyright (c) 2003-2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * Copyright (c) 2010-2011, Kaori Hagihara
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -26,19 +29,28 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef __CIO_H
-#define __CIO_H
+/*! \file
+ *  \brief Modification of jpip.h from 2KAN indexer
+ */
 
-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); */
-long long cio_read(int n);
-void cio_skip(int n);
 
-#endif
+#ifndef  CIDX_MANAGER_H_
+# define CIDX_MANAGER_H_
+
+#include "openjpeg.h"
+
+
+/* 
+ * Write Codestream index box (superbox)
+ *
+ * @param[in] offset    offset of j2k codestream
+ * @param[in] cio       file output handle
+ * @param[in] image     image data
+ * @param[in] cstr_info codestream information
+ * @param[in] j2klen    length of j2k codestream
+ * @return              length of cidx box
+ */
+int write_cidx( int offset, opj_cio_t *cio, opj_image_t *image, opj_codestream_info_t cstr_info, int j2klen);
+
+
+#endif      /* !CIDX_MANAGER_H_ */
diff --git a/applications/jpip/tools/indexer/cio.c b/applications/jpip/tools/indexer/cio.c
deleted file mode 100644
index 29f160ee..00000000
--- a/applications/jpip/tools/indexer/cio.c
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- * 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) { */
-long long cio_read(int n) {
-    int i;
-    /*unsigned int v;*/
-    long long 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;
-}
diff --git a/applications/jpip/tools/indexer/jpip.h b/applications/jpip/tools/indexer/cio_ext.c
similarity index 57%
rename from applications/jpip/tools/indexer/jpip.h
rename to applications/jpip/tools/indexer/cio_ext.c
index 84df3554..d507cc9f 100644
--- a/applications/jpip/tools/indexer/jpip.h
+++ b/applications/jpip/tools/indexer/cio_ext.c
@@ -1,6 +1,13 @@
 /*
- * Copyright (c) 2003, Yannick Verschueren
- * Copyright (c) 2003,  Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * $Id$
+ *
+ * Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2011, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * Copyright (c) 2010-2011, Kaori Hagihara
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -25,18 +32,31 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef __JPIP_H
-#define __JPIP_H
+#include "cio_ext.h"
+#include "event.h"
 
-#include "j2k.h"
 
-// Codestream index box (superbox)
-int jpip_write_cidx(int offset, info_image_t img, j2k_cp_t *j2k_cp, int version);
+/*
+ * Write a byte.
+ */
+opj_bool cio_ext_byteout(opj_cio_t *cio, unsigned char v);
 
-// Index Finder Box
-void jpip_write_iptr(int offset, int length);
+unsigned int cio_ext_write( opj_cio_t *cio, unsigned long long int v, int n)
+{  
+  int i;
+  for (i = n - 1; i >= 0; i--) {
+    if( !cio_ext_byteout(cio, (unsigned char) ((v >> (i << 3)) & 0xff)) )
+      return 0;
+  }
+  return n;
+}
 
-// File Index Box
-int jpip_write_fidx(int offset_jp2c, int length_jp2c, int offset_idx, int length_idx);
-
-#endif
+opj_bool cio_ext_byteout(opj_cio_t *cio, unsigned char v)
+{
+  if (cio->bp >= cio->end) {
+    opj_event_msg(cio->cinfo, EVT_ERROR, "write error\n");
+    return OPJ_FALSE;
+  }
+  *cio->bp++ = v;
+  return OPJ_TRUE;
+}
diff --git a/applications/jpip/tools/indexer/t2.h b/applications/jpip/tools/indexer/cio_ext.h
similarity index 65%
rename from applications/jpip/tools/indexer/t2.h
rename to applications/jpip/tools/indexer/cio_ext.h
index f4951079..42f138df 100644
--- a/applications/jpip/tools/indexer/t2.h
+++ b/applications/jpip/tools/indexer/cio_ext.h
@@ -1,7 +1,9 @@
 /*
- * Copyright (c) 2001-2002, David Janssens
- * Copyright (c) 2003, Yannick Verschueren
- * Copyright (c) 2003,  Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * $Id$
+ *
+ * Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2011, Professor Benoit Macq
+ * Copyright (c) 2010-2011, Kaori Hagihara
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -26,21 +28,25 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef __T2_H
-#define __T2_H
+/*! \file
+ *  \brief Additional functions to libopenjpeg/cio.h
+ */
+
+#ifndef  CIO_EXT_H_
+# define CIO_EXT_H_
+
+#include "openjpeg.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
+ * Write byte codes with 5 bytes to 8 bytes length
+ *     cio_write supports up to 4 bytes
+ *
+ * @param[in] cio file handler
+ * @param[in] v   byte code
+ * @param[in] n   byte length
+ * @return        really writen byte length
  */
-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 int cio_ext_write( opj_cio_t *cio, unsigned long long int v, int n);
 
-#endif
+#endif      /* !CIO_EXT_H_ */
diff --git a/applications/jpip/tools/indexer/event_mgr_handler.c b/applications/jpip/tools/indexer/event_mgr_handler.c
new file mode 100644
index 00000000..d6d57ba9
--- /dev/null
+++ b/applications/jpip/tools/indexer/event_mgr_handler.c
@@ -0,0 +1,72 @@
+/*
+ * $Id$
+ *
+ * Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2011, Professor Benoit Macq
+ * Copyright (c) 2010-2011, Kaori Hagihara
+ * 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 <string.h>
+#include "event_mgr_handler.h"
+
+void error_callback(const char *msg, void *client_data);
+void warning_callback(const char *msg, void *client_data);
+void info_callback(const char *msg, void *client_data);
+
+opj_event_mgr_t set_default_event_mgr()
+{
+  opj_event_mgr_t event_mgr;
+
+  /* configure the event callbacks (not required) */
+  memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
+  event_mgr.error_handler = error_callback;
+  event_mgr.warning_handler = warning_callback;
+  event_mgr.info_handler = info_callback;
+
+  return event_mgr;
+}
+
+/**
+   sample error callback expecting a FILE* client object
+*/
+void error_callback(const char *msg, void *client_data) {
+  FILE *stream = (FILE*)client_data;
+  fprintf(stream, "[ERROR] %s", msg);
+}
+/**
+   sample warning callback expecting a FILE* client object
+*/
+void warning_callback(const char *msg, void *client_data) {
+  FILE *stream = (FILE*)client_data;
+  fprintf(stream, "[WARNING] %s", msg);
+}
+/**
+   sample debug callback expecting no client object
+*/
+void info_callback(const char *msg, void *client_data) {
+  (void)client_data;
+  //  fprintf(stdout, "[INFO] %s", msg);
+}
diff --git a/applications/jpip/tools/indexer/jp2.h b/applications/jpip/tools/indexer/event_mgr_handler.h
similarity index 74%
rename from applications/jpip/tools/indexer/jp2.h
rename to applications/jpip/tools/indexer/event_mgr_handler.h
index d5510f5a..1fd40f1c 100644
--- a/applications/jpip/tools/indexer/jp2.h
+++ b/applications/jpip/tools/indexer/event_mgr_handler.h
@@ -1,6 +1,9 @@
 /*
- * Copyright (c) 2003, Yannick Verschueren
- * Copyright (c) 2003,  Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * $Id$
+ *
+ * Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2011, Professor Benoit Macq
+ * Copyright (c) 2010-2011, Kaori Hagihara
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -24,21 +27,17 @@
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
-#ifndef __JP2_H
-#define __JP2_H
 
-#include "j2k.h"
+#ifndef  EVENT_MG_HANDLER_H_
+# define EVENT_MG_HANDLER_H_
 
-void jp2_write_url(char *Idx_file);
+#include "openjpeg.h"
 
-void jp2_write_dbtl(char *Idx_file);
+/* 
+ * Set default event message handler
+ *
+ * @return event message handler
+ */
+opj_event_mgr_t set_default_event_mgr();
 
-void jp2_write_jp2h(j2k_image_t *j2k_img);
-
-void jp2_write_ftyp();
-
-int jp2_write_jp2c(char *J2K_file);
-
-void jp2_write_jp();
-
-#endif
+#endif      /* !EVENT_MG_HANDLER_H_ */
diff --git a/applications/jpip/tools/indexer/idxjp2_manager.c b/applications/jpip/tools/indexer/idxjp2_manager.c
new file mode 100644
index 00000000..08c9217b
--- /dev/null
+++ b/applications/jpip/tools/indexer/idxjp2_manager.c
@@ -0,0 +1,306 @@
+/*
+ * $Id$
+ *
+ * Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2011, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+
+ * Copyright (c) 2010-2011, Kaori Hagihara
+ * 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.
+ */
+
+/*! \file
+ *  \brief Copy of some jp2.c functions, and modification of jpip.h from 2KAN indexer
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include "event_mgr_handler.h"
+#include "cio.h"
+#include "cio_ext.h"
+#include "j2k_to_idxjp2.h"
+#include "cidx_manager.h"
+#include "indexbox_manager.h"
+
+/* 
+ * Encode JP2 stream with index box
+ *
+ * @param[in] jp2       jp2 handle
+ * @param[in] cio       file output handle
+ * @param[in] j2kstream j2k codestream
+ * @param[in] j2klen    length of j2k codestream
+ * @param[in] cstr_info codestream information
+ * @param[in] image     image data
+ * @return              true if succeed
+ */
+opj_bool idxjp2_encode( opj_jp2_t *jp2, opj_cio_t *cio, unsigned char *j2kstream, int j2klen, opj_codestream_info_t cstr_info, opj_image_t *image);
+
+
+void fwrite_idxjp2( char filename[], unsigned char *j2kstream, int j2klen, opj_image_t *image, opj_codestream_info_t cstr_info)
+{
+  int codestream_length;
+  opj_cio_t *cio = NULL;
+  FILE *fp = NULL;
+  opj_cinfo_t *cinfo;
+  opj_cparameters_t parameters;	/* compression parameters */
+  opj_event_mgr_t event_mgr;
+  opj_bool encSuccess;
+
+  /* set encoding parameters to default values */
+  opj_set_default_encoder_parameters(&parameters);
+  
+  /* get a JP2 compressor handle */
+  cinfo = opj_create_compress(CODEC_JP2);
+
+  event_mgr = set_default_event_mgr();
+
+  /* catch events using our callbacks and give a local context */
+  opj_set_event_mgr((opj_common_ptr)cinfo, &event_mgr, stderr);
+
+  /* setup the encoder parameters using the current image and using user parameters */
+  opj_setup_encoder(cinfo, &parameters, image);
+
+  /* open a byte stream for writing */
+  /* allocate memory for all tiles */
+  cio = opj_cio_open((opj_common_ptr)cinfo, NULL, 0);
+
+  encSuccess = idxjp2_encode( (opj_jp2_t*)cinfo->jp2_handle, cio, j2kstream, j2klen, cstr_info, image);
+
+  if (!encSuccess){
+    opj_cio_close(cio);
+    fprintf(stderr, "failed to encode image\n");
+    return;
+  }
+  codestream_length = cio_tell(cio);
+
+  /* write the buffer to disk */
+  fp = fopen( filename, "wb");
+  if (!fp) {
+    fprintf(stderr, "failed to open %s for writing\n", filename);
+    return;
+  }
+
+  fwrite(cio->buffer, 1, codestream_length, fp);
+  fclose(fp);
+  fprintf(stderr,"Generated outfile %s\n", filename);
+  /* close and free the byte stream */
+  opj_cio_close(cio);
+
+  /* free remaining compression structures */
+  opj_destroy_compress(cinfo);
+
+  opj_destroy_cstr_info(&cstr_info);
+}
+
+/* 
+ * Write JP box
+ *    copy from jp2.c
+ *
+ * @param[in] cio file output handler
+ */
+void jp2_write_jp(opj_cio_t *cio);
+
+/* 
+ * Write FTYP box - File type box
+ *    copy from jp2.c
+ *
+ * @param[in] jp2 JP2 handle
+ * @param[in] cio file output handle
+ */
+void jp2_write_ftyp(opj_jp2_t *jp2, opj_cio_t *cio);
+
+/* 
+ * Write file Index (superbox)
+ *
+ * @param[in] offset_jp2c offset of jp2c box
+ * @param[in] length_jp2c length of jp2c box
+ * @param[in] offset_idx  offset of cidx box
+ * @param[in] length_idx  length of cidx box
+ * @param[in] cio         file output handle
+ * @return                length of fidx box
+ */
+int write_fidx( int offset_jp2c, int length_jp2c, int offset_idx, int length_idx, opj_cio_t *cio);
+
+/* 
+ * Write index Finder box
+ *
+ * @param[in] offset offset of fidx box
+ * @param[in] length length of fidx box
+ * @param[in] cio         file output handle
+ */
+void write_iptr( int offset, int length, opj_cio_t *cio);
+
+opj_bool idxjp2_encode( opj_jp2_t *jp2, opj_cio_t *cio, unsigned char *j2kstream, int j2klen, opj_codestream_info_t cstr_info, opj_image_t *image)
+{  
+  int pos_iptr, pos_cidx, pos_jp2c, end_pos, pos_fidx, len_fidx;
+  int i;
+  
+  /* JP2 encoding */
+ 
+  /* JPEG 2000 Signature box */
+  jp2_write_jp(cio);
+  /* File Type box */
+  jp2_write_ftyp(jp2, cio);
+  /* JP2 Header box */
+  jp2_write_jp2h(jp2, cio);
+  
+  pos_iptr = cio_tell( cio);
+  cio_skip( cio, 24); /* IPTR further ! */
+  
+  pos_jp2c = cio_tell( cio);
+
+  cio_write( cio, j2klen+8, 4); // L NOTICE: modify for the extended box
+  cio_write( cio, JP2_JP2C, 4);  // JP2C
+
+  for( i=0; i<j2klen; i++)
+    cio_write( cio, j2kstream[i], 1);
+
+  pos_cidx = cio_tell( cio);
+
+  write_cidx( pos_jp2c+8, cio, image, cstr_info, j2klen);
+
+  pos_fidx = cio_tell( cio);
+  len_fidx = write_fidx( pos_jp2c, pos_cidx-pos_jp2c, pos_cidx, cio_tell(cio), cio);
+
+  end_pos = cio_tell( cio);
+
+  cio_seek( cio, pos_iptr);
+  write_iptr( pos_fidx, len_fidx, cio);
+  
+  cio_seek( cio, end_pos);
+
+  return OPJ_TRUE;
+}
+
+void jp2_write_jp( opj_cio_t *cio)
+{
+  opj_jp2_box_t box;
+
+  box.init_pos = cio_tell(cio);
+  cio_skip(cio, 4);
+  cio_write(cio, JP2_JP, 4);		/* JP2 signature */
+  cio_write(cio, 0x0d0a870a, 4);
+
+  box.length = cio_tell(cio) - box.init_pos;
+  cio_seek(cio, box.init_pos);
+  cio_write(cio, box.length, 4);	/* L */
+  cio_seek(cio, box.init_pos + box.length);
+}
+
+void jp2_write_ftyp(opj_jp2_t *jp2, opj_cio_t *cio)
+{
+  unsigned int i;
+  opj_jp2_box_t box;
+
+  box.init_pos = cio_tell(cio);
+  cio_skip(cio, 4);
+  cio_write(cio, JP2_FTYP, 4);		/* FTYP */
+
+  cio_write(cio, jp2->brand, 4);		/* BR */
+  cio_write(cio, jp2->minversion, 4);	/* MinV */
+
+  for (i = 0; i < jp2->numcl; i++) {
+    cio_write(cio, jp2->cl[i], 4);	/* CL */
+  }
+
+  box.length = cio_tell(cio) - box.init_pos;
+  cio_seek(cio, box.init_pos);
+  cio_write(cio, box.length, 4);	/* L */
+  cio_seek(cio, box.init_pos + box.length);
+}
+
+
+/* 
+ * Write proxy box
+ *
+ * @param[in] offset_jp2c offset of jp2c box
+ * @param[in] length_jp2c length of jp2c box
+ * @param[in] offset_idx  offset of cidx box
+ * @param[in] length_idx  length of cidx box
+ * @param[in] cio         file output handle
+ */
+void write_prxy( int offset_jp2c, int length_jp2c, int offset_idx, int length_idx, opj_cio_t *cio);
+
+int write_fidx( int offset_jp2c, int length_jp2c, int offset_idx, int length_idx, opj_cio_t *cio)
+{  
+  int len, lenp;
+  
+  lenp = cio_tell( cio);
+  cio_skip( cio, 4);              /* L [at the end] */
+  cio_write( cio, JPIP_FIDX, 4);  /* IPTR           */
+  
+  write_prxy( offset_jp2c, length_jp2c, offset_idx, offset_jp2c, cio);
+
+  len = cio_tell( cio)-lenp;
+  cio_seek( cio, lenp);
+  cio_write( cio, len, 4);        /* L              */
+  cio_seek( cio, lenp+len);  
+
+  return len;
+}
+
+void write_prxy( int offset_jp2c, int length_jp2c, int offset_idx, int length_idx, opj_cio_t *cio)
+{
+  int len, lenp;
+
+  lenp = cio_tell( cio);
+  cio_skip( cio, 4);              /* L [at the end] */
+  cio_write( cio, JPIP_PRXY, 4);  /* IPTR           */
+  
+  cio_ext_write( cio, offset_jp2c, 8); /* OOFF           */
+  cio_write( cio, length_jp2c, 4); /* OBH part 1     */
+  cio_write( cio, JP2_JP2C, 4);        /* OBH part 2     */
+  
+  cio_write( cio, 1,1);           /* NI             */
+
+  cio_ext_write( cio, offset_idx, 8);  /* IOFF           */
+  cio_write( cio, length_idx, 4);  /* IBH part 1     */
+  cio_write( cio, JPIP_CIDX, 4);   /* IBH part 2     */
+
+  len = cio_tell( cio)-lenp;
+  cio_seek( cio, lenp);
+  cio_write( cio, len, 4);        /* L              */
+  cio_seek( cio, lenp+len);
+}
+
+void write_iptr( int offset, int length, opj_cio_t *cio)
+{
+  int len, lenp;
+  
+  lenp = cio_tell( cio);
+  cio_skip( cio, 4);              /* L [at the end] */
+  cio_write( cio, JPIP_IPTR, 4);  /* IPTR           */
+  
+  cio_ext_write( cio, offset, 8);
+  cio_ext_write( cio, length, 8);
+
+  len = cio_tell( cio)-lenp;
+  cio_seek( cio, lenp);
+  cio_write( cio, len, 4);        /* L             */
+  cio_seek( cio, lenp+len);
+}
diff --git a/applications/jpip/tools/indexer/index_create.c b/applications/jpip/tools/indexer/index_create.c
deleted file mode 100644
index 1e90152d..00000000
--- a/applications/jpip/tools/indexer/index_create.c
+++ /dev/null
@@ -1,1227 +0,0 @@
-/*
- * Copyright (c) 2001-2002, David Janssens
- * Copyright (c) 2003-2004, Yannick Verschueren
- * Copyright (c) 2003-2004, 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
-
-#define START_NB 10
-#define INCREMENT 5
-
-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=0, resno=0, precno=0;
-
-  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(tile_Idx->marker);
-    free(tile_Idx->tile_parts);
-    free(tile_Idx->marker_mul.COC);
-    free(tile_Idx->marker_mul.RGN);
-    free(tile_Idx->marker_mul.QCC);
-    free(tile_Idx->marker_mul.PLT);
-    free(tile_Idx->marker_mul.PPT);
-    free(tile_Idx->marker_mul.COM);
-}
-  free(img.tile);
-  free(img.marker);
-  free(img.marker_mul.COC);
-  free(img.marker_mul.RGN);
-  free(img.marker_mul.QCC);
-  free(img.marker_mul.PLM);
-  free(img.marker_mul.PPM);
-  free(img.marker_mul.COM);
-}
-
-
-
-void j2k_read_soc() {
-  j2k_state=J2K_STATE_MHSIZ;
-}
-
-
-
-void j2k_read_siz() {
-    int len, i;
-    info_tile_t *tile;
-
-    len = cio_read(2);
-
-    /* <INDEX> [MHIX BOX] */
-    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> [MHIX BOX] */
-    
-    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_cp->tx0, j2k_cp->tdx);
-    j2k_cp->th = int_ceildiv(j2k_img->y1 - j2k_cp->ty0, j2k_cp->tdy);
-
-    j2k_cp->tcps = (j2k_tcp_t*)calloc((j2k_cp->tw * j2k_cp->th), sizeof(j2k_tcp_t));
-
-    for (i = 0; i < j2k_cp->tw * j2k_cp->th; i++)
-      {
-	j2k_cp->tcps[i].POC = 0;
-	j2k_cp->tcps[i].numpocs = 0;
-	// j2k_cp->tcps[i].first=1;
-      }
-
-    /* Initialization for PPM marker */
-    j2k_cp->ppm = 0;
-    j2k_cp->ppm_data = NULL;
-    j2k_cp->ppm_previous = 0;
-    j2k_cp->ppm_store = 0;
-
-    j2k_default_tcp.tccps = (j2k_tccp_t*)malloc(j2k_img->numcomps * sizeof(j2k_tccp_t));
-    for (i = 0; i < j2k_cp->tw * j2k_cp->th; i++) {
-	j2k_cp->tcps[i].tccps = (j2k_tccp_t*)malloc(j2k_img->numcomps * sizeof(j2k_tccp_t));
-    }
-    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));
-
-    for (i = 0; i < img.tw * img.th; i++)
-      {
-	tile = &img.tile[i];
-	tile->marker = (info_marker_t*)malloc(32 * sizeof(info_marker_t));
-	tile->num_marker = 0;
-	tile->marker_mul.num_COC = 0;
-	tile->marker_mul.CzCOC = START_NB;
-	tile->marker_mul.num_RGN = 0;
-	tile->marker_mul.CzRGN = START_NB;
-	tile->marker_mul.num_QCC = 0;
-	tile->marker_mul.CzQCC = START_NB;
-	tile->marker_mul.num_PLT = 0;
-	tile->marker_mul.CzPLT = START_NB;
-	tile->marker_mul.num_PPT = 0;
-	tile->marker_mul.CzPPT = START_NB;
-	tile->marker_mul.num_COM = 0;
-	tile->marker_mul.CzCOM = START_NB;
-      }
-    /* </INDEX> */
-
-
- }
-
-void j2k_read_com() {
-    int len;
-    info_tile_t *tile;
-    info_marker_t *tmp;
-
-    len = cio_read(2);
-
-    /* <INDEX> [MHIX BOX] */
-    if (j2k_state == J2K_STATE_MH)
-      {
-	if (!img.marker_mul.num_COM) 
-	  img.marker_mul.COM = (info_marker_t*)malloc(img.marker_mul.CzCOM * sizeof(info_marker_t));
-	if (img.marker_mul.num_COM >= img.marker_mul.CzCOM)
-	  {
-	    tmp = (info_marker_t*)malloc(2 * img.marker_mul.CzCOM * sizeof(info_marker_t));
-	    memcpy(tmp,img.marker_mul.COM,img.marker_mul.CzCOM);
-	    img.marker_mul.CzCOM *= 2;
-	    free(img.marker_mul.COM);
-	    img.marker_mul.COM = tmp;
-	  }
-
-	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++;
-      } else
-	{
-	  tile = &img.tile[j2k_curtileno];
-	  if (!tile->marker_mul.num_COM)
-	    tile->marker_mul.COM = (info_marker_t*)calloc(START_NB, sizeof(info_marker_t));
-	  if (tile->marker_mul.num_COM >= tile->marker_mul.CzCOM)
-	    {
-	      tmp = (info_marker_t*)malloc(2 * tile->marker_mul.CzCOM * sizeof(info_marker_t));
-	      memcpy(tmp,tile->marker_mul.COM,tile->marker_mul.CzCOM);
-	      tile->marker_mul.CzCOM *= 2;
-	      free(tile->marker_mul.COM);
-	      tile->marker_mul.COM = tmp;
-	    }
-	  tile->marker_mul.COM[tile->marker_mul.num_COM].type = J2K_MS_COM;
-	  tile->marker_mul.COM[tile->marker_mul.num_COM].start_pos = cio_tell()-2;
-	  tile->marker_mul.COM[tile->marker_mul.num_COM].len = len;
-	  tile->marker_mul.num_COM++;
-	}
-    /* </INDEX> [MHIX BOX] */
-
-    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;
-    info_tile_t *tile;
-
-    tcp = j2k_state == J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp;
-    len = cio_read(2);
-
-    /* <INDEX> [MHIX BOX] */
-    if (j2k_state == J2K_STATE_MH)
-      {
-	img.marker[img.num_marker].type = J2K_MS_COD;
-	img.marker[img.num_marker].start_pos = cio_tell()-2;
-	img.marker[img.num_marker].len = len;
-	img.num_marker++;
-      }
-    else
-      {
-	tile = &img.tile[j2k_curtileno];
-	tile->marker[tile->num_marker].type = J2K_MS_COD;
-	tile->marker[tile->num_marker].start_pos = cio_tell()-2;
-	tile->marker[tile->num_marker].len = len;
-	tile->num_marker++;
-  }
-    /* </INDEX> [MHIX BOX] */
-    
-    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;
-    info_tile_t *tile;
-    info_marker_t *tmp;
-
-    tcp = j2k_state == J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp;
-    len = cio_read(2);
-    
-    /* <INDEX> [MHIX BOX] */
-    if (j2k_state == J2K_STATE_MH)
-      {
-	if (!img.marker_mul.num_COC)
-	  img.marker_mul.COC = (info_marker_t*)malloc(img.marker_mul.CzCOC * sizeof(info_marker_t));
-	if (img.marker_mul.num_COC >= img.marker_mul.CzCOC)
-	  {
-	    tmp = (info_marker_t*)malloc((INCREMENT + img.marker_mul.CzCOC) * sizeof(info_marker_t));
-	    memcpy(tmp,img.marker_mul.COC,img.marker_mul.CzCOC);
-	    img.marker_mul.CzCOC += INCREMENT;
-	    free(img.marker_mul.COC);
-	    img.marker_mul.COC = tmp;
-	  }
-	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++;
-      } else
-	{
-	  tile = &img.tile[j2k_curtileno];
-	  if (!tile->marker_mul.num_COC)
-	    tile->marker_mul.COC = (info_marker_t*)malloc(tile->marker_mul.CzCOC * sizeof(info_marker_t));
-	  if (tile->marker_mul.num_COC >= tile->marker_mul.CzCOC)
-	    {
-	      tmp = (info_marker_t*)malloc((INCREMENT + tile->marker_mul.CzCOC) * sizeof(info_marker_t));
-	      memcpy(tmp,tile->marker_mul.COC,tile->marker_mul.CzCOC);
-	      tile->marker_mul.CzCOC += INCREMENT;
-	      free(tile->marker_mul.COC);
-	      tile->marker_mul.COC = tmp;
-	    }
-	  tile->marker_mul.COC[tile->marker_mul.num_COC].type = J2K_MS_COC;
-	  tile->marker_mul.COC[tile->marker_mul.num_COC].start_pos = cio_tell() - 2;
-	  tile->marker_mul.COC[tile->marker_mul.num_COC].len = len;
-	  tile->marker_mul.num_COC++;
-	}
-    /* </INDEX> [MHIX BOX] */
-    
-    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;
-    info_tile_t *tile;
-
-    len = cio_read(2);    
-
-    /* <INDEX> [MHIX BOX] */
-    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++;
-      }	 else
-	{
-	  tile = &img.tile[j2k_curtileno];
-	  tile->marker[tile->num_marker].type = J2K_MS_QCD;
-	  tile->marker[tile->num_marker].start_pos = cio_tell()-2;
-	  tile->marker[tile->num_marker].len = len;
-	  tile->num_marker++;
-	}
-    /* </INDEX> [MHIX BOX] */
-    
-    
-    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;
-  info_tile_t *tile;
-  info_marker_t *tmp;
-
-  len = cio_read(2);  
-  /* <INDEX> [MHIX BOX] */
-  if (j2k_state == J2K_STATE_MH)
-    {
-      if (!img.marker_mul.num_QCC)
-	img.marker_mul.QCC = (info_marker_t*)malloc(img.marker_mul.CzQCC * sizeof(info_marker_t));
-	if (img.marker_mul.num_QCC >= img.marker_mul.CzQCC)
-	  {
-	    tmp = (info_marker_t*)malloc((INCREMENT + img.marker_mul.CzQCC) * sizeof(info_marker_t));
-	    memcpy(tmp,img.marker_mul.QCC,img.marker_mul.CzQCC);
-	    img.marker_mul.CzQCC += INCREMENT;
-	    free(img.marker_mul.QCC);
-	    img.marker_mul.QCC = tmp;
-	  }
-      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++;
-    } else
-      {
-	tile = &img.tile[j2k_curtileno];
-	if (!tile->marker_mul.num_QCC)
-	  tile->marker_mul.QCC = (info_marker_t*)malloc(tile->marker_mul.CzQCC * sizeof(info_marker_t));
-	if (tile->marker_mul.num_QCC >= tile->marker_mul.CzQCC)
-	  {
-	    tmp = (info_marker_t*)malloc((INCREMENT + tile->marker_mul.CzQCC) * sizeof(info_marker_t));
-	    memcpy(tmp,tile->marker_mul.QCC,tile->marker_mul.CzQCC);
-	    tile->marker_mul.CzQCC += INCREMENT;
-	    free(tile->marker_mul.QCC);
-	    tile->marker_mul.QCC = tmp;
-	  }
-	tile->marker_mul.QCC[tile->marker_mul.num_QCC].type = J2K_MS_QCC;
-	tile->marker_mul.QCC[tile->marker_mul.num_QCC].start_pos = cio_tell()-2;
-	tile->marker_mul.QCC[tile->marker_mul.num_QCC].len = len;
-	tile->marker_mul.num_QCC++;
-      }
-  /* </INDEX> [MHIX BOX] */
- 
-  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, old_poc;
-  j2k_tcp_t *tcp;
-  j2k_tccp_t *tccp;
-  info_tile_t *tile;
-
-  tcp = j2k_state == J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp;
-  old_poc = tcp->POC ? tcp->numpocs+1 : 0;
-  tcp->POC = 1;
-  tccp = &tcp->tccps[0];
-  len = cio_read(2);
-  
-  /* <INDEX> [MHIX BOX] */
-  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++;
-    } else
-      {
-	tile = &img.tile[j2k_curtileno];
-	tile->marker[tile->num_marker].type = J2K_MS_POC;
-	tile->marker[tile->num_marker].start_pos = cio_tell()-2;
-	tile->marker[tile->num_marker].len = len;
-	tile->num_marker++;
-      }
-  /* </INDEX> [MHIX BOX] */
-
-    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 = int_min(cio_read(2), tcp->numlayers);
-      poc->resno1 = int_min(cio_read(1), tccp->numresolutions);
-      poc->compno1 = int_min(cio_read(j2k_img->numcomps <= 256 ? 1 : 2), j2k_img->numcomps);
-      poc->prg = cio_read(1);
-    }
-
-    tcp->numpocs = numpchgs + old_poc - 1;
-}
-
-
-
-
-void j2k_read_crg() {
-    int len, i, Xcrg_i, Ycrg_i;
-
-    len = cio_read(2);
-
-    /* <INDEX> [MHIX BOX] */
-    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> [MHIX BOX] */
-
-    for (i = 0; i < j2k_img->numcomps; i++)
-      {  
-	Xcrg_i = cio_read(2);
-	Ycrg_i = cio_read(2);
-      }
-}
-
-
-
-
-void j2k_read_tlm() {
-    int len, Ztlm, Stlm, ST, SP, tile_tlm, i;
-    long int Ttlm_i, Ptlm_i;
-    info_marker_t *tmp;
-
-    len = cio_read(2);
-
-    /* <INDEX> [MHIX BOX] */
-    if (!img.marker_mul.num_TLM)
-      img.marker_mul.TLM = (info_marker_t*)malloc(img.marker_mul.CzTLM * sizeof(info_marker_t));
-    if (img.marker_mul.num_TLM >= img.marker_mul.CzTLM)
-      {
-	tmp = (info_marker_t*)malloc((INCREMENT + img.marker_mul.CzTLM) * sizeof(info_marker_t));
-	memcpy(tmp,img.marker_mul.TLM,img.marker_mul.CzTLM);
-	img.marker_mul.CzTLM += INCREMENT;
-	free(img.marker_mul.TLM);
-	img.marker_mul.TLM = tmp;
-      }
-    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> [MHIX BOX] */
-    
-    Ztlm = cio_read(1);
-    Stlm = cio_read(1);
-    ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
-    SP = (Stlm >> 6) & 0x01;
-    tile_tlm = (len - 4) / ((SP + 1) * 2 + ST);
-    for (i = 0; i < tile_tlm; i++)
-      {
-	Ttlm_i = cio_read(ST);
-	Ptlm_i = cio_read(SP ? 4 : 2);
-      }
-}
-
-
-
-
-void j2k_read_plm() {
-    int len, i, Z_plm, N_plm, add, packet_len=0;
-    info_marker_t *tmp;
-
-    len=cio_read(2);
-
-    /* <INDEX> [MHIX BOX] */
-    if (!img.marker_mul.num_PLM)
-      img.marker_mul.PLM = (info_marker_t*)malloc(img.marker_mul.CzPLM * sizeof(info_marker_t));
-    if (img.marker_mul.num_PLM >= img.marker_mul.CzPLM)
-      {
-	tmp = (info_marker_t*)malloc((INCREMENT + img.marker_mul.CzPLM) * sizeof(info_marker_t));
-	memcpy(tmp,img.marker_mul.PLM,img.marker_mul.CzPLM);
-	img.marker_mul.CzPLM += INCREMENT;
-	free(img.marker_mul.PLM);
-	img.marker_mul.PLM = tmp;
-      }
-    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> [MHIX BOX] */
-
-    Z_plm = cio_read(1);
-    len -= 3;
-    while (len > 0)
-      {
-	N_plm = cio_read(4);
-	len -= 4;
-	for (i = N_plm ; i > 0 ; i--)
-	  {
-	    add = cio_read(1);
-	    len--;
-	    packet_len = (packet_len << 7) + add;
-	    if ((add & 0x80) == 0)
-	      {
-		/* New packet */
-		packet_len = 0;
-	      }
-	    if (len <= 0) break;
-	  } 
-      }
-}
-
-
-
-
-void j2k_read_plt() {
-    int len, i, Zplt, packet_len=0, add;
-    info_tile_t *tile;
-    info_marker_t *tmp;
-;
-    len = cio_read(2);
- 
-    /* <INDEX> [MHIX BOX] */
-    tile = &img.tile[j2k_curtileno];
-    if (!tile->marker_mul.num_PLT)
-      tile->marker_mul.PLT = (info_marker_t*)malloc(tile->marker_mul.CzPLT * sizeof(info_marker_t));
-    if (tile->marker_mul.num_PLT >= tile->marker_mul.CzPLT)
-      {
-	tmp = (info_marker_t*)malloc((INCREMENT + tile->marker_mul.CzPLT) * sizeof(info_marker_t));
-	memcpy(tmp,tile->marker_mul.PLT,tile->marker_mul.CzPLT);
-	tile->marker_mul.CzPLT += INCREMENT;
-	free(tile->marker_mul.PLT);
-	tile->marker_mul.PLT = tmp;
-      }
-
-    tile->marker_mul.PLT[tile->marker_mul.num_PLT].type = J2K_MS_PLT;
-    tile->marker_mul.PLT[tile->marker_mul.num_PLT].start_pos = cio_tell()-2;
-    tile->marker_mul.PLT[tile->marker_mul.num_PLT].len = len;
-    tile->marker_mul.num_PLT++;
-    /* </INDEX> [MHIX BOX] */
-    
-    Zplt = cio_read(1);
-    for (i = len-3; i > 0; i--)
-      {
-	add = cio_read(1);
-	packet_len = (packet_len << 7) + add;
-	if ((add & 0x80) == 0)
-	  {
-	    /* New packet */
-	    packet_len = 0;
-	  }
-      }
-}
-
-
-
-
-void j2k_read_ppm() {
-    int len, Z_ppm, i, j;
-    int N_ppm;
-    info_marker_t *tmp;
-
-    len = cio_read(2);
-    
-    /* <INDEX> [MHIX BOX] */
-    if (!img.marker_mul.num_PPM)
-      img.marker_mul.PPM = (info_marker_t*)malloc(img.marker_mul.CzPPM * sizeof(info_marker_t));
-    if (img.marker_mul.num_PPM >= img.marker_mul.CzPPM)
-      {
-	tmp = (info_marker_t*)malloc((INCREMENT + img.marker_mul.CzPPM) * sizeof(info_marker_t));
-	memcpy(tmp,img.marker_mul.PPM,img.marker_mul.CzPPM);
-	img.marker_mul.CzPPM += INCREMENT;
-	free(img.marker_mul.PPM);
-	img.marker_mul.PPM = tmp;
-      }
-    img.marker_mul.PLM[img.marker_mul.num_PPM].type = J2K_MS_PPM;
-    img.marker_mul.PLM[img.marker_mul.num_PPM].start_pos = cio_tell()-2;
-    img.marker_mul.PLM[img.marker_mul.num_PPM].len = len;
-    img.marker_mul.num_PPM++;
-    /* </INDEX> [MHIX BOX] */
-    
-    j2k_cp->ppm = 1;
-    
-    Z_ppm = cio_read(1); /* Z_ppm */
-    len -= 3;
-    while (len > 0)
-      {
-	if (j2k_cp->ppm_previous == 0)
-	  {
-	    N_ppm = cio_read(4); /* N_ppm */
-	    len -= 4;
-	  } else
-	    {
-	      N_ppm = j2k_cp->ppm_previous;
-	    }
-	
-	j = j2k_cp->ppm_store;
-	if (Z_ppm == 0) /* First PPM marker */
-	  j2k_cp->ppm_data = (unsigned char*)calloc(N_ppm, sizeof(unsigned char));
-	else      /* NON-first PPM marker */
-	  j2k_cp->ppm_data = (unsigned char*)realloc(j2k_cp->ppm_data, (N_ppm + j2k_cp->ppm_store) * sizeof(unsigned char));
-	
-	for (i = N_ppm ; i > 0 ; i--) /* Read packet header */
-	  {
-	    j2k_cp->ppm_data[j] = cio_read(1);
-	    j++;
-	    len--;
-	    if (len == 0) break; /* Case of non-finished packet header in present marker but finished in next one */
-	  }
-	
-	j2k_cp->ppm_previous = i - 1;
-	j2k_cp->ppm_store = j;
-      }
-}
-
-
-
-
-void j2k_read_ppt() {
-    int len, Z_ppt, i, j = 0;
-    j2k_tcp_t *tcp;
-    info_tile_t *tile;
-    len=cio_read(2);
-
-    /* <INDEX> [MHIX BOX] */
-    tile = & img.tile[j2k_curtileno];
-    tile->marker[tile->num_marker].type = J2K_MS_PPT;
-    tile->marker[tile->num_marker].start_pos = cio_tell()-2;
-    tile->marker[tile->num_marker].len = len;
-    tile->num_marker++;
-    /* </INDEX> [MHIX BOX] */
-
-    Z_ppt = cio_read(1);
-    tcp = &j2k_cp->tcps[j2k_curtileno];
-    tcp->ppt = 1;
-    if (Z_ppt == 0) /* First PPT marker */
-      {
-	tcp->ppt_data = (unsigned char*)calloc(len - 3, sizeof(unsigned char));
-	tcp->ppt_store = 0;
-      }
-    else      /* NON-first PPT marker */
-      tcp->ppt_data = (unsigned char*)realloc(tcp->ppt_data, (len - 3 + tcp->ppt_store) * sizeof(unsigned char));
-    
-    j = tcp->ppt_store;
-    for (i = len - 3 ; i > 0 ; i--)
-      {
-	tcp->ppt_data[j] = cio_read(1);
-	j++;
-      }
-    tcp->ppt_store = j;
-}
-
-
-
-
-void j2k_read_sot() {
-    int len, tileno, totlen, partno, numparts, i;
-    j2k_tcp_t *tcp;
-    j2k_tccp_t *tmp;
-    info_tile_t *tile;
-    info_tile_part_t *tilepart_tmp;
-    
- 
-    //fprintf(stderr,"SOT\n");
-    len = cio_read(2);
-    tileno = cio_read(2);
-    /* <INDEX> [MHIX BOX] */
-    tile = & img.tile[tileno];
-    tile->marker[tile->num_marker].type = J2K_MS_SOT;
-    tile->marker[tile->num_marker].start_pos = cio_tell() - 4;
-    tile->marker[tile->num_marker].len = len;
-    tile->num_marker++;
-    /* </INDEX> [MHIX BOX] */
- 
-    totlen = cio_read(4);
-    if (!totlen) totlen = cio_numbytesleft() + 8;
-    partno = cio_read(1);
-    numparts = cio_read(1);
-
-    /* <INDEX> */
-    if (tileno == 0 && partno == 0 ) 
-      img.Main_head_end = cio_tell() - 12;  /* Correction End = First byte of first SOT */
-    
-    img.tile[tileno].num_tile = tileno;
-    /* </INDEX> */
-  
-    tile->numparts = partno + 1;                                               /* INDEX : Number of tile_parts for the tile */ 
-    img.num_max_tile_parts = int_max(tile->numparts, img.num_max_tile_parts);  /* INDEX : Maximum number of tile_part per tile */
-
-    if (partno == 0)
-    {
-      tile->tile_parts = (info_tile_part_t*)malloc(START_NB * sizeof(info_tile_part_t*));
-      tile->Cztile_parts = START_NB;
-    }
-    if (partno >= tile->Cztile_parts)
-      {
-	tilepart_tmp = (info_tile_part_t*)malloc((INCREMENT + tile->Cztile_parts) * sizeof(info_tile_part_t));
-	memcpy(tilepart_tmp, tile->tile_parts, tile->Cztile_parts); /*add tilepart_ a tmp*/
-	tile->Cztile_parts += INCREMENT;
-	free(tile->tile_parts);
-	tile->tile_parts = tilepart_tmp;
-      }
-
-    tile->tile_parts[partno].start_pos = cio_tell() - 12;        /* INDEX : start_pos of the tile_part       */
-    tile->tile_parts[partno].length = totlen;                    /* INDEX : length of the tile_part          */  
-    tile->tile_parts[partno].end_pos = totlen + cio_tell() - 12; /* INDEX : end position of the tile_part    */
-    //tile->tile_parts[partno].num_reso_AUX = j2k_default_tcp.tccps[0].numresolutions;
-
-    j2k_curtileno = tileno;
-    j2k_eot = cio_getbp() - 12 + totlen;
-    j2k_state = J2K_STATE_TPH;
-    tcp = &j2k_cp->tcps[j2k_curtileno];
-
-     if (partno == 0)
-       //  if (tcp->first == 1) 
-      {
-	tmp = tcp->tccps;
-	*tcp = j2k_default_tcp;
-	/* Initialization PPT */
-	tcp->ppt = 0; 
-	tcp->ppt_data = NULL;
-	
-	tcp->tccps = tmp;
-	for (i = 0; i < j2k_img->numcomps; i++) {
-	  tcp->tccps[i] = j2k_default_tcp.tccps[i];
-	}
-	//j2k_cp->tcps[j2k_curtileno].first=0;
-      }
-     //   tile->tile_parts[numparts].num_reso_AUX = tcp->tccps[0].numresolutions; /* INDEX : AUX value for TPIX       */
-}
-
-
-
-void j2k_read_rgn() {
-    int len, compno, roisty;
-    j2k_tcp_t *tcp;
-    info_tile_t *tile;
-    info_marker_t *tmp;
-    // fprintf(stderr,"RGN\n");
-    tcp = j2k_state == J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp;
-    len = cio_read(2);
-    
-    /* <INDEX> [MHIX BOX]*/
-    if (j2k_state == J2K_STATE_MH)
-      {
-	if (!img.marker_mul.num_RGN)
-	  img.marker_mul.RGN = (info_marker_t*)malloc(img.marker_mul.CzRGN * sizeof(info_marker_t));
-	if (img.marker_mul.num_RGN >= img.marker_mul.CzRGN)
-	  {
-	    tmp = (info_marker_t*)malloc((INCREMENT + img.marker_mul.CzRGN) * sizeof(info_marker_t));
-	    memcpy(tmp,img.marker_mul.RGN, img.marker_mul.CzRGN);
-	    img.marker_mul.CzRGN += INCREMENT;
-	    free(img.marker_mul.RGN);
-	    img.marker_mul.RGN = tmp;
-	  }
-	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++;
-      } else
-      {
-	tile = &img.tile[j2k_curtileno];
-	if (!tile->marker_mul.num_RGN)
-	  tile->marker_mul.RGN = (info_marker_t*)malloc(tile->marker_mul.CzRGN * sizeof(info_marker_t));
-	if (tile->marker_mul.num_RGN >= tile->marker_mul.CzRGN)
-	  {
-	    tmp = (info_marker_t*)malloc((INCREMENT + tile->marker_mul.CzRGN) * sizeof(info_marker_t));
-	    memcpy(tmp,tile->marker_mul.RGN,tile->marker_mul.CzRGN);
-	    tile->marker_mul.CzRGN += INCREMENT;
-	    free(tile->marker_mul.RGN);
-	    tile->marker_mul.RGN = tmp;
-	  }
-
-	tile->marker_mul.RGN[tile->marker_mul.num_RGN].type = J2K_MS_RGN;
-	tile->marker_mul.RGN[tile->marker_mul.num_RGN].start_pos = cio_tell() - 2;
-        tile->marker_mul.RGN[tile->marker_mul.num_RGN].len = len;
-	tile->marker_mul.num_RGN++;
-      }
-    /* </INDEX> [MHIX BOX] */
-    
-    compno = cio_read(j2k_img->numcomps <= 256 ? 1 : 2);
-    roisty = cio_read(1);
-    tcp->tccps[compno].roishift = cio_read(1);
-}
-
-
-
-
-
-void j2k_read_sod() {
-    int len, i;
-    unsigned char *data;
-    info_tile_t *tile;
-    info_tile_part_t *tile_part;
-    /* <INDEX> [MHIX BOX] */
-    tile = &img.tile[j2k_curtileno];
-    tile->marker[tile->num_marker].type = J2K_MS_SOD;
-    tile->marker[tile->num_marker].start_pos = cio_tell();
-    tile->marker[tile->num_marker].len = 0;
-    tile->num_marker++;
-    /* </INDEX> [MHIX BOX] */
-
-    tile_part = &tile->tile_parts[tile->numparts - 1];                   /* INDEX : Current tilepart of a tile                  */
-    tile_part->length_header = cio_tell() - 1 - tile_part->start_pos;    /* INDEX : length of the tile-part header              */
-    tile_part->end_header = cio_tell() - 1;                              /* INDEX : end header position of the tile-part header */
-
-    len = int_min(j2k_eot - cio_getbp(), cio_numbytesleft());
-
-    data = (unsigned char*)malloc((j2k_tile_len[j2k_curtileno] + len) * sizeof(unsigned char));
-
-    for (i=0; i<j2k_tile_len[j2k_curtileno]; i++)
-      data[i] = j2k_tile_data[j2k_curtileno][i];
-    for (i=0 ; i<len ; i++)
-      data[i+j2k_tile_len[j2k_curtileno]] = cio_read(1);
-    
-    j2k_tile_len[j2k_curtileno] += len;
-/*
-    free(j2k_tile_data[j2k_curtileno]);
- */
-    j2k_tile_data[j2k_curtileno] = data;	
-    data = NULL;
-
-    j2k_state = J2K_STATE_TPHSOT;
-}
-
-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, int version){
-  FILE *dest;
-  unsigned 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 = (unsigned 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, version); /* 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;
-}
-
-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*)calloc(1, sizeof(j2k_image_t));
-    j2k_cp = (j2k_cp_t*)calloc(1, 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
-
-int main(int argc, char **argv)
-{  
-  FILE *src;
-  int totlen;
-  unsigned char *j2kfile;
-  j2k_image_t *imgg;
-  j2k_cp_t *cp;
-  int version;
-
-  if (argc != 4)
-    {
-      fprintf(stderr,"\nERROR in entry : index_create J2K-file JP2-file version\n\nVersion : 0, 1, 2 or 3\n0 : [faix] 4-byte and no AUX fields\n1 : [faix] 8-byte and no AUX fields\n2 : [faix] 4-byte and AUX fields\n3 : [faix] 8-byte and AUX fields\n");
-      return 1;
-    }
-
-  src=fopen(argv[1], "rb");
-  if (!src) {
-    fprintf(stderr, "Failed to open %s for reading !!\n", argv[1]);
-    return 1;
-  }
-
-  /* length of the codestream */
-  fseek(src, 0, SEEK_END);
-  totlen = ftell(src);
-  fseek(src, 0, SEEK_SET);
-  
-  j2kfile = (unsigned char*)malloc(totlen);
-  fread(j2kfile, 1, totlen, src);
-  fclose(src);
-
-  img.marker = (info_marker_t*)malloc(32 * sizeof(info_marker_t));
-  img.num_marker = 0;
-  img.num_max_tile_parts = 0;
-  img.marker_mul.num_COC = 0;
-  img.marker_mul.CzCOC = START_NB;
-  img.marker_mul.num_RGN = 0;
-  img.marker_mul.CzRGN = START_NB;
-  img.marker_mul.num_QCC = 0;
-  img.marker_mul.CzQCC = START_NB;
-  img.marker_mul.num_TLM = 0;
-  img.marker_mul.CzTLM = START_NB;
-  img.marker_mul.num_PLM = 0;
-  img.marker_mul.CzPLM = START_NB;
-  img.marker_mul.num_PPM = 0;
-  img.marker_mul.CzPPM = START_NB;
-  img.marker_mul.num_COM = 0;
-  img.marker_mul.CzCOM = START_NB;
-
-  /* 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;
-  sscanf(argv[3], "%d", &version);
-  if (version > 3)
-    {
-      fprintf(stderr,"Error : value of version unauthorized !!  Value accepted : 0, 1, 2 or 3 !!\n");
-      return 0;
-    }
-
-  j2k_index_JPIP(argv[2], argv[1], totlen * 2 > 60000 ? totlen * 2 : 60000, version);
-  
-  j2k_clean();
-  return 0;
-}
- 
diff --git a/applications/jpip/tools/indexer/indexbox_manager.h b/applications/jpip/tools/indexer/indexbox_manager.h
new file mode 100644
index 00000000..ea4f4933
--- /dev/null
+++ b/applications/jpip/tools/indexer/indexbox_manager.h
@@ -0,0 +1,115 @@
+/*
+ * $Id$
+ *
+ * Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2011, Professor Benoit Macq
+ * Copyright (c) 2003-2004, Yannick Verschueren
+ * Copyright (c) 2010-2011, Kaori Hagihara
+ * 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.
+ */
+
+/*! \file
+ *  \brief Modification of jpip.c from 2KAN indexer
+ */
+
+#ifndef  INDEXBOX_MANAGER_H_
+# define INDEXBOX_MANAGER_H_
+
+#include "openjpeg.h"
+#include "j2k.h" // needed to use jp2.h
+#include "jp2.h"
+
+#define JPIP_CIDX 0x63696478   /* Codestream index                */
+#define JPIP_CPTR 0x63707472   /* Codestream Finder Box           */
+#define JPIP_MANF 0x6d616e66   /* Manifest Box                    */
+#define JPIP_FAIX 0x66616978   /* Fragment array Index box        */
+#define JPIP_MHIX 0x6d686978   /* Main Header Index Table         */
+#define JPIP_TPIX 0x74706978   /* Tile-part Index Table box       */
+#define JPIP_THIX 0x74686978   /* Tile header Index Table box     */
+#define JPIP_PPIX 0x70706978   /* Precinct Packet Index Table box */
+#define JPIP_PHIX 0x70686978   /* Packet Header index Table       */
+#define JPIP_FIDX 0x66696478   /* File Index                      */
+#define JPIP_FPTR 0x66707472   /* File Finder                     */
+#define JPIP_PRXY 0x70727879   /* Proxy boxes                     */
+#define JPIP_IPTR 0x69707472   /* Index finder box                */
+#define JPIP_PHLD 0x70686c64   /* Place holder                    */
+
+
+/* 
+ * Write tile-part Index table box (superbox)
+ *
+ * @param[in] cstr_info codestream information
+ * @param[in] j2klen    length of j2k codestream
+ * @param[in] cio       file output handle
+ * @return              length of tpix box
+ */
+int write_tpix( opj_codestream_info_t cstr_info, int j2klen, opj_cio_t *cio);
+
+
+/* 
+ * Write tile header index table box (superbox)
+ *
+ * @param[in] coff      offset of j2k codestream
+ * @param[in] cstr_info codestream information
+ * @param[in] cio       file output handle
+ * @return              length of thix box
+ */
+int write_thix( int coff, opj_codestream_info_t cstr_info, opj_cio_t *cio);
+
+
+/* 
+ * Write precinct packet index table box (superbox)
+ *
+ * @param[in] cstr_info codestream information
+ * @param[in] EPHused   true if EPH option used
+ * @param[in] j2klen    length of j2k codestream
+ * @param[in] cio       file output handle
+ * @return              length of ppix box
+ */
+int write_ppix( opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_cio_t *cio);
+
+
+/* 
+ * Write packet header index table box (superbox)
+ *
+ * @param[in] cstr_info codestream information
+ * @param[in] EPHused   true if EPH option used
+ * @param[in] j2klen    length of j2k codestream
+ * @param[in] cio       file output handle
+ * @return              length of ppix box
+ */
+int write_phix( opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_cio_t *cio);
+
+/* 
+ * Wriet manifest box (box)
+ *
+ * @param[in] second number to be visited
+ * @param[in] v      number of boxes
+ * @param[in] box    box to be manifested
+ * @param[in] cio    file output handle
+ */
+void write_manf(int second, int v, opj_jp2_box_t *box, opj_cio_t *cio);
+
+
+#endif      /* !INDEXBOX_MANAGER_H_ */
diff --git a/applications/jpip/tools/indexer/int.c b/applications/jpip/tools/indexer/int.c
deleted file mode 100644
index 29f778c9..00000000
--- a/applications/jpip/tools/indexer/int.c
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
- * 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;
-}
diff --git a/applications/jpip/tools/indexer/int.h b/applications/jpip/tools/indexer/int.h
deleted file mode 100644
index 4921ff4d..00000000
--- a/applications/jpip/tools/indexer/int.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * 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
diff --git a/applications/jpip/tools/indexer/j2k.h b/applications/jpip/tools/indexer/j2k.h
deleted file mode 100644
index c43e091f..00000000
--- a/applications/jpip/tools/indexer/j2k.h
+++ /dev/null
@@ -1,288 +0,0 @@
-/*
- * Copyright (c) 2001-2002, David Janssens
- * Copyright (c) 2003-2004, Yannick Verschueren
- * Copyright (c) 2003-2004, 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 version;
-  int x0, y0;          /* XOsiz, YOsiz              */
-  int x1, y1;          /* Xsiz, Ysiz                */ 
-  int numcomps;        /* number of components      */
-  int index_on;        /* 0 = no index || 1 = index */
-  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 first;
-  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                                     */
-  int POC;                   /* Precise if a POC marker has been used O:NO, 1:YES                       */
-  j2k_poc_t pocs[32];        /* progression order changes                                               */
-  unsigned char *ppt_data;   /* packet header store there for futur use in t2_decode_packet             */
-  int ppt;                   /* If ppt == 1 --> there was a PPT marker for the present tile             */
-  int ppt_store;             /* Use in case of multiple marker PPT (number of info already store)       */
-  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;
-  unsigned char *ppm_data;   /* packet header store there for futur use in t2_decode_packet             */
-  int ppm;                   /* If ppm == 1 --> there was a PPM marker for the present tile             */
-  int ppm_store;             /* Use in case of multiple marker PPM (number of info already store)       */
-  int ppm_previous;          /* Use in case of multiple marker PPM (case on non-finished previous info) */
-  j2k_tcp_t *tcps;           /* tile coding parameters                                                  */
-} j2k_cp_t;
-
-
-
-
-
-/* Packet information : Layer level */
-typedef struct {  
-  int len;               /* Length of the body of the packet   */
-  int len_header;        /* Length of the header of the packet */
-  int offset;            /* Offset of the body of the packet   */
-  int offset_header;     /* Offset of the header of the packet */
-} info_layer_t;
-
-
-/* Access to packet information : precinct level */
-typedef struct {  
-  info_layer_t *layer;
-} info_prec_t;
-
-
-/* Access to packet information : resolution level */
-typedef struct {  
-  info_prec_t *prec;
-} info_reso_t;
-
-
-/* Access to packet information : component level */
-typedef struct {  
-  info_reso_t *reso;
-} info_compo_t;
-
-
-/* Information about the marker */
-typedef struct {
-  int type;       /* type of marker [SIZ, QCD, POC, PPM, CRG, COD] appearing only once */
-  int start_pos;  /* Start position of the marker                                      */
-  int len;        /* Length of the marker                                              */
-} info_marker_t;
-
-
-/* Multiple marker in tile header */
-typedef struct{
-  info_marker_t *COC;    /* COC markers                    */
-  int num_COC;           /* Number of COC marker           */
-  int CzCOC;             /* Current size of the vector COC */
-  
-  info_marker_t *RGN;    /* RGN markers                    */
-  int num_RGN;           /* Number of RGN marker           */
-  int CzRGN;             /* Current size of the vector RGN */
-  
-  info_marker_t *QCC;    /* QCC markers                    */
-  int num_QCC;           /* Number of QCC marker           */
-  int CzQCC;             /* Current size of the vector QCC */
-  
-  info_marker_t *PLT;    /* PLT markers                    */
-  int num_PLT;           /* Number of PLT marker           */
-  int CzPLT;             /* Current size of the vector PLT */
-  
-  info_marker_t *PPT;    /* PPT markers                    */
-  int num_PPT;           /* Number of PPT marker           */
-  int CzPPT;             /* Current size of the vector PPT */
-  
-  info_marker_t *COM;    /* COM markers                    */
-  int num_COM;           /* Number of COM marker           */
-  int CzCOM;             /* Current size of the vector COC */
-} info_marker_mul_tile_t; 
-
-
-/* Information about each tile_part for a particulary tile */
-typedef struct{
-  int start_pos;                      /* Start position of the tile_part       */ 
-  int length;                         /* Length of the tile_part header + body */
-  int length_header;                  /* Length of the header                  */
-  int end_pos;                        /* End position of the tile part         */
-  int end_header;                     /* End position of the tile part header  */
-  int num_reso_AUX;                   /* Number of resolution level completed  */
-} info_tile_part_t;
-
-
-/* Information about each tile */
-typedef struct {
-  int num_tile;                       /* Number of Tile                                                    */
-  int pw, ph;                         /* number of precinct by tile                                        */
-  int num_packet;                     /* number of packet in the tile                                      */
-  info_compo_t *compo;                /* component [packet]                                                */
-  
-  info_marker_t *marker;              /* information concerning markers inside image [only one apparition] */
-  info_marker_mul_tile_t marker_mul;  /* information concerning markers inside image [multiple apparition] */ 
-  int num_marker;                     /* number of marker                                                  */
-  
-  int numparts;                       /* number of tile_part for this tile                                 */
-  info_tile_part_t *tile_parts;       /* Information about each tile_part                                  */
-  int Cztile_parts;                   /* Current size of the tile_parts vector                             */
-} info_tile_t;                        /* index struct                                                      */
-
-
-/* Multiple marker in main header */
-typedef struct{
-  info_marker_t *COC;    /* COC markers                    */
-  int num_COC;           /* Number of COC marker           */
-  int CzCOC;             /* Current size of the vector COC */
- 
-  info_marker_t *RGN;    /* RGN markers                    */
-  int num_RGN;           /* Number of RGN marker           */
-  int CzRGN;             /* Current size of the vector RGN */
-  
-  info_marker_t *QCC;    /* QCC markers                    */
-  int num_QCC;           /* Number of QCC marker           */
-  int CzQCC;             /* Current size of the vector QCC */
-  
-  info_marker_t *TLM;    /* TLM markers                    */
-  int num_TLM;           /* Number of TLM marker           */
-  int CzTLM;             /* Current size of the vector TLM */
-  
-  info_marker_t *PLM;    /* PLM markers                    */
-  int num_PLM;           /* Number of PLM marker           */
-  int CzPLM;             /* Current size of the vector PLM */
-  
-  info_marker_t *PPM;    /* PPM markers                    */
-  int num_PPM;           /* Number of PPM marker           */
-  int CzPPM;             /* Current size of the vector PPM */
-  
-  info_marker_t *COM;    /* COM markers                    */
-  int num_COM;           /* Number of COM marker           */
-  int CzCOM;             /* Current size of the vector COM */
-} info_marker_mul_t; /* index struct */
-
-
-/* Information about image */
-typedef struct {
-  int Im_w, Im_h;                /* Image width and Height                                            */
-  int Tile_x, Tile_y;            /* Number of Tile in X and Y                                         */
-  int tw, th;
-  int pw, ph;                    /* nombre precinct in X and Y                                        */
-  int pdx, pdy;                  /* size of precinct in X and Y                                       */
-
-  int Prog;                      /* progression order                                                 */
-  int Comp;                      /* Component numbers                                                 */
-  int Layer;                     /* number of layer                                                   */
-  int Decomposition;             /* number of decomposition                                           */
-
-  int Main_head_end;             /* Main header position                                              */
-  int codestream_size;           /* codestream's size                                                 */
-
-  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                                          */
-
-  int num_max_tile_parts;        /* Maximum number of tile-part                                       */
-  info_tile_t *tile;             /* information concerning tiles inside image                         */
-} info_image_t; /* index struct */
-
-
-#endif
diff --git a/applications/jpip/tools/indexer/j2k_decoder.c b/applications/jpip/tools/indexer/j2k_decoder.c
new file mode 100644
index 00000000..6e625035
--- /dev/null
+++ b/applications/jpip/tools/indexer/j2k_decoder.c
@@ -0,0 +1,157 @@
+/*
+ * $Id$
+ *
+ * Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2011, Professor Benoit Macq
+ * Copyright (c) 2010-2011, Kaori Hagihara
+ * 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 "j2k_to_idxjp2.h"
+#include "event_mgr_handler.h"
+#include "cio.h"
+#include "j2k.h"
+
+/* 
+ * Decode and Add main header marker information 
+ *
+ * @param[in]     cio       file input handle
+ * @param[in,out] cstr_info codestream information
+ */
+void add_mainheader_marker_info( opj_cio_t *cio, opj_codestream_info_t *cstr_info);
+
+opj_image_t * decode_j2k( unsigned char *j2kstream, int j2klen, opj_codestream_info_t *cstr_info)
+{
+  opj_image_t *image;
+  opj_dparameters_t parameters;	/* decompression parameters */
+  opj_dinfo_t *dinfo;	/* handle to a decompressor */
+  opj_cio_t *cio;
+  opj_event_mgr_t event_mgr;		/* event manager */
+
+  /* set decoding parameters to default values */
+  opj_set_default_decoder_parameters(&parameters);
+
+  /* decode the code-stream */
+  /* ---------------------- */
+
+  /* JPEG-2000 codestream */
+  /* get a decoder handle */
+  dinfo = opj_create_decompress( CODEC_J2K);
+
+  event_mgr = set_default_event_mgr();
+
+  /* catch events using our callbacks and give a local context */
+  opj_set_event_mgr((opj_common_ptr)dinfo, &event_mgr, stderr);
+
+  /* setup the decoder decoding parameters using user parameters */
+  opj_setup_decoder(dinfo, &parameters);
+
+  /* open a byte stream */
+  cio = opj_cio_open((opj_common_ptr)dinfo, j2kstream, j2klen);
+  
+  /* decode the stream and fill the image structure */
+  image = opj_decode_with_info(dinfo, cio, cstr_info);
+  if(!image) {
+    fprintf(stderr, "ERROR -> jp2_to_image: failed to decode image!\n");
+    opj_destroy_decompress(dinfo);
+    opj_cio_close(cio);
+    return NULL;
+  }
+
+  if( cstr_info->marknum == 0)
+    add_mainheader_marker_info( cio, cstr_info);
+  
+  /* close the byte stream */
+  opj_cio_close(cio);
+ 
+  /* free remaining structures */
+  if(dinfo) {
+    opj_destroy_decompress(dinfo);
+  }
+
+  return image;
+}
+
+
+/* 
+ * Get main headr marker size
+ *
+ * @param[in] type      marker type
+ * @param[in] cstr_info codestream information
+ * @param[in] cio       file input handle
+ * @return              marker size
+ */
+unsigned short get_mh_markersize( unsigned short type, opj_codestream_info_t cstr_info, opj_cio_t *cio);
+
+void add_mainheader_marker_info( opj_cio_t *cio, opj_codestream_info_t *cstr_info)
+{
+  opj_marker_info_t marker;
+  int pos;
+
+  cstr_info->marker = (opj_marker_info_t *)malloc( 100*sizeof(opj_marker_info_t)); // max 100
+  
+  pos = cstr_info->main_head_start;
+  cio_seek( cio, pos);
+  
+  while( pos <= cstr_info->main_head_end){
+    marker.type = cio_read( cio, 2);
+    marker.pos  = cio_tell( cio);
+    marker.len  = get_mh_markersize( marker.type, *cstr_info, cio);
+    cio_skip( cio, marker.len);
+    
+    cstr_info->marker[ cstr_info->marknum] = marker;
+
+    cstr_info->marknum++;
+    pos = cio_tell( cio);
+  }
+}
+
+unsigned short get_mh_markersize( unsigned short type, opj_codestream_info_t cstr_info, opj_cio_t *cio)
+{
+  unsigned short siz;
+  int pos;
+  
+  siz = 0;
+
+  switch( type){
+  case J2K_MS_SOC:
+    siz = 0;
+    break;
+  case J2K_MS_SIZ:
+    siz = 38+3*cstr_info.numcomps;
+    break;
+  case J2K_MS_COD:
+  case J2K_MS_QCD:
+  case J2K_MS_COM:
+    pos = cio_tell( cio);
+    siz = cio_read( cio, 2);
+    cio_seek( cio, pos);
+    break;
+  default:
+    fprintf( stderr, "marker %x length not defined yet!\n", type);
+  }
+  return siz;
+}
diff --git a/applications/jpip/tools/indexer/j2k_to_idxjp2.c b/applications/jpip/tools/indexer/j2k_to_idxjp2.c
new file mode 100644
index 00000000..82394010
--- /dev/null
+++ b/applications/jpip/tools/indexer/j2k_to_idxjp2.c
@@ -0,0 +1,108 @@
+/*
+ * $Id$
+ *
+ * Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2011, Professor Benoit Macq
+ * Copyright (c) 2010-2011, Kaori Hagihara
+ * 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.
+ */
+
+/*! \file
+ *  \brief j2k_to_idxjp2 is a program to make jp2 file with index box from j2k file
+ *
+ *  \section impinst Implementing instructions
+ *  This program takes two arguments. \n
+ *   -# Input  J2K image file\n
+ *   -# Output JP2 file name\n
+ *   % ./j2k_to_idxjp2 image.j2k image.jp2\n
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "openjpeg.h"
+#include "j2k_to_idxjp2.h"
+
+
+/* 
+ * Read a binary file
+ *
+ * @param[in]  filename  file name
+ * @param[out] lenoffile pointer to feed file length
+ * @return               byte code
+ */
+unsigned char * read_binaryfile( char filename[], int *lenoffile);
+
+int main(int argc, char **argv)
+{ 
+  opj_image_t *image = NULL;
+  opj_codestream_info_t cstr_info;  /* Codestream information structure */
+  unsigned char *j2kstream;
+  int j2klen;
+
+  if (argc < 3){
+    fprintf(stderr,"\nERROR in entry : j2k_to_idxjp2 J2K-file JP2-file\n");
+    return 1;
+  }
+
+  j2kstream = read_binaryfile( argv[1], &j2klen);
+
+  image = decode_j2k( j2kstream, j2klen, &cstr_info);
+  if( !image){
+    free(j2kstream);
+    return -1;
+  }
+  
+  fwrite_idxjp2( argv[2], j2kstream, j2klen, image, cstr_info);
+  
+  free(j2kstream);
+  
+  /* free image data structure */
+  opj_image_destroy(image);
+  
+  return 0;
+}
+
+unsigned char * read_binaryfile( char filename[], int *lenoffile)
+{
+  FILE *fp;
+  unsigned char *bytecode;
+
+  fp = fopen( filename, "rb");
+  if (!fp) {
+    fprintf(stderr, "Failed to open %s for reading !!\n", filename);
+    exit (-1);
+  }
+
+  /* length of the codestream */
+  fseek( fp, 0, SEEK_END);
+  *lenoffile = ftell(fp);
+  fseek( fp, 0, SEEK_SET);
+  
+  bytecode = (unsigned char*)malloc(*lenoffile);
+  fread( bytecode, *lenoffile, 1, fp);
+  fclose(fp);
+
+  return bytecode;
+}
diff --git a/applications/jpip/tools/indexer/bio.h b/applications/jpip/tools/indexer/j2k_to_idxjp2.h
similarity index 56%
rename from applications/jpip/tools/indexer/bio.h
rename to applications/jpip/tools/indexer/j2k_to_idxjp2.h
index eea6cff0..45a4a432 100644
--- a/applications/jpip/tools/indexer/bio.h
+++ b/applications/jpip/tools/indexer/j2k_to_idxjp2.h
@@ -1,7 +1,9 @@
 /*
- * Copyright (c) 2001-2002, David Janssens
- * Copyright (c) 2003-2004, Yannick Verschueren
- * Copyright (c) 2003-2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * $Id$
+ *
+ * Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2011, Professor Benoit Macq
+ * Copyright (c) 2010-2011, Kaori Hagihara
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -26,13 +28,31 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef __BIO_H
-#define __BIO_H
+#ifndef  J2K_TO_IDXJP2_H_
+# define J2K_TO_IDXJP2_H_
 
-int bio_numbytes();
-void bio_init_dec(unsigned char *bp, int len);
-int bio_read(int n);
-int bio_flush();
-int bio_inalign();
+#include "openjpeg.h"
 
-#endif
+/* 
+ * Decode j2k codestream
+ *
+ * @param[in]  j2kstream j2k codestream
+ * @param[in]  j2klen    length of j2k codestream
+ * @param[out] cstr_info codestream information
+ * @return               image data
+ */
+opj_image_t * decode_j2k( unsigned char *j2kstream, int j2klen, opj_codestream_info_t *cstr_info);
+
+
+/* 
+ * Write a JP2 file with index box
+ *
+ * @param[in] filename  file name
+ * @param[in] j2kstream j2k codestream
+ * @param[in] j2klen    length of j2k codestream
+ * @param[in] image     image data
+ * @param[in] cstr_info codestream information
+ */
+void fwrite_idxjp2( char filename[], unsigned char *j2kstream, int j2klen, opj_image_t *image, opj_codestream_info_t cstr_info);
+
+#endif      /* !J2K_TO_IDXJP2S_H_ */
diff --git a/applications/jpip/tools/indexer/jp2.c b/applications/jpip/tools/indexer/jp2.c
deleted file mode 100644
index 1c193ad7..00000000
--- a/applications/jpip/tools/indexer/jp2.c
+++ /dev/null
@@ -1,301 +0,0 @@
-/*
- * Copyright (c) 2003-2004, Yannick Verschueren
- * Copyright (c) 2003-2004,  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 "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);
-}
-
-/*
- * Write the JP2H box
- *
- * JP2 Header box
- *
- */
-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);
-}
-
-/*
- * Write the FTYP box
- *
- * File type box
- *
- */
-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);
-}
-
-/*
- * Read the FTYP box
- *
- * File type box
- *
- */
-void jp2_read_ftyp(int length)
-{
-  int BR, MinV, type, i;
-
-  BR = cio_read(4);         /* BR              */
-  MinV = cio_read(4);       /* MinV            */
-  length-=8;
-  
-  for (i=length/4;i>0;i--)
-    type = cio_read(4);     /* CLi : JP2, JPIP */
-}
-
-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);
-}
-
-/*
- * Read the JP box
- *
- * JPEG 2000 signature
- *
- * return 1 if error else 0
- */
-int jp2_read_jp()
-{
-  if (0x0d0a870a!=cio_read(4))
-    return 1;
-  else
-    return 0;
-}
diff --git a/applications/jpip/tools/indexer/jpip.c b/applications/jpip/tools/indexer/jpip.c
deleted file mode 100644
index 2e3ef91b..00000000
--- a/applications/jpip/tools/indexer/jpip.c
+++ /dev/null
@@ -1,778 +0,0 @@
-/*
- * Copyright (c) 2003-2004, Yannick Verschueren
- * Copyright (c) 2003-2004, 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   /* Codestream index                */
-#define JPIP_CPTR 0x63707472   /* Codestream Finder Box           */
-#define JPIP_MANF 0x6d616e66   /* Manifest Box                    */
-#define JPIP_FAIX 0x66616978   /* Fragment array Index box        */
-#define JPIP_MHIX 0x6d686978   /* Main Header Index Table         */
-#define JPIP_TPIX 0x74706978   /* Tile-part Index Table box       */
-#define JPIP_THIX 0x74686978   /* Tile header Index Table box     */
-#define JPIP_PPIX 0x70706978   /* Precinct Packet Index Table box */
-#define JPIP_PHIX 0x70686978   /* Packet Header index Table       */
-#define JPIP_FIDX 0x66696478   /* File Index                      */
-#define JPIP_FPTR 0x66707472   /* File Finder                     */
-#define JPIP_PRXY 0x70727879   /* Proxy boxes                     */
-#define JPIP_IPTR 0x69707472   /* Index finder box                */
-#define JPIP_PHLD 0x70686c64   /* Place holder                    */
-
-#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;
-
-/* 
- * Write the CPTR box
- *
- * Codestream finder box (box)
- *
- */
-void jpip_write_cptr(int offset, info_image_t img)
-{
-  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);
-}
-
-/* 
- * Read the CPTR box
- *
- * Codestream finder box (box)
- *
- */
-void jpip_read_cptr()
-{
-  int DR, CONT;
-  long long Coff, codestream_size;
-
-  DR = cio_read(2);               /* DR   */
-  CONT = cio_read(2);             /* CONT */
-  Coff = cio_read(8);             /* COFF */
-  codestream_size = cio_read(8);  /* CLEN */
-}
-
-/* 
- * Write the MANF box
- *
- * Manifest box (box)
- *
- */
-void jpip_write_manf(int second, int v, info_marker_t *marker)
-{
-  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);  /* Marker length                     */ 
-	  cio_write(marker[i].type,4); /* Marker type                       */
-	}
-    }
-
-  len=cio_tell()-lenp;
-  cio_seek(lenp);
-  cio_write(len, 4);                   /* L                                 */
-  cio_seek(lenp+len);
-}
-
-/* 
- * Read the MANF box
- *
- * Manifest box (box)
- *
- */
-void jpip_read_manf(int len)
-{
-  int i, v, marker_len, marker_type;
-  
-  v = (len - 8)/ 8;
-  
-  for(i=0;i<v;i++)
-    {
-      marker_len = cio_read(4);       /* Marker length */ 
-      marker_type = cio_read(4);      /* Marker type   */
-    }
-}
-
-/* 
- * Write the MHIX box
- *
- * Main Header Index Table (box)
- *
- */
-int jpip_write_mhix(info_image_t img, int status, int tileno)
-{
-  int len, lenp, i;
-  info_tile_t *tile;
-  lenp=cio_tell();
-  cio_skip(4);                               /* L [at the end]                    */
-  cio_write(JPIP_MHIX, 4);                   /* MHIX                              */
-
-  if (status==0) /* MAIN HEADER */
-    {
-      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_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_PPM - 1; i >= 0; i--) /* PPM */
-	{
-	  cio_write(img.marker_mul.PPM[i].type, 2);
-	  cio_write(i, 2);
-	  cio_write(img.marker_mul.PPM[i].start_pos, 8);
-	  cio_write(img.marker_mul.PPM[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);
-	}
-    } 
-  else /* TILE HEADER */
-    {
-      tile = &img.tile[tileno];
-      cio_write(tile->tile_parts[0].length_header, 8);  /* TLEN                              */ 
-      
-      for(i = 0; i < tile->num_marker; i++)             /* Marker restricted to 1 apparition */
-	{
-	  cio_write(tile->marker[i].type, 2);
-	  cio_write(0, 2);
-	  cio_write(tile->marker[i].start_pos, 8);
-	  cio_write(tile->marker[i].len, 2);
-	}
-      
-      /* Marker NOT restricted to 1 apparition */
-      for(i = tile->marker_mul.num_COC - 1; i >= 0; i--) /* COC */
-	{
-	  cio_write(tile->marker_mul.COC[i].type, 2);
-	  cio_write(i, 2);
-	  cio_write(tile->marker_mul.COC[i].start_pos, 8);
-	  cio_write(tile->marker_mul.COC[i].len, 2);
-	}
-      
-      for(i = tile->marker_mul.num_RGN - 1; i >= 0; i--) /* RGN */
-	{
-	  cio_write(tile->marker_mul.RGN[i].type, 2);
-	  cio_write(i, 2);
-	  cio_write(tile->marker_mul.RGN[i].start_pos, 8);
-	  cio_write(tile->marker_mul.RGN[i].len, 2);
-	}
-      
-      for(i = tile->marker_mul.num_QCC - 1; i >= 0; i--) /* QCC */
-	{
-	  cio_write(tile->marker_mul.QCC[i].type, 2);
-	  cio_write(i, 2);
-	  cio_write(tile->marker_mul.QCC[i].start_pos, 8);
-	  cio_write(tile->marker_mul.QCC[i].len, 2);
-	}
-      
-      for(i = tile->marker_mul.num_PLT - 1; i >= 0; i--) /* PLT */
-	{
-	  cio_write(tile->marker_mul.PLT[i].type,2);
-	  cio_write(i,2);
-	  cio_write(tile->marker_mul.PLT[i].start_pos,8);
-	  cio_write(tile->marker_mul.PLT[i].len,2);
-	}
-      
-      for(i = tile->marker_mul.num_PPT - 1; i >= 0; i--) /* PPT */
-	{
-	  cio_write(tile->marker_mul.PPT[i].type, 2);
-	  cio_write(i, 2);
-	  cio_write(tile->marker_mul.PPT[i].start_pos, 8);
-	  cio_write(tile->marker_mul.PPT[i].len, 2);
-	}
-      
-      for(i = tile->marker_mul.num_COM - 1; i >= 0; i--) /* COM */
-	{
-	  cio_write(tile->marker_mul.COM[i].type, 2);
-	  cio_write(i, 2);
-	  cio_write(tile->marker_mul.COM[i].start_pos, 8);
-	  cio_write(tile->marker_mul.COM[i].len, 2);
-	} 
-    }      
-  
-  len=cio_tell()-lenp;
-  cio_seek(lenp);
-  cio_write(len, 4);        /* L           */
-  cio_seek(lenp+len);
-  
-  return len;
-}
-
-/* 
- * Read the MHIX box
- *
- * Main Header Index Table (box)
- *
- */
-void jpip_read_mhix(int len)
-{
-  int i, v, marker_type, marker_start_pos, marker_len, marker_remains;
-
-  v = (len - 8) / 14;
-
-  for (i=0; i<v ; i++)
-    {
-      marker_type = cio_read(2);       /* Type of the marker               */ 
-      marker_remains = cio_read(2);    /* Number of same markers following */
-      marker_start_pos = cio_read(2);  /* Start position of the marker     */
-      marker_len = cio_read(2);        /* Length of the marker             */
-    }
-}
-
-/* 
- * Write the FAIX box
- *
- * Fragment array Index box (box)
- *
- */
-int jpip_write_faix(int v, int compno, info_image_t img, j2k_cp_t *j2k_cp, int version)
-{
-  int len, lenp, i, j;
-  int Aux;
-  int tileno, resno, precno, layno, num_packet=0;
-
-  lenp=cio_tell();
-  cio_skip(4);              /* L [at the end]      */
-  cio_write(JPIP_FAIX, 4);  /* FAIX                */ 
-  cio_write(version,1);     /* Version 0 = 4 bytes */
-  
-  switch(v)
-    {
-    case 0:   /* TPIX */
-      cio_write(img.num_max_tile_parts,(version & 0x01)?8:4);                      /* NMAX           */
-      cio_write(img.tw*img.th,(version & 0x01)?8:4);                               /* M              */
-      for (i = 0; i < img.tw*img.th; i++)
-	{
-	  for (j = 0; j < img.tile[i].numparts ; j++)
-	    {
-	      cio_write(img.tile[i].tile_parts[j].start_pos,(version & 0x01)?8:4); /* start position */
-	      cio_write(img.tile[i].tile_parts[j].length,(version & 0x01)?8:4);    /* length         */
-	      if (version & 0x02)
-		{
-		  if (img.tile[i].numparts == 1 && img.Decomposition > 1)
-		    Aux = img.Decomposition + 1;
-		  else
-		    Aux = j + 1;
-		  
-		  cio_write(Aux,4);
-		  //cio_write(img.tile[i].tile_parts[j].num_reso_AUX,4); /* Aux_i,j : Auxiliary value */
-		  // fprintf(stderr,"AUX value %d\n",Aux);
-		}
-		  //cio_write(0,4);
-	    }
-	  /* PADDING */
-	  while (j < img.num_max_tile_parts)
-	    {
-	      cio_write(0,(version & 0x01)?8:4); /* start position            */
-	      cio_write(0,(version & 0x01)?8:4); /* length                    */
-	      if (version & 0x02)
-		cio_write(0,4);                  /* Aux_i,j : Auxiliary value */
-	      j++;
-	    }
-	}
-      break;
-      
-      /*   case 1: */   /* THIX */
-      /* cio_write(1,(version & 0x01)?8:4);  */           /* NMAX */
-      /* cio_write(img.tw*img.th,(version & 0x01)?8:4); */ /* M    */
-      /* for (i=0;i<img.tw*img.th;i++) */
-      /* { */
-      /* cio_write(img.tile[i].start_pos,(version & 0x01)?8:4); */                         /* start position */
-      /* cio_write(img.tile[i].end_header-img.tile[i].start_pos,(version & 0x01)?8:4); */  /* length         */
-      /* if (version & 0x02)*/
-      /* cio_write(0,4); */ /* Aux_i,j : Auxiliary value */
-      /* } */
-      /* break; */
-
-    case 2:  /* PPIX  NOT FINISHED !! */
-      cio_write(img.num_packet_max,(version & 0x01)?8:4); /* NMAX */
-      cio_write(img.tw*img.th,(version & 0x01)?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;
-	  
-	  num_packet=0;
-	  
-	  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 & 0x01)?8:4);                                   /* start position */
-		      cio_write((layer_Idx->len_header-correction)?0:layer_Idx->len,(version & 0x01)?8:4); /* length         */
-		      if (version & 0x02)
-			cio_write(0,4); /* Aux_i,j : Auxiliary value */
-		      num_packet++;
-		    }
-		}
-	    }
-	  /* PADDING */
-	  while (num_packet < img.num_packet_max)
-	    {
-	      cio_write(0,(version & 0x01)?8:4); /* start position            */
-	      cio_write(0,(version & 0x01)?8:4); /* length                    */
-	      if (version & 0x02)
-		cio_write(0,4);                  /* Aux_i,j : Auxiliary value */
-	      num_packet++;
-	    }
-	}
-      
-      break;
-      
-    case 3:  /* PHIX NOT FINISHED !! */
-      cio_write(img.num_packet_max,(version & 0x01)?8:4); /* NMAX */
-      cio_write(img.tw*img.th,(version & 0x01)?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;
-
-	  num_packet = 0;
-	  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_header,(version & 0x01)?8:4);                                   /* start position */
-		      cio_write((layer_Idx->len_header-correction)?0:layer_Idx->len_header,(version & 0x01)?8:4); /* length         */
-		      if (version & 0x02)
-			cio_write(0,4); /* Aux_i,j : Auxiliary value */
-		      num_packet++;
-		    }
-		}
-	    }
-	  /* PADDING */
-	  while (num_packet<img.num_packet_max)
-	    {
-	      cio_write(0,(version & 0x01)?8:4); /* start position            */
-	      cio_write(0,(version & 0x01)?8:4); /* length                    */
-	      if (version & 0x02)
-		cio_write(0,4);                  /* Aux_i,j : Auxiliary value */
-	      num_packet++;
-	    }
-	}
-      break;
-    }
-  
-  len=cio_tell()-lenp;
-  cio_seek(lenp);
-  cio_write(len, 4);        /* L  */
-  cio_seek(lenp+len);
-
-  return len;
-}
-
-/* 
- * Write the TPIX box
- *
- * Tile-part Index table box (superbox)
- *
- */
-int jpip_write_tpix(info_image_t img, j2k_cp_t *j2k_cp, int version)
-{
-  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, version);
-
-  len=cio_tell()-lenp;
-  cio_seek(lenp);
-  cio_write(len, 4);        /* L              */
-  cio_seek(lenp+len);
-
-  return len;
-}
-
-/* 
- * Write the THIX box
- *
- * Tile header Index table box (superbox)
- *
- */
-//int jpip_write_thix(info_image_t img, j2k_cp_t *j2k_cp)
-//  {
-//  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_thix(info_image_t img, j2k_cp_t *j2k_cp)
-{
-  int len, lenp, i;
-  int tileno;
-  info_marker_t *marker;
-  int num_marker_local_jpip;
-
-  marker = (info_marker_t*)calloc(sizeof(info_marker_t), j2k_cp->tw*j2k_cp->th);
-
-  for ( i = 0; i < 2 ; i++ )
-    {
-      if (i) cio_seek(lenp);
-      
-      lenp = cio_tell();
-      cio_skip(4);              /* L [at the end] */
-      cio_write(JPIP_THIX, 4);  /* THIX           */
-      jpip_write_manf(i, j2k_cp->tw*j2k_cp->th, marker);
-      num_marker_local_jpip=img.Comp;
-      
-      for (tileno = 0; tileno < j2k_cp->tw*j2k_cp->th; tileno++)
-	{
-	  marker[tileno].len = jpip_write_mhix(img, 1, tileno);
-	  marker[tileno].type = JPIP_MHIX;
-	}
-      
-      len=cio_tell()-lenp;
-      cio_seek(lenp);
-      cio_write(len, 4);        /* L              */
-      cio_seek(lenp+len);
-    }
-
-  free(marker);
-
-  return len;
-}
-/* 
- * Write the PPIX box
- *
- * Precinct Packet Index table box (superbox)
- *
- */
-int jpip_write_ppix(info_image_t img,j2k_cp_t *j2k_cp)
-{
-  int len, lenp, compno, i;
-  info_marker_t *marker;
-  int num_marker_local_jpip;
-  marker = (info_marker_t*)calloc(sizeof(info_marker_t), img.Comp);
-  
-  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);
-      num_marker_local_jpip=img.Comp;
-      
-      for (compno=0; compno<img.Comp; compno++)
-	{
-	  marker[compno].len=jpip_write_faix(2,compno,img, j2k_cp, 0);
-	  marker[compno].type=JPIP_FAIX;
-	}
-   
-      len=cio_tell()-lenp;
-      cio_seek(lenp);
-      cio_write(len, 4);        /* L              */
-      cio_seek(lenp+len);
-    }
-  
-  free(marker);
-
-  return len;
-}
-
-/* 
- * Write the PHIX box
- *
- * Packet Header Index table box (superbox)
- *
- */
-int jpip_write_phix(info_image_t img, j2k_cp_t *j2k_cp)
-{
-  int len, lenp=0, compno, i;
-  info_marker_t *marker;
-
-  marker = (info_marker_t*)calloc(sizeof(info_marker_t), img.Comp);
-
-  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);
-
-      for (compno=0; compno<img.Comp; compno++)
-	{	
-	  marker[compno].len=jpip_write_faix(3,compno,img, j2k_cp, 0);
-	  marker[compno].type=JPIP_FAIX;
-	}
-
-      len=cio_tell()-lenp;
-      cio_seek(lenp);
-      cio_write(len, 4);        /* L              */
-      cio_seek(lenp+len);
-    }
-
-  free(marker);
-
-  return len;
-}
-
-/* 
- * Write the CIDX box
- *
- * Codestream Index box (superbox)
- *
- */
-int jpip_write_cidx(int offset, info_image_t img, j2k_cp_t *j2k_cp, int version)
-{
-  int len, lenp = 0, i;
-  info_marker_t *marker_jpip;
-  int num_marker_jpip = 0;
-
-  marker_jpip = (info_marker_t*)calloc(sizeof(info_marker_t), 32);
-
-  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);
-
-      num_marker_jpip=0;
-      marker_jpip[num_marker_jpip].len=jpip_write_mhix(img, 0, 0);
-      marker_jpip[num_marker_jpip].type=JPIP_MHIX;
-      num_marker_jpip++;
-
-      marker_jpip[num_marker_jpip].len=jpip_write_tpix(img, j2k_cp, version);
-      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);
-    }
-
-  free(marker_jpip);
-
-  return len;
-
-}
-
-/* 
- * Write the IPTR box
- *
- * Index Finder box
- *
- */
-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);
-}
-
-/* 
- * Write the PRXY box
- *
- * proxy (box)
- *
- */
-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);
-}
-
-
-/* 
- * Write the FIDX box
- *
- * File Index (superbox)
- *
- */
-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;
-}
diff --git a/applications/jpip/tools/indexer/phix_manager.c b/applications/jpip/tools/indexer/phix_manager.c
new file mode 100644
index 00000000..da7a6ae0
--- /dev/null
+++ b/applications/jpip/tools/indexer/phix_manager.c
@@ -0,0 +1,142 @@
+/*
+ * $Id$
+ *
+ * Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2011, Professor Benoit Macq
+ * Copyright (c) 2003-2004, Yannick Verschueren
+ * Copyright (c) 2010-2011, Kaori Hagihara
+ * 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.
+ */
+
+/*! \file
+ *  \brief Modification of jpip.c from 2KAN indexer
+ */
+
+#include <stdlib.h>
+#include <math.h>
+#include "indexbox_manager.h"
+#include "cio_ext.h"
+#include "cio.h"
+
+/* 
+ * Write faix box of phix
+ *
+ * @param[in] compno    component number
+ * @param[in] cstr_info codestream information
+ * @param[in] EPHused   true if if EPH option used
+ * @param[in] j2klen    length of j2k codestream
+ * @param[in] cio       file output handle
+ * @return              length of faix box
+ */
+int write_phixfaix( int compno, opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_cio_t *cio);
+
+int write_phix( opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_cio_t *cio)
+{
+  int len, lenp=0, compno, i;
+  opj_jp2_box_t *box;
+
+  box = (opj_jp2_box_t *)calloc( cstr_info.numcomps, sizeof(opj_jp2_box_t));
+  
+  for( i=0;i<2;i++){
+    if (i) cio_seek( cio, lenp);
+      
+    lenp = cio_tell( cio);
+    cio_skip( cio, 4);              /* L [at the end] */
+    cio_write( cio, JPIP_PHIX, 4);  /* PHIX           */
+      
+    write_manf( i, cstr_info.numcomps, box, cio);
+
+    for( compno=0; compno<cstr_info.numcomps; compno++){       
+      box[compno].length = write_phixfaix( compno, cstr_info, EPHused, j2klen, cio);
+      box[compno].type = JPIP_FAIX;
+    }
+
+    len = cio_tell( cio)-lenp;
+    cio_seek( cio, lenp);
+    cio_write( cio, len, 4);        /* L              */
+    cio_seek( cio, lenp+len);
+  }
+
+  free(box);
+
+  return len;
+}
+
+int write_phixfaix( int compno, opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_cio_t *cio)
+{
+  int len, lenp;
+  int size_of_coding; // 4 or 8
+  int version;
+  int tileno, resno, precno, layno, num_packet=0;
+    
+  if( j2klen > pow( 2, 32)){
+    size_of_coding =  8;
+    version = 1;
+  }
+  else{
+    size_of_coding = 4;
+    version = 0;
+  }
+
+  lenp = cio_tell( cio);
+  cio_skip( cio, 4);              /* L [at the end]      */
+  cio_write( cio, JPIP_FAIX, 4);  /* FAIX                */ 
+  cio_write( cio, version,1);     /* Version 0 = 4 bytes */
+  
+  cio_ext_write( cio, cstr_info.packno, size_of_coding); /* NMAX */
+  cio_ext_write( cio, cstr_info.tw*cstr_info.th, size_of_coding);      /* M    */
+  
+  for( tileno=0; tileno<cstr_info.tw*cstr_info.th; tileno++){
+    
+    opj_tile_info_t *tile_Idx = &cstr_info.tile[ tileno];
+    //    int correction = EPHused ? 3 : 1;
+    num_packet = 0;
+
+    for( resno=0; resno<cstr_info.numdecompos[compno]+1; resno++){
+      for( precno=0; precno<tile_Idx->pw[resno]*tile_Idx->ph[resno]; precno++){
+	for( layno=0; layno<cstr_info.numlayers; layno++){	  
+	  opj_packet_info_t packet = tile_Idx->packet[num_packet];
+	  cio_ext_write( cio, packet.start_pos, size_of_coding);                                   /* start position */
+	  cio_ext_write( cio, packet.end_ph_pos-packet.start_pos+1, size_of_coding); /* length         */
+	  
+	  num_packet++;
+	}
+      }
+    }
+
+    /* PADDING */
+    while( num_packet < cstr_info.packno){
+      cio_ext_write( cio, 0, size_of_coding); /* start position            */
+      cio_ext_write( cio, 0, size_of_coding); /* length                    */
+      num_packet++;
+    }
+  }
+
+  len = cio_tell( cio)-lenp;
+  cio_seek( cio, lenp);
+  cio_write( cio, len, 4);        /* L  */
+  cio_seek( cio, lenp+len);
+
+  return len;
+}
diff --git a/applications/jpip/tools/indexer/pi.c b/applications/jpip/tools/indexer/pi.c
deleted file mode 100644
index 691ef497..00000000
--- a/applications/jpip/tools/indexer/pi.c
+++ /dev/null
@@ -1,465 +0,0 @@
-/*
- * Copyright (c) 2001-2002, David Janssens
- * Copyright (c) 2003-2004, Yannick Verschueren
- * Copyright (c) 2003-2004, 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;
-	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;
-			}
-		}
-		
-		tccp = &tcp->tccps[0];
-		pi[pino].step_p=1;
-		pi[pino].step_c=100*pi[pino].step_p;
-		pi[pino].step_r=img->numcomps*pi[pino].step_c;
-		pi[pino].step_l=maxres*pi[pino].step_r;
-		
-		if (pino==0)
-		  pi[pino].include=(short int*)calloc(img->numcomps*maxres*tcp->numlayers*100,sizeof(short int));
-		else
-		  pi[pino].include=pi[pino-1].include;
-
-		/*if (pino == tcp->numpocs) {*/
-		  if (tcp->POC == 0) {
-			pi[pino].first = 1;
-			pi[pino].poc.resno0 = 0;
-			pi[pino].poc.compno0 = 0;
-			pi[pino].poc.layno1 = tcp->numlayers;
-			pi[pino].poc.resno1 = maxres;
-			pi[pino].poc.compno1 = 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->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p]){
-				    pi->include[pi->layno * pi->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p] = 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->step_l+pi->resno*pi->step_r+pi->compno*pi->step_c+pi->precno*pi->step_p]){
-				    pi->include[pi->layno*pi->step_l+pi->resno*pi->step_r+pi->compno*pi->step_c+pi->precno*pi->step_p] = 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->step_l+pi->resno*pi->step_r+pi->compno*pi->step_c+pi->precno*pi->step_p]){
-					    pi->include[pi->layno*pi->step_l+pi->resno*pi->step_r+pi->compno*pi->step_c+pi->precno*pi->step_p] = 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->step_l+pi->resno*pi->step_r+pi->compno*pi->step_c+pi->precno*pi->step_p]){
-					    pi->include[pi->layno*pi->step_l+pi->resno*pi->step_r+pi->compno*pi->step_c+pi->precno*pi->step_p] = 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->step_l+pi->resno*pi->step_r+pi->compno*pi->step_c+pi->precno*pi->step_p]){
-					    pi->include[pi->layno*pi->step_l+pi->resno*pi->step_r+pi->compno*pi->step_c+pi->precno*pi->step_p] = 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;
-}
diff --git a/applications/jpip/tools/indexer/pi.h b/applications/jpip/tools/indexer/pi.h
deleted file mode 100644
index b300b9e3..00000000
--- a/applications/jpip/tools/indexer/pi.h
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * Copyright (c) 2001-2002, David Janssens
- * 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 {
-	short int *include;
-  int step_l, step_r, step_c, step_p; 
-	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
diff --git a/applications/jpip/tools/indexer/ppix_manager.c b/applications/jpip/tools/indexer/ppix_manager.c
new file mode 100644
index 00000000..4fd45f8f
--- /dev/null
+++ b/applications/jpip/tools/indexer/ppix_manager.c
@@ -0,0 +1,147 @@
+/*
+ * $Id$
+ *
+ * Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2011, Professor Benoit Macq
+ * Copyright (c) 2003-2004, Yannick Verschueren
+ * Copyright (c) 2010-2011, Kaori Hagihara
+ * 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.
+ */
+
+/*! \file
+ *  \brief Modification of jpip.c from 2KAN indexer
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include "indexbox_manager.h"
+#include "cio_ext.h"
+#include "cio.h"
+
+/* 
+ * Write faix box of ppix
+ *
+ * @param[in] compno    component number
+ * @param[in] cstr_info codestream information
+ * @param[in] EPHused   true if if EPH option used
+ * @param[in] j2klen    length of j2k codestream
+ * @param[in] cio       file output handle
+ * @return              length of faix box
+ */
+int write_ppixfaix( int compno, opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_cio_t *cio);
+
+int write_ppix( opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_cio_t *cio)
+{
+  int len, lenp, compno, i;
+  opj_jp2_box_t *box;
+
+  printf("cstr_info.packno %d\n", cstr_info.packno); //NMAX?
+
+  box = (opj_jp2_box_t *)calloc( cstr_info.numcomps, sizeof(opj_jp2_box_t));
+  
+  for (i=0;i<2;i++){
+    if (i) cio_seek( cio, lenp);
+    
+    lenp = cio_tell( cio);
+    cio_skip( cio, 4);              /* L [at the end] */
+    cio_write( cio, JPIP_PPIX, 4);  /* PPIX           */
+
+    write_manf( i, cstr_info.numcomps, box, cio);
+    
+    for (compno=0; compno<cstr_info.numcomps; compno++){
+      box[compno].length = write_ppixfaix( compno, cstr_info, EPHused, j2klen, cio);
+      box[compno].type = JPIP_FAIX;
+    }
+   
+    len = cio_tell( cio)-lenp;
+    cio_seek( cio, lenp);
+    cio_write( cio, len, 4);        /* L              */
+    cio_seek( cio, lenp+len);
+  }
+  
+  free(box);
+
+  return len;
+}
+
+// NMAX might be wrong , phix too, do sth to correction
+int write_ppixfaix( int compno, opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_cio_t *cio)
+{
+  int len, lenp;
+  int tileno, resno, precno, layno, num_packet=0;
+  int size_of_coding; // 4 or 8
+  int version;
+
+  if( j2klen > pow( 2, 32)){
+    size_of_coding =  8;
+    version = 1;
+  }
+  else{
+    size_of_coding = 4;
+    version = 0;
+  }
+  
+  lenp = cio_tell( cio);
+  cio_skip( cio, 4);              /* L [at the end]      */
+  cio_write( cio, JPIP_FAIX, 4);  /* FAIX                */ 
+  cio_write( cio, version, 1);     /* Version 0 = 4 bytes */
+
+  cio_ext_write( cio, cstr_info.packno, size_of_coding); /* NMAX */
+  cio_ext_write( cio, cstr_info.tw*cstr_info.th, size_of_coding);      /* M    */
+
+  for( tileno=0; tileno<cstr_info.tw*cstr_info.th; tileno++){
+    
+    opj_tile_info_t *tile_Idx = &cstr_info.tile[ tileno];
+    //    int correction = EPHused ? 3 : 1;
+    num_packet=0;
+        
+    for( resno=0; resno< cstr_info.numdecompos[compno]+1; resno++){
+      for( precno=0; precno<tile_Idx->pw[resno]*tile_Idx->ph[resno]; precno++){
+	for( layno=0; layno<cstr_info.numlayers; layno++){
+	  opj_packet_info_t packet = tile_Idx->packet[num_packet];
+	  cio_ext_write( cio, packet.start_pos, size_of_coding);                                   /* start position */
+	  cio_ext_write( cio, packet.end_pos-packet.start_pos+1, size_of_coding); /* length         */
+	  
+	  num_packet++;
+	}
+      }
+    }
+    
+    /* PADDING */
+    while( num_packet < cstr_info.packno){
+      cio_ext_write( cio, 0, size_of_coding); /* start position            */
+      cio_ext_write( cio, 0, size_of_coding); /* length                    */
+      num_packet++;
+    }
+  }
+
+  len = cio_tell( cio)-lenp;
+  cio_seek( cio, lenp);
+  cio_write( cio, len, 4);        /* L  */
+  cio_seek( cio, lenp+len);
+
+  return len;
+
+}
diff --git a/applications/jpip/tools/indexer/t2.c b/applications/jpip/tools/indexer/t2.c
deleted file mode 100644
index 14a44bea..00000000
--- a/applications/jpip/tools/indexer/t2.c
+++ /dev/null
@@ -1,389 +0,0 @@
-/*
- * 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_cp_t * cp, 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;
-            }
-        }  
-    }
-    /* INDEX */
-    layer_Idx->len_header = 0;
-
-    /* When the marker PPT/PPM is used the packet header are store in PPT/PPM marker
-       This part deal with this caracteristic
-       step 1: Read packet header in the saved structure
-       step 2: (futher) return to codestream for decoding */
-    if (cp->ppm == 1) /* PPM */
-      {	    
-	c = cp->ppm_data;
-	d = c;
-	bio_init_dec(c, 1000);
-      } else 
-	{
-	  if (tcp->ppt == 1) /* PPT */
-	    {
-	      c = tcp->ppt_data;
-	      d = c;
-	      bio_init_dec(c, 1000);
-	    } else /* Normal Case */
-	      {
-		if (tcp->csty & J2K_CP_CSTY_SOP) 
-		  {
-		    if ((*c) != 255 || (*(c+1) != 145)) {printf("Error : expected SOP marker [1]!!!\n");}
-		    c += 6;
-		  }
-		bio_init_dec(c, src + len - c);
-		layer_Idx->len_header = -6;
-	      }
-	}
-    
-    present = bio_read(1);
-    
-    if (!present) 
-      {
-	bio_inalign();
-	/* Normal case */
-	c += bio_numbytes();
-	if (tcp->csty & J2K_CP_CSTY_EPH) 
-	  {
-	    if ((*c) != 255 || (*(c+1) != 146)) {printf("Error : expected EPH marker [1]!!!\n");}
-	    c += 2;
-	  }
-	/* INDEX */
-	layer_Idx->len_header += (c-d);
-
-	/* PPT and PPM dealing */
-	if (cp->ppm == 1) /* PPM */
-	  {	
-	    cp->ppm_data = c;	    
-	    return 0;
-	  }
-	if (tcp->ppt == 1) /* PPT */
-	  {
-	    tcp->ppt_data = c;
-	    return 0;
-	  }
-	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) { /* EPH marker */
-      if ((*c) != 255 || (*(c+1) != 146)) {printf("Error : expected EPH marker [2]!!!\n"); }
-      c += 2;
-    }
-    
-    /* INDEX */
-    layer_Idx->len_header += (c-d);
-
-    /* PPT Step 2 : see above for details */
-    if (cp->ppm == 1)
-      {
-	cp->ppm_data = c; /* Update pointer */
-
-	/* INDEX */
-	layer_Idx->len_header = c-d;
-
-	c = src;
-	d = c;
-	if (tcp->csty & J2K_CP_CSTY_SOP) 
-	  {
-	    if ((*c) != 255 || (*(c+1) != 145)) {printf("Error : expected SOP marker [2] !!!\n"); }
-	    c += 6;
-	  }
-	bio_init_dec(c, src + len - c);
-      } else 
-	{
-	  if (tcp->ppt == 1)
-	    { 
-	      tcp->ppt_data = c; /* Update pointer */
-	      /* INDEX */
-	      layer_Idx->len_header = c-d;
-
-	      c = src;
-	      d = c;
-	      if (tcp->csty & J2K_CP_CSTY_SOP) /* SOP marker */
-		{ 
-		  if ((*c) != 255 || (*(c+1) != 145)) {printf("Error : expected SOP marker [2] !!!\n"); }
-		  c += 6;
-		}
-	      bio_init_dec(c, src + len - c);
-	      
-	    }
-	}
-
-    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;
-}
-
-void t2_init_info_packets(info_image_t *img, j2k_cp_t *cp)
-{
-  int compno, tileno, resno, precno, layno;
-
-  for(compno = 0; compno < img->Comp; compno++)
-    {
-      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];
-	  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];
-		      layer_Idx->offset = 0;        /* start position */
-		      layer_Idx->len_header = 0;    /* length         */
-		    }
-		}
-	    }
-	}
-    }
-}
-
-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 partno;
-    info_tile_part_t *tile_part;
-    int position;
-    int length_read;
-    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;
-
-    t2_init_info_packets(imgg, cp); /* Initialize the packets information : LEN and OFFSET to 0 */
-
-    tile_Idx = &imgg->tile[tileno];
-    tile_Idx->num_packet = 0;
-    pi = pi_create(img, cp, tileno);
-    partno = 0;
-    tile_part = &tile_Idx->tile_parts[partno];
-    position = tile_part->end_header + 1;
-    length_read = 0;
-
-    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;
-	    layer_Idx->offset_header = position;
-	    
-	    e = t2_decode_packet(c, src+len-c, tile, cp, &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;
-	    
-	    /* Update position in case of multiple tile-parts for a tile >> */
-	    length_read += e;
-	    if (length_read >= (tile_part->end_pos - tile_part->end_header))
-	      {
-		partno++;
-		tile_part = &tile_Idx->tile_parts[partno];
-		position = tile_part->end_header + 1;
-		length_read = 0;
-	      }
-	    /* << end_update */
-	    
-	    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[0].include);
-    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;
-      }
-}
diff --git a/applications/jpip/tools/indexer/tcd.c b/applications/jpip/tools/indexer/tcd.c
deleted file mode 100644
index c4045c73..00000000
--- a/applications/jpip/tools/indexer/tcd.c
+++ /dev/null
@@ -1,285 +0,0 @@
-/*
- * 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;
-
-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;
-
-    tile = &tcd_image.tiles[tileno];
-
-    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;
-}
diff --git a/applications/jpip/tools/indexer/tcd.h b/applications/jpip/tools/indexer/tcd.h
deleted file mode 100644
index 9a31723b..00000000
--- a/applications/jpip/tools/indexer/tcd.h
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
- * 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
diff --git a/applications/jpip/tools/indexer/tgt.c b/applications/jpip/tools/indexer/tgt.c
deleted file mode 100644
index c2b46824..00000000
--- a/applications/jpip/tools/indexer/tgt.c
+++ /dev/null
@@ -1,170 +0,0 @@
-/*
- * 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;
-}
diff --git a/applications/jpip/tools/indexer/tgt.h b/applications/jpip/tools/indexer/tgt.h
deleted file mode 100644
index 9d85ade7..00000000
--- a/applications/jpip/tools/indexer/tgt.h
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * 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
diff --git a/applications/jpip/tools/indexer/thix_manager.c b/applications/jpip/tools/indexer/thix_manager.c
new file mode 100644
index 00000000..dbe1b1b4
--- /dev/null
+++ b/applications/jpip/tools/indexer/thix_manager.c
@@ -0,0 +1,208 @@
+/*
+ * $Id$
+ *
+ * Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2011, Professor Benoit Macq
+ * Copyright (c) 2003-2004, Yannick Verschueren
+ * Copyright (c) 2010-2011, Kaori Hagihara
+ * 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.
+ */
+
+/*! \file
+ *  \brief Modification of jpip.c from 2KAN indexer
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "indexbox_manager.h"
+#include "cio_ext.h"
+#include "cio.h"
+
+/* 
+ * Write tile-part headers mhix box
+ *
+ * @param[in] coff      offset of j2k codestream
+ * @param[in] cstr_info codestream information
+ * @param[in] tileno    tile number
+ * @param[in] cio       file output handle
+ * @return              length of mhix box
+ */
+int write_tilemhix( int coff, opj_codestream_info_t cstr_info, int tileno, opj_cio_t *cio);
+
+int write_thix( int coff, opj_codestream_info_t cstr_info, opj_cio_t *cio)
+{
+  int len, lenp, i;
+  int tileno;
+  opj_jp2_box_t *box;
+
+  lenp = 0;
+  box = (opj_jp2_box_t *)calloc( cstr_info.tw*cstr_info.th, sizeof(opj_jp2_box_t));
+
+  for ( i = 0; i < 2 ; i++ ){
+    if (i)
+      cio_seek( cio, lenp);
+
+    lenp = cio_tell( cio);
+    cio_skip( cio, 4);              /* L [at the end] */
+    cio_write( cio, JPIP_THIX, 4);  /* THIX           */
+    write_manf( i, cstr_info.tw*cstr_info.th, box, cio);
+    
+    for (tileno = 0; tileno < cstr_info.tw*cstr_info.th; tileno++){
+      box[tileno].length = write_tilemhix( coff, cstr_info, tileno, cio);
+      box[tileno].type = JPIP_MHIX;
+    }
+ 
+    len = cio_tell( cio)-lenp;
+    cio_seek( cio, lenp);
+    cio_write( cio, len, 4);        /* L              */
+    cio_seek( cio, lenp+len);
+  }
+
+  free(box);
+
+  return len;
+}
+
+
+/* 
+ * Find tile markers
+ *
+ * @param[in]  coff     offset of j2k codestream
+ * @param[in]  startpos tile start byte position
+ * @param[in]  endpos   tile end position
+ * @param[in]  cio      file output handle
+ * @param[out] marknum  pointer to number of markers
+ * @return              found marker information array
+ */
+opj_marker_info_t * find_tile_markers( int coff, int startpos, int endpos, opj_cio_t *cio, int *marknum);
+
+int write_tilemhix( int coff, opj_codestream_info_t cstr_info, int tileno, opj_cio_t *cio)
+{
+  int i;
+  opj_tile_info_t tile;
+  opj_tp_info_t tp;
+  int marknum;
+  int len, lenp;
+  opj_marker_info_t *marker;
+
+  lenp = cio_tell( cio);
+  cio_skip( cio, 4);                               /* L [at the end]                    */
+  cio_write( cio, JPIP_MHIX, 4);                   /* MHIX                              */
+
+  tile = cstr_info.tile[tileno];
+  tp = tile.tp[0];
+
+  cio_ext_write( cio, tp.tp_end_header-tp.tp_start_pos+1, 8);  /* TLEN                              */ 
+
+  marker = find_tile_markers( coff, tile.start_pos, tile.end_header, cio, &marknum);
+
+  for( i=0; i<marknum; i++){             /* Marker restricted to 1 apparition */
+    cio_write( cio, marker[i].type, 2);
+    cio_write( cio, 0, 2);
+    cio_ext_write( cio, marker[i].pos, 8);
+    cio_write( cio, marker[i].len, 2);
+  }
+     
+  free( marker);
+
+  len = cio_tell( cio) - lenp;
+  cio_seek( cio, lenp);
+  cio_write( cio, len, 4);        /* L           */
+  cio_seek( cio, lenp+len);
+
+  return len;
+}
+
+
+/* 
+ * Get tile marker size
+ * 
+ * @param[in] type marker type
+ * @param[in] cio  file input handle
+ * @return         marker size
+ */
+unsigned short get_tile_markersize( unsigned short type, opj_cio_t *cio);
+
+opj_marker_info_t * find_tile_markers( int coff, int startpos, int endpos, opj_cio_t *cio, int *marknum)
+{
+  int org_pos, pos;
+  opj_marker_info_t *marker, *tmp;
+  int max_num_of_markers = 100;
+
+  marker = (opj_marker_info_t *)malloc( max_num_of_markers*sizeof(opj_marker_info_t));
+  if( !marker){
+    fprintf( stderr, "malloc error for marker in find_tile_markers()\n");
+    exit(-1);
+  }
+  (*marknum) = 0;
+
+  org_pos = cio_tell( cio);
+  cio_seek( cio, coff+startpos);
+  pos = startpos;
+
+  while( pos < coff+endpos){
+    if( *marknum >= max_num_of_markers){
+      tmp = marker;
+      marker = (opj_marker_info_t *)malloc( (max_num_of_markers+100)*sizeof(opj_marker_info_t));
+      memcpy( marker, tmp, max_num_of_markers*sizeof(opj_marker_info_t));
+      free( tmp);
+      max_num_of_markers += 100;
+    }
+
+    marker[*marknum].type = cio_read( cio, 2);
+    marker[*marknum].pos  = cio_tell( cio)-coff;
+    marker[*marknum].len  = get_tile_markersize( marker[*marknum].type, cio);
+    cio_skip( cio, marker[*marknum].len);
+
+    (*marknum)++;
+    pos += 2+marker[*marknum].len;
+  }
+
+  cio_seek( cio, org_pos);
+
+  return marker;
+}
+
+unsigned short get_tile_markersize( unsigned short type, opj_cio_t *cio)
+{
+  unsigned short siz;
+  int pos;
+  
+  siz = 0;
+
+  switch( type){
+  case J2K_MS_SOD:
+  case J2K_MS_EOC:
+  case J2K_MS_EPH:
+    siz = 0;
+    break;
+  default:
+    pos = cio_tell( cio);
+    siz = cio_read( cio, 2);
+    cio_seek( cio, pos);
+    break;
+  }
+  return siz;
+}
diff --git a/applications/jpip/tools/indexer/tpix_manager.c b/applications/jpip/tools/indexer/tpix_manager.c
new file mode 100644
index 00000000..1f71ce6d
--- /dev/null
+++ b/applications/jpip/tools/indexer/tpix_manager.c
@@ -0,0 +1,154 @@
+/*
+ * $Id$
+ *
+ * Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2011, Professor Benoit Macq
+ * Copyright (c) 2003-2004, Yannick Verschueren
+ * Copyright (c) 2010-2011, Kaori Hagihara
+ * 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.
+ */
+
+/*! \file
+ *  \brief Modification of jpip.c from 2KAN indexer
+ */
+
+#include <math.h>
+#include "indexbox_manager.h"
+#include "cio_ext.h"
+#include "cio.h"
+
+#define MAX(a,b) ((a)>(b)?(a):(b))
+
+
+/* 
+ * Write faix box of tpix
+ *
+ * @param[in] compno    component number
+ * @param[in] cstr_info codestream information
+ * @param[in] j2klen    length of j2k codestream
+ * @param[in] cio       file output handle
+ * @return              length of faix box
+ */
+int write_tpixfaix( int compno, opj_codestream_info_t cstr_info, int j2klen, opj_cio_t *cio);
+
+
+int write_tpix( opj_codestream_info_t cstr_info, int j2klen, opj_cio_t *cio)
+{
+  int len, lenp;
+  lenp = cio_tell( cio);
+  cio_skip( cio, 4);              /* L [at the end] */
+  cio_write( cio, JPIP_TPIX, 4);  /* TPIX           */
+  
+  write_tpixfaix( 0, cstr_info, j2klen, cio);
+
+  len = cio_tell( cio)-lenp;
+  cio_seek( cio, lenp);
+  cio_write( cio, len, 4);        /* L              */
+  cio_seek( cio, lenp+len);
+
+  return len;
+}
+
+
+/* 
+ * Get number of maximum tile parts per tile
+ *
+ * @param[in] cstr_info codestream information
+ * @return              number of maximum tile parts per tile
+ */
+int get_num_max_tile_parts( opj_codestream_info_t cstr_info);
+
+int write_tpixfaix( int compno, opj_codestream_info_t cstr_info, int j2klen, opj_cio_t *cio)
+{
+  int len, lenp;
+  int i, j;
+  int Aux;
+  int num_max_tile_parts;
+  int size_of_coding; // 4 or 8
+  opj_tp_info_t tp;
+  int version;
+
+  num_max_tile_parts = get_num_max_tile_parts( cstr_info);
+
+  if( j2klen > pow( 2, 32)){
+    size_of_coding =  8;
+    version = num_max_tile_parts == 1 ? 1:3;
+  }
+  else{
+    size_of_coding = 4;
+    version = num_max_tile_parts == 1 ? 0:2;
+  }
+
+  lenp = cio_tell( cio);
+  cio_skip( cio, 4);              /* L [at the end]      */
+  cio_write( cio, JPIP_FAIX, 4);  /* FAIX                */ 
+  cio_write( cio, version, 1);     /* Version 0 = 4 bytes */
+
+  cio_ext_write( cio, num_max_tile_parts, size_of_coding);                      /* NMAX           */
+  cio_ext_write( cio, cstr_info.tw*cstr_info.th, size_of_coding);                               /* M              */
+  for (i = 0; i < cstr_info.tw*cstr_info.th; i++){
+    for (j = 0; j < cstr_info.tile[i].num_tps; j++){
+      tp = cstr_info.tile[i].tp[j];
+      cio_ext_write( cio, tp.tp_start_pos, size_of_coding); /* start position */
+      cio_ext_write( cio, tp.tp_end_pos-tp.tp_start_pos+1, size_of_coding);    /* length         */
+      if (version & 0x02){
+	if( cstr_info.tile[i].num_tps == 1 && cstr_info.numdecompos[compno] > 1)
+	  Aux = cstr_info.numdecompos[compno] + 1;
+	else
+	  Aux = j + 1;
+		  
+	cio_write( cio, Aux,4);
+	//cio_write(img.tile[i].tile_parts[j].num_reso_AUX,4); /* Aux_i,j : Auxiliary value */
+	// fprintf(stderr,"AUX value %d\n",Aux);
+      }
+      //cio_write(0,4);
+    }
+    /* PADDING */
+    while (j < num_max_tile_parts){
+      cio_ext_write( cio, 0, size_of_coding); /* start position            */
+      cio_ext_write( cio, 0, size_of_coding); /* length                    */
+      if (version & 0x02)
+	cio_write( cio, 0,4);                  /* Aux_i,j : Auxiliary value */
+      j++;
+    }
+  }
+  
+  len = cio_tell( cio)-lenp;
+  cio_seek( cio, lenp);
+  cio_write( cio, len, 4);        /* L  */
+  cio_seek( cio, lenp+len);
+
+  return len;
+
+}
+
+int get_num_max_tile_parts( opj_codestream_info_t cstr_info)
+{
+  int num_max_tp = 0, i;
+
+  for( i=0; i<cstr_info.tw*cstr_info.th; i++)
+    num_max_tp = MAX( cstr_info.tile[i].num_tps, num_max_tp);
+  
+  return num_max_tp;
+}