speexdsp回声消除模块在android中封装及使用例子

最新推荐文章于 2024-05-21 13:06:00 发布
最新推荐文章于 2024-05-21 13:06:00 发布
阅读量3.8k 收藏 14
点赞数 22
分类专栏： 音视频开发 文章标签： speex android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/q384264619/article/details/106492784
版权

前言

本来我只是个纯写一般app的码农，奈何进了这家以音视频为主的公司。刚进公司时，还有好些牛人都没有离职（在
音视频方面浸淫以久的同事)。那关于音视频方面的什么传输库，h264,aac编解码等方面的事，有专门的人员来写和维
护，我作为移动端的开发人员，只需要用他们提供的传输库，使用他们在pc端的功能模块就可以了。我也可以快乐的
下班。可公司发展不景气（没有挣到钱），接下来你们懂的。（人员各种流失。。。）最后，移动原生开发的就剩下
两人（我也算在里面）。ios方面的开发，全走了。交接工作全给了我了，OMY,我对苹果开发可是啥也不会呀。只希
望公司能接下来招几个搞ios的人吧。。。可是过了很长的时间，都没有招人，慢慢的，我也了解到领导就没有再招人
的意思。。很明显，交接给你了（我），那么ios的工作就你来干了。。。。我真是。。。。好吧，说远了！回到主
题，因为有些android手机对回声消除不太好，老板就要求我能不能解决下这个问题。我去，我是谁，，我在哪。。我
不会呀。但总不能直接说不会吧。只能硬着头皮上了。。

上网

不会没有关系，网上有很多相关的文章，经过查找知道手机端可用方案大概有如下几种：

  • AcousticEchoCanceler（API4.1提供，部分手机不支持）
  • AudioSource.VOICE_COMMUNICATION（使用voip通道录音，不靠谱）
  • webrtc（业界有名的回声消除库，支持跨平台，难点是计算delay时间）
  • SpeexDsp

参考文章：

先谈speex

 说干就干，反正我自己现在（以后）也是没有能力写出回声消除算法的（那都是天才巨人干的事）。我能做的就是站在巨人的肩上。

下载speexdsp

speex现在分成两部分了，主要的speex包含编码解码 ，另外一部分声学处理就是speexdsp专门用来处理回声消除
下传送门:
在这里插入图片描述

解压源代码

在这里插入图片描述

将用红色箭头标识的两文件夹复制到android工程的cpp（jni）目录下的speexdsp目录中:

在这里插入图片描述

这里注意了

复制都完成了，就把libseexdsp中的几个test文件删除，不然会有些麻烦，不删除也没有问题哈。主要是这几个test文件都有main函数。

另外，还得在使用我另外编译iconv中使用的方式先configurate下，生成config.h文件。把这个config.h文件也复制到speexdsp目录的include目录中

export NDK=/Users/xxx/Library/Android/android-ndk-r20

export ANDROID_NDK=/Users/xxx/Library/Android/android-ndk-r20

export NDK=/Users/xxx/Library/Android/android-ndk-r20


export PATH=${PATH}:${ANDROID_NDK}

export PATH=${PATH}:${NDK}

export ANDROID_TOOLS=/Users/xxx/Library/Android/sdk/platform-tools

export ANDROID_HOME=/Users/xxx/Library/Android/sdk


export PATH=${PATH}:${ANDROID_HOME}

export ANDROID_TOOLS

export PATH=${PATH}:${ANDROID_TOOLS}

#PATH=/bin:/usr/bin:/usr/local/bin:${PATH} 

# darwin-x86_64 是Mac的路径，实际按目录结构修改
export PATH="$NDK:$NDK/shader-tools/darwin-x86_64:$NDK/build/tools:$PATH"
# 预设值，待会才生成的目录
export SYSROOT=~/my-android-toolchain/sysroot
export PATH=~/my-android-toolchain/bin:$PATH
export CC=arm-linux-androideabi-gcc   # or export CC=clang
export CXX=arm-linux-androideabi-g++  # or export CXX=clang++
export CXXFLAGS="-lstdc++"
export CPPFLAGS="-lstdc++"
export CC="arm-linux-androideabi-gcc --sysroot=$SYSROOT"
export LD="arm-linux-androideabi-ld"
export AR="arm-linux-androideabi-ar"
export RANLIB="arm-linux-androideabi-ranlib"
export STRIP="arm-linux-androideabi-strip"
export CPP="arm-linux-androideabi-gcc -E"

cd ~

mkdir my-android-toolchain

$NDK/build/tools/make-standalone-toolchain.sh  --arch=arm  --install-dir=~/my-android-toolchain --platform=android-21 --stl=gnustl 

cd ~/Downloads/speexdsp-1.2rc3

./configurate --host=arm-linux-eabi

接下来就是编写CMakeLists.txt及jni中间文件

  1. audio_echo.h
//
// Created by vnetoo on 2020/5/8.
//
#include  "echo_config.h"
#ifndef SPEEX_AUDIO_ECHO_H
#define SPEEX_AUDIO_ECHO_H


#define NN 128           //帧长      一般都是  80,160,320,
#define TAIL 1024        //尾长      一般都是  80*25 ,160*25 ,320*25

#define ECHO_ERROR -1
#define ECHO_OK 0

// defined speexEcho struct
typedef struct SpeexEcho{
  SpeexEchoState* st;
  SpeexPreprocessState* den;
  int aec_init_flag;
  pthread_mutex_t mutex;
  int enable_echo;
  int frame_size;
  int enable_vad;
}SpeexEcho;


/**
* 初始化回声消除
* @param context
* @param frameSize
* @param filterSize
* @param sampleRate
* @return
*/
int echo_init(SpeexEcho* context,const unsigned short frameSize ,const unsigned short filterSize,const unsigned short sampleRate);

/**
* 设置回声消除参数
* @param context
* @param key
* @param value
* @ 0/1
*/
int echo_set_ctl(SpeexEcho* context,const unsigned short key , int value);

/**
* 获取回声消除器的参数
* @param context
* @param key
* @param result
* @return
*/
int echo_get_ctl(SpeexEcho* context,const unsigned short key , void* result);

/***
* 设置噪声参数
* @param context
* @param key
* @param value
* @return
*/
int echo_set_preprocess_ctl(SpeexEcho* context,const unsigned short key , void* value);



int echo_get_preprocess_ctl(SpeexEcho* context,const unsigned short key , void* value);

/***
* 处理数据
* @param context
* @param near mic数据
* @param far  播放数据
* @param out  处理之后的数据
* @return
*/
int echo_sync_process(const SpeexEcho* context,unsigned short* near,unsigned short* far, unsigned short* out,size_t size);

int echo_denoise_only(const SpeexEcho* context,unsigned short* near);


int echo_asyn_process_near(const SpeexEcho* context,unsigned short* near,unsigned short *out);

int echo_asyn_process_far(const SpeexEcho* context,unsigned short* far);

/**
* 清除，释放
*/
void echo_distroy(SpeexEcho* context);


#endif //SPEEX_AUDIO_ECHO_H
  1. audio_echo.c
//
// Created by vnetoo on 2020/5/8.
//

#include "include/audio_echo.h"

int echo_init(SpeexEcho *context, const unsigned short frameSize, const unsigned short filterSize,
             const unsigned short sampleRate) {

   pthread_mutex_lock(&(context->mutex));

   unsigned short fs = frameSize;
   if (fs <= 0) {
       return ECHO_ERROR;
   }

   unsigned short fl = filterSize;

   if (fl <= 0) {
       return ECHO_ERROR;
   }

   int mSampleRate = sampleRate;

   if(mSampleRate<=0){
       return ECHO_ERROR;
   }

   context->st = speex_echo_state_init(fs, fl);
   ASSERT(context->st != NULL, "init echo error");
   if (context->st == NULL) {
       LOGE("init echo error with frameSize:%d,filterSize:%d", fs, fl);
       return ECHO_ERROR;
   }
   context->den = speex_preprocess_state_init(fs, sampleRate);
   ASSERT(context->den != NULL, "init preprocess with sampleRate: %d, error", mSampleRate);

   int flag = -1;

   flag = speex_echo_ctl(context->st, SPEEX_ECHO_SET_SAMPLING_RATE, &mSampleRate);

   ASSERT(flag == 0, "set sampleRate for echo error");

   flag = speex_preprocess_ctl(context->den, SPEEX_PREPROCESS_SET_ECHO_STATE, context->st);

   ASSERT(flag == 0, "set  aec proprocess to st error")

   context->aec_init_flag = flag == 0 ? 1 : 0;
   pthread_mutex_unlock(&(context->mutex));
   LOGI("init speex aec success");
   return ECHO_OK;

}


int echo_set_ctl(SpeexEcho *context, const unsigned short key, int value) {
   ASSERT(context != NULL, "speexEcho is NULL")
   if (context != NULL && context->aec_init_flag == 1) {
       int result = speex_echo_ctl(context->st, key, &value);
       if (result == 0) {
           return ECHO_OK;
       } else {
           LOGE("set speex_echo_ctl(%d,%d) unknow key", key, value);
       }

   }
   return ECHO_ERROR;
}

int echo_get_ctl(SpeexEcho *context, const unsigned short key, void *result) {
   ASSERT(context != NULL, "speexEcho is NULL")
   if (context != NULL && context->aec_init_flag == 1) {
       int result = speex_echo_ctl(context->st, key, &result);
       if (result == 0) {
           return ECHO_OK;
       } else {
           LOGE("get speex_echo_ctl(%d,%d) unknow key", key, result);
       }

   }
   return ECHO_ERROR;
}

int echo_set_preprocess_ctl(SpeexEcho *context, const unsigned short key, void *value) {
   ASSERT(context != NULL, "speexEcho is NULL")
   if (context != NULL && context->aec_init_flag == 1) {
       pthread_mutex_lock(&(context->mutex));
       int result = speex_preprocess_ctl(context->den, key, value);
       if(key == SPEEX_PREPROCESS_SET_NOISE_SUPPRESS){
           int* v = (int*)value;
           LOGI("SPEEX_PREPROCESS_SET_NOISE_SUPPRESS=>%d result:%d",*v,result);

       }else if(key == SPEEX_PREPROCESS_SET_DENOISE){
           int* v = (int*)value;
           LOGI("SPEEX_PREPROCESS_SET_DENOISE=>%d result:%d",*v,result);
       }
       else if(key == SPEEX_PREPROCESS_SET_AGC){
           int* v = (int*)value;
           LOGI("SPEEX_PREPROCESS_SET_AGC=>%d result:%d",*v,result);
       }else if(key == SPEEX_PREPROCESS_SET_DEREVERB){
           int* v = (int*)value;
           LOGI("SPEEX_PREPROCESS_SET_DEREVERB=>%d result:%d",*v,result);
       }else if(key == SPEEX_PREPROCESS_SET_VAD){
           int* v = (int*)value;
           &context->enable_vad == *v;
           LOGI("SPEEX_PREPROCESS_SET_VAD=>%d result:%d",*v,result);
       }else if(key == SPEEX_PREPROCESS_SET_NOISE_SUPPRESS){
           int* v = (int*)value;
           LOGI("SPEEX_PREPROCESS_SET_NOISE_SUPPRESS=>%d result:%d",*v,result);
       }else if(key == SPEEX_PREPROCESS_SET_AGC_LEVEL){
           int* v = (int*)value;
           LOGI("SPEEX_PREPROCESS_SET_AGC_LEVEL=>%d result:%d",*v,result);
       }
       pthread_mutex_unlock(&(context->mutex));
       if (result == 0) {
           return ECHO_OK;
       } else {
           LOGE("set echo_set_preprocess_ctl(%d) unknow key", key);
       }
   }
   return ECHO_ERROR;
}

int echo_get_preprocess_ctl(SpeexEcho *context, const unsigned short key, void *result) {
   ASSERT(context != NULL, "speexEcho is NULL")
   if (context != NULL && context->aec_init_flag == 1) {
       int ret = speex_preprocess_ctl(context->den, key, result);
       if (ret == 0) {
           return ECHO_OK;
       } else {
           LOGE("get echo_set_preprocess_ctl(%d) unknow key", key);
       }
   }
   return ECHO_ERROR;
}

int echo_sync_process(const SpeexEcho *context, unsigned short *near, unsigned short *far,
                     unsigned short *out,size_t size) {
   ASSERT(context != NULL, "speexEcho is NULL")
   ASSERT(near != NULL, "mic record data is NULL")
   ASSERT(far != NULL, "playData is NULL")
   ASSERT(out != NULL, "outputBuffer is NULL")

   if (context != NULL && context->aec_init_flag == 1) {
       pthread_mutex_lock(&(context->mutex));
       // speex_preprocess_run(context->den, far);
       speex_echo_cancellation(context->st, near, far, out);
       int result = speex_preprocess_run(context->den, out);
       pthread_mutex_unlock(&(context->mutex));
       return result;
   }
   return ECHO_ERROR;

}

int echo_denoise_only(const SpeexEcho* context,unsigned short* near){
   ASSERT(near != NULL, "near data is NULL")
   pthread_mutex_lock(&(context->mutex));
   int result = speex_preprocess_run(context->den, near);
   pthread_mutex_unlock(&(context->mutex));
   return result;
}

int echo_asyn_process_near(const SpeexEcho* context,unsigned short* near,unsigned short *out){
   if (context != NULL && context->aec_init_flag == 1) {
       pthread_mutex_lock(&(context->mutex));
       speex_echo_capture(context->st,near,out);
       pthread_mutex_unlock(&(context->mutex));
       return ECHO_OK;
   }
   return ECHO_ERROR;
}

int echo_asyn_process_far(const SpeexEcho* context,unsigned short* far){
   if (context != NULL && context->aec_init_flag == 1) {
       pthread_mutex_lock(&(context->mutex));
       speex_echo_playback(context->st,far);
       pthread_mutex_unlock(&(context->mutex));
       return ECHO_OK;
   }
   return ECHO_ERROR;
}

void echo_distroy(SpeexEcho *context) {
   if (context != NULL && context->aec_init_flag == 1) {
       pthread_mutex_lock(&(context->mutex));
       speex_preprocess_state_destroy(context->den);
       speex_echo_state_destroy(context->st);
       context->aec_init_flag = 0;
       pthread_mutex_unlock(&(context->mutex));
       LOGE("release speex echo");
   }
}
  1. echo_jni.c
//
// Created by vnetoo on 2020/5/8.
//

#include <stdlib.h>
#include <assert.h>
#include <jni.h>
#include <string.h>
#include <pthread.h>

#include "include/audio_echo.h"

#define ClassName "com/vnetoo/speex/echo/SpeexEcho"

#define EchoPk(method) Java_com_vnetoo_speex_echo_SpeexEcho_##method

static SpeexEcho echo;

static short *out;

int debug = 1;

inline void throwException(JNIEnv *env, const char *clasz, const char *errorMsg);

void throwException(JNIEnv *env, const char *clasz, const char *errorMsg) {
   jclass newExcCls;

   (*env)->ExceptionDescribe(env);

   (*env)->ExceptionClear(env);

   newExcCls = (*env)->FindClass(env, clasz);
   if (newExcCls != NULL) {
       (*env)->ThrowNew(env, newExcCls, errorMsg);
   }

}


JNIEXPORT jint JNICALL
EchoPk(aecInit)(JNIEnv *env, jclass jclasz, jint frameSize, jint filterSize, jint sampleRate) {

   int result = echo_init(&echo, frameSize, filterSize, sampleRate);

   if (result == ECHO_ERROR) {

       throwException(env, "java/lang/IllegalStateException", "init aec error");

   }

   echo.frame_size = frameSize;
   LOGI("speex jni init aec success");

   return result;
}

JNIEXPORT jint JNICALL
EchoPk(aec_1set_1feature)(JNIEnv *env, jclass jclasz, jint key, jint value) {
   if (echo.aec_init_flag) {
       return echo_set_ctl(&echo, key, value);
   }
   return ECHO_ERROR;
}


JNIEXPORT jint JNICALL
EchoPk(aec_1set_1other_1feature__II)(JNIEnv *env, jclass clazz,
                                    jint key, jint value) {
   if (echo.aec_init_flag) {
       int v = value;
       return echo_set_preprocess_ctl(&echo, key, &v);
   }
   return ECHO_ERROR;
}

JNIEXPORT jint JNICALL
EchoPk(aec_1set_1other_1feature__IF)(JNIEnv *env, jclass clazz,
                                    jint key, jfloat value) {
   if (echo.aec_init_flag) {
       float v = value;
       return echo_set_preprocess_ctl(&echo, key, &v);
   }
   return ECHO_ERROR;
}

JNIEXPORT jint JNICALL
EchoPk(aec_1process)(JNIEnv *env, jclass clazz, jbyteArray near,
                    jbyteArray far,jbyteArray out) {
   jbyteArray ret = NULL;
   jbyte *nearData = (*env)->GetByteArrayElements(env, near, JNI_FALSE);
   jbyte *fearData = (*env)->GetByteArrayElements(env, far, JNI_FALSE);
   jbyte *outData = (*env)->GetByteArrayElements(env, out, JNI_FALSE);
   int result = 0;
   bool needRet = false;
   if(echo.enable_echo == 1){
       result= echo_sync_process(&echo, nearData, fearData, outData, echo.frame_size);
       LOGI("echo canncel :%d", result );
   }
   else{
       result = echo_denoise_only(&echo,nearData);
       LOGI("echo_denoise_only:%d", result );
   }
   (*env)->ReleaseByteArrayElements(env, near, nearData, JNI_FALSE);
   (*env)->ReleaseByteArrayElements(env, far, fearData, JNI_FALSE);
   (*env)->ReleaseByteArrayElements(env, out, outData, JNI_FALSE);
   return result;
}

JNIEXPORT void JNICALL
EchoPk(destory)(JNIEnv *env, jclass clazz) {
   // pthread_mutex_lock(&(echo.mutex));
   echo_distroy(&echo);
   free(out);
   // pthread_mutex_unlock(&(echo.mutex));
   out = NULL;
}

JNIEXPORT jint JNICALL
EchoPk(aec_1set_1enable_1echo)(JNIEnv *env, jclass clazz,
                              jboolean enable) {
   pthread_mutex_lock(&(echo.mutex));
   echo.enable_echo = enable ? 1 : 0;
   LOGI("echo.enable_echo=%d", echo.enable_echo);
   pthread_mutex_unlock(&(echo.mutex));
   return ECHO_OK;
}

JNIEXPORT jfloat JNICALL
EchoPk(aec_1get_1other_1float_1feature)(JNIEnv *env, jclass clazz,

                                       jint key) {
   pthread_mutex_lock(&(echo.mutex));
   float value = 0;
   echo_get_preprocess_ctl(&(echo),key,&value);
   pthread_mutex_unlock(&(echo.mutex));
   return value;
}

JNIEXPORT jint JNICALL
EchoPk(aec_1get_1other_1int_1feature)(JNIEnv *env, jclass clazz,
                                     jint key) {
   pthread_mutex_lock(&(echo.mutex));
   int  value = 0;
   echo_get_preprocess_ctl(&(echo),key,&value);
   pthread_mutex_unlock(&(echo.mutex));
   return value;
}

JNIEXPORT jint JNICALL
Java_com_vnetoo_speex_echo_SpeexEcho_ProcessStream(JNIEnv *env, jclass clazz, jbyteArray data,
                                                  jint offset, jint len) {


   jbyte *nearData = (*env)->GetByteArrayElements(env, data, JNI_FALSE);
       short*  out = (short*)malloc(len);
       memset(out,0,len);
       echo_asyn_process_near(&echo,nearData,out);
       memcpy(nearData,out,len);
       free(out);

   (*env)->ReleaseByteArrayElements(env, data, nearData, JNI_FALSE);
   return 0;
}

JNIEXPORT jint JNICALL
Java_com_vnetoo_speex_echo_SpeexEcho_ProcessReverseStream(JNIEnv *env, jclass clazz,
                                                         jbyteArray far_end, jint offset,
                                                         jint len) {

   jbyte *nearData = (*env)->GetByteArrayElements(env, far_end, JNI_FALSE);

       echo_asyn_process_far(&echo,nearData);

   (*env)->ReleaseByteArrayElements(env, far_end, nearData, JNI_FALSE);
   return 0;
}
  1. SpeexEcho.java
package com.vnetoo.speex.echo;

class SpeexEcho {

   public static native int aecInit(int frame_size, int filter_length, int sampling_rate) throws IllegalStateException;

   public static native  int aec_set_enable_echo(boolean enable);

   public static native int aec_set_feature(int key,int value);

   public static native int aec_set_other_feature(int key,int  value);

   public static native int aec_set_other_feature(int key,float value);

   public static native float aec_get_other_float_feature(int key);

   public static native int  aec_get_other_int_feature(int key);

   public static native int aec_process(byte[] near, byte[] far,byte[] out);

   public static  native int ProcessStream(byte[] data,int offset, int len);

   public static  native int ProcessReverseStream(byte[] far_end,int offset, int len);




   public static native void destory();

   // public static native int aec_get_feature(int key);

   /**
    * Set preprocessor denoiser state
    */
   public static final int SPEEX_PREPROCESS_SET_DENOISE = 0;
   /**
    * Get preprocessor denoiser state
    */
   public static final int SPEEX_PREPROCESS_GET_DENOISE = 1;

   /**
    * Set preprocessor Automatic Gain Control state
    */
   public static final int SPEEX_PREPROCESS_SET_AGC = 2;
   /**
    * Get preprocessor Automatic Gain Control state
    */
   public static final int SPEEX_PREPROCESS_GET_AGC = 3;

   /**
    * Set preprocessor Voice Activity Detection state
    */
   public static final int SPEEX_PREPROCESS_SET_VAD = 4;
   /**
    * Get preprocessor Voice Activity Detection state
    */
   public static final int SPEEX_PREPROCESS_GET_VAD = 5;

   /**
    * Set preprocessor Automatic Gain Control level (float)
    */
   public static final int SPEEX_PREPROCESS_SET_AGC_LEVEL = 6;
   /**
    * Get preprocessor Automatic Gain Control level (float)
    */
   public static final int SPEEX_PREPROCESS_GET_AGC_LEVEL = 7;

   /**
    * Set preprocessor dereverb state
    */
   public static final int SPEEX_PREPROCESS_SET_DEREVERB = 8;
   /**
    * Get preprocessor dereverb state
    */
   public static final int SPEEX_PREPROCESS_GET_DEREVERB = 9;

   /**
    * Set preprocessor dereverb level
    */
   public static final int SPEEX_PREPROCESS_SET_DEREVERB_LEVEL = 10;
   /**
    * Get preprocessor dereverb level
    */
   public static final int SPEEX_PREPROCESS_GET_DEREVERB_LEVEL = 11;

   /**
    * Set preprocessor dereverb decay
    */
   public static final int SPEEX_PREPROCESS_SET_DEREVERB_DECAY = 12;
   /**
    * Get preprocessor dereverb decay
    */
   public static final int SPEEX_PREPROCESS_GET_DEREVERB_DECAY = 13;

   /**
    * Set probability required for the VAD = to go from silence to voice
    */
   public static final int SPEEX_PREPROCESS_SET_PROB_START = 14;
   /**
    * Get probability required for the VAD = to go from silence to voice
    */
   public static final int SPEEX_PREPROCESS_GET_PROB_START = 15;

   /**
    * Set probability required for the VAD = to stay in the voice state (integer percent)
    */
   public static final int SPEEX_PREPROCESS_SET_PROB_CONTINUE = 16;
   /**
    * Get probability required for the VAD = to stay in the voice state (integer percent)
    */
   public static final int SPEEX_PREPROCESS_GET_PROB_CONTINUE = 17;

   /**
    * Set maximum attenuation of the noise in dB = (negative number)
    */
   public static final int SPEEX_PREPROCESS_SET_NOISE_SUPPRESS = 18;
   /**
    * Get maximum attenuation of the noise in dB = (negative number)
    */
   public static final int SPEEX_PREPROCESS_GET_NOISE_SUPPRESS = 19;

   /**
    * Set maximum attenuation of the residual echo in dB = (negative number)
    */
   public static final int SPEEX_PREPROCESS_SET_ECHO_SUPPRESS = 20;
   /**
    * Get maximum attenuation of the residual echo in dB = (negative number)
    */
   public static final int SPEEX_PREPROCESS_GET_ECHO_SUPPRESS = 21;

   /**
    * Set maximum attenuation of the residual echo in dB = when near end is active (negative number)
    */
   public static final int SPEEX_PREPROCESS_SET_ECHO_SUPPRESS_ACTIVE = 22;
   /**
    * Get maximum attenuation of the residual echo in dB = when near end is active (negative number)
    */
   public static final int SPEEX_PREPROCESS_GET_ECHO_SUPPRESS_ACTIVE = 23;

   /**
    * Set the corresponding echo canceller state so that residual echo suppression can be performed (NULL = for no residual echo suppression)
    */
   public static final int SPEEX_PREPROCESS_SET_ECHO_STATE = 24;
   /**
    * Get the corresponding echo canceller state
    */
   public static final int SPEEX_PREPROCESS_GET_ECHO_STATE = 25;

   /**
    * Set maximal gain increase in dB/second (int32)
    */
   public static final int SPEEX_PREPROCESS_SET_AGC_INCREMENT = 26;

   /**
    * Get maximal gain increase in dB/second (int32)
    */
   public static final int SPEEX_PREPROCESS_GET_AGC_INCREMENT = 27;

   /**
    * Set maximal gain decrease in dB/second (int32)
    */
   public static final int SPEEX_PREPROCESS_SET_AGC_DECREMENT = 28;

   /**
    * Get maximal gain decrease in dB/second (int32)
    */
   public static final int SPEEX_PREPROCESS_GET_AGC_DECREMENT = 29;

   /**
    * Set maximal gain in dB = (int32)
    */
   public static final int SPEEX_PREPROCESS_SET_AGC_MAX_GAIN = 30;

   /**
    * Get maximal gain in dB = (int32)
    */
   public static final int SPEEX_PREPROCESS_GET_AGC_MAX_GAIN = 31;

   /*  Can't set loudness */
   /**
    * Get loudness
    */
   public static final int SPEEX_PREPROCESS_GET_AGC_LOUDNESS = 33;

   /*  Can't set gain */
   /**
    * Get current gain (int32 percent)
    */
   public static final int SPEEX_PREPROCESS_GET_AGC_GAIN = 35;

   /*  Can't set spectrum size */
   /**
    * Get spectrum size for power spectrum (int32)
    */
   public static final int SPEEX_PREPROCESS_GET_PSD_SIZE = 37;

   /*  Can't set power spectrum */
   /**
    * Get power spectrum (int32[] of squared values)
    */
   public static final int SPEEX_PREPROCESS_GET_PSD = 39;

   /*  Can't set noise size */
   /**
    * Get spectrum size for noise estimate (int32)
    */
   public static final int SPEEX_PREPROCESS_GET_NOISE_PSD_SIZE = 41;

   /*  Can't set noise estimate */
   /**
    * Get noise estimate (int32[] of squared values)
    */
   public static final int SPEEX_PREPROCESS_GET_NOISE_PSD = 43;

   /* Can't set speech probability */
   /**
    * Get speech probability in last frame (int32).
    */
   public static final int SPEEX_PREPROCESS_GET_PROB = 45;

   /**
    * Set preprocessor Automatic Gain Control level (int32)
    */
   public static final int SPEEX_PREPROCESS_SET_AGC_TARGET = 46;
   /**
    * Get preprocessor Automatic Gain Control level (int32)
    */
   public static final int SPEEX_PREPROCESS_GET_AGC_TARGET = 47;

}

使用及例子及所有源码

我已经将所有源代码上传于github,各位可以自行下载修改，所有speex支持的参数设置，我已经通过jni公开。只是有很多参数

我也是不得要领，不知道有什么作为！

传送门

speexdsp使用手册

官方例子：

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "speex/speex_echo.h"
#include "speex/speex_preprocess.h"
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>


#define NN 128
#define TAIL 1024

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

本地验证呢，这个nn,与tail是最难确认的了。

结束

有人使用speexdsp作了测试，有人说效果可以，实际环境中使用效果如何，有待验证。

兄弟点个赞！！

q384264619
关注
  • 22
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 12
    评论
专栏目录
<开源> 基于Android的SIP电话-----Speex 回音消除 在android 平台
小脸龙的老巢
03-08 2万+
搞了将近一个月的时间，将Speex的编码和解码做好了，发现还不错。 参考API，又尝试了回音消除，发现最新版还提供了用于在多线程中的playback()和capture()，有了这两个函数，就可以避免在线程中不能同步的问题。 结果，发现虽然进行了回音有了部分消除，但是，还是会一点啸叫以及回声，想来还是要做一点处理，譬如去噪，减小播放或者来音的增益。 在使用了speex提供的 preproce
安卓使用speex开源库
里昂的博客
09-03 3085
Speex是一套主要针对语音的开源免费，无专利保护的音频压缩格式。 Speex工程着力于通过提供一个可以替代高性能语音编解码来降低语音应用输入门槛 。 另外，相对于其它编解码器，Speex也很适合网络应用，在网络应用上有着自己独特的优势。 同时，Speex还是GNU工程的一部分，在改版的BSD协议中得到了很好的支持。 它完全是C语言实现的，所以它具有很好的移植性。所以在Android当中具有很好的...
Android 回声消除
hugang的博客
01-22 1302
android speex AEC 回音消除 上面这篇文章，代码简单清晰 Android 回音消除(AcousticEchoCanceler)的使用 java speex回声消除_android 利用speex 音频降噪，回声消除demo android 用speex做回音消除 Speex回声消除原理深度解析 Speex回声消除代码分析 Android 平台语音通话及回音消除、噪音消除研究(转) android、ios、windows等平台回声消除的解决方案 下面几张图是这篇文章的很重要的东西 Spee
SpeexDsp的编译和使用
最新发布
qq_32002563的博客
05-21 370
一开始的时候，看到了configure,以为像其它库一下，可以用configure来进行编译， 花了大半天时间 ，编译成功了， 但是放到项目中， 老是找不到方法的实现，具体原因不知道，不知道是不是这个库的时间比较久，不支持现在NDK的版本怎么我的.configure的脚本写错了， 还是什么原因，没有找到下面给出脚本，看看哪位大佬知道原因的，帮忙修正/bin/bashAPI=21thenfiif [!
speex的下载、编译、测试和在android推流端的集成
wensan911的博客
05-07 2326
目录 一、概述 二、实例 三、总结 一、概述 二、实例 https://github.com/xiph/speex/tree/master，这个是codec库 https://github.com/xiph/speexdsp， 现在只是测试一下speex的去噪部分，下载speexdsp库 选择对应的tag 版本，下载 正在上传…重新上传取消 ./autogen.sh;./configure ;make;sudo make install;sudo ldconfig 然后可以看..
SpeexDSP: 优化音频处理的开源神器
gitblog_00072的博客
04-19 609
SpeexDSP: 优化音频处理的开源神器 项目地址:https://gitcode.com/xiph/speexdsp SpeexDSP 是一个由 Xiph.Org 基金会开发的开源库，专注于音频信号处理。它提供了广泛的功能，包括回声消除、降噪、增益控制、语音活动检测等，为开发者提供了一套强大的工具箱，用于构建高质量的音频通信和处理应用。 技术解析 1. 回声消除 (AEC) SpeexDSP ...
android 利用speex 音频降噪，回声消除demo
11-29
android 利用speex 音频降噪，回声消除demo，提高音频播放质量
快速掌握Node.js模块封装及使用
10-22
主要为大家详细介绍了Node.js模块封装及使用，帮助大家快速掌握Node.js模块封装及使用，感兴趣的小伙伴们可以参考一下
Android中HttpURLConnection与HttpClient的使用与封装
01-05
 本文并不针对HTTP协议的具体内容，仅探讨android开发中使用HTTP协议访问网络的两种方式——HttpURLConnection和HttpClient  因为需要访问网络，需在AndroidManifest.xml中添加如下权限 <uses android:name=...
Node.js模块封装及使用方法
10-22
主要为大家详细介绍了Node.js模块封装及使用方法，感兴趣的朋友可以参考一下
Android-用于简化WebSocket在Android平台使用的封装方法
08-13
本篇文章将详细介绍如何在Android中封装WebSocket以简化其使用。 一、WebSocket简介 WebSocket协议是HTML5标准的一部分，它通过一个TCP连接提供全双工通信，消除了HTTP协议的无状态性和请求-响应模式的限制。相比于...
speex音频噪声抑制
12-03
基于speex开源库实现的噪声抑制，可以直接运行，里面有测试文件
speexdsp-1.2rc3.zip
05-16
speex音频去噪的库，有实例，可以移植。speex是一个很强大的音频处理软件，这一部分是去噪模块，值得研究。
SpeexAudio
02-21
Android demo 生成各个平台的so文件
语音编码解码speex，c代码iOS和Android平台。
qq_17524035的博客
02-16 1919
android ios speex编解码
基于Speex的声学回声消除
热门推荐
叶剑杰的专栏
02-26 1万+
所谓声学回声消除，是为了解决VoIP（网络电话）中这样一个问题：即A与B进行通话，A端有麦克风和扬声器分别用来采集A的声音和播放B的声音，B端有麦克风和扬声器分别用来采集B的声音和播放A的声音，很明显，由于声音传播的特性，A端的麦克风在采集A的声音的同时，也采集到了A端扬声器播放的来自B的声音，也就是A端采集到的声音是一个混合的声音，这个声音通过网络发给B时，B就不仅能听到A的声音，也能听见B前几
speex回声消除源码解读
memath音频算法
01-22 8374
一、speex回声消除aec小析：  频域自适应算法采用了分块处理的思想，以减少高阶自适应滤波器的计算复杂度，多延迟自适应滤波器（MDF)则更一般可以分M块来处理，其中块的长度比自适应滤波器的阶数更小。         后置滤波器系数一直在更新，单讲时前置滤波器用后置滤波器系数更新，双讲时前置滤波器系数不更新。         如果近端远端的数据线性比较好的话，用speex处理回声效果还不错
speex 笔记（二）
朔望两弦的专栏
03-23 1197
单纯从目录结构出发： 最关键的三个目录：doc，libspeex，src doc自不必说 libspeex存放了libspeex，libspeexdsp的源码，以及一些测试源码： testdenoise.c -->测试噪音消除 testecho.c  -->AEC 回声抑制 testenc_uwb.c --> 使用SPEEX_MODEID_UWB初始化编码。 testenc_
speex库音频降噪(含代码)
weixin_30536513的博客
06-07 781
speex库中音频降噪效果不错，应该是应用最广泛的吧，speex库下载地址https://www.speex.org/downloads/，可以直接下载二进制代码使用，像配置OpenCV一样配置speex库就可以了。speex库的API参考文档下载：http://download.csdn.net/detail/yizhaoyanbo/9856894。 贴出C语言实现的音频降噪代码如下。 ...
android中okhttp3封装使用
05-11
OkHttp3是一个非常强大的网络请求框架，它可以方便的实现HTTP/2、SPDY和WebSocket。下面是一个简单的封装使用示例： 1. 在app/build.gradle文件中添加OkHttp3依赖： ``` implementation 'com.squareup.okhttp3:okhttp:4.9.0' ``` 2. 创建一个OkHttpUtil类，封装OkHttp3网络请求： ``` public class OkHttpUtil { private static final OkHttpClient client = new OkHttpClient(); public static void sendRequest(String url, Callback callback) { Request request = new Request.Builder() .url(url) .build(); client.newCall(request).enqueue(callback); } } ``` 3. 在Activity或Fragment中调用OkHttpUtil发送网络请求： ``` OkHttpUtil.sendRequest("http://www.example.com", new Callback() { @Override public void onFailure(Call call, IOException e) { // 网络请求失败 } @Override public void onResponse(Call call, Response response) throws IOException { if (response.isSuccessful()) { // 网络请求成功 String result = response.body().string(); } } }); ``` 这是一个简单的OkHttp3封装示例，你可以根据具体需求增加其他方法，比如POST请求等。
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值