921 lines
25 KiB
C
921 lines
25 KiB
C
#include "asm/includes.h"
|
||
#include "media/includes.h"
|
||
#include "system/includes.h"
|
||
#include "aec_user.h"
|
||
#include "asm/audio_src.h"
|
||
#include "audio_enc.h"
|
||
#include "app_main.h"
|
||
#include "btstack/avctp_user.h"
|
||
#include "audio_digital_vol.h"
|
||
#include "audio_sbc_codec.h"
|
||
#include "clock_cfg.h"
|
||
#include "media/pcm_decoder.h"
|
||
#include "audio_dec.h"
|
||
|
||
#define SBC_AUDIO_OVERLAY 0 // sbc发射和audio空间互用
|
||
|
||
#define BT_USE_PCM_DEC 0 //多加一个解码，会多耗资源，时钟也会增加,用来解决完全切歌的时候出现杂音的问题
|
||
|
||
#define SBC_RESERVED_LAST_PCM 1 //淡入淡出功能，耗资源很小，可以解决正常速度切歌杂音，但是快速连续切歌会有杂音
|
||
|
||
enum {
|
||
SBC_RUN_STEP_NOR = 0,
|
||
SBC_RUN_STEP_WAIT_STOP,
|
||
SBC_RUN_STEP_STOP,
|
||
SBC_RUN_STEP_WAIT_NOR,
|
||
};
|
||
|
||
extern struct audio_encoder_task *encode_task;
|
||
//static struct audio_encoder_task *encode_task = NULL;
|
||
#define SBC_ENC_WRITING BIT(1)
|
||
#define SBC_ENC_START BIT(2)
|
||
#define SBC_ENC_WAKEUP_SEND BIT(3) /*减少唤醒问题*/
|
||
#define SBC_ENC_PCM_MUTE_DATA BIT(4) /*发一包静音数据*/
|
||
|
||
static u8 sbc_buf_flag = 0;
|
||
#define ESCO_ADC_BUF_NUM 2
|
||
#define ESCO_ADC_IRQ_POINTS 256
|
||
#define ESCO_ADC_BUFS_SIZE (ESCO_ADC_BUF_NUM * ESCO_ADC_IRQ_POINTS)
|
||
|
||
#define SBC_USE_MIC_CHANNEL 0
|
||
#define SBC_ENC_PACK_ENABLE 0 /*sbc数据包封装*/
|
||
#define SBC_ENC_IN_SIZE 512
|
||
#define SBC_ENC_OUT_SIZE 256
|
||
|
||
#define SBC_ENC_IN_CBUF_SIZE (SBC_ENC_IN_SIZE * 8)
|
||
#define SBC_ENC_OUT_CBUF_SIZE (SBC_ENC_OUT_SIZE * 8)
|
||
|
||
|
||
struct sbc_enc_hdl {
|
||
struct audio_encoder encoder;
|
||
OS_SEM pcm_frame_sem;
|
||
u8 output_frame[SBC_ENC_OUT_SIZE];
|
||
u8 pcm_frame[SBC_ENC_IN_SIZE];
|
||
u8 frame_size;
|
||
u8 backup_digital_vol;
|
||
u8 overlay;
|
||
#if SBC_RESERVED_LAST_PCM
|
||
u8 run_step;
|
||
u8 run_cnt;
|
||
u8 in_cnt;
|
||
OS_SEM run_sem;
|
||
#endif
|
||
cbuffer_t output_cbuf;
|
||
u8 *p_out_cbuf_buf;
|
||
cbuffer_t pcm_in_cbuf;/*要注意要跟DAC的buf大小一致*/
|
||
u8 *p_in_cbuf_buf;
|
||
#if SBC_ENC_PACK_ENABLE
|
||
u16 cp_type;
|
||
u16 packet_head_sn;
|
||
#endif
|
||
int mute_data_send_timer;
|
||
#if SBC_USE_MIC_CHANNEL
|
||
struct audio_adc_output_hdl adc_output;
|
||
struct adc_mic_ch mic_ch;
|
||
s16 adc_buf[ESCO_ADC_BUFS_SIZE]; //align 4Bytes
|
||
#endif
|
||
|
||
#if BT_USE_PCM_DEC
|
||
struct audio_mixer_ch mix_ch;
|
||
struct audio_res_wait wait;
|
||
struct pcm_decoder pcm_dec; // pcm解码句柄
|
||
struct audio_stream *audio_stream; // 音频流
|
||
#endif
|
||
|
||
|
||
/* dvol_handle *dvol; */
|
||
};
|
||
static struct sbc_enc_hdl *sbc_enc = NULL;
|
||
|
||
__attribute__((weak))
|
||
void audio_sbc_enc_inbuf_resume(void)
|
||
{
|
||
;
|
||
}
|
||
|
||
__attribute__((weak))
|
||
void audio_sbc_enc_open_exit(void)
|
||
{
|
||
;
|
||
}
|
||
|
||
__attribute__((weak))
|
||
void audio_sbc_enc_close_enter(void)
|
||
{
|
||
;
|
||
}
|
||
|
||
#if BT_USE_PCM_DEC
|
||
|
||
static int pcm_fread(void *hdl, void *buf, int len)
|
||
{
|
||
len = len / 2;
|
||
memset(buf, 0, len);
|
||
return len;
|
||
}
|
||
static int pcm_dec_data_handler(struct audio_stream_entry *entry,
|
||
struct audio_data_frame *in,
|
||
struct audio_data_frame *out)
|
||
{
|
||
struct audio_decoder *decoder = container_of(entry, struct audio_decoder, entry);
|
||
struct pcm_decoder *pcm_dec = container_of(decoder, struct pcm_decoder, decoder);
|
||
struct sbc_enc_hdl *dec = container_of(pcm_dec, struct sbc_enc_hdl, pcm_dec);
|
||
audio_stream_run(&decoder->entry, in);
|
||
/* audio_mixer_ch_pause(&dec->mix_ch, 0); */
|
||
return decoder->process_len;
|
||
}
|
||
static void pcm_dec_event_handler(struct audio_decoder *decoder, int argc, int *argv)
|
||
{
|
||
}
|
||
static void dec_out_stream_resume(void *p)
|
||
{
|
||
struct sbc_enc_hdl *dec = (struct sbc_enc_hdl *)p;
|
||
|
||
audio_decoder_resume(&dec->pcm_dec.decoder);
|
||
}
|
||
static int pcm_dec_start(struct sbc_enc_hdl *stream)
|
||
{
|
||
int err = 0;
|
||
if (stream == NULL) {
|
||
return -EINVAL;
|
||
}
|
||
err = pcm_decoder_open(&stream->pcm_dec, &decode_task);
|
||
if (err) {
|
||
return err;
|
||
}
|
||
pcm_decoder_set_event_handler(&stream->pcm_dec, pcm_dec_event_handler, 0);
|
||
pcm_decoder_set_read_data(&stream->pcm_dec, pcm_fread, stream);
|
||
pcm_decoder_set_data_handler(&stream->pcm_dec, pcm_dec_data_handler);
|
||
|
||
audio_mixer_ch_open(&stream->mix_ch, &mixer);
|
||
audio_mixer_ch_set_src(&stream->mix_ch, 0, 0);
|
||
struct audio_stream_entry *entries[8] = {NULL};
|
||
u8 entry_cnt = 0;
|
||
entries[entry_cnt++] = &stream->pcm_dec.decoder.entry;
|
||
entries[entry_cnt++] = &stream->mix_ch.entry;
|
||
stream->audio_stream = audio_stream_open(stream, dec_out_stream_resume);
|
||
audio_stream_add_list(stream->audio_stream, entries, entry_cnt);
|
||
|
||
audio_output_set_start_volume(APP_AUDIO_STATE_MUSIC);
|
||
err = audio_decoder_start(&stream->pcm_dec.decoder);
|
||
if (err == 0) {
|
||
printf("pcm_dec_start ok\n");
|
||
}
|
||
return err;
|
||
}
|
||
static void pcm_dec_stop(struct sbc_enc_hdl *stream)
|
||
{
|
||
printf("mic stream dec stop \n\n");
|
||
if (stream) {
|
||
|
||
pcm_decoder_close(&stream->pcm_dec);
|
||
audio_mixer_ch_close(&stream->mix_ch);
|
||
if (stream->audio_stream) {
|
||
audio_stream_close(stream->audio_stream);
|
||
stream->audio_stream = NULL;
|
||
}
|
||
}
|
||
}
|
||
|
||
static int pcmdec_wait_res_handler(struct audio_res_wait *wait, int event)
|
||
{
|
||
int err = 0;
|
||
struct sbc_enc_hdl *stream = container_of(wait, struct sbc_enc_hdl, wait);
|
||
if (event == AUDIO_RES_GET) {
|
||
err = pcm_dec_start(stream);
|
||
} else if (event == AUDIO_RES_PUT) {
|
||
/* pcm_dec_stop(stream); */
|
||
}
|
||
|
||
return err;
|
||
}
|
||
static int pcm_dec_open(struct sbc_enc_hdl *stream, struct audio_fmt *pfmt)
|
||
{
|
||
stream->pcm_dec.output_ch_num = stream->pcm_dec.ch_num = pfmt->channel;
|
||
stream->pcm_dec.sample_rate = pfmt->sample_rate;
|
||
if (stream->pcm_dec.output_ch_num == 2) {
|
||
stream->pcm_dec.output_ch_type = AUDIO_CH_LR;
|
||
} else {
|
||
stream->pcm_dec.output_ch_type = AUDIO_CH_DIFF;
|
||
}
|
||
|
||
stream->wait.priority = 0;
|
||
stream->wait.preemption = 0;
|
||
stream->wait.protect = 1;
|
||
stream->wait.handler = pcmdec_wait_res_handler;
|
||
return audio_decoder_task_add_wait(&decode_task, &stream->wait);
|
||
}
|
||
|
||
static void pcm_dec_close(struct sbc_enc_hdl *stream)
|
||
{
|
||
pcm_dec_stop(stream);
|
||
audio_decoder_task_del_wait(&decode_task, &stream->wait);
|
||
}
|
||
|
||
#endif /*BT_USE_PCM_DEC*/
|
||
|
||
|
||
#if SBC_RESERVED_LAST_PCM
|
||
static void sbc_enc_pcm_data_fade_out(s16 *data, int len)
|
||
{
|
||
u16 samples = len >> 1;
|
||
int down_step = (32767 + samples - 1) / samples + 1;
|
||
int value = 32767;
|
||
|
||
for (int i = 0; i < samples; i++) {
|
||
if (value > down_step) {
|
||
value -= down_step;
|
||
} else {
|
||
value = 0;
|
||
}
|
||
s32 tmp = *data;
|
||
*data++ = tmp * value / 32767;
|
||
}
|
||
}
|
||
static void sbc_enc_pcm_data_fade_in(s16 *data, int len)
|
||
{
|
||
|
||
u16 samples = len >> 1;
|
||
int down_step = (32767 + samples - 1) / samples + 1;
|
||
int value = 0;
|
||
|
||
for (int i = 0; i < samples; i++) {
|
||
if (value + down_step < 32767) {
|
||
value += down_step;
|
||
} else {
|
||
value = 32767;
|
||
}
|
||
s32 tmp = *data;
|
||
*data++ = tmp * value / 32767;
|
||
}
|
||
|
||
}
|
||
|
||
#endif /* SBC_RESERVED_LAST_PCM */
|
||
|
||
static void sbc_send_mute_data()
|
||
{
|
||
sbc_buf_flag |= SBC_ENC_PCM_MUTE_DATA;
|
||
audio_encoder_resume(&sbc_enc->encoder);
|
||
}
|
||
static int sbc_enc_pcm_get(struct audio_encoder *encoder, s16 **frame, u16 frame_len)
|
||
{
|
||
u8 read_flag = 1;
|
||
int pcm_len = 0;
|
||
if (encoder == NULL) {
|
||
r_printf("encoder NULL");
|
||
}
|
||
struct sbc_enc_hdl *enc = container_of(encoder, struct sbc_enc_hdl, encoder);
|
||
|
||
if (enc == NULL) {
|
||
r_printf("enc NULL");
|
||
}
|
||
int limit_size = SBC_ENC_IN_SIZE;
|
||
#if SBC_RESERVED_LAST_PCM
|
||
if (enc->run_step == SBC_RUN_STEP_NOR) {
|
||
limit_size += SBC_ENC_IN_SIZE;
|
||
}
|
||
#endif
|
||
if (cbuf_get_data_size(&enc->pcm_in_cbuf) < limit_size) {
|
||
if (!(sbc_buf_flag & SBC_ENC_PCM_MUTE_DATA)) {
|
||
#if SBC_RESERVED_LAST_PCM
|
||
if (enc->run_step == SBC_RUN_STEP_STOP) {
|
||
if (enc->run_cnt) {
|
||
enc->run_cnt--;
|
||
if (enc->run_cnt == 0) {
|
||
os_sem_post(&enc->run_sem);
|
||
}
|
||
memset(enc->pcm_frame, 0, SBC_ENC_IN_SIZE);
|
||
*frame = enc->pcm_frame;
|
||
return SBC_ENC_IN_SIZE;
|
||
}
|
||
}
|
||
#endif
|
||
return 0;
|
||
} else {
|
||
read_flag = 0;
|
||
}
|
||
}
|
||
if (read_flag) {
|
||
pcm_len = cbuf_read(&enc->pcm_in_cbuf, enc->pcm_frame, SBC_ENC_IN_SIZE);
|
||
#if SBC_RESERVED_LAST_PCM
|
||
if (pcm_len && enc->run_step) {
|
||
local_irq_disable();
|
||
if (enc->run_step == SBC_RUN_STEP_WAIT_STOP) {
|
||
enc->run_step = SBC_RUN_STEP_STOP;
|
||
enc->run_cnt = 200; // 发射每次读取5包，至少保证发射一帧
|
||
sbc_enc_pcm_data_fade_out(enc->pcm_frame, pcm_len);
|
||
} else if (enc->run_step == SBC_RUN_STEP_STOP) {
|
||
memset(enc->pcm_frame, 0, pcm_len);
|
||
if (enc->run_cnt) {
|
||
enc->run_cnt--;
|
||
if (enc->run_cnt == 0) {
|
||
os_sem_post(&enc->run_sem);
|
||
}
|
||
}
|
||
} else if (sbc_enc->run_step == SBC_RUN_STEP_WAIT_NOR) {
|
||
|
||
if (sbc_enc->in_cnt > 0) {
|
||
sbc_enc->in_cnt--;
|
||
memset(enc->pcm_frame, 0, pcm_len);
|
||
|
||
} else {
|
||
sbc_enc->run_step = SBC_RUN_STEP_NOR;
|
||
sbc_enc_pcm_data_fade_in(enc->pcm_frame, pcm_len);
|
||
|
||
}
|
||
}
|
||
|
||
local_irq_enable();
|
||
} else {
|
||
}
|
||
#endif
|
||
#if (AUDIO_OUTPUT_WAY == AUDIO_OUTPUT_WAY_BT)
|
||
audio_stream_resume(&sbc_emitter.entry);
|
||
#endif
|
||
} else {
|
||
memset(enc->pcm_frame, 0, SBC_ENC_IN_SIZE);
|
||
pcm_len = SBC_ENC_IN_SIZE;
|
||
}
|
||
if (pcm_len != SBC_ENC_IN_SIZE) {
|
||
}
|
||
|
||
*frame = enc->pcm_frame;
|
||
return pcm_len;
|
||
}
|
||
|
||
static void sbc_enc_pcm_put(struct audio_encoder *encoder, s16 *frame)
|
||
{
|
||
}
|
||
|
||
static const struct audio_enc_input sbc_enc_input = {
|
||
.fget = sbc_enc_pcm_get,
|
||
.fput = sbc_enc_pcm_put,
|
||
};
|
||
|
||
static int sbc_enc_probe_handler(struct audio_encoder *encoder)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
#if SBC_ENC_PACK_ENABLE
|
||
/*
|
||
struct Media_Playload_Header {
|
||
u8 Version: 2;
|
||
u8 Padding: 1;
|
||
u8 Extension: 1;
|
||
u8 CSRC_Count: 4;
|
||
u8 Marker: 1;
|
||
u8 PayloadType: 7;
|
||
u16 SequenceNumber;
|
||
u32 TimeStamp;
|
||
u32 SSRC;
|
||
};
|
||
SBC_FRAME_SUM defined within sbc_packet_head_buf used for Media Playload parameter:Number of Frames
|
||
*/
|
||
#define SBC_PACKET_HEADER_LEN (14) /*包头Max Length*/
|
||
#define SBC_FRAME_SUM (4) /*一包多少帧*/
|
||
static unsigned char sbc_packet_head_buf[SBC_PACKET_HEADER_LEN] = {
|
||
0x80, 0x60, //Version:2 Playload Type:0x60
|
||
0x00, 0x64, //Sequencenumber
|
||
0x00, 0x00, 0x03, 0x20, //Timestamp
|
||
0x00, 0x00, 0x00, 0x00 //Synchronization Source
|
||
//SBC_FRAME_SUM //defined for Media Payload
|
||
};
|
||
|
||
void sbc_enc_packet_pack(struct sbc_enc_hdl *hdl)
|
||
{
|
||
unsigned int TS; /*TimeStamp*/
|
||
/*SequenceNumber*/
|
||
hdl->packet_head_sn++;
|
||
/*Timestamp*/
|
||
TS = hdl->packet_head_sn * (128 * SBC_FRAME_SUM);
|
||
|
||
sbc_packet_head_buf[2] = hdl->packet_head_sn >> 8;
|
||
sbc_packet_head_buf[3] = hdl->packet_head_sn & 0xff;
|
||
sbc_packet_head_buf[4] = TS >> 24;
|
||
sbc_packet_head_buf[5] = (TS >> 16) & 0xff;
|
||
sbc_packet_head_buf[6] = (TS >> 8) & 0xff;
|
||
sbc_packet_head_buf[7] = (TS) & 0xff;
|
||
if (hdl->cp_type == 0x0002) {
|
||
/*
|
||
*Content Protection Header
|
||
*L-bit :bit0
|
||
*Cp-bit:bit1
|
||
*RFA :bit2 to bit7
|
||
*/
|
||
sbc_packet_head_buf[12] = 0;
|
||
sbc_packet_head_buf[13] = SBC_FRAME_SUM;
|
||
} else {
|
||
sbc_packet_head_buf[12] = SBC_FRAME_SUM;
|
||
}
|
||
}
|
||
#endif/*SBC_ENC_PACK_ENABLE*/
|
||
|
||
static int sbc_enc_output_handler(struct audio_encoder *encoder, u8 *frame, int len)
|
||
{
|
||
if (encoder == NULL) {
|
||
r_printf("encoder NULL");
|
||
}
|
||
struct sbc_enc_hdl *enc = container_of(encoder, struct sbc_enc_hdl, encoder);
|
||
enc->frame_size = len;
|
||
|
||
u16 wlen = cbuf_write(&enc->output_cbuf, frame, len);
|
||
if (wlen != len) {
|
||
return len;
|
||
}
|
||
if (cbuf_get_data_size(&sbc_enc->output_cbuf) >= enc->frame_size * 5) {
|
||
//达到基本的数据量，唤醒蓝牙发数
|
||
user_send_cmd_prepare(USER_CTRL_CMD_RESUME_STACK, 0, NULL);
|
||
}
|
||
return len;
|
||
}
|
||
|
||
const static struct audio_enc_handler sbc_enc_handler = {
|
||
.enc_probe = sbc_enc_probe_handler,
|
||
.enc_output = sbc_enc_output_handler,
|
||
};
|
||
int a2dp_sbc_encoder_get_data(u8 *packet, u16 buf_len, int *frame_size)
|
||
{
|
||
if (sbc_enc == NULL) {
|
||
return 0;
|
||
}
|
||
|
||
if (cbuf_get_data_size(&sbc_enc->output_cbuf) < buf_len) {
|
||
return 0;
|
||
}
|
||
int debug_frame_size = sbc_enc->frame_size;
|
||
int number = buf_len / debug_frame_size; /*取整数包*/
|
||
*frame_size = debug_frame_size;
|
||
u16 rlen = cbuf_read(&sbc_enc->output_cbuf, packet, *frame_size * number);
|
||
if (rlen == 0) {
|
||
}
|
||
#if SBC_RESERVED_LAST_PCM
|
||
if (sbc_enc->run_step != SBC_RUN_STEP_NOR) {
|
||
// 非正常状态，sbc数据取走后激活一下编码
|
||
audio_encoder_resume(&sbc_enc->encoder);
|
||
}
|
||
#endif
|
||
return rlen;
|
||
}
|
||
|
||
static void sbc_enc_event_handler(struct audio_decoder *decoder, int argc, int *argv)
|
||
{
|
||
printf("sbc_enc_event_handler:0x%x,%d\n", argv[0], argv[0]);
|
||
switch (argv[0]) {
|
||
case AUDIO_ENC_EVENT_END:
|
||
puts("AUDIO_ENC_EVENT_END\n");
|
||
break;
|
||
}
|
||
}
|
||
#include "sbc_enc.h"
|
||
sbc_t sbc_param = {
|
||
.frequency = SBC_FREQ_44100,
|
||
.blocks = SBC_BLK_16,
|
||
.subbands = SBC_SB_8,
|
||
.mode = SBC_MODE_STEREO,
|
||
.allocation = 0,
|
||
.endian = SBC_LE,
|
||
.bitpool = 53,
|
||
};
|
||
|
||
int audio_sbc_enc_config(void *cfg)
|
||
{
|
||
sbc_t *p = cfg;
|
||
if (p) {
|
||
printf("sbc_enc_param update:\n");
|
||
printf("frequency:%d\n", p->frequency);
|
||
printf("blocks:%d\n", p->blocks);
|
||
printf("subbands:%d\n", p->subbands);
|
||
printf("mode:%d\n", p->mode);
|
||
printf("allocation:%d\n", p->allocation);
|
||
printf("endian:%d\n", p->endian);
|
||
printf("bitpool:%d\n", p->bitpool);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int audio_sbc_enc_check_empty_len(void)
|
||
{
|
||
if (!(sbc_buf_flag & SBC_ENC_START)) {
|
||
return 0;
|
||
}
|
||
if (!sbc_enc) {
|
||
return 0;
|
||
}
|
||
return sbc_enc->pcm_in_cbuf.total_len - sbc_enc->pcm_in_cbuf.data_len;
|
||
}
|
||
|
||
static int audio_sbc_enc_write_base(s16 *data, int len, u8 ch_i, u8 ch_o)
|
||
{
|
||
if (!(sbc_buf_flag & SBC_ENC_START)) {
|
||
return 0;
|
||
}
|
||
if (!sbc_enc) {
|
||
return 0;
|
||
}
|
||
sbc_buf_flag |= SBC_ENC_WRITING;
|
||
|
||
int wlen = 0;
|
||
int ilen = 0;
|
||
int remain_len = len;
|
||
while (remain_len) {
|
||
wlen = 0;
|
||
void *obuf = cbuf_write_alloc(&sbc_enc->pcm_in_cbuf, &wlen);
|
||
if (!wlen) {
|
||
break;
|
||
}
|
||
if (ch_o == ch_i) {
|
||
ilen = wlen;
|
||
if (ilen > remain_len) {
|
||
ilen = remain_len;
|
||
wlen = ilen;
|
||
}
|
||
memcpy(obuf, data, wlen);
|
||
} else if ((ch_o == 2) && (ch_i == 1)) {
|
||
ilen = (wlen >> 2) << 1;
|
||
if (ilen > remain_len) {
|
||
ilen = remain_len;
|
||
wlen = ilen << 1;
|
||
}
|
||
s16 *outbuf = obuf;
|
||
s16 *inbuf = data;
|
||
int run_len = ilen >> 1;
|
||
while (run_len --) {
|
||
*outbuf++ = *inbuf;
|
||
*outbuf++ = *inbuf;
|
||
inbuf++;
|
||
}
|
||
} else if ((ch_o == 1) && (ch_i == 2)) {
|
||
ilen = wlen << 1;
|
||
if (ilen > remain_len) {
|
||
ilen = remain_len;
|
||
wlen = ilen >> 1;
|
||
}
|
||
s16 *outbuf = obuf;
|
||
s16 *inbuf = data;
|
||
int run_len = ilen >> 2;
|
||
while (run_len--) {
|
||
*outbuf++ = data_sat_s16(inbuf[0] + inbuf[1]);
|
||
inbuf += 2;
|
||
}
|
||
}
|
||
cbuf_write_updata(&sbc_enc->pcm_in_cbuf, wlen);
|
||
remain_len -= ilen;
|
||
data += ilen / 2;
|
||
};
|
||
wlen = len - remain_len;
|
||
|
||
if (cbuf_get_data_size(&sbc_enc->pcm_in_cbuf) >= SBC_ENC_IN_SIZE) {
|
||
audio_encoder_resume(&sbc_enc->encoder);
|
||
}
|
||
sbc_buf_flag &= ~SBC_ENC_WRITING;
|
||
return wlen;
|
||
}
|
||
|
||
int audio_sbc_enc_write(s16 *data, int len)
|
||
{
|
||
if (!(sbc_buf_flag & SBC_ENC_START)) {
|
||
return 0;
|
||
}
|
||
if (!sbc_enc) {
|
||
return 0;
|
||
}
|
||
sbc_buf_flag |= SBC_ENC_WRITING;
|
||
|
||
#if 0
|
||
u16 wlen = cbuf_write(&sbc_enc->pcm_in_cbuf, data, len);
|
||
if (wlen != len) {
|
||
}
|
||
#else
|
||
int wlen = 0;
|
||
int remain_len = len;
|
||
while (remain_len) {
|
||
wlen = 0;
|
||
void *obuf = cbuf_write_alloc(&sbc_enc->pcm_in_cbuf, &wlen);
|
||
if (!wlen) {
|
||
break;
|
||
}
|
||
if (wlen > remain_len) {
|
||
wlen = remain_len;
|
||
}
|
||
memcpy(obuf, data, wlen);
|
||
/* audio_digital_vol_run(sbc_enc->dvol, obuf, wlen); */
|
||
cbuf_write_updata(&sbc_enc->pcm_in_cbuf, wlen);
|
||
remain_len -= wlen;
|
||
data += wlen / 2;
|
||
};
|
||
wlen = len - remain_len;
|
||
#endif
|
||
|
||
if (cbuf_get_data_size(&sbc_enc->pcm_in_cbuf) >= SBC_ENC_IN_SIZE) {
|
||
audio_encoder_resume(&sbc_enc->encoder);
|
||
}
|
||
sbc_buf_flag &= ~SBC_ENC_WRITING;
|
||
return wlen;
|
||
}
|
||
|
||
#if SBC_USE_MIC_CHANNEL
|
||
s16 temp_data[ESCO_ADC_IRQ_POINTS * 2];
|
||
extern struct audio_adc_hdl adc_hdl;
|
||
static void adc_mic_output_handler(void *priv, s16 *data, int len)
|
||
{
|
||
u16 points = len >> 1;
|
||
if (!(sbc_buf_flag & SBC_ENC_START)) {
|
||
return;
|
||
}
|
||
if (sbc_enc) {
|
||
//单变双
|
||
for (int i = 0; i < points ; i++) {
|
||
temp_data[i * 2] = data[i];
|
||
temp_data[i * 2 + 1] = data[i];
|
||
}
|
||
putchar('m');
|
||
audio_sbc_enc_write(temp_data, len * 2);
|
||
}
|
||
}
|
||
#endif
|
||
|
||
int audio_sbc_enc_open()
|
||
{
|
||
int err;
|
||
struct audio_fmt fmt;
|
||
u16 frame_len = 512;
|
||
|
||
if (encode_task) {
|
||
return -1;
|
||
}
|
||
printf("sbc_enc_open,frame_len:%d\n", frame_len);
|
||
sbc_buf_flag &= ~SBC_ENC_START;
|
||
fmt.channel = 1;
|
||
fmt.frame_len = frame_len;
|
||
fmt.coding_type = AUDIO_CODING_SBC;
|
||
|
||
fmt.priv = &sbc_param;
|
||
|
||
audio_encoder_task_open();
|
||
if (!sbc_enc) {
|
||
sbc_enc = zalloc(sizeof(*sbc_enc));
|
||
#if SBC_RESERVED_LAST_PCM
|
||
os_sem_create(&sbc_enc->run_sem, 0);
|
||
#endif
|
||
|
||
u8 *cbuf_buf;
|
||
#if SBC_AUDIO_OVERLAY
|
||
cbuf_buf = app_audio_alloc_use_buff(SBC_ENC_OUT_CBUF_SIZE + SBC_ENC_IN_CBUF_SIZE);
|
||
if (cbuf_buf) {
|
||
sbc_enc->overlay = 1;
|
||
} else
|
||
#endif
|
||
{
|
||
cbuf_buf = malloc(SBC_ENC_OUT_CBUF_SIZE + SBC_ENC_IN_CBUF_SIZE);
|
||
}
|
||
sbc_enc->p_out_cbuf_buf = cbuf_buf;
|
||
sbc_enc->p_in_cbuf_buf = &cbuf_buf[SBC_ENC_OUT_CBUF_SIZE];
|
||
}
|
||
printf("init vol:%d \n", app_var.music_volume);
|
||
/* sbc_enc->dvol = audio_digital_vol_open(app_var.music_volume, 30, 7); */
|
||
cbuf_init(&sbc_enc->output_cbuf, sbc_enc->p_out_cbuf_buf, SBC_ENC_OUT_CBUF_SIZE);
|
||
cbuf_init(&sbc_enc->pcm_in_cbuf, sbc_enc->p_in_cbuf_buf, SBC_ENC_IN_CBUF_SIZE);
|
||
os_sem_create(&sbc_enc->pcm_frame_sem, 0);
|
||
audio_encoder_open(&sbc_enc->encoder, &sbc_enc_input, encode_task);
|
||
audio_encoder_set_handler(&sbc_enc->encoder, &sbc_enc_handler);
|
||
audio_encoder_set_fmt(&sbc_enc->encoder, &fmt);
|
||
audio_encoder_set_event_handler(&sbc_enc->encoder, sbc_enc_event_handler, 0);
|
||
audio_encoder_set_output_buffs(&sbc_enc->encoder, sbc_enc->output_frame,
|
||
sizeof(sbc_enc->output_frame), 1);
|
||
int start_err = audio_encoder_start(&sbc_enc->encoder);
|
||
printf("sbc_enc_open ok %d\n", start_err);
|
||
|
||
#if SBC_USE_MIC_CHANNEL
|
||
fmt.sample_rate = 44100;
|
||
audio_adc_mic_open(&sbc_enc->mic_ch, AUDIO_ADC_MIC_CH, &adc_hdl);
|
||
audio_adc_mic_set_sample_rate(&sbc_enc->mic_ch, fmt.sample_rate);
|
||
audio_adc_mic_set_gain(&sbc_enc->mic_ch, app_var.aec_mic_gain);
|
||
audio_adc_mic_set_buffs(&sbc_enc->mic_ch, sbc_enc->adc_buf,
|
||
ESCO_ADC_IRQ_POINTS * 2, ESCO_ADC_BUF_NUM);
|
||
sbc_enc->adc_output.handler = adc_mic_output_handler;
|
||
audio_adc_add_output_handler(&adc_hdl, &sbc_enc->adc_output);
|
||
audio_adc_mic_start(&sbc_enc->mic_ch);
|
||
#endif
|
||
|
||
|
||
#if BT_USE_PCM_DEC
|
||
|
||
clock_add(DEC_PCM_CLK);
|
||
pcm_dec_open(sbc_enc, &fmt);
|
||
#endif
|
||
|
||
|
||
|
||
clock_add(ENC_SBC_CLK);
|
||
|
||
clock_set_cur();
|
||
sbc_buf_flag |= SBC_ENC_START;
|
||
audio_sbc_enc_open_exit();
|
||
return 0;
|
||
|
||
}
|
||
int audio_sbc_enc_reset_buf(u8 flag)
|
||
{
|
||
if (!sbc_enc) {
|
||
return -1;
|
||
}
|
||
r_printf("audio_sbc_enc_reset_buf %d\n", flag);
|
||
if (flag) {
|
||
if (sbc_enc->mute_data_send_timer) {
|
||
sys_hi_timer_del(sbc_enc->mute_data_send_timer);
|
||
sbc_enc->mute_data_send_timer = 0;
|
||
sbc_buf_flag &= ~SBC_ENC_PCM_MUTE_DATA;
|
||
}
|
||
} else {
|
||
if (sbc_enc->mute_data_send_timer == 0) {
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
int audio_sbc_enc_close()
|
||
{
|
||
if (!sbc_enc) {
|
||
return -1;
|
||
}
|
||
printf("audio_sbc_enc_close\n");
|
||
audio_sbc_enc_close_enter();
|
||
sbc_buf_flag &= ~SBC_ENC_START;
|
||
|
||
#if BT_USE_PCM_DEC
|
||
pcm_dec_close(sbc_enc);
|
||
clock_remove(DEC_PCM_CLK);
|
||
#endif
|
||
|
||
|
||
|
||
|
||
#if SBC_RESERVED_LAST_PCM
|
||
os_sem_post(&sbc_enc->run_sem);
|
||
#endif
|
||
while (sbc_buf_flag & SBC_ENC_WRITING) {
|
||
os_time_dly(1);
|
||
|
||
}
|
||
#if SBC_USE_MIC_CHANNEL
|
||
audio_adc_mic_close(&sbc_enc->mic_ch);
|
||
audio_adc_del_output_handler(&adc_hdl, &sbc_enc->adc_output);
|
||
#endif
|
||
audio_encoder_close(&sbc_enc->encoder);
|
||
|
||
#if SBC_AUDIO_OVERLAY
|
||
if (sbc_enc->overlay) {
|
||
app_audio_release_use_buff(sbc_enc->p_out_cbuf_buf);
|
||
} else
|
||
#endif
|
||
{
|
||
free(sbc_enc->p_out_cbuf_buf);
|
||
}
|
||
free(sbc_enc);
|
||
sbc_enc = NULL;
|
||
|
||
audio_encoder_task_close();
|
||
|
||
clock_remove(ENC_SBC_CLK);
|
||
|
||
clock_set_cur();
|
||
printf("audio_sbc_enc_close end\n");
|
||
return 0;
|
||
}
|
||
|
||
void audio_sbc_enc_init(void)
|
||
{
|
||
}
|
||
|
||
int audio_sbc_enc_is_work(void)
|
||
{
|
||
if ((sbc_buf_flag & SBC_ENC_START) && sbc_enc) {
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
#if (AUDIO_OUTPUT_WAY == AUDIO_OUTPUT_WAY_BT)
|
||
#include "application/audio_dig_vol.h"
|
||
extern void *bt_digvol_last;
|
||
#endif
|
||
void bt_emitter_set_vol(u8 vol)
|
||
{
|
||
if (!(sbc_buf_flag & SBC_ENC_START)) {
|
||
return ;
|
||
}
|
||
if (!sbc_enc) {
|
||
return ;
|
||
}
|
||
sbc_enc->backup_digital_vol = vol;
|
||
r_printf("=======set vol %d\n", vol);
|
||
#if (AUDIO_OUTPUT_WAY == AUDIO_OUTPUT_WAY_BT)
|
||
if (bt_digvol_last) {
|
||
audio_dig_vol_set(bt_digvol_last, AUDIO_DIG_VOL_ALL_CH, vol);
|
||
}
|
||
#endif
|
||
}
|
||
|
||
int audio_sbc_enc_get_rate(void)
|
||
{
|
||
int sr = 44100;
|
||
switch (sbc_param.frequency) {
|
||
case SBC_FREQ_16000:
|
||
sr = 16000;
|
||
break;
|
||
case SBC_FREQ_32000:
|
||
sr = 32000;
|
||
break;
|
||
case SBC_FREQ_44100:
|
||
sr = 44100;
|
||
break;
|
||
case SBC_FREQ_48000:
|
||
sr = 48000;
|
||
break;
|
||
}
|
||
return sr;
|
||
}
|
||
int audio_sbc_enc_get_channel_num(void)
|
||
{
|
||
return sbc_param.mode == SBC_MODE_MONO ? 1 : 2;
|
||
}
|
||
|
||
int a2dp_sbc_encoder_init(void *sbc_struct)
|
||
{
|
||
if (sbc_struct) {
|
||
memcpy(&sbc_param, sbc_struct, sizeof(sbc_t));
|
||
extern void audio_mixer_reset_sample_rate(u32 sr);
|
||
audio_mixer_reset_sample_rate(audio_sbc_enc_get_rate());
|
||
//audio_sbc_enc_config(&sbc_param);
|
||
audio_sbc_enc_open();
|
||
} else {
|
||
#if USER_SUPPORT_DUAL_A2DP_SOURCE
|
||
if (get_total_connect_dev() == 0) { //当前有一台连接上了
|
||
audio_sbc_enc_close();
|
||
}
|
||
#else
|
||
audio_sbc_enc_close();
|
||
#endif
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
|
||
#if (AUDIO_OUTPUT_WAY == AUDIO_OUTPUT_WAY_BT)
|
||
|
||
struct sbc_emitter_hdl sbc_emitter = {0};
|
||
|
||
static int audio_stream_sbc_emitter_data_handler(struct audio_stream_entry *entry, struct audio_data_frame *in,
|
||
struct audio_data_frame *out)
|
||
{
|
||
local_irq_disable();
|
||
if (false == audio_sbc_enc_is_work()) {
|
||
local_irq_enable();
|
||
return in->data_len;
|
||
}
|
||
#if SBC_RESERVED_LAST_PCM
|
||
if (in->stop) {
|
||
if (sbc_enc->run_step == SBC_RUN_STEP_NOR) {
|
||
sbc_enc->run_step = SBC_RUN_STEP_WAIT_STOP;
|
||
}
|
||
audio_encoder_resume(&sbc_enc->encoder);
|
||
os_sem_set(&sbc_enc->run_sem, 0);
|
||
local_irq_enable();
|
||
if ((sbc_enc->run_step == SBC_RUN_STEP_WAIT_STOP) || (sbc_enc->run_cnt)) {
|
||
os_sem_pend(&sbc_enc->run_sem, 3);
|
||
if ((sbc_enc->run_step == SBC_RUN_STEP_WAIT_STOP) || (sbc_enc->run_cnt)) {
|
||
log_w("sbc wait stop err, step:%d, cnt:%d \n\n", sbc_enc->run_step, sbc_enc->run_cnt);
|
||
}
|
||
}
|
||
return in->data_len;
|
||
} else {
|
||
if (sbc_enc->run_step != SBC_RUN_STEP_NOR && (sbc_enc->run_step != SBC_RUN_STEP_WAIT_NOR)) {
|
||
cbuf_clear(&sbc_enc->pcm_in_cbuf);
|
||
|
||
sbc_enc->run_step = SBC_RUN_STEP_WAIT_NOR;
|
||
|
||
sbc_enc->in_cnt = 100; //丢掉前面几包
|
||
|
||
|
||
|
||
}
|
||
|
||
}
|
||
#endif
|
||
local_irq_enable();
|
||
if (in->data_len == 0) {
|
||
return 0;
|
||
}
|
||
return audio_sbc_enc_write_base(in->data, in->data_len, in->channel, audio_sbc_enc_get_channel_num());
|
||
}
|
||
|
||
void audio_sbc_emitter_init(void)
|
||
{
|
||
sbc_emitter.entry.data_handler = audio_stream_sbc_emitter_data_handler;
|
||
}
|
||
|
||
#endif
|
||
|
||
|