/*

Read in a Schwind Brain Star EEG file and convert it into an EBS file.
Copyright (C) 1993/94 Markus 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: bs2ebs.c,v 1.25 1994/12/16 15:38:14 aescheel Exp $

*/


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <math.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

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

#undef PI
#define PI 3.14159265358979323846

#define NO_SAMPLES 0xffffffff

char copyright[]= 
"Read in a Schwind Brain Star EEG file and convert it into an EBS file.\n"
"Copyright (C) 1993/94 Markus 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[] = "Brain Star to EBS converter, V1.0\n(C) 1993/94 Markus Kuhn, IPB, Erlangen";
char version_short[] = "Brain Star to EBS converter, V1.0, Markus Kuhn, IPB";

char usage[] = "%s\n\nusage: %s [-vfrd] [-e<format] "
                     "[-ss<samples> | -st<time>]\n"
                     "          [-ls<samples> | -lt<time>] "
#ifdef MSDOS
  "<brainstar-file> <ebs-file>\n"
#else
  "[(<brainstar-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 brainstar header\n" 
  "\t-f           don't stop conversion because of misterious header,\n"
  "\t             force output (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-d           don't create a graphical diagram with channel positions\n"
  "\t-r           don't use the coordinates of the reference potential\n\n";


#define BUFSIZE 3000

#define CGMELEM(class, id, length) \
          fputi16(((class) << 12) | (id << 5) | length, fout)

/* modify routine for dataconv(): Brainstar data is stored as 16-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 *start, int length, unsigned long channel,
	    unsigned long pos)
{
  int i;
  for (i = 0; i < length; i++) 
    start[i] -= 0x800;
}


/* 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);
}


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;
  int i, j, k, count, block;
  unsigned long length = 0xffffffffL, l;  /* number of samples */
  unsigned long start = 0; /* first sample position that will be copied */
  char *from_position= NULL, *npositions= NULL;
  long outcode = (long) 0xffffffffL;
  long ret;
  int bs_from_stdin = 0; /* - was part of the command line */
  int headerblocks;
  char namebuf[1000];    /* for processing history, etc. */
  void *dummy;
  double w;
  int force = 0, verbose = 0, diagram = 1, reference = 1;
  int only_ebs_head = 0;
  
  /* Brainstar header fields (names are identical to those in the manual) */
  char name[41];         /* for the patient name, etc. */
  int points, channels, eich, time, typ;
  int flags, delay, filter, timconst;
  char (*hot)[4], (*ref)[4], (*hotc)[2], (*refc)[2];
  
  /* do all the command line and file open stuff */
  fin = stdin;
  fout = stdout;
  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 (bs_from_stdin) {
	  fprintf(stderr, usage, version, argv[0]);
	  exit(1);
	}
	bs_from_stdin = 1;
      } else
	for (j = 1; j < 2000 && argv[i][j] != 0; j++)
	  switch (argv[i][j]) {
	  case 'd':
	  case 'D':
	    diagram = 0;
	    break;
	  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 '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 'r':
	  case 'R':
	    reference = 0;
	    break;
	  case 'f':
	  case 'F':
	    force = 1;
	  case 'v':
	  case 'V':
	    fprintf(stderr, "%s\n", version);
	    verbose = 1;
	    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 && !bs_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 BrainStar header: it is ceiling(channels/16)*256 bytes long,
     the first 256-bytes block contains general information and information
     for the first 16 channels, each further 256-bytes block contains
     information about the next 16 channels in the same format and position
     as in the first block. */
  points = fgeti16l(fin);
  channels = fgeti16l(fin);
  headerblocks = (channels < 1) ? 1 : (((channels - 1) | 15) + 1) >> 4;
  hot =  (char (*)[4]) malloc(4 * 16 * headerblocks);
  ref =  (char (*)[4]) malloc(4 * 16 * headerblocks);
  hotc = (char (*)[2]) malloc(2 * 16 * headerblocks);
  refc = (char (*)[2]) malloc(2 * 16 * headerblocks);
  if (hot == NULL || ref == NULL || hotc == NULL || refc == NULL) {
    fprintf(stderr, "Not enough memory (hot, etc.)!\n");
    exit(1);
  }
  eich = fgeti16l(fin);
  time = fgeti16l(fin);
  fread(name, 1, 40, fin);
  name[40] = '\0';
  remove_spaces (name);
  typ = fgeti16l(fin);
  flags = fgeti16l(fin);
  delay = fgeti16l(fin);
  for (k = 0; k < 16; k++)
    fread(hot[k], 3, 1, fin);
  for (k = 0; k < 16; k++)
    fread(ref[k], 3, 1, fin);
  fread(hotc, 2, 16, fin);
  fread(refc, 2, 16, fin);
  filter = fgeti16l(fin);
  timconst = fgeti16l(fin);
  /* skip empty rest of first 256-bytes block */
  for (j = 0; j < 38; j++) fgetc(fin);
  /* read further header blocks */
  for (i = 1; i < headerblocks; i++) {
    for (j = 0; j < 54; j++) fgetc(fin);
    for (k = 0; k < 16; k++)
      fread(hot[16*i+k], 3, 1, fin);
    for (k = 0; k < 16; k++)
      fread(ref[16*i+k], 3, 1, fin);
    fread(hotc + 16*i, 2, 16, fin);
    fread(refc + 16*i, 2, 16, fin);
    for (j = 0; j < 42; j++) fgetc(fin);
  }
  if (feof(fin)) {
    fprintf(stderr, "Unexpected end of input file!\n");
    exit(1);
  }
  if (verbose) {
    fprintf(stderr, "\npoints    = %d\n", points);
    fprintf(stderr, "channels  = %d\n", channels);
    fprintf(stderr, "eich      = %d\n", eich);
    fprintf(stderr, "time      = %d\n", time);
    dummy = namebuf;
    puts4_cs(name, EBS_CS_IBM437, &dummy);  /* use the ebs.c routines for */
    dummy = namebuf;                        /* character set conversion */
    gets4(namebuf + 300, 100, &dummy);
    fprintf(stderr, "name      = '%s'\n", namebuf + 300);
    fprintf(stderr, "typ       = %d\n", typ);
    fprintf(stderr, "flags     = 0x%04x (%s, %s, %s, %s)\n", flags,
	    (flags & 1) ? "polar coordinates" : "area coordinates",
	    (flags & 2) ? "DC recording" : "AC recording",
	    (flags & 8) ? "discontinuous data" : "continuous data",
	    (flags & 16) ? "V 2.0" : "V 1");
    fprintf(stderr, "delay     = %d\n", delay);
    if (flags & 4) {
      fprintf(stderr, "filter    = %d Hz\n", filter);
      fprintf(stderr, "timeconst = %d %s\n", timconst, timconst ? "ms" : "");
    }
    fprintf(stderr, "hotc      =");
    for (i = 0; i < channels; i++)
      fprintf(stderr, " %d/%d%s", hotc[i][0], hotc[i][1],
	      (i == channels-1) ? ".\n" :
	      (((i&7) == 7) ? ",\n           " : ","));
    fprintf(stderr, "refc      =");
    for (i = 0; i < channels; i++)
      fprintf(stderr, " %d/%d%s", refc[i][0], refc[i][1],
	      (i == channels-1) ? ".\n\n" :
	      (((i&7) == 7) ? ",\n           " : ","));
  }
  if (typ != 0) {
    fprintf(stderr, "%s input file is not a Brainstar EEG-File "
	    "(typ = %d).\n", force ? "Warning:" : "Sorry,", typ);
    if (only_ebs_head) return(2);
    if (!force) {
      fprintf(stderr, "No output written (use -f to override).\n");
      fclose(fout);
      if (fout != stdout) remove(fnout);
      exit(1);
    }
  }
  if (points != 1) {
    fprintf(stderr, "%s can't handle this Brainstar format "
	    "(points = %d).\n", force ? "Warning:" : "Sorry,", points);
    if (!force) {
      fprintf(stderr, "No output written (use -f to override).\n");
      fclose(fout);
      if (fout != stdout) remove(fnout);
      exit(1);
    }
  }
  if ((flags & 1) && diagram) {
    fprintf(stderr, "%s this file uses polar coordinates.\n",
	    force ? "Warning:" : "Sorry,");
    if (!force) {
      fprintf(stderr, "No output written (use -f to override).\n");
      fclose(fout);
      if (fout != stdout) remove(fnout);
      exit(1);
    }
  }

  if (time != 0) {    
    /* If -s or -l is given, calculate start and length of segment */
    if (from_position!= NULL) {
      double frq= 1e6/ (double) time;
      start= to_samples (from_position, (double) frq);
    }
    if (npositions!= NULL) {
      double frq= 1e6/ (double) time;
      length= to_samples (npositions, (double) frq);
    }
  }
  else
    if ((from_position!= NULL && tolower (from_position [0])!= 's') ||
	(npositions!= NULL && tolower (npositions [0])!= 's')) {
      fprintf (stderr, "No sample rate specified, can't use -st<time>\n");
      fclose (fout);
      exit (1);
    }
      
  /* write EBS file */

  /* fixed header */
  fputi32(EBS_MAGIC1, fout);            /* magic code */
  fputi32(EBS_MAGIC2, fout);
  fputi32(outcode, fout);
  fputi32(channels, 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 */

  /* SAMPLE_RATE */
  if (time != 0) {
    fputi32(EBS_SAMPLE_RATE, fout);
    fputi32(f4len(1e6/(double)time), fout);
    fputf4(1e6/(double)time, fout);
  }
    
  /* PREFERRED_INTEGER_RANGE */
  fputi32(EBS_PREFERRED_INTEGER_RANGE, fout);
  fputi32(2*channels, fout);
  for (i = 0; i < channels; i++) {
    fputi32(-2048, fout);
    fputi32(2048, fout);
  }

  /* UNITS */
  if (eich != 0) {
    fputi32(EBS_UNITS, fout);
    fputi32((f4len(100.0/(double)eich) +
	     s4len_cs("\265V", EBS_CS_LATIN1)) *
	    channels, fout);
    for (i = 0; i < channels; i++) {
      fputf4(100.0/(double)eich, fout);
      fputs4_cs("\265V", EBS_CS_LATIN1, fout);
    }
  }

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

  /* CHANNEL_DESCRIPTION */
  if (hot[0][0] != '?') {
    for (i = 0; i < channels; i++) {
      /* remove unnecessary spaces */
      hot[i][3] = '\0';
      remove_spaces (hot [i]);
    }
    j = 0;
    for (i = 0; i < channels; i++)
      j += s4len_cs(hot[i], EBS_CS_IBM437) + 1;
    fputi32(EBS_CHANNEL_DESCRIPTION, fout);
    fputi32(j, fout);
    for (i = 0; i < channels; i++) {
      fputs4_cs(hot[i], EBS_CS_IBM437, fout);
      fputs4("", fout);
    }
  }
  
  /* FILTERS */
  if (flags & 4) {
    fputi32(EBS_FILTERS, fout);
    fputi32(channels * (5 + f4len(filter) +
			f4len(1/(2*PI* (double)timconst/1000))), fout);
    for (i = 0; i < channels; i++) {
      /* lowpass filter */
      fputi32(1, fout);
      fputf4(filter, fout);
      fputi32(0, fout); /* not-a-number: we don't know */
      /* highpass filter */
      fputi32(2, fout);
      fputf4(1/(2*PI* (double)timconst/1000), fout);
      fputi32(0, fout); /* not-a-number: we don't know */
      /* end of filter list */
      fputi32(0xffffffffL, fout);
    }
  }

  /* LOCATION DIAGRAM and CHANNEL_LOCATIONS */
  if (diagram) {
    /* LOCATION_DIAGRAM */
    fputi32(EBS_LOCATION_DIAGRAM, fout);
    fputi32(104, fout);

    CGMELEM(0, 1, 1);                     /* begin metafile */
    putc(0, fout);     /* parameter: "" */
    putc(0, fout);     /* fill byte */
    CGMELEM(1, 1, 2);                     /* metafile version */
    fputi16(1, fout);  /* Version: 1 */
    CGMELEM(1, 11, 20);                   /* metafile element list */
    fputi16(5, fout);
    fputi16(0, fout);  fputi16(3, fout);  /* begin picture */
    fputi16(0, fout);  fputi16(4, fout);  /* begin picture body */
    fputi16(0, fout);  fputi16(5, fout);  /* end picture */
    fputi16(2, fout);  fputi16(6, fout);  /* begin picture */
    fputi16(4, fout);  fputi16(1, fout);  /* begin picture */

    CGMELEM(0, 3, 1);                     /* begin picture */
    putc(0, fout);     /* parameter: "" */
    putc(0, fout);     /* fill byte */
    CGMELEM(2, 6, 8);                     /* vdc extend */
    fputi16(-10, fout);
    fputi16(-10, fout);
    fputi16(110, fout);
    fputi16(110, fout);
    CGMELEM(0, 4, 0);                     /* begin picture body */

    /* circle representing head */
    CGMELEM(4, 1, 31);                    /* polyline, long form */
    fputi16(244, fout);
    for (i = 0; i <= 60; i++) {
      w = 2.0 * PI * i / 60.0;
      fputi16(50.5 + 50 * cos(w), fout);
      fputi16(50.5 + 50 * sin(w), fout);
    }
    /* nose */
    CGMELEM(4, 1, 12);                    /* polyline, short form */
    fputi16(45, fout);   fputi16(100, fout);
    fputi16(50, fout);   fputi16(107, fout);
    fputi16(55, fout);   fputi16(100, fout);
    /* lines */
    CGMELEM(4, 1, 8);                     /* polyline, short form */
    fputi16(10, fout);   fputi16(21, fout);
    fputi16(10, fout);   fputi16(79, fout);
    CGMELEM(4, 1, 8);                     /* polyline, short form */
    fputi16(30, fout);   fputi16(4, fout);
    fputi16(30, fout);   fputi16(96, fout);
    CGMELEM(4, 1, 8);                     /* polyline, short form */
    fputi16(50, fout);   fputi16(0, fout);
    fputi16(50, fout);   fputi16(100, fout);
    CGMELEM(4, 1, 8);                     /* polyline, short form */
    fputi16(70, fout);   fputi16(4, fout);
    fputi16(70, fout);   fputi16(96, fout);
    CGMELEM(4, 1, 8);                     /* polyline, short form */
    fputi16(90, fout);   fputi16(21, fout);
    fputi16(90, fout);   fputi16(79, fout);
    CGMELEM(4, 1, 8);                     /* polyline, short form */
    fputi16(21, fout);   fputi16(10, fout);
    fputi16(79, fout);   fputi16(10, fout);
    CGMELEM(4, 1, 8);                     /* polyline, short form */
    fputi16(4, fout);    fputi16(30, fout);
    fputi16(96, fout);   fputi16(30, fout);
    CGMELEM(4, 1, 8);                     /* polyline, short form */
    fputi16(0, fout);    fputi16(50, fout);
    fputi16(100, fout);  fputi16(50, fout);
    CGMELEM(4, 1, 8);                     /* polyline, short form */
    fputi16(4, fout);    fputi16(70, fout);
    fputi16(96, fout);   fputi16(70, fout);
    CGMELEM(4, 1, 8);                     /* polyline, short form */
    fputi16(21, fout);   fputi16(90, fout);
    fputi16(79, fout);   fputi16(90, fout);

    CGMELEM(0, 5, 0);                     /* end picture */
    CGMELEM(0, 2, 0);                     /* end metafile */
    fputi16(0, fout);

    /* CHANNEL LOCATIONS */
    fputi32(EBS_CHANNEL_LOCATIONS, fout);
    fputi32(6 * channels, fout);
    for (i = 0; i < channels; i++) {
      fputi32(i, fout);
      fputi32(0, fout);
      fputi32(hotc[i][0], fout);
      fputi32(100 - hotc[i][1], fout);
      if (reference) {
	fputi32(refc[i][0], fout);
	fputi32(100 - refc[i][1], fout);
      } else {
	fputi32(0x80000000L, fout);
	fputi32(0x80000000L, 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 - ftell(fin);
    number_of_samples = (length_of_data/2)/channels;

    fputi32 (EBS_ASSUMED_NSAMPLES, fout);    /* TAG */
    fputi32 (2L*channels, fout);          /* Length */
    for (i=0; i<channels; 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 * channels * start; l++)
      (void) getc(fin);
    l = 0;
    block = (int) BUFSIZE / (2 * channels);
    while (!feof(fin) && l < length) {
      count = fread(buffer, 2*channels, 
		    (block < length - l) ? block : (length - l), fin);
      l += count;
      if (outcode == EBS_TIL_16) {
	for (i = 0; i < count * channels; i++)
	  buffer[i*2+1] = buffer[i*2+1] - 0x08;
      } else {
	for (i = 0; i < count * channels; i++) {
	  tmp = buffer[i*2];
	  buffer[i*2] = buffer[i*2+1] - 0x08;
	  buffer[i*2+1] = tmp;
	}
      }
      if (fwrite(buffer, 2*channels, 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) */
    ret = dataconv(fin, fout, EBS_TIL_16, outcode, 
		   ftell(fin) + 2 * channels * start, ftell(fout),
		   channels, &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 -s or -l was specified, print out start and length of extracted data */
  if (verbose && (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 (fclose(fout)) {
    fprintf(stderr, "Error occured while writing '%s", fnout);
    perror("'");
    remove(fnout);
  }
  return(0);
}