AudioInput::~AudioInput() {
bRunning = false;
wait();
if (ceEncoder) {
cCodec->celt_encoder_destroy(ceEncoder);
} else if (esSpeex) {
speex_bits_destroy(&sbBits);
speex_encoder_destroy(esSpeex);
}
foreach(short *buf, qlEchoFrames)
delete [] buf;
if (sppPreprocess)
speex_preprocess_state_destroy(sppPreprocess);
if (sesEcho)
speex_echo_state_destroy(sesEcho);
if (srsMic)
speex_resampler_destroy(srsMic);
if (srsEcho)
speex_resampler_destroy(srsEcho);
delete [] psMic;
delete [] psClean;
delete [] psSpeaker;
delete [] pfMicInput;
delete [] pfEchoInput;
delete [] pfOutput;
}
AudioInput::~AudioInput() {
bRunning = false;
wait();
#ifdef USE_OPUS
if (opusState)
opus_encoder_destroy(opusState);
#endif
if (ceEncoder) {
cCodec->celt_encoder_destroy(ceEncoder);
}
foreach(short *buf, qlEchoFrames)
delete [] buf;
if (sppPreprocess)
speex_preprocess_state_destroy(sppPreprocess);
if (sesEcho)
speex_echo_state_destroy(sesEcho);
if (srsMic)
speex_resampler_destroy(srsMic);
if (srsEcho)
speex_resampler_destroy(srsEcho);
delete [] psMic;
delete [] psClean;
delete [] psSpeaker;
delete [] pfMicInput;
delete [] pfEchoInput;
delete [] pfOutput;
}
static void
AudioQualityImprovement_free(AudioQualityImprovement *aqi)
{
/* mutex */
Mutex_free(aqi->mutex);
/* preprocess */
if (aqi->preprocess)
speex_preprocess_state_destroy(aqi->preprocess);
/* echo */
if (aqi->echo)
speex_echo_state_destroy(aqi->echo);
/* out */
if (aqi->out)
free(aqi->out);
/* play */
if (aqi->play)
free(aqi->play);
/* resampler */
if (aqi->resampler)
speex_resampler_destroy(aqi->resampler);
/* stringID */
free(aqi->stringID);
free(aqi);
}
AudioInput::~AudioInput() {
bRunning = false;
wait();
speex_bits_destroy(&sbBits);
speex_encoder_destroy(esEncState);
mumble_drft_clear(&fftTable);
jitter_buffer_destroy(jb);
if (sppPreprocess)
speex_preprocess_state_destroy(sppPreprocess);
if (sesEcho)
speex_echo_state_destroy(sesEcho);
if (srsMic)
speex_resampler_destroy(srsMic);
if (srsEcho)
speex_resampler_destroy(srsEcho);
delete [] psMic;
delete [] psSpeaker;
delete [] psClean;
if (pfMicInput)
delete [] pfMicInput;
if (pfEchoInput)
delete [] pfEchoInput;
if (pfOutput)
delete [] pfOutput;
}
JNIEXPORT void JNICALL Java_com_pullmi_shanghai_TalkActivity_speex_1EchoCanceller_1close
(JNIEnv *env, jobject jobj)
{
//close
speex_echo_state_destroy(st);
speex_preprocess_state_destroy(den);
}
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;
}
bool SpeexPlugin::disablePreprocessing() throw(OperationNotPerfomedException) {
if (preprocess) {
speex_preprocess_state_destroy(preprocess);
return true;
}
return false;
}
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;
}
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;
}
int speex_filter_close(AVFilterContext *avf)
{
SpeexFilterContext *s = avf->priv_data;
speex_preprocess_state_destroy(s->preproc);
return 0;
}
bool pa_speex_ec_init(pa_core *c, pa_echo_canceller *ec,
pa_sample_spec *rec_ss, pa_channel_map *rec_map,
pa_sample_spec *play_ss, pa_channel_map *play_map,
pa_sample_spec *out_ss, pa_channel_map *out_map,
uint32_t *nframes, const char *args) {
int rate;
uint32_t frame_size_ms, filter_size_ms;
pa_modargs *ma;
if (!(ma = pa_modargs_new(args, valid_modargs))) {
pa_log("Failed to parse submodule arguments.");
goto fail;
}
filter_size_ms = DEFAULT_FILTER_SIZE_MS;
if (pa_modargs_get_value_u32(ma, "filter_size_ms", &filter_size_ms) < 0 || filter_size_ms < 1 || filter_size_ms > 2000) {
pa_log("Invalid filter_size_ms specification");
goto fail;
}
frame_size_ms = DEFAULT_FRAME_SIZE_MS;
if (pa_modargs_get_value_u32(ma, "frame_size_ms", &frame_size_ms) < 0 || frame_size_ms < 1 || frame_size_ms > 200) {
pa_log("Invalid frame_size_ms specification");
goto fail;
}
pa_speex_ec_fixate_spec(rec_ss, rec_map, play_ss, play_map, out_ss, out_map);
rate = out_ss->rate;
*nframes = pa_echo_canceller_blocksize_power2(rate, frame_size_ms);
pa_log_debug ("Using nframes %d, channels %d, rate %d", *nframes, out_ss->channels, out_ss->rate);
ec->params.priv.speex.state = speex_echo_state_init_mc(*nframes, (rate * filter_size_ms) / 1000, out_ss->channels, out_ss->channels);
if (!ec->params.priv.speex.state)
goto fail;
speex_echo_ctl(ec->params.priv.speex.state, SPEEX_ECHO_SET_SAMPLING_RATE, &rate);
if (!pa_speex_ec_preprocessor_init(ec, out_ss, *nframes, ma))
goto fail;
pa_modargs_free(ma);
return true;
fail:
if (ma)
pa_modargs_free(ma);
if (ec->params.priv.speex.pp_state) {
speex_preprocess_state_destroy(ec->params.priv.speex.pp_state);
ec->params.priv.speex.pp_state = NULL;
}
if (ec->params.priv.speex.state) {
speex_echo_state_destroy(ec->params.priv.speex.state);
ec->params.priv.speex.state = NULL;
}
return false;
}
extern "C" JNIEXPORT void Java_com_haitou_xiaoyoupai_imservice_support_audio_Speex_destroyEcho(
JNIEnv * env, jobject jobj) {
if (aec_status == AEC_CLOSED)
return;
aec_status = AEC_CLOSED;
speex_echo_state_destroy(echoState);
speex_preprocess_state_destroy(den);
}
static void volume_uninit(MSFilter *f){
Volume *v=(Volume*)f->data;
#ifdef HAVE_SPEEXDSP
if (v->speex_pp)
speex_preprocess_state_destroy(v->speex_pp);
#endif
ms_bufferizer_destroy(v->buffer);
ms_free(f->data);
}
static void speexpp_destructor(void *arg)
{
struct preproc *st = arg;
if (st->state)
speex_preprocess_state_destroy(st->state);
list_unlink(&st->af.le);
}
extern "C" JNIEXPORT void Java_com_mogujie_tt_support_audio_Speex_destroyEcho(
JNIEnv * env, jobject jobj) {
if (aec_status == AEC_CLOSED)
return;
aec_status = AEC_CLOSED;
speex_echo_state_destroy(echoState);
speex_preprocess_state_destroy(den);
}
int roardsp_speex_prep_uninit (struct roardsp_filter * filter) {
struct roardsp_speex_prep * self = filter->inst;
if ( self->preprocess != NULL )
speex_preprocess_state_destroy(self->preprocess);
roar_mm_free(self);
return 0;
}
static void lintospeex_destroy(struct ast_trans_pvt *arg)
{
struct speex_coder_pvt *pvt = arg->pvt;
#ifdef _SPEEX_TYPES_H
if (preproc)
speex_preprocess_state_destroy(pvt->pp);
#endif
speex_encoder_destroy(pvt->speex);
speex_bits_destroy(&pvt->bits);
}
static int tdav_speex_denoise_close(tmedia_denoise_t* self)
{
tdav_speex_denoise_t *denoiser = (tdav_speex_denoise_t *)self;
if(denoiser->preprocess_state_record){
speex_preprocess_state_destroy(denoiser->preprocess_state_record);
denoiser->preprocess_state_record = tsk_null;
}
if(denoiser->preprocess_state_playback){
speex_preprocess_state_destroy(denoiser->preprocess_state_playback);
denoiser->preprocess_state_playback = tsk_null;
}
if(denoiser->echo_state){
speex_echo_state_destroy(denoiser->echo_state);
denoiser->echo_state = tsk_null;
}
TSK_FREE(denoiser->echo_output_frame);
return 0;
}
static void channel_uninit(Channel *chan){
ms_bufferizer_uninit(&chan->buff);
chan->is_speaking=0;
chan->energy=0;
chan->average_psd=0;
#ifndef DISABLE_SPEEX
if (chan->speex_pp!=NULL)
speex_preprocess_state_destroy(chan->speex_pp);
chan->speex_pp=NULL;
#endif
}
// 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 pa_speex_ec_done(pa_echo_canceller *ec) {
if (ec->params.priv.speex.pp_state) {
speex_preprocess_state_destroy(ec->params.priv.speex.pp_state);
ec->params.priv.speex.pp_state = NULL;
}
if (ec->params.priv.speex.state) {
speex_echo_state_destroy(ec->params.priv.speex.state);
ec->params.priv.speex.state = NULL;
}
}
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;
}
JNIEXPORT jint JNICALL Java_com_ccut_shangri_audiorecorder_IMSpeexDSPAndEnc_close (JNIEnv *env, jobject obj, jint size)
{
if (!codec_open)
return -1;
speex_preprocess_state_destroy(denoise_state);
//exit amr_enc
arm_enc_exit();
codec_open = 0;
}
void destroy_speex_encoder() {
if (gEncoderState != NULL) {
speex_encoder_destroy(gEncoderState);
speex_bits_destroy(&gEncoderBits);
gEncoderState = NULL;
}
if (gPreprocessState)
{
speex_preprocess_state_destroy(gPreprocessState);
gPreprocessState = 0;
}
}
void RakVoice::FreeChannelMemory(unsigned index, bool removeIndex)
{
VoiceChannel *channel;
channel=voiceChannels[index];
speex_encoder_destroy(channel->enc_state);
speex_decoder_destroy(channel->dec_state);
speex_preprocess_state_destroy((SpeexPreprocessState*)channel->pre_state);
rakFree_Ex(channel->incomingBuffer, __FILE__, __LINE__ );
rakFree_Ex(channel->outgoingBuffer, __FILE__, __LINE__ );
RakNet::OP_DELETE(channel, __FILE__, __LINE__);
if (removeIndex)
voiceChannels.RemoveAtIndex(index);
}
static void destroy_callback(void *data)
{
struct speex_info *si = data;
ast_audiohook_destroy(&si->audiohook);
if (si->rx && si->rx->state) {
speex_preprocess_state_destroy(si->rx->state);
}
if (si->tx && si->tx->state) {
speex_preprocess_state_destroy(si->tx->state);
}
if (si->rx) {
ast_free(si->rx);
}
if (si->tx) {
ast_free(si->tx);
}
ast_free(data);
};
static void winsnd_uninit(MSFilter *f){
WinSnd *d=(WinSnd*)f->data;
flushq(&d->rq,0);
flushq(&d->write_rq,0);
#ifndef DISABLE_SPEEX
if (d->pst!=NULL)
speex_preprocess_state_destroy(d->pst);
d->pst=NULL;
d->pst_frame_size=0;
#endif
d->ready=0;
d->workaround=0;
ms_mutex_destroy(&d->mutex);
ms_free(f->data);
}
static void speex_ec_postprocess(MSFilter *f){
SpeexECState *s=(SpeexECState*)f->data;
ms_bufferizer_flush (&s->delayed_ref);
ms_bufferizer_flush (&s->echo);
ms_bufferizer_flush (&s->ref);
if (s->ecstate!=NULL){
speex_echo_state_destroy(s->ecstate);
s->ecstate=NULL;
}
if (s->den!=NULL){
speex_preprocess_state_destroy(s->den);
s->den=NULL;
}
}
/* destructor */
static tsk_object_t* tdav_speex_denoise_dtor(tsk_object_t * self)
{
tdav_speex_denoise_t *denoise = self;
if(denoise){
/* deinit base */
tmedia_denoise_deinit(TMEDIA_DENOISE(denoise));
/* deinit self */
if(denoise->preprocess_state_record){
speex_preprocess_state_destroy(denoise->preprocess_state_record);
denoise->preprocess_state_record = tsk_null;
}
if(denoise->preprocess_state_playback){
speex_preprocess_state_destroy(denoise->preprocess_state_playback);
denoise->preprocess_state_playback = tsk_null;
}
if(denoise->echo_state){
speex_echo_state_destroy(denoise->echo_state);
denoise->echo_state = tsk_null;
}
TSK_FREE(denoise->echo_output_frame);
}
return self;
}
t_audio_rx::~t_audio_rx() {
struct timespec sleeptimer;
if (is_running) {
stop_running = true;
do {
sleeptimer.tv_sec = 0;
sleeptimer.tv_nsec = 10000000;
nanosleep(&sleeptimer, NULL);
} while (is_running);
}
#ifdef HAVE_SPEEX
// cleaning speex preprocessing
if (audio_session->get_do_echo_cancellation()) {
speex_echo_state_reset(audio_session->get_speex_echo_state());
}
speex_preprocess_state_destroy(speex_preprocess_state);
#endif
MEMMAN_DELETE_ARRAY(input_sample_buf);
delete [] input_sample_buf;
MEMMAN_DELETE_ARRAY(payload);
delete [] payload;
MEMMAN_DELETE(audio_encoder);
delete audio_encoder;
// Clean up resources for 3-way conference calls
if (media_3way_peer_tx) {
MEMMAN_DELETE(media_3way_peer_tx);
delete media_3way_peer_tx;
}
if (media_3way_peer_rx) {
MEMMAN_DELETE(media_3way_peer_rx);
delete media_3way_peer_rx;
}
if (mix_buf_3way) {
MEMMAN_DELETE_ARRAY(mix_buf_3way);
delete [] mix_buf_3way;
}
if (dtmf_player) {
MEMMAN_DELETE(dtmf_player);
delete dtmf_player;
}
}
