int main()
{
short in[NN];
int i;
SpeexPreprocessState *st;
int count=0;
float f;
st = speex_preprocess_state_init(NN, 8000);
i=1;
speex_preprocess_ctl(st, SPEEX_PREPROCESS_SET_DENOISE, &i);
i=0;
speex_preprocess_ctl(st, SPEEX_PREPROCESS_SET_AGC, &i);
f=8000;
speex_preprocess_ctl(st, SPEEX_PREPROCESS_SET_AGC_LEVEL, &f);
i=0;
speex_preprocess_ctl(st, SPEEX_PREPROCESS_SET_DEREVERB, &i);
f=.4;
speex_preprocess_ctl(st, SPEEX_PREPROCESS_SET_DEREVERB_DECAY, &f);
f=.3;
speex_preprocess_ctl(st, SPEEX_PREPROCESS_SET_DEREVERB_LEVEL, &f);
while (1)
{
int vad;
fread(in, sizeof(short), NN, stdin);
if (feof(stdin))
break;
vad = speex_preprocess(st, in, NULL);
/*fprintf (stderr, "%d\n", vad);*/
fwrite(in, sizeof(short), NN, stdout);
count++;
}
speex_preprocess_state_destroy(st);
return 0;
}
void CSpeexEC::Init(int frame_size, int filter_length, int sampling_rate)
{
Reset();
if (frame_size<=0 || filter_length<=0 || sampling_rate<=0)
{
m_nFrameSize =160;
m_nFilterLen = 160*8;
m_nSampleRate = 8000;
}
else
{
m_nFrameSize =frame_size;
m_nFilterLen = filter_length;
m_nSampleRate = sampling_rate;
}
m_pState = speex_echo_state_init(m_nFrameSize, m_nFilterLen);
m_pPreprocessorState = speex_preprocess_state_init(m_nFrameSize, m_nSampleRate);
m_pfNoise = new int[m_nFrameSize+1];
m_bHasInit = true;
speex_echo_ctl(m_pState, SPEEX_ECHO_SET_SAMPLING_RATE, &m_nSampleRate);
speex_preprocess_ctl(m_pPreprocessorState, SPEEX_PREPROCESS_SET_ECHO_STATE, m_pState);
}
int main(int argc, char **argv)
{
int echo_fd, ref_fd, e_fd;
spx_int32_t noise[NN+1];
short echo_buf[NN], ref_buf[NN], e_buf[NN];
SpeexEchoState *st;
SpeexPreprocessState *den;
if (argc != 4)
{
fprintf (stderr, "testecho mic_signal.sw speaker_signal.sw output.sw\n");
exit(1);
}
echo_fd = open (argv[2], O_RDONLY);
ref_fd = open (argv[1], O_RDONLY);
e_fd = open (argv[3], O_WRONLY | O_CREAT | O_TRUNC, 0644);
st = speex_echo_state_init(NN, 8*NN);
den = speex_preprocess_state_init(NN, 8000);
while (read(ref_fd, ref_buf, NN*2))
{
read(echo_fd, echo_buf, NN*2);
speex_echo_cancel(st, ref_buf, echo_buf, e_buf, noise);
/*speex_preprocess(den, e_buf, noise);*/
write(e_fd, e_buf, NN*2);
}
speex_echo_state_destroy(st);
speex_preprocess_state_destroy(den);
close(e_fd);
close(echo_fd);
close(ref_fd);
return 0;
}
static void speex_ec_preprocess(MSFilter *f){
SpeexECState *s=(SpeexECState*)f->data;
int delay_samples=0;
mblk_t *m;
s->echostarted=FALSE;
s->filterlength=(s->tail_length_ms*s->samplerate)/1000;
s->framesize=adjust_framesize(s->framesize_at_8000,s->samplerate);
delay_samples=s->delay_ms*s->samplerate/1000;
ms_message("Initializing speex echo canceler with framesize=%i, filterlength=%i, delay_samples=%i",
s->framesize,s->filterlength,delay_samples);
s->ecstate=speex_echo_state_init(s->framesize,s->filterlength);
s->den = speex_preprocess_state_init(s->framesize, s->samplerate);
speex_echo_ctl(s->ecstate, SPEEX_ECHO_SET_SAMPLING_RATE, &s->samplerate);
speex_preprocess_ctl(s->den, SPEEX_PREPROCESS_SET_ECHO_STATE, s->ecstate);
/* fill with zeroes for the time of the delay*/
m=allocb(delay_samples*2,0);
m->b_wptr+=delay_samples*2;
ms_bufferizer_put (&s->delayed_ref,m);
s->min_ref_samples=-1;
s->nominal_ref_samples=delay_samples;
audio_flow_controller_init(&s->afc);
s->flow_control_time = f->ticker->time;
#ifdef SPEEX_ECHO_GET_BLOB
apply_config(s);
#else
if (s->state_str) ms_warning("This version of speex doesn't support echo canceller restoration state. Rebuild speex and mediatreamer2 if you want to use this feature.");
#endif
}
extern "C" JNIEXPORT jint JNICALL Java_com_haitou_xiaoyoupai_imservice_support_audio_Speex_open(
JNIEnv *env, jobject obj, jint compression) {
int tmp = 0;
if (codec_open++ != 0)
return (jint) 0;
speex_bits_init(&ebits);
speex_bits_init(&dbits);
enc_state = speex_encoder_init(&speex_nb_mode);
dec_state = speex_decoder_init(&speex_nb_mode);
tmp = compression;
speex_encoder_ctl(enc_state, SPEEX_SET_QUALITY, &tmp);
speex_encoder_ctl(enc_state, SPEEX_GET_FRAME_SIZE, &enc_frame_size);
speex_decoder_ctl(dec_state, SPEEX_GET_FRAME_SIZE, &dec_frame_size);
SpeexPreprocessState * m_st;
m_st = speex_preprocess_state_init(enc_frame_size, 8000);
int denoise = 1;
int noiseSuppress = -25;
speex_preprocess_ctl(m_st, SPEEX_PREPROCESS_SET_DENOISE, &denoise);
speex_preprocess_ctl(m_st, SPEEX_PREPROCESS_SET_NOISE_SUPPRESS,
&noiseSuppress);
return (jint) 0;
}
int main()
{
int echo_fd, ref_fd, e_fd;
float noise[NN+1];
short echo_buf[NN], ref_buf[NN], e_buf[NN];
SpeexEchoState *st;
SpeexPreprocessState *den;
echo_fd = open ("play.sw", O_RDONLY);
ref_fd = open ("rec.sw", O_RDONLY);
e_fd = open ("echo.sw", O_WRONLY | O_CREAT | O_TRUNC, 0644);
st = speex_echo_state_init(NN, 8*NN);
den = speex_preprocess_state_init(NN, 8000);
while (read(ref_fd, ref_buf, NN*2))
{
read(echo_fd, echo_buf, NN*2);
speex_echo_cancel(st, ref_buf, echo_buf, e_buf, noise);
speex_preprocess(den, e_buf, noise);
write(e_fd, e_buf, NN*2);
}
speex_echo_state_destroy(st);
speex_preprocess_state_destroy(den);
close(e_fd);
close(echo_fd);
close(ref_fd);
return 0;
}
int speex_filter_init(AVFilterContext *avf)
{
SpeexFilterContext *s = avf->priv_data;
int opt = 1;
if (avf->avctx->channels == 2) {
av_log(avf, AV_LOG_ERROR, "Speex error: preprocessor does not support stereo encoding\n");
return -1;
}
s->preproc = speex_preprocess_state_init(avf->avctx->frame_size, avf->avctx->sample_rate);
if (avf->flags & FILTER_FLAG_SPEEX_VAD) {
speex_preprocess_ctl(s->preproc, SPEEX_PREPROCESS_SET_VAD, &opt);
}
if (avf->flags & FILTER_FLAG_SPEEX_AGC) {
float flevel = avf->agc_level;
speex_preprocess_ctl(s->preproc, SPEEX_PREPROCESS_SET_AGC, &opt);
speex_preprocess_ctl(s->preproc, SPEEX_PREPROCESS_SET_AGC_LEVEL, &flevel);
}
opt = (avf->flags & FILTER_FLAG_SPEEX_DENOISER) ? 1 : 0;
speex_preprocess_ctl(s->preproc, SPEEX_PREPROCESS_SET_DENOISE, &opt);
av_log(avf, AV_LOG_INFO, "Speex preproc: using preprocessor (vad: %d, agc level: %d, denoiser: %d)\n",
(avf->flags & FILTER_FLAG_SPEEX_VAD) ? 1 : 0,
avf->agc_level,
(avf->flags & FILTER_FLAG_SPEEX_DENOISER) ? 1 : 0);
return 0;
};
void init_speex_encoder() {
if (!gEncoderState) {
gEncoderState = speex_encoder_init(&speex_nb_mode);
int quality = 3; // 8000 bps
speex_encoder_ctl(gEncoderState, SPEEX_SET_QUALITY, &quality);
int complexity = 4; // net play is demanding, ok?
speex_encoder_ctl(gEncoderState, SPEEX_SET_COMPLEXITY, &complexity);
int tmp = kNetworkAudioSampleRate;
speex_encoder_ctl(gEncoderState, SPEEX_SET_SAMPLING_RATE, &tmp);
speex_bits_init(&gEncoderBits);
// set up the preprocessor
int frame_size;
speex_encoder_ctl(gEncoderState, SPEEX_GET_FRAME_SIZE, &frame_size);
gPreprocessState = speex_preprocess_state_init(frame_size, kNetworkAudioSampleRate);
// turn on AGC and denoise
tmp = 1;
speex_preprocess_ctl(gPreprocessState, SPEEX_PREPROCESS_SET_DENOISE, &tmp);
tmp = 1;
speex_preprocess_ctl(gPreprocessState, SPEEX_PREPROCESS_SET_AGC, &tmp);
float agc_level = 32768.0 * 0.7;
speex_preprocess_ctl(gPreprocessState, SPEEX_PREPROCESS_SET_AGC_LEVEL, &agc_level);
}
}
// Constructor
MprSpeexPreprocess::MprSpeexPreprocess(const UtlString& rName,
int samplesPerFrame, int samplesPerSec)
: MpAudioResource(rName, 1, 2, 1, 1, samplesPerFrame, samplesPerSec)
, m_bVadEnabled(FALSE)
{
// Initialize Speex preprocessor state
mpPreprocessState = speex_preprocess_state_init(samplesPerFrame, samplesPerSec);
}
/*
* Create the echo canceller.
*/
pjs_echo_canceller::pjs_echo_canceller(pj_pool_t *pool_, unsigned clock_rate,
unsigned samples_per_frame_, unsigned tail_ms, unsigned latency_ms,
unsigned options) {
int sampling_rate = clock_rate;
unsigned ptime, lat_cnt;
unsigned delay_buf_opt = 0;
lat_ready = PJ_FALSE;
/* Create new pool and instantiate and init the EC */
pool = pj_pool_create(pool_->factory, "ec%p", 256, 256, NULL);
lock = new PPJ_SemaphoreLock(pool, NULL, 1, 1);
samples_per_frame = samples_per_frame_;
frm_buf = (pj_int16_t*) pj_pool_alloc(pool, samples_per_frame << 1);
state = speex_echo_state_init(samples_per_frame,
clock_rate * tail_ms / 1000);
speex_echo_ctl(state, SPEEX_ECHO_SET_SAMPLING_RATE,
&sampling_rate);
preprocess = speex_preprocess_state_init(samples_per_frame,
clock_rate);
tmp_frame = (pj_int16_t*) pj_pool_zalloc(pool, 2*samples_per_frame);
speex_preprocess_ctl(preprocess, SPEEX_PREPROCESS_SET_ECHO_STATE,
state);
pj_list_init(&lat_buf);
pj_list_init(&lat_free);
PJ_LOG(5, (THIS_FILE, "Creating echo canceler"));
/* Create latency buffers */
ptime = samples_per_frame * 1000 / clock_rate;
if (latency_ms < ptime) {
/* Give at least one frame delay to simplify programming */
latency_ms = ptime;
}
lat_cnt = latency_ms / ptime;
while (lat_cnt--) {
struct frame *frm;
frm = (struct frame*) pj_pool_alloc(pool,
(samples_per_frame << 1) + sizeof(struct frame));
pj_list_push_back(&lat_free, frm);
}
/* Create delay buffer to compensate drifts */
if (options & PJMEDIA_ECHO_USE_SIMPLE_FIFO)
delay_buf_opt |= PJMEDIA_DELAY_BUF_SIMPLE_FIFO;
pjmedia_delay_buf_create(pool, NULL, clock_rate, samples_per_frame,
1, (PJMEDIA_SOUND_BUFFER_COUNT + 1) * ptime, delay_buf_opt,
&delay_buf);
PJ_LOG(4, (THIS_FILE, "ECHO canceller created, clock_rate=%d, channel=%d, "
"samples per frame=%d, tail length=%d ms, "
"latency=%d ms", clock_rate, 1, samples_per_frame, tail_ms, latency_ms));
}
bool SpeexPlugin::enablePreprocessing() throw (OperationNotPerfomedException) {
if (!encoder)
throw OperationNotPerfomedException("Encoder not initialized");
uint16 sampleRate = getEncodingSampleRate();
this->preprocess = speex_preprocess_state_init(sampleRate / 1000
* getEncodingPtime(), sampleRate);
return true;
}
JNIEXPORT void JNICALL Java_com_pullmi_shanghai_TalkActivity_speex_1EchoCanceller_1open
(JNIEnv *env, jobject jobj, jint jSampleRate, jint jBufSize, jint jTotalSize)
{
//init
int sampleRate = jSampleRate;
st = speex_echo_state_init(jBufSize, jTotalSize);
den = speex_preprocess_state_init(jBufSize, sampleRate);
speex_echo_ctl(st, SPEEX_ECHO_SET_SAMPLING_RATE, &sampleRate);
speex_preprocess_ctl(den, SPEEX_PREPROCESS_SET_ECHO_STATE, st);
}
static int speex_callback(struct ast_audiohook *audiohook, struct ast_channel *chan, struct ast_frame *frame, enum ast_audiohook_direction direction)
{
struct ast_datastore *datastore = NULL;
struct speex_direction_info *sdi = NULL;
struct speex_info *si = NULL;
char source[80];
/* If the audiohook is stopping it means the channel is shutting down.... but we let the datastore destroy take care of it */
if (audiohook->status == AST_AUDIOHOOK_STATUS_DONE || frame->frametype != AST_FRAME_VOICE) {
return -1;
}
/* We are called with chan already locked */
if (!(datastore = ast_channel_datastore_find(chan, &speex_datastore, NULL))) {
return -1;
}
si = datastore->data;
sdi = (direction == AST_AUDIOHOOK_DIRECTION_READ) ? si->rx : si->tx;
if (!sdi) {
return -1;
}
if ((sdi->samples != frame->samples) || (ast_format_rate(&frame->subclass.format) != si->lastrate)) {
si->lastrate = ast_format_rate(&frame->subclass.format);
if (sdi->state) {
speex_preprocess_state_destroy(sdi->state);
}
if (!(sdi->state = speex_preprocess_state_init((sdi->samples = frame->samples), si->lastrate))) {
return -1;
}
speex_preprocess_ctl(sdi->state, SPEEX_PREPROCESS_SET_AGC, &sdi->agc);
if (sdi->agc) {
speex_preprocess_ctl(sdi->state, SPEEX_PREPROCESS_SET_AGC_LEVEL, &sdi->agclevel);
}
speex_preprocess_ctl(sdi->state, SPEEX_PREPROCESS_SET_DENOISE, &sdi->denoise);
}
speex_preprocess(sdi->state, frame->data.ptr, NULL);
snprintf(source, sizeof(source), "%s/speex", frame->src);
if (frame->mallocd & AST_MALLOCD_SRC) {
ast_free((char *) frame->src);
}
frame->src = ast_strdup(source);
frame->mallocd |= AST_MALLOCD_SRC;
return 0;
}
SoundPreprocessor::SoundPreprocessor(int sampleRate, int bytesPerSample, int channelNumber, int denoiseLevel){
spx_int32_t i=1;
spx_int32_t noisesuppress=(spx_int32_t)denoiseLevel;
mBytesPerFrame = getBytesPerFrame(sampleRate, bytesPerSample, channelNumber);
mpSpStat = speex_preprocess_state_init(mBytesPerFrame / sizeof(short), sampleRate);
if(mpSpStat){
speex_preprocess_ctl(mpSpStat, SPEEX_PREPROCESS_SET_DENOISE, &i);
speex_preprocess_ctl(mpSpStat, SPEEX_PREPROCESS_SET_NOISE_SUPPRESS, &noisesuppress);
}else{
mBytesPerFrame = 0;
}
}
static int encode_update(struct aufilt_enc_st **stp, void **ctx,
const struct aufilt *af, struct aufilt_prm *prm)
{
struct preproc *st;
unsigned sampc;
(void)ctx;
if (!stp || !af || !prm || prm->ch != 1)
return EINVAL;
st = mem_zalloc(sizeof(*st), speexpp_destructor);
if (!st)
return ENOMEM;
sampc = prm->srate * prm->ch * prm->ptime / 1000;
st->state = speex_preprocess_state_init(sampc, prm->srate);
if (!st->state)
goto error;
speex_preprocess_ctl(st->state, SPEEX_PREPROCESS_SET_DENOISE,
&pp_conf.denoise_enabled);
speex_preprocess_ctl(st->state, SPEEX_PREPROCESS_SET_AGC,
&pp_conf.agc_enabled);
#ifdef SPEEX_PREPROCESS_SET_AGC_TARGET
if (pp_conf.agc_enabled) {
speex_preprocess_ctl(st->state,
SPEEX_PREPROCESS_SET_AGC_TARGET,
&pp_conf.agc_level);
}
#endif
speex_preprocess_ctl(st->state, SPEEX_PREPROCESS_SET_VAD,
&pp_conf.vad_enabled);
speex_preprocess_ctl(st->state, SPEEX_PREPROCESS_SET_DEREVERB,
&pp_conf.dereverb_enabled);
info("speex_pp: Speex preprocessor loaded: srate = %uHz\n",
prm->srate);
*stp = (struct aufilt_enc_st *)st;
return 0;
error:
mem_deref(st);
return ENOMEM;
}
void AudioInput::resetAudioProcessor() {
if (!bResetProcessor)
return;
int iArg;
if (sppPreprocess)
speex_preprocess_state_destroy(sppPreprocess);
if (sesEcho)
speex_echo_state_destroy(sesEcho);
sppPreprocess = speex_preprocess_state_init(iFrameSize, iSampleRate);
iArg = 1;
speex_preprocess_ctl(sppPreprocess, SPEEX_PREPROCESS_SET_VAD, &iArg);
speex_preprocess_ctl(sppPreprocess, SPEEX_PREPROCESS_SET_AGC, &iArg);
speex_preprocess_ctl(sppPreprocess, SPEEX_PREPROCESS_SET_DENOISE, &iArg);
speex_preprocess_ctl(sppPreprocess, SPEEX_PREPROCESS_SET_DEREVERB, &iArg);
iArg = 30000;
speex_preprocess_ctl(sppPreprocess, SPEEX_PREPROCESS_SET_AGC_TARGET, &iArg);
float v = 30000.0f / static_cast<float>(g.s.iMinLoudness);
iArg = iroundf(floorf(20.0f * log10f(v)));
speex_preprocess_ctl(sppPreprocess, SPEEX_PREPROCESS_SET_AGC_MAX_GAIN, &iArg);
iArg = -60;
speex_preprocess_ctl(sppPreprocess, SPEEX_PREPROCESS_SET_AGC_DECREMENT, &iArg);
iArg = g.s.iNoiseSuppress;
speex_preprocess_ctl(sppPreprocess, SPEEX_PREPROCESS_SET_NOISE_SUPPRESS, &iArg);
if (iEchoChannels > 0) {
sesEcho = speex_echo_state_init_mc(iFrameSize, iFrameSize * 10, 1, bEchoMulti ? iEchoChannels : 1);
iArg = iSampleRate;
speex_echo_ctl(sesEcho, SPEEX_ECHO_SET_SAMPLING_RATE, &iArg);
speex_preprocess_ctl(sppPreprocess, SPEEX_PREPROCESS_SET_ECHO_STATE, sesEcho);
qWarning("AudioInput: ECHO CANCELLER ACTIVE");
} else {
sesEcho = NULL;
}
bResetEncoder = true;
bResetProcessor = false;
}
extern "C" JNIEXPORT void Java_com_haitou_xiaoyoupai_imservice_support_audio_Speex_initEcho(
JNIEnv *env, jobject jobj, jint frame_size, jint filter_length) {
if (aec_status == AEC_OPENED)
return;
aec_status = AEC_OPENED;
int frm_size;
int f_length;
frm_size = frame_size;
f_length = filter_length;
echoState = speex_echo_state_init(frame_size, filter_length);
den = speex_preprocess_state_init(frame_size, sampleRate);
speex_echo_ctl(echoState, SPEEX_ECHO_SET_SAMPLING_RATE, &sampleRate);
speex_preprocess_ctl(den, SPEEX_PREPROCESS_SET_ECHO_STATE, echoState);
}
void sound::start(){
const PaDeviceInfo * info = Pa_GetDeviceInfo(indexInputDevice);
inputStreamParameters.device = indexInputDevice;
inputStreamParameters.channelCount = 1;
inputStreamParameters.hostApiSpecificStreamInfo = 0;
inputStreamParameters.sampleFormat = paInt16;
inputStreamParameters.suggestedLatency = info->defaultLowInputLatency;
PaError err = Pa_OpenStream(&input, &inputStreamParameters, 0, info->defaultSampleRate, BUFF_LONG, paNoFlag, sound::inputcallback, this);
if (err != paNoError){
throw std::exception("open stream err=%d", err);
}
err = Pa_StartStream(input);
if (err != paNoError){
throw std::exception("start stream err=%d", err);
}
speexppstate = speex_preprocess_state_init(BUFF_LONG*inputStreamParameters.channelCount, (int)info->defaultSampleRate);
spx_int32_t on = 1;
speex_preprocess_ctl(speexppstate, SPEEX_PREPROCESS_SET_AGC, &on);
float agcLevel = 24000;
speex_preprocess_ctl(speexppstate, SPEEX_PREPROCESS_SET_AGC_LEVEL, &agcLevel);
int denoise = 1;
speex_preprocess_ctl(speexppstate, SPEEX_PREPROCESS_SET_DENOISE, &denoise); //½µÔë
int noiseSuppress = -25;
speex_preprocess_ctl(speexppstate, SPEEX_PREPROCESS_SET_NOISE_SUPPRESS, &noiseSuppress); //ÉèÖÃÔëÉùµÄdB
speexechostate = speex_echo_state_init(BUFF_LONG*inputStreamParameters.channelCount, BUFF_LONG*inputStreamParameters.channelCount);
info = Pa_GetDeviceInfo(indexOutputDevice);
outputStreamParameters.device = indexOutputDevice;
outputStreamParameters.channelCount = 1;
outputStreamParameters.hostApiSpecificStreamInfo = 0;
outputStreamParameters.sampleFormat = paInt16;
outputStreamParameters.suggestedLatency = info->defaultLowOutputLatency;
err = Pa_OpenStream(&output, 0, &outputStreamParameters, info->defaultSampleRate, BUFF_LONG, paNoFlag, sound::outputcallback, this);
if (err != paNoError){
throw std::exception("open stream err=%d", err);
}
err = Pa_StartStream(output);
if (err != paNoError){
throw std::exception("start stream err=%d", err);
}
}
NetworkSoundRecorder::NetworkSoundRecorder(State::Context* context)
: m_context(context)
, m_frameSize(160)
{
speex_bits_init(&m_speexBits);
m_speexState = speex_encoder_init(&speex_nb_mode);
int quality = 6;
speex_encoder_ctl(m_speexState, SPEEX_SET_QUALITY, &quality);
int enabled = 1;
int target = 16000;
m_speexPreprocessState = speex_preprocess_state_init(m_frameSize, 8180);
speex_preprocess_ctl(m_speexPreprocessState, SPEEX_PREPROCESS_SET_AGC, &enabled);
speex_preprocess_ctl(m_speexPreprocessState, SPEEX_PREPROCESS_SET_AGC_TARGET, &target);
setProcessingInterval(cpp3ds::milliseconds(100));
}
JNIEXPORT jint JNICALL Java_com_ccut_shangri_audiorecorder_IMSpeexDSPAndEnc_init (JNIEnv *env, jobject obj,
jint size, jint rate, jint channel)
{
if (codec_open++ != 0)
{
LOGD("IMSpeexDSPAndEnc jni init fail, it is already init!");
return -1;
}
LOGD("IMSpeexDSPAndEnc jni init");
frame_size = size;
sampling_rate = rate;
channel_num = channel;
if (NULL == filepath)
{
LOGD("IMSpeexDSPAndEnc jni init fail, file path is null!");
return -1;
}
denoise_state = speex_preprocess_state_init(frame_size, sampling_rate);
int i = 1;
speex_preprocess_ctl(denoise_state, SPEEX_PREPROCESS_SET_DENOISE, &i);
i = -25;
speex_preprocess_ctl(denoise_state, SPEEX_PREPROCESS_SET_NOISE_SUPPRESS, &i);
i = 0;
speex_preprocess_ctl(denoise_state, SPEEX_PREPROCESS_SET_AGC, &i);
i = 0;
speex_preprocess_ctl(denoise_state, SPEEX_PREPROCESS_SET_DEREVERB, &i);
float f = 0.0;
speex_preprocess_ctl(denoise_state, SPEEX_PREPROCESS_SET_DEREVERB_DECAY, &f);
f = 0.0;
speex_preprocess_ctl(denoise_state, SPEEX_PREPROCESS_SET_DEREVERB_LEVEL, &f);
LOGD("IMSpeexDSPAndEnc jni success!");
//init amr_enc
amr_enc_init("/sdcard/amrQAQ.amr", 16, 1, 8000);
count = 0;
}
static void volume_preprocess(MSFilter *f){
Volume *v=(Volume*)f->data;
/*process agc by chunks of 10 ms*/
v->nsamples=(int)(0.01*(float)v->sample_rate);
if (v->agc_enabled){
ms_message("AGC is enabled.");
#if defined HAVE_SPEEXDSP && !defined MS_FIXED_POINT
if (v->speex_pp==NULL){
int tmp=1;
v->speex_pp=speex_preprocess_state_init(v->nsamples,v->sample_rate);
if (speex_preprocess_ctl(v->speex_pp,SPEEX_PREPROCESS_SET_AGC,&tmp)==-1){
ms_warning("Speex AGC is not available.");
}
tmp=0;
speex_preprocess_ctl(v->speex_pp,SPEEX_PREPROCESS_SET_VAD,&tmp);
speex_preprocess_ctl(v->speex_pp,SPEEX_PREPROCESS_SET_DENOISE,&tmp);
speex_preprocess_ctl(v->speex_pp,SPEEX_PREPROCESS_SET_DEREVERB,&tmp);
}
#endif
}
}
static int speex_encoder_construct(struct ast_trans_pvt *pvt, const SpeexMode *profile, int sampling_rate)
{
struct speex_coder_pvt *tmp = pvt->pvt;
if (!(tmp->speex = speex_encoder_init(profile)))
return -1;
speex_bits_init(&tmp->bits);
speex_bits_reset(&tmp->bits);
speex_encoder_ctl(tmp->speex, SPEEX_GET_FRAME_SIZE, &tmp->framesize);
speex_encoder_ctl(tmp->speex, SPEEX_SET_COMPLEXITY, &complexity);
#ifdef _SPEEX_TYPES_H
if (preproc) {
tmp->pp = speex_preprocess_state_init(tmp->framesize, sampling_rate);
speex_preprocess_ctl(tmp->pp, SPEEX_PREPROCESS_SET_VAD, &pp_vad);
speex_preprocess_ctl(tmp->pp, SPEEX_PREPROCESS_SET_AGC, &pp_agc);
speex_preprocess_ctl(tmp->pp, SPEEX_PREPROCESS_SET_AGC_LEVEL, &pp_agc_level);
speex_preprocess_ctl(tmp->pp, SPEEX_PREPROCESS_SET_DENOISE, &pp_denoise);
speex_preprocess_ctl(tmp->pp, SPEEX_PREPROCESS_SET_DEREVERB, &pp_dereverb);
speex_preprocess_ctl(tmp->pp, SPEEX_PREPROCESS_SET_DEREVERB_DECAY, &pp_dereverb_decay);
speex_preprocess_ctl(tmp->pp, SPEEX_PREPROCESS_SET_DEREVERB_LEVEL, &pp_dereverb_level);
}
#endif
if (!abr && !vbr) {
speex_encoder_ctl(tmp->speex, SPEEX_SET_QUALITY, &quality);
if (vad)
speex_encoder_ctl(tmp->speex, SPEEX_SET_VAD, &vad);
}
if (vbr) {
speex_encoder_ctl(tmp->speex, SPEEX_SET_VBR, &vbr);
speex_encoder_ctl(tmp->speex, SPEEX_SET_VBR_QUALITY, &vbr_quality);
}
if (abr)
speex_encoder_ctl(tmp->speex, SPEEX_SET_ABR, &abr);
if (dtx)
speex_encoder_ctl(tmp->speex, SPEEX_SET_DTX, &dtx);
tmp->silent_state = 0;
return 0;
}
OsStatus MpeSipxSpeexUWb::initEncode(void)
{
mpEncoderState = speex_encoder_init(speex_lib_get_mode(SPEEX_MODEID_UWB));
speex_encoder_ctl(mpEncoderState, SPEEX_SET_MODE, &mMode);
speex_encoder_ctl(mpEncoderState, SPEEX_SET_SAMPLING_RATE, &mSampleRate);
// Enable wanted extensions.
speex_encoder_ctl(mpEncoderState, SPEEX_SET_VAD, &mDoVad);
speex_encoder_ctl(mpEncoderState, SPEEX_SET_DTX, &mDoDtx);
speex_encoder_ctl(mpEncoderState, SPEEX_SET_VBR, &mDoVbr);
speex_bits_init(&mBits);
if(mDoPreprocess)
{
mpPreprocessState = speex_preprocess_state_init(getInfo()->getNumSamplesPerFrame(), mSampleRate);
speex_preprocess_ctl(mpPreprocessState, SPEEX_PREPROCESS_SET_DENOISE,
&mDoDenoise);
speex_preprocess_ctl(mpPreprocessState, SPEEX_PREPROCESS_SET_AGC, &mDoAgc);
}
return OS_SUCCESS;
}
int main(int argc, char **argv)
{
FILE *echo_fd, *ref_fd, *e_fd;
short echo_buf[NN], ref_buf[NN], e_buf[NN];
SpeexEchoState *st;
SpeexPreprocessState *den;
int sampleRate = 8000;
if (argc != 4)
{
fprintf(stderr, "testecho mic_signal.sw speaker_signal.sw output.sw\n");
exit(1);
}
echo_fd = fopen(argv[2], "rb");
ref_fd = fopen(argv[1], "rb");
e_fd = fopen(argv[3], "wb");
st = speex_echo_state_init(NN, TAIL);
den = speex_preprocess_state_init(NN, sampleRate);
speex_echo_ctl(st, SPEEX_ECHO_SET_SAMPLING_RATE, &sampleRate);
speex_preprocess_ctl(den, SPEEX_PREPROCESS_SET_ECHO_STATE, st);
while (!feof(ref_fd) && !feof(echo_fd))
{
fread(ref_buf, sizeof(short), NN, ref_fd);
fread(echo_buf, sizeof(short), NN, echo_fd);
speex_echo_cancellation(st, ref_buf, echo_buf, e_buf);
speex_preprocess_run(den, e_buf);
fwrite(e_buf, sizeof(short), NN, e_fd);
}
speex_echo_state_destroy(st);
speex_preprocess_state_destroy(den);
fclose(e_fd);
fclose(echo_fd);
fclose(ref_fd);
return 0;
}
void AudioCaptureThread::Denoise(BYTE* lpData, DWORD dwBytes)
{
DWORD dwProcessed = 0;
short* in = (short*)lpData;
int i;
SpeexPreprocessState *st;
//int count=0;
float f;
st = speex_preprocess_state_init(SAMPLES_PER_RECORD, SAMPLES_PER_SECOND);
i=1;
speex_preprocess_ctl(st, SPEEX_PREPROCESS_SET_DENOISE, &i);
i=0;
speex_preprocess_ctl(st, SPEEX_PREPROCESS_SET_AGC, &i);
i=SAMPLES_PER_SECOND;
speex_preprocess_ctl(st, SPEEX_PREPROCESS_SET_AGC_LEVEL, &i);
i=0;
speex_preprocess_ctl(st, SPEEX_PREPROCESS_SET_DEREVERB, &i);
f=.0;
speex_preprocess_ctl(st, SPEEX_PREPROCESS_SET_DEREVERB_DECAY, &f);
f=.0;
speex_preprocess_ctl(st, SPEEX_PREPROCESS_SET_DEREVERB_LEVEL, &f);
while (dwProcessed < SAMPLES_PER_RECORD)
{
int vad;
//fread(in, sizeof(short), SAMPLES_PER_RECORD, stdin);
//if (feof(stdin))
// break;
vad = speex_preprocess_run(st, in);
//fprintf (stderr, "%d\n", vad);
//fwrite(in, sizeof(short), SAMPLES_PER_RECORD, stdout);
//count++;
dwProcessed += SAMPLES_PER_RECORD;
in += SAMPLES_PER_RECORD;
}
speex_preprocess_state_destroy(st);
}
static qbool S_Speex_Init (void)
{
int i;
const SpeexMode *mode;
if (s_speex.inited)
return s_speex.loaded;
s_speex.inited = true;
mode = speex_lib_get_mode (SPEEX_MODEID_NB);
speex_bits_init (&s_speex.encbits);
speex_bits_reset (&s_speex.encbits);
s_speex.encoder = speex_encoder_init (mode);
speex_encoder_ctl (s_speex.encoder, SPEEX_GET_FRAME_SIZE, &s_speex.framesize);
speex_encoder_ctl (s_speex.encoder, SPEEX_GET_SAMPLING_RATE, &s_speex.samplerate);
s_speex.samplerate = 11025;
speex_encoder_ctl (s_speex.encoder, SPEEX_SET_SAMPLING_RATE, &s_speex.samplerate);
s_speex.preproc = speex_preprocess_state_init (s_speex.framesize, s_speex.samplerate);
i = 1;
speex_preprocess_ctl (s_speex.preproc, SPEEX_PREPROCESS_SET_DENOISE, &i);
i = 1;
speex_preprocess_ctl (s_speex.preproc, SPEEX_PREPROCESS_SET_AGC, &i);
for (i = 0; i < MAX_CLIENTS; i++) {
speex_bits_init (&s_speex.decbits[i]);
speex_bits_reset (&s_speex.decbits[i]);
s_speex.decoder[i] = speex_decoder_init (mode);
s_speex.decamp[i] = 1;
}
s_speex.loaded = true;
return s_speex.loaded;
}
static pa_bool_t pa_speex_ec_preprocessor_init(pa_echo_canceller *ec, pa_sample_spec *source_ss, uint32_t nframes, pa_modargs *ma) {
pa_bool_t agc;
pa_bool_t denoise;
pa_bool_t echo_suppress;
int32_t echo_suppress_attenuation;
int32_t echo_suppress_attenuation_active;
agc = DEFAULT_AGC_ENABLED;
if (pa_modargs_get_value_boolean(ma, "agc", &agc) < 0) {
pa_log("Failed to parse agc value");
goto fail;
}
denoise = DEFAULT_DENOISE_ENABLED;
if (pa_modargs_get_value_boolean(ma, "denoise", &denoise) < 0) {
pa_log("Failed to parse denoise value");
goto fail;
}
echo_suppress = DEFAULT_ECHO_SUPPRESS_ENABLED;
if (pa_modargs_get_value_boolean(ma, "echo_suppress", &echo_suppress) < 0) {
pa_log("Failed to parse echo_suppress value");
goto fail;
}
echo_suppress_attenuation = DEFAULT_ECHO_SUPPRESS_ATTENUATION;
if (pa_modargs_get_value_s32(ma, "echo_suppress_attenuation", &echo_suppress_attenuation) < 0) {
pa_log("Failed to parse echo_suppress_attenuation value");
goto fail;
}
if (echo_suppress_attenuation > 0) {
pa_log("echo_suppress_attenuation should be a negative dB value");
goto fail;
}
echo_suppress_attenuation_active = DEFAULT_ECHO_SUPPRESS_ATTENUATION;
if (pa_modargs_get_value_s32(ma, "echo_suppress_attenuation_active", &echo_suppress_attenuation_active) < 0) {
pa_log("Failed to parse echo_suppress_attenuation_active value");
goto fail;
}
if (echo_suppress_attenuation_active > 0) {
pa_log("echo_suppress_attenuation_active should be a negative dB value");
goto fail;
}
if (agc || denoise || echo_suppress) {
spx_int32_t tmp;
if (source_ss->channels != 1) {
pa_log("AGC, denoising and echo suppression only work with channels=1");
goto fail;
}
ec->params.priv.speex.pp_state = speex_preprocess_state_init(nframes, source_ss->rate);
tmp = agc;
speex_preprocess_ctl(ec->params.priv.speex.pp_state, SPEEX_PREPROCESS_SET_AGC, &tmp);
tmp = denoise;
speex_preprocess_ctl(ec->params.priv.speex.pp_state, SPEEX_PREPROCESS_SET_DENOISE, &tmp);
if (echo_suppress) {
if (echo_suppress_attenuation)
speex_preprocess_ctl(ec->params.priv.speex.pp_state, SPEEX_PREPROCESS_SET_ECHO_SUPPRESS,
&echo_suppress_attenuation);
if (echo_suppress_attenuation_active) {
speex_preprocess_ctl(ec->params.priv.speex.pp_state, SPEEX_PREPROCESS_SET_ECHO_SUPPRESS_ACTIVE,
&echo_suppress_attenuation_active);
}
speex_preprocess_ctl(ec->params.priv.speex.pp_state, SPEEX_PREPROCESS_SET_ECHO_STATE,
ec->params.priv.speex.state);
}
pa_log_info("Loaded speex preprocessor with params: agc=%s, denoise=%s, echo_suppress=%s", pa_yes_no(agc),
pa_yes_no(denoise), pa_yes_no(echo_suppress));
} else
pa_log_info("All preprocessing options are disabled");
return TRUE;
fail:
return FALSE;
}
int iaxc_input_postprocess(void *audio, int len, int rate)
{
double volume;
static double lowest_volume = 1;
int silent=0;
if(!st || (speex_state_size != len) || (speex_state_rate != rate)) {
if(st) speex_preprocess_state_destroy(st);
st = speex_preprocess_state_init(len,rate);
speex_state_size = len;
speex_state_rate = rate;
iaxc_set_speex_filters();
}
calculate_level(audio, len, &input_level);
/* only preprocess if we're interested in VAD, AGC, or DENOISE */
if((iaxc_filters & (IAXC_FILTER_DENOISE | IAXC_FILTER_AGC)) || iaxc_silence_threshold > 0)
silent = !speex_preprocess(st, audio, NULL);
/* Analog AGC: Bring speex AGC gain out to mixer, with lots of hysteresis */
/* use a higher continuation threshold for AAGC than for VAD itself */
if(!silent &&
(iaxc_silence_threshold != 0) &&
(iaxc_filters & IAXC_FILTER_AGC) &&
(iaxc_filters & IAXC_FILTER_AAGC) &&
(st->speech_prob > .20)
) {
static int i;
double level;
i++;
if((i&0x3f) == 0) {
float loudness = st->loudness2;
if((loudness > 8000) || (loudness < 4000)) {
level = iaxc_input_level_get();
/* fprintf(stderr, "loudness = %f, level = %f\n", loudness, level); */
/* lower quickly if we're really too hot */
if((loudness > 16000) && (level > 0.5)) {
/* fprintf(stderr, "lowering quickly level\n"); */
iaxc_input_level_set(level - 0.2);
}
/* lower less quickly if we're a bit too hot */
else if((loudness > 8000) && (level >= 0.15)) {
/* fprintf(stderr, "lowering slowly level\n"); */
iaxc_input_level_set(level - 0.1);
}
/* raise slowly if we're cold */
else if((loudness < 4000) && (level <= 0.9)) {
/* fprintf(stderr, "raising level\n"); */
iaxc_input_level_set(level + 0.1);
}
}
}
}
/* this is ugly. Basically just don't get volume level if speex thought
* we were silent. just set it to 0 in that case */
if(iaxc_silence_threshold > 0 && silent)
input_level = 0;
do_level_callback();
volume = vol_to_db(input_level);
if(volume < lowest_volume) lowest_volume = volume;
if(iaxc_silence_threshold > 0)
return silent;
else
return volume < iaxc_silence_threshold;
}
void RakVoice::OpenChannel(Packet *packet)
{
RakNet::BitStream in(packet->data, packet->length, false);
in.IgnoreBits(8);
FreeChannelMemory(packet->guid);
VoiceChannel *channel=RakNet::OP_NEW<VoiceChannel>( __FILE__, __LINE__ );
channel->guid=packet->guid;
channel->isSendingVoiceData=false;
int sampleRate;
in.Read(sampleRate);
channel->remoteSampleRate=sampleRate;
if (channel->remoteSampleRate!=8000 && channel->remoteSampleRate!=16000 && channel->remoteSampleRate!=32000)
{
#ifdef _DEBUG
RakAssert(0);
#endif
RakNet::OP_DELETE(channel, __FILE__, __LINE__);
return;
}
if (sampleRate==8000)
channel->enc_state=speex_encoder_init(&speex_nb_mode);
else if (sampleRate==16000)
channel->enc_state=speex_encoder_init(&speex_wb_mode);
else // 32000
channel->enc_state=speex_encoder_init(&speex_uwb_mode);
if (channel->remoteSampleRate==8000)
channel->dec_state=speex_decoder_init(&speex_nb_mode);
else if (channel->remoteSampleRate==16000)
channel->dec_state=speex_decoder_init(&speex_wb_mode);
else // 32000
channel->dec_state=speex_decoder_init(&speex_uwb_mode);
// make sure encoder and decoder are created
RakAssert((channel->enc_state)&&(channel->dec_state));
int ret;
ret=speex_encoder_ctl(channel->enc_state, SPEEX_GET_FRAME_SIZE, &channel->speexOutgoingFrameSampleCount);
RakAssert(ret==0);
channel->outgoingBuffer = (char*) rakMalloc_Ex(bufferSizeBytes * FRAME_OUTGOING_BUFFER_COUNT, __FILE__, __LINE__);
channel->outgoingReadIndex=0;
channel->outgoingWriteIndex=0;
channel->bufferOutput=true;
channel->outgoingMessageNumber=0;
channel->copiedOutgoingBufferToBufferedOutput=false;
ret=speex_decoder_ctl(channel->dec_state, SPEEX_GET_FRAME_SIZE, &channel->speexIncomingFrameSampleCount);
RakAssert(ret==0);
channel->incomingBuffer = (char*) rakMalloc_Ex(bufferSizeBytes * FRAME_INCOMING_BUFFER_COUNT, __FILE__, __LINE__);
channel->incomingReadIndex=0;
channel->incomingWriteIndex=0;
channel->lastSend=0;
channel->incomingMessageNumber=0;
// Initialize preprocessor
channel->pre_state = speex_preprocess_state_init(channel->speexOutgoingFrameSampleCount, sampleRate);
RakAssert(channel->pre_state);
// Set encoder default parameters
SetEncoderParameter(channel->enc_state, SPEEX_SET_VBR, (defaultVBRState) ? 1 : 0 );
SetEncoderParameter(channel->enc_state, SPEEX_SET_COMPLEXITY, defaultEncoderComplexity);
// Set preprocessor default parameters
SetPreprocessorParameter(channel->pre_state, SPEEX_PREPROCESS_SET_DENOISE, (defaultDENOISEState) ? 1 : 2);
SetPreprocessorParameter(channel->pre_state, SPEEX_PREPROCESS_SET_VAD, (defaultVADState) ? 1 : 2);
voiceChannels.Insert(packet->guid, channel, true, __FILE__, __LINE__);
}
int main(int argc, char*argv[])
{
/* The Sample format to use */
static const pa_sample_spec ss =
{
.format = PA_SAMPLE_S16LE,
.rate = 44100,
.channels = 2
};
pa_simple* dev_out = 0;
pa_simple* dev_in = 0;
int ret = 1;
int error;
/* Create a new playback stream */
if (!(dev_out = pa_simple_new(NULL, "Noise Remover", PA_STREAM_PLAYBACK, NULL, "playback", &ss, NULL, NULL, &error)))
{
fprintf(stderr, __FILE__": pa_simple_new() failed: %dev_out\n", pa_strerror(error));
goto finish;
}
if (!(dev_in = pa_simple_new(NULL, "Noise Remover", PA_STREAM_RECORD, NULL, "record", &ss, NULL, NULL, &error)))
{
fprintf(stderr, __FILE__": pa_simple_new() failed: %dev_out\n", pa_strerror(error));
goto finish;
}
{
int i;
float f;
SpeexPreprocessState* pp = speex_preprocess_state_init(BUFSIZE, ss.rate);
i = 1; speex_preprocess_ctl(pp, SPEEX_PREPROCESS_SET_DENOISE, &i);
i = 1; speex_preprocess_ctl(pp, SPEEX_PREPROCESS_SET_AGC, &i);
f = 8000; speex_preprocess_ctl(pp, SPEEX_PREPROCESS_SET_AGC_LEVEL, &f);
i = 1; speex_preprocess_ctl(pp, SPEEX_PREPROCESS_SET_DEREVERB, &i);
f = 0.04; speex_preprocess_ctl(pp, SPEEX_PREPROCESS_SET_DEREVERB_DECAY, &f);
f = 0.03; speex_preprocess_ctl(pp, SPEEX_PREPROCESS_SET_DEREVERB_LEVEL, &f);
double lowest_rms = 99999999999999;
int silence_count = 0;
for (;;)
{
int16_t buf[BUFSIZE];
/* Read some data ... */
if (pa_simple_read(dev_in, buf, sizeof(buf), &error) < 0)
{
fprintf(stderr, __FILE__": pa_simple_read() failed: %s\n", pa_strerror(error));
goto finish;
}
/* ... Use speex to de-noise ... */
double total = 0;
for(int n = 0; n < sizeof(buf); n++)
total += buf[n] * buf[n];
double rms = std::sqrt(total / sizeof(buf));
if(rms < lowest_rms)
lowest_rms = rms;
if((rms - lowest_rms) < 50) // this value will probably need adjusting for you
silence_count = 0;
else if(silence_count < 10)
silence_count++;
if(silence_count == 10)
speex_preprocess_run(pp, buf);
else
continue; // don't write it out...
/* ... and play it */
if (pa_simple_write(dev_out, buf, sizeof(buf), &error) < 0)
{
fprintf(stderr, __FILE__": pa_simple_write() failed: %dev_out\n", pa_strerror(error));
goto finish;
}
}
/* Make sure that every single sample was played */
if (pa_simple_drain(dev_out, &error) < 0)
{
fprintf(stderr, __FILE__": pa_simple_drain() failed: %dev_out\n", pa_strerror(error));
goto finish;
}
}
ret = 0;
finish:
if (dev_out)
pa_simple_free(dev_out);
if (dev_in)
pa_simple_free(dev_in);
return ret;
}
