From: snickersun Date: Sun, 28 Jun 2026 03:51:30 +0000 (+0800) Subject: think播报加速 X-Git-Url: http://git.snicker.com.cn/css/static/gitweb.css?a=commitdiff_plain;h=4073dda040661ea2835fce7b9790daac27173cc7;p=mirrors%2FASR1603_G5.git think播报加速 --- diff --git a/2.sdk/project/7PIN_1_5/sdk/services/microPython/microPython.mk b/2.sdk/project/7PIN_1_5/sdk/services/microPython/microPython.mk index 7fdb7168..577e06f1 100644 --- a/2.sdk/project/7PIN_1_5/sdk/services/microPython/microPython.mk +++ b/2.sdk/project/7PIN_1_5/sdk/services/microPython/microPython.mk @@ -295,6 +295,7 @@ QPY_SRCS = \ ports/quectel/core/source/code128_p.c \ ports/quectel/core/source/modmask.c \ ports/quectel/core/source/modcws_frame.c \ + ports/quectel/core/source/modws_dispatcher.c \ ports/quectel/core/source/modVad.c \ ports/quectel/core/source/machine_one_wire.c\ ports/quectel/core/source/modalipay_collection.c \ diff --git a/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/Makefile b/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/Makefile index 8246a3e1..66521c90 100644 --- a/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/Makefile +++ b/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/Makefile @@ -381,6 +381,7 @@ SRC_QSTR += \ source/modwlan.c \ source/modmask.c \ source/modcws_frame.c \ + source/modws_dispatcher.c \ source/modVad.c \ source/machine_one_wire.c diff --git a/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/default_config.py b/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/default_config.py index 156ee434..7ccbacc3 100644 --- a/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/default_config.py +++ b/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/default_config.py @@ -220,7 +220,7 @@ VAD_RULE2_SILENCE = 500 # rule3 尾部静音(ms):10s 以上最短连续静音判定语音结束(之前跟随 VAD_SILENCE_DEFAULT,现已独立) VAD_RULE3_SILENCE = 960 # 本地 VAD 判句末后追加采集的尾音(ms),到点再发 audio.completed;防句尾渐弱音被关闸截断。0=立即收尾 -LOCAL_VAD_ENDPOINT_HANGOVER_MS = 200 +LOCAL_VAD_ENDPOINT_HANGOVER_MS = 0 # 本地 imsl VAD 能量阈值:越低越灵敏(易触发说话),越高越钝;modVad.c 默认 15000 VAD_ENERGY_THRESHOLD = 15000 # imsl auth_vad:DMP 区域 0=海外 dmp-global.raisound.com 1=国内正式服务器 dmp.raisound.com 2=国内测试服务器 dmp-dev.raisound.com 3=测试服2 dmp-intl.raisound.com(与 imsl_vad.h AuthInfo.server_addr 一致) diff --git a/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/products/configs/g3p/default_config.py b/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/products/configs/g3p/default_config.py index 156ee434..7ccbacc3 100644 --- a/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/products/configs/g3p/default_config.py +++ b/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/products/configs/g3p/default_config.py @@ -220,7 +220,7 @@ VAD_RULE2_SILENCE = 500 # rule3 尾部静音(ms):10s 以上最短连续静音判定语音结束(之前跟随 VAD_SILENCE_DEFAULT,现已独立) VAD_RULE3_SILENCE = 960 # 本地 VAD 判句末后追加采集的尾音(ms),到点再发 audio.completed;防句尾渐弱音被关闸截断。0=立即收尾 -LOCAL_VAD_ENDPOINT_HANGOVER_MS = 200 +LOCAL_VAD_ENDPOINT_HANGOVER_MS = 0 # 本地 imsl VAD 能量阈值:越低越灵敏(易触发说话),越高越钝;modVad.c 默认 15000 VAD_ENERGY_THRESHOLD = 15000 # imsl auth_vad:DMP 区域 0=海外 dmp-global.raisound.com 1=国内正式服务器 dmp.raisound.com 2=国内测试服务器 dmp-dev.raisound.com 3=测试服2 dmp-intl.raisound.com(与 imsl_vad.h AuthInfo.server_addr 一致) diff --git a/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/products/configs/k8v3/default_config.py b/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/products/configs/k8v3/default_config.py index 50f0d98f..60e4bd88 100644 --- a/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/products/configs/k8v3/default_config.py +++ b/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/products/configs/k8v3/default_config.py @@ -227,7 +227,7 @@ VAD_RULE2_SILENCE = 500 # rule3 尾部静音(ms):10s 以上最短连续静音判定语音结束(之前跟随 VAD_SILENCE_DEFAULT,现已独立) VAD_RULE3_SILENCE = 960 # 本地 VAD 判句末后追加采集的尾音(ms),到点再发 audio.completed;防句尾渐弱音被关闸截断。0=立即收尾 -LOCAL_VAD_ENDPOINT_HANGOVER_MS = 200 +LOCAL_VAD_ENDPOINT_HANGOVER_MS = 0 # 本地 imsl VAD 能量阈值:越低越灵敏(易触发说话),越高越钝;modVad.c 默认 15000 VAD_ENERGY_THRESHOLD = 15000 # imsl auth_vad:DMP 区域 0=海外 dmp-global.raisound.com 1=国内正式服务器 dmp.raisound.com 2=国内测试服务器 dmp-dev.raisound.com 3=测试服2 dmp-intl.raisound.com(与 imsl_vad.h AuthInfo.server_addr 一致) diff --git a/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/source/audio_audio.c b/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/source/audio_audio.c new file mode 100644 index 00000000..99d0f973 --- /dev/null +++ b/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/source/audio_audio.c @@ -0,0 +1,3095 @@ +/* + * Copyright (c) Quectel Wireless Solution, Co., Ltd.All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include +#include "runtime.h" +#include "extmod/vfs.h" +#ifndef MICROPY_QPY_AUDIO_AUDIO +#define MICROPY_QPY_AUDIO_AUDIO 1 +#define PLAT_ASR_1606 1 +#endif + + +#if MICROPY_QPY_AUDIO_AUDIO + + +#include "runtime.h" +#include "stream.h" +#include "mperrno.h" + + +#include "audio_queue.h" +#include "helios_audio.h" +#include "helios_debug.h" +#include "helios_gpio.h" +#include "audio_handle.h" +#include "helios_fs.h" + + +#if defined(BOARD_EC600MCN_LA) || defined(BOARD_EC600MCN_LA_POC_XBND)|| defined(BOARD_EC600MCN_LA_POC_QS) \ + || defined(BOARD_EC600MCN_LA_VOLTE) || defined(BOARD_EC600MCN_LA_HJT) \ + || defined(BOARD_EC600MCN_LE) || defined(BOARD_EC600MCN_LE_POC_XBND) || defined(BOARD_EC600MCN_LE_ALIPAY) \ + || defined(BOARD_EC600MCN_LA_POC_ZZD) || defined(BOARD_EC600MCN_LE_POC_ZZD) \ + || defined(BOARD_EC600MCN_LE_POC_QS) || defined(BOARD_EC600MCN_LE_VOLTE) || defined(BOARD_EC600MCN_LE_BTZ)\ + || defined(BOARD_EC600MCN_MC) || defined(BOARD_EC600MEU_LA) || defined(BOARD_EC600MEU_LA_POC_XBND) \ + || defined(BOARD_EC800MCN_GA) || defined(BOARD_EC800MCN_GA_VOLTE) || defined(BOARD_EC600MLA_LA_POC_XBND)\ + || defined(BOARD_EC800MCN_GA_ALIPAY) || defined(BOARD_EG810MCN_GA_ALIPAY) \ + || defined(BOARD_EC800MCN_GA_SPISD) || defined(BOARD_EC800MCN_GA_MS) || defined(BOARD_EC800MCN_GA_VOEXT)\ + || defined(BOARD_EC800MCN_LE) || defined(BOARD_EC800MCN_LE_VOLTE) || defined(BOARD_EC800MCN_LE_VOLVGL)\ + || defined(BOARD_EC800MCN_LA_POC_XBND) || defined(BOARD_EC800MCN_LE_POC_XBND) \ + || defined(BOARD_EG810MCN_GA) || defined(BOARD_EG810MCN_GA_VOEXT) || defined(BOARD_EG810MCN_GA_VOLTE) \ + || defined(BOARD_EG810MCN_GB) || defined(BOARD_EG810MCN_GB_VOEXT) \ + || defined(BOARD_EG810MCN_LA) || defined(BOARD_EG810MCN_LA_VOLTE) \ + || defined(BOARD_EG810MEU_LA) || defined(BOARD_EG810MEU_LA_VOEXT) \ + || defined(PLAT_ASR_1803s) || defined(PLAT_ASR_1803sc) || defined(BOARD_EC800MCN_LE_CPE) || defined(BOARD_EC800MCN_GB_VOEXT) \ + || defined(BOARD_EG810MEU_LA_VOLVGL) || defined(BOARD_EC800MCN_LE_VOEXT) + + + + +#define AUDIO_DTMF_TONE_NEW_SUPPORT 1 + +#endif + + + +#if CONFIG_AUDIO + +typedef void HeliosMPFILE; +extern HeliosMPFILE* Helios_MP_fopen(const char* path_in, const char* mode_in); +extern int Helios_MP_fread(void *buffer, size_t size, size_t num, HeliosMPFILE *file); +extern int Helios_MP_fwrite(void *buffer, size_t size, size_t num, HeliosMPFILE *file); +extern int Helios_MP_fclose(HeliosMPFILE *file); +extern int Helios_MP_fseek(HeliosMPFILE *file, long offset, int origin); + +#undef HeliosFILE +#undef Helios_fopen +#undef Helios_fread +#undef Helios_fwrite +#undef Helios_fclose +#undef Helios_fseek + +#define HeliosFILE HeliosMPFILE +#define Helios_fopen Helios_MP_fopen +#define Helios_fread Helios_MP_fread +#define Helios_fwrite Helios_MP_fwrite +#define Helios_fclose Helios_MP_fclose +#define Helios_fseek Helios_MP_fseek +#endif + + + +typedef struct _audio_obj_t { + mp_obj_base_t base; + int device; + //int inited; +} audio_obj_t; + +#define HELIOS_AUDIO_LOG(fmt, ...) custom_log(audio_audio, fmt, ##__VA_ARGS__) + +#define AUDIO_CHANNEL_MAX 3 +extern const mp_obj_type_t audio_audio_type; + +extern c_callback_t *g_audio_callback; +static c_callback_t *g_audio_speakerpa_callback; +static int g_gpio_pa = -1; +static int g_pa_class = 2; +static audio_obj_t *audio_obj[AUDIO_CHANNEL_MAX] = {NULL}; +char audio_playing_file_name[256] = {0}; + + +extern int audio_err_handle(void); +extern int audio_play_callback(char *ptr, size_t lens, Helios_EnumAudPlayerState state); + +#define FREE_BUFF(X) do \ +{ \ + if(X) { \ + free(X); \ + X = NULL; \ + } \ +} while (0); + + +#define CALLOC_BUFF_SET(X,Y) do \ +{ \ + X = calloc(1, strlen(Y)+16); \ + memset(X, 0, strlen(Y)+16); \ + if(X) { \ + strncpy(X, Y, strlen(Y)); \ + } \ +} while (0); + +#if defined(CONFIG_AUDIO) && !defined(PLAT_Unisoc_8850) && !defined(PLAT_Unisoc_8850_R02) +#define GET_FILE_VFS_PATH(x, y) \ + do \ + { \ + sprintf(y, "%s", x); \ + HELIOS_AUDIO_LOG("vfs_path:%s\n", y); \ + } while (0) +#else + +#if defined(PLAT_ASR) || defined(PLAT_Unisoc) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) || defined(PLAT_Unisoc_8850) \ + || defined(PLAT_Unisoc_8910_R05)|| defined(PLAT_Unisoc_8910_R06) || defined(PLAT_ASR_1602) || defined(PLAT_Unisoc_8850_R02) +#define GET_FILE_VFS_PATH(x, y) get_vfs_path(x,y) +#else +#define GET_FILE_VFS_PATH(x, y) \ + do \ + { \ + char *p_out = NULL; \ + if (0 == strncmp(x, "U:", 2) || 0 == strncmp(x, "B:", 2) \ + || 0 == strncmp(x, "mp3files=U:", 11) || 0 == strncmp(x, "mp3files=B:", 11)) \ + { \ + sprintf(y, "%s", x); \ + break; \ + } \ + mp_vfs_mount_t *vfs = mp_vfs_lookup_path(x, (const char **)&p_out); \ + if (vfs != MP_VFS_NONE && vfs != MP_VFS_ROOT) \ + { \ + if(0 == strncmp(vfs->str, "/bak", strlen("/bak"))) { \ + sprintf(y, "B:%s", p_out); \ + } else { \ + sprintf(y, "U:%s", p_out); \ + } \ + } \ + else if(0 == strncmp(x, "mp3files=", 9) || 0 == strncmp(x, "amrfiles=", 9)) \ + { \ + vfs = mp_vfs_lookup_path(x + 9, (const char **)&p_out); \ + if (vfs != MP_VFS_NONE && vfs != MP_VFS_ROOT) \ + { \ + memcpy(y, x, 9); \ + if(0 == strncmp(vfs->str, "/bak", strlen("/bak"))) { \ + sprintf(y + 9, "B:%s", p_out); \ + } else { \ + sprintf(y + 9, "U:%s", p_out); \ + } \ + } \ + else \ + { \ + sprintf(y, "%s", x); \ + } \ + } \ + else \ + { \ + sprintf(y, "U:/%s", x); \ + } \ + HELIOS_AUDIO_LOG("vfs_path:%s\n", y); \ + } while (0) +#endif + +#endif + + +//虚函数,用来解决ASR160X R07在关闭MP3解码库宏控时造成的编译问�? +#if defined (PLAT_ASR) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) || defined (PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) \ + || defined(PLAT_ASR_1602) || defined(PLAT_Unisoc_8910_R06) + +#if (!CONFIG_AUDIO_MP3) || (!defined(CONFIG_AUDIO_MP3)) +__attribute__((weak)) void Helios_mp3_stream_close_flag(unsigned char value) +{ + (void) value; + return; +} +#endif + +#endif +//end + +STATIC void delay_us(unsigned int us) +{ + int cnt = 26; + volatile int i = 0; + while(us--){ + i = cnt; + while(i--); + } +} + +STATIC void set_clk_high(void) +{ + Helios_GPIO_SetLevel(g_gpio_pa, HELIOS_LVL_HIGH); +} + +STATIC void set_clk_low(void) +{ + Helios_GPIO_SetLevel(g_gpio_pa, HELIOS_LVL_LOW); +} +STATIC void set_pa_flag(uint8_t flag) +{ + Helios_Mutex_Lock(audio_pa.pa_mutex, HELIOS_WAIT_FOREVER); + if(flag > 0) + { + audio_pa.open_flag++; + } + else + { + if(audio_pa.open_flag > 0){ + audio_pa.open_flag--; + } + } + Helios_Mutex_Unlock(audio_pa.pa_mutex); +} + +STATIC uint8_t get_pa_flag(void) +{ + uint8_t flag = 0; + flag = audio_pa.open_flag; + return flag; +} + +STATIC void set_PA_pulse(int num) +{ + int i = 0; + if(num < 0) return; + for (i = 0; i < num; i++) + { + set_clk_low(); + delay_us(3); + set_clk_high(); + delay_us(3); + } +} + +STATIC void audio_open_power_amplifier(void) +{ + if(get_pa_flag() <= 0) + { + return; + } + set_PA_pulse(g_pa_class); +} + +STATIC void audio_close_power_amplifier(void) +{ + if(get_pa_flag() > 0) + { + return; + } + set_clk_low(); +} + +enum { + PA_AUDIO_PLAY, + PA_AUDIO_STOP, +}; +static uint8_t play_state = PA_AUDIO_STOP; + +static Helios_MsgQ_t open_pa_q = 0; +static Helios_Thread_t open_pa_task_id = 0; + + + +// 延时打开PA +void helios_open_pa(void * argv) { + uint8_t pa_ctrl = 0; + int ret = -1; + + while (1) { + ret = Helios_MsgQ_Get(open_pa_q, (void *)&pa_ctrl, sizeof(uint8_t), HELIOS_WAIT_FOREVER); + if (ret != 0) + { + HELIOS_AUDIO_LOG("helios_open_pa thread failed to get queue\n"); + continue; + } + if (pa_ctrl == 1) { + Helios_msleep(audio_pa.open_pa_delay); + audio_open_power_amplifier(); + play_state = PA_AUDIO_PLAY; + HELIOS_AUDIO_LOG("audio set high, event 1.\r\n"); + } + else { + if(audio_pa.close_pa_delay > 0) + { + Helios_msleep(audio_pa.close_pa_delay); + } + audio_close_power_amplifier(); + play_state = PA_AUDIO_STOP; + HELIOS_AUDIO_LOG("audio set low, event 0.\r\n"); + } + } + +} + +int asynch_open_pa_init(void) { + int ret = 0; + Helios_ThreadAttr attr = {0}; + + if (open_pa_q == 0) { + open_pa_q = Helios_MsgQ_Create(1, sizeof(uint8_t)); + } + + if(audio_pa.pa_mutex == 0) + { + audio_pa.pa_mutex = Helios_Mutex_Create(); + if(audio_pa.pa_mutex == 0) + { + HELIOS_AUDIO_LOG("create open pa mutex failed\n"); + return -1; + } + } + + if(open_pa_task_id == 0) + { + attr.name = "open_pa"; + attr.stack_size = 1024*2; + attr.priority = 90; + attr.entry = helios_open_pa; + + open_pa_task_id = Helios_Thread_Create(&attr); + if (0 == open_pa_task_id) + { + HELIOS_AUDIO_LOG("create open pa task failed\n"); + return -1; + } + } + return ret; +} + +void user_audio_speakerpa_callback(unsigned int event) +{ + uint8_t pa_ctrl; + unsigned int on_off = 0; + if(g_gpio_pa != -1) + { +#if !defined(BOARD_EC600MCN_LF_SLPOC) + if(audio_pa.pa_is_delay_close && (event == AUDIO_PA_CLOSE_NOW)) + { + event = AUDIO_PA_CLOSE_DELAY; + } + if(audio_pa.pa_is_delay_open && (event == AUDIO_PA_OPEN_NOW)) + { + event = AUDIO_PA_OPEN_DELAY; + } +#endif + +#if defined(BOARD_EC600MCN_LE_POC_QS) + extern unsigned char ptt_tone_play_end_skip_pa; + if(ptt_tone_play_end_skip_pa) + { + ptt_tone_play_end_skip_pa--; + return; + } +#endif + + switch(event) + { + case AUDIO_PA_CLOSE_NOW: + set_pa_flag(0); + audio_close_power_amplifier(); + play_state = PA_AUDIO_STOP; + on_off = 0; + HELIOS_AUDIO_LOG("audio set low, event 0.\r\n"); + break; + case AUDIO_PA_OPEN_DELAY: + set_pa_flag(1); + if (audio_pa.open_pa_delay == 0) { + audio_open_power_amplifier(); + play_state = PA_AUDIO_PLAY; + HELIOS_AUDIO_LOG("audio set high, event 1.\r\n"); + } + else { + pa_ctrl = 1; + Helios_MsgQ_Put(open_pa_q, (const void *)&pa_ctrl, sizeof(uint8_t), HELIOS_NO_WAIT); + } + on_off = 1; + HELIOS_AUDIO_LOG("asynch_open_pa start.\r\n"); + break; + case AUDIO_PA_OPEN_NOW: + set_pa_flag(1); + audio_open_power_amplifier(); + play_state = PA_AUDIO_PLAY; + on_off = 1; + HELIOS_AUDIO_LOG("audio set high, event 1.\r\n"); + break; + case AUDIO_PA_CLOSE_DELAY: + set_pa_flag(0); + pa_ctrl = 0; + Helios_MsgQ_Put(open_pa_q, (const void *)&pa_ctrl, sizeof(uint8_t), HELIOS_NO_WAIT); + on_off = 0; + break; + default: + HELIOS_AUDIO_LOG("audio pa error event:%d\r\n",event); + return; + } + } + if (g_audio_speakerpa_callback) + { + GC_STACKTOP_SET(); + mp_sched_schedule_ex(g_audio_speakerpa_callback, mp_obj_new_int(on_off)); + GC_STACKTOP_CLEAR(); + } +} + +#if defined(BOARD_EC600MCN_LE_POC_QS) || defined(BOARD_EC600MCN_LA_POC_QS) +STATIC mp_obj_t mpy_set_audio_read_delay(mp_obj_t self_in, mp_obj_t delay) { + Helios_set_audio_read_delay(mp_obj_get_int(delay)); + return mp_const_none; +} +STATIC MP_DEFINE_CONST_FUN_OBJ_2(mpy_set_audio_read_delay_obj, mpy_set_audio_read_delay); +#endif + +#if defined (PLAT_ASR) || defined(PLAT_Unisoc) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) || defined(PLAT_Unisoc_8850) \ + || defined(PLAT_EIGEN)|| defined(PLAT_EIGEN_718) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_Unisoc_8910_R06) \ + || defined(PLAT_ASR_1602) || defined(PLAT_Unisoc_8850_R02) || defined(PLAT_ASR_1803s) || defined(PLAT_ASR_1803sc) +STATIC mp_obj_t helios_set_pa(size_t n_args, const mp_obj_t *args) +{ + int ret = 0; + Helios_GPIOInitStruct gpio_struct = {0}; + gpio_struct.dir = HELIOS_GPIO_OUTPUT; + gpio_struct.pull = HELIOS_PULL_NONE; + gpio_struct.value = HELIOS_LVL_LOW; + + if(mp_obj_get_int(args[1]) == 0 || mp_obj_get_int(args[1]) > PLAT_GPIO_NUM) { + mp_raise_ValueError(MP_ERROR_TEXT("invalid pin")); + } + g_gpio_pa = mp_obj_get_int(args[1]); + if (n_args == 3) + { + if(mp_obj_get_int(args[2]) > 10 || mp_obj_get_int(args[2]) < 0) { + mp_raise_ValueError(MP_ERROR_TEXT("Too many PA pulses, limited to 10. [0,10]")); + } + if(g_pa_class == 0 && 0 != mp_obj_get_int(args[2]) && play_state == PA_AUDIO_PLAY) { + g_pa_class = mp_obj_get_int(args[2]); + Helios_GPIO_Init(g_gpio_pa, &gpio_struct); + audio_open_power_amplifier(); + return mp_obj_new_int(1); + } + g_pa_class = mp_obj_get_int(args[2]); + } + + ret = Helios_GPIO_Init(g_gpio_pa, &gpio_struct);//Helios_Audio_SetPa(g_gpio_pa); + if (ret != 0) + { + return mp_obj_new_int(0); + } + return mp_obj_new_int(1); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(helios_set_pa_obj, 2, 3, helios_set_pa); + +STATIC mp_obj_t helios_set_open_pa_delay(mp_obj_t self_in, mp_obj_t delay) { + audio_pa.open_pa_delay = mp_obj_get_int(delay); + if(audio_pa.open_pa_delay > 0) + { + audio_pa.pa_is_delay_open = 1; + } + else + { + audio_pa.pa_is_delay_open = 0; + } + return mp_obj_new_int(1); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_2(helios_set_open_pa_delay_obj, helios_set_open_pa_delay); + +STATIC mp_obj_t helios_set_close_pa_delay(mp_obj_t self_in, mp_obj_t delay) { + audio_pa.close_pa_delay = mp_obj_get_int(delay); + if(audio_pa.close_pa_delay > 0) + { + audio_pa.pa_is_delay_close = 1; + } + else + { + audio_pa.pa_is_delay_close = 0; + } + return mp_obj_new_int(1); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_2(helios_set_close_pa_delay_obj, helios_set_close_pa_delay); + +STATIC mp_obj_t helios_set_speakerpa_callback(mp_obj_t self_in, mp_obj_t callback) +{ + static c_callback_t cb = {0}; + memset(&cb, 0, sizeof(c_callback_t)); + g_audio_speakerpa_callback = &cb; + mp_sched_schedule_callback_register(g_audio_speakerpa_callback, callback); + return mp_obj_new_int(0); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_2(helios_set_speakerpa_callback_obj, helios_set_speakerpa_callback); + +STATIC mp_obj_t helios_user_speakerpa_switch(mp_obj_t self_in, mp_obj_t pa_com) +{ + unsigned int event = 0; + if(mp_obj_get_int(pa_com) < 0 || mp_obj_get_int(pa_com) > 1) { + mp_raise_ValueError(MP_ERROR_TEXT("invalid parameter")); + } + event = mp_obj_get_int(pa_com); + user_audio_speakerpa_callback(event); + + return mp_obj_new_int(0); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_2(helios_user_speakerpa_switch_obj, helios_user_speakerpa_switch); + +#if defined(PLAT_Unisoc_8850_R02) && defined(CONFIG_POC) +STATIC mp_obj_t helios_set_audio_data_dump_log(mp_obj_t self_in, mp_obj_t set) +{ + unsigned char enable = 0; + int ret = -1; + if(mp_obj_get_int(enable) < 0 || mp_obj_get_int(enable) > 1) { + mp_raise_ValueError(MP_ERROR_TEXT("invalid parameter")); + } + enable = mp_obj_get_int(set); + ret = Helios_Debug_PCM_Data_Dump_Log_Set(enable); + return mp_obj_new_int(ret); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_2(helios_set_audio_data_dump_log_obj, helios_set_audio_data_dump_log); +#endif + +#if defined(PLAT_Unisoc) + +STATIC mp_obj_t helios_internal_pa_type(mp_uint_t n_args, const mp_obj_t *args) { + int pa_type = 0; + if(n_args == 1) + { + pa_type = Helios_Get_Audio_Pa_Type(); + if(pa_type >= HELIOS_AUD_SPKPA_TYPE_MAX || pa_type < HELIOS_AUD_SPKPA_TYPE_CLASSAB) + { + return mp_obj_new_int(-1); + } + return mp_obj_new_int(pa_type); + } + else if(n_args == 2) + { + pa_type = mp_obj_get_int(args[1]); + if(pa_type >= HELIOS_AUD_SPKPA_TYPE_MAX || pa_type < HELIOS_AUD_SPKPA_TYPE_CLASSAB) + { + return mp_obj_new_int(-1); + } + int ret = Helios_Set_Audio_Pa_Type(pa_type); + return mp_obj_new_int(ret); + } + return mp_obj_new_int(0); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(helios_internal_pa_type_obj, 1, 2, (mp_obj_t)helios_internal_pa_type); + +#endif + +#endif + +/*=============================================================================*/ +/* FUNCTION: helios_set_audio_callback */ +/*=============================================================================*/ +/*!@brief : user callback function for audio playing. + * @param[in] : callback - user's callback + * @param[out] : + * @return : + */ +/*=============================================================================*/ +STATIC mp_obj_t helios_set_audio_callback(mp_obj_t self_in, mp_obj_t callback) +{ + static c_callback_t cb = {0}; + memset(&cb, 0, sizeof(c_callback_t)); + g_audio_callback = &cb; + mp_sched_schedule_callback_register(g_audio_callback, callback); + + return mp_obj_new_int(0); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_2(helios_set_audio_callback_obj, helios_set_audio_callback); + +#if !CONFIG_AUDIO_PWM +#if defined (PLAT_ASR) || defined (PLAT_Unisoc) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) || defined (PLAT_Unisoc_8850) \ + || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_ASR_1602) || defined(PLAT_Unisoc_8850_R02) || defined(PLAT_Unisoc_8910_R06) \ + || defined(PLAT_ASR_1803s) || defined(PLAT_ASR_1803sc) +STATIC mp_obj_t helios_audio_set_channel(mp_obj_t self_in, mp_obj_t dev) +{ + audio_obj_t *self = MP_OBJ_TO_PTR(self_in); + + int device = HELIOS_OUTPUT_RECEIVER; + device = mp_obj_get_int(dev); + + if(self->device != device) + { + + if (!audio_channel_check(device)) + { + mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("The current platform does not support device %d."), device); + } + + if(device == HELIOS_OUTPUT_RECEIVER||device == HELIOS_OUTPUT_SPEAKER||device == HELIOS_OUTPUT_HEADPHONE){ + Helios_Audio_SetAudioChannle(device); + } + else{ + device = HELIOS_OUTPUT_RECEIVER; //default replay path + Helios_Audio_SetAudioChannle(device); + } + self->device = device; + + } + return mp_obj_new_int(0); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_2(helios_set_channel_obj, helios_audio_set_channel); +#endif +#endif + +STATIC void helios_codec_callback(Helios_pcm_codec_event event) +{ + + switch(event) + { + case Helios_PCM_CODEC_AboutToOpen: + if(audio.play_start_mode == HELIOS_AUD_START_FIRST_PA_THEN_DEC) + { + user_audio_speakerpa_callback(2); + Helios_msleep(audio.interval_of_start_dec_pa); + } + break; + case Helios_PCM_CODEC_Opened: + if(audio.play_start_mode == HELIOS_AUD_START_FIRST_DEC_THEN_PA) + { + audio_pa.open_pa_delay = audio.interval_of_start_dec_pa; + user_audio_speakerpa_callback(1); + } + break; + case Helios_PCM_CODEC_AboutToClose: + if(audio.play_end_mode == HELIOS_AUD_END_FIRST_PA_THEN_DEC) + { + user_audio_speakerpa_callback(0); + Helios_msleep(audio.interval_of_close_dec_pa); + } + break; + case Helios_PCM_CODEC_Closed: + if(audio.play_end_mode == HELIOS_AUD_END_FIRST_DEC_THEN_PA) + { + audio_pa.close_pa_delay = audio.interval_of_close_dec_pa; + user_audio_speakerpa_callback(3); + } + break; + default: + break; + } +} + + +STATIC mp_obj_t audio_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) +{ + mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true); + int device = HELIOS_OUTPUT_RECEIVER; + device = mp_obj_get_int(args[0]); + + if (device < 0 || device > 2) { + mp_raise_ValueError(MP_ERROR_TEXT("invalid device index, the value of device should be in[0,2]")); + } + asynch_open_pa_init(); +#if !CONFIG_AUDIO_PWM +#if !defined(PLAT_EIGEN) && !defined(PLAT_EIGEN_718) + if (!audio_channel_check(device)) + { + mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("The current platform does not support device %d."), device); + } +#endif +#endif + if(audio_obj[device] == NULL) + { + audio_obj[device] = m_new_obj_with_finaliser(audio_obj_t); + } + audio_obj_t *self = audio_obj[device]; + self->base.type = &audio_audio_type; + self->device = device; + //self->inited = 0; + + Helios_Audio_Init(); +#if defined(BOARD_EC600MCN_LF_SLPOC) + Helios_PCM_Codec_Event_Callback_Register(helios_codec_callback); +#endif + +#if defined(PLAT_ASR) || defined(PLAT_Unisoc) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) || defined(PLAT_EIGEN) \ + || defined(PLAT_Unisoc_8850) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_ASR_1602) || defined(PLAT_Unisoc_8850_R02) || defined(PLAT_Unisoc_8910_R06)\ + || defined(PLAT_EIGEN_718) || defined(PLAT_ASR_1803s) || defined(PLAT_ASR_1803sc) + +#if defined(PLAT_EIGEN) || defined(PLAT_EIGEN_718) + extern int Helios_Audio_SetPaCallback_py(Helios_AudOutputType type, helios_audio_pa_cb_t cb); + Helios_Audio_SetPaCallback_py((Helios_AudOutputType)device, user_audio_speakerpa_callback); +#else + Helios_Audio_SetPaCallback((Helios_AudOutputType)device, user_audio_speakerpa_callback); +#endif +#endif + +#if !CONFIG_AUDIO_PWM +#if !defined(PLAT_EIGEN) && !defined(PLAT_EIGEN_718) + if(device == HELIOS_OUTPUT_RECEIVER||device == HELIOS_OUTPUT_SPEAKER||device == HELIOS_OUTPUT_HEADPHONE){ + Helios_Audio_SetAudioChannle(device); + } + else{ + device = HELIOS_OUTPUT_RECEIVER; //default replay path + Helios_Audio_SetAudioChannle(device); + } +#endif +#endif + if (audio.inited == 0) + { + uint8_t i = 0; + for (i=0; i= audio.cur_priority) + { + if (audio.cur_breakin == 1) + { + audio.audio_state = AUDIO_PLAYING; + + if (!audio_queue_is_full(&audio.audio_queue[new_priority])) + { + //Helios_Mutex_Lock(audio.queue_mutex, HELIOS_WAIT_FOREVER); + HELIOS_AUDIO_LOG("----- audio 2[%d,%d]-----\r\n", new_priority, audio.cur_priority); + uint8_t rear = audio.audio_queue[new_priority].rear; + uint8_t front = audio.audio_queue[new_priority].front; + + if (audio.audio_queue[new_priority].audio_data[rear].breakin == 0) + { + rear = (rear + 1) % QUEUE_SIZE; + audio.total_nums++; + } + else if (audio.audio_queue[new_priority].audio_data[rear].breakin == 1) + { + if (front == rear) + { + if (front == 0) + { + front = QUEUE_SIZE - 1; + } + else + { + front = (front - 1) % QUEUE_SIZE; + } + audio.total_nums++; + } + } + + audio.audio_queue[new_priority].audio_data[rear].audio_type = AUDIO_FILE; + audio.audio_queue[new_priority].audio_data[rear].priority = new_priority; + audio.audio_queue[new_priority].audio_data[rear].breakin = new_breakin; + audio.audio_queue[new_priority].audio_data[rear].mode = 0; + FREE_BUFF(audio.audio_queue[new_priority].audio_data[rear].data); + CALLOC_BUFF_SET(audio.audio_queue[new_priority].audio_data[rear].data, vfs_name); + + audio.audio_queue[new_priority].rear = rear; + audio.audio_queue[new_priority].front = front; + + Helios_Mutex_Unlock(audio.queue_mutex); + } + else + { + Helios_Mutex_Unlock(audio.queue_mutex); + return mp_obj_new_int(-2); + } + switch (audio.cur_type) + { + #if MICROPY_QPY_AUDIO_TTS + case AUDIO_TTS: + { + HELIOS_AUDIO_LOG("---- stop tts play. ----\r\n"); + Helios_TTS_Stop(); + break; + } + #endif + case AUDIO_FILE: + { + HELIOS_AUDIO_LOG("---- stop audio file play. ----\r\n"); + Helios_Audio_FilePlayStop(); + break; + } + case AUDIO_MONTAGE: + { + Helios_Mutex_Lock(audio.montage_mutex, HELIOS_WAIT_FOREVER); + HELIOS_AUDIO_LOG("---- stop audio montage play. ----\r\n"); + audio.montage_is_stopping = 1; + helios_set_montage_break_flag(1); + #if !defined(PLAT_EIGEN) && !defined(PLAT_EIGEN_718) + audio_err_handle(); + #endif + Helios_msleep(200); + + Helios_Audio_StreamPlayStop(); + audio.montage_is_stopping = 0; + Helios_Mutex_Unlock(audio.montage_mutex); + Helios_msleep(200); + uint8_t audio_msg = AUDIO_FINISH_EVENT; + if (Helios_MsgQ_Put(audio.queue_msg, (const void *)&audio_msg, sizeof(uint8_t), HELIOS_NO_WAIT) == -1) + { + HELIOS_AUDIO_LOG("send audio msg failed[%u].\r\n", audio_msg); + return mp_obj_new_int(-1); + } + break; + } + default: + { + HELIOS_AUDIO_LOG("Unknown audio type.\r\n"); + return mp_obj_new_int(-1); + } + } + + return mp_obj_new_int(0); + } + else if (audio.cur_breakin == 0) + { + if (!audio_queue_is_full(&audio.audio_queue[new_priority])) + { + //Helios_Mutex_Lock(audio.queue_mutex, HELIOS_WAIT_FOREVER); + uint8_t rear = audio.audio_queue[new_priority].rear; + uint8_t front = audio.audio_queue[new_priority].front; + + if (audio.audio_queue[new_priority].audio_data[rear].breakin == 0) + { + rear = (rear + 1) % QUEUE_SIZE; + audio.total_nums++; + } + else if (audio.audio_queue[new_priority].audio_data[rear].breakin == 1) + { + if (front == rear) + { + if (front == 0) + { + front = QUEUE_SIZE - 1; + } + else + { + front = (front - 1) % QUEUE_SIZE; + } + audio.total_nums++; + } + } + + audio.audio_queue[new_priority].audio_data[rear].audio_type = AUDIO_FILE; + audio.audio_queue[new_priority].audio_data[rear].priority = new_priority; + audio.audio_queue[new_priority].audio_data[rear].breakin = new_breakin; + audio.audio_queue[new_priority].audio_data[rear].mode = 0; + FREE_BUFF(audio.audio_queue[new_priority].audio_data[rear].data); + CALLOC_BUFF_SET(audio.audio_queue[new_priority].audio_data[rear].data, vfs_name); + audio.audio_queue[new_priority].rear = rear; + Helios_Mutex_Unlock(audio.queue_mutex); + } + else + { + Helios_Mutex_Unlock(audio.queue_mutex); + return mp_obj_new_int(-2); + } + + return mp_obj_new_int(1); + } + } + else + { + if (!audio_queue_is_full(&audio.audio_queue[new_priority])) + { + //Helios_Mutex_Lock(audio.queue_mutex, HELIOS_WAIT_FOREVER); + uint8_t rear = audio.audio_queue[new_priority].rear; + uint8_t front = audio.audio_queue[new_priority].front; + + if (audio.audio_queue[new_priority].audio_data[rear].breakin == 0) + { + rear = (rear + 1) % QUEUE_SIZE; + audio.total_nums++; + } + else if (audio.audio_queue[new_priority].audio_data[rear].breakin == 1) + { + if (front == rear) + { + if (front == 0) + { + front = QUEUE_SIZE - 1; + } + else + { + front = (front - 1) % QUEUE_SIZE; + } + audio.total_nums++; + } + } + + audio.audio_queue[new_priority].audio_data[rear].audio_type = AUDIO_FILE; + audio.audio_queue[new_priority].audio_data[rear].priority = new_priority; + audio.audio_queue[new_priority].audio_data[rear].breakin = new_breakin; + audio.audio_queue[new_priority].audio_data[rear].mode = 0; + FREE_BUFF(audio.audio_queue[new_priority].audio_data[rear].data); + CALLOC_BUFF_SET(audio.audio_queue[new_priority].audio_data[rear].data, vfs_name); + audio.audio_queue[new_priority].rear = rear; + audio.audio_queue[new_priority].front = front; + + Helios_Mutex_Unlock(audio.queue_mutex); + } + else + { + Helios_Mutex_Unlock(audio.queue_mutex); + return mp_obj_new_int(-2); + } + + return mp_obj_new_int(1); + } + } + int ret = Helios_Audio_FilePlayStart(vfs_name, HELIOS_AUDIO_PLAY_TYPE_LOCAL, audio_play_callback); + if (ret == -1) + { + Helios_Mutex_Lock(audio.queue_mutex, HELIOS_WAIT_FOREVER); + audio.audio_state = AUDIO_IDLE; + Helios_Mutex_Unlock(audio.queue_mutex); + } + else + { + memcpy(audio_playing_file_name, vfs_name, sizeof(vfs_name)); + } + return mp_obj_new_int(ret); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_KW(helios_play_file_start_obj, 1, helios_play_file_start); + +#if defined(BOARD_EC600MCN_LF_SLPOC) +STATIC mp_obj_t helios_set_audio_play_mode(size_t n_args, const mp_obj_t *args) + { + if (n_args == 5) + { + if(mp_obj_get_int(args[1]) < 0 || mp_obj_get_int(args[1]) > HELIOS_AUD_START_MODE_MAX) { + mp_raise_ValueError(MP_ERROR_TEXT("parameter error!")); + } + if(mp_obj_get_int(args[2]) > 5000 || mp_obj_get_int(args[2]) < 0) { + mp_raise_ValueError(MP_ERROR_TEXT("Too many time")); + } + + + + audio.play_start_mode = mp_obj_get_int(args[1]); + audio.interval_of_start_dec_pa = mp_obj_get_int(args[2]); + audio.play_end_mode = mp_obj_get_int(args[3]); + audio.interval_of_close_dec_pa = mp_obj_get_int(args[4]); + return mp_obj_new_int(0); + } + else if (n_args == 1) + { + mp_obj_t tuple[4] = + { + mp_obj_new_int(audio.play_start_mode), + mp_obj_new_int(audio.interval_of_start_dec_pa), + mp_obj_new_int(audio.play_end_mode), + mp_obj_new_int(audio.interval_of_close_dec_pa), + }; + return mp_obj_new_tuple(4, tuple); + } + return mp_obj_new_int(-1); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(helios_set_audio_play_mode_obj, 1, 5, helios_set_audio_play_mode); +#endif + +STATIC mp_obj_t helios_get_audio_play_state(mp_obj_t self_in) +{ + int state = 0; + if (audio.audio_state == AUDIO_PLAYING) + { + state = 1; + } + else + { + state = 0; + } + return mp_obj_new_int(state); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_get_audio_play_state_obj, helios_get_audio_play_state); + +STATIC mp_obj_t helios_get_audio_playing_file_name(mp_obj_t self_in) +{ + int i = 0; + int wait_file = 0; + int count = 0; + mp_obj_t wait_list = mp_obj_new_list(0, NULL); + if (audio.audio_state == AUDIO_IDLE) + { + return mp_obj_new_int(-1); + } + for (i=QUEUE_NUMS-1; i>=0; i--) + { + uint8_t front = audio.audio_queue[i].front; + uint8_t rear = audio.audio_queue[i].rear; + uint8_t cur = front; + if (!audio_queue_is_empty(&audio.audio_queue[i])) + { + while(cur != rear) + { + cur = (cur + 1) % QUEUE_SIZE; + mp_obj_list_append(wait_list, mp_obj_new_str(audio.audio_queue[i].audio_data[cur].data, strlen(audio.audio_queue[i].audio_data[cur].data))); + if(cur == rear) + { + break; + } + } + + } + } + mp_obj_t tuple[3] = + { + mp_obj_new_int(audio.total_nums), + mp_obj_new_str(audio_playing_file_name,strlen(audio_playing_file_name)), + wait_list, + }; + return mp_obj_new_tuple(3, tuple); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_get_audio_playing_file_name_obj, helios_get_audio_playing_file_name); + + + +/*=============================================================================*/ +/* FUNCTION: helios_play_file_stop */ +/*=============================================================================*/ +/*!@brief : stop playing the audio file(mp3,amr) + * @param[in] : + * @param[out] : + * @return : + * - 0--success + */ +/*=============================================================================*/ +STATIC mp_obj_t helios_play_file_stop(mp_obj_t self_in) +{ + int ret = Helios_Audio_FilePlayStop(); + return mp_obj_new_int(ret); +} + +STATIC mp_obj_t helios_play_stream_stop(mp_obj_t self_in); + +STATIC mp_obj_t helios_play_file_stop_all(mp_obj_t self_in) +{ + uint8_t i = 0; + int ret = 0; + + helios_set_montage_break_flag(1); + #if defined (PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_Unisoc_8910_R06) + audio_err_handle(); + #endif + + Helios_Mutex_Lock(audio.queue_mutex, HELIOS_WAIT_FOREVER); + for (i=0; i= HELIOS_AUDIO_FORMAT_MAX) + { + mp_raise_ValueError(MP_ERROR_TEXT("Unsupport format!")); + return mp_obj_new_int(-1); + } +#endif + +#if defined (PLAT_ASR) + if(format != HELIOS_AUDIO_FORMAT_WAVPCM && format != HELIOS_AUDIO_FORMAT_MP3 && format != HELIOS_AUDIO_FORMAT_AMRNB + && format != HELIOS_AUDIO_FORMAT_AMRWB) + { + mp_raise_ValueError(MP_ERROR_TEXT("Unsupport format!")); + return mp_obj_new_int(-1); + } +#endif + + audio_obj_t *self = MP_OBJ_TO_PTR(args[0]); + mp_buffer_info_t buff_a; + if(vals[ARG_audiobuf].u_obj != mp_const_none) { + mp_get_buffer_raise(vals[ARG_audiobuf].u_obj, &buff_a, MP_BUFFER_READ); + if(buff_a.len <= 0 || buff_a.buf == NULL) { + mp_raise_ValueError(MP_ERROR_TEXT("invalid audio_buff data")); + } + } +#if defined (PLAT_ASR) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) || defined (PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) \ + || defined(PLAT_ASR_1602) || defined(PLAT_Unisoc_8910_R06) + Helios_mp3_stream_close_flag(vals[ARG_mode].u_int); +#endif + MP_THREAD_GIL_EXIT(); + int ret = 0; + audio.cur_type = AUDIO_STREAM; + if(play_len == 0) { + ret = Helios_Audio_StreamPlayStart(format, buff_a.buf, buff_a.len, HELIOS_AUDIO_PLAY_TYPE_LOCAL, self->device, audio_play_callback); + } else { + ret = Helios_Audio_StreamPlayStart(format, buff_a.buf, play_len, HELIOS_AUDIO_PLAY_TYPE_LOCAL, self->device, audio_play_callback); + } + MP_THREAD_GIL_ENTER(); + return mp_obj_new_int(ret); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_KW(helios_play_stream_start_obj, 1, helios_play_stream_start); + +#if defined (PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_Unisoc_8910_R06) +STATIC mp_obj_t helios_pcm_para_set(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) +{ + enum { ARG_samplerate, ARG_channels }; + static const mp_arg_t allowed_args[] = + { + { MP_QSTR_samplerate, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 44100} }, + { MP_QSTR_channels, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 2} }, + }; + mp_arg_val_t vals[MP_ARRAY_SIZE(allowed_args)]; + mp_arg_parse_all(n_args - 1, args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, vals); + + int samplerate = 0; + samplerate = vals[ARG_samplerate].u_int; + if(samplerate != 96000 && samplerate != 88200 && samplerate != 64000&& samplerate != 48000 && samplerate != 44100 + && samplerate != 32000 && samplerate != 22050 && samplerate != 16000 && samplerate != 11025 && samplerate != 8000 && samplerate!=6000) + { + mp_raise_ValueError(MP_ERROR_TEXT("Unsupport samplerate!")); + return mp_obj_new_int(-1); + } + + int channels = vals[ARG_channels].u_int; + if(channels != 2 && channels != 1) + { + mp_raise_ValueError(MP_ERROR_TEXT("Unsupport channels!")); + return mp_obj_new_int(-1); + } + + Helios_Audio_PCM_para_set(samplerate, channels); + return mp_obj_new_int(0); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_KW(helios_pcm_para_obj, 1, helios_pcm_para_set); +#endif + + +/*=============================================================================*/ +/* FUNCTION: helios_play_stream_stop */ +/*=============================================================================*/ +/*!@brief : stop playing the audio file(mp3,amr) + * @param[in] : + * @param[out] : + * @return : + * - 0--success + */ +/*=============================================================================*/ +STATIC mp_obj_t helios_play_stream_stop(mp_obj_t self_in) +{ + if(0 != audio.montage_mutex) + Helios_Mutex_Lock(audio.montage_mutex, HELIOS_WAIT_FOREVER); + + helios_set_montage_break_flag(1); + #if defined (PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_Unisoc_8910_R06) + audio_err_handle(); + #endif + + int ret = Helios_Audio_StreamPlayStop(); + if(0 != audio.montage_mutex) + Helios_Mutex_Unlock(audio.montage_mutex); + return mp_obj_new_int(ret); + +} +STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_play_stream_stop_obj, helios_play_stream_stop); + + +STATIC mp_obj_t helios_audio_play_stop(mp_obj_t self_in) +{ + int ret = 0; + if(audio.cur_type == AUDIO_MONTAGE || audio.cur_type == AUDIO_STREAM) + { + ret = mp_obj_get_int(helios_play_stream_stop(self_in)); + } + else if(audio.cur_type == AUDIO_FILE) + { + ret = mp_obj_get_int(helios_play_file_stop(self_in)); + } + if(1 == ret) + { + ret = 0; + } + return mp_obj_new_int(ret); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_audio_play_stop_obj, helios_audio_play_stop); + + +/*=============================================================================*/ +/* FUNCTION: helios_get_audio_state */ +/*=============================================================================*/ +/*!@brief : get the initialization state of audio. + * @param[in] : + * @param[out] : + * @return : + * - -1 -- False + * - 0 -- True + */ +/*=============================================================================*/ +STATIC mp_obj_t helios_get_audio_state(mp_obj_t self_in) +{ + #if defined (PLAT_ASR) || defined (PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_Unisoc_8910_R06) + int ret = helios_audio_getInitState(); + #else + int ret = 0; + #endif + return mp_obj_new_int(ret); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_get_audio_state_obj, helios_get_audio_state); + + +/*=============================================================================*/ +/* FUNCTION: helios_set_volume */ +/*=============================================================================*/ +/*!@brief : set volume. + * @param[in] : + * @param[out] : + * @return : + */ +/*=============================================================================*/ +STATIC mp_obj_t helios_set_volume(mp_obj_t self_in, mp_obj_t volume) +{ + int vol = mp_obj_get_int(volume); + if (vol < 0 || vol > 11) + { + mp_raise_ValueError(MP_ERROR_TEXT("invalid value,TTS volume should be array between [0,11]")); + return mp_obj_new_int(-1); + } + + Helios_AudPlayerType type = 1; +#ifdef CONFIG_AUDIO_PWM + int ret = Helios_Aud_PWM_Set_Volume(vol); +#else + int ret = Helios_Audio_SetVolume(type, vol); +#endif + return mp_obj_new_int(ret); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_2(helios_set_volume_obj, helios_set_volume); + + +/*=============================================================================*/ +/* FUNCTION: helios_get_volume */ +/*=============================================================================*/ +/*!@brief : get volume. + * @param[in] : + * @param[out] : + * @return : current volume + */ +/*=============================================================================*/ +STATIC mp_obj_t helios_get_volume(mp_obj_t self_in) +{ + Helios_AudPlayerType type = 1; +#ifdef CONFIG_AUDIO_PWM + int vol = Helios_Aud_PWM_Get_Volume(); +#else + int vol = Helios_Audio_GetVolume(type); +#endif + return mp_obj_new_int(vol); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_get_volume_obj, helios_get_volume); + +#ifdef CONFIG_AUDIO_PWM +STATIC mp_obj_t helios_set_pwm_gain(mp_obj_t self_in, mp_obj_t gain_min, mp_obj_t gain_max) +{ + float gainMin = mp_obj_get_float(gain_min); + float gainMax = mp_obj_get_float(gain_max); + + int ret = Helios_Aud_PWM_Set_Gain_Value(gainMin, gainMax); + return mp_obj_new_int(ret); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_3(helios_set_pwm_gain_obj, helios_set_pwm_gain); +#endif + +#ifdef AUDIO_DTMF_TONE_NEW_SUPPORT +STATIC mp_obj_t helios_set_ToneVolume(mp_obj_t self_in, mp_obj_t volume) +{ + int vol = mp_obj_get_int(volume); + if (vol < 0 || vol > 11) + { + mp_raise_ValueError(MP_ERROR_TEXT("invalid value,Tone volume should be array between [0,10]")); + return mp_obj_new_int(-1); + } + + int ret = Helios_Audio_SetToneVolume(vol); + return mp_obj_new_int(ret); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_2(helios_set_ToneVolume_obj, helios_set_ToneVolume); +#endif + +#if defined (PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_Unisoc_8910_R06) +STATIC mp_obj_t helios_play_stream_jump(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) +{ + enum { ARG_second, ARG_drection }; + static const mp_arg_t allowed_args[] = + { + { MP_QSTR_second, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} }, + { MP_QSTR_drection, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} }, + }; + mp_arg_val_t vals[MP_ARRAY_SIZE(allowed_args)]; + mp_arg_parse_all(n_args - 1, args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, vals); + + int second = 0; + second = vals[ARG_second].u_int; + + int drection = 0; + drection = vals[ARG_drection].u_int; + Helios_JumpInfoStruct info = {0,0}; + info = Helios_Audio_Stream_Jump(second,drection); + if(info.ofs == 0&&info.bytenow == 0) + return mp_obj_new_int(-1); + else + return mp_obj_new_int(0); + +} +STATIC MP_DEFINE_CONST_FUN_OBJ_KW(helios_play_stream_jump_obj, 1, helios_play_stream_jump); + +STATIC mp_obj_t helios_play_stream_pause(mp_obj_t self_in) +{ + int s = Helios_Audio_Stream_Pause(); + return mp_obj_new_int(s); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_play_stream_pause_obj, helios_play_stream_pause); + +STATIC mp_obj_t helios_play_stream_continue(mp_obj_t self_in) +{ + int s = Helios_Audio_Stream_Continue(); + return mp_obj_new_int(s); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_play_stream_continue_obj, helios_play_stream_continue); + +STATIC mp_obj_t helios_play_stream_seek(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) +{ + enum { ARG_second }; + static const mp_arg_t allowed_args[] = + { + { MP_QSTR_second, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} }, + }; + mp_arg_val_t vals[MP_ARRAY_SIZE(allowed_args)]; + mp_arg_parse_all(n_args - 1, args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, vals); + + uint32_t second = 0; + second = vals[ARG_second].u_int; + + long unsigned int bytepos = Helios_Audio_Stream_Seek(second); + + return mp_obj_new_int(bytepos); + +} +STATIC MP_DEFINE_CONST_FUN_OBJ_KW(helios_play_stream_seek_obj, 1, helios_play_stream_seek); +#endif + +#if CONFIG_AUDIO +STATIC mp_obj_t helios_play_frame_jump(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) +{ + enum { ARG_number }; + static const mp_arg_t allowed_args[] = + { + { MP_QSTR_num, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} }, + }; + mp_arg_val_t vals[MP_ARRAY_SIZE(allowed_args)]; + mp_arg_parse_all(n_args - 1, args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, vals); + + extern void Helios_file_jump_frame(Helios_AudStreamFormat format, uint32_t cnt); + Helios_file_jump_frame(HELIOS_AUDIO_FORMAT_MP3, vals[ARG_number].u_int); + + return mp_obj_new_int(0); + +} +STATIC MP_DEFINE_CONST_FUN_OBJ_KW(helios_play_jump_frame_obj, 1, helios_play_frame_jump); +#endif + +#if defined (PLAT_ASR) || defined (PLAT_Unisoc) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) \ + || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_ASR_1602) || defined(PLAT_ASR_1803s) || defined(PLAT_ASR_1803sc) || defined(PLAT_Unisoc_8850_R02) || defined(PLAT_Unisoc_8910_R06) +#ifndef AUDIO_DTMF_TONE_NEW_SUPPORT +STATIC const mp_arg_t tone_allowed_args[] = { + { MP_QSTR_tone, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} }, + { MP_QSTR_time, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 500} }, +}; +#endif +static Helios_OSTimer_t aud_tone_timer = 0; +static Helios_Thread_t aud_tone_thread_id = 0; +static Helios_MsgQ_t aud_tone_queue_msg = 0; +static uint8_t aud_tone_flag = 0; + + +static void helios_aud_tone_play_cb(void *argv) { + uint8_t audio_msg = 1; + Helios_MsgQ_Put(aud_tone_queue_msg, (const void *)&audio_msg, sizeof(uint8_t), HELIOS_NO_WAIT); +} + +static void helios_aud_tone_stop_task(void *argv) +{ + HELIOS_AUDIO_LOG("helios_aud_tone_dtmf_stop_task start...\r\n"); + uint8_t audio_msg = 0; + int ret = 0; + while (1) + { + ret = Helios_MsgQ_Get(aud_tone_queue_msg, (void *)&audio_msg, sizeof(uint8_t), HELIOS_WAIT_FOREVER); + if (ret == 0) + { + switch (audio_msg) + { + case 1: + while(aud_tone_flag == 0){ + Helios_msleep(20); + } + aud_tone_flag = 0; + HELIOS_AUDIO_LOG("----Aud Tone Stop---\r\n"); + Helios_Audio_Stop_Tone(); +#ifdef AUDIO_DTMF_TONE_NEW_SUPPORT + Helios_Audio_Stop_DTMF(); +#endif + break; + default: + break; + } + } + } +} + + +//dial tone,ring back tone +#ifdef AUDIO_DTMF_TONE_NEW_SUPPORT +//dial tone,ring back tone +STATIC mp_obj_t helios_aud_tone_play(size_t n_args, const mp_obj_t *args) +{ + + unsigned int time = 0; + int ret = 0; + int tone = 0; + int f1 = 0, f2 = 0; + unsigned char tone_flag = 0; //0: tone 1:dtmf + + + audio_obj_t *self = MP_OBJ_TO_PTR(args[0]); + + if(n_args == 3) { + tone = mp_obj_get_int(args[1]); + time = mp_obj_get_int(args[2]); + + } else if(n_args == 4) { + f1 = mp_obj_get_int(args[1]); + f2 = mp_obj_get_int(args[2]); + time = mp_obj_get_int(args[3]); + tone_flag = 1; + } + + if(aud_tone_timer == 0) + { + aud_tone_timer = Helios_OSTimer_Create(); + } + + if(aud_tone_timer == 0) + { + return mp_obj_new_int(-1); + } else { + Helios_OSTimer_Stop(aud_tone_timer); + Helios_Audio_Stop_Tone(); + Helios_Audio_Stop_DTMF(); + aud_tone_flag = 0; + } + + if(0 != time) + { + Helios_OSTimerAttr OSTimerAttr = { + .ms = (uint32_t)time, + .cycle_enable = 0, + .cb = helios_aud_tone_play_cb, + .argv = (void *)self + }; + ret = Helios_OSTimer_Start(aud_tone_timer, &OSTimerAttr); + } + + if(ret) + { + HELIOS_AUDIO_LOG("Timer starte failed\r\n"); + } + HELIOS_AUDIO_LOG("Timer started\r\n"); + + if(ret != 0) + { + Helios_Audio_Stop_Tone(); + Helios_Audio_Stop_DTMF(); + if(aud_tone_timer != 0) + { + ret = Helios_OSTimer_Stop(aud_tone_timer); + } + return mp_obj_new_int(-1); + } + + if(0 != time && 0 == aud_tone_thread_id) + { + Helios_ThreadAttr attr = {0}; + attr.name = "aud_tone_stop"; + attr.stack_size = 4096; + attr.priority = 95; + attr.entry = helios_aud_tone_stop_task; + + aud_tone_queue_msg = Helios_MsgQ_Create(10, sizeof(uint8_t)); + if (!aud_tone_queue_msg) + { + return mp_obj_new_int(-1); + } + + aud_tone_thread_id = Helios_Thread_Create(&attr); + if (aud_tone_thread_id == 0) + { + Helios_MsgQ_Delete(aud_tone_queue_msg); + return mp_obj_new_int(-1); + } + } + + while(aud_tone_flag == 1){ + Helios_msleep(20); + } + MP_THREAD_GIL_EXIT(); + if(tone_flag == 0) { + ret = Helios_Audio_Play_DTMF(tone, (uint32_t)time); + } else { + ret = Helios_Audio_Play_Tone(f1, f2); + } + MP_THREAD_GIL_ENTER(); + if(ret != 0) + { + Helios_OSTimer_Stop(aud_tone_timer); + Helios_Audio_Stop_Tone(); + Helios_Audio_Stop_DTMF(); + aud_tone_flag = 0; + return mp_obj_new_int(-1); + } + aud_tone_flag = 1; + return mp_obj_new_int(0); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_helios_aud_tone_play_obj, 3, 4, helios_aud_tone_play); + +#else +STATIC mp_obj_t helios_aud_tone_play(size_t n_args, const mp_obj_t *p_args, mp_map_t *kw_args) +{ + enum { ARG_tone, ARG_time}; + + mp_arg_val_t args[MP_ARRAY_SIZE(tone_allowed_args)]; + mp_arg_parse_all(n_args - 1, p_args + 1, kw_args, + MP_ARRAY_SIZE(tone_allowed_args), tone_allowed_args, args); + + unsigned int time = 0; + int ret = 0; + int tone = 0; + + audio_obj_t *self = MP_OBJ_TO_PTR(p_args[0]); + + tone = args[ARG_tone].u_int; + time = args[ARG_time].u_int; + + if(tone > 22 || tone < 0) + { + mp_raise_ValueError(MP_ERROR_TEXT("Parameter error\n")); + return mp_obj_new_int(-1); + } + + if(aud_tone_timer == 0) + { + aud_tone_timer = Helios_OSTimer_Create(); + } + + if(aud_tone_timer == 0) + { + return mp_obj_new_int(-1); + } else { + Helios_OSTimer_Stop(aud_tone_timer); + Helios_Audio_Stop_Tone(); + aud_tone_flag = 0; + } + + if(0 != time && 0 == aud_tone_thread_id) + { + Helios_ThreadAttr attr = {0}; + attr.name = "aud_tone_stop"; + attr.stack_size = 4096; + attr.priority = 95; + attr.entry = helios_aud_tone_stop_task; + + aud_tone_queue_msg = Helios_MsgQ_Create(10, sizeof(uint8_t)); + if (!aud_tone_queue_msg) + { + return mp_obj_new_int(-1); + } + + aud_tone_thread_id = Helios_Thread_Create(&attr); + if (aud_tone_thread_id == 0) + { + Helios_MsgQ_Delete(aud_tone_queue_msg); + return mp_obj_new_int(-1); + } + } + + while(aud_tone_flag == 1){ + Helios_msleep(20); + } + + if(0 != time) + { + Helios_OSTimerAttr OSTimerAttr = { + .ms = (uint32_t)time, + .cycle_enable = 0, + .cb = helios_aud_tone_play_cb, + .argv = (void *)self + }; + ret = Helios_OSTimer_Start(aud_tone_timer, &OSTimerAttr); + } + if(ret) + { + HELIOS_AUDIO_LOG("Timer starte failed\r\n"); + } + + if(ret != 0) + { + Helios_Audio_Stop_Tone(); + if(aud_tone_timer != 0) + { + ret = Helios_OSTimer_Stop(aud_tone_timer); + } + return mp_obj_new_int(-1); + } + + MP_THREAD_GIL_EXIT(); + aud_tone_flag = 1; + ret = Helios_Audio_Play_Tone(tone, (uint32_t)time); + MP_THREAD_GIL_ENTER(); + if(ret != 0) + { + Helios_OSTimer_Stop(aud_tone_timer); + Helios_Audio_Stop_Tone(); + aud_tone_flag = 0; + return mp_obj_new_int(-1); + } + return mp_obj_new_int(0); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_KW(mp_helios_aud_tone_play_obj, 1, helios_aud_tone_play); +#endif + +STATIC mp_obj_t helios_aud_tone_play_stop(mp_obj_t self_in) +{ + int ret = 0; + Helios_Audio_Stop_Tone(); +#ifdef AUDIO_DTMF_TONE_NEW_SUPPORT + Helios_Audio_Stop_DTMF(); + +#endif + if(aud_tone_timer != 0) { + ret = Helios_OSTimer_Stop(aud_tone_timer); + } + return mp_obj_new_int(ret); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_aud_tone_play_stop_obj, helios_aud_tone_play_stop); + +#if defined(BOARD_EC800GCN_LD_XBND) +STATIC mp_obj_t helios_aud_set_tone_gain(mp_obj_t self_in, mp_obj_t gain) { + int tone_gain = mp_obj_get_int(gain); + if (tone_gain < 0 || tone_gain > 0x4000) + { + mp_raise_ValueError(MP_ERROR_TEXT("invalid value,tone gain should be array between [0x0, 0x4000]")); + return mp_obj_new_int(-1); + } + int ret = 0; + ret = Helios_Audio_Set_Tone_Gain(tone_gain); + return mp_obj_new_int(ret); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_2(helios_aud_set_tone_gain_obj, helios_aud_set_tone_gain); +#endif + +#endif + + +#if defined (PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_Unisoc_8910_R06) +STATIC mp_obj_t helios_setGainTabel(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) +{ + + int i = 0,ret = -1; + int16_t gain[12] = {0xff}; + + HELIOS_AUDIO_LOG("gain para count = %d\n",n_args); + if(n_args != 14) { + mp_raise_ValueError(MP_ERROR_TEXT("Please enter complete parameters, including the gain corresponding to ID and volume (0-11)")); + } + + HELIOS_AUDIO_LOG("gain id[%d]\n",mp_obj_get_int(args[1])); + + for (i = 0; i < 12; i++) { + gain[i] = mp_obj_get_int(args[i+2]); + HELIOS_AUDIO_LOG("gain para[%d]:%d\n",i,gain[i]); + if (gain[i] < -26 || gain[i] > 23) { + mp_raise_ValueError(MP_ERROR_TEXT("gain error, gain is out (-26db-23db)")); + return mp_obj_new_int(-1); + } + } + + if( 0 != Helios_Audio_SetDSPGainTable(mp_obj_get_int(args[1]), gain)) { + return mp_obj_new_int(-1); + } + return mp_obj_new_int(0); + + +} +STATIC MP_DEFINE_CONST_FUN_OBJ_KW(helios_setgaintabel_obj, 1, helios_setGainTabel); +#endif + +#if defined (PLAT_EIGEN) || defined(PLAT_EIGEN_718) +STATIC mp_obj_t helios_setGainTabel(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) +{ + + int i = 0,ret = -1; + int16_t gain[12] = {0xff}; + + HELIOS_AUDIO_LOG("gain para count = %d\n",n_args); + if(n_args != 13) { + mp_raise_ValueError(MP_ERROR_TEXT("Please enter complete parameters, including the gain corresponding to ID and volume (0-11)")); + } + + HELIOS_AUDIO_LOG("gain id[%d]\n",mp_obj_get_int(args[1])); + + for (i = 0; i < 11; i++) { + gain[i] = mp_obj_get_int(args[i+2]); + HELIOS_AUDIO_LOG("gain para[%d]:%d\n",i,gain[i]); + if (gain[i] < -36 || gain[i] > 36) { + mp_raise_ValueError(MP_ERROR_TEXT("gain error, gain is out (-36db-36db)")); + return mp_obj_new_int(-1); + } + } + + if( 0 != Helios_Audio_SetDigGainTable(mp_obj_get_int(args[1]), gain)) { + return mp_obj_new_int(-1); + } + return mp_obj_new_int(0); + + +} +STATIC MP_DEFINE_CONST_FUN_OBJ_KW(helios_setgaintabel_obj, 1, helios_setGainTabel); + +#endif + +STATIC mp_obj_t helios_audio___del__(mp_obj_t self_in) +{ + uint8_t i = 0; + audio_obj_t *self = MP_OBJ_TO_PTR(self_in); + Helios_Mutex_Lock(audio.queue_mutex, HELIOS_WAIT_FOREVER); + for (i=0; idevice] = NULL; + + int ret = Helios_Audio_FilePlayStop(); + return mp_obj_new_int(ret); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_audio___del___obj, helios_audio___del__); + +//================================montage Handel start===================================================== +#if defined (PLAT_Unisoc) || defined (PLAT_ASR) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) || defined(PLAT_EIGEN) \ +|| defined(PLAT_Unisoc_8910_R05) || defined(PLAT_ASR_1602) || defined(PLAT_EIGEN_718) || defined(PLAT_Unisoc_8910_R06) + +extern int Helios_Audio_MontageFilePlayStart(char *montage_name, char *file_name, Helios_AudPlayerType type, helios_cb_on_player usr_cb, int device); +static mp_obj_t helios_play_montage_file_start(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) +{ + enum + { + ARF_montage_file, + ARG_priority, + ARG_breakin, + ARG_data + }; + static const mp_arg_t allowed_args[] = + { + {MP_QSTR_montageFile, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL}}, + {MP_QSTR_priority, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0}}, + {MP_QSTR_breakin, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0}}, + {MP_QSTR_data, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL}}, + }; + mp_arg_val_t vals[MP_ARRAY_SIZE(allowed_args)]; + mp_arg_parse_all(n_args - 1, args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, vals); + + if(vals[ARG_priority].u_int > 4) + { + mp_raise_ValueError(MP_ERROR_TEXT("invalid priority,must be in 0~4")); + } + if(vals[ARG_breakin].u_int > 1) + { + mp_raise_ValueError(MP_ERROR_TEXT("invalid breakin,must be in 0~1")); + } + audio_obj_t *self = MP_OBJ_TO_PTR(args[0]); + int new_priority = vals[ARG_priority].u_int; + int new_breakin = vals[ARG_breakin].u_int; + char vfs_name[256] = {0}; + char *new_data = NULL; + char *new_monFile = NULL; + char vfs_monFile[256] = {0}; + if (mp_obj_is_str(vals[ARG_data].u_obj)) + { + new_data = (char *)mp_obj_str_get_str(vals[ARG_data].u_obj); + } + else + { + mp_raise_ValueError(MP_ERROR_TEXT("invalid data")); + } + // GET_FILE_VFS_PATH(new_data, vfs_name); + memcpy(vfs_name, new_data, strlen(new_data)); + + if (mp_obj_is_str(vals[ARF_montage_file].u_obj)) + { + new_monFile = (char *)mp_obj_str_get_str(vals[ARF_montage_file].u_obj); + } + else + { + mp_raise_ValueError(MP_ERROR_TEXT("invalid montage fail")); + } + GET_FILE_VFS_PATH(new_monFile, vfs_monFile); + + HeliosFILE *fp = Helios_fopen(vfs_monFile, "rb"); + if (NULL == fp) + { + HELIOS_AUDIO_LOG("montage(%s) does not exist\n", vfs_monFile); + mp_raise_ValueError(MP_ERROR_TEXT("monatage file does not exist")); + } else { + Helios_fclose(fp); + } + + + Helios_Mutex_Lock(audio.queue_mutex, HELIOS_WAIT_FOREVER); + mp_printf(&mp_plat_print, "audio.audio_state :%d\n",audio.audio_state ); + if (audio.audio_state == AUDIO_IDLE) + { + // HELIOS_AUDIO_LOG("----- audio 1-----\r\n"); + audio.cur_priority = new_priority; + audio.cur_breakin = new_breakin; + audio.cur_type = AUDIO_MONTAGE; + audio.audio_state = AUDIO_PLAYING; + Helios_Mutex_Unlock(audio.queue_mutex); + } + else if (audio.audio_state == AUDIO_PLAYING) + { + if (new_priority >= audio.cur_priority) + { + if (audio.cur_breakin == 1) + { + audio.audio_state = AUDIO_PLAYING; + + if (!audio_queue_is_full(&audio.audio_queue[new_priority])) + { + // Helios_Mutex_Lock(audio.queue_mutex, HELIOS_WAIT_FOREVER); + HELIOS_AUDIO_LOG("----- audio 2[%d,%d]-----\r\n", new_priority, audio.cur_priority); + uint8_t rear = audio.audio_queue[new_priority].rear; + uint8_t front = audio.audio_queue[new_priority].front; + + if (audio.audio_queue[new_priority].audio_data[rear].breakin == 0) + { + rear = (rear + 1) % QUEUE_SIZE; + audio.total_nums++; + } + else if (audio.audio_queue[new_priority].audio_data[rear].breakin == 1) + { + if (front == rear) + { + if (front == 0) + { + front = QUEUE_SIZE - 1; + } + else + { + front = (front - 1) % QUEUE_SIZE; + } + audio.total_nums++; + } + } + + audio.audio_queue[new_priority].audio_data[rear].audio_type = AUDIO_MONTAGE; + audio.audio_queue[new_priority].audio_data[rear].priority = new_priority; + audio.audio_queue[new_priority].audio_data[rear].breakin = new_breakin; + audio.audio_queue[new_priority].audio_data[rear].mode = 0; + + FREE_BUFF(audio.audio_queue[new_priority].audio_data[rear].data); + FREE_BUFF(audio.audio_queue[new_priority].audio_data[rear].montage); + + CALLOC_BUFF_SET(audio.audio_queue[new_priority].audio_data[rear].data, new_data); + CALLOC_BUFF_SET(audio.audio_queue[new_priority].audio_data[rear].montage, new_monFile); + + audio.audio_queue[new_priority].audio_data[rear].device = self->device; + audio.audio_queue[new_priority].rear = rear; + audio.audio_queue[new_priority].front = front; + + Helios_Mutex_Unlock(audio.queue_mutex); + } + else + { + Helios_Mutex_Unlock(audio.queue_mutex); + return mp_obj_new_int(-2); + } + + switch (audio.cur_type) + { + #if MICROPY_QPY_AUDIO_TTS + case AUDIO_TTS: + { + HELIOS_AUDIO_LOG("---- stop tts play. ----\r\n"); + Helios_TTS_Stop(); + break; + } + #endif + case AUDIO_FILE: + { + HELIOS_AUDIO_LOG("---- stop audio file play. ----\r\n"); + Helios_Audio_FilePlayStop(); + break; + } + case AUDIO_MONTAGE: + { + Helios_Mutex_Lock(audio.montage_mutex, HELIOS_WAIT_FOREVER); + HELIOS_AUDIO_LOG("---- stop audio montage play. ----\r\n"); + audio.montage_is_stopping = 1; + helios_set_montage_break_flag(1); + #if !defined(PLAT_EIGEN) && !defined(PLAT_EIGEN_718) + audio_err_handle(); + #endif + Helios_msleep(200); + + Helios_Audio_StreamPlayStop(); + audio.montage_is_stopping = 0; + Helios_Mutex_Unlock(audio.montage_mutex); + Helios_msleep(200); + uint8_t audio_msg = AUDIO_FINISH_EVENT; + if (Helios_MsgQ_Put(audio.queue_msg, (const void *)&audio_msg, sizeof(uint8_t), HELIOS_NO_WAIT) == -1) + { + HELIOS_AUDIO_LOG("send audio msg failed[%u].\r\n", audio_msg); + return mp_obj_new_int(-1); + } + break; + } + default: + { + HELIOS_AUDIO_LOG("Unknown audio type.\r\n"); + return mp_obj_new_int(-1); + } + } + + return mp_obj_new_int(0); + } + else if (audio.cur_breakin == 0) + { + if (!audio_queue_is_full(&audio.audio_queue[new_priority])) + { + // Helios_Mutex_Lock(audio.queue_mutex, HELIOS_WAIT_FOREVER); + uint8_t rear = audio.audio_queue[new_priority].rear; + uint8_t front = audio.audio_queue[new_priority].front; + + if (audio.audio_queue[new_priority].audio_data[rear].breakin == 0) + { + rear = (rear + 1) % QUEUE_SIZE; + audio.total_nums++; + } + else if (audio.audio_queue[new_priority].audio_data[rear].breakin == 1) + { + if (front == rear) + { + if (front == 0) + { + front = QUEUE_SIZE - 1; + } + else + { + front = (front - 1) % QUEUE_SIZE; + } + audio.total_nums++; + } + } + + audio.audio_queue[new_priority].audio_data[rear].audio_type = AUDIO_MONTAGE; + audio.audio_queue[new_priority].audio_data[rear].priority = new_priority; + audio.audio_queue[new_priority].audio_data[rear].breakin = new_breakin; + audio.audio_queue[new_priority].audio_data[rear].mode = 0; + FREE_BUFF(audio.audio_queue[new_priority].audio_data[rear].data); + FREE_BUFF(audio.audio_queue[new_priority].audio_data[rear].montage); + + CALLOC_BUFF_SET(audio.audio_queue[new_priority].audio_data[rear].data, new_data); + CALLOC_BUFF_SET(audio.audio_queue[new_priority].audio_data[rear].montage, new_monFile); + audio.audio_queue[new_priority].rear = rear; + audio.audio_queue[new_priority].audio_data[rear].device = self->device; + + Helios_Mutex_Unlock(audio.queue_mutex); + } + else + { + Helios_Mutex_Unlock(audio.queue_mutex); + return mp_obj_new_int(-2); + } + + return mp_obj_new_int(1); + } + } + else + { + if (!audio_queue_is_full(&audio.audio_queue[new_priority])) + { + // Helios_Mutex_Lock(audio.queue_mutex, HELIOS_WAIT_FOREVER); + uint8_t rear = audio.audio_queue[new_priority].rear; + uint8_t front = audio.audio_queue[new_priority].front; + + if (audio.audio_queue[new_priority].audio_data[rear].breakin == 0) + { + rear = (rear + 1) % QUEUE_SIZE; + audio.total_nums++; + } + else if (audio.audio_queue[new_priority].audio_data[rear].breakin == 1) + { + if (front == rear) + { + if (front == 0) + { + front = QUEUE_SIZE - 1; + } + else + { + front = (front - 1) % QUEUE_SIZE; + } + audio.total_nums++; + } + } + + audio.audio_queue[new_priority].audio_data[rear].audio_type = AUDIO_MONTAGE; + audio.audio_queue[new_priority].audio_data[rear].priority = new_priority; + audio.audio_queue[new_priority].audio_data[rear].breakin = new_breakin; + audio.audio_queue[new_priority].audio_data[rear].mode = 0; + FREE_BUFF(audio.audio_queue[new_priority].audio_data[rear].data); + FREE_BUFF(audio.audio_queue[new_priority].audio_data[rear].montage); + + CALLOC_BUFF_SET(audio.audio_queue[new_priority].audio_data[rear].data, new_data); + CALLOC_BUFF_SET(audio.audio_queue[new_priority].audio_data[rear].montage, new_monFile); + audio.audio_queue[new_priority].rear = rear; + audio.audio_queue[new_priority].front = front; + audio.audio_queue[new_priority].audio_data[rear].device = self->device; + + Helios_Mutex_Unlock(audio.queue_mutex); + } + else + { + Helios_Mutex_Unlock(audio.queue_mutex); + return mp_obj_new_int(-2); + } + + return mp_obj_new_int(1); + } + } + + HELIOS_AUDIO_LOG("Helios_Audio_MontageFilePlayStart start %s # %s\r\n", vfs_monFile, new_data); + int ret = Helios_Audio_MontageFilePlayStart(vfs_monFile, new_data, HELIOS_AUDIO_PLAY_TYPE_LOCAL, audio_play_callback, self->device); + HELIOS_AUDIO_LOG("Helios_Audio_MontageFilePlayStart ret = %d\r\n", ret); + if (ret == -1) + { + Helios_Mutex_Lock(audio.queue_mutex, HELIOS_WAIT_FOREVER); + audio.audio_state = AUDIO_IDLE; + Helios_Mutex_Unlock(audio.queue_mutex); + } + else + { + memcpy(audio_playing_file_name, vfs_monFile ,strlen(vfs_monFile)); + } + + return mp_obj_new_int(ret); +} +static MP_DEFINE_CONST_FUN_OBJ_KW(helios_play_montage_file_start_obj, 1, helios_play_montage_file_start); +#endif + +//================================montage Handel end===================================================== + +#if defined (PLAT_ASR) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) || defined(PLAT_ASR_1602) +#if CONFIG_AUDIO_MP3 +STATIC mp_obj_t helios_aud_mp3_clear_cache(mp_obj_t self_in) +{ + int ret = Helios_mp3_Clear_Cache(); + return mp_obj_new_int(ret); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_aud_clear_cache_obj, helios_aud_mp3_clear_cache); + +STATIC mp_obj_t helios_aud_mp3_cache_size(mp_obj_t self_in) +{ + int ret = Helios_mp3_get_cache_size(); + return mp_obj_new_int(ret); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_aud_cache_size_obj, helios_aud_mp3_cache_size); +#endif +#endif + +#if defined (PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_Unisoc_8850_R02) || defined(PLAT_ASR_1606) || defined(PLAT_Unisoc_8910_R06) +STATIC mp_obj_t mpy_get_audio_file_time_lenth(mp_obj_t self_in, mp_obj_t filename) { + char vfs_name[256] = {0}; + char *new_data = NULL; + + if (mp_obj_is_str(filename)) + { + new_data = (char *)mp_obj_str_get_str(filename); + } + else + { + mp_raise_ValueError(MP_ERROR_TEXT("invalid data")); + } + GET_FILE_VFS_PATH(new_data, vfs_name); + + int ret = Helios_get_audio_file_time_lenth(vfs_name); + return mp_obj_new_int(ret); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_2(mpy_get_audio_file_time_lenth_obj, mpy_get_audio_file_time_lenth); +#endif + +#if defined (PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_Unisoc_8850_R02) || defined(PLAT_Unisoc_8910_R06) +STATIC mp_obj_t mpy_audio_pause(mp_obj_t self_in, mp_obj_t enable_obj) { + int enable = mp_obj_get_int(enable_obj); + if (enable == 1) { + return mp_obj_new_int(Helios_Audio_Stream_Pause()); + } else { + return mp_obj_new_int(Helios_Audio_Stream_Continue()); + } + +} +STATIC MP_DEFINE_CONST_FUN_OBJ_2(mpy_audio_pause_obj, mpy_audio_pause); +#endif + +#if defined(PLAT_ASR_1606) && (defined(BOARD_EC600MCN_LE_POC_QS)|| defined(BOARD_EC600MCN_LA_POC_XBND)) +STATIC mp_obj_t helios_audio_denoise_config(mp_uint_t n_args, const mp_obj_t *args) { + unsigned char cfg = 0; + int ret =-1; + if(n_args == 1) + { + ret = Helios_Audio_Get_Denoise(&cfg); + if(0 != ret) + { + return mp_obj_new_int(-1); + } + return mp_obj_new_int(cfg); + } + else if(n_args == 2) + { + unsigned char check_flag = 0; + Helios_Audio_Check_Denoise_Licenses_Verify(&check_flag); + if(0 == check_flag) + { + return mp_obj_new_int(-2); + } + cfg = mp_obj_get_int(args[1]); + ret = Helios_Audio_Set_Denoise(cfg); + return mp_obj_new_int(ret); + } + return mp_obj_new_int(-1); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(helios_audio_denoise_config_obj, 1, 2, (mp_obj_t)helios_audio_denoise_config); + +STATIC mp_obj_t helios_audio_denoise_check_verify(mp_obj_t self_in) +{ + unsigned char check_flag = 0; + Helios_Audio_Check_Denoise_Licenses_Verify(&check_flag); + return mp_obj_new_int(check_flag); //0-unauthorized 1-authorized +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_audio_denoise_check_verify_obj, helios_audio_denoise_check_verify); + +STATIC mp_obj_t helios_audio_get_denoise_libary_version(mp_obj_t self_in) +{ + char version[64] = {0}; + char data_len = 0; + Helios_Audio_Get_Denoise_Lib_Version(&version); + for(int i=0; i<64; i++) + { + if(version[i]==0) + { + data_len = i; + break; + } + } + return mp_obj_new_str(version, data_len); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_audio_get_denoise_libary_version_obj, helios_audio_get_denoise_libary_version); + + +#endif +const mp_obj_type_t audio_audio_pcm; + +STATIC const mp_rom_map_elem_t audio_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&helios_audio___del___obj) }, + { MP_ROM_QSTR(MP_QSTR_play), MP_ROM_PTR(&helios_play_file_start_obj) }, + { MP_ROM_QSTR(MP_QSTR_stop), MP_ROM_PTR(&helios_audio_play_stop_obj) }, + { MP_ROM_QSTR(MP_QSTR_stopAll), MP_ROM_PTR(&helios_play_file_stop_all_obj) }, + { MP_ROM_QSTR(MP_QSTR_getState), MP_ROM_PTR(&helios_get_audio_state_obj) }, + { MP_ROM_QSTR(MP_QSTR_getPlayState), MP_ROM_PTR(&helios_get_audio_play_state_obj) }, + { MP_ROM_QSTR(MP_QSTR_getPlayFile), MP_ROM_PTR(&helios_get_audio_playing_file_name_obj) }, +#if defined(PLAT_Unisoc_8850_R02) && defined(CONFIG_POC) + { MP_ROM_QSTR(MP_QSTR_setDataDumpLog), MP_ROM_PTR(&helios_set_audio_data_dump_log_obj) }, +#endif +#if defined(PLAT_ASR_1606) && (defined(BOARD_EC600MCN_LE_POC_QS)|| defined(BOARD_EC600MCN_LA_POC_XBND)) + { MP_ROM_QSTR(MP_QSTR_audDenoiseConfig), MP_ROM_PTR(&helios_audio_denoise_config_obj) }, + { MP_ROM_QSTR(MP_QSTR_audDenoiseCheckVerify), MP_ROM_PTR(&helios_audio_denoise_check_verify_obj) }, + { MP_ROM_QSTR(MP_QSTR_audDenoiseVersion), MP_ROM_PTR(&helios_audio_get_denoise_libary_version_obj) }, +#endif + #ifdef AUDIO_DTMF_TONE_NEW_SUPPORT + { MP_ROM_QSTR(MP_QSTR_setToneVolume), MP_ROM_PTR(&helios_set_ToneVolume_obj) }, + #endif + { MP_ROM_QSTR(MP_QSTR_setVolume), MP_ROM_PTR(&helios_set_volume_obj) }, + { MP_ROM_QSTR(MP_QSTR_getVolume), MP_ROM_PTR(&helios_get_volume_obj) }, +#ifdef CONFIG_AUDIO_PWM + { MP_ROM_QSTR(MP_QSTR_setPwmGain), MP_ROM_PTR(&helios_set_pwm_gain_obj) }, +#endif + { MP_ROM_QSTR(MP_QSTR_setCallback), MP_ROM_PTR(&helios_set_audio_callback_obj) }, + { MP_ROM_QSTR(MP_QSTR_playStream), MP_ROM_PTR(&helios_play_stream_start_obj) }, + { MP_ROM_QSTR(MP_QSTR_stopPlayStream), MP_ROM_PTR(&helios_play_stream_stop_obj) }, +#if defined (PLAT_ASR) || defined (PLAT_Unisoc) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) || defined (PLAT_Unisoc_8850) \ + || defined(PLAT_EIGEN) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_ASR_1602) || defined(PLAT_Unisoc_8850_R02) \ + || defined(PLAT_EIGEN_718) || defined(PLAT_Unisoc_8910_R06) || defined(PLAT_ASR_1803s) || defined(PLAT_ASR_1803sc) +#if !CONFIG_AUDIO_PWM +#if !defined(PLAT_EIGEN) && !defined(PLAT_EIGEN_718) + { MP_ROM_QSTR(MP_QSTR_set_channel), MP_ROM_PTR(&helios_set_channel_obj) }, +#endif +#endif + { MP_ROM_QSTR(MP_QSTR_set_pa), MP_ROM_PTR(&helios_set_pa_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_open_pa_delay), MP_ROM_PTR(&helios_set_open_pa_delay_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_close_pa_delay), MP_ROM_PTR(&helios_set_close_pa_delay_obj) }, + { MP_ROM_QSTR(MP_QSTR_setSpeakerpaCallback), MP_ROM_PTR(&helios_set_speakerpa_callback_obj) }, + { MP_ROM_QSTR(MP_QSTR_setSpeakerpaSwitch), MP_ROM_PTR(&helios_user_speakerpa_switch_obj) }, +#if defined (PLAT_Unisoc) + { MP_ROM_QSTR(MP_QSTR_internal_pa_type), MP_ROM_PTR(&helios_internal_pa_type_obj) }, +#endif + +#endif +#if defined (PLAT_ASR) || defined (PLAT_Unisoc) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_Unisoc_8910_R06) \ + || defined(PLAT_ASR_1602) || defined(PLAT_ASR_1803s) || defined(PLAT_ASR_1803sc) || defined(PLAT_Unisoc_8850_R02) + { MP_ROM_QSTR(MP_QSTR_aud_tone_play), MP_ROM_PTR(&mp_helios_aud_tone_play_obj) }, + { MP_ROM_QSTR(MP_QSTR_aud_tone_play_stop), MP_ROM_PTR(&helios_aud_tone_play_stop_obj) }, +#if defined(BOARD_EC800GCN_LD_XBND) + { MP_ROM_QSTR(MP_QSTR_aud_set_tone_gain), MP_ROM_PTR(&helios_aud_set_tone_gain_obj) }, +#endif +#if defined (PLAT_ASR) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) || defined(PLAT_ASR_1602) + #if CONFIG_AUDIO_MP3 + { MP_ROM_QSTR(MP_QSTR_aud_cache_clear), MP_ROM_PTR(&helios_aud_clear_cache_obj) }, + { MP_ROM_QSTR(MP_QSTR_aud_cache_size), MP_ROM_PTR(&helios_aud_cache_size_obj) }, + #endif +#endif +#endif +#if defined (PLAT_ASR) || defined (PLAT_Unisoc) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) || defined(PLAT_EIGEN) \ + || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_ASR_1602) || defined(PLAT_EIGEN_718) || defined(PLAT_Unisoc_8910_R06) + { MP_ROM_QSTR(MP_QSTR_montage_play), MP_ROM_PTR(&helios_play_montage_file_start_obj) }, +#endif +#if CONFIG_AUDIO + { MP_ROM_QSTR(MP_QSTR_FrameJumpNum), MP_ROM_PTR(&helios_play_jump_frame_obj) }, +#endif +#if defined (PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_Unisoc_8910_R06) + { MP_ROM_QSTR(MP_QSTR_pcmParaSet), MP_ROM_PTR(&helios_pcm_para_obj) }, + { MP_ROM_QSTR(MP_QSTR_StreamJump), MP_ROM_PTR(&helios_play_stream_jump_obj) }, + { MP_ROM_QSTR(MP_QSTR_StreamPause), MP_ROM_PTR(&helios_play_stream_pause_obj) }, + { MP_ROM_QSTR(MP_QSTR_StreamContinue), MP_ROM_PTR(&helios_play_stream_continue_obj) }, + { MP_ROM_QSTR(MP_QSTR_StreamSeek), MP_ROM_PTR(&helios_play_stream_seek_obj) }, +#endif +#if defined (PLAT_Unisoc) || defined (PLAT_EIGEN) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_EIGEN_718) || defined(PLAT_Unisoc_8910_R06) + { MP_ROM_QSTR(MP_QSTR_setGainTabel), MP_ROM_PTR(&helios_setgaintabel_obj) }, +#endif +#if defined (PLAT_ASR) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) || defined(PLAT_ASR_1803s) || defined(PLAT_ASR_1803sc) || defined(PLAT_ASR_1602) \ + || defined(PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_Unisoc_8910_R06) + { MP_ROM_QSTR(MP_QSTR_PCM), MP_ROM_PTR(&audio_audio_pcm) }, +#endif + +#if defined(BOARD_EC600MCN_LE_POC_QS) || defined(BOARD_EC600MCN_LA_POC_QS) + { MP_ROM_QSTR(MP_QSTR_set_audio_read_delay), MP_ROM_PTR(&mpy_set_audio_read_delay_obj) }, +#endif +#if defined(BOARD_EC600MCN_LF_SLPOC) + { MP_ROM_QSTR(MP_QSTR_playModeConfig), MP_ROM_PTR(&helios_set_audio_play_mode_obj) }, + { MP_ROM_QSTR(MP_QSTR_OPEN_CODEC_THEN_PA), MP_ROM_INT(0) }, + { MP_ROM_QSTR(MP_QSTR_OPEN_PA_THEN_CODEC), MP_ROM_INT(1) }, + { MP_ROM_QSTR(MP_QSTR_CLOSE_CODEC_THEN_PA), MP_ROM_INT(0) }, + { MP_ROM_QSTR(MP_QSTR_CLOSE_PA_THEN_CODEC), MP_ROM_INT(1) }, + +#endif + +#if defined (PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_Unisoc_8850_R02) || defined(PLAT_Unisoc_8910_R06) + { MP_ROM_QSTR(MP_QSTR_pause), MP_ROM_PTR(&mpy_audio_pause_obj) }, +#endif +#if defined (PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_Unisoc_8850_R02) || defined(PLAT_ASR_1606) || defined(PLAT_Unisoc_8910_R06) + { MP_ROM_QSTR(MP_QSTR_getFileTimeLenth), MP_ROM_PTR(&mpy_get_audio_file_time_lenth_obj) }, +#endif +}; +STATIC MP_DEFINE_CONST_DICT(audio_locals_dict, audio_locals_dict_table); + +const mp_obj_type_t audio_audio_type = { + { &mp_type_type }, + .name = MP_QSTR_Audio, + .make_new = audio_make_new, + .locals_dict = (mp_obj_dict_t *)&audio_locals_dict, +}; + +#if defined (PLAT_ASR) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) || defined(PLAT_ASR_1803s) || defined(PLAT_ASR_1803sc) || defined(PLAT_ASR_1602) || defined(PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_Unisoc_8910_R06) + +#define QL_PCM_BLOCK_FLAG (0x01) +#define QL_PCM_NONBLOCK_FLAG (0x02) +#define QL_PCM_READ_FLAG (0x04) +#define QL_PCM_WRITE_FLAG (0x08) + + + +enum { + MIC_CHANNEL_RECEIVER, + MIC_CHANNEL_HEADSET, + MIC_CHANNEL_AUTO, + MIC_CHANNEL_MAX, +}; + + + +typedef struct _machine_pcm_obj_t { + mp_obj_base_t base; + void* handle_read; + void* handle_write; + int mic_channel; + unsigned int channels; + unsigned int samplerate; + unsigned int flags; + unsigned int mode; + void* PCM_stream_ring_buf; + char PCM_stream_RW_flag; + char pause_flag ; +} machine_pcm_obj_t; + +const mp_obj_type_t audio_audio_pcm; + +static bool is_support_samplerate(unsigned int rate) +{ + switch(rate) { + case 8000: + case 11025: + case 12000: + case 16000: + case 22050: + case 24000: + case 32000: + case 44100: + case 48000: + return true; + } + return false; +} + +enum{ + PCM_FLAG_READ_ONLY, + PCM_FLAG_WRITE_ONLY, + PCM_FLAG_WRITE_READ, + PCM_FLAG_MAX, +}; +#if defined(PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) +static int poc_mode_state = 0; +#endif +STATIC void machine_pcm_init_helper(machine_pcm_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) { + enum { ARG_channel, ARG_samplerate, ARG_flags, ARG_mode, ARG_periodcnt}; + static const mp_arg_t allowed_args[] = { + { MP_QSTR_channel, MP_ARG_INT, {.u_int = 1} }, + { MP_QSTR_samplerate, MP_ARG_INT, {.u_int = 8000} }, + { MP_QSTR_flag, MP_ARG_INT, {.u_int = PCM_FLAG_WRITE_READ} }, + { MP_QSTR_mode, MP_ARG_INT, {.u_int = QL_PCM_BLOCK_FLAG} }, + { MP_QSTR_periodcnt, MP_ARG_INT, {.u_int = 3} }, + }; + + + mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)]; + mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args); + + if(args[ARG_channel].u_int > 2) { + mp_raise_ValueError(MP_ERROR_TEXT("invalid channels")); + } + + if(true != is_support_samplerate(args[ARG_samplerate].u_int)) { + mp_raise_ValueError(MP_ERROR_TEXT("invalid samplerate")); + } + + if(args[ARG_flags].u_int >= PCM_FLAG_MAX) { + mp_raise_ValueError(MP_ERROR_TEXT("invalid flag")); + } + + if(args[ARG_mode].u_int != QL_PCM_BLOCK_FLAG && args[ARG_mode].u_int != QL_PCM_NONBLOCK_FLAG){ + mp_raise_ValueError(MP_ERROR_TEXT("invalid mode, Value range [1,2]. 1: BLOCK 2:NOBLOCK")); + } + + if(args[ARG_periodcnt].u_int < 2 || args[ARG_periodcnt].u_int > 25){ + mp_raise_ValueError(MP_ERROR_TEXT("invalid periodcnt, Value range [2,25]")); + } + + self->channels = args[ARG_channel].u_int; + self->flags = args[ARG_flags].u_int; + self->samplerate = args[ARG_samplerate].u_int; + self->mode = args[ARG_mode].u_int; +#if !(defined(PLAT_ASR_1803s) || defined(PLAT_ASR_1803sc)) + Helios_set_mic_channel(self->mic_channel); +#endif + Helios_PCM_CONFIG_T pcm_info = {0}; + pcm_info.channels = args[ARG_channel].u_int; + pcm_info.samplerate = args[ARG_samplerate].u_int; + pcm_info.periodcnt = args[ARG_periodcnt].u_int; + +#if defined(PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) + if(args[ARG_flags].u_int == PCM_FLAG_WRITE_READ){ + Helios_set_pcm_type(HELIOS_PCM_POC, HELIOS_POC_TYPE_FULL_DUPLEX); + } + else{ + Helios_set_pcm_type(HELIOS_PCM_LOCAL, HELIOS_POC_TYPE_FULL_DUPLEX); + } +#endif + +#if defined(PLAT_Unisoc_8910_R06) + if (args[ARG_flags].u_int == PCM_FLAG_WRITE_READ) { + mp_raise_ValueError(MP_ERROR_TEXT("not support this mode")); // Unisoc 8910 C2 Audio do nont support duplex mode + } +#endif + switch (args[ARG_flags].u_int) + { + case PCM_FLAG_READ_ONLY: +#if CONFIG_AUDIO + self->handle_read = Helios_PCM_Open(pcm_info.channels, pcm_info.samplerate, QL_PCM_READ_FLAG|args[ARG_mode].u_int); +#else + self->handle_read = Helios_PCM_Open(&pcm_info, QL_PCM_READ_FLAG|args[ARG_mode].u_int); +#endif + if(NULL == self->handle_read) { + mp_raise_ValueError(MP_ERROR_TEXT("pcm open read only fail")); + } + self->handle_write = NULL; + break; + case PCM_FLAG_WRITE_ONLY: +#if CONFIG_AUDIO + self->handle_write = Helios_PCM_Open(pcm_info.channels, pcm_info.samplerate, QL_PCM_WRITE_FLAG|args[ARG_mode].u_int); +#else + self->handle_write = Helios_PCM_Open(&pcm_info, QL_PCM_WRITE_FLAG|args[ARG_mode].u_int); +#endif + if(NULL == self->handle_write) { + mp_raise_ValueError(MP_ERROR_TEXT("pcm open write only fail")); + } + self->handle_read = NULL; + break; + case PCM_FLAG_WRITE_READ: +#if CONFIG_AUDIO + self->handle_read = Helios_PCM_Open(pcm_info.channels, pcm_info.samplerate, QL_PCM_READ_FLAG|args[ARG_mode].u_int); +#else + self->handle_read = Helios_PCM_Open(&pcm_info, QL_PCM_READ_FLAG|args[ARG_mode].u_int); +#endif + if(NULL == self->handle_read) { + mp_raise_ValueError(MP_ERROR_TEXT("pcm open read fail")); + } +#if CONFIG_AUDIO + self->handle_write = Helios_PCM_Open(pcm_info.channels, pcm_info.samplerate, QL_PCM_WRITE_FLAG|args[ARG_mode].u_int); +#else + self->handle_write = Helios_PCM_Open(&pcm_info, QL_PCM_WRITE_FLAG|args[ARG_mode].u_int); +#endif +#if defined(PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) + Helios_start_poc_mode(1); + poc_mode_state = 1; +#endif + if(NULL == self->handle_write) { + mp_raise_ValueError(MP_ERROR_TEXT("pcm open write fail")); + } + break; + } + +} + + +STATIC mp_obj_t pcm_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) +{ + mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true); + int mic_channel = 1; + mic_channel = mp_obj_get_int(args[0]); + + if (mic_channel < 0 || mic_channel >= MIC_CHANNEL_MAX) { + mp_raise_ValueError(MP_ERROR_TEXT("Wrong mic channel, value range [0-2]. 0: Automatic 1: Headset 2: receiver")); + } + + machine_pcm_obj_t *self = m_new_obj_with_finaliser(machine_pcm_obj_t); + self->base.type = &audio_audio_pcm; + self->mic_channel = mic_channel; + self->PCM_stream_ring_buf = NULL; + self->PCM_stream_RW_flag = 0; + mp_map_t kw_args; + mp_map_init_fixed_table(&kw_args, n_kw, args + n_args); + machine_pcm_init_helper(self, n_args - 1, args + 1, &kw_args); + + return MP_OBJ_FROM_PTR(self); +} + + +STATIC mp_uint_t audio_pcm_read(mp_obj_t self_in, void *buf_in, mp_uint_t size, int *errcode) { + machine_pcm_obj_t *self = MP_OBJ_TO_PTR(self_in); + + + if(self->flags == PCM_FLAG_WRITE_ONLY || self->handle_read == NULL) { + mp_raise_ValueError(MP_ERROR_TEXT("This pcm only supports write operations")); + } + + // make sure we want at least 1 char + if (size == 0) { + return 0; + } + + //int bytes_read = ql_uart_read(self->uart_num, buf_in, size); + + int bytes_read =Helios_PCM_Read(self->handle_read, buf_in, size); + if (bytes_read < 0) { + *errcode = MP_EAGAIN; + return MP_STREAM_ERROR; + } + + return bytes_read; +} + +STATIC mp_uint_t audio_pcm_write(mp_obj_t self_in, const void *buf_in, mp_uint_t size, int *errcode) { + machine_pcm_obj_t *self = MP_OBJ_TO_PTR(self_in); + + if(self->flags == PCM_FLAG_READ_ONLY || self->handle_write == NULL) { + mp_raise_ValueError(MP_ERROR_TEXT("This pcm only supports read operations")); + } + int bytes_written = Helios_PCM_Write(self->handle_write, (void*)buf_in, size); + if (bytes_written < 0) { + *errcode = MP_EAGAIN; + return MP_STREAM_ERROR; + } + + // return number of bytes written + return bytes_written; +} + +STATIC mp_uint_t audio_pcm_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_t arg, int *errcode) { + //machine_uart_obj_t *self = self_in; + mp_uint_t ret; + if (request == MP_STREAM_POLL) { + mp_uint_t flags = (mp_uint_t)arg; + ret = 0; + size_t rxbufsize = 1; + //rxbufsize = ql_uart_get_rx_data_len(self->uart_num); + if ((flags & MP_STREAM_POLL_RD) && rxbufsize > 0) { + ret |= MP_STREAM_POLL_RD; + } + if ((flags & MP_STREAM_POLL_WR) && 1) { // FIXME: uart_tx_any_room(self->uart_num) + ret |= MP_STREAM_POLL_WR; + } + } else { + *errcode = MP_EINVAL; + ret = MP_STREAM_ERROR; + } + return ret; +} + +STATIC mp_obj_t helios_audio_pcm___del__(mp_obj_t self_in) +{ + uint8_t i = 0; + machine_pcm_obj_t *self = MP_OBJ_TO_PTR(self_in); +#if defined(PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) + if(self->handle_read && self->handle_write) { + if (poc_mode_state) { + poc_mode_state = 0; + Helios_stop_poc_mode(); + } + } +#endif + + if(self->handle_read) { + Helios_PCM_Close(self->handle_read); + self->handle_read = NULL; + } + + if(self->handle_write) { + Helios_PCM_Close(self->handle_write); + self->handle_write = NULL; + } + + return mp_obj_new_int(0); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_audio_pcm___del___obj, helios_audio_pcm___del__); +#include "helios_ringbuf.h" +#if 1 + //helios_ring_buf_t *PCM_stream_ring_buf = NULL; + + Helios_Thread_t PCM_stream_task_id = 0; + typedef enum + { + PCM_STREAM_NONE, + PCM_STREAM_READ , + PCM_STREAM_WRITE, + }PCM_STREAM_RW_TYPE; + #define PCM_READ_BUF_LEN 4*1024 + //char p_data[PCM_READ_BUF_LEN]={0}; + static void helios_audio_PCM_stream_task(void *self_in) + { + machine_pcm_obj_t *self = (machine_pcm_obj_t *)self_in; + self->pause_flag = 0; + //machine_pcm_obj_t *self = MP_OBJ_TO_PTR(*self_in); + char p_data[PCM_READ_BUF_LEN]={0}; + //char *p_data = NULL; + while(1) + { + if(self->pause_flag == 0) + { + if(self->PCM_stream_RW_flag == PCM_STREAM_READ) + { + int bytes_read =Helios_PCM_Read(self->handle_read, p_data, PCM_READ_BUF_LEN); + if(bytes_read>0) + { + if((helios_ring_buf_t *)self->PCM_stream_ring_buf != NULL) + helios_rb_write((helios_ring_buf_t *)self->PCM_stream_ring_buf, (unsigned char*)p_data, bytes_read); + }else + { + //printf("helios_audio_PCM_stream_task:READ no data\r\n"); + } + }else if(self->PCM_stream_RW_flag == PCM_STREAM_WRITE) + { + int bytes_read = helios_rb_read((helios_ring_buf_t *)self->PCM_stream_ring_buf, (unsigned char*)p_data, PCM_READ_BUF_LEN); + if(bytes_read>0) + { + int ret = Helios_PCM_Write(self->handle_write, p_data, bytes_read); + if(ret<1) + { + //printf("helios_audio_PCM_stream_task:pcm write error\r\n"); + } + } + + } + else + { + //printf("helios_audio_PCM_stream_task:NO_READ_WRITE\r\n"); + //Helios_msleep(2000); + } + } + + Helios_msleep(1); + } + + } + #define ring_buf_len 64*1024 + STATIC mp_obj_t helios_audio_PCM_stream_read_start(mp_obj_t self_in) + { + + machine_pcm_obj_t *self = MP_OBJ_TO_PTR(self_in); + self->PCM_stream_RW_flag = PCM_STREAM_READ; + + self->pause_flag = 0; + if(self->PCM_stream_ring_buf == NULL) { + self->PCM_stream_ring_buf = helios_rb_create(ring_buf_len); + } + if(self->PCM_stream_ring_buf == NULL) + { + mp_raise_ValueError(MP_ERROR_TEXT("Repeat opening1!!!!!!!!!!!!!!!!!!\r\n\r\n")); + return mp_obj_new_int(-2); + + } + if(PCM_stream_task_id == 0) + { + Helios_ThreadAttr attr = {0}; + attr.name = "PCM_stream"; + attr.stack_size = PCM_READ_BUF_LEN+4*1024; + attr.priority = 95; + attr.entry = helios_audio_PCM_stream_task; + attr.argv = (void *)self; + PCM_stream_task_id = Helios_Thread_Create(&attr); + } + + if (0 == PCM_stream_task_id) + { + mp_raise_ValueError(MP_ERROR_TEXT("helios_audio_PCM_stream_task error\n")); + return mp_obj_new_int(-1); + } + + return mp_obj_new_int(0); + } + + STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_helios_audio_PCM_stream_read_start_obj, helios_audio_PCM_stream_read_start); + + STATIC mp_obj_t helios_audio_PCM_stream_write_start(mp_obj_t self_in) + { + + machine_pcm_obj_t *self = MP_OBJ_TO_PTR(self_in); + self->PCM_stream_RW_flag = PCM_STREAM_WRITE; + + self->pause_flag = 0; + if(self->PCM_stream_ring_buf == NULL) { + self->PCM_stream_ring_buf = helios_rb_create(ring_buf_len); + } + if(self->PCM_stream_ring_buf == NULL) + { + mp_raise_ValueError(MP_ERROR_TEXT("Repeat opening1!!!!!!!!!!!!!!!!!!\r\n\r\n")); + return mp_obj_new_int(-2); + + } + if(PCM_stream_task_id == 0) + { + Helios_ThreadAttr attr = {0}; + attr.name = "PCM_stream"; + attr.stack_size = PCM_READ_BUF_LEN+4096; + attr.priority = 95; + attr.entry = helios_audio_PCM_stream_task; + attr.argv = (void *)self; + PCM_stream_task_id = Helios_Thread_Create(&attr); + + } + if (0 == PCM_stream_task_id) + { + mp_raise_ValueError(MP_ERROR_TEXT("helios_audio_PCM_stream_task error\n")); + return mp_obj_new_int(-1); + } + + return mp_obj_new_int(0); + } + STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_helios_audio_PCM_stream_write_start_obj, helios_audio_PCM_stream_write_start); + + STATIC mp_obj_t helios_audio_PCM_stream_read(mp_obj_t self_in,mp_obj_t read_buf, mp_obj_t len) + { + int read_actual_len = 0; + machine_pcm_obj_t *self = MP_OBJ_TO_PTR(self_in); + + mp_buffer_info_t bufinfo; + mp_get_buffer_raise(read_buf, &bufinfo, MP_BUFFER_WRITE); + + int read_len = mp_obj_get_int(len); + if(read_len > 0 && self->PCM_stream_ring_buf) { + read_actual_len = helios_rb_read((helios_ring_buf_t *)self->PCM_stream_ring_buf, bufinfo.buf, read_len); + return mp_obj_new_int(read_actual_len); + } + return mp_obj_new_int(-1); + } + STATIC MP_DEFINE_CONST_FUN_OBJ_3(mp_helios_audio_PCM_stream_read_obj, helios_audio_PCM_stream_read); + + /* 供外部 C 模块(如 modopus.c)直接写入 PCM ring buffer,避免 Python 层内存拷贝。 + 返回实际写入字节数;内部带 2000ms 背压等待。 */ + int _helios_pcm_rb_write(void *pcm_obj, const unsigned char *buf, int len) + { + machine_pcm_obj_t *self = (machine_pcm_obj_t *)pcm_obj; + if (!self || !self->PCM_stream_ring_buf || len <= 0) { + return 0; + } + int timerout = 2000; + while (1) { + timerout--; + if (timerout <= 0 || (helios_rb_data_len((helios_ring_buf_t *)self->PCM_stream_ring_buf) + len < ring_buf_len)) + break; + Helios_msleep(1); + } + return (int)helios_rb_write((helios_ring_buf_t *)self->PCM_stream_ring_buf, (unsigned char *)buf, (unsigned int)len); + } + + STATIC mp_obj_t helios_audio_PCM_stream_write(mp_obj_t self_in,mp_obj_t write_buf, mp_obj_t len) + { + int write_actual_len = 0; + machine_pcm_obj_t *self = MP_OBJ_TO_PTR(self_in); + + mp_buffer_info_t bufinfo; + mp_get_buffer_raise(write_buf, &bufinfo, MP_BUFFER_WRITE); + + int write_len = mp_obj_get_int(len); + if(write_len > 0 && self->PCM_stream_ring_buf) { + int timerout = 2000; + while(1) + { + timerout--; + if(timerout <=0 ||(helios_rb_data_len((helios_ring_buf_t *)self->PCM_stream_ring_buf) + write_len < ring_buf_len)) + break; + Helios_msleep(1); + } + write_actual_len = helios_rb_write((helios_ring_buf_t *)self->PCM_stream_ring_buf, bufinfo.buf, write_len); + return mp_obj_new_int(write_actual_len); + } + return mp_obj_new_int(-1); + } + STATIC MP_DEFINE_CONST_FUN_OBJ_3(mp_helios_audio_PCM_stream_write_obj, helios_audio_PCM_stream_write); + + STATIC mp_obj_t helios_audio_PCM_stream_stop(mp_obj_t self_in) + { + int ret = 0; + machine_pcm_obj_t *self = MP_OBJ_TO_PTR(self_in); + + if(PCM_stream_task_id != 0) + Helios_Thread_Delete(PCM_stream_task_id); + PCM_stream_task_id = 0; + if(self->PCM_stream_ring_buf != NULL) + { + helios_rb_destroy((helios_ring_buf_t **)&self->PCM_stream_ring_buf); + self->PCM_stream_ring_buf = NULL; + } + self->PCM_stream_RW_flag = PCM_STREAM_NONE; + return mp_obj_new_int(ret); + } + STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_helios_audio_PCM_stream_stop_obj, helios_audio_PCM_stream_stop); + STATIC mp_obj_t helios_audio_PCM_stream_pause(mp_obj_t self_in,mp_obj_t pause_flag)//暂停/开始 + { + machine_pcm_obj_t *self = MP_OBJ_TO_PTR(self_in); + + self->pause_flag =mp_obj_get_int(pause_flag); + return mp_obj_new_int(1); + } + + STATIC MP_DEFINE_CONST_FUN_OBJ_2(mp_helios_audio_PCM_stream_pause_obj, helios_audio_PCM_stream_pause); + + STATIC mp_obj_t helios_audio_pcm_rb_is_empty(mp_obj_t self_in) + { + int ret = 0; + machine_pcm_obj_t *self = MP_OBJ_TO_PTR(self_in); + + // if(self->handle_write) { + // ret = Helios_PCM_Reset_Write_Buffer(self->handle_write); + // } + if(self->PCM_stream_ring_buf != NULL) + { + if (helios_rb_is_empty((helios_ring_buf_t *)self->PCM_stream_ring_buf)) + ret = 1; + } + + return mp_obj_new_int(ret); + } + STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_helios_audio_pcm_rb_is_empty_obj, helios_audio_pcm_rb_is_empty); + //获取剩余长度 + STATIC mp_obj_t helios_audio_pcm_rb_get_buf_len(mp_obj_t self_in) + { + int ret = 0; + machine_pcm_obj_t *self = MP_OBJ_TO_PTR(self_in); + + // if(self->handle_write) { + // ret = Helios_PCM_Reset_Write_Buffer(self->handle_write); + // } + if(self->PCM_stream_ring_buf != NULL) + { + ret = ring_buf_len - helios_rb_data_len((helios_ring_buf_t *)self->PCM_stream_ring_buf) ; + + } + + return mp_obj_new_int(ret); + + } + STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_helios_audio_pcm_rb_get_buf_len_obj, helios_audio_pcm_rb_get_buf_len); +#endif +#if defined(PLAT_ASR_1606) +STATIC mp_obj_t helios_audio_pcm_get_write_frame_count(mp_obj_t self_in) +{ + int ret = 0; + machine_pcm_obj_t *self = MP_OBJ_TO_PTR(self_in); + + if(self->handle_write) { + ret = Helios_PCM_Get_Write_Frame_Count(self->handle_write); + } + + return mp_obj_new_int(ret); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_audio_pcm_get_write_frame_count_obj, helios_audio_pcm_get_write_frame_count); + +STATIC mp_obj_t helios_audio_pcm_reset_write_buffer(mp_obj_t self_in) +{ + int ret = 0; + machine_pcm_obj_t *self = MP_OBJ_TO_PTR(self_in); + + if(self->handle_write) { + ret = Helios_PCM_Reset_Write_Buffer(self->handle_write); + } + + return mp_obj_new_int(ret); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_audio_pcm_reset_write_buffer_obj, helios_audio_pcm_reset_write_buffer); + +#endif +STATIC const mp_stream_p_t pcm_stream_p = { + .read = audio_pcm_read, + .write = audio_pcm_write, + .ioctl = audio_pcm_ioctl, + .is_text = false, +}; + + +STATIC const mp_rom_map_elem_t pcm_locals_dict[] = { + { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&helios_audio_pcm___del___obj) }, + { MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mp_stream_write_obj) }, + { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) }, + { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&helios_audio_pcm___del___obj) }, + { MP_ROM_QSTR(MP_QSTR_stream_read_start), MP_ROM_PTR(&mp_helios_audio_PCM_stream_read_start_obj)}, + { MP_ROM_QSTR(MP_QSTR_stream_write_start), MP_ROM_PTR(&mp_helios_audio_PCM_stream_write_start_obj)}, + { MP_ROM_QSTR(MP_QSTR_stream_read), MP_ROM_PTR(&mp_helios_audio_PCM_stream_read_obj)}, + { MP_ROM_QSTR(MP_QSTR_stream_write), MP_ROM_PTR(&mp_helios_audio_PCM_stream_write_obj)}, + { MP_ROM_QSTR(MP_QSTR_stream_stop), MP_ROM_PTR(&mp_helios_audio_PCM_stream_stop_obj)}, + { MP_ROM_QSTR(MP_QSTR_stream_pause), MP_ROM_PTR(&mp_helios_audio_PCM_stream_pause_obj)}, + + { MP_ROM_QSTR(MP_QSTR_stream_is_empty), MP_ROM_PTR(&mp_helios_audio_pcm_rb_is_empty_obj)}, + { MP_ROM_QSTR(MP_QSTR_stream_get_buf_len), MP_ROM_PTR(&mp_helios_audio_pcm_rb_get_buf_len_obj)}, + + + { MP_ROM_QSTR(MP_QSTR_setVolume), MP_ROM_PTR(&helios_set_volume_obj) }, + { MP_ROM_QSTR(MP_QSTR_getVolume), MP_ROM_PTR(&helios_get_volume_obj) }, + #if defined(PLAT_ASR_1606) + { MP_ROM_QSTR(MP_QSTR_getWriteFrameCount), MP_ROM_PTR(&helios_audio_pcm_get_write_frame_count_obj) }, + { MP_ROM_QSTR(MP_QSTR_resetWriteBuffer), MP_ROM_PTR(&helios_audio_pcm_reset_write_buffer_obj) }, + #endif + { MP_ROM_QSTR(MP_QSTR_MONO), MP_ROM_INT(1) }, + { MP_ROM_QSTR(MP_QSTR_STEREO), MP_ROM_INT(2) }, + { MP_ROM_QSTR(MP_QSTR_READONLY), MP_ROM_INT(PCM_FLAG_READ_ONLY) }, + { MP_ROM_QSTR(MP_QSTR_WRITEONLY), MP_ROM_INT(PCM_FLAG_WRITE_ONLY) }, + { MP_ROM_QSTR(MP_QSTR_WRITEREAD), MP_ROM_INT(PCM_FLAG_WRITE_READ) }, + { MP_ROM_QSTR(MP_QSTR_BLOCK), MP_ROM_INT(QL_PCM_BLOCK_FLAG) }, + { MP_ROM_QSTR(MP_QSTR_NOBLOCK), MP_ROM_INT(QL_PCM_NONBLOCK_FLAG) }, +}; + +STATIC MP_DEFINE_CONST_DICT(pcm_locals_dict_obj, pcm_locals_dict); + + +const mp_obj_type_t audio_audio_pcm = { + { &mp_type_type }, + .name = MP_QSTR_PCM, + .make_new = pcm_make_new, + .getiter = mp_identity_getiter, + .iternext = mp_stream_unbuffered_iter, + .protocol = &pcm_stream_p, + .locals_dict = (mp_obj_dict_t *)&pcm_locals_dict_obj, +}; +#endif + +#endif /* MICROPY_QPY_AUDIO_AUDIO */ + + + + diff --git a/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/source/modopus.c b/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/source/modopus.c index 121812d6..f2e136c8 100644 --- a/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/source/modopus.c +++ b/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/source/modopus.c @@ -13,6 +13,9 @@ #include "opus/opus.h" +/* audio_audio.c 暴露的 ring-buffer 直接写入接口 */ +extern int _helios_pcm_rb_write(void *pcm_obj, const unsigned char *buf, int len); + #define MOD_OPUS_LOG(msg, ...) custom_log("modopus", msg, ##__VA_ARGS__) #define OPUS_CODEC_SR_HZ 16000 @@ -136,6 +139,36 @@ STATIC mp_obj_t opus_codec_decode(mp_obj_t self_in, mp_obj_t pkt_in) } STATIC MP_DEFINE_CONST_FUN_OBJ_2(opus_decode_obj, opus_codec_decode); +/* 解码 opus 包并直接写入 PCM 对象的 ring buffer,跳过 Python 层内存拷贝和队列。 + 参数: self (OpusCodec), pkt (opus 包 bytes), pcm_obj (audio.PCM 对象) + 返回: 写入 ring buffer 的实际字节数(int) */ +STATIC mp_obj_t opus_decode_to_pcm(mp_obj_t self_in, mp_obj_t pkt_in, mp_obj_t pcm_in) +{ + mp_obj_OpusCodec_t *self = MP_OBJ_TO_PTR(self_in); + if (!self->has_dec || self->dec == NULL) { + mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("decoder not open")); + } + mp_buffer_info_t pkt; + mp_get_buffer_raise(pkt_in, &pkt, MP_BUFFER_READ); + if (pkt.len == 0 || pkt.len > OPUS_CODEC_MAX_PKT) { + mp_raise_ValueError(MP_ERROR_TEXT("invalid opus packet")); + } + opus_int16 pcm[OPUS_CODEC_MAX_FRAME]; + mp_int_t n; + MP_THREAD_GIL_EXIT(); + n = opus_decode(self->dec, pkt.buf, (opus_int32)pkt.len, pcm, + OPUS_CODEC_MAX_FRAME, 0); + MP_THREAD_GIL_ENTER(); + if (n < 0) { + mp_raise_msg_varg(&mp_type_OSError, MP_ERROR_TEXT("opus_decode %d"), (int)n); + } + int pcm_bytes = (int)n * 2; + /* 直接写入 PCM 对象的 ring buffer(带背压),消除 mp_obj_new_bytes + bytearray 拷贝 */ + int written = _helios_pcm_rb_write(MP_OBJ_TO_PTR(pcm_in), (const unsigned char *)pcm, pcm_bytes); + return mp_obj_new_int(written); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_3(opus_decode_to_pcm_obj, opus_decode_to_pcm); + STATIC mp_obj_t opus_close(mp_obj_t self_in) { mp_obj_OpusCodec_t *self = MP_OBJ_TO_PTR(self_in); @@ -163,6 +196,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(opus_version_obj, opus_version); STATIC const mp_rom_map_elem_t OpusCodec_locals[] = { { MP_ROM_QSTR(MP_QSTR_encode), MP_ROM_PTR(&opus_encode_obj) }, { MP_ROM_QSTR(MP_QSTR_decode), MP_ROM_PTR(&opus_decode_obj) }, + { MP_ROM_QSTR(MP_QSTR_decode_to_pcm), MP_ROM_PTR(&opus_decode_to_pcm_obj) }, { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&opus_close_obj) }, }; STATIC MP_DEFINE_CONST_DICT(OpusCodec_locals_dict, OpusCodec_locals); diff --git a/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/source/modws_dispatcher.c b/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/source/modws_dispatcher.c new file mode 100644 index 00000000..02dddfeb --- /dev/null +++ b/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/source/modws_dispatcher.c @@ -0,0 +1,98 @@ +/* + * MicroPython WebSocket 事件分发加速模块 + * 将 O(n) Python if/elif 事件字符串比较替换为 C 层 O(1) 二分查找 + */ +#include +#include "py/runtime.h" + +/* 事件 ID 枚举 —— 与 vc_session_io.py 的 if/elif 链一一对应 */ +#define WS_EV_STARTED 0 +#define WS_EV_CONFIG_UPDATE 1 +#define WS_EV_ASR_STARTED 2 +#define WS_EV_ASR_RESULT 3 +#define WS_EV_ASR_COMPLETED 4 +#define WS_EV_VAD_ACTIVE 5 +#define WS_EV_VAD_SILENCE 6 +#define WS_EV_LLM_CREATED 7 +#define WS_EV_LLM_DELTA 8 +#define WS_EV_LLM_COMPLETED 9 +#define WS_EV_TTS_STARTED 10 +#define WS_EV_TTS_COMPLETED 11 +#define WS_EV_CANCELED 12 +#define WS_EV_COMPLETED 13 +#define WS_EV_FAILED 14 +#define WS_EV_COMMAND 15 +#define WS_EV_AUDIO_CONVERT_COMPLETED 16 +#define WS_EV_AUDIO_CONVERT_FAILED 17 +#define WS_EV_UNKNOWN 18 + +/* 有序事件名数组(用于二分查找) */ +typedef struct _ws_event_entry { + const char *name; + int id; +} ws_event_entry_t; + +static const ws_event_entry_t ws_event_table[] = { + { "asr.completed", WS_EV_ASR_COMPLETED }, + { "asr.result", WS_EV_ASR_RESULT }, + { "asr.started", WS_EV_ASR_STARTED }, + { "audio.convert.completed", WS_EV_AUDIO_CONVERT_COMPLETED }, + { "audio.convert.failed", WS_EV_AUDIO_CONVERT_FAILED }, + { "canceled", WS_EV_CANCELED }, + { "command", WS_EV_COMMAND }, + { "completed", WS_EV_COMPLETED }, + { "config.update", WS_EV_CONFIG_UPDATE }, + { "failed", WS_EV_FAILED }, + { "llm.completed", WS_EV_LLM_COMPLETED }, + { "llm.created", WS_EV_LLM_CREATED }, + { "llm.delta", WS_EV_LLM_DELTA }, + { "started", WS_EV_STARTED }, + { "tts.completed", WS_EV_TTS_COMPLETED }, + { "tts.started", WS_EV_TTS_STARTED }, + { "vad.active", WS_EV_VAD_ACTIVE }, + { "vad.silence", WS_EV_VAD_SILENCE }, +}; + +#define WS_EVENT_TABLE_LEN (sizeof(ws_event_table) / sizeof(ws_event_table[0])) + +/* 返回事件名对应的整数 ID;未找到返回 WS_EV_UNKNOWN */ +static int ws_classify_event(const char *name, mp_uint_t name_len) +{ + int lo = 0, hi = (int)WS_EVENT_TABLE_LEN - 1; + while (lo <= hi) { + int mid = (lo + hi) / 2; + int cmp = strncmp(name, ws_event_table[mid].name, name_len); + if (cmp == 0 && ws_event_table[mid].name[name_len] == '\0') { + return ws_event_table[mid].id; + } + if (cmp < 0) { + hi = mid - 1; + } else { + lo = mid + 1; + } + } + return WS_EV_UNKNOWN; +} + +STATIC mp_obj_t mod_ws_classify(mp_obj_t event_in) +{ + mp_buffer_info_t buf; + mp_get_buffer_raise(event_in, &buf, MP_BUFFER_READ); + int id = ws_classify_event((const char *)buf.buf, buf.len); + return mp_obj_new_int(id); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_ws_classify_obj, mod_ws_classify); + +/* 模块注册 */ +STATIC const mp_rom_map_elem_t ws_dispatcher_globals_table[] = { + { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR__ws_dispatcher) }, + { MP_ROM_QSTR(MP_QSTR_classify), MP_ROM_PTR(&mod_ws_classify_obj) }, +}; +STATIC MP_DEFINE_CONST_DICT(ws_dispatcher_globals, ws_dispatcher_globals_table); + +const mp_obj_module_t mp_module_ws_dispatcher = { + .base = { &mp_type_module }, + .globals = (mp_obj_dict_t *)&ws_dispatcher_globals, +}; + +MP_REGISTER_MODULE(MP_QSTR__ws_dispatcher, mp_module_ws_dispatcher, 1); diff --git a/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/source/mpconfigport.h b/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/source/mpconfigport.h index 6d862daf..28a98257 100644 --- a/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/source/mpconfigport.h +++ b/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/source/mpconfigport.h @@ -792,6 +792,8 @@ extern const struct _mp_obj_module_t mp_module_websocket_mask; #define MICROPY_PORT_BUILTIN_MODULES_WEBSOCKET_MASK { MP_OBJ_NEW_QSTR(MP_QSTR_websocket_mask), (mp_obj_t)&mp_module_websocket_mask}, extern const struct _mp_obj_module_t mp_module_cws_frame; #define MICROPY_PORT_BUILTIN_MODULES_CWS_FRAME { MP_OBJ_NEW_QSTR(MP_QSTR__cws_frame), (mp_obj_t)&mp_module_cws_frame}, +extern const struct _mp_obj_module_t mp_module_ws_dispatcher; +#define MICROPY_PORT_BUILTIN_MODULES_WS_DISPATCHER { MP_OBJ_NEW_QSTR(MP_QSTR__ws_dispatcher), (mp_obj_t)&mp_module_ws_dispatcher}, #if CONFIG_VAD extern const struct _mp_obj_module_t mp_module_VAD ; #define MICROPY_PORT_BUILTIN_MODULES_VAD { MP_OBJ_NEW_QSTR(MP_QSTR_VAD), (mp_obj_t)&mp_module_VAD}, @@ -966,6 +968,7 @@ extern const struct _mp_obj_type_t TiktokRTC_type; MICROPY_PORT_BUILTIN_MODULES_code128\ MICROPY_PORT_BUILTIN_MODULES_WEBSOCKET_MASK\ MICROPY_PORT_BUILTIN_MODULES_CWS_FRAME\ + MICROPY_PORT_BUILTIN_MODULES_WS_DISPATCHER\ MICROPY_PORT_BUILTIN_MODULES_VAD\ MICROPY_PORT_BUILTIN_MODULES_NETWORK \ MICROPY_PORT_BUILTIN_MODULES_ALIPAY_COLLECTION \ diff --git a/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/uwebsocket.py b/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/uwebsocket.py index 6dd164ef..c17e9edf 100644 --- a/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/uwebsocket.py +++ b/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/uwebsocket.py @@ -7,6 +7,7 @@ import ure as re import ustruct as struct import urandom as random import usocket as socket +import utime from ucollections import namedtuple import websocket_mask try: @@ -15,6 +16,26 @@ except ImportError: _cws_frame = None LOGGER = log.getLogger(__name__) +# ---- 性能对比开关 ---- +# True 时即使 _cws_frame 可用也强制走 Python 路径,用于 AB 对比 +_FORCE_PYTHON_PATH = False + +# 性能计数器 +_perf_cnt = 0 +_perf_total_us = 0 +_PERF_REPORT_EVERY = 50 + + +def _perf_tick(elapsed_us): + global _perf_cnt, _perf_total_us + _perf_cnt += 1 + _perf_total_us += elapsed_us + if _perf_cnt % _PERF_REPORT_EVERY == 0: + avg = _perf_total_us // _perf_cnt + path = "PY" if _FORCE_PYTHON_PATH else "C" + LOGGER.info("[PERF-%s] read_frame avg=%d us over %d frames", + path, avg, _perf_cnt) + def _vc_ws_native_ping_tx_enabled(): """1=客户端主动发 RFC6455 OP_PING;0=不发。入站 OP_PING 始终回 OP_PONG(与配置无关)。""" @@ -105,11 +126,14 @@ class Websocket(object): Read a frame from the socket. See https://tools.ietf.org/html/rfc6455#section-5.2 for the details. """ + t0 = utime.ticks_us() + # C 加速路径:_cws_frame 可用时,帧头解析 + unmask 在 C 层完成 - if _cws_frame is not None: + if _cws_frame is not None and not _FORCE_PYTHON_PATH: _max = -1 if max_size is None else max_size try: fin, opcode, data = _cws_frame.read_frame(self.sock, _max) + _perf_tick(utime.ticks_diff(utime.ticks_us(), t0)) if opcode == -1: # CWS_RET_NO_DATA raise NoDataException if opcode == -2: # CWS_RET_TOO_BIG @@ -127,6 +151,7 @@ class Websocket(object): two_bytes = self.sock.read(2) if not two_bytes: + _perf_tick(utime.ticks_diff(utime.ticks_us(), t0)) raise NoDataException byte1, byte2 = struct.unpack('!BB', two_bytes) @@ -153,6 +178,7 @@ class Websocket(object): # We can't receive this many bytes, close the socket if self.debug: LOGGER.info("Frame of length %s too big. Closing", length) self.close(code=CLOSE_TOO_BIG) + _perf_tick(utime.ticks_diff(utime.ticks_us(), t0)) return True, OP_CLOSE, None if mask: @@ -160,6 +186,7 @@ class Websocket(object): websocket_mask.MASK(_arr, len(_arr), bytearray(mask_bits)) data = bytes(_arr) + _perf_tick(utime.ticks_diff(utime.ticks_us(), t0)) return fin, opcode, data def write_frame(self, opcode, data=b''): diff --git a/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/vc_session_io.py b/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/vc_session_io.py index c0b4fec4..2042e992 100644 --- a/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/vc_session_io.py +++ b/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/vc_session_io.py @@ -6,6 +6,11 @@ from vc_utils import cfg_bool, cfg_attr, cfg_int, net_csq_rssi, net_csq_invalid # import * 不导入以下划线开头的符号;_thread 必须显式引入(否则 start_new_thread NameError) import _thread +try: + import _ws_dispatcher +except ImportError: + _ws_dispatcher = None + class VCSessionIoMixin: _VC_STALE_DROP_EVENTS = ( "tts.started", "tts.completed", "llm.created", "llm.completed", "completed", @@ -964,12 +969,18 @@ class VCSessionIoMixin: self._cur_sid = "" try: ev = jsload_data.get("event", "") + ev_id = -1 + if ev and _ws_dispatcher is not None: + try: + ev_id = _ws_dispatcher.classify(ev) + except Exception: + pass if ev: self._vc_dispatch_server_event(ev, jsload_data) except Exception: pass - if jsload_data["event"] == "started" :#会话开始 + if ev_id == 0 :#会话开始 #payload = jsload_data["payload"] # self.VC_dialog_id = payload["dialog_id"] # self.VC_task_id = jsload_data["task_id"] @@ -1012,14 +1023,14 @@ class VCSessionIoMixin: except Exception as e: usys.print_exception(e) - elif jsload_data["event"] == "config.update" :#配置更新中,需要停止录音 + elif ev_id == 1 :#配置更新中,需要停止录音 try: self.fsm.reset_rx_phases() except Exception: pass self.request_uplink_stop("config.update") - elif jsload_data["event"] == "asr.started" :#asr开始 + elif ev_id == 2 :#asr开始 try: self.fsm.on_server_asr_started() except Exception: @@ -1051,7 +1062,7 @@ class VCSessionIoMixin: pass # 单对话:勿在 asr.started ç½® flag=2(未真开麦会僵死);由 VC_Speech_Start 维护 self.LocalRespondingEnded_timerout = 0 - elif jsload_data["event"] == "asr.result" :#asr结果 + elif ev_id == 3 :#asr结果 try: raw = jsload_data["payload"]["content"] except Exception: @@ -1086,7 +1097,7 @@ class VCSessionIoMixin: if self.AI_ASR_str == "":#没识别到 self.AI_TTS_str = "我没听清,请再说一遍" self._vc_led_alert_rb_flash() - elif jsload_data["event"] == "asr.completed" :#asr 终止的标识 + elif ev_id == 4 :#asr 终止的标识 self._turn_has_asr_completed = 1 try: if hasattr(self, "_vc_flush_deferred_vad_uplink_stop"): @@ -1152,7 +1163,7 @@ class VCSessionIoMixin: # if dev_type != "7PIN" : #EventMesh.publish("publish_AI_btnInfo",{"func":self.send_tone}) - elif jsload_data["event"] == "vad.active" :#VAD 检测到说话→聆听 + elif ev_id == 5 :#VAD 检测到说话→聆听 if hasattr(self, "_vc_local_vad_endpoint") and self._vc_local_vad_endpoint(): print("[VC][VAD] ignore server vad.active (local endpoint)") else: @@ -1161,7 +1172,7 @@ class VCSessionIoMixin: self._server_vad_silence = 0 if cfg_bool("VAD_ACTIVE_BLUE_LED", True): self._server_vad_silence = 0 - elif jsload_data["event"] == "vad.silence" :#VAD 终止的标识 + elif ev_id == 6 :#VAD 终止的标识 if hasattr(self, "_vc_local_vad_endpoint") and self._vc_local_vad_endpoint(): print("[VC][VAD] ignore server vad.silence (local endpoint)") else: @@ -1183,7 +1194,7 @@ class VCSessionIoMixin: except Exception: self._server_vad_silence = 1 self._uplink_mark_end("vad.silence") - elif jsload_data["event"] == "llm.created" :#思考(LLM) + elif ev_id == 7 :#思考(LLM) self._turn_has_llm_created = 1 self._vc_llm_reply_buf = "" if ( @@ -1205,7 +1216,7 @@ class VCSessionIoMixin: and getattr(self, "_turn_has_asr_completed", 0) == 1 ): self._vc_expect_dialog_tts = 1 - elif jsload_data["event"] == "llm.completed" :#llm完成(可能无 tts) + elif ev_id == 9 :#llm完成(可能无 tts) try: _reply = getattr(self, "_vc_llm_reply_buf", "") if _reply: @@ -1224,7 +1235,7 @@ class VCSessionIoMixin: self._cur_dialog_id = "" if hasattr(self.fsm, "log"): self.fsm.log("server.llm.completed") - elif jsload_data["event"] == "llm.delta" :#llm返回数据 + elif ev_id == 8 :#llm返回数据 if cfg_bool("VC_LLM_DELTA_LOG", False): try: _frag = (jsload_data.get("payload") or {}).get("content", "") or "" @@ -1235,7 +1246,7 @@ class VCSessionIoMixin: if self.is_VAD == 0 and self.record_data_save_flag == 0: if self.VC_record_state_flag == 1:#llm返回数据还没停止,就先停止 self.request_uplink_stop("llm.delta") - elif jsload_data["event"] == "tts.started" :#tts开始 + elif ev_id == 10 :#tts开始 if not ( hasattr(self, "_vc_ptt_drop_server_event") and self._vc_ptt_drop_server_event("tts.started", "recv") @@ -1262,7 +1273,7 @@ class VCSessionIoMixin: self._pending_tts_kind = "" self._tts_completed_wall_ms = 0 self._tts_play_end_due_ms = 0 - elif jsload_data["event"] == "tts.completed" :#tts结束 + elif ev_id == 11 :#tts结束 if ( hasattr(self, "_vc_ptt_drop_server_event") and self._vc_ptt_drop_server_event("tts.completed", "recv") @@ -1300,7 +1311,7 @@ class VCSessionIoMixin: ) # 播完上报完全由 FSM await_played + play_end 驱动 - elif jsload_data["event"] == "canceled" :#打断 + elif ev_id == 12 :#打断 # 长对话清 is_ruppt:仅在 btn 编排 _vc_orchestrator_server_event_cb 中处理, # 勿在 recv 线程提前 settle(会与 stop_downlink 竞态,偶发放行旧 TTS 尾包) if getattr(self, "VC_mode", 0) != 0: @@ -1321,7 +1332,7 @@ class VCSessionIoMixin: print("AI_VC_start :AI_audio_queue_thread_id :{} ".format(self.AI_audio_queue_thread_id)) else: print("AI_VC_start :AI_audio_queue_thread_id != 0 ") - elif jsload_data["event"] == "completed" :#会话结束(可能无 TTS,如 ASR 空) + elif ev_id == 13 :#会话结束(可能无 TTS,如 ASR 空) # 重要:服务端常在 tts.completed 后紧跟 completed。 # 若本轮存在 TTS/待发 audio.played,则不能在此清零 LocalRespondingEnded_timerout/_need_audio_played_ack, # 否则会掐断「播完→audio.played→下一轮录音」链路,表现为最多 1~2 轮就停。 @@ -1355,7 +1366,7 @@ class VCSessionIoMixin: # 开麦由 FSM action list 统一触发(uplink_start:completed),这里不再重复调用 pass - elif jsload_data["event"] == "command" :#命令匹配 + elif ev_id == 15 :#命令匹配 ret = -1 try: if self.commands_mode ==1: @@ -1384,7 +1395,7 @@ class VCSessionIoMixin: self.request_uplink_stop("command") EventMesh.publish("publish_AI_btnInfo",{"func":self.websocket_deconnect_VC}) EventMesh.publish("publish_AI_btnInfo",{"func":self.AI_VC_start}) - elif jsload_data["event"] == "failed":#接口返回错误 + elif ev_id == 14:#接口返回错误 pl = jsload_data.get("payload") or {} err = pl.get("error") or "" msg = pl.get("message") or pl.get("msg") or err or "" @@ -1403,7 +1414,7 @@ class VCSessionIoMixin: ) pass - elif jsload_data["event"] == "audio.convert.completed":#音频转成完成没有出错 接口 + elif ev_id == 16:#音频转成完成没有出错 接口 # self.VC_state = VC_State_End print("未读留言初始数值:{}".format(self.pwk_cnt_voice)) if self.pwk_notice_flag == 1:#只有在播放的时候才会去计数 @@ -1453,7 +1464,7 @@ class VCSessionIoMixin: pass pass - elif jsload_data["event"] == "audio.convert.failed": #音频转换失败了 + elif ev_id == 17: #音频转换失败了 pass @@ -1490,21 +1501,59 @@ class VCSessionIoMixin: utime.sleep_ms(1) continue - # 下行 opus:每个二进制帧=一个 opus 包,解码为 PCM 再走原播放/保存路径 + # 下行 opus:每个二进制帧=一个 opus 包 if not isinstance(recv_data, str) and self._vc_opus_downlink_on(): try: _ilen = len(recv_data) _dec_t0 = utime.ticks_us() - recv_data = self._vc_opus_down_codec().decode(recv_data) - _dec_us = utime.ticks_diff(utime.ticks_us(), _dec_t0) - self._opus_dn_cnt = getattr(self, "_opus_dn_cnt", 0) + 1 - self._opus_dn_us_sum = getattr(self, "_opus_dn_us_sum", 0) + _dec_us - if _dec_us > getattr(self, "_opus_dn_us_max", 0): - self._opus_dn_us_max = _dec_us - if self._opus_dn_cnt <= 5 or (self._opus_dn_cnt % 50) == 0: - _avg = self._opus_dn_us_sum // self._opus_dn_cnt - print("[VC][opus_dn] #{} in={} out={} dec={}us avg={}us max={}us".format( - self._opus_dn_cnt, _ilen, len(recv_data), _dec_us, _avg, self._opus_dn_us_max)) + + # C 加速路径:decode + ring-buffer 写入合并,消除 buf_len 忙等待和 + # Python 队列往返。play_data_save 调试模式时仍走旧路径。 + _fast = ( + getattr(self, "play_data_save_flag", 0) != 1 + and self.VC_play_TYPE == VC_play_TYPE_PCM + and self.play_pcm is not None + ) + if _fast: + n = self._vc_opus_down_codec().decode_to_pcm(recv_data, self.play_pcm) + _dec_us = utime.ticks_diff(utime.ticks_us(), _dec_t0) + + self._opus_dn_cnt = getattr(self, "_opus_dn_cnt", 0) + 1 + self._opus_dn_us_sum = getattr(self, "_opus_dn_us_sum", 0) + _dec_us + if _dec_us > getattr(self, "_opus_dn_us_max", 0): + self._opus_dn_us_max = _dec_us + if self._opus_dn_cnt <= 5 or (self._opus_dn_cnt % 50) == 0: + _avg = self._opus_dn_us_sum // self._opus_dn_cnt + print("[VC][opus_dn] #{} in={} wr={} dec={}us avg={}us max={}us [C-fast]".format( + self._opus_dn_cnt, _ilen, n, _dec_us, _avg, self._opus_dn_us_max)) + + if n > 0: + if self.tts_in_data_len == 0: + try: + sid = getattr(self, "_cur_sid", "") + did = getattr(self, "_cur_dialog_id", "") + except Exception: + sid, did = "", "" + print("[TTS] first_chunk len={} play_pcm=1 sid={} did={} [C-fast]".format( + n, sid, did)) + self.tts_in_data_len += n + self.tts_out_data_len = getattr(self, "tts_out_data_len", 0) + n + + utime.sleep_ms(1) + continue + else: + # 旧路径:decode 返回 bytes,经队列→stream_write + recv_data = self._vc_opus_down_codec().decode(recv_data) + _dec_us = utime.ticks_diff(utime.ticks_us(), _dec_t0) + + self._opus_dn_cnt = getattr(self, "_opus_dn_cnt", 0) + 1 + self._opus_dn_us_sum = getattr(self, "_opus_dn_us_sum", 0) + _dec_us + if _dec_us > getattr(self, "_opus_dn_us_max", 0): + self._opus_dn_us_max = _dec_us + if self._opus_dn_cnt <= 5 or (self._opus_dn_cnt % 50) == 0: + _avg = self._opus_dn_us_sum // self._opus_dn_cnt + print("[VC][opus_dn] #{} in={} out={} dec={}us avg={}us max={}us".format( + self._opus_dn_cnt, _ilen, len(recv_data), _dec_us, _avg, self._opus_dn_us_max)) except Exception as e: print("[VC][opus_dn] decode fail in={}".format(_ilen)) usys.print_exception(e) diff --git a/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/vc_session_media.py b/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/vc_session_media.py index dc11cd25..538d1617 100644 --- a/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/vc_session_media.py +++ b/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/vc_session_media.py @@ -982,7 +982,7 @@ class VCSessionMediaMixin: self.request_uplink_stop("local.vad.end/audio.completed") def _vc_local_vad_on_endpoint(self): - """本地 VAD 句末:silence_gate + merge 窗 + audio.completed。""" + """本地 VAD 句末:关闸→排空队列→opus_flush→think 音→audio.completed。""" if not self._vc_local_vad_endpoint(): return if getattr(self, "record_data_save_flag", 0) != 0: @@ -1009,9 +1009,24 @@ class VCSessionMediaMixin: print("[VC][VAD] local endpoint defer (merge window)") self._vc_local_vad_send_audio_completed(defer_stop=True) return + # --- 正常收尾(非 merge 窗)--- self._server_vad_silence = 1 + # 排空 AI_record_tmp_queue 中已缓存的 PCM(直接发送,不走 Record Thread 的 gate 检查) + try: + q = getattr(self, "AI_record_tmp_queue", None) + if q is not None and q.empty() != True: + drained = 0 + while q.empty() != True: + self.AI_client_VC_send(q.get()) + drained += 1 + if drained: + print("[VC][endpoint] drained {} from tmp_queue".format(drained)) + except Exception: + pass self._uplink_mark_end("local.vad.end") + # 发送 audio.completed,触发 request_uplink_stop → VC_Speech_End self._vc_local_vad_send_audio_completed(defer_stop=False) + # think 音由 record_poll 在录音硬件释放后播(避免并行竞态) self._vc_arm_think_tone_pending() def _vc_endpoint_hangover_ms(self):