/***********************************************************************

ux2ascii - convert uxnmr x32 integer data to ascii floating point data

COMPILE:

gcc -o ux2ascii ux2ascii.c

USAGE:
	ux2ascii uxnmr_source_file TD ascii_output_file SWP OFFSET
	
	uxnmr_source_file:
		binary format uxnmr AspectStation data file (i.e. fid, 1r etc...).
	TD:	time domain size: number of data points per fid.
	ascii_output_file:
		ascii format output file name.
	SW:	sweep width in Hertz
	OFFSET: uxnmr OFFSET parameter

***********************************************************************/

#include <stdio.h>
#include <malloc.h>
#include <sys/types.h>
#include <sys/stat.h>

/* #define BIG_ENDIAN     /* big endian architecture (e.g. SGI Iris,
			* SUN Sparc, Sun MC68000 based).
			* Undefine BIG_ENDIAN for sall endian 
			* architecture (e.g. VAX, INTEL, NS based 
			* systems). */

/**********************************************************************/
main(argc, argv)
int	argc;
char	**argv;
{
	extern char *sys_errlist[];
	extern int  errno;

	FILE *f_in;
	FILE *f_out;
	struct stat buf;
	int  td, td1;
	double sw, offset, atof();

	if (argc != 6) {
		(void) printf("... wrong number of arguments\n");
		(void) printf(
		"USAGE: %s uxnmr_source_file TD ascii_output_file SWH OFFSET\n",
		argv[0]);
		(void) printf("EXIT\n\n");
		exit(1);
	} 
	
	td = atoi(argv[2]);
	if (td <= (int)0) {
		(void) printf(
		"ERROR in commad line argument: TD = %d\n", td);
		(void) printf("EXIT\n\n");
		exit(1);
	}
	(void) printf("... TD %d\n", td);


	if (stat(argv[1], &buf) == -1) {
		(void) printf("... cannot access %s: \n", argv[1]);
		(void) printf("    ERROR %s\n", sys_errlist[errno]);
		(void) printf("EXIT\n\n");
		exit(1);
	} else {
		if (buf.st_size < td * sizeof(int)) {
		  (void) printf("... wrong input file size: %d bytes\n",
				buf.st_size);
		  (void) printf("    expected %d bytes\n", 
				td * sizeof(int));
		  (void) printf("EXIT\n\n");
		  exit(1);
		}
	}

	if ((f_in = fopen(argv[1], "r")) == NULL) {
		(void) printf("... cannot read %s: \n", argv[1]);
		(void) printf("    ERROR %s\n", sys_errlist[errno]);
		(void) printf("EXIT\n\n");
		exit(1);
	} else {
		(void) printf("... %s open for read, %d bytes\n", 
		argv[1], buf.st_size);
	}

	if ((f_out = fopen(argv[3], "w")) == NULL) {
		(void) printf("... cannot write to %s: \n", argv[3]);
		(void) printf("    ERROR %s\n", sys_errlist[errno]);
		(void) printf("EXIT\n\n");
		exit(1);
	} else {
		(void) printf("... %s open for write\n", argv[3]);
	}

        sw = atof(argv[4]);
        if (sw <= (double)0) {
                (void) printf(
                "ERROR in commad line argument: SW = %6.2f\n", sw);
                (void) printf("EXIT\n\n");
                exit(1);
        }
        (void) printf("... SW %6.2f\n", sw);

        offset = atof(argv[5]);
        if (offset <= (double)0) {
                (void) printf(
                "ERROR in commad line argument: OFFSET = %8.5f\n", offset);
                (void) printf("EXIT\n\n");
                exit(1);
        }
        (void) printf("... OFFSET %6.2f\n", offset);

	td1 = convert(f_in, td, f_out, sw, offset);
	(void) printf("... td1 = %d, converted %d bytes.\n", td1,
		td*td1*sizeof(int));
	
	(void)fclose(f_in);
	(void)fclose(f_out);

	if (buf.st_size == td * td1 * sizeof(int)) {
		(void) printf("... no errors.\n");
	}
	(void) printf("\ndone %s.\n\n", argv[0]);
	exit(0);
}


/**********************************************************************/
static int
convert (f_in, td, f_out, sw, offset)
FILE 	*f_in;
int	td;
FILE	*f_out;
double  sw;
double	offset;
/*----------------------------------------------------------------------
Convert integer file to ascii format file.
----------------------------------------------------------------------*/
{
	void	reverse4ByteOrder();

	int 	*ip;
	int	cnt, i;
	int	bytes;
	int	m,n;

	ip = (int*) malloc((unsigned)(td * sizeof(int)));
	if (ip == NULL) {
		(void) printf("... no memory (%d bytes)\n", 
			td * sizeof(int));
		(void) printf("EXIT\n\n");
		exit(1);
	}

	bytes = sizeof(int) + td * sizeof(int) ;
	n = td/2;
	i = 0;
	(void) printf("\n");
	do {
		cnt = fread((char*)ip,sizeof(int),td,f_in);
		if (cnt == td) {
			(void) printf("row %4d\r",++i);
#ifndef BIG_ENDIAN
			reverse4ByteOrder(td, (char*)ip);
#endif
			for (m = 0; m < td; m++) {
    				fprintf(f_out,"%8.5f %d\n",offset-(sw-(sw*(td-m)/td)),*ip);
    				ip+=1;
  			}
		}
	} while (cnt == td);

	if (cnt != 0) {
	  (void) printf(
	  "... %d bytes remaining, incomplete conversion (?).\n",cnt);
	}

	return i;
}


/**********************************************************************/
static void
reverse4ByteOrder(nele, dtaptr)
int     nele;			       /* specify number of elements to
				        * convert */
char 	*dtaptr;		       /* specify and return conversion
				        * data    */
/*----------------------------------------------------------------------
Reverse byte order in 4 byte word (inplace).
----------------------------------------------------------------------*/
{
  register int *ip;
  register char *ca;
  register int m;
  union {
    char    ch[4];
    int     i;
  }       bs;

  ca = (char *) dtaptr;
  ip = (int *) dtaptr;
  for (m = 0; m < nele; m++) {
    bs.ch[3] = *ca++;
    bs.ch[2] = *ca++;
    bs.ch[1] = *ca++;
    bs.ch[0] = *ca++;
    *ip++ = bs.i;
  }

}				       /* reverse4ByteOrder() */