2078 lines
74 KiB
C
2078 lines
74 KiB
C
#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_ */
|
|
|