/*

Read in a Siemens Krenikon MEG 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: kre2ebs.c,v 1.15 1994/12/16 15:41:19 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"
#include "kre2ebs.h"

#ifdef MSDOS
#error This program is for Sun SPARC only
#endif

struct krehead header;

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

#define NO_SAMPLES 0xffffffff

char copyright[]= 
"Read in a Siemens Krenikon MEG 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[] = "Krenikon to EBS converter, V0.1 "__DATE__"\n"
"(C) 1993/94 Markus Prosch, Markus Kuhn, IPB, Erlangen";
char version_short[] = "Krenikon to EBS converter, V0.1, M. Prosch, "
"M. Kuhn, IPB";

char usage[] = "%s\n\nusage: %s [-v] [-e<format>] [-ss<samples> | -st<time>]\n"
                     "          [-ls<samples> | -lt<time>] "
#ifdef MSDOS
  "<krenikon-file> <ebs-file>\n"
#else
  "[(<krenikon-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 krenikon header\n" 
  "\t-e<format>   specify output data format (default is CIB_16 and if\n"
  "\t             stdin or stdout is used 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\n";

#define BUFSIZE 3000


/* Konvert the CS_LATIN1 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_LATIN1, &dummy);  /* use the ebs.c routines for */
  dummy = unicode;                      /* character set conversion */
  gets4(local, 2000, &dummy);
  return (local);
}


/* wrap lines longer than 64 chars */
char *force_64cpl (char *string)
{
  static char result [5000];
  char *from= string, *to= result, *end, *ptr;
  int count;

  /* Ignore leading white spaces */
  while (isspace (*from)) from++;

  count= 0;
  while (*from!= '\0') {
    if (*from== '\r') {from++; continue;}
    if (count== 64 && *from!= '\n') {
      /* begin next line */
      end= to;
      ptr= to- 1;
      /* search space */
      while (ptr> end- 64 && *ptr!= ' ') ptr--;
      if (*ptr== ' ') {
	*ptr= '\n';
	to= ptr+ 1;
	from= from- (end- ptr)+ 1;
      }
      else
	*to++= '\n';
      count= 0;
    }
    *to++= *from;
    count++;
    if (*from== '\n') count= 0;
    from++;
  }
  *to= '\0';

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

  return (result);
}


/* 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, *ptr;
  int i, j, k, count, block;
  unsigned long start= 0l;
  unsigned long l, length= 0xffffffffL;  /* number of samples */
  long outcode = (long) 0xffffffffL;
  long ret;
  int kre_from_stdin = 0; /* - was part of the command line */
  char namebuf[1000];   /* for processing history, etc. */
  int verbose = 0;
  char *from_position= NULL, *npositions= NULL;
  int only_ebs_head= 0;

  char name [80];
  char recording_time [16];
  char description [2000];
  int nfilters, filterlen;
  int *group, *members, ngroups, nmembers, found;

  /* 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 (kre_from_stdin) {
	  fprintf(stderr, usage, version, argv[0]);
	  exit(1);
	}
	kre_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]);
		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 '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 && !kre_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 Krenikon header: it is always sizeof (Krehead) long */
  if (fread (&header, sizeof (Krehead), 1, fin)!= 1) {
    perror ("Error reading header part");
    exit (1);
  }

  if (/* header.version!= KREHEAD_VERSION || */
      header.header_id!= KREHEAD_HEADER_ID ||
      header.header_bytes!= KREHEAD_HEADER_BYTES) {
    if (only_ebs_head)   return(2); 
    fprintf (stderr, "Unrecognized header format\n");
    exit (1);
  }

  /* If -s or -l is given, calculate start and length of segment */
  if (from_position!= NULL)
    start= to_samples (from_position, (double) header.frequ);
  if (npositions!= NULL)
    length= to_samples (npositions, (double) header.frequ);

  /* Remove leading and trailing white spaces */
  remove_spaces (header.first_name);
  remove_spaces (header.last_name);
  remove_spaces (header.pat_id);
  remove_spaces (header.institute_name);
  for (i= 0; i< header.nchn; ++i)
    remove_spaces (header.electrodes [i]);

  /* Patientname */
  *name= '\0';
  if (header.first_name [0]!= 0) 
    strcpy (name, header.first_name);
  if (header.last_name [0]!= 0) {
    if (name [0]!= '0')
      strcat (name, " ");
    strcat (name, header.last_name);
  }

  /* Recording Time */
  strftime (recording_time, 16, "%Y%m%dT%H%M%S", 
	    localtime ((time_t *) &header.measure_start_time));

  /* Description */
  strcpy (description, force_64cpl (header.pat));


  if (verbose) {
    fprintf(stderr, "\nVersion     = V%.2f\n", header.version);
    fprintf(stderr, "points      = %d\n", header.ndat);
    fprintf(stderr, "channels    = %d\n", header.nchn);
    fprintf(stderr, "sample rate = %.0fHz\n", header.frequ);
    fprintf(stderr, "notch       = %.fHz\n", header.notch);
    fprintf(stderr, "freql       = %.fHz\n", header.freql);
    fprintf(stderr, "freqh       = %.fHz\n", header.freqh);
    fprintf(stderr, "resolution  = %d\n", header.resol);
    fprintf(stderr, "name        = '%s'\n", to_local (name));
    fprintf(stderr, "id          = '%s'\n", to_local (header.pat_id));
    fprintf(stderr, "institution = '%s'\n", to_local (header.institute_name));
    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);
    fprintf(stderr, "description = '%s'\n", description);
    fprintf(stderr, "electrodes  = ");
    for (i= 0; i< header.nchn; ++i) 
      fprintf (stderr, "%s'%s'", i==0?"":((i & 7)==0?"\n              ":", "), 
	       header.electrodes [i]);
    fprintf (stderr, "\n");
  }

  /* write EBS file */

  /* fixed header */
  fputi32(EBS_MAGIC1, fout);             /* magic code */
  fputi32(EBS_MAGIC2, fout);
  fputi32(outcode, fout);
  fputi32(header.nchn, 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_LATIN1), fout);
    fputs4_cs (name, EBS_CS_LATIN1, fout);
  }

  /* PATIENT_ID */
  if (header.pat_id[0]!= '\0') {
    fputi32 (EBS_PATIENT_ID, fout);
    fputi32 (s4len_cs (header.pat_id, EBS_CS_LATIN1), fout);
    fputs4_cs (header.pat_id, EBS_CS_LATIN1, fout);
  }

  /* INSTITUTION */
  if (header.institute_name[0]!= '\0') {
    fputi32 (EBS_INSTITUTION, fout);
    fputi32 (s4len_cs (header.institute_name, EBS_CS_LATIN1), fout);
    fputs4_cs (header.institute_name, EBS_CS_LATIN1, fout);
  }

  /* DESCRIPTION */
  if (description[0]!= '\0') {
    fputi32 (EBS_DESCRIPTION, fout);
    fputi32 (s4len_cs (description, EBS_CS_LATIN1), fout);
    fputs4_cs (description, EBS_CS_LATIN1, fout);
  }

  /* SAMPLE_RATE */
  if (header.frequ != 0.0) {
    fputi32(EBS_SAMPLE_RATE, fout);
    fputi32(f4len(header.frequ), fout);
    fputf4(header.frequ, fout);
  }

  /* PREFERRED_INTEGER_RANGE */
  fputi32(EBS_PREFERRED_INTEGER_RANGE, fout);
  fputi32(2*header.nchn, fout);
  for (i = 0; i < header.nchn; i++) {
    fputi32(-(header.resol/2), fout);
    fputi32(header.resol/2+ 1, fout);
  }

  /* RECORDING_TIME */
  fputi32(EBS_RECORDING_TIME, fout);
  fputi32(4, fout);
  fprintf(fout, "%s", recording_time);
  putc(0, fout);
  
  /* CHANNEL_DESCRIPTION */
  j= 0;
  for (i= 0; i< header.nchn; ++i)
    if (header.electrodes [0]!= '\0') {j= 1; break;}
  if (j) {
    j= 0;
    for (i= 0; i< header.nchn; ++i)
      j+= s4len_cs (header.electrodes [i], EBS_CS_LATIN1)+ 1;
    fputi32 (EBS_CHANNEL_DESCRIPTION, fout);
    fputi32 (j, fout);
    for (i= 0; i< header.nchn; ++i) {
      fputs4_cs (header.electrodes [i], EBS_CS_LATIN1, fout);
      fputs4 ("", fout);
    }
  }

  /* FILTERS */
  nfilters= 0;
  filterlen= 0;
  if (header.notch> 10) {nfilters++; filterlen+= f4len (header.notch);}
  if (header.freql< header.freqh) 
    {nfilters+= 2; filterlen+= f4len (header.freql)+ f4len (header.freqh);} 
  if (nfilters!= 0) {
    fputi32 (EBS_FILTERS, fout);
    fputi32 (header.nchn* (nfilters* 2+ filterlen+ 1), fout);
    for (i= 0; i< header.nchn; ++i) {
      if (header.freql< header.freqh) {
	/* lowpass filter */
	fputi32 (1, fout);
	fputf4 (header.freqh, fout);
	fputi32 (0, fout); /* not-a-number: we don't know */
	/* highpass filter */
	fputi32 (2, fout);
	fputf4 (header.freql, fout);
	fputi32 (0, fout); /* not-a-number: we don't know */
      }
      if (header.notch> 10) {
	/* notch filter */
	fputi32 (3, fout);
	fputf4 (header.notch, fout);
	fputi32 (0, fout); /* not-a-number: we don't know */
      }
      fputi32 (0xffffffff, fout);
    }
  }

  /* CHANNEL_GROUPS */
  ngroups= 0;
  nmembers= 0;
  group= (int *) malloc (header.nchn* sizeof (int));
  members= (int *) malloc (header.nchn* sizeof (int));
  if (group!= NULL && members!= NULL) {
    for (i= 0; i< header.nchn; ++i) {
      if (header.chan_group_number [i]== 0xffff) continue;
      /* check whether header.chan_group_number [i] */
      /* appears for the first time                 */
      found= 0;
      for (j= 0; j< ngroups; ++j) 
	if (group [j]== header.chan_group_number [i]) 
	  {found= 1; members [j]++; break;}
      if (!found) {
	members [ngroups]= 1;
	group [ngroups++]= header.chan_group_number [i];
      }
      nmembers++;
    }
    if (ngroups> 0) {
      fputi32 (EBS_CHANNEL_GROUPS, fout);
      fputi32 (3* ngroups+ nmembers, fout);
      for (i= 0; i< ngroups; i++) {
	fputs4 ("", fout); /* do not know group name */
	fputs4 ("", fout); /* do not know group name */
	fputi32 (members [i], fout);
	for (j= 0; j< header.nchn; ++j)
	  if (group [i]== header.chan_group_number [j])
	    fputi32 (j, fout);
      }
    }
  }

  /* LOCATION DIAGRAM and CHANNEL_LOCATIONS */

  /* 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 - header.header_bytes;
    number_of_samples = (length_of_data/2)/header.nchn;

    fputi32 (EBS_ASSUMED_NSAMPLES, fout);    /* TAG */
    fputi32 (2L*header.nchn, fout);          /* Length */
    for (i=0; i<header.nchn; 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 * header.nchn * start; l++)
      (void) getc(fin);
    l= 0;
    block = (int) BUFSIZE / (2 * header.nchn);
    while (!feof(fin) && l< length) {
      count = fread(buffer, 2*header.nchn, block, fin);
      l += count;
      if (outcode != EBS_TIB_16) {
	for (i = 0; i < count * header.nchn; i++) {
	  tmp = buffer[i*2];
	  buffer[i*2] = buffer[i*2+1];
	  buffer[i*2+1] = tmp;
	}
      }
      if (fwrite(buffer, 2*header.nchn, count, fout) != count) {
	perror("Can't write output");
	exit(1);
      }
    }
  } 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_TIB_16, outcode, header.header_bytes+
		   2* header.nchn* start,
		   ftell(fout),
		   header.nchn, &length, NULL /*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);
}