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; }