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

Rev	Author	Line No.	Line
4758	right-hear	1	/*
		2	* Copyright (c) 2001-2003, David Janssens
		3	* Copyright (c) 2002-2003, Yannick Verschueren
		4	* Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
		5	* Copyright (c) 2005, Herv� Drolon, FreeImage Team
		6	* Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
		7	* Copyright (c) 2006, M�nica D�ez Garc�a, Image Processing Laboratory, University of Valladolid, Spain
		8	* All rights reserved.
		9	*
		10	* Redistribution and use in source and binary forms, with or without
		11	* modification, are permitted provided that the following conditions
		12	* are met:
		13	* 1. Redistributions of source code must retain the above copyright
		14	* notice, this list of conditions and the following disclaimer.
		15	* 2. Redistributions in binary form must reproduce the above copyright
		16	* notice, this list of conditions and the following disclaimer in the
		17	* documentation and/or other materials provided with the distribution.
		18	*
		19	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
		20	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		21	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
		22	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
		23	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
		24	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
		25	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
		26	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
		27	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
		28	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
		29	* POSSIBILITY OF SUCH DAMAGE.
		30	*/
		31	#include
		32	#include
		33	#include
		34	#include "../libjp3dvm/openjpeg3d.h"
		35	#ifdef _WIN32
		36	#include "windirent.h"
		37	#else
		38	#include
		39	#endif /* _WIN32 */
		40
		41
		42
		43	void dump_volume(FILE fd, opj_volume_t vol) {
		44	int compno;
		45	fprintf(fd, "volume {\n");
		46	fprintf(fd, " x0=%d, y0=%d, z0=%d, x1=%d, y1=%d, z1=%d\n", vol->x0, vol->y0, vol->z0,vol->x1, vol->y1, vol->z1);
		47	fprintf(fd, " numcomps=%d\n", vol->numcomps);
		48	for (compno = 0; compno < vol->numcomps; compno++) {
		49	opj_volume_comp_t *comp = &vol->comps[compno];
		50	fprintf(fd, " comp %d {\n", compno);
		51	fprintf(fd, " dx=%d, dy=%d, dz=%d\n", comp->dx, comp->dy, comp->dz);
		52	fprintf(fd, " prec=%d\n", comp->prec);
		53	fprintf(fd, " sgnd=%d\n", comp->sgnd);
		54	fprintf(fd, " }\n");
		55	}
		56	fprintf(fd, "}\n");
		57	}
		58
		59	/*
		60	* Get logarithm of an integer and round downwards.
		61	*
		62	* log2(a)
		63	*/
		64	static int int_floorlog2(int a) {
		65	int l;
		66	for (l = 0; a > 1; l++) {
		67	a >>= 1;
		68	}
		69	return l;
		70	}
		71
		72	/*
		73	* Divide an integer by a power of 2 and round upwards.
		74	*
		75	* a divided by 2^b
		76	*/
		77	static int int_ceildivpow2(int a, int b) {
		78	return (a + (1 << b) - 1) >> b;
		79	}
		80
		81	/*
		82	* Divide an integer and round upwards.
		83	*
		84	* a divided by b
		85	*/
		86	static int int_ceildiv(int a, int b) {
		87	return (a + b - 1) / b;
		88	}
		89
		90
		91	/* -->> -->> -->> -->>
		92
		93	PGX IMAGE FORMAT
		94
		95	<<-- <<-- <<-- <<-- */
		96
		97
		98	unsigned char readuchar(FILE * f)
		99	{
		100	unsigned char c1;
		101	fread(&c1, 1, 1, f);
		102	return c1;
		103	}
		104
		105	unsigned short readushort(FILE * f, int bigendian)
		106	{
		107	unsigned char c1, c2;
		108	fread(&c1, 1, 1, f);
		109	fread(&c2, 1, 1, f);
		110	if (bigendian)
		111	return (c1 << 8) + c2;
		112	else
		113	return (c2 << 8) + c1;
		114	}
		115
		116	unsigned int readuint(FILE * f, int bigendian)
		117	{
		118	unsigned char c1, c2, c3, c4;
		119	fread(&c1, 1, 1, f);
		120	fread(&c2, 1, 1, f);
		121	fread(&c3, 1, 1, f);
		122	fread(&c4, 1, 1, f);
		123	if (bigendian)
		124	return (c1 << 24) + (c2 << 16) + (c3 << 8) + c4;
		125	else
		126	return (c4 << 24) + (c3 << 16) + (c2 << 8) + c1;
		127	}
		128	/*****************************************/
		129	static unsigned short ShortSwap(unsigned short v)
		130	{
		131	unsigned char c1, c2;
		132	c1 = v & 0xff;
		133	c2 = (v >> 8) & 0xff;
		134	return (c1 << 8) + c2;
		135	}
		136
		137	static unsigned int LongSwap (unsigned int i)
		138	{
		139	unsigned char b1, b2, b3, b4;
		140	b1 = i & 255;
		141	b2 = ( i >> 8 ) & 255;
		142	b3 = ( i>>16 ) & 255;
		143	b4 = ( i>>24 ) & 255;
		144	return ((int)b1 << 24) + ((int)b2 << 16) + ((int)b3 << 8) + b4;
		145	}
		146	/*****************************************/
		147
		148	opj_volume_t* pgxtovolume(char relpath, opj_cparameters_t parameters) {
		149
		150	FILE *f = NULL;
		151	int w, h, prec;
		152	unsigned long offset;
		153	int i, s, numcomps, maxvalue, sliceno, slicepos, maxslice = 0;
		154
		155	OPJ_COLOR_SPACE color_space;
		156	opj_volume_cmptparm_t cmptparm; // maximum of 1 component
		157	opj_volume_t * volume = NULL;
		158
		159	char endian1,endian2,sign;
		160	char signtmp[32];
		161	char temp[32];
		162	opj_volume_comp_t *comp = NULL;
		163
		164	DIR *dirp;
		165	struct dirent *direntp;
		166
		167	char tmp = NULL, tmp2 = NULL,
		168	point = NULL, pgx = NULL;
		169	char tmpdirpath[MAX_PATH];
		170	char dirpath[MAX_PATH];
		171	char pattern[MAX_PATH];
		172	char pgxfiles[MAX_SLICES][MAX_PATH];
		173	int pgxslicepos[MAX_SLICES];
		174	char tmpno[3];
		175
		176	numcomps = 1;
		177	color_space = CLRSPC_GRAY;
		178	sliceno = 0;
		179	maxvalue = 0;
		180	memset(pgxfiles, 0, MAX_SLICES * MAX_PATH * sizeof(char));
		181	memset(&cmptparm, 0, sizeof(opj_volume_cmptparm_t));
		182
		183	/* Separaci�n del caso de un �nico slice frente al de muchos */
		184	if ((tmp = strrchr(relpath,'-')) == NULL){
		185	//fprintf(stdout,"[INFO] A volume of only one slice....\n");
		186	sliceno = 1;
		187	maxslice = 1;
		188	strcpy(pgxfiles[0],relpath);
		189
		190	} else {
		191	//Fetch only the path
		192	strcpy(tmpdirpath,relpath);
		193	if ((tmp = strrchr(tmpdirpath,'/')) != NULL){
		194	tmp++; *tmp='\0';
		195	strcpy(dirpath,tmpdirpath);
		196	} else {
		197	strcpy(dirpath,"./");
		198	}
		199
		200	//Fetch the pattern of the volume slices
		201	if ((tmp = strrchr (relpath,'/')) != NULL)
		202	tmp++;
		203	else
		204	tmp = relpath;
		205	if ((tmp2 = strrchr(tmp,'-')) != NULL)
		206	*tmp2='\0';
		207	else{
		208	fprintf(stdout, "[ERROR] tmp2 ha dado null. no ha encontrado el * %s %s",tmp,relpath);
		209	return NULL;
		210	}
		211	strcpy(pattern,tmp);
		212
		213	dirp = opendir( dirpath );
		214	if (dirp == NULL){
		215	fprintf(stdout, "[ERROR] Infile must be a .pgx file or a directory that contain pgx files");
		216	return NULL;
		217	}
		218
		219	/Read all .pgx files of directory /
		220	while ( (direntp = readdir( dirp )) != NULL )
		221	{
		222	/* Found a directory, but ignore . and .. */
		223	if(strcmp(".",direntp->d_name) == 0 \|\| strcmp("..",direntp->d_name) == 0)
		224	continue;
		225
		226	if( ((pgx = strstr(direntp->d_name,pattern)) != NULL) && ((tmp2 = strstr(direntp->d_name,".pgx")) != NULL) ){
		227
		228	strcpy(tmp,dirpath);
		229	tmp = strcat(tmp,direntp->d_name);
		230
		231	//Obtenemos el index de la secuencia de slices
		232	if ((tmp2 = strpbrk (direntp->d_name, "0123456789")) == NULL)
		233	continue;
		234	i = 0;
		235	while (tmp2 != NULL) {
		236	tmpno[i++] = *tmp2;
		237	point = tmp2;
		238	tmp2 = strpbrk (tmp2+1,"0123456789");
		239	}tmpno[i]='\0';
		240
		241	//Comprobamos que no estamos leyendo algo raro como pattern.jp3d
		242	if ((point = strpbrk (point,".")) == NULL){
		243	break;
		244	}
		245	//Slicepos --> index de slice; Sliceno --> no de slices hasta el momento
		246	slicepos = atoi(tmpno);
		247	pgxslicepos[sliceno] = slicepos - 1;
		248	sliceno++;
		249	if (slicepos>maxslice)
		250	maxslice = slicepos;
		251
		252	//Colocamos el slices en su posicion correspondiente
		253	strcpy(pgxfiles[slicepos-1],tmp);
		254	}
		255	}
		256
		257	}/* else if pattern.pgx /
		258
		259	if (!sliceno) {
		260	fprintf(stdout,"[ERROR] No slices with this pattern founded !! Please check input volume name\n");
		261	return NULL;
		262	}
		263	/*if ( maxslice != sliceno) {
		264	fprintf(stdout,"[ERROR] Slices are not sequentially numbered !! Please rename them accordingly\n");
		265	return NULL;
		266	}*/
		267
		268	for (s=0;s
		269	{
		270	int pos = maxslice == sliceno ? s: pgxslicepos[s];
		271	f = fopen(pgxfiles[pos], "rb");
		272	if (!f) {
		273	fprintf(stdout, "[ERROR] Failed to open %s for reading !\n", pgxfiles[s]);
		274	return NULL;
		275	}
		276	fprintf(stdout, "[INFO] Loading %s \n",pgxfiles[pos]);
		277
		278	fseek(f, 0, SEEK_SET);
		279	fscanf(f, "PG%[ \t]%c%c%[ \t+-]%d%[ \t]%d%[ \t]%d",temp,&endian1,&endian2,signtmp,&prec,temp,&w,temp,&h);
		280
		281	i=0;
		282	sign='+';
		283	while (signtmp[i]!='\0') {
		284	if (signtmp[i]=='-') sign='-';
		285	i++;
		286	}
		287
		288	fgetc(f);
		289	if (endian1=='M' && endian2=='L') {
		290	cmptparm.bigendian = 1;
		291	} else if (endian2=='M' && endian1=='L') {
		292	cmptparm.bigendian = 0;
		293	} else {
		294	fprintf(stdout, "[ERROR] Bad pgx header, please check input file\n");
		295	return NULL;
		296	}
		297
		298	if (s==0){
		299	/* initialize volume component */
		300
		301	cmptparm.x0 = parameters->volume_offset_x0;
		302	cmptparm.y0 = parameters->volume_offset_y0;
		303	cmptparm.z0 = parameters->volume_offset_z0;
		304	cmptparm.w = !cmptparm.x0 ? (w - 1) * parameters->subsampling_dx + 1 : cmptparm.x0 + (w - 1) * parameters->subsampling_dx + 1;
		305	cmptparm.h = !cmptparm.y0 ? (h - 1) * parameters->subsampling_dy + 1 : cmptparm.y0 + (h - 1) * parameters->subsampling_dy + 1;
		306	cmptparm.l = !cmptparm.z0 ? (sliceno - 1) * parameters->subsampling_dz + 1 : cmptparm.z0 + (sliceno - 1) * parameters->subsampling_dz + 1;
		307
		308	if (sign == '-') {
		309	cmptparm.sgnd = 1;
		310	} else {
		311	cmptparm.sgnd = 0;
		312	}
		313	cmptparm.prec = prec;
		314	cmptparm.bpp = prec;
		315	cmptparm.dcoffset = parameters->dcoffset;
		316	cmptparm.dx = parameters->subsampling_dx;
		317	cmptparm.dy = parameters->subsampling_dy;
		318	cmptparm.dz = parameters->subsampling_dz;
		319
		320	/* create the volume */
		321	volume = opj_volume_create(numcomps, &cmptparm, color_space);
		322	if(!volume) {
		323	fclose(f);
		324	return NULL;
		325	}
		326	/* set volume offset and reference grid */
		327	volume->x0 = cmptparm.x0;
		328	volume->y0 = cmptparm.y0;
		329	volume->z0 = cmptparm.z0;
		330	volume->x1 = cmptparm.w;
		331	volume->y1 = cmptparm.h;
		332	volume->z1 = cmptparm.l;
		333
		334	/* set volume data :only one component, that is a volume*/
		335	comp = &volume->comps[0];
		336
		337	}//if sliceno==1
		338
		339	offset = w * h * s;
		340
		341	for (i = 0; i < w * h; i++) {
		342	int v;
		343	if (comp->prec <= 8) {
		344	if (!comp->sgnd) {
		345	v = readuchar(f);
		346	} else {
		347	v = (char) readuchar(f);
		348	}
		349	} else if (comp->prec <= 16) {
		350	if (!comp->sgnd) {
		351	v = readushort(f, cmptparm.bigendian);
		352	} else {
		353	v = (short) readushort(f, cmptparm.bigendian);
		354	}
		355	} else {
		356	if (!comp->sgnd) {
		357	v = readuint(f, cmptparm.bigendian);
		358	} else {
		359	v = (int) readuint(f, cmptparm.bigendian);
		360	}
		361	}
		362	if (v > maxvalue)
		363	maxvalue = v;
		364	comp->data[i + offset] = v;
		365
		366	}
		367	fclose(f);
		368	} // for s --> sliceno
		369	comp->bpp = int_floorlog2(maxvalue) + 1;
		370	if (sliceno != 1)
		371	closedir( dirp );
		372	//dump_volume(stdout, volume);
		373	return volume;
		374	}
		375
		376
		377	int volumetopgx(opj_volume_t * volume, char *outfile) {
		378	int w, wr, wrr, h, hr, hrr, l, lr, lrr;
		379	int i, j, compno, offset, sliceno;
		380	FILE *fdest = NULL;
		381
		382	for (compno = 0; compno < volume->numcomps; compno++) {
		383	opj_volume_comp_t *comp = &volume->comps[compno];
		384	char name[256];
		385	int nbytes = 0;
		386	char *tmp = outfile;
		387	while (*tmp) {
		388	tmp++;
		389	}
		390	while (*tmp!='.') {
		391	tmp--;
		392	}
		393	*tmp='\0';
		394	for(sliceno = 0; sliceno < volume->z1 - volume->z0; sliceno++) {
		395
		396	if (volume->numcomps > 1) {
		397	sprintf(name, "%s%d-%d.pgx", outfile, sliceno+1, compno);
		398	} else if ((volume->z1 - volume->z0) > 1) {
		399	sprintf(name, "%s%d.pgx", outfile, sliceno+1);
		400	} else {
		401	sprintf(name, "%s.pgx", outfile);
		402	}
		403
		404	fdest = fopen(name, "wb");
		405	if (!fdest) {
		406	fprintf(stdout, "[ERROR] Failed to open %s for writing \n", name);
		407	return 1;
		408	}
		409
		410	fprintf(stdout,"[INFO] Writing in %s (%s)\n",name,volume->comps[0].bigendian ? "Bigendian" : "Little-endian");
		411
		412	w = int_ceildiv(volume->x1 - volume->x0, volume->comps[compno].dx);
		413	wr = volume->comps[compno].w;
		414	wrr = int_ceildivpow2(volume->comps[compno].w, volume->comps[compno].factor[0]);
		415
		416	h = int_ceildiv(volume->y1 - volume->y0, volume->comps[compno].dy);
		417	hr = volume->comps[compno].h;
		418	hrr = int_ceildivpow2(volume->comps[compno].h, volume->comps[compno].factor[1]);
		419
		420	l = int_ceildiv(volume->z1 - volume->z0, volume->comps[compno].dz);
		421	lr = volume->comps[compno].l;
		422	lrr = int_ceildivpow2(volume->comps[compno].l, volume->comps[compno].factor[2]);
		423
		424	fprintf(fdest, "PG %c%c %c%d %d %d\n", comp->bigendian ? 'M':'L', comp->bigendian ? 'L':'M',comp->sgnd ? '-' : '+', comp->prec, wr, hr);
		425	if (comp->prec <= 8) {
		426	nbytes = 1;
		427	} else if (comp->prec <= 16) {
		428	nbytes = 2;
		429	} else {
		430	nbytes = 4;
		431	}
		432
		433	offset = (sliceno / lrr * l) + (sliceno % lrr);
		434	offset = wrr * hrr * offset;
		435	//fprintf(stdout,"%d %d %d %d\n",offset,wrr*hrr,wrr,w);
		436	for (i = 0; i < wrr * hrr; i++) {
		437	int v = volume->comps[0].data[(i / wrr * w) + (i % wrr) + offset];
		438	if (volume->comps[0].bigendian) {
		439	for (j = nbytes - 1; j >= 0; j--) {
		440	char byte = (char) ((v >> (j * 8)) & 0xff);
		441	fwrite(&byte, 1, 1, fdest);
		442	}
		443	} else {
		444	for (j = 0; j <= nbytes - 1; j++) {
		445	char byte = (char) ((v >> (j * 8)) & 0xff);
		446	fwrite(&byte, 1, 1, fdest);
		447	}
		448	}
		449	}
		450
		451	fclose(fdest);
		452	}//for sliceno
		453	}//for compno
		454
		455	return 0;
		456	}
		457
		458	/* -->> -->> -->> -->>
		459
		460	BIN IMAGE FORMAT
		461
		462	<<-- <<-- <<-- <<-- */
		463
		464	opj_volume_t* bintovolume(char filename, char fileimg, opj_cparameters_t *parameters) {
		465	int subsampling_dx = parameters->subsampling_dx;
		466	int subsampling_dy = parameters->subsampling_dy;
		467	int subsampling_dz = parameters->subsampling_dz;
		468
		469	int i, compno, w, h, l, numcomps = 1;
		470	int prec, max = 0;
		471
		472	// char temp[32];
		473	char line[100];
		474	int bigendian;
		475
		476	FILE *f = NULL;
		477	FILE *fimg = NULL;
		478	OPJ_COLOR_SPACE color_space;
		479	opj_volume_cmptparm_t cmptparm; /* maximum of 1 component */
		480	opj_volume_t * volume = NULL;
		481	opj_volume_comp_t *comp = NULL;
		482
		483	bigendian = 0;
		484	color_space = CLRSPC_GRAY;
		485
		486	fimg = fopen(fileimg,"r");
		487	if (!fimg) {
		488	fprintf(stdout, "[ERROR] Failed to open %s for reading !!\n", fileimg);
		489	return 0;
		490	}
		491
		492	fseek(fimg, 0, SEEK_SET);
		493	while (!feof(fimg)) {
		494	fgets(line,100,fimg);
		495	//fprintf(stdout,"%s %d \n",line,feof(fimg));
		496	if (strncmp(line,"Bpp",3) == 0){
		497	sscanf(line,"%s%[ \t]%d",&prec);
		498	} else if (strncmp(line,"Color",5) == 0){
		499	sscanf(line, "%s%[ \t]%d",&color_space);
		500	} else if (strncmp(line,"Dim",3) == 0){
		501	sscanf(line, "%s%[ \t]%d%[ \t]%d%[ \t]%d",&w,&h,&l);
		502	}
		503	}
		504	//fscanf(fimg, "Bpp%[ \t]%d%[ \t\n]",temp,&prec,temp);
		505	//fscanf(fimg, "Color Map%[ \t]%d%[ \n\t]Dimensions%[ \t]%d%[ \t]%d%[ \t]%d%[ \n\t]",temp,&color_space,temp,temp,&w,temp,&h,temp,&l,temp);
		506	//fscanf(fimg, "Resolution(mm)%[ \t]%d%[ \t]%d%[ \t]%d%[ \n\t]",temp,&subsampling_dx,temp,&subsampling_dy,temp,&subsampling_dz,temp);
		507
		508	#ifdef VERBOSE
		509	fprintf(stdout, "[INFO] %d \t %d %d %d \t %3.2f %2.2f %2.2f \t %d \n",color_space,w,h,l,subsampling_dx,subsampling_dy,subsampling_dz,prec);
		510	#endif
		511	fclose(fimg);
		512
		513	/* initialize volume components */
		514	memset(&cmptparm, 0, sizeof(opj_volume_cmptparm_t));
		515
		516	cmptparm.prec = prec;
		517	cmptparm.bpp = prec;
		518	cmptparm.sgnd = 0;
		519	cmptparm.bigendian = bigendian;
		520	cmptparm.dcoffset = parameters->dcoffset;
		521	cmptparm.dx = subsampling_dx;
		522	cmptparm.dy = subsampling_dy;
		523	cmptparm.dz = subsampling_dz;
		524	cmptparm.w = w;
		525	cmptparm.h = h;
		526	cmptparm.l = l;
		527
		528	/* create the volume */
		529	volume = opj_volume_create(numcomps, &cmptparm, color_space);
		530	if(!volume) {
		531	fprintf(stdout,"[ERROR] Unable to create volume");
		532	fclose(f);
		533	return NULL;
		534	}
		535
		536	/* set volume offset and reference grid */
		537	volume->x0 = parameters->volume_offset_x0;
		538	volume->y0 = parameters->volume_offset_y0;
		539	volume->z0 = parameters->volume_offset_z0;
		540	volume->x1 = parameters->volume_offset_x0 + (w - 1) * subsampling_dx + 1;
		541	volume->y1 = parameters->volume_offset_y0 + (h - 1) * subsampling_dy + 1;
		542	volume->z1 = parameters->volume_offset_z0 + (l - 1) * subsampling_dz + 1;
		543
		544	/* set volume data */
		545	f = fopen(filename, "rb");
		546	if (!f) {
		547	fprintf(stdout, "[ERROR] Failed to open %s for reading !!\n", filename);
		548	return 0;
		549	}
		550
		551	/* BINARY */
		552	for (compno = 0; compno < volume->numcomps; compno++) {
		553	int whl = w * h * l;
		554	/* set volume data */
		555	comp = &volume->comps[compno];
		556
		557	/*if (comp->prec <= 8) {
		558	if (!comp->sgnd) {
		559	unsigned char data = (unsigned char ) malloc(whl * sizeof(unsigned char));
		560	fread(data, 1, whl, f);
		561	for (i = 0; i < whl; i++) {
		562	comp->data[i] = data[i];
		563	if (comp->data[i] > max)
		564	max = comp->data[i];
		565	}
		566	free(data);
		567	} else {
		568	char data = (char ) malloc(whl);
		569	fread(data, 1, whl, f);
		570	for (i = 0; i < whl; i++) {
		571	comp->data[i] = data[i];
		572	if (comp->data[i] > max)
		573	max = comp->data[i];
		574	}
		575	free(data);
		576	}
		577	} else if (comp->prec <= 16) {
		578	if (!comp->sgnd) {
		579	unsigned short data = (unsigned short ) malloc(whl * sizeof(unsigned short));
		580	int leido = fread(data, 2, whl, f);
		581	if (!leido) {
		582	free(data); fclose(f);
		583	return NULL;
		584	}
		585
		586	for (i = 0; i < whl; i++) {
		587	if (bigendian) //(c1 << 8) + c2;
		588	comp->data[i] = data[i];
		589	else{ //(c2 << 8) + c1;
		590	comp->data[i] = ShortSwap(data[i]);
		591	}
		592	if (comp->data[i] > max)
		593	max = comp->data[i];
		594	}
		595	free(data);
		596	} else {
		597	short data = (short ) malloc(whl);
		598	int leido = fread(data, 2, whl, f);
		599	if (!leido) {
		600	free(data); fclose(f);
		601	return NULL;
		602	}
		603	for (i = 0; i < whl; i++) {
		604	if (bigendian){ //(c1 << 8) + c2;
		605	comp->data[i] = data[i];
		606	}else{ //(c2 << 8) + c1;
		607	comp->data[i] = (short) ShortSwap((unsigned short) data[i]);
		608	}
		609	if (comp->data[i] > max)
		610	max = comp->data[i];
		611	}
		612	free(data);
		613	}
		614	} else {
		615	if (!comp->sgnd) {
		616	unsigned int data = (unsigned int ) malloc(whl * sizeof(unsigned int));
		617	int leido = fread(data, 4, whl, f);
		618	if (!leido) {
		619	free(data); fclose(f);
		620	return NULL;
		621	} for (i = 0; i < whl; i++) {
		622	if (!bigendian)
		623	comp->data[i] = LongSwap(data[i]);
		624	else
		625	comp->data[i] = data[i];
		626	if (comp->data[i] > max)
		627	max = comp->data[i];
		628	}
		629	free(data);
		630	} else {
		631	int leido = fread(comp->data, 4, whl, f);
		632	if (!leido) {
		633	fclose(f);
		634	return NULL;
		635	}
		636	for (i = 0; i < whl; i++) {
		637	if (!bigendian)
		638	comp->data[i] = (int) LongSwap((unsigned int) comp->data[i]);
		639	if (comp->data[i] > max)
		640	max = comp->data[i];
		641	}
		642	}
		643	}*/
		644
		645	for (i = 0; i < whl; i++) {
		646	int v;
		647	if (comp->prec <= 8) {
		648	if (!comp->sgnd) {
		649	v = readuchar(f);
		650	} else {
		651	v = (char) readuchar(f);
		652	}
		653	} else if (comp->prec <= 16) {
		654	if (!comp->sgnd) {
		655	v = readushort(f, bigendian);
		656	} else {
		657	v = (short) readushort(f, bigendian);
		658	}
		659	} else {
		660	if (!comp->sgnd) {
		661	v = readuint(f, bigendian);
		662	} else {
		663	v = (int) readuint(f, bigendian);
		664	}
		665	}
		666	if (v > max)
		667	max = v;
		668	comp->data[i] = v;
		669	}
		670	comp->bpp = int_floorlog2(max) + 1;
		671	}
		672	fclose(f);
		673	return volume;
		674	}
		675
		676	int volumetobin(opj_volume_t * volume, char *outfile) {
		677	int w, wr, wrr, h, hr, hrr, l, lr, lrr, max;
		678	int i,j, compno, nbytes;
		679	int offset, sliceno;
		680	FILE *fdest = NULL;
		681	FILE *fimgdest = NULL;
		682	// char *imgtemp;
		683	char name[256];
		684
		685	for (compno = 0; compno < 1; compno++) { //Only one component
		686
		687	fdest = fopen(outfile, "wb");
		688	if (!fdest) {
		689	fprintf(stdout, "[ERROR] Failed to open %s for writing\n", outfile);
		690	return 1;
		691	}
		692	fprintf(stdout,"[INFO] Writing outfile %s (%s) \n",outfile, volume->comps[0].bigendian ? "Bigendian" : "Little-endian");
		693
		694	w = int_ceildiv(volume->x1 - volume->x0, volume->comps[compno].dx);
		695	wr = volume->comps[compno].w;
		696	wrr = int_ceildivpow2(volume->comps[compno].w, volume->comps[compno].factor[0]);
		697
		698	h = int_ceildiv(volume->y1 - volume->y0, volume->comps[compno].dy);
		699	hr = volume->comps[compno].h;
		700	hrr = int_ceildivpow2(volume->comps[compno].h, volume->comps[compno].factor[1]);
		701
		702	l = int_ceildiv(volume->z1 - volume->z0, volume->comps[compno].dz);
		703	lr = volume->comps[compno].l;
		704	lrr = int_ceildivpow2(volume->comps[compno].l, volume->comps[compno].factor[2]);
		705
		706	max = (volume->comps[compno].prec <= 8) ? 255 : (1 << volume->comps[compno].prec) - 1;
		707
		708	volume->comps[compno].x0 = int_ceildivpow2(volume->comps[compno].x0 - int_ceildiv(volume->x0, volume->comps[compno].dx), volume->comps[compno].factor[0]);
		709	volume->comps[compno].y0 = int_ceildivpow2(volume->comps[compno].y0 - int_ceildiv(volume->y0, volume->comps[compno].dy), volume->comps[compno].factor[1]);
		710	volume->comps[compno].z0 = int_ceildivpow2(volume->comps[compno].z0 - int_ceildiv(volume->z0, volume->comps[compno].dz), volume->comps[compno].factor[2]);
		711
		712	if (volume->comps[0].prec <= 8) {
		713	nbytes = 1;
		714	} else if (volume->comps[0].prec <= 16) {
		715	nbytes = 2;
		716	} else {
		717	nbytes = 4;
		718	}
		719
		720	//fprintf(stdout,"w %d wr %d wrr %d h %d hr %d hrr %d l %d lr %d lrr %d max %d nbytes %d\n Factor %d %d %d",w,wr,wrr,h,hr,hrr,l,lr,lrr,max,nbytes,volume->comps[compno].factor[0],volume->comps[compno].factor[1],volume->comps[compno].factor[2]);
		721
		722	for(sliceno = 0; sliceno < lrr; sliceno++) {
		723	offset = (sliceno / lrr * l) + (sliceno % lrr);
		724	offset = wrr * hrr * offset;
		725	for (i = 0; i < wrr * hrr; i++) {
		726	int v = volume->comps[0].data[(i / wrr * w) + (i % wrr) + offset];
		727	if (volume->comps[0].bigendian) {
		728	for (j = nbytes - 1; j >= 0; j--) {
		729	char byte = (char) ((v >> (j * 8)) & 0xff);
		730	fwrite(&byte, 1, 1, fdest);
		731	}
		732	} else {
		733	for (j = 0; j <= nbytes - 1; j++) {
		734	char byte = (char) ((v >> (j * 8)) & 0xff);
		735	fwrite(&byte, 1, 1, fdest);
		736	}
		737	}
		738	}
		739	}
		740
		741	}
		742
		743	fclose(fdest);
		744
		745	sprintf(name,"%s.img",outfile);
		746	fimgdest = fopen(name, "w");
		747	if (!fimgdest) {
		748	fprintf(stdout, "[ERROR] Failed to open %s for writing\n", name);
		749	return 1;
		750	}
		751	fprintf(fimgdest, "Bpp\t%d\nColor Map\t2\nDimensions\t%d\t%d\t%d\nResolution(mm)\t%d\t%d\t%d\t\n",
		752	volume->comps[0].prec,wrr,hrr,lrr,volume->comps[0].dx,volume->comps[0].dy,volume->comps[0].dz);
		753
		754	fclose(fimgdest);
		755	return 0;
		756	}
		757	/* -->> -->> -->> -->>
		758
		759	IMG IMAGE FORMAT
		760
		761	<<-- <<-- <<-- <<-- */
		762	opj_volume_t* imgtovolume(char fileimg, opj_cparameters_t parameters) {
		763	int subsampling_dx = parameters->subsampling_dx;
		764	int subsampling_dy = parameters->subsampling_dy;
		765	int subsampling_dz = parameters->subsampling_dz;
		766
		767	int i, compno, w, h, l, numcomps = 1;
		768	int prec, max = 0, min = 0;
		769	float dx, dy, dz;
		770	char filename[100], tmpdirpath[100], dirpath[100], *tmp;
		771	char line[100], datatype[100];
		772	int bigendian;
		773
		774	FILE *f = NULL;
		775	FILE *fimg = NULL;
		776	OPJ_COLOR_SPACE color_space;
		777	opj_volume_cmptparm_t cmptparm; /* maximum of 1 component */
		778	opj_volume_t * volume = NULL;
		779	opj_volume_comp_t *comp = NULL;
		780
		781	bigendian = 0;
		782	color_space = CLRSPC_GRAY;
		783
		784	fimg = fopen(fileimg,"r");
		785	if (!fimg) {
		786	fprintf(stderr, "[ERROR] Failed to open %s for reading !!\n", fileimg);
		787	return 0;
		788	}
		789
		790	//Fetch only the path
		791	strcpy(tmpdirpath,fileimg);
		792	if ((tmp = strrchr(tmpdirpath,'/')) != NULL){
		793	tmp++; *tmp='\0';
		794	strcpy(dirpath,tmpdirpath);
		795	} else {
		796	strcpy(dirpath,"./");
		797	}
		798
		799	fseek(fimg, 0, SEEK_SET);
		800	while (!feof(fimg)) {
		801	fgets(line,100,fimg);
		802	//fprintf(stdout,"%s %d \n",line,feof(fimg));
		803	if (strncmp(line,"Image",5) == 0){
		804	sscanf(line,"%s%[ \t]%s",datatype);
		805	} else if (strncmp(line,"File",4) == 0){
		806	sscanf(line,"%s %s%*[ \t]%s",filename);
		807	strcat(dirpath, filename);
		808	strcpy(filename,dirpath);
		809	} else if (strncmp(line,"Min",3) == 0){
		810	sscanf(line,"%s %s%[ \t]%d%[ \t]%d",&min,&max);
		811	prec = int_floorlog2(max - min + 1);
		812	} else if (strncmp(line,"Bpp",3) == 0){
		813	sscanf(line,"%s%[ \t]%d",&prec);
		814	} else if (strncmp(line,"Color",5) == 0){
		815	sscanf(line, "%s %s%*[ \t]%d",&color_space);
		816	} else if (strncmp(line,"Dim",3) == 0){
		817	sscanf(line, "%s%[ \t]%d%[ \t]%d%[ \t]%d",&w,&h,&l);
		818	} else if (strncmp(line,"Res",3) == 0){
		819	sscanf(line,"%s%[ \t]%f%[ \t]%f%[ \t]%f",&dx,&dy,&dz);
		820	}
		821
		822	}
		823	#ifdef VERBOSE
		824	fprintf(stdout, "[INFO] %s %d \t %d %d %d \t %f %f %f \t %d %d %d \n",filename,color_space,w,h,l,dx,dy,dz,max,min,prec);
		825	#endif
		826	fclose(fimg);
		827
		828	/* error control */
		829	if ( !prec \|\| !w \|\| !h \|\| !l ){
		830	fprintf(stderr,"[ERROR] Unable to read IMG file correctly. Found some null values.");
		831	return NULL;
		832	}
		833
		834	/* initialize volume components */
		835	memset(&cmptparm, 0, sizeof(opj_volume_cmptparm_t));
		836
		837	cmptparm.prec = prec;
		838	cmptparm.bpp = prec;
		839	cmptparm.sgnd = 0;
		840	cmptparm.bigendian = bigendian;
		841	cmptparm.dcoffset = parameters->dcoffset;
		842	cmptparm.dx = subsampling_dx;
		843	cmptparm.dy = subsampling_dy;
		844	cmptparm.dz = subsampling_dz;
		845	cmptparm.w = w;
		846	cmptparm.h = h;
		847	cmptparm.l = l;
		848
		849	/* create the volume */
		850	volume = opj_volume_create(numcomps, &cmptparm, color_space);
		851	if(!volume) {
		852	fprintf(stdout,"[ERROR] Unable to create volume");
		853	return NULL;
		854	}
		855
		856	/* set volume offset and reference grid */
		857	volume->x0 = parameters->volume_offset_x0;
		858	volume->y0 = parameters->volume_offset_y0;
		859	volume->z0 = parameters->volume_offset_z0;
		860	volume->x1 = parameters->volume_offset_x0 + (w - 1) * subsampling_dx + 1;
		861	volume->y1 = parameters->volume_offset_y0 + (h - 1) * subsampling_dy + 1;
		862	volume->z1 = parameters->volume_offset_z0 + (l - 1) * subsampling_dz + 1;
		863
		864	max = 0;
		865	/* set volume data */
		866	f = fopen(filename, "rb");
		867	if (!f) {
		868	fprintf(stderr, "[ERROR] Failed to open %s for reading !!\n", filename);
		869	fclose(f);
		870	return 0;
		871	}
		872
		873	/* BINARY */
		874	for (compno = 0; compno < volume->numcomps; compno++) {
		875	int whl = w * h * l;
		876	/* set volume data */
		877	comp = &volume->comps[compno];
		878
		879	/*if (comp->prec <= 8) {
		880	if (!comp->sgnd) {
		881	unsigned char data = (unsigned char ) malloc(whl * sizeof(unsigned char));
		882	fread(data, 1, whl, f);
		883	for (i = 0; i < whl; i++) {
		884	comp->data[i] = data[i];
		885	if (comp->data[i] > max)
		886	max = comp->data[i];
		887	}
		888	free(data);
		889	} else {
		890	char data = (char ) malloc(whl);
		891	fread(data, 1, whl, f);
		892	for (i = 0; i < whl; i++) {
		893	comp->data[i] = data[i];
		894	if (comp->data[i] > max)
		895	max = comp->data[i];
		896	}
		897	free(data);
		898	}
		899	} else if (comp->prec <= 16) {
		900	if (!comp->sgnd) {
		901	unsigned short data = (unsigned short ) malloc(whl * sizeof(unsigned short));
		902	int leido = fread(data, 2, whl, f);
		903	if (!leido) {
		904	free(data); fclose(f);
		905	return NULL;
		906	}
		907
		908	for (i = 0; i < whl; i++) {
		909	if (bigendian) //(c1 << 8) + c2;
		910	comp->data[i] = data[i];
		911	else{ //(c2 << 8) + c1;
		912	comp->data[i] = ShortSwap(data[i]);
		913	}
		914	if (comp->data[i] > max)
		915	max = comp->data[i];
		916	}
		917	free(data);
		918	} else {
		919	short data = (short ) malloc(whl);
		920	int leido = fread(data, 2, whl, f);
		921	if (!leido) {
		922	free(data); fclose(f);
		923	return NULL;
		924	}
		925	for (i = 0; i < whl; i++) {
		926	if (bigendian){ //(c1 << 8) + c2;
		927	comp->data[i] = data[i];
		928	}else{ //(c2 << 8) + c1;
		929	comp->data[i] = (short) ShortSwap((unsigned short) data[i]);
		930	}
		931	if (comp->data[i] > max)
		932	max = comp->data[i];
		933	}
		934	free(data);
		935	}
		936	} else {
		937	if (!comp->sgnd) {
		938	unsigned int data = (unsigned int ) malloc(whl * sizeof(unsigned int));
		939	int leido = fread(data, 4, whl, f);
		940	if (!leido) {
		941	free(data); fclose(f);
		942	return NULL;
		943	} for (i = 0; i < whl; i++) {
		944	if (!bigendian)
		945	comp->data[i] = LongSwap(data[i]);
		946	else
		947	comp->data[i] = data[i];
		948	if (comp->data[i] > max)
		949	max = comp->data[i];
		950	}
		951	free(data);
		952	} else {
		953	int leido = fread(comp->data, 4, whl, f);
		954	if (!leido) {
		955	fclose(f);
		956	return NULL;
		957	}
		958	for (i = 0; i < whl; i++) {
		959	if (!bigendian)
		960	comp->data[i] = (int) LongSwap((unsigned int) comp->data[i]);
		961	if (comp->data[i] > max)
		962	max = comp->data[i];
		963	}
		964	}
		965	}*/
		966
		967	for (i = 0; i < whl; i++) {
		968	int v;
		969	if (comp->prec <= 8) {
		970	if (!comp->sgnd) {
		971	v = readuchar(f);
		972	} else {
		973	v = (char) readuchar(f);
		974	}
		975	} else if (comp->prec <= 16) {
		976	if (!comp->sgnd) {
		977	v = readushort(f, bigendian);
		978	} else {
		979	v = (short) readushort(f, bigendian);
		980	}
		981	} else {
		982	if (!comp->sgnd) {
		983	v = readuint(f, bigendian);
		984	} else {
		985	v = (int) readuint(f, bigendian);
		986	}
		987	}
		988	if (v > max)
		989	max = v;
		990	comp->data[i] = v;
		991	}
		992	comp->bpp = int_floorlog2(max) + 1;
		993	}
		994	fclose(f);
		995	return volume;
		996	}
		997

Subversion Repositories Kolibri OS

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