织梦CMS - 轻松建站从此开始!

罗索

静音检测VAD算法

jackyhwei 发布于 2020-08-07 13:41 点击:次 
最近把opus编码器里的VAD算法提取了出来,之前在网上没找到合适的开源VAD模块,就把代码放在这里吧,希望能帮助到人。
TAG: VAD  静音检测  VAD算法  

最近把opus编码器里的VAD算法提取了出来,之前在网上没找到合适的开源VAD模块,就把代码放在这里吧,希望能帮助到人。
下面是.h文件和.cpp文件,使用的时候,需要调用silk_VAD_Get()这个函数,每次输入一个帧(我默认了帧长是20ms,采样率16khz,可以自己在silk_VAD_Get里修改),返回0或者1,代表该帧是否为静音帧。
.h文件代码:

  1. #include <stdlib.h> 
  2. #include <malloc.h> 
  3. #include <intrin.h> 
  4. #include <string.h> 
  5.   
  6. int silk_VAD_Get( 
  7.     //int          state,                       /*  Encoder state                               */ 
  8.     const short            pIn[]                           /* I    PCM input                                   */ 
  9. ); 
  10.   
  11. #define TYPE_NO_VOICE_ACTIVITY                  0 
  12. #define TYPE_UNVOICED                           1 
  13. #define TYPE_VOICED                             2 
  14.   
  15. #define SPEECH_ACTIVITY_DTX_THRES                       0.05f 
  16. #define SILK_FIX_CONST( C, Q )              ((int)((C) * ((long)1 << (Q)) + 0.5)) 
  17. #define silk_int16_MAX   0x7FFF                               /*  2^15 - 1 =  32767 */ 
  18. #define silk_int16_MIN   ((short)0x8000)                 /* -2^15     = -32768 */ 
  19. #define silk_int32_MAX   0x7FFFFFFF                           /*  2^31 - 1 =  2147483647 */ 
  20. #define silk_int32_MIN   ((int)0x80000000)             /* -2^31     = -2147483648 */ 
  21. #define silk_memset(dest, src, size)        memset((dest), (src), (size)) 
  22.   
  23. #define VAD_NOISE_LEVEL_SMOOTH_COEF_Q16         1024    /* Must be <  4096 */ 
  24. #define VAD_NOISE_LEVELS_BIAS                   50 
  25.   
  26. /* Sigmoid settings */ 
  27. #define VAD_NEGATIVE_OFFSET_Q5                  128     /* sigmoid is 0 at -128 */ 
  28. #define VAD_SNR_FACTOR_Q16                      45000 
  29.   
  30. /* smoothing for SNR measurement */ 
  31. #define VAD_SNR_SMOOTH_COEF_Q18                 4096 
  32.   
  33. #define VAD_N_BANDS 4 
  34. #define VAD_INTERNAL_SUBFRAMES_LOG2             2 
  35. #define VAD_INTERNAL_SUBFRAMES                  ( 1 << VAD_INTERNAL_SUBFRAMES_LOG2 ) 
  36. #define silk_uint8_MAX   0xFF                                 /*  2^8 - 1 = 255 */ 
  37.   
  38. #define VARDECL(type, var) type *var 
  39. #define silk_RSHIFT32(a, shift)             ((a)>>(shift)) 
  40. #define silk_RSHIFT(a, shift)             ((a)>>(shift)) 
  41. #define silk_LSHIFT32(a, shift)             ((a)<<(shift)) 
  42. #define silk_LSHIFT(a, shift)             ((a)<<(shift)) 
  43. #define ALLOC(var, size, type) var = ((type*)alloca(sizeof(type)*(size))) 
  44. #define silk_ADD16(a, b)                    ((a) + (b)) 
  45. #define silk_ADD32(a, b)                    ((a) + (b)) 
  46. #define silk_ADD64(a, b)                    ((a) + (b)) 
  47.   
  48. #define silk_SUB16(a, b)                    ((a) - (b)) 
  49. #define silk_SUB32(a, b)                    ((a) - (b)) 
  50. #define silk_SUB64(a, b)                    ((a) - (b)) 
  51. #define silk_SMULWB(a32, b32)
  52.             ((((a32) >> 16) * (int)((short)(b32))) + ((((a32) & 0x0000FFFF) * (int)((short)(b32))) >> 16)) 
  53. #define silk_SMLAWB(a32, b32, c32)
  54.        ((a32) + ((((b32) >> 16) * (int)((short)(c32))) + ((((b32) & 0x0000FFFF) * (int)((short)(c32))) >> 16))) 
  55. #define silk_SAT16(a) 
  56.                       ((a) > silk_int16_MAX ? silk_int16_MAX :      \ 
  57.                                             ((a) < silk_int16_MIN ? silk_int16_MIN : (a))) 
  58. #define silk_MLA(a32, b32, c32)             silk_ADD32((a32),((b32) * (c32))) 
  59. #define silk_SMLABB(a32, b32, c32)
  60.        ((a32) + ((int)((short)(b32))) * (int)((short)(c32))) 
  61. #define silk_ADD_POS_SAT32(a, b)
  62.             ((((unsigned int)(a)+(unsigned int)(b)) & 0x80000000) ? silk_int32_MAX : ((a)+(b))) 
  63. #define silk_ADD_POS_SAT32(a, b)
  64.             ((((unsigned int)(a)+(unsigned int)(b)) & 0x80000000) ? silk_int32_MAX : ((a)+(b))) 
  65. #define silk_DIV32_16(a32, b16)             ((int)((a32) / (b16))) 
  66. #define silk_DIV32(a32, b32)                ((int)((a32) / (b32))) 
  67. #define silk_RSHIFT_ROUND(a, shift)
  68.          ((shift) == 1 ? ((a) >> 1) + ((a) & 1) : (((a) >> ((shift) - 1)) + 1) >> 1) 
  69.   
  70. #define silk_SMULWW(a32, b32)
  71.             silk_MLA(silk_SMULWB((a32), (b32)), (a32), silk_RSHIFT_ROUND((b32), 16)) 
  72. #define silk_min(a, b)                      (((a) < (b)) ? (a) : (b)) 
  73. #define silk_max(a, b)                      (((a) > (b)) ? (a) : (b)) 
  74. #define silk_ADD_LSHIFT32(a, b, shift)
  75.       silk_ADD32((a), silk_LSHIFT32((b), (shift)))    /* shift >= 0 */ 
  76. #define silk_MUL(a32, b32)                  ((a32) * (b32)) 
  77. #define silk_SMULBB(a32, b32) 
  78.            ((int)((short)(a32)) * (int)((short)(b32))) 
  79. #define silk_LIMIT( a, limit1, limit2)
  80.   ((limit1) > (limit2) ? ((a) > (limit1) ? (limit1) : ((a) < (limit2) ? (limit2) : (a))) \ 
  81.  : ((a) > (limit2) ? (limit2) : ((a) < (limit1) ? (limit1) : (a)))) 
  82.   
  83. #define silk_LSHIFT_SAT32(a, shift)
  84.          (silk_LSHIFT32( silk_LIMIT( (a), silk_RSHIFT32( silk_int32_MIN, (shift) ), \ 
  85.          silk_RSHIFT32( silk_int32_MAX, (shift) ) ), (shift) )) 
  86.   
  87.   
  88.   
  89.   
  90.   
  91.   
  92.   
  93. static const int tiltWeights[VAD_N_BANDS] = { 30000, 6000, -12000, -12000 }; 
  94. static const int sigm_LUT_neg_Q15[6] = { 
  95.     16384, 8812, 3906, 1554, 589, 219 
  96. }; 
  97. static const int sigm_LUT_slope_Q10[6] = { 
  98.     237, 153, 73, 30, 12, 7 
  99. }; 
  100. static const int sigm_LUT_pos_Q15[6] = { 
  101.     16384, 23955, 28861, 31213, 32178, 32548 
  102. }; 
  103.   
  104. static __inline int ec_bsr(unsigned long _x) { 
  105.     unsigned long ret; 
  106.     _BitScanReverse(&ret, _x); 
  107.     return (int)ret; 
  108. # define EC_CLZ0    (1) 
  109. # define EC_CLZ(_x) (-ec_bsr(_x)) 
  110. # define EC_ILOG(_x) (EC_CLZ0-EC_CLZ(_x)) 
  111. static int silk_min_int(int a, int b) 
  112.     return (((a) < (b)) ? (a) : (b)); 
  113. static int silk_max_int(int a, int b) 
  114.     return (((a) > (b)) ? (a) : (b)); 
  115. static int silk_max_32(int a, int b) 
  116.     return (((a) > (b)) ? (a) : (b)); 
  117. static  int silk_CLZ32(int in32) 
  118.     return in32 ? 32 - EC_ILOG(in32) : 32; 
  119. static  int silk_ROR32(int a32, int rot) 
  120.     unsigned int x = (unsigned int)a32; 
  121.     unsigned int r = (unsigned int)rot; 
  122.     unsigned int m = (unsigned int)-rot; 
  123.     if (rot == 0) { 
  124.         return a32; 
  125.     } 
  126.     else if (rot < 0) { 
  127.         return (int)((x << m) | (x >> (32 - m))); 
  128.     } 
  129.     else { 
  130.         return (int)((x << (32 - r)) | (x >> r)); 
  131.     } 
  132. static  void silk_CLZ_FRAC( 
  133.     int in,            /* I  input                               */ 
  134.     int *lz,           /* O  number of leading zeros             */ 
  135.     int *frac_Q7       /* O  the 7 bits right after the leading one */ 
  136.     int lzeros = silk_CLZ32(in); 
  137.   
  138.     *lz = lzeros; 
  139.     *frac_Q7 = silk_ROR32(in, 24 - lzeros) & 0x7f; 
  140.   
  141.   
  142. /* Approximation of square root                                          */ 
  143. /* Accuracy: < +/- 10%  for output values > 15                           */ 
  144. /*           < +/- 2.5% for output values > 120                          */ 
  145. static  int silk_SQRT_APPROX(int x) 
  146.     int y, lz, frac_Q7; 
  147.   
  148.     if (x <= 0) { 
  149.         return 0; 
  150.     } 
  151.   
  152.     silk_CLZ_FRAC(x, &lz, &frac_Q7); 
  153.   
  154.     if (lz & 1) { 
  155.         y = 32768; 
  156.     } 
  157.     else { 
  158.         y = 46214;        /* 46214 = sqrt(2) * 32768 */ 
  159.     } 
  160.   
  161.     /* get scaling right */ 
  162.     y >>= silk_RSHIFT(lz, 1); 
  163.   
  164.     /* increment using fractional part of input */ 
  165.     y = silk_SMLAWB(y, y, silk_SMULBB(213, frac_Q7)); 
  166.   
  167.     return y; 

.cpp文件代码:

  1. #include "opusvad.h" 
  2. #include <stdlib.h> 
  3.   
  4. static short A_fb1_20 = 5394 << 1
  5. static short A_fb1_21 = -24290; /* (int16)(20623 << 1) */ 
  6.   
  7. typedef struct { 
  8.     int                  AnaState[2];            
  9.       /* Analysis filterbank state: 0-8 kHz                                   */ 
  10.     int                  AnaState1[2];           
  11.       /* Analysis filterbank state: 0-4 kHz                                   */ 
  12.     int                  AnaState2[2];            
  13.      /* Analysis filterbank state: 0-2 kHz                                   */ 
  14.     int                  XnrgSubfr[4];  
  15.      /* Subframe energies                                                    */ 
  16.     int                  NrgRatioSmth_Q8[VAD_N_BANDS];
  17.  /* Smoothed energy level in each band                                   */ 
  18.     short                 HPstate;          
  19.               /* State of differentiator in the lowest band                           */ 
  20.     int                  NL[VAD_N_BANDS];      
  21.         /* Noise energy level in each band                                      */ 
  22.     int                  inv_NL[VAD_N_BANDS];   
  23.        /* Inverse noise energy level in each band                              */ 
  24.     int                  NoiseLevelBias[VAD_N_BANDS];
  25.   /* Noise level estimator bias/offset                                    */ 
  26.     int                  counter;       
  27.       /* Frame counter used in the initial phase                              */ 
  28. } VAD_state; 
  29.   
  30. /* Split signal into two decimated bands using first-order allpass filters */ 
  31. void silk_ana_filt_bank_1( 
  32.     const short            *in,  
  33.               /* I    Input signal [N]                                            */ 
  34.     int                  *S,  
  35.                /* I/O  State vector [2]                                            */ 
  36.     short                  *outL,  
  37.             /* O    Low band [N/2]                                              */ 
  38.     short                  *outH, 
  39.              /* O    High band [N/2]                                             */ 
  40.     const int            N    
  41.                /* I    Number of input samples                                     */ 
  42.     int      k, N2 = silk_RSHIFT(N, 1); 
  43.     int    in32, X, Y, out_1, out_2; 
  44.   
  45.     /* Internal variables and state are in Q10 format */ 
  46.     for (k = 0; k < N2; k++) { 
  47.         /* Convert to Q10 */ 
  48.         in32 = silk_LSHIFT((int)in[2 * k], 10); 
  49.   
  50.         /* All-pass section for even input sample */ 
  51.         Y = silk_SUB32(in32, S[0]); 
  52.         X = silk_SMLAWB(Y, Y, A_fb1_21); 
  53.         out_1 = silk_ADD32(S[0], X); 
  54.         S[0] = silk_ADD32(in32, X); 
  55.   
  56.         /* Convert to Q10 */ 
  57.         in32 = silk_LSHIFT((int)in[2 * k + 1], 10); 
  58.   
  59.         /* All-pass section for odd input sample, and add to output of previous section */ 
  60.         Y = silk_SUB32(in32, S[1]); 
  61.         X = silk_SMULWB(Y, A_fb1_20); 
  62.         out_2 = silk_ADD32(S[1], X); 
  63.         S[1] = silk_ADD32(in32, X); 
  64.   
  65.         /* Add/subtract, convert back to int16 and store to output */ 
  66.         outL[k] = (short)silk_SAT16(silk_RSHIFT_ROUND(silk_ADD32(out_2, out_1), 11)); 
  67.         outH[k] = (short)silk_SAT16(silk_RSHIFT_ROUND(silk_SUB32(out_2, out_1), 11)); 
  68.     } 
  69.   
  70. void silk_VAD_GetNoiseLevels( 
  71.     const int            pX[VAD_N_BANDS],
  72.   /* I    subband energies                            */ 
  73.     VAD_state              *psSilk_VAD      
  74.   /* I/O  Pointer to Silk VAD state                   */ 
  75.     int   k; 
  76.     int nl, nrg, inv_nrg; 
  77.     int   coef, min_coef; 
  78.   
  79.     /* Initially faster smoothing */ 
  80.     if (psSilk_VAD->counter < 1000) { /* 1000 = 20 sec */ 
  81.         min_coef = silk_DIV32_16(silk_int16_MAX, silk_RSHIFT(psSilk_VAD->counter, 4) + 1); 
  82.     } 
  83.     else { 
  84.         min_coef = 0
  85.     } 
  86.   
  87.     for (k = 0; k < VAD_N_BANDS; k++) { 
  88.         /* Get old noise level estimate for current band */ 
  89.         nl = psSilk_VAD->NL[k]; 
  90.         //silk_assert(nl >= 0); 
  91.   
  92.         /* Add bias */ 
  93.         nrg = silk_ADD_POS_SAT32(pX[k], psSilk_VAD->NoiseLevelBias[k]); 
  94.         //silk_assert(nrg > 0); 
  95.   
  96.         /* Invert energies */ 
  97.         inv_nrg = silk_DIV32(silk_int32_MAX, nrg); 
  98.         //silk_assert(inv_nrg >= 0); 
  99.   
  100.         /* Less update when subband energy is high */ 
  101.         if (nrg > silk_LSHIFT(nl, 3)) { 
  102.             coef = VAD_NOISE_LEVEL_SMOOTH_COEF_Q16 >> 3; 
  103.         } 
  104.         else if (nrg < nl) { 
  105.             coef = VAD_NOISE_LEVEL_SMOOTH_COEF_Q16
  106.         } 
  107.         else { 
  108.             coef = silk_SMULWB(silk_SMULWW(inv_nrg, nl), VAD_NOISE_LEVEL_SMOOTH_COEF_Q16 << 1); 
  109.         } 
  110.   
  111.         /* Initially faster smoothing */ 
  112.         coef = silk_max_int(coef, min_coef); 
  113.   
  114.         /* Smooth inverse energies */ 
  115.         psSilk_VAD->inv_NL[k] = silk_SMLAWB(psSilk_VAD->inv_NL[k]
  116. , inv_nrg - psSilk_VAD->inv_NL[k], coef); 
  117.         //silk_assert(psSilk_VAD->inv_NL[k] >= 0); 
  118.   
  119.         /* Compute noise level by inverting again */ 
  120.         nl = silk_DIV32(silk_int32_MAX, psSilk_VAD->inv_NL[k]); 
  121.         //silk_assert(nl >= 0); 
  122.   
  123.         /* Limit noise levels (guarantee 7 bits of head room) */ 
  124.         nl = silk_min(nl, 0x00FFFFFF); 
  125.   
  126.         /* Store as part of state */ 
  127.         psSilk_VAD->NL[k] = nl; 
  128.     } 
  129.   
  130.     /* Increment frame counter */ 
  131.     psSilk_VAD->counter++; 
  132.   
  133. int silk_lin2log( 
  134.     const int            inLin               /* I  input in linear scale  */ 
  135.     int lz, frac_Q7; 
  136.   
  137.     silk_CLZ_FRAC(inLin, &lz, &frac_Q7); 
  138.   
  139.     /* Piece-wise parabolic approximation */ 
  140.     return silk_ADD_LSHIFT32(silk_SMLAWB(frac_Q7, silk_MUL(frac_Q7, 128 - frac_Q7), 179), 31 - lz, 7); 
  141.   
  142. int silk_sigm_Q15( 
  143.     int                    in_Q5               /* I  */ 
  144.     int ind; 
  145.   
  146.     if (in_Q5 < 0) { 
  147.         /* Negative input */ 
  148.         in_Q5 = -in_Q5; 
  149.         if (in_Q5 >= 6 * 32) { 
  150.             return 0;        /* Clip */ 
  151.         } 
  152.         else { 
  153.             /* Linear interpolation of look up table */ 
  154.             ind = silk_RSHIFT(in_Q5, 5); 
  155.             return(sigm_LUT_neg_Q15[ind] - silk_SMULBB(sigm_LUT_slope_Q10[ind], in_Q5 & 0x1F)); 
  156.         } 
  157.     } 
  158.     else { 
  159.         /* Positive input */ 
  160.         if (in_Q5 >= 6 * 32) { 
  161.             return 32767;        /* clip */ 
  162.         } 
  163.         else { 
  164.             /* Linear interpolation of look up table */ 
  165.             ind = silk_RSHIFT(in_Q5, 5); 
  166.             return(sigm_LUT_pos_Q15[ind] + silk_SMULBB(sigm_LUT_slope_Q10[ind], in_Q5 & 0x1F)); 
  167.         } 
  168.     } 
  169. int silk_VAD_Init(                              
  170.            /* O    Return value, 0 if success                  */ 
  171.     VAD_state              *psSilk_VAD            
  172.          /* I/O  Pointer to Silk VAD state                   */ 
  173.     int b, ret = 0
  174.   
  175.     /* reset state memory */ 
  176.     silk_memset(psSilk_VAD, 0, sizeof(VAD_state)); 
  177.   
  178.     /* init noise levels */ 
  179.     /* Initialize array with approx pink noise levels (psd proportional to inverse of frequency) */ 
  180.     for (b = 0; b < VAD_N_BANDS; b++) { 
  181.         psSilk_VAD->NoiseLevelBias[b] = silk_max_32(silk_DIV32_16(VAD_NOISE_LEVELS_BIAS, b + 1), 1); 
  182.     } 
  183.   
  184.     /* Initialize state */ 
  185.     for (b = 0; b < VAD_N_BANDS; b++) { 
  186.         psSilk_VAD->NL[b] = silk_MUL(100, psSilk_VAD->NoiseLevelBias[b]); 
  187.         psSilk_VAD->inv_NL[b] = silk_DIV32(silk_int32_MAX, psSilk_VAD->NL[b]); 
  188.     } 
  189.     psSilk_VAD->counter = 15
  190.   
  191.     /* init smoothed energy-to-noise ratio*/ 
  192.     for (b = 0; b < VAD_N_BANDS; b++) { 
  193.         psSilk_VAD->NrgRatioSmth_Q8[b] = 100 * 256;       /* 100 * 256 --> 20 dB SNR */ 
  194.     } 
  195.   
  196.     return(ret); 
  197.   
  198. static int noSpeechCounter; 
  199.   
  200. int silk_VAD_Get( 
  201.     //int          state,                       /*  Encoder state     */ 
  202.     const short            pIn[]                           /* I    PCM input    */ 
  203.     int   SA_Q15, pSNR_dB_Q7, input_tilt; 
  204.     int   decimated_framelength1, decimated_framelength2; 
  205.     int   decimated_framelength; 
  206.     int   dec_subframe_length, dec_subframe_offset, SNR_Q7, i, b, s; 
  207.     int sumSquared, smooth_coef_Q16; 
  208.     short HPstateTmp; 
  209.     VARDECL(short, X); 
  210.     int Xnrg[4]; 
  211.     int NrgToNoiseRatio_Q8[4]; 
  212.     int speech_nrg, x_tmp; 
  213.     int   X_offset[4]; 
  214.     int   ret = 0
  215.     int frame_length = 20;// 
  216.     int fs_kHz = 16
  217.     int  input_quality_bands_Q15[VAD_N_BANDS]; 
  218.     int signalType; 
  219.     int VAD_flag; 
  220.     /* Safety checks 
  221.     silk_assert(4 == 4); 
  222.     silk_assert(MAX_FRAME_LENGTH >= frame_length); 
  223.     silk_assert(frame_length <= 512); 
  224.     silk_assert(frame_length == 8 * silk_RSHIFT(frame_length, 3)); 
  225.     */ 
  226.     /***********************/ 
  227.     /* Filter and Decimate */ 
  228.     /***********************/ 
  229.     decimated_framelength1 = silk_RSHIFT(frame_length, 1); 
  230.     decimated_framelength2 = silk_RSHIFT(frame_length, 2); 
  231.     decimated_framelength = silk_RSHIFT(frame_length, 3); 
  232.     /* Decimate into 4 bands: 
  233.     0       L      3L       L              3L                             5L 
  234.     -      --       -              --                             -- 
  235.     8       8       2               4                              4 
  236.     [0-1 kHz| temp. |1-2 kHz|    2-4 kHz    |            4-8 kHz           | 
  237.     They're arranged to allow the minimal ( frame_length / 4 ) extra 
  238.     scratch space during the downsampling process */ 
  239.     X_offset[0] = 0; 
  240.     X_offset[1] = decimated_framelength + decimated_framelength2; 
  241.     X_offset[2] = X_offset[1] + decimated_framelength; 
  242.     X_offset[3] = X_offset[2] + decimated_framelength2; 
  243.     ALLOC(X, X_offset[3] + decimated_framelength1, short); 
  244.     VAD_state *psSilk_VAD; 
  245.     psSilk_VAD = (VAD_state*)malloc(sizeof(VAD_state)); 
  246.     int ret1 = silk_VAD_Init(psSilk_VAD); 
  247.   
  248.   
  249.   
  250.     /* 0-8 kHz to 0-4 kHz and 4-8 kHz */ 
  251.     silk_ana_filt_bank_1(pIn, &psSilk_VAD->AnaState[0], 
  252.         X, &X[X_offset[3]], frame_length); 
  253.   
  254.     /* 0-4 kHz to 0-2 kHz and 2-4 kHz */ 
  255.     silk_ana_filt_bank_1(X, &psSilk_VAD->AnaState1[0], 
  256.         X, &X[X_offset[2]], decimated_framelength1); 
  257.   
  258.     /* 0-2 kHz to 0-1 kHz and 1-2 kHz */ 
  259.     silk_ana_filt_bank_1(X, &psSilk_VAD->AnaState2[0], 
  260.         X, &X[X_offset[1]], decimated_framelength2); 
  261.   
  262.     /*********************************************/ 
  263.     /* HP filter on lowest band (differentiator) */ 
  264.     /*********************************************/ 
  265.     X[decimated_framelength - 1] = silk_RSHIFT(X[decimated_framelength - 1], 1); 
  266.     HPstateTmp = X[decimated_framelength - 1]; 
  267.     for (i = decimated_framelength - 1; i > 0; i--) { 
  268.         X[i - 1] = silk_RSHIFT(X[i - 1], 1); 
  269.         X[i] -X[i - 1]; 
  270.     } 
  271.     X[0] -psSilk_VAD->HPstate; 
  272.     psSilk_VAD->HPstate = HPstateTmp
  273.   
  274.     /*************************************/ 
  275.     /* Calculate the energy in each band */ 
  276.     /*************************************/ 
  277.     for (b = 0; b < 4; b++) { 
  278.         /* Find the decimated framelength in the non-uniformly divided bands */ 
  279.         decimated_framelength = silk_RSHIFT(frame_length, silk_min_int(4 - b, 4 - 1)); 
  280.   
  281.         /* Split length into subframe lengths */ 
  282.         dec_subframe_length = silk_RSHIFT(decimated_framelength, VAD_INTERNAL_SUBFRAMES_LOG2); 
  283.         dec_subframe_offset = 0
  284.   
  285.         /* Compute energy per sub-frame */ 
  286.         /* initialize with summed energy of last subframe */ 
  287.         Xnrg[b] = psSilk_VAD->XnrgSubfr[b]; 
  288.         for (s = 0; s < VAD_INTERNAL_SUBFRAMES; s++) { 
  289.             sumSquared = 0
  290.             for (i = 0; i < dec_subframe_length; i++) { 
  291. /* The energy will be less than dec_subframe_length * ( silk_short_MIN / 8 ) ^ 2.            */ 
  292. /* Therefore we can accumulate with no risk of overflow (unless dec_subframe_length > 128)  */ 
  293.                 x_tmp = silk_RSHIFT
  294.                     X[X_offset[b] + i + dec_subframe_offset], 3); 
  295.                 sumSquared = silk_SMLABB(sumSquared, x_tmp, x_tmp); 
  296.   
  297.                 /* Safety check */ 
  298.                 //silk_assert(sumSquared >= 0); 
  299.             } 
  300.   
  301.             /* Add/saturate summed energy of current subframe */ 
  302.             if (s < VAD_INTERNAL_SUBFRAMES - 1) { 
  303.                 Xnrg[b] = silk_ADD_POS_SAT32(Xnrg[b], sumSquared); 
  304.             } 
  305.             else { 
  306.                 /* Look-ahead subframe */ 
  307.                 Xnrg[b] = silk_ADD_POS_SAT32(Xnrg[b], silk_RSHIFT(sumSquared, 1)); 
  308.             } 
  309.   
  310.             dec_subframe_offset += dec_subframe_length; 
  311.         } 
  312.         psSilk_VAD->XnrgSubfr[b] = sumSquared; 
  313.     } 
  314.   
  315.     /********************/ 
  316.     /* Noise estimation */ 
  317.     /********************/ 
  318.     silk_VAD_GetNoiseLevels(&Xnrg[0], psSilk_VAD); 
  319.   
  320.     /***********************************************/ 
  321.     /* Signal-plus-noise to noise ratio estimation */ 
  322.     /***********************************************/ 
  323.     sumSquared = 0
  324.     input_tilt = 0
  325.     for (b = 0; b < 4; b++) { 
  326.         speech_nrg = Xnrg[b] - psSilk_VAD->NL[b]; 
  327.         if (speech_nrg > 0) { 
  328.             /* Divide, with sufficient resolution */ 
  329.             if ((Xnrg[b] & 0xFF800000) == 0) { 
  330.                 NrgToNoiseRatio_Q8[b] = silk_DIV32(silk_LSHIFT(Xnrg[b], 8), psSilk_VAD->NL[b] + 1); 
  331.             } 
  332.             else { 
  333.                 NrgToNoiseRatio_Q8[b] = silk_DIV32(Xnrg[b], silk_RSHIFT(psSilk_VAD->NL[b], 8) + 1); 
  334.             } 
  335.   
  336.             /* Convert to log domain */ 
  337.             SNR_Q7 = silk_lin2log(NrgToNoiseRatio_Q8[b]) - 8 * 128; 
  338.   
  339.             /* Sum-of-squares */ 
  340.             sumSquared = silk_SMLABB(sumSquared, SNR_Q7, SNR_Q7);          /* Q14 */ 
  341.   
  342.                                                                            /* Tilt measure */ 
  343.             if (speech_nrg < ((int)1 << 20)) { 
  344.                 /* Scale down SNR value for small subband speech energies */ 
  345.                 SNR_Q7 = silk_SMULWB(silk_LSHIFT(silk_SQRT_APPROX(speech_nrg), 6), SNR_Q7); 
  346.             } 
  347.             input_tilt = silk_SMLAWB(input_tilt, tiltWeights[b], SNR_Q7); 
  348.         } 
  349.         else { 
  350.             NrgToNoiseRatio_Q8[b] = 256; 
  351.         } 
  352.     } 
  353.   
  354.     /* Mean-of-squares */ 
  355.     sumSquared = silk_DIV32_16(sumSquared, 4); /* Q14 */ 
  356.   
  357.   /* Root-mean-square approximation, scale to dBs, and write to output pointer */ 
  358.     pSNR_dB_Q7 = (short)(3 * silk_SQRT_APPROX(sumSquared)); /* Q7 */ 
  359.   
  360. /*********************************/ 
  361. /* Speech Probability Estimation */ 
  362. /*********************************/ 
  363.     SA_Q15 = silk_sigm_Q15(silk_SMULWB(VAD_SNR_FACTOR_Q16, pSNR_dB_Q7) - VAD_NEGATIVE_OFFSET_Q5); 
  364.   
  365.     /**************************/ 
  366.     /* Frequency Tilt Measure */ 
  367.     /**************************/ 
  368.     int input_tilt_Q15 = silk_LSHIFT(silk_sigm_Q15(input_tilt) - 16384, 1); 
  369.   
  370.     /**************************************************/ 
  371.     /* Scale the sigmoid output based on power levels */ 
  372.     /**************************************************/ 
  373.     speech_nrg = 0
  374.     for (b = 0; b < 4; b++) { 
  375.         /* Accumulate signal-without-noise energies, higher frequency bands have more weight */ 
  376.         speech_nrg += (b + 1) * silk_RSHIFT(Xnrg[b] - psSilk_VAD->NL[b], 4); 
  377.     } 
  378.   
  379.     /* Power scaling */ 
  380.     if (speech_nrg <= 0) { 
  381.         SA_Q15 = silk_RSHIFT(SA_Q15, 1); 
  382.     } 
  383.     else if (speech_nrg < 32768) { 
  384.         if (frame_length == 10 * fs_kHz) { 
  385.             speech_nrg = silk_LSHIFT_SAT32(speech_nrg, 16); 
  386.         } 
  387.         else { 
  388.             speech_nrg = silk_LSHIFT_SAT32(speech_nrg, 15); 
  389.         } 
  390.   
  391.         /* square-root */ 
  392.         speech_nrg = silk_SQRT_APPROX(speech_nrg); 
  393.         SA_Q15 = silk_SMULWB(32768 + speech_nrg, SA_Q15); 
  394.     } 
  395.   
  396.     /* Copy the resulting speech activity in Q8 */ 
  397.     int speech_activity_Q8 = silk_min_int(silk_RSHIFT(SA_Q15, 7), silk_uint8_MAX); 
  398.   
  399.     /***********************************/ 
  400.     /* Energy Level and SNR estimation */ 
  401.     /***********************************/ 
  402.     /* Smoothing coefficient */ 
  403.     smooth_coef_Q16 = silk_SMULWB(VAD_SNR_SMOOTH_COEF_Q18, silk_SMULWB((int)SA_Q15, SA_Q15)); 
  404.   
  405.     if (frame_length == 10 * fs_kHz) { 
  406.         smooth_coef_Q16 >>= 1; 
  407.     } 
  408.   
  409.     for (b = 0; b < 4; b++) { 
  410.         /* compute smoothed energy-to-noise ratio per band */ 
  411.         psSilk_VAD->NrgRatioSmth_Q8[b] = silk_SMLAWB(psSilk_VAD->NrgRatioSmth_Q8[b], 
  412.             NrgToNoiseRatio_Q8[b] - psSilk_VAD->NrgRatioSmth_Q8[b], smooth_coef_Q16); 
  413.   
  414.         /* signal to noise ratio in dB per band */ 
  415.         SNR_Q7 = 3 * (silk_lin2log(psSilk_VAD->NrgRatioSmth_Q8[b]) - 8 * 128); 
  416.         /* quality = sigmoid( 0.25 * ( SNR_dB - 16 ) ); */ 
  417.         input_quality_bands_Q15[b] = silk_sigm_Q15(silk_RSHIFT(SNR_Q7 - 16 * 128, 4)); 
  418.     } 
  419.     //gap************************************************************// 
  420.     if (speech_activity_Q8 < SILK_FIX_CONST(SPEECH_ACTIVITY_DTX_THRES, 8)) { 
  421.         signalType = TYPE_NO_VOICE_ACTIVITY
  422.         //noSpeechCounter++; 
  423.         VAD_flag = 0
  424.     } 
  425.     else { 
  426.         signalType = TYPE_UNVOICED
  427.         VAD_flag = 1
  428.     } 
  429.     free(psSilk_VAD); 
  430.     return(VAD_flag); 

 

(weixin_34059951)
本站文章除注明转载外,均为本站原创或编译欢迎任何形式的转载,但请务必注明出处,尊重他人劳动,同学习共成长。转载请注明:文章转载自:罗索实验室 [http://www.rosoo.net/a/202008/17724.html]
本文出处:CSDN博客 作者:weixin_34059951 原文
顶一下
(0)
0%
踩一下
(0)
0%
------分隔线----------------------------
相关文章
发表评论
请自觉遵守互联网相关的政策法规,严禁发布色情、暴力、反动的言论。
评价:
表情:
用户名: 验证码:点击我更换图片
栏目列表
将本文分享到微信
织梦二维码生成器
推荐内容