esig2fea.c

speech signal process tools

		}
		else if (subf->type != CHAR)
		{
		    if (debug_level)
			fprintf(stderr,
				"FieldList_to_fea: enumStrings not CHAR.\n");
		}
		else if (subf->rank != 2)
		{
		    if (debug_level)
			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 (debug_level >= 2)
			fprintf(stderr,
				"FieldList_to_fea: "
				"global field[%d]: \"%s\".\n",
				i, name);

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

		    if (size == 0)
		    {
			if (debug_level)
			    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 (debug_level)
				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 (debug_level >= 2)
			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 (debug_level)
		    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 (debug_level)
			    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 (debug_level)
		    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. */

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;
}


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;
}


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


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


static long
SkipRecs(FILE	    *file,
	 long	    skip,
	 long	    size,
	 FieldSpec  **fields,
	 int	    arch)
{
    long    n;

    if (skip == 0)
	return 0;

    if (size != -1)
    {
	skiprec(file, skip, size);
	return skip;
    }
    else
    {
	for (n = 0; n < skip && ReadRecord(fields, arch, file); n++)
	{ }

	return n;
    }
}


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;
    }
}