基于FreeSwitch插件实现静音检测（VAD）和语音识别（ASR）

已于 2022-07-07 12:13:33 修改
阅读量4.3k 收藏 19
点赞数 3
分类专栏： FreeSwitch C++ 文章标签： c++ 语音识别
于 2022-07-04 15:53:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shanghaimoon/article/details/125601441
版权

个人长期从事通信语音方面的产品开发工作，且近期打算开发一款智能机器人语音通信产品，由于产品的主体是基于目前广泛使用的FreeSwitch软交换开源系统，因此基于FreeSwitch的插件技术开发一些智能语音机器人的基础模块是比较理想的选择。

本文主要就语音机器人的两个核心功能静音检测（VAD）和语音识别（ASR）来完成这一款插件。插件主要是通过FreeSwitch的media bug技术实时获取语音流，然后通过抽取opus的VAD检测算法进行静音检测，最后对接了科大讯飞的实时语音转写接口实现了ASR识别，结果通过ESL事件方式上报给应用层使用。整体效果测试下来比较理想，响应速度快，识别准确率高。有需要的朋友可以参考实现。核心的代码展示如下：


#define DR_WAV_IMPLEMENTATION

#include <switch.h>
#include "dr_wav.h"
#include "opusvad.h"
#include "queue.h"
#include "xfasr.h"

#define VAD_EVENT_START "vad::start"
#define VAD_EVENT_STOP "vad::stop"
#define VAD_EVENT_ASR "vad::asr"

static switch_bool_t robot_callback(switch_media_bug_t *bug, void *user_data, switch_abc_type_t type);

#define MAX_VOICE_LEN 240000
#define MAX_VOICE_LEN_BASE64 645000
#define MAXFILES 8
#define TTS_MAX_SIZE 900
#define MAX_HZ_SIZE 240
#define VAD_VOICE_FRAMES 5 
#define VAD_SILINCE_FRAMES 50
#define VAD_HIS_LEN 100
#define VAD_ADD_FRAME_SIZE 5

static struct {
	char* appid;
	char* appkey;
} globals;


typedef struct robot_session_info {
	int index;
	int filetime;
	int fileplaytime;
	int nostoptime;
	int asrtimeout;
	int asr;
	int play, pos;
	int sos, eos, ec, count;
	int eos_silence_threshold;
	int final_timeout_ms;
	int silence_threshold; 
	int harmonic;
	int monitor;
	int lanid;
	int vadvoicems;
	int vadsilencems;
	int nslevel;
	switch_core_session_t *session;
	char taskid[32];
	char groupid[32];
	char telno[32];
	char userid[64];
	char callid[64];
	char orgi[64];
	char extid[64];
	char uuid[64];
	char uuidbak[64];
	char recordfilename[128];
	char para1[256];
	char para2[256];
	char para3[256];
	char filename[TTS_MAX_SIZE];
	char vadfilename[TTS_MAX_SIZE];
	short buffer[MAX_VOICE_LEN];
	drwav *fwav;
	drwav *fvadwav; 
	int state; // 0:silence 1:voice
	queue *vadqueue;
	int16_t *vadbuffer;
	int16_t framecount;
	switch_audio_resampler_t  *resampler;
	asr_session_t *asrsession;

} robot_session_info_t;


SWITCH_BEGIN_EXTERN_C

SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_vadasr_shutdown);
SWITCH_MODULE_LOAD_FUNCTION(mod_vadasr_load);
SWITCH_MODULE_DEFINITION(mod_vadasr, mod_vadasr_load, mod_vadasr_shutdown, NULL);
SWITCH_STANDARD_APP(robotasr_start_function);

SWITCH_MODULE_LOAD_FUNCTION(mod_vadasr_load)
{

	switch_application_interface_t *app_interface;
	char *cf = "asr.conf";
	switch_xml_t cfg, xml, settings, param;

	memset(&globals, 0, sizeof(globals));
	globals.appid = NULL;
	globals.appkey = NULL;

	if (switch_event_reserve_subclass(VAD_EVENT_START) != SWITCH_STATUS_SUCCESS) {
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Robot Couldn't register subclass %s!\n",
			VAD_EVENT_START);
		return SWITCH_STATUS_TERM;
	}

	if (switch_event_reserve_subclass(VAD_EVENT_STOP) != SWITCH_STATUS_SUCCESS) {
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Robot Couldn't register subclass %s!\n",
			VAD_EVENT_STOP);
		return SWITCH_STATUS_TERM;
	}

	if (switch_event_reserve_subclass(VAD_EVENT_ASR) != SWITCH_STATUS_SUCCESS) {
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Robot Couldn't register subclass %s!\n",
			VAD_EVENT_ASR);
		return SWITCH_STATUS_TERM;
	}

	/* connect my internal structure to the blank pointer passed to me */
	*module_interface = switch_loadable_module_create_module_interface(pool, modname);

	if (!(xml = switch_xml_open_cfg(cf, &cfg, NULL))) {
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Open of %s failed\n", cf);
	}
	else {
		if ((settings = switch_xml_child(cfg, "settings"))) {
			for (param = switch_xml_child(settings, "param"); param; param = param->next) {
				char *var = (char *)switch_xml_attr_soft(param, "name");
				char *val = (char *)switch_xml_attr_soft(param, "value");
				if (!strcmp(var, "appid")) {
					globals.appid = val;
				}
				if (!strcmp(var, "appkey")) {
					globals.appkey = val;
				}
			}
		}

		switch_xml_free(xml);
	}

	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Robot enabled,appid=%s,appkey=%s\n", globals.appid, globals.appkey);

	// 为此模块增加app，调用名称即为 vad
	SWITCH_ADD_APP(app_interface, "vad", "vad", "ai robot", robotasr_start_function, "[<ACTION ><VAD_VOICE_FRAMES> <VAD_SILINCE_FRAMES> <NS_LEVEL>]", SAF_NONE);

	/* indicate that the module should continue to be loaded */
	return SWITCH_STATUS_SUCCESS;
}

//  Called when the system shuts down
SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_vadasr_shutdown)
{
	switch_event_free_subclass(VAD_EVENT_START);
	switch_event_free_subclass(VAD_EVENT_STOP);
	switch_event_free_subclass(VAD_EVENT_ASR);
	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "myapplication disabled\n");
	return SWITCH_STATUS_SUCCESS;
}

SWITCH_STANDARD_APP(robotasr_start_function)
{
	switch_media_bug_t *bug;
	switch_status_t status;
	switch_channel_t *channel;
	robot_session_info_t *robot_info;

	// switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "robot_start_function start\n");
	if (session == NULL) {
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR,
			"FreeSWITCH is NULL! Please report to developers\n");
		return;
	}
	channel = switch_core_session_get_channel(session);
	if (channel == NULL) {
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR,
			"No channel for FreeSWITCH session! Please report this "
			"to the developers.\n");
		return;
	}

	/* Is this channel already set? */
	bug = (switch_media_bug_t *)switch_channel_get_private(channel, "_robot_");

	/* If yes */

	if (bug != NULL) {

		/* If we have a stop remove audio bug */
		if (strcasecmp(data, "stop") == 0) {
			// robot_info = (robot_session_info_t *)switch_channel_get_private(channel, "_robotinfo_");
			switch_channel_set_private(channel, "_robot_", NULL);
			// process_close(robot_info);
			switch_core_media_bug_remove(session, &bug);
			return;
		}
		/* We have already started */
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING,
			"Robot Cannot run 2 at once on the same channel!\n");
		return;
	}

	const char *action = NULL, *vadvoicems = NULL, *vadsilencems = NULL, *nslevel = NULL;
	char *argv[4] = { 0 };
	char *mycmd = NULL;

	if (!zstr(data)) {
		mycmd = switch_core_session_strdup(session, data);
		switch_separate_string(mycmd, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
	}

	if (argv[0]) action = argv[0];
	if (argv[1]) vadvoicems = argv[1];
	if (argv[2]) vadsilencems = argv[2];
	if (argv[3]) nslevel = argv[3];

	if (!action || !vadvoicems || !vadsilencems || !nslevel) {
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "-ERR Missing Arguments\n");
		return;
	}

	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO,
		"action %s vadvoicems %s vadsilencems %s nslevel %s\n", action, vadvoicems, vadsilencems,
		nslevel);

	// 初始化变量， 一定记得要 free掉
	robot_info = (robot_session_info_t *)malloc(sizeof(robot_session_info_t));
	if (robot_info == NULL) return;
	robot_info->session = session;
	strcpy(robot_info->uuid, switch_core_session_get_uuid(robot_info->session));
	robot_info->vadvoicems = atoi(vadvoicems);
	robot_info->vadsilencems = atoi(vadsilencems);
	robot_info->nslevel = atoi(nslevel);

	status = switch_core_media_bug_add(session, "vmd", NULL, robot_callback, robot_info, 0, SMBF_READ_REPLACE, &bug);

	if (status != SWITCH_STATUS_SUCCESS) {
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Robot Failure hooking to stream\n");
		return;
	}
	switch_channel_set_private(channel, "_robot_", bug);
}

SWITCH_END_EXTERN_C


static switch_bool_t process_close(robot_session_info_t *rh)
{
	switch_channel_t *channel;

	rh->uuid[0] = 0;
	rh->index = -1;
	if (NULL != rh->fwav) { drwav_uninit(rh->fwav); }
	if (NULL != rh->fvadwav) { drwav_uninit(rh->fvadwav); }
	destroy_queue(rh->vadqueue);
	channel = switch_core_session_get_channel(rh->session);
	switch_channel_set_private(channel, "_robot_", NULL);
	delete rh->asrsession;
	free(rh);
	return SWITCH_TRUE;
}



void handle_event(const std::string & message, void *arg)
{
	switch_event_t *event;
	switch_status_t status;
	switch_event_t *event_copy;
	switch_channel_t *channel;

	robot_session_info_t *robot_info = (robot_session_info_t *)arg;
	channel = switch_core_session_get_channel(robot_info->session);

	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "eventAsrText:%s\n", message.c_str());

	status = switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, VAD_EVENT_ASR);
	if (status != SWITCH_STATUS_SUCCESS) { return; }

	switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Asr-Text", message.c_str());
	switch_channel_event_set_data(channel, event);
	switch_event_fire(&event);
}

void handle_message(const std::string & message, void *arg)
{
	char middleText[500] = { 0 };
	//printf(">>> %s\n", message.c_str());
	cJSON* cjson_test = NULL;
	cJSON* cjson_action = NULL;
	cJSON* cjson_code = NULL;
	cJSON* cjson_data = NULL;
	cJSON* cjson_desc = NULL;
	cJSON* cjson_sid = NULL;
	cJSON* cjson_text = NULL;
	cJSON* cjson_segid = NULL;
	cJSON* cjson_cn = NULL;
	cJSON* cjson_st = NULL;
	cJSON* cjson_rt = NULL;
	cJSON* cjson_rt_item = NULL;
	cJSON* cjson_cw_item = NULL;
	cJSON* cjson_w_item = NULL;
	cJSON* cjson_type = NULL;
	cJSON* cjson_ws = NULL;
	cJSON* cjson_cw = NULL;
	cJSON* cjson_w = NULL;

	asr_session_t *asr = (asr_session_t *)arg;

	cjson_test = cJSON_Parse(message.c_str());
	cjson_action = cJSON_GetObjectItem(cjson_test, "action");
	cjson_code = cJSON_GetObjectItem(cjson_test, "code");
	cjson_data = cJSON_GetObjectItem(cjson_test, "data");
	cjson_desc = cJSON_GetObjectItem(cjson_test, "desc");
	cjson_sid = cJSON_GetObjectItem(cjson_test, "sid");

	if (strcmp(cjson_action->valuestring, "result") == 0 && strcmp(cjson_code->valuestring, "0") == 0 && strlen(cjson_data->valuestring) > 0)
	{
		cjson_text = cJSON_Parse(cjson_data->valuestring);
		cjson_segid = cJSON_GetObjectItem(cjson_text, "seg_id");
		cjson_cn = cJSON_GetObjectItem(cjson_text, "cn");
		cjson_st = cJSON_GetObjectItem(cjson_cn, "st");
		cjson_rt = cJSON_GetObjectItem(cjson_st, "rt");
		cjson_type = cJSON_GetObjectItem(cjson_st, "type");

		if (strcmp(cjson_type->valuestring, "0") == 0)
		{
			int rt_array_size = cJSON_GetArraySize(cjson_rt);
			//printf("rt_array_size:%d", rt_array_size);
			for (int i = 0; i < rt_array_size; i++)
			{
				cjson_rt_item = cJSON_GetArrayItem(cjson_rt, i);
				cjson_ws = cJSON_GetObjectItem(cjson_rt_item, "ws");

				int ws_array_size = cJSON_GetArraySize(cjson_ws);
				for (int j = 0; j < ws_array_size; j++)
				{
					cjson_cw_item = cJSON_GetArrayItem(cjson_ws, j);
					cjson_cw = cJSON_GetObjectItem(cjson_cw_item, "cw");

					int cw_array_size = cJSON_GetArraySize(cjson_cw);
					for (int k = 0; k < cw_array_size; k++)
					{
						cjson_w_item = cJSON_GetArrayItem(cjson_cw, k);
						cjson_w = cJSON_GetObjectItem(cjson_w_item, "w");
						//printf("w:%s", cjson_w->valuestring);
						if (strlen(asr->asr_text) <= BFLEN - 20)
						{
							strcat(asr->asr_text, cjson_w->valuestring);
						}
						else
						{
							switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "content too long!!!!!!\n");
						}

					}

				}

			}		
			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "asrFinalResult:%s\n", asr->asr_text);

		}
		else
		{
			int rt_array_size = cJSON_GetArraySize(cjson_rt);
			//printf("rt_array_size:%d", rt_array_size);
			for (int i = 0; i < rt_array_size; i++)
			{
				cjson_rt_item = cJSON_GetArrayItem(cjson_rt, i);
				cjson_ws = cJSON_GetObjectItem(cjson_rt_item, "ws");

				int ws_array_size = cJSON_GetArraySize(cjson_ws);
				for (int j = 0; j < ws_array_size; j++)
				{
					cjson_cw_item = cJSON_GetArrayItem(cjson_ws, j);
					cjson_cw = cJSON_GetObjectItem(cjson_cw_item, "cw");

					int cw_array_size = cJSON_GetArraySize(cjson_cw);
					for (int k = 0; k < cw_array_size; k++)
					{
						cjson_w_item = cJSON_GetArrayItem(cjson_cw, k);
						cjson_w = cJSON_GetObjectItem(cjson_w_item, "w");
						strcat(middleText, cjson_w->valuestring);

					}
				}
			}
			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "asrTempResult:%s\n", middleText);
		}
	}
	else if (strcmp(cjson_action->valuestring, "error") == 0 )
	{
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "asrErrorInfo:%s\n", cjson_desc->valuestring);

	}

}

static switch_bool_t robot_callback(switch_media_bug_t *bug, void *user_data, switch_abc_type_t type)
{
	robot_session_info_t *robot_info;
	//	switch_codec_t *read_codec;
	switch_frame_t *frame;
	int flag;
	drwav_data_format format;// = { 0 };
	int16_t len;
	int voiceflagcount;
	int silenceflagcount;
	int nslevel;
	switch_event_t *event;
	switch_status_t status;
	switch_event_t *event_copy;
	char *recorddir = NULL;
	switch_codec_implementation_t read_impl;
	switch_channel_t *channel;

	
	
	robot_info = (robot_session_info_t *)user_data;
	if (robot_info == NULL) { return SWITCH_FALSE; }

	channel = switch_core_session_get_channel(robot_info->session);

	voiceflagcount = robot_info->vadvoicems / 20;
	silenceflagcount = robot_info->vadsilencems / 20;
	nslevel = robot_info->nslevel;

	format.container = drwav_container_riff;
	format.format = DR_WAVE_FORMAT_PCM;
	format.channels = 1;
	format.sampleRate = (drwav_uint32)8000;
	format.bitsPerSample = 16;

	recorddir = switch_core_get_variable_dup("record_prefix");

	switch (type) {

	case SWITCH_ABC_TYPE_INIT:
		sprintf(robot_info->filename, "%s%s.wav", recorddir, robot_info->uuid);
		robot_info->fwav = drwav_open_file_write(robot_info->filename, &format);
		if (!robot_info->fwav) {
			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "full record openfile error %s\n",
				robot_info->filename);
		}

		SetConsoleOutputCP(CP_UTF8); //解决windows控制台输出中文乱码

		robot_info->vadqueue = create_queue();
		robot_info->state = 0;
		robot_info->framecount = 0;
		robot_info->fvadwav = NULL;

		//初始话语音识别
		robot_info->asrsession = new asr_session_t();
		robot_info->asrsession->handle_message = handle_message;		
		robot_info->asrsession->handle_event = handle_event;
		robot_info->asrsession->event_arg = robot_info;

		switch_core_session_get_read_impl(robot_info->session, &read_impl);
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Read imp %u %u.\n", read_impl.samples_per_second, read_impl.number_of_channels);
		status = switch_resample_create(&robot_info->resampler, read_impl.actual_samples_per_second, 16000, 640, SWITCH_RESAMPLE_QUALITY, 1);
		if (status != SWITCH_STATUS_SUCCESS) {
			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unable to allocate resampler\n");
		}

		break; 

	case SWITCH_ABC_TYPE_READ_REPLACE:
		
		if (robot_info->uuid[0] == 0) break;

		//获取语音数据
		frame = switch_core_media_bug_get_read_replace_frame(bug);

		//静音检测
		flag = silk_VAD_Get((const short*)frame->data);
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "vad result %d\n", flag);

		//静音标志缓冲
		len = get_queue_length(robot_info->vadqueue);
		if (len == VAD_HIS_LEN) { delete_queue(robot_info->vadqueue); }
		insert_queue(robot_info->vadqueue, flag, NULL, 0);


		//语音检测
		if (getvadflagcount(robot_info->vadqueue, voiceflagcount, 1) && robot_info->state == 0) {

			robot_info->state = 1;
			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "+++++Speech Detected!!!+++++\n");

			//开启语音识别
			init_asr((char*)globals.appid, (char*)globals.appkey, robot_info->asrsession);

			sprintf(robot_info->vadfilename, "%s%s_%d.wav", recorddir, robot_info->uuid, robot_info->framecount);
			robot_info->fvadwav = drwav_open_file_write(robot_info->vadfilename, &format);
			if (!robot_info->fvadwav) {
				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "vad open file error %s\n",
					robot_info->vadfilename);
				strcpy(robot_info->vadfilename, "");
				//break;
			}
						
			
			status = switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, VAD_EVENT_START);
			if (status != SWITCH_STATUS_SUCCESS) { break; }
			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Vad-Status", "start");
			switch_channel_event_set_data(channel, event);	
			/*if ((switch_event_dup(&event_copy, event)) != SWITCH_STATUS_SUCCESS) { break; }
			switch_core_session_queue_event(robot_info->session, &event);
			switch_event_fire(&event_copy);*/
			switch_event_fire(&event);
		}

		//静音检测
		if (getvadflagcount(robot_info->vadqueue, silenceflagcount, 0) && robot_info->state == 1) {
			robot_info->state = 0;
			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE,
				"-----Silence Detected,Stop Recording!!! FileName:%s.-----\n", robot_info->vadfilename);
			if (robot_info->fvadwav) { drwav_uninit(robot_info->fvadwav); }
			robot_info->fvadwav = NULL;

			status = switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, VAD_EVENT_STOP);
			if (status != SWITCH_STATUS_SUCCESS) { break; }
			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Vad-Status", "stop");
			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Vad-RecordFile", robot_info->vadfilename);
			switch_channel_event_set_data(channel, event);
			switch_event_fire(&event);
		    
			//发送Asr结束标记
			send_end(robot_info->asrsession);
		}

		//录音-vad部分
		if (robot_info->fvadwav) { drwav_write_pcm_frames(robot_info->fvadwav, frame->samples, frame->data); }
		//完整部分
		if (robot_info->fwav){ drwav_write_pcm_frames(robot_info->fwav, frame->samples, frame->data); }
		robot_info->framecount++;
		
		//检测到语音时发送语音数据包
		if(robot_info->state == 1)
		{
			//上采样至16K
			switch_resample_process(robot_info->resampler, (int16_t *)frame->data, frame->datalen);
			send_data(robot_info->asrsession, (char*)robot_info->resampler->to, robot_info->resampler->to_len);
		}
		break;

	case SWITCH_ABC_TYPE_CLOSE:
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "SWITCH_ABC_TYPE_CLOSE\n");
		send_end(robot_info->asrsession);
		thrd_join(robot_info->asrsession->thr, NULL);
		thrd_detach(robot_info->asrsession->thr);
		mtx_destroy(&robot_info->asrsession->mutex);

		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "the asr thread closed!!!\n");

		if (robot_info->resampler)
		{
			switch_resample_destroy(&robot_info->resampler);
		}
		process_close(robot_info);
		break;
	default:
		break;
	}

	switch_safe_free(recorddir);
	return SWITCH_TRUE;
}

代码工程是在Windows下编译通过的，FreeSitch使用的是1.6.20版本，代码基本是标准C和标准C++混合编码的，在Linux下编译不会有太大的改动，大家可以自行处理。

项目已开源到github，地址为：https://github.com/shanghaimoon888/mod_vadasr，如有问题，欢迎添加QQ号：1869731沟通交流。

shanghaimoon
关注
  • 3
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
audio语音相关的基础知识-VAD,ASR,AEC,AGC,BF等
u013250861的博客
08-03 109
有音素之间的间隙，也有静音和语音本身的间隙，为了对数据从时间上进行相对的校准，语音端点检测技术就应运而生了，因此端点检测技术可以决定这种校准的相对精度，使得同一内容的特征更趋于相同，当然，一般情况下是不可能完全相同的。盲源分离的目的是求得源信号的最佳估计，盲辨识的目的是求得传输通道的。这个技术的主要任务是从带有噪声的语音中准确的定位出语音的开始和结束点，因为语音中含有很长的静音，也就是把静音和实际语音分离开来，因为是语音数据的原始处理，所以VAD是语音信号处理过程的关键技术之一。呈现出与会者清晰的声音。
freeswitch基于阿里云的的语音识别检测模块
10-25
本模块已经编译好了 可以直接使用 也有源码在里面 对freeswitch的空号识别有兴趣 已经想学习编写freeswitch模块的人 可以下载看看
Freeswitch之ASR（语音识别）总结大全
Magician的博客
02-26 1万+
在做智能外呼的时候要做智能交互的功能，所以就了解了些ASR相关的功能，这里分享下留下的一些资料。根据FS权威指南中Freeswitch使用的第三方模块进行试验，但是效果很不理想，所以如果你想要一个准确率比较好的效果，就需要自己训练声音模型。 1、使用Pocket Sphinx进行英文语音识别 参考：https://wsonh.com/article/60.html 2、PocketSphinx语音...
用Freeswitch实现智能座席助手的例子
fsliwenjie的博客
03-13 687
这里主要是实现座席通话过程中进行实时语音识别，并把通话的文字显示到座席的工作台界面的功能。智能座席助手的定义是语音识别、自然语言处理、智能对话引擎技术为基础面向联络中心提供坐席应答辅助、实时质检及运营质量监控的系统工具。的程序进行呼入、呼出、识别结果接口返回等更多的控制，这些大家自行按实际情况写程序即可。上图的上部是原有路由，下部分是改造后的路由，增加了红色的Freeswitch。服务器，语音识别使用讯飞，也可以使用其它阿里、腾讯、百度等，都一样。实现这个功能，不影响原有的呼叫中心。识别系统进行实时识别；
基于Freeswitch对接免费的ASR语音识别引擎
shanghaimoon的专栏
11-30 2812
目前大部分的只能呼叫中心系统都对接了ASR语音识别引擎，主流的识别引擎有科大讯飞，阿里，百度等大厂的产品，价格不菲，有没有什么免费的引擎可以使用呢，答案是肯定的。
freeswitch 使用 silero-vad 静音拆分使用 fastasr 识别
Java_lilin的专栏
06-10 3248
silero-vad 在git 的评分挺高的测试好像比webrtc vad好下面测试下silero-vad 支持c++ 和py 由于识别c的框架少下面使用py以下基于python3.8+torch1.12.0+torchaudio 1.12.0。
FreeSWITCH vad 模块介绍
热门推荐
FreeSWITCH二次开发-CTI接口
01-19 1万+
介绍 mod_vad是一个freeswitch的模块，实现VAD录音和放音支持打断。 下载 mod_vad 安装 libmyauth.so copy 到 fs/ib 目录 一般是 /usr/local/freeswitch/lib mod_vad.so copy 到fs/mod 目录/usr/local/freeswitch/mod machinecode chmod +x ...
freeswitch对接讯飞语音识别模块
09-19
freeswitch对接讯飞语音识别模块源码分享，从头开始编译
freeswitch对接google的语音识别和语音合成例子
03-28
本示例主要关注的是如何利用Freeswitch与Google的先进语音技术进行集成，包括语音识别（Automatic Speech Recognition, ASR）和语音合成（Text-to-Speech, TTS）。 首先，让我们深入理解`mod_google_tts`和`mod_...
freeswitch使用阿里3.x新版sdk对接阿里语音识别
03-28
阿里云ASR（Automatic Speech Recognition，语音识别）服务是阿里巴巴提供的先进语音处理技术，能够将语音转换为文本，极大地推动了语音交互的发展。本文将详细介绍如何使用阿里云3.x新版SDK在Freeswitch中对接阿里...
FreeSWITCH中文语音文挡
11-06
软交换机FreeSWITCH缺省语音的中文语音文挡包,mono8bit,替换sounds下相关对应文档即可。 软交换机FreeSWITCH缺省语音的中文语音文挡包,mono8bit,替换sounds下相关对应文档即可。
FreeSwitch media bug获取通话语音流的完整例子
07-25
media bug获取通话语音流的完整例子
freeswitch
01-14
freeswitch的安装包，至于安装教程，网上有很多
FreeSWITCH-ASR:FreeSWITCH ASR应用程式
05-07
FreeSWITCH ASR 模块 最近很多人都对FreeSWITCH和ASR对接比较感谢兴趣，我之前已经做了一个商业模块（商业模块请点击这里），考虑到大部分人，只是研究一下，并不准确购买商业模块，特意做一个开源项目给大家提供一个参考。 第一个版本实现 和FreeSWITCH的直接对接，把识别结果通过ESL输出。 FreeSWITCH技术交流群：21596142 欢迎加群交流 2017-12-10 第一版本代码提交 安装 如果你觉得自己编译太麻烦，可以直接下载我编译好的，放在bin 目录里面。路径请根据自己情况修改。注意只支持x64系统 mod_asr.so 复制到到 FreeSWITCH mod 目录。 cp mod_asr.so /usr/local/freeswitch/mod/,如果是fs1.2,请用fs1.2_mod_asr.so的那个。 librealTimeUnity.so
开发智能语音机器人所需要的Freesiwtch VAD识别模块参数
FaGuangFZJ的博客
06-26 374
在智能语音行业，软件机器人是现在大多数科技企业都所推崇的，特别是那些中小型企业，开发出这样一套设备不需要是相对来说能够承受的，对比智能音箱，智能手机产业，没有供应商的卡脖子和漫天要价，软件层面是这些中小型企业的首要选择。 人工智能呈现迅猛开展态势，其中语音智能电话机器人不断深入更多垂直范畴，高效的客户数据分类，提高意向客户的转化率，电话机器人轻松完成意向指标，更好契合了电销行业对于社会的需求。相较...
freeswitch对接阿里语音识别（非mrcp方式）+简单asr空号检测
大头菜馅馒头
04-12 7528
最近有朋友在搞智能客服系统，他们使用freeswitch作为软交换，有需要对接asr，在尝试了mrcp方式之后，想着能否直接对接，通过http方式或者sdk方式，所以尝试开发了一下对接的mod，发觉还是可行的，主要是仿照阿里sdk中的demo来做，只是具体的细节要自己优化一下。 这里要说明下，以前看了某大佬写的一个mod对.........
介绍 FreeSWITCH mod_simple_vad 模块
最新发布
fs交流的博客
04-24 232
FreeSWITCH mod_simple_vad 模块
FreeSWITCH 电话机器人 VAD 打断 ASR集成 全功能开源代码
FreeSWITCH二次开发-CTI接口
02-28 2493
FreeSWITCH 电话机器人 VAD 打断 ASR集成 全功能开源例子
freeswitch 实现websocket
12-10
FreeSWITCH是一个开源的电话软交换平台，它支持多种通信协议和编解码器。在FreeSWITCH中，可以通过mod_event_socket模块来实现WebSocket协议的支持。 要实现WebSocket协议，需要进行以下步骤： 1. 安装mod_event_socket模块：在FreeSWITCH中，可以通过mod_event_socket模块来实现与外部应用程序的通信。可以通过以下命令安装该模块： ``` sudo apt-get install freeswitch-mod-event-socket ``` 2. 配置mod_event_socket模块：在FreeSWITCH的配置文件中，需要添加以下内容来启用mod_event_socket模块： ``` <load module="mod_event_socket"/> <module name="event_socket"> <param name="listen-ip" value="127.0.0.1"/> <param name="listen-port" value="8084"/> <param name="password" value="ClueCon"/> </module> ``` 其中，listen-ip和listen-port参数指定了mod_event_socket模块监听的IP地址和端口号，password参数指定了连接时需要提供的密码。 3. 启动mod_event_socket模块：可以通过以下命令启动mod_event_socket模块： ``` fs_cli -x "event_socket start" ``` 4. 使用WebSocket连接到FreeSWITCH：可以使用任何支持WebSocket协议的客户端应用程序连接到FreeSWITCH。连接时需要提供以下信息： - WebSocket URL：ws://<FreeSWITCH IP>:<FreeSWITCH WebSocket端口号>/api - 认证信息：ClueCon 连接成功后，可以通过WebSocket协议发送命令给FreeSWITCH，并接收FreeSWITCH的响应。 以上是实现WebSocket协议的基本步骤，具体实现细节可以参考FreeSWITCH的官方文档。如果您有其他问题，请随时提出。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值