1 /****************************************************************************** 2 * 3 * Copyright (C) 2004-2012 Broadcom Corporation 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at: 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 ******************************************************************************/ 18 19 /****************************************************************************** 20 * 21 * This is the main implementation file for the BTA advanced audio/video. 22 * 23 ******************************************************************************/ 24 25 #include <assert.h> 26 #include <string.h> 27 28 #include "bt_target.h" 29 #include "osi/include/log.h" 30 31 #if defined(BTA_AV_INCLUDED) && (BTA_AV_INCLUDED == TRUE) 32 #include "bta_av_int.h" 33 #include "utl.h" 34 #include "l2c_api.h" 35 #include "l2cdefs.h" 36 #include "bta_av_co.h" 37 #if( defined BTA_AR_INCLUDED ) && (BTA_AR_INCLUDED == TRUE) 38 #include "bta_ar_api.h" 39 #endif 40 41 /***************************************************************************** 42 ** Constants and types 43 *****************************************************************************/ 44 45 /* AVDTP protocol timeout values */ 46 #define BTIF_AVK_SERVICE_NAME "Advanced Audio Sink" 47 48 #ifndef BTA_AV_RET_TOUT 49 #define BTA_AV_RET_TOUT 4 50 #endif 51 52 #ifndef BTA_AV_SIG_TOUT 53 #define BTA_AV_SIG_TOUT 4 54 #endif 55 56 #ifndef BTA_AV_IDLE_TOUT 57 #define BTA_AV_IDLE_TOUT 10 58 #endif 59 60 /* the delay time in milliseconds to retry role switch */ 61 #ifndef BTA_AV_RS_TIME_VAL 62 #define BTA_AV_RS_TIME_VAL 1000 63 #endif 64 65 /* state machine states */ 66 enum 67 { 68 BTA_AV_INIT_ST, 69 BTA_AV_OPEN_ST 70 }; 71 72 /* state machine action enumeration list */ 73 enum 74 { 75 BTA_AV_DISABLE, 76 BTA_AV_RC_OPENED, 77 BTA_AV_RC_REMOTE_CMD, 78 BTA_AV_RC_VENDOR_CMD, 79 BTA_AV_RC_VENDOR_RSP, 80 BTA_AV_RC_FREE_RSP, 81 BTA_AV_RC_FREE_MSG, 82 BTA_AV_RC_META_RSP, 83 BTA_AV_RC_MSG, 84 BTA_AV_RC_CLOSE, 85 BTA_AV_NUM_ACTIONS 86 }; 87 88 #define BTA_AV_IGNORE BTA_AV_NUM_ACTIONS 89 90 /* type for action functions */ 91 typedef void (*tBTA_AV_ACTION)(tBTA_AV_CB *p_cb, tBTA_AV_DATA *p_data); 92 93 /* action functions */ 94 const tBTA_AV_ACTION bta_av_action[] = 95 { 96 bta_av_disable, 97 bta_av_rc_opened, 98 bta_av_rc_remote_cmd, 99 bta_av_rc_vendor_cmd, 100 bta_av_rc_vendor_rsp, 101 bta_av_rc_free_rsp, 102 bta_av_rc_free_msg, 103 bta_av_rc_meta_rsp, 104 bta_av_rc_msg, 105 bta_av_rc_close, 106 NULL 107 }; 108 109 /* state table information */ 110 #define BTA_AV_ACTION_COL 0 /* position of actions */ 111 #define BTA_AV_NEXT_STATE 1 /* position of next state */ 112 #define BTA_AV_NUM_COLS 2 /* number of columns in state tables */ 113 114 /* state table for init state */ 115 static const UINT8 bta_av_st_init[][BTA_AV_NUM_COLS] = 116 { 117 /* Event Action 1 Next state */ 118 /* API_DISABLE_EVT */ {BTA_AV_DISABLE, BTA_AV_INIT_ST }, 119 /* API_REMOTE_CMD_EVT */ {BTA_AV_IGNORE, BTA_AV_INIT_ST }, 120 /* API_VENDOR_CMD_EVT */ {BTA_AV_IGNORE, BTA_AV_INIT_ST }, 121 /* API_VENDOR_RSP_EVT */ {BTA_AV_IGNORE, BTA_AV_INIT_ST }, 122 /* API_META_RSP_EVT */ {BTA_AV_RC_FREE_RSP, BTA_AV_INIT_ST }, 123 /* API_RC_CLOSE_EVT */ {BTA_AV_IGNORE, BTA_AV_INIT_ST }, 124 /* AVRC_OPEN_EVT */ {BTA_AV_RC_OPENED, BTA_AV_OPEN_ST }, 125 /* AVRC_MSG_EVT */ {BTA_AV_RC_FREE_MSG, BTA_AV_INIT_ST }, 126 /* AVRC_NONE_EVT */ {BTA_AV_IGNORE, BTA_AV_INIT_ST }, 127 }; 128 129 /* state table for open state */ 130 static const UINT8 bta_av_st_open[][BTA_AV_NUM_COLS] = 131 { 132 /* Event Action 1 Next state */ 133 /* API_DISABLE_EVT */ {BTA_AV_DISABLE, BTA_AV_INIT_ST }, 134 /* API_REMOTE_CMD_EVT */ {BTA_AV_RC_REMOTE_CMD, BTA_AV_OPEN_ST }, 135 /* API_VENDOR_CMD_EVT */ {BTA_AV_RC_VENDOR_CMD, BTA_AV_OPEN_ST }, 136 /* API_VENDOR_RSP_EVT */ {BTA_AV_RC_VENDOR_RSP, BTA_AV_OPEN_ST }, 137 /* API_META_RSP_EVT */ {BTA_AV_RC_META_RSP, BTA_AV_OPEN_ST }, 138 /* API_RC_CLOSE_EVT */ {BTA_AV_RC_CLOSE, BTA_AV_OPEN_ST }, 139 /* AVRC_OPEN_EVT */ {BTA_AV_RC_OPENED, BTA_AV_OPEN_ST }, 140 /* AVRC_MSG_EVT */ {BTA_AV_RC_MSG, BTA_AV_OPEN_ST }, 141 /* AVRC_NONE_EVT */ {BTA_AV_IGNORE, BTA_AV_INIT_ST }, 142 }; 143 144 /* type for state table */ 145 typedef const UINT8 (*tBTA_AV_ST_TBL)[BTA_AV_NUM_COLS]; 146 147 /* state table */ 148 static const tBTA_AV_ST_TBL bta_av_st_tbl[] = 149 { 150 bta_av_st_init, 151 bta_av_st_open 152 }; 153 154 typedef void (*tBTA_AV_NSM_ACT)(tBTA_AV_DATA *p_data); 155 static void bta_av_api_enable(tBTA_AV_DATA *p_data); 156 static void bta_av_api_register(tBTA_AV_DATA *p_data); 157 #if (BTA_AV_SINK_INCLUDED == TRUE) 158 static void bta_av_api_sink_enable(tBTA_AV_DATA *p_data); 159 #endif 160 static void bta_av_ci_data(tBTA_AV_DATA *p_data); 161 #if (AVDT_REPORTING == TRUE) 162 static void bta_av_rpc_conn(tBTA_AV_DATA *p_data); 163 #endif 164 static void bta_av_api_to_ssm(tBTA_AV_DATA *p_data); 165 166 static void bta_av_sco_chg_cback(tBTA_SYS_CONN_STATUS status, UINT8 id, UINT8 167 app_id, BD_ADDR peer_addr); 168 static void bta_av_sys_rs_cback (tBTA_SYS_CONN_STATUS status,UINT8 id, UINT8 app_id, BD_ADDR peer_addr); 169 170 171 /* action functions */ 172 const tBTA_AV_NSM_ACT bta_av_nsm_act[] = 173 { 174 bta_av_api_enable, /* BTA_AV_API_ENABLE_EVT */ 175 bta_av_api_register, /* BTA_AV_API_REGISTER_EVT */ 176 bta_av_api_deregister, /* BTA_AV_API_DEREGISTER_EVT */ 177 bta_av_api_disconnect, /* BTA_AV_API_DISCONNECT_EVT */ 178 bta_av_ci_data, /* BTA_AV_CI_SRC_DATA_READY_EVT */ 179 bta_av_sig_chg, /* BTA_AV_SIG_CHG_EVT */ 180 bta_av_sig_timer, /* BTA_AV_SIG_TIMER_EVT */ 181 bta_av_rc_disc_done, /* BTA_AV_SDP_AVRC_DISC_EVT */ 182 bta_av_rc_closed, /* BTA_AV_AVRC_CLOSE_EVT */ 183 bta_av_conn_chg, /* BTA_AV_CONN_CHG_EVT */ 184 bta_av_dereg_comp, /* BTA_AV_DEREG_COMP_EVT */ 185 #if (BTA_AV_SINK_INCLUDED == TRUE) 186 bta_av_api_sink_enable, /* BTA_AV_API_SINK_ENABLE_EVT */ 187 #endif 188 #if (AVDT_REPORTING == TRUE) 189 bta_av_rpc_conn, /* BTA_AV_AVDT_RPT_CONN_EVT */ 190 #endif 191 bta_av_api_to_ssm, /* BTA_AV_API_START_EVT */ 192 bta_av_api_to_ssm, /* BTA_AV_API_STOP_EVT */ 193 }; 194 195 /***************************************************************************** 196 ** Global data 197 *****************************************************************************/ 198 199 /* AV control block */ 200 #if BTA_DYNAMIC_MEMORY == FALSE 201 tBTA_AV_CB bta_av_cb; 202 #endif 203 204 #if (defined(BTA_AV_DEBUG) && BTA_AV_DEBUG == TRUE) 205 static char *bta_av_st_code(UINT8 state); 206 #endif 207 208 /******************************************************************************* 209 ** 210 ** Function bta_av_timer_cback 211 ** 212 ** Description forward the event to stream state machine 213 ** 214 ** Returns void 215 ** 216 *******************************************************************************/ 217 static void bta_av_timer_cback(void *p_tle) 218 { 219 BT_HDR *p_buf; 220 TIMER_LIST_ENT *p = (TIMER_LIST_ENT *)p_tle; 221 int xx; 222 tBTA_AV_SCB *p_scb = NULL; 223 224 /* find the SCB that has the timer */ 225 for(xx=0; xx<BTA_AV_NUM_STRS; xx++) 226 { 227 if(bta_av_cb.p_scb[xx] && &(bta_av_cb.p_scb[xx]->timer)== p) 228 { 229 p_scb = bta_av_cb.p_scb[xx]; 230 break; 231 } 232 } 233 234 if (p_scb && (p_buf = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL) 235 { 236 /* send the event through the audio state machine. 237 * only when the audio SM is open, the main SM opens the RC connection as INT */ 238 p_buf->event = p->event; 239 p_buf->layer_specific = p_scb->hndl; 240 bta_sys_sendmsg(p_buf); 241 } 242 } 243 244 /******************************************************************************* 245 ** 246 ** Function bta_av_api_enable 247 ** 248 ** Description Handle an API enable event. 249 ** 250 ** 251 ** Returns void 252 ** 253 *******************************************************************************/ 254 static void bta_av_api_enable(tBTA_AV_DATA *p_data) 255 { 256 int i; 257 tBTA_AV_ENABLE enable; 258 259 /* initialize control block */ 260 memset(&bta_av_cb, 0, sizeof(tBTA_AV_CB)); 261 262 for(i=0; i<BTA_AV_NUM_RCB; i++) 263 bta_av_cb.rcb[i].handle = BTA_AV_RC_HANDLE_NONE; 264 265 bta_av_cb.rc_acp_handle = BTA_AV_RC_HANDLE_NONE; 266 267 /* store parameters */ 268 bta_av_cb.p_cback = p_data->api_enable.p_cback; 269 bta_av_cb.features = p_data->api_enable.features; 270 bta_av_cb.sec_mask = p_data->api_enable.sec_mask; 271 272 enable.features = bta_av_cb.features; 273 274 /* Register for SCO change event */ 275 if (!(bta_av_cb.features & BTA_AV_FEAT_NO_SCO_SSPD)) 276 { 277 bta_sys_sco_register(bta_av_sco_chg_cback); 278 } 279 280 /* call callback with enable event */ 281 (*bta_av_cb.p_cback)(BTA_AV_ENABLE_EVT, (tBTA_AV *)&enable); 282 } 283 284 /******************************************************************************* 285 ** 286 ** Function bta_av_addr_to_scb 287 ** 288 ** Description find the stream control block by the peer addr 289 ** 290 ** Returns void 291 ** 292 *******************************************************************************/ 293 static tBTA_AV_SCB * bta_av_addr_to_scb(BD_ADDR bd_addr) 294 { 295 tBTA_AV_SCB * p_scb = NULL; 296 int xx; 297 298 for(xx=0; xx<BTA_AV_NUM_STRS; xx++) 299 { 300 if(bta_av_cb.p_scb[xx]) 301 { 302 if(!bdcmp(bd_addr, bta_av_cb.p_scb[xx]->peer_addr)) 303 { 304 p_scb = bta_av_cb.p_scb[xx]; 305 break; 306 } 307 } 308 } 309 return p_scb; 310 } 311 312 /******************************************************************************* 313 ** 314 ** Function bta_av_hndl_to_scb 315 ** 316 ** Description find the stream control block by the handle 317 ** 318 ** Returns void 319 ** 320 *******************************************************************************/ 321 tBTA_AV_SCB * bta_av_hndl_to_scb(UINT16 handle) 322 { 323 tBTA_AV_HNDL hndl = (tBTA_AV_HNDL)handle; 324 tBTA_AV_SCB * p_scb = NULL; 325 UINT8 idx = (hndl & BTA_AV_HNDL_MSK); 326 327 if(idx && (idx <= BTA_AV_NUM_STRS) ) 328 { 329 p_scb = bta_av_cb.p_scb[idx-1]; 330 } 331 return p_scb; 332 } 333 334 /******************************************************************************* 335 ** 336 ** Function bta_av_alloc_scb 337 ** 338 ** Description allocate stream control block, 339 ** register the service to stack 340 ** create SDP record 341 ** 342 ** Returns void 343 ** 344 *******************************************************************************/ 345 static tBTA_AV_SCB * bta_av_alloc_scb(tBTA_AV_CHNL chnl) 346 { 347 tBTA_AV_SCB *p_ret = NULL; 348 int xx; 349 tBTA_AV_STATUS sts = BTA_AV_SUCCESS; 350 351 if(chnl == BTA_AV_CHNL_VIDEO) 352 { 353 if(p_bta_av_cfg->p_act_tbl == NULL || p_bta_av_cfg->p_reg == NULL) 354 { 355 APPL_TRACE_ERROR("Video streaming not supported"); 356 sts = BTA_AV_FAIL; 357 } 358 else 359 { 360 /* allow only one Video channel */ 361 if(bta_av_cb.reg_video) 362 { 363 APPL_TRACE_ERROR("Already registered"); 364 sts = BTA_AV_FAIL; 365 } 366 } 367 } 368 else if(chnl != BTA_AV_CHNL_AUDIO) 369 { 370 APPL_TRACE_ERROR("bad channel: %d", chnl); 371 sts = BTA_AV_FAIL; 372 } 373 374 if(sts == BTA_AV_SUCCESS) 375 { 376 for(xx=0; xx<BTA_AV_NUM_STRS; xx++) 377 { 378 if(bta_av_cb.p_scb[xx] == NULL) 379 { 380 /* found an empty spot */ 381 p_ret = (tBTA_AV_SCB *)GKI_getbuf(sizeof(tBTA_AV_SCB)); 382 if(p_ret) 383 { 384 memset(p_ret, 0, sizeof(tBTA_AV_SCB)); 385 p_ret->rc_handle = BTA_AV_RC_HANDLE_NONE; 386 p_ret->chnl = chnl; 387 p_ret->hndl = (tBTA_AV_HNDL)((xx + 1) | chnl); 388 p_ret->hdi = xx; 389 p_ret->a2d_list = list_new(NULL); 390 bta_av_cb.p_scb[xx] = p_ret; 391 } 392 break; 393 } 394 } 395 } 396 return p_ret; 397 } 398 399 /******************************************************************************* 400 ** 401 ** Function bta_av_free_scb 402 ** 403 ** Description free stream control block, 404 ** 405 ** 406 ** Returns void 407 ** 408 *******************************************************************************/ 409 static void bta_av_free_scb(tBTA_AV_SCB *p_scb) 410 { 411 // NOTE(google) This free currently is not called 412 assert(p_scb != NULL); 413 414 list_free(p_scb->a2d_list); 415 GKI_freebuf(p_scb); 416 } 417 418 /******************************************************************************* 419 *******************************************************************************/ 420 void bta_av_conn_cback(UINT8 handle, BD_ADDR bd_addr, UINT8 event, tAVDT_CTRL *p_data) 421 { 422 tBTA_AV_STR_MSG *p_msg; 423 UINT16 evt = 0; 424 tBTA_AV_SCB *p_scb = NULL; 425 UNUSED(handle); 426 427 #if( defined BTA_AR_INCLUDED ) && (BTA_AR_INCLUDED == TRUE) 428 if (event == BTA_AR_AVDT_CONN_EVT || 429 event == AVDT_CONNECT_IND_EVT || event == AVDT_DISCONNECT_IND_EVT) 430 #else 431 if (event == AVDT_CONNECT_IND_EVT || event == AVDT_DISCONNECT_IND_EVT) 432 #endif 433 { 434 evt = BTA_AV_SIG_CHG_EVT; 435 if(AVDT_DISCONNECT_IND_EVT == event) 436 p_scb = bta_av_addr_to_scb(bd_addr); 437 #if (defined(BTA_AV_DEBUG) && BTA_AV_DEBUG == TRUE) 438 else if (AVDT_CONNECT_IND_EVT == event) 439 { 440 APPL_TRACE_DEBUG("CONN_IND is ACP:%d", p_data->hdr.err_param); 441 } 442 #endif 443 444 if (/*((p_scb && (p_scb->role & BTA_AV_ROLE_AD_ACP)) || 445 446 //(AVDT_CONNECT_IND_EVT == event && AVDT_ACP == p_data->hdr.err_param)) 447 448 (AVDT_CONNECT_IND_EVT == event))&& */ 449 (p_msg = (tBTA_AV_STR_MSG *) GKI_getbuf((UINT16) (sizeof(tBTA_AV_STR_MSG)))) != NULL) 450 { 451 p_msg->hdr.event = evt; 452 p_msg->hdr.layer_specific = event; 453 p_msg->hdr.offset = p_data->hdr.err_param; 454 bdcpy(p_msg->bd_addr, bd_addr); 455 #if (defined(BTA_AV_DEBUG) && BTA_AV_DEBUG == TRUE) 456 if(p_scb) 457 { 458 APPL_TRACE_DEBUG("scb hndl x%x, role x%x", p_scb->hndl, p_scb->role); 459 } 460 #endif 461 APPL_TRACE_DEBUG("conn_cback bd_addr:%02x-%02x-%02x-%02x-%02x-%02x", 462 bd_addr[0], bd_addr[1], 463 bd_addr[2], bd_addr[3], 464 bd_addr[4], bd_addr[5]); 465 bta_sys_sendmsg(p_msg); 466 } 467 } 468 469 } 470 471 #if AVDT_REPORTING == TRUE 472 /******************************************************************************* 473 ** 474 ** Function bta_av_a2dp_report_cback 475 ** 476 ** Description A2DP report callback. 477 ** 478 ** Returns void 479 ** 480 *******************************************************************************/ 481 static void bta_av_a2dp_report_cback(UINT8 handle, AVDT_REPORT_TYPE type, 482 tAVDT_REPORT_DATA *p_data) 483 { 484 UNUSED(handle); 485 UNUSED(type); 486 UNUSED(p_data); 487 /* Do not need to handle report data for now. 488 * This empty function is here for conformance reasons. */ 489 } 490 #endif 491 492 #if (BTA_AV_SINK_INCLUDED == TRUE) 493 /******************************************************************************* 494 ** 495 ** Function bta_av_api_sink_enable 496 ** 497 ** Description activate, deactive A2DP Sink, 498 ** 499 ** Returns void 500 ** 501 *******************************************************************************/ 502 503 static void bta_av_api_sink_enable(tBTA_AV_DATA *p_data) 504 { 505 UINT16 activate_sink = 0; 506 activate_sink = p_data->hdr.layer_specific; 507 APPL_TRACE_DEBUG("bta_av_api_sink_enable %d ", activate_sink) 508 char p_service_name[BTA_SERVICE_NAME_LEN+1]; 509 BCM_STRNCPY_S(p_service_name, sizeof(p_service_name), 510 BTIF_AVK_SERVICE_NAME, BTA_SERVICE_NAME_LEN); 511 512 if(activate_sink) 513 { 514 AVDT_SINK_Activate(); 515 if (bta_av_cb.sdp_a2d_snk_handle == 0) 516 { 517 bta_av_cb.sdp_a2d_snk_handle = SDP_CreateRecord(); 518 A2D_AddRecord(UUID_SERVCLASS_AUDIO_SINK, p_service_name, NULL, 519 A2D_SUPF_PLAYER, bta_av_cb.sdp_a2d_snk_handle); 520 bta_sys_add_uuid(UUID_SERVCLASS_AUDIO_SINK); 521 } 522 } 523 else 524 { 525 AVDT_SINK_Deactivate(); 526 if (bta_av_cb.sdp_a2d_snk_handle != 0) 527 { 528 SDP_DeleteRecord(bta_av_cb.sdp_a2d_snk_handle); 529 bta_av_cb.sdp_a2d_snk_handle = 0; 530 bta_sys_remove_uuid(UUID_SERVCLASS_AUDIO_SINK); 531 } 532 } 533 } 534 #endif 535 /******************************************************************************* 536 ** 537 ** Function bta_av_api_register 538 ** 539 ** Description allocate stream control block, 540 ** register the service to stack 541 ** create SDP record 542 ** 543 ** Returns void 544 ** 545 *******************************************************************************/ 546 static void bta_av_api_register(tBTA_AV_DATA *p_data) 547 { 548 tBTA_AV_REGISTER registr; 549 tBTA_AV_SCB *p_scb; /* stream control block */ 550 tAVDT_REG reg; 551 tAVDT_CS cs; 552 char *p_service_name; 553 tBTA_AV_CODEC codec_type; 554 tBTA_UTL_COD cod; 555 UINT8 index = 0; 556 char p_avk_service_name[BTA_SERVICE_NAME_LEN+1]; 557 BCM_STRNCPY_S(p_avk_service_name, sizeof(p_avk_service_name), BTIF_AVK_SERVICE_NAME, BTA_SERVICE_NAME_LEN); 558 559 memset(&cs,0,sizeof(tAVDT_CS)); 560 561 registr.status = BTA_AV_FAIL_RESOURCES; 562 registr.app_id = p_data->api_reg.app_id; 563 registr.chnl = (tBTA_AV_CHNL)p_data->hdr.layer_specific; 564 do 565 { 566 p_scb = bta_av_alloc_scb(registr.chnl); 567 if(p_scb == NULL) 568 { 569 APPL_TRACE_ERROR("failed to alloc SCB"); 570 break; 571 } 572 573 registr.hndl = p_scb->hndl; 574 p_scb->app_id = registr.app_id; 575 576 /* initialize the stream control block */ 577 p_scb->timer.p_cback = (TIMER_CBACK*)&bta_av_timer_cback; 578 registr.status = BTA_AV_SUCCESS; 579 580 if((bta_av_cb.reg_audio + bta_av_cb.reg_video) == 0) 581 { 582 /* the first channel registered. register to AVDTP */ 583 reg.ctrl_mtu = p_bta_av_cfg->sig_mtu; 584 reg.ret_tout = BTA_AV_RET_TOUT; 585 reg.sig_tout = BTA_AV_SIG_TOUT; 586 reg.idle_tout = BTA_AV_IDLE_TOUT; 587 reg.sec_mask = bta_av_cb.sec_mask; 588 #if( defined BTA_AR_INCLUDED ) && (BTA_AR_INCLUDED == TRUE) 589 bta_ar_reg_avdt(®, bta_av_conn_cback, BTA_ID_AV); 590 #endif 591 bta_sys_role_chg_register(&bta_av_sys_rs_cback); 592 593 /* create remote control TG service if required */ 594 if (bta_av_cb.features & (BTA_AV_FEAT_RCTG)) 595 { 596 /* register with no authorization; let AVDTP use authorization instead */ 597 #if( defined BTA_AR_INCLUDED ) && (BTA_AR_INCLUDED == TRUE) 598 #if (BTA_AV_WITH_AVCTP_AUTHORIZATION == TRUE) 599 bta_ar_reg_avct(p_bta_av_cfg->avrc_mtu, p_bta_av_cfg->avrc_br_mtu, 600 bta_av_cb.sec_mask, BTA_ID_AV); 601 #else 602 bta_ar_reg_avct(p_bta_av_cfg->avrc_mtu, p_bta_av_cfg->avrc_br_mtu, 603 (UINT8)(bta_av_cb.sec_mask & (~BTA_SEC_AUTHORIZE)), BTA_ID_AV); 604 #endif 605 606 bta_ar_reg_avrc(UUID_SERVCLASS_AV_REM_CTRL_TARGET, "AV Remote Control Target", NULL, 607 p_bta_av_cfg->avrc_tg_cat, BTA_ID_AV); 608 #endif 609 } 610 611 /* Set the Capturing service class bit */ 612 #if (BTA_AV_SINK_INCLUDED == TRUE) 613 cod.service = BTM_COD_SERVICE_CAPTURING | BTM_COD_SERVICE_RENDERING; 614 #else 615 cod.service = BTM_COD_SERVICE_CAPTURING; 616 #endif 617 utl_set_device_class(&cod, BTA_UTL_SET_COD_SERVICE_CLASS); 618 } /* if 1st channel */ 619 620 /* get stream configuration and create stream */ 621 /* memset(&cs.cfg,0,sizeof(tAVDT_CFG)); */ 622 cs.cfg.num_codec = 1; 623 cs.tsep = AVDT_TSEP_SRC; 624 625 /* 626 * memset of cs takes care setting call back pointers to null. 627 cs.p_data_cback = NULL; 628 cs.p_report_cback = NULL; 629 */ 630 cs.nsc_mask = AVDT_NSC_RECONFIG | 631 ((bta_av_cb.features & BTA_AV_FEAT_PROTECT) ? 0 : AVDT_NSC_SECURITY); 632 APPL_TRACE_DEBUG("nsc_mask: 0x%x", cs.nsc_mask); 633 634 if (p_data->api_reg.p_service_name[0] == 0) 635 { 636 p_service_name = NULL; 637 } 638 else 639 { 640 p_service_name = p_data->api_reg.p_service_name; 641 } 642 643 p_scb->suspend_sup = TRUE; 644 p_scb->recfg_sup = TRUE; 645 646 cs.p_ctrl_cback = bta_av_dt_cback[p_scb->hdi]; 647 if(registr.chnl == BTA_AV_CHNL_AUDIO) 648 { 649 /* set up the audio stream control block */ 650 p_scb->p_act_tbl = (const tBTA_AV_ACT *)bta_av_a2d_action; 651 p_scb->p_cos = &bta_av_a2d_cos; 652 p_scb->media_type= AVDT_MEDIA_AUDIO; 653 cs.cfg.psc_mask = AVDT_PSC_TRANS; 654 cs.media_type = AVDT_MEDIA_AUDIO; 655 cs.mtu = p_bta_av_cfg->audio_mtu; 656 cs.flush_to = L2CAP_DEFAULT_FLUSH_TO; 657 #if AVDT_REPORTING == TRUE 658 if(bta_av_cb.features & BTA_AV_FEAT_REPORT) 659 { 660 cs.cfg.psc_mask |= AVDT_PSC_REPORT; 661 cs.p_report_cback = bta_av_a2dp_report_cback; 662 #if AVDT_MULTIPLEXING == TRUE 663 cs.cfg.mux_tsid_report = 2; 664 #endif 665 } 666 #endif 667 if(bta_av_cb.features & BTA_AV_FEAT_DELAY_RPT) 668 cs.cfg.psc_mask |= AVDT_PSC_DELAY_RPT; 669 670 /* keep the configuration in the stream control block */ 671 memcpy(&p_scb->cfg, &cs.cfg, sizeof(tAVDT_CFG)); 672 while(index < BTA_AV_MAX_SEPS && 673 (*bta_av_a2d_cos.init)(&codec_type, cs.cfg.codec_info, 674 &cs.cfg.num_protect, cs.cfg.protect_info, index) == TRUE) 675 { 676 677 #if (BTA_AV_SINK_INCLUDED == TRUE) 678 if(index == 1) 679 { 680 cs.tsep = AVDT_TSEP_SNK; 681 cs.p_data_cback = bta_av_stream_data_cback; 682 } 683 APPL_TRACE_DEBUG(" SEP Type = %d",cs.tsep); 684 #endif 685 if(AVDT_CreateStream(&p_scb->seps[index].av_handle, &cs) == AVDT_SUCCESS) 686 { 687 p_scb->seps[index].codec_type = codec_type; 688 689 #if (BTA_AV_SINK_INCLUDED == TRUE) 690 p_scb->seps[index].tsep = cs.tsep; 691 if(cs.tsep == AVDT_TSEP_SNK) 692 p_scb->seps[index].p_app_data_cback = p_data->api_reg.p_app_data_cback; 693 else 694 p_scb->seps[index].p_app_data_cback = NULL; /* In case of A2DP SOURCE we don't need a callback to handle media packets */ 695 #endif 696 697 APPL_TRACE_DEBUG("audio[%d] av_handle: %d codec_type: %d", 698 index, p_scb->seps[index].av_handle, p_scb->seps[index].codec_type); 699 index++; 700 } 701 else 702 break; 703 } 704 705 if(!bta_av_cb.reg_audio) 706 { 707 /* create the SDP records on the 1st audio channel */ 708 bta_av_cb.sdp_a2d_handle = SDP_CreateRecord(); 709 A2D_AddRecord(UUID_SERVCLASS_AUDIO_SOURCE, p_service_name, NULL, 710 A2D_SUPF_PLAYER, bta_av_cb.sdp_a2d_handle); 711 bta_sys_add_uuid(UUID_SERVCLASS_AUDIO_SOURCE); 712 713 #if (BTA_AV_SINK_INCLUDED == TRUE) 714 bta_av_cb.sdp_a2d_snk_handle = SDP_CreateRecord(); 715 A2D_AddRecord(UUID_SERVCLASS_AUDIO_SINK, p_avk_service_name, NULL, 716 A2D_SUPF_PLAYER, bta_av_cb.sdp_a2d_snk_handle); 717 bta_sys_add_uuid(UUID_SERVCLASS_AUDIO_SINK); 718 #endif 719 /* start listening when A2DP is registered */ 720 if (bta_av_cb.features & BTA_AV_FEAT_RCTG) 721 bta_av_rc_create(&bta_av_cb, AVCT_ACP, 0, BTA_AV_NUM_LINKS + 1); 722 723 /* if the AV and AVK are both supported, it cannot support the CT role */ 724 if (bta_av_cb.features & (BTA_AV_FEAT_RCCT)) 725 { 726 /* if TG is not supported, we need to register to AVCT now */ 727 if ((bta_av_cb.features & (BTA_AV_FEAT_RCTG)) == 0) 728 { 729 #if( defined BTA_AR_INCLUDED ) && (BTA_AR_INCLUDED == TRUE) 730 #if (BTA_AV_WITH_AVCTP_AUTHORIZATION == TRUE) 731 bta_ar_reg_avct(p_bta_av_cfg->avrc_mtu, p_bta_av_cfg->avrc_br_mtu, 732 bta_av_cb.sec_mask, BTA_ID_AV); 733 #else 734 bta_ar_reg_avct(p_bta_av_cfg->avrc_mtu, p_bta_av_cfg->avrc_br_mtu, 735 (UINT8)(bta_av_cb.sec_mask & (~BTA_SEC_AUTHORIZE)), BTA_ID_AV); 736 #endif 737 #endif 738 } 739 #if( defined BTA_AR_INCLUDED ) && (BTA_AR_INCLUDED == TRUE) 740 /* create an SDP record as AVRC CT. */ 741 bta_ar_reg_avrc(UUID_SERVCLASS_AV_REMOTE_CONTROL, NULL, NULL, 742 p_bta_av_cfg->avrc_ct_cat, BTA_ID_AV); 743 #endif 744 } 745 } 746 bta_av_cb.reg_audio |= BTA_AV_HNDL_TO_MSK(p_scb->hdi); 747 APPL_TRACE_DEBUG("reg_audio: 0x%x",bta_av_cb.reg_audio); 748 } 749 else 750 { 751 bta_av_cb.reg_video = BTA_AV_HNDL_TO_MSK(p_scb->hdi); 752 bta_av_cb.sdp_vdp_handle = SDP_CreateRecord(); 753 /* register the video channel */ 754 /* no need to verify the function pointer here. it's verified prior */ 755 (*p_bta_av_cfg->p_reg)(&cs, p_service_name, p_scb); 756 } 757 } while (0); 758 759 /* call callback with register event */ 760 (*bta_av_cb.p_cback)(BTA_AV_REGISTER_EVT, (tBTA_AV *)®istr); 761 } 762 763 /******************************************************************************* 764 ** 765 ** Function bta_av_api_deregister 766 ** 767 ** Description de-register a channel 768 ** 769 ** 770 ** Returns void 771 ** 772 *******************************************************************************/ 773 void bta_av_api_deregister(tBTA_AV_DATA *p_data) 774 { 775 tBTA_AV_SCB *p_scb = bta_av_hndl_to_scb(p_data->hdr.layer_specific); 776 777 if(p_scb) 778 { 779 p_scb->deregistring = TRUE; 780 bta_av_ssm_execute(p_scb, BTA_AV_API_CLOSE_EVT, p_data); 781 } 782 else 783 { 784 bta_av_dereg_comp(p_data); 785 } 786 } 787 788 /******************************************************************************* 789 ** 790 ** Function bta_av_ci_data 791 ** 792 ** Description forward the BTA_AV_CI_SRC_DATA_READY_EVT to stream state machine 793 ** 794 ** 795 ** Returns void 796 ** 797 *******************************************************************************/ 798 static void bta_av_ci_data(tBTA_AV_DATA *p_data) 799 { 800 tBTA_AV_SCB *p_scb; 801 int i; 802 UINT8 chnl = (UINT8)p_data->hdr.layer_specific; 803 804 for( i=0; i < BTA_AV_NUM_STRS; i++ ) 805 { 806 p_scb = bta_av_cb.p_scb[i]; 807 808 if(p_scb && p_scb->chnl == chnl) 809 { 810 bta_av_ssm_execute(p_scb, BTA_AV_SRC_DATA_READY_EVT, p_data); 811 } 812 } 813 } 814 815 /******************************************************************************* 816 ** 817 ** Function bta_av_rpc_conn 818 ** 819 ** Description report report channel open 820 ** 821 ** Returns void 822 ** 823 *******************************************************************************/ 824 #if (AVDT_REPORTING == TRUE) 825 static void bta_av_rpc_conn(tBTA_AV_DATA *p_data) 826 { 827 UNUSED(p_data); 828 } 829 #endif 830 831 /******************************************************************************* 832 ** 833 ** Function bta_av_api_to_ssm 834 ** 835 ** Description forward the API request to stream state machine 836 ** 837 ** 838 ** Returns void 839 ** 840 *******************************************************************************/ 841 static void bta_av_api_to_ssm(tBTA_AV_DATA *p_data) 842 { 843 int xx; 844 UINT16 event = p_data->hdr.event - BTA_AV_FIRST_A2S_API_EVT + BTA_AV_FIRST_A2S_SSM_EVT; 845 846 for(xx=0; xx<BTA_AV_NUM_STRS; xx++) 847 { 848 bta_av_ssm_execute(bta_av_cb.p_scb[xx], event, p_data); 849 } 850 } 851 852 /******************************************************************************* 853 ** 854 ** Function bta_av_chk_start 855 ** 856 ** Description if this is audio channel, check if more than one audio 857 ** channel is connected & already started. 858 ** 859 ** Returns TRUE, if need api_start 860 ** 861 *******************************************************************************/ 862 BOOLEAN bta_av_chk_start(tBTA_AV_SCB *p_scb) 863 { 864 BOOLEAN start = FALSE; 865 tBTA_AV_SCB *p_scbi; 866 int i; 867 868 if(p_scb->chnl == BTA_AV_CHNL_AUDIO) 869 { 870 if ((bta_av_cb.audio_open_cnt >= 2) && 871 ((0 == (p_scb->role & BTA_AV_ROLE_AD_ACP)) || /* Outgoing connection or */ 872 (bta_av_cb.features & BTA_AV_FEAT_ACP_START))) /* auto-starting option */ 873 { 874 /* more than one audio channel is connected */ 875 /* if this is the 2nd stream as ACP, give INT a chance to issue the START command */ 876 for(i=0; i<BTA_AV_NUM_STRS; i++) 877 { 878 p_scbi = bta_av_cb.p_scb[i]; 879 if(p_scbi && p_scbi->chnl == BTA_AV_CHNL_AUDIO && p_scbi->co_started) 880 { 881 start = TRUE; 882 /* may need to update the flush timeout of this already started stream */ 883 if(p_scbi->co_started != bta_av_cb.audio_open_cnt) 884 { 885 p_scbi->co_started = bta_av_cb.audio_open_cnt; 886 L2CA_SetFlushTimeout(p_scbi->peer_addr, p_bta_av_cfg->p_audio_flush_to[p_scbi->co_started - 1] ); 887 } 888 } 889 } 890 } 891 } 892 return start; 893 } 894 895 /******************************************************************************* 896 ** 897 ** Function bta_av_restore_switch 898 ** 899 ** Description assume that the caller of this function already makes 900 ** sure that there's only one ACL connection left 901 ** 902 ** Returns void 903 ** 904 *******************************************************************************/ 905 void bta_av_restore_switch (void) 906 { 907 tBTA_AV_CB *p_cb = &bta_av_cb; 908 int i; 909 UINT8 mask; 910 911 APPL_TRACE_DEBUG("reg_audio: 0x%x",bta_av_cb.reg_audio); 912 for(i=0; i<BTA_AV_NUM_STRS; i++) 913 { 914 mask = BTA_AV_HNDL_TO_MSK(i); 915 if (p_cb->conn_audio == mask) 916 { 917 if (p_cb->p_scb[i]) 918 { 919 bta_sys_set_policy(BTA_ID_AV, HCI_ENABLE_MASTER_SLAVE_SWITCH, p_cb->p_scb[i]->peer_addr); 920 } 921 break; 922 } 923 } 924 } 925 926 /******************************************************************************* 927 ** 928 ** Function bta_av_sys_rs_cback 929 ** 930 ** Description Receives the role change event from dm 931 ** 932 ** Returns (BTA_SYS_ROLE_CHANGE, new_role, hci_status, p_bda) 933 ** 934 *******************************************************************************/ 935 static void bta_av_sys_rs_cback (tBTA_SYS_CONN_STATUS status,UINT8 id, UINT8 app_id, BD_ADDR peer_addr) 936 { 937 int i; 938 tBTA_AV_SCB *p_scb = NULL; 939 tBTA_AV_ROLE_RES *p_buf; 940 UINT8 cur_role; 941 UINT8 peer_idx = 0; 942 UNUSED(status); 943 944 APPL_TRACE_DEBUG("bta_av_sys_rs_cback: %d", bta_av_cb.rs_idx); 945 for(i=0; i<BTA_AV_NUM_STRS; i++) 946 { 947 /* loop through all the SCBs to find matching peer addresses and report the role change event */ 948 /* note that more than one SCB (a2dp & vdp) maybe waiting for this event */ 949 p_scb = bta_av_cb.p_scb[i]; 950 if (p_scb && (bdcmp (peer_addr, p_scb->peer_addr) == 0) && 951 (p_buf = (tBTA_AV_ROLE_RES *) GKI_getbuf(sizeof(tBTA_AV_ROLE_RES))) != NULL) 952 { 953 APPL_TRACE_DEBUG("new_role:%d, hci_status:x%x hndl: x%x", id, app_id, p_scb->hndl); 954 /* 955 if ((id != BTM_ROLE_MASTER) && (app_id != HCI_SUCCESS)) 956 { 957 bta_sys_set_policy(BTA_ID_AV, (HCI_ENABLE_MASTER_SLAVE_SWITCH|HCI_ENABLE_SNIFF_MODE), p_scb->peer_addr); 958 } 959 */ 960 p_buf->hdr.event = BTA_AV_ROLE_CHANGE_EVT; 961 p_buf->hdr.layer_specific = p_scb->hndl; 962 p_buf->new_role = id; 963 p_buf->hci_status = app_id; 964 bta_sys_sendmsg(p_buf); 965 966 peer_idx = p_scb->hdi + 1; /* Handle index for the peer_addr */ 967 } 968 } 969 970 /* restore role switch policy, if role switch failed */ 971 if ((HCI_SUCCESS != app_id) && 972 (BTM_GetRole (peer_addr, &cur_role) == BTM_SUCCESS) && 973 (cur_role == BTM_ROLE_SLAVE) ) 974 { 975 bta_sys_set_policy(BTA_ID_AV, HCI_ENABLE_MASTER_SLAVE_SWITCH, peer_addr); 976 } 977 978 /* if BTA_AvOpen() was called for other device, which caused the role switch of the peer_addr, */ 979 /* we need to continue opening process for the BTA_AvOpen(). */ 980 if ((bta_av_cb.rs_idx != 0) && (bta_av_cb.rs_idx != peer_idx)) 981 { 982 if ((bta_av_cb.rs_idx -1) < BTA_AV_NUM_STRS) 983 { 984 p_scb = bta_av_cb.p_scb[bta_av_cb.rs_idx - 1]; 985 } 986 if (p_scb && p_scb->q_tag == BTA_AV_Q_TAG_OPEN) 987 { 988 APPL_TRACE_DEBUG ("bta_av_sys_rs_cback: rs_idx(%d), hndl:x%x q_tag: %d", 989 bta_av_cb.rs_idx, p_scb->hndl, p_scb->q_tag); 990 991 if(HCI_SUCCESS == app_id || HCI_ERR_NO_CONNECTION == app_id) 992 p_scb->q_info.open.switch_res = BTA_AV_RS_OK; 993 else 994 p_scb->q_info.open.switch_res = BTA_AV_RS_FAIL; 995 996 /* Continue av open process */ 997 bta_av_do_disc_a2d (p_scb, (tBTA_AV_DATA *)&(p_scb->q_info.open)); 998 } 999 1000 bta_av_cb.rs_idx = 0; 1001 } 1002 } 1003 1004 /******************************************************************************* 1005 ** 1006 ** Function bta_av_sco_chg_cback 1007 ** 1008 ** Description receive & process the SCO connection up/down event from sys. 1009 ** call setup also triggers this callback, to suspend av before sco 1010 ** activity happens, or to resume av once call ends. 1011 ** 1012 ** Returns void 1013 ** 1014 *******************************************************************************/ 1015 static void bta_av_sco_chg_cback(tBTA_SYS_CONN_STATUS status, UINT8 id, UINT8 1016 app_id, BD_ADDR peer_addr) 1017 { 1018 tBTA_AV_SCB *p_scb; 1019 int i; 1020 tBTA_AV_API_STOP stop; 1021 UNUSED(app_id); 1022 UNUSED(peer_addr); 1023 1024 APPL_TRACE_DEBUG("bta_av_sco_chg_cback:%d status:%d", id, status); 1025 if(id) 1026 { 1027 bta_av_cb.sco_occupied = TRUE; 1028 1029 /* either BTA_SYS_SCO_OPEN or BTA_SYS_SCO_CLOSE with remaining active SCO */ 1030 for(i=0; i<BTA_AV_NUM_STRS; i++) 1031 { 1032 p_scb = bta_av_cb.p_scb[i]; 1033 1034 if( p_scb && p_scb->co_started && (p_scb->sco_suspend == FALSE)) 1035 { 1036 APPL_TRACE_DEBUG("suspending scb:%d", i); 1037 /* scb is used and started, not suspended automatically */ 1038 p_scb->sco_suspend = TRUE; 1039 stop.flush = FALSE; 1040 stop.suspend = TRUE; 1041 bta_av_ssm_execute(p_scb, BTA_AV_AP_STOP_EVT, (tBTA_AV_DATA *)&stop); 1042 } 1043 } 1044 } 1045 else 1046 { 1047 bta_av_cb.sco_occupied = FALSE; 1048 1049 for(i=0; i<BTA_AV_NUM_STRS; i++) 1050 { 1051 p_scb = bta_av_cb.p_scb[i]; 1052 1053 if( p_scb && p_scb->sco_suspend ) /* scb is used and suspended for SCO */ 1054 { 1055 APPL_TRACE_DEBUG("starting scb:%d", i); 1056 bta_av_ssm_execute(p_scb, BTA_AV_AP_START_EVT, NULL); 1057 } 1058 } 1059 } 1060 } 1061 1062 /******************************************************************************* 1063 ** 1064 ** Function bta_av_switch_if_needed 1065 ** 1066 ** Description This function checks if there is another existing AV 1067 ** channel that is local as slave role. 1068 ** If so, role switch and remove it from link policy. 1069 ** 1070 ** Returns TRUE, if role switch is done 1071 ** 1072 *******************************************************************************/ 1073 BOOLEAN bta_av_switch_if_needed(tBTA_AV_SCB *p_scb) 1074 { 1075 UINT8 role; 1076 BOOLEAN needed = FALSE; 1077 tBTA_AV_SCB *p_scbi; 1078 int i; 1079 UINT8 mask; 1080 1081 for(i=0; i<BTA_AV_NUM_STRS; i++) 1082 { 1083 mask = BTA_AV_HNDL_TO_MSK(i); 1084 p_scbi = bta_av_cb.p_scb[i]; 1085 if( p_scbi && (p_scb->hdi != i) && /* not the original channel */ 1086 ((bta_av_cb.conn_audio & mask) ||/* connected audio */ 1087 (bta_av_cb.conn_video & mask)) ) /* connected video */ 1088 { 1089 BTM_GetRole(p_scbi->peer_addr, &role); 1090 /* this channel is open - clear the role switch link policy for this link */ 1091 if(BTM_ROLE_MASTER != role) 1092 { 1093 if (bta_av_cb.features & BTA_AV_FEAT_MASTER) 1094 bta_sys_clear_policy(BTA_ID_AV, HCI_ENABLE_MASTER_SLAVE_SWITCH, p_scbi->peer_addr); 1095 if (BTM_CMD_STARTED != BTM_SwitchRole(p_scbi->peer_addr, BTM_ROLE_MASTER, NULL)) 1096 { 1097 /* can not switch role on SCBI 1098 * start the timer on SCB - because this function is ONLY called when SCB gets API_OPEN */ 1099 bta_sys_start_timer(&p_scb->timer, BTA_AV_AVRC_TIMER_EVT, BTA_AV_RS_TIME_VAL); 1100 } 1101 needed = TRUE; 1102 /* mark the original channel as waiting for RS result */ 1103 bta_av_cb.rs_idx = p_scb->hdi + 1; 1104 break; 1105 } 1106 } 1107 } 1108 return needed; 1109 } 1110 1111 /******************************************************************************* 1112 ** 1113 ** Function bta_av_link_role_ok 1114 ** 1115 ** Description This function checks if the SCB has existing ACL connection 1116 ** If so, check if the link role fits the requirements. 1117 ** 1118 ** Returns TRUE, if role is ok 1119 ** 1120 *******************************************************************************/ 1121 BOOLEAN bta_av_link_role_ok(tBTA_AV_SCB *p_scb, UINT8 bits) 1122 { 1123 UINT8 role; 1124 BOOLEAN is_ok = TRUE; 1125 1126 if (BTM_GetRole(p_scb->peer_addr, &role) == BTM_SUCCESS) 1127 { 1128 LOG_INFO("%s hndl:x%x role:%d conn_audio:x%x bits:%d features:x%x", 1129 __func__, p_scb->hndl, role, bta_av_cb.conn_audio, bits, 1130 bta_av_cb.features); 1131 if (BTM_ROLE_MASTER != role && (A2D_BitsSet(bta_av_cb.conn_audio) > bits || (bta_av_cb.features & BTA_AV_FEAT_MASTER))) 1132 { 1133 if (bta_av_cb.features & BTA_AV_FEAT_MASTER) 1134 bta_sys_clear_policy(BTA_ID_AV, HCI_ENABLE_MASTER_SLAVE_SWITCH, p_scb->peer_addr); 1135 1136 if (BTM_CMD_STARTED != BTM_SwitchRole(p_scb->peer_addr, BTM_ROLE_MASTER, NULL)) 1137 { 1138 /* can not switch role on SCB - start the timer on SCB */ 1139 } 1140 is_ok = FALSE; 1141 p_scb->wait |= BTA_AV_WAIT_ROLE_SW_RES_START; 1142 1143 } 1144 } 1145 1146 return is_ok; 1147 } 1148 1149 /******************************************************************************* 1150 ** 1151 ** Function bta_av_chk_mtu 1152 ** 1153 ** Description if this is audio channel, check if more than one audio 1154 ** channel is connected. 1155 ** 1156 ** Returns The smallest mtu of the connected audio channels 1157 ** 1158 *******************************************************************************/ 1159 UINT16 bta_av_chk_mtu(tBTA_AV_SCB *p_scb, UINT16 mtu) 1160 { 1161 UINT16 ret_mtu = BTA_AV_MAX_A2DP_MTU; 1162 tBTA_AV_SCB *p_scbi; 1163 int i; 1164 UINT8 mask; 1165 UNUSED(mtu); 1166 1167 /* TODO_MV mess with the mtu according to the number of EDR/non-EDR headsets */ 1168 if(p_scb->chnl == BTA_AV_CHNL_AUDIO) 1169 { 1170 if(bta_av_cb.audio_open_cnt >= 2) 1171 { 1172 /* more than one audio channel is connected */ 1173 for(i=0; i<BTA_AV_NUM_STRS; i++) 1174 { 1175 p_scbi = bta_av_cb.p_scb[i]; 1176 if((p_scb != p_scbi) && p_scbi && (p_scbi->chnl == BTA_AV_CHNL_AUDIO) ) 1177 { 1178 mask = BTA_AV_HNDL_TO_MSK(i); 1179 APPL_TRACE_DEBUG("[%d] mtu: %d, mask:0x%x", 1180 i, p_scbi->stream_mtu, mask); 1181 if(bta_av_cb.conn_audio & mask) 1182 { 1183 if(ret_mtu > p_scbi->stream_mtu) 1184 ret_mtu = p_scbi->stream_mtu; 1185 } 1186 } 1187 } 1188 } 1189 APPL_TRACE_DEBUG("bta_av_chk_mtu audio count:%d, conn_audio:0x%x, ret:%d", 1190 bta_av_cb.audio_open_cnt, bta_av_cb.conn_audio, ret_mtu); 1191 } 1192 return ret_mtu; 1193 } 1194 1195 /******************************************************************************* 1196 ** 1197 ** Function bta_av_dup_audio_buf 1198 ** 1199 ** Description dup the audio data to the q_info.a2d of other audio channels 1200 ** 1201 ** Returns void 1202 ** 1203 *******************************************************************************/ 1204 void bta_av_dup_audio_buf(tBTA_AV_SCB *p_scb, BT_HDR *p_buf) 1205 { 1206 tBTA_AV_SCB *p_scbi; 1207 int i; 1208 UINT16 size, copy_size; 1209 BT_HDR *p_new; 1210 1211 if(!p_buf) 1212 return; 1213 1214 if(bta_av_cb.audio_open_cnt >= 2) 1215 { 1216 size = GKI_get_buf_size(p_buf); 1217 copy_size = BT_HDR_SIZE + p_buf->len + p_buf->offset; 1218 /* more than one audio channel is connected */ 1219 for(i=0; i<BTA_AV_NUM_STRS; i++) 1220 { 1221 p_scbi = bta_av_cb.p_scb[i]; 1222 if( (p_scb->hdi != i) && /* not the original channel */ 1223 (bta_av_cb.conn_audio & BTA_AV_HNDL_TO_MSK(i)) && /* connected audio */ 1224 p_scbi && p_scbi->co_started ) /* scb is used and started */ 1225 { 1226 /* enqueue the data only when the stream is started */ 1227 p_new = (BT_HDR *)GKI_getbuf(size); 1228 if(p_new) 1229 { 1230 memcpy(p_new, p_buf, copy_size); 1231 list_append(p_scbi->a2d_list, p_new); 1232 if (list_length(p_scbi->a2d_list) > p_bta_av_cfg->audio_mqs) { 1233 // Drop the oldest packet 1234 bta_av_co_audio_drop(p_scbi->hndl); 1235 BT_HDR *p_buf = list_front(p_scbi->a2d_list); 1236 list_remove(p_scbi->a2d_list, p_buf); 1237 GKI_freebuf(p_buf); 1238 } 1239 } 1240 } 1241 } 1242 } 1243 1244 } 1245 1246 /******************************************************************************* 1247 ** 1248 ** Function bta_av_sm_execute 1249 ** 1250 ** Description State machine event handling function for AV 1251 ** 1252 ** 1253 ** Returns void 1254 ** 1255 *******************************************************************************/ 1256 void bta_av_sm_execute(tBTA_AV_CB *p_cb, UINT16 event, tBTA_AV_DATA *p_data) 1257 { 1258 tBTA_AV_ST_TBL state_table; 1259 UINT8 action; 1260 1261 #if (defined(BTA_AV_DEBUG) && BTA_AV_DEBUG == TRUE) 1262 APPL_TRACE_EVENT("AV event=0x%x(%s) state=%d(%s)", 1263 event, bta_av_evt_code(event), p_cb->state, bta_av_st_code(p_cb->state)); 1264 #else 1265 APPL_TRACE_EVENT("AV event=0x%x state=%d", event, p_cb->state); 1266 #endif 1267 1268 /* look up the state table for the current state */ 1269 state_table = bta_av_st_tbl[p_cb->state]; 1270 1271 event &= 0x00FF; 1272 1273 /* set next state */ 1274 p_cb->state = state_table[event][BTA_AV_NEXT_STATE]; 1275 APPL_TRACE_EVENT("next state=%d", p_cb->state); 1276 1277 /* execute action functions */ 1278 if ((action = state_table[event][BTA_AV_ACTION_COL]) != BTA_AV_IGNORE) 1279 { 1280 (*bta_av_action[action])(p_cb, p_data); 1281 } 1282 } 1283 1284 1285 /******************************************************************************* 1286 ** 1287 ** Function bta_av_hdl_event 1288 ** 1289 ** Description Advanced audio/video main event handling function. 1290 ** 1291 ** 1292 ** Returns BOOLEAN 1293 ** 1294 *******************************************************************************/ 1295 BOOLEAN bta_av_hdl_event(BT_HDR *p_msg) 1296 { 1297 UINT16 event = p_msg->event; 1298 UINT16 first_event = BTA_AV_FIRST_NSM_EVT; 1299 1300 if (event > BTA_AV_LAST_EVT) 1301 { 1302 return TRUE; /* to free p_msg */ 1303 } 1304 1305 if(event >= first_event) 1306 { 1307 #if (defined(BTA_AV_DEBUG) && BTA_AV_DEBUG == TRUE) 1308 APPL_TRACE_VERBOSE("AV nsm event=0x%x(%s)", event, bta_av_evt_code(event)); 1309 #else 1310 APPL_TRACE_VERBOSE("AV nsm event=0x%x", event); 1311 #endif 1312 /* non state machine events */ 1313 (*bta_av_nsm_act[event - BTA_AV_FIRST_NSM_EVT]) ((tBTA_AV_DATA *) p_msg); 1314 } 1315 else if (event >= BTA_AV_FIRST_SM_EVT && event <= BTA_AV_LAST_SM_EVT) 1316 { 1317 #if (defined(BTA_AV_DEBUG) && BTA_AV_DEBUG == TRUE) 1318 APPL_TRACE_VERBOSE("AV sm event=0x%x(%s)", event, bta_av_evt_code(event)); 1319 #else 1320 APPL_TRACE_VERBOSE("AV sm event=0x%x", event); 1321 #endif 1322 /* state machine events */ 1323 bta_av_sm_execute(&bta_av_cb, p_msg->event, (tBTA_AV_DATA *) p_msg); 1324 } 1325 else 1326 { 1327 APPL_TRACE_VERBOSE("handle=0x%x", p_msg->layer_specific); 1328 /* stream state machine events */ 1329 bta_av_ssm_execute( bta_av_hndl_to_scb(p_msg->layer_specific), 1330 p_msg->event, (tBTA_AV_DATA *) p_msg); 1331 } 1332 return TRUE; 1333 } 1334 1335 1336 /***************************************************************************** 1337 ** Debug Functions 1338 *****************************************************************************/ 1339 #if (defined(BTA_AV_DEBUG) && BTA_AV_DEBUG == TRUE) 1340 /******************************************************************************* 1341 ** 1342 ** Function bta_av_st_code 1343 ** 1344 ** Description 1345 ** 1346 ** Returns char * 1347 ** 1348 *******************************************************************************/ 1349 static char *bta_av_st_code(UINT8 state) 1350 { 1351 switch(state) 1352 { 1353 case BTA_AV_INIT_ST: return "INIT"; 1354 case BTA_AV_OPEN_ST: return "OPEN"; 1355 default: return "unknown"; 1356 } 1357 } 1358 /******************************************************************************* 1359 ** 1360 ** Function bta_av_evt_code 1361 ** 1362 ** Description 1363 ** 1364 ** Returns char * 1365 ** 1366 *******************************************************************************/ 1367 char *bta_av_evt_code(UINT16 evt_code) 1368 { 1369 switch(evt_code) 1370 { 1371 case BTA_AV_API_DISABLE_EVT: return "API_DISABLE"; 1372 case BTA_AV_API_REMOTE_CMD_EVT: return "API_REMOTE_CMD"; 1373 case BTA_AV_API_VENDOR_CMD_EVT: return "API_VENDOR_CMD"; 1374 case BTA_AV_API_VENDOR_RSP_EVT: return "API_VENDOR_RSP"; 1375 case BTA_AV_API_META_RSP_EVT: return "API_META_RSP_EVT"; 1376 case BTA_AV_API_RC_CLOSE_EVT: return "API_RC_CLOSE"; 1377 case BTA_AV_AVRC_OPEN_EVT: return "AVRC_OPEN"; 1378 case BTA_AV_AVRC_MSG_EVT: return "AVRC_MSG"; 1379 case BTA_AV_AVRC_NONE_EVT: return "AVRC_NONE"; 1380 1381 case BTA_AV_API_OPEN_EVT: return "API_OPEN"; 1382 case BTA_AV_API_CLOSE_EVT: return "API_CLOSE"; 1383 case BTA_AV_AP_START_EVT: return "AP_START"; 1384 case BTA_AV_AP_STOP_EVT: return "AP_STOP"; 1385 case BTA_AV_API_RECONFIG_EVT: return "API_RECONFIG"; 1386 case BTA_AV_API_PROTECT_REQ_EVT: return "API_PROTECT_REQ"; 1387 case BTA_AV_API_PROTECT_RSP_EVT: return "API_PROTECT_RSP"; 1388 case BTA_AV_API_RC_OPEN_EVT: return "API_RC_OPEN"; 1389 case BTA_AV_SRC_DATA_READY_EVT: return "SRC_DATA_READY"; 1390 case BTA_AV_CI_SETCONFIG_OK_EVT: return "CI_SETCONFIG_OK"; 1391 case BTA_AV_CI_SETCONFIG_FAIL_EVT: return "CI_SETCONFIG_FAIL"; 1392 case BTA_AV_SDP_DISC_OK_EVT: return "SDP_DISC_OK"; 1393 case BTA_AV_SDP_DISC_FAIL_EVT: return "SDP_DISC_FAIL"; 1394 case BTA_AV_STR_DISC_OK_EVT: return "STR_DISC_OK"; 1395 case BTA_AV_STR_DISC_FAIL_EVT: return "STR_DISC_FAIL"; 1396 case BTA_AV_STR_GETCAP_OK_EVT: return "STR_GETCAP_OK"; 1397 case BTA_AV_STR_GETCAP_FAIL_EVT: return "STR_GETCAP_FAIL"; 1398 case BTA_AV_STR_OPEN_OK_EVT: return "STR_OPEN_OK"; 1399 case BTA_AV_STR_OPEN_FAIL_EVT: return "STR_OPEN_FAIL"; 1400 case BTA_AV_STR_START_OK_EVT: return "STR_START_OK"; 1401 case BTA_AV_STR_START_FAIL_EVT: return "STR_START_FAIL"; 1402 case BTA_AV_STR_CLOSE_EVT: return "STR_CLOSE"; 1403 case BTA_AV_STR_CONFIG_IND_EVT: return "STR_CONFIG_IND"; 1404 case BTA_AV_STR_SECURITY_IND_EVT: return "STR_SECURITY_IND"; 1405 case BTA_AV_STR_SECURITY_CFM_EVT: return "STR_SECURITY_CFM"; 1406 case BTA_AV_STR_WRITE_CFM_EVT: return "STR_WRITE_CFM"; 1407 case BTA_AV_STR_SUSPEND_CFM_EVT: return "STR_SUSPEND_CFM"; 1408 case BTA_AV_STR_RECONFIG_CFM_EVT: return "STR_RECONFIG_CFM"; 1409 case BTA_AV_AVRC_TIMER_EVT: return "AVRC_TIMER"; 1410 case BTA_AV_AVDT_CONNECT_EVT: return "AVDT_CONNECT"; 1411 case BTA_AV_AVDT_DISCONNECT_EVT: return "AVDT_DISCONNECT"; 1412 case BTA_AV_ROLE_CHANGE_EVT: return "ROLE_CHANGE"; 1413 case BTA_AV_AVDT_DELAY_RPT_EVT: return "AVDT_DELAY_RPT"; 1414 case BTA_AV_ACP_CONNECT_EVT: return "ACP_CONNECT"; 1415 1416 case BTA_AV_API_ENABLE_EVT: return "API_ENABLE"; 1417 case BTA_AV_API_REGISTER_EVT: return "API_REG"; 1418 case BTA_AV_API_DEREGISTER_EVT: return "API_DEREG"; 1419 case BTA_AV_API_DISCONNECT_EVT: return "API_DISCNT"; 1420 case BTA_AV_CI_SRC_DATA_READY_EVT: return "CI_DATA_READY"; 1421 case BTA_AV_SIG_CHG_EVT: return "SIG_CHG"; 1422 case BTA_AV_SIG_TIMER_EVT: return "SIG_TMR"; 1423 case BTA_AV_SDP_AVRC_DISC_EVT: return "SDP_AVRC_DISC"; 1424 case BTA_AV_AVRC_CLOSE_EVT: return "AVRC_CLOSE"; 1425 case BTA_AV_CONN_CHG_EVT: return "CONN_CHG"; 1426 case BTA_AV_DEREG_COMP_EVT: return "DEREG_COMP"; 1427 #if (BTA_AV_SINK_INCLUDED == TRUE) 1428 case BTA_AV_API_SINK_ENABLE_EVT: return "SINK_ENABLE"; 1429 #endif 1430 #if (AVDT_REPORTING == TRUE) 1431 case BTA_AV_AVDT_RPT_CONN_EVT: return "RPT_CONN"; 1432 #endif 1433 case BTA_AV_API_START_EVT: return "API_START"; 1434 case BTA_AV_API_STOP_EVT: return "API_STOP"; 1435 default: return "unknown"; 1436 } 1437 } 1438 #endif 1439 1440 #endif /* BTA_AV_INCLUDED */ 1441
