/*

Extract arbitrary intervalls of EBS files
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: ebscut.c,v 1.11 1994/03/01 11:08:31 msprosch Exp $

*/


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "ebs.h"

#ifndef SEEK_CUR
#define SEEK_CUR 1
#endif

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

char copyright[]= 
"Extract arbitrary intervalls of EBS files\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";

const char usage[] = "Extract arbitrary intervalls of EBS files, V0.2\n"
                     "(C) 1993/94, Markus Kuhn, IPB, Erlangen\n\n"
  "usage: %s [-a] (<output-file> | -s)\n"
  "       {<ebs-file> <channel> <start-position> (- | <length>)}\n\n"
  "options:\n"
  "\t-c           print out copyright notice\n"
  "\t-h           print out this message\n"
  "\t-a           output is a single column ASCII list of numbers\n"
  "\t-s           the result is sent to standard output\n\n"
  "\t<start-position> and <length> may be entered as s<samples> or\n"
  "\t             t<time> (if a sample rate is specified)\n\n"
  "\t             example: ebscut -a -s file.ebs 1 t1:23.45 s200\n"
  "\t             extracts 200 samples of channel 1 beginning at position\n"
  "\t             1 minute, 23 seconds and 45 hundredths of file file.ebs\n"
  "\t             and prints the values on the screen (in ASCII)\n\n";

#define BUFSIZE 8192
#define NO_SAMPLES 0xffffffff

struct attribute {         /* a node in a list of attributes */
  char *attribute;
  long attrib_length;
  long tag;
  struct attribute *next;
};

struct fin {
  struct attribute *first_attribute;
  long length, full_length;
  long start;
  int channel;
  FILE *f;
  char *fn;
};

int files;                 /* number of input files */
struct fin *header;
unsigned char buffer[BUFSIZE];

void *mymalloc(size_t bytes)
{
  void *p;
  
  if ((p = malloc(bytes)) == NULL) {
    fprintf(stderr, "Not enough memory available!\n");
    exit(1);
  }
  return p;
}


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


/*
 * In the command line you can specify the start position and the length
 * of a data part either as a simple number of samples or a time
 */

long parse_arg(char *arg, char *type, char *file, float sample_rate)
{
  long result;
  char c;

  /* Check syntax */
  if (to_samples (arg, 0.0)== NO_SAMPLES) {
    fprintf (stderr, "Illegal %s for file %s: '%s'\n", type, file, arg);
    exit (1);
  }

  /* if a time is specified, then the sample rate must be given */
  if (tolower (arg[0])!= 's' && sample_rate< 1.0) {
    fprintf(stderr, "Unspecified sample rate in file '%s'.\n"
	    "You can't use a time for the %s.\n",
	    file, type);      
    exit (1);
  }

  return (to_samples (arg, sample_rate));
}


int main(int argc, char **argv)
{
  FILE *fout = NULL;
  char *fnout = NULL;
  int i, j;
  int a;                        /* current position in command line */
  int ascii = 0;
  int channels;
  long tag;
  unsigned long samples, samples_hi, length, length_hi;
  int flag;
  float sample_rate;
  struct attribute **ap;
  struct attribute *history = NULL;
  char my_history[5000];
  struct attribute *rap, *cap;  /* pointer to reference attribute in
                                   first file and compared attributes in
                                   other files */
  char *cp;
  
  /* test command line options */
  for (a = 1; a < argc && argv[a][0] == '-'; a++)
    for (i = 1; i < 999 && argv[a][i] != 0; i++)
      switch(argv[a][i]) {
      case 'a':
      case 'A':
	ascii = 1;
	break;
      case 's':
      case 'S':
	fout = stdout;
	break;
      case 'c':
      case 'C':
	fprintf (stderr, copyright);
	exit (1);
      default:
	fprintf(stderr, usage, argv[0]);
	exit(1);
      }
  
#ifdef MSDOS
  if (fout == stdout && !ascii) {
    fprintf(stderr, "On MS-DOS systems, binary files can't be sent to "
	    "standard output!\n");
    exit(1);
  }
#endif

  /* output file name */
  if (fout == NULL) {
    if (a >= argc) {
      fprintf(stderr, usage, argv[0]);
      exit(1);
    }
    fnout = argv[a++];
  }
  
  if (argc < 2 || !strcmp(argv[1], "/?") || ((argc - a) & 3) != 0) {
    fprintf(stderr, usage, argv[0]);
    exit(1);
  }

  files = (argc - a) / 4;
  header = (struct fin *) mymalloc(files * sizeof(struct fin));
  
  /* open all input files and read their headers */
  for (i = 0; i < files; i++) {
    header[i].f = fopen(argv[a], "rb");
    if (header[i].f == NULL) {
      fprintf(stderr, "Can't open input file '%s", argv[a]);
      perror("'");
      exit(1);
    }
    header[i].fn = argv[a++];

    /* read fixed header */
    if (fgeti32(header[i].f) != EBS_MAGIC1 ||
	fgeti32(header[i].f) != EBS_MAGIC2 ||
	fgeti32(header[i].f) != EBS_CIB_16 || feof(header[i].f)) {
      fprintf(stderr, "Input file '%s' is not in EBS CIB_16 format!\n",
	      header[i].fn);
      exit(1);
    }
    channels = fgeti32(header[i].f);
    samples_hi = fgeti32(header[i].f);
    samples = fgeti32(header[i].f);
    if (samples_hi != 0) {
      if (samples_hi == 0xffffffffL && samples == 0xffffffffL)
	fprintf(stderr, "File '%s' has an unspecified number of samples!\n",
		header[i].fn);
      else
	fprintf(stderr, "File '%s' is too long!\n", header[i].fn);
      exit(1);
    }
    header[i].full_length = samples;
    length_hi = fgeti32(header[i].f);
    length = fgeti32(header[i].f);
    if (length_hi != 0L &&
        (length_hi != 0xffffffffL || length != 0xffffffffL)) {
      fprintf(stderr, "File '%s' is too long!\n", header[i].fn);
      exit(1);
    }
    header[i].channel = atoi(argv[a++]) - 1;
    if (header[i].channel >= channels || header[i].channel < 0) {
      fprintf(stderr, "File '%s' has only %d channel%s, so you can't use "
	      "channel %d!\n", header[i].fn, channels, 
	      (channels == 1) ? "" : "s", header[i].channel + 1);
      exit(1);
    }

    /* read variable header */
    sample_rate = 0.0;
    ap = &header[i].first_attribute;
    *ap = NULL;
    history = NULL;
    while ((tag = fgeti32(header[i].f)) != EBS_FINAL_TAG) {
      if (feof(header[i].f)) {
	fprintf(stderr, "Unexpected end of file '%s'!\n", header[i].fn);
	exit(1);
      }
      *ap = (struct attribute *) mymalloc(sizeof(struct attribute));
      (*ap)->tag = tag;
      (*ap)->next = NULL;
      (*ap)->attrib_length = fgeti32(header[i].f);
      (*ap)->attribute = (char *) mymalloc((*ap)->attrib_length * 4);
      if ((fread((*ap)->attribute, 1, 4 * (*ap)->attrib_length, header[i].f) 
	   != 4 * (*ap)->attrib_length) || ferror(header[i].f)) {
	fprintf(stderr, "Can't read from file '%s", header[i].fn);
	perror("'");
	exit(1);
      }
      switch (tag) {
      case EBS_UNITS:
	for (j = 0; j < header[i].channel; j++) {
	  getf4((void **) &(*ap)->attribute, NULL);
	  gets4(NULL, 0, (void **) &(*ap)->attribute);
	}
	cp = (*ap)->attribute;
	getf4((void **) &cp, NULL);
	gets4(NULL, 0, (void **) &cp);
	(*ap)->attrib_length = (cp - (*ap)->attribute) >> 2;
	break;
      case EBS_PREFERRED_INTEGER_RANGE:
	(*ap)->attribute += header[i].channel * 8;
	(*ap)->attrib_length = 2;
	break;
      case EBS_CHANNEL_DESCRIPTION:
	for (j = 0; j < header[i].channel * 2; j++)
	  gets4(NULL, 0, (void **) &(*ap)->attribute);
	cp = (*ap)->attribute;
	gets4(NULL, 0, (void **) &cp);
	gets4(NULL, 0, (void **) &cp);
	(*ap)->attrib_length = (cp - (*ap)->attribute) >> 2;
	break;
      case EBS_PROCESSING_HISTORY:
	history = *ap;
	break;
      case EBS_SAMPLE_RATE:
	cp = (*ap)->attribute;
	sample_rate = getf4((void **) &cp, NULL);
	break;
      default:
	/* just take the attribute as it is if the number is even or
           remove it, if the number is odd. */
	if (tag & 1) {
	  (*ap)->attrib_length = 0;
	  (*ap)->attribute = NULL;
	}
	break;
      }
      ap = &((*ap)->next);
    }

    /* determine requested start and length of data part */
    header[i].start = parse_arg(argv[a], "start position",
				header[i].fn, sample_rate);
    a++;
    if (argv[a][0] == '-' && argv[a][1] == '\0')
      header[i].length = header[i].full_length - header[i].start;
    else
      header[i].length = parse_arg(argv[a], "length",
				   header[i].fn, sample_rate);
    a++;
    if (header[i].start >= header[i].full_length) {
      fprintf(stderr, "You can't start at position %ld in file '%s',\n"
	      "because it's length is only %ld!\n", header[i].start, 
	      header[i].fn, header[i].full_length);
      exit(1);
    }
    if (header[i].start + header[i].length - 1 >= header[i].full_length) {
      fprintf(stderr, "You can't read beyond the end of file '%s'!\n",
	      header[i].fn);
      exit(1);
    }
    
  } /* for */

  /* open output file */
  if (fout == NULL) {
    fout = fopen(fnout, ascii ? "w" : "wb");
    if (fout == NULL) {
      fprintf(stderr, "Can't open output file '%s", fnout);
      perror("'");
      exit(1);
    }
  }

  /* write output file */
  if (!ascii) {
    fputi32(EBS_MAGIC1, fout);
    fputi32(EBS_MAGIC2, fout);
    fputi32(EBS_CIB_16, fout);
    fputi32(1, fout);     /* we produce only single-channel files */
    for (i = 0, samples = 0; i < files; samples += header[i++].length);
    fputi32(0, fout);
    fputi32(samples, fout);
    fputi32(0xffffffffL, fout);
    fputi32(0xffffffffL, fout);
    /* prepare the additional processing history */
    if (files > 1)
      strcpy(my_history, "Single-channel parts have been concatenated "
	     "from several files:\n ");
    else
      strcpy(my_history, "A single-channel part has been extracted:\n ");
    i = 0;  /* line length counter */
    for (a = 0; a < argc; a++) {
      j = strlen(argv[a]);
      if (j + i > 70 && i != 0) {
	i = 0;
	strcat(my_history, "\n ");
      }
      strcat(my_history, " ");
      strcat(my_history, argv[a]);
      i += j + 1;
    }
    /* write variable header with those attributes that are identical
       in all input files without the processing histroy. In attributes
       where only a part of the attribute is relevant to the single-
       channel output file, only the relevant part has already been
       read into the header structure.                               */
    rap = header[0].first_attribute;
    while (rap != NULL) {
      flag = (rap->attribute != NULL);
      for (i = 1; i < files && flag; i++) {
	cap = header[i].first_attribute;
	flag = 0;
	while (cap != NULL && cap->tag != rap->tag) cap = cap->next;
	if (cap != NULL && cap->attribute != NULL) 
	  flag = (rap->attrib_length == cap->attrib_length &&
		  memcmp(rap->attribute, cap->attribute, 
			 rap->attrib_length * 4) == 0);
      }
      if (flag && rap->tag != EBS_PROCESSING_HISTORY) {
	fputi32(rap->tag, fout);
	fputi32(rap->attrib_length, fout);
	fwrite(rap->attribute, 4 * rap->attrib_length, 1, fout);
      }
      rap = rap->next;
    }
    /* write PROCESSING_HISTORY attribute */
    fputi32(EBS_PROCESSING_HISTORY, fout);
    if (files == 1 && history != NULL) {
      fputi32(history->attrib_length + s4len(my_history), fout);
      fwrite(history->attribute, 4 * history->attrib_length, 1, fout);
      fputs4(my_history, fout);
    } else {
      fputi32(s4len(my_history), fout);
      fputs4(my_history, fout);
    }
    /* end of variable header */
    fputi32(EBS_FINAL_TAG, fout);
    if (ferror(fout)) {
      perror("Can't write output file");
      fclose(fout);
      if (fnout != NULL) remove(fnout);
      exit(1);
    }
  }
  
  for (i = 0; i < files; i++) {
    fseek(header[i].f, (header[i].channel * header[i].full_length + 
			header[i].start) * 2, SEEK_CUR);
    while (header[i].length > 0) {
      if (feof(header[i].f)) {
	fprintf(stderr, "Unexpected end of file '%s'!\n", header[i].fn);
	fclose(fout);
	if (fnout != NULL) remove(fnout);
	exit(1);
      }
      a = (header[i].length > BUFSIZE/2) ? BUFSIZE/2 : (header[i].length);
      a = fread(buffer, 2, a, header[i].f);
      if (ferror(header[i].f)) {
	fprintf(stderr, "Can't read from file '%s", header[i].fn);
	perror("'");
	fclose(fout);
	if (fnout != NULL) remove(fnout);
	exit(1);
      }
      header[i].length -= a;
      if (ascii)
	for (j = 0; j < a; j++)
	  fprintf(fout, "%d\n", (short) ((buffer[j*2] << 8) | buffer[j*2+1]));
      else
	if (fwrite(buffer, 2, a, fout) != a) {
	  perror("Error while writing output file");
	  fclose(fout);
	  if (fnout != NULL) remove(fnout);
	  exit(1);
	}
    }
  }
  
  if (fclose(fout) || ferror(fout)) {
    perror("Can't close output file");
    if (fnout != NULL) remove(fnout);
    exit(1);
  }

  return 0;
}