LiJie
/
MXC_A39_20240320
11
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
MXC_A39_20240320/SW/components/btdm/include/a2dp_api.h

2078 lines
74 KiB
C
Raw Normal View History

800*320工程文件+初始demo提交
2024-03-07 16:46:43 +08:00
#ifndef __A2DP_API_H_
#define __A2DP_API_H_
#include "btconfig.h"
//#include "type_lib.h"
#include "avdtp_api.h"
#include "bt_types.h"
#include "me_api.h"
/*---------------------------------------------------------------------------
* A2DP API layer
*
* Advanced Audio Distribution Profile (A2DP) is the Profile
* defined by the Bluetooth Audio Video Working Group for
* streaming audio content over a Bluetooth connection.
*
* The A2DP API is designed for audio applications using the
* SDK core protocol stack. It provides functions
* for connection management, audio stream discovery, audio stream
* management, and security.
*
* Applications that use the A2DP API will also require knowledge of
* certain AVDTP (Audio/Video Distribution Transport Protocol) types as
* referenced by this API. Although some AVDTP data structures are
* used by A2DP, applications should use either the AVDTP API or
* the A2DP API and not mix the two.
*/
/****************************************************************************
*
* Types
*
****************************************************************************/
/*---------------------------------------------------------------------------
* A2dpEvent type
*
* All indications and confirmations are sent through a callback
* function as events. The type of event will determine which
* fields in the A2dpCallbackParms structure are valid. The 'len', and
* 'error' fields are always valid. The 'event' field contains the event
* associated with the callback.
*/
typedef uint8_t A2dpEvent;
/** This event is received by the application when the remote device is
* requesting that stream be opened. The application can accept or reject
* this request by calling A2DP_OpenStreamRsp().
*
* During this callback, the 'p.configReq' parameter is valid.
*/
#define A2DP_EVENT_STREAM_OPEN_IND 1
/** This event is received by the application when a stream is open. This
* can happen in response to a call from A2DP_OpenStream() or
* A2D_OpenStreamRsp().
*
* During this callback, the 'p.configReq' parameter is valid.
*/
#define A2DP_EVENT_STREAM_OPEN 2
/** This event is received by the application during the establishment of an
* outgoing stream (A2DP_OpenStream()) to indicate the capabilities of the
* remote device. This event may also be received after calling
* A2DP_GetStreamCapabilities().
*
* During this callback, the 'p.codec' parameter is valid.
*/
#define A2DP_EVENT_CODEC_INFO 3
/** This event is received by the application during the establishment of an
* outgoing stream (A2DP_OpenStream()) to indicated the capabilities of the
* remote device. This event may also be received after calling
* A2DP_GetStreamCapabilities().
*
* During this callback, the 'p.cp' parameter is valid.
*/
#define A2DP_EVENT_CP_INFO 4
/** This event is received by the application during the establishment of an
* outgoing stream (A2DP_OpenStream()) to indicated the capabilities of the
* remote device. If this event is received, then the remote device
* supports the Delay Reporting feature.
*/
#define A2DP_EVENT_DELAY_REPORTING_INFO 5
/** This event is received by the application when a stream is opening and
* all matching capabilities have been found. The application must call
* A2DP_SetStreamConfig() to configure the stream. If successful, the
* stream will be opened. A2DP_CloseStream() can also be called to close
* the stream. This event is only received on outgoing connections.
*/
#define A2DP_EVENT_GET_CONFIG_IND 6
/** This event is received after calling A2DP_GetStreamCapabilities(). This
* event is received after all the capabilities of the remote device have
* been indicated (see A2DP_EVENT_CODEC_INFO and A2DP_EVENT_CP_INFO).
*/
#define A2DP_EVENT_GET_CAP_CNF 7
/** This event is received by the application when an open stream has been
* closed. This can happen as a result of a call to A2DP_CloseStream(), if
* the stream has been closed by the remote device, if a link loss has been
* detected, or if the remote device rejects a request to open the stream.
*
* During this callback, the 'p.capability' parameter will be valid if the
* stream is closed because the configuration was rejected. The
* 'p.capability.type' field will be set to the capability type that was
* rejected. The 'len' field will be non-zero if the 'p.capability'
* parameter is valid.
*
* The 'error' field will contain the error code. If the close was
* successful, 'error' will contain AVDTP_ERR_NO_ERROR.
*
* If the stream was closed because of an L2CAP disconnect, the 'status'
* field will contain the L2CAP disconnect reason (L2capDiscReason),
* otherwise it will contain L2DISC_REASON_UNKNOWN.
*/
#define A2DP_EVENT_STREAM_CLOSED 8
/** This event is received by the application when an open stream has been
* set to the idle state. This happens as a result of a call to
* A2DP_IdleStream().
*/
#define A2DP_EVENT_STREAM_IDLE 9
/** When the remote device requests streaming to begin, this event will be
* received by the application. The application can accept or reject
* this request by calling A2DP_StartStreamRsp(). (Note: this event
* will be received only after A2DP_EVENT_STREAM_OPEN_IND but it may arrive
* before A2DP_EVENT_STREAM_OPEN.)
*/
#define A2DP_EVENT_STREAM_START_IND 10
/** When streaming has been started, this event will be received by the
* application. This can happen as the result to a call to
* A2DP_StartStream() or A2DP_StartStreamRsp().
*/
#define A2DP_EVENT_STREAM_STARTED 11
/** When streaming has been suspended, this event will be received by the
* application. This happens as the result to a call to
* A2DP_SuspendStream(), or when the remote device suspends the stream.
*/
#define A2DP_EVENT_STREAM_SUSPENDED 12
/** When the remote device wishes to reconfigure an open stream, this event
* is received by the application. The application can accept or reject
* the request by calling A2DP_ReconfigStreamRsp().
*
* During this callback, the 'p.configReq' parameter will be valid.
*/
#define A2DP_EVENT_STREAM_RECONFIG_IND 13
/** When an open stream is reconfigured, this event is received by the
* application.
*
* During this callback, the 'p.configReq' parameter is valid when the
* 'error' field is set to AVDTP_ERR_NO_ERROR. Otherwise,
* 'p.capability.type' contains the capability that caused the failure.
*/
#define A2DP_EVENT_STREAM_RECONFIG_CNF 14
/** This event is received when the remote device requests the security
* process to begin. The application responds to this request by calling
* A2DP_SecurityControlRsp().
*
* If 'error' contains no error, the 'p.data' parameter is valid.
*/
#define A2DP_EVENT_STREAM_SECURITY_IND 15
/** This event is received by the application when the remote device responds
* to the security process request.
*
* If 'error' contains no error, the 'p.data' parameter is valid.
*/
#define A2DP_EVENT_STREAM_SECURITY_CNF 16
/** When the stream is aborted, this event is received by the application.
* This can happen in response to a request from the remote device to abort
* the stream, or as the result of a call to A2DP_AbortStream(). When a
* stream is aborted, the stream is closed.
*/
#define A2DP_EVENT_STREAM_ABORTED 17
/** This event is received when stream data has been received from the remote
* device. The data is raw and is not parsed by A2DP. It should contain
* a single media packet.
*
* If 'error' contains no error, the 'p.data' parameter is valid.
*/
#define A2DP_EVENT_STREAM_DATA_IND 18
/** This event is received when raw data has been sent to the remote device.
* This happens as the result of a call to A2DP_StreamSendRawPacket().
*
* During this callback, the 'p.packet' parameter is valid.
*/
#define A2DP_EVENT_STREAM_PACKET_SENT 19
/** This event is received when SBC data has been sent to the remote device.
* This happens as the result of a call to A2DP_StreamSendSbcPacket().
*/
#define A2DP_EVENT_STREAM_SBC_PACKET_SENT 20
/** This event is received by a Source when the Sink reports the value of its
* buffer/processing delay. This may happen when the stream is configured
* (or reconfigured), and when the stream is in the streaming state.
*
* During this callback, the 'p.delayMs' parameter is valid.
*/
#define A2DP_EVENT_DELAY_REPORT_IND 21
/** This event is received by a Sink when the Source acknowldeges the
* transmitted buffer/processing delay.
*/
#define A2DP_EVENT_DELAY_REPORT_CNF 22
/** When the the lower level AVDTP connection is established between the
* local and remote devices, this event will be generated.
*
* During this callback, the 'p.device' parameter contains a pointer to the
* device that was connected.
*/
#define A2DP_EVENT_AVDTP_CONNECT 23
/** When the the lower level AVDTP connection is disconnected, this event
* will be generated.
*
* During this callback, the 'p.device' parameter contains a pointer to the
* device that was disconnected. The 'status' parameter contains the L2CAP
* disconnect reason (L2capDiscReason). If 'status' equals
* L2DISC_LINK_DISCON, then the 'discReason' parameter contains the reason
* for the link disconnect (BtErrorCode).
*/
#define A2DP_EVENT_AVDTP_DISCONNECT 24
/* Confirms AVDTP has received configuration information after an
* AVDTP_GetConfig() request.
*/
#define A2DP_AVDTP_EVENT_GET_CFG_CNF 27
/* Confirms AVDTP has sent configuration information after an
* AVDTP_OpenStream() request.
*/
#define A2DP_AVDTP_EVENT_SET_CFG_CNF 28
/* End of A2dpEvent */
/*---------------------------------------------------------------------------
* A2dpError type
*
* Error codes for the A2DP profile. If errors are detected in the
* Codec or Content protection requests, these error codes are used.
* Each error code description indicates the codec to which the error
* is applicable.
*
* This variable type can also contain AVDTP errors. See AvdtpError
* for more error codes.
*/
typedef AvdtpError A2dpError;
/** No error
*/
#define A2DP_ERR_NO_ERROR 0x00
/** Bad Service
*
* Generic
*/
#define A2DP_ERR_BAD_SERVICE 0x80
/** Insufficient Resources
*
* Generic
*/
#define A2DP_ERR_INSUFFICIENT_RESOURCE 0x81
/** Codec media type not valid
*
* Generic
*/
#define A2DP_ERR_INVALID_CODEC_TYPE 0xC1
/** Codec media type not supported
*
* Generic
*/
#define A2DP_ERR_NOT_SUPPORTED_CODEC_TYPE 0xC2
/** Sampling frequency not valid
*
* Generic
*/
#define A2DP_ERR_INVALID_SAMPLING_FREQUENCY 0xC3
/** Sampling frequency not supported
*
* Generic
*/
#define A2DP_ERR_NOT_SUPPORTED_SAMP_FREQ 0xC4
/** Channel mode not valid
*
* SBC
* MPEG-1,2 Audio
* ATRAC family
*/
#define A2DP_ERR_INVALID_CHANNEL_MODE 0xC5
/** Channel mode not supported
*
* SBC
* MPEG-1,2 Audio
* ATRAC family
*/
#define A2DP_ERR_NOT_SUPPORTED_CHANNEL_MODE 0xC6
/** Number of subbands not valid
*
* SBC
*/
#define A2DP_ERR_INVALID_SUBBANDS 0xC7
/** Number of subbands not supported
*
* SBC
*/
#define A2DP_ERR_NOT_SUPPORTED_SUBBANDS 0xC8
/** Allocation method not valid
*
* SBC
*/
#define A2DP_ERR_INVALID_ALLOCATION_METHOD 0xC9
/** Allocation method not supported
*
* SBC
*/
#define A2DP_ERR_NOT_SUPPORTED_ALLOC_METHOD 0xCA
/** Minimum bitpool value not valid
*
* SBC
*/
#define A2DP_ERR_INVALID_MIN_BITPOOL_VALUE 0xCB
/** Minimum bitpool value not supported
*
* SBC
*/
#define A2DP_ERR_NOT_SUPPORTED_MIN_BITPOOL_VALUE 0xCC
/** Maximum bitpool value not valid
*
* SBC
*/
#define A2DP_ERR_INVALID_MAX_BITPOOL_VALUE 0xCD
/** Maximum bitpool value not supported
*
* SBC
*/
#define A2DP_ERR_NOT_SUPPORTED_MAX_BITPOOL_VALUE 0xCE
/** None or multiple values have been selected for Layer
*
* MPEG-1,2 Audio
*/
#define A2DP_ERR_INVALID_LAYER 0xCF
/** Layer is not supported
*
* MPEG-1,2 Audio
*/
#define A2DP_ERR_NOT_SUPPORTED_LAYER 0xD0
/** CRC is not supported
*
* MPEG-1,2 Audio
*/
#define A2DP_ERR_NOT_SUPPORTED_CRC 0xD1
/** MPF-2 is not supported
*
* MPEG-1,2 Audio
*/
#define A2DP_ERR_NOT_SUPPORTED_MPF 0xD2
/** VBR is not supported
*
* MPEG-1,2 Audio
* MPEG-2,4 AAC
* ATRAC family
*/
#define A2DP_ERR_NOT_SUPPORTED_VBR 0xD3
/** None or multiple values have been selected for Bit Rate
*
* MPEG-1,2 Audio
* ATRAC family
*/
#define A2DP_ERR_INVALID_BIT_RATE 0xD4
/** Bit Rate is not supported
*
* MPEG-1,2 Audio
* MPEG-2,4 AAC
* ATRAC family
*/
#define A2DP_ERR_NOT_SUPPORTED_BIT_RATE 0xD5
/** Either 1) Object type is not valid (b3-b0) or 2) None or multiple values
* have been selected for Object Type
*
* MPEG-2,4 AAC
*/
#define A2DP_ERR_INVALID_OBJECT_TYPE 0xD6
/** Object Type is not supported
*
* MPEG-2,4 AAC
*/
#define A2DP_ERR_NOT_SUPPORTED_OBJECT_TYPE 0xD7
/** None or multiple values have been selected for Channels
*
* MPEG-2,4 AAC
*/
#define A2DP_ERR_INVALID_CHANNELS 0xD8
/** Channels is not supported
*
* MPEG-2,4 AAC
*/
#define A2DP_ERR_NOT_SUPPORTED_CHANNELS 0xD9
/** Version is not valid
*
* ATRAC family
*/
#define A2DP_ERR_INVALID_VERSION 0xDA
/** Version is not supported
*
* ATRAC family
*/
#define A2DP_ERR_NOT_SUPPORTED_VERSION 0xDB
/** Maximum SUL is not acceptable for the Decoder in the SNK
*
* ATRAC family
*/
#define A2DP_ERR_NOT_SUPPORTED_MAXIMUM_SUL 0xDC
/** None or multiple values have been selected for Block Length
*
* SBC
*/
#define A2DP_ERR_INVALID_BLOCK_LENGTH 0xDD
/** The requested CP Type is not supported
*
* Generic
*/
#define A2DP_ERR_INVALID_CP_TYPE 0xE0
/** The format of Content Protection Service Capability/Content Protection
* Scheme Dependent Data is not correct
*
* Generic
*/
#define A2DP_ERR_INVALID_CP_FORMAT 0xE1
/** Unknown error
*/
#define A2DP_ERR_UNKNOWN_ERROR 0xFF
/* End of A2dpError */
/*---------------------------------------------------------------------------
* A2dpVersion type
*
* Describes the version of the A2DP profile (0x0100 means version 1.0).
*/
typedef uint16_t A2dpVersion;
/* End of A2dpVersion */
/*---------------------------------------------------------------------------
* A2dpFeatures type
*
* Describes the features of a source or sink.
*/
typedef uint16_t A2dpFeatures;
/* Audio Player */
#define A2DP_SRC_FEATURE_PLAYER 0x01
/* Microphone */
#define A2DP_SRC_FEATURE_MIC 0x02
/* Tuner */
#define A2DP_SRC_FEATURE_TUNER 0x04
/* Mixer */
#define A2DP_SRC_FEATURE_MIXER 0x08
/* Headphones */
#define A2DP_SNK_FEATURE_HEADPHONE 0x01
/* Loudspeaker */
#define A2DP_SNK_FEATURE_SPEAKER 0x02
/* Audio Recorder */
#define A2DP_SNK_FEATURE_RECORDER 0x04
/* Amplifier */
#define A2DP_SNK_FEATURE_AMP 0x08
/* End of A2dpFeatures */
/*---------------------------------------------------------------------------
* A2dpEndpointType type
*
* Describes the type of stream (Source or Sink).
*/
typedef uint8_t A2dpEndpointType;
/* The stream is a source */
#define A2DP_STREAM_TYPE_SOURCE 0
/* The stream is a sink */
#define A2DP_STREAM_TYPE_SINK 1
/* End of A2dpEndpointType */
/*---------------------------------------------------------------------------
* A2dpStreamState type
*
* Describes the state of a stream.
*/
typedef uint8_t A2dpStreamState;
/* The stream is closed */
#define A2DP_STREAM_STATE_CLOSED 0
/* The stream is idle */
#define A2DP_STREAM_STATE_IDLE 1
/* The stream is open */
#define A2DP_STREAM_STATE_OPEN 2
/* The stream is streaming */
#define A2DP_STREAM_STATE_STREAMING 3
/* Unknown state */
#define A2DP_STREAM_STATE_UNKNOWN 0xFF
/* End of A2dpStreamState */
/* A2dp device states*/
#define A2DP_DEV_STATE_DISCONNECTED 0x00
#define A2DP_DEV_STATE_INCOMING 0x01
#define A2DP_DEV_STATE_OUTGOING 0x02
#define A2DP_DEV_STATE_CONNECTED 0x03
/*---------------------------------------------------------------------------
* A2dpSbcCodecInfElement0 type
*
* The first byte of an SBC codec information element contains the
* sampling frequency and the channel mode of the stream. These values
* can all be OR'd together to describe the capabilities of the coded.
*/
typedef uint8_t A2dpSbcCodecInfElement0;
#define A2DP_SBC_CODEC_FREQ_16000 0x80
#define A2DP_SBC_CODEC_FREQ_32000 0x40
#define A2DP_SBC_CODEC_FREQ_44100 0x20
#define A2DP_SBC_CODEC_FREQ_48000 0x10
#define A2DP_SBC_CODEC_CHNL_MODE_MONO 0x08
#define A2DP_SBC_CODEC_CHNL_MODE_DUAL 0x04
#define A2DP_SBC_CODEC_CHNL_MODE_STEREO 0x02
#define A2DP_SBC_CODEC_CHNL_MODE_JOINT 0x01
/* End of A2dpSbcCodecInfElement0 */
/*---------------------------------------------------------------------------
* A2dpSbcCodecInfElement1 type
*
* The second byte of an SBC codec information element contains the
* number of blocks, subbands, and the allocation method to use when
* encoding the stream. These values can all be OR'd together to
* describe the capabilities of the codec.
*/
typedef uint8_t A2dpSbcCodecInfElement1;
#define A2DP_SBC_CODEC_BLOCKS_4 0x80
#define A2DP_SBC_CODEC_BLOCKS_8 0x40
#define A2DP_SBC_CODEC_BLOCKS_12 0x20
#define A2DP_SBC_CODEC_BLOCKS_16 0x10
#define A2DP_SBC_CODEC_SUBBANDS_4 0x08
#define A2DP_SBC_CODEC_SUBBANDS_8 0x04
#define A2DP_SBC_CODEC_ALLOCATION_SNR 0x02
#define A2DP_SBC_CODEC_ALLOCATION_LOUDNESS 0x01
/* End of A2dpSbcCodecInfElement1 */
/*---------------------------------------------------------------------------
* A2dpAacCodecInfElement1 type
*/
typedef uint8_t A2dpAacCodecInfElement1;
#define A2DP_AAC_CODEC_MPEG2_LC 0x80
#define A2DP_AAC_CODEC_MPEG4_LC 0x40
#define A2DP_AAC_CODEC_MPEG4_LTP 0x20
#define A2DP_AAC_CODEC_MPEG4_SCALABLE 0x10
/* End of A2dpAacCodecInfElement1 */
/*---------------------------------------------------------------------------
* A2dpAacCodecInfElement2 type
*/
typedef uint8_t A2dpAacCodecInfElement2;
#define A2DP_AAC_CODEC_FREQ_8000 0x80
#define A2DP_AAC_CODEC_FREQ_11025 0x40
#define A2DP_AAC_CODEC_FREQ_12000 0x20
#define A2DP_AAC_CODEC_FREQ_16000 0x10
#define A2DP_AAC_CODEC_FREQ_22050 0x08
#define A2DP_AAC_CODEC_FREQ_24000 0x04
#define A2DP_AAC_CODEC_FREQ_32000 0x02
#define A2DP_AAC_CODEC_FREQ_44100 0x01
/* End of A2dpAacCodecInfElement2 */
/*---------------------------------------------------------------------------
* A2dpAacCodecInfElement3 type
*/
typedef uint8_t A2dpAacCodecInfElement3;
#define A2DP_AAC_CODEC_FREQ_48000 0x80
#define A2DP_AAC_CODEC_FREQ_64000 0x40
#define A2DP_AAC_CODEC_FREQ_88200 0x20
#define A2DP_AAC_CODEC_FREQ_96000 0x10
#define A2DP_AAC_CODEC_CHNL_MONO 0x08
#define A2DP_AAC_CODEC_CHNL_STEREO 0x04
/* End of A2dpAacCodecInfElement3 */
/*---------------------------------------------------------------------------
* A2dpAacCodecInfElement4 type
*/
typedef uint8_t A2dpAacCodecInfElement4;
#define A2DP_AAC_CODEC_FREQ_48000 0x80
#define A2DP_AAC_CODEC_FREQ_64000 0x40
#define A2DP_AAC_CODEC_FREQ_88200 0x20
#define A2DP_AAC_CODEC_FREQ_96000 0x10
#define A2DP_AAC_CODEC_CHNL_MONO 0x08
#define A2DP_AAC_CODEC_CHNL_STEREO 0x04
#define A2DP_AAC_CODEC_VBR 0x80
/* End of A2dpAacCodecInfElement4 */
/* Forward declaration */
typedef struct _A2dpCallbackParms A2dpCallbackParms;
typedef struct _A2dpStream A2dpStream;
/*---------------------------------------------------------------------------
* A2dpCallback type
*
* A function of this type is called to indicate events to the application.
*/
typedef void (*A2dpCallback)(A2dpStream *Stream, const A2dpCallbackParms *Info);
/* End of A2dpCallback */
/****************************************************************************
*
* Data Structures
*
****************************************************************************/
/* AvdevCmdToken structure - used internally */
struct _AvCmdToken {
/* Flag to determine if the token is in use */
int inUse;
/* On input contains the callback function for discoveries */
void * callback;
/* On input contains the type of command to send */
uint8_t cmdType;
/* On input contains the parameters of specific commands */
union {
/* Parms for the AVDTP Connect command */
struct {
BtRemoteDevice *remDev;
} connect;
/* Parms for the Get Capabillies command */
struct {
AvdtpStreamId id;
} getCap;
/* Parms for the Accept Link command */
struct {
int accept;
} acceptLink;
} p;
};
typedef struct _AvCmdToken AvCmdToken;
/*---------------------------------------------------------------------------
* AvDevice structure
*
* Indentifies the remote AV device, or the signaling channel connected to
* that device. No fields in this structure are usable by applications.
*/
struct _AvDevice {
ListEntry node; /* Used internally by AvDevice */
AvdtpChannel channel; /* AVDTP channel */
uint8_t refCount; /* Reference count for signal channel */
CmgrHandler cmgrHandler; /* Used for SDP and signal channel */
uint8_t state; /* Device state */
uint8_t flags; /* Device flags */
AvCmdToken cmdToken; /* Command Token used for this device */
int delayReporting; /* Indicates whether delay reporting is
* supported or not.
*/
/* Used by upper layer */
void *currentStream; /* Current stream on this device */
uint8_t currentType; /* Current type of stream */
/* Updated by SDP queries */
SdpQueryToken sdpQueryToken; /* SDP query token */
uint8_t queryFlags; /* SDP query flags */
uint8_t features;
uint16_t avdtpVersion; /* Version of AVDTP on the remote device */
uint16_t a2dpVersion; /* Version of A2DP on the remote device */
uint16_t vdpVersion; /* Version of VDP on the remote device */
};
typedef struct _AvDevice AvDevice;
/*---------------------------------------------------------------------------
* A2dpSbcPacket structure
*
* Used for transmitting SBC data.
*/
typedef struct _A2dpSbcPacket {
ListEntry node; /* Used internally by A2DP */
uint8_t *data; /* Pointer to transmit data */
uint16_t dataLen; /* Length of transmit data */
uint16_t frameSize; /* Size of an SBC frame */
/* === Internal use only === */
BtPacket packet; /* For sending over L2CAP */
uint16_t dataSent;
uint16_t frmDataSent;
} A2dpSbcPacket;
/*---------------------------------------------------------------------------
* A2dpCallbackParms structure
*
* Contains information about the application callback event.
*/
struct _A2dpCallbackParms {
A2dpEvent event; /* The A2DP Event */
uint16_t len; /* Length of the parameters */
BtStatus status; /* Transport status */
A2dpError error; /* The A2DP or AVDTP error code
* associated with the event (if
* any).
*/
BtErrorCode discReason; /* Link disconnect reason (if any). */
union {
AvdtpContentProt *cp; /* Content Protection Capability */
AvdtpCodec *codec; /* Codec Capability */
AvdtpCapability *capability; /* AVDTP Capability */
AvdtpConfigRequest *configReq; /* AVDTP Config request */
BtPacket *btPacket; /* Raw Transmit packet */
A2dpSbcPacket *sbcPacket; /* SBC Transmit packet */
uint8_t *data; /* Receive data */
uint16_t delayMs; /* Buffering/processing delay of
* the Sink.
*/
AvdtpStreamInfo *streamInfo; /* Stream information */
void *device; /* The connecting or disconnecting
* device.
*/
} p;
};
/* Stream information returned by stream discovery */
typedef struct _A2dpStreamInfo {
ListEntry node; /* Used internally by A2DP. */
AvdtpStreamInfo info; /* Stream information */
} A2dpStreamInfo;
/*---------------------------------------------------------------------------
* A2dpStream structure
*
* Contains the A2DP stream object. This structure identifies the stream
* in callbacks and API calls.
*/
struct _A2dpStream {
ListEntry node; /* Used internally by A2DP. */
A2dpEndpointType type; /* Stream endpoint type */
/* === Internal use only === */
A2dpCallback callback; /* Application callback */
AvDevice *device; /* The device associated with the
* stream
*/
AvdtpStream stream; /* Stream structure used by this
* source
*/
ListEntry sbcQueue; /* Transmit queue for SBC data */
AvdtpMediaHeader mediaHeader; /* Media header for SBC packets */
uint16_t timeInc; /* Time stamp increment */
AvdtpCapability lastCap;
AvdtpCallbackParms lastParms; /* Last AV error that occurred */
uint8_t flags; /* State flags */
ListEntry streamInfoList; /* List of stream information used
* during the discovery process.
*/
A2dpStreamInfo *currentInfo; /* Stream discovery info used with
* with the current operation
*/
EvmTimer closeTimer; /* Closes stream when open never
* completes
*/
};
typedef struct _SbcStreamInfo {
/* Bitpool affects the bitrate of the stream according to the following
* formula: bit_rate = 8 * frameLength * sampleFreq / numSubBands /
* numBlocks. The frameLength value can be determined by setting the
* bitPool value and calling the SBC_FrameLen() function.
* Bitpool can be changed dynamically from frame to frame during
* encode/decode without suspending the stream.
*/
uint8_t bitPool;
/* Sampling frequency of the stream */
uint8_t sampleFreq;
/* The channel (Mono, Stereo, etc.) */
uint8_t channelMode;
/* The allocation method for the stream */
uint8_t allocMethod;
/* Number of blocks used to encode the stream (4, 8, 12, or 16) */
uint8_t numBlocks;
/* The number of subbands in the stream (4 or 8) */
uint8_t numSubBands;
/* The number of channels in the stream (calculated from channelMode) */
uint8_t numChannels;
} SbcStreamInfo;
/****************************************************************************
*
* Function Reference
*
****************************************************************************/
/*---------------------------------------------------------------------------
* A2DP_Init()
*
* Initialize the A2DP SDK. This function should only be called
* once, normally at initialization time. The calling of this function
* can be specified in overide.h using the XA_LOAD_LIST macro
* (i.e. #define XA_LOAD_LIST XA_MODULE(A2DP) ... ).
*
* Returns:
*
* TRUE - Initialization was successful
*
* FALSE - Initialization failed.
*/
int A2DP_Init(void);
/*---------------------------------------------------------------------------
* A2DP_Register()
*
* Registers an audio source or sink for both originating and receiving
* connections. An application callback function is provided for
* receiving A2DP events. This function must be called before any
* other A2DP source functions.
*
* Parameters:
* Stream - An initialized A2DP stream structure, the 'type' field must
* be initialized with the appropriate endpoint type (see
* A2dpEndpointType).
*
* Codec - An initialized AVDTP codec structure (see AvdtpCodec). All
* fields must be initialized.
*
* Callback - Identifies the application function that will be called
* with A2DP events.
*
* Returns:
* BT_STATUS_SUCCESS - The A2DP stream was successfully registered.
*
* BT_STATUS_IN_USE - The specified source is already in use.
*
* BT_STATUS_INVALID_PARM - The 'Stream' or 'Callback' parameter
* does not contain a valid pointer. (XA_ERROR_CHECK only).
*/
BtStatus A2DP_Register(A2dpStream *Stream,
AvdtpCodec *Codec,
A2dpCallback Callback);
/*---------------------------------------------------------------------------
* A2DP_Deregister()
*
* Deregisters the audio source or sink.
*
* Parameters:
*
* Stream - A registered A2DP stream structure.
*
* Returns:
*
* BT_STATUS_SUCCESS - The A2DP stream was successfully deregistered.
*
* BT_STATUS_IN_USE - The specified stream is already in use.
*
* BT_STATUS_INVALID_PARM - The 'Stream' parameter does not contain
* a valid pointer. (XA_ERROR_CHECK only).
*/
BtStatus A2DP_Deregister(A2dpStream *Stream);
/*---------------------------------------------------------------------------
* A2DP_AddContentProtection()
*
* Adds content protection capabilities to a registered stream. Multiple
* capabilities can be added to a single stream. Once registered,
* the content protection structure's memory is "owned" by A2DP. This
* memory must not be changed or freed. Once a stream is deregistered
* the content protection structure memory can be changed or freed.
*
* Parameters:
*
* Stream - A registered A2DP stream.
*
* Cp - Structure that defines the type of content protection supported
* by the stream.
*
* Returns:
*
* BT_STATUS_SUCCESS - The content protection was successfully
* registered.
*
* BT_STATUS_INVALID_PARM - The 'Stream' or 'Cp' parameter does not
* contain a valid pointer. (XA_ERROR_CHECK only).
*
* BT_STATUS_NOT_FOUND - The specified stream has not been registered.
*
* BT_STATUS_IN_USE - The specified stream or content protection is in
* use.
*/
extern BtStatus AVDTP_SuspendStream(AvdtpStream *Stream);
BtStatus A2DP_AddContentProtection(A2dpStream *Stream, AvdtpContentProt *Cp);
#define A2DP_AddContentProtection(s, c) AVDTP_AddContentProtection(&(s)->stream, c)
/*---------------------------------------------------------------------------
* A2DP_OpenStream()
*
* Searches for and begins to open a stream on the remote device. This
* function searches for a stream with capabilities matching those that
* were registered using A2DP_Register() and
* A2DP_AddContentProtection(). As streams are discovered, the
* application is notified of matching capability types through the
* A2DP_EVENT_CODEC_INFO and A2DP_EVENT_CP_INFO events. The application
* can cache or verify the specific elements of these capabilities. When
* all matching capabilities have been discovered, the application is
* notified through the A2DP_EVENT_GET_CONFIG_IND event. When this event
* is received, the application must call A2DP_SetStreamConfig(). The
* connection progress will not continue until the stream has been
* configured. Once configured, the application will receive the
* A2DP_STREAM_OPEN event. When this event has been received with no
* errors, the stream is open. If no streams with matching capabilities
* can be found, the stream is closed.
*
* A2DP_AbortStream() can be called to close the stream to abort this
* process if necessary.
*
* Parameters:
*
* Stream - A registered and configured A2DP stream.
*
* Addr - The Bluetooth address of the device to which the connection
* should be made. If Addr is 0, then a device inquiry will be
* initiated. A Device Monitor handler must be registered to
* receive events and to select the desired device. It is only
* possible to use and value of 0 for Addr if connecting to a
* device that is not already connected. If the device was
* already connected, an attempt to connect again will fail. To
* establish a new stream to an already connected device, the
* BD_ADDR of the connected device must be used in the Addr
* parameter.
*
* Returns:
*
* BT_STATUS_PENDING - The Open Stream operation was started
* successfully. Codec and Content Protection events will be
* received if a stream is discovered.
*
* BT_STATUS_INVALID_PARM - The 'Stream', or 'Cp' parameter does not
* contain a valid pointer. (XA_ERROR_CHECK only).
*
* BT_STATUS_IN_USE - The specified stream is already in use.
*
* BT_STATUS_BUSY - A search is already in progress.
*
* BT_STATUS_NOT_FOUND - The specified channel or stream is not
* registered.
*
* Other - It is possible to receive other error codes, depending on the
* lower layer service in use (L2CAP or Management Entity).
*/
BtStatus A2DP_OpenStream(A2dpStream *Stream, BD_ADDR *Addr);
/* Used by the following macros */
BtStatus A2dpSetStreamConfig(A2dpStream *Stream,
AvdtpCodec *Codec,
AvdtpContentProt *Cp,
uint16_t delayMs);
/*---------------------------------------------------------------------------
* A2DP_SetStreamConfig()
*
* Configures the specified stream. This function is called in response
* to the A2DP_EVENT_GET_CONFIG_IND event or when the stream has been
* placed into the idle state (see A2DP_IdleStream()). The desired Codec
* and Content Protection information is selected based on the
* capabilities received in the A2DP_EVENT_CODEC_INFO and
* A2DP_EVENT_CP_INFO events. If these event have not been received,
* the stream must be opened by caling A2DP_OpenStream().
*
* Parameters:
*
* Stream - A registered A2DP stream.
*
* Codec - Structure that defines the specific codec type to use for this
* stream, and the specific codec elements to use. Selected codec
* elements must not be ambiguous. For example, only one sampling
* frequency should be selected.
*
* Cp - Structure that defines the type of content protection to
* configure on the remote device. This structure must have been
* registered on the stream previously by calling
* A2DP_AddContentProtection(). If no content protection is
* desired, this parameter may be set to NULL.
*
* Returns:
*
* BT_STATUS_PENDING - The Stream Config operation was started
* successfully. The stream open process will continue. Once the
* stream is open, the A2DP_EVENT_STREAM_OPEN event will be
* received.
*
* BT_STATUS_INVALID_PARM - The 'Stream', 'Codec', or 'Cp' parameter
* does not contain a valid pointer. (XA_ERROR_CHECK only).
*
* BT_STATUS_FAILED - The specified stream is not in the correct state.
*
* BT_STATUS_NOT_FOUND - The specified channel or stream is not
* registered.
*
* Other - It is possible to receive other error codes, depending on the
* lower layer service in use (L2CAP or Management Entity).
*/
BtStatus A2DP_SetStreamConfig(A2dpStream *Stream,
AvdtpCodec *Codec,
AvdtpContentProt *Cp);
#define A2DP_SetStreamConfig(s, c, p) A2dpSetStreamConfig(s, c, p, 0)
/*---------------------------------------------------------------------------
* A2DP_SetStreamConfigWithSinkDelay()
*
* Configures the specified stream. This function is called in response
* to the A2DP_EVENT_GET_CONFIG_IND event or when the stream has been
* placed into the idle state (see A2DP_IdleStream()). The desired Codec
* and Content Protection information is selected based on the
* capabilities received in the A2DP_EVENT_CODEC_INFO and
* A2DP_EVENT_CP_INFO events. If these event have not been received,
* the stream must be opened by caling A2DP_OpenStream(). A value
* representing the delay in the Sink buffering/processing may be
* specified.
*
* Parameters:
*
* Stream - A registered A2DP stream.
*
* Codec - Structure that defines the specific codec type to use for this
* stream, and the specific codec elements to use. Selected codec
* elements must not be ambiguous. For example, only one sampling
* frequency should be selected.
*
* Cp - Structure that defines the type of content protection to
* configure on the remote device. This structure must have been
* registered on the stream previously by calling
* A2DP_AddContentProtection(). If no content protection is
* desired, this parameter may be set to NULL.
*
* delayMs - Delay in milliseconds for the Sinks buffering/processing of
* audio data. If the Stream is a Source, this value is ignored.
*
*
* Returns:
*
* BT_STATUS_PENDING - The Stream Config operation was started
* successfully. The stream open process will continue. Once the
* stream is open, the A2DP_EVENT_STREAM_OPEN event will be
* received.
*
* BT_STATUS_INVALID_PARM - The 'Stream', 'Codec', or 'Cp' parameter
* does not contain a valid pointer. (XA_ERROR_CHECK only).
*
* BT_STATUS_FAILED - The specified stream is not in the correct state.
*
* BT_STATUS_NOT_FOUND - The specified channel or stream is not
* registered.
*
* Other - It is possible to receive other error codes, depending on the
* lower layer service in use (L2CAP or Management Entity).
*/
BtStatus A2DP_SetStreamConfigWithSinkDelay(A2dpStream *Stream,
AvdtpCodec *Codec,
AvdtpContentProt *Cp,
uint16_t delayMs);
#define A2DP_SetStreamConfigWithSinkDelay(s, c, p, f) A2dpSetStreamConfig(s, c, p, f)
/* Used by the following macros */
BtStatus A2dpOpenStreamRsp(A2dpStream *Stream,
A2dpError Error,
AvdtpCapabilityType CapType,
uint16_t delayMs);
/*---------------------------------------------------------------------------
* A2DP_OpenStreamRsp()
*
* Responds to an request to open a connection with the remote device
* (See A2DP_EVENT_STREAM_OPEN_IND). The open request is accepted by the
* application if this function is called with A2DP_ERR_NO_ERROR. Any
* other error code rejects the request.
*
* Parameters:
*
* Stream - A registered and configured A2DP stream.
*
* Error - If the request to open the connection is granted then
* A2DP_ERR_NO_ERROR is passed in this parameter, otherwise
* another appropriate error code should be used.
*
* CapType - Capability type associated with the reason for rejecting
* the connection. If 'Error' is set to A2DP_ERR_NO_ERROR,
* this parameter is ignored.
*
* Returns:
*
* BT_STATUS_PENDING - The Open Stream Response operation was started
* successfully. An A2DP_EVENT_STREAM_OPEN event will be received
* when the stream is open.
*
* BT_STATUS_INVALID_PARM - The 'Stream' parameter does not contain a
* valid pointer. (XA_ERROR_CHECK only).
*
* BT_STATUS_NO_CONNECTION - The specified stream did not request a
* connection.
*
* BT_STATUS_NOT_FOUND - The specified channel or stream is not
* registered.
*
* Other - It is possible to receive other error codes, depending on the
* lower layer service in use (L2CAP or Management Entity).
*/
BtStatus A2DP_OpenStreamRsp(A2dpStream *Stream,
A2dpError Error,
AvdtpCapabilityType CapType);
#define A2DP_OpenStreamRsp(s, e, c) A2dpOpenStreamRsp(s, e, c, 0)
/*---------------------------------------------------------------------------
* A2DP_OpenStreamRspWithSinkDelay()
*
* Responds to an request to open a connection with the remote device
* (See A2DP_EVENT_STREAM_OPEN_IND). The open request is accepted by the
* application if this function is called with A2DP_ERR_NO_ERROR. Any
* other error code rejects the request. A value representing the delay
* in the Sink buffering/processing may be specified.
*
* Parameters:
*
* Stream - A registered and configured A2DP stream.
*
* Error - If the request to open the connection is granted then
* A2DP_ERR_NO_ERROR is passed in this parameter, otherwise
* another appropriate error code should be used.
*
* CapType - Capability type associated with the reason for rejecting
* the connection. If 'Error' is set to A2DP_ERR_NO_ERROR,
* this parameter is ignored.
*
* delayMs - A value representing the delay in the Sink
* buffering/processing. If the Stream is a Source, this value is
* ignored.
*
* Returns:
*
* BT_STATUS_PENDING - The Open Stream Response operation was started
* successfully. An A2DP_EVENT_STREAM_OPEN event will be received
* when the stream is open.
*
* BT_STATUS_INVALID_PARM - The 'Stream' parameter does not contain a
* valid pointer. (XA_ERROR_CHECK only).
*
* BT_STATUS_NO_CONNECTION - The specified stream did not request a
* connection.
*
* BT_STATUS_NOT_FOUND - The specified channel or stream is not
* registered.
*
* Other - It is possible to receive other error codes, depending on the
* lower layer service in use (L2CAP or Management Entity).
*/
BtStatus A2DP_OpenStreamRspWithSinkDelay(A2dpStream *Stream,
A2dpError Error,
AvdtpCapabilityType CapType,
uint16_t delayMs);
#define A2DP_OpenStreamRspWithSinkDelay(s, e, c, f) A2dpOpenStreamRsp(s, e, c, f)
/*---------------------------------------------------------------------------
* A2DP_SetSinkDelay()
*
* Set a value representing the delay in the Sink buffering/processing.
* This call can be made by a Sink when the delay changes, or by a Source
* if the Sink reports a change in the delay. If a Source calls this
* function, it will set the flush timeout and, upon success, return
* BT_STATUS_SUCCESS. If a Sink calls this function, and Delay Reporting
* feature is enabled, it will send the delay value to the Source and,
* upon success, return BT_STATUS_PENDING.
*
* Parameters:
*
* Stream - A registered and configured A2DP stream.
*
* delayMs - A value representing the delay in the Sink
* buffering/processing. If the Stream is a Source, this value is
* ignored.
*
* Returns:
* BT_STATUS_SUCCESS - Flush Timeout was set. No events will be
* received.
*
* BT_STATUS_PENDING - The delay value was sent to the Source. When the
* Source acnkowldeged the value, the A2DP_EVENT_DELAY_REPORTING_CNF
* event will be received (only if Delay Reporting feature is
* enabled).
*
* BT_STATUS_FAILED - The stream is not a Sink or is not in the correct
* state (STREAMING) for sending this command.
*
* BT_STATUS_INVALID_PARM - The 'Stream' parameter does not contain a
* valid pointer. (XA_ERROR_CHECK only).
*
* BT_STATUS_IN_USE - The specified streams is already in use.
*
* BT_STATUS_NOT_FOUND - The specified channel or stream is not
* registered.
*
* BT_STATUS_NO_CONNECTION - The stream is not allocated on a channel.
*
* Other - It is possible to receive other error codes, depending on the
* lower layer service in use (L2CAP or Management Entity).
*/
BtStatus A2DP_SetSinkDelay(A2dpStream *Stream, uint16_t delayMs);
/*---------------------------------------------------------------------------
* A2DP_GetStreamCapabilities()
*
* Query the remote stream for its capabilities.
*
* Parameters:
*
* Stream - A registered and open A2DP stream.
*
* Returns:
*
* BT_STATUS_PENDING - The Get Capabilities operation was started
* successfully. An A2DP_EVENT_CODEC_INFO event will be received.
* If the remote device has any content protection registered, then
* a A2DP_EVENT_CP_INFO event will be received for each registered
* capability. When all capabilities have been notified, an
* A2DP_EVENT_GET_CAP_CNF event will be received.
*
* BT_STATUS_INVALID_PARM - The 'Stream' parameter is not valid.
* (XA_ERROR_CHECK only).
*
* BT_STATUS_NOT_FOUND - The specified stream is not registered.
*
* BT_STATUS_NO_CONNECTION - No connection exists on this stream.
*
* Other - It is possible to receive other error codes, depending on the
* lower layer service in use (L2CAP or Management Entity).
*/
BtStatus A2DP_GetStreamCapabilities(A2dpStream *Stream);
/* Used by macros below */
BtStatus A2dpCloseStream(A2dpStream *Stream, int discFlag);
/*---------------------------------------------------------------------------
* A2DP_CloseStream()
*
* Initiate the closing an open stream.
*
* Parameters:
*
* Stream - A registered and open A2DP stream.
*
* Returns:
*
* BT_STATUS_PENDING - The Close Stream operation was started
* successfully. An A2DP_EVENT_STREAM_CLOSED event will be received
* when the stream is closed.
*
* BT_STATUS_NO_CONNECTION - The stream is not in the open or active
* state.
*
* BT_STATUS_INVALID_PARM - The 'Stream' parameter does not
* contain a valid pointer. (XA_ERROR_CHECK only).
*
* BT_STATUS_NOT_FOUND - The specified channel or stream is not
* registered.
*
* Other - It is possible to receive other error codes, depending on the
* lower layer service in use (L2CAP or Management Entity).
*/
BtStatus A2DP_CloseStream(A2dpStream *Stream);
#define A2DP_CloseStream(s) A2dpCloseStream((s), TRUE)
/*---------------------------------------------------------------------------
* A2DP_IdleStream()
*
* Put the stream into the Idle state. This differs from closing the
* stream, because the lower layers (L2CAP and ACL) stay connected. When
* in this state, it is necessary to configure the stream again before
* starting the Stream (see A2DP_SetStreamConfig()).
*
* Parameters:
*
* Stream - A registered and open A2DP stream.
*
* Returns:
*
* BT_STATUS_PENDING - The Idle Stream operation was started
* successfully. An A2DP_EVENT_STREAM_IDLE event will be received
* when the stream is closed.
*
* BT_STATUS_FAILED - The stream is not in the open or active state.
*
* BT_STATUS_INVALID_PARM - The 'Stream' parameter does not
* contain a valid pointer. (XA_ERROR_CHECK only).
*
* BT_STATUS_NOT_FOUND - The specified channel or stream is not
* registered.
*
* Other - It is possible to receive other error codes, depending on the
* lower layer service in use (L2CAP or Management Entity).
*/
BtStatus A2DP_IdleStream(A2dpStream *Stream);
#define A2DP_IdleStream(s) A2dpCloseStream((s), FALSE)
/*---------------------------------------------------------------------------
* A2DP_StartStream()
*
* Initiates streaming on the open stream. Calling this function puts
* the stream into an active state, which allows media packets to be sent
* on the stream.
*
* Parameters:
*
* Stream - A registered and open A2DP stream.
*
* Returns:
*
* BT_STATUS_PENDING - The operation was initiated successfully.
* An A2DP_EVENT_STREAM_STARTED event will be received when the
* stream is ready for streaming.
*
* BT_STATUS_FAILED - The stream is not in the open state.
*
* BT_STATUS_INVALID_PARM - The 'Stream' parameter does not contain a
* valid pointer. (XA_ERROR_CHECK only).
*
* BT_STATUS_IN_USE - One of the specified streams is already in use.
*
* BT_STATUS_NOT_FOUND - The specified channel or stream is not
* registered.
*
* Other - It is possible to receive other error codes, depending on the
* lower layer service in use (L2CAP or Management Entity).
*/
BtStatus A2DP_StartStream(A2dpStream *Stream);
#define A2DP_StartStream(s) AVDTP_StartStream(&(s)->stream)
/*---------------------------------------------------------------------------
* A2DP_StartStreamRsp()
*
* Called in response to an A2DP_EVENT_STREAM_START_IND event. Calling
* this function will either accept the streaming request or reject it.
*
* Parameters:
*
* Stream - A registered and open A2DP stream.
*
* Error - If the streaming request is accepted, this parameter must be
* set to A2DP_ERR_NO_ERROR. If the streaming request is rejected,
* this parameter must be set to the appropriate error defined by
* A2dpError.
*
* Returns:
*
* BT_STATUS_PENDING - The Start Streams Response operation was started
* successfully. An A2DP_EVENT_STREAM_STARTED event will be received
* when the stream has been started. If the start stream request was
* rejected, the A2DP_EVENT_STREAM_SUSPENDED event will be received.
*
* BT_STATUS_FAILED - The stream is not in the open state.
*
* BT_STATUS_INVALID_PARM - The Stream parameter does not contain a
* valid pointer. (XA_ERROR_CHECK only).
*
* BT_STATUS_IN_USE - One of the specified streams is already in use.
*
* BT_STATUS_NOT_FOUND - The specified channel or stream is not
* registered.
*
* Other - It is possible to receive other error codes, depending on the
* lower layer service in use (L2CAP or Management Entity).
*/
extern BtStatus AVDTP_StartStreamRsp(AvdtpStream *Stream, AvdtpError Error);
BtStatus A2DP_StartStreamRsp(A2dpStream *Stream, A2dpError Error);
#define A2DP_StartStreamRsp(s, e) AVDTP_StartStreamRsp(&(s)->stream, e)
/*---------------------------------------------------------------------------
* A2DP_SuspendStream()
*
* Suspends a stream that is currently active.
*
* Parameters:
*
* Stream - A registered and active A2DP stream.
*
* Returns:
*
* BT_STATUS_PENDING - The Suspend Streams Response operation was started
* successfully. An A2DP_EVENT_STREAM_SUSPENDED event will be
* received when the stream has been suspended.
*
* BT_STATUS_FAILED - The stream is not in an active state.
*
* BT_STATUS_INVALID_PARM - The 'Stream' parameter does not contain a
* valid pointer. (XA_ERROR_CHECK only).
*
* BT_STATUS_NOT_FOUND - The specified channel or stream is not
* registered.
*
* Other - It is possible to receive other error codes, depending on the
* lower layer service in use (L2CAP or Management Entity).
*/
BtStatus A2DP_SuspendStream(A2dpStream *Stream);
#define A2DP_SuspendStream(s) AVDTP_SuspendStream(&(s)->stream)
/*---------------------------------------------------------------------------
* A2DP_ReconfigStream()
*
* Reconfigure an open stream. This call can be made only if the stream
* is in the open state. In other words, a stream that is currently
* streaming audio/video must be suspended before trying to reconfigure
* it.
*
* Parameters:
*
* Stream - A registered and open A2DP stream.
*
* Codec - Structure that defines the specific codec type to use for this
* stream, and the specific codec elements to use. Selected codec
* elements must not be ambiguous. For example, only one sampling
* frequency should be selected.
*
* Cp - Structure that defines the type of content protection to
* configure on the remote device. This structure must have been
* registered on the stream previously by calling
* A2DP_AddContentProtection(). If no content protection is
* desired, this parameter may be set to NULL.
*
* Returns:
*
* BT_STATUS_PENDING - The Reconfig operation was started successfully.
* An A2DP_EVENT_STREAM_RECONFIG event will be received when the
* stream is reconfigured.
*
* BT_STATUS_FAILED - The stream is not in the open state.
*
* BT_STATUS_INVALID_PARM - The 'Stream' or 'Cp' parameter does not
* contain a valid pointer. (XA_ERROR_CHECK only).
*
* BT_STATUS_NOT_FOUND - The specified channel or stream is not
* registered.
*
* Other - It is possible to receive other error codes, depending on the
* lower layer service in use (L2CAP or Management Entity).
*/
BtStatus A2DP_ReconfigStream(A2dpStream *Stream,
AvdtpCodec *Codec,
AvdtpContentProt *Cp);
#define A2DP_ReconfigStream(s, c, cp) AVDTP_Reconfig(&(s)->stream, c, cp)
/*---------------------------------------------------------------------------
* A2DP_ReconfigStreamRsp()
*
* Respond to a request to reconfigure an open stream (See
* A2DP_EVENT_STREAM_RECONFIG_IND). This call can be made only if the
* stream is in the open state.
*
* Parameters:
*
* Stream - A registered and open A2DP stream.
*
* Error - If the request to reconfigure the stream is granted then
* A2DP_ERR_NO_ERROR is passed in this parameter, otherwise
* another appropriate error code should be used.
*
* Type - Capability type that caused an error (if any). This value
* is ignored if 'Error' is set to A2DP_ERR_NO_ERROR.
*
* Returns:
*
* BT_STATUS_PENDING - The operation was started successfully.
* An A2DP_EVENT_STREAM_RECONFIG_CNF event will be received when the
* stream is reconfigured.
*
* BT_STATUS_FAILED - The stream is not in the open state.
*
* BT_STATUS_INVALID_PARM - The 'Stream' parameter does not contain a
* valid pointer. (XA_ERROR_CHECK only).
*
* BT_STATUS_NOT_FOUND - The specified channel or stream is not
* registered.
*
* Other - It is possible to receive other error codes, depending on the
* lower layer service in use (L2CAP or Management Entity).
*/
BtStatus A2DP_ReconfigStreamRsp(A2dpStream *Stream,
A2dpError Error,
AvdtpCapabilityType Type);
#define A2DP_ReconfigStreamRsp(s, e, t) AVDTP_ReconfigRsp(&(s)->stream, e, t)
/*---------------------------------------------------------------------------
* A2DP_SecurityControlReq()
*
* Initiates a security procedure (content protection). The security
* procedure data is application specific and is not interpreted in any
* way by A2DP.
*
* Parameters:
*
* Stream - A registered A2DP stream.
*
* Data - Application specific data.
*
* Len - Length of the security data.
*
* Returns:
*
* BT_STATUS_PENDING - The Security Request operation was started
* successfully. An A2DP_EVENT_STREAM_SECURITY_CNF event will be
* received when the security data has been sent.
*
* BT_STATUS_FAILED - The stream is not in the correct state or content
* protection is not configured on the stream.
*
* BT_STATUS_INVALID_PARM - The 'Stream' or 'Data' parameter does not
* contain a valid pointer. (XA_ERROR_CHECK only).
*
* BT_STATUS_NOT_SUPPORTED - The current stream is not configured for
* content protection.
*
* BT_STATUS_NOT_FOUND - The specified channel or stream is not
* registered.
*
* Other - It is possible to receive other error codes, depending on the
* lower layer service in use (L2CAP or Management Entity).
*/
BtStatus A2DP_SecurityControlReq(A2dpStream *Stream, uint8_t *Data, uint16_t Len);
#define A2DP_SecurityControlReq(s, d, l) AVDTP_SecurityControlReq(&(s)->stream, d, l)
/*---------------------------------------------------------------------------
* A2DP_SecurityControlRsp()
*
* Called in response to an A2DP_EVENT_STREAM_SECURITY_IND event. The
* security procedure data is application specific and is not interpreted
* in any way by A2DP.
*
* Parameters:
*
* Stream - A registered A2DP stream.
*
* Data - Application specific data.
*
* Len - Length of the security data.
*
* Error - If the security request is accepted, this parameter must be
* set to AVDTP_ERR_NO_ERROR. If the security request is rejected,
* this parameter must be set to the appropriate error defined by
* AvdtpError.
*
* Returns:
*
* BT_STATUS_PENDING - The Security Request operation was started
* successfully. An A2DP_EVENT_STREAM_SECURITY_CNF event will be
* received when the security data has been sent. This event will
* be received even if the security request was rejected, however,
* the 'error' field of the callback parameters will be set to the
* value sent in the 'Error' parameter.
*
* BT_STATUS_FAILED - The stream is not in the correct state.
*
* BT_STATUS_INVALID_PARM - The 'Stream' or 'Data' parameter does not
* contain a valid pointer. (XA_ERROR_CHECK only).
*
* BT_STATUS_NOT_FOUND - The specified channel or stream is not
* registered.
*
* Other - It is possible to receive other error codes, depending on the
* lower layer service in use (L2CAP or Management Entity).
*/
BtStatus A2DP_SecurityControlRsp(A2dpStream *Stream,
uint8_t *Data,
uint16_t Len,
AvdtpError Error);
#define A2DP_SecurityControlRsp(s, d, l, e) AVDTP_SecurityControlRsp(&(s)->stream, d, l, e)
/*---------------------------------------------------------------------------
* A2DP_AbortStream()
*
* Aborts any open or active stream. Once aborted, an open stream will
* be in a closed state.
*
* Parameters:
*
* Stream - An open, or active A2DP stream.
*
* Returns:
*
* BT_STATUS_PENDING - The Abort Stream operation was started
* successfully. An A2DP_EVENT_STREAM_ABORTED event will be received
* when the stream has been aborted.
*
* BT_STATUS_FAILED - The stream is not in the correct state.
*
* BT_STATUS_INVALID_PARM - The Stream parameter does not contain a
* valid pointer. (XA_ERROR_CHECK only).
*
* BT_STATUS_NOT_FOUND - The specified channel or stream is not
* registered.
*
* Other - It is possible to receive other error codes, depending on the
* lower layer service in use (L2CAP or Management Entity).
*/
BtStatus A2DP_AbortStream(A2dpStream *Stream);
#define A2DP_AbortStream(s) AVDTP_AbortStream(&(s)->stream)
/*---------------------------------------------------------------------------
* A2DP_StreamSendRawPacket()
*
* Sends data on the specified stream. The stream must be open and in
* an streaming state. No checking is done on the validity of
* the data format. Data is simply delivered to the stream raw. It is
* assumed that the data is properly formatted using the RTP media
* packet format described in RFC1889 (see A2DP_CreateMediaHeader). It
* is further assumed that the payload of the RTP media packet is in the
* proper format for the configured stream.
*
* Parameters:
*
* Stream - A registered and active A2DP stream.
*
* Packet - An initialized BtPacket structure. The Packet->data,
* Packet->dataLen, Packet->header, Packet->headerLen, and
* Packet->flags fields must be properly initialized (see
* BtPacket). The only valid flag that can be used is
* BTP_FLAG_INUSE. The data must be formatted as an RTP media
* packet defined by RFC1889.
*
* Returns:
*
* BT_STATUS_PENDING - The Write operation was started
* successfully. An A2DP_EVENT_STREAM_PACKET_SENT event will be
* received when the data has been sent.
*
* BT_STATUS_FAILED - The stream is not in the active state.
*
* BT_STATUS_INVALID_PARM - The 'Stream' or 'Packet' parameter does not
* contain a valid pointer. (XA_ERROR_CHECK only).
*
* BT_STATUS_NOT_FOUND - The specified channel or stream is not
* registered.
*
* Other - It is possible to receive other error codes, depending on the
* lower layer service in use (L2CAP or Management Entity).
*/
BtStatus A2DP_StreamSendRawPacket(A2dpStream *Stream, BtPacket *Packet);
/*---------------------------------------------------------------------------
* A2DP_StreamSendSbcPacket()
*
* Sends SBC data on the specified stream. The stream must be open and
* in an streaming state. No checking is done on the validity of
* the data format. Data is delivered to the stream with the media
* packet header and SBC header.
*
* Parameters:
*
* Stream - A registered and active A2DP stream.
*
* Packet - An initialized SbcPacket structure with valid SBC data. The
* data, datalen, and FrameSize fields must be initialized. All
* frames in the buffer to be sent must be the same size, which
* means that the Bitpool value for each frame in the SBC data to be
* transmitted must be the same. The bitpool value can changed in
* subsequent calls to this function.
*
* StreamInfo - Information about the SBC stream.
*
* Returns:
*
* BT_STATUS_PENDING - The Write operation was started successfully.
* An A2DP_EVENT_STREAM_SBC_PACKET_SENT event will be received when
* the data has been sent.
*
* BT_STATUS_FAILED - The stream is not in the active state.
*
* BT_STATUS_INVALID_PARM - The 'Stream'' 'Packet,' or 'StreamInfo'
* parameter does not contain a valid pointer. (XA_ERROR_CHECK
* only).
*
* BT_STATUS_NOT_FOUND - The specified channel or stream is not
* registered.
*
* Other - It is possible to receive other error codes, depending on the
* lower layer service in use (L2CAP or Management Entity).
*/
BtStatus A2DP_StreamSendSbcPacket(A2dpStream *Stream,
A2dpSbcPacket *Packet,
SbcStreamInfo *StreamInfo);
#if 0
/*---------------------------------------------------------------------------
* A2DP_StreamIncrementTimeStamp()
*
* Increments the timestamp for the SBC stream. This function should be
* called whenever sampled data cannot be sent and will be discarded
* (due to a lack of resources, for example). Each SBC packet has a
* timestamp associated with it when it is sent, so when PCM data cannot
* be sent, the timestamp needs to be adjusted to account for the lost
* audio data. The amount of the adjustment is obtained from the number
* of samples in the PCM data block.
*
* Parameters:
*
* Stream - A registered and active A2DP stream.
*
* Packet - An initialized SbcPacket structure with valid SBC data. The
* data, datalen, and FrameSize fields must be initialized.
*
* StreamInfo - Information about the SBC stream.
*
* Returns: void
*
*/
void A2DP_StreamIncrementTimeStamp(A2dpStream *Stream, SbcPcmData *Data);
#define A2DP_StreamIncrementTimeStamp(s,d) ((s)->mediaHeader.timestamp += \
(d)->numChannels ? \
(d)->dataLen / 2 / (d)->numChannels : \
0)
#endif
/*---------------------------------------------------------------------------
* A2DP_MediaPacketSize()
*
* Returns the negotiated L2CAP packet size for sending media packets.
*
* Parameters:
*
* Stream - A registered and active A2DP stream.
*
* Returns:
*
* The maximum size for media packets.
*/
uint16_t A2DP_MediaPacketSize(A2dpStream *Stream);
#define A2DP_MediaPacketSize(s) (AVDTP_MediaPacketSize(&(s)->stream))
/*---------------------------------------------------------------------------
* A2DP_CreateMediaHeader()
*
* Used to create a media packet header (RFC1889) before transmitting
* media data using the A2DP_StreamSendRawPacket(). A media packet
* header is typically 12 bytes, but can be up to 72 bytes. Passing in
* a NULL buffer will simply calculate the media header size.
*
* Parameters:
*
* Header - A media packet header structure initialized with the
* appropriate values. The media header values are specified by
* the profile.
*
* Buffer - A buffer in which the media packet header is assembled. If
* NULL, the header is not created, but the size is calculated.
*
* Returns:
*
* The actual size of the media header.
*/
uint16_t A2DP_CreateMediaHeader(AvdtpMediaHeader *Header, uint8_t *Buffer);
#define A2DP_CreateMediaHeader(h, b) AVDTP_CreateMediaHeader(h, b)
/*---------------------------------------------------------------------------
* A2DP_ParseMediaHeader()
*
* Used to parse a media packet header (RFC1889) when a media packet has
* been received from the remote device.
*
* Parameters:
*
* Buffer - A buffer received during the A2DP_EVENT_STREAM_DATA_IND
* event.
*
* Header - A media packet header structure to receive the header
* values.
*
* Returns:
*
* The actual size of the media header.
*/
uint16_t A2DP_ParseMediaHeader(AvdtpMediaHeader *Header, uint8_t *Buffer);
#define A2DP_ParseMediaHeader(h, b) AVDTP_ParseMediaHeader(h, b)
/*---------------------------------------------------------------------------
* A2DP_GetStreamState()
*
* Returns the current stream state.
*
* Parameters:
*
* Stream - An open, or active A2DP stream.
*
* Returns:
*
* The current stream state (see A2dpStreamState).
*/
A2dpStreamState A2DP_GetStreamState(A2dpStream *Stream);
/*---------------------------------------------------------------------------
* A2DP_GetConfiguredCodec()
*
* Returns the current configured codec.
*
* Parameters:
*
* Stream - An open, or active A2DP stream.
*
* Returns:
*
* The current stream codec (see AvtdpCodec).
*/
AvdtpCodec *A2DP_GetConfiguredCodec(A2dpStream *Stream);
/*---------------------------------------------------------------------------
* A2DP_GetRegisteredCodec()
*
* Returns the registered codec.
*
* Parameters:
*
* Stream - An registered stream.
*
* Returns:
*
* The registered stream codec (see AvtdpCodec).
*/
AvdtpCodec *A2DP_GetRegisteredCodec(A2dpStream *Stream);
/*---------------------------------------------------------------------------
* A2DP_GetConfiguredCP()
*
* Returns the configured content protection structure of an open
* stream. If no content protection is configured, this function
* returns 0.
*
* Parameters:
*
* Stream - An open, or active A2DP stream.
*
* Returns:
*
* The configured content protection of the current stream, or 0 if
* no content protection is configured.
*/
AvdtpContentProt *A2DP_GetConfiguredCP(A2dpStream *Stream);
/*---------------------------------------------------------------------------
* A2DP_GetRemoteDevice()
*
* Returns the remote device of that is associated with the specified
* stream.
*
* Parameters:
*
* Stream - An open, or active A2DP stream.
*
* Returns:
*
* A pointer to the BtRemoteDevice structure.
*/
BtRemoteDevice *A2DP_GetRemoteDevice(A2dpStream *Stream);
/*---------------------------------------------------------------------------
* A2DP_GetRegisteredCP()
*
* Returns the registered content protection structures. The first call
* should be made with the value of 'Cp' set to 0. This will retrieve
* the first registered structure. Subsequent calls should be made with
* a pointer to the last structure returned by this function in the 'Cp'
* parameter. In this case, the next registered structure will be
* returned. If there are no more structures, then 0 will be returned.
*
* Parameters:
*
* Stream - An open, or active A2DP stream.
*
* Cp - Should be set to 0, or to a pointer to the last structure
* received.
*
* Returns:
*
* The next registered content protection structure.
*/
AvdtpContentProt *A2DP_GetRegisteredCP(A2dpStream *Stream,
AvdtpContentProt *Cp);
/*---------------------------------------------------------------------------
* A2DP_SetMasterRole()
*
* Sets the stream's preference for being the piconet master.
*
* Parameters:
*
* Stream - An open, or active A2DP stream.
*
* Flag - TRUE indicates that the current stream's connection wishes to
* remain as master. FALSE indicates that the stream doesn't care.
*
* Returns:
*
* The next registered content protection structure.
*/
BtStatus A2DP_SetMasterRole(A2dpStream *Stream, int Flag);
#define A2DP_SetMasterRole(s, f) \
CMGR_SetMasterRole(&((s)->device->cmgrHandler), f)
/****************************************************************************
*
* Section: A2DP Macros
*
****************************************************************************/
/*---------------------------------------------------------------------------
* A2DP_SBC_CODEC_INF_ELEMENTS()
*
* Macro that forms the SBC information elements. The information
* elements define the parameters that the SBC codec can use to
* encode or decode the stream. This macro can be used to create the
* SBC elements for the AvdtpCodec structure. This macro should be used
* in the initialization of a statically declared byte array. For a
* definition of acceptable values, see the description of
* A2dpSbcCodecInfElement0 and A2dpSbcCodecInfElement1. Certain
* features are required for SRC and SNK roles. These are defined
* below.
*
* SRC Role requirements:
* Sampling frequencies - Must support 48000 or 44100.
* Channel mode - Must support MONO and one other mode.
* Block length - Must support all block lengths.
* Subbands - Must support 8 subbands.
* Allocation Method - must support LOUDNESS.
*
* SNK Role requirements:
* Sampling frequencies - Must support 48000 and 44100.
* Channel mode - Must support all modes.
* Block length - Must support all block lengths.
* Subbands - Must support all subbands.
* Allocation Method - Must support all methods.
*
* Parameters:
* f - Sampling frequency of the encoded stream.
* c - Channel mode of the encoded stream.
* b - Block length of the encoded stream.
* s - Number of subbands in the encoded stream.
* m - Allocation method used to encode the stream.
* a - Maximum bitpool value for the stream.
* i - Minimum bitpool value for the stream.
*/
#define A2DP_SBC_CODEC_INF_ELEMENT(f, c, b, s, m, a, i) \
(uint8_t)((f) | (c)), \
(uint8_t)((b) | (s) | (m)), \
(uint8_t)(a), \
(uint8_t)(i)
/*---------------------------------------------------------------------------
* Is_a2dp_stream_registered()
*
* Check whether the stream is registered.
*
* Parameters:
*
* Stream - An open, or active A2DP stream.
*
* Returns:
*
* True or False.
*/
int Is_a2dp_stream_registered(A2dpStream *Stream);
#endif /* __A2DP_H_ */