String8 A2dpAudioInterface::getParameters(const String8& keys)
{
AudioParameter param = AudioParameter(keys);
AudioParameter a2dpParam = AudioParameter();
String8 value;
String8 key;
key = "bluetooth_enabled";
if (param.get(key, value) == NO_ERROR) {
value = mBluetoothEnabled ? "true" : "false";
a2dpParam.add(key, value);
param.remove(key);
}
key = "A2dpSuspended";
if (param.get(key, value) == NO_ERROR) {
value = mSuspended ? "true" : "false";
a2dpParam.add(key, value);
param.remove(key);
}
String8 keyValuePairs = a2dpParam.toString();
if (param.size()) {
if (keyValuePairs != "") {
keyValuePairs += ";";
}
keyValuePairs += mHardwareInterface->getParameters(param.toString());
}
LOGV("getParameters() %s", keyValuePairs.string());
return keyValuePairs;
}
status_t A2dpAudioInterface::setParameters(const String8& keyValuePairs)
{
AudioParameter param = AudioParameter(keyValuePairs);
String8 value;
String8 key;
status_t status = NO_ERROR;
LOGV("setParameters() %s", keyValuePairs.string());
key = "bluetooth_enabled";
if (param.get(key, value) == NO_ERROR) {
mBluetoothEnabled = (value == "true");
if (mOutput) {
mOutput->setBluetoothEnabled(mBluetoothEnabled);
}
param.remove(key);
}
key = String8("A2dpSuspended");
if (param.get(key, value) == NO_ERROR) {
mSuspended = (value == "true");
if (mOutput) {
mOutput->setSuspended(mSuspended);
}
param.remove(key);
}
if (param.size()) {
status_t hwStatus = mHardwareInterface->setParameters(param.toString());
if (status == NO_ERROR) {
status = hwStatus;
}
}
return status;
}
String8 AudioALSAStreamOut::getParameters(const String8 &keys)
{
#ifdef MTK_DYNAMIC_CHANGE_HAL_BUFFER_SIZE
ALOGD("%s, keyvalue %s", __FUNCTION__, keys.string());
String8 value;
String8 keyLowLatency = String8("LowLatency");
AudioParameter param = AudioParameter(keys);
AudioParameter returnParam = AudioParameter();
if (param.get(keyLowLatency, value) == NO_ERROR)
{
param.remove(keyLowLatency);
char buf[10];
sprintf(buf, "%d", LOW_LATENCY_HAL_BUFFER_SIZE);
returnParam.add(keyLowLatency, String8(buf));
}
const String8 keyValuePairs = returnParam.toString();
ALOGD("-%s(), return \"%s\"", __FUNCTION__, keyValuePairs.string());
return keyValuePairs;
#else
ALOGD("%s()", __FUNCTION__);
AudioParameter param = AudioParameter(keys);
return param.toString();
#endif
}
String8 A2dpAudioInterface::A2dpAudioStreamOut::getParameters(const String8& keys)
{
AudioParameter param = AudioParameter(keys);
String8 value;
String8 key = String8("a2dp_sink_address");
if (param.get(key, value) == NO_ERROR) {
value = mA2dpAddress;
param.add(key, value);
}
key = AudioParameter::keyRouting;
if (param.get(key, value) == NO_ERROR) {
param.addInt(key, (int)mDevice);
}
LOGV("A2dpAudioStreamOut::getParameters() %s", param.toString().string());
return param.toString();
}
status_t AudioHardware::setParameters(const String8& keyValuePairs)
{
AudioParameter param = AudioParameter(keyValuePairs);
String8 value;
String8 key;
const char BT_NREC_KEY[] = "bt_headset_nrec";
const char BT_NAME_KEY[] = "bt_headset_name";
const char BT_NREC_VALUE_ON[] = "on";
LOGV("setParameters() %s", keyValuePairs.string());
if (keyValuePairs.length() == 0) return BAD_VALUE;
key = String8(BT_NREC_KEY);
if (param.get(key, value) == NO_ERROR) {
if (value == BT_NREC_VALUE_ON) {
mBluetoothNrec = true;
} else {
mBluetoothNrec = false;
LOGI("Turning noise reduction and echo cancellation off for BT "
"headset");
}
}
key = String8(BT_NAME_KEY);
if (param.get(key, value) == NO_ERROR) {
mBluetoothId = 0;
for (int i = 0; i < mNumSndEndpoints; i++) {
if (!strcasecmp(value.string(), mSndEndpoints[i].name)) {
mBluetoothId = mSndEndpoints[i].id;
LOGI("Using custom acoustic parameters for %s", value.string());
break;
}
}
if (mBluetoothId == 0) {
LOGI("Using default acoustic parameters "
"(%s not in acoustic database)", value.string());
doRouting();
}
}
return NO_ERROR;
}
char* AudioHardwareOutput::getParameters(const char* keys) {
Settings s;
// Explicit scope for auto-lock pattern.
{
// Snapshot the current settings so we don't have to hold the settings
// lock while formatting the results.
Mutex::Autolock _l(mSettingsLock);
s = mSettings;
}
AudioParameter param = AudioParameter(String8(keys));
String8 tmp;
/***************************************************************
* HDMI Audio Options *
***************************************************************/
if (param.get(kHDMIAllowedParamKey, tmp) == NO_ERROR)
param.addInt(kHDMIAllowedParamKey, s.hdmi.allowed ? 1 : 0);
if (param.get(kHDMIDelayCompParamKey, tmp) == NO_ERROR)
param.addFloat(kHDMIDelayCompParamKey,
static_cast<float>(s.hdmi.delayCompUsec) / 1000.0);
if (param.get(kFixedHDMIOutputParamKey, tmp) == NO_ERROR)
param.addInt(kFixedHDMIOutputParamKey, s.hdmi.isFixed ? 1 : 0);
if (param.get(kFixedHDMIOutputLevelParamKey, tmp) == NO_ERROR)
param.addFloat(kFixedHDMIOutputLevelParamKey, s.hdmi.fixedLvl);
/***************************************************************
* Other Options *
***************************************************************/
if (param.get(kVideoDelayCompParamKey, tmp) == NO_ERROR)
param.addFloat(kVideoDelayCompParamKey,
static_cast<float>(s.videoDelayCompUsec) / 1000.0);
return strdup(param.toString().string());
}
String8 AudioAACStreamIn::getParameters(const String8& keys)
{
AudioParameter param = AudioParameter(keys);
String8 value;
String8 key = String8(AudioParameter::keyRouting);
if (param.get(key, value) == NO_ERROR) {
param.addInt(key, (int)mDevice);
}
ALOGV("getParameters() %s", param.toString().string());
return param.toString();
}
String8 AudioStreamInMotorola::getParameters(const String8& keys)
{
AudioParameter param = AudioParameter(keys);
String8 value;
String8 key = String8(AudioParameter::keyRouting);
if (param.get(key, value) == NO_ERROR) {
param.addInt(key, (int)mDevices);
}
LOGD("getParameters(%s)", param.toString().string());
return param.toString();
}
status_t A2dpAudioInterface::A2dpAudioStreamOut::setParameters(const String8& keyValuePairs)
{
AudioParameter param = AudioParameter(keyValuePairs);
String8 value;
String8 key = String8("a2dp_sink_address");
status_t status = NO_ERROR;
int device;
LOGV("A2dpAudioStreamOut::setParameters() %s", keyValuePairs.string());
if (param.get(key, value) == NO_ERROR) {
if (value.length() != strlen("00:00:00:00:00:00")) {
status = BAD_VALUE;
} else {
setAddress(value.string());
}
param.remove(key);
}
key = String8("closing");
if (param.get(key, value) == NO_ERROR) {
mClosing = (value == "true");
param.remove(key);
}
key = AudioParameter::keyRouting;
if (param.getInt(key, device) == NO_ERROR) {
if (AudioSystem::isA2dpDevice((AudioSystem::audio_devices)device)) {
mDevice = device;
status = NO_ERROR;
} else {
status = BAD_VALUE;
}
param.remove(key);
}
if (param.size()) {
status = BAD_VALUE;
}
return status;
}
String8 AudioHardware::AudioStreamOutMSM72xx::getParameters(const String8& keys)
{
AudioParameter param = AudioParameter(keys);
String8 value;
String8 key = String8(AudioParameter::keyRouting);
if (param.get(key, value) == NO_ERROR) {
LOGV("get routing %x", mDevices);
param.addInt(key, (int)mDevices);
}
LOGV("AudioStreamOutMSM72xx::getParameters() %s", param.toString().string());
return param.toString();
}
status_t AudioResourceManager::setParameter(const String8& keyValuePairs) {
String8 key;
String8 value;
status_t status = NO_ERROR;
AudioParameter param = AudioParameter(keyValuePairs);
Mutex::Autolock autolock(mLock);
ALOGD(" setParameter %s:", keyValuePairs.string());
for(uint8_t i=0; i < ARRAY_SIZE(sUseCaseNameToEnumValue); i++) {
key = sUseCaseNameToEnumValue[i].name;
if (param.get(key, value) == NO_ERROR) {
audio_use_case_value_t useCase =
(audio_use_case_value_t) extractMetaData(
sUseCaseNameToEnumValue,
ARRAY_SIZE(sUseCaseNameToEnumValue),
key);
ALOGD("key = %s, value = %s, useCase = %d",
key.string(), value.string(), (int32_t)useCase);
if(value == "true") {
// check if there is a conflicting usecase
// if yes, return error without updating the refCount
// if no increment the refCount
ALOGV("handleConcurrency");
status = handleConcurrency(useCase, true);
}
else if(value == "false") {
// Decrement the refCount
ALOGV("updateUsecaseRefCount");
status = updateUsecaseRefCount(useCase, false);
}
else {
ALOGE(" Wrong value set for use case = %s", key.string());
status = BAD_VALUE;
}
break;
} else {
status = NAME_NOT_FOUND;
ALOGV("Not a concurrency setParameter - Not an error");
}
}
param.remove(key);
return status;
}
String8 AudioStreamInWrapper::getParameters(const String8& keys)
{
LOGV("AudioStreamInWrapper::getParameters(\"%s\")", keys.string());
AudioParameter param = AudioParameter(keys);
String8 value;
String8 key = String8(AudioParameter::keyRouting);
if (param.get(key, value) == NO_ERROR) {
LOGV("get routing %x", mDevices);
param.addInt(key, (int)mDevices);
}
LOGV("AudioStreamInWrapper::getParameters() %s", param.toString().string());
return param.toString();
}
bool WrappedJucePlugin::loadPluginStuff ()
{
if (instance)
{
int numParams = instance->getNumParameters();
setNumParameters (numParams);
for (int i=0; i<numParams; i++)
{
AudioParameter* parameter = new AudioParameter ();
parameter->part (i);
parameter->name (instance->getParameterName(i));
parameter->get (MakeDelegate (this, &WrappedJucePlugin::getParameterReal));
parameter->set (MakeDelegate (this, &WrappedJucePlugin::setParameterReal));
parameter->text (MakeDelegate (this, &WrappedJucePlugin::getParameterTextReal));
registerParameter(i, parameter);
}
}
return true;
}
//==============================================================================
bool LadspaPlugin::loadPluginFromFile (const File& filePath)
{
ptrLibrary = PlatformUtilities::loadDynamicLibrary (filePath.getFullPathName());
if (ptrLibrary != 0)
{
LADSPA_Descriptor_Function pfDescriptorFunction
= (LADSPA_Descriptor_Function)
PlatformUtilities::getProcedureEntryPoint (ptrLibrary, T("ladspa_descriptor"));
if (pfDescriptorFunction != 0)
{
for (uint32 iPluginIndex = 0;; iPluginIndex++)
{
ptrPlug = pfDescriptorFunction (iPluginIndex);
if (ptrPlug != NULL)
break;
}
if (ptrPlug == 0)
{
printf ("Cannot find any valid descriptor in shared library \n");
return false;
}
}
else
{
// plugin raised an exception
printf ("Cannot find any valid plugin in shared library \n");
return false;
}
}
else
{
printf ("You are trying to load a shared library ? \n");
return false;
}
jassert (ptrPlug);
pluginFile = filePath;
plugin = ptrPlug->instantiate (ptrPlug, (unsigned int) samplingRate);
ins.clear ();
outs.clear ();
pars.clear ();
for (unsigned int i = 0; i < ptrPlug->PortCount; i++)
{
if (ptrPlug->PortDescriptors [i] & LADSPA_PORT_CONTROL) pars.add (i);
if (ptrPlug->PortDescriptors [i] & LADSPA_PORT_AUDIO)
{
if (ptrPlug->PortDescriptors [i] & LADSPA_PORT_INPUT) ins.add (i);
if (ptrPlug->PortDescriptors [i] & LADSPA_PORT_OUTPUT) outs.add (i);
}
}
int numParams = pars.size ();
params = new float [numParams];
normalized = new float [numParams];
memset (params, 0, numParams * sizeof (float));
memset (normalized, 0, numParams * sizeof (float));
for (int i = 0; i < numParams; i++)
ptrPlug->connect_port (plugin, pars [i], &normalized[i]);
// create params
setNumParameters (numParams);
for (int i = 0; i < numParams; i++)
{
AudioParameter* parameter = new AudioParameter ();
parameter->part (i);
parameter->name (ptrPlug->PortNames [pars [i]]);
parameter->get (MakeDelegate (this, &LadspaPlugin::getParameterReal));
parameter->set (MakeDelegate (this, &LadspaPlugin::setParameterReal));
parameter->text (MakeDelegate (this, &LadspaPlugin::getParameterTextReal));
registerParameter (i, parameter);
}
// setCurrentProgram (0);
return true;
}
//==============================================================================
bool DssiPlugin::loadPluginFromFile (const File& filePath)
{
ptrLibrary = PlatformUtilities::loadDynamicLibrary (filePath.getFullPathName());
if (ptrLibrary != 0)
{
DSSI_Descriptor_Function pfDescriptorFunction
= (DSSI_Descriptor_Function)
PlatformUtilities::getProcedureEntryPoint (ptrLibrary, T("dssi_descriptor"));
if (pfDescriptorFunction != 0)
{
for (uint32 iPluginIndex = 0;; iPluginIndex++)
{
ptrPlug = pfDescriptorFunction (iPluginIndex);
if (ptrPlug != NULL)
break;
}
if (ptrPlug == 0)
{
printf ("Cannot find any valid descriptor in shared library \n");
return false;
}
}
else
{
// plugin raised an exception
printf ("Cannot find any valid plugin in shared library \n");
return false;
}
}
else
{
printf ("You are trying to load a shared library ? \n");
return false;
}
jassert (ptrPlug);
pluginFile = filePath;
ladspa = ptrPlug->LADSPA_Plugin;
// version = ptrPlug->DSSI_API_Version;
plugin = ladspa->instantiate (ladspa, (unsigned int) samplingRate);
/*
if (ptrPlug->configure)
ptrPlug->configure (DSSI_PROJECT_DIRECTORY_KEY, (const char*) filePath.getParentDirectory()
.getFullPathName ());
*/
// count ports
ins.clear ();
outs.clear ();
pars.clear ();
for (uint i = 0; i < ladspa->PortCount; i++)
{
LADSPA_PortDescriptor pod = ladspa->PortDescriptors[i];
if (pod & LADSPA_PORT_AUDIO)
{
if (pod & LADSPA_PORT_INPUT) ins.add (i);
else if (pod & LADSPA_PORT_OUTPUT) outs.add (i);
}
else if (pod & LADSPA_PORT_CONTROL)
{
pars.add (i);
}
}
// create ports
int numParams = pars.size ();
params = new float [numParams];
normalized = new float [numParams];
memset (params, 0, numParams * sizeof (float));
memset (normalized, 0, numParams * sizeof (float));
// connect ports
if (ladspa->connect_port)
{
for (int i = 0; i < pars.size (); i++)
ladspa->connect_port (plugin, pars [i], &normalized[i]);
for (int i = 0; i < ins.size (); i++)
ladspa->connect_port (plugin, ins [i], emptyBuffer.getSampleData (0));
for (int i = 0; i < outs.size (); i++)
ladspa->connect_port (plugin, outs [i], emptyBuffer.getSampleData (0));
}
// count programs
if (ptrPlug->get_program)
for (numPrograms = 0; ptrPlug->get_program (plugin, numPrograms); ++numPrograms);
// set default to 0
// setCurrentProgram (0);
setDefaultProgram ();
// start osc listener to itself
osc.setPort (18910);
osc.setRootAddress ("dssi");
osc.addListener (this);
osc.startListening ();
DBG ("DssiPlugin::loadPluginFromFile");
// create params
setNumParameters (numParams);
for (int i = 0; i < numParams; i++)
{
AudioParameter* parameter = new AudioParameter ();
parameter->part (i);
parameter->name (ladspa->PortNames [pars [i]]);
parameter->get (MakeDelegate (this, &DssiPlugin::getParameterReal));
parameter->set (MakeDelegate (this, &DssiPlugin::setParameterReal));
parameter->text (MakeDelegate (this, &DssiPlugin::getParameterTextReal));
registerParameter (i, parameter);
}
return true;
}
