esignal.c

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

    }
    else			/* More than one component. */
    {
	len = tail - name;
	terminator = DOT;
    }

    /* Allocate space for copy including final null. */

    head = (char *) malloc(1 + len);
    if (head == NULL)
	return NULL;

    /* Copy. */

    p = head;
    while (*name != terminator)
	*p++ = *name++;
    *p = '\0';

    return head;
}


/*
 * Add a field at top level to a field list.
 */

int
AddField(FieldList   *list,	/* variable containing field list */
	 FieldSpec   *field)	/* specification of field */
{
    int		n;		/* length of list */
    FieldList	new_list;	/* new field list */

    /* Check for bad argument. */

    if (field == NULL || list == NULL)
	return FALSE;

    /* Extend list with 1 new pointer plus terminating NULL. */

    if (*list == NULL)
    {
	n = 0;
	new_list = (FieldList) malloc(2 * sizeof(**list));
    }
    else
    {
	n = FieldListLength(*list);
	new_list = (FieldList) realloc(*list, (n+2) * sizeof(**list));
    }

    if (new_list == NULL)	/* Allocation failure. */
	return FALSE;

    new_list[n] = field;
    new_list[n+1] = NULL;
    *list = new_list;

    return TRUE;
}


/*
 * Add field as subfield of another field.
 */

int
AddSubfield(FieldSpec   *field,	   /* field to aquire subfield */
	    FieldSpec   *subfield) /* subfield to be added */
{
    /* Check for bad arguments. */

    if (field == NULL || subfield == NULL)
	return FALSE;		/* Failure. */

    /* Add subfield. */

    return AddField(&field->subfields, subfield);
}


/*
 * Make NULL-terminated linear array in field order of REQUIRED
 * and OPTIONAL fields (and subfields ...) of a field list.
 * Fill in "fullname" members.
 */

FieldSpec **
FieldOrder(FieldList list)
{
    return SubFieldOrder(list, NULL);
}


/*
 * Make NULL-terminated linear array in type order of REQUIRED
 * and OPTIONAL fields (and subfields ...) of a field list.
 */

FieldSpec **
TypeOrder(FieldList list)
{
    FieldSpec	**fld_order;	/* fields in field order */
    FieldSpec   **typ_order;	/* fields in type order */
    long	len;		/* number of fields ... */
    long	i, j;		/* list indices */

    fld_order = FieldOrder(list);

    if (fld_order == NULL)
	return NULL;

    len = FieldArrayLength(fld_order);

    typ_order = (FieldSpec **) malloc((len+1) * sizeof(*typ_order));
    if (typ_order == NULL)
	return NULL;		/* Allocation failure. */

    j = 0;

    for (i = 0; i < len; i++)
	if (fld_order[i]->type == ARRAY)
	    typ_order[j++] = fld_order[i];
    for (i = 0; i < len; i++)
	if (fld_order[i]->type == DOUBLE)
	    typ_order[j++] = fld_order[i];
    for (i = 0; i < len; i++)
	if (fld_order[i]->type == DOUBLE_COMPLEX)
	    typ_order[j++] = fld_order[i];
    for (i = 0; i < len; i++)
	if (fld_order[i]->type == FLOAT)
	    typ_order[j++] = fld_order[i];
    for (i = 0; i < len; i++)
	if (fld_order[i]->type == FLOAT_COMPLEX)
	    typ_order[j++] = fld_order[i];
    for (i = 0; i < len; i++)
	switch (fld_order[i]->type)
	{
	case LONG: /* Fall through */
	case ULONG:
	    typ_order[j++] = fld_order[i];
	}
    for (i = 0; i < len; i++)
	if (fld_order[i]->type == LONG_COMPLEX)
	    typ_order[j++] = fld_order[i];
    for (i = 0; i < len; i++)
	switch (fld_order[i]->type)
	{
	case SHORT:
	case USHORT:
	case WCHAR:
	    typ_order[j++] = fld_order[i];
	}
    for (i = 0; i < len; i++)
	if (fld_order[i]->type == SHORT_COMPLEX)
	    typ_order[j++] = fld_order[i];
    for (i = 0; i < len; i++)
	switch (fld_order[i]->type)
	{
	case SCHAR: /* Fall through. */
	case UCHAR: /* Fall through. */
	case CHAR: /* Fall through. */
	case BOOL:
	    typ_order[j++] = fld_order[i];
	}
    for (i = 0; i < len; i++)
	if (fld_order[i]->type == SCHAR_COMPLEX)
	    typ_order[j++] = fld_order[i];

    typ_order[j] = NULL;

    free(fld_order);

    return typ_order;
}


/*
 * Output via "order" (if not NULL) the ordering---FIELD_ORDER or
 * TYPE_ORDER---of a field list.  The result is TYPE_ORDER, the
 * default, if there is no field named "fieldOrder", and it is
 * the value of that field if it is a GLOBAL scalar numeric field
 * with one of the two allowed values.  In either of those cases
 * return TRUE for success.  Return FALSE for failure in any other
 * case.
 */

int
GetFieldOrdering(FieldList  list,
		 int	    *order)
{
    FieldSpec	*field;
    long	ord;

    field = FindField(list, "fieldOrder");

    if (field == NULL)
	ord = TYPE_ORDER;
    else if (field->occurrence != GLOBAL
	     || field->rank != 0
	     || field->data == NULL
	     || !LongVal(field->data, field->type, &ord)
	     || ord != FIELD_ORDER && ord != TYPE_ORDER)
    {
	DebugMsg(1, "Bad field \"fieldOrder\".");
	return FALSE;
    }

    if (order != NULL)
	*order = ord;

    return TRUE;
}


/*
 * Set "list" to indicate an ordering of "order", which should be
 * FIELD_ORDER or TYPE_ORDER.  If no field named "fieldOrder" is
 * present, and "order" is TYPE_ORDER (the default) no action is
 * needed.  If the field exists and is not GLOBAL, return an
 * indication of failure.  Otherwise create the field if necessary
 * (and possible) make it a SHORT scalar field, and assign "order"
 * as its value.  Return TRUE for success and FALSE for failure.
 */

int
SetFieldOrdering(FieldList  *list,
		 int	    order)
{
    FieldSpec	*field;

    if (*list == NULL)
    {
	DebugMsg(1, "SetFieldOrdering: NULL field list.");
	return FALSE;
    }

    field = FindField(*list, "fieldOrder");

    if (field == NULL)
    {
	if (order == TYPE_ORDER)
	    return TRUE;

	field = NewFieldSpec(SHORT, 0);
	if (field == NULL)
	{
	    DebugMsg(1, "SetFieldOrdering: Couldn't create field spec.");
	    return FALSE;
	}

	field->name = StrDup("fieldOrder");
	field->occurrence = GLOBAL;
	if (!AddField(list, field))
	{
	    DebugMsg(1, "SetFieldOrdering: Couldn't add field spec.");
	    return FALSE;
	}
    }
    else    /* field != NULL */
    {
	if (field->occurrence != GLOBAL)
	{
	    DebugMsg(1, "SetFieldOrdering: non-GLOBAL field \"fieldOrder\".");
	    return FALSE;
	}
	field->type = SHORT;
	field->rank = 0;
    }

    field->data = ((field->data == NULL)
		   ? malloc(sizeof(short))
		   : realloc(field->data, sizeof(short)));
    if (field->data == NULL)
    {
	DebugMsg(1, "SetFieldOrdering: couldn't (re)allocate data.");
	return FALSE;
    }

    *(short *) field->data = order;
    return TRUE;
}


/*
 * *** GENERAL INPUT/OUTPUT
 * - ReadPreamble
 * - ReadFieldList
 * - ReadHeader
 * - OpenIn
 * - WritePreamble
 * - WriteFieldList
 * - WriteHeader
 * - OpenOut
 * - RecordSize
 * - ReadRecord
 * - WriteRecord
 * - ReadSamples
 * - WriteSamples
 */

/*
 * Read preamble from file.  Information returned via pointer
 * arguments.  Return TRUE on success, FALSE on failure.
 */

int
ReadPreamble(char **version,	/* version (output) */
	     char **arch,	/* architecture (output) */
	     long *pre_size,	/* preamble size (output) */
	     long *hdr_size,	/* header size (output) */
	     long *rec_size,	/* record size (output) */
	     FILE *file)	/* input file */
{
    char    buf[PREAM_MAX + 1]; /* input string + null */

    /* Check magic number, MAGIC. */

    if (!GetLine(buf, 8, file))
	return FALSE;

    if (strcmp(buf, MAGIC) != 0)
	return FALSE;

    if (!GetLine(buf, 8, file))
	return FALSE;
    if (version != NULL)
	*version = StrDup(buf);

    /* Get architecture. */

    if (!GetLine(buf, 8, file))
	return FALSE;
    if (arch != NULL)
	*arch = StrDup(buf);

    /* Get preamble size */

    if (!GetLong(pre_size, 8, file))
	return FALSE;

    /* Could check *pre_size here. */

    /* Get header size */

    if (!GetLong(hdr_size, 8, file))
	return FALSE;

    /* Get record size */

    if (!GetLong(rec_size, 8, file))
	return FALSE;

    return TRUE;		/* success */
}


/*
 * Read field list from a given file in a given format.
 */

int
ReadFieldList(FieldList *list,
	      int arch,
	      FILE *file)
{
    switch (arch)
    {
    case EDR1:
	return ReadEdrFieldList(list, file, EDR1);
	break;
    case EDR2:
	return ReadEdrFieldList(list, file, EDR2);
	break;
    case NATIVE:
	return ReadNativeFieldList(list, file);
	break;
    case ASCII:
	return ReadAsciiFieldList(list, file);
	break;
    default:
	return FALSE;
	break;
    }
}


/*
 * Read header from file.
 * Return value is field list (NULL on failure).
 * Information from preamble is returned via pointer arguments.
 */

FieldList
ReadHeader(char     **version,	/* version (output) */
	   int      *arch,	/* architecture (output) */
	   long     *pre_size,	/* preamble size  (output) */
	   long     *hdr_size,	/* header size (output) */
	   long     *rec_size,	/* record size (output) */
	   FILE     *file)	/* input file */
{
    FieldList	list;
    char	*architecture;

    if (!ReadPreamble(version,
		      &architecture, pre_size, hdr_size, rec_size, file))
	return NULL;	/* Bad preamble. */
    if (strcmp(architecture, EsignalArch) == 0)    /* native architecture */
    {
	if (arch != NULL)
	    *arch = NATIVE;

	if (!ReadNativeFieldList(&list, file))
	    return NULL;
    }
    else if (strcmp(architecture, "EDR1") == 0)
    {
	if (arch != NULL)
	    *arch = EDR1;

	/*
	 * On machines whose native architecture is EDR1, could call
	 * ReadNativeFieldList here.
	 */
	if (!ReadEdrFieldList(&list, file, EDR1))
	    return NULL;
    }
    else if (strcmp(architecture, "EDR2") == 0)
    {
	if (arch != NULL)
	    *arch = EDR2;
	/*
	 * On machines whose native architecture is EDR2, could call
	 * ReadNativeFieldList here.
	 */
	if (!ReadEdrFieldList(&list, file, EDR2))
	    return NULL;
    }
    else if (strcmp(architecture, "ASCII") == 0)
    {
	if (arch != NULL)
	    *arch = ASCII;

	if (!ReadAsciiFieldList(&list, file))
	    return NULL;
    }
    else
    {
	if (arch != NULL)
	    *arch = UNKNOWN;

	return NULL;		/* Unsupported architecture. */
    }

    return list;
}


/*
 * Open file "filename" for reading, or use stdin if filename is "-".
 * If successful, call ReadHeader on the file.  Return NULL in case
 * of failure.
 */

FieldList
OpenIn(char	*filename,	/* name of input file */
       char     **version,	/* version (output) */
       int      *arch,		/* architecture (output) */
       long     *pre_size,	/* preamble size (output) */
       long     *hdr_size,	/* header size (output) */
       long     *rec_size,	/* record size (output) */
       FILE     **file)		/* input file (output) */
{
    FILE    *input;

    if (filename == NULL)
	return NULL;

    if (strcmp(filename, "-") == 0)
	input = stdin;
    else
	input = fopen(filename, "r");

    if (input == NULL)
	return NULL;

    if (file != NULL)
	*file = input;

    return ReadHeader(version, arch, pre_size, hdr_size, rec_size, input);
}


/*
 * Write preamble to file given architecture, field-list size, and
 * record size.  (Preamble size is known to the function; header size is
 * field-list size plus preamble size.)  Return TRUE on success, FALSE on
 * failure.
 */

int
WritePreamble(char  *arch,
	      long  fld_size,
	      long  rec_size,
	      FILE  *file)
{
    long    pre_size = 48;	/* Preamble size: total length of
				 * strings to be printed, including
				 * terminal '\n'.
				 *  8	magic number
				 *  8	version
				 *  8	architecture
				 *  8	preamble size
				 *  8	header size
				 *  8	record size
				 * --
				 * 48	total
				 */

    if (fprintf(file, "%7s\n", MAGIC) != 8)
	return FALSE;

    if (fprintf(file, "%7s\n", VERSION) != 8)
	return FALSE;

    if (fprintf(file, "%7s\n", arch) != 8)
	return FALSE;

    if (fprintf(file, "%7ld\n", pre_size) != 8)
	return FALSE;

    /* Header size: preamble size plus field-list size. */

    if (fprintf(file, "%7ld\n", fld_size + pre_size) != 8)
	return FALSE;

    if (fprintf(file, "%7ld\n", rec_size) != 8)
	return FALSE;

    return TRUE;		/* success */
}


/*
 * Write field list to file in specified format (Edr1 or Edr2 portable
 * binary, native binary, or Ascii.  "annotate" is ignored unless
 * the format is ASCII, and then it means add annotations in "[]"
 * for readability.  Return TRUE on success, FALSE on failure.
 */

int
WriteFieldList(FieldList list,
	       int arch,
	       FILE *file,
	       Annot *annotate)
{
    switch (arch)
    {
    case EDR1:
	return WriteEdrFieldList(list, file, EDR1);
	break;
    case EDR2:
	return WriteEdrFieldList(list, file, EDR2);
	break;
    case NATIVE:
	return WriteNativeFieldList(list, file);
	break;
    case ASCII:
	return WriteAsciiFieldList(list, file, annotate);
	break;
    default:
	return FALSE;
	break;
    }
}


/*
 * Write header to file, in format for given architecture, given field
 * list.  The field list is written to a temporary file so
 * that the header size can be determined when the preamble is written.
 * (This is only really necessary if the output cannot be rewound---
 * e.g. a pipe.)
 * The value of annotate is ignored unless arch is ASCII; then a
 * non-NULL value means add annotations in "[]" for readability.
 * Return TRUE on success, FALSE on failure.
 */

int
WriteHeader(FieldList  list,
	    int        arch,
	    FILE       *file,
	    Annot      *annotate)
{
    FILE	*temp;		/* temporary file */
    int 	okay;		/* success or failure? */
    long	rec_size;	/* record size */
    long	fld_size;	/* field-list size */
    static char	buf[BUFSIZ];	/* buffer for file copy */
    char	*architecture;	/* architecture name */
    int 	n;		/* byte count for file copy */
    long	tot;		/* byte count total for file copy */


    /* Make temp file. */

    temp = tmpfile();

    if (temp == NULL)
	return FALSE;		/* Failure to make temp file. */

    /* Write field list to temp file; get record size. */

    switch (arch)
    {
    case NATIVE:
	okay = WriteNativeFieldList(list, temp);
	architecture = EsignalArch;
	if (okay)
	    rec_size = NativeRecordSize(list);
	break;
    case EDR1:
	/*
	 * On machines whose native architecture is EDR1, could call
	 * WriteNativeFieldList here.
	 */
	okay = WriteEdrFieldList(list, temp, EDR1);
	architecture = "EDR1";
	if (okay)
	    rec_size = EdrRecordSize(list, EDR1);
	break;
    case EDR2:
	/*
	 * On machines whose native architecture is EDR2, could call
	 * WriteNativeFieldList here.
	 */
	okay = WriteEdrFieldList(list, temp, EDR2);
	architecture = "EDR2";
	if (okay)
	    rec_size = EdrRecordSize(list, EDR2);
	break;
    case ASCII:
	okay = WriteAsciiFieldList(list, temp, annotate);
	architecture = "ASCII";