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