3653 lines
96 KiB
C
3653 lines
96 KiB
C
#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 "application/eq_config.h"
|
||
#include "application/audio_energy_detect.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_syncts.h"
|
||
#include "audio_dec_eff.h"
|
||
#include "audio_codec_clock.h"
|
||
#include "audio_utils.h"
|
||
#if TCFG_USER_TWS_ENABLE
|
||
#include "bt_tws.h"
|
||
#endif/*TCFG_USER_TWS_ENABLE*/
|
||
#if (SYS_VOL_TYPE == VOL_TYPE_DIGITAL)
|
||
#include "audio_digital_vol.h"
|
||
#endif/*SYS_VOL_TYPE == VOL_TYPE_DIGITAL*/
|
||
|
||
#include "audio_plc.h"
|
||
#if TCFG_AUDIO_NOISE_GATE
|
||
#include "audio_noise_gate.h"
|
||
#endif/*TCFG_AUDIO_NOISE_GATE*/
|
||
|
||
#if TCFG_APP_FM_EMITTER_EN
|
||
#include "fm_emitter/fm_emitter_manage.h"
|
||
#endif
|
||
|
||
#if TCFG_AUDIO_ANC_ENABLE
|
||
#include "audio_anc.h"
|
||
#endif/*TCFG_AUDIO_ANC_ENABLE*/
|
||
|
||
#include "phone_message/phone_message.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
|
||
|
||
#ifdef CONFIG_256K_FLASH
|
||
#define CONFIG_MINI_BT_AUDIO_ENABLE 1
|
||
#else
|
||
#define CONFIG_MINI_BT_AUDIO_ENABLE 0
|
||
#endif
|
||
|
||
#define AUDIO_CODEC_SUPPORT_SYNC 1
|
||
|
||
#define A2DP_AUDIO_PLC_ENABLE 1
|
||
|
||
#if A2DP_AUDIO_PLC_ENABLE
|
||
#include "media/tech_lib/LFaudio_plc_api.h"
|
||
#endif
|
||
|
||
#define A2DP_RX_AND_AUDIO_DELAY 1
|
||
|
||
#define ESCO_DRC_EN 0 //通话下行增加限幅器处理，默认关闭
|
||
|
||
#if (!TCFG_DRC_ENABLE || !TCFG_PHONE_EQ_ENABLE)
|
||
#undef ESCO_DRC_EN 0
|
||
#define ESCO_DRC_EN 0
|
||
#endif
|
||
|
||
#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 int slience_samples;
|
||
|
||
|
||
struct tone_dec_hdl {
|
||
struct audio_decoder decoder;
|
||
void (*handler)(void *, int argc, int *argv);
|
||
void *priv;
|
||
};
|
||
|
||
struct a2dp_dec_hdl {
|
||
struct audio_decoder decoder;
|
||
struct audio_res_wait wait;
|
||
#if AUDIO_OUT_MIXER_ENABLE
|
||
struct audio_mixer_ch mix_ch;
|
||
#endif
|
||
enum audio_channel channel;
|
||
u8 start;
|
||
u8 ch;
|
||
s16 header_len;
|
||
u8 remain;
|
||
u8 eq_remain;
|
||
u8 fetch_lock;
|
||
u8 preempt;
|
||
u8 stream_error;
|
||
u8 new_frame;
|
||
u8 repair;
|
||
void *sample_detect;
|
||
void *syncts;
|
||
void *repair_pkt;
|
||
s16 repair_pkt_len;
|
||
u16 missed_num;
|
||
u16 repair_frames;
|
||
u16 overrun_seqn;
|
||
u16 slience_frames;
|
||
#if AUDIO_CODEC_SUPPORT_SYNC
|
||
u8 ts_start;
|
||
u8 sync_step;
|
||
void *ts_handle;
|
||
u32 timestamp;
|
||
u32 base_time;
|
||
#endif /*AUDIO_CODEC_SUPPORT_SYNC*/
|
||
#if A2DP_AUDIO_PLC_ENABLE
|
||
LFaudio_PLC_API *plc_ops;
|
||
void *plc_mem;
|
||
#endif /*A2DP_AUDIO_PLC_ENABLE*/
|
||
u32 mix_ch_event_params[3];
|
||
u32 pending_time;
|
||
u16 seqn;
|
||
u16 sample_rate;
|
||
int timer;
|
||
u32 coding_type;
|
||
u16 delay_time;
|
||
u16 detect_timer;
|
||
u8 underrun_feedback;
|
||
|
||
#if TCFG_EQ_ENABLE&&TCFG_BT_MUSIC_EQ_ENABLE
|
||
struct dec_eq_drc *eq_drc;
|
||
#endif//TCFG_BT_MUSIC_EQ_ENABLE
|
||
|
||
#if (SYS_VOL_TYPE == VOL_TYPE_DIGITAL)
|
||
dvol_handle *dvol;
|
||
#endif/*SYS_VOL_TYPE == VOL_TYPE_DIGITAL*/
|
||
};
|
||
|
||
|
||
struct esco_dec_hdl {
|
||
struct audio_decoder decoder;
|
||
struct audio_res_wait wait;
|
||
#if AUDIO_OUT_MIXER_ENABLE
|
||
struct audio_mixer_ch mix_ch;
|
||
#endif
|
||
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 repair;
|
||
u16 slience_frames;
|
||
void *syncts;
|
||
#if AUDIO_CODEC_SUPPORT_SYNC
|
||
void *ts_handle;
|
||
u8 ts_start;
|
||
u8 sync_step;
|
||
u8 preempt_state;
|
||
#endif
|
||
u32 mix_ch_event_params[3];
|
||
u8 esco_len;
|
||
u8 frame_err_len;
|
||
u8 remain;
|
||
|
||
int data[15];/*ALIGNED(4)*/
|
||
#if (SYS_VOL_TYPE == VOL_TYPE_DIGITAL)
|
||
dvol_handle *dvol;
|
||
#endif/*SYS_VOL_TYPE == VOL_TYPE_DIGITAL*/
|
||
|
||
#if TCFG_EQ_ENABLE&&TCFG_PHONE_EQ_ENABLE
|
||
struct dec_eq_drc *eq_drc;
|
||
#endif//TCFG_PHONE_EQ_ENABLE
|
||
u32 hash;
|
||
};
|
||
|
||
#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
|
||
|
||
void *audio_sync = NULL;
|
||
|
||
#if (TCFG_AUDIO_DAC_CONNECT_MODE == DAC_OUTPUT_LR)
|
||
#define MIX_POINTS_NUM 256
|
||
#else
|
||
#define MIX_POINTS_NUM 128
|
||
#endif
|
||
#if A2DP_RX_AND_AUDIO_DELAY
|
||
#define AUDIO_DAC_DELAY_TIME 30
|
||
#else
|
||
#define AUDIO_DAC_DELAY_TIME 50
|
||
#endif
|
||
|
||
#if (TCFG_AUDIO_DAC_CONNECT_MODE == DAC_OUTPUT_LR)
|
||
s16 dac_buff[6 * 1024];
|
||
#else
|
||
s16 dac_buff[2 * 1024 - 512];
|
||
#endif
|
||
#if AUDIO_CODEC_SUPPORT_SYNC
|
||
#define DEC_RUN_BY_ITSELF 0
|
||
#define DEC_PREEMTED_BY_PRIORITY 1
|
||
#define DEC_PREEMTED_BY_OUTSIDE 3
|
||
#define DEC_RESUME_BY_OUTSIDE 2
|
||
/* [>AAC解码需要加大同步和MIX的buffer用来提高异步效率<] */
|
||
|
||
s16 dac_sync_filt[24 * 2];
|
||
#endif
|
||
|
||
#if AUDIO_OUT_MIXER_ENABLE
|
||
s16 mix_buff[MIX_POINTS_NUM];
|
||
#endif
|
||
|
||
#define MAX_SRC_NUMBER 3
|
||
s16 audio_src_hw_filt[24 * 2 * MAX_SRC_NUMBER];
|
||
|
||
#define A2DP_TO_PCM_DEVICE_FORMAT 0//48000
|
||
#define A2DP_FLUENT_STREAM_MODE 1//流畅模式
|
||
#define A2DP_FLUENT_DETECT_INTERVAL 100000//ms 流畅播放延时检测时长
|
||
#if A2DP_FLUENT_STREAM_MODE
|
||
#define A2DP_MAX_PENDING_TIME 120
|
||
#else
|
||
#define A2DP_MAX_PENDING_TIME 40
|
||
#endif
|
||
|
||
#define A2DP_STREAM_NO_ERR 0
|
||
#define A2DP_STREAM_UNDERRUN 1
|
||
#define A2DP_STREAM_OVERRUN 2
|
||
#define A2DP_STREAM_MISSED 3
|
||
#define A2DP_STREAM_DECODE_ERR 4
|
||
#define A2DP_STREAM_LOW_UNDERRUN 5
|
||
|
||
/*OS_SEM dac_sem;*/
|
||
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;
|
||
struct audio_dac_hdl dac_hdl;
|
||
#if AUDIO_OUT_MIXER_ENABLE
|
||
struct audio_mixer mixer;
|
||
#endif
|
||
extern struct dac_platform_data dac_data;
|
||
extern struct audio_adc_hdl adc_hdl;
|
||
|
||
static u16 a2dp_delay_time;
|
||
static u8 a2dp_low_latency = 0;
|
||
static u16 drop_a2dp_timer;
|
||
static u16 a2dp_low_latency_seqn = 0;
|
||
extern const int CONFIG_LOW_LATENCY_ENABLE;
|
||
extern const int CONFIG_A2DP_DELAY_TIME;
|
||
extern const int CONFIG_A2DP_DELAY_TIME_LO;
|
||
extern const int CONFIG_A2DP_SBC_DELAY_TIME_LO;
|
||
extern const int const_surround_en;
|
||
|
||
struct a2dp_dec_hdl *a2dp_dec = NULL;
|
||
struct esco_dec_hdl *esco_dec = NULL;
|
||
|
||
extern int platform_device_sbc_init();
|
||
|
||
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 int bt_audio_sync_nettime_select(u8 basetime);
|
||
extern u32 bt_audio_sync_lat_time(void);
|
||
void audio_syncts_add(void *priv);
|
||
void audio_syncts_del(void *priv);
|
||
void audio_output_open(void *priv, u32 sample_rate);
|
||
int audio_dac_start_pre(struct audio_dac_hdl *dac);
|
||
|
||
void *a2dp_play_sync_open(u8 channel, u32 sample_rate, u32 output_rate, u32 coding_type);
|
||
|
||
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 audio_fade_in_fade_out(u8 left_gain, u8 right_gain);
|
||
|
||
void set_source_sample_rate(u16 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();
|
||
}
|
||
|
||
|
||
#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);
|
||
}
|
||
local_irq_enable();
|
||
log_i("audio_decoder_task_add_probe:%d\n", task->wakeup_timer);
|
||
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 TCFG_AUDIO_OUTPUT_IIS
|
||
/*唤醒源为输出目标中断*/
|
||
if (!audio_iis_is_working()) {
|
||
return audio_decoder_wakeup_select(0);
|
||
}
|
||
|
||
int err = audio_iis_irq_resume_decoder(a2dp_low_latency ? 2 : AUDIO_DECODE_TASK_WAKEUP_TIME, NULL, audio_decoder_wakeup_timer);
|
||
#else
|
||
/*唤醒源为输出目标中断*/
|
||
if (!audio_dac_is_working(&dac_hdl)) {
|
||
return audio_decoder_wakeup_select(0);
|
||
}
|
||
|
||
/*int err = audio_dac_set_irq_time(&dac_hdl, a2dp_low_latency ? 2 : AUDIO_DECODE_TASK_WAKEUP_TIME);*/
|
||
int err = audio_dac_irq_enable(&dac_hdl, a2dp_low_latency ? 2 : AUDIO_DECODE_TASK_WAKEUP_TIME,
|
||
NULL, audio_decoder_wakeup_timer);
|
||
#endif
|
||
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()
|
||
{
|
||
/* putchar('A'); */
|
||
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);
|
||
/*r_printf("resuem\n");*/
|
||
}
|
||
}
|
||
|
||
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);
|
||
}
|
||
}
|
||
}
|
||
|
||
static int _audio_output_handler(s16 *data, u16 len)
|
||
{
|
||
|
||
int rlen = len;
|
||
int wlen = 0;
|
||
|
||
/*os_sem_set(&dac_sem, 0);*/
|
||
/* 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_AUDIO_OUTPUT_IIS
|
||
u8 dac_connect_mode = audio_dac_get_channel(&dac_hdl);
|
||
if (dac_connect_mode == DAC_OUTPUT_LR) {
|
||
wlen = audio_iis_output_write(data, len);
|
||
} else {
|
||
s16 *mono_data = (s16 *)data;
|
||
s16 point_num = 0;
|
||
u16 remain_points = (len >> 1);
|
||
s16 two_ch_data[IIS_MONO_TO_DUAL_POINTS * 2];
|
||
|
||
do {
|
||
point_num = IIS_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);
|
||
int tmp_len = audio_iis_output_write(two_ch_data, point_num << 2);
|
||
wlen += tmp_len;
|
||
remain_points -= (tmp_len >> 2);
|
||
if (tmp_len < (point_num << 2)) {
|
||
break;
|
||
}
|
||
mono_data += point_num;
|
||
} while (remain_points);
|
||
wlen = wlen >> 1;
|
||
}
|
||
|
||
#elif TCFG_APP_FM_EMITTER_EN
|
||
fm_emitter_cbuf_write((u8 *)data, len);
|
||
#else
|
||
wlen = audio_dac_write(&dac_hdl, data, len);
|
||
#endif
|
||
|
||
return wlen;
|
||
}
|
||
|
||
|
||
static int audio_output_handler(s16 *data, u16 len)
|
||
{
|
||
#if AUDIO_OUT_MIXER_ENABLE
|
||
return _audio_output_handler(data, len);
|
||
#else
|
||
int wlen = 0;
|
||
if (slience_samples) {
|
||
u16 points = ARRAY_SIZE(dac_buff);
|
||
int slience_len = (slience_samples < points ? slience_samples : points) * 2;
|
||
wlen = _audio_output_handler(dac_buff, slience_len);
|
||
slience_samples -= wlen / 2;
|
||
wlen = 0;
|
||
}
|
||
if (slience_samples == 0) {
|
||
wlen = _audio_output_handler(data, len);
|
||
}
|
||
return wlen;
|
||
|
||
#endif
|
||
}
|
||
|
||
#if AUDIO_OUT_EFFECT_ENABLE
|
||
static int audio_output_effect_handler(s16 *data, u16 len)
|
||
{
|
||
if (!audio_out_effect) {
|
||
return audio_output_handler(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 = audio_output_handler(data, len);
|
||
if (wlen == len) {
|
||
audio_out_effect->remain = 0;
|
||
} else {
|
||
audio_out_effect->remain = 1;
|
||
}
|
||
return wlen;
|
||
}
|
||
#endif
|
||
|
||
int audio_output_data(s16 *data, u16 len)
|
||
{
|
||
#if AUDIO_OUT_EFFECT_ENABLE
|
||
return audio_output_effect_handler(data, len);
|
||
#else
|
||
return audio_output_handler(data, len);
|
||
#endif
|
||
}
|
||
int audio_output_data_a2dp(void *p, s16 *data, u16 len)
|
||
{
|
||
#if !AUDIO_OUT_MIXER_ENABLE
|
||
struct a2dp_dec_hdl *dec = p;
|
||
if (dec->start == 1) {
|
||
dec->start = 2;
|
||
audio_output_open(NULL, dec->sample_rate);
|
||
audio_syncts_add(dec->mix_ch_event_params);
|
||
}
|
||
#endif
|
||
return audio_output_data(data, len);
|
||
}
|
||
|
||
int audio_output_data_esco(void *p, s16 *data, u16 len)
|
||
{
|
||
#if !AUDIO_OUT_MIXER_ENABLE
|
||
struct esco_dec_hdl *dec = (struct esco_dec_hdl *)p;
|
||
if (dec->start == 1) {
|
||
dec->start = 2;
|
||
audio_output_open(NULL, dec->decoder.fmt.sample_rate);
|
||
audio_syncts_add(dec->mix_ch_event_params);
|
||
}
|
||
#endif
|
||
return audio_output_data(data, len);
|
||
}
|
||
|
||
|
||
|
||
#if AUDIO_OUTPUT_AUTOMUTE
|
||
|
||
void audio_mix_out_automute_mute(u8 mute)
|
||
{
|
||
printf(">>>>>>>>>>>>>>>>>>>> %s\n", mute ? ("MUTE") : ("UNMUTE"));
|
||
if (mute) {
|
||
app_audio_mute(AUDIO_MUTE_DEFAULT);
|
||
} else {
|
||
app_audio_mute(AUDIO_UNMUTE_DEFAULT);
|
||
}
|
||
}
|
||
|
||
/* #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 (ch == dac_hdl.channel) {
|
||
audio_mix_out_automute_mute(event);
|
||
}
|
||
}
|
||
|
||
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);
|
||
audio_mix_out_automute_mute(mute);
|
||
}
|
||
}
|
||
|
||
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 = dac_hdl.channel;
|
||
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
|
||
|
||
#if AUDIO_OUT_EFFECT_ENABLE
|
||
|
||
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;
|
||
}
|
||
|
||
static int mix_output_handler(struct audio_mixer *mixer, s16 *data, u16 len);
|
||
static void audio_out_effect_close(void)
|
||
{
|
||
if (!audio_out_effect) {
|
||
return ;
|
||
}
|
||
audio_out_eq_drc_free(audio_out_effect);
|
||
audio_out_effect = NULL;
|
||
}
|
||
|
||
static 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;
|
||
}
|
||
|
||
static 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
|
||
u8 dac_connect_mode = audio_dac_get_channel(&dac_hdl);
|
||
if (dac_connect_mode == DAC_OUTPUT_LR) {
|
||
ch_num = 2;
|
||
} else {
|
||
ch_num = 1;
|
||
}
|
||
#endif//TCFG_APP_FM_EMITTER_EN
|
||
|
||
audio_out_effect = audio_out_eq_drc_setup(priv, (eq_output_cb)mix_output_handler, sample_rate, ch_num, 1, 0);
|
||
return 0;
|
||
}
|
||
|
||
|
||
#if AUDIO_OUT_MIXER_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
|
||
#endif/*AUDIO_OUT_EFFECT_ENABLE*/
|
||
|
||
extern void audio_adc_mic_demo(u8 mic_idx, u8 gain, u8 mic_2_dac);
|
||
extern void dac_analog_power_control(u8 en);
|
||
extern void audio_dac_output_enable(struct audio_dac_hdl *dac);
|
||
extern void audio_dac_output_disable(struct audio_dac_hdl *dac);
|
||
|
||
u8 audio_fast_mode = 0;
|
||
void audio_fast_mode_test()
|
||
{
|
||
audio_fast_mode = 1;
|
||
audio_dac_set_volume(&dac_hdl, app_audio_get_volume(APP_AUDIO_CURRENT_STATE));
|
||
dac_analog_power_control(1);////将关闭基带，不开可发现，不可连接
|
||
audio_dac_start(&dac_hdl);
|
||
audio_adc_mic_demo(AUDIO_ADC_MIC_CH, 10, 1);
|
||
|
||
}
|
||
|
||
u8 dac_power_off_flag = 1;
|
||
u8 is_dac_power_off()
|
||
{
|
||
if (a2dp_dec || esco_dec || get_call_status() != BT_CALL_HANGUP) {
|
||
return 1;
|
||
}
|
||
return dac_power_off_flag;
|
||
}
|
||
|
||
void dac_analog_power_control(u8 en)
|
||
{
|
||
#ifdef CONFIG_CURRENT_SOUND_DEAL_ENABLE
|
||
if (en) {
|
||
dac_power_off_flag = 0;
|
||
audio_dac_output_enable(&dac_hdl);
|
||
} else {
|
||
#if TCFG_AUDIO_ANC_ENABLE
|
||
if (!anc_status_get()) {
|
||
puts("anc dac_power_off");
|
||
/*dac_power_off();*/
|
||
audio_dac_output_disable(&dac_hdl);
|
||
}
|
||
#else
|
||
puts("dac_power_off");
|
||
audio_dac_output_disable(&dac_hdl);
|
||
/*dac_power_off();*/
|
||
#endif
|
||
dac_power_off_flag = 1;
|
||
}
|
||
#endif
|
||
}
|
||
int audio_dac_add_slience_samples(int samples)
|
||
{
|
||
slience_samples = samples;
|
||
return 0;
|
||
}
|
||
|
||
void audio_output_open(void *priv, u32 sample_rate)
|
||
{
|
||
slience_samples = 0;
|
||
#if AUDIO_OUTPUT_AUTOMUTE
|
||
audio_energy_detect_sample_rate_update(mix_out_automute_hdl, sample_rate);
|
||
#endif //#if AUDIO_OUTPUT_AUTOMUTE
|
||
|
||
#if TCFG_AUDIO_OUTPUT_IIS
|
||
audio_iis_output_set_srI(audio_mixer_get_sample_rate(priv));
|
||
audio_iis_output_start(1);
|
||
#elif TCFG_APP_FM_EMITTER_EN
|
||
|
||
#else
|
||
if (A2DP_TO_PCM_DEVICE_FORMAT && a2dp_dec && a2dp_dec->start) {
|
||
audio_dac_set_sample_rate(&dac_hdl, A2DP_TO_PCM_DEVICE_FORMAT);
|
||
} else {
|
||
audio_dac_set_sample_rate(&dac_hdl, sample_rate);
|
||
}
|
||
audio_dac_set_volume(&dac_hdl, app_audio_get_volume(APP_AUDIO_CURRENT_STATE));
|
||
audio_dac_start(&dac_hdl);
|
||
dac_analog_power_control(1);
|
||
#if AUDIO_OUT_MIXER_ENABLE
|
||
g_printf("MIXER_EVENT_CH_OPEN=%d\n", dac_power_off_flag);
|
||
audio_dac_set_input_correct_callback(&dac_hdl,
|
||
(void *)priv,
|
||
(void (*)(void *, int))audio_mixer_position_correct);
|
||
#endif
|
||
|
||
#endif
|
||
#if AUDIO_OUT_EFFECT_ENABLE
|
||
if (!audio_out_effect_dis) {
|
||
audio_out_effect_open(priv, sample_rate);
|
||
}
|
||
#endif
|
||
}
|
||
|
||
void audio_output_close(void *priv)
|
||
{
|
||
audio_dac_set_input_correct_callback(&dac_hdl, NULL, NULL);
|
||
#if AUDIO_OUT_EFFECT_ENABLE
|
||
audio_out_effect_close();
|
||
#endif
|
||
|
||
#if TCFG_AUDIO_OUTPUT_IIS
|
||
audio_iis_output_stop();
|
||
#elif TCFG_APP_FM_EMITTER_EN
|
||
|
||
#else
|
||
audio_dac_set_protect_time(&dac_hdl, 0, NULL, NULL);
|
||
audio_dac_stop(&dac_hdl);
|
||
dac_analog_power_control(0);
|
||
g_printf("MIXER_EVENT_CH_CLOSE=%d\n", dac_power_off_flag);
|
||
if (audio_fast_mode) {
|
||
audio_fast_mode_test();
|
||
}
|
||
#endif
|
||
}
|
||
|
||
#if AUDIO_OUT_MIXER_ENABLE
|
||
static void mixer_event_handler(struct audio_mixer *mixer, int event)
|
||
{
|
||
switch (event) {
|
||
case MIXER_EVENT_CH_OPEN:
|
||
if (audio_mixer_get_start_ch_num(mixer) == 1) {
|
||
audio_output_open(mixer, audio_mixer_get_sample_rate(mixer));
|
||
}
|
||
break;
|
||
case MIXER_EVENT_CH_CLOSE:
|
||
if (audio_mixer_get_ch_num(mixer) == 0) {
|
||
audio_output_close(mixer);
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
#endif
|
||
|
||
static int mix_probe_handler(struct audio_mixer *mixer)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
#define IIS_MONO_TO_DUAL_POINTS 64
|
||
static inline void audio_pcm_mono_to_dual(s16 *dual_pcm, s16 *mono_pcm, int points);
|
||
static int mix_output_handler(struct audio_mixer *mixer, s16 *data, u16 len)
|
||
{
|
||
return audio_output_handler(data, len);
|
||
}
|
||
|
||
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
|
||
};
|
||
|
||
void audio_syncts_add(void *priv)
|
||
{
|
||
if (priv) {
|
||
u32 *params = (u32 *)priv;
|
||
struct audio_mixer_ch *ch = (struct audio_mixer_ch *)params[0];
|
||
u32 base_time = params[2];
|
||
#if defined(TCFG_AUDIO_OUTPUT_IIS) && TCFG_AUDIO_OUTPUT_IIS
|
||
audio_iis_add_syncts_handle((void *)params[1]);
|
||
#else
|
||
audio_dac_add_syncts_handle(&dac_hdl, (void *)params[1]);
|
||
#endif
|
||
u32 current_time = (bt_audio_sync_lat_time() * 625 * TIME_US_FACTOR);
|
||
u32 time_diff = ((base_time - current_time) & 0xffffffff) / TIME_US_FACTOR;
|
||
/*printf("-----base time : %u, current_time : %u------\n", base_time, current_time);*/
|
||
if (time_diff < 500000) {
|
||
int buf_frame = audio_dac_buffered_frames(&dac_hdl);
|
||
#if defined(TCFG_AUDIO_OUTPUT_IIS) && TCFG_AUDIO_OUTPUT_IIS
|
||
buf_frame = audio_iis_buffered_frames();
|
||
#endif
|
||
|
||
#if AUDIO_OUT_MIXER_ENABLE
|
||
int sample_rate = audio_mixer_get_sample_rate(&mixer);
|
||
#else
|
||
int sample_rate = audio_dac_get_sample_rate(&dac_hdl);
|
||
#endif
|
||
int slience_frames = (u64)time_diff * sample_rate / 1000000 - buf_frame;
|
||
if (slience_frames < 0) {
|
||
slience_frames = 0;
|
||
}
|
||
/*printf("-------slience_frames : %d-------\n", slience_frames);*/
|
||
sound_pcm_update_frame_num((void *)params[1], -slience_frames);
|
||
#if AUDIO_OUT_MIXER_ENABLE
|
||
audio_mixer_ch_add_slience_samples(ch, slience_frames * dac_hdl.channel);
|
||
#else
|
||
audio_dac_add_slience_samples(slience_frames * dac_hdl.channel);
|
||
#endif
|
||
}
|
||
}
|
||
}
|
||
|
||
void audio_syncts_del(void *priv)
|
||
{
|
||
if (priv) {
|
||
u32 *params = (u32 *)priv;
|
||
#if defined(TCFG_AUDIO_OUTPUT_IIS) && TCFG_AUDIO_OUTPUT_IIS
|
||
audio_iis_remove_syncts_handle((void *)params[1]);
|
||
#else
|
||
audio_dac_remove_syncts_handle(&dac_hdl, (void *)params[1]);
|
||
#endif
|
||
}
|
||
}
|
||
void audio_mix_ch_event_handler(void *priv, int event)
|
||
{
|
||
switch (event) {
|
||
case MIXER_EVENT_CH_OPEN:
|
||
audio_syncts_add(priv);
|
||
break;
|
||
case MIXER_EVENT_CH_CLOSE:
|
||
audio_syncts_del(priv);
|
||
break;
|
||
}
|
||
}
|
||
|
||
#define RB16(b) (u16)(((u8 *)b)[0] << 8 | (((u8 *)b))[1])
|
||
#define RB32(b) (u32)(((u8 *)b)[0] << 24 | (((u8 *)b))[1] << 16 | (((u8 *)b))[2] << 8 | (((u8 *)b))[3])
|
||
|
||
static int get_rtp_header_len(u8 new_frame, u8 *buf, int len)
|
||
{
|
||
int ext, csrc;
|
||
int byte_len;
|
||
int header_len = 0;
|
||
u8 *data = buf;
|
||
|
||
csrc = buf[0] & 0x0f;
|
||
ext = buf[0] & 0x10;
|
||
|
||
byte_len = 12 + 4 * csrc;
|
||
buf += byte_len;
|
||
|
||
if (ext) {
|
||
ext = (RB16(buf + 2) + 1) << 2;
|
||
}
|
||
|
||
if (new_frame) {
|
||
header_len = byte_len + ext + 1;
|
||
} else {
|
||
header_len = byte_len + ext;
|
||
}
|
||
if (a2dp_dec->coding_type == AUDIO_CODING_SBC) {
|
||
while (data[header_len] != 0x9c) {
|
||
if (++header_len > len) {
|
||
return len;
|
||
}
|
||
}
|
||
}
|
||
|
||
return header_len;
|
||
}
|
||
|
||
__attribute__((weak))
|
||
int audio_dac_get_channel(struct audio_dac_hdl *p)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
void __a2dp_drop_frame(void *p)
|
||
{
|
||
int len;
|
||
u8 *frame;
|
||
|
||
#if 0
|
||
int num = a2dp_media_get_packet_num();
|
||
if (num > 1) {
|
||
for (int i = 0; i < num; i++) {
|
||
len = a2dp_media_get_packet(&frame);
|
||
if (len <= 0) {
|
||
break;
|
||
}
|
||
//printf("a2dp_drop_frame: %d\n", len);
|
||
a2dp_media_free_packet(frame);
|
||
}
|
||
}
|
||
#else
|
||
while (1) {
|
||
len = a2dp_media_try_get_packet(&frame);
|
||
if (len <= 0) {
|
||
break;
|
||
}
|
||
a2dp_media_free_packet(frame);
|
||
}
|
||
|
||
#endif
|
||
|
||
}
|
||
|
||
static void __a2dp_clean_frame_by_number(struct a2dp_dec_hdl *dec, u16 num)
|
||
{
|
||
u16 end_seqn = dec->seqn + num;
|
||
if (end_seqn == 0) {
|
||
end_seqn++;
|
||
}
|
||
/*__a2dp_drop_frame(NULL);*/
|
||
/*dec->drop_seqn = end_seqn;*/
|
||
a2dp_media_clear_packet_before_seqn(end_seqn);
|
||
}
|
||
|
||
static void a2dp_tws_clean_frame(void *arg)
|
||
{
|
||
u8 master = 0;
|
||
#if TCFG_USER_TWS_ENABLE
|
||
if (tws_api_get_role() == TWS_ROLE_MASTER) {
|
||
master = 1;
|
||
}
|
||
#else
|
||
master = 1;
|
||
#endif
|
||
if (!master) {
|
||
return;
|
||
}
|
||
|
||
int msecs = a2dp_media_get_remain_play_time(0);
|
||
if (msecs <= 0) {
|
||
return;
|
||
}
|
||
|
||
if (a2dp_dec && a2dp_dec->fetch_lock) {
|
||
return;
|
||
}
|
||
int len = 0;
|
||
u16 seqn = 0;
|
||
u8 *packet = a2dp_media_fetch_packet(&len, NULL);
|
||
if (!packet) {
|
||
return;
|
||
}
|
||
seqn = RB16(packet + 2) + 10;
|
||
if (seqn == 0) {
|
||
seqn = 1;
|
||
}
|
||
a2dp_media_clear_packet_before_seqn(seqn);
|
||
}
|
||
|
||
static u8 a2dp_suspend = 0;
|
||
static u32 a2dp_resume_time = 0;
|
||
|
||
|
||
|
||
int a2dp_decoder_pause(void)
|
||
{
|
||
if (a2dp_dec) {
|
||
return audio_decoder_pause(&(a2dp_dec->decoder));
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
int a2dp_decoder_start(void)
|
||
{
|
||
if (a2dp_dec) {
|
||
return audio_decoder_start(&(a2dp_dec->decoder));
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
u8 get_a2dp_drop_frame_flag()
|
||
{
|
||
if (a2dp_dec) {
|
||
return a2dp_dec->timer;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
void a2dp_drop_frame_start()
|
||
{
|
||
if (a2dp_dec && (a2dp_dec->timer == 0)) {
|
||
a2dp_dec->timer = sys_timer_add(NULL, __a2dp_drop_frame, 50);
|
||
a2dp_tws_audio_conn_offline();
|
||
}
|
||
}
|
||
|
||
void a2dp_drop_frame_stop()
|
||
{
|
||
if (a2dp_dec && a2dp_dec->timer) {
|
||
sys_timer_del(a2dp_dec->timer);
|
||
a2dp_tws_audio_conn_delete();
|
||
a2dp_dec->timer = 0;
|
||
}
|
||
}
|
||
|
||
static void a2dp_dec_set_output_channel(struct a2dp_dec_hdl *dec)
|
||
{
|
||
int state = 0;
|
||
enum audio_channel channel;
|
||
u8 dac_connect_mode = 0;
|
||
|
||
#if TCFG_USER_TWS_ENABLE
|
||
state = tws_api_get_tws_state();
|
||
if (state & TWS_STA_SIBLING_CONNECTED) {
|
||
channel = tws_api_get_local_channel() == 'L' ? AUDIO_CH_L : AUDIO_CH_R;
|
||
dec->ch = 1;
|
||
} else {
|
||
dac_connect_mode = audio_dac_get_channel(&dac_hdl);
|
||
if (dac_connect_mode == DAC_OUTPUT_LR) {
|
||
channel = AUDIO_CH_LR;
|
||
dec->ch = 2;
|
||
} else {
|
||
channel = AUDIO_CH_DIFF;
|
||
dec->ch = 1;
|
||
}
|
||
}
|
||
|
||
#else
|
||
dac_connect_mode = audio_dac_get_channel(&dac_hdl);
|
||
if (dac_connect_mode == DAC_OUTPUT_LR) {
|
||
channel = AUDIO_CH_LR;
|
||
dec->ch = 2;
|
||
} else {
|
||
channel = AUDIO_CH_DIFF;
|
||
dec->ch = 1;
|
||
}
|
||
#endif
|
||
|
||
#if TCFG_APP_FM_EMITTER_EN
|
||
channel = AUDIO_CH_LR;
|
||
#endif
|
||
if (channel != dec->channel) {
|
||
printf("set_channel: %d\n", channel);
|
||
audio_decoder_set_output_channel(&dec->decoder, channel);
|
||
dec->channel = channel;
|
||
#if TCFG_EQ_ENABLE&&TCFG_BT_MUSIC_EQ_ENABLE
|
||
if (dec->eq_drc && dec->eq_drc->eq) {
|
||
audio_eq_set_channel(dec->eq_drc->eq, dec->ch);
|
||
}
|
||
#endif
|
||
}
|
||
}
|
||
|
||
/*
|
||
*
|
||
*/
|
||
static int a2dp_decoder_set_timestamp(struct a2dp_dec_hdl *dec, u16 seqn)
|
||
{
|
||
#if AUDIO_CODEC_SUPPORT_SYNC
|
||
u32 timestamp;
|
||
|
||
timestamp = a2dp_audio_update_timestamp(dec->ts_handle, seqn, audio_syncts_get_dts(dec->syncts));
|
||
if (!dec->ts_start) {
|
||
dec->ts_start = 1;
|
||
dec->mix_ch_event_params[2] = timestamp;
|
||
} else {
|
||
audio_syncts_next_pts(dec->syncts, timestamp);
|
||
audio_syncts_update_sample_rate(dec->syncts, a2dp_audio_sample_rate(dec->ts_handle));;
|
||
}
|
||
dec->timestamp = timestamp;
|
||
/*printf("timestamp : %d, %d\n", seqn, timestamp / TIME_US_FACTOR / 625);*/
|
||
#endif
|
||
return 0;
|
||
}
|
||
|
||
static bool a2dp_audio_is_underrun(struct a2dp_dec_hdl *dec)
|
||
{
|
||
#if AUDIO_CODEC_SUPPORT_SYNC
|
||
if (dec->ts_start != 2) {
|
||
return false;
|
||
}
|
||
#endif
|
||
int underrun_time = a2dp_low_latency ? 1 : 20;
|
||
#if defined(TCFG_AUDIO_OUTPUT_IIS) && TCFG_AUDIO_OUTPUT_IIS
|
||
if (audio_iis_data_time() < underrun_time) {
|
||
return true;
|
||
}
|
||
#else
|
||
if (audio_dac_data_time(&dac_hdl) < underrun_time) {
|
||
return true;
|
||
}
|
||
#endif
|
||
return false;
|
||
}
|
||
|
||
static bool a2dp_bt_rx_overrun(void)
|
||
{
|
||
return a2dp_media_get_remain_buffer_size() < 768 ? true : false;
|
||
}
|
||
|
||
static void a2dp_decoder_stream_free(struct a2dp_dec_hdl *dec, void *packet)
|
||
{
|
||
if (packet) {
|
||
a2dp_media_free_packet(packet);
|
||
}
|
||
|
||
if ((void *)packet == (void *)dec->repair_pkt) {
|
||
dec->repair_pkt = NULL;
|
||
}
|
||
|
||
if (dec->repair_pkt) {
|
||
a2dp_media_free_packet(dec->repair_pkt);
|
||
dec->repair_pkt = NULL;
|
||
}
|
||
dec->repair_pkt_len = 0;
|
||
}
|
||
|
||
static void a2dp_stream_underrun_feedback(void *priv);
|
||
static int a2dp_audio_delay_time(struct a2dp_dec_hdl *dec);
|
||
#define a2dp_seqn_before(a, b) ((a < b && (u16)(b - a) < 1000) || (a > b && (u16)(a - b) > 1000))
|
||
static int a2dp_buffered_stream_sample_rate(struct a2dp_dec_hdl *dec, u8 *from_packet, u16 *end_seqn)
|
||
{
|
||
u8 *packet = from_packet;
|
||
int len = 0;
|
||
int sample_rate = 0;
|
||
|
||
if (!dec->sample_detect) {
|
||
return dec->sample_rate;
|
||
}
|
||
|
||
a2dp_frame_sample_detect_start(dec->sample_detect, a2dp_media_dump_rx_time(packet));
|
||
while (1) {
|
||
packet = a2dp_media_fetch_packet(&len, packet);
|
||
if (!packet) {
|
||
break;
|
||
}
|
||
sample_rate = a2dp_frame_sample_detect(dec->sample_detect, packet, len, a2dp_media_dump_rx_time(packet));
|
||
*end_seqn = RB16(packet + 2);
|
||
}
|
||
|
||
/*printf("A2DP sample detect : %d - %d\n", sample_rate, dec->sample_rate);*/
|
||
return sample_rate;
|
||
}
|
||
|
||
static int a2dp_stream_overrun_handler(struct a2dp_dec_hdl *dec, u8 **frame, int *len)
|
||
{
|
||
u8 *packet = NULL;
|
||
int rlen = 0;
|
||
|
||
int msecs = 0;
|
||
int overrun = 0;
|
||
int sample_rate = 0;
|
||
u16 from_seqn = RB16(dec->repair_pkt + 2);
|
||
u16 seqn = from_seqn;
|
||
u16 end_seqn = 0;
|
||
overrun = 1;
|
||
while (1) {
|
||
msecs = a2dp_audio_delay_time(dec);
|
||
if (msecs < (CONFIG_A2DP_DELAY_TIME + 50) && !a2dp_bt_rx_overrun()) {
|
||
break;
|
||
}
|
||
overrun = 0;
|
||
rlen = a2dp_media_try_get_packet(&packet);
|
||
if (rlen <= 0) {
|
||
break;
|
||
}
|
||
|
||
sample_rate = a2dp_buffered_stream_sample_rate(dec, dec->repair_pkt, &end_seqn);
|
||
a2dp_decoder_stream_free(dec, NULL);
|
||
dec->repair_pkt = packet;
|
||
dec->repair_pkt_len = rlen;
|
||
seqn = RB16(packet + 2);
|
||
if (!a2dp_seqn_before(seqn, dec->overrun_seqn)) {
|
||
*frame = packet;
|
||
*len = rlen;
|
||
/*printf("------> end frame : %d\n", dec->overrun_seqn);*/
|
||
return 1;
|
||
}
|
||
|
||
if (/*sample_rate < (dec->sample_rate * 4 / 5) || */sample_rate > (dec->sample_rate * 4 / 3)) {
|
||
if (a2dp_seqn_before(dec->overrun_seqn, end_seqn)) {
|
||
dec->overrun_seqn = end_seqn;
|
||
}
|
||
continue;
|
||
}
|
||
}
|
||
if (overrun) {
|
||
/*putchar('+');*/
|
||
/* dec->overrun_seqn++; */
|
||
} else {
|
||
/*putchar('-');*/
|
||
}
|
||
|
||
*frame = dec->repair_pkt;
|
||
*len = dec->repair_pkt_len;
|
||
return 0;
|
||
}
|
||
|
||
static int a2dp_stream_missed_handler(struct a2dp_dec_hdl *dec, u8 **frame, int *len)
|
||
{
|
||
int msecs = a2dp_audio_delay_time(dec);
|
||
*frame = dec->repair_pkt;
|
||
*len = dec->repair_pkt_len;
|
||
if ((msecs >= (dec->delay_time + 50) || a2dp_bt_rx_overrun()) || --dec->missed_num == 0) {
|
||
/*putchar('M');*/
|
||
return 1;
|
||
}
|
||
/*putchar('m');*/
|
||
return 0;
|
||
}
|
||
|
||
static int a2dp_stream_underrun_handler(struct a2dp_dec_hdl *dec, u8 **packet)
|
||
{
|
||
|
||
if (!a2dp_audio_is_underrun(dec)) {
|
||
putchar('x');
|
||
return 0;
|
||
}
|
||
putchar('X');
|
||
if (dec->stream_error != A2DP_STREAM_UNDERRUN) {
|
||
if (!dec->stream_error) {
|
||
a2dp_stream_underrun_feedback(dec);
|
||
}
|
||
dec->stream_error = a2dp_low_latency ? A2DP_STREAM_LOW_UNDERRUN : A2DP_STREAM_UNDERRUN;
|
||
dec->repair = a2dp_low_latency ? 0 : 1;
|
||
}
|
||
*packet = dec->repair_pkt;
|
||
dec->repair_frames++;
|
||
return dec->repair_pkt_len;
|
||
}
|
||
|
||
static int a2dp_stream_error_filter(struct a2dp_dec_hdl *dec, u8 new_packet, u8 *packet, int len)
|
||
{
|
||
int err = 0;
|
||
|
||
if (dec->coding_type == AUDIO_CODING_AAC) {
|
||
dec->header_len = get_rtp_header_len(dec->new_frame, packet, len);
|
||
dec->new_frame = 0;
|
||
} else {
|
||
dec->header_len = get_rtp_header_len(1, packet, len);
|
||
}
|
||
|
||
if (dec->header_len >= len) {
|
||
printf("##A2DP header error : %d\n", dec->header_len);
|
||
a2dp_decoder_stream_free(dec, packet);
|
||
return -EFAULT;
|
||
}
|
||
|
||
u16 seqn = RB16(packet + 2);
|
||
if (new_packet) {
|
||
if (dec->stream_error == A2DP_STREAM_UNDERRUN) {
|
||
int missed_frames = (u16)(seqn - dec->seqn) - 1;
|
||
if (missed_frames > dec->repair_frames) {
|
||
dec->stream_error = A2DP_STREAM_MISSED;
|
||
dec->missed_num = missed_frames - dec->repair_frames + 1;
|
||
/*printf("case 0 : %d, %d\n", missed_frames, dec->repair_frames);*/
|
||
err = -EAGAIN;
|
||
} else if (missed_frames < dec->repair_frames) {
|
||
dec->stream_error = A2DP_STREAM_OVERRUN;
|
||
dec->overrun_seqn = seqn + dec->repair_frames - missed_frames;
|
||
/*printf("case 1 : %d, %d, seqn : %d, %d\n", missed_frames, dec->repair_frames, seqn, dec->overrun_seqn); */
|
||
err = -EAGAIN;
|
||
}
|
||
} else if (!dec->stream_error && (u16)(seqn - dec->seqn) > 1) {
|
||
dec->stream_error = A2DP_STREAM_MISSED;
|
||
if (a2dp_audio_delay_time(dec) < dec->delay_time) {
|
||
dec->missed_num = (u16)(seqn - dec->seqn);
|
||
err = -EAGAIN;
|
||
}
|
||
int pkt_len;
|
||
void *head = a2dp_media_fetch_packet(&pkt_len, NULL);
|
||
/*printf("case 2 : %d, %d, pkt : 0x%x, 0x%x\n", seqn, dec->seqn, (u32)head, (u32)packet);*/
|
||
if (dec->missed_num > 30) {
|
||
printf("##A serious mistake : A2DP stream missed too much, %d\n", dec->missed_num);
|
||
dec->missed_num = 30;
|
||
}
|
||
}
|
||
dec->repair_frames = 0;
|
||
}
|
||
if (!err && new_packet) {
|
||
dec->seqn = seqn;
|
||
}
|
||
dec->repair_pkt = packet;
|
||
dec->repair_pkt_len = len;
|
||
return err;
|
||
}
|
||
|
||
static int a2dp_dec_get_frame(struct audio_decoder *decoder, u8 **frame)
|
||
{
|
||
struct a2dp_dec_hdl *dec = container_of(decoder, struct a2dp_dec_hdl, decoder);
|
||
u8 *packet = NULL;
|
||
int len = 0;
|
||
u8 new_packet = 0;
|
||
|
||
try_again:
|
||
switch (dec->stream_error) {
|
||
case A2DP_STREAM_OVERRUN:
|
||
new_packet = a2dp_stream_overrun_handler(dec, &packet, &len);
|
||
break;
|
||
case A2DP_STREAM_MISSED:
|
||
new_packet = a2dp_stream_missed_handler(dec, &packet, &len);
|
||
break;
|
||
default:
|
||
len = a2dp_media_try_get_packet(&packet);
|
||
if (len <= 0) {
|
||
len = a2dp_stream_underrun_handler(dec, &packet);
|
||
} else {
|
||
a2dp_decoder_stream_free(dec, NULL);
|
||
new_packet = 1;
|
||
}
|
||
break;
|
||
}
|
||
|
||
if (len <= 0) {
|
||
return 0;
|
||
}
|
||
|
||
int err = a2dp_stream_error_filter(dec, new_packet, packet, len);
|
||
if (err) {
|
||
if (-err == EAGAIN) {
|
||
dec->new_frame = 1;
|
||
goto try_again;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
*frame = packet + dec->header_len;
|
||
len -= dec->header_len;
|
||
if (dec->stream_error && new_packet) {
|
||
#if AUDIO_CODEC_SUPPORT_SYNC && TCFG_USER_TWS_ENABLE
|
||
if (dec->ts_handle) {
|
||
tws_a2dp_share_timestamp(dec->ts_handle);
|
||
}
|
||
#endif
|
||
dec->stream_error = 0;
|
||
}
|
||
|
||
if (dec->slience_frames) {
|
||
dec->slience_frames--;
|
||
}
|
||
a2dp_decoder_set_timestamp(dec, dec->seqn);
|
||
|
||
return len;
|
||
}
|
||
|
||
static void a2dp_dec_put_frame(struct audio_decoder *decoder, u8 *frame)
|
||
{
|
||
struct a2dp_dec_hdl *dec = container_of(decoder, struct a2dp_dec_hdl, decoder);
|
||
|
||
if (frame) {
|
||
if (!a2dp_media_channel_exist() || app_var.goto_poweroff_flag) {
|
||
a2dp_decoder_stream_free(dec, (void *)(frame - dec->header_len));
|
||
}
|
||
/*a2dp_media_free_packet((void *)(frame - dec->header_len));*/
|
||
}
|
||
}
|
||
|
||
static int a2dp_dec_fetch_frame(struct audio_decoder *decoder, u8 **frame)
|
||
{
|
||
struct a2dp_dec_hdl *dec = container_of(decoder, struct a2dp_dec_hdl, decoder);
|
||
u8 *packet = NULL;
|
||
int len = 0;
|
||
u32 wait_timeout = 0;
|
||
|
||
if (!dec->start) {
|
||
wait_timeout = jiffies + msecs_to_jiffies(500);
|
||
}
|
||
|
||
dec->fetch_lock = 1;
|
||
__retry_fetch:
|
||
packet = a2dp_media_fetch_packet(&len, NULL);
|
||
if (packet) {
|
||
dec->header_len = get_rtp_header_len(1, packet, len);
|
||
*frame = packet + dec->header_len;
|
||
len -= dec->header_len;
|
||
} else if (!dec->start) {
|
||
if (time_before(jiffies, wait_timeout)) {
|
||
os_time_dly(1);
|
||
goto __retry_fetch;
|
||
}
|
||
}
|
||
|
||
dec->fetch_lock = 0;
|
||
return len;
|
||
}
|
||
|
||
static const struct audio_dec_input a2dp_input = {
|
||
.coding_type = AUDIO_CODING_SBC,
|
||
.data_type = AUDIO_INPUT_FRAME,
|
||
.ops = {
|
||
.frame = {
|
||
.fget = a2dp_dec_get_frame,
|
||
.fput = a2dp_dec_put_frame,
|
||
.ffetch = a2dp_dec_fetch_frame,
|
||
}
|
||
}
|
||
};
|
||
|
||
|
||
#define bt_time_before(t1, t2) \
|
||
(((t1 < t2) && ((t2 - t1) & 0x7ffffff) < 0xffff) || \
|
||
((t1 > t2) && ((t1 - t2) & 0x7ffffff) > 0xffff))
|
||
#define bt_time_to_msecs(clk) (((clk) * 625) / 1000)
|
||
#define msecs_to_bt_time(m) (((m + 1)* 1000) / 625)
|
||
|
||
static int a2dp_audio_delay_time(struct a2dp_dec_hdl *dec)
|
||
{
|
||
/*struct a2dp_dec_hdl *dec = container_of(decoder, struct a2dp_dec_hdl, decoder);*/
|
||
int msecs = 0;
|
||
|
||
#if TCFG_USER_TWS_ENABLE
|
||
msecs = a2dp_media_get_remain_play_time(1);
|
||
#else
|
||
msecs = a2dp_media_get_remain_play_time(0);
|
||
#endif
|
||
|
||
if (dec->syncts) {
|
||
msecs += sound_buffered_between_syncts_and_device(dec->syncts, 0);
|
||
}
|
||
|
||
#if defined(TCFG_AUDIO_OUTPUT_IIS) && TCFG_AUDIO_OUTPUT_IIS
|
||
msecs += audio_iis_data_time();
|
||
#else
|
||
msecs += audio_dac_data_time(&dac_hdl);
|
||
#endif
|
||
|
||
return msecs;
|
||
}
|
||
|
||
static int a2dp_decoder_stream_delay_update(struct audio_decoder *decoder)
|
||
{
|
||
struct a2dp_dec_hdl *dec = container_of(decoder, struct a2dp_dec_hdl, decoder);
|
||
int msecs = 0;
|
||
int err = 0;
|
||
|
||
#if AUDIO_CODEC_SUPPORT_SYNC
|
||
msecs = a2dp_audio_delay_time(dec);
|
||
if (dec->stream_error) {
|
||
return 0;
|
||
}
|
||
|
||
if (dec->sync_step == 2) {
|
||
int distance_time = msecs - a2dp_delay_time;
|
||
if (a2dp_bt_rx_overrun() && distance_time < 50) {
|
||
distance_time = 50;
|
||
}
|
||
|
||
if (dec->ts_handle) {
|
||
a2dp_audio_delay_offset_update(dec->ts_handle, distance_time);
|
||
}
|
||
}
|
||
|
||
#endif
|
||
/*printf("%d -> %dms, delay_time : %dms\n", msecs1, msecs, a2dp_delay_time);*/
|
||
return 0;
|
||
}
|
||
|
||
/*
|
||
* A2DP 音频同步控制处理函数
|
||
* 1.包括音频延时浮动参数;
|
||
* 2.处理因为超时等情况丢弃音频样点;
|
||
* 3.调用与蓝牙主机音频延时做同步的功能;
|
||
* 4.处理TWS从机加入与解码被打断的情况。
|
||
*
|
||
*/
|
||
static int a2dp_decoder_audio_sync_handler(struct audio_decoder *decoder)
|
||
{
|
||
struct a2dp_dec_hdl *dec = container_of(decoder, struct a2dp_dec_hdl, decoder);
|
||
int err;
|
||
|
||
if (!dec->syncts) {
|
||
return 0;
|
||
}
|
||
|
||
|
||
err = a2dp_decoder_stream_delay_update(decoder);
|
||
if (err) {
|
||
audio_decoder_suspend(decoder, 0);
|
||
return -EAGAIN;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
static u16 a2dp_max_interval = 0;
|
||
#define A2DP_EST_AUDIO_CAPACITY 350//ms
|
||
|
||
static void a2dp_stream_underrun_feedback(void *priv)
|
||
{
|
||
struct a2dp_dec_hdl *dec = (struct a2dp_dec_hdl *)priv;
|
||
|
||
dec->underrun_feedback = 1;
|
||
|
||
if (a2dp_delay_time < a2dp_max_interval + 50) {
|
||
a2dp_delay_time = a2dp_max_interval + 50;
|
||
} else {
|
||
a2dp_delay_time += 50;
|
||
}
|
||
if (a2dp_delay_time > A2DP_EST_AUDIO_CAPACITY) {
|
||
a2dp_delay_time = A2DP_EST_AUDIO_CAPACITY;
|
||
}
|
||
}
|
||
|
||
/*void a2dp_stream_interval_time_handler(int time)*/
|
||
void reset_a2dp_sbc_instant_time(u16 time)
|
||
{
|
||
if (a2dp_max_interval < time) {
|
||
a2dp_max_interval = time;
|
||
if (a2dp_max_interval > 350) {
|
||
a2dp_max_interval = 350;
|
||
}
|
||
#if A2DP_FLUENT_STREAM_MODE
|
||
if (a2dp_max_interval > a2dp_delay_time) {
|
||
a2dp_delay_time = a2dp_max_interval + 5;
|
||
if (a2dp_delay_time > A2DP_EST_AUDIO_CAPACITY) {
|
||
a2dp_delay_time = A2DP_EST_AUDIO_CAPACITY;
|
||
}
|
||
}
|
||
#endif
|
||
/*printf("Max : %dms\n", time);*/
|
||
}
|
||
}
|
||
|
||
static void a2dp_stream_stability_detect(void *priv)
|
||
{
|
||
struct a2dp_dec_hdl *dec = (struct a2dp_dec_hdl *)priv;
|
||
|
||
if (dec->underrun_feedback) {
|
||
dec->underrun_feedback = 0;
|
||
return;
|
||
}
|
||
|
||
if (a2dp_delay_time > dec->delay_time) {
|
||
if (a2dp_max_interval < a2dp_delay_time) {
|
||
a2dp_delay_time -= 50;
|
||
if (a2dp_delay_time < dec->delay_time) {
|
||
a2dp_delay_time = dec->delay_time;
|
||
}
|
||
|
||
if (a2dp_delay_time < a2dp_max_interval) {
|
||
a2dp_delay_time = a2dp_max_interval + 5;
|
||
}
|
||
}
|
||
a2dp_max_interval = dec->delay_time;
|
||
}
|
||
}
|
||
|
||
#if AUDIO_CODEC_SUPPORT_SYNC
|
||
static void a2dp_decoder_update_base_time(struct a2dp_dec_hdl *dec)
|
||
{
|
||
int distance_time = a2dp_low_latency ? a2dp_delay_time : (a2dp_delay_time - a2dp_media_get_remain_play_time(1));
|
||
if (!a2dp_low_latency) {
|
||
distance_time = a2dp_delay_time;
|
||
} else if (distance_time < 20) {
|
||
distance_time = 20;
|
||
}
|
||
dec->base_time = bt_audio_sync_lat_time() + msecs_to_bt_time(distance_time);
|
||
}
|
||
|
||
#endif
|
||
static int a2dp_decoder_stream_is_available(struct a2dp_dec_hdl *dec)
|
||
{
|
||
int err = 0;
|
||
u8 *packet = NULL;
|
||
int len = 0;
|
||
int drop = 0;
|
||
|
||
#if AUDIO_CODEC_SUPPORT_SYNC
|
||
if (dec->sync_step) {
|
||
return 0;
|
||
}
|
||
|
||
packet = (u8 *)a2dp_media_fetch_packet(&len, NULL);
|
||
if (!packet) {
|
||
return -EINVAL;
|
||
}
|
||
|
||
dec->seqn = RB16(packet + 2);
|
||
if (dec->ts_handle) {
|
||
#if TCFG_USER_TWS_ENABLE
|
||
if (!tws_network_audio_was_started() && !a2dp_audio_timestamp_is_available(dec->ts_handle, dec->seqn, 0, &drop)) {
|
||
if (drop) {
|
||
local_irq_disable();
|
||
u8 *check_packet = (u8 *)a2dp_media_fetch_packet(&len, NULL);
|
||
if (check_packet && RB16(check_packet + 2) == dec->seqn) {
|
||
a2dp_media_free_packet(packet);
|
||
}
|
||
local_irq_enable();
|
||
a2dp_decoder_update_base_time(dec);
|
||
a2dp_audio_set_base_time(dec->ts_handle, dec->base_time);
|
||
}
|
||
return -EINVAL;
|
||
}
|
||
#endif
|
||
}
|
||
dec->sync_step = 2;
|
||
#endif
|
||
|
||
return 0;
|
||
}
|
||
|
||
static int a2dp_dec_probe_handler(struct audio_decoder *decoder)
|
||
{
|
||
struct a2dp_dec_hdl *dec = container_of(decoder, struct a2dp_dec_hdl, decoder);
|
||
int err = 0;
|
||
|
||
err = a2dp_decoder_stream_is_available(dec);
|
||
if (err) {
|
||
audio_decoder_suspend(decoder, 0);
|
||
return err;
|
||
}
|
||
|
||
err = a2dp_decoder_audio_sync_handler(decoder);
|
||
if (err) {
|
||
audio_decoder_suspend(decoder, 0);
|
||
return err;
|
||
}
|
||
|
||
dec->new_frame = 1;
|
||
|
||
a2dp_dec_set_output_channel(dec);
|
||
|
||
return err;
|
||
}
|
||
|
||
#if (SYS_VOL_TYPE == VOL_TYPE_DIGITAL)
|
||
void a2dp_digital_vol_set(u8 vol)
|
||
{
|
||
if (a2dp_dec) {
|
||
audio_digital_vol_set(a2dp_dec->dvol, vol);
|
||
}
|
||
}
|
||
#endif/*SYS_VOL_TYPE == VOL_TYPE_DIGITAL*/
|
||
|
||
|
||
static int a2dp_output_after_syncts_filter(void *priv, void *data, int len)
|
||
{
|
||
int wlen = 0;
|
||
int drop_len = 0;
|
||
struct a2dp_dec_hdl *dec = (struct a2dp_dec_hdl *)priv;
|
||
|
||
#if TCFG_EQ_ENABLE&&TCFG_BT_MUSIC_EQ_ENABLE
|
||
if (dec->eq_drc && dec->eq_drc->async) {
|
||
return eq_drc_run(dec->eq_drc, data, len);//异步eq
|
||
}
|
||
#endif
|
||
|
||
#if AUDIO_OUT_MIXER_ENABLE
|
||
return audio_mixer_ch_write(&dec->mix_ch, data, len);
|
||
#else
|
||
return audio_output_data_a2dp(dec, data, len);
|
||
#endif
|
||
}
|
||
|
||
static void a2dp_output_before_syncts_handler(struct a2dp_dec_hdl *dec, void *data, int len)
|
||
{
|
||
#if AUDIO_CODEC_SUPPORT_SYNC
|
||
if (dec->ts_start == 1) {
|
||
u32 timestamp = dec->timestamp;
|
||
u32 current_time = ((bt_audio_sync_lat_time() + (30000 / 625)) & 0x7ffffff) * 625 * TIME_US_FACTOR;
|
||
#define time_after_timestamp(t1, t2) \
|
||
((t1 > t2 && ((t1 - t2) < (10000000L * TIME_US_FACTOR))) || (t1 < t2 && ((t2 - t1) > (10000000L * TIME_US_FACTOR))))
|
||
if (!time_after_timestamp(timestamp, current_time)) {//时间戳与当前解码时间相差太近，直接丢掉
|
||
audio_syncts_resample_suspend(dec->syncts);
|
||
} else {
|
||
audio_syncts_resample_resume(dec->syncts);
|
||
dec->mix_ch_event_params[2] = timestamp;
|
||
dec->ts_start = 2;
|
||
}
|
||
}
|
||
#endif
|
||
}
|
||
|
||
static void audio_filter_resume_decoder(void *priv)
|
||
{
|
||
struct audio_decoder *decoder = (struct audio_decoder *)priv;
|
||
|
||
audio_decoder_resume(decoder);
|
||
}
|
||
|
||
static int a2dp_decoder_slience_plc_filter(struct a2dp_dec_hdl *dec, void *data, int len)
|
||
{
|
||
if (len == 0) {
|
||
a2dp_decoder_stream_free(dec, NULL);
|
||
if (!dec->stream_error) {
|
||
dec->stream_error = A2DP_STREAM_DECODE_ERR;
|
||
dec->repair = 1;
|
||
}
|
||
return 0;
|
||
}
|
||
if (dec->stream_error) {
|
||
memset(data, 0x0, len);
|
||
}
|
||
#if TCFG_USER_TWS_ENABLE
|
||
u8 tws_pairing = 0;
|
||
if (dec->preempt || tws_network_audio_was_started()) {
|
||
/*a2dp播放中副机加入，声音淡入进去*/
|
||
tws_network_local_audio_start();
|
||
dec->preempt = 0;
|
||
tws_pairing = 1;
|
||
memset(data, 0x0, len);
|
||
dec->slience_frames = 30;
|
||
}
|
||
#endif
|
||
#if A2DP_AUDIO_PLC_ENABLE
|
||
if (dec->plc_ops) {
|
||
if (dec->slience_frames) {
|
||
dec->plc_ops->run(dec->plc_mem, data, data, len >> 1, 2);
|
||
} else if (dec->stream_error) {
|
||
dec->plc_ops->run(dec->plc_mem, data, data, len >> 1, dec->repair ? 1 : 2);
|
||
dec->repair = 0;
|
||
} else {
|
||
dec->plc_ops->run(dec->plc_mem, data, data, len >> 1, 0);
|
||
}
|
||
}
|
||
#else
|
||
if (dec->slience_frames) {
|
||
memset(data, 0x0, len);
|
||
}
|
||
#endif
|
||
return len;
|
||
}
|
||
|
||
static int a2dp_dec_output_handler(struct audio_decoder *decoder, s16 *data, int len, void *priv)
|
||
{
|
||
int wlen = 0;
|
||
struct a2dp_dec_hdl *dec = container_of(decoder, struct a2dp_dec_hdl, decoder);
|
||
if (!dec->remain) {
|
||
wlen = a2dp_decoder_slience_plc_filter(dec, data, len);
|
||
if (wlen < len) {
|
||
return wlen;
|
||
}
|
||
#if (SYS_VOL_TYPE == VOL_TYPE_DIGITAL)
|
||
audio_digital_vol_run(dec->dvol, data, len);
|
||
#endif
|
||
|
||
#if TCFG_DIG_PHASE_INVERTER_EN
|
||
digital_phase_inverter_s16(data, len);
|
||
#endif/*TCFG_DIG_PHASE_INVERTER_EN*/
|
||
|
||
#if TCFG_EQ_ENABLE&&TCFG_BT_MUSIC_EQ_ENABLE
|
||
if (dec->eq_drc && !dec->eq_drc->async) {
|
||
eq_drc_run(dec->eq_drc, data, len);//同步eq
|
||
}
|
||
#endif
|
||
|
||
a2dp_output_before_syncts_handler(dec, data, len);
|
||
}
|
||
#if AUDIO_CODEC_SUPPORT_SYNC
|
||
if (dec->syncts) {
|
||
int wlen = audio_syncts_frame_filter(dec->syncts, data, len);
|
||
if (wlen < len) {
|
||
audio_syncts_trigger_resume(dec->syncts, (void *)decoder, audio_filter_resume_decoder);
|
||
}
|
||
dec->remain = wlen < len ? 1 : 0;
|
||
return wlen;
|
||
}
|
||
#endif
|
||
wlen = a2dp_output_after_syncts_filter(dec, data, len);
|
||
dec->remain = wlen < len ? 1 : 0;
|
||
return wlen;
|
||
}
|
||
|
||
|
||
static int a2dp_dec_post_handler(struct audio_decoder *decoder)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
static const struct audio_dec_handler a2dp_dec_handler = {
|
||
.dec_probe = a2dp_dec_probe_handler,
|
||
.dec_output = a2dp_dec_output_handler,
|
||
.dec_post = a2dp_dec_post_handler,
|
||
};
|
||
|
||
void a2dp_dec_close();
|
||
|
||
static void a2dp_dec_release()
|
||
{
|
||
audio_decoder_task_del_wait(&decode_task, &a2dp_dec->wait);
|
||
a2dp_drop_frame_stop();
|
||
|
||
local_irq_disable();
|
||
free(a2dp_dec);
|
||
a2dp_dec = NULL;
|
||
local_irq_enable();
|
||
}
|
||
|
||
static void a2dp_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");
|
||
a2dp_dec_close();
|
||
break;
|
||
}
|
||
}
|
||
|
||
static void a2dp_decoder_delay_time_setup(struct a2dp_dec_hdl *dec)
|
||
{
|
||
#if TCFG_USER_TWS_ENABLE
|
||
int a2dp_low_latency = tws_api_get_low_latency_state();
|
||
#endif
|
||
if (a2dp_low_latency) {
|
||
a2dp_delay_time = a2dp_dec->coding_type == AUDIO_CODING_AAC ? CONFIG_A2DP_DELAY_TIME_LO : CONFIG_A2DP_SBC_DELAY_TIME_LO;
|
||
} else {
|
||
a2dp_delay_time = CONFIG_A2DP_DELAY_TIME;
|
||
}
|
||
a2dp_max_interval = 0;
|
||
|
||
dec->delay_time = a2dp_delay_time;
|
||
|
||
dec->detect_timer = sys_timer_add((void *)dec, a2dp_stream_stability_detect, A2DP_FLUENT_DETECT_INTERVAL);
|
||
}
|
||
|
||
|
||
|
||
static int a2dp_decoder_syncts_setup(struct a2dp_dec_hdl *dec)
|
||
{
|
||
int err = 0;
|
||
#if AUDIO_CODEC_SUPPORT_SYNC
|
||
struct audio_syncts_params params = {0};
|
||
|
||
params.nch = dec->ch;
|
||
#if defined(TCFG_AUDIO_OUTPUT_IIS) && TCFG_AUDIO_OUTPUT_IIS
|
||
params.pcm_device = PCM_OUTSIDE_DAC;
|
||
params.rout_sample_rate = TCFG_IIS_SAMPLE_RATE;
|
||
#else
|
||
params.pcm_device = PCM_INSIDE_DAC;
|
||
params.rout_sample_rate = dec->sample_rate;
|
||
#endif
|
||
params.network = AUDIO_NETWORK_BT2_1;
|
||
params.rin_sample_rate = dec->sample_rate;
|
||
params.priv = dec;
|
||
params.factor = TIME_US_FACTOR;
|
||
params.output = a2dp_output_after_syncts_filter;
|
||
|
||
bt_audio_sync_nettime_select(0);//0 - a2dp主机，1 - tws, 2 - BLE
|
||
|
||
a2dp_decoder_update_base_time(dec);
|
||
dec->ts_handle = a2dp_audio_timestamp_create(dec->sample_rate, dec->base_time, TIME_US_FACTOR);
|
||
|
||
err = audio_syncts_open(&dec->syncts, ¶ms);
|
||
if (!err) {
|
||
#if AUDIO_OUT_MIXER_ENABLE
|
||
dec->mix_ch_event_params[0] = (u32)&dec->mix_ch;
|
||
dec->mix_ch_event_params[1] = (u32)dec->syncts;
|
||
dec->mix_ch_event_params[2] = dec->base_time * 625 * TIME_US_FACTOR;
|
||
audio_mixer_ch_set_event_handler(&dec->mix_ch, (void *)dec->mix_ch_event_params, audio_mix_ch_event_handler);
|
||
#else
|
||
dec->mix_ch_event_params[1] = (u32)dec->syncts;
|
||
dec->mix_ch_event_params[2] = dec->base_time * 625 * TIME_US_FACTOR;
|
||
#endif
|
||
}
|
||
|
||
dec->sync_step = 0;
|
||
#endif
|
||
return err;
|
||
}
|
||
|
||
static void a2dp_decoder_syncts_free(struct a2dp_dec_hdl *dec)
|
||
{
|
||
#if AUDIO_CODEC_SUPPORT_SYNC
|
||
if (dec->ts_handle) {
|
||
a2dp_audio_timestamp_close(dec->ts_handle);
|
||
dec->ts_handle = NULL;
|
||
}
|
||
if (dec->syncts) {
|
||
audio_syncts_close(dec->syncts);
|
||
dec->syncts = NULL;
|
||
}
|
||
#endif
|
||
}
|
||
|
||
static int a2dp_decoder_plc_setup(struct a2dp_dec_hdl *dec)
|
||
{
|
||
#if A2DP_AUDIO_PLC_ENABLE
|
||
int plc_mem_size;
|
||
dec->plc_ops = get_lfaudioPLC_api();
|
||
plc_mem_size = dec->plc_ops->need_buf(dec->ch); // 3660bytes，请衡量是否使用该空间换取PLC处理
|
||
dec->plc_mem = malloc(plc_mem_size);
|
||
if (!dec->plc_mem) {
|
||
dec->plc_ops = NULL;
|
||
return -ENOMEM;
|
||
}
|
||
dec->plc_ops->open(dec->plc_mem, dec->ch, a2dp_low_latency ? 0 : 4);
|
||
#endif
|
||
return 0;
|
||
}
|
||
|
||
static void a2dp_decoder_plc_free(struct a2dp_dec_hdl *dec)
|
||
{
|
||
#if A2DP_AUDIO_PLC_ENABLE
|
||
if (dec->plc_mem) {
|
||
free(dec->plc_mem);
|
||
dec->plc_mem = NULL;
|
||
}
|
||
#endif
|
||
}
|
||
|
||
void a2dp_decoder_sample_detect_setup(struct a2dp_dec_hdl *dec)
|
||
{
|
||
dec->sample_detect = a2dp_sample_detect_open(dec->sample_rate, dec->coding_type);
|
||
}
|
||
|
||
void a2dp_decoder_sample_detect_free(struct a2dp_dec_hdl *dec)
|
||
{
|
||
if (dec->sample_detect) {
|
||
a2dp_sample_detect_close(dec->sample_detect);
|
||
dec->sample_detect = NULL;
|
||
}
|
||
}
|
||
|
||
|
||
|
||
void audio_overlay_load_code(u32 type);
|
||
int a2dp_dec_start()
|
||
{
|
||
int err;
|
||
struct audio_fmt *fmt;
|
||
enum audio_channel channel;
|
||
struct a2dp_dec_hdl *dec = a2dp_dec;
|
||
|
||
if (!a2dp_dec) {
|
||
return -EINVAL;
|
||
}
|
||
|
||
a2dp_drop_frame_stop();
|
||
puts("a2dp_dec_start: in\n");
|
||
#if TCFG_USER_TWS_ENABLE
|
||
int a2dp_low_latency = tws_api_get_low_latency_state();
|
||
#endif
|
||
|
||
#if CONFIG_MINI_BT_AUDIO_ENABLE
|
||
a2dp_delay_time = a2dp_low_latency ? CONFIG_A2DP_SBC_DELAY_TIME_LO : CONFIG_A2DP_DELAY_TIME;
|
||
#else
|
||
if (a2dp_low_latency) {
|
||
a2dp_delay_time = a2dp_dec->coding_type == AUDIO_CODING_AAC ? CONFIG_A2DP_DELAY_TIME_LO : CONFIG_A2DP_SBC_DELAY_TIME_LO;
|
||
} else {
|
||
a2dp_delay_time = CONFIG_A2DP_DELAY_TIME;
|
||
}
|
||
a2dp_max_interval = 0;
|
||
|
||
dec->delay_time = a2dp_delay_time;
|
||
if (a2dp_dec->coding_type == AUDIO_CODING_AAC) {
|
||
audio_overlay_load_code(a2dp_dec->coding_type);
|
||
}
|
||
#endif /*CONFIG_MINI_BT_AUDIO_ENABLE*/
|
||
|
||
err = audio_decoder_open(&dec->decoder, &a2dp_input, &decode_task);
|
||
if (err) {
|
||
goto __err1;
|
||
}
|
||
dec->channel = AUDIO_CH_MAX;
|
||
|
||
audio_decoder_set_handler(&dec->decoder, &a2dp_dec_handler);
|
||
audio_decoder_set_event_handler(&dec->decoder, a2dp_dec_event_handler, 0);
|
||
|
||
#if !CONFIG_MINI_BT_AUDIO_ENABLE
|
||
if (a2dp_dec->coding_type != a2dp_input.coding_type) {
|
||
struct audio_fmt f = {0};
|
||
f.coding_type = a2dp_dec->coding_type;
|
||
err = audio_decoder_set_fmt(&dec->decoder, &f);
|
||
if (err) {
|
||
goto __err2;
|
||
}
|
||
}
|
||
#endif /*CONFIG_MINI_BT_AUDIO_ENABLE*/
|
||
|
||
err = audio_decoder_get_fmt(&dec->decoder, &fmt);
|
||
if (err) {
|
||
goto __err2;
|
||
}
|
||
|
||
if (fmt->sample_rate == 0) {
|
||
log_w("A2DP stream maybe error\n");
|
||
goto __err2;
|
||
}
|
||
//dac_hdl.dec_channel_num = fmt->channel;
|
||
dec->sample_rate = fmt->sample_rate;
|
||
|
||
a2dp_decoder_delay_time_setup(dec);
|
||
set_source_sample_rate(fmt->sample_rate);
|
||
a2dp_dec_set_output_channel(dec);
|
||
|
||
/*audio_dac_set_protect_time(&dac_hdl, 3, dec, NULL);//a2dp_stream_underrun_feedback);*/
|
||
#if AUDIO_OUT_MIXER_ENABLE
|
||
audio_mixer_ch_open(&dec->mix_ch, &mixer);
|
||
#if defined(TCFG_AUDIO_OUTPUT_IIS) && TCFG_AUDIO_OUTPUT_IIS
|
||
audio_mixer_ch_set_sample_rate(&dec->mix_ch, TCFG_IIS_SAMPLE_RATE);
|
||
#else
|
||
audio_mixer_ch_set_sample_rate(&dec->mix_ch, fmt->sample_rate);
|
||
#endif
|
||
audio_mixer_ch_set_resume_handler(&dec->mix_ch, (void *)&dec->decoder, (void (*)(void *))audio_decoder_resume);
|
||
#endif
|
||
|
||
app_audio_state_switch(APP_AUDIO_STATE_MUSIC, get_max_sys_vol());
|
||
#if (SYS_VOL_TYPE == VOL_TYPE_DIGITAL)
|
||
a2dp_dec->dvol = audio_digital_vol_open(app_audio_get_volume(APP_AUDIO_STATE_MUSIC), SYS_MAX_VOL, 2);
|
||
#endif/*SYS_VOL_TYPE == VOL_TYPE_DIGITAL*/
|
||
a2dp_decoder_sample_detect_setup(dec);
|
||
#if TCFG_EQ_ENABLE&&TCFG_BT_MUSIC_EQ_ENABLE
|
||
u8 drc_en = 0;
|
||
#if TCFG_DRC_ENABLE&&TCFG_BT_MUSIC_DRC_ENABLE
|
||
drc_en = 1;
|
||
#endif//TCFG_BT_MUSIC_DRC_ENABLE
|
||
|
||
#if defined(AUDIO_GAME_EFFECT_CONFIG) && AUDIO_GAME_EFFECT_CONFIG
|
||
if (a2dp_low_latency) {
|
||
drc_en |= BIT(1);
|
||
}
|
||
#endif /*AUDIO_GAME_EFFECT_CONFIG*/
|
||
|
||
#if AUDIO_OUT_MIXER_ENABLE
|
||
dec->eq_drc = dec_eq_drc_setup(&dec->mix_ch, (eq_output_cb)audio_mixer_ch_write, fmt->sample_rate, dec->ch, a2dp_low_latency ? 0 : 1, drc_en);
|
||
#else
|
||
dec->eq_drc = dec_eq_drc_setup(dec, (eq_output_cb)audio_output_data_a2dp, fmt->sample_rate, dec->ch, a2dp_low_latency ? 0 : 1, drc_en);
|
||
#endif
|
||
#endif//TCFG_BT_MUSIC_EQ_ENABLE
|
||
|
||
a2dp_decoder_syncts_setup(dec);
|
||
a2dp_decoder_plc_setup(dec);
|
||
|
||
dec->remain = 0;
|
||
#if 0
|
||
if (dec->coding_type == AUDIO_CODING_SBC) {
|
||
#if (TCFG_BT_MUSIC_EQ_ENABLE && ((EQ_SECTION_MAX >= 10) && AUDIO_OUT_EFFECT_ENABLE))
|
||
clk_set_sys_lock(a2dp_low_latency ? SYS_64M : SYS_48M, 0) ;
|
||
#elif (TCFG_BT_MUSIC_EQ_ENABLE && ((EQ_SECTION_MAX >= 10) || AUDIO_OUT_EFFECT_ENABLE))
|
||
#if A2DP_AUDIO_PLC_ENABLE
|
||
clk_set_sys_lock(a2dp_low_latency ? SYS_64M : SYS_48M, 0) ;
|
||
#else
|
||
clk_set_sys_lock(a2dp_low_latency ? SYS_48M : SYS_32M, 0) ;
|
||
#endif//A2DP_AUDIO_PLC_ENABLE
|
||
#else
|
||
#if (!TCFG_AUDIO_ANC_ENABLE)
|
||
clk_set_sys_lock(a2dp_low_latency ? SYS_24M : SYS_16M, 0) ;
|
||
#if A2DP_AUDIO_PLC_ENABLE
|
||
clk_set_sys_lock(SYS_32M, 0) ;
|
||
#endif//A2DP_AUDIO_PLC_ENABLE
|
||
#endif
|
||
#endif
|
||
#if !CONFIG_MINI_BT_AUDIO_ENABLE
|
||
} else if (dec->coding_type == AUDIO_CODING_AAC) {
|
||
#if (TCFG_BT_MUSIC_EQ_ENABLE && ((EQ_SECTION_MAX >= 10) && AUDIO_OUT_EFFECT_ENABLE))
|
||
clk_set_sys_lock(SYS_64M, 0) ;
|
||
#elif (TCFG_BT_MUSIC_EQ_ENABLE && ((EQ_SECTION_MAX >= 10) || AUDIO_OUT_EFFECT_ENABLE))
|
||
clk_set_sys_lock(a2dp_low_latency ? SYS_64M : SYS_48M, 0) ;
|
||
#else
|
||
clk_set_sys_lock(a2dp_low_latency ? SYS_48M : SYS_48M, 0) ;
|
||
#endif
|
||
#endif /*CONFIG_MINI_BT_AUDIO_ENABLE*/
|
||
}
|
||
#else
|
||
audio_codec_clock_set(AUDIO_A2DP_MODE, dec->coding_type, dec->wait.preemption);
|
||
#endif
|
||
|
||
err = audio_decoder_start(&dec->decoder);
|
||
if (err) {
|
||
goto __err3;
|
||
}
|
||
if (get_sniff_out_status()) {
|
||
clear_sniff_out_status();
|
||
audio_dac_start_pre(&dac_hdl);
|
||
}
|
||
|
||
dec->start = 1;
|
||
|
||
return 0;
|
||
|
||
__err3:
|
||
#if AUDIO_OUT_MIXER_ENABLE
|
||
audio_mixer_ch_close(&a2dp_dec->mix_ch);
|
||
#else
|
||
audio_output_close(NULL);
|
||
#if AUDIO_CODEC_SUPPORT_SYNC
|
||
if (a2dp_dec->syncts) {
|
||
u32 mix_ch_event_params[3] = {0};
|
||
mix_ch_event_params[1] = (u32)a2dp_dec->syncts;
|
||
audio_syncts_del(mix_ch_event_params);
|
||
}
|
||
#endif
|
||
#endif
|
||
a2dp_decoder_syncts_free(a2dp_dec);
|
||
|
||
__err2:
|
||
audio_decoder_close(&dec->decoder);
|
||
__err1:
|
||
a2dp_dec_release();
|
||
|
||
return err;
|
||
}
|
||
|
||
static int __a2dp_audio_res_close(void)
|
||
{
|
||
a2dp_dec->start = 0;
|
||
if (a2dp_dec->detect_timer) {
|
||
sys_timer_del(a2dp_dec->detect_timer);
|
||
}
|
||
a2dp_decoder_sample_detect_free(a2dp_dec);
|
||
audio_decoder_close(&a2dp_dec->decoder);
|
||
#if AUDIO_OUT_MIXER_ENABLE
|
||
audio_mixer_ch_close(&a2dp_dec->mix_ch);
|
||
#else
|
||
audio_output_close(NULL);
|
||
#if AUDIO_CODEC_SUPPORT_SYNC
|
||
if (a2dp_dec->syncts) {
|
||
u32 mix_ch_event_params[3] = {0};
|
||
mix_ch_event_params[1] = (u32)a2dp_dec->syncts;
|
||
audio_syncts_del(mix_ch_event_params);
|
||
}
|
||
#endif
|
||
|
||
#endif
|
||
|
||
a2dp_decoder_syncts_free(a2dp_dec);
|
||
a2dp_decoder_plc_free(a2dp_dec);
|
||
a2dp_decoder_stream_free(a2dp_dec, NULL);
|
||
#if TCFG_EQ_ENABLE&&TCFG_BT_MUSIC_EQ_ENABLE
|
||
if (a2dp_dec->eq_drc) {
|
||
dec_eq_drc_free(a2dp_dec->eq_drc);
|
||
a2dp_dec->eq_drc = NULL;
|
||
}
|
||
#endif//TCFG_BT_MUSIC_EQ_ENABLE
|
||
|
||
#if (SYS_VOL_TYPE == VOL_TYPE_DIGITAL)
|
||
audio_digital_vol_close(a2dp_dec->dvol);
|
||
a2dp_dec->dvol = NULL;
|
||
#endif/*SYS_VOL_TYPE == VOL_TYPE_DIGITAL*/
|
||
#if 0
|
||
clk_set_sys_lock(BT_NORMAL_HZ, 0);
|
||
#else
|
||
audio_codec_clock_del(AUDIO_A2DP_MODE);
|
||
#endif
|
||
|
||
a2dp_dec->preempt = 1;
|
||
app_audio_state_exit(APP_AUDIO_STATE_MUSIC);
|
||
return 0;
|
||
}
|
||
|
||
static int a2dp_wait_res_handler(struct audio_res_wait *wait, int event)
|
||
{
|
||
int err = 0;
|
||
|
||
printf("a2dp_wait_res_handler: %d\n", event);
|
||
|
||
if (event == AUDIO_RES_GET) {
|
||
err = a2dp_dec_start();
|
||
} else if (event == AUDIO_RES_PUT) {
|
||
if (a2dp_dec->start) {
|
||
__a2dp_audio_res_close();
|
||
a2dp_drop_frame_start();
|
||
}
|
||
}
|
||
return err;
|
||
}
|
||
|
||
#define A2DP_CODEC_SBC 0x00
|
||
#define A2DP_CODEC_MPEG12 0x01
|
||
#define A2DP_CODEC_MPEG24 0x02
|
||
int __a2dp_dec_open(int media_type, u8 resume)
|
||
{
|
||
struct a2dp_dec_hdl *dec;
|
||
|
||
if (strcmp(os_current_task(), "app_core") != 0) {
|
||
log_e("a2dp dec open in task : %s\n", os_current_task());
|
||
}
|
||
|
||
#if TCFG_AUDIO_ANC_ENABLE
|
||
#ifdef CONFIG_ANC_OVERLAY
|
||
if (anc_train_open_query()) {
|
||
printf("anc_train_open,suspend a2dp_dec\n");
|
||
if (drop_a2dp_timer == 0) {
|
||
drop_a2dp_timer = sys_timer_add(NULL, __a2dp_drop_frame, 50);
|
||
}
|
||
return 0;
|
||
}
|
||
#endif/*CONFIG_ANC_OVERLAY*/
|
||
#endif /*TCFG_AUDIO_ANC_ENABLE*/
|
||
|
||
if (a2dp_suspend) {
|
||
if (tws_api_get_role() == TWS_ROLE_MASTER) {
|
||
if (drop_a2dp_timer == 0) {
|
||
drop_a2dp_timer = sys_timer_add(NULL,
|
||
a2dp_media_clear_packet_before_seqn, 100);
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
if (a2dp_dec) {
|
||
return 0;
|
||
}
|
||
|
||
media_type = a2dp_media_get_codec_type();
|
||
printf("a2dp_dec_open: %d\n", media_type);
|
||
|
||
dec = zalloc(sizeof(*dec));
|
||
if (!dec) {
|
||
return -ENOMEM;
|
||
}
|
||
|
||
switch (media_type) {
|
||
case A2DP_CODEC_SBC:
|
||
printf("a2dp_media_type:SBC");
|
||
dec->coding_type = AUDIO_CODING_SBC;
|
||
break;
|
||
#if !CONFIG_MINI_BT_AUDIO_ENABLE
|
||
case A2DP_CODEC_MPEG24:
|
||
printf("a2dp_media_type:AAC");
|
||
dec->coding_type = AUDIO_CODING_AAC;
|
||
break;
|
||
#endif /*CONFIG_MINI_BT_AUDIO_ENABLE*/
|
||
default:
|
||
printf("a2dp_media_type unsupoport:%d", media_type);
|
||
free(dec);
|
||
return -EINVAL;
|
||
}
|
||
|
||
#if TCFG_USER_TWS_ENABLE
|
||
if (CONFIG_LOW_LATENCY_ENABLE) {
|
||
a2dp_low_latency = tws_api_get_low_latency_state();
|
||
}
|
||
#endif
|
||
a2dp_dec = dec;
|
||
dec->preempt = resume ? 1 : 0;
|
||
dec->wait.priority = 0;
|
||
dec->wait.preemption = 1;
|
||
dec->wait.handler = a2dp_wait_res_handler;
|
||
audio_decoder_task_add_wait(&decode_task, &dec->wait);
|
||
|
||
if (a2dp_dec && (a2dp_dec->start == 0)) {
|
||
a2dp_drop_frame_start();
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
int a2dp_dec_open(int media_type)
|
||
{
|
||
return __a2dp_dec_open(media_type, 0);
|
||
}
|
||
|
||
void a2dp_dec_close()
|
||
{
|
||
if (!a2dp_dec) {
|
||
if (CONFIG_LOW_LATENCY_ENABLE) {
|
||
a2dp_low_latency_seqn = 0;
|
||
}
|
||
if (drop_a2dp_timer) {
|
||
sys_timer_del(drop_a2dp_timer);
|
||
drop_a2dp_timer = 0;
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (a2dp_dec->start) {
|
||
__a2dp_audio_res_close();
|
||
}
|
||
|
||
a2dp_dec_release();
|
||
|
||
puts("a2dp_dec_close: exit\n");
|
||
}
|
||
|
||
|
||
static void a2dp_low_latency_clear_a2dp_packet(u8 *data, int len, int rx)
|
||
{
|
||
if (rx) {
|
||
a2dp_low_latency_seqn = (data[0] << 8) | data[1];
|
||
}
|
||
}
|
||
REGISTER_TWS_FUNC_STUB(audio_dec_clear_a2dp_packet) = {
|
||
.func_id = 0x132A6578,
|
||
.func = a2dp_low_latency_clear_a2dp_packet,
|
||
};
|
||
|
||
|
||
static void low_latency_drop_a2dp_frame(void *p)
|
||
{
|
||
int len;
|
||
|
||
/*y_printf("low_latency_drop_a2dp_frame\n");*/
|
||
|
||
if (a2dp_low_latency_seqn == 0) {
|
||
a2dp_media_clear_packet_before_seqn(0);
|
||
return;
|
||
}
|
||
while (1) {
|
||
u8 *packet = a2dp_media_fetch_packet(&len, NULL);
|
||
if (!packet) {
|
||
return;
|
||
}
|
||
u16 seqn = (packet[2] << 8) | packet[3];
|
||
if (seqn_after(seqn, a2dp_low_latency_seqn)) {
|
||
printf("clear_end: %d\n", seqn);
|
||
break;
|
||
}
|
||
a2dp_media_free_packet(packet);
|
||
/*printf("clear: %d\n", seqn);*/
|
||
}
|
||
|
||
if (drop_a2dp_timer) {
|
||
sys_timer_del(drop_a2dp_timer);
|
||
drop_a2dp_timer = 0;
|
||
}
|
||
int type = a2dp_media_get_codec_type();
|
||
if (type >= 0) {
|
||
/*a2dp_dec_open(type);*/
|
||
__a2dp_dec_open(type, 1);
|
||
}
|
||
|
||
if (a2dp_low_latency == 0) {
|
||
tws_api_auto_role_switch_enable();
|
||
}
|
||
|
||
printf("a2dp_delay: %d\n", a2dp_media_get_remain_play_time(1));
|
||
}
|
||
|
||
|
||
int earphone_a2dp_codec_set_low_latency_mode(int enable, int msec)
|
||
{
|
||
int ret = 0;
|
||
int len, err;
|
||
|
||
if (CONFIG_LOW_LATENCY_ENABLE == 0) {
|
||
return -EINVAL;
|
||
}
|
||
|
||
if (esco_dec) {
|
||
return -EINVAL;
|
||
}
|
||
if (drop_a2dp_timer) {
|
||
return -EINVAL;
|
||
}
|
||
if (a2dp_suspend) {
|
||
return -EINVAL;
|
||
}
|
||
|
||
a2dp_low_latency = enable;
|
||
a2dp_low_latency_seqn = 0;
|
||
|
||
r_printf("a2dp_low_latency: %d, %d, %d\n", a2dp_dec->seqn, a2dp_delay_time, enable);
|
||
|
||
if (!a2dp_dec || a2dp_dec->start == 0) {
|
||
#if TCFG_USER_TWS_ENABLE
|
||
tws_api_low_latency_enable(enable);
|
||
#endif
|
||
return 0;
|
||
}
|
||
|
||
if (a2dp_dec->coding_type == AUDIO_CODING_SBC) {
|
||
a2dp_low_latency_seqn = a2dp_dec->seqn + (msec + a2dp_delay_time) / 15;
|
||
} else {
|
||
a2dp_low_latency_seqn = a2dp_dec->seqn + (msec + a2dp_delay_time) / 20;
|
||
}
|
||
|
||
#if TCFG_USER_TWS_ENABLE
|
||
u8 data[2];
|
||
data[0] = a2dp_low_latency_seqn >> 8;
|
||
data[1] = a2dp_low_latency_seqn;
|
||
err = tws_api_send_data_to_slave(data, 2, 0x132A6578);
|
||
if (err == -ENOMEM) {
|
||
return -EINVAL;
|
||
}
|
||
#endif
|
||
|
||
a2dp_dec_close();
|
||
|
||
a2dp_media_clear_packet_before_seqn(0);
|
||
|
||
#if TCFG_USER_TWS_ENABLE
|
||
if (enable) {
|
||
tws_api_auto_role_switch_disable();
|
||
}
|
||
tws_api_low_latency_enable(enable);
|
||
#endif
|
||
|
||
drop_a2dp_timer = sys_timer_add(NULL, low_latency_drop_a2dp_frame, 40);
|
||
|
||
/*r_printf("clear_to_seqn: %d\n", a2dp_low_latency_seqn);*/
|
||
|
||
return 0;
|
||
}
|
||
|
||
int earphone_a2dp_codec_get_low_latency_mode()
|
||
{
|
||
#if TCFG_USER_TWS_ENABLE
|
||
return tws_api_get_low_latency_state();
|
||
#endif
|
||
return a2dp_low_latency;
|
||
}
|
||
|
||
|
||
int a2dp_tws_dec_suspend(void *p)
|
||
{
|
||
r_printf("a2dp_tws_dec_suspend\n");
|
||
/*mem_stats();*/
|
||
|
||
if (a2dp_suspend) {
|
||
return -EINVAL;
|
||
}
|
||
a2dp_suspend = 1;
|
||
|
||
if (a2dp_dec) {
|
||
a2dp_dec_close();
|
||
a2dp_media_clear_packet_before_seqn(0);
|
||
if (tws_api_get_role() == 0) {
|
||
drop_a2dp_timer = sys_timer_add(NULL, (void (*)(void *))a2dp_media_clear_packet_before_seqn, 100);
|
||
}
|
||
}
|
||
|
||
int err = audio_decoder_fmt_lock(&decode_task, AUDIO_CODING_AAC);
|
||
if (err) {
|
||
log_e("AAC_dec_lock_faild\n");
|
||
}
|
||
|
||
return err;
|
||
}
|
||
|
||
|
||
void a2dp_tws_dec_resume(void)
|
||
{
|
||
r_printf("a2dp_tws_dec_resume\n");
|
||
|
||
if (a2dp_suspend) {
|
||
a2dp_suspend = 0;
|
||
|
||
if (drop_a2dp_timer) {
|
||
sys_timer_del(drop_a2dp_timer);
|
||
drop_a2dp_timer = 0;
|
||
}
|
||
|
||
audio_decoder_fmt_unlock(&decode_task, AUDIO_CODING_AAC);
|
||
|
||
int type = a2dp_media_get_codec_type();
|
||
printf("codec_type: %d\n", type);
|
||
if (type >= 0) {
|
||
if (tws_api_get_role() == 0) {
|
||
a2dp_media_clear_packet_before_seqn(0);
|
||
}
|
||
a2dp_resume_time = jiffies + msecs_to_jiffies(80);
|
||
/*a2dp_dec_open(type);*/
|
||
__a2dp_dec_open(type, 1);
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
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);
|
||
}
|
||
|
||
#define MSBC_FRAME_LEN 58
|
||
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_frame_head_check(struct esco_dec_hdl *dec)
|
||
{
|
||
if (dec->coding_type != AUDIO_CODING_MSBC || dec->data_len) {
|
||
return 0;
|
||
}
|
||
/*新的一帧数据*/
|
||
int len = dec->frame_len - dec->offset;
|
||
u8 *data = (u8 *)dec->frame + dec->offset;
|
||
int offset;
|
||
|
||
for (offset = 0; offset < len; offset++) {
|
||
if (data[offset] == 0xAD) {
|
||
if (offset >= 2 && !headcheck(data + offset - 2)) {
|
||
continue;
|
||
}
|
||
goto check_success;
|
||
}
|
||
}
|
||
|
||
return -EINVAL;
|
||
check_success:
|
||
dec->offset += offset;
|
||
return 0;
|
||
}
|
||
|
||
|
||
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->repair && dec->coding_type == AUDIO_CODING_MSBC) {
|
||
memcpy((u8 *)dec->data, msbc_mute_data, sizeof(msbc_mute_data));
|
||
*frame = (u8 *)dec->data;
|
||
return dec->esco_len;
|
||
}
|
||
|
||
if (dec->frame) {
|
||
int err = esco_frame_head_check(dec);
|
||
if (err) {
|
||
dec->frame_err_len += dec->frame_len;
|
||
if (dec->frame_err_len >= dec->esco_len) {
|
||
lmp_private_free_esco_packet(dec->frame);
|
||
dec->frame = NULL;
|
||
dec->repair = 1;
|
||
dec->frame_err_len = 0;
|
||
goto __again;
|
||
}
|
||
} else {
|
||
dec->frame_err_len = 0;
|
||
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
|
||
dec->repair = 0;
|
||
#if (defined(TCFG_PHONE_MESSAGE_ENABLE) && (TCFG_PHONE_MESSAGE_ENABLE))
|
||
phone_message_enc_write(dec->frame + 2, len - 2);
|
||
#endif
|
||
if (dec->data_len) {
|
||
dec->offset = 0;
|
||
} else {
|
||
dec->offset = dec->coding_type == AUDIO_CODING_MSBC ? 2 : 0;
|
||
}
|
||
dec->frame_len = len;
|
||
u32 *error_num = (u32 *)dec->frame;
|
||
if (error_num[0] == 0xAAAA5555 && error_num[1] == 0xAAAAAAAA) {
|
||
if (dec->coding_type == AUDIO_CODING_MSBC) {
|
||
lmp_private_free_esco_packet(dec->frame);
|
||
dec->frame = NULL;
|
||
}
|
||
dec->repair = 1;
|
||
}
|
||
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;
|
||
dec->repair = 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_rx_delay_monitor(struct audio_decoder *decoder, struct rt_stream_info *info)
|
||
{
|
||
struct esco_dec_hdl *dec = container_of(decoder, struct esco_dec_hdl, decoder);
|
||
|
||
#if 0
|
||
if (!dec->sync_step) {
|
||
if (info->data_len <= 0) {
|
||
return -EAGAIN;
|
||
}
|
||
#if 0//TCFG_USER_TWS_ENABLE
|
||
int state = tws_api_get_tws_state();
|
||
if (state & TWS_STA_SIBLING_CONNECTED) {
|
||
if (tws_api_get_role() == TWS_ROLE_SLAVE) {
|
||
audio_dac_sound_reset(&dac_hdl, 150);
|
||
}
|
||
}
|
||
#endif
|
||
dec->sync_step = 2;
|
||
}
|
||
|
||
if (info->data_len <= 120) {
|
||
info->distance_time = -15;
|
||
} else if (info->data_len > 240) {
|
||
info->distance_time = 15;
|
||
}
|
||
|
||
#endif
|
||
/*printf("%d - %d\n", info->data_len, info->remain_len);*/
|
||
return 0;
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
|
||
|
||
static int audio_esco_int2short_convert_output(void *priv, s16 *data, int len)
|
||
{
|
||
/* put_buf(data,len); */
|
||
return audio_dac_write(&dac_hdl, data, len);
|
||
|
||
}
|
||
static int audio_esco_short2int_convert_output(void *priv, void *data, int len)
|
||
{
|
||
#if 0//AUDIO_CODEC_SUPPORT_SYNC
|
||
if (audio_sync) {
|
||
audio_decoder_sync_run(audio_sync, data, len);
|
||
#if TCFG_PHONE_EQ_ENABLE
|
||
} else if (esco_eq) {
|
||
return audio_eq_run(esco_eq, data, len);
|
||
#endif
|
||
} else if (int2short_convert) {
|
||
/*return int2short_convert_run(int2short_convert, data, len);*/
|
||
}
|
||
#endif
|
||
return len;
|
||
}
|
||
|
||
/*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
|
||
};
|
||
#define MONO_TO_DUAL_POINTS 30
|
||
|
||
|
||
//////////////////////////////////////////////////////////////////////////////
|
||
static inline void audio_pcm_mono_to_dual(s16 *dual_pcm, s16 *mono_pcm, int points)
|
||
{
|
||
s16 *mono = mono_pcm;
|
||
int i = 0;
|
||
u8 j = 0;
|
||
|
||
for (i = 0; i < points; i++, mono++) {
|
||
*dual_pcm++ = *mono;
|
||
*dual_pcm++ = *mono;
|
||
}
|
||
}
|
||
|
||
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;
|
||
|
||
#if TCFG_AUDIO_OUTPUT_IIS
|
||
#if AUDIO_OUT_MIXER_ENABLE
|
||
wlen = audio_mixer_ch_write(&dec->mix_ch, data, len);
|
||
#else
|
||
wlen = audio_output_data_esco(dec, data, len);
|
||
#endif
|
||
#else
|
||
s16 two_ch_data[MONO_TO_DUAL_POINTS * 2];
|
||
s16 point_num = 0;
|
||
u8 mono_to_dual = 0;
|
||
s16 *mono_data = (s16 *)data;
|
||
u16 remain_points = (len >> 1);
|
||
/*
|
||
*如果dac输出是双声道，因为esco解码出来时单声道
|
||
*所以这里要根据dac通道确定是否做单变双
|
||
*/
|
||
|
||
#if (TCFG_AUDIO_DAC_CONNECT_MODE == DAC_OUTPUT_LR)
|
||
mono_to_dual = 1;
|
||
#endif
|
||
if (mono_to_dual) {
|
||
do {
|
||
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);
|
||
#if AUDIO_OUT_MIXER_ENABLE
|
||
int tmp_len = audio_mixer_ch_write(&dec->mix_ch, two_ch_data, point_num << 2);
|
||
#else
|
||
int tmp_len = audio_output_data_esco(dec, two_ch_data, point_num << 2);
|
||
#endif
|
||
|
||
wlen += tmp_len;
|
||
remain_points -= (tmp_len >> 2);
|
||
if (tmp_len < (point_num << 2)) {
|
||
break;
|
||
}
|
||
mono_data += point_num;
|
||
} while (remain_points);
|
||
wlen >>= 1;
|
||
} else {
|
||
#if AUDIO_OUT_MIXER_ENABLE
|
||
wlen = audio_mixer_ch_write(&dec->mix_ch, data, len);
|
||
#else
|
||
wlen = audio_output_data_esco(dec, data, len);
|
||
#endif
|
||
}
|
||
#endif
|
||
|
||
return wlen;
|
||
|
||
}
|
||
|
||
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 (dec->slience_frames) {
|
||
memset(data, 0x0, len);
|
||
dec->slience_frames--;
|
||
}
|
||
#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(esco_dec->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_DIG_PHASE_INVERTER_EN
|
||
digital_phase_inverter_s16(data, len);
|
||
#endif/*TCFG_DIG_PHASE_INVERTER_EN*/
|
||
|
||
#if TCFG_AUDIO_NOISE_GATE
|
||
/*来电去电铃声不做处理*/
|
||
if (get_call_status() == BT_CALL_ACTIVE) {
|
||
audio_noise_gate_run(data, data, len);
|
||
}
|
||
#endif/*TCFG_AUDIO_NOISE_GATE*/
|
||
|
||
#if TCFG_EQ_ENABLE&&TCFG_PHONE_EQ_ENABLE
|
||
eq_drc_run(dec->eq_drc, data, len);
|
||
#endif//TCFG_PHONE_EQ_ENABLE
|
||
|
||
}
|
||
|
||
#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()
|
||
{
|
||
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;
|
||
}
|
||
}
|
||
|
||
|
||
static void esco_dec_set_output_channel(struct esco_dec_hdl *dec)
|
||
{
|
||
u8 dac_connect_mode = audio_dac_get_channel(&dac_hdl);
|
||
}
|
||
|
||
u16 source_sr;
|
||
void set_source_sample_rate(u16 sample_rate)
|
||
{
|
||
source_sr = sample_rate;
|
||
}
|
||
|
||
u16 get_source_sample_rate()
|
||
{
|
||
if (bt_audio_is_running()) {
|
||
return source_sr;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
#if (SYS_VOL_TYPE == VOL_TYPE_DIGITAL)
|
||
void esco_digital_vol_set(u8 vol)
|
||
{
|
||
if (esco_dec) {
|
||
audio_digital_vol_set(esco_dec->dvol, vol);
|
||
}
|
||
}
|
||
#endif/*SYS_VOL_TYPE == VOL_TYPE_DIGITAL*/
|
||
|
||
int esco_dec_dac_gain_set(u8 gain)
|
||
{
|
||
app_var.aec_dac_gain = gain;
|
||
if (esco_dec) {
|
||
audio_dac_set_analog_vol(&dac_hdl, gain);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
static int esco_decoder_syncts_setup(struct esco_dec_hdl *dec)
|
||
{
|
||
int err = 0;
|
||
#if AUDIO_CODEC_SUPPORT_SYNC
|
||
#define ESCO_DELAY_TIME 60
|
||
struct audio_syncts_params params = {0};
|
||
int sample_rate = dec->decoder.fmt.sample_rate;
|
||
|
||
params.nch = dec->decoder.fmt.channel;
|
||
#if defined(TCFG_AUDIO_OUTPUT_IIS) && TCFG_AUDIO_OUTPUT_IIS
|
||
params.pcm_device = PCM_OUTSIDE_DAC;
|
||
params.rout_sample_rate = TCFG_IIS_SAMPLE_RATE;
|
||
#else
|
||
params.pcm_device = PCM_INSIDE_DAC;
|
||
params.rout_sample_rate = sample_rate;
|
||
#endif
|
||
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 >= MSBC_FRAME_LEN ? 12 : 6;
|
||
dec->ts_handle = esco_audio_timestamp_create(frame_clkn, ESCO_DELAY_TIME, TIME_US_FACTOR);
|
||
dec->frame_time = frame_clkn;
|
||
audio_syncts_open(&dec->syncts, ¶ms);
|
||
if (!err) {
|
||
|
||
#if AUDIO_OUT_MIXER_ENABLE
|
||
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);
|
||
#else
|
||
dec->mix_ch_event_params[1] = (u32)dec->syncts;
|
||
#endif
|
||
}
|
||
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_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;
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
set_source_sample_rate(f.sample_rate);
|
||
esco_dec_set_output_channel(esco_dec);
|
||
|
||
err = audio_decoder_set_fmt(&dec->decoder, &f);
|
||
if (err) {
|
||
goto __err2;
|
||
}
|
||
|
||
/*
|
||
*虽然mix有直通的处理，但是如果混合第二种声音进来的时候，就会按照mix_buff
|
||
*的大小来混合输出，该buff太大，回导致dac没有连续的数据播放
|
||
*/
|
||
#if AUDIO_OUT_MIXER_ENABLE
|
||
/*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);
|
||
#if defined(TCFG_AUDIO_OUTPUT_IIS) && TCFG_AUDIO_OUTPUT_IIS
|
||
audio_mixer_ch_set_sample_rate(&dec->mix_ch, TCFG_IIS_SAMPLE_RATE);
|
||
#else
|
||
audio_mixer_ch_set_sample_rate(&dec->mix_ch, f.sample_rate);
|
||
#endif
|
||
audio_mixer_ch_set_resume_handler(&dec->mix_ch, (void *)&dec->decoder, (void (*)(void *))audio_decoder_resume);
|
||
#endif
|
||
|
||
app_audio_state_switch(APP_AUDIO_STATE_CALL, app_var.aec_dac_gain);
|
||
#if (SYS_VOL_TYPE == VOL_TYPE_DIGITAL)
|
||
esco_dec->dvol = audio_digital_vol_open(app_audio_get_volume(APP_AUDIO_STATE_CALL), 15, 4);
|
||
#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);
|
||
|
||
audio_plc_open(f.sample_rate);
|
||
|
||
#if TCFG_AUDIO_NOISE_GATE
|
||
/*限幅器上限*/
|
||
#define LIMITER_THR -10000 /*-12000 = -12dB,放大1000倍,(-10000参考)*/
|
||
/*小于CONST_NOISE_GATE的当成噪声处理,防止清0近端声音*/
|
||
#define LIMITER_NOISE_GATE -40000 /*-12000 = -12dB,放大1000倍,(-30000参考)*/
|
||
/*低于噪声门限阈值的增益 */
|
||
#define LIMITER_NOISE_GAIN (0 << 30) /*(0~1)*2^30*/
|
||
audio_noise_gate_open(f.sample_rate, LIMITER_THR, LIMITER_NOISE_GATE, LIMITER_NOISE_GAIN);
|
||
#endif/*TCFG_AUDIO_NOISE_GATE*/
|
||
#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(NULL, NULL, f.sample_rate, f.channel, 0, drc_en);
|
||
#endif//TCFG_PHONE_EQ_ENABLE
|
||
|
||
|
||
|
||
#if AUDIO_CODEC_SUPPORT_SYNC
|
||
esco_decoder_syncts_setup(dec);
|
||
#endif/*AUDIO_CODEC_SUPPORT_SYNC*/
|
||
|
||
audio_dac_set_delay_time(&dac_hdl, 30, 50);
|
||
lmp_private_esco_suspend_resume(2);
|
||
err = audio_decoder_start(&dec->decoder);
|
||
if (err) {
|
||
goto __err3;
|
||
}
|
||
if (get_sniff_out_status()) {
|
||
clear_sniff_out_status();
|
||
audio_dac_start_pre(&dac_hdl);
|
||
}
|
||
audio_out_effect_dis = 1;//通话模式关闭高低音
|
||
|
||
dec->start = 1;
|
||
dec->remain = 0;
|
||
|
||
err = audio_aec_init(f.sample_rate);
|
||
if (err) {
|
||
printf("audio_aec_init failed:%d", err);
|
||
//goto __err3;
|
||
}
|
||
err = esco_enc_open(dec->coding_type, dec->esco_len);
|
||
if (err) {
|
||
printf("audio_enc_open failed:%d", err);
|
||
goto __err3;
|
||
}
|
||
|
||
audio_codec_clock_set(AUDIO_ESCO_MODE, dec->coding_type, dec->wait.preemption);
|
||
#if ESCO_DRC_EN
|
||
clk_set_sys_lock(96 * (1000000L), 0);
|
||
#endif
|
||
dec->enc_start = 1; //该函数所在任务优先级低可能未open编码就开始解码，加入enc开始的标志防止解码过快输出
|
||
printf("esco_dec_start ok\n");
|
||
|
||
return 0;
|
||
|
||
__err3:
|
||
#if AUDIO_OUT_MIXER_ENABLE
|
||
audio_mixer_ch_close(&dec->mix_ch);
|
||
#else
|
||
audio_output_close(NULL);
|
||
#if AUDIO_CODEC_SUPPORT_SYNC
|
||
if (dec->syncts) {
|
||
u32 mix_ch_event_params[3] = {0};
|
||
mix_ch_event_params[1] = (u32)dec->syncts;
|
||
audio_syncts_del(mix_ch_event_params);
|
||
}
|
||
#endif
|
||
#endif
|
||
esco_decoder_syncts_free(dec);
|
||
|
||
__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;
|
||
|
||
audio_aec_close();
|
||
esco_enc_close();
|
||
app_audio_state_exit(APP_AUDIO_STATE_CALL);
|
||
audio_decoder_close(&esco_dec->decoder);
|
||
#if AUDIO_OUT_MIXER_ENABLE
|
||
audio_mixer_ch_close(&esco_dec->mix_ch);
|
||
#else
|
||
audio_output_close(NULL);
|
||
#if AUDIO_CODEC_SUPPORT_SYNC
|
||
if (esco_dec->syncts) {
|
||
u32 mix_ch_event_params[3] = {0};
|
||
mix_ch_event_params[1] = (u32)esco_dec->syncts;
|
||
audio_syncts_del(mix_ch_event_params);
|
||
}
|
||
#endif
|
||
#endif
|
||
|
||
#if A2DP_RX_AND_AUDIO_DELAY
|
||
audio_dac_set_delay_time(&dac_hdl, 20, AUDIO_DAC_DELAY_TIME);
|
||
#else
|
||
audio_dac_set_delay_time(&dac_hdl, 30, AUDIO_DAC_DELAY_TIME);
|
||
#endif
|
||
#if AUDIO_CODEC_SUPPORT_SYNC
|
||
esco_decoder_syncts_free(esco_dec);
|
||
esco_dec->sync_step = 0;
|
||
esco_dec->preempt_state = DEC_PREEMTED_BY_PRIORITY;
|
||
#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
|
||
|
||
|
||
|
||
audio_out_effect_dis = 0;
|
||
|
||
#if (SYS_VOL_TYPE == VOL_TYPE_DIGITAL)
|
||
audio_digital_vol_close(esco_dec->dvol);
|
||
esco_dec->dvol = NULL;
|
||
#endif/*SYS_VOL_TYPE == VOL_TYPE_DIGITAL*/
|
||
|
||
audio_plc_close();
|
||
#if TCFG_AUDIO_NOISE_GATE
|
||
audio_noise_gate_close();
|
||
#endif/*TCFG_AUDIO_NOISE_GATE*/
|
||
audio_codec_clock_del(AUDIO_ESCO_MODE);
|
||
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;
|
||
}
|
||
|
||
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;
|
||
|
||
#if TCFG_AUDIO_ANC_ENABLE
|
||
#ifdef CONFIG_ANC_OVERLAY
|
||
if (anc_train_open_query()) {
|
||
printf("anc_train_open,suspend esco_dec\n");
|
||
lmp_private_esco_suspend_resume(1);
|
||
return 0;
|
||
}
|
||
#endif/*CONFIG_ANC_OVERLAY*/
|
||
#endif /*TCFG_AUDIO_ANC_ENABLE*/
|
||
|
||
printf("esco_dec_open, type=%d,len=%d\n", codec_type, esco_len);
|
||
|
||
dec = zalloc(sizeof(*dec));
|
||
if (!dec) {
|
||
return -ENOMEM;
|
||
}
|
||
esco_dec = dec;
|
||
|
||
if (codec_type == 3) {
|
||
dec->coding_type = AUDIO_CODING_MSBC;
|
||
dec->esco_len = MSBC_FRAME_LEN;
|
||
} else if (codec_type == 2) {
|
||
dec->coding_type = AUDIO_CODING_CVSD;
|
||
dec->esco_len = esco_len;
|
||
}
|
||
|
||
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) {
|
||
lmp_private_esco_suspend_resume(1);
|
||
}
|
||
|
||
#if AUDIO_OUTPUT_AUTOMUTE
|
||
mix_out_automute_skip(1);
|
||
#endif
|
||
return err;
|
||
}
|
||
|
||
|
||
void esco_dec_close()
|
||
{
|
||
if (!esco_dec) {
|
||
return;
|
||
}
|
||
|
||
__esco_dec_res_close();
|
||
esco_dec_release();
|
||
#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
|
||
|
||
#if AUDIO_OUT_MIXER_ENABLE
|
||
audio_mixer_set_output_buf(&mixer, mix_buff, sizeof(mix_buff));
|
||
#endif
|
||
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;
|
||
}
|
||
|
||
static void audio_dac_trim_init(int arg)
|
||
{
|
||
struct audio_dac_trim dac_trim;
|
||
|
||
audio_dac_do_trim(&dac_hdl, &dac_trim, 0);
|
||
syscfg_write(CFG_DAC_TRIM_INFO, (void *)&dac_trim, sizeof(dac_trim));
|
||
|
||
audio_dac_set_trim_value(&dac_hdl, &dac_trim);
|
||
}
|
||
|
||
extern u32 read_capless_DTB(void);
|
||
static u8 audio_dec_inited = 0;
|
||
//////////////////////////////////////////////////////////////////////////////
|
||
int audio_dec_init()
|
||
{
|
||
int err;
|
||
|
||
printf("audio_dec_init\n");
|
||
|
||
#if TCFG_WAV_TONE_MIX_ENABLE
|
||
wav_decoder_init();
|
||
#endif/*TCFG_WAV_TONE_MIX_ENABLE*/
|
||
|
||
tone_play_init();
|
||
|
||
#if TCFG_KEY_TONE_EN
|
||
// 按键音初始化
|
||
audio_key_tone_init();
|
||
#endif
|
||
|
||
/*os_sem_create(&dac_sem, 0);*/
|
||
err = audio_decoder_task_create(&decode_task, "audio_dec");
|
||
#if (SYS_VOL_TYPE == VOL_TYPE_DIGITAL)
|
||
audio_digital_vol_init(NULL, 0);
|
||
#endif/*SYS_VOL_TYPE == VOL_TYPE_DIGITAL*/
|
||
audio_dac_init(&dac_hdl, &dac_data);
|
||
#if TCFG_AUDIO_ANC_ENABLE
|
||
audio_dac_anc_set(&dac_hdl, 1);
|
||
#endif/*TCFG_AUDIO_ANC_ENABLE*/
|
||
|
||
u32 dacr32 = read_capless_DTB();
|
||
audio_dac_set_capless_DTB(&dac_hdl, dacr32);
|
||
audio_dac_set_buff(&dac_hdl, dac_buff, sizeof(dac_buff));
|
||
#if A2DP_RX_AND_AUDIO_DELAY
|
||
audio_dac_set_delay_time(&dac_hdl, 10, AUDIO_DAC_DELAY_TIME);
|
||
#else
|
||
audio_dac_set_delay_time(&dac_hdl, 10, AUDIO_DAC_DELAY_TIME);
|
||
#endif/*A2DP_RX_AND_AUDIO_DELAY*/
|
||
audio_dac_set_analog_vol(&dac_hdl, 0);
|
||
|
||
request_irq(IRQ_AUDIO_IDX, 2, audio_irq_handler, 0);
|
||
struct audio_dac_trim dac_trim;
|
||
int len = syscfg_read(CFG_DAC_TRIM_INFO, (void *)&dac_trim, sizeof(dac_trim));
|
||
if (len != sizeof(dac_trim)) {
|
||
#if 0 //DAC 异步trim
|
||
int argv[8];
|
||
argv[0] = (int)audio_dac_trim_init;
|
||
argv[1] = 2;
|
||
do {
|
||
int err = os_taskq_post_type("audio_dec", Q_CALLBACK, 4, argv);
|
||
if (err == OS_ERR_NONE) {
|
||
break;
|
||
}
|
||
if (err != OS_Q_FULL) {
|
||
break;
|
||
}
|
||
os_time_dly(2);
|
||
} while (1);
|
||
#else
|
||
audio_dac_trim_init(0);
|
||
#endif
|
||
} else {
|
||
audio_dac_set_trim_value(&dac_hdl, &dac_trim);
|
||
}
|
||
#if TCFG_MC_BIAS_AUTO_ADJUST
|
||
mic_trim_run();
|
||
#endif/*TCFG_MC_BIAS_AUTO_ADJUST*/
|
||
audio_dac_set_fade_handler(&dac_hdl, NULL, audio_fade_in_fade_out);
|
||
#if AUDIO_CODEC_SUPPORT_SYNC
|
||
audio_sync_resample_set_filt(dac_sync_filt, sizeof(dac_sync_filt));
|
||
#endif
|
||
|
||
/*硬件SRC模块滤波器buffer设置，可根据最大使用数量设置整体buffer*/
|
||
audio_src_base_filt_init(audio_src_hw_filt, sizeof(audio_src_hw_filt));
|
||
|
||
|
||
#if AUDIO_OUT_MIXER_ENABLE
|
||
audio_mixer_open(&mixer);
|
||
audio_mixer_set_handler(&mixer, &mix_handler);
|
||
audio_mixer_set_event_handler(&mixer, mixer_event_handler);
|
||
audio_mixer_set_output_buf(&mixer, mix_buff, sizeof(mix_buff));
|
||
#else
|
||
printf("\n\n\n no support mixer !!! \n\n\n");
|
||
#endif
|
||
|
||
#if AUDIO_OUTPUT_AUTOMUTE
|
||
mix_out_automute_open();
|
||
#endif //#if AUDIO_OUTPUT_AUTOMUTE
|
||
|
||
audio_dec_inited = 1;
|
||
return err;
|
||
}
|
||
|
||
static u8 audio_dec_init_complete()
|
||
{
|
||
/*不支持Audio功能，返回idle*/
|
||
#if (defined TCFG_AUDIO_ENABLE && (TCFG_AUDIO_ENABLE == 0))
|
||
return 1;
|
||
#endif/*TCFG_AUDIO_ENABLE*/
|
||
if (!audio_dec_inited) {
|
||
return 0;
|
||
}
|
||
|
||
return 1;
|
||
}
|
||
REGISTER_LP_TARGET(audio_dec_init_lp_target) = {
|
||
.name = "audio_dec_init",
|
||
.is_idle = audio_dec_init_complete,
|
||
};
|
||
|
||
|
||
|
||
/* ----------------------debug_function---------------------------- */
|
||
/* ----------------------debug_function---------------------------- */
|
||
#include "tone_player.h"
|
||
static const char *num0_9[] = {
|
||
TONE_NUM_0,
|
||
TONE_NUM_1,
|
||
TONE_NUM_2,
|
||
TONE_NUM_3,
|
||
TONE_NUM_4,
|
||
TONE_NUM_5,
|
||
TONE_NUM_6,
|
||
TONE_NUM_7,
|
||
TONE_NUM_8,
|
||
TONE_NUM_9,
|
||
};
|
||
|
||
static void a2dp_test_tone_warning(int error, int is_seqn)
|
||
{
|
||
return ;
|
||
|
||
const char *tone_seqn[16];
|
||
if (is_seqn) {
|
||
int ten_num = 0;
|
||
int num = error;
|
||
while (num < 10) {
|
||
num /= 10;
|
||
ten_num++;
|
||
}
|
||
|
||
int list_i = 0;
|
||
int i;
|
||
tone_seqn[list_i++] = TONE_RING;
|
||
for (i = ten_num; i > 0; i--) {
|
||
tone_seqn[list_i++] = num0_9[((error / (ten_num * 10)) % 10)];
|
||
}
|
||
tone_seqn[list_i] = num0_9[(error % 10)];
|
||
tone_file_list_play(tone_seqn, 1);
|
||
} else {
|
||
tone_play_index(error, 1);
|
||
}
|
||
}
|
||
|
||
static void a2dp_error_tone_warning(int error)
|
||
{
|
||
return;
|
||
|
||
int argv[8];
|
||
argv[0] = (int)a2dp_test_tone_warning;
|
||
argv[1] = 2;
|
||
argv[2] = (int)IDEX_TONE_NUM_0 + error;
|
||
argv[3] = (int)0;
|
||
|
||
do {
|
||
int err = os_taskq_post_type("app_core", Q_CALLBACK, 4, argv);
|
||
if (err == OS_ERR_NONE) {
|
||
break;
|
||
}
|
||
|
||
os_time_dly(2);
|
||
} while (1);
|
||
}
|
||
|
||
void rx_full_tone_warning(void)
|
||
{
|
||
/* if (rx_full == 0) { */
|
||
/* rx_full = 1; */
|
||
/* } */
|
||
}
|
||
|
||
|
||
|
||
|
||
/*----------------------------------------------------------------------------*/
|
||
/**@brief 获取输出默认采样率
|
||
@param
|
||
@return 0: 采样率可变
|
||
@return 非0: 固定采样率
|
||
@note
|
||
*/
|
||
/*----------------------------------------------------------------------------*/
|
||
u32 audio_output_nor_rate(void)
|
||
{
|
||
#if (TCFG_IIS_ENABLE && TCFG_AUDIO_OUTPUT_IIS)
|
||
return TCFG_IIS_SAMPLE_RATE;
|
||
#endif
|
||
#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;
|
||
}
|
||
|
||
|
||
/*******************************************************
|
||
* 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);
|
||
}
|
||
|
||
|