1.Speex音频降噪模块

相关文章链接：开源库Speex编解码，speex开源库分析（前置处理）
Speex是很强大的编解码库，也包含一些降噪，自动增益，回音消除等模块功能，Speex是开源的，Opus是Speex的更优替代方案，但是Opus没有降噪去噪模块，就具体我所在公司，我们公司使用的是Speex编码，没有使用更新的Opus，经过实际实验，Speex的去噪效果有限，话不多说，上过程：
部分代码：

#define USE_SPEEX_DENOISE 0

class CHHAudioEncoderG711ADenoise:public IHHAudioEncoder
{
public:
    CHHAudioEncoderG711ADenoise(int samplerate,int bitsize):m_RetainCount(1)
    {
        m_encoder = new CHHAudioEncoderG711A;
#if USE_SPEEX_DENOISE
        //帧长度，以20ms为例，帧长度=20*采样率/1000=(20ms内的采样点数量)
        int framesize = 20*samplerate/1000;
        m_context = speex_preprocess_state_init(framesize, samplerate);
        int i=1;//1表示开启，0表示关闭
        //SPEEX_PREPROCESS_SET_DENOISE表示降噪
        speex_preprocess_ctl(m_context, SPEEX_PREPROCESS_SET_DENOISE, &i);//降噪
        int noiseSuppress = -25;//噪音分贝数，是一个负值
        //Speex的降噪是通过简单的设置音频数据的阀值，过滤掉低分贝的声音来实现的
        //优点是简单，使用Speex编解码库时可以直接使用
        //缺点是会把声音细节抹掉
        speex_preprocess_ctl(m_context, SPEEX_PREPROCESS_SET_NOISE_SUPPRESS, &noiseSuppress); 
#endif
    }
    virtual ~CHHAudioEncoderG711ADenoise(void)
    {
        if (m_encoder){
            m_encoder->Release();
            m_encoder = NULL;
        }
#if USE_SPEEX_DENOISE
        if (m_context){
            speex_preprocess_state_destroy(m_context);
            m_context = NULL;
        }
#endif
    }
protected:
    virtual void Retain()
    {
        ++m_RetainCount;
    }
    virtual void Release()
    {
        if (--m_RetainCount==0) {
            delete this;
        }
    }
    virtual bool Encode(unsigned char *pInData,int nInLen,onAudioEncodeResultCallback func,void* param)
    {
        //去噪声
#if USE_SPEEX_DENOISE
                //pInData是采集到的音频数据，因为上层的原因，采集到的缓存长度是320个字节
        speex_preprocess_run(m_context, (short*)pInData);
#endif
        //编码
        m_encoder->Encode(pInData,nInLen,func,param);
        return true ;
    }
private:
    unsigned long m_RetainCount;
    IHHAudioEncoder* m_encoder;
#if USE_SPEEX_DENOISE
    SpeexPreprocessState* m_context;//Speex预处理器指针
#endif
};

使用过程很简单，依次顺序为：

1.创建Speex预处理器指针：speex_preprocess_state_init

支持的采样率有3种：8K，16K，44K，采样送进去降噪的数据需要控制在20ms，也就是（20采样率/1000）*个采样点。

2.设置预处理器的参数：speex_preprocess_ctl

包括SPEEX_PREPROCESS_SET_DENOISE和SPEEX_PREPROCESS_SET_NOISE_SUPPRESS

3.处理一帧音频数据：speex_preprocess_run

第二个参数是音频数据指针，处理完成后也会保存在这个指针，另外注意指针类型应该为short*

4.销毁预处理器：speex_preprocess_state_destroy

效果：（使用Audacity分析）
语音内容：“Speex降噪效果对比”

Speex降噪效果对比：时域（降噪前为上面那个，降噪后为下面那个）

降噪前频域分析

 

降噪后频域分析

从图片上看，不管是时域还是频域，效果都不明显，实际听的效果的话，降噪后，背景的沙沙声有所减弱，但是总体效果还是不佳。

 

2.WebRTC音频降噪模块

相关的文章推荐：单独编译使用WebRTC的音频处理模块 - android
WebRTC源码链接：https://chromium.googlesource.com/external/webrtc/+/master
说句题外话，不得不佩服谷歌，只要是个做开发的，这辈子估计都离不开谷歌了，对于咱们这种小喽啰来说，只要记住“谷歌出品，必属精品”就好了，当然，这里用到的WebRTC也是谷歌的，感兴趣的可以自己去找相关的信息。
WebRTC是最近几年比较火的技术，原谅我原先都不知道~~~，WebRTC提供了视频会议的核心技术，包括音视频的采集、编解码、网络传输、显示等功能，并且还支持跨平台：Windows，Linux，Mac，Android（这句来自百度……）。
我们这里使用的就是WebRTC的音频处理模块——audio_processing，源代码在webrtc\modules\audio_processing目录下。

温馨提示：部分谷歌链接需要翻墙打开

部分代码：

#define USE_WEBRTC_NOISESUPPRESSION 1

#if USE_WEBRTC_NOISESUPPRESSION
#include "../WebRtcModule/signal_processing_library.h"
#include "../WebRtcModule/noise_suppression_x.h"
#include "../WebRtcModule/noise_suppression.h"
#include "../WebRtcModule/gain_control.h"
#endif

class CHHAudioEncoderG711ADenoise:public IHHAudioEncoder
{
public:
    CHHAudioEncoderG711ADenoise(int samplerate,int bitsize):m_RetainCount(1)
    {
        m_encoder = new CHHAudioEncoderG711A;
#if USE_WEBRTC_NOISESUPPRESSION
        m_pNSinst = NULL;
        //创建降噪处理句柄
        if (0 != WebRtcNsx_Create(&m_pNSinst))
        {
            WRITELOG(LL_Debug,"Noise_Suppression WebRtcNs_Create err!\n");
            return;
        }

        //WebRTC只支持三种采样率，8K，16K和32K，如果超过32K，则需要重采样成符合要求的采样率，这边不做处理
        if (samplerate != 8000 && samplerate != 16000 && samplerate != 32000){
            WRITELOG(LL_Debug,"Noise_Suppression samplerate err! \n");
            return;
        }
        m_samplerate = samplerate;
        //根据采样率初始化降噪处理句柄
        if (0 !=  WebRtcNsx_Init(m_pNSinst,samplerate))
        {
            WRITELOG(LL_Debug,"Noise_Suppression WebRtcNs_Init err! \n");
            return;
        }
        int nMode = 3;
        //设置降噪处理策略，nMode值只能取四个值：0，1，2，3，越高效果越好
        if (0 !=  WebRtcNsx_set_policy(m_pNSinst,nMode))
        {
            WRITELOG(LL_Debug,"Noise_Suppression WebRtcNs_set_policy err! \n");
            return;
        }
        memset(filter_state1,0,sizeof(filter_state1));
        memset(filter_state12,0,sizeof(filter_state12));
        memset(Synthesis_state1,0,sizeof(Synthesis_state1));
        memset(Synthesis_state12,0,sizeof(Synthesis_state12));
#endif
    }
    virtual ~CHHAudioEncoderG711ADenoise(void)
    {
        if (m_encoder){
            m_encoder->Release();
            m_encoder = NULL;
        }
#if USE_WEBRTC_NOISESUPPRESSION
        if (m_pNSinst){
            WebRtcNsx_Free(m_pNSinst);
            m_pNSinst = NULL;
        }
#endif
    }
protected:
    virtual void Retain()
    {
        ++m_RetainCount;
    }
    virtual void Release()
    {
        if (--m_RetainCount==0) {
            delete this;
        }
    }
    virtual bool Encode(unsigned char *pInData,int nInLen,onAudioEncodeResultCallback func,void* param)
    {
        //去噪声
#if USE_WEBRTC_NOISESUPPRESSION
        //每次取一帧10ms数据的采样点进行循环降噪
        //如果是8K采样率的，则对应8000/1000*10=80个采样点
        //16K采样率对应16000/1000*10=160个采样点
        //32K采样率对应的是320个采样点
        for (int i = 0; i < nInLen; i += sizeof(short)*m_samplerate/100){
            //这里没有明确写出，但是实际上在项目中做了限制，每次传进来的长度是320个字节
            //也就是说采样率为8K16位的话，会循环两次，16K16位的话，只会循环一次，32K8位的话也只会循环一次，具体需要根据采样率和位宽计算
            if (m_samplerate == 8000){
                if (nInLen - i >= 160){
                    short shBufferIn[80] = {0};
                    short shBufferOut[80] = {0};
                    memcpy(shBufferIn,(char*)(pInData+i),80*sizeof(short));
                    //将需要降噪的数据作为低频数据传入对应接口，高频数据为空，同时需要注意返回数据也是分高频和低频，此处低频数据为降噪结果
                    if (0 != WebRtcNsx_Process(m_pNSinst ,shBufferIn  ,NULL ,shBufferOut , NULL)){
                        WRITELOG(LL_Debug,"Noise_Suppression WebRtcNs_Process err! \n");
                    }
                    memcpy(pInData+i,shBufferOut,80*sizeof(short));
                }
            }else if (m_samplerate == 16000){
                if (nInLen - i >= 320){
                    short shBufferIn[160] = {0};
                    short shBufferOut[160] = {0};
                    memcpy(shBufferIn,(char*)(pInData+i),160*sizeof(short));
                    if (0 != WebRtcNsx_Process(m_pNSinst ,shBufferIn  ,NULL ,shBufferOut , NULL)){
                        WRITELOG(LL_Debug,"Noise_Suppression WebRtcNs_Process err! \n");
                    }
                    memcpy(pInData+i,shBufferOut,160*sizeof(short));
                }
            }
            //因为项目的特殊性，每次传进来的数据长度，长度只有320个字节，如果是采样率是32K的话，进来的帧长度只有5ms，并不能满足降噪处理的最低要求，为避免数据异常，不处理32K数据
            //根据前辈的说法，32K数据需要分为高频和低频两个部分进行降噪，降噪后再合并为降噪后数据
            //else if (m_samplerate == 32000){
            //  if (nInLen - i >= 640)
            //  {
            //      short shBufferIn[320] = {0};

            //      short shInL[160],shInH[160];
            //      short shOutL[160] = {0},shOutH[160] = {0};

            //      memcpy(shBufferIn,(char*)(pInData+i),320*sizeof(short));
            //      //首先需要使用滤波函数将音频数据分高低频，以高频和低频的方式传入降噪函数内部
            //      WebRtcSpl_AnalysisQMF(shBufferIn,320,shInL,shInH,filter_state1,filter_state12);

            //      //将需要降噪的数据以高频和低频传入对应接口，同时需要注意返回数据也是分高频和低频
            //      if (0 == WebRtcNsx_Process(m_pNSinst ,shInL  ,shInH ,shOutL , shOutH))
            //      {
            //          short shBufferOut[320];
            //          //如果降噪成功，则根据降噪后高频和低频数据传入滤波接口，然后用将返回的数据写入文件
            //          WebRtcSpl_SynthesisQMF(shOutL,shOutH,160,shBufferOut,Synthesis_state1,Synthesis_state12);
            //          memcpy(pInData+i,shBufferOut,320*sizeof(short));
            //      }
            //  }
            //}
        }
#endif
        //编码
        m_encoder->Encode(pInData,nInLen,func,param);
        return true ;
    }
private:
    unsigned long m_RetainCount;
    IHHAudioEncoder* m_encoder;
#if USE_WEBRTC_NOISESUPPRESSION
    NsxHandle* m_pNSinst;
    int  filter_state1[6],filter_state12[6];//滤波分频需要用到的参数
    int  Synthesis_state1[6],Synthesis_state12[6];//合并高低频数据需要用到的参数
    int m_samplerate;//采样率
#endif
};

使用过程如下：

1.创建WebRTC降噪处理句柄：WebRtcNsx_Create

2.初始化WebRTC降噪处理句柄：WebRtcNsx_Init

参数是WebRTC降噪句柄和采样率，WebRTC只支持三种采样率，8K，16K和32K，如果超过32K，则需要重采样成符合要求的采样率，这边不考虑采样率超出32K需要重采样的情况。

3.设置WebRTC降噪处理策略：WebRtcNsx_set_policy

nMode是策略的选项，但是数值越高，效果越好，估计对性能有影响，不建议在CPU性能不佳的环境使用。只能取4个值：0，1，2，3。

4.降噪处理，按帧循环处理音频数据直到数据处理完毕

要求每次取一帧长度为10ms的数据进行降噪处理，如果采样率是8K，则对应8000/1000*10=80个采样点，16K是160个采样点，32K是320个采样点。具体到我的程序中，因为每次传进入的音频数据是8K16位的，而且缓存长度固定是320个字节，计算一下，一次送进去160个字节数据降噪，所以可以预知，循环两次。

根据前辈的说法，32K数据需要分为高频和低频两个部分进行降噪，降噪后再合并为降噪后数据

• 1.（可选）使用滤波函数将音频数据分为高频，低频：WebRtcSpl_AnalysisQMF
  将需要降噪的数据作为低频数据传入对应接口，高频数据为空，同时需要注意返回数据也是分高频和低频，此处低频数据为降噪结果。但是，如果是8K和16K数据，不需要这个步骤，可以作为低频数据直接降噪，所以这个是可选步骤。
• 2.降噪处理：WebRtcNsx_Process
  将需要降噪的数据以高频和低频传入对应接口，同时需要注意返回数据也是分高频和低频。如果是8K或者16K的数据，则作为低频数据输入，输出也是通过低频数据返回。
• 3.（可选）降噪成功后，将高频，低频数据合并后输出：WebRtcSpl_SynthesisQMF
  如果降噪成功，则根据降噪后高频和低频数据传入滤波接口，然后用将返回的数据写入文件。这一步是可选的，根据上面是否分成高低频来使用。

5.释放WebRTC降噪句柄：WebRtcNsx_Free

效果：（使用Audacity分析）
语音内容：“WebRTC降噪效果对比”

WebRTC降噪效果对比：时域（降噪前为上面那个，降噪后为下面那个）

 

降噪前频域分析

 

降噪后频域分析

 

从图片上看，时域上音量较低的数据基本被抹平，但是不影响波形清晰，频域上，频率峰值明显加强，1500Hz到3500Hz区域，能量普遍下降，实际听的效果的话，降噪后，背景的沙沙声基本没有，但是音量也有所下降，直观感觉上，比Speex好一些。

3.根据PCM文件的音量进行阀值限制

以二进制方式打开，PCM数据其实就是音量数据，如果把音量小的声音默认为噪声，则可以通过把音量小的数值替换为0，来实现降噪，这就是第三个方法的原理，但是这个方法的缺点也是明显的，会把很多的比较小的细节声音直接去掉了。
部分代码：

class CHHAudioEncoderG711ADenoise:public IHHAudioEncoder
{
public:
    CHHAudioEncoderG711ADenoise(int samplerate,int bitsize):m_RetainCount(1)
    {
        m_encoder = new CHHAudioEncoderG711A;
    }
    virtual ~CHHAudioEncoderG711ADenoise(void)
    {
        if (m_encoder){
            m_encoder->Release();
            m_encoder = NULL;
        }
    }
protected:
    virtual void Retain()
    {
        ++m_RetainCount;
    }
    virtual void Release()
    {
        if (--m_RetainCount==0) {
            delete this;
        }
    }
    virtual bool Encode(unsigned char *pInData,int nInLen,onAudioEncodeResultCallback func,void* param)
    {
        //去噪声
        static const short NOISE_SIZE =256;
        short* pdata = (short*)pInData;
        for (int i=0;i<nInLen/2;i++)
        {
            if (pdata[i]<NOISE_SIZE && pdata[i]>-NOISE_SIZE) {
                pdata[i]=0;
            }else if(pdata[i]>NOISE_SIZE){
                pdata[i]=pdata[i]-NOISE_SIZE;
            }
            else if (pdata[i]<-NOISE_SIZE){
                pdata[i]=pdata[i]+NOISE_SIZE;
            }
        }
        //编码
        m_encoder->Encode(pInData,nInLen,func,param);
        return true ;
    }
private:
    unsigned long m_RetainCount;
    IHHAudioEncoder* m_encoder;
};

过程：

1.设置噪声阀值

这个数值是用来和PCM数据中的数值进行比较的，这里会使用到音量计算公式dB = 20×log(data)，data就是这里的噪声阀值，如果设25dB为界点，则data 约等于18，如果设置为48

2.替换噪声

简单判断大小后就替换
从实际效果上看，和Speex差不多，噪音有所减弱，但是会变为另一种方式的噪音，实际上只是把一部分数据给抹平而已，简单粗暴。