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; }