#include "asm/includes.h" #include "media/includes.h" #include "system/includes.h" #include "classic/tws_api.h" #include "classic/hci_lmp.h" #include "effectrs_sync.h" #include "audio_syncts.h" #include "application/eq_config.h" #include "application/audio_energy_detect.h" #include "application/audio_surround.h" #include "app_config.h" #include "audio_config.h" #include "aec_user.h" #include "audio_enc.h" #include "app_main.h" #include "btstack/avctp_user.h" #include "btstack/a2dp_media_codec.h" #include "tone_player.h" /* #include "audio_demo/audio_demo.h" */ #include "media/audio_vbass.h" #include "audio_plc.h" #include "audio_dec_eff.h" #include "audio_codec_clock.h" #if TCFG_AUDIO_HEARING_AID_ENABLE #include "audio_hearing_aid.h" #endif/*TCFG_AUDIO_HEARING_AID_ENABLE*/ #if TCFG_USER_TWS_ENABLE #include "bt_tws.h" #endif/*TCFG_USER_TWS_ENABLE*/ #if (SYS_VOL_TYPE == VOL_TYPE_DIGITAL) #include "audio_dvol.h" #endif/*SYS_VOL_TYPE == VOL_TYPE_DIGITAL*/ #if TCFG_APP_FM_EMITTER_EN #include "fm_emitter/fm_emitter_manage.h" #endif/*TCFG_APP_FM_EMITTER_EN*/ #if TCFG_AUDIO_ANC_ENABLE #include "audio_anc.h" #endif/*TCFG_AUDIO_ANC_ENABLE*/ #if (defined(TCFG_PHONE_MESSAGE_ENABLE) && (TCFG_PHONE_MESSAGE_ENABLE)) #include "phone_message/phone_message.h" #endif/*TCFG_PHONE_MESSAGE_ENABLE*/ #if TCFG_SMART_VOICE_ENABLE #include "smart_voice/smart_voice.h" #include "media/jl_kws.h" #if TCFG_CALL_KWS_SWITCH_ENABLE #include "btstack/avctp_user.h" #endif #endif #include "media/audio_gain_process.h" #ifdef SUPPORT_MS_EXTENSIONS /* #pragma bss_seg(".audio_decoder_bss") */ /* #pragma data_seg(".audio_decoder_data") */ #pragma const_seg(".audio_decoder_const") #pragma code_seg(".audio_decoder_code") #endif/*SUPPORT_MS_EXTENSIONS*/ #include "sound_device.h" #if TCFG_ESCO_DL_NS_ENABLE #include "audio_ns.h" #define DL_NS_MODE 0 #define DL_NS_NOISELEVEL 100.0f #define DL_NS_AGGRESSFACTOR 1.0f #define DL_NS_MINSUPPRESS 0.09f #endif/*TCFG_ESCO_DL_NS_ENABLE*/ #if TCFG_AUDIO_ESCO_DL_NOISEGATE_ENABLE #include "audio_NoiseGate.h" static u8 *esco_dl_noisegate_buf = NULL; #endif/*TCFG_AUDIO_ESCO_DL_NOISEGATE_ENABLE*/ #if ((defined TCFG_DIAFX_ENABLE) && TCFG_DIAFX_ENABLE) #include "diafx.h" #endif #if (TCFG_AUDIO_OUTPUT_IIS) #include "audio_iis.h" #endif #if TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN #include "icsd_adt_app.h" #endif /*TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN*/ #define AUDIO_CODEC_SUPPORT_SYNC 1 #define ESCO_DRC_EN 0 //通话下行增加限幅器处理，默认关闭,need en TCFG_DRC_ENABLE #if (!TCFG_DRC_ENABLE || !TCFG_PHONE_EQ_ENABLE) #undef ESCO_DRC_EN 0 #define ESCO_DRC_EN 0 #endif #if TCFG_AUDIO_ANC_ENABLE && TCFG_DRC_ENABLE #define MIX_OUT_DRC_EN 0/*mixout后增加一级限幅处理,默认关闭,need en TCFG_DRC_ENABLE*/ #else #define MIX_OUT_DRC_EN 0/*mixout后增加一级限幅处理,默认关闭,need en TCFG_DRC_ENABLE*/ #endif/*TCFG_AUDIO_ANC_ENABLE && TCFG_DRC_ENABLE*/ #if AUDIO_OUT_EFFECT_ENABLE int audio_out_effect_open(void *priv, u16 sample_rate); void audio_out_effect_close(void); int audio_out_effect_stream_clear(); struct dec_eq_drc *audio_out_effect = NULL; #endif /*AUDIO_OUT_EFFECT_ENABLE*/ static u8 audio_out_effect_dis = 0; static u8 mix_out_remain = 0; struct tone_dec_hdl { struct audio_decoder decoder; void (*handler)(void *, int argc, int *argv); void *priv; }; #if AUDIO_SURROUND_CONFIG static u8 a2dp_surround_eff; //音效模式记录 void a2dp_surround_set(u8 eff) { a2dp_surround_eff = eff; } #endif struct esco_dec_hdl { struct audio_decoder decoder; struct audio_res_wait wait; struct audio_mixer_ch mix_ch; u32 coding_type; u8 *frame; u8 frame_len; u8 offset; u8 data_len; u8 tws_mute_en; u8 start; u8 enc_start; u8 frame_time; u8 preempt; u8 channels; u8 ul_stream_open; u16 slience_frames; u16 sample_rate; void *syncts; #if AUDIO_CODEC_SUPPORT_SYNC void *ts_handle; u8 ts_start; u8 sync_step; #endif u32 mix_ch_event_params[3]; u8 esco_len; u16 remain; int data[15];/*ALIGNED(4)*/ #if TCFG_EQ_ENABLE&&TCFG_PHONE_EQ_ENABLE struct dec_eq_drc *eq_drc; #endif//TCFG_PHONE_EQ_ENABLE #if TCFG_ESCO_DL_NS_ENABLE void *dl_ns; s16 dl_ns_out[NS_OUT_POINTS_MAX]; u16 dl_ns_offset; u16 dl_ns_remain; #endif/*TCFG_ESCO_DL_NS_ENABLE*/ #if TCFG_AUDIO_ESCO_LIMITER_ENABLE struct audio_drc *limiter; #endif u32 hash; s16 fade_trigger; s16 fade_volume; s16 fade_step; #if TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN u8 icsd_adt_state; #endif }; #if AUDIO_OUTPUT_AUTOMUTE void *mix_out_automute_hdl = NULL; extern void mix_out_automute_open(); extern void mix_out_automute_close(); #endif //#if AUDIO_OUTPUT_AUTOMUTE #define AUDIO_DAC_DELAY_TIME 30 #define DIGITAL_OdB_VOLUME 16384 #if (TCFG_AUDIO_DAC_CONNECT_MODE == DAC_OUTPUT_LR)||(TCFG_AUDIO_DAC_CONNECT_MODE == DAC_OUTPUT_MONO_LR_DIFF) #define MIX_POINTS_NUM 256 #else #define MIX_POINTS_NUM 256 #endif s16 mix_buff[MIX_POINTS_NUM]; /* #define MAX_SRC_NUMBER 3 */ /* s16 audio_src_hw_filt[24 * 2 * MAX_SRC_NUMBER]; */ static u16 dac_idle_delay_max = 10000; static u16 dac_idle_delay_cnt = 10000; static struct tone_dec_hdl *tone_dec = NULL; struct audio_decoder_task decode_task; extern struct audio_dac_hdl dac_hdl; struct audio_mixer mixer; extern struct dac_platform_data dac_data; extern struct audio_adc_hdl adc_hdl; struct esco_dec_hdl *esco_dec = NULL; int lmp_private_get_esco_remain_buffer_size(); int lmp_private_get_esco_data_len(); void *lmp_private_get_esco_packet(int *len, u32 *hash); void lmp_private_free_esco_packet(void *packet); extern int lmp_private_esco_suspend_resume(int flag); extern void user_sat16(s32 *in, s16 *out, u32 npoint); void *esco_play_sync_open(u8 channel, u16 sample_rate, u16 output_rate); //void audio_adc_init(void); void *audio_adc_open(void *param, const char *source); int audio_adc_sample_start(void *adc); void set_source_sample_rate(u32 sample_rate); u8 bt_audio_is_running(void); void audio_resume_all_decoder(void) { audio_decoder_resume_all(&decode_task); } void audio_src_isr_deal(void) { audio_resume_all_decoder(); } __attribute__((weak)) u8 get_sniff_out_status() { return 0; } __attribute__((weak)) void clear_sniff_out_status() { } u8 is_dac_power_off() { #if 1 return 1; #else //开机播完提示音再初始化蓝牙 if (a2dp_dec || esco_dec || get_call_status() != BT_CALL_HANGUP || !tone_get_status()) { return 1; } return 0; #endif } #include "a2dp_dec.c" //这里将A2DP解码代码分解到另外文件 #define AUDIO_DECODE_TASK_WAKEUP_TIME 4 //ms #if AUDIO_DECODE_TASK_WAKEUP_TIME #include "timer.h" static void audio_decoder_wakeup_timer(void *priv) { //putchar('k'); audio_decoder_resume_all(&decode_task); } int audio_decoder_task_add_probe(struct audio_decoder_task *task) { local_irq_disable(); if (task->wakeup_timer == 0) { task->wakeup_timer = usr_timer_add(NULL, audio_decoder_wakeup_timer, AUDIO_DECODE_TASK_WAKEUP_TIME, 1); log_i("audio_decoder_task_add_probe:%d\n", task->wakeup_timer); } local_irq_enable(); return 0; } int audio_decoder_task_del_probe(struct audio_decoder_task *task) { log_i("audio_decoder_task_del_probe\n"); if (audio_decoder_task_wait_state(task) > 0) { /*解码任务列表还有任务*/ return 0; } local_irq_disable(); if (task->wakeup_timer) { log_i("audio_decoder_task_del_probe:%d\n", task->wakeup_timer); usr_timer_del(task->wakeup_timer); task->wakeup_timer = 0; } local_irq_enable(); return 0; } int audio_decoder_wakeup_modify(int msecs) { if (decode_task.wakeup_timer) { usr_timer_modify(decode_task.wakeup_timer, msecs); } return 0; } /* * DA输出源启动后可使用DAC irq做唤醒，省去hi_timer */ int audio_decoder_wakeup_select(u8 source) { if (source == 0) { /*唤醒源为hi_timer*/ local_irq_disable(); if (!decode_task.wakeup_timer) { decode_task.wakeup_timer = usr_timer_add(NULL, audio_decoder_wakeup_timer, AUDIO_DECODE_TASK_WAKEUP_TIME, 1); } local_irq_enable(); } else if (source == 1) { /*唤醒源为输出目标中断*/ if (!sound_pcm_dev_is_running()) { return audio_decoder_wakeup_select(0); } int err = sound_pcm_trigger_resume(a2dp_low_latency ? 2 : AUDIO_DECODE_TASK_WAKEUP_TIME, NULL, audio_decoder_wakeup_timer); if (err) { return audio_decoder_wakeup_select(0); } local_irq_disable(); if (decode_task.wakeup_timer) { usr_timer_del(decode_task.wakeup_timer); decode_task.wakeup_timer = 0; } local_irq_enable(); } return 0; } #endif/*AUDIO_DECODE_TASK_WAKEUP_TIME*/ static u8 bt_dec_idle_query() { if (a2dp_dec || esco_dec) { return 0; } return 1; } REGISTER_LP_TARGET(bt_dec_lp_target) = { .name = "bt_dec", .is_idle = bt_dec_idle_query, }; ___interrupt static void audio_irq_handler() { if (JL_AUDIO->DAC_CON & BIT(7)) { JL_AUDIO->DAC_CON |= BIT(6); if (JL_AUDIO->DAC_CON & BIT(5)) { audio_decoder_resume_all(&decode_task); audio_dac_irq_handler(&dac_hdl); } } if (JL_AUDIO->ADC_CON & BIT(7)) { JL_AUDIO->ADC_CON |= BIT(6); if ((JL_AUDIO->ADC_CON & BIT(5)) && (JL_AUDIO->ADC_CON & BIT(4))) { audio_adc_irq_handler(&adc_hdl); } } } #if AUDIO_OUTPUT_AUTOMUTE void audio_mix_out_automute_mute(u8 mute) { printf(">>>>>>>>>>>>>>>>>>>> %s\n", mute ? ("MUTE") : ("UNMUTE")); } /* #define AUDIO_E_DET_UNMUTE (0x00) */ /* #define AUDIO_E_DET_MUTE (0x01) */ void mix_out_automute_handler(u8 event, u8 ch) { printf(">>>> ch:%d %s\n", ch, event ? ("MUTE") : ("UNMUTE")); #if (TCFG_AUDIO_HEARING_AID_ENABLE && TCFG_AUDIO_DHA_AND_MUSIC_MUTEX) if (ch == sound_pcm_dev_channel_mapping(ch)) { printf("[DHA]>>>>>>>>>>>>>>>>>>>> %s\n", event ? ("MUTE") : ("UNMUTE")); if (a2dp_dec) { if (event) { audio_hearing_aid_resume(); } else { audio_hearing_aid_suspend(); } } } #else sound_pcm_dev_channel_mute(BIT(ch), event); if (ch == sound_pcm_dev_channel_mapping(ch)) { audio_mix_out_automute_mute(event); } #endif/*TCFG_AUDIO_HEARING_AID_ENABLE*/ } void mix_out_automute_skip(u8 skip) { u8 mute = !skip; if (mix_out_automute_hdl) { audio_energy_detect_skip(mix_out_automute_hdl, 0xFFFF, skip); mix_out_automute_handler(mute, sound_pcm_dev_channel_mapping(0)); } } void mix_out_automute_open() { if (mix_out_automute_hdl) { printf("mix_out_automute is already open !\n"); return; } audio_energy_detect_param e_det_param = {0}; e_det_param.mute_energy = 5; e_det_param.unmute_energy = 10; e_det_param.mute_time_ms = 1000; e_det_param.unmute_time_ms = 50; e_det_param.count_cycle_ms = 10; e_det_param.sample_rate = 44100; e_det_param.event_handler = mix_out_automute_handler; e_det_param.ch_total = sound_pcm_dev_channel_mapping(0); e_det_param.dcc = 1; mix_out_automute_hdl = audio_energy_detect_open(&e_det_param); } void mix_out_automute_close() { if (mix_out_automute_hdl) { audio_energy_detect_close(mix_out_automute_hdl); } } #endif //#if AUDIO_OUTPUT_AUTOMUTE static void mixer_event_handler(struct audio_mixer *mixer, int event) { switch (event) { case MIXER_EVENT_CH_OPEN: if ((audio_mixer_get_ch_num(mixer) == 1) || (audio_mixer_get_start_ch_num(mixer) == 1)) { #if AUDIO_OUTPUT_AUTOMUTE audio_energy_detect_sample_rate_update(mix_out_automute_hdl, audio_mixer_get_sample_rate(mixer)); #endif //#if AUDIO_OUTPUT_AUTOMUTE #if TCFG_APP_FM_EMITTER_EN #else #if TCFG_AUDIO_ANC_ENABLE audio_anc_mix_process(1); #endif/*TCFG_AUDIO_ANC_ENABLE*/ sound_pcm_dev_start(NULL, audio_mixer_get_sample_rate(mixer), app_audio_get_volume(APP_AUDIO_CURRENT_STATE)); #endif #if AUDIO_OUT_EFFECT_ENABLE if (!audio_out_effect_dis) { audio_out_effect_open(mixer, audio_mixer_get_sample_rate(mixer)); } #endif mix_out_remain = 0; #if MIX_OUT_DRC_EN mix_out_drc_close(); mix_out_drc_open(audio_mixer_get_sample_rate(mixer)); #endif//MIX_OUT_DRC_EN } break; case MIXER_EVENT_CH_CLOSE: if (audio_mixer_get_ch_num(mixer) == 0) { #if AUDIO_OUT_EFFECT_ENABLE audio_out_effect_close(); #endif #if MIX_OUT_DRC_EN mix_out_drc_close(); #endif//MIX_OUT_DRC_EN #if TCFG_APP_FM_EMITTER_EN #else sound_pcm_dev_stop(NULL); #if TCFG_AUDIO_ANC_ENABLE audio_anc_mix_process(0); #endif/*TCFG_AUDIO_ANC_ENABLE*/ #endif } break; } } static int mix_probe_handler(struct audio_mixer *mixer) { return 0; } static int mix_output_handler(struct audio_mixer *mixer, s16 *data, u16 len) { int rlen = len; int wlen = 0; if (!mix_out_remain) { #if MIX_OUT_DRC_EN mix_out_drc_run(data, len); #endif//MIX_OUT_DRC_EN #if ((defined TCFG_DIAFX_ENABLE) && TCFG_DIAFX_ENABLE) jl_platform_diafx_run(data, len >> 1); #endif } /* audio_aec_refbuf(data, len); */ #if AUDIO_OUTPUT_AUTOMUTE audio_energy_detect_run(mix_out_automute_hdl, data, len); #endif //#if AUDIO_OUTPUT_AUTOMUTE #if TCFG_APP_FM_EMITTER_EN fm_emitter_cbuf_write((u8 *)data, len); #else wlen = sound_pcm_dev_write(NULL, data, len); /*printf("0x%x, %d, %d\n", (u32)data, len, wlen);*/ /* if (wlen == len) { audio_decoder_resume_all(&decode_task); } */ #endif/*TCFG_APP_FM_EMITTER_EN*/ if (wlen >= len) { mix_out_remain = 0; } else { mix_out_remain = 1; } return wlen; } #if AUDIO_OUT_EFFECT_ENABLE static int mix_output_effect_handler(struct audio_mixer *mixer, s16 *data, u16 len) { if (!audio_out_effect) { return mix_output_handler(mixer, data, len); } if (audio_out_effect && audio_out_effect->async) { return eq_drc_run(audio_out_effect, data, len); } if (!audio_out_effect->remain) { if (audio_out_effect && !audio_out_effect->async) { eq_drc_run(audio_out_effect, data, len); } } int wlen = mix_output_handler(mixer, data, len); if (wlen == len) { audio_out_effect->remain = 0; } else { audio_out_effect->remain = 1; } return wlen; } #endif//AUDIO_OUT_EFFECT_ENABLE static const struct audio_mix_handler mix_handler = { .mix_probe = mix_probe_handler, #if AUDIO_OUT_EFFECT_ENABLE .mix_output = mix_output_effect_handler, #else .mix_output = mix_output_handler, #endif//AUDIO_OUT_EFFECT_ENABLE }; static const u8 msbc_mute_data[] = { 0xAD, 0x00, 0x00, 0xC5, 0x00, 0x00, 0x00, 0x00, 0x77, 0x6D, 0xB6, 0xDD, 0xDB, 0x6D, 0xB7, 0x76, 0xDB, 0x6D, 0xDD, 0xB6, 0xDB, 0x77, 0x6D, 0xB6, 0xDD, 0xDB, 0x6D, 0xB7, 0x76, 0xDB, 0x6D, 0xDD, 0xB6, 0xDB, 0x77, 0x6D, 0xB6, 0xDD, 0xDB, 0x6D, 0xB7, 0x76, 0xDB, 0x6D, 0xDD, 0xB6, 0xDB, 0x77, 0x6D, 0xB6, 0xDD, 0xDB, 0x6D, 0xB7, 0x76, 0xDB, 0x6C, 0x00, }; static int headcheck(u8 *buf) { int sync_word = buf[0] | ((buf[1] & 0x0f) << 8); return (sync_word == 0x801) && (buf[2] == 0xAD); } static int esco_dump_rts_info(struct rt_stream_info *pkt) { u32 hash = 0xffffffff; int read_len = 0; pkt->baddr = lmp_private_get_esco_packet(&read_len, &hash); pkt->seqn = hash; /* printf("hash0=%d,%d ",hash,pkt->baddr ); */ if (pkt->baddr && read_len) { pkt->remain_len = lmp_private_get_esco_remain_buffer_size(); pkt->data_len = lmp_private_get_esco_data_len(); return 0; } if (read_len == -EINVAL) { //puts("----esco close\n"); return -EINVAL; } if (read_len < 0) { return -ENOMEM; } return ENOMEM; } static int esco_dec_get_frame(struct audio_decoder *decoder, u8 **frame) { int len = 0; u32 hash = 0; struct esco_dec_hdl *dec = container_of(decoder, struct esco_dec_hdl, decoder); __again: if (dec->frame) { int len = dec->frame_len - dec->offset; if (len > dec->esco_len - dec->data_len) { len = dec->esco_len - dec->data_len; } /*memcpy((u8 *)dec->data + dec->data_len, msbc_mute_data, sizeof(msbc_mute_data));*/ memcpy((u8 *)dec->data + dec->data_len, dec->frame + dec->offset, len); dec->offset += len; dec->data_len += len; if (dec->offset == dec->frame_len) { lmp_private_free_esco_packet(dec->frame); dec->frame = NULL; } } if (dec->data_len < dec->esco_len) { dec->frame = lmp_private_get_esco_packet(&len, &hash); /* printf("hash1=%d,%d ",hash,dec->frame ); */ if (len <= 0) { printf("rlen=%d ", len); return -EIO; } #if AUDIO_CODEC_SUPPORT_SYNC u32 timestamp; if (dec->ts_handle) { timestamp = esco_audio_timestamp_update(dec->ts_handle, hash); if (dec->syncts && (((hash - dec->hash) & 0x7ffffff) == dec->frame_time)) { audio_syncts_next_pts(dec->syncts, timestamp); } dec->hash = hash; if (!dec->ts_start) { dec->ts_start = 1; dec->mix_ch_event_params[2] = timestamp; } } #endif #if (defined(TCFG_PHONE_MESSAGE_ENABLE) && (TCFG_PHONE_MESSAGE_ENABLE)) phone_message_enc_write(dec->frame + 2, len - 2); #endif dec->offset = 0; dec->frame_len = len; goto __again; } *frame = (u8 *)dec->data; return dec->esco_len; } static void esco_dec_put_frame(struct audio_decoder *decoder, u8 *frame) { struct esco_dec_hdl *dec = container_of(decoder, struct esco_dec_hdl, decoder); dec->data_len = 0; /*lmp_private_free_esco_packet((void *)frame);*/ } static const struct audio_dec_input esco_input = { .coding_type = AUDIO_CODING_MSBC, .data_type = AUDIO_INPUT_FRAME, .ops = { .frame = { .fget = esco_dec_get_frame, .fput = esco_dec_put_frame, } } }; u32 lmp_private_clear_sco_packet(u8 clear_num); static void esco_dec_clear_all_packet(struct esco_dec_hdl *dec) { lmp_private_clear_sco_packet(0xff); } static int esco_dec_probe_handler(struct audio_decoder *decoder) { struct esco_dec_hdl *dec = container_of(decoder, struct esco_dec_hdl, decoder); int err = 0; int find_packet = 0; struct rt_stream_info rts_info = {0}; err = esco_dump_rts_info(&rts_info); if (err == -EINVAL) { return err; } if (err || !dec->enc_start) { audio_decoder_suspend(decoder, 0); return -EAGAIN; } #if TCFG_USER_TWS_ENABLE if (tws_network_audio_was_started()) { /*清除从机声音加入标志*/ dec->slience_frames = 20; tws_network_local_audio_start(); } #endif if (dec->preempt) { dec->preempt = 0; dec->slience_frames = 20; } return err; } #define MONO_TO_DUAL_POINTS 30 ////////////////////////////////////////////////////////////////////////////// static inline void audio_pcm_mono_to_dual(s16 *dual_pcm, s16 *mono_pcm, int points) { //printf("<%d,%x>",points,mono_pcm); s16 *mono = mono_pcm; int i = 0; u8 j = 0; for (i = 0; i < points; i++, mono++) { *dual_pcm++ = *mono; *dual_pcm++ = *mono; } } /*level:0~15*/ static const u16 esco_dvol_tab[] = { 0, //0 111,//1 161,//2 234,//3 338,//4 490,//5 708,//6 1024,//7 1481,//8 2142,//9 3098,//10 4479,//11 6477,//12 9366,//13 14955,//14 16384 //15 }; /* ********************************************************************* * ESCO Decode mix filter * Description: ESCO语音解码输出接入mix滤镜 * Arguments : data - 音频数据，len - 音频byte长度 * Return : 输出到后级的数据长度 * Note(s) : 音频后级PCM设备为单声道直接写入mixer，PCM设备为双声道， * 这里通过1 to 2ch的处理将数据写入mixer，并返回消耗的原始 * 数据长度。 ********************************************************************* */ static s16 two_ch_data[MONO_TO_DUAL_POINTS * 2]; static s16 dual_offset_points = 0; static s16 dual_total_points = 0; static int esco_decoder_mix_filter(struct esco_dec_hdl *dec, s16 *data, int len) { int wlen = 0; s16 point_num = 0; u8 mono_to_dual = 0; s16 *mono_data = (s16 *)data; u16 remain_points = (len >> 1); /* *如果dac输出是双声道，因为esco解码出来时单声道 *所以这里要根据dac通道确定是否做单变双 */ mono_to_dual = sound_pcm_dev_channel_mapping(1) == 2 ? 1 : 0; if (mono_to_dual) { do { if (dual_offset_points < dual_total_points) { int tmp_len = audio_mixer_ch_write(&dec->mix_ch, &two_ch_data[dual_offset_points], (dual_total_points - dual_offset_points) << 1); dual_offset_points += tmp_len >> 1; if (tmp_len < ((dual_total_points - dual_offset_points) << 1)) { break; } if (dual_offset_points < dual_total_points) { continue; } } point_num = MONO_TO_DUAL_POINTS; if (point_num >= remain_points) { point_num = remain_points; } audio_pcm_mono_to_dual(two_ch_data, mono_data, point_num); dual_offset_points = 0; dual_total_points = point_num << 1; int tmp_len = audio_mixer_ch_write(&dec->mix_ch, &two_ch_data[dual_offset_points], (dual_total_points - dual_offset_points) << 1); dual_offset_points += tmp_len >> 1; wlen += dual_total_points << 1; remain_points -= (dual_total_points >> 1); mono_data += point_num; if (tmp_len < (dual_total_points - dual_offset_points) << 1) { break; } } while (remain_points); } else { wlen = audio_mixer_ch_write(&dec->mix_ch, data, len); } wlen = mono_to_dual ? (wlen >> 1) : wlen; return wlen; } /* ********************************************************************* * ESCO Decode DL_NS filter * Description: ESCO语音解码输出下行降噪滤镜 * Arguments : data - 音频数据，len - 音频byte长度 * Return : 输出到后级的数据长度 * Note(s) : 下行降噪通话接通前为直通，接通后进行NS RUN处理。 ********************************************************************* */ static int esco_decoder_dl_ns_filter(struct esco_dec_hdl *dec, s16 *data, int len) { #if TCFG_ESCO_DL_NS_ENABLE int wlen = 0; int ret_len = len; if (dec->dl_ns_remain) { wlen = esco_decoder_mix_filter(dec, dec->dl_ns_out + (dec->dl_ns_offset / 2), dec->dl_ns_remain); dec->dl_ns_offset += wlen; dec->dl_ns_remain -= wlen; if (dec->dl_ns_remain) { return 0; } } if (get_call_status() == BT_CALL_ACTIVE) { /*接通的时候再开始做降噪*/ int ns_out = audio_ns_run(dec->dl_ns, data, dec->dl_ns_out, len); //输入消耗完毕，没有输出 if (ns_out == 0) { return len; } len = ns_out; } else { memcpy(dec->dl_ns_out, data, len); } wlen = esco_decoder_mix_filter(dec, dec->dl_ns_out, len); dec->dl_ns_offset = wlen; dec->dl_ns_remain = len - wlen; return ret_len; #else return 0; #endif/*TCFG_ESCO_DL_NS_ENABLE*/ } /* ********************************************************************* * ESCO output after syncts * Description: esco同步滤镜后的数据流滤镜 * Arguments : data - 音频数据，len - 音频byte长度 * Return : 输出到后级的数据长度 * Note(s) : 音频同步后使用。 ********************************************************************* */ static int esco_output_after_syncts_filter(void *priv, s16 *data, int len) { struct esco_dec_hdl *dec = (struct esco_dec_hdl *)priv; int wlen = 0; /* *如果dac输出是双声道，因为esco解码出来时单声道 *所以这里要根据dac通道确定是否做单变双 */ #if TCFG_ESCO_DL_NS_ENABLE wlen = esco_decoder_dl_ns_filter(dec, data, len); #else wlen = esco_decoder_mix_filter(dec, data, len); #endif return wlen; } /* *slience_frames结束前增加淡入处理，防止声音突变，听到一下的不适感 * */ static void esco_fade_in(struct esco_dec_hdl *dec, s16 *data, int len) { if (dec->fade_trigger) { int tmp = 0; s16 *p = data; u16 frames = (len >> 1) / dec->channels; for (int i = 0; i < frames; i++) { for (int j = 0; j < dec->channels; j++) { tmp = *p; *p++ = dec->fade_volume * tmp / DIGITAL_OdB_VOLUME; } dec->fade_volume += dec->fade_step; if (dec->fade_volume > DIGITAL_OdB_VOLUME) { dec->fade_volume = DIGITAL_OdB_VOLUME; break; } } if (dec->fade_volume == DIGITAL_OdB_VOLUME) { dec->fade_trigger = 0; } } } /* ********************************************************************* * ESCO Decode Output * Description: 蓝牙通话解码输出 * Arguments : *priv 数据包错误表示(1 == error) * Return : 输出到后级的数据长度 * Note(s) : dec->remain不等于0表示解码输出的数据后级没有消耗完 * 也就是说，只有(dec->remain == 0)的情况，才是新解码 * 出来的数据，才是需要做后处理的数据，否则直接输出到 * 后级即可。 ********************************************************************* */ static int esco_dec_output_handler(struct audio_decoder *decoder, s16 *buf, int size, void *priv) { int wlen = 0; int ret_len = size; int len = size; short *data = buf; struct esco_dec_hdl *dec = container_of(decoder, struct esco_dec_hdl, decoder); /*非上次残留数据,进行后处理*/ if (!dec->remain) { #if (defined(TCFG_PHONE_MESSAGE_ENABLE) && (TCFG_PHONE_MESSAGE_ENABLE)) phone_message_call_api_esco_out_data(data, len); #endif/*TCFG_PHONE_MESSAGE_ENABLE*/ if (priv) { audio_plc_run(data, len, *(u8 *)priv); } #if (SYS_VOL_TYPE == VOL_TYPE_DIGITAL) audio_digital_vol_run(CALL_DVOL, data, len); u16 dvol_val = esco_dvol_tab[app_var.aec_dac_gain]; for (u16 i = 0; i < len / 2; i++) { s32 tmp_data = data[i]; if (tmp_data < 0) { tmp_data = -tmp_data; tmp_data = (tmp_data * dvol_val) >> 14; tmp_data = -tmp_data; } else { tmp_data = (tmp_data * dvol_val) >> 14; } data[i] = tmp_data; } #endif/*SYS_VOL_TYPE == VOL_TYPE_DIGITAL*/ #if TCFG_AUDIO_ESCO_DL_NOISEGATE_ENABLE /*来电去电铃声不做处理*/ if ((get_call_status() == BT_CALL_ACTIVE) && esco_dl_noisegate_buf) { audio_noise_gate_run(esco_dl_noisegate_buf, data, data, len / 2); } #endif/*TCFG_AUDIO_ESCO_DL_NOISEGATE_ENABLE*/ #if TCFG_AUDIO_ESCO_LIMITER_ENABLE if (dec->limiter) { esco_limiter_run(dec->limiter, data, len); } #endif #if TCFG_EQ_ENABLE&&TCFG_PHONE_EQ_ENABLE eq_drc_run(dec->eq_drc, data, len); #endif//TCFG_PHONE_EQ_ENABLE if (dec->slience_frames) { if (dec->slience_frames == 1) { int fade_time = 6; int sample_rate = dec->decoder.fmt.sample_rate; dec->fade_step = DIGITAL_OdB_VOLUME / ((fade_time * sample_rate) / 1000); dec->fade_trigger = 1; dec->fade_volume = 0; } else { dec->fade_trigger = 0; dec->fade_volume = 0; memset(data, 0x0, len); } dec->slience_frames--; } esco_fade_in(dec, data, len); } #if AUDIO_CODEC_SUPPORT_SYNC if (dec->syncts) { wlen = audio_syncts_frame_filter(dec->syncts, data, len); if (wlen < len) { audio_syncts_trigger_resume(dec->syncts, (void *)decoder, audio_filter_resume_decoder); } goto ret_handle; } #endif wlen = esco_output_after_syncts_filter(dec, data, len); ret_handle: dec->remain = wlen == len ? 0 : 1; return wlen; } static int esco_dec_post_handler(struct audio_decoder *decoder) { return 0; } static const struct audio_dec_handler esco_dec_handler = { .dec_probe = esco_dec_probe_handler, .dec_output = esco_dec_output_handler, .dec_post = esco_dec_post_handler, }; void esco_dec_release() { #if TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN if (get_icsd_adt_mode()) { audio_icsd_adt_open(0); } #endif /*TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN*/ audio_decoder_task_del_wait(&decode_task, &esco_dec->wait); free(esco_dec); esco_dec = NULL; } void esco_dec_close(); static void esco_dec_event_handler(struct audio_decoder *decoder, int argc, int *argv) { switch (argv[0]) { case AUDIO_DEC_EVENT_END: puts("AUDIO_DEC_EVENT_END\n"); esco_dec_close(); break; } } u32 source_sr; void set_source_sample_rate(u32 sample_rate) { source_sr = sample_rate; } u16 get_source_sample_rate() { if (bt_audio_is_running()) { return source_sr; } return 0; } int esco_dec_dac_gain_set(u8 gain) { app_var.aec_dac_gain = gain; if (esco_dec) { #if (SYS_VOL_TYPE == VOL_TYPE_DIGITAL_HW) app_audio_set_max_volume(APP_AUDIO_STATE_CALL, gain); app_audio_set_volume(APP_AUDIO_STATE_CALL, app_audio_get_volume(APP_AUDIO_STATE_CALL), 1); #else sound_pcm_dev_set_analog_gain(gain); #endif/*SYS_VOL_TYPE*/ } return 0; } #define ESCO_SIRI_WAKEUP() (app_var.siri_stu == 1 || app_var.siri_stu == 2) static int esco_decoder_syncts_setup(struct esco_dec_hdl *dec) { int err = 0; #if AUDIO_CODEC_SUPPORT_SYNC #define ESCO_DELAY_TIME 60 #define ESCO_RECOGNTION_TIME 220 int delay_time = ESCO_DELAY_TIME; if (get_sniff_out_status()) { clear_sniff_out_status(); if (ESCO_SIRI_WAKEUP()) { /*fix : Siri出sniff蓝牙数据到音频通路延迟过长，容易引入同步的问题*/ delay_time = ESCO_RECOGNTION_TIME; } } struct audio_syncts_params params = {0}; int sample_rate = dec->decoder.fmt.sample_rate; params.nch = dec->decoder.fmt.channel; params.pcm_device = sound_pcm_sync_device_select();//PCM_INSIDE_DAC; params.rout_sample_rate = sound_pcm_match_sample_rate(sample_rate); params.network = AUDIO_NETWORK_BT2_1; params.rin_sample_rate = sample_rate; params.priv = dec; params.factor = TIME_US_FACTOR; params.output = (int (*)(void *, void *, int))esco_output_after_syncts_filter; bt_audio_sync_nettime_select(0);//0 - 主机，1 - tws, 2 - BLE u8 frame_clkn = dec->esco_len >= 60 ? 12 : 6; dec->ts_handle = esco_audio_timestamp_create(frame_clkn, delay_time, TIME_US_FACTOR); dec->frame_time = frame_clkn; audio_syncts_open(&dec->syncts, ¶ms); if (!err) { dec->mix_ch_event_params[0] = (u32)&dec->mix_ch; dec->mix_ch_event_params[1] = (u32)dec->syncts; audio_mixer_ch_set_event_handler(&dec->mix_ch, (void *)dec->mix_ch_event_params, audio_mix_ch_event_handler); } dec->ts_start = 0; #endif return err; } static void esco_decoder_syncts_free(struct esco_dec_hdl *dec) { #if AUDIO_CODEC_SUPPORT_SYNC if (dec->ts_handle) { esco_audio_timestamp_close(dec->ts_handle); dec->ts_handle = NULL; } if (dec->syncts) { audio_syncts_close(dec->syncts); dec->syncts = NULL; } #endif } int esco_ul_stream_open(u32 sample_rate, u16 esco_len, u32 codec_type) { int err = 0; printf("esco_ul_open,sr = %d,len = %d,type = %x\n", sample_rate, esco_len, codec_type); if (esco_dec->start == 0) { printf("esco_ul_stream close ing,return\n"); return 0; } if (esco_dec->ul_stream_open) { printf("esco_ul_stream_open now,return\n"); return 0; } esco_dec->ul_stream_open = 1; err = audio_aec_init(sample_rate); if (err) { printf("audio_aec_init failed:%d", err); //goto __err3; } err = esco_enc_open(codec_type, esco_len); if (err) { printf("audio_enc_open failed:%d", err); //goto __err3; } return err; } int esco_ul_stream_close(void) { printf("esco_ul_stream_close\n"); if (esco_dec->ul_stream_open == 0) { printf("esco_ul_stream_closed,return\n"); return 0; } audio_aec_close(); esco_enc_close(); esco_dec->ul_stream_open = 0; return 0; } int esco_ul_stream_switch(u8 en) { if (esco_dec == NULL) { printf("esco_ul_stream_close now,return\n"); return 0; } if (en) { return esco_ul_stream_open(esco_dec->sample_rate, esco_dec->esco_len, esco_dec->coding_type); } else { return esco_ul_stream_close(); } } int esco_enc_reset(void) { if (esco_dec == NULL) { printf("esco_ul_stream_close now,return\n"); return 0; } esco_enc_close(); esco_enc_open(esco_dec->coding_type, esco_dec->esco_len); return 0; } int esco_dec_start() { int err; struct audio_fmt f; enum audio_channel channel; struct esco_dec_hdl *dec = esco_dec; u16 mix_buf_len_fix = 240; if (!esco_dec) { return -EINVAL; } #if TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN /*通话前关闭adt*/ esco_dec->icsd_adt_state = audio_icsd_adt_is_running(); if (esco_dec->icsd_adt_state) { audio_icsd_adt_close(0); } #endif /*TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN*/ err = audio_decoder_open(&dec->decoder, &esco_input, &decode_task); if (err) { goto __err1; } audio_decoder_set_handler(&dec->decoder, &esco_dec_handler); audio_decoder_set_event_handler(&dec->decoder, esco_dec_event_handler, 0); if (dec->coding_type == AUDIO_CODING_MSBC) { f.coding_type = AUDIO_CODING_MSBC; f.sample_rate = 16000; f.channel = 1; } else if (dec->coding_type == AUDIO_CODING_CVSD) { f.coding_type = AUDIO_CODING_CVSD; f.sample_rate = 8000; f.channel = 1; mix_buf_len_fix = 120; } dec->sample_rate = f.sample_rate; set_source_sample_rate(f.sample_rate); err = audio_decoder_set_fmt(&dec->decoder, &f); if (err) { goto __err2; } dec->channels = f.channel; /* *虽然mix有直通的处理，但是如果混合第二种声音进来的时候，就会按照mix_buff *的大小来混合输出，该buff太大，回导致dac没有连续的数据播放 */ /*audio_mixer_set_output_buf(&mixer, mix_buff, sizeof(mix_buff) / 8);*/ audio_mixer_set_output_buf(&mixer, mix_buff, mix_buf_len_fix); audio_mixer_ch_open(&dec->mix_ch, &mixer); audio_mixer_ch_set_sample_rate(&dec->mix_ch, sound_pcm_match_sample_rate(f.sample_rate)); audio_mixer_ch_set_resume_handler(&dec->mix_ch, (void *)&dec->decoder, (void (*)(void *))audio_decoder_resume); #if TCFG_AUDIO_ESCO_DL_NOISEGATE_ENABLE esco_dl_noisegate_buf = audio_noise_gate_open(300, 5, ESCO_NOISEGATE_THR, ESCO_NOISEGATE_GAIN, 16000, 1); #endif/*TCFG_AUDIO_ESCO_DL_NOISEGATE_ENABLE*/ #if TCFG_AUDIO_ESCO_LIMITER_ENABLE dec->limiter = esco_limiter_open(f.sample_rate, f.channel); #endif/*TCFG_AUDIO_ESCO_LIMITER_ENABLE*/ #if TCFG_EQ_ENABLE&&TCFG_PHONE_EQ_ENABLE u8 drc_en = 0; #if TCFG_DRC_ENABLE&&ESCO_DRC_EN drc_en = 1; #endif//ESCO_DRC_EN dec->eq_drc = esco_eq_drc_setup(&dec->mix_ch, (eq_output_cb)audio_mixer_ch_write, f.sample_rate, f.channel, 0, drc_en); #endif//TCFG_PHONE_EQ_ENABLE app_audio_state_switch(APP_AUDIO_STATE_CALL, BT_CALL_VOL_LEAVE_MAX); #if (SYS_VOL_TYPE == VOL_TYPE_DIGITAL) audio_digital_vol_open(CALL_DVOL, app_audio_get_volume(APP_AUDIO_STATE_CALL), CALL_DVOL_MAX, CALL_DVOL_FS, -1); #endif/*SYS_VOL_TYPE == VOL_TYPE_DIGITAL*/ printf("max_vol:%d,call_vol:%d", app_var.aec_dac_gain, app_audio_get_volume(APP_AUDIO_STATE_CALL)); app_audio_set_volume(APP_AUDIO_STATE_CALL, app_var.call_volume, 1); #if AUDIO_CODEC_SUPPORT_SYNC esco_decoder_syncts_setup(dec); #endif/*AUDIO_CODEC_SUPPORT_SYNC*/ /*plc调用需要考虑到代码overlay或者压缩操作*/ audio_plc_open(f.sample_rate); sound_pcm_dev_set_delay_time(30, 50); lmp_private_esco_suspend_resume(2); err = audio_decoder_start(&dec->decoder); if (err) { goto __err3; } sound_pcm_dev_try_power_on(); audio_out_effect_dis = 1;//通话模式关闭高低音 dec->start = 1; dec->remain = 0; #if TCFG_ESCO_DL_NS_ENABLE dec->dl_ns = audio_ns_open(f.sample_rate, DL_NS_MODE, DL_NS_NOISELEVEL, DL_NS_AGGRESSFACTOR, DL_NS_MINSUPPRESS); dec->dl_ns_remain = 0; #endif/*TCFG_ESCO_DL_NS_ENABLE*/ err = esco_ul_stream_open(f.sample_rate, dec->esco_len, dec->coding_type); #if (TCFG_AUDIO_OUTPUT_IIS) audio_aec_ref_src_open(TCFG_IIS_SR, f.sample_rate); #endif clk_set_sys_lock(96 * (1000000L), 0); audio_codec_clock_set(AUDIO_ESCO_MODE, dec->coding_type, dec->wait.preemption); /* #if TCFG_DRC_ENABLE&&ESCO_DRC_EN */ /* #endif//ESCO_DRC_EN */ dec->enc_start = 1; //该函数所在任务优先级低可能未open编码就开始解码，加入enc开始的标志防止解码过快输出 printf("esco_dec_start ok\n"); return 0; __err3: audio_mixer_ch_close(&dec->mix_ch); __err2: audio_decoder_close(&dec->decoder); __err1: esco_dec_release(); return err; } static int __esco_dec_res_close(void) { if (!esco_dec->start) { return 0; } esco_dec->start = 0; esco_dec->enc_start = 0; esco_dec->preempt = 1; esco_ul_stream_close(); /* audio_aec_close(); */ /* esco_enc_close(); */ #if TCFG_AUDIO_CVP_DUT_ENABLE cvp_dut_mode_set(CVP_DUT_MODE_ALGORITHM); //通话结束 CVP_DUT恢复成算法模式 #endif/*TCFG_AUDIO_CVP_DUT_ENABLE*/ app_audio_state_exit(APP_AUDIO_STATE_CALL); audio_decoder_close(&esco_dec->decoder); audio_mixer_ch_close(&esco_dec->mix_ch); sound_pcm_dev_set_delay_time(20, AUDIO_DAC_DELAY_TIME); #if AUDIO_CODEC_SUPPORT_SYNC esco_decoder_syncts_free(esco_dec); esco_dec->sync_step = 0; #endif #if TCFG_EQ_ENABLE&&TCFG_PHONE_EQ_ENABLE if (esco_dec->eq_drc) { esco_eq_drc_free(esco_dec->eq_drc); esco_dec->eq_drc = NULL; } #endif//TCFG_PHONE_EQ_ENABLE audio_out_effect_dis = 0; #if (SYS_VOL_TYPE == VOL_TYPE_DIGITAL) audio_digital_vol_close(CALL_DVOL); #endif/*SYS_VOL_TYPE == VOL_TYPE_DIGITAL*/ #if TCFG_ESCO_DL_NS_ENABLE audio_ns_close(esco_dec->dl_ns); #endif/*TCFG_ESCO_DL_NS_ENABLE*/ audio_plc_close(); #if TCFG_AUDIO_ESCO_DL_NOISEGATE_ENABLE audio_noise_gate_close(esco_dl_noisegate_buf); #endif/*TCFG_AUDIO_ESCO_DL_NOISEGATE_ENABLE*/ #if TCFG_AUDIO_ESCO_LIMITER_ENABLE if (esco_dec->limiter) { esco_limiter_close(esco_dec->limiter); esco_dec->limiter = NULL; } #endif audio_codec_clock_del(AUDIO_ESCO_MODE); dual_offset_points = 0; dual_total_points = 0; return 0; } static int esco_wait_res_handler(struct audio_res_wait *wait, int event) { int err = 0; printf("esco_wait_res_handler:%d", event); if (event == AUDIO_RES_GET) { err = esco_dec_start(); } else if (event == AUDIO_RES_PUT) { err = __esco_dec_res_close(); lmp_private_esco_suspend_resume(1); } return err; } static void esco_smart_voice_detect_handler(void) { #if TCFG_SMART_VOICE_ENABLE #if TCFG_CALL_KWS_SWITCH_ENABLE if (ESCO_SIRI_WAKEUP() || (get_call_status() != BT_CALL_INCOMING)) { audio_smart_voice_detect_close(); } #else audio_smart_voice_detect_close(); #endif #endif } /* ********************************************************************* * SCO/ESCO Decode Open * Description: 打开蓝牙通话解码 * Arguments : param 蓝牙协议栈传递上来的编解码信息 * Return : 0 成功 其他 失败 * Note(s) : None. ********************************************************************* */ int esco_dec_open(void *param, u8 mute) { int err; struct esco_dec_hdl *dec; u32 esco_param = *(u32 *)param; int esco_len = esco_param >> 16; int codec_type = esco_param & 0x000000ff; printf("esco_dec_open, type=%d,len=%d\n", codec_type, esco_len); #if (TCFG_AUDIO_HEARING_AID_ENABLE && TCFG_AUDIO_DHA_AND_CALL_MUTEX) audio_hearing_aid_suspend(); #endif/*TCFG_AUDIO_HEARING_AID_ENABLE*/ esco_smart_voice_detect_handler(); dec = zalloc(sizeof(*dec)); if (!dec) { return -ENOMEM; } esco_dec = dec; dec->esco_len = esco_len; if (codec_type == 3) { dec->coding_type = AUDIO_CODING_MSBC; } else if (codec_type == 2) { dec->coding_type = AUDIO_CODING_CVSD; } else { printf("Unknow ESCO codec type:%d\n", codec_type); } dec->tws_mute_en = mute; dec->wait.priority = 2; dec->wait.preemption = 1; dec->wait.handler = esco_wait_res_handler; err = audio_decoder_task_add_wait(&decode_task, &dec->wait); if (esco_dec && esco_dec->start == 0) { dec->preempt = 1; lmp_private_esco_suspend_resume(1); } #if AUDIO_OUTPUT_AUTOMUTE mix_out_automute_skip(1); #endif return err; } /* ********************************************************************* * SCO/ESCO Decode Close * Description: 关闭蓝牙通话解码 * Arguments : None. * Return : None. * Note(s) : None. ********************************************************************* */ void esco_dec_close(void) { if (!esco_dec) { return; } __esco_dec_res_close(); esco_dec_release(); #if (TCFG_AUDIO_OUTPUT_IIS) audio_aec_ref_src_close(); #endif #if AUDIO_OUTPUT_AUTOMUTE mix_out_automute_skip(0); #endif #if (defined(TCFG_PHONE_MESSAGE_ENABLE) && (TCFG_PHONE_MESSAGE_ENABLE)) phone_message_call_api_stop(); #endif/*TCFG_PHONE_MESSAGE_ENABLE*/ audio_mixer_set_output_buf(&mixer, mix_buff, sizeof(mix_buff)); #if TCFG_SMART_VOICE_ENABLE audio_smart_voice_detect_open(JL_KWS_COMMAND_KEYWORD); #endif #if (TCFG_AUDIO_HEARING_AID_ENABLE && TCFG_AUDIO_DHA_AND_CALL_MUTEX) audio_hearing_aid_resume(); #endif/*TCFG_AUDIO_HEARING_AID_ENABLE*/ printf("esco_dec_close succ\n"); } ////////////////////////////////////////////////////////////////////////////// u8 bt_audio_is_running(void) { return (a2dp_dec || esco_dec); } u8 bt_media_is_running(void) { return a2dp_dec != NULL; } u8 bt_phone_dec_is_running() { return esco_dec != NULL; } __attribute__((weak)) void mic_trim_run(void) { printf("==========weak fun for tmp\n"); } extern u32 read_capless_DTB(void); static u8 audio_dec_inited = 0; /*音频配置实时跟踪，可以用来查看ADC/DAC增益，或者其他寄存器配置*/ static void audio_config_trace(void *priv) { printf(">>Audio_Config_Trace:\n"); audio_gain_dump(); //audio_adda_dump(); } ////////////////////////////////////////////////////////////////////////////// int audio_dec_init() { int err; printf("audio_dec_init\n"); tone_play_init(); #if TCFG_KEY_TONE_EN // 按键音初始化 audio_key_tone_init(); #endif err = audio_decoder_task_create(&decode_task, "audio_dec"); #if TCFG_AUDIO_ANC_ENABLE /* audio_dac_anc_set(&dac_hdl, 1); */ /* dac_data.max_ana_vol = anc_dac_gain_get(ANC_DAC_CH_L); //获取ANC设置的模拟增益 */ #endif/*TCFG_AUDIO_ANC_ENABLE*/ request_irq(IRQ_AUDIO_IDX, 2, audio_irq_handler, 0); /*硬件SRC模块滤波器buffer设置，可根据最大使用数量设置整体buffer*/ /* audio_src_base_filt_init(audio_src_hw_filt, sizeof(audio_src_hw_filt)); */ sound_pcm_driver_init(); sound_pcm_dev_set_delay_time(20, AUDIO_DAC_DELAY_TIME); audio_mixer_open(&mixer); audio_mixer_set_handler(&mixer, &mix_handler); audio_mixer_set_event_handler(&mixer, mixer_event_handler); #if defined(TCFG_AUDIO_DAC_24BIT_MODE) && TCFG_AUDIO_DAC_24BIT_MODE audio_mixer_set_mode(&mixer, 4, BIT24_MODE); #endif audio_mixer_set_output_buf(&mixer, mix_buff, sizeof(mix_buff)); #if AUDIO_OUTPUT_AUTOMUTE mix_out_automute_open(); #endif //#if AUDIO_OUTPUT_AUTOMUTE #if TCFG_AUDIO_CONFIG_TRACE sys_timer_add(NULL, audio_config_trace, 3000); #endif/*TCFG_AUDIO_CONFIG_TRACE*/ #if defined(AUDIO_SPK_EQ_CONFIG) && AUDIO_SPK_EQ_CONFIG spk_eq_read_from_vm(); #endif #if ((defined TCFG_DIAFX_ENABLE) && TCFG_DIAFX_ENABLE) diafx_init_mode(0); diafx_enabled(1); #endif audio_dec_inited = 1; #if TCFG_AUDIO_ANC_ENABLE && TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN /*需要再dac trim后调用*/ /*同时开ANC和免摘功能时，配置ADC固定打开的adc数字通道数*/ extern struct adc_platform_data adc_data; adc_data.anc_adt_en = 1; u8 esco_mic_num = audio_adc_file_get_esco_mic_num(); u8 adt_mic_num = get_icsd_adt_mic_num(); adc_data.anc_adt_mic_ch_num = esco_mic_num > adt_mic_num ? esco_mic_num : adt_mic_num; #endif /*TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN*/ return err; } static u8 audio_dec_init_complete() { if (!audio_dec_inited) { return 0; } return 1; } extern void audio_adc_mic_demo_open(u8 mic_idx, u8 gain, u16 sr, u8 mic_2_dac); extern void dac_analog_power_control(u8 en); void audio_fast_mode_test() { sound_pcm_dev_start(NULL, 44100, app_audio_get_volume(APP_AUDIO_CURRENT_STATE)); audio_adc_mic_demo_open(AUDIO_ADC_MIC_0, 10, 16000, 1); } REGISTER_LP_TARGET(audio_dec_init_lp_target) = { .name = "audio_dec_init", .is_idle = audio_dec_init_complete, }; #if AUDIO_OUT_EFFECT_ENABLE int audio_out_effect_stream_clear() { if (!audio_out_effect) { return 0; } if (audio_out_effect->eq && audio_out_effect->async) { audio_eq_async_data_clear(audio_out_effect->eq); } return 0; } void audio_out_effect_close(void) { if (!audio_out_effect) { return ; } audio_out_eq_drc_free(audio_out_effect); audio_out_effect = NULL; } int audio_out_effect_open(void *priv, u16 sample_rate) { audio_out_effect_close(); u8 ch_num; #if TCFG_APP_FM_EMITTER_EN ch_num = 2; #else ch_num = sound_pcm_dev_channel_mapping(0); #endif//TCFG_APP_FM_EMITTER_EN u8 drc_en = 0;// u8 async = 0; if (drc_en) { async = 1; } audio_out_effect = audio_out_eq_drc_setup(priv, (eq_output_cb)mix_output_handler, sample_rate, ch_num, async, drc_en); return 0; } int audio_out_eq_spec_set_gain(u8 idx, int gain) { if (!audio_out_effect) { return -1; } audio_out_eq_set_gain(audio_out_effect, idx, gain); return 0; } #endif//AUDIO_OUT_EFFECT_ENABLE /*----------------------------------------------------------------------------*/ /**@brief 获取输出默认采样率 @param @return 0: 采样率可变 @return 非0: 固定采样率 @note */ /*----------------------------------------------------------------------------*/ u32 audio_output_nor_rate(void) { #if TCFG_AUDIO_OUTPUT_IIS return TCFG_IIS_SR; #endif /*TCFG_AUDIO_OUTPUT_IIS*/ #if AUDIO_OUTPUT_INCLUDE_DAC #if (TCFG_MIC_EFFECT_ENABLE) return TCFG_REVERB_SAMPLERATE_DEFUAL; #endif /* return app_audio_output_samplerate_select(input_rate, 1); */ #elif (AUDIO_OUTPUT_WAY == AUDIO_OUTPUT_WAY_BT) #elif (AUDIO_OUTPUT_WAY == AUDIO_OUTPUT_WAY_FM) return 41667; #else return 44100; #endif /* #if TCFG_VIR_UDISK_ENABLE */ /* return 44100; */ /* #endif */ return 0; } int audio_dac_sample_rate_select(struct audio_dac_hdl *dac, u32 sample_rate, u8 high) { u32 sample_rate_tbl[] = {8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000, 64000, 88200, 96000 }; int rate_num = ARRAY_SIZE(sample_rate_tbl); int i = 0; for (i = 0; i < rate_num; i++) { if (sample_rate == sample_rate_tbl[i]) { return sample_rate; } if (sample_rate < sample_rate_tbl[i]) { if (high) { return sample_rate_tbl[i]; } else { return sample_rate_tbl[i > 0 ? (i - 1) : 0]; } } } return sample_rate_tbl[rate_num - 1]; } /******************************************************* * Function name : app_audio_output_samplerate_select * Description : 将输入采样率与输出采样率进行匹配对比 * Parameter : * @sample_rate 输入采样率 * @high: 0 - 低一级采样率，1 - 高一级采样率 * Return : 匹配后的采样率 ********************* -HB ******************************/ int app_audio_output_samplerate_select(u32 sample_rate, u8 high) { return audio_dac_sample_rate_select(&dac_hdl, sample_rate, high); } /*----------------------------------------------------------------------------*/ /**@brief 获取输出采样率 @param input_rate: 输入采样率 @return 输出采样率 @note */ /*----------------------------------------------------------------------------*/ u32 audio_output_rate(int input_rate) { u32 out_rate = audio_output_nor_rate(); if (out_rate) { return out_rate; } #if (TCFG_REVERB_ENABLE || TCFG_MIC_EFFECT_ENABLE) if (input_rate > 48000) { return 48000; } #endif return app_audio_output_samplerate_select(input_rate, 1); } #if TCFG_USER_TWS_ENABLE #if AUDIO_SURROUND_CONFIG #define TWS_FUNC_ID_A2DP_EFF \ ((int)(('A' + '2' + 'D' + 'P') << (2 * 8)) | \ (int)(('E' + 'F' + 'F') << (1 * 8)) | \ (int)(('S' + 'Y' + 'N' + 'C') << (0 * 8))) /* *发环绕左右耳效果同步 * */ void audio_surround_voice_ctrl() { int state = tws_api_get_tws_state(); if (state & TWS_STA_SIBLING_CONNECTED) { if (a2dp_dec && a2dp_dec->sur && a2dp_dec->sur->surround) { if (!a2dp_dec->sur->surround_eff) { a2dp_dec->sur->surround_eff = 1; } else { a2dp_dec->sur->surround_eff = 0; } int a2dp_eff = a2dp_dec->sur->surround_eff; tws_api_send_data_to_sibling((u8 *)&a2dp_eff, sizeof(int), TWS_FUNC_ID_A2DP_EFF); } } } /* *左右耳环绕效果同步回调 * */ static void tws_a2dp_eff_align(void *data, u16 len, bool rx) { if (a2dp_dec && a2dp_dec->sur && a2dp_dec->sur->surround) { int a2dp_eff; memcpy(&a2dp_eff, data, sizeof(int)); a2dp_dec->sur->surround_eff = a2dp_eff; a2dp_surround_set(a2dp_eff); audio_surround_voice(a2dp_dec->sur, a2dp_dec->sur->surround_eff); } } REGISTER_TWS_FUNC_STUB(a2dp_align_eff) = { .func_id = TWS_FUNC_ID_A2DP_EFF, .func = tws_a2dp_eff_align, }; #endif//AUDIO_SURROUND_CONFIG #endif /* TCFG_USER_TWS_ENABLE */