speechvoicescore.txt

语音评分算法的实现,主要可以实现对一段语音信号进行判别并进行打分功能.

/* Program to measure and score the difference between   */
/* a student utterance against a teacher's reference     */

#include "fixdpt_fp.h" 
#include "paras_fp.h"

#if RUN4PC
#include <stdio.h>
#include <stdlib.h>
#endif

/*global variables*/

#if RUN4PC   
/* declare array only for PC run */
SHORT TeacherSpeech[MAX_LEN] ; 
SHORT StudentSpeech[MAX_LEN] ;

 /** each frame, 0..OUTNUM-1 --> MFCC, NO logEnergy **/
FLOAT TeacherFeature[MAX_FRM][OUTNUM] ;   
FLOAT StudentFeature[MAX_FRM][OUTNUM] ;
#else  
/* for chip-run, both are pointers to flash mem */
SHORT *TeacherSpeech ;
SHORT *StudentSpeech ;
FLOAT *TeacherFeature ;
FLOAT *StudentFeature ;
#endif

/* Global variables */
INT   av1 ;
INT   av2 ;

#if RUN4PC
/* declare array only for PC run */
SHORT freq1[MAX_FRM] ;
char voicedv1[MAX_FRM] ;
SHORT  freq2[MAX_FRM] ;
char voicedv2[MAX_FRM] ;
#else
/* for chip-run,  make the following point to flash mem */
SHORT  *freq1 ;
char *voicedv1 ;
SHORT  *freq2 ;
char *voicedv2 ;
#endif

/* Global variables for DTW */
#if RUN4PC
SHORT   from[MAX_GRID*(2*BOUND/4)];   /** only 2-bit for each from direction **/
#else
 /* for chip-run,  make the following point to flash mem */
SHORT   *from ;
#endif

/* Computation Profiling Analysis */
#if CPA_F 
CPA COUNT = {0l,0l} ;

PrintCOUNT(char *s, int n)
{
   printf("%s\n",s)	;
   printf("Add = %ld    multy = %ld\n", COUNT.addition/n, COUNT.multy/n) ;
}
#endif

/*-------------------------------------*/
/* Fixed point arithmatic functions    */
/*-------------------------------------*/

FLOAT mult(FLOAT x, FLOAT y) 
{
  INT res ;   /* res needs to be 32-bit */
  
  res = x * y ;
  
#if CPA_F
COUNT.addition += 3 ;
COUNT.multy ++ ;
#endif
  
  if(res>(INT)0x02000000) return  MAX_16;
  if(res<(INT)0xfc000000) return  MIN_16;
  
  res >>= FPN   ;

  return (FLOAT) res ;
}

FLOAT divi(FLOAT x, FLOAT y)
{
   INT num, den ;    /* res needs to be 32-bit */

   num = ((INT)x) << FPN;
   den = (INT) y ;

#if CPA_F
COUNT.addition ++ ;
COUNT.multy ++ ;
#endif
   	
   return (FLOAT)(num/den);
}

SHORT extract_h(INT L_var1)
{
   SHORT var_out;

   var_out = (SHORT) (L_var1 >> 16);

   return(var_out);
}


SHORT extract_l(INT L_var1)
{
   SHORT var_out;

   var_out = (SHORT) L_var1;
  
   return(var_out);
}

SHORT saturate(INT L_var1)
{
   SHORT var_out;

   if (L_var1 > 0X00007fffL)
     {
      var_out = MAX_16;
     }
   else if (L_var1 < (INT)0xffff8000L)
     {
      var_out = MIN_16;
     }
   else
     {
      var_out = extract_l(L_var1);
     }

   return(var_out);
}

SHORT add(SHORT var1,SHORT var2)
{
   SHORT var_out;
   INT L_sum;

   L_sum = (INT) var1 + var2;
   var_out = saturate(L_sum);

   return(var_out);
}
  
SHORT shl(SHORT var1,SHORT var2)
{
   SHORT var_out;
   INT result;

   if (var2 < 0)
     {
      var_out = shr(var1,(SHORT)(-var2));
     }
   else
     {
      result = (INT) var1 * ((INT) 1 << var2);
     if ((var2 > 15 && var1 != 0) || (result != (INT)((SHORT) result)))
        {
         var_out = (var1 > 0) ? MAX_16 : MIN_16;
        }
      else
        {
         var_out = extract_l(result);
        }
     }
   return(var_out);
}

SHORT shr(SHORT var1,SHORT var2)
{
   SHORT var_out;

   if (var2 < 0)
     {
      var_out = shl(var1,(SHORT)(-var2));
     }
   else
     {
      if (var2 >= 15)
        {
         var_out = (var1 < 0) ? -1 : 0;
        }
      else
        {
         if (var1 < 0)
           {
     var_out = ~(( ~var1) >> var2 );
           }
         else
           {
            var_out = var1 >> var2;
           }
        }
     }
   return(var_out);
}
     
SHORT sub(SHORT var1,SHORT var2)
{
   SHORT var_out;
   INT L_diff;

   L_diff = (INT) var1 - var2;
   var_out = saturate(L_diff);

   return(var_out);
}

INT L_mult(SHORT var1,SHORT var2)
{
   INT L_var_out;

   L_var_out = (INT)var1 * (INT)var2;
   if (L_var_out != (INT)0x40000000L)
     {
      L_var_out *= 2;
     }
   else
     {
      L_var_out = MAX_32;
     }
      
   return(L_var_out);
}

INT L_msu(INT L_var3, SHORT var1, SHORT var2)
{
   INT L_var_out;
   INT L_product;

   L_product = L_mult(var1,var2);
 
   L_var_out = L_sub(L_var3,L_product);
 
   return(L_var_out);
}

INT L_sub(INT L_var1, INT L_var2)
{
   INT L_var_out;

   L_var_out = L_var1 - L_var2;

   if (((L_var1 ^ L_var2) & MIN_32) != 0)
     {
      if ((L_var_out ^ L_var1) & MIN_32)
        {
  			L_var_out = (L_var1 < 0L) ? MIN_32 : MAX_32;
        }
     }
   return(L_var_out);
}

INT L_shl(INT L_var1, SHORT var2)
{
   INT L_var_out;

   if (var2 <= 0)
     {
      L_var_out = L_shr(L_var1,(SHORT)(-var2));
     }
   else
     {
      for(;var2>0;var2--)
        {
         if (L_var1 > (INT) 0X3fffffffL)
           {
            L_var_out = MAX_32;
            break;
           }
         else
           {
            if (L_var1 < (INT) 0xc0000000L)
              {
               L_var_out = MIN_32;
               break;
              }
           }
         L_var1 *= 2;
         L_var_out = L_var1;
        }
     }
   return(L_var_out);
}

INT L_shr(INT L_var1, SHORT var2)
{
   INT L_var_out;

   if (var2 < 0)
     {
      L_var_out = L_shl(L_var1,(SHORT)(-var2));
     }
   else
     {
      if (var2 >= 31)
 {
  L_var_out = (L_var1 < 0L) ? -1 : 0;
 }
      else
 {
  if (L_var1<0)
    {
     L_var_out = ~((~L_var1) >> var2);
    }
  else
    {
     L_var_out = L_var1 >> var2;
    }
 }
     }
   return(L_var_out);
}

INT L_deposit_h(SHORT var1)
{
   INT L_var_out;

   L_var_out = (INT) var1 << 16;
   return(L_var_out);
}

SHORT norm_l(INT L_var1)
{
   SHORT var_out;

   if (L_var1 == 0)
     {
      var_out = 0;
     }
   else
     {
      if (L_var1 == (INT)0xffffffffL)
 {
  var_out = 31;
 }
      else
 {
  if (L_var1 < 0)
    {
     L_var1 = ~L_var1;
    }

  for(var_out = 0;L_var1 < (INT)0x40000000L;var_out++)
    {
     L_var1 <<= 1;
    }
 }
     }
   return(var_out);
}

void Log2(
  INT L_x,       /* (i)  : input value                                 */
  SHORT *exponant, /* (o)  : Integer part of Log2.   (range: 0<=val<=30) */
  SHORT *fraction  /* (o)  : Fractionnal part of Log2. (range: 0<=val<1) */
)
{
  SHORT exp, i, a, tmp;
  INT L_y;

  if( L_x <= (INT)0 )
  {
    *exponant = 0;
    *fraction = 0;
    return;
  }

  exp = norm_l(L_x);
  L_x = L_shl(L_x, exp );               /* L_x is normalized */

  *exponant = sub(30, exp);

  L_x = L_shr(L_x, 9);
  i   = extract_h(L_x);                 /* Extract b25-b31 */
  L_x = L_shr(L_x, 1);
  a   = extract_l(L_x);                 /* Extract b10-b24 of fraction */
  a   = (SHORT)(a & (SHORT)0x7fff);

  i   = sub(i, 32);

  L_y = L_deposit_h(log2table[i]);          /* table[i] << 16        */
  tmp = sub(log2table[i], log2table[i+1]);  /* table[i] - table[i+1] */
  L_y = L_msu(L_y, tmp, a);                 /* L_y -= tmp*a*2        */

  *fraction = extract_h( L_y);

  return;
}

INT xinvsqrt(INT L_x)
{
  SHORT exp, i, a, tmp;
  INT L_y;

  if( L_x <= (INT)0) {
    return ( (INT)0x3fffffffL);
  }

  exp = norm_l(L_x);
  L_x = L_shl(L_x, exp );              
  exp = sub(30, exp);
  if( (exp & 1) == 0 )                
      L_x = L_shr(L_x, 1);
  exp = shr(exp, 1);
  exp = add(exp, 1);
  L_x = L_shr(L_x, 9);
  i   = extract_h(L_x);                
  L_x = L_shr(L_x, 1);
  a   = extract_l(L_x);                
  a   = (SHORT)(a & (SHORT)0x7fff);       
  i   = sub(i, 16);
  L_y = L_deposit_h(xinvtable[i]);    
  tmp = sub(xinvtable[i], xinvtable[i+1]);
  L_y = L_msu(L_y, tmp, a);       
  L_y = L_shr(L_y, exp);          

  return(L_y);
}	 

/*************************************************************/
/** module for speech endpoints detection (based on energy) **/
/*************************************************************/

INT FrameEnergy(SHORT *smp, INT frm)
{
  INT j, e, s ;
  
  e = 0 ;
  for(j=0; j<FRAME_SIZE; j++) {
    s = (INT) smp[frm*FRAME_SHIFT+j];
    e += (s*s)>> 8;    /** >>8 == /FRAME_SIZE  -> do it here to avoid overflow **/
    
#if CPA_F
COUNT.addition += 5 ;
COUNT.multy +=2 ;
#endif 
 
  }
  return e;
}

/** energy-based end-pointing: detect beginning and end of speech **/
/** return # of speech frames **/

INT EndPointer(SHORT *smp, INT n_frames, INT *start, INT *end)
{
  INT frm, onset;
  INT e, noise_eng ;
  
  /** use first 10 frames to cal noise energy **/
  for(frm=0,noise_eng=0; frm<10; frm ++) 
    noise_eng += FrameEnergy(smp,frm) ;	
  noise_eng /= 10 ; 
  
#if PRINT && RUN4PC && 0
  printf("Noise Energy at speech beginning: %f per frame\n",(float)noise_eng) ;
#endif
  
  noise_eng *= ABOVE_NOISE_LEVEL ;
  
  onset=0 ;  *start = 0 ;
  for (frm=0; frm<n_frames; frm++) {
    e = FrameEnergy(smp,frm) ;
    if ( e >= noise_eng ) onset ++ ;
    else onset=0 ;