/******************************************************************************
*
* 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 "bt_target.h"
#include "bt_types.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. */
#define AVDT_SUCCESS 0 /* Function successful */
#define AVDT_BAD_PARAMS 1 /* Invalid parameters */
#define AVDT_NO_RESOURCES 2 /* Not enough resources */
#define AVDT_BAD_HANDLE 3 /* Bad handle */
#define AVDT_BUSY 4 /* A procedure is already in progress */
#define AVDT_WRITE_FAIL 5 /* Write failed */
/* 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 */
/* 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),
sec_mask(0),
scb_index(0) {}
AvdtpRcb& operator=(const AvdtpRcb&) = default;
void Reset() {
ctrl_mtu = 0;
ret_tout = 0;
sig_tout = 0;
idle_tout = 0;
sec_mask = 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 sec_mask; /* Security mask for BTM_SetSecurityLevel() */
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),
flush_to(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;
flush_to = 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
uint16_t flush_to; // The L2CAP flush timeout 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_ReconfigRsp
*
* Description Respond to a reconfigure request from the peer device.
* This function must be called if the application receives
* an AVDT_RECONFIG_IND_EVT through its control callback.
*
*
* Returns AVDT_SUCCESS if successful, otherwise error.
*
******************************************************************************/
extern uint16_t AVDT_ReconfigRsp(uint8_t handle, uint8_t label,
uint8_t error_code, uint8_t category);
/*******************************************************************************
*
* 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_WriteReq
*
* 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.
* 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.
*
*
* Returns AVDT_SUCCESS if successful, otherwise error.
*
******************************************************************************/
extern uint16_t AVDT_WriteReq(uint8_t handle, BT_HDR* p_pkt,
uint32_t time_stamp, uint8_t m_pt);
/*******************************************************************************
*
* 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, uint8_t sec_mask,
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_GetSignalChannel
*
* Description Get the L2CAP CID used by the signal channel of the given
* handle.
*
* Returns CID if successful, otherwise 0.
*
******************************************************************************/
extern uint16_t AVDT_GetSignalChannel(uint8_t handle,
const RawAddress& bd_addr);
/*******************************************************************************
*
* Function AVDT_SendReport
*
* Description
*
*
*
* Returns
*
******************************************************************************/
extern uint16_t AVDT_SendReport(uint8_t handle, AVDT_REPORT_TYPE type,
tAVDT_REPORT_DATA* p_data);
/******************************************************************************
*
* 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 */