static char * out_get_parameters(const struct audio_stream *stream,
const char *keys)
{
struct astream_out *out = (struct astream_out *)stream;
struct str_parms *parms;
struct str_parms *out_parms;
char *str;
char value[20];
int ret;
parms = str_parms_create_str(keys);
out_parms = str_parms_create();
pthread_mutex_lock(&out->lock);
ret = str_parms_get_str(parms, OUT_SINK_ADDR_PARM, value, sizeof(value));
if (ret >= 0)
str_parms_add_str(out_parms, OUT_SINK_ADDR_PARM, out->a2dp_addr);
pthread_mutex_unlock(&out->lock);
str = str_parms_to_str(out_parms);
str_parms_destroy(out_parms);
str_parms_destroy(parms);
return str;
}
static char * adev_get_parameters(const struct audio_hw_device *dev,
const char *keys)
{
struct adev_a2dp *adev = (struct adev_a2dp *)dev;
struct str_parms *parms;
struct str_parms *out_parms;
char *str;
char value[8];
int ret;
parms = str_parms_create_str(keys);
out_parms = str_parms_create();
pthread_mutex_lock(&adev->lock);
ret = str_parms_get_str(parms, BLUETOOOTH_ENABLED_PARM, value,
sizeof(value));
if (ret >= 0)
str_parms_add_str(out_parms, BLUETOOOTH_ENABLED_PARM,
adev->bt_enabled ? "true" : "false");
ret = str_parms_get_str(parms, A2DP_SUSPENDED_PARM, value, sizeof(value));
if (ret >= 0)
str_parms_add_str(out_parms, A2DP_SUSPENDED_PARM,
adev->suspended ? "true" : "false");
pthread_mutex_unlock(&adev->lock);
str = str_parms_to_str(out_parms);
str_parms_destroy(out_parms);
str_parms_destroy(parms);
return str;
}
static int out_set_parameters(struct audio_stream *stream, const char *kvpairs)
{
struct stream_out *out = (struct stream_out *)stream;
struct audio_device *adev = out->dev;
struct str_parms *parms;
char value[32];
int ret;
int routing = 0;
parms = str_parms_create_str(kvpairs);
pthread_mutex_lock(&adev->lock);
ret = str_parms_get_str(parms, "card", value, sizeof(value));
if (ret >= 0)
adev->card = atoi(value);
ret = str_parms_get_str(parms, "device", value, sizeof(value));
if (ret >= 0)
adev->device = atoi(value);
pthread_mutex_unlock(&adev->lock);
str_parms_destroy(parms);
return 0;
}
static int out_set_parameters(struct audio_stream *stream, const char *kvpairs)
{
struct astream_out *out = (struct astream_out *)stream;
struct str_parms *parms;
char *str;
char value[32];
int ret;
parms = str_parms_create_str(kvpairs);
pthread_mutex_lock(&out->lock);
ret = str_parms_get_str(parms, OUT_SINK_ADDR_PARM, value, sizeof(value));
if (ret >= 0) {
/* strlen(00:00:00:00:00:00) == 17 */
if (strlen(value) == 17) {
strlcpy(out->a2dp_addr, value, sizeof(out->a2dp_addr));
if (out->data)
a2dp_set_sink(out->data, out->a2dp_addr);
} else
ret = -EINVAL;
}
pthread_mutex_unlock(&out->lock);
str_parms_destroy(parms);
return ret;
}
static int adev_set_parameters(struct audio_hw_device *dev, const char *kvpairs)
{
struct adev_a2dp *adev = (struct adev_a2dp *)dev;
struct str_parms *parms;
char *str;
char value[8];
int ret;
parms = str_parms_create_str(kvpairs);
pthread_mutex_lock(&adev->lock);
ret = str_parms_get_str(parms, BLUETOOOTH_ENABLED_PARM, value,
sizeof(value));
if (ret >= 0) {
adev->bt_enabled = !strcmp(value, "true");
if (adev->output)
_out_bt_enable(adev->output, adev->bt_enabled);
}
ret = str_parms_get_str(parms, A2DP_SUSPENDED_PARM, value, sizeof(value));
if (ret >= 0) {
adev->suspended = !strcmp(value, "true");
if (adev->output)
_out_a2dp_suspend(adev->output, adev->suspended);
}
pthread_mutex_unlock(&adev->lock);
str_parms_destroy(parms);
return ret;
}
static int out_set_parameters(struct audio_stream *stream, const char *kvpairs)
{
struct stream_out *out = (struct stream_out *)stream;
struct audio_device *adev = out->dev;
struct str_parms *parms;
char value[32];
int ret;
int routing = 0;
ALOGV("%s enter",__func__);
parms = str_parms_create_str(kvpairs);
pthread_mutex_lock(&adev->lock);
if (parms == NULL) {
ALOGE("Couldn't extract string params from key value pair");
pthread_mutex_unlock(&adev->lock);
return 0;
}
ret = str_parms_get_str(parms, "card", value, sizeof(value));
if (ret >= 0)
adev->card = atoi(value);
ret = str_parms_get_str(parms, "device", value, sizeof(value));
if (ret >= 0)
adev->device = atoi(value);
pthread_mutex_unlock(&adev->lock);
str_parms_destroy(parms);
ALOGV("%s exit",__func__);
return 0;
}
static char * device_get_parameters(alsa_device_profile * profile, const char * keys)
{
ALOGV("usb:audio_hw::device_get_parameters() keys:%s", keys);
if (profile->card < 0 || profile->device < 0) {
return strdup("");
}
struct str_parms *query = str_parms_create_str(keys);
struct str_parms *result = str_parms_create();
/* These keys are from hardware/libhardware/include/audio.h */
/* supported sample rates */
if (str_parms_has_key(query, AUDIO_PARAMETER_STREAM_SUP_SAMPLING_RATES)) {
char* rates_list = profile_get_sample_rate_strs(profile);
str_parms_add_str(result, AUDIO_PARAMETER_STREAM_SUP_SAMPLING_RATES,
rates_list);
free(rates_list);
}
/* supported channel counts */
if (str_parms_has_key(query, AUDIO_PARAMETER_STREAM_SUP_CHANNELS)) {
char* channels_list = profile_get_channel_count_strs(profile);
str_parms_add_str(result, AUDIO_PARAMETER_STREAM_SUP_CHANNELS,
channels_list);
free(channels_list);
}
/* supported sample formats */
if (str_parms_has_key(query, AUDIO_PARAMETER_STREAM_SUP_FORMATS)) {
char * format_params = profile_get_format_strs(profile);
str_parms_add_str(result, AUDIO_PARAMETER_STREAM_SUP_FORMATS,
format_params);
free(format_params);
}
str_parms_destroy(query);
char* result_str = str_parms_to_str(result);
str_parms_destroy(result);
ALOGV("usb:audio_hw::device_get_parameters = %s", result_str);
return result_str;
}
static void test_str_parms_str(const char* str, const char* expected) {
str_parms* str_parms = str_parms_create_str(str);
str_parms_add_str(str_parms, "dude", "woah");
str_parms_add_str(str_parms, "dude", "woah");
str_parms_del(str_parms, "dude");
str_parms_dump(str_parms);
char* out_str = str_parms_to_str(str_parms);
str_parms_destroy(str_parms);
ASSERT_STREQ(expected, out_str) << str;
free(out_str);
}
static int adev_set_parameters(struct audio_hw_device *dev, const char *kvpairs)
{
struct adev_a2dp *adev = (struct adev_a2dp *)dev;
struct str_parms *parms;
char *str;
char value[8];
int ret;
LOGV("adev_set_parameters() %s", kvpairs);
const char *keyMono = "toMono=";
if (strstr(kvpairs, keyMono) != NULL) {
if( strlen(kvpairs) > strlen(keyMono) ){
if( kvpairs[strlen(keyMono)] == '1')
isToMono = true;
else
isToMono = false;
LOGV("IsToMono %d", isToMono);
}
return 0;
}
parms = str_parms_create_str(kvpairs);
pthread_mutex_lock(&adev->lock);
ret = str_parms_get_str(parms, BLUETOOOTH_ENABLED_PARM, value,
sizeof(value));
if (ret >= 0) {
adev->bt_enabled = !strcmp(value, "true");
if (adev->output)
_out_bt_enable(adev->output, adev->bt_enabled);
}
ret = str_parms_get_str(parms, A2DP_SUSPENDED_PARM, value, sizeof(value));
if (ret >= 0) {
adev->suspended = !strcmp(value, "true");
if (adev->output)
_out_a2dp_suspend(adev->output, adev->suspended);
}
pthread_mutex_unlock(&adev->lock);
str_parms_destroy(parms);
return ret;
}
static int out_set_parameters(struct audio_stream *stream, const char *kvpairs)
{
ALOGV("usb:audio_hw::out out_set_parameters() keys:%s", kvpairs);
struct stream_out *out = (struct stream_out *)stream;
char value[32];
int param_val;
int routing = 0;
int ret_value = 0;
int card = -1;
int device = -1;
struct str_parms * parms = str_parms_create_str(kvpairs);
pthread_mutex_lock(&out->dev->lock);
pthread_mutex_lock(&out->lock);
param_val = str_parms_get_str(parms, "card", value, sizeof(value));
if (param_val >= 0)
card = atoi(value);
param_val = str_parms_get_str(parms, "device", value, sizeof(value));
if (param_val >= 0)
device = atoi(value);
if (card >= 0 && device >= 0 && !profile_is_cached_for(out->profile, card, device)) {
/* cannot read pcm device info if playback is active */
if (!out->standby)
ret_value = -ENOSYS;
else {
int saved_card = out->profile->card;
int saved_device = out->profile->device;
out->profile->card = card;
out->profile->device = device;
ret_value = profile_read_device_info(out->profile) ? 0 : -EINVAL;
if (ret_value != 0) {
out->profile->card = saved_card;
out->profile->device = saved_device;
}
}
}
pthread_mutex_unlock(&out->lock);
pthread_mutex_unlock(&out->dev->lock);
str_parms_destroy(parms);
return ret_value;
}
static int usb_connect_output(hw_ext_module_t * hw_module,
audio_devices_t device,
const char* CardAndDevice)
{
audio_policy_anm *apm=hw_module->apm;
struct usb_internal_data_s * usb_info = (struct usb_internal_data_s *)hw_module->data;
char *str = NULL;
struct str_parms *param;
if(usb_info==NULL) return -1;
switch(usb_info->state) {
case IO_OPENED:
case IO_DISCONNECTED:
//continue treatment
break;
case IO_CLOSED:
ALOG_WARN("USB output is in closed state ; Impossible to connect it");
return -1;
break;
case IO_CONNECTED:
ALOG_WARN("usb_connect_output : already connected");
return 0;
break;
default:
ALOG_WARN("usb_connect_output : unknown state");
}
if (usb_info->output_handle <=0 ) {
ALOG_WARN("USB output is invalid ; Impossible to connect it");
return -1;
}
ALOG_INFO("USB Output = %d, mStrategyRefCount = %d, CardAndDevice => %s",
usb_info->output_handle,usb_info->output_desc.mStrategyRefCount,CardAndDevice);
// handle USB device connection
strncpy(usb_info->usb_card_and_device,CardAndDevice, sizeof(char)*MAX_DEVICE_ADDRESS_LEN);
param = str_parms_create_str(usb_info->usb_card_and_device);
str = str_parms_to_str(param);
apm->mp_client_interface->set_parameters(apm->mService, usb_info->output_handle, str, 0);
str_parms_destroy(param);
usb_info->state=IO_CONNECTED;
return 0;
}
static int usb_close_output(hw_ext_module_t * hw_module,audio_devices_t device){
struct usb_internal_data_s * usb_info = (struct usb_internal_data_s *)hw_module->data;
audio_policy_anm *apm=hw_module->apm;
struct str_parms *param;
if(usb_info==NULL)
return -1;
switch(usb_info->state) {
case IO_OPENED:
case IO_DISCONNECTED:
//continue treatment
break;
case IO_CONNECTED:
ALOG_WARN("usb_close_output : USB output is not in disconnected state ; Impossible to close it");
return -1;
break;
case IO_CLOSED:
ALOG_WARN("usb_close_output : already closed");
return 0;
break;
default:
ALOG_WARN("usb_close_output : unknown state");
}
if (usb_info->output_handle <=0 ) {
ALOG_WARN("USB output is invalid ; Impossible to connect it");
return -1;
}
ALOG_INFO("USB request closing ");
param = str_parms_create_str("closing");
str_parms_add_str(param, "closing", "true");
apm->mp_client_interface->set_parameters(apm->mService, usb_info->output_handle, str_parms_to_str(param), 0);
str_parms_destroy(param);
apm->mp_client_interface->close_output(apm->mService, usb_info->output_handle);
ALOG_INFO("Usb closed ");
return(usb_init(hw_module));
}
/*
* Extract the card and device numbers from the supplied key/value pairs.
* kvpairs A null-terminated string containing the key/value pairs or card and device.
* i.e. "card=1;device=42"
* card A pointer to a variable to receive the parsed-out card number.
* device A pointer to a variable to receive the parsed-out device number.
* NOTE: The variables pointed to by card and device return -1 (undefined) if the
* associated key/value pair is not found in the provided string.
* Return true if the kvpairs string contain a card/device spec, false otherwise.
*/
static bool parse_card_device_params(const char *kvpairs, int *card, int *device)
{
struct str_parms * parms = str_parms_create_str(kvpairs);
char value[32];
int param_val;
// initialize to "undefined" state.
*card = -1;
*device = -1;
param_val = str_parms_get_str(parms, "card", value, sizeof(value));
if (param_val >= 0) {
*card = atoi(value);
}
param_val = str_parms_get_str(parms, "device", value, sizeof(value));
if (param_val >= 0) {
*device = atoi(value);
}
str_parms_destroy(parms);
return *card >= 0 && *device >= 0;
}
static int audio_hw_set_parameters(struct audio_hw_device *dev,
const char *kvpairs)
{
struct tinyalsa_audio_device *device;
struct str_parms *parms;
char value_string[32] = { 0 };
int value;
int rc;
ALOGD("%s(%p, %s)++", __func__, dev, kvpairs);
if(dev == NULL || kvpairs == NULL)
return -1;
device = (struct tinyalsa_audio_device *) dev;
if(device->mixer == NULL)
return -1;
parms = str_parms_create_str(kvpairs);
if(parms == NULL)
return -1;
rc = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING, value_string, sizeof(value_string));
if(rc < 0)
goto error_params;
value = atoi(value_string);
pthread_mutex_lock(&device->lock);
if(audio_is_output_device((audio_devices_t) value)) {
if(device->stream_out != NULL && device->stream_out->device_current != (audio_devices_t) value) {
pthread_mutex_lock(&device->stream_out->lock);
audio_out_set_route(device->stream_out, (audio_devices_t) value);
pthread_mutex_unlock(&device->stream_out->lock);
}
if(device->ril_interface != NULL && device->ril_interface->device_current != (audio_devices_t) value) {
audio_ril_interface_set_route(device->ril_interface, (audio_devices_t) value);
}
} else if(audio_is_input_device((audio_devices_t) value)) {
if(device->stream_in != NULL && device->stream_in->device_current != (audio_devices_t) value) {
pthread_mutex_lock(&device->stream_in->lock);
audio_in_set_route(device->stream_in, (audio_devices_t) value);
pthread_mutex_unlock(&device->stream_in->lock);
}
}
pthread_mutex_unlock(&device->lock);
str_parms_destroy(parms);
ALOGD("%s(%p, %s)--", __func__, dev, kvpairs);
return 0;
error_params:
str_parms_destroy(parms);
ALOGD("%s(%p, %s)-- (PARAMETER ERROR)", __func__, dev, kvpairs);
return -1;
}
char * hdmi_out_get_parameters(const struct audio_stream *stream,
const char *keys)
{
struct str_parms *query = str_parms_create_str(keys);
char *str;
char value[256];
struct str_parms *reply = str_parms_create();
int status;
hdmi_audio_caps_t caps;
TRACEM("stream=%p keys='%s'", stream, keys);
if (hdmi_query_audio_caps(HDMI_EDID_PATH, &caps)) {
ALOGE("Unable to get the HDMI audio capabilities");
str = calloc(1, 1);
goto end;
}
status = str_parms_get_str(query, AUDIO_PARAMETER_STREAM_SUP_CHANNELS,
value, sizeof(value));
if (status >= 0) {
unsigned sa = caps.speaker_alloc;
bool first = true;
/* STEREO is intentionally skipped. This code is only
* executed for the 'DIRECT' interface, and we don't
* want stereo on a DIRECT thread.
*/
value[0] = '\0';
if (SUPPORTS_ARR(sa, MASK_CEA_QUAD)) {
if (!first) {
strcat(value, "|");
}
first = false;
strcat(value, "AUDIO_CHANNEL_OUT_QUAD");
}
if (SUPPORTS_ARR(sa, MASK_CEA_SURROUND)) {
if (!first) {
strcat(value, "|");
}
first = false;
strcat(value, "AUDIO_CHANNEL_OUT_SURROUND");
}
if (SUPPORTS_ARR(sa, MASK_CEA_5POINT1)) {
if (!first) {
strcat(value, "|");
}
first = false;
strcat(value, "AUDIO_CHANNEL_OUT_5POINT1");
}
if (SUPPORTS_ARR(sa, MASK_CEA_7POINT1)) {
if (!first) {
strcat(value, "|");
}
first = false;
strcat(value, "AUDIO_CHANNEL_OUT_7POINT1");
}
str_parms_add_str(reply, AUDIO_PARAMETER_STREAM_SUP_CHANNELS, value);
str = strdup(str_parms_to_str(reply));
} else {
str = strdup(keys);
}
ALOGV("%s() reply: '%s'", __func__, str);
end:
str_parms_destroy(query);
str_parms_destroy(reply);
return str;
}
