esig_edr.c

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

}


/* Read items of type BOOL */

static int
EdrReadBool(Bool    *data,
            long    length,
            FILE    *file)
{
   long     n;          /* number of items read */
   int              ch;         /* input character */

   for (n = 0; n < length; n++)
      {
         if ((ch = getc(file)) == EOF)
            break;

         data[n] = (ch != 0);
      }

   return n;
}


/* Read items of type DOUBLE_COMPLEX */

static int
EdrReadDoubleComplex(DoubleComplex  *data,
                     long           length,
                     FILE           *file)
{
   long     n;          /* number of items read */
   double           x[2];       /* real and imaginary parts */

   for (n = 0; n < length; n++)
      {
         if (EdrReadDouble(x, 2, file) != 2)
            break;

         data[n].real = x[0];
         data[n].imag = x[1];
      }

   return n;
}


/* Read items of type FLOAT_COMPLEX */

static int
EdrReadFloatComplex(FloatComplex    *data,
                    long            length,
                    FILE            *file)
{
   long     n;          /* number of items read */
   float            x[2];       /* real and imaginary parts */

   for (n = 0; n < length; n++)
      {
         if (EdrReadFloat(x, 2, file) != 2)
            break;

         data[n].real = x[0];
         data[n].imag = x[1];
      }

   return n;
}


/* Read items of type LONG_COMPLEX */

static int
EdrReadLongComplex(LongComplex  *data,
                   long     length,
                   FILE     *file,
                   int      longlong)
{
   long     n;          /* number of items read */
   long     x[2];       /* real and imaginary parts */

   for (n = 0; n < length; n++)
      {
         if (EdrReadLong(x, 2, file, longlong) != 2)
            break;

         data[n].real = x[0];
         data[n].imag = x[1];
      }

   return n;
}


/* Read items of type SHORT_COMPLEX */

static int
EdrReadShortComplex(ShortComplex    *data,
                    long            length,
                    FILE            *file)
{
   long     n;          /* number of items read */
   short            x[2];       /* real and imaginary parts */

   for (n = 0; n < length; n++)
      {
         if (EdrReadShort(x, 2, file) != 2)
            break;

         data[n].real = x[0];
         data[n].imag = x[1];
      }

   return n;
}


/* Read items of type SCHAR_COMPLEX */

static int
EdrReadScharComplex(ScharComplex    *data,
                    long            length,
                    FILE            *file)
{
   long     n;          /* number of items read */
   Schar            x[2];       /* real and imaginary parts */

   for (n = 0; n < length; n++)
      {
         if (EdrReadSchar(x, 2, file) != 2)
            break;

         data[n].real = x[0];
         data[n].imag = x[1];
      }

   return n;
}


/* Read items of type CHAR */

static int
EdrReadChar(char *data,
            long length,
            FILE *file)
{
   long    n;                   /* number of items read */
   int      ch;                 /* input character */

   for (n = 0; n < length; n++)
      {
         if ((ch = getc(file)) == EOF)
            break;

         data[n] = ch;
      }

   return n;
}


/* Read items of type WCHAR */

static int
EdrReadWchar(Wchar      *data,
             long       length,
             FILE       *file)
{
   long     n;          /* number of items read */
   unsigned int    item;        /* one input data item */
   int              ch;         /* input character */

   for (n = 0; n < length; n++)
      {
         if ((ch = getc(file)) == EOF)
            break;
         item = ch;

         if ((ch = getc(file)) == EOF)
            break;
         item = (item << 8) | ch;

         data[n] = item;
      }

   return n;
}


/*
 * *** FUNCTIONS FOR OUTPUT
 */

/*
 * Write "data" member of field to file in EDR format.
 * Return TRUE on success, FALSE on failure.
 */

static int
WriteEdrData(FieldSpec  *field,
             FILE       *file,
             int        longlong)
{
   long    length;              /* number of elements */

   if (file  == NULL || field == NULL || field->type == NO_TYPE)
      return FALSE;

   length = FieldLength(field);

   if (length != 0 && field->data == NULL)
      return FALSE;

   if (EdrWrite(field->data,
                field->type, length, file, longlong) != length)
      return FALSE;

   return TRUE;
}


/*
 * Write field specification to file in EDR format.
 * Return TRUE on success, FALSE on failure.
 */

static int
WriteEdrFieldSpec(FieldSpec *field,
                  FILE      *file,
                  int       longlong)
{
   int     rank;                /* number of dimensions */
   int     i;                   /* loop index */
   long    num_ax_names;        /* number of axis names */

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

   if (!WriteEdrString(field->name, file, longlong))
      return FALSE;

   if (EdrWriteShort(&field->type, 1, file) != 1)
      return FALSE;

   if (EdrWriteShort(&field->rank, 1, file) != 1)
      return FALSE;

   rank = field->rank;

   if (rank != 0 && field->dim == NULL)
      return FALSE;             /* Inconsistent rank and dimensions. */

   if (EdrWriteLong(field->dim, rank, file, longlong) != rank)
      return FALSE;

   if (!WriteEdrString(field->units, file, longlong))
      return FALSE;

   if (EdrWriteDouble(&field->scale, 1, file) != 1)
      return FALSE;

   if (EdrWriteDouble(&field->offset, 1, file) != 1)
      return FALSE;

   num_ax_names = (field->axis_names == NULL) ? 0 : rank;
   if (EdrWriteLong(&num_ax_names, 1, file, longlong) != 1)
      return FALSE;
   for (i = 0; i < num_ax_names; i++)
      if (!WriteEdrString(field->axis_names[i], file, longlong))
         return FALSE;

   if (EdrWriteShort(&field->occurrence, 1, file) != 1)
      return FALSE;

   if (field->type != NO_TYPE
       && field->occurrence != REQUIRED && field->occurrence != OPTIONAL)
      {
         if (!WriteEdrData(field, file, longlong))
            return FALSE;
      }

   if (!WriteEdrFieldList(field->subfields, file, longlong))
      return FALSE;

   return TRUE;
}


/*
 * Write a string to a file in portable binary format:  the string length
 * in EDR1 or EDR2 LONG format, followed by the characters of the string.
 * Return TRUE on success and FALSE in case of failure.
 */

static int
WriteEdrString(char     *string,
               FILE     *file,
               int      longlong)
{
   long    length;
   long    i;

   if (file == NULL)
      return FALSE;

   if (string == NULL)
      string = "";

   length = strlen(string);

   if (EdrWriteLong(&length, 1, file, longlong) != 1)
      return FALSE;             /* Couldn't write length. */

   for (i = 0; i < length && putc(string[i], file) != EOF; i++)
      { }

   return (i == length);
}


/*
 * Write items of data to a file in EDR1 or EDR2 portable binary format
 * from the block of storage indicated by the pointer "data".
 * The number of items is given by "length", and their data type
 * is indicated by the integer code "type".
 * Return the number of successfully written items.  (A value other
 * than "length" indicates an error).
 */

static int
EdrWrite(void   *data,
         int    type,
         long   length,
         FILE   *file,
         int    longlong)
{
   if (file == NULL || data == NULL || length <= 0)
      return 0;

   switch (type)
      {
      case ARRAY:
         return EdrWriteArray((Array *) data, length, file, longlong);
      case DOUBLE:
         return EdrWriteDouble((double *) data, length, file);
      case FLOAT:
         return EdrWriteFloat((float *) data, length, file);
      case LONG:
         return EdrWriteLong((long *) data, length, file, longlong);
      case ULONG:
         return EdrWriteUlong((Ulong *) data, length, file, longlong);
      case SHORT:
         return EdrWriteShort((short *) data, length, file);
      case USHORT:
         return EdrWriteUshort((Ushort *) data, length, file);
      case SCHAR:
         return EdrWriteSchar((Schar *) data, length, file);
      case UCHAR:
         return EdrWriteUchar((Uchar *) data, length, file);
      case BOOL:
         return EdrWriteBool((Bool *) data, length, file);
      case DOUBLE_COMPLEX:
         return EdrWriteDoubleComplex((DoubleComplex *) data, length, file);
      case FLOAT_COMPLEX:
         return EdrWriteFloatComplex((FloatComplex *) data, length, file);
      case LONG_COMPLEX:
         return EdrWriteLongComplex((LongComplex *) data,
                                    length, file, longlong);
      case SHORT_COMPLEX:
         return EdrWriteShortComplex((ShortComplex *) data, length, file);
      case SCHAR_COMPLEX:
         return EdrWriteScharComplex((ScharComplex *) data, length, file);
      case CHAR:
         return EdrWriteChar((char *) data, length, file);
      case WCHAR:
         return EdrWriteWchar((Wchar *) data, length, file);
      default:    /* Invalid code or NO_TYPE. */
         return 0;
      }
}


/*
 * Write to "file" the EDR1 or EDR2 representation of one item of type
 * ARRAY from the location indicated by "array".
 * Return TRUE for success, FALSE for failure.
 */

static int
WriteEdrArray(Array *array,
              FILE  *file,
              int   longlong)
{
   short   type;
   short   rank;
   long    *dim;
   void    *data;
   long    length;

   if (file == NULL || array == NULL)
      return FALSE;

   type = array->type;
   rank = array->rank;
   dim = array->dim;
   data = array->data;

   if (EdrWriteShort(&type, 1, file) != 1)
      return FALSE;

   if (EdrWriteShort(&rank, 1, file) != 1)
      return FALSE;

   if (rank > 0)
      {
         if (dim == NULL)
            return FALSE;

         if (EdrWriteLong(dim, rank, file, longlong) != rank)
            return FALSE;
      }

   length = LongProd(rank, dim);

   if (length > 0)
      {
         if (data == NULL)
            return FALSE;

         if (EdrWrite(data, type, length, file, longlong) != length)
            return FALSE;
      }

   return TRUE;
}


/*
 * Each of the following functions with names of the form
 *
 *      EdrWrite<type>
 *
 * takes three arguments:
 *      <type>  *data,
 *      long    length,
 *      FILE    *file,
 * and in some cases a fourth:
 *      int     longlong
 * The function writes "length" items of data of the indicated data type
 * in EDR portable binary format to the stream "file" from the block of
 * storage indicated by "data".  The fourth argument, "longlong", is
 * present when the EDR1 and EDR2 representations of the data type differ;
 * a value of 1 indicates EDR1, and 2 indicates EDR2.  The int return
 * value is the number of items successfully written, which will be less
 * than "length" in case of error.
 */

/* Write items of type ARRAY */

static int
EdrWriteArray(Array     *data,
              long      length,
              FILE      *file,
              int       longlong)
{
   long n;

   for (n = 0;
        n < length && WriteEdrArray(&data[n], file, longlong);
        n++)
      { }

   return n;
}


/* Write items of type DOUBLE */

static int
EdrWriteDouble(double   *data,
               long     length,
               FILE     *file)
{
   long     n;          /* number of items written */
   double           item;       /* one data item for output */
   int              sn;         /* set sign bit? */
   int              ex;         /* exponent */
   unsigned long   hi;          /* high-order fraction bits