esignal.c

该压缩包为最新版htk的源代码,htk是现在比较流行的语音处理软件,请有兴趣的朋友下载使用

   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, ARCH) == 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, "rb"); /* Binary file */

   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=0L;    /* record size */
   long fld_size;       /* field-list size */
   static char  buf[BUFSIZ];    /* buffer for file copy */
   char *architecture=NULL;  /* 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 = ARCH;
         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";
         if (okay)
            rec_size = -1;
         break;
      default:
         DebugMsg(1, "WriteHeader: unrecognized architecture code.");
         okay = FALSE;          /* Unsupported architecture. */
         break;
      }

   if (!okay)
      {
         fclose(temp);
         return FALSE;          /* Failure to write field list. */
      }

   /* Get field-list size */

   fld_size = ftell(temp);

   /* Write preamble. */

   if (!WritePreamble(architecture, fld_size, rec_size, file))
      return FALSE;             /* Failure to write preamble. */

   /* Copy field list from temp file. */

   rewind(temp);

   tot = 0;
   while ((n = fread(buf, 1, BUFSIZ, temp)) > 0)
      {
         fwrite(buf, 1, n, file);
         tot += n;
      }

   if (tot != fld_size)
      return FALSE;             /* I/O error or wrong fld_size. */

   return TRUE;         /* success */
}


/*
 * Open file "filename" for writing, or use stdout if filename is "-".
 * If successful, call WriteHeader on the file.  Return FALSE in case
 * of failure.
 */

int
OpenOut(char        *filename,
        FieldList   list,
        int         arch,
        FILE        **file,
        Annot       *annotate)
{
   FILE    *output;

   if (filename == NULL)
      {
         DebugMsg(1, "OpenOut: NULL file name.");
         return FALSE;
      }

   if (strcmp(filename, "-") == 0)
      output = stdout;
   else
      output = fopen(filename, "wb"); /* Binary file */

   if (output == NULL)
      {
         DebugMsg(1, "OpenOut: couldn't open file.");
         return FALSE;
      }

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