tizen-audio-device.c \
tizen-audio-volume.c \
tizen-audio-ucm.c \
+ tizen-audio-comm.c \
tizen-audio-util.c
libtizen_audio_la_LDFLAGS = $(AM_LDFLAGS) -disable-static -avoid-version
if USE_TINYALSA
Name: audio-hal-wm1831
Summary: TIZEN Audio HAL for WM1831
-Version: 0.1.1
+Version: 0.1.2
Release: 0
Group: System/Libraries
License: Apache-2.0
/* FIXME : To avoid build warning... */
int _snd_pcm_poll_descriptor(snd_pcm_t *pcm);
#endif
-
/* #define DEBUG_TIMING */
static device_type_t outDeviceTypes[] = {
{ 0, 0 },
};
+static const char* mode_to_verb_str[] = {
+ AUDIO_USE_CASE_VERB_HIFI,
+};
+
static uint32_t convert_device_string_to_enum(const char* device_str, uint32_t direction)
{
uint32_t device = 0;
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(devices, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(num_of_devices, AUDIO_ERR_PARAMETER);
if (num_of_devices > MAX_DEVICES) {
num_of_devices = MAX_DEVICES;
return AUDIO_ERR_PARAMETER;
}
- if ((devices[0].direction == AUDIO_DIRECTION_OUT) && ah->device.active_in) {
- /* check the active in devices */
- for (j = 0; j < inDeviceTypes[j].type; j++) {
- if (((ah->device.active_in & (~0x80000000)) & inDeviceTypes[j].type))
- active_devices[dev_idx++] = inDeviceTypes[j].name;
+ if (devices[0].direction == AUDIO_DIRECTION_OUT) {
+ ah->device.active_out &= 0x0;
+ if (ah->device.active_in) {
+ /* check the active in devices */
+ for (j = 0; j < inDeviceTypes[j].type; j++) {
+ if (((ah->device.active_in & (~AUDIO_DEVICE_IN)) & inDeviceTypes[j].type))
+ active_devices[dev_idx++] = inDeviceTypes[j].name;
+ }
}
- } else if ((devices[0].direction == AUDIO_DIRECTION_IN) && ah->device.active_out) {
- /* check the active out devices */
- for (j = 0; j < outDeviceTypes[j].type; j++) {
- if (ah->device.active_out & outDeviceTypes[j].type)
- active_devices[dev_idx++] = outDeviceTypes[j].name;
+ } else if (devices[0].direction == AUDIO_DIRECTION_IN) {
+ ah->device.active_in &= 0x0;
+ if (ah->device.active_out) {
+ /* check the active out devices */
+ for (j = 0; j < outDeviceTypes[j].type; j++) {
+ if (ah->device.active_out & outDeviceTypes[j].type)
+ active_devices[dev_idx++] = outDeviceTypes[j].name;
+ }
}
}
for (i = 0; i < num_of_devices; i++) {
new_device = convert_device_string_to_enum(devices[i].type, devices[i].direction);
- if (new_device & 0x80000000) {
+ if (new_device & AUDIO_DEVICE_IN) {
for (j = 0; j < inDeviceTypes[j].type; j++) {
if (new_device == inDeviceTypes[j].type) {
active_devices[dev_idx++] = inDeviceTypes[j].name;
}
audio_ret = _audio_ucm_set_devices(ah, verb, active_devices);
- if (audio_ret) {
+ if (audio_ret)
AUDIO_LOG_ERROR("Failed to set device: error = %d", audio_ret);
- return audio_ret;
- }
- return audio_ret;
+ return audio_ret;
}
audio_return_t _audio_device_init(audio_hal_t *ah)
{
audio_return_t audio_ret = AUDIO_RET_OK;
device_info_t *devices = NULL;
- const char *verb = NULL;
+ const char *verb = mode_to_verb_str[VERB_NORMAL];
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(route_info, AUDIO_ERR_PARAMETER);
/* int mod_idx = 0; */
/* const char *modifiers[MAX_MODIFIERS] = {NULL,}; */
- verb = AUDIO_USE_CASE_VERB_HIFI;
AUDIO_LOG_INFO("do_route_ap_playback_capture++ ");
audio_ret = set_devices(ah, verb, devices, route_info->num_of_devices);
return audio_ret;
}
-audio_return_t _do_route_voip(audio_hal_t *ah, device_info_t *devices, int32_t num_of_devices)
+static audio_return_t _do_route_voip(audio_hal_t *ah, device_info_t *devices, int32_t num_of_devices)
{
audio_return_t audio_ret = AUDIO_RET_OK;
- const char *verb = NULL;
- verb = AUDIO_USE_CASE_VERB_HIFI;
+ const char *verb = mode_to_verb_str[VERB_NORMAL];
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(devices, AUDIO_ERR_PARAMETER);
return audio_ret;
}
-audio_return_t _do_route_reset(audio_hal_t *ah, uint32_t direction)
+static audio_return_t _do_route_reset(audio_hal_t *ah, uint32_t direction)
{
audio_return_t audio_ret = AUDIO_RET_OK;
+ const char *active_devices[MAX_DEVICES] = {NULL,};
+ int i = 0, dev_idx = 0;
/* FIXME: If you need to reset, set verb inactive */
/* const char *verb = NULL; */
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
- AUDIO_LOG_INFO("do_route_reset++, direction(%p)", direction);
+ AUDIO_LOG_INFO("do_route_reset++, direction(0x%x)", direction);
if (direction == AUDIO_DIRECTION_OUT) {
ah->device.active_out &= 0x0;
+ if (ah->device.active_in) {
+ /* check the active in devices */
+ for (i = 0; i < inDeviceTypes[i].type; i++) {
+ if (((ah->device.active_in & (~AUDIO_DEVICE_IN)) & inDeviceTypes[i].type)) {
+ active_devices[dev_idx++] = inDeviceTypes[i].name;
+ AUDIO_LOG_INFO("added for in : %s", inDeviceTypes[i].name);
+ }
+ }
+ }
} else {
ah->device.active_in &= 0x0;
+ if (ah->device.active_out) {
+ /* check the active out devices */
+ for (i = 0; i < outDeviceTypes[i].type; i++) {
+ if (ah->device.active_out & outDeviceTypes[i].type) {
+ active_devices[dev_idx++] = outDeviceTypes[i].name;
+ AUDIO_LOG_INFO("added for out : %s", outDeviceTypes[i].name);
+ }
+ }
+ }
}
- /* TO DO: Set Inactive */
+ if (active_devices[0] == NULL) {
+ AUDIO_LOG_DEBUG("active device is NULL, no need to update.");
+ return AUDIO_RET_OK;
+ }
+
+ audio_ret = _audio_ucm_set_devices(ah, mode_to_verb_str[ah->device.mode], active_devices);
+ if (audio_ret)
+ AUDIO_LOG_ERROR("Failed to set device: error = %d", audio_ret);
+
return audio_ret;
}
+#define LOOPBACK_ARG_LATENCY_MSEC 40
+#define LOOPBACK_ARG_ADJUST_TIME_SEC 3
audio_return_t audio_do_route(void *audio_handle, audio_route_info_t *info)
{
audio_return_t audio_ret = AUDIO_RET_OK;
AUDIO_LOG_INFO("role:%s", info->role);
+ devices = info->device_infos;
+
if (!strncmp("voip", info->role, MAX_NAME_LEN)) {
audio_ret = _do_route_voip(ah, devices, info->num_of_devices);
if (AUDIO_IS_ERROR(audio_ret)) {
AUDIO_LOG_WARN("set reset return 0x%x", audio_ret);
}
} else {
+ /* send latency and adjust time for loopback */
+ if (!strncmp("loopback", info->role, MAX_NAME_LEN)) {
+ _audio_comm_send_message(ah, "loopback::latency", LOOPBACK_ARG_LATENCY_MSEC);
+ _audio_comm_send_message(ah, "loopback::adjust_time", LOOPBACK_ARG_ADJUST_TIME_SEC);
+ }
/* need to prepare for "alarm","notification","emergency","voice-information","voice-recognition","ringtone" */
audio_ret = _do_route_ap_playback_capture(ah, info);
-
if (AUDIO_IS_ERROR(audio_ret)) {
AUDIO_LOG_WARN("set playback route return 0x%x", audio_ret);
}
} while (0)
/* Devices : Normal */
+#define AUDIO_DEVICE_OUT 0x00000000
+#define AUDIO_DEVICE_IN 0x80000000
enum audio_device_type {
AUDIO_DEVICE_NONE = 0,
/* output devices */
- AUDIO_DEVICE_OUT_SPEAKER = 0x00000001,
- AUDIO_DEVICE_OUT_RECEIVER = 0x00000002,
- AUDIO_DEVICE_OUT_JACK = 0x00000004,
- AUDIO_DEVICE_OUT_BT_SCO = 0x00000008,
- AUDIO_DEVICE_OUT_AUX = 0x00000010,
- AUDIO_DEVICE_OUT_HDMI = 0x00000020,
+ AUDIO_DEVICE_OUT_SPEAKER = AUDIO_DEVICE_OUT | 0x00000001,
+ AUDIO_DEVICE_OUT_RECEIVER = AUDIO_DEVICE_OUT | 0x00000002,
+ AUDIO_DEVICE_OUT_JACK = AUDIO_DEVICE_OUT | 0x00000004,
+ AUDIO_DEVICE_OUT_BT_SCO = AUDIO_DEVICE_OUT | 0x00000008,
+ AUDIO_DEVICE_OUT_AUX = AUDIO_DEVICE_OUT | 0x00000010,
+ AUDIO_DEVICE_OUT_HDMI = AUDIO_DEVICE_OUT | 0x00000020,
AUDIO_DEVICE_OUT_ALL = (AUDIO_DEVICE_OUT_SPEAKER |
AUDIO_DEVICE_OUT_RECEIVER |
AUDIO_DEVICE_OUT_JACK |
AUDIO_DEVICE_OUT_AUX |
AUDIO_DEVICE_OUT_HDMI),
/* input devices */
- AUDIO_DEVICE_IN_MAIN_MIC = 0x80000001,
- AUDIO_DEVICE_IN_SUB_MIC = 0x80000002,
- AUDIO_DEVICE_IN_JACK = 0x80000004,
- AUDIO_DEVICE_IN_BT_SCO = 0x80000008,
+ AUDIO_DEVICE_IN_MAIN_MIC = AUDIO_DEVICE_IN | 0x00000001,
+ AUDIO_DEVICE_IN_SUB_MIC = AUDIO_DEVICE_IN | 0x00000002,
+ AUDIO_DEVICE_IN_JACK = AUDIO_DEVICE_IN | 0x00000004,
+ AUDIO_DEVICE_IN_BT_SCO = AUDIO_DEVICE_IN | 0x00000008,
AUDIO_DEVICE_IN_ALL = (AUDIO_DEVICE_IN_MAIN_MIC |
AUDIO_DEVICE_IN_SUB_MIC |
AUDIO_DEVICE_IN_JACK |
typedef enum audio_route_mode {
VERB_NORMAL,
-
-/* Add verb mode if you need */
-
-/* VERB_CALL, */
-/* VERB_VOIP */
-
} audio_route_mode_t;
typedef struct audio_hal_device {
audio_route_mode_t mode;
} audio_hal_device_t;
-
/* Stream */
#define AUDIO_VOLUME_LEVEL_MAX 16
AUDIO_SAMPLE_INVALID = -1
} audio_sample_format_t;
+typedef struct audio_hal_comm {
+ message_cb msg_cb;
+ void *user_data;
+} audio_hal_comm_t;
+
/* Overall */
typedef struct audio_hal {
audio_hal_device_t device;
audio_hal_volume_t volume;
audio_hal_ucm_t ucm;
audio_hal_mixer_t mixer;
+ audio_hal_comm_t comm;
} audio_hal_t;
typedef struct {
audio_return_t _audio_volume_init(audio_hal_t *ah);
audio_return_t _audio_volume_deinit(audio_hal_t *ah);
-
audio_return_t _audio_device_init(audio_hal_t *ah);
-audio_return_t _audio_device_deinit(audio_hal_t * ah);
+audio_return_t _audio_device_deinit(audio_hal_t *ah);
audio_return_t _audio_ucm_init(audio_hal_t *ah);
audio_return_t _audio_ucm_deinit(audio_hal_t *ah);
+audio_return_t _audio_util_init(audio_hal_t *ah);
+audio_return_t _audio_util_deinit(audio_hal_t *ah);
+audio_return_t _audio_comm_init(audio_hal_t *ah);
+audio_return_t _audio_comm_deinit(audio_hal_t *ah);
+
void _audio_ucm_get_device_name(audio_hal_t *ah, const char *use_case, audio_direction_t direction, const char **value);
#define _audio_ucm_update_use_case _audio_ucm_set_use_case
audio_return_t _audio_ucm_set_use_case(audio_hal_t *ah, const char *verb, const char *devices[], const char *modifiers[]);
int _audio_ucm_fill_device_info_list(audio_hal_t *ah, audio_device_info_t *device_info_list, const char *verb);
audio_return_t _audio_ucm_get_verb(audio_hal_t *ah, const char **value);
audio_return_t _audio_ucm_reset_use_case(audio_hal_t *ah);
-audio_return_t _audio_util_init(audio_hal_t *ah);
-audio_return_t _audio_util_deinit(audio_hal_t *ah);
audio_return_t _audio_mixer_control_set_param(audio_hal_t *ah, const char* ctl_name, snd_ctl_elem_value_t* value, int size);
audio_return_t _audio_mixer_control_set_value(audio_hal_t *ah, const char *ctl_name, int val);
audio_return_t _audio_mixer_control_set_value_string(audio_hal_t *ah, const char* ctl_name, const char* value);
audio_return_t _audio_mixer_control_get_value(audio_hal_t *ah, const char *ctl_name, int *val);
audio_return_t _audio_mixer_control_get_element(audio_hal_t *ah, const char *ctl_name, snd_hctl_elem_t **elem);
+audio_return_t _audio_comm_send_message(audio_hal_t *ah, const char *name, int value);
+audio_return_t _audio_comm_set_message_callback(audio_hal_t *ah, message_cb callback, void *user_data);
+audio_return_t _audio_comm_unset_message_callback(audio_hal_t *ah);
audio_return_t _audio_pcm_set_sw_params(snd_pcm_t *pcm, snd_pcm_uframes_t avail_min, uint8_t period_event);
audio_return_t _audio_pcm_set_hw_params(snd_pcm_t *pcm, audio_pcm_sample_spec_t *sample_spec, uint8_t *use_mmap, snd_pcm_uframes_t *period_size, snd_pcm_uframes_t *buffer_size);
uint32_t _convert_format(audio_sample_format_t format);
static const char* AUDIO_LATENCY_HIGH = "high";
static const char* AUDIO_LATENCY_VOIP = "voip";
+audio_return_t audio_set_message_cb(void *audio_handle, message_cb callback, void *user_data)
+{
+ audio_return_t ret = AUDIO_RET_OK;
+
+ AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(callback, AUDIO_ERR_PARAMETER);
+
+ ret = _audio_comm_set_message_callback((audio_hal_t *)audio_handle, callback, user_data);
+
+ return ret;
+}
+
audio_return_t audio_init(void **audio_handle)
{
audio_hal_t *ah;
AUDIO_LOG_ERROR("mixer init failed");
goto error_exit;
}
+ if (AUDIO_IS_ERROR((ret = _audio_comm_init(ah)))) {
+ AUDIO_LOG_ERROR("comm init failed");
+ goto error_exit;
+ }
*audio_handle = (void *)ah;
return AUDIO_RET_OK;
_audio_volume_deinit(ah);
_audio_ucm_deinit(ah);
_audio_util_deinit(ah);
+ _audio_comm_deinit(ah);
free(ah);
ah = NULL;
AUDIO_ERR_RESOURCE = (int32_t)0x80001001,
AUDIO_ERR_PARAMETER = (int32_t)0x80001002,
AUDIO_ERR_IOCTL = (int32_t)0x80001003,
- AUDIO_ERR_NOT_IMPLEMENTED = (int32_t)0x80001004,
+ AUDIO_ERR_INVALID_STATE = (int32_t)0x80001004,
+ AUDIO_ERR_INTERNAL = (int32_t)0x80001005,
+
+ AUDIO_ERR_NOT_IMPLEMENTED = (int32_t)0x80001100,
} audio_return_t ;
typedef enum audio_direction {
uint32_t idx;
} audio_stream_info_t ;
+typedef void (*message_cb)(const char *name, int value, void *user_data);
+
/* Overall */
typedef struct audio_interface {
audio_return_t (*init)(void **audio_handle);
audio_return_t (*deinit)(void *audio_handle);
+ /* Volume */
audio_return_t (*get_volume_level_max)(void *audio_handle, audio_volume_info_t *info, uint32_t *level);
audio_return_t (*get_volume_level)(void *audio_handle, audio_volume_info_t *info, uint32_t *level);
audio_return_t (*set_volume_level)(void *audio_handle, audio_volume_info_t *info, uint32_t level);
audio_return_t (*get_volume_value)(void *audio_handle, audio_volume_info_t *info, uint32_t level, double *value);
audio_return_t (*get_volume_mute)(void *audio_handle, audio_volume_info_t *info, uint32_t *mute);
audio_return_t (*set_volume_mute)(void *audio_handle, audio_volume_info_t *info, uint32_t mute);
+ /* Routing */
audio_return_t (*do_route)(void *audio_handle, audio_route_info_t *info);
audio_return_t (*update_route_option)(void *audio_handle, audio_route_option_t *option);
audio_return_t (*update_stream_connection_info) (void *audio_handle, audio_stream_info_t *info, uint32_t is_connected);
+ /* Buffer Attribute */
audio_return_t (*get_buffer_attr)(void *audio_handle, uint32_t direction, const char *latency, uint32_t samplerate, int format, uint32_t channels,
uint32_t *maxlength, uint32_t *tlength, uint32_t *prebuf, uint32_t* minreq, uint32_t *fragsize);
/* Interface of PCM device */
audio_return_t (*pcm_recover)(void *audio_handle, void *pcm_handle, int revents);
audio_return_t (*pcm_get_params)(void *audio_handle, void *pcm_handle, uint32_t direction, void **sample_spec, uint32_t *period_size, uint32_t *periods);
audio_return_t (*pcm_set_params)(void *audio_handle, void *pcm_handle, uint32_t direction, void *sample_spec, uint32_t period_size, uint32_t periods);
+ /* Message callback */
+ audio_return_t (*set_message_cb)(void *audio_handle, message_cb callback, void *user_data);
} audio_interface_t;
audio_return_t audio_init(void **audio_handle);
audio_return_t audio_pcm_recover(void *audio_handle, void *pcm_handle, int revents);
audio_return_t audio_pcm_get_params(void *audio_handle, void *pcm_handle, uint32_t direction, void **sample_spec, uint32_t *period_size, uint32_t *periods);
audio_return_t audio_pcm_set_params(void *audio_handle, void *pcm_handle, uint32_t direction, void *sample_spec, uint32_t period_size, uint32_t periods);
+audio_return_t audio_set_message_cb(void *audio_handle, message_cb callback, void *user_data);
#endif
projects / platform / adaptation / samsung_exynos / audio-hal-wm1831.git / commitdiff