/******************************************************************************
$Id: IO.c,v 1.1 2013/02/14 16:58:03 pascal Exp $

Those fonctions performs IO swapping between big-endian and little
endian representation.
*****************************************************************************/
#include <stdio.h>
#include <stdlib.h>

#include "config.h"
#include "EndianSwap/IO.h"
#include "EndianSwap/swapint.h"
#include "EndianSwap/swapfloat.h"


/******************************************************************************
ES_fwrite_short
###############
Write short values to a file from little-endian memory representation
to big endian representation in file. The writing is performed like the
standard fwrite function.

IN:
const short *buf : pointer to the short values to write
size_t nmemb : number of values to write.

INOUT:
FILE * stream : stream to write the data.

RETURN: 
size_t : the number of short values successfully written.
 *****************************************************************************/


size_t ES_fwrite_short(const short * buf, size_t nmemb, FILE * stream)
{
  short *tmp_buf;

  tmp_buf = (short *) malloc(nmemb*sizeof(short));

  memcpy(tmp_buf, buf, sizeof(short)*nmemb);
  
  {
    int i;
    for(i=0; i<nmemb; i++)
      {
	tmp_buf[i] = ES_swap_short(&tmp_buf[i]);
      }
  }

  return (fwrite(tmp_buf, sizeof(short), nmemb, stream));
}

/******************************************************************************
ES_fwrite_int
#############
Write int values to a file from little-endian memory representation
to big endian representation in file. The writing is performed like the
standard fwrite function.

IN:
const int *buf : pointer to the int values to write
size_t nmemb : number of values to write.

INOUT:
FILE * stream : stream to write the data.

RETURN: 
size_t : the number of int values successfully written.
 *****************************************************************************/

size_t ES_fwrite_int(const int * buf, size_t nmemb, FILE * stream)
{

  int *tmp_buf;

  tmp_buf = (int *) malloc(nmemb*sizeof(int));

  memcpy(tmp_buf, buf, sizeof(int)*nmemb);
  
  {
    int i;
    for(i=0; i<nmemb; i++)
      {
	tmp_buf[i] = ES_swap_int(&tmp_buf[i]);
      }
  }

  return (fwrite(tmp_buf, sizeof(int), nmemb, stream));

}

/******************************************************************************
ES_fwrite_float
###############
Write float values to a file from little-endian memory representation
to big endian representation in file. The writing is performed like the
standard fwrite function.

IN:
const float *buf : pointer to the float values to write
size_t nmemb : number of values to write.

INOUT:
FILE * stream : stream to write the data.

RETURN: 
size_t : the number of float values successfully written.
 *****************************************************************************/

size_t ES_fwrite_float(const float * buf, size_t nmemb, FILE * stream)
{

  float * tmp_buf;

  tmp_buf = (float *) malloc(nmemb*sizeof(float));

  memcpy(tmp_buf, buf, sizeof(float)*nmemb);
  
  {
    int i;
    for(i=0; i<nmemb; i++)
      {
	tmp_buf[i] = ES_swap_float(&tmp_buf[i]);
      }
  }

  return (fwrite(tmp_buf, sizeof(float), nmemb, stream));
}

/******************************************************************************
ES_fwrite_double
################
Write double values to a file from little-endian memory representation
to big endian representation in file. The writing is performed like the
standard fwrite function.

IN:
const double *buf : pointer to the double values to write
size_t nmemb : number of values to write.

INOUT:
FILE * stream : stream to write the data.

RETURN: 
size_t : the number of double values successfully written.
 *****************************************************************************/

size_t ES_fwrite_double(const double * buf, size_t nmemb, FILE * stream)
{

  double * tmp_buf;

  tmp_buf = (double *) malloc(nmemb*sizeof(double));

  memcpy(tmp_buf, buf, sizeof(double)*nmemb);
  
  {
    int i;
    for(i=0; i<nmemb; i++)
      {
	tmp_buf[i] = ES_swap_double(&tmp_buf[i]);
      }
  }

  return (fwrite(tmp_buf, sizeof(double), nmemb, stream));

}

/******************************************************************************
ES_fwrite_swap
##############
Write values to a file from little-endian memory representation
to big endian representation in file. The writing is performed like the
standard fwrite function.

IN:
const void *buf : pointer to the values to write
size_t size : size of the data type.
size_t nmemb : number of values to write.

INOUT:
FILE * stream : stream to write the data.

RETURN: 
size_t : the number of values successfully written.
 *****************************************************************************/

size_t ES_fwrite_swap(const void * buf, size_t size, size_t nmemb, FILE *
		      stream)
{

   void * tmp_buf;
   
   tmp_buf = malloc(size*nmemb);

   memcpy(tmp_buf, buf, size*nmemb);

  {
    int i;
    for(i=0; i<nmemb; i++)
      {
	ES_swap(&((char*)buf)[i*size], size);
      }
  }
  return (fwrite(tmp_buf, size, nmemb, stream));
}

/******************************************************************************
ES_fread_short
################
Read short data from a stream. The data are swapped from big-endian to
little-endian representation. The reading is performed like the
standard fread function.

IN:
size_t nmemb : number of short values to read.

OUT:
short *buf : pointer to the memory space that will receive the data.

INOUT:
FILE * stream : stream to read the data.

RETURN: 
size_t : the number of short values successfully read.
 *****************************************************************************/

size_t ES_fread_short(short * buf, size_t nmemb, FILE * stream)
{
  size_t nb_read;

  nb_read= fread(buf, sizeof(short), nmemb, stream);
  
  {
    int i;
    for(i=0; i<nb_read; i++)
      {
	buf[i] = ES_swap_short(&buf[i]);
      }
  }

  return nb_read;
}

/******************************************************************************
ES_fread_int
################
Read int data from a stream. The data are swapped from big-endian to
little-endian representation. The reading is performed like the
standard fread function.

IN:
size_t nmemb : number of int values to read.

OUT:
int *buf : pointer to the memory space that will receive the data.

INOUT:
FILE * stream : stream to read the data.

RETURN: 
size_t : the number of int values successfully read.
 *****************************************************************************/

size_t ES_fread_int(int * buf, size_t nmemb, FILE * stream)
{
  size_t nb_read;

  nb_read= fread(buf, sizeof(int), nmemb, stream);
  
  {
    int i;
    for(i=0; i<nb_read; i++)
      {
	buf[i] = ES_swap_int(&buf[i]);
      }
  }
  return nb_read;
}

/******************************************************************************
ES_fread_float
################
Read float data from a stream. The data are swapped from big-endian to
little-endian representation. The reading is performed like the
standard fread function.

IN:
size_t nmemb : number of float values to read.

OUT:
float *buf : pointer to the memory space that will receive the data.

INOUT:
FILE * stream : stream to read the data.

RETURN: 
size_t : the number of float values successfully read.
 *****************************************************************************/


size_t ES_fread_float(float * buf, size_t nmemb, FILE * stream)
{
  size_t nb_read;

  nb_read= fread(buf, sizeof(float), nmemb, stream);  
  {
    int i;
    for(i=0; i<nb_read; i++)
      {
	buf[i] = ES_swap_float(&buf[i]);
      }
  }
  return nb_read;
}

/******************************************************************************
ES_fread_double
################
Read double data from a stream. The data are swapped from big-endian to
little-endian representation. The reading is performed like the
standard fread function.

IN:
size_t nmemb : number of double values to read.

OUT:
double *buf : pointer to the memory space that will receive the data.

INOUT:
FILE * stream : stream to read the data.

RETURN: 
size_t : the number of double values successfully read.
 *****************************************************************************/



size_t ES_fread_double(double * buf, size_t nmemb, FILE * stream)
{
  size_t nb_read;

  nb_read= fread(buf, sizeof(double), nmemb, stream);
  {
    int i;
    for(i=0; i<nb_read; i++)
      {
	buf[i] = ES_swap_double(&buf[i]);
      }
  }
  return nb_read;
}

/******************************************************************************
ES_fread_swap
################
Read data from a stream. The data are swapped from big-endian to
little-endian representation. The reading is performed like the
standard fread function.

IN:
size_t size : size of the data type
size_t nmemb : number of values to read.

OUT:
short *buf : pointer to the memory space that will receive the data.

INOUT:
FILE * stream : stream to read the data.

RETURN: 
size_t : the number of values successfully read.
 *****************************************************************************/

size_t ES_fread_swap(double * buf, size_t size, size_t nmemb, FILE * stream)
{
  size_t nb_read;

  nb_read= fread(buf, size, nmemb, stream);
  
  {
    int i;
    for(i=0; i<nb_read; i++)
      {
	ES_swap(&((char*)buf)[i*size], size);
      }
  }
  return nb_read;
}