bta/av/bta_av_int.h

   1 /******************************************************************************
   2  *
   3  *  Copyright 2004-2012 Broadcom Corporation
   4  *
   5  *  Licensed under the Apache License, Version 2.0 (the "License");
   6  *  you may not use this file except in compliance with the License.
   7  *  You may obtain a copy of the License at:
   8  *
   9  *  http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *  Unless required by applicable law or agreed to in writing, software
  12  *  distributed under the License is distributed on an "AS IS" BASIS,
  13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *  See the License for the specific language governing permissions and
  15  *  limitations under the License.
  16  *
  17  ******************************************************************************/
  18
  19 /******************************************************************************
  20  *
  21  *  This is the private interface file for the BTA advanced audio/video.
  22  *
  23  ******************************************************************************/
  24 #ifndef BTA_AV_INT_H
  25 #define BTA_AV_INT_H
  26
  27 #include <cstdint>
  28 #include <string>
  29
  30 #include "bta/av/bta_av_int.h"
  31 #include "bta/include/bta_av_api.h"
  32 #include "bta/include/bta_av_co.h"
  33 #include "bta/sys/bta_sys.h"
  34 #include "osi/include/list.h"
  35 #include "stack/include/avdt_api.h"
  36 #include "stack/include/bt_types.h"
  37
  38 #define CASE_RETURN_TEXT(code) \
  39   case code:                   \
  40     return #code
  41
  42 /*****************************************************************************
  43  *  Constants
  44  ****************************************************************************/
  45
  46 enum {
  47   /* these events are handled by the AV main state machine */
  48   BTA_AV_API_DISABLE_EVT = BTA_SYS_EVT_START(BTA_ID_AV),
  49   BTA_AV_API_REMOTE_CMD_EVT,
  50   BTA_AV_API_VENDOR_CMD_EVT,
  51   BTA_AV_API_VENDOR_RSP_EVT,
  52   BTA_AV_API_META_RSP_EVT,
  53   BTA_AV_API_RC_CLOSE_EVT,
  54   BTA_AV_AVRC_OPEN_EVT,
  55   BTA_AV_AVRC_MSG_EVT,
  56   BTA_AV_AVRC_NONE_EVT,
  57
  58   /* these events are handled by the AV stream state machine */
  59   BTA_AV_API_OPEN_EVT,
  60   BTA_AV_API_CLOSE_EVT,
  61   BTA_AV_AP_START_EVT, /* the following 2 events must be in the same order as
  62                           the *API_*EVT */
  63   BTA_AV_AP_STOP_EVT,
  64   BTA_AV_API_RECONFIG_EVT,
  65   BTA_AV_API_PROTECT_REQ_EVT,
  66   BTA_AV_API_PROTECT_RSP_EVT,
  67   BTA_AV_API_RC_OPEN_EVT,
  68   BTA_AV_SRC_DATA_READY_EVT,
  69   BTA_AV_CI_SETCONFIG_OK_EVT,
  70   BTA_AV_CI_SETCONFIG_FAIL_EVT,
  71   BTA_AV_SDP_DISC_OK_EVT,
  72   BTA_AV_SDP_DISC_FAIL_EVT,
  73   BTA_AV_STR_DISC_OK_EVT,
  74   BTA_AV_STR_DISC_FAIL_EVT,
  75   BTA_AV_STR_GETCAP_OK_EVT,
  76   BTA_AV_STR_GETCAP_FAIL_EVT,
  77   BTA_AV_STR_OPEN_OK_EVT,
  78   BTA_AV_STR_OPEN_FAIL_EVT,
  79   BTA_AV_STR_START_OK_EVT,
  80   BTA_AV_STR_START_FAIL_EVT,
  81   BTA_AV_STR_CLOSE_EVT,
  82   BTA_AV_STR_CONFIG_IND_EVT,
  83   BTA_AV_STR_SECURITY_IND_EVT,
  84   BTA_AV_STR_SECURITY_CFM_EVT,
  85   BTA_AV_STR_WRITE_CFM_EVT,
  86   BTA_AV_STR_SUSPEND_CFM_EVT,
  87   BTA_AV_STR_RECONFIG_CFM_EVT,
  88   BTA_AV_AVRC_TIMER_EVT,
  89   BTA_AV_AVDT_CONNECT_EVT,
  90   BTA_AV_AVDT_DISCONNECT_EVT,
  91   BTA_AV_ROLE_CHANGE_EVT,
  92   BTA_AV_AVDT_DELAY_RPT_EVT,
  93   BTA_AV_AVDT_DELAY_RPT_CFM_EVT,
  94   BTA_AV_ACP_CONNECT_EVT,
  95   BTA_AV_API_OFFLOAD_START_EVT,
  96   BTA_AV_API_OFFLOAD_START_RSP_EVT,
  97
  98   /* these events are handled outside of the state machine */
  99   BTA_AV_API_ENABLE_EVT,
 100   BTA_AV_API_REGISTER_EVT,
 101   BTA_AV_API_DEREGISTER_EVT,
 102   BTA_AV_API_DISCONNECT_EVT,
 103   BTA_AV_CI_SRC_DATA_READY_EVT,
 104   BTA_AV_SIG_CHG_EVT,
 105   BTA_AV_SIGNALLING_TIMER_EVT,
 106   BTA_AV_SDP_AVRC_DISC_EVT,
 107   BTA_AV_AVRC_CLOSE_EVT,
 108   BTA_AV_AVRC_BROWSE_OPEN_EVT,
 109   BTA_AV_AVRC_BROWSE_CLOSE_EVT,
 110   BTA_AV_CONN_CHG_EVT,
 111   BTA_AV_DEREG_COMP_EVT,
 112   BTA_AV_AVDT_RPT_CONN_EVT,
 113   BTA_AV_API_START_EVT, /* the following 2 events must be in the same order as
 114                            the *AP_*EVT */
 115   BTA_AV_API_STOP_EVT
 116 };
 117
 118 /* events for AV control block state machine */
 119 #define BTA_AV_FIRST_SM_EVT BTA_AV_API_DISABLE_EVT
 120 #define BTA_AV_LAST_SM_EVT BTA_AV_AVRC_NONE_EVT
 121
 122 /* events for AV stream control block state machine */
 123 #define BTA_AV_FIRST_SSM_EVT BTA_AV_API_OPEN_EVT
 124
 125 /* events that do not go through state machine */
 126 #define BTA_AV_FIRST_NSM_EVT BTA_AV_API_ENABLE_EVT
 127 #define BTA_AV_LAST_NSM_EVT BTA_AV_API_STOP_EVT
 128
 129 /* API events passed to both SSMs (by bta_av_api_to_ssm) */
 130 #define BTA_AV_FIRST_A2S_API_EVT BTA_AV_API_START_EVT
 131 #define BTA_AV_FIRST_A2S_SSM_EVT BTA_AV_AP_START_EVT
 132
 133 #define BTA_AV_LAST_EVT BTA_AV_API_STOP_EVT
 134
 135 /* maximum number of SEPS in stream discovery results */
 136 #define BTA_AV_NUM_SEPS 32
 137
 138 /* initialization value for AVRC handle */
 139 #define BTA_AV_RC_HANDLE_NONE 0xFF
 140
 141 /* size of database for service discovery */
 142 #define BTA_AV_DISC_BUF_SIZE 2000
 143
 144 /* maximum length of AVDTP security data */
 145 #define BTA_AV_SECURITY_MAX_LEN 400
 146
 147 /* check number of buffers queued at L2CAP when this amount of buffers are
 148  * queued to L2CAP */
 149 #define BTA_AV_QUEUE_DATA_CHK_NUM L2CAP_HIGH_PRI_MIN_XMIT_QUOTA
 150
 151 /* the number of ACL links with AVDT */
 152 #define BTA_AV_NUM_LINKS AVDT_NUM_LINKS
 153
 154 #define BTA_AV_BE_STREAM_TO_CO_ID(u32, p)                                 \
 155   {                                                                       \
 156     (u32) = (((uint32_t)(*((p) + 2))) + (((uint32_t)(*((p) + 1))) << 8) + \
 157              (((uint32_t)(*(p))) << 16));                                 \
 158     (p) += 3;                                                             \
 159   }
 160
 161 /*****************************************************************************
 162  *  Data types
 163  ****************************************************************************/
 164
 165 /* function types for call-out functions */
 166 typedef bool (*tBTA_AV_CO_INIT)(btav_a2dp_codec_index_t codec_index,
 167                                 AvdtpSepConfig* p_cfg);
 168 typedef void (*tBTA_AV_CO_DISC_RES)(tBTA_AV_HNDL bta_av_handle,
 169                                     const RawAddress& peer_addr,
 170                                     uint8_t num_seps, uint8_t num_snk,
 171                                     uint8_t num_src, uint16_t uuid_local);
 172 typedef tA2DP_STATUS (*tBTA_AV_CO_GETCFG)(tBTA_AV_HNDL bta_av_handle,
 173                                           const RawAddress& peer_addr,
 174                                           uint8_t* p_codec_info,
 175                                           uint8_t* p_sep_info_idx, uint8_t seid,
 176                                           uint8_t* p_num_protect,
 177                                           uint8_t* p_protect_info);
 178 typedef void (*tBTA_AV_CO_SETCFG)(tBTA_AV_HNDL bta_av_handle,
 179                                   const RawAddress& peer_addr,
 180                                   const uint8_t* p_codec_info, uint8_t seid,
 181                                   uint8_t num_protect,
 182                                   const uint8_t* p_protect_info,
 183                                   uint8_t t_local_sep, uint8_t avdt_handle);
 184 typedef void (*tBTA_AV_CO_OPEN)(tBTA_AV_HNDL bta_av_handle,
 185                                 const RawAddress& peer_addr, uint16_t mtu);
 186 typedef void (*tBTA_AV_CO_CLOSE)(tBTA_AV_HNDL bta_av_handle,
 187                                  const RawAddress& peer_addr);
 188 typedef void (*tBTA_AV_CO_START)(tBTA_AV_HNDL bta_av_handle,
 189                                  const RawAddress& peer_addr,
 190                                  const uint8_t* p_codec_info,
 191                                  bool* p_no_rtp_header);
 192 typedef void (*tBTA_AV_CO_STOP)(tBTA_AV_HNDL bta_av_handle,
 193                                 const RawAddress& peer_addr);
 194 typedef BT_HDR* (*tBTA_AV_CO_DATAPATH)(const uint8_t* p_codec_info,
 195                                        uint32_t* p_timestamp);
 196 typedef void (*tBTA_AV_CO_DELAY)(tBTA_AV_HNDL bta_av_handle,
 197                                  const RawAddress& peer_addr, uint16_t delay);
 198 typedef void (*tBTA_AV_CO_UPDATE_MTU)(tBTA_AV_HNDL bta_av_handle,
 199                                       const RawAddress& peer_addr,
 200                                       uint16_t mtu);
 201
 202 typedef btav_a2dp_scmst_info_t (*tBTA_AV_CO_GET_SCMST_INFO)(
 203     const RawAddress& peer_addr);
 204
 205 /* the call-out functions for one stream */
 206 typedef struct {
 207   tBTA_AV_CO_INIT init;
 208   tBTA_AV_CO_DISC_RES disc_res;
 209   tBTA_AV_CO_GETCFG getcfg;
 210   tBTA_AV_CO_SETCFG setcfg;
 211   tBTA_AV_CO_OPEN open;
 212   tBTA_AV_CO_CLOSE close;
 213   tBTA_AV_CO_START start;
 214   tBTA_AV_CO_STOP stop;
 215   tBTA_AV_CO_DATAPATH data;
 216   tBTA_AV_CO_DELAY delay;
 217   tBTA_AV_CO_UPDATE_MTU update_mtu;
 218   tBTA_AV_CO_GET_SCMST_INFO get_scmst_info;
 219 } tBTA_AV_CO_FUNCTS;
 220
 221 /* data type for BTA_AV_API_ENABLE_EVT */
 222 typedef struct {
 223   BT_HDR_RIGID hdr;
 224   tBTA_AV_CBACK* p_cback;
 225   tBTA_AV_FEAT features;
 226 } tBTA_AV_API_ENABLE;
 227
 228 /* data type for BTA_AV_API_REGISTER_EVT */
 229 typedef struct {
 230   BT_HDR_RIGID hdr;
 231   char p_service_name[BTA_SERVICE_NAME_LEN + 1];
 232   uint8_t app_id;
 233   tBTA_AV_SINK_DATA_CBACK* p_app_sink_data_cback;
 234   uint16_t service_uuid;
 235 } tBTA_AV_API_REG;
 236
 237 typedef enum : uint8_t {
 238   BTA_AV_RS_NONE, /* straight API call */
 239   BTA_AV_RS_OK,   /* the role switch result - successful */
 240   BTA_AV_RS_FAIL, /* the role switch result - failed */
 241   BTA_AV_RS_DONE  /* the role switch is done - continue */
 242 } tBTA_AV_RS_RES;
 243
 244 inline std::string bta_av_role_switch_result_text(
 245     const tBTA_AV_RS_RES& result) {
 246   switch (result) {
 247     CASE_RETURN_TEXT(BTA_AV_RS_NONE);
 248     CASE_RETURN_TEXT(BTA_AV_RS_OK);
 249     CASE_RETURN_TEXT(BTA_AV_RS_FAIL);
 250     CASE_RETURN_TEXT(BTA_AV_RS_DONE);
 251     default:
 252       return std::string("UNKNOWN");
 253   }
 254 }
 255
 256 /* data type for BTA_AV_API_OPEN_EVT */
 257 typedef struct {
 258   BT_HDR_RIGID hdr;
 259   RawAddress bd_addr;
 260   bool use_rc;
 261   tBTA_AV_RS_RES switch_res;
 262   uint16_t uuid; /* uuid of initiator */
 263 } tBTA_AV_API_OPEN;
 264
 265 /* data type for BTA_AV_API_STOP_EVT */
 266 typedef struct {
 267   BT_HDR_RIGID hdr;
 268   bool suspend;
 269   bool flush;
 270   bool reconfig_stop;  // True if the stream is stopped for reconfiguration
 271 } tBTA_AV_API_STOP;
 272
 273 /* data type for BTA_AV_API_DISCONNECT_EVT */
 274 typedef struct {
 275   BT_HDR_RIGID hdr;
 276 } tBTA_AV_API_DISCNT;
 277
 278 /* data type for BTA_AV_API_PROTECT_REQ_EVT */
 279 typedef struct {
 280   BT_HDR_RIGID hdr;
 281   uint8_t* p_data;
 282   uint16_t len;
 283 } tBTA_AV_API_PROTECT_REQ;
 284
 285 /* data type for BTA_AV_API_PROTECT_RSP_EVT */
 286 typedef struct {
 287   BT_HDR_RIGID hdr;
 288   uint8_t* p_data;
 289   uint16_t len;
 290   uint8_t error_code;
 291 } tBTA_AV_API_PROTECT_RSP;
 292
 293 /* data type for BTA_AV_API_REMOTE_CMD_EVT */
 294 typedef struct {
 295   BT_HDR_RIGID hdr;
 296   tAVRC_MSG_PASS msg;
 297   uint8_t label;
 298 } tBTA_AV_API_REMOTE_CMD;
 299
 300 /* data type for BTA_AV_API_VENDOR_CMD_EVT and RSP */
 301 typedef struct {
 302   BT_HDR_RIGID hdr;
 303   tAVRC_MSG_VENDOR msg;
 304   uint8_t label;
 305 } tBTA_AV_API_VENDOR;
 306
 307 /* data type for BTA_AV_API_RC_OPEN_EVT */
 308 typedef struct {
 309   BT_HDR_RIGID hdr;
 310 } tBTA_AV_API_OPEN_RC;
 311
 312 /* data type for BTA_AV_API_RC_CLOSE_EVT */
 313 typedef struct {
 314   BT_HDR_RIGID hdr;
 315 } tBTA_AV_API_CLOSE_RC;
 316
 317 /* data type for BTA_AV_API_META_RSP_EVT */
 318 typedef struct {
 319   BT_HDR_RIGID hdr;
 320   bool is_rsp;
 321   uint8_t label;
 322   tBTA_AV_CODE rsp_code;
 323   BT_HDR* p_pkt;
 324 } tBTA_AV_API_META_RSP;
 325
 326 /* data type for BTA_AV_API_RECONFIG_EVT */
 327 typedef struct {
 328   BT_HDR_RIGID hdr;
 329   uint8_t codec_info[AVDT_CODEC_SIZE]; /* codec configuration */
 330   uint8_t* p_protect_info;
 331   uint8_t num_protect;
 332   bool suspend;
 333   uint8_t sep_info_idx;
 334 } tBTA_AV_API_RCFG;
 335
 336 /* data type for BTA_AV_CI_SETCONFIG_OK_EVT and BTA_AV_CI_SETCONFIG_FAIL_EVT */
 337 typedef struct {
 338   BT_HDR_RIGID hdr;
 339   tBTA_AV_HNDL hndl;
 340   uint8_t err_code;
 341   uint8_t category;
 342   uint8_t num_seid;
 343   uint8_t* p_seid;
 344   bool recfg_needed;
 345   uint8_t avdt_handle; /* local sep type for which this stream will be set up */
 346 } tBTA_AV_CI_SETCONFIG;
 347
 348 /* data type for all stream events from AVDTP */
 349 typedef struct {
 350   BT_HDR_RIGID hdr;
 351   AvdtpSepConfig cfg; /* configuration/capabilities parameters */
 352   tAVDT_CTRL msg;  /* AVDTP callback message parameters */
 353   RawAddress bd_addr; /* bd address */
 354   uint8_t scb_index;
 355   uint8_t handle;
 356   uint8_t avdt_event;
 357   bool initiator; /* true, if local device initiates the SUSPEND */
 358 } tBTA_AV_STR_MSG;
 359
 360 /* data type for BTA_AV_AVRC_MSG_EVT */
 361 typedef struct {
 362   BT_HDR_RIGID hdr;
 363   tAVRC_MSG msg;
 364   uint8_t handle;
 365   uint8_t label;
 366   uint8_t opcode;
 367 } tBTA_AV_RC_MSG;
 368
 369 /* data type for BTA_AV_AVRC_OPEN_EVT, BTA_AV_AVRC_CLOSE_EVT */
 370 typedef struct {
 371   BT_HDR_RIGID hdr;
 372   RawAddress peer_addr;
 373   uint8_t handle;
 374 } tBTA_AV_RC_CONN_CHG;
 375
 376 /* data type for BTA_AV_CONN_CHG_EVT */
 377 typedef struct {
 378   BT_HDR_RIGID hdr;
 379   RawAddress peer_addr;
 380   bool is_up;
 381 } tBTA_AV_CONN_CHG;
 382
 383 /* data type for BTA_AV_ROLE_CHANGE_EVT */
 384 typedef struct {
 385   BT_HDR_RIGID hdr;
 386   uint8_t new_role;
 387   uint8_t hci_status;
 388 } tBTA_AV_ROLE_RES;
 389
 390 /* data type for BTA_AV_SDP_DISC_OK_EVT */
 391 typedef struct {
 392   BT_HDR_RIGID hdr;
 393 } tBTA_AV_SDP_RES;
 394
 395 /* data type for BTA_AV_API_OFFLOAD_RSP_EVT */
 396 typedef struct {
 397   BT_HDR_RIGID hdr;
 398   tBTA_AV_STATUS status;
 399 } tBTA_AV_API_STATUS_RSP;
 400
 401 /* type for SEP control block */
 402 typedef struct {
 403   uint8_t av_handle;                   /* AVDTP handle */
 404   uint8_t tsep;                        /* SEP type of local SEP */
 405   uint8_t codec_info[AVDT_CODEC_SIZE]; /* Codec info */
 406   tBTA_AV_SINK_DATA_CBACK*
 407       p_app_sink_data_cback; /* Sink application callback for media packets */
 408 } tBTA_AV_SEP;
 409
 410 enum : uint8_t {
 411   /* initiator/acceptor role for adaption */
 412   BTA_AV_ROLE_AD_INT = 0x00, /* initiator */
 413   BTA_AV_ROLE_AD_ACP = 0x01, /* acceptor */
 414
 415   /* initiator/acceptor signaling roles */
 416   BTA_AV_ROLE_START_ACP = 0x00,
 417   BTA_AV_ROLE_START_INT = 0x10, /* do not change this value */
 418
 419   BTA_AV_ROLE_SUSPEND = 0x20,     /* suspending on start */
 420   BTA_AV_ROLE_SUSPEND_OPT = 0x40, /* Suspend on Start option is set */
 421 };
 422 typedef uint8_t tBTA_AV_ROLE;
 423
 424 /* union of all event datatypes */
 425 union tBTA_AV_DATA {
 426   BT_HDR_RIGID hdr;
 427   tBTA_AV_API_ENABLE api_enable;
 428   tBTA_AV_API_REG api_reg;
 429   tBTA_AV_API_OPEN api_open;
 430   tBTA_AV_API_STOP api_stop;
 431   tBTA_AV_API_DISCNT api_discnt;
 432   tBTA_AV_API_PROTECT_REQ api_protect_req;
 433   tBTA_AV_API_PROTECT_RSP api_protect_rsp;
 434   tBTA_AV_API_REMOTE_CMD api_remote_cmd;
 435   tBTA_AV_API_VENDOR api_vendor;
 436   tBTA_AV_API_RCFG api_reconfig;
 437   tBTA_AV_CI_SETCONFIG ci_setconfig;
 438   tBTA_AV_STR_MSG str_msg;
 439   tBTA_AV_RC_MSG rc_msg;
 440   tBTA_AV_RC_CONN_CHG rc_conn_chg;
 441   tBTA_AV_CONN_CHG conn_chg;
 442   tBTA_AV_ROLE_RES role_res;
 443   tBTA_AV_SDP_RES sdp_res;
 444   tBTA_AV_API_META_RSP api_meta_rsp;
 445   tBTA_AV_API_STATUS_RSP api_status_rsp;
 446 };
 447
 448 typedef union {
 449   tBTA_AV_API_OPEN open; /* used only before open and role switch
 450                             is needed on another AV channel */
 451 } tBTA_AV_Q_INFO;
 452
 453 #define BTA_AV_Q_TAG_OPEN 0x01   /* after API_OPEN, before STR_OPENED */
 454 #define BTA_AV_Q_TAG_START 0x02  /* before start sending media packets */
 455 #define BTA_AV_Q_TAG_STREAM 0x03 /* during streaming */
 456
 457 #define BTA_AV_WAIT_ACP_CAPS_ON 0x01 /* retriving the peer capabilities */
 458 #define BTA_AV_WAIT_ACP_CAPS_STARTED \
 459   0x02 /* started while retriving peer capabilities */
 460 #define BTA_AV_WAIT_ROLE_SW_RES_OPEN \
 461   0x04 /* waiting for role switch result after API_OPEN, before STR_OPENED */
 462 #define BTA_AV_WAIT_ROLE_SW_RES_START \
 463   0x08 /* waiting for role switch result before streaming */
 464 #define BTA_AV_WAIT_ROLE_SW_STARTED \
 465   0x10 /* started while waiting for role switch result */
 466 #define BTA_AV_WAIT_ROLE_SW_RETRY 0x20 /* set when retry on timeout */
 467 #define BTA_AV_WAIT_CHECK_RC \
 468   0x40 /* set when the timer is used by role switch */
 469 #define BTA_AV_WAIT_ROLE_SW_FAILED 0x80 /* role switch failed */
 470
 471 #define BTA_AV_WAIT_ROLE_SW_BITS                                  \
 472   (BTA_AV_WAIT_ROLE_SW_RES_OPEN | BTA_AV_WAIT_ROLE_SW_RES_START | \
 473    BTA_AV_WAIT_ROLE_SW_STARTED | BTA_AV_WAIT_ROLE_SW_RETRY)
 474
 475 /* Bitmap for collision, coll_mask */
 476 #define BTA_AV_COLL_INC_TMR \
 477   0x01 /* Timer is running for incoming L2C connection */
 478 #define BTA_AV_COLL_API_CALLED \
 479   0x02 /* API open was called while incoming timer is running */
 480
 481 /* type for AV stream control block */
 482 // TODO: This should be renamed and changed to a proper class
 483 struct tBTA_AV_SCB final {
 484  public:
 485   const tBTA_AV_CO_FUNCTS* p_cos; /* the associated callout functions */
 486   bool sdp_discovery_started; /* variable to determine whether SDP is started */
 487   tBTA_AV_SEP seps[BTAV_A2DP_CODEC_INDEX_MAX];
 488   AvdtpSepConfig peer_cap; /* buffer used for get capabilities */
 489   list_t* a2dp_list; /* used for audio channels only */
 490   tBTA_AV_Q_INFO q_info;
 491   tAVDT_SEP_INFO sep_info[BTA_AV_NUM_SEPS]; /* stream discovery results */
 492   AvdtpSepConfig cfg;                       /* local SEP configuration */
 493   alarm_t* avrc_ct_timer;                   /* delay timer for AVRC CT */
 494   alarm_t* link_signalling_timer;
 495   alarm_t*
 496       accept_signalling_timer; /* timer to monitor signalling when accepting */
 497   uint16_t l2c_cid;                         /* L2CAP channel ID */
 498   uint16_t stream_mtu;                      /* MTU of stream */
 499   uint8_t media_type;         /* Media type: AVDT_MEDIA_TYPE_* */
 500   bool cong;                  /* true if AVDTP congested */
 501   tBTA_AV_STATUS open_status; /* open failure status */
 502   tBTA_AV_CHNL chnl;          /* the channel: audio/video */
 503   tBTA_AV_HNDL hndl;          /* the handle: ((hdi + 1)|chnl) */
 504   uint16_t cur_psc_mask;      /* Protocol service capabilities mask for current
 505                                  connection */
 506   uint8_t avdt_handle;        /* AVDTP handle */
 507   uint8_t hdi;                /* the index to SCB[] */
 508   uint8_t num_seps;           /* number of seps returned by stream discovery */
 509   uint8_t num_disc_snks;      /* number of discovered snks */
 510   uint8_t num_disc_srcs;      /* number of discovered srcs */
 511   uint8_t sep_info_idx;       /* current index into sep_info */
 512   uint8_t sep_idx;            /* current index into local seps[] */
 513   uint8_t rcfg_idx;           /* reconfig requested index into sep_info */
 514   uint8_t state;              /* state machine state */
 515   uint8_t avdt_label;         /* AVDTP label */
 516   uint8_t app_id;             /* application id */
 517   uint8_t num_recfg;          /* number of reconfigure sent */
 518   uint8_t role;
 519   uint8_t l2c_bufs;  /* the number of buffers queued to L2CAP */
 520   uint8_t rc_handle; /* connected AVRCP handle */
 521   bool use_rc;       /* true if AVRCP is allowed */
 522   bool started;      /* true if stream started */
 523   bool use_rtp_header_marker_bit; /* true if the encoded data packets have RTP
 524                                    * headers, and the Marker bit in the header
 525                                    * is set according to RFC 6416 */
 526   uint8_t
 527       co_started;    /* non-zero, if stream started from call-out perspective */
 528   bool recfg_sup;    /* true if the first attempt to reconfigure the stream was
 529                         successfull, else False if command fails */
 530   bool suspend_sup;  /* true if Suspend stream is supported, else false if
 531                         suspend command fails */
 532   bool deregistering; /* true if deregistering */
 533   bool sco_suspend;  /* true if SUSPEND is issued automatically for SCO */
 534   uint8_t coll_mask; /* Mask to check incoming and outgoing collision */
 535   tBTA_AV_API_OPEN open_api; /* Saved OPEN api message */
 536   uint8_t wait;  /* set 0x1, when getting Caps as ACP, set 0x2, when started */
 537   uint8_t q_tag; /* identify the associated q_info union member */
 538   bool no_rtp_header; /* true if add no RTP header */
 539   uint16_t uuid_int; /*intended UUID of Initiator to connect to */
 540
 541   /**
 542    * Called to setup the state when connected to a peer.
 543    *
 544    * @param peer_address the peer address
 545    */
 546   void OnConnected(const RawAddress& peer_address);
 547
 548   /**
 549    * Called to clear the state when disconnected from a peer.
 550    *
 551    */
 552   void OnDisconnected();
 553
 554   /**
 555    * Get the peer address.
 556    */
 557   const RawAddress& PeerAddress() const { return peer_address_; }
 558
 559   /**
 560    * Get the AVDTP version of the peer device.
 561    */
 562   uint16_t AvdtpVersion() const { return avdtp_version_; }
 563
 564   /**
 565    * Set the AVDTP version of the peer device.
 566    *
 567    * @param avdtp_version the AVDTP version to use
 568    */
 569   void SetAvdtpVersion(uint16_t avdtp_version);
 570
 571   /**
 572    * Check whether the entry is assigned and currenty used.
 573    *
 574    * @return true if the entry is assigned and currently used
 575    */
 576   bool IsAssigned() const { return !peer_address_.IsEmpty(); }
 577
 578  private:
 579   RawAddress peer_address_;  // Peer address
 580   uint16_t avdtp_version_;   // The AVDTP version of the peer device
 581 };
 582
 583 #define BTA_AV_RC_ROLE_MASK 0x10
 584 #define BTA_AV_RC_ROLE_INT 0x00
 585 #define BTA_AV_RC_ROLE_ACP 0x10
 586
 587 #define BTA_AV_RC_CONN_MASK 0x20
 588
 589 /* type for AV RCP control block */
 590 /* index to this control block is the rc handle */
 591 typedef struct {
 592   uint8_t status;
 593   uint8_t handle;
 594   uint8_t shdl;               /* stream handle (hdi + 1) */
 595   uint8_t lidx;               /* (index+1) to LCB */
 596   tBTA_AV_FEAT peer_features; /* peer features mask */
 597   uint16_t cover_art_psm;     /* BIP PSM for cover art feature */
 598 } tBTA_AV_RCB;
 599 #define BTA_AV_NUM_RCB (BTA_AV_NUM_STRS + 2)
 600
 601 enum { BTA_AV_LCB_FREE, BTA_AV_LCB_FIND };
 602
 603 /* type for AV ACL Link control block */
 604 typedef struct {
 605   RawAddress addr;  /* peer BD address */
 606   uint8_t conn_msk; /* handle mask of connected stream handle */
 607   uint8_t lidx;     /* index + 1 */
 608 } tBTA_AV_LCB;
 609
 610 /* type for stream state machine action functions */
 611 typedef void (*tBTA_AV_SACT)(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 612
 613 /* type for AV control block */
 614 typedef struct {
 615   tBTA_AV_SCB* p_scb[BTA_AV_NUM_STRS];   /* stream control block */
 616   tSDP_DISCOVERY_DB* p_disc_db;          /* pointer to discovery database */
 617   tBTA_AV_CBACK* p_cback;                /* application callback function */
 618   tBTA_AV_RCB rcb[BTA_AV_NUM_RCB];       /* RCB control block */
 619   tBTA_AV_LCB lcb[BTA_AV_NUM_LINKS + 1]; /* link control block */
 620   uint32_t sdp_a2dp_handle;     /* SDP record handle for audio src */
 621   uint32_t sdp_a2dp_snk_handle; /* SDP record handle for audio snk */
 622   tBTA_AV_FEAT features;        /* features mask */
 623   tBTA_SEC sec_mask;            /* security mask */
 624   tBTA_AV_HNDL handle;          /* the handle for SDP activity */
 625   bool disabling;               /* true if api disabled called */
 626   uint8_t enabling_attempts;    // counter to wait for previous disabling
 627   uint8_t
 628       disc; /* (hdi+1) or (rc_handle|BTA_AV_CHNL_MSK) if p_disc_db is in use */
 629   uint8_t state;          /* state machine state */
 630   uint8_t conn_audio;     /* handle mask of connected audio channels */
 631   uint8_t conn_lcb;       /* index mask of used LCBs */
 632   uint8_t audio_open_cnt; /* number of connected audio channels */
 633   uint8_t reg_audio;      /* handle mask of registered audio channels */
 634   uint8_t rc_acp_handle;
 635   uint8_t rc_acp_idx; /* (index + 1) to RCB */
 636   uint8_t rs_idx;    /* (index + 1) to SCB for the one waiting for RS on open */
 637   bool sco_occupied; /* true if SCO is being used or call is in progress */
 638   uint16_t offload_start_pending_acl_hdl;
 639   uint16_t offload_started_acl_hdl;
 640 } tBTA_AV_CB;
 641
 642 // total attempts are half seconds
 643 constexpr uint32_t kEnablingAttemptsIntervalMs = 100;
 644 constexpr uint8_t kEnablingAttemptsCountMaximum = 5;
 645
 646 // A2DP offload VSC parameters
 647 class tBT_A2DP_OFFLOAD {
 648  public:
 649   uint32_t codec_type;            /* codec types ex: SBC/AAC/LDAC/APTx */
 650   uint16_t max_latency;           /* maximum latency */
 651   std::array<uint8_t, 2> scms_t_enable; /* SCMS-T enable */
 652   uint32_t sample_rate;           /* Sample rates ex: 44.1/48/88.2/96 Khz */
 653   uint8_t bits_per_sample;        /* bits per sample ex: 16/24/32 */
 654   uint8_t ch_mode;                /* None:0 Left:1 Right:2 */
 655   uint32_t encoded_audio_bitrate; /* encoder audio bitrates */
 656   uint16_t acl_hdl;               /* connection handle */
 657   uint16_t l2c_rcid;              /* l2cap channel id */
 658   uint16_t mtu;                   /* MTU size */
 659   uint8_t codec_info[32];         /* Codec specific information */
 660 };
 661
 662 /* Vendor OFFLOAD VSC */
 663 #define HCI_VSQC_CONTROLLER_A2DP_OPCODE 0x000A
 664
 665 #define VS_HCI_A2DP_OFFLOAD_START 0x01
 666 #define VS_HCI_A2DP_OFFLOAD_STOP 0x02
 667 /*****************************************************************************
 668  *  Global data
 669  ****************************************************************************/
 670
 671 /* control block declaration */
 672 extern tBTA_AV_CB bta_av_cb;
 673
 674 /* config struct */
 675 extern const tBTA_AV_CFG* p_bta_av_cfg;
 676 extern const tBTA_AV_CFG bta_avk_cfg;
 677 extern const tBTA_AV_CFG bta_av_cfg;
 678 extern const tBTA_AV_CFG bta_av_cfg_compatibility;
 679
 680 /* rc id config struct */
 681 extern uint16_t* p_bta_av_rc_id;
 682 extern uint16_t* p_bta_av_rc_id_ac;
 683
 684 extern const tBTA_AV_CO_FUNCTS bta_av_a2dp_cos;
 685 extern void bta_av_sink_data_cback(uint8_t handle, BT_HDR* p_pkt,
 686                                    uint32_t time_stamp, uint8_t m_pt);
 687
 688 /*****************************************************************************
 689  *  Function prototypes
 690  ****************************************************************************/
 691 /* utility functions */
 692 extern tBTA_AV_SCB* bta_av_hndl_to_scb(uint16_t handle);
 693 tBTA_AV_SCB* bta_av_addr_to_scb(const RawAddress& bd_addr);
 694 extern bool bta_av_chk_start(tBTA_AV_SCB* p_scb);
 695 extern void bta_av_restore_switch(void);
 696 extern void bta_av_conn_cback(uint8_t handle, const RawAddress& bd_addr,
 697                               uint8_t event, tAVDT_CTRL* p_data,
 698                               uint8_t scb_index);
 699 extern uint8_t bta_av_rc_create(tBTA_AV_CB* p_cb, uint8_t role, uint8_t shdl,
 700                                 uint8_t lidx);
 701 extern void bta_av_stream_chg(tBTA_AV_SCB* p_scb, bool started);
 702 extern bool bta_av_is_scb_opening(tBTA_AV_SCB* p_scb);
 703 extern bool bta_av_is_scb_incoming(tBTA_AV_SCB* p_scb);
 704 extern void bta_av_set_scb_sst_init(tBTA_AV_SCB* p_scb);
 705 extern bool bta_av_is_scb_init(tBTA_AV_SCB* p_scb);
 706 extern void bta_av_set_scb_sst_incoming(tBTA_AV_SCB* p_scb);
 707 extern tBTA_AV_LCB* bta_av_find_lcb(const RawAddress& addr, uint8_t op);
 708 extern const char* bta_av_sst_code(uint8_t state);
 709 extern void bta_av_free_scb(tBTA_AV_SCB* p_scb);
 710
 711 /* main functions */
 712 extern void bta_av_api_deregister(tBTA_AV_DATA* p_data);
 713 extern void bta_av_dup_audio_buf(tBTA_AV_SCB* p_scb, BT_HDR* p_buf);
 714 extern void bta_av_sm_execute(tBTA_AV_CB* p_cb, uint16_t event,
 715                               tBTA_AV_DATA* p_data);
 716 extern void bta_av_ssm_execute(tBTA_AV_SCB* p_scb, uint16_t event,
 717                                tBTA_AV_DATA* p_data);
 718 extern bool bta_av_hdl_event(BT_HDR_RIGID* p_msg);
 719 extern const char* bta_av_evt_code(uint16_t evt_code);
 720 extern bool bta_av_switch_if_needed(tBTA_AV_SCB* p_scb);
 721 extern bool bta_av_link_role_ok(tBTA_AV_SCB* p_scb, uint8_t bits);
 722
 723 /* nsm action functions */
 724 extern void bta_av_api_disconnect(tBTA_AV_DATA* p_data);
 725 extern void bta_av_sig_chg(tBTA_AV_DATA* p_data);
 726 extern void bta_av_signalling_timer(tBTA_AV_DATA* p_data);
 727 extern void bta_av_rc_disc_done(tBTA_AV_DATA* p_data);
 728 extern void bta_av_rc_closed(tBTA_AV_DATA* p_data);
 729 extern void bta_av_rc_browse_opened(tBTA_AV_DATA* p_data);
 730 extern void bta_av_rc_browse_closed(tBTA_AV_DATA* p_data);
 731 extern void bta_av_rc_disc(uint8_t disc);
 732 extern void bta_av_conn_chg(tBTA_AV_DATA* p_data);
 733 extern void bta_av_dereg_comp(tBTA_AV_DATA* p_data);
 734
 735 /* sm action functions */
 736 extern void bta_av_disable(tBTA_AV_CB* p_cb, tBTA_AV_DATA* p_data);
 737 extern void bta_av_rc_opened(tBTA_AV_CB* p_cb, tBTA_AV_DATA* p_data);
 738 extern void bta_av_rc_remote_cmd(tBTA_AV_CB* p_cb, tBTA_AV_DATA* p_data);
 739 extern void bta_av_rc_vendor_cmd(tBTA_AV_CB* p_cb, tBTA_AV_DATA* p_data);
 740 extern void bta_av_rc_vendor_rsp(tBTA_AV_CB* p_cb, tBTA_AV_DATA* p_data);
 741 extern void bta_av_rc_msg(tBTA_AV_CB* p_cb, tBTA_AV_DATA* p_data);
 742 extern void bta_av_rc_close(tBTA_AV_CB* p_cb, tBTA_AV_DATA* p_data);
 743 extern void bta_av_rc_meta_rsp(tBTA_AV_CB* p_cb, tBTA_AV_DATA* p_data);
 744 extern void bta_av_rc_free_rsp(tBTA_AV_CB* p_cb, tBTA_AV_DATA* p_data);
 745 extern void bta_av_rc_free_browse_msg(tBTA_AV_CB* p_cb, tBTA_AV_DATA* p_data);
 746
 747 extern tBTA_AV_RCB* bta_av_get_rcb_by_shdl(uint8_t shdl);
 748 extern void bta_av_del_rc(tBTA_AV_RCB* p_rcb);
 749
 750 extern void bta_av_proc_stream_evt(uint8_t handle, const RawAddress& bd_addr,
 751                                    uint8_t event, tAVDT_CTRL* p_data,
 752                                    uint8_t scb_index);
 753
 754 /* ssm action functions */
 755 extern void bta_av_do_disc_a2dp(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 756 extern void bta_av_cleanup(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 757 extern void bta_av_free_sdb(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 758 extern void bta_av_config_ind(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 759 extern void bta_av_disconnect_req(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 760 extern void bta_av_security_req(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 761 extern void bta_av_security_rsp(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 762 extern void bta_av_setconfig_rsp(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 763 extern void bta_av_str_opened(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 764 extern void bta_av_security_ind(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 765 extern void bta_av_security_cfm(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 766 extern void bta_av_do_close(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 767 extern void bta_av_connect_req(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 768 extern void bta_av_sdp_failed(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 769 extern void bta_av_disc_results(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 770 extern void bta_av_disc_res_as_acp(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 771 extern void bta_av_open_failed(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 772 extern void bta_av_getcap_results(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 773 extern void bta_av_setconfig_rej(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 774 extern void bta_av_discover_req(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 775 extern void bta_av_conn_failed(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 776 extern void bta_av_do_start(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 777 extern void bta_av_str_stopped(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 778 extern void bta_av_reconfig(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 779 extern void bta_av_data_path(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 780 extern void bta_av_start_ok(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 781 extern void bta_av_start_failed(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 782 extern void bta_av_str_closed(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 783 extern void bta_av_clr_cong(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 784 extern void bta_av_suspend_cfm(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 785 extern void bta_av_rcfg_str_ok(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 786 extern void bta_av_rcfg_failed(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 787 extern void bta_av_rcfg_connect(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 788 extern void bta_av_rcfg_discntd(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 789 extern void bta_av_suspend_cont(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 790 extern void bta_av_rcfg_cfm(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 791 extern void bta_av_rcfg_open(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 792 extern void bta_av_security_rej(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 793 extern void bta_av_open_rc(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 794 extern void bta_av_chk_2nd_start(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 795 extern void bta_av_save_caps(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 796 extern void bta_av_rej_conn(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 797 extern void bta_av_rej_conn(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 798 extern void bta_av_set_use_rc(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 799 extern void bta_av_cco_close(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 800 extern void bta_av_switch_role(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 801 extern void bta_av_role_res(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 802 extern void bta_av_delay_co(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 803 extern void bta_av_open_at_inc(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 804 extern void bta_av_offload_req(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 805 extern void bta_av_offload_rsp(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 806 extern void bta_av_vendor_offload_stop(void);
 807 extern void bta_av_st_rc_timer(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data);
 808
 809 #endif /* BTA_AV_INT_H */