/* Vis5D version 5.0 */

/*
Vis5D system for visualizing five dimensional gridded data sets
Copyright (C) 1990 - 1997 Bill Hibbard, Johan Kellum, Brian Paul,
Dave Santek, and Andre Battaiola.

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 1, or (at your option)
any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

/*
 * Functions to do binary I/O of floats, ints.
 *
 * >>>> These functions are built on top of Unix I/O functions, not stdio! <<<<
 *
 * The file format is assumed to be BIG-ENDIAN.
 * If this code is compiled with -DLITTLE and executes on a little endian
 * CPU then byte-swapping will be done.
 *
 * If an ANSI compiler is used prototypes and ANSI function declarations
 * are used.  Otherwise use K&R conventions.
 *
 * If we're running on a CRAY (8-byte ints and floats), conversions will
 * be done as needed.
 */


/*
 * Updates:
 *
 * April 13, 1995, brianp
 *   added cray_to_ieee and iee_to_cray array conversion functions.
 *   fixed potential cray bug in write_float4_array function.
 *
 */



#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#ifdef _CRAY
#  include <string.h>
#endif
#include "binio.h"




/**********************************************************************/
/******                     Byte Flipping                         *****/
/**********************************************************************/


#define FLIP4( n )  (  (n & 0xff000000) >> 24     \
                     | (n & 0x00ff0000) >> 8      \
                     | (n & 0x0000ff00) << 8      \
                     | (n & 0x000000ff) << 24  )


#define FLIP2( n )  (((unsigned short) (n & 0xff00)) >> 8  |  (n & 0x00ff) << 8)



/*
 * Flip the order of the 4 bytes in an array of 4-byte words.
 */
void flip4( const unsigned int *src, unsigned int *dest, int n )
{
   int i;

   for (i=0;i<n;i++) {
      unsigned int tmp = src[i];
      dest[i] = FLIP4( tmp );
   }
}



/*
 * Flip the order of the 2 bytes in an array of 2-byte words.
 */
void flip2( const unsigned short *src, unsigned short *dest, int n )
{
   int i;

   for (i=0;i<n;i++) {
      unsigned short tmp = src[i];
      dest[i] = FLIP2( tmp );
   }
}


#ifdef _CRAY
/*****************************************************************************
*
* The following source code is in the public domain.
* Specifically, we give to the public domain all rights for future licensing
* of the source code, all resale rights, and all publishing rights.
*
* We ask, but do not require, that the following message be included in all
* derived works:
*
* Portions developed at the National Center for Supercomputing Applications at
* the University of Illinois at Urbana-Champaign.
*
* THE UNIVERSITY OF ILLINOIS GIVES NO WARRANTY, EXPRESSED OR IMPLIED, FOR THE
* SOFTWARE AND/OR DOCUMENTATION PROVIDED, INCLUDING, WITHOUT LIMITATION,
* WARRANTY OF MERCHANTABILITY AND WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE
*
****************************************************************************/

/** THESE ROUTINES MUST BE COMPILED ON THE CRAY ONLY SINCE THEY **/
/** REQUIRE 8-BYTES PER C-TYPE LONG                             **/

/* Cray to IEEE single precision */
static void c_to_if( long *t, const long *f)
{
  /*
   * Clamp values to [-1e35, -1e-35] U {0} U [1e-35, 1e+35]
   * to prevent overflows and underflows that can occur when converting
   * from 8 byte to 4 byte floats.
   */

    const float* fp   = (const float*) f;
    float        x    = *fp;

    if ( x != 0 )
    {
#define SIGN(x) ((x) < 0 ? -1 : 1)
#define ABS(x)  ((x) < 0 ? -(x) : (x))

      const float  huge = 1e35;
      const float  tiny = 1e-35;

      if (      ABS( x ) < tiny ) x = tiny * SIGN( x );
      else if ( ABS( x ) > huge ) x = huge * SIGN( x );

      f = (const long*) &x;

#undef SIGN
#undef ABS
    }

    if (*f != 0){
        *t = (((*f & 0x8000000000000000) |      /* sign bit */
                 ((((*f & 0x7fff000000000000) >> 48)-16258) << 55)) + /* exp */
                 (((*f & 0x00007fffff000000) +
                    ((*f & 0x0000000000800000) << 1)) << 8));  /* mantissa */
    }
    else *t = *f;
}


#define C_TO_IF( T, F )							\
	if (F != 0) {							\
		T = (((F & 0x8000000000000000) |			\
		((((F & 0x7fff000000000000) >> 48)-16258) << 55)) +	\
		(((F & 0x00007fffff000000) +				\
		((F & 0x0000000000800000) << 1)) << 8));		\
	}								\
	else {								\
		T = F;							\
	}



/* IEEE single precison to Cray */
static void if_to_c( long *t, const long *f)
{
    if (*f != 0) {
        *t = (((*f & 0x8000000000000000) |
                ((*f & 0x7f80000000000000) >> 7) +
                (16258 << 48)) |
                (((*f & 0x007fffff00000000) >> 8) | (0x0000800000000000)));
        if ((*f << 1) == 0) *t = 0;
    }
    else *t = *f;
}

/* T and F must be longs! */
#define IF_TO_C( T, F )							\
	if (F != 0) {							\
		T = (((F & 0x8000000000000000) |			\
		((F & 0x7f80000000000000) >> 7) +			\
		(16258 << 48)) |					\
		(((F & 0x007fffff00000000) >> 8) | (0x0000800000000000)));  \
		if ((F << 1) == 0) T = 0;				\
	}								\
	else {								\
		T = F;							\
	}




/*
 * Convert an array of Cray 8-byte floats to an array of IEEE 4-byte floats.
 */
void cray_to_ieee_array( long *dest, const float *source, int n )
{
   long *dst;
   const long *src;
   long tmp1, tmp2;
   int i;

   dst = dest;
   src = (const long *) source;

   for (i=0;i<n;i+=2) {       /* add 1 in case n is odd */
      c_to_if( &tmp1, &src[i] );
      if ((i+1) >= n) {
         tmp2 = 0;
      }
      else {
         c_to_if( &tmp2, &src[i+1] );
      }
      *dst = (tmp1 & 0xffffffff00000000) | (tmp2 >> 32);
      dst++;
   }
}



/*
 * Convert an array of IEEE 4-byte floats to an array of 8-byte Cray floats.
 */
void ieee_to_cray_array( float *dest, const long *source, int n )
{
   long *dst;
   const long *src;
   int i;
   long ieee;

   src = source;
   dst = (long *) dest;

   for (i=0;i<n;i++) {
      /* most significant 4-bytes of ieee contain bit pattern to convert */
      if ((i&1)==0) {
         /* get upper half */
         ieee = src[i/2] & 0xffffffff00000000;
      }
      else {
         /* get lower half */
         ieee = src[i/2] << 32;
      }
      if_to_c( dst, &ieee );
      dst++;
   }
}


#endif /*_CRAY*/



/**********************************************************************/
/*****                     Read Functions                         *****/
/**********************************************************************/


/*
 * Read a block of bytes.
 *  Input:  f - the file descriptor to read from.
 *         b - address of buffer to read into.
 *         n - number of bytes to read.
 * Return:  number of bytes read, 0 if error.
 */
int read_bytes( int f, void *b, int n )
{
   return read( f, b, n );
}



/*
 * Read an array of 2-byte integers.
 * Input:  f - file descriptor
 *         iarray - address to put integers
 *         n - number of integers to read.
 * Return:  number of integers read.
 */
int read_int2_array( int f, short *iarray, int n )
{
#ifdef _CRAY
   int i;
   signed char *buffer;
   int nread;
   buffer = (signed char *) malloc( n * 2 );
   if (!buffer)  return 0;
   nread = read( f, buffer, n*2 );
   if (nread<=0)  return 0;
   nread /= 2;
   for (i=0;i<nread;i++) {
      /* don't forget about sign extension! */
      iarray[i] = (buffer[i*2] * 256) | buffer[i*2+1];
   }
   free( buffer );
   return nread;
#else
   int nread = read( f, iarray, n*2 );
   if (nread<=0)
      return 0;
#ifdef LITTLE
   flip2( (const unsigned short *) iarray, (unsigned short *) iarray, nread/2);
#endif
   return nread/2;
#endif
}



/*
 * Read an array of unsigned 2-byte integers.
 * Input:  f - file descriptor
 *         iarray - address to put integers
 *         n - number of integers to read.
 * Return:  number of integers read.
 */
int read_uint2_array( int f, unsigned short *iarray, int n )
{
#ifdef _CRAY
   int i;
   unsigned char *buffer;
   int nread;
   buffer = (unsigned char *) malloc( n * 2 );
   if (!buffer)  return 0;
   nread = read( f, buffer, n*2 );
   if (nread<=0)  return 0;
   nread /= 2;
   for (i=0;i<nread;i++) {
      iarray[i] = (buffer[i*2] << 8) | buffer[i*2+1];
   }
   free( buffer );
   return nread;
#else
   int nread = read( f, iarray, n*2 );
   if (nread<=0)
      return 0;
#ifdef LITTLE
   flip2( iarray, iarray, nread/2 );
#endif
   return nread/2;
#endif
}



/*
 * Read a 4-byte integer.
 * Input:  f - the file descriptor to read from
 *         i - pointer to integer to put result into.
 * Return:  1 = ok, 0 = error
 */
int read_int4( int f, int *i )
{
#ifdef LITTLE
   /* read big endian and convert to little endian */
   unsigned int n;
   if (read( f, &n, 4 )==4) {
      *i = FLIP4( n );
      return 1;
   }
   else {
      return 0;
   }
#else
   if (read( f, i, 4 )==4) {
#  ifdef _CRAY
      *i = *i >> 32;
#  endif
      return 1;
   }
   else {
      return 0;
   }
#endif
}



/*
 * Read an array of 4-byte integers.
 * Input:  f - file descriptor
 *         iarray - address to put integers
 *         n - number of integers to read.
 * Return:  number of integers read.
 */
int read_int4_array( int f, int *iarray, int n )
{
#ifdef _CRAY
   int j, nread;
   int *buffer;

   buffer = (int *) malloc( (n+1)*4 );
   if (!buffer)
      return 0;
   nread = read( f, buffer, 4*n );
   if (nread<=0) {
      return 0;
   }
   nread /= 4;

   for (j=0;j<nread;j++) {
      if ((j&1)==0) {
         iarray[j] = buffer[j/2] >> 32;
      }
      else {
         iarray[j] = buffer[j/2] & 0xffffffff;
      }
   }
   free( buffer );
   return nread;
#else
   int nread = read( f, iarray, 4*n );
   if (nread<=0)
     return 0;
#  ifdef LITTLE
      flip4( (const unsigned int *) iarray, (unsigned int *) iarray, nread/4 );
#  endif
   return nread/4;
#endif
}



/*
 * Read a 4-byte IEEE float.
 * Input:  f - the file descriptor to read from.
 *         x - pointer to float to put result into.
 * Return:  1 = ok, 0 = error
 */
int read_float4( int f, float *x )
{
#ifdef _CRAY
   long buffer = 0;

   if ( read( f, &buffer, 4 )==4 ) {
      /* convert IEEE float (buffer) to Cray float (x) */
      if_to_c( (long *) x, &buffer );
      return 1;
    }
    return 0;
#else
#  ifdef LITTLE
      unsigned int n, *iptr;
      if (read( f, &n, 4 )==4) {
         iptr = (unsigned int *) x;
         *iptr = FLIP4( n );
         return 1;
      }
      else {
         return 0;
      }
#  else
      if (read( f, x, 4 )==4) {
         return 1;
      }
      else {
         return 0;
      }
#  endif
#endif
}



/*
 * Read an array of 4-byte IEEE floats.
 * Input:  f - file descriptor
 *         x - address to put floats
 *         n - number of floats to read.
 * Return:  number of floats read.
 */
int read_float4_array( int f, float *x, int n )
{
#ifdef _CRAY
   /* read IEEE floats into buffer, then convert to Cray format */
   long *buffer;
   int i, nread;

   buffer = (long *) malloc( (n+1) * 4 );
   if (!buffer) return 0;
   nread = read( f, buffer, n*4 );
   if (nread<=0)  return 0;
   nread /= 4;
   ieee_to_cray_array( x, buffer, nread );
   free( buffer );
   return nread;
#else
   int nread = read( f, x, 4*n );
   if (nread<=0)
      return 0;
#ifdef LITTLE
   flip4( (const unsigned int *) x, (unsigned int*) x, nread/4 );
#endif
   return nread/4;
#endif
}



/*
 * Read a block of memory.
 * Input:  f - file descriptor
 *         data - address of first byte
 *         elements - number of elements to read
 *         elsize - size of each element to read (1, 2 or 4)
 * Return: number of elements written
 */
int read_block( int f, void *data, int elements, int elsize )
{
   if (elsize==1) {
      return read( f, data, elements );
   }
   else if (elsize==2) {
#ifdef LITTLE
      int n;
      n = read( f, data, elements*2 ) / 2;
      if (n==elements) {
         flip2( (const unsigned short *) data, (unsigned short *) data,
                elements );
      }
      return n;
#else
      return read( f, data, elements*2 ) / 2;
#endif
   }
   else if (elsize==4) {
#ifdef LITTLE
      int n;
      n = read( f, data, elements*4 ) / 4;
      if (n==elements) {
         flip4( (const unsigned int *) data, (unsigned int *) data, elements );
      }
      return n;
#else
      return read( f, data, elements*4 ) / 4;
#endif
   }
   else {
      printf("Fatal error in read_block(): bad elsize (%d)\n", elsize );
      abort();
   }
   return 0;
}




/**********************************************************************/
/*****                         Write Functions                    *****/
/**********************************************************************/



/*
 * Write a block of bytes.
 * Input:  f - the file descriptor to write to.
 *         b - address of buffer to write.
 *         n - number of bytes to write.
 * Return:  number of bytes written, 0 if error.
 */
int write_bytes( int f, const void *b, int n )
{
   return write( f, b, n );
}




/*
 * Write an array of 2-byte integers.
 * Input:  f - file descriptor
 *         iarray - address to put integers
 *         n - number of integers to write.
 * Return:  number of integers written
 */
int write_int2_array( int f, const short *iarray, int n )
{
#ifdef _CRAY
   printf("write_int2_array not implemented!\n");
   exit(1);
#else
   int nwritten;
#ifdef LITTLE
   flip2( (const unsigned short *) iarray, (unsigned short *) iarray, n );
#endif
   nwritten = write( f, iarray, 2*n );
#ifdef LITTLE
   flip2( (const unsigned short *) iarray, (unsigned short *) iarray, n );
#endif
   if (nwritten<=0)
      return 0;
   return nwritten/2;
#endif
}



/*
 * Write an array of 2-byte unsigned integers.
 * Input:  f - file descriptor
 *         iarray - address to put integers
 *         n - number of integers to write.
 * Return:  number of integers written
 */
int write_uint2_array( int f, const unsigned short *iarray, int n )
{
#ifdef _CRAY
   int i, nwritten;
   unsigned char *buffer;
   buffer = (unsigned char *) malloc( 2*n );
   if (!buffer)  return 0;
   for (i=0;i<n;i++) {
      buffer[i*2] = (iarray[i] >> 8) & 0xff;
      buffer[i*2+1] = iarray[i] & 0xff;
   }
   nwritten = write( f, buffer, 2*n );
   free( buffer );
   if (nwritten<=0)
      return 0;
   else
      return nwritten/2;
#else
   int nwritten;
#ifdef LITTLE
   flip2( iarray, (unsigned short *) iarray, n );
#endif
   nwritten = write( f, iarray, 2*n );
#ifdef LITTLE
   flip2( iarray, (unsigned short *) iarray, n );
#endif
   if (nwritten<=0)
      return 0;
   else
      return nwritten/2;
#endif
}



/*
 * Write a 4-byte integer.
 *Input:  f - the file descriptor
 *         i - the integer
 * Return:  1 = ok, 0 = error
 */
int write_int4( int f, int i )
{
#ifdef _CRAY
   i = i << 32;
   return write( f, &i, 4 ) > 0;
#else
#  ifdef LITTLE
     i = FLIP4( i );
#  endif
   return write( f, &i, 4 ) > 0;
#endif
}



/*
 * Write an array of 4-byte integers.
 * Input:  f - the file descriptor
 *         i - the array of ints
 *           n - the number of ints in array
 *  Return:  number of integers written.
 */
int write_int4_array( int f, const int *i, int n )
{
#ifdef _CRAY
   int j, nwritten;
   char *buf, *b, *ptr;

   b = buf = (char *) malloc( n*4 + 8 );
   if (!b)
      return 0;
   ptr = (char *) i;
   for (j=0;j<n;j++) {
      ptr += 4;      /* skip upper 4 bytes */
      *b++ = *ptr++;
      *b++ = *ptr++;
      *b++ = *ptr++;
      *b++ = *ptr++;
   }
   nwritten = write( f, buf, 4*n );
   free( buf );
   if (nwritten<=0)
      return 0;
   else
      return nwritten / 4;
#else
#  ifdef LITTLE
      int nwritten;
      flip4( (const unsigned int *) i, (unsigned int *) i, n );
      nwritten = write( f, i, 4*n );
      flip4( (const unsigned int *) i, (unsigned int *) i, n );
      if (nwritten<=0)
         return 0;
      else
        return nwritten / 4;
#  else
      return write( f, i, 4*n ) / 4;
#  endif
#endif
}



/*
 * Write a 4-byte IEEE float.
 * Input:  f - the file descriptor
 *         x - the float
 * Return:  1 = ok, 0 = error
 */
int write_float4( int f, float x )
{
#ifdef _CRAY
   char buffer[8];
   c_to_if( (long *) buffer, (const long *) &x );
   return write( f, buffer, 4 ) > 0;
#else
#  ifdef LITTLE
      float y;
      unsigned int *iptr = (unsigned int *) &y, temp;
      y = (float) x;
      temp = FLIP4( *iptr );
      return write( f, &temp, 4 ) > 0;
#  else
      float y;
      y = (float) x;
      return write( f, &y, 4 ) > 0;
#  endif
#endif
}



/*
 * Write an array of 4-byte IEEE floating point numbers.
 * Input:  f - the file descriptor
 *         x - the array of floats
 *         n - number of floats in array
 * Return:  number of float written.
 */
int write_float4_array( int f, const float *x, int n )
{
#ifdef _CRAY
   /* convert cray floats to IEEE and put into buffer */
   int nwritten,i;
   long *buffer;
   buffer = (long *) malloc( n*4 + 8 );
   if (!buffer)
      return 0;
   cray_to_ieee_array( buffer, x, n );
   nwritten = write( f, buffer, 4*n );
   free( buffer );
   if (nwritten<=0)
      return 0;
   else
      return nwritten / 4;
#else
#  ifdef LITTLE
      int nwritten;
      flip4( (const unsigned int *) x, (unsigned int *) x, n );
      nwritten = write( f, x, 4*n );
      flip4( (const unsigned int *) x, (unsigned int *) x, n );
      if (nwritten<=0)
         return 0;
      else 
         return nwritten / 4;
#  else
      return write( f, x, 4*n ) / 4;
#  endif
#endif
}



/*
 * Write a block of memory.
 * Input:  f - file descriptor
 *         data - address of first byte
 *         elements - number of elements to write
 *         elsize - size of each element to write (1, 2 or 4)
 * Return: number of elements written
 */
int write_block( int f, const void *data, int elements, int elsize )
{
   if (elsize==1) {
      return write( f, data, elements );
   }
   else if (elsize==2) {
#ifdef LITTLE
      int n;
      flip2( (const unsigned short *) data, (unsigned short *) data, elements);
      n = write( f, data, elements*2 ) / 2;
      flip2( (const unsigned short *) data, (unsigned short *) data, elements);
      return n;
#else
      return write( f, data, elements*2 ) / 2;
#endif
   }
   else if (elsize==4) {
#ifdef LITTLE
      int n;
      flip4( (const unsigned int *) data, (unsigned int *) data, elements );
      n = write( f, data, elements*4 ) / 4;
      flip4( (const unsigned int *) data, (unsigned int *) data, elements );
      return n;
#else
      return write( f, data, elements*4 ) / 4;
#endif
   }
   else {
      printf("Fatal error in write_block(): bad elsize (%d)\n", elsize );
      abort();
   }
   return 0;
}