header.c

speech signal process tools

  if(h && str && (n = strlen(str))) {
    i=0;
    while(strrchr(str,delim[i])) {
     if(!delim[i]) {
    printf("Couldn't find a unique delimiter from the set %s in head_list()\n",
	       delim);
	return(0);
      } else
	i++;
    }
    if((cp = malloc(n + 6 + strlen(ident) + 1))) {
      sprintf(cp,"%s %c %s %c\n",ident,delim[i],str,delim[i]);
      head_append(h,cp,(n = strlen(cp)));
      free(cp);
      return(n);
    } else
      printf("Can't allocate a buffer in head_ident()\n");
  } else
  printf("Bad arguments to head_ident()\n");
  
  return(0);
}

/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/* Append "size" bytes drawn from "arg" to header "h."  The total
header length (h->nbytes) will be forced to be modulo-4. */
head_append(h, arg, size)
     Header *h;
     char *arg;
     int size;
{
  register int newpad, newhead_size, j;

  if(h && arg && size){
    newhead_size = size + h->nbytes - h->npad;
    if((j = newhead_size & 3))	/* force modulo-4 bytes */
      newpad = 4 - j;
    else
      newpad = 0;
    newhead_size += newpad;
    if(!(h->header = realloc(h->header, newhead_size + 1))) {
      printf("Can't allocate enough buffer space in head_append()\n");
      return(FALSE);
    }
    chcopy(h->header + h->nbytes - h->npad, arg, size);
    h->npad = newpad;
    for( ; newpad; newpad--)
      h->header[newhead_size-newpad] = ' '; /* pad with spaces */
    h->header[newhead_size] = 0;
    h->nbytes = newhead_size;
    return(TRUE);
  }
  return(FALSE);
}
  
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/* Read a signal header and initialize the Signal structure values
   accordingly.  Note that multiple versions of the header may be read, but
   only the most recently specified values are retained in the Signal
   structure.  Sig->bytes_skip will be set to the number of bytes offset in
   the file required to skip the header.  Minimal support is provided here for
   Nirvonics headers and Peter Kroon's headers.  Normal return is TRUE, else
   FALSE. */
w_read_header(sig, head)
     Signal *sig;
     Header *head;
{
  if (debug_level >= 1)
      printf("w_read_header: head->magic = 0x%x.\n", head->magic);
  if( sig && head ) {
    if(head->magic == SIGNAL_MAGIC) {
      if (debug_level >= 1)
	  printf("w_read_header: calling setup_access & get_header_args.\n");
      setup_access(sig);
      get_header_args(head->header,&head_a0);
      sig->bytes_skip = head->nbytes + 12;
      if (debug_level >= 1)
	  printf("w_read_header: sig->bytes_skip = %d.\n", sig->bytes_skip);
      return(TRUE);
    }
    switch(head->magic)
    {
    case ESPS_MAGIC:
	if (debug_level >= 1)
	    printf("w_read_header: calling read_esps_hdr.\n");
    	if (!read_esps_hdr(sig, head->esps_hdr))
	{
	    printf("w_read_header: call to read_esps_hdr failed.\n");
    	    return FALSE;
    	}
 
	sig->bytes_skip = head->esps_nbytes;
    	{
	    Header	*h;

	    h = w_write_header(sig);
	    head->header = h->header;
	    head->nbytes = h->nbytes;
	    free(h);
	}
	if (debug_level >= 1)
	    printf("w_read_header: sig->bytes_skip = %d.\n", sig->bytes_skip);
	return TRUE;
	break;
    case HEADER_MAGIC:
    case RHEADR_MAGIC: 
	{
#define pk2(byt) (p=bpos+byt, ((int)p[1])&255 | (((int)p[0])&255)<<8)
#define pk4(byt) \
(p=bpos+byt, ((int)p[1])&255 | (((int)p[0])&255)<<8 \
	 | (((int)p[3])&255)<<16 | (((int)p[2])&255)<<24);
	    char *bpos = head->header, *p;
	    int type, size;
	    for(;;) {
	      size=pk4(0);
	      if(size<8) size=8;
	      type=pk4(4);
	      if(type == 2) {
		sig->freq = pk4(8);
		sig->type = (pk2(14) ? P_SHORTS : P_USHORTS);
	      }   
	      if(type == 0) break;
	      bpos += size;
	    }
	    sig->bytes_skip = head->nbytes + 4;
	    return(TRUE);
        }
    case SPPACK_MAGIC:
        {
	    Header *h;
	    Sppack *sphdr;
    	    int length = 0;
    	    int fd = -1;

    	    sig->bytes_skip = 01000;
    	    if (sig->file >= 0) {	/* already open */
	    	length = lseek(sig->file,0L,2) - sig->bytes_skip;
	    	lseek(sig->file,(long)sig->bytes_skip,0);
	    }
	    else if ((fd=open(sig->name,O_RDONLY)) >= 0) {
		length = lseek(fd,0L,2) - sig->bytes_skip;
		close(fd);
	    }
    	    if (length < 0)
    	    	length = 0;
	    sphdr = (Sppack*)(head->header);
	    if(sphdr->type < 0 ) 
	      sphdr->type = - sphdr->type ;
	    switch (sphdr->type / 1000) {
	    case 1:
	      sig->type = 4;
	      sig->file_size = length / sizeof(short);
	      break;
	    case 2:
	      sig->type = 5;
	      sig->file_size = length / sizeof(int);
	      break;
	    case 3:
	      sig->type = 7;
	      sig->file_size = length / sizeof(float);
	      break;
	    case 4:
	      sig->type = 8;
	      sig->file_size = length / sizeof(double);
	      break;
	    default:
	      printf("not able to handle this data type\n");
	      return(FALSE);
	    }
	    sig->freq = sphdr->frequency;
	    sig->band = sig->freq/2.0;
    	    if (sig->freq > 0)
    	    	sig->end_time = sig->start_time + sig->file_size/sig->freq;
	    if(head->header) free(head->header);
	    if((h = w_write_header(sig))) {
	      head->header = h->header;
	      head->nbytes = h->nbytes;
	      free(h);
	      return(TRUE);
	    } else {
	      printf("Problems with spp header in w_read_header\n");
	      return(FALSE);
	    }
    	}
    default:
    	printf("Header type %d is not yet recognized.\n",head->magic);
    	printf("Please add processing for this type to w_read_header()");
      	printf(" in header.c\n");
      	return(FALSE);
    }
  }
  return(FALSE);
	   
}

/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/* Write a SIG header to a file.  The file must be open for writing and
   the file pointer must be properly set (i.e. to the beginning of the file
   for single-segment files, or the beginning of a segment for multi-segment
   files). */
put_header(h,fd)
     Header *h;
     int fd;
{
  char temp[10];
  int i;
  
  if (fd >= 0) {
      if (h && h->nbytes && (h->magic == SIGNAL_MAGIC) && h->header) {
	  i = SIGNAL_MAGIC;
	  sprintf(temp,"%7d\n",h->nbytes);
	  if((write(fd,&i,4) == 4) && (write(fd,temp,8) == 8)) {
	      if(write(fd,h->header,h->nbytes) == h->nbytes)
		  return(TRUE);
	      else
		  printf("Can't write body of header in put_header()\n");
	  } else
	      printf("Can't write header header in put_header()\n");
      }
      else if (h && h->magic == ESPS_MAGIC && h->esps_hdr && h->strm)
      {
	  write_header(h->esps_hdr, h->strm);
	  h->esps_nbytes = ftell(h->strm);
	  return TRUE;
      }
      else
	  printf("Bad header in put_header()\n");
  } else
      printf("File is not open in put_header()\n");
  return(FALSE);
}

void 
byte_swap(buf,nbyt)
char *buf;
int nbyt;
{
  register char *p = buf-1, c, *p2 = p + (nbyt & -2);
  while(++p < p2) {
    c = *p;
    *p = p[1];
    *++p = c;
  }
}

/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/* Read the header from the file whose file descriptor is "file."
   Return the loaded Header structure. */
Header *
get_header(file)
    int	    file;
{
    int     magic, nbytes, sum, type;
    Header  *h = NULL;
    char    count[8];

    if (debug_level >= 1)
	printf("get_header: function entered; file descriptor %d.\n", file);
    if(file >= 0)
    {
	/* first we try to read an ESPS header*/
	struct header *hd;
	FILE          *strm;

	strm = fdopen(file, "r");
	if (!strm)
	{
	    printf("get_header: Can't make stream for file descriptor.\n");
	    return(NULL);
	}

	hd = read_header(strm);

	if (hd == NULL && debug_level >= 1)
	    printf("get_header: couldn't read ESPS header; maybe it's another kind.\n");

	if (hd != NULL) /*process as ESPS file*/
	{
	    if (debug_level >= 1)
		if (hd->common.type == FT_FEA) 
		    printf("get_header: this is an ESPS file, type FT_FEA, subtype %s.\n",
			   fea_file_type[hd->hd.fea->fea_type]);
		else
		    printf("get_header: this is an ESPS file, type %s.\n",
			   file_type[hd->common.type]);
	  
	    h = w_new_header(0);
	    if (!h)
	    {
		printf("get_header: Can't create Waves header structure.\n");
		return(NULL);
	    }

	    h->magic = ESPS_MAGIC;
	    h->esps_nbytes = ftell(strm);
	    if (debug_level >= 1)
		printf("get_header: h->esps_nbytes = %ld.\n", h->esps_nbytes);
	    h->e_scrsd = 0;
	    h->e_short = 0;
	    h->strm = strm;
	    /*here's the place to catch FT_SD and stick in a FEA_SD header*/
	    /*unless we want old-style SD to result in old-style SD*/
	    h->esps_hdr = hd;
	    return h;
	}
    	else			/* Not an ESPS file */
	{
	    lseek(file, 0L, L_SET);
	    if((read(file,&magic,4) == 4))
	    {
		if (debug_level >= 1)
		    printf("get_header: magic = %d.\n", magic);
		if (magic == SIGNAL_MAGIC)
		{
		    if((read(file,count,8) == 8) && (count[7] == '\n'))
		    {
			nbytes = 0;
			count[7] = 0;
			if(strlen(count)) sscanf(count,"%ld",&nbytes);
			if(nbytes)
			{
			    if ((h = w_new_header(nbytes))
				&& (read(file,h->header,nbytes) == nbytes))
			    {
				h->header[nbytes] = 0;
				return(h);
			    } else
				printf("Can't allocate header and read file in get_header()\n");
			} else
			    printf("Zero header size in get_header()\n");
		    } else
			printf("Can't read header count in get_header()\n");
		    return(NULL);
		}
		switch(magic)
		{
		case HEADER_MAGIC:
		    {

#define tran4(x) \
    (magic == RHEADR_MAGIC ? \
	(int)(	 ((((unsigned) x)&0xff000000)>>24) \
		|((((unsigned) x)&0x00ff0000)>>8) \
		|((((unsigned) x)&0x0000ff00)<<8) \
		|((((unsigned) x)&0x000000ff)<<24)) \
	:(int)(  ((((unsigned) x)&0xffff0000)>>16) \
		|((((unsigned) x)&0x000000ff)<<16)))

			sum = 4;
			while ( (read(file,&nbytes,4) == 4) &&
				(read(file,&type,  4) == 4))
			{
			    type = tran4(type);
			    nbytes = tran4(nbytes);
			    if(nbytes < 8) nbytes = 8;
			    sum += nbytes;
			    if(type == 0) break;
			    if(nbytes > 8) lseek(file, nbytes-8,L_INCR);
			}
			lseek(file,4,L_SET);
			if(h = w_new_header(sum)) {
			    if((nbytes=read(file,h->header,sum)) != sum) {
				printf("Trouble reading Nirvonics header");
				break;
			    }
			    if(magic == RHEADR_MAGIC)
				byte_swap(h->header,sum);
			    h->magic = magic;
			    return(h);
			} else
			printf("Can't allocate header and read file in get_header()\n");
		    }
		    break;
		default:		/* Check if it is an SPPACK header */
		    {
			Sppack *sphdr;

			lseek(file,0,0);
			if(!(sphdr = (Sppack*)malloc(sizeof(Sppack)))) {
			    printf("Can't allocate Sppack in get_header()\n");
			    return(NULL);
			}
			if((read(file,sphdr,sizeof(Sppack)) == sizeof(Sppack)))
			{
			    if(sphdr->magic == SPPACK_MAGIC) {
				if((h = w_new_header(0))) {
				    h->header = (char*)sphdr;
				    h->magic = sphdr->magic;
				    return(h);
				} else
				    printf("Can't allocate header and read file in get_header()\n");
				return(NULL);
			    }
			}
		    }
		    /* printf("Unknown header type: %d in get_header()\n"); */
		    return(NULL);
		}
	    } else
		printf("Can't read the file\n");
	}
    } else
    	printf("Bad file descriptor in get_header()\n");
  
    if(h) free(h);
  
    return(NULL);
}

/*      ----------------------------------------------------------      */
char *
get_date()
{
    long	tim, time();
    char	*date, *ctime(), *c;
    
    tim = time((long*)0);
    if((c = date = ctime(&tim))) {
      while(*c != '\n') c++;
      *c = 0;
    }
    return(date);
}

/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
update_hdr_for_mod(sig)		/* add date & comment for modification */
     Signal *sig;
{
  char comment[256];

  head_printf(sig->header,"time",get_date());
  sprintf(comment,"modify_signal: signal %s",sig->name);
  head_printf(sig->header,"operation",comment);
  if (sig->header->magic == ESPS_MAGIC)
  {
      sprintf(comment, "%s\n", get_date());
      add_comment(sig->header->esps_hdr, comment);
      sprintf(comment, "modify_signal: signal %s\n", sig->name);
      add_comment(sig->header->esps_hdr, comment);
  }
  return;
}