static struct pa_policy_group* get_group(struct userdata *u, const char *group_name, pa_proplist *sinp_proplist, uint32_t *flags_ret)
{
struct pa_policy_group *group = NULL;
const void *flags;
size_t len_flags = 0;
pa_assert(u);
pa_assert(sinp_proplist);
/* If group name is provided use that, otherwise check sink input proplist. */
if (!group_name)
/* Just grab the group name from the proplist to avoid classifying multiple
* times (and to avoid classifying incorrectly if properties are
* overwritten when handling PA_CORE_HOOK_SINK_INPUT_NEW).*/
group_name = pa_proplist_gets(sinp_proplist, PA_PROP_POLICY_GROUP);
if (group_name && (group = pa_policy_group_find(u, group_name)) != NULL) {
/* Only update flags if flags_ret is non null */
if (flags_ret) {
if (pa_proplist_get(sinp_proplist, PA_PROP_POLICY_STREAM_FLAGS, &flags, &len_flags) < 0 ||
len_flags != sizeof(uint32_t)) {
pa_log_warn("No stream flags in proplist or malformed flags.");
*flags_ret = 0;
} else
*flags_ret = *(uint32_t *)flags;
}
}
return group;
}
void pa_dbus_append_proplist(DBusMessageIter *iter, pa_proplist *proplist) {
DBusMessageIter dict_iter;
DBusMessageIter dict_entry_iter;
DBusMessageIter array_iter;
void *state = NULL;
const char *key;
pa_assert(iter);
pa_assert(proplist);
pa_assert_se(dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, "{say}", &dict_iter));
while ((key = pa_proplist_iterate(proplist, &state))) {
const void *value = NULL;
size_t nbytes;
pa_assert_se(pa_proplist_get(proplist, key, &value, &nbytes) >= 0);
pa_assert_se(dbus_message_iter_open_container(&dict_iter, DBUS_TYPE_DICT_ENTRY, NULL, &dict_entry_iter));
pa_assert_se(dbus_message_iter_append_basic(&dict_entry_iter, DBUS_TYPE_STRING, &key));
pa_assert_se(dbus_message_iter_open_container(&dict_entry_iter, DBUS_TYPE_ARRAY, "y", &array_iter));
pa_assert_se(dbus_message_iter_append_fixed_array(&array_iter, DBUS_TYPE_BYTE, &value, nbytes));
pa_assert_se(dbus_message_iter_close_container(&dict_entry_iter, &array_iter));
pa_assert_se(dbus_message_iter_close_container(&dict_iter, &dict_entry_iter));
}
pa_assert_se(dbus_message_iter_close_container(iter, &dict_iter));
}
JNIEXPORT jint JNICALL
Java_org_jitsi_impl_neomedia_pulseaudio_PA_format_1info_1get_1prop_1int
(JNIEnv *env, jclass clazz, jlong f, jstring key)
{
const char *keyChars
= key ? (*env)->GetStringUTFChars(env, key, NULL) : NULL;
int ret;
if ((*env)->ExceptionCheck(env))
ret = 0;
else
{
pa_proplist *plist = ((pa_format_info *) (intptr_t) f)->plist;
if (plist)
{
const void *data = NULL;
size_t nbytes = 0;
pa_proplist_get(plist, keyChars, &data, &nbytes);
ret = (data && (nbytes == sizeof(int))) ? *((const int *) data) : 0;
}
else
ret = 0;
if (keyChars)
(*env)->ReleaseStringUTFChars(env, key, keyChars);
}
return ret;
}
void
voice_sink_proplist_update(struct userdata *u, pa_sink *s)
{
pa_sink *master_sink;
const char *mode;
const char *accessory_hwid;
pa_proplist *p;
char *hash_str;
unsigned int hash;
const char *file;
char fname[256];
size_t nbytes;
const void *data;
master_sink = voice_get_original_master_sink(u);
ENTER();
if (!master_sink)
{
pa_log_warn("Original master sink not found, parameters not loaded.");
return;
}
if (!pa_proplist_get(s->proplist, "x-maemo.aep.trace-func", &data, &nbytes))
memcpy(&u->trace_func, data, sizeof(u->trace_func));
mode = pa_proplist_gets(s->proplist, PA_NOKIA_PROP_AUDIO_MODE);
accessory_hwid = pa_proplist_gets(s->proplist,
PA_NOKIA_PROP_AUDIO_ACCESSORY_HWID);
if (!accessory_hwid || !mode)
return;
if (master_sink != s)
{
p = pa_proplist_new();
pa_proplist_sets(p, PA_NOKIA_PROP_AUDIO_MODE, mode);
pa_proplist_sets(p, PA_NOKIA_PROP_AUDIO_ACCESSORY_HWID, accessory_hwid);
pa_proplist_update(master_sink->proplist, PA_UPDATE_REPLACE, p);
pa_proplist_free(p);
}
hash_str = pa_sprintf_malloc("%s%s", mode, accessory_hwid);
hash = pa_idxset_string_hash_func(hash_str);
pa_xfree(hash_str);
if (hash == u->mode_accessory_hwid_hash &&
!voice_pa_proplist_get_bool(master_sink->proplist, "x-maemo.tuning"))
return;
u->mode_accessory_hwid_hash = hash;
file = pa_proplist_gets(master_sink->proplist, "x-maemo.file");
if (!file)
file = "/var/lib/pulse-nokia/%s%s.parameters";
pa_snprintf(fname, sizeof(fname), file, mode);
pa_log_debug("Loading tuning parameters from file: %s",fname);
p = pa_nokia_proplist_from_file(fname);
if (!pa_proplist_contains(p, "x-maemo.aep") )
{
pa_log_warn("Parameter file not valid: %s", fname);
pa_proplist_free(p);
return;
}
u->btmono = FALSE;
if (!strcmp(mode, "ihf"))
aep_runtime_switch[3] = 'i';
else if (!strcmp(mode, "hs"))
aep_runtime_switch[3] = 't';
else if (!strcmp(mode, "btmono"))
{
aep_runtime_switch[3] = 't';
u->btmono = TRUE;
}
else if (!strcmp(mode, "hp"))
aep_runtime_switch[3] = 'p';
else if (!strcmp(mode, "lineout"))
aep_runtime_switch[3] = 'f';
else
aep_runtime_switch[3] = 't';
if (master_sink == s)
pa_proplist_update(master_sink->proplist, PA_UPDATE_REPLACE, p);
else
pa_sink_update_proplist(master_sink, PA_UPDATE_REPLACE, p);
pa_proplist_free(p);
voice_update_parameters(u);
return;
}
void voice_update_parameters(struct userdata *u)
{
pa_sink *sink;
const char *s;
double tmp_d, old_d;
int tmp, old;
size_t nbytes;
const void *data;
ENTER();
sink = voice_get_original_master_sink(u);
if (!sink)
{
pa_log_warn("Original master sink not found, parameters not updated.");
return;
}
u->updating_parameters = TRUE;
if (!pa_proplist_get(sink->proplist, "x-maemo.xprot.parameters.left", &data, &nbytes))
xprot_change_params(u->xprot, data, nbytes, 0);
if (!pa_proplist_get(sink->proplist,"x-maemo.xprot.parameters.right", &data, &nbytes))
xprot_change_params(u->xprot, data, nbytes, 1);
s = voice_pa_proplist_gets(sink->proplist, "x-maemo.cmt.ul_timing_advance");
old = u->ul_timing_advance;
if (!pa_atoi(s, &tmp) && tmp > -5000 && tmp < 5000)
u->ul_timing_advance = tmp;
pa_log_debug("cmt_ul_timing_advance \"%s\" %d %d", s, u->ul_timing_advance, old);
s = voice_pa_proplist_gets(sink->proplist, "x-maemo.alt_mixer_compensation");
/* CHECKME */
old_d = u->alt_mixer_compensation;
if (!pa_atod(s, &tmp_d) && tmp_d > 0.0 && tmp_d <= 60.0) /* < 60.0 ? */
u->alt_mixer_compensation = pa_sw_volume_from_dB(tmp_d);
pa_log_debug("alt_mixer_compensation \"%s\" %d %f", s, u->alt_mixer_compensation, old_d);
s = voice_pa_proplist_gets(sink->proplist, "x-maemo.ear_ref_padding");
old = u->ear_ref.loop_padding_usec ;
if (!pa_atoi(s, &tmp) && tmp > -10000 && tmp < 199999)
u->ear_ref.loop_padding_usec = tmp;
pa_log_debug("ear_ref_padding \"%s\" %d %d", s, u->ear_ref.loop_padding_usec, old);
voice_parse_aep_steps(u, voice_pa_proplist_gets(sink->proplist, "x-maemo.audio_aep_mb_steps"));
s = voice_pa_proplist_gets(sink->proplist, "x-maemo.nrec");
u->nrec_enable = pa_parse_boolean(s);
if (u->master_source &&
pa_proplist_gets(u->master_source->proplist, "bluetooth.nrec"))
{
/* WTF ?!? */
u->sidetone_enable = pa_parse_boolean(s) && u->nrec_enable;
}
if (!pa_proplist_get(sink->proplist, "x-maemo.aep.switches",
(const void **)&data, &nbytes) )
{
uint16_t *as = (uint16_t *)data;
aep_switches.field_0 = as[0];
aep_switches.field_2 = as[1];
aep_switches.field_4 = 0;
if ( aep_switches.field_0 & 0x400 )
aep_switches.field_4 = 0x30;
if (aep_switches.field_0 & 1)
aep_switches.field_4 |= 0x300u;
aep_switches.field_4 |= 0x1800u;
}
if (!pa_proplist_get(sink->proplist, "x-maemo.aep.parameters", &data, &nbytes))
{
const char *argv[7] =
{
"../execute/d4gnt560",
"b-ai-1n------0---u",
"/dev/null",
"/dev/null",
"/dev/null",
"/dev/null",
"/dev/null",
};
if (strlen(aep_runtime_switch) >= strlen(argv[1]))
argv[1] = aep_runtime_switch;
fprintf(stderr, "AEP runtime switch %s\n", argv[1]);
current_aep_tuning = (void *)data;
init_main(7, argv);
voice_aep_ear_ref_loop_reset(u);
}
sidetone_write_parameters(u);
if (!pa_proplist_get(sink->proplist, "x-maemo.wb_meq.parameters", &data, &nbytes))
iir_eq_change_params(u->wb_mic_iir_eq, data, nbytes);
if (!pa_proplist_get(sink->proplist, "x-maemo.nb_meq.parameters", &data, &nbytes) )
iir_eq_change_params(u->nb_mic_iir_eq, data, nbytes);
if (!pa_proplist_get(sink->proplist,"x-maemo.wb_eeq.parameters", &data, &nbytes))
fir_eq_change_params(u->wb_ear_iir_eq, data, nbytes);
if (!pa_proplist_get(sink->proplist, "x-maemo.nb_eeq.parameters", &data, &nbytes))
iir_eq_change_params(u->nb_ear_iir_eq, data, nbytes);
u->aep_enable = voice_pa_proplist_get_bool(sink->proplist, "x-maemo.aep");
u->wb_meq_enable = voice_pa_proplist_get_bool(sink->proplist, "x-maemo.wb_meq");
u->wb_eeq_enable = voice_pa_proplist_get_bool(sink->proplist, "x-maemo.wb_eeq");
u->nb_meq_enable = voice_pa_proplist_get_bool(sink->proplist, "x-maemo.nb_meq");
u->nb_eeq_enable = voice_pa_proplist_get_bool(sink->proplist, "x-maemo.nb_eeq");
u->xprot->displ_limit = voice_pa_proplist_get_bool(sink->proplist, "x-maemo.xprot.displacement");
u->xprot->temp_limit = voice_pa_proplist_get_bool(sink->proplist, "x-maemo.xprot.temperature");
u->xprot_enable = u->xprot->displ_limit || u->xprot->temp_limit;
u->updating_parameters = FALSE;
}
