mirror of
https://gitlab.freedesktop.org/pulseaudio/pulseaudio.git
synced 2025-11-06 13:29:56 -05:00
merge glitch-free branch back into trunk
git-svn-id: file:///home/lennart/svn/public/pulseaudio/trunk@2445 fefdeb5f-60dc-0310-8127-8f9354f1896f
This commit is contained in:
Lennart Poettering
parent
91f092eadc
commit
045c1d602d
189 changed files with 12559 additions and 4959 deletions
|
|
@ -27,6 +27,7 @@
|
|||
#endif
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <limits.h>
|
||||
#include <asoundlib.h>
|
||||
|
||||
#include <pulse/sample.h>
|
||||
|
|
@ -35,6 +36,7 @@
|
|||
#include <pulsecore/log.h>
|
||||
#include <pulsecore/macro.h>
|
||||
#include <pulsecore/core-util.h>
|
||||
#include <pulsecore/atomic.h>
|
||||
|
||||
#include "alsa-util.h"
|
||||
|
||||
|
|
@ -290,16 +292,22 @@ int pa_alsa_set_hw_params(
|
|||
pa_sample_spec *ss,
|
||||
uint32_t *periods,
|
||||
snd_pcm_uframes_t *period_size,
|
||||
snd_pcm_uframes_t tsched_size,
|
||||
pa_bool_t *use_mmap,
|
||||
pa_bool_t *use_tsched,
|
||||
pa_bool_t require_exact_channel_number) {
|
||||
|
||||
int ret = -1;
|
||||
snd_pcm_uframes_t _period_size = *period_size;
|
||||
unsigned int _periods = *periods;
|
||||
snd_pcm_uframes_t buffer_size;
|
||||
unsigned int r = ss->rate;
|
||||
unsigned int c = ss->channels;
|
||||
pa_sample_format_t f = ss->format;
|
||||
snd_pcm_hw_params_t *hwparams;
|
||||
pa_bool_t _use_mmap = use_mmap && *use_mmap;
|
||||
pa_bool_t _use_tsched = use_tsched && *use_tsched;
|
||||
int dir;
|
||||
|
||||
pa_assert(pcm_handle);
|
||||
pa_assert(ss);
|
||||
|
|
@ -308,8 +316,6 @@ int pa_alsa_set_hw_params(
|
|||
|
||||
snd_pcm_hw_params_alloca(&hwparams);
|
||||
|
||||
buffer_size = *periods * *period_size;
|
||||
|
||||
if ((ret = snd_pcm_hw_params_any(pcm_handle, hwparams)) < 0)
|
||||
goto finish;
|
||||
|
||||
|
|
@ -330,12 +336,19 @@ int pa_alsa_set_hw_params(
|
|||
} else if ((ret = snd_pcm_hw_params_set_access(pcm_handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
|
||||
goto finish;
|
||||
|
||||
if (!_use_mmap)
|
||||
_use_tsched = FALSE;
|
||||
|
||||
if ((ret = set_format(pcm_handle, hwparams, &f)) < 0)
|
||||
goto finish;
|
||||
|
||||
if ((ret = snd_pcm_hw_params_set_rate_near(pcm_handle, hwparams, &r, NULL)) < 0)
|
||||
goto finish;
|
||||
|
||||
/* Adjust the buffer sizes, if we didn't get the rate we were asking for */
|
||||
_period_size = (snd_pcm_uframes_t) (((uint64_t) _period_size * r) / ss->rate);
|
||||
tsched_size = (snd_pcm_uframes_t) (((uint64_t) tsched_size * r) / ss->rate);
|
||||
|
||||
if (require_exact_channel_number) {
|
||||
if ((ret = snd_pcm_hw_params_set_channels(pcm_handle, hwparams, c)) < 0)
|
||||
goto finish;
|
||||
|
|
@ -344,10 +357,32 @@ int pa_alsa_set_hw_params(
|
|||
goto finish;
|
||||
}
|
||||
|
||||
if ((*period_size > 0 && (ret = snd_pcm_hw_params_set_period_size_near(pcm_handle, hwparams, period_size, NULL)) < 0) ||
|
||||
(*periods > 0 && (ret = snd_pcm_hw_params_set_buffer_size_near(pcm_handle, hwparams, &buffer_size)) < 0))
|
||||
if (_use_tsched) {
|
||||
_period_size = tsched_size;
|
||||
_periods = 1;
|
||||
|
||||
pa_assert_se(snd_pcm_hw_params_get_buffer_size_max(hwparams, &buffer_size) == 0);
|
||||
pa_log_debug("Maximum hw buffer size is %u ms", (unsigned) buffer_size * 1000 / r);
|
||||
}
|
||||
|
||||
buffer_size = _periods * _period_size;
|
||||
|
||||
if ((ret = snd_pcm_hw_params_set_periods_integer(pcm_handle, hwparams)) < 0)
|
||||
goto finish;
|
||||
|
||||
if (_periods > 0) {
|
||||
dir = 1;
|
||||
if ((ret = snd_pcm_hw_params_set_periods_near(pcm_handle, hwparams, &_periods, &dir)) < 0) {
|
||||
dir = -1;
|
||||
if ((ret = snd_pcm_hw_params_set_periods_near(pcm_handle, hwparams, &_periods, &dir)) < 0)
|
||||
goto finish;
|
||||
}
|
||||
}
|
||||
|
||||
if (_period_size > 0)
|
||||
if ((ret = snd_pcm_hw_params_set_buffer_size_near(pcm_handle, hwparams, &buffer_size)) < 0)
|
||||
goto finish;
|
||||
|
||||
if ((ret = snd_pcm_hw_params(pcm_handle, hwparams)) < 0)
|
||||
goto finish;
|
||||
|
||||
|
|
@ -363,8 +398,8 @@ int pa_alsa_set_hw_params(
|
|||
if ((ret = snd_pcm_prepare(pcm_handle)) < 0)
|
||||
goto finish;
|
||||
|
||||
if ((ret = snd_pcm_hw_params_get_buffer_size(hwparams, &buffer_size)) < 0 ||
|
||||
(ret = snd_pcm_hw_params_get_period_size(hwparams, period_size, NULL)) < 0)
|
||||
if ((ret = snd_pcm_hw_params_get_period_size(hwparams, &_period_size, &dir)) < 0 ||
|
||||
(ret = snd_pcm_hw_params_get_periods(hwparams, &_periods, &dir)) < 0)
|
||||
goto finish;
|
||||
|
||||
/* If the sample rate deviates too much, we need to resample */
|
||||
|
|
@ -373,14 +408,18 @@ int pa_alsa_set_hw_params(
|
|||
ss->channels = c;
|
||||
ss->format = f;
|
||||
|
||||
pa_assert(buffer_size > 0);
|
||||
pa_assert(*period_size > 0);
|
||||
*periods = buffer_size / *period_size;
|
||||
pa_assert(*periods > 0);
|
||||
pa_assert(_periods > 0);
|
||||
pa_assert(_period_size > 0);
|
||||
|
||||
*periods = _periods;
|
||||
*period_size = _period_size;
|
||||
|
||||
if (use_mmap)
|
||||
*use_mmap = _use_mmap;
|
||||
|
||||
if (use_tsched)
|
||||
*use_tsched = _use_tsched;
|
||||
|
||||
ret = 0;
|
||||
|
||||
finish:
|
||||
|
|
@ -388,7 +427,7 @@ finish:
|
|||
return ret;
|
||||
}
|
||||
|
||||
int pa_alsa_set_sw_params(snd_pcm_t *pcm) {
|
||||
int pa_alsa_set_sw_params(snd_pcm_t *pcm, snd_pcm_uframes_t avail_min) {
|
||||
snd_pcm_sw_params_t *swparams;
|
||||
int err;
|
||||
|
||||
|
|
@ -411,6 +450,11 @@ int pa_alsa_set_sw_params(snd_pcm_t *pcm) {
|
|||
return err;
|
||||
}
|
||||
|
||||
if ((err = snd_pcm_sw_params_set_avail_min(pcm, swparams, avail_min)) < 0) {
|
||||
pa_log_error("snd_pcm_sw_params_set_avail_min() failed: %s", snd_strerror(err));
|
||||
return err;
|
||||
}
|
||||
|
||||
if ((err = snd_pcm_sw_params(pcm, swparams)) < 0) {
|
||||
pa_log_warn("Unable to set sw params: %s\n", snd_strerror(err));
|
||||
return err;
|
||||
|
|
@ -477,7 +521,9 @@ snd_pcm_t *pa_alsa_open_by_device_id(
|
|||
int mode,
|
||||
uint32_t *nfrags,
|
||||
snd_pcm_uframes_t *period_size,
|
||||
pa_bool_t *use_mmap) {
|
||||
snd_pcm_uframes_t tsched_size,
|
||||
pa_bool_t *use_mmap,
|
||||
pa_bool_t *use_tsched) {
|
||||
|
||||
int i;
|
||||
int direction = 1;
|
||||
|
|
@ -526,7 +572,11 @@ snd_pcm_t *pa_alsa_open_by_device_id(
|
|||
d = pa_sprintf_malloc("%s:%s", device_table[i].name, dev_id);
|
||||
pa_log_debug("Trying %s...", d);
|
||||
|
||||
if ((err = snd_pcm_open(&pcm_handle, d, mode, SND_PCM_NONBLOCK)) < 0) {
|
||||
if ((err = snd_pcm_open(&pcm_handle, d, mode,
|
||||
SND_PCM_NONBLOCK|
|
||||
SND_PCM_NO_AUTO_RESAMPLE|
|
||||
SND_PCM_NO_AUTO_CHANNELS|
|
||||
SND_PCM_NO_AUTO_FORMAT)) < 0) {
|
||||
pa_log_info("Couldn't open PCM device %s: %s", d, snd_strerror(err));
|
||||
pa_xfree(d);
|
||||
continue;
|
||||
|
|
@ -536,7 +586,7 @@ snd_pcm_t *pa_alsa_open_by_device_id(
|
|||
try_ss.rate = ss->rate;
|
||||
try_ss.format = ss->format;
|
||||
|
||||
if ((err = pa_alsa_set_hw_params(pcm_handle, &try_ss, nfrags, period_size, use_mmap, TRUE)) < 0) {
|
||||
if ((err = pa_alsa_set_hw_params(pcm_handle, &try_ss, nfrags, period_size, tsched_size, use_mmap, use_tsched, TRUE)) < 0) {
|
||||
pa_log_info("PCM device %s refused our hw parameters: %s", d, snd_strerror(err));
|
||||
pa_xfree(d);
|
||||
snd_pcm_close(pcm_handle);
|
||||
|
|
@ -550,11 +600,11 @@ snd_pcm_t *pa_alsa_open_by_device_id(
|
|||
return pcm_handle;
|
||||
}
|
||||
|
||||
/* OK, we didn't find any good device, so let's try the raw hw: stuff */
|
||||
/* OK, we didn't find any good device, so let's try the raw plughw: stuff */
|
||||
|
||||
d = pa_sprintf_malloc("hw:%s", dev_id);
|
||||
d = pa_sprintf_malloc("plughw:%s", dev_id);
|
||||
pa_log_debug("Trying %s as last resort...", d);
|
||||
pcm_handle = pa_alsa_open_by_device_string(d, dev, ss, map, mode, nfrags, period_size, use_mmap);
|
||||
pcm_handle = pa_alsa_open_by_device_string(d, dev, ss, map, mode, nfrags, period_size, tsched_size, use_mmap, use_tsched);
|
||||
pa_xfree(d);
|
||||
|
||||
return pcm_handle;
|
||||
|
|
@ -568,7 +618,9 @@ snd_pcm_t *pa_alsa_open_by_device_string(
|
|||
int mode,
|
||||
uint32_t *nfrags,
|
||||
snd_pcm_uframes_t *period_size,
|
||||
pa_bool_t *use_mmap) {
|
||||
snd_pcm_uframes_t tsched_size,
|
||||
pa_bool_t *use_mmap,
|
||||
pa_bool_t *use_tsched) {
|
||||
|
||||
int err;
|
||||
char *d;
|
||||
|
|
@ -585,13 +637,16 @@ snd_pcm_t *pa_alsa_open_by_device_string(
|
|||
|
||||
for (;;) {
|
||||
|
||||
if ((err = snd_pcm_open(&pcm_handle, d, mode, SND_PCM_NONBLOCK)) < 0) {
|
||||
if ((err = snd_pcm_open(&pcm_handle, d, mode, SND_PCM_NONBLOCK|
|
||||
SND_PCM_NO_AUTO_RESAMPLE|
|
||||
SND_PCM_NO_AUTO_CHANNELS|
|
||||
SND_PCM_NO_AUTO_FORMAT)) < 0) {
|
||||
pa_log("Error opening PCM device %s: %s", d, snd_strerror(err));
|
||||
pa_xfree(d);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if ((err = pa_alsa_set_hw_params(pcm_handle, ss, nfrags, period_size, use_mmap, FALSE)) < 0) {
|
||||
if ((err = pa_alsa_set_hw_params(pcm_handle, ss, nfrags, period_size, tsched_size, use_mmap, use_tsched, FALSE)) < 0) {
|
||||
|
||||
if (err == -EPERM) {
|
||||
/* Hmm, some hw is very exotic, so we retry with plug, if without it didn't work */
|
||||
|
|
@ -616,8 +671,24 @@ snd_pcm_t *pa_alsa_open_by_device_string(
|
|||
*dev = d;
|
||||
|
||||
if (ss->channels != map->channels) {
|
||||
pa_assert_se(pa_channel_map_init_auto(map, ss->channels, PA_CHANNEL_MAP_AUX));
|
||||
pa_channel_map_init_auto(map, ss->channels, PA_CHANNEL_MAP_ALSA);
|
||||
if (!pa_channel_map_init_auto(map, ss->channels, PA_CHANNEL_MAP_ALSA)) {
|
||||
unsigned c;
|
||||
pa_channel_position_t pos;
|
||||
|
||||
pa_log_warn("Device has an unknown channel mapping. This is a limitation of ALSA. Synthesizing channel map.");
|
||||
|
||||
for (c = ss->channels; c > 0; c--)
|
||||
if (pa_channel_map_init_auto(map, c, PA_CHANNEL_MAP_ALSA))
|
||||
break;
|
||||
|
||||
pa_assert(c > 0);
|
||||
|
||||
pos = PA_CHANNEL_POSITION_AUX0;
|
||||
for (; c < map->channels; c ++)
|
||||
map->map[c] = pos++;
|
||||
|
||||
map->channels = ss->channels;
|
||||
}
|
||||
}
|
||||
|
||||
return pcm_handle;
|
||||
|
|
@ -773,7 +844,7 @@ int pa_alsa_calc_mixer_map(snd_mixer_elem_t *elem, const pa_channel_map *channel
|
|||
}
|
||||
|
||||
if ((is_mono && mono_used) || (!is_mono && alsa_channel_used[id])) {
|
||||
pa_log_info("Channel map has duplicate channel '%s', failling back to software volume control.", pa_channel_position_to_string(channel_map->map[i]));
|
||||
pa_log_info("Channel map has duplicate channel '%s', falling back to software volume control.", pa_channel_position_to_string(channel_map->map[i]));
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
|
@ -793,7 +864,275 @@ int pa_alsa_calc_mixer_map(snd_mixer_elem_t *elem, const pa_channel_map *channel
|
|||
}
|
||||
}
|
||||
|
||||
pa_log_info("All %u channels can be mapped to mixer channels. Using hardware volume control.", channel_map->channels);
|
||||
pa_log_info("All %u channels can be mapped to mixer channels.", channel_map->channels);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void pa_alsa_0dB_playback(snd_mixer_elem_t *elem) {
|
||||
long min, max, v;
|
||||
|
||||
pa_assert(elem);
|
||||
|
||||
/* Try to enable 0 dB if possible. If ALSA cannot do dB, then use
|
||||
* raw volume levels and fix them to 75% */
|
||||
|
||||
if (snd_mixer_selem_set_playback_dB_all(elem, 0, -1) >= 0)
|
||||
return;
|
||||
|
||||
if (snd_mixer_selem_set_playback_dB_all(elem, 0, 1) >= 0)
|
||||
return;
|
||||
|
||||
if (snd_mixer_selem_get_playback_volume_range(elem, &min, &max) < 0)
|
||||
return;
|
||||
|
||||
v = min + ((max - min) * 3) / 4; /* 75% */
|
||||
|
||||
if (v <= min)
|
||||
v = max;
|
||||
|
||||
snd_mixer_selem_set_playback_volume_all(elem, v);
|
||||
}
|
||||
|
||||
void pa_alsa_0dB_capture(snd_mixer_elem_t *elem) {
|
||||
long min, max, v;
|
||||
|
||||
pa_assert(elem);
|
||||
|
||||
/* Try to enable 0 dB if possible. If ALSA cannot do dB, then use
|
||||
* raw volume levels and fix them to 75% */
|
||||
|
||||
if (snd_mixer_selem_set_capture_dB_all(elem, 0, -1) >= 0)
|
||||
return;
|
||||
|
||||
if (snd_mixer_selem_set_capture_dB_all(elem, 0, 1) >= 0)
|
||||
return;
|
||||
|
||||
if (snd_mixer_selem_get_capture_volume_range(elem, &min, &max) < 0)
|
||||
return;
|
||||
|
||||
v = min + ((max - min) * 3) / 4; /* 75% */
|
||||
|
||||
if (v <= min)
|
||||
v = max;
|
||||
|
||||
snd_mixer_selem_set_capture_volume_all(elem, v);
|
||||
}
|
||||
|
||||
void pa_alsa_dump(snd_pcm_t *pcm) {
|
||||
int err;
|
||||
snd_output_t *out;
|
||||
|
||||
pa_assert(pcm);
|
||||
|
||||
pa_assert_se(snd_output_buffer_open(&out) == 0);
|
||||
|
||||
if ((err = snd_pcm_dump(pcm, out)) < 0)
|
||||
pa_log_debug("snd_pcm_dump(): %s", snd_strerror(err));
|
||||
else {
|
||||
char *s = NULL;
|
||||
snd_output_buffer_string(out, &s);
|
||||
pa_log_debug("snd_pcm_dump():\n%s", pa_strnull(s));
|
||||
}
|
||||
|
||||
pa_assert_se(snd_output_close(out) == 0);
|
||||
}
|
||||
|
||||
void pa_alsa_dump_status(snd_pcm_t *pcm) {
|
||||
int err;
|
||||
snd_output_t *out;
|
||||
snd_pcm_status_t *status;
|
||||
|
||||
pa_assert(pcm);
|
||||
|
||||
snd_pcm_status_alloca(&status);
|
||||
|
||||
pa_assert_se(snd_output_buffer_open(&out) == 0);
|
||||
|
||||
pa_assert_se(snd_pcm_status(pcm, status) == 0);
|
||||
|
||||
if ((err = snd_pcm_status_dump(status, out)) < 0)
|
||||
pa_log_debug("snd_pcm_dump(): %s", snd_strerror(err));
|
||||
else {
|
||||
char *s = NULL;
|
||||
snd_output_buffer_string(out, &s);
|
||||
pa_log_debug("snd_pcm_dump():\n%s", pa_strnull(s));
|
||||
}
|
||||
|
||||
pa_assert_se(snd_output_close(out) == 0);
|
||||
}
|
||||
|
||||
static void alsa_error_handler(const char *file, int line, const char *function, int err, const char *fmt,...) {
|
||||
va_list ap;
|
||||
|
||||
va_start(ap, fmt);
|
||||
|
||||
pa_log_levelv_meta(PA_LOG_WARN, file, line, function, fmt, ap);
|
||||
|
||||
va_end(ap);
|
||||
}
|
||||
|
||||
static pa_atomic_t n_error_handler_installed = PA_ATOMIC_INIT(0);
|
||||
|
||||
void pa_alsa_redirect_errors_inc(void) {
|
||||
/* This is not really thread safe, but we do our best */
|
||||
|
||||
if (pa_atomic_inc(&n_error_handler_installed) == 0)
|
||||
snd_lib_error_set_handler(alsa_error_handler);
|
||||
}
|
||||
|
||||
void pa_alsa_redirect_errors_dec(void) {
|
||||
int r;
|
||||
|
||||
pa_assert_se((r = pa_atomic_dec(&n_error_handler_installed)) >= 1);
|
||||
|
||||
if (r == 1)
|
||||
snd_lib_error_set_handler(NULL);
|
||||
}
|
||||
|
||||
void pa_alsa_init_proplist(pa_proplist *p, snd_pcm_info_t *pcm_info) {
|
||||
|
||||
static const char * const alsa_class_table[SND_PCM_CLASS_LAST+1] = {
|
||||
[SND_PCM_CLASS_GENERIC] = "generic",
|
||||
[SND_PCM_CLASS_MULTI] = "multi",
|
||||
[SND_PCM_CLASS_MODEM] = "modem",
|
||||
[SND_PCM_CLASS_DIGITIZER] = "digitizer"
|
||||
};
|
||||
static const char * const class_table[SND_PCM_CLASS_LAST+1] = {
|
||||
[SND_PCM_CLASS_GENERIC] = "sound",
|
||||
[SND_PCM_CLASS_MULTI] = NULL,
|
||||
[SND_PCM_CLASS_MODEM] = "modem",
|
||||
[SND_PCM_CLASS_DIGITIZER] = NULL
|
||||
};
|
||||
static const char * const alsa_subclass_table[SND_PCM_SUBCLASS_LAST+1] = {
|
||||
[SND_PCM_SUBCLASS_GENERIC_MIX] = "generic-mix",
|
||||
[SND_PCM_SUBCLASS_MULTI_MIX] = "multi-mix"
|
||||
};
|
||||
|
||||
snd_pcm_class_t class;
|
||||
snd_pcm_subclass_t subclass;
|
||||
const char *n, *id, *sdn;
|
||||
char *cn = NULL, *lcn = NULL;
|
||||
int card;
|
||||
|
||||
pa_assert(p);
|
||||
pa_assert(pcm_info);
|
||||
|
||||
pa_proplist_sets(p, PA_PROP_DEVICE_API, "alsa");
|
||||
|
||||
class = snd_pcm_info_get_class(pcm_info);
|
||||
if (class <= SND_PCM_CLASS_LAST) {
|
||||
if (class_table[class])
|
||||
pa_proplist_sets(p, PA_PROP_DEVICE_CLASS, class_table[class]);
|
||||
if (alsa_class_table[class])
|
||||
pa_proplist_sets(p, "alsa.class", alsa_class_table[class]);
|
||||
}
|
||||
subclass = snd_pcm_info_get_subclass(pcm_info);
|
||||
if (subclass <= SND_PCM_SUBCLASS_LAST)
|
||||
if (alsa_subclass_table[subclass])
|
||||
pa_proplist_sets(p, "alsa.subclass", alsa_subclass_table[subclass]);
|
||||
|
||||
if ((n = snd_pcm_info_get_name(pcm_info)))
|
||||
pa_proplist_sets(p, "alsa.name", n);
|
||||
|
||||
if ((id = snd_pcm_info_get_id(pcm_info)))
|
||||
pa_proplist_sets(p, "alsa.id", id);
|
||||
|
||||
pa_proplist_setf(p, "alsa.subdevice", "%u", snd_pcm_info_get_subdevice(pcm_info));
|
||||
if ((sdn = snd_pcm_info_get_subdevice_name(pcm_info)))
|
||||
pa_proplist_sets(p, "alsa.subdevice_name", sdn);
|
||||
|
||||
pa_proplist_setf(p, "alsa.device", "%u", snd_pcm_info_get_device(pcm_info));
|
||||
|
||||
if ((card = snd_pcm_info_get_card(pcm_info)) >= 0) {
|
||||
pa_proplist_setf(p, "alsa.card", "%i", card);
|
||||
|
||||
if (snd_card_get_name(card, &cn) >= 0)
|
||||
pa_proplist_sets(p, "alsa.card_name", cn);
|
||||
|
||||
if (snd_card_get_longname(card, &lcn) >= 0)
|
||||
pa_proplist_sets(p, "alsa.long_card_name", lcn);
|
||||
}
|
||||
|
||||
if (cn && n)
|
||||
pa_proplist_setf(p, PA_PROP_DEVICE_DESCRIPTION, "%s - %s", cn, n);
|
||||
else if (cn)
|
||||
pa_proplist_sets(p, PA_PROP_DEVICE_DESCRIPTION, cn);
|
||||
else if (n)
|
||||
pa_proplist_sets(p, PA_PROP_DEVICE_DESCRIPTION, n);
|
||||
|
||||
free(lcn);
|
||||
free(cn);
|
||||
}
|
||||
|
||||
int pa_alsa_recover_from_poll(snd_pcm_t *pcm, int revents) {
|
||||
snd_pcm_state_t state;
|
||||
int err;
|
||||
|
||||
pa_assert(pcm);
|
||||
|
||||
if (revents & POLLERR)
|
||||
pa_log_warn("Got POLLERR from ALSA");
|
||||
if (revents & POLLNVAL)
|
||||
pa_log_warn("Got POLLNVAL from ALSA");
|
||||
if (revents & POLLHUP)
|
||||
pa_log_warn("Got POLLHUP from ALSA");
|
||||
|
||||
state = snd_pcm_state(pcm);
|
||||
pa_log_warn("PCM state is %s", snd_pcm_state_name(state));
|
||||
|
||||
/* Try to recover from this error */
|
||||
|
||||
switch (state) {
|
||||
|
||||
case SND_PCM_STATE_XRUN:
|
||||
if ((err = snd_pcm_recover(pcm, -EPIPE, 1)) != 0) {
|
||||
pa_log_warn("Could not recover from POLLERR|POLLNVAL|POLLHUP and XRUN: %s", snd_strerror(err));
|
||||
return -1;
|
||||
}
|
||||
break;
|
||||
|
||||
case SND_PCM_STATE_SUSPENDED:
|
||||
if ((err = snd_pcm_recover(pcm, -ESTRPIPE, 1)) != 0) {
|
||||
pa_log_warn("Could not recover from POLLERR|POLLNVAL|POLLHUP and SUSPENDED: %s", snd_strerror(err));
|
||||
return -1;
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
|
||||
snd_pcm_drop(pcm);
|
||||
|
||||
if ((err = snd_pcm_prepare(pcm)) < 0) {
|
||||
pa_log_warn("Could not recover from POLLERR|POLLNVAL|POLLHUP with snd_pcm_prepare(): %s", snd_strerror(err));
|
||||
return -1;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
pa_rtpoll_item* pa_alsa_build_pollfd(snd_pcm_t *pcm, pa_rtpoll *rtpoll) {
|
||||
int n, err;
|
||||
struct pollfd *pollfd;
|
||||
pa_rtpoll_item *item;
|
||||
|
||||
pa_assert(pcm);
|
||||
|
||||
if ((n = snd_pcm_poll_descriptors_count(pcm)) < 0) {
|
||||
pa_log("snd_pcm_poll_descriptors_count() failed: %s", snd_strerror(n));
|
||||
return NULL;
|
||||
}
|
||||
|
||||
item = pa_rtpoll_item_new(rtpoll, PA_RTPOLL_NEVER, n);
|
||||
pollfd = pa_rtpoll_item_get_pollfd(item, NULL);
|
||||
|
||||
if ((err = snd_pcm_poll_descriptors(pcm, pollfd, n)) < 0) {
|
||||
pa_log("snd_pcm_poll_descriptors() failed: %s", snd_strerror(err));
|
||||
pa_rtpoll_item_free(item);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return item;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -29,8 +29,10 @@
|
|||
|
||||
#include <pulse/sample.h>
|
||||
#include <pulse/mainloop-api.h>
|
||||
|
||||
#include <pulse/channelmap.h>
|
||||
#include <pulse/proplist.h>
|
||||
|
||||
#include <pulsecore/rtpoll.h>
|
||||
|
||||
typedef struct pa_alsa_fdlist pa_alsa_fdlist;
|
||||
|
||||
|
|
@ -43,10 +45,12 @@ int pa_alsa_set_hw_params(
|
|||
pa_sample_spec *ss,
|
||||
uint32_t *periods,
|
||||
snd_pcm_uframes_t *period_size,
|
||||
snd_pcm_uframes_t tsched_size,
|
||||
pa_bool_t *use_mmap,
|
||||
pa_bool_t *use_tsched,
|
||||
pa_bool_t require_exact_channel_number);
|
||||
|
||||
int pa_alsa_set_sw_params(snd_pcm_t *pcm);
|
||||
int pa_alsa_set_sw_params(snd_pcm_t *pcm, snd_pcm_uframes_t avail_min);
|
||||
|
||||
int pa_alsa_prepare_mixer(snd_mixer_t *mixer, const char *dev);
|
||||
snd_mixer_elem_t *pa_alsa_find_elem(snd_mixer_t *mixer, const char *name, const char *fallback);
|
||||
|
|
@ -59,7 +63,9 @@ snd_pcm_t *pa_alsa_open_by_device_id(
|
|||
int mode,
|
||||
uint32_t *nfrags,
|
||||
snd_pcm_uframes_t *period_size,
|
||||
pa_bool_t *use_mmap);
|
||||
snd_pcm_uframes_t tsched_size,
|
||||
pa_bool_t *use_mmap,
|
||||
pa_bool_t *use_tsched);
|
||||
|
||||
snd_pcm_t *pa_alsa_open_by_device_string(
|
||||
const char *device,
|
||||
|
|
@ -69,8 +75,25 @@ snd_pcm_t *pa_alsa_open_by_device_string(
|
|||
int mode,
|
||||
uint32_t *nfrags,
|
||||
snd_pcm_uframes_t *period_size,
|
||||
pa_bool_t *use_mmap);
|
||||
snd_pcm_uframes_t tsched_size,
|
||||
pa_bool_t *use_mmap,
|
||||
pa_bool_t *use_tsched);
|
||||
|
||||
int pa_alsa_calc_mixer_map(snd_mixer_elem_t *elem, const pa_channel_map *channel_map, snd_mixer_selem_channel_id_t mixer_map[], pa_bool_t playback);
|
||||
|
||||
void pa_alsa_0dB_playback(snd_mixer_elem_t *elem);
|
||||
void pa_alsa_0dB_capture(snd_mixer_elem_t *elem);
|
||||
|
||||
void pa_alsa_dump(snd_pcm_t *pcm);
|
||||
void pa_alsa_dump_status(snd_pcm_t *pcm);
|
||||
|
||||
void pa_alsa_redirect_errors_inc(void);
|
||||
void pa_alsa_redirect_errors_dec(void);
|
||||
|
||||
void pa_alsa_init_proplist(pa_proplist *p, snd_pcm_info_t *pcm_info);
|
||||
|
||||
int pa_alsa_recover_from_poll(snd_pcm_t *pcm, int revents);
|
||||
|
||||
pa_rtpoll_item* pa_alsa_build_pollfd(snd_pcm_t *pcm, pa_rtpoll *rtpoll);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
File diff suppressed because it is too large
Load diff
|
|
@ -66,7 +66,7 @@ PA_MODULE_USAGE(
|
|||
"channel_map=<channel map>");
|
||||
|
||||
#define DEFAULT_SINK_NAME "combined"
|
||||
#define MEMBLOCKQ_MAXLENGTH (1024*170)
|
||||
#define MEMBLOCKQ_MAXLENGTH (1024*1024*16)
|
||||
|
||||
#define DEFAULT_ADJUST_TIME 10
|
||||
|
||||
|
|
@ -139,7 +139,7 @@ enum {
|
|||
};
|
||||
|
||||
enum {
|
||||
SINK_INPUT_MESSAGE_POST = PA_SINK_INPUT_MESSAGE_MAX
|
||||
SINK_INPUT_MESSAGE_POST = PA_SINK_INPUT_MESSAGE_MAX,
|
||||
};
|
||||
|
||||
static void output_free(struct output *o);
|
||||
|
|
@ -162,13 +162,13 @@ static void adjust_rates(struct userdata *u) {
|
|||
if (!u->master)
|
||||
return;
|
||||
|
||||
if (!PA_SINK_OPENED(pa_sink_get_state(u->sink)))
|
||||
if (!PA_SINK_IS_OPENED(pa_sink_get_state(u->sink)))
|
||||
return;
|
||||
|
||||
for (o = pa_idxset_first(u->outputs, &idx); o; o = pa_idxset_next(u->outputs, &idx)) {
|
||||
pa_usec_t sink_latency;
|
||||
|
||||
if (!o->sink_input || !PA_SINK_OPENED(pa_sink_get_state(o->sink)))
|
||||
if (!o->sink_input || !PA_SINK_IS_OPENED(pa_sink_get_state(o->sink)))
|
||||
continue;
|
||||
|
||||
sink_latency = pa_sink_get_latency(o->sink);
|
||||
|
|
@ -194,7 +194,7 @@ static void adjust_rates(struct userdata *u) {
|
|||
for (o = pa_idxset_first(u->outputs, &idx); o; o = pa_idxset_next(u->outputs, &idx)) {
|
||||
uint32_t r = base_rate;
|
||||
|
||||
if (!o->sink_input || !PA_SINK_OPENED(pa_sink_get_state(o->sink)))
|
||||
if (!o->sink_input || !PA_SINK_IS_OPENED(pa_sink_get_state(o->sink)))
|
||||
continue;
|
||||
|
||||
if (o->total_latency < target_latency)
|
||||
|
|
@ -203,10 +203,10 @@ static void adjust_rates(struct userdata *u) {
|
|||
r += (uint32_t) (((((double) o->total_latency - target_latency))/u->adjust_time)*r/PA_USEC_PER_SEC);
|
||||
|
||||
if (r < (uint32_t) (base_rate*0.9) || r > (uint32_t) (base_rate*1.1)) {
|
||||
pa_log_warn("[%s] sample rates too different, not adjusting (%u vs. %u).", o->sink_input->name, base_rate, r);
|
||||
pa_log_warn("[%s] sample rates too different, not adjusting (%u vs. %u).", pa_proplist_gets(o->sink_input->proplist, PA_PROP_MEDIA_NAME), base_rate, r);
|
||||
pa_sink_input_set_rate(o->sink_input, base_rate);
|
||||
} else {
|
||||
pa_log_info("[%s] new rate is %u Hz; ratio is %0.3f; latency is %0.0f usec.", o->sink_input->name, r, (double) r / base_rate, (float) o->total_latency);
|
||||
pa_log_info("[%s] new rate is %u Hz; ratio is %0.3f; latency is %0.0f usec.", pa_proplist_gets(o->sink_input->proplist, PA_PROP_MEDIA_NAME), r, (double) r / base_rate, (float) o->total_latency);
|
||||
pa_sink_input_set_rate(o->sink_input, r);
|
||||
}
|
||||
}
|
||||
|
|
@ -250,10 +250,18 @@ static void thread_func(void *userdata) {
|
|||
if (u->sink->thread_info.state == PA_SINK_RUNNING && !u->thread_info.active_outputs) {
|
||||
struct timeval now;
|
||||
|
||||
/* Just rewind if necessary, since we are in NULL mode, we
|
||||
* don't have to pass this on */
|
||||
pa_sink_process_rewind(u->sink, u->sink->thread_info.rewind_nbytes);
|
||||
u->sink->thread_info.rewind_nbytes = 0;
|
||||
|
||||
pa_rtclock_get(&now);
|
||||
|
||||
if (!u->thread_info.in_null_mode || pa_timeval_cmp(&u->thread_info.timestamp, &now) <= 0) {
|
||||
pa_sink_skip(u->sink, u->block_size);
|
||||
pa_memchunk chunk;
|
||||
|
||||
pa_sink_render_full(u->sink, u->block_size, &chunk);
|
||||
pa_memblock_unref(chunk.memblock);
|
||||
|
||||
if (!u->thread_info.in_null_mode)
|
||||
u->thread_info.timestamp = now;
|
||||
|
|
@ -354,27 +362,20 @@ static void request_memblock(struct output *o, size_t length) {
|
|||
}
|
||||
|
||||
/* Called from I/O thread context */
|
||||
static int sink_input_peek_cb(pa_sink_input *i, size_t length, pa_memchunk *chunk) {
|
||||
static int sink_input_pop_cb(pa_sink_input *i, size_t nbytes, pa_memchunk *chunk) {
|
||||
struct output *o;
|
||||
|
||||
pa_sink_input_assert_ref(i);
|
||||
pa_assert_se(o = i->userdata);
|
||||
|
||||
/* If necessary, get some new data */
|
||||
request_memblock(o, length);
|
||||
request_memblock(o, nbytes);
|
||||
|
||||
return pa_memblockq_peek(o->memblockq, chunk);
|
||||
}
|
||||
if (pa_memblockq_peek(o->memblockq, chunk) < 0)
|
||||
return -1;
|
||||
|
||||
/* Called from I/O thread context */
|
||||
static void sink_input_drop_cb(pa_sink_input *i, size_t length) {
|
||||
struct output *o;
|
||||
|
||||
pa_sink_input_assert_ref(i);
|
||||
pa_assert(length > 0);
|
||||
pa_assert_se(o = i->userdata);
|
||||
|
||||
pa_memblockq_drop(o->memblockq, length);
|
||||
pa_memblockq_drop(o->memblockq, chunk->length);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Called from I/O thread context */
|
||||
|
|
@ -386,7 +387,7 @@ static void sink_input_attach_cb(pa_sink_input *i) {
|
|||
|
||||
/* Set up the queue from the sink thread to us */
|
||||
pa_assert(!o->inq_rtpoll_item);
|
||||
o->inq_rtpoll_item = pa_rtpoll_item_new_asyncmsgq(
|
||||
o->inq_rtpoll_item = pa_rtpoll_item_new_asyncmsgq_read(
|
||||
i->sink->rtpoll,
|
||||
PA_RTPOLL_LATE, /* This one is not that important, since we check for data in _peek() anyway. */
|
||||
o->inq);
|
||||
|
|
@ -434,12 +435,13 @@ static int sink_input_process_msg(pa_msgobject *obj, int code, void *data, int64
|
|||
|
||||
case SINK_INPUT_MESSAGE_POST:
|
||||
|
||||
if (PA_SINK_OPENED(o->sink_input->sink->thread_info.state))
|
||||
if (PA_SINK_IS_OPENED(o->sink_input->sink->thread_info.state))
|
||||
pa_memblockq_push_align(o->memblockq, chunk);
|
||||
else
|
||||
pa_memblockq_flush(o->memblockq);
|
||||
|
||||
break;
|
||||
|
||||
}
|
||||
|
||||
return pa_sink_input_process_msg(obj, code, data, offset, chunk);
|
||||
|
|
@ -472,7 +474,7 @@ static void enable_output(struct output *o) {
|
|||
|
||||
pa_sink_input_put(o->sink_input);
|
||||
|
||||
if (o->userdata->sink && PA_SINK_LINKED(pa_sink_get_state(o->userdata->sink)))
|
||||
if (o->userdata->sink && PA_SINK_IS_LINKED(pa_sink_get_state(o->userdata->sink)))
|
||||
pa_asyncmsgq_send(o->userdata->sink->asyncmsgq, PA_MSGOBJECT(o->userdata->sink), SINK_MESSAGE_ADD_OUTPUT, o, 0, NULL);
|
||||
}
|
||||
}
|
||||
|
|
@ -505,7 +507,7 @@ static void unsuspend(struct userdata *u) {
|
|||
|
||||
pa_sink_suspend(o->sink, FALSE);
|
||||
|
||||
if (PA_SINK_OPENED(pa_sink_get_state(o->sink)))
|
||||
if (PA_SINK_IS_OPENED(pa_sink_get_state(o->sink)))
|
||||
enable_output(o);
|
||||
}
|
||||
|
||||
|
|
@ -526,7 +528,7 @@ static int sink_set_state(pa_sink *sink, pa_sink_state_t state) {
|
|||
|
||||
switch (state) {
|
||||
case PA_SINK_SUSPENDED:
|
||||
pa_assert(PA_SINK_OPENED(pa_sink_get_state(u->sink)));
|
||||
pa_assert(PA_SINK_IS_OPENED(pa_sink_get_state(u->sink)));
|
||||
|
||||
suspend(u);
|
||||
break;
|
||||
|
|
@ -585,7 +587,7 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
|
|||
|
||||
/* Create pa_asyncmsgq to the sink thread */
|
||||
|
||||
op->outq_rtpoll_item = pa_rtpoll_item_new_asyncmsgq(
|
||||
op->outq_rtpoll_item = pa_rtpoll_item_new_asyncmsgq_read(
|
||||
u->rtpoll,
|
||||
PA_RTPOLL_EARLY-1, /* This item is very important */
|
||||
op->outq);
|
||||
|
|
@ -616,35 +618,35 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
|
|||
}
|
||||
|
||||
/* Called from main context */
|
||||
static pa_usec_t sink_get_latency_cb(pa_sink *s) {
|
||||
struct userdata *u;
|
||||
/* static pa_usec_t sink_get_latency_cb(pa_sink *s) { */
|
||||
/* struct userdata *u; */
|
||||
|
||||
pa_sink_assert_ref(s);
|
||||
pa_assert_se(u = s->userdata);
|
||||
/* pa_sink_assert_ref(s); */
|
||||
/* pa_assert_se(u = s->userdata); */
|
||||
|
||||
if (u->master) {
|
||||
/* If we have a master sink, we just return the latency of it
|
||||
* and add our own buffering on top */
|
||||
/* if (u->master) { */
|
||||
/* /\* If we have a master sink, we just return the latency of it */
|
||||
/* * and add our own buffering on top *\/ */
|
||||
|
||||
if (!u->master->sink_input)
|
||||
return 0;
|
||||
/* if (!u->master->sink_input) */
|
||||
/* return 0; */
|
||||
|
||||
return
|
||||
pa_sink_input_get_latency(u->master->sink_input) +
|
||||
pa_sink_get_latency(u->master->sink);
|
||||
/* return */
|
||||
/* pa_sink_input_get_latency(u->master->sink_input) + */
|
||||
/* pa_sink_get_latency(u->master->sink); */
|
||||
|
||||
} else {
|
||||
pa_usec_t usec = 0;
|
||||
/* } else { */
|
||||
/* pa_usec_t usec = 0; */
|
||||
|
||||
/* We have no master, hence let's ask our own thread which
|
||||
* implements the NULL sink */
|
||||
/* /\* We have no master, hence let's ask our own thread which */
|
||||
/* * implements the NULL sink *\/ */
|
||||
|
||||
if (pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_LATENCY, &usec, 0, NULL) < 0)
|
||||
return 0;
|
||||
/* if (pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_LATENCY, &usec, 0, NULL) < 0) */
|
||||
/* return 0; */
|
||||
|
||||
return usec;
|
||||
}
|
||||
}
|
||||
/* return usec; */
|
||||
/* } */
|
||||
/* } */
|
||||
|
||||
static void update_description(struct userdata *u) {
|
||||
int first = 1;
|
||||
|
|
@ -665,10 +667,10 @@ static void update_description(struct userdata *u) {
|
|||
char *e;
|
||||
|
||||
if (first) {
|
||||
e = pa_sprintf_malloc("%s %s", t, o->sink->description);
|
||||
e = pa_sprintf_malloc("%s %s", t, pa_strnull(pa_proplist_gets(o->sink->proplist, PA_PROP_DEVICE_DESCRIPTION)));
|
||||
first = 0;
|
||||
} else
|
||||
e = pa_sprintf_malloc("%s, %s", t, o->sink->description);
|
||||
e = pa_sprintf_malloc("%s, %s", t, pa_strnull(pa_proplist_gets(o->sink->proplist, PA_PROP_DEVICE_DESCRIPTION)));
|
||||
|
||||
pa_xfree(t);
|
||||
t = e;
|
||||
|
|
@ -698,7 +700,7 @@ static void pick_master(struct userdata *u, struct output *except) {
|
|||
if (u->master &&
|
||||
u->master != except &&
|
||||
u->master->sink_input &&
|
||||
PA_SINK_OPENED(pa_sink_get_state(u->master->sink))) {
|
||||
PA_SINK_IS_OPENED(pa_sink_get_state(u->master->sink))) {
|
||||
update_master(u, u->master);
|
||||
return;
|
||||
}
|
||||
|
|
@ -706,7 +708,7 @@ static void pick_master(struct userdata *u, struct output *except) {
|
|||
for (o = pa_idxset_first(u->outputs, &idx); o; o = pa_idxset_next(u->outputs, &idx))
|
||||
if (o != except &&
|
||||
o->sink_input &&
|
||||
PA_SINK_OPENED(pa_sink_get_state(o->sink))) {
|
||||
PA_SINK_IS_OPENED(pa_sink_get_state(o->sink))) {
|
||||
update_master(u, o);
|
||||
return;
|
||||
}
|
||||
|
|
@ -723,12 +725,12 @@ static int output_create_sink_input(struct output *o) {
|
|||
if (o->sink_input)
|
||||
return 0;
|
||||
|
||||
t = pa_sprintf_malloc("Simultaneous output on %s", o->sink->description);
|
||||
t = pa_sprintf_malloc("Simultaneous output on %s", pa_strnull(pa_proplist_gets(o->sink->proplist, PA_PROP_DEVICE_DESCRIPTION)));
|
||||
|
||||
pa_sink_input_new_data_init(&data);
|
||||
data.sink = o->sink;
|
||||
data.driver = __FILE__;
|
||||
data.name = t;
|
||||
pa_proplist_sets(data.proplist, PA_PROP_DEVICE_DESCRIPTION, t);
|
||||
pa_sink_input_new_data_set_sample_spec(&data, &o->userdata->sink->sample_spec);
|
||||
pa_sink_input_new_data_set_channel_map(&data, &o->userdata->sink->channel_map);
|
||||
data.module = o->userdata->module;
|
||||
|
|
@ -736,14 +738,15 @@ static int output_create_sink_input(struct output *o) {
|
|||
|
||||
o->sink_input = pa_sink_input_new(o->userdata->core, &data, PA_SINK_INPUT_VARIABLE_RATE|PA_SINK_INPUT_DONT_MOVE);
|
||||
|
||||
pa_sink_input_new_data_done(&data);
|
||||
|
||||
pa_xfree(t);
|
||||
|
||||
if (!o->sink_input)
|
||||
return -1;
|
||||
|
||||
o->sink_input->parent.process_msg = sink_input_process_msg;
|
||||
o->sink_input->peek = sink_input_peek_cb;
|
||||
o->sink_input->drop = sink_input_drop_cb;
|
||||
o->sink_input->pop = sink_input_pop_cb;
|
||||
o->sink_input->attach = sink_input_attach_cb;
|
||||
o->sink_input->detach = sink_input_detach_cb;
|
||||
o->sink_input->kill = sink_input_kill_cb;
|
||||
|
|
@ -775,26 +778,27 @@ static struct output *output_new(struct userdata *u, pa_sink *sink) {
|
|||
pa_frame_size(&u->sink->sample_spec),
|
||||
1,
|
||||
0,
|
||||
0,
|
||||
NULL);
|
||||
|
||||
pa_assert_se(pa_idxset_put(u->outputs, o, NULL) == 0);
|
||||
|
||||
if (u->sink && PA_SINK_LINKED(pa_sink_get_state(u->sink)))
|
||||
if (u->sink && PA_SINK_IS_LINKED(pa_sink_get_state(u->sink)))
|
||||
pa_asyncmsgq_send(u->sink->asyncmsgq, PA_MSGOBJECT(u->sink), SINK_MESSAGE_ADD_OUTPUT, o, 0, NULL);
|
||||
else {
|
||||
/* If the sink is not yet started, we need to do the activation ourselves */
|
||||
PA_LLIST_PREPEND(struct output, u->thread_info.active_outputs, o);
|
||||
|
||||
o->outq_rtpoll_item = pa_rtpoll_item_new_asyncmsgq(
|
||||
o->outq_rtpoll_item = pa_rtpoll_item_new_asyncmsgq_read(
|
||||
u->rtpoll,
|
||||
PA_RTPOLL_EARLY-1, /* This item is very important */
|
||||
o->outq);
|
||||
}
|
||||
|
||||
if (PA_SINK_OPENED(pa_sink_get_state(u->sink)) || pa_sink_get_state(u->sink) == PA_SINK_INIT) {
|
||||
if (PA_SINK_IS_OPENED(pa_sink_get_state(u->sink)) || pa_sink_get_state(u->sink) == PA_SINK_INIT) {
|
||||
pa_sink_suspend(sink, FALSE);
|
||||
|
||||
if (PA_SINK_OPENED(pa_sink_get_state(sink)))
|
||||
if (PA_SINK_IS_OPENED(pa_sink_get_state(sink)))
|
||||
if (output_create_sink_input(o) < 0)
|
||||
goto fail;
|
||||
}
|
||||
|
|
@ -897,7 +901,7 @@ static pa_hook_result_t sink_state_changed_hook_cb(pa_core *c, pa_sink *s, struc
|
|||
|
||||
state = pa_sink_get_state(s);
|
||||
|
||||
if (PA_SINK_OPENED(state) && PA_SINK_OPENED(pa_sink_get_state(u->sink)) && !o->sink_input) {
|
||||
if (PA_SINK_IS_OPENED(state) && PA_SINK_IS_OPENED(pa_sink_get_state(u->sink)) && !o->sink_input) {
|
||||
enable_output(o);
|
||||
pick_master(u, NULL);
|
||||
}
|
||||
|
|
@ -920,6 +924,7 @@ int pa__init(pa_module*m) {
|
|||
pa_channel_map map;
|
||||
struct output *o;
|
||||
uint32_t idx;
|
||||
pa_sink_new_data data;
|
||||
|
||||
pa_assert(m);
|
||||
|
||||
|
|
@ -943,8 +948,8 @@ int pa__init(pa_module*m) {
|
|||
u->master = NULL;
|
||||
u->time_event = NULL;
|
||||
u->adjust_time = DEFAULT_ADJUST_TIME;
|
||||
pa_thread_mq_init(&u->thread_mq, m->core->mainloop);
|
||||
u->rtpoll = pa_rtpoll_new();
|
||||
pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
|
||||
u->thread = NULL;
|
||||
u->resample_method = resample_method;
|
||||
u->outputs = pa_idxset_new(NULL, NULL);
|
||||
|
|
@ -953,7 +958,6 @@ int pa__init(pa_module*m) {
|
|||
PA_LLIST_HEAD_INIT(struct output, u->thread_info.active_outputs);
|
||||
pa_atomic_store(&u->thread_info.running, FALSE);
|
||||
u->thread_info.in_null_mode = FALSE;
|
||||
pa_rtpoll_item_new_asyncmsgq(u->rtpoll, PA_RTPOLL_EARLY, u->thread_mq.inq);
|
||||
|
||||
if (pa_modargs_get_value_u32(ma, "adjust_time", &u->adjust_time) < 0) {
|
||||
pa_log("Failed to parse adjust_time value");
|
||||
|
|
@ -1003,19 +1007,28 @@ int pa__init(pa_module*m) {
|
|||
goto fail;
|
||||
}
|
||||
|
||||
if (!(u->sink = pa_sink_new(m->core, __FILE__, pa_modargs_get_value(ma, "sink_name", DEFAULT_SINK_NAME), 0, &ss, &map))) {
|
||||
pa_sink_new_data_init(&data);
|
||||
data.name = pa_xstrdup(pa_modargs_get_value(ma, "sink_name", DEFAULT_SINK_NAME));
|
||||
data.namereg_fail = FALSE;
|
||||
data.driver = __FILE__;
|
||||
data.module = m;
|
||||
pa_sink_new_data_set_sample_spec(&data, &ss);
|
||||
pa_sink_new_data_set_channel_map(&data, &map);
|
||||
pa_proplist_sets(data.proplist, PA_PROP_DEVICE_DESCRIPTION, "Simultaneous Output");
|
||||
|
||||
u->sink = pa_sink_new(m->core, &data, PA_SINK_LATENCY);
|
||||
pa_sink_new_data_done(&data);
|
||||
|
||||
if (!u->sink) {
|
||||
pa_log("Failed to create sink");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
u->sink->parent.process_msg = sink_process_msg;
|
||||
u->sink->get_latency = sink_get_latency_cb;
|
||||
/* u->sink->get_latency = sink_get_latency_cb; */
|
||||
u->sink->set_state = sink_set_state;
|
||||
u->sink->userdata = u;
|
||||
|
||||
u->sink->flags = PA_SINK_LATENCY;
|
||||
pa_sink_set_module(u->sink, m);
|
||||
pa_sink_set_description(u->sink, "Simultaneous output");
|
||||
pa_sink_set_rtpoll(u->sink, u->rtpoll);
|
||||
pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
|
||||
|
||||
|
|
@ -1075,7 +1088,7 @@ int pa__init(pa_module*m) {
|
|||
}
|
||||
}
|
||||
|
||||
u->sink_new_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_NEW_POST], (pa_hook_cb_t) sink_new_hook_cb, u);
|
||||
u->sink_new_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_PUT], (pa_hook_cb_t) sink_new_hook_cb, u);
|
||||
}
|
||||
|
||||
u->sink_unlink_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_UNLINK], (pa_hook_cb_t) sink_unlink_hook_cb, u);
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@
|
|||
/***
|
||||
This file is part of PulseAudio.
|
||||
|
||||
Copyright 2006 Lennart Poettering
|
||||
Copyright 2006-2008 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
|
||||
|
|
@ -25,10 +25,16 @@
|
|||
#include <config.h>
|
||||
#endif
|
||||
|
||||
#include <errno.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#include <pulse/timeval.h>
|
||||
|
||||
#include <pulsecore/core-util.h>
|
||||
#include <pulsecore/module.h>
|
||||
#include <pulsecore/log.h>
|
||||
#include <pulsecore/namereg.h>
|
||||
#include <pulsecore/core-error.h>
|
||||
|
||||
#include "module-default-device-restore-symdef.h"
|
||||
|
||||
|
|
@ -39,15 +45,24 @@ PA_MODULE_LOAD_ONCE(TRUE);
|
|||
|
||||
#define DEFAULT_SINK_FILE "default-sink"
|
||||
#define DEFAULT_SOURCE_FILE "default-source"
|
||||
#define DEFAULT_SAVE_INTERVAL 5
|
||||
|
||||
int pa__init(pa_module *m) {
|
||||
struct userdata {
|
||||
pa_core *core;
|
||||
pa_subscription *subscription;
|
||||
pa_time_event *time_event;
|
||||
char *sink_filename, *source_filename;
|
||||
pa_bool_t modified;
|
||||
};
|
||||
|
||||
static void load(struct userdata *u) {
|
||||
FILE *f;
|
||||
|
||||
/* We never overwrite manually configured settings */
|
||||
|
||||
if (m->core->default_sink_name)
|
||||
if (u->core->default_sink_name)
|
||||
pa_log_info("Manually configured default sink, not overwriting.");
|
||||
else if ((f = pa_open_config_file(NULL, DEFAULT_SINK_FILE, NULL, NULL, "r"))) {
|
||||
else if ((f = fopen(u->sink_filename, "r"))) {
|
||||
char ln[256] = "";
|
||||
|
||||
fgets(ln, sizeof(ln)-1, f);
|
||||
|
|
@ -55,17 +70,19 @@ int pa__init(pa_module *m) {
|
|||
fclose(f);
|
||||
|
||||
if (!ln[0])
|
||||
pa_log_debug("No previous default sink setting, ignoring.");
|
||||
else if (pa_namereg_get(m->core, ln, PA_NAMEREG_SINK, 1)) {
|
||||
pa_namereg_set_default(m->core, ln, PA_NAMEREG_SINK);
|
||||
pa_log_debug("Restored default sink '%s'.", ln);
|
||||
pa_log_info("No previous default sink setting, ignoring.");
|
||||
else if (pa_namereg_get(u->core, ln, PA_NAMEREG_SINK, TRUE)) {
|
||||
pa_namereg_set_default(u->core, ln, PA_NAMEREG_SINK);
|
||||
pa_log_info("Restored default sink '%s'.", ln);
|
||||
} else
|
||||
pa_log_info("Saved default sink '%s' not existant, not restoring default sink setting.", ln);
|
||||
}
|
||||
|
||||
if (m->core->default_source_name)
|
||||
} else if (errno != ENOENT)
|
||||
pa_log("Failed to load default sink: %s", pa_cstrerror(errno));
|
||||
|
||||
if (u->core->default_source_name)
|
||||
pa_log_info("Manually configured default source, not overwriting.");
|
||||
else if ((f = pa_open_config_file(NULL, DEFAULT_SOURCE_FILE, NULL, NULL, "r"))) {
|
||||
else if ((f = fopen(u->source_filename, "r"))) {
|
||||
char ln[256] = "";
|
||||
|
||||
fgets(ln, sizeof(ln)-1, f);
|
||||
|
|
@ -73,29 +90,114 @@ int pa__init(pa_module *m) {
|
|||
fclose(f);
|
||||
|
||||
if (!ln[0])
|
||||
pa_log_debug("No previous default source setting, ignoring.");
|
||||
else if (pa_namereg_get(m->core, ln, PA_NAMEREG_SOURCE, 1)) {
|
||||
pa_namereg_set_default(m->core, ln, PA_NAMEREG_SOURCE);
|
||||
pa_log_debug("Restored default source '%s'.", ln);
|
||||
pa_log_info("No previous default source setting, ignoring.");
|
||||
else if (pa_namereg_get(u->core, ln, PA_NAMEREG_SOURCE, TRUE)) {
|
||||
pa_namereg_set_default(u->core, ln, PA_NAMEREG_SOURCE);
|
||||
pa_log_info("Restored default source '%s'.", ln);
|
||||
} else
|
||||
pa_log_info("Saved default source '%s' not existant, not restoring default source setting.", ln);
|
||||
|
||||
} else if (errno != ENOENT)
|
||||
pa_log("Failed to load default sink: %s", pa_cstrerror(errno));
|
||||
}
|
||||
|
||||
static void save(struct userdata *u) {
|
||||
FILE *f;
|
||||
|
||||
if (!u->modified)
|
||||
return;
|
||||
|
||||
if (u->sink_filename) {
|
||||
if ((f = fopen(u->sink_filename, "w"))) {
|
||||
const char *n = pa_namereg_get_default_sink_name(u->core);
|
||||
fprintf(f, "%s\n", pa_strempty(n));
|
||||
fclose(f);
|
||||
} else
|
||||
pa_log("Failed to save default sink: %s", pa_cstrerror(errno));
|
||||
}
|
||||
|
||||
if (u->source_filename) {
|
||||
if ((f = fopen(u->source_filename, "w"))) {
|
||||
const char *n = pa_namereg_get_default_source_name(u->core);
|
||||
fprintf(f, "%s\n", pa_strempty(n));
|
||||
fclose(f);
|
||||
} else
|
||||
pa_log("Failed to save default source: %s", pa_cstrerror(errno));
|
||||
}
|
||||
|
||||
u->modified = FALSE;
|
||||
}
|
||||
|
||||
static void time_cb(pa_mainloop_api *a, pa_time_event *e, const struct timeval *tv, void *userdata) {
|
||||
struct userdata *u = userdata;
|
||||
|
||||
pa_assert(u);
|
||||
save(u);
|
||||
|
||||
if (u->time_event) {
|
||||
u->core->mainloop->time_free(u->time_event);
|
||||
u->time_event = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
static void subscribe_cb(pa_core *c, pa_subscription_event_type_t t, uint32_t idx, void *userdata) {
|
||||
struct userdata *u = userdata;
|
||||
|
||||
pa_assert(u);
|
||||
|
||||
u->modified = TRUE;
|
||||
|
||||
if (!u->time_event) {
|
||||
struct timeval tv;
|
||||
pa_gettimeofday(&tv);
|
||||
pa_timeval_add(&tv, DEFAULT_SAVE_INTERVAL*PA_USEC_PER_SEC);
|
||||
u->time_event = u->core->mainloop->time_new(u->core->mainloop, &tv, time_cb, u);
|
||||
}
|
||||
}
|
||||
|
||||
int pa__init(pa_module *m) {
|
||||
struct userdata *u;
|
||||
|
||||
pa_assert(u);
|
||||
|
||||
u = pa_xnew0(struct userdata, 1);
|
||||
u->core = m->core;
|
||||
|
||||
if (!(u->sink_filename = pa_runtime_path(DEFAULT_SINK_FILE)))
|
||||
goto fail;
|
||||
|
||||
if (!(u->source_filename = pa_runtime_path(DEFAULT_SOURCE_FILE)))
|
||||
goto fail;
|
||||
|
||||
load(u);
|
||||
|
||||
u->subscription = pa_subscription_new(u->core, PA_SUBSCRIPTION_MASK_SERVER, subscribe_cb, u);
|
||||
|
||||
return 0;
|
||||
|
||||
fail:
|
||||
pa__done(m);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
void pa__done(pa_module*m) {
|
||||
FILE *f;
|
||||
struct userdata *u;
|
||||
|
||||
if ((f = pa_open_config_file(NULL, DEFAULT_SINK_FILE, NULL, NULL, "w"))) {
|
||||
const char *n = pa_namereg_get_default_sink_name(m->core);
|
||||
fprintf(f, "%s\n", n ? n : "");
|
||||
fclose(f);
|
||||
}
|
||||
pa_assert(m);
|
||||
|
||||
if ((f = pa_open_config_file(NULL, DEFAULT_SOURCE_FILE, NULL, NULL, "w"))) {
|
||||
const char *n = pa_namereg_get_default_source_name(m->core);
|
||||
fprintf(f, "%s\n", n ? n : "");
|
||||
fclose(f);
|
||||
}
|
||||
if (!(u = m->userdata))
|
||||
return;
|
||||
|
||||
save(u);
|
||||
|
||||
if (u->subscription)
|
||||
pa_subscription_free(u->subscription);
|
||||
|
||||
if (u->time_event)
|
||||
m->core->mainloop->time_free(u->time_event);
|
||||
|
||||
pa_xfree(u->sink_filename);
|
||||
pa_xfree(u->source_filename);
|
||||
pa_xfree(u);
|
||||
}
|
||||
|
|
|
|||
349
src/modules/module-device-restore.c
Normal file
349
src/modules/module-device-restore.c
Normal file
|
|
@ -0,0 +1,349 @@
|
|||
/* $Id$ */
|
||||
|
||||
/***
|
||||
This file is part of PulseAudio.
|
||||
|
||||
Copyright 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 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, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
|
||||
USA.
|
||||
***/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <config.h>
|
||||
#endif
|
||||
|
||||
#include <unistd.h>
|
||||
#include <string.h>
|
||||
#include <errno.h>
|
||||
#include <sys/types.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <ctype.h>
|
||||
#include <gdbm.h>
|
||||
|
||||
#include <pulse/xmalloc.h>
|
||||
#include <pulse/volume.h>
|
||||
#include <pulse/timeval.h>
|
||||
#include <pulse/util.h>
|
||||
|
||||
#include <pulsecore/core-error.h>
|
||||
#include <pulsecore/module.h>
|
||||
#include <pulsecore/core-util.h>
|
||||
#include <pulsecore/modargs.h>
|
||||
#include <pulsecore/log.h>
|
||||
#include <pulsecore/core-subscribe.h>
|
||||
#include <pulsecore/sink-input.h>
|
||||
#include <pulsecore/source-output.h>
|
||||
#include <pulsecore/namereg.h>
|
||||
|
||||
#include "module-device-restore-symdef.h"
|
||||
|
||||
PA_MODULE_AUTHOR("Lennart Poettering");
|
||||
PA_MODULE_DESCRIPTION("Automatically restore the volume/mute state of devices");
|
||||
PA_MODULE_VERSION(PACKAGE_VERSION);
|
||||
PA_MODULE_LOAD_ONCE(TRUE);
|
||||
|
||||
#define SAVE_INTERVAL 10
|
||||
|
||||
static const char* const valid_modargs[] = {
|
||||
NULL,
|
||||
};
|
||||
|
||||
struct userdata {
|
||||
pa_core *core;
|
||||
pa_subscription *subscription;
|
||||
pa_hook_slot *sink_fixate_hook_slot, *source_fixate_hook_slot;
|
||||
pa_time_event *save_time_event;
|
||||
GDBM_FILE gdbm_file;
|
||||
};
|
||||
|
||||
struct entry {
|
||||
pa_cvolume volume;
|
||||
int muted;
|
||||
};
|
||||
|
||||
static void save_time_callback(pa_mainloop_api*a, pa_time_event* e, const struct timeval *tv, void *userdata) {
|
||||
struct userdata *u = userdata;
|
||||
|
||||
pa_assert(a);
|
||||
pa_assert(e);
|
||||
pa_assert(tv);
|
||||
pa_assert(u);
|
||||
|
||||
pa_assert(e == u->save_time_event);
|
||||
u->core->mainloop->time_free(u->save_time_event);
|
||||
u->save_time_event = NULL;
|
||||
|
||||
gdbm_sync(u->gdbm_file);
|
||||
pa_log_info("Synced.");
|
||||
}
|
||||
|
||||
static void subscribe_callback(pa_core *c, pa_subscription_event_type_t t, uint32_t idx, void *userdata) {
|
||||
struct userdata *u = userdata;
|
||||
struct entry entry;
|
||||
char *name;
|
||||
datum key, data;
|
||||
|
||||
pa_assert(c);
|
||||
pa_assert(u);
|
||||
|
||||
if (t != (PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_NEW) &&
|
||||
t != (PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE) &&
|
||||
t != (PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_NEW) &&
|
||||
t != (PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE))
|
||||
return;
|
||||
|
||||
if ((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_SINK) {
|
||||
pa_sink *sink;
|
||||
|
||||
if (!(sink = pa_idxset_get_by_index(c->sinks, idx)))
|
||||
return;
|
||||
|
||||
name = pa_sprintf_malloc("sink:%s", sink->name);
|
||||
entry.volume = *pa_sink_get_volume(sink);
|
||||
entry.muted = pa_sink_get_mute(sink);
|
||||
|
||||
} else {
|
||||
pa_source *source;
|
||||
|
||||
pa_assert((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_SOURCE);
|
||||
|
||||
if (!(source = pa_idxset_get_by_index(c->sources, idx)))
|
||||
return;
|
||||
|
||||
name = pa_sprintf_malloc("source:%s", source->name);
|
||||
entry.volume = *pa_source_get_volume(source);
|
||||
entry.muted = pa_source_get_mute(source);
|
||||
}
|
||||
|
||||
key.dptr = name;
|
||||
key.dsize = strlen(name);
|
||||
|
||||
data = gdbm_fetch(u->gdbm_file, key);
|
||||
|
||||
if (data.dptr) {
|
||||
|
||||
if (data.dsize == sizeof(struct entry)) {
|
||||
struct entry *old = (struct entry*) data.dptr;
|
||||
|
||||
if (pa_cvolume_valid(&old->volume)) {
|
||||
|
||||
if (pa_cvolume_equal(&old->volume, &entry.volume) &&
|
||||
!old->muted == !entry.muted) {
|
||||
|
||||
pa_xfree(data.dptr);
|
||||
pa_xfree(name);
|
||||
return;
|
||||
}
|
||||
} else
|
||||
pa_log_warn("Invalid volume stored in database for device %s", name);
|
||||
|
||||
} else
|
||||
pa_log_warn("Database contains entry for device %s of wrong size %lu != %lu", name, (unsigned long) data.dsize, (unsigned long) sizeof(struct entry));
|
||||
|
||||
pa_xfree(data.dptr);
|
||||
}
|
||||
|
||||
data.dptr = (void*) &entry;
|
||||
data.dsize = sizeof(entry);
|
||||
|
||||
pa_log_info("Storing volume/mute for device %s.", name);
|
||||
|
||||
gdbm_store(u->gdbm_file, key, data, GDBM_REPLACE);
|
||||
|
||||
if (!u->save_time_event) {
|
||||
struct timeval tv;
|
||||
pa_gettimeofday(&tv);
|
||||
tv.tv_sec += SAVE_INTERVAL;
|
||||
u->save_time_event = u->core->mainloop->time_new(u->core->mainloop, &tv, save_time_callback, u);
|
||||
}
|
||||
|
||||
pa_xfree(name);
|
||||
}
|
||||
|
||||
static struct entry* read_entry(struct userdata *u, char *name) {
|
||||
datum key, data;
|
||||
struct entry *e;
|
||||
|
||||
pa_assert(u);
|
||||
pa_assert(name);
|
||||
|
||||
key.dptr = name;
|
||||
key.dsize = strlen(name);
|
||||
|
||||
data = gdbm_fetch(u->gdbm_file, key);
|
||||
|
||||
if (!data.dptr)
|
||||
goto fail;
|
||||
|
||||
if (data.dsize != sizeof(struct entry)) {
|
||||
pa_log_warn("Database contains entry for device %s of wrong size %lu != %lu", name, (unsigned long) data.dsize, (unsigned long) sizeof(struct entry));
|
||||
goto fail;
|
||||
}
|
||||
|
||||
e = (struct entry*) data.dptr;
|
||||
|
||||
if (!(pa_cvolume_valid(&e->volume))) {
|
||||
pa_log_warn("Invalid volume stored in database for device %s", name);
|
||||
goto fail;
|
||||
}
|
||||
|
||||
return e;
|
||||
|
||||
fail:
|
||||
|
||||
pa_xfree(data.dptr);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
static pa_hook_result_t sink_fixate_hook_callback(pa_core *c, pa_sink_new_data *new_data, struct userdata *u) {
|
||||
char *name;
|
||||
struct entry *e;
|
||||
|
||||
pa_assert(new_data);
|
||||
|
||||
name = pa_sprintf_malloc("sink:%s", new_data->name);
|
||||
|
||||
if ((e = read_entry(u, name))) {
|
||||
|
||||
if (e->volume.channels == new_data->sample_spec.channels) {
|
||||
pa_log_info("Restoring volume for sink %s.", new_data->name);
|
||||
pa_sink_new_data_set_volume(new_data, &e->volume);
|
||||
}
|
||||
|
||||
pa_log_info("Restoring mute state for sink %s.", new_data->name);
|
||||
pa_sink_new_data_set_muted(new_data, e->muted);
|
||||
pa_xfree(e);
|
||||
}
|
||||
|
||||
pa_xfree(name);
|
||||
|
||||
return PA_HOOK_OK;
|
||||
}
|
||||
|
||||
static pa_hook_result_t source_fixate_hook_callback(pa_core *c, pa_source_new_data *new_data, struct userdata *u) {
|
||||
char *name;
|
||||
struct entry *e;
|
||||
|
||||
pa_assert(new_data);
|
||||
|
||||
name = pa_sprintf_malloc("source:%s", new_data->name);
|
||||
|
||||
if ((e = read_entry(u, name))) {
|
||||
|
||||
if (e->volume.channels == new_data->sample_spec.channels) {
|
||||
pa_log_info("Restoring volume for source %s.", new_data->name);
|
||||
pa_source_new_data_set_volume(new_data, &e->volume);
|
||||
}
|
||||
|
||||
pa_log_info("Restoring mute state for source %s.", new_data->name);
|
||||
pa_source_new_data_set_muted(new_data, e->muted);
|
||||
pa_xfree(e);
|
||||
}
|
||||
|
||||
pa_xfree(name);
|
||||
|
||||
return PA_HOOK_OK;
|
||||
}
|
||||
|
||||
int pa__init(pa_module*m) {
|
||||
pa_modargs *ma = NULL;
|
||||
struct userdata *u;
|
||||
char *fname, *runtime_dir;
|
||||
char hn[256];
|
||||
pa_sink *sink;
|
||||
pa_source *source;
|
||||
uint32_t idx;
|
||||
|
||||
pa_assert(m);
|
||||
|
||||
if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
|
||||
pa_log("Failed to parse module arguments");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
u = pa_xnew(struct userdata, 1);
|
||||
u->core = m->core;
|
||||
u->save_time_event = NULL;
|
||||
|
||||
u->subscription = pa_subscription_new(m->core, PA_SUBSCRIPTION_MASK_SINK|PA_SUBSCRIPTION_MASK_SOURCE, subscribe_callback, u);
|
||||
|
||||
u->sink_fixate_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_FIXATE], (pa_hook_cb_t) sink_fixate_hook_callback, u);
|
||||
u->source_fixate_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_FIXATE], (pa_hook_cb_t) source_fixate_hook_callback, u);
|
||||
|
||||
m->userdata = u;
|
||||
|
||||
if (!pa_get_host_name(hn, sizeof(hn)))
|
||||
goto fail;
|
||||
|
||||
if (!(runtime_dir = pa_get_runtime_dir()))
|
||||
goto fail;
|
||||
|
||||
fname = pa_sprintf_malloc("%s/device-volumes.%s.gdbm", runtime_dir, hn);
|
||||
pa_xfree(runtime_dir);
|
||||
|
||||
if (!(u->gdbm_file = gdbm_open(fname, 0, GDBM_WRCREAT, 0600, NULL))) {
|
||||
pa_log("Failed to open volume database '%s': %s", fname, gdbm_strerror(gdbm_errno));
|
||||
pa_xfree(fname);
|
||||
goto fail;
|
||||
}
|
||||
|
||||
pa_log_info("Sucessfully opened database file '%s'.", fname);
|
||||
pa_xfree(fname);
|
||||
|
||||
for (sink = pa_idxset_first(m->core->sinks, &idx); sink; sink = pa_idxset_next(m->core->sinks, &idx))
|
||||
subscribe_callback(m->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_NEW, sink->index, u);
|
||||
|
||||
for (source = pa_idxset_first(m->core->sources, &idx); source; source = pa_idxset_next(m->core->sources, &idx))
|
||||
subscribe_callback(m->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_NEW, source->index, u);
|
||||
|
||||
pa_modargs_free(ma);
|
||||
return 0;
|
||||
|
||||
fail:
|
||||
pa__done(m);
|
||||
|
||||
if (ma)
|
||||
pa_modargs_free(ma);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
void pa__done(pa_module*m) {
|
||||
struct userdata* u;
|
||||
|
||||
pa_assert(m);
|
||||
|
||||
if (!(u = m->userdata))
|
||||
return;
|
||||
|
||||
if (u->subscription)
|
||||
pa_subscription_free(u->subscription);
|
||||
|
||||
if (u->sink_fixate_hook_slot)
|
||||
pa_hook_slot_free(u->sink_fixate_hook_slot);
|
||||
if (u->source_fixate_hook_slot)
|
||||
pa_hook_slot_free(u->source_fixate_hook_slot);
|
||||
|
||||
if (u->save_time_event)
|
||||
u->core->mainloop->time_free(u->save_time_event);
|
||||
|
||||
if (u->gdbm_file)
|
||||
gdbm_close(u->gdbm_file);
|
||||
|
||||
pa_xfree(u);
|
||||
}
|
||||
|
|
@ -143,7 +143,7 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
|
|||
switch ((pa_sink_state_t) PA_PTR_TO_UINT(data)) {
|
||||
|
||||
case PA_SINK_SUSPENDED:
|
||||
pa_assert(PA_SINK_OPENED(u->sink->thread_info.state));
|
||||
pa_assert(PA_SINK_IS_OPENED(u->sink->thread_info.state));
|
||||
|
||||
pa_smoother_pause(u->smoother, pa_rtclock_usec());
|
||||
break;
|
||||
|
|
@ -211,7 +211,7 @@ static void thread_func(void *userdata) {
|
|||
pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL);
|
||||
|
||||
/* Render some data and write it to the fifo */
|
||||
if (PA_SINK_OPENED(u->sink->thread_info.state) && pollfd->revents) {
|
||||
if (PA_SINK_IS_OPENED(u->sink->thread_info.state) && pollfd->revents) {
|
||||
pa_usec_t usec;
|
||||
int64_t n;
|
||||
|
||||
|
|
@ -294,7 +294,7 @@ static void thread_func(void *userdata) {
|
|||
}
|
||||
|
||||
/* Hmm, nothing to do. Let's sleep */
|
||||
pollfd->events = PA_SINK_OPENED(u->sink->thread_info.state) ? POLLOUT : 0;
|
||||
pollfd->events = PA_SINK_IS_OPENED(u->sink->thread_info.state) ? POLLOUT : 0;
|
||||
}
|
||||
|
||||
if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
|
||||
|
|
@ -502,12 +502,11 @@ static void on_connection(PA_GCC_UNUSED pa_socket_client *c, pa_iochannel*io, vo
|
|||
|
||||
int pa__init(pa_module*m) {
|
||||
struct userdata *u = NULL;
|
||||
const char *p;
|
||||
pa_sample_spec ss;
|
||||
pa_modargs *ma = NULL;
|
||||
char *t;
|
||||
const char *espeaker;
|
||||
uint32_t key;
|
||||
pa_sink_new_data data;
|
||||
|
||||
pa_assert(m);
|
||||
|
||||
|
|
@ -533,13 +532,12 @@ int pa__init(pa_module*m) {
|
|||
u->module = m;
|
||||
m->userdata = u;
|
||||
u->fd = -1;
|
||||
u->smoother = pa_smoother_new(PA_USEC_PER_SEC, PA_USEC_PER_SEC*2, TRUE);
|
||||
u->smoother = pa_smoother_new(PA_USEC_PER_SEC, PA_USEC_PER_SEC*2, TRUE, 10);
|
||||
pa_memchunk_reset(&u->memchunk);
|
||||
u->offset = 0;
|
||||
|
||||
pa_thread_mq_init(&u->thread_mq, m->core->mainloop);
|
||||
u->rtpoll = pa_rtpoll_new();
|
||||
pa_rtpoll_item_new_asyncmsgq(u->rtpoll, PA_RTPOLL_EARLY, u->thread_mq.inq);
|
||||
pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
|
||||
u->rtpoll_item = NULL;
|
||||
|
||||
u->format =
|
||||
|
|
@ -554,30 +552,38 @@ int pa__init(pa_module*m) {
|
|||
u->state = STATE_AUTH;
|
||||
u->latency = 0;
|
||||
|
||||
if (!(u->sink = pa_sink_new(m->core, __FILE__, pa_modargs_get_value(ma, "sink_name", DEFAULT_SINK_NAME), 0, &ss, NULL))) {
|
||||
if (!(espeaker = getenv("ESPEAKER")))
|
||||
espeaker = ESD_UNIX_SOCKET_NAME;
|
||||
|
||||
espeaker = pa_modargs_get_value(ma, "server", espeaker);
|
||||
|
||||
pa_sink_new_data_init(&data);
|
||||
data.driver = __FILE__;
|
||||
data.module = m;
|
||||
pa_sink_new_data_set_name(&data, pa_modargs_get_value(ma, "sink_name", DEFAULT_SINK_NAME));
|
||||
pa_sink_new_data_set_sample_spec(&data, &ss);
|
||||
pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, espeaker);
|
||||
pa_proplist_setf(data.proplist, PA_PROP_DEVICE_DESCRIPTION, "Esound sink '%s'", espeaker);
|
||||
|
||||
u->sink = pa_sink_new(m->core, &data, PA_SINK_LATENCY|PA_SINK_NETWORK);
|
||||
pa_sink_new_data_done(&data);
|
||||
|
||||
if (!u->sink) {
|
||||
pa_log("Failed to create sink.");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
u->sink->parent.process_msg = sink_process_msg;
|
||||
u->sink->userdata = u;
|
||||
u->sink->flags = PA_SINK_LATENCY|PA_SINK_NETWORK;
|
||||
|
||||
pa_sink_set_module(u->sink, m);
|
||||
pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
|
||||
pa_sink_set_rtpoll(u->sink, u->rtpoll);
|
||||
|
||||
if (!(espeaker = getenv("ESPEAKER")))
|
||||
espeaker = ESD_UNIX_SOCKET_NAME;
|
||||
|
||||
if (!(u->client = pa_socket_client_new_string(u->core->mainloop, p = pa_modargs_get_value(ma, "server", espeaker), ESD_DEFAULT_PORT))) {
|
||||
if (!(u->client = pa_socket_client_new_string(u->core->mainloop, espeaker, ESD_DEFAULT_PORT))) {
|
||||
pa_log("Failed to connect to server.");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
pa_sink_set_description(u->sink, t = pa_sprintf_malloc("Esound sink '%s'", p));
|
||||
pa_xfree(t);
|
||||
|
||||
pa_socket_client_set_callback(u->client, on_connection, u);
|
||||
|
||||
/* Prepare the initial request */
|
||||
|
|
|
|||
|
|
@ -372,7 +372,7 @@ static int hal_device_add_all(struct userdata *u, const char *capability) {
|
|||
pa_log_debug("Not loaded device %s", udis[i]);
|
||||
else {
|
||||
if (d->sink_name)
|
||||
pa_scache_play_item_by_name(u->core, "pulse-coldplug", d->sink_name, PA_VOLUME_NORM, 0);
|
||||
pa_scache_play_item_by_name(u->core, "pulse-coldplug", d->sink_name, FALSE, PA_VOLUME_NORM, NULL, NULL);
|
||||
count++;
|
||||
}
|
||||
}
|
||||
|
|
@ -412,7 +412,7 @@ static void device_added_time_cb(pa_mainloop_api *ea, pa_time_event *ev, const s
|
|||
pa_log_debug("Not loaded device %s", td->udi);
|
||||
else {
|
||||
if (d->sink_name)
|
||||
pa_scache_play_item_by_name(td->u->core, "pulse-hotplug", d->sink_name, PA_VOLUME_NORM, 0);
|
||||
pa_scache_play_item_by_name(td->u->core, "pulse-hotplug", d->sink_name, FALSE, PA_VOLUME_NORM, NULL, NULL);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -575,7 +575,7 @@ static DBusHandlerResult filter_cb(DBusConnection *bus, DBusMessage *message, vo
|
|||
if (prev_suspended && !suspend) {
|
||||
/* resume */
|
||||
if (pa_sink_suspend(sink, 0) >= 0)
|
||||
pa_scache_play_item_by_name(u->core, "pulse-access", d->sink_name, PA_VOLUME_NORM, 0);
|
||||
pa_scache_play_item_by_name(u->core, "pulse-access", d->sink_name, FALSE, PA_VOLUME_NORM, NULL, NULL);
|
||||
else
|
||||
d->acl_race_fix = 1;
|
||||
|
||||
|
|
@ -643,7 +643,7 @@ static DBusHandlerResult filter_cb(DBusConnection *bus, DBusMessage *message, vo
|
|||
if (prev_suspended) {
|
||||
/* resume */
|
||||
if (pa_sink_suspend(sink, 0) >= 0)
|
||||
pa_scache_play_item_by_name(u->core, "pulse-access", d->sink_name, PA_VOLUME_NORM, 0);
|
||||
pa_scache_play_item_by_name(u->core, "pulse-access", d->sink_name, FALSE, PA_VOLUME_NORM, NULL, NULL);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -53,7 +53,7 @@
|
|||
|
||||
/* General overview:
|
||||
*
|
||||
* Because JACK has a very unflexible event loop management, which
|
||||
* Because JACK has a very unflexible event loop management which
|
||||
* doesn't allow us to add our own event sources to the event thread
|
||||
* we cannot use the JACK real-time thread for dispatching our PA
|
||||
* work. Instead, we run an additional RT thread which does most of
|
||||
|
|
@ -276,7 +276,7 @@ int pa__init(pa_module*m) {
|
|||
pa_bool_t do_connect = TRUE;
|
||||
unsigned i;
|
||||
const char **ports = NULL, **p;
|
||||
char *t;
|
||||
pa_sink_new_data data;
|
||||
|
||||
pa_assert(m);
|
||||
|
||||
|
|
@ -300,9 +300,8 @@ int pa__init(pa_module*m) {
|
|||
u->module = m;
|
||||
m->userdata = u;
|
||||
u->saved_frame_time_valid = FALSE;
|
||||
pa_thread_mq_init(&u->thread_mq, m->core->mainloop);
|
||||
u->rtpoll = pa_rtpoll_new();
|
||||
pa_rtpoll_item_new_asyncmsgq(u->rtpoll, PA_RTPOLL_EARLY, u->thread_mq.inq);
|
||||
pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
|
||||
|
||||
/* The queue linking the JACK thread and our RT thread */
|
||||
u->jack_msgq = pa_asyncmsgq_new(0);
|
||||
|
|
@ -312,7 +311,7 @@ int pa__init(pa_module*m) {
|
|||
* all other drivers make: supplying the audio device with data is
|
||||
* the top priority -- and as long as that is possible we don't do
|
||||
* anything else */
|
||||
u->rtpoll_item = pa_rtpoll_item_new_asyncmsgq(u->rtpoll, PA_RTPOLL_EARLY-1, u->jack_msgq);
|
||||
u->rtpoll_item = pa_rtpoll_item_new_asyncmsgq_read(u->rtpoll, PA_RTPOLL_EARLY-1, u->jack_msgq);
|
||||
|
||||
if (!(u->client = jack_client_open(client_name, server_name ? JackServerName : JackNullOption, &status, server_name))) {
|
||||
pa_log("jack_client_open() failed.");
|
||||
|
|
@ -355,20 +354,31 @@ int pa__init(pa_module*m) {
|
|||
}
|
||||
}
|
||||
|
||||
if (!(u->sink = pa_sink_new(m->core, __FILE__, pa_modargs_get_value(ma, "sink_name", DEFAULT_SINK_NAME), 0, &ss, &map))) {
|
||||
pa_log("failed to create sink.");
|
||||
pa_sink_new_data_init(&data);
|
||||
data.driver = __FILE__;
|
||||
data.module = m;
|
||||
pa_sink_new_data_set_name(&data, pa_modargs_get_value(ma, "sink_name", DEFAULT_SINK_NAME));
|
||||
pa_sink_new_data_set_sample_spec(&data, &ss);
|
||||
pa_sink_new_data_set_channel_map(&data, &map);
|
||||
pa_proplist_sets(data.proplist, PA_PROP_DEVICE_API, "jack");
|
||||
if (server_name)
|
||||
pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, server_name);
|
||||
pa_proplist_setf(data.proplist, PA_PROP_DEVICE_DESCRIPTION, "Jack sink (%s)", jack_get_client_name(u->client));
|
||||
pa_proplist_sets(data.proplist, "jack.client_name", jack_get_client_name(u->client));
|
||||
|
||||
u->sink = pa_sink_new(m->core, &data, PA_SINK_LATENCY);
|
||||
pa_sink_new_data_done(&data);
|
||||
|
||||
if (!u->sink) {
|
||||
pa_log("Failed to create sink.");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
u->sink->parent.process_msg = sink_process_msg;
|
||||
u->sink->userdata = u;
|
||||
u->sink->flags = PA_SINK_LATENCY;
|
||||
|
||||
pa_sink_set_module(u->sink, m);
|
||||
pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
|
||||
pa_sink_set_rtpoll(u->sink, u->rtpoll);
|
||||
pa_sink_set_description(u->sink, t = pa_sprintf_malloc("Jack sink (%s)", jack_get_client_name(u->client)));
|
||||
pa_xfree(t);
|
||||
|
||||
jack_set_process_callback(u->client, jack_process, u);
|
||||
jack_on_shutdown(u->client, jack_shutdown, u);
|
||||
|
|
|
|||
|
|
@ -253,7 +253,7 @@ int pa__init(pa_module*m) {
|
|||
pa_bool_t do_connect = TRUE;
|
||||
unsigned i;
|
||||
const char **ports = NULL, **p;
|
||||
char *t;
|
||||
pa_source_new_data data;
|
||||
|
||||
pa_assert(m);
|
||||
|
||||
|
|
@ -278,12 +278,11 @@ int pa__init(pa_module*m) {
|
|||
m->userdata = u;
|
||||
u->saved_frame_time_valid = FALSE;
|
||||
|
||||
pa_thread_mq_init(&u->thread_mq, m->core->mainloop);
|
||||
u->rtpoll = pa_rtpoll_new();
|
||||
pa_rtpoll_item_new_asyncmsgq(u->rtpoll, PA_RTPOLL_EARLY, u->thread_mq.inq);
|
||||
pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
|
||||
|
||||
u->jack_msgq = pa_asyncmsgq_new(0);
|
||||
u->rtpoll_item = pa_rtpoll_item_new_asyncmsgq(u->rtpoll, PA_RTPOLL_EARLY-1, u->jack_msgq);
|
||||
u->rtpoll_item = pa_rtpoll_item_new_asyncmsgq_read(u->rtpoll, PA_RTPOLL_EARLY-1, u->jack_msgq);
|
||||
|
||||
if (!(u->client = jack_client_open(client_name, server_name ? JackServerName : JackNullOption, &status, server_name))) {
|
||||
pa_log("jack_client_open() failed.");
|
||||
|
|
@ -326,20 +325,31 @@ int pa__init(pa_module*m) {
|
|||
}
|
||||
}
|
||||
|
||||
if (!(u->source = pa_source_new(m->core, __FILE__, pa_modargs_get_value(ma, "source_name", DEFAULT_SOURCE_NAME), 0, &ss, &map))) {
|
||||
pa_log("failed to create source.");
|
||||
pa_source_new_data_init(&data);
|
||||
data.driver = __FILE__;
|
||||
data.module = m;
|
||||
pa_source_new_data_set_name(&data, pa_modargs_get_value(ma, "source_name", DEFAULT_SOURCE_NAME));
|
||||
pa_source_new_data_set_sample_spec(&data, &ss);
|
||||
pa_source_new_data_set_channel_map(&data, &map);
|
||||
pa_proplist_sets(data.proplist, PA_PROP_DEVICE_API, "jack");
|
||||
if (server_name)
|
||||
pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, server_name);
|
||||
pa_proplist_setf(data.proplist, PA_PROP_DEVICE_DESCRIPTION, "Jack source (%s)", jack_get_client_name(u->client));
|
||||
pa_proplist_sets(data.proplist, "jack.client_name", jack_get_client_name(u->client));
|
||||
|
||||
u->source = pa_source_new(m->core, &data, PA_SOURCE_LATENCY);
|
||||
pa_source_new_data_done(&data);
|
||||
|
||||
if (!u->source) {
|
||||
pa_log("Failed to create source.");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
u->source->parent.process_msg = source_process_msg;
|
||||
u->source->userdata = u;
|
||||
u->source->flags = PA_SOURCE_LATENCY;
|
||||
|
||||
pa_source_set_module(u->source, m);
|
||||
pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
|
||||
pa_source_set_rtpoll(u->source, u->rtpoll);
|
||||
pa_source_set_description(u->source, t = pa_sprintf_malloc("Jack source (%s)", jack_get_client_name(u->client)));
|
||||
pa_xfree(t);
|
||||
|
||||
jack_set_process_callback(u->client, jack_process, u);
|
||||
jack_on_shutdown(u->client, jack_shutdown, u);
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@
|
|||
/***
|
||||
This file is part of PulseAudio.
|
||||
|
||||
Copyright 2004-2006 Lennart Poettering
|
||||
Copyright 2004-2008 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
|
||||
|
|
@ -41,6 +41,7 @@
|
|||
#include <pulsecore/thread-mq.h>
|
||||
#include <pulsecore/rtpoll.h>
|
||||
#include <pulsecore/sample-util.h>
|
||||
#include <pulsecore/ltdl-helper.h>
|
||||
|
||||
#include "module-ladspa-sink-symdef.h"
|
||||
#include "ladspa.h"
|
||||
|
|
@ -60,6 +61,8 @@ PA_MODULE_USAGE(
|
|||
"label=<ladspa plugin label> "
|
||||
"control=<comma seperated list of input control values>");
|
||||
|
||||
#define MEMBLOCKQ_MAXLENGTH (16*1024*1024)
|
||||
|
||||
struct userdata {
|
||||
pa_core *core;
|
||||
pa_module *module;
|
||||
|
|
@ -79,7 +82,7 @@ struct userdata {
|
|||
about control out ports. We connect them all to this single buffer. */
|
||||
LADSPA_Data control_out;
|
||||
|
||||
pa_memchunk memchunk;
|
||||
pa_memblockq *memblockq;
|
||||
};
|
||||
|
||||
static const char* const valid_modargs[] = {
|
||||
|
|
@ -104,10 +107,14 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
|
|||
case PA_SINK_MESSAGE_GET_LATENCY: {
|
||||
pa_usec_t usec = 0;
|
||||
|
||||
/* Get the latency of the master sink */
|
||||
if (PA_MSGOBJECT(u->master)->process_msg(PA_MSGOBJECT(u->master), PA_SINK_MESSAGE_GET_LATENCY, &usec, 0, NULL) < 0)
|
||||
usec = 0;
|
||||
|
||||
*((pa_usec_t*) data) = usec + pa_bytes_to_usec(u->memchunk.length, &u->sink->sample_spec);
|
||||
/* Add the latency internal to our sink input on top */
|
||||
usec += pa_bytes_to_usec(pa_memblockq_get_length(u->sink_input->thread_info.render_memblockq), &u->master->sample_spec);
|
||||
|
||||
*((pa_usec_t*) data) = usec;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
|
@ -122,110 +129,143 @@ static int sink_set_state(pa_sink *s, pa_sink_state_t state) {
|
|||
pa_sink_assert_ref(s);
|
||||
pa_assert_se(u = s->userdata);
|
||||
|
||||
if (PA_SINK_LINKED(state) && u->sink_input && PA_SINK_INPUT_LINKED(pa_sink_input_get_state(u->sink_input)))
|
||||
if (PA_SINK_IS_LINKED(state) &&
|
||||
u->sink_input &&
|
||||
PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u->sink_input)))
|
||||
|
||||
pa_sink_input_cork(u->sink_input, state == PA_SINK_SUSPENDED);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Called from I/O thread context */
|
||||
static int sink_input_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
|
||||
struct userdata *u = PA_SINK_INPUT(o)->userdata;
|
||||
static void sink_request_rewind(pa_sink *s) {
|
||||
struct userdata *u;
|
||||
|
||||
switch (code) {
|
||||
case PA_SINK_INPUT_MESSAGE_GET_LATENCY:
|
||||
*((pa_usec_t*) data) = pa_bytes_to_usec(u->memchunk.length, &u->sink_input->sample_spec);
|
||||
pa_sink_assert_ref(s);
|
||||
pa_assert_se(u = s->userdata);
|
||||
|
||||
/* Fall through, the default handler will add in the extra
|
||||
* latency added by the resampler */
|
||||
break;
|
||||
}
|
||||
|
||||
return pa_sink_input_process_msg(o, code, data, offset, chunk);
|
||||
/* Just hand this one over to the master sink */
|
||||
pa_sink_input_request_rewind(u->sink_input, s->thread_info.rewind_nbytes + pa_memblockq_get_length(u->memblockq), TRUE, FALSE);
|
||||
}
|
||||
|
||||
/* Called from I/O thread context */
|
||||
static int sink_input_peek_cb(pa_sink_input *i, size_t length, pa_memchunk *chunk) {
|
||||
static void sink_update_requested_latency(pa_sink *s) {
|
||||
struct userdata *u;
|
||||
|
||||
pa_sink_assert_ref(s);
|
||||
pa_assert_se(u = s->userdata);
|
||||
|
||||
/* Just hand this one over to the master sink */
|
||||
pa_sink_input_set_requested_latency_within_thread(
|
||||
u->sink_input,
|
||||
pa_sink_get_requested_latency_within_thread(s));
|
||||
}
|
||||
|
||||
/* Called from I/O thread context */
|
||||
static int sink_input_pop_cb(pa_sink_input *i, size_t nbytes, pa_memchunk *chunk) {
|
||||
struct userdata *u;
|
||||
float *src, *dst;
|
||||
size_t fs;
|
||||
unsigned n, c;
|
||||
pa_memchunk tchunk;
|
||||
|
||||
pa_sink_input_assert_ref(i);
|
||||
pa_assert(chunk);
|
||||
pa_assert_se(u = i->userdata);
|
||||
|
||||
if (!u->memchunk.memblock) {
|
||||
pa_memchunk tchunk;
|
||||
float *src, *dst;
|
||||
size_t fs;
|
||||
unsigned n, c;
|
||||
if (!u->sink || !PA_SINK_IS_OPENED(u->sink->thread_info.state))
|
||||
return -1;
|
||||
|
||||
pa_sink_render(u->sink, length, &tchunk);
|
||||
while (pa_memblockq_peek(u->memblockq, &tchunk) < 0) {
|
||||
pa_memchunk nchunk;
|
||||
|
||||
fs = pa_frame_size(&i->sample_spec);
|
||||
n = tchunk.length / fs;
|
||||
|
||||
pa_assert(n > 0);
|
||||
|
||||
u->memchunk.memblock = pa_memblock_new(i->sink->core->mempool, tchunk.length);
|
||||
u->memchunk.index = 0;
|
||||
u->memchunk.length = tchunk.length;
|
||||
|
||||
src = (float*) ((uint8_t*) pa_memblock_acquire(tchunk.memblock) + tchunk.index);
|
||||
dst = (float*) pa_memblock_acquire(u->memchunk.memblock);
|
||||
|
||||
for (c = 0; c < u->channels; c++) {
|
||||
unsigned j;
|
||||
float *p, *q;
|
||||
|
||||
p = src + c;
|
||||
q = u->input;
|
||||
for (j = 0; j < n; j++, p += u->channels, q++)
|
||||
*q = PA_CLAMP_UNLIKELY(*p, -1.0, 1.0);
|
||||
|
||||
u->descriptor->run(u->handle[c], n);
|
||||
|
||||
q = u->output;
|
||||
p = dst + c;
|
||||
for (j = 0; j < n; j++, q++, p += u->channels)
|
||||
*p = PA_CLAMP_UNLIKELY(*q, -1.0, 1.0);
|
||||
}
|
||||
|
||||
pa_memblock_release(tchunk.memblock);
|
||||
pa_memblock_release(u->memchunk.memblock);
|
||||
|
||||
pa_memblock_unref(tchunk.memblock);
|
||||
pa_sink_render(u->sink, nbytes, &nchunk);
|
||||
pa_memblockq_push(u->memblockq, &nchunk);
|
||||
pa_memblock_unref(nchunk.memblock);
|
||||
}
|
||||
|
||||
pa_assert(u->memchunk.length > 0);
|
||||
pa_assert(u->memchunk.memblock);
|
||||
pa_assert(tchunk.length > 0);
|
||||
|
||||
*chunk = u->memchunk;
|
||||
pa_memblock_ref(chunk->memblock);
|
||||
fs = pa_frame_size(&i->sample_spec);
|
||||
n = PA_MIN(tchunk.length, u->block_size) / fs;
|
||||
|
||||
pa_assert(n > 0);
|
||||
|
||||
chunk->index = 0;
|
||||
chunk->length = n*fs;
|
||||
chunk->memblock = pa_memblock_new(i->sink->core->mempool, chunk->length);
|
||||
|
||||
pa_memblockq_drop(u->memblockq, chunk->length);
|
||||
|
||||
src = (float*) ((uint8_t*) pa_memblock_acquire(tchunk.memblock) + tchunk.index);
|
||||
dst = (float*) pa_memblock_acquire(chunk->memblock);
|
||||
|
||||
for (c = 0; c < u->channels; c++) {
|
||||
pa_sample_clamp(PA_SAMPLE_FLOAT32NE, u->input, sizeof(float), src+c, u->channels*sizeof(float), n);
|
||||
u->descriptor->run(u->handle[c], n);
|
||||
pa_sample_clamp(PA_SAMPLE_FLOAT32NE, dst+c, u->channels*sizeof(float), u->output, sizeof(float), n);
|
||||
}
|
||||
|
||||
pa_memblock_release(tchunk.memblock);
|
||||
pa_memblock_release(chunk->memblock);
|
||||
|
||||
pa_memblock_unref(tchunk.memblock);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Called from I/O thread context */
|
||||
static void sink_input_drop_cb(pa_sink_input *i, size_t length) {
|
||||
static void sink_input_process_rewind_cb(pa_sink_input *i, size_t nbytes) {
|
||||
struct userdata *u;
|
||||
|
||||
pa_sink_input_assert_ref(i);
|
||||
pa_assert_se(u = i->userdata);
|
||||
pa_assert(length > 0);
|
||||
pa_assert(nbytes > 0);
|
||||
|
||||
if (u->memchunk.memblock) {
|
||||
if (!u->sink || !PA_SINK_IS_OPENED(u->sink->thread_info.state))
|
||||
return;
|
||||
|
||||
if (length < u->memchunk.length) {
|
||||
u->memchunk.index += length;
|
||||
u->memchunk.length -= length;
|
||||
return;
|
||||
if (u->sink->thread_info.rewind_nbytes > 0) {
|
||||
size_t max_rewrite, amount;
|
||||
|
||||
max_rewrite = nbytes + pa_memblockq_get_length(u->memblockq);
|
||||
amount = PA_MIN(u->sink->thread_info.rewind_nbytes, max_rewrite);
|
||||
u->sink->thread_info.rewind_nbytes = 0;
|
||||
|
||||
if (amount > 0) {
|
||||
unsigned c;
|
||||
|
||||
pa_memblockq_seek(u->memblockq, - (int64_t) amount, PA_SEEK_RELATIVE);
|
||||
pa_sink_process_rewind(u->sink, amount);
|
||||
|
||||
pa_log_debug("Resetting plugin");
|
||||
|
||||
/* Reset the plugin */
|
||||
if (u->descriptor->deactivate)
|
||||
for (c = 0; c < u->channels; c++)
|
||||
u->descriptor->deactivate(u->handle[c]);
|
||||
if (u->descriptor->activate)
|
||||
for (c = 0; c < u->channels; c++)
|
||||
u->descriptor->activate(u->handle[c]);
|
||||
}
|
||||
|
||||
pa_memblock_unref(u->memchunk.memblock);
|
||||
length -= u->memchunk.length;
|
||||
pa_memchunk_reset(&u->memchunk);
|
||||
}
|
||||
|
||||
if (length > 0)
|
||||
pa_sink_skip(u->sink, length);
|
||||
pa_memblockq_rewind(u->memblockq, nbytes);
|
||||
}
|
||||
|
||||
/* Called from I/O thread context */
|
||||
static void sink_input_update_max_rewind_cb(pa_sink_input *i, size_t nbytes) {
|
||||
struct userdata *u;
|
||||
|
||||
pa_sink_input_assert_ref(i);
|
||||
pa_assert_se(u = i->userdata);
|
||||
|
||||
if (!u->sink || !PA_SINK_IS_OPENED(u->sink->thread_info.state))
|
||||
return;
|
||||
|
||||
pa_memblockq_set_maxrewind(u->memblockq, nbytes);
|
||||
pa_sink_set_max_rewind(u->sink, nbytes);
|
||||
}
|
||||
|
||||
/* Called from I/O thread context */
|
||||
|
|
@ -235,7 +275,12 @@ static void sink_input_detach_cb(pa_sink_input *i) {
|
|||
pa_sink_input_assert_ref(i);
|
||||
pa_assert_se(u = i->userdata);
|
||||
|
||||
if (!u->sink || !PA_SINK_IS_OPENED(u->sink->thread_info.state))
|
||||
return;
|
||||
|
||||
pa_sink_detach_within_thread(u->sink);
|
||||
pa_sink_set_asyncmsgq(u->sink, NULL);
|
||||
pa_sink_set_rtpoll(u->sink, NULL);
|
||||
}
|
||||
|
||||
/* Called from I/O thread context */
|
||||
|
|
@ -245,10 +290,15 @@ static void sink_input_attach_cb(pa_sink_input *i) {
|
|||
pa_sink_input_assert_ref(i);
|
||||
pa_assert_se(u = i->userdata);
|
||||
|
||||
if (!u->sink || !PA_SINK_IS_OPENED(u->sink->thread_info.state))
|
||||
return;
|
||||
|
||||
pa_sink_set_asyncmsgq(u->sink, i->sink->asyncmsgq);
|
||||
pa_sink_set_rtpoll(u->sink, i->sink->rtpoll);
|
||||
|
||||
pa_sink_attach_within_thread(u->sink);
|
||||
|
||||
u->sink->max_latency = u->master->max_latency;
|
||||
u->sink->min_latency = u->master->min_latency;
|
||||
}
|
||||
|
||||
/* Called from main context */
|
||||
|
|
@ -258,25 +308,43 @@ static void sink_input_kill_cb(pa_sink_input *i) {
|
|||
pa_sink_input_assert_ref(i);
|
||||
pa_assert_se(u = i->userdata);
|
||||
|
||||
pa_sink_unlink(u->sink);
|
||||
pa_sink_input_unlink(u->sink_input);
|
||||
|
||||
pa_sink_unref(u->sink);
|
||||
u->sink = NULL;
|
||||
pa_sink_input_unref(u->sink_input);
|
||||
u->sink_input = NULL;
|
||||
|
||||
pa_sink_unlink(u->sink);
|
||||
pa_sink_unref(u->sink);
|
||||
u->sink = NULL;
|
||||
|
||||
pa_module_unload_request(u->module);
|
||||
}
|
||||
|
||||
/* Called from IO thread context */
|
||||
static void sink_input_state_change_cb(pa_sink_input *i, pa_sink_input_state_t state) {
|
||||
struct userdata *u;
|
||||
|
||||
pa_sink_input_assert_ref(i);
|
||||
pa_assert_se(u = i->userdata);
|
||||
|
||||
/* If we are added for the first time, ask for a rewinding so that
|
||||
* we are heard right-away. */
|
||||
if (PA_SINK_INPUT_IS_LINKED(state) &&
|
||||
i->thread_info.state == PA_SINK_INPUT_INIT) {
|
||||
pa_log_debug("Requesting rewind due to state change.");
|
||||
pa_sink_input_request_rewind(i, 0, FALSE, TRUE);
|
||||
}
|
||||
}
|
||||
|
||||
int pa__init(pa_module*m) {
|
||||
struct userdata *u;
|
||||
pa_sample_spec ss;
|
||||
pa_channel_map map;
|
||||
pa_modargs *ma;
|
||||
char *t;
|
||||
const char *z;
|
||||
pa_sink *master;
|
||||
pa_sink_input_new_data data;
|
||||
pa_sink_input_new_data sink_input_data;
|
||||
pa_sink_new_data sink_data;
|
||||
const char *plugin, *label;
|
||||
LADSPA_Descriptor_Function descriptor_func;
|
||||
const char *e, *cdata;
|
||||
|
|
@ -284,7 +352,6 @@ int pa__init(pa_module*m) {
|
|||
unsigned long input_port, output_port, p, j, n_control;
|
||||
unsigned c;
|
||||
pa_bool_t *use_default = NULL;
|
||||
char *default_sink_name = NULL;
|
||||
|
||||
pa_assert(m);
|
||||
|
||||
|
|
@ -325,7 +392,9 @@ int pa__init(pa_module*m) {
|
|||
u->module = m;
|
||||
m->userdata = u;
|
||||
u->master = master;
|
||||
pa_memchunk_reset(&u->memchunk);
|
||||
u->sink = NULL;
|
||||
u->sink_input = NULL;
|
||||
u->memblockq = pa_memblockq_new(0, MEMBLOCKQ_MAXLENGTH, 0, pa_frame_size(&ss), 1, 1, 0, NULL);
|
||||
|
||||
if (!(e = getenv("LADSPA_PATH")))
|
||||
e = LADSPA_PATH;
|
||||
|
|
@ -342,7 +411,7 @@ int pa__init(pa_module*m) {
|
|||
goto fail;
|
||||
}
|
||||
|
||||
if (!(descriptor_func = (LADSPA_Descriptor_Function) lt_dlsym(m->dl, "ladspa_descriptor"))) {
|
||||
if (!(descriptor_func = (LADSPA_Descriptor_Function) pa_load_sym(m->dl, NULL, "ladspa_descriptor"))) {
|
||||
pa_log("LADSPA module lacks ladspa_descriptor() symbol.");
|
||||
goto fail;
|
||||
}
|
||||
|
|
@ -350,7 +419,7 @@ int pa__init(pa_module*m) {
|
|||
for (j = 0;; j++) {
|
||||
|
||||
if (!(d = descriptor_func(j))) {
|
||||
pa_log("Failed to find plugin label '%s' in plugin '%s'.", plugin, label);
|
||||
pa_log("Failed to find plugin label '%s' in plugin '%s'.", label, plugin);
|
||||
goto fail;
|
||||
}
|
||||
|
||||
|
|
@ -582,43 +651,66 @@ int pa__init(pa_module*m) {
|
|||
for (c = 0; c < u->channels; c++)
|
||||
d->activate(u->handle[c]);
|
||||
|
||||
default_sink_name = pa_sprintf_malloc("%s.ladspa", master->name);
|
||||
|
||||
/* Create sink */
|
||||
if (!(u->sink = pa_sink_new(m->core, __FILE__, pa_modargs_get_value(ma, "sink_name", default_sink_name), 0, &ss, &map))) {
|
||||
pa_sink_new_data_init(&sink_data);
|
||||
sink_data.driver = __FILE__;
|
||||
sink_data.module = m;
|
||||
if (!(sink_data.name = pa_xstrdup(pa_modargs_get_value(ma, "sink_name", NULL))))
|
||||
sink_data.name = pa_sprintf_malloc("%s.ladspa", master->name);
|
||||
sink_data.namereg_fail = FALSE;
|
||||
pa_sink_new_data_set_sample_spec(&sink_data, &ss);
|
||||
pa_sink_new_data_set_channel_map(&sink_data, &map);
|
||||
z = pa_proplist_gets(master->proplist, PA_PROP_DEVICE_DESCRIPTION);
|
||||
pa_proplist_setf(sink_data.proplist, PA_PROP_DEVICE_DESCRIPTION, "LADSPA Plugin %s on %s", label, z ? z : master->name);
|
||||
pa_proplist_sets(sink_data.proplist, PA_PROP_DEVICE_MASTER_DEVICE, master->name);
|
||||
pa_proplist_sets(sink_data.proplist, PA_PROP_DEVICE_CLASS, "filter");
|
||||
pa_proplist_sets(sink_data.proplist, "device.ladspa.module", plugin);
|
||||
pa_proplist_sets(sink_data.proplist, "device.ladspa.label", d->Label);
|
||||
pa_proplist_sets(sink_data.proplist, "device.ladspa.name", d->Name);
|
||||
pa_proplist_sets(sink_data.proplist, "device.ladspa.maker", d->Maker);
|
||||
pa_proplist_sets(sink_data.proplist, "device.ladspa.copyright", d->Copyright);
|
||||
pa_proplist_setf(sink_data.proplist, "device.ladspa.unique_id", "%lu", (unsigned long) d->UniqueID);
|
||||
|
||||
u->sink = pa_sink_new(m->core, &sink_data, PA_SINK_LATENCY);
|
||||
pa_sink_new_data_done(&sink_data);
|
||||
|
||||
if (!u->sink) {
|
||||
pa_log("Failed to create sink.");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
u->sink->parent.process_msg = sink_process_msg;
|
||||
u->sink->set_state = sink_set_state;
|
||||
u->sink->update_requested_latency = sink_update_requested_latency;
|
||||
u->sink->request_rewind = sink_request_rewind;
|
||||
u->sink->userdata = u;
|
||||
u->sink->flags = PA_SINK_LATENCY;
|
||||
|
||||
pa_sink_set_module(u->sink, m);
|
||||
pa_sink_set_description(u->sink, t = pa_sprintf_malloc("LADSPA plugin '%s' on '%s'", label, master->description));
|
||||
pa_xfree(t);
|
||||
pa_sink_set_asyncmsgq(u->sink, master->asyncmsgq);
|
||||
pa_sink_set_rtpoll(u->sink, master->rtpoll);
|
||||
|
||||
/* Create sink input */
|
||||
pa_sink_input_new_data_init(&data);
|
||||
data.sink = u->master;
|
||||
data.driver = __FILE__;
|
||||
data.name = "LADSPA Stream";
|
||||
pa_sink_input_new_data_set_sample_spec(&data, &ss);
|
||||
pa_sink_input_new_data_set_channel_map(&data, &map);
|
||||
data.module = m;
|
||||
pa_sink_input_new_data_init(&sink_input_data);
|
||||
sink_input_data.driver = __FILE__;
|
||||
sink_input_data.module = m;
|
||||
sink_input_data.sink = u->master;
|
||||
pa_proplist_sets(sink_input_data.proplist, PA_PROP_MEDIA_NAME, "LADSPA Stream");
|
||||
pa_proplist_sets(sink_input_data.proplist, PA_PROP_MEDIA_ROLE, "filter");
|
||||
pa_sink_input_new_data_set_sample_spec(&sink_input_data, &ss);
|
||||
pa_sink_input_new_data_set_channel_map(&sink_input_data, &map);
|
||||
|
||||
if (!(u->sink_input = pa_sink_input_new(m->core, &data, PA_SINK_INPUT_DONT_MOVE)))
|
||||
u->sink_input = pa_sink_input_new(m->core, &sink_input_data, PA_SINK_INPUT_DONT_MOVE);
|
||||
pa_sink_input_new_data_done(&sink_input_data);
|
||||
|
||||
if (!u->sink_input)
|
||||
goto fail;
|
||||
|
||||
u->sink_input->parent.process_msg = sink_input_process_msg;
|
||||
u->sink_input->peek = sink_input_peek_cb;
|
||||
u->sink_input->drop = sink_input_drop_cb;
|
||||
u->sink_input->pop = sink_input_pop_cb;
|
||||
u->sink_input->process_rewind = sink_input_process_rewind_cb;
|
||||
u->sink_input->update_max_rewind = sink_input_update_max_rewind_cb;
|
||||
u->sink_input->kill = sink_input_kill_cb;
|
||||
u->sink_input->attach = sink_input_attach_cb;
|
||||
u->sink_input->detach = sink_input_detach_cb;
|
||||
u->sink_input->state_change = sink_input_state_change_cb;
|
||||
u->sink_input->userdata = u;
|
||||
|
||||
pa_sink_put(u->sink);
|
||||
|
|
@ -627,7 +719,6 @@ int pa__init(pa_module*m) {
|
|||
pa_modargs_free(ma);
|
||||
|
||||
pa_xfree(use_default);
|
||||
pa_xfree(default_sink_name);
|
||||
|
||||
return 0;
|
||||
|
||||
|
|
@ -636,7 +727,6 @@ fail:
|
|||
pa_modargs_free(ma);
|
||||
|
||||
pa_xfree(use_default);
|
||||
pa_xfree(default_sink_name);
|
||||
|
||||
pa__done(m);
|
||||
|
||||
|
|
@ -652,18 +742,15 @@ void pa__done(pa_module*m) {
|
|||
if (!(u = m->userdata))
|
||||
return;
|
||||
|
||||
if (u->sink_input) {
|
||||
pa_sink_input_unlink(u->sink_input);
|
||||
pa_sink_input_unref(u->sink_input);
|
||||
}
|
||||
|
||||
if (u->sink) {
|
||||
pa_sink_unlink(u->sink);
|
||||
pa_sink_unref(u->sink);
|
||||
}
|
||||
|
||||
if (u->memchunk.memblock)
|
||||
pa_memblock_unref(u->memchunk.memblock);
|
||||
if (u->sink_input) {
|
||||
pa_sink_input_unlink(u->sink_input);
|
||||
pa_sink_input_unref(u->sink_input);
|
||||
}
|
||||
|
||||
for (c = 0; c < u->channels; c++)
|
||||
if (u->handle[c]) {
|
||||
|
|
@ -675,6 +762,9 @@ void pa__done(pa_module*m) {
|
|||
if (u->output != u->input)
|
||||
pa_xfree(u->output);
|
||||
|
||||
if (u->memblockq)
|
||||
pa_memblockq_free(u->memblockq);
|
||||
|
||||
pa_xfree(u->input);
|
||||
|
||||
pa_xfree(u->control);
|
||||
|
|
|
|||
|
|
@ -82,12 +82,14 @@ static int load_rules(struct userdata *u, const char *filename) {
|
|||
|
||||
pa_assert(u);
|
||||
|
||||
f = filename ?
|
||||
fopen(fn = pa_xstrdup(filename), "r") :
|
||||
pa_open_config_file(DEFAULT_MATCH_TABLE_FILE, DEFAULT_MATCH_TABLE_FILE_USER, NULL, &fn, "r");
|
||||
if (filename)
|
||||
f = fopen(fn = pa_xstrdup(filename), "r");
|
||||
else
|
||||
f = pa_open_config_file(DEFAULT_MATCH_TABLE_FILE, DEFAULT_MATCH_TABLE_FILE_USER, NULL, &fn);
|
||||
|
||||
if (!f) {
|
||||
pa_log("failed to open file '%s': %s", fn, pa_cstrerror(errno));
|
||||
pa_xfree(fn);
|
||||
pa_log("Failed to open file config file: %s", pa_cstrerror(errno));
|
||||
goto finish;
|
||||
}
|
||||
|
||||
|
|
@ -166,6 +168,7 @@ static void callback(pa_core *c, pa_subscription_event_type_t t, uint32_t idx, v
|
|||
struct userdata *u = userdata;
|
||||
pa_sink_input *si;
|
||||
struct rule *r;
|
||||
const char *n;
|
||||
|
||||
pa_assert(c);
|
||||
pa_assert(u);
|
||||
|
|
@ -176,13 +179,13 @@ static void callback(pa_core *c, pa_subscription_event_type_t t, uint32_t idx, v
|
|||
if (!(si = pa_idxset_get_by_index(c->sink_inputs, idx)))
|
||||
return;
|
||||
|
||||
if (!si->name)
|
||||
if (!(n = pa_proplist_gets(si->proplist, PA_PROP_MEDIA_NAME)))
|
||||
return;
|
||||
|
||||
for (r = u->rules; r; r = r->next) {
|
||||
if (!regexec(&r->regex, si->name, 0, NULL, 0)) {
|
||||
if (!regexec(&r->regex, n, 0, NULL, 0)) {
|
||||
pa_cvolume cv;
|
||||
pa_log_debug("changing volume of sink input '%s' to 0x%03x", si->name, r->volume);
|
||||
pa_log_debug("changing volume of sink input '%s' to 0x%03x", n, r->volume);
|
||||
pa_cvolume_set(&cv, si->sample_spec.channels, r->volume);
|
||||
pa_sink_input_set_volume(si, &cv);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@
|
|||
/***
|
||||
This file is part of PulseAudio.
|
||||
|
||||
Copyright 2004-2006 Lennart Poettering
|
||||
Copyright 2004-2008 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
|
||||
|
|
@ -64,6 +64,7 @@ PA_MODULE_USAGE(
|
|||
"description=<description for the sink>");
|
||||
|
||||
#define DEFAULT_SINK_NAME "null"
|
||||
#define MAX_LATENCY_USEC (PA_USEC_PER_SEC * 2)
|
||||
|
||||
struct userdata {
|
||||
pa_core *core;
|
||||
|
|
@ -76,7 +77,8 @@ struct userdata {
|
|||
|
||||
size_t block_size;
|
||||
|
||||
struct timeval timestamp;
|
||||
pa_usec_t block_usec;
|
||||
pa_usec_t timestamp;
|
||||
};
|
||||
|
||||
static const char* const valid_modargs[] = {
|
||||
|
|
@ -96,26 +98,95 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
|
|||
case PA_SINK_MESSAGE_SET_STATE:
|
||||
|
||||
if (PA_PTR_TO_UINT(data) == PA_SINK_RUNNING)
|
||||
pa_rtclock_get(&u->timestamp);
|
||||
u->timestamp = pa_rtclock_usec();
|
||||
|
||||
break;
|
||||
|
||||
case PA_SINK_MESSAGE_GET_LATENCY: {
|
||||
struct timeval now;
|
||||
pa_usec_t now;
|
||||
|
||||
pa_rtclock_get(&now);
|
||||
now = pa_rtclock_usec();
|
||||
*((pa_usec_t*) data) = u->timestamp > now ? u->timestamp - now : 0;
|
||||
|
||||
if (pa_timeval_cmp(&u->timestamp, &now) > 0)
|
||||
*((pa_usec_t*) data) = 0;
|
||||
else
|
||||
*((pa_usec_t*) data) = pa_timeval_diff(&u->timestamp, &now);
|
||||
break;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
return pa_sink_process_msg(o, code, data, offset, chunk);
|
||||
}
|
||||
|
||||
static void sink_update_requested_latency_cb(pa_sink *s) {
|
||||
struct userdata *u;
|
||||
|
||||
pa_sink_assert_ref(s);
|
||||
u = s->userdata;
|
||||
pa_assert(u);
|
||||
|
||||
u->block_usec = pa_sink_get_requested_latency_within_thread(s);
|
||||
}
|
||||
|
||||
static void process_rewind(struct userdata *u, pa_usec_t now) {
|
||||
size_t rewind_nbytes, in_buffer;
|
||||
pa_usec_t delay;
|
||||
|
||||
pa_assert(u);
|
||||
|
||||
/* Figure out how much we shall rewind and reset the counter */
|
||||
rewind_nbytes = u->sink->thread_info.rewind_nbytes;
|
||||
u->sink->thread_info.rewind_nbytes = 0;
|
||||
|
||||
pa_assert(rewind_nbytes > 0);
|
||||
pa_log_debug("Requested to rewind %lu bytes.", (unsigned long) rewind_nbytes);
|
||||
|
||||
if (u->timestamp <= now)
|
||||
return;
|
||||
|
||||
delay = u->timestamp - now;
|
||||
in_buffer = pa_usec_to_bytes(delay, &u->sink->sample_spec);
|
||||
|
||||
if (in_buffer <= 0)
|
||||
return;
|
||||
|
||||
if (rewind_nbytes > in_buffer)
|
||||
rewind_nbytes = in_buffer;
|
||||
|
||||
pa_sink_process_rewind(u->sink, rewind_nbytes);
|
||||
u->timestamp -= pa_bytes_to_usec(rewind_nbytes, &u->sink->sample_spec);
|
||||
|
||||
pa_log_debug("Rewound %lu bytes.", (unsigned long) rewind_nbytes);
|
||||
}
|
||||
|
||||
static void process_render(struct userdata *u, pa_usec_t now) {
|
||||
size_t nbytes;
|
||||
size_t ate = 0;
|
||||
|
||||
pa_assert(u);
|
||||
|
||||
/* This is the configured latency. Sink inputs connected to us
|
||||
might not have a single frame more than this value queued. Hence:
|
||||
at maximum read this many bytes from the sink inputs. */
|
||||
|
||||
nbytes = pa_usec_to_bytes(u->block_usec, &u->sink->sample_spec);
|
||||
|
||||
/* Fill the buffer up the the latency size */
|
||||
while (u->timestamp < now + u->block_usec) {
|
||||
pa_memchunk chunk;
|
||||
|
||||
pa_sink_render(u->sink, nbytes, &chunk);
|
||||
pa_memblock_unref(chunk.memblock);
|
||||
|
||||
pa_log_debug("Ate %lu bytes.", (unsigned long) chunk.length);
|
||||
u->timestamp += pa_bytes_to_usec(chunk.length, &u->sink->sample_spec);
|
||||
|
||||
ate += chunk.length;
|
||||
|
||||
if (ate >= nbytes)
|
||||
break;
|
||||
}
|
||||
|
||||
pa_log_debug("Ate in sum %lu bytes (of %lu)", (unsigned long) ate, (unsigned long) nbytes);
|
||||
}
|
||||
|
||||
static void thread_func(void *userdata) {
|
||||
struct userdata *u = userdata;
|
||||
|
||||
|
|
@ -126,28 +197,29 @@ static void thread_func(void *userdata) {
|
|||
pa_thread_mq_install(&u->thread_mq);
|
||||
pa_rtpoll_install(u->rtpoll);
|
||||
|
||||
pa_rtclock_get(&u->timestamp);
|
||||
u->timestamp = pa_rtclock_usec();
|
||||
|
||||
for (;;) {
|
||||
int ret;
|
||||
|
||||
/* Render some data and drop it immediately */
|
||||
if (u->sink->thread_info.state == PA_SINK_RUNNING) {
|
||||
struct timeval now;
|
||||
pa_usec_t now;
|
||||
|
||||
pa_rtclock_get(&now);
|
||||
now = pa_rtclock_usec();
|
||||
|
||||
if (pa_timeval_cmp(&u->timestamp, &now) <= 0) {
|
||||
pa_sink_skip(u->sink, u->block_size);
|
||||
pa_timeval_add(&u->timestamp, pa_bytes_to_usec(u->block_size, &u->sink->sample_spec));
|
||||
}
|
||||
if (u->sink->thread_info.rewind_nbytes > 0)
|
||||
process_rewind(u, now);
|
||||
|
||||
pa_rtpoll_set_timer_absolute(u->rtpoll, &u->timestamp);
|
||||
if (u->timestamp <= now)
|
||||
process_render(u, now);
|
||||
|
||||
pa_rtpoll_set_timer_absolute(u->rtpoll, u->timestamp);
|
||||
} else
|
||||
pa_rtpoll_set_timer_disabled(u->rtpoll);
|
||||
|
||||
/* Hmm, nothing to do. Let's sleep */
|
||||
if ((ret = pa_rtpoll_run(u->rtpoll, 1)) < 0)
|
||||
if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
|
||||
goto fail;
|
||||
|
||||
if (ret == 0)
|
||||
|
|
@ -169,6 +241,7 @@ int pa__init(pa_module*m) {
|
|||
pa_sample_spec ss;
|
||||
pa_channel_map map;
|
||||
pa_modargs *ma = NULL;
|
||||
pa_sink_new_data data;
|
||||
|
||||
pa_assert(m);
|
||||
|
||||
|
|
@ -187,27 +260,35 @@ int pa__init(pa_module*m) {
|
|||
u->core = m->core;
|
||||
u->module = m;
|
||||
m->userdata = u;
|
||||
pa_thread_mq_init(&u->thread_mq, m->core->mainloop);
|
||||
u->rtpoll = pa_rtpoll_new();
|
||||
pa_rtpoll_item_new_asyncmsgq(u->rtpoll, PA_RTPOLL_EARLY, u->thread_mq.inq);
|
||||
pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
|
||||
|
||||
if (!(u->sink = pa_sink_new(m->core, __FILE__, pa_modargs_get_value(ma, "sink_name", DEFAULT_SINK_NAME), 0, &ss, &map))) {
|
||||
pa_log("Failed to create sink.");
|
||||
pa_sink_new_data_init(&data);
|
||||
data.driver = __FILE__;
|
||||
data.module = m;
|
||||
pa_sink_new_data_set_name(&data, pa_modargs_get_value(ma, "sink_name", DEFAULT_SINK_NAME));
|
||||
pa_sink_new_data_set_sample_spec(&data, &ss);
|
||||
pa_sink_new_data_set_channel_map(&data, &map);
|
||||
pa_proplist_sets(data.proplist, PA_PROP_DEVICE_DESCRIPTION, pa_modargs_get_value(ma, "description", "Null Output"));
|
||||
|
||||
u->sink = pa_sink_new(m->core, &data, PA_SINK_LATENCY);
|
||||
pa_sink_new_data_done(&data);
|
||||
|
||||
if (!u->sink) {
|
||||
pa_log("Failed to create sink object.");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
u->sink->parent.process_msg = sink_process_msg;
|
||||
u->sink->update_requested_latency = sink_update_requested_latency_cb;
|
||||
u->sink->userdata = u;
|
||||
u->sink->flags = PA_SINK_LATENCY;
|
||||
|
||||
pa_sink_set_module(u->sink, m);
|
||||
pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
|
||||
pa_sink_set_rtpoll(u->sink, u->rtpoll);
|
||||
pa_sink_set_description(u->sink, pa_modargs_get_value(ma, "description", "NULL sink"));
|
||||
|
||||
u->block_size = pa_bytes_per_second(&ss) / 20; /* 50 ms */
|
||||
if (u->block_size <= 0)
|
||||
u->block_size = pa_frame_size(&ss);
|
||||
u->block_usec = u->sink->max_latency = MAX_LATENCY_USEC;
|
||||
|
||||
u->sink->thread_info.max_rewind = pa_usec_to_bytes(u->block_usec, &u->sink->sample_spec);
|
||||
|
||||
if (!(u->thread = pa_thread_new(thread_func, u))) {
|
||||
pa_log("Failed to create thread.");
|
||||
|
|
|
|||
|
|
@ -161,10 +161,10 @@ static void trigger(struct userdata *u, pa_bool_t quick) {
|
|||
|
||||
pa_log_debug("trigger");
|
||||
|
||||
if (u->source && PA_SOURCE_OPENED(u->source->thread_info.state))
|
||||
if (u->source && PA_SOURCE_IS_OPENED(u->source->thread_info.state))
|
||||
enable_bits |= PCM_ENABLE_INPUT;
|
||||
|
||||
if (u->sink && PA_SINK_OPENED(u->sink->thread_info.state))
|
||||
if (u->sink && PA_SINK_IS_OPENED(u->sink->thread_info.state))
|
||||
enable_bits |= PCM_ENABLE_OUTPUT;
|
||||
|
||||
pa_log_debug("trigger: %i", enable_bits);
|
||||
|
|
@ -202,7 +202,7 @@ static void trigger(struct userdata *u, pa_bool_t quick) {
|
|||
* register the fd as ready.
|
||||
*/
|
||||
|
||||
if (u->source && PA_SOURCE_OPENED(u->source->thread_info.state)) {
|
||||
if (u->source && PA_SOURCE_IS_OPENED(u->source->thread_info.state)) {
|
||||
uint8_t *buf = pa_xnew(uint8_t, u->in_fragment_size);
|
||||
pa_read(u->fd, buf, u->in_fragment_size, NULL);
|
||||
pa_xfree(buf);
|
||||
|
|
@ -641,7 +641,7 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
|
|||
switch ((pa_sink_state_t) PA_PTR_TO_UINT(data)) {
|
||||
|
||||
case PA_SINK_SUSPENDED:
|
||||
pa_assert(PA_SINK_OPENED(u->sink->thread_info.state));
|
||||
pa_assert(PA_SINK_IS_OPENED(u->sink->thread_info.state));
|
||||
|
||||
if (!u->source || u->source_suspended) {
|
||||
if (suspend(u) < 0)
|
||||
|
|
@ -658,7 +658,7 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
|
|||
|
||||
if (u->sink->thread_info.state == PA_SINK_INIT) {
|
||||
do_trigger = TRUE;
|
||||
quick = u->source && PA_SOURCE_OPENED(u->source->thread_info.state);
|
||||
quick = u->source && PA_SOURCE_IS_OPENED(u->source->thread_info.state);
|
||||
}
|
||||
|
||||
if (u->sink->thread_info.state == PA_SINK_SUSPENDED) {
|
||||
|
|
@ -721,7 +721,7 @@ static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t off
|
|||
|
||||
switch ((pa_source_state_t) PA_PTR_TO_UINT(data)) {
|
||||
case PA_SOURCE_SUSPENDED:
|
||||
pa_assert(PA_SOURCE_OPENED(u->source->thread_info.state));
|
||||
pa_assert(PA_SOURCE_IS_OPENED(u->source->thread_info.state));
|
||||
|
||||
if (!u->sink || u->sink_suspended) {
|
||||
if (suspend(u) < 0)
|
||||
|
|
@ -738,7 +738,7 @@ static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t off
|
|||
|
||||
if (u->source->thread_info.state == PA_SOURCE_INIT) {
|
||||
do_trigger = TRUE;
|
||||
quick = u->sink && PA_SINK_OPENED(u->sink->thread_info.state);
|
||||
quick = u->sink && PA_SINK_IS_OPENED(u->sink->thread_info.state);
|
||||
}
|
||||
|
||||
if (u->source->thread_info.state == PA_SOURCE_SUSPENDED) {
|
||||
|
|
@ -877,7 +877,7 @@ static void thread_func(void *userdata) {
|
|||
|
||||
/* Render some data and write it to the dsp */
|
||||
|
||||
if (u->sink && PA_SINK_OPENED(u->sink->thread_info.state) && ((revents & POLLOUT) || u->use_mmap || u->use_getospace)) {
|
||||
if (u->sink && PA_SINK_IS_OPENED(u->sink->thread_info.state) && ((revents & POLLOUT) || u->use_mmap || u->use_getospace)) {
|
||||
|
||||
if (u->use_mmap) {
|
||||
|
||||
|
|
@ -985,7 +985,7 @@ static void thread_func(void *userdata) {
|
|||
|
||||
/* Try to read some data and pass it on to the source driver. */
|
||||
|
||||
if (u->source && PA_SOURCE_OPENED(u->source->thread_info.state) && ((revents & POLLIN) || u->use_mmap || u->use_getispace)) {
|
||||
if (u->source && PA_SOURCE_IS_OPENED(u->source->thread_info.state) && ((revents & POLLIN) || u->use_mmap || u->use_getispace)) {
|
||||
|
||||
if (u->use_mmap) {
|
||||
|
||||
|
|
@ -1095,8 +1095,8 @@ static void thread_func(void *userdata) {
|
|||
|
||||
pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL);
|
||||
pollfd->events =
|
||||
((u->source && PA_SOURCE_OPENED(u->source->thread_info.state)) ? POLLIN : 0) |
|
||||
((u->sink && PA_SINK_OPENED(u->sink->thread_info.state)) ? POLLOUT : 0);
|
||||
((u->source && PA_SOURCE_IS_OPENED(u->source->thread_info.state)) ? POLLIN : 0) |
|
||||
((u->sink && PA_SINK_IS_OPENED(u->sink->thread_info.state)) ? POLLOUT : 0);
|
||||
}
|
||||
|
||||
/* Hmm, nothing to do. Let's sleep */
|
||||
|
|
@ -1143,9 +1143,11 @@ int pa__init(pa_module*m) {
|
|||
pa_sample_spec ss;
|
||||
pa_channel_map map;
|
||||
pa_modargs *ma = NULL;
|
||||
char hwdesc[64], *t;
|
||||
char hwdesc[64];
|
||||
const char *name;
|
||||
int namereg_fail;
|
||||
pa_bool_t namereg_fail;
|
||||
pa_sink_new_data sink_new_data;
|
||||
pa_source_new_data source_new_data;
|
||||
|
||||
pa_assert(m);
|
||||
|
||||
|
|
@ -1226,17 +1228,16 @@ int pa__init(pa_module*m) {
|
|||
m->userdata = u;
|
||||
u->fd = fd;
|
||||
u->mixer_fd = -1;
|
||||
u->use_getospace = u->use_getispace = 1;
|
||||
u->use_getodelay = 1;
|
||||
u->use_getospace = u->use_getispace = TRUE;
|
||||
u->use_getodelay = TRUE;
|
||||
u->mode = mode;
|
||||
u->frame_size = pa_frame_size(&ss);
|
||||
u->device_name = pa_xstrdup(dev);
|
||||
u->in_nfrags = u->out_nfrags = u->nfrags = nfrags;
|
||||
u->out_fragment_size = u->in_fragment_size = u->frag_size = frag_size;
|
||||
u->use_mmap = use_mmap;
|
||||
pa_thread_mq_init(&u->thread_mq, m->core->mainloop);
|
||||
u->rtpoll = pa_rtpoll_new();
|
||||
pa_rtpoll_item_new_asyncmsgq(u->rtpoll, PA_RTPOLL_EARLY, u->thread_mq.inq);
|
||||
pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
|
||||
u->rtpoll_item = NULL;
|
||||
build_pollfd(u);
|
||||
|
||||
|
|
@ -1244,14 +1245,14 @@ int pa__init(pa_module*m) {
|
|||
pa_log_info("Input -- %u fragments of size %u.", info.fragstotal, info.fragsize);
|
||||
u->in_fragment_size = info.fragsize;
|
||||
u->in_nfrags = info.fragstotal;
|
||||
u->use_getispace = 1;
|
||||
u->use_getispace = TRUE;
|
||||
}
|
||||
|
||||
if (ioctl(fd, SNDCTL_DSP_GETOSPACE, &info) >= 0) {
|
||||
pa_log_info("Output -- %u fragments of size %u.", info.fragstotal, info.fragsize);
|
||||
u->out_fragment_size = info.fragsize;
|
||||
u->out_nfrags = info.fragstotal;
|
||||
u->use_getospace = 1;
|
||||
u->use_getospace = TRUE;
|
||||
}
|
||||
|
||||
u->in_hwbuf_size = u->in_nfrags * u->in_fragment_size;
|
||||
|
|
@ -1263,21 +1264,37 @@ int pa__init(pa_module*m) {
|
|||
if (use_mmap) {
|
||||
if ((u->in_mmap = mmap(NULL, u->in_hwbuf_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
|
||||
pa_log_warn("mmap(PROT_READ) failed, reverting to non-mmap mode: %s", pa_cstrerror(errno));
|
||||
use_mmap = u->use_mmap = 0;
|
||||
use_mmap = u->use_mmap = FALSE;
|
||||
u->in_mmap = NULL;
|
||||
} else
|
||||
pa_log_debug("Successfully mmap()ed input buffer.");
|
||||
}
|
||||
|
||||
if ((name = pa_modargs_get_value(ma, "source_name", NULL)))
|
||||
namereg_fail = 1;
|
||||
namereg_fail = TRUE;
|
||||
else {
|
||||
name = name_buf = pa_sprintf_malloc("oss_input.%s", pa_path_get_filename(dev));
|
||||
namereg_fail = 0;
|
||||
namereg_fail = FALSE;
|
||||
}
|
||||
|
||||
u->source = pa_source_new(m->core, __FILE__, name, namereg_fail, &ss, &map);
|
||||
pa_source_new_data_init(&source_new_data);
|
||||
source_new_data.driver = __FILE__;
|
||||
source_new_data.module = m;
|
||||
pa_source_new_data_set_name(&source_new_data, name);
|
||||
source_new_data.namereg_fail = namereg_fail;
|
||||
pa_source_new_data_set_sample_spec(&source_new_data, &ss);
|
||||
pa_source_new_data_set_channel_map(&source_new_data, &map);
|
||||
pa_proplist_sets(source_new_data.proplist, PA_PROP_DEVICE_STRING, dev);
|
||||
pa_proplist_sets(source_new_data.proplist, PA_PROP_DEVICE_API, "oss");
|
||||
pa_proplist_sets(source_new_data.proplist, PA_PROP_DEVICE_DESCRIPTION, hwdesc[0] ? hwdesc : dev);
|
||||
pa_proplist_sets(source_new_data.proplist, PA_PROP_DEVICE_ACCESS_MODE, use_mmap ? "mmap" : "serial");
|
||||
pa_proplist_setf(source_new_data.proplist, PA_PROP_DEVICE_BUFFERING_BUFFER_SIZE, "%lu", (unsigned long) (u->in_hwbuf_size));
|
||||
pa_proplist_setf(source_new_data.proplist, PA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZE, "%lu", (unsigned long) (u->in_fragment_size));
|
||||
|
||||
u->source = pa_source_new(m->core, &source_new_data, PA_SOURCE_HARDWARE|PA_SOURCE_LATENCY);
|
||||
pa_source_new_data_done(&source_new_data);
|
||||
pa_xfree(name_buf);
|
||||
|
||||
if (!u->source) {
|
||||
pa_log("Failed to create source object");
|
||||
goto fail;
|
||||
|
|
@ -1286,18 +1303,8 @@ int pa__init(pa_module*m) {
|
|||
u->source->parent.process_msg = source_process_msg;
|
||||
u->source->userdata = u;
|
||||
|
||||
pa_source_set_module(u->source, m);
|
||||
pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
|
||||
pa_source_set_rtpoll(u->source, u->rtpoll);
|
||||
pa_source_set_description(u->source, t = pa_sprintf_malloc(
|
||||
"OSS PCM on %s%s%s%s%s",
|
||||
dev,
|
||||
hwdesc[0] ? " (" : "",
|
||||
hwdesc[0] ? hwdesc : "",
|
||||
hwdesc[0] ? ")" : "",
|
||||
use_mmap ? " via DMA" : ""));
|
||||
pa_xfree(t);
|
||||
u->source->flags = PA_SOURCE_HARDWARE|PA_SOURCE_LATENCY;
|
||||
u->source->refresh_volume = TRUE;
|
||||
|
||||
if (use_mmap)
|
||||
|
|
@ -1315,7 +1322,7 @@ int pa__init(pa_module*m) {
|
|||
goto go_on;
|
||||
} else {
|
||||
pa_log_warn("mmap(PROT_WRITE) failed, reverting to non-mmap mode: %s", pa_cstrerror(errno));
|
||||
u->use_mmap = (use_mmap = FALSE);
|
||||
u->use_mmap = use_mmap = FALSE;
|
||||
u->out_mmap = NULL;
|
||||
}
|
||||
} else {
|
||||
|
|
@ -1325,14 +1332,30 @@ int pa__init(pa_module*m) {
|
|||
}
|
||||
|
||||
if ((name = pa_modargs_get_value(ma, "sink_name", NULL)))
|
||||
namereg_fail = 1;
|
||||
namereg_fail = TRUE;
|
||||
else {
|
||||
name = name_buf = pa_sprintf_malloc("oss_output.%s", pa_path_get_filename(dev));
|
||||
namereg_fail = 0;
|
||||
namereg_fail = FALSE;
|
||||
}
|
||||
|
||||
u->sink = pa_sink_new(m->core, __FILE__, name, namereg_fail, &ss, &map);
|
||||
pa_sink_new_data_init(&sink_new_data);
|
||||
sink_new_data.driver = __FILE__;
|
||||
sink_new_data.module = m;
|
||||
pa_sink_new_data_set_name(&sink_new_data, name);
|
||||
sink_new_data.namereg_fail = namereg_fail;
|
||||
pa_sink_new_data_set_sample_spec(&sink_new_data, &ss);
|
||||
pa_sink_new_data_set_channel_map(&sink_new_data, &map);
|
||||
pa_proplist_sets(sink_new_data.proplist, PA_PROP_DEVICE_STRING, dev);
|
||||
pa_proplist_sets(sink_new_data.proplist, PA_PROP_DEVICE_API, "oss");
|
||||
pa_proplist_sets(sink_new_data.proplist, PA_PROP_DEVICE_DESCRIPTION, hwdesc[0] ? hwdesc : dev);
|
||||
pa_proplist_sets(sink_new_data.proplist, PA_PROP_DEVICE_ACCESS_MODE, use_mmap ? "mmap" : "serial");
|
||||
pa_proplist_setf(sink_new_data.proplist, PA_PROP_DEVICE_BUFFERING_BUFFER_SIZE, "%lu", (unsigned long) (u->out_hwbuf_size));
|
||||
pa_proplist_setf(sink_new_data.proplist, PA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZE, "%lu", (unsigned long) (u->out_fragment_size));
|
||||
|
||||
u->sink = pa_sink_new(m->core, &sink_new_data, PA_SINK_HARDWARE|PA_SINK_LATENCY);
|
||||
pa_sink_new_data_done(&sink_new_data);
|
||||
pa_xfree(name_buf);
|
||||
|
||||
if (!u->sink) {
|
||||
pa_log("Failed to create sink object");
|
||||
goto fail;
|
||||
|
|
@ -1341,18 +1364,8 @@ int pa__init(pa_module*m) {
|
|||
u->sink->parent.process_msg = sink_process_msg;
|
||||
u->sink->userdata = u;
|
||||
|
||||
pa_sink_set_module(u->sink, m);
|
||||
pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
|
||||
pa_sink_set_rtpoll(u->sink, u->rtpoll);
|
||||
pa_sink_set_description(u->sink, t = pa_sprintf_malloc(
|
||||
"OSS PCM on %s%s%s%s%s",
|
||||
dev,
|
||||
hwdesc[0] ? " (" : "",
|
||||
hwdesc[0] ? hwdesc : "",
|
||||
hwdesc[0] ? ")" : "",
|
||||
use_mmap ? " via DMA" : ""));
|
||||
pa_xfree(t);
|
||||
u->sink->flags = PA_SINK_HARDWARE|PA_SINK_LATENCY;
|
||||
u->sink->refresh_volume = TRUE;
|
||||
|
||||
if (use_mmap)
|
||||
|
|
@ -1360,7 +1373,7 @@ int pa__init(pa_module*m) {
|
|||
}
|
||||
|
||||
if ((u->mixer_fd = pa_oss_open_mixer_for_device(u->device_name)) >= 0) {
|
||||
int do_close = 1;
|
||||
pa_bool_t do_close = TRUE;
|
||||
u->mixer_devmask = 0;
|
||||
|
||||
if (ioctl(fd, SOUND_MIXER_READ_DEVMASK, &u->mixer_devmask) < 0)
|
||||
|
|
@ -1372,7 +1385,7 @@ int pa__init(pa_module*m) {
|
|||
u->sink->flags |= PA_SINK_HW_VOLUME_CTRL;
|
||||
u->sink->get_volume = sink_get_volume;
|
||||
u->sink->set_volume = sink_set_volume;
|
||||
do_close = 0;
|
||||
do_close = FALSE;
|
||||
}
|
||||
|
||||
if (u->source && (u->mixer_devmask & (SOUND_MASK_RECLEV|SOUND_MASK_IGAIN))) {
|
||||
|
|
@ -1380,7 +1393,7 @@ int pa__init(pa_module*m) {
|
|||
u->source->flags |= PA_SOURCE_HW_VOLUME_CTRL;
|
||||
u->source->get_volume = source_get_volume;
|
||||
u->source->set_volume = source_set_volume;
|
||||
do_close = 0;
|
||||
do_close = FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1402,10 +1415,25 @@ go_on:
|
|||
}
|
||||
|
||||
/* Read mixer settings */
|
||||
if (u->sink && u->sink->get_volume)
|
||||
sink_get_volume(u->sink);
|
||||
if (u->source && u->source->get_volume)
|
||||
source_get_volume(u->source);
|
||||
if (u->sink) {
|
||||
if (sink_new_data.volume_is_set) {
|
||||
if (u->sink->set_volume)
|
||||
u->sink->set_volume(u->sink);
|
||||
} else {
|
||||
if (u->sink->get_volume)
|
||||
u->sink->get_volume(u->sink);
|
||||
}
|
||||
}
|
||||
|
||||
if (u->source) {
|
||||
if (source_new_data.volume_is_set) {
|
||||
if (u->source->set_volume)
|
||||
u->source->set_volume(u->source);
|
||||
} else {
|
||||
if (u->source->get_volume)
|
||||
u->source->get_volume(u->source);
|
||||
}
|
||||
}
|
||||
|
||||
if (u->sink)
|
||||
pa_sink_put(u->sink);
|
||||
|
|
|
|||
|
|
@ -62,7 +62,7 @@ PA_MODULE_USAGE(
|
|||
"rate=<sample rate>"
|
||||
"channel_map=<channel map>");
|
||||
|
||||
#define DEFAULT_FILE_NAME "/tmp/music.output"
|
||||
#define DEFAULT_FILE_NAME "fifo_output"
|
||||
#define DEFAULT_SINK_NAME "fifo_output"
|
||||
|
||||
struct userdata {
|
||||
|
|
@ -80,6 +80,8 @@ struct userdata {
|
|||
pa_memchunk memchunk;
|
||||
|
||||
pa_rtpoll_item *rtpoll_item;
|
||||
|
||||
int write_type;
|
||||
};
|
||||
|
||||
static const char* const valid_modargs[] = {
|
||||
|
|
@ -109,16 +111,64 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
|
|||
n += u->memchunk.length;
|
||||
|
||||
*((pa_usec_t*) data) = pa_bytes_to_usec(n, &u->sink->sample_spec);
|
||||
break;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
return pa_sink_process_msg(o, code, data, offset, chunk);
|
||||
}
|
||||
|
||||
static void process_rewind(struct userdata *u) {
|
||||
pa_assert(u);
|
||||
|
||||
pa_log_debug("Rewind requested but not supported by pipe sink. Ignoring.");
|
||||
u->sink->thread_info.rewind_nbytes = 0;
|
||||
}
|
||||
|
||||
static int process_render(struct userdata *u) {
|
||||
pa_assert(u);
|
||||
|
||||
if (u->memchunk.length <= 0)
|
||||
pa_sink_render(u->sink, PIPE_BUF, &u->memchunk);
|
||||
|
||||
pa_assert(u->memchunk.length > 0);
|
||||
|
||||
for (;;) {
|
||||
ssize_t l;
|
||||
void *p;
|
||||
|
||||
p = pa_memblock_acquire(u->memchunk.memblock);
|
||||
l = pa_write(u->fd, (uint8_t*) p + u->memchunk.index, u->memchunk.length, &u->write_type);
|
||||
pa_memblock_release(u->memchunk.memblock);
|
||||
|
||||
pa_assert(l != 0);
|
||||
|
||||
if (l < 0) {
|
||||
|
||||
if (errno == EINTR)
|
||||
continue;
|
||||
else if (errno != EAGAIN) {
|
||||
pa_log("Failed to write data to FIFO: %s", pa_cstrerror(errno));
|
||||
return -1;
|
||||
}
|
||||
|
||||
} else {
|
||||
|
||||
u->memchunk.index += l;
|
||||
u->memchunk.length -= l;
|
||||
|
||||
if (u->memchunk.length <= 0) {
|
||||
pa_memblock_unref(u->memchunk.memblock);
|
||||
pa_memchunk_reset(&u->memchunk);
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
static void thread_func(void *userdata) {
|
||||
struct userdata *u = userdata;
|
||||
int write_type = 0;
|
||||
|
||||
pa_assert(u);
|
||||
|
||||
|
|
@ -134,39 +184,14 @@ static void thread_func(void *userdata) {
|
|||
pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL);
|
||||
|
||||
/* Render some data and write it to the fifo */
|
||||
if (u->sink->thread_info.state == PA_SINK_RUNNING && pollfd->revents) {
|
||||
ssize_t l;
|
||||
void *p;
|
||||
if (u->sink->thread_info.state == PA_SINK_RUNNING) {
|
||||
|
||||
if (u->memchunk.length <= 0)
|
||||
pa_sink_render(u->sink, PIPE_BUF, &u->memchunk);
|
||||
if (u->sink->thread_info.rewind_nbytes > 0)
|
||||
process_rewind(u);
|
||||
|
||||
pa_assert(u->memchunk.length > 0);
|
||||
|
||||
p = pa_memblock_acquire(u->memchunk.memblock);
|
||||
l = pa_write(u->fd, (uint8_t*) p + u->memchunk.index, u->memchunk.length, &write_type);
|
||||
pa_memblock_release(u->memchunk.memblock);
|
||||
|
||||
pa_assert(l != 0);
|
||||
|
||||
if (l < 0) {
|
||||
|
||||
if (errno == EINTR)
|
||||
continue;
|
||||
else if (errno != EAGAIN) {
|
||||
pa_log("Failed to write data to FIFO: %s", pa_cstrerror(errno));
|
||||
if (pollfd->revents) {
|
||||
if (process_render(u) < 0)
|
||||
goto fail;
|
||||
}
|
||||
|
||||
} else {
|
||||
|
||||
u->memchunk.index += l;
|
||||
u->memchunk.length -= l;
|
||||
|
||||
if (u->memchunk.length <= 0) {
|
||||
pa_memblock_unref(u->memchunk.memblock);
|
||||
pa_memchunk_reset(&u->memchunk);
|
||||
}
|
||||
|
||||
pollfd->revents = 0;
|
||||
}
|
||||
|
|
@ -205,8 +230,8 @@ int pa__init(pa_module*m) {
|
|||
pa_sample_spec ss;
|
||||
pa_channel_map map;
|
||||
pa_modargs *ma;
|
||||
char *t;
|
||||
struct pollfd *pollfd;
|
||||
pa_sink_new_data data;
|
||||
|
||||
pa_assert(m);
|
||||
|
||||
|
|
@ -226,11 +251,11 @@ int pa__init(pa_module*m) {
|
|||
u->module = m;
|
||||
m->userdata = u;
|
||||
pa_memchunk_reset(&u->memchunk);
|
||||
pa_thread_mq_init(&u->thread_mq, m->core->mainloop);
|
||||
u->rtpoll = pa_rtpoll_new();
|
||||
pa_rtpoll_item_new_asyncmsgq(u->rtpoll, PA_RTPOLL_EARLY, u->thread_mq.inq);
|
||||
pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
|
||||
u->write_type = 0;
|
||||
|
||||
u->filename = pa_xstrdup(pa_modargs_get_value(ma, "file", DEFAULT_FILE_NAME));
|
||||
u->filename = pa_runtime_path(pa_modargs_get_value(ma, "file", DEFAULT_FILE_NAME));
|
||||
|
||||
mkfifo(u->filename, 0666);
|
||||
if ((u->fd = open(u->filename, O_RDWR|O_NOCTTY)) < 0) {
|
||||
|
|
@ -251,20 +276,28 @@ int pa__init(pa_module*m) {
|
|||
goto fail;
|
||||
}
|
||||
|
||||
if (!(u->sink = pa_sink_new(m->core, __FILE__, pa_modargs_get_value(ma, "sink_name", DEFAULT_SINK_NAME), 0, &ss, &map))) {
|
||||
pa_sink_new_data_init(&data);
|
||||
data.driver = __FILE__;
|
||||
data.module = m;
|
||||
pa_sink_new_data_set_name(&data, pa_modargs_get_value(ma, "sink_name", DEFAULT_SINK_NAME));
|
||||
pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, u->filename);
|
||||
pa_proplist_setf(data.proplist, PA_PROP_DEVICE_DESCRIPTION, "Unix FIFO sink %s", u->filename);
|
||||
pa_sink_new_data_set_sample_spec(&data, &ss);
|
||||
pa_sink_new_data_set_channel_map(&data, &map);
|
||||
|
||||
u->sink = pa_sink_new(m->core, &data, PA_SINK_LATENCY);
|
||||
pa_sink_new_data_done(&data);
|
||||
|
||||
if (!u->sink) {
|
||||
pa_log("Failed to create sink.");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
u->sink->parent.process_msg = sink_process_msg;
|
||||
u->sink->userdata = u;
|
||||
u->sink->flags = PA_SINK_LATENCY;
|
||||
|
||||
pa_sink_set_module(u->sink, m);
|
||||
pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
|
||||
pa_sink_set_rtpoll(u->sink, u->rtpoll);
|
||||
pa_sink_set_description(u->sink, t = pa_sprintf_malloc("Unix FIFO sink '%s'", u->filename));
|
||||
pa_xfree(t);
|
||||
|
||||
u->rtpoll_item = pa_rtpoll_item_new(u->rtpoll, PA_RTPOLL_NEVER, 1);
|
||||
pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL);
|
||||
|
|
|
|||
|
|
@ -153,13 +153,14 @@ static void thread_func(void *userdata) {
|
|||
/* Hmm, nothing to do. Let's sleep */
|
||||
pollfd->events = u->source->thread_info.state == PA_SOURCE_RUNNING ? POLLIN : 0;
|
||||
|
||||
if ((ret = pa_rtpoll_run(u->rtpoll, 1)) < 0)
|
||||
if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
|
||||
goto fail;
|
||||
|
||||
if (ret == 0)
|
||||
goto finish;
|
||||
|
||||
pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL);
|
||||
|
||||
if (pollfd->revents & ~POLLIN) {
|
||||
pa_log("FIFO shutdown.");
|
||||
goto fail;
|
||||
|
|
@ -182,8 +183,8 @@ int pa__init(pa_module*m) {
|
|||
pa_sample_spec ss;
|
||||
pa_channel_map map;
|
||||
pa_modargs *ma;
|
||||
char *t;
|
||||
struct pollfd *pollfd;
|
||||
pa_source_new_data data;
|
||||
|
||||
pa_assert(m);
|
||||
|
||||
|
|
@ -203,11 +204,10 @@ int pa__init(pa_module*m) {
|
|||
u->module = m;
|
||||
m->userdata = u;
|
||||
pa_memchunk_reset(&u->memchunk);
|
||||
pa_thread_mq_init(&u->thread_mq, m->core->mainloop);
|
||||
u->rtpoll = pa_rtpoll_new();
|
||||
pa_rtpoll_item_new_asyncmsgq(u->rtpoll, PA_RTPOLL_EARLY, u->thread_mq.inq);
|
||||
pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
|
||||
|
||||
u->filename = pa_xstrdup(pa_modargs_get_value(ma, "file", DEFAULT_FILE_NAME));
|
||||
u->filename = pa_runtime_path(pa_modargs_get_value(ma, "file", DEFAULT_FILE_NAME));
|
||||
|
||||
mkfifo(u->filename, 0666);
|
||||
if ((u->fd = open(u->filename, O_RDWR|O_NOCTTY)) < 0) {
|
||||
|
|
@ -228,19 +228,27 @@ int pa__init(pa_module*m) {
|
|||
goto fail;
|
||||
}
|
||||
|
||||
if (!(u->source = pa_source_new(m->core, __FILE__, pa_modargs_get_value(ma, "source_name", DEFAULT_SOURCE_NAME), 0, &ss, &map))) {
|
||||
pa_source_new_data_init(&data);
|
||||
data.driver = __FILE__;
|
||||
data.module = m;
|
||||
pa_source_new_data_set_name(&data, pa_modargs_get_value(ma, "source_name", DEFAULT_SOURCE_NAME));
|
||||
pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, u->filename);
|
||||
pa_proplist_setf(data.proplist, PA_PROP_DEVICE_DESCRIPTION, "Unix FIFO source %s", u->filename);
|
||||
pa_source_new_data_set_sample_spec(&data, &ss);
|
||||
pa_source_new_data_set_channel_map(&data, &map);
|
||||
|
||||
u->source = pa_source_new(m->core, &data, 0);
|
||||
pa_source_new_data_done(&data);
|
||||
|
||||
if (!u->source) {
|
||||
pa_log("Failed to create source.");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
u->source->userdata = u;
|
||||
u->source->flags = 0;
|
||||
|
||||
pa_source_set_module(u->source, m);
|
||||
pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
|
||||
pa_source_set_rtpoll(u->source, u->rtpoll);
|
||||
pa_source_set_description(u->source, t = pa_sprintf_malloc("Unix FIFO source '%s'", u->filename));
|
||||
pa_xfree(t);
|
||||
|
||||
u->rtpoll_item = pa_rtpoll_item_new(u->rtpoll, PA_RTPOLL_NEVER, 1);
|
||||
pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL);
|
||||
|
|
|
|||
|
|
@ -215,15 +215,6 @@ int pa__init(pa_module*m) {
|
|||
#else
|
||||
pa_socket_server *s;
|
||||
int r;
|
||||
char tmp[PATH_MAX];
|
||||
|
||||
#if defined(USE_PROTOCOL_ESOUND)
|
||||
#if defined(USE_PER_USER_ESOUND_SOCKET)
|
||||
char esdsocketpath[PATH_MAX];
|
||||
#else
|
||||
const char esdsocketpath[] = "/tmp/.esd/socket";
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
|
||||
pa_assert(m);
|
||||
|
|
@ -255,27 +246,28 @@ int pa__init(pa_module*m) {
|
|||
goto fail;
|
||||
|
||||
if (s_ipv4)
|
||||
if (!(u->protocol_ipv4 = protocol_new(m->core, s_ipv4, m, ma)))
|
||||
pa_socket_server_unref(s_ipv4);
|
||||
|
||||
u->protocol_ipv4 = protocol_new(m->core, s_ipv4, m, ma);
|
||||
if (s_ipv6)
|
||||
if (!(u->protocol_ipv6 = protocol_new(m->core, s_ipv6, m, ma)))
|
||||
pa_socket_server_unref(s_ipv6);
|
||||
u->protocol_ipv6 = protocol_new(m->core, s_ipv6, m, ma);
|
||||
|
||||
if (!u->protocol_ipv4 && !u->protocol_ipv6)
|
||||
goto fail;
|
||||
|
||||
if (s_ipv6)
|
||||
pa_socket_server_unref(s_ipv6);
|
||||
if (s_ipv6)
|
||||
pa_socket_server_unref(s_ipv4);
|
||||
|
||||
#else
|
||||
|
||||
#if defined(USE_PROTOCOL_ESOUND)
|
||||
|
||||
#if defined(USE_PER_USER_ESOUND_SOCKET)
|
||||
snprintf(esdsocketpath, sizeof(esdsocketpath), "/tmp/.esd-%lu/socket", (unsigned long) getuid());
|
||||
u->socket_path = pa_sprintf_malloc("/tmp/.esd-%lu/socket", (unsigned long) getuid());
|
||||
#else
|
||||
u->socket_path = pa_xstrdup("/tmp/.esd/socket");
|
||||
#endif
|
||||
|
||||
pa_runtime_path(pa_modargs_get_value(ma, "socket", esdsocketpath), tmp, sizeof(tmp));
|
||||
u->socket_path = pa_xstrdup(tmp);
|
||||
|
||||
/* This socket doesn't reside in our own runtime dir but in
|
||||
* /tmp/.esd/, hence we have to create the dir first */
|
||||
|
||||
|
|
@ -285,24 +277,26 @@ int pa__init(pa_module*m) {
|
|||
}
|
||||
|
||||
#else
|
||||
pa_runtime_path(pa_modargs_get_value(ma, "socket", UNIX_SOCKET), tmp, sizeof(tmp));
|
||||
u->socket_path = pa_xstrdup(tmp);
|
||||
#endif
|
||||
|
||||
if ((r = pa_unix_socket_remove_stale(tmp)) < 0) {
|
||||
pa_log("Failed to remove stale UNIX socket '%s': %s", tmp, pa_cstrerror(errno));
|
||||
if (!(u->socket_path = pa_runtime_path(pa_modargs_get_value(ma, "socket", UNIX_SOCKET)))) {
|
||||
pa_log("Failed to generate socket path.");
|
||||
goto fail;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (r)
|
||||
pa_log("Removed stale UNIX socket '%s'.", tmp);
|
||||
if ((r = pa_unix_socket_remove_stale(u->socket_path)) < 0) {
|
||||
pa_log("Failed to remove stale UNIX socket '%s': %s", u->socket_path, pa_cstrerror(errno));
|
||||
goto fail;
|
||||
} else if (r > 0)
|
||||
pa_log_info("Removed stale UNIX socket '%s'.", u->socket_path);
|
||||
|
||||
if (!(s = pa_socket_server_new_unix(m->core->mainloop, tmp)))
|
||||
if (!(s = pa_socket_server_new_unix(m->core->mainloop, u->socket_path)))
|
||||
goto fail;
|
||||
|
||||
if (!(u->protocol_unix = protocol_new(m->core, s, m, ma)))
|
||||
goto fail;
|
||||
|
||||
pa_socket_server_unref(s);
|
||||
|
||||
#endif
|
||||
|
||||
m->userdata = u;
|
||||
|
|
@ -325,24 +319,22 @@ fail:
|
|||
#else
|
||||
if (u->protocol_unix)
|
||||
protocol_free(u->protocol_unix);
|
||||
|
||||
if (u->socket_path)
|
||||
pa_xfree(u->socket_path);
|
||||
pa_xfree(u->socket_path);
|
||||
#endif
|
||||
|
||||
pa_xfree(u);
|
||||
} else {
|
||||
#if defined(USE_TCP_SOCKETS)
|
||||
if (s_ipv4)
|
||||
pa_socket_server_unref(s_ipv4);
|
||||
if (s_ipv6)
|
||||
pa_socket_server_unref(s_ipv6);
|
||||
#else
|
||||
if (s)
|
||||
pa_socket_server_unref(s);
|
||||
#endif
|
||||
}
|
||||
|
||||
#if defined(USE_TCP_SOCKETS)
|
||||
if (s_ipv4)
|
||||
pa_socket_server_unref(s_ipv4);
|
||||
if (s_ipv6)
|
||||
pa_socket_server_unref(s_ipv6);
|
||||
#else
|
||||
if (s)
|
||||
pa_socket_server_unref(s);
|
||||
#endif
|
||||
|
||||
goto finish;
|
||||
}
|
||||
|
||||
|
|
@ -362,7 +354,7 @@ void pa__done(pa_module*m) {
|
|||
if (u->protocol_unix)
|
||||
protocol_free(u->protocol_unix);
|
||||
|
||||
#if defined(USE_PROTOCOL_ESOUND)
|
||||
#if defined(USE_PROTOCOL_ESOUND) && !defined(USE_PER_USER_ESOUND_SOCKET)
|
||||
if (u->socket_path) {
|
||||
char *p = pa_parent_dir(u->socket_path);
|
||||
rmdir(p);
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@
|
|||
/***
|
||||
This file is part of PulseAudio.
|
||||
|
||||
Copyright 2004-2006 Lennart Poettering
|
||||
Copyright 2004-2008 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
|
||||
|
|
@ -59,8 +59,6 @@ struct userdata {
|
|||
|
||||
pa_sink *sink, *master;
|
||||
pa_sink_input *sink_input;
|
||||
|
||||
pa_memchunk memchunk;
|
||||
};
|
||||
|
||||
static const char* const valid_modargs[] = {
|
||||
|
|
@ -83,10 +81,14 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
|
|||
case PA_SINK_MESSAGE_GET_LATENCY: {
|
||||
pa_usec_t usec = 0;
|
||||
|
||||
/* Get the latency of the master sink */
|
||||
if (PA_MSGOBJECT(u->master)->process_msg(PA_MSGOBJECT(u->master), PA_SINK_MESSAGE_GET_LATENCY, &usec, 0, NULL) < 0)
|
||||
usec = 0;
|
||||
|
||||
*((pa_usec_t*) data) = usec + pa_bytes_to_usec(u->memchunk.length, &u->sink->sample_spec);
|
||||
/* Add the latency internal to our sink input on top */
|
||||
usec += pa_bytes_to_usec(pa_memblockq_get_length(u->sink_input->thread_info.render_memblockq), &u->master->sample_spec);
|
||||
|
||||
*((pa_usec_t*) data) = usec;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
|
@ -101,67 +103,86 @@ static int sink_set_state(pa_sink *s, pa_sink_state_t state) {
|
|||
pa_sink_assert_ref(s);
|
||||
pa_assert_se(u = s->userdata);
|
||||
|
||||
if (PA_SINK_LINKED(state) && u->sink_input && PA_SINK_INPUT_LINKED(pa_sink_input_get_state(u->sink_input)))
|
||||
if (PA_SINK_IS_LINKED(state) &&
|
||||
u->sink_input &&
|
||||
PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u->sink_input)))
|
||||
|
||||
pa_sink_input_cork(u->sink_input, state == PA_SINK_SUSPENDED);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Called from I/O thread context */
|
||||
static int sink_input_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
|
||||
struct userdata *u = PA_SINK_INPUT(o)->userdata;
|
||||
static void sink_request_rewind(pa_sink *s) {
|
||||
struct userdata *u;
|
||||
|
||||
switch (code) {
|
||||
case PA_SINK_INPUT_MESSAGE_GET_LATENCY:
|
||||
*((pa_usec_t*) data) = pa_bytes_to_usec(u->memchunk.length, &u->sink_input->sample_spec);
|
||||
pa_sink_assert_ref(s);
|
||||
pa_assert_se(u = s->userdata);
|
||||
|
||||
/* Fall through, the default handler will add in the extra
|
||||
* latency added by the resampler */
|
||||
break;
|
||||
}
|
||||
|
||||
return pa_sink_input_process_msg(o, code, data, offset, chunk);
|
||||
pa_sink_input_request_rewind(u->sink_input, s->thread_info.rewind_nbytes, TRUE, FALSE);
|
||||
}
|
||||
|
||||
/* Called from I/O thread context */
|
||||
static int sink_input_peek_cb(pa_sink_input *i, size_t length, pa_memchunk *chunk) {
|
||||
static void sink_update_requested_latency(pa_sink *s) {
|
||||
struct userdata *u;
|
||||
|
||||
pa_sink_assert_ref(s);
|
||||
pa_assert_se(u = s->userdata);
|
||||
|
||||
/* Just hand this one over to the master sink */
|
||||
pa_sink_input_set_requested_latency_within_thread(
|
||||
u->sink_input,
|
||||
pa_sink_get_requested_latency_within_thread(s));
|
||||
}
|
||||
|
||||
/* Called from I/O thread context */
|
||||
static int sink_input_pop_cb(pa_sink_input *i, size_t nbytes, pa_memchunk *chunk) {
|
||||
struct userdata *u;
|
||||
|
||||
pa_sink_input_assert_ref(i);
|
||||
pa_assert(chunk);
|
||||
pa_assert_se(u = i->userdata);
|
||||
|
||||
if (!u->memchunk.memblock)
|
||||
pa_sink_render(u->sink, length, &u->memchunk);
|
||||
if (!u->sink || !PA_SINK_IS_OPENED(u->sink->thread_info.state))
|
||||
return -1;
|
||||
|
||||
pa_assert(u->memchunk.memblock);
|
||||
*chunk = u->memchunk;
|
||||
pa_memblock_ref(chunk->memblock);
|
||||
pa_sink_render(u->sink, nbytes, chunk);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Called from I/O thread context */
|
||||
static void sink_input_drop_cb(pa_sink_input *i, size_t length) {
|
||||
static void sink_input_process_rewind_cb(pa_sink_input *i, size_t nbytes) {
|
||||
struct userdata *u;
|
||||
|
||||
pa_sink_input_assert_ref(i);
|
||||
pa_assert_se(u = i->userdata);
|
||||
pa_assert(length > 0);
|
||||
pa_assert(nbytes > 0);
|
||||
|
||||
if (u->memchunk.memblock) {
|
||||
if (!u->sink || !PA_SINK_IS_OPENED(u->sink->thread_info.state))
|
||||
return;
|
||||
|
||||
if (length < u->memchunk.length) {
|
||||
u->memchunk.index += length;
|
||||
u->memchunk.length -= length;
|
||||
return;
|
||||
}
|
||||
if (u->sink->thread_info.rewind_nbytes > 0) {
|
||||
size_t amount;
|
||||
|
||||
pa_memblock_unref(u->memchunk.memblock);
|
||||
length -= u->memchunk.length;
|
||||
pa_memchunk_reset(&u->memchunk);
|
||||
amount = PA_MIN(u->sink->thread_info.rewind_nbytes, nbytes);
|
||||
u->sink->thread_info.rewind_nbytes = 0;
|
||||
|
||||
if (amount > 0)
|
||||
pa_sink_process_rewind(u->sink, amount);
|
||||
}
|
||||
}
|
||||
|
||||
if (length > 0)
|
||||
pa_sink_skip(u->sink, length);
|
||||
/* Called from I/O thread context */
|
||||
static void sink_input_update_max_rewind_cb(pa_sink_input *i, size_t nbytes) {
|
||||
struct userdata *u;
|
||||
|
||||
pa_sink_input_assert_ref(i);
|
||||
pa_assert_se(u = i->userdata);
|
||||
|
||||
if (!u->sink || !PA_SINK_IS_OPENED(u->sink->thread_info.state))
|
||||
return;
|
||||
|
||||
pa_sink_set_max_rewind(u->sink, nbytes);
|
||||
}
|
||||
|
||||
/* Called from I/O thread context */
|
||||
|
|
@ -171,7 +192,12 @@ static void sink_input_detach_cb(pa_sink_input *i) {
|
|||
pa_sink_input_assert_ref(i);
|
||||
pa_assert_se(u = i->userdata);
|
||||
|
||||
if (!u->sink || !PA_SINK_IS_OPENED(u->sink->thread_info.state))
|
||||
return;
|
||||
|
||||
pa_sink_detach_within_thread(u->sink);
|
||||
pa_sink_set_asyncmsgq(u->sink, NULL);
|
||||
pa_sink_set_rtpoll(u->sink, NULL);
|
||||
}
|
||||
|
||||
/* Called from I/O thread context */
|
||||
|
|
@ -181,10 +207,15 @@ static void sink_input_attach_cb(pa_sink_input *i) {
|
|||
pa_sink_input_assert_ref(i);
|
||||
pa_assert_se(u = i->userdata);
|
||||
|
||||
if (!u->sink || !PA_SINK_IS_OPENED(u->sink->thread_info.state))
|
||||
return;
|
||||
|
||||
pa_sink_set_asyncmsgq(u->sink, i->sink->asyncmsgq);
|
||||
pa_sink_set_rtpoll(u->sink, i->sink->rtpoll);
|
||||
|
||||
pa_sink_attach_within_thread(u->sink);
|
||||
|
||||
u->sink->max_latency = u->master->max_latency;
|
||||
u->sink->min_latency = u->master->min_latency;
|
||||
}
|
||||
|
||||
/* Called from main context */
|
||||
|
|
@ -194,26 +225,42 @@ static void sink_input_kill_cb(pa_sink_input *i) {
|
|||
pa_sink_input_assert_ref(i);
|
||||
pa_assert_se(u = i->userdata);
|
||||
|
||||
pa_sink_unlink(u->sink);
|
||||
pa_sink_input_unlink(u->sink_input);
|
||||
|
||||
pa_sink_unref(u->sink);
|
||||
u->sink = NULL;
|
||||
pa_sink_input_unref(u->sink_input);
|
||||
u->sink_input = NULL;
|
||||
|
||||
pa_sink_unlink(u->sink);
|
||||
pa_sink_unref(u->sink);
|
||||
u->sink = NULL;
|
||||
|
||||
pa_module_unload_request(u->module);
|
||||
}
|
||||
|
||||
/* Called from IO thread context */
|
||||
static void sink_input_state_change_cb(pa_sink_input *i, pa_sink_input_state_t state) {
|
||||
struct userdata *u;
|
||||
|
||||
pa_sink_input_assert_ref(i);
|
||||
pa_assert_se(u = i->userdata);
|
||||
|
||||
/* If we are added for the first time, ask for a rewinding so that
|
||||
* we are heard right-away. */
|
||||
if (PA_SINK_INPUT_IS_LINKED(state) &&
|
||||
i->thread_info.state == PA_SINK_INPUT_INIT) {
|
||||
pa_log_debug("Requesting rewind due to state change.");
|
||||
pa_sink_input_request_rewind(i, 0, FALSE, TRUE);
|
||||
}
|
||||
}
|
||||
|
||||
int pa__init(pa_module*m) {
|
||||
struct userdata *u;
|
||||
pa_sample_spec ss;
|
||||
pa_channel_map sink_map, stream_map;
|
||||
pa_modargs *ma;
|
||||
char *t;
|
||||
const char *k;
|
||||
pa_sink *master;
|
||||
pa_sink_input_new_data data;
|
||||
char *default_sink_name = NULL;
|
||||
pa_sink_input_new_data sink_input_data;
|
||||
pa_sink_new_data sink_data;
|
||||
|
||||
pa_assert(m);
|
||||
|
||||
|
|
@ -245,57 +292,76 @@ int pa__init(pa_module*m) {
|
|||
goto fail;
|
||||
}
|
||||
|
||||
if (pa_channel_map_equal(&stream_map, &master->channel_map))
|
||||
pa_log_warn("No remapping configured, proceeding nonetheless!");
|
||||
|
||||
u = pa_xnew0(struct userdata, 1);
|
||||
u->core = m->core;
|
||||
u->module = m;
|
||||
m->userdata = u;
|
||||
u->master = master;
|
||||
pa_memchunk_reset(&u->memchunk);
|
||||
|
||||
default_sink_name = pa_sprintf_malloc("%s.remapped", master->name);
|
||||
u->sink = NULL;
|
||||
u->sink_input = NULL;
|
||||
|
||||
/* Create sink */
|
||||
if (!(u->sink = pa_sink_new(m->core, __FILE__, pa_modargs_get_value(ma, "sink_name", default_sink_name), 0, &ss, &sink_map))) {
|
||||
pa_sink_new_data_init(&sink_data);
|
||||
sink_data.driver = __FILE__;
|
||||
sink_data.module = m;
|
||||
if (!(sink_data.name = pa_xstrdup(pa_modargs_get_value(ma, "sink_name", NULL))))
|
||||
sink_data.name = pa_sprintf_malloc("%s.remapped", master->name);
|
||||
pa_sink_new_data_set_sample_spec(&sink_data, &ss);
|
||||
pa_sink_new_data_set_channel_map(&sink_data, &sink_map);
|
||||
k = pa_proplist_gets(master->proplist, PA_PROP_DEVICE_DESCRIPTION);
|
||||
pa_proplist_setf(sink_data.proplist, PA_PROP_DEVICE_DESCRIPTION, "Remapped %s", k ? k : master->name);
|
||||
pa_proplist_sets(sink_data.proplist, PA_PROP_DEVICE_MASTER_DEVICE, master->name);
|
||||
pa_proplist_sets(sink_data.proplist, PA_PROP_DEVICE_CLASS, "filter");
|
||||
|
||||
u->sink = pa_sink_new(m->core, &sink_data, PA_SINK_LATENCY);
|
||||
pa_sink_new_data_done(&sink_data);
|
||||
|
||||
if (!u->sink) {
|
||||
pa_log("Failed to create sink.");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
u->sink->parent.process_msg = sink_process_msg;
|
||||
u->sink->set_state = sink_set_state;
|
||||
u->sink->update_requested_latency = sink_update_requested_latency;
|
||||
u->sink->request_rewind = sink_request_rewind;
|
||||
u->sink->userdata = u;
|
||||
u->sink->flags = PA_SINK_LATENCY;
|
||||
|
||||
pa_sink_set_module(u->sink, m);
|
||||
pa_sink_set_description(u->sink, t = pa_sprintf_malloc("Remapped %s", master->description));
|
||||
pa_xfree(t);
|
||||
pa_sink_set_asyncmsgq(u->sink, master->asyncmsgq);
|
||||
pa_sink_set_rtpoll(u->sink, master->rtpoll);
|
||||
|
||||
/* Create sink input */
|
||||
pa_sink_input_new_data_init(&data);
|
||||
data.sink = u->master;
|
||||
data.driver = __FILE__;
|
||||
data.name = "Remapped Stream";
|
||||
pa_sink_input_new_data_set_sample_spec(&data, &ss);
|
||||
pa_sink_input_new_data_set_channel_map(&data, &stream_map);
|
||||
data.module = m;
|
||||
pa_sink_input_new_data_init(&sink_input_data);
|
||||
sink_input_data.driver = __FILE__;
|
||||
sink_input_data.module = m;
|
||||
sink_input_data.sink = u->master;
|
||||
pa_proplist_sets(sink_input_data.proplist, PA_PROP_MEDIA_NAME, "Remapped Stream");
|
||||
pa_proplist_sets(sink_input_data.proplist, PA_PROP_MEDIA_ROLE, "filter");
|
||||
pa_sink_input_new_data_set_sample_spec(&sink_input_data, &ss);
|
||||
pa_sink_input_new_data_set_channel_map(&sink_input_data, &stream_map);
|
||||
|
||||
if (!(u->sink_input = pa_sink_input_new(m->core, &data, PA_SINK_INPUT_DONT_MOVE)))
|
||||
u->sink_input = pa_sink_input_new(m->core, &sink_input_data, PA_SINK_INPUT_DONT_MOVE);
|
||||
pa_sink_input_new_data_done(&sink_input_data);
|
||||
|
||||
if (!u->sink_input)
|
||||
goto fail;
|
||||
|
||||
u->sink_input->parent.process_msg = sink_input_process_msg;
|
||||
u->sink_input->peek = sink_input_peek_cb;
|
||||
u->sink_input->drop = sink_input_drop_cb;
|
||||
u->sink_input->pop = sink_input_pop_cb;
|
||||
u->sink_input->process_rewind = sink_input_process_rewind_cb;
|
||||
u->sink_input->update_max_rewind = sink_input_update_max_rewind_cb;
|
||||
u->sink_input->kill = sink_input_kill_cb;
|
||||
u->sink_input->attach = sink_input_attach_cb;
|
||||
u->sink_input->detach = sink_input_detach_cb;
|
||||
u->sink_input->state_change = sink_input_state_change_cb;
|
||||
u->sink_input->userdata = u;
|
||||
|
||||
pa_sink_put(u->sink);
|
||||
pa_sink_input_put(u->sink_input);
|
||||
|
||||
pa_modargs_free(ma);
|
||||
pa_xfree(default_sink_name);
|
||||
|
||||
return 0;
|
||||
|
||||
|
|
@ -305,8 +371,6 @@ fail:
|
|||
|
||||
pa__done(m);
|
||||
|
||||
pa_xfree(default_sink_name);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
|
@ -318,18 +382,15 @@ void pa__done(pa_module*m) {
|
|||
if (!(u = m->userdata))
|
||||
return;
|
||||
|
||||
if (u->sink_input) {
|
||||
pa_sink_input_unlink(u->sink_input);
|
||||
pa_sink_input_unref(u->sink_input);
|
||||
}
|
||||
|
||||
if (u->sink) {
|
||||
pa_sink_unlink(u->sink);
|
||||
pa_sink_unref(u->sink);
|
||||
}
|
||||
|
||||
if (u->memchunk.memblock)
|
||||
pa_memblock_unref(u->memchunk.memblock);
|
||||
if (u->sink_input) {
|
||||
pa_sink_input_unlink(u->sink_input);
|
||||
pa_sink_input_unref(u->sink_input);
|
||||
}
|
||||
|
||||
pa_xfree(u);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -75,12 +75,12 @@ static pa_hook_result_t sink_hook_callback(pa_core *c, pa_sink *sink, void* user
|
|||
}
|
||||
|
||||
while ((i = pa_idxset_first(sink->inputs, NULL))) {
|
||||
if (pa_sink_input_move_to(i, target, 1) < 0) {
|
||||
pa_log_warn("Failed to move sink input %u \"%s\" to %s.", i->index, i->name, target->name);
|
||||
if (pa_sink_input_move_to(i, target) < 0) {
|
||||
pa_log_warn("Failed to move sink input %u \"%s\" to %s.", i->index, pa_proplist_gets(i->proplist, PA_PROP_APPLICATION_NAME), target->name);
|
||||
return PA_HOOK_OK;
|
||||
}
|
||||
|
||||
pa_log_info("Sucessfully moved sink input %u \"%s\" to %s.", i->index, i->name, target->name);
|
||||
pa_log_info("Sucessfully moved sink input %u \"%s\" to %s.", i->index, pa_proplist_gets(i->proplist, PA_PROP_APPLICATION_NAME), target->name);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -116,11 +116,11 @@ static pa_hook_result_t source_hook_callback(pa_core *c, pa_source *source, void
|
|||
|
||||
while ((o = pa_idxset_first(source->outputs, NULL))) {
|
||||
if (pa_source_output_move_to(o, target) < 0) {
|
||||
pa_log_warn("Failed to move source output %u \"%s\" to %s.", o->index, o->name, target->name);
|
||||
pa_log_warn("Failed to move source output %u \"%s\" to %s.", o->index, pa_proplist_gets(o->proplist, PA_PROP_APPLICATION_NAME), target->name);
|
||||
return PA_HOOK_OK;
|
||||
}
|
||||
|
||||
pa_log_info("Sucessfully moved source output %u \"%s\" to %s.", o->index, o->name, target->name);
|
||||
pa_log_info("Sucessfully moved source output %u \"%s\" to %s.", o->index, pa_proplist_gets(o->proplist, PA_PROP_APPLICATION_NAME), target->name);
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -59,44 +59,43 @@ static const char* const valid_modargs[] = {
|
|||
NULL,
|
||||
};
|
||||
|
||||
static int sink_input_peek_cb(pa_sink_input *i, size_t length, pa_memchunk *chunk) {
|
||||
static int sink_input_pop_cb(pa_sink_input *i, size_t nbytes, pa_memchunk *chunk) {
|
||||
struct userdata *u;
|
||||
|
||||
pa_assert(i);
|
||||
u = i->userdata;
|
||||
pa_assert(u);
|
||||
pa_sink_input_assert_ref(i);
|
||||
pa_assert_se(u = i->userdata);
|
||||
pa_assert(chunk);
|
||||
|
||||
chunk->memblock = pa_memblock_ref(u->memblock);
|
||||
chunk->index = u->peek_index;
|
||||
chunk->length = pa_memblock_get_length(u->memblock) - u->peek_index;
|
||||
chunk->index = u->peek_index;
|
||||
|
||||
u->peek_index = 0;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void sink_input_drop_cb(pa_sink_input *i, size_t length) {
|
||||
struct userdata *u;
|
||||
static void sink_input_process_rewind_cb(pa_sink_input *i, size_t nbytes) {
|
||||
size_t l;
|
||||
struct userdata *u;
|
||||
|
||||
pa_assert(i);
|
||||
u = i->userdata;
|
||||
pa_assert(u);
|
||||
pa_assert(length > 0);
|
||||
|
||||
u->peek_index += length;
|
||||
pa_sink_input_assert_ref(i);
|
||||
pa_assert_se(u = i->userdata);
|
||||
|
||||
l = pa_memblock_get_length(u->memblock);
|
||||
nbytes %= l;
|
||||
|
||||
while (u->peek_index >= l)
|
||||
u->peek_index -= l;
|
||||
if (u->peek_index >= nbytes)
|
||||
u->peek_index -= nbytes;
|
||||
else
|
||||
u->peek_index = l + u->peek_index - nbytes;
|
||||
}
|
||||
|
||||
static void sink_input_kill_cb(pa_sink_input *i) {
|
||||
struct userdata *u;
|
||||
|
||||
pa_assert(i);
|
||||
u = i->userdata;
|
||||
pa_assert(u);
|
||||
pa_sink_input_assert_ref(i);
|
||||
pa_assert_se(u = i->userdata);
|
||||
|
||||
pa_sink_input_unlink(u->sink_input);
|
||||
pa_sink_input_unref(u->sink_input);
|
||||
|
|
@ -105,6 +104,20 @@ static void sink_input_kill_cb(pa_sink_input *i) {
|
|||
pa_module_unload_request(u->module);
|
||||
}
|
||||
|
||||
/* Called from IO thread context */
|
||||
static void sink_input_state_change_cb(pa_sink_input *i, pa_sink_input_state_t state) {
|
||||
struct userdata *u;
|
||||
|
||||
pa_sink_input_assert_ref(i);
|
||||
pa_assert_se(u = i->userdata);
|
||||
|
||||
/* If we are added for the first time, ask for a rewinding so that
|
||||
* we are heard right-away. */
|
||||
if (PA_SINK_INPUT_IS_LINKED(state) &&
|
||||
i->thread_info.state == PA_SINK_INPUT_INIT)
|
||||
pa_sink_input_request_rewind(i, 0, FALSE, TRUE);
|
||||
}
|
||||
|
||||
static void calc_sine(float *f, size_t l, float freq) {
|
||||
size_t i;
|
||||
|
||||
|
|
@ -120,7 +133,6 @@ int pa__init(pa_module*m) {
|
|||
pa_sink *sink;
|
||||
pa_sample_spec ss;
|
||||
uint32_t frequency;
|
||||
char t[256];
|
||||
void *p;
|
||||
pa_sink_input_new_data data;
|
||||
|
||||
|
|
@ -156,21 +168,25 @@ int pa__init(pa_module*m) {
|
|||
calc_sine(p, pa_memblock_get_length(u->memblock), frequency);
|
||||
pa_memblock_release(u->memblock);
|
||||
|
||||
pa_snprintf(t, sizeof(t), "Sine Generator at %u Hz", frequency);
|
||||
|
||||
pa_sink_input_new_data_init(&data);
|
||||
data.sink = sink;
|
||||
data.driver = __FILE__;
|
||||
data.name = t;
|
||||
pa_proplist_setf(data.proplist, PA_PROP_MEDIA_NAME, "%u Hz Sine", frequency);
|
||||
pa_proplist_sets(data.proplist, PA_PROP_MEDIA_ROLE, "abstract");
|
||||
pa_proplist_setf(data.proplist, "sine.hz", "%u", frequency);
|
||||
pa_sink_input_new_data_set_sample_spec(&data, &ss);
|
||||
data.module = m;
|
||||
|
||||
if (!(u->sink_input = pa_sink_input_new(m->core, &data, 0)))
|
||||
u->sink_input = pa_sink_input_new(m->core, &data, 0);
|
||||
pa_sink_input_new_data_done(&data);
|
||||
|
||||
if (!u->sink_input)
|
||||
goto fail;
|
||||
|
||||
u->sink_input->peek = sink_input_peek_cb;
|
||||
u->sink_input->drop = sink_input_drop_cb;
|
||||
u->sink_input->pop = sink_input_pop_cb;
|
||||
u->sink_input->process_rewind = sink_input_process_rewind_cb;
|
||||
u->sink_input->kill = sink_input_kill_cb;
|
||||
u->sink_input->state_change = sink_input_state_change_cb;
|
||||
u->sink_input->userdata = u;
|
||||
|
||||
pa_sink_input_put(u->sink_input);
|
||||
|
|
|
|||
|
|
@ -317,7 +317,7 @@ static pa_hook_result_t device_state_changed_hook_cb(pa_core *c, pa_object *o, s
|
|||
|
||||
if (pa_sink_used_by(s) <= 0) {
|
||||
|
||||
if (PA_SINK_OPENED(state))
|
||||
if (PA_SINK_IS_OPENED(state))
|
||||
restart(d);
|
||||
|
||||
}
|
||||
|
|
@ -328,7 +328,7 @@ static pa_hook_result_t device_state_changed_hook_cb(pa_core *c, pa_object *o, s
|
|||
|
||||
if (pa_source_used_by(s) <= 0) {
|
||||
|
||||
if (PA_SOURCE_OPENED(state))
|
||||
if (PA_SOURCE_IS_OPENED(state))
|
||||
restart(d);
|
||||
}
|
||||
}
|
||||
|
|
@ -367,8 +367,8 @@ int pa__init(pa_module*m) {
|
|||
for (source = pa_idxset_first(m->core->sources, &idx); source; source = pa_idxset_next(m->core->sources, &idx))
|
||||
device_new_hook_cb(m->core, PA_OBJECT(source), u);
|
||||
|
||||
u->sink_new_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_NEW_POST], (pa_hook_cb_t) device_new_hook_cb, u);
|
||||
u->source_new_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_NEW_POST], (pa_hook_cb_t) device_new_hook_cb, u);
|
||||
u->sink_new_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_PUT], (pa_hook_cb_t) device_new_hook_cb, u);
|
||||
u->source_new_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_PUT], (pa_hook_cb_t) device_new_hook_cb, u);
|
||||
u->sink_unlink_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_UNLINK_POST], (pa_hook_cb_t) device_unlink_hook_cb, u);
|
||||
u->source_unlink_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_UNLINK_POST], (pa_hook_cb_t) device_unlink_hook_cb, u);
|
||||
u->sink_state_changed_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_STATE_CHANGED], (pa_hook_cb_t) device_state_changed_hook_cb, u);
|
||||
|
|
|
|||
|
|
@ -303,7 +303,7 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
|
|||
|
||||
/* First, change the state, because otherwide pa_sink_render() would fail */
|
||||
if ((r = pa_sink_process_msg(o, code, data, offset, chunk)) >= 0)
|
||||
if (PA_SINK_OPENED((pa_sink_state_t) PA_PTR_TO_UINT(data)))
|
||||
if (PA_SINK_IS_OPENED((pa_sink_state_t) PA_PTR_TO_UINT(data)))
|
||||
send_data(u);
|
||||
|
||||
return r;
|
||||
|
|
@ -314,7 +314,7 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
|
|||
pa_assert(offset > 0);
|
||||
u->requested_bytes += (size_t) offset;
|
||||
|
||||
if (PA_SINK_OPENED(u->sink->thread_info.state))
|
||||
if (PA_SINK_IS_OPENED(u->sink->thread_info.state))
|
||||
send_data(u);
|
||||
|
||||
return 0;
|
||||
|
|
@ -343,7 +343,7 @@ static int sink_set_state(pa_sink *s, pa_sink_state_t state) {
|
|||
switch ((pa_sink_state_t) state) {
|
||||
|
||||
case PA_SINK_SUSPENDED:
|
||||
pa_assert(PA_SINK_OPENED(s->state));
|
||||
pa_assert(PA_SINK_IS_OPENED(s->state));
|
||||
stream_cork(u, TRUE);
|
||||
break;
|
||||
|
||||
|
|
@ -369,7 +369,7 @@ static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t off
|
|||
switch (code) {
|
||||
case SOURCE_MESSAGE_POST:
|
||||
|
||||
if (PA_SOURCE_OPENED(u->source->thread_info.state))
|
||||
if (PA_SOURCE_IS_OPENED(u->source->thread_info.state))
|
||||
pa_source_post(u->source, chunk);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -385,7 +385,7 @@ static int source_set_state(pa_source *s, pa_source_state_t state) {
|
|||
switch ((pa_source_state_t) state) {
|
||||
|
||||
case PA_SOURCE_SUSPENDED:
|
||||
pa_assert(PA_SOURCE_OPENED(s->state));
|
||||
pa_assert(PA_SOURCE_IS_OPENED(s->state));
|
||||
stream_cork(u, TRUE);
|
||||
break;
|
||||
|
||||
|
|
@ -577,29 +577,29 @@ static void timeout_callback(pa_mainloop_api *m, pa_time_event*e, PA_GCC_UNUSED
|
|||
}
|
||||
|
||||
#ifdef TUNNEL_SINK
|
||||
static pa_usec_t sink_get_latency(pa_sink *s) {
|
||||
pa_usec_t t, c;
|
||||
struct userdata *u = s->userdata;
|
||||
/* static pa_usec_t sink_get_latency(pa_sink *s) { */
|
||||
/* pa_usec_t t, c; */
|
||||
/* struct userdata *u = s->userdata; */
|
||||
|
||||
pa_sink_assert_ref(s);
|
||||
/* pa_sink_assert_ref(s); */
|
||||
|
||||
c = pa_bytes_to_usec(u->counter, &s->sample_spec);
|
||||
t = pa_smoother_get(u->smoother, pa_rtclock_usec());
|
||||
/* c = pa_bytes_to_usec(u->counter, &s->sample_spec); */
|
||||
/* t = pa_smoother_get(u->smoother, pa_rtclock_usec()); */
|
||||
|
||||
return c > t ? c - t : 0;
|
||||
}
|
||||
/* return c > t ? c - t : 0; */
|
||||
/* } */
|
||||
#else
|
||||
static pa_usec_t source_get_latency(pa_source *s) {
|
||||
pa_usec_t t, c;
|
||||
struct userdata *u = s->userdata;
|
||||
/* static pa_usec_t source_get_latency(pa_source *s) { */
|
||||
/* pa_usec_t t, c; */
|
||||
/* struct userdata *u = s->userdata; */
|
||||
|
||||
pa_source_assert_ref(s);
|
||||
/* pa_source_assert_ref(s); */
|
||||
|
||||
c = pa_bytes_to_usec(u->counter, &s->sample_spec);
|
||||
t = pa_smoother_get(u->smoother, pa_rtclock_usec());
|
||||
/* c = pa_bytes_to_usec(u->counter, &s->sample_spec); */
|
||||
/* t = pa_smoother_get(u->smoother, pa_rtclock_usec()); */
|
||||
|
||||
return t > c ? t - c : 0;
|
||||
}
|
||||
/* return t > c ? t - c : 0; */
|
||||
/* } */
|
||||
#endif
|
||||
|
||||
static void update_description(struct userdata *u) {
|
||||
|
|
@ -1066,7 +1066,7 @@ static void setup_complete_callback(pa_pdispatch *pd, uint32_t command, uint32_t
|
|||
pa_tagstruct_putu32(reply, PA_INVALID_INDEX);
|
||||
pa_tagstruct_puts(reply, u->sink_name);
|
||||
pa_tagstruct_putu32(reply, u->maxlength);
|
||||
pa_tagstruct_put_boolean(reply, !PA_SINK_OPENED(pa_sink_get_state(u->sink)));
|
||||
pa_tagstruct_put_boolean(reply, !PA_SINK_IS_OPENED(pa_sink_get_state(u->sink)));
|
||||
pa_tagstruct_putu32(reply, u->tlength);
|
||||
pa_tagstruct_putu32(reply, u->prebuf);
|
||||
pa_tagstruct_putu32(reply, u->minreq);
|
||||
|
|
@ -1082,7 +1082,7 @@ static void setup_complete_callback(pa_pdispatch *pd, uint32_t command, uint32_t
|
|||
pa_tagstruct_putu32(reply, PA_INVALID_INDEX);
|
||||
pa_tagstruct_puts(reply, u->source_name);
|
||||
pa_tagstruct_putu32(reply, u->maxlength);
|
||||
pa_tagstruct_put_boolean(reply, !PA_SOURCE_OPENED(pa_source_get_state(u->source)));
|
||||
pa_tagstruct_put_boolean(reply, !PA_SOURCE_IS_OPENED(pa_source_get_state(u->source)));
|
||||
pa_tagstruct_putu32(reply, u->fragsize);
|
||||
#endif
|
||||
|
||||
|
|
@ -1294,6 +1294,11 @@ int pa__init(pa_module*m) {
|
|||
pa_sample_spec ss;
|
||||
pa_channel_map map;
|
||||
char *t, *dn = NULL;
|
||||
#ifdef TUNNEL_SINK
|
||||
pa_sink_new_data data;
|
||||
#else
|
||||
pa_source_new_data data;
|
||||
#endif
|
||||
|
||||
pa_assert(m);
|
||||
|
||||
|
|
@ -1318,15 +1323,14 @@ int pa__init(pa_module*m) {
|
|||
u->source_name = pa_xstrdup(pa_modargs_get_value(ma, "source", NULL));;
|
||||
u->source = NULL;
|
||||
#endif
|
||||
u->smoother = pa_smoother_new(PA_USEC_PER_SEC, PA_USEC_PER_SEC*2, TRUE);
|
||||
u->smoother = pa_smoother_new(PA_USEC_PER_SEC, PA_USEC_PER_SEC*2, TRUE, 10);
|
||||
u->ctag = 1;
|
||||
u->device_index = u->channel = PA_INVALID_INDEX;
|
||||
u->auth_cookie_in_property = FALSE;
|
||||
u->time_event = NULL;
|
||||
|
||||
pa_thread_mq_init(&u->thread_mq, m->core->mainloop);
|
||||
u->rtpoll = pa_rtpoll_new();
|
||||
pa_rtpoll_item_new_asyncmsgq(u->rtpoll, PA_RTPOLL_EARLY, u->thread_mq.inq);
|
||||
pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
|
||||
|
||||
if (load_key(u, pa_modargs_get_value(ma, "cookie", NULL)) < 0)
|
||||
goto fail;
|
||||
|
|
@ -1354,7 +1358,18 @@ int pa__init(pa_module*m) {
|
|||
if (!(dn = pa_xstrdup(pa_modargs_get_value(ma, "sink_name", NULL))))
|
||||
dn = pa_sprintf_malloc("tunnel.%s", u->server_name);
|
||||
|
||||
if (!(u->sink = pa_sink_new(m->core, __FILE__, dn, 1, &ss, &map))) {
|
||||
pa_sink_new_data_init(&data);
|
||||
data.driver = __FILE__;
|
||||
data.module = m;
|
||||
data.namereg_fail = TRUE;
|
||||
pa_sink_new_data_set_name(&data, dn);
|
||||
pa_sink_new_data_set_sample_spec(&data, &ss);
|
||||
pa_sink_new_data_set_channel_map(&data, &map);
|
||||
|
||||
u->sink = pa_sink_new(m->core, &data, PA_SINK_NETWORK|PA_SINK_LATENCY|PA_SINK_HW_VOLUME_CTRL);
|
||||
pa_sink_new_data_done(&data);
|
||||
|
||||
if (!u->sink) {
|
||||
pa_log("Failed to create sink.");
|
||||
goto fail;
|
||||
}
|
||||
|
|
@ -1362,14 +1377,12 @@ int pa__init(pa_module*m) {
|
|||
u->sink->parent.process_msg = sink_process_msg;
|
||||
u->sink->userdata = u;
|
||||
u->sink->set_state = sink_set_state;
|
||||
u->sink->get_latency = sink_get_latency;
|
||||
/* u->sink->get_latency = sink_get_latency; */
|
||||
u->sink->get_volume = sink_get_volume;
|
||||
u->sink->get_mute = sink_get_mute;
|
||||
u->sink->set_volume = sink_set_volume;
|
||||
u->sink->set_mute = sink_set_mute;
|
||||
u->sink->flags = PA_SINK_NETWORK|PA_SINK_LATENCY|PA_SINK_HW_VOLUME_CTRL;
|
||||
|
||||
pa_sink_set_module(u->sink, m);
|
||||
pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
|
||||
pa_sink_set_rtpoll(u->sink, u->rtpoll);
|
||||
pa_sink_set_description(u->sink, t = pa_sprintf_malloc("%s%s%s", u->sink_name ? u->sink_name : "", u->sink_name ? " on " : "", u->server_name));
|
||||
|
|
@ -1380,7 +1393,18 @@ int pa__init(pa_module*m) {
|
|||
if (!(dn = pa_xstrdup(pa_modargs_get_value(ma, "source_name", NULL))))
|
||||
dn = pa_sprintf_malloc("tunnel.%s", u->server_name);
|
||||
|
||||
if (!(u->source = pa_source_new(m->core, __FILE__, dn, 1, &ss, &map))) {
|
||||
pa_source_new_data_init(&data);
|
||||
data.driver = __FILE__;
|
||||
data.module = m;
|
||||
data.namereg_fail = TRUE;
|
||||
pa_source_new_data_set_name(&data, dn);
|
||||
pa_source_new_data_set_sample_spec(&data, &ss);
|
||||
pa_source_new_data_set_channel_map(&data, &map);
|
||||
|
||||
u->source = pa_source_new(m->core, &data, PA_SOURCE_NETWORK|PA_SOURCE_LATENCY);
|
||||
pa_source_new_data_done(&data);
|
||||
|
||||
if (!u->source) {
|
||||
pa_log("Failed to create source.");
|
||||
goto fail;
|
||||
}
|
||||
|
|
@ -1388,10 +1412,8 @@ int pa__init(pa_module*m) {
|
|||
u->source->parent.process_msg = source_process_msg;
|
||||
u->source->userdata = u;
|
||||
u->source->set_state = source_set_state;
|
||||
u->source->get_latency = source_get_latency;
|
||||
u->source->flags = PA_SOURCE_NETWORK|PA_SOURCE_LATENCY;
|
||||
/* u->source->get_latency = source_get_latency; */
|
||||
|
||||
pa_source_set_module(u->source, m);
|
||||
pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
|
||||
pa_source_set_rtpoll(u->source, u->rtpoll);
|
||||
pa_source_set_description(u->source, t = pa_sprintf_malloc("%s%s%s", u->source_name ? u->source_name : "", u->source_name ? " on " : "", u->server_name));
|
||||
|
|
|
|||
|
|
@ -115,7 +115,7 @@ static pa_cvolume* parse_volume(const char *s, pa_cvolume *v) {
|
|||
|
||||
k = strtol(p, &p, 0);
|
||||
|
||||
if (k < PA_VOLUME_MUTED)
|
||||
if (k < (long) PA_VOLUME_MUTED)
|
||||
return NULL;
|
||||
|
||||
v->values[i] = (pa_volume_t) k;
|
||||
|
|
@ -134,16 +134,12 @@ static int load_rules(struct userdata *u) {
|
|||
char buf_name[256], buf_volume[256], buf_sink[256], buf_source[256];
|
||||
char *ln = buf_name;
|
||||
|
||||
f = u->table_file ?
|
||||
fopen(u->table_file, "r") :
|
||||
pa_open_config_file(NULL, DEFAULT_VOLUME_TABLE_FILE, NULL, &u->table_file, "r");
|
||||
|
||||
if (!f) {
|
||||
if (!(f = fopen(u->table_file, "r"))) {
|
||||
if (errno == ENOENT) {
|
||||
pa_log_info("starting with empty ruleset.");
|
||||
pa_log_info("Starting with empty ruleset.");
|
||||
ret = 0;
|
||||
} else
|
||||
pa_log("failed to open file '%s': %s", u->table_file, pa_cstrerror(errno));
|
||||
pa_log("Failed to open file '%s': %s", u->table_file, pa_cstrerror(errno));
|
||||
|
||||
goto finish;
|
||||
}
|
||||
|
|
@ -236,11 +232,7 @@ static int save_rules(struct userdata *u) {
|
|||
|
||||
pa_log_info("Saving rules...");
|
||||
|
||||
f = u->table_file ?
|
||||
fopen(u->table_file, "w") :
|
||||
pa_open_config_file(NULL, DEFAULT_VOLUME_TABLE_FILE, NULL, &u->table_file, "w");
|
||||
|
||||
if (!f) {
|
||||
if (!(f = fopen(u->table_file, "w"))) {
|
||||
pa_log("Failed to open file '%s': %s", u->table_file, pa_cstrerror(errno));
|
||||
goto finish;
|
||||
}
|
||||
|
|
@ -280,10 +272,10 @@ finish:
|
|||
static char* client_name(pa_client *c) {
|
||||
char *t, *e;
|
||||
|
||||
if (!c->name || !c->driver)
|
||||
if (!pa_proplist_gets(c->proplist, PA_PROP_APPLICATION_NAME) || !c->driver)
|
||||
return NULL;
|
||||
|
||||
t = pa_sprintf_malloc("%s$%s", c->driver, c->name);
|
||||
t = pa_sprintf_malloc("%s$%s", c->driver, pa_proplist_gets(c->proplist, PA_PROP_APPLICATION_NAME));
|
||||
t[strcspn(t, "\n\r#")] = 0;
|
||||
|
||||
if (!*t) {
|
||||
|
|
@ -496,7 +488,7 @@ int pa__init(pa_module*m) {
|
|||
u = pa_xnew(struct userdata, 1);
|
||||
u->core = m->core;
|
||||
u->hashmap = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
|
||||
u->table_file = pa_xstrdup(pa_modargs_get_value(ma, "table", NULL));
|
||||
u->table_file = pa_runtime_path(pa_modargs_get_value(ma, "table", DEFAULT_VOLUME_TABLE_FILE));
|
||||
u->modified = FALSE;
|
||||
u->subscription = NULL;
|
||||
u->sink_input_new_hook_slot = u->sink_input_fixate_hook_slot = u->source_output_new_hook_slot = NULL;
|
||||
|
|
|
|||
|
|
@ -81,7 +81,7 @@ static int x11_event_callback(pa_x11_wrapper *w, XEvent *e, void *userdata) {
|
|||
|
||||
bne = (XkbBellNotifyEvent*) e;
|
||||
|
||||
if (pa_scache_play_item_by_name(u->core, u->scache_item, u->sink_name, (bne->percent*PA_VOLUME_NORM)/100, 1) < 0) {
|
||||
if (pa_scache_play_item_by_name(u->core, u->scache_item, u->sink_name, TRUE, (bne->percent*PA_VOLUME_NORM)/100, NULL, NULL) < 0) {
|
||||
pa_log_info("Ringing bell failed, reverting to X11 device bell.");
|
||||
XkbForceDeviceBell(pa_x11_wrapper_get_display(w), bne->device, bne->bell_class, bne->bell_id, bne->percent);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -115,7 +115,7 @@ static void get_service_data(struct service *s, pa_sample_spec *ret_ss, pa_chann
|
|||
*ret_ss = sink->sample_spec;
|
||||
*ret_map = sink->channel_map;
|
||||
*ret_name = sink->name;
|
||||
*ret_description = sink->description;
|
||||
*ret_description = pa_strnull(pa_proplist_gets(sink->proplist, PA_PROP_DEVICE_DESCRIPTION));
|
||||
*ret_subtype = sink->flags & PA_SINK_HARDWARE ? SUBTYPE_HARDWARE : SUBTYPE_VIRTUAL;
|
||||
|
||||
} else if (pa_source_isinstance(s->device)) {
|
||||
|
|
@ -124,7 +124,7 @@ static void get_service_data(struct service *s, pa_sample_spec *ret_ss, pa_chann
|
|||
*ret_ss = source->sample_spec;
|
||||
*ret_map = source->channel_map;
|
||||
*ret_name = source->name;
|
||||
*ret_description = source->description;
|
||||
*ret_description = pa_strnull(pa_proplist_gets(source->proplist, PA_PROP_DEVICE_DESCRIPTION));
|
||||
*ret_subtype = source->monitor_of ? SUBTYPE_MONITOR : (source->flags & PA_SOURCE_HARDWARE ? SUBTYPE_HARDWARE : SUBTYPE_VIRTUAL);
|
||||
|
||||
} else
|
||||
|
|
@ -304,10 +304,10 @@ static struct service *get_service(struct userdata *u, pa_object *device) {
|
|||
s->device = device;
|
||||
|
||||
if (pa_sink_isinstance(device)) {
|
||||
if (!(n = PA_SINK(device)->description))
|
||||
if (!(n = pa_proplist_gets(PA_SINK(device)->proplist, PA_PROP_DEVICE_DESCRIPTION)))
|
||||
n = PA_SINK(device)->name;
|
||||
} else {
|
||||
if (!(n = PA_SOURCE(device)->description))
|
||||
if (!(n = pa_proplist_gets(PA_SOURCE(device)->proplist, PA_PROP_DEVICE_DESCRIPTION)))
|
||||
n = PA_SOURCE(device)->name;
|
||||
}
|
||||
|
||||
|
|
@ -578,11 +578,11 @@ int pa__init(pa_module*m) {
|
|||
|
||||
u->services = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
|
||||
|
||||
u->sink_new_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_NEW_POST], (pa_hook_cb_t) device_new_or_changed_cb, u);
|
||||
u->sink_changed_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_DESCRIPTION_CHANGED], (pa_hook_cb_t) device_new_or_changed_cb, u);
|
||||
u->sink_new_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_PUT], (pa_hook_cb_t) device_new_or_changed_cb, u);
|
||||
u->sink_changed_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_PROPLIST_CHANGED], (pa_hook_cb_t) device_new_or_changed_cb, u);
|
||||
u->sink_unlink_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_UNLINK], (pa_hook_cb_t) device_unlink_cb, u);
|
||||
u->source_new_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_NEW_POST], (pa_hook_cb_t) device_new_or_changed_cb, u);
|
||||
u->source_changed_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_DESCRIPTION_CHANGED], (pa_hook_cb_t) device_new_or_changed_cb, u);
|
||||
u->source_new_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_PUT], (pa_hook_cb_t) device_new_or_changed_cb, u);
|
||||
u->source_changed_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_PROPLIST_CHANGED], (pa_hook_cb_t) device_new_or_changed_cb, u);
|
||||
u->source_unlink_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_UNLINK], (pa_hook_cb_t) device_unlink_cb, u);
|
||||
|
||||
u->main_entry_group = NULL;
|
||||
|
|
|
|||
|
|
@ -251,7 +251,7 @@ int pa_oss_set_fragments(int fd, int nfrags, int frag_size) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
int pa_oss_get_volume(int fd, int mixer, const pa_sample_spec *ss, pa_cvolume *volume) {
|
||||
int pa_oss_get_volume(int fd, unsigned long mixer, const pa_sample_spec *ss, pa_cvolume *volume) {
|
||||
char cv[PA_CVOLUME_SNPRINT_MAX];
|
||||
unsigned vol;
|
||||
|
||||
|
|
@ -273,7 +273,7 @@ int pa_oss_get_volume(int fd, int mixer, const pa_sample_spec *ss, pa_cvolume *v
|
|||
return 0;
|
||||
}
|
||||
|
||||
int pa_oss_set_volume(int fd, long mixer, const pa_sample_spec *ss, const pa_cvolume *volume) {
|
||||
int pa_oss_set_volume(int fd, unsigned long mixer, const pa_sample_spec *ss, const pa_cvolume *volume) {
|
||||
char cv[PA_CVOLUME_SNPRINT_MAX];
|
||||
unsigned vol;
|
||||
pa_volume_t l, r;
|
||||
|
|
|
|||
|
|
@ -33,8 +33,8 @@ int pa_oss_auto_format(int fd, pa_sample_spec *ss);
|
|||
|
||||
int pa_oss_set_fragments(int fd, int frags, int frag_size);
|
||||
|
||||
int pa_oss_set_volume(int fd, long mixer, const pa_sample_spec *ss, const pa_cvolume *volume);
|
||||
int pa_oss_get_volume(int fd, int mixer, const pa_sample_spec *ss, pa_cvolume *volume);
|
||||
int pa_oss_set_volume(int fd, unsigned long mixer, const pa_sample_spec *ss, const pa_cvolume *volume);
|
||||
int pa_oss_get_volume(int fd, unsigned long mixer, const pa_sample_spec *ss, pa_cvolume *volume);
|
||||
|
||||
int pa_oss_get_hw_description(const char *dev, char *name, size_t l);
|
||||
|
||||
|
|
|
|||
|
|
@ -51,6 +51,7 @@
|
|||
#include <pulsecore/atomic.h>
|
||||
#include <pulsecore/rtclock.h>
|
||||
#include <pulsecore/atomic.h>
|
||||
#include <pulsecore/time-smoother.h>
|
||||
|
||||
#include "module-rtp-recv-symdef.h"
|
||||
|
||||
|
|
@ -69,9 +70,11 @@ PA_MODULE_USAGE(
|
|||
|
||||
#define SAP_PORT 9875
|
||||
#define DEFAULT_SAP_ADDRESS "224.0.0.56"
|
||||
#define MEMBLOCKQ_MAXLENGTH (1024*170)
|
||||
#define MEMBLOCKQ_MAXLENGTH (1024*1024*40)
|
||||
#define MAX_SESSIONS 16
|
||||
#define DEATH_TIMEOUT 20
|
||||
#define RATE_UPDATE_INTERVAL (5*PA_USEC_PER_SEC)
|
||||
#define LATENCY_USEC (500*PA_USEC_PER_MSEC)
|
||||
|
||||
static const char* const valid_modargs[] = {
|
||||
"sink",
|
||||
|
|
@ -97,6 +100,12 @@ struct session {
|
|||
pa_rtpoll_item *rtpoll_item;
|
||||
|
||||
pa_atomic_t timestamp;
|
||||
|
||||
pa_smoother *smoother;
|
||||
pa_usec_t intended_latency;
|
||||
pa_usec_t sink_latency;
|
||||
|
||||
pa_usec_t last_rate_update;
|
||||
};
|
||||
|
||||
struct userdata {
|
||||
|
|
@ -133,21 +142,37 @@ static int sink_input_process_msg(pa_msgobject *o, int code, void *data, int64_t
|
|||
}
|
||||
|
||||
/* Called from I/O thread context */
|
||||
static int sink_input_peek(pa_sink_input *i, size_t length, pa_memchunk *chunk) {
|
||||
static int sink_input_pop_cb(pa_sink_input *i, size_t length, pa_memchunk *chunk) {
|
||||
struct session *s;
|
||||
pa_sink_input_assert_ref(i);
|
||||
pa_assert_se(s = i->userdata);
|
||||
|
||||
return pa_memblockq_peek(s->memblockq, chunk);
|
||||
if (pa_memblockq_peek(s->memblockq, chunk) < 0)
|
||||
return -1;
|
||||
|
||||
pa_memblockq_drop(s->memblockq, chunk->length);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Called from I/O thread context */
|
||||
static void sink_input_drop(pa_sink_input *i, size_t length) {
|
||||
static void sink_input_process_rewind_cb(pa_sink_input *i, size_t nbytes) {
|
||||
struct session *s;
|
||||
|
||||
pa_sink_input_assert_ref(i);
|
||||
pa_assert_se(s = i->userdata);
|
||||
|
||||
pa_memblockq_drop(s->memblockq, length);
|
||||
pa_memblockq_rewind(s->memblockq, nbytes);
|
||||
}
|
||||
|
||||
/* Called from thread context */
|
||||
static void sink_input_update_max_rewind_cb(pa_sink_input *i, size_t nbytes) {
|
||||
struct session *s;
|
||||
|
||||
pa_sink_input_assert_ref(i);
|
||||
pa_assert_se(s = i->userdata);
|
||||
|
||||
pa_memblockq_set_maxrewind(s->memblockq, nbytes);
|
||||
}
|
||||
|
||||
/* Called from main context */
|
||||
|
|
@ -215,20 +240,82 @@ static int rtpoll_work_cb(pa_rtpoll_item *i) {
|
|||
|
||||
pa_memblockq_seek(s->memblockq, delta * s->rtp_context.frame_size, PA_SEEK_RELATIVE);
|
||||
|
||||
pa_rtclock_get(&now);
|
||||
|
||||
pa_smoother_put(s->smoother, pa_timeval_load(&now), pa_bytes_to_usec(pa_memblockq_get_write_index(s->memblockq), &s->sink_input->sample_spec));
|
||||
|
||||
if (pa_memblockq_push(s->memblockq, &chunk) < 0) {
|
||||
/* queue overflow, let's flush it and try again */
|
||||
pa_memblockq_flush(s->memblockq);
|
||||
pa_memblockq_push(s->memblockq, &chunk);
|
||||
pa_log_warn("Queue overrun");
|
||||
pa_memblockq_seek(s->memblockq, chunk.length, PA_SEEK_RELATIVE);
|
||||
}
|
||||
|
||||
pa_log("blocks in q: %u", pa_memblockq_get_nblocks(s->memblockq));
|
||||
|
||||
pa_memblock_unref(chunk.memblock);
|
||||
|
||||
/* The next timestamp we expect */
|
||||
s->offset = s->rtp_context.timestamp + (chunk.length / s->rtp_context.frame_size);
|
||||
|
||||
pa_memblock_unref(chunk.memblock);
|
||||
|
||||
pa_rtclock_get(&now);
|
||||
pa_atomic_store(&s->timestamp, now.tv_sec);
|
||||
|
||||
if (s->last_rate_update + RATE_UPDATE_INTERVAL < pa_timeval_load(&now)) {
|
||||
pa_usec_t wi, ri, render_delay, sink_delay = 0, latency, fix;
|
||||
unsigned fix_samples;
|
||||
|
||||
pa_log("Updating sample rate");
|
||||
|
||||
wi = pa_smoother_get(s->smoother, pa_timeval_load(&now));
|
||||
ri = pa_bytes_to_usec(pa_memblockq_get_read_index(s->memblockq), &s->sink_input->sample_spec);
|
||||
|
||||
if (PA_MSGOBJECT(s->sink_input->sink)->process_msg(PA_MSGOBJECT(s->sink_input->sink), PA_SINK_MESSAGE_GET_LATENCY, &sink_delay, 0, NULL) < 0)
|
||||
sink_delay = 0;
|
||||
|
||||
render_delay = pa_bytes_to_usec(pa_memblockq_get_length(s->sink_input->thread_info.render_memblockq), &s->sink_input->sink->sample_spec);
|
||||
|
||||
if (ri > render_delay+sink_delay)
|
||||
ri -= render_delay+sink_delay;
|
||||
else
|
||||
ri = 0;
|
||||
|
||||
if (wi < ri)
|
||||
latency = 0;
|
||||
else
|
||||
latency = wi - ri;
|
||||
|
||||
pa_log_debug("Write index deviates by %0.2f ms, expected %0.2f ms", (double) latency/PA_USEC_PER_MSEC, (double) s->intended_latency/PA_USEC_PER_MSEC);
|
||||
|
||||
/* Calculate deviation */
|
||||
if (latency < s->intended_latency)
|
||||
fix = s->intended_latency - latency;
|
||||
else
|
||||
fix = latency - s->intended_latency;
|
||||
|
||||
/* How many samples is this per second? */
|
||||
fix_samples = fix * s->sink_input->thread_info.sample_spec.rate / RATE_UPDATE_INTERVAL;
|
||||
|
||||
/* Check if deviation is in bounds */
|
||||
if (fix_samples > s->sink_input->sample_spec.rate*.20)
|
||||
pa_log_debug("Hmmm, rate fix is too large (%lu Hz), not applying.", (unsigned long) fix_samples);
|
||||
|
||||
/* Fix up rate */
|
||||
if (latency < s->intended_latency)
|
||||
s->sink_input->sample_spec.rate -= fix_samples;
|
||||
else
|
||||
s->sink_input->sample_spec.rate += fix_samples;
|
||||
|
||||
pa_resampler_set_input_rate(s->sink_input->thread_info.resampler, s->sink_input->sample_spec.rate);
|
||||
|
||||
pa_log_debug("Updated sampling rate to %lu Hz.", (unsigned long) s->sink_input->sample_spec.rate);
|
||||
|
||||
s->last_rate_update = pa_timeval_load(&now);
|
||||
}
|
||||
|
||||
if (pa_memblockq_is_readable(s->memblockq) &&
|
||||
s->sink_input->thread_info.underrun_for > 0) {
|
||||
pa_log_debug("Requesting rewind due to end of underrun");
|
||||
pa_sink_input_request_rewind(s->sink_input, 0, FALSE, TRUE);
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
|
@ -314,10 +401,9 @@ fail:
|
|||
|
||||
static struct session *session_new(struct userdata *u, const pa_sdp_info *sdp_info) {
|
||||
struct session *s = NULL;
|
||||
char *c;
|
||||
pa_sink *sink;
|
||||
int fd = -1;
|
||||
pa_memblock *silence;
|
||||
pa_memchunk silence;
|
||||
pa_sink_input_new_data data;
|
||||
struct timeval now;
|
||||
|
||||
|
|
@ -329,37 +415,46 @@ static struct session *session_new(struct userdata *u, const pa_sdp_info *sdp_in
|
|||
goto fail;
|
||||
}
|
||||
|
||||
if (!(sink = pa_namereg_get(u->module->core, u->sink_name, PA_NAMEREG_SINK, 1))) {
|
||||
if (!(sink = pa_namereg_get(u->module->core, u->sink_name, PA_NAMEREG_SINK, TRUE))) {
|
||||
pa_log("Sink does not exist.");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
pa_rtclock_get(&now);
|
||||
|
||||
s = pa_xnew0(struct session, 1);
|
||||
s->userdata = u;
|
||||
s->first_packet = FALSE;
|
||||
s->sdp_info = *sdp_info;
|
||||
s->rtpoll_item = NULL;
|
||||
|
||||
pa_rtclock_get(&now);
|
||||
s->intended_latency = LATENCY_USEC;
|
||||
s->smoother = pa_smoother_new(PA_USEC_PER_SEC*5, PA_USEC_PER_SEC*2, TRUE, 10);
|
||||
pa_smoother_set_time_offset(s->smoother, pa_timeval_load(&now));
|
||||
s->last_rate_update = pa_timeval_load(&now);
|
||||
pa_atomic_store(&s->timestamp, now.tv_sec);
|
||||
|
||||
if ((fd = mcast_socket((const struct sockaddr*) &sdp_info->sa, sdp_info->salen)) < 0)
|
||||
goto fail;
|
||||
|
||||
c = pa_sprintf_malloc("RTP Stream%s%s%s",
|
||||
sdp_info->session_name ? " (" : "",
|
||||
sdp_info->session_name ? sdp_info->session_name : "",
|
||||
sdp_info->session_name ? ")" : "");
|
||||
|
||||
pa_sink_input_new_data_init(&data);
|
||||
data.sink = sink;
|
||||
data.driver = __FILE__;
|
||||
data.name = c;
|
||||
pa_proplist_sets(data.proplist, PA_PROP_MEDIA_ROLE, "stream");
|
||||
pa_proplist_setf(data.proplist, PA_PROP_MEDIA_NAME,
|
||||
"RTP Stream%s%s%s",
|
||||
sdp_info->session_name ? " (" : "",
|
||||
sdp_info->session_name ? sdp_info->session_name : "",
|
||||
sdp_info->session_name ? ")" : "");
|
||||
|
||||
if (sdp_info->session_name)
|
||||
pa_proplist_sets(data.proplist, "rtp.session", sdp_info->session_name);
|
||||
pa_proplist_sets(data.proplist, "rtp.origin", sdp_info->origin);
|
||||
pa_proplist_setf(data.proplist, "rtp.payload", "%u", (unsigned) sdp_info->payload);
|
||||
data.module = u->module;
|
||||
pa_sink_input_new_data_set_sample_spec(&data, &sdp_info->sample_spec);
|
||||
|
||||
s->sink_input = pa_sink_input_new(u->module->core, &data, 0);
|
||||
pa_xfree(c);
|
||||
pa_sink_input_new_data_done(&data);
|
||||
|
||||
if (!s->sink_input) {
|
||||
pa_log("Failed to create sink input.");
|
||||
|
|
@ -369,27 +464,31 @@ static struct session *session_new(struct userdata *u, const pa_sdp_info *sdp_in
|
|||
s->sink_input->userdata = s;
|
||||
|
||||
s->sink_input->parent.process_msg = sink_input_process_msg;
|
||||
s->sink_input->peek = sink_input_peek;
|
||||
s->sink_input->drop = sink_input_drop;
|
||||
s->sink_input->pop = sink_input_pop_cb;
|
||||
s->sink_input->process_rewind = sink_input_process_rewind_cb;
|
||||
s->sink_input->update_max_rewind = sink_input_update_max_rewind_cb;
|
||||
s->sink_input->kill = sink_input_kill;
|
||||
s->sink_input->attach = sink_input_attach;
|
||||
s->sink_input->detach = sink_input_detach;
|
||||
|
||||
silence = pa_silence_memblock_new(
|
||||
s->userdata->module->core->mempool,
|
||||
&s->sink_input->sample_spec,
|
||||
pa_frame_align(pa_bytes_per_second(&s->sink_input->sample_spec)/128, &s->sink_input->sample_spec));
|
||||
pa_sink_input_get_silence(s->sink_input, &silence);
|
||||
|
||||
s->sink_latency = pa_sink_input_set_requested_latency(s->sink_input, s->intended_latency/2);
|
||||
|
||||
if (s->intended_latency < s->sink_latency*2)
|
||||
s->intended_latency = s->sink_latency*2;
|
||||
|
||||
s->memblockq = pa_memblockq_new(
|
||||
0,
|
||||
MEMBLOCKQ_MAXLENGTH,
|
||||
MEMBLOCKQ_MAXLENGTH,
|
||||
pa_frame_size(&s->sink_input->sample_spec),
|
||||
pa_bytes_per_second(&s->sink_input->sample_spec)/10+1,
|
||||
pa_usec_to_bytes(s->intended_latency - s->sink_latency, &s->sink_input->sample_spec),
|
||||
0,
|
||||
silence);
|
||||
0,
|
||||
&silence);
|
||||
|
||||
pa_memblock_unref(silence);
|
||||
pa_memblock_unref(silence.memblock);
|
||||
|
||||
pa_rtp_context_init_recv(&s->rtp_context, fd, pa_frame_size(&s->sdp_info.sample_spec));
|
||||
|
||||
|
|
@ -429,12 +528,14 @@ static void session_free(struct session *s) {
|
|||
pa_sdp_info_destroy(&s->sdp_info);
|
||||
pa_rtp_context_destroy(&s->rtp_context);
|
||||
|
||||
pa_smoother_free(s->smoother);
|
||||
|
||||
pa_xfree(s);
|
||||
}
|
||||
|
||||
static void sap_event_cb(pa_mainloop_api *m, pa_io_event *e, int fd, pa_io_event_flags_t flags, void *userdata) {
|
||||
struct userdata *u = userdata;
|
||||
int goodbye;
|
||||
pa_bool_t goodbye = FALSE;
|
||||
pa_sdp_info info;
|
||||
struct session *s;
|
||||
|
||||
|
|
|
|||
|
|
@ -288,14 +288,20 @@ int pa__init(pa_module*m) {
|
|||
pa_make_fd_cloexec(sap_fd);
|
||||
|
||||
pa_source_output_new_data_init(&data);
|
||||
data.name = "RTP Monitor Stream";
|
||||
pa_proplist_sets(data.proplist, PA_PROP_MEDIA_NAME, "RTP Monitor Stream");
|
||||
pa_proplist_sets(data.proplist, "rtp.destination", dest);
|
||||
pa_proplist_setf(data.proplist, "rtp.mtu", "%lu", (unsigned long) mtu);
|
||||
pa_proplist_setf(data.proplist, "rtp.port", "%lu", (unsigned long) port);
|
||||
data.driver = __FILE__;
|
||||
data.module = m;
|
||||
data.source = s;
|
||||
pa_source_output_new_data_set_sample_spec(&data, &ss);
|
||||
pa_source_output_new_data_set_channel_map(&data, &cm);
|
||||
|
||||
if (!(o = pa_source_output_new(m->core, &data, 0))) {
|
||||
o = pa_source_output_new(m->core, &data, 0);
|
||||
pa_source_output_new_data_done(&data);
|
||||
|
||||
if (!o) {
|
||||
pa_log("failed to create source output.");
|
||||
goto fail;
|
||||
}
|
||||
|
|
@ -318,6 +324,7 @@ int pa__init(pa_module*m) {
|
|||
pa_frame_size(&ss),
|
||||
1,
|
||||
0,
|
||||
0,
|
||||
NULL);
|
||||
|
||||
u->mtu = mtu;
|
||||
|
|
|
|||
|
|
@ -55,6 +55,8 @@ pa_rtp_context* pa_rtp_context_init_send(pa_rtp_context *c, int fd, uint32_t ssr
|
|||
c->payload = payload & 127;
|
||||
c->frame_size = frame_size;
|
||||
|
||||
pa_memchunk_reset(&c->memchunk);
|
||||
|
||||
return c;
|
||||
}
|
||||
|
||||
|
|
@ -152,6 +154,8 @@ pa_rtp_context* pa_rtp_context_init_recv(pa_rtp_context *c, int fd, size_t frame
|
|||
|
||||
c->fd = fd;
|
||||
c->frame_size = frame_size;
|
||||
|
||||
pa_memchunk_reset(&c->memchunk);
|
||||
return c;
|
||||
}
|
||||
|
||||
|
|
@ -173,12 +177,28 @@ int pa_rtp_recv(pa_rtp_context *c, pa_memchunk *chunk, pa_mempool *pool) {
|
|||
goto fail;
|
||||
}
|
||||
|
||||
if (!size)
|
||||
if (size <= 0)
|
||||
return 0;
|
||||
|
||||
chunk->memblock = pa_memblock_new(pool, size);
|
||||
if (c->memchunk.length < (unsigned) size) {
|
||||
size_t l;
|
||||
|
||||
iov.iov_base = pa_memblock_acquire(chunk->memblock);
|
||||
if (c->memchunk.memblock)
|
||||
pa_memblock_unref(c->memchunk.memblock);
|
||||
|
||||
l = PA_MAX((size_t) size, pa_mempool_block_size_max(pool));
|
||||
|
||||
c->memchunk.memblock = pa_memblock_new(pool, l);
|
||||
c->memchunk.index = 0;
|
||||
c->memchunk.length = pa_memblock_get_length(c->memchunk.memblock);
|
||||
}
|
||||
|
||||
pa_assert(c->memchunk.length >= (size_t) size);
|
||||
|
||||
chunk->memblock = pa_memblock_ref(c->memchunk.memblock);
|
||||
chunk->index = c->memchunk.index;
|
||||
|
||||
iov.iov_base = (uint8_t*) pa_memblock_acquire(chunk->memblock) + chunk->index;
|
||||
iov.iov_len = size;
|
||||
|
||||
m.msg_name = NULL;
|
||||
|
|
@ -236,14 +256,22 @@ int pa_rtp_recv(pa_rtp_context *c, pa_memchunk *chunk, pa_mempool *pool) {
|
|||
goto fail;
|
||||
}
|
||||
|
||||
chunk->index = 12 + cc*4;
|
||||
chunk->length = size - chunk->index;
|
||||
chunk->index += 12 + cc*4;
|
||||
chunk->length = size - 12 + cc*4;
|
||||
|
||||
if (chunk->length % c->frame_size != 0) {
|
||||
pa_log_warn("Bad RTP packet size.");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
c->memchunk.index = chunk->index + chunk->length;
|
||||
c->memchunk.length = pa_memblock_get_length(c->memchunk.memblock) - c->memchunk.index;
|
||||
|
||||
if (c->memchunk.length <= 0) {
|
||||
pa_memblock_unref(c->memchunk.memblock);
|
||||
pa_memchunk_reset(&c->memchunk);
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
fail:
|
||||
|
|
@ -329,7 +357,10 @@ int pa_rtp_sample_spec_valid(const pa_sample_spec *ss) {
|
|||
void pa_rtp_context_destroy(pa_rtp_context *c) {
|
||||
pa_assert(c);
|
||||
|
||||
pa_close(c->fd);
|
||||
pa_assert_se(pa_close(c->fd) == 0);
|
||||
|
||||
if (c->memchunk.memblock)
|
||||
pa_memblock_unref(c->memchunk.memblock);
|
||||
}
|
||||
|
||||
const char* pa_rtp_format_to_string(pa_sample_format_t f) {
|
||||
|
|
@ -361,4 +392,3 @@ pa_sample_format_t pa_rtp_string_to_format(const char *s) {
|
|||
else
|
||||
return PA_SAMPLE_INVALID;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -37,6 +37,8 @@ typedef struct pa_rtp_context {
|
|||
uint32_t ssrc;
|
||||
uint8_t payload;
|
||||
size_t frame_size;
|
||||
|
||||
pa_memchunk memchunk;
|
||||
} pa_rtp_context;
|
||||
|
||||
pa_rtp_context* pa_rtp_context_init_send(pa_rtp_context *c, int fd, uint32_t ssrc, uint8_t payload, size_t frame_size);
|
||||
|
|
|
|||
|
|
@ -71,7 +71,7 @@ void pa_sap_context_destroy(pa_sap_context *c) {
|
|||
pa_xfree(c->sdp_data);
|
||||
}
|
||||
|
||||
int pa_sap_send(pa_sap_context *c, int goodbye) {
|
||||
int pa_sap_send(pa_sap_context *c, pa_bool_t goodbye) {
|
||||
uint32_t header;
|
||||
struct sockaddr_storage sa_buf;
|
||||
struct sockaddr *sa = (struct sockaddr*) &sa_buf;
|
||||
|
|
@ -127,7 +127,7 @@ pa_sap_context* pa_sap_context_init_recv(pa_sap_context *c, int fd) {
|
|||
return c;
|
||||
}
|
||||
|
||||
int pa_sap_recv(pa_sap_context *c, int *goodbye) {
|
||||
int pa_sap_recv(pa_sap_context *c, pa_bool_t *goodbye) {
|
||||
struct msghdr m;
|
||||
struct iovec iov;
|
||||
int size, k;
|
||||
|
|
|
|||
|
|
@ -40,9 +40,9 @@ typedef struct pa_sap_context {
|
|||
pa_sap_context* pa_sap_context_init_send(pa_sap_context *c, int fd, char *sdp_data);
|
||||
void pa_sap_context_destroy(pa_sap_context *c);
|
||||
|
||||
int pa_sap_send(pa_sap_context *c, int goodbye);
|
||||
int pa_sap_send(pa_sap_context *c, pa_bool_t goodbye);
|
||||
|
||||
pa_sap_context* pa_sap_context_init_recv(pa_sap_context *c, int fd);
|
||||
int pa_sap_recv(pa_sap_context *c, int *goodbye);
|
||||
int pa_sap_recv(pa_sap_context *c, pa_bool_t *goodbye);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -117,7 +117,7 @@ static pa_sample_spec *parse_sdp_sample_spec(pa_sample_spec *ss, char *c) {
|
|||
|
||||
pa_sdp_info *pa_sdp_parse(const char *t, pa_sdp_info *i, int is_goodbye) {
|
||||
uint16_t port = 0;
|
||||
int ss_valid = 0;
|
||||
pa_bool_t ss_valid = FALSE;
|
||||
|
||||
pa_assert(t);
|
||||
pa_assert(i);
|
||||
|
|
@ -202,7 +202,7 @@ pa_sdp_info *pa_sdp_parse(const char *t, pa_sdp_info *i, int is_goodbye) {
|
|||
i->payload = (uint8_t) _payload;
|
||||
|
||||
if (pa_rtp_sample_spec_from_payload(i->payload, &i->sample_spec))
|
||||
ss_valid = 1;
|
||||
ss_valid = TRUE;
|
||||
}
|
||||
}
|
||||
} else if (pa_startswith(t, "a=rtpmap:")) {
|
||||
|
|
@ -222,7 +222,7 @@ pa_sdp_info *pa_sdp_parse(const char *t, pa_sdp_info *i, int is_goodbye) {
|
|||
c[strcspn(c, "\n")] = 0;
|
||||
|
||||
if (parse_sdp_sample_spec(&i->sample_spec, c))
|
||||
ss_valid = 1;
|
||||
ss_valid = TRUE;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue