X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=codec%2Fconvert.c;h=5e9f49693f9520ee3171b2eb5326915f34de427d;hb=a6ba04cdf49772f2e90515b277f174a0849bc8b6;hp=94c2e6a48f96e3760e851bce1aa53b3333292ca9;hpb=abe8e93c21b42a738a5035869d9550284a9eb09e;p=openjpeg.git

diff --git a/codec/convert.c b/codec/convert.c
index 94c2e6a4..5e9f4969 100644
--- a/codec/convert.c
+++ b/codec/convert.c
@@ -1,9 +1,11 @@
 /*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
  * 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) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * Copyright (c) 2006-2007, Parvatha Elangovan
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -31,6 +33,8 @@
 #include <stdlib.h>
 #include <string.h>
 #include "openjpeg.h"
+#include "../libs/libtiff/tiffio.h"
+#include "convert.h"
 
 /*
  * Get logarithm of an integer and round downwards.
@@ -63,6 +67,300 @@ static int int_ceildiv(int a, int b) {
 	return (a + b - 1) / b;
 }
 
+
+/* -->> -->> -->> -->>
+
+  TGA IMAGE FORMAT
+
+ <<-- <<-- <<-- <<-- */
+
+// TGA header definition.
+#pragma pack(push,1) // Pack structure byte aligned
+typedef struct tga_header
+{                           
+    uint8   id_length;              /* Image id field length    */
+    uint8   colour_map_type;        /* Colour map type          */
+    uint8   image_type;             /* Image type               */
+    /*
+    ** Colour map specification
+    */
+    uint16  colour_map_index;       /* First entry index        */
+    uint16  colour_map_length;      /* Colour map length        */
+    uint8   colour_map_entry_size;  /* Colour map entry size    */
+    /*
+    ** Image specification
+    */
+    uint16  x_origin;               /* x origin of image        */
+    uint16  y_origin;               /* u origin of image        */
+    uint16  image_width;            /* Image width              */
+    uint16  image_height;           /* Image height             */
+    uint8   pixel_depth;            /* Pixel depth              */
+    uint8   image_desc;             /* Image descriptor         */
+} tga_header;
+#pragma pack(pop) // Return to normal structure packing alignment.
+
+int tga_readheader(FILE *fp, int *bits_per_pixel, int *width, int *height, int *flip_image)
+{
+	int palette_size;
+	tga_header tga ;
+
+	if (!bits_per_pixel || !width || !height || !flip_image)
+		return 0;
+	
+	// Read TGA header
+	fread((uint8*)&tga, sizeof(tga_header), 1, fp);
+
+	*bits_per_pixel = tga.pixel_depth;
+	
+	*width  = tga.image_width;
+	*height = tga.image_height ;
+
+	// Ignore tga identifier, if present ...
+	if (tga.id_length)
+	{
+		uint8 *id = (uint8 *) malloc(tga.id_length);
+		fread(id, tga.id_length, 1, fp);
+		free(id);  
+	}
+
+	// Test for compressed formats ... not yet supported ...
+	// Note :-  9 - RLE encoded palettized.
+	//	  	   10 - RLE encoded RGB.
+	if (tga.image_type > 8)
+	{
+		fprintf(stderr, "Sorry, compressed tga files are not currently supported.\n");
+		return 0 ;
+	}
+
+	*flip_image = !(tga.image_desc & 32);
+
+	// Palettized formats are not yet supported, skip over the palette, if present ... 
+	palette_size = tga.colour_map_length * (tga.colour_map_entry_size/8);
+	
+	if (palette_size>0)
+	{
+		fprintf(stderr, "File contains a palette - not yet supported.");
+		fseek(fp, palette_size, SEEK_CUR);
+	}
+	return 1;
+}
+
+int tga_writeheader(FILE *fp, int bits_per_pixel, int width, int height, bool flip_image)
+{
+	tga_header tga;
+
+	if (!bits_per_pixel || !width || !height)
+		return 0;
+
+	memset(&tga, 0, sizeof(tga_header));
+
+	tga.pixel_depth = bits_per_pixel;
+	tga.image_width  = width;
+	tga.image_height = height;
+	tga.image_type = 2; // Uncompressed.
+	tga.image_desc = 8; // 8 bits per component.
+
+	if (flip_image)
+		tga.image_desc |= 32;
+
+	// Write TGA header
+	fwrite((uint8*)&tga, sizeof(tga_header), 1, fp);
+
+	return 1;
+}
+
+opj_image_t* tgatoimage(const char *filename, opj_cparameters_t *parameters) {
+	FILE *f;
+	opj_image_t *image;
+	uint32 image_width, image_height, pixel_bit_depth;
+	uint32 x, y;
+	int flip_image=0;
+	opj_image_cmptparm_t cmptparm[4];	/* maximum 4 components */
+	int numcomps;
+	OPJ_COLOR_SPACE color_space;
+	bool mono ;
+	bool save_alpha;
+	int subsampling_dx, subsampling_dy;
+	int i;	
+
+	f = fopen(filename, "rb");
+	if (!f) {
+		fprintf(stderr, "Failed to open %s for reading !!\n", filename);
+		return 0;
+	}
+
+	if (!tga_readheader(f, &pixel_bit_depth, &image_width, &image_height, &flip_image))
+		return NULL;
+
+	// We currently only support 24 & 32 bit tga's ...
+	if (!((pixel_bit_depth == 24) || (pixel_bit_depth == 32)))
+		return NULL;
+
+	/* initialize image components */   
+	memset(&cmptparm[0], 0, 4 * sizeof(opj_image_cmptparm_t));
+
+	mono = (pixel_bit_depth == 8) || (pixel_bit_depth == 16);  // Mono with & without alpha.
+	save_alpha = (pixel_bit_depth == 16) || (pixel_bit_depth == 32); // Mono with alpha, or RGB with alpha
+
+	if (mono) {
+		color_space = CLRSPC_GRAY;
+		numcomps = save_alpha ? 2 : 1;
+	}	
+	else {
+		numcomps = save_alpha ? 4 : 3;
+		color_space = CLRSPC_SRGB;
+	}
+
+	subsampling_dx = parameters->subsampling_dx;
+	subsampling_dy = parameters->subsampling_dy;
+
+	for (i = 0; i < numcomps; i++) {
+		cmptparm[i].prec = 8;
+		cmptparm[i].bpp = 8;
+		cmptparm[i].sgnd = 0;
+		cmptparm[i].dx = subsampling_dx;
+		cmptparm[i].dy = subsampling_dy;
+		cmptparm[i].w = image_width;
+		cmptparm[i].h = image_height;
+	}
+
+	/* create the image */
+	image = opj_image_create(numcomps, &cmptparm[0], color_space);
+
+	if (!image)
+		return NULL;
+
+	/* set image offset and reference grid */
+	image->x0 = parameters->image_offset_x0;
+	image->y0 = parameters->image_offset_y0;
+	image->x1 =	!image->x0 ? (image_width - 1) * subsampling_dx + 1 : image->x0 + (image_width - 1) * subsampling_dx + 1;
+	image->y1 =	!image->y0 ? (image_height - 1) * subsampling_dy + 1 : image->y0 + (image_height - 1) * subsampling_dy + 1;
+
+	/* set image data */
+	for (y=0; y < image_height; y++) 
+	{
+		int index;
+
+		if (flip_image)
+			index = (image_height-y-1)*image_width;
+		else
+			index = y*image_width;
+
+		if (numcomps==3)
+		{
+			for (x=0;x<image_width;x++) 
+			{
+				uint8 r,g,b;
+				fread(&b, 1, 1, f);
+				fread(&g, 1, 1, f);
+				fread(&r, 1, 1, f);
+
+				image->comps[0].data[index]=r;
+				image->comps[1].data[index]=g;
+				image->comps[2].data[index]=b;
+				index++;
+			}
+		}
+		else if (numcomps==4)
+		{
+			for (x=0;x<image_width;x++) 
+			{
+				uint8 r,g,b,a;
+				fread(&b, 1, 1, f);
+				fread(&g, 1, 1, f);
+				fread(&r, 1, 1, f);
+				fread(&a, 1, 1, f);
+
+				image->comps[0].data[index]=r;
+				image->comps[1].data[index]=g;
+				image->comps[2].data[index]=b;
+				image->comps[3].data[index]=a;
+				index++;
+			}
+		}
+		else {
+			fprintf(stderr, "Currently unsupported bit depth : %s\n", filename);
+		}
+	}	
+	return image;
+}
+
+int imagetotga(opj_image_t * image, const char *outfile) {
+	int width, height, bpp, x, y;
+	bool write_alpha;
+	int i;
+	uint32 alpha_channel;
+	float r,g,b,a;
+	uint8 value;
+	float scale;
+	FILE *fdest;
+
+	fdest = fopen(outfile, "wb");
+	if (!fdest) {
+		fprintf(stderr, "ERROR -> failed to open %s for writing\n", outfile);
+		return 1;
+	}
+
+	for (i = 0; i < image->numcomps-1; i++)	{
+		if ((image->comps[0].dx != image->comps[i+1].dx) 
+			||(image->comps[0].dy != image->comps[i+1].dy) 
+			||(image->comps[0].prec != image->comps[i+1].prec))	{
+      fprintf(stderr, "Unable to create a tga file with such J2K image charateristics.");
+      return 1;
+   }
+	}
+
+	width  = int_ceildiv(image->x1-image->x0, image->comps[0].dx);
+	height = int_ceildiv(image->y1-image->y0, image->comps[0].dy);
+
+	// Mono with alpha, or RGB with alpha.
+	write_alpha = (image->numcomps==2) || (image->numcomps==4);   
+
+	// Write TGA header 
+	bpp = write_alpha ? 32 : 24;
+	if (!tga_writeheader(fdest, bpp, width, height, true))
+		return 1;
+
+	alpha_channel = image->numcomps-1; 
+
+	scale = 255.0f / (float)((1<<image->comps[0].prec)-1);
+
+	for (y=0; y < height; y++) {
+		uint32 index=y*width;
+
+		for (x=0; x < width; x++, index++)	{
+			r = (float)(image->comps[0].data[index]);
+
+			if (image->numcomps>2) {
+				g = (float)(image->comps[1].data[index]);
+				b = (float)(image->comps[2].data[index]);
+			}
+			else  {// Greyscale ...
+				g = r;
+				b = r;
+			}
+
+			// TGA format writes BGR ...
+			value = (uint8)(b*scale);
+			fwrite(&value,1,1,fdest);
+
+			value = (uint8)(g*scale);
+			fwrite(&value,1,1,fdest);
+
+			value = (uint8)(r*scale);
+			fwrite(&value,1,1,fdest);
+
+			if (write_alpha) {
+				a = (float)(image->comps[alpha_channel].data[index]);
+				value = (uint8)(a*scale);
+				fwrite(&value,1,1,fdest);
+			}
+		}
+	}
+
+	return 0;
+}
+
 /* -->> -->> -->> -->>
 
   BMP IMAGE FORMAT
@@ -122,7 +420,7 @@ opj_image_t* bmptoimage(const char *filename, opj_cparameters_t *parameters) {
   
 	IN = fopen(filename, "rb");
 	if (!IN) {
-		fprintf(stderr, "\033[0;33mFailed to open %s for reading !!\033[0;39m\n", filename);
+		fprintf(stderr, "Failed to open %s for reading !!\n", filename);
 		return 0;
 	}
 	
@@ -344,7 +642,9 @@ opj_image_t* bmptoimage(const char *filename, opj_cparameters_t *parameters) {
 				}
 			}
 			free(RGB);
-            
+      free(table_R);
+      free(table_G);
+      free(table_B);
 		} else if (Info_h.biBitCount == 8 && Info_h.biCompression == 1) {				
 			table_R = (unsigned char *) malloc(256 * sizeof(unsigned char));
 			table_G = (unsigned char *) malloc(256 * sizeof(unsigned char));
@@ -450,6 +750,9 @@ opj_image_t* bmptoimage(const char *filename, opj_cparameters_t *parameters) {
 				}
 			}
 			free(RGB);
+      free(table_R);
+      free(table_G);
+      free(table_B);
 	} else {
 		fprintf(stderr, 
 			"Other system than 24 bits/pixels or 8 bits (no RLE coding) is not yet implemented [%d]\n", Info_h.biBitCount);
@@ -464,6 +767,7 @@ int imagetobmp(opj_image_t * image, const char *outfile) {
 	int w, wr, h, hr;
 	int i, pad;
 	FILE *fdest = NULL;
+	int adjustR, adjustG, adjustB;
 
 	if (image->numcomps == 3 && image->comps[0].dx == image->comps[1].dx
 		&& image->comps[1].dx == image->comps[2].dx
@@ -482,13 +786,9 @@ int imagetobmp(opj_image_t * image, const char *outfile) {
 			return 1;
 		}
 	    
-		/* w = int_ceildiv(image->x1 - image->x0, image->comps[0].dx); */
-		/* wr = int_ceildiv(int_ceildivpow2(image->x1 - image->x0,image->factor), image->comps[0].dx); */
 		w = image->comps[0].w;
 		wr = int_ceildivpow2(image->comps[0].w, image->comps[0].factor);
 	    
-		/* h = int_ceildiv(image->y1 - image->y0, image->comps[0].dy); */
-		/* hr = int_ceildiv(int_ceildivpow2(image->y1 - image->y0,image->factor), image->comps[0].dy); */
 		h = image->comps[0].h;
 		hr = int_ceildivpow2(image->comps[0].h, image->comps[0].factor);
 	    
@@ -527,16 +827,40 @@ int imagetobmp(opj_image_t * image, const char *outfile) {
 		fprintf(fdest, "%c%c%c%c", (0) & 0xff, ((0) >> 8) & 0xff, ((0) >> 16) & 0xff, ((0) >> 24) & 0xff);
 		fprintf(fdest, "%c%c%c%c", (0) & 0xff, ((0) >> 8) & 0xff, ((0) >> 16) & 0xff, ((0) >> 24) & 0xff);
 	    
+		if (image->comps[0].prec > 8) {
+			adjustR = image->comps[0].prec - 8;
+			printf("BMP CONVERSION: Truncating component 0 from %d bits to 8 bits\n", image->comps[0].prec);
+		}
+		else 
+			adjustR = 0;
+		if (image->comps[1].prec > 8) {
+			adjustG = image->comps[1].prec - 8;
+			printf("BMP CONVERSION: Truncating component 1 from %d bits to 8 bits\n", image->comps[1].prec);
+		}
+		else 
+			adjustG = 0;
+		if (image->comps[2].prec > 8) {
+			adjustB = image->comps[2].prec - 8;
+			printf("BMP CONVERSION: Truncating component 2 from %d bits to 8 bits\n", image->comps[2].prec);
+		}
+		else 
+			adjustB = 0;
+
 		for (i = 0; i < wr * hr; i++) {
-			unsigned char R, G, B;
-			/* a modifier */
-			/* R = image->comps[0].data[w * h - ((i) / (w) + 1) * w + (i) % (w)]; */
-			R = image->comps[0].data[w * hr - ((i) / (wr) + 1) * w + (i) % (wr)];
-			/* G = image->comps[1].data[w * h - ((i) / (w) + 1) * w + (i) % (w)]; */
-			G = image->comps[1].data[w * hr - ((i) / (wr) + 1) * w + (i) % (wr)];
-			/* B = image->comps[2].data[w * h - ((i) / (w) + 1) * w + (i) % (w)]; */
-			B = image->comps[2].data[w * hr - ((i) / (wr) + 1) * w + (i) % (wr)];
-			fprintf(fdest, "%c%c%c", B, G, R);
+			unsigned char rc, gc, bc;
+			int r, g, b;
+							
+			r = image->comps[0].data[w * hr - ((i) / (wr) + 1) * w + (i) % (wr)];
+			r += (image->comps[0].sgnd ? 1 << (image->comps[0].prec - 1) : 0);
+			rc = (unsigned char) ((r >> adjustR)+((r >> (adjustR-1))%2));
+			g = image->comps[1].data[w * hr - ((i) / (wr) + 1) * w + (i) % (wr)];
+			g += (image->comps[1].sgnd ? 1 << (image->comps[1].prec - 1) : 0);
+			gc = (unsigned char) ((g >> adjustG)+((g >> (adjustG-1))%2));
+			b = image->comps[2].data[w * hr - ((i) / (wr) + 1) * w + (i) % (wr)];
+			b += (image->comps[2].sgnd ? 1 << (image->comps[2].prec - 1) : 0);
+			bc = (unsigned char) ((b >> adjustB)+((b >> (adjustB-1))%2));
+
+			fprintf(fdest, "%c%c%c", bc, gc, rc);
 			
 			if ((i + 1) % wr == 0) {
 				for (pad = (3 * wr) % 4 ? 4 - (3 * wr) % 4 : 0; pad > 0; pad--)	/* ADD */
@@ -551,13 +875,9 @@ int imagetobmp(opj_image_t * image, const char *outfile) {
 		<<-- <<-- <<-- <<-- */
 
 		fdest = fopen(outfile, "wb");
-		/* w = int_ceildiv(image->x1 - image->x0, image->comps[0].dx); */
-		/* wr = int_ceildiv(int_ceildivpow2(image->x1 - image->x0,image->factor), image->comps[0].dx); */
 		w = image->comps[0].w;
 		wr = int_ceildivpow2(image->comps[0].w, image->comps[0].factor);
 	    
-		/* h = int_ceildiv(image->y1 - image->y0, image->comps[0].dy); */
-		/* hr = int_ceildiv(int_ceildivpow2(image->y1 - image->y0,image->factor), image->comps[0].dy); */
 		h = image->comps[0].h;
 		hr = int_ceildivpow2(image->comps[0].h, image->comps[0].factor);
 	    
@@ -597,16 +917,25 @@ int imagetobmp(opj_image_t * image, const char *outfile) {
 		fprintf(fdest, "%c%c%c%c", (256) & 0xff, ((256) >> 8) & 0xff, ((256) >> 16) & 0xff, ((256) >> 24) & 0xff);
 		fprintf(fdest, "%c%c%c%c", (256) & 0xff, ((256) >> 8) & 0xff, ((256) >> 16) & 0xff, ((256) >> 24) & 0xff);
 
+		if (image->comps[0].prec > 8) {
+			adjustR = image->comps[0].prec - 8;
+			printf("BMP CONVERSION: Truncating component 0 from %d bits to 8 bits\n", image->comps[0].prec);
+		}
+
 		for (i = 0; i < 256; i++) {
 			fprintf(fdest, "%c%c%c%c", i, i, i, 0);
 		}
 
 		for (i = 0; i < wr * hr; i++) {
-			/* a modifier !! */
-			/* fprintf(fdest, "%c", image->comps[0].data[w * h - ((i) / (w) + 1) * w + (i) % (w)]); */
-			fprintf(fdest, "%c", image->comps[0].data[w * hr - ((i) / (wr) + 1) * w + (i) % (wr)]);
-			/*if (((i + 1) % w == 0 && w % 2))
-			fprintf(fdest, "%c", 0); */
+			unsigned char rc;
+			int r;
+			
+			r = image->comps[0].data[w * hr - ((i) / (wr) + 1) * w + (i) % (wr)];
+			r += (image->comps[0].sgnd ? 1 << (image->comps[0].prec - 1) : 0);
+			rc = (unsigned char) ((r >> adjustR)+((r >> (adjustR-1))%2));
+			
+			fprintf(fdest, "%c", rc);
+
 			if ((i + 1) % wr == 0) {
 				for (pad = wr % 4 ? 4 - wr % 4 : 0; pad > 0; pad--)	/* ADD */
 					fprintf(fdest, "%c", 0);
@@ -768,41 +1097,46 @@ opj_image_t* pgxtoimage(const char *filename, opj_cparameters_t *parameters) {
 	return image;
 }
 
-int imagetopgx(opj_image_t * image, char *outfile) {
+int imagetopgx(opj_image_t * image, const char *outfile) {
 	int w, wr, h, hr;
 	int i, j, compno;
 	FILE *fdest = NULL;
 
 	for (compno = 0; compno < image->numcomps; compno++) {
 		opj_image_comp_t *comp = &image->comps[compno];
-		char name[256];
-		int nbytes = 0;
-		char *tmp = outfile;
-		while (*tmp) {
-			tmp++;
-		}
-		while (*tmp!='.') {
-			tmp--;
-		}
-		*tmp='\0';
-
+		char bname[256]; /* buffer for name */
+    char *name = bname; /* pointer */
+    int nbytes = 0;
+    const size_t olen = strlen(outfile);
+    const size_t dotpos = olen - 4;
+    const size_t total = dotpos + 1 + 1 + 4; /* '-' + '[1-3]' + '.pgx' */
+    if( outfile[dotpos] != '.' ) {
+      /* `pgx` was recognized but there is no dot at expected position */
+      fprintf(stderr, "ERROR -> Impossible happen." );
+      return 1;
+      }
+    if( total > 256 ) {
+      name = (char*)malloc(total+1);
+      }
+    strncpy(name, outfile, dotpos);
 		if (image->numcomps > 1) {
-			sprintf(name, "%s-%d.pgx", outfile, compno);
+			sprintf(name+dotpos, "-%d.pgx", compno);
 		} else {
-			sprintf(name, "%s.pgx", outfile);
+			strcpy(name+dotpos, ".pgx");
 		}
 		fdest = fopen(name, "wb");
 		if (!fdest) {
 			fprintf(stderr, "ERROR -> failed to open %s for writing\n", name);
 			return 1;
 		}
-		/* w = int_ceildiv(image->x1 - image->x0, comp->dx); */
-		/* wr = int_ceildiv(int_ceildivpow2(image->x1 - image->x0,image->factor), comp->dx); */
+    /* dont need name anymore */
+    if( total > 256 ) {
+      free(name);
+      }
+
 		w = image->comps[compno].w;
 		wr = int_ceildivpow2(image->comps[compno].w, image->comps[compno].factor);
 	    
-		/* h = int_ceildiv(image->y1 - image->y0, comp->dy); */
-		/* hr = int_ceildiv(int_ceildivpow2(image->y1 - image->y0,image->factor), comp->dy); */
 		h = image->comps[compno].h;
 		hr = int_ceildivpow2(image->comps[compno].h, image->comps[compno].factor);
 	    
@@ -846,7 +1180,7 @@ opj_image_t* pnmtoimage(const char *filename, opj_cparameters_t *parameters) {
 	
 	f = fopen(filename, "rb");
 	if (!f) {
-		fprintf(stderr, "\033[0;33mFailed to open %s for reading !!\033[0;39m\n", filename);
+		fprintf(stderr, "Failed to open %s for reading !!\n", filename);
 		return 0;
 	}
 
@@ -935,7 +1269,7 @@ opj_image_t* pnmtoimage(const char *filename, opj_cparameters_t *parameters) {
 int imagetopnm(opj_image_t * image, const char *outfile) {
 	int w, wr, wrr, h, hr, hrr, max;
 	int i, compno;
-	int adjust;
+	int adjustR, adjustG, adjustB, adjustX;
 	FILE *fdest = NULL;
 	char S2;
 	const char *tmp = outfile;
@@ -962,12 +1296,10 @@ int imagetopnm(opj_image_t * image, const char *outfile) {
 		}
 
 		w = int_ceildiv(image->x1 - image->x0, image->comps[0].dx);
-		/* wr = int_ceildiv(int_ceildivpow2(image->x1 - image->x0,image->factor),image->comps[0].dx); */
 		wr = image->comps[0].w;
 		wrr = int_ceildivpow2(image->comps[0].w, image->comps[0].factor);
         
 		h = int_ceildiv(image->y1 - image->y0, image->comps[0].dy);
-		/* hr = int_ceildiv(int_ceildivpow2(image->y1 - image->y0,image->factor), image->comps[0].dy); */
 		hr = image->comps[0].h;
 		hrr = int_ceildivpow2(image->comps[0].h, image->comps[0].factor);
 	    
@@ -977,28 +1309,49 @@ int imagetopnm(opj_image_t * image, const char *outfile) {
 		image->comps[0].y0 = int_ceildivpow2(image->comps[0].y0 -	int_ceildiv(image->y0, image->comps[0].dy), image->comps[0].factor);
 
 		fprintf(fdest, "P6\n%d %d\n%d\n", wrr, hrr, max);
-		adjust = image->comps[0].prec > 8 ? image->comps[0].prec - 8 : 0;
+
+		if (image->comps[0].prec > 8) {
+			adjustR = image->comps[0].prec - 8;
+			printf("PNM CONVERSION: Truncating component 0 from %d bits to 8 bits\n", image->comps[0].prec);
+		}
+		else 
+			adjustR = 0;
+		if (image->comps[1].prec > 8) {
+			adjustG = image->comps[1].prec - 8;
+			printf("PNM CONVERSION: Truncating component 1 from %d bits to 8 bits\n", image->comps[1].prec);
+		}
+		else 
+			adjustG = 0;
+		if (image->comps[2].prec > 8) {
+			adjustB = image->comps[2].prec - 8;
+			printf("PNM CONVERSION: Truncating component 2 from %d bits to 8 bits\n", image->comps[2].prec);
+		}
+		else 
+			adjustB = 0;
+
+
 		for (i = 0; i < wrr * hrr; i++) {
 			int r, g, b;
 			unsigned char rc,gc,bc;
 			r = image->comps[0].data[i / wrr * wr + i % wrr];
 			r += (image->comps[0].sgnd ? 1 << (image->comps[0].prec - 1) : 0);
-			rc = (unsigned char) ((r >> adjust)+((r >> (adjust-1))%2));
+			rc = (unsigned char) ((r >> adjustR)+((r >> (adjustR-1))%2));
 
 			g = image->comps[1].data[i / wrr * wr + i % wrr];
 			g += (image->comps[1].sgnd ? 1 << (image->comps[1].prec - 1) : 0);
-			gc = (unsigned char) ((g >> adjust)+((g >> (adjust-1))%2));
+			gc = (unsigned char) ((g >> adjustG)+((g >> (adjustG-1))%2));
 			
 			b = image->comps[2].data[i / wrr * wr + i % wrr];
 			b += (image->comps[2].sgnd ? 1 << (image->comps[2].prec - 1) : 0);
-			bc = (unsigned char) ((b >> adjust)+((b >> (adjust-1))%2));
+			bc = (unsigned char) ((b >> adjustB)+((b >> (adjustB-1))%2));
 			
 			fprintf(fdest, "%c%c%c", rc, gc, bc);
 		}
 		fclose(fdest);
+
 	} else {
 		int ncomp=(S2=='g' || S2=='G')?1:image->numcomps;
-		if (image->numcomps>ncomp) {
+		if (image->numcomps > ncomp) {
 			fprintf(stderr,"WARNING -> [PGM files] Only the first component\n");
 			fprintf(stderr,"           is written to the file\n");
 		}
@@ -1017,12 +1370,10 @@ int imagetopnm(opj_image_t * image, const char *outfile) {
 			}
             
 			w = int_ceildiv(image->x1 - image->x0, image->comps[compno].dx);
-			/* wr = int_ceildiv(int_ceildivpow2(image->x1 - image->x0,image->factor),image->comps[compno].dx); */
 			wr = image->comps[compno].w;
 			wrr = int_ceildivpow2(image->comps[compno].w, image->comps[compno].factor);
 			
 			h = int_ceildiv(image->y1 - image->y0, image->comps[compno].dy);
-			/* hr = int_ceildiv(int_ceildivpow2(image->y1 - image->y0,image->factor), image->comps[compno].dy); */
 			hr = image->comps[compno].h;
 			hrr = int_ceildivpow2(image->comps[compno].h, image->comps[compno].factor);
 			
@@ -1032,14 +1383,20 @@ int imagetopnm(opj_image_t * image, const char *outfile) {
 			image->comps[compno].y0 = int_ceildivpow2(image->comps[compno].y0 - int_ceildiv(image->y0, image->comps[compno].dy), image->comps[compno].factor);
 			
 			fprintf(fdest, "P5\n%d %d\n%d\n", wrr, hrr, max);
-			adjust = image->comps[compno].prec > 8 ? image->comps[compno].prec - 8 : 0;
-
+			
+			if (image->comps[compno].prec > 8) {
+				adjustX = image->comps[0].prec - 8;
+				printf("PNM CONVERSION: Truncating component %d from %d bits to 8 bits\n",compno, image->comps[compno].prec);
+			}
+			else 
+				adjustX = 0;
+			
 			for (i = 0; i < wrr * hrr; i++) {
 				int l;
 				unsigned char lc;
 				l = image->comps[compno].data[i / wrr * wr + i % wrr];
 				l += (image->comps[compno].sgnd ? 1 << (image->comps[compno].prec - 1) : 0);
-				lc = (unsigned char) ((l >> adjust)+((l >> (adjust-1))%2));
+				lc = (unsigned char) ((l >> adjustX)+((l >> (adjustX-1))%2));
 				fprintf(fdest, "%c", lc);
 			}
 			fclose(fdest);
@@ -1049,4 +1406,722 @@ int imagetopnm(opj_image_t * image, const char *outfile) {
 	return 0;
 }
 
+/* -->> -->> -->> -->>
+
+	TIFF IMAGE FORMAT
+
+ <<-- <<-- <<-- <<-- */
+
+typedef struct tiff_infoheader{
+	DWORD tiWidth;  // Width of Image in pixel
+	DWORD tiHeight; // Height of Image in pixel
+	DWORD tiPhoto;	// Photometric
+	WORD  tiBps;	// Bits per sample
+	WORD  tiSf;		// Sample Format
+	WORD  tiSpp;	// Sample per pixel 1-bilevel,gray scale , 2- RGB
+	WORD  tiPC;	// Planar config (1-Interleaved, 2-Planarcomp)
+}tiff_infoheader_t;
+
+int imagetotif(opj_image_t * image, const char *outfile) {
+	int width, height, imgsize;
+	int bps,index,adjust = 0;
+	int last_i=0;
+	TIFF *tif;
+	tdata_t buf;
+	tstrip_t strip;
+	tsize_t strip_size;
+
+	if (image->numcomps == 3 && image->comps[0].dx == image->comps[1].dx
+		&& image->comps[1].dx == image->comps[2].dx
+		&& image->comps[0].dy == image->comps[1].dy
+		&& image->comps[1].dy == image->comps[2].dy
+		&& image->comps[0].prec == image->comps[1].prec
+		&& image->comps[1].prec == image->comps[2].prec) {
+
+			/* -->> -->> -->>    
+			RGB color	    
+			<<-- <<-- <<-- */
+
+			tif = TIFFOpen(outfile, "wb"); 
+			if (!tif) {
+				fprintf(stderr, "ERROR -> failed to open %s for writing\n", outfile);
+				return 1;
+			}
+
+			width	= image->comps[0].w;
+			height	= image->comps[0].h;
+			imgsize = image->comps[0].w * image->comps[0].h ;
+			bps		= image->comps[0].prec;
+			/* Set tags */
+			TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width);
+			TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height);
+			TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 3);
+			TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bps);
+			TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
+			TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
+			TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
+			TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, 1);
+
+			/* Get a buffer for the data */
+			buf = _TIFFmalloc(TIFFStripSize(tif));
+			index=0;
+			strip_size=0;
+			strip_size=TIFFStripSize(tif);
+			adjust = image->comps[0].sgnd ? 1 << (image->comps[0].prec - 1) : 0;
+			for (strip = 0; strip < TIFFNumberOfStrips(tif); strip++) {
+				unsigned char *dat8;
+				int i, ssize;
+				ssize = TIFFStripSize(tif);
+				dat8 = buf;
+				if (image->comps[0].prec == 8){
+					for (i=0; i<ssize-2; i+=3) {	// 8 bits per pixel 
+						int r = 0,g = 0,b = 0;
+						if(index < imgsize){
+							r = image->comps[0].data[index];
+							g = image->comps[1].data[index];
+							b = image->comps[2].data[index];
+							if (image->comps[0].sgnd){			
+								r += adjust;
+								g += adjust;
+								b += adjust;
+							}
+							dat8[i+0] = r ;	// R 
+							dat8[i+1] = g ;	// G 
+							dat8[i+2] = b ;	// B 
+							index++;
+							last_i = i+3;
+						}else
+							break;
+					}
+					if(last_i < ssize){
+						for (i=last_i; i<ssize; i+=3) {	// 8 bits per pixel 
+							int r = 0,g = 0,b = 0;
+							if(index < imgsize){
+								r = image->comps[0].data[index];
+								g = image->comps[1].data[index];
+								b = image->comps[2].data[index];
+								if (image->comps[0].sgnd){			
+									r += adjust;
+									g += adjust;
+									b += adjust;
+								}
+								dat8[i+0] = r ;	// R 
+								if(i+1 <ssize) dat8[i+1] = g ;	else break;// G 
+								if(i+2 <ssize) dat8[i+2] = b ;	else break;// B 
+								index++;
+							}else
+								break;
+						}
+					}
+				}else if (image->comps[0].prec == 12){
+					for (i=0; i<ssize-8; i+=9) {	// 12 bits per pixel 
+						int r = 0,g = 0,b = 0;
+						int r1 = 0,g1 = 0,b1 = 0;
+						if((index < imgsize)&(index+1 < imgsize)){
+							r  = image->comps[0].data[index];
+							g  = image->comps[1].data[index];
+							b  = image->comps[2].data[index];
+							r1 = image->comps[0].data[index+1];
+							g1 = image->comps[1].data[index+1];
+							b1 = image->comps[2].data[index+1];
+							if (image->comps[0].sgnd){														
+								r  += adjust;
+								g  += adjust;
+								b  += adjust;
+								r1 += adjust;
+								g1 += adjust;
+								b1 += adjust;
+							}
+							dat8[i+0] = (r >> 4);
+							dat8[i+1] = ((r & 0x0f) << 4 )|((g >> 8)& 0x0f);
+							dat8[i+2] = g ;		
+							dat8[i+3] = (b >> 4);
+							dat8[i+4] = ((b & 0x0f) << 4 )|((r1 >> 8)& 0x0f);
+							dat8[i+5] = r1;		
+							dat8[i+6] = (g1 >> 4);
+							dat8[i+7] = ((g1 & 0x0f)<< 4 )|((b1 >> 8)& 0x0f);
+							dat8[i+8] = b1;
+							index+=2;
+							last_i = i+9;
+						}else
+							break;
+					}
+					if(last_i < ssize){
+						for (i= last_i; i<ssize; i+=9) {	// 12 bits per pixel 
+							int r = 0,g = 0,b = 0;
+							int r1 = 0,g1 = 0,b1 = 0;
+							if((index < imgsize)&(index+1 < imgsize)){
+								r  = image->comps[0].data[index];
+								g  = image->comps[1].data[index];
+								b  = image->comps[2].data[index];
+								r1 = image->comps[0].data[index+1];
+								g1 = image->comps[1].data[index+1];
+								b1 = image->comps[2].data[index+1];
+								if (image->comps[0].sgnd){														
+									r  += adjust;
+									g  += adjust;
+									b  += adjust;
+									r1 += adjust;
+									g1 += adjust;
+									b1 += adjust;
+								}
+								dat8[i+0] = (r >> 4);
+								if(i+1 <ssize) dat8[i+1] = ((r & 0x0f) << 4 )|((g >> 8)& 0x0f); else break;
+								if(i+2 <ssize) dat8[i+2] = g ;			else break;
+								if(i+3 <ssize) dat8[i+3] = (b >> 4);	else break;
+								if(i+4 <ssize) dat8[i+4] = ((b & 0x0f) << 4 )|((r1 >> 8)& 0x0f);else break;
+								if(i+5 <ssize) dat8[i+5] = r1;			else break;
+								if(i+6 <ssize) dat8[i+6] = (g1 >> 4);	else break;
+								if(i+7 <ssize) dat8[i+7] = ((g1 & 0x0f)<< 4 )|((b1 >> 8)& 0x0f);else break;
+								if(i+8 <ssize) dat8[i+8] = b1;			else break;
+								index+=2;
+							}else
+								break;
+						}
+					}
+				}else if (image->comps[0].prec == 16){
+					for (i=0 ; i<ssize-5 ; i+=6) {	// 16 bits per pixel 
+						int r = 0,g = 0,b = 0;
+						if(index < imgsize){
+							r = image->comps[0].data[index];
+							g = image->comps[1].data[index];
+							b = image->comps[2].data[index];
+							if (image->comps[0].sgnd){
+							r += adjust;
+							g += adjust;
+							b += adjust;
+							}
+							dat8[i+0] =  r;//LSB
+							dat8[i+1] = (r >> 8);//MSB	 
+							dat8[i+2] =  g;		
+							dat8[i+3] = (g >> 8);
+							dat8[i+4] =  b;	
+							dat8[i+5] = (b >> 8);
+							index++;
+							last_i = i+6;
+						}else
+							break; 
+					}
+					if(last_i < ssize){
+						for (i=0 ; i<ssize ; i+=6) {	// 16 bits per pixel 
+							int r = 0,g = 0,b = 0;
+							if(index < imgsize){
+								r = image->comps[0].data[index];
+								g = image->comps[1].data[index];
+								b = image->comps[2].data[index];
+								if (image->comps[0].sgnd){
+									r += adjust;
+									g += adjust;
+									b += adjust;
+								}
+								dat8[i+0] =  r;//LSB
+								if(i+1 <ssize) dat8[i+1] = (r >> 8);else break;//MSB	 
+								if(i+2 <ssize) dat8[i+2] =  g;		else break;
+								if(i+3 <ssize) dat8[i+3] = (g >> 8);else break;
+								if(i+4 <ssize) dat8[i+4] =  b;		else break;
+								if(i+5 <ssize) dat8[i+5] = (b >> 8);else break;
+								index++;
+							}else
+								break; 
+						}						
+					}
+				}else{
+					fprintf(stderr,"Bits=%d, Only 8,12,16 bits implemented\n",image->comps[0].prec);
+					fprintf(stderr,"Aborting\n");
+					return 1;
+				}
+				TIFFWriteEncodedStrip(tif, strip, buf, strip_size);
+			}
+			_TIFFfree(buf);
+			TIFFClose(tif);
+		}else if (image->numcomps == 1){
+			/* -->> -->> -->>    
+			Black and White	    
+			<<-- <<-- <<-- */
+
+			tif = TIFFOpen(outfile, "wb"); 
+			if (!tif) {
+				fprintf(stderr, "ERROR -> failed to open %s for writing\n", outfile);
+				return 1;
+			}
+
+			width	= image->comps[0].w;
+			height= image->comps[0].h;
+			bps		= image->comps[0].prec;
+
+			/* Set tags */
+			TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width);
+			TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height);
+			TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 1);
+			TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bps);
+			TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
+			TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
+			TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
+			TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, 1);
+
+			/* Get a buffer for the data */
+			buf = _TIFFmalloc(TIFFStripSize(tif));
+			index = 0;
+			strip_size = 0;
+			strip_size = TIFFStripSize(tif);
+			for (strip = 0; strip < TIFFNumberOfStrips(tif); strip++) {
+				unsigned char *dat8;
+				int i;
+				dat8 = buf;
+				if (image->comps[0].prec == 8){
+					for (i=0; i<TIFFStripSize(tif); i+=1) {	// 8 bits per pixel 
+						int r = 0;
+						r = image->comps[0].data[index];
+						if (image->comps[0].sgnd){
+							r  += adjust;
+						}
+						dat8[i+0] = r;
+						index++;
+					}
+				}else if (image->comps[0].prec == 12){
+					for (i = 0; i<TIFFStripSize(tif); i+=3) {	// 12 bits per pixel 
+						int r = 0, r1 = 0;
+						r  = image->comps[0].data[index];
+						r1 = image->comps[0].data[index+1];
+						if (image->comps[0].sgnd){
+							r  += adjust;
+							r1 += adjust;
+						}
+						dat8[i+0] = (r >> 4);
+						dat8[i+1] = ((r & 0x0f) << 4 )|((r1 >> 8)& 0x0f);
+						dat8[i+2] = r1 ;
+						index+=2;
+					}
+				}else if (image->comps[0].prec == 16){
+					for (i=0; i<TIFFStripSize(tif); i+=2) {	// 16 bits per pixel 
+						int r = 0;
+						r = image->comps[0].data[index];
+						if (image->comps[0].sgnd){
+							r  += adjust;
+						}
+						dat8[i+0] = r;
+						dat8[i+1] = r >> 8;
+						index++;
+					}
+				}else{
+					fprintf(stderr,"Bits=%d, Only 8,12,16 bits implemented\n",image->comps[0].prec);
+					fprintf(stderr,"Aborting\n");
+					return 1;
+				}
+				TIFFWriteEncodedStrip(tif, strip, buf, strip_size);
+			}
+			_TIFFfree(buf);
+			TIFFClose(tif);
+		}else{
+			fprintf(stderr,"False color format. Only RGB & Grayscale has been implemented\n");
+			fprintf(stderr,"Aborting\n");
+			return 1;
+		}
+		return 0;
+}
+
+opj_image_t* tiftoimage(const char *filename, opj_cparameters_t *parameters)
+{
+	int subsampling_dx = parameters->subsampling_dx;
+	int subsampling_dy = parameters->subsampling_dy;
+	TIFF *tif;
+	tiff_infoheader_t Info;
+	tdata_t buf;
+	tstrip_t strip;
+	tsize_t strip_size;
+	int j, numcomps, w, h,index;
+	OPJ_COLOR_SPACE color_space;
+	opj_image_cmptparm_t cmptparm[3];
+	opj_image_t * image = NULL;
+	int imgsize;
+
+	tif = TIFFOpen(filename, "r");
+
+	if (!tif) {
+		fprintf(stderr, "Failed to open %s for reading\n", filename);
+		return 0;
+	}
+
+	TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &Info.tiWidth);
+	TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &Info.tiHeight);
+	TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, &Info.tiBps);
+	TIFFGetField(tif, TIFFTAG_SAMPLEFORMAT, &Info.tiSf);
+	TIFFGetField(tif, TIFFTAG_SAMPLESPERPIXEL, &Info.tiSpp);
+	Info.tiPhoto = 0;
+	TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &Info.tiPhoto);
+	TIFFGetField(tif, TIFFTAG_PLANARCONFIG, &Info.tiPC);
+	w= Info.tiWidth;
+	h= Info.tiHeight;
+	
+	if (Info.tiPhoto == 2) { 
+		/* -->> -->> -->>    
+		RGB color	    
+		<<-- <<-- <<-- */
+
+		numcomps = 3;
+		color_space = CLRSPC_SRGB;
+		/* initialize image components*/ 
+		memset(&cmptparm[0], 0, 3 * sizeof(opj_image_cmptparm_t));
+		for(j = 0; j < numcomps; j++) {
+			if (parameters->cp_cinema) {
+				cmptparm[j].prec = 12;
+				cmptparm[j].bpp = 12;
+			}else{
+				cmptparm[j].prec = Info.tiBps;
+				cmptparm[j].bpp = Info.tiBps;
+			}
+			cmptparm[j].sgnd = 0;
+			cmptparm[j].dx = subsampling_dx;
+			cmptparm[j].dy = subsampling_dy;
+			cmptparm[j].w = w;
+			cmptparm[j].h = h;
+		}
+		/* create the image*/ 
+		image = opj_image_create(numcomps, &cmptparm[0], color_space);
+		if(!image) {
+			TIFFClose(tif);
+			return NULL;
+		}
+
+		/* set image offset and reference grid */
+		image->x0 = parameters->image_offset_x0;
+		image->y0 = parameters->image_offset_y0;
+		image->x1 =	!image->x0 ? (w - 1) * subsampling_dx + 1 : image->x0 + (w - 1) * subsampling_dx + 1;
+		image->y1 =	!image->y0 ? (h - 1) * subsampling_dy + 1 : image->y0 + (h - 1) * subsampling_dy + 1;
+
+		buf = _TIFFmalloc(TIFFStripSize(tif));
+		strip_size=0;
+		strip_size=TIFFStripSize(tif);
+		index = 0;
+		imgsize = image->comps[0].w * image->comps[0].h ;
+		/* Read the Image components*/
+		for (strip = 0; strip < TIFFNumberOfStrips(tif); strip++) {
+			unsigned char *dat8;
+			int i, ssize;
+			ssize = TIFFReadEncodedStrip(tif, strip, buf, strip_size);
+			dat8 = buf;
+
+			if (Info.tiBps==12){
+				for (i=0; i<ssize; i+=9) {	/*12 bits per pixel*/
+					if((index < imgsize)&(index+1 < imgsize)){
+						image->comps[0].data[index]   = ( dat8[i+0]<<4 )		|(dat8[i+1]>>4);
+						image->comps[1].data[index]   = ((dat8[i+1]& 0x0f)<< 8)	| dat8[i+2];
+						image->comps[2].data[index]   = ( dat8[i+3]<<4)			|(dat8[i+4]>>4);
+						image->comps[0].data[index+1] = ((dat8[i+4]& 0x0f)<< 8)	| dat8[i+5];
+						image->comps[1].data[index+1] = ( dat8[i+6] <<4)		|(dat8[i+7]>>4);
+						image->comps[2].data[index+1] = ((dat8[i+7]& 0x0f)<< 8)	| dat8[i+8];
+						index+=2;
+					}else
+						break;
+				}
+			}
+			else if( Info.tiBps==16){
+				for (i=0; i<ssize; i+=6) {	/* 16 bits per pixel */
+					if(index < imgsize){
+						image->comps[0].data[index] = ( dat8[i+1] << 8 ) | dat8[i+0]; // R 
+						image->comps[1].data[index] = ( dat8[i+3] << 8 ) | dat8[i+2]; // G 
+						image->comps[2].data[index] = ( dat8[i+5] << 8 ) | dat8[i+4]; // B 
+						if(parameters->cp_cinema){/* Rounding to 12 bits*/
+							image->comps[0].data[index] = (image->comps[0].data[index] + 0x08) >> 4 ;
+							image->comps[1].data[index] = (image->comps[1].data[index] + 0x08) >> 4 ;
+							image->comps[2].data[index] = (image->comps[2].data[index] + 0x08) >> 4 ;
+						}
+						index++;
+					}else
+						break;
+				}
+			}
+			else if ( Info.tiBps==8){
+				for (i=0; i<ssize; i+=3) {	/* 8 bits per pixel */
+					if(index < imgsize){
+						image->comps[0].data[index] = dat8[i+0];// R 
+						image->comps[1].data[index] = dat8[i+1];// G 
+						image->comps[2].data[index] = dat8[i+2];// B 
+						if(parameters->cp_cinema){/* Rounding to 12 bits*/
+							image->comps[0].data[index] = image->comps[0].data[index] << 4 ;
+							image->comps[1].data[index] = image->comps[1].data[index] << 4 ;
+							image->comps[2].data[index] = image->comps[2].data[index] << 4 ;
+						}
+						index++;
+					}else
+						break;
+				}
+			}
+			else{
+				fprintf(stderr,"Bits=%d, Only 8,12,16 bits implemented\n",Info.tiBps);
+				fprintf(stderr,"Aborting\n");
+				return NULL;
+			}
+		}
+
+		_TIFFfree(buf);
+		TIFFClose(tif);
+	}else if(Info.tiPhoto == 1) { 
+		/* -->> -->> -->>    
+		Black and White
+		<<-- <<-- <<-- */
+
+		numcomps = 1;
+		color_space = CLRSPC_GRAY;
+		/* initialize image components*/ 
+		memset(&cmptparm[0], 0, sizeof(opj_image_cmptparm_t));
+		cmptparm[0].prec = Info.tiBps;
+		cmptparm[0].bpp = Info.tiBps;
+		cmptparm[0].sgnd = 0;
+		cmptparm[0].dx = subsampling_dx;
+		cmptparm[0].dy = subsampling_dy;
+		cmptparm[0].w = w;
+		cmptparm[0].h = h;
+
+		/* create the image*/ 
+		image = opj_image_create(numcomps, &cmptparm[0], color_space);
+		if(!image) {
+			TIFFClose(tif);
+			return NULL;
+		}
+		/* set image offset and reference grid */
+		image->x0 = parameters->image_offset_x0;
+		image->y0 = parameters->image_offset_y0;
+		image->x1 =	!image->x0 ? (w - 1) * subsampling_dx + 1 : image->x0 + (w - 1) * subsampling_dx + 1;
+		image->y1 =	!image->y0 ? (h - 1) * subsampling_dy + 1 : image->y0 + (h - 1) * subsampling_dy + 1;
+
+		buf = _TIFFmalloc(TIFFStripSize(tif));
+		strip_size = 0;
+		strip_size = TIFFStripSize(tif);
+		index = 0;
+		/* Read the Image components*/
+		for (strip = 0; strip < TIFFNumberOfStrips(tif); strip++) {
+			unsigned char *dat8;
+			int i, ssize;
+			ssize = TIFFReadEncodedStrip(tif, strip, buf, strip_size);
+			dat8 = buf;
+
+			if (Info.tiBps==12){
+				for (i=0; i<ssize; i+=3) {	/* 12 bits per pixel*/
+					if(index < imgsize){
+						image->comps[0].data[index]   = ( dat8[i+0]<<4 )		|(dat8[i+1]>>4) ;
+						image->comps[0].data[index+1] = ((dat8[i+1]& 0x0f)<< 8)	| dat8[i+2];
+						index+=2;
+					}else
+						break;
+				}
+			}
+			else if( Info.tiBps==16){
+				for (i=0; i<ssize; i+=2) {	/* 16 bits per pixel */
+					if(index < imgsize){
+						image->comps[0].data[index] = ( dat8[i+1] << 8 ) | dat8[i+0];
+						index++;
+					}else
+						break;
+				}
+			}
+			else if ( Info.tiBps==8){
+				for (i=0; i<ssize; i+=1) {	/* 8 bits per pixel */
+					if(index < imgsize){
+						image->comps[0].data[index] = dat8[i+0];
+						index++;
+					}else
+						break;
+				}
+			}
+			else{
+				fprintf(stderr,"Bits=%d, Only 8,12,16 bits implemented\n",Info.tiBps);
+				fprintf(stderr,"Aborting\n");
+				return NULL;
+			}
+		}
+
+		_TIFFfree(buf);
+		TIFFClose(tif);
+	}else{
+		fprintf(stderr,"False color format. Only RGB & Grayscale has been implemented\n");
+		fprintf(stderr,"Aborting\n");
+		return NULL;
+	}
+	return image;
+}
+
+/* -->> -->> -->> -->>
+
+	RAW IMAGE FORMAT
 
+ <<-- <<-- <<-- <<-- */
+
+opj_image_t* rawtoimage(const char *filename, opj_cparameters_t *parameters, raw_cparameters_t *raw_cp) {
+	int subsampling_dx = parameters->subsampling_dx;
+	int subsampling_dy = parameters->subsampling_dy;
+
+	FILE *f = NULL;
+	int i, compno, numcomps, w, h;
+	OPJ_COLOR_SPACE color_space;
+	opj_image_cmptparm_t *cmptparm;	
+	opj_image_t * image = NULL;
+	unsigned short ch;
+	
+	if((! (raw_cp->rawWidth & raw_cp->rawHeight & raw_cp->rawComp & raw_cp->rawBitDepth)) == 0)
+	{
+		fprintf(stderr,"\nError: invalid raw image parameters\n");
+		fprintf(stderr,"Please use the Format option -F:\n");
+		fprintf(stderr,"-F rawWidth,rawHeight,rawComp,rawBitDepth,s/u (Signed/Unsigned)\n");
+		fprintf(stderr,"Example: -i lena.raw -o lena.j2k -F 512,512,3,8,u\n");
+		fprintf(stderr,"Aborting\n");
+		return NULL;
+	}
+
+	f = fopen(filename, "rb");
+	if (!f) {
+		fprintf(stderr, "Failed to open %s for reading !!\n", filename);
+		fprintf(stderr,"Aborting\n");
+		return NULL;
+	}
+	numcomps = raw_cp->rawComp;
+	color_space = CLRSPC_SRGB;
+	w = raw_cp->rawWidth;
+	h = raw_cp->rawHeight;
+	cmptparm = (opj_image_cmptparm_t*) malloc(numcomps * sizeof(opj_image_cmptparm_t));
+	
+	/* initialize image components */	
+	memset(&cmptparm[0], 0, numcomps * sizeof(opj_image_cmptparm_t));
+	for(i = 0; i < numcomps; i++) {		
+		cmptparm[i].prec = raw_cp->rawBitDepth;
+		cmptparm[i].bpp = raw_cp->rawBitDepth;
+		cmptparm[i].sgnd = raw_cp->rawSigned;
+		cmptparm[i].dx = subsampling_dx;
+		cmptparm[i].dy = subsampling_dy;
+		cmptparm[i].w = w;
+		cmptparm[i].h = h;
+	}
+	/* create the image */
+	image = opj_image_create(numcomps, &cmptparm[0], color_space);
+	if(!image) {
+		fclose(f);
+		return NULL;
+	}
+	/* set image offset and reference grid */
+	image->x0 = parameters->image_offset_x0;
+	image->y0 = parameters->image_offset_y0;
+	image->x1 = parameters->image_offset_x0 + (w - 1) *	subsampling_dx + 1;
+	image->y1 = parameters->image_offset_y0 + (h - 1) *	subsampling_dy + 1;
+
+	if(raw_cp->rawBitDepth <= 8)
+	{
+		unsigned char value = 0;
+		for(compno = 0; compno < numcomps; compno++) {
+			for (i = 0; i < w * h; i++) {
+				if (!fread(&value, 1, 1, f)) {
+					fprintf(stderr,"Error reading raw file. End of file probably reached.\n");
+					return NULL;
+				}
+				image->comps[compno].data[i] = raw_cp->rawSigned?(char)value:value;
+			}
+		}
+	}
+	else
+	{
+		unsigned short value = 0;
+		for(compno = 0; compno < numcomps; compno++) {
+			for (i = 0; i < w * h; i++) {
+				if (!fread(&value, 2, 1, f)) {
+					fprintf(stderr,"Error reading raw file. End of file probably reached.\n");
+					return NULL;
+				}
+				image->comps[compno].data[i] = raw_cp->rawSigned?(short)value:value;
+			}
+		}
+	}
+
+	if (fread(&ch, 1, 1, f)) {
+		fprintf(stderr,"Warning. End of raw file not reached... processing anyway\n");
+	}
+	fclose(f);
+
+	return image;
+}
+
+int imagetoraw(opj_image_t * image, const char *outfile)
+{
+	FILE *rawFile = NULL;
+	int compno, pixelsToWrite, offset, cont;
+
+	if((image->numcomps * image->x1 * image->y1) == 0)
+	{
+		fprintf(stderr,"\nError: invalid raw image parameters\n");
+		return 1;
+	}
+
+	rawFile = fopen(outfile, "wb");
+	if (!rawFile) {
+		fprintf(stderr, "Failed to open %s for writing !!\n", outfile);
+		return 1;
+	}
+
+	fprintf(stdout,"Raw image characteristics: %d components\n", image->numcomps);
+
+	for(compno = 0; compno < image->numcomps; compno++)
+	{
+		fprintf(stdout,"Component %d characteristics: %dx%dx%d %s\n", compno, image->comps[compno].w,
+			image->comps[compno].h, image->comps[compno].prec, image->comps[compno].sgnd==1 ? "signed": "unsigned");
+
+		pixelsToWrite = image->comps[compno].w * image->comps[compno].h;
+		offset = 0;
+
+		if(image->comps[compno].prec <= 8)
+		{
+			if(image->comps[compno].sgnd == 1)
+			{
+				signed char curr;
+				int mask = (1 << image->comps[compno].prec) - 1;
+				for(cont = 0; cont < pixelsToWrite; cont++)
+				{				
+					curr = (signed char) (image->comps[compno].data[cont] & mask);
+					fwrite(&curr, sizeof(signed char), 1, rawFile);
+				}
+			}
+			else if(image->comps[compno].sgnd == 0)
+			{
+				unsigned char curr;
+				int mask = (1 << image->comps[compno].prec) - 1;
+				for(cont = 0; cont < pixelsToWrite; cont++)
+				{				
+					curr = (unsigned char) (image->comps[compno].data[cont] & mask);
+					fwrite(&curr, sizeof(unsigned char), 1, rawFile);
+				}
+			}
+		}
+		else if(image->comps[compno].prec <= 16)
+		{
+			if(image->comps[compno].sgnd == 1)
+			{
+				signed short int curr;
+				int mask = (1 << image->comps[compno].prec) - 1;
+				for(cont = 0; cont < pixelsToWrite; cont++)
+				{				
+					curr = (signed short int) (image->comps[compno].data[cont] & mask);
+					fwrite(&curr, sizeof(signed short int), 1, rawFile);
+				}
+			}
+			else if(image->comps[compno].sgnd == 0)
+			{
+				unsigned short int curr;
+				int mask = (1 << image->comps[compno].prec) - 1;
+				for(cont = 0; cont < pixelsToWrite; cont++)
+				{				
+					curr = (unsigned short int) (image->comps[compno].data[cont] & mask);
+					fwrite(&curr, sizeof(unsigned short int), 1, rawFile);
+				}
+			}
+		}
+		else if (image->comps[compno].prec <= 32)
+		{
+
+
+		}
+		else
+		{
+			fprintf(stderr,"\nError: invalid precision\n");
+			return 1;
+		}
+	}
+	fclose(rawFile);
+	return 0;
+}