--- /dev/null
+/*
+ * 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 <stdio.h>
+#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<QUEUE_NUMS; i++)
+ {
+ audio_queue_init(&audio.audio_queue[i]);
+ }
+ audio.cur_priority = 0;
+ audio.cur_breakin = 0;
+ audio.audio_state = AUDIO_IDLE;
+ audio.inited = 1;
+ audio.total_nums = 0;
+ audio.queue_mutex = 0;
+ audio.queue_msg = 0;
+ audio.montage_mutex = 0;
+ audio.queue_mutex = Helios_Mutex_Create();
+ audio.montage_mutex = Helios_Mutex_Create();
+ audio.queue_msg = Helios_MsgQ_Create(10, sizeof(uint8_t));
+ audio.play_start_mode = 0;
+ audio.play_end_mode = 0;
+ audio.interval_of_start_dec_pa = 0;
+ audio.interval_of_close_dec_pa = 0;
+ if (!audio.queue_msg)
+ {
+ Helios_Mutex_Delete(audio.queue_mutex);
+ Helios_Mutex_Delete(audio.montage_mutex);
+ mp_raise_ValueError(MP_ERROR_TEXT("create audio object failed, can not create msgQ."));
+ }
+
+ Helios_ThreadAttr attr = {0};
+ attr.name = "audio_queue_play";
+ attr.stack_size = 4096;
+ attr.priority = 95;
+ attr.entry = helios_audio_queue_play_task;
+
+ Helios_Thread_t id = Helios_Thread_Create(&attr);
+ if (id == 0)
+ {
+ Helios_MsgQ_Delete(audio.queue_msg);
+ Helios_Mutex_Delete(audio.queue_mutex);
+ Helios_Mutex_Delete(audio.montage_mutex);
+ mp_raise_ValueError(MP_ERROR_TEXT("create audio object failed, can not create queue play task."));
+ }
+ }
+ else
+ {
+ if((audio.montage_mutex == 0) && (audio.queue_msg != 0))
+ {
+ audio.montage_mutex = Helios_Mutex_Create();
+ }
+ }
+
+ return MP_OBJ_FROM_PTR(self);
+}
+
+
+
+/*=============================================================================*/
+/* FUNCTION: helios_play_file_start */
+/*=============================================================================*/
+/*!@brief : play the audio file(mp3,amr)
+ * @param[in] : filename
+ * @param[out] :
+ * @return :
+ * - 0--success
+ * - -1--error
+ * @modify :
+ ---------- --------- ---------------------------------------------------
+ 2020/10/16 Jayceon.Fu add queue, priority, breakin.
+ */
+/*=============================================================================*/
+STATIC mp_obj_t helios_play_file_start(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args)
+{
+ enum { ARG_priority, ARG_breakin, ARG_data, ARG_frameJump};
+ static const mp_arg_t allowed_args[] =
+ {
+ { 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_QSTR_frameJump, MP_ARG_OBJ, {.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);
+
+#if CONFIG_AUDIO
+ extern void Helios_file_jump_frame(Helios_AudStreamFormat format, uint32_t cnt);
+ Helios_file_jump_frame(HELIOS_AUDIO_FORMAT_MP3, vals[ARG_frameJump].u_int);
+#endif
+
+ 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;
+ 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);
+
+ Helios_Mutex_Lock(audio.queue_mutex, HELIOS_WAIT_FOREVER);
+ 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_FILE;
+ 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_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<QUEUE_NUMS; i++)
+ {
+ audio_queue_init(&audio.audio_queue[i]);
+ }
+ audio.cur_priority = 0;
+ audio.cur_breakin = 0;
+ audio.total_nums = 0;
+
+ Helios_Mutex_Unlock(audio.queue_mutex);
+ if(audio.cur_type == AUDIO_MONTAGE || audio.cur_type == AUDIO_STREAM)
+ {
+ ret = mp_obj_get_int(helios_play_stream_stop(self_in));
+ }
+ else
+ {
+ ret = Helios_Audio_FilePlayStop();
+ }
+ audio.audio_state = AUDIO_IDLE;
+ return mp_obj_new_int(ret);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_play_file_stop_all_obj, helios_play_file_stop_all);
+
+
+/*=============================================================================*/
+/* FUNCTION: helios_play_stream_start */
+/*=============================================================================*/
+/*!@brief : play the audio file(mp3,amr)
+ * @param[in] : filename
+ * @param[out] :
+ * @return :
+ * - 0--success
+ * - -1--error
+ * @modify :
+ ---------- --------- ---------------------------------------------------
+ 2020/10/16 Jayceon.Fu add queue, priority, breakin.
+ */
+/*=============================================================================*/
+STATIC mp_obj_t helios_play_stream_start(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args)
+{
+ enum { ARG_format, ARG_audiobuf, ARG_mode, ARG_len };
+ static const mp_arg_t allowed_args[] =
+ {
+ { MP_QSTR_format, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
+ { MP_QSTR_audiobuf, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+ { MP_QSTR_mode, MP_ARG_INT, {.u_int = 0} },
+ { MP_QSTR_len, 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 format = 1;
+ format = vals[ARG_format].u_int;
+ int play_len = vals[ARG_len].u_int;
+#if defined (PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_Unisoc_8910_R06)
+ if(format <= HELIOS_AUDIO_FORMAT_UNKNOWN || format >= 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; i<QUEUE_NUMS; i++)
+ {
+ audio_queue_init(&audio.audio_queue[i]);
+ }
+ audio.cur_priority = 0;
+ audio.cur_breakin = 0;
+ audio.total_nums = 0;
+ //audio.audio_state = AUDIO_IDLE;
+ Helios_Mutex_Unlock(audio.queue_mutex);
+ g_audio_callback = NULL;
+ g_audio_speakerpa_callback = NULL;
+ audio_obj[self->device] = 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 */
+
+
+
+