android音频降噪webrtc

http://www.itwendao.com/article/detail/81229.html
转自
android音频降噪webrtc
移动开发 来源:hesong1120 2016-11-20 22:27 8℃ 0评论
在音频处理的开源项目中，webrtc是一个很不错的例子。它包含降噪，去回声，增益，均衡等音频处理。这里我讲讲我所使用到的如何使用降噪方式。当然，具体它是如何降噪的，大家可以细看源码处理了。好了，线上源码。

以下是java 层MainActivity.java：

package com.test.jni;

import android.media.AudioFormat;
import android.media.AudioManager;
import android.media.AudioRecord;
import android.media.AudioTrack;
import android.media.MediaRecorder;
import android.os.Bundle;
import android.os.Environment;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.widget.CheckBox;
import android.widget.CompoundButton;
import android.widget.SeekBar;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class MainActivity extends AppCompatActivity implements View.OnClickListener{

SeekBar skbVolume;//调节音量
boolean isProcessing = true;//是否录放的标记
boolean isRecording = false;//是否录放的标记

static final int frequency = 8000;
static final int channelConfiguration = AudioFormat.CHANNEL_CONFIGURATION_MONO;
static final int audioEncoding = AudioFormat.ENCODING_PCM_16BIT;
int recBufSize, playBufSize;
AudioRecord audioRecord;
AudioTrack audioTrack;

private String outFilePath;
private OutputStream mOutputStream;
private static final int FLAG_RECORD_START = 1;
private static final int FLAG_RECORDING = 2;
private static final int FLAG_RECORD_FINISH = 3;

private WebrtcProcessor mProcessor;

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    //获得合适的录音缓存大小
    recBufSize = AudioRecord.getMinBufferSize(frequency, channelConfiguration, audioEncoding);
    Log.e("", "recBufSize:" + recBufSize);
    //获得合适的播放缓存大小
    playBufSize = AudioTrack.getMinBufferSize(frequency, channelConfiguration, audioEncoding);

    //创建录音和播放实例
    audioRecord = new AudioRecord(MediaRecorder.AudioSource.MIC, frequency, channelConfiguration, audioEncoding, recBufSize);
    audioTrack = new AudioTrack(AudioManager.STREAM_MUSIC, frequency, channelConfiguration, audioEncoding, playBufSize, AudioTrack.MODE_STREAM);

    findViewById(R.id.btnRecord).setOnClickListener(this);
    findViewById(R.id.btnStop).setOnClickListener(this);

    skbVolume = (SeekBar) this.findViewById(R.id.skbVolume);
    skbVolume.setMax(100);//音量调节的极限
    skbVolume.setProgress(50);//设置seekbar的位置值
    audioTrack.setStereoVolume(0.7f, 0.7f);//设置当前音量大小
    skbVolume.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {

        @Override
        public void onStopTrackingTouch(SeekBar seekBar) {
            float vol = (float) (seekBar.getProgress()) / (float) (seekBar.getMax());
            audioTrack.setStereoVolume(vol, vol);//设置音量
        }

        @Override
        public void onStartTrackingTouch(SeekBar seekBar) {
        }

        @Override
        public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
        }
    });
    ((CheckBox) findViewById(R.id.cb_ap)).setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {

        @Override
        public void onCheckedChanged(CompoundButton view, boolean checked) {
            isProcessing = checked;
        }
    });

    initProccesor();
}

@Override
protected void onDestroy() {

    releaseProcessor();

    android.os.Process.killProcess(android.os.Process.myPid());
    super.onDestroy();
}

@Override
public void onClick(View v) {
    if (v.getId() == R.id.btnRecord) {
        isRecording = true;

        //启动线程,开始录音和一边播放

        new RecordPlayThread().start();

    } else if (v.getId() == R.id.btnStop) {
        isRecording = false;
    }
}

class RecordPlayThread extends Thread {
    public void run() {
        try {

            short[] buffer = new short[recBufSize/2];
            audioRecord.startRecording();//开始录制
            audioTrack.play();//开始播放

            saveToFile(FLAG_RECORD_START, null);

            while (isRecording) {
                //setp 1 从MIC保存数据到缓冲区
                int bufferReadResult = audioRecord.read(buffer, 0, recBufSize/2);
                short[] tmpBuf_src = new short[bufferReadResult];
                System.arraycopy(buffer, 0, tmpBuf_src, 0, bufferReadResult);

                //setp 2 进行处理
                if (isProcessing) {

                    processData(tmpBuf_src);

                } else {
                }
                //写入数据即播放
                audioTrack.write(tmpBuf_src, 0, tmpBuf_src.length);

                //saveToFile(FLAG_RECORDING, tmpBuf_src);

            }

            saveToFile(FLAG_RECORD_FINISH, null);

            audioTrack.stop();
            audioRecord.stop();
        } catch (Exception t) {
            t.printStackTrace();
        }
    }
};

class RecordPlayThread2 extends Thread {
    public void run() {
        try {

            byte[] buffer = new byte[recBufSize];
            audioRecord.startRecording();//开始录制
            audioTrack.play();//开始播放

            saveToFile(FLAG_RECORD_START, null);

            while (isRecording) {
                //setp 1 从MIC保存数据到缓冲区
                int bufferReadResult = audioRecord.read(buffer, 0, recBufSize);
                byte[] tmpBuf_src = new byte[bufferReadResult];
                System.arraycopy(buffer, 0, tmpBuf_src, 0, bufferReadResult);

                //setp 2 进行处理
                if (isProcessing) {

                    processData(tmpBuf_src);

                } else {
                }
                //写入数据即播放
                audioTrack.write(tmpBuf_src, 0, tmpBuf_src.length);

                saveToFile(FLAG_RECORDING, tmpBuf_src);

            }

            saveToFile(FLAG_RECORD_FINISH, null);

            audioTrack.stop();
            audioRecord.stop();
        } catch (Exception t) {
            t.printStackTrace();
        }
    }
};

/** * 保存录音数据到本地wav文件 * @param flag * @param data */
private void saveToFile(int flag, byte[] data){

    switch (flag){
        case FLAG_RECORD_START:

            String pcmPath = Environment.getExternalStorageDirectory().getAbsolutePath() + "/record/record.pcm";
            try {
                mOutputStream = new FileOutputStream(pcmPath);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }

            break;
        case FLAG_RECORDING:

            if(mOutputStream != null){
                try {
                    mOutputStream.write(data);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            break;
        case FLAG_RECORD_FINISH:

            try {
                if(mOutputStream != null){
                    mOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

            pcmPath = Environment.getExternalStorageDirectory().getAbsolutePath() + "/record/record.pcm";
            String wavePath = Environment.getExternalStorageDirectory().getAbsolutePath() + "/record/record.wav";

            AudioEncodeUtil.convertPcm2Wav(pcmPath, wavePath);

            break;
    }

}

/** * 初始化降噪 */
private void initProccesor(){
    mProcessor = new WebrtcProcessor();
    mProcessor.init(frequency);
}

/** * 释放降噪资源 */
private void releaseProcessor(){
    if(mProcessor != null){
        mProcessor.release();
    }
}

/** * 处理需要降噪的音频数据 * @param data */
private void processData(byte[] data){
    if(mProcessor != null){
        mProcessor.processNoise(data);
    }
}

/** * 处理需要降噪的音频数据 * @param data */
private void processData(short[] data){
    if(mProcessor != null){
        mProcessor.processNoise(data);
    }
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
以上代码主要是实现一边录音，一边播放录音的声音，类似ktv，在其中对每次获取的录音数据tmpBuf_src交给WebrtcProcessor处理，这里可以读取为byte[]或者short[] 数据，但是交给底层webrtc处理时，都是需要转换为short[] 数据的。然后这边采样率我采用8000，采样编码位16，单声道。

接下来看看WebrtcProcessor.java的处理：

package com.test.jni;

import android.util.Log;

/* 音频降噪处理 */
public class WebrtcProcessor {

static {
    try {
        //加载降噪库
        System.loadLibrary("webrtc");
    } catch (UnsatisfiedLinkError e) {
        Log.e("TAG", "Couldn't load lib: - " + e.getMessage());
    }

}

/** * 处理降噪 * @param data */
public void processNoise(byte[] data){

    if(data == null) return;

    int newDataLength = data.length/2;
    if(data.length % 2 == 1){
        newDataLength += 1;
    }

    //此处是将字节数据转换为short数据
    short[] newData = new short[newDataLength];

    for(int i=0; i<newDataLength; i++){
        byte low = 0;
        byte high = 0;

        if(2*i < data.length){
            low = data[2*i];
        }
        if((2*i+1) < data.length){
            high = data[2*i+1];
        }

        newData[i] = (short) (((high << 8) & 0xff00) | (low & 0x00ff));
    }

    // 交给底层处理
    processNoise(newData);

    //处理完之后, 又将short数据转换为字节数据
    for(int i=0; i<newDataLength; i++){
        if(2*i < data.length){
            data[2*i] = (byte) (newData[i] & 0xff);
        }
        if((2*i+1) < data.length){
            data[2*i+1] = (byte) ((newData[i] >> 8) & 0xff);
        }
    }

}

/** * 初始化降噪设置 * @param sampleRate 采样率 * @return 是否初始化成功 */
public native boolean init(int sampleRate);

/** * 处理降噪 * @param data * @return */
public native boolean processNoise(short[] data);

/** * 释放降噪资源 */
public native void release();

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
此处你可能需要将字节数据转换为short数据，要特别小心，如果不小心转错了，你的音频数据就乱码了，来的后果是，听到的声音基本都是沙沙声，我之前就是在这里踩了坑，底层调试了很久也没解决，后面才意识到可能上层出错了，调试之后发现是这里。正常呢，调试时看short数据时，如果它们的数值不是很大，那应该是没问题的，如果大部分都是4000以上，或者－4000以下的，那很可能是转换的时候出问题了，一般来说数值都是几十，几百的样子。

好了，现在看看底层大概是如何实现的：

include

include “audio_ns.h”

include “noise_suppression.h”

//此处是为了里面的底层方法能被java层识别
extern “C” {

//降噪的实例,句柄
NsHandle* handle = NULL;

//降噪处理
void innerProcess(short in_sample[], short out_sample[], int length){

int curPosition = 0;

//此处以160为单位, 依次调用audio_ns_process处理数据,因为这个方法一次只能处理160个short音频数据
while(curPosition < length){

    audio_ns_process((int) handle, in_sample + curPosition, out_sample + curPosition);

    curPosition += 160;

}

}

JNIEXPORT jboolean JNICALL
Java_com_test_jni_WebrtcProcessor_init(JNIEnv *env, jobject instance, jint sample_rate) {

//初始化降噪实例
handle = (NsHandle *) audio_ns_init(sample_rate);

return false;

}

JNIEXPORT jboolean JNICALL
Java_com_test_jni_WebrtcProcessor_processNoise(JNIEnv *env, jobject instance, jshortArray sample) {

if(!handle)
    return false;

//获取数据长度
jsize length = env->GetArrayLength(sample);

//转换为jshort数组
jshort *sam = env->GetShortArrayElements(sample, 0);

//将sam的数据全部复制给新的in_sample
short in_sample[length];
for(int i=0; i<length; i++){
    in_sample[i] = sam[i];
}

//传入in_sample作为需要处理音频数据, 处理之后的数据返回到sam中
innerProcess(in_sample, sam, length);

//将sam中的数据,再转换回sample中
env->ReleaseShortArrayElements(sample, sam, 0);

return true;

}

JNIEXPORT void JNICALL
Java_com_test_jni_WebrtcProcessor_release(JNIEnv *env, jobject instance) {

// 释放降噪资源
if(handle){
    audio_ns_destroy((int) handle);
}

}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
上面代码描述的比较清晰了，就是实际上webrtc降噪一次性只处理了80个short数据,在8000采样率中是这样的，意思就是说webrtc每次只能处理10毫秒，0.01秒的数据。那么依次类推，针对44100采样率的数据处理的话，每次能处理的数据长度就应该是441个short数据了，有不同采样率需求的朋友，可以自行修改测试。接下来看看webrtc的降噪是如何初始化和处理的：

include “audio_ns.h”

include “noise_suppression.h”

include