lixian
/
doubao_chat
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
doubao_chat/apps/demo/demo_edr/bt_decode.c

995 lines
26 KiB
C
Raw Permalink Blame History

#include "server/audio_server.h"
#include "server/server_core.h"
#include "btstack/avctp_user.h"
#include "app_config.h"
#include "asm/sbc.h"
#include "asm/clock.h"
#include "btstack/a2dp_media_codec.h"
#include "system/timer.h"
#ifdef CONFIG_BT_ENABLE
#define log_info log_i
#define BT_MUSIC_DECODE
#define BT_PHONE_DECODE
#if TCFG_USER_EMITTER_ENABLE
#define BT_EMITTER_ENABLE
#endif
extern void earphone_a2dp_audio_codec_close(void);
extern void phone_call_end(void);
extern int a2dp_media_get_total_buffer_size(void);
#ifdef BT_MUSIC_DECODE
#define A2DP_CODEC_SBC 0x00
#define A2DP_CODEC_MPEG12 0x01
#define A2DP_CODEC_MPEG24 0x02
#define BT_AUDIO_FORMAT_SBC 1
#define BT_AUDIO_FORMAT_AAC 2
#define BT_AUDIO_FORMAT_APTX 3
#define BT_AUDIO_FORMAT_LADC 4
#define BT_AUDIO_FORMAT_CVSD 5
#define BT_AUDIO_FORMAT_MSBC 6
#define BT_DEC_RATE_MAX_STEP 100
#define BT_DEC_RATE_INC_STEP 2
#define BT_DEC_RATE_DEC_STEP 2
struct bt_media_vfs_handle {
u8 format;
u8 not_mute_cnt;
u8 a2dp_open;
u8 ready;
u16 seqn;
s16 adjust_step;
void *p_addr;
int p_len;
int p_pos;
void *audio_dec;
u32 begin_size;
u32 top_size;
u32 bottom_size;
};
static struct bt_media_vfs_handle bt_media_vfs_handle;
#define mfs (&bt_media_vfs_handle)
static void sbc_dec_event_handler(void *priv, int argc, int *argv)
{
union audio_req req = {0};
switch (argv[0]) {
case AUDIO_SERVER_EVENT_END:
earphone_a2dp_audio_codec_close();
break;
default:
break;
}
}
#define RB16(b) (u16)(((u8 *)b)[0] << 8 | (((u8 *)b))[1])
static int get_rtp_header_len(u8 *buf, int len)
{
int ext, csrc;
int byte_len;
int header_len = 0;
u8 *data = buf;
if (RB16(buf + 2) != (u16)(mfs->seqn + 1) && mfs->seqn) {
putchar('K');
}
mfs->seqn = RB16(buf + 2);
csrc = buf[0] & 0x0f;
ext = buf[0] & 0x10;
byte_len = 12 + 4 * csrc;
buf += byte_len;
if (ext) {
ext = (RB16(buf + 2) + 1) << 2;
}
header_len = byte_len + ext + 1;
if (mfs->format == BT_AUDIO_FORMAT_SBC) {
/*sbc兼容性处理*/
while (data[header_len] != 0x9c) {
if (++header_len > len) {
log_w("sbc warn\n");
return len;
}
}
}
if (header_len != byte_len + ext + 1) {
/* log_w("sbc warn!!!\n"); */
/* put_buf(data, len); */
}
return header_len;
}
static void media_stream_free(void)
{
if (mfs->p_addr) {
a2dp_media_free_packet(mfs->p_addr);
mfs->p_addr = NULL;
mfs->p_pos = 0;
mfs->p_len = 0;
}
}
static int bt_sbc_file_read(void *priv, void *buf, u32 len)
{
u32 r_len = 0;
u32 offset = 0;
do {
if (!mfs->p_addr) {
mfs->p_len = a2dp_media_get_packet((u8 **)&mfs->p_addr);
if (!mfs->p_addr) {
if (!mfs->a2dp_open) {
return 0;
}
if (mfs->p_len == -EINVAL) {
return -1;
}
continue;
}
mfs->p_pos = get_rtp_header_len(mfs->p_addr, mfs->p_len);
}
if (len == (u32) - 1) { //第一包
if (0x800 > mfs->p_len && mfs->format == BT_AUDIO_FORMAT_SBC) {
memcpy(buf, (u8 *)mfs->p_addr, mfs->p_len);
offset = mfs->p_len;
media_stream_free();
break;
} else {
if (mfs->format == BT_AUDIO_FORMAT_SBC) {
memcpy(buf, (u8 *)mfs->p_addr, 0x20);
} else {
memcpy(buf, (u8 *)mfs->p_addr + mfs->p_pos, 0x20);
}
offset = 0x20;
media_stream_free();
break;
}
}
if (!mfs->ready) {
//等待存够50ms才开始解码
while (a2dp_media_get_remain_play_time(0) < 50) {
if (!mfs->a2dp_open) {
return 0;
}
os_time_dly(1);
}
mfs->ready = 1;
}
r_len = mfs->p_len - mfs->p_pos;
if (r_len > (len - offset)) {
r_len = len - offset;
}
memcpy((u8 *)buf + offset, (u8 *)mfs->p_addr + mfs->p_pos, r_len);
mfs->p_pos += r_len;
offset += r_len;
if (mfs->p_pos >= mfs->p_len) {
media_stream_free();
if (mfs->format == BT_AUDIO_FORMAT_SBC) {
break;
}
}
} while (offset < len);
return offset;
}
static int bt_sbc_file_seek(void *priv, u32 offset, int orig)
{
return 0;
}
static const struct audio_vfs_ops bt_sbc_audio_dec_vfs_ops = {
.fread = bt_sbc_file_read,
.fseek = bt_sbc_file_seek,
};
static int bt_sync(void *priv, u32 data_size, u16 *in_rate, u16 *out_rate)
{
data_size = a2dp_media_get_total_data_len();
if (data_size < mfs->bottom_size) {
/* putchar('<'); */
mfs->adjust_step += BT_DEC_RATE_INC_STEP;
if (mfs->adjust_step < 0) {
mfs->adjust_step += BT_DEC_RATE_INC_STEP * 2;
}
} else if (data_size > mfs->top_size) {
/* putchar('>'); */
mfs->adjust_step -= BT_DEC_RATE_DEC_STEP;
if (mfs->adjust_step > 0) {
mfs->adjust_step -= BT_DEC_RATE_DEC_STEP * 2;
}
} else {
/* putchar('='); */
if (mfs->adjust_step > 0) {
mfs->adjust_step -= (mfs->adjust_step * BT_DEC_RATE_INC_STEP) / BT_DEC_RATE_MAX_STEP;
if (mfs->adjust_step > 0) {
mfs->adjust_step--;
}
} else if (mfs->adjust_step < 0) {
mfs->adjust_step += ((0 - mfs->adjust_step) * BT_DEC_RATE_DEC_STEP) / BT_DEC_RATE_MAX_STEP;
if (mfs->adjust_step < 0) {
mfs->adjust_step++;
}
}
}
if (mfs->adjust_step < -BT_DEC_RATE_MAX_STEP) {
mfs->adjust_step = -BT_DEC_RATE_MAX_STEP;
/* putchar('{'); */
} else if (mfs->adjust_step > BT_DEC_RATE_MAX_STEP) {
mfs->adjust_step = BT_DEC_RATE_MAX_STEP;
/* putchar('}'); */
}
*out_rate += mfs->adjust_step;
return 0;
}
void *earphone_a2dp_audio_codec_open(int media_type, u8 volume)
{
union audio_req req = {0};
int err = 0;
mfs->audio_dec = server_open("audio_server", "dec");
if (!mfs->audio_dec) {
return NULL;
}
/*播放事件注册(这个可以先不用加,根据需要添加)*/
server_register_event_handler(mfs->audio_dec, mfs, sbc_dec_event_handler);
switch (media_type) {
case A2DP_CODEC_SBC:
req.dec.dec_type = "sbc";
mfs->format = BT_AUDIO_FORMAT_SBC;
break;
case A2DP_CODEC_MPEG24:
req.dec.dec_type = "aac";
mfs->format = BT_AUDIO_FORMAT_AAC;
break;
}
req.dec.cmd = AUDIO_DEC_OPEN;
req.dec.volume = volume;
req.dec.output_buf = NULL;
req.dec.output_buf_len = 2 * 1024;
req.dec.channel = 0;
req.dec.sample_rate = 0;
req.dec.vfs_ops = &bt_sbc_audio_dec_vfs_ops;
req.dec.sample_source = "dac";
#if defined CONFIG_AUDIO_MIX_ENABLE
req.dec.attr = AUDIO_ATTR_REAL_TIME;
req.dec.dec_sync = bt_sync;
#endif
if (media_type == A2DP_CODEC_MPEG24) {
req.dec.attr |= AUDIO_ATTR_BT_AAC_EN;
}
mfs->a2dp_open = 1;
err = server_request(mfs->audio_dec, AUDIO_REQ_DEC, &req);
if (err) {
mfs->a2dp_open = 0;
server_close(mfs->audio_dec);
mfs->audio_dec = NULL;
return NULL;
}
mfs->seqn = 0;
mfs->adjust_step = 0;
int a2dp_total_size = a2dp_media_get_total_buffer_size();
mfs->begin_size = a2dp_total_size * 6 / 10;
mfs->top_size = a2dp_total_size / 2;
mfs->bottom_size = a2dp_total_size * 3 / 10;
req.dec.cmd = AUDIO_DEC_START;
server_request(mfs->audio_dec, AUDIO_REQ_DEC, &req);
return mfs->audio_dec;
}
void earphone_a2dp_audio_codec_close(void)
{
union audio_req req = {0};
mfs->a2dp_open = 0;
if (!mfs->audio_dec) {
return;
}
log_info("audio decode server close\n");
req.dec.cmd = AUDIO_DEC_STOP;
server_request(mfs->audio_dec, AUDIO_REQ_DEC, &req);
server_close(mfs->audio_dec);
media_stream_free();
mfs->audio_dec = NULL;
mfs->ready = 0;
}
#endif
#ifdef BT_PHONE_DECODE
extern void lmp_private_free_esco_packet(void *packet);
extern void *lmp_private_get_esco_packet(int *len, u32 *hash);
extern int lmp_private_send_esco_packet(void *priv, u8 *packet, int len);
extern u32 lmp_private_get_tx_remain_buffer(void);
struct bt_phone_vfs_handle {
u8 state;
u8 format;
u8 mute;
u8 lmp_open;
void *p_addr;
int p_len;
int p_pos;
int frame_offset;
int err_cnt;
int frame_len;
void *audio_dec;
void *audio_enc;
};
static struct bt_phone_vfs_handle bt_phone_vfs_handle;
#define pfs (&bt_phone_vfs_handle)
static u8 headcheck(u8 *buf)
{
int sync_word = buf[0] | ((buf[1] & 0x0f) << 8);
return (sync_word == 0x801) && (buf[2] == 0xAD);
}
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 const u8 msbc_err_data[] = {
0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
};
static void phone_stream_free(void)
{
if (pfs->p_addr) {
lmp_private_free_esco_packet(pfs->p_addr);
pfs->p_addr = NULL;
pfs->p_pos = 0;
pfs->p_len = 0;
}
}
static int bt_phone_file_read(void *priv, void *buf, u32 len)
{
u32 r_len = 0;
u32 offset = 0;
u32 hash = 0;
do {
if (!pfs->p_addr) {
if (pfs->mute) {
pfs->p_addr = (void *)msbc_mute_data;
pfs->p_len = sizeof(msbc_mute_data);
} else {
pfs->p_addr = (u8 *)lmp_private_get_esco_packet(&pfs->p_len, &hash);
if (pfs->p_addr) {
/* put_buf(pfs->p_addr,pfs->p_len); */
u8 test_check[4];
memset(test_check, 0, 4);
memcpy(test_check, pfs->p_addr, 4);
if (test_check[0] == 0x55 && test_check[1] == 0x55 && test_check[2] == 0xAA && test_check[3] == 0xAA) { //丢/错包标记0xAAAA5555
memcpy(buf, msbc_err_data, len);
phone_stream_free();
return len;
break;
}
}
}
if (!pfs->p_addr) {
pfs->p_len = 0;
if (!pfs->lmp_open) {
printf("lmp file close \r\n");
return 0;
} else {
#if 0
os_time_dly(1);
continue;
#else
return -1;
#endif
}
}
pfs->p_pos = 0;
}
if (pfs->frame_offset == 0) {
if (pfs->format == BT_AUDIO_FORMAT_MSBC) {
u32 head_offset = 0;
u8 *ptr = (u8 *)pfs->p_addr + pfs->p_pos;
int check_len = pfs->p_len - pfs->p_pos;
while (head_offset < check_len) {
if (ptr[head_offset] == 0xAD) {
if (head_offset >= 2) {
if (!headcheck(ptr + head_offset - 2)) {
/* put_buf(pfs->p_addr, pfs->p_len); */
pfs->err_cnt++;
head_offset++;
continue;
}
}
break;
}
pfs->err_cnt++;
head_offset++;
}
if (pfs->err_cnt >= pfs->frame_len + 2) {
phone_stream_free();
pfs->mute = 1;
pfs->err_cnt = 0;
continue;
}
if (pfs->p_pos >= pfs->p_len) {
phone_stream_free();
continue;
}
pfs->p_pos += head_offset;
pfs->err_cnt = 0;
} else if (pfs->format == BT_AUDIO_FORMAT_CVSD) {
pfs->frame_len = pfs->p_len;
}
}
r_len = pfs->frame_len - pfs->frame_offset;
if (r_len > (len - offset)) {
r_len = len - offset;
}
if (r_len > (pfs->p_len - pfs->p_pos)) {
r_len = pfs->p_len - pfs->p_pos;
}
memcpy((u8 *)buf + offset, (u8 *)pfs->p_addr + pfs->p_pos, r_len);
offset += r_len;
pfs->p_pos += r_len;
pfs->frame_offset += r_len;
if (pfs->frame_offset >= pfs->frame_len) {
pfs->frame_offset = 0;
}
if (pfs->p_pos >= pfs->p_len) {
if (pfs->mute) {
pfs->p_addr = NULL;
pfs->p_len = 0;
pfs->p_pos = 0;
pfs->mute = 0;
} else {
phone_stream_free();
break;
}
}
} while (offset < len);
if (offset < len) {
putchar('K');
return -1; //华为语音助手唤醒时偶尔会发两个不规范的包
}
return offset;
}
static int bt_phone_file_write(void *priv, void *buf, u32 len)
{
if (!pfs->lmp_open) {
return 0;
}
if (lmp_private_get_tx_remain_buffer() >= len + 28) {
lmp_private_send_esco_packet(NULL, buf, len);
}
return len;
}
static int bt_phone_file_seek(void *priv, u32 offset, int orig)
{
return 0;
}
static int bt_phone_file_len(void *priv)
{
return -1;
}
static const struct audio_vfs_ops bt_phone_audio_dec_vfs_ops = {
.fread = bt_phone_file_read,
.fwrite = bt_phone_file_write,
.fseek = bt_phone_file_seek,
.flen = bt_phone_file_len,
};
static void phone_call_dec_event_handler(void *priv, int argc, int *argv)
{
switch (argv[0]) {
/* case AUDIO_SERVER_EVENT_ERR: */
case AUDIO_SERVER_EVENT_END:
phone_call_end();
break;
default:
break;
}
}
static void *phone_decode_start(int format, u8 volume)
{
union audio_req req = {0};
pfs->audio_dec = server_open("audio_server", "dec");
if (!pfs->audio_dec) {
log_info("audio decode server open error\n");
return NULL;
}
server_register_event_handler(pfs->audio_dec, NULL, phone_call_dec_event_handler);
pfs->format = format;
pfs->frame_offset = 0;
pfs->err_cnt = 0;
if (format == BT_AUDIO_FORMAT_MSBC) {
req.dec.dec_type = "msbc";
req.dec.sample_rate = 16000;
pfs->frame_len = 58;
pfs->mute = 0;
} else if (format == BT_AUDIO_FORMAT_CVSD) {
req.dec.dec_type = "cvsd";
req.dec.sample_rate = 8000;
}
req.dec.cmd = AUDIO_DEC_OPEN;
req.dec.volume = volume;
req.dec.output_buf = NULL;
req.dec.output_buf_len = 1024 * 4;
req.dec.channel = 2;
req.dec.priority = 1;
req.dec.vfs_ops = &bt_phone_audio_dec_vfs_ops;
req.dec.sample_source = "dac";
server_request(pfs->audio_dec, AUDIO_REQ_DEC, &req);
req.dec.cmd = AUDIO_DEC_START;
req.dec.attr = AUDIO_ATTR_NO_WAIT_READY;
server_request(pfs->audio_dec, AUDIO_REQ_DEC, &req);
return pfs->audio_dec;
}
static void phone_decode_close(void)
{
union audio_req req = {0};
if (!pfs->audio_dec) {
return;
}
req.dec.cmd = AUDIO_DEC_STOP;
server_request(pfs->audio_dec, AUDIO_REQ_DEC, &req);
server_close(pfs->audio_dec);
phone_stream_free();
pfs->audio_dec = NULL;
}
static int phone_speak_start(int format, int packet_len)
{
int err = 0;
union audio_req req = {0};
pfs->audio_enc = server_open("audio_server", "enc");
if (!pfs->audio_enc) {
log_info("audio enc server open error\n");
return -1;
}
req.enc.cmd = AUDIO_ENC_OPEN;
req.enc.channel = 1;
req.enc.volume = 100;
req.enc.output_buf = NULL;
req.enc.sample_source = "mic";
req.enc.vfs_ops = &bt_phone_audio_dec_vfs_ops;
#ifdef CONFIG_ALL_ADC_CHANNEL_OPEN_ENABLE
req.enc.channel_bit_map = BIT(CONFIG_PHONE_CALL_ADC_CHANNEL);
#endif
if (format == BT_AUDIO_FORMAT_MSBC) {
req.enc.format = "msbc";
req.enc.sample_rate = 16000;
req.enc.output_buf_len = 512;
} else if (format == BT_AUDIO_FORMAT_CVSD) {
req.enc.format = "cvsd";
req.enc.sample_rate = 8000;
req.enc.frame_size = packet_len * 2;
req.enc.output_buf_len = packet_len * 2 * 10;
}
#if defined CONFIG_AEC_ENC_ENABLE && !defined CONFIG_FPGA_ENABLE
#define AEC_EN BIT(0)
#define NLP_EN BIT(1)
#define ANS_EN BIT(2)
/*aec module enable bit define*/
#define AEC_MODE_ADVANCE (AEC_EN | NLP_EN | ANS_EN)
#define AEC_MODE_REDUCE (NLP_EN | ANS_EN)
#define AEC_MODE_SIMPLEX (ANS_EN)
struct aec_s_attr aec_param = {0};
aec_param.EnableBit = AEC_MODE_ADVANCE;
/* aec_param.agc_en = 1; */
aec_param.output_way = 1; //1:使用硬件回采 0:使用软件回采
req.enc.aec_attr = &aec_param;
req.enc.aec_enable = 1;
extern void get_cfg_file_aec_config(struct aec_s_attr * aec_param);
get_cfg_file_aec_config(&aec_param);
#if 0
aec_param.ANS_NoiseLevel = 2.2e3f; //初始噪声水平,用来加速降噪收敛,跟 mic 信号的信噪比有关。 Mic 信号信噪比高， 该值可以小一点， 反之则需要稍微大一点。default: 2.2e3f(0 ~ 32767)
#endif
if (aec_param.EnableBit == 0) {
req.enc.aec_enable = 0;
req.enc.aec_attr = NULL;
}
if (aec_param.EnableBit != AEC_MODE_ADVANCE) {
aec_param.output_way = 0;
}
if (aec_param.output_way) {
#ifdef CONFIG_ALL_ADC_CHANNEL_OPEN_ENABLE
req.enc.channel_bit_map |= BIT(CONFIG_AEC_ADC_CHANNEL); //配置回采硬件通道
if (CONFIG_AEC_ADC_CHANNEL < CONFIG_PHONE_CALL_ADC_CHANNEL) {
req.enc.ch_data_exchange = 1; //如果回采通道使用的硬件channel比MIC通道使用的硬件channel靠前的话处理数据时需要交换一下顺序
}
#endif
}
aec_param.AGC_echo_look_ahead = 100;
aec_param.AGC_echo_hold = 400;
aec_param.ES_Unconverge_OverDrive = aec_param.ES_MinSuppress;
if (req.enc.sample_rate == 16000) {
aec_param.wideband = 1;
aec_param.hw_delay_offset = 50;
} else {
aec_param.wideband = 0;
aec_param.hw_delay_offset = 75;
}
#if CONFIG_AEC_SIMPLEX_ENABLE
#define AEC_SIMPLEX_TAIL 15 /*单工连续清0的帧数*/
/*远端数据大于CONST_AEC_SIMPLEX_THR,即清零近端数据越小，回音限制得越好，同时也就越容易卡*/
#define AEC_SIMPLEX_THR 100000 /*default:260000*/
aec_param.wn_en = 1;
aec_param.simplex = 1;
aec_param.dly_est = 1;
aec_param.wn_gain = 331;
aec_param.dst_delay = 50;
aec_param.EnableBit = AEC_MODE_SIMPLEX;
aec_param.SimplexTail = req.enc.sample_rate == 8000 ? AEC_SIMPLEX_TAIL / 2 : AEC_SIMPLEX_TAIL;
aec_param.SimplexThr = AEC_SIMPLEX_THR;
#endif/*TCFG_AEC_SIMPLEX*/
#endif
err = server_request(pfs->audio_enc, AUDIO_REQ_ENC, &req);
#if defined CONFIG_AEC_ENC_ENABLE && !defined CONFIG_FPGA_ENABLE
if (aec_param.output_way) {
#ifdef CONFIG_ALL_ADC_CHANNEL_OPEN_ENABLE
extern void adc_multiplex_set_gain(const char *source, u8 channel_bit_map, u8 gain);
adc_multiplex_set_gain("mic", BIT(CONFIG_AEC_ADC_CHANNEL), CONFIG_AEC_AUDIO_ADC_GAIN);
#endif
}
#endif
return err;
}
static int phone_speak_close(void)
{
union audio_req req = {0};
if (pfs->audio_enc) {
req.enc.cmd = AUDIO_ENC_STOP;
server_request(pfs->audio_enc, AUDIO_REQ_ENC, &req);
server_close(pfs->audio_enc);
pfs->audio_enc = NULL;
}
return 0;
}
void *phone_call_begin(void *priv, u8 volume)
{
int err = 0;
u32 esco_param = *(u32 *)priv;
int esco_len = esco_param >> 16;
int codec_type = esco_param & 0x000000ff;
if (codec_type == 3) {
log_info(">>sco_format:msbc\n");
codec_type = BT_AUDIO_FORMAT_MSBC;
} else if (codec_type == 2) {
log_info(">>sco_format:cvsd\n");
codec_type = BT_AUDIO_FORMAT_CVSD;
} else {
log_info("sco_format:error->please check %d\n", codec_type);
return NULL;
}
pfs->lmp_open = 1;
err = phone_speak_start(codec_type, esco_len);
if (err) {
goto __err;
}
return phone_decode_start(codec_type, volume);
__err:
phone_call_end();
return NULL;
}
void phone_call_end(void)
{
pfs->lmp_open = 0;
phone_speak_close();
phone_decode_close();
}
#endif
#ifdef BT_EMITTER_ENABLE
#define BT_EMITTER_CBUF_SIZE (512 * 6)
typedef struct sbc_param_str {
unsigned int flags;
u8 frequency;
u8 blocks;
u8 subbands;
u8 mode;
u8 allocation;
u8 bitpool;
u8 endian;
void *priv;
void *priv_alloc_base;
} sbc_t;
struct bt_emitter_vfs_handle {
u8 open;
u8 gain;
u8 suspend;
u16 frame_size;
void *audio_enc;
cbuffer_t cbuf;
void *buf;
};
static struct bt_emitter_vfs_handle bt_emitter_vfs_handle = {.gain = 100};
#define efs (&bt_emitter_vfs_handle)
static int bt_emitter_vfs_fwrite(void *file, void *data, u32 len)
{
cbuffer_t *cbuf = (cbuffer_t *)file;
efs->frame_size = len;
if (cbuf_write(cbuf, data, len) != len) {
putchar('N');
cbuf_clear(cbuf);
} else if (efs->suspend) {
efs->suspend = 0;
extern void stack_run_loop_resume();
stack_run_loop_resume();
}
return len;
}
static int bt_emitter_vfs_fclose(void *file)
{
return 0;
}
static const struct audio_vfs_ops bt_emitter_vfs_ops = {
.fwrite = bt_emitter_vfs_fwrite,
.fclose = bt_emitter_vfs_fclose,
};
int a2dp_sbc_encoder_init(void *sbc_struct)
{
int ret = 0;
union audio_req req = {0};
sbc_t *sbc = (sbc_t *)sbc_struct;
if (sbc) {
log_info("audio emitter server open \n");
efs->buf = malloc(BT_EMITTER_CBUF_SIZE);
if (!efs->buf) {
return -1;
}
efs->audio_enc = server_open("audio_server", "enc");
if (!efs->audio_enc) {
free(efs->buf);
efs->buf = NULL;
return -1;
}
cbuf_init(&efs->cbuf, efs->buf, BT_EMITTER_CBUF_SIZE);
req.enc.cmd = AUDIO_ENC_OPEN;
req.enc.channel = sbc->mode > 0 ? 2 : 1;
req.enc.volume = efs->gain;
req.enc.frame_size = (sbc->subbands ? 8 : 4) * (4 + (sbc->blocks * 4)) * req.enc.channel * 2;
req.enc.output_buf_len = 4 * req.enc.frame_size;
req.enc.format = "sbc";
req.enc.sample_source = "mic";
req.enc.vfs_ops = &bt_emitter_vfs_ops;
req.enc.file = (FILE *)&efs->cbuf;
req.enc.bitrate = ((3 - sbc->blocks) << 28) & sbc->bitpool;
if (sbc->endian) {
req.enc.bitrate |= BIT(31);
}
if (!sbc->subbands) {
req.enc.bitrate |= BIT(30);
}
if (sbc->frequency == SBC_FREQ_48000) {
req.enc.sample_rate = 48000;
} else if (sbc->frequency == SBC_FREQ_44100) {
req.enc.sample_rate = 44100;
} else if (sbc->frequency == SBC_FREQ_32000) {
req.enc.sample_rate = 32000;
} else {
req.enc.sample_rate = 16000;
}
if (req.enc.channel == 2) {
req.enc.channel_bit_map = BIT(CONFIG_AUDIO_ADC_CHANNEL_L) | BIT(CONFIG_AUDIO_ADC_CHANNEL_R);
} else {
req.enc.channel_bit_map = BIT(CONFIG_AUDIO_ADC_CHANNEL_L);
}
ret = server_request(efs->audio_enc, AUDIO_REQ_ENC, &req);
if (!ret) {
efs->open = 1;
}
return ret;
} else {
log_info("audio emitter server close \n");
efs->open = 0;
if (efs->audio_enc) {
req.enc.cmd = AUDIO_ENC_CLOSE;
server_request(efs->audio_enc, AUDIO_REQ_ENC, &req);
server_close(efs->audio_enc);
efs->audio_enc = NULL;
}
if (efs->buf) {
cbuf_clear(&efs->cbuf);
free(efs->buf);
efs->buf = NULL;
}
efs->frame_size = 0;
efs->suspend = 0;
return 0;
}
}
int a2dp_sbc_encoder_get_data(u8 *packet, u16 buf_len, int *frame_size)
{
int number = 0;
u32 data_size = 0;
while (efs->open) {
data_size = cbuf_get_data_size(&efs->cbuf);
if (!data_size) {
efs->suspend = 1;
return 0;
}
if (buf_len < data_size) {
data_size = buf_len;
}
number = data_size / efs->frame_size; /*取整数包*/
*frame_size = efs->frame_size;
data_size = cbuf_read(&efs->cbuf, packet, *frame_size * number);
if (data_size > 0) {
return data_size;
}
}
return 0;
}
u8 bt_emitter_stu_get(void)
{
return efs->open;
}
int bt_emitter_enc_gain_set(int step)
{
if (efs->audio_enc) {
union audio_req req = {0};
int gain = efs->gain + step;
if (gain < 0) {
gain = 0;
} else if (gain > 100) {
gain = 100;
}
if (gain == efs->gain) {
return -1;
}
efs->gain = gain;
log_d("set_enc_gain: %d\n", gain);
req.enc.cmd = AUDIO_ENC_SET_VOLUME;
req.enc.volume = gain;
return server_request(efs->audio_enc, AUDIO_REQ_ENC, &req);
}
return -1;
}
#endif
#endif
Reference in New Issue View Git Blame Copy Permalink