mirror of
https://gitlab.freedesktop.org/pulseaudio/pulseaudio.git
synced 2025-11-03 09:01:50 -05:00
6b34896130
Currently the default sink policy is simple: either the user has configured it explicitly, in which case we always use that as the default, or we pick the sink with the highest priority. The sink priorities are currently static, so there's no need to worry about updating the default sink when sink priorities change. I intend to make things a bit more complex: if the active port of a sink is unavailable, the sink should not be the default sink, and I also want to make sink priorities dependent on the active port, so changing the port should cause re-evaluation of which sink to choose as the default. Currently the default sink choice is done only when someone calls pa_namereg_get_default_sink(), and change notifications are only sent when a sink is created or destroyed. That makes it hard to add new rules to the default sink selection policy. This patch moves the default sink selection to pa_core_update_default_sink(), which is called whenever something happens that can affect the default sink choice. That function needs to know the previous choice in order to send change notifications as appropriate, but previously pa_core.default_sink was only set when the user had configured it explicitly. Now pa_core.default_sink is always set (unless there are no sinks at all), so pa_core_update_default_sink() can use that to get the previous choice. The user configuration is saved in a new variable, pa_core.configured_default_sink. pa_namereg_get_default_sink() is now unnecessary, because pa_core.default_sink can be used directly to get the currently-considered-best sink. pa_namereg_set_default_sink() is replaced by pa_core_set_configured_default_sink(). I haven't confirmed it, but I expect that this patch will fix problems in the D-Bus protocol related to default sink handling. The D-Bus protocol used to get confused when the current default sink gets removed. It would incorrectly think that if there's no explicitly configured default sink, then there's no default sink at all. Even worse, when the D-Bus thinks that there's no default sink, it concludes that there are no sinks at all, which made it impossible to configure the default sink via the D-Bus interface. Now that pa_core.default_sink is always set, except when there really aren't any sinks, the D-Bus protocol should behave correctly. BugLink: https://bugs.freedesktop.org/show_bug.cgi?id=99425
755 lines
27 KiB
C
755 lines
27 KiB
C
/***
|
|
This file is part of PulseAudio.
|
|
|
|
Copyright 2004-2006 Lennart Poettering
|
|
|
|
PulseAudio is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published
|
|
by the Free Software Foundation; either version 2.1 of the License,
|
|
or (at your option) any later version.
|
|
|
|
PulseAudio is distributed in the hope that it will be useful, but
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with PulseAudio; if not, see <http://www.gnu.org/licenses/>.
|
|
***/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
|
|
#include <pulse/volume.h>
|
|
#include <pulse/xmalloc.h>
|
|
#include <pulse/timeval.h>
|
|
|
|
#include <pulsecore/module.h>
|
|
#include <pulsecore/client.h>
|
|
#include <pulsecore/sink.h>
|
|
#include <pulsecore/source.h>
|
|
#include <pulsecore/sink-input.h>
|
|
#include <pulsecore/source-output.h>
|
|
#include <pulsecore/strbuf.h>
|
|
#include <pulsecore/core-scache.h>
|
|
#include <pulsecore/macro.h>
|
|
#include <pulsecore/core-util.h>
|
|
#include <pulsecore/namereg.h>
|
|
|
|
#include "cli-text.h"
|
|
|
|
char *pa_module_list_to_string(pa_core *c) {
|
|
pa_strbuf *s;
|
|
pa_module *m;
|
|
uint32_t idx = PA_IDXSET_INVALID;
|
|
pa_assert(c);
|
|
|
|
s = pa_strbuf_new();
|
|
|
|
pa_strbuf_printf(s, "%u module(s) loaded.\n", pa_idxset_size(c->modules));
|
|
|
|
PA_IDXSET_FOREACH(m, c->modules, idx) {
|
|
char *t;
|
|
|
|
pa_strbuf_printf(s, " index: %u\n"
|
|
"\tname: <%s>\n"
|
|
"\targument: <%s>\n"
|
|
"\tused: %i\n"
|
|
"\tload once: %s\n",
|
|
m->index,
|
|
m->name,
|
|
pa_strempty(m->argument),
|
|
pa_module_get_n_used(m),
|
|
pa_yes_no(m->load_once));
|
|
|
|
t = pa_proplist_to_string_sep(m->proplist, "\n\t\t");
|
|
pa_strbuf_printf(s, "\tproperties:\n\t\t%s\n", t);
|
|
pa_xfree(t);
|
|
}
|
|
|
|
return pa_strbuf_to_string_free(s);
|
|
}
|
|
|
|
char *pa_client_list_to_string(pa_core *c) {
|
|
pa_strbuf *s;
|
|
pa_client *client;
|
|
uint32_t idx = PA_IDXSET_INVALID;
|
|
pa_assert(c);
|
|
|
|
s = pa_strbuf_new();
|
|
|
|
pa_strbuf_printf(s, "%u client(s) logged in.\n", pa_idxset_size(c->clients));
|
|
|
|
PA_IDXSET_FOREACH(client, c->clients, idx) {
|
|
char *t;
|
|
pa_strbuf_printf(
|
|
s,
|
|
" index: %u\n"
|
|
"\tdriver: <%s>\n",
|
|
client->index,
|
|
client->driver);
|
|
|
|
if (client->module)
|
|
pa_strbuf_printf(s, "\towner module: %u\n", client->module->index);
|
|
|
|
t = pa_proplist_to_string_sep(client->proplist, "\n\t\t");
|
|
pa_strbuf_printf(s, "\tproperties:\n\t\t%s\n", t);
|
|
pa_xfree(t);
|
|
}
|
|
|
|
return pa_strbuf_to_string_free(s);
|
|
}
|
|
|
|
static const char *available_to_string(pa_available_t a) {
|
|
switch (a) {
|
|
case PA_AVAILABLE_UNKNOWN:
|
|
return "unknown";
|
|
case PA_AVAILABLE_NO:
|
|
return "no";
|
|
case PA_AVAILABLE_YES:
|
|
return "yes";
|
|
default:
|
|
return "invalid"; /* Should never happen! */
|
|
}
|
|
}
|
|
|
|
static void append_port_list(pa_strbuf *s, pa_hashmap *ports) {
|
|
pa_device_port *p;
|
|
void *state;
|
|
|
|
pa_assert(ports);
|
|
|
|
if (pa_hashmap_isempty(ports))
|
|
return;
|
|
|
|
pa_strbuf_puts(s, "\tports:\n");
|
|
PA_HASHMAP_FOREACH(p, ports, state) {
|
|
char *t = pa_proplist_to_string_sep(p->proplist, "\n\t\t\t\t");
|
|
pa_strbuf_printf(s, "\t\t%s: %s (priority %u, latency offset %" PRId64 " usec, available: %s)\n",
|
|
p->name, p->description, p->priority, p->latency_offset,
|
|
available_to_string(p->available));
|
|
pa_strbuf_printf(s, "\t\t\tproperties:\n\t\t\t\t%s\n", t);
|
|
pa_xfree(t);
|
|
}
|
|
}
|
|
|
|
char *pa_card_list_to_string(pa_core *c) {
|
|
pa_strbuf *s;
|
|
pa_card *card;
|
|
uint32_t idx = PA_IDXSET_INVALID;
|
|
pa_assert(c);
|
|
|
|
s = pa_strbuf_new();
|
|
|
|
pa_strbuf_printf(s, "%u card(s) available.\n", pa_idxset_size(c->cards));
|
|
|
|
PA_IDXSET_FOREACH(card, c->cards, idx) {
|
|
char *t;
|
|
pa_sink *sink;
|
|
pa_source *source;
|
|
uint32_t sidx;
|
|
pa_card_profile *profile;
|
|
void *state;
|
|
|
|
pa_strbuf_printf(
|
|
s,
|
|
" index: %u\n"
|
|
"\tname: <%s>\n"
|
|
"\tdriver: <%s>\n",
|
|
card->index,
|
|
card->name,
|
|
card->driver);
|
|
|
|
if (card->module)
|
|
pa_strbuf_printf(s, "\towner module: %u\n", card->module->index);
|
|
|
|
t = pa_proplist_to_string_sep(card->proplist, "\n\t\t");
|
|
pa_strbuf_printf(s, "\tproperties:\n\t\t%s\n", t);
|
|
pa_xfree(t);
|
|
|
|
pa_strbuf_puts(s, "\tprofiles:\n");
|
|
PA_HASHMAP_FOREACH(profile, card->profiles, state)
|
|
pa_strbuf_printf(s, "\t\t%s: %s (priority %u, available: %s)\n", profile->name, profile->description,
|
|
profile->priority, available_to_string(profile->available));
|
|
|
|
pa_strbuf_printf(
|
|
s,
|
|
"\tactive profile: <%s>\n",
|
|
card->active_profile->name);
|
|
|
|
if (!pa_idxset_isempty(card->sinks)) {
|
|
pa_strbuf_puts(s, "\tsinks:\n");
|
|
PA_IDXSET_FOREACH(sink, card->sinks, sidx)
|
|
pa_strbuf_printf(s, "\t\t%s/#%u: %s\n", sink->name, sink->index, pa_strna(pa_proplist_gets(sink->proplist, PA_PROP_DEVICE_DESCRIPTION)));
|
|
}
|
|
|
|
if (!pa_idxset_isempty(card->sources)) {
|
|
pa_strbuf_puts(s, "\tsources:\n");
|
|
PA_IDXSET_FOREACH(source, card->sources, sidx)
|
|
pa_strbuf_printf(s, "\t\t%s/#%u: %s\n", source->name, source->index, pa_strna(pa_proplist_gets(source->proplist, PA_PROP_DEVICE_DESCRIPTION)));
|
|
}
|
|
|
|
append_port_list(s, card->ports);
|
|
}
|
|
|
|
return pa_strbuf_to_string_free(s);
|
|
}
|
|
|
|
static const char *sink_state_to_string(pa_sink_state_t state) {
|
|
switch (state) {
|
|
case PA_SINK_INIT:
|
|
return "INIT";
|
|
case PA_SINK_RUNNING:
|
|
return "RUNNING";
|
|
case PA_SINK_SUSPENDED:
|
|
return "SUSPENDED";
|
|
case PA_SINK_IDLE:
|
|
return "IDLE";
|
|
case PA_SINK_UNLINKED:
|
|
return "UNLINKED";
|
|
default:
|
|
return "INVALID";
|
|
}
|
|
}
|
|
|
|
static const char *source_state_to_string(pa_source_state_t state) {
|
|
switch (state) {
|
|
case PA_SOURCE_INIT:
|
|
return "INIT";
|
|
case PA_SOURCE_RUNNING:
|
|
return "RUNNING";
|
|
case PA_SOURCE_SUSPENDED:
|
|
return "SUSPENDED";
|
|
case PA_SOURCE_IDLE:
|
|
return "IDLE";
|
|
case PA_SOURCE_UNLINKED:
|
|
return "UNLINKED";
|
|
default:
|
|
return "INVALID";
|
|
}
|
|
}
|
|
|
|
char *pa_sink_list_to_string(pa_core *c) {
|
|
pa_strbuf *s;
|
|
pa_sink *sink;
|
|
uint32_t idx = PA_IDXSET_INVALID;
|
|
pa_assert(c);
|
|
|
|
s = pa_strbuf_new();
|
|
|
|
pa_strbuf_printf(s, "%u sink(s) available.\n", pa_idxset_size(c->sinks));
|
|
|
|
PA_IDXSET_FOREACH(sink, c->sinks, idx) {
|
|
char ss[PA_SAMPLE_SPEC_SNPRINT_MAX],
|
|
cv[PA_CVOLUME_SNPRINT_VERBOSE_MAX],
|
|
v[PA_VOLUME_SNPRINT_VERBOSE_MAX],
|
|
cm[PA_CHANNEL_MAP_SNPRINT_MAX], *t;
|
|
const char *cmn;
|
|
|
|
cmn = pa_channel_map_to_pretty_name(&sink->channel_map);
|
|
|
|
pa_strbuf_printf(
|
|
s,
|
|
" %c index: %u\n"
|
|
"\tname: <%s>\n"
|
|
"\tdriver: <%s>\n"
|
|
"\tflags: %s%s%s%s%s%s%s%s\n"
|
|
"\tstate: %s\n"
|
|
"\tsuspend cause: %s%s%s%s\n"
|
|
"\tpriority: %u\n"
|
|
"\tvolume: %s\n"
|
|
"\t balance %0.2f\n"
|
|
"\tbase volume: %s\n"
|
|
"\tvolume steps: %u\n"
|
|
"\tmuted: %s\n"
|
|
"\tcurrent latency: %0.2f ms\n"
|
|
"\tmax request: %lu KiB\n"
|
|
"\tmax rewind: %lu KiB\n"
|
|
"\tmonitor source: %u\n"
|
|
"\tsample spec: %s\n"
|
|
"\tchannel map: %s%s%s\n"
|
|
"\tused by: %u\n"
|
|
"\tlinked by: %u\n",
|
|
sink == c->default_sink ? '*' : ' ',
|
|
sink->index,
|
|
sink->name,
|
|
sink->driver,
|
|
sink->flags & PA_SINK_HARDWARE ? "HARDWARE " : "",
|
|
sink->flags & PA_SINK_NETWORK ? "NETWORK " : "",
|
|
sink->flags & PA_SINK_HW_MUTE_CTRL ? "HW_MUTE_CTRL " : "",
|
|
sink->flags & PA_SINK_HW_VOLUME_CTRL ? "HW_VOLUME_CTRL " : "",
|
|
sink->flags & PA_SINK_DECIBEL_VOLUME ? "DECIBEL_VOLUME " : "",
|
|
sink->flags & PA_SINK_LATENCY ? "LATENCY " : "",
|
|
sink->flags & PA_SINK_FLAT_VOLUME ? "FLAT_VOLUME " : "",
|
|
sink->flags & PA_SINK_DYNAMIC_LATENCY ? "DYNAMIC_LATENCY" : "",
|
|
sink_state_to_string(pa_sink_get_state(sink)),
|
|
sink->suspend_cause & PA_SUSPEND_USER ? "USER " : "",
|
|
sink->suspend_cause & PA_SUSPEND_APPLICATION ? "APPLICATION " : "",
|
|
sink->suspend_cause & PA_SUSPEND_IDLE ? "IDLE " : "",
|
|
sink->suspend_cause & PA_SUSPEND_SESSION ? "SESSION" : "",
|
|
sink->priority,
|
|
pa_cvolume_snprint_verbose(cv,
|
|
sizeof(cv),
|
|
pa_sink_get_volume(sink, false),
|
|
&sink->channel_map,
|
|
sink->flags & PA_SINK_DECIBEL_VOLUME),
|
|
pa_cvolume_get_balance(pa_sink_get_volume(sink, false), &sink->channel_map),
|
|
pa_volume_snprint_verbose(v, sizeof(v), sink->base_volume, sink->flags & PA_SINK_DECIBEL_VOLUME),
|
|
sink->n_volume_steps,
|
|
pa_yes_no(pa_sink_get_mute(sink, false)),
|
|
(double) pa_sink_get_latency(sink) / (double) PA_USEC_PER_MSEC,
|
|
(unsigned long) pa_sink_get_max_request(sink) / 1024,
|
|
(unsigned long) pa_sink_get_max_rewind(sink) / 1024,
|
|
sink->monitor_source ? sink->monitor_source->index : PA_INVALID_INDEX,
|
|
pa_sample_spec_snprint(ss, sizeof(ss), &sink->sample_spec),
|
|
pa_channel_map_snprint(cm, sizeof(cm), &sink->channel_map),
|
|
cmn ? "\n\t " : "",
|
|
cmn ? cmn : "",
|
|
pa_sink_used_by(sink),
|
|
pa_sink_linked_by(sink));
|
|
|
|
if (sink->flags & PA_SINK_DYNAMIC_LATENCY) {
|
|
pa_usec_t min_latency, max_latency;
|
|
pa_sink_get_latency_range(sink, &min_latency, &max_latency);
|
|
|
|
pa_strbuf_printf(
|
|
s,
|
|
"\tconfigured latency: %0.2f ms; range is %0.2f .. %0.2f ms\n",
|
|
(double) pa_sink_get_requested_latency(sink) / (double) 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_sink_get_fixed_latency(sink) / PA_USEC_PER_MSEC);
|
|
|
|
if (sink->card)
|
|
pa_strbuf_printf(s, "\tcard: %u <%s>\n", sink->card->index, sink->card->name);
|
|
if (sink->module)
|
|
pa_strbuf_printf(s, "\tmodule: %u\n", sink->module->index);
|
|
|
|
t = pa_proplist_to_string_sep(sink->proplist, "\n\t\t");
|
|
pa_strbuf_printf(s, "\tproperties:\n\t\t%s\n", t);
|
|
pa_xfree(t);
|
|
|
|
append_port_list(s, sink->ports);
|
|
|
|
if (sink->active_port)
|
|
pa_strbuf_printf(
|
|
s,
|
|
"\tactive port: <%s>\n",
|
|
sink->active_port->name);
|
|
}
|
|
|
|
return pa_strbuf_to_string_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));
|
|
|
|
PA_IDXSET_FOREACH(source, c->sources, idx) {
|
|
char ss[PA_SAMPLE_SPEC_SNPRINT_MAX],
|
|
cv[PA_CVOLUME_SNPRINT_VERBOSE_MAX],
|
|
v[PA_VOLUME_SNPRINT_VERBOSE_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\n"
|
|
"\t balance %0.2f\n"
|
|
"\tbase volume: %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",
|
|
source == c->default_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_verbose(cv,
|
|
sizeof(cv),
|
|
pa_source_get_volume(source, false),
|
|
&source->channel_map,
|
|
source->flags & PA_SOURCE_DECIBEL_VOLUME),
|
|
pa_cvolume_get_balance(pa_source_get_volume(source, false), &source->channel_map),
|
|
pa_volume_snprint_verbose(v, sizeof(v), source->base_volume, source->flags & PA_SOURCE_DECIBEL_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_to_string_free(s);
|
|
}
|
|
|
|
char *pa_source_output_list_to_string(pa_core *c) {
|
|
pa_strbuf *s;
|
|
pa_source_output *o;
|
|
uint32_t idx = PA_IDXSET_INVALID;
|
|
static const char* const state_table[] = {
|
|
[PA_SOURCE_OUTPUT_INIT] = "INIT",
|
|
[PA_SOURCE_OUTPUT_RUNNING] = "RUNNING",
|
|
[PA_SOURCE_OUTPUT_CORKED] = "CORKED",
|
|
[PA_SOURCE_OUTPUT_UNLINKED] = "UNLINKED"
|
|
};
|
|
pa_assert(c);
|
|
|
|
s = pa_strbuf_new();
|
|
|
|
pa_strbuf_printf(s, "%u source output(s) available.\n", pa_idxset_size(c->source_outputs));
|
|
|
|
PA_IDXSET_FOREACH(o, c->source_outputs, idx) {
|
|
char ss[PA_SAMPLE_SPEC_SNPRINT_MAX], cv[PA_CVOLUME_SNPRINT_VERBOSE_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(&o->channel_map);
|
|
|
|
if ((cl = pa_source_output_get_requested_latency(o)) == (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(o->source);
|
|
|
|
if (pa_source_output_is_volume_readable(o)) {
|
|
pa_source_output_get_volume(o, &v, true);
|
|
volume_str = pa_sprintf_malloc("%s\n\t balance %0.2f",
|
|
pa_cvolume_snprint_verbose(cv, sizeof(cv), &v, &o->channel_map, true),
|
|
pa_cvolume_get_balance(&v, &o->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%s\n"
|
|
"\tstate: %s\n"
|
|
"\tsource: %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",
|
|
o->index,
|
|
o->driver,
|
|
o->flags & PA_SOURCE_OUTPUT_VARIABLE_RATE ? "VARIABLE_RATE " : "",
|
|
o->flags & PA_SOURCE_OUTPUT_DONT_MOVE ? "DONT_MOVE " : "",
|
|
o->flags & PA_SOURCE_OUTPUT_START_CORKED ? "START_CORKED " : "",
|
|
o->flags & PA_SOURCE_OUTPUT_NO_REMAP ? "NO_REMAP " : "",
|
|
o->flags & PA_SOURCE_OUTPUT_NO_REMIX ? "NO_REMIX " : "",
|
|
o->flags & PA_SOURCE_OUTPUT_FIX_FORMAT ? "FIX_FORMAT " : "",
|
|
o->flags & PA_SOURCE_OUTPUT_FIX_RATE ? "FIX_RATE " : "",
|
|
o->flags & PA_SOURCE_OUTPUT_FIX_CHANNELS ? "FIX_CHANNELS " : "",
|
|
o->flags & PA_SOURCE_OUTPUT_DONT_INHIBIT_AUTO_SUSPEND ? "DONT_INHIBIT_AUTO_SUSPEND " : "",
|
|
o->flags & PA_SOURCE_OUTPUT_NO_CREATE_ON_SUSPEND ? "NO_CREATE_ON_SUSPEND " : "",
|
|
o->flags & PA_SOURCE_OUTPUT_KILL_ON_SUSPEND ? "KILL_ON_SUSPEND " : "",
|
|
o->flags & PA_SOURCE_OUTPUT_PASSTHROUGH ? "PASSTHROUGH " : "",
|
|
state_table[pa_source_output_get_state(o)],
|
|
o->source->index, o->source->name,
|
|
volume_str,
|
|
pa_yes_no(o->muted),
|
|
(double) pa_source_output_get_latency(o, NULL) / PA_USEC_PER_MSEC,
|
|
clt,
|
|
pa_sample_spec_snprint(ss, sizeof(ss), &o->sample_spec),
|
|
pa_channel_map_snprint(cm, sizeof(cm), &o->channel_map),
|
|
cmn ? "\n\t " : "",
|
|
cmn ? cmn : "",
|
|
pa_resample_method_to_string(pa_source_output_get_resample_method(o)));
|
|
|
|
pa_xfree(volume_str);
|
|
|
|
if (o->module)
|
|
pa_strbuf_printf(s, "\towner module: %u\n", o->module->index);
|
|
if (o->client)
|
|
pa_strbuf_printf(s, "\tclient: %u <%s>\n", o->client->index, pa_strnull(pa_proplist_gets(o->client->proplist, PA_PROP_APPLICATION_NAME)));
|
|
if (o->direct_on_input)
|
|
pa_strbuf_printf(s, "\tdirect on input: %u\n", o->direct_on_input->index);
|
|
|
|
t = pa_proplist_to_string_sep(o->proplist, "\n\t\t");
|
|
pa_strbuf_printf(s, "\tproperties:\n\t\t%s\n", t);
|
|
pa_xfree(t);
|
|
}
|
|
|
|
return pa_strbuf_to_string_free(s);
|
|
}
|
|
|
|
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));
|
|
|
|
PA_IDXSET_FOREACH(i, c->sink_inputs, idx) {
|
|
char ss[PA_SAMPLE_SPEC_SNPRINT_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 balance %0.2f",
|
|
pa_cvolume_snprint_verbose(cv, sizeof(cv), &v, &i->channel_map, true),
|
|
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%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 " : "",
|
|
i->flags & PA_SINK_INPUT_PASSTHROUGH ? "PASSTHROUGH " : "",
|
|
state_table[pa_sink_input_get_state(i)],
|
|
i->sink->index, i->sink->name,
|
|
volume_str,
|
|
pa_yes_no(i->muted),
|
|
(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_to_string_free(s);
|
|
}
|
|
|
|
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;
|
|
|
|
PA_IDXSET_FOREACH(e, c->scache, idx) {
|
|
double l = 0;
|
|
char ss[PA_SAMPLE_SPEC_SNPRINT_MAX] = "n/a", cv[PA_CVOLUME_SNPRINT_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 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_verbose(cv, sizeof(cv), &e->volume, &e->channel_map, true) : "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_to_string_free(s);
|
|
}
|
|
|
|
char *pa_full_status_string(pa_core *c) {
|
|
pa_strbuf *s;
|
|
int i;
|
|
|
|
s = pa_strbuf_new();
|
|
|
|
for (i = 0; i < 8; i++) {
|
|
char *t = NULL;
|
|
|
|
switch (i) {
|
|
case 0:
|
|
t = pa_sink_list_to_string(c);
|
|
break;
|
|
case 1:
|
|
t = pa_source_list_to_string(c);
|
|
break;
|
|
case 2:
|
|
t = pa_sink_input_list_to_string(c);
|
|
break;
|
|
case 3:
|
|
t = pa_source_output_list_to_string(c);
|
|
break;
|
|
case 4:
|
|
t = pa_client_list_to_string(c);
|
|
break;
|
|
case 5:
|
|
t = pa_card_list_to_string(c);
|
|
break;
|
|
case 6:
|
|
t = pa_module_list_to_string(c);
|
|
break;
|
|
case 7:
|
|
t = pa_scache_list_to_string(c);
|
|
break;
|
|
}
|
|
|
|
pa_strbuf_puts(s, t);
|
|
pa_xfree(t);
|
|
}
|
|
|
|
return pa_strbuf_to_string_free(s);
|
|
}
|