int main(int argc, char **argv)
{
pa_cvolume volume, *new_volume;
pa_channel_map channel_map;
float balance;
char buf[1024];
int i;
memset(&volume, 0, sizeof(pa_cvolume));
volume.channels = 4;
volume.values[0] = 1500;
volume.values[1] = 1000;
volume.values[2] = 1000;
volume.values[3] = 1000;
//pa_cvolume_set(&volume, 4, 1500);
memset(&channel_map, 0, sizeof(pa_channel_map));
channel_map.channels = 4;
channel_map.map[0] = 1;
channel_map.map[1] = 2;
channel_map.map[2] = 8;
channel_map.map[3] = 9;
printf("PA_CVOLUME_SNPRINT_MAX: %d\n", PA_CVOLUME_SNPRINT_MAX);
printf("PA_DECIBEL_MININFTY:%f\n", PA_DECIBEL_MININFTY);
printf("PA_SW_CVOLUME_SNPRINT_DB_MAX: %d\n", PA_SW_CVOLUME_SNPRINT_DB_MAX);
printf("PA_SW_VOLUME_SNPRINT_DB_MAX: %d\n", PA_SW_VOLUME_SNPRINT_DB_MAX);
printf("PA_VOLUME_INVALID: %u\n", PA_VOLUME_INVALID);
printf("PA_VOLUME_MAX: %d\n", PA_VOLUME_MAX);
printf("PA_VOLUME_MUTED: %d\n", PA_VOLUME_MUTED);
printf("PA_VOLUME_NORM: %d\n", PA_VOLUME_NORM);
printf("PA_VOLUME_SNPRINT_MAX: %d\n", PA_VOLUME_SNPRINT_MAX);
printf("PA_VOLUME_UI_MAX: %d\n", PA_VOLUME_UI_MAX);
printf("mute dB: %f\n", pa_sw_volume_to_dB(PA_VOLUME_MUTED));
printf("normal dB: %f\n", pa_sw_volume_to_dB(PA_VOLUME_NORM));
printf("ui_max dB: %f\n", pa_sw_volume_to_dB(PA_VOLUME_UI_MAX));
printf("get_balance:%f\n", pa_cvolume_get_balance(&volume, &channel_map));
printf("volume = %s\n", pa_cvolume_snprint(buf, sizeof(buf)-1, &volume));
for (i = 0; i < volume.channels; i++) {
printf("\t%d channel volume: %d\n", i, volume.values[i]);
}
printf("map = %s\n", pa_channel_map_snprint(buf, sizeof(buf)-1, &channel_map));
printf("input new balance:");
scanf("%f", &balance);
new_volume = pa_cvolume_set_balance(&volume, &channel_map, balance);
printf("after get_balance:%f\n", pa_cvolume_get_balance(&volume, &channel_map));
printf("after volume = %s\n", pa_cvolume_snprint(buf, sizeof(buf)-1, &volume));
for (i = 0; i < volume.channels; i++) {
printf("\t%d channel volume: %d\n", i, volume.values[i]);
}
printf("after map = %s\n", pa_channel_map_snprint(buf, sizeof(buf)-1, &channel_map));
return 0;
}
char *pa_scache_list_to_string(pa_core *c) {
pa_strbuf *s;
pa_assert(c);
s = pa_strbuf_new();
pa_strbuf_printf(s, "%u cache entrie(s) available.\n", c->scache ? pa_idxset_size(c->scache) : 0);
if (c->scache) {
pa_scache_entry *e;
uint32_t idx = PA_IDXSET_INVALID;
for (e = pa_idxset_first(c->scache, &idx); e; e = pa_idxset_next(c->scache, &idx)) {
double l = 0;
char ss[PA_SAMPLE_SPEC_SNPRINT_MAX] = "n/a", cv[PA_CVOLUME_SNPRINT_MAX], cvdb[PA_SW_CVOLUME_SNPRINT_DB_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX] = "n/a", *t;
const char *cmn;
cmn = pa_channel_map_to_pretty_name(&e->channel_map);
if (e->memchunk.memblock) {
pa_sample_spec_snprint(ss, sizeof(ss), &e->sample_spec);
pa_channel_map_snprint(cm, sizeof(cm), &e->channel_map);
l = (double) e->memchunk.length / (double) pa_bytes_per_second(&e->sample_spec);
}
pa_strbuf_printf(
s,
" name: <%s>\n"
"\tindex: %u\n"
"\tsample spec: %s\n"
"\tchannel map: %s%s%s\n"
"\tlength: %lu\n"
"\tduration: %0.1f s\n"
"\tvolume: %s\n"
"\t %s\n"
"\t balance %0.2f\n"
"\tlazy: %s\n"
"\tfilename: <%s>\n",
e->name,
e->index,
ss,
cm,
cmn ? "\n\t " : "",
cmn ? cmn : "",
(long unsigned)(e->memchunk.memblock ? e->memchunk.length : 0),
l,
e->volume_is_set ? pa_cvolume_snprint(cv, sizeof(cv), &e->volume) : "n/a",
e->volume_is_set ? pa_sw_cvolume_snprint_dB(cvdb, sizeof(cvdb), &e->volume) : "n/a",
(e->memchunk.memblock && e->volume_is_set) ? pa_cvolume_get_balance(&e->volume, &e->channel_map) : 0.0f,
pa_yes_no(e->lazy),
e->filename ? e->filename : "n/a");
t = pa_proplist_to_string_sep(e->proplist, "\n\t\t");
pa_strbuf_printf(s, "\tproperties:\n\t\t%s\n", t);
pa_xfree(t);
}
}
return pa_strbuf_tostring_free(s);
}
char* output_info_str(const pa_source_output_info* i)
{
char t[32];
char k[32];
char s[PA_SAMPLE_SPEC_SNPRINT_MAX];
char cv[PA_CVOLUME_SNPRINT_MAX];
char cvdb[PA_SW_CVOLUME_SNPRINT_DB_MAX];
char cm[PA_CHANNEL_MAP_SNPRINT_MAX];
char f[PA_FORMAT_INFO_SNPRINT_MAX];
char *pl;
g_snprintf(t, sizeof(t), "%u", i->owner_module);
g_snprintf(k, sizeof(k), "%u", i->client);
char* str = g_strdup_printf(
"Source Output #%u\n"
"Driver: %s\n"
"Owner Module: %s\n"
"Client: %s\n"
"Source: %u\n"
"Sample Specification: %s\n"
"Channel Map: %s\n"
"Format: %s\n"
"Mute: %s\n"
"Volume: %s\n"
" %s\n"
"Balance: %0.2f\n"
"Buffer Latency: %0.0f usec\n"
"Source Latency: %0.0f usec\n"
"Resample method: %s\n"
"Properties:\n\t\t%s",
i->index,
i->driver,
i->owner_module != PA_INVALID_INDEX ? t : "n/a",
i->client != PA_INVALID_INDEX ? k : "n/a",
i->source,
pa_sample_spec_snprint(s, sizeof(s), &i->sample_spec),
pa_channel_map_snprint(cm, sizeof(cm), &i->channel_map),
pa_format_info_snprint(f, sizeof(f), i->format),
i->mute ? "yes" : "no",
pa_cvolume_snprint(cv, sizeof(cv), &i->volume),
pa_sw_cvolume_snprint_dB(cvdb, sizeof(cvdb), &i->volume),
pa_cvolume_get_balance(&i->volume, &i->channel_map),
(double) i->buffer_usec,
(double) i->source_usec,
i->resample_method ? i->resample_method : "n/a",
pl = pa_proplist_to_string_sep(i->proplist, "\n\t\t"));
pa_xfree(pl);
return str;
}
const gdouble *
gvc_channel_map_get_volume (GvcChannelMap *map)
{
g_return_val_if_fail (GVC_IS_CHANNEL_MAP (map), NULL);
if (!pa_channel_map_valid(&map->priv->pa_map))
return NULL;
map->priv->extern_volume[VOLUME] = (gdouble) pa_cvolume_max (&map->priv->pa_volume);
if (gvc_channel_map_can_balance (map))
map->priv->extern_volume[BALANCE] = (gdouble) pa_cvolume_get_balance (&map->priv->pa_volume, &map->priv->pa_map);
else
map->priv->extern_volume[BALANCE] = 0;
if (gvc_channel_map_can_fade (map))
map->priv->extern_volume[FADE] = (gdouble) pa_cvolume_get_fade (&map->priv->pa_volume, &map->priv->pa_map);
else
map->priv->extern_volume[FADE] = 0;
if (gvc_channel_map_has_lfe (map))
map->priv->extern_volume[LFE] = (gdouble) pa_cvolume_get_position (&map->priv->pa_volume, &map->priv->pa_map, PA_CHANNEL_POSITION_LFE);
else
map->priv->extern_volume[LFE] = 0;
return map->priv->extern_volume;
}
char* sink_info_str(const pa_sink_info* i)
{
static const char *state_table[] = {
[1+PA_SINK_INVALID_STATE] = "n/a",
[1+PA_SINK_RUNNING] = "RUNNING",
[1+PA_SINK_IDLE] = "IDLE",
[1+PA_SINK_SUSPENDED] = "SUSPENDED"
};
char s[PA_SAMPLE_SPEC_SNPRINT_MAX];
char cv[PA_CVOLUME_SNPRINT_MAX];
char cvdb[PA_SW_CVOLUME_SNPRINT_DB_MAX];
char v[PA_VOLUME_SNPRINT_MAX];
char vdb[PA_SW_VOLUME_SNPRINT_DB_MAX];
char cm[PA_CHANNEL_MAP_SNPRINT_MAX];
char* pl;
char* str = g_strdup_printf(
"Sink #%u\n"
"State: %s\n"
"Name: %s\n"
"Description: %s\n"
"Driver: %s\n"
"Sample Specification: %s\n"
"Channel Map: %s\n"
"Owner Module: %u\n"
"Mute: %s\n"
"Volume: %s%s%s\n"
"Balance: %0.2f\n"
"Base Volume: %s%s%s%s\n"
"Monitor Source: %s\n"
"Latency: %0.0f usec, configured %0.0f usec\n"
"Flags: %s%s%s%s%s%s%s\n"
"Properties:\n\t\t%s",
i->index,
state_table[1+i->state],
i->name,
i->description,
i->driver,
pa_sample_spec_snprint(s, sizeof(s), &i->sample_spec),
pa_channel_map_snprint(cm, sizeof(cm), &i->channel_map),
i->owner_module,
i->mute ? "yes" : "no",
pa_cvolume_snprint(cv, sizeof(cv), &i->volume),
i->flags & PA_SINK_DECIBEL_VOLUME ? "\n " : "",
i->flags & PA_SINK_DECIBEL_VOLUME ? pa_sw_cvolume_snprint_dB(cvdb, sizeof(cvdb), &i->volume) : "",
pa_cvolume_get_balance(&i->volume, &i->channel_map),
pa_volume_snprint(v, sizeof(v), i->base_volume),
i->flags & PA_SINK_DECIBEL_VOLUME ? " (" : "",
i->flags & PA_SINK_DECIBEL_VOLUME ? pa_sw_volume_snprint_dB(vdb, sizeof(vdb), i->base_volume) : "",
i->flags & PA_SINK_DECIBEL_VOLUME ? ")" : "",
i->monitor_source_name,
(double) i->latency, (double) i->configured_latency,
i->flags & PA_SINK_HARDWARE ? "HARDWARE " : "",
i->flags & PA_SINK_NETWORK ? "NETWORK " : "",
i->flags & PA_SINK_HW_MUTE_CTRL ? "HW_MUTE_CTRL " : "",
i->flags & PA_SINK_HW_VOLUME_CTRL ? "HW_VOLUME_CTRL " : "",
i->flags & PA_SINK_DECIBEL_VOLUME ? "DECIBEL_VOLUME " : "",
i->flags & PA_SINK_LATENCY ? "LATENCY " : "",
i->flags & PA_SINK_SET_FORMATS ? "SET_FORMATS " : "",
pl = pa_proplist_to_string_sep(i->proplist, "\n\t\t"));
pa_xfree(pl);
return str;
}
char *pa_sink_input_list_to_string(pa_core *c) {
pa_strbuf *s;
pa_sink_input *i;
uint32_t idx = PA_IDXSET_INVALID;
static const char* const state_table[] = {
[PA_SINK_INPUT_INIT] = "INIT",
[PA_SINK_INPUT_RUNNING] = "RUNNING",
[PA_SINK_INPUT_DRAINED] = "DRAINED",
[PA_SINK_INPUT_CORKED] = "CORKED",
[PA_SINK_INPUT_UNLINKED] = "UNLINKED"
};
pa_assert(c);
s = pa_strbuf_new();
pa_strbuf_printf(s, "%u sink input(s) available.\n", pa_idxset_size(c->sink_inputs));
for (i = pa_idxset_first(c->sink_inputs, &idx); i; i = pa_idxset_next(c->sink_inputs, &idx)) {
char ss[PA_SAMPLE_SPEC_SNPRINT_MAX], cvdb[PA_SW_CVOLUME_SNPRINT_DB_MAX], cv[PA_CVOLUME_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX], *t, clt[28];
pa_usec_t cl;
const char *cmn;
pa_cvolume v;
char *volume_str = NULL;
cmn = pa_channel_map_to_pretty_name(&i->channel_map);
if ((cl = pa_sink_input_get_requested_latency(i)) == (pa_usec_t) -1)
pa_snprintf(clt, sizeof(clt), "n/a");
else
pa_snprintf(clt, sizeof(clt), "%0.2f ms", (double) cl / PA_USEC_PER_MSEC);
pa_assert(i->sink);
if (pa_sink_input_is_volume_readable(i)) {
pa_sink_input_get_volume(i, &v, TRUE);
volume_str = pa_sprintf_malloc("%s\n\t %s\n\t balance %0.2f",
pa_cvolume_snprint(cv, sizeof(cv), &v),
pa_sw_cvolume_snprint_dB(cvdb, sizeof(cvdb), &v),
pa_cvolume_get_balance(&v, &i->channel_map));
} else
volume_str = pa_xstrdup("n/a");
pa_strbuf_printf(
s,
" index: %u\n"
"\tdriver: <%s>\n"
"\tflags: %s%s%s%s%s%s%s%s%s%s%s\n"
"\tstate: %s\n"
"\tsink: %u <%s>\n"
"\tvolume: %s\n"
"\tmuted: %s\n"
"\tcurrent latency: %0.2f ms\n"
"\trequested latency: %s\n"
"\tsample spec: %s\n"
"\tchannel map: %s%s%s\n"
"\tresample method: %s\n",
i->index,
i->driver,
i->flags & PA_SINK_INPUT_VARIABLE_RATE ? "VARIABLE_RATE " : "",
i->flags & PA_SINK_INPUT_DONT_MOVE ? "DONT_MOVE " : "",
i->flags & PA_SINK_INPUT_START_CORKED ? "START_CORKED " : "",
i->flags & PA_SINK_INPUT_NO_REMAP ? "NO_REMAP " : "",
i->flags & PA_SINK_INPUT_NO_REMIX ? "NO_REMIX " : "",
i->flags & PA_SINK_INPUT_FIX_FORMAT ? "FIX_FORMAT " : "",
i->flags & PA_SINK_INPUT_FIX_RATE ? "FIX_RATE " : "",
i->flags & PA_SINK_INPUT_FIX_CHANNELS ? "FIX_CHANNELS " : "",
i->flags & PA_SINK_INPUT_DONT_INHIBIT_AUTO_SUSPEND ? "DONT_INHIBIT_AUTO_SUSPEND " : "",
i->flags & PA_SINK_INPUT_NO_CREATE_ON_SUSPEND ? "NO_CREATE_SUSPEND " : "",
i->flags & PA_SINK_INPUT_KILL_ON_SUSPEND ? "KILL_ON_SUSPEND " : "",
state_table[pa_sink_input_get_state(i)],
i->sink->index, i->sink->name,
volume_str,
pa_yes_no(pa_sink_input_get_mute(i)),
(double) pa_sink_input_get_latency(i, NULL) / PA_USEC_PER_MSEC,
clt,
pa_sample_spec_snprint(ss, sizeof(ss), &i->sample_spec),
pa_channel_map_snprint(cm, sizeof(cm), &i->channel_map),
cmn ? "\n\t " : "",
cmn ? cmn : "",
pa_resample_method_to_string(pa_sink_input_get_resample_method(i)));
pa_xfree(volume_str);
if (i->module)
pa_strbuf_printf(s, "\tmodule: %u\n", i->module->index);
if (i->client)
pa_strbuf_printf(s, "\tclient: %u <%s>\n", i->client->index, pa_strnull(pa_proplist_gets(i->client->proplist, PA_PROP_APPLICATION_NAME)));
t = pa_proplist_to_string_sep(i->proplist, "\n\t\t");
pa_strbuf_printf(s, "\tproperties:\n\t\t%s\n", t);
pa_xfree(t);
}
return pa_strbuf_tostring_free(s);
}
char *pa_source_list_to_string(pa_core *c) {
pa_strbuf *s;
pa_source *source;
uint32_t idx = PA_IDXSET_INVALID;
pa_assert(c);
s = pa_strbuf_new();
pa_strbuf_printf(s, "%u source(s) available.\n", pa_idxset_size(c->sources));
for (source = pa_idxset_first(c->sources, &idx); source; source = pa_idxset_next(c->sources, &idx)) {
char ss[PA_SAMPLE_SPEC_SNPRINT_MAX],
cv[PA_CVOLUME_SNPRINT_MAX],
cvdb[PA_SW_CVOLUME_SNPRINT_DB_MAX],
v[PA_VOLUME_SNPRINT_MAX],
vdb[PA_SW_VOLUME_SNPRINT_DB_MAX],
cm[PA_CHANNEL_MAP_SNPRINT_MAX], *t;
const char *cmn;
cmn = pa_channel_map_to_pretty_name(&source->channel_map);
pa_strbuf_printf(
s,
" %c index: %u\n"
"\tname: <%s>\n"
"\tdriver: <%s>\n"
"\tflags: %s%s%s%s%s%s%s\n"
"\tstate: %s\n"
"\tsuspend cause: %s%s%s%s\n"
"\tpriority: %u\n"
"\tvolume: %s%s%s\n"
"\t balance %0.2f\n"
"\tbase volume: %s%s%s\n"
"\tvolume steps: %u\n"
"\tmuted: %s\n"
"\tcurrent latency: %0.2f ms\n"
"\tmax rewind: %lu KiB\n"
"\tsample spec: %s\n"
"\tchannel map: %s%s%s\n"
"\tused by: %u\n"
"\tlinked by: %u\n",
c->default_source == source ? '*' : ' ',
source->index,
source->name,
source->driver,
source->flags & PA_SOURCE_HARDWARE ? "HARDWARE " : "",
source->flags & PA_SOURCE_NETWORK ? "NETWORK " : "",
source->flags & PA_SOURCE_HW_MUTE_CTRL ? "HW_MUTE_CTRL " : "",
source->flags & PA_SOURCE_HW_VOLUME_CTRL ? "HW_VOLUME_CTRL " : "",
source->flags & PA_SOURCE_DECIBEL_VOLUME ? "DECIBEL_VOLUME " : "",
source->flags & PA_SOURCE_LATENCY ? "LATENCY " : "",
source->flags & PA_SOURCE_DYNAMIC_LATENCY ? "DYNAMIC_LATENCY" : "",
source_state_to_string(pa_source_get_state(source)),
source->suspend_cause & PA_SUSPEND_USER ? "USER " : "",
source->suspend_cause & PA_SUSPEND_APPLICATION ? "APPLICATION " : "",
source->suspend_cause & PA_SUSPEND_IDLE ? "IDLE " : "",
source->suspend_cause & PA_SUSPEND_SESSION ? "SESSION" : "",
source->priority,
pa_cvolume_snprint(cv, sizeof(cv), pa_source_get_volume(source, FALSE)),
source->flags & PA_SOURCE_DECIBEL_VOLUME ? "\n\t " : "",
source->flags & PA_SOURCE_DECIBEL_VOLUME ? pa_sw_cvolume_snprint_dB(cvdb, sizeof(cvdb), pa_source_get_volume(source, FALSE)) : "",
pa_cvolume_get_balance(pa_source_get_volume(source, FALSE), &source->channel_map),
pa_volume_snprint(v, sizeof(v), source->base_volume),
source->flags & PA_SOURCE_DECIBEL_VOLUME ? "\n\t " : "",
source->flags & PA_SOURCE_DECIBEL_VOLUME ? pa_sw_volume_snprint_dB(vdb, sizeof(vdb), source->base_volume) : "",
source->n_volume_steps,
pa_yes_no(pa_source_get_mute(source, FALSE)),
(double) pa_source_get_latency(source) / PA_USEC_PER_MSEC,
(unsigned long) pa_source_get_max_rewind(source) / 1024,
pa_sample_spec_snprint(ss, sizeof(ss), &source->sample_spec),
pa_channel_map_snprint(cm, sizeof(cm), &source->channel_map),
cmn ? "\n\t " : "",
cmn ? cmn : "",
pa_source_used_by(source),
pa_source_linked_by(source));
if (source->flags & PA_SOURCE_DYNAMIC_LATENCY) {
pa_usec_t min_latency, max_latency;
pa_source_get_latency_range(source, &min_latency, &max_latency);
pa_strbuf_printf(
s,
"\tconfigured latency: %0.2f ms; range is %0.2f .. %0.2f ms\n",
(double) pa_source_get_requested_latency(source) / PA_USEC_PER_MSEC,
(double) min_latency / PA_USEC_PER_MSEC,
(double) max_latency / PA_USEC_PER_MSEC);
} else
pa_strbuf_printf(
s,
"\tfixed latency: %0.2f ms\n",
(double) pa_source_get_fixed_latency(source) / PA_USEC_PER_MSEC);
if (source->monitor_of)
pa_strbuf_printf(s, "\tmonitor_of: %u\n", source->monitor_of->index);
if (source->card)
pa_strbuf_printf(s, "\tcard: %u <%s>\n", source->card->index, source->card->name);
if (source->module)
pa_strbuf_printf(s, "\tmodule: %u\n", source->module->index);
t = pa_proplist_to_string_sep(source->proplist, "\n\t\t");
pa_strbuf_printf(s, "\tproperties:\n\t\t%s\n", t);
pa_xfree(t);
append_port_list(s, source->ports);
if (source->active_port)
pa_strbuf_printf(
s,
"\tactive port: <%s>\n",
source->active_port->name);
}
return pa_strbuf_tostring_free(s);
}
int main(int argc, char *argv[]) {
pa_volume_t v;
pa_cvolume cv;
float b;
pa_channel_map map;
pa_volume_t md = 0;
unsigned mdn = 0;
if (!getenv("MAKE_CHECK"))
pa_log_set_level(PA_LOG_DEBUG);
pa_log("Attenuation of sample 1 against 32767: %g dB", 20.0*log10(1.0/32767.0));
pa_log("Smallest possible attenuation > 0 applied to 32767: %li", lrint(32767.0*pa_sw_volume_to_linear(1)));
for (v = PA_VOLUME_MUTED; v <= PA_VOLUME_NORM*2; v += 256) {
double dB = pa_sw_volume_to_dB(v);
double f = pa_sw_volume_to_linear(v);
pa_log_debug("Volume: %3i; percent: %i%%; decibel %0.2f; linear = %0.2f; volume(decibel): %3i; volume(linear): %3i",
v, (v*100)/PA_VOLUME_NORM, dB, f, pa_sw_volume_from_dB(dB), pa_sw_volume_from_linear(f));
}
for (v = PA_VOLUME_MUTED; v <= PA_VOLUME_NORM*2; v += 256) {
char s[PA_CVOLUME_SNPRINT_MAX], t[PA_SW_CVOLUME_SNPRINT_DB_MAX];
pa_cvolume_set(&cv, 2, v);
pa_log_debug("Volume: %3i [%s] [%s]", v, pa_cvolume_snprint(s, sizeof(s), &cv), pa_sw_cvolume_snprint_dB(t, sizeof(t), &cv));
}
map.channels = cv.channels = 2;
map.map[0] = PA_CHANNEL_POSITION_LEFT;
map.map[1] = PA_CHANNEL_POSITION_RIGHT;
for (cv.values[0] = PA_VOLUME_MUTED; cv.values[0] <= PA_VOLUME_NORM*2; cv.values[0] += 4096)
for (cv.values[1] = PA_VOLUME_MUTED; cv.values[1] <= PA_VOLUME_NORM*2; cv.values[1] += 4096) {
char s[PA_CVOLUME_SNPRINT_MAX];
pa_log_debug("Volume: [%s]; balance: %2.1f", pa_cvolume_snprint(s, sizeof(s), &cv), pa_cvolume_get_balance(&cv, &map));
}
for (cv.values[0] = PA_VOLUME_MUTED+4096; cv.values[0] <= PA_VOLUME_NORM*2; cv.values[0] += 4096)
for (cv.values[1] = PA_VOLUME_MUTED; cv.values[1] <= PA_VOLUME_NORM*2; cv.values[1] += 4096)
for (b = -1.0f; b <= 1.0f; b += 0.2f) {
char s[PA_CVOLUME_SNPRINT_MAX];
pa_cvolume r;
float k;
pa_log_debug("Before: volume: [%s]; balance: %2.1f", pa_cvolume_snprint(s, sizeof(s), &cv), pa_cvolume_get_balance(&cv, &map));
r = cv;
pa_cvolume_set_balance(&r, &map,b);
k = pa_cvolume_get_balance(&r, &map);
pa_log_debug("After: volume: [%s]; balance: %2.1f (intended: %2.1f) %s", pa_cvolume_snprint(s, sizeof(s), &r), k, b, k < b-.05 || k > b+.5 ? "MISMATCH" : "");
}
for (v = PA_VOLUME_MUTED; v <= PA_VOLUME_NORM*2; v += 51) {
double l = pa_sw_volume_to_linear(v);
pa_volume_t k = pa_sw_volume_from_linear(l);
double db = pa_sw_volume_to_dB(v);
pa_volume_t r = pa_sw_volume_from_dB(db);
pa_volume_t w;
pa_assert(k == v);
pa_assert(r == v);
for (w = PA_VOLUME_MUTED; w < PA_VOLUME_NORM*2; w += 37) {
double t = pa_sw_volume_to_linear(w);
double db2 = pa_sw_volume_to_dB(w);
pa_volume_t p, p1, p2;
double q, qq;
p = pa_sw_volume_multiply(v, w);
qq = db + db2;
p2 = pa_sw_volume_from_dB(qq);
q = l*t;
p1 = pa_sw_volume_from_linear(q);
if (p2 > p && p2 - p > md)
md = p2 - p;
if (p2 < p && p - p2 > md)
md = p - p2;
if (p1 > p && p1 - p > md)
md = p1 - p;
if (p1 < p && p - p1 > md)
md = p - p1;
if (p1 != p || p2 != p)
mdn++;
}
}
pa_log("max deviation: %lu n=%lu", (unsigned long) md, (unsigned long) mdn);
pa_assert(md <= 1);
pa_assert(mdn <= 251);
return 0;
}
