/*******************************************************************************
**
** Function smp_process_confirm
**
** Description This function is called when SConfirm/MConfirm is generated
** proceed to send the Confirm request/response to peer device.
**
** Returns void
**
*******************************************************************************/
static void smp_process_confirm(tSMP_CB *p_cb, tSMP_ENC *p)
{
tSMP_KEY key;
SMP_TRACE_DEBUG0 ("smp_process_confirm ");
#if SMP_CONFORMANCE_TESTING == TRUE
if (p_cb->enable_test_confirm_val)
{
BTM_TRACE_DEBUG0 ("Use confirm value from script");
memcpy(p_cb->confirm, p_cb->test_confirm, BT_OCTET16_LEN);
}
else
memcpy(p_cb->confirm, p->param_buf, BT_OCTET16_LEN);
#else
memcpy(p_cb->confirm, p->param_buf, BT_OCTET16_LEN);
#endif
#if (SMP_DEBUG == TRUE)
SMP_TRACE_DEBUG0("Confirm Generated");
smp_debug_print_nbyte_little_endian ((UINT8 *)p_cb->confirm, (const UINT8 *)"Confirm", 16);
#endif
key.key_type = SMP_KEY_TYPE_CFM;
key.p_data = p->param_buf;
smp_sm_event(p_cb, SMP_KEY_READY_EVT, &key);
}
/*******************************************************************************
**
** Function btm_dev_support_switch
**
** Description This function is called by the L2CAP to check if remote
** device supports role switch
**
** Parameters: bd_addr - Address of the peer device
**
** Returns TRUE if device is known and role switch is supported
**
*******************************************************************************/
BOOLEAN btm_dev_support_switch (BD_ADDR bd_addr)
{
tBTM_SEC_DEV_REC *p_dev_rec;
UINT8 xx;
BOOLEAN feature_empty = TRUE;
#if BTM_SCO_INCLUDED == TRUE
/* Role switch is not allowed if a SCO is up */
if (btm_is_sco_active_by_bdaddr(bd_addr))
return(FALSE);
#endif
p_dev_rec = btm_find_dev (bd_addr);
if (p_dev_rec && HCI_SWITCH_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
{
if (HCI_SWITCH_SUPPORTED(p_dev_rec->features[HCI_EXT_FEATURES_PAGE_0]))
{
BTM_TRACE_DEBUG0("btm_dev_support_switch return TRUE (feature found)");
return (TRUE);
}
/* If the feature field is all zero, we never received them */
for (xx = 0 ; xx < BD_FEATURES_LEN ; xx++)
{
if (p_dev_rec->features[HCI_EXT_FEATURES_PAGE_0][xx] != 0x00)
{
feature_empty = FALSE; /* at least one is != 0 */
break;
}
}
/* If we don't know peer's capabilities, assume it supports Role-switch */
if (feature_empty)
{
BTM_TRACE_DEBUG0("btm_dev_support_switch return TRUE (feature empty)");
return (TRUE);
}
}
BTM_TRACE_DEBUG0("btm_dev_support_switch return FALSE");
return(FALSE);
}
/*******************************************************************************
**
** Function btm_update_bg_conn_list
**
** Description This function update the local background connection device list.
*******************************************************************************/
BOOLEAN btm_update_bg_conn_list(BOOLEAN to_add, BD_ADDR bd_addr, UINT8 *p_attr_tag)
{
tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
tBTM_LE_BG_CONN_DEV *p_bg_dev = &p_cb->bg_dev_list[0], *p_next, *p_cur;
UINT8 i, j;
BOOLEAN ret = FALSE;
BTM_TRACE_EVENT0 ("btm_update_bg_conn_list");
if ((to_add && (p_cb->bg_dev_num == BTM_BLE_MAX_BG_CONN_DEV_NUM || p_cb->num_empty_filter == 0)))
{
BTM_TRACE_DEBUG1("num_empty_filter = %d", p_cb->num_empty_filter);
return ret;
}
for (i = 0; i < BTM_BLE_MAX_BG_CONN_DEV_NUM; i ++, p_bg_dev ++)
{
if (p_bg_dev->in_use && memcmp(p_bg_dev->bd_addr, bd_addr, BD_ADDR_LEN) == 0)
{
if (!to_add)
{
memset(p_bg_dev, 0, sizeof(tBTM_LE_BG_CONN_DEV));
p_cb->bg_dev_num --;
p_cur = p_bg_dev;
p_next = p_bg_dev + 1;
for (j = i + 1 ;j < BTM_BLE_MAX_BG_CONN_DEV_NUM && p_next->in_use ; j ++, p_cur ++, p_next ++ )
memcpy(p_cur, p_next, sizeof(tBTM_LE_BG_CONN_DEV));
}
ret = TRUE;
break;
}
else if (!p_bg_dev->in_use && to_add)
{
BTM_TRACE_DEBUG0("add new WL entry in bg_dev_list");
memcpy(p_bg_dev->bd_addr, bd_addr, BD_ADDR_LEN);
p_bg_dev->in_use = TRUE;
p_cb->bg_dev_num ++;
ret = TRUE;
break;
}
}
return ret;
}
static INT32 saveDATAtobuffer(UINT8 * buf, UINT32 len)
{
INT32 res = 0;
VOHOG_LOCK();
memcpy(adpcm_voice_data_buffer.buf[adpcm_voice_data_buffer.widx],buf,len);
adpcm_voice_data_buffer.widx ++;
adpcm_voice_data_buffer.widx %= ADPCM_VOICE_DATA_BUFFER_SIZE;
if(adpcm_voice_data_buffer.widx == adpcm_voice_data_buffer.ridx)
{
BTM_TRACE_DEBUG0("the adpcm buffer is full,discard the old frame");
adpcm_voice_data_buffer.ridx ++;
adpcm_voice_data_buffer.ridx %= ADPCM_VOICE_DATA_BUFFER_SIZE;
}
BTM_TRACE_DEBUG2("savePCMfrombuffer ridx:%d widx:%d\n", adpcm_voice_data_buffer.ridx, adpcm_voice_data_buffer.widx);
VOHOG_UNLOCK();
return 1;
}
/*******************************************************************************
**
** Function btm_ble_find_dev_in_whitelist
**
** Description This function check if the device is in the white list
*******************************************************************************/
BOOLEAN btm_ble_find_dev_in_whitelist(BD_ADDR bd_addr)
{
tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
UINT8 i;
BTM_TRACE_EVENT0 ("btm_ble_find_dev_in_whitelist");
/* empty wl */
if (p_cb->num_empty_filter == p_cb->max_filter_entries)
{
BTM_TRACE_DEBUG0("white list empty");
return FALSE;
}
for (i = 0; i < BTM_BLE_MAX_BG_CONN_DEV_NUM && i < p_cb->max_filter_entries; i ++)
{
if (memcmp(p_cb->bg_conn_dev_list[i], bd_addr, BD_ADDR_LEN) == 0)
return TRUE;
}
return FALSE;
}
void start_adpcm_voice_rec(void)
{
remove(RTK_STORAGE_PCM_FILE);
BTM_TRACE_ERROR1("%s\n", __FUNCTION__);
if (adpcm_rec_cb.adpcm_state == NULL)
{
BTM_TRACE_DEBUG0("init the adpcm");
adpcm_rec_cb.adpcm_state = adpcm_decode_alloc();
}
adpcm_rec_cb.n_20bytes_pkts = 0;
if(!mutex_init)
{
const pthread_mutexattr_t attr = PTHREAD_MUTEX_RECURSIVE;
pthread_mutex_init(&adpcm_rec_cb.mutex, &attr);
}
memset(&adpcm_voice_data_buffer,0,sizeof(adpcm_voice_data_buffer));
UIPC_Open(UIPC_CH_ID_RTKBT_VR_AUDIO, voice_out_cb);
UIPC_Ioctl(UIPC_CH_ID_RTKBT_VR_AUDIO, UIPC_SET_READ_POLL_TMO, 0);
start_work_thread();
}
/*******************************************************************************
**
** Function btm_update_dev_to_white_list
**
** Description This function adds a device into white list.
*******************************************************************************/
BOOLEAN btm_update_dev_to_white_list(BOOLEAN to_add, BD_ADDR bd_addr, tBLE_ADDR_TYPE addr_type)
{
/* look up the sec device record, and find the address */
tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
tBTM_SEC_DEV_REC *p_dev_rec;
BD_ADDR dummy_bda = {0};
BOOLEAN started = FALSE, suspend = FALSE;
if (btm_cb.btm_inq_vars.inq_active)
{
suspend = TRUE;
btsnd_hcic_ble_set_scan_enable (BTM_BLE_SCAN_DISABLE, BTM_BLE_DUPLICATE_ENABLE);
}
if ((p_dev_rec = btm_find_dev (bd_addr)) != NULL &&
p_dev_rec->device_type == BT_DEVICE_TYPE_BLE)
{
BTM_TRACE_DEBUG0("btm_update_dev_to_white_list 1");
if ((to_add && p_cb->num_empty_filter == 0) ||
(!to_add && p_cb->num_empty_filter == p_cb->max_filter_entries))
{
BTM_TRACE_ERROR1("num_entry available in controller: %d", p_cb->num_empty_filter);
return started;
}
if ( p_dev_rec->ble.ble_addr_type == BLE_ADDR_PUBLIC)
{
if (to_add)
started = btsnd_hcic_ble_add_white_list (BLE_ADDR_PUBLIC, bd_addr);
else
started = btsnd_hcic_ble_remove_from_white_list (BLE_ADDR_PUBLIC, bd_addr);
}
else
{
if (BLE_ADDR_IS_STATIC(bd_addr))
{
if (to_add)
started = btsnd_hcic_ble_add_white_list (BLE_ADDR_RANDOM, bd_addr);
else
started = btsnd_hcic_ble_remove_from_white_list (BLE_ADDR_RANDOM, bd_addr);
}
if (memcmp(p_dev_rec->ble.reconn_addr, dummy_bda, BD_ADDR_LEN) != 0)
{
if (to_add)
started = btsnd_hcic_ble_add_white_list (BLE_ADDR_RANDOM, p_dev_rec->ble.reconn_addr);
else
started = btsnd_hcic_ble_remove_from_white_list (BLE_ADDR_RANDOM, p_dev_rec->ble.reconn_addr);
}
}
}
/* if not a known device, shall we add it? */
else
{
if (to_add)
started = btsnd_hcic_ble_add_white_list (addr_type, bd_addr);
else
started = btsnd_hcic_ble_remove_from_white_list (addr_type, bd_addr);
}
if (suspend)
{
btsnd_hcic_ble_set_scan_enable (BTM_BLE_SCAN_ENABLE, BTM_BLE_DUPLICATE_DISABLE);
}
return started;
}
static void work_task(void *arg)
{
BTM_TRACE_WARNING0("WORK THREAD START");
while (1)
{
VOHOG_LOCK();
if(adpcm_rec_cb.running)
{
if(adpcm_rec_cb.channel_status)
{
if(!isEmpty())
{
if(getDATAfrombuffer(tempData,ADPCM_VOICE_DATA_BLOCK_SIZE))
{
if(UIPC_RTKBT_VR_Send_noblock(UIPC_CH_ID_RTKBT_VR_AUDIO, 0, tempData, ADPCM_VOICE_DATA_BLOCK_SIZE))
{
BTM_TRACE_DEBUG0("send data sucess");
adpcm_voice_data_buffer.ridx ++;
adpcm_voice_data_buffer.ridx %= ADPCM_VOICE_DATA_BUFFER_SIZE;
} else {
BTM_TRACE_ERROR0("send data failed");
}
}
}
}
} else {
if(adpcm_rec_cb.channel_status)
{
BTM_TRACE_WARNING0("close thread: channel is connected");
if(isEmpty())
{
BTM_TRACE_WARNING0("the buffer is empty, close socket");
resetBuffer();
UIPC_Close(UIPC_CH_ID_RTKBT_VR_AUDIO);
VOHOG_UNLOCK();
break;
} else {
BTM_TRACE_WARNING0("the buffer is not empty, send data");
if(getDATAfrombuffer(tempData,ADPCM_VOICE_DATA_BLOCK_SIZE))
{
if(UIPC_RTKBT_VR_Send_noblock(UIPC_CH_ID_RTKBT_VR_AUDIO, 0, tempData, ADPCM_VOICE_DATA_BLOCK_SIZE))
{
BTM_TRACE_DEBUG0("send data sucess");
adpcm_voice_data_buffer.ridx ++;
adpcm_voice_data_buffer.ridx %= ADPCM_VOICE_DATA_BUFFER_SIZE;
} else {
BTM_TRACE_ERROR0("send data failed,close socket");
resetBuffer();
UIPC_Close(UIPC_CH_ID_RTKBT_VR_AUDIO);
VOHOG_UNLOCK();
break;
}
}
}
}else {
BTM_TRACE_WARNING0("close thread: the socket is not connected");
VOHOG_UNLOCK();
break;
}
}
VOHOG_UNLOCK();
usleep(1000);
}
adpcm_rec_cb.tid = 0;
BTM_TRACE_WARNING0("VOICE THREAD DONE");
}
BOOLEAN adpcm_voice_encode(tBTA_ATT_HSDATA *att_data)
{
//BTM_TRACE_DEBUG0("adpcm_voice_encode");
uint8_t buffer[MAX_FRAME_SIZE];
int size;
int frame_size;
UINT8 *p = NULL;
FILE *fp;
fp = fopen (RTK_STORAGE_PCM_FILE, "a+");
if (fp == NULL)
{
BTM_TRACE_WARNING0("open file failed\n");
return FALSE;
}
p = (UINT8*)(att_data->data+3);
size = att_data->data_len - 3;
/* we must receive 12 20-bytes packets followed by a 19-bytes packet */
switch (size) {
case 20:
adpcm_rec_cb.n_20bytes_pkts++;
if (adpcm_rec_cb.n_20bytes_pkts > 12){
BTM_TRACE_DEBUG0("20bytes pkt is exceed 12");
adpcm_rec_cb.n_20bytes_pkts = 1;
memcpy(adpcm_rec_cb.buffer + (adpcm_rec_cb.n_20bytes_pkts - 1) * 20,p, 20);
} else {
memcpy(adpcm_rec_cb.buffer + (adpcm_rec_cb.n_20bytes_pkts - 1) * 20,p, 20);
}
break;
case 19:
if (adpcm_rec_cb.n_20bytes_pkts != 12) {
BTM_TRACE_DEBUG0("20bytes pkt!=12,discard the frame");
adpcm_rec_cb.n_20bytes_pkts = 0;
} else {
memcpy(adpcm_rec_cb.buffer + adpcm_rec_cb.n_20bytes_pkts * 20, p, 19);
adpcm_rec_cb.n_20bytes_pkts = 0;
frame_size = adpcm_decode(adpcm_rec_cb.adpcm_state, buffer, adpcm_rec_cb.buffer,ADPCM_ENCODED_FRAME_SIZE);
BTM_TRACE_DEBUG1("frame size= %d",frame_size);
if(frame_size == 1020)
{
fwrite(buffer, frame_size, 1, fp);
if(adpcm_rec_cb.channel_status)
{
if(isEmpty())
{
BTM_TRACE_DEBUG0("the buffer empty,send data to socket");
VOHOG_LOCK();
if(!UIPC_RTKBT_VR_Send_noblock(UIPC_CH_ID_RTKBT_VR_AUDIO, 0, buffer, frame_size))
{
BTM_TRACE_WARNING0("send data fail, save data to buffer");
saveDATAtobuffer(buffer, frame_size);
}
VOHOG_UNLOCK();
} else {
BTM_TRACE_DEBUG0("the buffer is not empty, save data to buffer");
saveDATAtobuffer(buffer, frame_size);
}
} else {
if(!adpcm_rec_cb.channel_status)
{
BTM_TRACE_DEBUG0("socket is close");
}
saveDATAtobuffer(buffer, frame_size);
}
}else {
BTM_TRACE_DEBUG0("frame_size is error");
}
}
break;
default:
BTM_TRACE_DEBUG0("size is error");
}
//BTM_TRACE_DEBUG1("20bytes pkt= %d",adpcm_rec_cb.n_20bytes_pkts);
free(att_data);
//fseek(fp,0,SEEK_END);
//int lSize = ftell(fp);
//BTM_TRACE_WARNING1("file length %d\n",lSize);
fclose(fp);
return TRUE;
}
