You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
948 lines
37 KiB
948 lines
37 KiB
/******************************************************************************
|
|
*
|
|
* Copyright 2002-2012 Broadcom Corporation
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at:
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
******************************************************************************/
|
|
|
|
/******************************************************************************
|
|
*
|
|
* This interface file contains the interface to the Audio Video
|
|
* Distribution Transport Protocol (AVDTP).
|
|
*
|
|
******************************************************************************/
|
|
#ifndef AVDT_API_H
|
|
#define AVDT_API_H
|
|
|
|
#include <base/strings/stringprintf.h>
|
|
#include <cstdint>
|
|
#include <string>
|
|
|
|
#include "bt_target.h"
|
|
#include "bt_types.h"
|
|
#include "osi/include/log.h"
|
|
|
|
/*****************************************************************************
|
|
* Constants
|
|
****************************************************************************/
|
|
#define AVDT_VERSION_1_3 0x0103
|
|
|
|
#define AVDTP_VERSION_CONFIG_KEY "AvdtpVersion"
|
|
|
|
/* Maximum size in bytes of the codec capabilities information element. */
|
|
#define AVDT_CODEC_SIZE 20
|
|
|
|
/* API function return value result codes. */
|
|
typedef enum : uint16_t {
|
|
AVDT_SUCCESS = 0, /* Function successful */
|
|
AVDT_BAD_PARAMS = 1, /* Invalid parameters */
|
|
AVDT_NO_RESOURCES = 2, /* Not enough resources */
|
|
AVDT_BAD_HANDLE = 3, /* Bad handle */
|
|
AVDT_BUSY = 4, /* A procedure is already in progress */
|
|
AVDT_WRITE_FAIL = 5, /* Write failed */
|
|
} tAVDT_RESULT;
|
|
|
|
inline tAVDT_RESULT ToAvdtResult(uint16_t result) {
|
|
ASSERT_LOG(result <= AVDT_WRITE_FAIL, "Unable to convert illegal result:%hu",
|
|
result);
|
|
return static_cast<tAVDT_RESULT>(result);
|
|
}
|
|
|
|
#define CASE_RETURN_TEXT(code) \
|
|
case code: \
|
|
return #code
|
|
|
|
inline std::string avdt_result_text(const tAVDT_RESULT& result) {
|
|
switch (result) {
|
|
CASE_RETURN_TEXT(AVDT_SUCCESS);
|
|
CASE_RETURN_TEXT(AVDT_BAD_PARAMS);
|
|
CASE_RETURN_TEXT(AVDT_NO_RESOURCES);
|
|
CASE_RETURN_TEXT(AVDT_BAD_HANDLE);
|
|
CASE_RETURN_TEXT(AVDT_BUSY);
|
|
CASE_RETURN_TEXT(AVDT_WRITE_FAIL);
|
|
default:
|
|
return base::StringPrintf("UNKNOWN[%hu]", result);
|
|
}
|
|
}
|
|
#undef CASE_RETURN_TEXT
|
|
|
|
/* The index to access the codec type in codec_info[]. */
|
|
#define AVDT_CODEC_TYPE_INDEX 2
|
|
|
|
/* The size in bytes of a Adaptation Layer header. */
|
|
#define AVDT_AL_HDR_SIZE 3
|
|
|
|
/* The size in bytes of a media packet header. */
|
|
#define AVDT_MEDIA_HDR_SIZE 12
|
|
|
|
/* The handle is used when reporting MULTI_AV specific events */
|
|
#define AVDT_MULTI_AV_HANDLE 0xFF
|
|
|
|
/* The number of bytes needed by the protocol stack for the protocol headers
|
|
* of a media packet. This is the size of the media packet header, the
|
|
* L2CAP packet header and HCI header.
|
|
*/
|
|
#define AVDT_MEDIA_OFFSET 23
|
|
|
|
/* The marker bit is used by the application to mark significant events such
|
|
* as frame boundaries in the data stream. This constant is used to check or
|
|
* set the marker bit in the m_pt parameter of an AVDT_WriteReq()
|
|
* or AVDT_DATA_IND_EVT.
|
|
*/
|
|
#define AVDT_MARKER_SET 0x80
|
|
|
|
#define MAX_2MBPS_AVDTP_MTU 663 // 2DH5 MTU=679, -12 for AVDTP, -4 for L2CAP
|
|
#define MAX_3MBPS_AVDTP_MTU 1005 // 3DH5 MTU=1021, -12 for AVDTP, -4 for L2CAP
|
|
|
|
/* SEP Type. This indicates the stream endpoint type. */
|
|
#define AVDT_TSEP_SRC 0 /* Source SEP */
|
|
#define AVDT_TSEP_SNK 1 /* Sink SEP */
|
|
#define AVDT_TSEP_INVALID 3 /* Invalid SEP */
|
|
inline const std::string peer_stream_endpoint_text(int type) {
|
|
switch (type) {
|
|
case AVDT_TSEP_SRC:
|
|
return std::string("Source");
|
|
case AVDT_TSEP_SNK:
|
|
return std::string("Sink");
|
|
default:
|
|
return std::string("Invalid");
|
|
}
|
|
}
|
|
|
|
/* initiator/acceptor role for adaption */
|
|
#define AVDT_INT 0 /* initiator */
|
|
#define AVDT_ACP 1 /* acceptor */
|
|
|
|
/* Media Type of the stream endpoint */
|
|
/* The value does not include the reserved 4-bit LSBs field */
|
|
#define AVDT_MEDIA_TYPE_AUDIO 0 /* Audio SEP */
|
|
#define AVDT_MEDIA_TYPE_VIDEO 1 /* Video SEP */
|
|
#define AVDT_MEDIA_TYPE_MULTI 2 /* Multimedia SEP */
|
|
|
|
/* for reporting packets (packet types) */
|
|
#define AVDT_RTCP_PT_SR 200 /* SR (Sender Report) */
|
|
#define AVDT_RTCP_PT_RR 201 /* RR (Receiver Report) */
|
|
#define AVDT_RTCP_PT_SDES 202 /* SDES (Source Description) */
|
|
typedef uint8_t AVDT_REPORT_TYPE;
|
|
|
|
#define AVDT_RTCP_SDES_CNAME 1 /* SDES item CNAME */
|
|
#ifndef AVDT_MAX_CNAME_SIZE
|
|
#define AVDT_MAX_CNAME_SIZE 28
|
|
#endif
|
|
|
|
/* Protocol service capabilities. This indicates the protocol service
|
|
* capabilities of a stream endpoint. This value is a mask.
|
|
* Multiple values can be combined with a bitwise OR.
|
|
*/
|
|
#define AVDT_PSC_TRANS (1 << 1) /* Media transport */
|
|
#define AVDT_PSC_REPORT (1 << 2) /* Reporting */
|
|
#define AVDT_PSC_RECOV (1 << 3) /* Recovery */
|
|
#define AVDT_PSC_HDRCMP (1 << 5) /* Header compression */
|
|
#define AVDT_PSC_MUX (1 << 6) /* Multiplexing */
|
|
#define AVDT_PSC_DELAY_RPT (1 << 8) /* Delay Report */
|
|
|
|
/* Recovery type. This indicates the recovery type. */
|
|
#define AVDT_RECOV_RFC2733 1 /* RFC2733 recovery */
|
|
|
|
/* Header compression capabilities. This indicates the header compression
|
|
* capabilities. This value is a mask. Multiple values can be combined
|
|
* with a bitwise OR.
|
|
*/
|
|
#define AVDT_HDRCMP_MEDIA (1 << 5) /* Available for media packets */
|
|
#define AVDT_HDRCMP_RECOV (1 << 6) /* Available for recovery packets */
|
|
#define AVDT_HDRCMP_BACKCH (1 << 7) /* Back channel supported */
|
|
|
|
/* Multiplexing capabilities mask. */
|
|
#define AVDT_MUX_FRAG (1 << 7) /* Allow Adaptation Layer Fragmentation */
|
|
|
|
/* Application service category. This indicates the application
|
|
* service category.
|
|
*/
|
|
#define AVDT_ASC_PROTECT 4 /* Content protection */
|
|
#define AVDT_ASC_CODEC 7 /* Codec */
|
|
|
|
/* the content protection IDs assigned by BT SIG */
|
|
#define AVDT_CP_SCMS_T_ID 0x0002
|
|
#define AVDT_CP_DTCP_ID 0x0001
|
|
|
|
#define AVDT_CP_LOSC 2
|
|
#define AVDT_CP_INFO_LEN 3
|
|
|
|
#define AVDT_CP_SCMS_COPY_MASK 3
|
|
#define AVDT_CP_SCMS_COPY_FREE 2
|
|
#define AVDT_CP_SCMS_COPY_ONCE 1
|
|
#define AVDT_CP_SCMS_COPY_NEVER 0
|
|
|
|
/* Error codes. The following are error codes defined in the AVDTP and GAVDP
|
|
* specifications. These error codes communicate protocol errors between
|
|
* AVDTP and the application. More detailed descriptions of the error codes
|
|
* and their appropriate use can be found in the AVDTP and GAVDP specifications.
|
|
* These error codes are unrelated to the result values returned by the
|
|
* AVDTP API functions.
|
|
*/
|
|
/* Bad packet header format */
|
|
#define AVDT_ERR_HEADER 0x01
|
|
/* Bad packet length */
|
|
#define AVDT_ERR_LENGTH 0x11
|
|
/* Invalid SEID */
|
|
#define AVDT_ERR_SEID 0x12
|
|
/* The SEP is in use */
|
|
#define AVDT_ERR_IN_USE 0x13
|
|
/* The SEP is not in use */
|
|
#define AVDT_ERR_NOT_IN_USE 0x14
|
|
/* Bad service category */
|
|
#define AVDT_ERR_CATEGORY 0x17
|
|
/* Bad payload format */
|
|
#define AVDT_ERR_PAYLOAD 0x18
|
|
/* Requested command not supported */
|
|
#define AVDT_ERR_NSC 0x19
|
|
/* Reconfigure attempted invalid capabilities */
|
|
#define AVDT_ERR_INVALID_CAP 0x1A
|
|
/* Requested recovery type not defined */
|
|
#define AVDT_ERR_RECOV_TYPE 0x22
|
|
/* Media transport capability not correct */
|
|
#define AVDT_ERR_MEDIA_TRANS 0x23
|
|
/* Recovery service capability not correct */
|
|
#define AVDT_ERR_RECOV_FMT 0x25
|
|
/* Header compression service capability not correct */
|
|
#define AVDT_ERR_ROHC_FMT 0x26
|
|
/* Content protection service capability not correct */
|
|
#define AVDT_ERR_CP_FMT 0x27
|
|
/* Multiplexing service capability not correct */
|
|
#define AVDT_ERR_MUX_FMT 0x28
|
|
/* Configuration not supported */
|
|
#define AVDT_ERR_UNSUP_CFG 0x29
|
|
/* Message cannot be processed in this state */
|
|
#define AVDT_ERR_BAD_STATE 0x31
|
|
/* Report service capability not correct */
|
|
#define AVDT_ERR_REPORT_FMT 0x65
|
|
/* Invalid service category */
|
|
#define AVDT_ERR_SERVICE 0x80
|
|
/* Insufficient resources */
|
|
#define AVDT_ERR_RESOURCE 0x81
|
|
/* Invalid Media Codec Type */
|
|
#define AVDT_ERR_INVALID_MCT 0xC1
|
|
/* Unsupported Media Codec Type */
|
|
#define AVDT_ERR_UNSUP_MCT 0xC2
|
|
/* Invalid Level */
|
|
#define AVDT_ERR_INVALID_LEVEL 0xC3
|
|
/* Unsupported Level */
|
|
#define AVDT_ERR_UNSUP_LEVEL 0xC4
|
|
/* Invalid Content Protection Type */
|
|
#define AVDT_ERR_INVALID_CP 0xE0
|
|
/* Invalid Content Protection format */
|
|
#define AVDT_ERR_INVALID_FORMAT 0xE1
|
|
|
|
/* Additional error codes. This indicates error codes used by AVDTP
|
|
* in addition to the ones defined in the specifications.
|
|
*/
|
|
#define AVDT_ERR_CONNECT 0x07 /* Connection failed. */
|
|
#define AVDT_ERR_TIMEOUT 0x08 /* Response timeout. */
|
|
|
|
/* Control callback events. */
|
|
#define AVDT_DISCOVER_CFM_EVT 0 /* Discover confirm */
|
|
#define AVDT_GETCAP_CFM_EVT 1 /* Get capabilities confirm */
|
|
#define AVDT_OPEN_CFM_EVT 2 /* Open confirm */
|
|
#define AVDT_OPEN_IND_EVT 3 /* Open indication */
|
|
#define AVDT_CONFIG_IND_EVT 4 /* Configuration indication */
|
|
#define AVDT_START_CFM_EVT 5 /* Start confirm */
|
|
#define AVDT_START_IND_EVT 6 /* Start indication */
|
|
#define AVDT_SUSPEND_CFM_EVT 7 /* Suspend confirm */
|
|
#define AVDT_SUSPEND_IND_EVT 8 /* Suspend indication */
|
|
#define AVDT_CLOSE_CFM_EVT 9 /* Close confirm */
|
|
#define AVDT_CLOSE_IND_EVT 10 /* Close indication */
|
|
#define AVDT_RECONFIG_CFM_EVT 11 /* Reconfiguration confirm */
|
|
#define AVDT_RECONFIG_IND_EVT 12 /* Reconfiguration indication */
|
|
#define AVDT_SECURITY_CFM_EVT 13 /* Security confirm */
|
|
#define AVDT_SECURITY_IND_EVT 14 /* Security indication */
|
|
#define AVDT_WRITE_CFM_EVT 15 /* Write confirm */
|
|
#define AVDT_CONNECT_IND_EVT 16 /* Signaling channel connected */
|
|
#define AVDT_DISCONNECT_IND_EVT 17 /* Signaling channel disconnected */
|
|
#define AVDT_REPORT_CONN_EVT 18 /* Reporting channel connected */
|
|
#define AVDT_REPORT_DISCONN_EVT 19 /* Reporting channel disconnected */
|
|
#define AVDT_DELAY_REPORT_EVT 20 /* Delay report received */
|
|
#define AVDT_DELAY_REPORT_CFM_EVT 21 /* Delay report response received */
|
|
|
|
#define AVDT_MAX_EVT (AVDT_DELAY_REPORT_CFM_EVT)
|
|
|
|
/* PSM for AVDT */
|
|
#define AVDT_PSM 0x0019
|
|
|
|
/*****************************************************************************
|
|
* Type Definitions
|
|
****************************************************************************/
|
|
|
|
typedef struct {
|
|
uint32_t ntp_sec; /* NTP time: seconds relative to 0h UTC on 1 January 1900 */
|
|
uint32_t ntp_frac; /* NTP time: the fractional part */
|
|
uint32_t rtp_time; /* timestamp in RTP header */
|
|
uint32_t pkt_count; /* sender's packet count: since starting transmission
|
|
* up until the time this SR packet was generated. */
|
|
uint32_t octet_count; /* sender's octet count: same comment */
|
|
} tAVDT_SENDER_INFO;
|
|
|
|
typedef struct {
|
|
uint8_t frag_lost; /* fraction lost since last RR */
|
|
uint32_t
|
|
packet_lost; /* cumulative number of packets lost since the beginning */
|
|
uint32_t seq_num_rcvd; /* extended highest sequence number received */
|
|
uint32_t jitter; /* interarrival jitter */
|
|
uint32_t lsr; /* last SR timestamp */
|
|
uint32_t dlsr; /* delay since last SR */
|
|
} tAVDT_REPORT_BLK;
|
|
|
|
typedef union {
|
|
tAVDT_SENDER_INFO sr;
|
|
tAVDT_REPORT_BLK rr;
|
|
uint8_t cname[AVDT_MAX_CNAME_SIZE + 1];
|
|
} tAVDT_REPORT_DATA;
|
|
|
|
/**
|
|
* AVDTP Registration Control Block.
|
|
*/
|
|
class AvdtpRcb {
|
|
public:
|
|
AvdtpRcb()
|
|
: ctrl_mtu(0),
|
|
ret_tout(0),
|
|
sig_tout(0),
|
|
idle_tout(0),
|
|
scb_index(0) {}
|
|
AvdtpRcb& operator=(const AvdtpRcb&) = default;
|
|
|
|
void Reset() {
|
|
ctrl_mtu = 0;
|
|
ret_tout = 0;
|
|
sig_tout = 0;
|
|
idle_tout = 0;
|
|
scb_index = 0;
|
|
}
|
|
|
|
uint16_t ctrl_mtu; /* L2CAP MTU of the AVDTP signaling channel */
|
|
uint8_t ret_tout; /* AVDTP signaling retransmission timeout */
|
|
uint8_t sig_tout; /* AVDTP signaling message timeout */
|
|
uint8_t idle_tout; /* AVDTP idle signaling channel timeout */
|
|
uint8_t scb_index; /* The Stream Control Block index */
|
|
};
|
|
|
|
/* This structure contains the SEP information. This information is
|
|
* transferred during the discovery procedure.
|
|
*/
|
|
typedef struct {
|
|
bool in_use; /* true if stream is currently in use */
|
|
uint8_t seid; /* Stream endpoint identifier */
|
|
uint8_t media_type; /* Media type: AVDT_MEDIA_TYPE_* */
|
|
uint8_t tsep; /* SEP type */
|
|
} tAVDT_SEP_INFO;
|
|
|
|
/**
|
|
* AVDTP SEP Configuration.
|
|
*/
|
|
class AvdtpSepConfig {
|
|
public:
|
|
AvdtpSepConfig()
|
|
: codec_info{},
|
|
protect_info{},
|
|
num_codec(0),
|
|
num_protect(0),
|
|
psc_mask(0),
|
|
recov_type(0),
|
|
recov_mrws(0),
|
|
recov_mnmp(0),
|
|
hdrcmp_mask(0) {}
|
|
AvdtpSepConfig& operator=(const AvdtpSepConfig&) = default;
|
|
|
|
void Reset() {
|
|
memset(codec_info, 0, sizeof(codec_info));
|
|
memset(protect_info, 0, sizeof(protect_info));
|
|
num_codec = 0;
|
|
num_protect = 0;
|
|
psc_mask = 0;
|
|
recov_type = 0;
|
|
recov_mrws = 0;
|
|
recov_mnmp = 0;
|
|
hdrcmp_mask = 0;
|
|
}
|
|
|
|
uint8_t codec_info[AVDT_CODEC_SIZE]; /* Codec capabilities array */
|
|
uint8_t protect_info[AVDT_PROTECT_SIZE]; /* Content protection capabilities */
|
|
uint8_t num_codec; /* Number of media codec information elements */
|
|
uint8_t num_protect; /* Number of content protection information elements */
|
|
uint16_t psc_mask; /* Protocol service capabilities mask */
|
|
uint8_t recov_type; /* Recovery type */
|
|
uint8_t recov_mrws; /* Maximum recovery window size */
|
|
uint8_t recov_mnmp; /* Recovery maximum number of media packets */
|
|
uint8_t hdrcmp_mask; /* Header compression capabilities */
|
|
};
|
|
|
|
/* Header structure for callback event parameters. */
|
|
typedef struct {
|
|
uint8_t
|
|
err_code; /* Zero if operation succeeded; nonzero if operation failed */
|
|
uint8_t err_param; /* Error parameter included for some events */
|
|
uint8_t label; /* Transaction label */
|
|
uint8_t seid; /* For internal use only */
|
|
uint8_t sig_id; /* For internal use only */
|
|
uint8_t ccb_idx; /* For internal use only */
|
|
} tAVDT_EVT_HDR;
|
|
|
|
/* This data structure is associated with the AVDT_GETCAP_CFM_EVT,
|
|
* AVDT_RECONFIG_IND_EVT, and AVDT_RECONFIG_CFM_EVT.
|
|
*/
|
|
typedef struct {
|
|
tAVDT_EVT_HDR hdr; /* Event header */
|
|
AvdtpSepConfig* p_cfg; /* Pointer to configuration for this SEP */
|
|
} tAVDT_CONFIG;
|
|
|
|
/* This data structure is associated with the AVDT_CONFIG_IND_EVT. */
|
|
typedef struct {
|
|
tAVDT_EVT_HDR hdr; /* Event header */
|
|
AvdtpSepConfig* p_cfg; /* Pointer to configuration for this SEP */
|
|
uint8_t int_seid; /* Stream endpoint ID of stream initiating the operation */
|
|
} tAVDT_SETCONFIG;
|
|
|
|
/* This data structure is associated with the AVDT_OPEN_IND_EVT and
|
|
* AVDT_OPEN_CFM_EVT. */
|
|
typedef struct {
|
|
tAVDT_EVT_HDR hdr; /* Event header */
|
|
uint16_t peer_mtu; /* Transport channel L2CAP MTU of the peer */
|
|
uint16_t lcid; /* L2CAP LCID for media channel */
|
|
} tAVDT_OPEN;
|
|
|
|
/* This data structure is associated with the AVDT_SECURITY_IND_EVT
|
|
* and AVDT_SECURITY_CFM_EVT.
|
|
*/
|
|
typedef struct {
|
|
tAVDT_EVT_HDR hdr; /* Event header */
|
|
uint8_t* p_data; /* Pointer to security data */
|
|
uint16_t len; /* Length in bytes of the security data */
|
|
} tAVDT_SECURITY;
|
|
|
|
/* This data structure is associated with the AVDT_DISCOVER_CFM_EVT. */
|
|
typedef struct {
|
|
tAVDT_EVT_HDR hdr; /* Event header */
|
|
tAVDT_SEP_INFO* p_sep_info; /* Pointer to SEP information */
|
|
uint8_t num_seps; /* Number of stream endpoints */
|
|
} tAVDT_DISCOVER;
|
|
|
|
/* This data structure is associated with the AVDT_DELAY_REPORT_EVT. */
|
|
typedef struct {
|
|
tAVDT_EVT_HDR hdr; /* Event header */
|
|
uint16_t delay; /* Delay value */
|
|
} tAVDT_DELAY_RPT;
|
|
|
|
/* Union of all control callback event data structures */
|
|
typedef union {
|
|
tAVDT_EVT_HDR hdr;
|
|
tAVDT_DISCOVER discover_cfm;
|
|
tAVDT_CONFIG getcap_cfm;
|
|
tAVDT_OPEN open_cfm;
|
|
tAVDT_OPEN open_ind;
|
|
tAVDT_SETCONFIG config_ind;
|
|
tAVDT_EVT_HDR start_cfm;
|
|
tAVDT_EVT_HDR suspend_cfm;
|
|
tAVDT_EVT_HDR close_cfm;
|
|
tAVDT_CONFIG reconfig_cfm;
|
|
tAVDT_CONFIG reconfig_ind;
|
|
tAVDT_SECURITY security_cfm;
|
|
tAVDT_SECURITY security_ind;
|
|
tAVDT_EVT_HDR connect_ind;
|
|
tAVDT_EVT_HDR disconnect_ind;
|
|
tAVDT_EVT_HDR report_conn;
|
|
tAVDT_DELAY_RPT delay_rpt_cmd;
|
|
} tAVDT_CTRL;
|
|
|
|
/* This is the control callback function. This function passes control events
|
|
* to the application. This function is required for all registered stream
|
|
* endpoints and for the AVDT_DiscoverReq() and AVDT_GetCapReq() functions.
|
|
*
|
|
*/
|
|
typedef void(tAVDT_CTRL_CBACK)(uint8_t handle, const RawAddress& bd_addr,
|
|
uint8_t event, tAVDT_CTRL* p_data,
|
|
uint8_t scb_index);
|
|
|
|
/* This is the data callback function. It is executed when AVDTP has a media
|
|
* packet ready for the application. This function is required for SNK
|
|
* endpoints and not applicable for SRC endpoints.
|
|
*/
|
|
typedef void(tAVDT_SINK_DATA_CBACK)(uint8_t handle, BT_HDR* p_pkt,
|
|
uint32_t time_stamp, uint8_t m_pt);
|
|
|
|
/* This is the report callback function. It is executed when AVDTP has a
|
|
* reporting packet ready for the application. This function is required for
|
|
* streams created with AVDT_PSC_REPORT.
|
|
*/
|
|
typedef void(tAVDT_REPORT_CBACK)(uint8_t handle, AVDT_REPORT_TYPE type,
|
|
tAVDT_REPORT_DATA* p_data);
|
|
|
|
/**
|
|
* AVDTP Stream Configuration.
|
|
* The information is used when a stream is created.
|
|
*/
|
|
class AvdtpStreamConfig {
|
|
public:
|
|
//
|
|
// Non-supported protocol command messages
|
|
//
|
|
// Suspend command not supported
|
|
static constexpr int AVDT_NSC_SUSPEND = 0x01;
|
|
// Reconfigure command not supported
|
|
static constexpr int AVDT_NSC_RECONFIG = 0x02;
|
|
// Security command not supported
|
|
static constexpr int AVDT_NSC_SECURITY = 0x04;
|
|
|
|
AvdtpStreamConfig()
|
|
: p_avdt_ctrl_cback(nullptr),
|
|
scb_index(0),
|
|
p_sink_data_cback(nullptr),
|
|
p_report_cback(nullptr),
|
|
mtu(0),
|
|
tsep(0),
|
|
media_type(0),
|
|
nsc_mask(0) {}
|
|
|
|
void Reset() {
|
|
cfg.Reset();
|
|
p_avdt_ctrl_cback = nullptr;
|
|
scb_index = 0;
|
|
p_sink_data_cback = nullptr;
|
|
p_report_cback = nullptr;
|
|
mtu = 0;
|
|
tsep = 0;
|
|
media_type = 0;
|
|
nsc_mask = 0;
|
|
}
|
|
|
|
AvdtpSepConfig cfg; // SEP configuration
|
|
tAVDT_CTRL_CBACK* p_avdt_ctrl_cback; // Control callback function
|
|
uint8_t scb_index; // The index to the bta_av_cb.p_scb[] entry
|
|
tAVDT_SINK_DATA_CBACK* p_sink_data_cback; // Sink data callback function
|
|
tAVDT_REPORT_CBACK* p_report_cback; // Report callback function
|
|
uint16_t mtu; // The L2CAP MTU of the transport channel
|
|
uint8_t tsep; // SEP type
|
|
uint8_t media_type; // Media type: AVDT_MEDIA_TYPE_*
|
|
uint16_t nsc_mask; // Nonsupported protocol command messages
|
|
};
|
|
|
|
/* AVDT data option mask is used in the write request */
|
|
#define AVDT_DATA_OPT_NONE 0x00 /* No option still add RTP header */
|
|
#define AVDT_DATA_OPT_NO_RTP (0x01 << 0) /* Skip adding RTP header */
|
|
|
|
typedef uint8_t tAVDT_DATA_OPT_MASK;
|
|
|
|
/*****************************************************************************
|
|
* External Function Declarations
|
|
****************************************************************************/
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function AVDT_Register
|
|
*
|
|
* Description This is the system level registration function for the
|
|
* AVDTP protocol. This function initializes AVDTP and
|
|
* prepares the protocol stack for its use. This function
|
|
* must be called once by the system or platform using AVDTP
|
|
* before the other functions of the API an be used.
|
|
*
|
|
*
|
|
* Returns void
|
|
*
|
|
******************************************************************************/
|
|
extern void AVDT_Register(AvdtpRcb* p_reg, tAVDT_CTRL_CBACK* p_cback);
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function AVDT_Deregister
|
|
*
|
|
* Description This function is called to deregister use AVDTP protocol.
|
|
* It is called when AVDTP is no longer being used by any
|
|
* application in the system. Before this function can be
|
|
* called, all streams must be removed with AVDT_RemoveStream.
|
|
*
|
|
* Returns void
|
|
*
|
|
******************************************************************************/
|
|
extern void AVDT_Deregister(void);
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function AVDT_AbortReq
|
|
*
|
|
* Description Trigger Abort request to pass AVDTP Abort related mandatory
|
|
* PTS Test case.
|
|
*
|
|
* Returns void.
|
|
*
|
|
******************************************************************************/
|
|
extern void AVDT_AbortReq(uint8_t handle);
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function AVDT_CreateStream
|
|
*
|
|
* Description Create a stream endpoint. After a stream endpoint is
|
|
* created an application can initiate a connection between
|
|
* this endpoint and an endpoint on a peer device. In
|
|
* addition, a peer device can discover, get the capabilities,
|
|
* and connect to this endpoint.
|
|
*
|
|
*
|
|
* Returns AVDT_SUCCESS if successful, otherwise error.
|
|
*
|
|
******************************************************************************/
|
|
extern uint16_t AVDT_CreateStream(uint8_t peer_id, uint8_t* p_handle,
|
|
const AvdtpStreamConfig& avdtp_stream_config);
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function AVDT_RemoveStream
|
|
*
|
|
* Description Remove a stream endpoint. This function is called when
|
|
* the application is no longer using a stream endpoint.
|
|
* If this function is called when the endpoint is connected
|
|
* the connection is closed and then the stream endpoint
|
|
* is removed.
|
|
*
|
|
*
|
|
* Returns AVDT_SUCCESS if successful, otherwise error.
|
|
*
|
|
******************************************************************************/
|
|
extern uint16_t AVDT_RemoveStream(uint8_t handle);
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function AVDT_DiscoverReq
|
|
*
|
|
* Description This function initiates a connection to the AVDTP service
|
|
* on the peer device, if not already present, and discovers
|
|
* the stream endpoints on the peer device. (Please note
|
|
* that AVDTP discovery is unrelated to SDP discovery).
|
|
* This function can be called at any time regardless of
|
|
* whether there is an AVDTP connection to the peer device.
|
|
*
|
|
* When discovery is complete, an AVDT_DISCOVER_CFM_EVT
|
|
* is sent to the application via its callback function.
|
|
* The application must not call AVDT_GetCapReq() or
|
|
* AVDT_DiscoverReq() again to the same device until
|
|
* discovery is complete.
|
|
*
|
|
* The memory addressed by sep_info is allocated by the
|
|
* application. This memory is written to by AVDTP as part
|
|
* of the discovery procedure. This memory must remain
|
|
* accessible until the application receives the
|
|
* AVDT_DISCOVER_CFM_EVT.
|
|
*
|
|
* Returns AVDT_SUCCESS if successful, otherwise error.
|
|
*
|
|
******************************************************************************/
|
|
extern uint16_t AVDT_DiscoverReq(const RawAddress& bd_addr,
|
|
uint8_t channel_index,
|
|
tAVDT_SEP_INFO* p_sep_info, uint8_t max_seps,
|
|
tAVDT_CTRL_CBACK* p_cback);
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function AVDT_GetCapReq
|
|
*
|
|
* Description This function initiates a connection to the AVDTP service
|
|
* on the peer device, if not already present, and gets the
|
|
* capabilities of a stream endpoint on the peer device.
|
|
* This function can be called at any time regardless of
|
|
* whether there is an AVDTP connection to the peer device.
|
|
*
|
|
* When the procedure is complete, an AVDT_GETCAP_CFM_EVT is
|
|
* sent to the application via its callback function. The
|
|
* application must not call AVDT_GetCapReq() or
|
|
* AVDT_DiscoverReq() again until the procedure is complete.
|
|
*
|
|
* The memory pointed to by p_cfg is allocated by the
|
|
* application. This memory is written to by AVDTP as part
|
|
* of the get capabilities procedure. This memory must
|
|
* remain accessible until the application receives
|
|
* the AVDT_GETCAP_CFM_EVT.
|
|
*
|
|
* Returns AVDT_SUCCESS if successful, otherwise error.
|
|
*
|
|
******************************************************************************/
|
|
extern uint16_t AVDT_GetCapReq(const RawAddress& bd_addr, uint8_t channel_index,
|
|
uint8_t seid, AvdtpSepConfig* p_cfg,
|
|
tAVDT_CTRL_CBACK* p_cback, bool get_all_cap);
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function AVDT_DelayReport
|
|
*
|
|
* Description This functions sends a Delay Report to the peer device
|
|
* that is associated with a particular SEID.
|
|
* This function is called by SNK device.
|
|
*
|
|
* Returns AVDT_SUCCESS if successful, otherwise error.
|
|
*
|
|
******************************************************************************/
|
|
extern uint16_t AVDT_DelayReport(uint8_t handle, uint8_t seid, uint16_t delay);
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function AVDT_OpenReq
|
|
*
|
|
* Description This function initiates a connection to the AVDTP service
|
|
* on the peer device, if not already present, and connects
|
|
* to a stream endpoint on a peer device. When the connection
|
|
* is completed, an AVDT_OPEN_CFM_EVT is sent to the
|
|
* application via the control callback function for this
|
|
* handle.
|
|
*
|
|
* Returns AVDT_SUCCESS if successful, otherwise error.
|
|
*
|
|
******************************************************************************/
|
|
extern uint16_t AVDT_OpenReq(uint8_t handle, const RawAddress& bd_addr,
|
|
uint8_t channel_index, uint8_t seid,
|
|
AvdtpSepConfig* p_cfg);
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function AVDT_ConfigRsp
|
|
*
|
|
* Description Respond to a configure request from the peer device. This
|
|
* function must be called if the application receives an
|
|
* AVDT_CONFIG_IND_EVT through its control callback.
|
|
*
|
|
*
|
|
* Returns AVDT_SUCCESS if successful, otherwise error.
|
|
*
|
|
******************************************************************************/
|
|
extern uint16_t AVDT_ConfigRsp(uint8_t handle, uint8_t label,
|
|
uint8_t error_code, uint8_t category);
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function AVDT_StartReq
|
|
*
|
|
* Description Start one or more stream endpoints. This initiates the
|
|
* transfer of media packets for the streams. All stream
|
|
* endpoints must previously be opened. When the streams
|
|
* are started, an AVDT_START_CFM_EVT is sent to the
|
|
* application via the control callback function for each
|
|
* stream.
|
|
*
|
|
*
|
|
* Returns AVDT_SUCCESS if successful, otherwise error.
|
|
*
|
|
******************************************************************************/
|
|
extern uint16_t AVDT_StartReq(uint8_t* p_handles, uint8_t num_handles);
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function AVDT_SuspendReq
|
|
*
|
|
* Description Suspend one or more stream endpoints. This suspends the
|
|
* transfer of media packets for the streams. All stream
|
|
* endpoints must previously be open and started. When the
|
|
* streams are suspended, an AVDT_SUSPEND_CFM_EVT is sent to
|
|
* the application via the control callback function for
|
|
* each stream.
|
|
*
|
|
*
|
|
* Returns AVDT_SUCCESS if successful, otherwise error.
|
|
*
|
|
******************************************************************************/
|
|
extern uint16_t AVDT_SuspendReq(uint8_t* p_handles, uint8_t num_handles);
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function AVDT_CloseReq
|
|
*
|
|
* Description Close a stream endpoint. This stops the transfer of media
|
|
* packets and closes the transport channel associated with
|
|
* this stream endpoint. When the stream is closed, an
|
|
* AVDT_CLOSE_CFM_EVT is sent to the application via the
|
|
* control callback function for this handle.
|
|
*
|
|
*
|
|
* Returns AVDT_SUCCESS if successful, otherwise error.
|
|
*
|
|
******************************************************************************/
|
|
extern uint16_t AVDT_CloseReq(uint8_t handle);
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function AVDT_ReconfigReq
|
|
*
|
|
* Description Reconfigure a stream endpoint. This allows the application
|
|
* to change the codec or content protection capabilities of
|
|
* a stream endpoint after it has been opened. This function
|
|
* can only be called if the stream is opened but not started
|
|
* or if the stream has been suspended. When the procedure
|
|
* is completed, an AVDT_RECONFIG_CFM_EVT is sent to the
|
|
* application via the control callback function for this
|
|
* handle.
|
|
*
|
|
*
|
|
* Returns AVDT_SUCCESS if successful, otherwise error.
|
|
*
|
|
******************************************************************************/
|
|
extern uint16_t AVDT_ReconfigReq(uint8_t handle, AvdtpSepConfig* p_cfg);
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function AVDT_SecurityReq
|
|
*
|
|
* Description Send a security request to the peer device. When the
|
|
* security procedure is completed, an AVDT_SECURITY_CFM_EVT
|
|
* is sent to the application via the control callback function
|
|
* for this handle. (Please note that AVDTP security
|
|
* procedures are unrelated to Bluetooth link level security.)
|
|
*
|
|
*
|
|
* Returns AVDT_SUCCESS if successful, otherwise error.
|
|
*
|
|
******************************************************************************/
|
|
extern uint16_t AVDT_SecurityReq(uint8_t handle, uint8_t* p_data, uint16_t len);
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function AVDT_SecurityRsp
|
|
*
|
|
* Description Respond to a security request from the peer device.
|
|
* This function must be called if the application receives
|
|
* an AVDT_SECURITY_IND_EVT through its control callback.
|
|
* (Please note that AVDTP security procedures are unrelated
|
|
* to Bluetooth link level security.)
|
|
*
|
|
*
|
|
* Returns AVDT_SUCCESS if successful, otherwise error.
|
|
*
|
|
******************************************************************************/
|
|
extern uint16_t AVDT_SecurityRsp(uint8_t handle, uint8_t label,
|
|
uint8_t error_code, uint8_t* p_data,
|
|
uint16_t len);
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function AVDT_WriteReqOpt
|
|
*
|
|
* Description Send a media packet to the peer device. The stream must
|
|
* be started before this function is called. Also, this
|
|
* function can only be called if the stream is a SRC
|
|
*
|
|
* When AVDTP has sent the media packet and is ready for the
|
|
* next packet, an AVDT_WRITE_CFM_EVT is sent to the
|
|
* application via the control callback. The application must
|
|
* wait for the AVDT_WRITE_CFM_EVT before it makes the next
|
|
* call to AVDT_WriteReq(). If the applications calls
|
|
* AVDT_WriteReq() before it receives the event the packet
|
|
* will not be sent. The application may make its first call
|
|
* to AVDT_WriteReq() after it receives an AVDT_START_CFM_EVT
|
|
* or AVDT_START_IND_EVT.
|
|
*
|
|
* The application passes the packet using the BT_HDR structure
|
|
* This structure is described in section 2.1. The offset
|
|
* field must be equal to or greater than AVDT_MEDIA_OFFSET
|
|
* (if NO_RTP is specified, L2CAP_MIN_OFFSET can be used)
|
|
* This allows enough space in the buffer for the L2CAP and
|
|
* AVDTP headers.
|
|
*
|
|
* The memory pointed to by p_pkt must be a GKI buffer
|
|
* allocated by the application. This buffer will be freed
|
|
* by the protocol stack; the application must not free
|
|
* this buffer.
|
|
*
|
|
* The opt parameter allows passing specific options like:
|
|
* - NO_RTP : do not add the RTP header to buffer
|
|
*
|
|
* Returns AVDT_SUCCESS if successful, otherwise error.
|
|
*
|
|
******************************************************************************/
|
|
extern uint16_t AVDT_WriteReqOpt(uint8_t handle, BT_HDR* p_pkt,
|
|
uint32_t time_stamp, uint8_t m_pt,
|
|
tAVDT_DATA_OPT_MASK opt);
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function AVDT_ConnectReq
|
|
*
|
|
* Description This function initiates an AVDTP signaling connection
|
|
* to the peer device. When the connection is completed, an
|
|
* AVDT_CONNECT_IND_EVT is sent to the application via its
|
|
* control callback function. If the connection attempt fails
|
|
* an AVDT_DISCONNECT_IND_EVT is sent. The security mask
|
|
* parameter overrides the outgoing security mask set in
|
|
* AVDT_Register().
|
|
*
|
|
* Returns AVDT_SUCCESS if successful, otherwise error.
|
|
*
|
|
******************************************************************************/
|
|
extern uint16_t AVDT_ConnectReq(const RawAddress& bd_addr,
|
|
uint8_t channel_index,
|
|
tAVDT_CTRL_CBACK* p_cback);
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function AVDT_DisconnectReq
|
|
*
|
|
* Description This function disconnect an AVDTP signaling connection
|
|
* to the peer device. When disconnected an
|
|
* AVDT_DISCONNECT_IND_EVT is sent to the application via its
|
|
* control callback function.
|
|
*
|
|
* Returns AVDT_SUCCESS if successful, otherwise error.
|
|
*
|
|
******************************************************************************/
|
|
extern uint16_t AVDT_DisconnectReq(const RawAddress& bd_addr,
|
|
tAVDT_CTRL_CBACK* p_cback);
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function AVDT_GetL2CapChannel
|
|
*
|
|
* Description Get the L2CAP CID used by the handle.
|
|
*
|
|
* Returns CID if successful, otherwise 0.
|
|
*
|
|
******************************************************************************/
|
|
extern uint16_t AVDT_GetL2CapChannel(uint8_t handle);
|
|
|
|
/******************************************************************************
|
|
*
|
|
* Function AVDT_SetTraceLevel
|
|
*
|
|
* Description Sets the trace level for AVDT. If 0xff is passed, the
|
|
* current trace level is returned.
|
|
*
|
|
* Input Parameters:
|
|
* new_level: The level to set the AVDT tracing to:
|
|
* 0xff-returns the current setting.
|
|
* 0-turns off tracing.
|
|
* >= 1-Errors.
|
|
* >= 2-Warnings.
|
|
* >= 3-APIs.
|
|
* >= 4-Events.
|
|
* >= 5-Debug.
|
|
*
|
|
* Returns The new trace level or current trace level if
|
|
* the input parameter is 0xff.
|
|
*
|
|
*****************************************************************************/
|
|
extern uint8_t AVDT_SetTraceLevel(uint8_t new_level);
|
|
|
|
/**
|
|
* Dump debug-related information for the Stack AVDTP module.
|
|
*
|
|
* @param fd the file descriptor to use for writing the ASCII formatted
|
|
* information
|
|
*/
|
|
void stack_debug_avdtp_api_dump(int fd);
|
|
|
|
#endif /* AVDT_API_H */
|