/******************************************************************************* ** ** 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; }