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 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); } }
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; } }
void RakVoice::SetPreprocessorParameter(void* pre_state, int vartype, int val) { if (pre_state){ // Set parameter for just one preprocessor int ret = speex_preprocess_ctl((SpeexPreprocessState*)pre_state, vartype, &val); RakAssert(ret==0); } else { // Set parameter for all decoders for (unsigned int index=0; index < voiceChannels.Size(); index++) { int ret = speex_preprocess_ctl((SpeexPreprocessState*)voiceChannels[index]->pre_state, vartype, &val); RakAssert(ret==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; }
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 }
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); }
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)); }
/* * 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)); }
UtlBoolean MprSpeexPreprocess::attachEchoCanceller(SpeexEchoState* pEchoState) { if (pEchoState && mpPreprocessState) { // attach echo canceller speex_preprocess_ctl(mpPreprocessState, SPEEX_PREPROCESS_SET_ECHO_STATE, pEchoState); } return FALSE; }
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); }
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; }
// Destructor MprSpeexPreprocess::~MprSpeexPreprocess() { if (mpPreprocessState) { // detach echo canceller speex_preprocess_ctl(mpPreprocessState, SPEEX_PREPROCESS_SET_ECHO_STATE, NULL); // free mpPreprocessState speex_preprocess_state_destroy(mpPreprocessState); mpPreprocessState = NULL; } }
void iaxc_set_speex_filters() { int i; float f; if(!st) return; i = 1; /* always make VAD decision */ speex_preprocess_ctl(st, SPEEX_PREPROCESS_SET_VAD, &i); i = (iaxc_filters & IAXC_FILTER_AGC) ? 1 : 0; speex_preprocess_ctl(st, SPEEX_PREPROCESS_SET_AGC, &i); i = (iaxc_filters & IAXC_FILTER_DENOISE) ? 1 : 0; speex_preprocess_ctl(st, SPEEX_PREPROCESS_SET_DENOISE, &i); /* make vad more sensitive */ f=0.30f; speex_preprocess_ctl(st, SPEEX_PREPROCESS_SET_PROB_START, &f); f=0.07f; speex_preprocess_ctl(st, SPEEX_PREPROCESS_SET_PROB_CONTINUE, &f); }
static double powerspectrum_stat_beyond8K(struct Channel *chan){ spx_int32_t ps_size = 0; spx_int32_t *ps = NULL; double mystat = 0; float fftmul = 1.0 / (32768.0); int i; speex_preprocess_ctl(chan->speex_pp, SPEEX_PREPROCESS_GET_PSD_SIZE, &ps_size); ps = (spx_int32_t*)ortp_malloc(sizeof(spx_int32_t)*ps_size); speex_preprocess_ctl(chan->speex_pp, SPEEX_PREPROCESS_GET_PSD, ps); mystat = 0; for (i=ps_size/2;i < ps_size; i++) { double yp; #if defined(__cplusplus) yp = sqrtf(sqrtf(static_cast<float>(ps[i]))) - 1.0f; #else yp = sqrtf(sqrtf((float)(ps[i]))) - 1.0f; #endif yp = yp * fftmul; yp = MIN(yp * 3000.0, 1.0); yp = (1 - yp) * (100 - 1.0f); mystat = yp + mystat; } mystat = (mystat*2)/ps_size; ortp_free(ps); /* values: Maximum: 108,064 low volume on high frequency. Decrease when volume increase. */ /* return value between 0 and 108,064? */ mystat = 108.064-mystat; chan->average_psd=(mystat*mystat*coef) + (1.0-coef)*chan->average_psd; //ms_message("average power spectrum on half highest values ONLY: stat=%.3lf", chan->average_psd); return mystat; }
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 } }
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; }
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; }
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; }
int speex_filter_proc(AVFilterContext *avf, AVFilterContext *prev, void *in) { SpeexFilterContext *s = avf->priv_data; float* spectral = prev && prev->specific && prev->active ? prev->specific : NULL; int opt; float flevel; // agc different? int newopt = (avf->flags & FILTER_FLAG_SPEEX_AGC) ? 1 : 0; speex_preprocess_ctl(s->preproc, SPEEX_PREPROCESS_GET_AGC, &opt); speex_preprocess_ctl(s->preproc, SPEEX_PREPROCESS_GET_AGC_LEVEL, &flevel); if (newopt ^ opt) { av_log(avf, AV_LOG_INFO, "Speex: changing AGC: %d\n", newopt); speex_preprocess_ctl(s->preproc, SPEEX_PREPROCESS_SET_AGC, &newopt); } if ((int) flevel != avf->agc_level) { av_log(avf, AV_LOG_INFO, "Speex: changing AGC level: %d\n", avf->agc_level); flevel = avf->agc_level; speex_preprocess_ctl(s->preproc, SPEEX_PREPROCESS_SET_AGC_LEVEL, &flevel); } // agc fixed different? /*newopt = (avf->flags & FILTER_FLAG_SPEEX_AGC_FIXED) ? 1 : 0; speex_preprocess_ctl(s->preproc, SPEEX_PREPROCESS_GET_AGC_FIXED, &opt); if (newopt ^ opt) { av_log(avf, AV_LOG_INFO, "Changing AGC fixed: %d\n", newopt); speex_preprocess_ctl(s->preproc, SPEEX_PREPROCESS_SET_AGC_FIXED, &newopt); }*/ // denoise different? newopt = (avf->flags & FILTER_FLAG_SPEEX_DENOISER) ? 1 : 0; speex_preprocess_ctl(s->preproc, SPEEX_PREPROCESS_GET_DENOISE, &opt); if (newopt ^ opt) { av_log(avf, AV_LOG_INFO, "Changing Denoiser: %d\n", newopt); speex_preprocess_ctl(s->preproc, SPEEX_PREPROCESS_SET_DENOISE, &newopt); } avf->vad = speex_preprocess(s->preproc, in, spectral); avf->loudness = (int) s->preproc->loudness2; av_log(avf, AV_LOG_DEBUG, "Speex preproc: current speex frame has (vad: %d, loudness: %d)\n", avf->vad, (int) avf->loudness); return 0; }
static void set_speex_filters() { int i; if ( !st ) return; i = 1; /* always make VAD decision */ speex_preprocess_ctl(st, SPEEX_PREPROCESS_SET_VAD, &i); i = (iaxci_filters & IAXC_FILTER_AGC) ? 1 : 0; speex_preprocess_ctl(st, SPEEX_PREPROCESS_SET_AGC, &i); i = (iaxci_filters & IAXC_FILTER_DENOISE) ? 1 : 0; speex_preprocess_ctl(st, SPEEX_PREPROCESS_SET_DENOISE, &i); /* * We can tweak these parameters to play with VAD sensitivity. * For now, we use the default values since it seems they are a good starting point. * However, if need be, this is the code that needs to change */ i = 35; speex_preprocess_ctl(st, SPEEX_PREPROCESS_SET_PROB_START, &i); i = 20; speex_preprocess_ctl(st, SPEEX_PREPROCESS_SET_PROB_CONTINUE, &i); }
uint16 SpeexPlugin::encode(int16 *sample_buf, uint16 nsamples, uint8 *payload, uint16 payload_size, bool &silence) throw(OperationNotPerfomedException) { if (payload_size < MAX_PAYLOAD_SIZE) throw OperationNotPerfomedException("The buffer is not large enough"); if (!encoder) throw OperationNotPerfomedException("Encoder not ready"); // // Falta fazer o echo cancelling // // // if (usingEchoCancellation && !echoCapturedLast) { // uint32 samplesize = getSampleSize(); // spx_int16_t *input_buf = new spx_int16_t[samplesize / 2]; // // for (int i = 0; i < getSampleSize() / 2; i++) { // input_buf[i] = sample_buf[i]; // } // // speex_echo_capture(echocancellation, input_buf, sample_buf); // echoCapturedLast = true; // delete input_buf; // } bool preprocessing_silence = false; if (preprocess) { preprocessing_silence = !speex_preprocess_run(preprocess, sample_buf); //Garantir que o nsamples sera sempre o mesmo bool speex_dsp_vad; speex_preprocess_ctl(preprocess, SPEEX_PREPROCESS_GET_VAD, &speex_dsp_vad); if (!speex_dsp_vad) preprocessing_silence = false; } silence = false; speex_bits_reset(&encoder->bits); silence = speex_encode_int(encoder->state, sample_buf, &encoder->bits) == 0; silence = silence || preprocessing_silence; return speex_bits_write(&encoder->bits, (char *) payload, payload_size); }
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); }
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; }
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; }
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; }
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); }