DSP公司内部使用的.rar_ vad dsp_DSP 逆变_vad_语音vad_语音压缩

/* * vad.cpp * * This is a simple vad implementation. It isn't tuned and testing * has been somewhat limited... but it seems to work ok. All numbers * that are db are multiplied by 100 to keep them slightly more * accurate and easy to use. (so -7450 is -74.50db) This code use * three functions not provided as part of this file : log10_32, bqInit * and bqProcess. The log function calculates : * 100 * 10 * log(x) - 9333 * which sould be an approximation of the signal energy x 100. * bqInit initializes a biquad data structure and bqProcess applies a * a biquad to a signal buffer. A biquad is used by the vad to filter * out lower frequency background noise. * * This code operates under the assumption that it will get frames with * lengths which are a multiple of 5ms. This is relatively easy to * change since the only real dependency is the hangover count -- its in * frames now but could easily be changed to samples. * */ #define VAD_CPP #include "c_utils.h" #include "c_vad.h" #define LOCAL static #define DATA_FRAME_LENGTH (5*8) /* * x = 1.5sec * 1000ms/sec * 8 samples/1 ms * samples => +1dB every x samples */ #define VAD_NOISEFLOOR_CNT_INIT (int)(8*1500) #define VAD_SIGNALMAX_CNT_INIT (int)(8*1500) /* Power Thresholds */ #define VAD_NOISE_TH_BASE (float) 10.00 /* 10.00 dB Noise Threshold */ #define VAD_NOISE_FLOOR_INIT (float)-74.00 /* -74.00 dB Initial Noise Floor */ #define VAD_SIGNAL_MAX_INIT (float)-80.00 /* -80.00 dB Initial Noise Max */ #define VAD_NOISE_TH_MIN (float) 1.00 /* 1.00 dB Minimum Noise Threshold */ /* High Pass Filter for getting rid of background noise from * input signal before energy calculations */ /* Butter : */ #define vhpfB0 (S2byte) 14339 #define vhpfB1 (S2byte)-28678 #define vhpfB2 (S2byte) 14339 #define vhpfA1 (S2byte)-28422 #define vhpfA2 (S2byte) 12550 /* Number of samples of silence before we declare silence period */ /* #samples = 8 samples/ms * 500ms */ #define VAD_HANGOVER_CNT_INIT (int)(8*500) typedef enum { VadState_Silence = 0, VadState_Speech, VadState_Unknown } t_VadState; typedef struct _vad { boolean enabled; /* Saved STA between input frames */ U4byte sta; /* state == 1 if VOICE * state == 0 if SILENCE */ t_VadState state; /* Countdown of consecutive frames before we declare silence */ int hangoverCnt; /* Threshold above which a signal is considered to be speech */ float noiseTH; /* Countdown after which the noise floor is * incremented by 1dB */ int noiseFloorCnt; /* Noise floor in dB */ float noiseFloor; /* Countdown after which the signal max is * decremented by 1dB */ int signalMaxCnt; /* Signal max in dB */ float signalMax; /* STARise == 1 if sta is rising * STARise == 0 if sta is falling */ int STARise; int stateTxCount; /* High Pass Filter for input signal */ t_biquad *bq; } t_vad; /* LOCAL */ LOCAL t_biquad vadbq; LOCAL t_vad vadd; void vadInit() { vadd.enabled = TRUE; vadd.bq = &vadbq; vadd.sta = 10000; vadd.noiseTH = VAD_NOISE_TH_BASE; vadd.state = VadState_Unknown; vadd.noiseFloorCnt = VAD_NOISEFLOOR_CNT_INIT; vadd.noiseFloor = VAD_NOISE_FLOOR_INIT; vadd.hangoverCnt = VAD_HANGOVER_CNT_INIT; vadd.STARise = 1; vadd.stateTxCount = 0; vadd.signalMax = VAD_SIGNAL_MAX_INIT; vadd.signalMaxCnt = VAD_SIGNALMAX_CNT_INIT; bqInit(vadd.bq, vhpfB0, vhpfB1, vhpfB2, vhpfA1, vhpfA2); } LOCAL U4byte computeSTA(S2byte *pdata, int length, U4byte *minSta) { int i; S4byte acc0,acc1; U4byte maxSta; *minSta = vadd.sta; maxSta = vadd.sta; for (i = 0; i < length; i++) { /* q.15 * q.15 = q.30 */ acc1 = pdata[i] * pdata[i]; if ( vadd.STARise ) { acc0 = -1 * (S4byte)(vadd.sta >> 6); acc1 = acc1 >> 5; } else { acc0 = -1 * (S4byte)(vadd.sta >> 9); acc1 = acc1 >> 8; } /* if */ acc0 += acc1; vadd.STARise = ( 0 >= acc0 ) ? 0 : 1; vadd.sta += acc0; if ( vadd.sta > maxSta ) { maxSta = vadd.sta; // arijit - i added the cast } else if ( vadd.sta < *minSta ) { *minSta = vadd.sta; } } /* for */ return maxSta; } LOCAL void computeNFE(float minpower, float maxpower, int length) { if ( minpower <= vadd.noiseFloor ) { vadd.noiseFloor = minpower; vadd.noiseFloorCnt = VAD_NOISEFLOOR_CNT_INIT; } else { if ( vadd.noiseFloorCnt < length ) { vadd.noiseFloor += 1; vadd.noiseFloorCnt = (VAD_NOISEFLOOR_CNT_INIT + vadd.noiseFloorCnt - length); } else { vadd.noiseFloorCnt -= length; } } } unsigned long stopCount = 32000; LOCAL boolean vadSubProcess(S2byte *data, int length) { boolean SpeechDetected; boolean FrameSpeechFlag; S2byte tmpData[DATA_FRAME_LENGTH]; U4byte sta[2]; float power[2]; static unsigned long count = 0; SpeechDetected = TRUE; FrameSpeechFlag = FALSE; bqProcess(vadd.bq, data, tmpData, length); sta[1] = computeSTA(tmpData, length, &sta[0]); calcPower(2, sta, power); computeNFE(power[0], power[1], length); count += length; if (count >= stopCount) { count = 0; } if (power[1] > (vadd.noiseFloor + vadd.noiseTH)) { FrameSpeechFlag = TRUE; } if ( FrameSpeechFlag == FALSE) { if ( vadd.hangoverCnt < length ) { SpeechDetected = FALSE; vadd.hangoverCnt = 0; if ( vadd.state != VadState_Silence ) { vadd.stateTxCount++; } vadd.state = VadState_Silence; } else { vadd.hangoverCnt -= length; } } else { vadd.hangoverCnt = VAD_HANGOVER_CNT_INIT; if ( vadd.state == VadState_Silence ) { vadd.stateTxCount++; } vadd.state = VadState_Speech; } return SpeechDetected; } /* * Returns: true for speech * false for silence */ boolean vadProcess(S2byte *data, int length) { /* vadProcess locals */ int idx; int step; boolean ret; ret = FALSE; if ( vadd.enabled == TRUE ) { /* Cut up the frame into 5ms chunks for processing purposes */ for (idx = 0; length > 0; length -= step) { step = (length < DATA_FRAME_LENGTH) ? length : DATA_FRAME_LENGTH; ret |= vadSubProcess(&data[idx], step); idx += step; } } else { ret = TRUE; } return ret; }