[trunk] FolderReorgProposal task: add JP3D

Update issue 177

15 files changed, 4227 insertions, 0 deletions

diff --git a/src/bin/jp3d/CMakeLists.txt b/src/bin/jp3d/CMakeLists.txt
new file mode 100644
index 00000000..a4742b7c
--- /dev/null
+++ b/src/bin/jp3d/CMakeLists.txt
@@ -0,0 +1,39 @@
+# Build the demo app, small examples
+
+# First thing define the common source:
+SET(common_SRCS
+  convert.c
+  )
+
+# Headers file are located here:
+include_directories(
+  ${OPENJPEG_SOURCE_DIR}/src/lib/openjp3d
+  ${LCMS_INCLUDE_DIRNAME}
+  ${OPENJPEG_SOURCE_DIR}/src/bin/common
+  ${Z_INCLUDE_DIRNAME}
+  ${PNG_INCLUDE_DIRNAME}
+  ${TIFF_INCLUDE_DIRNAME}
+  )
+
+IF(WIN32)
+  IF(BUILD_SHARED_LIBS)
+    ADD_DEFINITIONS(-DOPJ_EXPORTS)
+  ELSE(BUILD_SHARED_LIBS)
+    ADD_DEFINITIONS(-DOPJ_STATIC)
+  ENDIF(BUILD_SHARED_LIBS)
+ENDIF(WIN32)
+
+# Loop over all executables:
+FOREACH(exe jp3d_to_volume volume_to_jp3d)
+  ADD_EXECUTABLE(${exe} ${exe}.c ${common_SRCS})
+  TARGET_LINK_LIBRARIES(${exe} openjp3d)
+  # On unix you need to link to the math library:
+  IF(UNIX)
+    TARGET_LINK_LIBRARIES(${exe} m)
+  ENDIF(UNIX)
+  # Install exe
+  INSTALL(TARGETS ${exe}
+    EXPORT OpenJP3DTargets
+    DESTINATION ${OPENJPEG_INSTALL_BIN_DIR} COMPONENT Applications
+  )
+ENDFOREACH(exe)
diff --git a/src/bin/jp3d/Makefile.am b/src/bin/jp3d/Makefile.am
new file mode 100644
index 00000000..bf6ff1e5
--- /dev/null
+++ b/src/bin/jp3d/Makefile.am
@@ -0,0 +1,23 @@
+
+MAINTAINERCLEANFILES = Makefile.in
+
+bin_PROGRAMS = jp3d_to_volume volume_to_jp3d
+LDADD = $(USERLIBS) ../libjp3dvm/libopenjp3dvm.la
+
+jp3d_to_volume_CPPFLAGS =
+jp3d_to_volume_CFLAGS =
+jp3d_to_volume_LDADD = $(top_builddir)/jp3d/libjp3dvm/libopenjp3dvm.la -lm
+jp3d_to_volume_SOURCES = getopt.c convert.c jp3d_to_volume.c convert.h
+
+volume_to_jp3d_CPPFLAGS =
+volume_to_jp3d_CFLAGS =
+volume_to_jp3d_LDADD = $(top_builddir)/jp3d/libjp3dvm/libopenjp3dvm.la
+volume_to_jp3d_SOURCES = getopt.c convert.c volume_to_jp3d.c convert.h
+
+EXTRA_DIST = \
+CMakeLists.txt \
+windirent.h
+
+install-data-hook:
+	@echo -e " (B)\t$(bindir)/jp3d_to_volume$(EXEEXT)" >> $(top_builddir)/report.txt
+	@echo -e " (B)\t$(bindir)/volume_to_jp3d$(EXEEXT)" >> $(top_builddir)/report.txt
diff --git a/src/bin/jp3d/convert.c b/src/bin/jp3d/convert.c
new file mode 100755
index 00000000..e6131381
--- /dev/null
+++ b/src/bin/jp3d/convert.c
@@ -0,0 +1,997 @@
+/*
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * Copyright (c) 2006, Mónica Díez García, Image Processing Laboratory, University of Valladolid, Spain
+ * 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 "openjp3d.h"
+#ifdef _WIN32
+#include "windirent.h"
+#else
+#include <dirent.h>
+#endif /* _WIN32 */
+
+
+
+void dump_volume(FILE *fd, opj_volume_t * vol) {
+	int compno;
+	fprintf(fd, "volume {\n");
+	fprintf(fd, "  x0=%d, y0=%d, z0=%d, x1=%d, y1=%d, z1=%d\n", vol->x0, vol->y0, vol->z0,vol->x1, vol->y1,  vol->z1);
+	fprintf(fd, "  numcomps=%d\n", vol->numcomps);
+	for (compno = 0; compno < vol->numcomps; compno++) {
+		opj_volume_comp_t *comp = &vol->comps[compno];
+		fprintf(fd, "  comp %d {\n", compno);
+		fprintf(fd, "    dx=%d, dy=%d, dz=%d\n", comp->dx, comp->dy, comp->dz);
+		fprintf(fd, "    prec=%d\n", comp->prec);
+		fprintf(fd, "    sgnd=%d\n", comp->sgnd);
+		fprintf(fd, "  }\n");
+	}
+	fprintf(fd, "}\n");
+}
+
+/*
+ * Get logarithm of an integer and round downwards.
+ *
+ * log2(a)
+ */
+static int int_floorlog2(int a) {
+	int l;
+	for (l = 0; a > 1; l++) {
+		a >>= 1;
+	}
+	return l;
+}
+
+/*
+ * Divide an integer by a power of 2 and round upwards.
+ *
+ * a divided by 2^b
+ */
+static int int_ceildivpow2(int a, int b) {
+	return (a + (1 << b) - 1) >> b;
+}
+
+/*
+ * Divide an integer and round upwards.
+ *
+ * a divided by b
+ */
+static int int_ceildiv(int a, int b) {
+	return (a + b - 1) / b;
+}
+
+
+/* -->> -->> -->> -->>
+
+PGX IMAGE FORMAT
+
+<<-- <<-- <<-- <<-- */
+
+
+unsigned char readuchar(FILE * f)
+{
+  unsigned char c1;
+  fread(&c1, 1, 1, f);
+  return c1;
+}
+
+unsigned short readushort(FILE * f, int bigendian)
+{
+  unsigned char c1, c2;
+  fread(&c1, 1, 1, f);
+  fread(&c2, 1, 1, f);
+  if (bigendian)
+    return (c1 << 8) + c2;
+  else
+    return (c2 << 8) + c1;
+}
+
+unsigned int readuint(FILE * f, int bigendian)
+{
+  unsigned char c1, c2, c3, c4;
+  fread(&c1, 1, 1, f);
+  fread(&c2, 1, 1, f);
+  fread(&c3, 1, 1, f);
+  fread(&c4, 1, 1, f);
+  if (bigendian)
+    return (c1 << 24) + (c2 << 16) + (c3 << 8) + c4;
+  else
+    return (c4 << 24) + (c3 << 16) + (c2 << 8) + c1;
+}
+/*****************************************/
+static unsigned short ShortSwap(unsigned short v)
+{
+  unsigned char c1, c2;
+  c1 = v & 0xff;
+  c2 = (v >> 8) & 0xff;
+  return (c1 << 8) + c2;
+}
+
+static unsigned int LongSwap (unsigned int i)
+{
+  unsigned char b1, b2, b3, b4;
+  b1 = i & 255;
+  b2 = ( i >> 8 ) & 255;
+  b3 = ( i>>16 ) & 255;
+  b4 = ( i>>24 ) & 255;
+  return ((int)b1 << 24) + ((int)b2 << 16) + ((int)b3 << 8) + b4;
+}
+/*****************************************/
+
+opj_volume_t* pgxtovolume(char *relpath, opj_cparameters_t *parameters) {
+	
+	FILE *f = NULL;
+	int w, h, prec;
+	unsigned long offset;
+	int i, s, numcomps, maxvalue, sliceno, slicepos, maxslice = 0;
+	
+	OPJ_COLOR_SPACE color_space;
+	opj_volume_cmptparm_t cmptparm;	// maximum of 1 component 
+	opj_volume_t * volume = NULL;
+
+	char endian1,endian2,sign;
+	char signtmp[32];
+	char temp[32];
+	opj_volume_comp_t *comp = NULL;
+
+		DIR *dirp;
+    struct dirent *direntp;
+	
+	char *tmp = NULL, *tmp2 = NULL,
+		*point = NULL, *pgx = NULL;
+	char tmpdirpath[MAX_PATH];
+	char dirpath[MAX_PATH];
+	char pattern[MAX_PATH];
+	char pgxfiles[MAX_SLICES][MAX_PATH];
+	int pgxslicepos[MAX_SLICES];
+	char tmpno[3];
+	
+	numcomps = 1;
+	color_space = CLRSPC_GRAY;
+	sliceno = 0;
+	maxvalue = 0;
+	memset(pgxfiles, 0, MAX_SLICES * MAX_PATH * sizeof(char));
+	memset(&cmptparm, 0, sizeof(opj_volume_cmptparm_t));
+	
+	/* Separación del caso de un único slice frente al de muchos */
+	if ((tmp = strrchr(relpath,'-')) == NULL){ 
+		//fprintf(stdout,"[INFO] A volume of only one slice....\n");
+		sliceno = 1;
+		maxslice = 1;
+		strcpy(pgxfiles[0],relpath);
+	
+	} else {
+		//Fetch only the path 
+		strcpy(tmpdirpath,relpath);
+		if ((tmp = strrchr(tmpdirpath,'/')) != NULL){
+			tmp++; *tmp='\0';
+			strcpy(dirpath,tmpdirpath);
+		} else {
+			strcpy(dirpath,"./");
+		}
+
+		//Fetch the pattern of the volume slices
+		if ((tmp = strrchr (relpath,'/')) != NULL) 
+			tmp++;	
+		else 
+			tmp = relpath;
+        if ((tmp2 = strrchr(tmp,'-')) != NULL)
+            *tmp2='\0';
+		else{ 
+			fprintf(stdout, "[ERROR] tmp2 ha dado null. no ha encontrado el * %s %s",tmp,relpath);
+			return NULL;
+		}
+        strcpy(pattern,tmp);
+
+		dirp = opendir( dirpath );
+		if (dirp == NULL){
+			fprintf(stdout, "[ERROR] Infile must be a .pgx file or a directory that contain pgx files");
+			return NULL;
+		}
+
+		/*Read all .pgx files of directory */
+		while ( (direntp = readdir( dirp )) != NULL )
+		{
+			/* Found a directory, but ignore . and .. */
+			if(strcmp(".",direntp->d_name) == 0 || strcmp("..",direntp->d_name) == 0)
+					continue;
+			
+			if( ((pgx = strstr(direntp->d_name,pattern)) != NULL) && ((tmp2 = strstr(direntp->d_name,".pgx")) != NULL) ){
+			
+				strcpy(tmp,dirpath);
+				tmp = strcat(tmp,direntp->d_name);
+						
+				//Obtenemos el index de la secuencia de slices
+				if ((tmp2 = strpbrk (direntp->d_name, "0123456789")) == NULL) 
+					continue;
+				i = 0;
+				while (tmp2 != NULL) {					
+					tmpno[i++] = *tmp2;
+					point = tmp2;
+					tmp2 = strpbrk (tmp2+1,"0123456789");
+				}tmpno[i]='\0';
+
+				//Comprobamos que no estamos leyendo algo raro como pattern.jp3d
+				if ((point = strpbrk (point,".")) == NULL){
+					break;
+				}
+				//Slicepos --> index de slice; Sliceno --> no de slices hasta el momento
+				slicepos = atoi(tmpno);
+				pgxslicepos[sliceno] = slicepos - 1;
+				sliceno++;
+				if (slicepos>maxslice)
+					maxslice = slicepos;
+				
+				//Colocamos el slices en su posicion correspondiente
+				strcpy(pgxfiles[slicepos-1],tmp);
+			}
+		}
+	
+	}/* else if pattern*.pgx */
+
+	if (!sliceno) {
+		fprintf(stdout,"[ERROR] No slices with this pattern founded !! Please check input volume name\n");
+		return NULL;
+	}
+	/*if ( maxslice != sliceno) {
+		fprintf(stdout,"[ERROR] Slices are not sequentially numbered !! Please rename them accordingly\n");
+		return NULL;
+	}*/
+	
+	for (s=0;s<sliceno;s++)
+	{
+			int pos = maxslice == sliceno ? s: pgxslicepos[s];
+			f = fopen(pgxfiles[pos], "rb");
+			if (!f) {
+				fprintf(stdout, "[ERROR] Failed to open %s for reading !\n", pgxfiles[s]);
+				return NULL;
+			}
+			fprintf(stdout, "[INFO] Loading %s \n",pgxfiles[pos]);
+
+			fseek(f, 0, SEEK_SET);
+			fscanf(f, "PG%[ \t]%c%c%[ \t+-]%d%[ \t]%d%[ \t]%d",temp,&endian1,&endian2,signtmp,&prec,temp,&w,temp,&h);
+
+			i=0;
+			sign='+';		
+			while (signtmp[i]!='\0') {
+				if (signtmp[i]=='-') sign='-';
+				i++;
+			}
+		
+			fgetc(f);
+			if (endian1=='M' && endian2=='L') {
+				cmptparm.bigendian = 1;
+			} else if (endian2=='M' && endian1=='L') {
+				cmptparm.bigendian = 0;
+			} else {
+				fprintf(stdout, "[ERROR] Bad pgx header, please check input file\n");
+				return NULL;
+			}
+
+			if (s==0){
+				/* initialize volume component */
+
+				cmptparm.x0 = parameters->volume_offset_x0;
+				cmptparm.y0 = parameters->volume_offset_y0;
+				cmptparm.z0 = parameters->volume_offset_z0;
+				cmptparm.w = !cmptparm.x0 ? (w - 1) * parameters->subsampling_dx + 1 : cmptparm.x0 + (w - 1) * parameters->subsampling_dx + 1;
+				cmptparm.h = !cmptparm.y0 ? (h - 1) * parameters->subsampling_dy + 1 : cmptparm.y0 + (h - 1) * parameters->subsampling_dy + 1;
+				cmptparm.l = !cmptparm.z0 ? (sliceno - 1) * parameters->subsampling_dz + 1 : cmptparm.z0 + (sliceno - 1) * parameters->subsampling_dz + 1;
+				
+				if (sign == '-') {
+					cmptparm.sgnd = 1;
+				} else {
+					cmptparm.sgnd = 0;
+				}
+				cmptparm.prec = prec;
+				cmptparm.bpp = prec;
+				cmptparm.dcoffset = parameters->dcoffset;
+				cmptparm.dx = parameters->subsampling_dx;
+				cmptparm.dy = parameters->subsampling_dy;
+				cmptparm.dz = parameters->subsampling_dz;
+				
+				/* create the volume */
+				volume = opj_volume_create(numcomps, &cmptparm, color_space);
+				if(!volume) {
+					fclose(f);
+					return NULL;
+				}
+				/* set volume offset and reference grid */
+				volume->x0 = cmptparm.x0;
+				volume->y0 = cmptparm.y0;
+				volume->z0 = cmptparm.z0;
+				volume->x1 = cmptparm.w;
+				volume->y1 = cmptparm.h;
+				volume->z1 = cmptparm.l;
+				
+				/* set volume data :only one component, that is a volume*/
+				comp = &volume->comps[0];
+			
+			}//if sliceno==1
+			
+			offset = w * h * s;
+			
+			for (i = 0; i < w * h; i++) {
+				int v;
+				if (comp->prec <= 8) {
+					if (!comp->sgnd) {
+						v = readuchar(f);
+					} else {
+						v = (char) readuchar(f);
+					}
+				} else if (comp->prec <= 16) {
+					if (!comp->sgnd) {
+						v = readushort(f, cmptparm.bigendian);
+					} else {
+						v = (short) readushort(f, cmptparm.bigendian);
+					}
+				} else {
+					if (!comp->sgnd) {
+						v = readuint(f, cmptparm.bigendian);
+					} else {
+						v = (int) readuint(f, cmptparm.bigendian);
+					}
+				}				
+				if (v > maxvalue)
+					maxvalue = v;
+				comp->data[i + offset] = v;
+				
+			}
+			fclose(f);
+	} // for s --> sliceno
+	comp->bpp = int_floorlog2(maxvalue) + 1;
+	if (sliceno != 1)
+		closedir( dirp );
+	//dump_volume(stdout, volume);
+	return volume;
+}
+
+
+int volumetopgx(opj_volume_t * volume, char *outfile) {
+	int w, wr, wrr, h, hr, hrr, l, lr, lrr;
+	int i, j, compno, offset, sliceno;
+	FILE *fdest = NULL;
+
+	for (compno = 0; compno < volume->numcomps; compno++) {
+		opj_volume_comp_t *comp = &volume->comps[compno];
+		char name[256];
+		int nbytes = 0;
+		char *tmp = outfile;
+		while (*tmp) {
+			tmp++;
+		}
+		while (*tmp!='.') {
+			tmp--;
+		}
+		*tmp='\0';
+		for(sliceno = 0; sliceno < volume->z1 - volume->z0; sliceno++) {
+
+			if (volume->numcomps > 1) {
+				sprintf(name, "%s%d-%d.pgx", outfile, sliceno+1, compno);
+			} else if ((volume->z1 - volume->z0) > 1) {
+				sprintf(name, "%s%d.pgx", outfile, sliceno+1);
+			} else {
+				sprintf(name, "%s.pgx", outfile);
+			}
+
+			fdest = fopen(name, "wb");
+			if (!fdest) {
+				fprintf(stdout, "[ERROR] Failed to open %s for writing \n", name);
+				return 1;
+			}
+
+			fprintf(stdout,"[INFO] Writing in %s (%s)\n",name,volume->comps[0].bigendian ? "Bigendian" : "Little-endian");
+
+			w = int_ceildiv(volume->x1 - volume->x0, volume->comps[compno].dx);
+			wr = volume->comps[compno].w;
+			wrr = int_ceildivpow2(volume->comps[compno].w, volume->comps[compno].factor[0]);
+			
+			h = int_ceildiv(volume->y1 - volume->y0, volume->comps[compno].dy);
+			hr = volume->comps[compno].h;
+			hrr = int_ceildivpow2(volume->comps[compno].h, volume->comps[compno].factor[1]);
+			
+			l = int_ceildiv(volume->z1 - volume->z0, volume->comps[compno].dz);
+			lr = volume->comps[compno].l;
+			lrr = int_ceildivpow2(volume->comps[compno].l, volume->comps[compno].factor[2]);
+
+			fprintf(fdest, "PG %c%c %c%d %d %d\n", comp->bigendian ? 'M':'L', comp->bigendian ? 'L':'M',comp->sgnd ? '-' : '+', comp->prec, wr, hr);
+			if (comp->prec <= 8) {
+				nbytes = 1;
+			} else if (comp->prec <= 16) {
+				nbytes = 2;
+			} else {
+				nbytes = 4;
+			}
+
+			offset = (sliceno / lrr * l) + (sliceno % lrr);
+			offset = wrr * hrr * offset;
+			//fprintf(stdout,"%d %d %d %d\n",offset,wrr*hrr,wrr,w);
+			for (i = 0; i < wrr * hrr; i++) {
+				int v = volume->comps[0].data[(i / wrr * w) + (i % wrr) + offset];
+				if (volume->comps[0].bigendian) {
+					for (j = nbytes - 1; j >= 0; j--) {
+                        char byte = (char) ((v >> (j * 8)) & 0xff);
+                        fwrite(&byte, 1, 1, fdest);
+					}
+				} else {
+					for (j = 0; j <= nbytes - 1; j++) {
+                        char byte = (char) ((v >> (j * 8)) & 0xff);
+						fwrite(&byte, 1, 1, fdest);
+					}
+				}
+			}
+
+			fclose(fdest);
+		}//for sliceno
+	}//for compno
+
+	return 0;
+}
+
+/* -->> -->> -->> -->>
+
+BIN IMAGE FORMAT
+
+<<-- <<-- <<-- <<-- */
+
+opj_volume_t* bintovolume(char *filename, char *fileimg, opj_cparameters_t *parameters) {
+	int subsampling_dx =  parameters->subsampling_dx;
+	int subsampling_dy =  parameters->subsampling_dy;
+	int subsampling_dz =  parameters->subsampling_dz;
+	
+	int i, compno, w, h, l, numcomps = 1;
+	int prec, max = 0;
+
+//	char temp[32];
+	char line[100];
+	int bigendian;
+	
+	FILE *f = NULL;
+	FILE *fimg = NULL;
+	OPJ_COLOR_SPACE color_space;
+	opj_volume_cmptparm_t cmptparm;	/* maximum of 1 component */
+	opj_volume_t * volume = NULL;
+	opj_volume_comp_t *comp = NULL;
+
+	bigendian = 0;
+	color_space = CLRSPC_GRAY;
+
+	fimg = fopen(fileimg,"r");
+	if (!fimg) { 
+		fprintf(stdout, "[ERROR] Failed to open %s for reading !!\n", fileimg);
+		return 0;
+	}
+
+	fseek(fimg, 0, SEEK_SET);
+	while (!feof(fimg)) {
+        fgets(line,100,fimg);
+		//fprintf(stdout,"%s %d \n",line,feof(fimg));
+		if (strncmp(line,"Bpp",3) == 0){
+			sscanf(line,"%*s%*[ \t]%d",&prec);
+		} else if (strncmp(line,"Color",5) == 0){
+			sscanf(line, "%*s%*[ \t]%d",&color_space);
+		} else if (strncmp(line,"Dim",3) == 0){
+			sscanf(line, "%*s%*[ \t]%d%*[ \t]%d%*[ \t]%d",&w,&h,&l);
+		}
+	}
+	//fscanf(fimg, "Bpp%[ \t]%d%[ \t\n]",temp,&prec,temp);
+	//fscanf(fimg, "Color Map%[ \t]%d%[ \n\t]Dimensions%[ \t]%d%[ \t]%d%[ \t]%d%[ \n\t]",temp,&color_space,temp,temp,&w,temp,&h,temp,&l,temp);
+	//fscanf(fimg, "Resolution(mm)%[ \t]%d%[ \t]%d%[ \t]%d%[ \n\t]",temp,&subsampling_dx,temp,&subsampling_dy,temp,&subsampling_dz,temp);
+
+	#ifdef VERBOSE
+		fprintf(stdout, "[INFO] %d \t %d %d %d \t %3.2f %2.2f %2.2f \t %d \n",color_space,w,h,l,subsampling_dx,subsampling_dy,subsampling_dz,prec);
+	#endif
+	fclose(fimg);
+	
+	/* initialize volume components */
+	memset(&cmptparm, 0, sizeof(opj_volume_cmptparm_t));
+	
+	cmptparm.prec = prec;
+	cmptparm.bpp = prec;
+	cmptparm.sgnd = 0;
+	cmptparm.bigendian = bigendian;
+	cmptparm.dcoffset = parameters->dcoffset;
+	cmptparm.dx = subsampling_dx;
+	cmptparm.dy = subsampling_dy;
+	cmptparm.dz = subsampling_dz;
+	cmptparm.w = w;
+	cmptparm.h = h;
+	cmptparm.l = l;
+	
+	/* create the volume */
+	volume = opj_volume_create(numcomps, &cmptparm, color_space);
+	if(!volume) {
+		fprintf(stdout,"[ERROR] Unable to create volume");	
+		fclose(f);
+		return NULL;
+	}
+	
+	/* set volume offset and reference grid */
+	volume->x0 = parameters->volume_offset_x0;
+	volume->y0 = parameters->volume_offset_y0;
+	volume->z0 = parameters->volume_offset_z0;
+	volume->x1 = parameters->volume_offset_x0 + (w - 1) *	subsampling_dx + 1;
+	volume->y1 = parameters->volume_offset_y0 + (h - 1) *	subsampling_dy + 1;
+	volume->z1 = parameters->volume_offset_z0 + (l - 1) *	subsampling_dz + 1;
+	
+	/* set volume data */
+	f = fopen(filename, "rb");
+	if (!f) {
+		fprintf(stdout, "[ERROR] Failed to open %s for reading !!\n", filename);
+		return 0;
+	}
+	
+	/* BINARY */
+	for (compno = 0; compno < volume->numcomps; compno++) {
+		int whl = w * h * l;
+		/* set volume data */
+		comp = &volume->comps[compno];
+		
+		/*if (comp->prec <= 8) {
+			if (!comp->sgnd) {
+                unsigned char *data = (unsigned char *) malloc(whl * sizeof(unsigned char));
+				fread(data, 1, whl, f);
+				for (i = 0; i < whl; i++) {
+					comp->data[i] = data[i];
+					if (comp->data[i] > max)
+						max = comp->data[i];
+				}
+				free(data);
+			} else {
+				char *data = (char *) malloc(whl);
+				fread(data, 1, whl, f);
+				for (i = 0; i < whl; i++) {
+					comp->data[i] = data[i];
+					if (comp->data[i] > max)
+						max = comp->data[i];
+				}
+				free(data);
+			}
+		} else if (comp->prec <= 16) {
+			if (!comp->sgnd) {
+                unsigned short *data = (unsigned short *) malloc(whl * sizeof(unsigned short));
+				int leido = fread(data, 2, whl, f);
+				if (!leido)	{
+					free(data);	fclose(f);
+					return NULL;
+				}
+				
+				for (i = 0; i < whl; i++) {
+					if (bigendian)	//(c1 << 8) + c2;
+						comp->data[i] = data[i];
+					else{			//(c2 << 8) + c1;
+						comp->data[i] = ShortSwap(data[i]);
+					}
+					if (comp->data[i] > max)
+						max = comp->data[i];
+				}
+				free(data);
+			} else {
+				short *data = (short *) malloc(whl);
+				int leido = fread(data, 2, whl, f);
+				if (!leido)	{
+					free(data);	fclose(f);
+					return NULL;
+				}
+				for (i = 0; i < whl; i++) {
+					if (bigendian){	//(c1 << 8) + c2;
+						comp->data[i] = data[i];
+					}else{			//(c2 << 8) + c1;
+						comp->data[i] = (short) ShortSwap((unsigned short) data[i]);
+					}
+					if (comp->data[i] > max)
+						max = comp->data[i];
+				}
+				free(data);
+			}
+		} else {
+			if (!comp->sgnd) {
+                unsigned int *data = (unsigned int *) malloc(whl * sizeof(unsigned int));
+				int leido = fread(data, 4, whl, f);
+				if (!leido)	{
+					free(data);	fclose(f);
+					return NULL;
+				}				for (i = 0; i < whl; i++) {
+					if (!bigendian)
+						comp->data[i] = LongSwap(data[i]);
+					else
+						comp->data[i] = data[i];
+					if (comp->data[i] > max)
+						max = comp->data[i];
+				}
+				free(data);
+			} else {
+				int leido = fread(comp->data, 4, whl, f);
+				if (!leido)	{
+					fclose(f);
+					return NULL;
+				}				
+				for (i = 0; i < whl; i++) {
+					if (!bigendian) 
+						comp->data[i] = (int) LongSwap((unsigned int) comp->data[i]);
+					if (comp->data[i] > max)
+						max = comp->data[i];
+				}
+			}
+		}*/
+		
+		for (i = 0; i < whl; i++) {
+			int v;
+			if (comp->prec <= 8) {
+				if (!comp->sgnd) {
+					v = readuchar(f);
+				} else {
+					v = (char) readuchar(f);
+				}
+			} else if (comp->prec <= 16) {
+				if (!comp->sgnd) {
+					v = readushort(f, bigendian);
+				} else {
+					v = (short) readushort(f, bigendian);
+				}
+			} else {
+				if (!comp->sgnd) {
+					v = readuint(f, bigendian);
+				} else {
+					v = (int) readuint(f, bigendian);
+				}
+			}
+			if (v > max)
+				max = v;
+			comp->data[i] = v;
+		}
+		comp->bpp = int_floorlog2(max) + 1;
+	}
+	fclose(f);
+	return volume;
+}
+
+int volumetobin(opj_volume_t * volume, char *outfile) {
+	int w, wr, wrr, h, hr, hrr, l, lr, lrr, max;
+	int i,j, compno, nbytes;
+	int offset, sliceno;
+	FILE *fdest = NULL;
+	FILE *fimgdest = NULL;
+//	char *imgtemp;
+	char name[256];
+
+	for (compno = 0; compno < 1; compno++) { //Only one component
+		
+		fdest = fopen(outfile, "wb");
+		if (!fdest) {
+			fprintf(stdout, "[ERROR] Failed to open %s for writing\n", outfile);
+			return 1;
+		}
+        fprintf(stdout,"[INFO] Writing outfile %s (%s) \n",outfile, volume->comps[0].bigendian ? "Bigendian" : "Little-endian");
+
+		w = int_ceildiv(volume->x1 - volume->x0, volume->comps[compno].dx);
+		wr = volume->comps[compno].w;
+		wrr = int_ceildivpow2(volume->comps[compno].w, volume->comps[compno].factor[0]);
+		
+		h = int_ceildiv(volume->y1 - volume->y0, volume->comps[compno].dy);
+		hr = volume->comps[compno].h;
+		hrr = int_ceildivpow2(volume->comps[compno].h, volume->comps[compno].factor[1]);
+		
+		l = int_ceildiv(volume->z1 - volume->z0, volume->comps[compno].dz);
+		lr = volume->comps[compno].l;
+		lrr = int_ceildivpow2(volume->comps[compno].l, volume->comps[compno].factor[2]);
+
+		max = (volume->comps[compno].prec <= 8) ? 255 : (1 << volume->comps[compno].prec) - 1;
+		
+		volume->comps[compno].x0 = int_ceildivpow2(volume->comps[compno].x0 - int_ceildiv(volume->x0, volume->comps[compno].dx), volume->comps[compno].factor[0]);
+		volume->comps[compno].y0 = int_ceildivpow2(volume->comps[compno].y0 - int_ceildiv(volume->y0, volume->comps[compno].dy), volume->comps[compno].factor[1]);
+		volume->comps[compno].z0 = int_ceildivpow2(volume->comps[compno].z0 - int_ceildiv(volume->z0, volume->comps[compno].dz), volume->comps[compno].factor[2]);
+		
+		if (volume->comps[0].prec <= 8) {
+			nbytes = 1;
+		} else if (volume->comps[0].prec <= 16) {
+			nbytes = 2;
+		} else {
+			nbytes = 4;
+		}
+
+		//fprintf(stdout,"w %d wr %d wrr %d h %d hr %d hrr %d l %d lr %d lrr %d max %d nbytes %d\n Factor %d %d %d",w,wr,wrr,h,hr,hrr,l,lr,lrr,max,nbytes,volume->comps[compno].factor[0],volume->comps[compno].factor[1],volume->comps[compno].factor[2]);
+
+		for(sliceno = 0; sliceno < lrr; sliceno++) {
+			offset = (sliceno / lrr * l) + (sliceno % lrr);
+            offset = wrr * hrr * offset;
+			for (i = 0; i < wrr * hrr; i++) {
+				int v = volume->comps[0].data[(i / wrr * w) + (i % wrr) + offset];
+				if (volume->comps[0].bigendian) {
+					for (j = nbytes - 1; j >= 0; j--) {
+                        char byte = (char) ((v >> (j * 8)) & 0xff);
+                        fwrite(&byte, 1, 1, fdest);
+					}
+				} else {
+					for (j = 0; j <= nbytes - 1; j++) {
+                        char byte = (char) ((v >> (j * 8)) & 0xff);
+						fwrite(&byte, 1, 1, fdest);
+					}
+				}
+			}
+		}
+	
+	}
+	
+	fclose(fdest);
+
+	sprintf(name,"%s.img",outfile);
+	fimgdest = fopen(name, "w");
+		if (!fimgdest) {
+			fprintf(stdout, "[ERROR] Failed to open %s for writing\n", name);
+			return 1;
+		}
+	fprintf(fimgdest, "Bpp\t%d\nColor Map\t2\nDimensions\t%d\t%d\t%d\nResolution(mm)\t%d\t%d\t%d\t\n",
+		volume->comps[0].prec,wrr,hrr,lrr,volume->comps[0].dx,volume->comps[0].dy,volume->comps[0].dz);
+
+	fclose(fimgdest);
+	return 0;
+}
+/* -->> -->> -->> -->>
+
+IMG IMAGE FORMAT
+
+<<-- <<-- <<-- <<-- */
+opj_volume_t* imgtovolume(char *fileimg, opj_cparameters_t *parameters) {
+	int subsampling_dx =  parameters->subsampling_dx;
+	int subsampling_dy =  parameters->subsampling_dy;
+	int subsampling_dz =  parameters->subsampling_dz;
+	
+	int i, compno, w, h, l, numcomps = 1;
+	int prec, max = 0, min = 0;
+	float dx, dy, dz;
+	char filename[100], tmpdirpath[100], dirpath[100], *tmp;
+	char line[100], datatype[100];
+	int bigendian;
+	
+	FILE *f = NULL;
+	FILE *fimg = NULL;
+	OPJ_COLOR_SPACE color_space;
+	opj_volume_cmptparm_t cmptparm;	/* maximum of 1 component */
+	opj_volume_t * volume = NULL;
+	opj_volume_comp_t *comp = NULL;
+
+	bigendian = 0;
+	color_space = CLRSPC_GRAY;
+
+	fimg = fopen(fileimg,"r");
+	if (!fimg) { 
+		fprintf(stderr, "[ERROR] Failed to open %s for reading !!\n", fileimg);
+		return 0;
+	}
+
+	//Fetch only the path 
+	strcpy(tmpdirpath,fileimg);
+	if ((tmp = strrchr(tmpdirpath,'/')) != NULL){
+		tmp++; *tmp='\0';
+		strcpy(dirpath,tmpdirpath);
+	} else {
+		strcpy(dirpath,"./");
+	}
+
+	fseek(fimg, 0, SEEK_SET);
+	while (!feof(fimg)) {
+        fgets(line,100,fimg);
+		//fprintf(stdout,"%s %d \n",line,feof(fimg));
+		if (strncmp(line,"Image",5) == 0){
+			sscanf(line,"%*s%*[ \t]%s",datatype);
+		} else if (strncmp(line,"File",4) == 0){
+			sscanf(line,"%*s %*s%*[ \t]%s",filename);
+			strcat(dirpath, filename);
+			strcpy(filename,dirpath);
+		} else if (strncmp(line,"Min",3) == 0){
+			sscanf(line,"%*s %*s%*[ \t]%d%*[ \t]%d",&min,&max);
+			prec = int_floorlog2(max - min + 1);
+		} else if (strncmp(line,"Bpp",3) == 0){
+			sscanf(line,"%*s%*[ \t]%d",&prec);
+		} else if (strncmp(line,"Color",5) == 0){
+			sscanf(line, "%*s %*s%*[ \t]%d",&color_space);
+		} else if (strncmp(line,"Dim",3) == 0){
+			sscanf(line, "%*s%*[ \t]%d%*[ \t]%d%*[ \t]%d",&w,&h,&l);
+		} else if (strncmp(line,"Res",3) == 0){
+			sscanf(line,"%*s%*[ \t]%f%*[ \t]%f%*[ \t]%f",&dx,&dy,&dz);
+		}
+
+	}
+	#ifdef VERBOSE
+		fprintf(stdout, "[INFO] %s %d \t %d %d %d \t %f %f %f \t %d %d %d \n",filename,color_space,w,h,l,dx,dy,dz,max,min,prec);
+	#endif
+	fclose(fimg);
+
+	/* error control */
+	if ( !prec || !w || !h || !l ){
+		fprintf(stderr,"[ERROR] Unable to read IMG file correctly. Found some null values.");	
+		return NULL;
+	}
+
+	/* initialize volume components */
+	memset(&cmptparm, 0, sizeof(opj_volume_cmptparm_t));
+	
+	cmptparm.prec = prec;
+	cmptparm.bpp = prec;
+	cmptparm.sgnd = 0;
+	cmptparm.bigendian = bigendian;
+	cmptparm.dcoffset = parameters->dcoffset;
+	cmptparm.dx = subsampling_dx;
+	cmptparm.dy = subsampling_dy;
+	cmptparm.dz = subsampling_dz;
+	cmptparm.w = w;
+	cmptparm.h = h;
+	cmptparm.l = l;
+	
+	/* create the volume */
+	volume = opj_volume_create(numcomps, &cmptparm, color_space);
+	if(!volume) {
+		fprintf(stdout,"[ERROR] Unable to create volume");	
+		return NULL;
+	}
+	
+	/* set volume offset and reference grid */
+	volume->x0 = parameters->volume_offset_x0;
+	volume->y0 = parameters->volume_offset_y0;
+	volume->z0 = parameters->volume_offset_z0;
+	volume->x1 = parameters->volume_offset_x0 + (w - 1) *	subsampling_dx + 1;
+	volume->y1 = parameters->volume_offset_y0 + (h - 1) *	subsampling_dy + 1;
+	volume->z1 = parameters->volume_offset_z0 + (l - 1) *	subsampling_dz + 1;
+	
+	max = 0;
+	/* set volume data */
+	f = fopen(filename, "rb");
+	if (!f) {
+		fprintf(stderr, "[ERROR] Failed to open %s for reading !!\n", filename);
+		fclose(f);
+		return 0;
+	}
+	
+	/* BINARY */
+	for (compno = 0; compno < volume->numcomps; compno++) {
+		int whl = w * h * l;
+		/* set volume data */
+		comp = &volume->comps[compno];
+		
+		/*if (comp->prec <= 8) {
+			if (!comp->sgnd) {
+                unsigned char *data = (unsigned char *) malloc(whl * sizeof(unsigned char));
+				fread(data, 1, whl, f);
+				for (i = 0; i < whl; i++) {
+					comp->data[i] = data[i];
+					if (comp->data[i] > max)
+						max = comp->data[i];
+				}
+				free(data);
+			} else {
+				char *data = (char *) malloc(whl);
+				fread(data, 1, whl, f);
+				for (i = 0; i < whl; i++) {
+					comp->data[i] = data[i];
+					if (comp->data[i] > max)
+						max = comp->data[i];
+				}
+				free(data);
+			}
+		} else if (comp->prec <= 16) {
+			if (!comp->sgnd) {
+                unsigned short *data = (unsigned short *) malloc(whl * sizeof(unsigned short));
+				int leido = fread(data, 2, whl, f);
+				if (!leido)	{
+					free(data);	fclose(f);
+					return NULL;
+				}
+				
+				for (i = 0; i < whl; i++) {
+					if (bigendian)	//(c1 << 8) + c2;
+						comp->data[i] = data[i];
+					else{			//(c2 << 8) + c1;
+						comp->data[i] = ShortSwap(data[i]);
+					}
+					if (comp->data[i] > max)
+						max = comp->data[i];
+				}
+				free(data);
+			} else {
+				short *data = (short *) malloc(whl);
+				int leido = fread(data, 2, whl, f);
+				if (!leido)	{
+					free(data);	fclose(f);
+					return NULL;
+				}
+				for (i = 0; i < whl; i++) {
+					if (bigendian){	//(c1 << 8) + c2;
+						comp->data[i] = data[i];
+					}else{			//(c2 << 8) + c1;
+						comp->data[i] = (short) ShortSwap((unsigned short) data[i]);
+					}
+					if (comp->data[i] > max)
+						max = comp->data[i];
+				}
+				free(data);
+			}
+		} else {
+			if (!comp->sgnd) {
+                unsigned int *data = (unsigned int *) malloc(whl * sizeof(unsigned int));
+				int leido = fread(data, 4, whl, f);
+				if (!leido)	{
+					free(data);	fclose(f);
+					return NULL;
+				}				for (i = 0; i < whl; i++) {
+					if (!bigendian)
+						comp->data[i] = LongSwap(data[i]);
+					else
+						comp->data[i] = data[i];
+					if (comp->data[i] > max)
+						max = comp->data[i];
+				}
+				free(data);
+			} else {
+				int leido = fread(comp->data, 4, whl, f);
+				if (!leido)	{
+					fclose(f);
+					return NULL;
+				}				
+				for (i = 0; i < whl; i++) {
+					if (!bigendian) 
+						comp->data[i] = (int) LongSwap((unsigned int) comp->data[i]);
+					if (comp->data[i] > max)
+						max = comp->data[i];
+				}
+			}
+		}*/
+		
+		for (i = 0; i < whl; i++) {
+			int v;
+			if (comp->prec <= 8) {
+				if (!comp->sgnd) {
+					v = readuchar(f);
+				} else {
+					v = (char) readuchar(f);
+				}
+			} else if (comp->prec <= 16) {
+				if (!comp->sgnd) {
+					v = readushort(f, bigendian);
+				} else {
+					v = (short) readushort(f, bigendian);
+				}
+			} else {
+				if (!comp->sgnd) {
+					v = readuint(f, bigendian);
+				} else {
+					v = (int) readuint(f, bigendian);
+				}
+			}
+			if (v > max)
+				max = v;
+			comp->data[i] = v;
+		}
+		comp->bpp = int_floorlog2(max) + 1;
+	}
+	fclose(f);
+	return volume;
+}
+
diff --git a/src/bin/jp3d/convert.h b/src/bin/jp3d/convert.h
new file mode 100755
index 00000000..85885561
--- /dev/null
+++ b/src/bin/jp3d/convert.h
@@ -0,0 +1,51 @@
+/*

+ * Copyright (c) 2001-2003, David Janssens

+ * Copyright (c) 2002-2003, Yannick Verschueren

+ * Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe

+ * Copyright (c) 2005, Herve Drolon, FreeImage Team

+ * Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium

+ * Copyright (c) 2006, Mónica Díez García, Image Processing Laboratory, University of Valladolid, Spain

+ * 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 __JP3D_CONVERT_H

+#define __JP3D_CONVERT_H

+

+/**

+Load a single volume component encoded in PGX file format

+@param filename Name of the PGX file to load

+@param parameters *List ?*

+@return Returns a greyscale volume if successful, returns NULL otherwise

+*/

+opj_volume_t* pgxtovolume(char *filename, opj_cparameters_t *parameters);

+

+int volumetopgx(opj_volume_t *volume, char *outfile);

+

+opj_volume_t* bintovolume(char *filename,char *fileimg, opj_cparameters_t *parameters);

+

+int volumetobin(opj_volume_t *volume, char *outfile);

+

+opj_volume_t* imgtovolume(char *fileimg, opj_cparameters_t *parameters);

+

+#endif /* __J2K_CONVERT_H */

+

diff --git a/src/bin/jp3d/getopt.c b/src/bin/jp3d/getopt.c
new file mode 100755
index 00000000..69addc97
--- /dev/null
+++ b/src/bin/jp3d/getopt.c
@@ -0,0 +1,109 @@
+/*

+ * Copyright (c) 1987, 1993, 1994

+ *	The Regents of the University of California.  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.

+ * 3. All advertising materials mentioning features or use of this software

+ *    must display the following acknowledgement:

+ *	This product includes software developed by the University of

+ *	California, Berkeley and its contributors.

+ * 4. Neither the name of the University nor the names of its contributors

+ *    may be used to endorse or promote products derived from this software

+ *    without specific prior written permission.

+ *

+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.

+ */

+

+/* last review : october 29th, 2002 */

+

+#if defined(LIBC_SCCS) && !defined(lint)

+static char sccsid[] = "@(#)getopt.c	8.3 (Berkeley) 4/27/95";

+#endif				/* LIBC_SCCS and not lint */

+

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+

+int opterr = 1,			/* if error message should be printed */

+ optind = 1,			/* index into parent argv vector */

+ optopt,				/* character checked for validity */

+ optreset;				/* reset getopt */

+char *optarg;			/* argument associated with option */

+

+#define	BADCH	(int)'?'

+#define	BADARG	(int)':'

+#define	EMSG	""

+

+/*

+ * getopt --

+ *	Parse argc/argv argument vector.

+ */

+int getopt(int nargc, char *const *nargv, const char *ostr) {

+	

+  #  define __progname nargv[0] /* program name */

+	

+  static char *place = EMSG;	/* option letter processing */

+  char *oli;					/* option letter list index */

+

+  if (optreset || !*place) {	/* update scanning pointer */

+    optreset = 0;

+    if (optind >= nargc || *(place = nargv[optind]) != '-') {

+      place = EMSG;

+      return (-1);

+    }

+    if (place[1] && *++place == '-') {	/* found "--" */

+      ++optind;

+      place = EMSG;

+      return (-1);

+    }

+  }	/* option letter okay? */

+  

+  if ((optopt = (int) *place++) == (int) ':' || !(oli = strchr(ostr, optopt))) {

+    /* if the user didn't specify '-' as an option, assume it means -1. */

+    if (optopt == (int) '-')

+      return (-1);

+    if (!*place)

+      ++optind;

+    if (opterr && *ostr != ':')

+      (void) fprintf(stdout,"[ERROR] %s: illegal option -- %c\n", __progname, optopt);

+    return (BADCH);

+  }

+

+  if (*++oli != ':') {		/* don't need argument */

+    optarg = NULL;

+    if (!*place)

+      ++optind;

+  } else {					/* need an argument */

+    if (*place)						/* no white space */

+      optarg = place;

+    else if (nargc <= ++optind) {	/* no arg */

+      place = EMSG;

+      if (*ostr == ':')

+		return (BADARG);

+      if (opterr)

+		(void) fprintf(stdout, "[ERROR] %s: option requires an argument -- %c\n", __progname, optopt);

+      return (BADCH);

+    } else							/* white space */

+      optarg = nargv[optind];

+    place = EMSG;

+    ++optind;

+  }

+  return (optopt);		/* dump back option letter */

+}

diff --git a/src/bin/jp3d/getopt.h b/src/bin/jp3d/getopt.h
new file mode 100755
index 00000000..23299d1b
--- /dev/null
+++ b/src/bin/jp3d/getopt.h
@@ -0,0 +1,14 @@
+/* last review : october 29th, 2002 */

+

+#ifndef _GETOPT_H_

+#define _GETOPT_H_

+

+extern int opterr;

+extern int optind;

+extern int optopt;

+extern int optreset;

+extern char *optarg;

+

+extern int getopt(int nargc, char *const *nargv, const char *ostr);

+

+#endif				/* _GETOPT_H_ */

diff --git a/src/bin/jp3d/jp3d_to_volume.c b/src/bin/jp3d/jp3d_to_volume.c
new file mode 100755
index 00000000..7afb4488
--- /dev/null
+++ b/src/bin/jp3d/jp3d_to_volume.c
@@ -0,0 +1,540 @@
+/*

+ * Copyright (c) 2001-2003, David Janssens

+ * Copyright (c) 2002-2003, Yannick Verschueren

+ * Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe

+ * Copyright (c) 2005, Herve Drolon, FreeImage Team

+ * Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium

+ * Copyright (c) 2006, Mónica Díez García, Image Processing Laboratory, University of Valladolid, Spain

+ * 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 <stdlib.h>

+#include <math.h>

+

+#include "openjp3d.h"

+#include "getopt.h"

+#include "convert.h"

+

+#ifdef _WIN32

+#include <windows.h>

+#else

+#define stricmp strcasecmp

+#define strnicmp strncasecmp

+#endif /* _WIN32 */

+

+/* ----------------------------------------------------------------------- */

+static double calc_PSNR(opj_volume_t *original, opj_volume_t *decoded)

+{

+	int max, i, k, compno = 0, size;

+	double sum, total = 0;

+	int global = 1;

+    

+	max = (original->comps[compno].prec <= 8) ? 255 : (1 << original->comps[compno].prec) - 1;

+	if (global) {

+		size = (original->x1 - original->x0) * (original->y1 - original->y0) * (original->z1 - original->z0);

+

+		for (compno = 0; compno < original->numcomps; compno++) {

+			for(sum = 0, i = 0; i < size; ++i) {

+				if ((decoded->comps[compno].data[i] < 0) || (decoded->comps[compno].data[i] > max))

+					fprintf(stdout,"[WARNING] Data out of range during PSNR computing...\n");

+				else

+					sum += (original->comps[compno].data[i] - decoded->comps[compno].data[i]) * (original->comps[compno].data[i] - decoded->comps[compno].data[i]);        

+			}

+		}

+		sum /= size;

+		total = ((sum==0.0) ? 0.0 : 10 * log10(max * max / sum));

+	} else {

+		size = (original->x1 - original->x0) * (original->y1 - original->y0);

+

+		for (k = 0; k < original->z1 - original->z0; k++) {

+			int offset = k * size;

+			for (sum = 0, compno = 0; compno < original->numcomps; compno++) {

+				for(i = 0; i < size; ++i) {

+					if ((decoded->comps[compno].data[i + offset] < 0) || (decoded->comps[compno].data[i + offset] > max))

+						fprintf(stdout,"[WARNING] Data out of range during PSNR computing...\n");

+					else

+						sum += (original->comps[compno].data[i + offset] - decoded->comps[compno].data[i + offset]) * (original->comps[compno].data[i + offset] - decoded->comps[compno].data[i + offset]);        

+				}

+			}

+			sum /= size;

+			total = total + ((sum==0.0) ? 0.0 : 10 * log10(max * max / sum));

+		}

+

+	}

+	if(total == 0) /* perfect reconstruction, PSNR should return infinity */

+		return -1.0;

+	

+	return total;

+	//return 20 * log10((max - 1) / sqrt(sum));

+}

+

+static double calc_SSIM(opj_volume_t *original, opj_volume_t *decoded)

+{

+	int max, i, compno = 0, size, sizeM;

+	double sum;

+	double mux = 0.0, muy = 0.0, sigmax = 0.0, sigmay = 0.0,

+		sigmaxy = 0.0, structx = 0.0, structy = 0.0;

+	double lcomp,ccomp,scomp;

+	double C1,C2,C3;

+

+	max = (original->comps[compno].prec <= 8) ? 255 : (1 << original->comps[compno].prec) - 1;

+	size = (original->x1 - original->x0) * (original->y1 - original->y0) * (original->z1 - original->z0);

+

+	//MSSIM

+

+//	sizeM = size / (original->z1 - original->z0);

+

+	sizeM = size;	

+	for(sum = 0, i = 0; i < sizeM; ++i) {

+		// First, the luminance of each signal is compared.

+		mux += original->comps[compno].data[i];

+		muy += decoded->comps[compno].data[i];

+	}

+	mux /= sizeM;

+	muy /= sizeM;

+	

+	//We use the standard deviation (the square root of variance) as an estimate of the signal contrast.

+    for(sum = 0, i = 0; i < sizeM; ++i) {

+		// First, the luminance of each signal is compared.

+		sigmax += (original->comps[compno].data[i] - mux) * (original->comps[compno].data[i] - mux);

+		sigmay += (decoded->comps[compno].data[i] - muy) * (decoded->comps[compno].data[i] - muy);

+		sigmaxy += (original->comps[compno].data[i] - mux) * (decoded->comps[compno].data[i] - muy);

+	}

+	sigmax /= sizeM - 1;

+	sigmay /= sizeM - 1;

+	sigmaxy /= sizeM - 1;

+	

+	sigmax = sqrt(sigmax);

+	sigmay = sqrt(sigmay);

+	sigmaxy = sqrt(sigmaxy);

+

+	//Third, the signal is normalized (divided) by its own standard deviation, 

+	//so that the two signals being compared have unit standard deviation.

+

+	//Luminance comparison

+	C1 = (0.01 * max) * (0.01 * max);

+	lcomp = ((2 * mux * muy) + C1)/((mux*mux) + (muy*mux) + C1);

+	//Constrast comparison

+	C2 = (0.03 * max) * (0.03 * max);

+	ccomp = ((2 * sigmax * sigmay) + C2)/((sigmax*sigmax) + (sigmay*sigmay) + C2);

+	//Structure comparison

+	C3 = C2 / 2;

+	scomp = (sigmaxy + C3) / (sigmax * sigmay + C3);

+	//Similarity measure

+

+	sum = lcomp * ccomp * scomp;

+	return sum;

+}

+

+void decode_help_display() {

+	fprintf(stdout,"HELP\n----\n\n");

+	fprintf(stdout,"- the -h option displays this help information on screen\n\n");

+

+	fprintf(stdout,"List of parameters for the JPEG 2000 encoder:\n");

+	fprintf(stdout,"\n");

+	fprintf(stdout," Required arguments \n");

+	fprintf(stdout," ---------------------------- \n");

+	fprintf(stdout,"  -i <compressed file> ( *.jp3d, *.j3d )\n");

+	fprintf(stdout,"    Currently accepts J3D-files. The file type is identified based on its suffix.\n");

+	fprintf(stdout,"  -o <decompressed file> ( *.pgx, *.bin )\n");

+	fprintf(stdout,"    Currently accepts PGX-files and BIN-files. Binary data is written to the file (not ascii). \n");

+	fprintf(stdout,"    If a PGX filename is given, there will be as many output files as slices; \n");

+	fprintf(stdout,"    an indice starting from 0 will then be appended to the output filename,\n");

+	fprintf(stdout,"    just before the \"pgx\" extension.\n");

+	fprintf(stdout,"  -m <characteristics file> ( *.img ) \n");

+	fprintf(stdout,"    Required only for BIN-files. Ascii data of volume characteristics is written. \n");

+	fprintf(stdout,"\n");

+	fprintf(stdout," Optional  \n");

+	fprintf(stdout," ---------------------------- \n");

+	fprintf(stdout,"  -h \n ");

+	fprintf(stdout,"    Display the help information\n");

+	fprintf(stdout,"  -r <RFx,RFy,RFz>\n");

+	fprintf(stdout,"    Set the number of highest resolution levels to be discarded on each dimension. \n");

+	fprintf(stdout,"    The volume resolution is effectively divided by 2 to the power of the\n");

+	fprintf(stdout,"    number of discarded levels. The reduce factor is limited by the\n");

+	fprintf(stdout,"    smallest total number of decomposition levels among tiles.\n");

+	fprintf(stdout,"  -l <number of quality layers to decode>\n");

+	fprintf(stdout,"    Set the maximum number of quality layers to decode. If there are\n");

+	fprintf(stdout,"    less quality layers than the specified number, all the quality layers\n");

+	fprintf(stdout,"    are decoded. \n");

+	fprintf(stdout,"  -O original-file \n");

+    fprintf(stdout,"    This option offers the possibility to compute some quality results  \n");

+	fprintf(stdout,"    for the decompressed volume, like the PSNR value achieved or the global SSIM value.  \n");

+	fprintf(stdout,"    Needs the original file in order to compare with the new one.\n");

+    fprintf(stdout,"    NOTE: Only valid when -r option is 0,0,0 (both original and decompressed volumes have same resolutions) \n");

+    fprintf(stdout,"    NOTE: If original file is .BIN file, the volume characteristics file shall be defined with the -m option. \n");

+	fprintf(stdout,"    (i.e. -O original-BIN-file -m original-IMG-file) \n");

+	fprintf(stdout,"  -BE \n");

+	fprintf(stdout,"    Define that the recovered volume data will be saved with big endian byte order.\n");

+	fprintf(stdout,"    By default, little endian byte order is used.\n");

+	fprintf(stdout,"\n");

+}

+

+/* -------------------------------------------------------------------------- */

+

+int get_file_format(char *filename) {

+	int i;

+	static const char *extension[] = {"pgx", "bin", "j3d", "jp3d", "j2k", "img"};

+	static const int format[] = { PGX_DFMT, BIN_DFMT, J3D_CFMT, J3D_CFMT, J2K_CFMT, IMG_DFMT};

+	char * ext = strrchr(filename, '.');

+	if(ext) {

+		ext++;

+		for(i = 0; i < sizeof(format) / sizeof(format[0]); i++) {

+			if(strnicmp(ext, extension[i], 3) == 0) {

+				return format[i];

+			}

+		}

+	}

+

+	return -1;

+}

+

+/* -------------------------------------------------------------------------- */

+

+int parse_cmdline_decoder(int argc, char **argv, opj_dparameters_t *parameters) {

+	/* parse the command line */

+

+	while (1) {

+		int c = getopt(argc, argv, "i:o:O:r:l:B:m:h");

+		if (c == -1)			  

+			break;

+		switch (c) {

+			case 'i':			/* input file */

+			{

+				char *infile = optarg;

+				parameters->decod_format = get_file_format(infile);

+				switch(parameters->decod_format) {

+					case J3D_CFMT:

+					case J2K_CFMT:

+						break;

+					default:

+						fprintf(stdout, "[ERROR] Unknown format for infile %s [only *.j3d]!! \n", infile);

+						return 1;

+						break;

+				}

+				strncpy(parameters->infile, infile, MAX_PATH);

+				fprintf(stdout,	"[INFO] Infile: %s \n", parameters->infile);

+

+			}

+			break;

+

+			case 'm':			/* img file */

+			{

+				char *imgfile = optarg;

+				int imgformat = get_file_format(imgfile);

+				switch(imgformat) {

+					case IMG_DFMT:

+						break;

+					default:

+						fprintf(stdout,	"[ERROR] Unrecognized format for imgfile : %s [accept only *.img] !!\n\n", imgfile);

+						return 1;

+						break;

+				}

+				strncpy(parameters->imgfile, imgfile, MAX_PATH);

+				fprintf(stdout,	"[INFO] Imgfile: %s Format: %d\n", parameters->imgfile, imgformat);

+			}

+			break;

+				

+				/* ----------------------------------------------------- */

+

+			case 'o':			/* output file */

+			{

+				char *outfile = optarg;

+				parameters->cod_format = get_file_format(outfile);

+				switch(parameters->cod_format) {

+					case PGX_DFMT:

+					case BIN_DFMT:

+						break;

+					default:

+						fprintf(stdout,	"[ERROR] Unrecognized format for outfile : %s [accept only *.pgx or *.bin] !!\n\n", outfile);

+						return 1;

+						break;

+				}

+				strncpy(parameters->outfile, outfile, MAX_PATH);

+				fprintf(stdout,	"[INFO] Outfile: %s \n", parameters->outfile);

+

+			}

+			break;

+			

+				/* ----------------------------------------------------- */

+

+			case 'O':		/* Original image for PSNR computing */

+			{

+				char *original = optarg;

+				parameters->orig_format = get_file_format(original);

+				switch(parameters->orig_format) {

+					case PGX_DFMT:

+					case BIN_DFMT:

+						break;

+					default:

+						fprintf(stdout,	"[ERROR] Unrecognized format for original file : %s [accept only *.pgx or *.bin] !!\n\n", original);

+						return 1;

+						break;

+				}

+				strncpy(parameters->original, original, MAX_PATH);

+				fprintf(stdout,	"[INFO] Original file: %s \n", parameters->original);

+			}

+			break;

+

+				/* ----------------------------------------------------- */

+	    

+			case 'r':		/* reduce option */

+			{

+				//sscanf(optarg, "%d, %d, %d", &parameters->cp_reduce[0], &parameters->cp_reduce[1], &parameters->cp_reduce[2]);

+				int aux;

+				aux = sscanf(optarg, "%d,%d,%d", &parameters->cp_reduce[0], &parameters->cp_reduce[1], &parameters->cp_reduce[2]);

+				if (aux == 2) 

+					parameters->cp_reduce[2] = 0;

+				else if (aux == 1) {

+					parameters->cp_reduce[1] = parameters->cp_reduce[0];

+					parameters->cp_reduce[2] = 0;

+				}else if (aux == 0){

+					parameters->cp_reduce[0] = 0;

+					parameters->cp_reduce[1] = 0;

+					parameters->cp_reduce[2] = 0;

+				}

+			}

+			break;

+			

+				/* ----------------------------------------------------- */

+

+			case 'l':		/* layering option */

+			{

+				sscanf(optarg, "%d", &parameters->cp_layer);

+			}

+			break;

+

+				/* ----------------------------------------------------- */

+

+			case 'B':		/* BIGENDIAN vs. LITTLEENDIAN */

+			{

+				parameters->bigendian = 1;

+			}

+			break;

+			

+				/* ----------------------------------------------------- */

+

+			case 'L':		/* BIGENDIAN vs. LITTLEENDIAN */

+			{

+				parameters->decod_format = LSE_CFMT;

+			}

+			break;

+			

+			/* ----------------------------------------------------- */

+			

+			case 'h': 			/* display an help description */

+			{

+				decode_help_display();

+				return 1;

+			}

+			break;

+            

+				/* ----------------------------------------------------- */

+			

+			default:

+				fprintf(stdout,"[WARNING] This option is not valid \"-%c %s\"\n",c, optarg);

+				break;

+		}

+	}

+

+	/* check for possible errors */

+

+	if((parameters->infile[0] == 0) || (parameters->outfile[0] == 0)) {

+		fprintf(stdout,"[ERROR] At least one required argument is missing\n Check jp3d_to_volume -help for usage information\n");

+		return 1;

+	}

+

+	return 0;

+}

+

+/* -------------------------------------------------------------------------- */

+

+/**

+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) {

+	fprintf(stdout, "[INFO] %s", msg);

+}

+

+/* -------------------------------------------------------------------------- */

+

+int main(int argc, char **argv) {

+

+	opj_dparameters_t parameters;	/* decompression parameters */

+	opj_event_mgr_t event_mgr;		/* event manager */

+	opj_volume_t *volume = NULL;

+

+	opj_volume_t *original = NULL;

+	opj_cparameters_t cparameters;	/* original parameters */

+

+	FILE *fsrc = NULL;

+	unsigned char *src = NULL; 

+	int file_length;

+	int decodeok;

+	double psnr, ssim;

+

+	opj_dinfo_t* dinfo = NULL;	/* handle to a decompressor */

+	opj_cio_t *cio = NULL;

+

+	/* 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;

+

+	/* set decoding parameters to default values */

+	opj_set_default_decoder_parameters(&parameters);

+

+    /* parse input and get user decoding parameters */

+	strcpy(parameters.original,"NULL");

+	strcpy(parameters.imgfile,"NULL");

+	if(parse_cmdline_decoder(argc, argv, &parameters) == 1) {

+		return 0;

+	}

+	

+	/* read the input file and put it in memory */

+	/* ---------------------------------------- */

+	fprintf(stdout, "[INFO] Loading %s file \n",parameters.decod_format==J3D_CFMT ? ".jp3d" : ".j2k");

+	fsrc = fopen(parameters.infile, "rb");

+	if (!fsrc) {

+		fprintf(stdout, "[ERROR] Failed to open %s for reading\n", parameters.infile);

+		return 1;

+	}  

+	fseek(fsrc, 0, SEEK_END);

+	file_length = ftell(fsrc);

+	fseek(fsrc, 0, SEEK_SET);

+	src = (unsigned char *) malloc(file_length);

+	fread(src, 1, file_length, fsrc);

+	fclose(fsrc);

+	

+	/* decode the code-stream */

+	/* ---------------------- */

+	if (parameters.decod_format == J3D_CFMT || parameters.decod_format == J2K_CFMT) {		

+		/* get a JP3D or J2K decoder handle */

+		if (parameters.decod_format == J3D_CFMT) 

+			dinfo = opj_create_decompress(CODEC_J3D);

+		else if (parameters.decod_format == J2K_CFMT) 

+			dinfo = opj_create_decompress(CODEC_J2K);

+

+		/* 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, src, file_length);

+

+		/* decode the stream and fill the volume structure */

+		volume = opj_decode(dinfo, cio);

+		if(!volume) {

+			fprintf(stdout, "[ERROR] jp3d_to_volume: failed to decode volume!\n");				

+			opj_destroy_decompress(dinfo);

+			opj_cio_close(cio);

+			return 1;

+		}	

+

+		/* close the byte stream */

+		opj_cio_close(cio);

+	}

+  

+	/* free the memory containing the code-stream */

+	free(src);

+	src = NULL;

+

+	/* create output volume */

+	/* ------------------- */

+

+	switch (parameters.cod_format) {

+		case PGX_DFMT:			/* PGX */

+			decodeok = volumetopgx(volume, parameters.outfile);

+			if (decodeok)

+				fprintf(stdout,"[ERROR] Unable to write decoded volume into pgx files\n");

+			break;

+		

+		case BIN_DFMT:			/* BMP */

+			decodeok = volumetobin(volume, parameters.outfile);

+			if (decodeok)

+				fprintf(stdout,"[ERROR] Unable to write decoded volume into pgx files\n");

+			break;

+	}

+	switch (parameters.orig_format) {

+		case PGX_DFMT:			/* PGX */

+			if (strcmp("NULL",parameters.original) != 0){

+ 				fprintf(stdout,"Loading original file %s \n",parameters.original);

+				cparameters.subsampling_dx = 1;	cparameters.subsampling_dy = 1;	cparameters.subsampling_dz = 1;

+				cparameters.volume_offset_x0 = 0;cparameters.volume_offset_y0 = 0;cparameters.volume_offset_z0 = 0;

+				original = pgxtovolume(parameters.original,&cparameters);

+			}

+			break;

+		

+		case BIN_DFMT:			/* BMP */

+			if (strcmp("NULL",parameters.original) != 0 && strcmp("NULL",parameters.imgfile) != 0){

+				fprintf(stdout,"Loading original file %s %s\n",parameters.original,parameters.imgfile);

+				cparameters.subsampling_dx = 1;	cparameters.subsampling_dy = 1;	cparameters.subsampling_dz = 1;

+				cparameters.volume_offset_x0 = 0;cparameters.volume_offset_y0 = 0;cparameters.volume_offset_z0 = 0;

+				original = bintovolume(parameters.original,parameters.imgfile,&cparameters);

+			}

+			break;

+	}

+

+	fprintf(stdout, "[RESULT] Volume: %d x %d x %d (x %d bpv)\n ", 

+			 (volume->comps[0].w >> volume->comps[0].factor[0]),

+			 (volume->comps[0].h >> volume->comps[0].factor[1]),

+			 (volume->comps[0].l >> volume->comps[0].factor[2]),volume->comps[0].prec);

+

+	if(original){

+		psnr = calc_PSNR(original,volume);

+		ssim = calc_SSIM(original,volume);

+		if (psnr < 0.0)

+			fprintf(stdout, "  PSNR: Inf , SSMI %f -- Perfect reconstruction!\n",ssim);

+		else

+			fprintf(stdout, "  PSNR: %f , SSIM %f \n",psnr,ssim);

+	}

+	/* free remaining structures */

+	if(dinfo) {

+		opj_destroy_decompress(dinfo);

+	}

+

+	/* free volume data structure */

+	opj_volume_destroy(volume);

+   

+	return 0;

+}

+

diff --git a/src/bin/jp3d/tcltk/LPI_JP3D_VM.tcl b/src/bin/jp3d/tcltk/LPI_JP3D_VM.tcl
new file mode 100755
index 00000000..37657b27
--- /dev/null
+++ b/src/bin/jp3d/tcltk/LPI_JP3D_VM.tcl
@@ -0,0 +1,115 @@
+#!/bin/sh
+# The next line is executed by /bin/sh, but not tcl \
+exec wish "$0" ${1+"$@"}
+lappend auto_path /usr/share/tcltk/bwidget1.9.2
+
+namespace eval jp3dVM {
+
+    variable _progress 0
+    variable _afterid  ""
+    variable _status "Compute in progress..."
+    variable notebook
+    variable mainframe
+    variable dataout "Process execution information"
+    variable status
+    variable prgtext
+    variable prgindic
+
+    set pwd [pwd]
+    cd [file dirname [info script]]
+    variable VMDIR [pwd]
+    cd $pwd
+
+    foreach script {encoder.tcl decoder.tcl} {
+	namespace inscope :: source $VMDIR/$script
+    }
+}
+
+
+proc jp3dVM::create { } {
+    variable notebook
+    variable mainframe
+    variable dataout
+
+    bind all <F12> { catch {console show} }
+
+    # Menu description
+    set descmenu {
+        "&File" {} {} 0 {
+            {command "E&xit" {} "Exit BWidget jp3dVM" {} -command exit}
+        }
+        "&Options" {} {} 0 {
+            {command "&Encode" {} "Show encoder" {}
+                -command  {$jp3dVM::notebook raise [$jp3dVM::notebook page 0]}
+            }
+            {command "&Decode" {} "Show decoder" {}
+                -command  {$jp3dVM::notebook raise [$jp3dVM::notebook page 1]}
+            }
+        }
+	"&Help" {} {} 0 {
+            {command "&About authors..." {} "Show info about authors" {} 
+		-command {MessageDlg .msgdlg -parent . -title "About authors" -message " Copyright @ LPI-UVA 2006 " -type ok -icon info}}
+        }
+    }
+
+    set mainframe [MainFrame .mainframe \
+                       -menu         $descmenu \
+                       -textvariable jp3dVM::status \
+                       -progressvar  jp3dVM::prgindic]
+
+    $mainframe addindicator -text "JP3D Verification Model 1.0.0"
+
+    # NoteBook creation
+    set frame    [$mainframe getframe]
+    set notebook [NoteBook $frame.nb]
+
+    set logo [frame $frame.logo]
+    #creo imagen logo
+    image create photo LPIimg -file logoLPI.gif
+    set logoimg [Label $logo.logoimg -image LPIimg]
+    
+    set f0  [VMEncoder::create $notebook]
+    set f1  [VMDecoder::create $notebook]
+
+	set tfinfo [TitleFrame $frame.codinfo -text "Program Execution"]
+	set codinfo [$tfinfo getframe]
+	set sw [ScrolledWindow $codinfo.sw -relief sunken -borderwidth 2 -scrollbar both]
+	set sf [ScrollableFrame $codinfo.sf ]
+	$sw setwidget $sf
+	set subf [$sf getframe]
+	set labinfo [label $subf.labinfo -textvariable jp3dVM::dataout -justify left]
+
+	pack $labinfo -side left 
+	pack $sw 
+
+    $notebook compute_size
+    $notebook raise [$notebook page 0]
+
+    pack $logoimg -side left -fill x -expand yes 
+    pack $notebook -expand yes 
+    pack $logo $tfinfo -side left -expand yes 
+    pack $mainframe -fill both -expand yes
+    update idletasks
+}
+
+
+proc jp3dVM::main {} {
+    variable VMDIR
+
+    lappend ::auto_path [file dirname $VMDIR]
+    namespace inscope :: package require BWidget
+
+    option add *TitleFrame.l.font {helvetica 11 bold italic}
+
+    wm withdraw .
+    wm title . "JP3D Verification Model @ LPI"
+
+    jp3dVM::create
+    BWidget::place . 0 0 center
+    wm deiconify .
+    raise .
+    focus -force .
+}
+
+jp3dVM::main
+wm geom . [wm geom .]
diff --git a/src/bin/jp3d/tcltk/README b/src/bin/jp3d/tcltk/README
new file mode 100644
index 00000000..f4e2e359
--- /dev/null
+++ b/src/bin/jp3d/tcltk/README
@@ -0,0 +1,13 @@
+HOWTO USE THE TCL/TK APP IN 'jp3d/tcltk'
+----------------------------------------
+1. Download the 'BWidget-1.9.2'
+    http://www.sourceforge.net/projects/tcllib/
+
+2. Install it e.g. in '/usr/local/BWidget-1.9.2/'
+3. Add the lappend command in line 4
+  to jp3d/tcltk/LPI_JP3D_VM.tcl:
+
+#!/bin/sh
+# The next line is executed by /bin/sh, but not tcl \
+exec wish "$0" ${1+"$@"}
+lappend auto_path /usr/local/BWidget-1.9.2
diff --git a/src/bin/jp3d/tcltk/Thumbs.db b/src/bin/jp3d/tcltk/Thumbs.db
new file mode 100755
index 00000000..5d6ffdf9
--- /dev/null
+++ b/src/bin/jp3d/tcltk/Thumbs.db
diff --git a/src/bin/jp3d/tcltk/decoder.tcl b/src/bin/jp3d/tcltk/decoder.tcl
new file mode 100755
index 00000000..98edcde9
--- /dev/null
+++ b/src/bin/jp3d/tcltk/decoder.tcl
@@ -0,0 +1,272 @@
+

+namespace eval VMDecoder {

+	variable var

+	variable JP3Ddecoder "../bin/jp3d_to_volume.exe"

+	#variable JP3Ddecoder "jp3d_to_volume.exe"

+}

+

+

+proc VMDecoder::create { nb } {

+	variable var

+

+	set frameD [$nb insert end VMDecoder -text "Decoder"]

+	set topfD	[frame $frameD.topfD]

+	set medfD	[frame $frameD.medfD]

+	set bottomfD	[frame $frameD.bottomfD]

+	set srcfD [TitleFrame $topfD.srcfD -text "Source"]

+	set dstfD [TitleFrame $topfD.dstfD -text "Destination"]

+	set paramfD [TitleFrame $medfD.paramfD -text "Decoding parameters"]

+	set infofD [TitleFrame $medfD.infofD -text "Distortion measures"]

+

+	set frame1 [$srcfD getframe]

+	_sourceD  $frame1

+	set frame2  [$dstfD getframe]

+	_destinationD  $frame2

+	set frame3  [$infofD getframe]

+	_originalD $frame3

+	set frame4  [$paramfD getframe]

+	_paramsD $frame4

+

+	set butD   [Button $bottomfD.butD -text "Decode!" \

+		   -command  "VMDecoder::_decode $frame1 $frame2 $frame3" \

+		   -helptext "Decoding trigger button"]

+	set butR   [Button $bottomfD.butR -text "Save info" \

+		   -command  "VMDecoder::_save $frame3" \

+		   -helptext "Save information"]

+	

+	pack $srcfD $dstfD -side left -fill both -padx 10 -ipadx 5 -expand yes

+	pack $topfD -pady 4 -fill x

+	

+	pack $paramfD $infofD -side left -fill both -padx 10 -pady 2 -ipadx 5 -expand yes

+	pack $medfD -pady 4 -fill x 

+

+	pack $butD $butR -side left -padx 4 -pady 5 -expand yes

+	pack $bottomfD -pady 4 -fill x

+

+return $frameD

+}

+

+

+proc fileDialogD {w ent operation} {

+

+	variable file

+	

+	if {$operation == "open"} {

+		#-----Type names---------Extension(s)---

+		set types {

+		{"JP3D Files"	   {.jp3d}	}

+		{"All files"		*}

+		}

+		set file [tk_getOpenFile -filetypes $types -parent $w ]

+	} elseif {$operation == "original"} {

+		#-----Type names---------Extension(s)---

+		set types {

+		{"BIN Raw Image Files"  {.bin}  }

+		{"PGX Raw Image Files"	{.pgx}	}

+		{"All files"		*}

+		}

+		set file [tk_getOpenFile -filetypes $types -parent $w ]

+	} else {

+		#-----Type names---------Extension(s)---

+		set types {

+		{"BIN Raw Image Files"  {.bin}  }

+		{"PGX Raw Image Files"	{.pgx}	}

+		{"All files"		*}

+		}

+		set file [tk_getSaveFile -filetypes $types -parent $w -initialfile Untitled -defaultextension "*.bin"]

+	}

+	if {[string compare $file ""]} {

+		$ent delete 0 end

+		$ent insert end $file

+		$ent xview moveto 1

+	}

+}

+

+proc VMDecoder::_sourceD { parent } {

+	

+	variable var

+	

+	set labsrcD [LabelFrame $parent.labsrcD -text "Select compressed file: " -side top \

+			-anchor w -relief flat -borderwidth 0]

+	set subsrcD [$labsrcD getframe]

+	set listD [entry $subsrcD.entrysrcD -width 40 -textvariable VMDecoder::var(sourceD)]

+	

+	set labbrw [LabelFrame $parent.labbrw -side top -anchor w -relief flat -borderwidth 0]

+	set subbrw [$labbrw getframe]

+	set butbrw [button $subbrw.butbrw -image [Bitmap::get open] \

+		-relief raised -borderwidth 1 -padx 1 -pady 1 \

+		-command "fileDialogD . $subsrcD.entrysrcD open"]

+	

+	pack $listD -side top

+	pack $butbrw -side top

+	pack $labsrcD $labbrw -side left -fill both -expand yes

+

+

+}

+

+proc VMDecoder::_destinationD { parent } {

+	

+	variable var

+	

+	set labdstD [LabelFrame $parent.labdstD -text "Save decompressed volume file(s) as: " -side top \

+			-anchor w -relief flat -borderwidth 0]

+	set subdstD [$labdstD getframe]

+	set listD [entry $subdstD.entrydstD -width 40 -textvariable VMDecoder::var(destinationD)]

+	

+	set labbrw [LabelFrame $parent.labbrw -side top -anchor w -relief flat -borderwidth 0]

+	set subbrw [$labbrw getframe]

+	set butbrw [button $subbrw.butbrw -image [Bitmap::get save] \

+		-relief raised -borderwidth 1 -padx 1 -pady 1 \

+		-command "fileDialogD . $subdstD.entrydstD save"]

+

+	pack $listD -side top

+	pack $butbrw -side top

+	pack $labdstD $labbrw -side left -fill both -expand yes

+}

+

+proc VMDecoder::_originalD { parent } {

+	

+	variable var

+	

+	set laborgD [LabelFrame $parent.laborgD -text "Select original file: " -side top \

+			-anchor w -relief flat -borderwidth 0]

+	set suborgD [$laborgD getframe]

+	set listorgD [entry $suborgD.entryorgD -width 30 -textvariable VMDecoder::var(originalD)]

+	

+	set labbrw2 [LabelFrame $parent.labbrw2 -side top -anchor w -relief flat -borderwidth 0]

+	set subbrw2 [$labbrw2 getframe]

+	set butbrw2 [button $subbrw2.butbrw2 -image [Bitmap::get open] \

+		-relief raised -borderwidth 1 -padx 1 -pady 1 \

+		-command "fileDialogD . $suborgD.entryorgD original"]

+	

+	set infoD [Label $parent.infoD -relief sunken -textvariable VMDecoder::var(decodinfo) -justify left]

+

+	pack $listorgD -side left -anchor n

+	pack $butbrw2 -side left -anchor n

+	pack $infoD -side bottom -anchor nw -pady 4 -ipadx 150 -ipady 20 -expand yes

+	pack $laborgD $labbrw2 -side left -fill both 

+

+

+}

+

+proc VMDecoder::_paramsD { parent } {

+	

+	variable var

+	

+	########### DECODING  #############

+	set labcod [LabelFrame $parent.labcod -side top -anchor w -relief sunken -borderwidth 1]

+	set subcod  [$labcod getframe]

+

+		set frameres [frame $subcod.frameres -borderwidth 1]

+		set labres [LabelEntry $frameres.labres -label "Resolutions to discard: " -labelwidth 20 -labelanchor w \

+                   -textvariable VMDecoder::var(resdiscard) -editable 1 \

+                   -helptext "Number of highest resolution levels to be discarded on each dimension" ]

+	set VMDecoder::var(resdiscard) "0,0,0"

+	

+		set framelayer [frame $subcod.framelayer -borderwidth 1]

+		set lablayer [LabelEntry $framelayer.lablayer -label "Layers to decode: " -labelwidth 20 -labelanchor w \

+                   -textvariable VMDecoder::var(layer) -editable 1 \

+                   -helptext "Maximum number of quality layers to decode" ]

+	set VMDecoder::var(layer) "All"

+

+	set framebe [frame $subcod.framebe -borderwidth 1]

+	set chkbe [checkbutton $framebe.chkbe -text "Write decoded file with BigEndian byte order" \

+		   -variable VMDecoder::var(be) -onvalue 1 -offvalue 0 ]

+

+		pack $labres -side left -padx 2 -anchor n

+		pack $lablayer -side left -padx 2 -anchor n

+		pack $chkbe -side left -padx 2 -anchor w

+		pack $frameres $framelayer $framebe -side top -anchor w

+

+	pack $subcod -anchor n

+	pack $labcod -side left -fill both -padx 4 -expand yes

+}

+

+

+proc VMDecoder::_decode { framesrc framedst frameinfo} {

+

+	variable var

+

+	set sourceD [$framesrc.labsrcD.f.entrysrcD get ]

+	set destinationD [$framedst.labdstD.f.entrydstD get ]

+	set originD [$frameinfo.laborgD.f.entryorgD get ]

+	set cond1 [string match *.pgx [string tolower $destinationD]]

+	set cond2 [string match *\**.pgx [string tolower $destinationD]]

+	set cond3 [string match *.bin [string tolower $destinationD]]

+	

+	#comprobamos datos son correctos

+	if {($cond1 == 1) && ($cond2 == 0)} {

+		set pgx "*.pgx"

+		set pattern [string range $destinationD 0 [expr [string length $destinationD]-5]]

+		set destinationD $pattern$img

+	} elseif {$sourceD == ""} {

+	  MessageDlg .msgdlg -parent . -message "Error : Source file is not defined !" -type ok -icon error 

+	} elseif {$destinationD == ""} {

+	  MessageDlg .msgdlg -parent . -message "Error : Destination file is not defined !" -type ok -icon error 

+	} else {

+

+		#creamos datain a partir de los parametros de entrada

+		#set dirJP3Ddecoder [mk_relativepath $VMDecoder::JP3Ddecoder]

+		set dirJP3Ddecoder $VMDecoder::JP3Ddecoder

+		set datain [concat " $dirJP3Ddecoder -i [mk_relativepath $sourceD] "]

+		set datain [concat " $datain -o [mk_relativepath $destinationD] "]

+		if {$originD != ""} {

+			set datain [concat " $datain -O [mk_relativepath $originD] "]

+			if {$cond3 == 1} {

+				set img ".img"

+				set pattern [string range $originD 0 [expr [string length $originD]-5]]

+				set pattern $pattern$img

+				if {[file exists $pattern]} {

+				  set datain [concat " $datain -m [mk_relativepath $pattern] "]

+				} else {

+				  MessageDlg .msgdlg -parent . -message "Error : IMG file associated to original BIN volume file not found in same directory !" -type ok -icon info 

+				}

+			}

+		}

+		if {$VMDecoder::var(resdiscard) != "0,0,0"} {

+			set datain [concat " $datain -r $VMDecoder::var(resdiscard) "]

+		}

+		if {$VMDecoder::var(layer) != "All" && $VMDecoder::var(layer) > 0} {

+			set datain [concat " $datain -l $VMDecoder::var(layer) "]

+		}

+		if {$VMDecoder::var(be) == 1} {

+			set datain [concat " $datain -BE"]

+		}

+		

+		set VMDecoder::var(progval) 10

+		ProgressDlg .progress -parent . -title "Wait..." \

+			-type         infinite \

+			-width        20 \

+			-textvariable "Compute in progress..."\

+			-variable     VMDecoder::progval \

+			-stop         "Stop" \

+			-command      {destroy .progress}

+

+		after 200 set VMDecoder::var(progval) 2

+

+		set fp [open "| $datain " r+] 

+		fconfigure $fp -buffering line 

+		set jp3dVM::dataout [concat "EXECUTED PROGRAM:\n\t$datain"]

+		while {-1 != [gets $fp tmp]} {

+			set jp3dVM::dataout [concat "$jp3dVM::dataout\n$tmp"]

+		}

+		close $fp

+		destroy .progress

+		set cond [string first "ERROR" $jp3dVM::dataout]

+		set cond2 [string first "PSNR" $jp3dVM::dataout]

+		set cond3 [string first "RESULT" $jp3dVM::dataout]

+		if {$cond != -1} {

+		   MessageDlg .msgdlg -parent . -message [string range $jp3dVM::dataout [expr $cond-1] end] -type ok -icon error

+		} elseif {$cond3 != -1} {

+			if {$cond2 != -1} {

+				set VMDecoder::var(decodinfo) [string range $jp3dVM::dataout [expr $cond2-1] end]

+			}

+			MessageDlg .msgdlg -parent . -message [string range $jp3dVM::dataout [expr $cond3-1] end] -type ok -icon info

+		}

+	}

+}

+

+proc VMDecoder::_save { frameinfo } {

+

+}

+

diff --git a/src/bin/jp3d/tcltk/encoder.tcl b/src/bin/jp3d/tcltk/encoder.tcl
new file mode 100755
index 00000000..6c4a5083
--- /dev/null
+++ b/src/bin/jp3d/tcltk/encoder.tcl
@@ -0,0 +1,470 @@
+
+namespace eval VMEncoder {
+	variable var
+	variable JP3Dencoder "../bin/bin/volume_to_jp3d"
+}
+
+proc VMEncoder::create { nb } {
+
+	set frame [$nb insert end VMEncoder -text "Encoder"]
+	set topf	[frame $frame.topf]
+	set midf	[frame $frame.midf]
+	set bottomf	[frame $frame.bottomf]
+	set srcf [TitleFrame $topf.srcf -text "Source"]
+	set dstf [TitleFrame $topf.dstf -text "Destination"]
+	set Tparf [TitleFrame $midf.parfT -text "Transform Parameters"]
+	set Cparf [TitleFrame $midf.parfC -text "Coding Parameters"]
+
+	set frame1 [$srcf getframe]
+		VMEncoder::_sourceE  $frame1
+	
+	set frame2  [$dstf getframe]
+		VMEncoder::_destinationE  $frame2
+	
+	set frame3  [$Tparf getframe]
+		VMEncoder::_transformE $frame3
+
+	set frame4  [$Cparf getframe]
+		VMEncoder::_codingE $frame4
+	
+	set butE  [Button $bottomf.butE -text "Encode!" \
+		   -command  "VMEncoder::_encode $frame1 $frame2" \
+		   -helptext "Encoding trigger button"]
+	set butR  [Button $bottomf.butR -text "Restore defaults" \
+		   -command  "VMEncoder::_reset $frame1 $frame2 $frame3 $frame4" \
+		   -helptext "Reset to default values"]
+
+	pack $srcf $dstf -side left -fill y -padx 4 -expand yes
+	pack $topf -pady 2 -fill x
+
+	pack $Tparf $Cparf -side left -fill both -padx 4 -expand yes
+	pack $midf -pady 2 -fill x
+	
+	pack $butE $butR -side left -padx 40 -pady 5 -fill y -expand yes
+	pack $bottomf -pady 2 -fill x
+
+	return $frame
+}
+
+proc VMEncoder::_sourceE { parent } {
+
+	variable var
+
+	set labsrc [LabelFrame $parent.labsrc -text "Select volume file to encode: " -side top \
+			-anchor w -relief flat -borderwidth 0]
+	set subsrc [$labsrc getframe]
+	set list [entry $subsrc.entrysrc -width 30 -textvariable VMDecoder::var(source)]
+	
+	set labbrw [LabelFrame $parent.labbrw -side top -anchor w -relief flat -borderwidth 0]
+	set subbrw [$labbrw getframe]
+	set butbrw [button $subbrw.butbrw -image [Bitmap::get open] \
+		-relief raised -borderwidth 1 -padx 1 -pady 1 \
+		-command "fileDialogE . $subsrc.entrysrc open"]
+	
+	pack $list -side top
+	pack $butbrw -side top
+	pack $labsrc $labbrw -side left -fill both -expand yes
+}
+
+proc VMEncoder::_destinationE { parent } {
+
+	variable var
+
+	set labdst [LabelFrame $parent.labdst -text "Save compressed volume as: " -side top \
+			-anchor w -relief flat -borderwidth 0]
+	set subdst [$labdst getframe]
+	set list [entry $subdst.entrydst -width 30 -textvariable VMDecoder::var(destination)]
+	
+	set labbrw [LabelFrame $parent.labbrw -side top -anchor w -relief flat -borderwidth 0]
+	set subbrw [$labbrw getframe]
+	set butbrw [button $subbrw.butbrw -image [Bitmap::get save] \
+		-relief raised -borderwidth 1 -padx 1 -pady 1 \
+		-command "fileDialogE . $subdst.entrydst save"]
+	
+	pack $list -side top
+	pack $butbrw -side top
+	pack $labdst $labbrw -side left -fill both -expand yes
+}
+
+proc VMEncoder::_codingE { parent } {
+
+	
+	########### CODING  #############
+	set labcod [LabelFrame $parent.labcod -side top -anchor w -relief sunken -borderwidth 1]
+	set subcod  [$labcod getframe]
+
+		set framerate [frame $subcod.framerate -borderwidth 1]
+		set labrate [LabelEntry $framerate.labrate -label "Rates: " -labelwidth 9 -labelanchor w \
+                   -textvariable VMEncoder::var(rate) -editable 1 \
+                   -helptext "Compression ratios for different layers (R1, R2, R3,...). If R=1, lossless coding" ]
+	set VMEncoder::var(rate) "1"
+
+		set framecblk [frame $subcod.framecblk -borderwidth 1]
+		set labcblk [LabelEntry $framecblk.labcblk -label "Codeblock: " -labelwidth 9 -labelanchor w \
+                   -textvariable VMEncoder::var(cblksize) -editable 1 \
+                   -helptext "Codeblock size (X, Y, Z)" ]
+	set VMEncoder::var(cblksize) "64,64,64"
+
+		set frametile [frame $subcod.frametile -borderwidth 1]
+		set labtile [LabelEntry $frametile.labtile -label "Tile size: " -labelwidth 9 -labelanchor w \
+                   -textvariable VMEncoder::var(tilesize) -editable 1 \
+                   -helptext "Tile size (X, Y, Z)" ]
+	set VMEncoder::var(tilesize) "512,512,512"
+
+		set framesop [frame $subcod.framesop -borderwidth 1]
+		set chksop [checkbutton $framesop.chksop -text "Write SOP marker" \
+			   -variable VMEncoder::var(sop) -onvalue 1 -offvalue 0 ]
+		set frameeph [frame $subcod.frameeph -borderwidth 1]
+		set chkeph [checkbutton $frameeph.chkeph -text "Write EPH marker" \
+			   -variable VMEncoder::var(eph) -onvalue 1 -offvalue 0 ]
+	
+		set framepoc [frame $subcod.framepoc -borderwidth 1]
+		set labpoc [label $framepoc.labpoc -text "Progression order: " ]
+		set progorder [ComboBox $framepoc.progorder \
+			   -text {Choose a progression order} \
+			   -width 10 \
+			   -textvariable VMEncoder::var(progorder) \
+			   -values {"LRCP" "RLCP" "RPCL" "PCRL" "CPRL"} \
+			   -helptext "Progression order"]
+		set VMEncoder::var(progorder) "LRCP"
+
+		pack $labrate -side left -padx 2 -anchor n
+		pack $labcblk -side left -padx 2 -anchor n
+		pack $labpoc $progorder -side left -padx 2 -anchor w
+		#pack $labtile -side left -padx 2 -anchor n
+		pack $chksop -side left -padx 2 -anchor w
+		pack $chkeph -side left -padx 2 -anchor w
+	########### ENTROPY CODING  #############
+	set labent [LabelFrame $parent.labent -text "Entropy Coding" -side top -anchor w -relief sunken -borderwidth 1]
+	set subent  [$labent getframe]
+		foreach entval {2EB 3EB} entropy {2D_EBCOT 3D_EBCOT} {
+			set rad [radiobutton $subent.$entval \
+				-text $entropy \
+				-variable VMEncoder::var(encoding) \
+				-command "disableGR $entval $labcblk $progorder $labrate $chksop $chkeph" \
+				-value $entval ]
+			pack $rad -anchor w
+		}
+		$subent.2EB select 
+
+	pack $subent -padx 2 -anchor n
+
+	pack $framerate $framecblk $framepoc $framesop $frameeph -side top -anchor w
+	pack $subcod -anchor n
+
+	pack $labent $labcod -side left -fill both -padx 4 -expand yes
+
+
+}
+
+proc VMEncoder::_transformE { parent } {
+
+	variable var
+
+	########### TRANSFORM  #############
+	set labtrf [LabelFrame $parent.labtrf -text "Transform" -side top -anchor w -relief sunken -borderwidth 1]
+	set subtrf  [$labtrf getframe]
+	set labres [LabelFrame $parent.labres -side top -anchor w -relief sunken -borderwidth 1]
+	set subres [$labres getframe]
+		
+		########### ATK #############
+		set frameatk [frame $subres.frameatk -borderwidth 1]
+		set labatk [label $frameatk.labatk -text "Wavelet kernel:  " -anchor w]
+		set atk [ComboBox $frameatk.atk \
+				-textvariable VMEncoder::var(atk) \
+				-width 20 \
+				-text {Choose a wavelet kernel} \
+				-editable false \
+				-values {"R5.3" "I9.7"} ]
+		set VMEncoder::var(atk) "R5.3"
+		pack $labatk $atk -side left -anchor w
+		########### RESOLUTIONS #############
+		set frameres1 [frame $subres.frameres1 -borderwidth 1]
+		set labresolution [label $frameres1.labresol -text "Resolutions: " -anchor w ]
+		set frameres2 [frame $subres.frameres2 -borderwidth 1]
+		set labresX [label $frameres2.labresX -text "  X" -anchor w ]
+		set labresY [label $frameres2.labresY -text "  Y" -anchor w ]
+		set labresZ [label $frameres2.labresZ -text "  Z" -anchor w ]
+		
+
+		set resX [SpinBox $frameres2.spinresX \
+				-range {1 6 1} -textvariable VMEncoder::var(resX) \
+				-helptext "Number of resolutions in X" \
+				-width 3 \
+				-editable false ]
+ 		set resY [SpinBox $frameres2.spinresY \
+				-range {1 6 1} -textvariable VMEncoder::var(resY) \
+				-helptext "Number of resolutions in Y" \
+				-width 3 \
+				-editable false ]
+		set resZ [SpinBox $frameres2.spinresZ \
+				-range {1 6 1} -textvariable VMEncoder::var(resZ) \
+				-helptext "Number of resolutions in Z" \
+				-width 3 \
+				-editable false \
+				-state disabled ]
+		set VMEncoder::var(resX) 3
+		set VMEncoder::var(resY) 3
+		set VMEncoder::var(resZ) 3
+
+		########### TRF  #############
+		foreach trfval {2DWT 3DWT} trf {2D-DWT 3D-DWT} {
+			set rad [radiobutton $subtrf.$trfval -text $trf \
+					-variable VMEncoder::var(transform) \
+					-command "disable3RLS $trfval $atk $resX $resY $resZ"\
+					-value $trfval ]
+			pack $rad -anchor w
+		}
+		$subtrf.2DWT select
+		
+	pack $subtrf -side left -padx 2 -pady 4
+	
+		pack $labresolution -padx 2 -side left -anchor w
+		pack $labresX $resX -padx 2 -side left -anchor w
+		pack $labresY $resY -padx 2 -side left -anchor w
+		pack $labresZ $resZ -padx 2 -side left -anchor w
+
+		pack $frameres1 -side top -fill x
+		pack $frameres2 $frameatk -side top -padx 2 -pady 4 -anchor n
+
+	pack $subres -side left -padx 2 -pady 4
+	pack $labtrf $labres -side left -fill both -padx 4 -expand yes
+}
+
+
+proc VMEncoder::_encode { framesrc framedst } {
+
+	variable var
+
+	set source [$framesrc.labsrc.f.entrysrc get ]
+	set destination [$framedst.labdst.f.entrydst get ]
+	set cond1 [string match *.pgx [string tolower $source]]
+	set cond2 [string match *-*.pgx [string tolower $source]]
+	set cond3 [string match *.bin [string tolower $source]]
+
+	set img ".img"
+	set pattern [string range $source 0 [expr [string length $source]-5]]
+	set pattern $pattern$img
+	set exist [file exists $pattern]
+	
+	#comprobamos datos son correctos
+	if {($cond1 == 1) && ($cond2 == 0)} {
+	  MessageDlg .msgdlg -parent . -message "Info : Really want to encode an slice instead of a volume?.\n For a group of .pgx slices, name must contain a - denoting a sequential index!" -type ok -icon info
+	} 
+	
+	if {$source == ""} {
+	  MessageDlg .msgdlg -parent . -message "Error : Source file is not defined !" -type ok -icon error 
+	} elseif {$destination == ""} {
+	  MessageDlg .msgdlg -parent . -message "Error : Destination file is not defined !" -type ok -icon error 
+	} elseif { ($VMEncoder::var(transform) != "3RLS") && ($VMEncoder::var(atk) == "Choose a wavelet transformation kernel") } {
+	  MessageDlg .msgdlg -parent . -title "Info" -message "Please choose a wavelet transformation kernel"\
+			-type ok -icon warning
+	} elseif {($exist == 0) && ($cond1 == 0) && ($cond3 == 1)} {
+		  MessageDlg .msgdlg -parent . -message "Error : IMG file associated to BIN volume file not found in same directory !" -type ok -icon info 
+	} else {
+
+		#creamos datain a partir de los parametros de entrada
+#		set dirJP3Dencoder [mk_relativepath $VMEncoder::JP3Dencoder]
+		set dirJP3Dencoder $VMEncoder::JP3Dencoder
+		set datain [concat " $dirJP3Dencoder -i [mk_relativepath $source] "]
+		if {$cond3 == 1} {
+		   set datain [concat " $datain -m [mk_relativepath $pattern] "]
+		}
+		set datain [concat " $datain -o [mk_relativepath $destination] "]
+		if {$VMEncoder::var(encoding) != "2EB"} {
+			set datain [concat " $datain -C $VMEncoder::var(encoding) "]
+		}
+		if {$VMEncoder::var(transform) == "2DWT"} {
+			set datain [concat " $datain -n $VMEncoder::var(resX),$VMEncoder::var(resY) "]
+		} elseif {$VMEncoder::var(transform) == "3DWT"} {
+			set datain [concat " $datain -n $VMEncoder::var(resX),$VMEncoder::var(resY),$VMEncoder::var(resZ) "]
+		}
+		
+		set datain [concat " $datain -r $VMEncoder::var(rate) "]
+		
+		if {$VMEncoder::var(atk) == "I9.7"} {
+			set datain [concat " $datain -I "]
+		} 
+		if {$VMEncoder::var(sop) == 1} {
+			set datain [concat " $datain -SOP "]
+		}
+		if {$VMEncoder::var(eph) == 1} {
+			set datain [concat " $datain -EPH "]
+		}
+		if {$VMEncoder::var(progorder) != "LRCP"} {
+			set datain [concat " $datain -p $VMEncoder::var(progorder) "]
+		}
+		if {$VMEncoder::var(cblksize) != "64,64,64"} {
+			set datain [concat " $datain -b $VMEncoder::var(cblksize) "]
+		}
+
+		
+		#Making this work would be great !!! 
+		set VMEncoder::var(progval) 10
+		ProgressDlg .progress -parent . -title "Wait..." \
+			-type         infinite \
+			-width        20 \
+			-textvariable "Compute in progress..."\
+			-variable     VMEncoder::progval \
+			-stop         "Stop" \
+			-command      {destroy .progress}
+		after 200 set VMEncoder::var(progval) 2
+		set fp [open "| $datain " r+] 
+		fconfigure $fp -buffering line 
+		set jp3dVM::dataout [concat "EXECUTED PROGRAM:\n\t$datain"]
+		while {-1 != [gets $fp tmp]} {
+			set jp3dVM::dataout [concat "$jp3dVM::dataout\n$tmp"]
+		}
+		destroy .progress
+		set cond [string first "ERROR" $jp3dVM::dataout]
+		set cond2 [string first "RESULT" $jp3dVM::dataout]
+		if {$cond != -1} {
+		   MessageDlg .msgdlg -parent . -message [string range $jp3dVM::dataout [expr $cond-1] end] -type ok -icon error
+		} elseif {$cond2 != -1} {
+		   MessageDlg .msgdlg -parent . -message [string range $jp3dVM::dataout [expr $cond2+7] end] -type ok -icon info
+		   close $fp
+		} else {
+		   #Must do something with this !!! [pid $fp]
+  		   close $fp
+		}
+	}
+}
+
+proc VMEncoder::_reset { framesrc framedst frametrf framecod} {
+
+	variable var
+
+	#Restore defaults values
+	set VMEncoder::var(transform) 2DWT
+	set VMEncoder::var(encoding) 2EB
+	set VMEncoder::var(atk) "R5.3"
+	set VMEncoder::var(progorder) "LRCP"
+	set atk $frametrf.labres.f.frameatk.atk
+	set resX $frametrf.labres.f.frameres2.spinresX
+	set resY $frametrf.labres.f.frameres2.spinresY
+	set resZ $frametrf.labres.f.frameres2.spinresZ
+	disable3RLS 2DWT $atk $resX $resY $resZ 
+	set labcblk $framecod.labcod.f.framecblk.labcblk
+	set progorder $framecod.labcod.f.framepoc.progorder
+	set labrate $framecod.labcod.f.framerate.labrate
+	set chksop $framecod.labcod.f.framesop.chksop
+	set chkeph $framecod.labcod.f.frameeph.chkeph
+	disableGR 3EB $labcblk $progorder $labrate $chksop $chkeph
+
+	$framesrc.labsrc.f.entrysrc delete 0 end
+	$framedst.labdst.f.entrydst delete 0 end
+}
+
+proc fileDialogE {w ent operation} {
+
+	variable file
+	variable i j
+
+	if {$operation == "open"} {
+		set types {
+			{"Source Image Files"	{.pgx .bin}	}
+			{"All files"		*}
+		}
+		set file [tk_getOpenFile -filetypes $types -parent $w]
+		if {[string compare $file ""]} {
+			$ent delete 0 end
+			$ent insert end $file
+			$ent xview moveto 1
+		}
+	} else {
+		set types {
+			{"JP3D Files"		   {.jp3d}	}
+			{"JPEG2000 Files"	   {.j2k}	}
+			{"All files"		*}
+		}
+		set file [tk_getSaveFile -filetypes $types -parent $w \
+			-initialfile Untitled -defaultextension .jp3d]
+		if {[string compare $file ""]} {
+			$ent delete 0 end
+			$ent insert end $file
+			$ent xview moveto 1
+		}
+	}
+}
+
+proc mk_relativepath {abspath} {
+
+	set mydir [split [string trimleft [pwd] {/}] {/}]
+	set abspathcomps [split [string trimleft $abspath {/}] {/}]
+
+	set i 0
+	while {$i<[llength $mydir]} {
+		if {![string compare [lindex $abspathcomps $i] [lindex $mydir $i]]} {
+			incr i
+		} else {
+			break
+		}
+	}
+	set h [expr [llength $mydir]-$i]
+	set j [expr [llength $abspathcomps]-$i]
+
+	if {!$h} {
+		set relpath "./"
+	} else {
+		set relpath ""
+		while { $h > 0 } {
+			set relpath "../$relpath"
+			incr h -1
+		}
+	}
+
+	set h [llength $abspathcomps]
+	while { $h > $i } {
+		set relpath [concat $relpath[lindex $abspathcomps [expr [llength $abspathcomps]-$j]]/]
+		incr h -1
+		incr j -1
+	}
+	return [string trim $relpath {/}]
+}
+
+proc disable3RLS {flag atk resX resY resZ}  {
+
+	if {$flag == "3RLS"} {
+		$atk configure -state disabled
+		$resX configure -state disabled
+		$resY configure -state disabled
+		$resZ configure -state disabled
+	} elseif {$flag == "2DWT"} {
+		$atk configure -state normal
+		$resX configure -state normal
+		$resY configure -state normal
+		$resZ configure -state disabled
+	} elseif {$flag == "3DWT"} {
+		$atk configure -state normal
+		$resX configure -state normal
+		$resY configure -state normal
+		$resZ configure -state normal
+	}
+}
+
+proc disableGR {flag labcblk progorder labrate chksop chkeph} {
+	
+	if {$flag == "2EB"} {
+		$labcblk configure -state normal
+		$progorder configure -state normal
+		$labrate configure -state normal
+		$chksop configure -state normal
+		$chkeph configure -state normal
+		set VMEncoder::var(cblksize) "64,64,64"
+		set VMEncoder::var(tilesize) "512,512,512"
+	} elseif {$flag == "3EB"} {
+		$labcblk configure -state normal
+		$progorder configure -state normal
+		$labrate configure -state normal
+		$chksop configure -state normal
+		$chkeph configure -state normal
+		set VMEncoder::var(cblksize) "64,64,64"
+		set VMEncoder::var(tilesize) "512,512,512"
+	} else {
+		$labcblk configure -state disabled
+		$progorder configure -state disabled
+		$labrate configure -state disabled
+		$chksop configure -state disabled
+		$chkeph configure -state disabled
+	}
+}
diff --git a/src/bin/jp3d/tcltk/logoLPI.gif b/src/bin/jp3d/tcltk/logoLPI.gif
new file mode 100755
index 00000000..df795150
--- /dev/null
+++ b/src/bin/jp3d/tcltk/logoLPI.gif
diff --git a/src/bin/jp3d/volume_to_jp3d.c b/src/bin/jp3d/volume_to_jp3d.c
new file mode 100755
index 00000000..8a593b37
--- /dev/null
+++ b/src/bin/jp3d/volume_to_jp3d.c
@@ -0,0 +1,906 @@
+/*

+ * Copyright (c) 2001-2003, David Janssens

+ * Copyright (c) 2002-2003, Yannick Verschueren

+ * Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe

+ * Copyright (c) 2005, Herve Drolon, FreeImage Team

+ * Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium

+ * Copyright (c) 2006, Mónica Díez García, Image Processing Laboratory, University of Valladolid, Spain

+ * 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 <stdlib.h>

+

+#include "openjp3d.h"

+#include "getopt.h"

+#include "convert.h"

+

+#ifdef _WIN32

+#include <windows.h>

+#else

+#define stricmp strcasecmp

+#define strnicmp strncasecmp

+#endif /* _WIN32 */

+

+/* ----------------------------------------------------------------------- */

+

+void encode_help_display() {

+	fprintf(stdout,"List of parameters for the JPEG2000 Part 10 encoder:\n");

+	fprintf(stdout,"------------\n");

+	fprintf(stdout,"\n");

+	fprintf(stdout,"Required Parameters (except with -h):\n");

+	fprintf(stdout,"\n");

+	fprintf(stdout,"-i           : source file  (-i source.bin or source*.pgx) \n");

+	fprintf(stdout,"\n");

+	fprintf(stdout,"-m           : source characteristics file (-m imgfile.img) \n");

+	fprintf(stdout,"\n");

+	fprintf(stdout,"-o           : destination file (-o dest.jp3d) \n");

+	fprintf(stdout,"\n");

+	fprintf(stdout,"Optional Parameters:\n");

+	fprintf(stdout,"\n");

+	fprintf(stdout,"-h           : display the help information \n ");

+	fprintf(stdout,"\n");

+	fprintf(stdout,"-n           : number of resolutions (-n 3,3,3) \n");

+	fprintf(stdout,"\n");

+	fprintf(stdout,"-I           : use the irreversible transforms: ICT + DWT 9-7 (-I) \n");

+	fprintf(stdout,"\n");

+	fprintf(stdout,"-C           : coding algorithm (-C 2EB) [2EB, 3EB] \n");

+	fprintf(stdout,"\n");

+	fprintf(stdout,"-r           : different compression ratios for successive layers (-r 20,10,5)\n ");

+	fprintf(stdout,"	         - The rate specified for each quality level is the desired compression factor.\n");

+	fprintf(stdout,"	         - Rate 1 means lossless compression\n");

+	fprintf(stdout,"               (options -r and -q cannot be used together)\n ");

+	fprintf(stdout,"\n");

+	fprintf(stdout,"-q           : different psnr for successive layers (-q 30,40,50) \n ");

+	fprintf(stdout,"               (options -r and -q cannot be used together)\n ");

+	fprintf(stdout,"\n");

+	fprintf(stdout,"-b           : size of code block (-b 32,32,32) \n");

+	fprintf(stdout,"\n");

+	fprintf(stdout,"-c           : size of precinct (-c 128,128,128) \n");

+	fprintf(stdout,"\n");

+	fprintf(stdout,"-t           : size of tile (-t 512,512,512) \n");

+	fprintf(stdout,"\n");

+	fprintf(stdout,"-p           : progression order (-p LRCP) [LRCP, RLCP, RPCL, PCRL, CPRL] \n");

+	fprintf(stdout,"\n");

+	fprintf(stdout,"-s           : subsampling factor (-s 2,2,2) [-s X,Y,Z] \n");

+	fprintf(stdout,"			  - Remark: subsampling bigger than 2 can produce error\n");

+	fprintf(stdout,"\n");

+	fprintf(stdout,"-SOP         : write SOP marker before each packet \n");

+	fprintf(stdout,"\n");

+	fprintf(stdout,"-EPH         : write EPH marker after each header packet \n");

+	fprintf(stdout,"\n");

+	fprintf(stdout,"-M           : code-block style (-M 0) [1=BYPASS(LAZY) 2=RESET 4=RESTART(TERMALL)\n");

+	fprintf(stdout,"                 8=VSC 16=PTERM 32=SEGSYM 64=3DCTXT] \n");

+	fprintf(stdout,"                 Indicate multiple modes by adding their values. \n");

+	fprintf(stdout,"                 ex: RESTART(4) + RESET(2) + SEGMARK(32) = -M 38\n");

+	fprintf(stdout,"\n");

+	fprintf(stdout,"-D           : define DC offset (-D 12) \n");

+	fprintf(stdout,"\n");

+	fprintf(stdout,"-x           : create an index file *.Idx (-x index_name.Idx) \n");

+	fprintf(stdout,"\n");

+	fprintf(stdout,"-ROI         : c=%%d,U=%%d : quantization indices upshifted \n");

+	fprintf(stdout,"               for component c=%%d [%%d = 0,1,2]\n");

+	fprintf(stdout,"               with a value of U=%%d [0 <= %%d <= 37] (i.e. -ROI:c=0,U=25) \n");

+	fprintf(stdout,"\n");

+	fprintf(stdout,"-d           : offset of the origin of the volume (-d 150,300,100) \n");

+	fprintf(stdout,"\n");

+	fprintf(stdout,"-l           : offset of the origin of the tiles (-l 100,75,25) \n");

+	fprintf(stdout,"\n");

+	fprintf(stdout,"\n");

+	fprintf(stdout,"DEFAULT CODING:\n");

+	fprintf(stdout,"------------\n");

+	fprintf(stdout,"\n");

+	fprintf(stdout," * Lossless\n");

+	fprintf(stdout," * 1 tile\n");

+	fprintf(stdout," * Size of precinct : 2^15 x 2^15 x 2^15 (means 1 precinct)\n");

+	fprintf(stdout," * Size of code-block : 64 x 64 x 64\n");

+	fprintf(stdout," * Number of resolutions in x, y and z axis: 3\n");

+	fprintf(stdout," * No SOP marker in the codestream\n");

+	fprintf(stdout," * No EPH marker in the codestream\n");

+	fprintf(stdout," * No sub-sampling in x, y or z direction\n");

+	fprintf(stdout," * No mode switch activated\n");

+	fprintf(stdout," * Progression order: LRCP\n");

+	fprintf(stdout," * No index file\n");

+	fprintf(stdout," * No ROI upshifted\n");

+	fprintf(stdout," * No offset of the origin of the volume\n");

+	fprintf(stdout," * No offset of the origin of the tiles\n");

+	fprintf(stdout," * Reversible DWT 5-3 on each 2D slice\n");

+	fprintf(stdout," * Coding algorithm: 2D-EBCOT \n");

+	fprintf(stdout,"\n");

+	fprintf(stdout,"REMARKS:\n");

+	fprintf(stdout,"---------\n");

+	fprintf(stdout,"\n");

+	fprintf(stdout,"- The markers written to the main_header are : SOC SIZ COD QCD COM.\n");

+	fprintf(stdout,"- COD and QCD markers will never appear in the tile_header.\n");

+	fprintf(stdout,"\n");

+	fprintf(stdout,"- You need enough disk space memory (twice the original) to encode \n");

+	fprintf(stdout,"the volume,i.e. for a 1.5 GB volume you need a minimum of 3GB of disk memory)\n");

+	fprintf(stdout,"\n");

+	fprintf(stdout,"- When loading *.pgx files, a relative path to directory is needed for input argument \n");

+	fprintf(stdout," followed by the common prefix of the slices and a '*' character representing sequential numeration.\n");

+	fprintf(stdout,"( -i relativepath/slices*.pgx )\n");

+	fprintf(stdout,"\n");

+	fprintf(stdout," - The index file has the structure below:\n");

+	fprintf(stdout,"\n");

+	fprintf(stdout,"\t	Image_height Image_width Image_depth\n");

+	fprintf(stdout,"\t	Progression order: 0 (LRCP)\n");

+	fprintf(stdout,"\t	Tiles_size_X Tiles_size_Y Tiles_size_Z\n");

+	fprintf(stdout,"\t	Components_nb\n");

+	fprintf(stdout,"\t	Layers_nb\n");

+	fprintf(stdout,"\t	Decomposition_levels\n");

+	fprintf(stdout,"\t	[Precincts_size_X_res_Nr Precincts_size_Y_res_Nr Precincts_size_Z_res_Nr]\n\t  ...\n");

+	fprintf(stdout,"\t	[Precincts_size_X_res_0 Precincts_size_Y_res_0 Precincts_size_Z_res_0]\n");

+	fprintf(stdout,"\t	Main_header_end_position\n");

+	fprintf(stdout,"\t	Codestream_size\n");

+	fprintf(stdout,"\t	Tile_0 [start_pos end_header end_pos TotalDisto NumPix MaxMSE]\n");

+	fprintf(stdout,"\t	...\n");

+	fprintf(stdout,"\t	Tile_Nt [  ''         ''        ''        ''       ''    ''  ]\n");

+	fprintf(stdout,"\t  Tpacket_0 [Tile layer res. comp. prec. start_pos end_pos disto]\n");

+	fprintf(stdout,"\t  ...\n");

+	fprintf(stdout,"\t  Tpacket_Np [''   ''    ''   ''    ''       ''       ''     '' ]\n");

+	fprintf(stdout,"\t  MaxDisto\n");

+	fprintf(stdout,"\t  TotalDisto\n\n");

+	fprintf(stdout,"\n");

+

+}

+

+OPJ_PROG_ORDER give_progression(char progression[4]) {

+	if(strncmp(progression, "LRCP", 4) == 0) {

+		return LRCP;

+	}

+	if(strncmp(progression, "RLCP", 4) == 0) {

+		return RLCP;

+	}

+	if(strncmp(progression, "RPCL", 4) == 0) {

+		return RPCL;

+	}

+	if(strncmp(progression, "PCRL", 4) == 0) {

+		return PCRL;

+	}

+	if(strncmp(progression, "CPRL", 4) == 0) {

+		return CPRL;

+	}

+

+	return PROG_UNKNOWN;

+}

+

+OPJ_TRANSFORM give_transform(char transform[4]) {

+	if(strncmp(transform, "2DWT", 4) == 0) {

+		return TRF_2D_DWT;

+	}

+	if(strncmp(transform, "3DWT", 4) == 0) {

+		return TRF_3D_DWT;

+	}

+	return TRF_UNKNOWN;

+}

+

+OPJ_ENTROPY_CODING give_coding(char coding[3]) {

+

+	if(strncmp(coding, "2EB", 3) == 0) {

+		return ENCOD_2EB;

+	}

+	if(strncmp(coding, "3EB", 3) == 0) {

+		return ENCOD_3EB;

+	}

+	/*if(strncmp(coding, "2GR", 3) == 0) {

+		return ENCOD_2GR;

+	}

+	if(strncmp(coding, "3GR", 3) == 0) {

+		return ENCOD_3GR;

+	}*/

+

+	return ENCOD_UNKNOWN;

+}

+

+int get_file_format(char *filename) {

+	int i;

+	static const char *extension[] = {"pgx", "bin", "img", "j3d", "jp3d", "j2k"};

+	static const int format[] = { PGX_DFMT, BIN_DFMT, IMG_DFMT, J3D_CFMT, J3D_CFMT, J2K_CFMT};

+	char * ext = strrchr(filename, '.');

+	if (ext) {

+		ext++;

+        for(i = 0; i < sizeof(format)/sizeof(*format); i++) {

+			if(strnicmp(ext, extension[i], 3) == 0) {

+                return format[i];

+			}

+		}

+	}

+

+	return -1;

+}

+

+/* ------------------------------------------------------------------------------------ */

+

+int parse_cmdline_encoder(int argc, char **argv, opj_cparameters_t *parameters) {

+	int i, value;

+

+	/* parse the command line */

+

+	while (1) {

+		int c = getopt(argc, argv, "i:m:o:r:q:f:t:n:c:b:x:p:s:d:hP:S:E:M:D:R:l:T:C:A:I");

+		if (c == -1)

+			break;

+		switch (c) {

+			case 'i':			/* input file */

+			{

+				char *infile = optarg;

+				parameters->decod_format = get_file_format(infile);

+				switch(parameters->decod_format) {

+					case PGX_DFMT:

+					case BIN_DFMT:

+					case IMG_DFMT:

+						break;

+					default:

+						fprintf(stdout,	"[ERROR] Unrecognized format for infile : %s [accept only *.pgx or *.bin] !!\n\n", infile);

+						return 1;

+						break;

+				}

+				strncpy(parameters->infile, infile, MAX_PATH);

+				fprintf(stdout,	"[INFO] Infile: %s \n", parameters->infile);

+

+			}

+			break;

+				

+				/* ----------------------------------------------------- */

+			case 'm':			/* input IMG file */

+			{

+				char *imgfile = optarg;

+				int imgformat = get_file_format(imgfile);

+				switch(imgformat) {

+					case IMG_DFMT:

+						break;

+					default:

+						fprintf(stdout,	"[ERROR] Unrecognized format for imgfile : %s [accept only *.img] !!\n\n", imgfile);

+						return 1;

+						break;

+				}

+				strncpy(parameters->imgfile, imgfile, MAX_PATH);

+				fprintf(stdout,	"[INFO] Imgfile: %s Format: %d\n", parameters->imgfile, imgformat);

+			}

+			break;

+				

+				/* ----------------------------------------------------- */

+			case 'o':			/* output file */

+			{

+				char *outfile = optarg;

+				parameters->cod_format = get_file_format(outfile);

+				switch(parameters->cod_format) {

+					case J3D_CFMT:

+					case J2K_CFMT:

+					case LSE_CFMT:

+						break;

+					default:

+						fprintf(stdout, "[ERROR] Unknown output format volume %s [only *.j2k, *.lse3d or *.jp3d]!! \n", outfile);

+						return 1;

+						break;

+				}

+				strncpy(parameters->outfile, outfile, MAX_PATH);

+				fprintf(stdout,	"[INFO] Outfile: %s \n", parameters->outfile);

+			}

+			break;

+

+				/* ----------------------------------------------------- */

+			

+			case 'r':			/* define compression rates for each layer */

+			{

+				char *s = optarg;

+				while (sscanf(s, "%f", &parameters->tcp_rates[parameters->tcp_numlayers]) == 1) {

+					parameters->tcp_numlayers++;

+					while (*s && *s != ',') {

+						s++;

+					}

+					if (!*s)

+						break;

+					s++;

+				}

+				parameters->cp_disto_alloc = 1;

+			}

+			break;

+				

+				/* ----------------------------------------------------- */

+			

+			case 'q':			/* define distorsion (PSNR) for each layer */

+			{

+				char *s = optarg;

+				while (sscanf(s, "%f", &parameters->tcp_distoratio[parameters->tcp_numlayers]) == 1) {

+					parameters->tcp_numlayers++;

+					while (*s && *s != ',') {

+						s++;

+					}

+					if (!*s)

+						break;

+					s++;

+				}

+				parameters->cp_fixed_quality = 1;

+			}

+			break;

+				

+				/* ----------------------------------------------------- */

+

+			case 'f':	

+			{

+				fprintf(stdout, "/---------------------------------------------------\\\n");

+				fprintf(stdout, "|  Fixed layer allocation option not implemented !!  |\n");

+				fprintf(stdout, "\\---------------------------------------------------/\n");

+				/*int *row = NULL, *col = NULL;

+				int numlayers = 0, matrix_width = 0;

+

+				char *s = optarg;

+				sscanf(s, "%d", &numlayers);

+				s++;

+				if (numlayers > 9)

+					s++;

+

+				parameters->tcp_numlayers = numlayers;

+				matrix_width = parameters->numresolution[0] + parameters->numresolution[1] + parameters->numresolution[2];

+				parameters->cp_matrice = (int *) malloc(numlayers * matrix_width * sizeof(int));

+				s = s + 2;

+

+				for (i = 0; i < numlayers; i++) {

+					row = &parameters->cp_matrice[i * matrix_width];

+					col = row;

+					parameters->tcp_rates[i] = 1;

+					sscanf(s, "%d,", &col[0]);

+					s += 2;

+					if (col[0] > 9)

+						s++;

+					col[1] = 0;

+					col[2] = 0;

+					for (j = 1; j < matrix_width; j++) {

+						col += 3; j+=2;

+						sscanf(s, "%d,%d,%d", &col[0], &col[1], &col[2]);

+						s += 6;

+						if (col[0] > 9)

+							s++;

+						if (col[1] > 9)

+							s++;

+						if (col[2] > 9)

+							s++;

+					}

+					if (i < numlayers - 1)

+						s++;

+				}

+				parameters->cp_fixed_alloc = 1; */

+			}

+			break;

+				

+				/* ----------------------------------------------------- */

+

+			case 't':			/* tiles */

+			{

+				if (sscanf(optarg, "%d,%d,%d", &parameters->cp_tdx, &parameters->cp_tdy, &parameters->cp_tdz) !=3) {

+					fprintf(stdout,	"[ERROR] '-t' 'dimensions of tiles' argument error !  [-t tdx,tdy,tdz]\n");

+					return 1;

+				}

+				parameters->tile_size_on = true;

+			}

+			break;

+				

+				/* ----------------------------------------------------- */

+			

+			case 'n':			/* resolution */

+			{

+				int aux;

+				aux = sscanf(optarg, "%d,%d,%d", &parameters->numresolution[0], &parameters->numresolution[1], &parameters->numresolution[2]);

+				if (aux == 2) 

+					parameters->numresolution[2] = 1;

+				else if (aux == 1) {

+					parameters->numresolution[1] = parameters->numresolution[0];

+					parameters->numresolution[2] = 1;

+				}else if (aux == 0){

+					parameters->numresolution[0] = 1;

+					parameters->numresolution[1] = 1;

+					parameters->numresolution[2] = 1;

+				}

+			}

+			break;

+				

+				/* ----------------------------------------------------- */

+			case 'c':			/* precinct dimension */

+			{

+				char sep;

+				int res_spec = 0;

+				int aux;

+				char *s = optarg;

+				do {

+					sep = 0;

+					aux = sscanf(s, "[%d,%d,%d]%c", &parameters->prct_init[0][res_spec], &parameters->prct_init[1][res_spec], &parameters->prct_init[2][res_spec], &sep);

+					if (sep == ',' && aux != 4) {

+						fprintf(stdout,	"[ERROR] '-c' 'dimensions of precincts' argument error !  [-c [prcx_res0,prcy_res0,prcz_res0],...,[prcx_resN,prcy_resN,prcz_resN]]\n");

+						return 1;

+					}

+					parameters->csty |= 0x01;

+					res_spec++;

+					s = strpbrk(s, "]") + 2;

+				}

+				while (sep == ',');

+				parameters->res_spec = res_spec; /* number of precinct size specifications */

+			}

+			break;

+				

+				/* ----------------------------------------------------- */

+			

+			case 'b':			/* code-block dimension */

+			{

+				int cblockw_init = 0, cblockh_init = 0, cblockl_init = 0;

+				if (sscanf(optarg, "%d,%d,%d", &cblockw_init, &cblockh_init, &cblockl_init) != 3) {

+					fprintf(stdout,	"[ERROR] '-b' 'dimensions of codeblocks' argument error !  [-b cblkx,cblky,cblkz]\n");

+					return 1;

+				}

+				if (cblockw_init * cblockh_init * cblockl_init > (1<<18) || cblockw_init > 1024 || cblockw_init < 4 || cblockh_init > 1024 || cblockh_init < 4 || cblockl_init > 1024 || cblockl_init < 4) {

+					fprintf(stdout,"[ERROR] Size of code_block error (option -b) !!\n\nRestriction :\n * width*height*length<=4096\n * 4<=width,height,length<= 1024\n\n");

+					return 1;

+				}

+				parameters->cblock_init[0] = cblockw_init;

+				parameters->cblock_init[1] = cblockh_init;

+				parameters->cblock_init[2] = cblockl_init;

+			}

+			break;

+				

+				/* ----------------------------------------------------- */

+			

+			case 'x':			/* creation of index file */

+			{

+				char *index = optarg;

+				strncpy(parameters->index, index, MAX_PATH);

+				parameters->index_on = 1;

+			}

+			break;

+				

+				/* ----------------------------------------------------- */

+			

+			case 'p':			/* progression order */

+			{

+				char progression[4];

+

+				strncpy(progression, optarg, 4);

+				parameters->prog_order = give_progression(progression);

+				if (parameters->prog_order == -1) {

+					fprintf(stdout, "[ERROR] Unrecognized progression order [LRCP, RLCP, RPCL, PCRL, CPRL] !!\n");

+					return 1;

+				}

+			}

+			break;

+				

+				/* ----------------------------------------------------- */

+			

+			case 's':			/* subsampling factor */

+			{

+				if (sscanf(optarg, "%d,%d,%d", &parameters->subsampling_dx, &parameters->subsampling_dy, &parameters->subsampling_dz) != 2) {

+					fprintf(stdout,	"[ERROR] '-s' sub-sampling argument error !  [-s dx,dy,dz]\n");

+					return 1;

+				}

+			}

+			break;

+				

+				/* ----------------------------------------------------- */

+			

+			case 'd':			/* coordonnate of the reference grid */

+			{

+				if (sscanf(optarg, "%d,%d,%d", &parameters->volume_offset_x0, &parameters->volume_offset_y0, &parameters->volume_offset_z0) != 3) {

+					fprintf(stdout,	"[ERROR] -d 'coordonnate of the reference grid' argument error !! [-d x0,y0,z0]\n");

+					return 1;

+				}

+			}

+			break;

+				

+				/* ----------------------------------------------------- */

+			

+			case 'h':			/* display an help description */

+			{

+				encode_help_display();

+				return 1;

+			}

+			break;

+				

+				/* ----------------------------------------------------- */

+

+			case 'P':			/* POC */

+			{

+				int numpocs = 0;		/* number of progression order change (POC) default 0 */

+				opj_poc_t *POC = NULL;	/* POC : used in case of Progression order change */

+

+				char *s = optarg;

+				POC = parameters->POC;

+

+				fprintf(stdout, "/----------------------------------\\\n");

+				fprintf(stdout, "|  POC option not fully tested !!  |\n");

+				fprintf(stdout, "\\----------------------------------/\n");

+				

+				while (sscanf(s, "T%d=%d,%d,%d,%d,%d,%s", &POC[numpocs].tile,

+														&POC[numpocs].resno0, &POC[numpocs].compno0,

+														&POC[numpocs].layno1, &POC[numpocs].resno1,

+														&POC[numpocs].compno1, POC[numpocs].progorder) == 7) {

+					POC[numpocs].prg = give_progression(POC[numpocs].progorder);

+					/* POC[numpocs].tile; */

+					numpocs++;

+					while (*s && *s != '/') {

+						s++;

+					}

+					if (!*s) {

+						break;

+					}

+					s++;

+				}

+				parameters->numpocs = numpocs;

+			}

+			break;

+				

+				/* ------------------------------------------------------ */

+				

+			case 'S':			/* SOP marker */

+			{

+				parameters->csty |= 0x02;

+			}

+			break;

+				

+				/* ------------------------------------------------------ */

+			

+			case 'E':			/* EPH marker */

+			{

+				parameters->csty |= 0x04;

+			}

+			break;

+				

+				/* ------------------------------------------------------ */

+			

+			case 'M':			/* Codification mode switch */

+			{

+				fprintf(stdout, "[INFO] Mode switch option not fully tested !!\n");

+				value = 0;

+				if (sscanf(optarg, "%d", &value) == 1) {

+					for (i = 0; i <= 6; i++) {

+						int cache = value & (1 << i);

+						if (cache)

+							parameters->mode |= (1 << i);

+					}

+				}

+			}

+			break;

+				

+				/* ------------------------------------------------------ */

+			

+			case 'D':			/* DCO */

+			{

+				if (sscanf(optarg, "%d", &parameters->dcoffset) != 1) {

+					fprintf(stdout, "[ERROR] DC offset error !! [-D %d]\n",parameters->dcoffset);

+					return 1;

+				}

+			}

+			break;

+				

+				/* ------------------------------------------------------ */

+			

+			case 'R':			/* ROI */

+			{

+				if (sscanf(optarg, "OI:c=%d,U=%d", &parameters->roi_compno, &parameters->roi_shift) != 2) {

+					fprintf(stdout, "[ERROR] ROI error !! [-ROI:c='compno',U='shift']\n");

+					return 1;

+				}

+			}

+			break;

+				

+				/* ------------------------------------------------------ */

+			

+			case 'l':			/* Tile offset */

+			{

+				if (sscanf(optarg, "%d,%d,%d", &parameters->cp_tx0, &parameters->cp_ty0, &parameters->cp_tz0) != 3) {

+					fprintf(stdout, "[ERROR] -l 'tile offset' argument error !! [-l X0,Y0,Z0]");

+					return 1;

+				}

+			}

+			break;

+				

+				/* ------------------------------------------------------ 

+				

+			case 'T':			// Tranformation of original data (2D-DWT/3D-DWT/3D-RLS/2D-DWT+1D-RLS) 

+			{

+				char transform[4];

+

+				strncpy(transform, optarg, 4);

+				parameters->transform_format = give_transform(transform);

+				if (parameters->transform_format == -1) {

+					fprintf(stdout, "[ERROR] -T 'Transform domain' argument error !! [-T 2DWT, 3DWT, 3RLS or 3LSE only]");

+                    return 1;

+				}

+			}

+			break;

+				

+				 ------------------------------------------------------ */

+			

+			case 'C':			/* Coding of transformed data */

+			{

+				char coding[3];

+

+				strncpy(coding, optarg, 3);

+				parameters->encoding_format = give_coding(coding);

+				if (parameters->encoding_format == -1) {

+					fprintf(stdout, "[ERROR] -C 'Coding algorithm' argument error !! [-C 2EB, 3EB, 2GR, 3GR or GRI only]");

+                    return 1;

+				}

+			}

+			break;

+			

+			/* ------------------------------------------------------ */

+			

+			case 'I':			/* reversible or not */

+			{

+				parameters->irreversible = 1;

+			}

+			break;

+				

+			default:

+				fprintf(stdout, "[ERROR] This option is not valid \"-%c %s\"\n", c, optarg);

+				return 1;

+		}

+	}

+

+	/* check for possible errors */

+

+	if((parameters->infile[0] == 0) || (parameters->outfile[0] == 0)) {

+		fprintf(stdout, "usage: jp3d_vm_enc -i volume-file -o jp3d-file (+ options)\n");

+		return 1;

+	}

+

+	if((parameters->decod_format == BIN_DFMT) && (parameters->imgfile[0] == 0)) {

+		fprintf(stdout, "usage: jp3d_vm_enc -i bin-volume-file -m img-file -o jp3d-file (+ options)\n");

+		return 1;

+	}

+

+	if((parameters->decod_format != BIN_DFMT) && (parameters->decod_format != PGX_DFMT) && (parameters->decod_format != IMG_DFMT)) {

+		fprintf(stdout, "usage: jp3d_vm_enc -i input-volume-file [*.bin,*.pgx,*.img] -o jp3d-file [*.jp3d,*.j2k] (+ options)\n");

+		return 1;

+	}

+	if((parameters->cod_format != J3D_CFMT) && (parameters->cod_format != J2K_CFMT)) {

+		fprintf(stdout, "usage: jp3d_vm_enc -i input-volume-file [*.bin,*.pgx,*.img] -o jp3d-file [*.jp3d,*.j2k] (+ options)\n");

+		return 1;

+	}

+

+	if((parameters->encoding_format == ENCOD_2GR || parameters->encoding_format == ENCOD_3GR) && parameters->transform_format != TRF_3D_LSE && parameters->transform_format != TRF_3D_RLS) {

+		fprintf(stdout, "[ERROR] Entropy coding options -C [2GR,3GR] are only compatible with predictive-based transform algorithms: -T [3RLS,3LSE].\n");

+		return 1;

+	}

+	if (parameters->encoding_format == ENCOD_3EB)

+		parameters->mode |= (1 << 6);

+

+	if ((parameters->mode >> 6) & 1) {

+		parameters->encoding_format = ENCOD_3EB;

+	}

+

+	if((parameters->numresolution[2] == 0 || (parameters->numresolution[1] == 0) || (parameters->numresolution[0] == 0))) {

+		fprintf(stdout, "[ERROR] -n 'resolution levels' argument error ! Resolutions must be greater than 1 in order to perform DWT.\n");

+		return 1;

+	}

+	if (parameters->numresolution[1] != parameters->numresolution[0]) {

+		fprintf(stdout, "[ERROR] -n 'resolution levels' argument error ! Resolutions in X and Y axis must be the same in this implementation.\n");

+		return 1;

+	}

+	

+	if (parameters->numresolution[2] > parameters->numresolution[0]) {

+		fprintf(stdout, "[ERROR] -n 'resolution levels' argument error ! Resolutions in Z axis must be lower than in X-Y axis.\n");

+		return 1;

+	}

+	

+	if (parameters->dcoffset >= 128 && parameters->dcoffset <= -128) {

+		fprintf(stdout, "[ERROR] -D 'DC offset' argument error ! Value must be -128<=DCO<=128.\n");

+		return 1;

+	}

+

+	if(parameters->numresolution[2] != 1) {

+		parameters->transform_format = TRF_3D_DWT;

+		//fprintf(stdout, "[Warning] Resolution level in axial dim > 1 : 3D-DWT will be performed... \n");

+	} else if (parameters->numresolution[2] == 1) {

+		parameters->transform_format = TRF_2D_DWT;

+		//fprintf(stdout, "[Warning] Resolution level in axial dim == 1 : 2D-DWT will be performed... \n");

+	}

+	

+	if ((parameters->cod_format == J2K_CFMT) && (parameters->transform_format != TRF_2D_DWT || parameters->encoding_format != ENCOD_2EB)) {

+		fprintf(stdout, "[WARNING] Incompatible options -o *.j2k and defined transform or encoding algorithm. Latter will be ignored\n");

+		parameters->transform_format = TRF_2D_DWT;

+		parameters->encoding_format = ENCOD_2EB;

+	}

+

+	if ((parameters->cp_disto_alloc || parameters->cp_fixed_alloc || parameters->cp_fixed_quality) && (!(parameters->cp_disto_alloc ^ parameters->cp_fixed_quality))) {

+		fprintf(stdout, "[ERROR] Options -r and -q cannot be used together !!\n");

+		return 1;

+	}				/* mod fixed_quality */

+

+	/* if no rate entered, lossless by default */

+	if (parameters->tcp_numlayers == 0) {

+		parameters->tcp_rates[0] = 0.0;	/* MOD antonin : losslessbug */

+		parameters->tcp_numlayers++;

+		parameters->cp_disto_alloc = 1;

+	}

+

+	if((parameters->cp_tx0 > parameters->volume_offset_x0) || (parameters->cp_ty0 > parameters->volume_offset_y0) || (parameters->cp_tz0 > parameters->volume_offset_z0)) {

+		fprintf(stdout,	"[ERROR] Tile offset dimension is unnappropriate --> TX0(%d)<=IMG_X0(%d) TYO(%d)<=IMG_Y0(%d) TZO(%d)<=IMG_Z0(%d)\n",

+			parameters->cp_tx0, parameters->volume_offset_x0, parameters->cp_ty0, parameters->volume_offset_y0, 

+			parameters->cp_tz0, parameters->volume_offset_z0);

+		return 1;

+	}

+

+	for (i = 0; i < parameters->numpocs; i++) {

+		if (parameters->POC[i].prg == -1) {

+			fprintf(stdout,"[ERROR] Unrecognized progression order in option -P (POC n %d) [LRCP, RLCP, RPCL, PCRL, CPRL] !!\n",i + 1);

+		}

+	}

+	return 0;

+}

+

+/* -------------------------------------------------------------------------- */

+

+/**

+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 a FILE* client object

+*/

+void info_callback(const char *msg, void *client_data) {

+	FILE *stream = (FILE*)client_data;

+	fprintf(stream, "[INFO] %s", msg);

+}

+

+/* -------------------------------------------------------------------------- */

+

+int main(int argc, char **argv) {

+	bool bSuccess;

+	bool delete_comment = true;

+	opj_cparameters_t parameters;	/* compression parameters */

+	opj_event_mgr_t event_mgr;		/* event manager */

+	opj_volume_t *volume = NULL;

+

+	/* 

+	configure the event callbacks (not required)

+	setting of each callback is optionnal 

+	*/

+	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;

+

+	/* set encoding parameters to default values */

+	opj_set_default_encoder_parameters(&parameters);

+

+	/* parse input and get user encoding parameters */

+	if(parse_cmdline_encoder(argc, argv, &parameters) == 1) {

+		return 0;

+	}

+

+	if(parameters.cp_comment == NULL) {

+		parameters.cp_comment = "Created by OpenJPEG version JP3D";

+		/* no need to delete parameters.cp_comment on exit */

+		delete_comment = false;

+	}

+	

+	/* encode the destination volume */

+	/* ---------------------------- */

+	if (parameters.cod_format == J3D_CFMT || parameters.cod_format == J2K_CFMT)	{

+		int codestream_length, pixels, bitsin;

+		opj_cio_t *cio = NULL;

+		FILE *f = NULL;

+		opj_cinfo_t* cinfo = NULL;

+		

+		/* decode the source volume */

+		/* ----------------------- */

+		switch (parameters.decod_format) {

+			case PGX_DFMT: 

+				fprintf(stdout, "[INFO] Loading pgx file(s)\n");

+				volume = pgxtovolume(parameters.infile, &parameters);

+				if (!volume) {

+					fprintf(stdout, "[ERROR] Unable to load pgx files\n");

+					return 1;

+				}

+				break;

+			

+			case BIN_DFMT:

+				fprintf(stdout, "[INFO] Loading bin file\n");

+				volume = bintovolume(parameters.infile, parameters.imgfile, &parameters);

+				if (!volume) {

+					fprintf(stdout, "[ERROR] Unable to load bin file\n");

+					return 1;

+				}

+				break;

+

+			case IMG_DFMT:

+				fprintf(stdout, "[INFO] Loading img file\n");

+				volume = imgtovolume(parameters.infile, &parameters);

+				if (!volume) {

+					fprintf(stderr, "[ERROR] Unable to load img file\n");

+					return 1;

+				}

+				break;

+		}

+		

+		/* get a JP3D or J2K compressor handle */

+		if (parameters.cod_format == J3D_CFMT) 

+            cinfo = opj_create_compress(CODEC_J3D);

+		else if (parameters.cod_format == J2K_CFMT) 

+            cinfo = opj_create_compress(CODEC_J2K);

+

+		/* catch events using our callbacks and give a local context */

+		opj_set_event_mgr((opj_common_ptr)cinfo, &event_mgr, stdout);			

+

+		/* setup the encoder parameters using the current volume and using user parameters */

+		opj_setup_encoder(cinfo, &parameters, volume);

+		

+		/* open a byte stream for writing */

+		/* allocate memory for all tiles */

+		cio = opj_cio_open((opj_common_ptr)cinfo, NULL, 0);

+

+		/* encode the volume */

+		//fprintf(stdout, "[INFO] Encode the volume\n");

+		bSuccess = opj_encode(cinfo, cio, volume, parameters.index);

+		if (!bSuccess) {

+			opj_cio_close(cio);

+			fprintf(stdout, "[ERROR] Failed to encode volume\n");

+			return 1;

+		}

+		codestream_length = cio_tell(cio);

+		pixels =(volume->x1 - volume->x0) * (volume->y1 - volume->y0) * (volume->z1 - volume->z0);

+		bitsin = pixels * volume->comps[0].prec;

+		fprintf(stdout, "[RESULT] Volume: %d x %d x %d (x %d bpv)\n Codestream: %d B,  Ratio: %5.3f bpv,  (%5.3f : 1) \n", 

+			(volume->x1 - volume->x0),(volume->y1 - volume->y0),(volume->z1 - volume->z0),volume->comps[0].prec,

+			codestream_length, ((double)codestream_length * 8.0/(double)pixels), ((double)bitsin/(8.0*(double)codestream_length)));

+

+		/* write the buffer to disk */

+		f = fopen(parameters.outfile, "wb");

+		if (!f) {

+			fprintf(stdout, "[ERROR] Failed to open %s for writing\n", parameters.outfile);

+			return 1;

+		}

+		fwrite(cio->buffer, 1, codestream_length, f);

+		fclose(f);

+

+		/* close and free the byte stream */

+		opj_cio_close(cio);

+

+		/* free remaining compression structures */

+		opj_destroy_compress(cinfo);

+	} else {

+		fprintf(stdout, "[ERROR] Cod_format != JP3d !!! \n");

+		return 1;

+	}

+

+	/* free user parameters structure */

+	if(delete_comment) {

+		if(parameters.cp_comment) free(parameters.cp_comment);

+	}

+	if(parameters.cp_matrice) free(parameters.cp_matrice);

+

+	/* free volume data */

+	opj_volume_destroy(volume);

+	

+	return 0;

+}

diff --git a/src/bin/jp3d/windirent.h b/src/bin/jp3d/windirent.h
new file mode 100644
index 00000000..72b38cea
--- /dev/null
+++ b/src/bin/jp3d/windirent.h
@@ -0,0 +1,678 @@
+/*
+ * uce-dirent.h - operating system independent dirent implementation
+ * 
+ * Copyright (C) 1998-2002  Toni Ronkko
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * ``Software''), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL TONI RONKKO BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ * 
+ * May 28 1998, Toni Ronkko <tronkko@messi.uku.fi>
+ *
+ * $Id: uce-dirent.h,v 1.7 2002/05/13 10:48:35 tr Exp $
+ *
+ * $Log: uce-dirent.h,v $
+ * Revision 1.7  2002/05/13 10:48:35  tr
+ * embedded some source code directly to the header so that no source
+ * modules need to be included in the MS Visual C project using the
+ * interface, removed all the dependencies to other headers of the `uce'
+ * library so that the header can be made public
+ *
+ * Revision 1.6  2002/04/12 16:22:04  tr
+ * Unified Compiling Environment (UCE) replaced `std' library
+ *
+ * Revision 1.5  2001/07/20 16:33:40  tr
+ * moved to `std' library and re-named defines accordingly
+ *
+ * Revision 1.4  2001/07/10 16:47:18  tronkko
+ * revised comments
+ *
+ * Revision 1.3  2001/01/11 13:16:43  tr
+ * using ``uce-machine.h'' for finding out defines such as `FREEBSD'
+ *
+ * Revision 1.2  2000/10/08 16:00:41  tr
+ * copy of FreeBSD man page
+ *
+ * Revision 1.1  2000/07/10 05:53:16  tr
+ * Initial revision
+ *
+ * Revision 1.2  1998/07/19 18:29:14  tr
+ * Added error reporting capabilities and some asserts.
+ *
+ * Revision 1.1  1998/07/04 16:27:51  tr
+ * Initial revision
+ *
+ * 
+ * MSVC 1.0 scans automatic dependencies incorrectly when your project
+ * contains this very header.  The problem is that MSVC cannot handle
+ * include directives inside #if..#endif block those are never entered.
+ * Since this header ought to compile in many different operating systems,
+ * there had to be several conditional blocks that are compiled only in
+ * operating systems for what they were designed for.  MSVC 1.0 cannot
+ * handle inclusion of sys/dir.h in a part that is compiled only in Apollo
+ * operating system.  To fix the problem you need to insert DIR.H into
+ * SYSINCL.DAT located in MSVC\BIN directory and restart visual C++.
+ * Consult manuals for more informaton about the problem.
+ *
+ * Since many UNIX systems have dirent.h we assume to have one also.
+ * However, if your UNIX system does not have dirent.h you can download one
+ * for example at: http://ftp.uni-mannheim.de/ftp/GNU/dirent/dirent.tar.gz.
+ * You can also see if you have one of dirent.h, direct.h, dir.h, ndir.h,
+ * sys/dir.h and sys/ndir.h somewhere.  Try defining HAVE_DIRENT_H,
+ * HAVE_DIRECT_H, HAVE_DIR_H, HAVE_NDIR_H, HAVE_SYS_DIR_H and
+ * HAVE_SYS_NDIR_H according to the files found.
+ */
+#ifndef DIRENT_H
+#define DIRENT_H
+#define DIRENT_H_INCLUDED
+
+/* find out platform */
+#if defined(MSDOS)                             /* MS-DOS */
+#elif defined(__MSDOS__)                       /* Turbo C/Borland */
+# define MSDOS
+#elif defined(__DOS__)                         /* Watcom */
+# define MSDOS
+#endif
+
+#if defined(WIN32)                             /* MS-Windows */
+#elif defined(__NT__)                          /* Watcom */
+# define WIN32
+#elif defined(_WIN32)                          /* Microsoft */
+# define WIN32
+#elif defined(__WIN32__)                       /* Borland */
+# define WIN32
+#endif
+
+/*
+ * See what kind of dirent interface we have unless autoconf has already
+ * determinated that.
+ */
+#if !defined(HAVE_DIRENT_H) && !defined(HAVE_DIRECT_H) && !defined(HAVE_SYS_DIR_H) && !defined(HAVE_NDIR_H) && !defined(HAVE_SYS_NDIR_H) && !defined(HAVE_DIR_H)
+# if defined(_MSC_VER)                         /* Microsoft C/C++ */
+    /* no dirent.h */
+# elif defined(__MINGW32__)                    /* MinGW */
+    /* no dirent.h */
+# elif defined(__BORLANDC__)                   /* Borland C/C++ */
+#   define HAVE_DIRENT_H
+#   define VOID_CLOSEDIR
+# elif defined(__TURBOC__)                     /* Borland Turbo C */
+    /* no dirent.h */
+# elif defined(__WATCOMC__)                    /* Watcom C/C++ */
+#   define HAVE_DIRECT_H
+# elif defined(__apollo)                       /* Apollo */
+#   define HAVE_SYS_DIR_H
+# elif defined(__hpux)                         /* HP-UX */
+#   define HAVE_DIRENT_H
+# elif defined(__alpha) || defined(__alpha__)  /* Alpha OSF1 */
+#   error "not implemented"
+# elif defined(__sgi)                          /* Silicon Graphics */
+#   define HAVE_DIRENT_H
+# elif defined(sun) || defined(_sun)           /* Sun Solaris */
+#   define HAVE_DIRENT_H
+# elif defined(__FreeBSD__)                    /* FreeBSD */
+#   define HAVE_DIRENT_H
+# elif defined(__linux__)                      /* Linux */
+#   define HAVE_DIRENT_H
+# elif defined(__GNUC__)                       /* GNU C/C++ */
+#   define HAVE_DIRENT_H
+# else
+#   error "not implemented"
+# endif
+#endif
+
+/* include proper interface headers */
+#if defined(HAVE_DIRENT_H)
+# include <dirent.h>
+# ifdef FREEBSD
+#   define NAMLEN(dp) ((int)((dp)->d_namlen))
+# else
+#   define NAMLEN(dp) ((int)(strlen((dp)->d_name)))
+# endif
+
+#elif defined(HAVE_NDIR_H)
+# include <ndir.h>
+# define NAMLEN(dp) ((int)((dp)->d_namlen))
+
+#elif defined(HAVE_SYS_NDIR_H)
+# include <sys/ndir.h>
+# define NAMLEN(dp) ((int)((dp)->d_namlen))
+
+#elif defined(HAVE_DIRECT_H)
+# include <direct.h>
+# define NAMLEN(dp) ((int)((dp)->d_namlen))
+
+#elif defined(HAVE_DIR_H)
+# include <dir.h>
+# define NAMLEN(dp) ((int)((dp)->d_namlen))
+
+#elif defined(HAVE_SYS_DIR_H)
+# include <sys/types.h>
+# include <sys/dir.h>
+# ifndef dirent
+#   define dirent direct
+# endif
+# define NAMLEN(dp) ((int)((dp)->d_namlen))
+
+#elif defined(MSDOS) || defined(WIN32)
+
+  /* figure out type of underlaying directory interface to be used */
+# if defined(WIN32)
+#   define DIRENT_WIN32_INTERFACE
+# elif defined(MSDOS)
+#   define DIRENT_MSDOS_INTERFACE
+# else
+#   error "missing native dirent interface"
+# endif
+
+  /*** WIN32 specifics ***/
+# if defined(DIRENT_WIN32_INTERFACE)
+#   include <windows.h>
+#   if !defined(DIRENT_MAXNAMLEN)
+#     define DIRENT_MAXNAMLEN (MAX_PATH)
+#   endif
+
+
+  /*** MS-DOS specifics ***/
+# elif defined(DIRENT_MSDOS_INTERFACE)
+#   include <dos.h>
+
+    /* Borland defines file length macros in dir.h */
+#   if defined(__BORLANDC__)
+#     include <dir.h>
+#     if !defined(DIRENT_MAXNAMLEN)
+#       define DIRENT_MAXNAMLEN ((MAXFILE)+(MAXEXT))
+#     endif
+#     if !defined(_find_t)
+#       define _find_t find_t
+#     endif
+
+    /* Turbo C defines ffblk structure in dir.h */
+#   elif defined(__TURBOC__)
+#     include <dir.h>
+#     if !defined(DIRENT_MAXNAMLEN)
+#       define DIRENT_MAXNAMLEN ((MAXFILE)+(MAXEXT))
+#     endif
+#     define DIRENT_USE_FFBLK
+
+    /* MSVC */
+#   elif defined(_MSC_VER)
+#     if !defined(DIRENT_MAXNAMLEN)
+#       define DIRENT_MAXNAMLEN (12)
+#     endif
+
+    /* Watcom */
+#   elif defined(__WATCOMC__)
+#     if !defined(DIRENT_MAXNAMLEN)
+#       if defined(__OS2__) || defined(__NT__)
+#         define DIRENT_MAXNAMLEN (255)
+#       else
+#         define DIRENT_MAXNAMLEN (12)
+#       endif
+#     endif
+
+#   endif
+# endif
+
+  /*** generic MS-DOS and MS-Windows stuff ***/
+# if !defined(NAME_MAX) && defined(DIRENT_MAXNAMLEN)
+#   define NAME_MAX DIRENT_MAXNAMLEN
+# endif
+# if NAME_MAX < DIRENT_MAXNAMLEN
+#   error "assertion failed: NAME_MAX >= DIRENT_MAXNAMLEN"
+# endif
+
+
+  /*
+   * Substitute for real dirent structure.  Note that `d_name' field is a
+   * true character array although we have it copied in the implementation
+   * dependent data.  We could save some memory if we had declared `d_name'
+   * as a pointer refering the name within implementation dependent data.
+   * We have not done that since some code may rely on sizeof(d_name) to be
+   * something other than four.  Besides, directory entries are typically so
+   * small that it takes virtually no time to copy them from place to place.
+   */
+  typedef struct dirent {
+    char d_name[NAME_MAX + 1];
+
+    /*** Operating system specific part ***/
+# if defined(DIRENT_WIN32_INTERFACE)       /*WIN32*/
+    WIN32_FIND_DATA data;
+# elif defined(DIRENT_MSDOS_INTERFACE)     /*MSDOS*/
+#   if defined(DIRENT_USE_FFBLK)
+    struct ffblk data;
+#   else
+    struct _find_t data;
+#   endif
+# endif
+  } dirent;
+
+  /* DIR substitute structure containing directory name.  The name is
+   * essential for the operation of ``rewinndir'' function. */
+  typedef struct DIR {
+    char          *dirname;                    /* directory being scanned */
+    dirent        current;                     /* current entry */
+    int           dirent_filled;               /* is current un-processed? */
+
+  /*** Operating system specific part ***/
+#  if defined(DIRENT_WIN32_INTERFACE)
+    HANDLE        search_handle;
+#  elif defined(DIRENT_MSDOS_INTERFACE)
+#  endif
+  } DIR;
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+/* supply prototypes for dirent functions */
+static DIR *opendir (const char *dirname);
+static struct dirent *readdir (DIR *dirp);
+static int closedir (DIR *dirp);
+static void rewinddir (DIR *dirp);
+
+/*
+ * Implement dirent interface as static functions so that the user does not
+ * need to change his project in any way to use dirent function.  With this
+ * it is sufficient to include this very header from source modules using
+ * dirent functions and the functions will be pulled in automatically.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <errno.h>
+
+/* use ffblk instead of _find_t if requested */
+#if defined(DIRENT_USE_FFBLK)
+# define _A_ARCH   (FA_ARCH)
+# define _A_HIDDEN (FA_HIDDEN)
+# define _A_NORMAL (0)
+# define _A_RDONLY (FA_RDONLY)
+# define _A_SUBDIR (FA_DIREC)
+# define _A_SYSTEM (FA_SYSTEM)
+# define _A_VOLID  (FA_LABEL)
+# define _dos_findnext(dest) findnext(dest)
+# define _dos_findfirst(name,flags,dest) findfirst(name,dest,flags)
+#endif
+
+static int _initdir (DIR *p);
+static const char *_getdirname (const struct dirent *dp);
+static void _setdirname (struct DIR *dirp);
+
+/*
+ * <function name="opendir">
+ * <intro>open directory stream for reading
+ * <syntax>DIR *opendir (const char *dirname);
+ *
+ * <desc>Open named directory stream for read and return pointer to the
+ * internal working area that is used for retrieving individual directory
+ * entries.  The internal working area has no fields of your interest.
+ *
+ * <ret>Returns a pointer to the internal working area or NULL in case the 
+ * directory stream could not be opened.  Global `errno' variable will set
+ * in case of error as follows:
+ *
+ * <table>
+ * [EACESS  |Permission denied.
+ * [EMFILE  |Too many open files used by the process.
+ * [ENFILE  |Too many open files in system.
+ * [ENOENT  |Directory does not exist.
+ * [ENOMEM  |Insufficient memory.
+ * [ENOTDIR |dirname does not refer to directory.  This value is not
+ *           reliable on MS-DOS and MS-Windows platforms.  Many
+ *           implementations return ENOENT even when the name refers to a
+ *           file.]
+ * </table>
+ * </function>
+ */
+static DIR *opendir(const char *dirname)
+{
+  DIR *dirp;
+  assert (dirname != NULL);
+  
+  dirp = (DIR*)malloc (sizeof (struct DIR));
+  if (dirp != NULL) {
+    char *p;
+    
+    /* allocate room for directory name */
+    dirp->dirname = (char*) malloc (strlen (dirname) + 1 + strlen ("\\*.*"));
+    if (dirp->dirname == NULL) {
+      /* failed to duplicate directory name.  errno set by malloc() */
+      free (dirp);
+      return NULL;
+    }
+    /* Copy directory name while appending directory separator and "*.*".
+     * Directory separator is not appended if the name already ends with
+     * drive or directory separator.  Directory separator is assumed to be
+     * '/' or '\' and drive separator is assumed to be ':'. */
+    strcpy (dirp->dirname, dirname);
+    p = strchr (dirp->dirname, '\0');
+    if (dirp->dirname < p  &&
+        *(p - 1) != '\\'  &&  *(p - 1) != '/'  &&  *(p - 1) != ':')
+    {
+      strcpy (p++, "\\");
+    }
+# ifdef DIRENT_WIN32_INTERFACE
+    strcpy (p, "*"); /*scan files with and without extension in win32*/
+# else
+    strcpy (p, "*.*"); /*scan files with and without extension in DOS*/
+# endif
+
+    /* open stream */
+    if (_initdir (dirp) == 0) {
+      /* initialization failed */
+      free (dirp->dirname);
+      free (dirp);
+      return NULL;
+    }
+  }
+  return dirp;
+}
+
+
+/*
+ * <function name="readdir">
+ * <intro>read a directory entry
+ * <syntax>struct dirent *readdir (DIR *dirp);
+ *
+ * <desc>Read individual directory entry and return pointer to a structure
+ * containing the name of the entry.  Individual directory entries returned
+ * include normal files, sub-directories, pseudo-directories "." and ".."
+ * and also volume labels, hidden files and system files in MS-DOS and
+ * MS-Windows.   You might want to use stat(2) function to determinate which
+ * one are you dealing with.  Many dirent implementations already contain
+ * equivalent information in dirent structure but you cannot depend on
+ * this.
+ *
+ * The dirent structure contains several system dependent fields that
+ * generally have no interest to you.  The only interesting one is char
+ * d_name[] that is also portable across different systems.  The d_name
+ * field contains the name of the directory entry without leading path.
+ * While d_name is portable across different systems the actual storage
+ * capacity of d_name varies from system to system and there is no portable
+ * way to find out it at compile time as different systems define the
+ * capacity of d_name with different macros and some systems do not define
+ * capacity at all (besides actual declaration of the field). If you really
+ * need to find out storage capacity of d_name then you might want to try
+ * NAME_MAX macro. The NAME_MAX is defined in POSIX standard althought
+ * there are many MS-DOS and MS-Windows implementations those do not define
+ * it.  There are also systems that declare d_name as "char d_name[1]" and
+ * then allocate suitable amount of memory at run-time.  Thanks to Alain
+ * Decamps (Alain.Decamps@advalvas.be) for pointing it out to me.
+ *
+ * This all leads to the fact that it is difficult to allocate space
+ * for the directory names when the very same program is being compiled on
+ * number of operating systems.  Therefore I suggest that you always
+ * allocate space for directory names dynamically.
+ *
+ * <ret>
+ * Returns a pointer to a structure containing name of the directory entry
+ * in `d_name' field or NULL if there was an error.  In case of an error the
+ * global `errno' variable will set as follows:
+ *
+ * <table>
+ * [EBADF  |dir parameter refers to an invalid directory stream.  This value
+ *          is not set reliably on all implementations.]
+ * </table>
+ * </function>
+ */
+static struct dirent *
+readdir (DIR *dirp)
+{
+  assert(dirp != NULL);
+  if (dirp == NULL) {
+    errno = EBADF;
+    return NULL;
+  }
+
+#if defined(DIRENT_WIN32_INTERFACE)
+  if (dirp->search_handle == INVALID_HANDLE_VALUE) {
+    /* directory stream was opened/rewound incorrectly or it ended normally */
+    errno = EBADF;
+    return NULL;
+  }
+#endif
+
+  if (dirp->dirent_filled != 0) {
+    /*
+     * Directory entry has already been retrieved and there is no need to
+     * retrieve a new one.  Directory entry will be retrieved in advance
+     * when the user calls readdir function for the first time.  This is so
+     * because real dirent has separate functions for opening and reading
+     * the stream whereas Win32 and DOS dirents open the stream
+     * automatically when we retrieve the first file.  Therefore, we have to
+     * save the first file when opening the stream and later we have to
+     * return the saved entry when the user tries to read the first entry.
+     */
+    dirp->dirent_filled = 0;
+  } else {
+    /* fill in entry and return that */
+#if defined(DIRENT_WIN32_INTERFACE)
+    if (FindNextFile (dirp->search_handle, &dirp->current.data) == FALSE) {
+      /* Last file has been processed or an error occured */
+      FindClose (dirp->search_handle);
+      dirp->search_handle = INVALID_HANDLE_VALUE;
+      errno = ENOENT;
+      return NULL;
+    }
+
+# elif defined(DIRENT_MSDOS_INTERFACE)
+    if (_dos_findnext (&dirp->current.data) != 0) {
+      /* _dos_findnext and findnext will set errno to ENOENT when no
+       * more entries could be retrieved. */
+      return NULL;
+    }
+# endif
+
+    _setdirname (dirp);
+    assert (dirp->dirent_filled == 0);
+  }
+  return &dirp->current;
+}
+
+
+/*
+ * <function name="closedir">
+ * <intro>close directory stream.
+ * <syntax>int closedir (DIR *dirp);
+ *
+ * <desc>Close directory stream opened by the `opendir' function.  Close of
+ * directory stream invalidates the DIR structure as well as previously read
+ * dirent entry.
+ *
+ * <ret>The function typically returns 0 on success and -1 on failure but
+ * the function may be declared to return void on same systems.  At least
+ * Borland C/C++ and some UNIX implementations use void as a return type.
+ * The dirent wrapper tries to define VOID_CLOSEDIR whenever closedir is
+ * known to return nothing.  The very same definition is made by the GNU
+ * autoconf if you happen to use it.
+ *
+ * The global `errno' variable will set to EBADF in case of error.
+ * </function>
+ */
+static int
+closedir (DIR *dirp)
+{   
+  int retcode = 0;
+
+  /* make sure that dirp points to legal structure */
+  assert (dirp != NULL);
+  if (dirp == NULL) {
+    errno = EBADF;
+    return -1;
+  }
+ 
+  /* free directory name and search handles */
+  if (dirp->dirname != NULL) free (dirp->dirname);
+
+#if defined(DIRENT_WIN32_INTERFACE)
+  if (dirp->search_handle != INVALID_HANDLE_VALUE) {
+    if (FindClose (dirp->search_handle) == FALSE) {
+      /* Unknown error */
+      retcode = -1;
+      errno = EBADF;
+    }
+  }
+#endif                     
+
+  /* clear dirp structure to make sure that it cannot be used anymore*/
+  memset (dirp, 0, sizeof (*dirp));
+# if defined(DIRENT_WIN32_INTERFACE)
+  dirp->search_handle = INVALID_HANDLE_VALUE;
+# endif
+
+  free (dirp);
+  return retcode;
+}
+
+
+/*
+ * <function name="rewinddir">
+ * <intro>rewind directory stream to the beginning
+ * <syntax>void rewinddir (DIR *dirp);
+ *
+ * <desc>Rewind directory stream to the beginning so that the next call of
+ * readdir() returns the very first directory entry again.  However, note
+ * that next call of readdir() may not return the same directory entry as it
+ * did in first time.  The directory stream may have been affected by newly
+ * created files.
+ *
+ * Almost every dirent implementation ensure that rewinddir will update
+ * the directory stream to reflect any changes made to the directory entries
+ * since the previous ``opendir'' or ``rewinddir'' call.  Keep an eye on
+ * this if your program depends on the feature.  I know at least one dirent
+ * implementation where you are required to close and re-open the stream to
+ * see the changes.
+ *
+ * <ret>Returns nothing.  If something went wrong while rewinding, you will
+ * notice it later when you try to retrieve the first directory entry.
+ */
+static void
+rewinddir (DIR *dirp)
+{   
+  /* make sure that dirp is legal */
+  assert (dirp != NULL);
+  if (dirp == NULL) {
+    errno = EBADF;
+    return;
+  }
+  assert (dirp->dirname != NULL);
+  
+  /* close previous stream */
+#if defined(DIRENT_WIN32_INTERFACE)
+  if (dirp->search_handle != INVALID_HANDLE_VALUE) {
+    if (FindClose (dirp->search_handle) == FALSE) {
+      /* Unknown error */
+      errno = EBADF;
+    }
+  }
+#endif
+
+  /* re-open previous stream */
+  if (_initdir (dirp) == 0) {
+    /* initialization failed but we cannot deal with error.  User will notice
+     * error later when she tries to retrieve first directory enty. */
+    /*EMPTY*/;
+  }
+}
+
+
+/*
+ * Open native directory stream object and retrieve first file.
+ * Be sure to close previous stream before opening new one.
+ */
+static int
+_initdir (DIR *dirp)
+{ 
+  assert (dirp != NULL);
+  assert (dirp->dirname != NULL);
+  dirp->dirent_filled = 0;
+
+# if defined(DIRENT_WIN32_INTERFACE)
+  /* Open stream and retrieve first file */
+  dirp->search_handle = FindFirstFile (dirp->dirname, &dirp->current.data);
+  if (dirp->search_handle == INVALID_HANDLE_VALUE) {
+    /* something went wrong but we don't know what.  GetLastError() could
+     * give us more information about the error, but then we should map
+     * the error code into errno. */
+    errno = ENOENT;
+    return 0;
+  }
+
+# elif defined(DIRENT_MSDOS_INTERFACE)
+  if (_dos_findfirst (dirp->dirname,
+          _A_SUBDIR | _A_RDONLY | _A_ARCH | _A_SYSTEM | _A_HIDDEN,
+          &dirp->current.data) != 0)
+  {
+    /* _dos_findfirst and findfirst will set errno to ENOENT when no 
+     * more entries could be retrieved. */
+    return 0;
+  }
+# endif
+
+  /* initialize DIR and it's first entry */
+  _setdirname (dirp);
+  dirp->dirent_filled = 1;
+  return 1;
+}
+
+
+/*
+ * Return implementation dependent name of the current directory entry.
+ */
+static const char *
+_getdirname (const struct dirent *dp)
+{
+#if defined(DIRENT_WIN32_INTERFACE)
+  return dp->data.cFileName;
+  
+#elif defined(DIRENT_USE_FFBLK)
+  return dp->data.ff_name;
+  
+#else
+  return dp->data.name;
+#endif  
+}
+
+
+/*
+ * Copy name of implementation dependent directory entry to the d_name field.
+ */
+static void
+_setdirname (struct DIR *dirp) {
+  /* make sure that d_name is long enough */
+  assert (strlen (_getdirname (&dirp->current)) <= NAME_MAX);
+  
+  strncpy (dirp->current.d_name,
+      _getdirname (&dirp->current),
+      NAME_MAX);
+  dirp->current.d_name[NAME_MAX] = '\0'; /*char d_name[NAME_MAX+1]*/
+}
+  
+# ifdef __cplusplus
+}
+# endif
+# define NAMLEN(dp) ((int)(strlen((dp)->d_name)))
+
+#else
+# error "missing dirent interface"
+#endif
+
+
+#endif /*DIRENT_H*/