esignal_fea.c

来自「speech signal process tools」· C语言 代码 · 共 1,315 行 · 第 1/3 页

 */

static struct header *
FieldList_to_fea(FieldList	    list,
		 struct fea_data    **rec,
		 char		    **fnames,
		 int		    copy_sources)
{
    struct header	*hdr;
    int			i, j;
    FieldSpec		*fld;
    char		**codes;
    FieldList		subfields;
    FieldSpec		*subf;
    char		*name;
    void		*ptr;
    int			spstype;
    long		*dim;
    struct fea_header	*fea;
    struct header	*source;

    if (list == NULL)
	return NULL;

    hdr = new_header(FT_FEA);

    for (i = 0; (fld = list[i]) != NULL; i++)
    {
	codes = NULL;
	if (fld->occurrence != VIRTUAL
	    && (subfields = fld->subfields) != NULL)
	{
	    for (j = 0; (subf = subfields[j]) != NULL; j++)
	    {
		if (strcmp(subf->name, "enumStrings") != 0)
		{
		    if (DebugMsgLevel)
			fprintf(stderr,
				"FieldList_to_fea: subfields "
				"not supported in ESPS FEA files.\n");
		}
		else if (fld->type != SHORT)
		{
		    if (DebugMsgLevel)
			fprintf(stderr,
				"FieldList_to_fea: Non-SHORT field "
				"has subfield enumStrings.\n");
		}
		else if (subf->type != CHAR)
		{
		    if (DebugMsgLevel)
			fprintf(stderr,
				"FieldList_to_fea: enumStrings not CHAR.\n");
		}
		else if (subf->rank != 2)
		{
		    if (DebugMsgLevel)
			fprintf(stderr,
				"FieldList_to_fea: enumStrings "
				"not of rank 2.\n");
		}
		else
		    codes = StrArrayFromRect(subf->dim, subf->data);
	    }
	}

	if (FieldIsTag(fld) && FindStr(ESPS_TAG, fnames))
	    hdr->common.tag = TRUE;
	else if (FieldIsFeaSubtype(fld))
	    hdr->hd.fea->fea_type = *(short *) fld->data;
	else
	{
	    name = fld->name;

	    switch(fld->occurrence)
	    {
	    case GLOBAL:
		{
		    int     size = (int) FieldLength(fld);

		    ptr = fld->data;

		    if (DebugMsgLevel)
			fprintf(stderr,
				"FieldList_to_fea: "
				"global field[%d]: \"%s\".\n",
				i, name);

		    if (fld->rank > 1)
		    {
			if (DebugMsgLevel)
			    fprintf(stderr,
				    "FieldList_to_fea: rank %d globals "
				    "not supported in ESPS FEA files.\n",
				    fld->rank);
		    }

		    if (size == 0)
		    {
			if (DebugMsgLevel)
			    fprintf(stderr,
				    "FieldList_to_fea: empty globals "
				    "not supported in ESPS FEA files.\n");
		    }
		    else if (codes != NULL)
			(void) add_genhd_e(name,
					   (short *) ptr, size, codes, hdr);
		    else
			switch (fld->type)
			{
			case DOUBLE:
			    (void) add_genhd_d(name,
					       (double *) ptr, size, hdr);
			    break;
			case FLOAT:
			    (void) add_genhd_f(name,
					       (float *) ptr, size, hdr);
			    break;
			case LONG:
			    (void) add_genhd_l(name,
					       (long *) ptr, size, hdr);
			    break;
			case SHORT:
			    (void) add_genhd_s(name,
					       (short *) ptr, size, hdr);
			    break;
			case SCHAR:
			case UCHAR:
			case CHAR:
			    (void) add_genhd_c(name,
					       (char *) ptr, size, hdr);
			    break;
			default:
			    if (DebugMsgLevel)
				fprintf(stderr,
					"FieldList_to_fea: global type %d "
					"not supported in ESPS FEA files.\n",
					fld->type);
			}
		}
		break;
	    case REQUIRED:
		{
		    long    size = FieldLength(fld);

		    if (DebugMsgLevel)
			fprintf(stderr,
				"FieldList_to_fea: "
				"required field[%d]: \"%s\".\n",
				i, name);

		    if (FindStr(name, fnames))
		    {
			spstype = (codes != NULL) ? CODED
			    : ElibTypeToEsps(fld->type);
			if (spstype != UNDEF)
			{
			    dim = (long *) malloc(fld->rank * sizeof(long));
			    for (j = 0; j < fld->rank; j++)
				dim[j] = fld->dim[j];
			    add_fea_fld(name, size, fld->rank,
					dim, spstype, codes, hdr);
			}
		    }
		}
		break;
	    case OPTIONAL:
		if (DebugMsgLevel)
		    fprintf(stderr,
			    "FieldList_to_fea: optional fields "
			    "not supported in ESPS FEA files.\n");
		break;
	    case VIRTUAL:
		if (copy_sources)
		{
		    if (strncmp(name, "source_", 7) != 0)
		    {
			if (DebugMsgLevel)
			    fprintf(stderr, "Field_List_to_fea: VIRTUAL "
				    "field other than source_<n>.\n");
		    }
		    else if ((subfields = fld->subfields) != NULL
			     || fld->type == CHAR)
		    {
			size_t	len;
			char	*data;

			source = FieldList_to_fea(subfields,
						  NULL, NULL, TRUE);
			len = FieldLength(fld);
			data = (char *) malloc(len + 1);
			strncpy(data, fld->data, len);
			data[len] = '\0';

			add_source_file(hdr, data, source);
		    }
		}
		break;
	    case INCLUDED:
		if (DebugMsgLevel)
		    fprintf(stderr,
			    "FieldList_to_fea: included fields "
			    "not supported in ESPS FEA files.\n");
		break;
	    default:
		spsassert(0, "FieldList_to_fea: "
			  "unrecognized occurrence code.\n");
		break;
	    }
	}
    }

    if (rec != NULL)
    {
	*rec = allo_fea_rec(hdr);
	fea = hdr->hd.fea;

	if (hdr->common.tag)
	{
	    fld = FindField(list, ESPS_TAG);
	    fld->data = &(*rec)->tag;
	}

	for (i = 0; i < (int) fea->field_count; i++)
	{
	    name = fea->names[i];
	    fld = FindField(list, name);
	    fld->data = get_fea_ptr(*rec, name, hdr);
	}
    }

    return hdr;
}


/*!*/
/* Same function FindStr defined in fea2esig.c as well as
 * here and esig2fea.c.
 */

/*
 * If "arr" is non-NULL, it should point to the beginning of a
 * NULL-terminated string array; search for the string "str" in the
 * array, return TRUE if it is found and FALSE otherwise.  If "arr"
 * is NULL, just return TRUE.  (NULL is not treated as an empty string
 * array; it is an indicator that all strings are to be accepted,
 */

static int
FindStr(char	*str,
	char	**arr)
{
    int     i;

    spsassert(str != NULL, "FindStr: NULL string.");

    if (arr == NULL)
	return TRUE;		/* NULL array implies all fields */

    for (i = 0; arr[i] != NULL; i++)
	if (strcmp(str, arr[i]) == 0)
	    return TRUE;

    return FALSE;
}


/*
 * Convert a rectangular array of characters into a NULL-terminated
 * string array in which each string holds a copy of the contents of a
 * corresponding row of the character array (up to the first null
 * character---the rows are assumed to be null-padded on the right).
 * The beginning of the rectangular array is indicated by "data", and
 * its dimensions are given by dim[0] and dim[1].  The return value is
 * a pointer to the beginning of the string array.
 */

static char **
StrArrayFromRect(long	*dim,
		 void	*data)
{
    char	**strarr;
    long	len, wid, i;
    char	*row;

    len = 1 + dim[0];

    strarr = (char **) malloc(len * sizeof(char *));
    len -= 1;

    wid = dim[1];
    row = data;
    for (i = 0; i < len; i++)
    {
/*!*//* Should check for null termination of rows. */
	strarr[i] = savestring(row);
	row += wid;
    }

    strarr[len] = NULL;

    return strarr;
}


/*
 * Return TRUE if "fld" points to an Esignal field specification for a
 * LONG, scalar, REQUIRED field named "Tag"; return FALSE otherwise.
 * (Such a field in an Esignal file represents the ESPS tag in a FEA
 * file, not an ordinary FEA field named "Tag".)
 */

static int
FieldIsTag(FieldSpec *fld)
{
    if (strcmp(fld->name, ESPS_TAG) != 0)
	return FALSE;
    if (fld->occurrence != REQUIRED)
    {
	if (DebugMsgLevel)
	    fprintf(stderr,
		    "FieldIsTag: non-REQUIRED field named \"%s\".\n",
		    ESPS_TAG);
	return FALSE;
    }
    if (fld->type != LONG)
    {
	if (DebugMsgLevel)
	    fprintf(stderr,
		    "FieldIsTag: type of field named \"%s\" not LONG.\n",
		    ESPS_TAG);
	return FALSE;
    }
    if (fld->rank != 0)
    {
	if (DebugMsgLevel)
	    fprintf(stderr,
		    "FieldIsTag: rank of field named \"%s\" not 0.\n",
		    ESPS_TAG);
	return FALSE;
    }
    return TRUE;
}


/*
 * Return TRUE if "fld" points to an Esignal field specification for a
 * SHORT, scalar, GLOBAL field named "FeaSubtype"; return FALSE
 * otherwise.  (Such a occurs field in an Esignal file that results from
 * converting an ESPS FEA file that belongs to one of the special FEA
 * subtypes (FEA_SD, FEA_SPEC, etc.)  For the transformation to be
 * reversible, the field should give a value to hd.fea->fea_type in the
 * FEA header instead of being translated into a generic header item
 * named "FeaSubtype".
 */

static int
FieldIsFeaSubtype(FieldSpec *fld)
{
    if (strcmp(fld->name, ESPS_FEA_SUBTYPE) != 0)
	return FALSE;
    if (fld->occurrence != GLOBAL)
    {
	if (DebugMsgLevel)
	    fprintf(stderr,
		    "FieldIsFeaSubtype: non-GLOBAL field named \"%s\".\n",
		    ESPS_FEA_SUBTYPE);
	return FALSE;
    }
    if (fld->type != SHORT)
    {
	if (DebugMsgLevel)
	    fprintf(stderr,
		    "FieldIsFeaSubtype: "
		    "type of field named \"%s\" not SHORT.\n",
		    ESPS_FEA_SUBTYPE);
	return FALSE;
    }
    if (fld->rank != 0)
    {
	if (DebugMsgLevel)
	    fprintf(stderr,
		    "FieldIsFeaSubtype: rank of field named \"%s\" not 0.\n",
		    ESPS_FEA_SUBTYPE);
	return FALSE;
    }
    if (fld->data == NULL)
    {
	if (DebugMsgLevel)
	    fprintf(stderr,
		    "FieldIsFeaSubtype: "
		    "field named \"%s\" has NULL data pointer.\n",
		    ESPS_FEA_SUBTYPE);
	return FALSE;
    }
    return TRUE;
}


/*
 * If "type" is an Esignal data-type code, return the corresponding
 * ESPS data-type code, or UNDEF if no such ESPS data type exists.
 */

static int
ElibTypeToEsps(int type)
{
    switch (type)
    {
    case DOUBLE:
	return FDOUBLE;
    case FLOAT:
	return FFLOAT;
    case LONG:
	return FLONG;
    case SHORT:
	return FSHORT;
    case SCHAR:
	return BYTE;
    case UCHAR:
    case CHAR:
	return FCHAR;
    case DOUBLE_COMPLEX:
	return DOUBLE_CPLX;
    case FLOAT_COMPLEX:
	return FLOAT_CPLX;
    case LONG_COMPLEX:
	return LONG_CPLX;
    case SHORT_COMPLEX:
	return SHORT_CPLX;
    case SCHAR_COMPLEX:
	return BYTE_CPLX;
    default:
	return UNDEF;
    }
}