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 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 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;
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 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 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 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 hdmi_adev_set_parameters(audio_hw_device_t *dev, const char *kv_pairs)
{
TRACEM("dev=%p kv_pairss='%s'", dev, kv_pairs);
struct str_parms *params;
char *str;
char value[HDMI_MAX_CHANNELS];
int ret, x, val, numMatch = 0;
struct hdmi_device_t *adev = (struct hdmi_device_t *)dev;
params = str_parms_create_str(kv_pairs);
//Handle maximum of 8 channels
ret = str_parms_get_str(params, "channel_map", value, HDMI_MAX_CHANNELS);
if (ret >= 0) {
val = strtol(value, NULL, 10);
for(x = 0; x < HDMI_MAX_CHANNELS; x++) {
adev->map[x] = (val & (0xF << x*4)) >> x*4;
if (adev->map[x] == cea_channel_map[x])
numMatch += 1;
}
if (numMatch >= 5)
adev->CEAMap = true;
else
adev->CEAMap = false;
}
void audio_extn_pm_set_parameters(struct str_parms *parms)
{
int ret;
char value[32];
ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_DEV_SHUTDOWN, value, sizeof(value));
if (ret >= 0) {
if (strstr(value, "true")) {
ALOGD("Device shutdown notification received, unregister with PM");
audio_extn_pm_unvote();
}
}
}
void audio_extn_a2dp_set_parameters(struct str_parms *parms)
{
int ret, val;
char value[32]={0};
ret = str_parms_get_str(parms, AUDIO_PARAMETER_DEVICE_CONNECT, value,
sizeof(value));
if( ret >= 0) {
val = atoi(value);
if (val & AUDIO_DEVICE_OUT_ALL_A2DP) {
ALOGV("Received device connect request for A2DP");
open_a2dp_output();
}
}
ret = str_parms_get_str(parms, AUDIO_PARAMETER_DEVICE_DISCONNECT, value,
sizeof(value));
if( ret >= 0) {
val = atoi(value);
if (val & AUDIO_DEVICE_OUT_ALL_A2DP) {
ALOGV("Received device dis- connect request");
close_a2dp_output();
}
}
ret = str_parms_get_str(parms, "A2dpSuspended", value, sizeof(value));
if (ret >= 0) {
if (a2dp.a2dp_device && a2dp.a2dp_stream) {
a2dp.a2dp_device->set_parameters(a2dp.a2dp_device, str_parms_to_str(parms));
if (!strncmp(value,"true",sizeof(value))) {
a2dp.a2dp_suspended = true;
} else {
a2dp.a2dp_suspended = false;
}
}
}
}
/*
* 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;
}
