esps_utils.cc

Go to the documentation of this file.

/*************************************************************************/
/*                                                                       */
/*                Centre for Speech Technology Research                  */
/*                     University of Edinburgh, UK                       */
/*                   Copyright (c) 1994,1995,1996                        */
/*                        All Rights Reserved.                           */
/*                                                                       */
/*  Permission is hereby granted, free of charge, to use and distribute  */
/*  this software and its documentation without restriction, including   */
/*  without limitation the rights to use, copy, modify, merge, publish,  */
/*  distribute, sublicense, and/or sell copies of this work, and to      */
/*  permit persons to whom this work is furnished to do so, subject to   */
/*  the following conditions:                                            */
/*   1. The code must retain the above copyright notice, this list of    */
/*      conditions and the following disclaimer.                         */
/*   2. Any modifications must be clearly marked as such.                */
/*   3. Original authors' names are not deleted.                         */
/*   4. The authors' names are not used to endorse or promote products   */
/*      derived from this software without specific prior written        */
/*      permission.                                                      */
/*                                                                       */
/*  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        */
/*  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      */
/*  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   */
/*  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     */
/*  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    */
/*  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   */
/*  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          */
/*  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       */
/*  THIS SOFTWARE.                                                       */
/*                                                                       */
/*************************************************************************/
/*                    Author :  Alan W Black (and Paul Taylor)           */
/*                    Date   :  June 1996                                */
/*-----------------------------------------------------------------------*/
/*  These routines form a basis for reading and writing Entropic's ESPS  */
/*  headered files.  The reason we wrote them was to avoid including     */
/*  Entropic's own (large and cumbersome) code into all our programs.    */
/*  No Entropic proprietary code is included in this code which means    */
/*  you do not needs an Entropic licence to use it.                      */
/*                                                                       */
/*  However this should not be seen as anti-Entropic in anyway it is for */
/*  our and your convenience.  We would like to specifically thank       */
/*  Rodney Johnson of Entropic for giving us help and confirming to us   */
/*  the header format is in fact more complex than one can imagine,      */
/*  mostly for very bad reasons, (backward compatibility cripples all    */
/*  software in the long run).  Hence this code is almost definitely     */
/*  incomplete and is not guaranteed to read or create all ESPS files    */
/*  properly but it is adequate for many tasks.                          */
/*                                                                       */
/*  Also thanks go to Peter Kabal from McGill University whose AF code   */
/*  showed me this might be worth attempting, his code gave me something */
/*  to look at to start with.                                            */
/*                                                                       */
/*  I should add, this wasn't easy to write, though I'm much better at   */
/*  octal and hex dumps now.                                             */
/*=======================================================================*/
#include <cstdio>
#include <cstdlib>
#include "EST_unix.h"
#include <cstring>
#include <ctime>
#include "EST_wave_utils.h"
#include "esps_utils.h"
#include "EST_File.h"

using namespace std;

/* First you must realise there is in fact a number of very similar but */
/* subtly different header formats that appear on ESPS files.           */
/* ESPS_FEA and ESPS_SD (others for filters, spectrograms, etc)         */
/* The basic format is                                                  */
/*     preamble                                                         */
/*     fixed header                                                     */
/*     variable header                                                  */
/*        field descriptions (type and dimensions)                      */
/*        field names                                                   */
/*        header FEAs (maybe with values)                               */
/*        old and foreign headers (mostly ignored here)                 */
/*     data records themselves                                          */

/* esps_fea contain a name and possibly a value.  They appear in the    */
/* variable part of the header                                          */
esps_fea new_esps_fea()
{
    esps_fea r = walloc(struct ESPS_FEA_struct,1);
    r->type = 0;
    r->clength = 0;
    r->name = NULL;
    r->dtype = 0;
    r->count = 0;
    r->v.ival = NULL;
    return r;
}

void delete_esps_fea(esps_fea r)
{
    esps_fea t,u;

    for (t=r; t != NULL; t=u)
    {
    if (t->clength != 0)
        wfree(t->name);
    if (t->count != 0) /* this wont work if fields in v aren't aligned */
        wfree(t->v.ival);
    u = t->next;
    wfree(t);
    }
}

void print_esps_fea(esps_fea r)
{
    /* Print out the information in the FEA record */
    int i;
    
    fprintf(stdout,"type:  %d\n",r->type);
    fprintf(stdout,"name:  %s\n",r->name);
    fprintf(stdout,"size:  %d\n",r->count);
    fprintf(stdout,"dtype: %d\n",r->dtype);
    for (i=0; i<r->count; i++)
    switch (r->dtype)
    {
      case ESPS_DOUBLE:
        fprintf(stdout," %d: %g\n",i,r->v.dval[i]); break;
      case ESPS_FLOAT:
        fprintf(stdout," %d: %f\n",i,r->v.fval[i]); break;
      case ESPS_INT:
        fprintf(stdout," %d: %d\n",i,r->v.ival[i]); break;
      case ESPS_SHORT:
        fprintf(stdout," %d: %d\n",i,r->v.sval[i]); break;
      case ESPS_CHAR:
        fprintf(stdout," %d: %d\n",i,r->v.cval[i]); break;
      default:
        fprintf(stdout," %d: unknown\n",i);
    }
}

void add_field(esps_hdr hdr, const char *name, int type, int dimension)
{
    /* Add a new field to the record */
    char **names = hdr->field_name;
    short *types = hdr->field_type;
    int *dims = hdr->field_dimension;
    int i;

    hdr->field_name = walloc(char *,hdr->num_fields+1);
    hdr->field_type = walloc(short,hdr->num_fields+1);
    hdr->field_dimension = walloc(int,hdr->num_fields+1);
    for (i=0; i < hdr->num_fields; i++)
    {
    hdr->field_name[i] = names[i];
    hdr->field_type[i] = types[i];
    hdr->field_dimension[i] = dims[i];
    }
    wfree(names);
    wfree(types);
    wfree(dims);
    hdr->field_name[hdr->num_fields] = wstrdup(name);
    hdr->field_type[hdr->num_fields] = type;
    hdr->field_dimension[hdr->num_fields] = dimension;
    hdr->num_fields++;

    return;

}

void add_fea_d(esps_hdr hdr,const char *name, int pos, double d)
{
    /* Add a double FEA field to the header */
    esps_fea t = new_esps_fea();
    int i;

    t->type = 13;  /* must be lucky for some !! */
    t->clength = strlen(name);
    t->name = wstrdup(name);
    if (t->count < pos+1)
    {
    double *dval = t->v.dval;
    t->v.dval = walloc(double,pos+1);
    for (i=0; i<t->count; i++)
        t->v.dval[i] = dval[i];
    for (; i < pos+1; i++)
        t->v.dval[i] = 0.0;
    wfree(dval);
    t->count = pos+1;
    }
    t->dtype = ESPS_DOUBLE;
    if (pos >= 0)
      t->v.dval[pos] = d;

    t->next = hdr->fea;
    hdr->fea = t;

    return;
}

void add_fea_f(esps_hdr hdr,const char *name, int pos, float d)
{
    /* Add a float FEA field to the header */
    esps_fea t = new_esps_fea();
    int i;

    t->type = 13;
    t->clength = strlen(name);
    t->name = wstrdup(name);
    if (t->count < pos+1)
    {
    float *fval = t->v.fval;
    t->v.fval = walloc(float,pos+1);
    for (i=0; i<t->count; i++)
        t->v.fval[i] = fval[i];
    for (; i < pos+1; i++)
        t->v.fval[i] = 0.0;
    wfree(fval);
    t->count = pos+1;
    }
    t->dtype = ESPS_FLOAT;
    t->v.fval[pos] = d;

    t->next = hdr->fea;
    hdr->fea = t;

    return;
}

void add_fea_i(esps_hdr hdr,const char *name, int pos, int d)
{
    /* Add an int FEA field to the header */
    esps_fea t = new_esps_fea();
    int i;

    t->type = 13;
    t->clength = strlen(name);
    t->name = wstrdup(name);
    if (pos < 0) {
        fprintf(stderr, "%s", "ESPS: add_fea_i: pos should not be < 0\n");
        delete_esps_fea(t);
        return;
    }
    if (pos == INT_MAX) {
        fprintf(stderr, "%s", "ESPS: add_fea_i: pos too large\n");
        pos -=1;
    }
    if (t->count < pos+1)
    {
      int *ival = t->v.ival;
      t->v.ival = walloc(int,pos+1);
      for (i=0; i<t->count; i++)
        t->v.ival[i] = ival[i];
      for (; i < pos+1; i++)
        t->v.ival[i] = 0;
      wfree(ival);
      t->count = pos+1;
    }
    t->dtype = ESPS_INT;
    t->v.ival[pos] = d;

    t->next = hdr->fea;
    hdr->fea = t;

    return;
}

void add_fea_s(esps_hdr hdr,const char *name, int pos, short d)
{
    /* Add a short FEA field to the header */
    esps_fea t = new_esps_fea();
    int i;

    t->type = 13;
    t->clength = strlen(name);
    t->name = wstrdup(name);
    if (t->count < pos+1)
    {
    short *sval = t->v.sval;
    t->v.sval = walloc(short,pos+1);
    for (i=0; i<t->count; i++)
        t->v.sval[i] = sval[i];
    for (; i < pos+1; i++)
        t->v.sval[i] = (short)0;
    wfree(sval);
    t->count = pos+1;
    }
    t->dtype = ESPS_SHORT;
    t->v.sval[pos] = d;

    t->next = hdr->fea;
    hdr->fea = t;

    return;
}

void add_fea_c(esps_hdr hdr,const char *name, int pos, char d)
{
    /* Add a char FEA field to the header */
    esps_fea t = new_esps_fea();
    int i;

    t->type = 13;
    t->clength = strlen(name);
    t->name = wstrdup(name);
    if (t->count < pos+1)
    {
    char *cval = t->v.cval;
    t->v.cval = walloc(char,pos+1);
    for (i=0; i<t->count; i++)
        t->v.cval[i] = cval[i];
    for (; i < pos+1; i++)
        t->v.cval[i] = (char)0;
    wfree(cval);
    t->count = pos+1;
    }
    t->dtype = ESPS_CHAR;
    t->v.cval[pos] = d;

    t->next = hdr->fea;
    hdr->fea = t;

    return;
}

void add_fea_special(esps_hdr hdr,int type,const char *name)
{
    /* Add a special FEA field to the header */
    esps_fea t = new_esps_fea();

    t->type = type;
    t->clength = strlen(name);
    t->name = wstrdup(name);
    t->count = 0;
    
    t->next = hdr->fea;
    hdr->fea = t;

    return;
}

int fea_value_d(const char *name,int pos,esps_hdr hdr, double *d)
{
    /* Get value of double FEA */
    esps_fea t;
    
    for (t=hdr->fea; t != NULL; t=t->next)
    if (streq(name,t->name))
    {
        if (t->dtype != ESPS_DOUBLE)
        {
        fprintf(stderr,"ESPS hdr: access non-double field \"%s\" as double\n",
            name);
        return -1;
        }
        *d = t->v.dval[pos];
        return 0;
    }

    return -1;  /* failed to find it */
}

int fea_value_f(const char *name,int pos,esps_hdr hdr, float *d)
{
    /* Get value of float FEA */
    esps_fea t;
    
    for (t=hdr->fea; t != NULL; t=t->next)
    if (streq(name,t->name))
    {
        if (t->dtype != ESPS_FLOAT)
        {
        fprintf(stderr,"ESPS hdr: access non-float field \"%s\" as float\n",
            name);
        return -1;
        }
        *d = t->v.fval[pos];
        return 0;
    }

    return -1;  /* failed to find it */
}

int fea_value_s(const char *name,int pos,esps_hdr hdr, short *d)
{
    /* Get value of short FEA */
    esps_fea t;
    
    for (t=hdr->fea; t != NULL; t=t->next)
    if (streq(name,t->name))
    {
        if (t->dtype != ESPS_SHORT)
        {
        fprintf(stderr,"ESPS hdr: access non-short field \"%s\" as short\n",
            name);
        return -1;
        }
        *d = t->v.sval[pos];
        return 0;
    }

    return -1;  /* failed to find it */
}

int fea_value_i(const char *name,int pos,esps_hdr hdr, int *d)
{
    /* Get value of int FEA */
    esps_fea t;
    
    for (t=hdr->fea; t != NULL; t=t->next)
    if (streq(name,t->name))
    {
        if (t->dtype != ESPS_INT)
        {
        fprintf(stderr,"ESPS hdr: access non-int field \"%s\" as int\n",
            name);
        return -1;
        }
        *d = t->v.ival[pos];
        return 0;
    }

    return -1;  /* failed to find it */
}

int fea_value_c(const char *name,int pos,esps_hdr hdr, char *d)
{
    /* Get value of int FEA */
    esps_fea t;
    
    for (t=hdr->fea; t != NULL; t=t->next)
    if (streq(name,t->name))
    {
        if (t->dtype != ESPS_CHAR)
        {
        fprintf(stderr,"ESPS hdr: access non-char field \"%s\" as char\n",
            name);
        return -1;
        }
        *d = t->v.cval[pos];
        return 0;
    }

    return -1;  /* failed to find it */
}

static int esps_alloc_fea(esps_fea r)
{
    switch (r->dtype)
    {
      case 0: /* nothing */
    break;
      case ESPS_DOUBLE:
    r->v.dval = walloc(double,r->count); break;
      case ESPS_FLOAT:
    r->v.fval = walloc(float,r->count); break;
      case ESPS_INT:
    r->v.ival = walloc(int,r->count); break;
      case ESPS_SHORT:
    r->v.sval = walloc(short,r->count); break;
      case ESPS_CHAR:
    r->v.cval = walloc(char,r->count); break;
      default:
    fprintf(stderr,"ESPS file: unsupported FEA dtype\n");
    return -1;
    }

    return 0;
}

void write_esps_fea(FILE *fd, esps_fea t,esps_hdr hdr)
{
    /* write out this fea */
    (void)hdr;
    short clength;
    char *nspace;
    int i;

    fwrite(&t->type,2,1,fd);
    clength = (strlen(t->name)+3)/4;
    fwrite(&clength,2,1,fd);
    nspace = walloc(char, clength*4);
    memset(nspace,0,clength*4);
    memmove(nspace,t->name,strlen(t->name));
    fwrite(nspace,1,clength*4,fd);
    wfree(nspace);
    if ((t->type == 11) ||
    (t->type == 1) ||
    (t->type == 15))
    return;
    fwrite(&t->count,4,1,fd);
    fwrite(&t->dtype,2,1,fd);
    
    for (i=0; i<t->count; i++)
    {
    switch(t->dtype)
    {
      case ESPS_DOUBLE: 
        fwrite(&t->v.dval[i],8,1,fd); break;
      case ESPS_FLOAT: 
        fwrite(&t->v.fval[i],4,1,fd); break;
      case ESPS_INT: 
        fwrite(&t->v.ival[i],4,1,fd); break;
      case ESPS_SHORT: 
        fwrite(&t->v.sval[i],2,1,fd); break;
      case ESPS_CHAR: 
        fwrite(&t->v.cval[i],1,1,fd); break;
      default:
        fprintf(stderr,"ESPS write_hdr: unsupported FEA dtype %d\n",
            t->dtype);
    }
    }
    return;
}

int write_esps_rec(esps_rec r, esps_hdr h, FILE *fd)
{
    /* will have to worry about swap someday */
    (void)h;
    int i;

    for (i=0; i < r->num_fields; i++)
    {
    switch(r->field[i]->type)
    {
      case ESPS_DOUBLE:
        fwrite(r->field[i]->v.dval,8,r->field[i]->dimension,fd);
        break;
      case ESPS_FLOAT:
        fwrite(r->field[i]->v.fval,4,r->field[i]->dimension,fd);
        break;
      case ESPS_INT:
        fwrite(r->field[i]->v.ival,4,r->field[i]->dimension,fd);
        break;
      case ESPS_SHORT:
        fwrite(r->field[i]->v.sval,2,r->field[i]->dimension,fd);
        break;
      case ESPS_CHAR:
        fwrite(r->field[i]->v.cval,1,r->field[i]->dimension,fd);
        break;
      case ESPS_CODED:
        fwrite(r->field[i]->v.sval,2,r->field[i]->dimension,fd);
        break;

      default:
        fprintf(stderr,"ESPS file: unsupported field type %d\n",
            r->field[i]->type);
    }
    }
    return 0;
}

esps_fea read_esps_fea(FILE *fd, esps_hdr hdr)
{
    /* read next FEA record at point */
    esps_fea r = new_esps_fea();
    short sdata;
    int i;
    int idata;
    float fdata;
    double ddata;
    char cdata;
    int err=0;
    if (fread(&sdata,sizeof(short),1,fd) != 1) err = 1;
    if (hdr->swapped) sdata = SWAPSHORT(sdata);
    r->type = sdata;
    if (r->type == 0)              /* a field name */
    {   /* next short is the size in bytes */
    if (fread(&sdata,sizeof(short),1,fd) != 1) err = 1;
    if (hdr->swapped) sdata = SWAPSHORT(sdata);
    if (sdata < 0 || sdata > SHRT_MAX -1) {
        fprintf(stderr, "ESPS: fea record wrong size\n");
        wfree(r);
        return NULL;        
    }
    r->clength = sdata;
    }
    else if ((r->type == 13) ||   /* a feature and value */
             (r->type == 11) ||   /* a single string (comment ?) */
             (r->type == 1)  ||   /* a filename */
             (r->type == 4)  ||   /* a filename */
         (r->type == 15))     /* directory name */
    {                 
    if (fread(&sdata,sizeof(short),1,fd) != 1) err = 1;
    if (hdr->swapped) sdata = SWAPSHORT(sdata);
    if (sdata > SHRT_MAX/4) {
        fprintf(stderr, "ESPS: fea record too large\n");
        wfree(r);
        return NULL;
    }
    if (sdata < 0) {
        fprintf(stderr, "ESPS: fea record too small\n");
        wfree(r);
        return NULL;
    }
    r->clength = sdata * 4;
    if (r->clength > SHRT_MAX -1) {
        fprintf(stderr, "ESPS: fea record wrong size\n");
        wfree(r);
        return NULL;
    }
    }
    else
    {
    fprintf(stderr,"ESPS: fea record unknown type\n");
    wfree(r);
    return NULL;
    }
    r->name = walloc(char,r->clength+1);
    if (fread(r->name,sizeof(char),r->clength,fd) != (size_t) r->clength) err=1;
    r->name[r->clength] = '\0';
    if ((r->type == 11) ||       /* a single string */
    (r->type == 1)  ||       /* a filename */
    (r->type == 15))         /* directory name */
    return r;  
    if (fread(&idata,sizeof(int),1,fd) != 1) err = 1;
    if (hdr->swapped) idata = SWAPINT(idata);
    if (idata < 0 ) {
        fprintf(stderr, "ESPS: negative r->count: Bad header\n");
        wfree(r);
        return NULL;
    }
    r->count = idata;
    if (fread(&sdata,sizeof(short),1,fd) != 1) err = 1;
    if (hdr->swapped) sdata = SWAPSHORT(sdata);
    r->dtype = sdata;
    if (esps_alloc_fea(r) == -1) {
        wfree(r->name);
        wfree(r);
        return NULL;
    }
    for (i=0; i<r->count; i++)
    {
    switch (r->dtype)
    {
      case ESPS_DOUBLE:
        if (fread(&ddata,sizeof(double),1,fd) != 1) err=1;
        if (hdr->swapped) swapdouble(&ddata);
        r->v.dval[i] = ddata;
        break;
      case ESPS_FLOAT:
        if (fread(&fdata,sizeof(float),1,fd) != 1) err=1;
        if (hdr->swapped) swapfloat(&fdata);
        r->v.fval[i] = fdata;
        break;
      case ESPS_INT:
        if (fread(&idata,sizeof(int),1,fd) != 1) err = 1;
        if (hdr->swapped) idata = SWAPINT(idata);
        r->v.ival[i] = idata;
        break;
      case ESPS_SHORT:
        if (fread(&sdata,sizeof(short),1,fd) != 1) err=1;
        if (hdr->swapped) sdata = SWAPSHORT(sdata);
        r->v.sval[i] = sdata;
        break;
      case ESPS_CHAR:
        if (fread(&cdata,sizeof(char),1,fd) != 1) err=1;
        r->v.cval[i] = cdata;
        break;
      default:
        fprintf(stderr,"ESPS read_hdr: unsupported FEA dtype %d\n",r->dtype);
        wfree(r);
        return NULL;
    }
    }
    if (err==1) {
        fprintf(stderr, "ESPS read_hdr: Wrong format\n");
        wfree(r);
        return NULL;
    }

    return r;
}    

static char *esps_get_field_name(FILE *fd, esps_hdr hdr, int expect_source)
{
    /* read the next field name */
  short size=0;  /* bet its really a short */
  char *name;
  
  if (fread(&size,2,1,fd) != 1)
    {
      fputs("error reading field name size\n", stderr);
      return wstrdup("ERROR");
    }
  if (hdr->swapped) size = SWAPSHORT(size);
  if (size < 0 || size > SHRT_MAX -1) {
      fputs("error reading field size\n", stderr);
      return wstrdup("ERROR");
  }
  name = walloc(char, size+1);
  if (fread(name,1,size,fd) != (unsigned)size)
    {
      fputs("error reading field name\n", stderr);
      strncpy(name, "ERROR", size);
    }
  name[size] = '\0';
  if (hdr->file_type == ESPS_SD || expect_source) {
    if (fseek(fd,6,SEEK_CUR) != 0) {  /* skip some zeroes */
        fputs("error skipping some zeroes", stderr);
        wfree(name);
        return wstrdup("ERROR");
    }
  }  else {
    if (fseek(fd,2,SEEK_CUR) != 0){  /* skip some zeroes */
        fputs("error skipping some zeroes", stderr);
        wfree(name);
        return wstrdup("ERROR");
    }
  }

  if (expect_source)
    {
      if (fread(&size,sizeof(short),1,fd) != 1) {
          fprintf(stderr, "ESPS: wrong field format\n");
          wfree(name);
          return NULL;
      }
      if (hdr->swapped) size = SWAPSHORT(size);
      if (EST_fseek(fd,size,SEEK_CUR) != 0) {
        fprintf(stderr, "esps read error\n");
        wfree(name);
        return NULL;
    }
    }

  return name;
}

static void esps_put_field_name(char *name,FILE *fd, esps_hdr hdr)
{
    /* write the next field name */
    short size = strlen(name);
    short shortdata;

    shortdata = 0;
    fwrite(&shortdata,2,1,fd);
    fwrite(&size,2,1,fd);
    fwrite(name,1,size,fd);
    if (hdr->file_type == ESPS_SD)
    {
    shortdata = 0;
    fwrite(&shortdata,2,1,fd);
    fwrite(&shortdata,2,1,fd);
    fwrite(&shortdata,2,1,fd);
    }
    return;
}

esps_hdr new_esps_hdr(void)
{
    esps_hdr h = walloc(struct ESPS_HDR_struct,1);
    h->file_type = ESPS_FEA;
    h->swapped = FALSE;
    h->num_records = 0;
    h->num_fields = 0;
    h->field_name = NULL;
    h->field_type = NULL;
    h->field_dimension = NULL;
    h->fea = NULL;
    return h;
}

void delete_esps_hdr(esps_hdr h)
{
    int i;
    if (h != NULL)
    {
    if (h->field_name != NULL)
    {
        for (i=0; i < h->num_fields; i++)
        wfree(h->field_name[i]);
        wfree(h->field_name);
    }
    delete_esps_fea(h->fea);
    }
}

esps_rec new_esps_rec(const esps_hdr hdr)
{
    /* New esps record */
    esps_rec r = walloc(struct ESPS_REC_struct,1);
    int i,size;

    r->field = walloc(esps_field,hdr->num_fields);
    for (size=0,i=0; i < hdr->num_fields; i++)
    {
    r->field[i]=walloc(struct ESPS_FIELD_struct,1);
    r->field[i]->type = hdr->field_type[i];
    r->field[i]->dimension = hdr->field_dimension[i];
    switch(r->field[i]->type)
    {
      case ESPS_DOUBLE:
        r->field[i]->v.dval = walloc(double,r->field[i]->dimension);
        size += 8;
        break;
      case ESPS_FLOAT:
        r->field[i]->v.fval = walloc(float,r->field[i]->dimension);
        size += 4;
        break;
      case ESPS_INT:
        r->field[i]->v.ival = walloc(int,r->field[i]->dimension);
        size += 4;
        break;
      case ESPS_SHORT:
        r->field[i]->v.sval = walloc(short,r->field[i]->dimension);
        size += 2;
        break;
      case ESPS_CHAR:
        r->field[i]->v.cval = walloc(char,r->field[i]->dimension);
        size += 1;
        break;
      case ESPS_CODED:
        r->field[i]->v.sval = walloc(short,r->field[i]->dimension);
        size += 2;
        break;
      default:
        fprintf(stderr,"ESPS file: unsupported field type %d\n",
            r->field[i]->type);
    }
    }
    r->num_fields = hdr->num_fields;
    r->size = size;
    return r;

}

void delete_esps_rec(esps_rec r)
{
    int i;

    for (i=0; i<r->num_fields; i++)
    {
    wfree(r->field[i]->v.ival);
    wfree(r->field[i]);
    }
    wfree(r->field);
    /* wfree(r); (already freed on delete_esps_hdr) */
    return;
}

int read_esps_rec(esps_rec r, esps_hdr hdr, FILE *fd)
{
    /* read the next record at point */
    int i,j;
    double doubledata;
    float floatdata;
    int intdata;
    short shortdata;
    
    for (i=0; i< r->num_fields; i++)
    {
    switch (r->field[i]->type)
    {
      case ESPS_DOUBLE:
        for(j=0; j < r->field[i]->dimension; j++)
        {
        if (fread(&doubledata,8,1,fd) != 1) return EOF;
        if (hdr->swapped) swapdouble(&doubledata);
        r->field[i]->v.dval[j] = doubledata;
        }
        break;
      case ESPS_FLOAT:
        for(j=0; j < r->field[i]->dimension; j++)
        {
        if (fread(&floatdata,4,1,fd) != 1) return EOF;
        if (hdr->swapped) swapfloat(&floatdata);
        r->field[i]->v.fval[j] = floatdata;
        }
        break;
      case ESPS_INT:
        for(j=0; j < r->field[i]->dimension; j++)
        {
        if (fread(&intdata,4,1,fd) != 1) return EOF;
        if (hdr->swapped) intdata = SWAPINT(intdata);
        r->field[i]->v.ival[j] = intdata;
        }
        break;
      case ESPS_SHORT:
        for(j=0; j < r->field[i]->dimension; j++)
        {
        if (fread(&shortdata,2,1,fd) != 1) return EOF;
        if (hdr->swapped) shortdata = SWAPSHORT(shortdata);
        r->field[i]->v.sval[j] = shortdata;
        }
        break;
      case ESPS_CHAR:
        if (fread(r->field[i]->v.cval,1,r->field[i]->dimension,fd) !=
        (unsigned)r->field[i]->dimension) return EOF;
        break;
      case ESPS_CODED:
        for(j=0; j < r->field[i]->dimension; j++)
        {
        if (fread(&shortdata,2,1,fd) != 1) return EOF;
        if (hdr->swapped) shortdata = SWAPSHORT(shortdata);
        r->field[i]->v.sval[j] = shortdata;
        }
        break;
      default:
        fprintf(stderr,"ESPS file: unsupported field type %d\n",
            r->field[i]->type);
        return EOF;
    }

    }
    
    return 0;

}

double get_field_d(esps_rec r, int field, int pos)
{
    return r->field[field]->v.dval[pos];
}
float get_field_f(esps_rec r, int field, int pos)
{
    return r->field[field]->v.fval[pos];
}
int get_field_i(esps_rec r, int field, int pos)
{
    return r->field[field]->v.ival[pos];
}
short get_field_s(esps_rec r, int field, int pos)
{
    return r->field[field]->v.sval[pos];
}
char get_field_c(esps_rec r, int field, int pos)
{
    return r->field[field]->v.cval[pos];
}
void set_field_d(esps_rec r, int field, int pos, double d)
{
    r->field[field]->v.dval[pos] = d;
}
void set_field_f(esps_rec r, int field, int pos, float d)
{
    r->field[field]->v.fval[pos] = d;
}
void set_field_i(esps_rec r, int field, int pos, int d)
{
    r->field[field]->v.ival[pos] = d;
}
void set_field_s(esps_rec r, int field, int pos, short d)
{
    r->field[field]->v.sval[pos] = d;
}
void set_field_c(esps_rec r, int field, int pos, char d)
{
    r->field[field]->v.cval[pos] = d;
}

int esps_record_size(esps_hdr hdr)
{
    /* works out the number of bytes in a record */
    esps_rec r = new_esps_rec(hdr);
    int size = r->size;
    delete_esps_rec(r);
    wfree(r);
    return size;
}

static int esps_num_of_type(int type,esps_hdr hdr)
{
    /* counts up the number of occurrences of fields of type in a record */
    int i;
    int sum;

    for (sum=i=0; i < hdr->num_fields; i++)
    if (hdr->field_type[i] == type)
        sum++;
    return sum;
}    


esps_hdr make_esps_sd_hdr(void)
{
    /* returns a basic header for an ESPS_SD file */
    esps_hdr hdr = new_esps_hdr();
    hdr->file_type = ESPS_SD;
    return hdr;

}

esps_hdr make_esps_hdr(void)
{
    /* returns a basic header for an ESPS_SD file */
    esps_hdr hdr = new_esps_hdr();
    hdr->file_type = ESPS_FEA;
    return hdr;

}

enum EST_read_status read_esps_hdr(esps_hdr *uhdr,FILE *fd)
{
    /* reads an ESPS header from fd at point (should be position 0) */
    /* leaves point at start of data (immediately after header)     */
    struct ESPS_PREAMBLE preamble;
    struct ESPS_FIXED_HDR fhdr;
    esps_hdr hdr;
    EST_FilePos pos, end;
    int intdata,i;
    short shortdata;
    double sd_sample_rate;
    int typematch;
    int swap;
    short name_flag;
    int err = 0;
    if (fread(&(preamble.machine_code), sizeof(int), 1, fd) != 1) err=1;
    if (fread(&(preamble.check_code), sizeof(int), 1, fd) != 1) err=1;
    if (fread(&(preamble.data_offset), sizeof(int), 1, fd) != 1) err=1;
    if (fread(&(preamble.record_size), sizeof(int), 1, fd) != 1) err=1;
    if (fread(&(preamble.check), sizeof(int), 1, fd) != 1) err=1;
    if (fread(&(preamble.edr), sizeof(int), 1, fd) != 1) err=1;
    if (fread(&(preamble.fil1), sizeof(int), 1, fd) != 1) err=1;
    if (fread(&(preamble.foreign_hd), sizeof(int), 1, fd) != 1) err=1;
    if (preamble.check == ESPS_MAGIC)
    swap = FALSE;
    else if (preamble.check == SWAPINT(ESPS_MAGIC))
    swap = TRUE;
    else
    return wrong_format;

    hdr = new_esps_hdr();
    hdr->swapped = swap;
    if (fread(&(fhdr.thirteen), sizeof(short), 1, fd) != 1) err=1;
    if (fread(&(fhdr.sdr_size), sizeof(short), 1, fd) != 1) err=1;
    if (fread(&(fhdr.magic), sizeof(int), 1, fd) != 1) err=1;
    if (fread(&(fhdr.date), sizeof(char), 26, fd) != 26) err=1;
    if (fread(&(fhdr.version), sizeof(char), 8, fd) != 8) err=1;
    if (fread(&(fhdr.prog), sizeof(char), 16, fd) != 16) err=1;
    if (fread(&(fhdr.vers), sizeof(char), 8, fd) != 8) err=1;
    if (fread(&(fhdr.progcompdate), sizeof(char), 26, fd) != 26) err=1;
    if (fread(&(fhdr.num_samples), sizeof(int), 1, fd) != 1) err=1;
    if (fread(&(fhdr.filler), sizeof(int), 1, fd) != 1) err=1;
    if (fread(&(fhdr.num_doubles), sizeof(int), 1, fd) != 1) err=1;
    if (fread(&(fhdr.num_floats), sizeof(int), 1, fd) != 1) err=1;
    if (fread(&(fhdr.num_ints), sizeof(int), 1, fd) != 1) err=1;
    if (fread(&(fhdr.num_shorts), sizeof(int), 1, fd) != 1) err=1;
    if (fread(&(fhdr.num_chars), sizeof(int), 1, fd) != 1) err=1;
    if (fread(&(fhdr.fsize), sizeof(int), 1, fd) != 1) err=1;
    if (fread(&(fhdr.hsize), sizeof(int), 1, fd) != 1) err=1;
    if (fread(&(fhdr.username), sizeof(char), 8, fd) != 8) err=1;
    if (fread(&(fhdr.fil1), sizeof(int), 5, fd) != 5) err=1;
    if (fread(&(fhdr.fea_type), sizeof(short), 1, fd) != 1) err=1;
    if (fread(&(fhdr.fil2), sizeof(short), 1, fd) != 1) err=1;
    if (fread(&(fhdr.num_fields), sizeof(short), 1, fd) != 1) err=1;
    if (fhdr.num_fields < 0 || fhdr.num_fields > SHRT_MAX -1 ) {
        cerr << "Wrong ESPS header: Wrong number of fields" << endl;
        fhdr.num_fields = 0;
        delete_esps_hdr(hdr);
        wfree(hdr);
        return wrong_format;
    }
    if (fread(&(fhdr.fil3), sizeof(short), 1, fd) != 1) err=1;
    if (fread(&(fhdr.fil4), sizeof(int), 9, fd) != 9) err=1;
    if (fread(&(fhdr.fil5), sizeof(int), 8, fd) != 8) err=1;

    if (err == 1)
    {
        cerr << "Could not read ESPS header." << endl;
        cerr << "Wrong format" << endl;
        delete_esps_hdr(hdr);
        wfree(hdr);
        return wrong_format;
    }
    
    if (hdr->swapped) 
    {
    preamble.data_offset = SWAPINT(preamble.data_offset);
    preamble.record_size = SWAPINT(preamble.record_size);
    fhdr.num_samples = SWAPINT(fhdr.num_samples);
    fhdr.num_doubles = SWAPINT(fhdr.num_doubles);
    fhdr.num_floats = SWAPINT(fhdr.num_floats);
    fhdr.num_ints = SWAPINT(fhdr.num_ints);
    fhdr.num_shorts = SWAPINT(fhdr.num_shorts);
    fhdr.num_chars = SWAPINT(fhdr.num_chars);
    fhdr.fea_type = SWAPSHORT(fhdr.fea_type);
    fhdr.num_fields = SWAPSHORT(fhdr.num_fields);
    }
    if (fhdr.num_samples == 0)  /* has to be derived from the file size */
    {
    pos = EST_ftell(fd);
    if (pos < 0) {
        delete_esps_hdr(hdr);
        wfree(hdr);
        return misc_read_error;
    }
    if (EST_fseek(fd,0,SEEK_END) != 0) {
        delete_esps_hdr(hdr);
        wfree(hdr);
        return misc_read_error;
    }
    end = EST_ftell(fd);
    if (end < 0) {
        delete_esps_hdr(hdr);
        wfree(hdr);
        return misc_read_error;
    }
    if (EST_fseek(fd,pos,SEEK_SET) != 0) {
        delete_esps_hdr(hdr);
        wfree(hdr);
        return misc_read_error;
    }
    if (preamble.data_offset < 0) { /* Nonsense */
        delete_esps_hdr(hdr);
        wfree(hdr);
        return misc_read_error;
    }
    fhdr.num_samples = (end - preamble.data_offset)/preamble.record_size;
    }
    hdr->num_records = fhdr.num_samples;
    hdr->num_fields = fhdr.num_fields;
    hdr->hdr_size = preamble.data_offset;
    if (fhdr.thirteen == 9)
    {   /* esps identifies such files are as Sample Data Files */
    hdr->file_type = ESPS_SD;
    /* fake the rest to make it appear like other SD files */
    hdr->num_fields = 1;
    hdr->field_dimension = walloc(int,hdr->num_fields);
    hdr->field_dimension[0] = 1;
    hdr->field_type = walloc(short,hdr->num_fields);
    hdr->field_type[0] = ESPS_SHORT;
    hdr->field_name = walloc(char *,1);
    hdr->field_name[0] = wstrdup("samples");
    if (EST_fseek(fd,hdr->hdr_size,SEEK_SET) != 0) {
        delete_esps_hdr(hdr);
        wfree(hdr);
        return misc_read_error;        
    }
    /* In this cases its just in the header as a float */
    float *tmpfloat = (float *)&fhdr.fil4[0];
    sd_sample_rate = *tmpfloat;
    add_fea_d(hdr,"record_freq",0,(double)sd_sample_rate);
    *uhdr = hdr;
    return format_ok;
    }
    else if ((fhdr.fea_type == 8) &&
         (hdr->num_fields == 1) &&
         ((fhdr.num_shorts*2) == preamble.record_size))
    hdr->file_type = ESPS_SD;  /* this is a heuristic */
    else
    hdr->file_type = ESPS_FEA;
    /* Now we have the field descriptions */
    
    /* 0000 0001 dimensions */
    hdr->field_dimension = walloc(int,hdr->num_fields);
    for (i=0; i<hdr->num_fields; i++)                   
    {
    if (fread(&intdata,sizeof(int),1,fd) != 1) err = 1;                         /* dimensions */
    if (hdr->swapped) intdata = SWAPINT(intdata);
    hdr->field_dimension[i] = intdata;
    }
    /* 0 -> num_fields-1 -- probably ordering information */
    if (EST_fseek(fd,hdr->num_fields*4,SEEK_CUR) != 0) err = 1;               /* ordering info */
    if (EST_fseek(fd,hdr->num_fields*2,SEEK_CUR) != 0) err = 1;               /* zeros */
    hdr->field_type = walloc(short,hdr->num_fields);    
    for (i=0; i<hdr->num_fields; i++)
    {
    if (fread(&shortdata,sizeof(short),1,fd) != 1) err = 1;                       /* field types */  
    if (hdr->swapped) shortdata = SWAPSHORT(shortdata);
    hdr->field_type[i] = shortdata;
    }
    typematch = TRUE;
    if (fread(&intdata,sizeof(int),1,fd) != 1) err = 1;                         /* number of doubles */
    if (hdr->swapped) intdata = SWAPINT(intdata);
    if (fhdr.num_doubles != intdata) typematch = FALSE;
    if (fread(&intdata,sizeof(int),1,fd) != 1) err = 1;                             /* number of floats */
    if (hdr->swapped) intdata = SWAPINT(intdata);
    if (fhdr.num_floats != intdata) typematch = FALSE;
    if (fread(&intdata,sizeof(int),1,fd) != 1) err = 1;                             /* number of ints */
    if (hdr->swapped) intdata = SWAPINT(intdata);
    if (fhdr.num_ints != intdata) typematch = FALSE;
    if (fread(&intdata,sizeof(int), 1, fd) !=1) err = 1;                             /* number of shorts */
    if (hdr->swapped) intdata = SWAPINT(intdata);
    if (fhdr.num_shorts != intdata) typematch = FALSE;
    if (fread(&intdata,sizeof(int),1,fd) != 1) err = 1;                             /* number of chars */
    if (hdr->swapped) intdata = SWAPINT(intdata);
    if (fhdr.num_chars != intdata) typematch = FALSE;
    if ((hdr->file_type != ESPS_SD) && (typematch == FALSE))
    {
    fprintf(stderr,"ESPS hdr: got lost in the header (record description)\n");
    delete_esps_hdr(hdr);
    wfree(hdr);
    return misc_read_error;
    }
    /* other types ... */
    if (EST_fseek(fd,9*2,SEEK_CUR) != 0) {            /* other types */
        fprintf(stderr, "ESPS hdr: fseek error\n");
        return misc_read_error;
    }
    if (EST_fseek(fd,hdr->num_fields*2,SEEK_CUR) != 0) {    /* zeros */
        fprintf(stderr, "ESPS hdr: fseek error\n");
        return misc_read_error;
    }
    /* Now we can read the field names */
    hdr->field_name = walloc(char *,hdr->num_fields);

    if (fread(&name_flag, sizeof(short), 1, fd) != 1) err = 1;
    if (hdr->swapped) name_flag = SWAPSHORT(name_flag);

    for (i=0; i < hdr->num_fields; i++)
    hdr->field_name[i] = esps_get_field_name(fd,hdr,name_flag); /* field names */
    if (hdr->file_type == ESPS_SD)
    {   /* Only one field 'samples' */
    if (!streq(hdr->field_name[0],"samples"))
    {
        fprintf(stderr,"ESPS hdr: guessed wrong about FEA_SD file (no 'samples' field)\n");
        delete_esps_hdr(hdr);
        wfree(hdr);
        return misc_read_error;
    }
    }

    /* Now fea, feature and value -- but how many are there ? */
    while (EST_ftell(fd) < preamble.data_offset-4)
    {
    esps_fea r = read_esps_fea(fd,hdr);              /* feas */
    if (r == NULL) break;
/*  print_esps_fea(r); */
    r->next = hdr->fea;
    hdr->fea = r;
    if (r->type == 1) 
        break; /* I think this (filename) is last FEA */
    }
    /* There's other gunk after this but I think I've done enough */
    /* The rest seems to be mostly previous headers               */

    if (EST_fseek(fd,hdr->hdr_size,SEEK_SET) != 0) /* skip the rest of the header */
    {
        fprintf(stderr, "ESPS hdr: fseek error\n");        
        delete_esps_hdr(hdr);
        wfree(hdr);
        return misc_read_error;
    }
    *uhdr = hdr;
    
    if (err == 1) {
        fprintf(stderr, "ESPS hdr: wrong format\n");
        return wrong_format;
    }
    
    return format_ok;
}


enum EST_write_status write_esps_hdr(esps_hdr hdr,FILE *fd)
{
    /* well here's the scary part, try to write a valid file hdr to */
    /* the file                                                     */
    struct ESPS_PREAMBLE preamble;
    struct ESPS_FIXED_HDR fhdr;
    time_t tx = time(0);
    esps_fea t;
    int i,intdata;
    short shortdata;

    memset(&preamble,0,sizeof(preamble));
    memset(&fhdr,0,sizeof(fhdr));
    /* I can't really make the machine code work properly, so I'll  */
    /* just fix it for the two major byte orders to Sun and Suni386 */
    if (EST_NATIVE_BO == bo_big)
    preamble.machine_code = 4;  /* a sun */
    else
    preamble.machine_code = 6;  /* a suni386 */
    preamble.check_code  = 3000;  /* ? */
    preamble.data_offset = 0;  /* will come back and fix this later */
    preamble.record_size = esps_record_size(hdr);
    preamble.check = ESPS_MAGIC;
    preamble.edr = 0;
    preamble.fil1 = 0;
    preamble.foreign_hd = 0; /* docs say it should be -1, but its always 0 */

    fhdr.thirteen = 13;      /* must be for luck */
    fhdr.sdr_size = 0;
    fhdr.magic = ESPS_MAGIC;
    strncpy(fhdr.date,ctime(&tx),26);
    fhdr.date[25] = '\0';
    sprintf(fhdr.version,"1.91");  /* that's what all the others have */
    sprintf(fhdr.prog,"EDST");
    sprintf(fhdr.vers,"0.1");
    strncpy(fhdr.progcompdate,ctime(&tx),26);
    fhdr.progcompdate[25] = '\0';
    fhdr.num_samples = hdr->num_records;
    fhdr.filler = 0;
    /* in each record */
    fhdr.num_doubles = esps_num_of_type(ESPS_DOUBLE,hdr);
    fhdr.num_floats  = esps_num_of_type(ESPS_FLOAT,hdr);
    fhdr.num_ints    = esps_num_of_type(ESPS_INT,hdr);
    fhdr.num_shorts  = esps_num_of_type(ESPS_SHORT,hdr);
    fhdr.num_chars   = esps_num_of_type(ESPS_CHAR,hdr);
    fhdr.fsize = 40;
    fhdr.hsize = 0;    /* given value below on second shot */
    if (hdr->file_type == ESPS_SD)
    fhdr.fea_type = 8;
    else
    fhdr.fea_type = 0;
    fhdr.num_fields = hdr->num_fields;


    fwrite(&(preamble.machine_code),sizeof(int),1,fd);
    fwrite(&(preamble.check_code),sizeof(int),1,fd);
    fwrite(&(preamble.data_offset),sizeof(int),1,fd);
    fwrite(&(preamble.record_size),sizeof(int),1,fd);
    fwrite(&(preamble.check),sizeof(int),1,fd);
    fwrite(&(preamble.edr),sizeof(int),1,fd);
    fwrite(&(preamble.fil1),sizeof(int),1,fd);
    fwrite(&(preamble.foreign_hd),sizeof(int),1,fd);


    fwrite(&(fhdr.thirteen),sizeof(short),1,fd);
    fwrite(&(fhdr.sdr_size),sizeof(short),1,fd);
    fwrite(&(fhdr.magic),sizeof(int),1,fd);
    fwrite(&(fhdr.date),sizeof(char),26,fd);
    fwrite(&(fhdr.version),sizeof(char),8,fd);
    fwrite(&(fhdr.prog),sizeof(char),16,fd);
    fwrite(&(fhdr.vers),sizeof(char),8,fd);
    fwrite(&(fhdr.progcompdate),sizeof(char),26,fd);
    fwrite(&(fhdr.num_samples),sizeof(int),1,fd);
    fwrite(&(fhdr.filler),sizeof(int),1,fd);
    fwrite(&(fhdr.num_doubles),sizeof(int),1,fd);
    fwrite(&(fhdr.num_floats),sizeof(int),1,fd);
    fwrite(&(fhdr.num_ints),sizeof(int),1,fd);
    fwrite(&(fhdr.num_shorts),sizeof(int),1,fd);
    fwrite(&(fhdr.num_chars),sizeof(int),1,fd);
    fwrite(&(fhdr.fsize),sizeof(int),1,fd);
    fwrite(&(fhdr.hsize),sizeof(int),1,fd);
    fwrite(&(fhdr.username),sizeof(char),8,fd);
    fwrite(&(fhdr.fil1),sizeof(int),5,fd);
    fwrite(&(fhdr.fea_type),sizeof(short),1,fd);
    fwrite(&(fhdr.fil2),sizeof(short),1,fd);
    fwrite(&(fhdr.num_fields),sizeof(short),1,fd);
    fwrite(&(fhdr.fil3),sizeof(short),1,fd);
    fwrite(&(fhdr.fil4),sizeof(int),9,fd);
    fwrite(&(fhdr.fil5),sizeof(int),8,fd);

    /* The following cover dimensions, type and ordering info */
    for (i=0; i < hdr->num_fields; i++)
    {   /* Dimensions (i.e. number of channels) */
    intdata = 1;
    fwrite(&intdata,4,1,fd);                        /* dimensions */
    }
    for (i=0; i < hdr->num_fields; i++)                 /* ordering info (?) */
    fwrite(&i,4,1,fd);
    if (hdr->file_type == ESPS_SD)  /* zeros hmm should be zeroes only */
    shortdata = 1;              /* is FEA case, 1 in ESPS_SD case  */
    else                            /* fixed 24/7/98                   */
    shortdata = 0;
    for (i=0; i < hdr->num_fields; i++)
    fwrite(&shortdata,2,1,fd);     
    for (i=0; i < hdr->num_fields; i++)    
    {
    shortdata = hdr->field_type[0];                 /* field types */
    fwrite(&shortdata,2,1,fd);
    }
    intdata = fhdr.num_doubles;                        /* number of doubles */
    fwrite(&intdata,4,1,fd);
    intdata = fhdr.num_floats;                         /* number of floats */
    fwrite(&intdata,4,1,fd);
    intdata = fhdr.num_ints;                           /* number of ints */
    fwrite(&intdata,4,1,fd);
    intdata = fhdr.num_shorts;                         /* number of shorts */
    fwrite(&intdata,4,1,fd);
    intdata = fhdr.num_chars;                          /* number of chars */
    fwrite(&intdata,4,1,fd);
    shortdata = 0;
    for (i=0; i < 9; i++)
    fwrite(&shortdata,2,1,fd);                      /* other types */
    for (i=0; i < hdr->num_fields; i++)
    fwrite(&shortdata,2,1,fd);                      /* zeros */
    /* Now dump the filednames */
    for (i=0; i < hdr->num_fields; i++)
    esps_put_field_name(hdr->field_name[i],fd,hdr); /* field names */
    if (hdr->file_type != ESPS_SD)
    fwrite(&shortdata,2,1,fd);   /* another 0 */
    /* Now the feas */
    for (t=hdr->fea; t != NULL; t=t->next)
    write_esps_fea(fd,t,hdr);                       /* feas */
    /* now have to go back and fix the header size */
    intdata = 0;
    fwrite(&intdata,4,1,fd);
    preamble.data_offset = ftell(fd);
    fhdr.hsize = (preamble.data_offset-249)/2;
    if (fseek(fd,0,SEEK_SET) == -1)
    {
    fprintf(stderr,"esps write header: can't fseek to start of file\n");
    return misc_write_error;
    }
    if (fwrite(&(preamble.machine_code),sizeof(int),1,fd) != 1) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    if (fwrite(&(preamble.check_code),sizeof(int),1,fd) != 1) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    if (fwrite(&(preamble.data_offset),sizeof(int),1,fd) != 1) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    if (fwrite(&(preamble.record_size),sizeof(int),1,fd) != 1) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    if (fwrite(&(preamble.check),sizeof(int),1,fd) != 1) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    if (fwrite(&(preamble.edr),sizeof(int),1,fd) != 1) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    if (fwrite(&(preamble.fil1),sizeof(int),1,fd) != 1) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    if (fwrite(&(preamble.foreign_hd),sizeof(int),1,fd) != 1) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }


    if (fwrite(&(fhdr.thirteen),sizeof(short),1,fd) != 1) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    if (fwrite(&(fhdr.sdr_size),sizeof(short),1,fd) != 1) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    if (fwrite(&(fhdr.magic),sizeof(int),1,fd) != 1) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    if (fwrite(&(fhdr.date),sizeof(char),26,fd) != 26) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    if (fwrite(&(fhdr.version),sizeof(char),8,fd) != 8) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    if (fwrite(&(fhdr.prog),sizeof(char),16,fd) != 16) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    if (fwrite(&(fhdr.vers),sizeof(char),8,fd) != 8) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    if (fwrite(&(fhdr.progcompdate),sizeof(char),26,fd) != 26) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    if (fwrite(&(fhdr.num_samples),sizeof(int),1,fd) != 1) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    if (fwrite(&(fhdr.filler),sizeof(int),1,fd) != 1) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    if (fwrite(&(fhdr.num_doubles),sizeof(int),1,fd) != 1) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    if (fwrite(&(fhdr.num_floats),sizeof(int),1,fd) != 1) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    if (fwrite(&(fhdr.num_ints),sizeof(int),1,fd) != 1) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    if (fwrite(&(fhdr.num_shorts),sizeof(int),1,fd) != 1) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    if (fwrite(&(fhdr.num_chars),sizeof(int),1,fd) != 1) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    if (fwrite(&(fhdr.fsize),sizeof(int),1,fd) != 1) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    if (fwrite(&(fhdr.hsize),sizeof(int),1,fd) != 1) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    if (fwrite(&(fhdr.username),sizeof(char),8,fd) != 8) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    if (fwrite(&(fhdr.fil1),sizeof(int),5,fd) != 5) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    if (fwrite(&(fhdr.fea_type),sizeof(short),1,fd) != 1) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    if (fwrite(&(fhdr.fil2),sizeof(short),1,fd) != 1) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    if (fwrite(&(fhdr.num_fields),sizeof(short),1,fd) != 1) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    if (fwrite(&(fhdr.fil3),sizeof(short),1,fd) != 1) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    if (fwrite(&(fhdr.fil4),sizeof(int),9,fd) != 9) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    if (fwrite(&(fhdr.fil5),sizeof(int),8,fd) != 8) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    if (fseek(fd,preamble.data_offset,SEEK_SET) != 0) {
        fprintf(stderr, "esps write header: Write error\n");
        return misc_write_error;
    }
    
    return write_ok;
}