fea_sup.c

speech signal process tools

/* fea_sup: support modules for spstoa(1-ESPS) and atosps(1-ESPS).
 *
 * This material contains proprietary software of Entropic Speech, Inc.
 * Any reproduction, distribution, or publication without the prior
 * written permission of Entropic Speech, Inc. is strictly prohibited.
 * Any public distribution of copies of this work authorized in writing by
 * Entropic Speech, Inc. must bear the notice
 *
 *    "Copyright (c) 1987 Entropic Speech, Inc.; All rights reserved"
 *
 * Author: Ajaipal S. Virdy, Entropic Speech, Inc.
 *
 * Modules:  dump_fea_head, cvt_feahdr, cvt_fearec
 *
 */

#include <stdio.h>
#include <esps/esps.h>
#include <esps/fea.h>
#include <assert.h>
#include <ctype.h>
#include <esps/unix.h>

#ifdef SCCS
    static char *sccs_id = "@(#)fea_sup.c	3.11 6/9/93 ESI";
#endif

#define VERSION "3.11"
#define DATE "6/9/93"
#define PROG "fea_sup.c"
#define BUFSIZE 1024


/*
 * E S P S
 *  F U N C T I O N S
 *   R E F E R E N C E D
 */

short	fea_encode ();
float	**f_mat_alloc ();
long    get_fea_siz ();
short   get_fea_type ();
char	*get_genhd ();
int	lin_search2 ();
char	*savestring ();

/*
 * L O C A L
 *  F U N C T I O N S
 *   R E F E R E N C E D
 */

void	clear_fea_rec ();
char	**fill_codes1();

/*
 * G L O B A L
 *  V A R I A B L E S
 */

char    buf[BUFSIZE];
int	debug_level = 0;


dump_fea_head (tstrm, fh)
register FILE	*tstrm;
register struct header	*fh;
{
    extern  errno;
    extern  char *get_cmd_line ();

    struct fea_header	*fea;

    int	    i,
	    j,
	    k;

    int	    ngen = 0;
    char    **gen_names;

    long   size;
    short  type;

    int     getopt ();
    short   type_str ();
    void    print_rec ();


    fea = fh -> hd.fea;

    Fprintf (tstrm, 
    "%x %x %x\n",
    fh->common.tag, fea->fea_type, fea->segment_labeled);

    for (i = 0; i < fea -> field_count; i++) {
	Fprintf (tstrm, "%s %s ", fea -> names[i],
		type_codes[fea -> types[i]]);
	Fprintf (tstrm, "%ld %d ", fea -> sizes[i], fea -> ranks[i]);
	if (fea -> ranks[i] > 1)
	    for (j = 0; j < fea -> ranks[i]; j++)
		Fprintf (tstrm, "%ld ", fea -> dimens[i][j]);
	Fprintf (tstrm, "\n");
	if (fea -> types[i] == CODED) {
	    char  **s;
	    s = fea -> enums[i];
	    while (*s != NULL) {
		Fprintf (tstrm, " %s\n", *s++);
	    }
	}
	if (fea -> derived[i]) {
	    char  **s;
	    s = fea -> srcfields[i];
	    while (*s != NULL) {
		Fprintf (tstrm, "\t%s\n", *s++);
	    }
	}
    }

 gen_names = genhd_list (&ngen, fh);
 if (ngen > 0) {
    for (i = 0; i < ngen; i++) {
	char *cptr; double *dptr; float *fptr; long *lptr; short *sptr;
	type = genhd_type (gen_names[i], (int *) &size, fh);
	Fprintf (tstrm, "\n");
	Fprintf (tstrm, "@%s %s %ld ", gen_names[i], type_codes[type], size);
	k = 0;
	cptr = get_genhd(gen_names[i], fh);
	if (type == CODED) {
	    char    **s;
	    s = genhd_codes(gen_names[i], fh);
	    Fprintf (tstrm, "[ ");
	    while (*s != NULL)
		Fprintf (tstrm, "%s ", *s++);
	    Fprintf (tstrm, "] ");
	}
	if ((type == CHAR) && (size > 1)) {
	    Fprintf (tstrm, "%s ", cptr);
	}
	else
	    for (j = 0; j < size; j++) {
		k++;
		if (k > 7) {
		    Fprintf (tstrm, "\n");
		    k = 0; 
		}
		switch(type) {
		    case DOUBLE: 
		    dptr = (double *)get_genhd(gen_names[i],fh);
		    Fprintf (tstrm, "%lg ",dptr[j]);
		    break;
		case FLOAT: 
		    fptr = (float *)get_genhd(gen_names[i],fh);
		    Fprintf (tstrm, "%g ",fptr[j]);
		    break;
		case SHORT: 
		    sptr = (short *)get_genhd(gen_names[i],fh);
		    Fprintf (tstrm, "%d ",sptr[j]);
		    break;
		case LONG: 
		    lptr = (long *)get_genhd(gen_names[i],fh);
		    Fprintf (tstrm, "%ld ",lptr[j]);
		    break;
		case CHAR: 
		    cptr = get_genhd(gen_names[i],fh);
		    Fprintf (tstrm, "0x%x",cptr[j]);
		    break;
		case CODED:  {
		    char **codes = genhd_codes(gen_names[i],fh);
		    sptr = (short *)get_genhd(gen_names[i],fh);
		    if (idx_ok(sptr[j],codes))
			Fprintf (tstrm, "%s ",codes[sptr[j]]);
		    else
			Fprintf (tstrm, "invalid code %d ",sptr[j]);
		    break;
		}
		}
	    }
    }
    Fprintf (tstrm, "\n\n");
 } else
    Fprintf (tstrm, "\n");

}

cvt_feahdr (tstrm, oh)
register FILE	*tstrm;
register struct header	*oh;
{
    int	    flag = 1;

    char    *ProgName = "cvt_feahdr";

    int	    c;

    char    **code_ptr,
	    **cc_ptr,
	    **enums = NULL,
	    **srcfields = NULL;

    int	    type_tmp,
	    tag_tmp,
	    segment_tmp;

    double *dptr;
    float  *fptr;
    long   *lptr, *dimens = NULL, size;
    short  *sptr, rank, type;
    char   *bptr, *cptr, *dimen_chr, *name, *type_chr, *size_chr, *rank_chr;


	if (fgets (buf, BUFSIZE, tstrm) == NULL) {
	    Fprintf (stderr,
	    "%s: premature EOF while trying to convert fea hdr.\n",
	    ProgName);
	}

	(void) sscanf (buf, "%x %x %x", &tag_tmp, &type_tmp, &segment_tmp);

	oh -> common.tag = tag_tmp;
	oh -> hd.fea -> fea_type = type_tmp;
	oh -> hd.fea -> segment_labeled = segment_tmp;

	if (fgets (buf, BUFSIZE, tstrm) == NULL) {
	    Fprintf (stderr,
	    "%s: premature EOF while trying to convert fea hdr.\n",
	    ProgName);
	}

	while (buf[0] != '\n') {
	    if ((name = strtok (buf, " \t")) == NULL)
		goto trouble;
	    if ((type_chr = strtok ((char *) NULL, " \t")) == NULL)
		goto trouble;
	    if ((size_chr = strtok ((char *) NULL, " \t")) == NULL)
		goto trouble;
	    if ((rank_chr = strtok ((char *) NULL, " \t")) == NULL)
		goto trouble;
	    size = atol (size_chr);
	    rank = atoi (rank_chr);
	    dimens = NULL;
	    enums = NULL;
	    name = savestring (name);

	    if (rank > 1) {
		int     r = rank;
		long   *dp;
		dp = dimens = (long *) calloc ((unsigned)rank, sizeof (long));
		while (r--) {
		    if ((dimen_chr = strtok ((char *) NULL, " \t")) == NULL)
			break;
		    *dp++ = atol (dimen_chr);
		}
	    }

	    type = type_str (type_chr);
	    if (type == CODED) {
		int     k = 0;
		/* name = savestring (name); */	    /* already saved */
		enums = (char **) calloc (1, sizeof (char *));
		while (1) {
		    if (fgets (buf, BUFSIZE, tstrm) == NULL)
			goto trouble;
		    if (*buf != ' ')
			break;
		    enums[k++] = savestring (strtok (buf + 1, "\n"));
		    enums = (char **) realloc ((char *) enums, 
		     (unsigned) ((k + 1) * sizeof (char *)));
		    enums[k] = NULL;
		}
	    }

	    if (add_fea_fld(name, size, rank, dimens, type, enums, oh) != 0) {
		Fprintf (stderr, 
		"fea_sup: Trouble creating field for %s.\n", name);
		goto trouble;
	    }

	    if (type != CODED)
		if (fgets (buf, BUFSIZE, tstrm) == NULL)
		    goto trouble;

	    if (buf[0] == '\t') {	/* it's a derived field */
		int     k = 0;
		srcfields = (char **) calloc (1, sizeof (char *));
		while (1) {
		    if (buf[0] != '\t')
			break;
		    srcfields[k++] = savestring (strtok (buf + 1, "\n"));
		    srcfields = (char **) realloc ((char *) srcfields, 
		     (unsigned) ((k + 1) * sizeof (char *)));
		    srcfields[k] = NULL;
		    if (fgets (buf, BUFSIZE, tstrm) == NULL)
			goto trouble;
		}
		if (set_fea_deriv(name, srcfields, oh) != 0) {
		    Fprintf (stderr,
		    "fea_sup: Trouble setting derived field for %s.\n",
		    name);
		    goto trouble;
		}
	    }
	
	} /* end while (buf[0] != '\n') */

	/*
	 * A single carriage return has just been read.
	 * Next fgets() either gets generic header stuff (i.e. buf[0]
	 * is '@') or data (buf[0] = '#') depending upon the gflag.
	 */

	/* Now process the generic header stuff (if any):
	 *
	 * Get next character in stream to determine if any generic
	 * header stuff exists.  If the character is '@' then generic
	 * header items exist, otherwise they don't.
	 *
	 * Remember to put that character back onto the stream!
	 */

     c = getc(tstrm);

     if (c == '@') {	/* generic items exist */
	(void) ungetc((char) c, tstrm);
	if (fgets (buf, BUFSIZE, tstrm) == NULL)
	    goto trouble;
	while (buf[0] != '\n') {
	    if (flag == 0 || *buf == '\n') {
		if (fgets (buf, BUFSIZE, tstrm) == NULL)
		    break;
	    }
	    else if (*buf == '@') {
		if (debug_level > 0)
		    Fprintf (stderr, "%s: buf = %s\n", ProgName, buf);
		if ((name = strtok (buf, " \t")) == NULL)
		    goto trouble;
		name = savestring (name);
		name++;
		if ((type_chr = strtok ((char *) NULL, " \t")) == NULL)
		    goto trouble;
		if ((size_chr = strtok ((char *) NULL, " \t")) == NULL)
		    goto trouble;

		type = type_str (type_chr);
		size = atol (size_chr);

		if (debug_level > 2)
		    Fprintf (stderr,
		    "%s: name = %s, type = %s, size = %ld\n",
		    ProgName, name, type_codes[type], size);

		if (type == CODED) {
		    int	    gen_fields = 0;
		    cc_ptr = (char **) calloc (1, sizeof (char *));

		    code_ptr = fill_codes1 (cc_ptr, size, name, oh,
			    tstrm, '@', &gen_fields);

		    if (debug_level > 5)
		       Fprintf (stderr, "gen_fields = %d\n", gen_fields);

		    (void) add_genhd_e (name, (short *) NULL, (int) size, code_ptr, oh);

		} else
		    (void) add_genhd (name, type, (int) size,
				      (char *) NULL, (char **) NULL, oh);

		switch (type) {
		    case SHORT:
			sptr = (short *) get_genhd (name, oh);
			flag = fill_shorts (sptr, size, tstrm, '@');
			break;
		    case LONG:
			lptr = (long *) get_genhd (name, oh);
			flag = fill_longs (lptr, size, tstrm, '@');
			break;
		    case FLOAT:
			fptr = (float *) get_genhd (name, oh);
			flag = fill_floats (fptr, size, tstrm, '@');
			break;
		    case DOUBLE:
			dptr = (double *) get_genhd (name, oh);
			flag = fill_doubles (dptr, size, tstrm, '@');
			break;
		    case CHAR: 
			cptr = get_genhd (name, oh);
			flag = fill_chars (cptr, size, tstrm, '@');
			break;
		    case CODED: 
			sptr = (short *) get_genhd (name, oh);
			flag = fill_gencoded (sptr, size, name,
			oh, tstrm, '@', code_ptr);
			break;
		}
	    }
	    else if (*buf == '#')
		    break;

	}  /* end while (buf[0] != '\n') */
     } else
	(void) ungetc((char) c, tstrm);

	/* write_header (oh, out); */

	return;

trouble: 
    Fprintf (stderr, "cvt_feahdr: Trouble reading ascii file back.\n");
    exit (1);
}


cvt_fearec (tstrm, out, oh)
register FILE	*tstrm;
register FILE	*out;
register struct header *oh;
{
    int	    flag = 1,
	    rec_count = 0;

    double *dptr;
    float  *fptr;
    long   *lptr, size;
    short  *sptr, type;
    char   *bptr, *cptr, *name;

    struct  fea_data	*fea_rec;
    struct  fea_data	*allo_fea_rec();


    	fea_rec = allo_fea_rec (oh);

	/* flush a single carraige return */

	if (fgets (buf, BUFSIZE, tstrm) == NULL) {
	    Fprintf (stderr, "cvt_fearec: No data to process back in?\n");
	    exit (0);
	}

	/* read first record line */
	if (fgets (buf, BUFSIZE, tstrm) == NULL) {
	    Fprintf (stderr, "cvt_fearec: No data to process back in?\n");
	    exit (0);
	}

	while (1) {
	    if (flag == 0 || *buf == '\n') {
		put_fea_rec (fea_rec, oh, out);
		clear_fea_rec (fea_rec, oh);
		rec_count++;
		if (fgets (buf, BUFSIZE, tstrm) == NULL)
		   break;
	    }
	    else if (*buf == '#') {
		if (debug_level > 0)
		    Fprintf (stderr, "fea_sup: %s", buf);
		if ((name = strtok (buf, " \t")) == NULL)
		    goto trouble;
		if (strcmp (name + 1, "Tag") == 0) {
		    if ((cptr = strtok ((char *) NULL, " \t\n")) == NULL) {
			Fprintf (stderr, "fea_sup: Missing Tag value.\n");
			goto trouble;
		    }
		    fea_rec -> tag = atol (cptr);
		    if (fgets (buf, BUFSIZE, tstrm) == NULL)
			goto trouble;
		}
		else {
		    name = savestring (name);
		    name++;
		    size = get_fea_siz (name, oh, (short *)NULL, (long **)NULL);
		    if (size == 0) {
			Fprintf (stderr, 
			 "fea_sup: name: %s not a valid field.\n", name);
			goto trouble;
		    }
		    type = get_fea_type (name, oh);
		    switch (type) {
			case SHORT: 
			    sptr = (short *) get_fea_ptr (fea_rec, name, oh);
			    flag = fill_shorts (sptr, size, tstrm, '#');
			    break;
			case LONG: 
			    lptr = (long *) get_fea_ptr (fea_rec, name, oh);
			    flag = fill_longs (lptr, size, tstrm, '#');
			    break;
			case FLOAT: 
			    fptr = (float *) get_fea_ptr (fea_rec, name, oh);
			    flag = fill_floats (fptr, size, tstrm, '#');
			    break;
			case DOUBLE: 
			    dptr = (double *) get_fea_ptr (fea_rec, name, oh);
			    flag = fill_doubles (dptr, size, tstrm, '#');
			    break;
			case CHAR: 
			    cptr = get_fea_ptr (fea_rec, name, oh);
			    flag = fill_chars (cptr, size, tstrm, '#');
			    break;
			case BYTE: 
			    bptr = get_fea_ptr (fea_rec, name, oh);
			    flag = fill_bytes (bptr, size, tstrm, '#');
			    break;
			case CODED: