sp_utils.c

speech signal process tools

register struct field_t **fv;

if (h == HDRNULL)	return -1;	/* check sanity of arguments */
if (name == CNULL)	return -1;

fc = h->fc;
fv = h->fv;
for (i=0; i < fc ; i++, fv++)
	if (strcmp(name,(*fv)->name) == 0)
		switch ((*fv)->type) {
			case T_INTEGER:
				return sizeof(long);
			case T_REAL:
				return sizeof(double);
			case T_STRING:
				return (*fv)->datalen;
			default:
				return -1;
		}
return -1;
}

/***********************************************************************/
/* Returns the value of the specifed header field in "buf".            */
/* No more than "len" bytes are copied; "len" must be positive.        */
/* It really doesn't make much sense to ask for part of a long or      */
/*    double, but it's not illegal.                                    */
/* Remember that strings are not null-terminated.                      */
/***********************************************************************/

FUNCTION int sp_get_data(h,name,buf,len)
struct header_t *h;
char *name, *buf;
int *len;
{
register struct field_t **fv;
register int i, fc;
long n;
double x;

if (h == HDRNULL)	return -1;	/* check sanity of arguments */
if (name == CNULL)	return -1;
if (buf == CNULL)	return -1;
if (len == INULL)	return -1;
if (*len <= 0)		return -1;

fc = h->fc;
fv = h->fv;
for (i=0; i<fc; i++, fv++)
	if (strcmp(name,(*fv)->name) == 0) {
		switch ((*fv)->type) {
			case T_INTEGER:
				n = atol((*fv)->data);
				*len = MIN(*len,sizeof(long));
				(void) memcpy( buf, (char *) &n, *len );
				break;
			case T_REAL:
				x = atof((*fv)->data);
				*len = MIN(*len,sizeof(double));
				(void) memcpy( buf, (char *) &x, *len );
				break;
			case T_STRING:
				*len = MIN(*len,(*fv)->datalen);
				(void) memcpy( buf, (*fv)->data, *len );
				break;
			default:
				return -1;
		}
		return 0;
	}
return -1;
}

/*******************************************************************/
/* Adds the field "name" to header specified by "h".               */
/* Argument "type" is T_INTEGER, T_REAL, or T_STRING.              */
/* Argument "p" is a pointer to a long integer, a double, or a     */
/*    character cast if necessary to a character pointer.          */
/* The specified field must not already exist in the header.       */
/*******************************************************************/

FUNCTION int sp_add_field(h,name,type,p)
struct header_t *h;
int type;
char *name, *p;
{
    register struct field_t **fv, *nf;
    int size, i, fc;

    if (h == HDRNULL)		return -1;	/* check sanity of arguments */
    if (h->fc < 0)		return -1;
    if (name == CNULL)		return -1;
    if (p == CNULL)		return -1;
    if (spx_tp(type) == '?')	return -1;

    fc = h->fc;
    for (i=0; i < fc; i++)
	if (strcmp(name,h->fv[i]->name) == 0)
	    return -1;

    switch (type) {
      case T_INTEGER:
	size = sizeof(long);
	break;
      case T_REAL:
	size = sizeof(double);
	break;
      default:
	size = strlen(p);
	break;
    }

    nf = spx_allocate_field(type,name,p,size);
    if (nf == FNULL)
	return -1;

    fv = spx_get_field_vector(fc + 1);
    if (fv == FVNULL) {
	(void) spx_deallocate_field(nf);
	return -1;
    }
    
    if (fc > 0) {
	(void) spx_copy_field_vector(h->fv, fv, fc);
	mtrf_free((char *) h->fv);
    }
    fv[h->fc++] = nf;
    h->fv = fv;
    return 0;
}

/***********************************************************/
/* Deletes field "name" from header specified by "h".      */
/* The field must exist in the header.                     */
/***********************************************************/

FUNCTION int sp_delete_field(h,name)
struct header_t *h;
char *name;
{
    struct field_t **newfv, *nf;
    int i, newfc;

    if (h == HDRNULL)	return -1;	/* check sanity of arguments */
    if (h->fc <= 0)	return -1;
    if (name == CNULL)	return -1;

    if (h->fc > 1) {
	/* one less field will be left */
	newfv = spx_get_field_vector(h->fc - 1);
	if (newfv == FVNULL)
	    return -1;
    } else
	newfv = FVNULL;			/* won't have any fields left */

    nf = FNULL;
    for (i=0, newfc=0; i < h->fc; i++)
	if (strcmp(name,h->fv[i]->name) == 0) {
	    if (nf != FNULL) {
		mtrf_free((char *) newfv);
		return -1;
	    }
	    nf = h->fv[i];
	} else {
	    if ((nf == FNULL) && (i == h->fc - 1)) {
		mtrf_free((char *) newfv);
		return -1;
	    }
	    newfv[newfc++] = h->fv[i];
	}

    (void) spx_deallocate_field(nf);
    mtrf_free((char *) h->fv);
    h->fv = newfv;
    --h->fc;
    return 0;
}

/***********************************************************/
/* Changes an existing field to a new type and/or value.   */
/* The field must already exist in the header.             */
/***********************************************************/

FUNCTION int sp_change_field(h,name,type,p)
struct header_t *h;
char *name, *p;
int type;
{
register int i, field_index, size;
struct field_t *nf;

if (h == HDRNULL)		return -1;	/* check sanity of arguments */
if (name == CNULL)		return -1;
if (p == CNULL)			return -1;
if (spx_tp(type) == '?')	return -1;

for (i=0, field_index = -1; i< h->fc; i++)
	if (strcmp(h->fv[i]->name,name) == 0) {
		if (field_index >= 0)
			return -1;
		field_index = i;
	}

if (field_index < 0)			/* field not found */
	return -1;

switch (type) {
	case T_INTEGER:
		size = sizeof(long); break;
	case T_REAL:
		size = sizeof(double); break;
	default:
		size = strlen(p); break;
}

nf = spx_allocate_field(type,name,p,size);
if (nf == FNULL) return -1;

if (spx_deallocate_field(h->fv[field_index]) < 0) {
	(void) spx_deallocate_field(nf);
	return -1;
}
h->fv[field_index] = nf;
return 0;
}

/******************************************************************/
/* Returns a pointer to an empty header.                          */
/* Use sp_add_field() to insert fields into it.                   */
/* Use sp_print_header() to print it in readable format.          */
/* Use sp_format_header() to print it to a file in NIST SPHERE    */
/*      format.                                                   */
/******************************************************************/

FUNCTION struct header_t *sp_create_header()
{
return spx_allocate_header(0,FVNULL);
}

/*******************************************************************/
/* Returns TRUE if the specified field name is a "standard" field, */
/* FALSE otherwise.                                                */
/* Standard fields are listed in stdfield.c.                       */
/*******************************************************************/

FUNCTION int sp_is_std(name)
register char *name;
{
register char **f;

if (name == CNULL)
	return FALSE;

f = &std_fields[0];
while (*f != CNULL)
	if (strcmp(name,*f++) == 0)
		return TRUE;

return FALSE;
}

/**********************************************************************/
/* Returns the size of the file's sphere header in bytes              */
/**********************************************************************/
long sp_file_header_size(file)
char *file;
{
    FILE *fp;
    struct fileheader_fixed fh;

    if (file == CNULL)
	return -1;

    fp = fopen(file,"r");
    if (fp == FPNULL)
	return -1;

    if (fread((char *)&fh,1,sizeof(fh),fp) != sizeof(fh)) {
	(void) fclose(fp);
	return -1;
    }

    (void) fclose(fp);

    fh.header_size[HDR_SIZE_SIZE-1] = '\0';
    return atol(fh.header_size);
}

/**********************************************************************/
/* Returns the size of the header if it were to be written to a file  */
/**********************************************************************/
long sp_header_size(h)
struct header_t *h;
{
    FILE *fp;
    long header_size, data_size;    

    if (h == HDRNULL)
	return -1;

    fp = fopen(rsprintf("%s/%s.sz",TEMP_DIR,TEMP_BASE_NAME),"w");
    if (fp == FPNULL){
	if (sp_verbose > 15) printf("Can't open file '%s'\n",rsprintf("%s/%s.sz",TEMP_DIR,TEMP_BASE_NAME));
	return -1;
    }
    if (sp_write_header(fp,h,&header_size,&data_size) < 0){
	fclose(fp);
	unlink(rsprintf("%s/%s.sz",TEMP_DIR,TEMP_BASE_NAME));
	return(-1);
    }
    fclose(fp);
    unlink(rsprintf("%s/%s.sz",TEMP_DIR,TEMP_BASE_NAME));
    return(header_size);
}