esig_edr.c

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

                                   (28 plus one hidden) */
   unsigned long   lo;          /* 24 low-order fraction bits */
   double           hix, lox;   /* hi and lo as double */

   for (n = 0; n < length; n++)
      {
         item = data[n];

         if (!(item <= DBL_MAX))        /* Inf or NaN */
            /* Don't change to if (item > DBL_MAX)! */
            {
               if (item > DBL_MAX)      /* Inf */
                  {
                     ex = 0x7ff;
                     hi = 0x0000000;
                     lo = 0x000000;
                  }
               else             /* NaN */
                  {
                     ex = 0x7ff;
                     hi = 0xfffffff;
                     lo = 0xffffff;
                  }
            }
         else if (item < -DBL_MAX)      /* -Inf */
            {
               ex = 0xfff;
               hi = 0x0000000;
               lo = 0x000000;
            }
         else
            {
               sn = (item < 0.0);
               item = frexp((sn) ? -item : item, &ex);

               if (item == 0)
                  ex = -1021;
               else if (ex < -1021)
                  {
                     item = ldexp(item, 29 - (-1021 - ex));
                     ex = -1021;
                  }
               else
                  item = ldexp(item, 29);

               lox = modf(item, &hix);

               lo = (unsigned long) (0.5 + ldexp(lox, 24));
               if (lo >= 0x1000000) /* 2^24 */
                  {
                     lo -= 0x1000000; /* 2^24 */
                     hi = 1 + (unsigned long) hix;
                  }
               else
                  hi = (unsigned long) hix;

               if (hi >= 0x20000000) /* 2^29 */
                  {
                     hi = 0x10000000; /* 2^28 */
                     lo = 0;
                     ex += 1;
                  }
               else if (hi < 0x10000000 /* 2^28 */
                        && ex > -1021)
                  {
                     hi = 0x10000000; /* 2^28 */
                     lo = 0;
                  }

               if (ex > 1024)   /* overflow */
                  {
                     ex = 0x7ff;
                     hi = 0x0000000;
                     lo = 0x000000;
                  }
               else if (hi < 0x10000000) /* 2^28 *//* subnormal */
                  ex = 0x000;
               else             /* normalized */
                  {
                     ex += 1022;
                     hi &= 0xfffffff; /* mask off hidden bit */
                  }

               if (sn)
                  ex |= 0x800;
            }

         if (putc(ex >> 4, file) == EOF) /* sign, 7 bits of exponent */
            break;

         if (putc(((ex << 4) & 0xf0) | (hi >> 24),
                  file) == EOF) /* rest of exponent, 4 fraction bits */
            break;

         if (putc((hi >> 16) & 0xff, file) == EOF)
            break;

         if (putc((hi >> 8) & 0xff, file) == EOF)
            break;

         if (putc(hi & 0xff, file) == EOF)
            break;

         if (putc((lo >> 16) & 0xff, file) == EOF) /* start on lo */
            break;

         if (putc((lo >> 8) & 0xff, file) == EOF) /* start on lo */
            break;

         if (putc(lo & 0xff, file) == EOF) /* start on lo */
            break;
      }

   return n;
}


/* Write items of type FLOAT */

static int
EdrWriteFloat(float     *data,
              long      length,
              FILE      *file)
{
   long     n;          /* number of items written */
   float            item;       /* one data item for output */
   int              sn;         /* sign */
   int              ex;         /* exponent */
   unsigned long   fr;          /* 23 fraction bits (and hidden bit) */
   double           frx;        /* fr as double */

   for (n = 0; n < length; n++)
      {
         item = data[n];

         if (!(item <= FLT_MAX))
            /* Don't change to if (item > FLT_MAX)! */
            {
               if (item > DBL_MAX)      /* Inf */
                  {
                     ex = 0x0ff;
                     fr = 0x000000;
                  }
               else             /* NaN */
                  {
                     ex = 0x0ff;
                     fr = 0x7fffff;
                  }
            }
         else if (item < -FLT_MAX)      /* -Inf */
            {
               ex = 0x1ff;
               fr = 0x000000;
            }
         else
            {
               /*! Check for IEEE -0.0 */
               sn = (item < 0.0);
               frx = frexp((sn) ? -item : item, &ex);

               if (frx == 0)
                  ex = -125;
               else if (ex < -125)
                  {
                     frx = ldexp(frx, 24 - (-125 - ex));
                     ex = -125;
                  }
               else
                  frx = ldexp(frx, 24);

               fr = (unsigned long) (0.5 + frx);
               if (fr >= 0x1000000) /* 2^24 */
                  {
                     fr = 0x800000;     /* 2^23 */
                     ex += 1;
                  }
               else if (fr < 0x800000 /* 2^23 */
                        && ex > -125)
                  fr = 0x800000;        /* 2^23 */

               if (ex > 128)    /* overflow */
                  {
                     ex = 0x0ff;
                     fr = 0x000000;
                  }
               else if (fr < 0x800000) /* 2^23 *//* subnormal */
                  ex = 0x000;
               else             /* normalized */
                  {
                     ex += 126;
                     fr &= 0x7fffff;    /* mask off hidden bit */
                  }

               if (sn)
                  ex |= 0x100;
            }

         if (putc(ex >> 1, file) == EOF) /* sign, 7 bits of exponent */
            break;

         if (putc(((ex << 7) & 0x80) | (fr >> 16),
                  file) == EOF)  /* rest of exponent, 7 fraction bits */
            break;

         if (putc((fr >> 8) & 0xff, file) == EOF)
            break;

         if (putc(fr & 0xff, file) == EOF)
            break;
      }

   return n;
}


/* Write items of type LONG */

static int
EdrWriteLong(long       *data,
             long       length,
             FILE       *file,
             int        longlong)
{
   long     n;          /* number of items written */
   long     item;       /* one data item for output */

   /* This clips if native long values fall outside range
    * representable with EDR.
    */
   switch (longlong)
      {
      case EDR1:
         {
            unsigned long   u;

            for (n = 0; n < length; n++)
               {

#if (LONG_MAX > 0x7fffffffL)    /* longs more than 32 bits */

                  item = data[n];

                  if (item > 0x7fffffffL)
                     {
                        u = 0x7fffffffL;
                        /* CLIPPING */
                     }
                  else if (item < -0x80000000L)
                     {
                        u = -0x80000000L;
                        /* CLIPPING */
                     }
                  else
                     u = item;

#else  /* 32-bit longs */

                  u = data[n];

#endif

                  if (putc((u >> 24) & 0xff, file) == EOF)
                     break;

                  if (putc((u >> 16) & 0xff, file) == EOF)
                     break;

                  if (putc((u >> 8) & 0xff, file) == EOF)
                     break;

                  if (putc(u & 0xff, file) == EOF)
                     break;
               }

            return n;
         }
         break;
      case EDR2:
         {
            unsigned long   hi, lo;

            for (n = 0; n < length; n++)
               {
                  item = data[n];

#if (LONG_MAX > 0x7fffffffL)    /* longs more than 32 bits */

                  lo = ((unsigned long) item) & 0xffffffffUL;

                  if (item >= 0)
                     hi = item >> 32;
                  else
                     hi = ~((unsigned long) (-1L - item) >> 32);

#else  /* 32-bit longs */

                  if (item >= 0)
                     hi = 0UL;
                  else
                     hi = 0xffffffffUL;

                  lo = (unsigned long) item;

#endif

                  if (putc((hi >> 24) & 0xff, file) == EOF)
                     break;

                  if (putc((hi >> 16) & 0xff, file) == EOF)
                     break;

                  if (putc((hi >> 8) & 0xff, file) == EOF)
                     break;

                  if (putc(hi & 0xff, file) == EOF)
                     break;

                  if (putc((lo >> 24) & 0xff, file) == EOF)
                     break;

                  if (putc((lo >> 16) & 0xff, file) == EOF)
                     break;

                  if (putc((lo >> 8) & 0xff, file) == EOF)
                     break;

                  if (putc(lo & 0xff, file) == EOF)
                     break;
               }

            return n;
         }
         break;
      default:
         return 0;
      }
}


/* Write items of type ULONG */

static int
EdrWriteUlong(Ulong *data,
              long length,
              FILE *file,
              int longlong)
{
   long     n;          /* number of items written */

   /* This clips if native unsigned long values fall outside range
    * representable with EDR.
    */
   switch (longlong)
      {
      case EDR1:
         {
            unsigned long   u;

            for (n = 0; n < length; n++)
               {
                  u = data[n];

#if (ULONG_MAX > 0xffffffffUL)  /* unsigned longs more than 32 bits */

                  if (u > 0xffffffffL)
                     {
                        u = 0xffffffffL;
                        /* CLIPPING */
                     }

#endif

                  if (putc((u >> 24) & 0xff, file) == EOF)
                     break;

                  if (putc((u >> 16) & 0xff, file) == EOF)
                     break;

                  if (putc((u >> 8) & 0xff, file) == EOF)
                     break;

                  if (putc(u & 0xff, file) == EOF)
                     break;
               }

            return n;
         }
         break;
      case EDR2:
         {
            unsigned long   hi, lo;

            for (n = 0; n < length; n++)
               {
                  lo = data[n];

#if (ULONG_MAX > 0xffffffffUL)  /* unsigned longs more than 32 bits */

                  hi = lo >> 32;
                  lo &= 0xffffffffUL;

#else  /* 32-bit unsigned longs */

                  hi = 0UL;
#endif

                  if (putc((hi >> 24) & 0xff, file) == EOF)
                     break;

                  if (putc((hi >> 16) & 0xff, file) == EOF)
                     break;

                  if (putc((hi >> 8) & 0xff, file) == EOF)
                     break;

                  if (putc(hi & 0xff, file) == EOF)
                     break;

                  if (putc((lo >> 24) & 0xff, file) == EOF)
                     break;

                  if (putc((lo >> 16) & 0xff, file) == EOF)
                     break;

                  if (putc((lo >> 8) & 0xff, file) == EOF)
                     break;

                  if (putc(lo & 0xff, file) == EOF)
                     break;
               }

            return n;
         }
         break;
      default:
         return 0;
      }
}


/* Write items of type SHORT */

static int
EdrWriteShort(short     *data,
              long      length,
              FILE      *file)
{
   long     n;          /* number of items written */
   long     item;       /* one data item for output */
   unsigned int    u;           /* item as unsigned int */

   /* This clips if native short values fall outside range
    * representable with EDR.
    */

   for (n = 0; n < length; n++)
      {
         item = data[n];

         if (item < - 0x8000L)
            u = 0x8000U;
         else if (item > 0x7fffL)
            u = 0x7fffU;
         else
            u = (unsigned int) item;

         if (putc((u >> 8) & 0xff, file) == EOF)
            break;

         if (putc(u & 0xff, file) == EOF)
            break;
      }

   return n;
}


/* Write items of type USHORT */

static int
EdrWriteUshort(Ushort *data,
               long length,
               FILE *file)
{
   long     n;          /* number of items written */
   Ushort           u;          /* one data item for output */

   /* This clips if native short