initial release of jp3d library and codec

14 files changed, 2988 insertions, 0 deletions

diff --git a/codec/convert.c b/codec/convert.c
new file mode 100755
index 00000000..07ecd929
--- /dev/null
+++ b/codec/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, Hervé 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 "openjpeg.h"
+#ifdef WIN32
+#include "dirent.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/codec/convert.h b/codec/convert.h
new file mode 100755
index 00000000..18ae2127
--- /dev/null
+++ b/codec/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, HervŽ 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/codec/getopt.c b/codec/getopt.c
new file mode 100755
index 00000000..69addc97
--- /dev/null
+++ b/codec/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/codec/getopt.h b/codec/getopt.h
new file mode 100755
index 00000000..23299d1b
--- /dev/null
+++ b/codec/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/codec/jp3d_to_volume.c b/codec/jp3d_to_volume.c
new file mode 100755
index 00000000..81dc1c78
--- /dev/null
+++ b/codec/jp3d_to_volume.c
@@ -0,0 +1,535 @@
+/*

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

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

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

+ * Copyright (c) 2005, Hervé 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 "openjpeg.h"

+#include "getopt.h"

+#include "convert.h"

+

+#ifndef WIN32

+#define stricmp strcasecmp

+#define strnicmp strncasecmp

+#endif

+

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

+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, '.') + 1;

+	for(i = 0; i < sizeof(format); 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/codec/jp3d_vm_dec.ncb b/codec/jp3d_vm_dec.ncb
new file mode 100755
index 00000000..fc66b661
--- /dev/null
+++ b/codec/jp3d_vm_dec.ncb
diff --git a/codec/jp3d_vm_dec.sln b/codec/jp3d_vm_dec.sln
new file mode 100755
index 00000000..e696c5f7
--- /dev/null
+++ b/codec/jp3d_vm_dec.sln
@@ -0,0 +1,30 @@
+Microsoft Visual Studio Solution File, Format Version 8.00

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "jp3d_vm_dec", "jp3d_vm_dec.vcproj", "{E0C1B905-5B10-4C9A-AF55-2D8144D518AB}"

+	ProjectSection(ProjectDependencies) = postProject

+		{6F3FB035-8F4E-4794-B091-0F0A20223BE7} = {6F3FB035-8F4E-4794-B091-0F0A20223BE7}

+	EndProjectSection

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "LibJp3dVM", "..\LibJp3dVM.vcproj", "{6F3FB035-8F4E-4794-B091-0F0A20223BE7}"

+	ProjectSection(ProjectDependencies) = postProject

+	EndProjectSection

+EndProject

+Global

+	GlobalSection(SolutionConfiguration) = preSolution

+		Debug = Debug

+		Release = Release

+	EndGlobalSection

+	GlobalSection(ProjectConfiguration) = postSolution

+		{E0C1B905-5B10-4C9A-AF55-2D8144D518AB}.Debug.ActiveCfg = Debug|Win32

+		{E0C1B905-5B10-4C9A-AF55-2D8144D518AB}.Debug.Build.0 = Debug|Win32

+		{E0C1B905-5B10-4C9A-AF55-2D8144D518AB}.Release.ActiveCfg = Release|Win32

+		{E0C1B905-5B10-4C9A-AF55-2D8144D518AB}.Release.Build.0 = Release|Win32

+		{6F3FB035-8F4E-4794-B091-0F0A20223BE7}.Debug.ActiveCfg = Debug|Win32

+		{6F3FB035-8F4E-4794-B091-0F0A20223BE7}.Debug.Build.0 = Debug|Win32

+		{6F3FB035-8F4E-4794-B091-0F0A20223BE7}.Release.ActiveCfg = Release|Win32

+		{6F3FB035-8F4E-4794-B091-0F0A20223BE7}.Release.Build.0 = Release|Win32

+	EndGlobalSection

+	GlobalSection(ExtensibilityGlobals) = postSolution

+	EndGlobalSection

+	GlobalSection(ExtensibilityAddIns) = postSolution

+	EndGlobalSection

+EndGlobal

diff --git a/codec/jp3d_vm_dec.suo b/codec/jp3d_vm_dec.suo
new file mode 100755
index 00000000..28c2e255
--- /dev/null
+++ b/codec/jp3d_vm_dec.suo
diff --git a/codec/jp3d_vm_dec.vcproj b/codec/jp3d_vm_dec.vcproj
new file mode 100755
index 00000000..142c68d4
--- /dev/null
+++ b/codec/jp3d_vm_dec.vcproj
@@ -0,0 +1,157 @@
+<?xml version="1.0" encoding="Windows-1252"?>

+<VisualStudioProject

+	ProjectType="Visual C++"

+	Version="7.10"

+	Name="jp3d_vm_dec"

+	ProjectGUID="{E0C1B905-5B10-4C9A-AF55-2D8144D518AB}"

+	SccProjectName=""

+	SccLocalPath="">

+	<Platforms>

+		<Platform

+			Name="Win32"/>

+	</Platforms>

+	<Configurations>

+		<Configuration

+			Name="Debug|Win32"

+			OutputDirectory=".\Debug"

+			IntermediateDirectory=".\Debug"

+			ConfigurationType="1"

+			UseOfMFC="0"

+			ATLMinimizesCRunTimeLibraryUsage="FALSE"

+			CharacterSet="2">

+			<Tool

+				Name="VCCLCompilerTool"

+				Optimization="0"

+				AdditionalIncludeDirectories="../libjp3dvm"

+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;OPJ_STATIC"

+				BasicRuntimeChecks="3"

+				RuntimeLibrary="1"

+				UsePrecompiledHeader="2"

+				PrecompiledHeaderFile=".\Debug/jp3d_vm_dec.pch"

+				AssemblerListingLocation=".\Debug/"

+				ObjectFile=".\Debug/"

+				ProgramDataBaseFileName=".\Debug/"

+				WarningLevel="3"

+				SuppressStartupBanner="TRUE"

+				DebugInformationFormat="4"

+				CompileAs="0"/>

+			<Tool

+				Name="VCCustomBuildTool"/>

+			<Tool

+				Name="VCLinkerTool"

+				OutputFile=".\Debug/jp3d_vm_dec.exe"

+				LinkIncremental="0"

+				SuppressStartupBanner="TRUE"

+				GenerateDebugInformation="TRUE"

+				ProgramDatabaseFile=".\Debug/jp3d_vm_dec.pdb"

+				SubSystem="1"

+				TargetMachine="1"/>

+			<Tool

+				Name="VCMIDLTool"

+				TypeLibraryName=".\Debug/j2k_to_image.tlb"

+				HeaderFileName=""/>

+			<Tool

+				Name="VCPostBuildEventTool"

+				CommandLine="copy Debug\jp3d_vm_dec.exe ..\bin"/>

+			<Tool

+				Name="VCPreBuildEventTool"/>

+			<Tool

+				Name="VCPreLinkEventTool"/>

+			<Tool

+				Name="VCResourceCompilerTool"

+				PreprocessorDefinitions="_DEBUG"

+				Culture="1036"/>

+			<Tool

+				Name="VCWebServiceProxyGeneratorTool"/>

+			<Tool

+				Name="VCXMLDataGeneratorTool"/>

+			<Tool

+				Name="VCWebDeploymentTool"/>

+			<Tool

+				Name="VCManagedWrapperGeneratorTool"/>

+			<Tool

+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>

+		</Configuration>

+		<Configuration

+			Name="Release|Win32"

+			OutputDirectory=".\Release"

+			IntermediateDirectory=".\Release"

+			ConfigurationType="1"

+			UseOfMFC="0"

+			ATLMinimizesCRunTimeLibraryUsage="FALSE"

+			CharacterSet="2">

+			<Tool

+				Name="VCCLCompilerTool"

+				Optimization="2"

+				InlineFunctionExpansion="1"

+				AdditionalIncludeDirectories="../libjp3dvm"

+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;OPJ_STATIC"

+				StringPooling="TRUE"

+				RuntimeLibrary="0"

+				EnableFunctionLevelLinking="TRUE"

+				PrecompiledHeaderFile=".\Release/jp3d_vm_dec.pch"

+				AssemblerListingLocation=".\Release/"

+				ObjectFile=".\Release/"

+				ProgramDataBaseFileName=".\Release/"

+				WarningLevel="3"

+				SuppressStartupBanner="TRUE"

+				CompileAs="0"/>

+			<Tool

+				Name="VCCustomBuildTool"/>

+			<Tool

+				Name="VCLinkerTool"

+				OutputFile=".\Release/jp3d_vm_dec.exe"

+				LinkIncremental="1"

+				SuppressStartupBanner="TRUE"

+				ProgramDatabaseFile=".\Release/jp3d_vm_dec.pdb"

+				SubSystem="1"

+				TargetMachine="1"/>

+			<Tool

+				Name="VCMIDLTool"

+				TypeLibraryName=".\Release/j2k_to_image.tlb"

+				HeaderFileName=""/>

+			<Tool

+				Name="VCPostBuildEventTool"

+				CommandLine="copy Release\jp3d_vm_dec.exe ..\bin"/>

+			<Tool

+				Name="VCPreBuildEventTool"/>

+			<Tool

+				Name="VCPreLinkEventTool"/>

+			<Tool

+				Name="VCResourceCompilerTool"

+				PreprocessorDefinitions="NDEBUG"

+				Culture="1036"/>

+			<Tool

+				Name="VCWebServiceProxyGeneratorTool"/>

+			<Tool

+				Name="VCXMLDataGeneratorTool"/>

+			<Tool

+				Name="VCWebDeploymentTool"/>

+			<Tool

+				Name="VCManagedWrapperGeneratorTool"/>

+			<Tool

+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>

+		</Configuration>

+	</Configurations>

+	<References>

+	</References>

+	<Files>

+		<File

+			RelativePath=".\convert.c">

+		</File>

+		<File

+			RelativePath=".\convert.h">

+		</File>

+		<File

+			RelativePath=".\getopt.c">

+		</File>

+		<File

+			RelativePath=".\getopt.h">

+		</File>

+		<File

+			RelativePath=".\jp3d_to_volume.c">

+		</File>

+	</Files>

+	<Globals>

+	</Globals>

+</VisualStudioProject>

diff --git a/codec/jp3d_vm_enc.ncb b/codec/jp3d_vm_enc.ncb
new file mode 100755
index 00000000..7f0733b7
--- /dev/null
+++ b/codec/jp3d_vm_enc.ncb
diff --git a/codec/jp3d_vm_enc.sln b/codec/jp3d_vm_enc.sln
new file mode 100755
index 00000000..a0e6a748
--- /dev/null
+++ b/codec/jp3d_vm_enc.sln
@@ -0,0 +1,35 @@
+Microsoft Visual Studio Solution File, Format Version 8.00

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "jp3d_vm_enc", "jp3d_vm_enc.vcproj", "{A9704A2E-3B93-4BAA-9229-02FC93D27201}"

+	ProjectSection(ProjectDependencies) = postProject

+		{6F3FB035-8F4E-4794-B091-0F0A20223BE7} = {6F3FB035-8F4E-4794-B091-0F0A20223BE7}

+		{6F3FB035-8F4E-4794-B091-0F0A20223BE7} = {6F3FB035-8F4E-4794-B091-0F0A20223BE7}

+		{6F3FB035-8F4E-4794-B091-0F0A20223BE7} = {6F3FB035-8F4E-4794-B091-0F0A20223BE7}

+		{6F3FB035-8F4E-4794-B091-0F0A20223BE7} = {6F3FB035-8F4E-4794-B091-0F0A20223BE7}

+		{6F3FB035-8F4E-4794-B091-0F0A20223BE7} = {6F3FB035-8F4E-4794-B091-0F0A20223BE7}

+	EndProjectSection

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "LibJp3dVM", "..\LibJp3dVM.vcproj", "{6F3FB035-8F4E-4794-B091-0F0A20223BE7}"

+	ProjectSection(ProjectDependencies) = postProject

+		{6F3FB035-8F4E-4794-B091-0F0A20223BE7} = {6F3FB035-8F4E-4794-B091-0F0A20223BE7}

+	EndProjectSection

+EndProject

+Global

+	GlobalSection(SolutionConfiguration) = preSolution

+		Debug = Debug

+		Release = Release

+	EndGlobalSection

+	GlobalSection(ProjectConfiguration) = postSolution

+		{A9704A2E-3B93-4BAA-9229-02FC93D27201}.Debug.ActiveCfg = Debug|Win32

+		{A9704A2E-3B93-4BAA-9229-02FC93D27201}.Debug.Build.0 = Debug|Win32

+		{A9704A2E-3B93-4BAA-9229-02FC93D27201}.Release.ActiveCfg = Release|Win32

+		{A9704A2E-3B93-4BAA-9229-02FC93D27201}.Release.Build.0 = Release|Win32

+		{6F3FB035-8F4E-4794-B091-0F0A20223BE7}.Debug.ActiveCfg = Debug|Win32

+		{6F3FB035-8F4E-4794-B091-0F0A20223BE7}.Debug.Build.0 = Debug|Win32

+		{6F3FB035-8F4E-4794-B091-0F0A20223BE7}.Release.ActiveCfg = Release|Win32

+		{6F3FB035-8F4E-4794-B091-0F0A20223BE7}.Release.Build.0 = Release|Win32

+	EndGlobalSection

+	GlobalSection(ExtensibilityGlobals) = postSolution

+	EndGlobalSection

+	GlobalSection(ExtensibilityAddIns) = postSolution

+	EndGlobalSection

+EndGlobal

diff --git a/codec/jp3d_vm_enc.suo b/codec/jp3d_vm_enc.suo
new file mode 100755
index 00000000..702d0dd8
--- /dev/null
+++ b/codec/jp3d_vm_enc.suo
diff --git a/codec/jp3d_vm_enc.vcproj b/codec/jp3d_vm_enc.vcproj
new file mode 100755
index 00000000..4c24b352
--- /dev/null
+++ b/codec/jp3d_vm_enc.vcproj
@@ -0,0 +1,157 @@
+<?xml version="1.0" encoding="Windows-1252"?>

+<VisualStudioProject

+	ProjectType="Visual C++"

+	Version="7.10"

+	Name="jp3d_vm_enc"

+	ProjectGUID="{A9704A2E-3B93-4BAA-9229-02FC93D27201}"

+	SccProjectName=""

+	SccLocalPath="">

+	<Platforms>

+		<Platform

+			Name="Win32"/>

+	</Platforms>

+	<Configurations>

+		<Configuration

+			Name="Release|Win32"

+			OutputDirectory=".\Release"

+			IntermediateDirectory=".\Release"

+			ConfigurationType="1"

+			UseOfMFC="0"

+			ATLMinimizesCRunTimeLibraryUsage="FALSE"

+			CharacterSet="2">

+			<Tool

+				Name="VCCLCompilerTool"

+				Optimization="2"

+				InlineFunctionExpansion="1"

+				AdditionalIncludeDirectories="../libjp3dvm"

+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;OPJ_STATIC"

+				StringPooling="TRUE"

+				RuntimeLibrary="0"

+				EnableFunctionLevelLinking="TRUE"

+				PrecompiledHeaderFile=".\Release/jp3d_vm_enc.pch"

+				AssemblerListingLocation=".\Release/"

+				ObjectFile=".\Release/"

+				ProgramDataBaseFileName=".\Release/"

+				WarningLevel="3"

+				SuppressStartupBanner="TRUE"

+				CompileAs="0"/>

+			<Tool

+				Name="VCCustomBuildTool"/>

+			<Tool

+				Name="VCLinkerTool"

+				OutputFile=".\Release/jp3d_vm_enc.exe"

+				LinkIncremental="1"

+				SuppressStartupBanner="TRUE"

+				ProgramDatabaseFile=".\Release/jp3d_vm_enc.pdb"

+				SubSystem="1"

+				TargetMachine="1"/>

+			<Tool

+				Name="VCMIDLTool"

+				TypeLibraryName=".\Release/image_to_j2k.tlb"

+				HeaderFileName=""/>

+			<Tool

+				Name="VCPostBuildEventTool"

+				CommandLine="copy Release\jp3d_vm_enc.exe ..\bin"/>

+			<Tool

+				Name="VCPreBuildEventTool"/>

+			<Tool

+				Name="VCPreLinkEventTool"/>

+			<Tool

+				Name="VCResourceCompilerTool"

+				PreprocessorDefinitions="NDEBUG"

+				Culture="1036"/>

+			<Tool

+				Name="VCWebServiceProxyGeneratorTool"/>

+			<Tool

+				Name="VCXMLDataGeneratorTool"/>

+			<Tool

+				Name="VCWebDeploymentTool"/>

+			<Tool

+				Name="VCManagedWrapperGeneratorTool"/>

+			<Tool

+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>

+		</Configuration>

+		<Configuration

+			Name="Debug|Win32"

+			OutputDirectory=".\Debug"

+			IntermediateDirectory=".\Debug"

+			ConfigurationType="1"

+			UseOfMFC="0"

+			ATLMinimizesCRunTimeLibraryUsage="FALSE"

+			CharacterSet="2">

+			<Tool

+				Name="VCCLCompilerTool"

+				Optimization="0"

+				AdditionalIncludeDirectories="../libjp3dvm"

+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;OPJ_STATIC"

+				BasicRuntimeChecks="3"

+				RuntimeLibrary="1"

+				PrecompiledHeaderFile=".\Debug/jp3d_vm_enc.pch"

+				AssemblerListingLocation=".\Debug/"

+				ObjectFile=".\Debug/"

+				ProgramDataBaseFileName=".\Debug/"

+				WarningLevel="3"

+				SuppressStartupBanner="TRUE"

+				DebugInformationFormat="4"

+				CompileAs="0"/>

+			<Tool

+				Name="VCCustomBuildTool"/>

+			<Tool

+				Name="VCLinkerTool"

+				OutputFile=".\Debug/jp3d_vm_enc.exe"

+				LinkIncremental="0"

+				SuppressStartupBanner="TRUE"

+				AdditionalLibraryDirectories=""

+				GenerateDebugInformation="TRUE"

+				ProgramDatabaseFile=".\Debug/jp3d_vm_enc.pdb"

+				SubSystem="1"

+				TargetMachine="1"/>

+			<Tool

+				Name="VCMIDLTool"

+				TypeLibraryName=".\Debug/image_to_j2k.tlb"

+				HeaderFileName=""/>

+			<Tool

+				Name="VCPostBuildEventTool"

+				CommandLine="copy Debug\jp3d_vm_enc.exe ..\bin"/>

+			<Tool

+				Name="VCPreBuildEventTool"/>

+			<Tool

+				Name="VCPreLinkEventTool"/>

+			<Tool

+				Name="VCResourceCompilerTool"

+				PreprocessorDefinitions="_DEBUG"

+				Culture="1036"/>

+			<Tool

+				Name="VCWebServiceProxyGeneratorTool"/>

+			<Tool

+				Name="VCXMLDataGeneratorTool"/>

+			<Tool

+				Name="VCWebDeploymentTool"/>

+			<Tool

+				Name="VCManagedWrapperGeneratorTool"/>

+			<Tool

+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>

+		</Configuration>

+	</Configurations>

+	<References>

+	</References>

+	<Files>

+		<File

+			RelativePath=".\convert.c">

+		</File>

+		<File

+			RelativePath=".\convert.h">

+		</File>

+		<File

+			RelativePath=".\getopt.c">

+		</File>

+		<File

+			RelativePath=".\getopt.h">

+		</File>

+		<File

+			RelativePath=".\volume_to_jp3d.c">

+		</File>

+	</Files>

+	<Globals>

+	</Globals>

+</VisualStudioProject>

diff --git a/codec/volume_to_jp3d.c b/codec/volume_to_jp3d.c
new file mode 100755
index 00000000..84f01e83
--- /dev/null
+++ b/codec/volume_to_jp3d.c
@@ -0,0 +1,903 @@
+/*

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

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

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

+ * Copyright (c) 2005, Hervé 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 "openjpeg.h"

+#include "getopt.h"

+#include "convert.h"

+

+#ifndef WIN32

+#define stricmp strcasecmp

+#define strnicmp strncasecmp

+#endif

+

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

+

+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, '.') + 1;

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

+}