• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /******************************************************************************
2  *
3  *  Copyright 2011-2012 Broadcom Corporation
4  *
5  *  Licensed under the Apache License, Version 2.0 (the "License");
6  *  you may not use this file except in compliance with the License.
7  *  You may obtain a copy of the License at:
8  *
9  *  http://www.apache.org/licenses/LICENSE-2.0
10  *
11  *  Unless required by applicable law or agreed to in writing, software
12  *  distributed under the License is distributed on an "AS IS" BASIS,
13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  *  See the License for the specific language governing permissions and
15  *  limitations under the License.
16  *
17  ******************************************************************************/
18 
19 /******************************************************************************
20  *
21  *  This is the implementation of the API for the advanced audio/video (AV)
22  *  subsystem of BTA, Broadcom's Bluetooth application layer for mobile
23  *  phones.
24  *
25  ******************************************************************************/
26 
27 #define LOG_TAG "bt_bta_av"
28 
29 #include <base/logging.h>
30 
31 #include "bt_target.h"
32 
33 #include <string.h>
34 #include "bt_common.h"
35 #include "bta_api.h"
36 #include "bta_av_api.h"
37 #include "bta_av_int.h"
38 #include "bta_sys.h"
39 
40 #include "osi/include/allocator.h"
41 #include "osi/include/log.h"
42 
43 /*****************************************************************************
44  *  Constants
45  ****************************************************************************/
46 
47 static const tBTA_SYS_REG bta_av_reg = {bta_av_hdl_event, BTA_AvDisable};
48 
49 /*******************************************************************************
50  *
51  * Function         BTA_AvEnable
52  *
53  * Description      Enable the advanced audio/video service. When the enable
54  *                  operation is complete the callback function will be
55  *                  called with a BTA_AV_ENABLE_EVT. This function must
56  *                  be called before other function in the AV API are
57  *                  called.
58  *
59  * Returns          void
60  *
61  ******************************************************************************/
BTA_AvEnable(tBTA_SEC sec_mask,tBTA_AV_FEAT features,tBTA_AV_CBACK * p_cback)62 void BTA_AvEnable(tBTA_SEC sec_mask, tBTA_AV_FEAT features,
63                   tBTA_AV_CBACK* p_cback) {
64   tBTA_AV_API_ENABLE* p_buf =
65       (tBTA_AV_API_ENABLE*)osi_malloc(sizeof(tBTA_AV_API_ENABLE));
66 
67   /* register with BTA system manager */
68   bta_sys_register(BTA_ID_AV, &bta_av_reg);
69 
70   p_buf->hdr.event = BTA_AV_API_ENABLE_EVT;
71   p_buf->p_cback = p_cback;
72   p_buf->features = features;
73   p_buf->sec_mask = sec_mask;
74 
75   bta_sys_sendmsg(p_buf);
76 }
77 
78 /*******************************************************************************
79  *
80  * Function         BTA_AvDisable
81  *
82  * Description      Disable the advanced audio/video service.
83  *
84  * Returns          void
85  *
86  ******************************************************************************/
BTA_AvDisable(void)87 void BTA_AvDisable(void) {
88   BT_HDR* p_buf = (BT_HDR*)osi_malloc(sizeof(BT_HDR));
89 
90   bta_sys_deregister(BTA_ID_AV);
91   p_buf->event = BTA_AV_API_DISABLE_EVT;
92 
93   bta_sys_sendmsg(p_buf);
94 }
95 
96 /*******************************************************************************
97  *
98  * Function         BTA_AvRegister
99  *
100  * Description      Register the audio or video service to stack. When the
101  *                  operation is complete the callback function will be
102  *                  called with a BTA_AV_REGISTER_EVT. This function must
103  *                  be called before AVDT stream is open.
104  *
105  *
106  * Returns          void
107  *
108  ******************************************************************************/
BTA_AvRegister(tBTA_AV_CHNL chnl,const char * p_service_name,uint8_t app_id,tBTA_AV_SINK_DATA_CBACK * p_sink_data_cback,uint16_t service_uuid)109 void BTA_AvRegister(tBTA_AV_CHNL chnl, const char* p_service_name,
110                     uint8_t app_id, tBTA_AV_SINK_DATA_CBACK* p_sink_data_cback,
111                     uint16_t service_uuid) {
112   tBTA_AV_API_REG* p_buf =
113       (tBTA_AV_API_REG*)osi_malloc(sizeof(tBTA_AV_API_REG));
114 
115   p_buf->hdr.layer_specific = chnl;
116   p_buf->hdr.event = BTA_AV_API_REGISTER_EVT;
117   if (p_service_name)
118     strlcpy(p_buf->p_service_name, p_service_name, BTA_SERVICE_NAME_LEN);
119   else
120     p_buf->p_service_name[0] = 0;
121   p_buf->app_id = app_id;
122   p_buf->p_app_sink_data_cback = p_sink_data_cback;
123   p_buf->service_uuid = service_uuid;
124 
125   bta_sys_sendmsg(p_buf);
126 }
127 
128 /*******************************************************************************
129  *
130  * Function         BTA_AvDeregister
131  *
132  * Description      Deregister the audio or video service
133  *
134  * Returns          void
135  *
136  ******************************************************************************/
BTA_AvDeregister(tBTA_AV_HNDL hndl)137 void BTA_AvDeregister(tBTA_AV_HNDL hndl) {
138   BT_HDR* p_buf = (BT_HDR*)osi_malloc(sizeof(BT_HDR));
139 
140   p_buf->layer_specific = hndl;
141   p_buf->event = BTA_AV_API_DEREGISTER_EVT;
142 
143   bta_sys_sendmsg(p_buf);
144 }
145 
146 /*******************************************************************************
147  *
148  * Function         BTA_AvOpen
149  *
150  * Description      Opens an advanced audio/video connection to a peer device.
151  *                  When connection is open callback function is called
152  *                  with a BTA_AV_OPEN_EVT.
153  *
154  * Returns          void
155  *
156  ******************************************************************************/
BTA_AvOpen(const RawAddress & bd_addr,tBTA_AV_HNDL handle,bool use_rc,tBTA_SEC sec_mask,uint16_t uuid)157 void BTA_AvOpen(const RawAddress& bd_addr, tBTA_AV_HNDL handle, bool use_rc,
158                 tBTA_SEC sec_mask, uint16_t uuid) {
159   LOG_INFO(LOG_TAG, "%s: peer %s handle:0x%x use_rc=%s sec_mask=0x%x uuid=0x%x",
160            __func__, bd_addr.ToString().c_str(), handle,
161            (use_rc) ? "true" : "false", sec_mask, uuid);
162 
163   tBTA_AV_API_OPEN* p_buf =
164       (tBTA_AV_API_OPEN*)osi_malloc(sizeof(tBTA_AV_API_OPEN));
165 
166   p_buf->hdr.event = BTA_AV_API_OPEN_EVT;
167   p_buf->hdr.layer_specific = handle;
168   p_buf->bd_addr = bd_addr;
169   p_buf->use_rc = use_rc;
170   p_buf->sec_mask = sec_mask;
171   p_buf->switch_res = BTA_AV_RS_NONE;
172   p_buf->uuid = uuid;
173 
174   bta_sys_sendmsg(p_buf);
175 }
176 
177 /*******************************************************************************
178  *
179  * Function         BTA_AvClose
180  *
181  * Description      Close the current streams.
182  *
183  * Returns          void
184  *
185  ******************************************************************************/
BTA_AvClose(tBTA_AV_HNDL handle)186 void BTA_AvClose(tBTA_AV_HNDL handle) {
187   LOG_INFO(LOG_TAG, "%s: handle:0x%x", __func__, handle);
188 
189   BT_HDR* p_buf = (BT_HDR*)osi_malloc(sizeof(BT_HDR));
190 
191   p_buf->event = BTA_AV_API_CLOSE_EVT;
192   p_buf->layer_specific = handle;
193 
194   bta_sys_sendmsg(p_buf);
195 }
196 
197 /*******************************************************************************
198  *
199  * Function         BTA_AvDisconnect
200  *
201  * Description      Close the connection to the address.
202  *
203  * Returns          void
204  *
205  ******************************************************************************/
BTA_AvDisconnect(const RawAddress & bd_addr)206 void BTA_AvDisconnect(const RawAddress& bd_addr) {
207   LOG_INFO(LOG_TAG, "%s: peer %s", __func__, bd_addr.ToString().c_str());
208 
209   tBTA_AV_API_DISCNT* p_buf =
210       (tBTA_AV_API_DISCNT*)osi_malloc(sizeof(tBTA_AV_API_DISCNT));
211 
212   p_buf->hdr.event = BTA_AV_API_DISCONNECT_EVT;
213   p_buf->bd_addr = bd_addr;
214 
215   bta_sys_sendmsg(p_buf);
216 }
217 
218 /*******************************************************************************
219  *
220  * Function         BTA_AvStart
221  *
222  * Description      Start audio/video stream data transfer.
223  *
224  * Returns          void
225  *
226  ******************************************************************************/
BTA_AvStart(tBTA_AV_HNDL handle)227 void BTA_AvStart(tBTA_AV_HNDL handle) {
228   LOG_INFO(LOG_TAG, "%s: handle=%d", __func__, handle);
229 
230   BT_HDR* p_buf = (BT_HDR*)osi_malloc(sizeof(BT_HDR));
231 
232   p_buf->event = BTA_AV_API_START_EVT;
233   p_buf->layer_specific = handle;
234 
235   bta_sys_sendmsg(p_buf);
236 }
237 
238 /*******************************************************************************
239  *
240  * Function         BTA_AvOffloadStart
241  *
242  * Description      Start a2dp audio offloading.
243  *
244  * Returns          void
245  *
246  ******************************************************************************/
BTA_AvOffloadStart(tBTA_AV_HNDL hndl)247 void BTA_AvOffloadStart(tBTA_AV_HNDL hndl) {
248   LOG_INFO(LOG_TAG, "%s: handle=%d", __func__, hndl);
249 
250   BT_HDR* p_buf = (BT_HDR*)osi_malloc(sizeof(BT_HDR));
251 
252   p_buf->event = BTA_AV_API_OFFLOAD_START_EVT;
253   p_buf->layer_specific = hndl;
254 
255   bta_sys_sendmsg(p_buf);
256 }
257 
258 /*******************************************************************************
259  *
260  * Function         BTA_AvOffloadStartRsp
261  *
262  * Description      Response from vendor lib for A2DP Offload Start request.
263  *
264  * Returns          void
265  *
266  ******************************************************************************/
BTA_AvOffloadStartRsp(tBTA_AV_HNDL hndl,tBTA_AV_STATUS status)267 void BTA_AvOffloadStartRsp(tBTA_AV_HNDL hndl, tBTA_AV_STATUS status) {
268   tBTA_AV_API_STATUS_RSP* p_buf =
269       (tBTA_AV_API_STATUS_RSP*)osi_malloc(sizeof(tBTA_AV_API_STATUS_RSP));
270 
271   p_buf->hdr.event = BTA_AV_API_OFFLOAD_START_RSP_EVT;
272   p_buf->hdr.layer_specific = hndl;
273   p_buf->status = status;
274 
275   bta_sys_sendmsg(p_buf);
276 }
277 
278 /*******************************************************************************
279  *
280  * Function         BTA_AvStop
281  *
282  * Description      Stop audio/video stream data transfer.
283  *                  If suspend is true, this function sends AVDT suspend signal
284  *                  to the connected peer(s).
285  *
286  * Returns          void
287  *
288  ******************************************************************************/
BTA_AvStop(tBTA_AV_HNDL handle,bool suspend)289 void BTA_AvStop(tBTA_AV_HNDL handle, bool suspend) {
290   LOG_INFO(LOG_TAG, "%s: handle=%d suspend=%s", __func__, handle,
291            logbool(suspend).c_str());
292 
293   tBTA_AV_API_STOP* p_buf =
294       (tBTA_AV_API_STOP*)osi_malloc(sizeof(tBTA_AV_API_STOP));
295 
296   p_buf->hdr.event = BTA_AV_API_STOP_EVT;
297   p_buf->hdr.layer_specific = handle;
298   p_buf->flush = true;
299   p_buf->suspend = suspend;
300   p_buf->reconfig_stop = false;
301 
302   bta_sys_sendmsg(p_buf);
303 }
304 
305 /*******************************************************************************
306  *
307  * Function         BTA_AvReconfig
308  *
309  * Description      Reconfigure the audio/video stream.
310  *                  If suspend is true, this function tries the
311  *                  suspend/reconfigure procedure first.
312  *                  If suspend is false or when suspend/reconfigure fails,
313  *                  this function closes and re-opens the AVDT connection.
314  *
315  * Returns          void
316  *
317  ******************************************************************************/
BTA_AvReconfig(tBTA_AV_HNDL hndl,bool suspend,uint8_t sep_info_idx,uint8_t * p_codec_info,uint8_t num_protect,const uint8_t * p_protect_info)318 void BTA_AvReconfig(tBTA_AV_HNDL hndl, bool suspend, uint8_t sep_info_idx,
319                     uint8_t* p_codec_info, uint8_t num_protect,
320                     const uint8_t* p_protect_info) {
321   LOG_INFO(LOG_TAG, "%s: handle=%d suspend=%s sep_info_idx=%d", __func__, hndl,
322            logbool(suspend).c_str(), sep_info_idx);
323 
324   tBTA_AV_API_RCFG* p_buf =
325       (tBTA_AV_API_RCFG*)osi_malloc(sizeof(tBTA_AV_API_RCFG) + num_protect);
326 
327   p_buf->hdr.layer_specific = hndl;
328   p_buf->hdr.event = BTA_AV_API_RECONFIG_EVT;
329   p_buf->num_protect = num_protect;
330   p_buf->suspend = suspend;
331   p_buf->sep_info_idx = sep_info_idx;
332   p_buf->p_protect_info = (uint8_t*)(p_buf + 1);
333   memcpy(p_buf->codec_info, p_codec_info, AVDT_CODEC_SIZE);
334   memcpy(p_buf->p_protect_info, p_protect_info, num_protect);
335 
336   bta_sys_sendmsg(p_buf);
337 }
338 
339 /*******************************************************************************
340  *
341  * Function         BTA_AvProtectReq
342  *
343  * Description      Send a content protection request.  This function can only
344  *                  be used if AV is enabled with feature BTA_AV_FEAT_PROTECT.
345  *
346  * Returns          void
347  *
348  ******************************************************************************/
BTA_AvProtectReq(tBTA_AV_HNDL hndl,uint8_t * p_data,uint16_t len)349 void BTA_AvProtectReq(tBTA_AV_HNDL hndl, uint8_t* p_data, uint16_t len) {
350   tBTA_AV_API_PROTECT_REQ* p_buf = (tBTA_AV_API_PROTECT_REQ*)osi_malloc(
351       sizeof(tBTA_AV_API_PROTECT_REQ) + len);
352 
353   p_buf->hdr.layer_specific = hndl;
354   p_buf->hdr.event = BTA_AV_API_PROTECT_REQ_EVT;
355   p_buf->len = len;
356   if (p_data == NULL) {
357     p_buf->p_data = NULL;
358   } else {
359     p_buf->p_data = (uint8_t*)(p_buf + 1);
360     memcpy(p_buf->p_data, p_data, len);
361   }
362 
363   bta_sys_sendmsg(p_buf);
364 }
365 
366 /*******************************************************************************
367  *
368  * Function         BTA_AvProtectRsp
369  *
370  * Description      Send a content protection response.  This function must
371  *                  be called if a BTA_AV_PROTECT_REQ_EVT is received.
372  *                  This function can only be used if AV is enabled with
373  *                  feature BTA_AV_FEAT_PROTECT.
374  *
375  * Returns          void
376  *
377  ******************************************************************************/
BTA_AvProtectRsp(tBTA_AV_HNDL hndl,uint8_t error_code,uint8_t * p_data,uint16_t len)378 void BTA_AvProtectRsp(tBTA_AV_HNDL hndl, uint8_t error_code, uint8_t* p_data,
379                       uint16_t len) {
380   tBTA_AV_API_PROTECT_RSP* p_buf = (tBTA_AV_API_PROTECT_RSP*)osi_malloc(
381       sizeof(tBTA_AV_API_PROTECT_RSP) + len);
382 
383   p_buf->hdr.layer_specific = hndl;
384   p_buf->hdr.event = BTA_AV_API_PROTECT_RSP_EVT;
385   p_buf->len = len;
386   p_buf->error_code = error_code;
387   if (p_data == NULL) {
388     p_buf->p_data = NULL;
389   } else {
390     p_buf->p_data = (uint8_t*)(p_buf + 1);
391     memcpy(p_buf->p_data, p_data, len);
392   }
393 
394   bta_sys_sendmsg(p_buf);
395 }
396 
397 /*******************************************************************************
398  *
399  * Function         BTA_AvRemoteCmd
400  *
401  * Description      Send a remote control command.  This function can only
402  *                  be used if AV is enabled with feature BTA_AV_FEAT_RCCT.
403  *
404  * Returns          void
405  *
406  ******************************************************************************/
BTA_AvRemoteCmd(uint8_t rc_handle,uint8_t label,tBTA_AV_RC rc_id,tBTA_AV_STATE key_state)407 void BTA_AvRemoteCmd(uint8_t rc_handle, uint8_t label, tBTA_AV_RC rc_id,
408                      tBTA_AV_STATE key_state) {
409   tBTA_AV_API_REMOTE_CMD* p_buf =
410       (tBTA_AV_API_REMOTE_CMD*)osi_malloc(sizeof(tBTA_AV_API_REMOTE_CMD));
411 
412   p_buf->hdr.event = BTA_AV_API_REMOTE_CMD_EVT;
413   p_buf->hdr.layer_specific = rc_handle;
414   p_buf->msg.op_id = rc_id;
415   p_buf->msg.state = key_state;
416   p_buf->msg.p_pass_data = NULL;
417   p_buf->msg.pass_len = 0;
418   p_buf->label = label;
419 
420   bta_sys_sendmsg(p_buf);
421 }
422 
423 /*******************************************************************************
424  *
425  * Function         BTA_AvRemoteVendorUniqueCmd
426  *
427  * Description      Send a remote control command with Vendor Unique rc_id.
428  *                  This function can only be used if AV is enabled with
429  *                  feature BTA_AV_FEAT_RCCT.
430  *
431  * Returns          void
432  *
433  ******************************************************************************/
BTA_AvRemoteVendorUniqueCmd(uint8_t rc_handle,uint8_t label,tBTA_AV_STATE key_state,uint8_t * p_msg,uint8_t buf_len)434 void BTA_AvRemoteVendorUniqueCmd(uint8_t rc_handle, uint8_t label,
435                                  tBTA_AV_STATE key_state, uint8_t* p_msg,
436                                  uint8_t buf_len) {
437   tBTA_AV_API_REMOTE_CMD* p_buf = (tBTA_AV_API_REMOTE_CMD*)osi_malloc(
438       sizeof(tBTA_AV_API_REMOTE_CMD) + buf_len);
439 
440   p_buf->label = label;
441   p_buf->hdr.event = BTA_AV_API_REMOTE_CMD_EVT;
442   p_buf->hdr.layer_specific = rc_handle;
443   p_buf->msg.op_id = AVRC_ID_VENDOR;
444   p_buf->msg.state = key_state;
445   p_buf->msg.pass_len = buf_len;
446   if (p_msg == NULL) {
447     p_buf->msg.p_pass_data = NULL;
448   } else {
449     p_buf->msg.p_pass_data = (uint8_t*)(p_buf + 1);
450     memcpy(p_buf->msg.p_pass_data, p_msg, buf_len);
451   }
452   bta_sys_sendmsg(p_buf);
453 }
454 
455 /*******************************************************************************
456  *
457  * Function         BTA_AvVendorCmd
458  *
459  * Description      Send a vendor dependent remote control command.  This
460  *                  function can only be used if AV is enabled with feature
461  *                  BTA_AV_FEAT_VENDOR.
462  *
463  * Returns          void
464  *
465  ******************************************************************************/
BTA_AvVendorCmd(uint8_t rc_handle,uint8_t label,tBTA_AV_CODE cmd_code,uint8_t * p_data,uint16_t len)466 void BTA_AvVendorCmd(uint8_t rc_handle, uint8_t label, tBTA_AV_CODE cmd_code,
467                      uint8_t* p_data, uint16_t len) {
468   tBTA_AV_API_VENDOR* p_buf =
469       (tBTA_AV_API_VENDOR*)osi_malloc(sizeof(tBTA_AV_API_VENDOR) + len);
470 
471   p_buf->hdr.event = BTA_AV_API_VENDOR_CMD_EVT;
472   p_buf->hdr.layer_specific = rc_handle;
473   p_buf->msg.hdr.ctype = cmd_code;
474   p_buf->msg.hdr.subunit_type = AVRC_SUB_PANEL;
475   p_buf->msg.hdr.subunit_id = 0;
476   p_buf->msg.company_id = p_bta_av_cfg->company_id;
477   p_buf->label = label;
478   p_buf->msg.vendor_len = len;
479   if (p_data == NULL) {
480     p_buf->msg.p_vendor_data = NULL;
481   } else {
482     p_buf->msg.p_vendor_data = (uint8_t*)(p_buf + 1);
483     memcpy(p_buf->msg.p_vendor_data, p_data, len);
484   }
485 
486   bta_sys_sendmsg(p_buf);
487 }
488 
489 /*******************************************************************************
490  *
491  * Function         BTA_AvVendorRsp
492  *
493  * Description      Send a vendor dependent remote control response.
494  *                  This function must be called if a BTA_AV_VENDOR_CMD_EVT
495  *                  is received. This function can only be used if AV is
496  *                  enabled with feature BTA_AV_FEAT_VENDOR.
497  *
498  * Returns          void
499  *
500  ******************************************************************************/
BTA_AvVendorRsp(uint8_t rc_handle,uint8_t label,tBTA_AV_CODE rsp_code,uint8_t * p_data,uint16_t len,uint32_t company_id)501 void BTA_AvVendorRsp(uint8_t rc_handle, uint8_t label, tBTA_AV_CODE rsp_code,
502                      uint8_t* p_data, uint16_t len, uint32_t company_id) {
503   tBTA_AV_API_VENDOR* p_buf =
504       (tBTA_AV_API_VENDOR*)osi_malloc(sizeof(tBTA_AV_API_VENDOR) + len);
505 
506   p_buf->hdr.event = BTA_AV_API_VENDOR_RSP_EVT;
507   p_buf->hdr.layer_specific = rc_handle;
508   p_buf->msg.hdr.ctype = rsp_code;
509   p_buf->msg.hdr.subunit_type = AVRC_SUB_PANEL;
510   p_buf->msg.hdr.subunit_id = 0;
511   if (company_id)
512     p_buf->msg.company_id = company_id;
513   else
514     p_buf->msg.company_id = p_bta_av_cfg->company_id;
515   p_buf->label = label;
516   p_buf->msg.vendor_len = len;
517   if (p_data == NULL) {
518     p_buf->msg.p_vendor_data = NULL;
519   } else {
520     p_buf->msg.p_vendor_data = (uint8_t*)(p_buf + 1);
521     memcpy(p_buf->msg.p_vendor_data, p_data, len);
522   }
523 
524   bta_sys_sendmsg(p_buf);
525 }
526 
527 /*******************************************************************************
528  *
529  * Function         BTA_AvOpenRc
530  *
531  * Description      Open an AVRCP connection toward the device with the
532  *                  specified handle
533  *
534  * Returns          void
535  *
536  ******************************************************************************/
BTA_AvOpenRc(tBTA_AV_HNDL handle)537 void BTA_AvOpenRc(tBTA_AV_HNDL handle) {
538   tBTA_AV_API_OPEN_RC* p_buf =
539       (tBTA_AV_API_OPEN_RC*)osi_malloc(sizeof(tBTA_AV_API_OPEN_RC));
540 
541   p_buf->hdr.event = BTA_AV_API_RC_OPEN_EVT;
542   p_buf->hdr.layer_specific = handle;
543 
544   bta_sys_sendmsg(p_buf);
545 }
546 
547 /*******************************************************************************
548  *
549  * Function         BTA_AvCloseRc
550  *
551  * Description      Close an AVRCP connection
552  *
553  * Returns          void
554  *
555  ******************************************************************************/
BTA_AvCloseRc(uint8_t rc_handle)556 void BTA_AvCloseRc(uint8_t rc_handle) {
557   tBTA_AV_API_CLOSE_RC* p_buf =
558       (tBTA_AV_API_CLOSE_RC*)osi_malloc(sizeof(tBTA_AV_API_CLOSE_RC));
559 
560   p_buf->hdr.event = BTA_AV_API_RC_CLOSE_EVT;
561   p_buf->hdr.layer_specific = rc_handle;
562 
563   bta_sys_sendmsg(p_buf);
564 }
565 
566 /*******************************************************************************
567  *
568  * Function         BTA_AvMetaRsp
569  *
570  * Description      Send a Metadata/Advanced Control response. The message
571  *                  contained in p_pkt can be composed with AVRC utility
572  *                  functions.
573  *                  This function can only be used if AV is enabled with feature
574  *                  BTA_AV_FEAT_METADATA.
575  *
576  * Returns          void
577  *
578  ******************************************************************************/
BTA_AvMetaRsp(uint8_t rc_handle,uint8_t label,tBTA_AV_CODE rsp_code,BT_HDR * p_pkt)579 void BTA_AvMetaRsp(uint8_t rc_handle, uint8_t label, tBTA_AV_CODE rsp_code,
580                    BT_HDR* p_pkt) {
581   tBTA_AV_API_META_RSP* p_buf =
582       (tBTA_AV_API_META_RSP*)osi_malloc(sizeof(tBTA_AV_API_META_RSP));
583 
584   p_buf->hdr.event = BTA_AV_API_META_RSP_EVT;
585   p_buf->hdr.layer_specific = rc_handle;
586   p_buf->rsp_code = rsp_code;
587   p_buf->p_pkt = p_pkt;
588   p_buf->is_rsp = true;
589   p_buf->label = label;
590 
591   bta_sys_sendmsg(p_buf);
592 }
593 
594 /*******************************************************************************
595  *
596  * Function         BTA_AvMetaCmd
597  *
598  * Description      Send a Metadata/Advanced Control command. The message
599 *contained
600  *                  in p_pkt can be composed with AVRC utility functions.
601  *                  This function can only be used if AV is enabled with feature
602  *                  BTA_AV_FEAT_METADATA.
603  *                  This message is sent only when the peer supports the TG
604 *role.
605 *8                  The only command makes sense right now is the absolute
606 *volume command.
607  *
608  * Returns          void
609  *
610  ******************************************************************************/
BTA_AvMetaCmd(uint8_t rc_handle,uint8_t label,tBTA_AV_CMD cmd_code,BT_HDR * p_pkt)611 void BTA_AvMetaCmd(uint8_t rc_handle, uint8_t label, tBTA_AV_CMD cmd_code,
612                    BT_HDR* p_pkt) {
613   tBTA_AV_API_META_RSP* p_buf =
614       (tBTA_AV_API_META_RSP*)osi_malloc(sizeof(tBTA_AV_API_META_RSP));
615 
616   p_buf->hdr.event = BTA_AV_API_META_RSP_EVT;
617   p_buf->hdr.layer_specific = rc_handle;
618   p_buf->p_pkt = p_pkt;
619   p_buf->rsp_code = cmd_code;
620   p_buf->is_rsp = false;
621   p_buf->label = label;
622 
623   bta_sys_sendmsg(p_buf);
624 }
625