rudism/pinebuds
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
pinebuds/services/bt_app/app_a2dp_source.cpp
Ben V. Brown dca92cf01f Removing FPGA dev support 
As we will never get their FGPA source code. Zero loss.
2023-02-02 17:42:33 +11:00

831 lines
31 KiB
C++
Raw Blame History

/***************************************************************************
*
* Copyright 2015-2019 BES.
* All rights reserved. All unpublished rights reserved.
*
* No part of this work may be used or reproduced in any form or by any
* means, or stored in a database or retrieval system, without prior written
* permission of BES.
*
* Use of this work is governed by a license granted by BES.
* This work contains confidential and proprietary information of
* BES. which is protected by copyright, trade secret,
* trademark and other intellectual property rights.
*
****************************************************************************/
#if defined(APP_LINEIN_A2DP_SOURCE) || defined(APP_I2S_A2DP_SOURCE)
#include "app_a2dp_source.h"
#include "a2dp_api.h"
#include "app_overlay.h"
uint8_t *a2dp_linein_buff;
static char a2dp_transmit_buffer[A2DP_TRANS_SIZE];
sbcbank_t sbcbank;
A2DP_SOURCE_STRUCT a2dp_source;
static sbcpack_t *get_sbcPacket(void) {
int index = sbcbank.free;
sbcbank.free += 1;
if (sbcbank.free == 1) {
sbcbank.free = 0;
}
return &(sbcbank.sbcpacks[index]);
}
#if 0
typedef struct {
AvrcpAdvancedPdu pdu;
uint8_t para_buf[10];
}APP_A2DP_AVRCPADVANCEDPDU;
extern osPoolId app_a2dp_avrcpadvancedpdu_mempool;
#define app_a2dp_avrcpadvancedpdu_mempool_init() \
do { \
if (app_a2dp_avrcpadvancedpdu_mempool == NULL) \
app_a2dp_avrcpadvancedpdu_mempool = \
osPoolCreate(osPool(app_a2dp_avrcpadvancedpdu_mempool)); \
} while (0);
#define app_a2dp_avrcpadvancedpdu_mempool_calloc(buf) \
do { \
APP_A2DP_AVRCPADVANCEDPDU *avrcpadvancedpdu; \
avrcpadvancedpdu = (APP_A2DP_AVRCPADVANCEDPDU *)osPoolCAlloc( \
app_a2dp_avrcpadvancedpdu_mempool); \
buf = &(avrcpadvancedpdu->pdu); \
buf->parms = avrcpadvancedpdu->para_buf; \
} while (0);
#define app_a2dp_avrcpadvancedpdu_mempool_free(buf) \
do { \
osPoolFree(app_a2dp_avrcpadvancedpdu_mempool, buf); \
} while (0);
void a2dp_source_volume_local_set(int8_t vol)
{
app_bt_stream_volume_get_ptr()->a2dp_vol = vol;
nv_record_touch_cause_flush();
}
static int a2dp_volume_get(void)
{
int vol = app_bt_stream_volume_get_ptr()->a2dp_vol;
vol = 8*vol-1;
if (vol > (0x7f-1))
vol = 0x7f;
return (vol);
}
static int a2dp_volume_set(U8 vol)
{
int dest_vol;
dest_vol = (((int)vol&0x7f)<<4)/0x7f + 1;
if (dest_vol > TGT_VOLUME_LEVEL_15)
dest_vol = TGT_VOLUME_LEVEL_15;
if (dest_vol < TGT_VOLUME_LEVEL_0)
dest_vol = TGT_VOLUME_LEVEL_0;
a2dp_source_volume_local_set(dest_vol);
app_bt_stream_volumeset(dest_vol);
return (vol);
}
void avrcp_source_callback_TG(AvrcpChannel *chnl, const AvrcpCallbackParms *Parms)
{
TRACE(3,"%s : chnl %p, Parms %p,Parms->event\n", __FUNCTION__,chnl, Parms,Parms->event);
enum BT_DEVICE_ID_T device_id = BT_DEVICE_ID_1;
switch(Parms->event)
{
case AVRCP_EVENT_CONNECT:
if(0)//(chnl->avrcpVersion >=0x103)
{
TRACE(1,"::%s AVRCP_GET_CAPABILITY\n",__FUNCTION__);
if (app_bt_device.avrcp_cmd1[device_id] == NULL)
app_a2dp_avrcpadvancedpdu_mempool_calloc(app_bt_device.avrcp_cmd1[device_id]);
AVRCP_CtGetCapabilities(chnl,app_bt_device.avrcp_cmd1[device_id],AVRCP_CAPABILITY_EVENTS_SUPPORTED);
}
app_bt_device.avrcp_channel[device_id].avrcpState = AVRCP_STATE_CONNECTED;
TRACE(3,"::%s AVRCP_EVENT_CONNECT %x,device_id=%d\n",__FUNCTION__, chnl->avrcpVersion,device_id);
break;
case AVRCP_EVENT_DISCONNECT:
TRACE(1,"::%s AVRCP_EVENT_DISCONNECT",__FUNCTION__);
app_bt_device.avrcp_channel[device_id].avrcpState = AVRCP_STATE_DISCONNECTED;
if (app_bt_device.avrcp_get_capabilities_rsp[device_id]){
app_a2dp_avrcpadvancedpdu_mempool_free(app_bt_device.avrcp_get_capabilities_rsp[device_id]);
app_bt_device.avrcp_get_capabilities_rsp[device_id] = NULL;
}
if (app_bt_device.avrcp_control_rsp[device_id]){
app_a2dp_avrcpadvancedpdu_mempool_free(app_bt_device.avrcp_control_rsp[device_id]);
app_bt_device.avrcp_control_rsp[device_id] = NULL;
}
if (app_bt_device.avrcp_notify_rsp[device_id]){
app_a2dp_avrcpadvancedpdu_mempool_free(app_bt_device.avrcp_notify_rsp[device_id]);
app_bt_device.avrcp_notify_rsp[device_id] = NULL;
}
if (app_bt_device.avrcp_cmd1[device_id]){
app_a2dp_avrcpadvancedpdu_mempool_free(app_bt_device.avrcp_cmd1[device_id]);
app_bt_device.avrcp_cmd1[device_id] = NULL;
}
if (app_bt_device.avrcp_cmd2[device_id]){
app_a2dp_avrcpadvancedpdu_mempool_free(app_bt_device.avrcp_cmd2[device_id]);
app_bt_device.avrcp_cmd2[device_id] = NULL;
}
app_bt_device.volume_report[device_id] = 0;
break;
case AVRCP_EVENT_RESPONSE:
TRACE(3,"::%s AVRCP_EVENT_RESPONSE op=%x,status=%x\n",__FUNCTION__, Parms->advOp,Parms->status);
break;
case AVRCP_EVENT_PANEL_CNF:
TRACE(4,"::%s AVRCP_EVENT_PANEL_CNF %x,%x,%x",__FUNCTION__,
Parms->p.panelCnf.response,Parms->p.panelCnf.operation,Parms->p.panelCnf.press);
break;
case AVRCP_EVENT_ADV_TX_DONE:
TRACE(4,"::%s AVRCP_EVENT_ADV_TX_DONE device_id=%d,status=%x,errorcode=%x\n",__FUNCTION__,device_id,Parms->status,Parms->errorCode);
TRACE(3,"::%s AVRCP_EVENT_ADV_TX_DONE op:%d, transid:%x\n", __FUNCTION__,Parms->p.adv.txPdu->op,Parms->p.adv.txPdu->transId);
if (Parms->p.adv.txPdu->op == AVRCP_OP_GET_CAPABILITIES){
if (app_bt_device.avrcp_get_capabilities_rsp[device_id] == Parms->p.adv.txPdu){
app_bt_device.avrcp_get_capabilities_rsp[device_id] = NULL;
app_a2dp_avrcpadvancedpdu_mempool_free(Parms->p.adv.txPdu);
}
}
break;
case AVRCP_EVENT_COMMAND:
#ifndef __AVRCP_EVENT_COMMAND_VOLUME_SKIP__
TRACE(3,"::%s AVRCP_EVENT_COMMAND device_id=%d,role=%x\n",__FUNCTION__,device_id,chnl->role);
TRACE(3,"::%s AVRCP_EVENT_COMMAND ctype=%x,subunitype=%x\n",__FUNCTION__, Parms->p.cmdFrame->ctype,Parms->p.cmdFrame->subunitType);
TRACE(3,"::%s AVRCP_EVENT_COMMAND subunitId=%x,opcode=%x\n",__FUNCTION__, Parms->p.cmdFrame->subunitId,Parms->p.cmdFrame->opcode);
TRACE(3,"::%s AVRCP_EVENT_COMMAND operands=%x,operandLen=%x\n",__FUNCTION__, Parms->p.cmdFrame->operands,Parms->p.cmdFrame->operandLen);
TRACE(2,"::%s AVRCP_EVENT_COMMAND more=%x\n", Parms->p.cmdFrame->more);
if(Parms->p.cmdFrame->ctype == AVRCP_CTYPE_STATUS)
{
uint32_t company_id = *(Parms->p.cmdFrame->operands+2) + ((uint32_t)(*(Parms->p.cmdFrame->operands+1))<<8) + ((uint32_t)(*(Parms->p.cmdFrame->operands))<<16);
TRACE(2,"::%s AVRCP_EVENT_COMMAND company_id=%x\n",__FUNCTION__, company_id);
if(company_id == 0x001958) //bt sig
{
AvrcpOperation op = *(Parms->p.cmdFrame->operands+3);
uint8_t oplen = *(Parms->p.cmdFrame->operands+6)+ ((uint32_t)(*(Parms->p.cmdFrame->operands+5))<<8);
TRACE(3,"::%s AVRCP_EVENT_COMMAND op=%x,oplen=%x\n",__FUNCTION__, op,oplen);
switch(op)
{
case AVRCP_OP_GET_CAPABILITIES:
{
uint8_t event = *(Parms->p.cmdFrame->operands+7);
if(event==AVRCP_CAPABILITY_COMPANY_ID)
{
TRACE(1,"::%s AVRCP_EVENT_COMMAND send support compay id",__FUNCTION__);
}
else if(event == AVRCP_CAPABILITY_EVENTS_SUPPORTED)
{
TRACE(2,"::%s AVRCP_EVENT_COMMAND send support event transId:%d", __FUNCTION__,Parms->p.cmdFrame->transId);
chnl->adv.eventMask = AVRCP_ENABLE_VOLUME_CHANGED; ///volume control
if (app_bt_device.avrcp_get_capabilities_rsp[device_id] == NULL)
app_a2dp_avrcpadvancedpdu_mempool_calloc(app_bt_device.avrcp_get_capabilities_rsp[device_id]);
app_bt_device.avrcp_get_capabilities_rsp[device_id]->transId = Parms->p.cmdFrame->transId;
app_bt_device.avrcp_get_capabilities_rsp[device_id]->ctype = AVCTP_RESPONSE_IMPLEMENTED_STABLE;
TRACE(2,"::%s AVRCP_EVENT_COMMAND send support event transId:%d", __FUNCTION__,app_bt_device.avrcp_get_capabilities_rsp[device_id]->transId);
AVRCP_CtGetCapabilities_Rsp(chnl,app_bt_device.avrcp_get_capabilities_rsp[device_id],AVRCP_CAPABILITY_EVENTS_SUPPORTED,chnl->adv.eventMask);
}
else
{
TRACE(1,"::%s AVRCP_EVENT_COMMAND send error event value",__FUNCTION__);
}
}
break;
}
}
}else if(Parms->p.cmdFrame->ctype == AVCTP_CTYPE_CONTROL){
TRACE(1,"::%s AVRCP_EVENT_COMMAND AVCTP_CTYPE_CONTROL\n",__FUNCTION__);
DUMP8("%02x ", Parms->p.cmdFrame->operands, Parms->p.cmdFrame->operandLen);
if (Parms->p.cmdFrame->operands[3] == AVRCP_OP_SET_ABSOLUTE_VOLUME){
TRACE(2,"::%s AVRCP_EID_VOLUME_CHANGED transId:%d\n", __FUNCTION__,Parms->p.cmdFrame->transId);
a2dp_volume_set(Parms->p.cmdFrame->operands[7]);
if (app_bt_device.avrcp_control_rsp[device_id] == NULL)
app_a2dp_avrcpadvancedpdu_mempool_calloc(app_bt_device.avrcp_control_rsp[device_id]);
app_bt_device.avrcp_control_rsp[device_id]->transId = Parms->p.cmdFrame->transId;
app_bt_device.avrcp_control_rsp[device_id]->ctype = AVCTP_RESPONSE_ACCEPTED;
DUMP8("%02x ", Parms->p.cmdFrame->operands, Parms->p.cmdFrame->operandLen);
AVRCP_CtAcceptAbsoluteVolume_Rsp(chnl, app_bt_device.avrcp_control_rsp[device_id], Parms->p.cmdFrame->operands[7]);
}
}else if (Parms->p.cmdFrame->ctype == AVCTP_CTYPE_NOTIFY){
BtStatus status;
TRACE(1,"::%s AVRCP_EVENT_COMMAND AVCTP_CTYPE_NOTIFY\n",__FUNCTION__);
DUMP8("%02x ", Parms->p.cmdFrame->operands, Parms->p.cmdFrame->operandLen);
if (Parms->p.cmdFrame->operands[7] == AVRCP_EID_VOLUME_CHANGED){
TRACE(2,"::%s AVRCP_EID_VOLUME_CHANGED transId:%d\n", __FUNCTION__,Parms->p.cmdFrame->transId);
if (app_bt_device.avrcp_notify_rsp[device_id] == NULL)
app_a2dp_avrcpadvancedpdu_mempool_calloc(app_bt_device.avrcp_notify_rsp[device_id]);
app_bt_device.avrcp_notify_rsp[device_id]->transId = Parms->p.cmdFrame->transId;
app_bt_device.avrcp_notify_rsp[device_id]->ctype = AVCTP_RESPONSE_INTERIM;
app_bt_device.volume_report[device_id] = AVCTP_RESPONSE_INTERIM;
status = AVRCP_CtGetAbsoluteVolume_Rsp(chnl, app_bt_device.avrcp_notify_rsp[device_id], a2dp_volume_get());
TRACE(2,"::%s AVRCP_EVENT_COMMAND AVRCP_EID_VOLUME_CHANGED nRet:%x\n",__FUNCTION__,status);
}
}
#endif
break;
case AVRCP_EVENT_ADV_CMD_TIMEOUT:
TRACE(3,"::%s AVRCP_EVENT_ADV_CMD_TIMEOUT device_id=%d,role=%x\n",__FUNCTION__,device_id,chnl->role);
break;
}
}
#endif
osMutexId a2dp_source_mutex_id = NULL;
osMutexDef(a2dp_source_mutex);
static void a2dp_source_mutex_lock(void) {
osMutexWait(a2dp_source_mutex_id, osWaitForever);
}
static void a2dp_source_mutex_unlock(void) {
osMutexRelease(a2dp_source_mutex_id);
}
static void a2dp_source_sem_lock(a2dp_source_lock_t *lock) {
osSemaphoreWait(lock->_osSemaphoreId, osWaitForever);
}
static void a2dp_source_sem_unlock(a2dp_source_lock_t *lock) {
osSemaphoreRelease(lock->_osSemaphoreId);
}
static void a2dp_source_reset_send_lock(void) {
PSCB p_scb = (PSCB)(a2dp_source.sbc_send_lock._osSemaphoreDef.semaphore);
uint32_t lock = int_lock();
p_scb->tokens = 0;
int_unlock(lock);
}
static bool a2dp_source_is_send_wait(void) {
bool ret = false;
uint32_t lock = int_lock();
PSCB p_scb = (PSCB)(a2dp_source.sbc_send_lock._osSemaphoreDef.semaphore);
if (p_scb->p_lnk) {
ret = true;
}
int_unlock(lock);
return ret;
}
static void a2dp_source_wait_pcm_data(void) {
a2dp_source_lock_t *lock = &(a2dp_source.data_lock);
PSCB p_scb = (PSCB)(lock->_osSemaphoreDef.semaphore);
uint32_t iflag = int_lock();
p_scb->tokens = 0;
int_unlock(iflag);
a2dp_source_sem_lock(lock);
}
static void a2dp_source_put_data(void) {
a2dp_source_lock_t *lock = &(a2dp_source.data_lock);
a2dp_source_sem_unlock(lock);
}
#if 0
static void a2dp_source_lock_sbcsending(void * channel)
{
tws_lock_t *lock = &(a2dp_source.sbc_send_lock);
sem_lock(lock);
}
static void a2dp_source_unlock_sbcsending(void * channel)
{
tws_lock_t *lock = &(a2dp_source.sbc_send_lock);
sem_unlock(lock);
}
#endif
static int32_t a2dp_source_wait_sent(uint32_t timeout) {
int32_t ret = 0;
a2dp_source_lock_t *lock = &(a2dp_source.sbc_send_lock);
a2dp_source_reset_send_lock();
ret = osSemaphoreWait(lock->_osSemaphoreId, timeout);
return ret;
}
void a2dp_source_notify_send(void) {
if (a2dp_source_is_send_wait()) { // task wait lock
// TWS_DBLOG("\nNOTIFY SEND\n");
a2dp_source_sem_unlock(&(a2dp_source.sbc_send_lock));
}
}
// loop write
static int A2dpSourceEnCQueue(CQueue *Q, CQItemType *e, unsigned int len) {
int status = CQ_OK;
if (AvailableOfCQueue(Q) < (int)len) {
Q->write = 0;
Q->len = 0;
Q->read = 0;
status = CQ_ERR;
} else {
status = CQ_OK;
}
Q->len += len;
while (len > 0) {
Q->base[Q->write] = *e;
++Q->write;
++e;
--len;
if (Q->write >= Q->size)
Q->write = 0;
}
// TRACE(1,"Q->len:%d ", Q->len);
return status;
}
static int a2dp_source_pcm_buffer_write(uint8_t *pcm_buf, uint16_t len) {
int status;
// TWS_DBLOG("\nenter: %s %d\n",__FUNCTION__,__LINE__);
a2dp_source_mutex_lock();
status = A2dpSourceEnCQueue(&(a2dp_source.pcm_queue), pcm_buf, len);
a2dp_source_mutex_unlock();
// TWS_DBLOG("\nexit: %s %d\n",__FUNCTION__,__LINE__);
return status;
}
static int a2dp_source_pcm_buffer_read(uint8_t *buff, uint16_t len) {
uint8_t *e1 = NULL, *e2 = NULL;
unsigned int len1 = 0, len2 = 0;
int status;
a2dp_source_mutex_lock();
status = PeekCQueue(&(a2dp_source.pcm_queue), len, &e1, &len1, &e2, &len2);
if (len == (len1 + len2)) {
memcpy(buff, e1, len1);
memcpy(buff + len1, e2, len2);
DeCQueue(&(a2dp_source.pcm_queue), 0, len);
} else {
// SOURCE_DBLOG("memset buffer");
memset(buff, 0x00, len);
status = -1;
}
a2dp_source_mutex_unlock();
return status;
}
uint32_t a2dp_source_linein_more_pcm_data(uint8_t *pcm_buf, uint32_t len) {
#if 1
int status;
status = a2dp_source_pcm_buffer_write(pcm_buf, len);
// pcm data from adc
// DUMP8("%02x ",pcm_buf, 10);
if (status != CQ_OK) {
SOURCE_DBLOG("linin buff overflow!");
}
a2dp_source_put_data();
return len;
#else
int status;
status = a2dp_source_pcm_buffer_write(pcm_buf, len);
// pcm data from adc
// DUMP8("%02x ",pcm_buf, 10);
if (status != CQ_OK) {
SOURCE_DBLOG("linin buff overflow!");
}
if (((app_bt_device.input_onoff == 1) &&
(a2dp_source.pcm_queue.len > 10 * 1024)) ||
(app_bt_device.input_onoff == 2)) {
a2dp_source_put_data();
app_bt_device.input_onoff = 2;
}
return len;
#endif
}
static btif_handler a2dp_source_handler;
static uint8_t app_a2dp_source_find_process = 0;
void app_a2dp_source_stop_find(void) {
app_a2dp_source_find_process = 0;
// ME_UnregisterGlobalHandler(&a2dp_source_handler);
}
#if 0
static void bt_a2dp_source_call_back(const BtEvent* event)
{
switch (event->eType) {
case BTEVENT_HCI_COMMAND_SENT:
case BTEVENT_ACL_DATA_NOT_ACTIVE:
return;
case BTEVENT_ACL_DATA_ACTIVE:
CmgrHandler *cmgrHandler;
/* Start the sniff timer */
cmgrHandler = CMGR_GetAclHandler(event->p.remDev);
if (cmgrHandler)
app_bt_CMGR_SetSniffTimer(cmgrHandler, NULL, CMGR_SNIFF_TIMER);
return;
}
TRACE(1,"SRC app_bt_golbal_handle evt = %d",event->eType);
switch(event->eType){
case BTEVENT_NAME_RESULT:
SOURCE_DBLOG("\n%s %d BTEVENT_NAME_RESULT\n",__FUNCTION__,__LINE__);
break;
case BTEVENT_INQUIRY_RESULT:
SOURCE_DBLOG("\n%s %d BTEVENT_INQUIRY_RESULT\n",__FUNCTION__,__LINE__);
DUMP8("%02x ", event->p.inqResult.bdAddr.addr, 6);
SOURCE_DBLOG("inqmode = %x",event->p.inqResult.inqMode);
DUMP8("%02x ", event->p.inqResult.extInqResp, 20);
SOURCE_DBLOG("classdevice=%x",event->p.inqResult.classOfDevice);
///check the class of device to find the handfree device
if(event->p.inqResult.classOfDevice & COD_MAJOR_AUDIO)
//if((event->p.inqResult.classOfDevice & COD_MAJOR_AUDIO)&&(!memcmp(event->p.inqResult.bdAddr.addr,"\x36\x35\x34",3)))
{
memcpy(app_bt_device.inquried_snk_bdAddr.addr,event->p.inqResult.bdAddr.addr,sizeof(event->p.inqResult.bdAddr.addr));
DUMP8("%02x ",app_bt_device.inquried_snk_bdAddr.addr, 6);
ME_CancelInquiry();
app_a2dp_source_stop_find();
}
break;
case BTEVENT_INQUIRY_COMPLETE:
SOURCE_DBLOG("\n%s %d BTEVENT_INQUIRY_COMPLETE\n",__FUNCTION__,__LINE__);
app_a2dp_source_stop_find();
break;
/** The Inquiry process is canceled. */
case BTEVENT_INQUIRY_CANCELED:
SOURCE_DBLOG("\n%s %d BTEVENT_INQUIRY_CANCELED\n",__FUNCTION__,__LINE__);
SOURCE_DBLOG("start to connect peer device");
A2DP_OpenStream(&app_bt_device.a2dp_stream[BT_DEVICE_ID_1], (BT_BD_ADDR *)&app_bt_device.inquried_snk_bdAddr);
break;
case BTEVENT_LINK_CONNECT_CNF:
case BTEVENT_LINK_CONNECT_IND:
SOURCE_DBLOG("CONNECT_IND/CNF evt:%d errCode:0x%0x newRole:%d activeCons:%d",event->eType, event->errCode, event->p.remDev->role, MEC(activeCons));
#if defined(__BTIF_EARPHONE__) && defined(__BTIF_AUTOPOWEROFF__)
if (MEC(activeCons) == 0){
app_start_10_second_timer(APP_POWEROFF_TIMER_ID);
}else{
app_stop_10_second_timer(APP_POWEROFF_TIMER_ID);
}
#endif
if (MEC(activeCons) > 1){
app_bt_MeDisconnectLink(event->p.remDev);
}
default:
//SOURCE_DBLOG("\n%s %d etype:%d\n",__FUNCTION__,__LINE__,event->eType);
break;
}
app_bt_role_manager_process(event);
app_bt_accessible_manager_process(event);
app_bt_sniff_manager_process(event);
app_bt_golbal_handle_hook(event);
//SOURCE_DBLOG("\nexit: %s %d\n",__FUNCTION__,__LINE__);
}
#else
uint8_t source_bt_addr[6] = {0x88, 0xaa, 0x33, 0x22, 0x11, 0x11};
// uint8_t source_bt_addr[6]={0x85,0x7e,0xaa,0x3c,0xd0,0xe8};
static void bt_a2dp_source_call_back(const btif_event_t *Event) {
uint8_t etype = btif_me_get_callback_event_type(Event);
btif_remote_device_t *remDev;
switch (etype) {
case BTIF_BTEVENT_HCI_COMMAND_SENT:
case BTIF_BTEVENT_ACL_DATA_NOT_ACTIVE:
return;
case BTIF_BTEVENT_ACL_DATA_ACTIVE:
btif_cmgr_handler_t *cmgrHandler;
/* Start the sniff timer */
cmgrHandler =
btif_cmgr_get_acl_handler(btif_me_get_callback_event_rem_dev(Event));
if (cmgrHandler)
app_bt_CMGR_SetSniffTimer(cmgrHandler, NULL, BTIF_CMGR_SNIFF_TIMER);
return;
}
TRACE(1, "SRC app_bt_golbal_handle evt = %d", etype);
switch (etype) {
case BTIF_BTEVENT_NAME_RESULT:
SOURCE_DBLOG("\n%s %d BTEVENT_NAME_RESULT\n", __FUNCTION__, __LINE__);
break;
case BTIF_BTEVENT_INQUIRY_RESULT:
remDev = btif_me_get_callback_event_rem_dev(Event);
SOURCE_DBLOG("\n%s %d BTEVENT_INQUIRY_RESULT\n", __FUNCTION__, __LINE__);
DUMP8("%02x ", btif_me_get_callback_event_inq_result_bd_addr_addr(Event),
6);
SOURCE_DBLOG("inqmode = %x",
btif_me_get_callback_event_inq_result_inq_mode(Event));
DUMP8("%02x ", btif_me_get_callback_event_inq_result_ext_inq_resp(Event),
20);
SOURCE_DBLOG("classdevice=%x",
btif_me_get_callback_event_inq_result_classofdevice(Event));
/// check the class of device to find the handfree device
// if(btif_me_get_callback_event_inq_result_classofdevice(Event) &
// BTIF_COD_MAJOR_AUDIO)
if ((btif_me_get_callback_event_inq_result_classofdevice(Event) &
BTIF_COD_MAJOR_AUDIO) &&
(!memcmp(btif_me_get_callback_event_inq_result_bd_addr_addr(Event),
source_bt_addr, 6))) {
memcpy(app_bt_device.inquried_snk_bdAddr.addr,
btif_me_get_callback_event_inq_result_bd_addr_addr(Event), 6);
DUMP8("%02x ", app_bt_device.inquried_snk_bdAddr.addr, 6);
btif_me_cancel_inquiry();
app_a2dp_source_stop_find();
}
break;
case BTIF_BTEVENT_INQUIRY_COMPLETE:
SOURCE_DBLOG("\n%s %d BTEVENT_INQUIRY_COMPLETE\n", __FUNCTION__, __LINE__);
app_a2dp_source_stop_find();
break;
/** The Inquiry process is canceled. */
case BTIF_BTEVENT_INQUIRY_CANCELED:
SOURCE_DBLOG("\n%s %d BTEVENT_INQUIRY_CANCELED\n", __FUNCTION__, __LINE__);
SOURCE_DBLOG("start to connect peer device");
btif_a2dp_open_stream(
app_bt_device.a2dp_stream[BT_DEVICE_ID_1]->a2dp_stream,
(bt_bdaddr_t *)&app_bt_device.inquried_snk_bdAddr);
break;
case BTIF_BTEVENT_LINK_CONNECT_CNF:
case BTIF_BTEVENT_LINK_CONNECT_IND:
SOURCE_DBLOG(
"CONNECT_IND/CNF evt:%d errCode:0x%0x newRole:%d activeCons:%d", etype,
btif_me_get_callback_event_err_code(Event),
btif_me_get_remote_device_role(
btif_me_get_callback_event_rem_dev(Event)),
btif_me_get_activeCons());
#if defined(__BTIF_EARPHONE__) && defined(__BTIF_AUTOPOWEROFF__)
if (btif_me_get_activeCons() == 0) {
app_start_10_second_timer(APP_POWEROFF_TIMER_ID);
} else {
app_stop_10_second_timer(APP_POWEROFF_TIMER_ID);
}
#endif
if (btif_me_get_activeCons() > 1) {
remDev = btif_me_get_callback_event_rem_dev(Event);
app_bt_MeDisconnectLink(remDev);
}
default:
// SOURCE_DBLOG("\n%s %d etype:%d\n",__FUNCTION__,__LINE__,event->eType);
break;
}
app_bt_role_manager_process(Event);
app_bt_accessible_manager_process(Event);
app_bt_sniff_manager_process(Event);
// SOURCE_DBLOG("\nexit: %s %d\n",__FUNCTION__,__LINE__);
}
#endif
void app_a2dp_start_stream(void) {
btif_a2dp_start_stream(&app_bt_device.a2dp_stream[BT_DEVICE_ID_1]);
}
void app_a2dp_suspend_stream(void) {
btif_a2dp_suspend_stream(&app_bt_device.a2dp_stream[BT_DEVICE_ID_1]);
}
static void _find_a2dp_sink_peer_device_start(void) {
SOURCE_DBLOG("\nenter: %s %d\n", __FUNCTION__, __LINE__);
bt_status_t state;
if (app_a2dp_source_find_process == 0 && app_bt_device.a2dp_state[0] == 0) {
app_a2dp_source_find_process = 1;
again:
state = btif_me_inquiry(BTIF_BT_IAC_GIAC, 30, 0);
SOURCE_DBLOG("\n%s %d\n", __FUNCTION__, __LINE__);
if (state != BT_STS_PENDING) {
osDelay(500);
goto again;
}
SOURCE_DBLOG("\n%s %d\n", __FUNCTION__, __LINE__);
}
}
void app_a2dp_source_find_sink(void) { _find_a2dp_sink_peer_device_start(); }
static bool need_init_encoder = true;
//__PSRAMDATA static SbcStreamInfo StreamInfo = {0};
static btif_sbc_stream_info_short_t StreamInfo = {0};
static btif_sbc_encoder_t sbc_encoder;
static uint8_t
app_a2dp_source_samplerate_2_sbcenc_type(enum AUD_SAMPRATE_T sample_rate) {
uint8_t rate = BTIF_SBC_CHNL_SAMPLE_FREQ_16;
switch (sample_rate) {
case AUD_SAMPRATE_16000:
rate = BTIF_SBC_CHNL_SAMPLE_FREQ_16;
break;
case AUD_SAMPRATE_32000:
rate = BTIF_SBC_CHNL_SAMPLE_FREQ_32;
break;
case AUD_SAMPRATE_44100:
rate = BTIF_SBC_CHNL_SAMPLE_FREQ_44_1;
break;
case AUD_SAMPRATE_48000:
rate = BTIF_SBC_CHNL_SAMPLE_FREQ_48;
break;
default:
TRACE(0, "error! sbc enc don't support other samplerate");
break;
}
SOURCE_DBLOG("\n%s %d rate = %x\n", __FUNCTION__, __LINE__, rate);
return rate;
}
#if 1
static void a2dp_source_send_sbc_packet(void) {
uint32_t frame_size = 512;
uint32_t frame_num = A2DP_TRANS_SIZE / frame_size;
// a2dp_source.lock_stream(&(tws.tws_source));
uint16_t byte_encoded = 0;
// uint16_t pcm_frame_size = 512/2;
unsigned short enc_len = 0;
bt_status_t status = BT_STS_FAILED;
int lock = int_lock();
sbcpack_t *sbcpack = get_sbcPacket();
btif_a2dp_sbc_packet_t *sbcPacket = &(sbcpack->sbcPacket);
sbcPacket->data = (U8 *)sbcpack->buffer;
memcpy(sbcpack->buffer, a2dp_transmit_buffer, A2DP_TRANS_SIZE);
// sbcPacket->dataLen = len;
// sbcPacket->frameSize = len/frame_num;
btif_sbc_pcm_data_t PcmEncData;
if (need_init_encoder) {
btif_sbc_init_encoder(&sbc_encoder);
sbc_encoder.streamInfo.numChannels = 2;
sbc_encoder.streamInfo.channelMode = BTIF_SBC_CHNL_MODE_JOINT_STEREO;
sbc_encoder.streamInfo.bitPool = A2DP_SBC_BITPOOL;
sbc_encoder.streamInfo.sampleFreq =
app_a2dp_source_samplerate_2_sbcenc_type(a2dp_source.sample_rate);
sbc_encoder.streamInfo.allocMethod = BTIF_SBC_ALLOC_METHOD_SNR;
sbc_encoder.streamInfo.numBlocks = 16;
sbc_encoder.streamInfo.numSubBands = 8;
sbc_encoder.streamInfo.mSbcFlag = 0;
need_init_encoder = 0;
}
PcmEncData.data = (uint8_t *)a2dp_transmit_buffer;
PcmEncData.dataLen = A2DP_TRANS_SIZE;
PcmEncData.numChannels = 2;
PcmEncData.sampleFreq = sbc_encoder.streamInfo.sampleFreq;
btif_sbc_encode_frames(&sbc_encoder, &PcmEncData, &byte_encoded,
(unsigned char *)sbcpack->buffer, &enc_len,
A2DP_TRANS_SIZE);
sbcPacket->dataLen = enc_len;
sbcPacket->frameSize = enc_len / frame_num;
int_unlock(lock);
status = btif_a2dp_stream_send_sbc_packet(
app_bt_device.a2dp_stream[BT_DEVICE_ID_1]->a2dp_stream, sbcPacket,
&StreamInfo);
if (status == BT_STS_PENDING)
a2dp_source_wait_sent(osWaitForever);
}
#endif
// #define BT_A2DP_SOURCE_LINEIN_BUFF_SIZE (512*5*2*2)
#define BT_A2DP_SOURCE_LINEIN_BUFF_SIZE (A2DP_TRANS_SIZE * 2)
#if defined(APP_LINEIN_A2DP_SOURCE)
//////////start the audio linein stream for capure the pcm data
int app_a2dp_source_linein_on(bool on) {
uint8_t *buff_play = NULL;
struct AF_STREAM_CONFIG_T stream_cfg;
static bool isRun = false;
SOURCE_DBLOG("app_a2dp_source_linein_on work:%d op:%d", isRun, on);
if (isRun == on)
return 0;
if (on) {
#if defined(SLAVE_USE_OPUS) || defined(MASTER_USE_OPUS) || defined(ALL_USE_OPUS)
app_audio_mempool_init(app_audio_get_basebuf_ptr(APP_MEM_LINEIN_AUDIO),
app_audio_get_basebuf_size(APP_MEM_LINEIN_AUDIO));
#else
app_audio_mempool_init();
#endif
app_sysfreq_req(APP_SYSFREQ_USER_APP_0, APP_SYSFREQ_104M);
app_audio_mempool_get_buff(&buff_play, BT_A2DP_SOURCE_LINEIN_BUFF_SIZE);
memset(&stream_cfg, 0, sizeof(stream_cfg));
stream_cfg.bits = AUD_BITS_16;
stream_cfg.channel_num = AUD_CHANNEL_NUM_2;
stream_cfg.sample_rate = a2dp_source.sample_rate;
stream_cfg.device = AUD_STREAM_USE_INT_CODEC;
stream_cfg.vol = 10;
// stream_cfg.io_path = AUD_INPUT_PATH_HP_MIC;
// stream_cfg.io_path =AUD_INPUT_PATH_MAINMIC;
stream_cfg.io_path = AUD_INPUT_PATH_LINEIN;
stream_cfg.handler = a2dp_source_linein_more_pcm_data;
stream_cfg.data_ptr = buff_play;
stream_cfg.data_size = BT_A2DP_SOURCE_LINEIN_BUFF_SIZE;
af_stream_open(AUD_STREAM_ID_0, AUD_STREAM_CAPTURE, &stream_cfg);
af_stream_start(AUD_STREAM_ID_0, AUD_STREAM_CAPTURE);
SOURCE_DBLOG("app_source_linein_on on");
} else {
af_stream_stop(AUD_STREAM_ID_0, AUD_STREAM_CAPTURE);
af_stream_close(AUD_STREAM_ID_0, AUD_STREAM_CAPTURE);
SOURCE_DBLOG("app_source_linein_on off");
// clear buffer data
a2dp_source.pcm_queue.write = 0;
a2dp_source.pcm_queue.len = 0;
a2dp_source.pcm_queue.read = 0;
app_sysfreq_req(APP_SYSFREQ_USER_APP_0, APP_SYSFREQ_32K);
}
isRun = on;
return 0;
}
#endif
////////////////////////////creat the thread for send sbc data to a2dp sink
/// device ///////////////////
static void send_thread(const void *arg);
osThreadDef(send_thread, osPriorityHigh, 1, 1024 * 2, "a2dp_send");
#if 1
static void send_thread(const void *arg) {
while (1) {
a2dp_source_wait_pcm_data();
while (a2dp_source_pcm_buffer_read((uint8_t *)a2dp_transmit_buffer,
A2DP_TRANS_SIZE) == 0) {
a2dp_source_send_sbc_packet();
}
}
}
#endif
void app_source_init(void) {
// register the bt global handler
a2dp_source_handler.callback = bt_a2dp_source_call_back;
btif_me_register_global_handler(&a2dp_source_handler);
btif_me_set_event_mask(
&a2dp_source_handler,
BTIF_BEM_LINK_DISCONNECT | BTIF_BEM_ROLE_CHANGE |
BTIF_BEM_INQUIRY_RESULT | BTIF_BEM_INQUIRY_COMPLETE |
BTIF_BEM_INQUIRY_CANCELED | BTIF_BEM_LINK_CONNECT_CNF |
BTIF_BEM_LINK_CONNECT_IND);
}
///////init the a2dp source feature
void app_a2dp_source_init(void) {
a2dp_source_lock_t *lock;
// get heap from app_audio_buffer
app_audio_mempool_get_buff(&a2dp_linein_buff, A2DP_LINEIN_SIZE);
InitCQueue(&a2dp_source.pcm_queue, A2DP_LINEIN_SIZE,
(CQItemType *)a2dp_linein_buff);
if (a2dp_source_mutex_id == NULL) {
a2dp_source_mutex_id = osMutexCreate((osMutex(a2dp_source_mutex)));
}
lock = &(a2dp_source.data_lock);
memset(lock, 0, sizeof(a2dp_source_lock_t));
lock->_osSemaphoreDef.semaphore = lock->_semaphore_data;
lock->_osSemaphoreId = osSemaphoreCreate(&(lock->_osSemaphoreDef), 0);
lock = &(a2dp_source.sbc_send_lock);
memset(lock, 0, sizeof(a2dp_source_lock_t));
lock->_osSemaphoreDef.semaphore = lock->_semaphore_data;
lock->_osSemaphoreId = osSemaphoreCreate(&(lock->_osSemaphoreDef), 0);
a2dp_source.sbc_send_id = osThreadCreate(osThread(send_thread), NULL);
a2dp_source.sample_rate = AUD_SAMPRATE_44100;
}
#endif
Reference in a new issue View git blame Copy permalink