Merge commit 'd34f05cb6e67e28a4955332173950466edf0be3e' into audio-hal.lnx.5.1
Change-Id: I4656a1a78c2b1d4b4834b2fd538699f96e2aa90e
diff --git a/hal/audio_extn/a2dp.c b/hal/audio_extn/a2dp.c
index c5edd42..e986a54 100644
--- a/hal/audio_extn/a2dp.c
+++ b/hal/audio_extn/a2dp.c
@@ -50,15 +50,18 @@
#ifdef SPLIT_A2DP_ENABLED
#define AUDIO_PARAMETER_A2DP_STARTED "A2dpStarted"
-#define BT_IPC_LIB_NAME "libbthost_if.so"
-#define ENC_MEDIA_FMT_NONE 0
-#define ENC_MEDIA_FMT_AAC 0x00010DA6
-#define ENC_MEDIA_FMT_APTX 0x000131ff
-#define ENC_MEDIA_FMT_APTX_HD 0x00013200
-#define ENC_MEDIA_FMT_APTX_AD 0x00013204
-#define ENC_MEDIA_FMT_SBC 0x00010BF2
-#define ENC_MEDIA_FMT_CELT 0x00013221
-#define ENC_MEDIA_FMT_LDAC 0x00013224
+#define BT_IPC_SOURCE_LIB_NAME "libbthost_if.so"
+#define BT_IPC_SINK_LIB_NAME "libbthost_if_sink.so"
+#define MEDIA_FMT_NONE 0
+#define MEDIA_FMT_AAC 0x00010DA6
+#define MEDIA_FMT_APTX 0x000131ff
+#define MEDIA_FMT_APTX_HD 0x00013200
+#define MEDIA_FMT_APTX_AD 0x00013204
+#define MEDIA_FMT_SBC 0x00010BF2
+#define MEDIA_FMT_CELT 0x00013221
+#define MEDIA_FMT_LDAC 0x00013224
+#define MEDIA_FMT_MP3 0x00010BE9
+#define MEDIA_FMT_APTX_ADAPTIVE 0x00013204
#define MEDIA_FMT_AAC_AOT_LC 2
#define MEDIA_FMT_AAC_AOT_SBR 5
#define MEDIA_FMT_AAC_AOT_PS 29
@@ -71,16 +74,20 @@
#define MEDIA_FMT_SBC_CHANNEL_MODE_JOINT_STEREO 9
#define MEDIA_FMT_SBC_ALLOCATION_METHOD_LOUDNESS 0
#define MEDIA_FMT_SBC_ALLOCATION_METHOD_SNR 1
-#define MIXER_ENC_CONFIG_BLOCK "SLIM_7_RX Encoder Config"
-#define MIXER_DEC_CONFIG_BLOCK "SLIM_7_TX Decoder Config"
+#define MIXER_ENC_CONFIG_BLOCK "SLIM_7_RX Encoder Config"
+#define MIXER_SOURCE_DEC_CONFIG_BLOCK "SLIM_7_TX Decoder Config"
+#define MIXER_SINK_DEC_CONFIG_BLOCK "SLIM_9_TX Decoder Config"
#define MIXER_ENC_BIT_FORMAT "AFE Input Bit Format"
+#define MIXER_DEC_BIT_FORMAT "AFE Output Bit Format"
#define MIXER_SCRAMBLER_MODE "AFE Scrambler Mode"
#define MIXER_SAMPLE_RATE_RX "BT SampleRate RX"
-#define MIXER_SAMPLE_RATE_TX "BT SampleRate TX"
+#define MIXER_SOURCE_SAMPLE_RATE_TX "BT SampleRate TX"
#define MIXER_SAMPLE_RATE_DEFAULT "BT SampleRate"
#define MIXER_AFE_IN_CHANNELS "AFE Input Channels"
#define MIXER_ABR_TX_FEEDBACK_PATH "A2DP_SLIM7_UL_HL Switch"
#define MIXER_SET_FEEDBACK_CHANNEL "BT set feedback channel"
+#define MIXER_SINK_SAMPLE_RATE "BT_TX SampleRate"
+#define MIXER_AFE_SINK_CHANNELS "AFE Output Channels"
#define MIXER_ENC_FMT_SBC "SBC"
#define MIXER_ENC_FMT_AAC "AAC"
#define MIXER_ENC_FMT_APTX "APTX"
@@ -118,25 +125,28 @@
#define SAMPLING_RATE_441K 44100
#define CH_STEREO 2
#define CH_MONO 1
+#define SOURCE 0
+#define SINK 1
+
/*
* Below enum values are extended from audio_base.h to
- * to keep encoder codec type local to bthost_ipc
+ * to keep encoder and decoder type local to bthost_ipc
* and audio_hal as these are intended only for handshake
* between IPC lib and Audio HAL.
*/
typedef enum {
- ENC_CODEC_TYPE_INVALID = AUDIO_FORMAT_INVALID, // 0xFFFFFFFFUL
- ENC_CODEC_TYPE_AAC = AUDIO_FORMAT_AAC, // 0x04000000UL
- ENC_CODEC_TYPE_SBC = AUDIO_FORMAT_SBC, // 0x1F000000UL
- ENC_CODEC_TYPE_APTX = AUDIO_FORMAT_APTX, // 0x20000000UL
- ENC_CODEC_TYPE_APTX_HD = AUDIO_FORMAT_APTX_HD, // 0x21000000UL
+ CODEC_TYPE_INVALID = AUDIO_FORMAT_INVALID, // 0xFFFFFFFFUL
+ CODEC_TYPE_AAC = AUDIO_FORMAT_AAC, // 0x04000000UL
+ CODEC_TYPE_SBC = AUDIO_FORMAT_SBC, // 0x1F000000UL
+ CODEC_TYPE_APTX = AUDIO_FORMAT_APTX, // 0x20000000UL
+ CODEC_TYPE_APTX_HD = AUDIO_FORMAT_APTX_HD, // 0x21000000UL
#ifndef LINUX_ENABLED
- ENC_CODEC_TYPE_APTX_DUAL_MONO = 570425344u, // 0x22000000UL
+ CODEC_TYPE_APTX_DUAL_MONO = 570425344u, // 0x22000000UL
#endif
- ENC_CODEC_TYPE_LDAC = AUDIO_FORMAT_LDAC, // 0x23000000UL
- ENC_CODEC_TYPE_CELT = 603979776u, // 0x24000000UL
- ENC_CODEC_TYPE_APTX_AD = 620756992u, // 0x25000000UL
-}enc_codec_t;
+ CODEC_TYPE_LDAC = AUDIO_FORMAT_LDAC, // 0x23000000UL
+ CODEC_TYPE_CELT = 603979776u, // 0x24000000UL
+ CODEC_TYPE_APTX_AD = 620756992u, // 0x25000000UL
+}codec_t;
/*
* enums which describes the APTX Adaptive
@@ -162,19 +172,24 @@
APTX_AD_44_1 = 0x2, // 44.1kHz
} enc_aptx_ad_s_rate;
-typedef int (*audio_stream_open_t)(void);
-typedef int (*audio_stream_close_t)(void);
-typedef int (*audio_start_stream_t)(void);
-typedef int (*audio_stop_stream_t)(void);
-typedef int (*audio_suspend_stream_t)(void);
-typedef void (*audio_handoff_triggered_t)(void);
-typedef void (*clear_a2dpsuspend_flag_t)(void);
-typedef void * (*audio_get_codec_config_t)(uint8_t *multicast_status,uint8_t *num_dev,
- enc_codec_t *codec_type);
-typedef int (*audio_check_a2dp_ready_t)(void);
-typedef uint16_t (*audio_get_a2dp_sink_latency_t)(void);
-typedef int (*audio_is_scrambling_enabled_t)(void);
+typedef int (*audio_source_open_t)(void);
+typedef int (*audio_source_close_t)(void);
+typedef int (*audio_source_start_t)(void);
+typedef int (*audio_source_stop_t)(void);
+typedef int (*audio_source_suspend_t)(void);
+typedef void (*audio_source_handoff_triggered_t)(void);
+typedef void (*clear_source_a2dpsuspend_flag_t)(void);
+typedef void * (*audio_get_enc_config_t)(uint8_t *multicast_status,
+ uint8_t *num_dev, codec_t *codec_type);
+typedef int (*audio_source_check_a2dp_ready_t)(void);
+typedef int (*audio_is_source_scrambling_enabled_t)(void);
typedef bool (*audio_is_tws_mono_mode_enable_t)(void);
+typedef int (*audio_sink_start_t)(void);
+typedef int (*audio_sink_stop_t)(void);
+typedef void * (*audio_get_dec_config_t)(codec_t *codec_type);
+typedef void * (*audio_sink_session_setup_complete_t)(uint64_t system_latency);
+typedef int (*audio_sink_check_a2dp_ready_t)(void);
+typedef uint16_t (*audio_sink_get_a2dp_latency_t)(void);
enum A2DP_STATE {
A2DP_STATE_CONNECTED,
@@ -230,26 +245,25 @@
*/
struct a2dp_data {
struct audio_device *adev;
- void *bt_lib_handle;
- audio_stream_open_t audio_stream_open;
- audio_stream_close_t audio_stream_close;
- audio_start_stream_t audio_start_stream;
- audio_stop_stream_t audio_stop_stream;
- audio_suspend_stream_t audio_suspend_stream;
- audio_handoff_triggered_t audio_handoff_triggered;
- clear_a2dpsuspend_flag_t clear_a2dpsuspend_flag;
- audio_get_codec_config_t audio_get_codec_config;
- audio_check_a2dp_ready_t audio_check_a2dp_ready;
- audio_get_a2dp_sink_latency_t audio_get_a2dp_sink_latency;
- audio_is_scrambling_enabled_t audio_is_scrambling_enabled;
+ void *bt_lib_source_handle;
+ audio_source_open_t audio_source_open;
+ audio_source_close_t audio_source_close;
+ audio_source_start_t audio_source_start;
+ audio_source_stop_t audio_source_stop;
+ audio_source_suspend_t audio_source_suspend;
+ audio_source_handoff_triggered_t audio_source_handoff_triggered;
+ clear_source_a2dpsuspend_flag_t clear_source_a2dpsuspend_flag;
+ audio_get_enc_config_t audio_get_enc_config;
+ audio_source_check_a2dp_ready_t audio_source_check_a2dp_ready;
audio_is_tws_mono_mode_enable_t audio_is_tws_mono_mode_enable;
- enum A2DP_STATE bt_state;
- enc_codec_t bt_encoder_format;
+ audio_is_source_scrambling_enabled_t audio_is_source_scrambling_enabled;
+ enum A2DP_STATE bt_state_source;
+ codec_t bt_encoder_format;
uint32_t enc_sampling_rate;
uint32_t enc_channels;
- bool a2dp_started;
- bool a2dp_suspended;
- int a2dp_total_active_session_request;
+ bool a2dp_source_started;
+ bool a2dp_source_suspended;
+ int a2dp_source_total_active_session_requests;
bool is_a2dp_offload_supported;
bool is_handoff_in_progress;
bool is_aptx_dual_mono_supported;
@@ -258,6 +272,20 @@
bool is_aptx_adaptive;
/* Adaptive bitrate config for A2DP codecs */
struct a2dp_abr_config abr_config;
+
+ void *bt_lib_sink_handle;
+ audio_sink_start_t audio_sink_start;
+ audio_sink_stop_t audio_sink_stop;
+ audio_get_dec_config_t audio_get_dec_config;
+ audio_sink_session_setup_complete_t audio_sink_session_setup_complete;
+ audio_sink_check_a2dp_ready_t audio_sink_check_a2dp_ready;
+ audio_sink_get_a2dp_latency_t audio_sink_get_a2dp_latency;
+ enum A2DP_STATE bt_state_sink;
+ codec_t bt_decoder_format;
+ uint32_t dec_sampling_rate;
+ uint32_t dec_channels;
+ bool a2dp_sink_started;
+ int a2dp_sink_total_active_session_requests;
};
struct a2dp_data a2dp;
@@ -364,6 +392,37 @@
struct aac_frame_size_control_t frame_ctl;
} __attribute__ ((packed));
+typedef struct audio_aac_decoder_config_t audio_aac_decoder_config_t;
+struct audio_aac_decoder_config_t {
+ uint16_t aac_fmt_flag; /* LATM*/
+ uint16_t audio_object_type; /* LC */
+ uint16_t channels; /* Stereo */
+ uint16_t total_size_of_pce_bits; /* 0 - only for channel conf PCE */
+ uint32_t sampling_rate; /* 8k, 11.025k, 12k, 16k, 22.05k, 24k, 32k,
+ 44.1k, 48k, 64k, 88.2k, 96k */
+} __attribute__ ((packed));
+
+typedef struct audio_sbc_decoder_config_t audio_sbc_decoder_config_t;
+struct audio_sbc_decoder_config_t {
+ uint16_t channels; /* Mono, Stereo */
+ uint32_t sampling_rate; /* 8k, 11.025k, 12k, 16k, 22.05k, 24k, 32k,
+ 44.1k, 48k, 64k, 88.2k, 96k */
+} __attribute__ ((packed));
+
+/* AAC decoder configuration structure. */
+typedef struct aac_dec_cfg_t aac_dec_cfg_t;
+struct aac_dec_cfg_t {
+ uint32_t dec_format;
+ audio_aac_decoder_config_t data;
+} __attribute__ ((packed));
+
+/* SBC decoder configuration structure. */
+typedef struct sbc_dec_cfg_t sbc_dec_cfg_t;
+struct sbc_dec_cfg_t {
+ uint32_t dec_format;
+ audio_sbc_decoder_config_t data;
+} __attribute__ ((packed));
+
/* SBC encoder configuration structure. */
typedef struct sbc_enc_cfg_t sbc_enc_cfg_t;
@@ -581,6 +640,29 @@
uint32_t bits_per_sample;
} audio_ldac_encoder_config;
+/* Information about BT AAC decoder configuration
+ * This data is used between audio HAL module and
+ * BT IPC library to configure DSP decoder
+ */
+typedef struct {
+ uint16_t aac_fmt_flag; /* LATM*/
+ uint16_t audio_object_type; /* LC */
+ uint16_t channels; /* Stereo */
+ uint16_t total_size_of_pce_bits; /* 0 - only for channel conf PCE */
+ uint32_t sampling_rate; /* 8k, 11.025k, 12k, 16k, 22.05k, 24k, 32k,
+ 44.1k, 48k, 64k, 88.2k, 96k */
+} audio_aac_dec_config_t;
+
+/* Information about BT SBC decoder configuration
+ * This data is used between audio HAL module and
+ * BT IPC library to configure DSP decoder
+ */
+typedef struct {
+ uint16_t channels; /* Mono, Stereo */
+ uint32_t sampling_rate; /* 8k, 11.025k, 12k, 16k, 22.05k, 24k, 32k,
+ 44.1k, 48k, 64k, 88.2k, 96k */
+}audio_sbc_dec_config_t;
+
/*********** END of DSP configurable structures ********************/
/* API to identify DSP encoder captabilities */
@@ -750,98 +832,150 @@
return -ENOSYS;
}
-/* API to open BT IPC library to start IPC communication */
-static void open_a2dp_output()
+/* API to open BT IPC library to start IPC communication for BT Source*/
+static void open_a2dp_source()
{
int ret = 0;
- ALOGD(" Open A2DP output start ");
- if (a2dp.bt_lib_handle == NULL){
+ ALOGD(" Open A2DP source start ");
+ if (a2dp.bt_lib_source_handle == NULL){
ALOGD(" Requesting for BT lib handle");
- a2dp.bt_lib_handle = dlopen(BT_IPC_LIB_NAME, RTLD_NOW);
+ a2dp.bt_lib_source_handle = dlopen(BT_IPC_SOURCE_LIB_NAME, RTLD_NOW);
- if (a2dp.bt_lib_handle == NULL) {
- ALOGE("%s: DLOPEN failed for %s", __func__, BT_IPC_LIB_NAME);
+ if (a2dp.bt_lib_source_handle == NULL) {
+ ALOGE("%s: DLOPEN failed for %s", __func__, BT_IPC_SOURCE_LIB_NAME);
ret = -ENOSYS;
goto init_fail;
} else {
- a2dp.audio_stream_open = (audio_stream_open_t)
- dlsym(a2dp.bt_lib_handle, "audio_stream_open");
- a2dp.audio_start_stream = (audio_start_stream_t)
- dlsym(a2dp.bt_lib_handle, "audio_start_stream");
- a2dp.audio_get_codec_config = (audio_get_codec_config_t)
- dlsym(a2dp.bt_lib_handle, "audio_get_codec_config");
- a2dp.audio_suspend_stream = (audio_suspend_stream_t)
- dlsym(a2dp.bt_lib_handle, "audio_suspend_stream");
- a2dp.audio_handoff_triggered = (audio_handoff_triggered_t)
- dlsym(a2dp.bt_lib_handle, "audio_handoff_triggered");
- a2dp.clear_a2dpsuspend_flag = (clear_a2dpsuspend_flag_t)
- dlsym(a2dp.bt_lib_handle, "clear_a2dpsuspend_flag");
- a2dp.audio_stop_stream = (audio_stop_stream_t)
- dlsym(a2dp.bt_lib_handle, "audio_stop_stream");
- a2dp.audio_stream_close = (audio_stream_close_t)
- dlsym(a2dp.bt_lib_handle, "audio_stream_close");
- a2dp.audio_check_a2dp_ready = (audio_check_a2dp_ready_t)
- dlsym(a2dp.bt_lib_handle,"audio_check_a2dp_ready");
- a2dp.audio_get_a2dp_sink_latency = (audio_get_a2dp_sink_latency_t)
- dlsym(a2dp.bt_lib_handle,"audio_get_a2dp_sink_latency");
- a2dp.audio_is_scrambling_enabled = (audio_is_scrambling_enabled_t)
- dlsym(a2dp.bt_lib_handle,"audio_is_scrambling_enabled");
+ a2dp.audio_source_open = (audio_source_open_t)
+ dlsym(a2dp.bt_lib_source_handle, "audio_stream_open");
+ a2dp.audio_source_start = (audio_source_start_t)
+ dlsym(a2dp.bt_lib_source_handle, "audio_start_stream");
+ a2dp.audio_get_enc_config = (audio_get_enc_config_t)
+ dlsym(a2dp.bt_lib_source_handle, "audio_get_codec_config");
+ a2dp.audio_source_suspend = (audio_source_suspend_t)
+ dlsym(a2dp.bt_lib_source_handle, "audio_suspend_stream");
+ a2dp.audio_source_handoff_triggered = (audio_source_handoff_triggered_t)
+ dlsym(a2dp.bt_lib_source_handle, "audio_handoff_triggered");
+ a2dp.clear_source_a2dpsuspend_flag = (clear_source_a2dpsuspend_flag_t)
+ dlsym(a2dp.bt_lib_source_handle, "clear_a2dpsuspend_flag");
+ a2dp.audio_source_stop = (audio_source_stop_t)
+ dlsym(a2dp.bt_lib_source_handle, "audio_stop_stream");
+ a2dp.audio_source_close = (audio_source_close_t)
+ dlsym(a2dp.bt_lib_source_handle, "audio_stream_close");
+ a2dp.audio_source_check_a2dp_ready = (audio_source_check_a2dp_ready_t)
+ dlsym(a2dp.bt_lib_source_handle,"audio_check_a2dp_ready");
+ a2dp.audio_sink_get_a2dp_latency = (audio_sink_get_a2dp_latency_t)
+ dlsym(a2dp.bt_lib_source_handle,"audio_sink_get_a2dp_latency");
+ a2dp.audio_is_source_scrambling_enabled = (audio_is_source_scrambling_enabled_t)
+ dlsym(a2dp.bt_lib_source_handle,"audio_is_scrambling_enabled");
a2dp.audio_is_tws_mono_mode_enable = (audio_is_tws_mono_mode_enable_t)
- dlsym(a2dp.bt_lib_handle,"isTwsMonomodeEnable");
+ dlsym(a2dp.bt_lib_source_handle,"isTwsMonomodeEnable");
}
}
- if (a2dp.bt_lib_handle && a2dp.audio_stream_open) {
- if (a2dp.bt_state == A2DP_STATE_DISCONNECTED) {
+ if (a2dp.bt_lib_source_handle && a2dp.audio_source_open) {
+ if (a2dp.bt_state_source == A2DP_STATE_DISCONNECTED) {
ALOGD("calling BT stream open");
- ret = a2dp.audio_stream_open();
+ ret = a2dp.audio_source_open();
if(ret != 0) {
- ALOGE("Failed to open output stream for a2dp: status %d", ret);
+ ALOGE("Failed to open source stream for a2dp: status %d", ret);
goto init_fail;
}
- a2dp.bt_state = A2DP_STATE_CONNECTED;
+ a2dp.bt_state_source = A2DP_STATE_CONNECTED;
} else {
- ALOGD("Called a2dp open with improper state, Ignoring request state %d", a2dp.bt_state);
+ ALOGD("Called a2dp open with improper state, Ignoring request state %d", a2dp.bt_state_source);
}
} else {
ALOGE("a2dp handle is not identified, Ignoring open request");
- a2dp.bt_state = A2DP_STATE_DISCONNECTED;
+ a2dp.bt_state_source = A2DP_STATE_DISCONNECTED;
goto init_fail;
}
init_fail:
- if(ret != 0 && (a2dp.bt_lib_handle != NULL)) {
- dlclose(a2dp.bt_lib_handle);
- a2dp.bt_lib_handle = NULL;
+ if(ret != 0 && (a2dp.bt_lib_source_handle != NULL)) {
+ dlclose(a2dp.bt_lib_source_handle);
+ a2dp.bt_lib_source_handle = NULL;
+ }
+}
+
+/* API to open BT IPC library to start IPC communication for BT Sink*/
+static void open_a2dp_sink()
+{
+ ALOGD(" Open A2DP input start ");
+ if (a2dp.bt_lib_sink_handle == NULL){
+ ALOGD(" Requesting for BT lib handle");
+ a2dp.bt_lib_sink_handle = dlopen(BT_IPC_SINK_LIB_NAME, RTLD_NOW);
+
+ if (a2dp.bt_lib_sink_handle == NULL) {
+ ALOGE("%s: DLOPEN failed for %s", __func__, BT_IPC_SINK_LIB_NAME);
+ } else {
+ a2dp.audio_sink_start = (audio_sink_start_t)
+ dlsym(a2dp.bt_lib_sink_handle, "audio_sink_start_capture");
+ a2dp.audio_get_dec_config = (audio_get_dec_config_t)
+ dlsym(a2dp.bt_lib_sink_handle, "audio_get_decoder_config");
+ a2dp.audio_sink_stop = (audio_sink_stop_t)
+ dlsym(a2dp.bt_lib_sink_handle, "audio_sink_stop_capture");
+ a2dp.audio_sink_check_a2dp_ready = (audio_sink_check_a2dp_ready_t)
+ dlsym(a2dp.bt_lib_sink_handle,"audio_sink_check_a2dp_ready");
+ a2dp.audio_sink_session_setup_complete = (audio_sink_session_setup_complete_t)
+ dlsym(a2dp.bt_lib_sink_handle, "audio_sink_session_setup_complete");
+ }
}
}
static int close_a2dp_output()
{
ALOGV("%s\n",__func__);
- if (!(a2dp.bt_lib_handle && a2dp.audio_stream_close)) {
- ALOGE("a2dp handle is not identified, Ignoring close request");
+
+ if (!(a2dp.bt_lib_source_handle && a2dp.audio_source_close)) {
+ ALOGE("a2dp source handle is not identified, Ignoring close request");
return -ENOSYS;
}
- if (a2dp.bt_state != A2DP_STATE_DISCONNECTED) {
- ALOGD("calling BT stream close");
- if(a2dp.audio_stream_close() == false)
- ALOGE("failed close a2dp control path from BT library");
+
+ if (a2dp.bt_state_source != A2DP_STATE_DISCONNECTED) {
+ ALOGD("calling BT source stream close");
+ if(a2dp.audio_source_close() == false)
+ ALOGE("failed close a2dp source control path from BT library");
}
- a2dp.a2dp_started = false;
- a2dp.a2dp_total_active_session_request = 0;
- a2dp.a2dp_suspended = false;
- a2dp.bt_encoder_format = ENC_CODEC_TYPE_INVALID;
+ a2dp.a2dp_source_started = false;
+ a2dp.a2dp_source_total_active_session_requests = 0;
+ a2dp.a2dp_source_suspended = false;
+ a2dp.bt_encoder_format = CODEC_TYPE_INVALID;
a2dp.enc_sampling_rate = 48000;
a2dp.enc_channels = 2;
- a2dp.bt_state = A2DP_STATE_DISCONNECTED;
+ a2dp.bt_state_source = A2DP_STATE_DISCONNECTED;
if (a2dp.abr_config.is_abr_enabled && a2dp.abr_config.abr_started)
stop_abr();
a2dp.abr_config.is_abr_enabled = false;
a2dp.abr_config.abr_started = false;
a2dp.abr_config.imc_instance = 0;
a2dp.abr_config.abr_tx_handle = NULL;
+ a2dp.bt_state_source = A2DP_STATE_DISCONNECTED;
+
+ return 0;
+}
+
+static int close_a2dp_input()
+{
+ ALOGV("%s\n",__func__);
+
+ if (!(a2dp.bt_lib_sink_handle && a2dp.audio_source_close)) {
+ ALOGE("a2dp sink handle is not identified, Ignoring close request");
+ return -ENOSYS;
+ }
+
+ if (a2dp.bt_state_sink != A2DP_STATE_DISCONNECTED) {
+ ALOGD("calling BT sink stream close");
+ if(a2dp.audio_source_close() == false)
+ ALOGE("failed close a2dp sink control path from BT library");
+ }
+ a2dp.a2dp_sink_started = false;
+ a2dp.a2dp_sink_total_active_session_requests = 0;
+ a2dp.bt_decoder_format = CODEC_TYPE_INVALID;
+ a2dp.dec_sampling_rate = 48000;
+ a2dp.dec_channels = 2;
+ a2dp.bt_state_sink = A2DP_STATE_DISCONNECTED;
return 0;
}
@@ -850,15 +984,15 @@
{
bool scrambler_mode = false;
struct mixer_ctl *ctrl_scrambler_mode = NULL;
- if (a2dp.audio_is_scrambling_enabled && (a2dp.bt_state != A2DP_STATE_DISCONNECTED))
- scrambler_mode = a2dp.audio_is_scrambling_enabled();
+ if (a2dp.audio_is_source_scrambling_enabled && (a2dp.bt_state_source != A2DP_STATE_DISCONNECTED))
+ scrambler_mode = a2dp.audio_is_source_scrambling_enabled();
if (scrambler_mode) {
//enable scrambler in dsp
ctrl_scrambler_mode = mixer_get_ctl_by_name(a2dp.adev->mixer,
MIXER_SCRAMBLER_MODE);
if (!ctrl_scrambler_mode) {
- ALOGE(" ERROR scrambler mode mixer control not identifed");
+ ALOGE(" ERROR scrambler mode mixer control not identified");
return;
} else {
if (mixer_ctl_set_value(ctrl_scrambler_mode, 0, true) != 0) {
@@ -869,21 +1003,29 @@
}
}
-static int a2dp_set_backend_cfg()
+static bool a2dp_set_backend_cfg(uint8_t direction)
{
- char *rate_str = NULL, *in_channels = NULL;
- uint32_t sampling_rate_rx = a2dp.enc_sampling_rate;
- struct mixer_ctl *ctl_sample_rate = NULL, *ctrl_in_channels = NULL;
+ char *rate_str = NULL, *channels = NULL;
+ uint32_t sampling_rate;
+ struct mixer_ctl *ctl_sample_rate = NULL, *ctrl_channels = NULL;
+ bool is_configured = false;
- //For LDAC encoder open slimbus port at 96Khz for 48Khz input
- //and 88.2Khz for 44.1Khz input.
- if ((a2dp.bt_encoder_format == ENC_CODEC_TYPE_LDAC) &&
- (sampling_rate_rx == 48000 || sampling_rate_rx == 44100 )) {
- sampling_rate_rx *= 2;
+ if (direction == SINK) {
+ sampling_rate = a2dp.dec_sampling_rate;
+ } else {
+ sampling_rate = a2dp.enc_sampling_rate;
+ }
+ //For LDAC encoder and AAC decoder open slimbus port at
+ //96Khz for 48Khz input and 88.2Khz for 44.1Khz input.
+ if (((a2dp.bt_encoder_format == CODEC_TYPE_LDAC) ||
+ (a2dp.bt_decoder_format == CODEC_TYPE_SBC) ||
+ (a2dp.bt_decoder_format == AUDIO_FORMAT_AAC)) &&
+ (sampling_rate == 48000 || sampling_rate == 44100 )) {
+ sampling_rate = sampling_rate *2;
}
- // Set Rx backend sample rate
- switch (sampling_rate_rx) {
+ //Configure backend sampling rate
+ switch (sampling_rate) {
case 44100:
rate_str = "KHZ_44P1";
break;
@@ -899,31 +1041,42 @@
break;
}
- ALOGD("%s: set backend rx sample rate = %s", __func__, rate_str);
- ctl_sample_rate = mixer_get_ctl_by_name(a2dp.adev->mixer,
- MIXER_SAMPLE_RATE_RX);
+ if (direction == SINK) {
+ ALOGD("%s: set sink backend sample rate =%s", __func__, rate_str);
+ ctl_sample_rate = mixer_get_ctl_by_name(a2dp.adev->mixer,
+ MIXER_SINK_SAMPLE_RATE);
+ } else {
+ ALOGD("%s: set source backend sample rate =%s", __func__, rate_str);
+ ctl_sample_rate = mixer_get_ctl_by_name(a2dp.adev->mixer,
+ MIXER_SAMPLE_RATE_RX);
+ }
if (ctl_sample_rate) {
if (mixer_ctl_set_enum_by_string(ctl_sample_rate, rate_str) != 0) {
ALOGE("%s: Failed to set backend sample rate = %s", __func__, rate_str);
- return -ENOSYS;
+ is_configured = false;
+ goto fail;
}
- /* Set Tx backend sample rate */
- if (a2dp.abr_config.is_abr_enabled)
- rate_str = ABR_TX_SAMPLE_RATE;
+ if (direction == SOURCE) {
+ /* Set Tx backend sample rate */
+ if (a2dp.abr_config.is_abr_enabled)
+ rate_str = ABR_TX_SAMPLE_RATE;
- ALOGD("%s: set backend tx sample rate = %s", __func__, rate_str);
- ctl_sample_rate = mixer_get_ctl_by_name(a2dp.adev->mixer,
- MIXER_SAMPLE_RATE_TX);
- if (!ctl_sample_rate) {
+ ALOGD("%s: set backend tx sample rate = %s", __func__, rate_str);
+ ctl_sample_rate = mixer_get_ctl_by_name(a2dp.adev->mixer,
+ MIXER_SOURCE_SAMPLE_RATE_TX);
+ if (!ctl_sample_rate) {
ALOGE("%s: ERROR backend sample rate mixer control not identifed", __func__);
- return -ENOSYS;
- }
+ is_configured = false;
+ goto fail;
+ }
- if (mixer_ctl_set_enum_by_string(ctl_sample_rate, rate_str) != 0) {
- ALOGE("%s: Failed to set backend sample rate = %s", __func__, rate_str);
- return -ENOSYS;
+ if (mixer_ctl_set_enum_by_string(ctl_sample_rate, rate_str) != 0) {
+ ALOGE("%s: Failed to set backend sample rate = %s", __func__, rate_str);
+ is_configured = false;
+ goto fail;
+ }
}
} else {
/* Fallback to legacy approch if MIXER_SAMPLE_RATE_RX and
@@ -932,39 +1085,127 @@
MIXER_SAMPLE_RATE_DEFAULT);
if (!ctl_sample_rate) {
ALOGE("%s: ERROR backend sample rate mixer control not identifed", __func__);
- return -ENOSYS;
+ is_configured = false;
+ goto fail;
}
if (mixer_ctl_set_enum_by_string(ctl_sample_rate, rate_str) != 0) {
ALOGE("%s: Failed to set backend sample rate = %s", __func__, rate_str);
- return -ENOSYS;
+ is_configured = false;
+ goto fail;
}
}
- //Configure AFE input channels
- switch (a2dp.enc_channels) {
- case 1:
- in_channels = "One";
+ if (direction == SINK) {
+ switch (a2dp.dec_channels) {
+ case 1:
+ channels = "One";
+ break;
+ case 2:
+ default:
+ channels = "Two";
+ break;
+ }
+
+ ALOGD("%s: set afe dec channels =%d", __func__, channels);
+ ctrl_channels = mixer_get_ctl_by_name(a2dp.adev->mixer,
+ MIXER_AFE_SINK_CHANNELS);
+ } else {
+ //Configure AFE enc channels
+ switch (a2dp.enc_channels) {
+ case 1:
+ channels = "One";
+ break;
+ case 2:
+ default:
+ channels = "Two";
+ break;
+ }
+
+ ALOGD("%s: set afe enc channels =%d", __func__, channels);
+ ctrl_channels = mixer_get_ctl_by_name(a2dp.adev->mixer,
+ MIXER_AFE_IN_CHANNELS);
+ }
+
+ if (!ctrl_channels) {
+ ALOGE(" ERROR AFE channels mixer control not identified");
+ } else {
+ if (mixer_ctl_set_enum_by_string(ctrl_channels, channels) != 0) {
+ ALOGE("%s: Failed to set AFE channels =%d", __func__, channels);
+ is_configured = false;
+ goto fail;
+ }
+ }
+ is_configured = true;
+fail:
+ return is_configured;
+}
+
+bool configure_aac_dec_format(audio_aac_dec_config_t *aac_bt_cfg)
+{
+ struct mixer_ctl *ctl_dec_data = NULL, *ctrl_bit_format = NULL;
+ struct aac_dec_cfg_t aac_dsp_cfg;
+ bool is_configured = false;
+ int ret = 0;
+
+ if(aac_bt_cfg == NULL)
+ return false;
+
+ ctl_dec_data = mixer_get_ctl_by_name(a2dp.adev->mixer, MIXER_SINK_DEC_CONFIG_BLOCK);
+ if (!ctl_dec_data) {
+ ALOGE(" ERROR a2dp decoder CONFIG data mixer control not identified");
+ is_configured = false;
+ goto fail;
+ }
+
+ memset(&aac_dsp_cfg, 0x0, sizeof(struct aac_dec_cfg_t));
+ aac_dsp_cfg.dec_format = MEDIA_FMT_AAC;
+ aac_dsp_cfg.data.aac_fmt_flag = aac_bt_cfg->aac_fmt_flag;
+ aac_dsp_cfg.data.channels = aac_bt_cfg->channels;
+ switch(aac_bt_cfg->audio_object_type) {
+ case 0:
+ aac_dsp_cfg.data.audio_object_type = MEDIA_FMT_AAC_AOT_LC;
break;
case 2:
+ aac_dsp_cfg.data.audio_object_type = MEDIA_FMT_AAC_AOT_PS;
+ break;
+ case 1:
default:
- in_channels = "Two";
+ aac_dsp_cfg.data.audio_object_type = MEDIA_FMT_AAC_AOT_SBR;
break;
}
-
- ALOGD("%s: set AFE input channels = %d", __func__, a2dp.enc_channels);
- ctrl_in_channels = mixer_get_ctl_by_name(a2dp.adev->mixer,
- MIXER_AFE_IN_CHANNELS);
- if (!ctrl_in_channels) {
- ALOGE("%s: ERROR AFE input channels mixer control not identifed", __func__);
- return -ENOSYS;
- }
- if (mixer_ctl_set_enum_by_string(ctrl_in_channels, in_channels) != 0) {
- ALOGE("%s: Failed to set AFE in channels = %d", __func__, a2dp.enc_channels);
- return -ENOSYS;
+ aac_dsp_cfg.data.total_size_of_pce_bits = aac_bt_cfg->total_size_of_pce_bits;
+ aac_dsp_cfg.data.sampling_rate = aac_bt_cfg->sampling_rate;
+ ret = mixer_ctl_set_array(ctl_dec_data, (void *)&aac_dsp_cfg,
+ sizeof(struct aac_dec_cfg_t));
+ if (ret != 0) {
+ ALOGE("%s: failed to set AAC decoder config", __func__);
+ is_configured = false;
+ goto fail;
}
- return 0;
+ ctrl_bit_format = mixer_get_ctl_by_name(a2dp.adev->mixer,
+ MIXER_DEC_BIT_FORMAT);
+ if (!ctrl_bit_format) {
+ ALOGE(" ERROR Dec bit format mixer control not identified");
+ is_configured = false;
+ goto fail;
+ }
+ ret = mixer_ctl_set_enum_by_string(ctrl_bit_format, "S16_LE");
+ if (ret != 0) {
+ ALOGE("%s: Failed to set bit format to decoder", __func__);
+ is_configured = false;
+ goto fail;
+ }
+
+ is_configured = true;
+ a2dp.bt_decoder_format = CODEC_TYPE_AAC;
+ a2dp.dec_channels = aac_dsp_cfg.data.channels;
+ a2dp.dec_sampling_rate = aac_dsp_cfg.data.sampling_rate;
+ ALOGV("Successfully updated AAC dec format with sampling_rate: %d channels:%d",
+ aac_dsp_cfg.data.sampling_rate, aac_dsp_cfg.data.channels);
+fail:
+ return is_configured;
}
static int a2dp_set_bit_format(uint32_t enc_bit_format)
@@ -1000,25 +1241,31 @@
return 0;
}
-static int a2dp_reset_backend_cfg()
+static int a2dp_reset_backend_cfg(uint8_t direction)
{
- const char *rate_str = "KHZ_8", *in_channels = "Zero";
- struct mixer_ctl *ctl_sample_rate_rx = NULL, *ctl_sample_rate_tx = NULL;
- struct mixer_ctl *ctrl_in_channels = NULL;
+ const char *rate_str = "KHZ_8", *channels = "Zero";
+ struct mixer_ctl *ctl_sample_rate = NULL, *ctl_sample_rate_tx = NULL;
+ struct mixer_ctl *ctrl_channels = NULL;
// Reset backend sampling rate
- ALOGD("%s: reset backend sample rate = %s", __func__, rate_str);
- ctl_sample_rate_rx = mixer_get_ctl_by_name(a2dp.adev->mixer,
- MIXER_SAMPLE_RATE_RX);
- if (ctl_sample_rate_rx) {
+ if (direction == SINK) {
+ ALOGD("%s: reset sink backend sample rate =%s", __func__, rate_str);
+ ctl_sample_rate = mixer_get_ctl_by_name(a2dp.adev->mixer,
+ MIXER_SINK_SAMPLE_RATE);
+ } else {
+ ALOGD("%s: reset source backend sample rate =%s", __func__, rate_str);
+ ctl_sample_rate = mixer_get_ctl_by_name(a2dp.adev->mixer,
+ MIXER_SAMPLE_RATE_RX);
+ }
+ if (ctl_sample_rate) {
- if (mixer_ctl_set_enum_by_string(ctl_sample_rate_rx, rate_str) != 0) {
- ALOGE("%s: Failed to reset Rx backend sample rate = %s", __func__, rate_str);
+ if (mixer_ctl_set_enum_by_string(ctl_sample_rate, rate_str) != 0) {
+ ALOGE("%s: Failed to reset backend sample rate = %s", __func__, rate_str);
return -ENOSYS;
}
ctl_sample_rate_tx = mixer_get_ctl_by_name(a2dp.adev->mixer,
- MIXER_SAMPLE_RATE_TX);
+ MIXER_SOURCE_SAMPLE_RATE_TX);
if (!ctl_sample_rate_tx) {
ALOGE("%s: ERROR Tx backend sample rate mixer control not identifed", __func__);
return -ENOSYS;
@@ -1030,28 +1277,34 @@
}
} else {
- ctl_sample_rate_rx = mixer_get_ctl_by_name(a2dp.adev->mixer,
+ ctl_sample_rate = mixer_get_ctl_by_name(a2dp.adev->mixer,
MIXER_SAMPLE_RATE_DEFAULT);
- if (!ctl_sample_rate_rx) {
+ if (!ctl_sample_rate) {
ALOGE("%s: ERROR backend sample rate mixer control not identifed", __func__);
return -ENOSYS;
}
- if (mixer_ctl_set_enum_by_string(ctl_sample_rate_rx, rate_str) != 0) {
+ if (mixer_ctl_set_enum_by_string(ctl_sample_rate, rate_str) != 0) {
ALOGE("%s: Failed to reset backend sample rate = %s", __func__, rate_str);
return -ENOSYS;
}
}
// Reset AFE input channels
- ALOGD("%s: reset AFE input channels = %s", __func__, in_channels);
- ctrl_in_channels = mixer_get_ctl_by_name(a2dp.adev->mixer,
- MIXER_AFE_IN_CHANNELS);
- if (!ctrl_in_channels) {
+ if (direction == SINK) {
+ ALOGD("%s: reset afe sink channels =%s", __func__, channels);
+ ctrl_channels = mixer_get_ctl_by_name(a2dp.adev->mixer,
+ MIXER_AFE_SINK_CHANNELS);
+ } else {
+ ALOGD("%s: reset afe source channels =%s", __func__, channels);
+ ctrl_channels = mixer_get_ctl_by_name(a2dp.adev->mixer,
+ MIXER_AFE_IN_CHANNELS);
+ }
+ if (!ctrl_channels) {
ALOGE("%s: ERROR AFE input channels mixer control not identifed", __func__);
return -ENOSYS;
}
- if (mixer_ctl_set_enum_by_string(ctrl_in_channels, in_channels) != 0) {
+ if (mixer_ctl_set_enum_by_string(ctrl_channels, channels) != 0) {
ALOGE("%s: Failed to reset AFE in channels = %d", __func__, a2dp.enc_channels);
return -ENOSYS;
}
@@ -1060,14 +1313,14 @@
}
/* API to configure AFE decoder in DSP */
-static bool configure_a2dp_decoder_format(int dec_format)
+static bool configure_a2dp_source_decoder_format(int dec_format)
{
struct mixer_ctl *ctl_dec_data = NULL;
struct abr_dec_cfg_t dec_cfg;
int ret = 0;
if (a2dp.abr_config.is_abr_enabled) {
- ctl_dec_data = mixer_get_ctl_by_name(a2dp.adev->mixer, MIXER_DEC_CONFIG_BLOCK);
+ ctl_dec_data = mixer_get_ctl_by_name(a2dp.adev->mixer, MIXER_SOURCE_DEC_CONFIG_BLOCK);
if (!ctl_dec_data) {
ALOGE("%s: ERROR A2DP codec config data mixer control not identifed", __func__);
return false;
@@ -1085,9 +1338,104 @@
ALOGE("%s: Failed to set decoder config", __func__);
return false;
}
+ }
+
+ return true;
+}
+
+bool configure_sbc_dec_format(audio_sbc_dec_config_t *sbc_bt_cfg)
+{
+ struct mixer_ctl *ctl_dec_data = NULL, *ctrl_bit_format = NULL;
+ struct sbc_dec_cfg_t sbc_dsp_cfg;
+ bool is_configured = false;
+ int ret = 0;
+
+ if(sbc_bt_cfg == NULL)
+ goto fail;
+
+ ctl_dec_data = mixer_get_ctl_by_name(a2dp.adev->mixer, MIXER_SINK_DEC_CONFIG_BLOCK);
+ if (!ctl_dec_data) {
+ ALOGE(" ERROR a2dp decoder CONFIG data mixer control not identified");
+ is_configured = false;
+ goto fail;
}
- return true;
+ memset(&sbc_dsp_cfg, 0x0, sizeof(struct sbc_dec_cfg_t));
+ sbc_dsp_cfg.dec_format = MEDIA_FMT_SBC;
+ sbc_dsp_cfg.data.channels = sbc_bt_cfg->channels;
+ sbc_dsp_cfg.data.sampling_rate = sbc_bt_cfg->sampling_rate;
+ ret = mixer_ctl_set_array(ctl_dec_data, (void *)&sbc_dsp_cfg,
+ sizeof(struct sbc_dec_cfg_t));
+
+ if (ret != 0) {
+ ALOGE("%s: failed to set SBC decoder config", __func__);
+ is_configured = false;
+ goto fail;
+ }
+
+ ctrl_bit_format = mixer_get_ctl_by_name(a2dp.adev->mixer,
+ MIXER_DEC_BIT_FORMAT);
+ if (!ctrl_bit_format) {
+ ALOGE(" ERROR Dec bit format mixer control not identified");
+ is_configured = false;
+ goto fail;
+ }
+ ret = mixer_ctl_set_enum_by_string(ctrl_bit_format, "S16_LE");
+ if (ret != 0) {
+ ALOGE("%s: Failed to set bit format to decoder", __func__);
+ is_configured = false;
+ goto fail;
+ }
+
+ is_configured = true;
+ a2dp.bt_decoder_format = CODEC_TYPE_SBC;
+ if (sbc_dsp_cfg.data.channels == MEDIA_FMT_SBC_CHANNEL_MODE_MONO)
+ a2dp.dec_channels = 1;
+ else
+ a2dp.dec_channels = 2;
+ a2dp.dec_sampling_rate = sbc_dsp_cfg.data.sampling_rate;
+ ALOGV("Successfully updated SBC dec format");
+fail:
+ return is_configured;
+}
+
+/* API to configure AFE decoder in DSP */
+static bool configure_a2dp_sink_decoder_format()
+{
+ void *codec_info = NULL;
+ codec_t codec_type = CODEC_TYPE_INVALID;
+ bool is_configured = false;
+ struct mixer_ctl *ctl_dec_data = NULL;
+ int ret = 0;
+
+ if (!a2dp.audio_get_dec_config) {
+ ALOGE(" a2dp handle is not identified, ignoring a2dp decoder config");
+ return false;
+ }
+
+ ctl_dec_data = mixer_get_ctl_by_name(a2dp.adev->mixer, MIXER_SINK_DEC_CONFIG_BLOCK);
+ if (!ctl_dec_data) {
+ ALOGE(" ERROR a2dp decoder CONFIG data mixer control not identified");
+ is_configured = false;
+ return false;
+ }
+ codec_info = a2dp.audio_get_dec_config(&codec_type);
+ switch(codec_type) {
+ case CODEC_TYPE_SBC:
+ ALOGD(" SBC decoder supported BT device");
+ is_configured = configure_sbc_dec_format((audio_sbc_dec_config_t *)codec_info);
+ break;
+ case CODEC_TYPE_AAC:
+ ALOGD(" AAC decoder supported BT device");
+ is_configured =
+ configure_aac_dec_format((audio_aac_dec_config_t *)codec_info);
+ break;
+ default:
+ ALOGD(" Received Unsupported decoder format");
+ is_configured = false;
+ break;
+ }
+ return is_configured;
}
/* API to configure SBC DSP encoder */
@@ -1103,12 +1451,12 @@
ctl_enc_data = mixer_get_ctl_by_name(a2dp.adev->mixer, MIXER_ENC_CONFIG_BLOCK);
if (!ctl_enc_data) {
- ALOGE(" ERROR a2dp encoder CONFIG data mixer control not identifed");
+ ALOGE(" ERROR a2dp encoder CONFIG data mixer control not identified");
is_configured = false;
goto fail;
}
memset(&sbc_dsp_cfg, 0x0, sizeof(struct sbc_enc_cfg_t));
- sbc_dsp_cfg.enc_format = ENC_MEDIA_FMT_SBC;
+ sbc_dsp_cfg.enc_format = MEDIA_FMT_SBC;
sbc_dsp_cfg.num_subbands = sbc_bt_cfg->subband;
sbc_dsp_cfg.blk_len = sbc_bt_cfg->blk_len;
switch(sbc_bt_cfg->channels) {
@@ -1145,7 +1493,7 @@
goto fail;
}
is_configured = true;
- a2dp.bt_encoder_format = ENC_CODEC_TYPE_SBC;
+ a2dp.bt_encoder_format = CODEC_TYPE_SBC;
a2dp.enc_sampling_rate = sbc_bt_cfg->sampling_rate;
if (sbc_dsp_cfg.channel_mode == MEDIA_FMT_SBC_CHANNEL_MODE_MONO)
@@ -1259,7 +1607,7 @@
}
memset(aptx_dsp_cfg, 0x0, sizeof(struct aptx_enc_cfg_t));
- aptx_dsp_cfg->custom_cfg.enc_format = ENC_MEDIA_FMT_APTX;
+ aptx_dsp_cfg->custom_cfg.enc_format = MEDIA_FMT_APTX;
if (!a2dp.is_aptx_dual_mono_supported) {
aptx_dsp_cfg->custom_cfg.sample_rate = aptx_bt_cfg->default_cfg->sampling_rate;
@@ -1316,7 +1664,7 @@
}
memset(&aptx_dsp_cfg, 0x0, sizeof(struct custom_enc_cfg_t));
- aptx_dsp_cfg->enc_format = ENC_MEDIA_FMT_APTX;
+ aptx_dsp_cfg->enc_format = MEDIA_FMT_APTX;
aptx_dsp_cfg->sample_rate = aptx_bt_cfg->sampling_rate;
aptx_dsp_cfg->num_channels = aptx_bt_cfg->channels;
switch(aptx_dsp_cfg->num_channels) {
@@ -1410,9 +1758,9 @@
}
is_configured = true;
if (a2dp.is_aptx_adaptive)
- a2dp.bt_encoder_format = ENC_CODEC_TYPE_APTX_AD;
+ a2dp.bt_encoder_format = CODEC_TYPE_APTX_AD;
else
- a2dp.bt_encoder_format = ENC_CODEC_TYPE_APTX;
+ a2dp.bt_encoder_format = CODEC_TYPE_APTX;
fail:
/*restore sample rate */
if(!is_configured)
@@ -1438,13 +1786,13 @@
ctl_enc_data = mixer_get_ctl_by_name(a2dp.adev->mixer, MIXER_ENC_CONFIG_BLOCK);
if (!ctl_enc_data) {
- ALOGE(" ERROR a2dp encoder CONFIG data mixer control not identifed");
+ ALOGE(" ERROR a2dp encoder CONFIG data mixer control not identified");
is_configured = false;
goto fail;
}
memset(&aptx_dsp_cfg, 0x0, sizeof(struct custom_enc_cfg_t));
- aptx_dsp_cfg.enc_format = ENC_MEDIA_FMT_APTX_HD;
+ aptx_dsp_cfg.enc_format = MEDIA_FMT_APTX_HD;
aptx_dsp_cfg.sample_rate = aptx_bt_cfg->sampling_rate;
aptx_dsp_cfg.num_channels = aptx_bt_cfg->channels;
switch(aptx_dsp_cfg.num_channels) {
@@ -1470,7 +1818,7 @@
goto fail;
}
is_configured = true;
- a2dp.bt_encoder_format = ENC_CODEC_TYPE_APTX_HD;
+ a2dp.bt_encoder_format = CODEC_TYPE_APTX_HD;
a2dp.enc_sampling_rate = aptx_bt_cfg->sampling_rate;
a2dp.enc_channels = aptx_bt_cfg->channels;
ALOGV("Successfully updated APTX HD encformat with samplingrate: %d channels:%d",
@@ -1492,12 +1840,12 @@
ctl_enc_data = mixer_get_ctl_by_name(a2dp.adev->mixer, MIXER_ENC_CONFIG_BLOCK);
if (!ctl_enc_data) {
- ALOGE(" ERROR a2dp encoder CONFIG data mixer control not identifed");
+ ALOGE(" ERROR a2dp encoder CONFIG data mixer control not identified");
is_configured = false;
goto fail;
}
memset(&aac_dsp_cfg, 0x0, sizeof(struct aac_enc_cfg_t));
- aac_dsp_cfg.enc_format = ENC_MEDIA_FMT_AAC;
+ aac_dsp_cfg.enc_format = MEDIA_FMT_AAC;
aac_dsp_cfg.bit_rate = aac_bt_cfg->bitrate;
aac_dsp_cfg.sample_rate = aac_bt_cfg->sampling_rate;
switch (aac_bt_cfg->enc_mode) {
@@ -1528,7 +1876,7 @@
goto fail;
}
is_configured = true;
- a2dp.bt_encoder_format = ENC_CODEC_TYPE_AAC;
+ a2dp.bt_encoder_format = CODEC_TYPE_AAC;
a2dp.enc_sampling_rate = aac_bt_cfg->sampling_rate;
a2dp.enc_channels = aac_bt_cfg->channels;
ALOGV("%s: Successfully updated AAC enc format with sampling rate: %d channels:%d",
@@ -1607,13 +1955,13 @@
ctl_enc_data = mixer_get_ctl_by_name(a2dp.adev->mixer, MIXER_ENC_CONFIG_BLOCK);
if (!ctl_enc_data) {
- ALOGE(" ERROR a2dp encoder CONFIG data mixer control not identifed");
+ ALOGE(" ERROR a2dp encoder CONFIG data mixer control not identified");
is_configured = false;
goto fail;
}
memset(&celt_dsp_cfg, 0x0, sizeof(struct celt_enc_cfg_t));
- celt_dsp_cfg.custom_cfg.enc_format = ENC_MEDIA_FMT_CELT;
+ celt_dsp_cfg.custom_cfg.enc_format = MEDIA_FMT_CELT;
celt_dsp_cfg.custom_cfg.sample_rate = celt_bt_cfg->sampling_rate;
celt_dsp_cfg.custom_cfg.num_channels = celt_bt_cfg->channels;
switch(celt_dsp_cfg.custom_cfg.num_channels) {
@@ -1648,7 +1996,7 @@
goto fail;
}
is_configured = true;
- a2dp.bt_encoder_format = ENC_CODEC_TYPE_CELT;
+ a2dp.bt_encoder_format = CODEC_TYPE_CELT;
a2dp.enc_sampling_rate = celt_bt_cfg->sampling_rate;
a2dp.enc_channels = celt_bt_cfg->channels;
ALOGV("Successfully updated CELT encformat with samplingrate: %d channels:%d",
@@ -1668,13 +2016,13 @@
ldac_enc_data = mixer_get_ctl_by_name(a2dp.adev->mixer, MIXER_ENC_CONFIG_BLOCK);
if (!ldac_enc_data) {
- ALOGE(" ERROR a2dp encoder CONFIG data mixer control not identifed");
+ ALOGE(" ERROR a2dp encoder CONFIG data mixer control not identified");
is_configured = false;
goto fail;
}
memset(&ldac_dsp_cfg, 0x0, sizeof(struct ldac_enc_cfg_t));
- ldac_dsp_cfg.custom_cfg.enc_format = ENC_MEDIA_FMT_LDAC;
+ ldac_dsp_cfg.custom_cfg.enc_format = MEDIA_FMT_LDAC;
ldac_dsp_cfg.custom_cfg.sample_rate = ldac_bt_cfg->sampling_rate;
ldac_dsp_cfg.ldac_cfg.channel_mode = ldac_bt_cfg->channel_mode;
switch(ldac_dsp_cfg.ldac_cfg.channel_mode) {
@@ -1716,7 +2064,7 @@
goto fail;
}
is_configured = true;
- a2dp.bt_encoder_format = ENC_CODEC_TYPE_LDAC;
+ a2dp.bt_encoder_format = CODEC_TYPE_LDAC;
a2dp.enc_sampling_rate = ldac_bt_cfg->sampling_rate;
a2dp.enc_channels = ldac_dsp_cfg.custom_cfg.num_channels;
a2dp.abr_config.is_abr_enabled = ldac_bt_cfg->is_abr_enabled;
@@ -1730,16 +2078,16 @@
{
void *codec_info = NULL;
uint8_t multi_cast = 0, num_dev = 1;
- enc_codec_t codec_type = ENC_CODEC_TYPE_INVALID;
+ codec_t codec_type = CODEC_TYPE_INVALID;
bool is_configured = false;
audio_aptx_encoder_config aptx_encoder_cfg;
- if (!a2dp.audio_get_codec_config) {
+ if (!a2dp.audio_get_enc_config) {
ALOGE(" a2dp handle is not identified, ignoring a2dp encoder config");
return false;
}
ALOGD("configure_a2dp_encoder_format start");
- codec_info = a2dp.audio_get_codec_config(&multi_cast, &num_dev,
+ codec_info = a2dp.audio_get_enc_config(&multi_cast, &num_dev,
&codec_type);
// ABR disabled by default for all codecs
@@ -1747,12 +2095,12 @@
a2dp.is_aptx_adaptive = false;
switch(codec_type) {
- case ENC_CODEC_TYPE_SBC:
+ case CODEC_TYPE_SBC:
ALOGD(" Received SBC encoder supported BT device");
is_configured =
configure_sbc_enc_format((audio_sbc_encoder_config *)codec_info);
break;
- case ENC_CODEC_TYPE_APTX:
+ case CODEC_TYPE_APTX:
ALOGD(" Received APTX encoder supported BT device");
#ifndef LINUX_ENABLED
a2dp.is_aptx_dual_mono_supported = false;
@@ -1761,7 +2109,7 @@
is_configured =
configure_aptx_enc_format(&aptx_encoder_cfg);
break;
- case ENC_CODEC_TYPE_APTX_HD:
+ case CODEC_TYPE_APTX_HD:
ALOGD(" Received APTX HD encoder supported BT device");
#ifndef LINUX_ENABLED
is_configured =
@@ -1772,7 +2120,7 @@
#endif
break;
#ifndef LINUX_ENABLED
- case ENC_CODEC_TYPE_APTX_DUAL_MONO:
+ case CODEC_TYPE_APTX_DUAL_MONO:
ALOGD(" Received APTX dual mono encoder supported BT device");
a2dp.is_aptx_dual_mono_supported = true;
if (a2dp.audio_is_tws_mono_mode_enable != NULL)
@@ -1782,7 +2130,7 @@
configure_aptx_enc_format(&aptx_encoder_cfg);
break;
#endif
- case ENC_CODEC_TYPE_AAC:
+ case CODEC_TYPE_AAC:
ALOGD(" Received AAC encoder supported BT device");
bool is_aac_frame_ctl_enabled =
property_get_bool("persist.vendor.bt.aac_frm_ctl.enabled", false);
@@ -1790,22 +2138,22 @@
configure_aac_enc_format_v2((audio_aac_encoder_config_v2 *) codec_info) :
configure_aac_enc_format((audio_aac_encoder_config *) codec_info);
break;
- case ENC_CODEC_TYPE_CELT:
+ case CODEC_TYPE_CELT:
ALOGD(" Received CELT encoder supported BT device");
is_configured =
configure_celt_enc_format((audio_celt_encoder_config *)codec_info);
break;
- case ENC_CODEC_TYPE_LDAC:
+ case CODEC_TYPE_LDAC:
ALOGD(" Received LDAC encoder supported BT device");
if (!instance_id || instance_id > MAX_INSTANCE_ID)
instance_id = MAX_INSTANCE_ID;
a2dp.abr_config.imc_instance = instance_id--;
is_configured =
(configure_ldac_enc_format((audio_ldac_encoder_config *)codec_info) &&
- configure_a2dp_decoder_format(ENC_CODEC_TYPE_LDAC));
+ configure_a2dp_source_decoder_format(CODEC_TYPE_LDAC));
break;
#ifndef LINUX_ENABLED //Temporarily disabled for LE, need to take care while doing VT FR
- case ENC_CODEC_TYPE_APTX_AD:
+ case CODEC_TYPE_APTX_AD:
ALOGD(" Received APTX AD encoder supported BT device");
if (!instance_id || instance_id > MAX_INSTANCE_ID)
instance_id = MAX_INSTANCE_ID;
@@ -1815,7 +2163,7 @@
aptx_encoder_cfg.ad_cfg = (audio_aptx_ad_config *)codec_info;
is_configured =
(configure_aptx_enc_format(&aptx_encoder_cfg) &&
- configure_a2dp_decoder_format(ENC_MEDIA_FMT_APTX_AD));
+ configure_a2dp_source_decoder_format(ENC_MEDIA_FMT_APTX_AD));
break;
#endif
default:
@@ -1832,49 +2180,135 @@
ALOGD("audio_extn_a2dp_start_playback start");
- if(!(a2dp.bt_lib_handle && a2dp.audio_start_stream
- && a2dp.audio_get_codec_config)) {
- ALOGE("a2dp handle is not identified, Ignoring start request");
+ if(!(a2dp.bt_lib_source_handle && a2dp.audio_source_start
+ && a2dp.audio_get_enc_config)) {
+ ALOGE("a2dp handle is not identified, Ignoring start playback request");
return -ENOSYS;
}
- if(a2dp.a2dp_suspended == true) {
+ if(a2dp.a2dp_source_suspended == true) {
//session will be restarted after suspend completion
ALOGD("a2dp start requested during suspend state");
return -ENOSYS;
}
- if (!a2dp.a2dp_started && !a2dp.a2dp_total_active_session_request) {
+ if (!a2dp.a2dp_source_started && !a2dp.a2dp_source_total_active_session_requests) {
ALOGD("calling BT module stream start");
/* This call indicates BT IPC lib to start playback */
- ret = a2dp.audio_start_stream();
+ ret = a2dp.audio_source_start();
ALOGE("BT controller start return = %d",ret);
if (ret != 0 ) {
ALOGE("BT controller start failed");
- a2dp.a2dp_started = false;
+ a2dp.a2dp_source_started = false;
} else {
if(configure_a2dp_encoder_format() == true) {
- a2dp.a2dp_started = true;
+ a2dp.a2dp_source_started = true;
ret = 0;
ALOGD("Start playback successful to BT library");
} else {
ALOGD(" unable to configure DSP encoder");
- a2dp.a2dp_started = false;
+ a2dp.a2dp_source_started = false;
ret = -ETIMEDOUT;
}
}
}
- if (a2dp.a2dp_started) {
- a2dp.a2dp_total_active_session_request++;
+ if (a2dp.a2dp_source_started) {
+ a2dp.a2dp_source_total_active_session_requests++;
a2dp_check_and_set_scrambler();
- a2dp_set_backend_cfg();
+ a2dp_set_backend_cfg(SOURCE);
if (a2dp.abr_config.is_abr_enabled)
start_abr();
}
ALOGD("start A2DP playback total active sessions :%d",
- a2dp.a2dp_total_active_session_request);
+ a2dp.a2dp_source_total_active_session_requests);
+ return ret;
+}
+
+uint64_t audio_extn_a2dp_get_decoder_latency()
+{
+ uint32_t latency = 0;
+
+ switch(a2dp.bt_decoder_format) {
+ case CODEC_TYPE_SBC:
+ latency = DEFAULT_SINK_LATENCY_SBC;
+ break;
+ case CODEC_TYPE_AAC:
+ latency = DEFAULT_SINK_LATENCY_AAC;
+ break;
+ default:
+ latency = 200;
+ ALOGD("No valid decoder defined, setting latency to %dms", latency);
+ break;
+ }
+ return (uint64_t)latency;
+}
+
+bool a2dp_send_sink_setup_complete(void) {
+ uint64_t system_latency = 0;
+ bool is_complete = false;
+
+ system_latency = audio_extn_a2dp_get_decoder_latency();
+
+ if (a2dp.audio_sink_session_setup_complete(system_latency) == 0) {
+ is_complete = true;
+ }
+ return is_complete;
+}
+
+int audio_extn_a2dp_start_capture()
+{
+ int ret = 0;
+
+ ALOGD("audio_extn_a2dp_start_capture start");
+
+ if(!(a2dp.bt_lib_sink_handle && a2dp.audio_sink_start
+ && a2dp.audio_get_dec_config)) {
+ ALOGE("a2dp handle is not identified, Ignoring start capture request");
+ return -ENOSYS;
+ }
+
+ if (!a2dp.a2dp_sink_started && !a2dp.a2dp_sink_total_active_session_requests) {
+ ALOGD("calling BT module stream start");
+ /* This call indicates BT IPC lib to start capture */
+ ret = a2dp.audio_sink_start();
+ ALOGE("BT controller start capture return = %d",ret);
+ if (ret != 0 ) {
+ ALOGE("BT controller start capture failed");
+ a2dp.a2dp_sink_started = false;
+ } else {
+
+ if(!audio_extn_a2dp_sink_is_ready()) {
+ ALOGD("Wait for capture ready not successful");
+ ret = -ETIMEDOUT;
+ }
+
+ if(configure_a2dp_sink_decoder_format() == true) {
+ a2dp.a2dp_sink_started = true;
+ ret = 0;
+ ALOGD("Start capture successful to BT library");
+ } else {
+ ALOGD(" unable to configure DSP decoder");
+ a2dp.a2dp_sink_started = false;
+ ret = -ETIMEDOUT;
+ }
+
+ if (!a2dp_send_sink_setup_complete()) {
+ ALOGD("sink_setup_complete not successful");
+ ret = -ETIMEDOUT;
+ }
+ }
+ }
+
+ if (a2dp.a2dp_sink_started) {
+ if (a2dp_set_backend_cfg(SINK) == true) {
+ a2dp.a2dp_sink_total_active_session_requests++;
+ }
+ }
+
+ ALOGD("start A2DP sink total active sessions :%d",
+ a2dp.a2dp_sink_total_active_session_requests);
return ret;
}
@@ -1890,16 +2324,16 @@
ctl_enc_config = mixer_get_ctl_by_name(a2dp.adev->mixer,
MIXER_ENC_CONFIG_BLOCK);
if (!ctl_enc_config) {
- ALOGE(" ERROR a2dp encoder format mixer control not identifed");
+ ALOGE(" ERROR a2dp encoder format mixer control not identified");
} else {
ret = mixer_ctl_set_array(ctl_enc_config, (void *)&dummy_reset_config,
sizeof(struct sbc_enc_cfg_t));
- a2dp.bt_encoder_format = ENC_MEDIA_FMT_NONE;
+ a2dp.bt_encoder_format = MEDIA_FMT_NONE;
}
ctrl_bit_format = mixer_get_ctl_by_name(a2dp.adev->mixer,
MIXER_ENC_BIT_FORMAT);
if (!ctrl_bit_format) {
- ALOGE(" ERROR bit format CONFIG data mixer control not identifed");
+ ALOGE(" ERROR bit format CONFIG data mixer control not identified");
} else {
ret = mixer_ctl_set_enum_by_string(ctrl_bit_format, "S16_LE");
if (ret != 0) {
@@ -1919,14 +2353,14 @@
}
}
-static int reset_a2dp_dec_config_params()
+static int reset_a2dp_source_dec_config_params()
{
struct mixer_ctl *ctl_dec_data = NULL;
struct abr_dec_cfg_t dummy_reset_cfg;
int ret = 0;
if (a2dp.abr_config.is_abr_enabled) {
- ctl_dec_data = mixer_get_ctl_by_name(a2dp.adev->mixer, MIXER_DEC_CONFIG_BLOCK);
+ ctl_dec_data = mixer_get_ctl_by_name(a2dp.adev->mixer, MIXER_SOURCE_DEC_CONFIG_BLOCK);
if (!ctl_dec_data) {
ALOGE("%s: ERROR A2DP decoder config mixer control not identifed", __func__);
return -EINVAL;
@@ -1943,38 +2377,98 @@
return ret;
}
+static void reset_a2dp_sink_dec_config_params()
+{
+ int ret =0;
+
+ struct mixer_ctl *ctl_dec_config, *ctrl_bit_format;
+ struct aac_dec_cfg_t dummy_reset_config;
+
+ memset(&dummy_reset_config, 0x0, sizeof(struct aac_dec_cfg_t));
+ ctl_dec_config = mixer_get_ctl_by_name(a2dp.adev->mixer,
+ MIXER_SINK_DEC_CONFIG_BLOCK);
+ if (!ctl_dec_config) {
+ ALOGE(" ERROR a2dp decoder format mixer control not identified");
+ } else {
+ ret = mixer_ctl_set_array(ctl_dec_config, (void *)&dummy_reset_config,
+ sizeof(struct aac_dec_cfg_t));
+ a2dp.bt_decoder_format = MEDIA_FMT_NONE;
+ }
+ ctrl_bit_format = mixer_get_ctl_by_name(a2dp.adev->mixer,
+ MIXER_DEC_BIT_FORMAT);
+ if (!ctrl_bit_format) {
+ ALOGE(" ERROR bit format CONFIG data mixer control not identified");
+ } else {
+ ret = mixer_ctl_set_enum_by_string(ctrl_bit_format, "S16_LE");
+ if (ret != 0) {
+ ALOGE("%s: Failed to set bit format to decoder", __func__);
+ }
+ }
+}
+
int audio_extn_a2dp_stop_playback()
{
int ret =0;
ALOGV("audio_extn_a2dp_stop_playback start");
- if(!(a2dp.bt_lib_handle && a2dp.audio_stop_stream)) {
- ALOGE("a2dp handle is not identified, Ignoring start request");
+ if(!(a2dp.bt_lib_source_handle && a2dp.audio_source_stop)) {
+ ALOGE("a2dp handle is not identified, Ignoring stop request");
return -ENOSYS;
}
- if (a2dp.a2dp_total_active_session_request > 0)
- a2dp.a2dp_total_active_session_request--;
+ if (a2dp.a2dp_source_total_active_session_requests > 0)
+ a2dp.a2dp_source_total_active_session_requests--;
- if ( a2dp.a2dp_started && !a2dp.a2dp_total_active_session_request) {
+ if ( a2dp.a2dp_source_started && !a2dp.a2dp_source_total_active_session_requests) {
ALOGV("calling BT module stream stop");
- ret = a2dp.audio_stop_stream();
+ ret = a2dp.audio_source_stop();
if (ret < 0)
ALOGE("stop stream to BT IPC lib failed");
else
ALOGV("stop steam to BT IPC lib successful");
reset_a2dp_enc_config_params();
- reset_a2dp_dec_config_params();
- a2dp_reset_backend_cfg();
+ reset_a2dp_source_dec_config_params();
+ a2dp_reset_backend_cfg(SOURCE);
if (a2dp.abr_config.is_abr_enabled && a2dp.abr_config.abr_started)
stop_abr();
a2dp.abr_config.is_abr_enabled = false;
- a2dp.a2dp_started = false;
+ a2dp.a2dp_source_started = false;
+ a2dp_reset_backend_cfg(SOURCE);
}
- if(!a2dp.a2dp_total_active_session_request)
- a2dp.a2dp_started = false;
- ALOGD("Stop A2DP playback total active sessions :%d",
- a2dp.a2dp_total_active_session_request);
+ if(!a2dp.a2dp_source_total_active_session_requests)
+ a2dp.a2dp_source_started = false;
+ ALOGD("Stop A2DP playback, total active sessions :%d",
+ a2dp.a2dp_source_total_active_session_requests);
+ return 0;
+}
+
+int audio_extn_a2dp_stop_capture()
+{
+ int ret =0;
+
+ ALOGV("audio_extn_a2dp_stop_capture start");
+ if(!(a2dp.bt_lib_sink_handle && a2dp.audio_sink_stop)) {
+ ALOGE("a2dp handle is not identified, Ignoring stop request");
+ return -ENOSYS;
+ }
+
+ if (a2dp.a2dp_sink_total_active_session_requests > 0)
+ a2dp.a2dp_sink_total_active_session_requests--;
+
+ if ( a2dp.a2dp_sink_started && !a2dp.a2dp_sink_total_active_session_requests) {
+ ALOGV("calling BT module stream stop");
+ ret = a2dp.audio_sink_stop();
+ if (ret < 0)
+ ALOGE("stop stream to BT IPC lib failed");
+ else
+ ALOGV("stop steam to BT IPC lib successful");
+ reset_a2dp_sink_dec_config_params();
+ a2dp_reset_backend_cfg(SINK);
+ }
+ if(!a2dp.a2dp_sink_total_active_session_requests)
+ a2dp.a2dp_source_started = false;
+ ALOGD("Stop A2DP capture, total active sessions :%d",
+ a2dp.a2dp_sink_total_active_session_requests);
return 0;
}
@@ -1986,7 +2480,7 @@
struct listnode *node;
if(a2dp.is_a2dp_offload_supported == false) {
- ALOGV("no supported encoders identified,ignoring a2dp setparam");
+ ALOGV("no supported codecs identified,ignoring a2dp setparam");
return;
}
@@ -1995,8 +2489,8 @@
if (ret >= 0) {
val = atoi(value);
if (audio_is_a2dp_out_device(val)) {
- ALOGV("Received device connect request for A2DP");
- open_a2dp_output();
+ ALOGV("Received device connect request for A2DP source");
+ open_a2dp_source();
}
goto param_handled;
}
@@ -2007,15 +2501,20 @@
if (ret >= 0) {
val = atoi(value);
if (audio_is_a2dp_out_device(val)) {
- ALOGV("Received device dis- connect request");
- reset_a2dp_enc_config_params();
- reset_a2dp_dec_config_params();
+ ALOGV("Received source device dis- connect request");
close_a2dp_output();
- a2dp_reset_backend_cfg();
+ reset_a2dp_enc_config_params();
+ reset_a2dp_source_dec_config_params();
+ a2dp_reset_backend_cfg(SOURCE);
+ } else if (audio_is_a2dp_in_device(val)) {
+ ALOGV("Received sink device dis- connect request");
+ close_a2dp_input();
+ reset_a2dp_sink_dec_config_params();
+ a2dp_reset_backend_cfg(SINK);
}
goto param_handled;
}
-
+#ifndef LINUX_ENABLED
ret = str_parms_get_str(parms, "TwsChannelConfig", value, sizeof(value));
if (ret>=0) {
ALOGD("Setting tws channel mode to %s",value);
@@ -2026,14 +2525,14 @@
audio_a2dp_update_tws_channel_mode();
goto param_handled;
}
-
+#endif
ret = str_parms_get_str(parms, "A2dpSuspended", value, sizeof(value));
if (ret >= 0) {
- if (a2dp.bt_lib_handle) {
+ if (a2dp.bt_lib_source_handle) {
if ((!strncmp(value,"true",sizeof(value)))) {
ALOGD("Setting a2dp to suspend state");
- a2dp.a2dp_suspended = true;
- if (a2dp.bt_state == A2DP_STATE_DISCONNECTED)
+ a2dp.a2dp_source_suspended = true;
+ if (a2dp.bt_state_source == A2DP_STATE_DISCONNECTED)
goto param_handled;
list_for_each(node, &a2dp.adev->usecase_list) {
uc_info = node_to_item(node, struct audio_usecase, list);
@@ -2045,16 +2544,16 @@
}
}
reset_a2dp_enc_config_params();
- reset_a2dp_dec_config_params();
- if(a2dp.audio_suspend_stream)
- a2dp.audio_suspend_stream();
- } else if (a2dp.a2dp_suspended == true) {
+ reset_a2dp_source_dec_config_params();
+ if(a2dp.audio_source_suspend)
+ a2dp.audio_source_suspend();
+ } else if (a2dp.a2dp_source_suspended == true) {
ALOGD("Resetting a2dp suspend state");
struct audio_usecase *uc_info;
struct listnode *node;
- if(a2dp.clear_a2dpsuspend_flag)
- a2dp.clear_a2dpsuspend_flag();
- a2dp.a2dp_suspended = false;
+ if(a2dp.clear_source_a2dpsuspend_flag)
+ a2dp.clear_source_a2dpsuspend_flag();
+ a2dp.a2dp_source_suspended = false;
/*
* It is possible that before suspend,a2dp sessions can be active
* for example during music + voice activation concurrency
@@ -2066,13 +2565,13 @@
* Fix is to call a2dp start for IPC library post suspend
* based on number of active session count
*/
- if (a2dp.a2dp_total_active_session_request > 0) {
+ if (a2dp.a2dp_source_total_active_session_requests > 0) {
ALOGD(" Calling IPC lib start post suspend state");
- if(a2dp.audio_start_stream) {
- ret = a2dp.audio_start_stream();
+ if(a2dp.audio_source_start) {
+ ret = a2dp.audio_source_start();
if (ret != 0) {
ALOGE("BT controller start failed");
- a2dp.a2dp_started = false;
+ a2dp.a2dp_source_started = false;
}
}
}
@@ -2103,44 +2602,59 @@
//During encoder reconfiguration mode, force a2dp device switch
// Or if a2dp device is selected but earlier start failed ( as a2dp
// was suspended, force retry.
- return a2dp.is_handoff_in_progress || !a2dp.a2dp_started;
+ return a2dp.is_handoff_in_progress || !a2dp.a2dp_source_started;
}
-void audio_extn_a2dp_get_sample_rate(int *sample_rate)
+void audio_extn_a2dp_get_enc_sample_rate(int *sample_rate)
{
*sample_rate = a2dp.enc_sampling_rate;
}
-bool audio_extn_a2dp_is_ready()
+void audio_extn_a2dp_get_dec_sample_rate(int *sample_rate)
+{
+ *sample_rate = a2dp.dec_sampling_rate;
+}
+
+bool audio_extn_a2dp_source_is_ready()
{
bool ret = false;
- if (a2dp.a2dp_suspended)
+ if (a2dp.a2dp_source_suspended)
return ret;
- if ((a2dp.bt_state != A2DP_STATE_DISCONNECTED) &&
+ if ((a2dp.bt_state_source != A2DP_STATE_DISCONNECTED) &&
(a2dp.is_a2dp_offload_supported) &&
- (a2dp.audio_check_a2dp_ready))
- ret = a2dp.audio_check_a2dp_ready();
+ (a2dp.audio_source_check_a2dp_ready))
+ ret = a2dp.audio_source_check_a2dp_ready();
return ret;
}
-bool audio_extn_a2dp_is_suspended()
+bool audio_extn_a2dp_sink_is_ready()
{
- return a2dp.a2dp_suspended;
+ bool ret = false;
+
+ if ((a2dp.bt_state_sink != A2DP_STATE_DISCONNECTED) &&
+ (a2dp.is_a2dp_offload_supported) &&
+ (a2dp.audio_sink_check_a2dp_ready))
+ ret = a2dp.audio_sink_check_a2dp_ready();
+ return ret;
+}
+
+bool audio_extn_a2dp_source_is_suspended()
+{
+ return a2dp.a2dp_source_suspended;
}
void audio_extn_a2dp_init (void *adev)
{
a2dp.adev = (struct audio_device*)adev;
- a2dp.bt_lib_handle = NULL;
- a2dp.a2dp_started = false;
- a2dp.bt_state = A2DP_STATE_DISCONNECTED;
- a2dp.a2dp_total_active_session_request = 0;
- a2dp.a2dp_suspended = false;
- a2dp.bt_encoder_format = ENC_CODEC_TYPE_INVALID;
+ a2dp.bt_lib_source_handle = NULL;
+ a2dp.a2dp_source_started = false;
+ a2dp.bt_state_source = A2DP_STATE_DISCONNECTED;
+ a2dp.a2dp_source_total_active_session_requests = 0;
+ a2dp.a2dp_source_suspended = false;
+ a2dp.bt_encoder_format = CODEC_TYPE_INVALID;
a2dp.enc_sampling_rate = 48000;
- a2dp.is_a2dp_offload_supported = false;
a2dp.is_handoff_in_progress = false;
a2dp.is_aptx_dual_mono_supported = false;
a2dp.is_aptx_adaptive = false;
@@ -2150,7 +2664,16 @@
a2dp.abr_config.abr_tx_handle = NULL;
a2dp.is_tws_mono_mode_on = false;
reset_a2dp_enc_config_params();
- reset_a2dp_dec_config_params();
+ reset_a2dp_source_dec_config_params();
+ reset_a2dp_sink_dec_config_params();
+
+ a2dp.bt_lib_sink_handle = NULL;
+ a2dp.a2dp_sink_started = false;
+ a2dp.bt_state_sink = A2DP_STATE_DISCONNECTED;
+ a2dp.a2dp_sink_total_active_session_requests = 0;
+ open_a2dp_sink();
+
+ a2dp.is_a2dp_offload_supported = false;
update_offload_codec_capabilities();
}
@@ -2173,32 +2696,32 @@
}
uint32_t slatency = 0;
- if (a2dp.audio_get_a2dp_sink_latency && a2dp.bt_state != A2DP_STATE_DISCONNECTED) {
- slatency = a2dp.audio_get_a2dp_sink_latency();
+ if (a2dp.audio_sink_get_a2dp_latency && a2dp.bt_state_source != A2DP_STATE_DISCONNECTED) {
+ slatency = a2dp.audio_sink_get_a2dp_latency();
}
switch(a2dp.bt_encoder_format) {
- case ENC_CODEC_TYPE_SBC:
+ case CODEC_TYPE_SBC:
latency = (avsync_runtime_prop > 0) ? sbc_offset : ENCODER_LATENCY_SBC;
latency += (slatency <= 0) ? DEFAULT_SINK_LATENCY_SBC : slatency;
break;
- case ENC_CODEC_TYPE_APTX:
+ case CODEC_TYPE_APTX:
latency = (avsync_runtime_prop > 0) ? aptx_offset : ENCODER_LATENCY_APTX;
latency += (slatency <= 0) ? DEFAULT_SINK_LATENCY_APTX : slatency;
break;
- case ENC_CODEC_TYPE_APTX_HD:
+ case CODEC_TYPE_APTX_HD:
latency = (avsync_runtime_prop > 0) ? aptxhd_offset : ENCODER_LATENCY_APTX_HD;
latency += (slatency <= 0) ? DEFAULT_SINK_LATENCY_APTX_HD : slatency;
break;
- case ENC_CODEC_TYPE_AAC:
+ case CODEC_TYPE_AAC:
latency = (avsync_runtime_prop > 0) ? aac_offset : ENCODER_LATENCY_AAC;
latency += (slatency <= 0) ? DEFAULT_SINK_LATENCY_AAC : slatency;
break;
- case ENC_CODEC_TYPE_CELT:
+ case CODEC_TYPE_CELT:
latency = (avsync_runtime_prop > 0) ? celt_offset : ENCODER_LATENCY_CELT;
latency += (slatency <= 0) ? DEFAULT_SINK_LATENCY_CELT : slatency;
break;
- case ENC_CODEC_TYPE_LDAC:
+ case CODEC_TYPE_LDAC:
latency = (avsync_runtime_prop > 0) ? ldac_offset : ENCODER_LATENCY_LDAC;
latency += (slatency <= 0) ? DEFAULT_SINK_LATENCY_LDAC : slatency;
break;