/*

Read in a Monitor 7.0 file and convert it into an EBS file.
Copyright (C) 1993/94 M. Prosch, M. Kuhn, Institut fuer Physiologie und
     		      Biokybernetik (IPB), Universitaet Erlangen,
		      Deutschland

Permission to use, copy, modify, distribute, and sell this software
and its documentation for any purpose is hereby granted without fee,
provided that the above copyright notice appear in all copies and
related publications and that both that copyright notice and this
permission notice appear in supporting documentation. The authors make
no representations about the suitability of this software for any
purpose. It is provided "as is" without express or implied warranty.

Send your comments, suggestions or bug reports to
        ftpebs@uni-erlangen.de
 
Or mail to
        Institut fuer Physiologie und Biokybernetik
        Markus Prosch
        Universitaetsstrasse 17
        D-91054 Erlangen
        Germany

$Id: mon70ebs.c,v 1.22 1994/12/16 15:43:09 aescheel Exp $

*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <math.h>
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>

#include "ebs.h"


/* for pre-ANSI-versions of stdio.h */
#ifndef SEEK_SET
#define SEEK_SET 0
#endif
#ifndef SEEK_END
#define SEEK_END 2
#endif

#ifndef PI
#define PI 3.14159265358979323846
#endif

#ifdef MSDOS
#include "setstack.c"
#endif

#define HEADERLENGTH (3*256)

#define BLOCKSIZE 1000

#define RECORD_LEN 64

#define NO_SAMPLES 0xffffffff

#define SPIKES_SHORT_DESCRIPTION     "MonSpike"
#define SPIKES_DESCRIPTION          "Spike positions reported by Monitor 7.0 "\
"(Stellate Systems)"
#define SEIZURES_SHORT_DESCRIPTION   "MonSeiz"
#define SEIZURES_DESCRIPTION         "Seizure onsets reported by Monitor 7.0 "\
"(Stellate Systems)"
#define ANNOTATIONS_SHORT_DESCRIPTION "MonAnnot"
#define ANNOTATIONS_DESCRIPTION       "Annotations reported by Monitor 7.0 "\
"(Stellate Systems)"

char copyright[]= 
"Read in a Monitor 7.0 file and convert it into an EBS file.\n"
"Copyright (C) 1993/94 M. Prosch, M. Kuhn, Institut fuer Physiologie und\n"
"                      Biokybernetik (IPB), Universitaet Erlangen, Deutschland\n\n"
"Permission to use, copy, modify, distribute, and sell this software\n"
"and its documentation for any purpose is hereby granted without fee,\n"
"provided that the above copyright notice appear in all copies and\n"
"related publications and that both that copyright notice and this\n"
"permission notice appear in supporting documentation. The authors make\n"
"no representations about the suitability of this software for any\n"
"purpose. It is provided \"as is\" without express or implied warranty.\n\n"
"Send your comments, suggestions or bug reports to\n"
"        ftpebs@uni-erlangen.de\n\n"
"Or mail to\n"
"        Institut fuer Physiologie und Biokybernetik\n"
"        Markus Prosch\n"
"        Universitaetsstrasse 17\n"
"        D-91054 Erlangen\n"
"        Germany\n\n";

char version[] = "Monitor 7.0 to EBS converter, V0.2 "__DATE__"\n"
"(C) 1993/94 Markus Prosch, Markus Kuhn, Thomas Schicketanz, IPB, Erlangen";
char version_short[] = "Monitor 7.0 to EBS converter, V0.2, M. Prosch, "
"M. Kuhn, IPB";

char usage[] = "%s\n\nusage: %s [-v] [-f] [-e<format>] "
                     "[-ss<samples> | -st<time>]\n"
                     "          [-ls<samples> | -lt<time>] "
                     "[-m<path to montage file>]\n"
                     "          [-a<annotation file>] "
#ifdef MSDOS
  "<monitor 7.0 file> <ebs-file>\n"
#else
  "[(<monitor 7.0 file> | -) [<ebs-file>]]\n"
#endif
  "\noptions:\n"
  "\t-c           print out copyright notice\n"
  "\t-h           print out this message\n"
  "\t-v           print a few details about the monitor 7.0 header\n" 
  "\t-f           force program to accept other file-versions than Mon 7.0\n"
  "\t             (implies -v)\n"
  "\t-e<format>   specify output data format (default is CIB_16 and if\n"
  "\t             stdin or stdout is used, then TIB_16 is the default)\n"
  "\t-s<start>    Ignore the specified number of samples or the specified\n"
  "\t             time at the beginning of the file (default: 0)\n"
  "\t             examples: -ss521    (ignore 521 samples)\n"
  "\t                       -st1:02.4 (ignore the first 62.4 seconds)\n"
  "\t-l<length>   Don't read more than <length> samples, or <time>\n"
  "\t             examples: -ls200    (read 200 samples)\n"
  "\t                       -lt2.4    (read 2.4 seconds)\n"
  "\t-m<montage>  path to montage file (default: current path)\n"
  "\t-a<annot.>   path and filename of annotation file\n"
  "\t             (default: <monitor 7.0 file>.STA)\n\n";



#define BUFSIZE 3000


unsigned long nspikes= 0, *spike= NULL, actspikes= 0;
unsigned long nseizures= 0, *seizure= NULL, actseizures= 0;
unsigned long nannotations= 0, actannotations= 0, annotationlen= 0;
struct annotation_type {
  unsigned long position;
  int no;
} *annotation;
char annotation_text [16][10];
int spike_channel, spike_offset, seizure_channel, seizure_offset;
int annotation_channel, annotation_offset;


/* modify routine for dataconv(): Monitor 7.0 data is stored as 12-bit
   Littleendian integer time order data (like TIL_16) in the range 0
   to 4096, so we only have to substract 2048 and dataconv() will do
   the rest of the conversion. */
void modify(short *buf, int length, unsigned long channel,
            unsigned long pos)
{
  int i, aux, act;

  /* look for spikes */
  if (channel== spike_channel) {
    act= pos % RECORD_LEN+ spike_offset;
    if (act- RECORD_LEN>= 0) act-= RECORD_LEN;
    while (act< length) {
      if ((buf [act] & 0xf000)!= 0) {
	/* found spikes */
	if (actspikes== 0) {
	  /* Allocate memory for list of spike */
	  if (spike== NULL) 
	    spike= (unsigned long *) 
	      malloc (BLOCKSIZE* sizeof (unsigned long));
	  else
	    spike= (unsigned long *) 
	      realloc (spike, (nspikes+ BLOCKSIZE)* sizeof (unsigned long));
	  if (spike== NULL) {
	    perror ("error allocating memory");
	    exit (1);
	  }
	  actspikes= BLOCKSIZE;
	}
	spike [nspikes++]= pos+ act;
	actspikes--;
      }
      act+= RECORD_LEN;
    }
  }
  
  /* Look for seizures */
  if (channel== seizure_channel) {
    act= pos % RECORD_LEN+ seizure_offset;
    if (act- RECORD_LEN>= 0) act-= RECORD_LEN;
    while (act< length) {
      if ((buf [act] & 0xf000)!= 0) {
	/* found seizure */
	if (actseizures== 0) {
	  /* Allocate memory for list of seizure */
	  if (seizure== NULL) 
	    seizure= (unsigned long *) 
	      malloc (BLOCKSIZE* sizeof (unsigned long));
	  else
	    seizure= (unsigned long *) 
	      realloc (seizure, (nseizures+ BLOCKSIZE)*sizeof (unsigned long));
	  if (seizure== NULL) {
	    perror ("error allocating memory");
	    exit (1);
	  }
	  actseizures= BLOCKSIZE;
	}
	seizure [nseizures++]= pos+ act;
	actseizures--;
      }
      act+= RECORD_LEN;
    }
  }

  /* Look for annotations */
  if (channel== annotation_channel) {
    act= pos % RECORD_LEN+ annotation_offset;
    if (act- RECORD_LEN>= 0) act-= RECORD_LEN;
    while (act< length) {
      if ((aux= (buf [act] & 0xf000) >> 12)!= 0 && aux<= 10) {
	/* found annotation */
	if (actannotations== 0) {
	  /* Allocate memory for list of annotation */
	  if (annotation== NULL) 
	    annotation= (struct annotation_type *) 
	      malloc (BLOCKSIZE* sizeof (struct annotation_type));
	  else
	    annotation= (struct annotation_type *) 
	      realloc (annotation, (nannotations+ BLOCKSIZE)* 
		       sizeof (struct annotation_type));
	  if (annotation== NULL) {
	    perror ("error allocating memory");
	    exit (1);
	  }
	  actannotations= BLOCKSIZE;
	}
	annotation [nannotations].position= pos+ act;
	annotation [nannotations++].no= aux;
	annotationlen+= s4len (annotation_text [aux- 1]);
	actannotations--;
      }
      act+= RECORD_LEN;
    }
  }
  
  for (i = 0; i < length; i++) 
    buf[i]= (buf [i] & 0x0fff)- 0x800;
}


/* Konvert the IBM-CS into the local CS */
char *to_local (char *in)
{
  static char unicode [2001];
  static char local [2001];
  void *dummy;

  dummy = unicode;
  puts4_cs(in, EBS_CS_IBM437, &dummy);  /* use the ebs.c routines for */
  dummy = unicode;                      /* character set conversion */
  gets4(local, 2000, &dummy);
  return (local);
}


/* Get one single little-endian 16-bit value */
short sgeti16l (char *from)
{
  short value;

  value=  (unsigned char) *from;
  value|= (signed char) *(from+ 1)<< 8;
  return (value);
}


/* Get one single little-endian 32-bit value */
long sgeti32l (char *from)
{
  long value;

  value=  (unsigned char) *from;
  value|= (unsigned char) *(from+ 1) << 8;
  value|= (unsigned char) *(from+ 2) << 16;
  value|= (signed char) *(from+ 3) << 24;
  return (value);
}


/* read one single-line-string starting at position from */
void get_string (char *string, int max, char *from)
{
  char *to= string, *end= from+ max;

  /* ignore leading spaces */
  while (isspace (*from)) from++;

  while (from< end && *from!= '\0')
    *to++= *from++;
  *to= '\0';

  /* remove trailing white spaces */
  while (--to> string && isspace(*to)) *to= '\0';
}


/* Remove leading and trailing white spaces from string */
void remove_spaces (char *in)
{
  char *s, *t;

  s= in;
  t= s;
  /* remove leading spaces */
  while (isspace (*s)) s++;
  if (*s== '\0') {*t= '\0'; return;}
  if (t!= s) {
    while ((*t++= *s++)!='\0');
    t--;
  }
  else
    t+= strlen (t);

  /* remove trailing spaces */
  while (--t> in && isspace (*t)) *t= '\0';
}


/* Konvert time/sampelno to sampleno */
unsigned long to_samples (char *string_in, double samplerate) 
{
  char *aux, *pos, string [1000];
  double sec_100= 0.0, sec= 0.0, min= 0.0, hour= 0.0;
  double sampleno_aux;
  unsigned long sampleno;
  int len, aux_len, i;

  if (strlen (string_in)<= 1) return (NO_SAMPLES);

  /* Check, if number of samples is specified (simpler) */ 
  if (tolower (string_in [0])== 's') {
    for (i= 1; i< strlen (string_in); ++i)
      if (!isdigit (string_in [i])) return (NO_SAMPLES);
    /* return sampleno */
    return (atol (string_in+1));
  }

  /* Check, if time is specified */
  if (tolower (string_in [0])== 't') {
    for (i= 1; i< strlen (string_in); ++i)
      if (!isdigit (string_in [i]) && string_in [i]!= ':' &&
	  string_in [i]!= '.') return (NO_SAMPLES);
    
    strcpy (string, string_in+ 1);
    len= strlen (string);
    
    /* hundredth */
    pos= strrchr (string, '.');
    if (pos!= NULL) {
      /* Hunderstel holen */
      aux_len= string+ len- pos;
      if (aux_len== 2)
	sec_100= atoi (pos+ 1)* 10;
      if (aux_len> 2) {
	*(pos+ 3)= '\0';
	sec_100= atoi (pos+ 1);
      }
      if (sec_100< 0) sec_100= 0;
      *pos= '\0';
    }
    
    /* seconds */
    pos= strrchr (string, ':');
    if (pos== NULL) {
      /* no colon before seconds */
      sec= atoi (string);
    }
    else {
      /* colon before seconds */
      sec= atoi (pos+ 1);
      if (sec> 59) sec= 59;
      if (sec< 0) sec= 0;
      *pos= '\0';
      
      /* minutes */
      pos= strrchr (string, ':');
      if (pos== NULL) {
	/* no colon before minutes */
	min= atoi (string);
      }
      else {
	/* colon before minutes */
	min= atoi (pos+ 1);
	if (min> 59) min= 59;
	if (min< 0) min= 0;
	*pos= '\0';
	
	/* hours */
	hour= atoi (string);
	if (hour< 0) hour= 0;
      }
    }
    
    /* check range */
    sampleno_aux= (((60.0* hour+ min)* 60.0+ sec)* 100.0+ sec_100)*
      samplerate/ 100.0+ 0.5;
    if (sampleno_aux>= (double) (NO_SAMPLES-1))
      sampleno= (NO_SAMPLES-1);
    else
      if (sampleno_aux<= 0)
	sampleno= 0;
      else
	sampleno= sampleno_aux;
    
    return (sampleno);
  }
  
  return (NO_SAMPLES);
}


/* Read one line from stream */
int GetLine (FILE *in, char *line, int max)
{
  char *ptr= line;
  int c, act= 1;  /* terminating '\0' */

  max--;
  do {
    c= getc (in);
    if (c== EOF || c== '\n') {
      *ptr= '\0';
      return (c!= EOF);
    }

    if (c!= '\r') {
      *(ptr++)= c;
      act++;
    }
  } while (act< max);
  *ptr= '\0';

  /* skip until the next LF */
  while ((c= getc (in))== EOF || c== '\n'); 

  return (c!= EOF);
}


main(int argc, char **argv)
{
  FILE *fin, *fout;
  char *fnout = NULL;    /* output filename that might be unlinked */
  char *fnin = NULL;     /* input file name */
  char buffer[BUFSIZE];
  char tmp, *ptr;
  long i, j, k, count, block;
  unsigned long start= 0l;
  unsigned long length= 0xffffffffL;  /* number of samples */
  long outcode = (long) 0xffffffffL;
  long ret;
  int mon_from_stdin = 0; /* - was part of the command line */
  char namebuf[1000];   /* for processing history, etc. */
  int verbose = 0, force= 0;
  char *all_months[13] = {"Jan","Feb","Mar","Apr","May","Jun",
			    "Jul","Aug","Sep","Oct","Nov","Dec",NULL};
  int day, year, month= 0, hour, min, sec, no;
  char smonth [4];
  char montfile [2000], montline [1002], **electrodes, searchfor [30];
  FILE *mfile, *annot;
  int electrodes_len;
  char *record;
  int recordsize, all_zero, second_header= 0;
  unsigned long skip, startdata= 0, enddata= 0;
  char *annotation_filename= NULL;
  char *from_position= NULL, *npositions= NULL;
  unsigned long l;
  int only_ebs_head= 0;


  /* FROM the Monitor 7.0 header, same names */
  char header [3* 256], header_annotation [3* 256];
  char name [19], idnum [13], comments [31], recording_time [16];
  char montage [3], montfname [10], corr_recording_time [16];
  long ampavg;
  int avgdev [64], digfrh, digfrl, storage;
  int locutoff, loorder, hicutoff, hiorder;
  char progver [8], fflag;
  int gain, adrange, nchan;


  /* do all the command line and file open stuff */
  fin = stdin;
  fout = stdout;
  montfile [0]= '\0';
  for (i = 1; i < argc; i++) {
    if (argv[i][0] == '/' && argv[i][1] == '?' && argv[i][2] == 0) {
      fprintf(stderr, usage, version, argv[0]);
      exit(1);
    } else if (argv[i][0] == '-')
      if (argv[i][1] == '\0') {
	if (mon_from_stdin) {
	  fprintf(stderr, usage, version, argv[0]);
	  exit(1);
	}
	mon_from_stdin = 1;
      } else
	for (j = 1; j < 2000 && argv[i][j] != 0; j++)
	  switch (argv[i][j]) {
	  case 'e':
	  case 'E':
	    if (argv[i][j+1]!= '\0') {
	      outcode = formatid(argv[i]+ j+ 1);
	      if (outcode == 0xffffffffL) {
		fprintf(stderr, "Unknow output data format '%s'!\n", 
			argv[i]+ j+ 1);
		exit(1);
	      }
	      j = 9999;
	    } else {
	      fprintf(stderr, usage, version, argv[0]);
	      exit(1);
	    }
	    break;
	  case 'f':
	  case 'F':
	    force= 1;
	  case 'v':
	  case 'V':
	    fprintf(stderr, "%s\n", version);
	    verbose = 1;
	    break;
	  case 'm':
	  case 'M':
	    strcpy (montfile, argv [i]+ j+ 1);
	    if (*montfile!= '\0') {
#ifdef MSDOS
	      if (montfile [strlen (montfile)- 1]!= '\\' &&
		  !(strlen (montfile)== 2 && montfile [1]== ':'))
		strcat (montfile, "\\");
#else
	      if (montfile [strlen (montfile)- 1]!= '/')
		strcat (montfile, "/");
#endif
	    }
	    j= 9999;
	    break;
	  case 'a':
	  case 'A':
	    annotation_filename= argv [i]+ j+ 1;
	    j= 9999;
	    break;
	  case 's':
	  case 'S':
	    from_position= argv [i]+ j+ 1;
	    if (to_samples (from_position, 0.0)== NO_SAMPLES) {
	      fprintf (stderr, usage, version, argv [0]);
	      exit (1);
	    }
	    j= 9999;
	    break;
	  case 'l':
	  case 'L':
	    npositions= argv [i]+ j+ 1;
	    if (to_samples (npositions, 0.0)== NO_SAMPLES) {
	      fprintf (stderr, usage, version, argv [0]);
	      exit (1);
	    }
	    j= 9999;
	    break;
	  case 'c':
	  case 'C':
	    fprintf (stderr, copyright);
	    exit (1);
	  case 'p':
	  case 'P':
	    only_ebs_head = 1;
	    break;
	  default:
	    fprintf(stderr, usage, version, argv[0]);
	    exit(1);
	  }
    else if (fin == stdin && !mon_from_stdin) {
      fnin = argv[i];
      fin = fopen(fnin, "rb");
      if (fin == NULL) {
	fprintf(stderr, "Can't open input file '%s", fnin);
	perror("'");
	exit(1);
      }
    } else if (fout == stdout) {
      fnout = argv[i];
      fout = fopen(fnout, "wb");
      if (fout == NULL) {
	fprintf(stderr, "Can't open output file '%s", fnout);
	perror("'");
	exit(1);
      }
    } else {
      fprintf(stderr, usage, version, argv[0]);
      exit(1);
    }
  }
  
  /* set default output data encodings */
  if (fin == stdin || fout == stdout) {
#ifdef MSDOS
    /* MSDOS can't work with binary files on stdin and stdout */
    fprintf(stderr, usage, version, argv[0]);
    if (fout != stdout) remove(fnout);
    exit(1);
#endif
    if (outcode == 0xffffffffL)
      outcode = EBS_TIB_16;
    if (outcode != EBS_TIB_16 && outcode != EBS_TIL_16) {
      fprintf(stderr, "Only TIB_16 or TIL_16 are possible output formats "
	      "if stdin or stdout are used!\n");
      if (fout != stdout) remove(fnout);
      exit(1);
    }
  } else
    if (outcode == 0xffffffffL)
      outcode = EBS_CIB_16;


  /* read Monitor 7.0 header: it is always 3* 256 Bytes long */
  if (fread (header, 3* 256, 1, fin)!= 1) {
    perror ("Error reading header part");
    exit (1);
  }

  /* version */
  get_string (progver, 7, header+ 247);
  if (strcmp (progver, "Ver 7.0")!= 0) {
    if (only_ebs_head)   return(2); 
    fprintf (stderr,"\n%s: file is not a valid Mon 7.0 file\n",
	     force?"warning":"error");
    if (!force) exit (1);
  }

  /* If -s or -l is given, calculate start and length of segment */
  if (from_position!= NULL) {
    digfrl= sgeti16l (header+ 202);
    start= to_samples (from_position, (double) digfrl);
  }
  if (npositions!= NULL) {
    digfrl= sgeti16l (header+ 202);
    length= to_samples (npositions, (double) digfrl);
  }
  
  /* Patientname */
  get_string (name, 18, header+ 0);

  /* Patient ID */
  get_string (idnum, 12, header+ 18);

  /* Short description */
  get_string (comments, 30, header+ 30);

  /* Montage code */
  get_string (montage, 2, header+ 60);
  get_string (montfname, 9, header+ 148);

  /* Recording time */
  sscanf (header+ 62, "%3s %2d%*c%4d", smonth, &day, &year);
  sscanf (header+ 74, "%2d:%2d:%2d", &hour, &min, &sec);
  no = 0;
  while (all_months[no]!= NULL) {
    if (strcmp (all_months [no], smonth) == 0) {month= no+1; break;} 
    no++;
  }
  if (no== 0 || year < 1900 || day> 31 || day< 1 || hour> 24 || hour< 0 ||
      min> 59 || min< 0 || sec> 59 || sec< 0) {
    fprintf (stderr, "\nwarning: illegal recording time %12s %11s, ignored\n",
	     header+ 62, header+ 74);
    recording_time[0]= '\0';
  }
  else
    sprintf (recording_time,"%04d%02d%02dT%02d%02d%02d", 
	     year, month, day, hour, min, sec);

  /* bin to physical-unit */
  ampavg= sgeti32l (header+ 157);
  for (i= 0; i< 32; ++i)
    avgdev [i]= header [161+ i];
  for (i= 0; i< 32; ++i)
    avgdev [i+32]= header [258+ i];

  /* Samplerate */
  digfrh= sgeti16l (header+ 200);
  digfrl= sgeti16l (header+ 202);
  if (digfrl!= digfrh)
    fprintf (stderr, 
	     "\nwarning: two different samplerates are given, using digfrl\n");

  /* ADC word length */
  storage= sgeti16l (header+ 208);
  if (storage!= 12) {
    fprintf (stderr, 
       "\nerror: this version only supports an ADC word length of 12bit\n");
    exit (1);
  }

  /* Filters */
  fflag= header [212];
  if (fflag== 'F' || fflag== 'f') fflag= 'F';
  locutoff= sgeti16l (header+ 213);
  loorder = sgeti16l (header+ 215);
  hicutoff= sgeti16l (header+ 217);
  hiorder = sgeti16l (header+ 219);

  /* Channels */
  nchan = sgeti16l (header+ 230);

  /* EEG gain and ADC Range */
  gain= sgeti16l (header+ 494);
  adrange= sgeti16l (header+ 496);

  /* Channel description */
  ptr= montfname;
  while (*ptr!= '\0') {*ptr= toupper (*ptr); ptr++;}
  strcat (montfile, montfname);
  strcat (montfile, ".MTG");
  electrodes_len= 0;
  electrodes= NULL;
  mfile= fopen (montfile, "rb");
  if (mfile== NULL) {
    ptr= montfile+ strlen (montfile)-1;
    for (i= 0; i< strlen (montfname)+ strlen (".MTG"); ptr--, ++i)
      *ptr= tolower (*ptr);
    mfile= fopen (montfile, "rb");
  }
  if (mfile== NULL) {
    fprintf(stderr, "\nwarning: can't open montage-file '%s', "
	    "no channel-labels\n", montfile);
  }
  else {
    sprintf (searchfor, "%s%dref", montage, nchan);
    while (!(feof(mfile))) {
      GetLine (mfile, montline, 1000);
      if (strcmp (montline, searchfor) == 0) {
	electrodes= (char **) malloc (nchan * sizeof (char *));
	if (electrodes!= NULL)
	  for (i=0; i< nchan; i++) {
	    GetLine (mfile, montline, 1000);
	    montline[7] = '\0';
	    j = 6;
	    while (j>=0 && montline[j] == ' ') montline[j--] = '\0';
	    electrodes [i]= strdup (montline);
	    if (electrodes [i]== NULL) {
	      perror ("error allocating memory");
	      exit (1);
	    }
	    electrodes_len+= s4len_cs (montline, EBS_CS_IBM437)+ s4len ("");
	  }
	break;
      }
    }
    fclose (mfile);
  }
  
  /* In case of an ordinary file consider the annotation file */
  if (fin!= stdin) {
    char *annotation_file, *ptr= NULL;

    if (annotation_filename!= NULL)
      annotation_file= annotation_filename;
    else {
      /* replace the old extention with .STA */
      annotation_file= (char *) malloc (strlen (fnin)+ 4+ 1);
      if (annotation_file== NULL) {
	perror ("error allocating memory");
	exit (1);
      }
      strcpy (annotation_file, fnin);
      ptr= annotation_file+ strlen (annotation_file)- 1;
      while (ptr> annotation_file && *ptr!= '.') ptr--;
      if (ptr> annotation_file)
	*ptr= '\0';
      strcat (annotation_file, ".STA");
    }

    /* Try with lowercase extension */
    if ((annot= fopen (annotation_file, "rb"))== NULL &&
	annotation_filename== NULL) {
      *ptr= '\0';
      strcat (annotation_file, ".sta");
      annot= fopen (annotation_file, "rb");
    }
    if (annot== NULL) {
      fprintf (stderr, "\nwarning: could not open annotation file '%s', "
	       "using default names\n", annotation_file);
      for (i= 1; i<= 10; ++i)
	sprintf (annotation_text [i- 1], "Annote%2d", i);
    }
    else
      {
	/* read annotation-file header: only interessed */
	/* in the first 3* 256 Bytes                    */
	int result= fread (header_annotation, HEADERLENGTH, 1, annot);
	if (result!= 1 || memcmp (header, header_annotation, 2* 256)!= 0) {
	  if (result!= 1) 
	    fprintf (stderr, 
		     "\nwarning: error while reading annotation file '%s', "
		     "using default names\n", annotation_file);
	  else
	    fprintf (stderr,
		     "\nwarning: '%s' does not seem to be\n"
		    "\tthe corresponding annotation file, "
		     "using default names\n", annotation_file);
	  for (i= 1; i<= 10; ++i)
	    sprintf (annotation_text [i- 1], "Annote%2d", i);
	}
	else
	  for (i= 0; i< 10; ++i) {
	    strncpy (annotation_text [i], header_annotation+ 2* 256+ i* 9, 9);
	    annotation_text [i][9]= '\0';
	  }
	fclose (annot);
      }
  }
  
  /* In case of an ordinary file determine the length of the */
  /* initial all 0-value record                              */
  record= NULL;
  recordsize= 0;
  *corr_recording_time= '\0';
  skip= 0;
  if (fin!= stdin && fout!= stdout) {
    recordsize= 2* nchan* RECORD_LEN;
    record= (char *) malloc (recordsize);
    if (record== NULL) {
      perror ("error allocating memory");
      exit (1);
    }
    fseek (fin, 3* 256, SEEK_SET);
    while (!feof (fin)) {
      if (fread (record, recordsize, 1, fin)== 1) {
	ptr= record;
	all_zero= 1;
	for (i= 0 ; i< RECORD_LEN* nchan; ++i)
	  if (*ptr++!= 0x00 || (*ptr++ & 0x0f)!= 0x08) {all_zero= 0; break;}
	if (all_zero) skip+= RECORD_LEN; else break;
      }
    }
    if (skip!= 0 && *recording_time!= '\0') {
      /* Correct the recording time */
      struct tm tm, *tm2;
      time_t current_time;
      tm.tm_sec= sec;
      tm.tm_min= min;
      tm.tm_hour= hour;
      tm.tm_mday= day;
      tm.tm_mon= month- 1;
      tm.tm_year= year- 1900;
      tm.tm_wday= -1;
      tm.tm_yday= -1;
      tm.tm_isdst= -1;
      current_time= mktime (&tm);
      if (current_time!= -1) {
	current_time+= (time_t) ((skip+ start)/ digfrl);
	tm2= localtime (&current_time);
	if (tm2!= NULL) 
	  sprintf (corr_recording_time, "%04d%02d%02dT%02d%02d%02d", 
		   tm2->tm_year+ 1900, tm2->tm_mon+ 1, tm2->tm_mday, 
		   tm2->tm_hour, tm2->tm_min, tm2->tm_sec);
      }
    }
  }

  if (verbose) {
    fprintf(stderr, "\nchannels    = %d\n", nchan);
    fprintf(stderr, "sample rate = %dHz\n", digfrl);
    fprintf(stderr, "gain        = %d\n", gain);
    fprintf(stderr, "adrange     = %d\n", adrange);
    fprintf(stderr, "scaling     = %d\n", ampavg);
    if (fflag== 'F') {
      fprintf(stderr, "freql       = %dHz, order %d\n", locutoff, loorder);
      fprintf(stderr, "freqh       = %dHz, order %d\n", hicutoff, hiorder);
    }
    fprintf(stderr, "montage     = '%s'\n", montage);
    fprintf(stderr, "name        = '%s'\n", name);
    fprintf(stderr, "id          = '%s'\n", idnum);
    if (*recording_time!= '\0')
      fprintf(stderr, "date/time   = %.4s-%.2s-%.2s %.2s:%.2s:%.2s\n",
	      recording_time, recording_time+ 4, recording_time+ 6,
	      recording_time+ 9, recording_time+ 11, recording_time+ 13);
    if (*corr_recording_time!= '\0') {
      fprintf(stderr, "all zeros   = %ldsec\n", (long) (skip/ digfrl));
      fprintf(stderr, "corr. time  = %.4s-%.2s-%.2s %.2s:%.2s:%.2s\n",
	      corr_recording_time, corr_recording_time+ 4, 
	      corr_recording_time+ 6, corr_recording_time+ 9, 
	      corr_recording_time+ 11, corr_recording_time+ 13);
    }
    fprintf(stderr, "description = '%s'\n", comments);
    if (electrodes!= NULL) {
      fprintf(stderr, "electrodes  = ");
      for (i= 0; i< nchan; ++i) 
	fprintf (stderr, "%s'%s'", 
		 i==0?"":((i % 6)==0?"\n              ":", "), electrodes [i]);
      fprintf (stderr, "\n");
    }
  }

  /* write EBS file */

  /* fixed header */
  fputi32(EBS_MAGIC1, fout);            /* magic code */
  fputi32(EBS_MAGIC2, fout);
  fputi32(outcode, fout);
  fputi32(nchan, fout);                 /* number of channels */
  if (only_ebs_head) {
    fputi32(0L, fout);                  /* no samples */
    fputi32(0L, fout);
  } else {
    fputi32(0xffffffffL, fout);         /* will be overwritten later */
    fputi32(0xffffffffL, fout);
  }
  /* no second variable header part */
  fputi32(0xffffffffL, fout);
  fputi32(0xffffffffL, fout);

  /* variable header */

  /* PATIENT_NAME */
  if (name[0]!= '\0') {
    fputi32 (EBS_PATIENT_NAME, fout);
    fputi32 (s4len_cs (name, EBS_CS_IBM437), fout);
    fputs4_cs (name, EBS_CS_IBM437, fout);
  }

  /* PATIENT_ID */
  if (idnum[0]!= '\0') {
    fputi32 (EBS_PATIENT_ID, fout);
    fputi32 (s4len_cs (idnum, EBS_CS_IBM437), fout);
    fputs4_cs (idnum, EBS_CS_IBM437, fout);
  }

  /* SHORT_DESCRIPTION */
  if (comments[0]!= '\0' && strcmp (comments, "None")!= 0) {
    fputi32 (EBS_SHORT_DESCRIPTION, fout);
    fputi32 (s4len_cs (comments, EBS_CS_IBM437), fout);
    fputs4_cs (comments, EBS_CS_IBM437, fout);
  }

  /* SAMPLE_RATE */
  fputi32(EBS_SAMPLE_RATE, fout);
  fputi32(f4len(digfrl), fout);
  fputf4(digfrl, fout);

  /* PREFERRED_INTEGER_RANGE */
  fputi32(EBS_PREFERRED_INTEGER_RANGE, fout);
  fputi32(2*nchan, fout);
  for (i = 0; i < nchan; i++) {
    fputi32(-2048, fout);
    fputi32(2047, fout);
  }
  
  /* RECORDING_TIME */
  if (recording_time [0]!= '\0') {
    fputi32(EBS_RECORDING_TIME, fout);
    fputi32(4, fout);
    if (corr_recording_time [0]!= '\0')
      fprintf(fout, "%s", corr_recording_time);
    else
      fprintf(fout, "%s", recording_time);
    putc(0, fout);
  }
  
  /* FILTERS */
  if (fflag== 'F') {
    fputi32 (EBS_FILTERS, fout);
    fputi32 (nchan* (2* 2+ f4len (locutoff)+ f4len (hicutoff)+
		     f4len (-20.0* loorder)+ f4len (-20*  hiorder)+ 1), fout);
    for (i= 0; i< nchan; ++i) {
      /* lowpass filter */
      fputi32 (1, fout);
      fputf4 (hicutoff, fout);
      fputf4 (-20.0* hiorder, fout);
      /* highpass filter */
      fputi32 (2, fout);
      fputf4 (locutoff, fout);
      fputf4 (-20.0* loorder, fout);
      fputi32 (0xffffffff, fout);
    }
  }

  /* LOCATION DIAGRAM and CHANNEL_LOCATIONS */

  /* CHANNEL UNIT */
#if 0
  no= 0;
  for (i= 0; i< nchan; ++i)
    no+= f4len (ampavg* (100.0 + avgdev [i])/ 100.0);
  fputi32 (EBS_UNITS, fout);
  fputi32 (no+ s4len_cs ("\265V", EBS_CS_LATIN1)* nchan, fout);
  for (i= 0; i< nchan; ++i) {
    fputf4 (ampavg* (100.0 + avgdev [i])/ 100.0, fout);
    fputs4_cs ("\265V", EBS_CS_LATIN1, fout);
  }
#endif

  /* CHANNEL DESCRIPTION */
  if (electrodes!= NULL && electrodes_len!= 2* nchan) {
    fputi32 (EBS_CHANNEL_DESCRIPTION, fout);
    fputi32 (electrodes_len, fout);
    for (i= 0; i< nchan; ++i) {
      fputs4_cs (electrodes [i], EBS_CS_IBM437, fout);
      fputs4 ("", fout);
    }
  }

  /* PROCESSING_HISTORY */
  strcpy(namebuf, "Created by ");
  strcat(namebuf, version_short);
  strcat(namebuf, ":\n  ");
  j = 2;
  for (i = 0; i < argc; i++) {
    k = strlen(argv[i]);
    if (i > 0) 
      if (j + k + 2 < 64)
	strcat(namebuf, " "), j++;
      else
	strcat(namebuf, " \\\n  "), j = 2;
    j += k;
    strcat(namebuf, argv[i]);
  }
  fputi32(EBS_PROCESSING_HISTORY, fout);
  fputi32(s4len(namebuf), fout);
  fputs4(namebuf, fout);

  if (only_ebs_head) {

    /** number of samples **/
    struct stat buf;
    unsigned long length_of_data, number_of_samples;

    fstat(fileno(fin),&buf);
    length_of_data = buf.st_size - (HEADERLENGTH+skip* nchan* 2);
    number_of_samples = (length_of_data/2)/nchan;

    fputi32 (EBS_ASSUMED_NSAMPLES, fout);    /* TAG */
    fputi32 (2L* nchan, fout);               /* Length */
    for (i= 0; i< nchan; ++i)
      fputst (number_of_samples, fout);

    /* FINAL_TAG */
    fputi32(EBS_FINAL_TAG, fout);

    if (fclose(fout)) {
      fprintf(stderr, "Error occured while writing '%s", fnout);
      perror("'");
      remove(fnout);
      return (1);
    }
    return (0);
  }

  /* FINAL_TAG */
  fputi32(EBS_FINAL_TAG, fout);


  /* now we have written the full EBS header */

  /* copy and convert the data part */
  if (fin == stdin || fout == stdout) {
    /* This conversion code for time order formats allows to
       read data from growing files while the recording of data
       is still in progress. dataconc() can't be used for this very
       special application, because it jumps a lot with fseek()
       through the file */
    for (l = 0; l < 2 * nchan * start; l++)
      (void) getc(fin);
    l = 0;
    block = (int) BUFSIZE / (2 *nchan);
    while (!feof(fin) && l< length) {
      count = fread(buffer, 2* nchan, block, fin);
      l+= count;
      if (outcode != EBS_TIL_16) {
	for (i = 0; i < count * nchan; i++) {
	  tmp = buffer[i*2];
	  buffer[i*2] = (buffer[i*2+1] & 0x0f) - 0x08;
	  buffer[i*2+1] = tmp;
	}
      }
      if (fwrite(buffer, 2* nchan, count, fout) != count) {
	perror("Can't write output");
	exit(1);
      }
    }
    length= l;
  } else {
    /* use dataconv() if no stdin or stdout is used (that's the
       usual way of writing format converters and it's very simple
       if you ignore all the perfectionistic error handling below) */
    block = (int) BUFSIZE / (2 *nchan);
    startdata= ftell (fout);
    spike_channel= 0x0f % nchan;
    spike_offset= ((0x0f / nchan)- (start % RECORD_LEN)+ RECORD_LEN) % 
      RECORD_LEN;
    seizure_channel= 0x0d % nchan;
    seizure_offset= ((0x0d / nchan)- (start % RECORD_LEN)+ RECORD_LEN) % 
      RECORD_LEN;
    annotation_channel= 0x11 % nchan;
    annotation_offset= ((0x11 / nchan)- (start % RECORD_LEN)+ RECORD_LEN) % 
      RECORD_LEN;
    ret = dataconv(fin, fout, EBS_TIL_16, outcode, HEADERLENGTH+skip* nchan* 2+
		   2* nchan* start, ftell(fout), nchan, &length, modify);
    if (ret < 0) {
      /* something went wrong, so print an error message and abort */
      switch (ret) {
      case -1:
	fprintf(stderr, "Error occured while reading '%s", fnin);
	if (feof(fin))
	  fprintf(stderr, "': unexpected end of file\n");
	else
	  perror("'");
	break;
      case -2:
	fprintf(stderr, "Error occured while writing '%s", fnout);
	if (feof(fout))
	  fprintf(stderr, "': unexpected end of file\n");
	else
	  perror("'");
	break;
      case -3:
	fprintf(stderr, "Not enough memory available (dataconv)!");
	break;
      default:
	fprintf(stderr, "Unknow return code from dataconv() (%ld)!", ret);
	break;
      }
      fclose(fout);
      remove(fnout);
      exit(1);
    }
  }

  if (fout!= stdout) 
    enddata= ftell (fout);

  /* EBS_EVENTS */
  /* Write spike, seizure and annotation- positions */
  if (fout!= stdout && (spike!= NULL || seizure!= NULL || annotation!= NULL)) {
    unsigned long len= 0;
    if (spike!= NULL)
      len+= s4len (SPIKES_SHORT_DESCRIPTION)+ s4len (SPIKES_DESCRIPTION)+ 1+
	(5+ s4len (""))* nspikes;
    if (seizure!= NULL)
      len+= s4len (SEIZURES_SHORT_DESCRIPTION)+ 
	s4len (SEIZURES_DESCRIPTION)+ 1+ (5+ s4len (""))* nseizures;
    if (annotation!= NULL)
      len+= s4len (ANNOTATIONS_SHORT_DESCRIPTION)+ 
	s4len (ANNOTATIONS_DESCRIPTION)+ 1+ 5* nannotations+ annotationlen;
    fputi32 (EBS_EVENTS, fout);
    fputi32 (len, fout);
    if (spike!= NULL) {
      fputs4 (SPIKES_SHORT_DESCRIPTION, fout);
      fputs4 (SPIKES_DESCRIPTION, fout);
      fputi32 (nspikes, fout);
      for (l=  0; l< nspikes; ++l) {
	fputi32 (0xffffffff, fout);  /* no single channel */
	fputi32 (0x00000000, fout);  /* position hi */
	fputi32 (spike[l], fout);    /* position lo */
	fputi32 (0x00000000, fout);  /* intervall length hi */
	fputi32 (0x00000000, fout);  /* intervall length hi */
	fputs4 ("", fout);           /* info text */
      }
    }
    if (seizure!= NULL) {
      fputs4 (SEIZURES_SHORT_DESCRIPTION, fout);
      fputs4 (SEIZURES_DESCRIPTION, fout);
      fputi32 (nseizures, fout);
      for (l=  0; l< nseizures; ++l) {
	fputi32 (0xffffffff, fout);  /* no single channel */
	fputi32 (0x00000000, fout);  /* position hi */
	fputi32 (seizure [l], fout); /* position lo */
	fputi32 (0x00000000, fout);  /* intervall length hi */
	fputi32 (0x00000000, fout);  /* intervall length hi */
	fputs4 ("", fout);           /* info text */
      }
    }
    if (annotation!= NULL) {
      fputs4 (ANNOTATIONS_SHORT_DESCRIPTION, fout);
      fputs4 (ANNOTATIONS_DESCRIPTION, fout);
      fputi32 (nannotations, fout);
      for (l=  0; l< nannotations; ++l) {
	fputi32 (0xffffffff, fout);             /* no single channel */
	fputi32 (0x00000000, fout);             /* position hi */
	fputi32 (annotation[l].position, fout); /* position lo */
	fputi32 (0x00000000, fout);             /* intervall length hi */
	fputi32 (0x00000000, fout);             /* intervall length hi */
	fputs4 (annotation_text[annotation[l].no-1], fout); /* info text */
      }
    }

    /* FINAL_TAG */
    fputi32(EBS_FINAL_TAG, fout);

    second_header= 1;
  }

  if (verbose) {
    fprintf(stderr, "spikes      = %ld\n", nspikes);
    fprintf(stderr, "seizures    = %ld\n", nseizures);
    fprintf(stderr, "annotations = %ld\n", nannotations);
    if (from_position!= NULL || npositions!= NULL) {
      fprintf(stderr, "\nextracted %ld samples ", length);
      fprintf(stderr, "beginning at position %ld\n", start);
    }
  }
  
  /* correct length in fixed header */
  if (fout != stdout)
    if (fseek(fout, 16L, SEEK_SET) == 0) {
      fputi32(0, fout);
      fputi32(length, fout); 
      if (second_header) {
	fputi32(0, fout);
	fputi32((enddata- startdata)/ 4, fout);
      }
    }

  if (fclose(fout)) {
    fprintf(stderr, "Error occured while writing '%s", fnout);
    perror("'");
    remove(fnout);
    return(1);
  }
  return(0);
}