Name: audio-hal-sc7727
Summary: TIZEN Audio HAL for SC7727
-Version: 0.1.0
+Version: 0.1.1
Release: 0
Group: System/Libraries
License: Apache-2.0
return device;
}
-static audio_return_t set_devices(audio_mgr_t *am, const char *verb, device_info_t *devices, uint32_t num_of_devices)
+static audio_return_t set_devices(audio_hal_t *ah, const char *verb, device_info_t *devices, uint32_t num_of_devices)
{
audio_return_t audio_ret = AUDIO_RET_OK;
uint32_t new_device = 0;
const char *active_devices[MAX_DEVICES] = {NULL,};
int i = 0, j = 0, dev_idx = 0;
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(devices, AUDIO_ERR_PARAMETER);
+
if (num_of_devices > MAX_DEVICES) {
num_of_devices = MAX_DEVICES;
AUDIO_LOG_ERROR("error: num_of_devices");
return AUDIO_ERR_PARAMETER;
}
- if ((devices[0].direction == AUDIO_DIRECTION_OUT) && am->device.active_in) {
+ 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 (((am->device.active_in & (~0x80000000)) & inDeviceTypes[j].type))
+ if (((ah->device.active_in & (~0x80000000)) & inDeviceTypes[j].type))
active_devices[dev_idx++] = inDeviceTypes[j].name;
}
- } else if ((devices[0].direction == AUDIO_DIRECTION_IN) && am->device.active_out) {
+ } 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 (am->device.active_out & outDeviceTypes[j].type)
+ if (ah->device.active_out & outDeviceTypes[j].type)
active_devices[dev_idx++] = outDeviceTypes[j].name;
}
}
for (j = 0; j < inDeviceTypes[j].type; j++) {
if (new_device == inDeviceTypes[j].type) {
active_devices[dev_idx++] = inDeviceTypes[j].name;
- am->device.active_in |= new_device;
+ ah->device.active_in |= new_device;
}
}
} else {
for (j = 0; j < outDeviceTypes[j].type; j++) {
if (new_device == outDeviceTypes[j].type) {
active_devices[dev_idx++] = outDeviceTypes[j].name;
- am->device.active_out |= new_device;
+ ah->device.active_out |= new_device;
}
}
}
return AUDIO_ERR_PARAMETER;
}
- audio_ret = _audio_ucm_set_devices(am, verb, active_devices);
+ audio_ret = _audio_ucm_set_devices(ah, verb, active_devices);
if (audio_ret) {
AUDIO_LOG_ERROR("Failed to set device: error = %d", audio_ret);
return audio_ret;
}
-audio_return_t _audio_device_init (audio_mgr_t *am)
+audio_return_t _audio_device_init(audio_hal_t *ah)
{
- AUDIO_RETURN_VAL_IF_FAIL(am, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
- am->device.active_in = 0x0;
- am->device.active_out = 0x0;
- am->device.pcm_in = NULL;
- am->device.pcm_out = NULL;
- am->device.mode = VERB_NORMAL;
- pthread_mutex_init(&am->device.pcm_lock, NULL);
- am->device.pcm_count = 0;
+ ah->device.active_in = 0x0;
+ ah->device.active_out = 0x0;
+ ah->device.pcm_in = NULL;
+ ah->device.pcm_out = NULL;
+ ah->device.mode = VERB_NORMAL;
+ pthread_mutex_init(&ah->device.pcm_lock, NULL);
+ ah->device.pcm_count = 0;
return AUDIO_RET_OK;
}
-audio_return_t _audio_device_deinit (audio_mgr_t *am)
+audio_return_t _audio_device_deinit(audio_hal_t *ah)
{
- AUDIO_RETURN_VAL_IF_FAIL(am, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
return AUDIO_RET_OK;
}
-static audio_return_t _do_route_ap_playback_capture (audio_mgr_t *am, audio_route_info_t *route_info)
+static audio_return_t _do_route_ap_playback_capture(audio_hal_t *ah, audio_route_info_t *route_info)
{
audio_return_t audio_ret = AUDIO_RET_OK;
- device_info_t *devices = route_info->device_infos;
+ device_info_t *devices = NULL;
const char *verb = NULL;
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(route_info, AUDIO_ERR_PARAMETER);
+
+ devices = route_info->device_infos;
+
/* To Do: Set modifiers */
/* 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_RETURN_VAL_IF_FAIL(am, AUDIO_ERR_PARAMETER);
- audio_ret = set_devices(am, verb, devices, route_info->num_of_devices);
+ audio_ret = set_devices(ah, verb, devices, route_info->num_of_devices);
if (audio_ret) {
AUDIO_LOG_ERROR("Failed to set devices: error = 0x%x", audio_ret);
return audio_ret;
}
- am->device.mode = VERB_NORMAL;
+ ah->device.mode = VERB_NORMAL;
/* To Do: Set modifiers */
/*
if (!strncmp("voice_recognition", route_info->role, MAX_NAME_LEN)) {
modifiers[mod_idx++] = AUDIO_USE_CASE_MODIFIER_VOICESEARCH;
} else if ((!strncmp("alarm", route_info->role, MAX_NAME_LEN))||(!strncmp("notifiication", route_info->role, MAX_NAME_LEN))) {
- if (am->device.active_out &= AUDIO_DEVICE_OUT_JACK)
+ if (ah->device.active_out &= AUDIO_DEVICE_OUT_JACK)
modifiers[mod_idx++] = AUDIO_USE_CASE_MODIFIER_DUAL_MEDIA;
else
modifiers[mod_idx++] = AUDIO_USE_CASE_MODIFIER_MEDIA;
} else if (!strncmp("ringtone", route_info->role, MAX_NAME_LEN)) {
- if (am->device.active_out &= AUDIO_DEVICE_OUT_JACK)
+ if (ah->device.active_out &= AUDIO_DEVICE_OUT_JACK)
modifiers[mod_idx++] = AUDIO_USE_CASE_MODIFIER_DUAL_RINGTONE;
else
modifiers[mod_idx++] = AUDIO_USE_CASE_MODIFIER_RINGTONE;
} else {
- if (am->device.active_in)
+ if (ah->device.active_in)
modifiers[mod_idx++] = AUDIO_USE_CASE_MODIFIER_CAMCORDING;
else
modifiers[mod_idx++] = AUDIO_USE_CASE_MODIFIER_MEDIA;
}
- audio_ret = _audio_ucm_set_modifiers (am, verb, modifiers);
+ audio_ret = _audio_ucm_set_modifiers (ah, verb, modifiers);
*/
return audio_ret;
}
-audio_return_t _do_route_voicecall (audio_mgr_t *am, device_info_t *devices, int32_t num_of_devices)
+audio_return_t _do_route_voicecall(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_VOICECALL;
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(devices, AUDIO_ERR_PARAMETER);
+
AUDIO_LOG_INFO("do_route_voicecall++");
- AUDIO_RETURN_VAL_IF_FAIL(am, AUDIO_ERR_PARAMETER);
- audio_ret = set_devices(am, verb, devices, num_of_devices);
+ audio_ret = set_devices(ah, verb, devices, num_of_devices);
if (audio_ret) {
AUDIO_LOG_ERROR("Failed to set devices: error = 0x%x", audio_ret);
return audio_ret;
}
/* FIXME. Get network info and configure rate in pcm device */
- am->device.mode = VERB_CALL;
- if (am->device.active_out && am->device.active_in)
- _voice_pcm_open(am);
+ ah->device.mode = VERB_CALL;
+ if (ah->device.active_out && ah->device.active_in)
+ _voice_pcm_open(ah);
return audio_ret;
}
-audio_return_t _do_route_voip (audio_mgr_t *am, device_info_t *devices, int32_t num_of_devices)
+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;
const char *active_devices[MAX_DEVICES] = {NULL,};
verb = AUDIO_USE_CASE_VERB_HIFI;
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(devices, AUDIO_ERR_PARAMETER);
+
AUDIO_LOG_INFO("do_route_voip++");
- AUDIO_RETURN_VAL_IF_FAIL(am, AUDIO_ERR_PARAMETER);
- audio_ret = set_devices(am, verb, devices, num_of_devices);
+
+ audio_ret = set_devices(ah, verb, devices, num_of_devices);
if (audio_ret) {
AUDIO_LOG_ERROR("Failed to set devices: error = 0x%x", audio_ret);
return audio_ret;
}
/* FIXME. If necessary, set VERB_VOIP */
- am->device.mode = VERB_NORMAL;
+ ah->device.mode = VERB_NORMAL;
if (active_devices == NULL) {
AUDIO_LOG_ERROR("Failed to set device: active device is NULL");
return AUDIO_ERR_PARAMETER;
return audio_ret;
}
-audio_return_t _do_route_reset (audio_mgr_t *am, uint32_t direction)
+audio_return_t _do_route_reset(audio_hal_t *ah, uint32_t direction)
{
audio_return_t audio_ret = AUDIO_RET_OK;
/* const char *verb = NULL; */
/* verb = AUDIO_USE_CASE_VERB_INACTIVE; */
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+
AUDIO_LOG_INFO("do_route_reset++, direction(%p)", direction);
- AUDIO_RETURN_VAL_IF_FAIL(am, AUDIO_ERR_PARAMETER);
if (direction == AUDIO_DIRECTION_OUT) {
- am->device.active_out &= 0x0;
+ ah->device.active_out &= 0x0;
} else {
- am->device.active_in &= 0x0;
+ ah->device.active_in &= 0x0;
}
- if (am->device.mode == VERB_CALL) {
- _voice_pcm_close(am, direction);
+ if (ah->device.mode == VERB_CALL) {
+ _voice_pcm_close(ah, direction);
}
/* TO DO: Set Inactive */
return audio_ret;
}
-audio_return_t audio_do_route (void *userdata, audio_route_info_t *info)
+audio_return_t audio_do_route(void *audio_handle, audio_route_info_t *info)
{
audio_return_t audio_ret = AUDIO_RET_OK;
- audio_mgr_t *am = (audio_mgr_t *)userdata;
- device_info_t *devices = info->device_infos;
+ audio_hal_t *ah = (audio_hal_t *)audio_handle;
+ device_info_t *devices = NULL;
- AUDIO_RETURN_VAL_IF_FAIL(am, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(info, AUDIO_ERR_PARAMETER);
AUDIO_LOG_INFO("role:%s", info->role);
+ devices = info->device_infos;
+
if (!strncmp("call-voice", info->role, MAX_NAME_LEN)) {
- audio_ret = _do_route_voicecall(am, devices, info->num_of_devices);
+ audio_ret = _do_route_voicecall(ah, devices, info->num_of_devices);
if (AUDIO_IS_ERROR(audio_ret)) {
AUDIO_LOG_WARN("set voicecall route return 0x%x", audio_ret);
}
} else if (!strncmp("voip", info->role, MAX_NAME_LEN)) {
- audio_ret = _do_route_voip(am, devices, info->num_of_devices);
+ audio_ret = _do_route_voip(ah, devices, info->num_of_devices);
if (AUDIO_IS_ERROR(audio_ret)) {
AUDIO_LOG_WARN("set voip route return 0x%x", audio_ret);
}
} else if (!strncmp("reset", info->role, MAX_NAME_LEN)) {
- audio_ret = _do_route_reset(am, devices->direction);
+ audio_ret = _do_route_reset(ah, devices->direction);
if (AUDIO_IS_ERROR(audio_ret)) {
AUDIO_LOG_WARN("set reset return 0x%x", audio_ret);
}
} else {
/* need to prepare for "alarm","notification","emergency","voice-information","voice-recognition","ringtone" */
- audio_ret = _do_route_ap_playback_capture(am, info);
+ 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);
return audio_ret;
}
-audio_return_t audio_update_stream_connection_info (void *userdata, audio_stream_info_t *info, uint32_t is_connected)
+audio_return_t audio_update_stream_connection_info(void *audio_handle, audio_stream_info_t *info, uint32_t is_connected)
{
audio_return_t audio_ret = AUDIO_RET_OK;
- audio_mgr_t *am = (audio_mgr_t *)userdata;
+ audio_hal_t *ah = (audio_hal_t *)audio_handle;
- AUDIO_RETURN_VAL_IF_FAIL(am, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(info, AUDIO_ERR_PARAMETER);
AUDIO_LOG_INFO("role:%s, direction:%u, idx:%u, is_connected:%d", info->role, info->direction, info->idx, is_connected);
return audio_ret;
}
-audio_return_t audio_update_route_option (void *userdata, audio_route_option_t *option)
+audio_return_t audio_update_route_option(void *audio_handle, audio_route_option_t *option)
{
audio_return_t audio_ret = AUDIO_RET_OK;
- audio_mgr_t *am = (audio_mgr_t *)userdata;
+ audio_hal_t *ah = (audio_hal_t *)audio_handle;
- AUDIO_RETURN_VAL_IF_FAIL(am, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(option, AUDIO_ERR_PARAMETER);
AUDIO_LOG_INFO("role:%s, name:%s, value:%d", option->role, option->name, option->value);
return audio_ret;
}
-static int __voice_pcm_set_params (audio_mgr_t *am, snd_pcm_t *pcm)
+static int __voice_pcm_set_params(audio_hal_t *ah, snd_pcm_t *pcm)
{
snd_pcm_hw_params_t *params = NULL;
int err = 0;
unsigned int val = 0;
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(pcm, AUDIO_ERR_PARAMETER);
+
/* Skip parameter setting to null device. */
if (snd_pcm_type(pcm) == SND_PCM_TYPE_NULL)
return AUDIO_ERR_IOCTL;
return -1;
}
-int _voice_pcm_open (audio_mgr_t *am)
+int _voice_pcm_open(audio_hal_t *ah)
{
int err, ret = 0;
+
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+
AUDIO_LOG_INFO("open voice pcm handles");
/* Get playback voice-pcm from ucm conf. Open and set-params */
- if ((err = snd_pcm_open((void **)&am->device.pcm_out, VOICE_PCM_DEVICE, AUDIO_DIRECTION_OUT, 0)) < 0) {
+ if ((err = snd_pcm_open((snd_pcm_t **)&ah->device.pcm_out, VOICE_PCM_DEVICE, AUDIO_DIRECTION_OUT, 0)) < 0) {
AUDIO_LOG_ERROR("snd_pcm_open for %s failed. %s", VOICE_PCM_DEVICE, snd_strerror(err));
return AUDIO_ERR_IOCTL;
}
- ret = __voice_pcm_set_params(am, am->device.pcm_out);
+ ret = __voice_pcm_set_params(ah, ah->device.pcm_out);
AUDIO_LOG_INFO("pcm playback device open success device(%s)", VOICE_PCM_DEVICE);
/* Get capture voice-pcm from ucm conf. Open and set-params */
- if ((err = snd_pcm_open((void **)&am->device.pcm_in, VOICE_PCM_DEVICE, AUDIO_DIRECTION_IN, 0)) < 0) {
+ if ((err = snd_pcm_open((snd_pcm_t **)&ah->device.pcm_in, VOICE_PCM_DEVICE, AUDIO_DIRECTION_IN, 0)) < 0) {
AUDIO_LOG_ERROR("snd_pcm_open for %s failed. %s", VOICE_PCM_DEVICE, snd_strerror(err));
return AUDIO_ERR_IOCTL;
}
- ret = __voice_pcm_set_params(am, am->device.pcm_in);
+ ret = __voice_pcm_set_params(ah, ah->device.pcm_in);
AUDIO_LOG_INFO("pcm captures device open success device(%s)", VOICE_PCM_DEVICE);
return ret;
}
-int _voice_pcm_close (audio_mgr_t *am, uint32_t direction)
+int _voice_pcm_close(audio_hal_t *ah, uint32_t direction)
{
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+
AUDIO_LOG_INFO("close voice pcm handles");
- if (am->device.pcm_out && (direction == AUDIO_DIRECTION_OUT)) {
- audio_pcm_close((void *)am, am->device.pcm_out);
- am->device.pcm_out = NULL;
+ if (ah->device.pcm_out && (direction == AUDIO_DIRECTION_OUT)) {
+ audio_pcm_close((void *)ah, ah->device.pcm_out);
+ ah->device.pcm_out = NULL;
AUDIO_LOG_INFO("voice pcm_out handle close success");
- } else if (am->device.pcm_in && (direction == AUDIO_DIRECTION_IN)) {
- audio_pcm_close((void *)am, am->device.pcm_in);
- am->device.pcm_in = NULL;
+ } else if (ah->device.pcm_in && (direction == AUDIO_DIRECTION_IN)) {
+ audio_pcm_close((void *)ah, ah->device.pcm_in);
+ ah->device.pcm_in = NULL;
AUDIO_LOG_INFO("voice pcm_in handle close success");
}
}
#ifdef __USE_TINYALSA__
-static struct pcm *__tinyalsa_open_device (audio_pcm_sample_spec_t *ss, size_t period_size, size_t period_count, uint32_t direction)
+static struct pcm *__tinyalsa_open_device(audio_pcm_sample_spec_t *ss, size_t period_size, size_t period_count, uint32_t direction)
{
struct pcm *pcm = NULL;
struct pcm_config config;
+ AUDIO_RETURN_NULL_IF_FAIL(ss);
+
config.channels = ss->channels;
config.rate = ss->rate;
config.period_size = period_size;
}
#endif
-audio_return_t audio_pcm_open (void *userdata, void **pcm_handle, uint32_t direction, void *sample_spec, uint32_t period_size, uint32_t periods)
+audio_return_t audio_pcm_open(void *audio_handle, void **pcm_handle, uint32_t direction, void *sample_spec, uint32_t period_size, uint32_t periods)
{
#ifdef __USE_TINYALSA__
- audio_mgr_t *am;
+ audio_hal_t *ah;
audio_pcm_sample_spec_t *ss;
int err;
- AUDIO_RETURN_VAL_IF_FAIL(userdata, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(sample_spec, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL((period_size > 0), AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL((periods > 0), AUDIO_ERR_PARAMETER);
- am = (audio_mgr_t *)userdata;
+ ah = (audio_hal_t *)audio_handle;
ss = (audio_pcm_sample_spec_t *)sample_spec;
ss->format = _convert_format((audio_sample_format_t)ss->format);
AUDIO_LOG_ERROR("Error prepare PCM device : %d", err);
}
- am->device.pcm_count++;
+ ah->device.pcm_count++;
AUDIO_LOG_INFO("Opening PCM handle 0x%x", *pcm_handle);
#else /* alsa-lib */
- audio_mgr_t *am;
+ audio_hal_t *ah;
int err, mode;
char *device_name = NULL;
- uint8_t use_mmap = 0;
- snd_pcm_uframes_t buffer_size;
- AUDIO_RETURN_VAL_IF_FAIL(userdata, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(sample_spec, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL((period_size > 0), AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL((periods > 0), AUDIO_ERR_PARAMETER);
- am = (audio_mgr_t *)userdata;
+ ah = (audio_hal_t *)audio_handle;
mode = SND_PCM_NONBLOCK | SND_PCM_NO_AUTO_RESAMPLE | SND_PCM_NO_AUTO_CHANNELS | SND_PCM_NO_AUTO_FORMAT;
- buffer_size = (snd_pcm_uframes_t)(period_size * periods);
if(direction == AUDIO_DIRECTION_OUT)
device_name = PLAYBACK_PCM_DEVICE;
return AUDIO_ERR_RESOURCE;
}
- if ((err = audio_pcm_set_params(userdata, *pcm_handle, direction, sample_spec, period_size, periods)) != AUDIO_RET_OK) {
+ if ((err = audio_pcm_set_params(audio_handle, *pcm_handle, direction, sample_spec, period_size, periods)) != AUDIO_RET_OK) {
AUDIO_LOG_ERROR("Failed to set pcm parameters : %d", err);
return err;
}
- am->device.pcm_count++;
+ ah->device.pcm_count++;
AUDIO_LOG_INFO("Opening PCM handle 0x%x, PCM device %s", *pcm_handle, device_name);
#endif
return AUDIO_RET_OK;
}
-audio_return_t audio_pcm_start (void *userdata, void *pcm_handle)
+audio_return_t audio_pcm_start(void *audio_handle, void *pcm_handle)
{
int err;
+ AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
+
#ifdef __USE_TINYALSA__
if ((err = pcm_start(pcm_handle)) < 0) {
AUDIO_LOG_ERROR("Error starting PCM handle : %d", err);
return AUDIO_RET_OK;
}
-audio_return_t audio_pcm_stop (void *userdata, void *pcm_handle)
+audio_return_t audio_pcm_stop(void *audio_handle, void *pcm_handle)
{
int err;
+ AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
+
#ifdef __USE_TINYALSA__
if ((err = pcm_stop(pcm_handle)) < 0) {
AUDIO_LOG_ERROR("Error stopping PCM handle : %d", err);
return AUDIO_RET_OK;
}
-audio_return_t audio_pcm_close (void *userdata, void *pcm_handle)
+audio_return_t audio_pcm_close(void *audio_handle, void *pcm_handle)
{
- audio_mgr_t *am = (audio_mgr_t *)userdata;
+ audio_hal_t *ah = (audio_hal_t *)audio_handle;
int err;
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
+
AUDIO_LOG_INFO("Try to close PCM handle 0x%x", pcm_handle);
#ifdef __USE_TINYALSA__
#endif
pcm_handle = NULL;
- am->device.pcm_count--;
- AUDIO_LOG_INFO("PCM handle close success (count:%d)", am->device.pcm_count);
+ ah->device.pcm_count--;
+ AUDIO_LOG_INFO("PCM handle close success (count:%d)", ah->device.pcm_count);
return AUDIO_RET_OK;
}
-audio_return_t audio_pcm_avail (void *userdata, void *pcm_handle, uint32_t *avail)
+audio_return_t audio_pcm_avail(void *audio_handle, void *pcm_handle, uint32_t *avail)
{
#ifdef __USE_TINYALSA__
struct timespec tspec;
unsigned int frames_avail = 0;
int err;
+ AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(avail, AUDIO_ERR_PARAMETER);
#else /* alsa-lib */
snd_pcm_sframes_t frames_avail;
+ AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(avail, AUDIO_ERR_PARAMETER);
return AUDIO_RET_OK;
}
-audio_return_t audio_pcm_write (void *userdata, void *pcm_handle, const void *buffer, uint32_t frames)
+audio_return_t audio_pcm_write(void *audio_handle, void *pcm_handle, const void *buffer, uint32_t frames)
{
#ifdef __USE_TINYALSA__
int err;
+ AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
err = pcm_write(pcm_handle, buffer, pcm_frames_to_bytes(pcm_handle, (unsigned int)frames));
return AUDIO_RET_OK;
}
-audio_return_t audio_pcm_read (void *userdata, void *pcm_handle, void *buffer, uint32_t frames)
+audio_return_t audio_pcm_read(void *audio_handle, void *pcm_handle, void *buffer, uint32_t frames)
{
#ifdef __USE_TINYALSA__
int err;
+ AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
err = pcm_read(pcm_handle, buffer, pcm_frames_to_bytes(pcm_handle, (unsigned int)frames));
#else /* alsa-lib */
snd_pcm_sframes_t frames_read;
+ AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
frames_read = snd_pcm_readi(pcm_handle, buffer, (snd_pcm_uframes_t)frames);
return AUDIO_RET_OK;
}
-audio_return_t audio_pcm_get_fd(void *userdata, void *pcm_handle, int *fd)
+audio_return_t audio_pcm_get_fd(void *audio_handle, void *pcm_handle, int *fd)
{
+ AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(fd, AUDIO_ERR_PARAMETER);
+ /* we use an internal API of the (tiny)alsa library, so it causes warning message during compile */
#ifdef __USE_TINYALSA__
*fd = _pcm_poll_descriptor((struct pcm *)pcm_handle);
#else /* alsa-lib */
}
#endif
-audio_return_t audio_pcm_recover(void *userdata, void *pcm_handle, int revents)
+audio_return_t audio_pcm_recover(void *audio_handle, void *pcm_handle, int revents)
{
int state, err;
+ AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
if (revents & POLLERR)
return AUDIO_RET_OK;
}
-audio_return_t audio_pcm_get_params(void *userdata, void *pcm_handle, uint32_t direction, void **sample_spec, uint32_t *period_size, uint32_t *periods)
+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)
{
#ifdef __USE_TINYALSA__
audio_pcm_sample_spec_t *ss;
unsigned int _start_threshold, _stop_threshold, _silence_threshold;
struct pcm_config *config;
+ AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(sample_spec, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(period_size, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(periods, AUDIO_ERR_PARAMETER);
ss = (audio_pcm_sample_spec_t *)*sample_spec;
+ /* we use an internal API of the tiny alsa library, so it causes warning message during compile */
_pcm_config(pcm_handle, &config);
*period_size = config->period_size;
snd_pcm_hw_params_t *hwparams;
snd_pcm_sw_params_t *swparams;
+ AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(sample_spec, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(period_size, AUDIO_ERR_PARAMETER);
return AUDIO_RET_OK;
}
-audio_return_t audio_pcm_set_params(void *userdata, 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)
{
#ifdef __USE_TINYALSA__
/* Parameters are only acceptable in pcm_open() function */
snd_pcm_hw_params_t *hwparams;
snd_pcm_sw_params_t *swparams;
+ AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(sample_spec, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(period_size, AUDIO_ERR_PARAMETER);
return AUDIO_ERR_PARAMETER;
}
- if ((err = snd_pcm_hw_params_set_rate(pcm_handle, hwparams, ss.rate, NULL)) < 0) {
+ if ((err = snd_pcm_hw_params_set_rate(pcm_handle, hwparams, ss.rate, 0)) < 0) {
AUDIO_LOG_ERROR("snd_pcm_hw_params_set_rate() failed : %d", err);
return AUDIO_ERR_PARAMETER;
}
return val; \
} \
} while (0)
+#define AUDIO_RETURN_NULL_IF_FAIL(expr) do { \
+ if (!expr) { \
+ AUDIO_LOG_ERROR("%s failed", #expr); \
+ return NULL; \
+ } \
+} while (0)
/* Devices : Normal */
enum audio_device_type {
} audio_pcm_sample_spec_t;
/* Device */
-typedef enum audio_route_mode{
+typedef enum audio_device_api {
+ AUDIO_DEVICE_API_UNKNOWN,
+ AUDIO_DEVICE_API_ALSA,
+ AUDIO_DEVICE_API_BLUEZ,
+} audio_device_api_t;
+
+typedef struct audio_device_alsa_info {
+ char *card_name;
+ uint32_t card_idx;
+ uint32_t device_idx;
+} audio_device_alsa_info_t;
+
+typedef struct audio_device_bluz_info {
+ char *protocol;
+ uint32_t nrec;
+} audio_device_bluez_info_t;
+
+typedef struct audio_device_info {
+ audio_device_api_t api;
+ audio_direction_t direction;
+ char *name;
+ uint8_t is_default_device;
+ union {
+ audio_device_alsa_info_t alsa;
+ audio_device_bluez_info_t bluez;
+ };
+} audio_device_info_t;
+
+typedef enum audio_route_mode {
VERB_NORMAL,
VERB_CALL,
VERB_VOIP
} audio_route_mode_t;
-typedef struct audio_device_mgr {
+typedef struct audio_hal_device {
uint32_t active_in;
uint32_t active_out;
snd_pcm_t *pcm_in;
pthread_mutex_t pcm_lock;
uint32_t pcm_count;
audio_route_mode_t mode;
-} audio_device_mgr_t;
+} audio_hal_device_t;
/* Stream */
-
#define AUDIO_VOLUME_LEVEL_MAX 16
+typedef enum audio_volume {
+ AUDIO_VOLUME_TYPE_SYSTEM, /**< System volume type */
+ AUDIO_VOLUME_TYPE_NOTIFICATION, /**< Notification volume type */
+ AUDIO_VOLUME_TYPE_ALARM, /**< Alarm volume type */
+ AUDIO_VOLUME_TYPE_RINGTONE, /**< Ringtone volume type */
+ AUDIO_VOLUME_TYPE_MEDIA, /**< Media volume type */
+ AUDIO_VOLUME_TYPE_CALL, /**< Call volume type */
+ AUDIO_VOLUME_TYPE_VOIP, /**< VOIP volume type */
+ AUDIO_VOLUME_TYPE_VOICE, /**< Voice volume type */
+ AUDIO_VOLUME_TYPE_MAX, /**< Volume type count */
+} audio_volume_t;
+
+typedef enum audio_gain {
+ AUDIO_GAIN_TYPE_DEFAULT,
+ AUDIO_GAIN_TYPE_DIALER,
+ AUDIO_GAIN_TYPE_TOUCH,
+ AUDIO_GAIN_TYPE_AF,
+ AUDIO_GAIN_TYPE_SHUTTER1,
+ AUDIO_GAIN_TYPE_SHUTTER2,
+ AUDIO_GAIN_TYPE_CAMCODING,
+ AUDIO_GAIN_TYPE_MIDI,
+ AUDIO_GAIN_TYPE_BOOTING,
+ AUDIO_GAIN_TYPE_VIDEO,
+ AUDIO_GAIN_TYPE_TTS,
+ AUDIO_GAIN_TYPE_MAX,
+} audio_gain_t;
+
typedef struct audio_volume_value_table {
double volume[AUDIO_VOLUME_TYPE_MAX][AUDIO_VOLUME_LEVEL_MAX];
uint32_t volume_level_max[AUDIO_VOLUME_LEVEL_MAX];
AUDIO_VOLUME_DEVICE_MAX,
};
-typedef struct audio_volume_mgr {
+typedef struct audio_hal_volume {
uint32_t volume_level[AUDIO_VOLUME_TYPE_MAX];
audio_volume_value_table_t *volume_value_table;
-} audio_volume_mgr_t;
+} audio_hal_volume_t;
-typedef struct audio_ucm_mgr {
+typedef struct audio_hal_ucm {
snd_use_case_mgr_t* uc_mgr;
-} audio_ucm_mgr_t;
+} audio_hal_ucm_t;
-typedef struct audio_mixer_mgr {
+typedef struct audio_hal_mixer {
snd_mixer_t *mixer;
pthread_mutex_t mutex;
struct {
snd_ctl_elem_id_t *id;
snd_ctl_elem_info_t *info;
} control;
-} audio_mixer_mgr_t;
+} audio_hal_mixer_t;
+
+/* Audio format */
+typedef enum audio_sample_format {
+ AUDIO_SAMPLE_U8,
+ AUDIO_SAMPLE_ALAW,
+ AUDIO_SAMPLE_ULAW,
+ AUDIO_SAMPLE_S16LE,
+ AUDIO_SAMPLE_S16BE,
+ AUDIO_SAMPLE_FLOAT32LE,
+ AUDIO_SAMPLE_FLOAT32BE,
+ AUDIO_SAMPLE_S32LE,
+ AUDIO_SAMPLE_S32BE,
+ AUDIO_SAMPLE_S24LE,
+ AUDIO_SAMPLE_S24BE,
+ AUDIO_SAMPLE_S24_32LE,
+ AUDIO_SAMPLE_S24_32BE,
+ AUDIO_SAMPLE_MAX,
+ AUDIO_SAMPLE_INVALID = -1
+} audio_sample_format_t;
/* Overall */
-
-typedef struct audio_mgr {
- audio_device_mgr_t device;
- audio_volume_mgr_t volume;
- audio_ucm_mgr_t ucm;
- audio_mixer_mgr_t mixer;
-} audio_mgr_t;
+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_t;
typedef struct {
unsigned short is_open; /* if is_open is true, open device; else close device.*/
unsigned int samplerate; /* change samplerate.*/
} set_samplerate_t;
-audio_return_t _audio_volume_init (audio_mgr_t *am);
-audio_return_t _audio_volume_deinit (audio_mgr_t *am);
+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_mgr_t *am);
-audio_return_t _audio_device_deinit (audio_mgr_t * am);
-audio_return_t _audio_ucm_init (audio_mgr_t *am);
-audio_return_t _audio_ucm_deinit (audio_mgr_t *am);
-void _audio_ucm_get_device_name (audio_mgr_t *am, const char *use_case, audio_direction_t direction, const char **value);
+audio_return_t _audio_device_init(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);
+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_mgr_t *am, const char *verb, const char *devices[], const char *modifiers[]);
-audio_return_t _audio_ucm_set_devices (audio_mgr_t *am, const char *verb, const char *devices[]);
-audio_return_t _audio_ucm_set_modifiers (audio_mgr_t *am, const char *verb, const char *modifiers[]);
-int _audio_ucm_fill_device_info_list (audio_mgr_t *am, audio_device_info_t *device_info_list, const char *verb);
-int _voice_pcm_open(audio_mgr_t *am);
-int _voice_pcm_close(audio_mgr_t *am, uint32_t direction);
-audio_return_t _audio_ucm_get_verb (audio_mgr_t *am, const char **value);
-audio_return_t _audio_ucm_reset_use_case (audio_mgr_t *am);
-audio_return_t _audio_util_init (audio_mgr_t *am);
-audio_return_t _audio_util_deinit (audio_mgr_t *am);
-audio_return_t _audio_mixer_control_set_param(audio_mgr_t *am, const char* ctl_name, snd_ctl_elem_value_t* value, int size);
-audio_return_t _audio_mixer_control_set_value(audio_mgr_t *am, const char *ctl_name, int val);
-audio_return_t _audio_mixer_control_set_value_string(audio_mgr_t *am, const char* ctl_name, const char* value);
-audio_return_t _audio_mixer_control_get_value(audio_mgr_t *am, const char *ctl_name, int *val);
-audio_return_t _audio_mixer_control_get_element(audio_mgr_t *am, const char *ctl_name, snd_hctl_elem_t **elem);
+audio_return_t _audio_ucm_set_use_case(audio_hal_t *ah, const char *verb, const char *devices[], const char *modifiers[]);
+audio_return_t _audio_ucm_set_devices(audio_hal_t *ah, const char *verb, const char *devices[]);
+audio_return_t _audio_ucm_set_modifiers(audio_hal_t *ah, const char *verb, const char *modifiers[]);
+int _audio_ucm_fill_device_info_list(audio_hal_t *ah, audio_device_info_t *device_info_list, const char *verb);
+int _voice_pcm_open(audio_hal_t *ah);
+int _voice_pcm_close(audio_hal_t *ah, uint32_t direction);
+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_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);
#define SND_USE_CASE_SET snd_use_case_set
#endif
-audio_return_t _audio_ucm_init (audio_mgr_t *am)
+audio_return_t _audio_ucm_init(audio_hal_t *ah)
{
- snd_use_case_mgr_open(&am->ucm.uc_mgr, ALSA_DEFAULT_CARD);
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
- if (!am->ucm.uc_mgr) {
+ snd_use_case_mgr_open(&ah->ucm.uc_mgr, ALSA_DEFAULT_CARD);
+
+ if (!ah->ucm.uc_mgr) {
AUDIO_LOG_ERROR("uc_mgr open failed");
return AUDIO_ERR_RESOURCE;
}
return AUDIO_RET_OK;
}
-audio_return_t _audio_ucm_deinit (audio_mgr_t *am)
+audio_return_t _audio_ucm_deinit(audio_hal_t *ah)
{
- if (am->ucm.uc_mgr != NULL) {
- snd_use_case_mgr_close(am->ucm.uc_mgr);
- am->ucm.uc_mgr = NULL;
- }
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(ah->ucm.uc_mgr, AUDIO_ERR_PARAMETER);
+
+ snd_use_case_mgr_close(ah->ucm.uc_mgr);
+ ah->ucm.uc_mgr = NULL;
return AUDIO_RET_OK;
}
-void _audio_ucm_get_device_name (audio_mgr_t *am, const char *use_case, audio_direction_t direction, const char **value)
+void _audio_ucm_get_device_name(audio_hal_t *ah, const char *use_case, audio_direction_t direction, const char **value)
{
char identifier[70] = {0};
+ AUDIO_RETURN_IF_FAIL(ah);
+ AUDIO_RETURN_IF_FAIL(ah->ucm.uc_mgr);
+
if (direction == AUDIO_DIRECTION_IN) {
sprintf(identifier, "CapturePCM//%s", use_case);
} else {
sprintf(identifier, "PlaybackPCM//%s", use_case);
}
- snd_use_case_get(am->ucm.uc_mgr, identifier, value);
+ snd_use_case_get(ah->ucm.uc_mgr, identifier, value);
}
-static inline void __add_ucm_device_info (audio_mgr_t *am, const char *use_case, audio_direction_t direction, audio_device_info_t *device_info_list, int *device_info_count)
+static inline void __add_ucm_device_info(audio_hal_t *ah, const char *use_case, audio_direction_t direction, audio_device_info_t *device_info_list, int *device_info_count)
{
audio_device_info_t *device_info;
const char *device_name = NULL;
char *needle = NULL;
- _audio_ucm_get_device_name(am, use_case, direction, &device_name);
+ AUDIO_RETURN_IF_FAIL(ah);
+ AUDIO_RETURN_IF_FAIL(ah->ucm.uc_mgr);
+ AUDIO_RETURN_IF_FAIL(device_info_list);
+ AUDIO_RETURN_IF_FAIL(device_info_count);
+
+ _audio_ucm_get_device_name(ah, use_case, direction, &device_name);
if (device_name) {
device_info = &device_info_list[(*device_info_count)++];
}
}
-int _audio_ucm_fill_device_info_list (audio_mgr_t *am, audio_device_info_t *device_info_list, const char *verb)
+int _audio_ucm_fill_device_info_list(audio_hal_t *ah, audio_device_info_t *device_info_list, const char *verb)
{
int device_info_count = 0;
const char *curr_verb = NULL;
+ AUDIO_RETURN_VAL_IF_FAIL(ah, device_info_count);
+ AUDIO_RETURN_VAL_IF_FAIL(ah->ucm.uc_mgr, device_info_count);
+ AUDIO_RETURN_VAL_IF_FAIL(device_info_list, device_info_count);
+
if (!verb) {
- snd_use_case_get(am->ucm.uc_mgr, "_verb", &curr_verb);
+ snd_use_case_get(ah->ucm.uc_mgr, "_verb", &curr_verb);
verb = curr_verb;
}
if (verb) {
if (strncmp(verb, AUDIO_USE_CASE_VERB_VOICECALL, strlen(AUDIO_USE_CASE_VERB_VOICECALL)) &&
strncmp(verb, AUDIO_USE_CASE_VERB_LOOPBACK, strlen(AUDIO_USE_CASE_VERB_LOOPBACK))) {
- __add_ucm_device_info(am, verb, AUDIO_DIRECTION_IN, device_info_list, &device_info_count);
+ __add_ucm_device_info(ah, verb, AUDIO_DIRECTION_IN, device_info_list, &device_info_count);
if(strncmp(verb, AUDIO_USE_CASE_VERB_FMRADIO, strlen(AUDIO_USE_CASE_VERB_FMRADIO))) {
- __add_ucm_device_info(am, verb, AUDIO_DIRECTION_OUT, device_info_list, &device_info_count);
+ __add_ucm_device_info(ah, verb, AUDIO_DIRECTION_OUT, device_info_list, &device_info_count);
}
}
2) If verb is changed
-> Reset, set new verb, enable devices & modifiers
*/
-audio_return_t _audio_ucm_set_use_case (audio_mgr_t *am, const char *verb, const char *devices[], const char *modifiers[])
+audio_return_t _audio_ucm_set_use_case(audio_hal_t *ah, const char *verb, const char *devices[], const char *modifiers[])
{
audio_return_t audio_ret = AUDIO_RET_OK;
int is_verb_changed = 0, is_dev_changed = 0, is_mod_changed = 0;
int i = 0, j = 0;
char dump_str[512];
- if (!am->ucm.uc_mgr || !verb)
- return AUDIO_ERR_PARAMETER;
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(ah->ucm.uc_mgr, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(verb, AUDIO_ERR_PARAMETER);
- snd_use_case_get(am->ucm.uc_mgr, "_verb", &old_verb);
- old_dev_count = snd_use_case_get_list(am->ucm.uc_mgr, "_enadevs", &old_dev_list);
- old_mod_count = snd_use_case_get_list(am->ucm.uc_mgr, "_enamods", &old_mod_list);
+ snd_use_case_get(ah->ucm.uc_mgr, "_verb", &old_verb);
+ old_dev_count = snd_use_case_get_list(ah->ucm.uc_mgr, "_enadevs", &old_dev_list);
+ old_mod_count = snd_use_case_get_list(ah->ucm.uc_mgr, "_enamods", &old_mod_list);
__dump_use_case(old_verb, old_dev_list, old_dev_count, old_mod_list, old_mod_count, &dump_str[0]);
AUDIO_LOG_INFO(">>> UCM current %s", dump_str);
/* disable modifiers */
for (i = 0; i < dis_mod_count; i++) {
AUDIO_LOG_INFO("Disable modifier : %s", dis_mod_list[i]);
- if (snd_use_case_set(am->ucm.uc_mgr, "_dismod", dis_mod_list[i]) < 0)
+ if (snd_use_case_set(ah->ucm.uc_mgr, "_dismod", dis_mod_list[i]) < 0)
AUDIO_LOG_ERROR("disable %s modifier failed", dis_mod_list[i]);
}
/* disable devices */
for (i = 0; i < dis_dev_count; i++) {
AUDIO_LOG_INFO("Disable device : %s", dis_dev_list[i]);
- if (snd_use_case_set(am->ucm.uc_mgr, "_disdev", dis_dev_list[i]) < 0)
+ if (snd_use_case_set(ah->ucm.uc_mgr, "_disdev", dis_dev_list[i]) < 0)
AUDIO_LOG_ERROR("disable %s device failed", dis_dev_list[i]);
}
/* enable devices */
for (i = 0; i < ena_dev_count; i++) {
AUDIO_LOG_INFO("Enable device : %s", ena_dev_list[i]);
- if (snd_use_case_set(am->ucm.uc_mgr, "_enadev", ena_dev_list[i]) < 0)
+ if (snd_use_case_set(ah->ucm.uc_mgr, "_enadev", ena_dev_list[i]) < 0)
AUDIO_LOG_ERROR("enable %s device failed", ena_dev_list[i]);
}
/* enable modifiers */
for (i = 0; i < ena_mod_count; i++) {
AUDIO_LOG_INFO("Enable modifier : %s", ena_mod_list[i]);
- if (snd_use_case_set(am->ucm.uc_mgr, "_enamod", ena_mod_list[i]) < 0)
+ if (snd_use_case_set(ah->ucm.uc_mgr, "_enamod", ena_mod_list[i]) < 0)
AUDIO_LOG_ERROR("enable %s modifier failed", ena_mod_list[i]);
}
} else {
AUDIO_LOG_DEBUG("Setting new verb: %s", verb);
/* set new verb */
- if (snd_use_case_set(am->ucm.uc_mgr, "_verb", verb) < 0) {
+ if (snd_use_case_set(ah->ucm.uc_mgr, "_verb", verb) < 0) {
AUDIO_LOG_ERROR("Setting verb %s failed", verb);
audio_ret = AUDIO_ERR_UNDEFINED;
goto exit;
/* enable devices */
for (i = 0; i < dev_count; i++) {
AUDIO_LOG_DEBUG("Enable device : %s", devices[i]);
- if(snd_use_case_set(am->ucm.uc_mgr, "_enadev", devices[i]) < 0)
+ if(snd_use_case_set(ah->ucm.uc_mgr, "_enadev", devices[i]) < 0)
AUDIO_LOG_ERROR("Enable %s device failed", devices[i]);
}
/* enable modifiers */
for (i = 0; i < mod_count; i++) {
AUDIO_LOG_DEBUG("Enable modifier : %s", modifiers[i]);
- if(snd_use_case_set(am->ucm.uc_mgr, "_enamod", modifiers[i]) < 0)
+ if(snd_use_case_set(ah->ucm.uc_mgr, "_enamod", modifiers[i]) < 0)
AUDIO_LOG_ERROR("Enable %s modifier failed", modifiers[i]);
}
}
const char *new_verb = NULL, **new_dev_list = NULL, **new_mod_list = NULL;
int new_dev_count = 0, new_mod_count = 0;
- snd_use_case_get(am->ucm.uc_mgr, "_verb", &new_verb);
- new_dev_count = snd_use_case_get_list(am->ucm.uc_mgr, "_enadevs", &new_dev_list);
- new_mod_count = snd_use_case_get_list(am->ucm.uc_mgr, "_enamods", &new_mod_list);
+ snd_use_case_get(ah->ucm.uc_mgr, "_verb", &new_verb);
+ new_dev_count = snd_use_case_get_list(ah->ucm.uc_mgr, "_enadevs", &new_dev_list);
+ new_mod_count = snd_use_case_get_list(ah->ucm.uc_mgr, "_enamods", &new_mod_list);
__dump_use_case(new_verb, new_dev_list, new_dev_count, new_mod_list, new_mod_count, &dump_str[0]);
AUDIO_LOG_INFO("<<< UCM changed %s", dump_str);
return audio_ret;
}
-audio_return_t _audio_ucm_set_devices (audio_mgr_t *am, const char *verb, const char *devices[])
+audio_return_t _audio_ucm_set_devices(audio_hal_t *ah, const char *verb, const char *devices[])
{
audio_return_t audio_ret = AUDIO_RET_OK;
int is_verb_changed = 0, is_dev_changed = 0;
int i = 0, j = 0;
char dump_str[512];
- if (!am->ucm.uc_mgr || !verb)
- return AUDIO_ERR_PARAMETER;
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(ah->ucm.uc_mgr, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(verb, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(devices, AUDIO_ERR_PARAMETER);
- snd_use_case_get(am->ucm.uc_mgr, "_verb", &old_verb);
- old_dev_count = snd_use_case_get_list(am->ucm.uc_mgr, "_enadevs", &old_dev_list);
+ snd_use_case_get(ah->ucm.uc_mgr, "_verb", &old_verb);
+ old_dev_count = snd_use_case_get_list(ah->ucm.uc_mgr, "_enadevs", &old_dev_list);
__dump_use_case(old_verb, old_dev_list, old_dev_count, NULL, 0, &dump_str[0]);
AUDIO_LOG_INFO(">>> UCM current %s", dump_str);
/* disable devices */
for (i = 0; i < dis_dev_count; i++) {
AUDIO_LOG_INFO("Disable device : %s", dis_dev_list[i]);
- if (snd_use_case_set(am->ucm.uc_mgr, "_disdev", dis_dev_list[i]) < 0)
+ if (snd_use_case_set(ah->ucm.uc_mgr, "_disdev", dis_dev_list[i]) < 0)
AUDIO_LOG_ERROR("disable %s device failed", dis_dev_list[i]);
}
/* enable devices */
for (i = 0; i < ena_dev_count; i++) {
AUDIO_LOG_INFO("Enable device : %s", ena_dev_list[i]);
- if (snd_use_case_set(am->ucm.uc_mgr, "_enadev", ena_dev_list[i]) < 0)
+ if (snd_use_case_set(ah->ucm.uc_mgr, "_enadev", ena_dev_list[i]) < 0)
AUDIO_LOG_ERROR("enable %s device failed", ena_dev_list[i]);
}
AUDIO_LOG_DEBUG("Setting new verb: %s", verb);
/* set new verb */
- if (snd_use_case_set(am->ucm.uc_mgr, "_verb", verb) < 0) {
+ if (snd_use_case_set(ah->ucm.uc_mgr, "_verb", verb) < 0) {
AUDIO_LOG_ERROR("Setting verb %s failed", verb);
audio_ret = AUDIO_ERR_UNDEFINED;
goto exit;
/* enable devices */
for (i = 0; i < dev_count; i++) {
AUDIO_LOG_DEBUG("Enable device : %s", devices[i]);
- if(snd_use_case_set(am->ucm.uc_mgr, "_enadev", devices[i]) < 0)
+ if(snd_use_case_set(ah->ucm.uc_mgr, "_enadev", devices[i]) < 0)
AUDIO_LOG_ERROR("Enable %s device failed", devices[i]);
}
}
const char *new_verb = NULL, **new_dev_list = NULL;
int new_dev_count = 0;
- snd_use_case_get(am->ucm.uc_mgr, "_verb", &new_verb);
- new_dev_count = snd_use_case_get_list(am->ucm.uc_mgr, "_enadevs", &new_dev_list);
+ snd_use_case_get(ah->ucm.uc_mgr, "_verb", &new_verb);
+ new_dev_count = snd_use_case_get_list(ah->ucm.uc_mgr, "_enadevs", &new_dev_list);
__dump_use_case(new_verb, new_dev_list, new_dev_count, NULL, 0, &dump_str[0]);
AUDIO_LOG_INFO("<<< UCM changed %s", dump_str);
}
-audio_return_t _audio_ucm_set_modifiers (audio_mgr_t *am, const char *verb, const char *modifiers[])
+audio_return_t _audio_ucm_set_modifiers(audio_hal_t *ah, const char *verb, const char *modifiers[])
{
audio_return_t audio_ret = AUDIO_RET_OK;
int is_verb_changed = 0, is_mod_changed = 0;
int i = 0, j = 0;
char dump_str[512];
- if (!am->ucm.uc_mgr || !verb)
- return AUDIO_ERR_PARAMETER;
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(ah->ucm.uc_mgr, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(verb, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(modifiers, AUDIO_ERR_PARAMETER);
- snd_use_case_get(am->ucm.uc_mgr, "_verb", &old_verb);
- old_mod_count = snd_use_case_get_list(am->ucm.uc_mgr, "_enamods", &old_mod_list);
+ snd_use_case_get(ah->ucm.uc_mgr, "_verb", &old_verb);
+ old_mod_count = snd_use_case_get_list(ah->ucm.uc_mgr, "_enamods", &old_mod_list);
__dump_use_case(old_verb, NULL, 0, old_mod_list, old_mod_count, &dump_str[0]);
AUDIO_LOG_INFO(">>> UCM current %s", dump_str);
/* disable modifiers */
for (i = 0; i < dis_mod_count; i++) {
AUDIO_LOG_INFO("Disable modifier : %s", dis_mod_list[i]);
- if (snd_use_case_set(am->ucm.uc_mgr, "_dismod", dis_mod_list[i]) < 0)
+ if (snd_use_case_set(ah->ucm.uc_mgr, "_dismod", dis_mod_list[i]) < 0)
AUDIO_LOG_ERROR("disable %s modifier failed", dis_mod_list[i]);
}
/* enable modifiers */
for (i = 0; i < ena_mod_count; i++) {
AUDIO_LOG_INFO("Enable modifier : %s", ena_mod_list[i]);
- if (snd_use_case_set(am->ucm.uc_mgr, "_enamod", ena_mod_list[i]) < 0)
+ if (snd_use_case_set(ah->ucm.uc_mgr, "_enamod", ena_mod_list[i]) < 0)
AUDIO_LOG_ERROR("enable %s modifier failed", ena_mod_list[i]);
}
} else {
AUDIO_LOG_DEBUG("Setting new verb: %s", verb);
/* set new verb */
- if (snd_use_case_set(am->ucm.uc_mgr, "_verb", verb) < 0) {
+ if (snd_use_case_set(ah->ucm.uc_mgr, "_verb", verb) < 0) {
AUDIO_LOG_ERROR("Setting verb %s failed", verb);
audio_ret = AUDIO_ERR_UNDEFINED;
goto exit;
/* enable modifiers */
for (i = 0; i < mod_count; i++) {
AUDIO_LOG_DEBUG("Enable modifier : %s", modifiers[i]);
- if(snd_use_case_set(am->ucm.uc_mgr, "_enamod", modifiers[i]) < 0)
+ if(snd_use_case_set(ah->ucm.uc_mgr, "_enamod", modifiers[i]) < 0)
AUDIO_LOG_ERROR("Enable %s modifier failed", modifiers[i]);
}
}
const char *new_verb = NULL, **new_mod_list = NULL;
int new_mod_count = 0;
- snd_use_case_get(am->ucm.uc_mgr, "_verb", &new_verb);
- new_mod_count = snd_use_case_get_list(am->ucm.uc_mgr, "_enamods", &new_mod_list);
+ snd_use_case_get(ah->ucm.uc_mgr, "_verb", &new_verb);
+ new_mod_count = snd_use_case_get_list(ah->ucm.uc_mgr, "_enamods", &new_mod_list);
__dump_use_case(new_verb, NULL, 0, new_mod_list, new_mod_count, &dump_str[0]);
AUDIO_LOG_INFO("<<< UCM changed %s", dump_str);
return audio_ret;
}
-audio_return_t _audio_ucm_get_verb (audio_mgr_t *am, const char **value)
+audio_return_t _audio_ucm_get_verb(audio_hal_t *ah, const char **value)
{
audio_return_t ret = AUDIO_RET_OK;
- AUDIO_RETURN_VAL_IF_FAIL(am, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(ah->ucm.uc_mgr, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(value, AUDIO_ERR_PARAMETER);
- if ((ret = snd_use_case_get(am->ucm.uc_mgr, "_verb", value)) < 0) {
+ if ((ret = snd_use_case_get(ah->ucm.uc_mgr, "_verb", value)) < 0) {
AUDIO_LOG_ERROR("Getting current verb failed: Reason %d", ret);
ret = AUDIO_ERR_UNDEFINED;
}
}
-audio_return_t _audio_ucm_reset_use_case (audio_mgr_t *am)
+audio_return_t _audio_ucm_reset_use_case(audio_hal_t *ah)
{
audio_return_t ret = AUDIO_RET_OK;
- AUDIO_RETURN_VAL_IF_FAIL(am, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(ah->ucm.uc_mgr, AUDIO_ERR_PARAMETER);
AUDIO_LOG_INFO(">>> UCM reset Verb [ %s ]", AUDIO_USE_CASE_VERB_INACTIVE);
- if ((ret = snd_use_case_set(am->ucm.uc_mgr, "_verb", AUDIO_USE_CASE_VERB_INACTIVE)) < 0) {
+ if ((ret = snd_use_case_set(ah->ucm.uc_mgr, "_verb", AUDIO_USE_CASE_VERB_INACTIVE)) < 0) {
AUDIO_LOG_ERROR("Reset use case failed: Reason %d", ret);
ret = AUDIO_ERR_UNDEFINED;
}
#include "tizen-audio-internal.h"
-audio_return_t _audio_util_init (audio_mgr_t *am)
+audio_return_t _audio_util_init(audio_hal_t *ah)
{
- pthread_mutex_init(&(am->mixer.mutex), NULL);
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+
+ pthread_mutex_init(&(ah->mixer.mutex), NULL);
return AUDIO_RET_OK;
}
-audio_return_t _audio_util_deinit (audio_mgr_t *am)
+audio_return_t _audio_util_deinit(audio_hal_t *ah)
{
- pthread_mutex_destroy(&(am->mixer.mutex));
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+
+ pthread_mutex_destroy(&(ah->mixer.mutex));
return AUDIO_RET_OK;
}
#endif
-audio_return_t _audio_mixer_control_set_param(audio_mgr_t *am, const char* ctl_name, snd_ctl_elem_value_t* param, int size)
+audio_return_t _audio_mixer_control_set_param(audio_hal_t *ah, const char* ctl_name, snd_ctl_elem_value_t* param, int size)
{
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+
/* TODO. */
return AUDIO_RET_OK;
}
-audio_return_t audio_mixer_control_get_value (void *userdata, const char *ctl_name, int *val)
+audio_return_t audio_mixer_control_get_value(audio_hal_t *ah, const char *ctl_name, int *val)
{
audio_return_t audio_ret = AUDIO_RET_OK;
- audio_mgr_t *am = (audio_mgr_t *)userdata;
- audio_ret = _audio_mixer_control_get_value(am, ctl_name, val);
+
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+
+ audio_ret = _audio_mixer_control_get_value(ah, ctl_name, val);
return audio_ret;
}
-audio_return_t _audio_mixer_control_get_value(audio_mgr_t *am, const char *ctl_name, int *val)
+audio_return_t _audio_mixer_control_get_value(audio_hal_t *ah, const char *ctl_name, int *val)
{
snd_ctl_t *handle;
snd_ctl_elem_value_t *control;
int ret = 0, count = 0, i = 0;
- pthread_mutex_lock(&(am->mixer.mutex));
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+
+ pthread_mutex_lock(&(ah->mixer.mutex));
ret = snd_ctl_open(&handle, ALSA_DEFAULT_CARD, 0);
if (ret < 0) {
AUDIO_LOG_ERROR ("snd_ctl_open error, %s\n", snd_strerror(ret));
- pthread_mutex_unlock(&(am->mixer.mutex));
+ pthread_mutex_unlock(&(ah->mixer.mutex));
return AUDIO_ERR_IOCTL;
}
AUDIO_LOG_INFO("get mixer(%s) = %d success", ctl_name, *val);
#endif
- pthread_mutex_unlock(&(am->mixer.mutex));
+ pthread_mutex_unlock(&(ah->mixer.mutex));
return AUDIO_RET_OK;
close:
AUDIO_LOG_ERROR ("Error\n");
snd_ctl_close(handle);
- pthread_mutex_unlock(&(am->mixer.mutex));
+ pthread_mutex_unlock(&(ah->mixer.mutex));
return AUDIO_ERR_UNDEFINED;
}
-audio_return_t _audio_mixer_control_set_value(audio_mgr_t *am, const char *ctl_name, int val)
+audio_return_t _audio_mixer_control_set_value(audio_hal_t *ah, const char *ctl_name, int val)
{
snd_ctl_t *handle;
snd_ctl_elem_value_t *control;
char *card_name = NULL;
int ret = 0, count = 0, i = 0;
- pthread_mutex_lock(&(am->mixer.mutex));
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(ctl_name, AUDIO_ERR_PARAMETER);
+
+ pthread_mutex_lock(&(ah->mixer.mutex));
ret = snd_ctl_open(&handle, ALSA_DEFAULT_CARD, 0);
if (ret < 0) {
AUDIO_LOG_ERROR("snd_ctl_open error, card: %s: %s", card_name, snd_strerror(ret));
- pthread_mutex_unlock(&(am->mixer.mutex));
+ pthread_mutex_unlock(&(ah->mixer.mutex));
return AUDIO_ERR_IOCTL;
}
AUDIO_LOG_INFO("set mixer(%s) = %d success", ctl_name, val);
- pthread_mutex_unlock(&(am->mixer.mutex));
+ pthread_mutex_unlock(&(ah->mixer.mutex));
return AUDIO_RET_OK;
close:
AUDIO_LOG_ERROR("Error");
snd_ctl_close(handle);
- pthread_mutex_unlock(&(am->mixer.mutex));
+ pthread_mutex_unlock(&(ah->mixer.mutex));
return AUDIO_ERR_UNDEFINED;
}
-audio_return_t _audio_mixer_control_set_value_string(audio_mgr_t *am, const char* ctl_name, const char* value)
+audio_return_t _audio_mixer_control_set_value_string(audio_hal_t *ah, const char* ctl_name, const char* value)
{
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(ctl_name, AUDIO_ERR_PARAMETER);
+
/* TODO. */
return AUDIO_RET_OK;
}
-audio_return_t _audio_mixer_control_get_element(audio_mgr_t *am, const char *ctl_name, snd_hctl_elem_t **elem)
+audio_return_t _audio_mixer_control_get_element(audio_hal_t *ah, const char *ctl_name, snd_hctl_elem_t **elem)
{
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(ctl_name, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(elem, AUDIO_ERR_PARAMETER);
+
/* TODO. */
return AUDIO_RET_OK;
}
uint8_t _use_mmap = use_mmap && *use_mmap;
uint32_t channels = 0;
+ AUDIO_RETURN_VAL_IF_FAIL(pcm, AUDIO_ERR_PARAMETER);
+
snd_pcm_hw_params_alloca(&hwparams);
/* Skip parameter setting to null device. */
snd_pcm_uframes_t boundary;
int err;
+ AUDIO_RETURN_VAL_IF_FAIL(pcm, AUDIO_ERR_PARAMETER);
+
snd_pcm_sw_params_alloca(&swparams);
if ((err = snd_pcm_sw_params_current(pcm, swparams) < 0)) {
"file/private/sound/volume/call", /* AUDIO_VOLUME_TYPE_CALL */
"file/private/sound/volume/voip", /* AUDIO_VOLUME_TYPE_VOIP */
"file/private/sound/volume/voice", /* AUDIO_VOLUME_TYPE_VOICE */
- "file/private/sound/volume/fixed", /* AUDIO_VOLUME_TYPE_FIXED */
};
static const char *__get_volume_type_string_by_idx (uint32_t vol_type_idx)
case AUDIO_VOLUME_TYPE_CALL: return "call";
case AUDIO_VOLUME_TYPE_VOIP: return "voip";
case AUDIO_VOLUME_TYPE_VOICE: return "voice";
- case AUDIO_VOLUME_TYPE_FIXED: return "fixed";
default: return "invalid";
}
}
return AUDIO_VOLUME_TYPE_VOIP;
else if (!strncmp(vol_type, "voice", strlen(vol_type)) || !strncmp(vol_type, "7", strlen(vol_type)))
return AUDIO_VOLUME_TYPE_VOICE;
- else if (!strncmp(vol_type, "fixed", strlen(vol_type)) || !strncmp(vol_type, "8", strlen(vol_type)))
- return AUDIO_VOLUME_TYPE_FIXED;
else
return AUDIO_VOLUME_TYPE_MEDIA;
}
}
}
-static void __dump_tb (audio_mgr_t *am)
+static void __dump_tb (audio_hal_t *ah)
{
- audio_volume_value_table_t *volume_value_table = am->volume.volume_value_table;
+ audio_volume_value_table_t *volume_value_table = ah->volume.volume_value_table;
uint32_t vol_type_idx, vol_level_idx, gain_type_idx;
const char *gain_type_str[] = {
"def", /* AUDIO_GAIN_TYPE_DEFAULT */
AUDIO_LOG_INFO("%s", dump_str);
}
- volume_value_table = am->volume.volume_value_table;
+ volume_value_table = ah->volume.volume_value_table;
/* Dump gain table */
AUDIO_LOG_INFO("<<<<< gain table >>>>>");
}
-static audio_return_t __load_volume_value_table_from_ini (audio_mgr_t *am)
+static audio_return_t __load_volume_value_table_from_ini (audio_hal_t *ah)
{
dictionary * dict = NULL;
uint32_t vol_type_idx, vol_level_idx, gain_type_idx;
- audio_volume_value_table_t *volume_value_table = am->volume.volume_value_table;
+ audio_volume_value_table_t *volume_value_table = ah->volume.volume_value_table;
int size = 0;
dict = iniparser_load(VOLUME_INI_TEMP_PATH);
iniparser_freedict(dict);
- __dump_tb(am);
+ __dump_tb(ah);
return AUDIO_RET_OK;
}
-audio_return_t _audio_volume_init (audio_mgr_t *am)
+audio_return_t _audio_volume_init (audio_hal_t *ah)
{
int i;
int val = 0;
audio_return_t audio_ret = AUDIO_RET_OK;
- int init_value[AUDIO_VOLUME_TYPE_MAX] = { 9, 11, 7, 11, 7, 4, 4, 7, 4, 0 };
+ int init_value[AUDIO_VOLUME_TYPE_MAX] = { 9, 11, 7, 11, 7, 4, 4, 7 };
- AUDIO_RETURN_VAL_IF_FAIL(am, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
for (i = 0; i < AUDIO_VOLUME_TYPE_MAX; i++) {
- am->volume.volume_level[i] = init_value[i];
+ ah->volume.volume_level[i] = init_value[i];
}
for (i = 0; i < AUDIO_VOLUME_TYPE_MAX; i++) {
}
AUDIO_LOG_INFO("read vconf. %s = %d", g_volume_vconf[i], val);
- am->volume.volume_level[i] = val;
+ ah->volume.volume_level[i] = val;
}
- if (!(am->volume.volume_value_table = malloc(AUDIO_VOLUME_DEVICE_MAX * sizeof(audio_volume_value_table_t)))) {
+ if (!(ah->volume.volume_value_table = malloc(AUDIO_VOLUME_DEVICE_MAX * sizeof(audio_volume_value_table_t)))) {
AUDIO_LOG_ERROR("volume_value_table malloc failed");
return AUDIO_ERR_RESOURCE;
}
- audio_ret = __load_volume_value_table_from_ini(am);
+ audio_ret = __load_volume_value_table_from_ini(ah);
if(audio_ret != AUDIO_RET_OK) {
AUDIO_LOG_ERROR("gain table load error");
return AUDIO_ERR_UNDEFINED;
return audio_ret;
}
-audio_return_t _audio_volume_deinit (audio_mgr_t *am)
+audio_return_t _audio_volume_deinit (audio_hal_t *ah)
{
- AUDIO_RETURN_VAL_IF_FAIL(am, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
- if (am->volume.volume_value_table) {
- free(am->volume.volume_value_table);
- am->volume.volume_value_table = NULL;
+ if (ah->volume.volume_value_table) {
+ free(ah->volume.volume_value_table);
+ ah->volume.volume_value_table = NULL;
}
return AUDIO_RET_OK;
}
-audio_return_t audio_get_volume_level_max (void *userdata, audio_volume_info_t *info, uint32_t *level)
+audio_return_t audio_get_volume_level_max(void *audio_handle, audio_volume_info_t *info, uint32_t *level)
{
- audio_mgr_t *am = (audio_mgr_t *)userdata;
+ audio_hal_t *ah = (audio_hal_t *)audio_handle;
audio_volume_value_table_t *volume_value_table;
- AUDIO_RETURN_VAL_IF_FAIL(am, AUDIO_ERR_PARAMETER);
- AUDIO_RETURN_VAL_IF_FAIL(am->volume.volume_value_table, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(ah->volume.volume_value_table, AUDIO_ERR_PARAMETER);
/* Get max volume level by device & type */
- volume_value_table = am->volume.volume_value_table;
+ volume_value_table = ah->volume.volume_value_table;
*level = volume_value_table->volume_level_max[__get_volume_idx_by_string_type(info->type)];
AUDIO_LOG_DEBUG("get_[%s] volume_level_max: %d", info->type, *level);
return AUDIO_RET_OK;
}
-audio_return_t audio_get_volume_level (void *userdata, audio_volume_info_t *info, uint32_t *level)
+audio_return_t audio_get_volume_level(void *audio_handle, audio_volume_info_t *info, uint32_t *level)
{
- audio_mgr_t *am = (audio_mgr_t *)userdata;
+ audio_hal_t *ah = (audio_hal_t *)audio_handle;
- AUDIO_RETURN_VAL_IF_FAIL(am, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
- *level = am->volume.volume_level[__get_volume_idx_by_string_type(info->type)];
+ *level = ah->volume.volume_level[__get_volume_idx_by_string_type(info->type)];
AUDIO_LOG_INFO("get [%s] volume_level: %d, direction(%d)", info->type, *level, info->direction);
return AUDIO_RET_OK;
}
-audio_return_t audio_get_volume_value (void *userdata, audio_volume_info_t *info, uint32_t level, double *value)
+audio_return_t audio_get_volume_value(void *audio_handle, audio_volume_info_t *info, uint32_t level, double *value)
{
- audio_mgr_t *am = (audio_mgr_t *)userdata;
+ audio_hal_t *ah = (audio_hal_t *)audio_handle;
audio_volume_value_table_t *volume_value_table;
char dump_str[AUDIO_DUMP_STR_LEN] = {0,};
- AUDIO_RETURN_VAL_IF_FAIL(am, AUDIO_ERR_PARAMETER);
- AUDIO_RETURN_VAL_IF_FAIL(am->volume.volume_value_table, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(ah->volume.volume_value_table, AUDIO_ERR_PARAMETER);
/* Get basic volume by device & type & level */
- volume_value_table = am->volume.volume_value_table;
+ volume_value_table = ah->volume.volume_value_table;
if (volume_value_table->volume_level_max[__get_volume_idx_by_string_type(info->type)] < level)
*value = VOLUME_VALUE_MAX;
else
return AUDIO_RET_OK;
}
-audio_return_t audio_set_volume_level (void *userdata, audio_volume_info_t *info, uint32_t level)
+audio_return_t audio_set_volume_level(void *audio_handle, audio_volume_info_t *info, uint32_t level)
{
audio_return_t audio_ret = AUDIO_RET_OK;
- audio_mgr_t *am = (audio_mgr_t *)userdata;
+ audio_hal_t *ah = (audio_hal_t *)audio_handle;
- AUDIO_RETURN_VAL_IF_FAIL(am, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
/* Update volume level */
- am->volume.volume_level[__get_volume_idx_by_string_type(info->type)] = level;
+ ah->volume.volume_level[__get_volume_idx_by_string_type(info->type)] = level;
AUDIO_LOG_INFO("set [%s] volume_level: %d, direction(%d)", info->type, level, info->direction);
/* set mixer related to H/W volume if needed */
return audio_ret;
}
-audio_return_t audio_get_volume_mute (void *userdata, audio_volume_info_t *info, uint32_t *mute)
+audio_return_t audio_get_volume_mute(void *audio_handle, audio_volume_info_t *info, uint32_t *mute)
{
audio_return_t audio_ret = AUDIO_RET_OK;
- audio_mgr_t *am = (audio_mgr_t *)userdata;
+ audio_hal_t *ah = (audio_hal_t *)audio_handle;
- AUDIO_RETURN_VAL_IF_FAIL(am, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
/* TODO. Not implemented */
return audio_ret;
}
-audio_return_t audio_set_volume_mute (void *userdata, audio_volume_info_t *info, uint32_t mute)
+audio_return_t audio_set_volume_mute(void *audio_handle, audio_volume_info_t *info, uint32_t mute)
{
audio_return_t audio_ret = AUDIO_RET_OK;
- audio_mgr_t *am = (audio_mgr_t *)userdata;
+ audio_hal_t *ah = (audio_hal_t *)audio_handle;
- AUDIO_RETURN_VAL_IF_FAIL(am, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
/* TODO. Not implemented */
return audio_ret;
#include "tizen-audio-internal.h"
-audio_return_t audio_init (void **userdata)
+/* audio latency */
+static const char* AUDIO_LATENCY_LOW = "low";
+static const char* AUDIO_LATENCY_MID = "mid";
+static const char* AUDIO_LATENCY_HIGH = "high";
+static const char* AUDIO_LATENCY_VOIP = "voip";
+
+audio_return_t audio_init (void **audio_handle)
{
- audio_mgr_t *am;
+ audio_hal_t *ah;
audio_return_t ret = AUDIO_RET_OK;
- if (!(am = malloc(sizeof(audio_mgr_t)))) {
+ AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
+
+ if (!(ah = malloc(sizeof(audio_hal_t)))) {
AUDIO_LOG_ERROR("am malloc failed");
return AUDIO_ERR_RESOURCE;
}
- if (AUDIO_IS_ERROR((ret = _audio_device_init(am)))) {
+ if (AUDIO_IS_ERROR((ret = _audio_device_init(ah)))) {
AUDIO_LOG_ERROR("device init failed");
goto error_exit;
}
- if (AUDIO_IS_ERROR((ret = _audio_volume_init(am)))) {
+ if (AUDIO_IS_ERROR((ret = _audio_volume_init(ah)))) {
AUDIO_LOG_ERROR("stream init failed");
goto error_exit;
}
- if (AUDIO_IS_ERROR((ret = _audio_ucm_init(am)))) {
+ if (AUDIO_IS_ERROR((ret = _audio_ucm_init(ah)))) {
AUDIO_LOG_ERROR("ucm init failed");
goto error_exit;
}
- if (AUDIO_IS_ERROR((ret = _audio_util_init(am)))) {
+ if (AUDIO_IS_ERROR((ret = _audio_util_init(ah)))) {
AUDIO_LOG_ERROR("mixer init failed");
goto error_exit;
}
- *userdata = (void *)am;
+ *audio_handle = (void *)ah;
return AUDIO_RET_OK;
error_exit:
- if (am)
- free(am);
+ if (ah)
+ free(ah);
return ret;
}
-audio_return_t audio_deinit (void **userdata)
+audio_return_t audio_deinit (void *audio_handle)
{
- audio_mgr_t *am = (audio_mgr_t *)*userdata;
+ audio_hal_t *ah = (audio_hal_t *)audio_handle;
- if (am) {
- _audio_device_deinit(am);
- _audio_volume_deinit(am);
- _audio_ucm_deinit(am);
- _audio_util_deinit(am);
- free(am);
- *userdata = NULL;
- }
+ AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
+
+ _audio_device_deinit(ah);
+ _audio_volume_deinit(ah);
+ _audio_ucm_deinit(ah);
+ _audio_util_deinit(ah);
+ free(ah);
+ ah = NULL;
return AUDIO_RET_OK;
}
-static const unsigned int SAMPLES_PER_PERIOD_DEFAULT = 1536; /* Frames */
-static const unsigned int PERIODS_PER_BUFFER_FASTMODE = 4;
-static const unsigned int PERIODS_PER_BUFFER_DEFAULT = 6;
-static const unsigned int PERIODS_PER_BUFFER_VOIP = 2;
-static const unsigned int PERIODS_PER_BUFFER_PLAYBACK = 8;
-static const unsigned int PERIODS_PER_BUFFER_CAPTURE = 12;
-static const unsigned int PERIODS_PER_BUFFER_VIDEO = 10;
-
-
/* Latency msec */
static const unsigned int PERIOD_TIME_FOR_ULOW_LATENCY_MSEC = 20;
static const unsigned int PERIOD_TIME_FOR_LOW_LATENCY_MSEC = 25;
{
return g_size_table[format];
}
-audio_return_t audio_get_buffer_attr(void *userdata,
+audio_return_t audio_get_buffer_attr(void *audio_handle,
uint32_t direction,
const char *latency,
uint32_t samplerate,
uint32_t *minreq,
uint32_t *fragsize)
{
- assert(userdata);
- assert(latency);
- assert(maxlength);
- assert(tlength);
- assert(prebuf);
- assert(minreq);
- assert(fragsize);
+ AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(latency, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(maxlength, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(tlength, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(prebuf, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(minreq, AUDIO_ERR_PARAMETER);
+ AUDIO_RETURN_VAL_IF_FAIL(fragsize, AUDIO_ERR_PARAMETER);
AUDIO_LOG_DEBUG("hal-latency - audio_get_buffer_attr(direction:%d, latency:%s, samplerate:%d, format:%d, channels:%d)", direction, latency, samplerate, format, channels);
- audio_mgr_t *am = (audio_mgr_t *)userdata;
-
uint32_t period_time = 0,
- sample_per_period = 0,
- periods_per_buffer = 0;
+ sample_per_period = 0;
if (_sample_spec_valid(samplerate, format, channels) == 0) {
return AUDIO_ERR_PARAMETER;
AUDIO_LOG_DEBUG("AUDIO_DIRECTION_IN, AUDIO_LATENCY_LOW");
period_time = PERIOD_TIME_FOR_LOW_LATENCY_MSEC;
sample_per_period = (samplerate * period_time) / 1000;
- periods_per_buffer = PERIODS_PER_BUFFER_FASTMODE;
*prebuf = 0;
*minreq = -1;
*tlength = -1;
AUDIO_LOG_DEBUG("AUDIO_DIRECTION_IN, AUDIO_LATENCY_MID");
period_time = PERIOD_TIME_FOR_MID_LATENCY_MSEC;
sample_per_period = (samplerate * period_time) / 1000;
- periods_per_buffer = PERIODS_PER_BUFFER_DEFAULT;
*prebuf = 0;
*minreq = -1;
*tlength = -1;
AUDIO_LOG_DEBUG("AUDIO_DIRECTION_IN, AUDIO_LATENCY_HIGH");
period_time = PERIOD_TIME_FOR_HIGH_LATENCY_MSEC;
sample_per_period = (samplerate * period_time) / 1000;
- periods_per_buffer = PERIODS_PER_BUFFER_CAPTURE;
*prebuf = 0;
*minreq = -1;
*tlength = -1;
AUDIO_LOG_DEBUG("AUDIO_DIRECTION_IN, AUDIO_LATENCY_VOIP");
period_time = PERIOD_TIME_FOR_VOIP_LATENCY_MSEC;
sample_per_period = (samplerate * period_time) / 1000;
- periods_per_buffer = PERIODS_PER_BUFFER_VOIP;
*prebuf = 0;
*minreq = -1;
*tlength = -1;
AUDIO_LOG_DEBUG("AUDIO_DIRECTION_OUT, AUDIO_LATENCY_LOW");
period_time = PERIOD_TIME_FOR_LOW_LATENCY_MSEC;
sample_per_period = (samplerate * period_time) / 1000;
- periods_per_buffer = PERIODS_PER_BUFFER_FASTMODE;
*prebuf = 0;
*minreq = -1;
*tlength = (samplerate / 10) * _audio_sample_size(format) * channels; /* 100ms */
AUDIO_LOG_DEBUG("AUDIO_DIRECTION_OUT, AUDIO_LATENCY_MID");
period_time = PERIOD_TIME_FOR_MID_LATENCY_MSEC;
sample_per_period = (samplerate * period_time) / 1000;
- periods_per_buffer = PERIODS_PER_BUFFER_DEFAULT;
*prebuf = 0;
*minreq = -1;
*tlength = (uint32_t) _audio_usec_to_bytes(200000, samplerate, format, channels);
AUDIO_LOG_DEBUG("AUDIO_DIRECTION_OUT, AUDIO_LATENCY_HIGH");
period_time = PERIOD_TIME_FOR_HIGH_LATENCY_MSEC;
sample_per_period = (samplerate * period_time) / 1000;
- periods_per_buffer = PERIODS_PER_BUFFER_PLAYBACK;
*prebuf = 0;
*minreq = -1;
*tlength = (uint32_t) _audio_usec_to_bytes(400000, samplerate, format, channels);
AUDIO_LOG_DEBUG("AUDIO_DIRECTION_OUT, AUDIO_LATENCY_VOIP");
period_time = PERIOD_TIME_FOR_VOIP_LATENCY_MSEC;
sample_per_period = (samplerate * period_time) / 1000;
- periods_per_buffer = PERIODS_PER_BUFFER_VOIP;
*prebuf = 0;
*minreq = _audio_usec_to_bytes(20000, samplerate, format, channels);
*tlength = _audio_usec_to_bytes(100000, samplerate, format, channels);
*
*/
-#include <stdio.h>
-#include <stdlib.h>
#include <stdint.h>
/* Error code */
-
#define AUDIO_IS_ERROR(ret) (ret < 0)
typedef enum audio_return {
AUDIO_RET_OK = 0,
AUDIO_ERR_NOT_IMPLEMENTED = (int32_t)0x80001004,
} audio_return_t ;
-/* Direction */
typedef enum audio_direction {
AUDIO_DIRECTION_IN, /**< Capture */
AUDIO_DIRECTION_OUT, /**< Playback */
} audio_direction_t;
-typedef enum audio_device_api {
- AUDIO_DEVICE_API_UNKNOWN,
- AUDIO_DEVICE_API_ALSA,
- AUDIO_DEVICE_API_BLUEZ,
-} audio_device_api_t;
-
-typedef enum audio_device_param {
- AUDIO_DEVICE_PARAM_NONE,
- AUDIO_DEVICE_PARAM_CHANNELS,
- AUDIO_DEVICE_PARAM_SAMPLERATE,
- AUDIO_DEVICE_PARAM_FRAGMENT_SIZE,
- AUDIO_DEVICE_PARAM_FRAGMENT_NB,
- AUDIO_DEVICE_PARAM_START_THRESHOLD,
- AUDIO_DEVICE_PARAM_USE_MMAP,
- AUDIO_DEVICE_PARAM_USE_TSCHED,
- AUDIO_DEVICE_PARAM_TSCHED_BUF_SIZE,
- AUDIO_DEVICE_PARAM_SUSPEND_TIMEOUT,
- AUDIO_DEVICE_PARAM_ALTERNATE_RATE,
- AUDIO_DEVICE_PARAM_MAX,
-} audio_device_param_t;
-
-/* audio format */
-typedef enum audio_sample_format {
- AUDIO_SAMPLE_U8,
- AUDIO_SAMPLE_ALAW,
- AUDIO_SAMPLE_ULAW,
- AUDIO_SAMPLE_S16LE,
- AUDIO_SAMPLE_S16BE,
- AUDIO_SAMPLE_FLOAT32LE,
- AUDIO_SAMPLE_FLOAT32BE,
- AUDIO_SAMPLE_S32LE,
- AUDIO_SAMPLE_S32BE,
- AUDIO_SAMPLE_S24LE,
- AUDIO_SAMPLE_S24BE,
- AUDIO_SAMPLE_S24_32LE,
- AUDIO_SAMPLE_S24_32BE,
- AUDIO_SAMPLE_MAX,
- AUDIO_SAMPLE_INVALID = -1
-} audio_sample_format_t;
-
-/* audio latency */
-static const char* AUDIO_LATENCY_LOW = "low";
-static const char* AUDIO_LATENCY_MID = "mid";
-static const char* AUDIO_LATENCY_HIGH = "high";
-static const char* AUDIO_LATENCY_VOIP = "voip";
-
-typedef struct audio_device_param_info {
- audio_device_param_t param;
- union {
- int64_t s64_v;
- uint64_t u64_v;
- int32_t s32_v;
- uint32_t u32_v;
- };
-} audio_device_param_info_t;
-
-typedef struct audio_device_alsa_info {
- char *card_name;
- uint32_t card_idx;
- uint32_t device_idx;
-} audio_device_alsa_info_t;
-
-typedef struct audio_device_bluz_info {
- char *protocol;
- uint32_t nrec;
-} audio_device_bluez_info_t;
-
-typedef struct audio_device_info {
- audio_device_api_t api;
- audio_direction_t direction;
- char *name;
- uint8_t is_default_device;
- union {
- audio_device_alsa_info_t alsa;
- audio_device_bluez_info_t bluez;
- };
-} audio_device_info_t;
-
typedef struct device_info {
const char *type;
uint32_t direction;
uint32_t idx;
} audio_stream_info_t ;
-/* Stream */
-
-typedef enum audio_volume {
- AUDIO_VOLUME_TYPE_SYSTEM, /**< System volume type */
- AUDIO_VOLUME_TYPE_NOTIFICATION, /**< Notification volume type */
- AUDIO_VOLUME_TYPE_ALARM, /**< Alarm volume type */
- AUDIO_VOLUME_TYPE_RINGTONE, /**< Ringtone volume type */
- AUDIO_VOLUME_TYPE_MEDIA, /**< Media volume type */
- AUDIO_VOLUME_TYPE_CALL, /**< Call volume type */
- AUDIO_VOLUME_TYPE_VOIP, /**< VOIP volume type */
- AUDIO_VOLUME_TYPE_VOICE, /**< Voice volume type */
- AUDIO_VOLUME_TYPE_FIXED, /**< Volume type for fixed acoustic level */
- AUDIO_VOLUME_TYPE_MAX, /**< Volume type count */
-} audio_volume_t;
-
-typedef enum audio_gain {
- AUDIO_GAIN_TYPE_DEFAULT,
- AUDIO_GAIN_TYPE_DIALER,
- AUDIO_GAIN_TYPE_TOUCH,
- AUDIO_GAIN_TYPE_AF,
- AUDIO_GAIN_TYPE_SHUTTER1,
- AUDIO_GAIN_TYPE_SHUTTER2,
- AUDIO_GAIN_TYPE_CAMCODING,
- AUDIO_GAIN_TYPE_MIDI,
- AUDIO_GAIN_TYPE_BOOTING,
- AUDIO_GAIN_TYPE_VIDEO,
- AUDIO_GAIN_TYPE_TTS,
- AUDIO_GAIN_TYPE_MAX,
-} audio_gain_t;
-
/* Overall */
typedef struct audio_interface {
- audio_return_t (*init)(void **userdata);
- audio_return_t (*deinit)(void **userdata);
- audio_return_t (*get_volume_level_max)(void *userdata, audio_volume_info_t *info, uint32_t *level);
- audio_return_t (*get_volume_level)(void *userdata, audio_volume_info_t *info, uint32_t *level);
- audio_return_t (*set_volume_level)(void *userdata, audio_volume_info_t *info, uint32_t level);
- audio_return_t (*get_volume_value)(void *userdata, audio_volume_info_t *info, uint32_t level, double *value);
- audio_return_t (*get_volume_mute)(void *userdata, audio_volume_info_t *info, uint32_t *mute);
- audio_return_t (*set_volume_mute)(void *userdata, audio_volume_info_t *info, uint32_t mute);
- audio_return_t (*do_route)(void *userdata, audio_route_info_t *info);
- audio_return_t (*update_route_option)(void *userdata, audio_route_option_t *option);
- audio_return_t (*update_stream_connection_info) (void *userdata, audio_stream_info_t *info, uint32_t is_connected);
- audio_return_t (*get_buffer_attr)(void *userdata, uint32_t direction, const char *latency, uint32_t samplerate, int format, uint32_t channels,
+ audio_return_t (*init)(void **audio_handle);
+ audio_return_t (*deinit)(void *audio_handle);
+ 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);
+ 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);
+ 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_open)(void *userdata, void **pcm_handle, uint32_t direction, void *sample_spec, uint32_t period_size, uint32_t periods);
- audio_return_t (*pcm_start)(void *userdata, void *pcm_handle);
- audio_return_t (*pcm_stop)(void *userdata, void *pcm_handle);
- audio_return_t (*pcm_close)(void *userdata, void *pcm_handle);
- audio_return_t (*pcm_avail)(void *userdata, void *pcm_handle, uint32_t *avail);
- audio_return_t (*pcm_write)(void *userdata, void *pcm_handle, const void *buffer, uint32_t frames);
- audio_return_t (*pcm_read)(void *userdata, void *pcm_handle, void *buffer, uint32_t frames);
- audio_return_t (*pcm_get_fd)(void *userdata, void *pcm_handle, int *fd);
- audio_return_t (*pcm_recover)(void *userdata, void *pcm_handle, int revents);
- audio_return_t (*pcm_get_params)(void *userdata, void *pcm_handle, uint32_t direction, void **sample_spec, uint32_t *period_size, uint32_t *periods);
- audio_return_t (*pcm_set_params)(void *userdata, void *pcm_handle, uint32_t direction, void *sample_spec, uint32_t period_size, uint32_t periods);
+ audio_return_t (*pcm_open)(void *audio_handle, void **pcm_handle, uint32_t direction, void *sample_spec, uint32_t period_size, uint32_t periods);
+ audio_return_t (*pcm_start)(void *audio_handle, void *pcm_handle);
+ audio_return_t (*pcm_stop)(void *audio_handle, void *pcm_handle);
+ audio_return_t (*pcm_close)(void *audio_handle, void *pcm_handle);
+ audio_return_t (*pcm_avail)(void *audio_handle, void *pcm_handle, uint32_t *avail);
+ audio_return_t (*pcm_write)(void *audio_handle, void *pcm_handle, const void *buffer, uint32_t frames);
+ audio_return_t (*pcm_read)(void *audio_handle, void *pcm_handle, void *buffer, uint32_t frames);
+ audio_return_t (*pcm_get_fd)(void *audio_handle, void *pcm_handle, int *fd);
+ 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);
} audio_interface_t;
-audio_return_t audio_init(void **userdata);
-audio_return_t audio_deinit(void **userdata);
-audio_return_t audio_get_volume_level_max(void *userdata, audio_volume_info_t *info, uint32_t *level);
-audio_return_t audio_get_volume_level(void *userdata, audio_volume_info_t *info, uint32_t *level);
-audio_return_t audio_set_volume_level(void *userdata, audio_volume_info_t *info, uint32_t level);
-audio_return_t audio_get_volume_value(void *userdata, audio_volume_info_t *info, uint32_t level, double *value);
-audio_return_t audio_get_volume_mute(void *userdata, audio_volume_info_t *info, uint32_t *mute);
-audio_return_t audio_set_volume_mute(void *userdata, audio_volume_info_t *info, uint32_t mute);
-audio_return_t audio_do_route(void *userdata, audio_route_info_t *info);
-audio_return_t audio_update_route_option(void *userdata, audio_route_option_t *option);
-audio_return_t audio_update_stream_connection_info(void *userdata, audio_stream_info_t *info, uint32_t is_connected);
-audio_return_t audio_get_buffer_attr(void *userdata, uint32_t direction, const char *latency, uint32_t samplerate, int format, uint32_t channels,
+audio_return_t audio_init(void **audio_handle);
+audio_return_t audio_deinit(void *audio_handle);
+audio_return_t audio_get_volume_level_max(void *audio_handle, audio_volume_info_t *info, uint32_t *level);
+audio_return_t audio_get_volume_level(void *audio_handle, audio_volume_info_t *info, uint32_t *level);
+audio_return_t audio_set_volume_level(void *audio_handle, audio_volume_info_t *info, uint32_t level);
+audio_return_t audio_get_volume_value(void *audio_handle, audio_volume_info_t *info, uint32_t level, double *value);
+audio_return_t audio_get_volume_mute(void *audio_handle, audio_volume_info_t *info, uint32_t *mute);
+audio_return_t audio_set_volume_mute(void *audio_handle, audio_volume_info_t *info, uint32_t mute);
+audio_return_t audio_do_route(void *audio_handle, audio_route_info_t *info);
+audio_return_t audio_update_route_option(void *audio_handle, audio_route_option_t *option);
+audio_return_t audio_update_stream_connection_info(void *audio_handle, audio_stream_info_t *info, uint32_t is_connected);
+audio_return_t audio_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);
-audio_return_t audio_pcm_open(void *userdata, void **pcm_handle, uint32_t direction, void *sample_spec, uint32_t period_size, uint32_t periods);
-audio_return_t audio_pcm_start(void *userdata, void *pcm_handle);
-audio_return_t audio_pcm_stop(void *userdata, void *pcm_handle);
-audio_return_t audio_pcm_close(void *userdata, void *pcm_handle);
-audio_return_t audio_pcm_avail(void *userdata, void *pcm_handle, uint32_t *avail);
-audio_return_t audio_pcm_write(void *userdata, void *pcm_handle, const void *buffer, uint32_t frames);
-audio_return_t audio_pcm_read(void *userdata, void *pcm_handle, void *buffer, uint32_t frames);
-audio_return_t audio_pcm_get_fd(void *userdata, void *pcm_handle, int *fd);
-audio_return_t audio_pcm_recover(void *userdata, void *pcm_handle, int revents);
-audio_return_t audio_pcm_get_params(void *userdata, void *pcm_handle, uint32_t direction, void **sample_spec, uint32_t *period_size, uint32_t *periods);
-audio_return_t audio_pcm_set_params(void *userdata, void *pcm_handle, uint32_t direction, void *sample_spec, uint32_t period_size, uint32_t periods);
+audio_return_t audio_pcm_open(void *audio_handle, void **pcm_handle, uint32_t direction, void *sample_spec, uint32_t period_size, uint32_t periods);
+audio_return_t audio_pcm_start(void *audio_handle, void *pcm_handle);
+audio_return_t audio_pcm_stop(void *audio_handle, void *pcm_handle);
+audio_return_t audio_pcm_close(void *audio_handle, void *pcm_handle);
+audio_return_t audio_pcm_avail(void *audio_handle, void *pcm_handle, uint32_t *avail);
+audio_return_t audio_pcm_write(void *audio_handle, void *pcm_handle, const void *buffer, uint32_t frames);
+audio_return_t audio_pcm_read(void *audio_handle, void *pcm_handle, void *buffer, uint32_t frames);
+audio_return_t audio_pcm_get_fd(void *audio_handle, void *pcm_handle, int *fd);
+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);
#endif
projects / platform / adaptation / spreadtrum / audio-hal-sc7727.git / commitdiff