/***********************************************************************************
 *                                                                                 *
 *       Programa: frames2PICT    Proyecto Fin de Carrera  (c) Angel Soria 1993    *
 *                                                                                 *
 *       Convertidor de los ficheros .vff que produce SunVoxel a formato PICT      *
 *     Los ficheros se van convirtiendo, conforme se van generando por el Script   *
 *     y se van enviando a la unidad correspondiente, para su almacenamiento.      *
 *                                                                                 *
 ***********************************************************************************/
 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "pict.h"		/* pict.h (c) SPD Soft */

/* PARAMETROS DE COMPILACION */

#define ALFA 0			/* Si ALFA = 1 Se mantendra el canal alfa	*/
#define GUARDAR 1		/* Si GUARDAR = 1 Se ejecutara PROCESO 		*/
#define ELIMINA 1		/* Si ELIMINA = 1 se eliminaran los .vff	*/

/* Declaraciones */

#define PROCESO "guardar"	/* Proceso a lanzar si GUARDAR =1		*/
#define MAXCAD 100		/* Longitud maxima de las cadenas +1 		*/
#define TRUE 1			/* Para poder trabajar con booleanos  		*/
#define FALSE 0			/* Para poder trabajar con booleanos  		*/

/* Nombres y extensiones de los ficheros */

#define NOMB_IMAGEN "Imagen."		/* Nombre de las imagenes		*/
#define EXTENSION_P ""			/* Extension del fichero PICT		*/
#define EXTENSION_I ".image"		/* Extension de las imagenes vff 	*/

#define MALLOC(n,x) ((x*)malloc((n)*sizeof(x)))


/* Variables Globales */
/*--------------------*/

	FILE *vff;		/* Fichero vff procedente de SunVision.		*/
	Pict f_pict;		/* Fichero PICT de salida.			*/
	U_char c_map[256][3];	/* Paleta de color en ficheros que la tengan.	*/



/***********************************************************************************/
void salir_error(mensaje1,mensaje2)
char *mensaje1,*mensaje2;
/***********************************************************************************/

/* Da un mensaje de error y aborta el programa.*/
/*---------------------------------------------*/

{
	fprintf(stderr,"\tERROR: %s%s.\n",mensaje1,mensaje2);
 	exit(1);
}


/***********************************************************************************/
void error(mensaje1,mensaje2)
char *mensaje1,*mensaje2;
/***********************************************************************************/

/* Da un mensaje de error.*/
/*------------------------*/
{
	printf("\tERROR: %s%s.\n",mensaje1,mensaje2);
}


/***************************************************************************/
unsigned char Hex2Dec (cadena)
char *cadena;
/***************************************************************************/

/* Convierte una cadena de dos caracteres en hexadecimal a su valor decimal.
 */
 
{
	unsigned char dec=0;	/* Valor decimal 	*/
	int i;			/* variable auxiliar 	*/
	
	for (i=0;i<2; i++)
		cadena[i]=toupper(cadena[i]);
	
	if (cadena[1]>='A')
		dec=cadena[1]-'A'+10;
	else
		dec=cadena[1]-'0';
	if (cadena[0]>='A')
		dec=dec+(cadena[0]-'A'+10)*16;
	else
		dec=dec+(cadena[0]-'0')*16;
	
	return(dec);
}


/***************************************************************************/
int lee_linea (comando,valor)
char *comando;
char *valor;
/***************************************************************************/

/* Lee una linea terminada en '\n' o '\r' del fichero vff.
   Retorna true si ha sido correcto.
 */
 
{
	char	aux[MAXCAD];		/* Variable auxiliar */
	int 	i;			/* Variable auxiliar */
				
	if ( fgets(aux,MAXCAD-1,vff)==NULL )
		return(FALSE);
		
	for (i=0; (aux[i]!='\0')&&(aux[i]!='\n')&&(aux[i]!='\r'); i++);	
	aux[i]='\0';			/* Elimino \n o \r */
	
	strcpy(comando,aux);		/* Separo Comando y Valor */
	if (strchr(aux,'=')!=NULL)
	{
		*strchr(comando,'=')='\0';
		strcpy(valor,&(strchr(aux,'=')[1]));
	}
	return(TRUE);
}


/***********************************************************************************/
int cabecera_vff(lx,ly,canales)
int *lx,*ly,*canales;
/***********************************************************************************/

/* Lee la cabecera del fichero vff, la interpreta y devuelve:
 *  Las dimensiones lx, y  ly.
 *  El numero de canales.
 *  Rellena la paleta de  color si es un fichero con color indexado.
 *  Retorna 0 si no tiene exito.
 */
  
{
	char aux1[MAXCAD],aux2[MAXCAD];	/* Strings auxiliares	*/
	char buffer[MAXCAD+10];		/* String auxiliar	*/
	int  x;				/* Variable auxiliar	*/
	
	
	*lx=0;				/* Inicializo variables */
	*ly=0;
	*canales=0;
	
	lee_linea(aux1,aux2);
	if ( strcmp(aux1,"ncaa") )
	{
		error("El fichero no tiene 'ncaa'","");
		return(0);
	}
	do
	{
		lee_linea(aux1,aux2);
		if ( (!strcmp(aux1,"rank")) && (strcmp(aux2,"2;")) )
		{
			error("Fichero vff: ","Mal rango, debe ser 2.");
			return(0);
		}
		if ( (!strcmp(aux1,"type")) && (strcmp(aux2,"raster;")) )
		{
			error("Fichero vff: ","Mal tipo, debe ser raster.");
			return(0);
		}
		if ( (!strcmp(aux1,"format")) && (strcmp(aux2,"base;")) )
		{
			error("Fichero vff: ","Mal formato, debe ser base.");
			return(0);
		}
		if ( !strcmp(aux1,"size") )
		{
			sscanf(aux2,"%i %i",lx,ly);	/* Tama–o. 		*/
			continue;
		}
		if ( !strcmp(aux1,"bands") )
		{
			sscanf(aux2,"%i",canales);	/* n¼ de canales. 	*/
			continue;
		}
		
		/* No chequeo bits, solo puede ser 8 */
		/* No cheque ColorMapSize, solo puede ser 256 */
		
		if ( !strcmp(aux1,"colormap") )		/* Especifica paleta de color */
		{
		    strcpy(buffer,aux2);
		    x=0;
		    do
		    {
			do
			{	
			    strncpy(aux1,buffer,2);	/* Relleno la paleta de color */
			    aux1[2]='\0';
			    c_map[x][2]=Hex2Dec(aux1);	/*B*/	
			    strncpy(aux1,&(buffer[2]),2);
			    aux1[2]='\0';
			    c_map[x][1]=Hex2Dec(aux1);	/*G*/	
			    strncpy(aux1,&(buffer[4]),2);
			    aux1[2]='\0';
			    c_map[x][0]=Hex2Dec(aux1);	/*R*/	
			
			    strcpy(aux1,&(buffer[7]));	/* Me coloco en el siguiente */
			    strcpy(buffer,aux1);
			    x++;
			} while (strlen(buffer)>7);
				
			if (x!=256)	/* Si no he terminado, cargo mas datos */
			{
			    lee_linea(aux1,aux2);
			    strcat(buffer,aux1);
			}
			
		    } while (x<256);
		}		
	} while (aux1[0]!='\f');
	if ( (*canales==0)||(*lx==0)||(*ly==0) )
	{
		error("Fichero vff: ","Faltan datos imprescindibles.");
		return(0);
	}
	return(1);

}



/***********************************************************************************/
/*				Programa Principal				   */
/***********************************************************************************/

main()
{
 	char resp[MAXCAD];	/* Cadena usada para lectura de datos por pant. */
 	char nombvff[MAXCAD];	/* Nombre del fichero .vff original.		*/
 	char nombpict[MAXCAD];	/* Nombre completo del fichero .pict nuevo.	*/
	U_char *pixels;		/* Puntos que forman la linea que se convierte  */
	U_char *buff;		/* Buffer auxiliar para invertir los canales	*/
	int  lx,ly;		/* Tama–o de la picture.			*/
	int  canales;		/* Numero de canales del fichero de entrada.	*/
	int  y;			/* Linea en proceso de conversion.		*/
	int  ind;		/* Numero del fichero vff en curso.		*/
	int  img_i;		/* Numero de la imagen inicial.			*/
	int  num_i;		/* Numero de la imagen final.			*/
	long int longit;	/* Longitud de lo grabado en formato pict	*/
	unsigned int aux;	/* Variable auxiliar.				*/
	int  i,j,k;		/* Variables auxiliares.			*/
	
	
	fprintf(stderr,"\n###  Ejecutando frames2PICT  ###\n");
	fprintf(stderr,"\nConvertidor automatico de ficheros vff a PICT.\n");
	fprintf(stderr,"(c) 1993 Angel Soria.\n\n");
	
 	/* Parametros de la Imagen */
 	/*-------------------------*/ 	
 	
 	do
  	{
  		fprintf(stderr,"Numero de la primera imagen ? ");	
 		fscanf(stdin,"%i",&img_i);
 	  	fprintf(stderr,"\n");
 		fflush(stdin);
	} while (img_i<1);
 	do
  	{
  		fprintf(stderr,"Numero de la ultima imagen ? ");	
 		fscanf(stdin,"%i",&num_i);
 	  	fprintf(stderr,"\n");
 		fflush(stdin);
	} while (num_i<img_i);

 	/* Bucle de conversion */
 	/*---------------------*/

	longit=0;
	for(ind=img_i; ind<=num_i; ind++)
	{
		/* Espera a que termine con la imagen */
		/*------------------------------------*/

		/* Para saber que ha terminado, espero a que salga el siguiente fichero	*/
				
		if (ind==num_i)	/* En la ultima no puedo esperar al siguiente	*/
		{
  			fprintf(stderr,"Pulse '.' cuando termine de generar la ultima      ");	
 			fscanf(stdin,"%s",resp);
 	  		fprintf(stderr,"\n");
 			fflush(stdin);
		}
		else			/* Si no es la ultima espero al siguiente.	*/
		{	
			fprintf(stderr,"Esperando \"%s%04i%s\"...      \r",NOMB_IMAGEN,ind+1,EXTENSION_I);

			sprintf(resp,"%s%04i%s",NOMB_IMAGEN,ind+1,EXTENSION_I);
  			while( (vff=fopen(resp,"r"))==NULL )
  			{
  				sleep(2);	/* Pausa */
  			}
  			fclose(vff);
  		}
  		
		/* Convertir imagen */
		/*------------------*/
		
		sprintf(nombvff,"%s%04i%s",NOMB_IMAGEN,ind,EXTENSION_I);
		fprintf(stderr,"Convirtiendo: \"%s\"...     \r",nombvff);

  		/* Abro el fichero vff */
  		
  		if( (vff=fopen(nombvff,"r"))==NULL)
  		{
			error("Imposible abrir: ",nombvff);
			goto otro;
		}

		/* Leo el formato del fichero */
		
		if (!cabecera_vff(&lx,&ly,&canales))
			goto otro;
	
		/* Reservo Memoria */
	
		if( (pixels = MALLOC(lx*canales,U_char)) == NULL)
 			salir_error("Imposible crear espacio en memoria para Datos","");
		if( (buff = MALLOC(lx*canales,U_char)) == NULL)
 			salir_error("Imposible crear espacio en memoria para Datos","");

		sprintf(nombpict,"%s%04i%s",NOMB_IMAGEN,ind,EXTENSION_P);	
		switch(canales)
		{
		    case(1):	/* Creo el fichero PICT en modo RGB 8 bits */
		
			f_pict=pict_open(nombpict,P_WRITE,ly,lx,M_RGB8,c_map);
			break;

		    case(3):	/* Creo el fichero PICT en modo RGB 24 bits */
#if !ALFA
		    case(4):	/* Si se elimina el canal alfa */
#endif
			f_pict=pict_open(nombpict,P_WRITE,ly,lx,M_RGB24,c_map);
			break;
#if ALFA			
		    case(4):	/* Creo el fichero PICT en modo RGBA 32 bits */
			f_pict=pict_open(nombpict,P_WRITE,ly,lx,M_RGBA32,c_map);
			break;
#endif			
	    	    default:
	    		error("Numero de canales incorrecto.","");
	    		goto otro;
		}
		    		
		/* Relleno el fichero PICT */

		for(y=0; y<ly; y++)
		{
			if(fread(pixels,canales,lx,vff)!=lx)
			{
				error("Al leer del fichero vff","");
				goto otro;
			}
		    			
			/* Invierto los canales */

			k=0;
			switch(canales)
			{
		 	   case(1):	/* Modo RGB, 8 bits */
				memcpy(buff,pixels,lx);
			    	break;
			    case(3):	/* Modo RGB, 24 bits */
				for(j=2; j>=0; j--)  
				   for(i=0; i<lx; i++)
				   {
					buff[k++]=pixels[i*canales+j];
				   }
				break;
		 	   case(4):	/* Modo RGBA, 32 bits */
#if ALFA
				for(i=0; i<lx; i++)
					{
					buff[k++]=pixels[i*canales];	/* A */
				}
#endif
				for(j=3; j>0; j--)  
				    for(i=0; i<lx; i++)
				    {
					buff[k++]=pixels[i*canales+j];	/* RGB */
				    }
			}
			longit+=pict_put_line(f_pict,buff);
		}
		pict_close(f_pict);
		fclose(vff);
#if GUARDAR
		/* Grabacion de los ficheros */
		/*---------------------------*/
		
		fprintf(stderr,"\n");
		switch (fork())	/* Lanzo proceso */
		{
		    case -1:	/* Error */
		    	error("No se puede crear un nuevo proceso","");
		    	break;
		    case 0:	/* Hijo */
		    	execlp(PROCESO,PROCESO,nombpict,0);
		    	error("Fallo en execlp"," al lanzar el proceso");
  		    default:	/* Padre */
			fprintf(stderr,"Grabando: \"%s\"...       \r",nombpict);
 		    	if (wait(NULL)==-1)
 		    		error("Fallo en wait","");
 		}    	
		remove(nombpict);
		fprintf(stderr,"\nTotal Grabado: %.1f Mb.\n",(float)longit/1048576.0);
		    
#endif
		/* Libero memoria */

otro:		
#if ELIMINA
		remove(nombvff);
#endif
		free(pixels);
		free(buff);
	}
	
	fprintf(stderr,"\n\n###  Proceso terminado. ###\n\n");
}