/*
 *  LIBML library - read, write and manipulate MATLAB MAT-files
 *  Copyright (C) 1994 Michael J. Maurer
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Library General Public
 *  License as published by the Free Software Foundation; either
 *  version 2 of the License, or (at your option) any later version.
 *
 *  This library 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
 *  Library General Public License for more details.
 *
 *  You should have received a copy of the GNU Library General Public
 *  License along with this library; if not, write to the Free
 *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 *  Michael Maurer <maurer@nova.stanford.edu>
 *  Durand Bldg - Room 232
 *  Stanford, CA 94305-4055
 *  (415) 723-1024
 */
/******************************************************************************
  mlcvt.c

Provides data-format conversions for matlab MAT file library.
Copyright (c) 1993 by Michael Maurer (maurer@nova.stanford.edu).
******************************************************************************/
/* $Log$ */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "libml.h"
#include "libml.p"
#include "libmisc.h"

/******************************************************************************
  mltype

Parses type value into decimal digits, and returns the size in bytes of
a single element of this type.

Parses the matlab TYPE parameter in matlab format files.
Returns 5 values:
        M       Machine ID: 0=PC,MIPS, 1=Sun, 2=VAX, 3=VAX G-FLOAT
        O       0=column-major order    1=row-major order
        P       0 8-byte floating-point
                1 4-byte floating-point
                2 32-bit signed integer
                3 16-bit signed integer
                4 16-bit unsigned integer
                5 8-bit unsigned integer
        T       0=numerical data        1=string

The returned size may be incorrect for VAX-G float: what is the correct
answer?  We don't normally handle VAX-G.
******************************************************************************/

int
mltype(type, Mp, Op, Pp, Tp)
int type, *Mp, *Op, *Pp, *Tp;
{
   int dsize,M,O,P,T;

   T = type%10;
   type -= T;
   P = (type%100)/10;
   type -= P;
   O = (type%1000)/100;
   type -= O;
   M = (type%10000)/1000;
   switch (P*10) {
    case ML_DOUBLE:     dsize=sizeof(double);           break;
    case ML_FLOAT:      dsize=sizeof(float);            break;
    case ML_INT:        dsize=sizeof(long);             break;
    case ML_SHORT:      dsize=sizeof(short);            break;
    case ML_USHORT:     dsize=sizeof(unsigned short);   break;
    case ML_UCHAR:      dsize=sizeof(unsigned char);    break;
    default:
      fprintf(stderr, "[mltype] Illegal P type: %d\n", P);
      exit(1);
   }
   if (Mp) *Mp=M;
   if (Op) *Op=O;
   if (Pp) *Pp=P;
   if (Tp) *Tp=T;
   return dsize;
}

/******************************************************************************
  mlborder

Returns byte-order associated with data format 'type'.
See libml.h for definitions of return values.
******************************************************************************/

int
mlborder(type)
int type;
{
   int M,O,P,T;

   (void)mltype(type,&M,&O,&P,&T);
   switch (M*1000) {
    case ML_LIT_IEEE:
      return ML_LITEND;
    case ML_BIG_IEEE:
      return ML_BIGEND;
    case ML_LIT_VAXD:
      return ML_LITEND;
    case ML_LIT_VAXG:
      return ML_LITEND;
    default:
      return ML_UNKEND;
   }
}

/******************************************************************************
  mlcast

Uses default C cast rules to convert from one type to another of equal
or lesser precision.  If an overflow occurs, it's up to C to make the
cast.  Works in place if converting to lesser precision.  Cannot cast to
greater precision in place because converted values would overwrite old
vales before they were used.

iVP is pointer to input data (must be in native format)
oVP is pointer to output data (will be in native format)
itype is input matlab data type (see libml.h)
otype is output matlab data type (see libml.h)
******************************************************************************/

static int
mlcast(iVP,oVP,n,itype,otype)
void *iVP,*oVP;                                         /* input/output pointers */
int n;                                                  /* number of elements */
int itype,otype;                                        /* input/output data types */
{
   int                  k,idsize,odsize;
   int                  iM,iO,iP,iT;
   int                  oM,oO,oP,oT;
   unsigned char        *iUC=(unsigned char *)iVP;
   unsigned char        *oUC=(unsigned char *)oVP;
   unsigned short       *iUS=(unsigned short *)iVP;
   unsigned short       *oUS=(unsigned short *)oVP;
   short                *iS=(short *)iVP;
   short                *oS=(short *)oVP;
   int                  *iI=(int *)iVP;
   int                  *oI=(int *)oVP;
   float                *iF=(float *)iVP;
   float                *oF=(float *)oVP;
   double               *iD=(double *)iVP;
   double               *oD=(double *)oVP;
   
   idsize=mltype(itype,&iM,&iO,&iP,&iT);
   odsize=mltype(otype,&oM,&oO,&oP,&oT);
   if (iM*1000!=ML_TYPE || oM*1000!=ML_TYPE) {
      fprintf(stderr,"[mlcast] all data must be in native format\n");
      return -1;
   }
   if (iVP==oVP && odsize>idsize) {
      fprintf(stderr,"[mlcast] cannot cast in place to larger type\n");
      return -1;
   }
   iP*=10;
   oP*=10;
   switch (iP) {
    case ML_DOUBLE:
      switch (oP) {
       case ML_DOUBLE:
         memcpy(oVP,iVP,n*idsize);
         break;
       case ML_FLOAT:
         for (k=0; k<n; k++) oF[k]=iD[k];
         break;
       case ML_INT:
         for (k=0; k<n; k++) oI[k]=iD[k];
         break;
       case ML_SHORT:
         for (k=0; k<n; k++) oS[k]=iD[k];
         break;
       case ML_USHORT:
         for (k=0; k<n; k++) oUS[k]=iD[k];
         break;
       case ML_UCHAR:
         for (k=0; k<n; k++) oUC[k]=iD[k];
         break;
       default:
         return -2;
      }
      break;
    case ML_FLOAT:
      switch (oP) {
       case ML_DOUBLE:
         for (k=0; k<n; k++) oD[k]=iF[k];
         break;
       case ML_FLOAT:
         memcpy(oVP,iVP,n*idsize);
         break;
       case ML_INT:
         for (k=0; k<n; k++) oI[k]=iF[k];
         break;
       case ML_SHORT:
         for (k=0; k<n; k++) oS[k]=iF[k];
         break;
       case ML_USHORT:
         for (k=0; k<n; k++) oUS[k]=iF[k];
         break;
       case ML_UCHAR:
         for (k=0; k<n; k++) oUC[k]=iF[k];
         break;
       default:
         return -2;
      }
      break;
    case ML_INT:
      switch (oP) {
       case ML_DOUBLE:
         for (k=0; k<n; k++) oD[k]=iI[k];
         break;
       case ML_FLOAT:
         for (k=0; k<n; k++) oF[k]=iI[k];
         break;
       case ML_INT:
         memcpy(oVP,iVP,n*idsize);
         break;
       case ML_SHORT:
         for (k=0; k<n; k++) oS[k]=iI[k];
         break;
       case ML_USHORT:
         for (k=0; k<n; k++) oUS[k]=iI[k];
         break;
       case ML_UCHAR:
         for (k=0; k<n; k++) oUC[k]=iI[k];
         break;
       default:
         return -2;
      }
      break;
    case ML_SHORT:
      switch (oP) {
       case ML_DOUBLE:
         for (k=0; k<n; k++) oD[k]=iS[k];
         break;
       case ML_FLOAT:
         for (k=0; k<n; k++) oF[k]=iS[k];
         break;
       case ML_INT:
         for (k=0; k<n; k++) oI[k]=iS[k];
         break;
       case ML_SHORT:
         memcpy(oVP,iVP,n*idsize);
         break;
       case ML_USHORT:
         for (k=0; k<n; k++) oUS[k]=iS[k];
         break;
       case ML_UCHAR:
         for (k=0; k<n; k++) oUC[k]=iS[k];
         break;
       default:
         return -2;
      }
      break;
    case ML_USHORT:
      switch (oP) {
       case ML_DOUBLE:
         for (k=0; k<n; k++) oD[k]=iUS[k];
         break;
       case ML_FLOAT:
         for (k=0; k<n; k++) oF[k]=iUS[k];
         break;
       case ML_INT:
         for (k=0; k<n; k++) oI[k]=iUS[k];
         break;
       case ML_SHORT:
         for (k=0; k<n; k++) oS[k]=iUS[k];
         break;
       case ML_USHORT:
         memcpy(oVP,iVP,n*idsize);
         break;
       case ML_UCHAR:
         for (k=0; k<n; k++) oUC[k]=iUS[k];
         break;
       default:
         return -2;
      }
      break;
    case ML_UCHAR:
      switch (oP) {
       case ML_DOUBLE:
         for (k=0; k<n; k++) oD[k]=iUC[k];
         break;
       case ML_FLOAT:
         for (k=0; k<n; k++) oF[k]=iUC[k];
         break;
       case ML_INT:
         for (k=0; k<n; k++) oI[k]=iUC[k];
         break;
       case ML_SHORT:
         for (k=0; k<n; k++) oS[k]=iUC[k];
         break;
       case ML_USHORT:
         for (k=0; k<n; k++) oUS[k]=iUC[k];
         break;
       case ML_UCHAR:
         memcpy(oVP,iVP,n*idsize);
         break;
       default:
         return -2;
      }
      break;
   }
   return 0;
}

/******************************************************************************
  mlcvt

  Converts between number formats.  'itype' is input fomat, 'otype' is
desired output format.  If promoting to a type that is larger, operation
can not be done in place.

At the moment, mlcast() requires native format numbers, so it is
impossible to convert from a foreign machine format and also change the
data type simultaneously.  Use two sequential calls instead.

Doesn't handle VAX-G formats.
******************************************************************************/

int
mlcvt(ip,op,n,itype,otype)
void *ip,*op;                                           /* input/output pointers */
int n;                                                  /* number of elements */
int itype,otype;                                        /* input/output data type */
{
   int iM,iO,iP,iT,oM,oO,oP,oT;
   int idsize,odsize;

   idsize=mltype(itype,&iM,&iO,&iP,&iT);
   odsize=mltype(otype,&oM,&oO,&oP,&oT);
   if (iO!=oO || iT!=oT)                                /* we can't do transpose */
      return -1;
   if (iP!=oP) {
      if (mlcast(ip,op,n,itype,otype))
         return -1;
      iP=oP;
      idsize=odsize;
   }
   if (idsize!=odsize || iP!=oP)
      return -1;
   iP*=10;
   iM*=1000;
   oM*=1000;
   switch (iM) {
    case ML_MIPSEL:
      switch (oM) {
       case ML_MIPSEL:
         break;
       case ML_SUN:
         switch (iP) {
          case ML_DOUBLE:
            d_mipsel2ieee(ip,op,n);     break;
          case ML_FLOAT:
            f_mipsel2ieee(ip,op,n);     break;
          case ML_INT:
            l_mipsel2ieee(ip,op,n);     break;
          case ML_SHORT:
          case ML_USHORT:
            s_mipsel2ieee(ip,op,n);     break;
          case ML_UCHAR:
            break;
          default:
            return -4;
         }
         break;
       case ML_VAX:
         switch (iP) {
          case ML_DOUBLE:
            d_mipsel2ieee(ip,op,n);
            d_ieee2vax(ip,op,n);
            break;
          case ML_FLOAT:
            f_mipsel2ieee(ip,op,n);
            f_ieee2vax(ip,op,n);
            break;
          case ML_INT:
            l_mipsel2ieee(ip,op,n);
            l_ieee2vax(ip,op,n);
            break;
          case ML_SHORT:
          case ML_USHORT:
            s_mipsel2ieee(ip,op,n);
            s_ieee2vax(ip,op,n);
            break;
          case ML_UCHAR:
            break;
          default:
            return -4;
         }
         break;
       default:
         fprintf(stderr,"[mlcvt] machine output format %d unsupported\n",oM);
         return -3;
      }
      break;
    case ML_SUN:
      switch (oM) {
       case ML_MIPSEL:
         switch (iP) {
          case ML_DOUBLE:
            d_ieee2mipsel(ip,op,n);     break;
          case ML_FLOAT:
            f_ieee2mipsel(ip,op,n);     break;
          case ML_INT:
            l_ieee2mipsel(ip,op,n);     break;
          case ML_SHORT:
          case ML_USHORT:
            s_ieee2mipsel(ip,op,n);     break;
          case ML_UCHAR:
            break;
          default:
            return -4;
         }
         break;
       case ML_SUN:
         break;
       case ML_VAX:
         switch (iP) {
          case ML_DOUBLE:
            d_ieee2vax(ip,op,n);        break;
          case ML_FLOAT:
            f_ieee2vax(ip,op,n);        break;
          case ML_INT:
            l_ieee2vax(ip,op,n);        break;
          case ML_SHORT:
          case ML_USHORT:
            s_ieee2vax(ip,op,n);        break;
          case ML_UCHAR:
            break;
          default:
            return -4;
         }
         break;
       default:
         fprintf(stderr,"[mlcvt] machine output format %d unsupported\n",oM);
         return -3;
      }
      break;
    case ML_VAX:
      switch (oM) {
       case ML_MIPSEL:
         switch (iP) {
          case ML_DOUBLE:
            d_vax2ieee(ip,op,n);
            d_ieee2mipsel(ip,op,n);
            break;
          case ML_FLOAT:
            f_vax2ieee(ip,op,n);
            f_ieee2mipsel(ip,op,n);
            break;
          case ML_INT:
            l_vax2ieee(ip,op,n);
            l_ieee2mipsel(ip,op,n);
            break;
          case ML_SHORT:
          case ML_USHORT:
            s_vax2ieee(ip,op,n);
            s_ieee2mipsel(ip,op,n);
            break;
          case ML_UCHAR:
            break;
          default:
            return -4;
         }
         break;
       case ML_SUN:
         switch (iP) {
          case ML_DOUBLE:
            d_vax2ieee(ip,op,n);        break;
          case ML_FLOAT:
            f_vax2ieee(ip,op,n);        break;
          case ML_INT:
            l_vax2ieee(ip,op,n);        break;
          case ML_SHORT:
          case ML_USHORT:
            s_vax2ieee(ip,op,n);        break;
          case ML_UCHAR:
            break;
          default:
            return -4;
         }
         break;
       case ML_VAX:
         break;
       default:
         fprintf(stderr,"[mlcvt] machine output format %d unsupported\n",oM);
         return -3;
      }
      break;
    default:
      fprintf(stderr,"[mlcvt] machine input format %d unsupported\n",iM);
      return -2;
   }
   return 0;
}

/******************************************************************************
  mlpromote

Converts matlab file format (double,float,int,short) to doubles.
Input data format is given by 'itype'.

'itype' is 4 digit decimal number of form MOPT, where:

        M       Machine ID: 0=PC,MIPS, 1=Sun, 2=VAX, 3=VAX G-FLOAT
        O       0=column-major order    1=row-major order
        P       0 8-byte floating-point
                1 4-byte floating-point
                2 32-bit signed integer
                3 16-bit signed integer
                4 16-bit unsigned integer
                5 8-bit unsigned integer
        T       0=numerical data        1=string

Returns nonzero on failure.
******************************************************************************/

int
mlpromote(itype,mrows,ncols,imagf,ire,iim)
int itype,mrows,ncols,imagf;
void **ire,**iim;
{
   int dsize,otype,N,M,O,P,T;
   void *ore=NULL,*oim=NULL;

   N=mrows*ncols;
   dsize=mltype(itype,&M,&O,&P,&T);
   if (dsize==sizeof(double))
      return 0;

   otype=M*1000+O*100+ML_DOUBLE+T;

   if ((ore=malloc(N*sizeof(double)))==NULL)
      return 1;
   if (mlcast(*ire,ore,N,itype,otype))
      return 2;
   free(*ire);
   *ire=ore;

   if (imagf) {
      if ((oim=malloc(N*sizeof(double)))==NULL)
         return 1;
      if (mlcast(*iim,oim,N,itype,otype))
         return 2;
      free(*iim);
      *iim=oim;
   }

   return 0;
}