自学教程：C++ speex_preprocess_ctl函数代码示例

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); //
C++ speex_preprocess_state_destroy函数代码示例
C++ speex_encoder_init函数代码示例