Merge "hal: initialize the cal data structure in set and get cal functions"
diff --git a/Android.mk b/Android.mk
index a7c8f2d..b970f53 100644
--- a/Android.mk
+++ b/Android.mk
@@ -14,6 +14,7 @@
include $(MY_LOCAL_PATH)/mm-audio/Android.mk
include $(MY_LOCAL_PATH)/visualizer/Android.mk
include $(MY_LOCAL_PATH)/post_proc/Android.mk
+include $(MY_LOCAL_PATH)/qahw/Android.mk
include $(MY_LOCAL_PATH)/qahw_api/Android.mk
endif
diff --git a/configs/apq8098_latv/apq8098_latv.mk b/configs/apq8098_latv/apq8098_latv.mk
old mode 100644
new mode 100755
index 7fe0d48..493d5ce
--- a/configs/apq8098_latv/apq8098_latv.mk
+++ b/configs/apq8098_latv/apq8098_latv.mk
@@ -30,7 +30,7 @@
AUDIO_FEATURE_ENABLED_AUDIOSPHERE := true
AUDIO_FEATURE_ENABLED_USB_TUNNEL_AUDIO := true
AUDIO_FEATURE_ENABLED_SPLIT_A2DP := true
-AUDIO_FEATURE_ENABLED_3D_AUDIO := true
+AUDIO_FEATURE_ENABLED_3D_AUDIO := false
AUDIO_FEATURE_ENABLED_VOICE_PRINT := false
USE_LEGACY_AUDIO_DAEMON := false
USE_LEGACY_AUDIO_MEASUREMENT := false
diff --git a/configs/apq8098_latv/audio_policy_configuration.xml b/configs/apq8098_latv/audio_policy_configuration.xml
index 77db6e5..a66d99f 100755
--- a/configs/apq8098_latv/audio_policy_configuration.xml
+++ b/configs/apq8098_latv/audio_policy_configuration.xml
@@ -21,6 +21,7 @@
<!-- version section contains a “version” tag in the form “major.minor” e.g version=”1.0” -->
<!-- Global configuration Decalaration -->
+ <globalConfiguration speaker_drc_enabled="true"/>
<!-- Modules section:
@@ -48,7 +49,9 @@
<!-- Primary Audio HAL -->
<module name="primary" halVersion="2.0">
<attachedDevices>
- <item>HDMI</item>
+ <item>Telephony Tx</item>
+ <item>Built-In Mic</item>
+ <item>Built-In Back Mic</item>
</attachedDevices>
<defaultOutputDevice>HDMI</defaultOutputDevice>
<mixPorts>
@@ -56,26 +59,20 @@
<profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
samplingRates="48000" channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
</mixPort>
+ <mixPort name="raw" role="source"
+ flags="AUDIO_OUTPUT_FLAG_FAST|AUDIO_OUTPUT_FLAG_RAW">
+ <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+ samplingRates="48000" channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
+ </mixPort>
+ <mixPort name="mmap_no_irq_out" role="source" flags="AUDIO_OUTPUT_FLAG_DIRECT|AUDIO_OUTPUT_FLAG_MMAP_NOIRQ">
+ <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+ samplingRates="48000" channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
+ </mixPort>
<mixPort name="compress_passthrough" role="source"
flags="AUDIO_OUTPUT_FLAG_DIRECT|AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD|AUDIO_OUTPUT_FLAG_NON_BLOCKING">
<profile name="" format="dynamic"
samplingRates="dynamic" channelMasks="dynamic"/>
</mixPort>
- <mixPort name="direct_pcm" role="source"
- flags="AUDIO_OUTPUT_FLAG_DIRECT">
- <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
- samplingRates="8000,11025,12000,16000,22050,24000,32000,44100,48000,64000,88200,96000,128000,176400,192000"
- channelMasks="AUDIO_CHANNEL_OUT_MONO,AUDIO_CHANNEL_OUT_STEREO,AUDIO_CHANNEL_OUT_2POINT1,AUDIO_CHANNEL_OUT_QUAD,AUDIO_CHANNEL_OUT_PENTA,AUDIO_CHANNEL_OUT_5POINT1,AUDIO_CHANNEL_OUT_6POINT1,AUDIO_CHANNEL_OUT_7POINT1"/>
- <profile name="" format="AUDIO_FORMAT_PCM_8_24_BIT"
- samplingRates="8000,11025,12000,16000,22050,24000,32000,44100,48000,64000,88200,96000,128000,176400,192000,352800,384000"
- channelMasks="AUDIO_CHANNEL_OUT_MONO,AUDIO_CHANNEL_OUT_STEREO,AUDIO_CHANNEL_OUT_2POINT1,AUDIO_CHANNEL_OUT_QUAD,AUDIO_CHANNEL_OUT_PENTA,AUDIO_CHANNEL_OUT_5POINT1,AUDIO_CHANNEL_OUT_6POINT1,AUDIO_CHANNEL_OUT_7POINT1"/>
- <profile name="" format="AUDIO_FORMAT_PCM_24_BIT_PACKED"
- samplingRates="8000,11025,12000,16000,22050,24000,32000,44100,48000,64000,88200,96000,128000,176400,192000,352800,384000"
- channelMasks="AUDIO_CHANNEL_OUT_MONO,AUDIO_CHANNEL_OUT_STEREO,AUDIO_CHANNEL_OUT_2POINT1,AUDIO_CHANNEL_OUT_QUAD,AUDIO_CHANNEL_OUT_PENTA,AUDIO_CHANNEL_OUT_5POINT1,AUDIO_CHANNEL_OUT_6POINT1,AUDIO_CHANNEL_OUT_7POINT1"/>
- <profile name="" format="AUDIO_FORMAT_PCM_32_BIT"
- samplingRates="8000,11025,12000,16000,22050,24000,32000,44100,48000,64000,88200,96000,128000,176400,192000,352800,384000"
- channelMasks="AUDIO_CHANNEL_OUT_MONO,AUDIO_CHANNEL_OUT_STEREO,AUDIO_CHANNEL_OUT_2POINT1,AUDIO_CHANNEL_OUT_QUAD,AUDIO_CHANNEL_OUT_PENTA,AUDIO_CHANNEL_OUT_5POINT1,AUDIO_CHANNEL_OUT_6POINT1,AUDIO_CHANNEL_OUT_7POINT1"/>
- </mixPort>
<mixPort name="compressed_offload" role="source"
flags="AUDIO_OUTPUT_FLAG_DIRECT|AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD|AUDIO_OUTPUT_FLAG_NON_BLOCKING">
<profile name="" format="AUDIO_FORMAT_MP2"
@@ -109,10 +106,50 @@
samplingRates="8000,11025,12000,16000,22050,24000,32000,44100,48000,64000,88200,96000"
channelMasks="AUDIO_CHANNEL_OUT_STEREO,AUDIO_CHANNEL_OUT_MONO"/>
</mixPort>
+ <mixPort name="voice_tx" role="source">
+ <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+ samplingRates="8000,16000,48000" channelMasks="AUDIO_CHANNEL_OUT_MONO,AUDIO_CHANNEL_OUT_STEREO"/>
+ </mixPort>
+ <mixPort name="voip_rx" role="source"
+ flags="AUDIO_OUTPUT_FLAG_DIRECT|AUDIO_OUTPUT_FLAG_VOIP_RX">
+ <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+ samplingRates="8000,16000,32000,48000" channelMasks="AUDIO_CHANNEL_OUT_MONO"/>
+ </mixPort>
+
+ <mixPort name="primary input" role="sink">
+ <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+ samplingRates="8000,11025,12000,16000,22050,24000,32000,44100,48000"
+ channelMasks="AUDIO_CHANNEL_IN_MONO,AUDIO_CHANNEL_IN_STEREO,AUDIO_CHANNEL_IN_FRONT_BACK"/>
+ </mixPort>
+ <mixPort name="surround_sound" role="sink">
+ <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+ samplingRates="8000,11025,12000,16000,22050,24000,32000,44100,48000"
+ channelMasks="AUDIO_CHANNEL_IN_MONO,AUDIO_CHANNEL_IN_STEREO,AUDIO_CHANNEL_IN_FRONT_BACK,AUDIO_CHANNEL_INDEX_MASK_3,AUDIO_CHANNEL_INDEX_MASK_4,AUDIO_CHANNEL_IN_5POINT1,AUDIO_CHANNEL_INDEX_MASK_6"/>
+ </mixPort>
+ <mixPort name="record_24" role="sink">
+ <profile name="" format="AUDIO_FORMAT_PCM_24_BIT_PACKED"
+ samplingRates="8000,11025,12000,16000,22050,24000,32000,44100,48000,96000,192000"
+ channelMasks="AUDIO_CHANNEL_IN_MONO,AUDIO_CHANNEL_IN_STEREO,AUDIO_CHANNEL_IN_FRONT_BACK,AUDIO_CHANNEL_INDEX_MASK_3,AUDIO_CHANNEL_INDEX_MASK_4"/>
+ <profile name="" format="AUDIO_FORMAT_PCM_8_24_BIT"
+ samplingRates="8000,11025,12000,16000,22050,24000,32000,44100,48000,96000,192000"
+ channelMasks="AUDIO_CHANNEL_IN_MONO,AUDIO_CHANNEL_IN_STEREO,AUDIO_CHANNEL_IN_FRONT_BACK,AUDIO_CHANNEL_INDEX_MASK_3,AUDIO_CHANNEL_INDEX_MASK_4"/>
+ <profile name="" format="AUDIO_FORMAT_PCM_FLOAT"
+ samplingRates="8000,11025,12000,16000,22050,24000,32000,44100,48000,96000,192000"
+ channelMasks="AUDIO_CHANNEL_IN_MONO,AUDIO_CHANNEL_IN_STEREO,AUDIO_CHANNEL_IN_FRONT_BACK,AUDIO_CHANNEL_INDEX_MASK_3,AUDIO_CHANNEL_INDEX_MASK_4"/>
+ </mixPort>
+ <mixPort name="mmap_no_irq_in" role="sink" flags="AUDIO_INPUT_FLAG_MMAP_NOIRQ">
+ <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+ samplingRates="8000,11025,12000,16000,22050,24000,32000,44100,48000"
+ channelMasks="AUDIO_CHANNEL_IN_MONO,AUDIO_CHANNEL_IN_STEREO,AUDIO_CHANNEL_IN_FRONT_BACK,AUDIO_CHANNEL_INDEX_MASK_3"/>
+ </mixPort>
</mixPorts>
<devicePorts>
<!-- Output devices declaration, i.e. Sink DEVICE PORT -->
+ <devicePort tagName="Telephony Tx" type="AUDIO_DEVICE_OUT_TELEPHONY_TX" role="sink">
+ <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+ samplingRates="8000,16000" channelMasks="AUDIO_CHANNEL_OUT_MONO,AUDIO_CHANNEL_OUT_STEREO"/>
+ </devicePort>
<devicePort tagName="HDMI" type="AUDIO_DEVICE_OUT_AUX_DIGITAL" role="sink">
<profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
samplingRates="8000,11025,16000,22050,32000,44100,48000,64000,88200,96000,128000,176400,192000" channelMasks="dynamic"/>
@@ -129,17 +166,41 @@
<profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
samplingRates="48000" channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
</devicePort>
+ <devicePort tagName="Built-In Mic" type="AUDIO_DEVICE_IN_BUILTIN_MIC" role="source">
+ <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+ samplingRates="8000,11025,12000,16000,22050,24000,32000,44100,48000"
+ channelMasks="AUDIO_CHANNEL_IN_MONO,AUDIO_CHANNEL_IN_STEREO,AUDIO_CHANNEL_IN_FRONT_BACK"/>
+ </devicePort>
+ <devicePort tagName="Built-In Back Mic" type="AUDIO_DEVICE_IN_BACK_MIC" role="source">
+ <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+ samplingRates="8000,11025,12000,16000,22050,24000,32000,44100,48000"
+ channelMasks="AUDIO_CHANNEL_IN_MONO,AUDIO_CHANNEL_IN_STEREO,AUDIO_CHANNEL_IN_FRONT_BACK"/>
+ </devicePort>
+ <devicePort tagName="BT SCO Headset Mic" type="AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET" role="source">
+ <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+ samplingRates="8000,16000" channelMasks="AUDIO_CHANNEL_IN_MONO"/>
+ </devicePort>
</devicePorts>
<!-- route declaration, i.e. list all available sources for a given sink -->
<routes>
<route type="mix" sink="HDMI"
- sources="primary output,direct_pcm,compressed_offload,compress_passthrough"/>
+ sources="primary output,raw,compressed_offload,compress_passthrough"/>
+ <route type="mix" sink="Telephony Tx"
+ sources="voice_tx"/>
+ <route type="mix" sink="primary input"
+ sources="BT SCO Headset Mic"/>
+ <route type="mix" sink="surround_sound"
+ sources="Built-In Mic,Built-In Back Mic"/>
+ <route type="mix" sink="record_24"
+ sources="Built-In Mic,Built-In Back Mic"/>
+ <route type="mix" sink="mmap_no_irq_in"
+ sources="Built-In Mic,Built-In Back Mic"/>
<route type="mix" sink="BT A2DP Out"
- sources="primary output,direct_pcm,compressed_offload"/>
+ sources="primary output,raw,compressed_offload"/>
<route type="mix" sink="BT A2DP Headphones"
- sources="primary output,direct_pcm,compressed_offload"/>
+ sources="primary output,raw,compressed_offload"/>
<route type="mix" sink="BT A2DP Speaker"
- sources="primary output,direct_pcm,compressed_offload"/>
+ sources="primary output,raw,compressed_offload"/>
</routes>
</module>
diff --git a/configure.ac b/configure.ac
index 9a17458..805d00c 100644
--- a/configure.ac
+++ b/configure.ac
@@ -75,6 +75,7 @@
fi
AC_SUBST([TARGET_CFLAGS])
+AM_CONDITIONAL([QTI_AUDIO_SERVER_ENABLED],[test x$BOARD_SUPPORTS_QTI_AUDIO_SERVER = xtrue])
AM_CONDITIONAL([QAHW_SUPPORT], [test x$BOARD_SUPPORTS_QAHW = xtrue])
AM_CONDITIONAL([HDMI_EDID], [test x$AUDIO_FEATURE_ENABLED_HDMI_EDID = xtrue])
AM_CONDITIONAL([FM_POWER_OPT], [test x$AUDIO_FEATURE_ENABLED_FM_POWER_OPT = xtrue])
diff --git a/hal/audio_extn/a2dp.c b/hal/audio_extn/a2dp.c
index 8ce3784..5423665 100644
--- a/hal/audio_extn/a2dp.c
+++ b/hal/audio_extn/a2dp.c
@@ -1067,13 +1067,8 @@
return a2dp.is_handoff_in_progress || !a2dp.a2dp_started;
}
-void audio_extn_a2dp_get_apptype_params(uint32_t *sample_rate,
- uint32_t *bit_width)
+void audio_extn_a2dp_get_sample_rate(int *sample_rate)
{
- if(a2dp.bt_encoder_format == ENC_CODEC_TYPE_APTX_HD)
- *bit_width = 24;
- else
- *bit_width = 16;
*sample_rate = a2dp.enc_sampling_rate;
}
diff --git a/hal/audio_extn/audio_extn.h b/hal/audio_extn/audio_extn.h
index 81f51e4..fdab426 100644
--- a/hal/audio_extn/audio_extn.h
+++ b/hal/audio_extn/audio_extn.h
@@ -216,6 +216,7 @@
#define audio_extn_usb_get_max_channels(p) (0)
#define audio_extn_usb_get_max_bit_width(p) (0)
#define audio_extn_usb_get_sup_sample_rates(t, s, l) (0)
+#define audio_extn_usb_is_tunnel_supported() (0)
#else
void audio_extn_usb_init(void *adev);
void audio_extn_usb_deinit();
@@ -232,6 +233,7 @@
int audio_extn_usb_get_max_channels(bool playback);
int audio_extn_usb_get_max_bit_width(bool playback);
int audio_extn_usb_get_sup_sample_rates(int type, uint32_t *sr, uint32_t l);
+bool audio_extn_usb_is_tunnel_supported();
#endif
#ifndef SPLIT_A2DP_ENABLED
@@ -241,7 +243,7 @@
#define audio_extn_a2dp_set_parameters(parms) (0)
#define audio_extn_a2dp_is_force_device_switch() (0)
#define audio_extn_a2dp_set_handoff_mode(is_on) (0)
-#define audio_extn_a2dp_get_apptype_params(sample_rate,bit_width) (0)
+#define audio_extn_a2dp_get_sample_rate(sample_rate) (0)
#define audio_extn_a2dp_get_encoder_latency() (0)
#define audio_extn_a2dp_is_ready() (0)
#define audio_extn_a2dp_is_suspended() (0)
@@ -252,8 +254,7 @@
void audio_extn_a2dp_set_parameters(struct str_parms *parms);
bool audio_extn_a2dp_is_force_device_switch();
void audio_extn_a2dp_set_handoff_mode(bool is_on);
-void audio_extn_a2dp_get_apptype_params(uint32_t *sample_rate,
- uint32_t *bit_width);
+void audio_extn_a2dp_get_sample_rate(int *sample_rate);
uint32_t audio_extn_a2dp_get_encoder_latency();
bool audio_extn_a2dp_is_ready();
bool audio_extn_a2dp_is_suspended();
diff --git a/hal/audio_extn/qaf.c b/hal/audio_extn/qaf.c
old mode 100644
new mode 100755
index 37dba0a..9817563
--- a/hal/audio_extn/qaf.c
+++ b/hal/audio_extn/qaf.c
@@ -131,6 +131,7 @@
#endif
void set_hdmi_configuration_to_module();
+void set_bt_configuration_to_module();
struct qaf_adsp_hdlr_config_state {
struct audio_adsp_event event_params;
@@ -228,6 +229,7 @@
pthread_mutex_t lock;
+ bool bt_connect;
bool hdmi_connect;
int hdmi_sink_channels;
@@ -1951,8 +1953,10 @@
qaf_mod,
¬ify_event_callback,
AUDIO_DATA_EVENT_V2);
-
- set_hdmi_configuration_to_module();
+ if(p_qaf->bt_connect)
+ set_bt_configuration_to_module();
+ else
+ set_hdmi_configuration_to_module();
#ifdef AUDIO_EXTN_IP_HDLR_ENABLED
if (mod_type == MS12) {
@@ -2316,6 +2320,7 @@
*/
out->devices = val;
+#ifndef SPLIT_A2DP_ENABLED
if (val == AUDIO_DEVICE_OUT_BLUETOOTH_A2DP) {
//If device is BT then open the BT stream if not already opened.
if ( audio_extn_bt_hal_get_output_stream(qaf_mod->bt_hdl) == NULL
@@ -2334,6 +2339,7 @@
audio_extn_bt_hal_close_output_stream(qaf_mod->bt_hdl);
}
}
+#endif
if (p_qaf->passthrough_in == out) { //Device routing is received for QAF passthrough stream.
@@ -2512,6 +2518,14 @@
return ret;
}
+#ifndef LINUX_ENABLED
+//Bypass QAF for dummy PCM session opened by APM during boot time
+ if(flags == 0) {
+ ALOGD("bypassing QAF for flags is equal to none");
+ return ret;
+ }
+#endif
+
out = (struct stream_out *)*stream_out;
ret = qaf_stream_open(out, config, flags, devices);
@@ -2606,6 +2620,50 @@
return (prop_enabled);
}
+void set_bt_configuration_to_module()
+{
+ if (!p_qaf) {
+ return;
+ }
+
+ if (!p_qaf->bt_connect) {
+ DEBUG_MSG("BT is not connected.");
+ return;
+ }
+
+ struct str_parms *qaf_params;
+ char *format_params = NULL;
+
+ qaf_params = str_parms_create();
+ if (qaf_params) {
+ //ms12 wrapper don't support bt, treat this as speaker and routign to bt
+ //will take care as a part of data callback notifier
+ str_parms_add_str(qaf_params,
+ AUDIO_QAF_PARAMETER_KEY_DEVICE,
+ AUDIO_QAF_PARAMETER_VALUE_DEVICE_SPEAKER);
+
+ str_parms_add_str(qaf_params,
+ AUDIO_QAF_PARAMETER_KEY_RENDER_FORMAT,
+ AUDIO_QAF_PARAMETER_VALUE_PCM);
+ format_params = str_parms_to_str(qaf_params);
+
+ if (p_qaf->qaf_mod[MS12].session_handle && p_qaf->qaf_mod[MS12].qaf_audio_session_set_param) {
+ ALOGE(" Configuring BT/speaker for MS12 wrapper");
+ p_qaf->qaf_mod[MS12].qaf_audio_session_set_param(p_qaf->qaf_mod[MS12].session_handle,
+ format_params);
+ }
+ if (p_qaf->qaf_mod[DTS_M8].session_handle
+ && p_qaf->qaf_mod[DTS_M8].qaf_audio_session_set_param) {
+ ALOGE(" Configuring BT/speaker for MS12 wrapper");
+ p_qaf->qaf_mod[DTS_M8].qaf_audio_session_set_param(p_qaf->qaf_mod[DTS_M8].session_handle,
+ format_params);
+ }
+ }
+ str_parms_destroy(qaf_params);
+
+}
+
+
/* Query HDMI EDID and sets module output accordingly.*/
void set_hdmi_configuration_to_module()
{
@@ -2828,6 +2886,9 @@
set_hdmi_configuration_to_module();
} else if (val & AUDIO_DEVICE_OUT_BLUETOOTH_A2DP) {
+ p_qaf->bt_connect = 1;
+ set_bt_configuration_to_module();
+#ifndef SPLIT_A2DP_ENABLED
for (k = 0; k < MAX_MM_MODULE_TYPE; k++) {
if (!p_qaf->qaf_mod[k].bt_hdl) {
DEBUG_MSG("Opening a2dp output...");
@@ -2838,6 +2899,7 @@
}
}
}
+#endif
}
//TODO else if: Need to consider other devices.
}
@@ -2873,6 +2935,11 @@
str_parms_destroy(qaf_params);
close_qaf_passthrough_stream();
} else if (val & AUDIO_DEVICE_OUT_BLUETOOTH_A2DP) {
+ p_qaf->bt_connect = 0;
+ //reconfig HDMI as end device (if connected)
+ if(p_qaf->hdmi_connect)
+ set_hdmi_configuration_to_module();
+#ifndef SPLIT_A2DP_ENABLED
DEBUG_MSG("Closing a2dp output...");
for (k = 0; k < MAX_MM_MODULE_TYPE; k++) {
if (p_qaf->qaf_mod[k].bt_hdl) {
@@ -2880,6 +2947,7 @@
p_qaf->qaf_mod[k].bt_hdl = NULL;
}
}
+#endif
}
//TODO else if: Need to consider other devices.
}
diff --git a/hal/audio_extn/usb.c b/hal/audio_extn/usb.c
index 60216b1..8fa47a8 100644
--- a/hal/audio_extn/usb.c
+++ b/hal/audio_extn/usb.c
@@ -1005,6 +1005,11 @@
return usbmod->is_capture_supported;
}
+bool audio_extn_usb_is_tunnel_supported()
+{
+ return true;
+}
+
void audio_extn_usb_add_device(audio_devices_t device, int card)
{
struct usb_card_config *usb_card_info;
diff --git a/hal/audio_extn/utils.c b/hal/audio_extn/utils.c
index c7ad1a3..84416f3 100644
--- a/hal/audio_extn/utils.c
+++ b/hal/audio_extn/utils.c
@@ -737,12 +737,6 @@
sample_rate = OUTPUT_SAMPLING_RATE_DSD128;
}
- if(devices & AUDIO_DEVICE_OUT_ALL_A2DP) {
- //TODO: Handle fractional sampling rate configuration for LL
- audio_extn_a2dp_get_apptype_params(&sample_rate, &bit_width);
- ALOGI("%s using %d sampling rate %d bit width for A2DP CoPP",
- __func__, sample_rate, bit_width);
- }
ALOGV("%s: flags: %x, format: %x sample_rate %d, profile %s, app_type %d",
__func__, flags, format, sample_rate, profile, app_type_cfg->app_type);
@@ -989,6 +983,14 @@
(usecase->stream.out->sample_rate < OUTPUT_SAMPLING_RATE_44100)) {
/* Reset to default if no native stream is active*/
usecase->stream.out->app_type_cfg.sample_rate = DEFAULT_OUTPUT_SAMPLING_RATE;
+ } else if (usecase->stream.out->devices & AUDIO_DEVICE_OUT_ALL_A2DP) {
+ /*
+ * For a2dp playback get encoder sampling rate and set copp sampling rate,
+ * for bit width use the stream param only.
+ */
+ audio_extn_a2dp_get_sample_rate(&usecase->stream.out->app_type_cfg.sample_rate);
+ ALOGI("%s using %d sample rate rate for A2DP CoPP",
+ __func__, usecase->stream.out->app_type_cfg.sample_rate);
}
sample_rate = usecase->stream.out->app_type_cfg.sample_rate;
diff --git a/hal/audio_hw.c b/hal/audio_hw.c
index bbd05ee..6905a7b 100644
--- a/hal/audio_hw.c
+++ b/hal/audio_hw.c
@@ -116,6 +116,8 @@
.period_size = VOIP_IO_BUF_SIZE(DEFAULT_VOIP_SAMP_RATE, DEFAULT_VOIP_BUF_DURATION_MS, DEFAULT_VOIP_BIT_DEPTH_BYTE)/2,
.period_count = 2,
.format = PCM_FORMAT_S16_LE,
+ .avail_min = VOIP_IO_BUF_SIZE(DEFAULT_VOIP_SAMP_RATE, DEFAULT_VOIP_BUF_DURATION_MS, DEFAULT_VOIP_BIT_DEPTH_BYTE)/2,
+ .stop_threshold = INT_MAX,
};
#define MIN_CHANNEL_COUNT 1
@@ -2734,10 +2736,11 @@
ret = -errno;
}
else if (ret == -ETIMEDOUT)
- compress_drain(out->compr);
+ ret = compress_drain(out->compr);
else
ALOGE("%s: Next track returned error %d",__func__, ret);
- if (ret != -ENETRESET) {
+ if (-ENETRESET != ret && !(-EINTR == ret &&
+ CARD_STATUS_OFFLINE == out->card_status)) {
send_callback = true;
pthread_mutex_lock(&out->lock);
out->send_new_metadata = 1;
@@ -2750,10 +2753,15 @@
break;
case OFFLOAD_CMD_DRAIN:
ALOGD("copl(%p):calling compress_drain", out);
- compress_drain(out->compr);
- ALOGD("copl(%p):calling compress_drain", out);
- send_callback = true;
- event = STREAM_CBK_EVENT_DRAIN_READY;
+ ret = compress_drain(out->compr);
+ ALOGD("copl(%p):out of compress_drain", out);
+ // EINTR check avoids drain interruption due to SSR
+ if (-ENETRESET != ret && !(-EINTR == ret &&
+ CARD_STATUS_OFFLINE == out->card_status)) {
+ send_callback = true;
+ event = STREAM_CBK_EVENT_DRAIN_READY;
+ } else
+ ALOGI("%s: Block drain ready event during SSR", __func__);
break;
case OFFLOAD_CMD_ERROR:
ALOGD("copl(%p): sending error callback to AF", out);
@@ -3350,8 +3358,6 @@
{
struct stream_out *out = (struct stream_out *)stream;
struct audio_device *adev = out->dev;
- struct audio_usecase *uc_info;
- struct listnode *node;
bool do_stop = true;
ALOGD("%s: enter: stream (%p) usecase(%d: %s)", __func__,
@@ -3397,13 +3403,6 @@
if (do_stop) {
stop_output_stream(out);
}
- //restore output device for active usecase when current snd device and output device mismatch
- list_for_each(node, &adev->usecase_list) {
- uc_info = node_to_item(node, struct audio_usecase, list);
- if ((uc_info->type == PCM_PLAYBACK) &&
- (uc_info->out_snd_device != platform_get_output_snd_device(adev->platform, uc_info->stream.out)))
- select_devices(adev, uc_info->id);
- }
pthread_mutex_unlock(&adev->lock);
}
pthread_mutex_unlock(&out->lock);
@@ -3598,7 +3597,8 @@
* Avoid this by routing audio to speaker until standby.
*/
if ((out->devices & AUDIO_DEVICE_OUT_ALL_A2DP) &&
- (val == AUDIO_DEVICE_NONE)) {
+ (val == AUDIO_DEVICE_NONE) &&
+ !audio_extn_a2dp_is_ready()) {
val = AUDIO_DEVICE_OUT_SPEAKER;
}
/* To avoid a2dp to sco overlapping / BT device improper state
@@ -6260,8 +6260,8 @@
goto done;
}
platform_cache_edid(adev->platform);
- } else if ((audio_is_output_device(val) && (val & AUDIO_DEVICE_OUT_USB_DEVICE)) ||
- (audio_is_input_device(val) && ((uint32_t)val & AUDIO_DEVICE_IN_USB_DEVICE))) {
+ } else if (((audio_devices_t)val == AUDIO_DEVICE_OUT_USB_DEVICE) ||
+ ((audio_devices_t)val == AUDIO_DEVICE_IN_USB_DEVICE)) {
/*
* Do not allow AFE proxy port usage by WFD source when USB headset is connected.
* Per AudioPolicyManager, USB device is higher priority than WFD.
@@ -6276,8 +6276,10 @@
else
audio_extn_usb_add_device(AUDIO_DEVICE_IN_USB_DEVICE, atoi(value));
}
- ALOGV("detected USB connect .. disable proxy");
- adev->allow_afe_proxy_usage = false;
+ if (!audio_extn_usb_is_tunnel_supported()) {
+ ALOGV("detected USB connect .. disable proxy");
+ adev->allow_afe_proxy_usage = false;
+ }
}
}
@@ -6290,8 +6292,8 @@
* invalidated prior to updating sysfs of the disconnect event
* Invalidate will be handled by audio_extn_ext_disp_set_parameters()
*/
- if ((audio_is_output_device(val) && (val & AUDIO_DEVICE_OUT_USB_DEVICE)) ||
- (audio_is_input_device(val) && ((uint32_t)val == AUDIO_DEVICE_IN_USB_DEVICE))) {
+ if (((audio_devices_t)val == AUDIO_DEVICE_OUT_USB_DEVICE) ||
+ ((audio_devices_t)val == AUDIO_DEVICE_IN_USB_DEVICE)) {
ret = str_parms_get_str(parms, "card", value, sizeof(value));
if (ret >= 0) {
if (audio_is_output_device(val))
@@ -6299,8 +6301,10 @@
else
audio_extn_usb_remove_device(AUDIO_DEVICE_IN_USB_DEVICE, atoi(value));
}
- ALOGV("detected USB disconnect .. enable proxy");
- adev->allow_afe_proxy_usage = true;
+ if (!audio_extn_usb_is_tunnel_supported()) {
+ ALOGV("detected USB disconnect .. enable proxy");
+ adev->allow_afe_proxy_usage = true;
+ }
}
}
diff --git a/hal/msm8974/hw_info.c b/hal/msm8974/hw_info.c
old mode 100755
new mode 100644
index e3b86ac..bddaf97
--- a/hal/msm8974/hw_info.c
+++ b/hal/msm8974/hw_info.c
@@ -397,6 +397,11 @@
}
}
+static void update_hardware_info_sdx(struct hardware_info *hw_info __unused, const char *snd_card_name __unused)
+{
+ ALOGW("%s: Not a sdx device", __func__);
+}
+
static void update_hardware_info_8974(struct hardware_info *hw_info, const char *snd_card_name)
{
if (!strcmp(snd_card_name, "msm8974-taiko-mtp-snd-card")) {
@@ -553,6 +558,9 @@
} else if (strstr(snd_card_name, "sdm660") || strstr(snd_card_name, "sdm670")) {
ALOGV("Bear - variant soundcard");
update_hardware_info_bear(hw_info, snd_card_name);
+ } else if (strncmp(snd_card_name, "sdx", sizeof("sdx"))) {
+ ALOGV("SDX - variant soundcard");
+ update_hardware_info_sdx(hw_info, snd_card_name);
} else {
ALOGE("%s: Unsupported target %s:",__func__, snd_card_name);
free(hw_info);
diff --git a/hal/msm8974/platform.c b/hal/msm8974/platform.c
index 2b1b3ab..bf66355 100644
--- a/hal/msm8974/platform.c
+++ b/hal/msm8974/platform.c
@@ -1307,7 +1307,9 @@
!strncmp(snd_card_name, "apq8084-taiko-i2s-cdp-snd-card",
sizeof("apq8084-taiko-i2s-cdp-snd-card")) ||
!strncmp(snd_card_name, "apq8096-tasha-i2c-snd-card",
- sizeof("apq8096-tasha-i2c-snd-card"))) {
+ sizeof("apq8096-tasha-i2c-snd-card")) ||
+ !strncmp(snd_card_name, "sdx-tavil-i2s-snd-card",
+ sizeof("sdx-tavil-i2s-snd-card"))){
plat_data->is_i2s_ext_modem = true;
}
ALOGV("%s, is_i2s_ext_modem:%d soundcard name is %s",__func__,
@@ -2243,7 +2245,8 @@
property_get("ro.board.platform", platform, "");
property_get("ro.baseband", baseband, "");
if ((!strncmp("apq8084", platform, sizeof("apq8084")) ||
- !strncmp("msm8996", platform, sizeof("msm8996"))) &&
+ !strncmp("msm8996", platform, sizeof("msm8996")) ||
+ !strncmp("sdx", platform, sizeof("sdx"))) &&
!strncmp("mdm", baseband, (sizeof("mdm")-1))) {
my_data->csd = open_csd_client(my_data->is_i2s_ext_modem);
} else {
diff --git a/qahw/Android.mk b/qahw/Android.mk
new file mode 100644
index 0000000..c7df9e3
--- /dev/null
+++ b/qahw/Android.mk
@@ -0,0 +1,38 @@
+ifeq ($(strip $(BOARD_SUPPORTS_QAHW)),true)
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+libqahw-inc := $(LOCAL_PATH)/inc
+
+LOCAL_MODULE := libqahwwrapper
+LOCAL_MODULE_TAGS := optional
+LOCAL_C_INCLUDES := $(libqahw-inc)
+
+LOCAL_SRC_FILES := \
+ src/qahw.c \
+ src/qahw_effect.c
+
+LOCAL_SHARED_LIBRARIES := \
+ liblog \
+ libcutils \
+ libhardware \
+ libdl
+
+LOCAL_CFLAGS += -Wall -Werror
+
+LOCAL_COPY_HEADERS_TO := mm-audio/qahw/inc
+LOCAL_COPY_HEADERS := inc/qahw.h
+LOCAL_COPY_HEADERS += inc/qahw_effect_api.h
+
+LOCAL_PRELINK_MODULE := false
+
+include $(BUILD_SHARED_LIBRARY)
+
+include $(CLEAR_VARS)
+LOCAL_COPY_HEADERS_TO := mm-audio/qahw_api/inc
+LOCAL_COPY_HEADERS := inc/qahw_defs.h
+
+include $(BUILD_COPY_HEADERS)
+endif
diff --git a/qahw/Makefile.am b/qahw/Makefile.am
new file mode 100644
index 0000000..b6ebd8b
--- /dev/null
+++ b/qahw/Makefile.am
@@ -0,0 +1,20 @@
+AM_CFLAGS = -I $(top_srcdir)/inc
+
+h_sources = inc/qahw.h \
+ inc/qahw_effect_api.h
+
+qahw_include_HEADERS = $(h_sources)
+qahw_includedir = $(includedir)/mm-audio/qahw/inc
+
+qahw_api_include_HEADERS = inc/qahw_defs.h
+qahw_api_includedir = $(includedir)/mm-audio/qahw_api/inc
+
+lib_LTLIBRARIES = libqahwwrapper.la
+libqahwwrapper_la_SOURCES = src/qahw.c \
+ src/qahw_effect.c
+
+libqahwwrapper_la_CFLAGS = $(AM_CFLAGS)
+libqahwwrapper_la_CFLAGS += -include stddef.h
+libqahwwrapper_la_CFLAGS += -D__unused=__attribute__\(\(__unused__\)\)
+libqahwwrapper_la_CFLAGS += -Werror
+libqahwwrapper_la_LDFLAGS = -shared -avoid-version -llog -lcutils -lhardware
diff --git a/qahw/configure.ac b/qahw/configure.ac
new file mode 100644
index 0000000..c87447e
--- /dev/null
+++ b/qahw/configure.ac
@@ -0,0 +1,36 @@
+# -*- Autoconf -*-
+# configure.ac -- Autoconf script for halinterface
+#
+
+# Process this file with autoconf to produce a configure script.
+
+# Requires autoconf tool later than 2.61
+AC_PREREQ([2.69])
+# Initialize the audiohalwrapper-interface package version 1.0.0
+AC_INIT(audiohalwrapperinterface,1.0.0)
+# Does not strictly follow GNU Coding standards
+AM_INIT_AUTOMAKE([foreign])
+# Disables auto rebuilding of configure, Makefile.ins
+#AM_MAINTAINER_MODE
+# defines some macros variable to be included by source
+AC_CONFIG_HEADERS([config.h])
+# defines some macros variable to be included by source
+AC_CONFIG_MACRO_DIR([m4])
+
+# Checks for programs.
+AC_PROG_CC
+AM_PROG_CC_C_O
+AC_PROG_CXX
+AC_PROG_LIBTOOL
+AC_PROG_AWK
+AC_PROG_CPP
+AC_PROG_INSTALL
+AC_PROG_LN_S
+AC_PROG_MAKE_SET
+PKG_PROG_PKG_CONFIG
+
+AC_CONFIG_FILES([ \
+ Makefile
+ ])
+
+AC_OUTPUT
diff --git a/qahw/inc/qahw.h b/qahw/inc/qahw.h
new file mode 100644
index 0000000..b7088ed
--- /dev/null
+++ b/qahw/inc/qahw.h
@@ -0,0 +1,482 @@
+/*
+ * Copyright (c) 2016-2017, The Linux Foundation. All rights reserved.
+ * Not a Contribution.
+ *
+ * Copyright (C) 2011 The Android Open Source Project *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef QTI_AUDIO_QAHW_H
+#define QTI_AUDIO_QAHW_H
+
+#include <stdint.h>
+#include <strings.h>
+#include <sys/cdefs.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <cutils/bitops.h>
+#include <system/audio.h>
+#include "qahw_defs.h"
+
+__BEGIN_DECLS
+/*
+ * Helper macros for module implementors.
+ *
+ * The derived modules should provide convenience macros for supported
+ * versions so that implementations can explicitly specify module
+ * versions at definition time.
+ */
+
+#define QAHW_MAKE_API_VERSION(maj,min) \
+ ((((maj) & 0xff) << 8) | ((min) & 0xff))
+
+/* First generation of audio devices had version hardcoded to 0. all devices with
+ * versions < 1.0 will be considered of first generation API.
+ */
+#define QAHW_MODULE_API_VERSION_0_0 QAHW_MAKE_API_VERSION(0, 0)
+
+/* Minimal QTI audio HAL version supported by the audio framework */
+#define QAHW_MODULE_API_VERSION_MIN QAHW_MODULE_API_VERSION_0_0
+
+/**
+ * List of known audio HAL modules. This is the base name of the audio HAL
+ * library composed of the "audio." prefix, one of the base names below and
+ * a suffix specific to the device.
+ * e.g: audio.primary.goldfish.so or audio.a2dp.default.so
+ */
+
+#define QAHW_MODULE_ID_PRIMARY "audio.primary"
+#define QAHW_MODULE_ID_A2DP "audio.a2dp"
+#define QAHW_MODULE_ID_USB "audio.usb"
+
+typedef void qahw_module_handle_t;
+typedef void qahw_stream_handle_t;
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+/**************************************/
+/* Output stream specific APIs **/
+
+/*
+ * This method creates and opens the audio hardware output stream.
+ * The "address" parameter qualifies the "devices" audio device type if needed.
+ * The format format depends on the device type:
+ * - Bluetooth devices use the MAC address of the device in the form "00:11:22:AA:BB:CC"
+ * - USB devices use the ALSA card and device numbers in the form "card=X;device=Y"
+ * - Other devices may use a number or any other string.
+ */
+
+int qahw_open_output_stream_l(qahw_module_handle_t *hw_module,
+ audio_io_handle_t handle,
+ audio_devices_t devices,
+ audio_output_flags_t flags,
+ struct audio_config *config,
+ qahw_stream_handle_t **out_handle,
+ const char *address);
+
+int qahw_close_output_stream_l(qahw_stream_handle_t *out_handle);
+
+/*
+ * Return the sampling rate in Hz - eg. 44100.
+ */
+uint32_t qahw_out_get_sample_rate_l(const qahw_stream_handle_t *stream);
+
+/*
+ * use set_parameters with key QAHW_PARAMETER_STREAM_SAMPLING_RATE
+ */
+int qahw_out_set_sample_rate_l(qahw_stream_handle_t *stream, uint32_t rate);
+
+/*
+ * Return size of input/output buffer in bytes for this stream - eg. 4800.
+ * It should be a multiple of the frame size. See also get_input_buffer_size.
+ */
+size_t qahw_out_get_buffer_size_l(const qahw_stream_handle_t *stream);
+
+/*
+ * Return the channel mask -
+ * e.g. AUDIO_CHANNEL_OUT_STEREO or AUDIO_CHANNEL_IN_STEREO
+ */
+audio_channel_mask_t qahw_out_get_channels_l(const qahw_stream_handle_t *stream);
+
+/*
+ * Return the audio format - e.g. AUDIO_FORMAT_PCM_16_BIT
+ */
+audio_format_t qahw_out_get_format_l(const qahw_stream_handle_t *stream);
+
+/*
+ * Put the audio hardware input/output into standby mode.
+ * Driver should exit from standby mode at the next I/O operation.
+ * Returns 0 on success and <0 on failure.
+ */
+int qahw_out_standby_l(qahw_stream_handle_t *stream);
+
+/*
+ * set/get audio stream parameters. The function accepts a list of
+ * parameter key value pairs in the form: key1=value1;key2=value2;...
+ *
+ * Some keys are reserved for standard parameters (See AudioParameter class)
+ *
+ * If the implementation does not accept a parameter change while
+ * the output is active but the parameter is acceptable otherwise, it must
+ * return -ENOSYS.
+ *
+ * The audio flinger will put the stream in standby and then change the
+ * parameter value.
+ */
+int qahw_out_set_parameters_l(qahw_stream_handle_t *stream, const char*kv_pairs);
+
+/*
+ * Returns a pointer to a heap allocated string. The caller is responsible
+ * for freeing the memory for it using free().
+ */
+char* qahw_out_get_parameters_l(const qahw_stream_handle_t *stream,
+ const char *keys);
+
+/* API to set playback stream specific config parameters */
+int qahw_out_set_param_data_l(qahw_stream_handle_t *out_handle,
+ qahw_param_id param_id,
+ qahw_param_payload *payload);
+
+/* API to get playback stream specific config parameters */
+int qahw_out_get_param_data_l(qahw_stream_handle_t *out_handle,
+ qahw_param_id param_id,
+ qahw_param_payload *payload);
+
+/*
+ * Return the audio hardware driver estimated latency in milliseconds.
+ */
+uint32_t qahw_out_get_latency_l(const qahw_stream_handle_t *stream);
+
+/*
+ * Use this method in situations where audio mixing is done in the
+ * hardware. This method serves as a direct interface with hardware,
+ * allowing you to directly set the volume as apposed to via the framework.
+ * This method might produce multiple PCM outputs or hardware accelerated
+ * codecs, such as MP3 or AAC.
+ */
+int qahw_out_set_volume_l(qahw_stream_handle_t *stream, float left, float right);
+
+/*
+ * Write audio buffer present in meta_data starting from offset
+ * along with timestamp to driver. Returns number of bytes
+ * written or a negative status_t. If at least one frame was written successfully
+ * prior to the error, it is suggested that the driver return that successful
+ * (short) byte count and then return an error in the subsequent call.
+ * timestamp is only sent driver is session has been opened with timestamp flag
+ * otherwise its ignored.
+ *
+ * If set_callback() has previously been called to enable non-blocking mode
+ * the write() is not allowed to block. It must write only the number of
+ * bytes that currently fit in the driver/hardware buffer and then return
+ * this byte count. If this is less than the requested write size the
+ * callback function must be called when more space is available in the
+ * driver/hardware buffer.
+ */
+ssize_t qahw_out_write_l(qahw_stream_handle_t *stream,
+ qahw_out_buffer_t *out_buf);
+
+/*
+ * return the number of audio frames written by the audio dsp to DAC since
+ * the output has exited standby
+ */
+int qahw_out_get_render_position_l(const qahw_stream_handle_t *stream,
+ uint32_t *dsp_frames);
+
+/*
+ * set the callback function for notifying completion of non-blocking
+ * write and drain.
+ * Calling this function implies that all future rite() and drain()
+ * must be non-blocking and use the callback to signal completion.
+ */
+int qahw_out_set_callback_l(qahw_stream_handle_t *stream,
+ qahw_stream_callback_t callback,
+ void *cookie);
+
+/*
+ * Notifies to the audio driver to stop playback however the queued buffers are
+ * retained by the hardware. Useful for implementing pause/resume. Empty implementation
+ * if not supported however should be implemented for hardware with non-trivial
+ * latency. In the pause state audio hardware could still be using power. User may
+ * consider calling suspend after a timeout.
+ *
+ * Implementation of this function is mandatory for offloaded playback.
+ */
+int qahw_out_pause_l(qahw_stream_handle_t *out_handle);
+
+/*
+ * Notifies to the audio driver to resume playback following a pause.
+ * Returns error if called without matching pause.
+ *
+ * Implementation of this function is mandatory for offloaded playback.
+ */
+int qahw_out_resume_l(qahw_stream_handle_t *out_handle);
+
+/*
+ * Requests notification when data buffered by the driver/hardware has
+ * been played. If set_callback() has previously been called to enable
+ * non-blocking mode, the drain() must not block, instead it should return
+ * quickly and completion of the drain is notified through the callback.
+ * If set_callback() has not been called, the drain() must block until
+ * completion.
+ * If type==AUDIO_DRAIN_ALL, the drain completes when all previously written
+ * data has been played.
+ * If type==AUDIO_DRAIN_EARLY_NOTIFY, the drain completes shortly before all
+ * data for the current track has played to allow time for the framework
+ * to perform a gapless track switch.
+ *
+ * Drain must return immediately on stop() and flush() call
+ *
+ * Implementation of this function is mandatory for offloaded playback.
+ */
+int qahw_out_drain_l(qahw_stream_handle_t *out_handle, qahw_drain_type_t type);
+
+/*
+ * Notifies to the audio driver to flush the queued data. Stream must already
+ * be paused before calling flush().
+ *
+ * Implementation of this function is mandatory for offloaded playback.
+ */
+int qahw_out_flush_l(qahw_stream_handle_t *out_handle);
+
+/*
+ * Return a recent count of the number of audio frames presented to an external observer.
+ * This excludes frames which have been written but are still in the pipeline.
+ * The count is not reset to zero when output enters standby.
+ * Also returns the value of CLOCK_MONOTONIC as of this presentation count.
+ * The returned count is expected to be 'recent',
+ * but does not need to be the most recent possible value.
+ * However, the associated time should correspond to whatever count is returned.
+ * Example: assume that N+M frames have been presented, where M is a 'small' number.
+ * Then it is permissible to return N instead of N+M,
+ * and the timestamp should correspond to N rather than N+M.
+ * The terms 'recent' and 'small' are not defined.
+ * They reflect the quality of the implementation.
+ *
+ * 3.0 and higher only.
+ */
+int qahw_out_get_presentation_position_l(const qahw_stream_handle_t *out_handle,
+ uint64_t *frames, struct timespec *timestamp);
+
+/* Input stream specific APIs */
+
+/* This method creates and opens the audio hardware input stream */
+int qahw_open_input_stream_l(qahw_module_handle_t *hw_module,
+ audio_io_handle_t handle,
+ audio_devices_t devices,
+ struct audio_config *config,
+ qahw_stream_handle_t **stream_in,
+ audio_input_flags_t flags,
+ const char *address,
+ audio_source_t source);
+
+int qahw_close_input_stream_l(qahw_stream_handle_t *in_handle);
+
+/*
+ * Return the sampling rate in Hz - eg. 44100.
+ */
+uint32_t qahw_in_get_sample_rate_l(const qahw_stream_handle_t *in_handle);
+
+/*
+ * currently unused - use set_parameters with key
+ * QAHW_PARAMETER_STREAM_SAMPLING_RATE
+ */
+int qahw_in_set_sample_rate_l(qahw_stream_handle_t *in_handle, uint32_t rate);
+
+/*
+ * Return size of input/output buffer in bytes for this stream - eg. 4800.
+ * It should be a multiple of the frame size. See also get_input_buffer_size.
+ */
+size_t qahw_in_get_buffer_size_l(const qahw_stream_handle_t *in_handle);
+
+/*
+ * Return the channel mask -
+ * e.g. AUDIO_CHANNEL_OUT_STEREO or AUDIO_CHANNEL_IN_STEREO
+ */
+audio_channel_mask_t qahw_in_get_channels_l(const qahw_stream_handle_t *in_handle);
+
+/*
+ * Return the audio format - e.g. AUDIO_FORMAT_PCM_16_BIT
+ */
+audio_format_t qahw_in_get_format_l(const qahw_stream_handle_t *in_handle);
+
+/*
+ * currently unused - use set_parameters with key
+ * QAHW_PARAMETER_STREAM_FORMAT
+ */
+int qahw_in_set_format_l(qahw_stream_handle_t *in_handle, audio_format_t format);
+
+/*
+ * Put the audio hardware input/output into standby mode.
+ * Driver should exit from standby mode at the next I/O operation.
+ * Returns 0 on success and <0 on failure.
+ */
+int qahw_in_standby_l(qahw_stream_handle_t *in_handle);
+
+/*
+ * set/get audio stream parameters. The function accepts a list of
+ * parameter key value pairs in the form: key1=value1;key2=value2;...
+ *
+ * Some keys are reserved for standard parameters (See AudioParameter class)
+ *
+ * If the implementation does not accept a parameter change while
+ * the output is active but the parameter is acceptable otherwise, it must
+ * return -ENOSYS.
+ *
+ * The audio flinger will put the stream in standby and then change the
+ * parameter value.
+ */
+int qahw_in_set_parameters_l(qahw_stream_handle_t *in_handle, const char *kv_pairs);
+
+/*
+ * Returns a pointer to a heap allocated string. The caller is responsible
+ * for freeing the memory for it using free().
+ */
+char* qahw_in_get_parameters_l(const qahw_stream_handle_t *in_handle,
+ const char *keys);
+/*
+ * Read audio buffer in from audio driver. Returns number of bytes read, or a
+ * negative status_t. meta_data structure is filled buffer pointer, start
+ * offset and valid catpure timestamp (if session is opened with timetamp flag)
+ * and buffer. if at least one frame was read prior to the error,
+ * read should return that byte count and then return an error in the
+ * subsequent call.
+ */
+ssize_t qahw_in_read_l(qahw_stream_handle_t *in_handle,
+ qahw_in_buffer_t *in_buf);
+/*
+ * Return the amount of input frames lost in the audio driver since the
+ * last call of this function.
+ * Audio driver is expected to reset the value to 0 and restart counting
+ * upon returning the current value by this function call.
+ * Such loss typically occurs when the user space process is blocked
+ * longer than the capacity of audio driver buffers.
+ *
+ * Unit: the number of input audio frames
+ */
+uint32_t qahw_in_get_input_frames_lost_l(qahw_stream_handle_t *in_handle);
+
+/*
+ * Return a recent count of the number of audio frames received and
+ * the clock time associated with that frame count.
+ *
+ * frames is the total frame count received. This should be as early in
+ * the capture pipeline as possible. In general,
+ * frames should be non-negative and should not go "backwards".
+ *
+ * time is the clock MONOTONIC time when frames was measured. In general,
+ * time should be a positive quantity and should not go "backwards".
+ *
+ * The status returned is 0 on success, -ENOSYS if the device is not
+ * ready/available, or -EINVAL if the arguments are null or otherwise invalid.
+ */
+int qahw_in_get_capture_position_l(const qahw_stream_handle_t *in_handle,
+ int64_t *frames, int64_t *time);
+
+/* Module specific APIs */
+
+/* convenience API for opening and closing an audio HAL module */
+qahw_module_handle_t *qahw_load_module_l(const char *hw_module_id);
+
+int qahw_unload_module_l(qahw_module_handle_t *hw_module);
+
+/*
+ * check to see if the audio hardware interface has been initialized.
+ * returns 0 on success, -ENODEV on failure.
+ */
+int qahw_init_check_l(const qahw_module_handle_t *hw_module);
+
+/* set the audio volume of a voice call. Range is between 0.0 and 1.0 */
+int qahw_set_voice_volume_l(qahw_module_handle_t *hw_module, float volume);
+
+/*
+ * set_mode is called when the audio mode changes. AUDIO_MODE_NORMAL mode
+ * is for standard audio playback, AUDIO_MODE_RINGTONE when a ringtone is
+ * playing, and AUDIO_MODE_IN_CALL when a call is in progress.
+ */
+int qahw_set_mode_l(qahw_module_handle_t *hw_module, audio_mode_t mode);
+
+/* Mute/unmute mic during voice/voip/HFP call */
+int qahw_set_mic_mute_l(qahw_module_handle_t *hw_module, bool state);
+
+/* Get mute/unmute status of mic during voice call */
+int qahw_get_mic_mute_l(qahw_module_handle_t *hw_module, bool *state);
+
+/* set/get global audio parameters */
+int qahw_set_parameters_l(qahw_module_handle_t *hw_module, const char *kv_pairs);
+
+/*
+ * Returns a pointer to a heap allocated string. The caller is responsible
+ * for freeing the memory for it using free().
+ */
+char* qahw_get_parameters_l(const qahw_module_handle_t *hw_module,
+ const char *keys);
+
+/* Returns audio input buffer size according to parameters passed or
+ * 0 if one of the parameters is not supported.
+ * See also get_buffer_size which is for a particular stream.
+ */
+size_t qahw_get_input_buffer_size_l(const qahw_module_handle_t *hw_module,
+ const struct audio_config *config);
+
+/*returns current QTI HAL version */
+int qahw_get_version_l();
+
+/* Api to implement get parameters based on keyword param_id
+ * and store data in payload.
+ */
+int qahw_get_param_data_l(const qahw_module_handle_t *hw_module,
+ qahw_param_id param_id,
+ qahw_param_payload *payload);
+
+/* Api to implement set parameters based on keyword param_id
+ * and data present in payload.
+ */
+int qahw_set_param_data_l(const qahw_module_handle_t *hw_module,
+ qahw_param_id param_id,
+ qahw_param_payload *payload);
+
+/* Creates an audio patch between several source and sink ports.
+ * The handle is allocated by the HAL and should be unique for this
+ * audio HAL module.
+ */
+int qahw_create_audio_patch_l(qahw_module_handle_t *hw_module,
+ unsigned int num_sources,
+ const struct audio_port_config *sources,
+ unsigned int num_sinks,
+ const struct audio_port_config *sinks,
+ audio_patch_handle_t *handle);
+
+/* Release an audio patch */
+int qahw_release_audio_patch_l(qahw_module_handle_t *hw_module,
+ audio_patch_handle_t handle);
+/* Fills the list of supported attributes for a given audio port.
+ * As input, "port" contains the information (type, role, address etc...)
+ * needed by the HAL to identify the port.
+ * As output, "port" contains possible attributes (sampling rates, formats,
+ * channel masks, gain controllers...) for this port.
+ */
+int qahw_get_audio_port_l(qahw_module_handle_t *hw_module,
+ struct audio_port *port);
+
+/* Set audio port configuration */
+int qahw_set_audio_port_config_l(qahw_module_handle_t *hw_module,
+ const struct audio_port_config *config);
+#ifdef __cplusplus
+}
+#endif
+
+__END_DECLS
+
+#endif // QTI_AUDIO_QAHW_H
diff --git a/qahw/inc/qahw_defs.h b/qahw/inc/qahw_defs.h
new file mode 100644
index 0000000..c13a1a4
--- /dev/null
+++ b/qahw/inc/qahw_defs.h
@@ -0,0 +1,393 @@
+/*
+ * Copyright (c) 2016-2017, The Linux Foundation. All rights reserved.
+ * Not a Contribution.
+ *
+ * Copyright (C) 2011 The Android Open Source Project *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <sys/cdefs.h>
+#include <stdint.h>
+
+#ifndef QTI_AUDIO_HAL_DEFS_H
+#define QTI_AUDIO_HAL_DEFS_H
+
+__BEGIN_DECLS
+
+/**************************************/
+
+/**
+ * standard audio parameters that the HAL may need to handle
+ */
+
+/**
+ * audio device parameters
+ */
+
+/* BT SCO Noise Reduction + Echo Cancellation parameters */
+#define QAHW_PARAMETER_KEY_BT_NREC "bt_headset_nrec"
+#define QAHW_PARAMETER_VALUE_ON "on"
+#define QAHW_PARAMETER_VALUE_OFF "off"
+
+/* TTY mode selection */
+#define QAHW_PARAMETER_KEY_TTY_MODE "tty_mode"
+#define QAHW_PARAMETER_VALUE_TTY_OFF "tty_off"
+#define QAHW_PARAMETER_VALUE_TTY_VCO "tty_vco"
+#define QAHW_PARAMETER_VALUE_TTY_HCO "tty_hco"
+#define QAHW_PARAMETER_VALUE_TTY_FULL "tty_full"
+
+/* Hearing Aid Compatibility - Telecoil (HAC-T) mode on/off
+ Strings must be in sync with CallFeaturesSetting.java */
+#define QAHW_PARAMETER_KEY_HAC "HACSetting"
+#define QAHW_PARAMETER_VALUE_HAC_ON "ON"
+#define QAHW_PARAMETER_VALUE_HAC_OFF "OFF"
+
+/* A2DP sink address set by framework */
+#define QAHW_PARAMETER_A2DP_SINK_ADDRESS "a2dp_sink_address"
+
+/* A2DP source address set by framework */
+#define QAHW_PARAMETER_A2DP_SOURCE_ADDRESS "a2dp_source_address"
+
+/* Screen state */
+#define QAHW_PARAMETER_KEY_SCREEN_STATE "screen_state"
+
+/* Bluetooth SCO wideband */
+#define QAHW_PARAMETER_KEY_BT_SCO_WB "bt_wbs"
+
+/* Get a new HW synchronization source identifier.
+ * Return a valid source (positive integer) or AUDIO_HW_SYNC_INVALID if an error occurs
+ * or no HW sync is available. */
+#define QAHW_PARAMETER_HW_AV_SYNC "hw_av_sync"
+
+/**
+ * audio stream parameters
+ */
+
+#define QAHW_PARAMETER_STREAM_ROUTING "routing" /* audio_devices_t */
+#define QAHW_PARAMETER_STREAM_FORMAT "format" /* audio_format_t */
+#define QAHW_PARAMETER_STREAM_CHANNELS "channels" /* audio_channel_mask_t */
+#define QAHW_PARAMETER_STREAM_FRAME_COUNT "frame_count" /* size_t */
+#define QAHW_PARAMETER_STREAM_INPUT_SOURCE "input_source" /* audio_source_t */
+#define QAHW_PARAMETER_STREAM_SAMPLING_RATE "sampling_rate" /* uint32_t */
+
+#define QAHW_PARAMETER_DEVICE_CONNECT "connect" /* audio_devices_t */
+#define QAHW_PARAMETER_DEVICE_DISCONNECT "disconnect" /* audio_devices_t */
+
+/* Query supported formats. The response is a '|' separated list of strings from
+ * audio_format_t enum e.g: "sup_formats=AUDIO_FORMAT_PCM_16_BIT" */
+#define QAHW_PARAMETER_STREAM_SUP_FORMATS "sup_formats"
+
+/* Query supported channel masks. The response is a '|' separated list of
+ * strings from audio_channel_mask_t enum
+ * e.g: "sup_channels=AUDIO_CHANNEL_OUT_STEREO|AUDIO_CHANNEL_OUT_MONO" */
+#define QAHW_PARAMETER_STREAM_SUP_CHANNELS "sup_channels"
+
+/* Query supported sampling rates. The response is a '|' separated list of
+ * integer values e.g: "sup_sampling_rates=44100|48000" */
+#define QAHW_PARAMETER_STREAM_SUP_SAMPLING_RATES "sup_sampling_rates"
+
+/* Set the HW synchronization source for an output stream. */
+#define QAHW_PARAMETER_STREAM_HW_AV_SYNC "hw_av_sync"
+
+/* Enable mono audio playback if 1, else should be 0. */
+#define QAHW_PARAMETER_MONO_OUTPUT "mono_output"
+
+/**
+ * audio codec parameters
+ */
+
+#define QAHW_OFFLOAD_CODEC_PARAMS "music_offload_codec_param"
+#define QAHW_OFFLOAD_CODEC_BIT_PER_SAMPLE "music_offload_bit_per_sample"
+#define QAHW_OFFLOAD_CODEC_BIT_RATE "music_offload_bit_rate"
+#define QAHW_OFFLOAD_CODEC_AVG_BIT_RATE "music_offload_avg_bit_rate"
+#define QAHW_OFFLOAD_CODEC_ID "music_offload_codec_id"
+#define QAHW_OFFLOAD_CODEC_BLOCK_ALIGN "music_offload_block_align"
+#define QAHW_OFFLOAD_CODEC_SAMPLE_RATE "music_offload_sample_rate"
+#define QAHW_OFFLOAD_CODEC_ENCODE_OPTION "music_offload_encode_option"
+#define QAHW_OFFLOAD_CODEC_NUM_CHANNEL "music_offload_num_channels"
+#define QAHW_OFFLOAD_CODEC_DOWN_SAMPLING "music_offload_down_sampling"
+#define QAHW_OFFLOAD_CODEC_DELAY_SAMPLES "delay_samples"
+#define QAHW_OFFLOAD_CODEC_PADDING_SAMPLES "padding_samples"
+
+/**
+ * extended audio codec parameters
+ */
+
+#define QAHW_OFFLOAD_CODEC_WMA_FORMAT_TAG "music_offload_wma_format_tag"
+#define QAHW_OFFLOAD_CODEC_WMA_BLOCK_ALIGN "music_offload_wma_block_align"
+#define QAHW_OFFLOAD_CODEC_WMA_BIT_PER_SAMPLE "music_offload_wma_bit_per_sample"
+#define QAHW_OFFLOAD_CODEC_WMA_CHANNEL_MASK "music_offload_wma_channel_mask"
+#define QAHW_OFFLOAD_CODEC_WMA_ENCODE_OPTION "music_offload_wma_encode_option"
+#define QAHW_OFFLOAD_CODEC_WMA_ENCODE_OPTION1 "music_offload_wma_encode_option1"
+#define QAHW_OFFLOAD_CODEC_WMA_ENCODE_OPTION2 "music_offload_wma_encode_option2"
+
+#define QAHW_OFFLOAD_CODEC_FLAC_MIN_BLK_SIZE "music_offload_flac_min_blk_size"
+#define QAHW_OFFLOAD_CODEC_FLAC_MAX_BLK_SIZE "music_offload_flac_max_blk_size"
+#define QAHW_OFFLOAD_CODEC_FLAC_MIN_FRAME_SIZE "music_offload_flac_min_frame_size"
+#define QAHW_OFFLOAD_CODEC_FLAC_MAX_FRAME_SIZE "music_offload_flac_max_frame_size"
+
+#define QAHW_OFFLOAD_CODEC_ALAC_FRAME_LENGTH "music_offload_alac_frame_length"
+#define QAHW_OFFLOAD_CODEC_ALAC_COMPATIBLE_VERSION "music_offload_alac_compatible_version"
+#define QAHW_OFFLOAD_CODEC_ALAC_BIT_DEPTH "music_offload_alac_bit_depth"
+#define QAHW_OFFLOAD_CODEC_ALAC_PB "music_offload_alac_pb"
+#define QAHW_OFFLOAD_CODEC_ALAC_MB "music_offload_alac_mb"
+#define QAHW_OFFLOAD_CODEC_ALAC_KB "music_offload_alac_kb"
+#define QAHW_OFFLOAD_CODEC_ALAC_NUM_CHANNELS "music_offload_alac_num_channels"
+#define QAHW_OFFLOAD_CODEC_ALAC_MAX_RUN "music_offload_alac_max_run"
+#define QAHW_OFFLOAD_CODEC_ALAC_MAX_FRAME_BYTES "music_offload_alac_max_frame_bytes"
+#define QAHW_OFFLOAD_CODEC_ALAC_AVG_BIT_RATE "music_offload_alac_avg_bit_rate"
+#define QAHW_OFFLOAD_CODEC_ALAC_SAMPLING_RATE "music_offload_alac_sampling_rate"
+#define QAHW_OFFLOAD_CODEC_ALAC_CHANNEL_LAYOUT_TAG "music_offload_alac_channel_layout_tag"
+
+#define QAHW_OFFLOAD_CODEC_APE_COMPATIBLE_VERSION "music_offload_ape_compatible_version"
+#define QAHW_OFFLOAD_CODEC_APE_COMPRESSION_LEVEL "music_offload_ape_compression_level"
+#define QAHW_OFFLOAD_CODEC_APE_FORMAT_FLAGS "music_offload_ape_format_flags"
+#define QAHW_OFFLOAD_CODEC_APE_BLOCKS_PER_FRAME "music_offload_ape_blocks_per_frame"
+#define QAHW_OFFLOAD_CODEC_APE_FINAL_FRAME_BLOCKS "music_offload_ape_final_frame_blocks"
+#define QAHW_OFFLOAD_CODEC_APE_TOTAL_FRAMES "music_offload_ape_total_frames"
+#define QAHW_OFFLOAD_CODEC_APE_BITS_PER_SAMPLE "music_offload_ape_bits_per_sample"
+#define QAHW_OFFLOAD_CODEC_APE_NUM_CHANNELS "music_offload_ape_num_channels"
+#define QAHW_OFFLOAD_CODEC_APE_SAMPLE_RATE "music_offload_ape_sample_rate"
+#define QAHW_OFFLOAD_CODEC_APE_SEEK_TABLE_PRESENT "music_offload_seek_table_present"
+
+#define QAHW_OFFLOAD_CODEC_VORBIS_BITSTREAM_FMT "music_offload_vorbis_bitstream_fmt"
+
+/* Set or Query stream profile type */
+#define QAHW_PARAMETER_STREAM_PROFILE "audio_stream_profile"
+
+/* audio input flags for compress and timestamp mode.
+ * check other input flags defined in audio.h for conflicts
+ */
+#define QAHW_INPUT_FLAG_TIMESTAMP 0x80000000
+#define QAHW_INPUT_FLAG_COMPRESS 0x40000000
+
+/* Query fm volume */
+#define QAHW_PARAMETER_KEY_FM_VOLUME "fm_volume"
+
+/* Query if a2dp is supported */
+#define QAHW_PARAMETER_KEY_HANDLE_A2DP_DEVICE "isA2dpDeviceSupported"
+
+#define MAX_OUT_CHANNELS 8
+#define MAX_INP_CHANNELS 8
+
+#define QAHW_PCM_CHANNEL_FL 1 /* Front left channel. */
+#define QAHW_PCM_CHANNEL_FR 2 /* Front right channel. */
+#define QAHW_PCM_CHANNEL_FC 3 /* Front center channel. */
+#define QAHW_PCM_CHANNEL_LS 4 /* Left surround channel. */
+#define QAHW_PCM_CHANNEL_RS 5 /* Right surround channel. */
+#define QAHW_PCM_CHANNEL_LFE 6 /* Low frequency effect channel. */
+#define QAHW_PCM_CHANNEL_CS 7 /* Center surround channel; Rear center channel. */
+#define QAHW_PCM_CHANNEL_LB 8 /* Left back channel; Rear left channel. */
+#define QAHW_PCM_CHANNEL_RB 9 /* Right back channel; Rear right channel. */
+#define QAHW_PCM_CHANNEL_TS 10 /* Top surround channel. */
+#define QAHW_PCM_CHANNEL_CVH 11 /* Center vertical height channel. */
+#define QAHW_PCM_CHANNEL_MS 12 /* Mono surround channel. */
+#define QAHW_PCM_CHANNEL_FLC 13 /* Front left of center. */
+#define QAHW_PCM_CHANNEL_FRC 14 /* Front right of center. */
+#define QAHW_PCM_CHANNEL_RLC 15 /* Rear left of center. */
+#define QAHW_PCM_CHANNEL_RRC 16 /* Rear right of center. */
+
+/* type of asynchronous write callback events. Mutually exclusive */
+typedef enum {
+ QAHW_STREAM_CBK_EVENT_WRITE_READY, /* non blocking write completed */
+ QAHW_STREAM_CBK_EVENT_DRAIN_READY, /* drain completed */
+ QAHW_STREAM_CBK_EVENT_ERROR, /* stream hit some error */
+
+ QAHW_STREAM_CBK_EVENT_ADSP = 0x100 /* callback event from ADSP PP,
+ * corresponding payload will be
+ * sent as is to the client
+ */
+} qahw_stream_callback_event_t;
+
+typedef int qahw_stream_callback_t(qahw_stream_callback_event_t event,
+ void *param,
+ void *cookie);
+
+/* type of drain requested to audio_stream_out->drain(). Mutually exclusive */
+typedef enum {
+ QAHW_DRAIN_ALL, /* drain() returns when all data has been played */
+ QAHW_DRAIN_EARLY_NOTIFY /* drain() returns a short time before all data
+ from the current track has been played to
+ give time for gapless track switch */
+} qahw_drain_type_t;
+
+/* meta data flags */
+/*TBD: Extend this based on stb requirement*/
+typedef enum {
+ QAHW_META_DATA_FLAGS_NONE = 0,
+} qahw_meta_data_flags_t;
+
+typedef struct {
+ const void *buffer; /* write buffer pointer */
+ size_t bytes; /* size of buffer */
+ size_t offset; /* offset in buffer from where valid byte starts */
+ int64_t *timestamp; /* timestmap */
+ qahw_meta_data_flags_t flags; /* meta data flags */
+ uint32_t reserved[64]; /*reserved for future */
+} qahw_out_buffer_t;
+
+typedef struct {
+ void *buffer; /* read buffer pointer */
+ size_t bytes; /* size of buffer */
+ size_t offset; /* offset in buffer from where valid byte starts */
+ int64_t *timestamp; /* timestmap */
+ uint32_t reserved[64]; /*reserved for future */
+} qahw_in_buffer_t;
+
+#define MAX_SECTORS 8
+
+struct qahw_source_tracking_param {
+ uint8_t vad[MAX_SECTORS];
+ uint16_t doa_speech;
+ uint16_t doa_noise[3];
+ uint8_t polar_activity[360];
+};
+
+struct qahw_sound_focus_param {
+ uint16_t start_angle[MAX_SECTORS];
+ uint8_t enable[MAX_SECTORS];
+ uint16_t gain_step;
+};
+
+struct aptx_dec_bt_addr {
+ uint32_t nap;
+ uint32_t uap;
+ uint32_t lap;
+};
+
+struct qahw_aptx_dec_param {
+ struct aptx_dec_bt_addr bt_addr;
+};
+
+struct qahw_avt_device_drift_param {
+ /* Flag to indicate if resync is required on the client side for
+ * drift correction. Flag is set to TRUE for the first get_param response
+ * after device interface starts. This flag value can be used by client
+ * to identify if device interface restart has happened and if any
+ * re-sync is required at their end for drift correction.
+ */
+ uint32_t resync_flag;
+ /* Accumulated drift value in microseconds.
+ * Positive drift value indicates AV timer is running faster than device.
+ * Negative drift value indicates AV timer is running slower than device.
+ */
+ int32_t avt_device_drift_value;
+ /* 64-bit absolute timestamp of reference */
+ uint64_t ref_timer_abs_ts;
+};
+
+/*use these for setting infine window.i.e free run mode */
+#define QAHW_MAX_RENDER_START_WINDOW 0x8000000000000000
+#define QAHW_MAX_RENDER_END_WINDOW 0x7FFFFFFFFFFFFFFF
+
+struct qahw_out_render_window_param {
+ uint64_t render_ws; /* render window start value microseconds*/
+ uint64_t render_we; /* render window end value microseconds*/
+};
+
+struct qahw_out_start_delay_param {
+ uint64_t start_delay; /* session start delay in microseconds*/
+};
+
+struct qahw_out_enable_drift_correction {
+ bool enable; /* enable drift correction*/
+};
+
+struct qahw_out_correct_drift {
+ /*
+ * adjust time in microseconds, a positive value
+ * to advance the clock or a negative value to
+ * delay the clock.
+ */
+ int64_t adjust_time;
+};
+
+#define QAHW_MAX_ADSP_STREAM_CMD_PAYLOAD_LEN 512
+
+typedef enum {
+ QAHW_STREAM_PP_EVENT = 0,
+ QAHW_STREAM_ENCDEC_EVENT = 1,
+} qahw_event_id;
+
+/* payload format for HAL parameter
+ * QAHW_PARAM_ADSP_STREAM_CMD
+ */
+struct qahw_adsp_event {
+ qahw_event_id event_type; /* type of the event */
+ uint32_t payload_length; /* length in bytes of the payload */
+ void *payload; /* the actual payload */
+};
+
+struct qahw_out_channel_map_param {
+ uint8_t channels; /* Input Channels */
+ uint8_t channel_map[AUDIO_CHANNEL_COUNT_MAX]; /* Input Channel Map */
+};
+
+struct qahw_device_cfg_param {
+ uint32_t sample_rate;
+ uint32_t channels;
+ uint32_t bit_width;
+ audio_format_t format;
+ audio_devices_t device;
+ uint8_t channel_map[AUDIO_CHANNEL_COUNT_MAX];
+ uint16_t channel_allocation;
+};
+
+typedef struct qahw_mix_matrix_params {
+ uint16_t num_output_channels;
+ uint16_t num_input_channels;
+ uint8_t has_output_channel_map;
+ uint32_t output_channel_map[AUDIO_CHANNEL_COUNT_MAX];
+ uint8_t has_input_channel_map;
+ uint32_t input_channel_map[AUDIO_CHANNEL_COUNT_MAX];
+ uint8_t has_mixer_coeffs;
+ float mixer_coeffs[AUDIO_CHANNEL_COUNT_MAX][AUDIO_CHANNEL_COUNT_MAX];
+} qahw_mix_matrix_params_t;
+
+typedef union {
+ struct qahw_source_tracking_param st_params;
+ struct qahw_sound_focus_param sf_params;
+ struct qahw_aptx_dec_param aptx_params;
+ struct qahw_avt_device_drift_param drift_params;
+ struct qahw_out_render_window_param render_window_params;
+ struct qahw_out_start_delay_param start_delay;
+ struct qahw_out_enable_drift_correction drift_enable_param;
+ struct qahw_out_correct_drift drift_correction_param;
+ struct qahw_adsp_event adsp_event_params;
+ struct qahw_out_channel_map_param channel_map_params;
+ struct qahw_device_cfg_param device_cfg_params;
+ struct qahw_mix_matrix_params mix_matrix_params;
+} qahw_param_payload;
+
+typedef enum {
+ QAHW_PARAM_SOURCE_TRACK,
+ QAHW_PARAM_SOUND_FOCUS,
+ QAHW_PARAM_APTX_DEC,
+ QAHW_PARAM_AVT_DEVICE_DRIFT, /* PARAM to query AV timer vs device drift */
+ QAHW_PARAM_OUT_RENDER_WINDOW, /* PARAM to set render window */
+ QAHW_PARAM_OUT_START_DELAY, /* PARAM to set session start delay*/
+ /* enable adsp drift correction this must be called before out_write */
+ QAHW_PARAM_OUT_ENABLE_DRIFT_CORRECTION,
+ /* param to set drift value to be adjusted by dsp */
+ QAHW_PARAM_OUT_CORRECT_DRIFT,
+ QAHW_PARAM_ADSP_STREAM_CMD,
+ QAHW_PARAM_OUT_CHANNEL_MAP, /* PARAM to set i/p channel map */
+ QAHW_PARAM_DEVICE_CONFIG, /* PARAM to set device config */
+ QAHW_PARAM_OUT_MIX_MATRIX_PARAMS,
+ QAHW_PARAM_CH_MIX_MATRIX_PARAMS,
+} qahw_param_id;
+
+__END_DECLS
+
+#endif // QTI_AUDIO_HAL_DEFS_H
+
diff --git a/qahw_api/inc/qahw_effect_api.h b/qahw/inc/qahw_effect_api.h
similarity index 99%
rename from qahw_api/inc/qahw_effect_api.h
rename to qahw/inc/qahw_effect_api.h
index 5b380b1..de53cd3 100644
--- a/qahw_api/inc/qahw_effect_api.h
+++ b/qahw/inc/qahw_effect_api.h
@@ -31,7 +31,7 @@
#include <system/audio.h>
-#include "qahw_api.h"
+#include "qahw.h"
__BEGIN_DECLS
diff --git a/qahw_api/src/qahw.c b/qahw/src/qahw.c
similarity index 87%
rename from qahw_api/src/qahw.c
rename to qahw/src/qahw.c
index b5a85d7..91fc5bf 100644
--- a/qahw_api/src/qahw.c
+++ b/qahw/src/qahw.c
@@ -37,7 +37,7 @@
#include <cutils/list.h>
#include <hardware/audio.h>
-#include "qahw_api.h"
+#include "qahw.h"
#define NO_ERROR 0
#define MAX_MODULE_NAME_LENGTH 100
@@ -119,7 +119,7 @@
/******************************************************************************/
/* call this function without anylock held */
-static bool is_valid_qahw_stream(void *qahw_stream,
+static bool is_valid_qahw_stream_l(void *qahw_stream,
qahw_stream_direction_t dir)
{
@@ -174,7 +174,7 @@
}
/* call this fucntion with ahw_module_init_lock held*/
-static qahw_module_t* get_qahw_module_by_ptr(qahw_module_t *qahw_module)
+static qahw_module_t* get_qahw_module_by_ptr_l(qahw_module_t *qahw_module)
{
struct listnode *node = NULL;
qahw_module_t *module = NULL, *module_temp = NULL;
@@ -194,7 +194,7 @@
}
/* call this function with qahw_module_init_lock held*/
-static qahw_module_t* get_qahw_module_by_name(const char *qahw_name)
+static qahw_module_t* get_qahw_module_by_name_l(const char *qahw_name)
{
struct listnode *node = NULL;
qahw_module_t *module = NULL, *module_temp = NULL;
@@ -217,13 +217,13 @@
/*
* Return the sampling rate in Hz - eg. 44100.
*/
-uint32_t qahw_out_get_sample_rate(const qahw_stream_handle_t *out_handle)
+uint32_t qahw_out_get_sample_rate_l(const qahw_stream_handle_t *out_handle)
{
uint32_t rate = 0;
qahw_stream_out_t *qahw_stream_out = (qahw_stream_out_t *)out_handle;
audio_stream_out_t *out = NULL;
- if (!is_valid_qahw_stream((void *)qahw_stream_out, STREAM_DIR_OUT)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_out, STREAM_DIR_OUT)) {
ALOGV("%s::Invalid out handle %p", __func__, out_handle);
goto exit;
}
@@ -244,13 +244,13 @@
* currently unused - use set_parameters with key
* AUDIO_PARAMETER_STREAM_SAMPLING_RATE
*/
-int qahw_out_set_sample_rate(qahw_stream_handle_t *out_handle, uint32_t rate)
+int qahw_out_set_sample_rate_l(qahw_stream_handle_t *out_handle, uint32_t rate)
{
int32_t rc = -EINVAL;
qahw_stream_out_t *qahw_stream_out = (qahw_stream_out_t *)out_handle;
audio_stream_out_t *out = NULL;
- if (!is_valid_qahw_stream((void *)qahw_stream_out, STREAM_DIR_OUT)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_out, STREAM_DIR_OUT)) {
ALOGE("%s::Invalid out handle %p", __func__, out_handle);
goto exit;
}
@@ -267,13 +267,13 @@
return rc;
}
-size_t qahw_out_get_buffer_size(const qahw_stream_handle_t *out_handle)
+size_t qahw_out_get_buffer_size_l(const qahw_stream_handle_t *out_handle)
{
size_t buf_size = 0;
qahw_stream_out_t *qahw_stream_out = (qahw_stream_out_t *)out_handle;
audio_stream_out_t *out = NULL;
- if (!is_valid_qahw_stream((void *)qahw_stream_out, STREAM_DIR_OUT)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_out, STREAM_DIR_OUT)) {
ALOGE("%s::Invalid out handle %p", __func__, out_handle);
goto exit;
}
@@ -290,13 +290,13 @@
return buf_size;
}
-audio_channel_mask_t qahw_out_get_channels(const qahw_stream_handle_t *out_handle)
+audio_channel_mask_t qahw_out_get_channels_l(const qahw_stream_handle_t *out_handle)
{
audio_channel_mask_t ch_mask = 0;
qahw_stream_out_t *qahw_stream_out = (qahw_stream_out_t *)out_handle;
audio_stream_out_t *out = NULL;
- if (!is_valid_qahw_stream((void *)qahw_stream_out, STREAM_DIR_OUT)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_out, STREAM_DIR_OUT)) {
ALOGE("%s::Invalid out handle %p", __func__, out_handle);
goto exit;
}
@@ -313,13 +313,13 @@
return ch_mask;
}
-audio_format_t qahw_out_get_format(const qahw_stream_handle_t *out_handle)
+audio_format_t qahw_out_get_format_l(const qahw_stream_handle_t *out_handle)
{
audio_format_t format = AUDIO_FORMAT_INVALID;
qahw_stream_out_t *qahw_stream_out = (qahw_stream_out_t *)out_handle;
audio_stream_out_t *out = NULL;
- if (!is_valid_qahw_stream((void *)qahw_stream_out, STREAM_DIR_OUT)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_out, STREAM_DIR_OUT)) {
ALOGE("%s::Invalid out handle %p", __func__, out_handle);
goto exit;
}
@@ -336,13 +336,13 @@
return format;
}
-int qahw_out_standby(qahw_stream_handle_t *out_handle)
+int qahw_out_standby_l(qahw_stream_handle_t *out_handle)
{
int32_t rc = -EINVAL;
qahw_stream_out_t *qahw_stream_out = (qahw_stream_out_t *)out_handle;
audio_stream_out_t *out = NULL;
- if (!is_valid_qahw_stream((void *)qahw_stream_out, STREAM_DIR_OUT)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_out, STREAM_DIR_OUT)) {
ALOGE("%s::Invalid out handle %p", __func__, out_handle);
goto exit;
}
@@ -361,13 +361,13 @@
return rc;
}
-int qahw_out_set_parameters(qahw_stream_handle_t *out_handle, const char *kv_pairs)
+int qahw_out_set_parameters_l(qahw_stream_handle_t *out_handle, const char *kv_pairs)
{
int rc = NO_ERROR;
qahw_stream_out_t *qahw_stream_out = (qahw_stream_out_t *)out_handle;
audio_stream_out_t *out = NULL;
- if (!is_valid_qahw_stream((void *)qahw_stream_out, STREAM_DIR_OUT)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_out, STREAM_DIR_OUT)) {
ALOGE("%s::Invalid out handle %p", __func__, out_handle);
rc = -EINVAL;
goto exit;
@@ -387,14 +387,14 @@
return rc;
}
-char *qahw_out_get_parameters(const qahw_stream_handle_t *out_handle,
+char *qahw_out_get_parameters_l(const qahw_stream_handle_t *out_handle,
const char *keys)
{
char *str_param = NULL;
qahw_stream_out_t *qahw_stream_out = (qahw_stream_out_t *)out_handle;
audio_stream_out_t *out = NULL;
- if (!is_valid_qahw_stream((void *)qahw_stream_out, STREAM_DIR_OUT)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_out, STREAM_DIR_OUT)) {
ALOGE("%s::Invalid out handle %p", __func__, out_handle);
goto exit;
}
@@ -413,7 +413,7 @@
}
/* API to get playback stream specific config parameters */
-int qahw_out_set_param_data(qahw_stream_handle_t *out_handle,
+int qahw_out_set_param_data_l(qahw_stream_handle_t *out_handle,
qahw_param_id param_id,
qahw_param_payload *payload)
{
@@ -426,7 +426,7 @@
goto exit;
}
- if (!is_valid_qahw_stream((void *)qahw_stream_out, STREAM_DIR_OUT)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_out, STREAM_DIR_OUT)) {
ALOGE("%s::Invalid out handle %p", __func__, out_handle);
goto exit;
}
@@ -446,7 +446,7 @@
}
/* API to get playback stream specific config parameters */
-int qahw_out_get_param_data(qahw_stream_handle_t *out_handle,
+int qahw_out_get_param_data_l(qahw_stream_handle_t *out_handle,
qahw_param_id param_id,
qahw_param_payload *payload)
{
@@ -454,7 +454,7 @@
qahw_stream_out_t *qahw_stream_out = (qahw_stream_out_t *)out_handle;
audio_stream_out_t *out = NULL;
- if (!is_valid_qahw_stream((void *)qahw_stream_out, STREAM_DIR_OUT)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_out, STREAM_DIR_OUT)) {
ALOGE("%s::Invalid out handle %p", __func__, out_handle);
goto exit;
}
@@ -473,13 +473,13 @@
return rc;
}
-uint32_t qahw_out_get_latency(const qahw_stream_handle_t *out_handle)
+uint32_t qahw_out_get_latency_l(const qahw_stream_handle_t *out_handle)
{
uint32_t latency = 0;
qahw_stream_out_t *qahw_stream_out = (qahw_stream_out_t *)out_handle;
audio_stream_out_t *out = NULL;
- if (!is_valid_qahw_stream((void *)qahw_stream_out, STREAM_DIR_OUT)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_out, STREAM_DIR_OUT)) {
ALOGE("%s::Invalid out handle %p", __func__, out_handle);
goto exit;
}
@@ -497,13 +497,13 @@
return latency;
}
-int qahw_out_set_volume(qahw_stream_handle_t *out_handle, float left, float right)
+int qahw_out_set_volume_l(qahw_stream_handle_t *out_handle, float left, float right)
{
int rc = -EINVAL;
qahw_stream_out_t *qahw_stream_out = (qahw_stream_out_t *)out_handle;
audio_stream_out_t *out = NULL;
- if (!is_valid_qahw_stream((void *)qahw_stream_out, STREAM_DIR_OUT)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_out, STREAM_DIR_OUT)) {
ALOGE("%s::Invalid out handle %p", __func__, out_handle);
goto exit;
}
@@ -522,7 +522,7 @@
return rc;
}
-ssize_t qahw_out_write(qahw_stream_handle_t *out_handle,
+ssize_t qahw_out_write_l(qahw_stream_handle_t *out_handle,
qahw_out_buffer_t *out_buf)
{
int rc = -EINVAL;
@@ -534,7 +534,7 @@
goto exit;
}
- if (!is_valid_qahw_stream((void *)qahw_stream_out, STREAM_DIR_OUT)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_out, STREAM_DIR_OUT)) {
ALOGE("%s::Invalid out handle %p", __func__, out_handle);
goto exit;
}
@@ -557,14 +557,14 @@
return rc;
}
-int qahw_out_get_render_position(const qahw_stream_handle_t *out_handle,
+int qahw_out_get_render_position_l(const qahw_stream_handle_t *out_handle,
uint32_t *dsp_frames)
{
int rc = -EINVAL;
qahw_stream_out_t *qahw_stream_out = (qahw_stream_out_t *)out_handle;
audio_stream_out_t *out = NULL;
- if (!is_valid_qahw_stream((void *)qahw_stream_out, STREAM_DIR_OUT)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_out, STREAM_DIR_OUT)) {
ALOGE("%s::Invalid out handle %p", __func__, out_handle);
goto exit;
}
@@ -582,7 +582,7 @@
return rc;
}
-int qahw_out_set_callback(qahw_stream_handle_t *out_handle,
+int qahw_out_set_callback_l(qahw_stream_handle_t *out_handle,
qahw_stream_callback_t callback,
void *cookie)
{
@@ -591,7 +591,7 @@
qahw_stream_out_t *qahw_stream_out = (qahw_stream_out_t *)out_handle;
audio_stream_out_t *out = NULL;
- if (!is_valid_qahw_stream((void *)qahw_stream_out, STREAM_DIR_OUT)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_out, STREAM_DIR_OUT)) {
ALOGE("%s::Invalid out handle %p", __func__, out_handle);
goto exit;
}
@@ -610,14 +610,14 @@
return rc;
}
-int qahw_out_pause(qahw_stream_handle_t *out_handle)
+int qahw_out_pause_l(qahw_stream_handle_t *out_handle)
{
/*TBD:load hal func pointer and call */
int rc = -EINVAL;
qahw_stream_out_t *qahw_stream_out = (qahw_stream_out_t *)out_handle;
audio_stream_out_t *out = NULL;
- if (!is_valid_qahw_stream((void *)qahw_stream_out, STREAM_DIR_OUT)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_out, STREAM_DIR_OUT)) {
ALOGE("%s::Invalid out handle %p", __func__, out_handle);
goto exit;
}
@@ -636,14 +636,14 @@
return rc;
}
-int qahw_out_resume(qahw_stream_handle_t *out_handle)
+int qahw_out_resume_l(qahw_stream_handle_t *out_handle)
{
/*TBD:load hal func pointer and call */
int rc = -EINVAL;
qahw_stream_out_t *qahw_stream_out = (qahw_stream_out_t *)out_handle;
audio_stream_out_t *out = NULL;
- if (!is_valid_qahw_stream((void *)qahw_stream_out, STREAM_DIR_OUT)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_out, STREAM_DIR_OUT)) {
ALOGE("%s::Invalid out handle %p", __func__, out_handle);
goto exit;
}
@@ -662,14 +662,14 @@
return rc;
}
-int qahw_out_drain(qahw_stream_handle_t *out_handle, qahw_drain_type_t type )
+int qahw_out_drain_l(qahw_stream_handle_t *out_handle, qahw_drain_type_t type )
{
/*TBD:load hal func pointer and call */
int rc = -EINVAL;
qahw_stream_out_t *qahw_stream_out = (qahw_stream_out_t *)out_handle;
audio_stream_out_t *out = NULL;
- if (!is_valid_qahw_stream((void *)qahw_stream_out, STREAM_DIR_OUT)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_out, STREAM_DIR_OUT)) {
ALOGE("%s::Invalid out handle %p", __func__, out_handle);
goto exit;
}
@@ -688,13 +688,13 @@
return rc;
}
-int qahw_out_flush(qahw_stream_handle_t *out_handle)
+int qahw_out_flush_l(qahw_stream_handle_t *out_handle)
{
int rc = -EINVAL;
qahw_stream_out_t *qahw_stream_out = (qahw_stream_out_t *)out_handle;
audio_stream_out_t *out = NULL;
- if (!is_valid_qahw_stream((void *)qahw_stream_out, STREAM_DIR_OUT)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_out, STREAM_DIR_OUT)) {
ALOGE("%s::Invalid out handle %p", __func__, out_handle);
goto exit;
}
@@ -713,14 +713,14 @@
return rc;
}
-int qahw_out_get_presentation_position(const qahw_stream_handle_t *out_handle,
+int qahw_out_get_presentation_position_l(const qahw_stream_handle_t *out_handle,
uint64_t *frames, struct timespec *timestamp)
{
int rc = -EINVAL;
qahw_stream_out_t *qahw_stream_out = (qahw_stream_out_t *)out_handle;
audio_stream_out_t *out = NULL;
- if (!is_valid_qahw_stream((void *)qahw_stream_out, STREAM_DIR_OUT)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_out, STREAM_DIR_OUT)) {
ALOGE("%s::Invalid out handle %p", __func__, out_handle);
goto exit;
}
@@ -740,13 +740,13 @@
}
/* Input stream specific APIs */
-uint32_t qahw_in_get_sample_rate(const qahw_stream_handle_t *in_handle)
+uint32_t qahw_in_get_sample_rate_l(const qahw_stream_handle_t *in_handle)
{
uint32_t rate = 0;
qahw_stream_in_t *qahw_stream_in = (qahw_stream_in_t *)in_handle;
audio_stream_in_t *in = NULL;
- if (!is_valid_qahw_stream((void *)qahw_stream_in, STREAM_DIR_IN)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_in, STREAM_DIR_IN)) {
ALOGV("%s::Invalid in handle %p", __func__, in_handle);
goto exit;
}
@@ -768,13 +768,13 @@
* currently unused - use set_parameters with key
* AUDIO_PARAMETER_STREAM_SAMPLING_RATE
*/
-int qahw_in_set_sample_rate(qahw_stream_handle_t *in_handle, uint32_t rate)
+int qahw_in_set_sample_rate_l(qahw_stream_handle_t *in_handle, uint32_t rate)
{
int rc = -EINVAL;
qahw_stream_in_t *qahw_stream_in = (qahw_stream_in_t *)in_handle;
audio_stream_in_t *in = NULL;
- if (!is_valid_qahw_stream((void *)qahw_stream_in, STREAM_DIR_IN)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_in, STREAM_DIR_IN)) {
ALOGV("%s::Invalid in handle %p", __func__, in_handle);
goto exit;
}
@@ -793,13 +793,13 @@
return rc;
}
-size_t qahw_in_get_buffer_size(const qahw_stream_handle_t *in_handle)
+size_t qahw_in_get_buffer_size_l(const qahw_stream_handle_t *in_handle)
{
size_t buf_size = 0;
qahw_stream_in_t *qahw_stream_in = (qahw_stream_in_t *)in_handle;
audio_stream_in_t *in = NULL;
- if (!is_valid_qahw_stream((void *)qahw_stream_in, STREAM_DIR_IN)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_in, STREAM_DIR_IN)) {
ALOGV("%s::Invalid in handle %p", __func__, in_handle);
goto exit;
}
@@ -818,13 +818,13 @@
}
-audio_channel_mask_t qahw_in_get_channels(const qahw_stream_handle_t *in_handle)
+audio_channel_mask_t qahw_in_get_channels_l(const qahw_stream_handle_t *in_handle)
{
audio_channel_mask_t ch_mask = 0;;
qahw_stream_in_t *qahw_stream_in = (qahw_stream_in_t *)in_handle;
audio_stream_in_t *in = NULL;
- if (!is_valid_qahw_stream((void *)qahw_stream_in, STREAM_DIR_IN)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_in, STREAM_DIR_IN)) {
ALOGV("%s::Invalid in handle %p", __func__, in_handle);
goto exit;
}
@@ -842,13 +842,13 @@
return ch_mask;
}
-audio_format_t qahw_in_get_format(const qahw_stream_handle_t *in_handle)
+audio_format_t qahw_in_get_format_l(const qahw_stream_handle_t *in_handle)
{
audio_format_t format = AUDIO_FORMAT_INVALID;
qahw_stream_in_t *qahw_stream_in = (qahw_stream_in_t *)in_handle;
audio_stream_in_t *in = NULL;
- if (!is_valid_qahw_stream((void *)qahw_stream_in, STREAM_DIR_IN)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_in, STREAM_DIR_IN)) {
ALOGV("%s::Invalid in handle %p", __func__, in_handle);
goto exit;
}
@@ -870,13 +870,13 @@
* currently unused - use set_parameters with key
* AUDIO_PARAMETER_STREAM_FORMAT
*/
-int qahw_in_set_format(qahw_stream_handle_t *in_handle, audio_format_t format)
+int qahw_in_set_format_l(qahw_stream_handle_t *in_handle, audio_format_t format)
{
int rc = -EINVAL;
qahw_stream_in_t *qahw_stream_in = (qahw_stream_in_t *)in_handle;
audio_stream_in_t *in = NULL;
- if (!is_valid_qahw_stream((void *)qahw_stream_in, STREAM_DIR_IN)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_in, STREAM_DIR_IN)) {
ALOGV("%s::Invalid in handle %p", __func__, in_handle);
goto exit;
}
@@ -895,13 +895,13 @@
return rc;
}
-int qahw_in_standby(qahw_stream_handle_t *in_handle)
+int qahw_in_standby_l(qahw_stream_handle_t *in_handle)
{
int rc = -EINVAL;
qahw_stream_in_t *qahw_stream_in = (qahw_stream_in_t *)in_handle;
audio_stream_in_t *in = NULL;
- if (!is_valid_qahw_stream((void *)qahw_stream_in, STREAM_DIR_IN)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_in, STREAM_DIR_IN)) {
ALOGV("%s::Invalid in handle %p", __func__, in_handle);
goto exit;
}
@@ -933,13 +933,13 @@
* The audio flinger will put the stream in standby and then change the
* parameter value.
*/
-int qahw_in_set_parameters(qahw_stream_handle_t *in_handle, const char *kv_pairs)
+int qahw_in_set_parameters_l(qahw_stream_handle_t *in_handle, const char *kv_pairs)
{
int rc = -EINVAL;
qahw_stream_in_t *qahw_stream_in = (qahw_stream_in_t *)in_handle;
audio_stream_in_t *in = NULL;
- if (!is_valid_qahw_stream((void *)qahw_stream_in, STREAM_DIR_IN)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_in, STREAM_DIR_IN)) {
ALOGV("%s::Invalid in handle %p", __func__, in_handle);
goto exit;
}
@@ -961,14 +961,14 @@
* Returns a pointer to a heap allocated string. The caller is responsible
* for freeing the memory for it using free().
*/
-char * qahw_in_get_parameters(const qahw_stream_handle_t *in_handle,
+char * qahw_in_get_parameters_l(const qahw_stream_handle_t *in_handle,
const char *keys)
{
char *str_param = NULL;
qahw_stream_in_t *qahw_stream_in = (qahw_stream_in_t *)in_handle;
audio_stream_in_t *in = NULL;
- if (!is_valid_qahw_stream((void *)qahw_stream_in, STREAM_DIR_IN)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_in, STREAM_DIR_IN)) {
ALOGV("%s::Invalid in handle %p", __func__, in_handle);
goto exit;
}
@@ -991,7 +991,7 @@
* negative status_t. If at least one frame was read prior to the error,
* read should return that byte count and then return an error in the subsequent call.
*/
-ssize_t qahw_in_read(qahw_stream_handle_t *in_handle,
+ssize_t qahw_in_read_l(qahw_stream_handle_t *in_handle,
qahw_in_buffer_t *in_buf)
{
int rc = -EINVAL;
@@ -1003,7 +1003,7 @@
goto exit;
}
- if (!is_valid_qahw_stream((void *)qahw_stream_in, STREAM_DIR_IN)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_in, STREAM_DIR_IN)) {
ALOGV("%s::Invalid in handle %p", __func__, in_handle);
goto exit;
}
@@ -1037,13 +1037,13 @@
*
* Unit: the number of input audio frames
*/
-uint32_t qahw_in_get_input_frames_lost(qahw_stream_handle_t *in_handle)
+uint32_t qahw_in_get_input_frames_lost_l(qahw_stream_handle_t *in_handle)
{
uint32_t rc = 0;
qahw_stream_in_t *qahw_stream_in = (qahw_stream_in_t *)in_handle;
audio_stream_in_t *in = NULL;
- if (!is_valid_qahw_stream((void *)qahw_stream_in, STREAM_DIR_IN)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_in, STREAM_DIR_IN)) {
ALOGV("%s::Invalid in handle %p", __func__, in_handle);
goto exit;
}
@@ -1076,7 +1076,7 @@
* The status returned is 0 on success, -ENOSYS if the device is not
* ready/available, or -EINVAL if the arguments are null or otherwise invalid.
*/
-int qahw_in_get_capture_position(const qahw_stream_handle_t *in_handle __unused,
+int qahw_in_get_capture_position_l(const qahw_stream_handle_t *in_handle __unused,
int64_t *frames __unused, int64_t *time __unused)
{
/*TBD:: do we need this*/
@@ -1087,14 +1087,14 @@
* check to see if the audio hardware interface has been initialized.
* returns 0 on success, -ENODEV on failure.
*/
-int qahw_init_check(const qahw_module_handle_t *hw_module)
+int qahw_init_check_l(const qahw_module_handle_t *hw_module)
{
int rc = -EINVAL;
qahw_module_t *qahw_module = (qahw_module_t *)hw_module;
qahw_module_t *qahw_module_temp;
pthread_mutex_lock(&qahw_module_init_lock);
- qahw_module_temp = get_qahw_module_by_ptr(qahw_module);
+ qahw_module_temp = get_qahw_module_by_ptr_l(qahw_module);
pthread_mutex_unlock(&qahw_module_init_lock);
if (qahw_module_temp == NULL) {
ALOGE("%s:: invalid hw module %p", __func__, qahw_module);
@@ -1114,14 +1114,14 @@
return rc;
}
/* set the audio volume of a voice call. Range is between 0.0 and 1.0 */
-int qahw_set_voice_volume(qahw_module_handle_t *hw_module, float volume)
+int qahw_set_voice_volume_l(qahw_module_handle_t *hw_module, float volume)
{
int rc = -EINVAL;
qahw_module_t *qahw_module = (qahw_module_t *)hw_module;
qahw_module_t *qahw_module_temp;
pthread_mutex_lock(&qahw_module_init_lock);
- qahw_module_temp = get_qahw_module_by_ptr(qahw_module);
+ qahw_module_temp = get_qahw_module_by_ptr_l(qahw_module);
pthread_mutex_unlock(&qahw_module_init_lock);
if (qahw_module_temp == NULL) {
ALOGE("%s:: invalid hw module %p", __func__, qahw_module);
@@ -1147,14 +1147,14 @@
* is for standard audio playback, AUDIO_MODE_RINGTONE when a ringtone is
* playing, and AUDIO_MODE_IN_CALL when a call is in progress.
*/
-int qahw_set_mode(qahw_module_handle_t *hw_module, audio_mode_t mode)
+int qahw_set_mode_l(qahw_module_handle_t *hw_module, audio_mode_t mode)
{
int rc = -EINVAL;
qahw_module_t *qahw_module = (qahw_module_t *)hw_module;
qahw_module_t *qahw_module_temp;
pthread_mutex_lock(&qahw_module_init_lock);
- qahw_module_temp = get_qahw_module_by_ptr(qahw_module);
+ qahw_module_temp = get_qahw_module_by_ptr_l(qahw_module);
pthread_mutex_unlock(&qahw_module_init_lock);
if (qahw_module_temp == NULL) {
ALOGE("%s:: invalid hw module %p", __func__, qahw_module);
@@ -1175,14 +1175,14 @@
return rc;
}
-int qahw_set_mic_mute(qahw_module_handle_t *hw_module, bool state)
+int qahw_set_mic_mute_l(qahw_module_handle_t *hw_module, bool state)
{
int rc = -EINVAL;
qahw_module_t *qahw_module = (qahw_module_t *)hw_module;
qahw_module_t *qahw_module_temp;
pthread_mutex_lock(&qahw_module_init_lock);
- qahw_module_temp = get_qahw_module_by_ptr(qahw_module);
+ qahw_module_temp = get_qahw_module_by_ptr_l(qahw_module);
pthread_mutex_unlock(&qahw_module_init_lock);
if (qahw_module_temp == NULL) {
ALOGE("%s:: invalid hw module %p", __func__, qahw_module);
@@ -1203,7 +1203,7 @@
return rc;
}
-int qahw_get_mic_mute(qahw_module_handle_t *hw_module, bool *state)
+int qahw_get_mic_mute_l(qahw_module_handle_t *hw_module, bool *state)
{
size_t rc = 0;
qahw_module_t *qahw_module = (qahw_module_t *)hw_module;
@@ -1211,7 +1211,7 @@
audio_hw_device_t *audio_device;
pthread_mutex_lock(&qahw_module_init_lock);
- qahw_module_temp = get_qahw_module_by_ptr(qahw_module);
+ qahw_module_temp = get_qahw_module_by_ptr_l(qahw_module);
pthread_mutex_unlock(&qahw_module_init_lock);
if (qahw_module_temp == NULL) {
ALOGE("%s:: invalid hw module %p", __func__, qahw_module);
@@ -1233,7 +1233,7 @@
}
/* set/get global audio parameters */
-int qahw_set_parameters(qahw_module_handle_t *hw_module, const char *kv_pairs)
+int qahw_set_parameters_l(qahw_module_handle_t *hw_module, const char *kv_pairs)
{
int rc = -EINVAL;
qahw_module_t *qahw_module = (qahw_module_t *)hw_module;
@@ -1241,7 +1241,7 @@
audio_hw_device_t *audio_device;
pthread_mutex_lock(&qahw_module_init_lock);
- qahw_module_temp = get_qahw_module_by_ptr(qahw_module);
+ qahw_module_temp = get_qahw_module_by_ptr_l(qahw_module);
pthread_mutex_unlock(&qahw_module_init_lock);
if (qahw_module_temp == NULL) {
ALOGE("%s:: invalid hw module %p", __func__, qahw_module);
@@ -1266,7 +1266,7 @@
* Returns a pointer to a heap allocated string. The caller is responsible
* for freeing the memory for it using free().
*/
-char * qahw_get_parameters(const qahw_module_handle_t *hw_module,
+char * qahw_get_parameters_l(const qahw_module_handle_t *hw_module,
const char *keys)
{
char *str_param = NULL;
@@ -1275,7 +1275,7 @@
audio_hw_device_t *audio_device;
pthread_mutex_lock(&qahw_module_init_lock);
- qahw_module_temp = get_qahw_module_by_ptr(qahw_module);
+ qahw_module_temp = get_qahw_module_by_ptr_l(qahw_module);
pthread_mutex_unlock(&qahw_module_init_lock);
if (qahw_module_temp == NULL) {
ALOGE("%s:: invalid hw module %p", __func__, qahw_module);
@@ -1298,7 +1298,7 @@
/* Api to implement get parameters based on keyword param_id
* and store data in payload.
*/
-int qahw_get_param_data(const qahw_module_handle_t *hw_module,
+int qahw_get_param_data_l(const qahw_module_handle_t *hw_module,
qahw_param_id param_id,
qahw_param_payload *payload)
{
@@ -1307,7 +1307,7 @@
qahw_module_t *qahw_module_temp;
pthread_mutex_lock(&qahw_module_init_lock);
- qahw_module_temp = get_qahw_module_by_ptr(qahw_module);
+ qahw_module_temp = get_qahw_module_by_ptr_l(qahw_module);
pthread_mutex_unlock(&qahw_module_init_lock);
if (qahw_module_temp == NULL) {
ALOGE("%s:: invalid hw module %p", __func__, qahw_module);
@@ -1332,7 +1332,7 @@
/* Api to implement set parameters based on keyword param_id
* and data present in payload.
*/
-int qahw_set_param_data(const qahw_module_handle_t *hw_module,
+int qahw_set_param_data_l(const qahw_module_handle_t *hw_module,
qahw_param_id param_id,
qahw_param_payload *payload)
{
@@ -1341,7 +1341,7 @@
qahw_module_t *qahw_module_temp;
pthread_mutex_lock(&qahw_module_init_lock);
- qahw_module_temp = get_qahw_module_by_ptr(qahw_module);
+ qahw_module_temp = get_qahw_module_by_ptr_l(qahw_module);
pthread_mutex_unlock(&qahw_module_init_lock);
if (qahw_module_temp == NULL) {
ALOGE("%s:: invalid hw module %p", __func__, qahw_module);
@@ -1367,7 +1367,7 @@
* The handle is allocated by the HAL and should be unique for this
* audio HAL module.
*/
-int qahw_create_audio_patch(qahw_module_handle_t *hw_module,
+int qahw_create_audio_patch_l(qahw_module_handle_t *hw_module,
unsigned int num_sources,
const struct audio_port_config *sources,
unsigned int num_sinks,
@@ -1379,7 +1379,7 @@
qahw_module_t *qahw_module_temp;
pthread_mutex_lock(&qahw_module_init_lock);
- qahw_module_temp = get_qahw_module_by_ptr(qahw_module);
+ qahw_module_temp = get_qahw_module_by_ptr_l(qahw_module);
pthread_mutex_unlock(&qahw_module_init_lock);
if (qahw_module_temp == NULL) {
ALOGE("%s:: invalid hw module %p", __func__, qahw_module);
@@ -1406,7 +1406,7 @@
}
/* Release an audio patch */
-int qahw_release_audio_patch(qahw_module_handle_t *hw_module,
+int qahw_release_audio_patch_l(qahw_module_handle_t *hw_module,
audio_patch_handle_t handle)
{
int ret = 0;
@@ -1414,7 +1414,7 @@
qahw_module_t *qahw_module_temp;
pthread_mutex_lock(&qahw_module_init_lock);
- qahw_module_temp = get_qahw_module_by_ptr(qahw_module);
+ qahw_module_temp = get_qahw_module_by_ptr_l(qahw_module);
pthread_mutex_unlock(&qahw_module_init_lock);
if (qahw_module_temp == NULL) {
ALOGE("%s:: invalid hw module %p", __func__, qahw_module);
@@ -1442,7 +1442,7 @@
* As output, "port" contains possible attributes (sampling rates, formats,
* channel masks, gain controllers...) for this port.
*/
-int qahw_get_audio_port(qahw_module_handle_t *hw_module,
+int qahw_get_audio_port_l(qahw_module_handle_t *hw_module,
struct audio_port *port)
{
int ret = 0;
@@ -1450,7 +1450,7 @@
qahw_module_t *qahw_module_temp;
pthread_mutex_lock(&qahw_module_init_lock);
- qahw_module_temp = get_qahw_module_by_ptr(qahw_module);
+ qahw_module_temp = get_qahw_module_by_ptr_l(qahw_module);
pthread_mutex_unlock(&qahw_module_init_lock);
if (qahw_module_temp == NULL) {
ALOGE("%s:: invalid hw module %p", __func__, qahw_module);
@@ -1473,7 +1473,7 @@
}
/* Set audio port configuration */
-int qahw_set_audio_port_config(qahw_module_handle_t *hw_module,
+int qahw_set_audio_port_config_l(qahw_module_handle_t *hw_module,
const struct audio_port_config *config)
{
int ret = 0;
@@ -1481,7 +1481,7 @@
qahw_module_t *qahw_module_temp;
pthread_mutex_lock(&qahw_module_init_lock);
- qahw_module_temp = get_qahw_module_by_ptr(qahw_module);
+ qahw_module_temp = get_qahw_module_by_ptr_l(qahw_module);
pthread_mutex_unlock(&qahw_module_init_lock);
if (qahw_module_temp == NULL) {
ALOGE("%s:: invalid hw module %p", __func__, qahw_module);
@@ -1507,7 +1507,7 @@
* 0 if one of the parameters is not supported.
* See also get_buffer_size which is for a particular stream.
*/
-size_t qahw_get_input_buffer_size(const qahw_module_handle_t *hw_module,
+size_t qahw_get_input_buffer_size_l(const qahw_module_handle_t *hw_module,
const struct audio_config *config)
{
size_t rc = 0;
@@ -1516,7 +1516,7 @@
audio_hw_device_t *audio_device;
pthread_mutex_lock(&qahw_module_init_lock);
- qahw_module_temp = get_qahw_module_by_ptr(qahw_module);
+ qahw_module_temp = get_qahw_module_by_ptr_l(qahw_module);
pthread_mutex_unlock(&qahw_module_init_lock);
if (qahw_module_temp == NULL) {
ALOGE("%s:: invalid hw module %p", __func__, qahw_module);
@@ -1546,7 +1546,7 @@
* - USB devices use the ALSA card and device numbers in the form "card=X;device=Y"
* - Other devices may use a number or any other string.
*/
-int qahw_open_output_stream(qahw_module_handle_t *hw_module,
+int qahw_open_output_stream_l(qahw_module_handle_t *hw_module,
audio_io_handle_t handle,
audio_devices_t devices,
audio_output_flags_t flags,
@@ -1561,7 +1561,7 @@
qahw_stream_out_t *qahw_stream_out = NULL;
pthread_mutex_lock(&qahw_module_init_lock);
- qahw_module_temp = get_qahw_module_by_ptr(qahw_module);
+ qahw_module_temp = get_qahw_module_by_ptr_l(qahw_module);
pthread_mutex_unlock(&qahw_module_init_lock);
if (qahw_module_temp == NULL) {
ALOGE("%s:: invalid hw module %p", __func__, qahw_module);
@@ -1634,7 +1634,7 @@
return rc;
}
-int qahw_close_output_stream(qahw_stream_handle_t *out_handle)
+int qahw_close_output_stream_l(qahw_stream_handle_t *out_handle)
{
int rc = 0;
@@ -1642,7 +1642,7 @@
qahw_module_t *qahw_module = NULL;
audio_hw_device_t *audio_device = NULL;
- if (!is_valid_qahw_stream((void *)qahw_stream_out, STREAM_DIR_OUT)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_out, STREAM_DIR_OUT)) {
ALOGE("%s::Invalid out handle %p", __func__, out_handle);
rc = -EINVAL;
goto exit;
@@ -1669,7 +1669,7 @@
}
/* This method creates and opens the audio hardware input stream */
-int qahw_open_input_stream(qahw_module_handle_t *hw_module,
+int qahw_open_input_stream_l(qahw_module_handle_t *hw_module,
audio_io_handle_t handle,
audio_devices_t devices,
struct audio_config *config,
@@ -1685,7 +1685,7 @@
qahw_stream_in_t *qahw_stream_in = NULL;
pthread_mutex_lock(&qahw_module_init_lock);
- qahw_module_temp = get_qahw_module_by_ptr(qahw_module);
+ qahw_module_temp = get_qahw_module_by_ptr_l(qahw_module);
pthread_mutex_unlock(&qahw_module_init_lock);
if (qahw_module_temp == NULL) {
ALOGE("%s:: invalid hw module %p", __func__, qahw_module);
@@ -1738,14 +1738,14 @@
return rc;
}
-int qahw_close_input_stream(qahw_stream_handle_t *in_handle)
+int qahw_close_input_stream_l(qahw_stream_handle_t *in_handle)
{
int rc = 0;
qahw_stream_in_t *qahw_stream_in = (qahw_stream_in_t *)in_handle;
qahw_module_t *qahw_module = NULL;
audio_hw_device_t *audio_device = NULL;
- if (!is_valid_qahw_stream((void *)qahw_stream_in, STREAM_DIR_IN)) {
+ if (!is_valid_qahw_stream_l((void *)qahw_stream_in, STREAM_DIR_IN)) {
ALOGV("%s::Invalid in handle %p", __func__, in_handle);
rc = -EINVAL;
goto exit;
@@ -1772,13 +1772,13 @@
}
/*returns current QTI HAL verison */
-int qahw_get_version() {
+int qahw_get_version_l() {
return QAHW_MODULE_API_VERSION_CURRENT;
}
/* convenience API for opening and closing an audio HAL module */
-qahw_module_handle_t *qahw_load_module(const char *hw_module_id)
+qahw_module_handle_t *qahw_load_module_l(const char *hw_module_id)
{
int rc = -EINVAL;
qahw_module_handle_t *qahw_mod_handle = NULL;
@@ -1806,7 +1806,7 @@
/* return exiting module ptr if already loaded */
pthread_mutex_lock(&qahw_module_init_lock);
if (qahw_list_count > 0) {
- qahw_module = get_qahw_module_by_name(hw_module_id);
+ qahw_module = get_qahw_module_by_name_l(hw_module_id);
if(qahw_module != NULL) {
qahw_mod_handle = (void *)qahw_module;
pthread_mutex_lock(&qahw_module->lock);
@@ -1876,7 +1876,7 @@
return qahw_mod_handle;
}
-int qahw_unload_module(qahw_module_handle_t *hw_module)
+int qahw_unload_module_l(qahw_module_handle_t *hw_module)
{
int rc = -EINVAL;
bool is_empty = false;
@@ -1887,7 +1887,7 @@
* it is closed
*/
pthread_mutex_lock(&qahw_module_init_lock);
- qahw_module_temp = get_qahw_module_by_ptr(qahw_module);
+ qahw_module_temp = get_qahw_module_by_ptr_l(qahw_module);
if (qahw_module_temp == NULL) {
ALOGE("%s:: invalid hw module %p", __func__, qahw_module);
goto error_exit;
diff --git a/qahw_api/src/qahw_effect.c b/qahw/src/qahw_effect.c
similarity index 100%
rename from qahw_api/src/qahw_effect.c
rename to qahw/src/qahw_effect.c
diff --git a/qahw_api/Android.mk b/qahw_api/Android.mk
index ee06a30..ba402ba 100644
--- a/qahw_api/Android.mk
+++ b/qahw_api/Android.mk
@@ -4,28 +4,27 @@
include $(CLEAR_VARS)
-libqahw-inc := $(LOCAL_PATH)/inc
+libqahwapi-inc := $(LOCAL_PATH)/inc
LOCAL_MODULE := libqahw
LOCAL_MODULE_TAGS := optional
-LOCAL_C_INCLUDES := $(libqahw-inc)
+LOCAL_C_INCLUDES := $(libqahwapi-inc)
+LOCAL_C_INCLUDES += $(TARGET_OUT_HEADERS)/mm-audio/qahw/inc
LOCAL_SRC_FILES := \
- src/qahw.c \
- src/qahw_effect.c
+ src/qahw_api.cpp
LOCAL_SHARED_LIBRARIES := \
liblog \
libcutils \
libhardware \
- libdl
+ libdl \
+ libqahwwrapper
LOCAL_CFLAGS += -Wall -Werror
LOCAL_COPY_HEADERS_TO := mm-audio/qahw_api/inc
LOCAL_COPY_HEADERS := inc/qahw_api.h
-LOCAL_COPY_HEADERS += inc/qahw_defs.h
-LOCAL_COPY_HEADERS += inc/qahw_effect_api.h
LOCAL_COPY_HEADERS += inc/qahw_effect_audiosphere.h
LOCAL_COPY_HEADERS += inc/qahw_effect_bassboost.h
LOCAL_COPY_HEADERS += inc/qahw_effect_environmentalreverb.h
@@ -40,4 +39,5 @@
#test app compilation
include $(LOCAL_PATH)/test/Android.mk
+
endif
diff --git a/qahw_api/Makefile.am b/qahw_api/Makefile.am
index 7c74d25..13fe417 100644
--- a/qahw_api/Makefile.am
+++ b/qahw_api/Makefile.am
@@ -1,8 +1,4 @@
-AM_CFLAGS = -I $(top_srcdir)/qahw_api/inc
-
h_sources = inc/qahw_api.h \
- inc/qahw_defs.h \
- inc/qahw_effect_api.h \
inc/qahw_effect_audiosphere.h \
inc/qahw_effect_bassboost.h \
inc/qahw_effect_environmentalreverb.h \
@@ -11,15 +7,22 @@
inc/qahw_effect_virtualizer.h \
inc/qahw_effect_visualizer.h
+AM_CPPFLAGS := -I $(top_srcdir)/qahw_api/inc/
+AM_CPPFLAGS += -I $(PKG_CONFIG_SYSROOT_DIR)/usr/include/mm-audio/audio-hal-server
+AM_CPPFLAGS += -I $(PKG_CONFIG_SYSROOT_DIR)/usr/include/mm-audio/qahw/inc
+AM_CPPFLAGS += -D__unused=__attribute__\(\(__unused__\)\)
+
library_include_HEADERS = $(h_sources)
library_includedir = $(includedir)/mm-audio/qahw_api/inc
-lib_LTLIBRARIES = libqahw.la
-libqahw_la_SOURCES = src/qahw.c \
- src/qahw_effect.c
-libqahw_la_CFLAGS = -Dstrlcpy=g_strlcpy $(GLIB_CFLAGS) -include glib.h $(AM_CFLAGS) -include stddef.h
-libqahw_la_CFLAGS += -D__unused=__attribute__\(\(__unused__\)\)
-libqahw_la_CFLAGS += -Wno-sign-compare -Werror
-libqahw_la_CFLAGS += -Dstrlcat=g_strlcat -Dstrlcpy=g_strlcpy -include glib.h $(GLIB_CFLAGS)
-libqahw_la_LIBADD = $(GLIB_LIBS) -llog -lcutils -lhardware -ldl
-libqahw_la_LDFLAGS = -module -shared -avoid-version
+lib_LTLIBRARIES = libqahw.la
+libqahw_la_SOURCES = src/qahw_api.cpp
+libqahw_la_LIBADD = -lqahwwrapper
+libqahw_la_CPPFLAGS := $(AM_CPPFLAGS)
+libqahw_la_CPPFLAGS += -std=c++11 -DHAVE_PTHREADS -DHAVE_ANDROID_OS
+libqahw_la_CPPFLAGS += -DDEBUG_REFS_CALLSTACK_ENABLED=0
+libqahw_la_LDFLAGS = -ltinyalsa -lhardware -lexpat -lcutils -llog -ldl -lbinder -shared -avoid-version -llog -lcutils -lpthread -lutils
+if QTI_AUDIO_SERVER_ENABLED
+AM_CPPFLAGS += -DQTI_AUDIO_SERVER_ENABLED
+libqahw_la_LDFLAGS += -lqtiaudioserver
+endif
diff --git a/qahw_api/inc/qahw_api.h b/qahw_api/inc/qahw_api.h
index 5e0e661..0aa3c79 100644
--- a/qahw_api/inc/qahw_api.h
+++ b/qahw_api/inc/qahw_api.h
@@ -16,8 +16,8 @@
* limitations under the License.
*/
-#ifndef QTI_AUDIO_HAL_API_H
-#define QTI_AUDIO_HAL_API_H
+#ifndef QTI_AUDIO_QAHW_API_H
+#define QTI_AUDIO_QAHW_API_H
#include <stdint.h>
#include <strings.h>
@@ -61,6 +61,7 @@
typedef void qahw_module_handle_t;
typedef void qahw_stream_handle_t;
+typedef void (*audio_error_callback)(void* context);
/**************************************/
/* Output stream specific APIs **/
@@ -471,6 +472,8 @@
int qahw_set_audio_port_config(qahw_module_handle_t *hw_module,
const struct audio_port_config *config);
+void qahw_register_qas_death_notify_cb(audio_error_callback cb, void* context);
+
__END_DECLS
-#endif // QTI_AUDIO_HAL_API_H
+#endif // QTI_AUDIO_QAHW_API_H
diff --git a/qahw_api/src/qahw_api.cpp b/qahw_api/src/qahw_api.cpp
new file mode 100644
index 0000000..8967bd6
--- /dev/null
+++ b/qahw_api/src/qahw_api.cpp
@@ -0,0 +1,1626 @@
+/*
+* Copyright (c) 2016-2017, The Linux Foundation. All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are
+* met:
+* * Redistributions of source code must retain the above copyright
+* notice, this list of conditions and the following disclaimer.
+* * Redistributions in binary form must reproduce the above
+* copyright notice, this list of conditions and the following
+* disclaimer in the documentation and/or other materials provided
+* with the distribution.
+* * Neither the name of The Linux Foundation nor the names of its
+* contributors may be used to endorse or promote products derived
+* from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#define LOG_TAG "qahw_api"
+#define LOG_NDEBUG 0
+#define LOG_NDDEBUG 0
+
+#include <utils/Errors.h>
+#include <dlfcn.h>
+#include <utils/Log.h>
+#include <stdlib.h>
+#include <cutils/list.h>
+#include <assert.h>
+
+#include <hardware/audio.h>
+#include <cutils/properties.h>
+#include "qahw_api.h"
+#include "qahw.h"
+
+#if QTI_AUDIO_SERVER_ENABLED
+#include <mm-audio/qti-audio-server/qti_audio_server.h>
+#include <mm-audio/qti-audio-server/qti_audio_server_client.h>
+
+using namespace audiohal;
+extern struct listnode stream_list;
+extern pthread_mutex_t list_lock;
+
+/* Flag to indicate if QAS is enabled or not */
+bool g_binder_enabled = false;
+/* QTI audio server handle */
+sp<Iqti_audio_server> g_qas = NULL;
+/* Handle for client context*/
+void* g_ctxt = NULL;
+/* Death notification handle */
+sp<death_notifier> g_death_notifier = NULL;
+/* Client callback handle */
+audio_error_callback g_audio_err_cb = NULL;
+/* Flag to indicate qas status */
+bool g_qas_died = false;
+/* Count how many times hal is loaded */
+static unsigned int g_qas_load_count;
+/* Store HAL handle */
+qahw_module_handle_t *g_qas_handle = NULL;
+
+void death_notifier::binderDied(const wp<IBinder>& who)
+{
+ struct listnode *node;
+ p_stream_handle *handle;
+
+ if (g_audio_err_cb) {
+ ALOGD("%s %d", __func__, __LINE__);
+ g_audio_err_cb(g_ctxt);
+ }
+ g_qas_died = true;
+
+ pthread_mutex_lock(&list_lock);
+ list_for_each(node, &stream_list) {
+ handle = node_to_item(node, p_stream_handle, list);
+ if (handle != NULL) {
+ sh_mem_data *shmem_data = handle->shmem_data;
+ ALOGD("%s: %d: signal to unblock any wait conditions", __func__, __LINE__);
+ pthread_cond_signal(&shmem_data->c_cond);
+ shmem_data->status = 0;
+ }
+ }
+ pthread_mutex_unlock(&list_lock);
+
+}
+
+void qahw_register_qas_death_notify_cb(audio_error_callback cb, void* context)
+{
+ ALOGD("%s %d", __func__, __LINE__);
+ g_audio_err_cb = cb;
+ g_ctxt = context;
+}
+
+death_notifier::death_notifier()
+{
+ ALOGV("%s %d", __func__, __LINE__);
+ sp<ProcessState> proc(ProcessState::self());
+ proc->startThreadPool();
+}
+
+sp<Iqti_audio_server> get_qti_audio_server() {
+ sp<IServiceManager> sm;
+ sp<IBinder> binder;
+ int retry_cnt = 5;
+
+ if (g_qas == 0) {
+ sm = defaultServiceManager();
+ if (sm != NULL) {
+ do {
+ binder = sm->getService(String16(QTI_AUDIO_SERVER));
+ if (binder != 0)
+ break;
+ else
+ ALOGE("%d:%s: get qas service failed",__LINE__, __func__);
+
+ ALOGW("qti_audio_server not published, waiting...");
+ usleep(500000);
+ } while (--retry_cnt);
+ } else {
+ ALOGE("%d:%s: defaultServiceManager failed",__LINE__, __func__);
+ }
+ if (binder == NULL)
+ return NULL;
+
+ if (g_death_notifier == NULL) {
+ g_death_notifier = new death_notifier();
+ if (g_death_notifier == NULL) {
+ ALOGE("%d: %s() unable to allocate death notifier", __LINE__, __func__);
+ return NULL;
+ }
+ }
+ binder->linkToDeath(g_death_notifier);
+ g_qas = interface_cast<Iqti_audio_server>(binder);
+ assert(g_qas != 0);
+ }
+ return g_qas;
+}
+
+uint32_t qahw_out_get_sample_rate(const qahw_stream_handle_t *out_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_out_get_sample_rate(out_handle);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_out_get_sample_rate_l(out_handle);
+ }
+}
+
+int qahw_out_set_sample_rate(qahw_stream_handle_t *out_handle, uint32_t rate)
+{
+ ALOGV("%d:%s %d",__LINE__, __func__, rate);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_out_set_sample_rate(out_handle, rate);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_out_set_sample_rate_l(out_handle, rate);
+ }
+}
+
+size_t qahw_out_get_buffer_size(const qahw_stream_handle_t *out_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_out_get_buffer_size(out_handle);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_out_get_buffer_size_l(out_handle);
+ }
+}
+
+audio_channel_mask_t qahw_out_get_channels(const qahw_stream_handle_t
+ *out_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return (audio_channel_mask_t)(-ENODEV);
+ }
+ return qas->qahw_out_get_channels(out_handle);
+ } else {
+ return (audio_channel_mask_t)(-ENODEV);
+ }
+ } else {
+ return qahw_out_get_channels_l(out_handle);
+ }
+}
+
+audio_format_t qahw_out_get_format(const qahw_stream_handle_t *out_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return AUDIO_FORMAT_INVALID;
+ }
+ return qas->qahw_out_get_format(out_handle);
+ } else {
+ return AUDIO_FORMAT_INVALID;;
+ }
+ } else {
+ return qahw_out_get_format_l(out_handle);
+ }
+}
+
+int qahw_out_standby(qahw_stream_handle_t *out_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_out_standby(out_handle);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_out_standby_l(out_handle);
+ }
+}
+
+int qahw_out_set_parameters(qahw_stream_handle_t *out_handle,
+ const char *kv_pairs)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_out_set_parameters(out_handle, kv_pairs);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_out_set_parameters_l(out_handle, kv_pairs);
+ }
+}
+
+char *qahw_out_get_parameters(const qahw_stream_handle_t *out_handle,
+ const char *keys)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return NULL;
+ }
+ return qas->qahw_out_get_parameters(out_handle, keys);
+ } else {
+ return NULL;
+ }
+ } else {
+ return qahw_out_get_parameters_l(out_handle, keys);
+ }
+}
+
+int qahw_out_set_param_data(qahw_stream_handle_t *out_handle,
+ qahw_param_id param_id,
+ qahw_param_payload *payload)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_out_set_param_data(out_handle, param_id, payload);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_out_set_param_data_l(out_handle, param_id, payload);
+ }
+}
+
+int qahw_out_get_param_data(qahw_stream_handle_t *out_handle,
+ qahw_param_id param_id,
+ qahw_param_payload *payload)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_out_get_param_data(out_handle, param_id, payload);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_out_get_param_data_l(out_handle, param_id, payload);
+ }
+}
+
+uint32_t qahw_out_get_latency(const qahw_stream_handle_t *out_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_out_get_latency(out_handle);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_out_get_latency_l(out_handle);
+ }
+}
+
+int qahw_out_set_volume(qahw_stream_handle_t *out_handle, float left, float right)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_out_set_volume(out_handle, left, right);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_out_set_volume_l(out_handle, left, right);
+ }
+}
+
+ssize_t qahw_out_write(qahw_stream_handle_t *out_handle,
+ qahw_out_buffer_t *out_buf)
+{
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_out_write(out_handle, out_buf);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_out_write_l(out_handle, out_buf);
+ }
+}
+
+int qahw_out_get_render_position(const qahw_stream_handle_t *out_handle,
+ uint32_t *dsp_frames)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_out_get_render_position(out_handle, dsp_frames);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_out_get_render_position_l(out_handle, dsp_frames);
+ }
+}
+
+int qahw_out_set_callback(qahw_stream_handle_t *out_handle,
+ qahw_stream_callback_t callback,
+ void *cookie)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_out_set_callback(out_handle, callback, cookie);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_out_set_callback_l(out_handle, callback, cookie);
+ }
+}
+
+int qahw_out_pause(qahw_stream_handle_t *out_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_out_pause(out_handle);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_out_pause_l(out_handle);
+ }
+}
+
+int qahw_out_resume(qahw_stream_handle_t *out_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_out_resume(out_handle);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_out_resume_l(out_handle);
+ }
+}
+
+int qahw_out_drain(qahw_stream_handle_t *out_handle, qahw_drain_type_t type )
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_out_drain(out_handle, type);
+ } else {
+ return -EINVAL;
+ }
+ } else {
+ return qahw_out_drain_l(out_handle, type);
+ }
+}
+
+int qahw_out_flush(qahw_stream_handle_t *out_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_out_flush(out_handle);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_out_flush_l(out_handle);
+ }
+}
+
+int qahw_out_get_presentation_position(const qahw_stream_handle_t *out_handle,
+ uint64_t *frames, struct timespec *timestamp)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_out_get_presentation_position(out_handle,
+ frames, timestamp);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_out_get_presentation_position_l(out_handle,
+ frames, timestamp);
+ }
+}
+
+uint32_t qahw_in_get_sample_rate(const qahw_stream_handle_t *in_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_in_get_sample_rate(in_handle);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_in_get_sample_rate_l(in_handle);
+ }
+}
+
+int qahw_in_set_sample_rate(qahw_stream_handle_t *in_handle, uint32_t rate)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_in_set_sample_rate(in_handle, rate);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_in_set_sample_rate_l(in_handle, rate);
+ }
+}
+
+size_t qahw_in_get_buffer_size(const qahw_stream_handle_t *in_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_in_get_buffer_size(in_handle);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_in_get_buffer_size_l(in_handle);
+ }
+}
+
+audio_channel_mask_t qahw_in_get_channels(const qahw_stream_handle_t *in_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_in_get_channels(in_handle);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_in_get_channels_l(in_handle);
+ }
+}
+
+audio_format_t qahw_in_get_format(const qahw_stream_handle_t *in_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return (audio_format_t)-ENODEV;
+ }
+ return qas->qahw_in_get_format(in_handle);
+ } else {
+ return (audio_format_t)-ENODEV;
+ }
+ } else {
+ return qahw_in_get_format_l(in_handle);
+ }
+}
+
+int qahw_in_set_format(qahw_stream_handle_t *in_handle, audio_format_t format)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return (audio_format_t)-ENODEV;
+ }
+ return qas->qahw_in_set_format(in_handle, format);
+ } else {
+ return (audio_format_t)-ENODEV;
+ }
+ } else {
+ return qahw_in_set_format_l(in_handle, format);
+ }
+}
+
+int qahw_in_standby(qahw_stream_handle_t *in_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_in_standby(in_handle);
+ } else {
+ return -EINVAL;
+ }
+ } else {
+ return qahw_in_standby_l(in_handle);
+ }
+}
+
+int qahw_in_set_parameters(qahw_stream_handle_t *in_handle, const char *kv_pairs)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_in_set_parameters(in_handle, kv_pairs);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_in_set_parameters_l(in_handle, kv_pairs);
+ }
+}
+
+char* qahw_in_get_parameters(const qahw_stream_handle_t *in_handle,
+ const char *keys)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return NULL;
+ }
+ return qas->qahw_in_get_parameters(in_handle, keys);
+ } else {
+ return NULL;
+ }
+ } else {
+ return qahw_in_get_parameters_l(in_handle, keys);
+ }
+}
+
+ssize_t qahw_in_read(qahw_stream_handle_t *in_handle,
+ qahw_in_buffer_t *in_buf)
+{
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_in_read(in_handle, in_buf);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_in_read_l(in_handle, in_buf);
+ }
+}
+
+uint32_t qahw_in_get_input_frames_lost(qahw_stream_handle_t *in_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_in_get_input_frames_lost(in_handle);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_in_get_input_frames_lost_l(in_handle);
+ }
+}
+
+int qahw_in_get_capture_position(const qahw_stream_handle_t *in_handle,
+ int64_t *frames, int64_t *time)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_in_get_capture_position(in_handle, frames, time);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_in_get_capture_position_l(in_handle, frames, time);
+ }
+}
+
+int qahw_init_check(const qahw_module_handle_t *hw_module)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_init_check(hw_module);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_init_check_l(hw_module);
+ }
+}
+
+int qahw_set_voice_volume(qahw_module_handle_t *hw_module, float volume)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_set_voice_volume(hw_module, volume);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_set_voice_volume_l(hw_module, volume);
+ }
+}
+
+int qahw_set_mode(qahw_module_handle_t *hw_module, audio_mode_t mode)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_set_mode(hw_module, mode);;
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_set_mode_l(hw_module, mode);
+ }
+}
+
+int qahw_set_mic_mute(qahw_module_handle_t *hw_module, bool state)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_set_mic_mute(hw_module, state);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_set_mic_mute_l(hw_module, state);
+ }
+}
+
+int qahw_get_mic_mute(qahw_module_handle_t *hw_module, bool *state)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_get_mic_mute(hw_module, state);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_get_mic_mute_l(hw_module, state);
+ }
+}
+
+int qahw_set_parameters(qahw_module_handle_t *hw_module, const char *kv_pairs)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_set_parameters(hw_module, kv_pairs);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_set_parameters_l(hw_module, kv_pairs);
+ }
+}
+
+char* qahw_get_parameters(const qahw_module_handle_t *hw_module,
+ const char *keys)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return NULL;
+ }
+ return qas->qahw_get_parameters(hw_module, keys);;
+ } else {
+ return NULL;
+ }
+ } else {
+ return qahw_get_parameters_l(hw_module, keys);
+ }
+}
+
+int qahw_get_param_data(const qahw_module_handle_t *hw_module,
+ qahw_param_id param_id,
+ qahw_param_payload *payload)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_get_param_data(hw_module, param_id, payload);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_get_param_data_l(hw_module, param_id, payload);
+ }
+}
+
+int qahw_set_param_data(const qahw_module_handle_t *hw_module,
+ qahw_param_id param_id,
+ qahw_param_payload *payload)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_set_param_data(hw_module, param_id, payload);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_set_param_data_l(hw_module, param_id, payload);
+ }
+}
+
+int qahw_create_audio_patch(qahw_module_handle_t *hw_module,
+ unsigned int num_sources,
+ const struct audio_port_config *sources,
+ unsigned int num_sinks,
+ const struct audio_port_config *sinks,
+ audio_patch_handle_t *handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_create_audio_patch(hw_module, num_sources,
+ sources, num_sinks, sinks,
+ handle);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_create_audio_patch_l(hw_module, num_sources,
+ sources, num_sinks, sinks,
+ handle);
+ }
+}
+
+int qahw_release_audio_patch(qahw_module_handle_t *hw_module,
+ audio_patch_handle_t handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_release_audio_patch(hw_module, handle);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_release_audio_patch_l(hw_module, handle);
+ }
+}
+
+int qahw_get_audio_port(qahw_module_handle_t *hw_module,
+ struct audio_port *port)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_get_audio_port(hw_module, port);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_get_audio_port_l(hw_module, port);
+ }
+}
+
+int qahw_set_audio_port_config(qahw_module_handle_t *hw_module,
+ const struct audio_port_config *config)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_set_audio_port_config(hw_module, config);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_set_audio_port_config_l(hw_module, config);
+ }
+}
+
+size_t qahw_get_input_buffer_size(const qahw_module_handle_t *hw_module,
+ const struct audio_config *config)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_get_input_buffer_size(hw_module, config);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_get_input_buffer_size_l(hw_module, config);
+ }
+}
+
+int qahw_open_output_stream(qahw_module_handle_t *hw_module,
+ audio_io_handle_t handle,
+ audio_devices_t devices,
+ audio_output_flags_t flags,
+ struct audio_config *config,
+ qahw_stream_handle_t **out_handle,
+ const char *address)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_open_output_stream(hw_module, handle, devices,
+ flags, config, out_handle,
+ address);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_open_output_stream_l(hw_module, handle, devices,
+ flags, config, out_handle,
+ address);
+ }
+}
+
+int qahw_close_output_stream(qahw_stream_handle_t *out_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ int status;
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_close_output_stream(out_handle);
+ } else {
+ p_stream_handle *handle;
+ struct listnode *node, *tempnode;
+ pthread_mutex_lock(&list_lock);
+ list_for_each_safe(node, tempnode, &stream_list) {
+ handle = node_to_item(node, p_stream_handle, list);
+ p_stream_handle *p_stream = (p_stream_handle *)out_handle;
+ if (handle != NULL && handle == p_stream) {
+ sh_mem_data *shmem_data = handle->shmem_data;
+ ALOGD("%s %d: clear memory of handle %p &handle %p", __func__, __LINE__, handle, &handle);
+ handle->sh_mem_dealer.clear();
+ handle->sh_mem_handle.clear();
+ }
+ list_remove(node);
+ free(node_to_item(node, p_stream_handle, list));
+ ALOGD("%s %d: Freed node", __func__, __LINE__);
+ }
+ pthread_mutex_unlock(&list_lock);
+ return -ENODEV;
+ }
+ } else {
+ return qahw_close_output_stream_l(out_handle);
+ }
+}
+
+int qahw_open_input_stream(qahw_module_handle_t *hw_module,
+ audio_io_handle_t handle,
+ audio_devices_t devices,
+ struct audio_config *config,
+ qahw_stream_handle_t **in_handle,
+ audio_input_flags_t flags,
+ const char *address,
+ audio_source_t source)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_open_input_stream(hw_module, handle, devices,
+ config, in_handle, flags,
+ address, source);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_open_input_stream_l(hw_module, handle, devices,
+ config, in_handle, flags,
+ address, source);
+ }
+}
+
+int qahw_close_input_stream(qahw_stream_handle_t *in_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_close_input_stream(in_handle);
+ } else {
+ p_stream_handle *handle;
+ struct listnode *node, *tempnode;
+ pthread_mutex_lock(&list_lock);
+ list_for_each_safe(node, tempnode, &stream_list) {
+ ALOGD("%s %d", __func__, __LINE__);
+ handle = node_to_item(node, p_stream_handle, list);
+ p_stream_handle *p_stream = (p_stream_handle *)in_handle;
+ if (handle != NULL && handle == p_stream) {
+ sh_mem_data *shmem_data = handle->shmem_data;
+ ALOGD("%s %d: clear memory of handle %p &handle %p", __func__, __LINE__, handle, &handle);
+ handle->sh_mem_dealer.clear();
+ handle->sh_mem_handle.clear();
+ }
+ list_remove(node);
+ free(node_to_item(node, p_stream_handle, list));
+ ALOGD("%s %d: Freed node", __func__, __LINE__);
+ }
+ pthread_mutex_unlock(&list_lock);
+ return -EINVAL;
+ }
+ } else {
+ return qahw_close_input_stream_l(in_handle);
+ }
+}
+
+int qahw_get_version()
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_get_version();
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_get_version_l();
+ }
+}
+
+int qahw_unload_module(qahw_module_handle_t *hw_module)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ if (g_binder_enabled) {
+ if (!g_qas_died && (--g_qas_load_count == 0)) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return -ENODEV;
+ }
+ return qas->qahw_unload_module(hw_module);
+ } else {
+ return -ENODEV;
+ }
+ } else {
+ return qahw_unload_module_l(hw_module);
+ }
+}
+
+qahw_module_handle_t *qahw_load_module(const char *hw_module_id)
+{
+ char value[PROPERTY_VALUE_MAX];
+
+ ALOGV("%d:%s",__LINE__, __func__);
+ g_binder_enabled = property_get_bool("persist.vendor.audio.qas.enabled", false);
+ ALOGV("%d:%s: g_binder_enabled %d",__LINE__, __func__, g_binder_enabled);
+ if (g_binder_enabled) {
+ sp<Iqti_audio_server> qas = get_qti_audio_server();
+ if (qas == 0) {
+ ALOGE("%d:%s: invalid HAL handle",__LINE__, __func__);
+ return (void*)(-ENODEV);
+ }
+ g_qas_handle = qas->qahw_load_module(hw_module_id);
+ if (g_qas_handle == NULL) {
+ ALOGE("%s: HAL loading failed", __func__);
+ } else if (g_qas_load_count == 0) {
+ g_qas_load_count++;
+ g_qas_died = false;
+ pthread_mutex_init(&list_lock, (const pthread_mutexattr_t *) NULL);
+ list_init(&stream_list);
+ ALOGV("%s %d: stream_list %p", __func__, __LINE__, stream_list);
+ } else {
+ g_qas_load_count++;
+ ALOGD("%s: returning existing instance of hal", __func__);
+ }
+ } else {
+ g_qas_handle = qahw_load_module_l(hw_module_id);
+ }
+ return g_qas_handle;
+}
+#else
+void qahw_register_qas_death_notify_cb(audio_error_callback cb __unused, void* context __unused)
+{
+}
+
+uint32_t qahw_out_get_sample_rate(const qahw_stream_handle_t *out_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_out_get_sample_rate_l(out_handle);
+}
+
+int qahw_out_set_sample_rate(qahw_stream_handle_t *out_handle, uint32_t rate)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_out_set_sample_rate_l(out_handle, rate);
+}
+
+size_t qahw_out_get_buffer_size(const qahw_stream_handle_t *out_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_out_get_buffer_size_l(out_handle);
+}
+
+audio_channel_mask_t qahw_out_get_channels(const qahw_stream_handle_t
+ *out_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_out_get_channels_l(out_handle);
+}
+
+audio_format_t qahw_out_get_format(const qahw_stream_handle_t *out_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_out_get_format_l(out_handle);
+}
+
+int qahw_out_standby(qahw_stream_handle_t *out_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_out_standby_l(out_handle);
+}
+
+int qahw_out_set_parameters(qahw_stream_handle_t *out_handle,
+ const char *kv_pairs)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_out_set_parameters_l(out_handle, kv_pairs);
+}
+
+char *qahw_out_get_parameters(const qahw_stream_handle_t *out_handle,
+ const char *keys)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_out_get_parameters_l(out_handle, keys);
+}
+
+int qahw_out_set_param_data(qahw_stream_handle_t *out_handle,
+ qahw_param_id param_id,
+ qahw_param_payload *payload)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_out_set_param_data_l(out_handle, param_id, payload);
+}
+
+int qahw_out_get_param_data(qahw_stream_handle_t *out_handle,
+ qahw_param_id param_id,
+ qahw_param_payload *payload)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_out_get_param_data_l(out_handle, param_id, payload);
+}
+
+uint32_t qahw_out_get_latency(const qahw_stream_handle_t *out_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_out_get_latency_l(out_handle);
+}
+
+int qahw_out_set_volume(qahw_stream_handle_t *out_handle, float left, float right)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_out_set_volume_l(out_handle, left, right);
+}
+
+ssize_t qahw_out_write(qahw_stream_handle_t *out_handle,
+ qahw_out_buffer_t *out_buf)
+{
+ return qahw_out_write_l(out_handle, out_buf);
+}
+
+int qahw_out_get_render_position(const qahw_stream_handle_t *out_handle,
+ uint32_t *dsp_frames)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_out_get_render_position_l(out_handle, dsp_frames);
+}
+
+int qahw_out_set_callback(qahw_stream_handle_t *out_handle,
+ qahw_stream_callback_t callback,
+ void *cookie)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_out_set_callback_l(out_handle, callback, cookie);
+}
+
+int qahw_out_pause(qahw_stream_handle_t *out_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_out_pause_l(out_handle);
+}
+
+int qahw_out_resume(qahw_stream_handle_t *out_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_out_resume_l(out_handle);
+}
+
+int qahw_out_drain(qahw_stream_handle_t *out_handle, qahw_drain_type_t type )
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_out_drain_l(out_handle, type);
+}
+
+int qahw_out_flush(qahw_stream_handle_t *out_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_out_flush_l(out_handle);
+}
+
+int qahw_out_get_presentation_position(const qahw_stream_handle_t *out_handle,
+ uint64_t *frames, struct timespec *timestamp)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_out_get_presentation_position_l(out_handle,
+ frames, timestamp);
+}
+
+uint32_t qahw_in_get_sample_rate(const qahw_stream_handle_t *in_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_in_get_sample_rate_l(in_handle);
+}
+
+int qahw_in_set_sample_rate(qahw_stream_handle_t *in_handle, uint32_t rate)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_in_set_sample_rate_l(in_handle, rate);
+}
+
+size_t qahw_in_get_buffer_size(const qahw_stream_handle_t *in_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_in_get_buffer_size_l(in_handle);
+}
+
+audio_channel_mask_t qahw_in_get_channels(const qahw_stream_handle_t *in_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_in_get_channels_l(in_handle);
+}
+
+audio_format_t qahw_in_get_format(const qahw_stream_handle_t *in_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_in_get_format_l(in_handle);
+}
+
+int qahw_in_set_format(qahw_stream_handle_t *in_handle, audio_format_t format)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_in_set_format_l(in_handle, format);
+}
+
+int qahw_in_standby(qahw_stream_handle_t *in_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_in_standby_l(in_handle);
+}
+
+int qahw_in_set_parameters(qahw_stream_handle_t *in_handle, const char *kv_pairs)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_in_set_parameters_l(in_handle, kv_pairs);
+}
+
+char* qahw_in_get_parameters(const qahw_stream_handle_t *in_handle,
+ const char *keys)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_in_get_parameters_l(in_handle, keys);
+}
+
+ssize_t qahw_in_read(qahw_stream_handle_t *in_handle,
+ qahw_in_buffer_t *in_buf)
+{
+ return qahw_in_read_l(in_handle, in_buf);
+}
+
+uint32_t qahw_in_get_input_frames_lost(qahw_stream_handle_t *in_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_in_get_input_frames_lost_l(in_handle);
+}
+
+int qahw_in_get_capture_position(const qahw_stream_handle_t *in_handle,
+ int64_t *frames, int64_t *time)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_in_get_capture_position_l(in_handle, frames, time);
+}
+
+int qahw_init_check(const qahw_module_handle_t *hw_module)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_init_check_l(hw_module);
+}
+
+int qahw_set_voice_volume(qahw_module_handle_t *hw_module, float volume)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_set_voice_volume_l(hw_module, volume);
+}
+
+int qahw_set_mode(qahw_module_handle_t *hw_module, audio_mode_t mode)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_set_mode_l(hw_module, mode);
+}
+
+int qahw_set_mic_mute(qahw_module_handle_t *hw_module, bool state)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_set_mic_mute_l(hw_module, state);
+}
+
+int qahw_get_mic_mute(qahw_module_handle_t *hw_module, bool *state)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_get_mic_mute_l(hw_module, state);
+}
+
+int qahw_set_parameters(qahw_module_handle_t *hw_module, const char *kv_pairs)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_set_parameters_l(hw_module, kv_pairs);
+}
+
+char* qahw_get_parameters(const qahw_module_handle_t *hw_module,
+ const char *keys)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_get_parameters_l(hw_module, keys);
+}
+
+int qahw_get_param_data(const qahw_module_handle_t *hw_module,
+ qahw_param_id param_id,
+ qahw_param_payload *payload)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_get_param_data_l(hw_module, param_id, payload);
+}
+
+int qahw_set_param_data(const qahw_module_handle_t *hw_module,
+ qahw_param_id param_id,
+ qahw_param_payload *payload)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_set_param_data_l(hw_module, param_id, payload);
+}
+
+int qahw_create_audio_patch(qahw_module_handle_t *hw_module,
+ unsigned int num_sources,
+ const struct audio_port_config *sources,
+ unsigned int num_sinks,
+ const struct audio_port_config *sinks,
+ audio_patch_handle_t *handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_create_audio_patch_l(hw_module, num_sources,
+ sources, num_sinks, sinks,
+ handle);
+}
+
+int qahw_release_audio_patch(qahw_module_handle_t *hw_module,
+ audio_patch_handle_t handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_release_audio_patch_l(hw_module, handle);
+}
+
+int qahw_get_audio_port(qahw_module_handle_t *hw_module,
+ struct audio_port *port)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_get_audio_port_l(hw_module, port);
+}
+
+int qahw_set_audio_port_config(qahw_module_handle_t *hw_module,
+ const struct audio_port_config *config)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_set_audio_port_config_l(hw_module, config);
+}
+
+size_t qahw_get_input_buffer_size(const qahw_module_handle_t *hw_module,
+ const struct audio_config *config)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_get_input_buffer_size_l(hw_module, config);
+}
+
+int qahw_open_output_stream(qahw_module_handle_t *hw_module,
+ audio_io_handle_t handle,
+ audio_devices_t devices,
+ audio_output_flags_t flags,
+ struct audio_config *config,
+ qahw_stream_handle_t **out_handle,
+ const char *address)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_open_output_stream_l(hw_module, handle, devices,
+ flags, config, out_handle,
+ address);
+}
+
+int qahw_close_output_stream(qahw_stream_handle_t *out_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_close_output_stream_l(out_handle);
+}
+
+int qahw_open_input_stream(qahw_module_handle_t *hw_module,
+ audio_io_handle_t handle,
+ audio_devices_t devices,
+ struct audio_config *config,
+ qahw_stream_handle_t **in_handle,
+ audio_input_flags_t flags,
+ const char *address,
+ audio_source_t source)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_open_input_stream_l(hw_module, handle, devices,
+ config, in_handle, flags,
+ address, source);
+}
+
+int qahw_close_input_stream(qahw_stream_handle_t *in_handle)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_close_input_stream_l(in_handle);
+}
+
+int qahw_get_version()
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_get_version_l();
+}
+
+int qahw_unload_module(qahw_module_handle_t *hw_module)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_unload_module_l(hw_module);
+}
+
+qahw_module_handle_t *qahw_load_module(const char *hw_module_id)
+{
+ ALOGV("%d:%s",__LINE__, __func__);
+ return qahw_load_module_l(hw_module_id);
+}
+#endif
diff --git a/qahw_api/test/Android.mk b/qahw_api/test/Android.mk
index 887f416..ec4e698 100644
--- a/qahw_api/test/Android.mk
+++ b/qahw_api/test/Android.mk
@@ -8,6 +8,7 @@
LOCAL_MODULE := hal_play_test
hal-play-inc = $(TARGET_OUT_HEADERS)/mm-audio/qahw_api/inc
+hal-play-inc += $(TARGET_OUT_HEADERS)/mm-audio/qahw/inc
hal-play-inc += external/tinyalsa/include
LOCAL_CFLAGS += -Wall -Werror -Wno-sign-compare
@@ -15,6 +16,7 @@
LOCAL_SHARED_LIBRARIES := \
libaudioutils\
libqahw \
+ libqahwwrapper \
libutils \
libcutils
diff --git a/qahw_api/test/Makefile.am b/qahw_api/test/Makefile.am
index b4bbea7..40cc24a 100644
--- a/qahw_api/test/Makefile.am
+++ b/qahw_api/test/Makefile.am
@@ -1,34 +1,35 @@
bin_PROGRAMS = hal_play_test
-PLAY_CPPFLAGS = -Wno-sign-compare -Werror
-PLAY_CPPFLAGS += -D__unused=__attribute__\(\(__unused__\)\)
+PLAY_CFLAGS = -Wno-sign-compare -Werror
+PLAY_CFLAGS += -D__unused=__attribute__\(\(__unused__\)\)
PLAY_INCLUDES = -I $(top_srcdir)/qahw_api/inc
+PLAY_INCLUDES += -I $(top_srcdir)/qahw/inc
hal_play_test_SOURCES = qahw_playback_test.c \
qahw_effect_test.c
hal_play_test_LDADD = -lutils ../libqahw.la
+AM_CFLAGS = -I $(PKG_CONFIG_SYSROOT_DIR)/usr/include/mm-audio/qahw/inc
if QAP
-AM_CFLAGS = -DQAP
+AM_CFLAGS += -DQAP
AM_CFLAGS += -I ${WORKSPACE}/audio/mm-audio/qap_wrapper/inc/
hal_play_test_SOURCES += qap_wrapper_extn.c
hal_play_test_LDADD += -lqap_wrapper
endif
-hal_play_test_CPPFLAGS = $(PLAY_CPPFLAGS) $(PLAY_INCLUDES)
-hal_play_test_CFLAGS = $(AM_CFLAGS)
-hal_play_test_CFLAGS = -DLINUX_ENABLED
+hal_play_test_CFLAGS = $(PLAY_CFLAGS) $(PLAY_INCLUDES)
+hal_play_test_CFLAGS += $(AM_CFLAGS) -DLINUX_ENABLED
bin_PROGRAMS += hal_rec_test
-REC_CPPFLAGS = $(PLAY_CPPFLAGS) -Dnullptr=NULL
+REC_CFLAGS = $(PLAY_CFLAGS) -Dnullptr=NULL
REC_INCLUDES = $(PLAY_INCLUDES)
hal_rec_test_SOURCES = qahw_multi_record_test.c
-hal_rec_test_CPPFLAGS = -Dstrlcat=g_strlcat $(GLIB_CFLAGS) -include glib.h
-hal_rec_test_CPPFLAGS += $(REC_CPPFLAGS) $(REC_INCLUDES)
-hal_play_test_CFLAGS += $(AM_CFLAGS)
+hal_rec_test_CFLAGS = -Dstrlcat=g_strlcat $(GLIB_CFLAGS) -include glib.h
+hal_rec_test_CFLAGS += $(REC_CFLAGS) $(REC_INCLUDES)
+hal_rec_test_CFLAGS += $(AM_CFLAGS)
hal_rec_test_LDADD = -lutils ../libqahw.la $(GLIB_LIBS)
bin_PROGRAMS += trans_loopback_test
@@ -37,6 +38,6 @@
trans_loopback_test_SOURCES = trans_loopback_test.c
-trans_loopback_test_CFLAGS = $(CFLAGS) -Wno-sign-compare -Werror
+trans_loopback_test_CFLAGS = $(AM_CFLAGS) -Wno-sign-compare -Werror
trans_loopback_test_CFLAGS += $(trans_loopback_test_INCLUDES)
-trans_loopback_test_LDADD = -llog -lutils ../libqahw.la -lcutils
+trans_loopback_test_LDADD = -llog -lutils ../libqahw.la -lcutils -lm
diff --git a/qahw_api/test/qahw_multi_record_test.c b/qahw_api/test/qahw_multi_record_test.c
index 5b07b0f..d618101 100644
--- a/qahw_api/test/qahw_multi_record_test.c
+++ b/qahw_api/test/qahw_multi_record_test.c
@@ -90,6 +90,7 @@
int sourcetrack_done = 0;
static pthread_mutex_t sourcetrack_lock;
struct qahw_sound_focus_param sound_focus_data;
+void *context = NULL;
static bool request_wake_lock(bool wakelock_acquired, bool enable)
{
@@ -130,7 +131,6 @@
stop_record = true;
}
-
void read_soundfocus_param(void)
{
uint16_t start_angle[4] = {0};
@@ -249,7 +249,9 @@
{
int rc = 0, ret = 0, count = 0;
FILE *fdLatencyNode = nullptr;
- struct timespec tsColdI, tsColdF, tsCont;
+ struct timespec tsColdI = { 0, 0 };
+ struct timespec tsColdF = { 0, 0 };
+ struct timespec tsCont = { 0, 0 };
uint64_t tCold, tCont, tsec, tusec;
char latencyBuf[200] = {0};
time_t start_time = time(0);
@@ -352,6 +354,7 @@
fprintf(log_file, "File open failed \n");
if (log_file != stdout)
fprintf(stdout, "File open failed \n");
+ free(buffer);
test_end();
pthread_exit(0);
}
@@ -442,6 +445,7 @@
hdr.riff_sz = data_sz + 44 - 8;
fseek(fd, 0, SEEK_SET);
fwrite(&hdr, 1, sizeof(hdr), fd);
+ free(buffer);
fclose(fd);
/* capture latency kpis if required */
@@ -450,7 +454,8 @@
tsColdF.tv_nsec/1000000 - tsColdI.tv_nsec/1000000;
fread((void *) latencyBuf, 100, 1, fdLatencyNode);
- fclose(fdLatencyNode);
+ if (fdLatencyNode)
+ fclose(fdLatencyNode);
sscanf(latencyBuf, " %llu,%llu", &tsec, &tusec);
tCont = ((uint64_t)tsCont.tv_sec)*1000 - tsec*1000 + ((uint64_t)tsCont.tv_nsec)/1000000 - tusec/1000;
if (log_file != stdout) {
@@ -583,6 +588,12 @@
printf(" For mono channel 16kHz rate for 30seconds\n\n");
}
+static void qti_audio_server_death_notify_cb(void *ctxt) {
+ fprintf(log_file, "qas died\n");
+ fprintf(stderr, "qas died\n");
+ stop_record = true;
+}
+
int main(int argc, char* argv[]) {
int max_recordings_requested = 0, status = 0;
int thread_active[MAX_RECORD_SESSIONS] = {0};
@@ -675,6 +686,8 @@
break;
}
}
+ fprintf(log_file, "registering qas callback");
+ qahw_register_qas_death_notify_cb((audio_error_callback)qti_audio_server_death_notify_cb, context);
wakelock_acquired = request_wake_lock(wakelock_acquired, true);
qahw_mod_handle = qahw_load_module(mod_name);
diff --git a/qahw_api/test/qahw_playback_test.c b/qahw_api/test/qahw_playback_test.c
index fc55f83..fceff8b 100644
--- a/qahw_api/test/qahw_playback_test.c
+++ b/qahw_api/test/qahw_playback_test.c
@@ -54,6 +54,10 @@
#define DTSHD_CHUNK_STREAM_KEYWORD "STRMDATA"
#define DTSHD_META_KEYWORD_SIZE 8 /*in bytes */
+#ifndef AUDIO_OUTPUT_FLAG_MAIN
+#define AUDIO_OUTPUT_FLAG_MAIN 0x8000000
+#endif
+
static ssize_t get_bytes_to_read(FILE* file, int filetype);
static void init_streams(void);
int pthread_cancel(pthread_t thread);
@@ -351,7 +355,7 @@
struct proxy_data* params = (struct proxy_data*) data;
qahw_module_handle_t *qahw_mod_handle = params->acp.qahw_mod_handle;
qahw_in_buffer_t in_buf;
- char *buffer;
+ char *buffer = NULL;
int rc = 0;
int bytes_to_read, bytes_written = 0, bytes_wrote = 0;
FILE *fp = NULL;
@@ -378,6 +382,7 @@
if ((fp = fopen(params->acp.file_name,"w"))== NULL) {
fprintf(log_file, "Cannot open file to dump proxy data\n");
fprintf(stderr, "Cannot open file to dump proxy data\n");
+ free(buffer);
pthread_exit(0);
}
else {
@@ -420,6 +425,7 @@
fprintf(stderr, "could not close input stream %d \n", rc);
}
fprintf(log_file, "pcm data saved to file %s", params->acp.file_name);
+ free(buffer);
}
return 0;
}
@@ -463,7 +469,7 @@
return NULL;
}
-static int is_eof(stream_config *stream) {
+static int __unused is_eof (stream_config *stream) {
if (stream->filename) {
if (feof(stream->file_stream)) {
fprintf(log_file, "stream %d: error in fread, error %d\n", stream->stream_index, ferror(stream->file_stream));
@@ -505,7 +511,7 @@
ret = qahw_out_write(out_handle, &out_buf);
if (ret < 0) {
fprintf(log_file, "stream %d: writing data to hal failed (ret = %zd)\n", stream_params->stream_index, ret);
- } else if (ret != bytes) {
+ } else if ((ret != bytes) && (!stop_playback)) {
fprintf(log_file, "stream %d: provided bytes %zd, written bytes %d\n",stream_params->stream_index, bytes, ret);
fprintf(log_file, "stream %d: waiting for event write ready\n", stream_params->stream_index);
pthread_cond_wait(&stream_params->write_cond, &stream_params->write_lock);
@@ -516,7 +522,7 @@
return ret;
}
-static bool is_assoc_active()
+static bool __unused is_assoc_active()
{
int i = 0;
bool is_assoc_active = false;
@@ -530,7 +536,7 @@
return is_assoc_active;
}
-static int get_assoc_index()
+static int __unused get_assoc_index()
{
int i = 0;
@@ -1132,6 +1138,7 @@
if (data == NULL) {
fprintf(log_file, "calloc failed!!\n");
fprintf(stderr, "calloc failed!!\n");
+ fclose(fd_latency_node);
return -ENOMEM;
}
@@ -1144,7 +1151,8 @@
if (ret) {
fprintf(log_file, "error(%d) fetching start time for cold latency", ret);
fprintf(stderr, "error(%d) fetching start time for cold latency", ret);
- return -1;
+ rc = -1;
+ goto exit;
}
} else if (count == 16) {
int *d = (int *)data;
@@ -1153,7 +1161,8 @@
if (ret) {
fprintf(log_file, "error(%d) fetching start time for continuous latency", ret);
fprintf(stderr, "error(%d) fetching start time for continuous latency", ret);
- return -1;
+ rc = -1;
+ goto exit;
}
}
@@ -1179,6 +1188,9 @@
fprintf(log_file, "\n values from debug node %s\n", latency_buf);
fprintf(log_file, " cold latency %llums, continuous latency %llums,\n", tcold, tcont);
fprintf(log_file, " **Note: please add DSP Pipe/PP latency numbers to this, for final latency values\n");
+exit:
+ fclose(fd_latency_node);
+ free(data);
return rc;
}
@@ -1221,7 +1233,7 @@
void parse_aptx_dec_bt_addr(char *value, struct qahw_aptx_dec_param *aptx_cfg)
{
- int ba[6];
+ int ba[6] = {0, 0, 0, 0, 0, 0};
char *str, *tok;
uint32_t addr[3];
int i = 0;
@@ -1693,7 +1705,7 @@
ret = fread(&read_chunk_size, 1, DTSHD_META_KEYWORD_SIZE, file);
chunk_size = convert_BE_to_LE(read_chunk_size);
if (ret != DTSHD_META_KEYWORD_SIZE) {
- fprintf(stderr,"%s %d file read error ret %\n",
+ fprintf(stderr,"%s %d file read error ret %d \n",
__func__, __LINE__, ret);
file_read_size = -EINVAL;
break;
@@ -1836,6 +1848,7 @@
char *init_ptr = NULL;
char *token = NULL;
char *saveptr = NULL;
+ int rc = 0;
if (NULL == channel_map)
return -EINVAL;
@@ -1849,20 +1862,24 @@
init_ptr = token_string;
token = strtok_r(token_string, ",", &saveptr);
int index = 0;
- if (NULL == token)
- return -EINVAL;
+ if (NULL == token) {
+ rc = -EINVAL;
+ goto exit;
+ }
else
channel_map[index++] = get_channel_mask_for_name(token);
while(NULL !=(token = strtok_r(NULL,",",&saveptr)))
channel_map[index++] = get_channel_mask_for_name(token);
- free(init_ptr);
- init_ptr = NULL;
- token_string = NULL;
+ goto exit;
} else
return -EINVAL;
- return 0;
+exit:
+ free(init_ptr);
+ init_ptr = NULL;
+ token_string = NULL;
+ return rc;
}
int extract_mixer_coeffs(qahw_mix_matrix_params_t * mm_params, const char * arg_string){
@@ -1872,7 +1889,7 @@
char *token = NULL;
char *saveptr = NULL;
int i = 0;
- int j = 0;
+ int j = 0, rc = 0;
if (NULL == mm_params)
return -EINVAL;
@@ -1885,9 +1902,10 @@
if(token_string != NULL) {
init_ptr = token_string;
token = strtok_r(token_string, ",", &saveptr);
- int index = 0;
- if (NULL == token)
- return -EINVAL;
+ if (NULL == token) {
+ rc = -EINVAL;
+ goto exit;
+ }
else {
mm_params->mixer_coeffs[i][j] = atof(token);
j++;
@@ -1902,11 +1920,14 @@
break;
mm_params->mixer_coeffs[i][j++] = atof(token);
}
- free(init_ptr);
- init_ptr = NULL;
- token_string = NULL;
+ goto exit;
} else
return -EINVAL;
+exit:
+ free(init_ptr);
+ init_ptr = NULL;
+ token_string = NULL;
+ return rc;
}
#ifdef QAP
@@ -1956,6 +1977,16 @@
}
#endif
+static void qti_audio_server_death_notify_cb(void *ctxt) {
+ fprintf(log_file, "qas died\n");
+ fprintf(stderr, "qas died\n");
+
+ stream_config *s_params = (stream_config*) ctxt;
+ pthread_cond_signal(&s_params->write_cond);
+ pthread_cond_signal(&s_params->drain_cond);
+ stop_playback = true;
+}
+
int main(int argc, char* argv[]) {
char *ba = NULL;
qahw_param_payload payload;
@@ -2115,14 +2146,14 @@
get_kvpairs_string(optarg, "O", output_ch_map);
get_kvpairs_string(optarg, "M", mixer_coeff);
- extract_channel_mapping(stream_param[i].mm_params_downmix.input_channel_map, input_ch_map);
+ extract_channel_mapping((uint16_t *)(stream_param[i].mm_params_downmix.input_channel_map), input_ch_map);
stream_param[i].mm_params_downmix.has_input_channel_map = 1;
fprintf(log_file, "\ndownmix Input channel mapping: ");
for (iter_i= 0; iter_i < stream_param[i].mm_params_downmix.num_input_channels; iter_i++) {
fprintf(log_file, "0x%x, ", stream_param[i].mm_params_downmix.input_channel_map[iter_i]);
}
- extract_channel_mapping(stream_param[i].mm_params_downmix.output_channel_map, output_ch_map);
+ extract_channel_mapping((uint16_t *)(stream_param[i].mm_params_downmix.output_channel_map), output_ch_map);
stream_param[i].mm_params_downmix.has_output_channel_map = 1;
fprintf(log_file, "\ndownmix Output channel mapping: ");
for (iter_i = 0; iter_i < stream_param[i].mm_params_downmix.num_output_channels; iter_i++)
@@ -2150,14 +2181,14 @@
get_kvpairs_string(optarg, "O", output_ch_map);
get_kvpairs_string(optarg, "M", mixer_coeff);
- extract_channel_mapping(stream_param[i].mm_params_pan_scale.input_channel_map, input_ch_map);
+ extract_channel_mapping((uint16_t *)(stream_param[i].mm_params_pan_scale.input_channel_map), input_ch_map);
stream_param[i].mm_params_pan_scale.has_input_channel_map = 1;
fprintf(log_file, "\n pan_sclae Input channel mapping: ");
for (iter_i= 0; iter_i < stream_param[i].mm_params_pan_scale.num_input_channels; iter_i++) {
fprintf(log_file, "0x%x, ", stream_param[i].mm_params_pan_scale.input_channel_map[iter_i]);
}
- extract_channel_mapping(stream_param[i].mm_params_pan_scale.output_channel_map, output_ch_map);
+ extract_channel_mapping((uint16_t *)(stream_param[i].mm_params_pan_scale.output_channel_map), output_ch_map);
stream_param[i].mm_params_pan_scale.has_output_channel_map = 1;
fprintf(log_file, "\n pan_scale Output channel mapping: ");
for (iter_i = 0; iter_i < stream_param[i].mm_params_pan_scale.num_output_channels; iter_i++)
@@ -2313,6 +2344,8 @@
}
}
+ fprintf(log_file, "registering qas callback");
+ qahw_register_qas_death_notify_cb((audio_error_callback)qti_audio_server_death_notify_cb, &stream_param);
wakelock_acquired = request_wake_lock(wakelock_acquired, true);
num_of_streams = i+1;