#include <string.h>
#include "gsmamr_enc.h"
#include "amrnb_enc_api.h"
-#include "audio_file.h"
+#include "helios_audio_fs.h"
+#include <assert.h>
extern "C" {
-#include "utils.h"
typedef struct AmrNbEncState {
void *encCtx;
}AmrNbEncState;
typedef struct amrnb_enc_state {
- AUDIO_FILE_ID fSrc;
- AUDIO_FILE_ID fDst;
+ HeliosAudFILE* fSrc;
+ HeliosAudFILE* fDst;
uint16_t* inputBuf;
uint8_t* outputBuf;
AmrNbEncState* amr;
st->out_format = config->output_format;
// Open input file.
if (config->name) {
- st->fSrc = common_fopen(config->name, "rb");
+ st->fSrc = Helios_Aud_fopen(config->name, "rb");
if (st->fSrc == NULL) {
return -1;
}
// Open output file.
if (config->out_name) {
- st->fDst = common_fopen(config->out_name, "wb");
+ st->fDst = Helios_Aud_fopen(config->out_name, "wb");
if (st->fDst == NULL) {
return -2;
}
// Allocate input buffer.
st->inputBuf = (uint16_t*)malloc(kInputSize);
- ASSERT(st->inputBuf != NULL);
+ assert(st->inputBuf != NULL);
// Allocate output buffer.
st->outputBuf = (uint8_t*)malloc(kOutputSize);
- ASSERT(st->outputBuf != NULL);
+ assert(st->outputBuf != NULL);
// Initialize encoder.
st->amr = (AmrNbEncState*)malloc(sizeof(AmrNbEncState));
// Write file header.
if (st->out_format == AMR_TX_WMF && st->fDst)
- common_fwrite("#!AMR\n", 1, 6, st->fDst);
+ Helios_Aud_fwrite((void*)"#!AMR\n", 1, 6, st->fDst);
*handle = (amrnb_enc_handle)st;
return 0;
}
if (st) {
// Read next input frame.
int bytesRead;
- bytesRead = common_fread(st->inputBuf, 1, kInputSize, st->fSrc);
+ bytesRead = Helios_Aud_fread(st->inputBuf, 1, kInputSize, st->fSrc);
if (bytesRead != kInputSize) {
return -2;
}
return -2;
// Write the output.
- common_fwrite(st->outputBuf, 1, st->bytesGenerated, st->fDst);
+ Helios_Aud_fwrite(st->outputBuf, 1, st->bytesGenerated, st->fDst);
return 0;
}
return -1;
// Close the input and output files.
if (st->fSrc) {
- common_fclose(st->fSrc);
+ Helios_Aud_fclose(st->fSrc);
}
if (st->fDst) {
- common_fclose(st->fDst);
+ Helios_Aud_fclose(st->fDst);
}
free(st);
ring_buffer.c \
watermark.c \
helios_audio_montage.c \
- helios_audio_fs.c
GLOBAL_INCS += \
./
endif
+result1 := $(sort $(filter y,$(CONFIG_AUDIO) $(CONFIG_AUD_RECORD)))
+ifeq (y,$(result1))
+$(NAME)_SRCS += \
+ helios_audio_fs.c
+endif
+
+
ifeq ($(CONFIG_AUDIO_G711_COMPRESS), y)
$(NAME)_SRCS += \
G711/g711.c
ifeq ($(CONFIG_AUDIO_AMR), y)
$(NAME)_SRCS += \
helios_audio_amr.c \
- amr/amrnb/common/src/add.cpp \
- amr/amrnb/common/src/az_lsp.cpp \
- amr/amrnb/common/src/bitno_tab.cpp \
- amr/amrnb/common/src/bitreorder_tab.cpp \
- amr/amrnb/common/src/bits2prm.cpp \
- amr/amrnb/common/src/c2_9pf_tab.cpp \
- amr/amrnb/common/src/copy.cpp \
- amr/amrnb/common/src/div_32.cpp \
- amr/amrnb/common/src/div_s.cpp \
- amr/amrnb/common/src/extract_h.cpp \
- amr/amrnb/common/src/extract_l.cpp \
- amr/amrnb/common/src/gains_tbl.cpp \
- amr/amrnb/common/src/gc_pred.cpp \
- amr/amrnb/common/src/gmed_n.cpp \
- amr/amrnb/common/src/gray_tbl.cpp \
- amr/amrnb/common/src/grid_tbl.cpp \
- amr/amrnb/common/src/int_lpc.cpp \
- amr/amrnb/common/src/inv_sqrt.cpp \
- amr/amrnb/common/src/inv_sqrt_tbl.cpp \
- amr/amrnb/common/src/l_abs.cpp \
- amr/amrnb/common/src/l_deposit_h.cpp \
- amr/amrnb/common/src/l_deposit_l.cpp \
- amr/amrnb/common/src/l_shr_r.cpp \
- amr/amrnb/common/src/log2.cpp \
- amr/amrnb/common/src/log2_norm.cpp \
- amr/amrnb/common/src/log2_tbl.cpp \
- amr/amrnb/common/src/lsfwt.cpp \
- amr/amrnb/common/src/lsp.cpp \
- amr/amrnb/common/src/lsp_az.cpp \
- amr/amrnb/common/src/lsp_lsf.cpp \
- amr/amrnb/common/src/lsp_lsf_tbl.cpp \
- amr/amrnb/common/src/lsp_tab.cpp \
- amr/amrnb/common/src/mult_r.cpp \
- amr/amrnb/common/src/negate.cpp \
- amr/amrnb/common/src/norm_l.cpp \
- amr/amrnb/common/src/norm_s.cpp \
- amr/amrnb/common/src/ph_disp_tab.cpp \
- amr/amrnb/common/src/pow2.cpp \
- amr/amrnb/common/src/pow2_tbl.cpp \
- amr/amrnb/common/src/pred_lt.cpp \
- amr/amrnb/common/src/q_plsf.cpp \
- amr/amrnb/common/src/q_plsf_3.cpp \
- amr/amrnb/common/src/q_plsf_3_tbl.cpp \
- amr/amrnb/common/src/q_plsf_5.cpp \
- amr/amrnb/common/src/q_plsf_5_tbl.cpp \
- amr/amrnb/common/src/qua_gain_tbl.cpp \
- amr/amrnb/common/src/reorder.cpp \
- amr/amrnb/common/src/residu.cpp \
- amr/amrnb/common/src/round.cpp \
- amr/amrnb/common/src/set_zero.cpp \
- amr/amrnb/common/src/shr.cpp \
- amr/amrnb/common/src/shr_r.cpp \
- amr/amrnb/common/src/sqrt_l.cpp \
- amr/amrnb/common/src/sqrt_l_tbl.cpp \
- amr/amrnb/common/src/sub.cpp \
- amr/amrnb/common/src/syn_filt.cpp \
- amr/amrnb/common/src/vad1.cpp \
- amr/amrnb/common/src/weight_a.cpp \
- amr/amrnb/common/src/window_tab.cpp \
$(NAME)_SRCS += \
amr/amrnb/dec/src/pstfilt.cpp \
amr/amrnb/dec/src/qgain475_tab.cpp \
amr/amrnb/dec/src/sp_dec.cpp \
- amr/amrnb/dec/src/wmf_to_ets.cpp
+ amr/amrnb/dec/src/wmf_to_ets.cpp
GLOBAL_INCS += \
amr/include \
amr/amrnb/common/include \
amr/amrnb/dec/api \
amr/amrnb/dec/src \
- amr/amrnb/enc/api \
- amr/amrnb/enc/src \
amr/amrwb/include \
amr/amrwb/api \
amr/amrwb/src \
endif
-
-
ifeq ($(CONFIG_AUDIO_MP3), y)
$(NAME)_SRCS += \
-Wno-error=incompatible-pointer-types \
-Wno-error=sign-compare \
-Wno-error=unused-variable \
- -Wno-error=unused-label
+ -Wno-error=unused-label \
+ -Wno-error=memset-elt-size
$(NAME)_COMPONENTS = peripheral
+
+ifeq ($(CONFIG_AUD_RECORD), y)
+$(NAME)_SRCS += \
+ helios_record.c \
+
+GLOBAL_INCS += \
+ ./ \
+ amr/amrnb/common/include \
+
+
+endif
+
+result2 := $(sort $(filter y,$(CONFIG_AUDIO_AMR) $(CONFIG_AUDIO_RECORD_AMRNB)))
+ifeq (y,$(result2))
+$(NAME)_SRCS += \
+ amr/amrnb/common/src/add.cpp \
+ amr/amrnb/common/src/az_lsp.cpp \
+ amr/amrnb/common/src/bitno_tab.cpp \
+ amr/amrnb/common/src/bitreorder_tab.cpp \
+ amr/amrnb/common/src/bits2prm.cpp \
+ amr/amrnb/common/src/c2_9pf_tab.cpp \
+ amr/amrnb/common/src/copy.cpp \
+ amr/amrnb/common/src/div_32.cpp \
+ amr/amrnb/common/src/div_s.cpp \
+ amr/amrnb/common/src/extract_h.cpp \
+ amr/amrnb/common/src/extract_l.cpp \
+ amr/amrnb/common/src/gains_tbl.cpp \
+ amr/amrnb/common/src/gc_pred.cpp \
+ amr/amrnb/common/src/gmed_n.cpp \
+ amr/amrnb/common/src/gray_tbl.cpp \
+ amr/amrnb/common/src/grid_tbl.cpp \
+ amr/amrnb/common/src/int_lpc.cpp \
+ amr/amrnb/common/src/inv_sqrt.cpp \
+ amr/amrnb/common/src/inv_sqrt_tbl.cpp \
+ amr/amrnb/common/src/l_abs.cpp \
+ amr/amrnb/common/src/l_deposit_h.cpp \
+ amr/amrnb/common/src/l_deposit_l.cpp \
+ amr/amrnb/common/src/l_shr_r.cpp \
+ amr/amrnb/common/src/log2.cpp \
+ amr/amrnb/common/src/log2_norm.cpp \
+ amr/amrnb/common/src/log2_tbl.cpp \
+ amr/amrnb/common/src/lsfwt.cpp \
+ amr/amrnb/common/src/lsp.cpp \
+ amr/amrnb/common/src/lsp_az.cpp \
+ amr/amrnb/common/src/lsp_lsf.cpp \
+ amr/amrnb/common/src/lsp_lsf_tbl.cpp \
+ amr/amrnb/common/src/lsp_tab.cpp \
+ amr/amrnb/common/src/mult_r.cpp \
+ amr/amrnb/common/src/negate.cpp \
+ amr/amrnb/common/src/norm_l.cpp \
+ amr/amrnb/common/src/norm_s.cpp \
+ amr/amrnb/common/src/ph_disp_tab.cpp \
+ amr/amrnb/common/src/pow2.cpp \
+ amr/amrnb/common/src/pow2_tbl.cpp \
+ amr/amrnb/common/src/pred_lt.cpp \
+ amr/amrnb/common/src/q_plsf.cpp \
+ amr/amrnb/common/src/q_plsf_3.cpp \
+ amr/amrnb/common/src/q_plsf_3_tbl.cpp \
+ amr/amrnb/common/src/q_plsf_5.cpp \
+ amr/amrnb/common/src/q_plsf_5_tbl.cpp \
+ amr/amrnb/common/src/qua_gain_tbl.cpp \
+ amr/amrnb/common/src/reorder.cpp \
+ amr/amrnb/common/src/residu.cpp \
+ amr/amrnb/common/src/round.cpp \
+ amr/amrnb/common/src/set_zero.cpp \
+ amr/amrnb/common/src/shr.cpp \
+ amr/amrnb/common/src/shr_r.cpp \
+ amr/amrnb/common/src/sqrt_l.cpp \
+ amr/amrnb/common/src/sqrt_l_tbl.cpp \
+ amr/amrnb/common/src/sub.cpp \
+ amr/amrnb/common/src/syn_filt.cpp \
+ amr/amrnb/common/src/vad1.cpp \
+ amr/amrnb/common/src/weight_a.cpp \
+ amr/amrnb/common/src/window_tab.cpp \
+
+endif
+
+ifeq ($(CONFIG_AUDIO_RECORD_AMRNB), y)
+$(NAME)_SRCS += \
+ amr/amrnb/enc/src/amrencode.cpp \
+ amr/amrnb/enc/src/autocorr.cpp \
+ amr/amrnb/enc/src/c1035pf.cpp \
+ amr/amrnb/enc/src/c2_11pf.cpp \
+ amr/amrnb/enc/src/c2_9pf.cpp \
+ amr/amrnb/enc/src/c3_14pf.cpp \
+ amr/amrnb/enc/src/c4_17pf.cpp \
+ amr/amrnb/enc/src/c8_31pf.cpp \
+ amr/amrnb/enc/src/calc_cor.cpp \
+ amr/amrnb/enc/src/calc_en.cpp \
+ amr/amrnb/enc/src/cbsearch.cpp \
+ amr/amrnb/enc/src/cl_ltp.cpp \
+ amr/amrnb/enc/src/cod_amr.cpp \
+ amr/amrnb/enc/src/convolve.cpp \
+ amr/amrnb/enc/src/cor_h.cpp \
+ amr/amrnb/enc/src/cor_h_x.cpp \
+ amr/amrnb/enc/src/cor_h_x2.cpp \
+ amr/amrnb/enc/src/corrwght_tab.cpp \
+ amr/amrnb/enc/src/dtx_enc.cpp \
+ amr/amrnb/enc/src/enc_lag3.cpp \
+ amr/amrnb/enc/src/enc_lag6.cpp \
+ amr/amrnb/enc/src/enc_output_format_tab.cpp \
+ amr/amrnb/enc/src/ets_to_if2.cpp \
+ amr/amrnb/enc/src/ets_to_wmf.cpp \
+ amr/amrnb/enc/src/g_adapt.cpp \
+ amr/amrnb/enc/src/g_code.cpp \
+ amr/amrnb/enc/src/g_pitch.cpp \
+ amr/amrnb/enc/src/gain_q.cpp \
+ amr/amrnb/enc/src/hp_max.cpp \
+ amr/amrnb/enc/src/inter_36.cpp \
+ amr/amrnb/enc/src/inter_36_tab.cpp \
+ amr/amrnb/enc/src/l_comp.cpp \
+ amr/amrnb/enc/src/l_extract.cpp \
+ amr/amrnb/enc/src/l_negate.cpp \
+ amr/amrnb/enc/src/lag_wind.cpp \
+ amr/amrnb/enc/src/lag_wind_tab.cpp \
+ amr/amrnb/enc/src/levinson.cpp \
+ amr/amrnb/enc/src/lpc.cpp \
+ amr/amrnb/enc/src/ol_ltp.cpp \
+ amr/amrnb/enc/src/p_ol_wgh.cpp \
+ amr/amrnb/enc/src/pitch_fr.cpp \
+ amr/amrnb/enc/src/pitch_ol.cpp \
+ amr/amrnb/enc/src/pre_big.cpp \
+ amr/amrnb/enc/src/pre_proc.cpp \
+ amr/amrnb/enc/src/prm2bits.cpp \
+ amr/amrnb/enc/src/q_gain_c.cpp \
+ amr/amrnb/enc/src/q_gain_p.cpp \
+ amr/amrnb/enc/src/qgain475.cpp \
+ amr/amrnb/enc/src/qgain795.cpp \
+ amr/amrnb/enc/src/qua_gain.cpp \
+ amr/amrnb/enc/src/s10_8pf.cpp \
+ amr/amrnb/enc/src/set_sign.cpp \
+ amr/amrnb/enc/src/sid_sync.cpp \
+ amr/amrnb/enc/src/sp_enc.cpp \
+ amr/amrnb/enc/src/spreproc.cpp \
+ amr/amrnb/enc/src/spstproc.cpp \
+ amr/amrnb/enc/src/ton_stab.cpp \
+ amr/amrnb/enc/api/amrnb_enc_api.cpp \
+
+GLOBAL_INCS += \
+ ./ \
+ amr/amrnb/common/include \
+ amr/amrnb/enc/api \
+ amr/amrnb/enc/src \
+ amr/amrwbenc/api
+
+
+endif
+
+ifeq ($(CONFIG_AUDIO_RECORD_MP3), y)
+
+$(NAME)_SRCS += \
+ mp3_shine/bitstream.c \
+ mp3_shine/huffman.c \
+ mp3_shine/l3bitstream.c \
+ mp3_shine/l3loop.c \
+ mp3_shine/l3mdct.c \
+ mp3_shine/l3subband.c \
+ mp3_shine/layer3.c \
+ mp3_shine/reservoir.c \
+ mp3_shine/tables.c \
+
+GLOBAL_INCS += \
+ ./ \
+ mp3_shine
+
+endif
default n
help
Enable amrnb format.
+
config AUDIO_G711_COMPRESS
bool "Enable G711 compression"
default n
help
Enable G729(BGG729) compression function.
+
+config AUD_RECORD
+ bool "Enable Audio Record"
+ default n
+help
+ Audio Record is placed in the python SDK. Enable Audio_Record switch.
+
+config AUDIO_RECORD_AMRNB
+ bool "Enable AMRNB format recording"
+ depends on AUD_RECORD
+ default n
+help
+ Enable AMRNB format recording.
+
+config AUDIO_RECORD_WAV
+ bool "Enable WAV format recording"
+ depends on AUD_RECORD
+ default n
+help
+ Enable WAV format recording.
+
+config AUDIO_RECORD_MP3
+ bool "Enable MP3 format recording"
+ depends on AUD_RECORD
+ default n
+help
+ Enable MP3 format recording.
kFileHeaderSize = 6
};
static const uint32_t kFrameSizes[] = {12, 13, 15, 17, 19, 20, 26, 31};
-#define AMR_STREAM_WM_BUF_SIZE 960
+#define AMR_STREAM_WM_BUF_SIZE (1024*4)
#define AMR_DEC_CONTINUE (0x01)
#define AMR_WRITE_CONTINUE (0x02)
cb_on_player aud_play_cb = NULL;
+static bool _audio_play_state = 0;
+
+
+#if (defined(PLAT_ASR_1803s) || defined(BOARD_EC600MCN_CC_EXT) || defined(BOARD_EC600MCN_LF_SLPOC) \
+ ||defined(PLAT_Unisoc_8850) || defined(BOARD_EC600MCN_CC_EXT_TTS) || defined(BOARD_EC800MCN_CC_TTS) \
+ || defined(BOARD_EC800KCN_CC_TTS) || defined(BOARD_EC600KCN_CC_TTS))
+
+#define USR_HELIOS_AUDIO 1
+
+#endif
+
+
struct helios_arm_stream_cxt
{
wm_handle_t wm;
}
-#if defined(PLAT_ASR_1803s) || defined(BOARD_EC600MCN_CC_EXT) || defined(BOARD_EC600MCN_LF_SLPOC) || defined(PLAT_Unisoc_8850)
+#if defined(PLAT_ASR_1803s) || defined(BOARD_EC600MCN_CC_EXT) || defined(BOARD_EC600MCN_LF_SLPOC) \
+ || defined(PLAT_Unisoc_8850) || defined(BOARD_EC600MCN_CC_EXT_TTS) || defined(BOARD_EC800MCN_CC_TTS) \
+ || defined(BOARD_EC800KCN_CC_TTS) || defined(BOARD_EC600KCN_CC_TTS)
static void __pcm_play_cb(void *handle, int event){
AUDLOGE("__pcm_play_cb event[%d]\n",event);
g_arm_stream_cxt.pcm_whdl = NULL;
}
}
+
+ if(event == HELIOS_AUD_PLAYER_FINISHED || event == HELIOS_AUD_PLAYER_CLOSE) {
+ _audio_play_state = 0;
+ }
if(aud_play_cb != NULL) {
aud_play_cb("stream", 0, event);
inputBuf = pAmrInputBuf;
outputBuf = pAmrOutputBuf;
memset(pAmrOutputBuf, 0, kOutputBufferSize);
+ int _count = 100;
while (1)
{
g_arm_stream_cxt.is_dec_start = false;
+ _count = 100;
AUDLOGD("amr dec start\n");
Helios_Flag_Wait(g_arm_stream_cxt.flag_ref, AMR_DEC_CONTINUE, Helios_FLAG_OR_CLEAR, &event, HELIOS_WAIT_FOREVER);
g_arm_stream_cxt.is_dec_start = true;
+ if(g_arm_stream_cxt.pcm_whdl == NULL) {
+
+#ifdef USR_HELIOS_AUDIO
+ while(_audio_play_state == 1 && _count-- > 1){
+ AUDLOGE("audio1 is playing, waiting[%d]...\n",_count);
+ Helios_msleep(20);
+ }
+#endif
+
#ifdef CONFIG_AUDIO_PWM
- g_arm_stream_cxt.pcm_whdl = Helios_Aud_PWM_Open(CONFIG_AUDIO_PWM_PIN, 1, 8000, QL_PCM_WRITE_FLAG | QL_PCM_BLOCK_FLAG);
+ g_arm_stream_cxt.pcm_whdl = Helios_Aud_PWM_Open(CONFIG_AUDIO_PWM_PIN, 1, 8000, QL_PCM_WRITE_FLAG | QL_PCM_BLOCK_FLAG);
#else
- g_arm_stream_cxt.pcm_whdl = Helios_PCM_Open(1, 8000, QL_PCM_WRITE_FLAG | QL_PCM_BLOCK_FLAG);
-#if defined(PLAT_ASR_1803s) || defined(BOARD_EC600MCN_CC_EXT) || defined(BOARD_EC600MCN_LF_SLPOC) || defined(PLAT_Unisoc_8850)
- Helios_PCM_Play_Cb(g_arm_stream_cxt.pcm_whdl, __pcm_play_cb);
+ g_arm_stream_cxt.pcm_whdl = Helios_PCM_Open(1, 8000, QL_PCM_WRITE_FLAG | QL_PCM_BLOCK_FLAG);
+#ifdef USR_HELIOS_AUDIO
+ Helios_PCM_Play_Cb(g_arm_stream_cxt.pcm_whdl, __pcm_play_cb);
+ _audio_play_state = 1;
#endif
-
#endif
+ }
+
AUDLOGD("pcm_whdl[%x]\n", g_arm_stream_cxt.pcm_whdl);
AUDLOGE("pcm_whdl is NULL");
continue;
}
+ Speech_Decode_Frame_reset(g_arm_stream_cxt.amr_dec_hdl);
if (is_amr == 0)
{
if (aud_play_cb)
{
-#if !defined(PLAT_ASR_1803s) && !defined(BOARD_EC600MCN_CC_EXT) && !defined(BOARD_EC600MCN_LF_SLPOC) && !defined(PLAT_Unisoc_8850)
+#if !(defined(PLAT_ASR_1803s) || defined(BOARD_EC600MCN_CC_EXT) || defined(BOARD_EC600MCN_LF_SLPOC) \
+ ||defined(PLAT_Unisoc_8850) || defined(BOARD_EC600MCN_CC_EXT_TTS) || defined(BOARD_EC800MCN_CC_TTS) \
+ || defined(BOARD_EC800KCN_CC_TTS)) || defined(BOARD_EC600KCN_CC_TTS)
aud_play_cb(NULL, 0, HELIOS_AUD_PLAYER_START);
#endif
}
void Helios_aud_data_done(void);
Helios_aud_data_done();
#endif
-#if !defined(PLAT_ASR_1803s) && !defined(BOARD_EC600MCN_CC_EXT) && !defined(BOARD_EC600MCN_LF_SLPOC) && !defined(PLAT_Unisoc_8850)
+#if !(defined(PLAT_ASR_1803s) || defined(BOARD_EC600MCN_CC_EXT) || defined(BOARD_EC600MCN_LF_SLPOC) \
+ ||defined(PLAT_Unisoc_8850) || defined(BOARD_EC600MCN_CC_EXT_TTS) || defined(BOARD_EC800MCN_CC_TTS) \
+ || defined(BOARD_EC800KCN_CC_TTS) || defined(BOARD_EC600KCN_CC_TTS))
Helios_PCM_Close(g_arm_stream_cxt.pcm_whdl);
g_arm_stream_cxt.pcm_whdl = NULL;
#endif
{
if (aud_play_cb)
{
-#if !defined(PLAT_ASR_1803s) && !defined(BOARD_EC600MCN_CC_EXT) && !defined(BOARD_EC600MCN_LF_SLPOC) && !defined(PLAT_Unisoc_8850)
+#if !(defined(PLAT_ASR_1803s) || defined(BOARD_EC600MCN_CC_EXT) || defined(BOARD_EC600MCN_LF_SLPOC) \
+ ||defined(PLAT_Unisoc_8850) || defined(BOARD_EC600MCN_CC_EXT_TTS) || defined(BOARD_EC800MCN_CC_TTS) \
+ || defined(BOARD_EC800KCN_CC_TTS) || defined(BOARD_EC600KCN_CC_TTS))
aud_play_cb(NULL, 0, HELIOS_AUD_PLAYER_FINISHED);
#endif
}
uint8_t msg = 1;
int ret = -1;
static int amr_stream_open_start = 1;
+ int _count = 100;
if (amr_stream_open_start)
{
}
amr_stream_open_start = 0;
}
+
+#ifdef USR_HELIOS_AUDIO
+ while(_audio_play_state == 1 && g_arm_stream_cxt.pcm_whdl == NULL && _count-- > 1){
+ AUDLOGE("audio is playing, waiting[%d]...\n",_count);
+ Helios_msleep(20);
+ }
+#endif
+
Helios_Mutex_Lock(g_arm_stream_cxt.playflag_mux, HELIOS_WAIT_FOREVER);
g_arm_stream_cxt.is_playing = true;
static int __jump_cnt = -1;
static PCM_HANDLE_T mp3_pcm_whdl = NULL;
+static bool _audio_play_state = 0;
+static bool _mp3_stream_change_rate = false;
+
+
+#if (defined(PLAT_ASR_1803s) || defined(BOARD_EC600MCN_CC_EXT) || defined(BOARD_EC600MCN_LF_SLPOC) \
+ ||defined(PLAT_Unisoc_8850) || defined(BOARD_EC600MCN_CC_EXT_TTS) || defined(BOARD_EC800MCN_CC_TTS) \
+ || defined(BOARD_EC800KCN_CC_TTS) || defined(BOARD_EC600KCN_CC_TTS))
+
+#define USR_HELIOS_AUDIO 1
+
+#endif
-#if defined(PLAT_ASR_1803s) || defined(BOARD_EC600MCN_CC_EXT) || defined(BOARD_EC600MCN_LF_SLPOC) || defined(PLAT_Unisoc_8850)
+#ifdef USR_HELIOS_AUDIO
static void __pcm_play_cb(void *handle, int event){
- AUDLOGE("__pcm_play_cb event[%d]\n",event);
+ AUDLOGD("__pcm_play_cb event[%d][%x][%x]\n",event,handle,mp3_pcm_whdl);
if(event == HELIOS_AUD_PLAYER_NODATA_STRAT || event == HELIOS_AUD_PLAYER_FINISHED || event == HELIOS_AUD_PLAYER_CLOSE || event == HELIOS_AUD_PLAYER_REQURST_CLOSE) {
if(mp3_pcm_whdl){
mp3_pcm_whdl = NULL;
}
}
+ if(event == HELIOS_AUD_PLAYER_FINISHED || event == HELIOS_AUD_PLAYER_CLOSE) {
+ _audio_play_state = 0;
+ }
- if(aud_play_cb != NULL) {
+ if(aud_play_cb != NULL && _mp3_stream_change_rate == false) {
aud_play_cb("stream", 0, event);
}
+ if(event == HELIOS_AUD_PLAYER_START)
+ {
+ _mp3_stream_change_rate = false;
+ }
}
#endif
return true;
}
static uint32_t mp3_frame_size, mp3_sample_rate, mp3_num_channels;
+static uint8_t _header_buf_pre[4] = {0};
static int get_mp3_frame(void *buffer, uint32_t *size)
{
uint32 event;
{
return -1;
}
+ memcpy(_header_buf_pre, buf, 4);
return 0;
}
int Helios_play_stream_start(unsigned int rate, unsigned int ch, unsigned short *pcm_buf, unsigned int frameByteSize)
{
int ret = 0;
+ int _count = 100;
+ static unsigned int rate_pre = 0;
+ static unsigned int ch_pre = 0;
+ if(mp3_pcm_whdl && (rate_pre != rate || ch_pre != ch))
+ {
+ AUDLOGD("change rate\r\n");
+ _mp3_stream_change_rate = true;
+
+ while(_audio_play_state == 1 && _count-- > 1){
+ AUDLOGD("audio1 is playing, waiting[%d]...\n",_count);
+ Helios_msleep(20);
+ }
+ }
+ rate_pre = rate;
+ ch_pre = ch;
+ _count = 100;
+
if (mp3_pcm_whdl == NULL)
{
+#ifdef USR_HELIOS_AUDIO
+ while(_audio_play_state == 1 && _count-- > 1){
+ AUDLOGD("audio1 is playing, waiting[%d]...\n",_count);
+ Helios_msleep(20);
+ }
+#endif
#ifdef CONFIG_AUDIO_PWM
mp3_pcm_whdl = Helios_Aud_PWM_Open(CONFIG_AUDIO_PWM_PIN, 1, rate, HELIOS_PCM_WRITE_FLAG | HELIOS_PCM_BLOCK_FLAG);
#else
mp3_pcm_whdl = Helios_PCM_Open(ch, rate, HELIOS_PCM_WRITE_FLAG | HELIOS_PCM_BLOCK_FLAG);
-#if defined(PLAT_ASR_1803s) || defined(BOARD_EC600MCN_CC_EXT) || defined(BOARD_EC600MCN_LF_SLPOC) || defined(PLAT_Unisoc_8850)
+#ifdef USR_HELIOS_AUDIO
Helios_PCM_Play_Cb(mp3_pcm_whdl, __pcm_play_cb);
+ _audio_play_state = 1;
+
#endif
#endif
char nodataStartCnt = 5;
char is_resume = 0;
int is_silence = 0;
+ char is_mutex = 0;
+ char _change_tmp = 1;
buff = (unsigned char *)malloc(1024*2);
Helios_pcm_outbuf = (unsigned short *)malloc(4608*2);
if (aud_play_cb)
{
-#if !defined(PLAT_ASR_1803s) && !defined(BOARD_EC600MCN_CC_EXT) && !defined(BOARD_EC600MCN_LF_SLPOC) && !defined(PLAT_Unisoc_8850)
+#ifndef USR_HELIOS_AUDIO
aud_play_cb(NULL, 0, HELIOS_AUD_PLAYER_START);
#endif
}
if (ret != 0)
{
// break;
+ AUDLOGE("get_mp3_frame ret[%d][%d]\n", ret,_change_tmp);
+ Helios_msleep(20);
+ _change_tmp ^= 1;
+ if(_change_tmp == 0){
+ continue;
+ }
+
if (STREAM_IsNot_SwitchOff_Actively)
{
memset(buff, 0x00, 2 * 1024);
bytesRead = 2 * 1024;
- buff[0] = 0xff;
- buff[1] = 0xfb;
- buff[2] = 0x70;
- buff[3] = 0xC0;
- bytesRead = 313;
+ if(_header_buf_pre[0] == 0xff){
+ memcpy(buff, _header_buf_pre, 4);
+ bytesRead = mp3_frame_size;
+ } else {
+ buff[0] = 0xff;
+ buff[1] = 0xfb;
+ buff[2] = 0x70;
+ buff[3] = 0xC0;
+ bytesRead = 313;
+ }
+ AUDLOGD("header[%x][%x][%x][%x] size[%d]\n", buff[0],buff[1],buff[2],buff[3], mp3_frame_size);
+
if (nodataStartCnt == 1)
{
is_resume = 1;
if (aud_play_cb)
{
+ AUDLOGD("HELIOS_AUD_PLAYER_NODATA_STRAT\n");
aud_play_cb(NULL, 0, HELIOS_AUD_PLAYER_NODATA_STRAT);
}
}
{
break;
}
+ is_mutex = 1;
}
else
{
Helios_config.samplerate = mp3_sample_rate;
Helios_config.channels = mp3_num_channels;
nodataStartCnt = 5;
+ _change_tmp = 1;
if (is_resume == 1)
{
is_resume = 0;
if (aud_play_cb)
{
+ AUDLOGD("HELIOS_AUD_PLAYER_DATA_RESUME\n");
aud_play_cb(NULL, 0, HELIOS_AUD_PLAYER_DATA_RESUME);
}
}
+ is_mutex = 0;
}
Helios_Semaphore_Poll(Helios_ring_buf->wcond, &ret);
Helios_Semaphore_Release(Helios_ring_buf->wcond);
}
- if(__jump_cnt != -1 && __jump_count != 0 && isSilenceFrame(buff+4, (mp3_frame_size-4)/2)){
+ if(__jump_cnt != -1 && __jump_count != 0 && mp3_frame_size >= 4 && isSilenceFrame(buff+4, (mp3_frame_size-4)/2)){
is_silence = 1;
} else {
is_silence = 0;
continue;
}
- if(is_silence) {
+ if(is_silence && is_mutex == 0) {
AUDLOGD("jis_silence\n");
continue;
}
Helios_Aud_PWM_Close(mp3_pcm_whdl);
mp3_pcm_whdl = NULL;
#else
-#if !defined(PLAT_ASR_1803s) && !defined(BOARD_EC600MCN_CC_EXT) && !defined(BOARD_EC600MCN_LF_SLPOC) && !defined(PLAT_Unisoc_8850)
+#ifndef USR_HELIOS_AUDIO
Helios_PCM_Close(mp3_pcm_whdl);
mp3_pcm_whdl = NULL;
#endif
if (aud_play_cb)
{
-#if !defined(PLAT_ASR_1803s) && !defined(BOARD_EC600MCN_CC_EXT) && !defined(BOARD_EC600MCN_LF_SLPOC) && !defined(PLAT_Unisoc_8850)
+#ifndef USR_HELIOS_AUDIO
aud_play_cb(NULL, 0, HELIOS_AUD_PLAYER_FINISHED);
#endif
}
int tatol_size = 0;
int left_size = mp3_size;
int stream_start = 0;
+ int _count = 100;
AUDLOGD("stream mp3 size[%d]\n", mp3_size);
-
+#ifdef USR_HELIOS_AUDIO
+ while(_audio_play_state == 1 && mp3_pcm_whdl == NULL && _count-- > 1){
+ AUDLOGE("audio is playing, waiting[%d]...\n",_count);
+ Helios_msleep(20);
+ }
+#endif
if (Helios_ring_buf == NULL)
{
Helios_config.len_size = MP3_RINGBUFF_LEN;
{
if (aud_play_cb)
{
+ AUDLOGD("HELIOS_AUD_PLAYER_MOREDATA\n");
aud_play_cb(NULL, 0, HELIOS_AUD_PLAYER_MOREDATA);
}
}
{
aud_play_cb = aud_cb;
}
-#if defined(PLAT_ASR_1803s) || defined(BOARD_EC600MCN_CC_EXT) || defined(BOARD_EC600MCN_LF_SLPOC) || defined(PLAT_Unisoc_8850)
+#ifdef USR_HELIOS_AUDIO
Helios_aud_stop_play_flag = 0;
#endif
AUDLOGE("Sync to the first valid frame error\n");
if (aud_play_cb)
{
+ AUDLOGD("HELIOS_AUD_PLAYER_ERROR\n");
aud_play_cb(NULL, 0, HELIOS_AUD_PLAYER_ERROR);
}
free(mp3_buf);
AUDLOGE("fs seek failed\n");
if (aud_play_cb)
{
+ AUDLOGD("HELIOS_AUD_PLAYER_ERROR\n");
aud_play_cb(NULL, 0, HELIOS_AUD_PLAYER_ERROR);
}
free(mp3_buf);
AUDLOGE("fs seek failed\n");
if (aud_play_cb)
{
+ AUDLOGD("HELIOS_AUD_PLAYER_ERROR\n");
aud_play_cb(NULL, 0, HELIOS_AUD_PLAYER_ERROR);
}
free(mp3_buf);
while (1)
{
// memset(mp3_buf, 0, read_size);
-#if defined(PLAT_ASR_1803s) || defined(BOARD_EC600MCN_CC_EXT) || defined(BOARD_EC600MCN_LF_SLPOC) || defined(PLAT_Unisoc_8850)
+#ifdef USR_HELIOS_AUDIO
if(Helios_aud_stop_play_flag){
break;
}
AUDLOGE("error, mp3 is not playing\n");
return -1;
}
-#if !defined(PLAT_ASR_1803s) && !defined(BOARD_EC600MCN_CC_EXT) && !defined(BOARD_EC600MCN_LF_SLPOC) && !defined(PLAT_Unisoc_8850)
+#ifndef USR_HELIOS_AUDIO
Helios_aud_stop_play_flag = 1;
#endif
Helios_msleep(15);
count++;
}
-#if defined(PLAT_ASR_1803s) || defined(BOARD_EC600MCN_CC_EXT) || defined(BOARD_EC600MCN_LF_SLPOC) || defined(PLAT_Unisoc_8850)
+#ifdef USR_HELIOS_AUDIO
Helios_mp3_Clear_Cache();
#endif
AUDLOGD("mp3Stop finish");
* @return:
* start play audio file result, 0 for success,-1 for failure
*/
-#if defined(PLAT_ASR_1606)
+#if defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) || defined(PLAT_ASR_1602)
typedef void(*helios_cb_pcm_play)(void*, int);
static void __pcm_play_cb(void *handle, int event){
}
// AUDLOGI("wav fomat init completed channels:%d,samplerate:%d\n",wav_config.channels,wav_config.samplerate);
helios_stream_init_flag = HELIOS_INITED;
-#if defined(PLAT_ASR_1606)
+#if defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) || defined(PLAT_ASR_1602)
Helios_PCM_Play_Cb(write_hdl, __pcm_play_cb);
#endif
}
attr.entry = __Helios_file_play;
__audio_file_task = Helios_Thread_Create(&attr);
+
assert(__audio_file_task != 0);
inited = 1;
int Helios_Audio_FilePlayStop(void);
-
+static int Helios_Audio_Find_Files_by_name(char *file_name)
+{
+ int rc = 0;
+ int index = 0;
+ char* file_token = NULL;
+ char* path_index = NULL;
+ char folder_buff[256] = {0};
+ char file_name_buff[256] = {0};
+ char file_path_buff[256] = {0};
+ int file_name_len = strlen(file_name);
+ if(file_name_len < sizeof("mp3files="))
+ {
+ rc = helios_find_file(file_name);
+ if(rc != 1)
+ {
+ AUDLOGE("not find %s\n", file_name);
+ return -1;
+ }
+ }
+ else
+ {
+ if(strncmp(file_name,"mp3files=",strlen("mp3files=")) == 0)
+ {
+ strcpy(file_name_buff,file_name);
+ file_token = strtok(file_name_buff,"=+");
+ file_token = strtok(NULL,"=+");
+ //AUDLOGE("token: %s\n", file_token);
+ path_index = strrchr(file_token,'/');
+ if(NULL != path_index)
+ {
+ rc = helios_find_file(file_token);
+ if(rc != 1)
+ {
+ AUDLOGE("not find %s\n", file_token);
+ return -1;
+ }
+ index = path_index - file_token;
+ memset(folder_buff,0,sizeof(folder_buff));
+ strncpy(folder_buff,file_token,index+1); //get folder path
+ //AUDLOGE("folder_buff: %s\n", folder_buff);
+ }
+ while(NULL != file_token)
+ {
+ file_token = strtok(NULL,"=+");
+ if(NULL != file_token)
+ {
+ sprintf(file_path_buff,"%s%s",folder_buff,file_token); //get file path
+ //AUDLOGE("file: %s\n", file_path_buff);
+ rc = helios_find_file(file_path_buff);
+ if(rc != 1)
+ {
+ AUDLOGE("not find %s\n", file_path_buff);
+ return -1;
+ }
+ }
+ else{
+ break;
+ }
+ }
+
+ }
+ else
+ {
+ rc = helios_find_file(file_name);
+ if(rc != 1)
+ {
+ AUDLOGE("not find %s\n", file_name);
+ return -1;
+ }
+ }
+ }
+
+ return 0;
+}
int Helios_Audio_FilePlayStart(char *file_name, Helios_AudPlayerType type, helios_cb_on_player usr_cb)
{
+ int ret = 0;
(void)type;
AUDLOGE("file[%s] release\n", file_name);
play_user_cb = usr_cb;
//ql_audio_play_init(helios_audio_play_callback);
- int rc = 0, ret = 0;
- int read_size = 0;
-
-#if 0
- rc = helios_find_file(file_name);
- if(rc != 1)
- {
- AUDLOGE("not find %s\n", file_name);
- return -1;
- }
-#endif
+ ret = Helios_Audio_Find_Files_by_name(file_name);
+ if(0 != ret)
+ {
+ return -1;
+ }
memset(__audio_play_file, 0, sizeof(__audio_play_file));
sprintf(__audio_play_file, "%s", file_name);
HELIOS_AUDIO_FORMAT_AAC, ///< AAC
HELIOS_AUDIO_FORMAT_M4A, ///< M4A
HELIOS_AUDIO_FORMAT_TS, ///< TS
-
+ HELIOS_AUDIO_FORMAT_FLV,
+ HELIOS_AUDIO_FORMAT_RTMP,
HELIOS_AUDIO_FORMAT_MAX
} Helios_AudStreamFormat;
|| defined(BOARD_EC800MCN_GA) || defined(BOARD_EC800MCN_GA_VOLTE) \
|| defined(BOARD_EC800MCN_GA_ALIPAY) || defined(BOARD_EC800MCN_GA_ALIPAY) \
|| defined(BOARD_EC800MCN_GA_SPISD) || defined(BOARD_EC800MCN_GA_MS) \
- || defined(BOARD_EC800MCN_LE) || defined(BOARD_EC800MCN_LE_VOLTE) \
- || defined(BOARD_EC800MCN_LA_POC_XBND) || defined(BOARD_EC800MCN_LE_POC_XBND)
+ || 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_EC600MEU_LA_POC_XBND) || defined(PLAT_ASR_1803s)
static int g_pa_class = 2;
static audio_obj_t *audio_obj[AUDIO_CHANNEL_MAX] = {NULL};
static char montage_is_break = 0;
+char audio_playing_file_name[256] = {0};
int audio_err_handle(void);
} while (0)
#else
-#if defined(PLAT_ASR) || defined(PLAT_Unisoc) || defined(PLAT_ASR_1606) || defined(PLAT_Unisoc_8850) || defined(PLAT_Unisoc_8910_R05)
+#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)
#define GET_FILE_VFS_PATH(x, y) get_vfs_path(x,y)
#else
#define GET_FILE_VFS_PATH(x, y) \
static Helios_MsgQ_t open_pa_q = 0;
static Helios_Thread_t open_pa_task_id = 0;
-static uint32_t open_pa_delay = 200; // 默认延时200ms开启PA
+static uint32_t open_pa_delay = 0;
// 延时打开PA
void helios_open_pa(void * argv) {
return ret;
}
-#if defined(BOARD_EC600MCN_CC_EXT) || defined(BOARD_EC600MCN_LF_SLPOC) || defined(BOARD_EC600MCN_LE_POC_QS)
-
-void user_audio_speakerpa_callback(unsigned int event)
-{
- HELIOS_AUDIO_LOG("g_gpio_pa{%d],event[%d]\n",g_gpio_pa, event);
- if(g_gpio_pa != -1)
- {
- if (event == 1)
- {
- //打开PA
- audio_open_power_amplifier();
- HELIOS_AUDIO_LOG("audio set high, event 1.\r\n");
- } else {
- //关闭PA
- set_clk_low();
- HELIOS_AUDIO_LOG("audio set low, event 0.\r\n");
- }
- }
- if (g_audio_speakerpa_callback)
- {
- mp_sched_schedule_ex(g_audio_speakerpa_callback, mp_obj_new_int(event));
- }
-}
-
-#else
-
-
void user_audio_speakerpa_callback(unsigned int event)
{
uint8_t pa_ctrl;
}
}
-#endif
-
-#if defined (PLAT_ASR) || defined(PLAT_Unisoc) || defined(PLAT_ASR_1606) || defined(PLAT_Unisoc_8850) || defined(PLAT_EIGEN) || defined(PLAT_Unisoc_8910_R05)
+#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)
STATIC mp_obj_t helios_set_pa(size_t n_args, const mp_obj_t *args)
{
int ret = 0;
ret = Helios_GPIO_Init(g_gpio_pa, &gpio_struct);//Helios_Audio_SetPa(g_gpio_pa);
if (ret != 0)
{
-#if defined(BOARD_EC600MCN_CC_EXT) || defined(BOARD_EC600MCN_LF_SLPOC)
+#if defined(BOARD_EC600MCN_CC_EXT) || defined(BOARD_EC600MCN_LF_SLPOC) || defined(BOARD_EC600MCN_CC_EXT_TTS) \
+ || defined(BOARD_EC800MCN_CC_TTS) || defined(BOARD_EC800KCN_CC_TTS) || defined(BOARD_EC600KCN_CC_TTS)
Helios_Audio_SetPaCallback(HELIOS_OUTPUT_RECEIVER, user_audio_speakerpa_callback);
#endif
return mp_obj_new_int(0);
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)
+
+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
/*=============================================================================*/
}
#if !CONFIG_AUDIO_PWM
-#if defined (PLAT_ASR) || defined (PLAT_Unisoc) || defined(PLAT_ASR_1606) || defined (PLAT_Unisoc_8850) || defined(PLAT_Unisoc_8910_R05)
+#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)
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);
//self->inited = 0;
Helios_Audio_Init();
- #if defined(PLAT_ASR) || defined(PLAT_Unisoc) || defined(PLAT_ASR_1606) || defined(PLAT_EIGEN) || defined(PLAT_Unisoc_8850) || defined(PLAT_Unisoc_8910_R05)
+ #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)
#if CONFIG_AUDIO
extern int Helios_Audio_SetPaCallback_py(Helios_AudOutputType type, helios_audio_pa_cb_t cb);
-#if defined(BOARD_EC600MCN_CC_EXT) || defined(BOARD_EC600MCN_LF_SLPOC)
+#if defined(BOARD_EC600MCN_CC_EXT) || defined(BOARD_EC600MCN_LF_SLPOC) || defined(BOARD_EC600MCN_CC_EXT_TTS) \
+ || defined(BOARD_EC800MCN_CC_TTS) || defined(BOARD_EC800KCN_CC_TTS) || defined(BOARD_EC600KCN_CC_TTS)
Helios_Audio_SetPaCallback((Helios_AudOutputType)device, user_audio_speakerpa_callback);
#else
Helios_Audio_SetPaCallback_py((Helios_AudOutputType)device, user_audio_speakerpa_callback);
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);
}
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);
+int helios_set_montage_break_flag(char set){
+ if(set == 1 || set == 0)
+ {
+ montage_is_break = set;
+ return 0;
+ }
+ return -1;
+}
+
+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 */
int ret = Helios_Audio_FilePlayStop();
return mp_obj_new_int(ret);
}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_play_file_stop_obj, helios_play_file_stop);
+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;
montage_is_break = 1;
#if defined (PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05)
audio_err_handle();
audio.total_nums = 0;
//audio.audio_state = AUDIO_IDLE;
Helios_Mutex_Unlock(audio.queue_mutex);
-
- int ret = Helios_Audio_FilePlayStop();
+ 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();
+ }
return mp_obj_new_int(ret);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_play_file_stop_all_obj, helios_play_file_stop_all);
/*=============================================================================*/
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 };
+ 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)
- if(format != HELIOS_AUDIO_FORMAT_PCM && format != HELIOS_AUDIO_FORMAT_WAVPCM && format != HELIOS_AUDIO_FORMAT_MP3 && format != HELIOS_AUDIO_FORMAT_AMRNB
- && format != HELIOS_AUDIO_FORMAT_AMRWB && format != HELIOS_AUDIO_FORMAT_AAC && format != HELIOS_AUDIO_FORMAT_M4A && format != HELIOS_AUDIO_FORMAT_TS)
+ 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)
mp_raise_ValueError(MP_ERROR_TEXT("invalid audio_buff data"));
}
}
-#if defined (PLAT_ASR) || defined(PLAT_ASR_1606) || defined (PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05)
- #if CONFIG_AUDIO_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)
Helios_mp3_stream_close_flag(vals[ARG_mode].u_int);
- #endif
#endif
MP_THREAD_GIL_EXIT();
- int ret = Helios_Audio_StreamPlayStart(format, buff_a.buf, buff_a.len, HELIOS_AUDIO_PLAY_TYPE_LOCAL, self->device, audio_play_callback);
+ 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_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 */
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_Unisoc_8910_R05)
+#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)
#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} },
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 = {
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();
+ aud_tone_flag = 1;
ret = Helios_Audio_Play_Tone(tone, (uint32_t)time);
MP_THREAD_GIL_ENTER();
if(ret != 0)
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_KW(mp_helios_aud_tone_play_obj, 1, helios_aud_tone_play);
Helios_Audio_Stop_Tone();
#ifdef AUDIO_DTMF_TONE_NEW_SUPPORT
Helios_Audio_Stop_DTMF();
+
#endif
- if(aud_tone_timer != 0)
+ if(aud_tone_timer != 0) {
ret = Helios_OSTimer_Stop(aud_tone_timer);
+ }
return mp_obj_new_int(ret);
}
//================================montage Handel start=====================================================
-#if defined (PLAT_Unisoc) || defined (PLAT_ASR) || defined(PLAT_ASR_1606) || defined(PLAT_EIGEN) || defined(PLAT_Unisoc_8910_R05)
+#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)
#include "helios_os.h"
montage_index = __check_is_preprocessed(montage_name);
if (montage_index != -1)
{
- HELIOS_AUDIO_LOG("%s has been pretreated\n", montage_name);
return montage_index;
}
{
return NULL;
}
- HELIOS_AUDIO_LOG("__getElemByName montage index = %d\n", montage_index);
elem = (montage_elem *)(all_montage[montage_index].file_info_buf);
sprintf(actual_name, file_name + 3, strlen(file_name) - 3);
uint32_t i = 0;
for (i = 0; i < all_montage[montage_index].file_num; i++)
{
- HELIOS_AUDIO_LOG("actual_name:%s, elem:%s, offset %d, size=%d\n", actual_name, elem->file_name, elem->offset, elem->size);
if (0 == strncmp(file_name, elem->file_name, strlen(actual_name)+3))
{
- HELIOS_AUDIO_LOG("elem addr : 0x%x\n", elem);
return elem;
}
elem++;
uint32_t cur_count_offset = 0;
uint32_t cur_count_size = 0;
- HELIOS_AUDIO_LOG("files = %s\n", files);
-
if (strncmp(files, "mp3files=", 9) == 0)
{
// file_type = 1;
/* parse files info */
p = strtok(files_tmp + 9, "+");
- HELIOS_AUDIO_LOG("path_dir = %s\n", p);
if (p != NULL)
{
HELIOS_AUDIO_LOG("p = %s\n", p);
elem = __getElemByName(montage_file, p);
if (elem != NULL)
{
- HELIOS_AUDIO_LOG("XXX elem:%s, offset %d, size=%d\n", elem->file_name, elem->offset, elem->size);
+ //HELIOS_AUDIO_LOG("XXX elem:%s, offset %d, size=%d\n", elem->file_name, elem->offset, elem->size);
item = calloc(1, sizeof(struct mp3_file_list));
sprintf(item->file_name, "%s", p);
item->elem = elem;
if (montage_play_queue)
{
- return Helios_MsgQ_Put(montage_play_queue, (const void *)&play_elem, sizeof(montage_play_elem), HELIOS_NO_WAIT);
+ return Helios_MsgQ_Put(montage_play_queue, (const void *)&play_elem, sizeof(montage_play_elem), HELIOS_NO_WAIT);
}
return 0;
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);
}
//================================montage Handel end=====================================================
-#if defined (PLAT_ASR) || defined(PLAT_ASR_1606)
+#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)
{
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_play_file_stop_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) },
#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_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_Unisoc_8850) || defined(PLAT_EIGEN) || defined(PLAT_Unisoc_8910_R05)
+#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)
#if !CONFIG_AUDIO_PWM
#if !defined(PLAT_EIGEN)
{ MP_ROM_QSTR(MP_QSTR_set_channel), MP_ROM_PTR(&helios_set_channel_obj) },
{ 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_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_Unisoc_8910_R05)
+#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)
{ 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 (PLAT_ASR) || defined(PLAT_ASR_1606)
+#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_EIGEN) || defined(PLAT_Unisoc_8910_R05)
+#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)
{ MP_ROM_QSTR(MP_QSTR_montage_play), MP_ROM_PTR(&helios_play_montage_file_start_obj) },
#endif
#if CONFIG_AUDIO
#if defined (PLAT_Unisoc) || defined (PLAT_EIGEN) || defined(PLAT_Unisoc_8910_R05)
{ MP_ROM_QSTR(MP_QSTR_setGainTabel), MP_ROM_PTR(&helios_setgaintabel_obj) },
#endif
-#if defined (PLAT_ASR) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1803s)
+#if defined (PLAT_ASR) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) || defined(PLAT_ASR_1803s) || defined(PLAT_ASR_1602)
{ MP_ROM_QSTR(MP_QSTR_PCM), MP_ROM_PTR(&audio_audio_pcm) },
#endif
};
.locals_dict = (mp_obj_dict_t *)&audio_locals_dict,
};
-#if defined (PLAT_ASR) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1803s)
+#if defined (PLAT_ASR) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) || defined(PLAT_ASR_1803s) || defined(PLAT_ASR_1602)
#define QL_PCM_BLOCK_FLAG (0x01)
#define QL_PCM_NONBLOCK_FLAG (0x02)
AUDIO_T audio = {0};
extern int audio_play_callback(char *ptr, size_t lens, Helios_EnumAudPlayerState state);
-
+extern char audio_playing_file_name[256];
/*=============================================================================*/
/* FUNCTION: audio_queue_init */
} while (0);
-#if defined (PLAT_Unisoc) || defined (PLAT_ASR) || defined(PLAT_ASR_1606) || defined(PLAT_EIGEN) || defined(PLAT_Unisoc_8910_R05)
+#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)
extern int Helios_Audio_MontageFilePlayStart(char *montage_name, char *file_name, Helios_AudPlayerType type, helios_cb_on_player usr_cb, uint8_t device);
#endif
void helios_audio_play_queue(void)
#if MICROPY_QPY_AUDIO_TTS
if (audio_type == AUDIO_TTS)
{
- #if defined (PLAT_ASR) || defined (PLAT_Unisoc) || defined (PLAT_ASR_1606) || defined (PLAT_Unisoc_8850) || defined(PLAT_Unisoc_8910_R05)
+ #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)
extern void Helios_Set_MP_TTS_Callback(c_callback_t* callback);
Helios_Set_MP_TTS_Callback(&audio.audio_queue[i].audio_data[front].mp_cb);
ret = Helios_TTS_Start(mode, data, strlen(data));
+ if(ret != -1)
+ {
+ memcpy(audio_playing_file_name, data, strlen(data));
+ }
+
#endif
}
else
if (audio_type == AUDIO_FILE)
{
ret = Helios_Audio_FilePlayStart(data, HELIOS_AUDIO_PLAY_TYPE_LOCAL, audio_play_callback);
+ if(ret != -1)
+ {
+ memcpy(audio_playing_file_name, data, strlen(data));
+ }
HELIOS_AUDIO_QUEUE_LOG("Helios_Audio_FilePlayStart, ret = %d\r\n", ret);
}
- #if defined (PLAT_Unisoc) || defined (PLAT_ASR) || defined(PLAT_ASR_1606) || defined(PLAT_EIGEN) || defined(PLAT_Unisoc_8910_R05)
+ #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)
else if (audio_type == AUDIO_MONTAGE)
{
ret = Helios_Audio_MontageFilePlayStart(mondata, data, HELIOS_AUDIO_PLAY_TYPE_LOCAL, audio_play_callback, device);
+ if(ret != -1)
+ {
+ memcpy(audio_playing_file_name, mondata, strlen(mondata));
+ }
HELIOS_AUDIO_QUEUE_LOG("Helios_Audio_MontageFilePlayStart, ret = %d\r\n", ret);
}
#endif
break;
case AUDIO_FINISH_EVENT:
HELIOS_AUDIO_QUEUE_LOG("----AUDIO_FINISH_EVENT---\r\n");
+ memset(audio_playing_file_name, 0, sizeof(audio_playing_file_name));
#if !defined (PLAT_Unisoc) && !defined(PLAT_EIGEN) && !defined(PLAT_Unisoc_8850) || defined(PLAT_Unisoc_8910_R05)
+ #ifndef CONFIG_AUDIO
Helios_Audio_StreamPlayStop();
#endif
+ #endif
//HELIOS_AUDIO_QUEUE_LOG("start queue paly...\r\n");
helios_audio_play_queue();
break;
AUDIO_TTS = 1,
AUDIO_FILE,
AUDIO_MONTAGE,
+ AUDIO_STREAM,
}AUDIO_TYPE_E;
typedef enum
static c_callback_t *callback_cur;
//extern int device;
-#if defined(PLAT_ASR) || defined(PLAT_Unisoc) || defined(PLAT_ASR_1606) || defined(PLAT_Unisoc_8850) || defined(PLAT_Unisoc_8910_R05)
+#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)
#define GET_FILE_VFS_PATH(x, y) get_vfs_path(x,y)
#else
#define GET_FILE_VFS_PATH(x, y) \
self->device = mp_obj_get_int(args[0]);
if ((self->device < HELIOS_OUTPUT_RECEIVER) || (self->device > HELIOS_OUTPUT_SPEAKER))
{
- mp_raise_ValueError("invalid device index, the value of device should be in[0,2]");
+ mp_raise_ValueError(MP_ERROR_TEXT("invalid device index, the value of device should be in[0,2]"));
}
if (!audio_channel_check(self->device))
{
- mp_raise_msg_varg(&mp_type_ValueError, "The current platform does not support device %d.", self->device);
+ mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("The current platform does not support device %d."), self->device);
+
}
}
audio_record_printf("create record obj, n_args = %d, device = %d\r\n", n_args, self->device);
if(strncmp(st_old, "wav", 3)==0){
return FORMAT_WAV;
- }/* else if(strncmp(st_old, "mp3", 3)==0) {
+ } else if(strncmp(st_old, "mp3", 3)==0) {
return FORMAT_MP3;
- }*/ else if(strncmp(st_old, "amr", 3)==0) {
+ } else if(strncmp(st_old, "amr", 3)==0) {
return FORMAT_AMR;
} else {
return -3;
audio_record_obj_t *self = MP_OBJ_TO_PTR(p_args[0]);
if(self->isbusy == 1 || record_state == 1) {
- mp_raise_ValueError("record is busy\n");
+ mp_raise_ValueError(MP_ERROR_TEXT("record is busy\n"));
return mp_obj_new_int(-1);
}
callback_cur = self->callback;
- if((format != HELIOS_AUDIO_FORMAT_AMRNB && format != HELIOS_AUDIO_FORMAT_AMRWB) || !(samplerate == 8000 || samplerate == 16000)) {
- mp_raise_ValueError("Parameter error\n");
+ if(format != HELIOS_AUDIO_FORMAT_AMRNB && format != HELIOS_AUDIO_FORMAT_AMRWB && format != HELIOS_AUDIO_FORMAT_MP3) {
+ mp_raise_ValueError(MP_ERROR_TEXT("Parameter error\n"));
return mp_obj_new_int(-1);
}
//check time is valid
if(time < 0) {
- mp_raise_ValueError("Record time must be larger than or equal to 0.\n");
+ mp_raise_ValueError(MP_ERROR_TEXT("Record time must be larger than or equal to 0.\n"));
return mp_obj_new_int(-1);
}
record_info.cb = (void *)helios_file_record_cb;
ret = Helios_Audio_FileRecordStart(self->file_name, &record_info);
}
+ else if(format==FORMAT_MP3){
+ record_conf.samplerate = 22050;
+ Helios_AUDRecordInitStruct record_info;
+ record_info.record_para = &record_conf;
+ record_info.format = HELIOS_AUDIO_FORMAT_MP3;
+ record_info.type = HELIOS_REC_TYPE_MIC;
+ record_info.cb = (void *)helios_file_record_cb;
+ ret = Helios_Audio_FileRecordStart(self->file_name, &record_info);
+ }
else{
self->isbusy = 0;
record_state = 0;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(mp_helios_record_file_end_callback_obj, helios_set_record_callback);
+#if defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609)
+STATIC mp_obj_t helios_audio_record_gain_set(size_t n_args, const mp_obj_t *args)
+{
+ //audio_record_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+ int codec_gain = mp_obj_get_int(args[1]);
+ int dsp_gain = mp_obj_get_int(args[2]);
+
+ if (!(codec_gain >= 0 && codec_gain <= 4)) {
+ mp_raise_ValueError(MP_ERROR_TEXT("invalid codec_gain value, must be in [0,4]"));
+ }
+ if (!(dsp_gain >= -36 && dsp_gain <= 12)) {
+ mp_raise_ValueError(MP_ERROR_TEXT("invalid dsp_gain value, must be in [-36,12]"));
+ }
+ audio_record_printf("codec_gain = %d, dsp_gain = %d\n",codec_gain, dsp_gain);
+ Helios_Audio_GainSet(codec_gain, dsp_gain);
+
+ return mp_obj_new_int(0);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_helios_audio_record_gain_set_obj, 3, 3, helios_audio_record_gain_set);
+
+STATIC mp_obj_t helios_audio_record_gain_get(mp_obj_t self_in)
+{
+ short int codec_gain = 0;
+ char dsp_gain = 0;
+
+ Helios_Audio_GainGet(&codec_gain, &dsp_gain);
+ audio_record_printf("dsp_gain = %d\n", dsp_gain);
+ mp_obj_t gain_list[2] = {
+ mp_obj_new_int(codec_gain),
+ mp_obj_new_int((signed char)dsp_gain)
+ };
+ return mp_obj_new_list(2, gain_list);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_helios_audio_record_gain_get_obj, helios_audio_record_gain_get);
+#endif
+#ifdef PLAT_ASR
STATIC mp_obj_t helios_audio_record_gain(size_t n_args, const mp_obj_t *args)
{
//audio_record_obj_t *self = MP_OBJ_TO_PTR(args[0]);
return mp_obj_new_int(0);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_helios_record_file_gain_obj,3,3, helios_audio_record_gain);
-#ifdef PLAT_ASR
+
/*=============================================================================*/
/* FUNCTION: helios_amrenc_dtx_enable */
/*=============================================================================*/
return 0;
}
+#if MICROPY_QPY_AUDIO_AUDIO
STATIC mp_obj_t helios_audio_record_play(mp_obj_t self_in,mp_obj_t path, mp_obj_t audio_path)
{
return mp_obj_new_int(0);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_3(mp_helios_record_file_play_obj, helios_audio_record_play);
-
+#endif
STATIC mp_obj_t helios_audio_deinit(mp_obj_t self_in)
{
int ret = 0;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_helios_record_deinit_obj, helios_audio_deinit);
+#if CONFIG_AUDIO_RECORD_MP3
+STATIC mp_obj_t helios_set_mp3_record_bitr(mp_obj_t self_in, mp_obj_t bitr)
+{
+ int bitr_value = mp_obj_get_int(bitr);
+ extern void Helios_mp3Record_set_bitr(int val);
+ Helios_mp3Record_set_bitr(bitr_value);
+ return mp_obj_new_int(0);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(mp_helios_record_mp3_setBitr_obj, helios_set_mp3_record_bitr);
+#endif
STATIC const mp_rom_map_elem_t audio_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&mp_helios_record_deinit_obj) },
{ MP_ROM_QSTR(MP_QSTR_start), MP_ROM_PTR(&mp_helios_record_file_start_obj) },
+#if CONFIG_AUDIO_RECORD_MP3
+ { MP_ROM_QSTR(MP_QSTR_set_bitr), MP_ROM_PTR(&mp_helios_record_mp3_setBitr_obj) },
+#endif
{ MP_ROM_QSTR(MP_QSTR_stream_start), MP_ROM_PTR(&mp_helios_record_stream_start_obj) },
{ MP_ROM_QSTR(MP_QSTR_stream_read), MP_ROM_PTR(&mp_helios_record_stream_read_obj) },
{ MP_ROM_QSTR(MP_QSTR_stream_stop), MP_ROM_PTR(&mp_helios_record_stream_stop_obj) },
{ MP_ROM_QSTR(MP_QSTR_exists), MP_ROM_PTR(&mp_helios_record_file_exists_obj) },
{ MP_ROM_QSTR(MP_QSTR_isBusy), MP_ROM_PTR(&mp_helios_record_file_isBusy_obj) },
{ MP_ROM_QSTR(MP_QSTR_end_callback), MP_ROM_PTR(&mp_helios_record_file_end_callback_obj) },
- { MP_ROM_QSTR(MP_QSTR_gain), MP_ROM_PTR(&mp_helios_record_file_gain_obj) },
#ifdef PLAT_ASR
- //{ MP_ROM_QSTR(MP_QSTR_gain), MP_ROM_PTR(&mp_helios_record_file_gain_obj) },
+ { MP_ROM_QSTR(MP_QSTR_gain), MP_ROM_PTR(&mp_helios_record_file_gain_obj) },
{ MP_ROM_QSTR(MP_QSTR_WAV), MP_ROM_INT(HELIOS_AUDIO_FORMAT_WAVPCM) },
{ MP_ROM_QSTR(MP_QSTR_AMRNB), MP_ROM_INT(HELIOS_AUDIO_FORMAT_AMRNB) },
{ MP_ROM_QSTR(MP_QSTR_AMRWB), MP_ROM_INT(HELIOS_AUDIO_FORMAT_AMRWB) },
{ MP_ROM_QSTR(MP_QSTR_amrEncDtx_enable), MP_ROM_PTR(&helios_amrenc_dtx_enable_obj) },
#endif
+#if MICROPY_QPY_AUDIO_AUDIO
{ MP_ROM_QSTR(MP_QSTR_play), MP_ROM_PTR(&mp_helios_record_file_play_obj) },
+#endif
#if defined(PLAT_Unisoc) || defined(PLAT_Unisoc_8850) || defined(PLAT_Unisoc_8910_R05)
{ MP_ROM_QSTR(MP_QSTR_PCM), MP_ROM_INT(HELIOS_AUDIO_FORMAT_PCM) },
{ MP_ROM_QSTR(MP_QSTR_WAV), MP_ROM_INT(HELIOS_AUDIO_FORMAT_WAVPCM) },
{ MP_ROM_QSTR(MP_QSTR_AMRNB), MP_ROM_INT(HELIOS_AUDIO_FORMAT_AMRNB) },
{ MP_ROM_QSTR(MP_QSTR_AMRWB), MP_ROM_INT(HELIOS_AUDIO_FORMAT_AMRWB) },
#endif
+#if defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609)
+ { MP_ROM_QSTR(MP_QSTR_gain_set), MP_ROM_PTR(&mp_helios_audio_record_gain_set_obj) },
+ { MP_ROM_QSTR(MP_QSTR_gain_get), MP_ROM_PTR(&mp_helios_audio_record_gain_get_obj) },
+ { MP_ROM_QSTR(MP_QSTR_WAV), MP_ROM_INT(HELIOS_AUDIO_FORMAT_WAVPCM) },
+ { MP_ROM_QSTR(MP_QSTR_AMRNB), MP_ROM_INT(HELIOS_AUDIO_FORMAT_AMRNB) },
+ { MP_ROM_QSTR(MP_QSTR_AMRWB), MP_ROM_INT(HELIOS_AUDIO_FORMAT_AMRWB) },
+#endif
};
STATIC MP_DEFINE_CONST_DICT(record_locals_dict, audio_locals_dict_table);
};
const mp_obj_type_t audio_tts_type;
+extern char audio_playing_file_name[256];
+
typedef struct _audio_tts_obj_t {
mp_obj_base_t base;
int device = mp_obj_get_int(args[0]);
if (device < 0 || device > 2) {
- mp_raise_ValueError("invalid device index, the value of device should be in[0,2]");
+ mp_raise_ValueError(MP_ERROR_TEXT("invalid device index, the value of device should be in[0,2]"));
}
if (!audio_channel_check(device))
{
- mp_raise_msg_varg(&mp_type_ValueError, "The current platform does not support device %d.", device);
+ mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("The current platform does not support device %d."), device);
}
Helios_Audio_SetAudioChannle(device);
if (!audio.queue_msg)
{
Helios_Mutex_Delete(audio.queue_mutex);
- mp_raise_ValueError("create audio object failed, can not create msgQ.");
+ mp_raise_ValueError(MP_ERROR_TEXT("create audio object failed, can not create msgQ."));
}
Helios_ThreadAttr attr = {0};
{
Helios_MsgQ_Delete(audio.queue_msg);
Helios_Mutex_Delete(audio.queue_mutex);
- mp_raise_ValueError("create audio object failed, can not create queue play task.");
+ mp_raise_ValueError(MP_ERROR_TEXT("create audio object failed, can not create queue play task."));
}
}
}
else
{
- mp_raise_ValueError("TTS Init failed.");
+ mp_raise_ValueError(MP_ERROR_TEXT("TTS Init failed."));
}
Helios_TTS_SetSpeed(self->tts_speed);
if ((new_mode < 1) || (new_mode > 3))
{
HELIOS_TTS_LOG("new_mode is %d\n",new_mode);
- mp_raise_ValueError("invalid mode");
+ mp_raise_ValueError(MP_ERROR_TEXT("invalid mode"));
return mp_obj_new_int(-1);
}
int new_priority = vals[ARG_priority].u_int;
int new_breakin = vals[ARG_breakin].u_int;
if (new_priority < 0 || new_priority > 4) {
- mp_raise_ValueError("invalid priority value, must be in [0,4]");
+ mp_raise_ValueError(MP_ERROR_TEXT("invalid priority value, must be in [0,4]"));
}
if (new_breakin != 0 && new_breakin != 1) {
- mp_raise_ValueError("invalid breakin value, must be in [0,1]");
+ mp_raise_ValueError(MP_ERROR_TEXT("invalid breakin value, must be in [0,1]"));
}
mp_obj_t new_mp_cb = vals[ARG_cb].u_obj;
if(bufinfo.len > MAX_TTS_TEXT_LEN) {
- mp_raise_msg_varg(&mp_type_ValueError, "The string length cannot be greater than %d", MAX_TTS_TEXT_LEN);
+ mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("The string length cannot be greater than %d"), MAX_TTS_TEXT_LEN);
}
Helios_Mutex_Lock(audio.queue_mutex, HELIOS_WAIT_FOREVER);
Helios_Audio_FilePlayStop();
break;
}
+ case AUDIO_MONTAGE:
+ {
+ Helios_Mutex_Lock(audio.montage_mutex, HELIOS_WAIT_FOREVER);
+ HELIOS_TTS_LOG("---- stop audio montage play. ----\r\n");
+ extern int helios_set_montage_break_flag(char set);
+ helios_set_montage_break_flag(1);
+ audio.montage_is_stopping = 1;
+#if CONFIG_AUDIO
+ extern void helios_audio_montage_stop();
+ helios_audio_montage_stop();
+#endif
+ #if !defined(PLAT_EIGEN)
+ extern int audio_err_handle(void);
+ 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_TTS_LOG("send audio msg failed[%u].\r\n", audio_msg);
+ return mp_obj_new_int(-1);
+ }
+ break;
+ }
default:
{
HELIOS_TTS_LOG("Unknown audio type.\r\n");
Helios_Set_MP_TTS_Callback(&mp_cb);
int ret = Helios_TTS_Start(new_mode, bufinfo.buf, bufinfo.len);
+ if(ret != -1)
+ {
+ memcpy(audio_playing_file_name, bufinfo.buf, bufinfo.len);
+ }
+
MP_THREAD_GIL_ENTER();
if (ret == -1)
{
int index = mp_obj_get_int(volume);
if ((index > 9) || (index < 0))
{
- mp_raise_ValueError("invalid value,TTS volume should be array between [0,9]");
+ mp_raise_ValueError(MP_ERROR_TEXT("invalid value,TTS volume should be array between [0,9]"));
return mp_obj_new_int(-1);
}
STATIC mp_obj_t machine_lcd_init(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args)
{
+ //is_first_make_new = 1;
machine_lcd_init_helper(args[0], n_args - 1, args + 1, kw_args);
return mp_obj_new_int(0);
}
float x,y,z;
bool SC7A20_INT_STATUS = true;
unsigned int SC7A20_STATUS_COUNT = 3;
+//#include "lvgl.h"
unsigned int SL_SC7A20_PEDO_KCAL_WRIST_SLEEP_SWAY_L_ALGO(void)
{
#if SL_Sensor_Algo_Release_Enable==0x00
unsigned char sl_i;
#endif
+ //custom_log("lvgl:LV_DPI_DEF:%d",LV_DPI_DEF);
signed short SC7A20_XYZ_Buf[3][32];
unsigned char SC7A20_FIFO_NUM;
projects / mirrors / ASR1603_G5.git / commitdiff