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 file contains action functions for advanced audio/video stream
22 * state machine. these functions are shared by both audio and video
23 * streams.
24 *
25 ******************************************************************************/
26
27 #include "common/bt_target.h"
28 #if defined(BTA_AV_INCLUDED) && (BTA_AV_INCLUDED == TRUE)
29
30 #include <assert.h>
31 #include "common/bt_trace.h"
32 #include <string.h>
33
34 #include "osi/allocator.h"
35
36 #include "bta_av_int.h"
37 #include "stack/avdt_api.h"
38 #include "bta/utl.h"
39 #include "stack/l2c_api.h"
40 #include "stack/l2cdefs.h"
41 #if( defined BTA_AR_INCLUDED ) && (BTA_AR_INCLUDED == TRUE)
42 #include "bta/bta_ar_api.h"
43 #endif
44 #include "bta/bta_api.h"
45
46 /*****************************************************************************
47 ** Constants
48 *****************************************************************************/
49
50 /* the delay time in milliseconds to start service discovery on AVRCP */
51 #ifndef BTA_AV_RC_DISC_TIME_VAL
52 #define BTA_AV_RC_DISC_TIME_VAL 3500
53 #endif
54
55 /* the timer in milliseconds to guard against link busy and AVDT_CloseReq failed to be sent */
56 #ifndef BTA_AV_CLOSE_REQ_TIME_VAL
57 #define BTA_AV_CLOSE_REQ_TIME_VAL 4000
58 #endif
59
60 /* number to retry on reconfigure failure - some headsets requirs this number to be more than 1 */
61 #ifndef BTA_AV_RECONFIG_RETRY
62 #define BTA_AV_RECONFIG_RETRY 6
63 #endif
64
65 /* avdt_handle to send abort command for AVDTP BQB test */
66 #if A2D_SRC_BQB_INCLUDED
67 static uint8_t s_avdt_bqb_handle;
68 #endif /* CONFIG_BT_BQB_ENABLED */
69
70 static void bta_av_st_rc_timer(tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data);
71
72 /* state machine states */
73 enum {
74 BTA_AV_INIT_SST,
75 BTA_AV_INCOMING_SST,
76 BTA_AV_OPENING_SST,
77 BTA_AV_OPEN_SST,
78 BTA_AV_RCFG_SST,
79 BTA_AV_CLOSING_SST
80 };
81
82 /* ssm action functions for audio stream */
83 const tBTA_AV_SACT bta_av_a2d_action[] = {
84 bta_av_do_disc_a2d, /* BTA_AV_DO_DISC */
85 bta_av_cleanup, /* BTA_AV_CLEANUP */
86 bta_av_free_sdb, /* BTA_AV_FREE_SDB */
87 bta_av_config_ind, /* BTA_AV_CONFIG_IND */
88 bta_av_disconnect_req, /* BTA_AV_DISCONNECT_REQ */
89 bta_av_security_req, /* BTA_AV_SECURITY_REQ */
90 bta_av_security_rsp, /* BTA_AV_SECURITY_RSP */
91 bta_av_setconfig_rsp, /* BTA_AV_SETCONFIG_RSP */
92 bta_av_st_rc_timer, /* BTA_AV_ST_RC_TIMER */
93 bta_av_str_opened, /* BTA_AV_STR_OPENED */
94 bta_av_security_ind, /* BTA_AV_SECURITY_IND */
95 bta_av_security_cfm, /* BTA_AV_SECURITY_CFM */
96 bta_av_do_close, /* BTA_AV_DO_CLOSE */
97 bta_av_connect_req, /* BTA_AV_CONNECT_REQ */
98 bta_av_sdp_failed, /* BTA_AV_SDP_FAILED */
99 bta_av_disc_results, /* BTA_AV_DISC_RESULTS */
100 bta_av_disc_res_as_acp, /* BTA_AV_DISC_RES_AS_ACP */
101 bta_av_open_failed, /* BTA_AV_OPEN_FAILED */
102 bta_av_getcap_results, /* BTA_AV_GETCAP_RESULTS */
103 bta_av_setconfig_rej, /* BTA_AV_SETCONFIG_REJ */
104 bta_av_discover_req, /* BTA_AV_DISCOVER_REQ */
105 bta_av_conn_failed, /* BTA_AV_CONN_FAILED */
106 bta_av_do_start, /* BTA_AV_DO_START */
107 bta_av_str_stopped, /* BTA_AV_STR_STOPPED */
108 bta_av_reconfig, /* BTA_AV_RECONFIG */
109 bta_av_data_path, /* BTA_AV_DATA_PATH */
110 bta_av_start_ok, /* BTA_AV_START_OK */
111 bta_av_start_failed, /* BTA_AV_START_FAILED */
112 bta_av_str_closed, /* BTA_AV_STR_CLOSED */
113 bta_av_clr_cong, /* BTA_AV_CLR_CONG */
114 bta_av_suspend_cfm, /* BTA_AV_SUSPEND_CFM */
115 bta_av_rcfg_str_ok, /* BTA_AV_RCFG_STR_OK */
116 bta_av_rcfg_failed, /* BTA_AV_RCFG_FAILED */
117 bta_av_rcfg_connect, /* BTA_AV_RCFG_CONNECT */
118 bta_av_rcfg_discntd, /* BTA_AV_RCFG_DISCNTD */
119 bta_av_suspend_cont, /* BTA_AV_SUSPEND_CONT */
120 bta_av_rcfg_cfm, /* BTA_AV_RCFG_CFM */
121 bta_av_rcfg_open, /* BTA_AV_RCFG_OPEN */
122 bta_av_security_rej, /* BTA_AV_SECURITY_REJ */
123 bta_av_open_rc, /* BTA_AV_OPEN_RC */
124 bta_av_chk_2nd_start, /* BTA_AV_CHK_2ND_START */
125 bta_av_save_caps, /* BTA_AV_SAVE_CAPS */
126 bta_av_set_use_rc, /* BTA_AV_SET_USE_RC */
127 bta_av_cco_close, /* BTA_AV_CCO_CLOSE */
128 bta_av_switch_role, /* BTA_AV_SWITCH_ROLE */
129 bta_av_role_res, /* BTA_AV_ROLE_RES */
130 bta_av_delay_co, /* BTA_AV_DELAY_CO */
131 bta_av_open_at_inc, /* BTA_AV_OPEN_AT_INC */
132 bta_av_open_fail_sdp, /* BTA_AV_OPEN_FAIL_SDP */
133 bta_av_set_delay_value, /* BTA_AV_SET_DELAY_VALUE */
134 NULL
135 };
136
137 /* these tables translate AVDT events to SSM events */
138 static const UINT16 bta_av_stream_evt_ok[] = {
139 BTA_AV_STR_DISC_OK_EVT, /* AVDT_DISCOVER_CFM_EVT */
140 BTA_AV_STR_GETCAP_OK_EVT, /* AVDT_GETCAP_CFM_EVT */
141 BTA_AV_STR_OPEN_OK_EVT, /* AVDT_OPEN_CFM_EVT */
142 BTA_AV_STR_OPEN_OK_EVT, /* AVDT_OPEN_IND_EVT */
143 BTA_AV_STR_CONFIG_IND_EVT, /* AVDT_CONFIG_IND_EVT */
144 BTA_AV_STR_START_OK_EVT, /* AVDT_START_CFM_EVT */
145 BTA_AV_STR_START_OK_EVT, /* AVDT_START_IND_EVT */
146 BTA_AV_STR_SUSPEND_CFM_EVT, /* AVDT_SUSPEND_CFM_EVT */
147 BTA_AV_STR_SUSPEND_CFM_EVT, /* AVDT_SUSPEND_IND_EVT */
148 BTA_AV_STR_CLOSE_EVT, /* AVDT_CLOSE_CFM_EVT */
149 BTA_AV_STR_CLOSE_EVT, /* AVDT_CLOSE_IND_EVT */
150 BTA_AV_STR_RECONFIG_CFM_EVT, /* AVDT_RECONFIG_CFM_EVT */
151 0, /* AVDT_RECONFIG_IND_EVT */
152 BTA_AV_STR_SECURITY_CFM_EVT, /* AVDT_SECURITY_CFM_EVT */
153 BTA_AV_STR_SECURITY_IND_EVT, /* AVDT_SECURITY_IND_EVT */
154 BTA_AV_STR_WRITE_CFM_EVT, /* AVDT_WRITE_CFM_EVT */
155 BTA_AV_AVDT_CONNECT_EVT, /* AVDT_CONNECT_IND_EVT */
156 BTA_AV_AVDT_DISCONNECT_EVT, /* AVDT_DISCONNECT_IND_EVT */
157 #if (AVDT_REPORTING == TRUE)
158 BTA_AV_AVDT_RPT_CONN_EVT, /* AVDT_REPORT_CONN_EVT */
159 BTA_AV_AVDT_RPT_CONN_EVT, /* AVDT_REPORT_DISCONN_EVT */
160 #endif
161 BTA_AV_AVDT_DELAY_RPT_EVT, /* AVDT_DELAY_REPORT_EVT */
162 0 /* AVDT_DELAY_REPORT_CFM_EVT */
163 };
164
165 static const UINT16 bta_av_stream_evt_fail[] = {
166 BTA_AV_STR_DISC_FAIL_EVT, /* AVDT_DISCOVER_CFM_EVT */
167 BTA_AV_STR_GETCAP_FAIL_EVT, /* AVDT_GETCAP_CFM_EVT */
168 BTA_AV_STR_OPEN_FAIL_EVT, /* AVDT_OPEN_CFM_EVT */
169 BTA_AV_STR_OPEN_OK_EVT, /* AVDT_OPEN_IND_EVT */
170 BTA_AV_STR_CONFIG_IND_EVT, /* AVDT_CONFIG_IND_EVT */
171 BTA_AV_STR_START_FAIL_EVT, /* AVDT_START_CFM_EVT */
172 BTA_AV_STR_START_OK_EVT, /* AVDT_START_IND_EVT */
173 BTA_AV_STR_SUSPEND_CFM_EVT, /* AVDT_SUSPEND_CFM_EVT */
174 BTA_AV_STR_SUSPEND_CFM_EVT, /* AVDT_SUSPEND_IND_EVT */
175 BTA_AV_STR_CLOSE_EVT, /* AVDT_CLOSE_CFM_EVT */
176 BTA_AV_STR_CLOSE_EVT, /* AVDT_CLOSE_IND_EVT */
177 BTA_AV_STR_RECONFIG_CFM_EVT, /* AVDT_RECONFIG_CFM_EVT */
178 0, /* AVDT_RECONFIG_IND_EVT */
179 BTA_AV_STR_SECURITY_CFM_EVT, /* AVDT_SECURITY_CFM_EVT */
180 BTA_AV_STR_SECURITY_IND_EVT, /* AVDT_SECURITY_IND_EVT */
181 BTA_AV_STR_WRITE_CFM_EVT, /* AVDT_WRITE_CFM_EVT */
182 BTA_AV_AVDT_CONNECT_EVT, /* AVDT_CONNECT_IND_EVT */
183 BTA_AV_AVDT_DISCONNECT_EVT, /* AVDT_DISCONNECT_IND_EVT */
184 #if (AVDT_REPORTING == TRUE)
185 BTA_AV_AVDT_RPT_CONN_EVT, /* AVDT_REPORT_CONN_EVT */
186 BTA_AV_AVDT_RPT_CONN_EVT, /* AVDT_REPORT_DISCONN_EVT */
187 #endif
188 BTA_AV_AVDT_DELAY_RPT_EVT, /* AVDT_DELAY_REPORT_EVT */
189 0 /* AVDT_DELAY_REPORT_CFM_EVT */
190 };
191
192 void bta_av_stream_data_cback(UINT8 handle, BT_HDR *p_pkt, UINT32 time_stamp, UINT8 m_pt);
193 static void bta_av_stream0_cback(UINT8 handle, BD_ADDR bd_addr, UINT8 event, tAVDT_CTRL *p_data);
194 static void bta_av_stream1_cback(UINT8 handle, BD_ADDR bd_addr, UINT8 event, tAVDT_CTRL *p_data);
195 #if BTA_AV_NUM_STRS > 2
196 static void bta_av_stream2_cback(UINT8 handle, BD_ADDR bd_addr, UINT8 event, tAVDT_CTRL *p_data);
197 #endif
198 #if BTA_AV_NUM_STRS > 3
199 static void bta_av_stream3_cback(UINT8 handle, BD_ADDR bd_addr, UINT8 event, tAVDT_CTRL *p_data);
200 #endif
201 #if BTA_AV_NUM_STRS > 4
202 static void bta_av_stream4_cback(UINT8 handle, BD_ADDR bd_addr, UINT8 event, tAVDT_CTRL *p_data);
203 #endif
204 #if BTA_AV_NUM_STRS > 5
205 static void bta_av_stream5_cback(UINT8 handle, BD_ADDR bd_addr, UINT8 event, tAVDT_CTRL *p_data);
206 #endif
207 /* the array of callback functions to receive events from AVDT control channel */
208 tAVDT_CTRL_CBACK *const bta_av_dt_cback[] = {
209 bta_av_stream0_cback
210 , bta_av_stream1_cback
211 #if BTA_AV_NUM_STRS > 2
212 , bta_av_stream2_cback
213 #endif
214 #if BTA_AV_NUM_STRS > 3
215 , bta_av_stream3_cback
216 #endif
217 #if BTA_AV_NUM_STRS > 4
218 , bta_av_stream4_cback
219 #endif
220 #if BTA_AV_NUM_STRS > 5
221 , bta_av_stream5_cback
222 #endif
223 };
224 /***********************************************
225 **
226 ** Function bta_get_scb_handle
227 **
228 ** Description gives the registered AVDT handle.by checking with sep_type.
229 **
230 **
231 ** Returns void
232 ***********************************************/
bta_av_get_scb_handle(tBTA_AV_SCB * p_scb,UINT8 local_sep)233 static UINT8 bta_av_get_scb_handle(tBTA_AV_SCB *p_scb, UINT8 local_sep)
234 {
235 UINT8 xx = 0;
236 for (xx = 0; xx < BTA_AV_MAX_SEPS; xx++) {
237 if ((p_scb->seps[xx].tsep == local_sep) &&
238 (p_scb->seps[xx].codec_type == p_scb->codec_type)) {
239 return (p_scb->seps[xx].av_handle);
240 }
241 }
242 APPL_TRACE_DEBUG(" bta_av_get_scb_handle appropiate sep_type not found")
243 return 0; /* return invalid handle */
244 }
245
246 /***********************************************
247 **
248 ** Function bta_av_get_scb_sep_type
249 **
250 ** Description gives the sep type by cross-checking with AVDT handle
251 **
252 **
253 ** Returns void
254 ***********************************************/
bta_av_get_scb_sep_type(tBTA_AV_SCB * p_scb,UINT8 tavdt_handle)255 static UINT8 bta_av_get_scb_sep_type(tBTA_AV_SCB *p_scb, UINT8 tavdt_handle)
256 {
257 UINT8 xx = 0;
258 for (xx = 0; xx < BTA_AV_MAX_SEPS; xx++) {
259 if (p_scb->seps[xx].av_handle == tavdt_handle) {
260 return (p_scb->seps[xx].tsep);
261 }
262 }
263 APPL_TRACE_DEBUG(" bta_av_get_scb_sep_type appropiate handle not found")
264 return 3; /* return invalid sep type */
265 }
266
267 /*******************************************************************************
268 **
269 ** Function bta_av_save_addr
270 **
271 ** Description copy the bd_addr and maybe reset the supported flags
272 **
273 **
274 ** Returns void
275 **
276 *******************************************************************************/
bta_av_save_addr(tBTA_AV_SCB * p_scb,const BD_ADDR b)277 static void bta_av_save_addr(tBTA_AV_SCB *p_scb, const BD_ADDR b)
278 {
279 APPL_TRACE_DEBUG("bta_av_save_addr r:%d, s:%d",
280 p_scb->recfg_sup, p_scb->suspend_sup);
281 if (bdcmp(p_scb->peer_addr, b) != 0) {
282 APPL_TRACE_WARNING("reset flags");
283 /* a new addr, reset the supported flags */
284 p_scb->recfg_sup = TRUE;
285 p_scb->suspend_sup = TRUE;
286 }
287
288 /* do this copy anyway, just in case the first addr matches
289 * the control block one by accident */
290 bdcpy(p_scb->peer_addr, b);
291 }
292
293 /*******************************************************************************
294 **
295 ** Function notify_start_failed
296 **
297 ** Description notify up-layer AV start failed
298 **
299 **
300 ** Returns void
301 **
302 *******************************************************************************/
notify_start_failed(tBTA_AV_SCB * p_scb)303 static void notify_start_failed(tBTA_AV_SCB *p_scb)
304 {
305 tBTA_AV_START start;
306 /* if start failed, clear role */
307 p_scb->role &= ~BTA_AV_ROLE_START_INT;
308 start.chnl = p_scb->chnl;
309 start.status = BTA_AV_FAIL;
310 start.initiator = TRUE;
311 start.hndl = p_scb->hndl;
312 (*bta_av_cb.p_cback)(BTA_AV_START_EVT, (tBTA_AV *) &start);
313 }
314
315 /*******************************************************************************
316 **
317 ** Function bta_av_st_rc_timer
318 **
319 ** Description start the AVRC timer if no RC connection & CT is supported &
320 ** RC is used or
321 ** as ACP (we do not really know if we want AVRC)
322 **
323 ** Returns void
324 **
325 *******************************************************************************/
bta_av_st_rc_timer(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)326 static void bta_av_st_rc_timer(tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
327 {
328 UNUSED(p_data);
329
330 APPL_TRACE_DEBUG("bta_av_st_rc_timer rc_handle:%d, use_rc: %d",
331 p_scb->rc_handle, p_scb->use_rc);
332 /* for outgoing RC connection as INT/CT */
333 if ( (p_scb->rc_handle == BTA_AV_RC_HANDLE_NONE) &&
334 /*(bta_av_cb.features & BTA_AV_FEAT_RCCT) &&*/
335 (p_scb->use_rc == TRUE || (p_scb->role & BTA_AV_ROLE_AD_ACP)) ) {
336 if ((p_scb->wait & BTA_AV_WAIT_ROLE_SW_BITS) == 0) {
337 bta_sys_start_timer(&p_scb->timer, BTA_AV_AVRC_TIMER_EVT, BTA_AV_RC_DISC_TIME_VAL);
338 } else {
339 p_scb->wait |= BTA_AV_WAIT_CHECK_RC;
340 }
341 }
342
343 }
344
345 /*******************************************************************************
346 **
347 ** Function bta_av_next_getcap
348 **
349 ** Description The function gets the capabilities of the next available
350 ** stream found in the discovery results.
351 **
352 ** Returns TRUE if we sent request to AVDT, FALSE otherwise.
353 **
354 *******************************************************************************/
bta_av_next_getcap(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)355 static BOOLEAN bta_av_next_getcap(tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
356 {
357 int i;
358 tAVDT_GETCAP_REQ *p_req;
359 BOOLEAN sent_cmd = FALSE;
360 UINT16 uuid_int = p_scb->uuid_int;
361 UINT8 sep_requested = 0;
362
363 if (uuid_int == UUID_SERVCLASS_AUDIO_SOURCE) {
364 sep_requested = AVDT_TSEP_SNK;
365 } else if (uuid_int == UUID_SERVCLASS_AUDIO_SINK) {
366 sep_requested = AVDT_TSEP_SRC;
367 }
368
369 for (i = p_scb->sep_info_idx; i < p_scb->num_seps; i++) {
370 /* steam not in use, is a sink, and is the right media type (audio/video) */
371 if ((p_scb->sep_info[i].in_use == FALSE) &&
372 (p_scb->sep_info[i].tsep == sep_requested) &&
373 (p_scb->sep_info[i].media_type == p_scb->media_type)) {
374 p_scb->sep_info_idx = i;
375
376 /* we got a stream; get its capabilities */
377 if (p_scb->p_cap == NULL) {
378 p_scb->p_cap = (tAVDT_CFG *) osi_malloc(sizeof(tAVDT_CFG));
379 }
380 if (p_scb->p_cap == NULL) {
381 i = p_scb->num_seps;
382 break;
383 }
384 if (p_scb->avdt_version >= AVDT_VERSION_SYNC) {
385 p_req = AVDT_GetAllCapReq;
386 } else {
387 p_req = AVDT_GetCapReq;
388 }
389 (*p_req)(p_scb->peer_addr,
390 p_scb->sep_info[i].seid,
391 p_scb->p_cap, bta_av_dt_cback[p_scb->hdi]);
392 sent_cmd = TRUE;
393 break;
394 }
395 }
396
397 /* if no streams available then stream open fails */
398 if (!sent_cmd) {
399 bta_av_ssm_execute(p_scb, BTA_AV_STR_GETCAP_FAIL_EVT, p_data);
400 }
401
402 return sent_cmd;
403
404 }
405
406 /*******************************************************************************
407 **
408 ** Function bta_av_proc_stream_evt
409 **
410 ** Description Utility function to compose stream events.
411 **
412 ** Returns void
413 **
414 *******************************************************************************/
bta_av_proc_stream_evt(UINT8 handle,BD_ADDR bd_addr,UINT8 event,tAVDT_CTRL * p_data,int index)415 static void bta_av_proc_stream_evt(UINT8 handle, BD_ADDR bd_addr, UINT8 event, tAVDT_CTRL *p_data, int index)
416 {
417 tBTA_AV_STR_MSG *p_msg;
418 UINT16 sec_len = 0;
419 tBTA_AV_SCB *p_scb = bta_av_cb.p_scb[index];
420 int xx;
421
422 if (event == AVDT_DELAY_REPORT_CFM_EVT) {
423 APPL_TRACE_DEBUG("%s: AVDT_DELAY_REPORT_CFM_EVT", __func__);
424 return;
425 }
426
427 if (p_data) {
428 if (event == AVDT_SECURITY_IND_EVT) {
429 sec_len = (p_data->security_ind.len < BTA_AV_SECURITY_MAX_LEN) ?
430 p_data->security_ind.len : BTA_AV_SECURITY_MAX_LEN;
431 } else if (event == AVDT_SECURITY_CFM_EVT && p_data->hdr.err_code == 0) {
432 sec_len = (p_data->security_cfm.len < BTA_AV_SECURITY_MAX_LEN) ?
433 p_data->security_cfm.len : BTA_AV_SECURITY_MAX_LEN;
434 }
435 }
436
437 if (p_scb && (p_msg = (tBTA_AV_STR_MSG *) osi_malloc((UINT16) (sizeof(tBTA_AV_STR_MSG) + sec_len))) != NULL) {
438
439 /* copy event data, bd addr, and handle to event message buffer */
440 p_msg->hdr.offset = 0;
441
442 if (bd_addr != NULL) {
443 bdcpy(p_msg->bd_addr, bd_addr);
444 APPL_TRACE_DEBUG(" bd_addr:%02x-%02x-%02x-%02x-%02x-%02x",
445 bd_addr[0], bd_addr[1],
446 bd_addr[2], bd_addr[3],
447 bd_addr[4], bd_addr[5]);
448 }
449
450 if (p_data != NULL) {
451 memcpy(&p_msg->msg, p_data, sizeof (tAVDT_CTRL));
452 /* copy config params to event message buffer */
453 switch (event) {
454 case AVDT_RECONFIG_CFM_EVT:
455 APPL_TRACE_DEBUG("reconfig cfm event codec info = 0x%06x-%06x-%06x-%02x",
456 (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],
457 (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],
458 (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],
459 p_msg->msg.reconfig_cfm.p_cfg->codec_info[9]);
460 break;
461
462
463
464 case AVDT_CONFIG_IND_EVT:
465 /* We might have 2 SEP signallings(A2DP + VDP) with one peer device on one L2CAP.
466 * If we already have a signalling connection with the bd_addr and the streaming
467 * SST is at INIT state, change it to INCOMING state to handle the signalling
468 * from the 2nd SEP. */
469 if ((bta_av_find_lcb(bd_addr, BTA_AV_LCB_FIND) != NULL) && (bta_av_is_scb_init(p_scb))) {
470 bta_av_set_scb_sst_incoming (p_scb);
471
472 /* When ACP_CONNECT_EVT was received, we put first available scb to incoming state.
473 * Later when we receive AVDT_CONFIG_IND_EVT, we use a new p_scb and set its state to
474 * incoming which we do it above.
475 * We also have to set the old p_scb state to init to be used later */
476 for (xx = 0; xx < BTA_AV_NUM_STRS; xx++) {
477 if ((bta_av_cb.p_scb[xx]) && (xx != index)) {
478 if (bta_av_cb.p_scb[xx]->state == BTA_AV_INCOMING_SST) {
479 bta_av_cb.p_scb[xx]->state = BTA_AV_INIT_SST;
480 bta_av_cb.p_scb[xx]->coll_mask = 0;
481 break;
482 }
483 }
484 }
485 }
486
487 memcpy(&p_msg->cfg, p_data->config_ind.p_cfg, sizeof(tAVDT_CFG));
488 break;
489
490 case AVDT_SECURITY_IND_EVT:
491 p_msg->msg.security_ind.p_data = (UINT8 *) (p_msg + 1);
492 memcpy(p_msg->msg.security_ind.p_data, p_data->security_ind.p_data, sec_len);
493 break;
494
495 case AVDT_SECURITY_CFM_EVT:
496 p_msg->msg.security_cfm.p_data = (UINT8 *) (p_msg + 1);
497 if (p_data->hdr.err_code == 0) {
498 memcpy(p_msg->msg.security_cfm.p_data, p_data->security_cfm.p_data, sec_len);
499 }
500 break;
501 case AVDT_SUSPEND_IND_EVT:
502 p_msg->msg.hdr.err_code = 0;
503 break;
504 /*
505 case AVDT_CLOSE_CFM_EVT:
506 case AVDT_CLOSE_IND_EVT:
507 p_msg->disc_rsn = p_data->hdr.err_param;
508 break;
509 */
510 case AVDT_DISCONNECT_IND_EVT:
511 p_msg->hdr.offset = p_data->hdr.err_param;
512 break;
513 default:
514 break;
515 }
516 } else {
517 p_msg->msg.hdr.err_code = 0;
518 }
519
520 /* look up application event */
521 if ((p_data == NULL) || (p_data->hdr.err_code == 0)) {
522 p_msg->hdr.event = bta_av_stream_evt_ok[event];
523 if (p_msg->hdr.event == BTA_AV_STR_START_OK_EVT) {
524 BTA_DmCoexEventTrigger(BTA_COEX_EVT_STREAMING_STARTED);
525 } else if (p_msg->hdr.event == BTA_AV_STR_START_FAIL_EVT ||
526 p_msg->hdr.event == BTA_AV_STR_SUSPEND_CFM_EVT ||
527 p_msg->hdr.event == BTA_AV_STR_CLOSE_EVT) {
528 BTA_DmCoexEventTrigger(BTA_COEX_EVT_STREAMING_STOPPED);
529 }
530 } else {
531 p_msg->hdr.event = bta_av_stream_evt_fail[event];
532 if (p_msg->hdr.event == BTA_AV_STR_START_FAIL_EVT ||
533 p_msg->hdr.event == BTA_AV_STR_START_OK_EVT ||
534 p_msg->hdr.event == BTA_AV_STR_SUSPEND_CFM_EVT ||
535 p_msg->hdr.event == BTA_AV_STR_CLOSE_EVT) {
536 BTA_DmCoexEventTrigger(BTA_COEX_EVT_STREAMING_STOPPED);
537 }
538 }
539
540 p_msg->initiator = FALSE;
541 if (event == AVDT_SUSPEND_CFM_EVT) {
542 p_msg->initiator = TRUE;
543 }
544
545 APPL_TRACE_VERBOSE("hndl:x%x", p_scb->hndl);
546 p_msg->hdr.layer_specific = p_scb->hndl;
547 p_msg->handle = handle;
548 p_msg->avdt_event = event;
549 bta_sys_sendmsg(p_msg);
550 }
551
552 /* coverity[var_deref_model] */
553 /* false-positive: bta_av_conn_cback only processes AVDT_CONNECT_IND_EVT and AVDT_DISCONNECT_IND_EVT event
554 * these 2 events always have associated p_data */
555 if (p_data) {
556 bta_av_conn_cback(handle, bd_addr, event, p_data);
557 } else {
558 APPL_TRACE_EVENT("%s: p_data is null", __func__);
559 }
560 }
561
562 /*******************************************************************************
563 **
564 ** Function bta_av_stream_data_cback
565 **
566 ** Description This is the AVDTP callback function for stream events.
567 **
568 ** Returns void
569 **
570 *******************************************************************************/
bta_av_stream_data_cback(UINT8 handle,BT_HDR * p_pkt,UINT32 time_stamp,UINT8 m_pt)571 void bta_av_stream_data_cback(UINT8 handle, BT_HDR *p_pkt, UINT32 time_stamp, UINT8 m_pt)
572 {
573 int index = 0;
574 tBTA_AV_SCB *p_scb ;
575 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);
576 APPL_TRACE_DEBUG(" Number of frames 0x%x", *((UINT8 *)(p_pkt + 1) + p_pkt->offset));
577 APPL_TRACE_DEBUG("Sequence Number 0x%x", p_pkt->layer_specific);
578 /* Get SCB and correct sep type*/
579 for (index = 0; index < BTA_AV_NUM_STRS; index ++ ) {
580 p_scb = bta_av_cb.p_scb[index];
581 if ((p_scb->avdt_handle == handle) && (p_scb->seps[p_scb->sep_idx].tsep == AVDT_TSEP_SNK)) {
582 break;
583 }
584 }
585 if (index == BTA_AV_NUM_STRS) { /* cannot find correct handler */
586 osi_free(p_pkt);
587 return;
588 }
589 p_pkt->event = BTA_AV_MEDIA_DATA_EVT;
590 p_scb->seps[p_scb->sep_idx].p_app_data_cback(BTA_AV_MEDIA_DATA_EVT, (tBTA_AV_MEDIA *)p_pkt);
591 osi_free(p_pkt); /* a copy of packet had been delivered, we free this buffer */
592 }
593
594 /*******************************************************************************
595 **
596 ** Function bta_av_stream0_cback
597 **
598 ** Description This is the AVDTP callback function for stream events.
599 **
600 ** Returns void
601 **
602 *******************************************************************************/
bta_av_stream0_cback(UINT8 handle,BD_ADDR bd_addr,UINT8 event,tAVDT_CTRL * p_data)603 static void bta_av_stream0_cback(UINT8 handle, BD_ADDR bd_addr, UINT8 event, tAVDT_CTRL *p_data)
604 {
605 APPL_TRACE_VERBOSE("bta_av_stream0_cback avdt_handle: %d event=0x%x", handle, event);
606 bta_av_proc_stream_evt(handle, bd_addr, event, p_data, 0);
607 }
608
609 /*******************************************************************************
610 **
611 ** Function bta_av_stream1_cback
612 **
613 ** Description This is the AVDTP callback function for stream events.
614 **
615 ** Returns void
616 **
617 *******************************************************************************/
bta_av_stream1_cback(UINT8 handle,BD_ADDR bd_addr,UINT8 event,tAVDT_CTRL * p_data)618 static void bta_av_stream1_cback(UINT8 handle, BD_ADDR bd_addr, UINT8 event, tAVDT_CTRL *p_data)
619 {
620 APPL_TRACE_EVENT("bta_av_stream1_cback avdt_handle: %d event=0x%x", handle, event);
621 bta_av_proc_stream_evt(handle, bd_addr, event, p_data, 1);
622 }
623
624 #if BTA_AV_NUM_STRS > 2
625 /*******************************************************************************
626 **
627 ** Function bta_av_stream2_cback
628 **
629 ** Description This is the AVDTP callback function for stream events.
630 **
631 ** Returns void
632 **
633 *******************************************************************************/
bta_av_stream2_cback(UINT8 handle,BD_ADDR bd_addr,UINT8 event,tAVDT_CTRL * p_data)634 static void bta_av_stream2_cback(UINT8 handle, BD_ADDR bd_addr, UINT8 event, tAVDT_CTRL *p_data)
635 {
636 APPL_TRACE_EVENT("bta_av_stream2_cback avdt_handle: %d event=0x%x", handle, event);
637 bta_av_proc_stream_evt(handle, bd_addr, event, p_data, 2);
638 }
639 #endif
640
641 #if BTA_AV_NUM_STRS > 3
642 /*******************************************************************************
643 **
644 ** Function bta_av_stream3_cback
645 **
646 ** Description This is the AVDTP callback function for stream events.
647 **
648 ** Returns void
649 **
650 *******************************************************************************/
bta_av_stream3_cback(UINT8 handle,BD_ADDR bd_addr,UINT8 event,tAVDT_CTRL * p_data)651 static void bta_av_stream3_cback(UINT8 handle, BD_ADDR bd_addr, UINT8 event, tAVDT_CTRL *p_data)
652 {
653 APPL_TRACE_EVENT("bta_av_stream3_cback avdt_handle: %d event=0x%x", handle, event);
654 bta_av_proc_stream_evt(handle, bd_addr, event, p_data, 3);
655 }
656 #endif
657
658 /*******************************************************************************
659 **
660 ** Function bta_av_stream4_cback
661 **
662 ** Description This is the AVDTP callback function for stream events.
663 **
664 ** Returns void
665 **
666 *******************************************************************************/
667 #if BTA_AV_NUM_STRS > 4
bta_av_stream4_cback(UINT8 handle,BD_ADDR bd_addr,UINT8 event,tAVDT_CTRL * p_data)668 static void bta_av_stream4_cback(UINT8 handle, BD_ADDR bd_addr, UINT8 event, tAVDT_CTRL *p_data)
669 {
670 APPL_TRACE_EVENT("bta_av_stream4_cback avdt_handle: %d event=0x%x", handle, event);
671 bta_av_proc_stream_evt(handle, bd_addr, event, p_data, 4);
672 }
673 #endif
674
675 /*******************************************************************************
676 **
677 ** Function bta_av_stream5_cback
678 **
679 ** Description This is the AVDTP callback function for stream events.
680 **
681 ** Returns void
682 **
683 *******************************************************************************/
684 #if BTA_AV_NUM_STRS > 5
bta_av_stream5_cback(UINT8 handle,BD_ADDR bd_addr,UINT8 event,tAVDT_CTRL * p_data)685 static void bta_av_stream5_cback(UINT8 handle, BD_ADDR bd_addr, UINT8 event, tAVDT_CTRL *p_data)
686 {
687 APPL_TRACE_EVENT("bta_av_stream5_cback avdt_handle: %d event=0x%x", handle, event);
688 bta_av_proc_stream_evt(handle, bd_addr, event, p_data, 5);
689 }
690 #endif
691
692 /*******************************************************************************
693 **
694 ** Function bta_av_a2d_sdp_cback
695 **
696 ** Description A2DP service discovery callback.
697 **
698 ** Returns void
699 **
700 *******************************************************************************/
bta_av_a2d_sdp_cback(BOOLEAN found,tA2D_Service * p_service)701 static void bta_av_a2d_sdp_cback(BOOLEAN found, tA2D_Service *p_service)
702 {
703 tBTA_AV_SDP_RES *p_msg;
704 tBTA_AV_SCB *p_scb;
705
706 if ((p_msg = (tBTA_AV_SDP_RES *) osi_malloc(sizeof(tBTA_AV_SDP_RES))) != NULL) {
707 p_msg->hdr.event = (found) ? BTA_AV_SDP_DISC_OK_EVT : BTA_AV_SDP_DISC_FAIL_EVT;
708
709 p_scb = bta_av_hndl_to_scb(bta_av_cb.handle);
710 if (p_scb) {
711 if (found && (p_service != NULL)) {
712 p_scb->avdt_version = p_service->avdt_version;
713 } else {
714 p_scb->avdt_version = 0x00;
715 }
716
717 p_msg->hdr.layer_specific = bta_av_cb.handle;
718 bta_sys_sendmsg(p_msg);
719 } else {
720 APPL_TRACE_ERROR ("bta_av_a2d_sdp_cback, no scb found for handle(0x%x)", bta_av_cb.handle);
721 }
722 }
723 }
724
725 /*******************************************************************************
726 **
727 ** Function bta_av_adjust_seps_idx
728 **
729 ** Description adjust the sep_idx
730 **
731 ** Returns
732 **
733 *******************************************************************************/
bta_av_adjust_seps_idx(tBTA_AV_SCB * p_scb,UINT8 avdt_handle)734 static void bta_av_adjust_seps_idx(tBTA_AV_SCB *p_scb, UINT8 avdt_handle)
735 {
736 int xx;
737 APPL_TRACE_DEBUG("bta_av_adjust_seps_idx codec_type: %d", p_scb->codec_type);
738 for (xx = 0; xx < BTA_AV_MAX_SEPS; xx++) {
739 APPL_TRACE_DEBUG("av_handle: %d codec_type: %d",
740 p_scb->seps[xx].av_handle, p_scb->seps[xx].codec_type);
741 if ((p_scb->seps[xx].av_handle) && (p_scb->seps[xx].av_handle == avdt_handle)) {
742 p_scb->sep_idx = xx;
743 p_scb->avdt_handle = p_scb->seps[xx].av_handle;
744 break;
745 }
746 }
747 }
748
749 /*******************************************************************************
750 **
751 ** Function bta_av_switch_role
752 **
753 ** Description Switch role was not started and a timer was started.
754 ** another attempt to switch role now - still opening.
755 **
756 ** Returns void
757 **
758 *******************************************************************************/
bta_av_switch_role(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)759 void bta_av_switch_role (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
760 {
761 tBTA_AV_RS_RES switch_res = BTA_AV_RS_NONE;
762 tBTA_AV_API_OPEN *p_buf = &p_scb->q_info.open;
763 UNUSED(p_data);
764
765 APPL_TRACE_DEBUG("bta_av_switch_role wait:x%x", p_scb->wait);
766 if (p_scb->wait & BTA_AV_WAIT_ROLE_SW_RES_START) {
767 p_scb->wait |= BTA_AV_WAIT_ROLE_SW_RETRY;
768 }
769
770 /* clear the masks set when the timer is started */
771 p_scb->wait &= ~(BTA_AV_WAIT_ROLE_SW_RES_OPEN | BTA_AV_WAIT_ROLE_SW_RES_START);
772
773 if (p_scb->q_tag == BTA_AV_Q_TAG_OPEN) {
774 if (bta_av_switch_if_needed(p_scb) || !bta_av_link_role_ok(p_scb, A2D_SET_MULTL_BIT)) {
775 p_scb->wait |= BTA_AV_WAIT_ROLE_SW_RES_OPEN;
776 } else {
777 /* this should not happen in theory. Just in case...
778 * continue to do_disc_a2d */
779 switch_res = BTA_AV_RS_DONE;
780 }
781 } else {
782 /* report failure on OPEN */
783 switch_res = BTA_AV_RS_FAIL;
784 }
785
786 if (switch_res != BTA_AV_RS_NONE) {
787 if (bta_av_cb.rs_idx == (p_scb->hdi + 1)) {
788 bta_av_cb.rs_idx = 0;
789 }
790 p_scb->wait &= ~BTA_AV_WAIT_ROLE_SW_RETRY;
791 p_scb->q_tag = 0;
792 p_buf->switch_res = switch_res;
793 bta_av_do_disc_a2d(p_scb, (tBTA_AV_DATA *)p_buf);
794 }
795 }
796
797 /*******************************************************************************
798 **
799 ** Function bta_av_role_res
800 **
801 ** Description Handle the role changed event
802 **
803 **
804 ** Returns void
805 **
806 *******************************************************************************/
bta_av_role_res(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)807 void bta_av_role_res (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
808 {
809 BOOLEAN initiator = FALSE;
810 tBTA_AV_START start;
811 tBTA_AV_OPEN av_open;
812
813 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);
814 if (p_scb->role & BTA_AV_ROLE_START_INT) {
815 initiator = TRUE;
816 }
817
818 if (p_scb->q_tag == BTA_AV_Q_TAG_START) {
819 if (p_scb->wait & BTA_AV_WAIT_ROLE_SW_STARTED) {
820 p_scb->wait &= ~BTA_AV_WAIT_ROLE_SW_BITS;
821 if (p_data->role_res.hci_status != HCI_SUCCESS) {
822 p_scb->role &= ~BTA_AV_ROLE_START_INT;
823 bta_sys_idle(TSEP_TO_SYS_ID(p_scb->seps[p_scb->sep_idx].tsep), bta_av_cb.audio_open_cnt, p_scb->peer_addr);
824 /* start failed because of role switch. */
825 start.chnl = p_scb->chnl;
826 start.status = BTA_AV_FAIL_ROLE;
827 start.hndl = p_scb->hndl;
828 start.initiator = initiator;
829 (*bta_av_cb.p_cback)(BTA_AV_START_EVT, (tBTA_AV *) &start);
830 } else {
831 bta_av_start_ok(p_scb, p_data);
832 }
833 } else if (p_scb->wait & BTA_AV_WAIT_ROLE_SW_RES_START) {
834 p_scb->wait |= BTA_AV_WAIT_ROLE_SW_FAILED;
835 }
836 } else if (p_scb->q_tag == BTA_AV_Q_TAG_OPEN) {
837 if (p_scb->wait & BTA_AV_WAIT_ROLE_SW_RES_OPEN) {
838 p_scb->role &= ~BTA_AV_ROLE_START_INT;
839 p_scb->wait &= ~BTA_AV_WAIT_ROLE_SW_BITS;
840
841 if (p_data->role_res.hci_status != HCI_SUCCESS) {
842 /* Open failed because of role switch. */
843 bdcpy(av_open.bd_addr, p_scb->peer_addr);
844 av_open.chnl = p_scb->chnl;
845 av_open.hndl = p_scb->hndl;
846 start.status = BTA_AV_FAIL_ROLE;
847 if (p_scb->seps[p_scb->sep_idx].tsep == AVDT_TSEP_SRC ) {
848 av_open.sep = AVDT_TSEP_SNK;
849 } else if (p_scb->seps[p_scb->sep_idx].tsep == AVDT_TSEP_SNK ) {
850 av_open.sep = AVDT_TSEP_SRC;
851 }
852 (*bta_av_cb.p_cback)(BTA_AV_OPEN_EVT, (tBTA_AV *)&av_open);
853 } else {
854 /* Continue av open process */
855 p_scb->q_info.open.switch_res = BTA_AV_RS_DONE;
856 bta_av_do_disc_a2d (p_scb, (tBTA_AV_DATA *) & (p_scb->q_info.open));
857 }
858 } else {
859 APPL_TRACE_WARNING ("Unexpected role switch event: q_tag = %d wait = %d", p_scb->q_tag, p_scb->wait);
860 }
861 }
862
863 APPL_TRACE_DEBUG("wait:x%x, role:x%x", p_scb->wait, p_scb->role);
864 }
865
866 /*******************************************************************************
867 **
868 ** Function bta_av_delay_co
869 **
870 ** Description Call the delay call-out function to report the delay report
871 ** from SNK
872 **
873 ** Returns void
874 **
875 *******************************************************************************/
bta_av_delay_co(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)876 void bta_av_delay_co (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
877 {
878 p_scb->p_cos->delay(p_scb->hndl, p_data->str_msg.msg.delay_rpt_cmd.delay);
879 }
880
881 /*******************************************************************************
882 **
883 ** Function bta_av_do_disc_a2d
884 **
885 ** Description Do service discovery for A2DP.
886 **
887 ** Returns void
888 **
889 *******************************************************************************/
bta_av_do_disc_a2d(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)890 void bta_av_do_disc_a2d (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
891 {
892 BOOLEAN ok_continue = FALSE;
893 tA2D_SDP_DB_PARAMS db_params;
894 UINT16 attr_list[] = {ATTR_ID_SERVICE_CLASS_ID_LIST,
895 ATTR_ID_PROTOCOL_DESC_LIST,
896 ATTR_ID_BT_PROFILE_DESC_LIST
897 };
898 UINT16 sdp_uuid = 0; /* UUID for which SDP has to be done */
899
900 APPL_TRACE_DEBUG("bta_av_do_disc_a2d use_rc: %d rs:%d, oc:%d",
901 p_data->api_open.use_rc, p_data->api_open.switch_res, bta_av_cb.audio_open_cnt);
902
903 memcpy (&(p_scb->open_api), &(p_data->api_open), sizeof(tBTA_AV_API_OPEN));
904
905 switch (p_data->api_open.switch_res) {
906 case BTA_AV_RS_NONE:
907 if (bta_av_switch_if_needed(p_scb) || !bta_av_link_role_ok(p_scb, A2D_SET_MULTL_BIT)) {
908 /* waiting for role switch result. save the api to control block */
909 memcpy(&p_scb->q_info.open, &p_data->api_open, sizeof(tBTA_AV_API_OPEN));
910 p_scb->wait |= BTA_AV_WAIT_ROLE_SW_RES_OPEN;
911 p_scb->q_tag = BTA_AV_Q_TAG_OPEN;
912 } else {
913 ok_continue = TRUE;
914 }
915 break;
916
917 case BTA_AV_RS_FAIL:
918 /* report a new failure event */
919 p_scb->open_status = BTA_AV_FAIL_ROLE;
920 bta_av_ssm_execute(p_scb, BTA_AV_SDP_DISC_FAIL_EVT, NULL);
921 break;
922
923 case BTA_AV_RS_OK:
924 p_data = (tBTA_AV_DATA *)&p_scb->q_info.open;
925 /* continue to open if link role is ok */
926 if (bta_av_link_role_ok(p_scb, A2D_SET_MULTL_BIT)) {
927 ok_continue = TRUE;
928 } else {
929 p_scb->wait |= BTA_AV_WAIT_ROLE_SW_RES_OPEN;
930 }
931 break;
932
933 case BTA_AV_RS_DONE:
934 ok_continue = TRUE;
935 break;
936 }
937
938 APPL_TRACE_DEBUG("ok_continue: %d wait:x%x, q_tag: %d", ok_continue, p_scb->wait, p_scb->q_tag);
939 if (!ok_continue) {
940 return;
941 }
942
943 /* clear the role switch bits */
944 p_scb->wait &= ~BTA_AV_WAIT_ROLE_SW_BITS;
945
946 if (p_scb->wait & BTA_AV_WAIT_CHECK_RC) {
947 p_scb->wait &= ~BTA_AV_WAIT_CHECK_RC;
948 bta_sys_start_timer(&p_scb->timer, BTA_AV_AVRC_TIMER_EVT, BTA_AV_RC_DISC_TIME_VAL);
949 }
950
951 if (bta_av_cb.features & BTA_AV_FEAT_MASTER) {
952 L2CA_SetDesireRole(L2CAP_ROLE_DISALLOW_SWITCH);
953
954 if (bta_av_cb.audio_open_cnt == 1) {
955 /* there's already an A2DP connection. do not allow switch */
956 bta_sys_clear_default_policy(BTA_ID_AV, HCI_ENABLE_MASTER_SLAVE_SWITCH);
957 }
958 }
959 /* store peer addr other parameters */
960 bta_av_save_addr(p_scb, p_data->api_open.bd_addr);
961 p_scb->sec_mask = p_data->api_open.sec_mask;
962 p_scb->use_rc = p_data->api_open.use_rc;
963
964 bta_sys_app_open(TSEP_TO_SYS_ID(p_scb->seps[p_scb->sep_idx].tsep), p_scb->app_id, p_scb->peer_addr);
965
966 /* allocate discovery database */
967 if (p_scb->p_disc_db == NULL) {
968 p_scb->p_disc_db = (tSDP_DISCOVERY_DB *) osi_malloc(BTA_AV_DISC_BUF_SIZE);
969 }
970
971 /* only one A2D find service is active at a time */
972 bta_av_cb.handle = p_scb->hndl;
973
974 if (p_scb->p_disc_db) {
975 /* set up parameters */
976 db_params.db_len = BTA_AV_DISC_BUF_SIZE;
977 db_params.num_attr = 3;
978 db_params.p_db = p_scb->p_disc_db;
979 db_params.p_attrs = attr_list;
980 p_scb->uuid_int = p_data->api_open.uuid;
981 if (p_scb->uuid_int == UUID_SERVCLASS_AUDIO_SINK) {
982 sdp_uuid = UUID_SERVCLASS_AUDIO_SOURCE;
983 } else if (p_scb->uuid_int == UUID_SERVCLASS_AUDIO_SOURCE) {
984 sdp_uuid = UUID_SERVCLASS_AUDIO_SINK;
985 }
986
987 APPL_TRACE_DEBUG("uuid_int 0x%x, Doing SDP For 0x%x", p_scb->uuid_int, sdp_uuid);
988 if (A2D_FindService(sdp_uuid, p_scb->peer_addr, &db_params,
989 bta_av_a2d_sdp_cback) == A2D_SUCCESS) {
990 return;
991 }
992 }
993
994 /* when the code reaches here, either the DB is NULL
995 * or A2D_FindService is not successful */
996 bta_av_a2d_sdp_cback(FALSE, NULL);
997 }
998
999 /*******************************************************************************
1000 **
1001 ** Function bta_av_cleanup
1002 **
1003 ** Description cleanup AV stream control block.
1004 **
1005 ** Returns void
1006 **
1007 *******************************************************************************/
bta_av_cleanup(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)1008 void bta_av_cleanup(tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
1009 {
1010 tBTA_AV_CONN_CHG msg;
1011 int xx;
1012 UINT8 role = BTA_AV_ROLE_AD_INT;
1013 UNUSED(p_data);
1014
1015 APPL_TRACE_DEBUG("bta_av_cleanup");
1016
1017 /* free any buffers */
1018 utl_freebuf((void **) &p_scb->p_cap);
1019 utl_freebuf((void **) &p_scb->p_disc_db);
1020 p_scb->avdt_version = 0;
1021
1022 /* initialize some control block variables */
1023 p_scb->open_status = BTA_AV_SUCCESS;
1024
1025 /* if de-registering shut everything down */
1026 msg.hdr.layer_specific = p_scb->hndl;
1027 p_scb->started = FALSE;
1028 p_scb->cong = FALSE;
1029 p_scb->role = role;
1030 p_scb->cur_psc_mask = 0;
1031 p_scb->wait = 0;
1032 p_scb->num_disc_snks = 0;
1033 p_scb->disc_rsn = 0;
1034 p_scb->avdt_handle = 0;
1035 bta_sys_stop_timer(&p_scb->timer);
1036 if (p_scb->deregistring) {
1037 /* remove stream */
1038 for (xx = 0; xx < BTA_AV_MAX_SEPS; xx++) {
1039 if (p_scb->seps[xx].av_handle) {
1040 AVDT_RemoveStream(p_scb->seps[xx].av_handle);
1041 }
1042 p_scb->seps[xx].av_handle = 0;
1043 }
1044
1045 bta_av_dereg_comp((tBTA_AV_DATA *) &msg);
1046 } else {
1047 /* report stream closed to main SM */
1048 msg.is_up = FALSE;
1049 bdcpy(msg.peer_addr, p_scb->peer_addr);
1050 bta_av_conn_chg((tBTA_AV_DATA *) &msg);
1051 }
1052 }
1053
1054 /*******************************************************************************
1055 **
1056 ** Function bta_av_free_sdb
1057 **
1058 ** Description Free service discovery db buffer.
1059 **
1060 ** Returns void
1061 **
1062 *******************************************************************************/
bta_av_free_sdb(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)1063 void bta_av_free_sdb(tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
1064 {
1065 UNUSED(p_data);
1066 utl_freebuf((void **) &p_scb->p_disc_db);
1067 }
1068
1069 /*******************************************************************************
1070 **
1071 ** Function bta_av_open_fail_sdp
1072 **
1073 ** Description report BTA_AV_OPEN_EVT with service discovery failed status
1074 **
1075 ** Returns void
1076 **
1077 *******************************************************************************/
bta_av_open_fail_sdp(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)1078 void bta_av_open_fail_sdp(tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
1079 {
1080 tBTA_AV_OPEN open;
1081
1082 bdcpy(open.bd_addr, p_scb->peer_addr);
1083 open.chnl = p_scb->chnl;
1084 open.hndl = p_scb->hndl;
1085 open.status = BTA_AV_FAIL_SDP;
1086
1087 if (p_scb->seps[p_scb->sep_idx].tsep == AVDT_TSEP_SRC ) {
1088 open.sep = AVDT_TSEP_SNK;
1089 } else if (p_scb->seps[p_scb->sep_idx].tsep == AVDT_TSEP_SNK ) {
1090 open.sep = AVDT_TSEP_SRC;
1091 }
1092
1093 (*bta_av_cb.p_cback)(BTA_AV_OPEN_EVT, (tBTA_AV *) &open);
1094
1095 UNUSED(p_data);
1096 }
1097
1098 /*******************************************************************************
1099 **
1100 ** Function bta_av_config_ind
1101 **
1102 ** Description Handle a stream configuration indication from the peer.
1103 **
1104 ** Returns void
1105 **
1106 *******************************************************************************/
bta_av_config_ind(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)1107 void bta_av_config_ind (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
1108 {
1109 tBTA_AV_CI_SETCONFIG setconfig;
1110 tAVDT_SEP_INFO *p_info;
1111 tAVDT_CFG *p_evt_cfg = &p_data->str_msg.cfg;
1112 UINT8 psc_mask = (p_evt_cfg->psc_mask | p_scb->cfg.psc_mask);
1113 UINT8 local_sep; /* sep type of local handle on which connection was received */
1114 tBTA_AV_STR_MSG *p_msg = (tBTA_AV_STR_MSG *)p_data;
1115 UNUSED(p_data);
1116
1117 local_sep = bta_av_get_scb_sep_type(p_scb, p_msg->handle);
1118 p_scb->avdt_label = p_data->str_msg.msg.hdr.label;
1119 memcpy(p_scb->cfg.codec_info, p_evt_cfg->codec_info, AVDT_CODEC_SIZE);
1120 p_scb->codec_type = p_evt_cfg->codec_info[BTA_AV_CODEC_TYPE_IDX];
1121 bta_av_save_addr(p_scb, p_data->str_msg.bd_addr);
1122
1123 /* Clear collision mask */
1124 p_scb->coll_mask = 0;
1125 bta_sys_stop_timer(&bta_av_cb.acp_sig_tmr);
1126
1127 /* if no codec parameters in configuration, fail */
1128 if ((p_evt_cfg->num_codec == 0) ||
1129 /* or the peer requests for a service we do not support */
1130 ((psc_mask != p_scb->cfg.psc_mask) &&
1131 (psc_mask != (p_scb->cfg.psc_mask & ~AVDT_PSC_DELAY_RPT))) ) {
1132 setconfig.hndl = p_scb->hndl; /* we may not need this */
1133 setconfig.err_code = AVDT_ERR_UNSUP_CFG;
1134 bta_av_ssm_execute(p_scb, BTA_AV_CI_SETCONFIG_FAIL_EVT, (tBTA_AV_DATA *) &setconfig);
1135 } else {
1136 p_info = &p_scb->sep_info[0];
1137 p_info->in_use = 0;
1138 p_info->media_type = p_scb->media_type;
1139 p_info->seid = p_data->str_msg.msg.config_ind.int_seid;
1140
1141 /* Sep type of Peer will be oppsite role to our local sep */
1142 if (local_sep == AVDT_TSEP_SRC) {
1143 p_info->tsep = AVDT_TSEP_SNK;
1144 } else if (local_sep == AVDT_TSEP_SNK) {
1145 p_info->tsep = AVDT_TSEP_SRC;
1146 }
1147
1148 p_scb->role |= BTA_AV_ROLE_AD_ACP;
1149 p_scb->cur_psc_mask = p_evt_cfg->psc_mask;
1150 if (bta_av_cb.features & BTA_AV_FEAT_RCTG) {
1151 p_scb->use_rc = TRUE;
1152 } else {
1153 p_scb->use_rc = FALSE;
1154 }
1155
1156 p_scb->num_seps = 1;
1157 p_scb->sep_info_idx = 0;
1158 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);
1159 /* in case of A2DP SINK this is the first time peer data is being sent to co functions */
1160 if (local_sep == AVDT_TSEP_SNK) {
1161 p_scb->p_cos->setcfg(p_scb->hndl, p_scb->codec_type,
1162 p_evt_cfg->codec_info,
1163 p_info->seid,
1164 p_scb->peer_addr,
1165 p_evt_cfg->num_protect,
1166 p_evt_cfg->protect_info,
1167 AVDT_TSEP_SNK,
1168 p_msg->handle);
1169 } else {
1170 p_scb->p_cos->setcfg(p_scb->hndl, p_scb->codec_type,
1171 p_evt_cfg->codec_info,
1172 p_info->seid,
1173 p_scb->peer_addr,
1174 p_evt_cfg->num_protect,
1175 p_evt_cfg->protect_info,
1176 AVDT_TSEP_SRC,
1177 p_msg->handle);
1178 }
1179 }
1180 }
1181
1182 /*******************************************************************************
1183 **
1184 ** Function bta_av_disconnect_req
1185 **
1186 ** Description Disconnect AVDTP connection.
1187 **
1188 ** Returns void
1189 **
1190 *******************************************************************************/
bta_av_disconnect_req(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)1191 void bta_av_disconnect_req (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
1192 {
1193 tBTA_AV_RCB *p_rcb;
1194 UNUSED(p_data);
1195
1196 APPL_TRACE_DEBUG("bta_av_disconnect_req conn_lcb: 0x%x", bta_av_cb.conn_lcb);
1197
1198 bta_sys_stop_timer(&bta_av_cb.sig_tmr);
1199 bta_sys_stop_timer(&p_scb->timer);
1200 if (bta_av_cb.conn_lcb) {
1201 p_rcb = bta_av_get_rcb_by_shdl((UINT8)(p_scb->hdi + 1));
1202 if (p_rcb) {
1203 bta_av_del_rc(p_rcb);
1204 }
1205 AVDT_DisconnectReq(p_scb->peer_addr, bta_av_dt_cback[p_scb->hdi]);
1206 } else {
1207 bta_av_ssm_execute(p_scb, BTA_AV_AVDT_DISCONNECT_EVT, NULL);
1208 }
1209 }
1210
1211 /*******************************************************************************
1212 **
1213 ** Function bta_av_security_req
1214 **
1215 ** Description Send an AVDTP security request.
1216 **
1217 ** Returns void
1218 **
1219 *******************************************************************************/
bta_av_security_req(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)1220 void bta_av_security_req (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
1221 {
1222 if (bta_av_cb.features & BTA_AV_FEAT_PROTECT) {
1223 AVDT_SecurityReq(p_scb->avdt_handle, p_data->api_protect_req.p_data,
1224 p_data->api_protect_req.len);
1225 }
1226 }
1227
1228 /*******************************************************************************
1229 **
1230 ** Function bta_av_security_rsp
1231 **
1232 ** Description Send an AVDTP security response.
1233 **
1234 ** Returns void
1235 **
1236 *******************************************************************************/
bta_av_security_rsp(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)1237 void bta_av_security_rsp (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
1238 {
1239 if (bta_av_cb.features & BTA_AV_FEAT_PROTECT) {
1240 AVDT_SecurityRsp(p_scb->avdt_handle, p_scb->avdt_label, p_data->api_protect_rsp.error_code,
1241 p_data->api_protect_rsp.p_data, p_data->api_protect_rsp.len);
1242 } else {
1243 AVDT_SecurityRsp(p_scb->avdt_handle, p_scb->avdt_label, AVDT_ERR_NSC,
1244 NULL, 0);
1245 }
1246 }
1247
1248 /*******************************************************************************
1249 **
1250 ** Function bta_av_setconfig_rsp
1251 **
1252 ** Description setconfig is OK
1253 **
1254 ** Returns void
1255 **
1256 *******************************************************************************/
bta_av_setconfig_rsp(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)1257 void bta_av_setconfig_rsp (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
1258 {
1259 UINT8 num = p_data->ci_setconfig.num_seid + 1;
1260 UINT8 avdt_handle = p_data->ci_setconfig.avdt_handle;
1261 UINT8 *p_seid = p_data->ci_setconfig.p_seid;
1262 int i;
1263 UINT8 local_sep;
1264 tBTA_AV_SNK_PSC_CFG psc_cfg = {0};
1265
1266 /* we like this codec_type. find the sep_idx */
1267 local_sep = bta_av_get_scb_sep_type(p_scb, avdt_handle);
1268 bta_av_adjust_seps_idx(p_scb, avdt_handle);
1269 APPL_TRACE_DEBUG("bta_av_setconfig_rsp: sep_idx: %d cur_psc_mask:0x%x", p_scb->sep_idx, p_scb->cur_psc_mask);
1270
1271 if (AVDT_TSEP_SNK == local_sep) {
1272 if ((p_data->ci_setconfig.err_code == AVDT_SUCCESS) &&
1273 (p_scb->seps[p_scb->sep_idx].p_app_data_cback != NULL)) {
1274 p_scb->seps[p_scb->sep_idx].p_app_data_cback(BTA_AV_MEDIA_SINK_CFG_EVT,
1275 (tBTA_AV_MEDIA *)p_scb->cfg.codec_info);
1276 }
1277 if (p_scb->cur_psc_mask & AVDT_PSC_DELAY_RPT) {
1278 psc_cfg.psc_mask |= BTA_AV_PSC_DEALY_RPT;
1279 }
1280 (*bta_av_cb.p_cback)(BTA_AV_SNK_PSC_CFG_EVT, (tBTA_AV *)&psc_cfg);
1281 }
1282
1283
1284 AVDT_ConfigRsp(p_scb->avdt_handle, p_scb->avdt_label, p_data->ci_setconfig.err_code,
1285 p_data->ci_setconfig.category);
1286
1287 bta_sys_stop_timer(&bta_av_cb.sig_tmr);
1288
1289 if (p_data->ci_setconfig.err_code == AVDT_SUCCESS) {
1290 p_scb->wait = BTA_AV_WAIT_ACP_CAPS_ON;
1291 if (p_data->ci_setconfig.recfg_needed) {
1292 p_scb->role |= BTA_AV_ROLE_SUSPEND_OPT;
1293 }
1294 APPL_TRACE_DEBUG("bta_av_setconfig_rsp recfg_needed:%d role:x%x num:%d",
1295 p_data->ci_setconfig.recfg_needed, p_scb->role, num);
1296 /* callout module tells BTA the number of "good" SEPs and their SEIDs.
1297 * getcap on these SEID */
1298 p_scb->num_seps = num;
1299
1300 if (p_scb->cur_psc_mask & AVDT_PSC_DELAY_RPT) {
1301 p_scb->avdt_version = AVDT_VERSION_SYNC;
1302 }
1303
1304
1305 if (p_scb->codec_type == BTA_AV_CODEC_SBC || num > 1) {
1306 /* if SBC is used by the SNK as INT, discover req is not sent in bta_av_config_ind.
1307 * call cfg_res now */
1308 /* this is called in A2DP SRC path only, In case of SINK we don't need it */
1309 if (local_sep == AVDT_TSEP_SRC) {
1310 p_scb->p_cos->cfg_res(p_scb->hndl, num, num, 0, p_scb->peer_addr,
1311 UUID_SERVCLASS_AUDIO_SOURCE);
1312 }
1313 } else {
1314 /* we do not know the peer device and it is using non-SBC codec
1315 * we need to know all the SEPs on SNK */
1316 bta_av_discover_req(p_scb, NULL);
1317 return;
1318 }
1319
1320 for (i = 1; i < num; i++) {
1321 APPL_TRACE_DEBUG("sep_info[%d] SEID: %d", i, p_seid[i - 1]);
1322 /* initialize the sep_info[] to get capabilities */
1323 p_scb->sep_info[i].in_use = FALSE;
1324 p_scb->sep_info[i].tsep = AVDT_TSEP_SNK;
1325 p_scb->sep_info[i].media_type = p_scb->media_type;
1326 p_scb->sep_info[i].seid = p_seid[i - 1];
1327 }
1328
1329 /* only in case of local sep as SRC we need to look for other SEPs, In case of SINK we don't */
1330 if (local_sep == AVDT_TSEP_SRC) {
1331 /* Make sure UUID has been initialized... */
1332 if (p_scb->uuid_int == 0) {
1333 p_scb->uuid_int = p_scb->open_api.uuid;
1334 }
1335 bta_av_next_getcap(p_scb, p_data);
1336 }
1337 }
1338 }
1339
1340 /*******************************************************************************
1341 **
1342 ** Function bta_av_str_opened
1343 **
1344 ** Description Stream opened OK (incoming/outgoing).
1345 **
1346 ** Returns void
1347 **
1348 *******************************************************************************/
bta_av_str_opened(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)1349 void bta_av_str_opened (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
1350 {
1351 tBTA_AV_CONN_CHG msg;
1352 tBTA_AV_OPEN open;
1353 UINT8 *p;
1354 UINT16 mtu;
1355
1356 msg.hdr.layer_specific = p_scb->hndl;
1357 msg.is_up = TRUE;
1358 bdcpy(msg.peer_addr, p_scb->peer_addr);
1359 p_scb->l2c_cid = AVDT_GetL2CapChannel(p_scb->avdt_handle);
1360 bta_av_conn_chg((tBTA_AV_DATA *) &msg);
1361 /* set the congestion flag, so AV would not send media packets by accident */
1362 p_scb->cong = TRUE;
1363
1364
1365 p_scb->stream_mtu = p_data->str_msg.msg.open_ind.peer_mtu - AVDT_MEDIA_HDR_SIZE;
1366 mtu = bta_av_chk_mtu(p_scb, p_scb->stream_mtu);
1367 APPL_TRACE_DEBUG("bta_av_str_opened l2c_cid: 0x%x stream_mtu: %d mtu: %d",
1368 p_scb->l2c_cid, p_scb->stream_mtu, mtu);
1369 if (mtu == 0 || mtu > p_scb->stream_mtu) {
1370 mtu = p_scb->stream_mtu;
1371 }
1372
1373 /* Set the media channel as medium priority */
1374 L2CA_SetTxPriority(p_scb->l2c_cid, L2CAP_CHNL_PRIORITY_MEDIUM);
1375 L2CA_SetChnlFlushability (p_scb->l2c_cid, TRUE);
1376
1377 bta_sys_conn_open(TSEP_TO_SYS_ID(p_scb->seps[p_scb->sep_idx].tsep), p_scb->app_id, p_scb->peer_addr);
1378 memset(&p_scb->q_info, 0, sizeof(tBTA_AV_Q_INFO));
1379
1380 p_scb->l2c_bufs = 0;
1381 p_scb->p_cos->open(p_scb->hndl,
1382 p_scb->codec_type, p_scb->cfg.codec_info, mtu);
1383
1384 {
1385 /* TODO check if other audio channel is open.
1386 * If yes, check if reconfig is needed
1387 * Rigt now we do not do this kind of checking.
1388 * BTA-AV is INT for 2nd audio connection.
1389 * The application needs to make sure the current codec_info is proper.
1390 * If one audio connection is open and another SNK attempts to connect to AV,
1391 * the connection will be rejected.
1392 */
1393 /* check if other audio channel is started. If yes, start */
1394 bdcpy(open.bd_addr, p_scb->peer_addr);
1395 open.chnl = p_scb->chnl;
1396 open.hndl = p_scb->hndl;
1397 open.status = BTA_AV_SUCCESS;
1398 open.starting = bta_av_chk_start(p_scb);
1399 open.edr = 0;
1400 if ( NULL != (p = BTM_ReadRemoteFeatures(p_scb->peer_addr))) {
1401 if (HCI_EDR_ACL_2MPS_SUPPORTED(p)) {
1402 open.edr |= BTA_AV_EDR_2MBPS;
1403 }
1404 if (HCI_EDR_ACL_3MPS_SUPPORTED(p)) {
1405 open.edr |= BTA_AV_EDR_3MBPS;
1406 }
1407 }
1408 #if( defined BTA_AR_INCLUDED ) && (BTA_AR_INCLUDED == TRUE)
1409 bta_ar_avdt_conn(BTA_ID_AV, open.bd_addr);
1410 #endif
1411 if (p_scb->seps[p_scb->sep_idx].tsep == AVDT_TSEP_SRC ) {
1412 open.sep = AVDT_TSEP_SNK;
1413 } else if (p_scb->seps[p_scb->sep_idx].tsep == AVDT_TSEP_SNK ) {
1414 open.sep = AVDT_TSEP_SRC;
1415 }
1416
1417 (*bta_av_cb.p_cback)(BTA_AV_OPEN_EVT, (tBTA_AV *) &open);
1418 if (open.starting) {
1419 bta_av_ssm_execute(p_scb, BTA_AV_AP_START_EVT, NULL);
1420 }
1421 }
1422
1423 #if A2D_SRC_BQB_INCLUDED
1424 s_avdt_bqb_handle = p_scb->avdt_handle;
1425 #endif /* A2D_SRC_BQB_INCLUDED */
1426
1427 #if 0 /* TODO: implement the property enable/disable */
1428 // This code is used to pass PTS TC for AVDTP ABORT
1429 char value[PROPERTY_VALUE_MAX] = {0};
1430 if ((property_get("bluetooth.pts.force_a2dp_abort", value, "false"))
1431 && (!strcmp(value, "true"))) {
1432 APPL_TRACE_ERROR ("%s: Calling AVDT_AbortReq", __func__);
1433 AVDT_AbortReq(p_scb->avdt_handle);
1434 }
1435 #endif /* #if 0*/
1436 }
1437
1438 /*******************************************************************************
1439 **
1440 ** Function avdt_bqb_abort
1441 **
1442 ** Description Send AVDT abort request for BQB test
1443 **
1444 ** Returns void
1445 **
1446 *******************************************************************************/
1447 #if A2D_SRC_BQB_INCLUDED
avdt_bqb_abort(void)1448 void avdt_bqb_abort(void)
1449 {
1450 AVDT_AbortReq(s_avdt_bqb_handle);
1451 }
1452 #endif /* A2D_SRC_BQB_INCLUDED */
1453
1454 /*******************************************************************************
1455 **
1456 ** Function bta_av_security_ind
1457 **
1458 ** Description Handle an AVDTP security indication.
1459 **
1460 ** Returns void
1461 **
1462 *******************************************************************************/
bta_av_security_ind(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)1463 void bta_av_security_ind (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
1464 {
1465 tBTA_AV_PROTECT_REQ protect_req;
1466
1467 p_scb->avdt_label = p_data->str_msg.msg.hdr.label;
1468
1469 if (bta_av_cb.features & BTA_AV_FEAT_PROTECT) {
1470 protect_req.chnl = p_scb->chnl;
1471 protect_req.hndl = p_scb->hndl;
1472 /*
1473 APPL_TRACE_EVENT("sec ind handle: x%x", protect_req.hndl);
1474 */
1475 protect_req.p_data = p_data->str_msg.msg.security_ind.p_data;
1476 protect_req.len = p_data->str_msg.msg.security_ind.len;
1477
1478 (*bta_av_cb.p_cback)(BTA_AV_PROTECT_REQ_EVT, (tBTA_AV *) &protect_req);
1479 }
1480 /* app doesn't support security indication; respond with failure */
1481 else {
1482 AVDT_SecurityRsp(p_scb->avdt_handle, p_scb->avdt_label, AVDT_ERR_NSC, NULL, 0);
1483 }
1484 }
1485
1486 /*******************************************************************************
1487 **
1488 ** Function bta_av_security_cfm
1489 **
1490 ** Description Handle an AVDTP security confirm.
1491 **
1492 ** Returns void
1493 **
1494 *******************************************************************************/
bta_av_security_cfm(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)1495 void bta_av_security_cfm (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
1496 {
1497 tBTA_AV_PROTECT_RSP protect_rsp;
1498
1499 if (bta_av_cb.features & BTA_AV_FEAT_PROTECT) {
1500 protect_rsp.chnl = p_scb->chnl;
1501 protect_rsp.hndl = p_scb->hndl;
1502 protect_rsp.p_data = p_data->str_msg.msg.security_cfm.p_data;
1503 protect_rsp.len = p_data->str_msg.msg.security_cfm.len;
1504 protect_rsp.err_code = p_data->str_msg.msg.hdr.err_code;
1505
1506 (*bta_av_cb.p_cback)(BTA_AV_PROTECT_RSP_EVT, (tBTA_AV *) &protect_rsp);
1507 }
1508 }
1509
1510 /*******************************************************************************
1511 **
1512 ** Function bta_av_do_close
1513 **
1514 ** Description Close stream.
1515 **
1516 ** Returns void
1517 **
1518 *******************************************************************************/
bta_av_do_close(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)1519 void bta_av_do_close (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
1520 {
1521 UNUSED(p_data);
1522
1523 /* stop stream if started */
1524 if (p_scb->co_started) {
1525 bta_av_str_stopped(p_scb, NULL);
1526 }
1527 bta_sys_stop_timer(&bta_av_cb.sig_tmr);
1528
1529 /* close stream */
1530 p_scb->started = FALSE;
1531
1532 /* drop the buffers queued in L2CAP */
1533 L2CA_FlushChannel (p_scb->l2c_cid, L2CAP_FLUSH_CHANS_ALL);
1534
1535 AVDT_CloseReq(p_scb->avdt_handle);
1536 /* just in case that the link is congested, link is flow controled by peer or
1537 * for whatever reason the the close request can not be sent in time.
1538 * when this timer expires, AVDT_DisconnectReq will be called to disconnect the link
1539 */
1540 bta_sys_start_timer(&p_scb->timer,
1541 (UINT16)BTA_AV_API_CLOSE_EVT,
1542 BTA_AV_CLOSE_REQ_TIME_VAL);
1543
1544 }
1545
1546 /*******************************************************************************
1547 **
1548 ** Function bta_av_connect_req
1549 **
1550 ** Description Connect AVDTP connection.
1551 **
1552 ** Returns void
1553 **
1554 *******************************************************************************/
bta_av_connect_req(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)1555 void bta_av_connect_req (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
1556 {
1557 UNUSED(p_data);
1558
1559 utl_freebuf((void **) &p_scb->p_disc_db);
1560
1561 if (p_scb->coll_mask & BTA_AV_COLL_INC_TMR) {
1562 /* SNK initiated L2C connection while SRC was doing SDP. */
1563 /* Wait until timeout to check if SNK starts signalling. */
1564 APPL_TRACE_EVENT("bta_av_connect_req: coll_mask = 0x%2X", p_scb->coll_mask);
1565 return;
1566 }
1567
1568 AVDT_ConnectReq(p_scb->peer_addr, p_scb->sec_mask, bta_av_dt_cback[p_scb->hdi]);
1569 }
1570
1571 /*******************************************************************************
1572 **
1573 ** Function bta_av_sdp_failed
1574 **
1575 ** Description Service discovery failed.
1576 **
1577 ** Returns void
1578 **
1579 *******************************************************************************/
bta_av_sdp_failed(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)1580 void bta_av_sdp_failed (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
1581 {
1582 if (!p_scb->open_status) {
1583 p_scb->open_status = BTA_AV_FAIL_SDP;
1584 }
1585
1586 utl_freebuf((void **) &p_scb->p_disc_db);
1587 bta_av_str_closed(p_scb, p_data);
1588 }
1589
1590 /*******************************************************************************
1591 **
1592 ** Function bta_av_disc_results
1593 **
1594 ** Description Handle the AVDTP discover results. Search through the
1595 ** results and find the first available stream, and get
1596 ** its capabilities.
1597 **
1598 ** Returns void
1599 **
1600 *******************************************************************************/
bta_av_disc_results(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)1601 void bta_av_disc_results (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
1602 {
1603 UINT8 num_snks = 0, num_srcs = 0, i;
1604 /* our uuid in case we initiate connection */
1605 UINT16 uuid_int = p_scb->uuid_int;
1606
1607 APPL_TRACE_DEBUG(" initiator UUID 0x%x", uuid_int);
1608 /* store number of stream endpoints returned */
1609 p_scb->num_seps = p_data->str_msg.msg.discover_cfm.num_seps;
1610
1611 UINT8 num_seps = (p_scb->num_seps < BTA_AV_NUM_SEPS) ? p_scb->num_seps : BTA_AV_NUM_SEPS;
1612 memcpy(p_scb->sep_info, p_data->str_msg.msg.discover_cfm.p_sep_info, sizeof(tAVDT_SEP_INFO) * num_seps);
1613 for (i = 0; i < p_data->str_msg.msg.discover_cfm.num_seps; i++) {
1614 APPL_TRACE_DEBUG("peer sep %d, in use %d, seid %d, media type %d, tsep %d",
1615 i,
1616 p_data->str_msg.msg.discover_cfm.p_sep_info[i].in_use,
1617 p_data->str_msg.msg.discover_cfm.p_sep_info[i].seid,
1618 p_data->str_msg.msg.discover_cfm.p_sep_info[i].media_type,
1619 p_data->str_msg.msg.discover_cfm.p_sep_info[i].tsep
1620 );
1621 }
1622 for (i = 0; i < p_scb->num_seps; i++) {
1623 /* steam not in use, is a sink, and is audio */
1624 if ((p_scb->sep_info[i].in_use == FALSE) &&
1625 (p_scb->sep_info[i].media_type == p_scb->media_type)) {
1626 if ((p_scb->sep_info[i].tsep == AVDT_TSEP_SNK) &&
1627 (uuid_int == UUID_SERVCLASS_AUDIO_SOURCE)) {
1628 num_snks++;
1629 }
1630
1631 if ((p_scb->sep_info[i].tsep == AVDT_TSEP_SRC) &&
1632 (uuid_int == UUID_SERVCLASS_AUDIO_SINK)) {
1633 num_srcs++;
1634 }
1635 APPL_TRACE_DEBUG("num srcs: %d, num_snks: %d\n", num_snks, num_srcs);
1636 }
1637 }
1638
1639 p_scb->p_cos->disc_res(p_scb->hndl, p_scb->num_seps, num_snks, num_srcs, p_scb->peer_addr,
1640 uuid_int);
1641 p_scb->num_disc_snks = num_snks;
1642 p_scb->num_disc_srcs = num_srcs;
1643
1644 /* if we got any */
1645 if (p_scb->num_seps > 0) {
1646 /* initialize index into discovery results */
1647 p_scb->sep_info_idx = 0;
1648
1649 /* get the capabilities of the first available stream */
1650 bta_av_next_getcap(p_scb, p_data);
1651 }
1652 /* else we got discover response but with no streams; we're done */
1653 else {
1654 bta_av_ssm_execute(p_scb, BTA_AV_STR_DISC_FAIL_EVT, p_data);
1655 }
1656 }
1657
1658 /*******************************************************************************
1659 **
1660 ** Function bta_av_disc_res_as_acp
1661 **
1662 ** Description Handle the AVDTP discover results. Search through the
1663 ** results and find the first available stream, and get
1664 ** its capabilities.
1665 **
1666 ** Returns void
1667 **
1668 *******************************************************************************/
bta_av_disc_res_as_acp(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)1669 void bta_av_disc_res_as_acp (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
1670 {
1671 UINT8 num_snks = 0, i;
1672
1673 /* store number of stream endpoints returned */
1674 p_scb->num_seps = p_data->str_msg.msg.discover_cfm.num_seps;
1675
1676
1677
1678 for (i = 0; i < p_scb->num_seps; i++) {
1679 /* steam is a sink, and is audio */
1680 if ((p_scb->sep_info[i].tsep == AVDT_TSEP_SNK) &&
1681 (p_scb->sep_info[i].media_type == p_scb->media_type)) {
1682 p_scb->sep_info[i].in_use = FALSE;
1683 num_snks++;
1684 }
1685 }
1686 p_scb->p_cos->disc_res(p_scb->hndl, p_scb->num_seps, num_snks, 0, p_scb->peer_addr,
1687 UUID_SERVCLASS_AUDIO_SOURCE);
1688 p_scb->num_disc_snks = num_snks;
1689 p_scb->num_disc_srcs = 0;
1690
1691 /* if we got any */
1692 if (p_scb->num_seps > 0) {
1693 /* initialize index into discovery results */
1694 p_scb->sep_info_idx = 0;
1695
1696 /* get the capabilities of the first available stream */
1697 bta_av_next_getcap(p_scb, p_data);
1698 }
1699 /* else we got discover response but with no streams; we're done */
1700 else {
1701 bta_av_ssm_execute(p_scb, BTA_AV_STR_DISC_FAIL_EVT, p_data);
1702 }
1703 }
1704
1705 /*******************************************************************************
1706 **
1707 ** Function bta_av_save_caps
1708 **
1709 ** Description report the SNK SEP capabilities to application
1710 **
1711 ** Returns void
1712 **
1713 *******************************************************************************/
bta_av_save_caps(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)1714 void bta_av_save_caps(tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
1715 {
1716 tAVDT_CFG cfg;
1717 tAVDT_SEP_INFO *p_info = &p_scb->sep_info[p_scb->sep_info_idx];
1718 UINT8 old_wait = p_scb->wait;
1719 BOOLEAN getcap_done = FALSE;
1720
1721 APPL_TRACE_DEBUG("bta_av_save_caps num_seps:%d sep_info_idx:%d wait:x%x",
1722 p_scb->num_seps, p_scb->sep_info_idx, p_scb->wait);
1723 memcpy(&cfg, p_scb->p_cap, sizeof(tAVDT_CFG));
1724 /* let application know the capability of the SNK */
1725 p_scb->p_cos->getcfg(p_scb->hndl, cfg.codec_info[BTA_AV_CODEC_TYPE_IDX],
1726 cfg.codec_info, &p_scb->sep_info_idx, p_info->seid,
1727 &cfg.num_protect, cfg.protect_info);
1728
1729 p_scb->sep_info_idx++;
1730 if (p_scb->num_seps > p_scb->sep_info_idx) {
1731 /* Some devices have seps at the end of the discover list, which is not */
1732 /* matching media type(video not audio). */
1733 /* In this case, we are done with getcap without sending another */
1734 /* request to AVDT. */
1735 if (!bta_av_next_getcap(p_scb, p_data)) {
1736 getcap_done = TRUE;
1737 }
1738 } else {
1739 getcap_done = TRUE;
1740 }
1741
1742 if (getcap_done) {
1743 /* we are done getting capabilities. restore the p_cb->sep_info_idx */
1744 p_scb->sep_info_idx = 0;
1745 p_scb->wait &= ~(BTA_AV_WAIT_ACP_CAPS_ON | BTA_AV_WAIT_ACP_CAPS_STARTED);
1746 if (old_wait & BTA_AV_WAIT_ACP_CAPS_STARTED) {
1747 bta_av_start_ok (p_scb, NULL);
1748 }
1749 }
1750 }
1751
1752 /*******************************************************************************
1753 **
1754 ** Function bta_av_set_use_rc
1755 **
1756 ** Description set to use AVRC for this stream control block.
1757 **
1758 ** Returns void
1759 **
1760 *******************************************************************************/
bta_av_set_use_rc(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)1761 void bta_av_set_use_rc (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
1762 {
1763 UNUSED(p_data);
1764
1765 p_scb->use_rc = TRUE;
1766 }
1767
1768 /*******************************************************************************
1769 **
1770 ** Function bta_av_cco_close
1771 **
1772 ** Description call close call-out function.
1773 **
1774 ** Returns void
1775 **
1776 *******************************************************************************/
bta_av_cco_close(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)1777 void bta_av_cco_close (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
1778 {
1779 UINT16 mtu;
1780 UNUSED(p_data);
1781
1782 mtu = bta_av_chk_mtu(p_scb, BTA_AV_MAX_A2DP_MTU);
1783
1784 p_scb->p_cos->close(p_scb->hndl, p_scb->codec_type, mtu);
1785 }
1786
1787 /*******************************************************************************
1788 **
1789 ** Function bta_av_open_failed
1790 **
1791 ** Description Failed to open an AVDT stream
1792 **
1793 ** Returns void
1794 **
1795 *******************************************************************************/
bta_av_open_failed(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)1796 void bta_av_open_failed (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
1797 {
1798
1799 BOOLEAN is_av_opened = FALSE;
1800 tBTA_AV_SCB *p_opened_scb = NULL;
1801 UINT8 idx;
1802 tBTA_AV_OPEN open;
1803
1804 APPL_TRACE_DEBUG("bta_av_open_failed");
1805 p_scb->open_status = BTA_AV_FAIL_STREAM;
1806 bta_av_cco_close(p_scb, p_data);
1807
1808 /* check whether there is already an opened audio or video connection with the same device */
1809 for (idx = 0; (idx < BTA_AV_NUM_STRS) && (is_av_opened == FALSE); idx++ ) {
1810 p_opened_scb = bta_av_cb.p_scb[idx];
1811 if (p_opened_scb && (p_opened_scb->state == BTA_AV_OPEN_SST) && (!bdcmp(p_opened_scb->peer_addr, p_scb->peer_addr )) ) {
1812 is_av_opened = TRUE;
1813 }
1814
1815 }
1816
1817 /* if there is already an active AV connnection with the same bd_addr,
1818 don't send disconnect req, just report the open event with BTA_AV_FAIL_GET_CAP status */
1819 if (is_av_opened == TRUE) {
1820 bdcpy(open.bd_addr, p_scb->peer_addr);
1821 open.chnl = p_scb->chnl;
1822 open.hndl = p_scb->hndl;
1823 open.status = BTA_AV_FAIL_GET_CAP;
1824 open.starting = bta_av_chk_start(p_scb);
1825 open.edr = 0;
1826 /* set the state back to initial state */
1827 bta_av_set_scb_sst_init(p_scb);
1828
1829 if (p_scb->seps[p_scb->sep_idx].tsep == AVDT_TSEP_SRC ) {
1830 open.sep = AVDT_TSEP_SNK;
1831 } else if (p_scb->seps[p_scb->sep_idx].tsep == AVDT_TSEP_SNK ) {
1832 open.sep = AVDT_TSEP_SRC;
1833 }
1834
1835 (*bta_av_cb.p_cback)(BTA_AV_OPEN_EVT, (tBTA_AV *) &open);
1836
1837 } else {
1838 AVDT_DisconnectReq(p_scb->peer_addr, bta_av_dt_cback[p_scb->hdi]);
1839 }
1840 }
1841
1842
1843 /*******************************************************************************
1844 **
1845 ** Function bta_av_getcap_results
1846 **
1847 ** Description Handle the AVDTP get capabilities results. Check the codec
1848 ** type and see if it matches ours. If it does not, get the
1849 ** capabilities of the next stream, if any.
1850 **
1851 ** Returns void
1852 **
1853 *******************************************************************************/
bta_av_getcap_results(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)1854 void bta_av_getcap_results (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
1855 {
1856 tAVDT_CFG cfg;
1857 UINT8 media_type;
1858 tAVDT_SEP_INFO *p_info = &p_scb->sep_info[p_scb->sep_info_idx];
1859 UINT16 uuid_int; /* UUID for which connection was initiatied */
1860 tBTA_AV_SNK_PSC_CFG psc_cfg = {0};
1861
1862 memcpy(&cfg, &p_scb->cfg, sizeof(tAVDT_CFG));
1863 cfg.num_codec = 1;
1864 cfg.num_protect = p_scb->p_cap->num_protect;
1865 memcpy(cfg.codec_info, p_scb->p_cap->codec_info, AVDT_CODEC_SIZE);
1866 memcpy(cfg.protect_info, p_scb->p_cap->protect_info, AVDT_PROTECT_SIZE);
1867 media_type = p_scb->p_cap->codec_info[BTA_AV_MEDIA_TYPE_IDX] >> 4;
1868
1869 APPL_TRACE_DEBUG("num_codec %d", p_scb->p_cap->num_codec);
1870 APPL_TRACE_DEBUG("media type x%x, x%x", media_type, p_scb->media_type);
1871 #if AVDT_MULTIPLEXING == TRUE
1872 APPL_TRACE_DEBUG("mux x%x, x%x", cfg.mux_mask, p_scb->p_cap->mux_mask);
1873 #endif
1874
1875 /* if codec present and we get a codec configuration */
1876 if ((p_scb->p_cap->num_codec != 0) &&
1877 (media_type == p_scb->media_type) &&
1878 (p_scb->p_cos->getcfg(p_scb->hndl, p_scb->p_cap->codec_info[BTA_AV_CODEC_TYPE_IDX],
1879 cfg.codec_info, &p_scb->sep_info_idx, p_info->seid,
1880 &cfg.num_protect, cfg.protect_info) == 0)) {
1881 #if AVDT_MULTIPLEXING == TRUE
1882 cfg.mux_mask &= p_scb->p_cap->mux_mask;
1883 APPL_TRACE_DEBUG("mux_mask used x%x", cfg.mux_mask);
1884 #endif
1885 /* save copy of codec type and configuration */
1886 p_scb->codec_type = cfg.codec_info[BTA_AV_CODEC_TYPE_IDX];
1887 memcpy(&p_scb->cfg, &cfg, sizeof(tAVDT_CFG));
1888
1889 uuid_int = p_scb->uuid_int;
1890 APPL_TRACE_DEBUG(" initiator UUID = 0x%x ", uuid_int);
1891 if (uuid_int == UUID_SERVCLASS_AUDIO_SOURCE) {
1892 bta_av_adjust_seps_idx(p_scb, bta_av_get_scb_handle(p_scb, AVDT_TSEP_SRC));
1893 } else if (uuid_int == UUID_SERVCLASS_AUDIO_SINK) {
1894 bta_av_adjust_seps_idx(p_scb, bta_av_get_scb_handle(p_scb, AVDT_TSEP_SNK));
1895 }
1896
1897 /* use only the services peer supports */
1898 cfg.psc_mask &= p_scb->p_cap->psc_mask;
1899 p_scb->cur_psc_mask = cfg.psc_mask;
1900
1901 if (uuid_int == UUID_SERVCLASS_AUDIO_SINK) {
1902 if (p_scb->seps[p_scb->sep_idx].p_app_data_cback != NULL) {
1903 APPL_TRACE_DEBUG(" Configure Deoder for Sink Connection ");
1904 p_scb->seps[p_scb->sep_idx].p_app_data_cback(BTA_AV_MEDIA_SINK_CFG_EVT,
1905 (tBTA_AV_MEDIA *)p_scb->cfg.codec_info);
1906 }
1907 if (p_scb->cur_psc_mask & AVDT_PSC_DELAY_RPT) {
1908 psc_cfg.psc_mask |= BTA_AV_PSC_DEALY_RPT;
1909 }
1910 (*bta_av_cb.p_cback)(BTA_AV_SNK_PSC_CFG_EVT, (tBTA_AV *)&psc_cfg);
1911 }
1912
1913 /* open the stream */
1914 AVDT_OpenReq(p_scb->seps[p_scb->sep_idx].av_handle, p_scb->peer_addr,
1915 p_scb->sep_info[p_scb->sep_info_idx].seid, &cfg);
1916
1917 if (!bta_av_is_rcfg_sst(p_scb)) {
1918 /* free capabilities buffer */
1919 utl_freebuf((void **) &p_scb->p_cap);
1920 }
1921 } else {
1922 /* try the next stream, if any */
1923 p_scb->sep_info_idx++;
1924 bta_av_next_getcap(p_scb, p_data);
1925 }
1926 }
1927
1928 /*******************************************************************************
1929 **
1930 ** Function bta_av_setconfig_rej
1931 **
1932 ** Description Send AVDTP set config reject.
1933 **
1934 ** Returns void
1935 **
1936 *******************************************************************************/
bta_av_setconfig_rej(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)1937 void bta_av_setconfig_rej (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
1938 {
1939 tBTA_AV_REJECT reject;
1940 UINT8 avdt_handle = p_data->ci_setconfig.avdt_handle;
1941
1942 bta_av_adjust_seps_idx(p_scb, avdt_handle);
1943 APPL_TRACE_DEBUG("bta_av_setconfig_rej: sep_idx: %d", p_scb->sep_idx);
1944 AVDT_ConfigRsp(p_scb->avdt_handle, p_scb->avdt_label, p_data->ci_setconfig.err_code, 0);
1945
1946 bdcpy(reject.bd_addr, p_data->str_msg.bd_addr);
1947 reject.hndl = p_scb->hndl;
1948 (*bta_av_cb.p_cback)(BTA_AV_REJECT_EVT, (tBTA_AV *) &reject);
1949 }
1950
1951 /*******************************************************************************
1952 **
1953 ** Function bta_av_discover_req
1954 **
1955 ** Description Send an AVDTP discover request to the peer.
1956 **
1957 ** Returns void
1958 **
1959 *******************************************************************************/
bta_av_discover_req(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)1960 void bta_av_discover_req (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
1961 {
1962 UNUSED(p_data);
1963
1964 /* send avdtp discover request */
1965
1966 AVDT_DiscoverReq(p_scb->peer_addr, p_scb->sep_info, BTA_AV_NUM_SEPS, bta_av_dt_cback[p_scb->hdi]);
1967 }
1968
1969 /*******************************************************************************
1970 **
1971 ** Function bta_av_conn_failed
1972 **
1973 ** Description AVDTP connection failed.
1974 **
1975 ** Returns void
1976 **
1977 *******************************************************************************/
bta_av_conn_failed(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)1978 void bta_av_conn_failed (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
1979 {
1980 p_scb->open_status = BTA_AV_FAIL_STREAM;
1981 bta_av_str_closed(p_scb, p_data);
1982 }
1983
1984 /*******************************************************************************
1985 **
1986 ** Function bta_av_do_start
1987 **
1988 ** Description Start stream.
1989 **
1990 ** Returns void
1991 **
1992 *******************************************************************************/
bta_av_do_start(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)1993 void bta_av_do_start (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
1994 {
1995 UINT8 policy = HCI_ENABLE_SNIFF_MODE;
1996 UINT8 cur_role;
1997
1998 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);
1999 if (bta_av_cb.sco_occupied) {
2000 bta_av_start_failed(p_scb, p_data);
2001 return;
2002 }
2003
2004 /* disallow role switch during streaming, only if we are the master role
2005 * i.e. allow role switch, if we are slave.
2006 * It would not hurt us, if the peer device wants us to be master */
2007 if ((BTM_GetRole (p_scb->peer_addr, &cur_role) == BTM_SUCCESS) &&
2008 (cur_role == BTM_ROLE_MASTER) ) {
2009 policy |= HCI_ENABLE_MASTER_SLAVE_SWITCH;
2010 }
2011
2012 bta_sys_clear_policy(BTA_ID_AV, policy, p_scb->peer_addr);
2013
2014 if ((p_scb->started == FALSE) && ((p_scb->role & BTA_AV_ROLE_START_INT) == 0)) {
2015 p_scb->role |= BTA_AV_ROLE_START_INT;
2016 bta_sys_busy(TSEP_TO_SYS_ID(p_scb->seps[p_scb->sep_idx].tsep), bta_av_cb.audio_open_cnt, p_scb->peer_addr);
2017 AVDT_StartReq(&p_scb->avdt_handle, 1);
2018 } else if (p_scb->started) {
2019 p_scb->role |= BTA_AV_ROLE_START_INT;
2020 if ( p_scb->wait == 0 ) {
2021 if (p_scb->role & BTA_AV_ROLE_SUSPEND) {
2022 notify_start_failed(p_scb);
2023 } else {
2024 bta_av_start_ok(p_scb, NULL);
2025 }
2026 }
2027 }
2028 APPL_TRACE_DEBUG("started %d role:x%x", p_scb->started, p_scb->role);
2029 }
2030
2031 /*******************************************************************************
2032 **
2033 ** Function bta_av_str_stopped
2034 **
2035 ** Description Stream stopped.
2036 **
2037 ** Returns void
2038 **
2039 *******************************************************************************/
bta_av_str_stopped(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)2040 void bta_av_str_stopped (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
2041 {
2042 tBTA_AV_SUSPEND suspend_rsp;
2043 UINT8 start = p_scb->started;
2044 BOOLEAN sus_evt = TRUE;
2045 BT_HDR *p_buf;
2046 UINT8 policy = HCI_ENABLE_SNIFF_MODE;
2047
2048 APPL_TRACE_ERROR("bta_av_str_stopped:audio_open_cnt=%d, p_data %p",
2049 bta_av_cb.audio_open_cnt, p_data);
2050
2051 bta_sys_idle(TSEP_TO_SYS_ID(p_scb->seps[p_scb->sep_idx].tsep), bta_av_cb.audio_open_cnt, p_scb->peer_addr);
2052 if ((bta_av_cb.features & BTA_AV_FEAT_MASTER) == 0 || bta_av_cb.audio_open_cnt == 1) {
2053 policy |= HCI_ENABLE_MASTER_SLAVE_SWITCH;
2054 }
2055 bta_sys_set_policy(BTA_ID_AV, policy, p_scb->peer_addr);
2056
2057 if (p_scb->co_started) {
2058 bta_av_stream_chg(p_scb, FALSE);
2059 p_scb->co_started = FALSE;
2060
2061 p_scb->p_cos->stop(p_scb->hndl, p_scb->codec_type);
2062 L2CA_SetFlushTimeout(p_scb->peer_addr, L2CAP_DEFAULT_FLUSH_TO);
2063 }
2064
2065 /* if q_info.a2d_list is not empty, drop it now */
2066 if (BTA_AV_CHNL_AUDIO == p_scb->chnl) {
2067 while (!list_is_empty(p_scb->a2d_list)) {
2068 p_buf = (BT_HDR *)list_front(p_scb->a2d_list);
2069 list_remove(p_scb->a2d_list, p_buf);
2070 osi_free(p_buf);
2071 }
2072
2073 /* drop the audio buffers queued in L2CAP */
2074 if (p_data && p_data->api_stop.flush) {
2075 L2CA_FlushChannel (p_scb->l2c_cid, L2CAP_FLUSH_CHANS_ALL);
2076 }
2077 }
2078
2079 suspend_rsp.chnl = p_scb->chnl;
2080 suspend_rsp.hndl = p_scb->hndl;
2081
2082 if (p_data && p_data->api_stop.suspend) {
2083 APPL_TRACE_DEBUG("suspending: %d, sup:%d", start, p_scb->suspend_sup);
2084 if ((start) && (p_scb->suspend_sup)) {
2085 sus_evt = FALSE;
2086 p_scb->l2c_bufs = 0;
2087 AVDT_SuspendReq(&p_scb->avdt_handle, 1);
2088 }
2089
2090 /* send SUSPEND_EVT event only if not in reconfiguring state and sus_evt is TRUE*/
2091 if ((sus_evt) && (p_scb->state != BTA_AV_RCFG_SST)) {
2092 suspend_rsp.status = BTA_AV_SUCCESS;
2093 suspend_rsp.initiator = TRUE;
2094 (*bta_av_cb.p_cback)(BTA_AV_SUSPEND_EVT, (tBTA_AV *) &suspend_rsp);
2095 }
2096 } else {
2097 suspend_rsp.status = BTA_AV_SUCCESS;
2098 suspend_rsp.initiator = TRUE;
2099 APPL_TRACE_EVENT("bta_av_str_stopped status %d", suspend_rsp.status);
2100
2101 /* send STOP_EVT event only if not in reconfiguring state */
2102 if (p_scb->state != BTA_AV_RCFG_SST) {
2103 (*bta_av_cb.p_cback)(BTA_AV_STOP_EVT, (tBTA_AV *) &suspend_rsp);
2104 }
2105 }
2106 }
2107
2108 /*******************************************************************************
2109 **
2110 ** Function bta_av_reconfig
2111 **
2112 ** Description process the reconfigure request.
2113 ** save the parameter in control block and
2114 ** suspend, reconfigure or close the stream
2115 **
2116 ** Returns void
2117 **
2118 *******************************************************************************/
bta_av_reconfig(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)2119 void bta_av_reconfig (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
2120 {
2121 tAVDT_CFG *p_cfg;
2122 tBTA_AV_API_STOP stop;
2123 tBTA_AV_RECONFIG evt;
2124 tBTA_AV_API_RCFG *p_rcfg = &p_data->api_reconfig;
2125
2126 APPL_TRACE_DEBUG("bta_av_reconfig r:%d, s:%d idx: %d (o:%d)",
2127 p_scb->recfg_sup, p_scb->suspend_sup,
2128 p_scb->rcfg_idx, p_scb->sep_info_idx);
2129
2130 p_scb->num_recfg = 0;
2131 /* store the new configuration in control block */
2132 if (p_scb->p_cap == NULL) {
2133 p_scb->p_cap = (tAVDT_CFG *) osi_malloc(sizeof(tAVDT_CFG));
2134 }
2135 if ((p_cfg = p_scb->p_cap) == NULL) {
2136 /* report failure */
2137 evt.status = BTA_AV_FAIL_RESOURCES;
2138 evt.chnl = p_scb->chnl;
2139 evt.hndl = p_scb->hndl;
2140 (*bta_av_cb.p_cback)(BTA_AV_RECONFIG_EVT, (tBTA_AV *)&evt);
2141
2142 /* this event is not possible in this state.
2143 * use it to bring the SSM back to open state */
2144 bta_av_ssm_execute(p_scb, BTA_AV_SDP_DISC_OK_EVT, NULL);
2145 return;
2146 }
2147
2148 /*if(bta_av_cb.features & BTA_AV_FEAT_RCCT)*/
2149 bta_sys_stop_timer(&p_scb->timer);
2150
2151 memcpy(p_cfg, &p_scb->cfg, sizeof(tAVDT_CFG));
2152 p_cfg->num_protect = p_rcfg->num_protect;
2153 memcpy(p_cfg->codec_info, p_rcfg->codec_info, AVDT_CODEC_SIZE);
2154 memcpy(p_cfg->protect_info, p_rcfg->p_protect_info, p_rcfg->num_protect);
2155 p_scb->rcfg_idx = p_rcfg->sep_info_idx;
2156 p_scb->p_cap->psc_mask = p_scb->cur_psc_mask;
2157
2158 /* if the requested index differs from the current one, we can only close/open */
2159 if ((p_scb->rcfg_idx == p_scb->sep_info_idx) &&
2160 (p_rcfg->suspend) && (p_scb->recfg_sup) && (p_scb->suspend_sup)) {
2161 if (p_scb->started) {
2162 stop.flush = FALSE;
2163 stop.suspend = TRUE;
2164 bta_av_str_stopped(p_scb, (tBTA_AV_DATA *)&stop);
2165 } else {
2166 APPL_TRACE_DEBUG("Reconfig");
2167 AVDT_ReconfigReq(p_scb->avdt_handle, p_scb->p_cap);
2168 p_scb->p_cap->psc_mask = p_scb->cur_psc_mask;
2169 }
2170 } else {
2171 /* close the stream */
2172 APPL_TRACE_DEBUG("close/open num_protect: %d", p_cfg->num_protect);
2173 if (p_scb->started) {
2174 bta_av_str_stopped(p_scb, NULL);
2175 p_scb->started = FALSE;
2176
2177 /* drop the buffers queued in L2CAP */
2178 L2CA_FlushChannel (p_scb->l2c_cid, L2CAP_FLUSH_CHANS_ALL);
2179
2180 AVDT_CloseReq(p_scb->avdt_handle);
2181 }
2182 }
2183 }
2184
2185 /*******************************************************************************
2186 **
2187 ** Function bta_av_data_path
2188 **
2189 ** Description Handle stream data path.
2190 **
2191 ** Returns void
2192 **
2193 *******************************************************************************/
bta_av_data_path(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)2194 void bta_av_data_path (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
2195 {
2196 BT_HDR *p_buf = NULL;
2197 UINT32 data_len;
2198 UINT32 timestamp;
2199 BOOLEAN new_buf = FALSE;
2200 UINT8 m_pt = 0x60 | p_scb->codec_type;
2201 tAVDT_DATA_OPT_MASK opt;
2202 UNUSED(p_data);
2203
2204 if (p_scb->cong) {
2205 return;
2206 }
2207
2208 /*
2209 APPL_TRACE_ERROR("q: %d", p_scb->l2c_bufs);
2210 */
2211 //Always get the current number of bufs que'd up
2212 p_scb->l2c_bufs = (UINT8)L2CA_FlushChannel (p_scb->l2c_cid, L2CAP_FLUSH_CHANS_GET);
2213
2214 if (!list_is_empty(p_scb->a2d_list)) {
2215 p_buf = (BT_HDR *)list_front(p_scb->a2d_list);
2216 list_remove(p_scb->a2d_list, p_buf);
2217 /* use q_info.a2d data, read the timestamp */
2218 timestamp = *(UINT32 *)(p_buf + 1);
2219 } else {
2220 new_buf = TRUE;
2221 /* a2d_list empty, call co_data, dup data to other channels */
2222 p_buf = (BT_HDR *)p_scb->p_cos->data(p_scb->codec_type, &data_len,
2223 ×tamp);
2224
2225 if (p_buf) {
2226 /* use the offset area for the time stamp */
2227 *(UINT32 *)(p_buf + 1) = timestamp;
2228
2229 /* dup the data to other channels */
2230 bta_av_dup_audio_buf(p_scb, p_buf);
2231 }
2232 }
2233
2234 if (p_buf) {
2235 if (p_scb->l2c_bufs < (BTA_AV_QUEUE_DATA_CHK_NUM)) {
2236 /* there's a buffer, just queue it to L2CAP */
2237 /* There's no need to increment it here, it is always read from L2CAP see above */
2238 /* p_scb->l2c_bufs++; */
2239 /*
2240 APPL_TRACE_ERROR("qw: %d", p_scb->l2c_bufs);
2241 */
2242
2243 /* opt is a bit mask, it could have several options set */
2244 opt = AVDT_DATA_OPT_NONE;
2245 if (p_scb->no_rtp_hdr) {
2246 opt |= AVDT_DATA_OPT_NO_RTP;
2247 }
2248
2249 AVDT_WriteReqOpt(p_scb->avdt_handle, p_buf, timestamp, m_pt, opt);
2250 p_scb->cong = TRUE;
2251 } else {
2252 /* there's a buffer, but L2CAP does not seem to be moving data */
2253 if (new_buf) {
2254 /* just got this buffer from co_data,
2255 * put it in queue */
2256 list_append(p_scb->a2d_list, p_buf);
2257 } else {
2258 /* just dequeue it from the a2d_list */
2259 if (list_length(p_scb->a2d_list) < 3) {
2260 /* put it back to the queue */
2261 list_prepend(p_scb->a2d_list, p_buf);
2262 } else {
2263 /* too many buffers in a2d_list, drop it. */
2264 bta_av_co_audio_drop(p_scb->hndl);
2265 osi_free(p_buf);
2266 }
2267 }
2268 }
2269 }
2270 }
2271
2272 /*******************************************************************************
2273 **
2274 ** Function bta_av_start_ok
2275 **
2276 ** Description Stream started.
2277 **
2278 ** Returns void
2279 **
2280 *******************************************************************************/
bta_av_start_ok(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)2281 void bta_av_start_ok (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
2282 {
2283 tBTA_AV_START start;
2284 tBTA_AV_API_STOP stop;
2285 BOOLEAN initiator = FALSE;
2286 BOOLEAN suspend = FALSE;
2287 UINT16 flush_to;
2288 UINT8 new_role = p_scb->role;
2289 BT_HDR hdr;
2290 UINT8 policy = HCI_ENABLE_SNIFF_MODE;
2291 UINT8 cur_role;
2292
2293 APPL_TRACE_DEBUG("bta_av_start_ok wait:x%x, role:x%x", p_scb->wait, p_scb->role);
2294
2295 p_scb->started = TRUE;
2296 if (p_scb->sco_suspend) {
2297 p_scb->sco_suspend = FALSE;
2298 }
2299
2300 if (new_role & BTA_AV_ROLE_START_INT) {
2301 initiator = TRUE;
2302 }
2303
2304 /* for A2DP SINK we do not send get_caps */
2305 if ((p_scb->avdt_handle == p_scb->seps[p_scb->sep_idx].av_handle)
2306 && (p_scb->seps[p_scb->sep_idx].tsep == AVDT_TSEP_SNK)) {
2307 p_scb->wait &= ~(BTA_AV_WAIT_ACP_CAPS_ON);
2308 APPL_TRACE_DEBUG(" Local SEP type is SNK new wait is 0x%x", p_scb->wait);
2309 }
2310 if (p_scb->wait & BTA_AV_WAIT_ROLE_SW_FAILED) {
2311 /* role switch has failed */
2312 p_scb->wait &= ~BTA_AV_WAIT_ROLE_SW_FAILED;
2313 p_data = (tBTA_AV_DATA *)&hdr;
2314 hdr.offset = BTA_AV_RS_FAIL;
2315 }
2316 APPL_TRACE_DEBUG("wait:x%x", p_scb->wait);
2317
2318 if (p_data && (p_data->hdr.offset != BTA_AV_RS_NONE)) {
2319 p_scb->wait &= ~BTA_AV_WAIT_ROLE_SW_BITS;
2320 if (p_data->hdr.offset == BTA_AV_RS_FAIL) {
2321 bta_sys_idle(TSEP_TO_SYS_ID(p_scb->seps[p_scb->sep_idx].tsep), bta_av_cb.audio_open_cnt, p_scb->peer_addr);
2322 start.chnl = p_scb->chnl;
2323 start.status = BTA_AV_FAIL_ROLE;
2324 start.hndl = p_scb->hndl;
2325 start.initiator = initiator;
2326 (*bta_av_cb.p_cback)(BTA_AV_START_EVT, (tBTA_AV *) &start);
2327 return;
2328 }
2329 }
2330
2331 if (!bta_av_link_role_ok(p_scb, A2D_SET_ONE_BIT)) {
2332 p_scb->q_tag = BTA_AV_Q_TAG_START;
2333 } else {
2334 /* The wait flag may be set here while we are already master on the link */
2335 /* this could happen if a role switch complete event occurred during reconfig */
2336 /* if we are now master on the link, there is no need to wait for the role switch, */
2337 /* complete anymore so we can clear the wait for role switch flag */
2338 p_scb->wait &= ~BTA_AV_WAIT_ROLE_SW_BITS;
2339 }
2340
2341 if (p_scb->wait & (BTA_AV_WAIT_ROLE_SW_RES_OPEN | BTA_AV_WAIT_ROLE_SW_RES_START)) {
2342 p_scb->wait |= BTA_AV_WAIT_ROLE_SW_STARTED;
2343 p_scb->q_tag = BTA_AV_Q_TAG_START;
2344 }
2345
2346 if (p_scb->wait) {
2347 APPL_TRACE_ERROR("wait:x%x q_tag:%d- not started", p_scb->wait, p_scb->q_tag);
2348 /* Clear first bit of p_scb->wait and not to return from this point else
2349 * HAL layer gets blocked. And if there is delay in Get Capability response as
2350 * first bit of p_scb->wait is cleared hence it ensures bt_av_start_ok is not called
2351 * again from bta_av_save_caps.
2352 */
2353 p_scb->wait &= ~BTA_AV_WAIT_ACP_CAPS_ON;
2354 }
2355
2356 /* tell role manager to check M/S role */
2357 bta_sys_conn_open(TSEP_TO_SYS_ID(p_scb->seps[p_scb->sep_idx].tsep), p_scb->app_id, p_scb->peer_addr);
2358
2359 bta_sys_busy(TSEP_TO_SYS_ID(p_scb->seps[p_scb->sep_idx].tsep), bta_av_cb.audio_open_cnt, p_scb->peer_addr);
2360
2361 if (p_scb->media_type == AVDT_MEDIA_AUDIO) {
2362 /* in normal logic, conns should be bta_av_cb.audio_count - 1,
2363 * However, bta_av_stream_chg is not called to increase bta_av_cb.audio_count yet.
2364 * If the code were to be re-arranged for some reasons, this number may need to be changed
2365 */
2366 p_scb->co_started = bta_av_cb.audio_open_cnt;
2367 flush_to = p_bta_av_cfg->p_audio_flush_to[p_scb->co_started - 1];
2368 } else {
2369 flush_to = p_bta_av_cfg->video_flush_to;
2370 }
2371 L2CA_SetFlushTimeout(p_scb->peer_addr, flush_to );
2372
2373 /* clear the congestion flag */
2374 p_scb->cong = FALSE;
2375
2376 if (new_role & BTA_AV_ROLE_START_INT) {
2377 new_role &= ~BTA_AV_ROLE_START_INT;
2378 } else if ((new_role & BTA_AV_ROLE_AD_ACP) && (new_role & BTA_AV_ROLE_SUSPEND_OPT)) {
2379 suspend = TRUE;
2380 }
2381
2382 if (!suspend) {
2383 p_scb->q_tag = BTA_AV_Q_TAG_STREAM;
2384 bta_av_stream_chg(p_scb, TRUE);
2385 }
2386
2387 {
2388 /* If sink starts stream, disable sniff mode here */
2389 if (!initiator) {
2390 /* If souce is the master role, disable role switch during streaming.
2391 * Otherwise allow role switch, if source is slave.
2392 * Because it would not hurt source, if the peer device wants source to be master */
2393 if ((BTM_GetRole (p_scb->peer_addr, &cur_role) == BTM_SUCCESS) &&
2394 (cur_role == BTM_ROLE_MASTER) ) {
2395 policy |= HCI_ENABLE_MASTER_SLAVE_SWITCH;
2396 }
2397
2398 bta_sys_clear_policy(BTA_ID_AV, policy, p_scb->peer_addr);
2399 }
2400
2401 p_scb->role = new_role;
2402 p_scb->role &= ~BTA_AV_ROLE_AD_ACP;
2403 p_scb->role &= ~BTA_AV_ROLE_SUSPEND_OPT;
2404
2405 p_scb->no_rtp_hdr = FALSE;
2406 p_scb->p_cos->start(p_scb->hndl, p_scb->codec_type, p_scb->cfg.codec_info, &p_scb->no_rtp_hdr);
2407 p_scb->co_started = TRUE;
2408
2409 APPL_TRACE_DEBUG("bta_av_start_ok suspending: %d, role:x%x, init %d",
2410 suspend, p_scb->role, initiator);
2411
2412 start.suspending = suspend;
2413 start.initiator = initiator;
2414 start.chnl = p_scb->chnl;
2415 start.status = BTA_AV_SUCCESS;
2416 start.hndl = p_scb->hndl;
2417 (*bta_av_cb.p_cback)(BTA_AV_START_EVT, (tBTA_AV *) &start);
2418
2419 if (suspend) {
2420 p_scb->role |= BTA_AV_ROLE_SUSPEND;
2421 p_scb->cong = TRUE; /* do not allow the media data to go through */
2422 /* do not duplicate the media packets to this channel */
2423 p_scb->p_cos->stop(p_scb->hndl, p_scb->codec_type);
2424 p_scb->co_started = FALSE;
2425 stop.flush = FALSE;
2426 stop.suspend = TRUE;
2427 bta_av_ssm_execute(p_scb, BTA_AV_AP_STOP_EVT, (tBTA_AV_DATA *)&stop);
2428 }
2429 }
2430 }
2431
2432 /*******************************************************************************
2433 **
2434 ** Function bta_av_start_failed
2435 **
2436 ** Description Stream start failed.
2437 **
2438 ** Returns void
2439 **
2440 *******************************************************************************/
bta_av_start_failed(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)2441 void bta_av_start_failed (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
2442 {
2443 UNUSED(p_data);
2444
2445 if (p_scb->started == FALSE && p_scb->co_started == FALSE) {
2446 bta_sys_idle(TSEP_TO_SYS_ID(p_scb->seps[p_scb->sep_idx].tsep), bta_av_cb.audio_open_cnt, p_scb->peer_addr);
2447 notify_start_failed(p_scb);
2448 }
2449
2450 bta_sys_set_policy(BTA_ID_AV, (HCI_ENABLE_SNIFF_MODE | HCI_ENABLE_MASTER_SLAVE_SWITCH), p_scb->peer_addr);
2451 p_scb->sco_suspend = FALSE;
2452 }
2453
2454 /*******************************************************************************
2455 **
2456 ** Function bta_av_str_closed
2457 **
2458 ** Description Stream closed.
2459 **
2460 ** Returns void
2461 **
2462 *******************************************************************************/
bta_av_str_closed(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)2463 void bta_av_str_closed (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
2464 {
2465 tBTA_AV data;
2466 tBTA_AV_EVT event;
2467 UINT16 mtu;
2468 UINT8 policy = HCI_ENABLE_SNIFF_MODE;
2469
2470 if ((bta_av_cb.features & BTA_AV_FEAT_MASTER) == 0 || bta_av_cb.audio_open_cnt == 1) {
2471 policy |= HCI_ENABLE_MASTER_SLAVE_SWITCH;
2472 }
2473 bta_sys_set_policy(BTA_ID_AV, policy, p_scb->peer_addr);
2474 if (bta_av_cb.audio_open_cnt <= 1) {
2475 /* last connection - restore the allow switch flag */
2476 L2CA_SetDesireRole(L2CAP_ROLE_ALLOW_SWITCH);
2477 }
2478
2479 if (p_scb->open_status) {
2480 /* must be failure when opening the stream */
2481 bdcpy(data.open.bd_addr, p_scb->peer_addr);
2482 data.open.status = p_scb->open_status;
2483 data.open.chnl = p_scb->chnl;
2484 data.open.hndl = p_scb->hndl;
2485
2486 if (p_scb->seps[p_scb->sep_idx].tsep == AVDT_TSEP_SRC ) {
2487 data.open.sep = AVDT_TSEP_SNK;
2488 } else if (p_scb->seps[p_scb->sep_idx].tsep == AVDT_TSEP_SNK ) {
2489 data.open.sep = AVDT_TSEP_SRC;
2490 }
2491
2492 event = BTA_AV_OPEN_EVT;
2493 p_scb->open_status = BTA_AV_SUCCESS;
2494
2495 bta_sys_conn_close(TSEP_TO_SYS_ID(p_scb->seps[p_scb->sep_idx].tsep), p_scb->app_id, p_scb->peer_addr);
2496
2497 bta_av_cleanup(p_scb, p_data);
2498 (*bta_av_cb.p_cback)(event, &data);
2499 } else {
2500 /* do stop if we were started */
2501 if (p_scb->co_started) {
2502 bta_av_str_stopped(p_scb, NULL);
2503 }
2504
2505 /* Update common mtu shared by remaining connectons */
2506 mtu = bta_av_chk_mtu(p_scb, BTA_AV_MAX_A2DP_MTU);
2507
2508 {
2509 p_scb->p_cos->close(p_scb->hndl, p_scb->codec_type, mtu);
2510 data.close.chnl = p_scb->chnl;
2511 data.close.hndl = p_scb->hndl;
2512 data.close.disc_rsn = p_scb->disc_rsn;
2513 event = BTA_AV_CLOSE_EVT;
2514
2515 bta_sys_conn_close(TSEP_TO_SYS_ID(p_scb->seps[p_scb->sep_idx].tsep), p_scb->app_id, p_scb->peer_addr);
2516
2517 bta_av_cleanup(p_scb, p_data);
2518 (*bta_av_cb.p_cback)(event, &data);
2519 }
2520 }
2521 }
2522
2523 /*******************************************************************************
2524 **
2525 ** Function bta_av_clr_cong
2526 **
2527 ** Description Clear stream congestion flag.
2528 **
2529 ** Returns void
2530 **
2531 *******************************************************************************/
bta_av_clr_cong(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)2532 void bta_av_clr_cong (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
2533 {
2534 UNUSED(p_data);
2535
2536 if (p_scb->co_started) {
2537 p_scb->cong = FALSE;
2538 }
2539 }
2540
2541 /*******************************************************************************
2542 **
2543 ** Function bta_av_suspend_cfm
2544 **
2545 ** Description process the suspend response
2546 **
2547 ** Returns void
2548 **
2549 *******************************************************************************/
bta_av_suspend_cfm(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)2550 void bta_av_suspend_cfm (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
2551 {
2552 tBTA_AV_SUSPEND suspend_rsp;
2553 UINT8 err_code = p_data->str_msg.msg.hdr.err_code;
2554 UINT8 policy = HCI_ENABLE_SNIFF_MODE;
2555
2556 APPL_TRACE_DEBUG ("bta_av_suspend_cfm:audio_open_cnt = %d, err_code = %d",
2557 bta_av_cb.audio_open_cnt, err_code);
2558
2559 if (p_scb->started == FALSE) {
2560 /* handle the condition where there is a collision of SUSPEND req from either side
2561 ** Second SUSPEND req could be rejected. Do not treat this as a failure
2562 */
2563 APPL_TRACE_WARNING("bta_av_suspend_cfm: already suspended, ignore, err_code %d",
2564 err_code);
2565 return;
2566 }
2567
2568 suspend_rsp.status = BTA_AV_SUCCESS;
2569 if (err_code && (err_code != AVDT_ERR_BAD_STATE)) {
2570 /* Disable suspend feature only with explicit rejection(not with timeout) */
2571 if (err_code != AVDT_ERR_TIMEOUT) {
2572 p_scb->suspend_sup = FALSE;
2573 }
2574 suspend_rsp.status = BTA_AV_FAIL;
2575
2576 APPL_TRACE_ERROR ("bta_av_suspend_cfm: suspend failed, closing connection");
2577
2578 /* SUSPEND failed. Close connection. */
2579 bta_av_ssm_execute(p_scb, BTA_AV_API_CLOSE_EVT, NULL);
2580 } else {
2581 /* only set started to FALSE when suspend is successful */
2582 p_scb->started = FALSE;
2583 }
2584
2585 if (p_scb->role & BTA_AV_ROLE_SUSPEND) {
2586 p_scb->role &= ~BTA_AV_ROLE_SUSPEND;
2587 p_scb->cong = FALSE;
2588 }
2589
2590 bta_sys_idle(TSEP_TO_SYS_ID(p_scb->seps[p_scb->sep_idx].tsep), bta_av_cb.audio_open_cnt, p_scb->peer_addr);
2591 if ((bta_av_cb.features & BTA_AV_FEAT_MASTER) == 0 || bta_av_cb.audio_open_cnt == 1) {
2592 policy |= HCI_ENABLE_MASTER_SLAVE_SWITCH;
2593 }
2594 bta_sys_set_policy(BTA_ID_AV, policy, p_scb->peer_addr);
2595
2596 /* in case that we received suspend_ind, we may need to call co_stop here */
2597 if (p_scb->co_started) {
2598 bta_av_stream_chg(p_scb, FALSE);
2599
2600 {
2601 p_scb->co_started = FALSE;
2602 p_scb->p_cos->stop(p_scb->hndl, p_scb->codec_type);
2603 }
2604 L2CA_SetFlushTimeout(p_scb->peer_addr, L2CAP_DEFAULT_FLUSH_TO);
2605 }
2606
2607 {
2608 suspend_rsp.chnl = p_scb->chnl;
2609 suspend_rsp.hndl = p_scb->hndl;
2610 suspend_rsp.initiator = p_data->str_msg.initiator;
2611 (*bta_av_cb.p_cback)(BTA_AV_SUSPEND_EVT, (tBTA_AV *) &suspend_rsp);
2612 }
2613 }
2614
2615 /*******************************************************************************
2616 **
2617 ** Function bta_av_rcfg_str_ok
2618 **
2619 ** Description report reconfigure successful
2620 **
2621 ** Returns void
2622 **
2623 *******************************************************************************/
bta_av_rcfg_str_ok(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)2624 void bta_av_rcfg_str_ok (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
2625 {
2626 tBTA_AV_RECONFIG evt;
2627 UNUSED(p_data);
2628
2629 p_scb->l2c_cid = AVDT_GetL2CapChannel(p_scb->avdt_handle);
2630 APPL_TRACE_DEBUG("bta_av_rcfg_str_ok: l2c_cid: %d", p_scb->l2c_cid);
2631
2632 /* rc listen */
2633 bta_av_st_rc_timer(p_scb, NULL);
2634 utl_freebuf((void **)&p_scb->p_cap);
2635
2636 /* No need to keep the role bits once reconfig is done. */
2637 p_scb->role &= ~BTA_AV_ROLE_AD_ACP;
2638 p_scb->role &= ~BTA_AV_ROLE_SUSPEND_OPT;
2639 p_scb->role &= ~BTA_AV_ROLE_START_INT;
2640
2641 {
2642 /* reconfigure success */
2643 evt.status = BTA_AV_SUCCESS;
2644 evt.chnl = p_scb->chnl;
2645 evt.hndl = p_scb->hndl;
2646 (*bta_av_cb.p_cback)(BTA_AV_RECONFIG_EVT, (tBTA_AV *)&evt);
2647 }
2648 }
2649
2650 /*******************************************************************************
2651 **
2652 ** Function bta_av_rcfg_failed
2653 **
2654 ** Description process reconfigure failed
2655 **
2656 ** Returns void
2657 **
2658 *******************************************************************************/
bta_av_rcfg_failed(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)2659 void bta_av_rcfg_failed (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
2660 {
2661 tBTA_AV_RECONFIG evt;
2662
2663 APPL_TRACE_DEBUG("bta_av_rcfg_failed num_recfg: %d, conn_lcb:0x%x",
2664 p_scb->num_recfg, bta_av_cb.conn_lcb);
2665 if (p_scb->num_recfg > BTA_AV_RECONFIG_RETRY) {
2666 bta_av_cco_close(p_scb, p_data);
2667 /* report failure */
2668 evt.status = BTA_AV_FAIL_STREAM;
2669 evt.chnl = p_scb->chnl;
2670 evt.hndl = p_scb->hndl;
2671 (*bta_av_cb.p_cback)(BTA_AV_RECONFIG_EVT, (tBTA_AV *)&evt);
2672 /* go to closing state */
2673 bta_av_ssm_execute(p_scb, BTA_AV_API_CLOSE_EVT, NULL);
2674 } else {
2675 /* open failed. try again */
2676 p_scb->num_recfg++;
2677 if (bta_av_cb.conn_lcb) {
2678 AVDT_DisconnectReq(p_scb->peer_addr, bta_av_dt_cback[p_scb->hdi]);
2679 } else {
2680 bta_av_connect_req(p_scb, NULL);
2681 }
2682 }
2683 }
2684
2685 /*******************************************************************************
2686 **
2687 ** Function bta_av_rcfg_connect
2688 **
2689 ** Description stream closed. reconnect the stream
2690 **
2691 ** Returns void
2692 **
2693 *******************************************************************************/
bta_av_rcfg_connect(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)2694 void bta_av_rcfg_connect (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
2695 {
2696 UNUSED(p_data);
2697
2698 p_scb->cong = FALSE;
2699 p_scb->num_recfg++;
2700 APPL_TRACE_DEBUG("bta_av_rcfg_connect num_recfg: %d", p_scb->num_recfg);
2701 if (p_scb->num_recfg > BTA_AV_RECONFIG_RETRY) {
2702 /* let bta_av_rcfg_failed report fail */
2703 bta_av_rcfg_failed(p_scb, NULL);
2704 } else {
2705 AVDT_ConnectReq(p_scb->peer_addr, p_scb->sec_mask, bta_av_dt_cback[p_scb->hdi]);
2706 }
2707 }
2708
2709 /*******************************************************************************
2710 **
2711 ** Function bta_av_rcfg_discntd
2712 **
2713 ** Description AVDT disconnected. reconnect the stream
2714 **
2715 ** Returns void
2716 **
2717 *******************************************************************************/
bta_av_rcfg_discntd(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)2718 void bta_av_rcfg_discntd (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
2719 {
2720 tBTA_AV_RECONFIG evt;
2721 UNUSED(p_data);
2722
2723 APPL_TRACE_DEBUG("bta_av_rcfg_discntd num_recfg: %d", p_scb->num_recfg);
2724 p_scb->num_recfg++;
2725 if (p_scb->num_recfg > BTA_AV_RECONFIG_RETRY) {
2726 /* report failure */
2727 evt.status = BTA_AV_FAIL_STREAM;
2728 evt.chnl = p_scb->chnl;
2729 evt.hndl = p_scb->hndl;
2730 (*bta_av_cb.p_cback)(BTA_AV_RECONFIG_EVT, (tBTA_AV *)&evt);
2731 /* report close event & go to init state */
2732 bta_av_ssm_execute(p_scb, BTA_AV_STR_DISC_FAIL_EVT, NULL);
2733 } else {
2734 AVDT_ConnectReq(p_scb->peer_addr, p_scb->sec_mask, bta_av_dt_cback[p_scb->hdi]);
2735 }
2736 }
2737
2738 /*******************************************************************************
2739 **
2740 ** Function bta_av_suspend_cont
2741 **
2742 ** Description received the suspend response.
2743 ** continue to reconfigure the stream
2744 **
2745 ** Returns void
2746 **
2747 *******************************************************************************/
bta_av_suspend_cont(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)2748 void bta_av_suspend_cont (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
2749 {
2750 UINT8 err_code = p_data->str_msg.msg.hdr.err_code;
2751 tBTA_AV_RECONFIG evt;
2752
2753 p_scb->started = FALSE;
2754 p_scb->cong = FALSE;
2755 if (err_code) {
2756 if (AVDT_ERR_CONNECT == err_code) {
2757 /* report failure */
2758 evt.status = BTA_AV_FAIL;
2759 (*bta_av_cb.p_cback)(BTA_AV_RECONFIG_EVT, (tBTA_AV *)&evt);
2760 bta_av_ssm_execute(p_scb, BTA_AV_STR_DISC_FAIL_EVT, NULL);
2761 } else {
2762 APPL_TRACE_ERROR("suspend rejected, try close");
2763 /* Disable suspend feature only with explicit rejection(not with timeout) */
2764 if (err_code != AVDT_ERR_TIMEOUT) {
2765 p_scb->suspend_sup = FALSE;
2766 }
2767 /* drop the buffers queued in L2CAP */
2768 L2CA_FlushChannel (p_scb->l2c_cid, L2CAP_FLUSH_CHANS_ALL);
2769
2770 AVDT_CloseReq(p_scb->avdt_handle);
2771 }
2772 } else {
2773 APPL_TRACE_DEBUG("bta_av_suspend_cont calling AVDT_ReconfigReq");
2774 /* reconfig the stream */
2775
2776 AVDT_ReconfigReq(p_scb->avdt_handle, p_scb->p_cap);
2777 p_scb->p_cap->psc_mask = p_scb->cur_psc_mask;
2778 }
2779 }
2780
2781 /*******************************************************************************
2782 **
2783 ** Function bta_av_rcfg_cfm
2784 **
2785 ** Description if reconfigure is successful, report the event
2786 ** otherwise, close the stream.
2787 **
2788 ** Returns void
2789 **
2790 *******************************************************************************/
bta_av_rcfg_cfm(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)2791 void bta_av_rcfg_cfm (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
2792 {
2793 UINT8 err_code = p_data->str_msg.msg.hdr.err_code;
2794
2795 /*
2796 APPL_TRACE_DEBUG("bta_av_rcfg_cfm");
2797 */
2798 if (err_code) {
2799 APPL_TRACE_ERROR("reconfig rejected, try close");
2800 /* Disable reconfiguration feature only with explicit rejection(not with timeout) */
2801 if (err_code != AVDT_ERR_TIMEOUT) {
2802 p_scb->recfg_sup = FALSE;
2803 }
2804 /* started flag is FALSE when reconfigure command is sent */
2805 /* drop the buffers queued in L2CAP */
2806 L2CA_FlushChannel (p_scb->l2c_cid, L2CAP_FLUSH_CHANS_ALL);
2807 AVDT_CloseReq(p_scb->avdt_handle);
2808 } else {
2809 /* update the codec info after rcfg cfm */
2810 memcpy(p_scb->cfg.codec_info, p_data->str_msg.msg.reconfig_cfm.p_cfg->codec_info, AVDT_CODEC_SIZE);
2811 /* take the SSM back to OPEN state */
2812 bta_av_ssm_execute(p_scb, BTA_AV_STR_OPEN_OK_EVT, NULL);
2813 }
2814 }
2815
2816 /*******************************************************************************
2817 **
2818 ** Function bta_av_rcfg_open
2819 **
2820 ** Description AVDT is connected. open the stream with the new configuration
2821 **
2822 ** Returns void
2823 **
2824 *******************************************************************************/
bta_av_rcfg_open(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)2825 void bta_av_rcfg_open (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
2826 {
2827 UNUSED(p_data);
2828
2829 APPL_TRACE_DEBUG("bta_av_rcfg_open, num_disc_snks = %d", p_scb->num_disc_snks);
2830
2831 if (p_scb->num_disc_snks == 0) {
2832 /* Need to update call-out module so that it will be ready for discover */
2833 p_scb->p_cos->stop(p_scb->hndl, p_scb->codec_type);
2834
2835 /* send avdtp discover request */
2836 AVDT_DiscoverReq(p_scb->peer_addr, p_scb->sep_info, BTA_AV_NUM_SEPS, bta_av_dt_cback[p_scb->hdi]);
2837 } else {
2838 p_scb->codec_type = p_scb->p_cap->codec_info[BTA_AV_CODEC_TYPE_IDX];
2839 memcpy(p_scb->cfg.codec_info, p_scb->p_cap->codec_info, AVDT_CODEC_SIZE);
2840 /* we may choose to use a different SEP at reconfig.
2841 * adjust the sep_idx now */
2842 bta_av_adjust_seps_idx(p_scb, bta_av_get_scb_handle(p_scb, AVDT_TSEP_SRC));
2843
2844 /* open the stream with the new config */
2845 p_scb->sep_info_idx = p_scb->rcfg_idx;
2846 AVDT_OpenReq(p_scb->avdt_handle, p_scb->peer_addr,
2847 p_scb->sep_info[p_scb->sep_info_idx].seid, p_scb->p_cap);
2848 }
2849
2850 }
2851
2852 /*******************************************************************************
2853 **
2854 ** Function bta_av_security_rej
2855 **
2856 ** Description Send an AVDTP security reject.
2857 **
2858 ** Returns void
2859 **
2860 *******************************************************************************/
bta_av_security_rej(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)2861 void bta_av_security_rej (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
2862 {
2863 UNUSED(p_data);
2864
2865 AVDT_SecurityRsp(p_scb->avdt_handle, p_scb->avdt_label, AVDT_ERR_BAD_STATE,
2866 NULL, 0);
2867 }
2868
2869 /*******************************************************************************
2870 **
2871 ** Function bta_av_chk_2nd_start
2872 **
2873 ** Description check if this is 2nd stream and if it needs to be started.
2874 ** This function needs to be kept very similar to bta_av_chk_start
2875 **
2876 ** Returns void
2877 **
2878 *******************************************************************************/
bta_av_chk_2nd_start(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)2879 void bta_av_chk_2nd_start (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
2880 {
2881 tBTA_AV_SCB *p_scbi;
2882 int i;
2883 BOOLEAN new_started = FALSE;
2884 UNUSED(p_data);
2885
2886 if ((p_scb->chnl == BTA_AV_CHNL_AUDIO) && (bta_av_cb.audio_open_cnt >= 2)) {
2887 /* more than one audio channel is connected */
2888 if (!(p_scb->role & BTA_AV_ROLE_SUSPEND_OPT)) {
2889 /* this channel does not need to be reconfigured.
2890 * if there is other channel streaming, start the stream now */
2891 for (i = 0; i < BTA_AV_NUM_STRS; i++) {
2892 p_scbi = bta_av_cb.p_scb[i];
2893 if (p_scbi && p_scbi->chnl == BTA_AV_CHNL_AUDIO && p_scbi->co_started) {
2894 if (!new_started) {
2895 /* start the new stream */
2896 new_started = TRUE;
2897 bta_av_ssm_execute(p_scb, BTA_AV_AP_START_EVT, NULL);
2898 }
2899 /* may need to update the flush timeout of this already started stream */
2900 if (p_scbi->co_started != bta_av_cb.audio_open_cnt) {
2901 p_scbi->co_started = bta_av_cb.audio_open_cnt;
2902 L2CA_SetFlushTimeout(p_scbi->peer_addr, p_bta_av_cfg->p_audio_flush_to[p_scbi->co_started - 1] );
2903 }
2904 }
2905 }
2906 }
2907 }
2908 }
2909
2910 /*******************************************************************************
2911 **
2912 ** Function bta_av_open_rc
2913 **
2914 ** Description Send a message to main SM to open RC channel.
2915 **
2916 ** Returns void
2917 **
2918 *******************************************************************************/
bta_av_open_rc(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)2919 void bta_av_open_rc (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
2920 {
2921 tBTA_AV_START start;
2922
2923 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);
2924 if ((p_scb->wait & BTA_AV_WAIT_ROLE_SW_BITS) && (p_scb->q_tag == BTA_AV_Q_TAG_START)) {
2925 /* waiting for role switch for some reason & the timer expires */
2926 if (!bta_av_link_role_ok(p_scb, A2D_SET_ONE_BIT)) {
2927 APPL_TRACE_ERROR ("failed to start streaming for role management reasons!!");
2928 bta_sys_stop_timer(&p_scb->timer);
2929 start.chnl = p_scb->chnl;
2930 start.status = BTA_AV_FAIL_ROLE;
2931 start.initiator = TRUE;
2932 start.hndl = p_scb->hndl;
2933 p_scb->wait &= ~BTA_AV_WAIT_ROLE_SW_BITS;
2934 bta_av_cb.rs_idx = 0;
2935 (*bta_av_cb.p_cback)(BTA_AV_START_EVT, (tBTA_AV *) &start);
2936 } else {
2937 /* role switch is done. continue to start streaming */
2938 bta_av_cb.rs_idx = 0;
2939 p_data->hdr.offset = BTA_AV_RS_OK;
2940 bta_av_start_ok (p_scb, p_data);
2941 }
2942 return;
2943 }
2944
2945 if (p_scb->use_rc == TRUE || (p_scb->role & BTA_AV_ROLE_AD_ACP) ) {
2946 if (bta_av_cb.disc) {
2947 /* AVRC discover db is in use */
2948 if (p_scb->rc_handle == BTA_AV_RC_HANDLE_NONE) {
2949 /* AVRC channel is not connected. delay a little bit */
2950 if ((p_scb->wait & BTA_AV_WAIT_ROLE_SW_BITS) == 0) {
2951 bta_sys_start_timer(&p_scb->timer, BTA_AV_AVRC_TIMER_EVT, BTA_AV_RC_DISC_TIME_VAL);
2952 } else {
2953 p_scb->wait |= BTA_AV_WAIT_CHECK_RC;
2954 }
2955 }
2956 } else {
2957 /* use main SM for AVRC SDP activities */
2958 bta_av_rc_disc((UINT8)(p_scb->hdi + 1));
2959 }
2960 } else {
2961 if (BTA_AV_RC_HANDLE_NONE != p_scb->rc_handle) {
2962 /* the open API said that this handle does not want a RC connection.
2963 * disconnect it now */
2964 AVRC_Close(p_scb->rc_handle);
2965 }
2966 }
2967 }
2968
2969 /*******************************************************************************
2970 **
2971 ** Function bta_av_open_at_inc
2972 **
2973 ** Description This function is called if API open is called by application
2974 ** while state-machine is at incoming state.
2975 **
2976 ** Returns void
2977 **
2978 *******************************************************************************/
bta_av_open_at_inc(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)2979 void bta_av_open_at_inc (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
2980 {
2981 tBTA_AV_API_OPEN *p_buf;
2982
2983 memcpy (&(p_scb->open_api), &(p_data->api_open), sizeof(tBTA_AV_API_OPEN));
2984
2985 if (p_scb->coll_mask & BTA_AV_COLL_INC_TMR) {
2986 p_scb->coll_mask |= BTA_AV_COLL_API_CALLED;
2987
2988 /* API open will be handled at timeout if SNK did not start signalling. */
2989 /* API open will be ignored if SNK starts signalling. */
2990 } else {
2991 /* SNK did not start signalling, API was called N seconds timeout. */
2992 /* We need to switch to INIT state and start opening connection. */
2993 p_scb->coll_mask = 0;
2994 bta_av_set_scb_sst_init (p_scb);
2995
2996 if ((p_buf = (tBTA_AV_API_OPEN *) osi_malloc(sizeof(tBTA_AV_API_OPEN))) != NULL) {
2997 memcpy(p_buf, &(p_scb->open_api), sizeof(tBTA_AV_API_OPEN));
2998 bta_sys_sendmsg(p_buf);
2999 }
3000 }
3001 }
3002
3003 /*******************************************************************************
3004 **
3005 ** Function bta_av_set_delay_value
3006 **
3007 ** Description This function is called if application layer
3008 ** call the API set_delay_value
3009 **
3010 ** Returns void
3011 **
3012 *******************************************************************************/
bta_av_set_delay_value(tBTA_AV_SCB * p_scb,tBTA_AV_DATA * p_data)3013 void bta_av_set_delay_value (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
3014 {
3015 tBTA_AV_DELAY delay = {0};
3016
3017 AVDT_SetDelayValue(p_data->api_set_delay_vlaue.delay_value);
3018 delay.delay_value = p_data->api_set_delay_vlaue.delay_value;
3019
3020 if (p_scb->state == BTA_AV_OPEN_SST) {
3021 if (AVDT_DelayReport(p_scb->avdt_handle, 0, delay.delay_value) != AVDT_SUCCESS) {
3022 delay.status = BTA_AV_FAIL;
3023 }
3024 }
3025
3026 /* call callback with set delay value event */
3027 (*bta_av_cb.p_cback)(BTA_AV_SET_DELAY_VALUE_EVT, (tBTA_AV *)&delay);
3028 }
3029
3030 #endif /* BTA_AV_INCLUDED */
3031
