/*
|
* 同时支持任意时刻主副唤醒词打断
|
* 支持任意时刻关闭录音设备
|
*/
|
#include "dui.h"
|
#include "os_log.h"
|
#include "os_stream.h"
|
#include "os_utils.h"
|
#include "os_thread.h"
|
#include "os_queue.h"
|
#include "os_semaphore.h"
|
#include "os_event_group.h"
|
#include "os_mutex.h"
|
#include "recorder.h"
|
#include "dui_fsm.h"
|
#include "os_memory.h"
|
#include "duilite.h"
|
#include "dds.h"
|
#include "dui_msg.h"
|
|
#include "player.h"
|
#include "cJSON.h"
|
|
#include <sys/time.h>
|
#include <ctype.h>
|
#include <string.h>
|
#include <assert.h>
|
#include <stdio.h>
|
|
#ifdef SAVE_AUDIO
|
static FILE *input_fd, *output_fd;
|
#endif
|
|
const char *dui_msg_table[] = {
|
"RECORDER_CMD_START",
|
"RECORDER_CMD_STOP",
|
"PLAYER_CMD_PLAY",
|
"PLAYER_INFO_PLAY_END",
|
"PLAYER_INFO_PLAY",
|
"VAD_CMD_START",
|
"VAD_CMD_STOP",
|
"VAD_CMD_ABORT",
|
"VAD_INFO_TIMEOUT",
|
"VAD_INFO_TIMEOUT_REPEAT",
|
"VAD_INFO_START",
|
"VAD_INFO_END",
|
"WAKEUP_CMD_START",
|
"WAKEUP_CMD_STOP",
|
"WAKEUP_INFO_DOA",
|
"WAKEUP_INFO_WAKEUP",
|
"WAKEUP_INFO_WAKEUP_MINOR",
|
"DDS_INFO_RESULT",
|
"DDS_INFO_SPEECH_CONTINUE",
|
"DDS_INFO_ERROR"
|
};
|
|
//TODO
|
static player_handle_t tts_player;
|
static player_handle_t media_player;
|
|
typedef struct {
|
struct {
|
int bits;
|
int samplerate;
|
int channels;
|
char *device;
|
} recorder;
|
struct {
|
char *device;
|
} player;
|
struct {
|
char *cfg;
|
char *param;
|
//唤醒词数组
|
char **word;
|
char **audio;
|
int word_count;
|
} wakeup;
|
struct {
|
char *cfg;
|
char *param;
|
char *start_timeout_prompt;
|
char *start_timeout_repeat_prompt;
|
} vad;
|
struct {
|
char *productId;
|
char *aliasKey;
|
char *server;
|
char *deviceProfile;
|
} dds;
|
user_listen_cb listen;
|
} dui_library_cfg_t;
|
|
static dui_library_cfg_t g_cfg;
|
|
//录音线程就绪标志
|
#define RECORDER_READY_BIT (1 << 0)
|
//唤醒线程就绪标志
|
#define WAKEUP_READY_BIT (1 << 1)
|
//VAD线程就绪标志
|
#define VAD_READY_BIT (1 << 2)
|
//DDS线程就绪标志
|
#define DDS_READY_BIT (1 << 3)
|
//播放控制线程就绪标志
|
#define PLAYER_READY_BIT (1 << 4)
|
//用户监听线程就绪标志
|
#define USER_LISTEN_READY_BIT (1 << 5)
|
//处理线程就绪标志
|
#define PROCESS_READY_BIT (1 << 6)
|
|
//线程就绪事件组
|
static os_event_group_handle_t task_ready_ev;
|
|
//日志结构
|
os_log_create_module(recorder, OS_LOG_LEVEL_INFO);
|
os_log_create_module(vad, OS_LOG_LEVEL_INFO);
|
os_log_create_module(wakeup, OS_LOG_LEVEL_INFO);
|
os_log_create_module(dds, OS_LOG_LEVEL_INFO);
|
os_log_create_module(process, OS_LOG_LEVEL_INFO);
|
os_log_create_module(player, OS_LOG_LEVEL_INFO);
|
os_log_create_module(user_listen, OS_LOG_LEVEL_INFO);
|
|
//录音线程句柄
|
static os_thread_handle_t recorder_task;
|
//播放控制线程句柄
|
static os_thread_handle_t player_task;
|
//前端信号处理线程句柄
|
static os_thread_handle_t wakeup_task;
|
//vad处理线程句柄
|
static os_thread_handle_t vad_task;
|
//dds线程句柄
|
static os_thread_handle_t dds_task;
|
//处理线程句柄
|
static os_thread_handle_t process_task;
|
//用户监听线程句柄
|
static os_thread_handle_t user_listen_task;
|
|
//录音数据写入
|
os_stream_handle_t wakeup_stream;
|
|
//vad截取后的音频数据写入
|
os_stream_handle_t dds_stream;
|
|
//前端信号处理后的音频写入
|
os_stream_handle_t vad_stream;
|
|
//处理线程消息队列
|
os_queue_handle_t process_queue;
|
|
//前端信号处理消息队列
|
os_queue_handle_t wakeup_queue;
|
|
//播放控制线程消息队列
|
os_queue_handle_t player_queue;
|
|
//vad处理线程消息队列
|
os_queue_handle_t vad_queue;
|
|
//录音线程消息队列
|
os_queue_handle_t recorder_queue;
|
|
//用户监听线程消息队列
|
os_queue_handle_t user_listen_queue;
|
|
static void user_listen_run(void *args) {
|
int ret;
|
dui_msg_t m;
|
//置位线程READY标志
|
os_event_group_set_bits(task_ready_ev, USER_LISTEN_READY_BIT);
|
OS_LOG_I(user_listen, "READY");
|
while (1) {
|
ret = os_queue_receive(user_listen_queue, &m);
|
if (ret == -1) break;
|
OS_LOG_I(user_listen, "%s", dui_msg_table[m.type]);
|
if (g_cfg.listen) {
|
g_cfg.listen(&m);
|
}
|
}
|
OS_LOG_I(user_listen, "EXIT");
|
}
|
|
static void recorder_run(void *args) {
|
int ret;
|
dui_msg_t m;
|
//置位线程READY标志
|
os_event_group_set_bits(task_ready_ev, RECORDER_READY_BIT);
|
OS_LOG_I(recorder, "READY");
|
while (1) {
|
ret = os_queue_receive(recorder_queue, &m);
|
if (ret == -1) break;
|
OS_LOG_I(recorder, "%s", dui_msg_table[m.type]);
|
if (m.type == RECORDER_CMD_START) {
|
alsa_open_config_t cfg = {
|
.bits = g_cfg.recorder.bits,
|
.channels = g_cfg.recorder.channels,
|
.samplerate = g_cfg.recorder.samplerate,
|
.device = g_cfg.recorder.device
|
};
|
recorder_handle_t recorder = recorder_open(&cfg);
|
assert(recorder != NULL);
|
int block = cfg.bits * cfg.channels / 8;
|
char *read_buf = (char *)os_malloc(cfg.period_size * block);
|
assert(read_buf != NULL);
|
#ifdef WAKEUP_FESPA
|
system("tinymix set 27 3");
|
system("tinymix set 28 3");
|
system("tinymix set 29 3");
|
system("tinymix set 30 3");
|
system("tinymix set 31 3");
|
|
system("tinymix set 35 6");
|
system("tinymix set 36 18");
|
system("tinymix set 37 18");
|
system("tinymix set 38 18");
|
system("tinymix set 39 18");
|
#elif defined(WAKEUP_FESPL)
|
system("tinymix set 28 3");
|
system("tinymix set 36 12");
|
system("tinymix set 29 3");
|
system("tinymix set 37 12");
|
system("tinymix set 26 3");
|
system("tinymix set 35 5");
|
#endif
|
|
recorder_start(recorder);
|
OS_LOG_I(recorder, "START: %s", cfg.device);
|
os_queue_send(user_listen_queue, &m);
|
int frames, read_bytes;
|
while (1) {
|
frames = recorder_read(recorder, read_buf, cfg.period_size);
|
if (frames > 0) {
|
read_bytes = frames * block;
|
//OS_LOG_I(recorder, "read bytes: %d", read_bytes);
|
ret = os_stream_write(wakeup_stream, read_buf, read_bytes);
|
if (ret == -1) break; //录音缓冲被终止
|
} else {
|
OS_LOG_W(recorder, "read data error");
|
}
|
}
|
recorder_stop(recorder);
|
recorder_close(recorder);
|
os_free(read_buf);
|
} else if (m.type == RECORDER_CMD_STOP) {
|
os_queue_send(user_listen_queue, &m);
|
OS_LOG_I(recorder, "STOP");
|
}
|
}
|
OS_LOG_W(recorder, "EXIT");
|
}
|
|
static void player_run(void *args) {
|
int ret;
|
dui_msg_t m;
|
//置位线程READY标志
|
os_event_group_set_bits(task_ready_ev, PLAYER_READY_BIT);
|
OS_LOG_I(player, "READY");
|
|
play_cfg_t item;
|
bool cancel = false;
|
while (1) {
|
memset(&item, 0, sizeof(item));
|
ret = os_queue_receive(player_queue, &m);
|
if (ret == -1) break;
|
OS_LOG_I(player, "%s", dui_msg_table[m.type]);
|
|
if (m.player.mode == PLAYER_MODE_PROMPT) {
|
item.target = m.player.target;
|
item.type = PLAY_TYPE_NATIVE;
|
item.need_free = m.player.need_free;
|
|
player_play(tts_player, &item);
|
ret = player_wait_idle(tts_player);
|
if (ret == 0) {
|
if (m.player.end_session) {
|
player_resume(media_player);
|
} else {
|
memset(&m, 0, sizeof(m));
|
m.type = PLAYER_INFO_PLAY_END;
|
os_queue_send(process_queue, &m);
|
}
|
}
|
} else if (m.player.mode == PLAYER_MODE_TTS) {
|
item.type = PLAY_TYPE_NETWORK;
|
item.target = m.player.target;
|
item.need_free = m.player.need_free;
|
player_play(tts_player, &item);
|
ret = player_wait_idle(tts_player);
|
if (ret == -1) {
|
//合成音播放被终止
|
cancel = true;
|
} else {
|
cancel = false;
|
if (m.player.end_session == true) {
|
player_resume(media_player);
|
} else {
|
//多轮对话告知状态机需要再次进入VAD
|
memset(&m, 0, sizeof(m));
|
m.type = DDS_INFO_SPEECH_CONTINUE;
|
os_queue_send(process_queue, &m);
|
}
|
}
|
} else if (m.player.mode == PLAYER_MODE_AUDIO) {
|
item.target = m.player.target;
|
item.type = PLAY_TYPE_NETWORK;
|
item.need_free = m.player.need_free;
|
if (cancel == false) {
|
player_stop(media_player);
|
player_play(media_player, &item);
|
} else {
|
cancel = false;
|
if (m.player.need_free) {
|
os_free(m.player.target);
|
}
|
}
|
}
|
}
|
OS_LOG_W(player, "EXIT");
|
}
|
|
static bool is_same_word(const char *s1, const char *s2) {
|
while (s1[0] && s2[0]) {
|
if (isspace(s1[0])) {
|
s1++;
|
continue;
|
}
|
if (isspace(s2[0])) {
|
s2++;
|
continue;
|
}
|
if (*s1 != *s2) return false;
|
s1++;
|
s2++;
|
}
|
if (strlen(s1)) {
|
while (s1[0]) {
|
if (!isspace(s1[0])) return false;
|
s1++;
|
}
|
}
|
if (strlen(s2)) {
|
while (s2[0]) {
|
if (!isspace(s2[0])) return false;
|
s2++;
|
}
|
}
|
return true;
|
}
|
|
#ifdef WAKEUP_FESPA
|
#include "wakeup_fespa.c"
|
#elif defined(WAKEUP_FESPL)
|
#include "wakeup_fespl.c"
|
#elif defined(WAKEUP_AEC)
|
#include "wakeup_aec.c"
|
#endif
|
|
|
typedef struct {
|
int status;
|
bool first;
|
} vad_info_t;
|
|
static int vad_callback(void *userdata, int type, char *result, int len) {
|
dui_msg_t m;
|
vad_info_t *info = (vad_info_t *)userdata;
|
if (type == DUILITE_MSG_TYPE_JSON) {
|
OS_LOG_I(vad, "VAD: %s", result);
|
cJSON *js = cJSON_Parse(result);
|
cJSON *status_js = cJSON_GetObjectItem(js, "status");
|
info->status = status_js->valueint;
|
cJSON_Delete(js);
|
} else {
|
if (info->status == 1) {
|
if (info->first) {
|
memset(&m, 0, sizeof(m));
|
m.type = VAD_INFO_START;
|
os_queue_send(process_queue, &m);
|
|
//开始云端请求
|
struct dds_msg *msg = dds_msg_new();
|
dds_msg_set_type(msg, DDS_EV_IN_SPEECH);
|
dds_msg_set_string(msg, "action", "start");
|
dds_send(msg);
|
dds_msg_delete(msg);
|
info->first = false;
|
|
//允许截取的音频写入DDS数据缓冲
|
os_stream_start(dds_stream);
|
}
|
os_stream_write(dds_stream, result, len);
|
}
|
}
|
return 0;
|
}
|
|
bool check_time_expire(struct timeval *now, struct timeval *before, int timeout) {
|
long int expire = (now->tv_sec - before->tv_sec) * 1000 + now->tv_usec / 1000 - before->tv_usec / 1000;
|
if (expire >= timeout) return true;
|
return false;
|
}
|
|
static void vad_run(void *args) {
|
int ret;
|
dui_msg_t m;
|
vad_info_t info;
|
|
struct duilite_vad *vad_engine = duilite_vad_new(g_cfg.vad.cfg, vad_callback, &info);
|
assert(vad_engine != NULL);
|
//50ms
|
int read_buf_size = g_cfg.recorder.channels * g_cfg.recorder.bits / 8 * g_cfg.recorder.samplerate / 20;
|
char *read_buf = (char *)os_malloc(read_buf_size);
|
assert(read_buf != NULL);
|
|
os_event_group_set_bits(task_ready_ev, VAD_READY_BIT);
|
OS_LOG_I(vad, "READY");
|
while (1) {
|
ret = os_queue_receive(vad_queue, &m);
|
if (ret == -1) break;
|
OS_LOG_I(vad, "%s", dui_msg_table[m.type]);
|
if (m.type == VAD_CMD_START) {
|
struct timeval start_time, now_time;
|
info.first = true;
|
info.status = 0;
|
os_stream_start(vad_stream);
|
duilite_vad_start(vad_engine, g_cfg.vad.param);
|
int read_bytes;
|
|
OS_LOG_I(vad, "START");
|
gettimeofday(&start_time, NULL);
|
while (1) {
|
read_bytes = os_stream_read(vad_stream, read_buf, read_buf_size);
|
if (read_bytes == -1) {
|
//vad数据输入缓冲被终止
|
duilite_vad_cancel(vad_engine);
|
if (info.status == 1) {
|
//终止DDS数据缓冲
|
os_stream_stop(dds_stream);
|
//复位dds状态机
|
struct dds_msg *msg = dds_msg_new();
|
dds_msg_set_type(msg, DDS_EV_IN_RESET);
|
dds_send(msg);
|
dds_msg_delete(msg);
|
}
|
break;
|
}
|
|
duilite_vad_feed(vad_engine, read_buf, read_bytes);
|
|
if (info.status == 0) {
|
//判断检测开始说话超时
|
gettimeofday(&now_time, NULL);
|
if (check_time_expire(&now_time, &start_time, 5000)) {
|
//终止VAD输入缓冲写入
|
os_stream_stop(vad_stream);
|
duilite_vad_cancel(vad_engine);
|
memset(&m, 0, sizeof(m));
|
m.type = VAD_INFO_TIMEOUT;
|
os_queue_send(process_queue, &m);
|
break;
|
}
|
}
|
|
if (info.status == 2) {
|
//终止VAD输入缓冲写入
|
duilite_vad_stop(vad_engine);
|
|
//os_stream_finish(dds_stream);
|
os_stream_stop(vad_stream);
|
|
struct dds_msg *msg = dds_msg_new();
|
dds_msg_set_type(msg, DDS_EV_IN_SPEECH);
|
dds_msg_set_string(msg, "action", "end");
|
dds_send(msg);
|
dds_msg_delete(msg);
|
memset(&m, 0, sizeof(m));
|
m.type = VAD_INFO_END;
|
os_queue_send(process_queue, &m);
|
break;
|
}
|
}
|
} else if (m.type == VAD_CMD_STOP){
|
OS_LOG_I(vad, "STOP");
|
}
|
}
|
os_free(read_buf);
|
duilite_vad_delete(vad_engine);
|
OS_LOG_I(vad, "EXIT");
|
}
|
|
void dui_start_recorder() {
|
dui_msg_t m;
|
memset(&m, 0, sizeof(m));
|
m.type = RECORDER_CMD_START;
|
os_queue_send(process_queue, &m); }
|
|
void dui_stop_recorder() {
|
dui_msg_t m;
|
memset(&m, 0, sizeof(m));
|
m.type = RECORDER_CMD_STOP;
|
os_queue_send(process_queue, &m);
|
}
|
|
typedef enum {
|
//空闲
|
PROCESS_STATE_IDLE = 0,
|
//等待唤醒（此时可能正在播放音频）
|
PROCESS_STATE_WAIT_FOR_WAKEUP,
|
//唤醒提示音播放中
|
PROCESS_STATE_WAKEUP_PROMPT,
|
//语音起点检测超时提示音播放中
|
PROCESS_STATE_VAD_START_TIMEOUT_PROMPT,
|
//检测语音起点中
|
PROCESS_STATE_WAIT_FOR_SPEECH_START,
|
//识别拾音中
|
PROCESS_STATE_SPEECH,
|
//等待识别结果
|
PROCESS_STATE_WAIT_FOR_ASR,
|
} process_state_t;
|
|
static void idle_to_wait_for_wakeup(void *args) {
|
//打开录音缓冲
|
os_stream_start(wakeup_stream);
|
|
//开启唤醒
|
dui_msg_t m;
|
memset(&m, 0, sizeof(m));
|
m.type = WAKEUP_CMD_START;
|
os_queue_send(wakeup_queue, &m);
|
|
//开启录音
|
memset(&m, 0, sizeof(m));
|
m.type = RECORDER_CMD_START;
|
os_queue_send(recorder_queue, &m);
|
OS_LOG_I(process, "=====");
|
}
|
|
static void wait_for_wakeup_to_idle(void *args) {
|
//终止录音缓冲（此时唤醒和录音循环被中断）
|
os_stream_stop(wakeup_stream);
|
|
//关闭唤醒
|
dui_msg_t m;
|
memset(&m, 0, sizeof(m));
|
m.type = WAKEUP_CMD_STOP;
|
os_queue_send(wakeup_queue, &m);
|
|
//关闭录音
|
memset(&m, 0, sizeof(m));
|
m.type= RECORDER_CMD_STOP;
|
os_queue_send(recorder_queue, &m);
|
OS_LOG_I(process, "=====");
|
}
|
|
static void wait_for_wakeup_to_wakeup_prompt(void *args) {
|
//当前可能正在播放合成音或者音乐
|
//停止提示音/合成音播放
|
player_stop(tts_player);
|
//暂停音乐播放
|
player_pause(media_player);
|
|
dui_msg_t *msg = (dui_msg_t *)args;
|
|
dui_msg_t m;
|
memset(&m, 0, sizeof(m));
|
m.type = PLAYER_CMD_PLAY;
|
m.player.mode = PLAYER_MODE_PROMPT;
|
m.player.target = g_cfg.wakeup.audio[msg->wakeup.index];
|
m.player.native = true;
|
m.player.need_free = false;
|
|
m.player.end_session = false;
|
|
os_queue_send(player_queue, &m);
|
OS_LOG_I(process, "=====");
|
}
|
|
static void wakeup_prompt_to_wakeup_prompt(void *args) {
|
//停止提示音
|
player_stop(tts_player);
|
|
dui_msg_t *msg = (dui_msg_t *)args;
|
|
dui_msg_t m;
|
memset(&m, 0, sizeof(m));
|
m.type = PLAYER_CMD_PLAY;
|
m.player.mode = PLAYER_MODE_PROMPT;
|
m.player.target = g_cfg.wakeup.audio[msg->wakeup.index];
|
m.player.native = true;
|
m.player.need_free = false;
|
|
m.player.end_session = false;
|
|
os_queue_send(player_queue, &m);
|
OS_LOG_I(process, "=====");
|
}
|
|
static void wakeup_prompt_to_wait_for_speech_start(void *args) {
|
//开启VAD
|
dui_msg_t m;
|
memset(&m, 0, sizeof(m));
|
m.type = VAD_CMD_START;
|
os_queue_send(vad_queue, &m);
|
OS_LOG_I(process, "=====");
|
}
|
|
static void wait_for_speech_start_to_speech(void *args) {
|
OS_LOG_I(process, "=====");
|
}
|
|
static void speech_to_wait_for_asr(void *args) {
|
OS_LOG_I(process, "=====");
|
}
|
|
static void wait_for_asr_to_wait_for_wakeup(void *args) {
|
OS_LOG_I(process, "=====");
|
}
|
|
static void wait_for_asr_to_wait_for_wakeup3(void *args) {
|
dui_msg_t m;
|
memset(&m, 0, sizeof(m));
|
m.type = PLAYER_CMD_PLAY;
|
m.player.mode = PLAYER_MODE_PROMPT;
|
m.player.target = "./audio/network_error.mp3";
|
m.player.native = true;
|
m.player.need_free = false;
|
m.player.end_session = true;
|
os_queue_send(player_queue, &m);
|
OS_LOG_I(process, "=====");
|
}
|
|
static void wait_for_asr_to_wait_for_wakeup2(void *args) {
|
struct dds_msg *dm = dds_msg_new();
|
dds_msg_set_type(dm, DDS_EV_IN_RESET);
|
dds_send(dm);
|
dds_msg_delete(dm);
|
|
dui_msg_t *msg = (dui_msg_t *)args;
|
dui_msg_t m;
|
memset(&m, 0, sizeof(m));
|
m.type = PLAYER_CMD_PLAY;
|
m.player.mode = PLAYER_MODE_PROMPT;
|
m.player.target = g_cfg.wakeup.audio[msg->wakeup.index];
|
m.player.native = true;
|
m.player.need_free = false;
|
m.player.end_session = true;
|
os_queue_send(player_queue, &m);
|
OS_LOG_I(process, "=====");
|
}
|
|
static void wait_for_speech_start_to_wakeup_prompt(void *args) {
|
dui_msg_t *msg = (dui_msg_t *)args;
|
//终止VAD数据缓冲写入
|
os_stream_stop(vad_stream);
|
dui_msg_t m;
|
memset(&m, 0, sizeof(m));
|
m.type = PLAYER_CMD_PLAY;
|
m.player.mode = PLAYER_MODE_PROMPT;
|
m.player.target = g_cfg.wakeup.audio[msg->wakeup.index];
|
m.player.native = true;
|
m.player.need_free = false;
|
m.player.end_session = false;
|
os_queue_send(player_queue, &m);
|
OS_LOG_I(process, "=====");
|
}
|
|
static void speech_to_wakeup_prompt(void *args) {
|
dui_msg_t *msg = (dui_msg_t *)args;
|
//终止VAD数据缓冲写入
|
os_stream_stop(vad_stream);
|
os_stream_stop(dds_stream);
|
dui_msg_t m;
|
memset(&m, 0, sizeof(m));
|
m.type = PLAYER_CMD_PLAY;
|
m.player.mode = PLAYER_MODE_PROMPT;
|
m.player.target = g_cfg.wakeup.audio[msg->wakeup.index];
|
m.player.native = true;
|
m.player.need_free = false;
|
m.player.end_session = false;
|
os_queue_send(player_queue, &m);
|
OS_LOG_I(process, "=====");
|
}
|
|
static void wait_for_speech_start_to_wait_for_wakeup(void *args) {
|
dui_msg_t m;
|
memset(&m, 0, sizeof(m));
|
m.type = PLAYER_CMD_PLAY;
|
m.player.mode = PLAYER_MODE_PROMPT;
|
m.player.target = g_cfg.vad.start_timeout_prompt;
|
m.player.native = true;
|
m.player.need_free = false;
|
m.player.end_session = true;
|
os_queue_send(player_queue, &m);
|
OS_LOG_I(process, "=====");
|
}
|
|
static void wait_for_asr_to_wakeup_prompt(void *args) {
|
struct dds_msg *dm = dds_msg_new();
|
dds_msg_set_type(dm, DDS_EV_IN_RESET);
|
dds_send(dm);
|
dds_msg_delete(dm);
|
|
dui_msg_t *msg = (dui_msg_t *)args;
|
|
dui_msg_t m;
|
memset(&m, 0, sizeof(m));
|
m.type = PLAYER_CMD_PLAY;
|
m.player.mode = PLAYER_MODE_PROMPT;
|
m.player.target = g_cfg.wakeup.audio[msg->wakeup.index];
|
m.player.native = true;
|
m.player.need_free = false;
|
m.player.end_session = true;
|
os_queue_send(player_queue, &m);
|
OS_LOG_I(process, "=====");
|
}
|
|
static void speech_to_wait_for_wakeup(void *args) {
|
//终止VAD数据缓冲写入
|
os_stream_stop(vad_stream);
|
os_stream_stop(dds_stream);
|
dui_msg_t m;
|
memset(&m, 0, sizeof(m));
|
m.type = PLAYER_CMD_PLAY;
|
m.player.mode = PLAYER_MODE_PROMPT;
|
m.player.target = "./audio/network_error.mp3";
|
m.player.native = true;
|
m.player.need_free = false;
|
m.player.end_session = true;
|
os_queue_send(player_queue, &m);
|
OS_LOG_I(process, "=====");
|
}
|
|
static void speech_to_wait_for_wakeup2(void *args) {
|
//终止VAD数据缓冲写入
|
os_stream_stop(vad_stream);
|
os_stream_stop(dds_stream);
|
|
dui_msg_t *msg = (dui_msg_t *)args;
|
|
dui_msg_t m;
|
memset(&m, 0, sizeof(m));
|
m.type = PLAYER_CMD_PLAY;
|
m.player.mode = PLAYER_MODE_PROMPT;
|
m.player.target = g_cfg.wakeup.audio[msg->wakeup.index];
|
m.player.native = true;
|
m.player.need_free = false;
|
m.player.end_session = true;
|
os_queue_send(player_queue, &m);
|
OS_LOG_I(process, "=====");
|
}
|
|
static void wait_for_wakeup_to_wait_for_wakeup(void *args) {
|
//当前可能正在播放合成音或者音乐
|
//停止提示音/合成音播放
|
player_stop(tts_player);
|
//暂停音乐播放
|
player_pause(media_player);
|
|
dui_msg_t *msg = (dui_msg_t *)args;
|
|
dui_msg_t m;
|
memset(&m, 0, sizeof(m));
|
m.type = PLAYER_CMD_PLAY;
|
m.player.mode = PLAYER_MODE_PROMPT;
|
m.player.target = g_cfg.wakeup.audio[msg->wakeup.index];
|
m.player.native = true;
|
m.player.need_free = false;
|
m.player.end_session = true;
|
os_queue_send(player_queue, &m);
|
OS_LOG_I(process, "=====");
|
}
|
|
static void wakeup_prompt_to_wait_for_wakeup(void *args) {
|
//停止提示音/合成音播放
|
player_stop(tts_player);
|
dui_msg_t *msg = (dui_msg_t *)args;
|
|
dui_msg_t m;
|
memset(&m, 0, sizeof(m));
|
m.type = PLAYER_CMD_PLAY;
|
m.player.mode = PLAYER_MODE_PROMPT;
|
m.player.target = g_cfg.wakeup.audio[msg->wakeup.index];
|
m.player.native = true;
|
m.player.need_free = false;
|
m.player.end_session = true;
|
os_queue_send(player_queue, &m);
|
OS_LOG_I(process, "=====");
|
}
|
|
static void wait_for_speech_start_to_wait_for_wakeup2(void *args) {
|
dui_msg_t *msg = (dui_msg_t *)args;
|
//终止VAD数据缓冲写入
|
os_stream_stop(vad_stream);
|
dui_msg_t m;
|
memset(&m, 0, sizeof(m));
|
m.type = PLAYER_CMD_PLAY;
|
m.player.mode = PLAYER_MODE_PROMPT;
|
m.player.target = g_cfg.wakeup.audio[msg->wakeup.index];
|
m.player.native = true;
|
m.player.need_free = false;
|
m.player.end_session = true;
|
os_queue_send(player_queue, &m);
|
OS_LOG_I(process, "=====");
|
}
|
|
static void wakeup_prompt_to_idle(void *args) {
|
//停止提示音
|
player_stop(tts_player);
|
|
//终止wakeup输入缓冲
|
os_stream_stop(wakeup_stream);
|
|
//关闭唤醒
|
dui_msg_t m;
|
memset(&m, 0, sizeof(m));
|
m.type = WAKEUP_CMD_STOP;
|
os_queue_send(wakeup_queue, &m);
|
|
//关闭录音
|
memset(&m, 0, sizeof(m));
|
m.type = RECORDER_CMD_STOP;
|
os_queue_send(recorder_queue, &m);
|
OS_LOG_I(process, "=====");
|
}
|
|
static void wait_for_speech_start_to_idle(void *args) {
|
//终止VAD数据流
|
os_stream_stop(vad_stream);
|
|
//终止WAKEUP数据流
|
os_stream_stop(wakeup_stream);
|
//关闭唤醒
|
dui_msg_t m;
|
memset(&m, 0, sizeof(m));
|
m.type = WAKEUP_CMD_STOP;
|
os_queue_send(wakeup_queue, &m);
|
|
//关闭录音
|
memset(&m, 0, sizeof(m));
|
m.type= RECORDER_CMD_STOP;
|
os_queue_send(recorder_queue, &m);
|
OS_LOG_I(process, "=====");
|
}
|
|
static void speech_to_idle(void *args) {
|
//终止VAD数据缓冲
|
os_stream_stop(vad_stream);
|
os_stream_stop(dds_stream);
|
|
//终止录音缓冲
|
os_stream_stop(wakeup_stream);
|
|
//关闭唤醒
|
dui_msg_t m;
|
memset(&m, 0, sizeof(m));
|
m.type = WAKEUP_CMD_STOP;
|
os_queue_send(wakeup_queue, &m);
|
|
//关闭录音
|
memset(&m, 0, sizeof(m));
|
m.type= RECORDER_CMD_STOP;
|
os_queue_send(recorder_queue, &m);
|
OS_LOG_I(process, "=====");
|
}
|
|
static void wait_for_asr_to_idle(void *args) {
|
|
struct dds_msg *msg = dds_msg_new();
|
dds_msg_set_type(msg, DDS_EV_IN_RESET);
|
dds_send(msg);
|
dds_msg_delete(msg);
|
|
//终止录音缓冲
|
os_stream_stop(wakeup_stream);
|
|
//关闭唤醒
|
dui_msg_t m;
|
memset(&m, 0, sizeof(m));
|
m.type = WAKEUP_CMD_STOP;
|
os_queue_send(wakeup_queue, &m);
|
|
//关闭录音
|
memset(&m, 0, sizeof(m));
|
m.type= RECORDER_CMD_STOP;
|
os_queue_send(recorder_queue, &m);
|
OS_LOG_I(process, "=====");
|
}
|
|
static void wait_for_wakeup_to_wait_for_speech_start(void *args) {
|
dui_msg_t m;
|
memset(&m, 0, sizeof(m));
|
m.type = VAD_CMD_START;
|
os_queue_send(vad_queue, &m);
|
OS_LOG_I(process, "=====");
|
}
|
|
static dui_fsm_transfer_t process_transfer_table[] = {
|
//触发事件---当前状态---执行动作---下一个状态
|
{RECORDER_CMD_START, PROCESS_STATE_IDLE, idle_to_wait_for_wakeup, PROCESS_STATE_WAIT_FOR_WAKEUP},
|
|
{RECORDER_CMD_STOP, PROCESS_STATE_WAIT_FOR_WAKEUP, wait_for_wakeup_to_idle, PROCESS_STATE_IDLE},
|
{WAKEUP_INFO_WAKEUP, PROCESS_STATE_WAIT_FOR_WAKEUP, wait_for_wakeup_to_wakeup_prompt, PROCESS_STATE_WAKEUP_PROMPT},
|
{DDS_INFO_SPEECH_CONTINUE, PROCESS_STATE_WAIT_FOR_WAKEUP, wait_for_wakeup_to_wait_for_speech_start, PROCESS_STATE_WAIT_FOR_SPEECH_START},
|
{WAKEUP_INFO_WAKEUP_MINOR, PROCESS_STATE_WAIT_FOR_WAKEUP, wait_for_wakeup_to_wait_for_wakeup, PROCESS_STATE_WAIT_FOR_WAKEUP},
|
|
{WAKEUP_INFO_WAKEUP, PROCESS_STATE_WAKEUP_PROMPT, wakeup_prompt_to_wakeup_prompt, PROCESS_STATE_WAKEUP_PROMPT},
|
{WAKEUP_INFO_WAKEUP_MINOR, PROCESS_STATE_WAKEUP_PROMPT, wakeup_prompt_to_wait_for_wakeup, PROCESS_STATE_WAIT_FOR_WAKEUP},
|
{PLAYER_INFO_PLAY_END, PROCESS_STATE_WAKEUP_PROMPT, wakeup_prompt_to_wait_for_speech_start, PROCESS_STATE_WAIT_FOR_SPEECH_START},
|
{RECORDER_CMD_STOP, PROCESS_STATE_WAKEUP_PROMPT, wakeup_prompt_to_idle, PROCESS_STATE_IDLE},
|
|
{WAKEUP_INFO_WAKEUP, PROCESS_STATE_WAIT_FOR_SPEECH_START, wait_for_speech_start_to_wakeup_prompt, PROCESS_STATE_WAKEUP_PROMPT},
|
{VAD_INFO_TIMEOUT, PROCESS_STATE_WAIT_FOR_SPEECH_START, wait_for_speech_start_to_wait_for_wakeup, PROCESS_STATE_WAIT_FOR_WAKEUP},
|
{WAKEUP_INFO_WAKEUP_MINOR, PROCESS_STATE_WAIT_FOR_SPEECH_START, wait_for_speech_start_to_wait_for_wakeup2, PROCESS_STATE_WAIT_FOR_WAKEUP},
|
{VAD_INFO_START, PROCESS_STATE_WAIT_FOR_SPEECH_START, wait_for_speech_start_to_speech, PROCESS_STATE_SPEECH},
|
{RECORDER_CMD_STOP, PROCESS_STATE_WAIT_FOR_SPEECH_START, wait_for_speech_start_to_idle, PROCESS_STATE_IDLE},
|
|
{WAKEUP_INFO_WAKEUP, PROCESS_STATE_SPEECH, speech_to_wakeup_prompt, PROCESS_STATE_WAKEUP_PROMPT},
|
{VAD_INFO_END, PROCESS_STATE_SPEECH, speech_to_wait_for_asr, PROCESS_STATE_WAIT_FOR_ASR},
|
{DDS_INFO_ERROR, PROCESS_STATE_SPEECH, speech_to_wait_for_wakeup, PROCESS_STATE_WAIT_FOR_WAKEUP},
|
{WAKEUP_INFO_WAKEUP_MINOR, PROCESS_STATE_SPEECH, speech_to_wait_for_wakeup2, PROCESS_STATE_WAIT_FOR_WAKEUP},
|
{RECORDER_CMD_STOP, PROCESS_STATE_SPEECH, speech_to_idle, PROCESS_STATE_IDLE},
|
|
{DDS_INFO_RESULT, PROCESS_STATE_WAIT_FOR_ASR, wait_for_asr_to_wait_for_wakeup, PROCESS_STATE_WAIT_FOR_WAKEUP},
|
{DDS_INFO_ERROR, PROCESS_STATE_WAIT_FOR_ASR, wait_for_asr_to_wait_for_wakeup3, PROCESS_STATE_WAIT_FOR_WAKEUP},
|
{WAKEUP_INFO_WAKEUP, PROCESS_STATE_WAIT_FOR_ASR, wait_for_asr_to_wakeup_prompt, PROCESS_STATE_WAKEUP_PROMPT},
|
{WAKEUP_INFO_WAKEUP_MINOR, PROCESS_STATE_WAIT_FOR_ASR, wait_for_asr_to_wait_for_wakeup2, PROCESS_STATE_WAIT_FOR_WAKEUP},
|
{RECORDER_CMD_STOP, PROCESS_STATE_WAIT_FOR_ASR, wait_for_asr_to_idle, PROCESS_STATE_IDLE}
|
};
|
|
static void process_run(void *args) {
|
int ret;
|
dui_msg_t m;
|
dui_fsm_t fsm = {
|
.cur_state = PROCESS_STATE_IDLE,
|
.t = process_transfer_table,
|
.t_size = sizeof(process_transfer_table) / sizeof(process_transfer_table[0])
|
};
|
os_event_group_set_bits(task_ready_ev, PROCESS_READY_BIT);
|
OS_LOG_I(process, "READY");
|
while (1) {
|
ret = os_queue_receive(process_queue, &m);
|
if (ret == -1) break;
|
OS_LOG_I(process, "%s", dui_msg_table[m.type]);
|
dui_fsm_handle(&fsm, m.type, &m);
|
}
|
OS_LOG_I(process, "EXIT");
|
}
|
|
static char *msg_type_set[] = {
|
"",
|
"DDS_EV_OUT_RECORD_AUDIO",
|
"DDS_EV_OUT_NATIVE_CALL",
|
"DDS_EV_OUT_COMMAND",
|
"DDS_EV_OUT_MEDIA",
|
"DDS_EV_OUT_STATUS",
|
"DDS_EV_OUT_TTS",
|
"DDS_EV_OUT_ERROR",
|
"DDS_EV_OUT_ASR_RESULT",
|
"DDS_EV_OUT_DUI_RESPONSE",
|
"DDS_EV_OUT_DUI_LOGIN"
|
};
|
|
static int process_tts(struct dds_msg *msg) {
|
char *str_value = NULL;
|
dds_msg_get_string(msg, "speakUrl", &str_value);
|
OS_LOG_I(dds, "tts url: %s", str_value);
|
char *url = NULL;
|
if (strncmp(str_value, "https://", 8) == 0) {
|
url = os_strdup(str_value + 8);
|
} else {
|
url = os_strdup(str_value);
|
}
|
dui_msg_t m;
|
memset(&m, 0, sizeof(m));
|
m.type = PLAYER_CMD_PLAY;
|
m.player.mode = PLAYER_MODE_TTS;
|
m.player.native = false;
|
m.player.target = url;
|
m.player.need_free = true;
|
int end_session;
|
dds_msg_get_integer(msg, "endSession", &end_session);
|
m.player.end_session = (end_session == 1) ? true : false;
|
os_queue_send(player_queue, &m);
|
return 0;
|
}
|
|
#define HTTP_PREFIX "http://ac.iot.aispeech.com/ogg2mp3/"
|
static int process_media(struct dds_msg *msg) {
|
char *list = NULL;
|
char *task = NULL;
|
dds_msg_get_string(msg, "list", &list);
|
dds_msg_get_string(msg, "task", &task);
|
if (list) {
|
cJSON *js = cJSON_Parse(list);
|
if (js) {
|
int items = cJSON_GetArraySize(js);
|
if (items > 0) {
|
cJSON *first_js = cJSON_GetArrayItem(js, 0);
|
cJSON *linkUrl_js = cJSON_GetObjectItem(first_js, "linkUrl");
|
int len;
|
if (linkUrl_js && (len = strlen(linkUrl_js->valuestring)) > 0) {
|
char *url = strdup(linkUrl_js->valuestring);
|
if ((len > 4) && (0 == strcmp(linkUrl_js->valuestring + len - 4, ".ogg"))) {
|
//如果是ogg音频，需要跳转到解码服务器进行转码
|
url = (char *)os_calloc(len + strlen(HTTP_PREFIX) + 1, sizeof(char));
|
assert(url != NULL);
|
memcpy(url, HTTP_PREFIX, strlen(HTTP_PREFIX));
|
memcpy(url + strlen(HTTP_PREFIX), linkUrl_js->valuestring, len);
|
}
|
if (strncmp(url, "https://", 8) == 0) {
|
memmove(url, url + 8, strlen(url) + 1 - 8);
|
}
|
dui_msg_t m;
|
memset(&m, 0, sizeof(m));
|
m.type = PLAYER_CMD_PLAY;
|
m.player.mode = PLAYER_MODE_AUDIO;
|
m.player.native = false;
|
m.player.target = url;
|
m.player.need_free = true;
|
os_queue_send(player_queue, &m);
|
}
|
}
|
cJSON_Delete(js);
|
}
|
}
|
return 0;
|
}
|
|
|
static char recorder_data[6400];
|
static int dds_handler(void *userdata, struct dds_msg *msg) {
|
int type;
|
int errorId;
|
char *str_value;
|
dds_msg_get_integer(msg, "type", &type);
|
OS_LOG_I(dds, "dds msg type id: %d, type: %s", type, msg_type_set[type]);
|
switch (type) {
|
case DDS_EV_OUT_RECORD_AUDIO: {
|
int read_bytes = os_stream_read2(dds_stream, recorder_data, sizeof(recorder_data));
|
if (read_bytes > 0) {
|
msg = dds_msg_new();
|
assert(msg != NULL);
|
dds_msg_set_type(msg, DDS_EV_IN_AUDIO_STREAM);
|
dds_msg_set_bin(msg, "audio", recorder_data, read_bytes);
|
dds_send(msg);
|
dds_msg_delete(msg);
|
struct timeval tv;
|
gettimeofday(&tv, NULL);
|
}
|
//OS_LOG_I(dds, "read audio length: %d, now: %.3lf\n", read_bytes, tv.tv_sec + tv.tv_usec / 1000000.0);
|
break;
|
}
|
case DDS_EV_OUT_NATIVE_CALL: {
|
//process_native(msg);
|
break;
|
}
|
case DDS_EV_OUT_COMMAND: {
|
//process_command(msg);
|
break;
|
}
|
case DDS_EV_OUT_MEDIA: {
|
process_media(msg);
|
break;
|
}
|
case DDS_EV_OUT_STATUS: {
|
dds_msg_get_string(msg, "status", &str_value);
|
OS_LOG_I(dds, "dds status: %s", str_value);
|
if (0 == strcmp(str_value, "idle")) {
|
|
} else if (0 == strcmp(str_value, "listening")) {
|
} else if (0 == strcmp(str_value, "understanding")) {
|
}
|
break;
|
}
|
case DDS_EV_OUT_TTS: {
|
process_tts(msg);
|
break;
|
}
|
case DDS_EV_OUT_ERROR: {
|
dui_msg_t m;
|
memset(&m, 0, sizeof(m));
|
m.type = DDS_INFO_ERROR;
|
os_queue_send(process_queue, &m);
|
dds_msg_get_string(msg, "error", &str_value);
|
dds_msg_get_integer(msg, "errorId", &errorId);
|
OS_LOG_I(dds, "error: %s, errorId: %d\n", str_value, errorId);
|
break;
|
}
|
case DDS_EV_OUT_ASR_RESULT: {
|
if (!dds_msg_get_string(msg, "var", &str_value)) {
|
OS_LOG_I(dds,"var: %s\n", str_value);
|
}
|
if (!dds_msg_get_string(msg, "text", &str_value)) {
|
OS_LOG_I(dds, "text: %s\n", str_value);
|
}
|
dui_msg_t m;
|
memset(&m, 0, sizeof(m));
|
m.type = DDS_INFO_RESULT;
|
os_queue_send(process_queue, &m);
|
break;
|
}
|
case DDS_EV_OUT_DUI_RESPONSE: {
|
dds_msg_get_string(msg, "response", &str_value);
|
OS_LOG_I(dds, "response: %s\n", str_value);
|
break;
|
}
|
default:
|
break;
|
}
|
return 0;
|
}
|
|
static void dds_run(void *args) {
|
struct dds_msg *msg = dds_msg_new();
|
dds_msg_set_string(msg, "productId", g_cfg.dds.productId);
|
dds_msg_set_string(msg, "aliasKey", g_cfg.dds.aliasKey);
|
dds_msg_set_string(msg, "server", g_cfg.dds.server);
|
dds_msg_set_string(msg, "deviceProfile", g_cfg.dds.deviceProfile);
|
struct dds_opt opt = {
|
._handler = dds_handler
|
};
|
os_event_group_set_bits(task_ready_ev, DDS_READY_BIT);
|
OS_LOG_I(dds, "READY");
|
int ret = dds_start(msg, &opt);
|
if (ret != 0) {
|
OS_LOG_I(dds, "dds start error");
|
}
|
dds_msg_delete(msg);
|
OS_LOG_I(dds, "EXIT");
|
}
|
|
|
static int dui_parse_cfg(const char *cfg) {
|
cJSON_Hooks js_hook = {
|
.malloc_fn = os_malloc,
|
.free_fn = os_free
|
};
|
cJSON_InitHooks(&js_hook);
|
|
cJSON *js = cJSON_Parse(cfg);
|
if (!js) return -1;
|
//auth
|
cJSON *auth_js = cJSON_GetObjectItem(js, "auth");
|
char *auth = cJSON_Print(auth_js);
|
duilite_library_load(auth);
|
free(auth);
|
|
//recorder
|
cJSON *recorder_js = cJSON_GetObjectItem(js, "recorder");
|
cJSON *recorder_device_js = cJSON_GetObjectItem(recorder_js, "device");
|
cJSON *recorder_bits_js = cJSON_GetObjectItem(recorder_js, "bits");
|
cJSON *recorder_channels_js = cJSON_GetObjectItem(recorder_js, "channels");
|
cJSON *recorder_samplerate_js = cJSON_GetObjectItem(recorder_js, "samplerate");
|
|
g_cfg.recorder.device = os_strdup(recorder_device_js->valuestring);
|
g_cfg.recorder.bits = recorder_bits_js->valueint;
|
g_cfg.recorder.samplerate = recorder_samplerate_js->valueint;
|
g_cfg.recorder.channels = recorder_channels_js->valueint;
|
|
//player
|
cJSON *player_js = cJSON_GetObjectItem(js, "player");
|
cJSON *player_device_js = cJSON_GetObjectItem(player_js, "device");
|
g_cfg.player.device = os_strdup(player_device_js->valuestring);
|
|
//wakeup
|
cJSON *wakeup_js = cJSON_GetObjectItem(js, "wakeup");
|
cJSON *wakeup_cfg_js = cJSON_GetObjectItem(wakeup_js, "cfg");
|
|
cJSON *wakeup_word_js = cJSON_GetObjectItem(wakeup_js, "wakeupWord");
|
cJSON *wakeup_audio_js = cJSON_GetObjectItem(wakeup_js, "wakeupAudio");
|
g_cfg.wakeup.word_count = cJSON_GetArraySize(wakeup_word_js);
|
|
if (g_cfg.wakeup.word_count > 0) {
|
g_cfg.wakeup.word = (char **)os_malloc(g_cfg.wakeup.word_count * sizeof(char *));
|
g_cfg.wakeup.audio = (char **)os_malloc(g_cfg.wakeup.word_count * sizeof(char *));
|
int i;
|
for (i = 0; i < g_cfg.wakeup.word_count; i++) {
|
g_cfg.wakeup.word[i] = os_strdup(cJSON_GetArrayItem(wakeup_word_js, i)->valuestring);
|
g_cfg.wakeup.audio[i] = os_strdup(cJSON_GetArrayItem(wakeup_audio_js, i)->valuestring);
|
}
|
}
|
g_cfg.wakeup.cfg = cJSON_Print(wakeup_cfg_js);
|
|
//vad
|
cJSON *vad_js = cJSON_GetObjectItem(js, "vad");
|
cJSON *vad_cfg_js = cJSON_GetObjectItem(vad_js, "cfg");
|
cJSON *vad_start_timeout_prompt_js = cJSON_GetObjectItem(vad_js, "startTimeoutPrompt");
|
g_cfg.vad.cfg = cJSON_Print(vad_cfg_js);
|
g_cfg.vad.start_timeout_prompt = os_strdup(vad_start_timeout_prompt_js->valuestring);
|
|
|
//dds
|
cJSON *dds_js = cJSON_GetObjectItem(js, "dds");
|
cJSON *productId_js = cJSON_GetObjectItem(dds_js, "productId");
|
cJSON *aliasKey_js = cJSON_GetObjectItem(dds_js, "aliasKey");
|
cJSON *server_js = cJSON_GetObjectItem(dds_js, "server");
|
cJSON *deviceProfile_js = cJSON_GetObjectItem(dds_js, "deviceProfile");
|
|
g_cfg.dds.productId = os_strdup(productId_js->valuestring);
|
g_cfg.dds.aliasKey = os_strdup(aliasKey_js->valuestring);
|
g_cfg.dds.server = os_strdup(server_js->valuestring);
|
g_cfg.dds.deviceProfile = os_strdup(deviceProfile_js->valuestring);
|
|
cJSON_Delete(js);
|
return 0;
|
}
|
|
int dui_library_init(const char *cfg, user_listen_cb listen) {
|
#ifdef SAVE_AUDIO
|
input_fd = fopen("/userdata/1.pcm", "wb");
|
output_fd = fopen("/userdata/2.pcm", "wb");
|
#endif
|
if (0 != dui_parse_cfg(cfg)) return -1;
|
os_log_init(NULL);
|
|
player_init();
|
player_cfg_t tts_cfg = {
|
.preprocess_buf_size = 10240,
|
.decode_buf_size = 1024 * 5,
|
.name = "tts"
|
};
|
tts_player = player_create(&tts_cfg);
|
assert(tts_player != NULL);
|
|
player_cfg_t media_cfg = {
|
.preprocess_buf_size = 1024 * 100,
|
.decode_buf_size = 1024 * 10,
|
.name = "media"
|
};
|
media_player = player_create(&media_cfg);
|
assert(media_player != NULL);
|
|
g_cfg.listen = listen;
|
|
recorder_queue = os_queue_create(5, sizeof(dui_msg_t));
|
wakeup_queue = os_queue_create(5, sizeof(dui_msg_t));
|
vad_queue = os_queue_create(5, sizeof(dui_msg_t));
|
process_queue = os_queue_create(10, sizeof(dui_msg_t));
|
player_queue = os_queue_create(5, sizeof(dui_msg_t));
|
user_listen_queue = os_queue_create(10, sizeof(dui_msg_t));
|
|
task_ready_ev = os_event_group_create();
|
|
//500ms缓冲
|
int recorder_stream_size = 5 * g_cfg.recorder.channels * (g_cfg.recorder.bits / 8) * (g_cfg.recorder.samplerate / 10);
|
wakeup_stream = os_stream_create(recorder_stream_size);
|
|
//200ms缓冲
|
int vad_stream_size = 2 * (g_cfg.recorder.bits / 8) * (g_cfg.recorder.samplerate / 10);
|
vad_stream = os_stream_create(vad_stream_size);
|
|
//500ms缓冲
|
//由于VAD在检测到语音起始点时数据较大
|
int dds_stream_size = 5 * (g_cfg.recorder.bits / 8) * (g_cfg.recorder.samplerate / 10);
|
dds_stream = os_stream_create(dds_stream_size);
|
|
//录音线程
|
os_thread_cfg_t c = {
|
.run = recorder_run
|
};
|
recorder_task = os_thread_create(&c);
|
|
//唤醒线程
|
c.run = wakeup_run;
|
wakeup_task = os_thread_create(&c);
|
|
//vad线程
|
c.run = vad_run;
|
vad_task = os_thread_create(&c);
|
|
//处理线程
|
c.run = process_run;
|
process_task = os_thread_create(&c);
|
|
//dds线程
|
c.run = dds_run;
|
dds_task = os_thread_create(&c);
|
|
//播放线程
|
c.run = player_run;
|
player_task = os_thread_create(&c);
|
|
c.run = user_listen_run;
|
user_listen_task = os_thread_create(&c);
|
|
os_event_group_wait_bits(task_ready_ev, RECORDER_READY_BIT | WAKEUP_READY_BIT | VAD_READY_BIT | PLAYER_READY_BIT | DDS_READY_BIT | USER_LISTEN_READY_BIT | PROCESS_READY_BIT,
|
true, true);
|
return 0;
|
}
|
|
void dui_library_cleanup(void) {
|
//TODO
|
os_thread_exit(recorder_task);
|
os_thread_exit(wakeup_task);
|
os_thread_exit(vad_task);
|
os_thread_exit(process_task);
|
os_thread_exit(dds_task);
|
os_thread_exit(player_task);
|
os_thread_exit(user_listen_task);
|
|
os_stream_destroy(wakeup_stream);
|
os_stream_destroy(vad_stream);
|
os_stream_destroy(dds_stream);
|
os_event_group_destroy(task_ready_ev);
|
os_queue_destroy(process_queue);
|
os_queue_destroy(wakeup_queue);
|
os_queue_destroy(vad_queue);
|
os_queue_destroy(recorder_queue);
|
os_queue_destroy(player_queue);
|
os_queue_destroy(user_listen_queue);
|
os_log_deinit();
|
|
os_free(g_cfg.recorder.device);
|
os_free(g_cfg.player.device);
|
os_free(g_cfg.wakeup.cfg);
|
os_free(g_cfg.wakeup.param);
|
int i;
|
for (i = 0; i < g_cfg.wakeup.word_count; i++) {
|
os_free(g_cfg.wakeup.word[i]);
|
os_free(g_cfg.wakeup.audio[i]);
|
}
|
os_free(g_cfg.wakeup.word);
|
os_free(g_cfg.wakeup.audio);
|
os_free(g_cfg.vad.cfg);
|
os_free(g_cfg.vad.param);
|
os_free(g_cfg.vad.start_timeout_prompt);
|
|
os_free(g_cfg.dds.productId);
|
os_free(g_cfg.dds.aliasKey);
|
os_free(g_cfg.dds.server);
|
os_free(g_cfg.dds.deviceProfile);
|
memset(&g_cfg, 0, sizeof(g_cfg));
|
}
|
