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