WebSVN – Kolibri OS – Blame – /contrib/menuetlibc/openjpeg/codec/convert.c

Rev	Author	Line No.	Line
4758	right-hear	1	/*
		2	* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
		3	* Copyright (c) 2002-2007, Professor Benoit Macq
		4	* Copyright (c) 2001-2003, David Janssens
		5	* Copyright (c) 2002-2003, Yannick Verschueren
		6	* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
		7	* Copyright (c) 2005, Herve Drolon, FreeImage Team
		8	* Copyright (c) 2006-2007, Parvatha Elangovan
		9	* All rights reserved.
		10	*
		11	* Redistribution and use in source and binary forms, with or without
		12	* modification, are permitted provided that the following conditions
		13	* are met:
		14	* 1. Redistributions of source code must retain the above copyright
		15	* notice, this list of conditions and the following disclaimer.
		16	* 2. Redistributions in binary form must reproduce the above copyright
		17	* notice, this list of conditions and the following disclaimer in the
		18	* documentation and/or other materials provided with the distribution.
		19	*
		20	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
		21	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		22	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
		23	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
		24	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
		25	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
		26	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
		27	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
		28	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
		29	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
		30	* POSSIBILITY OF SUCH DAMAGE.
		31	*/
		32	#include "opj_config.h"
		33
		34	#include
		35	#include
		36	#include
		37
		38	#ifdef HAVE_LIBTIFF
		39	#ifdef _WIN32
		40	#include "../libs/libtiff/tiffio.h"
		41	#else
		42	#include
		43	#endif /* _WIN32 */
		44	#endif /* HAVE_LIBTIFF */
		45
		46	#ifdef HAVE_LIBPNG
		47	#ifdef _WIN32
		48	#include "../libs/png/png.h"
		49	#else
		50	#include
		51	#endif /* _WIN32 */
		52	#endif /* HAVE_LIBPNG */
		53
		54	#include "../libopenjpeg/openjpeg.h"
		55	#include "convert.h"
		56
		57	/*
		58	* Get logarithm of an integer and round downwards.
		59	*
		60	* log2(a)
		61	*/
		62	static int int_floorlog2(int a) {
		63	int l;
		64	for (l = 0; a > 1; l++) {
		65	a >>= 1;
		66	}
		67	return l;
		68	}
		69
		70	/*
		71	* Divide an integer by a power of 2 and round upwards.
		72	*
		73	* a divided by 2^b
		74	*/
		75	static int int_ceildivpow2(int a, int b) {
		76	return (a + (1 << b) - 1) >> b;
		77	}
		78
		79	/*
		80	* Divide an integer and round upwards.
		81	*
		82	* a divided by b
		83	*/
		84	static int int_ceildiv(int a, int b) {
		85	return (a + b - 1) / b;
		86	}
		87
		88
		89	/* -->> -->> -->> -->>
		90
		91	TGA IMAGE FORMAT
		92
		93	<<-- <<-- <<-- <<-- */
		94
		95	// TGA header definition.
		96	#pragma pack(push,1) // Pack structure byte aligned
		97	typedef struct tga_header
		98	{
		99	unsigned char id_length; /* Image id field length */
		100	unsigned char colour_map_type; /* Colour map type */
		101	unsigned char image_type; /* Image type */
		102	/*
		103	** Colour map specification
		104	*/
		105	unsigned short colour_map_index; /* First entry index */
		106	unsigned short colour_map_length; /* Colour map length */
		107	unsigned char colour_map_entry_size; /* Colour map entry size */
		108	/*
		109	** Image specification
		110	*/
		111	unsigned short x_origin; /* x origin of image */
		112	unsigned short y_origin; /* u origin of image */
		113	unsigned short image_width; /* Image width */
		114	unsigned short image_height; /* Image height */
		115	unsigned char pixel_depth; /* Pixel depth */
		116	unsigned char image_desc; /* Image descriptor */
		117	} tga_header;
		118	#pragma pack(pop) // Return to normal structure packing alignment.
		119
		120	int tga_readheader(FILE fp, unsigned int bits_per_pixel,
		121	unsigned int width, unsigned int height, int *flip_image)
		122	{
		123	int palette_size;
		124	tga_header tga ;
		125
		126	if (!bits_per_pixel \|\| !width \|\| !height \|\| !flip_image)
		127	return 0;
		128
		129	// Read TGA header
		130	fread((unsigned char*)&tga, sizeof(tga_header), 1, fp);
		131
		132	*bits_per_pixel = tga.pixel_depth;
		133
		134	*width = tga.image_width;
		135	*height = tga.image_height ;
		136
		137	// Ignore tga identifier, if present ...
		138	if (tga.id_length)
		139	{
		140	unsigned char id = (unsigned char ) malloc(tga.id_length);
		141	fread(id, tga.id_length, 1, fp);
		142	free(id);
		143	}
		144
		145	// Test for compressed formats ... not yet supported ...
		146	// Note :- 9 - RLE encoded palettized.
		147	// 10 - RLE encoded RGB.
		148	if (tga.image_type > 8)
		149	{
		150	fprintf(stderr, "Sorry, compressed tga files are not currently supported.\n");
		151	return 0 ;
		152	}
		153
		154	*flip_image = !(tga.image_desc & 32);
		155
		156	// Palettized formats are not yet supported, skip over the palette, if present ...
		157	palette_size = tga.colour_map_length * (tga.colour_map_entry_size/8);
		158
		159	if (palette_size>0)
		160	{
		161	fprintf(stderr, "File contains a palette - not yet supported.");
		162	fseek(fp, palette_size, SEEK_CUR);
		163	}
		164	return 1;
		165	}
		166
		167	int tga_writeheader(FILE *fp, int bits_per_pixel, int width, int height,
		168	bool flip_image)
		169	{
		170	tga_header tga;
		171
		172	if (!bits_per_pixel \|\| !width \|\| !height)
		173	return 0;
		174
		175	memset(&tga, 0, sizeof(tga_header));
		176
		177	tga.pixel_depth = bits_per_pixel;
		178	tga.image_width = width;
		179	tga.image_height = height;
		180	tga.image_type = 2; // Uncompressed.
		181	tga.image_desc = 8; // 8 bits per component.
		182
		183	if (flip_image)
		184	tga.image_desc \|= 32;
		185
		186	// Write TGA header
		187	fwrite((unsigned char*)&tga, sizeof(tga_header), 1, fp);
		188
		189	return 1;
		190	}
		191
		192	opj_image_t* tgatoimage(const char filename, opj_cparameters_t parameters) {
		193	FILE *f;
		194	opj_image_t *image;
		195	unsigned int image_width, image_height, pixel_bit_depth;
		196	unsigned int x, y;
		197	int flip_image=0;
		198	opj_image_cmptparm_t cmptparm[4]; /* maximum 4 components */
		199	int numcomps;
		200	OPJ_COLOR_SPACE color_space;
		201	bool mono ;
		202	bool save_alpha;
		203	int subsampling_dx, subsampling_dy;
		204	int i;
		205
		206	f = fopen(filename, "rb");
		207	if (!f) {
		208	fprintf(stderr, "Failed to open %s for reading !!\n", filename);
		209	return 0;
		210	}
		211
		212	if (!tga_readheader(f, &pixel_bit_depth, &image_width, &image_height, &flip_image))
		213	return NULL;
		214
		215	// We currently only support 24 & 32 bit tga's ...
		216	if (!((pixel_bit_depth == 24) \|\| (pixel_bit_depth == 32)))
		217	return NULL;
		218
		219	/* initialize image components */
		220	memset(&cmptparm[0], 0, 4 * sizeof(opj_image_cmptparm_t));
		221
		222	mono = (pixel_bit_depth == 8) \|\| (pixel_bit_depth == 16); // Mono with & without alpha.
		223	save_alpha = (pixel_bit_depth == 16) \|\| (pixel_bit_depth == 32); // Mono with alpha, or RGB with alpha
		224
		225	if (mono) {
		226	color_space = CLRSPC_GRAY;
		227	numcomps = save_alpha ? 2 : 1;
		228	}
		229	else {
		230	numcomps = save_alpha ? 4 : 3;
		231	color_space = CLRSPC_SRGB;
		232	}
		233
		234	subsampling_dx = parameters->subsampling_dx;
		235	subsampling_dy = parameters->subsampling_dy;
		236
		237	for (i = 0; i < numcomps; i++) {
		238	cmptparm[i].prec = 8;
		239	cmptparm[i].bpp = 8;
		240	cmptparm[i].sgnd = 0;
		241	cmptparm[i].dx = subsampling_dx;
		242	cmptparm[i].dy = subsampling_dy;
		243	cmptparm[i].w = image_width;
		244	cmptparm[i].h = image_height;
		245	}
		246
		247	/* create the image */
		248	image = opj_image_create(numcomps, &cmptparm[0], color_space);
		249
		250	if (!image)
		251	return NULL;
		252
		253	/* set image offset and reference grid */
		254	image->x0 = parameters->image_offset_x0;
		255	image->y0 = parameters->image_offset_y0;
		256	image->x1 = !image->x0 ? (image_width - 1) * subsampling_dx + 1 : image->x0 + (image_width - 1) * subsampling_dx + 1;
		257	image->y1 = !image->y0 ? (image_height - 1) * subsampling_dy + 1 : image->y0 + (image_height - 1) * subsampling_dy + 1;
		258
		259	/* set image data */
		260	for (y=0; y < image_height; y++)
		261	{
		262	int index;
		263
		264	if (flip_image)
		265	index = (image_height-y-1)*image_width;
		266	else
		267	index = y*image_width;
		268
		269	if (numcomps==3)
		270	{
		271	for (x=0;x
		272	{
		273	unsigned char r,g,b;
		274	fread(&b, 1, 1, f);
		275	fread(&g, 1, 1, f);
		276	fread(&r, 1, 1, f);
		277
		278	image->comps[0].data[index]=r;
		279	image->comps[1].data[index]=g;
		280	image->comps[2].data[index]=b;
		281	index++;
		282	}
		283	}
		284	else if (numcomps==4)
		285	{
		286	for (x=0;x
		287	{
		288	unsigned char r,g,b,a;
		289	fread(&b, 1, 1, f);
		290	fread(&g, 1, 1, f);
		291	fread(&r, 1, 1, f);
		292	fread(&a, 1, 1, f);
		293
		294	image->comps[0].data[index]=r;
		295	image->comps[1].data[index]=g;
		296	image->comps[2].data[index]=b;
		297	image->comps[3].data[index]=a;
		298	index++;
		299	}
		300	}
		301	else {
		302	fprintf(stderr, "Currently unsupported bit depth : %s\n", filename);
		303	}
		304	}
		305	return image;
		306	}
		307
		308	int imagetotga(opj_image_t * image, const char *outfile) {
		309	int width, height, bpp, x, y;
		310	bool write_alpha;
		311	int i;
		312	unsigned int alpha_channel;
		313	float r,g,b,a;
		314	unsigned char value;
		315	float scale;
		316	FILE *fdest;
		317
		318	fdest = fopen(outfile, "wb");
		319	if (!fdest) {
		320	fprintf(stderr, "ERROR -> failed to open %s for writing\n", outfile);
		321	return 1;
		322	}
		323
		324	for (i = 0; i < image->numcomps-1; i++) {
		325	if ((image->comps[0].dx != image->comps[i+1].dx)
		326	\|\|(image->comps[0].dy != image->comps[i+1].dy)
		327	\|\|(image->comps[0].prec != image->comps[i+1].prec)) {
		328	fprintf(stderr, "Unable to create a tga file with such J2K image charateristics.");
		329	return 1;
		330	}
		331	}
		332
		333	width = image->comps[0].w;
		334	height = image->comps[0].h;
		335
		336	// Mono with alpha, or RGB with alpha.
		337	write_alpha = (image->numcomps==2) \|\| (image->numcomps==4);
		338
		339	// Write TGA header
		340	bpp = write_alpha ? 32 : 24;
		341	if (!tga_writeheader(fdest, bpp, width , height, true))
		342	return 1;
		343
		344	alpha_channel = image->numcomps-1;
		345
		346	scale = 255.0f / (float)((1<comps[0].prec)-1);
		347
		348	for (y=0; y < height; y++) {
		349	unsigned int index=y*width;
		350
		351	for (x=0; x < width; x++, index++) {
		352	r = (float)(image->comps[0].data[index]);
		353
		354	if (image->numcomps>2) {
		355	g = (float)(image->comps[1].data[index]);
		356	b = (float)(image->comps[2].data[index]);
		357	}
		358	else {// Greyscale ...
		359	g = r;
		360	b = r;
		361	}
		362
		363	// TGA format writes BGR ...
		364	value = (unsigned char)(b*scale);
		365	fwrite(&value,1,1,fdest);
		366
		367	value = (unsigned char)(g*scale);
		368	fwrite(&value,1,1,fdest);
		369
		370	value = (unsigned char)(r*scale);
		371	fwrite(&value,1,1,fdest);
		372
		373	if (write_alpha) {
		374	a = (float)(image->comps[alpha_channel].data[index]);
		375	value = (unsigned char)(a*scale);
		376	fwrite(&value,1,1,fdest);
		377	}
		378	}
		379	}
		380
		381	return 0;
		382	}
		383
		384	/* -->> -->> -->> -->>
		385
		386	BMP IMAGE FORMAT
		387
		388	<<-- <<-- <<-- <<-- */
		389
		390	/* WORD defines a two byte word */
		391	typedef unsigned short int WORD;
		392
		393	/* DWORD defines a four byte word */
		394	typedef unsigned long int DWORD;
		395
		396	typedef struct {
		397	WORD bfType; /* 'BM' for Bitmap (19776) */
		398	DWORD bfSize; /* Size of the file */
		399	WORD bfReserved1; /* Reserved : 0 */
		400	WORD bfReserved2; /* Reserved : 0 */
		401	DWORD bfOffBits; /* Offset */
		402	} BITMAPFILEHEADER_t;
		403
		404	typedef struct {
		405	DWORD biSize; /* Size of the structure in bytes */
		406	DWORD biWidth; /* Width of the image in pixels */
		407	DWORD biHeight; /* Heigth of the image in pixels */
		408	WORD biPlanes; /* 1 */
		409	WORD biBitCount; /* Number of color bits by pixels */
		410	DWORD biCompression; /* Type of encoding 0: none 1: RLE8 2: RLE4 */
		411	DWORD biSizeImage; /* Size of the image in bytes */
		412	DWORD biXpelsPerMeter; /* Horizontal (X) resolution in pixels/meter */
		413	DWORD biYpelsPerMeter; /* Vertical (Y) resolution in pixels/meter */
		414	DWORD biClrUsed; /* Number of color used in the image (0: ALL) */
		415	DWORD biClrImportant; /* Number of important color (0: ALL) */
		416	} BITMAPINFOHEADER_t;
		417
		418	opj_image_t* bmptoimage(const char filename, opj_cparameters_t parameters) {
		419	int subsampling_dx = parameters->subsampling_dx;
		420	int subsampling_dy = parameters->subsampling_dy;
		421
		422	int i, numcomps, w, h;
		423	OPJ_COLOR_SPACE color_space;
		424	opj_image_cmptparm_t cmptparm[3]; /* maximum of 3 components */
		425	opj_image_t * image = NULL;
		426
		427	FILE *IN;
		428	BITMAPFILEHEADER_t File_h;
		429	BITMAPINFOHEADER_t Info_h;
		430	unsigned char *RGB;
		431	unsigned char table_R, table_G, *table_B;
		432	unsigned int j, PAD = 0;
		433
		434	int x, y, index;
		435	int gray_scale = 1, not_end_file = 1;
		436
		437	unsigned int line = 0, col = 0;
		438	unsigned char v, v2;
		439	DWORD W, H;
		440
		441	IN = fopen(filename, "rb");
		442	if (!IN) {
		443	fprintf(stderr, "Failed to open %s for reading !!\n", filename);
		444	return 0;
		445	}
		446
		447	File_h.bfType = getc(IN);
		448	File_h.bfType = (getc(IN) << 8) + File_h.bfType;
		449
		450	if (File_h.bfType != 19778) {
		451	fprintf(stderr,"Error, not a BMP file!\n");
		452	return 0;
		453	} else {
		454	/* FILE HEADER */
		455	/* ------------- */
		456	File_h.bfSize = getc(IN);
		457	File_h.bfSize = (getc(IN) << 8) + File_h.bfSize;
		458	File_h.bfSize = (getc(IN) << 16) + File_h.bfSize;
		459	File_h.bfSize = (getc(IN) << 24) + File_h.bfSize;
		460
		461	File_h.bfReserved1 = getc(IN);
		462	File_h.bfReserved1 = (getc(IN) << 8) + File_h.bfReserved1;
		463
		464	File_h.bfReserved2 = getc(IN);
		465	File_h.bfReserved2 = (getc(IN) << 8) + File_h.bfReserved2;
		466
		467	File_h.bfOffBits = getc(IN);
		468	File_h.bfOffBits = (getc(IN) << 8) + File_h.bfOffBits;
		469	File_h.bfOffBits = (getc(IN) << 16) + File_h.bfOffBits;
		470	File_h.bfOffBits = (getc(IN) << 24) + File_h.bfOffBits;
		471
		472	/* INFO HEADER */
		473	/* ------------- */
		474
		475	Info_h.biSize = getc(IN);
		476	Info_h.biSize = (getc(IN) << 8) + Info_h.biSize;
		477	Info_h.biSize = (getc(IN) << 16) + Info_h.biSize;
		478	Info_h.biSize = (getc(IN) << 24) + Info_h.biSize;
		479
		480	Info_h.biWidth = getc(IN);
		481	Info_h.biWidth = (getc(IN) << 8) + Info_h.biWidth;
		482	Info_h.biWidth = (getc(IN) << 16) + Info_h.biWidth;
		483	Info_h.biWidth = (getc(IN) << 24) + Info_h.biWidth;
		484	w = Info_h.biWidth;
		485
		486	Info_h.biHeight = getc(IN);
		487	Info_h.biHeight = (getc(IN) << 8) + Info_h.biHeight;
		488	Info_h.biHeight = (getc(IN) << 16) + Info_h.biHeight;
		489	Info_h.biHeight = (getc(IN) << 24) + Info_h.biHeight;
		490	h = Info_h.biHeight;
		491
		492	Info_h.biPlanes = getc(IN);
		493	Info_h.biPlanes = (getc(IN) << 8) + Info_h.biPlanes;
		494
		495	Info_h.biBitCount = getc(IN);
		496	Info_h.biBitCount = (getc(IN) << 8) + Info_h.biBitCount;
		497
		498	Info_h.biCompression = getc(IN);
		499	Info_h.biCompression = (getc(IN) << 8) + Info_h.biCompression;
		500	Info_h.biCompression = (getc(IN) << 16) + Info_h.biCompression;
		501	Info_h.biCompression = (getc(IN) << 24) + Info_h.biCompression;
		502
		503	Info_h.biSizeImage = getc(IN);
		504	Info_h.biSizeImage = (getc(IN) << 8) + Info_h.biSizeImage;
		505	Info_h.biSizeImage = (getc(IN) << 16) + Info_h.biSizeImage;
		506	Info_h.biSizeImage = (getc(IN) << 24) + Info_h.biSizeImage;
		507
		508	Info_h.biXpelsPerMeter = getc(IN);
		509	Info_h.biXpelsPerMeter = (getc(IN) << 8) + Info_h.biXpelsPerMeter;
		510	Info_h.biXpelsPerMeter = (getc(IN) << 16) + Info_h.biXpelsPerMeter;
		511	Info_h.biXpelsPerMeter = (getc(IN) << 24) + Info_h.biXpelsPerMeter;
		512
		513	Info_h.biYpelsPerMeter = getc(IN);
		514	Info_h.biYpelsPerMeter = (getc(IN) << 8) + Info_h.biYpelsPerMeter;
		515	Info_h.biYpelsPerMeter = (getc(IN) << 16) + Info_h.biYpelsPerMeter;
		516	Info_h.biYpelsPerMeter = (getc(IN) << 24) + Info_h.biYpelsPerMeter;
		517
		518	Info_h.biClrUsed = getc(IN);
		519	Info_h.biClrUsed = (getc(IN) << 8) + Info_h.biClrUsed;
		520	Info_h.biClrUsed = (getc(IN) << 16) + Info_h.biClrUsed;
		521	Info_h.biClrUsed = (getc(IN) << 24) + Info_h.biClrUsed;
		522
		523	Info_h.biClrImportant = getc(IN);
		524	Info_h.biClrImportant = (getc(IN) << 8) + Info_h.biClrImportant;
		525	Info_h.biClrImportant = (getc(IN) << 16) + Info_h.biClrImportant;
		526	Info_h.biClrImportant = (getc(IN) << 24) + Info_h.biClrImportant;
		527
		528	/* Read the data and store them in the OUT file */
		529
		530	if (Info_h.biBitCount == 24) {
		531	numcomps = 3;
		532	color_space = CLRSPC_SRGB;
		533	/* initialize image components */
		534	memset(&cmptparm[0], 0, 3 * sizeof(opj_image_cmptparm_t));
		535	for(i = 0; i < numcomps; i++) {
		536	cmptparm[i].prec = 8;
		537	cmptparm[i].bpp = 8;
		538	cmptparm[i].sgnd = 0;
		539	cmptparm[i].dx = subsampling_dx;
		540	cmptparm[i].dy = subsampling_dy;
		541	cmptparm[i].w = w;
		542	cmptparm[i].h = h;
		543	}
		544	/* create the image */
		545	image = opj_image_create(numcomps, &cmptparm[0], color_space);
		546	if(!image) {
		547	fclose(IN);
		548	return NULL;
		549	}
		550
		551	/* set image offset and reference grid */
		552	image->x0 = parameters->image_offset_x0;
		553	image->y0 = parameters->image_offset_y0;
		554	image->x1 = !image->x0 ? (w - 1) * subsampling_dx + 1 : image->x0 + (w - 1) * subsampling_dx + 1;
		555	image->y1 = !image->y0 ? (h - 1) * subsampling_dy + 1 : image->y0 + (h - 1) * subsampling_dy + 1;
		556
		557	/* set image data */
		558
		559	/* Place the cursor at the beginning of the image information */
		560	fseek(IN, 0, SEEK_SET);
		561	fseek(IN, File_h.bfOffBits, SEEK_SET);
		562
		563	W = Info_h.biWidth;
		564	H = Info_h.biHeight;
		565
		566	/* PAD = 4 - (3 * W) % 4; */
		567	/* PAD = (PAD == 4) ? 0 : PAD; */
		568	PAD = (3 * W) % 4 ? 4 - (3 * W) % 4 : 0;
		569
		570	RGB = (unsigned char ) malloc((3 W + PAD) * H * sizeof(unsigned char));
		571
		572	fread(RGB, sizeof(unsigned char), (3 * W + PAD) * H, IN);
		573
		574	index = 0;
		575
		576	for(y = 0; y < (int)H; y++) {
		577	unsigned char scanline = RGB + (3 W + PAD) * (H - 1 - y);
		578	for(x = 0; x < (int)W; x++) {
		579	unsigned char pixel = &scanline[3 x];
		580	image->comps[0].data[index] = pixel[2]; /* R */
		581	image->comps[1].data[index] = pixel[1]; /* G */
		582	image->comps[2].data[index] = pixel[0]; /* B */
		583	index++;
		584	}
		585	}
		586
		587	free(RGB);
		588
		589	} else if (Info_h.biBitCount == 8 && Info_h.biCompression == 0) {
		590	table_R = (unsigned char ) malloc(256 sizeof(unsigned char));
		591	table_G = (unsigned char ) malloc(256 sizeof(unsigned char));
		592	table_B = (unsigned char ) malloc(256 sizeof(unsigned char));
		593
		594	for (j = 0; j < Info_h.biClrUsed; j++) {
		595	table_B[j] = getc(IN);
		596	table_G[j] = getc(IN);
		597	table_R[j] = getc(IN);
		598	getc(IN);
		599	if (table_R[j] != table_G[j] && table_R[j] != table_B[j] && table_G[j] != table_B[j])
		600	gray_scale = 0;
		601	}
		602
		603	/* Place the cursor at the beginning of the image information */
		604	fseek(IN, 0, SEEK_SET);
		605	fseek(IN, File_h.bfOffBits, SEEK_SET);
		606
		607	W = Info_h.biWidth;
		608	H = Info_h.biHeight;
		609	if (Info_h.biWidth % 2)
		610	W++;
		611
		612	numcomps = gray_scale ? 1 : 3;
		613	color_space = gray_scale ? CLRSPC_GRAY : CLRSPC_SRGB;
		614	/* initialize image components */
		615	memset(&cmptparm[0], 0, 3 * sizeof(opj_image_cmptparm_t));
		616	for(i = 0; i < numcomps; i++) {
		617	cmptparm[i].prec = 8;
		618	cmptparm[i].bpp = 8;
		619	cmptparm[i].sgnd = 0;
		620	cmptparm[i].dx = subsampling_dx;
		621	cmptparm[i].dy = subsampling_dy;
		622	cmptparm[i].w = w;
		623	cmptparm[i].h = h;
		624	}
		625	/* create the image */
		626	image = opj_image_create(numcomps, &cmptparm[0], color_space);
		627	if(!image) {
		628	fclose(IN);
		629	return NULL;
		630	}
		631
		632	/* set image offset and reference grid */
		633	image->x0 = parameters->image_offset_x0;
		634	image->y0 = parameters->image_offset_y0;
		635	image->x1 = !image->x0 ? (w - 1) * subsampling_dx + 1 : image->x0 + (w - 1) * subsampling_dx + 1;
		636	image->y1 = !image->y0 ? (h - 1) * subsampling_dy + 1 : image->y0 + (h - 1) * subsampling_dy + 1;
		637
		638	/* set image data */
		639
		640	RGB = (unsigned char ) malloc(W H * sizeof(unsigned char));
		641
		642	fread(RGB, sizeof(unsigned char), W * H, IN);
		643	if (gray_scale) {
		644	index = 0;
		645	for (j = 0; j < W * H; j++) {
		646	if ((j % W < W - 1 && Info_h.biWidth % 2) \|\| !(Info_h.biWidth % 2)) {
		647	image->comps[0].data[index] = table_R[RGB[W * H - ((j) / (W) + 1) * W + (j) % (W)]];
		648	index++;
		649	}
		650	}
		651
		652	} else {
		653	index = 0;
		654	for (j = 0; j < W * H; j++) {
		655	if ((j % W < W - 1 && Info_h.biWidth % 2) \|\| !(Info_h.biWidth % 2)) {
		656	unsigned char pixel_index = RGB[W * H - ((j) / (W) + 1) * W + (j) % (W)];
		657	image->comps[0].data[index] = table_R[pixel_index];
		658	image->comps[1].data[index] = table_G[pixel_index];
		659	image->comps[2].data[index] = table_B[pixel_index];
		660	index++;
		661	}
		662	}
		663	}
		664	free(RGB);
		665	free(table_R);
		666	free(table_G);
		667	free(table_B);
		668	} else if (Info_h.biBitCount == 8 && Info_h.biCompression == 1) {
		669	table_R = (unsigned char ) malloc(256 sizeof(unsigned char));
		670	table_G = (unsigned char ) malloc(256 sizeof(unsigned char));
		671	table_B = (unsigned char ) malloc(256 sizeof(unsigned char));
		672
		673	for (j = 0; j < Info_h.biClrUsed; j++) {
		674	table_B[j] = getc(IN);
		675	table_G[j] = getc(IN);
		676	table_R[j] = getc(IN);
		677	getc(IN);
		678	if (table_R[j] != table_G[j] && table_R[j] != table_B[j] && table_G[j] != table_B[j])
		679	gray_scale = 0;
		680	}
		681
		682	numcomps = gray_scale ? 1 : 3;
		683	color_space = gray_scale ? CLRSPC_GRAY : CLRSPC_SRGB;
		684	/* initialize image components */
		685	memset(&cmptparm[0], 0, 3 * sizeof(opj_image_cmptparm_t));
		686	for(i = 0; i < numcomps; i++) {
		687	cmptparm[i].prec = 8;
		688	cmptparm[i].bpp = 8;
		689	cmptparm[i].sgnd = 0;
		690	cmptparm[i].dx = subsampling_dx;
		691	cmptparm[i].dy = subsampling_dy;
		692	cmptparm[i].w = w;
		693	cmptparm[i].h = h;
		694	}
		695	/* create the image */
		696	image = opj_image_create(numcomps, &cmptparm[0], color_space);
		697	if(!image) {
		698	fclose(IN);
		699	return NULL;
		700	}
		701
		702	/* set image offset and reference grid */
		703	image->x0 = parameters->image_offset_x0;
		704	image->y0 = parameters->image_offset_y0;
		705	image->x1 = !image->x0 ? (w - 1) * subsampling_dx + 1 : image->x0 + (w - 1) * subsampling_dx + 1;
		706	image->y1 = !image->y0 ? (h - 1) * subsampling_dy + 1 : image->y0 + (h - 1) * subsampling_dy + 1;
		707
		708	/* set image data */
		709
		710	/* Place the cursor at the beginning of the image information */
		711	fseek(IN, 0, SEEK_SET);
		712	fseek(IN, File_h.bfOffBits, SEEK_SET);
		713
		714	RGB = (unsigned char ) malloc(Info_h.biWidth Info_h.biHeight * sizeof(unsigned char));
		715
		716	while (not_end_file) {
		717	v = getc(IN);
		718	if (v) {
		719	v2 = getc(IN);
		720	for (i = 0; i < (int) v; i++) {
		721	RGB[line * Info_h.biWidth + col] = v2;
		722	col++;
		723	}
		724	} else {
		725	v = getc(IN);
		726	switch (v) {
		727	case 0:
		728	col = 0;
		729	line++;
		730	break;
		731	case 1:
		732	line++;
		733	not_end_file = 0;
		734	break;
		735	case 2:
		736	fprintf(stderr,"No Delta supported\n");
		737	opj_image_destroy(image);
		738	fclose(IN);
		739	return NULL;
		740	default:
		741	for (i = 0; i < v; i++) {
		742	v2 = getc(IN);
		743	RGB[line * Info_h.biWidth + col] = v2;
		744	col++;
		745	}
		746	if (v % 2)
		747	v2 = getc(IN);
		748	break;
		749	}
		750	}
		751	}
		752	if (gray_scale) {
		753	index = 0;
		754	for (line = 0; line < Info_h.biHeight; line++) {
		755	for (col = 0; col < Info_h.biWidth; col++) {
		756	image->comps[0].data[index] = table_R[(int)RGB[(Info_h.biHeight - line - 1) * Info_h.biWidth + col]];
		757	index++;
		758	}
		759	}
		760	} else {
		761	index = 0;
		762	for (line = 0; line < Info_h.biHeight; line++) {
		763	for (col = 0; col < Info_h.biWidth; col++) {
		764	unsigned char pixel_index = (int)RGB[(Info_h.biHeight - line - 1) * Info_h.biWidth + col];
		765	image->comps[0].data[index] = table_R[pixel_index];
		766	image->comps[1].data[index] = table_G[pixel_index];
		767	image->comps[2].data[index] = table_B[pixel_index];
		768	index++;
		769	}
		770	}
		771	}
		772	free(RGB);
		773	free(table_R);
		774	free(table_G);
		775	free(table_B);
		776	} else {
		777	fprintf(stderr,
		778	"Other system than 24 bits/pixels or 8 bits (no RLE coding) is not yet implemented [%d]\n", Info_h.biBitCount);
		779	}
		780	fclose(IN);
		781	}
		782
		783	return image;
		784	}
		785
		786	int imagetobmp(opj_image_t * image, const char *outfile) {
		787	int w, h;
		788	int i, pad;
		789	FILE *fdest = NULL;
		790	int adjustR, adjustG, adjustB;
		791
		792	if (image->numcomps == 3 && image->comps[0].dx == image->comps[1].dx
		793	&& image->comps[1].dx == image->comps[2].dx
		794	&& image->comps[0].dy == image->comps[1].dy
		795	&& image->comps[1].dy == image->comps[2].dy
		796	&& image->comps[0].prec == image->comps[1].prec
		797	&& image->comps[1].prec == image->comps[2].prec) {
		798
		799	/* -->> -->> -->> -->>
		800	24 bits color
		801	<<-- <<-- <<-- <<-- */
		802
		803	fdest = fopen(outfile, "wb");
		804	if (!fdest) {
		805	fprintf(stderr, "ERROR -> failed to open %s for writing\n", outfile);
		806	return 1;
		807	}
		808
		809	w = image->comps[0].w;
		810	h = image->comps[0].h;
		811
		812	fprintf(fdest, "BM");
		813
		814	/* FILE HEADER */
		815	/* ------------- */
		816	fprintf(fdest, "%c%c%c%c",
		817	(unsigned char) (h * w * 3 + 3 * h * (w % 2) + 54) & 0xff,
		818	(unsigned char) ((h * w * 3 + 3 * h * (w % 2) + 54) >> 8) & 0xff,
		819	(unsigned char) ((h * w * 3 + 3 * h * (w % 2) + 54) >> 16) & 0xff,
		820	(unsigned char) ((h * w * 3 + 3 * h * (w % 2) + 54) >> 24) & 0xff);
		821	fprintf(fdest, "%c%c%c%c", (0) & 0xff, ((0) >> 8) & 0xff, ((0) >> 16) & 0xff, ((0) >> 24) & 0xff);
		822	fprintf(fdest, "%c%c%c%c", (54) & 0xff, ((54) >> 8) & 0xff,((54) >> 16) & 0xff, ((54) >> 24) & 0xff);
		823
		824	/* INFO HEADER */
		825	/* ------------- */
		826	fprintf(fdest, "%c%c%c%c", (40) & 0xff, ((40) >> 8) & 0xff, ((40) >> 16) & 0xff, ((40) >> 24) & 0xff);
		827	fprintf(fdest, "%c%c%c%c", (unsigned char) ((w) & 0xff),
		828	(unsigned char) ((w) >> 8) & 0xff,
		829	(unsigned char) ((w) >> 16) & 0xff,
		830	(unsigned char) ((w) >> 24) & 0xff);
		831	fprintf(fdest, "%c%c%c%c", (unsigned char) ((h) & 0xff),
		832	(unsigned char) ((h) >> 8) & 0xff,
		833	(unsigned char) ((h) >> 16) & 0xff,
		834	(unsigned char) ((h) >> 24) & 0xff);
		835	fprintf(fdest, "%c%c", (1) & 0xff, ((1) >> 8) & 0xff);
		836	fprintf(fdest, "%c%c", (24) & 0xff, ((24) >> 8) & 0xff);
		837	fprintf(fdest, "%c%c%c%c", (0) & 0xff, ((0) >> 8) & 0xff, ((0) >> 16) & 0xff, ((0) >> 24) & 0xff);
		838	fprintf(fdest, "%c%c%c%c", (unsigned char) (3 * h * w + 3 * h * (w % 2)) & 0xff,
		839	(unsigned char) ((h * w * 3 + 3 * h * (w % 2)) >> 8) & 0xff,
		840	(unsigned char) ((h * w * 3 + 3 * h * (w % 2)) >> 16) & 0xff,
		841	(unsigned char) ((h * w * 3 + 3 * h * (w % 2)) >> 24) & 0xff);
		842	fprintf(fdest, "%c%c%c%c", (7834) & 0xff, ((7834) >> 8) & 0xff, ((7834) >> 16) & 0xff, ((7834) >> 24) & 0xff);
		843	fprintf(fdest, "%c%c%c%c", (7834) & 0xff, ((7834) >> 8) & 0xff, ((7834) >> 16) & 0xff, ((7834) >> 24) & 0xff);
		844	fprintf(fdest, "%c%c%c%c", (0) & 0xff, ((0) >> 8) & 0xff, ((0) >> 16) & 0xff, ((0) >> 24) & 0xff);
		845	fprintf(fdest, "%c%c%c%c", (0) & 0xff, ((0) >> 8) & 0xff, ((0) >> 16) & 0xff, ((0) >> 24) & 0xff);
		846
		847	if (image->comps[0].prec > 8) {
		848	adjustR = image->comps[0].prec - 8;
		849	printf("BMP CONVERSION: Truncating component 0 from %d bits to 8 bits\n", image->comps[0].prec);
		850	}
		851	else
		852	adjustR = 0;
		853	if (image->comps[1].prec > 8) {
		854	adjustG = image->comps[1].prec - 8;
		855	printf("BMP CONVERSION: Truncating component 1 from %d bits to 8 bits\n", image->comps[1].prec);
		856	}
		857	else
		858	adjustG = 0;
		859	if (image->comps[2].prec > 8) {
		860	adjustB = image->comps[2].prec - 8;
		861	printf("BMP CONVERSION: Truncating component 2 from %d bits to 8 bits\n", image->comps[2].prec);
		862	}
		863	else
		864	adjustB = 0;
		865
		866	for (i = 0; i < w * h; i++) {
		867	unsigned char rc, gc, bc;
		868	int r, g, b;
		869
		870	r = image->comps[0].data[w * h - ((i) / (w) + 1) * w + (i) % (w)];
		871	r += (image->comps[0].sgnd ? 1 << (image->comps[0].prec - 1) : 0);
		872	rc = (unsigned char) ((r >> adjustR)+((r >> (adjustR-1))%2));
		873	g = image->comps[1].data[w * h - ((i) / (w) + 1) * w + (i) % (w)];
		874	g += (image->comps[1].sgnd ? 1 << (image->comps[1].prec - 1) : 0);
		875	gc = (unsigned char) ((g >> adjustG)+((g >> (adjustG-1))%2));
		876	b = image->comps[2].data[w * h - ((i) / (w) + 1) * w + (i) % (w)];
		877	b += (image->comps[2].sgnd ? 1 << (image->comps[2].prec - 1) : 0);
		878	bc = (unsigned char) ((b >> adjustB)+((b >> (adjustB-1))%2));
		879
		880	fprintf(fdest, "%c%c%c", bc, gc, rc);
		881
		882	if ((i + 1) % w == 0) {
		883	for (pad = (3 * w) % 4 ? 4 - (3 * w) % 4 : 0; pad > 0; pad--) /* ADD */
		884	fprintf(fdest, "%c", 0);
		885	}
		886	}
		887	fclose(fdest);
		888	} else { /* Gray-scale */
		889
		890	/* -->> -->> -->> -->>
		891	8 bits non code (Gray scale)
		892	<<-- <<-- <<-- <<-- */
		893
		894	fdest = fopen(outfile, "wb");
		895	w = image->comps[0].w;
		896	h = image->comps[0].h;
		897
		898	fprintf(fdest, "BM");
		899
		900	/* FILE HEADER */
		901	/* ------------- */
		902	fprintf(fdest, "%c%c%c%c", (unsigned char) (h * w + 54 + 1024 + h * (w % 2)) & 0xff,
		903	(unsigned char) ((h * w + 54 + 1024 + h * (w % 2)) >> 8) & 0xff,
		904	(unsigned char) ((h * w + 54 + 1024 + h * (w % 2)) >> 16) & 0xff,
		905	(unsigned char) ((h * w + 54 + 1024 + w * (w % 2)) >> 24) & 0xff);
		906	fprintf(fdest, "%c%c%c%c", (0) & 0xff, ((0) >> 8) & 0xff, ((0) >> 16) & 0xff, ((0) >> 24) & 0xff);
		907	fprintf(fdest, "%c%c%c%c", (54 + 1024) & 0xff, ((54 + 1024) >> 8) & 0xff,
		908	((54 + 1024) >> 16) & 0xff,
		909	((54 + 1024) >> 24) & 0xff);
		910
		911	/* INFO HEADER */
		912	/* ------------- */
		913	fprintf(fdest, "%c%c%c%c", (40) & 0xff, ((40) >> 8) & 0xff, ((40) >> 16) & 0xff, ((40) >> 24) & 0xff);
		914	fprintf(fdest, "%c%c%c%c", (unsigned char) ((w) & 0xff),
		915	(unsigned char) ((w) >> 8) & 0xff,
		916	(unsigned char) ((w) >> 16) & 0xff,
		917	(unsigned char) ((w) >> 24) & 0xff);
		918	fprintf(fdest, "%c%c%c%c", (unsigned char) ((h) & 0xff),
		919	(unsigned char) ((h) >> 8) & 0xff,
		920	(unsigned char) ((h) >> 16) & 0xff,
		921	(unsigned char) ((h) >> 24) & 0xff);
		922	fprintf(fdest, "%c%c", (1) & 0xff, ((1) >> 8) & 0xff);
		923	fprintf(fdest, "%c%c", (8) & 0xff, ((8) >> 8) & 0xff);
		924	fprintf(fdest, "%c%c%c%c", (0) & 0xff, ((0) >> 8) & 0xff, ((0) >> 16) & 0xff, ((0) >> 24) & 0xff);
		925	fprintf(fdest, "%c%c%c%c", (unsigned char) (h * w + h * (w % 2)) & 0xff,
		926	(unsigned char) ((h * w + h * (w % 2)) >> 8) & 0xff,
		927	(unsigned char) ((h * w + h * (w % 2)) >> 16) & 0xff,
		928	(unsigned char) ((h * w + h * (w % 2)) >> 24) & 0xff);
		929	fprintf(fdest, "%c%c%c%c", (7834) & 0xff, ((7834) >> 8) & 0xff, ((7834) >> 16) & 0xff, ((7834) >> 24) & 0xff);
		930	fprintf(fdest, "%c%c%c%c", (7834) & 0xff, ((7834) >> 8) & 0xff, ((7834) >> 16) & 0xff, ((7834) >> 24) & 0xff);
		931	fprintf(fdest, "%c%c%c%c", (256) & 0xff, ((256) >> 8) & 0xff, ((256) >> 16) & 0xff, ((256) >> 24) & 0xff);
		932	fprintf(fdest, "%c%c%c%c", (256) & 0xff, ((256) >> 8) & 0xff, ((256) >> 16) & 0xff, ((256) >> 24) & 0xff);
		933
		934	if (image->comps[0].prec > 8) {
		935	adjustR = image->comps[0].prec - 8;
		936	printf("BMP CONVERSION: Truncating component 0 from %d bits to 8 bits\n", image->comps[0].prec);
		937	}else
		938	adjustR = 0;
		939
		940	for (i = 0; i < 256; i++) {
		941	fprintf(fdest, "%c%c%c%c", i, i, i, 0);
		942	}
		943
		944	for (i = 0; i < w * h; i++) {
		945	unsigned char rc;
		946	int r;
		947
		948	r = image->comps[0].data[w * h - ((i) / (w) + 1) * w + (i) % (w)];
		949	r += (image->comps[0].sgnd ? 1 << (image->comps[0].prec - 1) : 0);
		950	rc = (unsigned char) ((r >> adjustR)+((r >> (adjustR-1))%2));
		951
		952	fprintf(fdest, "%c", rc);
		953
		954	if ((i + 1) % w == 0) {
		955	for (pad = w % 4 ? 4 - w % 4 : 0; pad > 0; pad--) /* ADD */
		956	fprintf(fdest, "%c", 0);
		957	}
		958	}
		959	fclose(fdest);
		960	}
		961
		962	return 0;
		963	}
		964
		965	/* -->> -->> -->> -->>
		966
		967	PGX IMAGE FORMAT
		968
		969	<<-- <<-- <<-- <<-- */
		970
		971
		972	unsigned char readuchar(FILE * f)
		973	{
		974	unsigned char c1;
		975	fread(&c1, 1, 1, f);
		976	return c1;
		977	}
		978
		979	unsigned short readushort(FILE * f, int bigendian)
		980	{
		981	unsigned char c1, c2;
		982	fread(&c1, 1, 1, f);
		983	fread(&c2, 1, 1, f);
		984	if (bigendian)
		985	return (c1 << 8) + c2;
		986	else
		987	return (c2 << 8) + c1;
		988	}
		989
		990	unsigned int readuint(FILE * f, int bigendian)
		991	{
		992	unsigned char c1, c2, c3, c4;
		993	fread(&c1, 1, 1, f);
		994	fread(&c2, 1, 1, f);
		995	fread(&c3, 1, 1, f);
		996	fread(&c4, 1, 1, f);
		997	if (bigendian)
		998	return (c1 << 24) + (c2 << 16) + (c3 << 8) + c4;
		999	else
		1000	return (c4 << 24) + (c3 << 16) + (c2 << 8) + c1;
		1001	}
		1002
		1003	opj_image_t* pgxtoimage(const char filename, opj_cparameters_t parameters) {
		1004	FILE *f = NULL;
		1005	int w, h, prec;
		1006	int i, numcomps, max;
		1007	OPJ_COLOR_SPACE color_space;
		1008	opj_image_cmptparm_t cmptparm; /* maximum of 1 component */
		1009	opj_image_t * image = NULL;
		1010
		1011	char endian1,endian2,sign;
		1012	char signtmp[32];
		1013
		1014	char temp[32];
		1015	int bigendian;
		1016	opj_image_comp_t *comp = NULL;
		1017
		1018	numcomps = 1;
		1019	color_space = CLRSPC_GRAY;
		1020
		1021	memset(&cmptparm, 0, sizeof(opj_image_cmptparm_t));
		1022
		1023	max = 0;
		1024
		1025	f = fopen(filename, "rb");
		1026	if (!f) {
		1027	fprintf(stderr, "Failed to open %s for reading !\n", filename);
		1028	return NULL;
		1029	}
		1030
		1031	fseek(f, 0, SEEK_SET);
		1032	fscanf(f, "PG%[ \t]%c%c%[ \t+-]%d%[ \t]%d%[ \t]%d",temp,&endian1,&endian2,signtmp,&prec,temp,&w,temp,&h);
		1033
		1034	i=0;
		1035	sign='+';
		1036	while (signtmp[i]!='\0') {
		1037	if (signtmp[i]=='-') sign='-';
		1038	i++;
		1039	}
		1040
		1041	fgetc(f);
		1042	if (endian1=='M' && endian2=='L') {
		1043	bigendian = 1;
		1044	} else if (endian2=='M' && endian1=='L') {
		1045	bigendian = 0;
		1046	} else {
		1047	fprintf(stderr, "Bad pgx header, please check input file\n");
		1048	return NULL;
		1049	}
		1050
		1051	/* initialize image component */
		1052
		1053	cmptparm.x0 = parameters->image_offset_x0;
		1054	cmptparm.y0 = parameters->image_offset_y0;
		1055	cmptparm.w = !cmptparm.x0 ? (w - 1) * parameters->subsampling_dx + 1 : cmptparm.x0 + (w - 1) * parameters->subsampling_dx + 1;
		1056	cmptparm.h = !cmptparm.y0 ? (h - 1) * parameters->subsampling_dy + 1 : cmptparm.y0 + (h - 1) * parameters->subsampling_dy + 1;
		1057
		1058	if (sign == '-') {
		1059	cmptparm.sgnd = 1;
		1060	} else {
		1061	cmptparm.sgnd = 0;
		1062	}
		1063	cmptparm.prec = prec;
		1064	cmptparm.bpp = prec;
		1065	cmptparm.dx = parameters->subsampling_dx;
		1066	cmptparm.dy = parameters->subsampling_dy;
		1067
		1068	/* create the image */
		1069	image = opj_image_create(numcomps, &cmptparm, color_space);
		1070	if(!image) {
		1071	fclose(f);
		1072	return NULL;
		1073	}
		1074	/* set image offset and reference grid */
		1075	image->x0 = cmptparm.x0;
		1076	image->y0 = cmptparm.x0;
		1077	image->x1 = cmptparm.w;
		1078	image->y1 = cmptparm.h;
		1079
		1080	/* set image data */
		1081
		1082	comp = &image->comps[0];
		1083
		1084	for (i = 0; i < w * h; i++) {
		1085	int v;
		1086	if (comp->prec <= 8) {
		1087	if (!comp->sgnd) {
		1088	v = readuchar(f);
		1089	} else {
		1090	v = (char) readuchar(f);
		1091	}
		1092	} else if (comp->prec <= 16) {
		1093	if (!comp->sgnd) {
		1094	v = readushort(f, bigendian);
		1095	} else {
		1096	v = (short) readushort(f, bigendian);
		1097	}
		1098	} else {
		1099	if (!comp->sgnd) {
		1100	v = readuint(f, bigendian);
		1101	} else {
		1102	v = (int) readuint(f, bigendian);
		1103	}
		1104	}
		1105	if (v > max)
		1106	max = v;
		1107	comp->data[i] = v;
		1108	}
		1109	fclose(f);
		1110	comp->bpp = int_floorlog2(max) + 1;
		1111
		1112	return image;
		1113	}
		1114
		1115	int imagetopgx(opj_image_t * image, const char *outfile) {
		1116	int w, h;
		1117	int i, j, compno;
		1118	FILE *fdest = NULL;
		1119
		1120	for (compno = 0; compno < image->numcomps; compno++) {
		1121	opj_image_comp_t *comp = &image->comps[compno];
		1122	char bname[256]; /* buffer for name */
		1123	char name = bname; / pointer */
		1124	int nbytes = 0;
		1125	const size_t olen = strlen(outfile);
		1126	const size_t dotpos = olen - 4;
		1127	const size_t total = dotpos + 1 + 1 + 4; /* '-' + '[1-3]' + '.pgx' */
		1128	if( outfile[dotpos] != '.' ) {
		1129	/* `pgx` was recognized but there is no dot at expected position */
		1130	fprintf(stderr, "ERROR -> Impossible happen." );
		1131	return 1;
		1132	}
		1133	if( total > 256 ) {
		1134	name = (char*)malloc(total+1);
		1135	}
		1136	strncpy(name, outfile, dotpos);
		1137	if (image->numcomps > 1) {
		1138	sprintf(name+dotpos, "-%d.pgx", compno);
		1139	} else {
		1140	strcpy(name+dotpos, ".pgx");
		1141	}
		1142	fdest = fopen(name, "wb");
		1143	if (!fdest) {
		1144	fprintf(stderr, "ERROR -> failed to open %s for writing\n", name);
		1145	return 1;
		1146	}
		1147	/* dont need name anymore */
		1148	if( total > 256 ) {
		1149	free(name);
		1150	}
		1151
		1152	w = image->comps[compno].w;
		1153	h = image->comps[compno].h;
		1154
		1155	fprintf(fdest, "PG ML %c %d %d %d\n", comp->sgnd ? '-' : '+', comp->prec, w, h);
		1156	if (comp->prec <= 8) {
		1157	nbytes = 1;
		1158	} else if (comp->prec <= 16) {
		1159	nbytes = 2;
		1160	} else {
		1161	nbytes = 4;
		1162	}
		1163	for (i = 0; i < w * h; i++) {
		1164	int v = image->comps[compno].data[i];
		1165	for (j = nbytes - 1; j >= 0; j--) {
		1166	char byte = (char) (v >> (j * 8));
		1167	fwrite(&byte, 1, 1, fdest);
		1168	}
		1169	}
		1170	fclose(fdest);
		1171	}
		1172
		1173	return 0;
		1174	}
		1175
		1176	/* -->> -->> -->> -->>
		1177
		1178	PNM IMAGE FORMAT
		1179
		1180	<<-- <<-- <<-- <<-- */
		1181
		1182	opj_image_t* pnmtoimage(const char filename, opj_cparameters_t parameters) {
		1183	int subsampling_dx = parameters->subsampling_dx;
		1184	int subsampling_dy = parameters->subsampling_dy;
		1185
		1186	FILE *f = NULL;
		1187	int i, compno, numcomps, w, h;
		1188	OPJ_COLOR_SPACE color_space;
		1189	opj_image_cmptparm_t cmptparm[3]; /* maximum of 3 components */
		1190	opj_image_t * image = NULL;
		1191	char value;
		1192
		1193	f = fopen(filename, "rb");
		1194	if (!f) {
		1195	fprintf(stderr, "Failed to open %s for reading !!\n", filename);
		1196	return 0;
		1197	}
		1198
		1199	if (fgetc(f) != 'P')
		1200	return 0;
		1201	value = fgetc(f);
		1202
		1203	switch(value) {
		1204	case '2': /* greyscale image type */
		1205	case '5':
		1206	numcomps = 1;
		1207	color_space = CLRSPC_GRAY;
		1208	break;
		1209
		1210	case '3': /* RGB image type */
		1211	case '6':
		1212	numcomps = 3;
		1213	color_space = CLRSPC_SRGB;
		1214	break;
		1215
		1216	default:
		1217	fclose(f);
		1218	return NULL;
		1219	}
		1220
		1221	fgetc(f);
		1222
		1223	/* skip comments */
		1224	while(fgetc(f) == '#') while(fgetc(f) != '\n');
		1225
		1226	fseek(f, -1, SEEK_CUR);
		1227	fscanf(f, "%d %d\n255", &w, &h);
		1228	fgetc(f); /* */
		1229
		1230	/* initialize image components */
		1231	memset(&cmptparm[0], 0, 3 * sizeof(opj_image_cmptparm_t));
		1232	for(i = 0; i < numcomps; i++) {
		1233	cmptparm[i].prec = 8;
		1234	cmptparm[i].bpp = 8;
		1235	cmptparm[i].sgnd = 0;
		1236	cmptparm[i].dx = subsampling_dx;
		1237	cmptparm[i].dy = subsampling_dy;
		1238	cmptparm[i].w = w;
		1239	cmptparm[i].h = h;
		1240	}
		1241	/* create the image */
		1242	image = opj_image_create(numcomps, &cmptparm[0], color_space);
		1243	if(!image) {
		1244	fclose(f);
		1245	return NULL;
		1246	}
		1247
		1248	/* set image offset and reference grid */
		1249	image->x0 = parameters->image_offset_x0;
		1250	image->y0 = parameters->image_offset_y0;
		1251	image->x1 = parameters->image_offset_x0 + (w - 1) * subsampling_dx + 1;
		1252	image->y1 = parameters->image_offset_y0 + (h - 1) * subsampling_dy + 1;
		1253
		1254	/* set image data */
		1255
		1256	if ((value == '2') \|\| (value == '3')) { /* ASCII */
		1257	for (i = 0; i < w * h; i++) {
		1258	for(compno = 0; compno < numcomps; compno++) {
		1259	unsigned int index = 0;
		1260	fscanf(f, "%u", &index);
		1261	/* compno : 0 = GREY, (0, 1, 2) = (R, G, B) */
		1262	image->comps[compno].data[i] = index;
		1263	}
		1264	}
		1265	} else if ((value == '5') \|\| (value == '6')) { /* BINARY */
		1266	for (i = 0; i < w * h; i++) {
		1267	for(compno = 0; compno < numcomps; compno++) {
		1268	unsigned char index = 0;
		1269	fread(&index, 1, 1, f);
		1270	/* compno : 0 = GREY, (0, 1, 2) = (R, G, B) */
		1271	image->comps[compno].data[i] = index;
		1272	}
		1273	}
		1274	}
		1275
		1276	fclose(f);
		1277
		1278	return image;
		1279	}
		1280
		1281	int imagetopnm(opj_image_t * image, const char *outfile) {
		1282	int w, wr, h, hr, max;
		1283	int i, compno;
		1284	int adjustR, adjustG, adjustB, adjustX;
		1285	FILE *fdest = NULL;
		1286	char S2;
		1287	const char *tmp = outfile;
		1288
		1289	while (*tmp) {
		1290	tmp++;
		1291	}
		1292	tmp--;
		1293	tmp--;
		1294	S2 = *tmp;
		1295
		1296	if (image->numcomps == 3 && image->comps[0].dx == image->comps[1].dx
		1297	&& image->comps[1].dx == image->comps[2].dx
		1298	&& image->comps[0].dy == image->comps[1].dy
		1299	&& image->comps[1].dy == image->comps[2].dy
		1300	&& image->comps[0].prec == image->comps[1].prec
		1301	&& image->comps[1].prec == image->comps[2].prec
		1302	&& S2 !='g' && S2 !='G') {
		1303
		1304	fdest = fopen(outfile, "wb");
		1305	if (!fdest) {
		1306	fprintf(stderr, "ERROR -> failed to open %s for writing\n", outfile);
		1307	return 1;
		1308	}
		1309
		1310	w = int_ceildiv(image->x1 - image->x0, image->comps[0].dx);
		1311	wr = image->comps[0].w;
		1312
		1313	h = int_ceildiv(image->y1 - image->y0, image->comps[0].dy);
		1314	hr = image->comps[0].h;
		1315
		1316	max = image->comps[0].prec > 8 ? 255 : (1 << image->comps[0].prec) - 1;
		1317
		1318	image->comps[0].x0 = int_ceildivpow2(image->comps[0].x0 - int_ceildiv(image->x0, image->comps[0].dx), image->comps[0].factor);
		1319	image->comps[0].y0 = int_ceildivpow2(image->comps[0].y0 - int_ceildiv(image->y0, image->comps[0].dy), image->comps[0].factor);
		1320
		1321	fprintf(fdest, "P6\n%d %d\n%d\n", wr, hr, max);
		1322
		1323	if (image->comps[0].prec > 8) {
		1324	adjustR = image->comps[0].prec - 8;
		1325	printf("PNM CONVERSION: Truncating component 0 from %d bits to 8 bits\n", image->comps[0].prec);
		1326	}
		1327	else
		1328	adjustR = 0;
		1329	if (image->comps[1].prec > 8) {
		1330	adjustG = image->comps[1].prec - 8;
		1331	printf("PNM CONVERSION: Truncating component 1 from %d bits to 8 bits\n", image->comps[1].prec);
		1332	}
		1333	else
		1334	adjustG = 0;
		1335	if (image->comps[2].prec > 8) {
		1336	adjustB = image->comps[2].prec - 8;
		1337	printf("PNM CONVERSION: Truncating component 2 from %d bits to 8 bits\n", image->comps[2].prec);
		1338	}
		1339	else
		1340	adjustB = 0;
		1341
		1342
		1343	for (i = 0; i < wr * hr; i++) {
		1344	int r, g, b;
		1345	unsigned char rc,gc,bc;
		1346	r = image->comps[0].data[i];
		1347	r += (image->comps[0].sgnd ? 1 << (image->comps[0].prec - 1) : 0);
		1348	rc = (unsigned char) ((r >> adjustR)+((r >> (adjustR-1))%2));
		1349
		1350	g = image->comps[1].data[i];
		1351	g += (image->comps[1].sgnd ? 1 << (image->comps[1].prec - 1) : 0);
		1352	gc = (unsigned char) ((g >> adjustG)+((g >> (adjustG-1))%2));
		1353
		1354	b = image->comps[2].data[i];
		1355	b += (image->comps[2].sgnd ? 1 << (image->comps[2].prec - 1) : 0);
		1356	bc = (unsigned char) ((b >> adjustB)+((b >> (adjustB-1))%2));
		1357
		1358	fprintf(fdest, "%c%c%c", rc, gc, bc);
		1359	}
		1360	fclose(fdest);
		1361
		1362	} else {
		1363	int ncomp=(S2=='g' \|\| S2=='G')?1:image->numcomps;
		1364	if (image->numcomps > ncomp) {
		1365	fprintf(stderr,"WARNING -> [PGM files] Only the first component\n");
		1366	fprintf(stderr," is written to the file\n");
		1367	}
		1368	for (compno = 0; compno < ncomp; compno++) {
		1369	char name[256];
		1370	if (ncomp > 1) {
		1371	sprintf(name, "%d.%s", compno, outfile);
		1372	} else {
		1373	sprintf(name, "%s", outfile);
		1374	}
		1375
		1376	fdest = fopen(name, "wb");
		1377	if (!fdest) {
		1378	fprintf(stderr, "ERROR -> failed to open %s for writing\n", name);
		1379	return 1;
		1380	}
		1381
		1382	w = int_ceildiv(image->x1 - image->x0, image->comps[compno].dx);
		1383	wr = image->comps[compno].w;
		1384
		1385	h = int_ceildiv(image->y1 - image->y0, image->comps[compno].dy);
		1386	hr = image->comps[compno].h;
		1387
		1388	max = image->comps[compno].prec > 8 ? 255 : (1 << image->comps[compno].prec) - 1;
		1389
		1390	image->comps[compno].x0 = int_ceildivpow2(image->comps[compno].x0 - int_ceildiv(image->x0, image->comps[compno].dx), image->comps[compno].factor);
		1391	image->comps[compno].y0 = int_ceildivpow2(image->comps[compno].y0 - int_ceildiv(image->y0, image->comps[compno].dy), image->comps[compno].factor);
		1392
		1393	fprintf(fdest, "P5\n%d %d\n%d\n", wr, hr, max);
		1394
		1395	if (image->comps[compno].prec > 8) {
		1396	adjustX = image->comps[0].prec - 8;
		1397	printf("PNM CONVERSION: Truncating component %d from %d bits to 8 bits\n",compno, image->comps[compno].prec);
		1398	}
		1399	else
		1400	adjustX = 0;
		1401
		1402	for (i = 0; i < wr * hr; i++) {
		1403	int l;
		1404	unsigned char lc;
		1405	l = image->comps[compno].data[i];
		1406	l += (image->comps[compno].sgnd ? 1 << (image->comps[compno].prec - 1) : 0);
		1407	lc = (unsigned char) ((l >> adjustX)+((l >> (adjustX-1))%2));
		1408	fprintf(fdest, "%c", lc);
		1409	}
		1410	fclose(fdest);
		1411	}
		1412	}
		1413
		1414	return 0;
		1415	}
		1416
		1417	#ifdef HAVE_LIBTIFF
		1418	/* -->> -->> -->> -->>
		1419
		1420	TIFF IMAGE FORMAT
		1421
		1422	<<-- <<-- <<-- <<-- */
		1423
		1424	typedef struct tiff_infoheader{
		1425	DWORD tiWidth; // Width of Image in pixel
		1426	DWORD tiHeight; // Height of Image in pixel
		1427	DWORD tiPhoto; // Photometric
		1428	WORD tiBps; // Bits per sample
		1429	WORD tiSf; // Sample Format
		1430	WORD tiSpp; // Sample per pixel 1-bilevel,gray scale , 2- RGB
		1431	WORD tiPC; // Planar config (1-Interleaved, 2-Planarcomp)
		1432	}tiff_infoheader_t;
		1433
		1434	int imagetotif(opj_image_t * image, const char *outfile) {
		1435	int width, height, imgsize;
		1436	int bps,index,adjust = 0;
		1437	int last_i=0;
		1438	TIFF *tif;
		1439	tdata_t buf;
		1440	tstrip_t strip;
		1441	tsize_t strip_size;
		1442
		1443	if (image->numcomps == 3 && image->comps[0].dx == image->comps[1].dx
		1444	&& image->comps[1].dx == image->comps[2].dx
		1445	&& image->comps[0].dy == image->comps[1].dy
		1446	&& image->comps[1].dy == image->comps[2].dy
		1447	&& image->comps[0].prec == image->comps[1].prec
		1448	&& image->comps[1].prec == image->comps[2].prec) {
		1449
		1450	/* -->> -->> -->>
		1451	RGB color
		1452	<<-- <<-- <<-- */
		1453
		1454	tif = TIFFOpen(outfile, "wb");
		1455	if (!tif) {
		1456	fprintf(stderr, "ERROR -> failed to open %s for writing\n", outfile);
		1457	return 1;
		1458	}
		1459
		1460	width = image->comps[0].w;
		1461	height = image->comps[0].h;
		1462	imgsize = width * height ;
		1463	bps = image->comps[0].prec;
		1464	/* Set tags */
		1465	TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width);
		1466	TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height);
		1467	TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 3);
		1468	TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bps);
		1469	TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
		1470	TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
		1471	TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
		1472	TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, 1);
		1473
		1474	/* Get a buffer for the data */
		1475	strip_size=TIFFStripSize(tif);
		1476	buf = _TIFFmalloc(strip_size);
		1477	index=0;
		1478	adjust = image->comps[0].sgnd ? 1 << (image->comps[0].prec - 1) : 0;
		1479	for (strip = 0; strip < TIFFNumberOfStrips(tif); strip++) {
		1480	unsigned char *dat8;
		1481	tsize_t i, ssize;
		1482	ssize = TIFFStripSize(tif);
		1483	dat8 = (unsigned char*)buf;
		1484	if (image->comps[0].prec == 8){
		1485	for (i=0; i
		1486	int r = 0,g = 0,b = 0;
		1487	if(index < imgsize){
		1488	r = image->comps[0].data[index];
		1489	g = image->comps[1].data[index];
		1490	b = image->comps[2].data[index];
		1491	if (image->comps[0].sgnd){
		1492	r += adjust;
		1493	g += adjust;
		1494	b += adjust;
		1495	}
		1496	dat8[i+0] = r ; // R
		1497	dat8[i+1] = g ; // G
		1498	dat8[i+2] = b ; // B
		1499	index++;
		1500	last_i = i+3;
		1501	}else
		1502	break;
		1503	}
		1504	if(last_i < ssize){
		1505	for (i=last_i; i
		1506	int r = 0,g = 0,b = 0;
		1507	if(index < imgsize){
		1508	r = image->comps[0].data[index];
		1509	g = image->comps[1].data[index];
		1510	b = image->comps[2].data[index];
		1511	if (image->comps[0].sgnd){
		1512	r += adjust;
		1513	g += adjust;
		1514	b += adjust;
		1515	}
		1516	dat8[i+0] = r ; // R
		1517	if(i+1
		1518	if(i+2
		1519	index++;
		1520	}else
		1521	break;
		1522	}
		1523	}
		1524	}else if (image->comps[0].prec == 12){
		1525	for (i=0; i
		1526	int r = 0,g = 0,b = 0;
		1527	int r1 = 0,g1 = 0,b1 = 0;
		1528	if((index < imgsize)&(index+1 < imgsize)){
		1529	r = image->comps[0].data[index];
		1530	g = image->comps[1].data[index];
		1531	b = image->comps[2].data[index];
		1532	r1 = image->comps[0].data[index+1];
		1533	g1 = image->comps[1].data[index+1];
		1534	b1 = image->comps[2].data[index+1];
		1535	if (image->comps[0].sgnd){
		1536	r += adjust;
		1537	g += adjust;
		1538	b += adjust;
		1539	r1 += adjust;
		1540	g1 += adjust;
		1541	b1 += adjust;
		1542	}
		1543	dat8[i+0] = (r >> 4);
		1544	dat8[i+1] = ((r & 0x0f) << 4 )\|((g >> 8)& 0x0f);
		1545	dat8[i+2] = g ;
		1546	dat8[i+3] = (b >> 4);
		1547	dat8[i+4] = ((b & 0x0f) << 4 )\|((r1 >> 8)& 0x0f);
		1548	dat8[i+5] = r1;
		1549	dat8[i+6] = (g1 >> 4);
		1550	dat8[i+7] = ((g1 & 0x0f)<< 4 )\|((b1 >> 8)& 0x0f);
		1551	dat8[i+8] = b1;
		1552	index+=2;
		1553	last_i = i+9;
		1554	}else
		1555	break;
		1556	}
		1557	if(last_i < ssize){
		1558	for (i= last_i; i
		1559	int r = 0,g = 0,b = 0;
		1560	int r1 = 0,g1 = 0,b1 = 0;
		1561	if((index < imgsize)&(index+1 < imgsize)){
		1562	r = image->comps[0].data[index];
		1563	g = image->comps[1].data[index];
		1564	b = image->comps[2].data[index];
		1565	r1 = image->comps[0].data[index+1];
		1566	g1 = image->comps[1].data[index+1];
		1567	b1 = image->comps[2].data[index+1];
		1568	if (image->comps[0].sgnd){
		1569	r += adjust;
		1570	g += adjust;
		1571	b += adjust;
		1572	r1 += adjust;
		1573	g1 += adjust;
		1574	b1 += adjust;
		1575	}
		1576	dat8[i+0] = (r >> 4);
		1577	if(i+1 > 8)& 0x0f); else break;
		1578	if(i+2
		1579	if(i+3 > 4); else break;
		1580	if(i+4 > 8)& 0x0f);else break;
		1581	if(i+5
		1582	if(i+6 > 4); else break;
		1583	if(i+7 > 8)& 0x0f);else break;
		1584	if(i+8
		1585	index+=2;
		1586	}else
		1587	break;
		1588	}
		1589	}
		1590	}else if (image->comps[0].prec == 16){
		1591	for (i=0 ; i
		1592	int r = 0,g = 0,b = 0;
		1593	if(index < imgsize){
		1594	r = image->comps[0].data[index];
		1595	g = image->comps[1].data[index];
		1596	b = image->comps[2].data[index];
		1597	if (image->comps[0].sgnd){
		1598	r += adjust;
		1599	g += adjust;
		1600	b += adjust;
		1601	}
		1602	dat8[i+0] = r;//LSB
		1603	dat8[i+1] = (r >> 8);//MSB
		1604	dat8[i+2] = g;
		1605	dat8[i+3] = (g >> 8);
		1606	dat8[i+4] = b;
		1607	dat8[i+5] = (b >> 8);
		1608	index++;
		1609	last_i = i+6;
		1610	}else
		1611	break;
		1612	}
		1613	if(last_i < ssize){
		1614	for (i=0 ; i
		1615	int r = 0,g = 0,b = 0;
		1616	if(index < imgsize){
		1617	r = image->comps[0].data[index];
		1618	g = image->comps[1].data[index];
		1619	b = image->comps[2].data[index];
		1620	if (image->comps[0].sgnd){
		1621	r += adjust;
		1622	g += adjust;
		1623	b += adjust;
		1624	}
		1625	dat8[i+0] = r;//LSB
		1626	if(i+1 > 8);else break;//MSB
		1627	if(i+2
		1628	if(i+3 > 8);else break;
		1629	if(i+4
		1630	if(i+5 > 8);else break;
		1631	index++;
		1632	}else
		1633	break;
		1634	}
		1635	}
		1636	}else{
		1637	fprintf(stderr,"Bits=%d, Only 8,12,16 bits implemented\n",image->comps[0].prec);
		1638	fprintf(stderr,"Aborting\n");
		1639	return 1;
		1640	}
		1641	(void)TIFFWriteEncodedStrip(tif, strip, (void*)buf, strip_size);
		1642	}
		1643	_TIFFfree((void*)buf);
		1644	TIFFClose(tif);
		1645	}else if (image->numcomps == 1){
		1646	/* -->> -->> -->>
		1647	Black and White
		1648	<<-- <<-- <<-- */
		1649
		1650	tif = TIFFOpen(outfile, "wb");
		1651	if (!tif) {
		1652	fprintf(stderr, "ERROR -> failed to open %s for writing\n", outfile);
		1653	return 1;
		1654	}
		1655
		1656	width = image->comps[0].w;
		1657	height = image->comps[0].h;
		1658	imgsize = width * height;
		1659	bps = image->comps[0].prec;
		1660
		1661	/* Set tags */
		1662	TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width);
		1663	TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height);
		1664	TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 1);
		1665	TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bps);
		1666	TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
		1667	TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
		1668	TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
		1669	TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, 1);
		1670
		1671	/* Get a buffer for the data */
		1672	strip_size = TIFFStripSize(tif);
		1673	buf = _TIFFmalloc(strip_size);
		1674	index = 0;
		1675	for (strip = 0; strip < TIFFNumberOfStrips(tif); strip++) {
		1676	unsigned char *dat8;
		1677	tsize_t i;
		1678	dat8 = (unsigned char*)buf;
		1679	if (image->comps[0].prec == 8){
		1680	for (i=0; i
		1681	if(index < imgsize){
		1682	int r = 0;
		1683	r = image->comps[0].data[index];
		1684	if (image->comps[0].sgnd){
		1685	r += adjust;
		1686	}
		1687	dat8[i+0] = r;
		1688	index++;
		1689	}else
		1690	break;
		1691	}
		1692	}else if (image->comps[0].prec == 12){
		1693	for (i = 0; i
		1694	if(index < imgsize){
		1695	int r = 0, r1 = 0;
		1696	r = image->comps[0].data[index];
		1697	r1 = image->comps[0].data[index+1];
		1698	if (image->comps[0].sgnd){
		1699	r += adjust;
		1700	r1 += adjust;
		1701	}
		1702	dat8[i+0] = (r >> 4);
		1703	dat8[i+1] = ((r & 0x0f) << 4 )\|((r1 >> 8)& 0x0f);
		1704	dat8[i+2] = r1 ;
		1705	index+=2;
		1706	}else
		1707	break;
		1708	}
		1709	}else if (image->comps[0].prec == 16){
		1710	for (i=0; i
		1711	if(index < imgsize){
		1712	int r = 0;
		1713	r = image->comps[0].data[index];
		1714	if (image->comps[0].sgnd){
		1715	r += adjust;
		1716	}
		1717	dat8[i+0] = r;
		1718	dat8[i+1] = r >> 8;
		1719	index++;
		1720	}else
		1721	break;
		1722	}
		1723	}else{
		1724	fprintf(stderr,"TIFF file creation. Bits=%d, Only 8,12,16 bits implemented\n",image->comps[0].prec);
		1725	fprintf(stderr,"Aborting\n");
		1726	return 1;
		1727	}
		1728	(void)TIFFWriteEncodedStrip(tif, strip, (void*)buf, strip_size);
		1729	}
		1730	_TIFFfree(buf);
		1731	TIFFClose(tif);
		1732	}else{
		1733	fprintf(stderr,"TIFF file creation. Bad color format. Only RGB & Grayscale has been implemented\n");
		1734	fprintf(stderr,"Aborting\n");
		1735	return 1;
		1736	}
		1737	return 0;
		1738	}
		1739
		1740	opj_image_t* tiftoimage(const char filename, opj_cparameters_t parameters)
		1741	{
		1742	int subsampling_dx = parameters->subsampling_dx;
		1743	int subsampling_dy = parameters->subsampling_dy;
		1744	TIFF *tif;
		1745	tiff_infoheader_t Info;
		1746	tdata_t buf;
		1747	tstrip_t strip;
		1748	tsize_t strip_size;
		1749	int j, numcomps, w, h,index;
		1750	OPJ_COLOR_SPACE color_space;
		1751	opj_image_cmptparm_t cmptparm[3];
		1752	opj_image_t * image = NULL;
		1753	int imgsize = 0;
		1754
		1755	tif = TIFFOpen(filename, "r");
		1756
		1757	if (!tif) {
		1758	fprintf(stderr, "Failed to open %s for reading\n", filename);
		1759	return 0;
		1760	}
		1761
		1762	TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &Info.tiWidth);
		1763	TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &Info.tiHeight);
		1764	TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, &Info.tiBps);
		1765	TIFFGetField(tif, TIFFTAG_SAMPLEFORMAT, &Info.tiSf);
		1766	TIFFGetField(tif, TIFFTAG_SAMPLESPERPIXEL, &Info.tiSpp);
		1767	Info.tiPhoto = 0;
		1768	TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &Info.tiPhoto);
		1769	TIFFGetField(tif, TIFFTAG_PLANARCONFIG, &Info.tiPC);
		1770	w= Info.tiWidth;
		1771	h= Info.tiHeight;
		1772
		1773	if (Info.tiPhoto == 2) {
		1774	/* -->> -->> -->>
		1775	RGB color
		1776	<<-- <<-- <<-- */
		1777
		1778	numcomps = 3;
		1779	color_space = CLRSPC_SRGB;
		1780	/* initialize image components*/
		1781	memset(&cmptparm[0], 0, 3 * sizeof(opj_image_cmptparm_t));
		1782	for(j = 0; j < numcomps; j++) {
		1783	if (parameters->cp_cinema) {
		1784	cmptparm[j].prec = 12;
		1785	cmptparm[j].bpp = 12;
		1786	}else{
		1787	cmptparm[j].prec = Info.tiBps;
		1788	cmptparm[j].bpp = Info.tiBps;
		1789	}
		1790	cmptparm[j].sgnd = 0;
		1791	cmptparm[j].dx = subsampling_dx;
		1792	cmptparm[j].dy = subsampling_dy;
		1793	cmptparm[j].w = w;
		1794	cmptparm[j].h = h;
		1795	}
		1796	/* create the image*/
		1797	image = opj_image_create(numcomps, &cmptparm[0], color_space);
		1798	if(!image) {
		1799	TIFFClose(tif);
		1800	return NULL;
		1801	}
		1802
		1803	/* set image offset and reference grid */
		1804	image->x0 = parameters->image_offset_x0;
		1805	image->y0 = parameters->image_offset_y0;
		1806	image->x1 = !image->x0 ? (w - 1) * subsampling_dx + 1 : image->x0 + (w - 1) * subsampling_dx + 1;
		1807	image->y1 = !image->y0 ? (h - 1) * subsampling_dy + 1 : image->y0 + (h - 1) * subsampling_dy + 1;
		1808
		1809	buf = _TIFFmalloc(TIFFStripSize(tif));
		1810	strip_size=0;
		1811	strip_size=TIFFStripSize(tif);
		1812	index = 0;
		1813	imgsize = image->comps[0].w * image->comps[0].h ;
		1814	/* Read the Image components*/
		1815	for (strip = 0; strip < TIFFNumberOfStrips(tif); strip++) {
		1816	unsigned char *dat8;
		1817	int i, ssize;
		1818	ssize = TIFFReadEncodedStrip(tif, strip, buf, strip_size);
		1819	dat8 = (unsigned char*)buf;
		1820
		1821	if (Info.tiBps==12){
		1822	for (i=0; i
		1823	if((index < imgsize)&(index+1 < imgsize)){
		1824	image->comps[0].data[index] = ( dat8[i+0]<<4 ) \|(dat8[i+1]>>4);
		1825	image->comps[1].data[index] = ((dat8[i+1]& 0x0f)<< 8) \| dat8[i+2];
		1826	image->comps[2].data[index] = ( dat8[i+3]<<4) \|(dat8[i+4]>>4);
		1827	image->comps[0].data[index+1] = ((dat8[i+4]& 0x0f)<< 8) \| dat8[i+5];
		1828	image->comps[1].data[index+1] = ( dat8[i+6] <<4) \|(dat8[i+7]>>4);
		1829	image->comps[2].data[index+1] = ((dat8[i+7]& 0x0f)<< 8) \| dat8[i+8];
		1830	index+=2;
		1831	}else
		1832	break;
		1833	}
		1834	}
		1835	else if( Info.tiBps==16){
		1836	for (i=0; i
		1837	if(index < imgsize){
		1838	image->comps[0].data[index] = ( dat8[i+1] << 8 ) \| dat8[i+0]; // R
		1839	image->comps[1].data[index] = ( dat8[i+3] << 8 ) \| dat8[i+2]; // G
		1840	image->comps[2].data[index] = ( dat8[i+5] << 8 ) \| dat8[i+4]; // B
		1841	if(parameters->cp_cinema){/* Rounding to 12 bits*/
		1842	image->comps[0].data[index] = (image->comps[0].data[index] + 0x08) >> 4 ;
		1843	image->comps[1].data[index] = (image->comps[1].data[index] + 0x08) >> 4 ;
		1844	image->comps[2].data[index] = (image->comps[2].data[index] + 0x08) >> 4 ;
		1845	}
		1846	index++;
		1847	}else
		1848	break;
		1849	}
		1850	}
		1851	else if ( Info.tiBps==8){
		1852	for (i=0; i
		1853	if(index < imgsize){
		1854	image->comps[0].data[index] = dat8[i+0];// R
		1855	image->comps[1].data[index] = dat8[i+1];// G
		1856	image->comps[2].data[index] = dat8[i+2];// B
		1857	if(parameters->cp_cinema){/* Rounding to 12 bits*/
		1858	image->comps[0].data[index] = image->comps[0].data[index] << 4 ;
		1859	image->comps[1].data[index] = image->comps[1].data[index] << 4 ;
		1860	image->comps[2].data[index] = image->comps[2].data[index] << 4 ;
		1861	}
		1862	index++;
		1863	}else
		1864	break;
		1865	}
		1866	}
		1867	else{
		1868	fprintf(stderr,"TIFF file creation. Bits=%d, Only 8,12,16 bits implemented\n",Info.tiBps);
		1869	fprintf(stderr,"Aborting\n");
		1870	return NULL;
		1871	}
		1872	}
		1873
		1874	_TIFFfree(buf);
		1875	TIFFClose(tif);
		1876	}else if(Info.tiPhoto == 1) {
		1877	/* -->> -->> -->>
		1878	Black and White
		1879	<<-- <<-- <<-- */
		1880
		1881	numcomps = 1;
		1882	color_space = CLRSPC_GRAY;
		1883	/* initialize image components*/
		1884	memset(&cmptparm[0], 0, sizeof(opj_image_cmptparm_t));
		1885	cmptparm[0].prec = Info.tiBps;
		1886	cmptparm[0].bpp = Info.tiBps;
		1887	cmptparm[0].sgnd = 0;
		1888	cmptparm[0].dx = subsampling_dx;
		1889	cmptparm[0].dy = subsampling_dy;
		1890	cmptparm[0].w = w;
		1891	cmptparm[0].h = h;
		1892
		1893	/* create the image*/
		1894	image = opj_image_create(numcomps, &cmptparm[0], color_space);
		1895	if(!image) {
		1896	TIFFClose(tif);
		1897	return NULL;
		1898	}
		1899	/* set image offset and reference grid */
		1900	image->x0 = parameters->image_offset_x0;
		1901	image->y0 = parameters->image_offset_y0;
		1902	image->x1 = !image->x0 ? (w - 1) * subsampling_dx + 1 : image->x0 + (w - 1) * subsampling_dx + 1;
		1903	image->y1 = !image->y0 ? (h - 1) * subsampling_dy + 1 : image->y0 + (h - 1) * subsampling_dy + 1;
		1904
		1905	buf = _TIFFmalloc(TIFFStripSize(tif));
		1906	strip_size = 0;
		1907	strip_size = TIFFStripSize(tif);
		1908	index = 0;
		1909	imgsize = image->comps[0].w * image->comps[0].h ;
		1910	/* Read the Image components*/
		1911	for (strip = 0; strip < TIFFNumberOfStrips(tif); strip++) {
		1912	unsigned char *dat8;
		1913	int i, ssize;
		1914	ssize = TIFFReadEncodedStrip(tif, strip, buf, strip_size);
		1915	dat8 = (unsigned char*)buf;
		1916
		1917	if (Info.tiBps==12){
		1918	for (i=0; i
		1919	if(index < imgsize){
		1920	image->comps[0].data[index] = ( dat8[i+0]<<4 ) \|(dat8[i+1]>>4) ;
		1921	image->comps[0].data[index+1] = ((dat8[i+1]& 0x0f)<< 8) \| dat8[i+2];
		1922	index+=2;
		1923	}else
		1924	break;
		1925	}
		1926	}
		1927	else if( Info.tiBps==16){
		1928	for (i=0; i
		1929	if(index < imgsize){
		1930	image->comps[0].data[index] = ( dat8[i+1] << 8 ) \| dat8[i+0];
		1931	index++;
		1932	}else
		1933	break;
		1934	}
		1935	}
		1936	else if ( Info.tiBps==8){
		1937	for (i=0; i
		1938	if(index < imgsize){
		1939	image->comps[0].data[index] = dat8[i+0];
		1940	index++;
		1941	}else
		1942	break;
		1943	}
		1944	}
		1945	else{
		1946	fprintf(stderr,"TIFF file creation. Bits=%d, Only 8,12,16 bits implemented\n",Info.tiBps);
		1947	fprintf(stderr,"Aborting\n");
		1948	return NULL;
		1949	}
		1950	}
		1951
		1952	_TIFFfree(buf);
		1953	TIFFClose(tif);
		1954	}else{
		1955	fprintf(stderr,"TIFF file creation. Bad color format. Only RGB & Grayscale has been implemented\n");
		1956	fprintf(stderr,"Aborting\n");
		1957	return NULL;
		1958	}
		1959	return image;
		1960	}
		1961
		1962	#endif /* HAVE_LIBTIFF */
		1963
		1964	/* -->> -->> -->> -->>
		1965
		1966	RAW IMAGE FORMAT
		1967
		1968	<<-- <<-- <<-- <<-- */
		1969
		1970	opj_image_t* rawtoimage(const char filename, opj_cparameters_t parameters, raw_cparameters_t *raw_cp) {
		1971	int subsampling_dx = parameters->subsampling_dx;
		1972	int subsampling_dy = parameters->subsampling_dy;
		1973
		1974	FILE *f = NULL;
		1975	int i, compno, numcomps, w, h;
		1976	OPJ_COLOR_SPACE color_space;
		1977	opj_image_cmptparm_t *cmptparm;
		1978	opj_image_t * image = NULL;
		1979	unsigned short ch;
		1980
		1981	if((! (raw_cp->rawWidth & raw_cp->rawHeight & raw_cp->rawComp & raw_cp->rawBitDepth)) == 0)
		1982	{
		1983	fprintf(stderr,"\nError: invalid raw image parameters\n");
		1984	fprintf(stderr,"Please use the Format option -F:\n");
		1985	fprintf(stderr,"-F rawWidth,rawHeight,rawComp,rawBitDepth,s/u (Signed/Unsigned)\n");
		1986	fprintf(stderr,"Example: -i lena.raw -o lena.j2k -F 512,512,3,8,u\n");
		1987	fprintf(stderr,"Aborting\n");
		1988	return NULL;
		1989	}
		1990
		1991	f = fopen(filename, "rb");
		1992	if (!f) {
		1993	fprintf(stderr, "Failed to open %s for reading !!\n", filename);
		1994	fprintf(stderr,"Aborting\n");
		1995	return NULL;
		1996	}
		1997	numcomps = raw_cp->rawComp;
		1998	color_space = CLRSPC_SRGB;
		1999	w = raw_cp->rawWidth;
		2000	h = raw_cp->rawHeight;
		2001	cmptparm = (opj_image_cmptparm_t) malloc(numcomps sizeof(opj_image_cmptparm_t));
		2002
		2003	/* initialize image components */
		2004	memset(&cmptparm[0], 0, numcomps * sizeof(opj_image_cmptparm_t));
		2005	for(i = 0; i < numcomps; i++) {
		2006	cmptparm[i].prec = raw_cp->rawBitDepth;
		2007	cmptparm[i].bpp = raw_cp->rawBitDepth;
		2008	cmptparm[i].sgnd = raw_cp->rawSigned;
		2009	cmptparm[i].dx = subsampling_dx;
		2010	cmptparm[i].dy = subsampling_dy;
		2011	cmptparm[i].w = w;
		2012	cmptparm[i].h = h;
		2013	}
		2014	/* create the image */
		2015	image = opj_image_create(numcomps, &cmptparm[0], color_space);
		2016	if(!image) {
		2017	fclose(f);
		2018	return NULL;
		2019	}
		2020	/* set image offset and reference grid */
		2021	image->x0 = parameters->image_offset_x0;
		2022	image->y0 = parameters->image_offset_y0;
		2023	image->x1 = parameters->image_offset_x0 + (w - 1) * subsampling_dx + 1;
		2024	image->y1 = parameters->image_offset_y0 + (h - 1) * subsampling_dy + 1;
		2025
		2026	if(raw_cp->rawBitDepth <= 8)
		2027	{
		2028	unsigned char value = 0;
		2029	for(compno = 0; compno < numcomps; compno++) {
		2030	for (i = 0; i < w * h; i++) {
		2031	if (!fread(&value, 1, 1, f)) {
		2032	fprintf(stderr,"Error reading raw file. End of file probably reached.\n");
		2033	return NULL;
		2034	}
		2035	image->comps[compno].data[i] = raw_cp->rawSigned?(char)value:value;
		2036	}
		2037	}
		2038	}
		2039	else if(raw_cp->rawBitDepth <= 16)
		2040	{
		2041	unsigned short value;
		2042	for(compno = 0; compno < numcomps; compno++) {
		2043	for (i = 0; i < w * h; i++) {
		2044	unsigned char temp;
		2045	if (!fread(&temp, 1, 1, f)) {
		2046	fprintf(stderr,"Error reading raw file. End of file probably reached.\n");
		2047	return NULL;
		2048	}
		2049	value = temp << 8;
		2050	if (!fread(&temp, 1, 1, f)) {
		2051	fprintf(stderr,"Error reading raw file. End of file probably reached.\n");
		2052	return NULL;
		2053	}
		2054	value += temp;
		2055	image->comps[compno].data[i] = raw_cp->rawSigned?(short)value:value;
		2056	}
		2057	}
		2058	}
		2059	else {
		2060	fprintf(stderr,"OpenJPEG cannot encode raw components with bit depth higher than 16 bits.\n");
		2061	return NULL;
		2062	}
		2063
		2064	if (fread(&ch, 1, 1, f)) {
		2065	fprintf(stderr,"Warning. End of raw file not reached... processing anyway\n");
		2066	}
		2067	fclose(f);
		2068
		2069	return image;
		2070	}
		2071
		2072	int imagetoraw(opj_image_t * image, const char *outfile)
		2073	{
		2074	FILE *rawFile = NULL;
		2075	int compno;
		2076	int w, h;
		2077	int line, row;
		2078	int *ptr;
		2079
		2080	if((image->numcomps * image->x1 * image->y1) == 0)
		2081	{
		2082	fprintf(stderr,"\nError: invalid raw image parameters\n");
		2083	return 1;
		2084	}
		2085
		2086	rawFile = fopen(outfile, "wb");
		2087	if (!rawFile) {
		2088	fprintf(stderr, "Failed to open %s for writing !!\n", outfile);
		2089	return 1;
		2090	}
		2091
		2092	fprintf(stdout,"Raw image characteristics: %d components\n", image->numcomps);
		2093
		2094	for(compno = 0; compno < image->numcomps; compno++)
		2095	{
		2096	fprintf(stdout,"Component %d characteristics: %dx%dx%d %s\n", compno, image->comps[compno].w,
		2097	image->comps[compno].h, image->comps[compno].prec, image->comps[compno].sgnd==1 ? "signed": "unsigned");
		2098
		2099	w = image->comps[compno].w;
		2100	h = image->comps[compno].h;
		2101
		2102	if(image->comps[compno].prec <= 8)
		2103	{
		2104	if(image->comps[compno].sgnd == 1)
		2105	{
		2106	signed char curr;
		2107	int mask = (1 << image->comps[compno].prec) - 1;
		2108	ptr = image->comps[compno].data;
		2109	for (line = 0; line < h; line++) {
		2110	for(row = 0; row < w; row++) {
		2111	curr = (signed char) (*ptr & mask);
		2112	fwrite(&curr, sizeof(signed char), 1, rawFile);
		2113	ptr++;
		2114	}
		2115	}
		2116	}
		2117	else if(image->comps[compno].sgnd == 0)
		2118	{
		2119	unsigned char curr;
		2120	int mask = (1 << image->comps[compno].prec) - 1;
		2121	ptr = image->comps[compno].data;
		2122	for (line = 0; line < h; line++) {
		2123	for(row = 0; row < w; row++) {
		2124	curr = (unsigned char) (*ptr & mask);
		2125	fwrite(&curr, sizeof(unsigned char), 1, rawFile);
		2126	ptr++;
		2127	}
		2128	}
		2129	}
		2130	}
		2131	else if(image->comps[compno].prec <= 16)
		2132	{
		2133	if(image->comps[compno].sgnd == 1)
		2134	{
		2135	signed short int curr;
		2136	int mask = (1 << image->comps[compno].prec) - 1;
		2137	ptr = image->comps[compno].data;
		2138	for (line = 0; line < h; line++) {
		2139	for(row = 0; row < w; row++) {
		2140	unsigned char temp;
		2141	curr = (signed short int) (*ptr & mask);
		2142	temp = (unsigned char) (curr >> 8);
		2143	fwrite(&temp, 1, 1, rawFile);
		2144	temp = (unsigned char) curr;
		2145	fwrite(&temp, 1, 1, rawFile);
		2146	ptr++;
		2147	}
		2148	}
		2149	}
		2150	else if(image->comps[compno].sgnd == 0)
		2151	{
		2152	unsigned short int curr;
		2153	int mask = (1 << image->comps[compno].prec) - 1;
		2154	ptr = image->comps[compno].data;
		2155	for (line = 0; line < h; line++) {
		2156	for(row = 0; row < w; row++) {
		2157	unsigned char temp;
		2158	curr = (unsigned short int) (*ptr & mask);
		2159	temp = (unsigned char) (curr >> 8);
		2160	fwrite(&temp, 1, 1, rawFile);
		2161	temp = (unsigned char) curr;
		2162	fwrite(&temp, 1, 1, rawFile);
		2163	ptr++;
		2164	}
		2165	}
		2166	}
		2167	}
		2168	else if (image->comps[compno].prec <= 32)
		2169	{
		2170	fprintf(stderr,"More than 16 bits per component no handled yet\n");
		2171	return 1;
		2172	}
		2173	else
		2174	{
		2175	fprintf(stderr,"Error: invalid precision: %d\n", image->comps[compno].prec);
		2176	return 1;
		2177	}
		2178	}
		2179	fclose(rawFile);
		2180	return 0;
		2181	}
		2182
		2183	#ifdef HAVE_LIBPNG
		2184
		2185	#define PNG_MAGIC "\x89PNG\x0d\x0a\x1a\x0a"
		2186	#define MAGIC_SIZE 8
		2187	/* PNG allows bits per sample: 1, 2, 4, 8, 16 */
		2188
		2189	opj_image_t pngtoimage(const char read_idf, opj_cparameters_t * params)
		2190	{
		2191	png_structp png;
		2192	png_infop info;
		2193	double gamma, display_exponent;
		2194	int bit_depth, interlace_type,compression_type, filter_type;
		2195	int unit;
		2196	png_uint_32 resx, resy;
		2197	unsigned int i, j;
		2198	png_uint_32 width, height;
		2199	int color_type, has_alpha, is16;
		2200	unsigned char *s;
		2201	FILE *reader;
		2202	unsigned char **rows;
		2203	/* j2k: */
		2204	opj_image_t *image;
		2205	opj_image_cmptparm_t cmptparm[4];
		2206	int sub_dx, sub_dy;
		2207	unsigned int nr_comp;
		2208	int r, g, b, a;
		2209	unsigned char sigbuf[8];
		2210
		2211	if((reader = fopen(read_idf, "rb")) == NULL)
		2212	{
		2213	fprintf(stderr,"pngtoimage: can not open %s\n",read_idf);
		2214	return NULL;
		2215	}
		2216	image = NULL; png = NULL; rows = NULL;
		2217
		2218	if(fread(sigbuf, 1, MAGIC_SIZE, reader) != MAGIC_SIZE
		2219	\|\| memcmp(sigbuf, PNG_MAGIC, MAGIC_SIZE) != 0)
		2220	{
		2221	fprintf(stderr,"pngtoimage: %s is no valid PNG file\n",read_idf);
		2222	goto fin;
		2223	}
		2224	/* libpng-VERSION/example.c:
		2225	* PC : screen_gamma = 2.2;
		2226	* Mac: screen_gamma = 1.7 or 1.0;
		2227	*/
		2228	display_exponent = 2.2;
		2229
		2230	if((png = png_create_read_struct(PNG_LIBPNG_VER_STRING,
		2231	NULL, NULL, NULL)) == NULL)
		2232	goto fin;
		2233	if((info = png_create_info_struct(png)) == NULL)
		2234	goto fin;
		2235
		2236	if(setjmp(png_jmpbuf(png)))
		2237	goto fin;
		2238
		2239	png_init_io(png, reader);
		2240	png_set_sig_bytes(png, MAGIC_SIZE);
		2241
		2242	png_read_info(png, info);
		2243
		2244	if(png_get_IHDR(png, info, &width, &height,
		2245	&bit_depth, &color_type, &interlace_type,
		2246	&compression_type, &filter_type) == 0)
		2247	goto fin;
		2248
		2249	/* png_set_expand():
		2250	* expand paletted images to RGB, expand grayscale images of
		2251	* less than 8-bit depth to 8-bit depth, and expand tRNS chunks
		2252	* to alpha channels.
		2253	*/
		2254	if(color_type == PNG_COLOR_TYPE_PALETTE)
		2255	png_set_expand(png);
		2256	else
		2257	if(color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
		2258	png_set_expand(png);
		2259
		2260	if(png_get_valid(png, info, PNG_INFO_tRNS))
		2261	png_set_expand(png);
		2262
		2263	is16 = (bit_depth == 16);
		2264
		2265	/* GRAY => RGB; GRAY_ALPHA => RGBA
		2266	*/
		2267	if(color_type == PNG_COLOR_TYPE_GRAY
		2268	\|\| color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
		2269	{
		2270	png_set_gray_to_rgb(png);
		2271	color_type =
		2272	(color_type == PNG_COLOR_TYPE_GRAY? PNG_COLOR_TYPE_RGB:
		2273	PNG_COLOR_TYPE_RGB_ALPHA);
		2274	}
		2275	if( !png_get_gAMA(png, info, &gamma))
		2276	gamma = 0.45455;
		2277
		2278	png_set_gamma(png, display_exponent, gamma);
		2279
		2280	png_read_update_info(png, info);
		2281
		2282	png_get_pHYs(png, info, &resx, &resy, &unit);
		2283
		2284	color_type = png_get_color_type(png, info);
		2285
		2286	has_alpha = (color_type == PNG_COLOR_TYPE_RGB_ALPHA);
		2287
		2288	nr_comp = 3 + has_alpha;
		2289
		2290	bit_depth = png_get_bit_depth(png, info);
		2291
		2292	rows = (unsigned char*)calloc(height+1, sizeof(unsigned char));
		2293	for(i = 0; i < height; ++i)
		2294	rows[i] = (unsigned char*)malloc(png_get_rowbytes(png,info));
		2295
		2296	png_read_image(png, rows);
		2297
		2298	memset(&cmptparm, 0, 4 * sizeof(opj_image_cmptparm_t));
		2299
		2300	sub_dx = params->subsampling_dx; sub_dy = params->subsampling_dy;
		2301
		2302	for(i = 0; i < nr_comp; ++i)
		2303	{
		2304	cmptparm[i].prec = bit_depth;
		2305	/* bits_per_pixel: 8 or 16 */
		2306	cmptparm[i].bpp = bit_depth;
		2307	cmptparm[i].sgnd = 0;
		2308	cmptparm[i].dx = sub_dx;
		2309	cmptparm[i].dy = sub_dy;
		2310	cmptparm[i].w = width;
		2311	cmptparm[i].h = height;
		2312	}
		2313
		2314	image = opj_image_create(nr_comp, &cmptparm[0], CLRSPC_SRGB);
		2315
		2316	if(image == NULL) goto fin;
		2317
		2318	image->x0 = params->image_offset_x0;
		2319	image->y0 = params->image_offset_y0;
		2320	image->x1 = image->x0 + (width - 1) * sub_dx + 1 + image->x0;
		2321	image->y1 = image->y0 + (height - 1) * sub_dy + 1 + image->y0;
		2322
		2323	r = image->comps[0].data;
		2324	g = image->comps[1].data;
		2325	b = image->comps[2].data;
		2326	a = image->comps[3].data;
		2327
		2328	for(i = 0; i < height; ++i)
		2329	{
		2330	s = rows[i];
		2331
		2332	for(j = 0; j < width; ++j)
		2333	{
		2334	if(is16)
		2335	{
		2336	*r++ = s[0]<<8\|s[1]; s += 2;
		2337
		2338	*g++ = s[0]<<8\|s[1]; s += 2;
		2339
		2340	*b++ = s[0]<<8\|s[1]; s += 2;
		2341
		2342	if(has_alpha) { *a++ = s[0]<<8\|s[1]; s += 2; }
		2343
		2344	continue;
		2345	}
		2346	r++ = s++; g++ = s++; b++ = s++;
		2347
		2348	if(has_alpha) a++ = s++;
		2349	}
		2350	}
		2351	fin:
		2352	if(rows)
		2353	{
		2354	for(i = 0; i < height; ++i)
		2355	free(rows[i]);
		2356	free(rows);
		2357	}
		2358	if(png)
		2359	png_destroy_read_struct(&png, &info, NULL);
		2360
		2361	fclose(reader);
		2362
		2363	return image;
		2364
		2365	}/* pngtoimage() */
		2366
		2367	int imagetopng(opj_image_t * image, const char *write_idf)
		2368	{
		2369	FILE *writer;
		2370	png_structp png;
		2371	png_infop info;
		2372	int red, green, blue, alpha;
		2373	unsigned char row_buf, d;
		2374	int has_alpha, width, height, nr_comp, color_type;
		2375	int adjustR, adjustG, adjustB, x, y, fails, is16, force16;
		2376	int opj_prec, prec, ushift, dshift;
		2377	unsigned short mask = 0xffff;
		2378	png_color_8 sig_bit;
		2379
		2380	is16 = force16 = ushift = dshift = 0; fails = 1;
		2381	prec = opj_prec = image->comps[0].prec;
		2382
		2383	if(prec > 8 && prec < 16)
		2384	{
		2385	prec = 16; force16 = 1;
		2386	}
		2387	if(prec != 1 && prec != 2 && prec != 4 && prec != 8 && prec != 16)
		2388	{
		2389	fprintf(stderr,"imagetopng: can not create %s"
		2390	"\n\twrong bit_depth %d\n", write_idf, prec);
		2391	return fails;
		2392	}
		2393	writer = fopen(write_idf, "wb");
		2394
		2395	if(writer == NULL) return fails;
		2396
		2397	info = NULL; has_alpha = 0;
		2398
		2399	/* Create and initialize the png_struct with the desired error handler
		2400	* functions. If you want to use the default stderr and longjump method,
		2401	* you can supply NULL for the last three parameters. We also check that
		2402	* the library version is compatible with the one used at compile time,
		2403	* in case we are using dynamically linked libraries. REQUIRED.
		2404	*/
		2405	png = png_create_write_struct(PNG_LIBPNG_VER_STRING,
		2406	NULL, NULL, NULL);
		2407	/png_voidp user_error_ptr, user_error_fn, user_warning_fn); /
		2408
		2409	if(png == NULL) goto fin;
		2410
		2411	/* Allocate/initialize the image information data. REQUIRED
		2412	*/
		2413	info = png_create_info_struct(png);
		2414
		2415	if(info == NULL) goto fin;
		2416
		2417	/* Set error handling. REQUIRED if you are not supplying your own
		2418	* error handling functions in the png_create_write_struct() call.
		2419	*/
		2420	if(setjmp(png_jmpbuf(png))) goto fin;
		2421
		2422	/* I/O initialization functions is REQUIRED
		2423	*/
		2424	png_init_io(png, writer);
		2425
		2426	/* Set the image information here. Width and height are up to 2^31,
		2427	* bit_depth is one of 1, 2, 4, 8, or 16, but valid values also depend on
		2428	* the color_type selected. color_type is one of PNG_COLOR_TYPE_GRAY,
		2429	* PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB,
		2430	* or PNG_COLOR_TYPE_RGB_ALPHA. interlace is either PNG_INTERLACE_NONE or
		2431	* PNG_INTERLACE_ADAM7, and the compression_type and filter_type MUST
		2432	* currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE.
		2433	* REQUIRED
		2434	*/
		2435	png_set_compression_level(png, Z_BEST_COMPRESSION);
		2436
		2437	if(prec == 16) mask = 0xffff;
		2438	else
		2439	if(prec == 8) mask = 0x00ff;
		2440	else
		2441	if(prec == 4) mask = 0x000f;
		2442	else
		2443	if(prec == 2) mask = 0x0003;
		2444	else
		2445	if(prec == 1) mask = 0x0001;
		2446
		2447	nr_comp = image->numcomps;
		2448
		2449	if(nr_comp >= 3
		2450	&& image->comps[0].dx == image->comps[1].dx
		2451	&& image->comps[1].dx == image->comps[2].dx
		2452	&& image->comps[0].dy == image->comps[1].dy
		2453	&& image->comps[1].dy == image->comps[2].dy
		2454	&& image->comps[0].prec == image->comps[1].prec
		2455	&& image->comps[1].prec == image->comps[2].prec)
		2456	{
		2457	int v;
		2458
		2459	has_alpha = (nr_comp > 3);
		2460
		2461	is16 = (prec == 16);
		2462
		2463	width = image->comps[0].w;
		2464	height = image->comps[0].h;
		2465
		2466	red = image->comps[0].data;
		2467	green = image->comps[1].data;
		2468	blue = image->comps[2].data;
		2469
		2470	sig_bit.red = sig_bit.green = sig_bit.blue = prec;
		2471
		2472	if(has_alpha)
		2473	{
		2474	sig_bit.alpha = prec;
		2475	alpha = image->comps[3].data;
		2476	color_type = PNG_COLOR_TYPE_RGB_ALPHA;
		2477	}
		2478	else
		2479	{
		2480	sig_bit.alpha = 0; alpha = NULL;
		2481	color_type = PNG_COLOR_TYPE_RGB;
		2482	}
		2483	png_set_sBIT(png, info, &sig_bit);
		2484
		2485	png_set_IHDR(png, info, width, height, prec,
		2486	color_type,
		2487	PNG_INTERLACE_NONE,
		2488	PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
		2489
		2490	/=============================/
		2491	png_write_info(png, info);
		2492	/=============================/
		2493	if(opj_prec < 8)
		2494	{
		2495	png_set_packing(png);
		2496	}
		2497	if(force16)
		2498	{
		2499	ushift = 16 - opj_prec; dshift = opj_prec - ushift;
		2500	}
		2501	adjustR = (image->comps[0].sgnd ? 1 << (image->comps[0].prec - 1) : 0);
		2502	adjustG = (image->comps[1].sgnd ? 1 << (image->comps[1].prec - 1) : 0);
		2503	adjustB = (image->comps[2].sgnd ? 1 << (image->comps[2].prec - 1) : 0);
		2504
		2505	row_buf = (unsigned char)malloc(width nr_comp * 2);
		2506
		2507	for(y = 0; y < height; ++y)
		2508	{
		2509	d = row_buf;
		2510
		2511	for(x = 0; x < width; ++x)
		2512	{
		2513	if(is16)
		2514	{
		2515	/* Network byte order */
		2516	v = *red + adjustR; ++red;
		2517
		2518	if(force16) { v = (v<>dshift); }
		2519
		2520	d++ = (unsigned char)(v>>8); d++ = (unsigned char)v;
		2521
		2522	v = *green + adjustG; ++green;
		2523
		2524	if(force16) { v = (v<>dshift); }
		2525
		2526	d++ = (unsigned char)(v>>8); d++ = (unsigned char)v;
		2527
		2528	v = *blue + adjustB; ++blue;
		2529
		2530	if(force16) { v = (v<>dshift); }
		2531
		2532	d++ = (unsigned char)(v>>8); d++ = (unsigned char)v;
		2533
		2534	if(has_alpha)
		2535	{
		2536	v = *alpha++;
		2537
		2538	if(force16) { v = (v<>dshift); }
		2539
		2540	d++ = (unsigned char)(v>>8); d++ = (unsigned char)v;
		2541	}
		2542	continue;
		2543	}
		2544	d++ = (unsigned char)((red + adjustR) & mask); ++red;
		2545	d++ = (unsigned char)((green + adjustG) & mask); ++green;
		2546	d++ = (unsigned char)((blue + adjustB) & mask); ++blue;
		2547
		2548	if(has_alpha)
		2549	{
		2550	d++ = (unsigned char)(alpha & mask); ++alpha;
		2551	}
		2552	} /* for(x) */
		2553
		2554	png_write_row(png, row_buf);
		2555
		2556	} /* for(y) */
		2557	free(row_buf);
		2558
		2559	}/* nr_comp >= 3 */
		2560	else
		2561	if(nr_comp == 1 /* GRAY */
		2562	\|\| ( nr_comp == 2 /* GRAY_ALPHA */
		2563	&& image->comps[0].dx == image->comps[1].dx
		2564	&& image->comps[0].dy == image->comps[1].dy
		2565	&& image->comps[0].prec == image->comps[1].prec))
		2566	{
		2567	int v;
		2568
		2569	red = image->comps[0].data;
		2570
		2571	if(force16)
		2572	{
		2573	ushift = 16 - opj_prec; dshift = opj_prec - ushift;
		2574	}
		2575
		2576	sig_bit.gray = prec;
		2577	sig_bit.red = sig_bit.green = sig_bit.blue = sig_bit.alpha = 0;
		2578	alpha = NULL;
		2579	color_type = PNG_COLOR_TYPE_GRAY;
		2580
		2581	if(nr_comp == 2)
		2582	{
		2583	has_alpha = 1; sig_bit.alpha = prec;
		2584	alpha = image->comps[1].data;
		2585	color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
		2586	}
		2587	width = image->comps[0].w;
		2588	height = image->comps[0].h;
		2589
		2590	png_set_IHDR(png, info, width, height, sig_bit.gray,
		2591	color_type,
		2592	PNG_INTERLACE_NONE,
		2593	PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
		2594
		2595	png_set_sBIT(png, info, &sig_bit);
		2596	/=============================/
		2597	png_write_info(png, info);
		2598	/=============================/
		2599	adjustR = (image->comps[0].sgnd ? 1 << (image->comps[0].prec - 1) : 0);
		2600
		2601	if(opj_prec < 8)
		2602	{
		2603	png_set_packing(png);
		2604	}
		2605
		2606	if(prec > 8)
		2607	{
		2608	/* Network byte order */
		2609
		2610
		2611	row_buf = (unsigned char*)
		2612	malloc(width * nr_comp * sizeof(unsigned short));
		2613
		2614	for(y = 0; y < height; ++y)
		2615	{
		2616	d = row_buf;
		2617
		2618	for(x = 0; x < width; ++x)
		2619	{
		2620	v = *red + adjustR; ++red;
		2621
		2622	if(force16) { v = (v<>dshift); }
		2623
		2624	d++ = (unsigned char)(v>>8); d++ = (unsigned char)(v & 0xff);
		2625
		2626	if(has_alpha)
		2627	{
		2628	v = *alpha++;
		2629
		2630	if(force16) { v = (v<>dshift); }
		2631
		2632	d++ = (unsigned char)(v>>8); d++ = (unsigned char)(v & 0xff);
		2633	}
		2634	}/* for(x) */
		2635	png_write_row(png, row_buf);
		2636
		2637	} /* for(y) */
		2638	free(row_buf);
		2639	}
		2640	else /* prec <= 8 */
		2641	{
		2642	row_buf = (unsigned char)calloc(width, nr_comp 2);
		2643
		2644	for(y = 0; y < height; ++y)
		2645	{
		2646	d = row_buf;
		2647
		2648	for(x = 0; x < width; ++x)
		2649	{
		2650	d++ = (unsigned char)((red + adjustR) & mask); ++red;
		2651
		2652	if(has_alpha)
		2653	{
		2654	d++ = (unsigned char)(alpha & mask); ++alpha;
		2655	}
		2656	}/* for(x) */
		2657
		2658	png_write_row(png, row_buf);
		2659
		2660	} /* for(y) */
		2661	free(row_buf);
		2662	}
		2663	}
		2664	else
		2665	{
		2666	fprintf(stderr,"imagetopng: can not create %s\n",write_idf);
		2667	goto fin;
		2668	}
		2669	png_write_end(png, info);
		2670
		2671	fails = 0;
		2672
		2673	fin:
		2674
		2675	if(png)
		2676	{
		2677	png_destroy_write_struct(&png, &info);
		2678	}
		2679	fclose(writer);
		2680
		2681	if(fails) remove(write_idf);
		2682
		2683	return fails;
		2684	}/* imagetopng() */
		2685	#endif /* HAVE_LIBPNG */
		2686

Subversion Repositories Kolibri OS

(root)/contrib/menuetlibc/openjpeg/codec/convert.c – Rev 4758