static UINT8 bta_ar_id(tBTA_SYS_ID sys_id)
{
UINT8 mask = 0;
- if (sys_id == BTA_ID_AV)
- {
+ if (sys_id == BTA_ID_AV) {
mask = BTA_AR_AV_MASK;
- }
- else if (sys_id == BTA_ID_AVK)
- {
+ } else if (sys_id == BTA_ID_AVK) {
mask = BTA_AR_AVK_MASK;
}
static void bta_ar_avdt_cback(UINT8 handle, BD_ADDR bd_addr, UINT8 event, tAVDT_CTRL *p_data)
{
/* route the AVDT registration callback to av or avk */
- if (bta_ar_cb.p_av_conn_cback)
+ if (bta_ar_cb.p_av_conn_cback) {
(*bta_ar_cb.p_av_conn_cback)(handle, bd_addr, event, p_data);
- if (bta_ar_cb.p_avk_conn_cback)
+ }
+ if (bta_ar_cb.p_avk_conn_cback) {
(*bta_ar_cb.p_avk_conn_cback)(handle, bd_addr, event, p_data);
+ }
}
/*******************************************************************************
{
UINT8 mask = 0;
- if (sys_id == BTA_ID_AV)
- {
+ if (sys_id == BTA_ID_AV) {
bta_ar_cb.p_av_conn_cback = p_cback;
mask = BTA_AR_AV_MASK;
- }
- else if (sys_id == BTA_ID_AVK)
- {
+ } else if (sys_id == BTA_ID_AVK) {
bta_ar_cb.p_avk_conn_cback = p_cback;
mask = BTA_AR_AVK_MASK;
}
#if (BTA_AR_DEBUG == TRUE)
- else
- {
+ else {
APPL_TRACE_ERROR("bta_ar_reg_avdt: the registration is from wrong sys_id:%d", sys_id);
}
#endif
- if (mask)
- {
- if (bta_ar_cb.avdt_registered == 0)
- {
+ if (mask) {
+ if (bta_ar_cb.avdt_registered == 0) {
AVDT_Register(p_reg, bta_ar_avdt_cback);
}
bta_ar_cb.avdt_registered |= mask;
{
UINT8 mask = 0;
- if (sys_id == BTA_ID_AV)
- {
+ if (sys_id == BTA_ID_AV) {
bta_ar_cb.p_av_conn_cback = NULL;
mask = BTA_AR_AV_MASK;
- }
- else if (sys_id == BTA_ID_AVK)
- {
+ } else if (sys_id == BTA_ID_AVK) {
bta_ar_cb.p_avk_conn_cback = NULL;
mask = BTA_AR_AVK_MASK;
}
bta_ar_cb.avdt_registered &= ~mask;
- if (bta_ar_cb.avdt_registered == 0)
+ if (bta_ar_cb.avdt_registered == 0) {
AVDT_Deregister();
+ }
}
/*******************************************************************************
UINT8 event = BTA_AR_AVDT_CONN_EVT;
tAVDT_CTRL data;
- if (sys_id == BTA_ID_AV)
- {
- if (bta_ar_cb.p_avk_conn_cback)
- {
+ if (sys_id == BTA_ID_AV) {
+ if (bta_ar_cb.p_avk_conn_cback) {
(*bta_ar_cb.p_avk_conn_cback)(0, bd_addr, event, &data);
}
- }
- else if (sys_id == BTA_ID_AVK)
- {
- if (bta_ar_cb.p_av_conn_cback)
- {
+ } else if (sys_id == BTA_ID_AVK) {
+ if (bta_ar_cb.p_av_conn_cback) {
(*bta_ar_cb.p_av_conn_cback)(0, bd_addr, event, &data);
}
}
{
UINT8 mask = bta_ar_id (sys_id);
- if (mask)
- {
- if (bta_ar_cb.avct_registered == 0)
- {
+ if (mask) {
+ if (bta_ar_cb.avct_registered == 0) {
AVCT_Register(mtu, mtu_br, sec_mask);
}
bta_ar_cb.avct_registered |= mask;
bta_ar_cb.avct_registered &= ~mask;
- if (bta_ar_cb.avct_registered == 0)
+ if (bta_ar_cb.avct_registered == 0) {
AVCT_Deregister();
+ }
}
/******************************************************************************
**
******************************************************************************/
void bta_ar_reg_avrc(UINT16 service_uuid, char *service_name, char *provider_name,
- UINT16 categories, tBTA_SYS_ID sys_id)
+ UINT16 categories, tBTA_SYS_ID sys_id)
{
UINT8 mask = bta_ar_id (sys_id);
UINT8 temp[8], *p;
- if (!mask || !categories)
+ if (!mask || !categories) {
return;
+ }
- if (service_uuid == UUID_SERVCLASS_AV_REM_CTRL_TARGET)
- {
- if (bta_ar_cb.sdp_tg_handle == 0)
- {
+ if (service_uuid == UUID_SERVCLASS_AV_REM_CTRL_TARGET) {
+ if (bta_ar_cb.sdp_tg_handle == 0) {
bta_ar_cb.tg_registered = mask;
bta_ar_cb.sdp_tg_handle = SDP_CreateRecord();
AVRC_AddRecord(service_uuid, service_name, provider_name, categories, bta_ar_cb.sdp_tg_handle);
}
/* only one TG is allowed (first-come, first-served).
* If sdp_tg_handle is non-0, ignore this request */
- }
- else if ((service_uuid == UUID_SERVCLASS_AV_REMOTE_CONTROL) || (service_uuid == UUID_SERVCLASS_AV_REM_CTRL_CONTROL))
- {
+ } else if ((service_uuid == UUID_SERVCLASS_AV_REMOTE_CONTROL) || (service_uuid == UUID_SERVCLASS_AV_REM_CTRL_CONTROL)) {
bta_ar_cb.ct_categories [mask - 1] = categories;
- categories = bta_ar_cb.ct_categories[0]|bta_ar_cb.ct_categories[1];
- if (bta_ar_cb.sdp_ct_handle == 0)
- {
+ categories = bta_ar_cb.ct_categories[0] | bta_ar_cb.ct_categories[1];
+ if (bta_ar_cb.sdp_ct_handle == 0) {
bta_ar_cb.sdp_ct_handle = SDP_CreateRecord();
AVRC_AddRecord(service_uuid, service_name, provider_name, categories, bta_ar_cb.sdp_ct_handle);
bta_sys_add_uuid(service_uuid);
- }
- else
- {
+ } else {
/* multiple CTs are allowed.
* Change supported categories on the second one */
p = temp;
UINT16_TO_BE_STREAM(p, categories);
SDP_AddAttribute(bta_ar_cb.sdp_ct_handle, ATTR_ID_SUPPORTED_FEATURES, UINT_DESC_TYPE,
- (UINT32)2, (UINT8*)temp);
+ (UINT32)2, (UINT8 *)temp);
}
}
}
UINT16 categories = 0;
UINT8 temp[8], *p;
- if (!mask)
+ if (!mask) {
return;
+ }
- if (service_uuid == UUID_SERVCLASS_AV_REM_CTRL_TARGET)
- {
- if (bta_ar_cb.sdp_tg_handle && mask == bta_ar_cb.tg_registered)
- {
+ if (service_uuid == UUID_SERVCLASS_AV_REM_CTRL_TARGET) {
+ if (bta_ar_cb.sdp_tg_handle && mask == bta_ar_cb.tg_registered) {
bta_ar_cb.tg_registered = 0;
SDP_DeleteRecord(bta_ar_cb.sdp_tg_handle);
bta_ar_cb.sdp_tg_handle = 0;
bta_sys_remove_uuid(service_uuid);
}
- }
- else if (service_uuid == UUID_SERVCLASS_AV_REMOTE_CONTROL)
- {
- if (bta_ar_cb.sdp_ct_handle)
- {
+ } else if (service_uuid == UUID_SERVCLASS_AV_REMOTE_CONTROL) {
+ if (bta_ar_cb.sdp_ct_handle) {
bta_ar_cb.ct_categories [mask - 1] = 0;
- categories = bta_ar_cb.ct_categories[0]|bta_ar_cb.ct_categories[1];
- if (!categories)
- {
+ categories = bta_ar_cb.ct_categories[0] | bta_ar_cb.ct_categories[1];
+ if (!categories) {
/* no CT is still registered - cleaup */
SDP_DeleteRecord(bta_ar_cb.sdp_ct_handle);
bta_ar_cb.sdp_ct_handle = 0;
bta_sys_remove_uuid(service_uuid);
- }
- else
- {
+ } else {
/* change supported categories to the remaning one */
p = temp;
UINT16_TO_BE_STREAM(p, categories);
SDP_AddAttribute(bta_ar_cb.sdp_ct_handle, ATTR_ID_SUPPORTED_FEATURES, UINT_DESC_TYPE,
- (UINT32)2, (UINT8*)temp);
+ (UINT32)2, (UINT8 *)temp);
}
}
}
#define BTA_AR_AVK_MASK 0x02
/* data associated with BTA_AR */
-typedef struct
-{
+typedef struct {
tAVDT_CTRL_CBACK *p_av_conn_cback; /* av connection callback function */
tAVDT_CTRL_CBACK *p_avk_conn_cback; /* avk connection callback function */
UINT8 avdt_registered;
UINT8 avct_registered;
- UINT32 sdp_tg_handle;
- UINT32 sdp_ct_handle;
+ UINT32 sdp_tg_handle;
+ UINT32 sdp_ct_handle;
UINT16 ct_categories[2];
UINT8 tg_registered;
tBTA_AV_HNDL hndl; /* Handle associated with the stream that rejected the connection. */
static void bta_av_st_rc_timer(tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data);
/* state machine states */
-enum
-{
+enum {
BTA_AV_INIT_SST,
BTA_AV_INCOMING_SST,
BTA_AV_OPENING_SST,
/* ssm action functions for audio stream */
-const tBTA_AV_SACT bta_av_a2d_action[] =
-{
+const tBTA_AV_SACT bta_av_a2d_action[] = {
bta_av_do_disc_a2d, /* BTA_AV_DO_DISC */
bta_av_cleanup, /* BTA_AV_CLEANUP */
bta_av_free_sdb, /* BTA_AV_FREE_SDB */
static void bta_av_stream5_cback(UINT8 handle, BD_ADDR bd_addr, UINT8 event, tAVDT_CTRL *p_data);
#endif
/* the array of callback functions to receive events from AVDT control channel */
-tAVDT_CTRL_CBACK * const bta_av_dt_cback[] =
-{
+tAVDT_CTRL_CBACK *const bta_av_dt_cback[] = {
bta_av_stream0_cback
- ,bta_av_stream1_cback
+ , bta_av_stream1_cback
#if BTA_AV_NUM_STRS > 2
- ,bta_av_stream2_cback
+ , bta_av_stream2_cback
#endif
#if BTA_AV_NUM_STRS > 3
- ,bta_av_stream3_cback
+ , bta_av_stream3_cback
#endif
#if BTA_AV_NUM_STRS > 4
- ,bta_av_stream4_cback
+ , bta_av_stream4_cback
#endif
#if BTA_AV_NUM_STRS > 5
- ,bta_av_stream5_cback
+ , bta_av_stream5_cback
#endif
};
/***********************************************
***********************************************/
static UINT8 bta_av_get_scb_handle(tBTA_AV_SCB *p_scb, UINT8 local_sep)
{
- UINT8 xx =0;
- for (xx = 0; xx<BTA_AV_MAX_SEPS; xx++)
- {
+ UINT8 xx = 0;
+ for (xx = 0; xx < BTA_AV_MAX_SEPS; xx++) {
if ((p_scb->seps[xx].tsep == local_sep) &&
- (p_scb->seps[xx].codec_type == p_scb->codec_type))
+ (p_scb->seps[xx].codec_type == p_scb->codec_type)) {
return (p_scb->seps[xx].av_handle);
+ }
}
APPL_TRACE_DEBUG(" bta_av_get_scb_handle appropiate sep_type not found")
return 0; /* return invalid handle */
***********************************************/
static UINT8 bta_av_get_scb_sep_type(tBTA_AV_SCB *p_scb, UINT8 tavdt_handle)
{
- UINT8 xx =0;
- for (xx = 0; xx<BTA_AV_MAX_SEPS; xx++)
- {
- if (p_scb->seps[xx].av_handle == tavdt_handle)
+ UINT8 xx = 0;
+ for (xx = 0; xx < BTA_AV_MAX_SEPS; xx++) {
+ if (p_scb->seps[xx].av_handle == tavdt_handle) {
return (p_scb->seps[xx].tsep);
+ }
}
APPL_TRACE_DEBUG(" bta_av_get_scb_sep_type appropiate handle not found")
return 3; /* return invalid sep type */
static void bta_av_save_addr(tBTA_AV_SCB *p_scb, const BD_ADDR b)
{
APPL_TRACE_DEBUG("bta_av_save_addr r:%d, s:%d",
- p_scb->recfg_sup, p_scb->suspend_sup);
- if(bdcmp(p_scb->peer_addr, b) != 0)
- {
+ p_scb->recfg_sup, p_scb->suspend_sup);
+ if (bdcmp(p_scb->peer_addr, b) != 0) {
APPL_TRACE_ERROR("reset flags");
/* a new addr, reset the supported flags */
p_scb->recfg_sup = TRUE;
UNUSED(p_data);
APPL_TRACE_DEBUG("bta_av_st_rc_timer rc_handle:%d, use_rc: %d",
- p_scb->rc_handle, p_scb->use_rc);
+ p_scb->rc_handle, p_scb->use_rc);
/* for outgoing RC connection as INT/CT */
- if( (p_scb->rc_handle == BTA_AV_RC_HANDLE_NONE) &&
- /*(bta_av_cb.features & BTA_AV_FEAT_RCCT) &&*/
- (p_scb->use_rc == TRUE || (p_scb->role & BTA_AV_ROLE_AD_ACP)) )
- {
- if ((p_scb->wait & BTA_AV_WAIT_ROLE_SW_BITS) == 0)
+ if ( (p_scb->rc_handle == BTA_AV_RC_HANDLE_NONE) &&
+ /*(bta_av_cb.features & BTA_AV_FEAT_RCCT) &&*/
+ (p_scb->use_rc == TRUE || (p_scb->role & BTA_AV_ROLE_AD_ACP)) ) {
+ if ((p_scb->wait & BTA_AV_WAIT_ROLE_SW_BITS) == 0) {
bta_sys_start_timer(&p_scb->timer, BTA_AV_AVRC_TIMER_EVT, BTA_AV_RC_DISC_TIME_VAL);
- else
+ } else {
p_scb->wait |= BTA_AV_WAIT_CHECK_RC;
+ }
}
}
UINT16 uuid_int = p_scb->uuid_int;
UINT8 sep_requested = 0;
- if(uuid_int == UUID_SERVCLASS_AUDIO_SOURCE)
- sep_requested = AVDT_TSEP_SNK;
- else if(uuid_int == UUID_SERVCLASS_AUDIO_SINK)
- sep_requested = AVDT_TSEP_SRC;
+ if (uuid_int == UUID_SERVCLASS_AUDIO_SOURCE) {
+ sep_requested = AVDT_TSEP_SNK;
+ } else if (uuid_int == UUID_SERVCLASS_AUDIO_SINK) {
+ sep_requested = AVDT_TSEP_SRC;
+ }
- for (i = p_scb->sep_info_idx; i < p_scb->num_seps; i++)
- {
+ for (i = p_scb->sep_info_idx; i < p_scb->num_seps; i++) {
/* steam not in use, is a sink, and is the right media type (audio/video) */
if ((p_scb->sep_info[i].in_use == FALSE) &&
- (p_scb->sep_info[i].tsep == sep_requested) &&
- (p_scb->sep_info[i].media_type == p_scb->media_type))
- {
+ (p_scb->sep_info[i].tsep == sep_requested) &&
+ (p_scb->sep_info[i].media_type == p_scb->media_type)) {
p_scb->sep_info_idx = i;
/* we got a stream; get its capabilities */
- if (p_scb->p_cap == NULL)
- {
+ if (p_scb->p_cap == NULL) {
p_scb->p_cap = (tAVDT_CFG *) GKI_getbuf(sizeof(tAVDT_CFG));
}
- if (p_scb->p_cap == NULL)
- {
+ if (p_scb->p_cap == NULL) {
i = p_scb->num_seps;
break;
}
- if (p_scb->avdt_version >= AVDT_VERSION_SYNC)
- {
+ if (p_scb->avdt_version >= AVDT_VERSION_SYNC) {
p_req = AVDT_GetAllCapReq;
- }
- else
- {
+ } else {
p_req = AVDT_GetCapReq;
}
(*p_req)(p_scb->peer_addr,
- p_scb->sep_info[i].seid,
- p_scb->p_cap, bta_av_dt_cback[p_scb->hdi]);
+ p_scb->sep_info[i].seid,
+ p_scb->p_cap, bta_av_dt_cback[p_scb->hdi]);
sent_cmd = TRUE;
break;
}
}
/* if no streams available then stream open fails */
- if (!sent_cmd)
- {
+ if (!sent_cmd) {
bta_av_ssm_execute(p_scb, BTA_AV_STR_GETCAP_FAIL_EVT, p_data);
}
tBTA_AV_SCB *p_scb = bta_av_cb.p_scb[index];
int xx;
- if (p_data)
- {
- if (event == AVDT_SECURITY_IND_EVT)
- {
+ if (p_data) {
+ if (event == AVDT_SECURITY_IND_EVT) {
sec_len = (p_data->security_ind.len < BTA_AV_SECURITY_MAX_LEN) ?
- p_data->security_ind.len : BTA_AV_SECURITY_MAX_LEN;
- }
- else if (event == AVDT_SECURITY_CFM_EVT && p_data->hdr.err_code == 0)
- {
+ p_data->security_ind.len : BTA_AV_SECURITY_MAX_LEN;
+ } else if (event == AVDT_SECURITY_CFM_EVT && p_data->hdr.err_code == 0) {
sec_len = (p_data->security_cfm.len < BTA_AV_SECURITY_MAX_LEN) ?
- p_data->security_cfm.len : BTA_AV_SECURITY_MAX_LEN;
+ p_data->security_cfm.len : BTA_AV_SECURITY_MAX_LEN;
}
}
- if (p_scb && (p_msg = (tBTA_AV_STR_MSG *) GKI_getbuf((UINT16) (sizeof(tBTA_AV_STR_MSG) + sec_len))) != NULL)
- {
+ if (p_scb && (p_msg = (tBTA_AV_STR_MSG *) GKI_getbuf((UINT16) (sizeof(tBTA_AV_STR_MSG) + sec_len))) != NULL) {
/* copy event data, bd addr, and handle to event message buffer */
p_msg->hdr.offset = 0;
- if (bd_addr != NULL)
- {
+ if (bd_addr != NULL) {
bdcpy(p_msg->bd_addr, bd_addr);
APPL_TRACE_DEBUG(" bd_addr:%02x-%02x-%02x-%02x-%02x-%02x",
- bd_addr[0], bd_addr[1],
- bd_addr[2], bd_addr[3],
- bd_addr[4], bd_addr[5]);
+ bd_addr[0], bd_addr[1],
+ bd_addr[2], bd_addr[3],
+ bd_addr[4], bd_addr[5]);
}
- if (p_data != NULL)
- {
+ if (p_data != NULL) {
memcpy(&p_msg->msg, p_data, sizeof (tAVDT_CTRL));
/* copy config params to event message buffer */
- switch (event)
- {
+ switch (event) {
case AVDT_RECONFIG_CFM_EVT:
- APPL_TRACE_DEBUG("reconfig cfm event codec info = 0x%06x-%06x-%06x-%02x",
- (p_msg->msg.reconfig_cfm.p_cfg->codec_info[0]<<16)+(p_msg->msg.reconfig_cfm.p_cfg->codec_info[1]<<8)+p_msg->msg.reconfig_cfm.p_cfg->codec_info[2],
- (p_msg->msg.reconfig_cfm.p_cfg->codec_info[3]<<16)+(p_msg->msg.reconfig_cfm.p_cfg->codec_info[4]<<8)+p_msg->msg.reconfig_cfm.p_cfg->codec_info[5],
- (p_msg->msg.reconfig_cfm.p_cfg->codec_info[6]<<16)+(p_msg->msg.reconfig_cfm.p_cfg->codec_info[7]<<8)+p_msg->msg.reconfig_cfm.p_cfg->codec_info[8],
- p_msg->msg.reconfig_cfm.p_cfg->codec_info[9]);
- break;
+ APPL_TRACE_DEBUG("reconfig cfm event codec info = 0x%06x-%06x-%06x-%02x",
+ (p_msg->msg.reconfig_cfm.p_cfg->codec_info[0] << 16) + (p_msg->msg.reconfig_cfm.p_cfg->codec_info[1] << 8) + p_msg->msg.reconfig_cfm.p_cfg->codec_info[2],
+ (p_msg->msg.reconfig_cfm.p_cfg->codec_info[3] << 16) + (p_msg->msg.reconfig_cfm.p_cfg->codec_info[4] << 8) + p_msg->msg.reconfig_cfm.p_cfg->codec_info[5],
+ (p_msg->msg.reconfig_cfm.p_cfg->codec_info[6] << 16) + (p_msg->msg.reconfig_cfm.p_cfg->codec_info[7] << 8) + p_msg->msg.reconfig_cfm.p_cfg->codec_info[8],
+ p_msg->msg.reconfig_cfm.p_cfg->codec_info[9]);
+ break;
case AVDT_CONFIG_IND_EVT:
- /* We might have 2 SEP signallings(A2DP + VDP) with one peer device on one L2CAP.
- * If we already have a signalling connection with the bd_addr and the streaming
- * SST is at INIT state, change it to INCOMING state to handle the signalling
- * from the 2nd SEP. */
- if ((bta_av_find_lcb(bd_addr, BTA_AV_LCB_FIND) != NULL) && (bta_av_is_scb_init(p_scb)))
- {
- bta_av_set_scb_sst_incoming (p_scb);
-
- /* When ACP_CONNECT_EVT was received, we put first available scb to incoming state.
- * Later when we receive AVDT_CONFIG_IND_EVT, we use a new p_scb and set its state to
- * incoming which we do it above.
- * We also have to set the old p_scb state to init to be used later */
- for (xx = 0; xx < BTA_AV_NUM_STRS; xx++)
- {
- if ((bta_av_cb.p_scb[xx]) && (xx != index))
- {
- if (bta_av_cb.p_scb[xx]->state == BTA_AV_INCOMING_SST)
- {
- bta_av_cb.p_scb[xx]->state = BTA_AV_INIT_SST;
- bta_av_cb.p_scb[xx]->coll_mask = 0;
- break;
+ /* We might have 2 SEP signallings(A2DP + VDP) with one peer device on one L2CAP.
+ * If we already have a signalling connection with the bd_addr and the streaming
+ * SST is at INIT state, change it to INCOMING state to handle the signalling
+ * from the 2nd SEP. */
+ if ((bta_av_find_lcb(bd_addr, BTA_AV_LCB_FIND) != NULL) && (bta_av_is_scb_init(p_scb))) {
+ bta_av_set_scb_sst_incoming (p_scb);
+
+ /* When ACP_CONNECT_EVT was received, we put first available scb to incoming state.
+ * Later when we receive AVDT_CONFIG_IND_EVT, we use a new p_scb and set its state to
+ * incoming which we do it above.
+ * We also have to set the old p_scb state to init to be used later */
+ for (xx = 0; xx < BTA_AV_NUM_STRS; xx++) {
+ if ((bta_av_cb.p_scb[xx]) && (xx != index)) {
+ if (bta_av_cb.p_scb[xx]->state == BTA_AV_INCOMING_SST) {
+ bta_av_cb.p_scb[xx]->state = BTA_AV_INIT_SST;
+ bta_av_cb.p_scb[xx]->coll_mask = 0;
+ break;
+ }
}
}
}
- }
- memcpy(&p_msg->cfg, p_data->config_ind.p_cfg, sizeof(tAVDT_CFG));
- break;
+ memcpy(&p_msg->cfg, p_data->config_ind.p_cfg, sizeof(tAVDT_CFG));
+ break;
case AVDT_SECURITY_IND_EVT:
p_msg->msg.security_ind.p_data = (UINT8 *) (p_msg + 1);
case AVDT_SECURITY_CFM_EVT:
p_msg->msg.security_cfm.p_data = (UINT8 *) (p_msg + 1);
- if (p_data->hdr.err_code == 0)
- {
+ if (p_data->hdr.err_code == 0) {
memcpy(p_msg->msg.security_cfm.p_data, p_data->security_cfm.p_data, sec_len);
}
break;
case AVDT_SUSPEND_IND_EVT:
p_msg->msg.hdr.err_code = 0;
break;
- /*
+ /*
case AVDT_CLOSE_CFM_EVT:
case AVDT_CLOSE_IND_EVT:
- p_msg->disc_rsn = p_data->hdr.err_param;
- break;
- */
+ p_msg->disc_rsn = p_data->hdr.err_param;
+ break;
+ */
default:
break;
}
- }
- else
+ } else {
p_msg->msg.hdr.err_code = 0;
+ }
/* look up application event */
- if ((p_data == NULL) || (p_data->hdr.err_code == 0))
- {
+ if ((p_data == NULL) || (p_data->hdr.err_code == 0)) {
p_msg->hdr.event = bta_av_stream_evt_ok[event];
- }
- else
- {
+ } else {
p_msg->hdr.event = bta_av_stream_evt_fail[event];
}
p_msg->initiator = FALSE;
- if (event == AVDT_SUSPEND_CFM_EVT)
+ if (event == AVDT_SUSPEND_CFM_EVT) {
p_msg->initiator = TRUE;
+ }
APPL_TRACE_VERBOSE("hndl:x%x", p_scb->hndl);
p_msg->hdr.layer_specific = p_scb->hndl;
bta_sys_sendmsg(p_msg);
}
-/* coverity[var_deref_model] */
-/* false-positive: bta_av_conn_cback only processes AVDT_CONNECT_IND_EVT and AVDT_DISCONNECT_IND_EVT event
- * these 2 events always have associated p_data */
- if (p_data)
- {
+ /* coverity[var_deref_model] */
+ /* false-positive: bta_av_conn_cback only processes AVDT_CONNECT_IND_EVT and AVDT_DISCONNECT_IND_EVT event
+ * these 2 events always have associated p_data */
+ if (p_data) {
bta_av_conn_cback(handle, bd_addr, event, p_data);
- }
- else
- {
+ } else {
APPL_TRACE_ERROR("%s: p_data is null", __func__);
}
}
{
int index = 0;
tBTA_AV_SCB *p_scb ;
- APPL_TRACE_DEBUG("bta_av_stream_data_cback avdt_handle: %d pkt_len=0x%x ofst = 0x%x", handle,p_pkt->len,p_pkt->offset);
- APPL_TRACE_DEBUG(" Number of frames 0x%x",*((UINT8*)(p_pkt + 1) + p_pkt->offset));
- APPL_TRACE_DEBUG("Sequence Number 0x%x",p_pkt->layer_specific);
+ APPL_TRACE_DEBUG("bta_av_stream_data_cback avdt_handle: %d pkt_len=0x%x ofst = 0x%x", handle, p_pkt->len, p_pkt->offset);
+ APPL_TRACE_DEBUG(" Number of frames 0x%x", *((UINT8 *)(p_pkt + 1) + p_pkt->offset));
+ APPL_TRACE_DEBUG("Sequence Number 0x%x", p_pkt->layer_specific);
/* Get SCB and correct sep type*/
- for(index = 0; index < BTA_AV_NUM_STRS;index ++ )
- {
+ for (index = 0; index < BTA_AV_NUM_STRS; index ++ ) {
p_scb = bta_av_cb.p_scb[index];
- if((p_scb->avdt_handle == handle)&&(p_scb->seps[p_scb->sep_idx].tsep == AVDT_TSEP_SNK))
+ if ((p_scb->avdt_handle == handle) && (p_scb->seps[p_scb->sep_idx].tsep == AVDT_TSEP_SNK)) {
break;
+ }
}
- if(index == BTA_AV_NUM_STRS) /* cannot find correct handler */
- {
+ if (index == BTA_AV_NUM_STRS) { /* cannot find correct handler */
GKI_freebuf(p_pkt);
return;
}
p_pkt->event = BTA_AV_MEDIA_DATA_EVT;
- p_scb->seps[p_scb->sep_idx].p_app_data_cback(BTA_AV_MEDIA_DATA_EVT, (tBTA_AV_MEDIA*)p_pkt);
+ p_scb->seps[p_scb->sep_idx].p_app_data_cback(BTA_AV_MEDIA_DATA_EVT, (tBTA_AV_MEDIA *)p_pkt);
GKI_freebuf(p_pkt); /* a copy of packet had been delivered, we free this buffer */
}
tBTA_AV_SDP_RES *p_msg;
tBTA_AV_SCB *p_scb;
- if ((p_msg = (tBTA_AV_SDP_RES *) GKI_getbuf(sizeof(tBTA_AV_SDP_RES))) != NULL)
- {
+ if ((p_msg = (tBTA_AV_SDP_RES *) GKI_getbuf(sizeof(tBTA_AV_SDP_RES))) != NULL) {
p_msg->hdr.event = (found) ? BTA_AV_SDP_DISC_OK_EVT : BTA_AV_SDP_DISC_FAIL_EVT;
p_scb = bta_av_hndl_to_scb(bta_av_cb.handle);
- if (p_scb)
- {
- if (found && (p_service != NULL))
+ if (p_scb) {
+ if (found && (p_service != NULL)) {
p_scb->avdt_version = p_service->avdt_version;
- else
+ } else {
p_scb->avdt_version = 0x00;
+ }
p_msg->hdr.layer_specific = bta_av_cb.handle;
bta_sys_sendmsg(p_msg);
- }
- else
- {
+ } else {
APPL_TRACE_ERROR ("bta_av_a2d_sdp_cback, no scb found for handle(0x%x)", bta_av_cb.handle);
}
}
{
int xx;
APPL_TRACE_DEBUG("bta_av_adjust_seps_idx codec_type: %d", p_scb->codec_type);
- for(xx=0; xx<BTA_AV_MAX_SEPS; xx++)
- {
+ for (xx = 0; xx < BTA_AV_MAX_SEPS; xx++) {
APPL_TRACE_DEBUG("av_handle: %d codec_type: %d",
- p_scb->seps[xx].av_handle, p_scb->seps[xx].codec_type);
- if((p_scb->seps[xx].av_handle && p_scb->codec_type == p_scb->seps[xx].codec_type)
- && (p_scb->seps[xx].av_handle == avdt_handle))
- {
+ p_scb->seps[xx].av_handle, p_scb->seps[xx].codec_type);
+ if ((p_scb->seps[xx].av_handle && p_scb->codec_type == p_scb->seps[xx].codec_type)
+ && (p_scb->seps[xx].av_handle == avdt_handle)) {
p_scb->sep_idx = xx;
p_scb->avdt_handle = p_scb->seps[xx].av_handle;
break;
UNUSED(p_data);
APPL_TRACE_DEBUG("bta_av_switch_role wait:x%x", p_scb->wait);
- if (p_scb->wait & BTA_AV_WAIT_ROLE_SW_RES_START)
+ if (p_scb->wait & BTA_AV_WAIT_ROLE_SW_RES_START) {
p_scb->wait |= BTA_AV_WAIT_ROLE_SW_RETRY;
+ }
/* clear the masks set when the timer is started */
- p_scb->wait &= ~(BTA_AV_WAIT_ROLE_SW_RES_OPEN|BTA_AV_WAIT_ROLE_SW_RES_START);
+ p_scb->wait &= ~(BTA_AV_WAIT_ROLE_SW_RES_OPEN | BTA_AV_WAIT_ROLE_SW_RES_START);
- if (p_scb->q_tag == BTA_AV_Q_TAG_OPEN)
- {
- if (bta_av_switch_if_needed(p_scb) || !bta_av_link_role_ok(p_scb, A2D_SET_MULTL_BIT))
- {
+ if (p_scb->q_tag == BTA_AV_Q_TAG_OPEN) {
+ if (bta_av_switch_if_needed(p_scb) || !bta_av_link_role_ok(p_scb, A2D_SET_MULTL_BIT)) {
p_scb->wait |= BTA_AV_WAIT_ROLE_SW_RES_OPEN;
- }
- else
- {
+ } else {
/* this should not happen in theory. Just in case...
* continue to do_disc_a2d */
switch_res = BTA_AV_RS_DONE;
}
- }
- else
- {
+ } else {
/* report failure on OPEN */
switch_res = BTA_AV_RS_FAIL;
}
- if (switch_res != BTA_AV_RS_NONE)
- {
- if (bta_av_cb.rs_idx == (p_scb->hdi + 1))
- {
+ if (switch_res != BTA_AV_RS_NONE) {
+ if (bta_av_cb.rs_idx == (p_scb->hdi + 1)) {
bta_av_cb.rs_idx = 0;
}
p_scb->wait &= ~BTA_AV_WAIT_ROLE_SW_RETRY;
tBTA_AV_OPEN av_open;
APPL_TRACE_DEBUG("bta_av_role_res q_tag:%d, wait:x%x, role:x%x", p_scb->q_tag, p_scb->wait, p_scb->role);
- if (p_scb->role & BTA_AV_ROLE_START_INT)
+ if (p_scb->role & BTA_AV_ROLE_START_INT) {
initiator = TRUE;
+ }
- if (p_scb->q_tag == BTA_AV_Q_TAG_START)
- {
- if (p_scb->wait & BTA_AV_WAIT_ROLE_SW_STARTED)
- {
+ if (p_scb->q_tag == BTA_AV_Q_TAG_START) {
+ if (p_scb->wait & BTA_AV_WAIT_ROLE_SW_STARTED) {
p_scb->wait &= ~BTA_AV_WAIT_ROLE_SW_BITS;
- if (p_data->role_res.hci_status != HCI_SUCCESS)
- {
+ if (p_data->role_res.hci_status != HCI_SUCCESS) {
p_scb->role &= ~BTA_AV_ROLE_START_INT;
bta_sys_idle(BTA_ID_AV, bta_av_cb.audio_open_cnt, p_scb->peer_addr);
/* start failed because of role switch. */
start.hndl = p_scb->hndl;
start.initiator = initiator;
(*bta_av_cb.p_cback)(BTA_AV_START_EVT, (tBTA_AV *) &start);
- }
- else
- {
+ } else {
bta_av_start_ok(p_scb, p_data);
}
- }
- else if (p_scb->wait & BTA_AV_WAIT_ROLE_SW_RES_START)
+ } else if (p_scb->wait & BTA_AV_WAIT_ROLE_SW_RES_START) {
p_scb->wait |= BTA_AV_WAIT_ROLE_SW_FAILED;
- }
- else if (p_scb->q_tag == BTA_AV_Q_TAG_OPEN)
- {
- if (p_scb->wait & BTA_AV_WAIT_ROLE_SW_RES_OPEN)
- {
+ }
+ } else if (p_scb->q_tag == BTA_AV_Q_TAG_OPEN) {
+ if (p_scb->wait & BTA_AV_WAIT_ROLE_SW_RES_OPEN) {
p_scb->role &= ~BTA_AV_ROLE_START_INT;
p_scb->wait &= ~BTA_AV_WAIT_ROLE_SW_BITS;
- if (p_data->role_res.hci_status != HCI_SUCCESS)
- {
+ if (p_data->role_res.hci_status != HCI_SUCCESS) {
/* Open failed because of role switch. */
bdcpy(av_open.bd_addr, p_scb->peer_addr);
av_open.chnl = p_scb->chnl;
av_open.hndl = p_scb->hndl;
start.status = BTA_AV_FAIL_ROLE;
- if(p_scb->seps[p_scb->sep_idx].tsep == AVDT_TSEP_SRC )
+ if (p_scb->seps[p_scb->sep_idx].tsep == AVDT_TSEP_SRC ) {
av_open.sep = AVDT_TSEP_SNK;
- else if(p_scb->seps[p_scb->sep_idx].tsep == AVDT_TSEP_SNK )
+ } else if (p_scb->seps[p_scb->sep_idx].tsep == AVDT_TSEP_SNK ) {
av_open.sep = AVDT_TSEP_SRC;
+ }
(*bta_av_cb.p_cback)(BTA_AV_OPEN_EVT, (tBTA_AV *)&av_open);
- }
- else
- {
+ } else {
/* Continue av open process */
p_scb->q_info.open.switch_res = BTA_AV_RS_DONE;
- bta_av_do_disc_a2d (p_scb, (tBTA_AV_DATA *)&(p_scb->q_info.open));
+ bta_av_do_disc_a2d (p_scb, (tBTA_AV_DATA *) & (p_scb->q_info.open));
}
- }
- else
- {
+ } else {
APPL_TRACE_WARNING ("Unexpected role switch event: q_tag = %d wait = %d", p_scb->q_tag, p_scb->wait);
}
}
tA2D_SDP_DB_PARAMS db_params;
UINT16 attr_list[] = {ATTR_ID_SERVICE_CLASS_ID_LIST,
ATTR_ID_PROTOCOL_DESC_LIST,
- ATTR_ID_BT_PROFILE_DESC_LIST};
+ ATTR_ID_BT_PROFILE_DESC_LIST
+ };
UINT16 sdp_uuid = 0; /* UUID for which SDP has to be done */
APPL_TRACE_DEBUG("bta_av_do_disc_a2d use_rc: %d rs:%d, oc:%d",
- p_data->api_open.use_rc, p_data->api_open.switch_res, bta_av_cb.audio_open_cnt);
+ p_data->api_open.use_rc, p_data->api_open.switch_res, bta_av_cb.audio_open_cnt);
memcpy (&(p_scb->open_api), &(p_data->api_open), sizeof(tBTA_AV_API_OPEN));
- switch(p_data->api_open.switch_res)
- {
+ switch (p_data->api_open.switch_res) {
case BTA_AV_RS_NONE:
- if (bta_av_switch_if_needed(p_scb) || !bta_av_link_role_ok(p_scb, A2D_SET_MULTL_BIT))
- {
+ if (bta_av_switch_if_needed(p_scb) || !bta_av_link_role_ok(p_scb, A2D_SET_MULTL_BIT)) {
/* waiting for role switch result. save the api to control block */
memcpy(&p_scb->q_info.open, &p_data->api_open, sizeof(tBTA_AV_API_OPEN));
p_scb->wait |= BTA_AV_WAIT_ROLE_SW_RES_OPEN;
p_scb->q_tag = BTA_AV_Q_TAG_OPEN;
- }
- else
- {
+ } else {
ok_continue = TRUE;
}
break;
case BTA_AV_RS_OK:
p_data = (tBTA_AV_DATA *)&p_scb->q_info.open;
/* continue to open if link role is ok */
- if (bta_av_link_role_ok(p_scb, A2D_SET_MULTL_BIT))
- {
+ if (bta_av_link_role_ok(p_scb, A2D_SET_MULTL_BIT)) {
ok_continue = TRUE;
- }
- else
- {
+ } else {
p_scb->wait |= BTA_AV_WAIT_ROLE_SW_RES_OPEN;
}
break;
}
APPL_TRACE_DEBUG("ok_continue: %d wait:x%x, q_tag: %d", ok_continue, p_scb->wait, p_scb->q_tag);
- if (!ok_continue)
+ if (!ok_continue) {
return;
+ }
/* clear the role switch bits */
p_scb->wait &= ~BTA_AV_WAIT_ROLE_SW_BITS;
- if (p_scb->wait & BTA_AV_WAIT_CHECK_RC)
- {
+ if (p_scb->wait & BTA_AV_WAIT_CHECK_RC) {
p_scb->wait &= ~BTA_AV_WAIT_CHECK_RC;
bta_sys_start_timer(&p_scb->timer, BTA_AV_AVRC_TIMER_EVT, BTA_AV_RC_DISC_TIME_VAL);
}
- if (bta_av_cb.features & BTA_AV_FEAT_MASTER)
- {
+ if (bta_av_cb.features & BTA_AV_FEAT_MASTER) {
L2CA_SetDesireRole(L2CAP_ROLE_DISALLOW_SWITCH);
- if (bta_av_cb.audio_open_cnt == 1)
- {
+ if (bta_av_cb.audio_open_cnt == 1) {
/* there's already an A2DP connection. do not allow switch */
bta_sys_clear_default_policy(BTA_ID_AV, HCI_ENABLE_MASTER_SLAVE_SWITCH);
}
bta_sys_app_open(BTA_ID_AV, p_scb->app_id, p_scb->peer_addr);
/* allocate discovery database */
- if (p_scb->p_disc_db == NULL)
- {
+ if (p_scb->p_disc_db == NULL) {
p_scb->p_disc_db = (tSDP_DISCOVERY_DB *) GKI_getbuf(BTA_AV_DISC_BUF_SIZE);
}
/* only one A2D find service is active at a time */
bta_av_cb.handle = p_scb->hndl;
- if(p_scb->p_disc_db)
- {
+ if (p_scb->p_disc_db) {
/* set up parameters */
db_params.db_len = BTA_AV_DISC_BUF_SIZE;
db_params.num_attr = 3;
db_params.p_db = p_scb->p_disc_db;
db_params.p_attrs = attr_list;
p_scb->uuid_int = p_data->api_open.uuid;
- if (p_scb->uuid_int == UUID_SERVCLASS_AUDIO_SINK)
+ if (p_scb->uuid_int == UUID_SERVCLASS_AUDIO_SINK) {
sdp_uuid = UUID_SERVCLASS_AUDIO_SOURCE;
- else if (p_scb->uuid_int == UUID_SERVCLASS_AUDIO_SOURCE)
+ } else if (p_scb->uuid_int == UUID_SERVCLASS_AUDIO_SOURCE) {
sdp_uuid = UUID_SERVCLASS_AUDIO_SINK;
+ }
APPL_TRACE_DEBUG("uuid_int 0x%x, Doing SDP For 0x%x", p_scb->uuid_int, sdp_uuid);
- if(A2D_FindService(sdp_uuid, p_scb->peer_addr, &db_params,
- bta_av_a2d_sdp_cback) == A2D_SUCCESS)
- {
+ if (A2D_FindService(sdp_uuid, p_scb->peer_addr, &db_params,
+ bta_av_a2d_sdp_cback) == A2D_SUCCESS) {
return;
}
}
p_scb->num_disc_snks = 0;
p_scb->disc_rsn = 0;
bta_sys_stop_timer(&p_scb->timer);
- if (p_scb->deregistring)
- {
+ if (p_scb->deregistring) {
/* remove stream */
- for(xx=0; xx<BTA_AV_MAX_SEPS; xx++)
- {
- if(p_scb->seps[xx].av_handle)
+ for (xx = 0; xx < BTA_AV_MAX_SEPS; xx++) {
+ if (p_scb->seps[xx].av_handle) {
AVDT_RemoveStream(p_scb->seps[xx].av_handle);
+ }
p_scb->seps[xx].av_handle = 0;
}
bta_av_dereg_comp((tBTA_AV_DATA *) &msg);
- }
- else
- {
+ } else {
/* report stream closed to main SM */
msg.is_up = FALSE;
bdcpy(msg.peer_addr, p_scb->peer_addr);
/* if no codec parameters in configuration, fail */
if ((p_evt_cfg->num_codec == 0) ||
- /* or the peer requests for a service we do not support */
- ((psc_mask != p_scb->cfg.psc_mask) &&
- (psc_mask != (p_scb->cfg.psc_mask&~AVDT_PSC_DELAY_RPT))) )
- {
+ /* or the peer requests for a service we do not support */
+ ((psc_mask != p_scb->cfg.psc_mask) &&
+ (psc_mask != (p_scb->cfg.psc_mask & ~AVDT_PSC_DELAY_RPT))) ) {
setconfig.hndl = p_scb->hndl; /* we may not need this */
setconfig.err_code = AVDT_ERR_UNSUP_CFG;
bta_av_ssm_execute(p_scb, BTA_AV_CI_SETCONFIG_FAIL_EVT, (tBTA_AV_DATA *) &setconfig);
- }
- else
- {
+ } else {
p_info = &p_scb->sep_info[0];
p_info->in_use = 0;
p_info->media_type = p_scb->media_type;
p_info->seid = p_data->str_msg.msg.config_ind.int_seid;
/* Sep type of Peer will be oppsite role to our local sep */
- if (local_sep == AVDT_TSEP_SRC)
+ if (local_sep == AVDT_TSEP_SRC) {
p_info->tsep = AVDT_TSEP_SNK;
- else if (local_sep == AVDT_TSEP_SNK)
+ } else if (local_sep == AVDT_TSEP_SNK) {
p_info->tsep = AVDT_TSEP_SRC;
+ }
p_scb->role |= BTA_AV_ROLE_AD_ACP;
p_scb->cur_psc_mask = p_evt_cfg->psc_mask;
- if (bta_av_cb.features & BTA_AV_FEAT_RCTG)
+ if (bta_av_cb.features & BTA_AV_FEAT_RCTG) {
p_scb->use_rc = TRUE;
- else
+ } else {
p_scb->use_rc = FALSE;
+ }
p_scb->num_seps = 1;
p_scb->sep_info_idx = 0;
APPL_TRACE_DEBUG("bta_av_config_ind: SEID: %d use_rc: %d cur_psc_mask:0x%x", p_info->seid, p_scb->use_rc, p_scb->cur_psc_mask);
/* in case of A2DP SINK this is the first time peer data is being sent to co functions */
- if (local_sep == AVDT_TSEP_SNK)
- {
+ if (local_sep == AVDT_TSEP_SNK) {
p_scb->p_cos->setcfg(p_scb->hndl, p_scb->codec_type,
- p_evt_cfg->codec_info,
- p_info->seid,
- p_scb->peer_addr,
- p_evt_cfg->num_protect,
- p_evt_cfg->protect_info,
- AVDT_TSEP_SNK,
- p_msg->handle);
- }
- else
- {
+ p_evt_cfg->codec_info,
+ p_info->seid,
+ p_scb->peer_addr,
+ p_evt_cfg->num_protect,
+ p_evt_cfg->protect_info,
+ AVDT_TSEP_SNK,
+ p_msg->handle);
+ } else {
p_scb->p_cos->setcfg(p_scb->hndl, p_scb->codec_type,
- p_evt_cfg->codec_info,
- p_info->seid,
- p_scb->peer_addr,
- p_evt_cfg->num_protect,
- p_evt_cfg->protect_info,
- AVDT_TSEP_SRC,
- p_msg->handle);
+ p_evt_cfg->codec_info,
+ p_info->seid,
+ p_scb->peer_addr,
+ p_evt_cfg->num_protect,
+ p_evt_cfg->protect_info,
+ AVDT_TSEP_SRC,
+ p_msg->handle);
}
}
}
bta_sys_stop_timer(&bta_av_cb.sig_tmr);
bta_sys_stop_timer(&p_scb->timer);
- if(bta_av_cb.conn_lcb)
- {
+ if (bta_av_cb.conn_lcb) {
p_rcb = bta_av_get_rcb_by_shdl((UINT8)(p_scb->hdi + 1));
- if (p_rcb)
+ if (p_rcb) {
bta_av_del_rc(p_rcb);
+ }
AVDT_DisconnectReq(p_scb->peer_addr, bta_av_dt_cback[p_scb->hdi]);
- }
- else
- {
+ } else {
bta_av_ssm_execute(p_scb, BTA_AV_AVDT_DISCONNECT_EVT, NULL);
}
}
*******************************************************************************/
void bta_av_security_req (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
{
- if (bta_av_cb.features & BTA_AV_FEAT_PROTECT)
- {
+ if (bta_av_cb.features & BTA_AV_FEAT_PROTECT) {
AVDT_SecurityReq(p_scb->avdt_handle, p_data->api_protect_req.p_data,
p_data->api_protect_req.len);
}
*******************************************************************************/
void bta_av_security_rsp (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
{
- if (bta_av_cb.features & BTA_AV_FEAT_PROTECT)
- {
+ if (bta_av_cb.features & BTA_AV_FEAT_PROTECT) {
AVDT_SecurityRsp(p_scb->avdt_handle, p_scb->avdt_label, p_data->api_protect_rsp.error_code,
p_data->api_protect_rsp.p_data, p_data->api_protect_rsp.len);
- }
- else
- {
+ } else {
AVDT_SecurityRsp(p_scb->avdt_handle, p_scb->avdt_label, AVDT_ERR_NSC,
- NULL, 0);
+ NULL, 0);
}
}
UINT8 local_sep;
/* we like this codec_type. find the sep_idx */
- local_sep = bta_av_get_scb_sep_type(p_scb,avdt_handle);
+ local_sep = bta_av_get_scb_sep_type(p_scb, avdt_handle);
bta_av_adjust_seps_idx(p_scb, avdt_handle);
APPL_TRACE_DEBUG("bta_av_setconfig_rsp: sep_idx: %d cur_psc_mask:0x%x", p_scb->sep_idx, p_scb->cur_psc_mask);
if ((AVDT_TSEP_SNK == local_sep) && (p_data->ci_setconfig.err_code == AVDT_SUCCESS) &&
- (p_scb->seps[p_scb->sep_idx].p_app_data_cback != NULL))
+ (p_scb->seps[p_scb->sep_idx].p_app_data_cback != NULL))
p_scb->seps[p_scb->sep_idx].p_app_data_cback(BTA_AV_MEDIA_SINK_CFG_EVT,
- (tBTA_AV_MEDIA*)p_scb->cfg.codec_info);
+ (tBTA_AV_MEDIA *)p_scb->cfg.codec_info);
AVDT_ConfigRsp(p_scb->avdt_handle, p_scb->avdt_label, p_data->ci_setconfig.err_code,
bta_sys_stop_timer(&bta_av_cb.sig_tmr);
- if(p_data->ci_setconfig.err_code == AVDT_SUCCESS)
- {
+ if (p_data->ci_setconfig.err_code == AVDT_SUCCESS) {
p_scb->wait = BTA_AV_WAIT_ACP_CAPS_ON;
- if(p_data->ci_setconfig.recfg_needed)
+ if (p_data->ci_setconfig.recfg_needed) {
p_scb->role |= BTA_AV_ROLE_SUSPEND_OPT;
+ }
APPL_TRACE_DEBUG("bta_av_setconfig_rsp recfg_needed:%d role:x%x num:%d",
- p_data->ci_setconfig.recfg_needed, p_scb->role, num);
+ p_data->ci_setconfig.recfg_needed, p_scb->role, num);
/* callout module tells BTA the number of "good" SEPs and their SEIDs.
* getcap on these SEID */
p_scb->num_seps = num;
- if (p_scb->cur_psc_mask & AVDT_PSC_DELAY_RPT)
+ if (p_scb->cur_psc_mask & AVDT_PSC_DELAY_RPT) {
p_scb->avdt_version = AVDT_VERSION_SYNC;
+ }
- if (p_scb->codec_type == BTA_AV_CODEC_SBC || num > 1)
- {
+ if (p_scb->codec_type == BTA_AV_CODEC_SBC || num > 1) {
/* if SBC is used by the SNK as INT, discover req is not sent in bta_av_config_ind.
* call disc_res now */
- /* this is called in A2DP SRC path only, In case of SINK we don't need it */
+ /* this is called in A2DP SRC path only, In case of SINK we don't need it */
if (local_sep == AVDT_TSEP_SRC)
p_scb->p_cos->disc_res(p_scb->hndl, num, num, 0, p_scb->peer_addr,
- UUID_SERVCLASS_AUDIO_SOURCE);
- }
- else
- {
+ UUID_SERVCLASS_AUDIO_SOURCE);
+ } else {
/* we do not know the peer device and it is using non-SBC codec
* we need to know all the SEPs on SNK */
bta_av_discover_req(p_scb, NULL);
return;
}
- for (i = 1; i < num; i++)
- {
- APPL_TRACE_DEBUG("sep_info[%d] SEID: %d", i, p_seid[i-1]);
+ for (i = 1; i < num; i++) {
+ APPL_TRACE_DEBUG("sep_info[%d] SEID: %d", i, p_seid[i - 1]);
/* initialize the sep_info[] to get capabilities */
p_scb->sep_info[i].in_use = FALSE;
p_scb->sep_info[i].tsep = AVDT_TSEP_SNK;
p_scb->sep_info[i].media_type = p_scb->media_type;
- p_scb->sep_info[i].seid = p_seid[i-1];
+ p_scb->sep_info[i].seid = p_seid[i - 1];
}
/* only in case of local sep as SRC we need to look for other SEPs, In case of SINK we don't */
- if (local_sep == AVDT_TSEP_SRC)
- {
+ if (local_sep == AVDT_TSEP_SRC) {
/* Make sure UUID has been initialized... */
- if (p_scb->uuid_int == 0)
+ if (p_scb->uuid_int == 0) {
p_scb->uuid_int = p_scb->open_api.uuid;
+ }
bta_av_next_getcap(p_scb, p_data);
}
}
p_scb->stream_mtu = p_data->str_msg.msg.open_ind.peer_mtu - AVDT_MEDIA_HDR_SIZE;
mtu = bta_av_chk_mtu(p_scb, p_scb->stream_mtu);
APPL_TRACE_DEBUG("bta_av_str_opened l2c_cid: 0x%x stream_mtu: %d mtu: %d",
- p_scb->l2c_cid, p_scb->stream_mtu, mtu);
- if(mtu == 0 || mtu > p_scb->stream_mtu)
+ p_scb->l2c_cid, p_scb->stream_mtu, mtu);
+ if (mtu == 0 || mtu > p_scb->stream_mtu) {
mtu = p_scb->stream_mtu;
+ }
/* Set the media channel as medium priority */
L2CA_SetTxPriority(p_scb->l2c_cid, L2CAP_CHNL_PRIORITY_MEDIUM);
p_scb->l2c_bufs = 0;
p_scb->p_cos->open(p_scb->hndl,
- p_scb->codec_type, p_scb->cfg.codec_info, mtu);
+ p_scb->codec_type, p_scb->cfg.codec_info, mtu);
{
/* TODO check if other audio channel is open.
open.status = BTA_AV_SUCCESS;
open.starting = bta_av_chk_start(p_scb);
open.edr = 0;
- if( NULL != (p = BTM_ReadRemoteFeatures(p_scb->peer_addr)))
- {
- if(HCI_EDR_ACL_2MPS_SUPPORTED(p))
+ if ( NULL != (p = BTM_ReadRemoteFeatures(p_scb->peer_addr))) {
+ if (HCI_EDR_ACL_2MPS_SUPPORTED(p)) {
open.edr |= BTA_AV_EDR_2MBPS;
- if(HCI_EDR_ACL_3MPS_SUPPORTED(p))
+ }
+ if (HCI_EDR_ACL_3MPS_SUPPORTED(p)) {
open.edr |= BTA_AV_EDR_3MBPS;
+ }
}
#if( defined BTA_AR_INCLUDED ) && (BTA_AR_INCLUDED == TRUE)
bta_ar_avdt_conn(BTA_ID_AV, open.bd_addr);
#endif
- if (p_scb->seps[p_scb->sep_idx].tsep == AVDT_TSEP_SRC )
+ if (p_scb->seps[p_scb->sep_idx].tsep == AVDT_TSEP_SRC ) {
open.sep = AVDT_TSEP_SNK;
- else if (p_scb->seps[p_scb->sep_idx].tsep == AVDT_TSEP_SNK )
+ } else if (p_scb->seps[p_scb->sep_idx].tsep == AVDT_TSEP_SNK ) {
open.sep = AVDT_TSEP_SRC;
+ }
(*bta_av_cb.p_cback)(BTA_AV_OPEN_EVT, (tBTA_AV *) &open);
- if(open.starting)
- {
+ if (open.starting) {
bta_av_ssm_execute(p_scb, BTA_AV_AP_START_EVT, NULL);
}
}
-#if 0 /* TODO: implement the property enable/disable */
+#if 0 /* TODO: implement the property enable/disable */
// This code is used to pass PTS TC for AVDTP ABORT
char value[PROPERTY_VALUE_MAX] = {0};
if ((property_get("bluetooth.pts.force_a2dp_abort", value, "false"))
- && (!strcmp(value, "true")))
- {
+ && (!strcmp(value, "true"))) {
APPL_TRACE_ERROR ("%s: Calling AVDT_AbortReq", __func__);
AVDT_AbortReq(p_scb->avdt_handle);
}
p_scb->avdt_label = p_data->str_msg.msg.hdr.label;
- if (bta_av_cb.features & BTA_AV_FEAT_PROTECT)
- {
+ if (bta_av_cb.features & BTA_AV_FEAT_PROTECT) {
protect_req.chnl = p_scb->chnl;
protect_req.hndl = p_scb->hndl;
/*
(*bta_av_cb.p_cback)(BTA_AV_PROTECT_REQ_EVT, (tBTA_AV *) &protect_req);
}
/* app doesn't support security indication; respond with failure */
- else
- {
+ else {
AVDT_SecurityRsp(p_scb->avdt_handle, p_scb->avdt_label, AVDT_ERR_NSC, NULL, 0);
}
}
{
tBTA_AV_PROTECT_RSP protect_rsp;
- if (bta_av_cb.features & BTA_AV_FEAT_PROTECT)
- {
+ if (bta_av_cb.features & BTA_AV_FEAT_PROTECT) {
protect_rsp.chnl = p_scb->chnl;
protect_rsp.hndl = p_scb->hndl;
protect_rsp.p_data = p_data->str_msg.msg.security_cfm.p_data;
protect_rsp.len = p_data->str_msg.msg.security_cfm.len;
- protect_rsp.err_code= p_data->str_msg.msg.hdr.err_code;
+ protect_rsp.err_code = p_data->str_msg.msg.hdr.err_code;
(*bta_av_cb.p_cback)(BTA_AV_PROTECT_RSP_EVT, (tBTA_AV *) &protect_rsp);
}
UNUSED(p_data);
/* stop stream if started */
- if (p_scb->co_started)
- {
+ if (p_scb->co_started) {
bta_av_str_stopped(p_scb, NULL);
}
bta_sys_stop_timer(&bta_av_cb.sig_tmr);
utl_freebuf((void **) &p_scb->p_disc_db);
- if (p_scb->coll_mask & BTA_AV_COLL_INC_TMR)
- {
+ if (p_scb->coll_mask & BTA_AV_COLL_INC_TMR) {
/* SNK initiated L2C connection while SRC was doing SDP. */
/* Wait until timeout to check if SNK starts signalling. */
APPL_TRACE_EVENT("bta_av_connect_req: coll_mask = 0x%2X", p_scb->coll_mask);
*******************************************************************************/
void bta_av_sdp_failed (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
{
- if (!p_scb->open_status)
+ if (!p_scb->open_status) {
p_scb->open_status = BTA_AV_FAIL_SDP;
+ }
utl_freebuf((void **) &p_scb->p_disc_db);
bta_av_str_closed(p_scb, p_data);
*******************************************************************************/
void bta_av_disc_results (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
{
- UINT8 num_snks = 0, num_srcs =0, i;
+ UINT8 num_snks = 0, num_srcs = 0, i;
/* our uuid in case we initiate connection */
UINT16 uuid_int = p_scb->uuid_int;
/* store number of stream endpoints returned */
p_scb->num_seps = p_data->str_msg.msg.discover_cfm.num_seps;
- for (i = 0; i < p_scb->num_seps; i++)
- {
+ for (i = 0; i < p_scb->num_seps; i++) {
/* steam not in use, is a sink, and is audio */
if ((p_scb->sep_info[i].in_use == FALSE) &&
- (p_scb->sep_info[i].media_type == p_scb->media_type))
- {
- if((p_scb->sep_info[i].tsep == AVDT_TSEP_SNK) &&
- (uuid_int == UUID_SERVCLASS_AUDIO_SOURCE))
+ (p_scb->sep_info[i].media_type == p_scb->media_type)) {
+ if ((p_scb->sep_info[i].tsep == AVDT_TSEP_SNK) &&
+ (uuid_int == UUID_SERVCLASS_AUDIO_SOURCE)) {
num_snks++;
+ }
- if((p_scb->sep_info[i].tsep == AVDT_TSEP_SRC) &&
- (uuid_int == UUID_SERVCLASS_AUDIO_SINK))
+ if ((p_scb->sep_info[i].tsep == AVDT_TSEP_SRC) &&
+ (uuid_int == UUID_SERVCLASS_AUDIO_SINK)) {
num_srcs++;
+ }
}
}
p_scb->p_cos->disc_res(p_scb->hndl, p_scb->num_seps, num_snks, num_srcs, p_scb->peer_addr,
- uuid_int);
+ uuid_int);
p_scb->num_disc_snks = num_snks;
p_scb->num_disc_srcs = num_srcs;
/* if we got any */
- if (p_scb->num_seps > 0)
- {
+ if (p_scb->num_seps > 0) {
/* initialize index into discovery results */
p_scb->sep_info_idx = 0;
bta_av_next_getcap(p_scb, p_data);
}
/* else we got discover response but with no streams; we're done */
- else
- {
+ else {
bta_av_ssm_execute(p_scb, BTA_AV_STR_DISC_FAIL_EVT, p_data);
}
}
- for (i = 0; i < p_scb->num_seps; i++)
- {
+ for (i = 0; i < p_scb->num_seps; i++) {
/* steam is a sink, and is audio */
if ((p_scb->sep_info[i].tsep == AVDT_TSEP_SNK) &&
- (p_scb->sep_info[i].media_type == p_scb->media_type))
- {
+ (p_scb->sep_info[i].media_type == p_scb->media_type)) {
p_scb->sep_info[i].in_use = FALSE;
num_snks++;
}
}
p_scb->p_cos->disc_res(p_scb->hndl, p_scb->num_seps, num_snks, 0, p_scb->peer_addr,
- UUID_SERVCLASS_AUDIO_SOURCE);
+ UUID_SERVCLASS_AUDIO_SOURCE);
p_scb->num_disc_snks = num_snks;
p_scb->num_disc_srcs = 0;
/* if we got any */
- if (p_scb->num_seps > 0)
- {
+ if (p_scb->num_seps > 0) {
/* initialize index into discovery results */
p_scb->sep_info_idx = 0;
bta_av_next_getcap(p_scb, p_data);
}
/* else we got discover response but with no streams; we're done */
- else
- {
+ else {
bta_av_ssm_execute(p_scb, BTA_AV_STR_DISC_FAIL_EVT, p_data);
}
}
BOOLEAN getcap_done = FALSE;
APPL_TRACE_DEBUG("bta_av_save_caps num_seps:%d sep_info_idx:%d wait:x%x",
- p_scb->num_seps, p_scb->sep_info_idx, p_scb->wait);
+ p_scb->num_seps, p_scb->sep_info_idx, p_scb->wait);
memcpy(&cfg, p_scb->p_cap, sizeof(tAVDT_CFG));
/* let application know the capability of the SNK */
p_scb->p_cos->getcfg(p_scb->hndl, cfg.codec_info[BTA_AV_CODEC_TYPE_IDX],
- cfg.codec_info, &p_scb->sep_info_idx, p_info->seid,
- &cfg.num_protect, cfg.protect_info);
+ cfg.codec_info, &p_scb->sep_info_idx, p_info->seid,
+ &cfg.num_protect, cfg.protect_info);
p_scb->sep_info_idx++;
- if(p_scb->num_seps > p_scb->sep_info_idx)
- {
+ if (p_scb->num_seps > p_scb->sep_info_idx) {
/* Some devices have seps at the end of the discover list, which is not */
/* matching media type(video not audio). */
/* In this case, we are done with getcap without sending another */
/* request to AVDT. */
- if (!bta_av_next_getcap(p_scb, p_data))
+ if (!bta_av_next_getcap(p_scb, p_data)) {
getcap_done = TRUE;
- }
- else
+ }
+ } else {
getcap_done = TRUE;
+ }
- if (getcap_done)
- {
+ if (getcap_done) {
/* we are done getting capabilities. restore the p_cb->sep_info_idx */
p_scb->sep_info_idx = 0;
- p_scb->wait &= ~(BTA_AV_WAIT_ACP_CAPS_ON|BTA_AV_WAIT_ACP_CAPS_STARTED);
- if (old_wait & BTA_AV_WAIT_ACP_CAPS_STARTED)
- {
+ p_scb->wait &= ~(BTA_AV_WAIT_ACP_CAPS_ON | BTA_AV_WAIT_ACP_CAPS_STARTED);
+ if (old_wait & BTA_AV_WAIT_ACP_CAPS_STARTED) {
bta_av_start_ok (p_scb, NULL);
}
}
{
BOOLEAN is_av_opened = FALSE;
- tBTA_AV_SCB * p_opened_scb = NULL;
+ tBTA_AV_SCB *p_opened_scb = NULL;
UINT8 idx;
tBTA_AV_OPEN open;
bta_av_cco_close(p_scb, p_data);
/* check whether there is already an opened audio or video connection with the same device */
- for (idx = 0; (idx < BTA_AV_NUM_STRS) && (is_av_opened == FALSE); idx++ )
- {
+ for (idx = 0; (idx < BTA_AV_NUM_STRS) && (is_av_opened == FALSE); idx++ ) {
p_opened_scb = bta_av_cb.p_scb[idx];
- if (p_opened_scb && (p_opened_scb->state == BTA_AV_OPEN_SST) && (!bdcmp(p_opened_scb->peer_addr,p_scb->peer_addr )) )
+ if (p_opened_scb && (p_opened_scb->state == BTA_AV_OPEN_SST) && (!bdcmp(p_opened_scb->peer_addr, p_scb->peer_addr )) ) {
is_av_opened = TRUE;
+ }
}
/* if there is already an active AV connnection with the same bd_addr,
don't send disconnect req, just report the open event with BTA_AV_FAIL_GET_CAP status */
- if (is_av_opened == TRUE)
- {
+ if (is_av_opened == TRUE) {
bdcpy(open.bd_addr, p_scb->peer_addr);
open.chnl = p_scb->chnl;
open.hndl = p_scb->hndl;
/* set the state back to initial state */
bta_av_set_scb_sst_init(p_scb);
- if (p_scb->seps[p_scb->sep_idx].tsep == AVDT_TSEP_SRC )
+ if (p_scb->seps[p_scb->sep_idx].tsep == AVDT_TSEP_SRC ) {
open.sep = AVDT_TSEP_SNK;
- else if (p_scb->seps[p_scb->sep_idx].tsep == AVDT_TSEP_SNK )
+ } else if (p_scb->seps[p_scb->sep_idx].tsep == AVDT_TSEP_SNK ) {
open.sep = AVDT_TSEP_SRC;
+ }
(*bta_av_cb.p_cback)(BTA_AV_OPEN_EVT, (tBTA_AV *) &open);
- }
- else
- {
+ } else {
AVDT_DisconnectReq(p_scb->peer_addr, bta_av_dt_cback[p_scb->hdi]);
}
}
/* if codec present and we get a codec configuration */
if ((p_scb->p_cap->num_codec != 0) &&
- (media_type == p_scb->media_type) &&
- (p_scb->p_cos->getcfg(p_scb->hndl, p_scb->p_cap->codec_info[BTA_AV_CODEC_TYPE_IDX],
- cfg.codec_info, &p_scb->sep_info_idx, p_info->seid,
- &cfg.num_protect, cfg.protect_info) == 0))
- {
+ (media_type == p_scb->media_type) &&
+ (p_scb->p_cos->getcfg(p_scb->hndl, p_scb->p_cap->codec_info[BTA_AV_CODEC_TYPE_IDX],
+ cfg.codec_info, &p_scb->sep_info_idx, p_info->seid,
+ &cfg.num_protect, cfg.protect_info) == 0)) {
#if AVDT_MULTIPLEXING == TRUE
cfg.mux_mask &= p_scb->p_cap->mux_mask;
APPL_TRACE_DEBUG("mux_mask used x%x", cfg.mux_mask);
uuid_int = p_scb->uuid_int;
APPL_TRACE_DEBUG(" initiator UUID = 0x%x ", uuid_int);
- if (uuid_int == UUID_SERVCLASS_AUDIO_SOURCE)
+ if (uuid_int == UUID_SERVCLASS_AUDIO_SOURCE) {
bta_av_adjust_seps_idx(p_scb, bta_av_get_scb_handle(p_scb, AVDT_TSEP_SRC));
- else if (uuid_int == UUID_SERVCLASS_AUDIO_SINK)
+ } else if (uuid_int == UUID_SERVCLASS_AUDIO_SINK) {
bta_av_adjust_seps_idx(p_scb, bta_av_get_scb_handle(p_scb, AVDT_TSEP_SNK));
+ }
/* use only the services peer supports */
cfg.psc_mask &= p_scb->p_cap->psc_mask;
p_scb->cur_psc_mask = cfg.psc_mask;
if ((uuid_int == UUID_SERVCLASS_AUDIO_SINK) &&
- (p_scb->seps[p_scb->sep_idx].p_app_data_cback != NULL))
- {
+ (p_scb->seps[p_scb->sep_idx].p_app_data_cback != NULL)) {
APPL_TRACE_DEBUG(" Configure Deoder for Sink Connection ");
p_scb->seps[p_scb->sep_idx].p_app_data_cback(BTA_AV_MEDIA_SINK_CFG_EVT,
- (tBTA_AV_MEDIA*)p_scb->cfg.codec_info);
+ (tBTA_AV_MEDIA *)p_scb->cfg.codec_info);
}
/* open the stream */
AVDT_OpenReq(p_scb->seps[p_scb->sep_idx].av_handle, p_scb->peer_addr,
p_scb->sep_info[p_scb->sep_info_idx].seid, &cfg);
- if (!bta_av_is_rcfg_sst(p_scb))
- {
+ if (!bta_av_is_rcfg_sst(p_scb)) {
/* free capabilities buffer */
utl_freebuf((void **) &p_scb->p_cap);
}
- }
- else
- {
+ } else {
/* try the next stream, if any */
p_scb->sep_info_idx++;
bta_av_next_getcap(p_scb, p_data);
UINT8 avdt_handle = p_data->ci_setconfig.avdt_handle;
bta_av_adjust_seps_idx(p_scb, avdt_handle);
- APPL_TRACE_DEBUG("bta_av_setconfig_rej: sep_idx: %d",p_scb->sep_idx);
+ APPL_TRACE_DEBUG("bta_av_setconfig_rej: sep_idx: %d", p_scb->sep_idx);
AVDT_ConfigRsp(p_scb->avdt_handle, p_scb->avdt_label, AVDT_ERR_UNSUP_CFG, 0);
bdcpy(reject.bd_addr, p_data->str_msg.bd_addr);
UINT8 cur_role;
APPL_TRACE_DEBUG("bta_av_do_start sco_occupied:%d, role:x%x, started:%d", bta_av_cb.sco_occupied, p_scb->role, p_scb->started);
- if (bta_av_cb.sco_occupied)
- {
+ if (bta_av_cb.sco_occupied) {
bta_av_start_failed(p_scb, p_data);
return;
}
* i.e. allow role switch, if we are slave.
* It would not hurt us, if the peer device wants us to be master */
if ((BTM_GetRole (p_scb->peer_addr, &cur_role) == BTM_SUCCESS) &&
- (cur_role == BTM_ROLE_MASTER) )
- {
+ (cur_role == BTM_ROLE_MASTER) ) {
policy |= HCI_ENABLE_MASTER_SLAVE_SWITCH;
}
bta_sys_clear_policy(BTA_ID_AV, policy, p_scb->peer_addr);
- if ((p_scb->started == FALSE) && ((p_scb->role & BTA_AV_ROLE_START_INT) == 0))
- {
+ if ((p_scb->started == FALSE) && ((p_scb->role & BTA_AV_ROLE_START_INT) == 0)) {
p_scb->role |= BTA_AV_ROLE_START_INT;
bta_sys_busy(BTA_ID_AV, bta_av_cb.audio_open_cnt, p_scb->peer_addr);
AVDT_StartReq(&p_scb->avdt_handle, 1);
- }
- else if (p_scb->started)
- {
+ } else if (p_scb->started) {
p_scb->role |= BTA_AV_ROLE_START_INT;
if ( p_scb->wait == 0 ) {
if (p_scb->role & BTA_AV_ROLE_SUSPEND) {
UINT8 policy = HCI_ENABLE_SNIFF_MODE;
APPL_TRACE_ERROR("bta_av_str_stopped:audio_open_cnt=%d, p_data %p",
- bta_av_cb.audio_open_cnt, p_data);
+ bta_av_cb.audio_open_cnt, p_data);
bta_sys_idle(BTA_ID_AV, bta_av_cb.audio_open_cnt, p_scb->peer_addr);
- if ((bta_av_cb.features & BTA_AV_FEAT_MASTER) == 0 || bta_av_cb.audio_open_cnt == 1)
+ if ((bta_av_cb.features & BTA_AV_FEAT_MASTER) == 0 || bta_av_cb.audio_open_cnt == 1) {
policy |= HCI_ENABLE_MASTER_SLAVE_SWITCH;
+ }
bta_sys_set_policy(BTA_ID_AV, policy, p_scb->peer_addr);
- if (p_scb->co_started)
- {
+ if (p_scb->co_started) {
bta_av_stream_chg(p_scb, FALSE);
p_scb->co_started = FALSE;
/* if q_info.a2d_list is not empty, drop it now */
if (BTA_AV_CHNL_AUDIO == p_scb->chnl) {
- while (!list_is_empty(p_scb->a2d_list))
- {
+ while (!list_is_empty(p_scb->a2d_list)) {
p_buf = (BT_HDR *)list_front(p_scb->a2d_list);
list_remove(p_scb->a2d_list, p_buf);
GKI_freebuf(p_buf);
}
- /* drop the audio buffers queued in L2CAP */
- if (p_data && p_data->api_stop.flush)
+ /* drop the audio buffers queued in L2CAP */
+ if (p_data && p_data->api_stop.flush) {
L2CA_FlushChannel (p_scb->l2c_cid, L2CAP_FLUSH_CHANS_ALL);
+ }
}
suspend_rsp.chnl = p_scb->chnl;
suspend_rsp.hndl = p_scb->hndl;
- if (p_data && p_data->api_stop.suspend)
- {
+ if (p_data && p_data->api_stop.suspend) {
APPL_TRACE_DEBUG("suspending: %d, sup:%d", start, p_scb->suspend_sup);
- if ((start) && (p_scb->suspend_sup))
- {
+ if ((start) && (p_scb->suspend_sup)) {
sus_evt = FALSE;
p_scb->l2c_bufs = 0;
AVDT_SuspendReq(&p_scb->avdt_handle, 1);
}
/* send SUSPEND_EVT event only if not in reconfiguring state and sus_evt is TRUE*/
- if ((sus_evt)&&(p_scb->state != BTA_AV_RCFG_SST))
- {
+ if ((sus_evt) && (p_scb->state != BTA_AV_RCFG_SST)) {
suspend_rsp.status = BTA_AV_SUCCESS;
suspend_rsp.initiator = TRUE;
(*bta_av_cb.p_cback)(BTA_AV_SUSPEND_EVT, (tBTA_AV *) &suspend_rsp);
}
- }
- else
- {
+ } else {
suspend_rsp.status = BTA_AV_SUCCESS;
suspend_rsp.initiator = TRUE;
APPL_TRACE_EVENT("bta_av_str_stopped status %d", suspend_rsp.status);
/* send STOP_EVT event only if not in reconfiguring state */
- if (p_scb->state != BTA_AV_RCFG_SST)
- {
+ if (p_scb->state != BTA_AV_RCFG_SST) {
(*bta_av_cb.p_cback)(BTA_AV_STOP_EVT, (tBTA_AV *) &suspend_rsp);
}
}
tBTA_AV_API_RCFG *p_rcfg = &p_data->api_reconfig;
APPL_TRACE_DEBUG("bta_av_reconfig r:%d, s:%d idx: %d (o:%d)",
- p_scb->recfg_sup, p_scb->suspend_sup,
- p_scb->rcfg_idx, p_scb->sep_info_idx);
+ p_scb->recfg_sup, p_scb->suspend_sup,
+ p_scb->rcfg_idx, p_scb->sep_info_idx);
p_scb->num_recfg = 0;
/* store the new configuration in control block */
- if (p_scb->p_cap == NULL)
- {
+ if (p_scb->p_cap == NULL) {
p_scb->p_cap = (tAVDT_CFG *) GKI_getbuf(sizeof(tAVDT_CFG));
}
- if((p_cfg = p_scb->p_cap) == NULL)
- {
+ if ((p_cfg = p_scb->p_cap) == NULL) {
/* report failure */
evt.status = BTA_AV_FAIL_RESOURCES;
evt.chnl = p_scb->chnl;
}
/*if(bta_av_cb.features & BTA_AV_FEAT_RCCT)*/
- bta_sys_stop_timer(&p_scb->timer);
+ bta_sys_stop_timer(&p_scb->timer);
memcpy(p_cfg, &p_scb->cfg, sizeof(tAVDT_CFG));
p_cfg->num_protect = p_rcfg->num_protect;
/* if the requested index differs from the current one, we can only close/open */
if ((p_scb->rcfg_idx == p_scb->sep_info_idx) &&
- (p_rcfg->suspend)&& (p_scb->recfg_sup) && (p_scb->suspend_sup))
- {
- if(p_scb->started)
- {
+ (p_rcfg->suspend) && (p_scb->recfg_sup) && (p_scb->suspend_sup)) {
+ if (p_scb->started) {
stop.flush = FALSE;
stop.suspend = TRUE;
bta_av_str_stopped(p_scb, (tBTA_AV_DATA *)&stop);
- }
- else
- {
+ } else {
APPL_TRACE_DEBUG("Reconfig");
AVDT_ReconfigReq(p_scb->avdt_handle, p_scb->p_cap);
p_scb->p_cap->psc_mask = p_scb->cur_psc_mask;
}
- }
- else
- {
+ } else {
/* close the stream */
APPL_TRACE_DEBUG("close/open num_protect: %d", p_cfg->num_protect);
- if(p_scb->started)
- {
+ if (p_scb->started) {
bta_av_str_stopped(p_scb, NULL);
p_scb->started = FALSE;
tAVDT_DATA_OPT_MASK opt;
UNUSED(p_data);
- if (p_scb->cong)
- {
+ if (p_scb->cong) {
return;
}
if (!list_is_empty(p_scb->a2d_list)) {
p_buf = (BT_HDR *)list_front(p_scb->a2d_list);
list_remove(p_scb->a2d_list, p_buf);
- /* use q_info.a2d data, read the timestamp */
+ /* use q_info.a2d data, read the timestamp */
timestamp = *(UINT32 *)(p_buf + 1);
- }
- else
- {
+ } else {
new_buf = TRUE;
/* a2d_list empty, call co_data, dup data to other channels */
p_buf = (BT_HDR *)p_scb->p_cos->data(p_scb->codec_type, &data_len,
- ×tamp);
+ ×tamp);
- if (p_buf)
- {
+ if (p_buf) {
/* use the offset area for the time stamp */
*(UINT32 *)(p_buf + 1) = timestamp;
}
}
- if(p_buf)
- {
- if(p_scb->l2c_bufs < (BTA_AV_QUEUE_DATA_CHK_NUM))
- {
+ if (p_buf) {
+ if (p_scb->l2c_bufs < (BTA_AV_QUEUE_DATA_CHK_NUM)) {
/* there's a buffer, just queue it to L2CAP */
/* There's no need to increment it here, it is always read from L2CAP see above */
/* p_scb->l2c_bufs++; */
/* opt is a bit mask, it could have several options set */
opt = AVDT_DATA_OPT_NONE;
- if (p_scb->no_rtp_hdr)
- {
+ if (p_scb->no_rtp_hdr) {
opt |= AVDT_DATA_OPT_NO_RTP;
}
AVDT_WriteReqOpt(p_scb->avdt_handle, p_buf, timestamp, m_pt, opt);
p_scb->cong = TRUE;
- }
- else
- {
+ } else {
/* there's a buffer, but L2CAP does not seem to be moving data */
- if(new_buf)
- {
+ if (new_buf) {
/* just got this buffer from co_data,
* put it in queue */
list_append(p_scb->a2d_list, p_buf);
- }
- else
- {
+ } else {
/* just dequeue it from the a2d_list */
if (list_length(p_scb->a2d_list) < 3) {
/* put it back to the queue */
list_prepend(p_scb->a2d_list, p_buf);
- }
- else
- {
+ } else {
/* too many buffers in a2d_list, drop it. */
bta_av_co_audio_drop(p_scb->hndl);
GKI_freebuf(p_buf);
APPL_TRACE_DEBUG("bta_av_start_ok wait:x%x, role:x%x", p_scb->wait, p_scb->role);
p_scb->started = TRUE;
- if (p_scb->sco_suspend)
- {
+ if (p_scb->sco_suspend) {
p_scb->sco_suspend = FALSE;
}
- if (new_role & BTA_AV_ROLE_START_INT)
+ if (new_role & BTA_AV_ROLE_START_INT) {
initiator = TRUE;
+ }
/* for A2DP SINK we do not send get_caps */
if ((p_scb->avdt_handle == p_scb->seps[p_scb->sep_idx].av_handle)
- &&(p_scb->seps[p_scb->sep_idx].tsep == AVDT_TSEP_SNK))
- {
+ && (p_scb->seps[p_scb->sep_idx].tsep == AVDT_TSEP_SNK)) {
p_scb->wait &= ~(BTA_AV_WAIT_ACP_CAPS_ON);
- APPL_TRACE_DEBUG(" Local SEP type is SNK new wait is 0x%x",p_scb->wait);
+ APPL_TRACE_DEBUG(" Local SEP type is SNK new wait is 0x%x", p_scb->wait);
}
- if (p_scb->wait & BTA_AV_WAIT_ROLE_SW_FAILED)
- {
+ if (p_scb->wait & BTA_AV_WAIT_ROLE_SW_FAILED) {
/* role switch has failed */
p_scb->wait &= ~BTA_AV_WAIT_ROLE_SW_FAILED;
p_data = (tBTA_AV_DATA *)&hdr;
}
APPL_TRACE_DEBUG("wait:x%x", p_scb->wait);
- if (p_data && (p_data->hdr.offset != BTA_AV_RS_NONE))
- {
+ if (p_data && (p_data->hdr.offset != BTA_AV_RS_NONE)) {
p_scb->wait &= ~BTA_AV_WAIT_ROLE_SW_BITS;
- if (p_data->hdr.offset == BTA_AV_RS_FAIL)
- {
+ if (p_data->hdr.offset == BTA_AV_RS_FAIL) {
bta_sys_idle(BTA_ID_AV, bta_av_cb.audio_open_cnt, p_scb->peer_addr);
start.chnl = p_scb->chnl;
start.status = BTA_AV_FAIL_ROLE;
}
}
- if (!bta_av_link_role_ok(p_scb, A2D_SET_ONE_BIT))
+ if (!bta_av_link_role_ok(p_scb, A2D_SET_ONE_BIT)) {
p_scb->q_tag = BTA_AV_Q_TAG_START;
- else
- {
+ } else {
/* The wait flag may be set here while we are already master on the link */
/* this could happen if a role switch complete event occurred during reconfig */
/* if we are now master on the link, there is no need to wait for the role switch, */
p_scb->wait &= ~BTA_AV_WAIT_ROLE_SW_BITS;
}
- if (p_scb->wait & (BTA_AV_WAIT_ROLE_SW_RES_OPEN|BTA_AV_WAIT_ROLE_SW_RES_START))
- {
+ if (p_scb->wait & (BTA_AV_WAIT_ROLE_SW_RES_OPEN | BTA_AV_WAIT_ROLE_SW_RES_START)) {
p_scb->wait |= BTA_AV_WAIT_ROLE_SW_STARTED;
p_scb->q_tag = BTA_AV_Q_TAG_START;
}
- if (p_scb->wait)
- {
+ if (p_scb->wait) {
APPL_TRACE_ERROR("wait:x%x q_tag:%d- not started", p_scb->wait, p_scb->q_tag);
/* Clear first bit of p_scb->wait and not to return from this point else
* HAL layer gets blocked. And if there is delay in Get Capability response as
bta_sys_busy(BTA_ID_AV, bta_av_cb.audio_open_cnt, p_scb->peer_addr);
- if(p_scb->media_type == AVDT_MEDIA_AUDIO)
- {
+ if (p_scb->media_type == AVDT_MEDIA_AUDIO) {
/* in normal logic, conns should be bta_av_cb.audio_count - 1,
* However, bta_av_stream_chg is not called to increase bta_av_cb.audio_count yet.
* If the code were to be re-arranged for some reasons, this number may need to be changed
*/
p_scb->co_started = bta_av_cb.audio_open_cnt;
flush_to = p_bta_av_cfg->p_audio_flush_to[p_scb->co_started - 1];
- }
- else
- {
+ } else {
flush_to = p_bta_av_cfg->video_flush_to;
}
L2CA_SetFlushTimeout(p_scb->peer_addr, flush_to );
/* clear the congestion flag */
p_scb->cong = FALSE;
- if (new_role & BTA_AV_ROLE_START_INT)
- {
+ if (new_role & BTA_AV_ROLE_START_INT) {
new_role &= ~BTA_AV_ROLE_START_INT;
- }
- else if ((new_role & BTA_AV_ROLE_AD_ACP) && (new_role & BTA_AV_ROLE_SUSPEND_OPT))
- {
+ } else if ((new_role & BTA_AV_ROLE_AD_ACP) && (new_role & BTA_AV_ROLE_SUSPEND_OPT)) {
suspend = TRUE;
}
- if (!suspend)
- {
+ if (!suspend) {
p_scb->q_tag = BTA_AV_Q_TAG_STREAM;
bta_av_stream_chg(p_scb, TRUE);
}
{
/* If sink starts stream, disable sniff mode here */
- if (!initiator)
- {
- /* If souce is the master role, disable role switch during streaming.
- * Otherwise allow role switch, if source is slave.
- * Because it would not hurt source, if the peer device wants source to be master */
+ if (!initiator) {
+ /* If souce is the master role, disable role switch during streaming.
+ * Otherwise allow role switch, if source is slave.
+ * Because it would not hurt source, if the peer device wants source to be master */
if ((BTM_GetRole (p_scb->peer_addr, &cur_role) == BTM_SUCCESS) &&
- (cur_role == BTM_ROLE_MASTER) )
- {
+ (cur_role == BTM_ROLE_MASTER) ) {
policy |= HCI_ENABLE_MASTER_SLAVE_SWITCH;
}
p_scb->co_started = TRUE;
APPL_TRACE_DEBUG("bta_av_start_ok suspending: %d, role:x%x, init %d",
- suspend, p_scb->role, initiator);
+ suspend, p_scb->role, initiator);
start.suspending = suspend;
start.initiator = initiator;
start.hndl = p_scb->hndl;
(*bta_av_cb.p_cback)(BTA_AV_START_EVT, (tBTA_AV *) &start);
- if(suspend)
- {
+ if (suspend) {
p_scb->role |= BTA_AV_ROLE_SUSPEND;
p_scb->cong = TRUE; /* do not allow the media data to go through */
/* do not duplicate the media packets to this channel */
{
UNUSED(p_data);
- if(p_scb->started == FALSE && p_scb->co_started == FALSE)
- {
+ if (p_scb->started == FALSE && p_scb->co_started == FALSE) {
bta_sys_idle(BTA_ID_AV, bta_av_cb.audio_open_cnt, p_scb->peer_addr);
notify_start_failed(p_scb);
}
- bta_sys_set_policy(BTA_ID_AV, (HCI_ENABLE_SNIFF_MODE|HCI_ENABLE_MASTER_SLAVE_SWITCH), p_scb->peer_addr);
+ bta_sys_set_policy(BTA_ID_AV, (HCI_ENABLE_SNIFF_MODE | HCI_ENABLE_MASTER_SLAVE_SWITCH), p_scb->peer_addr);
p_scb->sco_suspend = FALSE;
}
UINT16 mtu;
UINT8 policy = HCI_ENABLE_SNIFF_MODE;
- if ((bta_av_cb.features & BTA_AV_FEAT_MASTER) == 0 || bta_av_cb.audio_open_cnt == 1)
+ if ((bta_av_cb.features & BTA_AV_FEAT_MASTER) == 0 || bta_av_cb.audio_open_cnt == 1) {
policy |= HCI_ENABLE_MASTER_SLAVE_SWITCH;
+ }
bta_sys_set_policy(BTA_ID_AV, policy, p_scb->peer_addr);
- if (bta_av_cb.audio_open_cnt <= 1)
- {
+ if (bta_av_cb.audio_open_cnt <= 1) {
/* last connection - restore the allow switch flag */
L2CA_SetDesireRole(L2CAP_ROLE_ALLOW_SWITCH);
}
- if (p_scb->open_status)
- {
+ if (p_scb->open_status) {
/* must be failure when opening the stream */
bdcpy(data.open.bd_addr, p_scb->peer_addr);
data.open.status = p_scb->open_status;
data.open.chnl = p_scb->chnl;
data.open.hndl = p_scb->hndl;
- if (p_scb->seps[p_scb->sep_idx].tsep == AVDT_TSEP_SRC )
+ if (p_scb->seps[p_scb->sep_idx].tsep == AVDT_TSEP_SRC ) {
data.open.sep = AVDT_TSEP_SNK;
- else if (p_scb->seps[p_scb->sep_idx].tsep == AVDT_TSEP_SNK )
+ } else if (p_scb->seps[p_scb->sep_idx].tsep == AVDT_TSEP_SNK ) {
data.open.sep = AVDT_TSEP_SRC;
+ }
event = BTA_AV_OPEN_EVT;
p_scb->open_status = BTA_AV_SUCCESS;
bta_sys_conn_close(BTA_ID_AV, p_scb->app_id, p_scb->peer_addr);
bta_av_cleanup(p_scb, p_data);
(*bta_av_cb.p_cback)(event, &data);
- }
- else
- {
+ } else {
/* do stop if we were started */
- if (p_scb->co_started)
- {
+ if (p_scb->co_started) {
bta_av_str_stopped(p_scb, NULL);
}
{
UNUSED(p_data);
- if(p_scb->co_started)
+ if (p_scb->co_started) {
p_scb->cong = FALSE;
+ }
}
/*******************************************************************************
UINT8 policy = HCI_ENABLE_SNIFF_MODE;
APPL_TRACE_DEBUG ("bta_av_suspend_cfm:audio_open_cnt = %d, err_code = %d",
- bta_av_cb.audio_open_cnt, err_code);
+ bta_av_cb.audio_open_cnt, err_code);
- if (p_scb->started == FALSE)
- {
+ if (p_scb->started == FALSE) {
/* handle the condition where there is a collision of SUSPEND req from either side
** Second SUSPEND req could be rejected. Do not treat this as a failure
*/
APPL_TRACE_WARNING("bta_av_suspend_cfm: already suspended, ignore, err_code %d",
- err_code);
+ err_code);
return;
}
suspend_rsp.status = BTA_AV_SUCCESS;
- if (err_code && (err_code != AVDT_ERR_BAD_STATE))
- {
- /* Disable suspend feature only with explicit rejection(not with timeout) */
- if (err_code != AVDT_ERR_TIMEOUT)
- {
+ if (err_code && (err_code != AVDT_ERR_BAD_STATE)) {
+ /* Disable suspend feature only with explicit rejection(not with timeout) */
+ if (err_code != AVDT_ERR_TIMEOUT) {
p_scb->suspend_sup = FALSE;
}
suspend_rsp.status = BTA_AV_FAIL;
/* SUSPEND failed. Close connection. */
bta_av_ssm_execute(p_scb, BTA_AV_API_CLOSE_EVT, NULL);
- }
- else
- {
+ } else {
/* only set started to FALSE when suspend is successful */
p_scb->started = FALSE;
}
- if (p_scb->role & BTA_AV_ROLE_SUSPEND)
- {
+ if (p_scb->role & BTA_AV_ROLE_SUSPEND) {
p_scb->role &= ~BTA_AV_ROLE_SUSPEND;
p_scb->cong = FALSE;
}
bta_sys_idle(BTA_ID_AV, bta_av_cb.audio_open_cnt, p_scb->peer_addr);
- if ((bta_av_cb.features & BTA_AV_FEAT_MASTER) == 0 || bta_av_cb.audio_open_cnt == 1)
+ if ((bta_av_cb.features & BTA_AV_FEAT_MASTER) == 0 || bta_av_cb.audio_open_cnt == 1) {
policy |= HCI_ENABLE_MASTER_SLAVE_SWITCH;
+ }
bta_sys_set_policy(BTA_ID_AV, policy, p_scb->peer_addr);
/* in case that we received suspend_ind, we may need to call co_stop here */
- if(p_scb->co_started)
- {
+ if (p_scb->co_started) {
bta_av_stream_chg(p_scb, FALSE);
{
tBTA_AV_RECONFIG evt;
APPL_TRACE_DEBUG("bta_av_rcfg_failed num_recfg: %d, conn_lcb:0x%x",
- p_scb->num_recfg, bta_av_cb.conn_lcb);
- if(p_scb->num_recfg > BTA_AV_RECONFIG_RETRY)
- {
+ p_scb->num_recfg, bta_av_cb.conn_lcb);
+ if (p_scb->num_recfg > BTA_AV_RECONFIG_RETRY) {
bta_av_cco_close(p_scb, p_data);
/* report failure */
evt.status = BTA_AV_FAIL_STREAM;
(*bta_av_cb.p_cback)(BTA_AV_RECONFIG_EVT, (tBTA_AV *)&evt);
/* go to closing state */
bta_av_ssm_execute(p_scb, BTA_AV_API_CLOSE_EVT, NULL);
- }
- else
- {
+ } else {
/* open failed. try again */
p_scb->num_recfg++;
- if(bta_av_cb.conn_lcb)
- {
+ if (bta_av_cb.conn_lcb) {
AVDT_DisconnectReq(p_scb->peer_addr, bta_av_dt_cback[p_scb->hdi]);
- }
- else
- {
+ } else {
bta_av_connect_req(p_scb, NULL);
}
}
p_scb->cong = FALSE;
p_scb->num_recfg++;
APPL_TRACE_DEBUG("bta_av_rcfg_connect num_recfg: %d", p_scb->num_recfg);
- if(p_scb->num_recfg > BTA_AV_RECONFIG_RETRY)
- {
+ if (p_scb->num_recfg > BTA_AV_RECONFIG_RETRY) {
/* let bta_av_rcfg_failed report fail */
bta_av_rcfg_failed(p_scb, NULL);
- }
- else
+ } else {
AVDT_ConnectReq(p_scb->peer_addr, p_scb->sec_mask, bta_av_dt_cback[p_scb->hdi]);
+ }
}
/*******************************************************************************
APPL_TRACE_DEBUG("bta_av_rcfg_discntd num_recfg: %d", p_scb->num_recfg);
p_scb->num_recfg++;
- if(p_scb->num_recfg > BTA_AV_RECONFIG_RETRY)
- {
+ if (p_scb->num_recfg > BTA_AV_RECONFIG_RETRY) {
/* report failure */
evt.status = BTA_AV_FAIL_STREAM;
evt.chnl = p_scb->chnl;
(*bta_av_cb.p_cback)(BTA_AV_RECONFIG_EVT, (tBTA_AV *)&evt);
/* report close event & go to init state */
bta_av_ssm_execute(p_scb, BTA_AV_STR_DISC_FAIL_EVT, NULL);
- }
- else
+ } else {
AVDT_ConnectReq(p_scb->peer_addr, p_scb->sec_mask, bta_av_dt_cback[p_scb->hdi]);
+ }
}
/*******************************************************************************
p_scb->started = FALSE;
p_scb->cong = FALSE;
- if (err_code)
- {
- if (AVDT_ERR_CONNECT == err_code)
- {
+ if (err_code) {
+ if (AVDT_ERR_CONNECT == err_code) {
/* report failure */
evt.status = BTA_AV_FAIL;
(*bta_av_cb.p_cback)(BTA_AV_RECONFIG_EVT, (tBTA_AV *)&evt);
bta_av_ssm_execute(p_scb, BTA_AV_STR_DISC_FAIL_EVT, NULL);
- }
- else
- {
+ } else {
APPL_TRACE_ERROR("suspend rejected, try close");
- /* Disable suspend feature only with explicit rejection(not with timeout) */
- if (err_code != AVDT_ERR_TIMEOUT)
- {
+ /* Disable suspend feature only with explicit rejection(not with timeout) */
+ if (err_code != AVDT_ERR_TIMEOUT) {
p_scb->suspend_sup = FALSE;
}
/* drop the buffers queued in L2CAP */
AVDT_CloseReq(p_scb->avdt_handle);
}
- }
- else
- {
+ } else {
APPL_TRACE_DEBUG("bta_av_suspend_cont calling AVDT_ReconfigReq");
/* reconfig the stream */
/*
APPL_TRACE_DEBUG("bta_av_rcfg_cfm");
*/
- if (err_code)
- {
+ if (err_code) {
APPL_TRACE_ERROR("reconfig rejected, try close");
- /* Disable reconfiguration feature only with explicit rejection(not with timeout) */
- if (err_code != AVDT_ERR_TIMEOUT)
- {
+ /* Disable reconfiguration feature only with explicit rejection(not with timeout) */
+ if (err_code != AVDT_ERR_TIMEOUT) {
p_scb->recfg_sup = FALSE;
}
/* started flag is FALSE when reconfigure command is sent */
/* drop the buffers queued in L2CAP */
L2CA_FlushChannel (p_scb->l2c_cid, L2CAP_FLUSH_CHANS_ALL);
AVDT_CloseReq(p_scb->avdt_handle);
- }
- else
- {
+ } else {
/* update the codec info after rcfg cfm */
- memcpy(p_scb->cfg.codec_info,p_data->str_msg.msg.reconfig_cfm.p_cfg->codec_info,AVDT_CODEC_SIZE);
+ memcpy(p_scb->cfg.codec_info, p_data->str_msg.msg.reconfig_cfm.p_cfg->codec_info, AVDT_CODEC_SIZE);
/* take the SSM back to OPEN state */
bta_av_ssm_execute(p_scb, BTA_AV_STR_OPEN_OK_EVT, NULL);
}
{
UNUSED(p_data);
- APPL_TRACE_DEBUG("bta_av_rcfg_open, num_disc_snks = %d", p_scb->num_disc_snks);
+ APPL_TRACE_DEBUG("bta_av_rcfg_open, num_disc_snks = %d", p_scb->num_disc_snks);
- if (p_scb->num_disc_snks == 0)
- {
+ if (p_scb->num_disc_snks == 0) {
/* Need to update call-out module so that it will be ready for discover */
p_scb->p_cos->stop(p_scb->hndl, p_scb->codec_type);
/* send avdtp discover request */
AVDT_DiscoverReq(p_scb->peer_addr, p_scb->sep_info, BTA_AV_NUM_SEPS, bta_av_dt_cback[p_scb->hdi]);
- }
- else
- {
+ } else {
p_scb->codec_type = p_scb->p_cap->codec_info[BTA_AV_CODEC_TYPE_IDX];
memcpy(p_scb->cfg.codec_info, p_scb->p_cap->codec_info, AVDT_CODEC_SIZE);
/* we may choose to use a different SEP at reconfig.
BOOLEAN new_started = FALSE;
UNUSED(p_data);
- if ((p_scb->chnl == BTA_AV_CHNL_AUDIO) && (bta_av_cb.audio_open_cnt >= 2))
- {
+ if ((p_scb->chnl == BTA_AV_CHNL_AUDIO) && (bta_av_cb.audio_open_cnt >= 2)) {
/* more than one audio channel is connected */
- if (!(p_scb->role & BTA_AV_ROLE_SUSPEND_OPT))
- {
+ if (!(p_scb->role & BTA_AV_ROLE_SUSPEND_OPT)) {
/* this channel does not need to be reconfigured.
* if there is other channel streaming, start the stream now */
- for(i=0; i<BTA_AV_NUM_STRS; i++)
- {
+ for (i = 0; i < BTA_AV_NUM_STRS; i++) {
p_scbi = bta_av_cb.p_scb[i];
- if(p_scbi && p_scbi->chnl == BTA_AV_CHNL_AUDIO && p_scbi->co_started)
- {
- if (!new_started)
- {
+ if (p_scbi && p_scbi->chnl == BTA_AV_CHNL_AUDIO && p_scbi->co_started) {
+ if (!new_started) {
/* start the new stream */
new_started = TRUE;
bta_av_ssm_execute(p_scb, BTA_AV_AP_START_EVT, NULL);
}
/* may need to update the flush timeout of this already started stream */
- if (p_scbi->co_started != bta_av_cb.audio_open_cnt)
- {
+ if (p_scbi->co_started != bta_av_cb.audio_open_cnt) {
p_scbi->co_started = bta_av_cb.audio_open_cnt;
L2CA_SetFlushTimeout(p_scbi->peer_addr, p_bta_av_cfg->p_audio_flush_to[p_scbi->co_started - 1] );
}
tBTA_AV_START start;
APPL_TRACE_DEBUG("bta_av_open_rc use_rc: %d, wait: x%x role:x%x", p_scb->use_rc, p_scb->wait, p_scb->role);
- if ((p_scb->wait & BTA_AV_WAIT_ROLE_SW_BITS) && (p_scb->q_tag == BTA_AV_Q_TAG_START))
- {
+ if ((p_scb->wait & BTA_AV_WAIT_ROLE_SW_BITS) && (p_scb->q_tag == BTA_AV_Q_TAG_START)) {
/* waiting for role switch for some reason & the timer expires */
- if (!bta_av_link_role_ok(p_scb, A2D_SET_ONE_BIT))
- {
+ if (!bta_av_link_role_ok(p_scb, A2D_SET_ONE_BIT)) {
APPL_TRACE_ERROR ("failed to start streaming for role management reasons!!");
bta_sys_stop_timer(&p_scb->timer);
start.chnl = p_scb->chnl;
p_scb->wait &= ~BTA_AV_WAIT_ROLE_SW_BITS;
bta_av_cb.rs_idx = 0;
(*bta_av_cb.p_cback)(BTA_AV_START_EVT, (tBTA_AV *) &start);
- }
- else
- {
+ } else {
/* role switch is done. continue to start streaming */
bta_av_cb.rs_idx = 0;
p_data->hdr.offset = BTA_AV_RS_OK;
return;
}
- if(p_scb->use_rc == TRUE || (p_scb->role & BTA_AV_ROLE_AD_ACP) )
- {
- if(bta_av_cb.disc)
- {
+ if (p_scb->use_rc == TRUE || (p_scb->role & BTA_AV_ROLE_AD_ACP) ) {
+ if (bta_av_cb.disc) {
/* AVRC discover db is in use */
- if(p_scb->rc_handle == BTA_AV_RC_HANDLE_NONE)
- {
+ if (p_scb->rc_handle == BTA_AV_RC_HANDLE_NONE) {
/* AVRC channel is not connected. delay a little bit */
- if ((p_scb->wait & BTA_AV_WAIT_ROLE_SW_BITS) == 0)
+ if ((p_scb->wait & BTA_AV_WAIT_ROLE_SW_BITS) == 0) {
bta_sys_start_timer(&p_scb->timer, BTA_AV_AVRC_TIMER_EVT, BTA_AV_RC_DISC_TIME_VAL);
- else
+ } else {
p_scb->wait |= BTA_AV_WAIT_CHECK_RC;
+ }
}
- }
- else
- {
+ } else {
/* use main SM for AVRC SDP activities */
bta_av_rc_disc((UINT8)(p_scb->hdi + 1));
}
- }
- else
- {
- if(BTA_AV_RC_HANDLE_NONE != p_scb->rc_handle)
- {
+ } else {
+ if (BTA_AV_RC_HANDLE_NONE != p_scb->rc_handle) {
/* the open API said that this handle does not want a RC connection.
* disconnect it now */
AVRC_Close(p_scb->rc_handle);
memcpy (&(p_scb->open_api), &(p_data->api_open), sizeof(tBTA_AV_API_OPEN));
- if (p_scb->coll_mask & BTA_AV_COLL_INC_TMR)
- {
+ if (p_scb->coll_mask & BTA_AV_COLL_INC_TMR) {
p_scb->coll_mask |= BTA_AV_COLL_API_CALLED;
/* API open will be handled at timeout if SNK did not start signalling. */
/* API open will be ignored if SNK starts signalling. */
- }
- else
- {
+ } else {
/* SNK did not start signalling, API was called N seconds timeout. */
/* We need to switch to INIT state and start opening connection. */
p_scb->coll_mask = 0;
bta_av_set_scb_sst_init (p_scb);
- if ((p_buf = (tBTA_AV_API_OPEN *) GKI_getbuf(sizeof(tBTA_AV_API_OPEN))) != NULL)
- {
+ if ((p_buf = (tBTA_AV_API_OPEN *) GKI_getbuf(sizeof(tBTA_AV_API_OPEN))) != NULL) {
memcpy(p_buf, &(p_scb->open_api), sizeof(tBTA_AV_API_OPEN));
bta_sys_sendmsg(p_buf);
}
** Returns tBTA_AV_RCB
**
*******************************************************************************/
-tBTA_AV_RCB * bta_av_get_rcb_by_shdl(UINT8 shdl)
+tBTA_AV_RCB *bta_av_get_rcb_by_shdl(UINT8 shdl)
{
tBTA_AV_RCB *p_rcb = NULL;
int i;
- for (i=0; i<BTA_AV_NUM_RCB; i++)
- {
- if (bta_av_cb.rcb[i].shdl == shdl && bta_av_cb.rcb[i].handle != BTA_AV_RC_HANDLE_NONE)
- {
+ for (i = 0; i < BTA_AV_NUM_RCB; i++) {
+ if (bta_av_cb.rcb[i].shdl == shdl && bta_av_cb.rcb[i].handle != BTA_AV_RC_HANDLE_NONE) {
p_rcb = &bta_av_cb.rcb[i];
break;
}
UINT8 rc_handle; /* connected AVRCP handle */
p_scb = NULL;
- if(p_rcb->handle != BTA_AV_RC_HANDLE_NONE)
- {
- if(p_rcb->shdl)
- {
+ if (p_rcb->handle != BTA_AV_RC_HANDLE_NONE) {
+ if (p_rcb->shdl) {
/* Validate array index*/
- if ((p_rcb->shdl - 1) < BTA_AV_NUM_STRS)
- {
+ if ((p_rcb->shdl - 1) < BTA_AV_NUM_STRS) {
p_scb = bta_av_cb.p_scb[p_rcb->shdl - 1];
}
- if(p_scb)
- {
+ if (p_scb) {
APPL_TRACE_DEBUG("bta_av_del_rc shdl:%d, srch:%d rc_handle:%d", p_rcb->shdl,
- p_scb->rc_handle, p_rcb->handle);
- if(p_scb->rc_handle == p_rcb->handle)
+ p_scb->rc_handle, p_rcb->handle);
+ if (p_scb->rc_handle == p_rcb->handle) {
p_scb->rc_handle = BTA_AV_RC_HANDLE_NONE;
+ }
/* just in case the RC timer is active
if(bta_av_cb.features & BTA_AV_FEAT_RCCT && p_scb->chnl == BTA_AV_CHNL_AUDIO) */
- bta_sys_stop_timer(&p_scb->timer);
+ bta_sys_stop_timer(&p_scb->timer);
}
}
APPL_TRACE_EVENT("bta_av_del_rc handle: %d status=0x%x, rc_acp_handle:%d, idx:%d",
- p_rcb->handle, p_rcb->status, bta_av_cb.rc_acp_handle, bta_av_cb.rc_acp_idx);
+ p_rcb->handle, p_rcb->status, bta_av_cb.rc_acp_handle, bta_av_cb.rc_acp_idx);
rc_handle = p_rcb->handle;
- if(!(p_rcb->status & BTA_AV_RC_CONN_MASK) ||
- ((p_rcb->status & BTA_AV_RC_ROLE_MASK) == BTA_AV_RC_ROLE_INT) )
- {
+ if (!(p_rcb->status & BTA_AV_RC_CONN_MASK) ||
+ ((p_rcb->status & BTA_AV_RC_ROLE_MASK) == BTA_AV_RC_ROLE_INT) ) {
p_rcb->status = 0;
p_rcb->handle = BTA_AV_RC_HANDLE_NONE;
p_rcb->shdl = 0;
}
/* else ACP && connected. do not clear the handle yet */
AVRC_Close(rc_handle);
- if (rc_handle == bta_av_cb.rc_acp_handle)
+ if (rc_handle == bta_av_cb.rc_acp_handle) {
bta_av_cb.rc_acp_handle = BTA_AV_RC_HANDLE_NONE;
+ }
APPL_TRACE_EVENT("end del_rc handle: %d status=0x%x, rc_acp_handle:%d, lidx:%d",
- p_rcb->handle, p_rcb->status, bta_av_cb.rc_acp_handle, p_rcb->lidx);
+ p_rcb->handle, p_rcb->status, bta_av_cb.rc_acp_handle, p_rcb->lidx);
}
}
{
int i;
- for(i=0; i<BTA_AV_NUM_RCB; i++)
- {
- if ((p_cb->disabling == TRUE) || (bta_av_cb.rcb[i].shdl != 0))
+ for (i = 0; i < BTA_AV_NUM_RCB; i++) {
+ if ((p_cb->disabling == TRUE) || (bta_av_cb.rcb[i].shdl != 0)) {
bta_av_del_rc(&bta_av_cb.rcb[i]);
+ }
}
}
*******************************************************************************/
static void bta_av_del_sdp_rec(UINT32 *p_sdp_handle)
{
- if(*p_sdp_handle != 0)
- {
+ if (*p_sdp_handle != 0) {
SDP_DeleteRecord(*p_sdp_handle);
*p_sdp_handle = 0;
}
BT_HDR *p_msg;
UNUSED(status);
- if ((p_msg = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL)
- {
+ if ((p_msg = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL) {
p_msg->event = BTA_AV_SDP_AVRC_DISC_EVT;
bta_sys_sendmsg(p_msg);
}
#else
APPL_TRACE_EVENT("bta_av_rc_ctrl_cback handle: %d event=0x%x", handle, event);
#endif
- if (event == AVRC_OPEN_IND_EVT)
- {
+ if (event == AVRC_OPEN_IND_EVT) {
/* save handle of opened connection
bta_av_cb.rc_handle = handle;*/
msg_event = BTA_AV_AVRC_OPEN_EVT;
- }
- else if (event == AVRC_CLOSE_IND_EVT)
- {
+ } else if (event == AVRC_CLOSE_IND_EVT) {
msg_event = BTA_AV_AVRC_CLOSE_EVT;
}
- if (msg_event)
- {
- if ((p_msg = (tBTA_AV_RC_CONN_CHG *) GKI_getbuf(sizeof(tBTA_AV_RC_CONN_CHG))) != NULL)
- {
+ if (msg_event) {
+ if ((p_msg = (tBTA_AV_RC_CONN_CHG *) GKI_getbuf(sizeof(tBTA_AV_RC_CONN_CHG))) != NULL) {
p_msg->hdr.event = msg_event;
p_msg->handle = handle;
- if(peer_addr)
+ if (peer_addr) {
bdcpy(p_msg->peer_addr, peer_addr);
+ }
bta_sys_sendmsg(p_msg);
}
}
if (p_data_src != NULL) {
UINT8 *p_data_dst = (UINT8 *)(p_buf + 1);
memcpy(p_data_dst, p_data_src, data_len);
- if (opcode == AVRC_OP_VENDOR)
+ if (opcode == AVRC_OP_VENDOR) {
p_buf->msg.vendor.p_vendor_data = p_data_dst;
- else if (opcode == AVRC_OP_PASS_THRU)
+ } else if (opcode == AVRC_OP_PASS_THRU) {
p_buf->msg.pass.p_pass_data = p_data_dst;
+ }
}
bta_sys_sendmsg(p_buf);
}
UINT8 rc_handle;
tBTA_AV_RCB *p_rcb;
- if(role == AVCT_INT)
- {
+ if (role == AVCT_INT) {
bda = p_scb->peer_addr;
status = BTA_AV_RC_ROLE_INT;
- }
- else
- {
- if ((p_rcb = bta_av_get_rcb_by_shdl(shdl)) != NULL )
- {
+ } else {
+ if ((p_rcb = bta_av_get_rcb_by_shdl(shdl)) != NULL ) {
APPL_TRACE_ERROR("bta_av_rc_create ACP handle exist for shdl:%d", shdl);
return p_rcb->handle;
}
ccb.control = p_cb->features & (BTA_AV_FEAT_RCTG | BTA_AV_FEAT_RCCT | AVRC_CT_PASSIVE);
- if (AVRC_Open(&rc_handle, &ccb, bda) != AVRC_SUCCESS)
+ if (AVRC_Open(&rc_handle, &ccb, bda) != AVRC_SUCCESS) {
return BTA_AV_RC_HANDLE_NONE;
+ }
i = rc_handle;
p_rcb = &p_cb->rcb[i];
- if (p_rcb->handle != BTA_AV_RC_HANDLE_NONE)
- {
+ if (p_rcb->handle != BTA_AV_RC_HANDLE_NONE) {
APPL_TRACE_ERROR("bta_av_rc_create found duplicated handle:%d", rc_handle);
}
p_rcb->shdl = shdl;
p_rcb->lidx = lidx;
p_rcb->peer_features = 0;
- if(lidx == (BTA_AV_NUM_LINKS + 1))
- {
+ if (lidx == (BTA_AV_NUM_LINKS + 1)) {
/* this LIDX is reserved for the AVRCP ACP connection */
p_cb->rc_acp_handle = p_rcb->handle;
p_cb->rc_acp_idx = (i + 1);
APPL_TRACE_DEBUG("rc_acp_handle:%d idx:%d", p_cb->rc_acp_handle, p_cb->rc_acp_idx);
}
APPL_TRACE_DEBUG("create %d, role: %d, shdl:%d, rc_handle:%d, lidx:%d, status:0x%x",
- i, role, shdl, p_rcb->handle, lidx, p_rcb->status);
+ i, role, shdl, p_rcb->handle, lidx, p_rcb->status);
return rc_handle;
}
*******************************************************************************/
static tBTA_AV_CODE bta_av_group_navi_supported(UINT8 len, UINT8 *p_data, BOOLEAN is_inquiry)
{
- tBTA_AV_CODE ret=BTA_AV_RSP_NOT_IMPL;
+ tBTA_AV_CODE ret = BTA_AV_RSP_NOT_IMPL;
UINT8 *p_ptr = p_data;
UINT16 u16;
UINT32 u32;
- if (p_bta_av_cfg->avrc_group && len == BTA_GROUP_NAVI_MSG_OP_DATA_LEN)
- {
+ if (p_bta_av_cfg->avrc_group && len == BTA_GROUP_NAVI_MSG_OP_DATA_LEN) {
BTA_AV_BE_STREAM_TO_CO_ID(u32, p_ptr);
BE_STREAM_TO_UINT16(u16, p_ptr);
- if (u32 == AVRC_CO_METADATA)
- {
- if (is_inquiry)
- {
- if (u16 <= AVRC_PDU_PREV_GROUP)
+ if (u32 == AVRC_CO_METADATA) {
+ if (is_inquiry) {
+ if (u16 <= AVRC_PDU_PREV_GROUP) {
ret = BTA_AV_RSP_IMPL_STBL;
- }
- else
- {
- if (u16 <= AVRC_PDU_PREV_GROUP)
+ }
+ } else {
+ if (u16 <= AVRC_PDU_PREV_GROUP) {
ret = BTA_AV_RSP_ACCEPT;
- else
+ } else {
ret = BTA_AV_RSP_REJ;
+ }
}
}
}
{
tBTA_AV_CODE ret_code = BTA_AV_RSP_NOT_IMPL;
- if (p_bta_av_rc_id)
- {
- if (is_inquiry)
- {
- if (p_bta_av_rc_id[rc_id >> 4] & (1 << (rc_id & 0x0F)))
- {
+ if (p_bta_av_rc_id) {
+ if (is_inquiry) {
+ if (p_bta_av_rc_id[rc_id >> 4] & (1 << (rc_id & 0x0F))) {
ret_code = BTA_AV_RSP_IMPL_STBL;
}
- }
- else
- {
- if (p_bta_av_rc_id[rc_id >> 4] & (1 << (rc_id & 0x0F)))
- {
+ } else {
+ if (p_bta_av_rc_id[rc_id >> 4] & (1 << (rc_id & 0x0F))) {
ret_code = BTA_AV_RSP_ACCEPT;
- }
- else if ((p_bta_av_cfg->rc_pass_rsp == BTA_AV_RSP_INTERIM) && p_bta_av_rc_id_ac)
- {
- if (p_bta_av_rc_id_ac[rc_id >> 4] & (1 << (rc_id & 0x0F)))
- {
+ } else if ((p_bta_av_cfg->rc_pass_rsp == BTA_AV_RSP_INTERIM) && p_bta_av_rc_id_ac) {
+ if (p_bta_av_rc_id_ac[rc_id >> 4] & (1 << (rc_id & 0x0F))) {
ret_code = BTA_AV_RSP_INTERIM;
}
}
** Returns NULL, if not found.
**
*******************************************************************************/
-tBTA_AV_LCB * bta_av_find_lcb(BD_ADDR addr, UINT8 op)
+tBTA_AV_LCB *bta_av_find_lcb(BD_ADDR addr, UINT8 op)
{
tBTA_AV_CB *p_cb = &bta_av_cb;
int xx;
UINT8 mask;
tBTA_AV_LCB *p_lcb = NULL;
- for(xx=0; xx<BTA_AV_NUM_LINKS; xx++)
- {
+ for (xx = 0; xx < BTA_AV_NUM_LINKS; xx++) {
mask = 1 << xx; /* the used mask for this lcb */
- if((mask & p_cb->conn_lcb) && 0 ==( bdcmp(p_cb->lcb[xx].addr, addr)))
- {
+ if ((mask & p_cb->conn_lcb) && 0 == ( bdcmp(p_cb->lcb[xx].addr, addr))) {
p_lcb = &p_cb->lcb[xx];
- if(op == BTA_AV_LCB_FREE)
- {
+ if (op == BTA_AV_LCB_FREE) {
p_cb->conn_lcb &= ~mask; /* clear the connect mask */
APPL_TRACE_DEBUG("conn_lcb: 0x%x", p_cb->conn_lcb);
}
UINT8 disc = 0;
/* find the SCB & stop the timer */
- for(i=0; i<BTA_AV_NUM_STRS; i++)
- {
+ for (i = 0; i < BTA_AV_NUM_STRS; i++) {
p_scb = p_cb->p_scb[i];
- if(p_scb && bdcmp(p_scb->peer_addr, p_data->rc_conn_chg.peer_addr) == 0)
- {
+ if (p_scb && bdcmp(p_scb->peer_addr, p_data->rc_conn_chg.peer_addr) == 0) {
p_scb->rc_handle = p_data->rc_conn_chg.handle;
APPL_TRACE_DEBUG("bta_av_rc_opened shdl:%d, srch %d", i + 1, p_scb->rc_handle);
- shdl = i+1;
+ shdl = i + 1;
LOG_INFO("%s allow incoming AVRCP connections:%d", __func__, p_scb->use_rc);
bta_sys_stop_timer(&p_scb->timer);
disc = p_scb->hndl;
}
i = p_data->rc_conn_chg.handle;
- if (p_cb->rcb[i].handle == BTA_AV_RC_HANDLE_NONE)
- {
+ if (p_cb->rcb[i].handle == BTA_AV_RC_HANDLE_NONE) {
APPL_TRACE_ERROR("not a valid handle:%d any more", i);
return;
}
- if (p_cb->rcb[i].lidx == (BTA_AV_NUM_LINKS + 1) && shdl != 0)
- {
+ if (p_cb->rcb[i].lidx == (BTA_AV_NUM_LINKS + 1) && shdl != 0) {
/* rc is opened on the RC only ACP channel, but is for a specific
* SCB -> need to switch RCBs */
p_rcb = bta_av_get_rcb_by_shdl(shdl);
- if (p_rcb)
- {
+ if (p_rcb) {
p_rcb->shdl = p_cb->rcb[i].shdl;
tmp = p_rcb->lidx;
p_rcb->lidx = p_cb->rcb[i].lidx;
p_cb->rc_acp_handle = p_rcb->handle;
p_cb->rc_acp_idx = (p_rcb - p_cb->rcb) + 1;
APPL_TRACE_DEBUG("switching RCB rc_acp_handle:%d idx:%d",
- p_cb->rc_acp_handle, p_cb->rc_acp_idx);
+ p_cb->rc_acp_handle, p_cb->rc_acp_idx);
}
}
p_cb->rcb[i].shdl = shdl;
rc_open.rc_handle = i;
APPL_TRACE_ERROR("bta_av_rc_opened rcb[%d] shdl:%d lidx:%d/%d",
- i, shdl, p_cb->rcb[i].lidx, p_cb->lcb[BTA_AV_NUM_LINKS].lidx);
+ i, shdl, p_cb->rcb[i].lidx, p_cb->lcb[BTA_AV_NUM_LINKS].lidx);
p_cb->rcb[i].status |= BTA_AV_RC_CONN_MASK;
- if(!shdl && 0 == p_cb->lcb[BTA_AV_NUM_LINKS].lidx)
- {
+ if (!shdl && 0 == p_cb->lcb[BTA_AV_NUM_LINKS].lidx) {
/* no associated SCB -> connected to an RC only device
* update the index to the extra LCB */
p_lcb = &p_cb->lcb[BTA_AV_NUM_LINKS];
bdcpy(p_lcb->addr, p_data->rc_conn_chg.peer_addr);
APPL_TRACE_DEBUG("rc_only bd_addr:%02x-%02x-%02x-%02x-%02x-%02x",
- p_lcb->addr[0], p_lcb->addr[1],
- p_lcb->addr[2], p_lcb->addr[3],
- p_lcb->addr[4], p_lcb->addr[5]);
+ p_lcb->addr[0], p_lcb->addr[1],
+ p_lcb->addr[2], p_lcb->addr[3],
+ p_lcb->addr[4], p_lcb->addr[5]);
p_lcb->lidx = BTA_AV_NUM_LINKS + 1;
- p_cb->rcb[i].lidx = p_lcb->lidx;
+ p_cb->rcb[i].lidx = p_lcb->lidx;
p_lcb->conn_msk = 1;
APPL_TRACE_ERROR("rcb[%d].lidx=%d, lcb.conn_msk=x%x",
- i, p_cb->rcb[i].lidx, p_lcb->conn_msk);
- disc = p_data->rc_conn_chg.handle|BTA_AV_CHNL_MSK;
+ i, p_cb->rcb[i].lidx, p_lcb->conn_msk);
+ disc = p_data->rc_conn_chg.handle | BTA_AV_CHNL_MSK;
}
bdcpy(rc_open.peer_addr, p_data->rc_conn_chg.peer_addr);
rc_open.peer_features = p_cb->rcb[i].peer_features;
rc_open.status = BTA_AV_SUCCESS;
APPL_TRACE_DEBUG("local features:x%x peer_features:x%x", p_cb->features,
- rc_open.peer_features);
- if(rc_open.peer_features == 0)
- {
+ rc_open.peer_features);
+ if (rc_open.peer_features == 0) {
/* we have not done SDP on peer RC capabilities.
* peer must have initiated the RC connection */
rc_open.peer_features = BTA_AV_FEAT_RCCT;
void bta_av_rc_remote_cmd(tBTA_AV_CB *p_cb, tBTA_AV_DATA *p_data)
{
tBTA_AV_RCB *p_rcb;
- if (p_cb->features & BTA_AV_FEAT_RCCT)
- {
- if(p_data->hdr.layer_specific < BTA_AV_NUM_RCB)
- {
+ if (p_cb->features & BTA_AV_FEAT_RCCT) {
+ if (p_data->hdr.layer_specific < BTA_AV_NUM_RCB) {
p_rcb = &p_cb->rcb[p_data->hdr.layer_specific];
- if(p_rcb->status & BTA_AV_RC_CONN_MASK)
- {
+ if (p_rcb->status & BTA_AV_RC_CONN_MASK) {
AVRC_PassCmd(p_rcb->handle, p_data->api_remote_cmd.label,
- &p_data->api_remote_cmd.msg);
+ &p_data->api_remote_cmd.msg);
}
}
}
{
tBTA_AV_RCB *p_rcb;
if ( (p_cb->features & (BTA_AV_FEAT_RCCT | BTA_AV_FEAT_VENDOR)) ==
- (BTA_AV_FEAT_RCCT | BTA_AV_FEAT_VENDOR))
- {
- if(p_data->hdr.layer_specific < BTA_AV_NUM_RCB)
- {
+ (BTA_AV_FEAT_RCCT | BTA_AV_FEAT_VENDOR)) {
+ if (p_data->hdr.layer_specific < BTA_AV_NUM_RCB) {
p_rcb = &p_cb->rcb[p_data->hdr.layer_specific];
AVRC_VendorCmd(p_rcb->handle, p_data->api_vendor.label, &p_data->api_vendor.msg);
}
{
tBTA_AV_RCB *p_rcb;
if ( (p_cb->features & (BTA_AV_FEAT_RCTG | BTA_AV_FEAT_VENDOR)) ==
- (BTA_AV_FEAT_RCTG | BTA_AV_FEAT_VENDOR))
- {
- if(p_data->hdr.layer_specific < BTA_AV_NUM_RCB)
- {
+ (BTA_AV_FEAT_RCTG | BTA_AV_FEAT_VENDOR)) {
+ if (p_data->hdr.layer_specific < BTA_AV_NUM_RCB) {
p_rcb = &p_cb->rcb[p_data->hdr.layer_specific];
AVRC_VendorRsp(p_rcb->handle, p_data->api_vendor.label, &p_data->api_vendor.msg);
}
tBTA_AV_RCB *p_rcb;
BOOLEAN do_free = TRUE;
- if ((p_cb->features & BTA_AV_FEAT_METADATA) && (p_data->hdr.layer_specific < BTA_AV_NUM_RCB))
- {
+ if ((p_cb->features & BTA_AV_FEAT_METADATA) && (p_data->hdr.layer_specific < BTA_AV_NUM_RCB)) {
if ((p_data->api_meta_rsp.is_rsp && (p_cb->features & BTA_AV_FEAT_RCTG)) ||
- (!p_data->api_meta_rsp.is_rsp && (p_cb->features & BTA_AV_FEAT_RCCT)) )
- {
+ (!p_data->api_meta_rsp.is_rsp && (p_cb->features & BTA_AV_FEAT_RCCT)) ) {
p_rcb = &p_cb->rcb[p_data->hdr.layer_specific];
if (p_rcb->handle != BTA_AV_RC_HANDLE_NONE) {
AVRC_MsgReq(p_rcb->handle, p_data->api_meta_rsp.label,
}
}
- if (do_free)
+ if (do_free) {
GKI_freebuf (p_data->api_meta_rsp.p_pkt);
+ }
}
/*******************************************************************************
BE_STREAM_TO_UINT16 (u16, p);
/* double check the fixed length */
- if ((u16 != 5) || (p_vendor->vendor_len != 9))
- {
+ if ((u16 != 5) || (p_vendor->vendor_len != 9)) {
status = AVRC_STS_INTERNAL_ERR;
- }
- else
- {
+ } else {
/* make sure the player_id is valid */
- for (xx=0; xx<p_bta_av_cfg->num_evt_ids; xx++)
- {
- if (*p == p_bta_av_cfg->p_meta_evt_ids[xx])
- {
+ for (xx = 0; xx < p_bta_av_cfg->num_evt_ids; xx++) {
+ if (*p == p_bta_av_cfg->p_meta_evt_ids[xx]) {
break;
}
}
- if (xx == p_bta_av_cfg->num_evt_ids)
- {
+ if (xx == p_bta_av_cfg->num_evt_ids) {
status = AVRC_STS_BAD_PARAM;
}
}
p_rc_rsp->pdu = pdu;
*p_ctype = AVRC_RSP_REJ;
/* Metadata messages only use PANEL sub-unit type */
- if (p_vendor->hdr.subunit_type != AVRC_SUB_PANEL)
- {
+ if (p_vendor->hdr.subunit_type != AVRC_SUB_PANEL) {
APPL_TRACE_DEBUG("SUBUNIT must be PANEL");
/* reject it */
- evt=0;
+ evt = 0;
p_vendor->hdr.ctype = BTA_AV_RSP_NOT_IMPL;
AVRC_VendorRsp(p_msg->handle, p_msg->label, &p_msg->msg.vendor);
- }
- else if (!AVRC_IsValidAvcType(pdu, p_vendor->hdr.ctype) )
- {
+ } else if (!AVRC_IsValidAvcType(pdu, p_vendor->hdr.ctype) ) {
APPL_TRACE_DEBUG("Invalid pdu/ctype: 0x%x, %d", pdu, p_vendor->hdr.ctype);
/* reject invalid message without reporting to app */
evt = 0;
p_rc_rsp->rsp.status = AVRC_STS_BAD_CMD;
- }
- else
- {
- switch (pdu)
- {
+ } else {
+ switch (pdu) {
case AVRC_PDU_GET_CAPABILITIES:
/* process GetCapabilities command without reporting the event to app */
evt = 0;
p = p_vendor->p_vendor_data + 2;
p_rc_rsp->get_caps.capability_id = u8;
BE_STREAM_TO_UINT16 (u16, p);
- if ((u16 != 1) || (p_vendor->vendor_len != 5))
- {
+ if ((u16 != 1) || (p_vendor->vendor_len != 5)) {
p_rc_rsp->get_caps.status = AVRC_STS_INTERNAL_ERR;
- }
- else
- {
+ } else {
p_rc_rsp->get_caps.status = AVRC_STS_NO_ERROR;
- if (u8 == AVRC_CAP_COMPANY_ID)
- {
+ if (u8 == AVRC_CAP_COMPANY_ID) {
*p_ctype = AVRC_RSP_IMPL_STBL;
p_rc_rsp->get_caps.count = p_bta_av_cfg->num_co_ids;
memcpy(p_rc_rsp->get_caps.param.company_id, p_bta_av_cfg->p_meta_co_ids,
(p_bta_av_cfg->num_co_ids << 2));
- }
- else if (u8 == AVRC_CAP_EVENTS_SUPPORTED)
- {
+ } else if (u8 == AVRC_CAP_EVENTS_SUPPORTED) {
*p_ctype = AVRC_RSP_IMPL_STBL;
p_rc_rsp->get_caps.count = p_bta_av_cfg->num_evt_ids;
memcpy(p_rc_rsp->get_caps.param.event_id, p_bta_av_cfg->p_meta_evt_ids,
p_bta_av_cfg->num_evt_ids);
- }
- else
- {
+ } else {
APPL_TRACE_DEBUG("Invalid capability ID: 0x%x", u8);
/* reject - unknown capability ID */
p_rc_rsp->get_caps.status = AVRC_STS_BAD_PARAM;
case AVRC_PDU_REGISTER_NOTIFICATION:
/* make sure the event_id is implemented */
p_rc_rsp->rsp.status = bta_av_chk_notif_evt_id (p_vendor);
- if (p_rc_rsp->rsp.status != BTA_AV_STS_NO_RSP)
+ if (p_rc_rsp->rsp.status != BTA_AV_STS_NO_RSP) {
evt = 0;
+ }
break;
}
rc_rsp.rsp.status = BTA_AV_STS_NO_RSP;
#endif
- if (p_data->rc_msg.opcode == AVRC_OP_PASS_THRU)
- {
- /* if this is a pass thru command */
+ if (p_data->rc_msg.opcode == AVRC_OP_PASS_THRU) {
+ /* if this is a pass thru command */
if ((p_data->rc_msg.msg.hdr.ctype == AVRC_CMD_CTRL) ||
- (p_data->rc_msg.msg.hdr.ctype == AVRC_CMD_SPEC_INQ) ||
- (p_data->rc_msg.msg.hdr.ctype == AVRC_CMD_GEN_INQ)
- )
- {
- /* check if operation is supported */
- if (p_data->rc_msg.msg.pass.op_id == AVRC_ID_VENDOR)
- {
+ (p_data->rc_msg.msg.hdr.ctype == AVRC_CMD_SPEC_INQ) ||
+ (p_data->rc_msg.msg.hdr.ctype == AVRC_CMD_GEN_INQ)
+ ) {
+ /* check if operation is supported */
+ if (p_data->rc_msg.msg.pass.op_id == AVRC_ID_VENDOR) {
p_data->rc_msg.msg.hdr.ctype = BTA_AV_RSP_NOT_IMPL;
#if (AVRC_METADATA_INCLUDED == TRUE)
if (p_cb->features & BTA_AV_FEAT_METADATA)
p_data->rc_msg.msg.hdr.ctype =
bta_av_group_navi_supported(p_data->rc_msg.msg.pass.pass_len,
- p_data->rc_msg.msg.pass.p_pass_data, is_inquiry);
+ p_data->rc_msg.msg.pass.p_pass_data, is_inquiry);
#endif
- }
- else
- {
+ } else {
p_data->rc_msg.msg.hdr.ctype = bta_av_op_supported(p_data->rc_msg.msg.pass.op_id, is_inquiry);
}
- APPL_TRACE_DEBUG("ctype %d",p_data->rc_msg.msg.hdr.ctype)
+ APPL_TRACE_DEBUG("ctype %d", p_data->rc_msg.msg.hdr.ctype)
/* send response */
- if (p_data->rc_msg.msg.hdr.ctype != BTA_AV_RSP_INTERIM)
+ if (p_data->rc_msg.msg.hdr.ctype != BTA_AV_RSP_INTERIM) {
AVRC_PassRsp(p_data->rc_msg.handle, p_data->rc_msg.label, &p_data->rc_msg.msg.pass);
+ }
/* set up for callback if supported */
- if (p_data->rc_msg.msg.hdr.ctype == BTA_AV_RSP_ACCEPT || p_data->rc_msg.msg.hdr.ctype == BTA_AV_RSP_INTERIM)
- {
+ if (p_data->rc_msg.msg.hdr.ctype == BTA_AV_RSP_ACCEPT || p_data->rc_msg.msg.hdr.ctype == BTA_AV_RSP_INTERIM) {
evt = BTA_AV_REMOTE_CMD_EVT;
av.remote_cmd.rc_id = p_data->rc_msg.msg.pass.op_id;
av.remote_cmd.key_state = p_data->rc_msg.msg.pass.state;
}
}
/* else if this is a pass thru response */
- else if (p_data->rc_msg.msg.hdr.ctype >= AVRC_RSP_ACCEPT)
- {
+ else if (p_data->rc_msg.msg.hdr.ctype >= AVRC_RSP_ACCEPT) {
/* set up for callback */
evt = BTA_AV_REMOTE_RSP_EVT;
av.remote_rsp.rc_id = p_data->rc_msg.msg.pass.op_id;
av.remote_rsp.label = p_data->rc_msg.label;
}
/* must be a bad ctype -> reject*/
- else
- {
+ else {
p_data->rc_msg.msg.hdr.ctype = BTA_AV_RSP_REJ;
AVRC_PassRsp(p_data->rc_msg.handle, p_data->rc_msg.label, &p_data->rc_msg.msg.pass);
}
}
/* else if this is a vendor specific command or response */
- else if (p_data->rc_msg.opcode == AVRC_OP_VENDOR)
- {
+ else if (p_data->rc_msg.opcode == AVRC_OP_VENDOR) {
/* set up for callback */
av.vendor_cmd.code = p_data->rc_msg.msg.hdr.ctype;
av.vendor_cmd.company_id = p_vendor->company_id;
/* if configured to support vendor specific and it's a command */
if ((p_cb->features & BTA_AV_FEAT_VENDOR) &&
- p_data->rc_msg.msg.hdr.ctype <= AVRC_CMD_GEN_INQ)
- {
+ p_data->rc_msg.msg.hdr.ctype <= AVRC_CMD_GEN_INQ) {
#if (AVRC_METADATA_INCLUDED == TRUE)
if ((p_cb->features & BTA_AV_FEAT_METADATA) &&
- (p_vendor->company_id == AVRC_CO_METADATA))
- {
+ (p_vendor->company_id == AVRC_CO_METADATA)) {
av.meta_msg.p_msg = &p_data->rc_msg.msg;
evt = bta_av_proc_meta_cmd (&rc_rsp, &p_data->rc_msg, &ctype);
- }
- else
+ } else
#endif
evt = BTA_AV_VENDOR_CMD_EVT;
}
/* else if configured to support vendor specific and it's a response */
else if ((p_cb->features & BTA_AV_FEAT_VENDOR) &&
- p_data->rc_msg.msg.hdr.ctype >= AVRC_RSP_ACCEPT)
- {
+ p_data->rc_msg.msg.hdr.ctype >= AVRC_RSP_ACCEPT) {
#if (AVRC_METADATA_INCLUDED == TRUE)
if ((p_cb->features & BTA_AV_FEAT_METADATA) &&
- (p_vendor->company_id == AVRC_CO_METADATA))
- {
+ (p_vendor->company_id == AVRC_CO_METADATA)) {
av.meta_msg.p_msg = &p_data->rc_msg.msg;
evt = BTA_AV_META_MSG_EVT;
- }
- else
+ } else
#endif
evt = BTA_AV_VENDOR_RSP_EVT;
}
/* else if not configured to support vendor specific and it's a command */
else if (!(p_cb->features & BTA_AV_FEAT_VENDOR) &&
- p_data->rc_msg.msg.hdr.ctype <= AVRC_CMD_GEN_INQ)
- {
- if(p_data->rc_msg.msg.vendor.p_vendor_data[0] == AVRC_PDU_INVALID)
- {
- /* reject it */
- p_data->rc_msg.msg.hdr.ctype = BTA_AV_RSP_REJ;
- p_data->rc_msg.msg.vendor.p_vendor_data[4] = AVRC_STS_BAD_CMD;
- }
- else
- p_data->rc_msg.msg.hdr.ctype = BTA_AV_RSP_NOT_IMPL;
- AVRC_VendorRsp(p_data->rc_msg.handle, p_data->rc_msg.label, &p_data->rc_msg.msg.vendor);
+ p_data->rc_msg.msg.hdr.ctype <= AVRC_CMD_GEN_INQ) {
+ if (p_data->rc_msg.msg.vendor.p_vendor_data[0] == AVRC_PDU_INVALID) {
+ /* reject it */
+ p_data->rc_msg.msg.hdr.ctype = BTA_AV_RSP_REJ;
+ p_data->rc_msg.msg.vendor.p_vendor_data[4] = AVRC_STS_BAD_CMD;
+ } else {
+ p_data->rc_msg.msg.hdr.ctype = BTA_AV_RSP_NOT_IMPL;
+ }
+ AVRC_VendorRsp(p_data->rc_msg.handle, p_data->rc_msg.label, &p_data->rc_msg.msg.vendor);
}
}
#if (AVRC_METADATA_INCLUDED == TRUE)
- if (evt == 0 && rc_rsp.rsp.status != BTA_AV_STS_NO_RSP)
- {
- if (!p_pkt)
- {
+ if (evt == 0 && rc_rsp.rsp.status != BTA_AV_STS_NO_RSP) {
+ if (!p_pkt) {
rc_rsp.rsp.opcode = p_data->rc_msg.opcode;
AVRC_BldResponse (0, &rc_rsp, &p_pkt);
}
- if (p_pkt)
+ if (p_pkt) {
AVRC_MsgReq (p_data->rc_msg.handle, p_data->rc_msg.label, ctype, p_pkt);
+ }
}
#endif
/* call callback */
- if (evt != 0)
- {
+ if (evt != 0) {
av.remote_cmd.rc_handle = p_data->rc_msg.handle;
(*p_cb->p_cback)(evt, &av);
}
tBTA_AV_SCB *p_scb;
tBTA_AV_RCB *p_rcb;
- if(handle < BTA_AV_NUM_RCB)
- {
+ if (handle < BTA_AV_NUM_RCB) {
p_rcb = &p_cb->rcb[handle];
APPL_TRACE_DEBUG("bta_av_rc_close handle: %d, status=0x%x", p_rcb->handle, p_rcb->status);
- if(p_rcb->handle != BTA_AV_RC_HANDLE_NONE)
- {
- if(p_rcb->shdl)
- {
+ if (p_rcb->handle != BTA_AV_RC_HANDLE_NONE) {
+ if (p_rcb->shdl) {
p_scb = bta_av_cb.p_scb[p_rcb->shdl - 1];
- if(p_scb)
- {
+ if (p_scb) {
/* just in case the RC timer is active
if(bta_av_cb.features & BTA_AV_FEAT_RCCT &&
p_scb->chnl == BTA_AV_CHNL_AUDIO) */
- bta_sys_stop_timer(&p_scb->timer);
+ bta_sys_stop_timer(&p_scb->timer);
}
}
int i;
UINT8 shdl = 0;
/* find the SCB & stop the timer */
- for(i=0; i<BTA_AV_NUM_STRS; i++)
- {
- if(p_scb == bta_av_cb.p_scb[i])
- {
- shdl = i+1;
+ for (i = 0; i < BTA_AV_NUM_STRS; i++) {
+ if (p_scb == bta_av_cb.p_scb[i]) {
+ shdl = i + 1;
break;
}
}
started_msk = BTA_AV_HNDL_TO_MSK(p_scb->hdi);
APPL_TRACE_DEBUG ("bta_av_stream_chg started:%d started_msk:x%x chnl:x%x", started,
- started_msk, p_scb->chnl);
- if (BTA_AV_CHNL_AUDIO == p_scb->chnl)
+ started_msk, p_scb->chnl);
+ if (BTA_AV_CHNL_AUDIO == p_scb->chnl) {
p_streams = &bta_av_cb.audio_streams;
- else
+ } else {
p_streams = &bta_av_cb.video_streams;
+ }
- if (started)
- {
+ if (started) {
/* Let L2CAP know this channel is processed with high priority */
L2CA_SetAclPriority(p_scb->peer_addr, L2CAP_PRIORITY_HIGH);
(*p_streams) |= started_msk;
- }
- else
- {
+ } else {
(*p_streams) &= ~started_msk;
}
- if (!started)
- {
- i=0;
- if (BTA_AV_CHNL_AUDIO == p_scb->chnl)
- {
- if (bta_av_cb.video_streams == 0)
+ if (!started) {
+ i = 0;
+ if (BTA_AV_CHNL_AUDIO == p_scb->chnl) {
+ if (bta_av_cb.video_streams == 0) {
no_streams = TRUE;
- }
- else
- {
+ }
+ } else {
no_streams = TRUE;
- if ( bta_av_cb.audio_streams )
- {
- for (; i<BTA_AV_NUM_STRS; i++)
- {
+ if ( bta_av_cb.audio_streams ) {
+ for (; i < BTA_AV_NUM_STRS; i++) {
p_scbi = bta_av_cb.p_scb[i];
/* scb is used and started */
if ( p_scbi && (bta_av_cb.audio_streams & BTA_AV_HNDL_TO_MSK(i))
- && bdcmp(p_scbi->peer_addr, p_scb->peer_addr) == 0)
- {
+ && bdcmp(p_scbi->peer_addr, p_scb->peer_addr) == 0) {
no_streams = FALSE;
break;
}
}
APPL_TRACE_DEBUG ("no_streams:%d i:%d, audio_streams:x%x, video_streams:x%x", no_streams, i,
- bta_av_cb.audio_streams, bta_av_cb.video_streams);
- if (no_streams)
- {
+ bta_av_cb.audio_streams, bta_av_cb.video_streams);
+ if (no_streams) {
/* Let L2CAP know this channel is processed with low priority */
L2CA_SetAclPriority(p_scb->peer_addr, L2CAP_PRIORITY_NORMAL);
}
BOOLEAN chk_restore = FALSE;
/* Validate array index*/
- if (index < BTA_AV_NUM_STRS)
- {
+ if (index < BTA_AV_NUM_STRS) {
p_scb = p_cb->p_scb[index];
}
mask = BTA_AV_HNDL_TO_MSK(index);
p_lcb = bta_av_find_lcb(p_data->conn_chg.peer_addr, BTA_AV_LCB_FIND);
conn_msk = 1 << (index + 1);
- if(p_data->conn_chg.is_up)
- {
+ if (p_data->conn_chg.is_up) {
/* set the conned mask for this channel */
- if(p_scb)
- {
- if(p_lcb)
- {
+ if (p_scb) {
+ if (p_lcb) {
p_lcb->conn_msk |= conn_msk;
- for (i=0; i<BTA_AV_NUM_RCB; i++)
- {
- if (bta_av_cb.rcb[i].lidx == p_lcb->lidx)
- {
+ for (i = 0; i < BTA_AV_NUM_RCB; i++) {
+ if (bta_av_cb.rcb[i].lidx == p_lcb->lidx) {
bta_av_cb.rcb[i].shdl = index + 1;
APPL_TRACE_DEBUG("conn_chg up[%d]: %d, status=0x%x, shdl:%d, lidx:%d", i,
- bta_av_cb.rcb[i].handle, bta_av_cb.rcb[i].status,
- bta_av_cb.rcb[i].shdl, bta_av_cb.rcb[i].lidx);
+ bta_av_cb.rcb[i].handle, bta_av_cb.rcb[i].status,
+ bta_av_cb.rcb[i].shdl, bta_av_cb.rcb[i].lidx);
break;
}
}
}
- if (p_scb->chnl == BTA_AV_CHNL_AUDIO)
- {
+ if (p_scb->chnl == BTA_AV_CHNL_AUDIO) {
old_msk = p_cb->conn_audio;
p_cb->conn_audio |= mask;
- }
- else
- {
+ } else {
old_msk = p_cb->conn_video;
p_cb->conn_video |= mask;
}
- if ((old_msk & mask) == 0)
- {
+ if ((old_msk & mask) == 0) {
/* increase the audio open count, if not set yet */
bta_av_cb.audio_open_cnt++;
}
APPL_TRACE_DEBUG("rc_acp_handle:%d rc_acp_idx:%d", p_cb->rc_acp_handle, p_cb->rc_acp_idx);
/* check if the AVRCP ACP channel is already connected */
- if(p_lcb && p_cb->rc_acp_handle != BTA_AV_RC_HANDLE_NONE && p_cb->rc_acp_idx)
- {
+ if (p_lcb && p_cb->rc_acp_handle != BTA_AV_RC_HANDLE_NONE && p_cb->rc_acp_idx) {
p_lcb_rc = &p_cb->lcb[BTA_AV_NUM_LINKS];
APPL_TRACE_DEBUG("rc_acp is connected && conn_chg on same addr p_lcb_rc->conn_msk:x%x",
- p_lcb_rc->conn_msk);
+ p_lcb_rc->conn_msk);
/* check if the RC is connected to the scb addr */
APPL_TRACE_DEBUG ("p_lcb_rc->addr: %02x:%02x:%02x:%02x:%02x:%02x",
- p_lcb_rc->addr[0], p_lcb_rc->addr[1], p_lcb_rc->addr[2], p_lcb_rc->addr[3],
- p_lcb_rc->addr[4], p_lcb_rc->addr[5]);
+ p_lcb_rc->addr[0], p_lcb_rc->addr[1], p_lcb_rc->addr[2], p_lcb_rc->addr[3],
+ p_lcb_rc->addr[4], p_lcb_rc->addr[5]);
APPL_TRACE_DEBUG ("conn_chg.peer_addr: %02x:%02x:%02x:%02x:%02x:%02x",
- p_data->conn_chg.peer_addr[0], p_data->conn_chg.peer_addr[1],
- p_data->conn_chg.peer_addr[2],
- p_data->conn_chg.peer_addr[3], p_data->conn_chg.peer_addr[4],
- p_data->conn_chg.peer_addr[5]);
- if (p_lcb_rc->conn_msk && bdcmp(p_lcb_rc->addr, p_data->conn_chg.peer_addr) == 0)
- {
+ p_data->conn_chg.peer_addr[0], p_data->conn_chg.peer_addr[1],
+ p_data->conn_chg.peer_addr[2],
+ p_data->conn_chg.peer_addr[3], p_data->conn_chg.peer_addr[4],
+ p_data->conn_chg.peer_addr[5]);
+ if (p_lcb_rc->conn_msk && bdcmp(p_lcb_rc->addr, p_data->conn_chg.peer_addr) == 0) {
/* AVRCP is already connected.
* need to update the association betwen SCB and RCB */
p_lcb_rc->conn_msk = 0; /* indicate RC ONLY is not connected */
p_rcb = &p_cb->rcb[p_cb->rc_acp_idx - 1];
p_rcb->shdl = bta_av_get_shdl(p_scb);
APPL_TRACE_DEBUG("update rc_acp shdl:%d/%d srch:%d", index + 1, p_rcb->shdl,
- p_scb->rc_handle );
+ p_scb->rc_handle );
p_rcb2 = bta_av_get_rcb_by_shdl(p_rcb->shdl);
- if (p_rcb2)
- {
+ if (p_rcb2) {
/* found the RCB that was created to associated with this SCB */
p_cb->rc_acp_handle = p_rcb2->handle;
p_cb->rc_acp_idx = (p_rcb2 - p_cb->rcb) + 1;
APPL_TRACE_DEBUG("new rc_acp_handle:%d, idx:%d", p_cb->rc_acp_handle,
- p_cb->rc_acp_idx);
+ p_cb->rc_acp_idx);
p_rcb2->lidx = (BTA_AV_NUM_LINKS + 1);
- APPL_TRACE_DEBUG("rc2 handle:%d lidx:%d/%d",p_rcb2->handle, p_rcb2->lidx,
- p_cb->lcb[p_rcb2->lidx-1].lidx);
+ APPL_TRACE_DEBUG("rc2 handle:%d lidx:%d/%d", p_rcb2->handle, p_rcb2->lidx,
+ p_cb->lcb[p_rcb2->lidx - 1].lidx);
}
p_rcb->lidx = p_lcb->lidx;
- APPL_TRACE_DEBUG("rc handle:%d lidx:%d/%d",p_rcb->handle, p_rcb->lidx,
- p_cb->lcb[p_rcb->lidx-1].lidx);
+ APPL_TRACE_DEBUG("rc handle:%d lidx:%d/%d", p_rcb->handle, p_rcb->lidx,
+ p_cb->lcb[p_rcb->lidx - 1].lidx);
}
}
}
- }
- else
- {
- if ((p_cb->conn_audio & mask) && bta_av_cb.audio_open_cnt)
- {
+ } else {
+ if ((p_cb->conn_audio & mask) && bta_av_cb.audio_open_cnt) {
/* this channel is still marked as open. decrease the count */
bta_av_cb.audio_open_cnt--;
}
/* clear the conned mask for this channel */
p_cb->conn_audio &= ~mask;
p_cb->conn_video &= ~mask;
- if(p_scb)
- {
+ if (p_scb) {
/* the stream is closed.
* clear the peer address, so it would not mess up the AVRCP for the next round of operation */
bdcpy(p_scb->peer_addr, bd_addr_null);
- if(p_scb->chnl == BTA_AV_CHNL_AUDIO)
- {
- if(p_lcb)
- {
+ if (p_scb->chnl == BTA_AV_CHNL_AUDIO) {
+ if (p_lcb) {
p_lcb->conn_msk &= ~conn_msk;
}
/* audio channel is down. make sure the INT channel is down */
}
APPL_TRACE_DEBUG("bta_av_conn_chg shdl:%d", index + 1);
- for (i=0; i<BTA_AV_NUM_RCB; i++)
- {
+ for (i = 0; i < BTA_AV_NUM_RCB; i++) {
APPL_TRACE_DEBUG("conn_chg dn[%d]: %d, status=0x%x, shdl:%d, lidx:%d", i,
- bta_av_cb.rcb[i].handle, bta_av_cb.rcb[i].status,
- bta_av_cb.rcb[i].shdl, bta_av_cb.rcb[i].lidx);
- if(bta_av_cb.rcb[i].shdl == index + 1)
- {
+ bta_av_cb.rcb[i].handle, bta_av_cb.rcb[i].status,
+ bta_av_cb.rcb[i].shdl, bta_av_cb.rcb[i].lidx);
+ if (bta_av_cb.rcb[i].shdl == index + 1) {
bta_av_del_rc(&bta_av_cb.rcb[i]);
break;
}
}
- if(p_cb->conn_audio == 0 && p_cb->conn_video == 0)
- {
+ if (p_cb->conn_audio == 0 && p_cb->conn_video == 0) {
/* if both channels are not connected,
* close all RC channels */
bta_av_close_all_rc(p_cb);
}
/* if the AVRCP is no longer listening, create the listening channel */
- if (bta_av_cb.rc_acp_handle == BTA_AV_RC_HANDLE_NONE && bta_av_cb.features & BTA_AV_FEAT_RCTG)
+ if (bta_av_cb.rc_acp_handle == BTA_AV_RC_HANDLE_NONE && bta_av_cb.features & BTA_AV_FEAT_RCTG) {
bta_av_rc_create(&bta_av_cb, AVCT_ACP, 0, BTA_AV_NUM_LINKS + 1);
+ }
}
APPL_TRACE_DEBUG("bta_av_conn_chg audio:%x video:%x up:%d conn_msk:0x%x chk_restore:%d audio_open_cnt:%d",
- p_cb->conn_audio, p_cb->conn_video, p_data->conn_chg.is_up, conn_msk, chk_restore, p_cb->audio_open_cnt);
+ p_cb->conn_audio, p_cb->conn_video, p_data->conn_chg.is_up, conn_msk, chk_restore, p_cb->audio_open_cnt);
- if (chk_restore)
- {
- if (p_cb->audio_open_cnt == 1)
- {
+ if (chk_restore) {
+ if (p_cb->audio_open_cnt == 1) {
/* one audio channel goes down and there's one audio channel remains open.
* restore the switch role in default link policy */
bta_sys_set_default_policy(BTA_ID_AV, HCI_ENABLE_MASTER_SLAVE_SWITCH);
/* allow role switch, if this is the last connection */
bta_av_restore_switch();
}
- if (p_cb->audio_open_cnt)
- {
+ if (p_cb->audio_open_cnt) {
/* adjust flush timeout settings to longer period */
- for (i=0; i<BTA_AV_NUM_STRS; i++)
- {
+ for (i = 0; i < BTA_AV_NUM_STRS; i++) {
p_scbi = bta_av_cb.p_scb[i];
- if (p_scbi && p_scbi->chnl == BTA_AV_CHNL_AUDIO && p_scbi->co_started)
- {
+ if (p_scbi && p_scbi->chnl == BTA_AV_CHNL_AUDIO && p_scbi->co_started) {
/* may need to update the flush timeout of this already started stream */
- if (p_scbi->co_started != bta_av_cb.audio_open_cnt)
- {
+ if (p_scbi->co_started != bta_av_cb.audio_open_cnt) {
p_scbi->co_started = bta_av_cb.audio_open_cnt;
L2CA_SetFlushTimeout(p_scbi->peer_addr, p_bta_av_cfg->p_audio_flush_to[p_scbi->co_started - 1] );
}
/* disable audio/video - de-register all channels,
* expect BTA_AV_DEREG_COMP_EVT when deregister is complete */
- for(xx=0; xx<BTA_AV_NUM_STRS; xx++)
- {
+ for (xx = 0; xx < BTA_AV_NUM_STRS; xx++) {
hdr.layer_specific = xx + 1;
bta_av_api_deregister((tBTA_AV_DATA *)&hdr);
}
tBTA_AV_LCB *p_lcb = NULL;
APPL_TRACE_DEBUG("bta_av_sig_chg event: %d", event);
- if(event == AVDT_CONNECT_IND_EVT)
- {
+ if (event == AVDT_CONNECT_IND_EVT) {
p_lcb = bta_av_find_lcb(p_data->str_msg.bd_addr, BTA_AV_LCB_FIND);
- if(!p_lcb)
- {
+ if (!p_lcb) {
/* if the address does not have an LCB yet, alloc one */
- for(xx=0; xx<BTA_AV_NUM_LINKS; xx++)
- {
+ for (xx = 0; xx < BTA_AV_NUM_LINKS; xx++) {
mask = 1 << xx;
APPL_TRACE_DEBUG("conn_lcb: 0x%x", p_cb->conn_lcb);
/* look for a p_lcb with its p_scb registered */
- if((!(mask & p_cb->conn_lcb)) && (p_cb->p_scb[xx] != NULL))
- {
+ if ((!(mask & p_cb->conn_lcb)) && (p_cb->p_scb[xx] != NULL)) {
p_lcb = &p_cb->lcb[xx];
p_lcb->lidx = xx + 1;
bdcpy(p_lcb->addr, p_data->str_msg.bd_addr);
p_lcb->conn_msk = 0; /* clear the connect mask */
/* start listening when the signal channel is open */
- if (p_cb->features & BTA_AV_FEAT_RCTG)
- {
+ if (p_cb->features & BTA_AV_FEAT_RCTG) {
bta_av_rc_create(p_cb, AVCT_ACP, 0, p_lcb->lidx);
}
/* this entry is not used yet. */
p_cb->conn_lcb |= mask; /* mark it as used */
APPL_TRACE_DEBUG("start sig timer %d", p_data->hdr.offset);
- if (p_data->hdr.offset == AVDT_ACP)
- {
+ if (p_data->hdr.offset == AVDT_ACP) {
APPL_TRACE_DEBUG("Incoming L2CAP acquired, set state as incoming");
bdcpy(p_cb->p_scb[xx]->peer_addr, p_data->str_msg.bd_addr);
p_cb->p_scb[xx]->use_rc = TRUE; /* allowing RC for incoming connection */
p_cb->p_scb[xx]->coll_mask = BTA_AV_COLL_INC_TMR;
p_cb->acp_sig_tmr.param = (UINT32)xx;
- p_cb->acp_sig_tmr.p_cback = (TIMER_CBACK*)&bta_av_acp_sig_timer_cback;
+ p_cb->acp_sig_tmr.p_cback = (TIMER_CBACK *)&bta_av_acp_sig_timer_cback;
bta_sys_start_timer(&p_cb->acp_sig_tmr, 0, BTA_AV_ACP_SIG_TIME_VAL);
}
break;
}
/* check if we found something */
- if (xx == BTA_AV_NUM_LINKS)
- {
+ if (xx == BTA_AV_NUM_LINKS) {
/* We do not have scb for this avdt connection. */
/* Silently close the connection. */
APPL_TRACE_ERROR("av scb not available for avdt connection");
}
}
#if( defined BTA_AR_INCLUDED ) && (BTA_AR_INCLUDED == TRUE)
- else if (event == BTA_AR_AVDT_CONN_EVT)
- {
+ else if (event == BTA_AR_AVDT_CONN_EVT) {
bta_sys_stop_timer(&bta_av_cb.sig_tmr);
}
#endif
- else
- {
+ else {
/* disconnected. */
p_lcb = bta_av_find_lcb(p_data->str_msg.bd_addr, BTA_AV_LCB_FREE);
- if(p_lcb && p_lcb->conn_msk)
- {
+ if (p_lcb && p_lcb->conn_msk) {
APPL_TRACE_DEBUG("conn_msk: 0x%x", p_lcb->conn_msk);
/* clean up ssm */
- for(xx=0; xx < BTA_AV_NUM_STRS; xx++)
- {
+ for (xx = 0; xx < BTA_AV_NUM_STRS; xx++) {
mask = 1 << (xx + 1);
if ((mask & p_lcb->conn_msk) && (p_cb->p_scb[xx]) &&
- (bdcmp(p_cb->p_scb[xx]->peer_addr, p_data->str_msg.bd_addr) == 0))
- {
+ (bdcmp(p_cb->p_scb[xx]->peer_addr, p_data->str_msg.bd_addr) == 0)) {
p_cb->p_scb[xx]->disc_rsn = p_data->str_msg.hdr.offset;
bta_av_ssm_execute(p_cb->p_scb[xx], BTA_AV_AVDT_DISCONNECT_EVT, NULL);
}
UNUSED(p_data);
APPL_TRACE_DEBUG("bta_av_sig_timer");
- for(xx=0; xx<BTA_AV_NUM_LINKS; xx++)
- {
+ for (xx = 0; xx < BTA_AV_NUM_LINKS; xx++) {
mask = 1 << xx;
- if(mask & p_cb->conn_lcb)
- {
+ if (mask & p_cb->conn_lcb) {
/* this entry is used. check if it is connected */
p_lcb = &p_cb->lcb[xx];
- if(!p_lcb->conn_msk)
- {
+ if (!p_lcb->conn_msk) {
bta_sys_start_timer(&p_cb->sig_tmr, BTA_AV_SIG_TIMER_EVT, BTA_AV_SIG_TIME_VAL);
bdcpy(pend.bd_addr, p_lcb->addr);
(*p_cb->p_cback)(BTA_AV_PENDING_EVT, (tBTA_AV *) &pend);
tBTA_AV_CB *p_cb = &bta_av_cb;
tBTA_AV_SCB *p_scb = NULL;
tBTA_AV_API_OPEN *p_buf;
- if (inx < BTA_AV_NUM_STRS)
- {
+ if (inx < BTA_AV_NUM_STRS) {
p_scb = p_cb->p_scb[inx];
}
- if (p_scb)
- {
+ if (p_scb) {
APPL_TRACE_DEBUG("bta_av_acp_sig_timer_cback, coll_mask = 0x%02X", p_scb->coll_mask);
- if (p_scb->coll_mask & BTA_AV_COLL_INC_TMR)
- {
+ if (p_scb->coll_mask & BTA_AV_COLL_INC_TMR) {
p_scb->coll_mask &= ~BTA_AV_COLL_INC_TMR;
- if (bta_av_is_scb_opening(p_scb))
- {
- if (p_scb->p_disc_db)
- {
+ if (bta_av_is_scb_opening(p_scb)) {
+ if (p_scb->p_disc_db) {
/* We are still doing SDP. Run the timer again. */
p_scb->coll_mask |= BTA_AV_COLL_INC_TMR;
p_cb->acp_sig_tmr.param = (UINT32)inx;
p_cb->acp_sig_tmr.p_cback = (TIMER_CBACK *)&bta_av_acp_sig_timer_cback;
bta_sys_start_timer(&p_cb->acp_sig_tmr, 0, BTA_AV_ACP_SIG_TIME_VAL);
- }
- else
- {
+ } else {
/* SNK did not start signalling, resume signalling process. */
bta_av_discover_req (p_scb, NULL);
}
- }
- else if (bta_av_is_scb_incoming(p_scb))
- {
+ } else if (bta_av_is_scb_incoming(p_scb)) {
/* Stay in incoming state if SNK does not start signalling */
/* API open was called right after SNK opened L2C connection. */
- if (p_scb->coll_mask & BTA_AV_COLL_API_CALLED)
- {
+ if (p_scb->coll_mask & BTA_AV_COLL_API_CALLED) {
p_scb->coll_mask &= ~BTA_AV_COLL_API_CALLED;
/* BTA_AV_API_OPEN_EVT */
- if ((p_buf = (tBTA_AV_API_OPEN *) GKI_getbuf(sizeof(tBTA_AV_API_OPEN))) != NULL)
- {
+ if ((p_buf = (tBTA_AV_API_OPEN *) GKI_getbuf(sizeof(tBTA_AV_API_OPEN))) != NULL) {
memcpy(p_buf, &(p_scb->open_api), sizeof(tBTA_AV_API_OPEN));
bta_sys_sendmsg(p_buf);
}
tBTA_AV_CB *p_cb = &bta_av_cb;
tSDP_DISC_REC *p_rec = NULL;
tSDP_DISC_ATTR *p_attr;
- UINT16 peer_rc_version=0;
+ UINT16 peer_rc_version = 0;
UINT16 categories = 0;
APPL_TRACE_DEBUG("bta_av_check_peer_features service_uuid:x%x", service_uuid);
/* loop through all records we found */
- while (TRUE)
- {
+ while (TRUE) {
/* get next record; if none found, we're done */
- if ((p_rec = SDP_FindServiceInDb(p_cb->p_disc_db, service_uuid, p_rec)) == NULL)
- {
+ if ((p_rec = SDP_FindServiceInDb(p_cb->p_disc_db, service_uuid, p_rec)) == NULL) {
break;
}
- if (( SDP_FindAttributeInRec(p_rec, ATTR_ID_SERVICE_CLASS_ID_LIST)) != NULL)
- {
+ if (( SDP_FindAttributeInRec(p_rec, ATTR_ID_SERVICE_CLASS_ID_LIST)) != NULL) {
/* find peer features */
- if (SDP_FindServiceInDb(p_cb->p_disc_db, UUID_SERVCLASS_AV_REMOTE_CONTROL, NULL))
- {
+ if (SDP_FindServiceInDb(p_cb->p_disc_db, UUID_SERVCLASS_AV_REMOTE_CONTROL, NULL)) {
peer_features |= BTA_AV_FEAT_RCCT;
}
- if (SDP_FindServiceInDb(p_cb->p_disc_db, UUID_SERVCLASS_AV_REM_CTRL_TARGET, NULL))
- {
+ if (SDP_FindServiceInDb(p_cb->p_disc_db, UUID_SERVCLASS_AV_REM_CTRL_TARGET, NULL)) {
peer_features |= BTA_AV_FEAT_RCTG;
}
}
- if (( SDP_FindAttributeInRec(p_rec, ATTR_ID_BT_PROFILE_DESC_LIST)) != NULL)
- {
+ if (( SDP_FindAttributeInRec(p_rec, ATTR_ID_BT_PROFILE_DESC_LIST)) != NULL) {
/* get profile version (if failure, version parameter is not updated) */
SDP_FindProfileVersionInRec(p_rec, UUID_SERVCLASS_AV_REMOTE_CONTROL, &peer_rc_version);
APPL_TRACE_DEBUG("peer_rc_version 0x%x", peer_rc_version);
- if (peer_rc_version >= AVRC_REV_1_3)
+ if (peer_rc_version >= AVRC_REV_1_3) {
peer_features |= (BTA_AV_FEAT_VENDOR | BTA_AV_FEAT_METADATA);
+ }
- if (peer_rc_version >= AVRC_REV_1_4)
- {
+ if (peer_rc_version >= AVRC_REV_1_4) {
peer_features |= (BTA_AV_FEAT_ADV_CTRL);
/* get supported categories */
if ((p_attr = SDP_FindAttributeInRec(p_rec,
- ATTR_ID_SUPPORTED_FEATURES)) != NULL)
- {
+ ATTR_ID_SUPPORTED_FEATURES)) != NULL) {
categories = p_attr->attr_value.v.u16;
- if (categories & AVRC_SUPF_CT_BROWSE)
+ if (categories & AVRC_SUPF_CT_BROWSE) {
peer_features |= (BTA_AV_FEAT_BROWSE);
+ }
}
}
}
UNUSED(p_data);
APPL_TRACE_DEBUG("bta_av_rc_disc_done disc:x%x", p_cb->disc);
- if (!p_cb->disc)
- {
+ if (!p_cb->disc) {
return;
}
- if ((p_cb->disc & BTA_AV_CHNL_MSK) == BTA_AV_CHNL_MSK)
- {
+ if ((p_cb->disc & BTA_AV_CHNL_MSK) == BTA_AV_CHNL_MSK) {
/* this is the rc handle/index to tBTA_AV_RCB */
rc_handle = p_cb->disc & (~BTA_AV_CHNL_MSK);
- }
- else
- {
+ } else {
/* Validate array index*/
- if (((p_cb->disc & BTA_AV_HNDL_MSK) - 1) < BTA_AV_NUM_STRS)
- {
+ if (((p_cb->disc & BTA_AV_HNDL_MSK) - 1) < BTA_AV_NUM_STRS) {
p_scb = p_cb->p_scb[(p_cb->disc & BTA_AV_HNDL_MSK) - 1];
}
- if (p_scb)
+ if (p_scb) {
rc_handle = p_scb->rc_handle;
- else
- {
+ } else {
p_cb->disc = 0;
return;
}
APPL_TRACE_DEBUG("rc_handle %d", rc_handle);
/* check peer version and whether support CT and TG role */
peer_features = bta_av_check_peer_features (UUID_SERVCLASS_AV_REMOTE_CONTROL);
- if ((p_cb->features & BTA_AV_FEAT_ADV_CTRL) && ((peer_features&BTA_AV_FEAT_ADV_CTRL) == 0))
- {
+ if ((p_cb->features & BTA_AV_FEAT_ADV_CTRL) && ((peer_features & BTA_AV_FEAT_ADV_CTRL) == 0)) {
/* if we support advance control and peer does not, check their support on TG role
* some implementation uses 1.3 on CT ans 1.4 on TG */
peer_features |= bta_av_check_peer_features (UUID_SERVCLASS_AV_REM_CTRL_TARGET);
APPL_TRACE_DEBUG("peer_features 0x%x, features 0x%x", peer_features, p_cb->features);
/* if we have no rc connection */
- if (rc_handle == BTA_AV_RC_HANDLE_NONE)
- {
- if (p_scb)
- {
+ if (rc_handle == BTA_AV_RC_HANDLE_NONE) {
+ if (p_scb) {
/* if peer remote control service matches ours and USE_RC is TRUE */
if ((((p_cb->features & BTA_AV_FEAT_RCCT) && (peer_features & BTA_AV_FEAT_RCTG)) ||
- ((p_cb->features & BTA_AV_FEAT_RCTG) && (peer_features & BTA_AV_FEAT_RCCT))) )
- {
+ ((p_cb->features & BTA_AV_FEAT_RCTG) && (peer_features & BTA_AV_FEAT_RCCT))) ) {
p_lcb = bta_av_find_lcb(p_scb->peer_addr, BTA_AV_LCB_FIND);
- if(p_lcb)
- {
+ if (p_lcb) {
rc_handle = bta_av_rc_create(p_cb, AVCT_INT, (UINT8)(p_scb->hdi + 1), p_lcb->lidx);
p_cb->rcb[rc_handle].peer_features = peer_features;
}
#if (BT_USE_TRACES == TRUE || BT_TRACE_APPL == TRUE)
- else
- {
+ else {
APPL_TRACE_ERROR("can not find LCB!!");
}
#endif
- }
- else if(p_scb->use_rc)
- {
+ } else if (p_scb->use_rc) {
/* can not find AVRC on peer device. report failure */
p_scb->use_rc = FALSE;
bdcpy(rc_open.peer_addr, p_scb->peer_addr);
(*p_cb->p_cback)(BTA_AV_RC_OPEN_EVT, (tBTA_AV *) &rc_open);
}
}
- }
- else
- {
+ } else {
p_cb->rcb[rc_handle].peer_features = peer_features;
rc_feat.rc_handle = rc_handle;
rc_feat.peer_features = peer_features;
rc_close.rc_handle = BTA_AV_RC_HANDLE_NONE;
p_scb = NULL;
APPL_TRACE_DEBUG("bta_av_rc_closed rc_handle:%d", p_msg->handle);
- for(i=0; i<BTA_AV_NUM_RCB; i++)
- {
+ for (i = 0; i < BTA_AV_NUM_RCB; i++) {
p_rcb = &p_cb->rcb[i];
APPL_TRACE_DEBUG("bta_av_rc_closed rcb[%d] rc_handle:%d, status=0x%x", i, p_rcb->handle, p_rcb->status);
- if(p_rcb->handle == p_msg->handle)
- {
+ if (p_rcb->handle == p_msg->handle) {
rc_close.rc_handle = i;
p_rcb->status &= ~BTA_AV_RC_CONN_MASK;
p_rcb->peer_features = 0;
APPL_TRACE_DEBUG(" shdl:%d, lidx:%d", p_rcb->shdl, p_rcb->lidx);
- if(p_rcb->shdl)
- {
- if ((p_rcb->shdl - 1) < BTA_AV_NUM_STRS)
- {
+ if (p_rcb->shdl) {
+ if ((p_rcb->shdl - 1) < BTA_AV_NUM_STRS) {
p_scb = bta_av_cb.p_scb[p_rcb->shdl - 1];
}
- if(p_scb)
- {
+ if (p_scb) {
bdcpy(rc_close.peer_addr, p_scb->peer_addr);
- if(p_scb->rc_handle == p_rcb->handle)
+ if (p_scb->rc_handle == p_rcb->handle) {
p_scb->rc_handle = BTA_AV_RC_HANDLE_NONE;
+ }
APPL_TRACE_DEBUG("shdl:%d, srch:%d", p_rcb->shdl, p_scb->rc_handle);
}
p_rcb->shdl = 0;
- }
- else if(p_rcb->lidx == (BTA_AV_NUM_LINKS + 1) )
- {
+ } else if (p_rcb->lidx == (BTA_AV_NUM_LINKS + 1) ) {
/* if the RCB uses the extra LCB, use the addr for event and clean it */
p_lcb = &p_cb->lcb[BTA_AV_NUM_LINKS];
bdcpy(rc_close.peer_addr, p_msg->peer_addr);
APPL_TRACE_DEBUG("rc_only closed bd_addr:%02x-%02x-%02x-%02x-%02x-%02x",
- p_msg->peer_addr[0], p_msg->peer_addr[1],
- p_msg->peer_addr[2], p_msg->peer_addr[3],
- p_msg->peer_addr[4], p_msg->peer_addr[5]);
+ p_msg->peer_addr[0], p_msg->peer_addr[1],
+ p_msg->peer_addr[2], p_msg->peer_addr[3],
+ p_msg->peer_addr[4], p_msg->peer_addr[5]);
p_lcb->conn_msk = 0;
p_lcb->lidx = 0;
}
p_rcb->lidx = 0;
- if((p_rcb->status & BTA_AV_RC_ROLE_MASK) == BTA_AV_RC_ROLE_INT)
- {
+ if ((p_rcb->status & BTA_AV_RC_ROLE_MASK) == BTA_AV_RC_ROLE_INT) {
/* AVCT CCB is deallocated */
p_rcb->handle = BTA_AV_RC_HANDLE_NONE;
p_rcb->status = 0;
- }
- else
- {
+ } else {
/* AVCT CCB is still there. dealloc */
bta_av_del_rc(p_rcb);
/* if the AVRCP is no longer listening, create the listening channel */
- if (bta_av_cb.rc_acp_handle == BTA_AV_RC_HANDLE_NONE && bta_av_cb.features & BTA_AV_FEAT_RCTG)
+ if (bta_av_cb.rc_acp_handle == BTA_AV_RC_HANDLE_NONE && bta_av_cb.features & BTA_AV_FEAT_RCTG) {
bta_av_rc_create(&bta_av_cb, AVCT_ACP, 0, BTA_AV_NUM_LINKS + 1);
+ }
}
- }
- else if((p_rcb->handle != BTA_AV_RC_HANDLE_NONE) && (p_rcb->status & BTA_AV_RC_CONN_MASK))
- {
+ } else if ((p_rcb->handle != BTA_AV_RC_HANDLE_NONE) && (p_rcb->status & BTA_AV_RC_CONN_MASK)) {
/* at least one channel is still connected */
conn = TRUE;
}
}
- if(!conn)
- {
+ if (!conn) {
/* no AVRC channels are connected, go back to INIT state */
bta_av_sm_execute(p_cb, BTA_AV_AVRC_NONE_EVT, NULL);
}
- if (rc_close.rc_handle == BTA_AV_RC_HANDLE_NONE)
- {
+ if (rc_close.rc_handle == BTA_AV_RC_HANDLE_NONE) {
rc_close.rc_handle = p_msg->handle;
bdcpy(rc_close.peer_addr, p_msg->peer_addr);
}
{
tBTA_AV_CB *p_cb = &bta_av_cb;
tAVRC_SDP_DB_PARAMS db_params;
- UINT16 attr_list[] = {ATTR_ID_SERVICE_CLASS_ID_LIST,
+ UINT16 attr_list[] = {ATTR_ID_SERVICE_CLASS_ID_LIST,
ATTR_ID_BT_PROFILE_DESC_LIST,
- ATTR_ID_SUPPORTED_FEATURES};
+ ATTR_ID_SUPPORTED_FEATURES
+ };
UINT8 hdi;
tBTA_AV_SCB *p_scb;
UINT8 *p_addr = NULL;
UINT8 rc_handle;
APPL_TRACE_DEBUG("bta_av_rc_disc 0x%x, %d", disc, bta_av_cb.disc);
- if ((bta_av_cb.disc != 0) || (disc == 0))
+ if ((bta_av_cb.disc != 0) || (disc == 0)) {
return;
+ }
- if ((disc & BTA_AV_CHNL_MSK) == BTA_AV_CHNL_MSK)
- {
+ if ((disc & BTA_AV_CHNL_MSK) == BTA_AV_CHNL_MSK) {
/* this is the rc handle/index to tBTA_AV_RCB */
rc_handle = disc & (~BTA_AV_CHNL_MSK);
- if (p_cb->rcb[rc_handle].lidx)
- {
- p_addr = p_cb->lcb[p_cb->rcb[rc_handle].lidx-1].addr;
+ if (p_cb->rcb[rc_handle].lidx) {
+ p_addr = p_cb->lcb[p_cb->rcb[rc_handle].lidx - 1].addr;
}
- }
- else
- {
+ } else {
hdi = (disc & BTA_AV_HNDL_MSK) - 1;
p_scb = p_cb->p_scb[hdi];
- if (p_scb)
- {
+ if (p_scb) {
APPL_TRACE_DEBUG("rc_handle %d", p_scb->rc_handle);
p_addr = p_scb->peer_addr;
}
}
- if (p_addr)
- {
+ if (p_addr) {
/* allocate discovery database */
- if (p_cb->p_disc_db == NULL)
- {
+ if (p_cb->p_disc_db == NULL) {
p_cb->p_disc_db = (tSDP_DISCOVERY_DB *) GKI_getbuf(BTA_AV_DISC_BUF_SIZE);
}
- if (p_cb->p_disc_db)
- {
+ if (p_cb->p_disc_db) {
/* set up parameters */
db_params.db_len = BTA_AV_DISC_BUF_SIZE;
db_params.num_attr = 3;
/* searching for UUID_SERVCLASS_AV_REMOTE_CONTROL gets both TG and CT */
if (AVRC_FindService(UUID_SERVCLASS_AV_REMOTE_CONTROL, p_addr, &db_params,
- bta_av_avrc_sdp_cback) == AVRC_SUCCESS)
- {
+ bta_av_avrc_sdp_cback) == AVRC_SUCCESS) {
p_cb->disc = disc;
APPL_TRACE_DEBUG("disc %d", p_cb->disc);
}
/* find the stream control block */
p_scb = bta_av_hndl_to_scb(p_data->hdr.layer_specific);
- if(p_scb)
- {
+ if (p_scb) {
APPL_TRACE_DEBUG("deregistered %d(h%d)", p_scb->chnl, p_scb->hndl);
mask = BTA_AV_HNDL_TO_MSK(p_scb->hdi);
- if(p_scb->chnl == BTA_AV_CHNL_AUDIO)
- {
+ if (p_scb->chnl == BTA_AV_CHNL_AUDIO) {
p_cb->reg_audio &= ~mask;
- if ((p_cb->conn_audio & mask) && bta_av_cb.audio_open_cnt)
- {
+ if ((p_cb->conn_audio & mask) && bta_av_cb.audio_open_cnt) {
/* this channel is still marked as open. decrease the count */
bta_av_cb.audio_open_cnt--;
}
if (p_scb->q_tag == BTA_AV_Q_TAG_STREAM && p_scb->a2d_list) {
/* make sure no buffers are in a2d_list */
while (!list_is_empty(p_scb->a2d_list)) {
- p_buf = (BT_HDR*)list_front(p_scb->a2d_list);
+ p_buf = (BT_HDR *)list_front(p_scb->a2d_list);
list_remove(p_scb->a2d_list, p_buf);
GKI_freebuf(p_buf);
}
}
/* remove the A2DP SDP record, if no more audio stream is left */
- if(!p_cb->reg_audio)
- {
+ if (!p_cb->reg_audio) {
#if( defined BTA_AR_INCLUDED ) && (BTA_AR_INCLUDED == TRUE)
bta_ar_dereg_avrc (UUID_SERVCLASS_AV_REMOTE_CONTROL, BTA_ID_AV);
#endif
bta_sys_remove_uuid(UUID_SERVCLASS_AUDIO_SINK);
#endif
}
- }
- else
- {
+ } else {
p_cb->reg_video &= ~mask;
/* make sure that this channel is not connected */
p_cb->conn_video &= ~mask;
}
APPL_TRACE_DEBUG("audio 0x%x, video: 0x%x, disable:%d",
- p_cb->reg_audio, p_cb->reg_video, p_cb->disabling);
+ p_cb->reg_audio, p_cb->reg_video, p_cb->disabling);
/* if no stream control block is active */
- if((p_cb->reg_audio + p_cb->reg_video) == 0)
- {
+ if ((p_cb->reg_audio + p_cb->reg_video) == 0) {
#if( defined BTA_AR_INCLUDED ) && (BTA_AR_INCLUDED == TRUE)
/* deregister from AVDT */
bta_ar_dereg_avdt(BTA_ID_AV);
bta_ar_dereg_avct(BTA_ID_AV);
#endif
- if(p_cb->disabling)
- {
+ if (p_cb->disabling) {
p_cb->disabling = FALSE;
bta_av_cb.features = 0;
}
** Constants
*****************************************************************************/
-static const tBTA_SYS_REG bta_av_reg =
-{
+static const tBTA_SYS_REG bta_av_reg = {
bta_av_hdl_event,
BTA_AvDisable
};
/* register with BTA system manager */
bta_sys_register(BTA_ID_AV, &bta_av_reg);
- if ((p_buf = (tBTA_AV_API_ENABLE *) GKI_getbuf(sizeof(tBTA_AV_API_ENABLE))) != NULL)
- {
+ if ((p_buf = (tBTA_AV_API_ENABLE *) GKI_getbuf(sizeof(tBTA_AV_API_ENABLE))) != NULL) {
p_buf->hdr.event = BTA_AV_API_ENABLE_EVT;
p_buf->p_cback = p_cback;
p_buf->features = features;
BT_HDR *p_buf;
bta_sys_deregister(BTA_ID_AV);
- if ((p_buf = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL)
- {
+ if ((p_buf = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL) {
p_buf->event = BTA_AV_API_DISABLE_EVT;
bta_sys_sendmsg(p_buf);
}
tBTA_AV_API_REG *p_buf;
- if ((p_buf = (tBTA_AV_API_REG *) GKI_getbuf(sizeof(tBTA_AV_API_REG))) != NULL)
- {
+ if ((p_buf = (tBTA_AV_API_REG *) GKI_getbuf(sizeof(tBTA_AV_API_REG))) != NULL) {
p_buf->hdr.layer_specific = chnl;
p_buf->hdr.event = BTA_AV_API_REGISTER_EVT;
- if(p_service_name)
- {
+ if (p_service_name) {
BCM_STRNCPY_S(p_buf->p_service_name, sizeof(p_buf->p_service_name), p_service_name, BTA_SERVICE_NAME_LEN);
- p_buf->p_service_name[BTA_SERVICE_NAME_LEN-1] = 0;
- }
- else
- {
+ p_buf->p_service_name[BTA_SERVICE_NAME_LEN - 1] = 0;
+ } else {
p_buf->p_service_name[0] = 0;
}
p_buf->app_id = app_id;
p_buf->p_app_data_cback = p_data_cback;
- p_buf->bta_av_cos = bta_av_cos;
+ p_buf->bta_av_cos = bta_av_cos;
bta_sys_sendmsg(p_buf);
}
}
{
BT_HDR *p_buf;
- if ((p_buf = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL)
- {
+ if ((p_buf = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL) {
p_buf->layer_specific = hndl;
p_buf->event = BTA_AV_API_DEREGISTER_EVT;
bta_sys_sendmsg(p_buf);
**
*******************************************************************************/
void BTA_AvOpen(BD_ADDR bd_addr, tBTA_AV_HNDL handle, BOOLEAN use_rc, tBTA_SEC sec_mask,
- UINT16 uuid)
+ UINT16 uuid)
{
tBTA_AV_API_OPEN *p_buf;
- if ((p_buf = (tBTA_AV_API_OPEN *) GKI_getbuf(sizeof(tBTA_AV_API_OPEN))) != NULL)
- {
+ if ((p_buf = (tBTA_AV_API_OPEN *) GKI_getbuf(sizeof(tBTA_AV_API_OPEN))) != NULL) {
p_buf->hdr.event = BTA_AV_API_OPEN_EVT;
p_buf->hdr.layer_specific = handle;
bdcpy(p_buf->bd_addr, bd_addr);
{
BT_HDR *p_buf;
- if ((p_buf = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL)
- {
+ if ((p_buf = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL) {
p_buf->event = BTA_AV_API_CLOSE_EVT;
p_buf->layer_specific = handle;
bta_sys_sendmsg(p_buf);
{
tBTA_AV_API_DISCNT *p_buf;
- if ((p_buf = (tBTA_AV_API_DISCNT *) GKI_getbuf(sizeof(tBTA_AV_API_DISCNT))) != NULL)
- {
+ if ((p_buf = (tBTA_AV_API_DISCNT *) GKI_getbuf(sizeof(tBTA_AV_API_DISCNT))) != NULL) {
p_buf->hdr.event = BTA_AV_API_DISCONNECT_EVT;
bdcpy(p_buf->bd_addr, bd_addr);
bta_sys_sendmsg(p_buf);
{
BT_HDR *p_buf;
- if ((p_buf = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL)
- {
+ if ((p_buf = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL) {
p_buf->event = BTA_AV_API_START_EVT;
bta_sys_sendmsg(p_buf);
}
{
#if (BTA_AV_SINK_INCLUDED == TRUE)
BT_HDR *p_buf;
- if ((p_buf = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL)
- {
+ if ((p_buf = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL) {
p_buf->event = BTA_AV_API_SINK_ENABLE_EVT;
p_buf->layer_specific = enable;
bta_sys_sendmsg(p_buf);
{
tBTA_AV_API_STOP *p_buf;
- if ((p_buf = (tBTA_AV_API_STOP *) GKI_getbuf(sizeof(tBTA_AV_API_STOP))) != NULL)
- {
+ if ((p_buf = (tBTA_AV_API_STOP *) GKI_getbuf(sizeof(tBTA_AV_API_STOP))) != NULL) {
p_buf->hdr.event = BTA_AV_API_STOP_EVT;
p_buf->flush = TRUE;
p_buf->suspend = suspend;
{
tBTA_AV_API_RCFG *p_buf;
- if ((p_buf = (tBTA_AV_API_RCFG *) GKI_getbuf((UINT16) (sizeof(tBTA_AV_API_RCFG) + num_protect))) != NULL)
- {
+ if ((p_buf = (tBTA_AV_API_RCFG *) GKI_getbuf((UINT16) (sizeof(tBTA_AV_API_RCFG) + num_protect))) != NULL) {
p_buf->hdr.layer_specific = hndl;
p_buf->hdr.event = BTA_AV_API_RECONFIG_EVT;
p_buf->num_protect = num_protect;
{
tBTA_AV_API_PROTECT_REQ *p_buf;
- if ((p_buf = (tBTA_AV_API_PROTECT_REQ *) GKI_getbuf((UINT16) (sizeof(tBTA_AV_API_PROTECT_REQ) + len))) != NULL)
- {
+ if ((p_buf = (tBTA_AV_API_PROTECT_REQ *) GKI_getbuf((UINT16) (sizeof(tBTA_AV_API_PROTECT_REQ) + len))) != NULL) {
p_buf->hdr.layer_specific = hndl;
p_buf->hdr.event = BTA_AV_API_PROTECT_REQ_EVT;
p_buf->len = len;
- if (p_data == NULL)
- {
+ if (p_data == NULL) {
p_buf->p_data = NULL;
- }
- else
- {
+ } else {
p_buf->p_data = (UINT8 *) (p_buf + 1);
memcpy(p_buf->p_data, p_data, len);
}
{
tBTA_AV_API_PROTECT_RSP *p_buf;
- if ((p_buf = (tBTA_AV_API_PROTECT_RSP *) GKI_getbuf((UINT16) (sizeof(tBTA_AV_API_PROTECT_RSP) + len))) != NULL)
- {
+ if ((p_buf = (tBTA_AV_API_PROTECT_RSP *) GKI_getbuf((UINT16) (sizeof(tBTA_AV_API_PROTECT_RSP) + len))) != NULL) {
p_buf->hdr.layer_specific = hndl;
p_buf->hdr.event = BTA_AV_API_PROTECT_RSP_EVT;
p_buf->len = len;
p_buf->error_code = error_code;
- if (p_data == NULL)
- {
+ if (p_data == NULL) {
p_buf->p_data = NULL;
- }
- else
- {
+ } else {
p_buf->p_data = (UINT8 *) (p_buf + 1);
memcpy(p_buf->p_data, p_data, len);
}
{
tBTA_AV_API_REMOTE_CMD *p_buf;
- if ((p_buf = (tBTA_AV_API_REMOTE_CMD *) GKI_getbuf(sizeof(tBTA_AV_API_REMOTE_CMD))) != NULL)
- {
+ if ((p_buf = (tBTA_AV_API_REMOTE_CMD *) GKI_getbuf(sizeof(tBTA_AV_API_REMOTE_CMD))) != NULL) {
p_buf->hdr.event = BTA_AV_API_REMOTE_CMD_EVT;
p_buf->hdr.layer_specific = rc_handle;
p_buf->msg.op_id = rc_id;
{
tBTA_AV_API_VENDOR *p_buf;
- if ((p_buf = (tBTA_AV_API_VENDOR *) GKI_getbuf((UINT16) (sizeof(tBTA_AV_API_VENDOR) + len))) != NULL)
- {
+ if ((p_buf = (tBTA_AV_API_VENDOR *) GKI_getbuf((UINT16) (sizeof(tBTA_AV_API_VENDOR) + len))) != NULL) {
p_buf->hdr.event = BTA_AV_API_VENDOR_CMD_EVT;
p_buf->hdr.layer_specific = rc_handle;
p_buf->msg.hdr.ctype = cmd_code;
p_buf->msg.company_id = p_bta_av_cfg->company_id;
p_buf->label = label;
p_buf->msg.vendor_len = len;
- if (p_data == NULL)
- {
+ if (p_data == NULL) {
p_buf->msg.p_vendor_data = NULL;
- }
- else
- {
+ } else {
p_buf->msg.p_vendor_data = (UINT8 *) (p_buf + 1);
memcpy(p_buf->msg.p_vendor_data, p_data, len);
}
{
tBTA_AV_API_VENDOR *p_buf;
- if ((p_buf = (tBTA_AV_API_VENDOR *) GKI_getbuf((UINT16) (sizeof(tBTA_AV_API_VENDOR) + len))) != NULL)
- {
+ if ((p_buf = (tBTA_AV_API_VENDOR *) GKI_getbuf((UINT16) (sizeof(tBTA_AV_API_VENDOR) + len))) != NULL) {
p_buf->hdr.event = BTA_AV_API_VENDOR_RSP_EVT;
p_buf->hdr.layer_specific = rc_handle;
p_buf->msg.hdr.ctype = rsp_code;
p_buf->msg.hdr.subunit_type = AVRC_SUB_PANEL;
p_buf->msg.hdr.subunit_id = 0;
- if(company_id)
+ if (company_id) {
p_buf->msg.company_id = company_id;
- else
+ } else {
p_buf->msg.company_id = p_bta_av_cfg->company_id;
+ }
p_buf->label = label;
p_buf->msg.vendor_len = len;
- if (p_data == NULL)
- {
+ if (p_data == NULL) {
p_buf->msg.p_vendor_data = NULL;
- }
- else
- {
+ } else {
p_buf->msg.p_vendor_data = (UINT8 *) (p_buf + 1);
memcpy(p_buf->msg.p_vendor_data, p_data, len);
}
{
tBTA_AV_API_OPEN_RC *p_buf;
- if ((p_buf = (tBTA_AV_API_OPEN_RC *) GKI_getbuf(sizeof(tBTA_AV_API_OPEN_RC))) != NULL)
- {
+ if ((p_buf = (tBTA_AV_API_OPEN_RC *) GKI_getbuf(sizeof(tBTA_AV_API_OPEN_RC))) != NULL) {
p_buf->hdr.event = BTA_AV_API_RC_OPEN_EVT;
p_buf->hdr.layer_specific = handle;
bta_sys_sendmsg(p_buf);
{
tBTA_AV_API_CLOSE_RC *p_buf;
- if ((p_buf = (tBTA_AV_API_CLOSE_RC *) GKI_getbuf(sizeof(tBTA_AV_API_CLOSE_RC))) != NULL)
- {
+ if ((p_buf = (tBTA_AV_API_CLOSE_RC *) GKI_getbuf(sizeof(tBTA_AV_API_CLOSE_RC))) != NULL) {
p_buf->hdr.event = BTA_AV_API_RC_CLOSE_EVT;
p_buf->hdr.layer_specific = rc_handle;
bta_sys_sendmsg(p_buf);
**
*******************************************************************************/
void BTA_AvMetaRsp(UINT8 rc_handle, UINT8 label, tBTA_AV_CODE rsp_code,
- BT_HDR *p_pkt)
+ BT_HDR *p_pkt)
{
tBTA_AV_API_META_RSP *p_buf;
- if ((p_buf = (tBTA_AV_API_META_RSP *) GKI_getbuf((UINT16) (sizeof(tBTA_AV_API_META_RSP)))) != NULL)
- {
+ if ((p_buf = (tBTA_AV_API_META_RSP *) GKI_getbuf((UINT16) (sizeof(tBTA_AV_API_META_RSP)))) != NULL) {
p_buf->hdr.event = BTA_AV_API_META_RSP_EVT;
p_buf->hdr.layer_specific = rc_handle;
p_buf->rsp_code = rsp_code;
{
tBTA_AV_API_META_RSP *p_buf;
- if ((p_buf = (tBTA_AV_API_META_RSP *) GKI_getbuf((UINT16) (sizeof(tBTA_AV_API_META_RSP)))) != NULL)
- {
+ if ((p_buf = (tBTA_AV_API_META_RSP *) GKI_getbuf((UINT16) (sizeof(tBTA_AV_API_META_RSP)))) != NULL) {
p_buf->hdr.event = BTA_AV_API_META_RSP_EVT;
p_buf->hdr.layer_specific = rc_handle;
p_buf->p_pkt = p_pkt;
#define BTA_AV_RC_SUPF_CT (AVRC_SUPF_CT_CAT2)
/* Added to modify
-** 1. flush timeout
-** 2. Remove Group navigation support in SupportedFeatures
-** 3. GetCapabilities supported event_ids list
-** 4. GetCapabilities supported event_ids count
+** 1. flush timeout
+** 2. Remove Group navigation support in SupportedFeatures
+** 3. GetCapabilities supported event_ids list
+** 4. GetCapabilities supported event_ids count
*/
/* Flushing partial avdtp packets can cause some headsets to disconnect the link
if receiving partial a2dp frames */
const UINT16 bta_av_audio_flush_to[] = {
- 0, /* 1 stream */
- 0, /* 2 streams */
- 0, /* 3 streams */
- 0, /* 4 streams */
- 0 /* 5 streams */
+ 0, /* 1 stream */
+ 0, /* 2 streams */
+ 0, /* 3 streams */
+ 0, /* 4 streams */
+ 0 /* 5 streams */
}; /* AVDTP audio transport channel flush timeout */
/* Note: Android doesnt support AVRC_SUPF_TG_GROUP_NAVI */
#define BTA_AV_MAX_RC_BR_MTU 1008
#endif
-const tBTA_AV_CFG bta_av_cfg =
-{
+const tBTA_AV_CFG bta_av_cfg = {
AVRC_CO_BROADCOM, /* AVRCP Company ID */
#if AVRC_METADATA_INCLUDED == TRUE
512, /* AVRCP MTU at L2CAP for control channel */
tBTA_AV_CFG *p_bta_av_cfg = (tBTA_AV_CFG *) &bta_av_cfg;
-const UINT16 bta_av_rc_id[] =
-{
+const UINT16 bta_av_rc_id[] = {
0x0000, /* bit mask: 0=SELECT, 1=UP, 2=DOWN, 3=LEFT,
4=RIGHT, 5=RIGHT_UP, 6=RIGHT_DOWN, 7=LEFT_UP,
8=LEFT_DOWN, 9=ROOT_MENU, 10=SETUP_MENU, 11=CONT_MENU,
};
#if (BTA_AV_RC_PASS_RSP_CODE == BTA_AV_RSP_INTERIM)
-const UINT16 bta_av_rc_id_ac[] =
-{
+const UINT16 bta_av_rc_id_ac[] = {
0x0000, /* bit mask: 0=SELECT, 1=UP, 2=DOWN, 3=LEFT,
4=RIGHT, 5=RIGHT_UP, 6=RIGHT_DOWN, 7=LEFT_UP,
8=LEFT_DOWN, 9=ROOT_MENU, 10=SETUP_MENU, 11=CONT_MENU,
{
BT_HDR *p_buf;
- if ((p_buf = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL)
- {
+ if ((p_buf = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL) {
p_buf->layer_specific = chnl;
p_buf->event = BTA_AV_CI_SRC_DATA_READY_EVT;
bta_sys_sendmsg(p_buf);
{
tBTA_AV_CI_SETCONFIG *p_buf;
- if ((p_buf = (tBTA_AV_CI_SETCONFIG *) GKI_getbuf(sizeof(tBTA_AV_CI_SETCONFIG))) != NULL)
- {
+ if ((p_buf = (tBTA_AV_CI_SETCONFIG *) GKI_getbuf(sizeof(tBTA_AV_CI_SETCONFIG))) != NULL) {
p_buf->hdr.layer_specific = hndl;
p_buf->hdr.event = (err_code == AVDT_SUCCESS) ?
BTA_AV_CI_SETCONFIG_OK_EVT : BTA_AV_CI_SETCONFIG_FAIL_EVT;
p_buf->category = category;
p_buf->recfg_needed = recfg_needed;
p_buf->num_seid = num_seid;
- p_buf->avdt_handle= avdt_handle;
- if(p_seid && num_seid)
- {
+ p_buf->avdt_handle = avdt_handle;
+ if (p_seid && num_seid) {
p_buf->p_seid = (UINT8 *)(p_buf + 1);
memcpy(p_buf->p_seid, p_seid, num_seid);
- }
- else
- {
+ } else {
p_buf->p_seid = NULL;
p_buf->num_seid = 0;
}
** Constants
*****************************************************************************/
-enum
-{
+enum {
/* these events are handled by the AV main state machine */
BTA_AV_API_DISABLE_EVT = BTA_SYS_EVT_START(BTA_ID_AV),
BTA_AV_API_REMOTE_CMD_EVT,
#if 0
/* function types for call-out functions */
typedef BOOLEAN (*tBTA_AV_CO_INIT) (UINT8 *p_codec_type, UINT8 *p_codec_info,
- UINT8 *p_num_protect, UINT8 *p_protect_info, UINT8 index);
+ UINT8 *p_num_protect, UINT8 *p_protect_info, UINT8 index);
typedef void (*tBTA_AV_CO_DISC_RES) (tBTA_AV_HNDL hndl, UINT8 num_seps,
UINT8 num_snk, UINT8 num_src, BD_ADDR addr, UINT16 uuid_local);
typedef UINT8 (*tBTA_AV_CO_GETCFG) (tBTA_AV_HNDL hndl, tBTA_AV_CODEC codec_type,
- UINT8 *p_codec_info, UINT8 *p_sep_info_idx, UINT8 seid,
- UINT8 *p_num_protect, UINT8 *p_protect_info);
+ UINT8 *p_codec_info, UINT8 *p_sep_info_idx, UINT8 seid,
+ UINT8 *p_num_protect, UINT8 *p_protect_info);
typedef void (*tBTA_AV_CO_SETCFG) (tBTA_AV_HNDL hndl, tBTA_AV_CODEC codec_type,
- UINT8 *p_codec_info, UINT8 seid, BD_ADDR addr,
- UINT8 num_protect, UINT8 *p_protect_info,
- UINT8 t_local_sep, UINT8 avdt_handle);
+ UINT8 *p_codec_info, UINT8 seid, BD_ADDR addr,
+ UINT8 num_protect, UINT8 *p_protect_info,
+ UINT8 t_local_sep, UINT8 avdt_handle);
typedef void (*tBTA_AV_CO_OPEN) (tBTA_AV_HNDL hndl,
tBTA_AV_CODEC codec_type, UINT8 *p_codec_info,
- UINT16 mtu);
+ UINT16 mtu);
typedef void (*tBTA_AV_CO_CLOSE) (tBTA_AV_HNDL hndl, tBTA_AV_CODEC codec_type, UINT16 mtu);
-typedef void (*tBTA_AV_CO_START) (tBTA_AV_HNDL hndl, tBTA_AV_CODEC codec_type,UINT8 *p_codec_info, BOOLEAN *p_no_rtp_hdr);
+typedef void (*tBTA_AV_CO_START) (tBTA_AV_HNDL hndl, tBTA_AV_CODEC codec_type, UINT8 *p_codec_info, BOOLEAN *p_no_rtp_hdr);
typedef void (*tBTA_AV_CO_STOP) (tBTA_AV_HNDL hndl, tBTA_AV_CODEC codec_type);
-typedef void * (*tBTA_AV_CO_DATAPATH) (tBTA_AV_CODEC codec_type,
- UINT32 *p_len, UINT32 *p_timestamp);
+typedef void *(*tBTA_AV_CO_DATAPATH) (tBTA_AV_CODEC codec_type,
+ UINT32 *p_len, UINT32 *p_timestamp);
typedef void (*tBTA_AV_CO_DELAY) (tBTA_AV_HNDL hndl, UINT16 delay);
/* the call-out functions for one stream */
-typedef struct
-{
+typedef struct {
tBTA_AV_CO_INIT init;
tBTA_AV_CO_DISC_RES disc_res;
tBTA_AV_CO_GETCFG getcfg;
#endif
/* data type for BTA_AV_API_ENABLE_EVT */
-typedef struct
-{
+typedef struct {
BT_HDR hdr;
tBTA_AV_CBACK *p_cback;
tBTA_AV_FEAT features;
} tBTA_AV_API_ENABLE;
/* data type for BTA_AV_API_REG_EVT */
-typedef struct
-{
+typedef struct {
BT_HDR hdr;
- char p_service_name[BTA_SERVICE_NAME_LEN+1];
+ char p_service_name[BTA_SERVICE_NAME_LEN + 1];
UINT8 app_id;
tBTA_AV_DATA_CBACK *p_app_data_cback;
tBTA_AV_CO_FUNCTS *bta_av_cos;
} tBTA_AV_API_REG;
-enum
-{
+enum {
BTA_AV_RS_NONE, /* straight API call */
BTA_AV_RS_OK, /* the role switch result - successful */
BTA_AV_RS_FAIL, /* the role switch result - failed */
};
typedef UINT8 tBTA_AV_RS_RES;
/* data type for BTA_AV_API_OPEN_EVT */
-typedef struct
-{
+typedef struct {
BT_HDR hdr;
BD_ADDR bd_addr;
BOOLEAN use_rc;
} tBTA_AV_API_OPEN;
/* data type for BTA_AV_API_STOP_EVT */
-typedef struct
-{
+typedef struct {
BT_HDR hdr;
BOOLEAN suspend;
BOOLEAN flush;
} tBTA_AV_API_STOP;
/* data type for BTA_AV_API_DISCONNECT_EVT */
-typedef struct
-{
+typedef struct {
BT_HDR hdr;
BD_ADDR bd_addr;
} tBTA_AV_API_DISCNT;
/* data type for BTA_AV_API_PROTECT_REQ_EVT */
-typedef struct
-{
+typedef struct {
BT_HDR hdr;
UINT8 *p_data;
UINT16 len;
} tBTA_AV_API_PROTECT_REQ;
/* data type for BTA_AV_API_PROTECT_RSP_EVT */
-typedef struct
-{
+typedef struct {
BT_HDR hdr;
UINT8 *p_data;
UINT16 len;
} tBTA_AV_API_PROTECT_RSP;
/* data type for BTA_AV_API_REMOTE_CMD_EVT */
-typedef struct
-{
+typedef struct {
BT_HDR hdr;
tAVRC_MSG_PASS msg;
UINT8 label;
} tBTA_AV_API_REMOTE_CMD;
/* data type for BTA_AV_API_VENDOR_CMD_EVT and RSP */
-typedef struct
-{
+typedef struct {
BT_HDR hdr;
tAVRC_MSG_VENDOR msg;
UINT8 label;
} tBTA_AV_API_VENDOR;
/* data type for BTA_AV_API_RC_OPEN_EVT */
-typedef struct
-{
+typedef struct {
BT_HDR hdr;
} tBTA_AV_API_OPEN_RC;
/* data type for BTA_AV_API_RC_CLOSE_EVT */
-typedef struct
-{
+typedef struct {
BT_HDR hdr;
} tBTA_AV_API_CLOSE_RC;
/* data type for BTA_AV_API_META_RSP_EVT */
-typedef struct
-{
+typedef struct {
BT_HDR hdr;
BOOLEAN is_rsp;
UINT8 label;
/* data type for BTA_AV_API_RECONFIG_EVT */
-typedef struct
-{
+typedef struct {
BT_HDR hdr;
UINT8 codec_info[AVDT_CODEC_SIZE]; /* codec configuration */
UINT8 *p_protect_info;
} tBTA_AV_API_RCFG;
/* data type for BTA_AV_CI_SETCONFIG_OK_EVT and BTA_AV_CI_SETCONFIG_FAIL_EVT */
-typedef struct
-{
+typedef struct {
BT_HDR hdr;
tBTA_AV_HNDL hndl;
UINT8 err_code;
} tBTA_AV_STR_MSG;
/* data type for BTA_AV_AVRC_MSG_EVT */
-typedef struct
-{
+typedef struct {
BT_HDR hdr;
tAVRC_MSG msg;
UINT8 handle;
} tBTA_AV_RC_MSG;
/* data type for BTA_AV_AVRC_OPEN_EVT, BTA_AV_AVRC_CLOSE_EVT */
-typedef struct
-{
+typedef struct {
BT_HDR hdr;
BD_ADDR peer_addr;
UINT8 handle;
} tBTA_AV_RC_CONN_CHG;
/* data type for BTA_AV_CONN_CHG_EVT */
-typedef struct
-{
+typedef struct {
BT_HDR hdr;
BD_ADDR peer_addr;
BOOLEAN is_up;
} tBTA_AV_CONN_CHG;
/* data type for BTA_AV_ROLE_CHANGE_EVT */
-typedef struct
-{
+typedef struct {
BT_HDR hdr;
UINT8 new_role;
UINT8 hci_status;
} tBTA_AV_ROLE_RES;
/* data type for BTA_AV_SDP_DISC_OK_EVT */
-typedef struct
-{
+typedef struct {
BT_HDR hdr;
UINT16 avdt_version; /* AVDTP protocol version */
} tBTA_AV_SDP_RES;
/* type for SEP control block */
-typedef struct
-{
+typedef struct {
UINT8 av_handle; /* AVDTP handle */
tBTA_AV_CODEC codec_type; /* codec type */
UINT8 tsep; /* SEP type of local SEP */
#define BTA_AV_ROLE_SUSPEND_OPT 0x40 /* Suspend on Start option is set */
/* union of all event datatypes */
-typedef union
-{
+typedef union {
BT_HDR hdr;
tBTA_AV_API_ENABLE api_enable;
tBTA_AV_API_REG api_reg;
typedef void (tBTA_AV_VDP_DATA_ACT)(void *p_scb);
-typedef struct
-{
+typedef struct {
tBTA_AV_VDP_DATA_ACT *p_act;
UINT8 *p_frame;
UINT16 buf_size;
UINT32 timestamp;
} tBTA_AV_VF_INFO;
-typedef union
-{
+typedef union {
tBTA_AV_VF_INFO vdp; /* used for video channels only */
tBTA_AV_API_OPEN open; /* used only before open and role switch
is needed on another AV channel */
#define BTA_AV_COLL_API_CALLED 0x02 /* API open was called while incoming timer is running */
/* type for AV stream control block */
-typedef struct
-{
+typedef struct {
const tBTA_AV_ACT *p_act_tbl; /* the action table for stream state machine */
const tBTA_AV_CO_FUNCTS *p_cos; /* the associated callout functions */
tSDP_DISCOVERY_DB *p_disc_db; /* pointer to discovery database */
/* type for AV RCP control block */
/* index to this control block is the rc handle */
-typedef struct
-{
+typedef struct {
UINT8 status;
UINT8 handle;
UINT8 shdl; /* stream handle (hdi + 1) */
} tBTA_AV_RCB;
#define BTA_AV_NUM_RCB (BTA_AV_NUM_STRS + 2)
-enum
-{
+enum {
BTA_AV_LCB_FREE,
BTA_AV_LCB_FIND
};
/* type for AV ACL Link control block */
-typedef struct
-{
+typedef struct {
BD_ADDR addr; /* peer BD address */
UINT8 conn_msk; /* handle mask of connected stream handle */
UINT8 lidx; /* index + 1 */
/* type for AV control block */
-typedef struct
-{
+typedef struct {
tBTA_AV_SCB *p_scb[BTA_AV_NUM_STRS]; /* stream control block */
tSDP_DISCOVERY_DB *p_disc_db; /* pointer to discovery database */
tBTA_AV_CBACK *p_cback; /* application callback function */
tBTA_AV_RCB rcb[BTA_AV_NUM_RCB]; /* RCB control block */
- tBTA_AV_LCB lcb[BTA_AV_NUM_LINKS+1]; /* link control block */
+ tBTA_AV_LCB lcb[BTA_AV_NUM_LINKS + 1]; /* link control block */
TIMER_LIST_ENT sig_tmr; /* link timer */
TIMER_LIST_ENT acp_sig_tmr; /* timer to monitor signalling when accepting */
UINT32 sdp_a2d_handle; /* SDP record handle for audio src */
extern const tBTA_AV_SACT bta_av_a2d_action[];
// extern const tBTA_AV_CO_FUNCTS bta_av_a2d_cos;
extern const tBTA_AV_SACT bta_av_vdp_action[];
-extern tAVDT_CTRL_CBACK * const bta_av_dt_cback[];
+extern tAVDT_CTRL_CBACK *const bta_av_dt_cback[];
extern void bta_av_stream_data_cback(UINT8 handle, BT_HDR *p_pkt, UINT32 time_stamp, UINT8 m_pt);
/*****************************************************************************
extern void bta_av_set_scb_sst_init (tBTA_AV_SCB *p_scb);
extern BOOLEAN bta_av_is_scb_init (tBTA_AV_SCB *p_scb);
extern void bta_av_set_scb_sst_incoming (tBTA_AV_SCB *p_scb);
-extern tBTA_AV_LCB * bta_av_find_lcb(BD_ADDR addr, UINT8 op);
+extern tBTA_AV_LCB *bta_av_find_lcb(BD_ADDR addr, UINT8 op);
/* main functions */
extern void bta_av_rc_free_rsp (tBTA_AV_CB *p_cb, tBTA_AV_DATA *p_data);
extern void bta_av_rc_free_msg (tBTA_AV_CB *p_cb, tBTA_AV_DATA *p_data);
-extern tBTA_AV_RCB * bta_av_get_rcb_by_shdl(UINT8 shdl);
+extern tBTA_AV_RCB *bta_av_get_rcb_by_shdl(UINT8 shdl);
extern void bta_av_del_rc(tBTA_AV_RCB *p_rcb);
/* ssm action functions */
#endif
/* state machine states */
-enum
-{
+enum {
BTA_AV_INIT_ST,
BTA_AV_OPEN_ST
};
/* state machine action enumeration list */
-enum
-{
+enum {
BTA_AV_DISABLE,
BTA_AV_RC_OPENED,
BTA_AV_RC_REMOTE_CMD,
typedef void (*tBTA_AV_ACTION)(tBTA_AV_CB *p_cb, tBTA_AV_DATA *p_data);
/* action functions */
-const tBTA_AV_ACTION bta_av_action[] =
-{
+const tBTA_AV_ACTION bta_av_action[] = {
bta_av_disable,
bta_av_rc_opened,
bta_av_rc_remote_cmd,
#define BTA_AV_NUM_COLS 2 /* number of columns in state tables */
/* state table for init state */
-static const UINT8 bta_av_st_init[][BTA_AV_NUM_COLS] =
-{
-/* Event Action 1 Next state */
-/* API_DISABLE_EVT */ {BTA_AV_DISABLE, BTA_AV_INIT_ST },
-/* API_REMOTE_CMD_EVT */ {BTA_AV_IGNORE, BTA_AV_INIT_ST },
-/* API_VENDOR_CMD_EVT */ {BTA_AV_IGNORE, BTA_AV_INIT_ST },
-/* API_VENDOR_RSP_EVT */ {BTA_AV_IGNORE, BTA_AV_INIT_ST },
-/* API_META_RSP_EVT */ {BTA_AV_RC_FREE_RSP, BTA_AV_INIT_ST },
-/* API_RC_CLOSE_EVT */ {BTA_AV_IGNORE, BTA_AV_INIT_ST },
-/* AVRC_OPEN_EVT */ {BTA_AV_RC_OPENED, BTA_AV_OPEN_ST },
-/* AVRC_MSG_EVT */ {BTA_AV_RC_FREE_MSG, BTA_AV_INIT_ST },
-/* AVRC_NONE_EVT */ {BTA_AV_IGNORE, BTA_AV_INIT_ST },
+static const UINT8 bta_av_st_init[][BTA_AV_NUM_COLS] = {
+ /* Event Action 1 Next state */
+ /* API_DISABLE_EVT */ {BTA_AV_DISABLE, BTA_AV_INIT_ST },
+ /* API_REMOTE_CMD_EVT */ {BTA_AV_IGNORE, BTA_AV_INIT_ST },
+ /* API_VENDOR_CMD_EVT */ {BTA_AV_IGNORE, BTA_AV_INIT_ST },
+ /* API_VENDOR_RSP_EVT */ {BTA_AV_IGNORE, BTA_AV_INIT_ST },
+ /* API_META_RSP_EVT */ {BTA_AV_RC_FREE_RSP, BTA_AV_INIT_ST },
+ /* API_RC_CLOSE_EVT */ {BTA_AV_IGNORE, BTA_AV_INIT_ST },
+ /* AVRC_OPEN_EVT */ {BTA_AV_RC_OPENED, BTA_AV_OPEN_ST },
+ /* AVRC_MSG_EVT */ {BTA_AV_RC_FREE_MSG, BTA_AV_INIT_ST },
+ /* AVRC_NONE_EVT */ {BTA_AV_IGNORE, BTA_AV_INIT_ST },
};
/* state table for open state */
-static const UINT8 bta_av_st_open[][BTA_AV_NUM_COLS] =
-{
-/* Event Action 1 Next state */
-/* API_DISABLE_EVT */ {BTA_AV_DISABLE, BTA_AV_INIT_ST },
-/* API_REMOTE_CMD_EVT */ {BTA_AV_RC_REMOTE_CMD, BTA_AV_OPEN_ST },
-/* API_VENDOR_CMD_EVT */ {BTA_AV_RC_VENDOR_CMD, BTA_AV_OPEN_ST },
-/* API_VENDOR_RSP_EVT */ {BTA_AV_RC_VENDOR_RSP, BTA_AV_OPEN_ST },
-/* API_META_RSP_EVT */ {BTA_AV_RC_META_RSP, BTA_AV_OPEN_ST },
-/* API_RC_CLOSE_EVT */ {BTA_AV_RC_CLOSE, BTA_AV_OPEN_ST },
-/* AVRC_OPEN_EVT */ {BTA_AV_RC_OPENED, BTA_AV_OPEN_ST },
-/* AVRC_MSG_EVT */ {BTA_AV_RC_MSG, BTA_AV_OPEN_ST },
-/* AVRC_NONE_EVT */ {BTA_AV_IGNORE, BTA_AV_INIT_ST },
+static const UINT8 bta_av_st_open[][BTA_AV_NUM_COLS] = {
+ /* Event Action 1 Next state */
+ /* API_DISABLE_EVT */ {BTA_AV_DISABLE, BTA_AV_INIT_ST },
+ /* API_REMOTE_CMD_EVT */ {BTA_AV_RC_REMOTE_CMD, BTA_AV_OPEN_ST },
+ /* API_VENDOR_CMD_EVT */ {BTA_AV_RC_VENDOR_CMD, BTA_AV_OPEN_ST },
+ /* API_VENDOR_RSP_EVT */ {BTA_AV_RC_VENDOR_RSP, BTA_AV_OPEN_ST },
+ /* API_META_RSP_EVT */ {BTA_AV_RC_META_RSP, BTA_AV_OPEN_ST },
+ /* API_RC_CLOSE_EVT */ {BTA_AV_RC_CLOSE, BTA_AV_OPEN_ST },
+ /* AVRC_OPEN_EVT */ {BTA_AV_RC_OPENED, BTA_AV_OPEN_ST },
+ /* AVRC_MSG_EVT */ {BTA_AV_RC_MSG, BTA_AV_OPEN_ST },
+ /* AVRC_NONE_EVT */ {BTA_AV_IGNORE, BTA_AV_INIT_ST },
};
/* type for state table */
typedef const UINT8 (*tBTA_AV_ST_TBL)[BTA_AV_NUM_COLS];
/* state table */
-static const tBTA_AV_ST_TBL bta_av_st_tbl[] =
-{
+static const tBTA_AV_ST_TBL bta_av_st_tbl[] = {
bta_av_st_init,
bta_av_st_open
};
static void bta_av_sco_chg_cback(tBTA_SYS_CONN_STATUS status, UINT8 id, UINT8
app_id, BD_ADDR peer_addr);
-static void bta_av_sys_rs_cback (tBTA_SYS_CONN_STATUS status,UINT8 id, UINT8 app_id, BD_ADDR peer_addr);
+static void bta_av_sys_rs_cback (tBTA_SYS_CONN_STATUS status, UINT8 id, UINT8 app_id, BD_ADDR peer_addr);
/* action functions */
-const tBTA_AV_NSM_ACT bta_av_nsm_act[] =
-{
+const tBTA_AV_NSM_ACT bta_av_nsm_act[] = {
bta_av_api_enable, /* BTA_AV_API_ENABLE_EVT */
bta_av_api_register, /* BTA_AV_API_REGISTER_EVT */
bta_av_api_deregister, /* BTA_AV_API_DEREGISTER_EVT */
tBTA_AV_SCB *p_scb = NULL;
/* find the SCB that has the timer */
- for(xx=0; xx<BTA_AV_NUM_STRS; xx++)
- {
- if(bta_av_cb.p_scb[xx] && &(bta_av_cb.p_scb[xx]->timer)== p)
- {
+ for (xx = 0; xx < BTA_AV_NUM_STRS; xx++) {
+ if (bta_av_cb.p_scb[xx] && &(bta_av_cb.p_scb[xx]->timer) == p) {
p_scb = bta_av_cb.p_scb[xx];
break;
}
}
- if (p_scb && (p_buf = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL)
- {
+ if (p_scb && (p_buf = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL) {
/* send the event through the audio state machine.
* only when the audio SM is open, the main SM opens the RC connection as INT */
p_buf->event = p->event;
/* initialize control block */
memset(&bta_av_cb, 0, sizeof(tBTA_AV_CB));
- for(i=0; i<BTA_AV_NUM_RCB; i++)
+ for (i = 0; i < BTA_AV_NUM_RCB; i++) {
bta_av_cb.rcb[i].handle = BTA_AV_RC_HANDLE_NONE;
+ }
bta_av_cb.rc_acp_handle = BTA_AV_RC_HANDLE_NONE;
enable.features = bta_av_cb.features;
/* Register for SCO change event */
- if (!(bta_av_cb.features & BTA_AV_FEAT_NO_SCO_SSPD))
- {
+ if (!(bta_av_cb.features & BTA_AV_FEAT_NO_SCO_SSPD)) {
bta_sys_sco_register(bta_av_sco_chg_cback);
}
** Returns void
**
*******************************************************************************/
-static tBTA_AV_SCB * bta_av_addr_to_scb(BD_ADDR bd_addr)
+static tBTA_AV_SCB *bta_av_addr_to_scb(BD_ADDR bd_addr)
{
- tBTA_AV_SCB * p_scb = NULL;
+ tBTA_AV_SCB *p_scb = NULL;
int xx;
- for(xx=0; xx<BTA_AV_NUM_STRS; xx++)
- {
- if(bta_av_cb.p_scb[xx])
- {
- if(!bdcmp(bd_addr, bta_av_cb.p_scb[xx]->peer_addr))
- {
+ for (xx = 0; xx < BTA_AV_NUM_STRS; xx++) {
+ if (bta_av_cb.p_scb[xx]) {
+ if (!bdcmp(bd_addr, bta_av_cb.p_scb[xx]->peer_addr)) {
p_scb = bta_av_cb.p_scb[xx];
break;
}
** Returns void
**
*******************************************************************************/
-tBTA_AV_SCB * bta_av_hndl_to_scb(UINT16 handle)
+tBTA_AV_SCB *bta_av_hndl_to_scb(UINT16 handle)
{
tBTA_AV_HNDL hndl = (tBTA_AV_HNDL)handle;
- tBTA_AV_SCB * p_scb = NULL;
+ tBTA_AV_SCB *p_scb = NULL;
UINT8 idx = (hndl & BTA_AV_HNDL_MSK);
- if(idx && (idx <= BTA_AV_NUM_STRS) )
- {
- p_scb = bta_av_cb.p_scb[idx-1];
+ if (idx && (idx <= BTA_AV_NUM_STRS) ) {
+ p_scb = bta_av_cb.p_scb[idx - 1];
}
return p_scb;
}
** Returns void
**
*******************************************************************************/
-static tBTA_AV_SCB * bta_av_alloc_scb(tBTA_AV_CHNL chnl)
+static tBTA_AV_SCB *bta_av_alloc_scb(tBTA_AV_CHNL chnl)
{
tBTA_AV_SCB *p_ret = NULL;
int xx;
tBTA_AV_STATUS sts = BTA_AV_SUCCESS;
- if(chnl == BTA_AV_CHNL_VIDEO)
- {
- if(p_bta_av_cfg->p_act_tbl == NULL || p_bta_av_cfg->p_reg == NULL)
- {
+ if (chnl == BTA_AV_CHNL_VIDEO) {
+ if (p_bta_av_cfg->p_act_tbl == NULL || p_bta_av_cfg->p_reg == NULL) {
APPL_TRACE_ERROR("Video streaming not supported");
sts = BTA_AV_FAIL;
- }
- else
- {
+ } else {
/* allow only one Video channel */
- if(bta_av_cb.reg_video)
- {
+ if (bta_av_cb.reg_video) {
APPL_TRACE_ERROR("Already registered");
sts = BTA_AV_FAIL;
}
}
- }
- else if(chnl != BTA_AV_CHNL_AUDIO)
- {
+ } else if (chnl != BTA_AV_CHNL_AUDIO) {
APPL_TRACE_ERROR("bad channel: %d\n", chnl);
sts = BTA_AV_FAIL;
}
- if(sts == BTA_AV_SUCCESS)
- {
- for(xx=0; xx<BTA_AV_NUM_STRS; xx++)
- {
- if(bta_av_cb.p_scb[xx] == NULL)
- {
+ if (sts == BTA_AV_SUCCESS) {
+ for (xx = 0; xx < BTA_AV_NUM_STRS; xx++) {
+ if (bta_av_cb.p_scb[xx] == NULL) {
/* found an empty spot */
p_ret = (tBTA_AV_SCB *)GKI_getbuf(sizeof(tBTA_AV_SCB));
- if(p_ret)
- {
+ if (p_ret) {
memset(p_ret, 0, sizeof(tBTA_AV_SCB));
p_ret->rc_handle = BTA_AV_RC_HANDLE_NONE;
p_ret->chnl = chnl;
#if( defined BTA_AR_INCLUDED ) && (BTA_AR_INCLUDED == TRUE)
if (event == BTA_AR_AVDT_CONN_EVT ||
- event == AVDT_CONNECT_IND_EVT || event == AVDT_DISCONNECT_IND_EVT)
+ event == AVDT_CONNECT_IND_EVT || event == AVDT_DISCONNECT_IND_EVT)
#else
if (event == AVDT_CONNECT_IND_EVT || event == AVDT_DISCONNECT_IND_EVT)
#endif
{
evt = BTA_AV_SIG_CHG_EVT;
- if(AVDT_DISCONNECT_IND_EVT == event)
+ if (AVDT_DISCONNECT_IND_EVT == event) {
p_scb = bta_av_addr_to_scb(bd_addr);
+ }
#if (defined(BTA_AV_DEBUG) && BTA_AV_DEBUG == TRUE)
- else if (AVDT_CONNECT_IND_EVT == event)
- {
+ else if (AVDT_CONNECT_IND_EVT == event) {
APPL_TRACE_DEBUG("CONN_IND is ACP:%d\n", p_data->hdr.err_param);
}
#endif
//(AVDT_CONNECT_IND_EVT == event && AVDT_ACP == p_data->hdr.err_param))
(AVDT_CONNECT_IND_EVT == event))&& */
- (p_msg = (tBTA_AV_STR_MSG *) GKI_getbuf((UINT16) (sizeof(tBTA_AV_STR_MSG)))) != NULL)
- {
+ (p_msg = (tBTA_AV_STR_MSG *) GKI_getbuf((UINT16) (sizeof(tBTA_AV_STR_MSG)))) != NULL) {
p_msg->hdr.event = evt;
p_msg->hdr.layer_specific = event;
p_msg->hdr.offset = p_data->hdr.err_param;
bdcpy(p_msg->bd_addr, bd_addr);
#if (defined(BTA_AV_DEBUG) && BTA_AV_DEBUG == TRUE)
- if(p_scb)
- {
+ if (p_scb) {
APPL_TRACE_DEBUG("scb hndl x%x, role x%x\n", p_scb->hndl, p_scb->role);
}
#endif
APPL_TRACE_DEBUG("conn_cback bd_addr:%02x-%02x-%02x-%02x-%02x-%02x\n",
- bd_addr[0], bd_addr[1],
- bd_addr[2], bd_addr[3],
- bd_addr[4], bd_addr[5]);
+ bd_addr[0], bd_addr[1],
+ bd_addr[2], bd_addr[3],
+ bd_addr[4], bd_addr[5]);
bta_sys_sendmsg(p_msg);
}
}
**
*******************************************************************************/
static void bta_av_a2dp_report_cback(UINT8 handle, AVDT_REPORT_TYPE type,
- tAVDT_REPORT_DATA *p_data)
+ tAVDT_REPORT_DATA *p_data)
{
UNUSED(handle);
UNUSED(type);
UINT16 activate_sink = 0;
activate_sink = p_data->hdr.layer_specific;
APPL_TRACE_DEBUG("bta_av_api_sink_enable %d \n", activate_sink)
- char p_service_name[BTA_SERVICE_NAME_LEN+1];
+ char p_service_name[BTA_SERVICE_NAME_LEN + 1];
BCM_STRNCPY_S(p_service_name, sizeof(p_service_name),
- BTIF_AVK_SERVICE_NAME, BTA_SERVICE_NAME_LEN);
+ BTIF_AVK_SERVICE_NAME, BTA_SERVICE_NAME_LEN);
- if(activate_sink)
- {
+ if (activate_sink) {
AVDT_SINK_Activate();
- if (bta_av_cb.sdp_a2d_snk_handle == 0)
- {
+ if (bta_av_cb.sdp_a2d_snk_handle == 0) {
bta_av_cb.sdp_a2d_snk_handle = SDP_CreateRecord();
A2D_AddRecord(UUID_SERVCLASS_AUDIO_SINK, p_service_name, NULL,
A2D_SUPF_PLAYER, bta_av_cb.sdp_a2d_snk_handle);
bta_sys_add_uuid(UUID_SERVCLASS_AUDIO_SINK);
}
- }
- else
- {
+ } else {
AVDT_SINK_Deactivate();
- if (bta_av_cb.sdp_a2d_snk_handle != 0)
- {
+ if (bta_av_cb.sdp_a2d_snk_handle != 0) {
SDP_DeleteRecord(bta_av_cb.sdp_a2d_snk_handle);
bta_av_cb.sdp_a2d_snk_handle = 0;
bta_sys_remove_uuid(UUID_SERVCLASS_AUDIO_SINK);
tBTA_AV_CODEC codec_type;
tBTA_UTL_COD cod;
UINT8 index = 0;
- char p_avk_service_name[BTA_SERVICE_NAME_LEN+1];
+ char p_avk_service_name[BTA_SERVICE_NAME_LEN + 1];
BCM_STRNCPY_S(p_avk_service_name, sizeof(p_avk_service_name), BTIF_AVK_SERVICE_NAME, BTA_SERVICE_NAME_LEN);
- memset(&cs,0,sizeof(tAVDT_CS));
+ memset(&cs, 0, sizeof(tAVDT_CS));
registr.status = BTA_AV_FAIL_RESOURCES;
registr.app_id = p_data->api_reg.app_id;
registr.chnl = (tBTA_AV_CHNL)p_data->hdr.layer_specific;
registr.p_bta_av_cos = p_data->api_reg.bta_av_cos;
- do
- {
+ do {
p_scb = bta_av_alloc_scb(registr.chnl);
- if(p_scb == NULL)
- {
+ if (p_scb == NULL) {
APPL_TRACE_ERROR("failed to alloc SCB");
break;
}
p_scb->app_id = registr.app_id;
/* initialize the stream control block */
- p_scb->timer.p_cback = (TIMER_CBACK*)&bta_av_timer_cback;
+ p_scb->timer.p_cback = (TIMER_CBACK *)&bta_av_timer_cback;
registr.status = BTA_AV_SUCCESS;
- if((bta_av_cb.reg_audio + bta_av_cb.reg_video) == 0)
- {
+ if ((bta_av_cb.reg_audio + bta_av_cb.reg_video) == 0) {
/* the first channel registered. register to AVDTP */
reg.ctrl_mtu = p_bta_av_cfg->sig_mtu;
reg.ret_tout = BTA_AV_RET_TOUT;
bta_sys_role_chg_register(&bta_av_sys_rs_cback);
/* create remote control TG service if required */
- if (bta_av_cb.features & (BTA_AV_FEAT_RCTG))
- {
+ if (bta_av_cb.features & (BTA_AV_FEAT_RCTG)) {
/* register with no authorization; let AVDTP use authorization instead */
#if( defined BTA_AR_INCLUDED ) && (BTA_AR_INCLUDED == TRUE)
#if (BTA_AV_WITH_AVCTP_AUTHORIZATION == TRUE)
cs.p_report_cback = NULL;
*/
cs.nsc_mask = AVDT_NSC_RECONFIG |
- ((bta_av_cb.features & BTA_AV_FEAT_PROTECT) ? 0 : AVDT_NSC_SECURITY);
+ ((bta_av_cb.features & BTA_AV_FEAT_PROTECT) ? 0 : AVDT_NSC_SECURITY);
APPL_TRACE_DEBUG("nsc_mask: 0x%x\n", cs.nsc_mask);
- if (p_data->api_reg.p_service_name[0] == 0)
- {
+ if (p_data->api_reg.p_service_name[0] == 0) {
p_service_name = NULL;
- }
- else
- {
+ } else {
p_service_name = p_data->api_reg.p_service_name;
}
p_scb->recfg_sup = TRUE;
cs.p_ctrl_cback = bta_av_dt_cback[p_scb->hdi];
- if(registr.chnl == BTA_AV_CHNL_AUDIO)
- {
+ if (registr.chnl == BTA_AV_CHNL_AUDIO) {
/* set up the audio stream control block */
p_scb->p_act_tbl = (const tBTA_AV_ACT *)bta_av_a2d_action;
// p_scb->p_cos = &bta_av_a2d_cos;
- p_scb->p_cos = registr.p_bta_av_cos;
- p_scb->media_type= AVDT_MEDIA_AUDIO;
+ p_scb->p_cos = registr.p_bta_av_cos;
+ p_scb->media_type = AVDT_MEDIA_AUDIO;
cs.cfg.psc_mask = AVDT_PSC_TRANS;
cs.media_type = AVDT_MEDIA_AUDIO;
cs.mtu = p_bta_av_cfg->audio_mtu;
cs.flush_to = L2CAP_DEFAULT_FLUSH_TO;
#if AVDT_REPORTING == TRUE
- if(bta_av_cb.features & BTA_AV_FEAT_REPORT)
- {
+ if (bta_av_cb.features & BTA_AV_FEAT_REPORT) {
cs.cfg.psc_mask |= AVDT_PSC_REPORT;
cs.p_report_cback = bta_av_a2dp_report_cback;
#if AVDT_MULTIPLEXING == TRUE
#endif
}
#endif
- if(bta_av_cb.features & BTA_AV_FEAT_DELAY_RPT)
+ if (bta_av_cb.features & BTA_AV_FEAT_DELAY_RPT) {
cs.cfg.psc_mask |= AVDT_PSC_DELAY_RPT;
+ }
/* keep the configuration in the stream control block */
memcpy(&p_scb->cfg, &cs.cfg, sizeof(tAVDT_CFG));
- while(index < BTA_AV_MAX_SEPS &&
- (p_scb->p_cos->init)(&codec_type, cs.cfg.codec_info,
- &cs.cfg.num_protect, cs.cfg.protect_info, index) == TRUE)
- {
+ while (index < BTA_AV_MAX_SEPS &&
+ (p_scb->p_cos->init)(&codec_type, cs.cfg.codec_info,
+ &cs.cfg.num_protect, cs.cfg.protect_info, index) == TRUE) {
#if (BTA_AV_SINK_INCLUDED == TRUE)
- if(index == 1)
- {
- cs.tsep = AVDT_TSEP_SNK;
- cs.p_data_cback = bta_av_stream_data_cback;
- }
- APPL_TRACE_DEBUG(" SEP Type = %d\n",cs.tsep);
+ if (index == 1) {
+ cs.tsep = AVDT_TSEP_SNK;
+ cs.p_data_cback = bta_av_stream_data_cback;
+ }
+ APPL_TRACE_DEBUG(" SEP Type = %d\n", cs.tsep);
#endif
- if(AVDT_CreateStream(&p_scb->seps[index].av_handle, &cs) == AVDT_SUCCESS)
- {
+ if (AVDT_CreateStream(&p_scb->seps[index].av_handle, &cs) == AVDT_SUCCESS) {
p_scb->seps[index].codec_type = codec_type;
#if (BTA_AV_SINK_INCLUDED == TRUE)
p_scb->seps[index].tsep = cs.tsep;
- if(cs.tsep == AVDT_TSEP_SNK)
+ if (cs.tsep == AVDT_TSEP_SNK) {
p_scb->seps[index].p_app_data_cback = p_data->api_reg.p_app_data_cback;
- else
- p_scb->seps[index].p_app_data_cback = NULL; /* In case of A2DP SOURCE we don't need a callback to handle media packets */
+ } else {
+ p_scb->seps[index].p_app_data_cback = NULL; /* In case of A2DP SOURCE we don't need a callback to handle media packets */
+ }
#endif
APPL_TRACE_DEBUG("audio[%d] av_handle: %d codec_type: %d\n",
- index, p_scb->seps[index].av_handle, p_scb->seps[index].codec_type);
+ index, p_scb->seps[index].av_handle, p_scb->seps[index].codec_type);
index++;
- }
- else
+ } else {
break;
+ }
}
- if(!bta_av_cb.reg_audio)
- {
+ if (!bta_av_cb.reg_audio) {
/* create the SDP records on the 1st audio channel */
bta_av_cb.sdp_a2d_handle = SDP_CreateRecord();
A2D_AddRecord(UUID_SERVCLASS_AUDIO_SOURCE, p_service_name, NULL,
- A2D_SUPF_PLAYER, bta_av_cb.sdp_a2d_handle);
+ A2D_SUPF_PLAYER, bta_av_cb.sdp_a2d_handle);
bta_sys_add_uuid(UUID_SERVCLASS_AUDIO_SOURCE);
#if (BTA_AV_SINK_INCLUDED == TRUE)
bta_av_cb.sdp_a2d_snk_handle = SDP_CreateRecord();
A2D_AddRecord(UUID_SERVCLASS_AUDIO_SINK, p_avk_service_name, NULL,
- A2D_SUPF_PLAYER, bta_av_cb.sdp_a2d_snk_handle);
+ A2D_SUPF_PLAYER, bta_av_cb.sdp_a2d_snk_handle);
bta_sys_add_uuid(UUID_SERVCLASS_AUDIO_SINK);
#endif
/* start listening when A2DP is registered */
- if (bta_av_cb.features & BTA_AV_FEAT_RCTG)
+ if (bta_av_cb.features & BTA_AV_FEAT_RCTG) {
bta_av_rc_create(&bta_av_cb, AVCT_ACP, 0, BTA_AV_NUM_LINKS + 1);
+ }
/* if the AV and AVK are both supported, it cannot support the CT role */
- if (bta_av_cb.features & (BTA_AV_FEAT_RCCT))
- {
+ if (bta_av_cb.features & (BTA_AV_FEAT_RCCT)) {
/* if TG is not supported, we need to register to AVCT now */
- if ((bta_av_cb.features & (BTA_AV_FEAT_RCTG)) == 0)
- {
+ if ((bta_av_cb.features & (BTA_AV_FEAT_RCTG)) == 0) {
#if( defined BTA_AR_INCLUDED ) && (BTA_AR_INCLUDED == TRUE)
#if (BTA_AV_WITH_AVCTP_AUTHORIZATION == TRUE)
bta_ar_reg_avct(p_bta_av_cfg->avrc_mtu, p_bta_av_cfg->avrc_br_mtu,
#if( defined BTA_AR_INCLUDED ) && (BTA_AR_INCLUDED == TRUE)
/* create an SDP record as AVRC CT. */
bta_ar_reg_avrc(UUID_SERVCLASS_AV_REMOTE_CONTROL, NULL, NULL,
- p_bta_av_cfg->avrc_ct_cat, BTA_ID_AV);
+ p_bta_av_cfg->avrc_ct_cat, BTA_ID_AV);
#endif
}
}
bta_av_cb.reg_audio |= BTA_AV_HNDL_TO_MSK(p_scb->hdi);
- APPL_TRACE_DEBUG("reg_audio: 0x%x\n",bta_av_cb.reg_audio);
- }
- else
- {
+ APPL_TRACE_DEBUG("reg_audio: 0x%x\n", bta_av_cb.reg_audio);
+ } else {
bta_av_cb.reg_video = BTA_AV_HNDL_TO_MSK(p_scb->hdi);
bta_av_cb.sdp_vdp_handle = SDP_CreateRecord();
/* register the video channel */
{
tBTA_AV_SCB *p_scb = bta_av_hndl_to_scb(p_data->hdr.layer_specific);
- if(p_scb)
- {
+ if (p_scb) {
p_scb->deregistring = TRUE;
bta_av_ssm_execute(p_scb, BTA_AV_API_CLOSE_EVT, p_data);
- }
- else
- {
+ } else {
bta_av_dereg_comp(p_data);
}
}
int i;
UINT8 chnl = (UINT8)p_data->hdr.layer_specific;
- for( i=0; i < BTA_AV_NUM_STRS; i++ )
- {
+ for ( i = 0; i < BTA_AV_NUM_STRS; i++ ) {
p_scb = bta_av_cb.p_scb[i];
- if(p_scb && p_scb->chnl == chnl)
- {
+ if (p_scb && p_scb->chnl == chnl) {
bta_av_ssm_execute(p_scb, BTA_AV_SRC_DATA_READY_EVT, p_data);
}
}
int xx;
UINT16 event = p_data->hdr.event - BTA_AV_FIRST_A2S_API_EVT + BTA_AV_FIRST_A2S_SSM_EVT;
- for(xx=0; xx<BTA_AV_NUM_STRS; xx++)
- {
+ for (xx = 0; xx < BTA_AV_NUM_STRS; xx++) {
bta_av_ssm_execute(bta_av_cb.p_scb[xx], event, p_data);
}
}
tBTA_AV_SCB *p_scbi;
int i;
- if(p_scb->chnl == BTA_AV_CHNL_AUDIO)
- {
+ if (p_scb->chnl == BTA_AV_CHNL_AUDIO) {
if ((bta_av_cb.audio_open_cnt >= 2) &&
- ((0 == (p_scb->role & BTA_AV_ROLE_AD_ACP)) || /* Outgoing connection or */
- (bta_av_cb.features & BTA_AV_FEAT_ACP_START))) /* auto-starting option */
- {
+ ((0 == (p_scb->role & BTA_AV_ROLE_AD_ACP)) || /* Outgoing connection or */
+ (bta_av_cb.features & BTA_AV_FEAT_ACP_START))) { /* auto-starting option */
/* more than one audio channel is connected */
/* if this is the 2nd stream as ACP, give INT a chance to issue the START command */
- for(i=0; i<BTA_AV_NUM_STRS; i++)
- {
+ for (i = 0; i < BTA_AV_NUM_STRS; i++) {
p_scbi = bta_av_cb.p_scb[i];
- if(p_scbi && p_scbi->chnl == BTA_AV_CHNL_AUDIO && p_scbi->co_started)
- {
+ if (p_scbi && p_scbi->chnl == BTA_AV_CHNL_AUDIO && p_scbi->co_started) {
start = TRUE;
/* may need to update the flush timeout of this already started stream */
- if(p_scbi->co_started != bta_av_cb.audio_open_cnt)
- {
+ if (p_scbi->co_started != bta_av_cb.audio_open_cnt) {
p_scbi->co_started = bta_av_cb.audio_open_cnt;
L2CA_SetFlushTimeout(p_scbi->peer_addr, p_bta_av_cfg->p_audio_flush_to[p_scbi->co_started - 1] );
}
int i;
UINT8 mask;
- APPL_TRACE_DEBUG("reg_audio: 0x%x\n",bta_av_cb.reg_audio);
- for(i=0; i<BTA_AV_NUM_STRS; i++)
- {
+ APPL_TRACE_DEBUG("reg_audio: 0x%x\n", bta_av_cb.reg_audio);
+ for (i = 0; i < BTA_AV_NUM_STRS; i++) {
mask = BTA_AV_HNDL_TO_MSK(i);
- if (p_cb->conn_audio == mask)
- {
- if (p_cb->p_scb[i])
- {
+ if (p_cb->conn_audio == mask) {
+ if (p_cb->p_scb[i]) {
bta_sys_set_policy(BTA_ID_AV, HCI_ENABLE_MASTER_SLAVE_SWITCH, p_cb->p_scb[i]->peer_addr);
}
break;
** Returns (BTA_SYS_ROLE_CHANGE, new_role, hci_status, p_bda)
**
*******************************************************************************/
-static void bta_av_sys_rs_cback (tBTA_SYS_CONN_STATUS status,UINT8 id, UINT8 app_id, BD_ADDR peer_addr)
+static void bta_av_sys_rs_cback (tBTA_SYS_CONN_STATUS status, UINT8 id, UINT8 app_id, BD_ADDR peer_addr)
{
int i;
tBTA_AV_SCB *p_scb = NULL;
UNUSED(status);
APPL_TRACE_DEBUG("bta_av_sys_rs_cback: %d\n", bta_av_cb.rs_idx);
- for(i=0; i<BTA_AV_NUM_STRS; i++)
- {
+ for (i = 0; i < BTA_AV_NUM_STRS; i++) {
/* loop through all the SCBs to find matching peer addresses and report the role change event */
/* note that more than one SCB (a2dp & vdp) maybe waiting for this event */
p_scb = bta_av_cb.p_scb[i];
if (p_scb && (bdcmp (peer_addr, p_scb->peer_addr) == 0) &&
- (p_buf = (tBTA_AV_ROLE_RES *) GKI_getbuf(sizeof(tBTA_AV_ROLE_RES))) != NULL)
- {
+ (p_buf = (tBTA_AV_ROLE_RES *) GKI_getbuf(sizeof(tBTA_AV_ROLE_RES))) != NULL) {
APPL_TRACE_DEBUG("new_role:%d, hci_status:x%x hndl: x%x\n", id, app_id, p_scb->hndl);
/*
if ((id != BTM_ROLE_MASTER) && (app_id != HCI_SUCCESS))
/* restore role switch policy, if role switch failed */
if ((HCI_SUCCESS != app_id) &&
- (BTM_GetRole (peer_addr, &cur_role) == BTM_SUCCESS) &&
- (cur_role == BTM_ROLE_SLAVE) )
- {
+ (BTM_GetRole (peer_addr, &cur_role) == BTM_SUCCESS) &&
+ (cur_role == BTM_ROLE_SLAVE) ) {
bta_sys_set_policy(BTA_ID_AV, HCI_ENABLE_MASTER_SLAVE_SWITCH, peer_addr);
}
/* if BTA_AvOpen() was called for other device, which caused the role switch of the peer_addr, */
/* we need to continue opening process for the BTA_AvOpen(). */
- if ((bta_av_cb.rs_idx != 0) && (bta_av_cb.rs_idx != peer_idx))
- {
- if ((bta_av_cb.rs_idx -1) < BTA_AV_NUM_STRS)
- {
+ if ((bta_av_cb.rs_idx != 0) && (bta_av_cb.rs_idx != peer_idx)) {
+ if ((bta_av_cb.rs_idx - 1) < BTA_AV_NUM_STRS) {
p_scb = bta_av_cb.p_scb[bta_av_cb.rs_idx - 1];
}
- if (p_scb && p_scb->q_tag == BTA_AV_Q_TAG_OPEN)
- {
+ if (p_scb && p_scb->q_tag == BTA_AV_Q_TAG_OPEN) {
APPL_TRACE_DEBUG ("bta_av_sys_rs_cback: rs_idx(%d), hndl:x%x q_tag: %d\n",
- bta_av_cb.rs_idx, p_scb->hndl, p_scb->q_tag);
+ bta_av_cb.rs_idx, p_scb->hndl, p_scb->q_tag);
- if(HCI_SUCCESS == app_id || HCI_ERR_NO_CONNECTION == app_id)
+ if (HCI_SUCCESS == app_id || HCI_ERR_NO_CONNECTION == app_id) {
p_scb->q_info.open.switch_res = BTA_AV_RS_OK;
- else
+ } else {
p_scb->q_info.open.switch_res = BTA_AV_RS_FAIL;
+ }
/* Continue av open process */
- bta_av_do_disc_a2d (p_scb, (tBTA_AV_DATA *)&(p_scb->q_info.open));
+ bta_av_do_disc_a2d (p_scb, (tBTA_AV_DATA *) & (p_scb->q_info.open));
}
bta_av_cb.rs_idx = 0;
UNUSED(peer_addr);
APPL_TRACE_DEBUG("bta_av_sco_chg_cback:%d status:%d\n", id, status);
- if(id)
- {
+ if (id) {
bta_av_cb.sco_occupied = TRUE;
/* either BTA_SYS_SCO_OPEN or BTA_SYS_SCO_CLOSE with remaining active SCO */
- for(i=0; i<BTA_AV_NUM_STRS; i++)
- {
+ for (i = 0; i < BTA_AV_NUM_STRS; i++) {
p_scb = bta_av_cb.p_scb[i];
- if( p_scb && p_scb->co_started && (p_scb->sco_suspend == FALSE))
- {
+ if ( p_scb && p_scb->co_started && (p_scb->sco_suspend == FALSE)) {
APPL_TRACE_DEBUG("suspending scb:%d\n", i);
/* scb is used and started, not suspended automatically */
p_scb->sco_suspend = TRUE;
bta_av_ssm_execute(p_scb, BTA_AV_AP_STOP_EVT, (tBTA_AV_DATA *)&stop);
}
}
- }
- else
- {
+ } else {
bta_av_cb.sco_occupied = FALSE;
- for(i=0; i<BTA_AV_NUM_STRS; i++)
- {
+ for (i = 0; i < BTA_AV_NUM_STRS; i++) {
p_scb = bta_av_cb.p_scb[i];
- if( p_scb && p_scb->sco_suspend ) /* scb is used and suspended for SCO */
- {
+ if ( p_scb && p_scb->sco_suspend ) { /* scb is used and suspended for SCO */
APPL_TRACE_DEBUG("starting scb:%d\n", i);
bta_av_ssm_execute(p_scb, BTA_AV_AP_START_EVT, NULL);
}
int i;
UINT8 mask;
- for(i=0; i<BTA_AV_NUM_STRS; i++)
- {
+ for (i = 0; i < BTA_AV_NUM_STRS; i++) {
mask = BTA_AV_HNDL_TO_MSK(i);
p_scbi = bta_av_cb.p_scb[i];
- if( p_scbi && (p_scb->hdi != i) && /* not the original channel */
- ((bta_av_cb.conn_audio & mask) ||/* connected audio */
- (bta_av_cb.conn_video & mask)) ) /* connected video */
- {
+ if ( p_scbi && (p_scb->hdi != i) && /* not the original channel */
+ ((bta_av_cb.conn_audio & mask) ||/* connected audio */
+ (bta_av_cb.conn_video & mask)) ) { /* connected video */
BTM_GetRole(p_scbi->peer_addr, &role);
/* this channel is open - clear the role switch link policy for this link */
- if(BTM_ROLE_MASTER != role)
- {
- if (bta_av_cb.features & BTA_AV_FEAT_MASTER)
+ if (BTM_ROLE_MASTER != role) {
+ if (bta_av_cb.features & BTA_AV_FEAT_MASTER) {
bta_sys_clear_policy(BTA_ID_AV, HCI_ENABLE_MASTER_SLAVE_SWITCH, p_scbi->peer_addr);
- if (BTM_CMD_STARTED != BTM_SwitchRole(p_scbi->peer_addr, BTM_ROLE_MASTER, NULL))
- {
+ }
+ if (BTM_CMD_STARTED != BTM_SwitchRole(p_scbi->peer_addr, BTM_ROLE_MASTER, NULL)) {
/* can not switch role on SCBI
* start the timer on SCB - because this function is ONLY called when SCB gets API_OPEN */
bta_sys_start_timer(&p_scb->timer, BTA_AV_AVRC_TIMER_EVT, BTA_AV_RS_TIME_VAL);
UINT8 role;
BOOLEAN is_ok = TRUE;
- if (BTM_GetRole(p_scb->peer_addr, &role) == BTM_SUCCESS)
- {
+ if (BTM_GetRole(p_scb->peer_addr, &role) == BTM_SUCCESS) {
LOG_INFO("%s hndl:x%x role:%d conn_audio:x%x bits:%d features:x%x\n",
- __func__, p_scb->hndl, role, bta_av_cb.conn_audio, bits,
- bta_av_cb.features);
- if (BTM_ROLE_MASTER != role && (A2D_BitsSet(bta_av_cb.conn_audio) > bits || (bta_av_cb.features & BTA_AV_FEAT_MASTER)))
- {
- if (bta_av_cb.features & BTA_AV_FEAT_MASTER)
+ __func__, p_scb->hndl, role, bta_av_cb.conn_audio, bits,
+ bta_av_cb.features);
+ if (BTM_ROLE_MASTER != role && (A2D_BitsSet(bta_av_cb.conn_audio) > bits || (bta_av_cb.features & BTA_AV_FEAT_MASTER))) {
+ if (bta_av_cb.features & BTA_AV_FEAT_MASTER) {
bta_sys_clear_policy(BTA_ID_AV, HCI_ENABLE_MASTER_SLAVE_SWITCH, p_scb->peer_addr);
+ }
- if (BTM_CMD_STARTED != BTM_SwitchRole(p_scb->peer_addr, BTM_ROLE_MASTER, NULL))
- {
+ if (BTM_CMD_STARTED != BTM_SwitchRole(p_scb->peer_addr, BTM_ROLE_MASTER, NULL)) {
/* can not switch role on SCB - start the timer on SCB */
}
is_ok = FALSE;
UNUSED(mtu);
/* TODO_MV mess with the mtu according to the number of EDR/non-EDR headsets */
- if(p_scb->chnl == BTA_AV_CHNL_AUDIO)
- {
- if(bta_av_cb.audio_open_cnt >= 2)
- {
+ if (p_scb->chnl == BTA_AV_CHNL_AUDIO) {
+ if (bta_av_cb.audio_open_cnt >= 2) {
/* more than one audio channel is connected */
- for(i=0; i<BTA_AV_NUM_STRS; i++)
- {
+ for (i = 0; i < BTA_AV_NUM_STRS; i++) {
p_scbi = bta_av_cb.p_scb[i];
- if((p_scb != p_scbi) && p_scbi && (p_scbi->chnl == BTA_AV_CHNL_AUDIO) )
- {
+ if ((p_scb != p_scbi) && p_scbi && (p_scbi->chnl == BTA_AV_CHNL_AUDIO) ) {
mask = BTA_AV_HNDL_TO_MSK(i);
APPL_TRACE_DEBUG("[%d] mtu: %d, mask:0x%x\n",
- i, p_scbi->stream_mtu, mask);
- if(bta_av_cb.conn_audio & mask)
- {
- if(ret_mtu > p_scbi->stream_mtu)
+ i, p_scbi->stream_mtu, mask);
+ if (bta_av_cb.conn_audio & mask) {
+ if (ret_mtu > p_scbi->stream_mtu) {
ret_mtu = p_scbi->stream_mtu;
+ }
}
}
}
}
APPL_TRACE_DEBUG("bta_av_chk_mtu audio count:%d, conn_audio:0x%x, ret:%d\n",
- bta_av_cb.audio_open_cnt, bta_av_cb.conn_audio, ret_mtu);
+ bta_av_cb.audio_open_cnt, bta_av_cb.conn_audio, ret_mtu);
}
return ret_mtu;
}
UINT16 size, copy_size;
BT_HDR *p_new;
- if(!p_buf)
+ if (!p_buf) {
return;
+ }
- if(bta_av_cb.audio_open_cnt >= 2)
- {
+ if (bta_av_cb.audio_open_cnt >= 2) {
size = GKI_get_buf_size(p_buf);
copy_size = BT_HDR_SIZE + p_buf->len + p_buf->offset;
/* more than one audio channel is connected */
- for(i=0; i<BTA_AV_NUM_STRS; i++)
- {
+ for (i = 0; i < BTA_AV_NUM_STRS; i++) {
p_scbi = bta_av_cb.p_scb[i];
- if( (p_scb->hdi != i) && /* not the original channel */
- (bta_av_cb.conn_audio & BTA_AV_HNDL_TO_MSK(i)) && /* connected audio */
- p_scbi && p_scbi->co_started ) /* scb is used and started */
- {
+ if ( (p_scb->hdi != i) && /* not the original channel */
+ (bta_av_cb.conn_audio & BTA_AV_HNDL_TO_MSK(i)) && /* connected audio */
+ p_scbi && p_scbi->co_started ) { /* scb is used and started */
/* enqueue the data only when the stream is started */
p_new = (BT_HDR *)GKI_getbuf(size);
- if(p_new)
- {
+ if (p_new) {
memcpy(p_new, p_buf, copy_size);
list_append(p_scbi->a2d_list, p_new);
if (list_length(p_scbi->a2d_list) > p_bta_av_cfg->audio_mqs) {
#if (defined(BTA_AV_DEBUG) && BTA_AV_DEBUG == TRUE)
APPL_TRACE_EVENT("AV event=0x%x(%s) state=%d(%s)\n",
- event, bta_av_evt_code(event), p_cb->state, bta_av_st_code(p_cb->state));
+ event, bta_av_evt_code(event), p_cb->state, bta_av_st_code(p_cb->state));
#else
APPL_TRACE_EVENT("AV event=0x%x state=%d\n", event, p_cb->state);
#endif
APPL_TRACE_EVENT("next state=%d\n", p_cb->state);
/* execute action functions */
- if ((action = state_table[event][BTA_AV_ACTION_COL]) != BTA_AV_IGNORE)
- {
+ if ((action = state_table[event][BTA_AV_ACTION_COL]) != BTA_AV_IGNORE) {
(*bta_av_action[action])(p_cb, p_data);
}
}
UINT16 event = p_msg->event;
UINT16 first_event = BTA_AV_FIRST_NSM_EVT;
- if (event > BTA_AV_LAST_EVT)
- {
+ if (event > BTA_AV_LAST_EVT) {
return TRUE; /* to free p_msg */
}
- if(event >= first_event)
- {
+ if (event >= first_event) {
#if (defined(BTA_AV_DEBUG) && BTA_AV_DEBUG == TRUE)
APPL_TRACE_VERBOSE("AV nsm event=0x%x(%s)\n", event, bta_av_evt_code(event));
#else
#endif
/* non state machine events */
(*bta_av_nsm_act[event - BTA_AV_FIRST_NSM_EVT]) ((tBTA_AV_DATA *) p_msg);
- }
- else if (event >= BTA_AV_FIRST_SM_EVT && event <= BTA_AV_LAST_SM_EVT)
- {
+ } else if (event >= BTA_AV_FIRST_SM_EVT && event <= BTA_AV_LAST_SM_EVT) {
#if (defined(BTA_AV_DEBUG) && BTA_AV_DEBUG == TRUE)
APPL_TRACE_VERBOSE("AV sm event=0x%x(%s)\n", event, bta_av_evt_code(event));
#else
#endif
/* state machine events */
bta_av_sm_execute(&bta_av_cb, p_msg->event, (tBTA_AV_DATA *) p_msg);
- }
- else
- {
+ } else {
APPL_TRACE_VERBOSE("handle=0x%x\n", p_msg->layer_specific);
/* stream state machine events */
bta_av_ssm_execute( bta_av_hndl_to_scb(p_msg->layer_specific),
- p_msg->event, (tBTA_AV_DATA *) p_msg);
+ p_msg->event, (tBTA_AV_DATA *) p_msg);
}
return TRUE;
}
*******************************************************************************/
static char *bta_av_st_code(UINT8 state)
{
- switch(state)
- {
+ switch (state) {
case BTA_AV_INIT_ST: return "INIT";
case BTA_AV_OPEN_ST: return "OPEN";
default: return "unknown";
*******************************************************************************/
char *bta_av_evt_code(UINT16 evt_code)
{
- switch(evt_code)
- {
+ switch (evt_code) {
case BTA_AV_API_DISABLE_EVT: return "API_DISABLE";
case BTA_AV_API_REMOTE_CMD_EVT: return "API_REMOTE_CMD";
case BTA_AV_API_VENDOR_CMD_EVT: return "API_VENDOR_CMD";
#if defined(BTA_AV_INCLUDED) && (BTA_AV_INCLUDED == TRUE)
typedef int (tBTA_AV_SBC_ACT)(void *p_src, void *p_dst,
- UINT32 src_samples, UINT32 dst_samples,
- UINT32 *p_ret);
+ UINT32 src_samples, UINT32 dst_samples,
+ UINT32 *p_ret);
-typedef struct
-{
+typedef struct {
INT32 cur_pos; /* current position */
UINT32 src_sps; /* samples per second (source audio data) */
UINT32 dst_sps; /* samples per second (converted audio data) */
bta_av_sbc_ups_cb.src_sps = src_sps;
bta_av_sbc_ups_cb.dst_sps = dst_sps;
bta_av_sbc_ups_cb.bits = bits;
- bta_av_sbc_ups_cb.n_channels= n_channels;
+ bta_av_sbc_ups_cb.n_channels = n_channels;
- if(n_channels == 1)
- {
+ if (n_channels == 1) {
/* mono */
- if(bits == 8)
- {
+ if (bits == 8) {
bta_av_sbc_ups_cb.p_act = bta_av_sbc_up_sample_8m;
bta_av_sbc_ups_cb.div = 1;
- }
- else
- {
+ } else {
bta_av_sbc_ups_cb.p_act = bta_av_sbc_up_sample_16m;
bta_av_sbc_ups_cb.div = 2;
}
- }
- else
- {
+ } else {
/* stereo */
- if(bits == 8)
- {
+ if (bits == 8) {
bta_av_sbc_ups_cb.p_act = bta_av_sbc_up_sample_8s;
bta_av_sbc_ups_cb.div = 2;
- }
- else
- {
+ } else {
bta_av_sbc_ups_cb.p_act = bta_av_sbc_up_sample_16s;
bta_av_sbc_ups_cb.div = 4;
}
**
*******************************************************************************/
int bta_av_sbc_up_sample (void *p_src, void *p_dst,
- UINT32 src_samples, UINT32 dst_samples,
- UINT32 *p_ret)
+ UINT32 src_samples, UINT32 dst_samples,
+ UINT32 *p_ret)
{
UINT32 src;
UINT32 dst;
- if(bta_av_sbc_ups_cb.p_act)
- {
- src = src_samples/bta_av_sbc_ups_cb.div;
- dst = dst_samples/bta_av_sbc_ups_cb.div;
+ if (bta_av_sbc_ups_cb.p_act) {
+ src = src_samples / bta_av_sbc_ups_cb.div;
+ dst = dst_samples / bta_av_sbc_ups_cb.div;
return (*bta_av_sbc_ups_cb.p_act)(p_src, p_dst, src, dst, p_ret);
- }
- else
- {
+ } else {
*p_ret = 0;
return 0;
}
**
*******************************************************************************/
int bta_av_sbc_up_sample_16s (void *p_src, void *p_dst,
- UINT32 src_samples, UINT32 dst_samples,
- UINT32 *p_ret)
+ UINT32 src_samples, UINT32 dst_samples,
+ UINT32 *p_ret)
{
INT16 *p_src_tmp = (INT16 *)p_src;
INT16 *p_dst_tmp = (INT16 *)p_dst;
UINT32 src_sps = bta_av_sbc_ups_cb.src_sps;
UINT32 dst_sps = bta_av_sbc_ups_cb.dst_sps;
- while (bta_av_sbc_ups_cb.cur_pos > 0 && dst_samples)
- {
+ while (bta_av_sbc_ups_cb.cur_pos > 0 && dst_samples) {
*p_dst_tmp++ = *p_worker1;
*p_dst_tmp++ = *p_worker2;
bta_av_sbc_ups_cb.cur_pos = dst_sps;
- while (src_samples-- && dst_samples)
- {
+ while (src_samples-- && dst_samples) {
*p_worker1 = *p_src_tmp++;
*p_worker2 = *p_src_tmp++;
- do
- {
+ do {
*p_dst_tmp++ = *p_worker1;
*p_dst_tmp++ = *p_worker2;
bta_av_sbc_ups_cb.cur_pos += dst_sps;
}
- if (bta_av_sbc_ups_cb.cur_pos == (INT32)dst_sps)
+ if (bta_av_sbc_ups_cb.cur_pos == (INT32)dst_sps) {
bta_av_sbc_ups_cb.cur_pos = 0;
+ }
*p_ret = ((char *)p_src_tmp - (char *)p_src);
return ((char *)p_dst_tmp - (char *)p_dst);
UINT32 src_sps = bta_av_sbc_ups_cb.src_sps;
UINT32 dst_sps = bta_av_sbc_ups_cb.dst_sps;
- while (bta_av_sbc_ups_cb.cur_pos > 0 && dst_samples)
- {
+ while (bta_av_sbc_ups_cb.cur_pos > 0 && dst_samples) {
*p_dst_tmp++ = *p_worker;
*p_dst_tmp++ = *p_worker;
bta_av_sbc_ups_cb.cur_pos = dst_sps;
- while (src_samples-- && dst_samples)
- {
+ while (src_samples-- && dst_samples) {
*p_worker = *p_src_tmp++;
- do
- {
+ do {
*p_dst_tmp++ = *p_worker;
*p_dst_tmp++ = *p_worker;
bta_av_sbc_ups_cb.cur_pos += dst_sps;
}
- if (bta_av_sbc_ups_cb.cur_pos == (INT32)dst_sps)
+ if (bta_av_sbc_ups_cb.cur_pos == (INT32)dst_sps) {
bta_av_sbc_ups_cb.cur_pos = 0;
+ }
*p_ret = ((char *)p_src_tmp - (char *)p_src);
return ((char *)p_dst_tmp - (char *)p_dst);
UINT32 src_sps = bta_av_sbc_ups_cb.src_sps;
UINT32 dst_sps = bta_av_sbc_ups_cb.dst_sps;
- while (bta_av_sbc_ups_cb.cur_pos > 0 && dst_samples)
- {
+ while (bta_av_sbc_ups_cb.cur_pos > 0 && dst_samples) {
*p_dst_tmp++ = *p_worker1;
*p_dst_tmp++ = *p_worker2;
bta_av_sbc_ups_cb.cur_pos = dst_sps;
- while (src_samples -- && dst_samples)
- {
+ while (src_samples -- && dst_samples) {
*p_worker1 = *(UINT8 *)p_src_tmp++;
*p_worker1 -= 0x80;
*p_worker1 <<= 8;
*p_worker2 -= 0x80;
*p_worker2 <<= 8;
- do
- {
+ do {
*p_dst_tmp++ = *p_worker1;
*p_dst_tmp++ = *p_worker2;
bta_av_sbc_ups_cb.cur_pos += dst_sps;
}
- if (bta_av_sbc_ups_cb.cur_pos == (INT32)dst_sps)
+ if (bta_av_sbc_ups_cb.cur_pos == (INT32)dst_sps) {
bta_av_sbc_ups_cb.cur_pos = 0;
+ }
*p_ret = ((char *)p_src_tmp - (char *)p_src);
return ((char *)p_dst_tmp - (char *)p_dst);
UINT32 src_sps = bta_av_sbc_ups_cb.src_sps;
UINT32 dst_sps = bta_av_sbc_ups_cb.dst_sps;
- while (bta_av_sbc_ups_cb.cur_pos > 0 && dst_samples)
- {
+ while (bta_av_sbc_ups_cb.cur_pos > 0 && dst_samples) {
*p_dst_tmp++ = *p_worker;
*p_dst_tmp++ = *p_worker;
bta_av_sbc_ups_cb.cur_pos = dst_sps;
- while (src_samples-- && dst_samples)
- {
+ while (src_samples-- && dst_samples) {
*p_worker = *(UINT8 *)p_src_tmp++;
*p_worker -= 0x80;
*p_worker <<= 8;
- do
- {
+ do {
*p_dst_tmp++ = *p_worker;
*p_dst_tmp++ = *p_worker;
bta_av_sbc_ups_cb.cur_pos += dst_sps;
}
- if (bta_av_sbc_ups_cb.cur_pos == (INT32)dst_sps)
+ if (bta_av_sbc_ups_cb.cur_pos == (INT32)dst_sps) {
bta_av_sbc_ups_cb.cur_pos = 0;
+ }
*p_ret = ((char *)p_src_tmp - (char *)p_src);
return ((char *)p_dst_tmp - (char *)p_dst);
UNUSED(p_cap);
/* parse peer capabilities */
- if ((status = A2D_ParsSbcInfo(&peer_cie, p_peer, TRUE)) != 0)
- {
+ if ((status = A2D_ParsSbcInfo(&peer_cie, p_peer, TRUE)) != 0) {
return status;
}
/* Check if the peer supports our channel mode */
- if (peer_cie.ch_mode & p_pref->ch_mode)
- {
+ if (peer_cie.ch_mode & p_pref->ch_mode) {
peer_cie.ch_mode = p_pref->ch_mode;
- }
- else
- {
+ } else {
APPL_TRACE_ERROR("bta_av_sbc_cfg_for_cap: ch_mode(0x%02X) not supported", p_pref->ch_mode);
return A2D_FAIL;
}
/* Check if the peer supports our sampling freq */
- if (peer_cie.samp_freq & p_pref->samp_freq)
- {
+ if (peer_cie.samp_freq & p_pref->samp_freq) {
peer_cie.samp_freq = p_pref->samp_freq;
- }
- else
- {
+ } else {
APPL_TRACE_ERROR("bta_av_sbc_cfg_for_cap: samp_freq(0x%02X) not supported", p_pref->samp_freq);
return A2D_FAIL;
}
/* Check if the peer supports our block len */
- if (peer_cie.block_len & p_pref->block_len)
- {
+ if (peer_cie.block_len & p_pref->block_len) {
peer_cie.block_len = p_pref->block_len;
- }
- else
- {
+ } else {
APPL_TRACE_ERROR("bta_av_sbc_cfg_for_cap: block_len(0x%02X) not supported", p_pref->block_len);
return A2D_FAIL;
}
/* Check if the peer supports our num subbands */
- if (peer_cie.num_subbands & p_pref->num_subbands)
- {
+ if (peer_cie.num_subbands & p_pref->num_subbands) {
peer_cie.num_subbands = p_pref->num_subbands;
- }
- else
- {
+ } else {
APPL_TRACE_ERROR("bta_av_sbc_cfg_for_cap: num_subbands(0x%02X) not supported", p_pref->num_subbands);
return A2D_FAIL;
}
/* Check if the peer supports our alloc method */
- if (peer_cie.alloc_mthd & p_pref->alloc_mthd)
- {
+ if (peer_cie.alloc_mthd & p_pref->alloc_mthd) {
peer_cie.alloc_mthd = p_pref->alloc_mthd;
- }
- else
- {
+ } else {
APPL_TRACE_ERROR("bta_av_sbc_cfg_for_cap: alloc_mthd(0x%02X) not supported", p_pref->alloc_mthd);
return A2D_FAIL;
}
/* max bitpool */
- if (p_pref->max_bitpool != 0 && p_pref->max_bitpool < peer_cie.max_bitpool)
- {
+ if (p_pref->max_bitpool != 0 && p_pref->max_bitpool < peer_cie.max_bitpool) {
peer_cie.max_bitpool = p_pref->max_bitpool;
}
/* min bitpool */
- if (p_pref->min_bitpool != 0 && p_pref->min_bitpool > peer_cie.min_bitpool)
- {
+ if (p_pref->min_bitpool != 0 && p_pref->min_bitpool > peer_cie.min_bitpool) {
peer_cie.min_bitpool = p_pref->min_bitpool;
}
- if (status == A2D_SUCCESS)
- {
+ if (status == A2D_SUCCESS) {
/* build configuration */
A2D_BldSbcInfo(A2D_MEDIA_TYPE_AUDIO, &peer_cie, p_peer);
}
tA2D_SBC_CIE cfg_cie;
/* parse configuration */
- if ((status = A2D_ParsSbcInfo(&cfg_cie, p_cfg, TRUE)) != 0)
- {
+ if ((status = A2D_ParsSbcInfo(&cfg_cie, p_cfg, TRUE)) != 0) {
APPL_TRACE_ERROR(" bta_av_sbc_cfg_matches_cap Parsing Failed %d", status);
return status;
}
APPL_TRACE_DEBUG(" Min_bitpool peer: 0%x, capability 0%x", cfg_cie.min_bitpool, p_cap->min_bitpool);
/* sampling frequency */
- if ((cfg_cie.samp_freq & p_cap->samp_freq) == 0)
- {
+ if ((cfg_cie.samp_freq & p_cap->samp_freq) == 0) {
status = A2D_NS_SAMP_FREQ;
}
/* channel mode */
- else if ((cfg_cie.ch_mode & p_cap->ch_mode) == 0)
- {
+ else if ((cfg_cie.ch_mode & p_cap->ch_mode) == 0) {
status = A2D_NS_CH_MODE;
}
/* block length */
- else if ((cfg_cie.block_len & p_cap->block_len) == 0)
- {
+ else if ((cfg_cie.block_len & p_cap->block_len) == 0) {
status = A2D_BAD_BLOCK_LEN;
}
/* subbands */
- else if ((cfg_cie.num_subbands & p_cap->num_subbands) == 0)
- {
+ else if ((cfg_cie.num_subbands & p_cap->num_subbands) == 0) {
status = A2D_NS_SUBBANDS;
}
/* allocation method */
- else if ((cfg_cie.alloc_mthd & p_cap->alloc_mthd) == 0)
- {
+ else if ((cfg_cie.alloc_mthd & p_cap->alloc_mthd) == 0) {
status = A2D_NS_ALLOC_MTHD;
}
/* max bitpool */
- else if (cfg_cie.max_bitpool > p_cap->max_bitpool)
- {
+ else if (cfg_cie.max_bitpool > p_cap->max_bitpool) {
status = A2D_NS_MAX_BITPOOL;
}
/* min bitpool */
- else if (cfg_cie.min_bitpool < p_cap->min_bitpool)
- {
+ else if (cfg_cie.min_bitpool < p_cap->min_bitpool) {
status = A2D_NS_MIN_BITPOOL;
}
tA2D_SBC_CIE cfg_cie;
/* parse configuration */
- if ((status = A2D_ParsSbcInfo(&cfg_cie, p_cfg, FALSE)) != 0)
- {
+ if ((status = A2D_ParsSbcInfo(&cfg_cie, p_cfg, FALSE)) != 0) {
return status;
}
/* sampling frequency */
- if ((cfg_cie.samp_freq & p_cap->samp_freq) == 0)
- {
+ if ((cfg_cie.samp_freq & p_cap->samp_freq) == 0) {
status = A2D_NS_SAMP_FREQ;
}
/* channel mode */
- else if ((cfg_cie.ch_mode & p_cap->ch_mode) == 0)
- {
+ else if ((cfg_cie.ch_mode & p_cap->ch_mode) == 0) {
status = A2D_NS_CH_MODE;
}
/* block length */
- else if ((cfg_cie.block_len & p_cap->block_len) == 0)
- {
+ else if ((cfg_cie.block_len & p_cap->block_len) == 0) {
status = A2D_BAD_BLOCK_LEN;
}
/* subbands */
- else if ((cfg_cie.num_subbands & p_cap->num_subbands) == 0)
- {
+ else if ((cfg_cie.num_subbands & p_cap->num_subbands) == 0) {
status = A2D_NS_SUBBANDS;
}
/* allocation method */
- else if ((cfg_cie.alloc_mthd & p_cap->alloc_mthd) == 0)
- {
+ else if ((cfg_cie.alloc_mthd & p_cap->alloc_mthd) == 0) {
status = A2D_NS_ALLOC_MTHD;
}
/* max bitpool */
- else if (cfg_cie.max_bitpool > p_cap->max_bitpool)
- {
+ else if (cfg_cie.max_bitpool > p_cap->max_bitpool) {
status = A2D_NS_MAX_BITPOOL;
}
/* min bitpool */
- else if (cfg_cie.min_bitpool < p_cap->min_bitpool)
- {
+ else if (cfg_cie.min_bitpool < p_cap->min_bitpool) {
status = A2D_NS_MIN_BITPOOL;
}
*****************************************************************************/
/* state machine states */
-enum
-{
+enum {
BTA_AV_INIT_SST,
BTA_AV_INCOMING_SST,
BTA_AV_OPENING_SST,
/* state machine action enumeration list */
-enum
-{
+enum {
BTA_AV_DO_DISC,
BTA_AV_CLEANUP,
BTA_AV_FREE_SDB,
#define BTA_AV_NUM_COLS 3 /* number of columns in state tables */
/* state table for init state */
-static const UINT8 bta_av_sst_init[][BTA_AV_NUM_COLS] =
-{
-/* Event Action 1 Action 2 Next state */
-/* AP_OPEN_EVT */ {BTA_AV_DO_DISC, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
-/* AP_CLOSE_EVT */ {BTA_AV_CLEANUP, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* AP_START_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* AP_STOP_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* API_RECONFIG_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* API_PROTECT_REQ_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* API_PROTECT_RSP_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* API_RC_OPEN_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* SRC_DATA_READY_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* CI_SETCONFIG_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* CI_SETCONFIG_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* SDP_DISC_OK_EVT */ {BTA_AV_FREE_SDB, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* SDP_DISC_FAIL_EVT */ {BTA_AV_FREE_SDB, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* STR_DISC_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* STR_DISC_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* STR_GETCAP_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* STR_GETCAP_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* STR_OPEN_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* STR_OPEN_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* STR_START_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* STR_START_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* STR_CLOSE_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* STR_CONFIG_IND_EVT */ {BTA_AV_SETCONFIG_REJ, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* STR_SECURITY_IND_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* STR_SECURITY_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* STR_WRITE_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* STR_SUSPEND_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* STR_RECONFIG_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* AVRC_TIMER_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* AVDT_CONNECT_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* AVDT_DISCONNECT_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* ROLE_CHANGE_EVT*/ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* AVDT_DELAY_RPT_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* ACP_CONNECT_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST }
+static const UINT8 bta_av_sst_init[][BTA_AV_NUM_COLS] = {
+ /* Event Action 1 Action 2 Next state */
+ /* AP_OPEN_EVT */ {BTA_AV_DO_DISC, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
+ /* AP_CLOSE_EVT */ {BTA_AV_CLEANUP, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* AP_START_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* AP_STOP_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* API_RECONFIG_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* API_PROTECT_REQ_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* API_PROTECT_RSP_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* API_RC_OPEN_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* SRC_DATA_READY_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* CI_SETCONFIG_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* CI_SETCONFIG_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* SDP_DISC_OK_EVT */ {BTA_AV_FREE_SDB, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* SDP_DISC_FAIL_EVT */ {BTA_AV_FREE_SDB, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* STR_DISC_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* STR_DISC_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* STR_GETCAP_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* STR_GETCAP_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* STR_OPEN_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* STR_OPEN_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* STR_START_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* STR_START_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* STR_CLOSE_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* STR_CONFIG_IND_EVT */ {BTA_AV_SETCONFIG_REJ, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* STR_SECURITY_IND_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* STR_SECURITY_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* STR_WRITE_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* STR_SUSPEND_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* STR_RECONFIG_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* AVRC_TIMER_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* AVDT_CONNECT_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* AVDT_DISCONNECT_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* ROLE_CHANGE_EVT*/ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* AVDT_DELAY_RPT_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* ACP_CONNECT_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST }
};
/* state table for incoming state */
-static const UINT8 bta_av_sst_incoming[][BTA_AV_NUM_COLS] =
-{
-/* Event Action 1 Action 2 Next state */
-/* AP_OPEN_EVT */ {BTA_AV_OPEN_AT_INC, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
-/* AP_CLOSE_EVT */ {BTA_AV_CCO_CLOSE, BTA_AV_DISCONNECT_REQ, BTA_AV_CLOSING_SST },
-/* AP_START_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
-/* AP_STOP_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
-/* API_RECONFIG_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
-/* API_PROTECT_REQ_EVT */ {BTA_AV_SECURITY_REQ, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
-/* API_PROTECT_RSP_EVT */ {BTA_AV_SECURITY_RSP, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
-/* API_RC_OPEN_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
-/* SRC_DATA_READY_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
-/* CI_SETCONFIG_OK_EVT */ {BTA_AV_SETCONFIG_RSP, BTA_AV_ST_RC_TIMER, BTA_AV_INCOMING_SST },
-/* CI_SETCONFIG_FAIL_EVT */ {BTA_AV_SETCONFIG_REJ, BTA_AV_CLEANUP, BTA_AV_INIT_SST },
-/* SDP_DISC_OK_EVT */ {BTA_AV_FREE_SDB, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
-/* SDP_DISC_FAIL_EVT */ {BTA_AV_FREE_SDB, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
-/* STR_DISC_OK_EVT */ {BTA_AV_DISC_RES_AS_ACP,BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
-/* STR_DISC_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
-/* STR_GETCAP_OK_EVT */ {BTA_AV_SAVE_CAPS, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
-/* STR_GETCAP_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
-/* STR_OPEN_OK_EVT */ {BTA_AV_STR_OPENED, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
-/* STR_OPEN_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
-/* STR_START_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
-/* STR_START_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
-/* STR_CLOSE_EVT */ {BTA_AV_CCO_CLOSE, BTA_AV_CLEANUP, BTA_AV_INIT_SST },
-/* STR_CONFIG_IND_EVT */ {BTA_AV_CONFIG_IND, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
-/* STR_SECURITY_IND_EVT */ {BTA_AV_SECURITY_IND, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
-/* STR_SECURITY_CFM_EVT */ {BTA_AV_SECURITY_CFM, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
-/* STR_WRITE_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
-/* STR_SUSPEND_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
-/* STR_RECONFIG_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
-/* AVRC_TIMER_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
-/* AVDT_CONNECT_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
-/* AVDT_DISCONNECT_EVT */ {BTA_AV_CCO_CLOSE, BTA_AV_CLEANUP, BTA_AV_INIT_SST },
-/* ROLE_CHANGE_EVT*/ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
-/* AVDT_DELAY_RPT_EVT */ {BTA_AV_DELAY_CO, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
-/* ACP_CONNECT_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST }
+static const UINT8 bta_av_sst_incoming[][BTA_AV_NUM_COLS] = {
+ /* Event Action 1 Action 2 Next state */
+ /* AP_OPEN_EVT */ {BTA_AV_OPEN_AT_INC, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
+ /* AP_CLOSE_EVT */ {BTA_AV_CCO_CLOSE, BTA_AV_DISCONNECT_REQ, BTA_AV_CLOSING_SST },
+ /* AP_START_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
+ /* AP_STOP_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
+ /* API_RECONFIG_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
+ /* API_PROTECT_REQ_EVT */ {BTA_AV_SECURITY_REQ, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
+ /* API_PROTECT_RSP_EVT */ {BTA_AV_SECURITY_RSP, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
+ /* API_RC_OPEN_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
+ /* SRC_DATA_READY_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
+ /* CI_SETCONFIG_OK_EVT */ {BTA_AV_SETCONFIG_RSP, BTA_AV_ST_RC_TIMER, BTA_AV_INCOMING_SST },
+ /* CI_SETCONFIG_FAIL_EVT */ {BTA_AV_SETCONFIG_REJ, BTA_AV_CLEANUP, BTA_AV_INIT_SST },
+ /* SDP_DISC_OK_EVT */ {BTA_AV_FREE_SDB, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
+ /* SDP_DISC_FAIL_EVT */ {BTA_AV_FREE_SDB, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
+ /* STR_DISC_OK_EVT */ {BTA_AV_DISC_RES_AS_ACP, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
+ /* STR_DISC_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
+ /* STR_GETCAP_OK_EVT */ {BTA_AV_SAVE_CAPS, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
+ /* STR_GETCAP_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
+ /* STR_OPEN_OK_EVT */ {BTA_AV_STR_OPENED, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
+ /* STR_OPEN_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
+ /* STR_START_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
+ /* STR_START_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
+ /* STR_CLOSE_EVT */ {BTA_AV_CCO_CLOSE, BTA_AV_CLEANUP, BTA_AV_INIT_SST },
+ /* STR_CONFIG_IND_EVT */ {BTA_AV_CONFIG_IND, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
+ /* STR_SECURITY_IND_EVT */ {BTA_AV_SECURITY_IND, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
+ /* STR_SECURITY_CFM_EVT */ {BTA_AV_SECURITY_CFM, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
+ /* STR_WRITE_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
+ /* STR_SUSPEND_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
+ /* STR_RECONFIG_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
+ /* AVRC_TIMER_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
+ /* AVDT_CONNECT_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
+ /* AVDT_DISCONNECT_EVT */ {BTA_AV_CCO_CLOSE, BTA_AV_CLEANUP, BTA_AV_INIT_SST },
+ /* ROLE_CHANGE_EVT*/ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
+ /* AVDT_DELAY_RPT_EVT */ {BTA_AV_DELAY_CO, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
+ /* ACP_CONNECT_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST }
};
/* state table for opening state */
-static const UINT8 bta_av_sst_opening[][BTA_AV_NUM_COLS] =
-{
-/* Event Action 1 Action 2 Next state */
-/* AP_OPEN_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
-/* AP_CLOSE_EVT */ {BTA_AV_DO_CLOSE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* AP_START_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
-/* AP_STOP_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
-/* API_RECONFIG_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
-/* API_PROTECT_REQ_EVT */ {BTA_AV_SECURITY_REQ, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
-/* API_PROTECT_RSP_EVT */ {BTA_AV_SECURITY_RSP, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
-/* API_RC_OPEN_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
-/* SRC_DATA_READY_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
-/* CI_SETCONFIG_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
-/* CI_SETCONFIG_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
-/* SDP_DISC_OK_EVT */ {BTA_AV_CONNECT_REQ, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
-/* SDP_DISC_FAIL_EVT */ {BTA_AV_CONNECT_REQ, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
-/* STR_DISC_OK_EVT */ {BTA_AV_DISC_RESULTS, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
-/* STR_DISC_FAIL_EVT */ {BTA_AV_OPEN_FAILED, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* STR_GETCAP_OK_EVT */ {BTA_AV_GETCAP_RESULTS, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
-/* STR_GETCAP_FAIL_EVT */ {BTA_AV_OPEN_FAILED, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* STR_OPEN_OK_EVT */ {BTA_AV_ST_RC_TIMER, BTA_AV_STR_OPENED, BTA_AV_OPEN_SST },
-/* STR_OPEN_FAIL_EVT */ {BTA_AV_OPEN_FAILED, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* STR_START_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
-/* STR_START_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
-/* STR_CLOSE_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
-/* STR_CONFIG_IND_EVT */ {BTA_AV_CONFIG_IND, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
-/* STR_SECURITY_IND_EVT */ {BTA_AV_SECURITY_IND, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
-/* STR_SECURITY_CFM_EVT */ {BTA_AV_SECURITY_CFM, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
-/* STR_WRITE_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
-/* STR_SUSPEND_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
-/* STR_RECONFIG_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
-/* AVRC_TIMER_EVT */ {BTA_AV_SWITCH_ROLE, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
-/* AVDT_CONNECT_EVT */ {BTA_AV_DISCOVER_REQ, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
-/* AVDT_DISCONNECT_EVT */ {BTA_AV_CONN_FAILED, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* ROLE_CHANGE_EVT*/ {BTA_AV_ROLE_RES, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
-/* AVDT_DELAY_RPT_EVT */ {BTA_AV_DELAY_CO, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
-/* ACP_CONNECT_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPENING_SST }
+static const UINT8 bta_av_sst_opening[][BTA_AV_NUM_COLS] = {
+ /* Event Action 1 Action 2 Next state */
+ /* AP_OPEN_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
+ /* AP_CLOSE_EVT */ {BTA_AV_DO_CLOSE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* AP_START_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
+ /* AP_STOP_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
+ /* API_RECONFIG_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
+ /* API_PROTECT_REQ_EVT */ {BTA_AV_SECURITY_REQ, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
+ /* API_PROTECT_RSP_EVT */ {BTA_AV_SECURITY_RSP, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
+ /* API_RC_OPEN_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
+ /* SRC_DATA_READY_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
+ /* CI_SETCONFIG_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
+ /* CI_SETCONFIG_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
+ /* SDP_DISC_OK_EVT */ {BTA_AV_CONNECT_REQ, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
+ /* SDP_DISC_FAIL_EVT */ {BTA_AV_CONNECT_REQ, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
+ /* STR_DISC_OK_EVT */ {BTA_AV_DISC_RESULTS, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
+ /* STR_DISC_FAIL_EVT */ {BTA_AV_OPEN_FAILED, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* STR_GETCAP_OK_EVT */ {BTA_AV_GETCAP_RESULTS, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
+ /* STR_GETCAP_FAIL_EVT */ {BTA_AV_OPEN_FAILED, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* STR_OPEN_OK_EVT */ {BTA_AV_ST_RC_TIMER, BTA_AV_STR_OPENED, BTA_AV_OPEN_SST },
+ /* STR_OPEN_FAIL_EVT */ {BTA_AV_OPEN_FAILED, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* STR_START_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
+ /* STR_START_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
+ /* STR_CLOSE_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
+ /* STR_CONFIG_IND_EVT */ {BTA_AV_CONFIG_IND, BTA_AV_SIGNORE, BTA_AV_INCOMING_SST },
+ /* STR_SECURITY_IND_EVT */ {BTA_AV_SECURITY_IND, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
+ /* STR_SECURITY_CFM_EVT */ {BTA_AV_SECURITY_CFM, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
+ /* STR_WRITE_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
+ /* STR_SUSPEND_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
+ /* STR_RECONFIG_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
+ /* AVRC_TIMER_EVT */ {BTA_AV_SWITCH_ROLE, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
+ /* AVDT_CONNECT_EVT */ {BTA_AV_DISCOVER_REQ, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
+ /* AVDT_DISCONNECT_EVT */ {BTA_AV_CONN_FAILED, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* ROLE_CHANGE_EVT*/ {BTA_AV_ROLE_RES, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
+ /* AVDT_DELAY_RPT_EVT */ {BTA_AV_DELAY_CO, BTA_AV_SIGNORE, BTA_AV_OPENING_SST },
+ /* ACP_CONNECT_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPENING_SST }
};
/* state table for open state */
-static const UINT8 bta_av_sst_open[][BTA_AV_NUM_COLS] =
-{
-/* Event Action 1 Action 2 Next state */
-/* AP_OPEN_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
-/* AP_CLOSE_EVT */ {BTA_AV_DO_CLOSE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* AP_START_EVT */ {BTA_AV_DO_START, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
-/* AP_STOP_EVT */ {BTA_AV_STR_STOPPED, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
-/* API_RECONFIG_EVT */ {BTA_AV_RECONFIG, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
-/* API_PROTECT_REQ_EVT */ {BTA_AV_SECURITY_REQ, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
-/* API_PROTECT_RSP_EVT */ {BTA_AV_SECURITY_RSP, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
-/* API_RC_OPEN_EVT */ {BTA_AV_SET_USE_RC, BTA_AV_OPEN_RC, BTA_AV_OPEN_SST },
-/* SRC_DATA_READY_EVT */ {BTA_AV_DATA_PATH, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
-/* CI_SETCONFIG_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
-/* CI_SETCONFIG_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
-/* SDP_DISC_OK_EVT */ {BTA_AV_FREE_SDB, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
-/* SDP_DISC_FAIL_EVT */ {BTA_AV_FREE_SDB, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
-/* STR_DISC_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
-/* STR_DISC_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
-/* STR_GETCAP_OK_EVT */ {BTA_AV_SAVE_CAPS, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
-/* STR_GETCAP_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
-/* STR_OPEN_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
-/* STR_OPEN_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
-/* STR_START_OK_EVT */ {BTA_AV_START_OK, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
-/* STR_START_FAIL_EVT */ {BTA_AV_START_FAILED, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
-/* STR_CLOSE_EVT */ {BTA_AV_STR_CLOSED, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* STR_CONFIG_IND_EVT */ {BTA_AV_SETCONFIG_REJ, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
-/* STR_SECURITY_IND_EVT */ {BTA_AV_SECURITY_IND, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
-/* STR_SECURITY_CFM_EVT */ {BTA_AV_SECURITY_CFM, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
-/* STR_WRITE_CFM_EVT */ {BTA_AV_CLR_CONG, BTA_AV_DATA_PATH, BTA_AV_OPEN_SST },
-/* STR_SUSPEND_CFM_EVT */ {BTA_AV_SUSPEND_CFM, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
-/* STR_RECONFIG_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
-/* AVRC_TIMER_EVT */ {BTA_AV_OPEN_RC, BTA_AV_CHK_2ND_START, BTA_AV_OPEN_SST },
-/* AVDT_CONNECT_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
-/* AVDT_DISCONNECT_EVT */ {BTA_AV_STR_CLOSED, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* ROLE_CHANGE_EVT*/ {BTA_AV_ROLE_RES, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
-/* AVDT_DELAY_RPT_EVT */ {BTA_AV_DELAY_CO, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
-/* ACP_CONNECT_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPEN_SST }
+static const UINT8 bta_av_sst_open[][BTA_AV_NUM_COLS] = {
+ /* Event Action 1 Action 2 Next state */
+ /* AP_OPEN_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
+ /* AP_CLOSE_EVT */ {BTA_AV_DO_CLOSE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* AP_START_EVT */ {BTA_AV_DO_START, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
+ /* AP_STOP_EVT */ {BTA_AV_STR_STOPPED, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
+ /* API_RECONFIG_EVT */ {BTA_AV_RECONFIG, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
+ /* API_PROTECT_REQ_EVT */ {BTA_AV_SECURITY_REQ, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
+ /* API_PROTECT_RSP_EVT */ {BTA_AV_SECURITY_RSP, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
+ /* API_RC_OPEN_EVT */ {BTA_AV_SET_USE_RC, BTA_AV_OPEN_RC, BTA_AV_OPEN_SST },
+ /* SRC_DATA_READY_EVT */ {BTA_AV_DATA_PATH, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
+ /* CI_SETCONFIG_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
+ /* CI_SETCONFIG_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
+ /* SDP_DISC_OK_EVT */ {BTA_AV_FREE_SDB, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
+ /* SDP_DISC_FAIL_EVT */ {BTA_AV_FREE_SDB, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
+ /* STR_DISC_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
+ /* STR_DISC_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
+ /* STR_GETCAP_OK_EVT */ {BTA_AV_SAVE_CAPS, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
+ /* STR_GETCAP_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
+ /* STR_OPEN_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
+ /* STR_OPEN_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
+ /* STR_START_OK_EVT */ {BTA_AV_START_OK, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
+ /* STR_START_FAIL_EVT */ {BTA_AV_START_FAILED, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
+ /* STR_CLOSE_EVT */ {BTA_AV_STR_CLOSED, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* STR_CONFIG_IND_EVT */ {BTA_AV_SETCONFIG_REJ, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
+ /* STR_SECURITY_IND_EVT */ {BTA_AV_SECURITY_IND, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
+ /* STR_SECURITY_CFM_EVT */ {BTA_AV_SECURITY_CFM, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
+ /* STR_WRITE_CFM_EVT */ {BTA_AV_CLR_CONG, BTA_AV_DATA_PATH, BTA_AV_OPEN_SST },
+ /* STR_SUSPEND_CFM_EVT */ {BTA_AV_SUSPEND_CFM, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
+ /* STR_RECONFIG_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
+ /* AVRC_TIMER_EVT */ {BTA_AV_OPEN_RC, BTA_AV_CHK_2ND_START, BTA_AV_OPEN_SST },
+ /* AVDT_CONNECT_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
+ /* AVDT_DISCONNECT_EVT */ {BTA_AV_STR_CLOSED, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* ROLE_CHANGE_EVT*/ {BTA_AV_ROLE_RES, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
+ /* AVDT_DELAY_RPT_EVT */ {BTA_AV_DELAY_CO, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
+ /* ACP_CONNECT_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_OPEN_SST }
};
/* state table for reconfig state */
-static const UINT8 bta_av_sst_rcfg[][BTA_AV_NUM_COLS] =
-{
-/* Event Action 1 Action 2 Next state */
-/* AP_OPEN_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
-/* AP_CLOSE_EVT */ {BTA_AV_DISCONNECT_REQ, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* AP_START_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
-/* AP_STOP_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
-/* API_RECONFIG_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
-/* API_PROTECT_REQ_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
-/* API_PROTECT_RSP_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
-/* API_RC_OPEN_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
-/* SRC_DATA_READY_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
-/* CI_SETCONFIG_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
-/* CI_SETCONFIG_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
-/* SDP_DISC_OK_EVT */ {BTA_AV_FREE_SDB, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
-/* SDP_DISC_FAIL_EVT */ {BTA_AV_FREE_SDB, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
-/* STR_DISC_OK_EVT */ {BTA_AV_DISC_RESULTS, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
-/* STR_DISC_FAIL_EVT */ {BTA_AV_STR_CLOSED, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* STR_GETCAP_OK_EVT */ {BTA_AV_GETCAP_RESULTS, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
-/* STR_GETCAP_FAIL_EVT */ {BTA_AV_STR_CLOSED, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* STR_OPEN_OK_EVT */ {BTA_AV_RCFG_STR_OK, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
-/* STR_OPEN_FAIL_EVT */ {BTA_AV_RCFG_FAILED, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
-/* STR_START_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
-/* STR_START_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
-/* STR_CLOSE_EVT */ {BTA_AV_RCFG_CONNECT, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
-/* STR_CONFIG_IND_EVT */ {BTA_AV_SETCONFIG_REJ, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
-/* STR_SECURITY_IND_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
-/* STR_SECURITY_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
-/* STR_WRITE_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
-/* STR_SUSPEND_CFM_EVT */ {BTA_AV_SUSPEND_CONT, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
-/* STR_RECONFIG_CFM_EVT */ {BTA_AV_RCFG_CFM, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
-/* AVRC_TIMER_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
-/* AVDT_CONNECT_EVT */ {BTA_AV_RCFG_OPEN, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
-/* AVDT_DISCONNECT_EVT */ {BTA_AV_RCFG_DISCNTD, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
-/* ROLE_CHANGE_EVT*/ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
-/* AVDT_DELAY_RPT_EVT */ {BTA_AV_DELAY_CO, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
-/* ACP_CONNECT_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST }
+static const UINT8 bta_av_sst_rcfg[][BTA_AV_NUM_COLS] = {
+ /* Event Action 1 Action 2 Next state */
+ /* AP_OPEN_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
+ /* AP_CLOSE_EVT */ {BTA_AV_DISCONNECT_REQ, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* AP_START_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
+ /* AP_STOP_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
+ /* API_RECONFIG_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
+ /* API_PROTECT_REQ_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
+ /* API_PROTECT_RSP_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
+ /* API_RC_OPEN_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
+ /* SRC_DATA_READY_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
+ /* CI_SETCONFIG_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
+ /* CI_SETCONFIG_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
+ /* SDP_DISC_OK_EVT */ {BTA_AV_FREE_SDB, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
+ /* SDP_DISC_FAIL_EVT */ {BTA_AV_FREE_SDB, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
+ /* STR_DISC_OK_EVT */ {BTA_AV_DISC_RESULTS, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
+ /* STR_DISC_FAIL_EVT */ {BTA_AV_STR_CLOSED, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* STR_GETCAP_OK_EVT */ {BTA_AV_GETCAP_RESULTS, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
+ /* STR_GETCAP_FAIL_EVT */ {BTA_AV_STR_CLOSED, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* STR_OPEN_OK_EVT */ {BTA_AV_RCFG_STR_OK, BTA_AV_SIGNORE, BTA_AV_OPEN_SST },
+ /* STR_OPEN_FAIL_EVT */ {BTA_AV_RCFG_FAILED, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
+ /* STR_START_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
+ /* STR_START_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
+ /* STR_CLOSE_EVT */ {BTA_AV_RCFG_CONNECT, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
+ /* STR_CONFIG_IND_EVT */ {BTA_AV_SETCONFIG_REJ, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
+ /* STR_SECURITY_IND_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
+ /* STR_SECURITY_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
+ /* STR_WRITE_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
+ /* STR_SUSPEND_CFM_EVT */ {BTA_AV_SUSPEND_CONT, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
+ /* STR_RECONFIG_CFM_EVT */ {BTA_AV_RCFG_CFM, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
+ /* AVRC_TIMER_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
+ /* AVDT_CONNECT_EVT */ {BTA_AV_RCFG_OPEN, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
+ /* AVDT_DISCONNECT_EVT */ {BTA_AV_RCFG_DISCNTD, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
+ /* ROLE_CHANGE_EVT*/ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
+ /* AVDT_DELAY_RPT_EVT */ {BTA_AV_DELAY_CO, BTA_AV_SIGNORE, BTA_AV_RCFG_SST },
+ /* ACP_CONNECT_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_RCFG_SST }
};
/* state table for closing state */
-static const UINT8 bta_av_sst_closing[][BTA_AV_NUM_COLS] =
-{
-/* Event Action 1 Action 2 Next state */
-/* AP_OPEN_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* AP_CLOSE_EVT */ {BTA_AV_DISCONNECT_REQ, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* AP_START_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* AP_STOP_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* API_RECONFIG_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* API_PROTECT_REQ_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* API_PROTECT_RSP_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* API_RC_OPEN_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* SRC_DATA_READY_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* CI_SETCONFIG_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* CI_SETCONFIG_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* SDP_DISC_OK_EVT */ {BTA_AV_SDP_FAILED, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* SDP_DISC_FAIL_EVT */ {BTA_AV_SDP_FAILED, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* STR_DISC_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* STR_DISC_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* STR_GETCAP_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* STR_GETCAP_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* STR_OPEN_OK_EVT */ {BTA_AV_DO_CLOSE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* STR_OPEN_FAIL_EVT */ {BTA_AV_DISCONNECT_REQ, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* STR_START_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* STR_START_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* STR_CLOSE_EVT */ {BTA_AV_DISCONNECT_REQ, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* STR_CONFIG_IND_EVT */ {BTA_AV_SETCONFIG_REJ, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* STR_SECURITY_IND_EVT */ {BTA_AV_SECURITY_REJ, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* STR_SECURITY_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* STR_WRITE_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* STR_SUSPEND_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* STR_RECONFIG_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* AVRC_TIMER_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* AVDT_CONNECT_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* AVDT_DISCONNECT_EVT */ {BTA_AV_STR_CLOSED, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
-/* ROLE_CHANGE_EVT*/ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* AVDT_DELAY_RPT_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
-/* ACP_CONNECT_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST }
+static const UINT8 bta_av_sst_closing[][BTA_AV_NUM_COLS] = {
+ /* Event Action 1 Action 2 Next state */
+ /* AP_OPEN_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* AP_CLOSE_EVT */ {BTA_AV_DISCONNECT_REQ, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* AP_START_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* AP_STOP_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* API_RECONFIG_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* API_PROTECT_REQ_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* API_PROTECT_RSP_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* API_RC_OPEN_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* SRC_DATA_READY_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* CI_SETCONFIG_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* CI_SETCONFIG_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* SDP_DISC_OK_EVT */ {BTA_AV_SDP_FAILED, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* SDP_DISC_FAIL_EVT */ {BTA_AV_SDP_FAILED, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* STR_DISC_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* STR_DISC_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* STR_GETCAP_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* STR_GETCAP_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* STR_OPEN_OK_EVT */ {BTA_AV_DO_CLOSE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* STR_OPEN_FAIL_EVT */ {BTA_AV_DISCONNECT_REQ, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* STR_START_OK_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* STR_START_FAIL_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* STR_CLOSE_EVT */ {BTA_AV_DISCONNECT_REQ, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* STR_CONFIG_IND_EVT */ {BTA_AV_SETCONFIG_REJ, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* STR_SECURITY_IND_EVT */ {BTA_AV_SECURITY_REJ, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* STR_SECURITY_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* STR_WRITE_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* STR_SUSPEND_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* STR_RECONFIG_CFM_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* AVRC_TIMER_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* AVDT_CONNECT_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* AVDT_DISCONNECT_EVT */ {BTA_AV_STR_CLOSED, BTA_AV_SIGNORE, BTA_AV_INIT_SST },
+ /* ROLE_CHANGE_EVT*/ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* AVDT_DELAY_RPT_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST },
+ /* ACP_CONNECT_EVT */ {BTA_AV_SIGNORE, BTA_AV_SIGNORE, BTA_AV_CLOSING_SST }
};
/* type for state table */
typedef const UINT8 (*tBTA_AV_SST_TBL)[BTA_AV_NUM_COLS];
/* state table */
-static const tBTA_AV_SST_TBL bta_av_sst_tbl[] =
-{
+static const tBTA_AV_SST_TBL bta_av_sst_tbl[] = {
bta_av_sst_init,
bta_av_sst_incoming,
bta_av_sst_opening,
{
BOOLEAN is_rcfg_sst = FALSE;
- if (p_scb != NULL)
- {
- if (p_scb->state == BTA_AV_RCFG_SST)
+ if (p_scb != NULL) {
+ if (p_scb->state == BTA_AV_RCFG_SST) {
is_rcfg_sst = TRUE;
+ }
}
return is_rcfg_sst;
UINT8 action;
int i, xx;
- if(p_scb == NULL)
- {
+ if (p_scb == NULL) {
/* this stream is not registered */
APPL_TRACE_EVENT("AV channel not registered");
return;
/* When ACP_CONNECT_EVT was received, we put first available scb to */
/* to Incoming state. Later, when STR_CONFIG_IND_EVT is coming, we */
/* know if it is A2DP or VDP. */
- if ((p_scb->state == BTA_AV_INIT_SST) && (event == BTA_AV_STR_CONFIG_IND_EVT))
- {
- for (xx = 0; xx < BTA_AV_NUM_STRS; xx++)
- {
- if (bta_av_cb.p_scb[xx])
- {
- if (bta_av_cb.p_scb[xx]->state == BTA_AV_INCOMING_SST)
- {
+ if ((p_scb->state == BTA_AV_INIT_SST) && (event == BTA_AV_STR_CONFIG_IND_EVT)) {
+ for (xx = 0; xx < BTA_AV_NUM_STRS; xx++) {
+ if (bta_av_cb.p_scb[xx]) {
+ if (bta_av_cb.p_scb[xx]->state == BTA_AV_INCOMING_SST) {
bta_av_cb.p_scb[xx]->state = BTA_AV_INIT_SST;
bta_av_cb.p_scb[xx]->coll_mask = 0;
p_scb->state = BTA_AV_INCOMING_SST;
#if (defined(BTA_AV_DEBUG) && BTA_AV_DEBUG == TRUE)
APPL_TRACE_VERBOSE("AV Sevent(0x%x)=0x%x(%s) state=%d(%s)",
- p_scb->hndl, event, bta_av_evt_code(event), p_scb->state, bta_av_sst_code(p_scb->state));
+ p_scb->hndl, event, bta_av_evt_code(event), p_scb->state, bta_av_sst_code(p_scb->state));
#else
APPL_TRACE_VERBOSE("AV Sevent=0x%x state=%d", event, p_scb->state);
#endif
p_scb->state = state_table[event][BTA_AV_SNEXT_STATE];
/* execute action functions */
- for(i=0; i< BTA_AV_SACTIONS; i++)
- {
- if ((action = state_table[event][i]) != BTA_AV_SIGNORE)
- {
+ for (i = 0; i < BTA_AV_SACTIONS; i++) {
+ if ((action = state_table[event][i]) != BTA_AV_SIGNORE) {
(*p_scb->p_act_tbl[action])(p_scb, p_data);
- }
- else
+ } else {
break;
+ }
}
}
{
BOOLEAN is_opening = FALSE;
- if (p_scb)
- {
- if (p_scb->state == BTA_AV_OPENING_SST)
+ if (p_scb) {
+ if (p_scb->state == BTA_AV_OPENING_SST) {
is_opening = TRUE;
+ }
}
return is_opening;
{
BOOLEAN is_incoming = FALSE;
- if (p_scb)
- {
- if (p_scb->state == BTA_AV_INCOMING_SST)
+ if (p_scb) {
+ if (p_scb->state == BTA_AV_INCOMING_SST) {
is_incoming = TRUE;
+ }
}
return is_incoming;
*******************************************************************************/
void bta_av_set_scb_sst_init (tBTA_AV_SCB *p_scb)
{
- if (p_scb)
- {
+ if (p_scb) {
p_scb->state = BTA_AV_INIT_SST;
}
}
{
BOOLEAN is_init = FALSE;
- if (p_scb)
- {
- if (p_scb->state == BTA_AV_INIT_SST)
+ if (p_scb) {
+ if (p_scb->state == BTA_AV_INIT_SST) {
is_init = TRUE;
+ }
}
return is_init;
*******************************************************************************/
void bta_av_set_scb_sst_incoming (tBTA_AV_SCB *p_scb)
{
- if (p_scb)
- {
+ if (p_scb) {
p_scb->state = BTA_AV_INCOMING_SST;
}
}
*******************************************************************************/
static char *bta_av_sst_code(UINT8 state)
{
- switch(state)
- {
+ switch (state) {
case BTA_AV_INIT_SST: return "INIT";
case BTA_AV_INCOMING_SST: return "INCOMING";
case BTA_AV_OPENING_SST: return "OPENING";
**
******************************************************************************/
extern void bta_ar_reg_avrc(UINT16 service_uuid, char *p_service_name,
- char *p_provider_name, UINT16 categories, tBTA_SYS_ID sys_id);
+ char *p_provider_name, UINT16 categories, tBTA_SYS_ID sys_id);
/******************************************************************************
**
#endif
#ifndef BTA_AV_MAX_A2DP_MTU
- /*#define BTA_AV_MAX_A2DP_MTU 668 //224 (DM5) * 3 - 4(L2CAP header) */
+/*#define BTA_AV_MAX_A2DP_MTU 668 //224 (DM5) * 3 - 4(L2CAP header) */
#define BTA_AV_MAX_A2DP_MTU 1008
#endif
/* function types for call-out functions */
typedef BOOLEAN (*tBTA_AV_CO_INIT) (UINT8 *p_codec_type, UINT8 *p_codec_info,
- UINT8 *p_num_protect, UINT8 *p_protect_info, UINT8 index);
+ UINT8 *p_num_protect, UINT8 *p_protect_info, UINT8 index);
typedef void (*tBTA_AV_CO_DISC_RES) (tBTA_AV_HNDL hndl, UINT8 num_seps,
UINT8 num_snk, UINT8 num_src, BD_ADDR addr, UINT16 uuid_local);
typedef UINT8 (*tBTA_AV_CO_GETCFG) (tBTA_AV_HNDL hndl, tBTA_AV_CODEC codec_type,
- UINT8 *p_codec_info, UINT8 *p_sep_info_idx, UINT8 seid,
- UINT8 *p_num_protect, UINT8 *p_protect_info);
+ UINT8 *p_codec_info, UINT8 *p_sep_info_idx, UINT8 seid,
+ UINT8 *p_num_protect, UINT8 *p_protect_info);
typedef void (*tBTA_AV_CO_SETCFG) (tBTA_AV_HNDL hndl, tBTA_AV_CODEC codec_type,
- UINT8 *p_codec_info, UINT8 seid, BD_ADDR addr,
- UINT8 num_protect, UINT8 *p_protect_info,
- UINT8 t_local_sep, UINT8 avdt_handle);
+ UINT8 *p_codec_info, UINT8 seid, BD_ADDR addr,
+ UINT8 num_protect, UINT8 *p_protect_info,
+ UINT8 t_local_sep, UINT8 avdt_handle);
typedef void (*tBTA_AV_CO_OPEN) (tBTA_AV_HNDL hndl,
tBTA_AV_CODEC codec_type, UINT8 *p_codec_info,
- UINT16 mtu);
+ UINT16 mtu);
typedef void (*tBTA_AV_CO_CLOSE) (tBTA_AV_HNDL hndl, tBTA_AV_CODEC codec_type, UINT16 mtu);
-typedef void (*tBTA_AV_CO_START) (tBTA_AV_HNDL hndl, tBTA_AV_CODEC codec_type,UINT8 *p_codec_info, BOOLEAN *p_no_rtp_hdr);
+typedef void (*tBTA_AV_CO_START) (tBTA_AV_HNDL hndl, tBTA_AV_CODEC codec_type, UINT8 *p_codec_info, BOOLEAN *p_no_rtp_hdr);
typedef void (*tBTA_AV_CO_STOP) (tBTA_AV_HNDL hndl, tBTA_AV_CODEC codec_type);
-typedef void * (*tBTA_AV_CO_DATAPATH) (tBTA_AV_CODEC codec_type,
- UINT32 *p_len, UINT32 *p_timestamp);
+typedef void *(*tBTA_AV_CO_DATAPATH) (tBTA_AV_CODEC codec_type,
+ UINT32 *p_len, UINT32 *p_timestamp);
typedef void (*tBTA_AV_CO_DELAY) (tBTA_AV_HNDL hndl, UINT16 delay);
/* the call-out functions for one stream */
-typedef struct
-{
+typedef struct {
tBTA_AV_CO_INIT init;
tBTA_AV_CO_DISC_RES disc_res;
tBTA_AV_CO_GETCFG getcfg;
typedef UINT8 tBTA_AV_EVT;
/* Event associated with BTA_AV_ENABLE_EVT */
-typedef struct
-{
+typedef struct {
tBTA_AV_FEAT features;
} tBTA_AV_ENABLE;
/* Event associated with BTA_AV_REGISTER_EVT */
-typedef struct
-{
+typedef struct {
tBTA_AV_CHNL chnl; /* audio/video */
tBTA_AV_HNDL hndl; /* Handle associated with the stream. */
UINT8 app_id; /* ID associated with call to BTA_AvRegister() */
#define BTA_AV_EDR_3MBPS 0x02
typedef UINT8 tBTA_AV_EDR;
-typedef struct
-{
+typedef struct {
tBTA_AV_CHNL chnl;
tBTA_AV_HNDL hndl;
BD_ADDR bd_addr;
} tBTA_AV_OPEN;
/* data associated with BTA_AV_CLOSE_EVT */
-typedef struct
-{
+typedef struct {
tBTA_AV_CHNL chnl;
tBTA_AV_HNDL hndl;
UINT8 disc_rsn; /* disconnection reason */
} tBTA_AV_CLOSE;
/* data associated with BTA_AV_START_EVT */
-typedef struct
-{
+typedef struct {
tBTA_AV_CHNL chnl;
tBTA_AV_HNDL hndl;
tBTA_AV_STATUS status;
} tBTA_AV_START;
/* data associated with BTA_AV_SUSPEND_EVT */
-typedef struct
-{
+typedef struct {
tBTA_AV_CHNL chnl;
tBTA_AV_HNDL hndl;
BOOLEAN initiator; /* TRUE, if local device initiates the SUSPEND */
} tBTA_AV_SUSPEND;
/* data associated with BTA_AV_RECONFIG_EVT */
-typedef struct
-{
+typedef struct {
tBTA_AV_CHNL chnl;
tBTA_AV_HNDL hndl;
tBTA_AV_STATUS status;
} tBTA_AV_RECONFIG;
/* data associated with BTA_AV_PROTECT_REQ_EVT */
-typedef struct
-{
+typedef struct {
tBTA_AV_CHNL chnl;
tBTA_AV_HNDL hndl;
UINT8 *p_data;
} tBTA_AV_PROTECT_REQ;
/* data associated with BTA_AV_PROTECT_RSP_EVT */
-typedef struct
-{
+typedef struct {
tBTA_AV_CHNL chnl;
tBTA_AV_HNDL hndl;
UINT8 *p_data;
} tBTA_AV_PROTECT_RSP;
/* data associated with BTA_AV_RC_OPEN_EVT */
-typedef struct
-{
+typedef struct {
UINT8 rc_handle;
tBTA_AV_FEAT peer_features;
BD_ADDR peer_addr;
} tBTA_AV_RC_OPEN;
/* data associated with BTA_AV_RC_CLOSE_EVT */
-typedef struct
-{
+typedef struct {
UINT8 rc_handle;
BD_ADDR peer_addr;
} tBTA_AV_RC_CLOSE;
/* data associated with BTA_AV_RC_FEAT_EVT */
-typedef struct
-{
+typedef struct {
UINT8 rc_handle;
tBTA_AV_FEAT peer_features;
} tBTA_AV_RC_FEAT;
/* data associated with BTA_AV_REMOTE_CMD_EVT */
-typedef struct
-{
+typedef struct {
UINT8 rc_handle;
tBTA_AV_RC rc_id;
tBTA_AV_STATE key_state;
} tBTA_AV_REMOTE_CMD;
/* data associated with BTA_AV_REMOTE_RSP_EVT */
-typedef struct
-{
+typedef struct {
UINT8 rc_handle;
tBTA_AV_RC rc_id;
tBTA_AV_STATE key_state;
} tBTA_AV_REMOTE_RSP;
/* data associated with BTA_AV_VENDOR_CMD_EVT, BTA_AV_VENDOR_RSP_EVT */
-typedef struct
-{
+typedef struct {
UINT8 rc_handle;
UINT16 len; /* Max vendor dependent message is 512 */
UINT8 label;
} tBTA_AV_VENDOR;
/* data associated with BTA_AV_META_MSG_EVT */
-typedef struct
-{
+typedef struct {
UINT8 rc_handle;
UINT16 len;
UINT8 label;
} tBTA_AV_META_MSG;
/* data associated with BTA_AV_PENDING_EVT */
-typedef struct
-{
+typedef struct {
BD_ADDR bd_addr;
} tBTA_AV_PEND;
/* data associated with BTA_AV_REJECT_EVT */
-typedef struct
-{
+typedef struct {
BD_ADDR bd_addr;
tBTA_AV_HNDL hndl; /* Handle associated with the stream that rejected the connection. */
} tBTA_AV_REJECT;
/* union of data associated with AV callback */
-typedef union
-{
+typedef union {
tBTA_AV_CHNL chnl;
tBTA_AV_ENABLE enable;
tBTA_AV_REGISTER registr;
} tBTA_AV;
/* union of data associated with AV Media callback */
-typedef union
-{
+typedef union {
BT_HDR *p_data;
UINT8 *codec_info;
} tBTA_AV_MEDIA;
typedef void (tBTA_AV_REG) (tAVDT_CS *p_cs, char *p_service_name, void *p_data);
/* AV configuration structure */
-typedef struct
-{
+typedef struct {
UINT32 company_id; /* AVRCP Company ID */
UINT16 avrc_mtu; /* AVRCP MTU at L2CAP for control channel */
UINT16 avrc_br_mtu; /* AVRCP MTU at L2CAP for browsing channel */
**
*******************************************************************************/
void BTA_AvEnable(tBTA_SEC sec_mask, tBTA_AV_FEAT features,
- tBTA_AV_CBACK *p_cback);
+ tBTA_AV_CBACK *p_cback);
/*******************************************************************************
**
**
*******************************************************************************/
void BTA_AvRegister(tBTA_AV_CHNL chnl, const char *p_service_name,
- UINT8 app_id, tBTA_AV_DATA_CBACK *p_data_cback, tBTA_AV_CO_FUNCTS * bta_av_cos);
+ UINT8 app_id, tBTA_AV_DATA_CBACK *p_data_cback, tBTA_AV_CO_FUNCTS *bta_av_cos);
/*******************************************************************************
**
**
*******************************************************************************/
void BTA_AvOpen(BD_ADDR bd_addr, tBTA_AV_HNDL handle,
- BOOLEAN use_rc, tBTA_SEC sec_mask, UINT16 uuid);
+ BOOLEAN use_rc, tBTA_SEC sec_mask, UINT16 uuid);
/*******************************************************************************
**
**
*******************************************************************************/
void BTA_AvReconfig(tBTA_AV_HNDL hndl, BOOLEAN suspend, UINT8 sep_info_idx,
- UINT8 *p_codec_info, UINT8 num_protect, UINT8 *p_protect_info);
+ UINT8 *p_codec_info, UINT8 num_protect, UINT8 *p_protect_info);
/*******************************************************************************
**
**
*******************************************************************************/
void BTA_AvProtectRsp(tBTA_AV_HNDL hndl, UINT8 error_code, UINT8 *p_data,
- UINT16 len);
+ UINT16 len);
/*******************************************************************************
**
**
*******************************************************************************/
void BTA_AvRemoteCmd(UINT8 rc_handle, UINT8 label, tBTA_AV_RC rc_id,
- tBTA_AV_STATE key_state);
+ tBTA_AV_STATE key_state);
/*******************************************************************************
**
**
*******************************************************************************/
void BTA_AvVendorCmd(UINT8 rc_handle, UINT8 label, tBTA_AV_CODE cmd_code,
- UINT8 *p_data, UINT16 len);
+ UINT8 *p_data, UINT16 len);
/*******************************************************************************
**
**
*******************************************************************************/
void BTA_AvVendorRsp(UINT8 rc_handle, UINT8 label, tBTA_AV_CODE rsp_code,
- UINT8 *p_data, UINT16 len, UINT32 company_id);
+ UINT8 *p_data, UINT16 len, UINT32 company_id);
/*******************************************************************************
**
*******************************************************************************/
void BTA_AvMetaRsp(UINT8 rc_handle, UINT8 label, tBTA_AV_CODE rsp_code,
- BT_HDR *p_pkt);
+ BT_HDR *p_pkt);
/*******************************************************************************
**
**
*******************************************************************************/
extern void bta_av_ci_setconfig(tBTA_AV_HNDL hndl, UINT8 err_code,
- UINT8 category, UINT8 num_seid, UINT8 *p_seid,
- BOOLEAN recfg_needed, UINT8 avdt_handle);
+ UINT8 category, UINT8 num_seid, UINT8 *p_seid,
+ BOOLEAN recfg_needed, UINT8 avdt_handle);
#ifdef __cplusplus
#define BTA_AV_CO_DEFAULT_AUDIO_OFFSET AVDT_MEDIA_OFFSET
-enum
-{
+enum {
BTA_AV_CO_ST_INIT,
BTA_AV_CO_ST_IN,
BTA_AV_CO_ST_OUT,
/* data type for the Audio Codec Information*/
-typedef struct
-{
+typedef struct {
UINT16 bit_rate; /* SBC encoder bit rate in kbps */
UINT16 bit_rate_busy; /* SBC encoder bit rate in kbps */
UINT16 bit_rate_swampd;/* SBC encoder bit rate in kbps */
**
*******************************************************************************/
extern void bta_av_co_audio_disc_res(tBTA_AV_HNDL hndl, UINT8 num_seps,
- UINT8 num_snk, UINT8 num_src, BD_ADDR addr, UINT16 uuid_local);
+ UINT8 num_snk, UINT8 num_src, BD_ADDR addr, UINT16 uuid_local);
/*******************************************************************************
**
**
*******************************************************************************/
extern void bta_av_co_audio_setconfig(tBTA_AV_HNDL hndl, tBTA_AV_CODEC codec_type,
- UINT8 *p_codec_info, UINT8 seid, BD_ADDR addr,
- UINT8 num_protect, UINT8 *p_protect_info,UINT8 t_local_sep, UINT8 avdt_handle);
+ UINT8 *p_codec_info, UINT8 seid, BD_ADDR addr,
+ UINT8 num_protect, UINT8 *p_protect_info, UINT8 t_local_sep, UINT8 avdt_handle);
/*******************************************************************************
**
** Otherwise, a GKI buffer (BT_HDR*) containing the audio data.
**
*******************************************************************************/
-extern void * bta_av_co_audio_src_data_path(tBTA_AV_CODEC codec_type,
- UINT32 *p_len, UINT32 *p_timestamp);
+extern void *bta_av_co_audio_src_data_path(tBTA_AV_CODEC codec_type,
+ UINT32 *p_len, UINT32 *p_timestamp);
/*******************************************************************************
**
** Otherwise, a video data buffer (UINT8*).
**
*******************************************************************************/
-extern void * bta_av_co_video_src_data_path(tBTA_AV_CODEC codec_type,
- UINT32 *p_len, UINT32 *p_timestamp);
+extern void *bta_av_co_video_src_data_path(tBTA_AV_CODEC codec_type,
+ UINT32 *p_len, UINT32 *p_timestamp);
/*******************************************************************************
**
**
*******************************************************************************/
extern int bta_av_sbc_up_sample_16s (void *p_src, void *p_dst,
- UINT32 src_samples, UINT32 dst_samples,
- UINT32 *p_ret);
+ UINT32 src_samples, UINT32 dst_samples,
+ UINT32 *p_ret);
/*******************************************************************************
**
**
*******************************************************************************/
extern int bta_av_sbc_up_sample_8s (void *p_src, void *p_dst,
- UINT32 src_samples, UINT32 dst_samples,
- UINT32 *p_ret);
+ UINT32 src_samples, UINT32 dst_samples,
+ UINT32 *p_ret);
/*******************************************************************************
**
**
*******************************************************************************/
extern int bta_av_sbc_up_sample_8m (void *p_src, void *p_dst,
- UINT32 src_samples, UINT32 dst_samples,
- UINT32 *p_ret);
+ UINT32 src_samples, UINT32 dst_samples,
+ UINT32 *p_ret);
/*******************************************************************************
**
msg.sig = BTC_SIG_API_CB;
msg.pid = BTC_PID_DM_SEC;
msg.act = event;
-
+
btc_transfer_context(&msg, (btc_dm_sec_args_t *)data, sizeof(btc_dm_sec_args_t), btc_dm_sec_arg_deep_copy);
}
bt_bdaddr_t bd_addr;
bt_status_t status;
LOG_DEBUG("%s: bond state success %d, present %d, type%d\n", __func__, p_auth_cmpl->success,
- p_auth_cmpl->key_present, p_auth_cmpl->key_type);
+ p_auth_cmpl->key_present, p_auth_cmpl->key_type);
bdcpy(bd_addr.address, p_auth_cmpl->bd_addr);
- if ( (p_auth_cmpl->success == TRUE) && (p_auth_cmpl->key_present) )
- {
- #if 0
+ if ( (p_auth_cmpl->success == TRUE) && (p_auth_cmpl->key_present) ) {
+#if 0
if ((p_auth_cmpl->key_type < HCI_LKEY_TYPE_DEBUG_COMB) ||
- (p_auth_cmpl->key_type == HCI_LKEY_TYPE_AUTH_COMB) ||
- (p_auth_cmpl->key_type == HCI_LKEY_TYPE_CHANGED_COMB) ||
- (p_auth_cmpl->key_type == HCI_LKEY_TYPE_AUTH_COMB_P_256)
- )
- #endif
- if (1)
- {
- bt_status_t ret;
- LOG_DEBUG("%s: Storing link key. key_type=0x%x",
- __FUNCTION__, p_auth_cmpl->key_type);
- ret = btc_storage_add_bonded_device(&bd_addr,
- p_auth_cmpl->key, p_auth_cmpl->key_type,
- 16);
- BTC_ASSERTC(ret == BT_STATUS_SUCCESS, "storing link key failed", ret);
- }
- else
- {
- LOG_DEBUG("%s: Temporary key. Not storing. key_type=0x%x",
- __FUNCTION__, p_auth_cmpl->key_type);
- }
+ (p_auth_cmpl->key_type == HCI_LKEY_TYPE_AUTH_COMB) ||
+ (p_auth_cmpl->key_type == HCI_LKEY_TYPE_CHANGED_COMB) ||
+ (p_auth_cmpl->key_type == HCI_LKEY_TYPE_AUTH_COMB_P_256)
+ )
+#endif
+ if (1) {
+ bt_status_t ret;
+ LOG_DEBUG("%s: Storing link key. key_type=0x%x",
+ __FUNCTION__, p_auth_cmpl->key_type);
+ ret = btc_storage_add_bonded_device(&bd_addr,
+ p_auth_cmpl->key, p_auth_cmpl->key_type,
+ 16);
+ BTC_ASSERTC(ret == BT_STATUS_SUCCESS, "storing link key failed", ret);
+ } else {
+ LOG_DEBUG("%s: Temporary key. Not storing. key_type=0x%x",
+ __FUNCTION__, p_auth_cmpl->key_type);
+ }
}
// Skip SDP for certain HID Devices
- if (p_auth_cmpl->success)
- {
- }
- else
- {
+ if (p_auth_cmpl->success) {
+ } else {
// Map the HCI fail reason to bt status
- switch(p_auth_cmpl->fail_reason)
- {
- case HCI_ERR_PAGE_TIMEOUT:
- LOG_WARN("%s() - Pairing timeout; retrying () ...", __FUNCTION__);
- return;
- /* Fall-through */
- case HCI_ERR_CONNECTION_TOUT:
- status = BT_STATUS_RMT_DEV_DOWN;
- break;
-
- case HCI_ERR_PAIRING_NOT_ALLOWED:
- status = BT_STATUS_AUTH_REJECTED;
- break;
-
- case HCI_ERR_LMP_RESPONSE_TIMEOUT:
- status = BT_STATUS_AUTH_FAILURE;
- break;
-
- /* map the auth failure codes, so we can retry pairing if necessary */
- case HCI_ERR_AUTH_FAILURE:
- case HCI_ERR_KEY_MISSING:
- btc_storage_remove_bonded_device(&bd_addr);
- case HCI_ERR_HOST_REJECT_SECURITY:
- case HCI_ERR_ENCRY_MODE_NOT_ACCEPTABLE:
- case HCI_ERR_UNIT_KEY_USED:
- case HCI_ERR_PAIRING_WITH_UNIT_KEY_NOT_SUPPORTED:
- case HCI_ERR_INSUFFCIENT_SECURITY:
- case HCI_ERR_PEER_USER:
- case HCI_ERR_UNSPECIFIED:
- LOG_DEBUG(" %s() Authentication fail reason %d",
- __FUNCTION__, p_auth_cmpl->fail_reason);
- /* if autopair attempts are more than 1, or not attempted */
- status = BT_STATUS_AUTH_FAILURE;
- break;
- default:
- status = BT_STATUS_FAIL;
+ switch (p_auth_cmpl->fail_reason) {
+ case HCI_ERR_PAGE_TIMEOUT:
+ LOG_WARN("%s() - Pairing timeout; retrying () ...", __FUNCTION__);
+ return;
+ /* Fall-through */
+ case HCI_ERR_CONNECTION_TOUT:
+ status = BT_STATUS_RMT_DEV_DOWN;
+ break;
+
+ case HCI_ERR_PAIRING_NOT_ALLOWED:
+ status = BT_STATUS_AUTH_REJECTED;
+ break;
+
+ case HCI_ERR_LMP_RESPONSE_TIMEOUT:
+ status = BT_STATUS_AUTH_FAILURE;
+ break;
+
+ /* map the auth failure codes, so we can retry pairing if necessary */
+ case HCI_ERR_AUTH_FAILURE:
+ case HCI_ERR_KEY_MISSING:
+ btc_storage_remove_bonded_device(&bd_addr);
+ case HCI_ERR_HOST_REJECT_SECURITY:
+ case HCI_ERR_ENCRY_MODE_NOT_ACCEPTABLE:
+ case HCI_ERR_UNIT_KEY_USED:
+ case HCI_ERR_PAIRING_WITH_UNIT_KEY_NOT_SUPPORTED:
+ case HCI_ERR_INSUFFCIENT_SECURITY:
+ case HCI_ERR_PEER_USER:
+ case HCI_ERR_UNSPECIFIED:
+ LOG_DEBUG(" %s() Authentication fail reason %d",
+ __FUNCTION__, p_auth_cmpl->fail_reason);
+ /* if autopair attempts are more than 1, or not attempted */
+ status = BT_STATUS_AUTH_FAILURE;
+ break;
+ default:
+ status = BT_STATUS_FAIL;
}
}
(void) status;
switch (msg->act) {
case BTA_DM_ENABLE_EVT: {
btc_clear_services_mask();
- btc_storage_load_bonded_devices();
+ btc_storage_load_bonded_devices();
btc_enable_bluetooth_evt(p_data->enable.status);
break;
}
break;
}
case BTA_DM_PIN_REQ_EVT:
- break;
+ break;
case BTA_DM_AUTH_CMPL_EVT:
- btc_dm_auth_cmpl_evt(&p_data->auth_cmpl);
- break;
+ btc_dm_auth_cmpl_evt(&p_data->auth_cmpl);
+ break;
case BTA_DM_BOND_CANCEL_CMPL_EVT:
case BTA_DM_SP_CFM_REQ_EVT:
case BTA_DM_SP_KEY_NOTIF_EVT:
queue_int_advance();
break;
}
-
+
if (esp_bluedroid_get_status() == ESP_BLUEDROID_STATUS_ENABLED) {
btc_queue_connect_next();
}
**
******************************************************************************/
bt_status_t btc_sm_dispatch(btc_sm_handle_t handle, btc_sm_event_t event,
- void *data)
+ void *data)
{
bt_status_t status = BT_STATUS_SUCCESS;
**
******************************************************************************/
btc_sm_handle_t btc_sm_init(const btc_sm_handler_t *p_handlers,
- btc_sm_state_t initial_state);
+ btc_sm_state_t initial_state);
/*****************************************************************************
**
**
******************************************************************************/
bt_status_t btc_sm_dispatch(btc_sm_handle_t handle, btc_sm_event_t event,
- void *data);
+ void *data);
/*****************************************************************************
**
A2D_TRACE_API("a2d_sdp_cback status: %d", status);
- if (status == SDP_SUCCESS)
- {
+ if (status == SDP_SUCCESS) {
/* loop through all records we found */
- do
- {
+ do {
/* get next record; if none found, we're done */
if ((p_rec = SDP_FindServiceInDb(a2d_cb.find.p_db,
- a2d_cb.find.service_uuid, p_rec)) == NULL)
- {
+ a2d_cb.find.service_uuid, p_rec)) == NULL) {
break;
}
memset(&a2d_svc, 0, sizeof(tA2D_Service));
/* get service name */
if ((p_attr = SDP_FindAttributeInRec(p_rec,
- ATTR_ID_SERVICE_NAME)) != NULL)
- {
+ ATTR_ID_SERVICE_NAME)) != NULL) {
a2d_svc.p_service_name = (char *) p_attr->attr_value.v.array;
a2d_svc.service_len = SDP_DISC_ATTR_LEN(p_attr->attr_len_type);
}
/* get provider name */
if ((p_attr = SDP_FindAttributeInRec(p_rec,
- ATTR_ID_PROVIDER_NAME)) != NULL)
- {
+ ATTR_ID_PROVIDER_NAME)) != NULL) {
a2d_svc.p_provider_name = (char *) p_attr->attr_value.v.array;
a2d_svc.provider_len = SDP_DISC_ATTR_LEN(p_attr->attr_len_type);
}
/* get supported features */
if ((p_attr = SDP_FindAttributeInRec(p_rec,
- ATTR_ID_SUPPORTED_FEATURES)) != NULL)
- {
+ ATTR_ID_SUPPORTED_FEATURES)) != NULL) {
a2d_svc.features = p_attr->attr_value.v.u16;
}
/* get AVDTP version */
- if (SDP_FindProtocolListElemInRec(p_rec, UUID_PROTOCOL_AVDTP, &elem))
- {
+ if (SDP_FindProtocolListElemInRec(p_rec, UUID_PROTOCOL_AVDTP, &elem)) {
a2d_svc.avdt_version = elem.params[0];
A2D_TRACE_DEBUG("avdt_version: 0x%x", a2d_svc.avdt_version);
}
a2d_cb.find.service_uuid = 0;
/* return info from sdp record in app callback function */
- if (a2d_cb.find.p_cback != NULL)
- {
+ if (a2d_cb.find.p_cback != NULL) {
(*a2d_cb.find.p_cback)(found, &a2d_svc);
}
**
******************************************************************************/
tA2D_STATUS A2D_AddRecord(UINT16 service_uuid, char *p_service_name, char *p_provider_name,
- UINT16 features, UINT32 sdp_handle)
+ UINT16 features, UINT32 sdp_handle)
{
UINT16 browse_list[1];
BOOLEAN result = TRUE;
A2D_TRACE_API("A2D_AddRecord uuid: %x", service_uuid);
- if( (sdp_handle == 0) ||
- (service_uuid != UUID_SERVCLASS_AUDIO_SOURCE && service_uuid != UUID_SERVCLASS_AUDIO_SINK) )
+ if ( (sdp_handle == 0) ||
+ (service_uuid != UUID_SERVCLASS_AUDIO_SOURCE && service_uuid != UUID_SERVCLASS_AUDIO_SINK) ) {
return A2D_INVALID_PARAMS;
+ }
/* add service class id list */
result &= SDP_AddServiceClassIdList(sdp_handle, 1, &service_uuid);
- memset((void*) proto_list, 0 , A2D_NUM_PROTO_ELEMS*sizeof(tSDP_PROTOCOL_ELEM));
+ memset((void *) proto_list, 0 , A2D_NUM_PROTO_ELEMS * sizeof(tSDP_PROTOCOL_ELEM));
/* add protocol descriptor list */
proto_list[0].protocol_uuid = UUID_PROTOCOL_L2CAP;
result &= SDP_AddProfileDescriptorList(sdp_handle, UUID_SERVCLASS_ADV_AUDIO_DISTRIBUTION, A2D_VERSION);
/* add supported feature */
- if (features != 0)
- {
+ if (features != 0) {
p = temp;
UINT16_TO_BE_STREAM(p, features);
result &= SDP_AddAttribute(sdp_handle, ATTR_ID_SUPPORTED_FEATURES, UINT_DESC_TYPE,
- (UINT32)2, (UINT8*)temp);
+ (UINT32)2, (UINT8 *)temp);
}
/* add provider name */
- if (p_provider_name != NULL)
- {
+ if (p_provider_name != NULL) {
result &= SDP_AddAttribute(sdp_handle, ATTR_ID_PROVIDER_NAME, TEXT_STR_DESC_TYPE,
- (UINT32)(strlen(p_provider_name)+1), (UINT8 *) p_provider_name);
+ (UINT32)(strlen(p_provider_name) + 1), (UINT8 *) p_provider_name);
}
/* add service name */
- if (p_service_name != NULL)
- {
+ if (p_service_name != NULL) {
result &= SDP_AddAttribute(sdp_handle, ATTR_ID_SERVICE_NAME, TEXT_STR_DESC_TYPE,
- (UINT32)(strlen(p_service_name)+1), (UINT8 *) p_service_name);
+ (UINT32)(strlen(p_service_name) + 1), (UINT8 *) p_service_name);
}
/* add browse group list */
**
******************************************************************************/
tA2D_STATUS A2D_FindService(UINT16 service_uuid, BD_ADDR bd_addr,
- tA2D_SDP_DB_PARAMS *p_db, tA2D_FIND_CBACK *p_cback)
+ tA2D_SDP_DB_PARAMS *p_db, tA2D_FIND_CBACK *p_cback)
{
tSDP_UUID uuid_list;
BOOLEAN result = TRUE;
ATTR_ID_SUPPORTED_FEATURES,
ATTR_ID_SERVICE_NAME,
ATTR_ID_PROTOCOL_DESC_LIST,
- ATTR_ID_PROVIDER_NAME};
+ ATTR_ID_PROVIDER_NAME
+ };
A2D_TRACE_API("A2D_FindService uuid: %x", service_uuid);
- if( (service_uuid != UUID_SERVCLASS_AUDIO_SOURCE && service_uuid != UUID_SERVCLASS_AUDIO_SINK) ||
- p_db == NULL || p_db->p_db == NULL || p_cback == NULL)
+ if ( (service_uuid != UUID_SERVCLASS_AUDIO_SOURCE && service_uuid != UUID_SERVCLASS_AUDIO_SINK) ||
+ p_db == NULL || p_db->p_db == NULL || p_cback == NULL) {
return A2D_INVALID_PARAMS;
+ }
- if( a2d_cb.find.service_uuid == UUID_SERVCLASS_AUDIO_SOURCE ||
- a2d_cb.find.service_uuid == UUID_SERVCLASS_AUDIO_SINK)
+ if ( a2d_cb.find.service_uuid == UUID_SERVCLASS_AUDIO_SOURCE ||
+ a2d_cb.find.service_uuid == UUID_SERVCLASS_AUDIO_SINK) {
return A2D_BUSY;
+ }
/* set up discovery database */
uuid_list.len = LEN_UUID_16;
uuid_list.uu.uuid16 = service_uuid;
- if(p_db->p_attrs == NULL || p_db->num_attr == 0)
- {
+ if (p_db->p_attrs == NULL || p_db->num_attr == 0) {
p_db->p_attrs = a2d_attr_list;
p_db->num_attr = A2D_NUM_ATTR;
}
result = SDP_InitDiscoveryDb(p_db->p_db, p_db->db_len, 1, &uuid_list, p_db->num_attr,
p_db->p_attrs);
- if (result == TRUE)
- {
+ if (result == TRUE) {
/* store service_uuid and discovery db pointer */
a2d_cb.find.p_db = p_db->p_db;
a2d_cb.find.service_uuid = service_uuid;
/* perform service search */
result = SDP_ServiceSearchAttributeRequest(bd_addr, p_db->p_db, a2d_sdp_cback);
- if(FALSE == result)
- {
+ if (FALSE == result) {
a2d_cb.find.service_uuid = 0;
}
}
******************************************************************************/
UINT8 A2D_SetTraceLevel (UINT8 new_level)
{
- if (new_level != 0xFF)
+ if (new_level != 0xFF) {
a2d_cb.trace_level = new_level;
+ }
return (a2d_cb.trace_level);
}
{
UINT8 count;
BOOLEAN res;
- if(num == 0)
+ if (num == 0) {
res = A2D_SET_ZERO_BIT;
- else
- {
+ } else {
count = (num & (num - 1));
- res = ((count==0)?A2D_SET_ONE_BIT:A2D_SET_MULTL_BIT);
+ res = ((count == 0) ? A2D_SET_ONE_BIT : A2D_SET_MULTL_BIT);
}
return res;
}
#define A2D_SBC_GET_IDX(sc) (((sc) & 0x3) + (((sc) & 0x30) >> 2))
-typedef struct
-{
+typedef struct {
UINT8 use;
UINT8 idx;
} tA2D_SBC_FR_CB;
-typedef struct
-{
+typedef struct {
tA2D_SBC_FR_CB fr[2];
UINT8 index;
UINT8 base;
UINT8 num_chnl = 1;
UINT8 num_subband = 4;
- if((p_pkt[0] & A2D_SBC_SYNC_MASK) == 0)
- {
+ if ((p_pkt[0] & A2D_SBC_SYNC_MASK) == 0) {
a2d_cb.use_desc = TRUE;
fmt = p_pkt[1];
p_pkt[0] |= A2D_SBC_SYNC_MASK;
memset(&a2d_sbc_ds_cb, 0, sizeof(tA2D_SBC_DS_CB));
- if(fmt & A2D_SBC_CH_M_BITS)
+ if (fmt & A2D_SBC_CH_M_BITS) {
num_chnl = 2;
- if(fmt & A2D_SBC_SUBBAND_BIT)
+ }
+ if (fmt & A2D_SBC_SUBBAND_BIT) {
num_subband = 8;
- a2d_sbc_ds_cb.base = 6 + num_chnl*num_subband/2;
+ }
+ a2d_sbc_ds_cb.base = 6 + num_chnl * num_subband / 2;
/*printf("base: %d\n", a2d_sbc_ds_cb.base);
a2d_count = 0;*/
}
tA2D_SBC_FR_CB *p_cur, *p_last;
UINT32 idx, tmp, tmp2;
- if(a2d_cb.use_desc)
- {
+ if (a2d_cb.use_desc) {
/* c2l */
p_last = &a2d_sbc_ds_cb.fr[A2D_SBC_LIDX];
p_cur = &a2d_sbc_ds_cb.fr[A2D_SBC_CIDX];
/* getc */
p_cur->use = p_pkt[A2D_SBC_CRC_IDX] & A2D_SBC_USE_MASK;
p_cur->idx = A2D_SBC_GET_IDX(p_pkt[A2D_SBC_CRC_IDX]);
- a2d_sbc_ds_cb.index = (p_cur->use)?A2D_SBC_CIDX:A2D_SBC_LIDX;
+ a2d_sbc_ds_cb.index = (p_cur->use) ? A2D_SBC_CIDX : A2D_SBC_LIDX;
/*
printf("%05d: ar[%02d]: x%02x, msk: x%02x, use: %s, idx: %02d, ",
a2d_count++,
*/
/* descramble */
idx = a2d_sbc_ds_cb.fr[a2d_sbc_ds_cb.index].idx;
- if(idx > 0)
- {
+ if (idx > 0) {
p_pkt = &p_pkt[a2d_sbc_ds_cb.base];
- if((idx&1) && (len > (a2d_sbc_ds_cb.base+(idx<<1))))
- {
- tmp2 = (idx<<1);
+ if ((idx & 1) && (len > (a2d_sbc_ds_cb.base + (idx << 1)))) {
+ tmp2 = (idx << 1);
tmp = p_pkt[idx];
p_pkt[idx] = p_pkt[tmp2];
p_pkt[tmp2] = tmp;
printf("tmp2: %02d, len: %d, idx: %d\n",
tmp2, len, a2d_sbc_ds_cb.fr[a2d_sbc_ds_cb.index].idx);
*/
- }
- else
- {
+ } else {
tmp2 = p_pkt[idx];
- tmp = (tmp2>>3)+(tmp2<<5);
+ tmp = (tmp2 >> 3) + (tmp2 << 5);
p_pkt[idx] = (UINT8)tmp;
/*
printf("tmp: x%02x, len: %d, idx: %d(cmp:%d)\n",
{
tA2D_STATUS status;
- if( p_ie == NULL || p_result == NULL ||
- (p_ie->samp_freq & ~A2D_SBC_IE_SAMP_FREQ_MSK) ||
- (p_ie->ch_mode & ~A2D_SBC_IE_CH_MD_MSK) ||
- (p_ie->block_len & ~A2D_SBC_IE_BLOCKS_MSK) ||
- (p_ie->num_subbands & ~A2D_SBC_IE_SUBBAND_MSK) ||
- (p_ie->alloc_mthd & ~A2D_SBC_IE_ALLOC_MD_MSK) ||
- (p_ie->max_bitpool < p_ie->min_bitpool) ||
- (p_ie->max_bitpool < A2D_SBC_IE_MIN_BITPOOL) ||
- (p_ie->max_bitpool > A2D_SBC_IE_MAX_BITPOOL) ||
- (p_ie->min_bitpool < A2D_SBC_IE_MIN_BITPOOL) ||
- (p_ie->min_bitpool > A2D_SBC_IE_MAX_BITPOOL) )
- {
+ if ( p_ie == NULL || p_result == NULL ||
+ (p_ie->samp_freq & ~A2D_SBC_IE_SAMP_FREQ_MSK) ||
+ (p_ie->ch_mode & ~A2D_SBC_IE_CH_MD_MSK) ||
+ (p_ie->block_len & ~A2D_SBC_IE_BLOCKS_MSK) ||
+ (p_ie->num_subbands & ~A2D_SBC_IE_SUBBAND_MSK) ||
+ (p_ie->alloc_mthd & ~A2D_SBC_IE_ALLOC_MD_MSK) ||
+ (p_ie->max_bitpool < p_ie->min_bitpool) ||
+ (p_ie->max_bitpool < A2D_SBC_IE_MIN_BITPOOL) ||
+ (p_ie->max_bitpool > A2D_SBC_IE_MAX_BITPOOL) ||
+ (p_ie->min_bitpool < A2D_SBC_IE_MIN_BITPOOL) ||
+ (p_ie->min_bitpool > A2D_SBC_IE_MAX_BITPOOL) ) {
/* if any unused bit is set */
status = A2D_INVALID_PARAMS;
- }
- else
- {
+ } else {
status = A2D_SUCCESS;
*p_result++ = A2D_SBC_INFO_LEN;
*p_result++ = media_type;
tA2D_STATUS status;
UINT8 losc;
- if( p_ie == NULL || p_info == NULL)
+ if ( p_ie == NULL || p_info == NULL) {
status = A2D_INVALID_PARAMS;
- else
- {
+ } else {
losc = *p_info++;
p_info++;
/* If the function is called for the wrong Media Type or Media Codec Type */
- if(losc != A2D_SBC_INFO_LEN || *p_info != A2D_MEDIA_CT_SBC)
+ if (losc != A2D_SBC_INFO_LEN || *p_info != A2D_MEDIA_CT_SBC) {
status = A2D_WRONG_CODEC;
- else
- {
+ } else {
p_info++;
p_ie->samp_freq = *p_info & A2D_SBC_IE_SAMP_FREQ_MSK;
p_ie->ch_mode = *p_info & A2D_SBC_IE_CH_MD_MSK;
p_ie->min_bitpool = *p_info++;
p_ie->max_bitpool = *p_info;
status = A2D_SUCCESS;
- if(p_ie->min_bitpool < A2D_SBC_IE_MIN_BITPOOL || p_ie->min_bitpool > A2D_SBC_IE_MAX_BITPOOL )
+ if (p_ie->min_bitpool < A2D_SBC_IE_MIN_BITPOOL || p_ie->min_bitpool > A2D_SBC_IE_MAX_BITPOOL ) {
status = A2D_BAD_MIN_BITPOOL;
+ }
- if(p_ie->max_bitpool < A2D_SBC_IE_MIN_BITPOOL || p_ie->max_bitpool > A2D_SBC_IE_MAX_BITPOOL ||
- p_ie->max_bitpool < p_ie->min_bitpool)
+ if (p_ie->max_bitpool < A2D_SBC_IE_MIN_BITPOOL || p_ie->max_bitpool > A2D_SBC_IE_MAX_BITPOOL ||
+ p_ie->max_bitpool < p_ie->min_bitpool) {
status = A2D_BAD_MAX_BITPOOL;
+ }
- if(for_caps == FALSE)
- {
- if(A2D_BitsSet(p_ie->samp_freq) != A2D_SET_ONE_BIT)
+ if (for_caps == FALSE) {
+ if (A2D_BitsSet(p_ie->samp_freq) != A2D_SET_ONE_BIT) {
status = A2D_BAD_SAMP_FREQ;
- if(A2D_BitsSet(p_ie->ch_mode) != A2D_SET_ONE_BIT)
+ }
+ if (A2D_BitsSet(p_ie->ch_mode) != A2D_SET_ONE_BIT) {
status = A2D_BAD_CH_MODE;
- if(A2D_BitsSet(p_ie->block_len) != A2D_SET_ONE_BIT)
+ }
+ if (A2D_BitsSet(p_ie->block_len) != A2D_SET_ONE_BIT) {
status = A2D_BAD_BLOCK_LEN;
- if(A2D_BitsSet(p_ie->num_subbands) != A2D_SET_ONE_BIT)
+ }
+ if (A2D_BitsSet(p_ie->num_subbands) != A2D_SET_ONE_BIT) {
status = A2D_BAD_SUBBANDS;
- if(A2D_BitsSet(p_ie->alloc_mthd) != A2D_SET_ONE_BIT)
+ }
+ if (A2D_BitsSet(p_ie->alloc_mthd) != A2D_SET_ONE_BIT) {
status = A2D_BAD_ALLOC_MTHD;
+ }
}
}
}
******************************************************************************/
void A2D_BldSbcMplHdr(UINT8 *p_dst, BOOLEAN frag, BOOLEAN start, BOOLEAN last, UINT8 num)
{
- if(p_dst)
- {
+ if (p_dst) {
*p_dst = 0;
- if(frag)
+ if (frag) {
*p_dst |= A2D_SBC_HDR_F_MSK;
- if(start)
+ }
+ if (start) {
*p_dst |= A2D_SBC_HDR_S_MSK;
- if(last)
+ }
+ if (last) {
*p_dst |= A2D_SBC_HDR_L_MSK;
+ }
*p_dst |= (A2D_SBC_HDR_NUM_MSK & num);
}
}
******************************************************************************/
void A2D_ParsSbcMplHdr(UINT8 *p_src, BOOLEAN *p_frag, BOOLEAN *p_start, BOOLEAN *p_last, UINT8 *p_num)
{
- if(p_src && p_frag && p_start && p_last && p_num)
- {
- *p_frag = (*p_src & A2D_SBC_HDR_F_MSK) ? TRUE: FALSE;
- *p_start= (*p_src & A2D_SBC_HDR_S_MSK) ? TRUE: FALSE;
- *p_last = (*p_src & A2D_SBC_HDR_L_MSK) ? TRUE: FALSE;
+ if (p_src && p_frag && p_start && p_last && p_num) {
+ *p_frag = (*p_src & A2D_SBC_HDR_F_MSK) ? TRUE : FALSE;
+ *p_start = (*p_src & A2D_SBC_HDR_S_MSK) ? TRUE : FALSE;
+ *p_last = (*p_src & A2D_SBC_HDR_L_MSK) ? TRUE : FALSE;
*p_num = (*p_src & A2D_SBC_HDR_NUM_MSK);
}
}
*****************************************************************************/
/* Control block used by A2D_FindService(). */
-typedef struct
-{
+typedef struct {
tA2D_FIND_CBACK *p_cback; /* pointer to application callback */
tSDP_DISCOVERY_DB *p_db; /* pointer to discovery database */
UINT16 service_uuid; /* service UUID of search */
} tA2D_FIND_CB;
-typedef struct
-{
+typedef struct {
tA2D_FIND_CB find; /* find service control block */
UINT8 trace_level;
BOOLEAN use_desc;
BTM_SetSecurityLevel(TRUE, "", BTM_SEC_SERVICE_AVCTP_BROWSE, sec_mask, AVCT_BR_PSM, 0, 0);
BTM_SetSecurityLevel(FALSE, "", BTM_SEC_SERVICE_AVCTP_BROWSE, sec_mask, AVCT_BR_PSM, 0, 0);
- if (mtu_br < AVCT_MIN_BROWSE_MTU)
+ if (mtu_br < AVCT_MIN_BROWSE_MTU) {
mtu_br = AVCT_MIN_BROWSE_MTU;
+ }
avct_cb.mtu_br = mtu_br;
#endif
avct_cb.trace_level = BT_TRACE_LEVEL_NONE;
#endif
- if (mtu < AVCT_MIN_CONTROL_MTU)
+ if (mtu < AVCT_MIN_CONTROL_MTU) {
mtu = AVCT_MIN_CONTROL_MTU;
+ }
/* store mtu */
avct_cb.mtu = mtu;
}
AVCT_TRACE_API("AVCT_CreateConn: %d, control:%d", p_cc->role, p_cc->control);
/* Allocate ccb; if no ccbs, return failure */
- if ((p_ccb = avct_ccb_alloc(p_cc)) == NULL)
- {
+ if ((p_ccb = avct_ccb_alloc(p_cc)) == NULL) {
result = AVCT_NO_RESOURCES;
- }
- else
- {
+ } else {
/* get handle */
*p_handle = avct_ccb_to_idx(p_ccb);
/* if initiator connection */
- if (p_cc->role == AVCT_INT)
- {
+ if (p_cc->role == AVCT_INT) {
/* find link; if none allocate a new one */
- if ((p_lcb = avct_lcb_by_bd(peer_addr)) == NULL)
- {
- if ((p_lcb = avct_lcb_alloc(peer_addr)) == NULL)
- {
+ if ((p_lcb = avct_lcb_by_bd(peer_addr)) == NULL) {
+ if ((p_lcb = avct_lcb_alloc(peer_addr)) == NULL) {
/* no link resources; free ccb as well */
avct_ccb_dealloc(p_ccb, AVCT_NO_EVT, 0, NULL);
result = AVCT_NO_RESOURCES;
}
}
/* check if PID already in use */
- else if (avct_lcb_has_pid(p_lcb, p_cc->pid))
- {
+ else if (avct_lcb_has_pid(p_lcb, p_cc->pid)) {
avct_ccb_dealloc(p_ccb, AVCT_NO_EVT, 0, NULL);
result = AVCT_PID_IN_USE;
}
- if (result == AVCT_SUCCESS)
- {
+ if (result == AVCT_SUCCESS) {
/* bind lcb to ccb */
p_ccb->p_lcb = p_lcb;
AVCT_TRACE_DEBUG("ch_state: %d", p_lcb->ch_state);
AVCT_TRACE_API("AVCT_RemoveConn");
/* map handle to ccb */
- if ((p_ccb = avct_ccb_by_idx(handle)) == NULL)
- {
+ if ((p_ccb = avct_ccb_by_idx(handle)) == NULL) {
result = AVCT_BAD_HANDLE;
}
/* if connection not bound to lcb, dealloc */
- else if (p_ccb->p_lcb == NULL)
- {
+ else if (p_ccb->p_lcb == NULL) {
avct_ccb_dealloc(p_ccb, AVCT_NO_EVT, 0, NULL);
}
/* send unbind event to lcb */
- else
- {
+ else {
avct_lcb_event(p_ccb->p_lcb, AVCT_LCB_UL_UNBIND_EVT, (tAVCT_LCB_EVT *) &p_ccb);
}
return result;
AVCT_TRACE_API("AVCT_CreateBrowse: %d", role);
/* map handle to ccb */
- if ((p_ccb = avct_ccb_by_idx(handle)) == NULL)
- {
+ if ((p_ccb = avct_ccb_by_idx(handle)) == NULL) {
return AVCT_BAD_HANDLE;
- }
- else
- {
+ } else {
/* mark this CCB as supporting browsing channel */
- if ((p_ccb->allocated & AVCT_ALOC_BCB) == 0)
- {
+ if ((p_ccb->allocated & AVCT_ALOC_BCB) == 0) {
p_ccb->allocated |= AVCT_ALOC_BCB;
}
}
/* if initiator connection */
- if (role == AVCT_INT)
- {
+ if (role == AVCT_INT) {
/* the link control block must exist before this function is called as INT. */
- if ((p_ccb->p_lcb == NULL) || (p_ccb->p_lcb->allocated == 0))
- {
+ if ((p_ccb->p_lcb == NULL) || (p_ccb->p_lcb->allocated == 0)) {
result = AVCT_NOT_OPEN;
- }
- else
- {
+ } else {
/* find link; if none allocate a new one */
index = p_ccb->p_lcb->allocated;
- if (index > AVCT_NUM_LINKS)
- {
+ if (index > AVCT_NUM_LINKS) {
result = AVCT_BAD_HANDLE;
- }
- else
- {
+ } else {
p_bcb = &avct_cb.bcb[index - 1];
p_bcb->allocated = index;
}
}
- if (result == AVCT_SUCCESS)
- {
+ if (result == AVCT_SUCCESS) {
/* bind bcb to ccb */
p_ccb->p_bcb = p_bcb;
AVCT_TRACE_DEBUG("ch_state: %d", p_bcb->ch_state);
AVCT_TRACE_API("AVCT_RemoveBrowse");
/* map handle to ccb */
- if ((p_ccb = avct_ccb_by_idx(handle)) == NULL)
- {
+ if ((p_ccb = avct_ccb_by_idx(handle)) == NULL) {
result = AVCT_BAD_HANDLE;
- }
- else if (p_ccb->p_bcb != NULL)
- /* send unbind event to bcb */
+ } else if (p_ccb->p_bcb != NULL)
+ /* send unbind event to bcb */
{
avct_bcb_event(p_ccb->p_bcb, AVCT_LCB_UL_UNBIND_EVT, (tAVCT_LCB_EVT *) &p_ccb);
}
#if (AVCT_BROWSE_INCLUDED == TRUE)
tAVCT_CCB *p_ccb;
- if ((p_ccb = avct_ccb_by_idx(handle)) != NULL && p_ccb->p_bcb != NULL)
- {
+ if ((p_ccb = avct_ccb_by_idx(handle)) != NULL && p_ccb->p_bcb != NULL) {
peer_mtu = p_ccb->p_bcb->peer_mtu;
}
#else
tAVCT_CCB *p_ccb;
/* map handle to ccb */
- if ((p_ccb = avct_ccb_by_idx(handle)) != NULL)
- {
- if (p_ccb->p_lcb)
- {
+ if ((p_ccb = avct_ccb_by_idx(handle)) != NULL) {
+ if (p_ccb->p_lcb) {
peer_mtu = p_ccb->p_lcb->peer_mtu;
}
}
AVCT_TRACE_API("AVCT_MsgReq");
/* verify p_msg parameter */
- if (p_msg == NULL)
- {
+ if (p_msg == NULL) {
return AVCT_NO_RESOURCES;
}
AVCT_TRACE_API("len: %d", p_msg->len);
/* map handle to ccb */
- if ((p_ccb = avct_ccb_by_idx(handle)) == NULL)
- {
+ if ((p_ccb = avct_ccb_by_idx(handle)) == NULL) {
result = AVCT_BAD_HANDLE;
GKI_freebuf(p_msg);
}
/* verify channel is bound to link */
- else if (p_ccb->p_lcb == NULL)
- {
+ else if (p_ccb->p_lcb == NULL) {
result = AVCT_NOT_OPEN;
GKI_freebuf(p_msg);
}
- if (result == AVCT_SUCCESS)
- {
+ if (result == AVCT_SUCCESS) {
ul_msg.p_buf = p_msg;
ul_msg.p_ccb = p_ccb;
ul_msg.label = label;
#if (AVCT_BROWSE_INCLUDED == TRUE)
/* send msg event to bcb */
- if (p_msg->layer_specific == AVCT_DATA_BROWSE)
- {
- if (p_ccb->p_bcb == NULL && (p_ccb->allocated & AVCT_ALOC_BCB) == 0)
- {
+ if (p_msg->layer_specific == AVCT_DATA_BROWSE) {
+ if (p_ccb->p_bcb == NULL && (p_ccb->allocated & AVCT_ALOC_BCB) == 0) {
/* BCB channel is not open and not allocated */
result = AVCT_BAD_HANDLE;
GKI_freebuf(p_msg);
- }
- else
- {
+ } else {
p_ccb->p_bcb = avct_bcb_by_lcb(p_ccb->p_lcb);
avct_bcb_event(p_ccb->p_bcb, AVCT_LCB_UL_MSG_EVT, (tAVCT_LCB_EVT *) &ul_msg);
}
tAVCT_CCB *p_ccb = &avct_cb.ccb[0];
int i;
- for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++)
- {
- if (!p_ccb->allocated)
- {
+ for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++) {
+ if (!p_ccb->allocated) {
p_ccb->allocated = AVCT_ALOC_LCB;
memcpy(&p_ccb->cc, p_cc, sizeof(tAVCT_CC));
AVCT_TRACE_DEBUG("avct_ccb_alloc %d", i);
}
}
- if (i == AVCT_NUM_CONN)
- {
+ if (i == AVCT_NUM_CONN) {
/* out of ccbs */
p_ccb = NULL;
AVCT_TRACE_WARNING("Out of ccbs");
AVCT_TRACE_DEBUG("avct_ccb_dealloc %d", avct_ccb_to_idx(p_ccb));
#if (AVCT_BROWSE_INCLUDED == TRUE)
- if(p_ccb->p_bcb == NULL)
+ if (p_ccb->p_bcb == NULL) {
memset(p_ccb, 0, sizeof(tAVCT_CCB));
- else
- {
+ } else {
/* control channel is down, but the browsing channel is still connected 0 disconnect it now */
avct_bcb_event(p_ccb->p_bcb, AVCT_LCB_UL_UNBIND_EVT, (tAVCT_LCB_EVT *) &p_ccb);
p_ccb->p_lcb = NULL;
memset(p_ccb, 0, sizeof(tAVCT_CCB));
#endif
- if (event != AVCT_NO_EVT)
- {
+ if (event != AVCT_NO_EVT) {
(*p_cback)(avct_ccb_to_idx(p_ccb), event, result, bd_addr);
}
}
tAVCT_CCB *p_ccb;
/* verify index */
- if (idx < AVCT_NUM_CONN)
- {
+ if (idx < AVCT_NUM_CONN) {
p_ccb = &avct_cb.ccb[idx];
/* verify ccb is allocated */
- if (!p_ccb->allocated)
- {
+ if (!p_ccb->allocated) {
p_ccb = NULL;
AVCT_TRACE_WARNING("ccb %d not allocated", idx);
}
- }
- else
- {
+ } else {
p_ccb = NULL;
AVCT_TRACE_WARNING("No ccb for idx %d", idx);
}
tAVCT_CCB *p_ccb = &avct_cb.ccb[0];
int i;
- for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++)
- {
- if (p_ccb->allocated && (p_ccb->p_lcb == p_lcb))
- {
+ for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++) {
+ if (p_ccb->allocated && (p_ccb->p_lcb == p_lcb)) {
AVCT_TRACE_DEBUG("avct_l2c_is_ct control:x%x", p_ccb->cc.control);
- if (p_ccb->cc.control & AVCT_PASSIVE)
- {
+ if (p_ccb->cc.control & AVCT_PASSIVE) {
is_passive = TRUE;
break;
}
UNUSED(psm);
/* do we already have a channel for this peer? */
- if ((p_lcb = avct_lcb_by_bd(bd_addr)) == NULL)
- {
+ if ((p_lcb = avct_lcb_by_bd(bd_addr)) == NULL) {
/* no, allocate lcb */
- if ((p_lcb = avct_lcb_alloc(bd_addr)) == NULL)
- {
+ if ((p_lcb = avct_lcb_alloc(bd_addr)) == NULL) {
/* no ccb available, reject L2CAP connection */
result = L2CAP_CONN_NO_RESOURCES;
}
}
/* else we already have a channel for this peer */
- else
- {
- if (!avct_l2c_is_passive (p_lcb) || (p_lcb->ch_state == AVCT_CH_OPEN))
- {
+ else {
+ if (!avct_l2c_is_passive (p_lcb) || (p_lcb->ch_state == AVCT_CH_OPEN)) {
/* this LCB included CT role - reject */
result = L2CAP_CONN_NO_RESOURCES;
- }
- else
- {
+ } else {
/* TG role only - accept the connection from CT. move the channel ID to the conflict list */
p_lcb->conflict_lcid = p_lcb->ch_lcid;
AVCT_TRACE_DEBUG("avct_l2c_connect_ind_cback conflict_lcid:0x%x", p_lcb->conflict_lcid);
}
}
- if(p_lcb)
- {
+ if (p_lcb) {
AVCT_TRACE_DEBUG("avct_l2c_connect_ind_cback: 0x%x, res: %d, ch_state: %d",
- lcid, result, p_lcb->ch_state);
+ lcid, result, p_lcb->ch_state);
}
/* Send L2CAP connect rsp */
L2CA_ConnectRsp(bd_addr, id, lcid, result, 0);
/* if result ok, proceed with connection */
- if (result == L2CAP_CONN_OK)
- {
+ if (result == L2CAP_CONN_OK) {
/* store LCID */
p_lcb->ch_lcid = lcid;
}
#if (BT_USE_TRACES == TRUE)
- if(p_lcb)
+ if (p_lcb) {
AVCT_TRACE_DEBUG("ch_state cni: %d ", p_lcb->ch_state);
+ }
#endif
}
tL2CAP_CFG_INFO cfg;
/* look up lcb for this channel */
- if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL)
- {
+ if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL) {
AVCT_TRACE_DEBUG("avct_l2c_connect_cfm_cback lcid:0x%x result: %d ch_state: %d, conflict_lcid:0x%x",
- lcid, result, p_lcb->ch_state, p_lcb->conflict_lcid);
+ lcid, result, p_lcb->ch_state, p_lcb->conflict_lcid);
/* if in correct state */
- if (p_lcb->ch_state == AVCT_CH_CONN)
- {
+ if (p_lcb->ch_state == AVCT_CH_CONN) {
/* if result successful */
- if (result == L2CAP_CONN_OK)
- {
+ if (result == L2CAP_CONN_OK) {
/* set channel state */
p_lcb->ch_state = AVCT_CH_CFG;
AVCT_TRACE_DEBUG("avct_l2c snd Cfg Req");
}
/* else failure */
- else
- {
+ else {
AVCT_TRACE_DEBUG("avct_l2c_connect_cfm_cback conflict_lcid:0x%x", p_lcb->conflict_lcid);
- if (p_lcb->conflict_lcid == lcid)
+ if (p_lcb->conflict_lcid == lcid) {
p_lcb->conflict_lcid = 0;
- else
+ } else {
avct_lcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, (tAVCT_LCB_EVT *) &result);
+ }
}
- }
- else if (p_lcb->conflict_lcid == lcid)
- {
+ } else if (p_lcb->conflict_lcid == lcid) {
/* we must be in AVCT_CH_CFG state for the ch_lcid channel */
AVCT_TRACE_DEBUG("avct_l2c_connect_cfm_cback ch_state: %d, conflict_lcid:0x%x", p_lcb->ch_state, p_lcb->conflict_lcid);
- if (result == L2CAP_CONN_OK)
- {
+ if (result == L2CAP_CONN_OK) {
/* just in case the peer also accepts our connection - Send L2CAP disconnect req */
L2CA_DisconnectReq(lcid);
}
tAVCT_LCB *p_lcb;
/* look up lcb for this channel */
- if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL)
- {
+ if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL) {
AVCT_TRACE_DEBUG("avct_l2c_config_cfm_cback: 0x%x, ch_state: %d, res: %d",
- lcid, p_lcb->ch_state, p_cfg->result);
+ lcid, p_lcb->ch_state, p_cfg->result);
/* if in correct state */
- if (p_lcb->ch_state == AVCT_CH_CFG)
- {
+ if (p_lcb->ch_state == AVCT_CH_CFG) {
/* if result successful */
- if (p_cfg->result == L2CAP_CFG_OK)
- {
+ if (p_cfg->result == L2CAP_CFG_OK) {
/* update flags */
p_lcb->ch_flags |= AVCT_L2C_CFG_CFM_DONE;
/* if configuration complete */
- if (p_lcb->ch_flags & AVCT_L2C_CFG_IND_DONE)
- {
+ if (p_lcb->ch_flags & AVCT_L2C_CFG_IND_DONE) {
p_lcb->ch_state = AVCT_CH_OPEN;
avct_lcb_event(p_lcb, AVCT_LCB_LL_OPEN_EVT, NULL);
}
}
/* else failure */
- else
- {
+ else {
AVCT_TRACE_DEBUG("ERROR avct_l2c_config_cfm_cback L2CA_DisconnectReq %d ", p_lcb->ch_state);
/* store result value */
p_lcb->ch_result = p_cfg->result;
tAVCT_LCB *p_lcb;
/* look up lcb for this channel */
- if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL)
- {
+ if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL) {
AVCT_TRACE_DEBUG("avct_l2c_config_ind_cback: 0x%x, ch_state: %d", lcid, p_lcb->ch_state);
/* store the mtu in tbl */
- if (p_cfg->mtu_present)
- {
+ if (p_cfg->mtu_present) {
p_lcb->peer_mtu = p_cfg->mtu;
- }
- else
- {
+ } else {
p_lcb->peer_mtu = L2CAP_DEFAULT_MTU;
}
L2CA_ConfigRsp(lcid, p_cfg);
/* if first config ind */
- if ((p_lcb->ch_flags & AVCT_L2C_CFG_IND_DONE) == 0)
- {
+ if ((p_lcb->ch_flags & AVCT_L2C_CFG_IND_DONE) == 0) {
/* update flags */
p_lcb->ch_flags |= AVCT_L2C_CFG_IND_DONE;
/* if configuration complete */
- if (p_lcb->ch_flags & AVCT_L2C_CFG_CFM_DONE)
- {
+ if (p_lcb->ch_flags & AVCT_L2C_CFG_CFM_DONE) {
p_lcb->ch_state = AVCT_CH_OPEN;
avct_lcb_event(p_lcb, AVCT_LCB_LL_OPEN_EVT, NULL);
}
UINT16 result = AVCT_RESULT_FAIL;
/* look up lcb for this channel */
- if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL)
- {
+ if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL) {
AVCT_TRACE_DEBUG("avct_l2c_disconnect_ind_cback: 0x%x, ch_state: %d", lcid, p_lcb->ch_state);
- if (ack_needed)
- {
+ if (ack_needed) {
/* send L2CAP disconnect response */
L2CA_DisconnectRsp(lcid);
}
UINT16 res;
/* look up lcb for this channel */
- if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL)
- {
+ if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL) {
AVCT_TRACE_DEBUG("avct_l2c_disconnect_cfm_cback: 0x%x, ch_state: %d, res: %d",
- lcid, p_lcb->ch_state, result);
+ lcid, p_lcb->ch_state, result);
/* result value may be previously stored */
res = (p_lcb->ch_result != 0) ? p_lcb->ch_result : result;
p_lcb->ch_result = 0;
AVCT_TRACE_DEBUG("avct_l2c_congestion_ind_cback: 0x%x", lcid);
/* look up lcb for this channel */
- if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL)
- {
+ if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL) {
avct_lcb_event(p_lcb, AVCT_LCB_LL_CONG_EVT, (tAVCT_LCB_EVT *) &is_congested);
}
}
AVCT_TRACE_DEBUG("avct_l2c_data_ind_cback: 0x%x", lcid);
/* look up lcb for this channel */
- if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL)
- {
+ if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL) {
avct_lcb_event(p_lcb, AVCT_LCB_LL_MSG_EVT, (tAVCT_LCB_EVT *) &p_buf);
- }
- else /* prevent buffer leak */
- {
+ } else { /* prevent buffer leak */
AVCT_TRACE_WARNING("ERROR -> avct_l2c_data_ind_cback drop buffer");
GKI_freebuf(p_buf);
}
#if BT_TRACE_VERBOSE == TRUE
/* verbose state strings for trace */
-const char * const avct_lcb_st_str[] = {
+const char *const avct_lcb_st_str[] = {
"LCB_IDLE_ST",
"LCB_OPENING_ST",
"LCB_OPEN_ST",
};
/* verbose event strings for trace */
-const char * const avct_lcb_evt_str[] = {
+const char *const avct_lcb_evt_str[] = {
"UL_BIND_EVT",
"UL_UNBIND_EVT",
"UL_MSG_EVT",
/* state table for idle state */
const UINT8 avct_lcb_st_idle[][AVCT_LCB_NUM_COLS] = {
-/* Event Action 1 Action 2 Next state */
-/* UL_BIND_EVT */ {AVCT_LCB_CHNL_OPEN, AVCT_LCB_IGNORE, AVCT_LCB_OPENING_ST},
-/* UL_UNBIND_EVT */ {AVCT_LCB_UNBIND_DISC, AVCT_LCB_IGNORE, AVCT_LCB_IDLE_ST},
-/* UL_MSG_EVT */ {AVCT_LCB_DISCARD_MSG, AVCT_LCB_IGNORE, AVCT_LCB_IDLE_ST},
-/* INT_CLOSE_EVT */ {AVCT_LCB_IGNORE, AVCT_LCB_IGNORE, AVCT_LCB_IDLE_ST},
-/* LL_OPEN_EVT */ {AVCT_LCB_OPEN_IND, AVCT_LCB_IGNORE, AVCT_LCB_OPEN_ST},
-/* LL_CLOSE_EVT */ {AVCT_LCB_CLOSE_IND, AVCT_LCB_DEALLOC, AVCT_LCB_IDLE_ST},
-/* LL_MSG_EVT */ {AVCT_LCB_FREE_MSG_IND, AVCT_LCB_IGNORE, AVCT_LCB_IDLE_ST},
-/* LL_CONG_EVT */ {AVCT_LCB_IGNORE, AVCT_LCB_IGNORE, AVCT_LCB_IDLE_ST}
+ /* Event Action 1 Action 2 Next state */
+ /* UL_BIND_EVT */ {AVCT_LCB_CHNL_OPEN, AVCT_LCB_IGNORE, AVCT_LCB_OPENING_ST},
+ /* UL_UNBIND_EVT */ {AVCT_LCB_UNBIND_DISC, AVCT_LCB_IGNORE, AVCT_LCB_IDLE_ST},
+ /* UL_MSG_EVT */ {AVCT_LCB_DISCARD_MSG, AVCT_LCB_IGNORE, AVCT_LCB_IDLE_ST},
+ /* INT_CLOSE_EVT */ {AVCT_LCB_IGNORE, AVCT_LCB_IGNORE, AVCT_LCB_IDLE_ST},
+ /* LL_OPEN_EVT */ {AVCT_LCB_OPEN_IND, AVCT_LCB_IGNORE, AVCT_LCB_OPEN_ST},
+ /* LL_CLOSE_EVT */ {AVCT_LCB_CLOSE_IND, AVCT_LCB_DEALLOC, AVCT_LCB_IDLE_ST},
+ /* LL_MSG_EVT */ {AVCT_LCB_FREE_MSG_IND, AVCT_LCB_IGNORE, AVCT_LCB_IDLE_ST},
+ /* LL_CONG_EVT */ {AVCT_LCB_IGNORE, AVCT_LCB_IGNORE, AVCT_LCB_IDLE_ST}
};
/* state table for opening state */
const UINT8 avct_lcb_st_opening[][AVCT_LCB_NUM_COLS] = {
-/* Event Action 1 Action 2 Next state */
-/* UL_BIND_EVT */ {AVCT_LCB_IGNORE, AVCT_LCB_IGNORE, AVCT_LCB_OPENING_ST},
-/* UL_UNBIND_EVT */ {AVCT_LCB_UNBIND_DISC, AVCT_LCB_IGNORE, AVCT_LCB_OPENING_ST},
-/* UL_MSG_EVT */ {AVCT_LCB_DISCARD_MSG, AVCT_LCB_IGNORE, AVCT_LCB_OPENING_ST},
-/* INT_CLOSE_EVT */ {AVCT_LCB_CHNL_DISC, AVCT_LCB_IGNORE, AVCT_LCB_CLOSING_ST},
-/* LL_OPEN_EVT */ {AVCT_LCB_OPEN_IND, AVCT_LCB_IGNORE, AVCT_LCB_OPEN_ST},
-/* LL_CLOSE_EVT */ {AVCT_LCB_OPEN_FAIL, AVCT_LCB_DEALLOC, AVCT_LCB_IDLE_ST},
-/* LL_MSG_EVT */ {AVCT_LCB_FREE_MSG_IND, AVCT_LCB_IGNORE, AVCT_LCB_OPENING_ST},
-/* LL_CONG_EVT */ {AVCT_LCB_CONG_IND, AVCT_LCB_IGNORE, AVCT_LCB_OPENING_ST}
+ /* Event Action 1 Action 2 Next state */
+ /* UL_BIND_EVT */ {AVCT_LCB_IGNORE, AVCT_LCB_IGNORE, AVCT_LCB_OPENING_ST},
+ /* UL_UNBIND_EVT */ {AVCT_LCB_UNBIND_DISC, AVCT_LCB_IGNORE, AVCT_LCB_OPENING_ST},
+ /* UL_MSG_EVT */ {AVCT_LCB_DISCARD_MSG, AVCT_LCB_IGNORE, AVCT_LCB_OPENING_ST},
+ /* INT_CLOSE_EVT */ {AVCT_LCB_CHNL_DISC, AVCT_LCB_IGNORE, AVCT_LCB_CLOSING_ST},
+ /* LL_OPEN_EVT */ {AVCT_LCB_OPEN_IND, AVCT_LCB_IGNORE, AVCT_LCB_OPEN_ST},
+ /* LL_CLOSE_EVT */ {AVCT_LCB_OPEN_FAIL, AVCT_LCB_DEALLOC, AVCT_LCB_IDLE_ST},
+ /* LL_MSG_EVT */ {AVCT_LCB_FREE_MSG_IND, AVCT_LCB_IGNORE, AVCT_LCB_OPENING_ST},
+ /* LL_CONG_EVT */ {AVCT_LCB_CONG_IND, AVCT_LCB_IGNORE, AVCT_LCB_OPENING_ST}
};
/* state table for open state */
const UINT8 avct_lcb_st_open[][AVCT_LCB_NUM_COLS] = {
-/* Event Action 1 Action 2 Next state */
-/* UL_BIND_EVT */ {AVCT_LCB_BIND_CONN, AVCT_LCB_IGNORE, AVCT_LCB_OPEN_ST},
-/* UL_UNBIND_EVT */ {AVCT_LCB_CHK_DISC, AVCT_LCB_IGNORE, AVCT_LCB_OPEN_ST},
-/* UL_MSG_EVT */ {AVCT_LCB_SEND_MSG, AVCT_LCB_IGNORE, AVCT_LCB_OPEN_ST},
-/* INT_CLOSE_EVT */ {AVCT_LCB_CHNL_DISC, AVCT_LCB_IGNORE, AVCT_LCB_CLOSING_ST},
-/* LL_OPEN_EVT */ {AVCT_LCB_IGNORE, AVCT_LCB_IGNORE, AVCT_LCB_OPEN_ST},
-/* LL_CLOSE_EVT */ {AVCT_LCB_CLOSE_IND, AVCT_LCB_DEALLOC, AVCT_LCB_IDLE_ST},
-/* LL_MSG_EVT */ {AVCT_LCB_MSG_IND, AVCT_LCB_IGNORE, AVCT_LCB_OPEN_ST},
-/* LL_CONG_EVT */ {AVCT_LCB_CONG_IND, AVCT_LCB_IGNORE, AVCT_LCB_OPEN_ST}
+ /* Event Action 1 Action 2 Next state */
+ /* UL_BIND_EVT */ {AVCT_LCB_BIND_CONN, AVCT_LCB_IGNORE, AVCT_LCB_OPEN_ST},
+ /* UL_UNBIND_EVT */ {AVCT_LCB_CHK_DISC, AVCT_LCB_IGNORE, AVCT_LCB_OPEN_ST},
+ /* UL_MSG_EVT */ {AVCT_LCB_SEND_MSG, AVCT_LCB_IGNORE, AVCT_LCB_OPEN_ST},
+ /* INT_CLOSE_EVT */ {AVCT_LCB_CHNL_DISC, AVCT_LCB_IGNORE, AVCT_LCB_CLOSING_ST},
+ /* LL_OPEN_EVT */ {AVCT_LCB_IGNORE, AVCT_LCB_IGNORE, AVCT_LCB_OPEN_ST},
+ /* LL_CLOSE_EVT */ {AVCT_LCB_CLOSE_IND, AVCT_LCB_DEALLOC, AVCT_LCB_IDLE_ST},
+ /* LL_MSG_EVT */ {AVCT_LCB_MSG_IND, AVCT_LCB_IGNORE, AVCT_LCB_OPEN_ST},
+ /* LL_CONG_EVT */ {AVCT_LCB_CONG_IND, AVCT_LCB_IGNORE, AVCT_LCB_OPEN_ST}
};
/* state table for closing state */
const UINT8 avct_lcb_st_closing[][AVCT_LCB_NUM_COLS] = {
-/* Event Action 1 Action 2 Next state */
-/* UL_BIND_EVT */ {AVCT_LCB_BIND_FAIL, AVCT_LCB_IGNORE, AVCT_LCB_CLOSING_ST},
-/* UL_UNBIND_EVT */ {AVCT_LCB_IGNORE, AVCT_LCB_IGNORE, AVCT_LCB_CLOSING_ST},
-/* UL_MSG_EVT */ {AVCT_LCB_DISCARD_MSG, AVCT_LCB_IGNORE, AVCT_LCB_CLOSING_ST},
-/* INT_CLOSE_EVT */ {AVCT_LCB_IGNORE, AVCT_LCB_IGNORE, AVCT_LCB_CLOSING_ST},
-/* LL_OPEN_EVT */ {AVCT_LCB_IGNORE, AVCT_LCB_IGNORE, AVCT_LCB_CLOSING_ST},
-/* LL_CLOSE_EVT */ {AVCT_LCB_CLOSE_CFM, AVCT_LCB_DEALLOC, AVCT_LCB_IDLE_ST},
-/* LL_MSG_EVT */ {AVCT_LCB_FREE_MSG_IND, AVCT_LCB_IGNORE, AVCT_LCB_CLOSING_ST},
-/* LL_CONG_EVT */ {AVCT_LCB_IGNORE, AVCT_LCB_IGNORE, AVCT_LCB_CLOSING_ST}
+ /* Event Action 1 Action 2 Next state */
+ /* UL_BIND_EVT */ {AVCT_LCB_BIND_FAIL, AVCT_LCB_IGNORE, AVCT_LCB_CLOSING_ST},
+ /* UL_UNBIND_EVT */ {AVCT_LCB_IGNORE, AVCT_LCB_IGNORE, AVCT_LCB_CLOSING_ST},
+ /* UL_MSG_EVT */ {AVCT_LCB_DISCARD_MSG, AVCT_LCB_IGNORE, AVCT_LCB_CLOSING_ST},
+ /* INT_CLOSE_EVT */ {AVCT_LCB_IGNORE, AVCT_LCB_IGNORE, AVCT_LCB_CLOSING_ST},
+ /* LL_OPEN_EVT */ {AVCT_LCB_IGNORE, AVCT_LCB_IGNORE, AVCT_LCB_CLOSING_ST},
+ /* LL_CLOSE_EVT */ {AVCT_LCB_CLOSE_CFM, AVCT_LCB_DEALLOC, AVCT_LCB_IDLE_ST},
+ /* LL_MSG_EVT */ {AVCT_LCB_FREE_MSG_IND, AVCT_LCB_IGNORE, AVCT_LCB_CLOSING_ST},
+ /* LL_CONG_EVT */ {AVCT_LCB_IGNORE, AVCT_LCB_IGNORE, AVCT_LCB_CLOSING_ST}
};
/* type for state table */
p_lcb->state = state_table[event][AVCT_LCB_NEXT_STATE];
/* execute action functions */
- for (i = 0; i < AVCT_LCB_ACTIONS; i++)
- {
- if ((action = state_table[event][i]) != AVCT_LCB_IGNORE)
- {
+ for (i = 0; i < AVCT_LCB_ACTIONS; i++) {
+ if ((action = state_table[event][i]) != AVCT_LCB_IGNORE) {
(*avct_lcb_action[action])(p_lcb, p_data);
- }
- else
- {
+ } else {
break;
}
}
p_bcb->state = state_table[event][AVCT_LCB_NEXT_STATE];
/* execute action functions */
- for (i = 0; i < AVCT_LCB_ACTIONS; i++)
- {
- if ((action = state_table[event][i]) != AVCT_LCB_IGNORE)
- {
+ for (i = 0; i < AVCT_LCB_ACTIONS; i++) {
+ if ((action = state_table[event][i]) != AVCT_LCB_IGNORE) {
(*avct_bcb_action[action])(p_bcb, p_data);
- }
- else
- {
+ } else {
break;
}
}
tAVCT_LCB *p_lcb = &avct_cb.lcb[0];
int i;
- for (i = 0; i < AVCT_NUM_LINKS; i++, p_lcb++)
- {
+ for (i = 0; i < AVCT_NUM_LINKS; i++, p_lcb++) {
/* if allocated lcb has matching lcb */
- if (p_lcb->allocated && (!memcmp(p_lcb->peer_addr, bd_addr, BD_ADDR_LEN)))
- {
+ if (p_lcb->allocated && (!memcmp(p_lcb->peer_addr, bd_addr, BD_ADDR_LEN))) {
break;
}
}
- if (i == AVCT_NUM_LINKS)
- {
+ if (i == AVCT_NUM_LINKS) {
/* if no lcb found */
p_lcb = NULL;
AVCT_TRACE_DEBUG("No lcb for addr %02x-%02x-%02x-%02x-%02x-%02x",
- bd_addr[0], bd_addr[1], bd_addr[2], bd_addr[3], bd_addr[4], bd_addr[5]);
+ bd_addr[0], bd_addr[1], bd_addr[2], bd_addr[3], bd_addr[4], bd_addr[5]);
}
return p_lcb;
}
tAVCT_LCB *p_lcb = &avct_cb.lcb[0];
int i;
- for (i = 0; i < AVCT_NUM_LINKS; i++, p_lcb++)
- {
- if (!p_lcb->allocated)
- {
+ for (i = 0; i < AVCT_NUM_LINKS; i++, p_lcb++) {
+ if (!p_lcb->allocated) {
p_lcb->allocated = (UINT8)(i + 1);
memcpy(p_lcb->peer_addr, bd_addr, BD_ADDR_LEN);
AVCT_TRACE_DEBUG("avct_lcb_alloc %d", p_lcb->allocated);
}
}
- if (i == AVCT_NUM_LINKS)
- {
+ if (i == AVCT_NUM_LINKS) {
/* out of lcbs */
p_lcb = NULL;
AVCT_TRACE_WARNING("Out of lcbs");
AVCT_TRACE_DEBUG("avct_lcb_dealloc %d", p_lcb->allocated);
- for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++)
- {
+ for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++) {
/* if ccb allocated and */
- if (p_ccb->allocated)
- {
- if (p_ccb->p_lcb == p_lcb)
- {
+ if (p_ccb->allocated) {
+ if (p_ccb->p_lcb == p_lcb) {
AVCT_TRACE_DEBUG("avct_lcb_dealloc used by ccb: %d", i);
found = TRUE;
break;
}
}
- if (!found)
- {
+ if (!found) {
AVCT_TRACE_DEBUG("avct_lcb_dealloc now");
/* clear reassembled msg buffer if in use */
- if (p_lcb->p_rx_msg != NULL)
- {
+ if (p_lcb->p_rx_msg != NULL) {
GKI_freebuf(p_lcb->p_rx_msg);
}
memset(p_lcb, 0, sizeof(tAVCT_LCB));
tAVCT_LCB *p_lcb = &avct_cb.lcb[0];
int i;
- for (i = 0; i < AVCT_NUM_LINKS; i++, p_lcb++)
- {
- if (p_lcb->allocated && ((p_lcb->ch_lcid == lcid) || (p_lcb->conflict_lcid == lcid)))
- {
+ for (i = 0; i < AVCT_NUM_LINKS; i++, p_lcb++) {
+ if (p_lcb->allocated && ((p_lcb->ch_lcid == lcid) || (p_lcb->conflict_lcid == lcid))) {
break;
}
}
- if (i == AVCT_NUM_LINKS)
- {
+ if (i == AVCT_NUM_LINKS) {
/* out of lcbs */
p_lcb = NULL;
AVCT_TRACE_WARNING("No lcb for lcid %x", lcid);
tAVCT_CCB *p_ccb = &avct_cb.ccb[0];
int i;
- for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++)
- {
- if (p_ccb->allocated && (p_ccb->p_lcb == p_lcb) && (p_ccb->cc.pid == pid))
- {
+ for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++) {
+ if (p_ccb->allocated && (p_ccb->p_lcb == p_lcb) && (p_ccb->cc.pid == pid)) {
return p_ccb;
}
}
int i;
AVCT_TRACE_WARNING("avct_lcb_last_ccb");
- for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++)
- {
+ for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++) {
AVCT_TRACE_WARNING("%x: aloc:%d, lcb:%p/%p, ccb:%p/%p",
- i, p_ccb->allocated, p_ccb->p_lcb, p_lcb, p_ccb, p_ccb_last);
- if (p_ccb->allocated && (p_ccb->p_lcb == p_lcb) && (p_ccb != p_ccb_last))
- {
+ i, p_ccb->allocated, p_ccb->p_lcb, p_lcb, p_ccb, p_ccb_last);
+ if (p_ccb->allocated && (p_ccb->p_lcb == p_lcb) && (p_ccb != p_ccb_last)) {
return FALSE;
}
}
AVCT_PRS_PKT_TYPE(p, pkt_type);
/* quick sanity check on length */
- if (p_buf->len < avct_lcb_pkt_type_len[pkt_type])
- {
+ if (p_buf->len < avct_lcb_pkt_type_len[pkt_type]) {
GKI_freebuf(p_buf);
AVCT_TRACE_WARNING("Bad length during reassembly");
p_ret = NULL;
}
/* single packet */
- else if (pkt_type == AVCT_PKT_TYPE_SINGLE)
- {
+ else if (pkt_type == AVCT_PKT_TYPE_SINGLE) {
/* if reassembly in progress drop message and process new single */
- if (p_lcb->p_rx_msg != NULL)
- {
+ if (p_lcb->p_rx_msg != NULL) {
GKI_freebuf(p_lcb->p_rx_msg);
p_lcb->p_rx_msg = NULL;
AVCT_TRACE_WARNING("Got single during reassembly");
p_ret = p_buf;
}
/* start packet */
- else if (pkt_type == AVCT_PKT_TYPE_START)
- {
+ else if (pkt_type == AVCT_PKT_TYPE_START) {
/* if reassembly in progress drop message and process new start */
- if (p_lcb->p_rx_msg != NULL)
- {
+ if (p_lcb->p_rx_msg != NULL) {
GKI_freebuf(p_lcb->p_rx_msg);
AVCT_TRACE_WARNING("Got start during reassembly");
}
* not aware of possible packet size after reassembly they
* would have allocated smaller buffer.
*/
- p_lcb->p_rx_msg = (BT_HDR*)GKI_getbuf(GKI_MAX_BUF_SIZE);
- if (p_lcb->p_rx_msg == NULL)
- {
+ p_lcb->p_rx_msg = (BT_HDR *)GKI_getbuf(GKI_MAX_BUF_SIZE);
+ if (p_lcb->p_rx_msg == NULL) {
AVCT_TRACE_ERROR ("Cannot alloc buffer for reassembly !!");
GKI_freebuf(p_buf);
- }
- else
- {
+ } else {
memcpy (p_lcb->p_rx_msg, p_buf,
- sizeof(BT_HDR) + p_buf->offset + p_buf->len);
+ sizeof(BT_HDR) + p_buf->offset + p_buf->len);
/* Free original buffer */
GKI_freebuf(p_buf);
p_ret = NULL;
}
/* continue or end */
- else
- {
+ else {
/* if no reassembly in progress drop message */
- if (p_lcb->p_rx_msg == NULL)
- {
+ if (p_lcb->p_rx_msg == NULL) {
GKI_freebuf(p_buf);
AVCT_TRACE_WARNING("Pkt type=%d out of order", pkt_type);
p_ret = NULL;
- }
- else
- {
+ } else {
/* get size of buffer holding assembled message */
buf_len = GKI_get_buf_size(p_lcb->p_rx_msg) - sizeof(BT_HDR);
p_buf->len -= AVCT_HDR_LEN_CONT;
/* verify length */
- if ((p_lcb->p_rx_msg->offset + p_buf->len) > buf_len)
- {
+ if ((p_lcb->p_rx_msg->offset + p_buf->len) > buf_len) {
/* won't fit; free everything */
GKI_freebuf(p_lcb->p_rx_msg);
p_lcb->p_rx_msg = NULL;
GKI_freebuf(p_buf);
p_ret = NULL;
AVCT_TRACE_WARNING("Fragmented message to big!");
- }
- else
- {
+ } else {
/* copy contents of p_buf to p_rx_msg */
memcpy((UINT8 *)(p_lcb->p_rx_msg + 1) + p_lcb->p_rx_msg->offset,
(UINT8 *)(p_buf + 1) + p_buf->offset, p_buf->len);
- if (pkt_type == AVCT_PKT_TYPE_END)
- {
+ if (pkt_type == AVCT_PKT_TYPE_END) {
p_lcb->p_rx_msg->offset -= p_lcb->p_rx_msg->len;
p_lcb->p_rx_msg->len += p_buf->len;
p_ret = p_lcb->p_rx_msg;
p_lcb->p_rx_msg = NULL;
- }
- else
- {
+ } else {
p_lcb->p_rx_msg->offset += p_buf->len;
p_lcb->p_rx_msg->len += p_buf->len;
p_ret = NULL;
BTM_SetOutService(p_lcb->peer_addr, BTM_SEC_SERVICE_AVCTP, 0);
/* call l2cap connect req */
p_lcb->ch_state = AVCT_CH_CONN;
- if ((p_lcb->ch_lcid = L2CA_ConnectReq(AVCT_PSM, p_lcb->peer_addr)) == 0)
- {
+ if ((p_lcb->ch_lcid = L2CA_ConnectReq(AVCT_PSM, p_lcb->peer_addr)) == 0) {
/* if connect req failed, send ourselves close event */
avct_lcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, (tAVCT_LCB_EVT *) &result);
}
int i;
BOOLEAN bind = FALSE;
- for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++)
- {
+ for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++) {
/* if ccb allocated and */
- if (p_ccb->allocated)
- {
+ if (p_ccb->allocated) {
/* if bound to this lcb send connect confirm event */
- if (p_ccb->p_lcb == p_lcb)
- {
+ if (p_ccb->p_lcb == p_lcb) {
bind = TRUE;
L2CA_SetTxPriority(p_lcb->ch_lcid, L2CAP_CHNL_PRIORITY_HIGH);
p_ccb->cc.p_ctrl_cback(avct_ccb_to_idx(p_ccb), AVCT_CONNECT_CFM_EVT,
}
/* if unbound acceptor and lcb doesn't already have a ccb for this PID */
else if ((p_ccb->p_lcb == NULL) && (p_ccb->cc.role == AVCT_ACP) &&
- (avct_lcb_has_pid(p_lcb, p_ccb->cc.pid) == NULL))
- {
+ (avct_lcb_has_pid(p_lcb, p_ccb->cc.pid) == NULL)) {
/* bind ccb to lcb and send connect ind event */
bind = TRUE;
p_ccb->p_lcb = p_lcb;
L2CA_SetTxPriority(p_lcb->ch_lcid, L2CAP_CHNL_PRIORITY_HIGH);
p_ccb->cc.p_ctrl_cback(avct_ccb_to_idx(p_ccb), AVCT_CONNECT_IND_EVT,
- 0, p_lcb->peer_addr);
+ 0, p_lcb->peer_addr);
}
}
}
/* if no ccbs bound to this lcb, disconnect */
- if (bind == FALSE)
- {
+ if (bind == FALSE) {
avct_lcb_event(p_lcb, AVCT_LCB_INT_CLOSE_EVT, p_data);
}
}
tAVCT_CCB *p_ccb = &avct_cb.ccb[0];
int i;
- for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++)
- {
- if (p_ccb->allocated && (p_ccb->p_lcb == p_lcb))
- {
+ for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++) {
+ if (p_ccb->allocated && (p_ccb->p_lcb == p_lcb)) {
avct_ccb_dealloc(p_ccb, AVCT_CONNECT_CFM_EVT,
p_data->result, p_lcb->peer_addr);
}
int i;
UNUSED(p_data);
- for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++)
- {
- if (p_ccb->allocated && (p_ccb->p_lcb == p_lcb))
- {
- if (p_ccb->cc.role == AVCT_INT)
- {
+ for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++) {
+ if (p_ccb->allocated && (p_ccb->p_lcb == p_lcb)) {
+ if (p_ccb->cc.role == AVCT_INT) {
avct_ccb_dealloc(p_ccb, AVCT_DISCONNECT_IND_EVT,
0, p_lcb->peer_addr);
- }
- else
- {
+ } else {
p_ccb->p_lcb = NULL;
(*p_ccb->cc.p_ctrl_cback)(avct_ccb_to_idx(p_ccb), AVCT_DISCONNECT_IND_EVT,
0, p_lcb->peer_addr);
int i;
UINT8 event;
- for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++)
- {
- if (p_ccb->allocated && (p_ccb->p_lcb == p_lcb))
- {
+ for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++) {
+ if (p_ccb->allocated && (p_ccb->p_lcb == p_lcb)) {
/* if this ccb initiated close send disconnect cfm otherwise ind */
- if (p_ccb->ch_close)
- {
+ if (p_ccb->ch_close) {
p_ccb->ch_close = FALSE;
event = AVCT_DISCONNECT_CFM_EVT;
- }
- else
- {
+ } else {
event = AVCT_DISCONNECT_IND_EVT;
}
- if (p_ccb->cc.role == AVCT_INT)
- {
+ if (p_ccb->cc.role == AVCT_INT) {
avct_ccb_dealloc(p_ccb, event, p_data->result, p_lcb->peer_addr);
- }
- else
- {
+ } else {
p_ccb->p_lcb = NULL;
(*p_ccb->cc.p_ctrl_cback)(avct_ccb_to_idx(p_ccb), event,
- p_data->result, p_lcb->peer_addr);
+ p_data->result, p_lcb->peer_addr);
}
}
}
#if (AVCT_BROWSE_INCLUDED == TRUE)
avct_close_bcb(p_lcb, p_data);
#endif
- if (avct_lcb_last_ccb(p_lcb, p_data->p_ccb))
- {
+ if (avct_lcb_last_ccb(p_lcb, p_data->p_ccb)) {
AVCT_TRACE_WARNING("closing");
p_data->p_ccb->ch_close = TRUE;
avct_lcb_event(p_lcb, AVCT_LCB_INT_CLOSE_EVT, p_data);
- }
- else
- {
+ } else {
AVCT_TRACE_WARNING("dealloc ccb");
avct_lcb_unbind_disc(p_lcb, p_data);
}
/* set event */
event = (p_data->cong) ? AVCT_CONG_IND_EVT : AVCT_UNCONG_IND_EVT;
p_lcb->cong = p_data->cong;
- if (p_lcb->cong == FALSE && GKI_getfirst(&p_lcb->tx_q))
- {
- while ( !p_lcb->cong && (p_buf = (BT_HDR *)GKI_dequeue(&p_lcb->tx_q)) != NULL)
- {
- if (L2CA_DataWrite(p_lcb->ch_lcid, p_buf) == L2CAP_DW_CONGESTED)
- {
+ if (p_lcb->cong == FALSE && GKI_getfirst(&p_lcb->tx_q)) {
+ while ( !p_lcb->cong && (p_buf = (BT_HDR *)GKI_dequeue(&p_lcb->tx_q)) != NULL) {
+ if (L2CA_DataWrite(p_lcb->ch_lcid, p_buf) == L2CAP_DW_CONGESTED) {
p_lcb->cong = TRUE;
}
}
}
/* send event to all ccbs on this lcb */
- for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++)
- {
- if (p_ccb->allocated && (p_ccb->p_lcb == p_lcb))
- {
+ for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++) {
+ if (p_ccb->allocated && (p_ccb->p_lcb == p_lcb)) {
(*p_ccb->cc.p_ctrl_cback)(avct_ccb_to_idx(p_ccb), event, 0, p_lcb->peer_addr);
}
}
curr_msg_len = p_data->ul_msg.p_buf->len;
/* initialize packet type and other stuff */
- if (curr_msg_len <= (p_lcb->peer_mtu - AVCT_HDR_LEN_SINGLE))
- {
+ if (curr_msg_len <= (p_lcb->peer_mtu - AVCT_HDR_LEN_SINGLE)) {
pkt_type = AVCT_PKT_TYPE_SINGLE;
- }
- else
- {
+ } else {
pkt_type = AVCT_PKT_TYPE_START;
temp = (curr_msg_len + AVCT_HDR_LEN_START - p_lcb->peer_mtu);
nosp = temp / (p_lcb->peer_mtu - 1) + 1;
- if ( (temp % (p_lcb->peer_mtu - 1)) != 0)
+ if ( (temp % (p_lcb->peer_mtu - 1)) != 0) {
nosp++;
+ }
}
/* while we haven't sent all packets */
- while (curr_msg_len != 0)
- {
+ while (curr_msg_len != 0) {
/* set header len */
hdr_len = avct_lcb_pkt_type_len[pkt_type];
/* if remaining msg must be fragmented */
- if (p_data->ul_msg.p_buf->len > (p_lcb->peer_mtu - hdr_len))
- {
+ if (p_data->ul_msg.p_buf->len > (p_lcb->peer_mtu - hdr_len)) {
/* get a new buffer for fragment we are sending */
- if ((p_buf = (BT_HDR *) GKI_getbuf(buf_size)) == NULL)
- {
+ if ((p_buf = (BT_HDR *) GKI_getbuf(buf_size)) == NULL) {
/* whoops; free original msg buf and bail */
AVCT_TRACE_ERROR ("avct_lcb_send_msg cannot alloc buffer!!");
GKI_freebuf(p_data->ul_msg.p_buf);
p_data->ul_msg.p_buf->offset += p_buf->len;
p_data->ul_msg.p_buf->len -= p_buf->len;
- }
- else
- {
+ } else {
p_buf = p_data->ul_msg.p_buf;
}
/* build header */
AVCT_BLD_HDR(p, p_data->ul_msg.label, pkt_type, p_data->ul_msg.cr);
- if (pkt_type == AVCT_PKT_TYPE_START)
- {
+ if (pkt_type == AVCT_PKT_TYPE_START) {
UINT8_TO_STREAM(p, nosp);
}
- if ((pkt_type == AVCT_PKT_TYPE_START) || (pkt_type == AVCT_PKT_TYPE_SINGLE))
- {
+ if ((pkt_type == AVCT_PKT_TYPE_START) || (pkt_type == AVCT_PKT_TYPE_SINGLE)) {
UINT16_TO_BE_STREAM(p, p_data->ul_msg.p_ccb->cc.pid);
}
- if (p_lcb->cong == TRUE)
- {
+ if (p_lcb->cong == TRUE) {
GKI_enqueue (&p_lcb->tx_q, p_buf);
}
/* send message to L2CAP */
- else
- {
- if (L2CA_DataWrite(p_lcb->ch_lcid, p_buf) == L2CAP_DW_CONGESTED)
- {
+ else {
+ if (L2CA_DataWrite(p_lcb->ch_lcid, p_buf) == L2CAP_DW_CONGESTED) {
p_lcb->cong = TRUE;
}
}
/* update pkt type for next packet */
- if (curr_msg_len > (p_lcb->peer_mtu - AVCT_HDR_LEN_END))
- {
+ if (curr_msg_len > (p_lcb->peer_mtu - AVCT_HDR_LEN_END)) {
pkt_type = AVCT_PKT_TYPE_CONT;
- }
- else
- {
+ } else {
pkt_type = AVCT_PKT_TYPE_END;
}
}
{
UNUSED(p_lcb);
- if (p_data)
+ if (p_data) {
GKI_freebuf(p_data->p_buf);
+ }
return;
}
p_data->p_buf->layer_specific = AVCT_DATA_CTRL;
/* reassemble message; if no message available (we received a fragment) return */
- if ((p_data->p_buf = avct_lcb_msg_asmbl(p_lcb, p_data->p_buf)) == NULL)
- {
+ if ((p_data->p_buf = avct_lcb_msg_asmbl(p_lcb, p_data->p_buf)) == NULL) {
return;
}
UNUSED(type);
/* check for invalid cr_ipid */
- if (cr_ipid == AVCT_CR_IPID_INVALID)
- {
+ if (cr_ipid == AVCT_CR_IPID_INVALID) {
AVCT_TRACE_WARNING("Invalid cr_ipid %d", cr_ipid);
GKI_freebuf(p_data->p_buf);
return;
/* parse and lookup PID */
BE_STREAM_TO_UINT16(pid, p);
- if ((p_ccb = avct_lcb_has_pid(p_lcb, pid)) != NULL)
- {
+ if ((p_ccb = avct_lcb_has_pid(p_lcb, pid)) != NULL) {
/* PID found; send msg up, adjust bt hdr and call msg callback */
p_data->p_buf->offset += AVCT_HDR_LEN_SINGLE;
p_data->p_buf->len -= AVCT_HDR_LEN_SINGLE;
(*p_ccb->cc.p_msg_cback)(avct_ccb_to_idx(p_ccb), label, cr_ipid, p_data->p_buf);
- }
- else
- {
+ } else {
/* PID not found; drop message */
AVCT_TRACE_WARNING("No ccb for PID=%x", pid);
GKI_freebuf(p_data->p_buf);
/* if command send reject */
- if (cr_ipid == AVCT_CMD)
- {
- if ((p_buf = (BT_HDR *) GKI_getpoolbuf(AVCT_CMD_POOL_ID)) != NULL)
- {
+ if (cr_ipid == AVCT_CMD) {
+ if ((p_buf = (BT_HDR *) GKI_getpoolbuf(AVCT_CMD_POOL_ID)) != NULL) {
p_buf->len = AVCT_HDR_LEN_SINGLE;
p_buf->offset = AVCT_MSG_OFFSET - AVCT_HDR_LEN_SINGLE;
p = (UINT8 *)(p_buf + 1) + p_buf->offset;
*****************************************************************************/
/* sub control block type - common data members for tAVCT_LCB and tAVCT_BCB */
typedef struct {
- UINT16 peer_mtu; /* peer l2c mtu */
+ UINT16 peer_mtu; /* peer l2c mtu */
UINT16 ch_result; /* L2CAP connection result value */
UINT16 ch_lcid; /* L2CAP channel LCID */
UINT8 allocated; /* 0, not allocated. index+1, otherwise. */
/* link control block type */
typedef struct {
- UINT16 peer_mtu; /* peer l2c mtu */
+ UINT16 peer_mtu; /* peer l2c mtu */
UINT16 ch_result; /* L2CAP connection result value */
UINT16 ch_lcid; /* L2CAP channel LCID */
UINT8 allocated; /* 0, not allocated. index+1, otherwise. */
/* browse control block type */
typedef struct {
- UINT16 peer_mtu; /* peer l2c mtu */
+ UINT16 peer_mtu; /* peer l2c mtu */
UINT16 ch_result; /* L2CAP connection result value */
UINT16 ch_lcid; /* L2CAP channel LCID */
UINT8 allocated; /* 0, not allocated. index+1, otherwise. */
{
UINT8 scb_idx;
- if (type == AVDT_CHAN_SIG)
- {
+ if (type == AVDT_CHAN_SIG) {
return 0;
- }
- else
- {
+ } else {
scb_idx = avdt_scb_to_hdl(p_scb) - 1;
/*
AVDT_TRACE_DEBUG("type: %d, tcid: %d", type, ((scb_idx * (AVDT_CHAN_NUM_TYPES - 1)) + type));
{
UINT8 type;
- if (tcid == 0)
- {
+ if (tcid == 0) {
type = AVDT_CHAN_SIG;
- }
- else
- {
+ } else {
/* tcid translates to type based on number of channels, as follows:
** only media channel : tcid=1,2,3,4,5,6... type=1,1,1,1,1,1...
** media and report : tcid=1,2,3,4,5,6... type=1,2,1,2,1,2...
memset(&avdt_cb.ad, 0, sizeof(tAVDT_AD));
/* make sure the peer_mtu is a valid value */
- for (i = 0; i < AVDT_NUM_TC_TBL; i++, p_tbl++)
- {
+ for (i = 0; i < AVDT_NUM_TC_TBL; i++, p_tbl++) {
p_tbl->peer_mtu = L2CAP_DEFAULT_MTU;
}
}
tAVDT_TC_TBL *p_tbl = avdt_cb.ad.tc_tbl;
UINT8 ccb_idx;
- if (p_ccb == NULL)
- {
+ if (p_ccb == NULL) {
/* resending security req */
- for (i = 0; i < AVDT_NUM_TC_TBL; i++, p_tbl++)
- {
+ for (i = 0; i < AVDT_NUM_TC_TBL; i++, p_tbl++) {
/* must be AVDT_CHAN_SIG - tcid always zero */
if ((p_tbl->tcid == 0) &&
- (p_tbl->state == state))
- {
+ (p_tbl->state == state)) {
break;
}
}
- }
- else
- {
+ } else {
ccb_idx = avdt_ccb_to_idx(p_ccb);
- for (i = 0; i < AVDT_NUM_TC_TBL; i++, p_tbl++)
- {
- if (type == AVDT_CHAN_SIG)
- {
+ for (i = 0; i < AVDT_NUM_TC_TBL; i++, p_tbl++) {
+ if (type == AVDT_CHAN_SIG) {
/* if control channel, tcid always zero */
if ((p_tbl->tcid == 0) &&
- (p_tbl->ccb_idx == ccb_idx) &&
- (p_tbl->state == state))
- {
+ (p_tbl->ccb_idx == ccb_idx) &&
+ (p_tbl->state == state)) {
break;
}
- }
- else
- {
+ } else {
/* if other channel, tcid is always > zero */
if ((p_tbl->tcid > 0) &&
- (p_tbl->ccb_idx == ccb_idx) &&
- (p_tbl->state == state))
- {
+ (p_tbl->ccb_idx == ccb_idx) &&
+ (p_tbl->state == state)) {
break;
}
}
}
/* if nothing found return null */
- if (i == AVDT_NUM_TC_TBL)
- {
+ if (i == AVDT_NUM_TC_TBL) {
p_tbl = NULL;
}
idx = avdt_cb.ad.lcid_tbl[lcid - L2CAP_BASE_APPL_CID];
- if (idx < AVDT_NUM_TC_TBL)
- {
+ if (idx < AVDT_NUM_TC_TBL) {
return &avdt_cb.ad.tc_tbl[idx];
- }
- else
- {
+ } else {
return NULL;
}
}
/* get tcid from type, scb */
tcid = avdt_ad_type_to_tcid(type, p_scb);
- for (i = 0; i < AVDT_NUM_TC_TBL; i++, p_tbl++)
- {
- if ((p_tbl->tcid == tcid) && (p_tbl->ccb_idx == ccb_idx))
- {
+ for (i = 0; i < AVDT_NUM_TC_TBL; i++, p_tbl++) {
+ if ((p_tbl->tcid == tcid) && (p_tbl->ccb_idx == ccb_idx)) {
break;
}
}
tAVDT_TC_TBL *p_tbl = avdt_cb.ad.tc_tbl;
/* find next free entry in tc table */
- for (i = 0; i < AVDT_NUM_TC_TBL; i++, p_tbl++)
- {
- if (p_tbl->state == AVDT_AD_ST_UNUSED)
- {
+ for (i = 0; i < AVDT_NUM_TC_TBL; i++, p_tbl++) {
+ if (p_tbl->state == AVDT_AD_ST_UNUSED) {
break;
}
}
// UNUSED(reason);
close.old_tc_state = p_tbl->state;
-
+
/* clear avdt_ad_tc_tbl entry */
p_tbl->state = AVDT_AD_ST_UNUSED;
p_tbl->cfg_flags = 0;
p_tbl->peer_mtu = L2CAP_DEFAULT_MTU;
AVDT_TRACE_DEBUG("avdt_ad_tc_close_ind tcid: %d, old: %d\n",
- p_tbl->tcid, close.old_tc_state);
-
+ p_tbl->tcid, close.old_tc_state);
+
/* if signaling channel, notify ccb that channel open */
- if (p_tbl->tcid == 0)
- {
+ if (p_tbl->tcid == 0) {
p_ccb = avdt_ccb_by_idx(p_tbl->ccb_idx);
p_ccb->disc_rsn = (reason == AVDT_DISC_RSN_ABNORMAL) ? AVDT_DISC_RSN_ABNORMAL : AVDT_DISC_RSN_NORMAL;
avdt_ccb_event(p_ccb, AVDT_CCB_LL_CLOSE_EVT, NULL);
}
/* if media or other channel, notify scb that channel close */
- else
- {
+ else {
/* look up scb in stream routing table by ccb, tcid */
p_scb = avdt_scb_by_hdl(avdt_cb.ad.rt_tbl[p_tbl->ccb_idx][p_tbl->tcid].scb_hdl);
- if (p_scb != NULL)
- {
+ if (p_scb != NULL) {
close.tcid = p_tbl->tcid;
close.type = avdt_ad_tcid_to_type(p_tbl->tcid);
close.disc_rsn = (reason == AVDT_DISC_RSN_ABNORMAL) ? AVDT_DISC_RSN_ABNORMAL : AVDT_DISC_RSN_NORMAL;
p_tbl->state = AVDT_AD_ST_OPEN;
/* if signaling channel, notify ccb that channel open */
- if (p_tbl->tcid == 0)
- {
+ if (p_tbl->tcid == 0) {
/* set the signal channel to use high priority within the ACL link */
L2CA_SetTxPriority(avdt_cb.ad.rt_tbl[p_tbl->ccb_idx][AVDT_CHAN_SIG].lcid, L2CAP_CHNL_PRIORITY_HIGH);
/* use err_param to indicate the role of connection.
* AVDT_ACP, if ACP */
evt.err_param = AVDT_INT;
- if(p_tbl->cfg_flags & AVDT_L2C_CFG_CONN_ACP)
- {
+ if (p_tbl->cfg_flags & AVDT_L2C_CFG_CONN_ACP) {
evt.err_param = AVDT_ACP;
}
avdt_ccb_event(p_ccb, AVDT_CCB_LL_OPEN_EVT, (tAVDT_CCB_EVT *)&evt);
}
/* if media or other channel, notify scb that channel open */
- else
- {
+ else {
/* look up scb in stream routing table by ccb, tcid */
p_scb = avdt_scb_by_hdl(avdt_cb.ad.rt_tbl[p_tbl->ccb_idx][p_tbl->tcid].scb_hdl);
/* put lcid in event data */
- if (p_scb != NULL)
- {
+ if (p_scb != NULL) {
open.peer_mtu = p_tbl->peer_mtu;
open.lcid = avdt_cb.ad.rt_tbl[p_tbl->ccb_idx][p_tbl->tcid].lcid;
open.hdr.err_code = avdt_ad_tcid_to_type(p_tbl->tcid);
tAVDT_SCB *p_scb;
/* if signaling channel, notify ccb of congestion */
- if (p_tbl->tcid == 0)
- {
+ if (p_tbl->tcid == 0) {
p_ccb = avdt_ccb_by_idx(p_tbl->ccb_idx);
avdt_ccb_event(p_ccb, AVDT_CCB_LL_CONG_EVT, (tAVDT_CCB_EVT *) &is_congested);
}
/* if media or other channel, notify scb that channel open */
- else
- {
+ else {
/* look up scb in stream routing table by ccb, tcid */
p_scb = avdt_scb_by_hdl(avdt_cb.ad.rt_tbl[p_tbl->ccb_idx][p_tbl->tcid].scb_hdl);
- if (p_scb != NULL)
- {
+ if (p_scb != NULL) {
avdt_scb_event(p_scb, AVDT_SCB_TC_CONG_EVT, (tAVDT_SCB_EVT *) &is_congested);
}
}
/* if signaling channel, handle control message */
- if (p_tbl->tcid == 0)
- {
+ if (p_tbl->tcid == 0) {
p_ccb = avdt_ccb_by_idx(p_tbl->ccb_idx);
avdt_msg_ind(p_ccb, p_buf);
}
/* if media or other channel, send event to scb */
- else
- {
+ else {
p_scb = avdt_scb_by_hdl(avdt_cb.ad.rt_tbl[p_tbl->ccb_idx][p_tbl->tcid].scb_hdl);
- if (p_scb != NULL)
- {
+ if (p_scb != NULL) {
avdt_scb_event(p_scb, AVDT_SCB_TC_DATA_EVT, (tAVDT_SCB_EVT *) &p_buf);
- }
- else
- {
+ } else {
GKI_freebuf(p_buf);
AVDT_TRACE_ERROR(" avdt_ad_tc_data_ind buffer freed");
}
tAVDT_TC_TBL *p_tbl;
UINT16 lcid;
- if((p_tbl = avdt_ad_tc_tbl_alloc(p_ccb)) == NULL)
- {
+ if ((p_tbl = avdt_ad_tc_tbl_alloc(p_ccb)) == NULL) {
AVDT_TRACE_ERROR("avdt_ad_open_req: Cannot allocate p_tbl");
return;
}
p_tbl->tcid = avdt_ad_type_to_tcid(type, p_scb);
AVDT_TRACE_DEBUG("avdt_ad_open_req: type: %d, role: %d, tcid:%d\n",
- type, role, p_tbl->tcid);
+ type, role, p_tbl->tcid);
- if (type == AVDT_CHAN_SIG)
- {
+ if (type == AVDT_CHAN_SIG) {
/* if signaling, get mtu from registration control block */
p_tbl->my_mtu = avdt_cb.rcb.ctrl_mtu;
p_tbl->my_flush_to = L2CAP_DEFAULT_FLUSH_TO;
- }
- else
- {
+ } else {
/* otherwise get mtu from scb */
p_tbl->my_mtu = p_scb->cs.mtu;
p_tbl->my_flush_to = p_scb->cs.flush_to;
/* also set scb_hdl in rt_tbl */
avdt_cb.ad.rt_tbl[avdt_ccb_to_idx(p_ccb)][p_tbl->tcid].scb_hdl = avdt_scb_to_hdl(p_scb);
AVDT_TRACE_DEBUG("avdt_cb.ad.rt_tbl[%d][%d].scb_hdl = %d\n",
- avdt_ccb_to_idx(p_ccb), p_tbl->tcid,
- avdt_scb_to_hdl(p_scb));
+ avdt_ccb_to_idx(p_ccb), p_tbl->tcid,
+ avdt_scb_to_hdl(p_scb));
}
/* if we're acceptor, we're done; just sit back and listen */
- if (role == AVDT_ACP)
- {
+ if (role == AVDT_ACP) {
p_tbl->state = AVDT_AD_ST_ACP;
}
/* else we're inititator, start the L2CAP connection */
- else
- {
+ else {
p_tbl->state = AVDT_AD_ST_CONN;
/* call l2cap connect req */
- if ((lcid = L2CA_ConnectReq(AVDT_PSM, p_ccb->peer_addr)) != 0)
- {
+ if ((lcid = L2CA_ConnectReq(AVDT_PSM, p_ccb->peer_addr)) != 0) {
/* if connect req ok, store tcid in lcid table */
avdt_cb.ad.lcid_tbl[lcid - L2CAP_BASE_APPL_CID] = avdt_ad_tc_tbl_to_idx(p_tbl);
AVDT_TRACE_DEBUG("avdt_cb.ad.lcid_tbl[%d] = %d\n",
- (lcid - L2CAP_BASE_APPL_CID), avdt_ad_tc_tbl_to_idx(p_tbl));
+ (lcid - L2CAP_BASE_APPL_CID), avdt_ad_tc_tbl_to_idx(p_tbl));
avdt_cb.ad.rt_tbl[avdt_ccb_to_idx(p_ccb)][p_tbl->tcid].lcid = lcid;
AVDT_TRACE_DEBUG("avdt_cb.ad.rt_tbl[%d][%d].lcid = 0x%x\n",
- avdt_ccb_to_idx(p_ccb), p_tbl->tcid,
- lcid);
- }
- else
- {
+ avdt_ccb_to_idx(p_ccb), p_tbl->tcid,
+ lcid);
+ } else {
/* if connect req failed, call avdt_ad_tc_close_ind() */
avdt_ad_tc_close_ind(p_tbl, 0);
}
p_tbl = avdt_ad_tc_tbl_by_type(type, p_ccb, p_scb);
AVDT_TRACE_DEBUG("avdt_ad_close_req state: %d\n", p_tbl->state);
- switch(p_tbl->state)
- {
+ switch (p_tbl->state) {
case AVDT_AD_ST_UNUSED:
/* probably for reporting */
break;
UINT8 event = 0;
UINT8 err_code = AVDT_ERR_TIMEOUT;
- switch (p_tle->event)
- {
- case BTU_TTYPE_AVDT_CCB_RET:
- event = AVDT_CCB_RET_TOUT_EVT + AVDT_CCB_MKR;
- break;
+ switch (p_tle->event) {
+ case BTU_TTYPE_AVDT_CCB_RET:
+ event = AVDT_CCB_RET_TOUT_EVT + AVDT_CCB_MKR;
+ break;
- case BTU_TTYPE_AVDT_CCB_RSP:
- event = AVDT_CCB_RSP_TOUT_EVT + AVDT_CCB_MKR;
- break;
+ case BTU_TTYPE_AVDT_CCB_RSP:
+ event = AVDT_CCB_RSP_TOUT_EVT + AVDT_CCB_MKR;
+ break;
- case BTU_TTYPE_AVDT_CCB_IDLE:
- event = AVDT_CCB_IDLE_TOUT_EVT + AVDT_CCB_MKR;
- break;
+ case BTU_TTYPE_AVDT_CCB_IDLE:
+ event = AVDT_CCB_IDLE_TOUT_EVT + AVDT_CCB_MKR;
+ break;
- case BTU_TTYPE_AVDT_SCB_TC:
- event = AVDT_SCB_TC_TOUT_EVT;
- break;
+ case BTU_TTYPE_AVDT_SCB_TC:
+ event = AVDT_SCB_TC_TOUT_EVT;
+ break;
- default:
- break;
+ default:
+ break;
}
- if (event & AVDT_CCB_MKR)
- {
+ if (event & AVDT_CCB_MKR) {
avdt_ccb_event((tAVDT_CCB *) p_tle->param, (UINT8) (event & ~AVDT_CCB_MKR),
(tAVDT_CCB_EVT *) &err_code);
- }
- else
- {
+ } else {
avdt_scb_event((tAVDT_SCB *) p_tle->param, event, NULL);
}
}
/* set security level */
BTM_SetSecurityLevel(TRUE, "", BTM_SEC_SERVICE_AVDTP, p_reg->sec_mask,
- AVDT_PSM, BTM_SEC_PROTO_AVDT, AVDT_CHAN_SIG);
+ AVDT_PSM, BTM_SEC_PROTO_AVDT, AVDT_CHAN_SIG);
BTM_SetSecurityLevel(FALSE, "", BTM_SEC_SERVICE_AVDTP, p_reg->sec_mask,
- AVDT_PSM, BTM_SEC_PROTO_AVDT, AVDT_CHAN_SIG);
+ AVDT_PSM, BTM_SEC_PROTO_AVDT, AVDT_CHAN_SIG);
/* do not use security on the media channel */
BTM_SetSecurityLevel(TRUE, "", BTM_SEC_SERVICE_AVDTP_NOSEC, BTM_SEC_NONE,
- AVDT_PSM, BTM_SEC_PROTO_AVDT, AVDT_CHAN_MEDIA);
+ AVDT_PSM, BTM_SEC_PROTO_AVDT, AVDT_CHAN_MEDIA);
BTM_SetSecurityLevel(FALSE, "", BTM_SEC_SERVICE_AVDTP_NOSEC, BTM_SEC_NONE,
- AVDT_PSM, BTM_SEC_PROTO_AVDT, AVDT_CHAN_MEDIA);
+ AVDT_PSM, BTM_SEC_PROTO_AVDT, AVDT_CHAN_MEDIA);
#if AVDT_REPORTING == TRUE
/* do not use security on the reporting channel */
BTM_SetSecurityLevel(TRUE, "", BTM_SEC_SERVICE_AVDTP_NOSEC, BTM_SEC_NONE,
- AVDT_PSM, BTM_SEC_PROTO_AVDT, AVDT_CHAN_REPORT);
+ AVDT_PSM, BTM_SEC_PROTO_AVDT, AVDT_CHAN_REPORT);
BTM_SetSecurityLevel(FALSE, "", BTM_SEC_SERVICE_AVDTP_NOSEC, BTM_SEC_NONE,
- AVDT_PSM, BTM_SEC_PROTO_AVDT, AVDT_CHAN_REPORT);
+ AVDT_PSM, BTM_SEC_PROTO_AVDT, AVDT_CHAN_REPORT);
#endif
/* initialize AVDTP data structures */
int i;
AVDT_TRACE_DEBUG("AVDT_SINK_Activate");
/* for all allocated scbs */
- for (i = 0; i < AVDT_NUM_SEPS; i++, p_scb++)
- {
- if ((p_scb->allocated) && (p_scb->cs.tsep == AVDT_TSEP_SNK))
- {
+ for (i = 0; i < AVDT_NUM_SEPS; i++, p_scb++) {
+ if ((p_scb->allocated) && (p_scb->cs.tsep == AVDT_TSEP_SNK)) {
AVDT_TRACE_DEBUG("AVDT_SINK_Activate found scb");
p_scb->sink_activated = TRUE;
/* update in_use */
int i;
AVDT_TRACE_DEBUG("AVDT_SINK_Deactivate");
/* for all allocated scbs */
- for (i = 0; i < AVDT_NUM_SEPS; i++, p_scb++)
- {
- if ((p_scb->allocated) && (p_scb->cs.tsep == AVDT_TSEP_SNK))
- {
+ for (i = 0; i < AVDT_NUM_SEPS; i++, p_scb++) {
+ if ((p_scb->allocated) && (p_scb->cs.tsep == AVDT_TSEP_SNK)) {
AVDT_TRACE_DEBUG("AVDT_SINK_Deactivate, found scb");
p_scb->sink_activated = FALSE;
/* update in_use */
AVDT_TRACE_ERROR("%s\n", __func__);
tAVDT_SCB *p_scb = avdt_scb_by_hdl(handle);
- if (p_scb != NULL)
- {
+ if (p_scb != NULL) {
avdt_scb_event(p_scb, AVDT_SCB_API_ABORT_REQ_EVT, NULL);
} else {
AVDT_TRACE_ERROR("%s Improper SCB, can not abort the stream\n", __func__);
tAVDT_SCB *p_scb;
/* Verify parameters; if invalid, return failure */
- if (((p_cs->cfg.psc_mask & (~AVDT_PSC)) != 0) || (p_cs->p_ctrl_cback == NULL))
- {
+ if (((p_cs->cfg.psc_mask & (~AVDT_PSC)) != 0) || (p_cs->p_ctrl_cback == NULL)) {
result = AVDT_BAD_PARAMS;
}
/* Allocate scb; if no scbs, return failure */
- else if ((p_scb = avdt_scb_alloc(p_cs)) == NULL)
- {
+ else if ((p_scb = avdt_scb_alloc(p_cs)) == NULL) {
result = AVDT_NO_RESOURCES;
- }
- else
- {
+ } else {
*p_handle = avdt_scb_to_hdl(p_scb);
}
return result;
tAVDT_SCB *p_scb;
/* look up scb */
- if ((p_scb = avdt_scb_by_hdl(handle)) == NULL)
- {
+ if ((p_scb = avdt_scb_by_hdl(handle)) == NULL) {
result = AVDT_BAD_HANDLE;
- }
- else
- {
+ } else {
/* send remove event to scb */
avdt_scb_event(p_scb, AVDT_SCB_API_REMOVE_EVT, NULL);
}
tAVDT_CCB_EVT evt;
/* find channel control block for this bd addr; if none, allocate one */
- if ((p_ccb = avdt_ccb_by_bd(bd_addr)) == NULL)
- {
- if ((p_ccb = avdt_ccb_alloc(bd_addr)) == NULL)
- {
+ if ((p_ccb = avdt_ccb_by_bd(bd_addr)) == NULL) {
+ if ((p_ccb = avdt_ccb_alloc(bd_addr)) == NULL) {
/* could not allocate channel control block */
result = AVDT_NO_RESOURCES;
}
}
- if (result == AVDT_SUCCESS)
- {
+ if (result == AVDT_SUCCESS) {
/* make sure no discovery or get capabilities req already in progress */
- if (p_ccb->proc_busy)
- {
+ if (p_ccb->proc_busy) {
result = AVDT_BUSY;
}
/* send event to ccb */
- else
- {
+ else {
evt.discover.p_sep_info = p_sep_info;
evt.discover.num_seps = max_seps;
evt.discover.p_cback = p_cback;
UINT16 result = AVDT_SUCCESS;
/* verify SEID */
- if ((p_evt->single.seid < AVDT_SEID_MIN) || (p_evt->single.seid > AVDT_SEID_MAX))
- {
+ if ((p_evt->single.seid < AVDT_SEID_MIN) || (p_evt->single.seid > AVDT_SEID_MAX)) {
AVDT_TRACE_ERROR("seid: %d\n", p_evt->single.seid);
result = AVDT_BAD_PARAMS;
}
/* find channel control block for this bd addr; if none, allocate one */
- else if ((p_ccb = avdt_ccb_by_bd(bd_addr)) == NULL)
- {
- if ((p_ccb = avdt_ccb_alloc(bd_addr)) == NULL)
- {
+ else if ((p_ccb = avdt_ccb_by_bd(bd_addr)) == NULL) {
+ if ((p_ccb = avdt_ccb_alloc(bd_addr)) == NULL) {
/* could not allocate channel control block */
result = AVDT_NO_RESOURCES;
}
}
- if (result == AVDT_SUCCESS)
- {
+ if (result == AVDT_SUCCESS) {
/* make sure no discovery or get capabilities req already in progress */
- if (p_ccb->proc_busy)
- {
+ if (p_ccb->proc_busy) {
result = AVDT_BUSY;
}
/* send event to ccb */
- else
- {
+ else {
avdt_ccb_event(p_ccb, AVDT_CCB_API_GETCAP_REQ_EVT, (tAVDT_CCB_EVT *)p_evt);
}
}
tAVDT_SCB_EVT evt;
/* map handle to scb */
- if ((p_scb = avdt_scb_by_hdl(handle)) == NULL)
- {
+ if ((p_scb = avdt_scb_by_hdl(handle)) == NULL) {
result = AVDT_BAD_HANDLE;
- }
- else
- /* send event to scb */
+ } else
+ /* send event to scb */
{
evt.apidelay.hdr.seid = seid;
evt.apidelay.delay = delay;
tAVDT_SCB_EVT evt;
/* verify SEID */
- if ((seid < AVDT_SEID_MIN) || (seid > AVDT_SEID_MAX))
- {
+ if ((seid < AVDT_SEID_MIN) || (seid > AVDT_SEID_MAX)) {
result = AVDT_BAD_PARAMS;
}
/* map handle to scb */
- else if ((p_scb = avdt_scb_by_hdl(handle)) == NULL)
- {
+ else if ((p_scb = avdt_scb_by_hdl(handle)) == NULL) {
result = AVDT_BAD_HANDLE;
}
/* find channel control block for this bd addr; if none, allocate one */
- else if ((p_ccb = avdt_ccb_by_bd(bd_addr)) == NULL)
- {
- if ((p_ccb = avdt_ccb_alloc(bd_addr)) == NULL)
- {
+ else if ((p_ccb = avdt_ccb_by_bd(bd_addr)) == NULL) {
+ if ((p_ccb = avdt_ccb_alloc(bd_addr)) == NULL) {
/* could not allocate channel control block */
result = AVDT_NO_RESOURCES;
}
}
/* send event to scb */
- if (result == AVDT_SUCCESS)
- {
+ if (result == AVDT_SUCCESS) {
evt.msg.config_cmd.hdr.seid = seid;
evt.msg.config_cmd.hdr.ccb_idx = avdt_ccb_to_idx(p_ccb);
evt.msg.config_cmd.int_seid = handle;
UINT8 event_code;
/* map handle to scb */
- if ((p_scb = avdt_scb_by_hdl(handle)) == NULL)
- {
+ if ((p_scb = avdt_scb_by_hdl(handle)) == NULL) {
result = AVDT_BAD_HANDLE;
}
/* handle special case when this function is called but peer has not send
** a configuration cmd; ignore and return error result
*/
- else if (!p_scb->in_use)
- {
+ else if (!p_scb->in_use) {
result = AVDT_BAD_HANDLE;
}
/* send event to scb */
- else
- {
+ else {
evt.msg.hdr.err_code = error_code;
evt.msg.hdr.err_param = category;
evt.msg.hdr.label = label;
- if (error_code == 0)
- {
+ if (error_code == 0) {
event_code = AVDT_SCB_API_SETCONFIG_RSP_EVT;
- }
- else
- {
+ } else {
event_code = AVDT_SCB_API_SETCONFIG_REJ_EVT;
}
avdt_scb_event(p_scb, event_code, &evt);
UINT16 result = AVDT_SUCCESS;
int i;
- if ((num_handles == 0) || (num_handles > AVDT_NUM_SEPS))
- {
+ if ((num_handles == 0) || (num_handles > AVDT_NUM_SEPS)) {
result = AVDT_BAD_PARAMS;
- }
- else
- {
+ } else {
/* verify handles */
- for (i = 0; i < num_handles; i++)
- {
- if ((p_scb = avdt_scb_by_hdl(p_handles[i])) == NULL)
- {
+ for (i = 0; i < num_handles; i++) {
+ if ((p_scb = avdt_scb_by_hdl(p_handles[i])) == NULL) {
result = AVDT_BAD_HANDLE;
break;
}
}
}
- if (result == AVDT_SUCCESS)
- {
- if (p_scb->p_ccb == NULL)
- {
+ if (result == AVDT_SUCCESS) {
+ if (p_scb->p_ccb == NULL) {
result = AVDT_BAD_HANDLE;
- }
- else
- {
+ } else {
/* send event to ccb */
memcpy(evt.msg.multi.seid_list, p_handles, num_handles);
evt.msg.multi.num_seps = num_handles;
UINT16 result = AVDT_SUCCESS;
int i;
- if ((num_handles == 0) || (num_handles > AVDT_NUM_SEPS))
- {
+ if ((num_handles == 0) || (num_handles > AVDT_NUM_SEPS)) {
result = AVDT_BAD_PARAMS;
- }
- else
- {
+ } else {
/* verify handles */
- for (i = 0; i < num_handles; i++)
- {
- if ((p_scb = avdt_scb_by_hdl(p_handles[i])) == NULL)
- {
+ for (i = 0; i < num_handles; i++) {
+ if ((p_scb = avdt_scb_by_hdl(p_handles[i])) == NULL) {
result = AVDT_BAD_HANDLE;
break;
}
}
}
- if (result == AVDT_SUCCESS)
- {
- if (p_scb->p_ccb == NULL)
- {
+ if (result == AVDT_SUCCESS) {
+ if (p_scb->p_ccb == NULL) {
result = AVDT_BAD_HANDLE;
- }
- else
- {
+ } else {
/* send event to ccb */
memcpy(evt.msg.multi.seid_list, p_handles, num_handles);
evt.msg.multi.num_seps = num_handles;
UINT16 result = AVDT_SUCCESS;
/* map handle to scb */
- if ((p_scb = avdt_scb_by_hdl(handle)) == NULL)
- {
+ if ((p_scb = avdt_scb_by_hdl(handle)) == NULL) {
result = AVDT_BAD_HANDLE;
- }
- else
- /* send event to scb */
+ } else
+ /* send event to scb */
{
avdt_scb_event(p_scb, AVDT_SCB_API_CLOSE_REQ_EVT, NULL);
}
tAVDT_SCB_EVT evt;
/* map handle to scb */
- if ((p_scb = avdt_scb_by_hdl(handle)) == NULL)
- {
+ if ((p_scb = avdt_scb_by_hdl(handle)) == NULL) {
result = AVDT_BAD_HANDLE;
}
/* send event to scb */
- else
- {
+ else {
/* force psc_mask to zero */
p_cfg->psc_mask = 0;
UINT16 result = AVDT_SUCCESS;
/* map handle to scb */
- if ((p_scb = avdt_scb_by_hdl(handle)) == NULL)
- {
+ if ((p_scb = avdt_scb_by_hdl(handle)) == NULL) {
result = AVDT_BAD_HANDLE;
}
/* send event to scb */
- else
- {
+ else {
evt.msg.hdr.err_code = error_code;
evt.msg.hdr.err_param = category;
evt.msg.hdr.label = label;
tAVDT_SCB_EVT evt;
/* map handle to scb */
- if ((p_scb = avdt_scb_by_hdl(handle)) == NULL)
- {
+ if ((p_scb = avdt_scb_by_hdl(handle)) == NULL) {
result = AVDT_BAD_HANDLE;
}
/* send event to scb */
- else
- {
+ else {
evt.msg.security_rsp.p_data = p_data;
evt.msg.security_rsp.len = len;
avdt_scb_event(p_scb, AVDT_SCB_API_SECURITY_REQ_EVT, &evt);
tAVDT_SCB_EVT evt;
/* map handle to scb */
- if ((p_scb = avdt_scb_by_hdl(handle)) == NULL)
- {
+ if ((p_scb = avdt_scb_by_hdl(handle)) == NULL) {
result = AVDT_BAD_HANDLE;
}
/* send event to scb */
- else
- {
+ else {
evt.msg.security_rsp.hdr.err_code = error_code;
evt.msg.security_rsp.hdr.label = label;
evt.msg.security_rsp.p_data = p_data;
UINT16 result = AVDT_SUCCESS;
/* map handle to scb */
- if ((p_scb = avdt_scb_by_hdl(handle)) == NULL)
- {
+ if ((p_scb = avdt_scb_by_hdl(handle)) == NULL) {
result = AVDT_BAD_HANDLE;
- }
- else
- {
+ } else {
evt.apiwrite.p_buf = p_pkt;
evt.apiwrite.time_stamp = time_stamp;
evt.apiwrite.m_pt = m_pt;
tAVDT_CCB_EVT evt;
/* find channel control block for this bd addr; if none, allocate one */
- if ((p_ccb = avdt_ccb_by_bd(bd_addr)) == NULL)
- {
- if ((p_ccb = avdt_ccb_alloc(bd_addr)) == NULL)
- {
+ if ((p_ccb = avdt_ccb_by_bd(bd_addr)) == NULL) {
+ if ((p_ccb = avdt_ccb_alloc(bd_addr)) == NULL) {
/* could not allocate channel control block */
result = AVDT_NO_RESOURCES;
}
- }
- else if (p_ccb->ll_opened == FALSE)
- {
+ } else if (p_ccb->ll_opened == FALSE) {
AVDT_TRACE_WARNING("AVDT_ConnectReq: CCB LL is in the middle of opening");
/* ccb was already allocated for the incoming signalling. */
result = AVDT_BUSY;
}
- if (result == AVDT_SUCCESS)
- {
+ if (result == AVDT_SUCCESS) {
/* send event to ccb */
evt.connect.p_cback = p_cback;
evt.connect.sec_mask = sec_mask;
tAVDT_CCB_EVT evt;
/* find channel control block for this bd addr; if none, error */
- if ((p_ccb = avdt_ccb_by_bd(bd_addr)) == NULL)
- {
+ if ((p_ccb = avdt_ccb_by_bd(bd_addr)) == NULL) {
result = AVDT_BAD_PARAMS;
}
- if (result == AVDT_SUCCESS)
- {
+ if (result == AVDT_SUCCESS) {
/* send event to ccb */
evt.disconnect.p_cback = p_cback;
avdt_ccb_event(p_ccb, AVDT_CCB_API_DISCONNECT_REQ_EVT, &evt);
/* map handle to scb */
if (((p_scb = avdt_scb_by_hdl(handle)) != NULL)
- && ((p_ccb = p_scb->p_ccb) != NULL))
- {
+ && ((p_ccb = p_scb->p_ccb) != NULL)) {
/* get tcid from type, scb */
tcid = avdt_ad_type_to_tcid(AVDT_CHAN_MEDIA, p_scb);
/* map handle to scb */
if (((p_scb = avdt_scb_by_hdl(handle)) != NULL)
- && ((p_ccb = p_scb->p_ccb) != NULL))
- {
+ && ((p_ccb = p_scb->p_ccb) != NULL)) {
lcid = avdt_cb.ad.rt_tbl[avdt_ccb_to_idx(p_ccb)][tcid].lcid;
- }
- else if ((p_ccb = avdt_ccb_by_bd(bd_addr)) != NULL)
- {
+ } else if ((p_ccb = avdt_ccb_by_bd(bd_addr)) != NULL) {
lcid = avdt_cb.ad.rt_tbl[avdt_ccb_to_idx(p_ccb)][tcid].lcid;
}
tAVDT_SCB_EVT evt;
UINT16 result = AVDT_SUCCESS;
- do
- {
+ do {
/* check length of media frame */
- if(data_len > AVDT_MAX_MEDIA_SIZE)
- {
+ if (data_len > AVDT_MAX_MEDIA_SIZE) {
result = AVDT_BAD_PARAMS;
break;
}
/* map handle to scb */
- if ((p_scb = avdt_scb_by_hdl(handle)) == NULL)
- {
+ if ((p_scb = avdt_scb_by_hdl(handle)) == NULL) {
result = AVDT_BAD_HANDLE;
break;
}
AVDT_TRACE_WARNING("mux_tsid_media:%d\n", p_scb->curr_cfg.mux_tsid_media);
if (p_scb->p_pkt != NULL
- || p_scb->p_ccb == NULL
- || !GKI_queue_is_empty(&p_scb->frag_q)
- || p_scb->frag_off != 0
- || p_scb->curr_cfg.mux_tsid_media == 0)
- {
+ || p_scb->p_ccb == NULL
+ || !GKI_queue_is_empty(&p_scb->frag_q)
+ || p_scb->frag_off != 0
+ || p_scb->curr_cfg.mux_tsid_media == 0) {
result = AVDT_ERR_BAD_STATE;
AVDT_TRACE_WARNING("p_scb->p_pkt=%p, p_scb->p_ccb=%p, IsQueueEmpty=%x, p_scb->frag_off=%x\n",
- p_scb->p_pkt, p_scb->p_ccb, GKI_queue_is_empty(&p_scb->frag_q), p_scb->frag_off);
+ p_scb->p_pkt, p_scb->p_ccb, GKI_queue_is_empty(&p_scb->frag_q), p_scb->frag_off);
break;
}
evt.apiwrite.p_buf = 0; /* it will indicate using of fragments queue frag_q */
/* compose fragments from media payload and put fragments into gueue */
avdt_scb_queue_frags(p_scb, &p_data, &data_len, &evt.apiwrite.frag_q);
- if(GKI_queue_is_empty(&evt.apiwrite.frag_q))
- {
+ if (GKI_queue_is_empty(&evt.apiwrite.frag_q)) {
AVDT_TRACE_WARNING("AVDT_WriteDataReq out of GKI buffers");
result = AVDT_ERR_RESOURCE;
break;
/* process the fragments queue */
evt.apiwrite.time_stamp = time_stamp;
- evt.apiwrite.m_pt = m_pt | (marker<<7);
+ evt.apiwrite.m_pt = m_pt | (marker << 7);
avdt_scb_event(p_scb, AVDT_SCB_API_WRITE_REQ_EVT, &evt);
} while (0);
#if (BT_USE_TRACES == TRUE)
- if(result != AVDT_SUCCESS)
- {
- AVDT_TRACE_WARNING("*** AVDT_WriteDataReq failed result=%d\n",result);
+ if (result != AVDT_SUCCESS) {
+ AVDT_TRACE_WARNING("*** AVDT_WriteDataReq failed result=%d\n", result);
}
#endif
return result;
UINT16 result = AVDT_SUCCESS;
/* map handle to scb */
- if ((p_scb = avdt_scb_by_hdl(handle)) == NULL)
- {
+ if ((p_scb = avdt_scb_by_hdl(handle)) == NULL) {
result = AVDT_BAD_HANDLE;
- }
- else
- {
- if(p_buf && p_scb->cs.p_media_cback == NULL)
+ } else {
+ if (p_buf && p_scb->cs.p_media_cback == NULL) {
result = AVDT_NO_RESOURCES;
- else
- {
+ } else {
p_scb->p_media_buf = p_buf;
p_scb->media_buf_len = buf_len;
}
tAVDT_TC_TBL *p_tbl;
UINT8 *p, *plen, *pm1, *p_end;
#if AVDT_MULTIPLEXING == TRUE
- UINT8 *p_al=NULL, u;
+ UINT8 *p_al = NULL, u;
#endif
UINT32 ssrc;
UINT16 len;
/* map handle to scb && verify parameters */
if (((p_scb = avdt_scb_by_hdl(handle)) != NULL)
- && (p_scb->p_ccb != NULL)
- && (((type == AVDT_RTCP_PT_SR) && (p_scb->cs.tsep == AVDT_TSEP_SRC)) ||
- ((type == AVDT_RTCP_PT_RR) && (p_scb->cs.tsep == AVDT_TSEP_SNK)) ||
- (type == AVDT_RTCP_PT_SDES)) )
- {
+ && (p_scb->p_ccb != NULL)
+ && (((type == AVDT_RTCP_PT_SR) && (p_scb->cs.tsep == AVDT_TSEP_SRC)) ||
+ ((type == AVDT_RTCP_PT_RR) && (p_scb->cs.tsep == AVDT_TSEP_SNK)) ||
+ (type == AVDT_RTCP_PT_SDES)) ) {
result = AVDT_NO_RESOURCES;
/* build SR - assume fit in one packet */
p_tbl = avdt_ad_tc_tbl_by_type(AVDT_CHAN_REPORT, p_scb->p_ccb, p_scb);
- if((p_tbl->state == AVDT_AD_ST_OPEN) &&
- (p_pkt = (BT_HDR *)GKI_getbuf(p_tbl->peer_mtu)) != NULL)
- {
+ if ((p_tbl->state == AVDT_AD_ST_OPEN) &&
+ (p_pkt = (BT_HDR *)GKI_getbuf(p_tbl->peer_mtu)) != NULL) {
p_pkt->offset = L2CAP_MIN_OFFSET;
p = (UINT8 *)(p_pkt + 1) + p_pkt->offset;
#if AVDT_MULTIPLEXING == TRUE
- if(p_scb->curr_cfg.psc_mask & AVDT_PSC_MUX)
- {
+ if (p_scb->curr_cfg.psc_mask & AVDT_PSC_MUX) {
/* Adaptation Layer header later */
p_al = p;
p += 2;
*p++ = type;
/* save the location for length */
plen = p;
- p+= 2;
+ p += 2;
ssrc = avdt_scb_gen_ssrc(p_scb);
UINT32_TO_BE_STREAM(p, ssrc);
- switch(type)
- {
+ switch (type) {
case AVDT_RTCP_PT_SR: /* Sender Report */
*pm1 = AVDT_MEDIA_OCTET1;
UINT32_TO_BE_STREAM(p, p_data->sr.ntp_sec);
case AVDT_RTCP_PT_SDES: /* Source Description */
*p++ = AVDT_RTCP_SDES_CNAME;
len = strlen((char *)p_data->cname);
- if(len > AVDT_MAX_CNAME_SIZE)
+ if (len > AVDT_MAX_CNAME_SIZE) {
len = AVDT_MAX_CNAME_SIZE;
+ }
*p++ = (UINT8)len;
- BCM_STRNCPY_S((char *)p, len+1, (char *)p_data->cname, len+1);
+ BCM_STRNCPY_S((char *)p, len + 1, (char *)p_data->cname, len + 1);
p += len;
break;
}
UINT16_TO_BE_STREAM(plen, len);
#if AVDT_MULTIPLEXING == TRUE
- if(p_scb->curr_cfg.psc_mask & AVDT_PSC_MUX)
- {
+ if (p_scb->curr_cfg.psc_mask & AVDT_PSC_MUX) {
/* Adaptation Layer header */
p = p_al;
len++;
UINT16_TO_BE_STREAM(p_al, len );
/* TSID, no-fragment bit and coding of length(9-bit length field) */
u = *p;
- *p = (p_scb->curr_cfg.mux_tsid_report<<3) | AVDT_ALH_LCODE_9BITM0;
- if(u)
+ *p = (p_scb->curr_cfg.mux_tsid_report << 3) | AVDT_ALH_LCODE_9BITM0;
+ if (u) {
*p |= AVDT_ALH_LCODE_9BITM1;
+ }
}
#endif
/* set the actual payload length */
p_pkt->len = p_end - p;
/* send the packet */
- if(L2CAP_DW_FAILED != avdt_ad_write_req(AVDT_CHAN_REPORT, p_scb->p_ccb, p_scb, p_pkt))
+ if (L2CAP_DW_FAILED != avdt_ad_write_req(AVDT_CHAN_REPORT, p_scb->p_ccb, p_scb, p_pkt)) {
result = AVDT_SUCCESS;
+ }
}
}
******************************************************************************/
UINT8 AVDT_SetTraceLevel (UINT8 new_level)
{
- if (new_level != 0xFF)
+ if (new_level != 0xFF) {
avdt_cb.trace_level = new_level;
+ }
return (avdt_cb.trace_level);
}
#if AVDT_DEBUG == TRUE
/* verbose state strings for trace */
-const char * const avdt_ccb_st_str[] = {
+const char *const avdt_ccb_st_str[] = {
"CCB_IDLE_ST",
"CCB_OPENING_ST",
"CCB_OPEN_ST",
};
/* verbose event strings for trace */
-const char * const avdt_ccb_evt_str[] = {
+const char *const avdt_ccb_evt_str[] = {
"API_DISCOVER_REQ_EVT",
"API_GETCAP_REQ_EVT",
"API_START_REQ_EVT",
/* state table for idle state */
const UINT8 avdt_ccb_st_idle[][AVDT_CCB_NUM_COLS] = {
-/* Event Action 1 Action 2 Next state */
-/* API_DISCOVER_REQ_EVT */ {AVDT_CCB_SND_DISCOVER_CMD, AVDT_CCB_CHAN_OPEN, AVDT_CCB_OPENING_ST},
-/* API_GETCAP_REQ_EVT */ {AVDT_CCB_SND_GETCAP_CMD, AVDT_CCB_CHAN_OPEN, AVDT_CCB_OPENING_ST},
-/* API_START_REQ_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
-/* API_SUSPEND_REQ_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
-/* API_DISCOVER_RSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
-/* API_GETCAP_RSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
-/* API_START_RSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
-/* API_SUSPEND_RSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
-/* API_CONNECT_REQ_EVT */ {AVDT_CCB_SET_CONN, AVDT_CCB_CHAN_OPEN, AVDT_CCB_OPENING_ST},
-/* API_DISCONNECT_REQ_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
-/* MSG_DISCOVER_CMD_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
-/* MSG_GETCAP_CMD_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
-/* MSG_START_CMD_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
-/* MSG_SUSPEND_CMD_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
-/* MSG_DISCOVER_RSP_EVT */ {AVDT_CCB_HDL_DISCOVER_RSP, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
-/* MSG_GETCAP_RSP_EVT */ {AVDT_CCB_HDL_GETCAP_RSP, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
-/* MSG_START_RSP_EVT */ {AVDT_CCB_HDL_START_RSP, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
-/* MSG_SUSPEND_RSP_EVT */ {AVDT_CCB_HDL_SUSPEND_RSP, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
-/* RCVRSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
-/* SENDMSG_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
-/* RET_TOUT_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
-/* RSP_TOUT_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
-/* IDLE_TOUT_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
-/* UL_OPEN_EVT */ {AVDT_CCB_CHAN_OPEN, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
-/* UL_CLOSE_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
-/* LL_OPEN_EVT */ {AVDT_CCB_LL_OPENED, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
-/* LL_CLOSE_EVT */ {AVDT_CCB_LL_CLOSED, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
-/* LL_CONG_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST}
+ /* Event Action 1 Action 2 Next state */
+ /* API_DISCOVER_REQ_EVT */ {AVDT_CCB_SND_DISCOVER_CMD, AVDT_CCB_CHAN_OPEN, AVDT_CCB_OPENING_ST},
+ /* API_GETCAP_REQ_EVT */ {AVDT_CCB_SND_GETCAP_CMD, AVDT_CCB_CHAN_OPEN, AVDT_CCB_OPENING_ST},
+ /* API_START_REQ_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
+ /* API_SUSPEND_REQ_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
+ /* API_DISCOVER_RSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
+ /* API_GETCAP_RSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
+ /* API_START_RSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
+ /* API_SUSPEND_RSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
+ /* API_CONNECT_REQ_EVT */ {AVDT_CCB_SET_CONN, AVDT_CCB_CHAN_OPEN, AVDT_CCB_OPENING_ST},
+ /* API_DISCONNECT_REQ_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
+ /* MSG_DISCOVER_CMD_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
+ /* MSG_GETCAP_CMD_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
+ /* MSG_START_CMD_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
+ /* MSG_SUSPEND_CMD_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
+ /* MSG_DISCOVER_RSP_EVT */ {AVDT_CCB_HDL_DISCOVER_RSP, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
+ /* MSG_GETCAP_RSP_EVT */ {AVDT_CCB_HDL_GETCAP_RSP, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
+ /* MSG_START_RSP_EVT */ {AVDT_CCB_HDL_START_RSP, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
+ /* MSG_SUSPEND_RSP_EVT */ {AVDT_CCB_HDL_SUSPEND_RSP, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
+ /* RCVRSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
+ /* SENDMSG_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
+ /* RET_TOUT_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
+ /* RSP_TOUT_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
+ /* IDLE_TOUT_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
+ /* UL_OPEN_EVT */ {AVDT_CCB_CHAN_OPEN, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
+ /* UL_CLOSE_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
+ /* LL_OPEN_EVT */ {AVDT_CCB_LL_OPENED, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
+ /* LL_CLOSE_EVT */ {AVDT_CCB_LL_CLOSED, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
+ /* LL_CONG_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST}
};
/* state table for opening state */
const UINT8 avdt_ccb_st_opening[][AVDT_CCB_NUM_COLS] = {
-/* Event Action 1 Action 2 Next state */
-/* API_DISCOVER_REQ_EVT */ {AVDT_CCB_SND_DISCOVER_CMD, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
-/* API_GETCAP_REQ_EVT */ {AVDT_CCB_SND_GETCAP_CMD, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
-/* API_START_REQ_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
-/* API_SUSPEND_REQ_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
-/* API_DISCOVER_RSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
-/* API_GETCAP_RSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
-/* API_START_RSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
-/* API_SUSPEND_RSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
-/* API_CONNECT_REQ_EVT */ {AVDT_CCB_SET_CONN, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
-/* API_DISCONNECT_REQ_EVT */ {AVDT_CCB_SET_DISCONN, AVDT_CCB_DO_DISCONN, AVDT_CCB_CLOSING_ST},
-/* MSG_DISCOVER_CMD_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
-/* MSG_GETCAP_CMD_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
-/* MSG_START_CMD_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
-/* MSG_SUSPEND_CMD_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
-/* MSG_DISCOVER_RSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
-/* MSG_GETCAP_RSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
-/* MSG_START_RSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
-/* MSG_SUSPEND_RSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
-/* RCVRSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
-/* SENDMSG_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
-/* RET_TOUT_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
-/* RSP_TOUT_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
-/* IDLE_TOUT_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
-/* UL_OPEN_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
-/* UL_CLOSE_EVT */ {AVDT_CCB_CLEAR_CMDS, AVDT_CCB_CHAN_CLOSE, AVDT_CCB_CLOSING_ST},
-/* LL_OPEN_EVT */ {AVDT_CCB_SND_CMD, AVDT_CCB_LL_OPENED, AVDT_CCB_OPEN_ST},
-/* LL_CLOSE_EVT */ {AVDT_CCB_LL_CLOSED, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
-/* LL_CONG_EVT */ {AVDT_CCB_CONG_STATE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST}
+ /* Event Action 1 Action 2 Next state */
+ /* API_DISCOVER_REQ_EVT */ {AVDT_CCB_SND_DISCOVER_CMD, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
+ /* API_GETCAP_REQ_EVT */ {AVDT_CCB_SND_GETCAP_CMD, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
+ /* API_START_REQ_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
+ /* API_SUSPEND_REQ_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
+ /* API_DISCOVER_RSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
+ /* API_GETCAP_RSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
+ /* API_START_RSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
+ /* API_SUSPEND_RSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
+ /* API_CONNECT_REQ_EVT */ {AVDT_CCB_SET_CONN, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
+ /* API_DISCONNECT_REQ_EVT */ {AVDT_CCB_SET_DISCONN, AVDT_CCB_DO_DISCONN, AVDT_CCB_CLOSING_ST},
+ /* MSG_DISCOVER_CMD_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
+ /* MSG_GETCAP_CMD_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
+ /* MSG_START_CMD_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
+ /* MSG_SUSPEND_CMD_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
+ /* MSG_DISCOVER_RSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
+ /* MSG_GETCAP_RSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
+ /* MSG_START_RSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
+ /* MSG_SUSPEND_RSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
+ /* RCVRSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
+ /* SENDMSG_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
+ /* RET_TOUT_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
+ /* RSP_TOUT_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
+ /* IDLE_TOUT_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
+ /* UL_OPEN_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
+ /* UL_CLOSE_EVT */ {AVDT_CCB_CLEAR_CMDS, AVDT_CCB_CHAN_CLOSE, AVDT_CCB_CLOSING_ST},
+ /* LL_OPEN_EVT */ {AVDT_CCB_SND_CMD, AVDT_CCB_LL_OPENED, AVDT_CCB_OPEN_ST},
+ /* LL_CLOSE_EVT */ {AVDT_CCB_LL_CLOSED, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
+ /* LL_CONG_EVT */ {AVDT_CCB_CONG_STATE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST}
};
/* state table for open state */
const UINT8 avdt_ccb_st_open[][AVDT_CCB_NUM_COLS] = {
-/* Event Action 1 Action 2 Next state */
-/* API_DISCOVER_REQ_EVT */ {AVDT_CCB_SND_DISCOVER_CMD, AVDT_CCB_SND_CMD, AVDT_CCB_OPEN_ST},
-/* API_GETCAP_REQ_EVT */ {AVDT_CCB_SND_GETCAP_CMD, AVDT_CCB_SND_CMD, AVDT_CCB_OPEN_ST},
-/* API_START_REQ_EVT */ {AVDT_CCB_SND_START_CMD, AVDT_CCB_SND_CMD, AVDT_CCB_OPEN_ST},
-/* API_SUSPEND_REQ_EVT */ {AVDT_CCB_SND_SUSPEND_CMD, AVDT_CCB_SND_CMD, AVDT_CCB_OPEN_ST},
-/* API_DISCOVER_RSP_EVT */ {AVDT_CCB_SND_DISCOVER_RSP, AVDT_CCB_SND_CMD, AVDT_CCB_OPEN_ST},
-/* API_GETCAP_RSP_EVT */ {AVDT_CCB_SND_GETCAP_RSP, AVDT_CCB_SND_CMD, AVDT_CCB_OPEN_ST},
-/* API_START_RSP_EVT */ {AVDT_CCB_SND_START_RSP, AVDT_CCB_SND_CMD, AVDT_CCB_OPEN_ST},
-/* API_SUSPEND_RSP_EVT */ {AVDT_CCB_SND_SUSPEND_RSP, AVDT_CCB_SND_CMD, AVDT_CCB_OPEN_ST},
-/* API_CONNECT_REQ_EVT */ {AVDT_CCB_SET_CONN, AVDT_CCB_LL_OPENED, AVDT_CCB_OPEN_ST},
-/* API_DISCONNECT_REQ_EVT */ {AVDT_CCB_SET_DISCONN, AVDT_CCB_DO_DISCONN, AVDT_CCB_CLOSING_ST},
-/* MSG_DISCOVER_CMD_EVT */ {AVDT_CCB_HDL_DISCOVER_CMD, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
-/* MSG_GETCAP_CMD_EVT */ {AVDT_CCB_HDL_GETCAP_CMD, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
-/* MSG_START_CMD_EVT */ {AVDT_CCB_HDL_START_CMD, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
-/* MSG_SUSPEND_CMD_EVT */ {AVDT_CCB_HDL_SUSPEND_CMD, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
-/* MSG_DISCOVER_RSP_EVT */ {AVDT_CCB_CHK_CLOSE, AVDT_CCB_HDL_DISCOVER_RSP, AVDT_CCB_OPEN_ST},
-/* MSG_GETCAP_RSP_EVT */ {AVDT_CCB_CHK_CLOSE, AVDT_CCB_HDL_GETCAP_RSP, AVDT_CCB_OPEN_ST},
-/* MSG_START_RSP_EVT */ {AVDT_CCB_HDL_START_RSP, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
-/* MSG_SUSPEND_RSP_EVT */ {AVDT_CCB_HDL_SUSPEND_RSP, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
-/* RCVRSP_EVT */ {AVDT_CCB_FREE_CMD, AVDT_CCB_SND_CMD, AVDT_CCB_OPEN_ST},
-/* SENDMSG_EVT */ {AVDT_CCB_SND_MSG, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
-/* RET_TOUT_EVT */ {AVDT_CCB_RET_CMD, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
-/* RSP_TOUT_EVT */ {AVDT_CCB_CMD_FAIL, AVDT_CCB_SND_CMD, AVDT_CCB_OPEN_ST},
-/* IDLE_TOUT_EVT */ {AVDT_CCB_CLEAR_CMDS, AVDT_CCB_CHAN_CLOSE, AVDT_CCB_CLOSING_ST},
-/* UL_OPEN_EVT */ {AVDT_CCB_CHK_TIMER, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
-/* UL_CLOSE_EVT */ {AVDT_CCB_CHK_CLOSE, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
-/* LL_OPEN_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
-/* LL_CLOSE_EVT */ {AVDT_CCB_LL_CLOSED, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
-/* LL_CONG_EVT */ {AVDT_CCB_CONG_STATE, AVDT_CCB_SND_MSG, AVDT_CCB_OPEN_ST}
+ /* Event Action 1 Action 2 Next state */
+ /* API_DISCOVER_REQ_EVT */ {AVDT_CCB_SND_DISCOVER_CMD, AVDT_CCB_SND_CMD, AVDT_CCB_OPEN_ST},
+ /* API_GETCAP_REQ_EVT */ {AVDT_CCB_SND_GETCAP_CMD, AVDT_CCB_SND_CMD, AVDT_CCB_OPEN_ST},
+ /* API_START_REQ_EVT */ {AVDT_CCB_SND_START_CMD, AVDT_CCB_SND_CMD, AVDT_CCB_OPEN_ST},
+ /* API_SUSPEND_REQ_EVT */ {AVDT_CCB_SND_SUSPEND_CMD, AVDT_CCB_SND_CMD, AVDT_CCB_OPEN_ST},
+ /* API_DISCOVER_RSP_EVT */ {AVDT_CCB_SND_DISCOVER_RSP, AVDT_CCB_SND_CMD, AVDT_CCB_OPEN_ST},
+ /* API_GETCAP_RSP_EVT */ {AVDT_CCB_SND_GETCAP_RSP, AVDT_CCB_SND_CMD, AVDT_CCB_OPEN_ST},
+ /* API_START_RSP_EVT */ {AVDT_CCB_SND_START_RSP, AVDT_CCB_SND_CMD, AVDT_CCB_OPEN_ST},
+ /* API_SUSPEND_RSP_EVT */ {AVDT_CCB_SND_SUSPEND_RSP, AVDT_CCB_SND_CMD, AVDT_CCB_OPEN_ST},
+ /* API_CONNECT_REQ_EVT */ {AVDT_CCB_SET_CONN, AVDT_CCB_LL_OPENED, AVDT_CCB_OPEN_ST},
+ /* API_DISCONNECT_REQ_EVT */ {AVDT_CCB_SET_DISCONN, AVDT_CCB_DO_DISCONN, AVDT_CCB_CLOSING_ST},
+ /* MSG_DISCOVER_CMD_EVT */ {AVDT_CCB_HDL_DISCOVER_CMD, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
+ /* MSG_GETCAP_CMD_EVT */ {AVDT_CCB_HDL_GETCAP_CMD, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
+ /* MSG_START_CMD_EVT */ {AVDT_CCB_HDL_START_CMD, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
+ /* MSG_SUSPEND_CMD_EVT */ {AVDT_CCB_HDL_SUSPEND_CMD, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
+ /* MSG_DISCOVER_RSP_EVT */ {AVDT_CCB_CHK_CLOSE, AVDT_CCB_HDL_DISCOVER_RSP, AVDT_CCB_OPEN_ST},
+ /* MSG_GETCAP_RSP_EVT */ {AVDT_CCB_CHK_CLOSE, AVDT_CCB_HDL_GETCAP_RSP, AVDT_CCB_OPEN_ST},
+ /* MSG_START_RSP_EVT */ {AVDT_CCB_HDL_START_RSP, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
+ /* MSG_SUSPEND_RSP_EVT */ {AVDT_CCB_HDL_SUSPEND_RSP, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
+ /* RCVRSP_EVT */ {AVDT_CCB_FREE_CMD, AVDT_CCB_SND_CMD, AVDT_CCB_OPEN_ST},
+ /* SENDMSG_EVT */ {AVDT_CCB_SND_MSG, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
+ /* RET_TOUT_EVT */ {AVDT_CCB_RET_CMD, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
+ /* RSP_TOUT_EVT */ {AVDT_CCB_CMD_FAIL, AVDT_CCB_SND_CMD, AVDT_CCB_OPEN_ST},
+ /* IDLE_TOUT_EVT */ {AVDT_CCB_CLEAR_CMDS, AVDT_CCB_CHAN_CLOSE, AVDT_CCB_CLOSING_ST},
+ /* UL_OPEN_EVT */ {AVDT_CCB_CHK_TIMER, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
+ /* UL_CLOSE_EVT */ {AVDT_CCB_CHK_CLOSE, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
+ /* LL_OPEN_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
+ /* LL_CLOSE_EVT */ {AVDT_CCB_LL_CLOSED, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
+ /* LL_CONG_EVT */ {AVDT_CCB_CONG_STATE, AVDT_CCB_SND_MSG, AVDT_CCB_OPEN_ST}
};
/* state table for closing state */
const UINT8 avdt_ccb_st_closing[][AVDT_CCB_NUM_COLS] = {
-/* Event Action 1 Action 2 Next state */
-/* API_DISCOVER_REQ_EVT */ {AVDT_CCB_SET_RECONN, AVDT_CCB_SND_DISCOVER_CMD, AVDT_CCB_CLOSING_ST},
-/* API_GETCAP_REQ_EVT */ {AVDT_CCB_SET_RECONN, AVDT_CCB_SND_GETCAP_CMD, AVDT_CCB_CLOSING_ST},
-/* API_START_REQ_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
-/* API_SUSPEND_REQ_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
-/* API_DISCOVER_RSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
-/* API_GETCAP_RSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
-/* API_START_RSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
-/* API_SUSPEND_RSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
-/* API_CONNECT_REQ_EVT */ {AVDT_CCB_SET_RECONN, AVDT_CCB_SET_CONN, AVDT_CCB_CLOSING_ST},
-/* API_DISCONNECT_REQ_EVT */ {AVDT_CCB_CLR_RECONN, AVDT_CCB_SET_DISCONN, AVDT_CCB_CLOSING_ST},
-/* MSG_DISCOVER_CMD_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
-/* MSG_GETCAP_CMD_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
-/* MSG_START_CMD_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
-/* MSG_SUSPEND_CMD_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
-/* MSG_DISCOVER_RSP_EVT */ {AVDT_CCB_HDL_DISCOVER_RSP, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
-/* MSG_GETCAP_RSP_EVT */ {AVDT_CCB_HDL_GETCAP_RSP, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
-/* MSG_START_RSP_EVT */ {AVDT_CCB_HDL_START_RSP, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
-/* MSG_SUSPEND_RSP_EVT */ {AVDT_CCB_HDL_SUSPEND_RSP, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
-/* RCVRSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
-/* SENDMSG_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
-/* RET_TOUT_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
-/* RSP_TOUT_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
-/* IDLE_TOUT_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
-/* UL_OPEN_EVT */ {AVDT_CCB_SET_RECONN, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
-/* UL_CLOSE_EVT */ {AVDT_CCB_CLR_RECONN, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
-/* LL_OPEN_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
-/* LL_CLOSE_EVT */ {AVDT_CCB_CHK_RECONN, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
-/* LL_CONG_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST}
+ /* Event Action 1 Action 2 Next state */
+ /* API_DISCOVER_REQ_EVT */ {AVDT_CCB_SET_RECONN, AVDT_CCB_SND_DISCOVER_CMD, AVDT_CCB_CLOSING_ST},
+ /* API_GETCAP_REQ_EVT */ {AVDT_CCB_SET_RECONN, AVDT_CCB_SND_GETCAP_CMD, AVDT_CCB_CLOSING_ST},
+ /* API_START_REQ_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
+ /* API_SUSPEND_REQ_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
+ /* API_DISCOVER_RSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
+ /* API_GETCAP_RSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
+ /* API_START_RSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
+ /* API_SUSPEND_RSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
+ /* API_CONNECT_REQ_EVT */ {AVDT_CCB_SET_RECONN, AVDT_CCB_SET_CONN, AVDT_CCB_CLOSING_ST},
+ /* API_DISCONNECT_REQ_EVT */ {AVDT_CCB_CLR_RECONN, AVDT_CCB_SET_DISCONN, AVDT_CCB_CLOSING_ST},
+ /* MSG_DISCOVER_CMD_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
+ /* MSG_GETCAP_CMD_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
+ /* MSG_START_CMD_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
+ /* MSG_SUSPEND_CMD_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
+ /* MSG_DISCOVER_RSP_EVT */ {AVDT_CCB_HDL_DISCOVER_RSP, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
+ /* MSG_GETCAP_RSP_EVT */ {AVDT_CCB_HDL_GETCAP_RSP, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
+ /* MSG_START_RSP_EVT */ {AVDT_CCB_HDL_START_RSP, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
+ /* MSG_SUSPEND_RSP_EVT */ {AVDT_CCB_HDL_SUSPEND_RSP, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
+ /* RCVRSP_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
+ /* SENDMSG_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
+ /* RET_TOUT_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
+ /* RSP_TOUT_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
+ /* IDLE_TOUT_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
+ /* UL_OPEN_EVT */ {AVDT_CCB_SET_RECONN, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
+ /* UL_CLOSE_EVT */ {AVDT_CCB_CLR_RECONN, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
+ /* LL_OPEN_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
+ /* LL_CLOSE_EVT */ {AVDT_CCB_CHK_RECONN, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
+ /* LL_CONG_EVT */ {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST}
};
/* type for state table */
}
/* execute action functions */
- for (i = 0; i < AVDT_CCB_ACTIONS; i++)
- {
- if ((action = state_table[event][i]) != AVDT_CCB_IGNORE)
- {
+ for (i = 0; i < AVDT_CCB_ACTIONS; i++) {
+ if ((action = state_table[event][i]) != AVDT_CCB_IGNORE) {
(*avdt_cb.p_ccb_act[action])(p_ccb, p_data);
- }
- else
- {
+ } else {
break;
}
}
tAVDT_CCB *p_ccb = &avdt_cb.ccb[0];
int i;
- for (i = 0; i < AVDT_NUM_LINKS; i++, p_ccb++)
- {
+ for (i = 0; i < AVDT_NUM_LINKS; i++, p_ccb++) {
/* if allocated ccb has matching ccb */
- if (p_ccb->allocated && (!memcmp(p_ccb->peer_addr, bd_addr, BD_ADDR_LEN)))
- {
+ if (p_ccb->allocated && (!memcmp(p_ccb->peer_addr, bd_addr, BD_ADDR_LEN))) {
break;
}
}
- if (i == AVDT_NUM_LINKS)
- {
+ if (i == AVDT_NUM_LINKS) {
/* if no ccb found */
p_ccb = NULL;
AVDT_TRACE_DEBUG("No ccb for addr %02x-%02x-%02x-%02x-%02x-%02x\n",
- bd_addr[0], bd_addr[1], bd_addr[2], bd_addr[3], bd_addr[4], bd_addr[5]);
+ bd_addr[0], bd_addr[1], bd_addr[2], bd_addr[3], bd_addr[4], bd_addr[5]);
}
return p_ccb;
}
tAVDT_CCB *p_ccb = &avdt_cb.ccb[0];
int i;
- for (i = 0; i < AVDT_NUM_LINKS; i++, p_ccb++)
- {
- if (!p_ccb->allocated)
- {
+ for (i = 0; i < AVDT_NUM_LINKS; i++, p_ccb++) {
+ if (!p_ccb->allocated) {
p_ccb->allocated = TRUE;
memcpy(p_ccb->peer_addr, bd_addr, BD_ADDR_LEN);
GKI_init_q(&p_ccb->cmd_q);
}
}
- if (i == AVDT_NUM_LINKS)
- {
+ if (i == AVDT_NUM_LINKS) {
/* out of ccbs */
p_ccb = NULL;
AVDT_TRACE_WARNING("Out of ccbs");
tAVDT_CCB *p_ccb;
/* verify index */
- if (idx < AVDT_NUM_LINKS)
- {
+ if (idx < AVDT_NUM_LINKS) {
p_ccb = &avdt_cb.ccb[idx];
- }
- else
- {
+ } else {
p_ccb = NULL;
AVDT_TRACE_WARNING("No ccb for idx %d\n", idx);
}
p_ccb->ret_count = 0;
/* free message being fragmented */
- if (p_ccb->p_curr_msg != NULL)
- {
+ if (p_ccb->p_curr_msg != NULL) {
GKI_freebuf(p_ccb->p_curr_msg);
p_ccb->p_curr_msg = NULL;
}
/* free message being reassembled */
- if (p_ccb->p_rx_msg != NULL)
- {
+ if (p_ccb->p_rx_msg != NULL) {
GKI_freebuf(p_ccb->p_rx_msg);
p_ccb->p_rx_msg = NULL;
}
/* clear out response queue */
- while ((p_buf = (BT_HDR *) GKI_dequeue(&p_ccb->rsp_q)) != NULL)
- {
+ while ((p_buf = (BT_HDR *) GKI_dequeue(&p_ccb->rsp_q)) != NULL) {
GKI_freebuf(p_buf);
}
}
UNUSED(p_data);
/* see if there are any active scbs associated with this ccb */
- for (i = 0; i < AVDT_NUM_SEPS; i++, p_scb++)
- {
- if ((p_scb->allocated) && (p_scb->p_ccb == p_ccb))
- {
+ for (i = 0; i < AVDT_NUM_SEPS; i++, p_scb++) {
+ if ((p_scb->allocated) && (p_scb->p_ccb == p_ccb)) {
break;
}
}
/* if no active scbs start idle timer */
- if (i == AVDT_NUM_SEPS)
- {
+ if (i == AVDT_NUM_SEPS) {
btu_start_timer(&p_ccb->timer_entry, BTU_TTYPE_AVDT_CCB_IDLE, avdt_cb.rcb.idle_tout);
}
}
p_data->msg.discover_rsp.num_seps = 0;
/* for all allocated scbs */
- for (i = 0; i < AVDT_NUM_SEPS; i++, p_scb++)
- {
- if (p_scb->allocated)
- {
+ for (i = 0; i < AVDT_NUM_SEPS; i++, p_scb++) {
+ if (p_scb->allocated) {
/* copy sep info */
sep_info[p_data->msg.discover_rsp.num_seps].in_use = p_scb->in_use;
sep_info[p_data->msg.discover_rsp.num_seps].seid = i + 1;
/* verify all streams in the right state */
UINT8 seid = avdt_scb_verify(p_ccb, AVDT_VERIFY_START, p_data->msg.multi.seid_list,
p_data->msg.multi.num_seps, &err_code);
- if (seid == 0 && err_code == 0)
- {
+ if (seid == 0 && err_code == 0) {
/* we're ok, send response */
avdt_ccb_event(p_ccb, AVDT_CCB_API_START_RSP_EVT, p_data);
} else {
p = (UINT8 *)(p_ccb->p_curr_cmd + 1);
/* little trick here; length of current command equals number of streams */
- for (i = 0; i < p_ccb->p_curr_cmd->len; i++)
- {
- if ((p_scb = avdt_scb_by_hdl(p[i])) != NULL)
- {
+ for (i = 0; i < p_ccb->p_curr_cmd->len; i++) {
+ if ((p_scb = avdt_scb_by_hdl(p[i])) != NULL) {
avdt_scb_event(p_scb, event, (tAVDT_SCB_EVT *) &p_data->msg);
}
}
/* verify all streams in the right state */
if ((seid = avdt_scb_verify(p_ccb, AVDT_VERIFY_SUSPEND, p_data->msg.multi.seid_list,
p_data->msg.multi.num_seps, &err_code)) == 0 &&
- err_code == 0)
- {
+ err_code == 0) {
/* we're ok, send response */
avdt_ccb_event(p_ccb, AVDT_CCB_API_SUSPEND_RSP_EVT, p_data);
- }
- else
- {
+ } else {
/* not ok, send reject */
p_data->msg.hdr.err_code = err_code;
p_data->msg.hdr.err_param = seid;
p = (UINT8 *)(p_ccb->p_curr_cmd + 1);
/* little trick here; length of current command equals number of streams */
- for (i = 0; i < p_ccb->p_curr_cmd->len; i++)
- {
- if ((p_scb = avdt_scb_by_hdl(p[i])) != NULL)
- {
+ for (i = 0; i < p_ccb->p_curr_cmd->len; i++) {
+ if ((p_scb = avdt_scb_by_hdl(p[i])) != NULL) {
avdt_scb_event(p_scb, event, (tAVDT_SCB_EVT *) &p_data->msg);
}
}
p_ccb->proc_busy = TRUE;
/* build and queue discover req */
- if (p_data->msg.hdr.sig_id == AVDT_SIG_GET_ALLCAP)
+ if (p_data->msg.hdr.sig_id == AVDT_SIG_GET_ALLCAP) {
sig_id = AVDT_SIG_GET_ALLCAP;
+ }
avdt_msg_send_cmd(p_ccb, NULL, sig_id, (tAVDT_MSG *) &p_data->getcap.single);
}
{
UINT8 sig_id = AVDT_SIG_GETCAP;
- if (p_data->msg.hdr.sig_id == AVDT_SIG_GET_ALLCAP)
+ if (p_data->msg.hdr.sig_id == AVDT_SIG_GET_ALLCAP) {
sig_id = AVDT_SIG_GET_ALLCAP;
+ }
/* send response */
avdt_msg_send_rsp(p_ccb, sig_id, &p_data->msg);
/* verify all streams in the right state */
if ((avdt_msg.hdr.err_param = avdt_scb_verify(p_ccb, AVDT_VERIFY_OPEN, p_data->msg.multi.seid_list,
- p_data->msg.multi.num_seps, &avdt_msg.hdr.err_code)) == 0)
- {
+ p_data->msg.multi.num_seps, &avdt_msg.hdr.err_code)) == 0) {
/* set peer seid list in messsage */
avdt_scb_peer_seid_list(&p_data->msg.multi);
/* send command */
avdt_msg_send_cmd(p_ccb, seid_list, AVDT_SIG_START, &p_data->msg);
- }
- else
- {
+ } else {
/* failed; send ourselves a reject for each stream */
- for (i = 0; i < p_data->msg.multi.num_seps; i++)
- {
- if ((p_scb = avdt_scb_by_hdl(seid_list[i])) != NULL)
- {
+ for (i = 0; i < p_data->msg.multi.num_seps; i++) {
+ if ((p_scb = avdt_scb_by_hdl(seid_list[i])) != NULL) {
avdt_scb_event(p_scb, AVDT_SCB_MSG_START_REJ_EVT, (tAVDT_SCB_EVT *) &avdt_msg.hdr);
}
}
avdt_msg_send_rsp(p_ccb, AVDT_SIG_START, &p_data->msg);
/* send start event to each scb */
- for (i = 0; i < p_data->msg.multi.num_seps; i++)
- {
- if ((p_scb = avdt_scb_by_hdl(p_data->msg.multi.seid_list[i])) != NULL)
- {
+ for (i = 0; i < p_data->msg.multi.num_seps; i++) {
+ if ((p_scb = avdt_scb_by_hdl(p_data->msg.multi.seid_list[i])) != NULL) {
avdt_scb_event(p_scb, AVDT_SCB_MSG_START_CMD_EVT, NULL);
}
}
/* verify all streams in the right state */
if ((avdt_msg.hdr.err_param = avdt_scb_verify(p_ccb, AVDT_VERIFY_STREAMING, p_data->msg.multi.seid_list,
- p_data->msg.multi.num_seps, &avdt_msg.hdr.err_code)) == 0)
- {
+ p_data->msg.multi.num_seps, &avdt_msg.hdr.err_code)) == 0) {
/* set peer seid list in messsage */
avdt_scb_peer_seid_list(&p_data->msg.multi);
/* send command */
avdt_msg_send_cmd(p_ccb, seid_list, AVDT_SIG_SUSPEND, &p_data->msg);
- }
- else
- {
+ } else {
/* failed; send ourselves a reject for each stream */
- for (i = 0; i < p_data->msg.multi.num_seps; i++)
- {
- if ((p_scb = avdt_scb_by_hdl(seid_list[i])) != NULL)
- {
+ for (i = 0; i < p_data->msg.multi.num_seps; i++) {
+ if ((p_scb = avdt_scb_by_hdl(seid_list[i])) != NULL) {
avdt_scb_event(p_scb, AVDT_SCB_MSG_SUSPEND_REJ_EVT, (tAVDT_SCB_EVT *) &avdt_msg.hdr);
}
}
avdt_msg_send_rsp(p_ccb, AVDT_SIG_SUSPEND, &p_data->msg);
/* send start event to each scb */
- for (i = 0; i < p_data->msg.multi.num_seps; i++)
- {
- if ((p_scb = avdt_scb_by_hdl(p_data->msg.multi.seid_list[i])) != NULL)
- {
+ for (i = 0; i < p_data->msg.multi.num_seps; i++) {
+ if ((p_scb = avdt_scb_by_hdl(p_data->msg.multi.seid_list[i])) != NULL) {
avdt_scb_event(p_scb, AVDT_SCB_MSG_SUSPEND_CMD_EVT, NULL);
}
}
** to handle the case where there is a command on deck in p_curr_cmd,
** plus we need to clear out the queue
*/
- do
- {
+ do {
/* we know p_curr_cmd = NULL after this */
avdt_ccb_cmd_fail(p_ccb, (tAVDT_CCB_EVT *) &err_code);
} while (p_ccb->p_curr_cmd != NULL);
/* send a CC_CLOSE_EVT any active scbs associated with this ccb */
- for (i = 0; i < AVDT_NUM_SEPS; i++, p_scb++)
- {
- if ((p_scb->allocated) && (p_scb->p_ccb == p_ccb))
- {
+ for (i = 0; i < AVDT_NUM_SEPS; i++, p_scb++) {
+ if ((p_scb->allocated) && (p_scb->p_ccb == p_ccb)) {
avdt_scb_event(p_scb, AVDT_SCB_CC_CLOSE_EVT, NULL);
}
}
UINT8 evt;
tAVDT_SCB *p_scb;
- if (p_ccb->p_curr_cmd != NULL)
- {
+ if (p_ccb->p_curr_cmd != NULL) {
/* set up data */
msg.hdr.err_code = p_data->err_code;
msg.hdr.err_param = 0;
/* pretend that we received a rej message */
evt = avdt_msg_rej_2_evt[p_ccb->p_curr_cmd->event - 1];
- if (evt & AVDT_CCB_MKR)
- {
+ if (evt & AVDT_CCB_MKR) {
avdt_ccb_event(p_ccb, (UINT8) (evt & ~AVDT_CCB_MKR), (tAVDT_CCB_EVT *) &msg);
- }
- else
- {
+ } else {
/* we get the scb out of the current cmd */
p_scb = avdt_scb_by_hdl(*((UINT8 *)(p_ccb->p_curr_cmd + 1)));
- if (p_scb != NULL)
- {
+ if (p_scb != NULL) {
avdt_scb_event(p_scb, evt, (tAVDT_SCB_EVT *) &msg);
}
}
{
UNUSED(p_data);
- if (p_ccb->p_curr_cmd != NULL)
- {
+ if (p_ccb->p_curr_cmd != NULL) {
GKI_freebuf(p_ccb->p_curr_cmd);
p_ccb->p_curr_cmd = NULL;
}
BT_HDR *p_msg;
p_ccb->ret_count++;
- if (p_ccb->ret_count == AVDT_RET_MAX)
- {
+ if (p_ccb->ret_count == AVDT_RET_MAX) {
/* command failed */
p_ccb->ret_count = 0;
avdt_ccb_cmd_fail(p_ccb, (tAVDT_CCB_EVT *) &err_code);
/* go to next queued command */
avdt_ccb_snd_cmd(p_ccb, p_data);
- }
- else
- {
+ } else {
/* if command pending and we're not congested and not sending a fragment */
- if ((!p_ccb->cong) && (p_ccb->p_curr_msg == NULL) && (p_ccb->p_curr_cmd != NULL))
- {
+ if ((!p_ccb->cong) && (p_ccb->p_curr_msg == NULL) && (p_ccb->p_curr_cmd != NULL)) {
/* make copy of message in p_curr_cmd and send it */
- if ((p_msg = (BT_HDR *) GKI_getpoolbuf(AVDT_CMD_POOL_ID)) != NULL)
- {
+ if ((p_msg = (BT_HDR *) GKI_getpoolbuf(AVDT_CMD_POOL_ID)) != NULL) {
memcpy(p_msg, p_ccb->p_curr_cmd,
(sizeof(BT_HDR) + p_ccb->p_curr_cmd->offset + p_ccb->p_curr_cmd->len));
avdt_msg_send(p_ccb, p_msg);
/* do we have commands to send? send next command; make sure we're clear;
** not congested, not sending fragment, not waiting for response
*/
- if ((!p_ccb->cong) && (p_ccb->p_curr_msg == NULL) && (p_ccb->p_curr_cmd == NULL))
- {
- if ((p_msg = (BT_HDR *) GKI_dequeue(&p_ccb->cmd_q)) != NULL)
- {
+ if ((!p_ccb->cong) && (p_ccb->p_curr_msg == NULL) && (p_ccb->p_curr_cmd == NULL)) {
+ if ((p_msg = (BT_HDR *) GKI_dequeue(&p_ccb->cmd_q)) != NULL) {
/* make a copy of buffer in p_curr_cmd */
- if ((p_ccb->p_curr_cmd = (BT_HDR *) GKI_getpoolbuf(AVDT_CMD_POOL_ID)) != NULL)
- {
+ if ((p_ccb->p_curr_cmd = (BT_HDR *) GKI_getpoolbuf(AVDT_CMD_POOL_ID)) != NULL) {
memcpy(p_ccb->p_curr_cmd, p_msg, (sizeof(BT_HDR) + p_msg->offset + p_msg->len));
avdt_msg_send(p_ccb, p_msg);
UNUSED(p_data);
/* if not congested */
- if (!p_ccb->cong)
- {
+ if (!p_ccb->cong) {
/* are we sending a fragmented message? continue sending fragment */
- if (p_ccb->p_curr_msg != NULL)
- {
+ if (p_ccb->p_curr_msg != NULL) {
avdt_msg_send(p_ccb, NULL);
}
/* do we have responses to send? send them */
- else if (!GKI_queue_is_empty(&p_ccb->rsp_q))
- {
- while ((p_msg = (BT_HDR *) GKI_dequeue(&p_ccb->rsp_q)) != NULL)
- {
- if (avdt_msg_send(p_ccb, p_msg) == TRUE)
- {
+ else if (!GKI_queue_is_empty(&p_ccb->rsp_q)) {
+ while ((p_msg = (BT_HDR *) GKI_dequeue(&p_ccb->rsp_q)) != NULL) {
+ if (avdt_msg_send(p_ccb, p_msg) == TRUE) {
/* break out if congested */
break;
}
UINT8 err_code = AVDT_ERR_CONNECT;
UNUSED(p_data);
- if (p_ccb->reconn)
- {
+ if (p_ccb->reconn) {
p_ccb->reconn = FALSE;
/* clear out ccb */
/* reopen the signaling channel */
avdt_ccb_event(p_ccb, AVDT_CCB_UL_OPEN_EVT, NULL);
- }
- else
- {
+ } else {
avdt_ccb_ll_closed(p_ccb, NULL);
}
}
{
UNUSED(p_data);
- if (p_ccb->timer_entry.event == BTU_TTYPE_AVDT_CCB_IDLE)
- {
+ if (p_ccb->timer_entry.event == BTU_TTYPE_AVDT_CCB_IDLE) {
btu_stop_timer(&p_ccb->timer_entry);
}
}
p_ccb->p_conn_cback, p_data->disconnect.p_cback);
*/
/* save callback */
- if (p_data->disconnect.p_cback)
+ if (p_data->disconnect.p_cback) {
p_ccb->p_conn_cback = p_data->disconnect.p_cback;
+ }
}
/*******************************************************************************
/* save callback pointer, bd addr */
p_cback = p_ccb->p_conn_cback;
- if (!p_cback)
+ if (!p_cback) {
p_cback = avdt_cb.p_conn_cback;
+ }
memcpy(bd_addr, p_ccb->peer_addr, BD_ADDR_LEN);
disc_rsn = p_ccb->disc_rsn;
-
+
/* dealloc ccb */
avdt_ccb_dealloc(p_ccb, NULL);
/* call callback */
- if (p_cback)
- {
+ if (p_cback) {
avdt_ctrl.hdr.err_code = 0;
avdt_ctrl.hdr.err_param = disc_rsn;
p_ccb->ll_opened = TRUE;
- if (!p_ccb->p_conn_cback)
+ if (!p_ccb->p_conn_cback) {
p_ccb->p_conn_cback = avdt_cb.p_conn_cback;
+ }
/* call callback */
- if (p_ccb->p_conn_cback)
- {
+ if (p_ccb->p_conn_cback) {
avdt_ctrl.hdr.err_code = 0;
avdt_ctrl.hdr.err_param = p_data->msg.hdr.err_param;
(*p_ccb->p_conn_cback)(0, p_ccb->peer_addr, AVDT_CONNECT_IND_EVT, &avdt_ctrl);
**
*******************************************************************************/
static void avdt_sec_check_complete_term (BD_ADDR bd_addr, tBT_TRANSPORT transport,
- void *p_ref_data, UINT8 res)
+ void *p_ref_data, UINT8 res)
{
tAVDT_CCB *p_ccb = NULL;
tL2CAP_CFG_INFO cfg;
UNUSED(p_ref_data);
AVDT_TRACE_DEBUG("avdt_sec_check_complete_term res: %d\n", res);
- if (!bd_addr)
- {
+ if (!bd_addr) {
AVDT_TRACE_WARNING("avdt_sec_check_complete_term: NULL BD_ADDR");
return;
p_ccb = avdt_ccb_by_bd(bd_addr);
p_tbl = avdt_ad_tc_tbl_by_st(AVDT_CHAN_SIG, p_ccb, AVDT_AD_ST_SEC_ACP);
- if (p_tbl == NULL)
+ if (p_tbl == NULL) {
return;
+ }
- if (res == BTM_SUCCESS)
- {
+ if (res == BTM_SUCCESS) {
/* Send response to the L2CAP layer. */
L2CA_ConnectRsp (bd_addr, p_tbl->id, p_tbl->lcid, L2CAP_CONN_OK, L2CAP_CONN_OK);
cfg.flush_to_present = TRUE;
cfg.flush_to = p_tbl->my_flush_to;
L2CA_ConfigReq(p_tbl->lcid, &cfg);
- }
- else
- {
+ } else {
L2CA_ConnectRsp (bd_addr, p_tbl->id, p_tbl->lcid, L2CAP_CONN_SECURITY_BLOCK, L2CAP_CONN_OK);
avdt_ad_tc_close_ind(p_tbl, L2CAP_CONN_SECURITY_BLOCK);
}
**
*******************************************************************************/
static void avdt_sec_check_complete_orig (BD_ADDR bd_addr, tBT_TRANSPORT trasnport,
- void *p_ref_data, UINT8 res)
+ void *p_ref_data, UINT8 res)
{
tAVDT_CCB *p_ccb = NULL;
tL2CAP_CFG_INFO cfg;
UNUSED(p_ref_data);
AVDT_TRACE_DEBUG("avdt_sec_check_complete_orig res: %d\n", res);
- if (bd_addr)
+ if (bd_addr) {
p_ccb = avdt_ccb_by_bd(bd_addr);
+ }
p_tbl = avdt_ad_tc_tbl_by_st(AVDT_CHAN_SIG, p_ccb, AVDT_AD_ST_SEC_INT);
- if(p_tbl == NULL)
+ if (p_tbl == NULL) {
return;
+ }
- if( res == BTM_SUCCESS )
- {
+ if ( res == BTM_SUCCESS ) {
/* set channel state */
p_tbl->state = AVDT_AD_ST_CFG;
cfg.flush_to_present = TRUE;
cfg.flush_to = p_tbl->my_flush_to;
L2CA_ConfigReq(p_tbl->lcid, &cfg);
- }
- else
- {
+ } else {
L2CA_DisconnectReq (p_tbl->lcid);
avdt_ad_tc_close_ind(p_tbl, L2CAP_CONN_SECURITY_BLOCK);
}
UNUSED(psm);
/* do we already have a control channel for this peer? */
- if ((p_ccb = avdt_ccb_by_bd(bd_addr)) == NULL)
- {
+ if ((p_ccb = avdt_ccb_by_bd(bd_addr)) == NULL) {
/* no, allocate ccb */
- if ((p_ccb = avdt_ccb_alloc(bd_addr)) == NULL)
- {
+ if ((p_ccb = avdt_ccb_alloc(bd_addr)) == NULL) {
/* no ccb available, reject L2CAP connection */
result = L2CAP_CONN_NO_RESOURCES;
- }
- else
- {
+ } else {
/* allocate and set up entry; first channel is always signaling */
p_tbl = avdt_ad_tc_tbl_alloc(p_ccb);
p_tbl->my_mtu = avdt_cb.rcb.ctrl_mtu;
/* Check the security */
rc = btm_sec_mx_access_request (bd_addr, AVDT_PSM,
- FALSE, BTM_SEC_PROTO_AVDT,
- AVDT_CHAN_SIG,
- &avdt_sec_check_complete_term, NULL);
- if(rc == BTM_CMD_STARTED)
- {
+ FALSE, BTM_SEC_PROTO_AVDT,
+ AVDT_CHAN_SIG,
+ &avdt_sec_check_complete_term, NULL);
+ if (rc == BTM_CMD_STARTED) {
L2CA_ConnectRsp (p_ccb->peer_addr, p_tbl->id, lcid, L2CAP_CONN_PENDING, L2CAP_CONN_OK);
}
return;
}
}
/* deal with simultaneous control channel connect case */
- else if ((p_tbl = avdt_ad_tc_tbl_by_st(AVDT_CHAN_SIG, p_ccb, AVDT_AD_ST_CONN)) != NULL)
- {
+ else if ((p_tbl = avdt_ad_tc_tbl_by_st(AVDT_CHAN_SIG, p_ccb, AVDT_AD_ST_CONN)) != NULL) {
/* reject their connection */
result = L2CAP_CONN_NO_RESOURCES;
}
/* this must be a traffic channel; are we accepting a traffic channel
** for this ccb?
*/
- else if ((p_tbl = avdt_ad_tc_tbl_by_st(AVDT_CHAN_MEDIA, p_ccb, AVDT_AD_ST_ACP)) != NULL)
- {
+ else if ((p_tbl = avdt_ad_tc_tbl_by_st(AVDT_CHAN_MEDIA, p_ccb, AVDT_AD_ST_ACP)) != NULL) {
/* yes; proceed with connection */
result = L2CAP_CONN_OK;
}
/* this must be a reporting channel; are we accepting a reporting channel
** for this ccb?
*/
- else if ((p_tbl = avdt_ad_tc_tbl_by_st(AVDT_CHAN_REPORT, p_ccb, AVDT_AD_ST_ACP)) != NULL)
- {
+ else if ((p_tbl = avdt_ad_tc_tbl_by_st(AVDT_CHAN_REPORT, p_ccb, AVDT_AD_ST_ACP)) != NULL) {
/* yes; proceed with connection */
result = L2CAP_CONN_OK;
}
#endif
/* else we're not listening for traffic channel; reject */
- else
- {
+ else {
result = L2CAP_CONN_NO_PSM;
}
L2CA_ConnectRsp(bd_addr, id, lcid, result, 0);
/* if result ok, proceed with connection */
- if (result == L2CAP_CONN_OK)
- {
+ if (result == L2CAP_CONN_OK) {
/* store idx in LCID table, store LCID in routing table */
avdt_cb.ad.lcid_tbl[lcid - L2CAP_BASE_APPL_CID] = avdt_ad_tc_tbl_to_idx(p_tbl);
avdt_cb.ad.rt_tbl[avdt_ccb_to_idx(p_ccb)][p_tbl->tcid].lcid = lcid;
tAVDT_CCB *p_ccb;
AVDT_TRACE_DEBUG("avdt_l2c_connect_cfm_cback lcid: %d, result: %d\n",
- lcid, result);
+ lcid, result);
/* look up info for this channel */
- if ((p_tbl = avdt_ad_tc_tbl_by_lcid(lcid)) != NULL)
- {
+ if ((p_tbl = avdt_ad_tc_tbl_by_lcid(lcid)) != NULL) {
/* if in correct state */
- if (p_tbl->state == AVDT_AD_ST_CONN)
- {
+ if (p_tbl->state == AVDT_AD_ST_CONN) {
/* if result successful */
- if (result == L2CAP_CONN_OK)
- {
- if(p_tbl->tcid != AVDT_CHAN_SIG)
- {
+ if (result == L2CAP_CONN_OK) {
+ if (p_tbl->tcid != AVDT_CHAN_SIG) {
/* set channel state */
p_tbl->state = AVDT_AD_ST_CFG;
cfg.flush_to_present = TRUE;
cfg.flush_to = p_tbl->my_flush_to;
L2CA_ConfigReq(lcid, &cfg);
- }
- else
- {
+ } else {
p_ccb = avdt_ccb_by_idx(p_tbl->ccb_idx);
- if(p_ccb == NULL)
- {
+ if (p_ccb == NULL) {
result = L2CAP_CONN_NO_RESOURCES;
- }
- else
- {
+ } else {
/* set channel state */
p_tbl->state = AVDT_AD_ST_SEC_INT;
p_tbl->lcid = lcid;
/* Check the security */
btm_sec_mx_access_request (p_ccb->peer_addr, AVDT_PSM,
- TRUE, BTM_SEC_PROTO_AVDT,
- AVDT_CHAN_SIG,
- &avdt_sec_check_complete_orig, NULL);
+ TRUE, BTM_SEC_PROTO_AVDT,
+ AVDT_CHAN_SIG,
+ &avdt_sec_check_complete_orig, NULL);
}
}
}
/* failure; notify adaption that channel closed */
- if (result != L2CAP_CONN_OK)
- {
+ if (result != L2CAP_CONN_OK) {
avdt_ad_tc_close_ind(p_tbl, result);
}
}
tAVDT_TC_TBL *p_tbl;
/* look up info for this channel */
- if ((p_tbl = avdt_ad_tc_tbl_by_lcid(lcid)) != NULL)
- {
+ if ((p_tbl = avdt_ad_tc_tbl_by_lcid(lcid)) != NULL) {
p_tbl->lcid = lcid;
/* if in correct state */
- if (p_tbl->state == AVDT_AD_ST_CFG)
- {
+ if (p_tbl->state == AVDT_AD_ST_CFG) {
/* if result successful */
- if (p_cfg->result == L2CAP_CONN_OK)
- {
+ if (p_cfg->result == L2CAP_CONN_OK) {
/* update cfg_flags */
p_tbl->cfg_flags |= AVDT_L2C_CFG_CFM_DONE;
/* if configuration complete */
- if (p_tbl->cfg_flags & AVDT_L2C_CFG_IND_DONE)
- {
+ if (p_tbl->cfg_flags & AVDT_L2C_CFG_IND_DONE) {
avdt_ad_tc_open_ind(p_tbl);
}
}
/* else failure */
- else
- {
+ else {
/* Send L2CAP disconnect req */
L2CA_DisconnectReq(lcid);
}
tAVDT_TC_TBL *p_tbl;
/* look up info for this channel */
- if ((p_tbl = avdt_ad_tc_tbl_by_lcid(lcid)) != NULL)
- {
+ if ((p_tbl = avdt_ad_tc_tbl_by_lcid(lcid)) != NULL) {
/* store the mtu in tbl */
- if (p_cfg->mtu_present)
- {
+ if (p_cfg->mtu_present) {
p_tbl->peer_mtu = p_cfg->mtu;
- }
- else
- {
+ } else {
p_tbl->peer_mtu = L2CAP_DEFAULT_MTU;
}
- AVDT_TRACE_DEBUG("peer_mtu: %d, lcid: x%x\n",p_tbl->peer_mtu, lcid);
+ AVDT_TRACE_DEBUG("peer_mtu: %d, lcid: x%x\n", p_tbl->peer_mtu, lcid);
/* send L2CAP configure response */
memset(p_cfg, 0, sizeof(tL2CAP_CFG_INFO));
L2CA_ConfigRsp(lcid, p_cfg);
/* if first config ind */
- if ((p_tbl->cfg_flags & AVDT_L2C_CFG_IND_DONE) == 0)
- {
+ if ((p_tbl->cfg_flags & AVDT_L2C_CFG_IND_DONE) == 0) {
/* update cfg_flags */
p_tbl->cfg_flags |= AVDT_L2C_CFG_IND_DONE;
/* if configuration complete */
- if (p_tbl->cfg_flags & AVDT_L2C_CFG_CFM_DONE)
- {
+ if (p_tbl->cfg_flags & AVDT_L2C_CFG_CFM_DONE) {
avdt_ad_tc_open_ind(p_tbl);
}
}
tAVDT_TC_TBL *p_tbl;
UINT16 disc_rsn = AVDT_DISC_RSN_NORMAL;
AVDT_TRACE_DEBUG("avdt_l2c_disconnect_ind_cback lcid: %d, ack_needed: %d\n",
- lcid, ack_needed);
+ lcid, ack_needed);
/* look up info for this channel */
- if ((p_tbl = avdt_ad_tc_tbl_by_lcid(lcid)) != NULL)
- {
- if (ack_needed)
- {
+ if ((p_tbl = avdt_ad_tc_tbl_by_lcid(lcid)) != NULL) {
+ if (ack_needed) {
/* send L2CAP disconnect response */
L2CA_DisconnectRsp(lcid);
} else {
tAVDT_TC_TBL *p_tbl;
AVDT_TRACE_DEBUG("avdt_l2c_disconnect_cfm_cback lcid: %d, result: %d\n",
- lcid, result);
+ lcid, result);
/* look up info for this channel */
- if ((p_tbl = avdt_ad_tc_tbl_by_lcid(lcid)) != NULL)
- {
+ if ((p_tbl = avdt_ad_tc_tbl_by_lcid(lcid)) != NULL) {
avdt_ad_tc_close_ind(p_tbl, result);
}
}
tAVDT_TC_TBL *p_tbl;
/* look up info for this channel */
- if ((p_tbl = avdt_ad_tc_tbl_by_lcid(lcid)) != NULL)
- {
+ if ((p_tbl = avdt_ad_tc_tbl_by_lcid(lcid)) != NULL) {
avdt_ad_tc_cong_ind(p_tbl, is_congested);
}
}
tAVDT_TC_TBL *p_tbl;
/* look up info for this channel */
- if ((p_tbl = avdt_ad_tc_tbl_by_lcid(lcid)) != NULL)
- {
+ if ((p_tbl = avdt_ad_tc_tbl_by_lcid(lcid)) != NULL) {
avdt_ad_tc_data_ind(p_tbl, p_buf);
- }
- else /* prevent buffer leak */
+ } else { /* prevent buffer leak */
GKI_freebuf(p_buf);
+ }
}
#endif /* #if (defined(AVDT_INCLUDED) && AVDT_INCLUDED == TRUE) */
/* for now, just build media transport, codec, and content protection, and multiplexing */
/* media transport */
- if (p_cfg->psc_mask & AVDT_PSC_TRANS)
- {
+ if (p_cfg->psc_mask & AVDT_PSC_TRANS) {
*(*p)++ = AVDT_CAT_TRANS;
*(*p)++ = 0; /* length */
}
#if AVDT_REPORTING == TRUE
/* reporting transport */
- if (p_cfg->psc_mask & AVDT_PSC_REPORT)
- {
+ if (p_cfg->psc_mask & AVDT_PSC_REPORT) {
*(*p)++ = AVDT_CAT_REPORT;
*(*p)++ = 0; /* length */
}
#endif
/* codec */
- if (p_cfg->num_codec != 0)
- {
+ if (p_cfg->num_codec != 0) {
*(*p)++ = AVDT_CAT_CODEC;
len = p_cfg->codec_info[0] + 1;
- if( len > AVDT_CODEC_SIZE )
+ if ( len > AVDT_CODEC_SIZE ) {
len = AVDT_CODEC_SIZE;
+ }
memcpy(*p, p_cfg->codec_info, len);
*p += len;
}
/* content protection */
- if (p_cfg->num_protect != 0)
- {
+ if (p_cfg->num_protect != 0) {
*(*p)++ = AVDT_CAT_PROTECT;
len = p_cfg->protect_info[0] + 1;
- if( len > AVDT_PROTECT_SIZE )
+ if ( len > AVDT_PROTECT_SIZE ) {
len = AVDT_PROTECT_SIZE;
+ }
memcpy(*p, p_cfg->protect_info, len);
*p += len;
#if AVDT_MULTIPLEXING == TRUE
/* multiplexing */
- if (p_cfg->psc_mask & AVDT_PSC_MUX)
- {
+ if (p_cfg->psc_mask & AVDT_PSC_MUX) {
*(*p)++ = AVDT_CAT_MUX;
/* length */
- if (p_cfg->psc_mask & AVDT_PSC_RECOV)
- *(*p)++ = 7; /* frag (1) + media + report + recovery */
- else if (p_cfg->psc_mask & AVDT_PSC_REPORT)
- *(*p)++ = 5; /* frag (1) + media + report */
- else
- *(*p)++ = 3; /* frag (1) + media */
+ if (p_cfg->psc_mask & AVDT_PSC_RECOV) {
+ *(*p)++ = 7; /* frag (1) + media + report + recovery */
+ } else if (p_cfg->psc_mask & AVDT_PSC_REPORT) {
+ *(*p)++ = 5; /* frag (1) + media + report */
+ } else {
+ *(*p)++ = 3; /* frag (1) + media */
+ }
/* allow fragmentation */
- if(p_cfg->mux_mask & AVDT_MUX_FRAG)
+ if (p_cfg->mux_mask & AVDT_MUX_FRAG) {
*(*p)++ = 0x80;
- else
+ } else {
*(*p)++ = 0;
+ }
/* media transport session */
- *(*p)++ = p_cfg->mux_tsid_media<<3; /* TSID */
- *(*p)++ = p_cfg->mux_tcid_media<<3; /* TCID */
+ *(*p)++ = p_cfg->mux_tsid_media << 3; /* TSID */
+ *(*p)++ = p_cfg->mux_tcid_media << 3; /* TCID */
- if (p_cfg->psc_mask & AVDT_PSC_RECOV)
- {
+ if (p_cfg->psc_mask & AVDT_PSC_RECOV) {
/* reporting transport session */
- *(*p)++ = p_cfg->mux_tsid_report<<3; /* TSID */
- *(*p)++ = p_cfg->mux_tcid_report<<3; /* TCID */
+ *(*p)++ = p_cfg->mux_tsid_report << 3; /* TSID */
+ *(*p)++ = p_cfg->mux_tcid_report << 3; /* TCID */
/* recovery transport session */
- *(*p)++ = p_cfg->mux_tsid_recov<<3; /* TSID */
- *(*p)++ = p_cfg->mux_tcid_recov<<3; /* TCID */
- }
- else if (p_cfg->psc_mask & AVDT_PSC_REPORT)
- {
+ *(*p)++ = p_cfg->mux_tsid_recov << 3; /* TSID */
+ *(*p)++ = p_cfg->mux_tcid_recov << 3; /* TCID */
+ } else if (p_cfg->psc_mask & AVDT_PSC_REPORT) {
/* reporting transport session */
- *(*p)++ = p_cfg->mux_tsid_report<<3; /* TSID */
- *(*p)++ = p_cfg->mux_tcid_report<<3; /* TCID */
+ *(*p)++ = p_cfg->mux_tsid_report << 3; /* TSID */
+ *(*p)++ = p_cfg->mux_tcid_report << 3; /* TCID */
}
}
#endif
/* delay report */
- if (p_cfg->psc_mask & AVDT_PSC_DELAY_RPT)
- {
+ if (p_cfg->psc_mask & AVDT_PSC_DELAY_RPT) {
*(*p)++ = AVDT_CAT_DELAY_RPT;
*(*p)++ = 0; /* length */
}
{
int i;
- for (i = 0; i < p_msg->multi.num_seps; i++)
- {
+ for (i = 0; i < p_msg->multi.num_seps; i++) {
AVDT_MSG_BLD_SEID(*p, p_msg->multi.seid_list[i]);
}
}
{
int i;
- for (i = 0; i < p_msg->discover_rsp.num_seps; i++)
- {
+ for (i = 0; i < p_msg->discover_rsp.num_seps; i++) {
/* build discover rsp info */
AVDT_MSG_BLD_DISC(*p, p_msg->discover_rsp.p_sep_info[i].seid,
- p_msg->discover_rsp.p_sep_info[i].in_use,
- p_msg->discover_rsp.p_sep_info[i].media_type,
- p_msg->discover_rsp.p_sep_info[i].tsep);
+ p_msg->discover_rsp.p_sep_info[i].in_use,
+ p_msg->discover_rsp.p_sep_info[i].media_type,
+ p_msg->discover_rsp.p_sep_info[i].tsep);
}
}
** in p_elem.
**
*******************************************************************************/
-static UINT8 avdt_msg_prs_cfg(tAVDT_CFG *p_cfg, UINT8 *p, UINT16 len, UINT8* p_elem, UINT8 sig_id)
+static UINT8 avdt_msg_prs_cfg(tAVDT_CFG *p_cfg, UINT8 *p, UINT16 len, UINT8 *p_elem, UINT8 sig_id)
{
UINT8 *p_end;
UINT8 elem = 0;
UINT8 err = 0;
UINT8 protect_offset = 0;
- if (!p_cfg)
- {
+ if (!p_cfg) {
AVDT_TRACE_ERROR ("not expecting this cfg");
return AVDT_ERR_BAD_STATE;
}
/* while there is still data to parse */
p_end = p + len;
- while ((p < p_end) && (err == 0))
- {
+ while ((p < p_end) && (err == 0)) {
/* verify overall length */
- if ((p_end - p) < AVDT_LEN_CFG_MIN)
- {
+ if ((p_end - p) < AVDT_LEN_CFG_MIN) {
err = AVDT_ERR_PAYLOAD;
break;
}
elem = *p++;
elem_len = *p++;
- if ((elem == 0) || (elem > AVDT_CAT_MAX_CUR))
- {
+ if ((elem == 0) || (elem > AVDT_CAT_MAX_CUR)) {
/* this may not be really bad.
* It may be a service category that is too new for us.
* allow these to be parsed without reporting an error.
* If this is a "capability" (as in GetCapRsp & GetConfigRsp), this is filtered out.
* If this is a Configuration (as in SetConfigCmd & ReconfigCmd),
* this will be marked as an error in the caller of this function */
- if ((sig_id == AVDT_SIG_SETCONFIG) || (sig_id == AVDT_SIG_RECONFIG))
- {
+ if ((sig_id == AVDT_SIG_SETCONFIG) || (sig_id == AVDT_SIG_RECONFIG)) {
/* Cannot accept unknown category. */
err = AVDT_ERR_CATEGORY;
break;
- }
- else /* GETCAP or GET_ALLCAP */
- {
+ } else { /* GETCAP or GET_ALLCAP */
/* Skip unknown categories. */
p += elem_len;
AVDT_TRACE_DEBUG("skipping unknown service category=%d len: %d\n", elem, elem_len);
}
if ((elem_len > avdt_msg_ie_len_max[elem]) ||
- (elem_len < avdt_msg_ie_len_min[elem]))
- {
+ (elem_len < avdt_msg_ie_len_min[elem])) {
err = avdt_msg_ie_err[elem];
break;
}
AVDT_TRACE_DEBUG("elem=%d elem_len: %d psc_mask=0x%x\n", elem, elem_len, p_cfg->psc_mask);
/* parse individual information elements with additional parameters */
- switch (elem)
- {
- case AVDT_CAT_RECOV:
- p_cfg->recov_type = *p++;
- p_cfg->recov_mrws = *p++;
- p_cfg->recov_mnmp = *p++;
- if (p_cfg->recov_type != AVDT_RECOV_RFC2733)
- {
- err = AVDT_ERR_RECOV_TYPE;
- }
- else if ((p_cfg->recov_mrws < AVDT_RECOV_MRWS_MIN) ||
- (p_cfg->recov_mrws > AVDT_RECOV_MRWS_MAX) ||
- (p_cfg->recov_mnmp < AVDT_RECOV_MNMP_MIN) ||
- (p_cfg->recov_mnmp > AVDT_RECOV_MNMP_MAX))
- {
- err = AVDT_ERR_RECOV_FMT;
- }
- break;
+ switch (elem) {
+ case AVDT_CAT_RECOV:
+ p_cfg->recov_type = *p++;
+ p_cfg->recov_mrws = *p++;
+ p_cfg->recov_mnmp = *p++;
+ if (p_cfg->recov_type != AVDT_RECOV_RFC2733) {
+ err = AVDT_ERR_RECOV_TYPE;
+ } else if ((p_cfg->recov_mrws < AVDT_RECOV_MRWS_MIN) ||
+ (p_cfg->recov_mrws > AVDT_RECOV_MRWS_MAX) ||
+ (p_cfg->recov_mnmp < AVDT_RECOV_MNMP_MIN) ||
+ (p_cfg->recov_mnmp > AVDT_RECOV_MNMP_MAX)) {
+ err = AVDT_ERR_RECOV_FMT;
+ }
+ break;
- case AVDT_CAT_PROTECT:
- p_cfg->psc_mask &= ~AVDT_PSC_PROTECT;
- if ((elem_len + protect_offset) < AVDT_PROTECT_SIZE)
- {
- p_cfg->num_protect++;
- p_cfg->protect_info[protect_offset] = elem_len;
- protect_offset++;
- memcpy(&p_cfg->protect_info[protect_offset], p, elem_len);
- protect_offset += elem_len;
- }
- p += elem_len;
- break;
+ case AVDT_CAT_PROTECT:
+ p_cfg->psc_mask &= ~AVDT_PSC_PROTECT;
+ if ((elem_len + protect_offset) < AVDT_PROTECT_SIZE) {
+ p_cfg->num_protect++;
+ p_cfg->protect_info[protect_offset] = elem_len;
+ protect_offset++;
+ memcpy(&p_cfg->protect_info[protect_offset], p, elem_len);
+ protect_offset += elem_len;
+ }
+ p += elem_len;
+ break;
- case AVDT_CAT_HDRCMP:
- p_cfg->hdrcmp_mask = *p++;
- break;
+ case AVDT_CAT_HDRCMP:
+ p_cfg->hdrcmp_mask = *p++;
+ break;
#if AVDT_MULTIPLEXING == TRUE
- case AVDT_CAT_MUX:
- /* verify length */
- AVDT_TRACE_WARNING("psc_mask=0x%x elem_len=%d\n", p_cfg->psc_mask, elem_len);
- if( ((0 == (p_cfg->psc_mask & (AVDT_PSC_RECOV|AVDT_PSC_REPORT))) && (elem_len != 3))
+ case AVDT_CAT_MUX:
+ /* verify length */
+ AVDT_TRACE_WARNING("psc_mask=0x%x elem_len=%d\n", p_cfg->psc_mask, elem_len);
+ if ( ((0 == (p_cfg->psc_mask & (AVDT_PSC_RECOV | AVDT_PSC_REPORT))) && (elem_len != 3))
|| (((p_cfg->psc_mask & AVDT_PSC_REPORT) && !(p_cfg->psc_mask & AVDT_PSC_RECOV))
- && (elem_len != 5))
+ && (elem_len != 5))
|| ((!(p_cfg->psc_mask & AVDT_PSC_REPORT) && (p_cfg->psc_mask & AVDT_PSC_RECOV))
- && (elem_len != 5))
+ && (elem_len != 5))
|| (((p_cfg->psc_mask & AVDT_PSC_REPORT) && (p_cfg->psc_mask & AVDT_PSC_RECOV))
- && (elem_len != 7)) )
- {
- err = AVDT_ERR_MUX_FMT;
- break;
- }
+ && (elem_len != 7)) ) {
+ err = AVDT_ERR_MUX_FMT;
+ break;
+ }
+
+ /* parse fragmentation */
+ p_cfg->mux_mask = *p++ & (UINT8)AVDT_MUX_FRAG;
- /* parse fragmentation */
- p_cfg->mux_mask = *p++ & (UINT8)AVDT_MUX_FRAG;
-
- /* parse TSIDs and TCIDs */
- if(--elem_len)
- p_cfg->mux_tsid_media = (*p++)>>3;
- else
- break;
-
- if(--elem_len)
- p_cfg->mux_tcid_media = (*p++)>>3;
- else
- break;
-
- if(--elem_len)
- p_cfg->mux_tsid_report = (*p++)>>3;
- else
- break;
-
- if(--elem_len)
- p_cfg->mux_tcid_report = (*p++)>>3;
- else
- break;
-
- if(--elem_len)
- p_cfg->mux_tsid_recov = (*p++)>>3;
- else
- break;
-
- if(--elem_len)
- p_cfg->mux_tcid_recov = (*p++)>>3;
- else
- break;
+ /* parse TSIDs and TCIDs */
+ if (--elem_len) {
+ p_cfg->mux_tsid_media = (*p++) >> 3;
+ } else {
break;
-#endif
+ }
- case AVDT_CAT_CODEC:
- p_cfg->psc_mask &= ~AVDT_PSC_CODEC;
- tmp = elem_len;
- if (elem_len >= AVDT_CODEC_SIZE)
- {
- tmp = AVDT_CODEC_SIZE - 1;
- }
- p_cfg->num_codec++;
- p_cfg->codec_info[0] = elem_len;
- memcpy(&p_cfg->codec_info[1], p, tmp);
- p += elem_len;
+ if (--elem_len) {
+ p_cfg->mux_tcid_media = (*p++) >> 3;
+ } else {
+ break;
+ }
+
+ if (--elem_len) {
+ p_cfg->mux_tsid_report = (*p++) >> 3;
+ } else {
break;
+ }
- case AVDT_CAT_DELAY_RPT:
+ if (--elem_len) {
+ p_cfg->mux_tcid_report = (*p++) >> 3;
+ } else {
break;
+ }
- default:
- p += elem_len;
+ if (--elem_len) {
+ p_cfg->mux_tsid_recov = (*p++) >> 3;
+ } else {
break;
+ }
+
+ if (--elem_len) {
+ p_cfg->mux_tcid_recov = (*p++) >> 3;
+ } else {
+ break;
+ }
+ break;
+#endif
+
+ case AVDT_CAT_CODEC:
+ p_cfg->psc_mask &= ~AVDT_PSC_CODEC;
+ tmp = elem_len;
+ if (elem_len >= AVDT_CODEC_SIZE) {
+ tmp = AVDT_CODEC_SIZE - 1;
+ }
+ p_cfg->num_codec++;
+ p_cfg->codec_info[0] = elem_len;
+ memcpy(&p_cfg->codec_info[1], p, tmp);
+ p += elem_len;
+ break;
+
+ case AVDT_CAT_DELAY_RPT:
+ break;
+
+ default:
+ p += elem_len;
+ break;
} /* switch */
} /* while ! err, !end*/
*p_elem = elem;
UINT8 err = 0;
/* verify len */
- if (len != AVDT_LEN_SINGLE)
- {
+ if (len != AVDT_LEN_SINGLE) {
err = AVDT_ERR_LENGTH;
- }
- else
- {
+ } else {
AVDT_MSG_PRS_SEID(p, p_msg->single.seid);
- if (avdt_scb_by_hdl(p_msg->single.seid) == NULL)
- {
+ if (avdt_scb_by_hdl(p_msg->single.seid) == NULL) {
err = AVDT_ERR_SEID;
}
}
p_msg->hdr.err_param = 0;
/* verify len */
- if (len < AVDT_LEN_SETCONFIG_MIN)
- {
+ if (len < AVDT_LEN_SETCONFIG_MIN) {
err = AVDT_ERR_LENGTH;
- }
- else
- {
+ } else {
/* get seids */
AVDT_MSG_PRS_SEID(p, p_msg->config_cmd.hdr.seid);
- if (avdt_scb_by_hdl(p_msg->config_cmd.hdr.seid) == NULL)
- {
+ if (avdt_scb_by_hdl(p_msg->config_cmd.hdr.seid) == NULL) {
err = AVDT_ERR_SEID;
}
AVDT_MSG_PRS_SEID(p, p_msg->config_cmd.int_seid);
if ((p_msg->config_cmd.int_seid < AVDT_SEID_MIN) ||
- (p_msg->config_cmd.int_seid > AVDT_SEID_MAX))
- {
+ (p_msg->config_cmd.int_seid > AVDT_SEID_MAX)) {
err = AVDT_ERR_SEID;
}
}
- if (!err)
- {
+ if (!err) {
/* parse configuration parameters */
len -= 2;
err = avdt_msg_prs_cfg(p_msg->config_cmd.p_cfg, p, len, &p_msg->hdr.err_param, AVDT_SIG_SETCONFIG);
- if (!err)
- {
+ if (!err) {
/* verify protocol service capabilities are supported */
if (((p_msg->config_cmd.p_cfg->psc_mask & (~AVDT_PSC)) != 0) ||
- (p_msg->config_cmd.p_cfg->num_codec == 0))
- {
+ (p_msg->config_cmd.p_cfg->num_codec == 0)) {
err = AVDT_ERR_INVALID_CAP;
}
}
p_msg->hdr.err_param = 0;
/* verify len */
- if (len < AVDT_LEN_RECONFIG_MIN)
- {
+ if (len < AVDT_LEN_RECONFIG_MIN) {
err = AVDT_ERR_LENGTH;
- }
- else
- {
+ } else {
/* get seid */
AVDT_MSG_PRS_SEID(p, p_msg->reconfig_cmd.hdr.seid);
- if (avdt_scb_by_hdl(p_msg->reconfig_cmd.hdr.seid) == NULL)
- {
+ if (avdt_scb_by_hdl(p_msg->reconfig_cmd.hdr.seid) == NULL) {
err = AVDT_ERR_SEID;
- }
- else
- {
+ } else {
/* parse config parameters */
len--;
err = avdt_msg_prs_cfg(p_msg->config_cmd.p_cfg, p, len, &p_msg->hdr.err_param, AVDT_SIG_RECONFIG);
/* verify no protocol service capabilities in parameters */
- if (!err)
- {
+ if (!err) {
AVDT_TRACE_DEBUG("avdt_msg_prs_reconfig_cmd psc_mask=0x%x/0x%x\n", p_msg->config_cmd.p_cfg->psc_mask, AVDT_MSG_PSC_MASK);
if ((p_msg->config_cmd.p_cfg->psc_mask != 0) ||
- (p_msg->config_cmd.p_cfg->num_codec == 0 && p_msg->config_cmd.p_cfg->num_protect == 0))
- {
+ (p_msg->config_cmd.p_cfg->num_codec == 0 && p_msg->config_cmd.p_cfg->num_protect == 0)) {
err = AVDT_ERR_INVALID_CAP;
}
}
p_msg->hdr.err_param = 0;
/* verify len */
- if (len < AVDT_LEN_MULTI_MIN || (len > AVDT_NUM_SEPS))
- {
+ if (len < AVDT_LEN_MULTI_MIN || (len > AVDT_NUM_SEPS)) {
err = AVDT_ERR_LENGTH;
- }
- else
- {
+ } else {
/* get and verify all seps */
- for (i = 0; i < len; i++)
- {
+ for (i = 0; i < len; i++) {
AVDT_MSG_PRS_SEID(p, p_msg->multi.seid_list[i]);
- if (avdt_scb_by_hdl(p_msg->multi.seid_list[i]) == NULL)
- {
+ if (avdt_scb_by_hdl(p_msg->multi.seid_list[i]) == NULL) {
err = AVDT_ERR_SEID;
p_msg->hdr.err_param = p_msg->multi.seid_list[i];
break;
UINT8 err = 0;
/* verify len */
- if (len < AVDT_LEN_SECURITY_MIN)
- {
+ if (len < AVDT_LEN_SECURITY_MIN) {
err = AVDT_ERR_LENGTH;
- }
- else
- {
+ } else {
/* get seid */
AVDT_MSG_PRS_SEID(p, p_msg->security_cmd.hdr.seid);
- if (avdt_scb_by_hdl(p_msg->security_cmd.hdr.seid) == NULL)
- {
+ if (avdt_scb_by_hdl(p_msg->security_cmd.hdr.seid) == NULL) {
err = AVDT_ERR_SEID;
- }
- else
- {
+ } else {
p_msg->security_cmd.p_data = p;
p_msg->security_cmd.len = len - 1;
}
/* determine number of seps; seps in msg is len/2, but set to minimum
** of seps app has supplied memory for and seps in msg
*/
- if (p_msg->discover_rsp.num_seps > (len / 2))
- {
+ if (p_msg->discover_rsp.num_seps > (len / 2)) {
p_msg->discover_rsp.num_seps = (len / 2);
}
/* parse out sep info */
- for (i = 0; i < p_msg->discover_rsp.num_seps; i++)
- {
+ for (i = 0; i < p_msg->discover_rsp.num_seps; i++) {
/* parse discover rsp info */
AVDT_MSG_PRS_DISC(p, p_msg->discover_rsp.p_sep_info[i].seid,
p_msg->discover_rsp.p_sep_info[i].in_use,
/* verify that seid is valid */
if ((p_msg->discover_rsp.p_sep_info[i].seid < AVDT_SEID_MIN) ||
- (p_msg->discover_rsp.p_sep_info[i].seid > AVDT_SEID_MAX))
- {
+ (p_msg->discover_rsp.p_sep_info[i].seid > AVDT_SEID_MAX)) {
err = AVDT_ERR_SEID;
break;
}
{
/* parse parameters */
UINT8 err = avdt_msg_prs_cfg(p_msg->svccap.p_cfg, p, len, &p_msg->hdr.err_param, AVDT_SIG_GETCAP);
- if (p_msg->svccap.p_cfg)
- {
+ if (p_msg->svccap.p_cfg) {
p_msg->svccap.p_cfg->psc_mask &= AVDT_LEG_PSC;
}
static UINT8 avdt_msg_prs_all_svccap(tAVDT_MSG *p_msg, UINT8 *p, UINT16 len)
{
UINT8 err = avdt_msg_prs_cfg(p_msg->svccap.p_cfg, p, len, &p_msg->hdr.err_param, AVDT_SIG_GET_ALLCAP);
- if (p_msg->svccap.p_cfg)
- {
+ if (p_msg->svccap.p_cfg) {
p_msg->svccap.p_cfg->psc_mask &= AVDT_MSG_PSC_MASK;
}
return (err);
*******************************************************************************/
static UINT8 avdt_msg_prs_rej(tAVDT_MSG *p_msg, UINT8 *p, UINT8 sig)
{
- if ((sig == AVDT_SIG_SETCONFIG) || (sig == AVDT_SIG_RECONFIG))
- {
+ if ((sig == AVDT_SIG_SETCONFIG) || (sig == AVDT_SIG_RECONFIG)) {
p_msg->hdr.err_param = *p++;
p_msg->hdr.err_code = *p;
- }
- else if ((sig == AVDT_SIG_START) || (sig == AVDT_SIG_SUSPEND))
- {
+ } else if ((sig == AVDT_SIG_START) || (sig == AVDT_SIG_SUSPEND)) {
AVDT_MSG_PRS_SEID(p, p_msg->hdr.err_param);
p_msg->hdr.err_code = *p;
- }
- else
- {
+ } else {
p_msg->hdr.err_code = *p;
}
UINT8 err = 0;
/* verify len */
- if (len != AVDT_LEN_DELAY_RPT)
- {
+ if (len != AVDT_LEN_DELAY_RPT) {
AVDT_TRACE_WARNING("avdt_msg_prs_delay_rpt expected len: %u got: %u\n", AVDT_LEN_DELAY_RPT, len);
err = AVDT_ERR_LENGTH;
- }
- else
- {
+ } else {
/* get seid */
AVDT_MSG_PRS_SEID (p, p_msg->delay_rpt_cmd.hdr.seid);
- if (avdt_scb_by_hdl(p_msg->delay_rpt_cmd.hdr.seid) == NULL)
- {
+ if (avdt_scb_by_hdl(p_msg->delay_rpt_cmd.hdr.seid) == NULL) {
err = AVDT_ERR_SEID;
- }
- else
- {
+ } else {
BE_STREAM_TO_UINT16 (p_msg->delay_rpt_cmd.delay, p);
AVDT_TRACE_DEBUG("avdt_msg_prs_delay_rpt delay: %u\n", p_msg->delay_rpt_cmd.delay);
}
p_tbl = avdt_ad_tc_tbl_by_type(AVDT_CHAN_SIG, p_ccb, NULL);
/* set the current message if there is a message passed in */
- if (p_msg != NULL)
- {
+ if (p_msg != NULL) {
p_ccb->p_curr_msg = p_msg;
}
curr_msg_len = p_ccb->p_curr_msg->len;
/* while not congested and we haven't sent it all */
- while ((!p_ccb->cong) && (p_ccb->p_curr_msg != NULL))
- {
+ while ((!p_ccb->cong) && (p_ccb->p_curr_msg != NULL)) {
/* check what kind of message we've got here; we are using the offset
** to indicate that a message is being fragmented
*/
/* if message isn't being fragmented and it fits in mtu */
if ((p_ccb->p_curr_msg->offset == AVDT_MSG_OFFSET) &&
- (p_ccb->p_curr_msg->len <= p_tbl->peer_mtu - AVDT_LEN_TYPE_SINGLE))
- {
+ (p_ccb->p_curr_msg->len <= p_tbl->peer_mtu - AVDT_LEN_TYPE_SINGLE)) {
pkt_type = AVDT_PKT_TYPE_SINGLE;
hdr_len = AVDT_LEN_TYPE_SINGLE;
p_buf = p_ccb->p_curr_msg;
}
/* if message isn't being fragmented and it doesn't fit in mtu */
else if ((p_ccb->p_curr_msg->offset == AVDT_MSG_OFFSET) &&
- (p_ccb->p_curr_msg->len > p_tbl->peer_mtu - AVDT_LEN_TYPE_SINGLE))
- {
+ (p_ccb->p_curr_msg->len > p_tbl->peer_mtu - AVDT_LEN_TYPE_SINGLE)) {
pkt_type = AVDT_PKT_TYPE_START;
hdr_len = AVDT_LEN_TYPE_START;
nosp = (p_ccb->p_curr_msg->len + AVDT_LEN_TYPE_START - p_tbl->peer_mtu) /
(p_tbl->peer_mtu - 1) + 2;
/* get a new buffer for fragment we are sending */
- if ((p_buf = (BT_HDR *) GKI_getpoolbuf(AVDT_CMD_POOL_ID)) == NULL)
- {
+ if ((p_buf = (BT_HDR *) GKI_getpoolbuf(AVDT_CMD_POOL_ID)) == NULL) {
/* do we even want to try and recover from this? could do so
by setting retransmission timer */
return TRUE;
}
/* if message is being fragmented and remaining bytes don't fit in mtu */
else if ((p_ccb->p_curr_msg->offset > AVDT_MSG_OFFSET) &&
- (p_ccb->p_curr_msg->len > (p_tbl->peer_mtu - AVDT_LEN_TYPE_CONT)))
- {
+ (p_ccb->p_curr_msg->len > (p_tbl->peer_mtu - AVDT_LEN_TYPE_CONT))) {
pkt_type = AVDT_PKT_TYPE_CONT;
hdr_len = AVDT_LEN_TYPE_CONT;
/* get a new buffer for fragment we are sending */
- if ((p_buf = (BT_HDR *) GKI_getpoolbuf(AVDT_CMD_POOL_ID)) == NULL)
- {
+ if ((p_buf = (BT_HDR *) GKI_getpoolbuf(AVDT_CMD_POOL_ID)) == NULL) {
/* do we even want to try and recover from this? could do so
by setting retransmission timer */
return TRUE;
(UINT8 *)(p_ccb->p_curr_msg + 1) + p_ccb->p_curr_msg->offset, p_buf->len);
}
/* if message is being fragmented and remaining bytes do fit in mtu */
- else
- {
+ else {
pkt_type = AVDT_PKT_TYPE_END;
hdr_len = AVDT_LEN_TYPE_END;
p_buf = p_ccb->p_curr_msg;
/* keep track of how much of msg we've sent */
curr_msg_len -= p_buf->len;
- if (curr_msg_len == 0)
- {
+ if (curr_msg_len == 0) {
/* entire message sent; mark as finished */
p_ccb->p_curr_msg = NULL;
/* start timer here for commands */
- if (msg == AVDT_MSG_TYPE_CMD)
- {
+ if (msg == AVDT_MSG_TYPE_CMD) {
/* if retransmit timeout set to zero, sig doesn't use retransmit */
if ((sig == AVDT_SIG_DISCOVER) || (sig == AVDT_SIG_GETCAP) ||
- (sig == AVDT_SIG_SECURITY) || (avdt_cb.rcb.ret_tout == 0))
- {
+ (sig == AVDT_SIG_SECURITY) || (avdt_cb.rcb.ret_tout == 0)) {
btu_start_timer(&p_ccb->timer_entry, BTU_TTYPE_AVDT_CCB_RSP, avdt_cb.rcb.sig_tout);
- }
- else if (sig != AVDT_SIG_DELAY_RPT)
- {
+ } else if (sig != AVDT_SIG_DELAY_RPT) {
btu_start_timer(&p_ccb->timer_entry, BTU_TTYPE_AVDT_CCB_RET, avdt_cb.rcb.ret_tout);
}
}
- }
- else
- {
+ } else {
/* message being fragmented and not completely sent */
p_ccb->p_curr_msg->len -= p_buf->len;
p_ccb->p_curr_msg->offset += p_buf->len;
/* build header */
AVDT_MSG_BLD_HDR(p, label, pkt_type, msg);
- if (pkt_type == AVDT_PKT_TYPE_START)
- {
+ if (pkt_type == AVDT_PKT_TYPE_START) {
AVDT_MSG_BLD_NOSP(p, nosp);
}
- if ((pkt_type == AVDT_PKT_TYPE_START) || (pkt_type == AVDT_PKT_TYPE_SINGLE))
- {
+ if ((pkt_type == AVDT_PKT_TYPE_START) || (pkt_type == AVDT_PKT_TYPE_SINGLE)) {
AVDT_MSG_BLD_SIG(p, sig);
}
AVDT_MSG_PRS_PKT_TYPE(p, pkt_type);
/* quick sanity check on length */
- if (p_buf->len < avdt_msg_pkt_type_len[pkt_type])
- {
+ if (p_buf->len < avdt_msg_pkt_type_len[pkt_type]) {
GKI_freebuf(p_buf);
AVDT_TRACE_WARNING("Bad length during reassembly");
p_ret = NULL;
}
/* single packet */
- else if (pkt_type == AVDT_PKT_TYPE_SINGLE)
- {
+ else if (pkt_type == AVDT_PKT_TYPE_SINGLE) {
/* if reassembly in progress drop message and process new single */
- if (p_ccb->p_rx_msg != NULL)
- {
+ if (p_ccb->p_rx_msg != NULL) {
GKI_freebuf(p_ccb->p_rx_msg);
p_ccb->p_rx_msg = NULL;
AVDT_TRACE_WARNING("Got single during reassembly");
p_ret = p_buf;
}
/* start packet */
- else if (pkt_type == AVDT_PKT_TYPE_START)
- {
+ else if (pkt_type == AVDT_PKT_TYPE_START) {
/* if reassembly in progress drop message and process new single */
- if (p_ccb->p_rx_msg != NULL)
- {
+ if (p_ccb->p_rx_msg != NULL) {
GKI_freebuf(p_ccb->p_rx_msg);
AVDT_TRACE_WARNING("Got start during reassembly");
}
p_ret = NULL;
}
/* continue or end */
- else
- {
+ else {
/* if no reassembly in progress drop message */
- if (p_ccb->p_rx_msg == NULL)
- {
+ if (p_ccb->p_rx_msg == NULL) {
GKI_freebuf(p_buf);
AVDT_TRACE_WARNING("Pkt type=%d out of order\n", pkt_type);
p_ret = NULL;
- }
- else
- {
+ } else {
/* get size of buffer holding assembled message */
buf_len = GKI_get_buf_size(p_ccb->p_rx_msg) - sizeof(BT_HDR);
p_buf->len -= AVDT_LEN_TYPE_CONT;
/* verify length */
- if ((p_ccb->p_rx_msg->offset + p_buf->len) > buf_len)
- {
+ if ((p_ccb->p_rx_msg->offset + p_buf->len) > buf_len) {
/* won't fit; free everything */
GKI_freebuf(p_ccb->p_rx_msg);
p_ccb->p_rx_msg = NULL;
GKI_freebuf(p_buf);
p_ret = NULL;
- }
- else
- {
+ } else {
/* copy contents of p_buf to p_rx_msg */
memcpy((UINT8 *)(p_ccb->p_rx_msg + 1) + p_ccb->p_rx_msg->offset,
(UINT8 *)(p_buf + 1) + p_buf->offset, p_buf->len);
- if (pkt_type == AVDT_PKT_TYPE_END)
- {
+ if (pkt_type == AVDT_PKT_TYPE_END) {
p_ccb->p_rx_msg->offset -= p_ccb->p_rx_msg->len;
p_ccb->p_rx_msg->len += p_buf->len;
p_ret = p_ccb->p_rx_msg;
p_ccb->p_rx_msg = NULL;
- }
- else
- {
+ } else {
p_ccb->p_rx_msg->offset += p_buf->len;
p_ccb->p_rx_msg->len += p_buf->len;
p_ret = NULL;
/* get a buffer */
p_buf = (BT_HDR *) GKI_getpoolbuf(AVDT_CMD_POOL_ID);
- if (p_buf == NULL)
- {
+ if (p_buf == NULL) {
AVDT_TRACE_ERROR("avdt_msg_send_cmd out of buffer!!");
return;
}
p_buf->len = (UINT16) (p - p_start);
/* now store scb hdls, if any, in buf */
- if (p_scb != NULL)
- {
+ if (p_scb != NULL) {
p = (UINT8 *)(p_buf + 1);
/* for start and suspend, p_scb points to array of handles */
- if ((sig_id == AVDT_SIG_START) || (sig_id == AVDT_SIG_SUSPEND))
- {
+ if ((sig_id == AVDT_SIG_START) || (sig_id == AVDT_SIG_SUSPEND)) {
memcpy(p, (UINT8 *) p_scb, p_buf->len);
}
/* for all others, p_scb points to scb as usual */
- else
- {
+ else {
*p = avdt_scb_to_hdl((tAVDT_SCB *) p_scb);
}
}
/* get a buffer */
p_buf = (BT_HDR *) GKI_getpoolbuf(AVDT_CMD_POOL_ID);
- if (p_buf == NULL) return;
+ if (p_buf == NULL) {
+ return;
+ }
/* set up gki buf pointer and offset */
p_buf->offset = AVDT_MSG_OFFSET;
/* get a buffer */
p_buf = (BT_HDR *) GKI_getpoolbuf(AVDT_CMD_POOL_ID);
- if (p_buf == NULL) return;
+ if (p_buf == NULL) {
+ return;
+ }
/* set up gki buf pointer and offset */
p_buf->offset = AVDT_MSG_OFFSET;
p_start = p = (UINT8 *)(p_buf + 1) + p_buf->offset;
/* if sig id included, build into message */
- if (sig_id != AVDT_SIG_NONE)
- {
+ if (sig_id != AVDT_SIG_NONE) {
/* if this sig has a parameter, add the parameter */
if ((sig_id == AVDT_SIG_SETCONFIG) ||
- (sig_id == AVDT_SIG_RECONFIG))
- {
+ (sig_id == AVDT_SIG_RECONFIG)) {
AVDT_MSG_BLD_PARAM(p, p_params->hdr.err_param);
- }
- else if ((sig_id == AVDT_SIG_START) ||
- (sig_id == AVDT_SIG_SUSPEND))
- {
+ } else if ((sig_id == AVDT_SIG_START) ||
+ (sig_id == AVDT_SIG_SUSPEND)) {
AVDT_MSG_BLD_SEID(p, p_params->hdr.err_param);
}
/* get a buffer */
p_buf = (BT_HDR *) GKI_getpoolbuf(AVDT_CMD_POOL_ID);
- if (p_buf == NULL) return;
+ if (p_buf == NULL) {
+ return;
+ }
/* set up gki buf pointer and offset */
p_buf->offset = AVDT_MSG_OFFSET;
UINT8 scb_hdl;
/* reassemble message; if no message available (we received a fragment) return */
- if ((p_buf = avdt_msg_asmbl(p_ccb, p_buf)) == NULL)
- {
+ if ((p_buf = avdt_msg_asmbl(p_ccb, p_buf)) == NULL) {
return;
}
msg.hdr.ccb_idx = avdt_ccb_to_idx(p_ccb);
/* verify msg type */
- if (msg_type == AVDT_MSG_TYPE_GRJ)
- {
+ if (msg_type == AVDT_MSG_TYPE_GRJ) {
AVDT_TRACE_WARNING("Dropping msg msg_type=%d\n", msg_type);
ok = FALSE;
}
/* check for general reject */
- else if ((msg_type == AVDT_MSG_TYPE_REJ) && (p_buf->len == AVDT_LEN_GEN_REJ))
- {
+ else if ((msg_type == AVDT_MSG_TYPE_REJ) && (p_buf->len == AVDT_LEN_GEN_REJ)) {
gen_rej = TRUE;
- if (p_ccb->p_curr_cmd != NULL)
- {
+ if (p_ccb->p_curr_cmd != NULL) {
msg.hdr.sig_id = sig = (UINT8) p_ccb->p_curr_cmd->event;
evt = avdt_msg_rej_2_evt[sig - 1];
msg.hdr.err_code = AVDT_ERR_NSC;
msg.hdr.err_param = 0;
}
- }
- else /* not a general reject */
- {
+ } else { /* not a general reject */
/* get and verify signal */
AVDT_MSG_PRS_SIG(p, sig);
msg.hdr.sig_id = sig;
- if ((sig == 0) || (sig > AVDT_SIG_MAX))
- {
+ if ((sig == 0) || (sig > AVDT_SIG_MAX)) {
AVDT_TRACE_WARNING("Dropping msg sig=%d msg_type:%d\n", sig, msg_type);
ok = FALSE;
/* send a general reject */
- if (msg_type == AVDT_MSG_TYPE_CMD)
- {
+ if (msg_type == AVDT_MSG_TYPE_CMD) {
avdt_msg_send_grej(p_ccb, sig, &msg);
}
}
}
- if (ok && !gen_rej)
- {
+ if (ok && !gen_rej) {
/* skip over header (msg length already verified during reassembly) */
p_buf->len -= AVDT_LEN_TYPE_SINGLE;
/* set up to parse message */
- if ((msg_type == AVDT_MSG_TYPE_RSP) && (sig == AVDT_SIG_DISCOVER))
- {
+ if ((msg_type == AVDT_MSG_TYPE_RSP) && (sig == AVDT_SIG_DISCOVER)) {
/* parse discover rsp message to struct supplied by app */
msg.discover_rsp.p_sep_info = (tAVDT_SEP_INFO *) p_ccb->p_proc_data;
msg.discover_rsp.num_seps = p_ccb->proc_param;
- }
- else if ((msg_type == AVDT_MSG_TYPE_RSP) &&
- ((sig == AVDT_SIG_GETCAP) || (sig == AVDT_SIG_GET_ALLCAP)))
- {
+ } else if ((msg_type == AVDT_MSG_TYPE_RSP) &&
+ ((sig == AVDT_SIG_GETCAP) || (sig == AVDT_SIG_GET_ALLCAP))) {
/* parse discover rsp message to struct supplied by app */
msg.svccap.p_cfg = (tAVDT_CFG *) p_ccb->p_proc_data;
- }
- else if ((msg_type == AVDT_MSG_TYPE_RSP) && (sig == AVDT_SIG_GETCONFIG))
- {
+ } else if ((msg_type == AVDT_MSG_TYPE_RSP) && (sig == AVDT_SIG_GETCONFIG)) {
/* parse get config rsp message to struct allocated locally */
msg.svccap.p_cfg = &cfg;
- }
- else if ((msg_type == AVDT_MSG_TYPE_CMD) && (sig == AVDT_SIG_SETCONFIG))
- {
+ } else if ((msg_type == AVDT_MSG_TYPE_CMD) && (sig == AVDT_SIG_SETCONFIG)) {
/* parse config cmd message to struct allocated locally */
msg.config_cmd.p_cfg = &cfg;
- }
- else if ((msg_type == AVDT_MSG_TYPE_CMD) && (sig == AVDT_SIG_RECONFIG))
- {
+ } else if ((msg_type == AVDT_MSG_TYPE_CMD) && (sig == AVDT_SIG_RECONFIG)) {
/* parse reconfig cmd message to struct allocated locally */
msg.reconfig_cmd.p_cfg = &cfg;
}
/* parse message; while we're at it map message sig to event */
- if (msg_type == AVDT_MSG_TYPE_CMD)
- {
+ if (msg_type == AVDT_MSG_TYPE_CMD) {
msg.hdr.err_code = err = (*avdt_msg_prs_cmd[sig - 1])(&msg, p, p_buf->len);
evt = avdt_msg_cmd_2_evt[sig - 1];
- }
- else if (msg_type == AVDT_MSG_TYPE_RSP)
- {
+ } else if (msg_type == AVDT_MSG_TYPE_RSP) {
msg.hdr.err_code = err = (*avdt_msg_prs_rsp[sig - 1])(&msg, p, p_buf->len);
evt = avdt_msg_rsp_2_evt[sig - 1];
- }
- else /* msg_type == AVDT_MSG_TYPE_REJ */
- {
+ } else { /* msg_type == AVDT_MSG_TYPE_REJ */
err = avdt_msg_prs_rej(&msg, p, sig);
evt = avdt_msg_rej_2_evt[sig - 1];
}
/* if parsing failed */
- if (err != 0)
- {
+ if (err != 0) {
AVDT_TRACE_WARNING("Parsing failed sig=%d err=0x%x\n", sig, err);
/* if its a rsp or rej, drop it; if its a cmd, send a rej;
** note special case for abort; never send abort reject
*/
ok = FALSE;
- if ((msg_type == AVDT_MSG_TYPE_CMD) && (sig != AVDT_SIG_ABORT))
- {
+ if ((msg_type == AVDT_MSG_TYPE_CMD) && (sig != AVDT_SIG_ABORT)) {
avdt_msg_send_rej(p_ccb, sig, &msg);
}
}
** the rsp or rej. If we didn't send a cmd for it, drop it. If
** it does match a cmd, stop timer for the cmd.
*/
- if (ok)
- {
- if ((msg_type == AVDT_MSG_TYPE_RSP) || (msg_type == AVDT_MSG_TYPE_REJ))
- {
+ if (ok) {
+ if ((msg_type == AVDT_MSG_TYPE_RSP) || (msg_type == AVDT_MSG_TYPE_REJ)) {
if ((p_ccb->p_curr_cmd != NULL) &&
- (p_ccb->p_curr_cmd->event == sig) &&
- (AVDT_LAYERSPEC_LABEL(p_ccb->p_curr_cmd->layer_specific) == label))
- {
+ (p_ccb->p_curr_cmd->event == sig) &&
+ (AVDT_LAYERSPEC_LABEL(p_ccb->p_curr_cmd->layer_specific) == label)) {
/* stop timer */
btu_stop_timer(&p_ccb->timer_entry);
/* later in this function handle ccb event */
handle_rsp = TRUE;
- }
- else
- {
+ } else {
ok = FALSE;
AVDT_TRACE_WARNING("Cmd not found for rsp sig=%d label=%d\n", sig, label);
}
}
}
- if (ok)
- {
+ if (ok) {
/* if it's a ccb event send to ccb */
- if (evt & AVDT_CCB_MKR)
- {
+ if (evt & AVDT_CCB_MKR) {
avdt_ccb_event(p_ccb, (UINT8)(evt & ~AVDT_CCB_MKR), (tAVDT_CCB_EVT *) &msg);
}
/* if it's a scb event */
- else
- {
+ else {
/* Scb events always have a single seid. For cmd, get seid from
** message. For rej and rsp, get seid from p_curr_cmd.
*/
- if (msg_type == AVDT_MSG_TYPE_CMD)
- {
+ if (msg_type == AVDT_MSG_TYPE_CMD) {
scb_hdl = msg.single.seid;
- }
- else
- {
+ } else {
scb_hdl = *((UINT8 *)(p_ccb->p_curr_cmd + 1));
}
/* Map seid to the scb and send it the event. For cmd, seid has
** already been verified by parsing function.
*/
- if (evt && (p_scb = avdt_scb_by_hdl(scb_hdl)) != NULL)
- {
+ if (evt && (p_scb = avdt_scb_by_hdl(scb_hdl)) != NULL) {
avdt_scb_event(p_scb, evt, (tAVDT_SCB_EVT *) &msg);
}
}
/* if its a rsp or rej, send event to ccb to free associated
** cmd msg buffer and handle cmd queue
*/
- if (handle_rsp)
- {
+ if (handle_rsp) {
avdt_ccb_event(p_ccb, AVDT_CCB_RCVRSP_EVT, NULL);
}
}
#if AVDT_DEBUG == TRUE
/* verbose state strings for trace */
-const char * const avdt_scb_st_str[] = {
+const char *const avdt_scb_st_str[] = {
"SCB_IDLE_ST",
"SCB_CONF_ST",
"SCB_OPENING_ST",
};
/* verbose event strings for trace */
-const char * const avdt_scb_evt_str[] = {
+const char *const avdt_scb_evt_str[] = {
"API_REMOVE_EVT",
"API_WRITE_REQ_EVT",
"API_GETCONFIG_REQ_EVT",
/* state table for idle state */
const UINT8 avdt_scb_st_idle[][AVDT_SCB_NUM_COLS] = {
-/* Event Action 1 Action 2 Next state */
-/* API_REMOVE_EVT */ {AVDT_SCB_DEALLOC, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* API_WRITE_REQ_EVT */ {AVDT_SCB_FREE_PKT, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* API_GETCONFIG_REQ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* API_DELAY_RPT_REQ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* API_SETCONFIG_REQ_EVT */ {AVDT_SCB_SND_SETCONFIG_REQ, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* API_OPEN_REQ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* API_CLOSE_REQ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* API_RECONFIG_REQ_EVT */ {AVDT_SCB_CB_ERR, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* API_SECURITY_REQ_EVT */ {AVDT_SCB_CB_ERR, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* API_ABORT_REQ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* API_GETCONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* API_SETCONFIG_RSP_EVT */ {AVDT_SCB_SND_SETCONFIG_RSP, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* API_SETCONFIG_REJ_EVT */ {AVDT_SCB_SND_SETCONFIG_REJ, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* API_OPEN_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* API_CLOSE_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* API_RECONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* API_SECURITY_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* API_ABORT_RSP_EVT */ {AVDT_SCB_SND_ABORT_RSP, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* MSG_SETCONFIG_CMD_EVT */ {AVDT_SCB_HDL_SETCONFIG_CMD, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* MSG_GETCONFIG_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* MSG_OPEN_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* MSG_START_CMD_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* MSG_SUSPEND_CMD_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* MSG_CLOSE_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* MSG_ABORT_CMD_EVT */ {AVDT_SCB_HDL_ABORT_CMD, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* MSG_RECONFIG_CMD_EVT */ {AVDT_SCB_REJ_NOT_IN_USE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* MSG_SECURITY_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* MSG_DELAY_RPT_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* MSG_DELAY_RPT_RSP_EVT */ {AVDT_SCB_HDL_DELAY_RPT_RSP, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* MSG_SETCONFIG_RSP_EVT */ {AVDT_SCB_HDL_SETCONFIG_RSP, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* MSG_GETCONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* MSG_OPEN_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* MSG_START_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* MSG_SUSPEND_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* MSG_CLOSE_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* MSG_ABORT_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* MSG_RECONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* MSG_SECURITY_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* MSG_SETCONFIG_REJ_EVT */ {AVDT_SCB_HDL_SETCONFIG_REJ, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* MSG_OPEN_REJ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* MSG_START_REJ_EVT */ {AVDT_SCB_HDL_START_RSP, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* MSG_SUSPEND_REJ_EVT */ {AVDT_SCB_HDL_SUSPEND_RSP, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* TC_TOUT_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* TC_OPEN_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* TC_CLOSE_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* TC_CONG_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* TC_DATA_EVT */ {AVDT_SCB_DROP_PKT, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* CC_CLOSE_EVT */ {AVDT_SCB_CLR_VARS, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST}
+ /* Event Action 1 Action 2 Next state */
+ /* API_REMOVE_EVT */ {AVDT_SCB_DEALLOC, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* API_WRITE_REQ_EVT */ {AVDT_SCB_FREE_PKT, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* API_GETCONFIG_REQ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* API_DELAY_RPT_REQ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* API_SETCONFIG_REQ_EVT */ {AVDT_SCB_SND_SETCONFIG_REQ, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* API_OPEN_REQ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* API_CLOSE_REQ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* API_RECONFIG_REQ_EVT */ {AVDT_SCB_CB_ERR, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* API_SECURITY_REQ_EVT */ {AVDT_SCB_CB_ERR, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* API_ABORT_REQ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* API_GETCONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* API_SETCONFIG_RSP_EVT */ {AVDT_SCB_SND_SETCONFIG_RSP, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* API_SETCONFIG_REJ_EVT */ {AVDT_SCB_SND_SETCONFIG_REJ, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* API_OPEN_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* API_CLOSE_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* API_RECONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* API_SECURITY_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* API_ABORT_RSP_EVT */ {AVDT_SCB_SND_ABORT_RSP, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* MSG_SETCONFIG_CMD_EVT */ {AVDT_SCB_HDL_SETCONFIG_CMD, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* MSG_GETCONFIG_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* MSG_OPEN_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* MSG_START_CMD_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* MSG_SUSPEND_CMD_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* MSG_CLOSE_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* MSG_ABORT_CMD_EVT */ {AVDT_SCB_HDL_ABORT_CMD, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* MSG_RECONFIG_CMD_EVT */ {AVDT_SCB_REJ_NOT_IN_USE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* MSG_SECURITY_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* MSG_DELAY_RPT_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* MSG_DELAY_RPT_RSP_EVT */ {AVDT_SCB_HDL_DELAY_RPT_RSP, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* MSG_SETCONFIG_RSP_EVT */ {AVDT_SCB_HDL_SETCONFIG_RSP, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* MSG_GETCONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* MSG_OPEN_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* MSG_START_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* MSG_SUSPEND_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* MSG_CLOSE_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* MSG_ABORT_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* MSG_RECONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* MSG_SECURITY_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* MSG_SETCONFIG_REJ_EVT */ {AVDT_SCB_HDL_SETCONFIG_REJ, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* MSG_OPEN_REJ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* MSG_START_REJ_EVT */ {AVDT_SCB_HDL_START_RSP, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* MSG_SUSPEND_REJ_EVT */ {AVDT_SCB_HDL_SUSPEND_RSP, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* TC_TOUT_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* TC_OPEN_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* TC_CLOSE_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* TC_CONG_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* TC_DATA_EVT */ {AVDT_SCB_DROP_PKT, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* CC_CLOSE_EVT */ {AVDT_SCB_CLR_VARS, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST}
};
/* state table for configured state */
const UINT8 avdt_scb_st_conf[][AVDT_SCB_NUM_COLS] = {
-/* Event Action 1 Action 2 Next state */
-/* API_REMOVE_EVT */ {AVDT_SCB_SND_ABORT_REQ, AVDT_SCB_SET_REMOVE, AVDT_SCB_CONF_ST},
-/* API_WRITE_REQ_EVT */ {AVDT_SCB_FREE_PKT, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* API_GETCONFIG_REQ_EVT */ {AVDT_SCB_SND_GETCONFIG_REQ, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* API_DELAY_RPT_REQ_EVT */ {AVDT_SCB_SND_DELAY_RPT_REQ, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* API_SETCONFIG_REQ_EVT */ {AVDT_SCB_CB_ERR, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* API_OPEN_REQ_EVT */ {AVDT_SCB_SND_OPEN_REQ, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* API_CLOSE_REQ_EVT */ {AVDT_SCB_SND_ABORT_REQ, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* API_RECONFIG_REQ_EVT */ {AVDT_SCB_CB_ERR, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* API_SECURITY_REQ_EVT */ {AVDT_SCB_SND_SECURITY_REQ, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* API_ABORT_REQ_EVT */ {AVDT_SCB_SND_ABORT_REQ, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* API_GETCONFIG_RSP_EVT */ {AVDT_SCB_SND_GETCONFIG_RSP, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* API_SETCONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* API_SETCONFIG_REJ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* API_OPEN_RSP_EVT */ {AVDT_SCB_SND_OPEN_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* API_CLOSE_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* API_RECONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* API_SECURITY_RSP_EVT */ {AVDT_SCB_SND_SECURITY_RSP, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* API_ABORT_RSP_EVT */ {AVDT_SCB_SND_ABORT_RSP, AVDT_SCB_HDL_TC_CLOSE, AVDT_SCB_IDLE_ST},
-/* MSG_SETCONFIG_CMD_EVT */ {AVDT_SCB_REJ_IN_USE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* MSG_GETCONFIG_CMD_EVT */ {AVDT_SCB_HDL_GETCONFIG_CMD, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* MSG_OPEN_CMD_EVT */ {AVDT_SCB_HDL_OPEN_CMD, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* MSG_START_CMD_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* MSG_SUSPEND_CMD_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* MSG_CLOSE_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* MSG_ABORT_CMD_EVT */ {AVDT_SCB_HDL_ABORT_CMD, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* MSG_RECONFIG_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* MSG_SECURITY_CMD_EVT */ {AVDT_SCB_HDL_SECURITY_CMD, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* MSG_DELAY_RPT_CMD_EVT */ {AVDT_SCB_HDL_DELAY_RPT_CMD, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* MSG_DELAY_RPT_RSP_EVT */ {AVDT_SCB_HDL_DELAY_RPT_RSP, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* MSG_SETCONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* MSG_GETCONFIG_RSP_EVT */ {AVDT_SCB_HDL_GETCONFIG_RSP, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* MSG_OPEN_RSP_EVT */ {AVDT_SCB_HDL_OPEN_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* MSG_START_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* MSG_SUSPEND_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* MSG_CLOSE_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* MSG_ABORT_RSP_EVT */ {AVDT_SCB_HDL_ABORT_RSP, AVDT_SCB_HDL_TC_CLOSE, AVDT_SCB_IDLE_ST},
-/* MSG_RECONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* MSG_SECURITY_RSP_EVT */ {AVDT_SCB_HDL_SECURITY_RSP, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* MSG_SETCONFIG_REJ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* MSG_OPEN_REJ_EVT */ {AVDT_SCB_HDL_OPEN_REJ, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* MSG_START_REJ_EVT */ {AVDT_SCB_HDL_START_RSP, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* MSG_SUSPEND_REJ_EVT */ {AVDT_SCB_HDL_SUSPEND_RSP, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* TC_TOUT_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* TC_OPEN_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* TC_CLOSE_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* TC_CONG_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* TC_DATA_EVT */ {AVDT_SCB_DROP_PKT, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
-/* CC_CLOSE_EVT */ {AVDT_SCB_HDL_TC_CLOSE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST}
+ /* Event Action 1 Action 2 Next state */
+ /* API_REMOVE_EVT */ {AVDT_SCB_SND_ABORT_REQ, AVDT_SCB_SET_REMOVE, AVDT_SCB_CONF_ST},
+ /* API_WRITE_REQ_EVT */ {AVDT_SCB_FREE_PKT, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* API_GETCONFIG_REQ_EVT */ {AVDT_SCB_SND_GETCONFIG_REQ, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* API_DELAY_RPT_REQ_EVT */ {AVDT_SCB_SND_DELAY_RPT_REQ, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* API_SETCONFIG_REQ_EVT */ {AVDT_SCB_CB_ERR, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* API_OPEN_REQ_EVT */ {AVDT_SCB_SND_OPEN_REQ, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* API_CLOSE_REQ_EVT */ {AVDT_SCB_SND_ABORT_REQ, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* API_RECONFIG_REQ_EVT */ {AVDT_SCB_CB_ERR, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* API_SECURITY_REQ_EVT */ {AVDT_SCB_SND_SECURITY_REQ, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* API_ABORT_REQ_EVT */ {AVDT_SCB_SND_ABORT_REQ, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* API_GETCONFIG_RSP_EVT */ {AVDT_SCB_SND_GETCONFIG_RSP, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* API_SETCONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* API_SETCONFIG_REJ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* API_OPEN_RSP_EVT */ {AVDT_SCB_SND_OPEN_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* API_CLOSE_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* API_RECONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* API_SECURITY_RSP_EVT */ {AVDT_SCB_SND_SECURITY_RSP, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* API_ABORT_RSP_EVT */ {AVDT_SCB_SND_ABORT_RSP, AVDT_SCB_HDL_TC_CLOSE, AVDT_SCB_IDLE_ST},
+ /* MSG_SETCONFIG_CMD_EVT */ {AVDT_SCB_REJ_IN_USE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* MSG_GETCONFIG_CMD_EVT */ {AVDT_SCB_HDL_GETCONFIG_CMD, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* MSG_OPEN_CMD_EVT */ {AVDT_SCB_HDL_OPEN_CMD, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* MSG_START_CMD_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* MSG_SUSPEND_CMD_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* MSG_CLOSE_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* MSG_ABORT_CMD_EVT */ {AVDT_SCB_HDL_ABORT_CMD, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* MSG_RECONFIG_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* MSG_SECURITY_CMD_EVT */ {AVDT_SCB_HDL_SECURITY_CMD, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* MSG_DELAY_RPT_CMD_EVT */ {AVDT_SCB_HDL_DELAY_RPT_CMD, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* MSG_DELAY_RPT_RSP_EVT */ {AVDT_SCB_HDL_DELAY_RPT_RSP, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* MSG_SETCONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* MSG_GETCONFIG_RSP_EVT */ {AVDT_SCB_HDL_GETCONFIG_RSP, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* MSG_OPEN_RSP_EVT */ {AVDT_SCB_HDL_OPEN_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* MSG_START_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* MSG_SUSPEND_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* MSG_CLOSE_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* MSG_ABORT_RSP_EVT */ {AVDT_SCB_HDL_ABORT_RSP, AVDT_SCB_HDL_TC_CLOSE, AVDT_SCB_IDLE_ST},
+ /* MSG_RECONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* MSG_SECURITY_RSP_EVT */ {AVDT_SCB_HDL_SECURITY_RSP, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* MSG_SETCONFIG_REJ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* MSG_OPEN_REJ_EVT */ {AVDT_SCB_HDL_OPEN_REJ, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* MSG_START_REJ_EVT */ {AVDT_SCB_HDL_START_RSP, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* MSG_SUSPEND_REJ_EVT */ {AVDT_SCB_HDL_SUSPEND_RSP, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* TC_TOUT_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* TC_OPEN_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* TC_CLOSE_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* TC_CONG_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* TC_DATA_EVT */ {AVDT_SCB_DROP_PKT, AVDT_SCB_IGNORE, AVDT_SCB_CONF_ST},
+ /* CC_CLOSE_EVT */ {AVDT_SCB_HDL_TC_CLOSE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST}
};
/* state table for opening state */
const UINT8 avdt_scb_st_opening[][AVDT_SCB_NUM_COLS] = {
-/* Event Action 1 Action 2 Next state */
-/* API_REMOVE_EVT */ {AVDT_SCB_SND_CLOSE_REQ, AVDT_SCB_SET_REMOVE, AVDT_SCB_CLOSING_ST},
-/* API_WRITE_REQ_EVT */ {AVDT_SCB_FREE_PKT, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* API_GETCONFIG_REQ_EVT */ {AVDT_SCB_SND_GETCONFIG_REQ, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* API_DELAY_RPT_REQ_EVT */ {AVDT_SCB_SND_DELAY_RPT_REQ, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* API_SETCONFIG_REQ_EVT */ {AVDT_SCB_CB_ERR, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* API_OPEN_REQ_EVT */ {AVDT_SCB_CB_ERR, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* API_CLOSE_REQ_EVT */ {AVDT_SCB_SND_CLOSE_REQ, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* API_RECONFIG_REQ_EVT */ {AVDT_SCB_CB_ERR, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* API_SECURITY_REQ_EVT */ {AVDT_SCB_SND_SECURITY_REQ, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* API_ABORT_REQ_EVT */ {AVDT_SCB_SND_ABORT_REQ, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* API_GETCONFIG_RSP_EVT */ {AVDT_SCB_SND_GETCONFIG_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* API_SETCONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* API_SETCONFIG_REJ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* API_OPEN_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* API_CLOSE_RSP_EVT */ {AVDT_SCB_SND_CLOSE_RSP, AVDT_SCB_SND_TC_CLOSE, AVDT_SCB_CLOSING_ST},
-/* API_RECONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* API_SECURITY_RSP_EVT */ {AVDT_SCB_SND_SECURITY_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* API_ABORT_RSP_EVT */ {AVDT_SCB_SND_ABORT_RSP, AVDT_SCB_SND_TC_CLOSE, AVDT_SCB_CLOSING_ST},
-/* MSG_SETCONFIG_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* MSG_GETCONFIG_CMD_EVT */ {AVDT_SCB_HDL_GETCONFIG_CMD, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* MSG_OPEN_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* MSG_START_CMD_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* MSG_SUSPEND_CMD_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* MSG_CLOSE_CMD_EVT */ {AVDT_SCB_HDL_CLOSE_CMD, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* MSG_ABORT_CMD_EVT */ {AVDT_SCB_HDL_ABORT_CMD, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* MSG_RECONFIG_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* MSG_SECURITY_CMD_EVT */ {AVDT_SCB_HDL_SECURITY_CMD, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* MSG_DELAY_RPT_CMD_EVT */ {AVDT_SCB_HDL_DELAY_RPT_CMD, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* MSG_DELAY_RPT_RSP_EVT */ {AVDT_SCB_HDL_DELAY_RPT_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* MSG_SETCONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* MSG_GETCONFIG_RSP_EVT */ {AVDT_SCB_HDL_GETCONFIG_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* MSG_OPEN_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* MSG_START_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* MSG_SUSPEND_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* MSG_CLOSE_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* MSG_ABORT_RSP_EVT */ {AVDT_SCB_SND_TC_CLOSE, AVDT_SCB_HDL_ABORT_RSP, AVDT_SCB_CLOSING_ST},
-/* MSG_RECONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* MSG_SECURITY_RSP_EVT */ {AVDT_SCB_HDL_SECURITY_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* MSG_SETCONFIG_REJ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* MSG_OPEN_REJ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* MSG_START_REJ_EVT */ {AVDT_SCB_HDL_START_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* MSG_SUSPEND_REJ_EVT */ {AVDT_SCB_HDL_SUSPEND_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* TC_TOUT_EVT */ {AVDT_SCB_SND_ABORT_REQ, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* TC_OPEN_EVT */ {AVDT_SCB_HDL_TC_OPEN, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* TC_CLOSE_EVT */ {AVDT_SCB_HDL_TC_CLOSE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* TC_CONG_EVT */ {AVDT_SCB_CONG_STATE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* TC_DATA_EVT */ {AVDT_SCB_DROP_PKT, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
-/* CC_CLOSE_EVT */ {AVDT_SCB_SND_TC_CLOSE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST}
+ /* Event Action 1 Action 2 Next state */
+ /* API_REMOVE_EVT */ {AVDT_SCB_SND_CLOSE_REQ, AVDT_SCB_SET_REMOVE, AVDT_SCB_CLOSING_ST},
+ /* API_WRITE_REQ_EVT */ {AVDT_SCB_FREE_PKT, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* API_GETCONFIG_REQ_EVT */ {AVDT_SCB_SND_GETCONFIG_REQ, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* API_DELAY_RPT_REQ_EVT */ {AVDT_SCB_SND_DELAY_RPT_REQ, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* API_SETCONFIG_REQ_EVT */ {AVDT_SCB_CB_ERR, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* API_OPEN_REQ_EVT */ {AVDT_SCB_CB_ERR, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* API_CLOSE_REQ_EVT */ {AVDT_SCB_SND_CLOSE_REQ, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* API_RECONFIG_REQ_EVT */ {AVDT_SCB_CB_ERR, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* API_SECURITY_REQ_EVT */ {AVDT_SCB_SND_SECURITY_REQ, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* API_ABORT_REQ_EVT */ {AVDT_SCB_SND_ABORT_REQ, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* API_GETCONFIG_RSP_EVT */ {AVDT_SCB_SND_GETCONFIG_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* API_SETCONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* API_SETCONFIG_REJ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* API_OPEN_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* API_CLOSE_RSP_EVT */ {AVDT_SCB_SND_CLOSE_RSP, AVDT_SCB_SND_TC_CLOSE, AVDT_SCB_CLOSING_ST},
+ /* API_RECONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* API_SECURITY_RSP_EVT */ {AVDT_SCB_SND_SECURITY_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* API_ABORT_RSP_EVT */ {AVDT_SCB_SND_ABORT_RSP, AVDT_SCB_SND_TC_CLOSE, AVDT_SCB_CLOSING_ST},
+ /* MSG_SETCONFIG_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* MSG_GETCONFIG_CMD_EVT */ {AVDT_SCB_HDL_GETCONFIG_CMD, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* MSG_OPEN_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* MSG_START_CMD_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* MSG_SUSPEND_CMD_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* MSG_CLOSE_CMD_EVT */ {AVDT_SCB_HDL_CLOSE_CMD, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* MSG_ABORT_CMD_EVT */ {AVDT_SCB_HDL_ABORT_CMD, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* MSG_RECONFIG_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* MSG_SECURITY_CMD_EVT */ {AVDT_SCB_HDL_SECURITY_CMD, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* MSG_DELAY_RPT_CMD_EVT */ {AVDT_SCB_HDL_DELAY_RPT_CMD, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* MSG_DELAY_RPT_RSP_EVT */ {AVDT_SCB_HDL_DELAY_RPT_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* MSG_SETCONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* MSG_GETCONFIG_RSP_EVT */ {AVDT_SCB_HDL_GETCONFIG_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* MSG_OPEN_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* MSG_START_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* MSG_SUSPEND_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* MSG_CLOSE_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* MSG_ABORT_RSP_EVT */ {AVDT_SCB_SND_TC_CLOSE, AVDT_SCB_HDL_ABORT_RSP, AVDT_SCB_CLOSING_ST},
+ /* MSG_RECONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* MSG_SECURITY_RSP_EVT */ {AVDT_SCB_HDL_SECURITY_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* MSG_SETCONFIG_REJ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* MSG_OPEN_REJ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* MSG_START_REJ_EVT */ {AVDT_SCB_HDL_START_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* MSG_SUSPEND_REJ_EVT */ {AVDT_SCB_HDL_SUSPEND_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* TC_TOUT_EVT */ {AVDT_SCB_SND_ABORT_REQ, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* TC_OPEN_EVT */ {AVDT_SCB_HDL_TC_OPEN, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* TC_CLOSE_EVT */ {AVDT_SCB_HDL_TC_CLOSE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* TC_CONG_EVT */ {AVDT_SCB_CONG_STATE, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* TC_DATA_EVT */ {AVDT_SCB_DROP_PKT, AVDT_SCB_IGNORE, AVDT_SCB_OPENING_ST},
+ /* CC_CLOSE_EVT */ {AVDT_SCB_SND_TC_CLOSE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST}
};
/* state table for open state */
const UINT8 avdt_scb_st_open[][AVDT_SCB_NUM_COLS] = {
-/* Event Action 1 Action 2 Next state */
-/* API_REMOVE_EVT */ {AVDT_SCB_SND_CLOSE_REQ, AVDT_SCB_SET_REMOVE, AVDT_SCB_CLOSING_ST},
-/* API_WRITE_REQ_EVT */ {AVDT_SCB_FREE_PKT, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* API_GETCONFIG_REQ_EVT */ {AVDT_SCB_SND_GETCONFIG_REQ, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* API_DELAY_RPT_REQ_EVT */ {AVDT_SCB_SND_DELAY_RPT_REQ, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* API_SETCONFIG_REQ_EVT */ {AVDT_SCB_CB_ERR, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* API_OPEN_REQ_EVT */ {AVDT_SCB_CB_ERR, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* API_CLOSE_REQ_EVT */ {AVDT_SCB_SND_CLOSE_REQ, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* API_RECONFIG_REQ_EVT */ {AVDT_SCB_SND_RECONFIG_REQ, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* API_SECURITY_REQ_EVT */ {AVDT_SCB_SND_SECURITY_REQ, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* API_ABORT_REQ_EVT */ {AVDT_SCB_SND_ABORT_REQ, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* API_GETCONFIG_RSP_EVT */ {AVDT_SCB_SND_GETCONFIG_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* API_SETCONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* API_SETCONFIG_REJ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* API_OPEN_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* API_CLOSE_RSP_EVT */ {AVDT_SCB_SND_CLOSE_RSP, AVDT_SCB_TC_TIMER, AVDT_SCB_CLOSING_ST},
-/* API_RECONFIG_RSP_EVT */ {AVDT_SCB_SND_RECONFIG_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* API_SECURITY_RSP_EVT */ {AVDT_SCB_SND_SECURITY_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* API_ABORT_RSP_EVT */ {AVDT_SCB_SND_ABORT_RSP, AVDT_SCB_TC_TIMER, AVDT_SCB_CLOSING_ST},
-/* MSG_SETCONFIG_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* MSG_GETCONFIG_CMD_EVT */ {AVDT_SCB_HDL_GETCONFIG_CMD, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* MSG_OPEN_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* MSG_START_CMD_EVT */ {AVDT_SCB_HDL_START_CMD, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* MSG_SUSPEND_CMD_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* MSG_CLOSE_CMD_EVT */ {AVDT_SCB_HDL_CLOSE_CMD, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* MSG_ABORT_CMD_EVT */ {AVDT_SCB_HDL_ABORT_CMD, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* MSG_RECONFIG_CMD_EVT */ {AVDT_SCB_HDL_RECONFIG_CMD, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* MSG_SECURITY_CMD_EVT */ {AVDT_SCB_HDL_SECURITY_CMD, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* MSG_DELAY_RPT_CMD_EVT */ {AVDT_SCB_HDL_DELAY_RPT_CMD, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* MSG_DELAY_RPT_RSP_EVT */ {AVDT_SCB_HDL_DELAY_RPT_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* MSG_SETCONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* MSG_GETCONFIG_RSP_EVT */ {AVDT_SCB_HDL_GETCONFIG_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* MSG_OPEN_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* MSG_START_RSP_EVT */ {AVDT_SCB_HDL_START_RSP, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* MSG_SUSPEND_RSP_EVT */ {AVDT_SCB_HDL_SUSPEND_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* MSG_CLOSE_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* MSG_ABORT_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* MSG_RECONFIG_RSP_EVT */ {AVDT_SCB_HDL_RECONFIG_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* MSG_SECURITY_RSP_EVT */ {AVDT_SCB_HDL_SECURITY_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* MSG_SETCONFIG_REJ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* MSG_OPEN_REJ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* MSG_START_REJ_EVT */ {AVDT_SCB_HDL_START_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* MSG_SUSPEND_REJ_EVT */ {AVDT_SCB_HDL_SUSPEND_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* TC_TOUT_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* Event Action 1 Action 2 Next state */
+ /* API_REMOVE_EVT */ {AVDT_SCB_SND_CLOSE_REQ, AVDT_SCB_SET_REMOVE, AVDT_SCB_CLOSING_ST},
+ /* API_WRITE_REQ_EVT */ {AVDT_SCB_FREE_PKT, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* API_GETCONFIG_REQ_EVT */ {AVDT_SCB_SND_GETCONFIG_REQ, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* API_DELAY_RPT_REQ_EVT */ {AVDT_SCB_SND_DELAY_RPT_REQ, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* API_SETCONFIG_REQ_EVT */ {AVDT_SCB_CB_ERR, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* API_OPEN_REQ_EVT */ {AVDT_SCB_CB_ERR, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* API_CLOSE_REQ_EVT */ {AVDT_SCB_SND_CLOSE_REQ, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* API_RECONFIG_REQ_EVT */ {AVDT_SCB_SND_RECONFIG_REQ, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* API_SECURITY_REQ_EVT */ {AVDT_SCB_SND_SECURITY_REQ, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* API_ABORT_REQ_EVT */ {AVDT_SCB_SND_ABORT_REQ, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* API_GETCONFIG_RSP_EVT */ {AVDT_SCB_SND_GETCONFIG_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* API_SETCONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* API_SETCONFIG_REJ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* API_OPEN_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* API_CLOSE_RSP_EVT */ {AVDT_SCB_SND_CLOSE_RSP, AVDT_SCB_TC_TIMER, AVDT_SCB_CLOSING_ST},
+ /* API_RECONFIG_RSP_EVT */ {AVDT_SCB_SND_RECONFIG_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* API_SECURITY_RSP_EVT */ {AVDT_SCB_SND_SECURITY_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* API_ABORT_RSP_EVT */ {AVDT_SCB_SND_ABORT_RSP, AVDT_SCB_TC_TIMER, AVDT_SCB_CLOSING_ST},
+ /* MSG_SETCONFIG_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* MSG_GETCONFIG_CMD_EVT */ {AVDT_SCB_HDL_GETCONFIG_CMD, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* MSG_OPEN_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* MSG_START_CMD_EVT */ {AVDT_SCB_HDL_START_CMD, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* MSG_SUSPEND_CMD_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* MSG_CLOSE_CMD_EVT */ {AVDT_SCB_HDL_CLOSE_CMD, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* MSG_ABORT_CMD_EVT */ {AVDT_SCB_HDL_ABORT_CMD, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* MSG_RECONFIG_CMD_EVT */ {AVDT_SCB_HDL_RECONFIG_CMD, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* MSG_SECURITY_CMD_EVT */ {AVDT_SCB_HDL_SECURITY_CMD, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* MSG_DELAY_RPT_CMD_EVT */ {AVDT_SCB_HDL_DELAY_RPT_CMD, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* MSG_DELAY_RPT_RSP_EVT */ {AVDT_SCB_HDL_DELAY_RPT_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* MSG_SETCONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* MSG_GETCONFIG_RSP_EVT */ {AVDT_SCB_HDL_GETCONFIG_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* MSG_OPEN_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* MSG_START_RSP_EVT */ {AVDT_SCB_HDL_START_RSP, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* MSG_SUSPEND_RSP_EVT */ {AVDT_SCB_HDL_SUSPEND_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* MSG_CLOSE_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* MSG_ABORT_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* MSG_RECONFIG_RSP_EVT */ {AVDT_SCB_HDL_RECONFIG_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* MSG_SECURITY_RSP_EVT */ {AVDT_SCB_HDL_SECURITY_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* MSG_SETCONFIG_REJ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* MSG_OPEN_REJ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* MSG_START_REJ_EVT */ {AVDT_SCB_HDL_START_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* MSG_SUSPEND_REJ_EVT */ {AVDT_SCB_HDL_SUSPEND_RSP, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* TC_TOUT_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
#if AVDT_REPORTING == TRUE
-/* TC_OPEN_EVT */ {AVDT_SCB_HDL_TC_OPEN_STO, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* TC_CLOSE_EVT */ {AVDT_SCB_HDL_TC_CLOSE_STO, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* TC_OPEN_EVT */ {AVDT_SCB_HDL_TC_OPEN_STO, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* TC_CLOSE_EVT */ {AVDT_SCB_HDL_TC_CLOSE_STO, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
#else
-/* TC_OPEN_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* TC_CLOSE_EVT */ {AVDT_SCB_HDL_TC_CLOSE, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* TC_OPEN_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* TC_CLOSE_EVT */ {AVDT_SCB_HDL_TC_CLOSE, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
#endif
-/* TC_CONG_EVT */ {AVDT_SCB_CONG_STATE, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* TC_DATA_EVT */ {AVDT_SCB_DROP_PKT, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
-/* CC_CLOSE_EVT */ {AVDT_SCB_SND_TC_CLOSE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST}
+ /* TC_CONG_EVT */ {AVDT_SCB_CONG_STATE, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* TC_DATA_EVT */ {AVDT_SCB_DROP_PKT, AVDT_SCB_IGNORE, AVDT_SCB_OPEN_ST},
+ /* CC_CLOSE_EVT */ {AVDT_SCB_SND_TC_CLOSE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST}
};
/* state table for streaming state */
const UINT8 avdt_scb_st_stream[][AVDT_SCB_NUM_COLS] = {
-/* Event Action 1 Action 2 Next state */
-/* API_REMOVE_EVT */ {AVDT_SCB_SND_STREAM_CLOSE, AVDT_SCB_SET_REMOVE, AVDT_SCB_CLOSING_ST},
-/* API_WRITE_REQ_EVT */ {AVDT_SCB_HDL_WRITE_REQ, AVDT_SCB_CHK_SND_PKT, AVDT_SCB_STREAM_ST},
-/* API_GETCONFIG_REQ_EVT */ {AVDT_SCB_SND_GETCONFIG_REQ, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* API_DELAY_RPT_REQ_EVT */ {AVDT_SCB_SND_DELAY_RPT_REQ, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* API_SETCONFIG_REQ_EVT */ {AVDT_SCB_CB_ERR, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* API_OPEN_REQ_EVT */ {AVDT_SCB_CB_ERR, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* API_CLOSE_REQ_EVT */ {AVDT_SCB_SND_STREAM_CLOSE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* API_RECONFIG_REQ_EVT */ {AVDT_SCB_CB_ERR, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* API_SECURITY_REQ_EVT */ {AVDT_SCB_SND_SECURITY_REQ, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* API_ABORT_REQ_EVT */ {AVDT_SCB_SND_ABORT_REQ, AVDT_SCB_CLR_PKT, AVDT_SCB_CLOSING_ST},
-/* API_GETCONFIG_RSP_EVT */ {AVDT_SCB_SND_GETCONFIG_RSP, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* API_SETCONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* API_SETCONFIG_REJ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* API_OPEN_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* API_CLOSE_RSP_EVT */ {AVDT_SCB_SND_CLOSE_RSP, AVDT_SCB_TC_TIMER, AVDT_SCB_CLOSING_ST},
-/* API_RECONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* API_SECURITY_RSP_EVT */ {AVDT_SCB_SND_SECURITY_RSP, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* API_ABORT_RSP_EVT */ {AVDT_SCB_SND_ABORT_RSP, AVDT_SCB_TC_TIMER, AVDT_SCB_CLOSING_ST},
-/* MSG_SETCONFIG_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* MSG_GETCONFIG_CMD_EVT */ {AVDT_SCB_HDL_GETCONFIG_CMD, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* MSG_OPEN_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* MSG_START_CMD_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* MSG_SUSPEND_CMD_EVT */ {AVDT_SCB_HDL_SUSPEND_CMD, AVDT_SCB_CLR_PKT, AVDT_SCB_OPEN_ST},
-/* MSG_CLOSE_CMD_EVT */ {AVDT_SCB_HDL_CLOSE_CMD, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* MSG_ABORT_CMD_EVT */ {AVDT_SCB_HDL_ABORT_CMD, AVDT_SCB_CLR_PKT, AVDT_SCB_STREAM_ST},
-/* MSG_RECONFIG_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* MSG_SECURITY_CMD_EVT */ {AVDT_SCB_HDL_SECURITY_CMD, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* MSG_DELAY_RPT_CMD_EVT */ {AVDT_SCB_HDL_DELAY_RPT_CMD, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* MSG_DELAY_RPT_RSP_EVT */ {AVDT_SCB_HDL_DELAY_RPT_RSP, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* MSG_SETCONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* MSG_GETCONFIG_RSP_EVT */ {AVDT_SCB_HDL_GETCONFIG_RSP, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* MSG_OPEN_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* MSG_START_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* MSG_SUSPEND_RSP_EVT */ {AVDT_SCB_HDL_SUSPEND_RSP, AVDT_SCB_CLR_PKT, AVDT_SCB_OPEN_ST},
-/* MSG_CLOSE_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* MSG_ABORT_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* MSG_RECONFIG_RSP_EVT */ {AVDT_SCB_HDL_RECONFIG_RSP, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* MSG_SECURITY_RSP_EVT */ {AVDT_SCB_HDL_SECURITY_RSP, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* MSG_SETCONFIG_REJ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* MSG_OPEN_REJ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* MSG_START_REJ_EVT */ {AVDT_SCB_HDL_START_RSP, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* MSG_SUSPEND_REJ_EVT */ {AVDT_SCB_HDL_SUSPEND_RSP, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* TC_TOUT_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* TC_OPEN_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* TC_CLOSE_EVT */ {AVDT_SCB_HDL_TC_CLOSE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* TC_CONG_EVT */ {AVDT_SCB_CONG_STATE, AVDT_SCB_CHK_SND_PKT, AVDT_SCB_STREAM_ST},
-/* TC_DATA_EVT */ {AVDT_SCB_HDL_PKT, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
-/* CC_CLOSE_EVT */ {AVDT_SCB_SND_TC_CLOSE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST}
+ /* Event Action 1 Action 2 Next state */
+ /* API_REMOVE_EVT */ {AVDT_SCB_SND_STREAM_CLOSE, AVDT_SCB_SET_REMOVE, AVDT_SCB_CLOSING_ST},
+ /* API_WRITE_REQ_EVT */ {AVDT_SCB_HDL_WRITE_REQ, AVDT_SCB_CHK_SND_PKT, AVDT_SCB_STREAM_ST},
+ /* API_GETCONFIG_REQ_EVT */ {AVDT_SCB_SND_GETCONFIG_REQ, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* API_DELAY_RPT_REQ_EVT */ {AVDT_SCB_SND_DELAY_RPT_REQ, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* API_SETCONFIG_REQ_EVT */ {AVDT_SCB_CB_ERR, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* API_OPEN_REQ_EVT */ {AVDT_SCB_CB_ERR, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* API_CLOSE_REQ_EVT */ {AVDT_SCB_SND_STREAM_CLOSE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* API_RECONFIG_REQ_EVT */ {AVDT_SCB_CB_ERR, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* API_SECURITY_REQ_EVT */ {AVDT_SCB_SND_SECURITY_REQ, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* API_ABORT_REQ_EVT */ {AVDT_SCB_SND_ABORT_REQ, AVDT_SCB_CLR_PKT, AVDT_SCB_CLOSING_ST},
+ /* API_GETCONFIG_RSP_EVT */ {AVDT_SCB_SND_GETCONFIG_RSP, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* API_SETCONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* API_SETCONFIG_REJ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* API_OPEN_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* API_CLOSE_RSP_EVT */ {AVDT_SCB_SND_CLOSE_RSP, AVDT_SCB_TC_TIMER, AVDT_SCB_CLOSING_ST},
+ /* API_RECONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* API_SECURITY_RSP_EVT */ {AVDT_SCB_SND_SECURITY_RSP, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* API_ABORT_RSP_EVT */ {AVDT_SCB_SND_ABORT_RSP, AVDT_SCB_TC_TIMER, AVDT_SCB_CLOSING_ST},
+ /* MSG_SETCONFIG_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* MSG_GETCONFIG_CMD_EVT */ {AVDT_SCB_HDL_GETCONFIG_CMD, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* MSG_OPEN_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* MSG_START_CMD_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* MSG_SUSPEND_CMD_EVT */ {AVDT_SCB_HDL_SUSPEND_CMD, AVDT_SCB_CLR_PKT, AVDT_SCB_OPEN_ST},
+ /* MSG_CLOSE_CMD_EVT */ {AVDT_SCB_HDL_CLOSE_CMD, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* MSG_ABORT_CMD_EVT */ {AVDT_SCB_HDL_ABORT_CMD, AVDT_SCB_CLR_PKT, AVDT_SCB_STREAM_ST},
+ /* MSG_RECONFIG_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* MSG_SECURITY_CMD_EVT */ {AVDT_SCB_HDL_SECURITY_CMD, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* MSG_DELAY_RPT_CMD_EVT */ {AVDT_SCB_HDL_DELAY_RPT_CMD, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* MSG_DELAY_RPT_RSP_EVT */ {AVDT_SCB_HDL_DELAY_RPT_RSP, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* MSG_SETCONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* MSG_GETCONFIG_RSP_EVT */ {AVDT_SCB_HDL_GETCONFIG_RSP, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* MSG_OPEN_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* MSG_START_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* MSG_SUSPEND_RSP_EVT */ {AVDT_SCB_HDL_SUSPEND_RSP, AVDT_SCB_CLR_PKT, AVDT_SCB_OPEN_ST},
+ /* MSG_CLOSE_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* MSG_ABORT_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* MSG_RECONFIG_RSP_EVT */ {AVDT_SCB_HDL_RECONFIG_RSP, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* MSG_SECURITY_RSP_EVT */ {AVDT_SCB_HDL_SECURITY_RSP, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* MSG_SETCONFIG_REJ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* MSG_OPEN_REJ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* MSG_START_REJ_EVT */ {AVDT_SCB_HDL_START_RSP, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* MSG_SUSPEND_REJ_EVT */ {AVDT_SCB_HDL_SUSPEND_RSP, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* TC_TOUT_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* TC_OPEN_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* TC_CLOSE_EVT */ {AVDT_SCB_HDL_TC_CLOSE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* TC_CONG_EVT */ {AVDT_SCB_CONG_STATE, AVDT_SCB_CHK_SND_PKT, AVDT_SCB_STREAM_ST},
+ /* TC_DATA_EVT */ {AVDT_SCB_HDL_PKT, AVDT_SCB_IGNORE, AVDT_SCB_STREAM_ST},
+ /* CC_CLOSE_EVT */ {AVDT_SCB_SND_TC_CLOSE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST}
};
/* state table for closing state */
const UINT8 avdt_scb_st_closing[][AVDT_SCB_NUM_COLS] = {
-/* Event Action 1 Action 2 Next state */
-/* API_REMOVE_EVT */ {AVDT_SCB_SET_REMOVE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* API_WRITE_REQ_EVT */ {AVDT_SCB_FREE_PKT, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* API_GETCONFIG_REQ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* API_DELAY_RPT_REQ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* API_SETCONFIG_REQ_EVT */ {AVDT_SCB_CB_ERR, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* API_OPEN_REQ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* API_CLOSE_REQ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* API_RECONFIG_REQ_EVT */ {AVDT_SCB_CB_ERR, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* API_SECURITY_REQ_EVT */ {AVDT_SCB_CB_ERR, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* API_ABORT_REQ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* API_GETCONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* API_SETCONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* API_SETCONFIG_REJ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* API_OPEN_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* API_CLOSE_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* API_RECONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* API_SECURITY_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* API_ABORT_RSP_EVT */ {AVDT_SCB_SND_ABORT_RSP, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* MSG_SETCONFIG_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* MSG_GETCONFIG_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* MSG_OPEN_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* MSG_START_CMD_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* MSG_SUSPEND_CMD_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* MSG_CLOSE_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* MSG_ABORT_CMD_EVT */ {AVDT_SCB_HDL_ABORT_CMD, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* MSG_RECONFIG_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* MSG_SECURITY_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* MSG_DELAY_RPT_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* MSG_DELAY_RPT_RSP_EVT */ {AVDT_SCB_HDL_DELAY_RPT_RSP, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* MSG_SETCONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* MSG_GETCONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* MSG_OPEN_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* MSG_START_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* MSG_SUSPEND_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* MSG_CLOSE_RSP_EVT */ {AVDT_SCB_SND_TC_CLOSE, AVDT_SCB_HDL_CLOSE_RSP, AVDT_SCB_CLOSING_ST},
-/* MSG_ABORT_RSP_EVT */ {AVDT_SCB_SND_TC_CLOSE, AVDT_SCB_HDL_ABORT_RSP, AVDT_SCB_CLOSING_ST},
-/* MSG_RECONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* MSG_SECURITY_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* MSG_SETCONFIG_REJ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* MSG_OPEN_REJ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* MSG_START_REJ_EVT */ {AVDT_SCB_HDL_START_RSP, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* MSG_SUSPEND_REJ_EVT */ {AVDT_SCB_HDL_SUSPEND_RSP, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* TC_TOUT_EVT */ {AVDT_SCB_SND_TC_CLOSE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* TC_OPEN_EVT */ {AVDT_SCB_SND_TC_CLOSE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* TC_CLOSE_EVT */ {AVDT_SCB_HDL_TC_CLOSE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
-/* TC_CONG_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* TC_DATA_EVT */ {AVDT_SCB_DROP_PKT, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
-/* CC_CLOSE_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST}
+ /* Event Action 1 Action 2 Next state */
+ /* API_REMOVE_EVT */ {AVDT_SCB_SET_REMOVE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* API_WRITE_REQ_EVT */ {AVDT_SCB_FREE_PKT, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* API_GETCONFIG_REQ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* API_DELAY_RPT_REQ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* API_SETCONFIG_REQ_EVT */ {AVDT_SCB_CB_ERR, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* API_OPEN_REQ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* API_CLOSE_REQ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* API_RECONFIG_REQ_EVT */ {AVDT_SCB_CB_ERR, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* API_SECURITY_REQ_EVT */ {AVDT_SCB_CB_ERR, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* API_ABORT_REQ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* API_GETCONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* API_SETCONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* API_SETCONFIG_REJ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* API_OPEN_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* API_CLOSE_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* API_RECONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* API_SECURITY_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* API_ABORT_RSP_EVT */ {AVDT_SCB_SND_ABORT_RSP, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* MSG_SETCONFIG_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* MSG_GETCONFIG_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* MSG_OPEN_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* MSG_START_CMD_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* MSG_SUSPEND_CMD_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* MSG_CLOSE_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* MSG_ABORT_CMD_EVT */ {AVDT_SCB_HDL_ABORT_CMD, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* MSG_RECONFIG_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* MSG_SECURITY_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* MSG_DELAY_RPT_CMD_EVT */ {AVDT_SCB_REJ_STATE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* MSG_DELAY_RPT_RSP_EVT */ {AVDT_SCB_HDL_DELAY_RPT_RSP, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* MSG_SETCONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* MSG_GETCONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* MSG_OPEN_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* MSG_START_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* MSG_SUSPEND_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* MSG_CLOSE_RSP_EVT */ {AVDT_SCB_SND_TC_CLOSE, AVDT_SCB_HDL_CLOSE_RSP, AVDT_SCB_CLOSING_ST},
+ /* MSG_ABORT_RSP_EVT */ {AVDT_SCB_SND_TC_CLOSE, AVDT_SCB_HDL_ABORT_RSP, AVDT_SCB_CLOSING_ST},
+ /* MSG_RECONFIG_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* MSG_SECURITY_RSP_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* MSG_SETCONFIG_REJ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* MSG_OPEN_REJ_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* MSG_START_REJ_EVT */ {AVDT_SCB_HDL_START_RSP, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* MSG_SUSPEND_REJ_EVT */ {AVDT_SCB_HDL_SUSPEND_RSP, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* TC_TOUT_EVT */ {AVDT_SCB_SND_TC_CLOSE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* TC_OPEN_EVT */ {AVDT_SCB_SND_TC_CLOSE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* TC_CLOSE_EVT */ {AVDT_SCB_HDL_TC_CLOSE, AVDT_SCB_IGNORE, AVDT_SCB_IDLE_ST},
+ /* TC_CONG_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* TC_DATA_EVT */ {AVDT_SCB_DROP_PKT, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST},
+ /* CC_CLOSE_EVT */ {AVDT_SCB_IGNORE, AVDT_SCB_IGNORE, AVDT_SCB_CLOSING_ST}
};
/* type for state table */
}
/* execute action functions */
- for (i = 0; i < AVDT_SCB_ACTIONS; i++)
- {
- if ((action = state_table[event][i]) != AVDT_SCB_IGNORE)
- {
+ for (i = 0; i < AVDT_SCB_ACTIONS; i++) {
+ if ((action = state_table[event][i]) != AVDT_SCB_IGNORE) {
(*avdt_cb.p_scb_act[action])(p_scb, p_data);
- }
- else
- {
+ } else {
break;
}
}
int i;
/* find available scb */
- for (i = 0; i < AVDT_NUM_SEPS; i++, p_scb++)
- {
- if (!p_scb->allocated)
- {
- memset(p_scb,0,sizeof(tAVDT_SCB));
+ for (i = 0; i < AVDT_NUM_SEPS; i++, p_scb++) {
+ if (!p_scb->allocated) {
+ memset(p_scb, 0, sizeof(tAVDT_SCB));
p_scb->allocated = TRUE;
p_scb->p_ccb = NULL;
/* initialize sink as activated */
- if (p_cs->tsep == AVDT_TSEP_SNK)
- {
+ if (p_cs->tsep == AVDT_TSEP_SNK) {
p_scb->sink_activated = TRUE;
}
/* initialize fragments gueue */
GKI_init_q(&p_scb->frag_q);
- if(p_cs->cfg.psc_mask & AVDT_PSC_MUX)
- {
+ if (p_cs->cfg.psc_mask & AVDT_PSC_MUX) {
p_scb->cs.cfg.mux_tcid_media = avdt_ad_type_to_tcid(AVDT_CHAN_MEDIA, p_scb);
#if AVDT_REPORTING == TRUE
- if(p_cs->cfg.psc_mask & AVDT_PSC_REPORT)
- {
+ if (p_cs->cfg.psc_mask & AVDT_PSC_REPORT) {
p_scb->cs.cfg.mux_tcid_report = avdt_ad_type_to_tcid(AVDT_CHAN_REPORT, p_scb);
}
#endif
}
#endif
p_scb->timer_entry.param = (UINT32) p_scb;
- AVDT_TRACE_DEBUG("avdt_scb_alloc hdl=%d, psc_mask:0x%x\n", i+1, p_cs->cfg.psc_mask);
+ AVDT_TRACE_DEBUG("avdt_scb_alloc hdl=%d, psc_mask:0x%x\n", i + 1, p_cs->cfg.psc_mask);
break;
}
}
- if (i == AVDT_NUM_SEPS)
- {
+ if (i == AVDT_NUM_SEPS) {
/* out of ccbs */
p_scb = NULL;
AVDT_TRACE_WARNING("Out of scbs");
#if AVDT_MULTIPLEXING == TRUE
/* free fragments we're holding, if any; it shouldn't happen */
- while ((p_buf = GKI_dequeue (&p_scb->frag_q)) != NULL)
+ while ((p_buf = GKI_dequeue (&p_scb->frag_q)) != NULL) {
GKI_freebuf(p_buf);
+ }
#endif
memset(p_scb, 0, sizeof(tAVDT_SCB));
tAVDT_SCB *p_scb;
/* verify index */
- if ((hdl > 0) && (hdl <= AVDT_NUM_SEPS))
- {
+ if ((hdl > 0) && (hdl <= AVDT_NUM_SEPS)) {
p_scb = &avdt_cb.scb[hdl - 1];
/* verify scb is allocated */
- if (!p_scb->allocated)
- {
+ if (!p_scb->allocated) {
p_scb = NULL;
AVDT_TRACE_WARNING("scb hdl %d not allocated\n", hdl);
}
- }
- else
- {
+ } else {
p_scb = NULL;
AVDT_TRACE_WARNING("scb hdl %d out of range\n", hdl);
}
/* set nonsupported command mask */
/* translate public state into private state */
nsc_mask = 0;
- if (state == AVDT_VERIFY_SUSPEND)
- nsc_mask = AVDT_NSC_SUSPEND;
+ if (state == AVDT_VERIFY_SUSPEND) {
+ nsc_mask = AVDT_NSC_SUSPEND;
+ }
/* verify every scb */
- for (i = 0, *p_err_code = 0; (i < num_seid) && (*p_err_code == 0) && (i < AVDT_NUM_SEPS); i++)
- {
- if ((p_scb = avdt_scb_by_hdl(p_seid[i])) == NULL)
+ for (i = 0, *p_err_code = 0; (i < num_seid) && (*p_err_code == 0) && (i < AVDT_NUM_SEPS); i++) {
+ if ((p_scb = avdt_scb_by_hdl(p_seid[i])) == NULL) {
*p_err_code = AVDT_ERR_BAD_STATE;
- else if (p_scb->p_ccb != p_ccb)
+ } else if (p_scb->p_ccb != p_ccb) {
*p_err_code = AVDT_ERR_BAD_STATE;
- else if (p_scb->cs.nsc_mask & nsc_mask)
+ } else if (p_scb->cs.nsc_mask & nsc_mask) {
*p_err_code = AVDT_ERR_NSC;
+ }
switch (state) {
- case AVDT_VERIFY_OPEN:
- case AVDT_VERIFY_START:
- if (p_scb->state != AVDT_SCB_OPEN_ST && p_scb->state != AVDT_SCB_STREAM_ST)
- *p_err_code = AVDT_ERR_BAD_STATE;
+ case AVDT_VERIFY_OPEN:
+ case AVDT_VERIFY_START:
+ if (p_scb->state != AVDT_SCB_OPEN_ST && p_scb->state != AVDT_SCB_STREAM_ST) {
+ *p_err_code = AVDT_ERR_BAD_STATE;
+ }
break;
- case AVDT_VERIFY_SUSPEND:
- case AVDT_VERIFY_STREAMING:
- if (p_scb->state != AVDT_SCB_STREAM_ST)
- *p_err_code = AVDT_ERR_BAD_STATE;
+ case AVDT_VERIFY_SUSPEND:
+ case AVDT_VERIFY_STREAMING:
+ if (p_scb->state != AVDT_SCB_STREAM_ST) {
+ *p_err_code = AVDT_ERR_BAD_STATE;
+ }
break;
}
}
- if ((i != num_seid) && (i < AVDT_NUM_SEPS))
- {
+ if ((i != num_seid) && (i < AVDT_NUM_SEPS)) {
ret = p_seid[i];
}
int i;
tAVDT_SCB *p_scb;
- for (i = 0; i < p_multi->num_seps; i++)
- {
- if ((p_scb = avdt_scb_by_hdl(p_multi->seid_list[i])) != NULL)
- {
+ for (i = 0; i < p_multi->num_seps; i++) {
+ if ((p_scb = avdt_scb_by_hdl(p_multi->seid_list[i])) != NULL) {
p_multi->seid_list[i] = p_scb->peer_seid;
}
}
** Returns Nothing.
**
*******************************************************************************/
-void avdt_scb_hdl_getconfig_cmd(tAVDT_SCB *p_scb,tAVDT_SCB_EVT *p_data)
+void avdt_scb_hdl_getconfig_cmd(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
{
p_data->msg.svccap.p_cfg = &p_scb->curr_cfg;
p += o_cc * 4;
/* check for and skip over extension header */
- if (o_x)
- {
+ if (o_x) {
p += 2;
BE_STREAM_TO_UINT16(ex_len, p);
p += ex_len * 4;
offset = (UINT16) (p - p_start);
/* adjust length for any padding at end of packet */
- if (o_p)
- {
+ if (o_p) {
/* padding length in last byte of packet */
pad_len = *(p_start + p_data->p_pkt->len);
}
/* do sanity check */
- if ((offset > p_data->p_pkt->len) || ((pad_len + offset) > p_data->p_pkt->len))
- {
+ if ((offset > p_data->p_pkt->len) || ((pad_len + offset) > p_data->p_pkt->len)) {
AVDT_TRACE_WARNING("Got bad media packet");
GKI_freebuf(p_data->p_pkt);
}
/* adjust offset and length and send it up */
- else
- {
+ else {
p_data->p_pkt->len -= (offset + pad_len);
p_data->p_pkt->offset += offset;
- if (p_scb->cs.p_data_cback != NULL)
- {
+ if (p_scb->cs.p_data_cback != NULL) {
/* report sequence number */
p_data->p_pkt->layer_specific = seq;
(*p_scb->cs.p_data_cback)(avdt_scb_to_hdl(p_scb), p_data->p_pkt,
- time_stamp, (UINT8)(m_pt | (marker<<7)));
- }
- else
- {
+ time_stamp, (UINT8)(m_pt | (marker << 7)));
+ } else {
#if AVDT_MULTIPLEXING == TRUE
if ((p_scb->cs.p_media_cback != NULL)
- && (p_scb->p_media_buf != NULL)
- && (p_scb->media_buf_len > p_data->p_pkt->len))
- {
+ && (p_scb->p_media_buf != NULL)
+ && (p_scb->media_buf_len > p_data->p_pkt->len)) {
/* media buffer enough length is assigned by application. Lets use it*/
- memcpy(p_scb->p_media_buf,(UINT8*)(p_data->p_pkt + 1) + p_data->p_pkt->offset,
- p_data->p_pkt->len);
- (*p_scb->cs.p_media_cback)(avdt_scb_to_hdl(p_scb),p_scb->p_media_buf,
- p_scb->media_buf_len,time_stamp,seq,m_pt,marker);
+ memcpy(p_scb->p_media_buf, (UINT8 *)(p_data->p_pkt + 1) + p_data->p_pkt->offset,
+ p_data->p_pkt->len);
+ (*p_scb->cs.p_media_cback)(avdt_scb_to_hdl(p_scb), p_scb->p_media_buf,
+ p_scb->media_buf_len, time_stamp, seq, m_pt, marker);
}
#endif
GKI_freebuf(p_data->p_pkt);
** Returns Nothing.
**
*******************************************************************************/
-UINT8 * avdt_scb_hdl_report(tAVDT_SCB *p_scb, UINT8 *p, UINT16 len)
+UINT8 *avdt_scb_hdl_report(tAVDT_SCB *p_scb, UINT8 *p, UINT16 len)
{
UINT16 result = AVDT_SUCCESS;
UINT8 *p_start = p;
tAVDT_REPORT_DATA report, *p_rpt;
AVDT_TRACE_DEBUG( "avdt_scb_hdl_report");
- if(p_scb->cs.p_report_cback)
- {
+ if (p_scb->cs.p_report_cback) {
p_rpt = &report;
/* parse report packet header */
AVDT_MSG_PRS_RPT_OCTET1(p, o_v, o_p, o_cc);
UNUSED(o_p);
UNUSED(o_v);
- switch(pt)
- {
+ switch (pt) {
case AVDT_RTCP_PT_SR: /* the packet type - SR (Sender Report) */
BE_STREAM_TO_UINT32(report.sr.ntp_sec, p);
BE_STREAM_TO_UINT32(report.sr.ntp_frac, p);
break;
case AVDT_RTCP_PT_SDES: /* the packet type - SDES (Source Description) */
- if(*p == AVDT_RTCP_SDES_CNAME)
- {
- p_rpt = (tAVDT_REPORT_DATA *)(p+2);
- }
- else
- {
+ if (*p == AVDT_RTCP_SDES_CNAME) {
+ p_rpt = (tAVDT_REPORT_DATA *)(p + 2);
+ } else {
AVDT_TRACE_WARNING( " - SDES SSRC=0x%08x sc=%d %d len=%d %s\n",
- ssrc, o_cc, *p, *(p+1), p+2);
+ ssrc, o_cc, *p, *(p + 1), p + 2);
result = AVDT_BUSY;
}
break;
result = AVDT_BAD_PARAMS;
}
- if(result == AVDT_SUCCESS)
+ if (result == AVDT_SUCCESS) {
(*p_scb->cs.p_report_cback)(avdt_scb_to_hdl(p_scb), pt, p_rpt);
+ }
}
p_start += len;
void avdt_scb_hdl_pkt_frag(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
{
/* Fields of Adaptation Layer Header */
- UINT8 al_tsid,al_frag,al_lcode;
+ UINT8 al_tsid, al_frag, al_lcode;
UINT16 al_len;
/* media header fields */
UINT8 o_v, o_p, o_x, o_cc;
p = (UINT8 *)(p_data->p_pkt + 1) + p_data->p_pkt->offset;
p_end = p + p_data->p_pkt->len;
/* parse all fragments */
- while(p < p_end)
- {
- if (p_end - p < 4) /* length check. maximum length of AL header = 4 */
- {
+ while (p < p_end) {
+ if (p_end - p < 4) { /* length check. maximum length of AL header = 4 */
AVDT_TRACE_WARNING("p_end: %p - p:%p < 4\n", p_end, p);
break;
}
/* parse first byte */
- al_tsid = (*p)>>3;
+ al_tsid = (*p) >> 3;
al_frag = ( (*p) >> 2 ) & 0x01;
al_lcode = (*p++) & AVDT_ALH_LCODE_MASK;
/* in case of TSID=00000, a second AL header byte, before the length field,
** is expected and contains the actual TSID, aligned with MSB */
- if(al_tsid == 0)
+ if (al_tsid == 0) {
al_tsid = *p++;
+ }
/* get remaining media length on base of lcode */
- switch(al_lcode)
- {
+ switch (al_lcode) {
case AVDT_ALH_LCODE_NONE: /* No length field present. Take length from l2cap */
al_len = (UINT16)(p_end - p);
break;
al_len = *p++;
break;
default: /* 9 bit length field, MSB = 1, 8 LSBs in 1 octet following */
- al_len =(UINT16)*p++ + 0x100;
+ al_len = (UINT16) * p++ + 0x100;
}
/* max fragment length */
frag_len = (UINT16)(p_end - p);
/* if it isn't last fragment */
- if(frag_len >= al_len)
+ if (frag_len >= al_len) {
frag_len = al_len;
+ }
/* check TSID corresponds to config */
- if (al_tsid != p_scb->curr_cfg.mux_tsid_media)
- {
+ if (al_tsid != p_scb->curr_cfg.mux_tsid_media) {
#if AVDT_REPORTING == TRUE
- if((p_scb->curr_cfg.psc_mask & AVDT_PSC_REPORT) &&
- (al_tsid == p_scb->curr_cfg.mux_tsid_report))
- {
+ if ((p_scb->curr_cfg.psc_mask & AVDT_PSC_REPORT) &&
+ (al_tsid == p_scb->curr_cfg.mux_tsid_report)) {
/* parse reporting packet */
p = avdt_scb_hdl_report(p_scb, p, frag_len);
continue;
- }
- else
+ } else
#endif
{
AVDT_TRACE_WARNING("bad tsid: %d, mux_tsid_media:%d\n", al_tsid, p_scb->curr_cfg.mux_tsid_media);
}
}
/* check are buffer for assembling and related callback set */
- else if ((p_scb->p_media_buf == NULL) || (p_scb->cs.p_media_cback == NULL))
- {
+ else if ((p_scb->p_media_buf == NULL) || (p_scb->cs.p_media_cback == NULL)) {
AVDT_TRACE_WARNING("NULL p_media_buf or p_media_cback");
break;
}
/* it is media fragment beginning */
- if(!al_frag) /* is it first fragment of original media packet */
- {
+ if (!al_frag) { /* is it first fragment of original media packet */
AVDT_TRACE_DEBUG("al:%d media:%d\n",
- al_len, p_scb->media_buf_len);
+ al_len, p_scb->media_buf_len);
p_scb->frag_off = 0;
p_scb->frag_org_len = al_len; /* total length of original media packet */
/* length check: minimum length of media header is 12 */
- if (p_scb->frag_org_len < 12)
- {
+ if (p_scb->frag_org_len < 12) {
AVDT_TRACE_WARNING("bad al_len: %d(<12)\n", al_len);
break;
}
/* check that data fit into buffer */
- if (al_len > p_scb->media_buf_len)
- {
+ if (al_len > p_scb->media_buf_len) {
AVDT_TRACE_WARNING("bad al_len: %d(>%d)\n", al_len, p_scb->media_buf_len);
break;
}
/* make sure it is the last fragment in l2cap packet */
- if (p + al_len < p_end)
- {
+ if (p + al_len < p_end) {
AVDT_TRACE_WARNING("bad al_len: %d(>%d)\n", al_len, p_scb->media_buf_len);
break;
}
- }
- else
- {
+ } else {
AVDT_TRACE_DEBUG("al:%d media:%d frag_org_len:%d frag_off:%d\n",
- al_len, p_scb->media_buf_len, p_scb->frag_org_len, p_scb->frag_off);
+ al_len, p_scb->media_buf_len, p_scb->frag_org_len, p_scb->frag_off);
/* check that remaining length from AL header equals to original len - length of already received fragments */
- if(al_len != p_scb->frag_org_len - p_scb->frag_off)
- {
+ if (al_len != p_scb->frag_org_len - p_scb->frag_off) {
AVDT_TRACE_WARNING("al_len:%d != (frag_org_len:%d - frag_off:%d) %d\n",
- al_len, p_scb->frag_org_len, p_scb->frag_off,
- (p_scb->frag_org_len- p_scb->frag_off));
+ al_len, p_scb->frag_org_len, p_scb->frag_off,
+ (p_scb->frag_org_len - p_scb->frag_off));
break;
}
/* do sanity check */
- if (p_scb->frag_off == 0)
- {
+ if (p_scb->frag_off == 0) {
AVDT_TRACE_WARNING("frag_off=0");
break;
}
}
/* do common sanity check */
- if((p_scb->frag_org_len <= p_scb->frag_off) || (p_scb->frag_org_len >= p_scb->media_buf_len))
- {
+ if ((p_scb->frag_org_len <= p_scb->frag_off) || (p_scb->frag_org_len >= p_scb->media_buf_len)) {
AVDT_TRACE_WARNING("common sanity frag_off:%d frag_org_len:%d media_buf_len:%d\n",
- p_scb->frag_off, p_scb->frag_org_len, p_scb->media_buf_len);
+ p_scb->frag_off, p_scb->frag_org_len, p_scb->media_buf_len);
break;
}
AVDT_TRACE_DEBUG("Received fragment org_len=%d off=%d al_len=%d frag_len=%d\n",
- p_scb->frag_org_len, p_scb->frag_off, al_len, frag_len);
+ p_scb->frag_org_len, p_scb->frag_off, al_len, frag_len);
/* copy fragment into buffer */
memcpy(p_scb->p_media_buf + p_scb->frag_off, p, frag_len);
/* move to the next fragment */
p += frag_len;
/* if it is last fragment in original media packet then process total media pocket */
- if(p_scb->frag_off == p_scb->frag_org_len)
- {
+ if (p_scb->frag_off == p_scb->frag_org_len) {
p_payload = p_scb->p_media_buf;
/* media header */
p_payload += o_cc * 4;
/* check for and skip over extension header */
- if (o_x)
- {
- if(p_scb->p_media_buf + p_scb->frag_off - p_payload < 4)
- {
+ if (o_x) {
+ if (p_scb->p_media_buf + p_scb->frag_off - p_payload < 4) {
AVDT_TRACE_WARNING("length check frag_off:%d p_media_buf:%p p_payload:%p\n",
- p_scb->frag_off, p_scb->p_media_buf, p_payload);
+ p_scb->frag_off, p_scb->p_media_buf, p_payload);
break;/* length check */
}
p_payload += 2;
p_payload += ex_len * 4;
}
- if(p_payload >= p_scb->p_media_buf + p_scb->frag_off)
- {
+ if (p_payload >= p_scb->p_media_buf + p_scb->frag_off) {
AVDT_TRACE_WARNING("length check2 frag_off:%d p_media_buf:%p p_payload:%p\n",
- p_scb->frag_off, p_scb->p_media_buf, p_payload);
+ p_scb->frag_off, p_scb->p_media_buf, p_payload);
break;/* length check */
}
/* adjust length for any padding at end of packet */
- if (o_p)
- {
+ if (o_p) {
/* padding length in last byte of packet */
pad_len = *(p_scb->p_media_buf + p_scb->frag_off - 1);
- }
- else
+ } else {
pad_len = 0;
+ }
/* payload length */
payload_len = (UINT32)(p_scb->p_media_buf + p_scb->frag_off - pad_len - p_payload);
AVDT_TRACE_DEBUG("Received last fragment header=%d len=%d\n",
- p_payload - p_scb->p_media_buf,payload_len);
+ p_payload - p_scb->p_media_buf, payload_len);
/* send total media packet up */
- if (p_scb->cs.p_media_cback != NULL)
- {
+ if (p_scb->cs.p_media_cback != NULL) {
(*p_scb->cs.p_media_cback)(avdt_scb_to_hdl(p_scb), p_payload,
payload_len, time_stamp, seq, m_pt, marker);
}
}
} /* while(p < p_end) */
- if(p < p_end)
- {
+ if (p < p_end) {
AVDT_TRACE_WARNING("*** Got bad media packet");
}
GKI_freebuf(p_data->p_pkt);
#if AVDT_MULTIPLEXING == TRUE
/* select right function in dependance of is fragmentation supported or not */
- if( 0 != (p_scb->curr_cfg.psc_mask & AVDT_PSC_MUX))
- {
+ if ( 0 != (p_scb->curr_cfg.psc_mask & AVDT_PSC_MUX)) {
avdt_scb_hdl_pkt_frag(p_scb, p_data);
- }
- else
+ } else
#endif
#if AVDT_REPORTING == TRUE
- if(p_data->p_pkt->layer_specific == AVDT_CHAN_REPORT)
- {
- p = (UINT8 *)(p_data->p_pkt + 1) + p_data->p_pkt->offset;
- avdt_scb_hdl_report(p_scb, p, p_data->p_pkt->len);
- GKI_freebuf(p_data->p_pkt);
- }
- else
+ if (p_data->p_pkt->layer_specific == AVDT_CHAN_REPORT) {
+ p = (UINT8 *)(p_data->p_pkt + 1) + p_data->p_pkt->offset;
+ avdt_scb_hdl_report(p_scb, p, p_data->p_pkt->len);
+ GKI_freebuf(p_data->p_pkt);
+ } else
#endif
- avdt_scb_hdl_pkt_no_frag(p_scb, p_data);
+ avdt_scb_hdl_pkt_no_frag(p_scb, p_data);
}
/*******************************************************************************
void avdt_scb_hdl_reconfig_cmd(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
{
/* if command not supported */
- if (p_scb->cs.nsc_mask & AVDT_NSC_RECONFIG)
- {
+ if (p_scb->cs.nsc_mask & AVDT_NSC_RECONFIG) {
/* send reject */
p_data->msg.hdr.err_code = AVDT_ERR_NSC;
p_data->msg.hdr.err_param = 0;
avdt_scb_event(p_scb, AVDT_SCB_API_RECONFIG_RSP_EVT, p_data);
- }
- else
- {
+ } else {
/* store requested configuration */
memcpy(&p_scb->req_cfg, p_data->msg.reconfig_cmd.p_cfg, sizeof(tAVDT_CFG));
*******************************************************************************/
void avdt_scb_hdl_reconfig_rsp(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
{
- if (p_data->msg.hdr.err_code == 0)
- {
+ if (p_data->msg.hdr.err_code == 0) {
/* store new configuration */
- if (p_scb->req_cfg.num_codec > 0)
- {
+ if (p_scb->req_cfg.num_codec > 0) {
p_scb->curr_cfg.num_codec = p_scb->req_cfg.num_codec;
memcpy(p_scb->curr_cfg.codec_info, p_scb->req_cfg.codec_info, AVDT_CODEC_SIZE);
}
- if (p_scb->req_cfg.num_protect > 0)
- {
+ if (p_scb->req_cfg.num_protect > 0) {
p_scb->curr_cfg.num_protect = p_scb->req_cfg.num_protect;
memcpy(p_scb->curr_cfg.protect_info, p_scb->req_cfg.protect_info, AVDT_PROTECT_SIZE);
}
void avdt_scb_hdl_security_cmd(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
{
/* if command not supported */
- if (p_scb->cs.nsc_mask & AVDT_NSC_SECURITY)
- {
+ if (p_scb->cs.nsc_mask & AVDT_NSC_SECURITY) {
/* send reject */
p_data->msg.hdr.err_code = AVDT_ERR_NSC;
avdt_scb_event(p_scb, AVDT_SCB_API_SECURITY_RSP_EVT, p_data);
- }
- else
- {
+ } else {
/* call application callback */
(*p_scb->cs.p_ctrl_cback)(avdt_scb_to_hdl(p_scb),
NULL,
{
tAVDT_CFG *p_cfg;
- if (!p_scb->in_use)
- {
+ if (!p_scb->in_use) {
p_cfg = p_data->msg.config_cmd.p_cfg;
- if(p_scb->cs.cfg.codec_info[AVDT_CODEC_TYPE_INDEX] == p_cfg->codec_info[AVDT_CODEC_TYPE_INDEX])
- {
+ if (p_scb->cs.cfg.codec_info[AVDT_CODEC_TYPE_INDEX] == p_cfg->codec_info[AVDT_CODEC_TYPE_INDEX]) {
/* set sep as in use */
p_scb->in_use = TRUE;
p_scb->p_ccb ? p_scb->p_ccb->peer_addr : NULL,
AVDT_CONFIG_IND_EVT,
(tAVDT_CTRL *) &p_data->msg.config_cmd);
- }
- else
- {
+ } else {
p_data->msg.hdr.err_code = AVDT_ERR_UNSUP_CFG;
p_data->msg.hdr.err_param = 0;
avdt_msg_send_rej(avdt_ccb_by_idx(p_data->msg.hdr.ccb_idx),
p_data->msg.hdr.sig_id, &p_data->msg);
}
- }
- else
- {
+ } else {
avdt_scb_rej_in_use(p_scb, p_data);
}
}
tAVDT_EVT_HDR single;
UNUSED(p_data);
- if (p_scb->p_ccb != NULL)
- {
+ if (p_scb->p_ccb != NULL) {
/* save configuration */
memcpy(&p_scb->curr_cfg, &p_scb->req_cfg, sizeof(tAVDT_CFG));
p_scb->cong = FALSE;
/* free pkt we're holding, if any */
- if (p_scb->p_pkt != NULL)
- {
+ if (p_scb->p_pkt != NULL) {
GKI_freebuf(p_scb->p_pkt);
p_scb->p_pkt = NULL;
}
/* stop transport channel timer */
btu_stop_timer(&p_scb->timer_entry);
- if ((p_scb->role == AVDT_CLOSE_INT) || (p_scb->role == AVDT_OPEN_INT))
- {
+ if ((p_scb->role == AVDT_CLOSE_INT) || (p_scb->role == AVDT_OPEN_INT)) {
/* tell ccb we're done with signaling channel */
avdt_ccb_event(p_ccb, AVDT_CCB_UL_CLOSE_EVT, NULL);
}
event = (p_scb->role == AVDT_CLOSE_INT) ? AVDT_CLOSE_CFM_EVT : AVDT_CLOSE_IND_EVT;
p_scb->role = AVDT_CLOSE_ACP;
- if (p_scb->remove)
- {
+ if (p_scb->remove) {
avdt_scb_dealloc(p_scb, NULL);
}
AVDT_DELAY_REPORT_EVT,
(tAVDT_CTRL *) &p_data->msg.hdr);
- if (p_scb->p_ccb)
+ if (p_scb->p_ccb) {
avdt_msg_send_rsp(p_scb->p_ccb, AVDT_SIG_DELAY_RPT, &p_data->msg);
- else
+ } else {
avdt_scb_rej_not_in_use(p_scb, p_data);
+ }
}
/*******************************************************************************
{
tAVDT_CTRL avdt_ctrl;
/* AVDT_CHAN_SIG does not visit this action */
- if(p_data && p_data->close.type != AVDT_CHAN_MEDIA)
- {
+ if (p_data && p_data->close.type != AVDT_CHAN_MEDIA) {
/* it's reporting or recovery channel,
* the channel close in open state means the peer does not support it */
- if(p_data->close.old_tc_state == AVDT_AD_ST_OPEN)
- {
+ if (p_data->close.old_tc_state == AVDT_AD_ST_OPEN) {
avdt_ctrl.hdr.err_code = 0;
avdt_ctrl.hdr.err_param = 0;
/* call app callback */
p_scb->p_ccb ? p_scb->p_ccb->peer_addr : NULL,
AVDT_REPORT_DISCONN_EVT, &avdt_ctrl);
}
- }
- else
- {
+ } else {
/* must be in OPEN state. need to go back to idle */
avdt_scb_event(p_scb, AVDT_SCB_MSG_ABORT_RSP_EVT, NULL);
avdt_scb_hdl_tc_close(p_scb, p_data);
p_data->open.hdr.err_code = 0;
AVDT_TRACE_DEBUG("psc_mask: cfg: 0x%x, req:0x%x, cur: 0x%x\n",
- p_scb->cs.cfg.psc_mask, p_scb->req_cfg.psc_mask, p_scb->curr_cfg.psc_mask);
+ p_scb->cs.cfg.psc_mask, p_scb->req_cfg.psc_mask, p_scb->curr_cfg.psc_mask);
#if AVDT_REPORTING == TRUE
- if(p_scb->curr_cfg.psc_mask & AVDT_PSC_REPORT)
- {
+ if (p_scb->curr_cfg.psc_mask & AVDT_PSC_REPORT) {
/* open the reporting channel, if both devices support it */
role = (p_scb->role == AVDT_OPEN_INT) ? AVDT_INT : AVDT_ACP;
avdt_ad_open_req(AVDT_CHAN_REPORT, p_scb->p_ccb, p_scb, role);
/* open reporting channel here, when it is implemented */
/* call app callback */
- if(p_data->open.hdr.err_code == AVDT_CHAN_REPORT)
- {
+ if (p_data->open.hdr.err_code == AVDT_CHAN_REPORT) {
avdt_ctrl.hdr.err_code = 0;
avdt_ctrl.hdr.err_param = 1;
(*p_scb->cs.p_ctrl_cback)(avdt_scb_to_hdl(p_scb),
- p_scb->p_ccb ? p_scb->p_ccb->peer_addr : NULL,
- AVDT_REPORT_CONN_EVT, &avdt_ctrl);
+ p_scb->p_ccb ? p_scb->p_ccb->peer_addr : NULL,
+ AVDT_REPORT_CONN_EVT, &avdt_ctrl);
}
}
#endif
UINT32 ssrc;
/* free packet we're holding, if any; to be replaced with new */
- if (p_scb->p_pkt != NULL)
- {
+ if (p_scb->p_pkt != NULL) {
GKI_freebuf(p_scb->p_pkt);
/* this shouldn't be happening */
/* build a media packet */
/* Add RTP header if required */
- if ( !(p_data->apiwrite.opt & AVDT_DATA_OPT_NO_RTP) )
- {
+ if ( !(p_data->apiwrite.opt & AVDT_DATA_OPT_NO_RTP) ) {
ssrc = avdt_scb_gen_ssrc(p_scb);
p_data->apiwrite.p_buf->len += AVDT_MEDIA_HDR_SIZE;
BT_HDR *p_frag;
/* free fragments we're holding, if any; it shouldn't happen */
- if (!GKI_queue_is_empty(&p_scb->frag_q))
- {
- while((p_frag = (BT_HDR*)GKI_dequeue (&p_scb->frag_q)) != NULL)
+ if (!GKI_queue_is_empty(&p_scb->frag_q)) {
+ while ((p_frag = (BT_HDR *)GKI_dequeue (&p_scb->frag_q)) != NULL) {
GKI_freebuf(p_frag);
+ }
/* this shouldn't be happening */
AVDT_TRACE_WARNING("*** Dropped media packet; congested");
ssrc = avdt_scb_gen_ssrc(p_scb);
/* get first packet */
- p_frag = (BT_HDR*)GKI_getfirst (&p_data->apiwrite.frag_q);
+ p_frag = (BT_HDR *)GKI_getfirst (&p_data->apiwrite.frag_q);
/* posit on Adaptation Layer header */
p_frag->len += AVDT_AL_HDR_SIZE + AVDT_MEDIA_HDR_SIZE;
p_frag->offset -= AVDT_AL_HDR_SIZE + AVDT_MEDIA_HDR_SIZE;
/* Adaptation Layer header */
/* TSID, no-fragment bit and coding of length(in 2 length octets following) */
- *p++ = (p_scb->curr_cfg.mux_tsid_media<<3) | AVDT_ALH_LCODE_16BIT;
+ *p++ = (p_scb->curr_cfg.mux_tsid_media << 3) | AVDT_ALH_LCODE_16BIT;
/* length of all remaining transport packet */
- UINT16_TO_BE_STREAM(p, p_frag->layer_specific+AVDT_MEDIA_HDR_SIZE );
+ UINT16_TO_BE_STREAM(p, p_frag->layer_specific + AVDT_MEDIA_HDR_SIZE );
/* media header */
UINT8_TO_BE_STREAM(p, AVDT_MEDIA_OCTET1);
UINT8_TO_BE_STREAM(p, p_data->apiwrite.m_pt);
UINT32_TO_BE_STREAM(p, ssrc);
p_scb->media_seq++;
- while((p_frag = (BT_HDR*)GKI_getnext (p_frag)) != NULL)
- {
+ while ((p_frag = (BT_HDR *)GKI_getnext (p_frag)) != NULL) {
/* posit on Adaptation Layer header */
p_frag->len += AVDT_AL_HDR_SIZE;
p_frag->offset -= AVDT_AL_HDR_SIZE;
p = (UINT8 *)(p_frag + 1) + p_frag->offset;
/* Adaptation Layer header */
/* TSID, fragment bit and coding of length(in 2 length octets following) */
- *p++ = (p_scb->curr_cfg.mux_tsid_media<<3) | (AVDT_ALH_FRAG_MASK|AVDT_ALH_LCODE_16BIT);
+ *p++ = (p_scb->curr_cfg.mux_tsid_media << 3) | (AVDT_ALH_FRAG_MASK | AVDT_ALH_LCODE_16BIT);
/* length of all remaining transport packet */
UINT16_TO_BE_STREAM(p, p_frag->layer_specific );
#endif
avdt_scb_hdl_write_req_no_frag(p_scb, p_data);
#if AVDT_MULTIPLEXING == TRUE
- else
+ else {
avdt_scb_hdl_write_req_frag(p_scb, p_data);
+ }
#endif
}
tAVDT_EVT_HDR hdr;
UNUSED(p_data);
- if (p_scb->p_ccb != NULL)
- {
+ if (p_scb->p_ccb != NULL) {
p_scb->role = AVDT_CLOSE_INT;
hdr.seid = p_scb->peer_seid;
BT_HDR *p_frag;
AVDT_TRACE_WARNING("avdt_scb_snd_stream_close c:%d, off:%d\n",
- GKI_queue_length(&p_scb->frag_q), p_scb->frag_off);
+ GKI_queue_length(&p_scb->frag_q), p_scb->frag_off);
/* clean fragments queue */
- while((p_frag = (BT_HDR*)GKI_dequeue (&p_scb->frag_q)) != NULL)
- GKI_freebuf(p_frag);
+ while ((p_frag = (BT_HDR *)GKI_dequeue (&p_scb->frag_q)) != NULL) {
+ GKI_freebuf(p_frag);
+ }
p_scb->frag_off = 0;
#endif
- if (p_scb->p_pkt)
- {
+ if (p_scb->p_pkt) {
GKI_freebuf(p_scb->p_pkt);
p_scb->p_pkt = NULL;
}
#if 0
- if(p_scb->cong)
+ if (p_scb->cong) {
p_scb->cong = FALSE;
+ }
/* p_scb->curr_cfg.mux_tsid_media == 0 */
#endif
*******************************************************************************/
void avdt_scb_snd_reconfig_rsp(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
{
- if (p_data->msg.hdr.err_code == 0)
- {
+ if (p_data->msg.hdr.err_code == 0) {
/* store new configuration */
- if (p_scb->req_cfg.num_codec > 0)
- {
+ if (p_scb->req_cfg.num_codec > 0) {
p_scb->curr_cfg.num_codec = p_scb->req_cfg.num_codec;
memcpy(p_scb->curr_cfg.codec_info, p_scb->req_cfg.codec_info, AVDT_CODEC_SIZE);
}
- if (p_scb->req_cfg.num_protect > 0)
- {
+ if (p_scb->req_cfg.num_protect > 0) {
p_scb->curr_cfg.num_protect = p_scb->req_cfg.num_protect;
memcpy(p_scb->curr_cfg.protect_info, p_scb->req_cfg.protect_info, AVDT_PROTECT_SIZE);
}
/* send response */
avdt_msg_send_rsp(p_scb->p_ccb, AVDT_SIG_RECONFIG, &p_data->msg);
- }
- else
- {
+ } else {
/* send reject */
avdt_msg_send_rej(p_scb->p_ccb, AVDT_SIG_RECONFIG, &p_data->msg);
}
*******************************************************************************/
void avdt_scb_snd_security_rsp(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
{
- if (p_data->msg.hdr.err_code == 0)
- {
+ if (p_data->msg.hdr.err_code == 0) {
avdt_msg_send_rsp(p_scb->p_ccb, AVDT_SIG_SECURITY, &p_data->msg);
- }
- else
- {
+ } else {
avdt_msg_send_rej(p_scb->p_ccb, AVDT_SIG_SECURITY, &p_data->msg);
}
}
*******************************************************************************/
void avdt_scb_snd_setconfig_rej(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
{
- if (p_scb->p_ccb != NULL)
- {
+ if (p_scb->p_ccb != NULL) {
avdt_msg_send_rej(p_scb->p_ccb, AVDT_SIG_SETCONFIG, &p_data->msg);
/* clear scb variables */
#if AVDT_MULTIPLEXING == TRUE
p_req->mux_tsid_media = p_cfg->mux_tsid_media;
p_req->mux_tcid_media = p_cfg->mux_tcid_media;
- if(p_req->psc_mask & AVDT_PSC_REPORT)
- {
+ if (p_req->psc_mask & AVDT_PSC_REPORT) {
p_req->mux_tsid_report = p_cfg->mux_tsid_report;
p_req->mux_tcid_report = p_cfg->mux_tcid_report;
}
*******************************************************************************/
void avdt_scb_snd_setconfig_rsp(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
{
- if (p_scb->p_ccb != NULL)
- {
+ if (p_scb->p_ccb != NULL) {
memcpy(&p_scb->curr_cfg, &p_scb->req_cfg, sizeof(tAVDT_CFG));
avdt_msg_send_rsp(p_scb->p_ccb, AVDT_SIG_SETCONFIG, &p_data->msg);
UNUSED(p_data);
#if AVDT_REPORTING == TRUE
- if(p_scb->curr_cfg.psc_mask & AVDT_PSC_REPORT)
+ if (p_scb->curr_cfg.psc_mask & AVDT_PSC_REPORT) {
avdt_ad_close_req(AVDT_CHAN_REPORT, p_scb->p_ccb, p_scb);
+ }
#endif
avdt_ad_close_req(AVDT_CHAN_MEDIA, p_scb->p_ccb, p_scb);
}
avdt_ctrl.hdr.err_param = 0;
/* p_buf can be NULL in case using of fragments queue frag_q */
- if(p_data->apiwrite.p_buf)
+ if (p_data->apiwrite.p_buf) {
GKI_freebuf(p_data->apiwrite.p_buf);
+ }
#if AVDT_MULTIPLEXING == TRUE
/* clean fragments queue */
- while((p_frag = (BT_HDR*)GKI_dequeue (&p_data->apiwrite.frag_q)) != NULL)
- GKI_freebuf(p_frag);
+ while ((p_frag = (BT_HDR *)GKI_dequeue (&p_data->apiwrite.frag_q)) != NULL) {
+ GKI_freebuf(p_frag);
+ }
#endif
AVDT_TRACE_WARNING("Dropped media packet");
avdt_ctrl.hdr.err_code = AVDT_ERR_BAD_STATE;
avdt_ctrl.hdr.err_param = 0;
/* flush the media data queued at L2CAP */
- if((p_ccb = p_scb->p_ccb) != NULL)
- {
+ if ((p_ccb = p_scb->p_ccb) != NULL) {
/* get tcid from type, scb */
tcid = avdt_ad_type_to_tcid(AVDT_CHAN_MEDIA, p_scb);
L2CA_FlushChannel (lcid, L2CAP_FLUSH_CHANS_ALL);
}
- if (p_scb->p_pkt != NULL)
- {
+ if (p_scb->p_pkt != NULL) {
GKI_freebuf(p_scb->p_pkt);
p_scb->p_pkt = NULL;
&avdt_ctrl);
}
#if AVDT_MULTIPLEXING == TRUE
- else if(!GKI_queue_is_empty (&p_scb->frag_q))
- {
+ else if (!GKI_queue_is_empty (&p_scb->frag_q)) {
AVDT_TRACE_DEBUG("Dropped fragments queue");
/* clean fragments queue */
- while((p_frag = (BT_HDR*)GKI_dequeue (&p_scb->frag_q)) != NULL)
- GKI_freebuf(p_frag);
+ while ((p_frag = (BT_HDR *)GKI_dequeue (&p_scb->frag_q)) != NULL) {
+ GKI_freebuf(p_frag);
+ }
p_scb->frag_off = 0;
avdt_ctrl.hdr.err_code = 0;
- if (!p_scb->cong)
- {
- if (p_scb->p_pkt != NULL)
- {
+ if (!p_scb->cong) {
+ if (p_scb->p_pkt != NULL) {
p_pkt = p_scb->p_pkt;
p_scb->p_pkt = NULL;
avdt_ad_write_req(AVDT_CHAN_MEDIA, p_scb->p_ccb, p_scb, p_pkt);
(*p_scb->cs.p_ctrl_cback)(avdt_scb_to_hdl(p_scb), NULL, AVDT_WRITE_CFM_EVT, &avdt_ctrl);
}
#if AVDT_MULTIPLEXING == TRUE
- else
- {
+ else {
#if 0
AVDT_TRACE_DEBUG("num_q=%d\n",
- L2CA_FlushChannel(avdt_cb.ad.rt_tbl[avdt_ccb_to_idx(p_scb->p_ccb)][avdt_ad_type_to_tcid(AVDT_CHAN_MEDIA, p_scb)].lcid),
- L2CAP_FLUSH_CHANS_GET);
+ L2CA_FlushChannel(avdt_cb.ad.rt_tbl[avdt_ccb_to_idx(p_scb->p_ccb)][avdt_ad_type_to_tcid(AVDT_CHAN_MEDIA, p_scb)].lcid),
+ L2CAP_FLUSH_CHANS_GET);
#endif
- while((p_pkt = (BT_HDR*)GKI_dequeue (&p_scb->frag_q)) != NULL)
- {
+ while ((p_pkt = (BT_HDR *)GKI_dequeue (&p_scb->frag_q)) != NULL) {
sent = TRUE;
- AVDT_TRACE_DEBUG("Send fragment len=%d\n",p_pkt->len);
+ AVDT_TRACE_DEBUG("Send fragment len=%d\n", p_pkt->len);
/* fragments queue contains fragment to send */
res = avdt_ad_write_req(AVDT_CHAN_MEDIA, p_scb->p_ccb, p_scb, p_pkt);
- if(AVDT_AD_CONGESTED == res)
- {
+ if (AVDT_AD_CONGESTED == res) {
p_scb->cong = TRUE;
AVDT_TRACE_DEBUG("avdt/l2c congested!!");
break;/* exit loop if channel became congested */
+ }
}
- }
- AVDT_TRACE_DEBUG("res=%d left=%d\n",res, p_scb->frag_off);
+ AVDT_TRACE_DEBUG("res=%d left=%d\n", res, p_scb->frag_off);
- if(p_scb->frag_off)
- {
- if(AVDT_AD_SUCCESS == res || GKI_queue_is_empty (&p_scb->frag_q))
- {
+ if (p_scb->frag_off) {
+ if (AVDT_AD_SUCCESS == res || GKI_queue_is_empty (&p_scb->frag_q)) {
/* all buffers were sent to L2CAP, compose more to queue */
avdt_scb_queue_frags(p_scb, &p_scb->p_next_frag, &p_scb->frag_off, &p_scb->frag_q);
- if(!GKI_queue_is_empty (&p_scb->frag_q))
- {
+ if (!GKI_queue_is_empty (&p_scb->frag_q)) {
data.llcong = p_scb->cong;
avdt_scb_event(p_scb, AVDT_SCB_TC_CONG_EVT, &data);
}
}
/* Send event AVDT_WRITE_CFM_EVT if it was last fragment */
- else if (sent && GKI_queue_is_empty (&p_scb->frag_q))
- {
+ else if (sent && GKI_queue_is_empty (&p_scb->frag_q)) {
(*p_scb->cs.p_ctrl_cback)(avdt_scb_to_hdl(p_scb), NULL, AVDT_WRITE_CFM_EVT, &avdt_ctrl);
}
}
{
UNUSED(p_data);
- if ((p_scb->cs.tsep == AVDT_TSEP_SNK) && (!p_scb->sink_activated))
- {
+ if ((p_scb->cs.tsep == AVDT_TSEP_SNK) && (!p_scb->sink_activated)) {
p_scb->in_use = TRUE;
- }
- else
- {
+ } else {
p_scb->in_use = FALSE;
}
p_scb->p_ccb = NULL;
tcid = avdt_ad_type_to_tcid(AVDT_CHAN_MEDIA, p_scb);
lcid = avdt_cb.ad.rt_tbl[avdt_ccb_to_idx(p_scb->p_ccb)][tcid].lcid;
- if( p_scb->frag_off != 0)
- {
+ if ( p_scb->frag_off != 0) {
/* continuing process is usually triggered by un-congest event.
* the number of buffers at L2CAP is very small (if not 0).
* we do not need to L2CA_FlushChannel() */
offset = cont_offset;
al_hdr = TRUE;
num_frag = AVDT_MAX_FRAG_COUNT;
- }
- else
- {
+ } else {
num_frag = L2CA_FlushChannel(lcid, L2CAP_FLUSH_CHANS_GET);
AVDT_TRACE_DEBUG("num_q=%d lcid=%d\n", num_frag, lcid);
- if(num_frag >= AVDT_MAX_FRAG_COUNT)
- {
+ if (num_frag >= AVDT_MAX_FRAG_COUNT) {
num_frag = 0;
- }
- else
- {
+ } else {
num_frag = AVDT_MAX_FRAG_COUNT - num_frag;
}
}
p_tbl = avdt_ad_tc_tbl_by_type(AVDT_CHAN_MEDIA, p_scb->p_ccb, p_scb);
buf_size = p_tbl->peer_mtu + BT_HDR_SIZE;
AVDT_TRACE_DEBUG("peer_mtu: %d, buf_size: %d num_frag=%d\n",
- p_tbl->peer_mtu, buf_size, num_frag);
+ p_tbl->peer_mtu, buf_size, num_frag);
- if(buf_size > AVDT_DATA_POOL_SIZE)
+ if (buf_size > AVDT_DATA_POOL_SIZE) {
buf_size = AVDT_DATA_POOL_SIZE;
+ }
mtu_used = buf_size - BT_HDR_SIZE;
- while(*p_data_len && num_frag)
- {
+ while (*p_data_len && num_frag) {
/* allocate buffer for fragment */
- if(NULL == (p_frag = (BT_HDR*)GKI_getbuf(buf_size)))
- {
- AVDT_TRACE_WARNING("avdt_scb_queue_frags len=%d(out of GKI buffers)\n",*p_data_len);
+ if (NULL == (p_frag = (BT_HDR *)GKI_getbuf(buf_size))) {
+ AVDT_TRACE_WARNING("avdt_scb_queue_frags len=%d(out of GKI buffers)\n", *p_data_len);
break;
}
/* fill fragment by chunk of media payload */
offset = cont_offset;
p_frag->len = mtu_used - p_frag->offset;
- if(p_frag->len > *p_data_len)
+ if (p_frag->len > *p_data_len) {
p_frag->len = *p_data_len;
- memcpy((UINT8*)(p_frag+1) + p_frag->offset, *pp_data, p_frag->len);
+ }
+ memcpy((UINT8 *)(p_frag + 1) + p_frag->offset, *pp_data, p_frag->len);
*pp_data += p_frag->len;
*p_data_len -= p_frag->len;
AVDT_TRACE_DEBUG("Prepared fragment len=%d\n", p_frag->len);
- if(al_hdr)
- {
+ if (al_hdr) {
/* Adaptation Layer header */
p_frag->len += AVDT_AL_HDR_SIZE;
p_frag->offset -= AVDT_AL_HDR_SIZE;
p = (UINT8 *)(p_frag + 1) + p_frag->offset;
/* TSID, fragment bit and coding of length(in 2 length octets following) */
- *p++ = (p_scb->curr_cfg.mux_tsid_media<<3) | (AVDT_ALH_FRAG_MASK|AVDT_ALH_LCODE_16BIT);
+ *p++ = (p_scb->curr_cfg.mux_tsid_media << 3) | (AVDT_ALH_FRAG_MASK | AVDT_ALH_LCODE_16BIT);
/* length of all remaining transport packet */
UINT16_TO_BE_STREAM(p, p_frag->layer_specific );
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#endif
-static const UINT8 avrc_ctrl_event_map[] =
-{
+static const UINT8 avrc_ctrl_event_map[] = {
AVRC_OPEN_IND_EVT, /* AVCT_CONNECT_CFM_EVT */
AVRC_OPEN_IND_EVT, /* AVCT_CONNECT_IND_EVT */
AVRC_CLOSE_IND_EVT, /* AVCT_DISCONNECT_CFM_EVT */
**
******************************************************************************/
static void avrc_ctrl_cback(UINT8 handle, UINT8 event, UINT16 result,
- BD_ADDR peer_addr)
+ BD_ADDR peer_addr)
{
UINT8 avrc_event;
- if (event <= AVRC_MAX_RCV_CTRL_EVT && avrc_cb.ccb[handle].p_ctrl_cback)
- {
+ if (event <= AVRC_MAX_RCV_CTRL_EVT && avrc_cb.ccb[handle].p_ctrl_cback) {
avrc_event = avrc_ctrl_event_map[event];
- if (event == AVCT_CONNECT_CFM_EVT)
- {
- if (result != 0) /* failed */
+ if (event == AVCT_CONNECT_CFM_EVT) {
+ if (result != 0) { /* failed */
avrc_event = AVRC_CLOSE_IND_EVT;
+ }
}
(*avrc_cb.ccb[handle].p_ctrl_cback)(handle, avrc_event, result, peer_addr);
}
** Returns A pointer to the data payload.
**
******************************************************************************/
-static UINT8 * avrc_get_data_ptr(BT_HDR *p_pkt)
+static UINT8 *avrc_get_data_ptr(BT_HDR *p_pkt)
{
return (UINT8 *)(p_pkt + 1) + p_pkt->offset;
}
** Returns The buffer with the copied data.
**
******************************************************************************/
-static BT_HDR * avrc_copy_packet(BT_HDR *p_pkt, int rsp_pkt_len)
+static BT_HDR *avrc_copy_packet(BT_HDR *p_pkt, int rsp_pkt_len)
{
const int offset = MAX(AVCT_MSG_OFFSET, p_pkt->offset);
const int pkt_len = MAX(rsp_pkt_len, p_pkt->len);
p_pkt_new = p_fcb->p_fmsg;
p_pkt_new->len -= (AVRC_MAX_CTRL_DATA_LEN - AVRC_VENDOR_HDR_SIZE - AVRC_MIN_META_HDR_SIZE);
p_pkt_new->offset += (AVRC_MAX_CTRL_DATA_LEN - AVRC_VENDOR_HDR_SIZE - AVRC_MIN_META_HDR_SIZE);
- p_data = (UINT8 *)(p_pkt_new+1) + p_pkt_new->offset;
+ p_data = (UINT8 *)(p_pkt_new + 1) + p_pkt_new->offset;
*p_data++ = rsp_type;
*p_data++ = (AVRC_SUB_PANEL << AVRC_SUBTYPE_SHIFT);
*p_data++ = AVRC_OP_VENDOR;
AVRC_TRACE_DEBUG("%s handle = %u label = %u len = %d",
__func__, handle, label, p_pkt->len);
- if (p_pkt->len > AVRC_MAX_CTRL_DATA_LEN)
- {
+ if (p_pkt->len > AVRC_MAX_CTRL_DATA_LEN) {
int offset_len = MAX(AVCT_MSG_OFFSET, p_pkt->offset);
p_pkt_old = p_fcb->p_fmsg;
p_pkt = (BT_HDR *)GKI_getbuf((UINT16)(AVRC_PACKET_LEN + offset_len + BT_HDR_SIZE));
- if (p_pkt)
- {
+ if (p_pkt) {
p_pkt->len = AVRC_MAX_CTRL_DATA_LEN;
p_pkt->offset = AVCT_MSG_OFFSET;
p_pkt->layer_specific = p_pkt_old->layer_specific;
p_pkt->event = p_pkt_old->event;
- p_old = (UINT8 *)(p_pkt_old+1) + p_pkt_old->offset;
- p_data = (UINT8 *)(p_pkt+1) + p_pkt->offset;
+ p_old = (UINT8 *)(p_pkt_old + 1) + p_pkt_old->offset;
+ p_data = (UINT8 *)(p_pkt + 1) + p_pkt->offset;
memcpy (p_data, p_old, AVRC_MAX_CTRL_DATA_LEN);
/* use AVRC continue packet type */
p_data += AVRC_VENDOR_HDR_SIZE;
/* prepare the left over for as an end fragment */
avrc_prep_end_frag (handle);
- }
- else
- {
+ } else {
/* use the current GKI buffer to send Internal error status */
p_pkt = p_fcb->p_fmsg;
p_fcb->p_fmsg = NULL;
p_fcb->frag_enabled = FALSE;
AVRC_TRACE_ERROR ("AVRC_MsgReq no buffers for fragmentation - send internal error" );
- p_data = (UINT8 *)(p_pkt+1) + p_pkt->offset;
+ p_data = (UINT8 *)(p_pkt + 1) + p_pkt->offset;
*p_data++ = AVRC_PDU_REQUEST_CONTINUATION_RSP;
*p_data++ = 0;
UINT16_TO_BE_STREAM(p_data, 0);
AVRC_BldResponse( handle, (tAVRC_RESPONSE *)&rej_rsp, &p_pkt);
cr = AVCT_RSP;
}
- }
- else
- {
+ } else {
/* end fragment. clean the control block */
p_fcb->frag_enabled = FALSE;
p_fcb->p_fmsg = NULL;
** Returns if not NULL, the response to send right away.
**
******************************************************************************/
-static BT_HDR * avrc_proc_vendor_command(UINT8 handle, UINT8 label,
- BT_HDR *p_pkt, tAVRC_MSG_VENDOR *p_msg)
+static BT_HDR *avrc_proc_vendor_command(UINT8 handle, UINT8 label,
+ BT_HDR *p_pkt, tAVRC_MSG_VENDOR *p_msg)
{
BT_HDR *p_rsp = NULL;
UINT8 *p_data;
tAVRC_STS status = AVRC_STS_NO_ERROR;
tAVRC_FRAG_CB *p_fcb;
- p_begin = (UINT8 *)(p_pkt+1) + p_pkt->offset;
+ p_begin = (UINT8 *)(p_pkt + 1) + p_pkt->offset;
p_data = p_begin + AVRC_VENDOR_HDR_SIZE;
pkt_type = *(p_data + 1) & AVRC_PKT_TYPE_MASK;
- if (pkt_type != AVRC_PKT_SINGLE)
- {
+ if (pkt_type != AVRC_PKT_SINGLE) {
/* reject - commands can only be in single packets at AVRCP level */
AVRC_TRACE_ERROR ("commands must be in single packet pdu:0x%x", *p_data );
/* use the current GKI buffer to send the reject */
status = AVRC_STS_BAD_CMD;
}
/* check if there are fragments waiting to be sent */
- else if (avrc_cb.fcb[handle].frag_enabled)
- {
+ else if (avrc_cb.fcb[handle].frag_enabled) {
p_fcb = &avrc_cb.fcb[handle];
- if (p_msg->company_id == AVRC_CO_METADATA)
- {
- switch (*p_data)
- {
+ if (p_msg->company_id == AVRC_CO_METADATA) {
+ switch (*p_data) {
case AVRC_PDU_ABORT_CONTINUATION_RSP:
/* aborted by CT - send accept response */
abort_frag = TRUE;
- p_begin = (UINT8 *)(p_pkt+1) + p_pkt->offset;
+ p_begin = (UINT8 *)(p_pkt + 1) + p_pkt->offset;
*p_begin = (AVRC_RSP_ACCEPT & AVRC_CTYPE_MASK);
- if (*(p_data + 4) != p_fcb->frag_pdu)
- {
+ if (*(p_data + 4) != p_fcb->frag_pdu) {
*p_begin = (AVRC_RSP_REJ & AVRC_CTYPE_MASK);
*(p_data + 4) = AVRC_STS_BAD_PARAM;
- }
- else
- {
+ } else {
p_data = (p_begin + AVRC_VENDOR_HDR_SIZE + 2);
UINT16_TO_BE_STREAM(p_data, 0);
p_pkt->len = (p_data - p_begin);
break;
case AVRC_PDU_REQUEST_CONTINUATION_RSP:
- if (*(p_data + 4) == p_fcb->frag_pdu)
- {
+ if (*(p_data + 4) == p_fcb->frag_pdu) {
avrc_send_continue_frag(handle, label);
p_msg->hdr.opcode = AVRC_OP_DROP_N_FREE;
- }
- else
- {
+ } else {
/* the pdu id does not match - reject the command using the current GKI buffer */
AVRC_TRACE_ERROR("avrc_proc_vendor_command continue pdu: 0x%x does not match \
current re-assembly pdu: 0x%x",
- *(p_data + 4), p_fcb->frag_pdu);
+ *(p_data + 4), p_fcb->frag_pdu);
status = AVRC_STS_BAD_PARAM;
abort_frag = TRUE;
}
/* implicit abort */
abort_frag = TRUE;
}
- }
- else
- {
+ } else {
abort_frag = TRUE;
/* implicit abort */
}
- if (abort_frag)
- {
- if (p_fcb->p_fmsg)
+ if (abort_frag) {
+ if (p_fcb->p_fmsg) {
GKI_freebuf(p_fcb->p_fmsg);
+ }
p_fcb->p_fmsg = NULL;
p_fcb->frag_enabled = FALSE;
}
}
- if (status != AVRC_STS_NO_ERROR)
- {
+ if (status != AVRC_STS_NO_ERROR) {
/* use the current GKI buffer to build/send the reject message */
- p_data = (UINT8 *)(p_pkt+1) + p_pkt->offset;
+ p_data = (UINT8 *)(p_pkt + 1) + p_pkt->offset;
*p_data++ = AVRC_RSP_REJ;
p_data += AVRC_VENDOR_HDR_SIZE; /* pdu */
*p_data++ = 0; /* pkt_type */
**
******************************************************************************/
static UINT8 avrc_proc_far_msg(UINT8 handle, UINT8 label, UINT8 cr, BT_HDR **pp_pkt,
- tAVRC_MSG_VENDOR *p_msg)
+ tAVRC_MSG_VENDOR *p_msg)
{
BT_HDR *p_pkt = *pp_pkt;
UINT8 *p_data;
tAVRC_RASM_CB *p_rcb;
tAVRC_NEXT_CMD avrc_cmd;
- p_data = (UINT8 *)(p_pkt+1) + p_pkt->offset;
+ p_data = (UINT8 *)(p_pkt + 1) + p_pkt->offset;
/* Skip over vendor header (ctype, subunit*, opcode, CO_ID) */
p_data += AVRC_VENDOR_HDR_SIZE;
pkt_type = *(p_data + 1) & AVRC_PKT_TYPE_MASK;
AVRC_TRACE_DEBUG ("pkt_type %d", pkt_type );
p_rcb = &avrc_cb.rcb[handle];
- if (p_msg->company_id == AVRC_CO_METADATA)
- {
+ if (p_msg->company_id == AVRC_CO_METADATA) {
/* check if the message needs to be re-assembled */
- if (pkt_type == AVRC_PKT_SINGLE || pkt_type == AVRC_PKT_START)
- {
+ if (pkt_type == AVRC_PKT_SINGLE || pkt_type == AVRC_PKT_START) {
/* previous fragments need to be dropped, when received another new message */
p_rcb->rasm_offset = 0;
- if (p_rcb->p_rmsg)
- {
+ if (p_rcb->p_rmsg) {
GKI_freebuf(p_rcb->p_rmsg);
p_rcb->p_rmsg = NULL;
}
}
- if (pkt_type != AVRC_PKT_SINGLE && cr == AVCT_RSP)
- {
+ if (pkt_type != AVRC_PKT_SINGLE && cr == AVCT_RSP) {
/* not a single response packet - need to re-assemble metadata messages */
- if (pkt_type == AVRC_PKT_START)
- {
+ if (pkt_type == AVRC_PKT_START) {
/* Allocate buffer for re-assembly */
p_rcb->rasm_pdu = *p_data;
- if ((p_rcb->p_rmsg = (BT_HDR *)GKI_getbuf(GKI_MAX_BUF_SIZE)) != NULL)
- {
+ if ((p_rcb->p_rmsg = (BT_HDR *)GKI_getbuf(GKI_MAX_BUF_SIZE)) != NULL) {
/* Copy START packet to buffer for re-assembling fragments*/
memcpy(p_rcb->p_rmsg, p_pkt, sizeof(BT_HDR)); /* Copy bt hdr */
/* Copy metadata message */
memcpy((UINT8 *)(p_rcb->p_rmsg + 1),
- (UINT8 *)(p_pkt+1) + p_pkt->offset, p_pkt->len);
+ (UINT8 *)(p_pkt + 1) + p_pkt->offset, p_pkt->len);
/* offset of start of metadata response in reassembly buffer */
p_rcb->p_rmsg->offset = p_rcb->rasm_offset = 0;
/* Free original START packet, replace with pointer to reassembly buffer */
GKI_freebuf(p_pkt);
*pp_pkt = p_rcb->p_rmsg;
- }
- else
- {
+ } else {
/* Unable to allocate buffer for fragmented avrc message. Reuse START
buffer for reassembly (re-assembled message may fit into ACL buf) */
AVRC_TRACE_DEBUG ("Unable to allocate buffer for fragmented avrc message, \
/* set offset to point to where to copy next - use the same re-asm logic as AVCT */
p_rcb->p_rmsg->offset += p_rcb->p_rmsg->len;
req_continue = TRUE;
- }
- else if (p_rcb->p_rmsg == NULL)
- {
+ } else if (p_rcb->p_rmsg == NULL) {
/* Received a CONTINUE/END, but no corresponding START
(or previous fragmented response was dropped) */
AVRC_TRACE_DEBUG ("Received a CONTINUE/END without no corresponding START \
drop_code = 5;
GKI_freebuf(p_pkt);
*pp_pkt = NULL;
- }
- else
- {
+ } else {
/* get size of buffer holding assembled message */
buf_len = GKI_get_buf_size (p_rcb->p_rmsg) - sizeof(BT_HDR);
/* adjust offset and len of fragment for header byte */
p_pkt->offset += (AVRC_VENDOR_HDR_SIZE + AVRC_MIN_META_HDR_SIZE);
p_pkt->len -= (AVRC_VENDOR_HDR_SIZE + AVRC_MIN_META_HDR_SIZE);
/* verify length */
- if ((p_rcb->p_rmsg->offset + p_pkt->len) > buf_len)
- {
+ if ((p_rcb->p_rmsg->offset + p_pkt->len) > buf_len) {
AVRC_TRACE_WARNING("Fragmented message too big! - report the partial message");
p_pkt->len = buf_len - p_rcb->p_rmsg->offset;
pkt_type = AVRC_PKT_END;
memcpy((UINT8 *)(p_rcb->p_rmsg + 1) + p_rcb->p_rmsg->offset,
(UINT8 *)(p_pkt + 1) + p_pkt->offset, p_pkt->len);
- if (pkt_type == AVRC_PKT_END)
- {
+ if (pkt_type == AVRC_PKT_END) {
p_rcb->p_rmsg->offset = p_rcb->rasm_offset;
p_rcb->p_rmsg->len += p_pkt->len;
p_pkt_new = p_rcb->p_rmsg;
p_rcb->rasm_offset = 0;
p_rcb->p_rmsg = NULL;
- p_msg->p_vendor_data = (UINT8 *)(p_pkt_new+1) + p_pkt_new->offset;
+ p_msg->p_vendor_data = (UINT8 *)(p_pkt_new + 1) + p_pkt_new->offset;
p_msg->hdr.ctype = p_msg->p_vendor_data[0] & AVRC_CTYPE_MASK;
/* 6 = ctype, subunit*, opcode & CO_ID */
p_msg->p_vendor_data += AVRC_VENDOR_HDR_SIZE;
*p_data++ = AVRC_PKT_SINGLE;
UINT16_TO_BE_STREAM(p_data, (p_msg->vendor_len - AVRC_MIN_META_HDR_SIZE));
AVRC_TRACE_DEBUG("end frag:%d, total len:%d, offset:%d", p_pkt->len,
- p_pkt_new->len, p_pkt_new->offset);
- }
- else
- {
+ p_pkt_new->len, p_pkt_new->offset);
+ } else {
p_rcb->p_rmsg->offset += p_pkt->len;
p_rcb->p_rmsg->len += p_pkt->len;
p_pkt_new = NULL;
}
}
- if (cr == AVCT_CMD)
- {
+ if (cr == AVCT_CMD) {
p_rsp = avrc_proc_vendor_command(handle, label, *pp_pkt, p_msg);
- if (p_rsp)
- {
+ if (p_rsp) {
AVCT_MsgReq( handle, label, AVCT_RSP, p_rsp);
drop_code = 3;
- }
- else if (p_msg->hdr.opcode == AVRC_OP_DROP)
- {
+ } else if (p_msg->hdr.opcode == AVRC_OP_DROP) {
drop_code = 1;
- }
- else if (p_msg->hdr.opcode == AVRC_OP_DROP_N_FREE)
+ } else if (p_msg->hdr.opcode == AVRC_OP_DROP_N_FREE) {
drop_code = 4;
+ }
- }
- else if (cr == AVCT_RSP && req_continue == TRUE)
- {
+ } else if (cr == AVCT_RSP && req_continue == TRUE) {
avrc_cmd.pdu = AVRC_PDU_REQUEST_CONTINUATION_RSP;
avrc_cmd.status = AVRC_STS_NO_ERROR;
avrc_cmd.target_pdu = p_rcb->rasm_pdu;
- if (AVRC_BldCommand ((tAVRC_COMMAND *)&avrc_cmd, &p_cmd) == AVRC_STS_NO_ERROR)
- {
+ if (AVRC_BldCommand ((tAVRC_COMMAND *)&avrc_cmd, &p_cmd) == AVRC_STS_NO_ERROR) {
drop_code = 2;
AVRC_MsgReq (handle, (UINT8)(label), AVRC_CMD_CTRL, p_cmd);
}
**
******************************************************************************/
static void avrc_msg_cback(UINT8 handle, UINT8 label, UINT8 cr,
- BT_HDR *p_pkt)
+ BT_HDR *p_pkt)
{
UINT8 opcode;
tAVRC_MSG msg;
tAVRC_MSG_VENDOR *p_msg = &msg.vendor;
if (cr == AVCT_CMD &&
- (p_pkt->layer_specific & AVCT_DATA_CTRL && AVRC_PACKET_LEN < sizeof(p_pkt->len)))
- {
+ (p_pkt->layer_specific & AVCT_DATA_CTRL && AVRC_PACKET_LEN < sizeof(p_pkt->len))) {
/* Ignore the invalid AV/C command frame */
#if (BT_USE_TRACES == TRUE)
p_drop_msg = "dropped - too long AV/C cmd frame size";
return;
}
- if (cr == AVCT_REJ)
- {
+ if (cr == AVCT_REJ) {
/* The peer thinks that this PID is no longer open - remove this handle */
/* */
GKI_freebuf(p_pkt);
return;
}
- p_data = (UINT8 *)(p_pkt+1) + p_pkt->offset;
+ p_data = (UINT8 *)(p_pkt + 1) + p_pkt->offset;
memset(&msg, 0, sizeof(tAVRC_MSG) );
{
msg.hdr.ctype = p_data[0] & AVRC_CTYPE_MASK;
AVRC_TRACE_DEBUG("avrc_msg_cback handle:%d, ctype:%d, offset:%d, len: %d",
- handle, msg.hdr.ctype, p_pkt->offset, p_pkt->len);
+ handle, msg.hdr.ctype, p_pkt->offset, p_pkt->len);
msg.hdr.subunit_type = (p_data[1] & AVRC_SUBTYPE_MASK) >> AVRC_SUBTYPE_SHIFT;
msg.hdr.subunit_id = p_data[1] & AVRC_SUBID_MASK;
opcode = p_data[2];
}
if ( ((avrc_cb.ccb[handle].control & AVRC_CT_TARGET) && (cr == AVCT_CMD)) ||
- ((avrc_cb.ccb[handle].control & AVRC_CT_CONTROL) && (cr == AVCT_RSP)) )
- {
+ ((avrc_cb.ccb[handle].control & AVRC_CT_CONTROL) && (cr == AVCT_RSP)) ) {
- switch(opcode)
- {
+ switch (opcode) {
case AVRC_OP_UNIT_INFO:
- if (cr == AVCT_CMD)
- {
+ if (cr == AVCT_CMD) {
/* send the response to the peer */
p_rsp = avrc_copy_packet(p_pkt, AVRC_OP_UNIT_INFO_RSP_LEN);
p_rsp_data = avrc_get_data_ptr(p_rsp);
#if (BT_USE_TRACES == TRUE)
p_drop_msg = "auto respond";
#endif
- }
- else
- {
+ } else {
/* parse response */
p_data += 4; /* 3 bytes: ctype, subunit*, opcode + octet 3 (is 7)*/
msg.unit.unit_type = (*p_data & AVRC_SUBTYPE_MASK) >> AVRC_SUBTYPE_SHIFT;
break;
case AVRC_OP_SUB_INFO:
- if (cr == AVCT_CMD)
- {
+ if (cr == AVCT_CMD) {
/* send the response to the peer */
p_rsp = avrc_copy_packet(p_pkt, AVRC_OP_SUB_UNIT_INFO_RSP_LEN);
p_rsp_data = avrc_get_data_ptr(p_rsp);
#if (BT_USE_TRACES == TRUE)
p_drop_msg = "auto responded";
#endif
- }
- else
- {
+ } else {
/* parse response */
p_data += AVRC_AVC_HDR_SIZE; /* 3 bytes: ctype, subunit*, opcode */
msg.sub.page = (*p_data++ >> AVRC_SUB_PAGE_SHIFT) & AVRC_SUB_PAGE_MASK;
xx = 0;
- while (*p_data != AVRC_CMD_OPRND_PAD && xx<AVRC_SUB_TYPE_LEN)
- {
+ while (*p_data != AVRC_CMD_OPRND_PAD && xx < AVRC_SUB_TYPE_LEN) {
msg.sub.subunit_type[xx] = *p_data++ >> AVRC_SUBTYPE_SHIFT;
- if (msg.sub.subunit_type[xx] == AVRC_SUB_PANEL)
+ if (msg.sub.subunit_type[xx] == AVRC_SUB_PANEL) {
msg.sub.panel = TRUE;
+ }
xx++;
}
}
break;
case AVRC_OP_VENDOR:
- p_data = (UINT8 *)(p_pkt+1) + p_pkt->offset;
+ p_data = (UINT8 *)(p_pkt + 1) + p_pkt->offset;
p_begin = p_data;
- if (p_pkt->len < AVRC_VENDOR_HDR_SIZE) /* 6 = ctype, subunit*, opcode & CO_ID */
- {
- if (cr == AVCT_CMD)
+ if (p_pkt->len < AVRC_VENDOR_HDR_SIZE) { /* 6 = ctype, subunit*, opcode & CO_ID */
+ if (cr == AVCT_CMD) {
reject = TRUE;
- else
+ } else {
drop = TRUE;
+ }
break;
}
p_data += AVRC_AVC_HDR_SIZE; /* skip the first 3 bytes: ctype, subunit*, opcode */
#if (AVRC_METADATA_INCLUDED == TRUE)
UINT8 drop_code = 0;
- if (p_msg->company_id == AVRC_CO_METADATA)
- {
+ if (p_msg->company_id == AVRC_CO_METADATA) {
/* Validate length for metadata message */
- if (p_pkt->len < (AVRC_VENDOR_HDR_SIZE + AVRC_MIN_META_HDR_SIZE))
- {
- if (cr == AVCT_CMD)
+ if (p_pkt->len < (AVRC_VENDOR_HDR_SIZE + AVRC_MIN_META_HDR_SIZE)) {
+ if (cr == AVCT_CMD) {
reject = TRUE;
- else
+ } else {
drop = TRUE;
+ }
break;
}
/* Check+handle fragmented messages */
drop_code = avrc_proc_far_msg(handle, label, cr, &p_pkt, p_msg);
- if (drop_code > 0)
+ if (drop_code > 0) {
drop = TRUE;
+ }
}
- if (drop_code > 0)
- {
- if (drop_code != 4)
+ if (drop_code > 0) {
+ if (drop_code != 4) {
do_free = FALSE;
+ }
#if (BT_USE_TRACES == TRUE)
- switch (drop_code)
- {
+ switch (drop_code) {
case 1:
p_drop_msg = "sent_frag";
break;
break;
case AVRC_OP_PASS_THRU:
- if (p_pkt->len < 5) /* 3 bytes: ctype, subunit*, opcode & op_id & len */
- {
- if (cr == AVCT_CMD)
+ if (p_pkt->len < 5) { /* 3 bytes: ctype, subunit*, opcode & op_id & len */
+ if (cr == AVCT_CMD) {
reject = TRUE;
- else
+ } else {
drop = TRUE;
+ }
break;
}
p_data += AVRC_AVC_HDR_SIZE; /* skip the first 3 bytes: ctype, subunit*, opcode */
msg.pass.op_id = (AVRC_PASS_OP_ID_MASK & *p_data);
- if (AVRC_PASS_STATE_MASK & *p_data)
+ if (AVRC_PASS_STATE_MASK & *p_data) {
msg.pass.state = TRUE;
- else
+ } else {
msg.pass.state = FALSE;
+ }
p_data++;
msg.pass.pass_len = *p_data++;
- if (msg.pass.pass_len != p_pkt->len - 5)
+ if (msg.pass.pass_len != p_pkt->len - 5) {
msg.pass.pass_len = p_pkt->len - 5;
- if (msg.pass.pass_len)
+ }
+ if (msg.pass.pass_len) {
msg.pass.p_pass_data = p_data;
- else
+ } else {
msg.pass.p_pass_data = NULL;
+ }
break;
default:
- if ((avrc_cb.ccb[handle].control & AVRC_CT_TARGET) && (cr == AVCT_CMD))
- {
+ if ((avrc_cb.ccb[handle].control & AVRC_CT_TARGET) && (cr == AVCT_CMD)) {
/* reject unsupported opcode */
reject = TRUE;
}
drop = TRUE;
break;
}
- }
- else /* drop the event */
- {
- drop = TRUE;
+ } else { /* drop the event */
+ drop = TRUE;
}
- if (reject)
- {
+ if (reject) {
/* reject unsupported opcode */
p_rsp = avrc_copy_packet(p_pkt, AVRC_OP_REJ_MSG_LEN);
p_rsp_data = avrc_get_data_ptr(p_rsp);
drop = TRUE;
}
- if (p_rsp)
- {
+ if (p_rsp) {
/* set to send response right away */
AVCT_MsgReq( handle, label, cr, p_rsp);
drop = TRUE;
}
- if (drop == FALSE)
- {
+ if (drop == FALSE) {
msg.hdr.opcode = opcode;
(*avrc_cb.ccb[handle].p_msg_cback)(handle, label, opcode, &msg);
}
#if (BT_USE_TRACES == TRUE)
- else
- {
+ else {
AVRC_TRACE_WARNING("avrc_msg_cback %s msg handle:%d, control:%d, cr:%d, opcode:x%x",
- p_drop_msg,
- handle, avrc_cb.ccb[handle].control, cr, opcode);
+ p_drop_msg,
+ handle, avrc_cb.ccb[handle].control, cr, opcode);
}
#endif
- if (do_free)
+ if (do_free) {
GKI_freebuf(p_pkt);
+ }
}
** NULL if p_msg is NULL.
**
******************************************************************************/
-static BT_HDR * avrc_pass_msg(tAVRC_MSG_PASS *p_msg)
+static BT_HDR *avrc_pass_msg(tAVRC_MSG_PASS *p_msg)
{
BT_HDR *p_cmd = NULL;
UINT8 *p_data;
assert(p_msg != NULL);
- assert(AVRC_CMD_POOL_SIZE > (AVRC_MIN_CMD_LEN+p_msg->pass_len));
+ assert(AVRC_CMD_POOL_SIZE > (AVRC_MIN_CMD_LEN + p_msg->pass_len));
- if ((p_cmd = (BT_HDR *) GKI_getpoolbuf(AVRC_CMD_POOL_ID)) != NULL)
- {
+ if ((p_cmd = (BT_HDR *) GKI_getpoolbuf(AVRC_CMD_POOL_ID)) != NULL) {
p_cmd->offset = AVCT_MSG_OFFSET;
p_cmd->layer_specific = AVCT_DATA_CTRL;
p_data = (UINT8 *)(p_cmd + 1) + p_cmd->offset;
*p_data++ = (p_msg->hdr.ctype & AVRC_CTYPE_MASK);
*p_data++ = (AVRC_SUB_PANEL << AVRC_SUBTYPE_SHIFT); /* Panel subunit & id=0 */
*p_data++ = AVRC_OP_PASS_THRU;
- *p_data = (AVRC_PASS_OP_ID_MASK&p_msg->op_id);
- if (p_msg->state)
+ *p_data = (AVRC_PASS_OP_ID_MASK & p_msg->op_id);
+ if (p_msg->state) {
*p_data |= AVRC_PASS_STATE_MASK;
+ }
p_data++;
- if (p_msg->op_id == AVRC_ID_VENDOR)
- {
+ if (p_msg->op_id == AVRC_ID_VENDOR) {
*p_data++ = p_msg->pass_len;
- if (p_msg->pass_len && p_msg->p_pass_data)
- {
+ if (p_msg->pass_len && p_msg->p_pass_data) {
memcpy(p_data, p_msg->p_pass_data, p_msg->pass_len);
p_data += p_msg->pass_len;
}
- }
- else /* set msg len to 0 for other op_id */
- {
+ } else { /* set msg len to 0 for other op_id */
/* set msg len to 0 for other op_id */
*p_data++ = 0;
}
cc.control = p_ccb->control; /* Control role (Control/Target) */
status = AVCT_CreateConn(p_handle, &cc, peer_addr);
- if (status == AVCT_SUCCESS)
- {
+ if (status == AVCT_SUCCESS) {
memcpy(&avrc_cb.ccb[*p_handle], p_ccb, sizeof(tAVRC_CONN_CB));
#if (AVRC_METADATA_INCLUDED == TRUE)
memset(&avrc_cb.fcb[*p_handle], 0, sizeof(tAVRC_FRAG_CB));
#endif
}
AVRC_TRACE_DEBUG("AVRC_Open role: %d, control:%d status:%d, handle:%d", cc.role, cc.control,
- status, *p_handle);
+ status, *p_handle);
return status;
}
UINT16 len;
BT_HDR *p_pkt_new;
- if (!p_pkt)
+ if (!p_pkt) {
return AVRC_BAD_PARAM;
+ }
AVRC_TRACE_DEBUG("%s handle = %u label = %u ctype = %u len = %d",
__func__, handle, label, ctype, p_pkt->len);
- if (ctype >= AVRC_RSP_NOT_IMPL)
+ if (ctype >= AVRC_RSP_NOT_IMPL) {
cr = AVCT_RSP;
+ }
- if (p_pkt->event == AVRC_OP_VENDOR)
- {
+ if (p_pkt->event == AVRC_OP_VENDOR) {
/* add AVRCP Vendor Dependent headers */
p_start = ((UINT8 *)(p_pkt + 1) + p_pkt->offset);
p_pkt->offset -= AVRC_VENDOR_HDR_SIZE;
*p_data++ = (AVRC_SUB_PANEL << AVRC_SUBTYPE_SHIFT);
*p_data++ = AVRC_OP_VENDOR;
AVRC_CO_ID_TO_BE_STREAM(p_data, AVRC_CO_METADATA);
- }
- else if (p_pkt->event == AVRC_OP_PASS_THRU)
- {
+ } else if (p_pkt->event == AVRC_OP_PASS_THRU) {
/* add AVRCP Pass Through headers */
p_start = ((UINT8 *)(p_pkt + 1) + p_pkt->offset);
p_pkt->offset -= AVRC_PASS_THRU_SIZE;
/* abandon previous fragments */
p_fcb = &avrc_cb.fcb[handle];
- if (p_fcb->frag_enabled)
+ if (p_fcb->frag_enabled) {
p_fcb->frag_enabled = FALSE;
+ }
- if (p_fcb->p_fmsg)
- {
+ if (p_fcb->p_fmsg) {
GKI_freebuf(p_fcb->p_fmsg);
p_fcb->p_fmsg = NULL;
}
/* AVRCP spec has not defined any control channel commands that needs fragmentation at this level
* check for fragmentation only on the response */
- if ((cr == AVCT_RSP) && (chk_frag == TRUE))
- {
- if (p_pkt->len > AVRC_MAX_CTRL_DATA_LEN)
- {
+ if ((cr == AVCT_RSP) && (chk_frag == TRUE)) {
+ if (p_pkt->len > AVRC_MAX_CTRL_DATA_LEN) {
int offset_len = MAX(AVCT_MSG_OFFSET, p_pkt->offset);
p_pkt_new = (BT_HDR *)GKI_getbuf((UINT16)(AVRC_PACKET_LEN + offset_len
- + BT_HDR_SIZE));
- if (p_pkt_new && (p_start != NULL))
- {
+ + BT_HDR_SIZE));
+ if (p_pkt_new && (p_start != NULL)) {
p_fcb->frag_enabled = TRUE;
p_fcb->p_fmsg = p_pkt;
p_fcb->frag_pdu = *p_start;
p_pkt->offset = p_pkt_new->offset;
p_pkt->layer_specific = p_pkt_new->layer_specific;
p_pkt->event = p_pkt_new->event;
- p_data = (UINT8 *)(p_pkt+1) + p_pkt->offset;
+ p_data = (UINT8 *)(p_pkt + 1) + p_pkt->offset;
p_start -= AVRC_VENDOR_HDR_SIZE;
memcpy (p_data, p_start, AVRC_MAX_CTRL_DATA_LEN);
/* use AVRC start packet type */
avrc_prep_end_frag (handle);
AVRC_TRACE_DEBUG ("%s p_pkt len:%d/%d, next len:%d", __func__,
p_pkt->len, len, p_fcb->p_fmsg->len );
- }
- else
- {
+ } else {
AVRC_TRACE_ERROR ("AVRC_MsgReq no buffers for fragmentation" );
GKI_freebuf(p_pkt);
return AVRC_NO_RESOURCES;
{
BT_HDR *p_buf;
assert(p_msg != NULL);
- if (p_msg)
- {
+ if (p_msg) {
p_msg->hdr.ctype = AVRC_CMD_CTRL;
p_buf = avrc_pass_msg(p_msg);
- if (p_buf)
+ if (p_buf) {
return AVCT_MsgReq( handle, label, AVCT_CMD, p_buf);
+ }
}
return AVRC_NO_RESOURCES;
}
{
BT_HDR *p_buf;
assert(p_msg != NULL);
- if (p_msg)
- {
+ if (p_msg) {
p_buf = avrc_pass_msg(p_msg);
- if (p_buf)
+ if (p_buf) {
return AVCT_MsgReq( handle, label, AVCT_RSP, p_buf);
+ }
}
return AVRC_NO_RESOURCES;
}
** Otherwise, the error code.
**
*******************************************************************************/
-static tAVRC_STS avrc_bld_vol_change_notfn(BT_HDR * p_pkt)
+static tAVRC_STS avrc_bld_vol_change_notfn(BT_HDR *p_pkt)
{
UINT8 *p_data, *p_start;
p_data = p_start + 2; /* pdu + rsvd */
/* add fixed length 5 -*/
UINT16_TO_BE_STREAM(p_data, 5);
- UINT8_TO_BE_STREAM(p_data,AVRC_EVT_VOLUME_CHANGE);
+ UINT8_TO_BE_STREAM(p_data, AVRC_EVT_VOLUME_CHANGE);
UINT32_TO_BE_STREAM(p_data, 0);
p_pkt->len = (p_data - p_start);
return AVRC_STS_NO_ERROR;
*******************************************************************************/
static BT_HDR *avrc_bld_init_cmd_buffer(tAVRC_COMMAND *p_cmd)
{
- UINT16 offset = 0, chnl = AVCT_DATA_CTRL, len=AVRC_META_CMD_POOL_SIZE;
- BT_HDR *p_pkt=NULL;
+ UINT16 offset = 0, chnl = AVCT_DATA_CTRL, len = AVRC_META_CMD_POOL_SIZE;
+ BT_HDR *p_pkt = NULL;
UINT8 opcode;
opcode = avrc_opcode_from_pdu(p_cmd->pdu);
AVRC_TRACE_API("avrc_bld_init_cmd_buffer: pdu=%x, opcode=%x", p_cmd->pdu, opcode);
- switch (opcode)
- {
+ switch (opcode) {
case AVRC_OP_PASS_THRU:
offset = AVRC_MSG_PASS_THRU_OFFSET;
break;
/* allocate and initialize the buffer */
p_pkt = (BT_HDR *)GKI_getbuf(len);
- if (p_pkt)
- {
+ if (p_pkt) {
UINT8 *p_data, *p_start;
p_pkt->layer_specific = chnl;
p_start = p_data;
/* pass thru - group navigation - has a two byte op_id, so dont do it here */
- if (opcode != AVRC_OP_PASS_THRU)
+ if (opcode != AVRC_OP_PASS_THRU) {
*p_data++ = p_cmd->pdu;
+ }
- switch (opcode)
- {
+ switch (opcode) {
case AVRC_OP_VENDOR:
/* reserved 0, packet_type 0 */
UINT8_TO_BE_STREAM(p_data, 0);
BOOLEAN alloc = FALSE;
AVRC_TRACE_API("AVRC_BldCommand: pdu=%x status=%x", p_cmd->cmd.pdu, p_cmd->cmd.status);
- if (!p_cmd || !pp_pkt)
- {
+ if (!p_cmd || !pp_pkt) {
AVRC_TRACE_API("AVRC_BldCommand. Invalid parameters passed. p_cmd=%p, pp_pkt=%p",
- p_cmd, pp_pkt);
+ p_cmd, pp_pkt);
return AVRC_STS_BAD_PARAM;
}
- if (*pp_pkt == NULL)
- {
- if ((*pp_pkt = avrc_bld_init_cmd_buffer(p_cmd)) == NULL)
- {
+ if (*pp_pkt == NULL) {
+ if ((*pp_pkt = avrc_bld_init_cmd_buffer(p_cmd)) == NULL) {
AVRC_TRACE_API("AVRC_BldCommand: Failed to initialize command buffer");
return AVRC_STS_INTERNAL_ERR;
}
status = AVRC_STS_NO_ERROR;
p_pkt = *pp_pkt;
- switch (p_cmd->pdu)
- {
+ switch (p_cmd->pdu) {
case AVRC_PDU_REQUEST_CONTINUATION_RSP: /* 0x40 */
status = avrc_bld_next_cmd(&p_cmd->continu, p_pkt);
break;
case AVRC_PDU_REGISTER_NOTIFICATION: /* 0x31 */
#if (AVRC_ADV_CTRL_INCLUDED == TRUE)
- if(AVRC_EVT_VOLUME_CHANGE==p_cmd->reg_notif.event_id)
- status=avrc_bld_vol_change_notfn(p_pkt);
+ if (AVRC_EVT_VOLUME_CHANGE == p_cmd->reg_notif.event_id) {
+ status = avrc_bld_vol_change_notfn(p_pkt);
+ }
#endif
break;
}
- if (alloc && (status != AVRC_STS_NO_ERROR) )
- {
+ if (alloc && (status != AVRC_STS_NO_ERROR) ) {
GKI_freebuf(p_pkt);
*pp_pkt = NULL;
}
UINT8 *p_event_id;
tAVRC_STS status = AVRC_STS_NO_ERROR;
- if (!(AVRC_IS_VALID_CAP_ID(p_rsp->capability_id)))
- {
+ if (!(AVRC_IS_VALID_CAP_ID(p_rsp->capability_id))) {
AVRC_TRACE_ERROR("avrc_bld_get_capability_rsp bad parameter. p_rsp: %x", (int)p_rsp);
status = AVRC_STS_BAD_PARAM;
return status;
UINT8_TO_BE_STREAM(p_data, p_rsp->capability_id);
p_count = p_data;
- if (len == 0)
- {
+ if (len == 0) {
*p_count = p_rsp->count;
p_data++;
len = 2; /* move past the capability_id and count */
- }
- else
- {
+ } else {
p_data = p_start + p_pkt->len;
*p_count += p_rsp->count;
}
- if (p_rsp->capability_id == AVRC_CAP_COMPANY_ID)
- {
+ if (p_rsp->capability_id == AVRC_CAP_COMPANY_ID) {
p_company_id = p_rsp->param.company_id;
- for (xx=0; xx< p_rsp->count; xx++)
- {
+ for (xx = 0; xx < p_rsp->count; xx++) {
UINT24_TO_BE_STREAM(p_data, p_company_id[xx]);
}
len += p_rsp->count * 3;
- }
- else
- {
+ } else {
p_event_id = p_rsp->param.event_id;
*p_count = 0;
- for (xx=0; xx< p_rsp->count; xx++)
- {
- if (AVRC_IS_VALID_EVENT_ID(p_event_id[xx]))
- {
+ for (xx = 0; xx < p_rsp->count; xx++) {
+ if (AVRC_IS_VALID_EVENT_ID(p_event_id[xx])) {
(*p_count)++;
UINT8_TO_BE_STREAM(p_data, p_event_id[xx]);
}
BE_STREAM_TO_UINT16(len, p_data);
p_num = p_data;
- if (len == 0)
- {
+ if (len == 0) {
/* first time initialize the attribute count */
*p_num = 0;
p_data++;
- }
- else
- {
+ } else {
p_data = p_start + p_pkt->len;
}
- for (xx=0; xx<p_rsp->num_attr; xx++)
- {
- if(AVRC_IsValidPlayerAttr(p_rsp->attrs[xx]))
- {
+ for (xx = 0; xx < p_rsp->num_attr; xx++) {
+ if (AVRC_IsValidPlayerAttr(p_rsp->attrs[xx])) {
(*p_num)++;
UINT8_TO_BE_STREAM(p_data, p_rsp->attrs[xx]);
}
**
*******************************************************************************/
static tAVRC_STS avrc_bld_list_app_settings_values_rsp (tAVRC_LIST_APP_VALUES_RSP *p_rsp,
- BT_HDR *p_pkt)
+ BT_HDR *p_pkt)
{
UINT8 *p_data, *p_start, *p_len, *p_num;
UINT8 xx;
BE_STREAM_TO_UINT16(len, p_data);
p_num = p_data;
/* first time initialize the attribute count */
- if (len == 0)
- {
+ if (len == 0) {
*p_num = p_rsp->num_val;
p_data++;
- }
- else
- {
+ } else {
p_data = p_start + p_pkt->len;
*p_num += p_rsp->num_val;
}
- for (xx=0; xx<p_rsp->num_val; xx++)
- {
+ for (xx = 0; xx < p_rsp->num_val; xx++) {
UINT8_TO_BE_STREAM(p_data, p_rsp->vals[xx]);
}
**
*******************************************************************************/
static tAVRC_STS avrc_bld_get_cur_app_setting_value_rsp (tAVRC_GET_CUR_APP_VALUE_RSP *p_rsp,
- BT_HDR *p_pkt)
+ BT_HDR *p_pkt)
{
UINT8 *p_data, *p_start, *p_len, *p_count;
UINT16 len;
UINT8 xx;
- if (!p_rsp->p_vals)
- {
+ if (!p_rsp->p_vals) {
AVRC_TRACE_ERROR("avrc_bld_get_cur_app_setting_value_rsp NULL parameter");
return AVRC_STS_BAD_PARAM;
}
BE_STREAM_TO_UINT16(len, p_data);
p_count = p_data;
- if (len == 0)
- {
+ if (len == 0) {
/* first time initialize the attribute count */
*p_count = 0;
p_data++;
- }
- else
- {
+ } else {
p_data = p_start + p_pkt->len;
}
- for (xx=0; xx<p_rsp->num_val; xx++)
- {
- if (avrc_is_valid_player_attrib_value(p_rsp->p_vals[xx].attr_id, p_rsp->p_vals[xx].attr_val))
- {
+ for (xx = 0; xx < p_rsp->num_val; xx++) {
+ if (avrc_is_valid_player_attrib_value(p_rsp->p_vals[xx].attr_id, p_rsp->p_vals[xx].attr_val)) {
(*p_count)++;
UINT8_TO_BE_STREAM(p_data, p_rsp->p_vals[xx].attr_id);
UINT8_TO_BE_STREAM(p_data, p_rsp->p_vals[xx].attr_val);
tAVRC_STS sts = AVRC_STS_NO_ERROR;
UINT8 num_added = 0;
- if (!p_rsp->p_attrs)
- {
+ if (!p_rsp->p_attrs) {
AVRC_TRACE_ERROR("avrc_bld_app_setting_text_rsp NULL parameter");
return AVRC_STS_BAD_PARAM;
}
BE_STREAM_TO_UINT16(len, p_data);
p_count = p_data;
- if (len == 0)
- {
+ if (len == 0) {
*p_count = 0;
p_data++;
- }
- else
- {
+ } else {
p_data = p_start + p_pkt->len;
}
- for (xx=0; xx<p_rsp->num_attr; xx++)
- {
- if (len_left < (p_rsp->p_attrs[xx].str_len + 4))
- {
+ for (xx = 0; xx < p_rsp->num_attr; xx++) {
+ if (len_left < (p_rsp->p_attrs[xx].str_len + 4)) {
AVRC_TRACE_ERROR("avrc_bld_app_setting_text_rsp out of room %d(str_len:%d, left:%d)",
- xx, p_rsp->p_attrs[xx].str_len, len_left);
+ xx, p_rsp->p_attrs[xx].str_len, len_left);
p_rsp->num_attr = num_added;
sts = AVRC_STS_INTERNAL_ERR;
break;
}
- if ( !p_rsp->p_attrs[xx].str_len || !p_rsp->p_attrs[xx].p_str )
- {
+ if ( !p_rsp->p_attrs[xx].str_len || !p_rsp->p_attrs[xx].p_str ) {
AVRC_TRACE_ERROR("avrc_bld_app_setting_text_rsp NULL attr text[%d]", xx);
continue;
}
**
*******************************************************************************/
static tAVRC_STS avrc_bld_get_app_setting_attr_text_rsp (tAVRC_GET_APP_ATTR_TXT_RSP *p_rsp,
- BT_HDR *p_pkt)
+ BT_HDR *p_pkt)
{
AVRC_TRACE_API("avrc_bld_get_app_setting_attr_text_rsp");
return avrc_bld_app_setting_text_rsp(p_rsp, p_pkt);
**
*******************************************************************************/
static tAVRC_STS avrc_bld_get_app_setting_value_text_rsp (tAVRC_GET_APP_ATTR_TXT_RSP *p_rsp,
- BT_HDR *p_pkt)
+ BT_HDR *p_pkt)
{
AVRC_TRACE_API("avrc_bld_get_app_setting_value_text_rsp");
return avrc_bld_app_setting_text_rsp(p_rsp, p_pkt);
UINT8 xx;
AVRC_TRACE_API("avrc_bld_get_elem_attrs_rsp");
- if (!p_rsp->p_attrs)
- {
+ if (!p_rsp->p_attrs) {
AVRC_TRACE_ERROR("avrc_bld_get_elem_attrs_rsp NULL parameter");
return AVRC_STS_BAD_PARAM;
}
BE_STREAM_TO_UINT16(len, p_data);
p_count = p_data;
- if (len == 0)
- {
+ if (len == 0) {
*p_count = 0;
p_data++;
- }
- else
- {
+ } else {
p_data = p_start + p_pkt->len;
}
- for (xx=0; xx<p_rsp->num_attr; xx++)
- {
- if (!AVRC_IS_VALID_MEDIA_ATTRIBUTE(p_rsp->p_attrs[xx].attr_id))
- {
+ for (xx = 0; xx < p_rsp->num_attr; xx++) {
+ if (!AVRC_IS_VALID_MEDIA_ATTRIBUTE(p_rsp->p_attrs[xx].attr_id)) {
AVRC_TRACE_ERROR("avrc_bld_get_elem_attrs_rsp invalid attr id[%d]: %d", xx, p_rsp->p_attrs[xx].attr_id);
continue;
}
- if ( !p_rsp->p_attrs[xx].name.p_str )
- {
+ if ( !p_rsp->p_attrs[xx].name.p_str ) {
p_rsp->p_attrs[xx].name.str_len = 0;
}
UINT32_TO_BE_STREAM(p_data, p_rsp->p_attrs[xx].attr_id);
p_data += 2;
UINT8_TO_BE_STREAM(p_data, p_rsp->event_id);
- switch (p_rsp->event_id)
- {
+ switch (p_rsp->event_id) {
case AVRC_EVT_PLAY_STATUS_CHANGE: /* 0x01 */
/* p_rsp->param.play_status >= AVRC_PLAYSTATE_STOPPED is always TRUE */
if ((p_rsp->param.play_status <= AVRC_PLAYSTATE_REV_SEEK) ||
- (p_rsp->param.play_status == AVRC_PLAYSTATE_ERROR) )
- {
+ (p_rsp->param.play_status == AVRC_PLAYSTATE_ERROR) ) {
UINT8_TO_BE_STREAM(p_data, p_rsp->param.play_status);
len = 2;
- }
- else
- {
+ } else {
AVRC_TRACE_ERROR("bad play state");
status = AVRC_STS_BAD_PARAM;
}
break;
case AVRC_EVT_BATTERY_STATUS_CHANGE: /* 0x06 */
- if (AVRC_IS_VALID_BATTERY_STATUS(p_rsp->param.battery_status))
- {
+ if (AVRC_IS_VALID_BATTERY_STATUS(p_rsp->param.battery_status)) {
UINT8_TO_BE_STREAM(p_data, p_rsp->param.battery_status);
len = 2;
- }
- else
- {
+ } else {
AVRC_TRACE_ERROR("bad battery status");
status = AVRC_STS_BAD_PARAM;
}
break;
case AVRC_EVT_SYSTEM_STATUS_CHANGE: /* 0x07 */
- if (AVRC_IS_VALID_SYSTEM_STATUS(p_rsp->param.system_status))
- {
+ if (AVRC_IS_VALID_SYSTEM_STATUS(p_rsp->param.system_status)) {
UINT8_TO_BE_STREAM(p_data, p_rsp->param.system_status);
len = 2;
- }
- else
- {
+ } else {
AVRC_TRACE_ERROR("bad system status");
status = AVRC_STS_BAD_PARAM;
}
break;
case AVRC_EVT_APP_SETTING_CHANGE: /* 0x08 */
- if (p_rsp->param.player_setting.num_attr > AVRC_MAX_APP_SETTINGS)
+ if (p_rsp->param.player_setting.num_attr > AVRC_MAX_APP_SETTINGS) {
p_rsp->param.player_setting.num_attr = AVRC_MAX_APP_SETTINGS;
+ }
- if (p_rsp->param.player_setting.num_attr > 0)
- {
+ if (p_rsp->param.player_setting.num_attr > 0) {
UINT8_TO_BE_STREAM(p_data, p_rsp->param.player_setting.num_attr);
len = 2;
- for (xx=0; xx<p_rsp->param.player_setting.num_attr; xx++)
- {
+ for (xx = 0; xx < p_rsp->param.player_setting.num_attr; xx++) {
if (avrc_is_valid_player_attrib_value(p_rsp->param.player_setting.attr_id[xx],
- p_rsp->param.player_setting.attr_value[xx]))
- {
+ p_rsp->param.player_setting.attr_value[xx])) {
UINT8_TO_BE_STREAM(p_data, p_rsp->param.player_setting.attr_id[xx]);
UINT8_TO_BE_STREAM(p_data, p_rsp->param.player_setting.attr_value[xx]);
- }
- else
- {
+ } else {
AVRC_TRACE_ERROR("bad player app seeting attribute or value");
status = AVRC_STS_BAD_PARAM;
break;
}
len += 2;
}
- }
- else
+ } else {
status = AVRC_STS_BAD_PARAM;
+ }
break;
default:
{
UINT8 *p_data;
- if (!AVRC_IS_VALID_GROUP(navi_id))
- {
+ if (!AVRC_IS_VALID_GROUP(navi_id)) {
AVRC_TRACE_ERROR("avrc_bld_group_navigation_rsp bad navigation op id: %d", navi_id);
return AVRC_STS_BAD_PARAM;
}
AVRC_TRACE_API("avrc_bld_group_navigation_rsp");
- p_data = (UINT8 *)(p_pkt+1) + p_pkt->offset;
+ p_data = (UINT8 *)(p_pkt + 1) + p_pkt->offset;
UINT16_TO_BE_STREAM(p_data, navi_id);
p_pkt->len = 2;
return AVRC_STS_NO_ERROR;
*******************************************************************************/
static BT_HDR *avrc_bld_init_rsp_buffer(tAVRC_RESPONSE *p_rsp)
{
- UINT16 offset = AVRC_MSG_PASS_THRU_OFFSET, chnl = AVCT_DATA_CTRL, len=AVRC_META_CMD_POOL_SIZE;
- BT_HDR *p_pkt=NULL;
+ UINT16 offset = AVRC_MSG_PASS_THRU_OFFSET, chnl = AVCT_DATA_CTRL, len = AVRC_META_CMD_POOL_SIZE;
+ BT_HDR *p_pkt = NULL;
UINT8 opcode = avrc_opcode_from_pdu(p_rsp->pdu);
AVRC_TRACE_API("avrc_bld_init_rsp_buffer: pdu=%x, opcode=%x/%x", p_rsp->pdu, opcode,
- p_rsp->rsp.opcode);
+ p_rsp->rsp.opcode);
if (opcode != p_rsp->rsp.opcode && p_rsp->rsp.status != AVRC_STS_NO_ERROR &&
- avrc_is_valid_opcode(p_rsp->rsp.opcode))
- {
+ avrc_is_valid_opcode(p_rsp->rsp.opcode)) {
opcode = p_rsp->rsp.opcode;
AVRC_TRACE_API("opcode=%x", opcode);
}
- switch (opcode)
- {
+ switch (opcode) {
case AVRC_OP_PASS_THRU:
offset = AVRC_MSG_PASS_THRU_OFFSET;
break;
case AVRC_OP_VENDOR:
offset = AVRC_MSG_VENDOR_OFFSET;
- if (p_rsp->pdu == AVRC_PDU_GET_ELEMENT_ATTR)
+ if (p_rsp->pdu == AVRC_PDU_GET_ELEMENT_ATTR) {
len = AVRC_BROWSE_POOL_SIZE;
+ }
break;
}
/* allocate and initialize the buffer */
p_pkt = (BT_HDR *)GKI_getbuf(len);
- if (p_pkt)
- {
+ if (p_pkt) {
UINT8 *p_data, *p_start;
p_pkt->layer_specific = chnl;
p_start = p_data;
/* pass thru - group navigation - has a two byte op_id, so dont do it here */
- if (opcode != AVRC_OP_PASS_THRU)
+ if (opcode != AVRC_OP_PASS_THRU) {
*p_data++ = p_rsp->pdu;
+ }
- switch (opcode)
- {
+ switch (opcode) {
case AVRC_OP_VENDOR:
/* reserved 0, packet_type 0 */
UINT8_TO_BE_STREAM(p_data, 0);
BOOLEAN alloc = FALSE;
UNUSED(handle);
- if (!p_rsp || !pp_pkt)
- {
+ if (!p_rsp || !pp_pkt) {
AVRC_TRACE_API("AVRC_BldResponse. Invalid parameters passed. p_rsp=%p, pp_pkt=%p",
- p_rsp, pp_pkt);
+ p_rsp, pp_pkt);
return AVRC_STS_BAD_PARAM;
}
- if (*pp_pkt == NULL)
- {
- if ((*pp_pkt = avrc_bld_init_rsp_buffer(p_rsp)) == NULL)
- {
+ if (*pp_pkt == NULL) {
+ if ((*pp_pkt = avrc_bld_init_rsp_buffer(p_rsp)) == NULL) {
AVRC_TRACE_API("AVRC_BldResponse: Failed to initialize response buffer");
return AVRC_STS_INTERNAL_ERR;
}
p_pkt = *pp_pkt;
AVRC_TRACE_API("AVRC_BldResponse: pdu=%x status=%x", p_rsp->rsp.pdu, p_rsp->rsp.status);
- if (p_rsp->rsp.status != AVRC_STS_NO_ERROR)
- {
- return( avrc_bld_rejected_rsp(&p_rsp->rsp, p_pkt) );
+ if (p_rsp->rsp.status != AVRC_STS_NO_ERROR) {
+ return ( avrc_bld_rejected_rsp(&p_rsp->rsp, p_pkt) );
}
- switch (p_rsp->pdu)
- {
+ switch (p_rsp->pdu) {
case AVRC_PDU_NEXT_GROUP:
case AVRC_PDU_PREV_GROUP:
status = avrc_bld_group_navigation_rsp(p_rsp->pdu, p_pkt);
break;
}
- if (alloc && (status != AVRC_STS_NO_ERROR) )
- {
+ if (alloc && (status != AVRC_STS_NO_ERROR) ) {
GKI_freebuf(p_pkt);
*pp_pkt = NULL;
}
** NULL if p_msg is NULL.
**
******************************************************************************/
-static BT_HDR * avrc_vendor_msg(tAVRC_MSG_VENDOR *p_msg)
+static BT_HDR *avrc_vendor_msg(tAVRC_MSG_VENDOR *p_msg)
{
BT_HDR *p_cmd;
UINT8 *p_data;
assert(p_msg != NULL);
#if AVRC_METADATA_INCLUDED == TRUE
- assert(AVRC_META_CMD_POOL_SIZE > (AVRC_MIN_CMD_LEN+p_msg->vendor_len));
+ assert(AVRC_META_CMD_POOL_SIZE > (AVRC_MIN_CMD_LEN + p_msg->vendor_len));
if ((p_cmd = (BT_HDR *) GKI_getpoolbuf(AVRC_META_CMD_POOL_ID)) != NULL)
#else
- assert(AVRC_CMD_POOL_SIZE > (AVRC_MIN_CMD_LEN+p_msg->vendor_len));
+ assert(AVRC_CMD_POOL_SIZE > (AVRC_MIN_CMD_LEN + p_msg->vendor_len));
if ((p_cmd = (BT_HDR *) GKI_getpoolbuf(AVRC_CMD_POOL_ID)) != NULL)
#endif
{
*p_data++ = (p_msg->hdr.subunit_type << AVRC_SUBTYPE_SHIFT) | p_msg->hdr.subunit_id;
*p_data++ = AVRC_OP_VENDOR;
AVRC_CO_ID_TO_BE_STREAM(p_data, p_msg->company_id);
- if(p_msg->vendor_len && p_msg->p_vendor_data)
- {
+ if (p_msg->vendor_len && p_msg->p_vendor_data) {
memcpy(p_data, p_msg->p_vendor_data, p_msg->vendor_len);
}
p_cmd->len = (UINT16) (p_data + p_msg->vendor_len - (UINT8 *)(p_cmd + 1) - p_cmd->offset);
BT_HDR *p_cmd;
UINT8 *p_data;
- if ((p_cmd = (BT_HDR *) GKI_getpoolbuf(AVRC_CMD_POOL_ID)) != NULL)
- {
+ if ((p_cmd = (BT_HDR *) GKI_getpoolbuf(AVRC_CMD_POOL_ID)) != NULL) {
p_cmd->offset = AVCT_MSG_OFFSET;
p_data = (UINT8 *)(p_cmd + 1) + p_cmd->offset;
*p_data++ = AVRC_CMD_STATUS;
BT_HDR *p_cmd;
UINT8 *p_data;
- if ((p_cmd = (BT_HDR *) GKI_getpoolbuf(AVRC_CMD_POOL_ID)) != NULL)
- {
+ if ((p_cmd = (BT_HDR *) GKI_getpoolbuf(AVRC_CMD_POOL_ID)) != NULL) {
p_cmd->offset = AVCT_MSG_OFFSET;
p_data = (UINT8 *)(p_cmd + 1) + p_cmd->offset;
*p_data++ = AVRC_CMD_STATUS;
/* unit & id ignore */
*p_data++ = (AVRC_SUB_UNIT << AVRC_SUBTYPE_SHIFT) | AVRC_SUBID_IGNORE;
*p_data++ = AVRC_OP_SUB_INFO;
- *p_data++ = ((page&AVRC_SUB_PAGE_MASK) << AVRC_SUB_PAGE_SHIFT) | AVRC_SUB_EXT_CODE;
+ *p_data++ = ((page & AVRC_SUB_PAGE_MASK) << AVRC_SUB_PAGE_SHIFT) | AVRC_SUB_EXT_CODE;
memset(p_data, AVRC_CMD_OPRND_PAD, AVRC_SUB_OPRND_BYTES);
p_cmd->len = p_data + AVRC_SUB_OPRND_BYTES - (UINT8 *)(p_cmd + 1) - p_cmd->offset;
p_cmd->layer_specific = AVCT_DATA_CTRL;
UINT16 AVRC_VendorCmd(UINT8 handle, UINT8 label, tAVRC_MSG_VENDOR *p_msg)
{
BT_HDR *p_buf = avrc_vendor_msg(p_msg);
- if (p_buf)
+ if (p_buf) {
return AVCT_MsgReq( handle, label, AVCT_CMD, p_buf);
- else
+ } else {
return AVCT_NO_RESOURCES;
+ }
}
UINT16 AVRC_VendorRsp(UINT8 handle, UINT8 label, tAVRC_MSG_VENDOR *p_msg)
{
BT_HDR *p_buf = avrc_vendor_msg(p_msg);
- if (p_buf)
+ if (p_buf) {
return AVCT_MsgReq( handle, label, AVCT_RSP, p_buf);
- else
+ } else {
return AVCT_NO_RESOURCES;
+ }
}
#endif /* #if (defined(AVRC_INCLUDED) && AVRC_INCLUDED == TRUE) */
tAVRC_STS status = AVRC_STS_NO_ERROR;
UINT8 *p;
UINT16 len;
- UINT8 eventid=0;
+ UINT8 eventid = 0;
/* Check the vendor data */
- if (p_msg->vendor_len == 0)
+ if (p_msg->vendor_len == 0) {
return AVRC_STS_NO_ERROR;
- if (p_msg->p_vendor_data == NULL)
+ }
+ if (p_msg->p_vendor_data == NULL) {
return AVRC_STS_INTERNAL_ERR;
+ }
p = p_msg->p_vendor_data;
BE_STREAM_TO_UINT8 (p_result->pdu, p);
p++; /* skip the reserved/packe_type byte */
BE_STREAM_TO_UINT16 (len, p);
AVRC_TRACE_DEBUG("avrc_pars_vendor_rsp() ctype:0x%x pdu:0x%x, len:%d/0x%x", p_msg->hdr.ctype, p_result->pdu, len, len);
- if (p_msg->hdr.ctype == AVRC_RSP_REJ)
- {
+ if (p_msg->hdr.ctype == AVRC_RSP_REJ) {
p_result->rsp.status = *p;
return p_result->rsp.status;
}
- switch (p_result->pdu)
- {
- /* case AVRC_PDU_REQUEST_CONTINUATION_RSP: 0x40 */
- /* case AVRC_PDU_ABORT_CONTINUATION_RSP: 0x41 */
+ switch (p_result->pdu) {
+ /* case AVRC_PDU_REQUEST_CONTINUATION_RSP: 0x40 */
+ /* case AVRC_PDU_ABORT_CONTINUATION_RSP: 0x41 */
#if (AVRC_ADV_CTRL_INCLUDED == TRUE)
case AVRC_PDU_SET_ABSOLUTE_VOLUME: /* 0x50 */
- if (len != 1)
+ if (len != 1) {
status = AVRC_STS_INTERNAL_ERR;
- else
- {
+ } else {
BE_STREAM_TO_UINT8 (p_result->volume.volume, p);
}
break;
case AVRC_PDU_REGISTER_NOTIFICATION: /* 0x31 */
#if (AVRC_ADV_CTRL_INCLUDED == TRUE)
BE_STREAM_TO_UINT8 (eventid, p);
- if(AVRC_EVT_VOLUME_CHANGE==eventid
- && (AVRC_RSP_CHANGED==p_msg->hdr.ctype || AVRC_RSP_INTERIM==p_msg->hdr.ctype
- || AVRC_RSP_REJ==p_msg->hdr.ctype || AVRC_RSP_NOT_IMPL==p_msg->hdr.ctype))
- {
- p_result->reg_notif.status=p_msg->hdr.ctype;
- p_result->reg_notif.event_id=eventid;
+ if (AVRC_EVT_VOLUME_CHANGE == eventid
+ && (AVRC_RSP_CHANGED == p_msg->hdr.ctype || AVRC_RSP_INTERIM == p_msg->hdr.ctype
+ || AVRC_RSP_REJ == p_msg->hdr.ctype || AVRC_RSP_NOT_IMPL == p_msg->hdr.ctype)) {
+ p_result->reg_notif.status = p_msg->hdr.ctype;
+ p_result->reg_notif.event_id = eventid;
BE_STREAM_TO_UINT8 (p_result->reg_notif.param.volume, p);
}
- AVRC_TRACE_DEBUG("avrc_pars_vendor_rsp PDU reg notif response:event %x, volume %x",eventid,
- p_result->reg_notif.param.volume);
+ AVRC_TRACE_DEBUG("avrc_pars_vendor_rsp PDU reg notif response:event %x, volume %x", eventid,
+ p_result->reg_notif.param.volume);
#endif /* (AVRC_ADV_CTRL_INCLUDED == TRUE) */
break;
default:
UNUSED(p_buf);
UNUSED(buf_len);
- if (p_msg && p_result)
- {
- switch (p_msg->hdr.opcode)
- {
+ if (p_msg && p_result) {
+ switch (p_msg->hdr.opcode) {
case AVRC_OP_VENDOR: /* 0x00 Vendor-dependent commands */
status = avrc_pars_vendor_rsp(&p_msg->vendor, p_result);
break;
case AVRC_OP_PASS_THRU: /* 0x7C panel subunit opcode */
status = avrc_pars_pass_thru(&p_msg->pass, &id);
- if (status == AVRC_STS_NO_ERROR)
- {
+ if (status == AVRC_STS_NO_ERROR) {
p_result->pdu = (UINT8)id;
}
break;
UINT16 size_needed;
/* Check the vendor data */
- if (p_msg->vendor_len == 0)
+ if (p_msg->vendor_len == 0) {
return AVRC_STS_NO_ERROR;
- if (p_msg->p_vendor_data == NULL)
+ }
+ if (p_msg->p_vendor_data == NULL) {
return AVRC_STS_INTERNAL_ERR;
+ }
p = p_msg->p_vendor_data;
p_result->pdu = *p++;
AVRC_TRACE_DEBUG("avrc_pars_vendor_cmd() pdu:0x%x", p_result->pdu);
- if (!AVRC_IsValidAvcType (p_result->pdu, p_msg->hdr.ctype))
- {
+ if (!AVRC_IsValidAvcType (p_result->pdu, p_msg->hdr.ctype)) {
AVRC_TRACE_DEBUG("avrc_pars_vendor_cmd() detects wrong AV/C type!");
status = AVRC_STS_BAD_CMD;
}
p++; /* skip the reserved byte */
BE_STREAM_TO_UINT16 (len, p);
- if ((len+4) != (p_msg->vendor_len))
- {
+ if ((len + 4) != (p_msg->vendor_len)) {
status = AVRC_STS_INTERNAL_ERR;
}
- if (status != AVRC_STS_NO_ERROR)
+ if (status != AVRC_STS_NO_ERROR) {
return status;
+ }
- switch (p_result->pdu)
- {
+ switch (p_result->pdu) {
case AVRC_PDU_GET_CAPABILITIES: /* 0x10 */
p_result->get_caps.capability_id = *p++;
- if (!AVRC_IS_VALID_CAP_ID(p_result->get_caps.capability_id))
+ if (!AVRC_IS_VALID_CAP_ID(p_result->get_caps.capability_id)) {
status = AVRC_STS_BAD_PARAM;
- else if (len != 1)
+ } else if (len != 1) {
status = AVRC_STS_INTERNAL_ERR;
+ }
break;
case AVRC_PDU_LIST_PLAYER_APP_ATTR: /* 0x11 */
/* no additional parameters */
- if (len != 0)
+ if (len != 0) {
status = AVRC_STS_INTERNAL_ERR;
+ }
break;
case AVRC_PDU_LIST_PLAYER_APP_VALUES: /* 0x12 */
p_result->list_app_values.attr_id = *p++;
- if (!AVRC_IS_VALID_ATTRIBUTE(p_result->list_app_values.attr_id))
+ if (!AVRC_IS_VALID_ATTRIBUTE(p_result->list_app_values.attr_id)) {
status = AVRC_STS_BAD_PARAM;
- else if (len != 1)
+ } else if (len != 1) {
status = AVRC_STS_INTERNAL_ERR;
+ }
break;
case AVRC_PDU_GET_CUR_PLAYER_APP_VALUE: /* 0x13 */
case AVRC_PDU_GET_PLAYER_APP_ATTR_TEXT: /* 0x15 */
BE_STREAM_TO_UINT8 (p_result->get_cur_app_val.num_attr, p);
- if (len != (p_result->get_cur_app_val.num_attr+1))
- {
+ if (len != (p_result->get_cur_app_val.num_attr + 1)) {
status = AVRC_STS_INTERNAL_ERR;
break;
}
p_u8 = p_result->get_cur_app_val.attrs;
- for (xx=0, yy=0; xx< p_result->get_cur_app_val.num_attr; xx++)
- {
+ for (xx = 0, yy = 0; xx < p_result->get_cur_app_val.num_attr; xx++) {
/* only report the valid player app attributes */
- if (AVRC_IsValidPlayerAttr(*p))
+ if (AVRC_IsValidPlayerAttr(*p)) {
p_u8[yy++] = *p;
+ }
p++;
}
p_result->get_cur_app_val.num_attr = yy;
- if (yy == 0)
- {
+ if (yy == 0) {
status = AVRC_STS_BAD_PARAM;
}
break;
case AVRC_PDU_SET_PLAYER_APP_VALUE: /* 0x14 */
BE_STREAM_TO_UINT8 (p_result->set_app_val.num_val, p);
size_needed = sizeof(tAVRC_APP_SETTING);
- if (p_buf && (len == ((p_result->set_app_val.num_val<<1) + 1)))
- {
+ if (p_buf && (len == ((p_result->set_app_val.num_val << 1) + 1))) {
p_result->set_app_val.p_vals = (tAVRC_APP_SETTING *)p_buf;
p_app_set = p_result->set_app_val.p_vals;
- for (xx=0; ((xx< p_result->set_app_val.num_val) && (buf_len > size_needed)); xx++)
- {
+ for (xx = 0; ((xx < p_result->set_app_val.num_val) && (buf_len > size_needed)); xx++) {
p_app_set[xx].attr_id = *p++;
p_app_set[xx].attr_val = *p++;
- if (!avrc_is_valid_player_attrib_value(p_app_set[xx].attr_id, p_app_set[xx].attr_val))
+ if (!avrc_is_valid_player_attrib_value(p_app_set[xx].attr_id, p_app_set[xx].attr_val)) {
status = AVRC_STS_BAD_PARAM;
+ }
}
- if (xx != p_result->set_app_val.num_val)
- {
+ if (xx != p_result->set_app_val.num_val) {
AVRC_TRACE_ERROR("AVRC_PDU_SET_PLAYER_APP_VALUE not enough room:%d orig num_val:%d",
- xx, p_result->set_app_val.num_val);
+ xx, p_result->set_app_val.num_val);
p_result->set_app_val.num_val = xx;
}
- }
- else
- {
+ } else {
AVRC_TRACE_ERROR("AVRC_PDU_SET_PLAYER_APP_VALUE NULL decode buffer or bad len");
status = AVRC_STS_INTERNAL_ERR;
}
break;
case AVRC_PDU_GET_PLAYER_APP_VALUE_TEXT:/* 0x16 */
- if (len < 3)
+ if (len < 3) {
status = AVRC_STS_INTERNAL_ERR;
- else
- {
+ } else {
BE_STREAM_TO_UINT8 (p_result->get_app_val_txt.attr_id, p);
- if (!AVRC_IS_VALID_ATTRIBUTE(p_result->get_app_val_txt.attr_id))
+ if (!AVRC_IS_VALID_ATTRIBUTE(p_result->get_app_val_txt.attr_id)) {
status = AVRC_STS_BAD_PARAM;
- else
- {
+ } else {
BE_STREAM_TO_UINT8 (p_result->get_app_val_txt.num_val, p);
- if ( (len - 2/* attr_id & num_val */) != p_result->get_app_val_txt.num_val)
+ if ( (len - 2/* attr_id & num_val */) != p_result->get_app_val_txt.num_val) {
status = AVRC_STS_INTERNAL_ERR;
- else
- {
+ } else {
p_u8 = p_result->get_app_val_txt.vals;
- for (xx=0; xx< p_result->get_app_val_txt.num_val; xx++)
- {
+ for (xx = 0; xx < p_result->get_app_val_txt.num_val; xx++) {
p_u8[xx] = *p++;
if (!avrc_is_valid_player_attrib_value(p_result->get_app_val_txt.attr_id,
- p_u8[xx]))
- {
+ p_u8[xx])) {
status = AVRC_STS_BAD_PARAM;
break;
}
break;
case AVRC_PDU_INFORM_DISPLAY_CHARSET: /* 0x17 */
- if (len < 3)
+ if (len < 3) {
status = AVRC_STS_INTERNAL_ERR;
- else
- {
+ } else {
BE_STREAM_TO_UINT8 (p_result->inform_charset.num_id, p);
- if ( (len - 1/* num_id */) != p_result->inform_charset.num_id * 2)
+ if ( (len - 1/* num_id */) != p_result->inform_charset.num_id * 2) {
status = AVRC_STS_INTERNAL_ERR;
- else
- {
+ } else {
p_u16 = p_result->inform_charset.charsets;
- if (p_result->inform_charset.num_id > AVRC_MAX_CHARSET_SIZE)
+ if (p_result->inform_charset.num_id > AVRC_MAX_CHARSET_SIZE) {
p_result->inform_charset.num_id = AVRC_MAX_CHARSET_SIZE;
- for (xx=0; xx< p_result->inform_charset.num_id; xx++)
- {
+ }
+ for (xx = 0; xx < p_result->inform_charset.num_id; xx++) {
BE_STREAM_TO_UINT16 (p_u16[xx], p);
}
}
break;
case AVRC_PDU_INFORM_BATTERY_STAT_OF_CT:/* 0x18 */
- if (len != 1)
+ if (len != 1) {
status = AVRC_STS_INTERNAL_ERR;
- else
- {
+ } else {
p_result->inform_battery_status.battery_status = *p++;
- if (!AVRC_IS_VALID_BATTERY_STATUS(p_result->inform_battery_status.battery_status))
+ if (!AVRC_IS_VALID_BATTERY_STATUS(p_result->inform_battery_status.battery_status)) {
status = AVRC_STS_BAD_PARAM;
+ }
}
break;
case AVRC_PDU_GET_ELEMENT_ATTR: /* 0x20 */
- if (len < 9) /* UID/8 and num_attr/1 */
+ if (len < 9) { /* UID/8 and num_attr/1 */
status = AVRC_STS_INTERNAL_ERR;
- else
- {
+ } else {
BE_STREAM_TO_UINT32 (u32, p);
BE_STREAM_TO_UINT32 (u32_2, p);
- if (u32== 0 && u32_2 == 0)
- {
+ if (u32 == 0 && u32_2 == 0) {
BE_STREAM_TO_UINT8 (p_result->get_elem_attrs.num_attr, p);
- if ( (len - 9/* UID/8 and num_attr/1 */) != (p_result->get_elem_attrs.num_attr * 4))
+ if ( (len - 9/* UID/8 and num_attr/1 */) != (p_result->get_elem_attrs.num_attr * 4)) {
status = AVRC_STS_INTERNAL_ERR;
- else
- {
+ } else {
p_u32 = p_result->get_elem_attrs.attrs;
- if (p_result->get_elem_attrs.num_attr > AVRC_MAX_ELEM_ATTR_SIZE)
+ if (p_result->get_elem_attrs.num_attr > AVRC_MAX_ELEM_ATTR_SIZE) {
p_result->get_elem_attrs.num_attr = AVRC_MAX_ELEM_ATTR_SIZE;
- for (xx=0; xx< p_result->get_elem_attrs.num_attr; xx++)
- {
+ }
+ for (xx = 0; xx < p_result->get_elem_attrs.num_attr; xx++) {
BE_STREAM_TO_UINT32 (p_u32[xx], p);
}
}
- }
- else
+ } else {
status = AVRC_STS_NOT_FOUND;
+ }
}
break;
case AVRC_PDU_GET_PLAY_STATUS: /* 0x30 */
/* no additional parameters */
- if (len != 0)
+ if (len != 0) {
status = AVRC_STS_INTERNAL_ERR;
+ }
break;
case AVRC_PDU_REGISTER_NOTIFICATION: /* 0x31 */
- if (len != 5)
+ if (len != 5) {
status = AVRC_STS_INTERNAL_ERR;
- else
- {
+ } else {
BE_STREAM_TO_UINT8 (p_result->reg_notif.event_id, p);
BE_STREAM_TO_UINT32 (p_result->reg_notif.param, p);
}
break;
- case AVRC_PDU_SET_ABSOLUTE_VOLUME:
- {
- if(len!=1)
+ case AVRC_PDU_SET_ABSOLUTE_VOLUME: {
+ if (len != 1) {
status = AVRC_STS_INTERNAL_ERR;
+ }
break;
}
tAVRC_STS status = AVRC_STS_INTERNAL_ERR;
UINT16 id;
- if (p_msg && p_result)
- {
- switch (p_msg->hdr.opcode)
- {
+ if (p_msg && p_result) {
+ switch (p_msg->hdr.opcode) {
case AVRC_OP_VENDOR: /* 0x00 Vendor-dependent commands */
status = avrc_pars_vendor_cmd(&p_msg->vendor, p_result, p_buf, buf_len);
break;
case AVRC_OP_PASS_THRU: /* 0x7C panel subunit opcode */
status = avrc_pars_pass_thru(&p_msg->pass, &id);
- if (status == AVRC_STS_NO_ERROR)
- {
+ if (status == AVRC_STS_NO_ERROR) {
p_result->pdu = (UINT8)id;
}
break;
#endif
/* update AVRC_NUM_PROTO_ELEMS if this constant is changed */
-const tSDP_PROTOCOL_ELEM avrc_proto_list [] =
-{
+const tSDP_PROTOCOL_ELEM avrc_proto_list [] = {
{UUID_PROTOCOL_L2CAP, 1, {AVCT_PSM, 0} },
#if SDP_AVCTP_1_4 == TRUE
{UUID_PROTOCOL_AVCTP, 1, {AVCT_REV_1_4, 0} }
};
#if SDP_AVRCP_1_4 == TRUE
-const tSDP_PROTO_LIST_ELEM avrc_add_proto_list [] =
-{
- {AVRC_NUM_PROTO_ELEMS,
+const tSDP_PROTO_LIST_ELEM avrc_add_proto_list [] = {
{
- {UUID_PROTOCOL_L2CAP, 1, {AVCT_BR_PSM, 0} },
- {UUID_PROTOCOL_AVCTP, 1, {AVCT_REV_1_3, 0} }}}
+ AVRC_NUM_PROTO_ELEMS,
+ {
+ {UUID_PROTOCOL_L2CAP, 1, {AVCT_BR_PSM, 0} },
+ {UUID_PROTOCOL_AVCTP, 1, {AVCT_REV_1_3, 0} }
+ }
+ }
};
#endif
**
******************************************************************************/
UINT16 AVRC_FindService(UINT16 service_uuid, BD_ADDR bd_addr,
- tAVRC_SDP_DB_PARAMS *p_db, tAVRC_FIND_CBACK *p_cback)
+ tAVRC_SDP_DB_PARAMS *p_db, tAVRC_FIND_CBACK *p_cback)
{
tSDP_UUID uuid_list;
BOOLEAN result = TRUE;
ATTR_ID_BT_PROFILE_DESC_LIST,
ATTR_ID_SERVICE_NAME,
ATTR_ID_SUPPORTED_FEATURES,
- ATTR_ID_PROVIDER_NAME};
+ ATTR_ID_PROVIDER_NAME
+ };
AVRC_TRACE_API("AVRC_FindService uuid: %x", service_uuid);
- if( (service_uuid != UUID_SERVCLASS_AV_REM_CTRL_TARGET && service_uuid != UUID_SERVCLASS_AV_REMOTE_CONTROL) ||
- p_db == NULL || p_db->p_db == NULL || p_cback == NULL)
+ if ( (service_uuid != UUID_SERVCLASS_AV_REM_CTRL_TARGET && service_uuid != UUID_SERVCLASS_AV_REMOTE_CONTROL) ||
+ p_db == NULL || p_db->p_db == NULL || p_cback == NULL) {
return AVRC_BAD_PARAM;
+ }
/* check if it is busy */
- if( avrc_cb.service_uuid == UUID_SERVCLASS_AV_REM_CTRL_TARGET ||
- avrc_cb.service_uuid == UUID_SERVCLASS_AV_REMOTE_CONTROL)
+ if ( avrc_cb.service_uuid == UUID_SERVCLASS_AV_REM_CTRL_TARGET ||
+ avrc_cb.service_uuid == UUID_SERVCLASS_AV_REMOTE_CONTROL) {
return AVRC_NO_RESOURCES;
+ }
/* set up discovery database */
uuid_list.len = LEN_UUID_16;
uuid_list.uu.uuid16 = service_uuid;
- if(p_db->p_attrs == NULL || p_db->num_attr == 0)
- {
+ if (p_db->p_attrs == NULL || p_db->num_attr == 0) {
p_db->p_attrs = a2d_attr_list;
p_db->num_attr = AVRC_NUM_ATTR;
}
result = SDP_InitDiscoveryDb(p_db->p_db, p_db->db_len, 1, &uuid_list, p_db->num_attr,
p_db->p_attrs);
- if (result == TRUE)
- {
+ if (result == TRUE) {
/* store service_uuid and discovery db pointer */
avrc_cb.p_db = p_db->p_db;
avrc_cb.service_uuid = service_uuid;
**
******************************************************************************/
UINT16 AVRC_AddRecord(UINT16 service_uuid, char *p_service_name,
- char *p_provider_name, UINT16 categories, UINT32 sdp_handle)
+ char *p_provider_name, UINT16 categories, UINT32 sdp_handle)
{
UINT16 browse_list[1];
BOOLEAN result = TRUE;
AVRC_TRACE_API("AVRC_AddRecord uuid: %x", service_uuid);
- if( service_uuid != UUID_SERVCLASS_AV_REM_CTRL_TARGET && service_uuid != UUID_SERVCLASS_AV_REMOTE_CONTROL )
+ if ( service_uuid != UUID_SERVCLASS_AV_REM_CTRL_TARGET && service_uuid != UUID_SERVCLASS_AV_REMOTE_CONTROL ) {
return AVRC_BAD_PARAM;
+ }
/* add service class id list */
class_list[0] = service_uuid;
#if SDP_AVCTP_1_4 == TRUE
- if( service_uuid == UUID_SERVCLASS_AV_REMOTE_CONTROL )
- {
+ if ( service_uuid == UUID_SERVCLASS_AV_REMOTE_CONTROL ) {
class_list[1] = UUID_SERVCLASS_AV_REM_CTRL_CONTROL;
count = 2;
}
#else
#if SDP_AVRCP_1_4 == TRUE
- if( service_uuid == UUID_SERVCLASS_AV_REMOTE_CONTROL )
- {
+ if ( service_uuid == UUID_SERVCLASS_AV_REMOTE_CONTROL ) {
class_list[1] = UUID_SERVCLASS_AV_REM_CTRL_CONTROL;
count = 2;
}
p = temp;
UINT16_TO_BE_STREAM(p, categories);
result &= SDP_AddAttribute(sdp_handle, ATTR_ID_SUPPORTED_FEATURES, UINT_DESC_TYPE,
- (UINT32)2, (UINT8*)temp);
+ (UINT32)2, (UINT8 *)temp);
/* add provider name */
- if (p_provider_name != NULL)
- {
+ if (p_provider_name != NULL) {
result &= SDP_AddAttribute(sdp_handle, ATTR_ID_PROVIDER_NAME, TEXT_STR_DESC_TYPE,
- (UINT32)(strlen(p_provider_name)+1), (UINT8 *) p_provider_name);
+ (UINT32)(strlen(p_provider_name) + 1), (UINT8 *) p_provider_name);
}
/* add service name */
- if (p_service_name != NULL)
- {
+ if (p_service_name != NULL) {
result &= SDP_AddAttribute(sdp_handle, ATTR_ID_SERVICE_NAME, TEXT_STR_DESC_TYPE,
- (UINT32)(strlen(p_service_name)+1), (UINT8 *) p_service_name);
+ (UINT32)(strlen(p_service_name) + 1), (UINT8 *) p_service_name);
}
/* add browse group list */
******************************************************************************/
UINT8 AVRC_SetTraceLevel (UINT8 new_level)
{
- if (new_level != 0xFF)
+ if (new_level != 0xFF) {
avrc_cb.trace_level = new_level;
+ }
return (avrc_cb.trace_level);
}
*******************************************************************************/
BOOLEAN AVRC_IsValidAvcType(UINT8 pdu_id, UINT8 avc_type)
{
- BOOLEAN result=FALSE;
+ BOOLEAN result = FALSE;
- if (avc_type < AVRC_RSP_NOT_IMPL) /* command msg */
- {
- switch (pdu_id)
- {
+ if (avc_type < AVRC_RSP_NOT_IMPL) { /* command msg */
+ switch (pdu_id) {
case AVRC_PDU_GET_CAPABILITIES: /* 0x10 */
case AVRC_PDU_LIST_PLAYER_APP_ATTR: /* 0x11 */
case AVRC_PDU_LIST_PLAYER_APP_VALUES: /* 0x12 */
case AVRC_PDU_GET_PLAYER_APP_VALUE_TEXT: /* 0x16 */
case AVRC_PDU_GET_ELEMENT_ATTR: /* 0x20 */
case AVRC_PDU_GET_PLAY_STATUS: /* 0x30 */
- if (avc_type == AVRC_CMD_STATUS)
- result=TRUE;
- break;
+ if (avc_type == AVRC_CMD_STATUS) {
+ result = TRUE;
+ }
+ break;
case AVRC_PDU_SET_PLAYER_APP_VALUE: /* 0x14 */
case AVRC_PDU_INFORM_DISPLAY_CHARSET: /* 0x17 */
case AVRC_PDU_INFORM_BATTERY_STAT_OF_CT: /* 0x18 */
case AVRC_PDU_REQUEST_CONTINUATION_RSP: /* 0x40 */
case AVRC_PDU_ABORT_CONTINUATION_RSP: /* 0x41 */
- if (avc_type == AVRC_CMD_CTRL)
- result=TRUE;
- break;
+ if (avc_type == AVRC_CMD_CTRL) {
+ result = TRUE;
+ }
+ break;
case AVRC_PDU_REGISTER_NOTIFICATION: /* 0x31 */
- if (avc_type == AVRC_CMD_NOTIF)
- result=TRUE;
- break;
+ if (avc_type == AVRC_CMD_NOTIF) {
+ result = TRUE;
+ }
+ break;
}
- }
- else /* response msg */
- {
+ } else { /* response msg */
if (avc_type >= AVRC_RSP_NOT_IMPL &&
- avc_type <= AVRC_RSP_INTERIM )
- result=TRUE;
+ avc_type <= AVRC_RSP_INTERIM ) {
+ result = TRUE;
+ }
}
return result;
*******************************************************************************/
BOOLEAN avrc_is_valid_player_attrib_value(UINT8 attrib, UINT8 value)
{
- BOOLEAN result=FALSE;
+ BOOLEAN result = FALSE;
- switch(attrib)
- {
+ switch (attrib) {
case AVRC_PLAYER_SETTING_EQUALIZER:
- if ((value > 0) &&
- (value <= AVRC_PLAYER_VAL_ON))
- result=TRUE;
- break;
+ if ((value > 0) &&
+ (value <= AVRC_PLAYER_VAL_ON)) {
+ result = TRUE;
+ }
+ break;
case AVRC_PLAYER_SETTING_REPEAT:
- if ((value > 0) &&
- (value <= AVRC_PLAYER_VAL_GROUP_REPEAT))
- result=TRUE;
- break;
+ if ((value > 0) &&
+ (value <= AVRC_PLAYER_VAL_GROUP_REPEAT)) {
+ result = TRUE;
+ }
+ break;
case AVRC_PLAYER_SETTING_SHUFFLE:
case AVRC_PLAYER_SETTING_SCAN:
- if ((value > 0) &&
- (value <= AVRC_PLAYER_VAL_GROUP_SHUFFLE))
- result=TRUE;
- break;
+ if ((value > 0) &&
+ (value <= AVRC_PLAYER_VAL_GROUP_SHUFFLE)) {
+ result = TRUE;
+ }
+ break;
}
- if (attrib >= AVRC_PLAYER_SETTING_LOW_MENU_EXT)
- result = TRUE;
+ if (attrib >= AVRC_PLAYER_SETTING_LOW_MENU_EXT) {
+ result = TRUE;
+ }
if (!result)
AVRC_TRACE_ERROR(
*******************************************************************************/
BOOLEAN AVRC_IsValidPlayerAttr(UINT8 attr)
{
- BOOLEAN result=FALSE;
+ BOOLEAN result = FALSE;
if ( (attr >= AVRC_PLAYER_SETTING_EQUALIZER && attr <= AVRC_PLAYER_SETTING_SCAN) ||
- (attr >= AVRC_PLAYER_SETTING_LOW_MENU_EXT) )
- {
- result = TRUE;
+ (attr >= AVRC_PLAYER_SETTING_LOW_MENU_EXT) ) {
+ result = TRUE;
}
return result;
UINT16 id;
tAVRC_STS status = AVRC_STS_BAD_CMD;
- if (p_msg->op_id == AVRC_ID_VENDOR && p_msg->pass_len == AVRC_PASS_THRU_GROUP_LEN)
- {
+ if (p_msg->op_id == AVRC_ID_VENDOR && p_msg->pass_len == AVRC_PASS_THRU_GROUP_LEN) {
p_data = p_msg->p_pass_data;
AVRC_BE_STREAM_TO_CO_ID (co_id, p_data);
- if (co_id == AVRC_CO_METADATA)
- {
+ if (co_id == AVRC_CO_METADATA) {
BE_STREAM_TO_UINT16 (id, p_data);
- if (AVRC_IS_VALID_GROUP(id))
- {
+ if (AVRC_IS_VALID_GROUP(id)) {
*p_vendor_unique_id = id;
status = AVRC_STS_NO_ERROR;
}
{
UINT8 opcode = 0;
- switch (pdu)
- {
+ switch (pdu) {
case AVRC_PDU_NEXT_GROUP:
case AVRC_PDU_PREV_GROUP: /* pass thru */
opcode = AVRC_OP_PASS_THRU;
BOOLEAN avrc_is_valid_opcode(UINT8 opcode)
{
BOOLEAN is_valid = FALSE;
- switch (opcode)
- {
+ switch (opcode) {
case AVRC_OP_BROWSE:
case AVRC_OP_PASS_THRU:
case AVRC_OP_VENDOR:
#if (AVRC_METADATA_INCLUDED == TRUE)
/* type for Metadata fragmentation control block */
-typedef struct
-{
+typedef struct {
BT_HDR *p_fmsg; /* the fragmented message */
UINT8 frag_pdu; /* the PDU ID for fragmentation */
BOOLEAN frag_enabled; /* fragmentation flag */
} tAVRC_FRAG_CB;
/* type for Metadata re-assembly control block */
-typedef struct
-{
+typedef struct {
BT_HDR *p_rmsg; /* the received message */
UINT16 rasm_offset; /* re-assembly flag, the offset of the start fragment */
UINT8 rasm_pdu; /* the PDU ID for re-assembly */
} tAVRC_RASM_CB;
#endif
-typedef struct
-{
+typedef struct {
tAVRC_CONN_CB ccb[AVCT_NUM_CONN];
#if (AVRC_METADATA_INCLUDED == TRUE)
tAVRC_FRAG_CB fcb[AVCT_NUM_CONN];
extern BOOLEAN avrc_is_valid_pdu_id(UINT8 pdu_id);
extern BOOLEAN avrc_is_valid_player_attrib_value(UINT8 attrib, UINT8 value);
-extern BT_HDR * avrc_alloc_ctrl_pkt (UINT8 pdu);
+extern BT_HDR *avrc_alloc_ctrl_pkt (UINT8 pdu);
extern tAVRC_STS avrc_pars_pass_thru(tAVRC_MSG_PASS *p_msg, UINT16 *p_vendor_unique_id);
extern UINT8 avrc_opcode_from_pdu(UINT8 pdu);
extern BOOLEAN avrc_is_valid_opcode(UINT8 opcode);
/* This data type is used in A2D_FindService() to initialize the SDP database
* to hold the result service search. */
-typedef struct
-{
+typedef struct {
UINT32 db_len; /* Length, in bytes, of the discovery database */
UINT16 num_attr;/* The number of attributes in p_attrs */
tSDP_DISCOVERY_DB *p_db; /* Pointer to the discovery database */
} tA2D_SDP_DB_PARAMS;
/* This data type is used in tA2D_FIND_CBACK to report the result of the SDP discovery process. */
-typedef struct
-{
+typedef struct {
UINT16 service_len; /* Length, in bytes, of the service name */
UINT16 provider_len; /* Length, in bytes, of the provider name */
- char * p_service_name; /* Pointer the service name. This character string may not be null terminated.
+ char *p_service_name; /* Pointer the service name. This character string may not be null terminated.
* Use the service_len parameter to safely copy this string */
- char * p_provider_name;/* Pointer the provider name. This character string may not be null terminated.
+ char *p_provider_name;/* Pointer the provider name. This character string may not be null terminated.
* Use the provider_len parameter to safely copy this string */
UINT16 features; /* Profile supported features */
UINT16 avdt_version; /* AVDTP protocol version */
} tA2D_Service;
/* This is the callback to notify the result of the SDP discovery process. */
-typedef void (tA2D_FIND_CBACK)(BOOLEAN found, tA2D_Service * p_service);
+typedef void (tA2D_FIND_CBACK)(BOOLEAN found, tA2D_Service *p_service);
/*****************************************************************************
**
******************************************************************************/
extern tA2D_STATUS A2D_AddRecord(UINT16 service_uuid, char *p_service_name, char *p_provider_name,
- UINT16 features, UINT32 sdp_handle);
+ UINT16 features, UINT32 sdp_handle);
/******************************************************************************
**
*****************************************************************************/
/* data type for the SBC Codec Information Element*/
-typedef struct
-{
+typedef struct {
UINT8 samp_freq; /* Sampling frequency */
UINT8 ch_mode; /* Channel mode */
UINT8 block_len; /* Block length */
** Type Definitions
*****************************************************************************/
-typedef struct
-{
+typedef struct {
UINT32 ntp_sec; /* NTP time: seconds relative to 0h UTC on 1 January 1900 */
UINT32 ntp_frac; /* NTP time: the fractional part */
UINT32 rtp_time; /* timestamp in RTP header */
UINT32 octet_count; /* sender's octet count: same comment */
} tAVDT_SENDER_INFO;
-typedef struct
-{
+typedef struct {
UINT8 frag_lost; /* fraction lost since last RR */
UINT32 packet_lost; /* cumulative number of packets lost since the beginning */
UINT32 seq_num_rcvd; /* extended highest sequence number received */
UINT32 dlsr; /* delay since last SR */
} tAVDT_REPORT_BLK;
-typedef union
-{
+typedef union {
tAVDT_SENDER_INFO sr;
tAVDT_REPORT_BLK rr;
UINT8 cname[AVDT_MAX_CNAME_SIZE + 1];
** This function is required for SNK endpoints and not applicable for SRC endpoints.
*/
typedef void (tAVDT_MEDIA_CBACK)(UINT8 handle, UINT8 *p_payload, UINT32 payload_len,
- UINT32 time_stamp, UINT16 seq_num, UINT8 m_pt, UINT8 marker);
+ UINT32 time_stamp, UINT16 seq_num, UINT8 m_pt, UINT8 marker);
#endif
#if AVDT_REPORTING == TRUE
** created with AVDT_PSC_REPORT.
*/
typedef void (tAVDT_REPORT_CBACK)(UINT8 handle, AVDT_REPORT_TYPE type,
- tAVDT_REPORT_DATA *p_data);
+ tAVDT_REPORT_DATA *p_data);
#endif
typedef UINT16 (tAVDT_GETCAP_REQ) (BD_ADDR bd_addr, UINT8 seid, tAVDT_CFG *p_cfg, tAVDT_CTRL_CBACK *p_cback);
* send messages. */
#define AVRC_UNCONG_IND_EVT 3
- /* AVRC_BROWSE_OPEN_IND_EVT event is sent when the browse channel is successfully opened.
- * This eventis sent in response to an AVRC_Open() or AVRC_OpenBrowse() . */
+/* AVRC_BROWSE_OPEN_IND_EVT event is sent when the browse channel is successfully opened.
+* This eventis sent in response to an AVRC_Open() or AVRC_OpenBrowse() . */
#define AVRC_BROWSE_OPEN_IND_EVT 4
/* AVRC_BROWSE_CLOSE_IND_EVT event is sent when a browse channel is closed.
/* This data type is used in AVRC_FindService() to initialize the SDP database
* to hold the result service search. */
-typedef struct
-{
+typedef struct {
UINT32 db_len; /* Length, in bytes, of the discovery database */
tSDP_DISCOVERY_DB *p_db; /* Pointer to the discovery database */
UINT16 num_attr;/* The number of attributes in p_attrs */
/* This is the control callback function. This function passes events
* listed in Table 20 to the application. */
typedef void (tAVRC_CTRL_CBACK) (UINT8 handle, UINT8 event, UINT16 result,
- BD_ADDR peer_addr);
+ BD_ADDR peer_addr);
/* This is the message callback function. It is executed when AVCTP has
* callback function must copy the tAVRC_MSG structure passed to it as it
* is not guaranteed to remain after the callback function exits. */
typedef void (tAVRC_MSG_CBACK) (UINT8 handle, UINT8 label, UINT8 opcode,
- tAVRC_MSG *p_msg);
+ tAVRC_MSG *p_msg);
-typedef struct
-{
+typedef struct {
tAVRC_CTRL_CBACK *p_ctrl_cback; /* pointer to application control callback */
tAVRC_MSG_CBACK *p_msg_cback; /* pointer to application message callback */
UINT32 company_id; /* the company ID */
**
******************************************************************************/
extern UINT16 AVRC_AddRecord(UINT16 service_uuid, char *p_service_name,
- char *p_provider_name, UINT16 categories, UINT32 sdp_handle);
+ char *p_provider_name, UINT16 categories, UINT32 sdp_handle);
/******************************************************************************
**
/*
This structure contains the header parameters of an AV/C message.
*/
-typedef struct
-{
+typedef struct {
UINT8 ctype; /* Command type. */
UINT8 subunit_type; /* Subunit type. */
UINT8 subunit_id; /* Subunit ID. This value is typically ignored in AVRCP,
} tAVRC_HDR;
/* This structure contains a UNIT INFO message. */
-typedef struct
-{
+typedef struct {
tAVRC_HDR hdr; /* Message header. */
UINT32 company_id; /* Company identifier. */
UINT8 unit_type; /* Unit type. Uses the same values as subunit type. */
} tAVRC_MSG_UNIT;
/* This structure contains a SUBUNIT INFO message. */
-typedef struct
-{
+typedef struct {
tAVRC_HDR hdr; /* Message header. */
UINT8 subunit_type[AVRC_SUB_TYPE_LEN];
- /* Array containing subunit type values. */
+ /* Array containing subunit type values. */
BOOLEAN panel; /* TRUE if the panel subunit type is in the
* subunit_type array, FALSE otherwise. */
UINT8 page; /* Specifies which part of the subunit type table is
} tAVRC_MSG_SUB;
/* This structure contains a VENDOR DEPENDENT message. */
-typedef struct
-{
+typedef struct {
tAVRC_HDR hdr; /* Message header. */
UINT32 company_id; /* Company identifier. */
UINT8 *p_vendor_data;/* Pointer to vendor dependent data. */
} tAVRC_MSG_VENDOR;
/* PASS THROUGH message structure */
-typedef struct
-{
+typedef struct {
tAVRC_HDR hdr; /* hdr.ctype Unused.
* hdr.subunit_type Unused.
* hdr.subunit_id Unused. */
#define AVRC_RSP AVCT_RSP /* Response message */
/* Browsing channel message structure */
-typedef struct
-{
+typedef struct {
tAVRC_HDR hdr; /* hdr.ctype AVRC_CMD or AVRC_RSP.
* hdr.subunit_type Unused.
* hdr.subunit_id Unused. */
} tAVRC_MSG_BROWSE;
/* This is a union of all message type structures. */
-typedef union
-{
+typedef union {
tAVRC_HDR hdr; /* Message header. */
tAVRC_MSG_UNIT unit; /* UNIT INFO message. */
tAVRC_MSG_SUB sub; /* SUBUNIT INFO message. */
(a <= AVRC_EVT_APP_SETTING_CHANGE)) ? TRUE : FALSE)
#define AVRC_IS_VALID_ATTRIBUTE(a) (((((a > 0) && a <= AVRC_PLAYER_SETTING_SCAN)) || \
- (a >= AVRC_PLAYER_SETTING_LOW_MENU_EXT)) ? TRUE : FALSE)
+ (a >= AVRC_PLAYER_SETTING_LOW_MENU_EXT)) ? TRUE : FALSE)
#define AVRC_IS_VALID_MEDIA_ATTRIBUTE(a) ((a >= AVRC_MEDIA_ATTR_ID_TITLE) && \
(a <= AVRC_MEDIA_ATTR_ID_PLAYING_TIME) ? TRUE : FALSE)
#define AVRC_CAP_MAX_NUM_EVT_ID 16
#endif
-typedef union
-{
+typedef union {
UINT32 company_id[AVRC_CAP_MAX_NUM_COMP_ID];
UINT8 event_id[AVRC_CAP_MAX_NUM_EVT_ID];
} tAVRC_CAPS_PARAM;
-typedef struct
-{
+typedef struct {
UINT8 attr_id;
UINT8 attr_val;
} tAVRC_APP_SETTING;
-typedef struct
-{
+typedef struct {
UINT8 attr_id;
UINT16 charset_id;
UINT8 str_len;
typedef UINT8 tAVRC_FEATURE_MASK[AVRC_FEATURE_MASK_SIZE];
-typedef struct
-{
+typedef struct {
UINT16 player_id; /* A unique identifier for this media player.*/
UINT8 major_type; /* Use AVRC_MJ_TYPE_AUDIO, AVRC_MJ_TYPE_VIDEO, AVRC_MJ_TYPE_BC_AUDIO, or AVRC_MJ_TYPE_BC_VIDEO.*/
UINT32 sub_type; /* Use AVRC_SUB_TYPE_NONE, AVRC_SUB_TYPE_AUDIO_BOOK, or AVRC_SUB_TYPE_PODCAST*/
tAVRC_FULL_NAME name; /* The player name, name length and character set id.*/
} tAVRC_ITEM_PLAYER;
-typedef struct
-{
+typedef struct {
tAVRC_UID uid; /* The uid of this folder */
UINT8 type; /* Use AVRC_FOLDER_TYPE_MIXED, AVRC_FOLDER_TYPE_TITLES,
AVRC_FOLDER_TYPE_ALNUMS, AVRC_FOLDER_TYPE_ARTISTS, AVRC_FOLDER_TYPE_GENRES,
tAVRC_FULL_NAME name; /* The folder name, name length and character set id. */
} tAVRC_ITEM_FOLDER;
-typedef struct
-{
+typedef struct {
UINT32 attr_id; /* Use AVRC_MEDIA_ATTR_ID_TITLE, AVRC_MEDIA_ATTR_ID_ARTIST, AVRC_MEDIA_ATTR_ID_ALBUM,
AVRC_MEDIA_ATTR_ID_TRACK_NUM, AVRC_MEDIA_ATTR_ID_NUM_TRACKS,
AVRC_MEDIA_ATTR_ID_GENRE, AVRC_MEDIA_ATTR_ID_PLAYING_TIME */
tAVRC_FULL_NAME name; /* The attribute value, value length and character set id. */
} tAVRC_ATTR_ENTRY;
-typedef struct
-{
+typedef struct {
tAVRC_UID uid; /* The uid of this media element item */
UINT8 type; /* Use AVRC_MEDIA_TYPE_AUDIO or AVRC_MEDIA_TYPE_VIDEO. */
tAVRC_FULL_NAME name; /* The media name, name length and character set id. */
UINT8 attr_count; /* The number of attributes in p_attr_list */
- tAVRC_ATTR_ENTRY* p_attr_list; /* Attribute entry list. */
+ tAVRC_ATTR_ENTRY *p_attr_list; /* Attribute entry list. */
} tAVRC_ITEM_MEDIA;
-typedef struct
-{
+typedef struct {
UINT8 item_type; /* AVRC_ITEM_PLAYER, AVRC_ITEM_FOLDER, or AVRC_ITEM_MEDIA */
- union
- {
+ union {
tAVRC_ITEM_PLAYER player; /* The properties of a media player item.*/
tAVRC_ITEM_FOLDER folder; /* The properties of a folder item.*/
tAVRC_ITEM_MEDIA media; /* The properties of a media item.*/
} tAVRC_ITEM;
/* GetCapability */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (assigned by AVRC_BldCommand according to pdu) */
} tAVRC_GET_CAPS_CMD;
/* ListPlayerAppValues */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (assigned by AVRC_BldCommand according to pdu) */
} tAVRC_LIST_APP_VALUES_CMD;
/* GetCurAppValue */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (assigned by AVRC_BldCommand according to pdu) */
} tAVRC_GET_CUR_APP_VALUE_CMD;
/* SetAppValue */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (assigned by AVRC_BldCommand according to pdu) */
} tAVRC_SET_APP_VALUE_CMD;
/* GetAppAttrTxt */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (assigned by AVRC_BldCommand according to pdu) */
} tAVRC_GET_APP_ATTR_TXT_CMD;
/* GetAppValueTxt */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (assigned by AVRC_BldCommand according to pdu) */
} tAVRC_GET_APP_VAL_TXT_CMD;
/* InformCharset */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (assigned by AVRC_BldCommand according to pdu) */
} tAVRC_INFORM_CHARSET_CMD;
/* InformBatteryStatus */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (assigned by AVRC_BldCommand according to pdu) */
} tAVRC_BATTERY_STATUS_CMD;
/* GetElemAttrs */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (assigned by AVRC_BldCommand according to pdu) */
} tAVRC_GET_ELEM_ATTRS_CMD;
/* RegNotify */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (assigned by AVRC_BldCommand according to pdu) */
} tAVRC_REG_NOTIF_CMD;
/* SetAddrPlayer */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (assigned by AVRC_BldCommand according to pdu) */
} tAVRC_SET_ADDR_PLAYER_CMD;
/* SetBrowsedPlayer */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (assigned by AVRC_BldCommand according to pdu) */
} tAVRC_SET_BR_PLAYER_CMD;
/* SetAbsVolume */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (assigned by AVRC_BldCommand according to pdu) */
} tAVRC_SET_VOLUME_CMD;
/* GetFolderItems */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (assigned by AVRC_BldCommand according to pdu) */
} tAVRC_GET_ITEMS_CMD;
/* ChangePath */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (assigned by AVRC_BldCommand according to pdu) */
} tAVRC_CHG_PATH_CMD;
/* GetItemAttrs */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (assigned by AVRC_BldCommand according to pdu) */
} tAVRC_GET_ATTRS_CMD;
/* Search */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (assigned by AVRC_BldCommand according to pdu) */
} tAVRC_SEARCH_CMD;
/* PlayItem */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (assigned by AVRC_BldCommand according to pdu) */
} tAVRC_PLAY_ITEM_CMD;
/* AddToNowPlaying */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (assigned by AVRC_BldCommand according to pdu) */
UINT16 uid_counter;
} tAVRC_ADD_TO_PLAY_CMD;
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (assigned by AVRC_BldCommand according to pdu) */
} tAVRC_CMD;
/* Continue and Abort */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (assigned by AVRC_BldCommand according to pdu) */
UINT8 target_pdu;
} tAVRC_NEXT_CMD;
-typedef union
-{
+typedef union {
UINT8 pdu;
tAVRC_CMD cmd;
tAVRC_GET_CAPS_CMD get_caps; /* GetCapability */
} tAVRC_COMMAND;
/* GetCapability */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (copied from avrc_cmd.opcode by AVRC_BldResponse user. invalid one to generate according to pdu) */
} tAVRC_GET_CAPS_RSP;
/* ListPlayerAppAttr */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (copied from avrc_cmd.opcode by AVRC_BldResponse user. invalid one to generate according to pdu) */
} tAVRC_LIST_APP_ATTR_RSP;
/* ListPlayerAppValues */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (copied from avrc_cmd.opcode by AVRC_BldResponse user. invalid one to generate according to pdu) */
} tAVRC_LIST_APP_VALUES_RSP;
/* GetCurAppValue */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (copied from avrc_cmd.opcode by AVRC_BldResponse user. invalid one to generate according to pdu) */
} tAVRC_GET_CUR_APP_VALUE_RSP;
/* GetAppAttrTxt */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (copied from avrc_cmd.opcode by AVRC_BldResponse user. invalid one to generate according to pdu) */
} tAVRC_GET_APP_ATTR_TXT_RSP;
/* GetElemAttrs */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (copied from avrc_cmd.opcode by AVRC_BldResponse user. invalid one to generate according to pdu) */
} tAVRC_GET_ELEM_ATTRS_RSP;
/* GetPlayStatus */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (copied from avrc_cmd.opcode by AVRC_BldResponse user. invalid one to generate according to pdu) */
} tAVRC_GET_PLAY_STATUS_RSP;
/* notification event parameter for AddressedPlayer change */
-typedef struct
-{
+typedef struct {
UINT16 player_id;
UINT16 uid_counter;
} tAVRC_ADDR_PLAYER_PARAM;
#endif
/* notification event parameter for Player Application setting change */
-typedef struct
-{
+typedef struct {
UINT8 num_attr;
UINT8 attr_id[AVRC_MAX_APP_SETTINGS];
UINT8 attr_value[AVRC_MAX_APP_SETTINGS];
} tAVRC_PLAYER_APP_PARAM;
-typedef union
-{
+typedef union {
tAVRC_PLAYSTATE play_status;
tAVRC_UID track;
UINT32 play_pos;
} tAVRC_NOTIF_RSP_PARAM;
/* RegNotify */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (copied from avrc_cmd.opcode by AVRC_BldResponse user. invalid one to generate according to pdu) */
} tAVRC_REG_NOTIF_RSP;
/* SetAbsVolume */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (copied from avrc_cmd.opcode by AVRC_BldResponse user. invalid one to generate according to pdu) */
} tAVRC_SET_VOLUME_RSP;
/* SetBrowsedPlayer */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (copied from avrc_cmd.opcode by AVRC_BldResponse user. invalid one to generate according to pdu) */
} tAVRC_SET_BR_PLAYER_RSP;
/* GetFolderItems */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (copied from avrc_cmd.opcode by AVRC_BldResponse user. invalid one to generate according to pdu) */
} tAVRC_GET_ITEMS_RSP;
/* ChangePath */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (copied from avrc_cmd.opcode by AVRC_BldResponse user. invalid one to generate according to pdu) */
} tAVRC_CHG_PATH_RSP;
/* GetItemAttrs */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (copied from avrc_cmd.opcode by AVRC_BldResponse user. invalid one to generate according to pdu) */
} tAVRC_GET_ATTRS_RSP;
/* Search */
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (copied from avrc_cmd.opcode by AVRC_BldResponse user. invalid one to generate according to pdu) */
} tAVRC_SEARCH_RSP;
-typedef struct
-{
+typedef struct {
UINT8 pdu;
tAVRC_STS status;
UINT8 opcode; /* Op Code (copied from avrc_cmd.opcode by AVRC_BldResponse user. invalid one to generate according to pdu) */
} tAVRC_RSP;
-typedef union
-{
+typedef union {
UINT8 pdu;
tAVRC_RSP rsp;
tAVRC_GET_CAPS_RSP get_caps; /* GetCapability */
projects / esp-idf / commitdiff