1 /******************************************************************************
2 *
3 * Copyright (C) 2002-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 module contains the action functions associated with the stream
22 * control block state machine.
23 *
24 ******************************************************************************/
25
26 #include <string.h>
27 #include "data_types.h"
28 #include "bt_target.h"
29 #include "bt_utils.h"
30 #include "avdt_api.h"
31 #include "avdtc_api.h"
32 #include "avdt_int.h"
33 #include "gki.h"
34 #include "btu.h"
35
36 /* This table is used to lookup the callback event that matches a particular
37 ** state machine API request event. Note that state machine API request
38 ** events are at the beginning of the event list starting at zero, thus
39 ** allowing for this table.
40 */
41 const UINT8 avdt_scb_cback_evt[] = {
42 0, /* API_REMOVE_EVT (no event) */
43 AVDT_WRITE_CFM_EVT, /* API_WRITE_REQ_EVT */
44 0, /* API_GETCONFIG_REQ_EVT (no event) */
45 0, /* API_DELAY_RPT_REQ_EVT (no event) */
46 AVDT_OPEN_CFM_EVT, /* API_SETCONFIG_REQ_EVT */
47 AVDT_OPEN_CFM_EVT, /* API_OPEN_REQ_EVT */
48 AVDT_CLOSE_CFM_EVT, /* API_CLOSE_REQ_EVT */
49 AVDT_RECONFIG_CFM_EVT, /* API_RECONFIG_REQ_EVT */
50 AVDT_SECURITY_CFM_EVT, /* API_SECURITY_REQ_EVT */
51 0 /* API_ABORT_REQ_EVT (no event) */
52 };
53
54 /* This table is used to look up the callback event based on the signaling
55 ** role when the stream is closed.
56 */
57 const UINT8 avdt_scb_role_evt[] = {
58 AVDT_CLOSE_IND_EVT, /* AVDT_CLOSE_ACP */
59 AVDT_CLOSE_CFM_EVT, /* AVDT_CLOSE_INT */
60 AVDT_CLOSE_IND_EVT, /* AVDT_OPEN_ACP */
61 AVDT_OPEN_CFM_EVT /* AVDT_OPEN_INT */
62 };
63
64 /*******************************************************************************
65 **
66 ** Function avdt_scb_gen_ssrc
67 **
68 ** Description This function generates a SSRC number unique to the stream.
69 **
70 ** Returns SSRC value.
71 **
72 *******************************************************************************/
avdt_scb_gen_ssrc(tAVDT_SCB * p_scb)73 UINT32 avdt_scb_gen_ssrc(tAVDT_SCB *p_scb)
74 {
75 /* combine the value of the media type and codec type of the SCB */
76 return ((UINT32)(p_scb->cs.cfg.codec_info[1] | p_scb->cs.cfg.codec_info[2]));
77 }
78
79 /*******************************************************************************
80 **
81 ** Function avdt_scb_hdl_abort_cmd
82 **
83 ** Description This function sends the SCB an AVDT_SCB_API_ABORT_RSP_EVT
84 ** to initiate sending of an abort response message.
85 **
86 ** Returns Nothing.
87 **
88 *******************************************************************************/
avdt_scb_hdl_abort_cmd(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)89 void avdt_scb_hdl_abort_cmd(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
90 {
91 p_scb->role = AVDT_CLOSE_ACP;
92 avdt_scb_event(p_scb, AVDT_SCB_API_ABORT_RSP_EVT, p_data);
93 }
94
95 /*******************************************************************************
96 **
97 ** Function avdt_scb_hdl_abort_rsp
98 **
99 ** Description This function is an empty function; it serves as a
100 ** placeholder for a conformance API action function.
101 **
102 ** Returns Nothing.
103 **
104 *******************************************************************************/
avdt_scb_hdl_abort_rsp(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)105 void avdt_scb_hdl_abort_rsp(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
106 {
107 UNUSED(p_scb);
108 UNUSED(p_data);
109 return;
110 }
111
112 /*******************************************************************************
113 **
114 ** Function avdt_scb_hdl_close_cmd
115 **
116 ** Description This function sends the SCB an AVDT_SCB_API_CLOSE_RSP_EVT
117 ** to initiate sending of a close response message.
118 **
119 ** Returns Nothing.
120 **
121 *******************************************************************************/
avdt_scb_hdl_close_cmd(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)122 void avdt_scb_hdl_close_cmd(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
123 {
124 p_scb->role = AVDT_CLOSE_ACP;
125 avdt_scb_event(p_scb, AVDT_SCB_API_CLOSE_RSP_EVT, p_data);
126 }
127
128 /*******************************************************************************
129 **
130 ** Function avdt_scb_hdl_close_rsp
131 **
132 ** Description This function sets the close_code variable to the error
133 ** code returned in the close response.
134 **
135 ** Returns Nothing.
136 **
137 *******************************************************************************/
avdt_scb_hdl_close_rsp(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)138 void avdt_scb_hdl_close_rsp(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
139 {
140 p_scb->close_code = p_data->msg.hdr.err_code;
141 }
142
143 /*******************************************************************************
144 **
145 ** Function avdt_scb_hdl_getconfig_cmd
146 **
147 ** Description This function retrieves the configuration parameters of
148 ** the SCB and sends the SCB an AVDT_SCB_API_GETCONFIG_RSP_EVT
149 ** to initiate sending of a get configuration response message.
150 **
151 ** Returns Nothing.
152 **
153 *******************************************************************************/
avdt_scb_hdl_getconfig_cmd(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)154 void avdt_scb_hdl_getconfig_cmd(tAVDT_SCB *p_scb,tAVDT_SCB_EVT *p_data)
155 {
156 p_data->msg.svccap.p_cfg = &p_scb->curr_cfg;
157
158 avdt_scb_event(p_scb, AVDT_SCB_API_GETCONFIG_RSP_EVT, p_data);
159 }
160
161 /*******************************************************************************
162 **
163 ** Function avdt_scb_hdl_getconfig_rsp
164 **
165 ** Description This function is an empty function; it serves as a
166 ** placeholder for a conformance API action function.
167 **
168 ** Returns Nothing.
169 **
170 *******************************************************************************/
avdt_scb_hdl_getconfig_rsp(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)171 void avdt_scb_hdl_getconfig_rsp(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
172 {
173 UNUSED(p_scb);
174 UNUSED(p_data);
175 return;
176 }
177
178 /*******************************************************************************
179 **
180 ** Function avdt_scb_hdl_open_cmd
181 **
182 ** Description This function sends the SCB an AVDT_SCB_API_OPEN_RSP_EVT
183 ** to initiate sending of an open response message.
184 **
185 ** Returns Nothing.
186 **
187 *******************************************************************************/
avdt_scb_hdl_open_cmd(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)188 void avdt_scb_hdl_open_cmd(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
189 {
190 avdt_scb_event(p_scb, AVDT_SCB_API_OPEN_RSP_EVT, p_data);
191 }
192
193 /*******************************************************************************
194 **
195 ** Function avdt_scb_hdl_open_rej
196 **
197 ** Description This function calls the application callback function
198 ** indicating the open request has failed. It initializes
199 ** certain SCB variables and sends a AVDT_CCB_UL_CLOSE_EVT
200 ** to the CCB.
201 **
202 ** Returns Nothing.
203 **
204 *******************************************************************************/
avdt_scb_hdl_open_rej(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)205 void avdt_scb_hdl_open_rej(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
206 {
207 /* do exactly same as setconfig reject */
208 avdt_scb_hdl_setconfig_rej(p_scb, p_data);
209 }
210
211 /*******************************************************************************
212 **
213 ** Function avdt_scb_hdl_open_rsp
214 **
215 ** Description This function calls avdt_ad_open_req() to initiate
216 ** connection of the transport channel for this stream.
217 **
218 ** Returns Nothing.
219 **
220 *******************************************************************************/
avdt_scb_hdl_open_rsp(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)221 void avdt_scb_hdl_open_rsp(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
222 {
223 UNUSED(p_data);
224
225 /* initiate opening of trans channels for this SEID */
226 p_scb->role = AVDT_OPEN_INT;
227 avdt_ad_open_req(AVDT_CHAN_MEDIA, p_scb->p_ccb, p_scb, AVDT_INT);
228
229 /* start tc connect timer */
230 btu_start_timer(&p_scb->timer_entry, BTU_TTYPE_AVDT_SCB_TC, AVDT_SCB_TC_CONN_TOUT);
231 }
232
233 /*******************************************************************************
234 **
235 ** Function avdt_scb_hdl_pkt_no_frag
236 **
237 ** Description
238 **
239 ** Returns Nothing.
240 **
241 *******************************************************************************/
avdt_scb_hdl_pkt_no_frag(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)242 void avdt_scb_hdl_pkt_no_frag(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
243 {
244 UINT8 *p, *p_start;
245 UINT8 o_v, o_p, o_x, o_cc;
246 UINT8 m_pt;
247 UINT8 marker;
248 UINT16 seq;
249 UINT32 time_stamp;
250 UINT32 ssrc;
251 UINT16 offset;
252 UINT16 ex_len;
253 UINT8 pad_len = 0;
254
255 p = p_start = (UINT8 *)(p_data->p_pkt + 1) + p_data->p_pkt->offset;
256
257 /* parse media packet header */
258 AVDT_MSG_PRS_OCTET1(p, o_v, o_p, o_x, o_cc);
259 AVDT_MSG_PRS_M_PT(p, m_pt, marker);
260 BE_STREAM_TO_UINT16(seq, p);
261 BE_STREAM_TO_UINT32(time_stamp, p);
262 BE_STREAM_TO_UINT32(ssrc, p);
263
264 /* skip over any csrc's in packet */
265 p += o_cc * 4;
266
267 /* check for and skip over extension header */
268 if (o_x)
269 {
270 p += 2;
271 BE_STREAM_TO_UINT16(ex_len, p);
272 p += ex_len * 4;
273 }
274
275 /* save our new offset */
276 offset = (UINT16) (p - p_start);
277
278 /* adjust length for any padding at end of packet */
279 if (o_p)
280 {
281 /* padding length in last byte of packet */
282 pad_len = *(p_start + p_data->p_pkt->len);
283 }
284
285 /* do sanity check */
286 if ((offset > p_data->p_pkt->len) || ((pad_len + offset) > p_data->p_pkt->len))
287 {
288 AVDT_TRACE_WARNING("Got bad media packet");
289 GKI_freebuf(p_data->p_pkt);
290 }
291 /* adjust offset and length and send it up */
292 else
293 {
294 p_data->p_pkt->len -= (offset + pad_len);
295 p_data->p_pkt->offset += offset;
296
297 if (p_scb->cs.p_data_cback != NULL)
298 {
299 /* report sequence number */
300 p_data->p_pkt->layer_specific = seq;
301 (*p_scb->cs.p_data_cback)(avdt_scb_to_hdl(p_scb), p_data->p_pkt,
302 time_stamp, (UINT8)(m_pt | (marker<<7)));
303 }
304 else
305 {
306 #if AVDT_MULTIPLEXING == TRUE
307 if ((p_scb->cs.p_media_cback != NULL)
308 && (p_scb->p_media_buf != NULL)
309 && (p_scb->media_buf_len > p_data->p_pkt->len))
310 {
311 /* media buffer enough length is assigned by application. Lets use it*/
312 memcpy(p_scb->p_media_buf,(UINT8*)(p_data->p_pkt + 1) + p_data->p_pkt->offset,
313 p_data->p_pkt->len);
314 (*p_scb->cs.p_media_cback)(avdt_scb_to_hdl(p_scb),p_scb->p_media_buf,
315 p_scb->media_buf_len,time_stamp,seq,m_pt,marker);
316 }
317 #endif
318 GKI_freebuf(p_data->p_pkt);
319 }
320 }
321 }
322
323 #if AVDT_REPORTING == TRUE
324 /*******************************************************************************
325 **
326 ** Function avdt_scb_hdl_report
327 **
328 ** Description
329 **
330 ** Returns Nothing.
331 **
332 *******************************************************************************/
avdt_scb_hdl_report(tAVDT_SCB * p_scb,UINT8 * p,UINT16 len)333 UINT8 * avdt_scb_hdl_report(tAVDT_SCB *p_scb, UINT8 *p, UINT16 len)
334 {
335 UINT16 result = AVDT_SUCCESS;
336 UINT8 *p_start = p;
337 UINT32 ssrc;
338 UINT8 o_v, o_p, o_cc;
339 UINT16 pkt_len;
340 AVDT_REPORT_TYPE pt;
341 tAVDT_REPORT_DATA report, *p_rpt;
342
343 AVDT_TRACE_DEBUG( "avdt_scb_hdl_report");
344 if(p_scb->cs.p_report_cback)
345 {
346 p_rpt = &report;
347 /* parse report packet header */
348 AVDT_MSG_PRS_RPT_OCTET1(p, o_v, o_p, o_cc);
349 pt = *p++;
350 BE_STREAM_TO_UINT16(pkt_len, p);
351 BE_STREAM_TO_UINT32(ssrc, p);
352
353 switch(pt)
354 {
355 case AVDT_RTCP_PT_SR: /* the packet type - SR (Sender Report) */
356 BE_STREAM_TO_UINT32(report.sr.ntp_sec, p);
357 BE_STREAM_TO_UINT32(report.sr.ntp_frac, p);
358 BE_STREAM_TO_UINT32(report.sr.rtp_time, p);
359 BE_STREAM_TO_UINT32(report.sr.pkt_count, p);
360 BE_STREAM_TO_UINT32(report.sr.octet_count, p);
361 break;
362
363 case AVDT_RTCP_PT_RR: /* the packet type - RR (Receiver Report) */
364 report.rr.frag_lost = *p;
365 BE_STREAM_TO_UINT32(report.rr.packet_lost, p);
366 report.rr.packet_lost &= 0xFFFFFF;
367 BE_STREAM_TO_UINT32(report.rr.seq_num_rcvd, p);
368 BE_STREAM_TO_UINT32(report.rr.jitter, p);
369 BE_STREAM_TO_UINT32(report.rr.lsr, p);
370 BE_STREAM_TO_UINT32(report.rr.dlsr, p);
371 break;
372
373 case AVDT_RTCP_PT_SDES: /* the packet type - SDES (Source Description) */
374 if(*p == AVDT_RTCP_SDES_CNAME)
375 {
376 p_rpt = (tAVDT_REPORT_DATA *)(p+2);
377 }
378 else
379 {
380 AVDT_TRACE_WARNING( " - SDES SSRC=0x%08x sc=%d %d len=%d %s",
381 ssrc, o_cc, *p, *(p+1), p+2);
382 result = AVDT_BUSY;
383 }
384 break;
385
386 default:
387 AVDT_TRACE_ERROR( "Bad Report pkt - packet type: %d", pt);
388 result = AVDT_BAD_PARAMS;
389 }
390
391 if(result == AVDT_SUCCESS)
392 (*p_scb->cs.p_report_cback)(avdt_scb_to_hdl(p_scb), pt, p_rpt);
393
394 }
395 p_start += len;
396 return p_start;
397 }
398 #endif
399
400 #if AVDT_MULTIPLEXING == TRUE
401 /*******************************************************************************
402 **
403 ** Function avdt_scb_hdl_pkt_frag
404 **
405 ** Description
406 **
407 ** Returns Nothing.
408 **
409 *******************************************************************************/
avdt_scb_hdl_pkt_frag(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)410 void avdt_scb_hdl_pkt_frag(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
411 {
412 /* Fields of Adaptation Layer Header */
413 UINT8 al_tsid,al_frag,al_lcode;
414 UINT16 al_len;
415 /* media header fields */
416 UINT8 o_v, o_p, o_x, o_cc;
417 UINT8 m_pt;
418 UINT8 marker;
419 UINT16 seq;
420 UINT32 time_stamp;
421 UINT32 ssrc;
422 UINT16 ex_len;
423 UINT8 pad_len;
424 /* other variables */
425 UINT8 *p; /* current pointer */
426 UINT8 *p_end; /* end of all packet */
427 UINT8 *p_payload; /* pointer to media fragment payload in the buffer */
428 UINT32 payload_len; /* payload length */
429 UINT16 frag_len; /* fragment length */
430
431 p = (UINT8 *)(p_data->p_pkt + 1) + p_data->p_pkt->offset;
432 p_end = p + p_data->p_pkt->len;
433 /* parse all fragments */
434 while(p < p_end)
435 {
436 if (p_end - p < 4) /* length check. maximum length of AL header = 4 */
437 {
438 AVDT_TRACE_WARNING("p_end: 0x%x - p:0x%x < 4", p_end, p);
439 break;
440 }
441
442 /* parse first byte */
443 al_tsid = (*p)>>3;
444 al_frag = ( (*p) >> 2 ) & 0x01;
445 al_lcode = (*p++) & AVDT_ALH_LCODE_MASK;
446
447 /* in case of TSID=00000, a second AL header byte, before the length field,
448 ** is expected and contains the actual TSID, aligned with MSB */
449 if(al_tsid == 0)
450 al_tsid = *p++;
451
452 /* get remaining media length on base of lcode */
453 switch(al_lcode)
454 {
455 case AVDT_ALH_LCODE_NONE: /* No length field present. Take length from l2cap */
456 al_len = (UINT16)(p_end - p);
457 break;
458 case AVDT_ALH_LCODE_16BIT: /* 16 bit length field */
459 BE_STREAM_TO_UINT16(al_len, p);
460 break;
461 case AVDT_ALH_LCODE_9BITM0: /* 9 bit length field, MSB = 0, 8 LSBs in 1 octet following */
462 al_len = *p++;
463 break;
464 default: /* 9 bit length field, MSB = 1, 8 LSBs in 1 octet following */
465 al_len =(UINT16)*p++ + 0x100;
466 }
467
468 /* max fragment length */
469 frag_len = (UINT16)(p_end - p);
470 /* if it isn't last fragment */
471 if(frag_len >= al_len)
472 frag_len = al_len;
473
474 /* check TSID corresponds to config */
475 if (al_tsid != p_scb->curr_cfg.mux_tsid_media)
476 {
477 #if AVDT_REPORTING == TRUE
478 if((p_scb->curr_cfg.psc_mask & AVDT_PSC_REPORT) &&
479 (al_tsid == p_scb->curr_cfg.mux_tsid_report))
480 {
481 /* parse reporting packet */
482 p = avdt_scb_hdl_report(p_scb, p, frag_len);
483 continue;
484 }
485 else
486 #endif
487 {
488 AVDT_TRACE_WARNING("bad tsid: %d, mux_tsid_media:%d", al_tsid, p_scb->curr_cfg.mux_tsid_media);
489 break;
490 }
491 }
492 /* check are buffer for assembling and related callback set */
493 else if ((p_scb->p_media_buf == NULL) || (p_scb->cs.p_media_cback == NULL))
494 {
495 AVDT_TRACE_WARNING("NULL p_media_buf or p_media_cback");
496 break;
497 }
498
499
500 /* it is media fragment beginning */
501 if(!al_frag) /* is it first fragment of original media packet */
502 {
503 AVDT_TRACE_DEBUG("al:%d media:%d",
504 al_len, p_scb->media_buf_len);
505
506 p_scb->frag_off = 0;
507 p_scb->frag_org_len = al_len; /* total length of original media packet */
508 /* length check: minimum length of media header is 12 */
509 if (p_scb->frag_org_len < 12)
510 {
511 AVDT_TRACE_WARNING("bad al_len: %d(<12)", al_len);
512 break;
513 }
514 /* check that data fit into buffer */
515 if (al_len > p_scb->media_buf_len)
516 {
517 AVDT_TRACE_WARNING("bad al_len: %d(>%d)", al_len, p_scb->media_buf_len);
518 break;
519 }
520 /* make sure it is the last fragment in l2cap packet */
521 if (p + al_len < p_end)
522 {
523 AVDT_TRACE_WARNING("bad al_len: %d(>%d)", al_len, p_scb->media_buf_len);
524 break;
525 }
526 }
527 else
528 {
529 AVDT_TRACE_DEBUG("al:%d media:%d frag_org_len:%d frag_off:%d",
530 al_len, p_scb->media_buf_len, p_scb->frag_org_len, p_scb->frag_off);
531
532 /* check that remaining length from AL header equals to original len - length of already received fragments */
533 if(al_len != p_scb->frag_org_len - p_scb->frag_off)
534 {
535 AVDT_TRACE_WARNING("al_len:%d != (frag_org_len:%d - frag_off:%d) %d",
536 al_len, p_scb->frag_org_len, p_scb->frag_off,
537 (p_scb->frag_org_len- p_scb->frag_off));
538 break;
539 }
540
541 /* do sanity check */
542 if (p_scb->frag_off == 0)
543 {
544 AVDT_TRACE_WARNING("frag_off=0");
545 break;
546 }
547 }
548 /* do common sanity check */
549 if((p_scb->frag_org_len <= p_scb->frag_off) || (p_scb->frag_org_len >= p_scb->media_buf_len))
550 {
551 AVDT_TRACE_WARNING("common sanity frag_off:%d frag_org_len:%d media_buf_len:%d",
552 p_scb->frag_off, p_scb->frag_org_len, p_scb->media_buf_len);
553 break;
554 }
555
556 AVDT_TRACE_DEBUG("Received fragment org_len=%d off=%d al_len=%d frag_len=%d",
557 p_scb->frag_org_len, p_scb->frag_off, al_len, frag_len);
558
559 /* copy fragment into buffer */
560 memcpy(p_scb->p_media_buf + p_scb->frag_off, p, frag_len);
561 p_scb->frag_off += frag_len;
562 /* move to the next fragment */
563 p += frag_len;
564 /* if it is last fragment in original media packet then process total media pocket */
565 if(p_scb->frag_off == p_scb->frag_org_len)
566 {
567 p_payload = p_scb->p_media_buf;
568
569 /* media header */
570 AVDT_MSG_PRS_OCTET1(p_payload, o_v, o_p, o_x, o_cc);
571 AVDT_MSG_PRS_M_PT(p_payload, m_pt, marker);
572 BE_STREAM_TO_UINT16(seq, p_payload);
573 BE_STREAM_TO_UINT32(time_stamp, p_payload);
574 BE_STREAM_TO_UINT32(ssrc, p_payload);
575
576 /* skip over any csrc's in packet */
577 p_payload += o_cc * 4;
578
579 /* check for and skip over extension header */
580 if (o_x)
581 {
582 if(p_scb->p_media_buf + p_scb->frag_off - p_payload < 4)
583 {
584 AVDT_TRACE_WARNING("length check frag_off:%d p_media_buf:%d p_payload:%d",
585 p_scb->frag_off, p_scb->p_media_buf, p_payload);
586 break;/* length check */
587 }
588 p_payload += 2;
589 BE_STREAM_TO_UINT16(ex_len, p_payload);
590 p_payload += ex_len * 4;
591 }
592
593 if(p_payload >= p_scb->p_media_buf + p_scb->frag_off)
594 {
595 AVDT_TRACE_WARNING("length check2 frag_off:%d p_media_buf:%d p_payload:%d",
596 p_scb->frag_off, p_scb->p_media_buf, p_payload);
597 break;/* length check */
598 }
599
600 /* adjust length for any padding at end of packet */
601 if (o_p)
602 {
603 /* padding length in last byte of packet */
604 pad_len = *(p_scb->p_media_buf + p_scb->frag_off - 1);
605 }
606 else
607 pad_len = 0;
608 /* payload length */
609 payload_len = (UINT32)(p_scb->p_media_buf + p_scb->frag_off - pad_len - p_payload);
610
611 AVDT_TRACE_DEBUG("Received last fragment header=%d len=%d",
612 p_payload - p_scb->p_media_buf,payload_len);
613
614 /* send total media packet up */
615 if (p_scb->cs.p_media_cback != NULL)
616 {
617 (*p_scb->cs.p_media_cback)(avdt_scb_to_hdl(p_scb), p_payload,
618 payload_len, time_stamp, seq, m_pt, marker);
619 }
620 }
621 } /* while(p < p_end) */
622
623 if(p < p_end)
624 {
625 AVDT_TRACE_WARNING("*** Got bad media packet");
626 }
627 GKI_freebuf(p_data->p_pkt);
628 }
629 #endif
630
631 /*******************************************************************************
632 **
633 ** Function avdt_scb_hdl_pkt
634 **
635 ** Description
636 **
637 ** Returns Nothing.
638 **
639 *******************************************************************************/
avdt_scb_hdl_pkt(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)640 void avdt_scb_hdl_pkt(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
641 {
642 #if AVDT_REPORTING == TRUE
643 UINT8 *p;
644 #endif
645
646 #if AVDT_MULTIPLEXING == TRUE
647 /* select right function in dependance of is fragmentation supported or not */
648 if( 0 != (p_scb->curr_cfg.psc_mask & AVDT_PSC_MUX))
649 {
650 avdt_scb_hdl_pkt_frag(p_scb, p_data);
651 }
652 else
653 #endif
654 #if AVDT_REPORTING == TRUE
655 if(p_data->p_pkt->layer_specific == AVDT_CHAN_REPORT)
656 {
657 p = (UINT8 *)(p_data->p_pkt + 1) + p_data->p_pkt->offset;
658 avdt_scb_hdl_report(p_scb, p, p_data->p_pkt->len);
659 GKI_freebuf(p_data->p_pkt);
660 }
661 else
662 #endif
663 avdt_scb_hdl_pkt_no_frag(p_scb, p_data);
664 }
665
666 /*******************************************************************************
667 **
668 ** Function avdt_scb_drop_pkt
669 **
670 ** Description Drop an incoming media packet. This function is called if
671 ** a media packet is received in any state besides streaming.
672 **
673 ** Returns Nothing.
674 **
675 *******************************************************************************/
avdt_scb_drop_pkt(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)676 void avdt_scb_drop_pkt(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
677 {
678 UNUSED(p_scb);
679
680 GKI_freebuf(p_data->p_pkt);
681 AVDT_TRACE_ERROR(" avdt_scb_drop_pkt Dropped incoming media packet");
682 }
683
684 /*******************************************************************************
685 **
686 ** Function avdt_scb_hdl_reconfig_cmd
687 **
688 ** Description This function calls the application callback function
689 ** with a reconfiguration indication.
690 **
691 ** Returns Nothing.
692 **
693 *******************************************************************************/
avdt_scb_hdl_reconfig_cmd(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)694 void avdt_scb_hdl_reconfig_cmd(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
695 {
696 /* if command not supported */
697 if (p_scb->cs.nsc_mask & AVDT_NSC_RECONFIG)
698 {
699 /* send reject */
700 p_data->msg.hdr.err_code = AVDT_ERR_NSC;
701 p_data->msg.hdr.err_param = 0;
702 avdt_scb_event(p_scb, AVDT_SCB_API_RECONFIG_RSP_EVT, p_data);
703 }
704 else
705 {
706 /* store requested configuration */
707 memcpy(&p_scb->req_cfg, p_data->msg.reconfig_cmd.p_cfg, sizeof(tAVDT_CFG));
708
709 /* call application callback */
710 (*p_scb->cs.p_ctrl_cback)(avdt_scb_to_hdl(p_scb),
711 NULL,
712 AVDT_RECONFIG_IND_EVT,
713 (tAVDT_CTRL *) &p_data->msg.reconfig_cmd);
714 }
715 }
716
717 /*******************************************************************************
718 **
719 ** Function avdt_scb_hdl_reconfig_rsp
720 **
721 ** Description This function calls the application callback function
722 ** with a reconfiguration confirm.
723 **
724 ** Returns Nothing.
725 **
726 *******************************************************************************/
avdt_scb_hdl_reconfig_rsp(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)727 void avdt_scb_hdl_reconfig_rsp(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
728 {
729 if (p_data->msg.hdr.err_code == 0)
730 {
731 /* store new configuration */
732 if (p_scb->req_cfg.num_codec > 0)
733 {
734 p_scb->curr_cfg.num_codec = p_scb->req_cfg.num_codec;
735 memcpy(p_scb->curr_cfg.codec_info, p_scb->req_cfg.codec_info, AVDT_CODEC_SIZE);
736 }
737 if (p_scb->req_cfg.num_protect > 0)
738 {
739 p_scb->curr_cfg.num_protect = p_scb->req_cfg.num_protect;
740 memcpy(p_scb->curr_cfg.protect_info, p_scb->req_cfg.protect_info, AVDT_PROTECT_SIZE);
741 }
742 }
743
744 p_data->msg.svccap.p_cfg = &p_scb->curr_cfg;
745
746 /* call application callback */
747 (*p_scb->cs.p_ctrl_cback)(avdt_scb_to_hdl(p_scb),
748 NULL,
749 AVDT_RECONFIG_CFM_EVT,
750 (tAVDT_CTRL *) &p_data->msg.svccap);
751 }
752
753 /*******************************************************************************
754 **
755 ** Function avdt_scb_hdl_security_cmd
756 **
757 ** Description This function calls the application callback with a
758 ** security indication.
759 **
760 ** Returns Nothing.
761 **
762 *******************************************************************************/
avdt_scb_hdl_security_cmd(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)763 void avdt_scb_hdl_security_cmd(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
764 {
765 /* if command not supported */
766 if (p_scb->cs.nsc_mask & AVDT_NSC_SECURITY)
767 {
768 /* send reject */
769 p_data->msg.hdr.err_code = AVDT_ERR_NSC;
770 avdt_scb_event(p_scb, AVDT_SCB_API_SECURITY_RSP_EVT, p_data);
771 }
772 else
773 {
774 /* call application callback */
775 (*p_scb->cs.p_ctrl_cback)(avdt_scb_to_hdl(p_scb),
776 NULL,
777 AVDT_SECURITY_IND_EVT,
778 (tAVDT_CTRL *) &p_data->msg.security_cmd);
779 }
780 }
781
782 /*******************************************************************************
783 **
784 ** Function avdt_scb_hdl_security_rsp
785 **
786 ** Description This function calls the application callback with a
787 ** security confirm.
788 **
789 ** Returns Nothing.
790 **
791 *******************************************************************************/
avdt_scb_hdl_security_rsp(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)792 void avdt_scb_hdl_security_rsp(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
793 {
794 /* call application callback */
795 (*p_scb->cs.p_ctrl_cback)(avdt_scb_to_hdl(p_scb),
796 NULL,
797 AVDT_SECURITY_CFM_EVT,
798 (tAVDT_CTRL *) &p_data->msg.security_cmd);
799 }
800
801 /*******************************************************************************
802 **
803 ** Function avdt_scb_hdl_setconfig_cmd
804 **
805 ** Description This function marks the SCB as in use and copies the
806 ** configuration and peer SEID to the SCB. It then calls
807 ** the application callback with a configuration indication.
808 **
809 ** Returns Nothing.
810 **
811 *******************************************************************************/
avdt_scb_hdl_setconfig_cmd(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)812 void avdt_scb_hdl_setconfig_cmd(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
813 {
814 tAVDT_CFG *p_cfg;
815
816 if (!p_scb->in_use)
817 {
818 p_cfg = p_data->msg.config_cmd.p_cfg;
819 if(p_scb->cs.cfg.codec_info[AVDT_CODEC_TYPE_INDEX] == p_cfg->codec_info[AVDT_CODEC_TYPE_INDEX])
820 {
821 /* set sep as in use */
822 p_scb->in_use = TRUE;
823
824 /* copy info to scb */
825 p_scb->p_ccb = avdt_ccb_by_idx(p_data->msg.config_cmd.hdr.ccb_idx);
826 p_scb->peer_seid = p_data->msg.config_cmd.int_seid;
827 memcpy(&p_scb->req_cfg, p_cfg, sizeof(tAVDT_CFG));
828 /* call app callback */
829 (*p_scb->cs.p_ctrl_cback)(avdt_scb_to_hdl(p_scb), /* handle of scb- which is same as sep handle of bta_av_cb.p_scb*/
830 p_scb->p_ccb ? p_scb->p_ccb->peer_addr : NULL,
831 AVDT_CONFIG_IND_EVT,
832 (tAVDT_CTRL *) &p_data->msg.config_cmd);
833 }
834 else
835 {
836 p_data->msg.hdr.err_code = AVDT_ERR_UNSUP_CFG;
837 p_data->msg.hdr.err_param = 0;
838 avdt_msg_send_rej(avdt_ccb_by_idx(p_data->msg.hdr.ccb_idx),
839 p_data->msg.hdr.sig_id, &p_data->msg);
840 }
841 }
842 else
843 {
844 avdt_scb_rej_in_use(p_scb, p_data);
845 }
846 }
847
848 /*******************************************************************************
849 **
850 ** Function avdt_scb_hdl_setconfig_rej
851 **
852 ** Description This function marks the SCB as not in use and calls the
853 ** application callback with an open confirm indicating failure.
854 **
855 ** Returns Nothing.
856 **
857 *******************************************************************************/
avdt_scb_hdl_setconfig_rej(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)858 void avdt_scb_hdl_setconfig_rej(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
859 {
860 /* clear scb variables */
861 avdt_scb_clr_vars(p_scb, p_data);
862
863 /* tell ccb we're done with signaling channel */
864 avdt_ccb_event(avdt_ccb_by_idx(p_data->msg.hdr.ccb_idx), AVDT_CCB_UL_CLOSE_EVT, NULL);
865
866 /* call application callback */
867 (*p_scb->cs.p_ctrl_cback)(avdt_scb_to_hdl(p_scb),
868 NULL,
869 AVDT_OPEN_CFM_EVT,
870 (tAVDT_CTRL *) &p_data->msg.hdr);
871 }
872
873 /*******************************************************************************
874 **
875 ** Function avdt_scb_hdl_setconfig_rsp
876 **
877 ** Description This function sends the SCB an AVDT_SCB_API_OPEN_REQ_EVT
878 ** to initiate sending of an open command message.
879 **
880 ** Returns Nothing.
881 **
882 *******************************************************************************/
avdt_scb_hdl_setconfig_rsp(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)883 void avdt_scb_hdl_setconfig_rsp(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
884 {
885 tAVDT_EVT_HDR single;
886 UNUSED(p_data);
887
888 if (p_scb->p_ccb != NULL)
889 {
890 /* save configuration */
891 memcpy(&p_scb->curr_cfg, &p_scb->req_cfg, sizeof(tAVDT_CFG));
892
893 /* initiate open */
894 single.seid = p_scb->peer_seid;
895 avdt_scb_event(p_scb, AVDT_SCB_API_OPEN_REQ_EVT, (tAVDT_SCB_EVT *) &single);
896 }
897 }
898
899 /*******************************************************************************
900 **
901 ** Function avdt_scb_hdl_start_cmd
902 **
903 ** Description This function calls the application callback with a
904 ** start indication.
905 **
906 ** Returns Nothing.
907 **
908 *******************************************************************************/
avdt_scb_hdl_start_cmd(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)909 void avdt_scb_hdl_start_cmd(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
910 {
911 UNUSED(p_data);
912
913 (*p_scb->cs.p_ctrl_cback)(avdt_scb_to_hdl(p_scb),
914 p_scb->p_ccb ? p_scb->p_ccb->peer_addr : NULL,
915 AVDT_START_IND_EVT,
916 NULL);
917 }
918
919 /*******************************************************************************
920 **
921 ** Function avdt_scb_hdl_start_rsp
922 **
923 ** Description This function calls the application callback with a
924 ** start confirm.
925 **
926 ** Returns Nothing.
927 **
928 *******************************************************************************/
avdt_scb_hdl_start_rsp(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)929 void avdt_scb_hdl_start_rsp(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
930 {
931 (*p_scb->cs.p_ctrl_cback)(avdt_scb_to_hdl(p_scb),
932 p_scb->p_ccb ? p_scb->p_ccb->peer_addr : NULL,
933 AVDT_START_CFM_EVT,
934 (tAVDT_CTRL *) &p_data->msg.hdr);
935 }
936
937 /*******************************************************************************
938 **
939 ** Function avdt_scb_hdl_suspend_cmd
940 **
941 ** Description This function calls the application callback with a suspend
942 ** indication.
943 **
944 ** Returns Nothing.
945 **
946 *******************************************************************************/
avdt_scb_hdl_suspend_cmd(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)947 void avdt_scb_hdl_suspend_cmd(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
948 {
949 UNUSED(p_data);
950
951 (*p_scb->cs.p_ctrl_cback)(avdt_scb_to_hdl(p_scb),
952 p_scb->p_ccb ? p_scb->p_ccb->peer_addr : NULL,
953 AVDT_SUSPEND_IND_EVT,
954 NULL);
955 }
956
957 /*******************************************************************************
958 **
959 ** Function avdt_scb_hdl_suspend_rsp
960 **
961 ** Description This function calls the application callback with a suspend
962 ** confirm.
963 **
964 ** Returns Nothing.
965 **
966 *******************************************************************************/
avdt_scb_hdl_suspend_rsp(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)967 void avdt_scb_hdl_suspend_rsp(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
968 {
969 (*p_scb->cs.p_ctrl_cback)(avdt_scb_to_hdl(p_scb),
970 p_scb->p_ccb ? p_scb->p_ccb->peer_addr : NULL,
971 AVDT_SUSPEND_CFM_EVT,
972 (tAVDT_CTRL *) &p_data->msg.hdr);
973 }
974
975 /*******************************************************************************
976 **
977 ** Function avdt_scb_hdl_tc_close
978 **
979 ** Description This function is called when the transport channel is
980 ** closed. It marks the SCB as not in use and
981 ** initializes certain SCB parameters. It then sends
982 ** an AVDT_CCB_UL_CLOSE_EVT to the CCB if the SCB
983 ** initiated the close. It then checks to see if the SCB
984 ** is to be removed. If it is it deallocates the SCB. Finally,
985 ** it calls the application callback with a close indication.
986 **
987 ** Returns Nothing.
988 **
989 *******************************************************************************/
avdt_scb_hdl_tc_close(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)990 void avdt_scb_hdl_tc_close(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
991 {
992 UINT8 hdl = avdt_scb_to_hdl(p_scb);
993 tAVDT_CTRL_CBACK *p_ctrl_cback = p_scb->cs.p_ctrl_cback;
994 tAVDT_CTRL avdt_ctrl;
995 UINT8 event;
996 tAVDT_CCB *p_ccb = p_scb->p_ccb;
997 BD_ADDR remote_addr;
998
999
1000 memcpy (remote_addr, p_ccb->peer_addr, BD_ADDR_LEN);
1001
1002 /* set up hdr */
1003 avdt_ctrl.hdr.err_code = p_scb->close_code;
1004
1005 /* clear sep variables */
1006 avdt_scb_clr_vars(p_scb, p_data);
1007 p_scb->media_seq = 0;
1008 p_scb->cong = FALSE;
1009
1010 /* free pkt we're holding, if any */
1011 if (p_scb->p_pkt != NULL)
1012 {
1013 GKI_freebuf(p_scb->p_pkt);
1014 p_scb->p_pkt = NULL;
1015 }
1016
1017 /* stop transport channel timer */
1018 btu_stop_timer(&p_scb->timer_entry);
1019
1020 if ((p_scb->role == AVDT_CLOSE_INT) || (p_scb->role == AVDT_OPEN_INT))
1021 {
1022 /* tell ccb we're done with signaling channel */
1023 avdt_ccb_event(p_ccb, AVDT_CCB_UL_CLOSE_EVT, NULL);
1024 }
1025 event = (p_scb->role == AVDT_CLOSE_INT) ? AVDT_CLOSE_CFM_EVT : AVDT_CLOSE_IND_EVT;
1026 p_scb->role = AVDT_CLOSE_ACP;
1027
1028 if (p_scb->remove)
1029 {
1030 avdt_scb_dealloc(p_scb, NULL);
1031 }
1032
1033 /* call app callback */
1034 (*p_ctrl_cback)(hdl, remote_addr, event, &avdt_ctrl);
1035 }
1036
1037 /*******************************************************************************
1038 **
1039 ** Function avdt_scb_snd_delay_rpt_req
1040 **
1041 ** Description This function calls the application callback with a delay
1042 ** report.
1043 **
1044 ** Returns Nothing.
1045 **
1046 *******************************************************************************/
avdt_scb_snd_delay_rpt_req(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1047 void avdt_scb_snd_delay_rpt_req (tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1048 {
1049 avdt_msg_send_cmd(p_scb->p_ccb, p_scb, AVDT_SIG_DELAY_RPT, (tAVDT_MSG *) &p_data->apidelay);
1050 }
1051
1052 /*******************************************************************************
1053 **
1054 ** Function avdt_scb_hdl_delay_rpt_cmd
1055 **
1056 ** Description This function calls the application callback with a delay
1057 ** report.
1058 **
1059 ** Returns Nothing.
1060 **
1061 *******************************************************************************/
avdt_scb_hdl_delay_rpt_cmd(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1062 void avdt_scb_hdl_delay_rpt_cmd (tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1063 {
1064 (*p_scb->cs.p_ctrl_cback)(avdt_scb_to_hdl(p_scb),
1065 p_scb->p_ccb ? p_scb->p_ccb->peer_addr : NULL,
1066 AVDT_DELAY_REPORT_EVT,
1067 (tAVDT_CTRL *) &p_data->msg.hdr);
1068
1069 if (p_scb->p_ccb)
1070 avdt_msg_send_rsp(p_scb->p_ccb, AVDT_SIG_DELAY_RPT, &p_data->msg);
1071 else
1072 avdt_scb_rej_not_in_use(p_scb, p_data);
1073 }
1074
1075 /*******************************************************************************
1076 **
1077 ** Function avdt_scb_hdl_delay_rpt_rsp
1078 **
1079 ** Description This function calls the application callback with a delay
1080 ** report.
1081 **
1082 ** Returns Nothing.
1083 **
1084 *******************************************************************************/
avdt_scb_hdl_delay_rpt_rsp(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1085 void avdt_scb_hdl_delay_rpt_rsp (tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1086 {
1087 (*p_scb->cs.p_ctrl_cback)(avdt_scb_to_hdl(p_scb),
1088 p_scb->p_ccb ? p_scb->p_ccb->peer_addr : NULL,
1089 AVDT_DELAY_REPORT_CFM_EVT,
1090 (tAVDT_CTRL *) &p_data->msg.hdr);
1091 }
1092
1093 #if AVDT_REPORTING == TRUE
1094 /*******************************************************************************
1095 **
1096 ** Function avdt_scb_hdl_tc_close_sto
1097 **
1098 ** Description This function is called when a channel is closed in OPEN
1099 ** state. Check the channel type and process accordingly.
1100 **
1101 ** Returns Nothing.
1102 **
1103 *******************************************************************************/
avdt_scb_hdl_tc_close_sto(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1104 void avdt_scb_hdl_tc_close_sto(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1105 {
1106 tAVDT_CTRL avdt_ctrl;
1107 /* AVDT_CHAN_SIG does not visit this action */
1108 if(p_data && p_data->close.type != AVDT_CHAN_MEDIA)
1109 {
1110 /* it's reporting or recovery channel,
1111 * the channel close in open state means the peer does not support it */
1112 if(p_data->close.old_tc_state == AVDT_AD_ST_OPEN)
1113 {
1114 avdt_ctrl.hdr.err_code = 0;
1115 avdt_ctrl.hdr.err_param = 0;
1116 /* call app callback */
1117 (*p_scb->cs.p_ctrl_cback)(avdt_scb_to_hdl(p_scb),
1118 p_scb->p_ccb ? p_scb->p_ccb->peer_addr : NULL,
1119 AVDT_REPORT_DISCONN_EVT, &avdt_ctrl);
1120 }
1121 }
1122 else
1123 {
1124 /* must be in OPEN state. need to go back to idle */
1125 avdt_scb_event(p_scb, AVDT_SCB_MSG_ABORT_RSP_EVT, NULL);
1126 avdt_scb_hdl_tc_close(p_scb, p_data);
1127 }
1128 }
1129 #endif
1130
1131 /*******************************************************************************
1132 **
1133 ** Function avdt_scb_hdl_tc_open
1134 **
1135 ** Description This function is called when the transport channel is
1136 ** opened while in the opening state. It calls the
1137 ** application callback with an open indication or open
1138 ** confirm depending on who initiated the open procedure.
1139 **
1140 ** Returns Nothing.
1141 **
1142 *******************************************************************************/
avdt_scb_hdl_tc_open(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1143 void avdt_scb_hdl_tc_open(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1144 {
1145 UINT8 event;
1146 #if AVDT_REPORTING == TRUE
1147 UINT8 role;
1148 #endif
1149
1150 /* stop transport channel connect timer */
1151 btu_stop_timer(&p_scb->timer_entry);
1152
1153 event = (p_scb->role == AVDT_OPEN_INT) ? AVDT_OPEN_CFM_EVT : AVDT_OPEN_IND_EVT;
1154 p_data->open.hdr.err_code = 0;
1155
1156 AVDT_TRACE_DEBUG("psc_mask: cfg: 0x%x, req:0x%x, cur: 0x%x",
1157 p_scb->cs.cfg.psc_mask, p_scb->req_cfg.psc_mask, p_scb->curr_cfg.psc_mask);
1158 #if AVDT_REPORTING == TRUE
1159 if(p_scb->curr_cfg.psc_mask & AVDT_PSC_REPORT)
1160 {
1161 /* open the reporting channel, if both devices support it */
1162 role = (p_scb->role == AVDT_OPEN_INT) ? AVDT_INT : AVDT_ACP;
1163 avdt_ad_open_req(AVDT_CHAN_REPORT, p_scb->p_ccb, p_scb, role);
1164 }
1165 #endif
1166
1167 /* call app callback */
1168 (*p_scb->cs.p_ctrl_cback)(avdt_scb_to_hdl(p_scb),
1169 p_scb->p_ccb ? p_scb->p_ccb->peer_addr : NULL,
1170 event,
1171 (tAVDT_CTRL *) &p_data->open);
1172 }
1173
1174 #if AVDT_REPORTING == TRUE
1175 /*******************************************************************************
1176 **
1177 ** Function avdt_scb_hdl_tc_open_sto
1178 **
1179 ** Description This function is called when the transport channel is
1180 ** opened while in the opening state. It calls the
1181 ** application callback with an open indication or open
1182 ** confirm depending on who initiated the open procedure.
1183 **
1184 ** Returns Nothing.
1185 **
1186 *******************************************************************************/
avdt_scb_hdl_tc_open_sto(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1187 void avdt_scb_hdl_tc_open_sto(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1188 {
1189 tAVDT_CTRL avdt_ctrl;
1190 /* open reporting channel here, when it is implemented */
1191
1192 /* call app callback */
1193 if(p_data->open.hdr.err_code == AVDT_CHAN_REPORT)
1194 {
1195 avdt_ctrl.hdr.err_code = 0;
1196 avdt_ctrl.hdr.err_param = 1;
1197 (*p_scb->cs.p_ctrl_cback)(avdt_scb_to_hdl(p_scb),
1198 p_scb->p_ccb ? p_scb->p_ccb->peer_addr : NULL,
1199 AVDT_REPORT_CONN_EVT, &avdt_ctrl);
1200 }
1201 }
1202 #endif
1203
1204 /*******************************************************************************
1205 **
1206 ** Function avdt_scb_hdl_write_req_no_frag
1207 **
1208 ** Description This function frees the media packet currently stored in
1209 ** the SCB, if any. Then it builds a new media packet from
1210 ** with the passed in buffer and stores it in the SCB.
1211 **
1212 ** Returns Nothing.
1213 **
1214 *******************************************************************************/
avdt_scb_hdl_write_req_no_frag(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1215 void avdt_scb_hdl_write_req_no_frag(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1216 {
1217 UINT8 *p;
1218 UINT32 ssrc;
1219
1220 /* free packet we're holding, if any; to be replaced with new */
1221 if (p_scb->p_pkt != NULL)
1222 {
1223 GKI_freebuf(p_scb->p_pkt);
1224
1225 /* this shouldn't be happening */
1226 AVDT_TRACE_WARNING("Dropped media packet; congested");
1227 }
1228
1229 /* build a media packet */
1230 /* Add RTP header if required */
1231 if ( !(p_data->apiwrite.opt & AVDT_DATA_OPT_NO_RTP) )
1232 {
1233 ssrc = avdt_scb_gen_ssrc(p_scb);
1234
1235 p_data->apiwrite.p_buf->len += AVDT_MEDIA_HDR_SIZE;
1236 p_data->apiwrite.p_buf->offset -= AVDT_MEDIA_HDR_SIZE;
1237 p_scb->media_seq++;
1238 p = (UINT8 *)(p_data->apiwrite.p_buf + 1) + p_data->apiwrite.p_buf->offset;
1239
1240 UINT8_TO_BE_STREAM(p, AVDT_MEDIA_OCTET1);
1241 UINT8_TO_BE_STREAM(p, p_data->apiwrite.m_pt);
1242 UINT16_TO_BE_STREAM(p, p_scb->media_seq);
1243 UINT32_TO_BE_STREAM(p, p_data->apiwrite.time_stamp);
1244 UINT32_TO_BE_STREAM(p, ssrc);
1245 }
1246
1247 /* store it */
1248 p_scb->p_pkt = p_data->apiwrite.p_buf;
1249 }
1250
1251 #if AVDT_MULTIPLEXING == TRUE
1252 /*******************************************************************************
1253 **
1254 ** Function avdt_scb_hdl_write_req_frag
1255 **
1256 ** Description This function builds a new fragments of media packet from
1257 ** the passed in buffers and stores them in the SCB.
1258 **
1259 ** Returns Nothing.
1260 **
1261 *******************************************************************************/
avdt_scb_hdl_write_req_frag(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1262 void avdt_scb_hdl_write_req_frag(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1263 {
1264 UINT8 *p;
1265 UINT32 ssrc;
1266 BT_HDR *p_frag;
1267
1268 /* free fragments we're holding, if any; it shouldn't happen */
1269 if (!GKI_queue_is_empty(&p_scb->frag_q))
1270 {
1271 while((p_frag = (BT_HDR*)GKI_dequeue (&p_scb->frag_q)) != NULL)
1272 GKI_freebuf(p_frag);
1273
1274 /* this shouldn't be happening */
1275 AVDT_TRACE_WARNING("*** Dropped media packet; congested");
1276 }
1277
1278 /* build a media fragments */
1279 p_scb->frag_off = p_data->apiwrite.data_len;
1280 p_scb->p_next_frag = p_data->apiwrite.p_data;
1281
1282 ssrc = avdt_scb_gen_ssrc(p_scb);
1283
1284 /* get first packet */
1285 p_frag = (BT_HDR*)GKI_getfirst (&p_data->apiwrite.frag_q);
1286 /* posit on Adaptation Layer header */
1287 p_frag->len += AVDT_AL_HDR_SIZE + AVDT_MEDIA_HDR_SIZE;
1288 p_frag->offset -= AVDT_AL_HDR_SIZE + AVDT_MEDIA_HDR_SIZE;
1289 p = (UINT8 *)(p_frag + 1) + p_frag->offset;
1290
1291 /* Adaptation Layer header */
1292 /* TSID, no-fragment bit and coding of length(in 2 length octets following) */
1293 *p++ = (p_scb->curr_cfg.mux_tsid_media<<3) | AVDT_ALH_LCODE_16BIT;
1294
1295 /* length of all remaining transport packet */
1296 UINT16_TO_BE_STREAM(p, p_frag->layer_specific+AVDT_MEDIA_HDR_SIZE );
1297 /* media header */
1298 UINT8_TO_BE_STREAM(p, AVDT_MEDIA_OCTET1);
1299 UINT8_TO_BE_STREAM(p, p_data->apiwrite.m_pt);
1300 UINT16_TO_BE_STREAM(p, p_scb->media_seq);
1301 UINT32_TO_BE_STREAM(p, p_data->apiwrite.time_stamp);
1302 UINT32_TO_BE_STREAM(p, ssrc);
1303 p_scb->media_seq++;
1304
1305 while((p_frag = (BT_HDR*)GKI_getnext (p_frag)) != NULL)
1306 {
1307 /* posit on Adaptation Layer header */
1308 p_frag->len += AVDT_AL_HDR_SIZE;
1309 p_frag->offset -= AVDT_AL_HDR_SIZE;
1310 p = (UINT8 *)(p_frag + 1) + p_frag->offset;
1311 /* Adaptation Layer header */
1312 /* TSID, fragment bit and coding of length(in 2 length octets following) */
1313 *p++ = (p_scb->curr_cfg.mux_tsid_media<<3) | (AVDT_ALH_FRAG_MASK|AVDT_ALH_LCODE_16BIT);
1314
1315 /* length of all remaining transport packet */
1316 UINT16_TO_BE_STREAM(p, p_frag->layer_specific );
1317 }
1318
1319 /* store it */
1320 p_scb->frag_q = p_data->apiwrite.frag_q;
1321 }
1322 #endif
1323
1324
1325 /*******************************************************************************
1326 **
1327 ** Function avdt_scb_hdl_write_req
1328 **
1329 ** Description This function calls one of the two versions of building functions
1330 ** for case with and without fragmentation
1331 **
1332 ** Returns Nothing.
1333 **
1334 *******************************************************************************/
avdt_scb_hdl_write_req(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1335 void avdt_scb_hdl_write_req(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1336 {
1337 #if AVDT_MULTIPLEXING == TRUE
1338 if (GKI_queue_is_empty(&p_data->apiwrite.frag_q))
1339 #endif
1340 avdt_scb_hdl_write_req_no_frag(p_scb, p_data);
1341 #if AVDT_MULTIPLEXING == TRUE
1342 else
1343 avdt_scb_hdl_write_req_frag(p_scb, p_data);
1344 #endif
1345 }
1346
1347 /*******************************************************************************
1348 **
1349 ** Function avdt_scb_snd_abort_req
1350 **
1351 ** Description This function sends an abort command message.
1352 **
1353 ** Returns Nothing.
1354 **
1355 *******************************************************************************/
avdt_scb_snd_abort_req(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1356 void avdt_scb_snd_abort_req(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1357 {
1358 tAVDT_EVT_HDR hdr;
1359 UNUSED(p_data);
1360
1361 if (p_scb->p_ccb != NULL)
1362 {
1363 p_scb->role = AVDT_CLOSE_INT;
1364
1365 hdr.seid = p_scb->peer_seid;
1366
1367 avdt_msg_send_cmd(p_scb->p_ccb, p_scb, AVDT_SIG_ABORT, (tAVDT_MSG *) &hdr);
1368 }
1369 }
1370
1371 /*******************************************************************************
1372 **
1373 ** Function avdt_scb_snd_abort_rsp
1374 **
1375 ** Description This function sends an abort response message.
1376 **
1377 ** Returns Nothing.
1378 **
1379 *******************************************************************************/
avdt_scb_snd_abort_rsp(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1380 void avdt_scb_snd_abort_rsp(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1381 {
1382 UNUSED(p_scb);
1383
1384 avdt_msg_send_rsp(avdt_ccb_by_idx(p_data->msg.hdr.ccb_idx), AVDT_SIG_ABORT,
1385 &p_data->msg);
1386 }
1387
1388 /*******************************************************************************
1389 **
1390 ** Function avdt_scb_snd_close_req
1391 **
1392 ** Description This function sends a close command message.
1393 **
1394 ** Returns Nothing.
1395 **
1396 *******************************************************************************/
avdt_scb_snd_close_req(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1397 void avdt_scb_snd_close_req(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1398 {
1399 tAVDT_EVT_HDR hdr;
1400 UNUSED(p_data);
1401
1402 p_scb->role = AVDT_CLOSE_INT;
1403
1404 hdr.seid = p_scb->peer_seid;
1405
1406 avdt_msg_send_cmd(p_scb->p_ccb, p_scb, AVDT_SIG_CLOSE, (tAVDT_MSG *) &hdr);
1407 }
1408
1409 /*******************************************************************************
1410 **
1411 ** Function avdt_scb_snd_stream_close
1412 **
1413 ** Description This function sends a close command message.
1414 **
1415 ** Returns Nothing.
1416 **
1417 *******************************************************************************/
avdt_scb_snd_stream_close(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1418 void avdt_scb_snd_stream_close(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1419 {
1420 #if AVDT_MULTIPLEXING == TRUE
1421 BT_HDR *p_frag;
1422
1423 AVDT_TRACE_WARNING("avdt_scb_snd_stream_close c:%d, off:%d",
1424 p_scb->frag_q.count, p_scb->frag_off);
1425 /* clean fragments queue */
1426 while((p_frag = (BT_HDR*)GKI_dequeue (&p_scb->frag_q)) != NULL)
1427 GKI_freebuf(p_frag);
1428 p_scb->frag_off = 0;
1429 #endif
1430 if (p_scb->p_pkt)
1431 {
1432 GKI_freebuf(p_scb->p_pkt);
1433 p_scb->p_pkt = NULL;
1434 }
1435
1436 #if 0
1437 if(p_scb->cong)
1438 p_scb->cong = FALSE;
1439
1440 /* p_scb->curr_cfg.mux_tsid_media == 0 */
1441 #endif
1442 avdt_scb_snd_close_req(p_scb, p_data);
1443 }
1444
1445 /*******************************************************************************
1446 **
1447 ** Function avdt_scb_snd_close_rsp
1448 **
1449 ** Description This function sends a close response message.
1450 **
1451 ** Returns Nothing.
1452 **
1453 *******************************************************************************/
avdt_scb_snd_close_rsp(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1454 void avdt_scb_snd_close_rsp(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1455 {
1456 avdt_msg_send_rsp(p_scb->p_ccb, AVDT_SIG_CLOSE, &p_data->msg);
1457 }
1458
1459 /*******************************************************************************
1460 **
1461 ** Function avdt_scb_snd_getconfig_req
1462 **
1463 ** Description This function sends a get configuration command message.
1464 **
1465 ** Returns Nothing.
1466 **
1467 *******************************************************************************/
avdt_scb_snd_getconfig_req(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1468 void avdt_scb_snd_getconfig_req(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1469 {
1470 tAVDT_EVT_HDR hdr;
1471 UNUSED(p_data);
1472
1473 hdr.seid = p_scb->peer_seid;
1474
1475 avdt_msg_send_cmd(p_scb->p_ccb, p_scb, AVDT_SIG_GETCONFIG, (tAVDT_MSG *) &hdr);
1476 }
1477
1478 /*******************************************************************************
1479 **
1480 ** Function avdt_scb_snd_getconfig_rsp
1481 **
1482 ** Description This function sends a get configuration response message.
1483 **
1484 ** Returns Nothing.
1485 **
1486 *******************************************************************************/
avdt_scb_snd_getconfig_rsp(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1487 void avdt_scb_snd_getconfig_rsp(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1488 {
1489 avdt_msg_send_rsp(p_scb->p_ccb, AVDT_SIG_GETCONFIG, &p_data->msg);
1490 }
1491
1492 /*******************************************************************************
1493 **
1494 ** Function avdt_scb_snd_open_req
1495 **
1496 ** Description This function sends an open command message.
1497 **
1498 ** Returns Nothing.
1499 **
1500 *******************************************************************************/
avdt_scb_snd_open_req(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1501 void avdt_scb_snd_open_req(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1502 {
1503 tAVDT_EVT_HDR hdr;
1504 UNUSED(p_data);
1505
1506 hdr.seid = p_scb->peer_seid;
1507
1508 avdt_msg_send_cmd(p_scb->p_ccb, p_scb, AVDT_SIG_OPEN, (tAVDT_MSG *) &hdr);
1509 }
1510
1511 /*******************************************************************************
1512 **
1513 ** Function avdt_scb_snd_open_rsp
1514 **
1515 ** Description This function sends an open response message. It also
1516 ** calls avdt_ad_open_req() to accept a transport channel
1517 ** connection.
1518 **
1519 ** Returns Nothing.
1520 **
1521 *******************************************************************************/
avdt_scb_snd_open_rsp(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1522 void avdt_scb_snd_open_rsp(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1523 {
1524 /* notify adaption that we're waiting for transport channel open */
1525 p_scb->role = AVDT_OPEN_ACP;
1526 avdt_ad_open_req(AVDT_CHAN_MEDIA, p_scb->p_ccb, p_scb, AVDT_ACP);
1527
1528 /* send response */
1529 avdt_msg_send_rsp(p_scb->p_ccb, AVDT_SIG_OPEN, &p_data->msg);
1530
1531 /* start tc connect timer */
1532 btu_start_timer(&p_scb->timer_entry, BTU_TTYPE_AVDT_SCB_TC, AVDT_SCB_TC_CONN_TOUT);
1533 }
1534
1535 /*******************************************************************************
1536 **
1537 ** Function avdt_scb_snd_reconfig_req
1538 **
1539 ** Description This function stores the configuration parameters in the
1540 ** SCB and sends a reconfiguration command message.
1541 **
1542 ** Returns Nothing.
1543 **
1544 *******************************************************************************/
avdt_scb_snd_reconfig_req(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1545 void avdt_scb_snd_reconfig_req(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1546 {
1547 memcpy(&p_scb->req_cfg, p_data->msg.config_cmd.p_cfg, sizeof(tAVDT_CFG));
1548 p_data->msg.hdr.seid = p_scb->peer_seid;
1549 avdt_msg_send_cmd(p_scb->p_ccb, p_scb, AVDT_SIG_RECONFIG, &p_data->msg);
1550 }
1551
1552 /*******************************************************************************
1553 **
1554 ** Function avdt_scb_snd_reconfig_rsp
1555 **
1556 ** Description This function stores the configuration parameters in the
1557 ** SCB and sends a reconfiguration response message.
1558 **
1559 ** Returns Nothing.
1560 **
1561 *******************************************************************************/
avdt_scb_snd_reconfig_rsp(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1562 void avdt_scb_snd_reconfig_rsp(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1563 {
1564 if (p_data->msg.hdr.err_code == 0)
1565 {
1566 /* store new configuration */
1567 if (p_scb->req_cfg.num_codec > 0)
1568 {
1569 p_scb->curr_cfg.num_codec = p_scb->req_cfg.num_codec;
1570 memcpy(p_scb->curr_cfg.codec_info, p_scb->req_cfg.codec_info, AVDT_CODEC_SIZE);
1571 }
1572 if (p_scb->req_cfg.num_protect > 0)
1573 {
1574 p_scb->curr_cfg.num_protect = p_scb->req_cfg.num_protect;
1575 memcpy(p_scb->curr_cfg.protect_info, p_scb->req_cfg.protect_info, AVDT_PROTECT_SIZE);
1576 }
1577
1578 /* send response */
1579 avdt_msg_send_rsp(p_scb->p_ccb, AVDT_SIG_RECONFIG, &p_data->msg);
1580 }
1581 else
1582 {
1583 /* send reject */
1584 avdt_msg_send_rej(p_scb->p_ccb, AVDT_SIG_RECONFIG, &p_data->msg);
1585 }
1586 }
1587
1588 /*******************************************************************************
1589 **
1590 ** Function avdt_scb_snd_security_req
1591 **
1592 ** Description This function sends a security command message.
1593 **
1594 ** Returns Nothing.
1595 **
1596 *******************************************************************************/
avdt_scb_snd_security_req(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1597 void avdt_scb_snd_security_req(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1598 {
1599 p_data->msg.hdr.seid = p_scb->peer_seid;
1600 avdt_msg_send_cmd(p_scb->p_ccb, p_scb, AVDT_SIG_SECURITY, &p_data->msg);
1601 }
1602
1603 /*******************************************************************************
1604 **
1605 ** Function avdt_scb_snd_security_rsp
1606 **
1607 ** Description This function sends a security response message.
1608 **
1609 ** Returns Nothing.
1610 **
1611 *******************************************************************************/
avdt_scb_snd_security_rsp(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1612 void avdt_scb_snd_security_rsp(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1613 {
1614 if (p_data->msg.hdr.err_code == 0)
1615 {
1616 avdt_msg_send_rsp(p_scb->p_ccb, AVDT_SIG_SECURITY, &p_data->msg);
1617 }
1618 else
1619 {
1620 avdt_msg_send_rej(p_scb->p_ccb, AVDT_SIG_SECURITY, &p_data->msg);
1621 }
1622 }
1623
1624 /*******************************************************************************
1625 **
1626 ** Function avdt_scb_snd_setconfig_rej
1627 **
1628 ** Description This function marks the SCB as not in use and sends a
1629 ** set configuration reject message.
1630 **
1631 ** Returns Nothing.
1632 **
1633 *******************************************************************************/
avdt_scb_snd_setconfig_rej(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1634 void avdt_scb_snd_setconfig_rej(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1635 {
1636 if (p_scb->p_ccb != NULL)
1637 {
1638 avdt_msg_send_rej(p_scb->p_ccb, AVDT_SIG_SETCONFIG, &p_data->msg);
1639
1640 /* clear scb variables */
1641 avdt_scb_clr_vars(p_scb, p_data);
1642 }
1643 }
1644
1645 /*******************************************************************************
1646 **
1647 ** Function avdt_scb_snd_setconfig_req
1648 **
1649 ** Description This function marks the SCB as in use and copies the
1650 ** configuration parameters to the SCB. Then the function
1651 ** sends a set configuration command message and initiates
1652 ** opening of the signaling channel.
1653 **
1654 ** Returns Nothing.
1655 **
1656 *******************************************************************************/
avdt_scb_snd_setconfig_req(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1657 void avdt_scb_snd_setconfig_req(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1658 {
1659 tAVDT_CFG *p_req, *p_cfg;
1660
1661 /* copy API parameters to scb, set scb as in use */
1662 p_scb->in_use = TRUE;
1663 p_scb->p_ccb = avdt_ccb_by_idx(p_data->msg.config_cmd.hdr.ccb_idx);
1664 p_scb->peer_seid = p_data->msg.config_cmd.hdr.seid;
1665 p_req = p_data->msg.config_cmd.p_cfg;
1666 p_cfg = &p_scb->cs.cfg;
1667 #if AVDT_MULTIPLEXING == TRUE
1668 p_req->mux_tsid_media = p_cfg->mux_tsid_media;
1669 p_req->mux_tcid_media = p_cfg->mux_tcid_media;
1670 if(p_req->psc_mask & AVDT_PSC_REPORT)
1671 {
1672 p_req->mux_tsid_report = p_cfg->mux_tsid_report;
1673 p_req->mux_tcid_report = p_cfg->mux_tcid_report;
1674 }
1675 #endif
1676 memcpy(&p_scb->req_cfg, p_data->msg.config_cmd.p_cfg, sizeof(tAVDT_CFG));
1677
1678 avdt_msg_send_cmd(p_scb->p_ccb, p_scb, AVDT_SIG_SETCONFIG, &p_data->msg);
1679
1680 /* tell ccb to open channel */
1681 avdt_ccb_event(p_scb->p_ccb, AVDT_CCB_UL_OPEN_EVT, NULL);
1682 }
1683
1684 /*******************************************************************************
1685 **
1686 ** Function avdt_scb_snd_setconfig_rsp
1687 **
1688 ** Description This function copies the requested configuration into the
1689 ** current configuration and sends a set configuration
1690 ** response message.
1691 **
1692 ** Returns Nothing.
1693 **
1694 *******************************************************************************/
avdt_scb_snd_setconfig_rsp(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1695 void avdt_scb_snd_setconfig_rsp(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1696 {
1697 if (p_scb->p_ccb != NULL)
1698 {
1699 memcpy(&p_scb->curr_cfg, &p_scb->req_cfg, sizeof(tAVDT_CFG));
1700
1701 avdt_msg_send_rsp(p_scb->p_ccb, AVDT_SIG_SETCONFIG, &p_data->msg);
1702 }
1703 }
1704
1705 /*******************************************************************************
1706 **
1707 ** Function avdt_scb_snd_tc_close
1708 **
1709 ** Description This function calls avdt_ad_close_req() to close the
1710 ** transport channel for this SCB.
1711 **
1712 ** Returns Nothing.
1713 **
1714 *******************************************************************************/
avdt_scb_snd_tc_close(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1715 void avdt_scb_snd_tc_close(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1716 {
1717 UNUSED(p_data);
1718
1719 #if AVDT_REPORTING == TRUE
1720 if(p_scb->curr_cfg.psc_mask & AVDT_PSC_REPORT)
1721 avdt_ad_close_req(AVDT_CHAN_REPORT, p_scb->p_ccb, p_scb);
1722 #endif
1723 avdt_ad_close_req(AVDT_CHAN_MEDIA, p_scb->p_ccb, p_scb);
1724 }
1725
1726 /*******************************************************************************
1727 **
1728 ** Function avdt_scb_cb_err
1729 **
1730 ** Description This function calls the application callback function
1731 ** indicating an error.
1732 **
1733 ** Returns Nothing.
1734 **
1735 *******************************************************************************/
avdt_scb_cb_err(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1736 void avdt_scb_cb_err(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1737 {
1738 tAVDT_CTRL avdt_ctrl;
1739 UNUSED(p_data);
1740
1741 /* set error code and parameter */
1742 avdt_ctrl.hdr.err_code = AVDT_ERR_BAD_STATE;
1743 avdt_ctrl.hdr.err_param = 0;
1744
1745 /* call callback, using lookup table to get callback event */
1746 (*p_scb->cs.p_ctrl_cback)(avdt_scb_to_hdl(p_scb),
1747 NULL,
1748 avdt_scb_cback_evt[p_scb->curr_evt],
1749 &avdt_ctrl);
1750 }
1751
1752 /*******************************************************************************
1753 **
1754 ** Function avdt_scb_cong_state
1755 **
1756 ** Description This function sets the congestion state of the SCB media
1757 ** transport channel.
1758 **
1759 ** Returns Nothing.
1760 **
1761 *******************************************************************************/
avdt_scb_cong_state(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1762 void avdt_scb_cong_state(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1763 {
1764 p_scb->cong = p_data->llcong;
1765 }
1766
1767 /*******************************************************************************
1768 **
1769 ** Function avdt_scb_rej_state
1770 **
1771 ** Description This function sends a reject message to the peer indicating
1772 ** incorrect state for the received command message.
1773 **
1774 ** Returns Nothing.
1775 **
1776 *******************************************************************************/
avdt_scb_rej_state(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1777 void avdt_scb_rej_state(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1778 {
1779 UNUSED(p_scb);
1780
1781 p_data->msg.hdr.err_code = AVDT_ERR_BAD_STATE;
1782 p_data->msg.hdr.err_param = 0;
1783 avdt_msg_send_rej(avdt_ccb_by_idx(p_data->msg.hdr.ccb_idx),
1784 p_data->msg.hdr.sig_id, &p_data->msg);
1785 }
1786
1787 /*******************************************************************************
1788 **
1789 ** Function avdt_scb_rej_in_use
1790 **
1791 ** Description This function sends a reject message to the peer indicating
1792 ** the stream is in use.
1793 **
1794 ** Returns Nothing.
1795 **
1796 *******************************************************************************/
avdt_scb_rej_in_use(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1797 void avdt_scb_rej_in_use(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1798 {
1799 UNUSED(p_scb);
1800
1801 p_data->msg.hdr.err_code = AVDT_ERR_IN_USE;
1802 p_data->msg.hdr.err_param = 0;
1803 avdt_msg_send_rej(avdt_ccb_by_idx(p_data->msg.hdr.ccb_idx),
1804 p_data->msg.hdr.sig_id, &p_data->msg);
1805 }
1806
1807 /*******************************************************************************
1808 **
1809 ** Function avdt_scb_rej_not_in_use
1810 **
1811 ** Description This function sends a reject message to the peer indicating
1812 ** the stream is in use.
1813 **
1814 ** Returns Nothing.
1815 **
1816 *******************************************************************************/
avdt_scb_rej_not_in_use(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1817 void avdt_scb_rej_not_in_use(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1818 {
1819 UNUSED(p_scb);
1820
1821 p_data->msg.hdr.err_code = AVDT_ERR_NOT_IN_USE;
1822 p_data->msg.hdr.err_param = 0;
1823 avdt_msg_send_rej(avdt_ccb_by_idx(p_data->msg.hdr.ccb_idx),
1824 p_data->msg.hdr.sig_id, &p_data->msg);
1825 }
1826
1827 /*******************************************************************************
1828 **
1829 ** Function avdt_scb_set_remove
1830 **
1831 ** Description This function marks an SCB to be removed.
1832 **
1833 ** Returns Nothing.
1834 **
1835 *******************************************************************************/
avdt_scb_set_remove(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1836 void avdt_scb_set_remove(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1837 {
1838 UNUSED(p_data);
1839
1840 p_scb->remove = TRUE;
1841 }
1842
1843 /*******************************************************************************
1844 **
1845 ** Function avdt_scb_free_pkt
1846 **
1847 ** Description This function frees the media packet passed in.
1848 **
1849 ** Returns Nothing.
1850 **
1851 *******************************************************************************/
avdt_scb_free_pkt(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1852 void avdt_scb_free_pkt(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1853 {
1854 tAVDT_CTRL avdt_ctrl;
1855 #if AVDT_MULTIPLEXING == TRUE
1856 BT_HDR *p_frag;
1857 #endif
1858
1859 /* set error code and parameter */
1860 avdt_ctrl.hdr.err_code = AVDT_ERR_BAD_STATE;
1861 avdt_ctrl.hdr.err_param = 0;
1862
1863 /* p_buf can be NULL in case using of fragments queue frag_q */
1864 if(p_data->apiwrite.p_buf)
1865 GKI_freebuf(p_data->apiwrite.p_buf);
1866
1867 #if AVDT_MULTIPLEXING == TRUE
1868 /* clean fragments queue */
1869 while((p_frag = (BT_HDR*)GKI_dequeue (&p_data->apiwrite.frag_q)) != NULL)
1870 GKI_freebuf(p_frag);
1871 #endif
1872
1873 AVDT_TRACE_WARNING("Dropped media packet");
1874
1875 /* we need to call callback to keep data flow going */
1876 (*p_scb->cs.p_ctrl_cback)(avdt_scb_to_hdl(p_scb), NULL, AVDT_WRITE_CFM_EVT,
1877 &avdt_ctrl);
1878 }
1879
1880 /*******************************************************************************
1881 **
1882 ** Function avdt_scb_clr_pkt
1883 **
1884 ** Description This function frees the media packet stored in the SCB.
1885 **
1886 ** Returns Nothing.
1887 **
1888 *******************************************************************************/
avdt_scb_clr_pkt(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1889 void avdt_scb_clr_pkt(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1890 {
1891 tAVDT_CTRL avdt_ctrl;
1892 tAVDT_CCB *p_ccb;
1893 UINT8 tcid;
1894 UINT16 lcid;
1895 #if AVDT_MULTIPLEXING == TRUE
1896 BT_HDR *p_frag;
1897 #endif
1898 UNUSED(p_data);
1899
1900 /* set error code and parameter */
1901 avdt_ctrl.hdr.err_code = AVDT_ERR_BAD_STATE;
1902 avdt_ctrl.hdr.err_param = 0;
1903 /* flush the media data queued at L2CAP */
1904 if((p_ccb = p_scb->p_ccb) != NULL)
1905 {
1906 /* get tcid from type, scb */
1907 tcid = avdt_ad_type_to_tcid(AVDT_CHAN_MEDIA, p_scb);
1908
1909 lcid = avdt_cb.ad.rt_tbl[avdt_ccb_to_idx(p_ccb)][tcid].lcid;
1910 L2CA_FlushChannel (lcid, L2CAP_FLUSH_CHANS_ALL);
1911 }
1912
1913 if (p_scb->p_pkt != NULL)
1914 {
1915 GKI_freebuf(p_scb->p_pkt);
1916 p_scb->p_pkt = NULL;
1917
1918 AVDT_TRACE_DEBUG("Dropped stored media packet");
1919
1920 /* we need to call callback to keep data flow going */
1921 (*p_scb->cs.p_ctrl_cback)(avdt_scb_to_hdl(p_scb), NULL, AVDT_WRITE_CFM_EVT,
1922 &avdt_ctrl);
1923 }
1924 #if AVDT_MULTIPLEXING == TRUE
1925 else if(!GKI_queue_is_empty (&p_scb->frag_q))
1926 {
1927 AVDT_TRACE_DEBUG("Dropped fragments queue");
1928 /* clean fragments queue */
1929 while((p_frag = (BT_HDR*)GKI_dequeue (&p_scb->frag_q)) != NULL)
1930 GKI_freebuf(p_frag);
1931
1932 p_scb->frag_off = 0;
1933
1934 /* we need to call callback to keep data flow going */
1935 (*p_scb->cs.p_ctrl_cback)(avdt_scb_to_hdl(p_scb), NULL, AVDT_WRITE_CFM_EVT,
1936 &avdt_ctrl);
1937 }
1938 #endif
1939 }
1940
1941
1942 /*******************************************************************************
1943 **
1944 ** Function avdt_scb_chk_snd_pkt
1945 **
1946 ** Description This function checks if the SCB is congested, and if not
1947 ** congested it sends a stored media packet, if any. After it
1948 ** sends the packet it calls the application callback function
1949 ** with a write confirm.
1950 **
1951 ** Returns Nothing.
1952 **
1953 *******************************************************************************/
avdt_scb_chk_snd_pkt(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)1954 void avdt_scb_chk_snd_pkt(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
1955 {
1956 tAVDT_CTRL avdt_ctrl;
1957 BT_HDR *p_pkt;
1958 #if AVDT_MULTIPLEXING == TRUE
1959 BOOLEAN sent = FALSE;
1960 UINT8 res = AVDT_AD_SUCCESS;
1961 tAVDT_SCB_EVT data;
1962 #endif
1963 UNUSED(p_data);
1964
1965 avdt_ctrl.hdr.err_code = 0;
1966
1967 if (!p_scb->cong)
1968 {
1969 if (p_scb->p_pkt != NULL)
1970 {
1971 p_pkt = p_scb->p_pkt;
1972 p_scb->p_pkt = NULL;
1973 avdt_ad_write_req(AVDT_CHAN_MEDIA, p_scb->p_ccb, p_scb, p_pkt);
1974
1975 (*p_scb->cs.p_ctrl_cback)(avdt_scb_to_hdl(p_scb), NULL, AVDT_WRITE_CFM_EVT, &avdt_ctrl);
1976 }
1977 #if AVDT_MULTIPLEXING == TRUE
1978 else
1979 {
1980 #if 0
1981 AVDT_TRACE_DEBUG("num_q=%d",
1982 L2CA_FlushChannel(avdt_cb.ad.rt_tbl[avdt_ccb_to_idx(p_scb->p_ccb)][avdt_ad_type_to_tcid(AVDT_CHAN_MEDIA, p_scb)].lcid),
1983 L2CAP_FLUSH_CHANS_GET);
1984 #endif
1985 while((p_pkt = (BT_HDR*)GKI_dequeue (&p_scb->frag_q)) != NULL)
1986 {
1987 sent = TRUE;
1988 AVDT_TRACE_DEBUG("Send fragment len=%d",p_pkt->len);
1989 /* fragments queue contains fragment to send */
1990 res = avdt_ad_write_req(AVDT_CHAN_MEDIA, p_scb->p_ccb, p_scb, p_pkt);
1991 if(AVDT_AD_CONGESTED == res)
1992 {
1993 p_scb->cong = TRUE;
1994 AVDT_TRACE_DEBUG("avdt/l2c congested!!");
1995 break;/* exit loop if channel became congested */
1996 }
1997 }
1998 AVDT_TRACE_DEBUG("res=%d left=%d",res, p_scb->frag_off);
1999
2000 if(p_scb->frag_off)
2001 {
2002 if(AVDT_AD_SUCCESS == res || GKI_queue_is_empty (&p_scb->frag_q))
2003 {
2004 /* all buffers were sent to L2CAP, compose more to queue */
2005 avdt_scb_queue_frags(p_scb, &p_scb->p_next_frag, &p_scb->frag_off, &p_scb->frag_q);
2006 if(!GKI_queue_is_empty (&p_scb->frag_q))
2007 {
2008 data.llcong = p_scb->cong;
2009 avdt_scb_event(p_scb, AVDT_SCB_TC_CONG_EVT, &data);
2010 }
2011 }
2012 }
2013
2014 /* Send event AVDT_WRITE_CFM_EVT if it was last fragment */
2015 else if (sent && GKI_queue_is_empty (&p_scb->frag_q))
2016 {
2017 (*p_scb->cs.p_ctrl_cback)(avdt_scb_to_hdl(p_scb), NULL, AVDT_WRITE_CFM_EVT, &avdt_ctrl);
2018 }
2019 }
2020 #endif
2021 }
2022 }
2023
2024 /*******************************************************************************
2025 **
2026 ** Function avdt_scb_tc_timer
2027 **
2028 ** Description This function is called to start a timer when the peer
2029 ** initiates closing of the stream. The timer verifies that
2030 ** the peer disconnects the transport channel.
2031 **
2032 ** Returns Nothing.
2033 **
2034 *******************************************************************************/
avdt_scb_tc_timer(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)2035 void avdt_scb_tc_timer(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
2036 {
2037 UNUSED(p_data);
2038
2039 btu_start_timer(&p_scb->timer_entry, BTU_TTYPE_AVDT_SCB_TC, AVDT_SCB_TC_DISC_TOUT);
2040 }
2041
2042 /*******************************************************************************
2043 **
2044 ** Function avdt_scb_clr_vars
2045 **
2046 ** Description This function initializes certain SCB variables.
2047 **
2048 ** Returns Nothing.
2049 **
2050 *******************************************************************************/
avdt_scb_clr_vars(tAVDT_SCB * p_scb,tAVDT_SCB_EVT * p_data)2051 void avdt_scb_clr_vars(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
2052 {
2053 UNUSED(p_data);
2054
2055 if ((p_scb->cs.tsep == AVDT_TSEP_SNK) && (!p_scb->sink_activated))
2056 {
2057 p_scb->in_use = TRUE;
2058 }
2059 else
2060 {
2061 p_scb->in_use = FALSE;
2062 }
2063 p_scb->p_ccb = NULL;
2064 p_scb->peer_seid = 0;
2065 }
2066
2067 #if AVDT_MULTIPLEXING == TRUE
2068 /*******************************************************************************
2069 **
2070 ** Function avdt_scb_queue_frags
2071 **
2072 ** Description This function breaks media payload into fragments
2073 ** and put the fragments in the given queue.
2074 **
2075 ** Returns Nothing.
2076 **
2077 *******************************************************************************/
avdt_scb_queue_frags(tAVDT_SCB * p_scb,UINT8 ** pp_data,UINT32 * p_data_len,BUFFER_Q * pq)2078 void avdt_scb_queue_frags(tAVDT_SCB *p_scb, UINT8 **pp_data, UINT32 *p_data_len, BUFFER_Q *pq)
2079 {
2080 UINT16 lcid;
2081 UINT16 num_frag;
2082 UINT16 mtu_used;
2083 UINT8 *p;
2084 BOOLEAN al_hdr = FALSE;
2085 UINT8 tcid;
2086 tAVDT_TC_TBL *p_tbl;
2087 UINT16 buf_size;
2088 UINT16 offset = AVDT_MEDIA_OFFSET + AVDT_AL_HDR_SIZE;
2089 UINT16 cont_offset = offset - AVDT_MEDIA_HDR_SIZE;
2090 BT_HDR *p_frag;
2091
2092 tcid = avdt_ad_type_to_tcid(AVDT_CHAN_MEDIA, p_scb);
2093 lcid = avdt_cb.ad.rt_tbl[avdt_ccb_to_idx(p_scb->p_ccb)][tcid].lcid;
2094
2095 if( p_scb->frag_off != 0)
2096 {
2097 /* continuing process is usually triggered by un-congest event.
2098 * the number of buffers at L2CAP is very small (if not 0).
2099 * we do not need to L2CA_FlushChannel() */
2100 offset = cont_offset;
2101 al_hdr = TRUE;
2102 num_frag = AVDT_MAX_FRAG_COUNT;
2103 }
2104 else
2105 {
2106 num_frag = L2CA_FlushChannel(lcid, L2CAP_FLUSH_CHANS_GET);
2107 AVDT_TRACE_DEBUG("num_q=%d lcid=%d", num_frag, lcid);
2108 if(num_frag >= AVDT_MAX_FRAG_COUNT)
2109 {
2110 num_frag = 0;
2111 }
2112 else
2113 {
2114 num_frag = AVDT_MAX_FRAG_COUNT - num_frag;
2115 }
2116 }
2117
2118 /* look up transport channel table entry to get peer mtu */
2119 p_tbl = avdt_ad_tc_tbl_by_type(AVDT_CHAN_MEDIA, p_scb->p_ccb, p_scb);
2120 buf_size = p_tbl->peer_mtu + BT_HDR_SIZE;
2121 AVDT_TRACE_DEBUG("peer_mtu: %d, buf_size: %d num_frag=%d",
2122 p_tbl->peer_mtu, buf_size, num_frag);
2123
2124 if(buf_size > AVDT_DATA_POOL_SIZE)
2125 buf_size = AVDT_DATA_POOL_SIZE;
2126
2127 mtu_used = buf_size - BT_HDR_SIZE;
2128
2129 while(*p_data_len && num_frag)
2130 {
2131 /* allocate buffer for fragment */
2132 if(NULL == (p_frag = (BT_HDR*)GKI_getbuf(buf_size)))
2133 {
2134 AVDT_TRACE_WARNING("avdt_scb_queue_frags len=%d(out of GKI buffers)",*p_data_len);
2135 break;
2136 }
2137 /* fill fragment by chunk of media payload */
2138 p_frag->layer_specific = *p_data_len;/* length of all remaining transport packet */
2139 p_frag->offset = offset;
2140 /* adjust packet offset for continuing packets */
2141 offset = cont_offset;
2142
2143 p_frag->len = mtu_used - p_frag->offset;
2144 if(p_frag->len > *p_data_len)
2145 p_frag->len = *p_data_len;
2146 memcpy((UINT8*)(p_frag+1) + p_frag->offset, *pp_data, p_frag->len);
2147 *pp_data += p_frag->len;
2148 *p_data_len -= p_frag->len;
2149 AVDT_TRACE_DEBUG("Prepared fragment len=%d", p_frag->len);
2150
2151 if(al_hdr)
2152 {
2153 /* Adaptation Layer header */
2154 p_frag->len += AVDT_AL_HDR_SIZE;
2155 p_frag->offset -= AVDT_AL_HDR_SIZE;
2156 p = (UINT8 *)(p_frag + 1) + p_frag->offset;
2157 /* TSID, fragment bit and coding of length(in 2 length octets following) */
2158 *p++ = (p_scb->curr_cfg.mux_tsid_media<<3) | (AVDT_ALH_FRAG_MASK|AVDT_ALH_LCODE_16BIT);
2159
2160 /* length of all remaining transport packet */
2161 UINT16_TO_BE_STREAM(p, p_frag->layer_specific );
2162 }
2163 /* put fragment into gueue */
2164 GKI_enqueue(pq, p_frag);
2165 num_frag--;
2166 }
2167 }
2168 #endif
2169
2170