mirrors/pulseaudio
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pulseaudio/pulseaudio.git synced 2025-11-02 09:01:46 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

big alsa module rework to make things more robust to broken sound drivers and make it easier to debug them

Browse source
This commit is contained in:
Lennart Poettering 2009-02-20 03:21:17 +01:00
parent adc9c2db6b
commit 26a270a934
4 changed files with 397 additions and 279 deletions
Download patch file Download diff file Expand all files Collapse all files

347
src/modules/alsa/alsa-sink.c
View file

@ -56,11 +56,13 @@
#include "alsa-util.h" #include "alsa-util.h"
#include "alsa-sink.h" #include "alsa-sink.h"
/* #define DEBUG_TIMING */
#define DEFAULT_DEVICE "default" #define DEFAULT_DEVICE "default"
#define DEFAULT_TSCHED_BUFFER_USEC (2*PA_USEC_PER_SEC) /* 2s */ #define DEFAULT_TSCHED_BUFFER_USEC (2*PA_USEC_PER_SEC) /* 2s */
#define DEFAULT_TSCHED_WATERMARK_USEC (20*PA_USEC_PER_MSEC) /* 20ms */ #define DEFAULT_TSCHED_WATERMARK_USEC (20*PA_USEC_PER_MSEC) /* 20ms */
#define TSCHED_MIN_SLEEP_USEC (3*PA_USEC_PER_MSEC) /* 3ms */ #define TSCHED_MIN_SLEEP_USEC (10*PA_USEC_PER_MSEC) /* 10ms */
#define TSCHED_MIN_WAKEUP_USEC (3*PA_USEC_PER_MSEC) /* 3ms */ #define TSCHED_MIN_WAKEUP_USEC (4*PA_USEC_PER_MSEC) /* 4ms */
struct userdata { struct userdata {
pa_core *core; pa_core *core;
@ -78,17 +80,17 @@ struct userdata {
snd_mixer_elem_t *mixer_elem; snd_mixer_elem_t *mixer_elem;
long hw_volume_max, hw_volume_min; long hw_volume_max, hw_volume_min;
long hw_dB_max, hw_dB_min; long hw_dB_max, hw_dB_min;
pa_bool_t hw_dB_supported; pa_bool_t hw_dB_supported:1;
pa_bool_t mixer_seperate_channels; pa_bool_t mixer_seperate_channels:1;
pa_cvolume hardware_volume; pa_cvolume hardware_volume;
size_t frame_size, fragment_size, hwbuf_size, tsched_watermark; size_t frame_size, fragment_size, hwbuf_size, tsched_watermark, hwbuf_unused, min_sleep, min_wakeup;
unsigned nfragments; unsigned nfragments;
pa_memchunk memchunk; pa_memchunk memchunk;
char *device_name; char *device_name;
pa_bool_t use_mmap, use_tsched; pa_bool_t use_mmap:1, use_tsched:1;
pa_bool_t first, after_rewind; pa_bool_t first, after_rewind;
@ -97,39 +99,70 @@ struct userdata {
snd_mixer_selem_channel_id_t mixer_map[SND_MIXER_SCHN_LAST]; snd_mixer_selem_channel_id_t mixer_map[SND_MIXER_SCHN_LAST];
pa_smoother *smoother; pa_smoother *smoother;
int64_t frame_index; uint64_t write_count;
uint64_t since_start; uint64_t since_start;
snd_pcm_sframes_t hwbuf_unused_frames;
}; };
static void userdata_free(struct userdata *u); static void userdata_free(struct userdata *u);
static void fix_tsched_watermark(struct userdata *u) { static void fix_min_sleep_wakeup(struct userdata *u) {
size_t max_use; size_t max_use, max_use_2;
size_t min_sleep, min_wakeup;
pa_assert(u); pa_assert(u);
max_use = u->hwbuf_size - (size_t) u->hwbuf_unused_frames * u->frame_size; max_use = u->hwbuf_size - u->hwbuf_unused;
max_use_2 = pa_frame_align(max_use/2, &u->sink->sample_spec);
min_sleep = pa_usec_to_bytes(TSCHED_MIN_SLEEP_USEC, &u->sink->sample_spec); u->min_sleep = pa_usec_to_bytes(TSCHED_MIN_SLEEP_USEC, &u->sink->sample_spec);
min_wakeup = pa_usec_to_bytes(TSCHED_MIN_WAKEUP_USEC, &u->sink->sample_spec); u->min_sleep = PA_CLAMP(u->min_sleep, u->frame_size, max_use_2);
if (min_sleep > max_use/2) u->min_wakeup = pa_usec_to_bytes(TSCHED_MIN_WAKEUP_USEC, &u->sink->sample_spec);
min_sleep = pa_frame_align(max_use/2, &u->sink->sample_spec); u->min_wakeup = PA_CLAMP(u->min_wakeup, u->frame_size, max_use_2);
if (min_sleep < u->frame_size) }
min_sleep = u->frame_size;
if (min_wakeup > max_use/2) static void fix_tsched_watermark(struct userdata *u) {
min_wakeup = pa_frame_align(max_use/2, &u->sink->sample_spec); size_t max_use;
if (min_wakeup < u->frame_size) pa_assert(u);
min_wakeup = u->frame_size;
if (u->tsched_watermark > max_use-min_sleep) max_use = u->hwbuf_size - u->hwbuf_unused;
u->tsched_watermark = max_use-min_sleep;
if (u->tsched_watermark < min_wakeup) if (u->tsched_watermark > max_use - u->min_sleep)
u->tsched_watermark = min_wakeup; u->tsched_watermark = max_use - u->min_sleep;
if (u->tsched_watermark < u->min_wakeup)
u->tsched_watermark = u->min_wakeup;
}
static void adjust_after_underrun(struct userdata *u) {
size_t old_watermark;
pa_usec_t old_min_latency, new_min_latency;
pa_assert(u);
/* First, just try to increase the watermark */
old_watermark = u->tsched_watermark;
u->tsched_watermark *= 2;
fix_tsched_watermark(u);
if (old_watermark != u->tsched_watermark) {
pa_log_notice("Increasing wakeup watermark to %0.2f ms",
(double) pa_bytes_to_usec(u->tsched_watermark, &u->sink->sample_spec) / PA_USEC_PER_MSEC);
return;
}
/* Hmm, we cannot increase the watermark any further, hence let's raise the latency */
old_min_latency = u->sink->thread_info.min_latency;
new_min_latency = PA_MIN(old_min_latency * 2, u->sink->thread_info.max_latency);
if (old_min_latency != new_min_latency) {
pa_log_notice("Increasing minimal latency to %0.2f ms",
(double) new_min_latency / PA_USEC_PER_MSEC);
pa_sink_update_latency_range(u->sink, new_min_latency, u->sink->thread_info.max_latency);
return;
}
/* When we reach this we're officialy fucked! */
} }
static void hw_sleep_time(struct userdata *u, pa_usec_t *sleep_usec, pa_usec_t*process_usec) { static void hw_sleep_time(struct userdata *u, pa_usec_t *sleep_usec, pa_usec_t*process_usec) {
@ -145,17 +178,20 @@ static void hw_sleep_time(struct userdata *u, pa_usec_t *sleep_usec, pa_usec_t*p
if (usec == (pa_usec_t) -1) if (usec == (pa_usec_t) -1)
usec = pa_bytes_to_usec(u->hwbuf_size, &u->sink->sample_spec); usec = pa_bytes_to_usec(u->hwbuf_size, &u->sink->sample_spec);
/* pa_log_debug("hw buffer time: %u ms", (unsigned) (usec / PA_USEC_PER_MSEC)); */
wm = pa_bytes_to_usec(u->tsched_watermark, &u->sink->sample_spec); wm = pa_bytes_to_usec(u->tsched_watermark, &u->sink->sample_spec);
if (usec >= wm) { if (wm > usec)
*sleep_usec = usec - wm; wm = usec/2;
*process_usec = wm;
} else
*process_usec = *sleep_usec = usec / 2;
/* pa_log_debug("after watermark: %u ms", (unsigned) (*sleep_usec / PA_USEC_PER_MSEC)); */ *sleep_usec = usec - wm;
*process_usec = wm;
#ifdef DEBUG_TIMING
pa_log_debug("Buffer time: %lu ms; Sleep time: %lu ms; Process time: %lu ms",
(unsigned long) (usec / PA_USEC_PER_MSEC),
(unsigned long) (*sleep_usec / PA_USEC_PER_MSEC),
(unsigned long) (*process_usec / PA_USEC_PER_MSEC));
#endif
} }
static int try_recover(struct userdata *u, const char *call, int err) { static int try_recover(struct userdata *u, const char *call, int err) {
@ -170,40 +206,45 @@ static int try_recover(struct userdata *u, const char *call, int err) {
if (err == -EPIPE) if (err == -EPIPE)
pa_log_debug("%s: Buffer underrun!", call); pa_log_debug("%s: Buffer underrun!", call);
if ((err = snd_pcm_recover(u->pcm_handle, err, 1)) == 0) { if ((err = snd_pcm_recover(u->pcm_handle, err, 1)) < 0) {
u->first = TRUE; pa_log("%s: %s", call, snd_strerror(err));
u->since_start = 0; return -1;
return 0;
} }
pa_log("%s: %s", call, snd_strerror(err)); u->first = TRUE;
return -1; u->since_start = 0;
return 0;
} }
static size_t check_left_to_play(struct userdata *u, snd_pcm_sframes_t n) { static size_t check_left_to_play(struct userdata *u, size_t n_bytes) {
size_t left_to_play; size_t left_to_play;
if ((size_t) n*u->frame_size < u->hwbuf_size) /* We use <= instead of < for this check here because an underrun
left_to_play = u->hwbuf_size - ((size_t) n*u->frame_size); * only happens after the last sample was processed, not already when
else * it is removed from the buffer. This is particularly important
* when block transfer is used. */
if (n_bytes <= u->hwbuf_size) {
left_to_play = u->hwbuf_size - n_bytes;
#ifdef DEBUG_TIMING
pa_log_debug("%0.2f ms left to play", (double) pa_bytes_to_usec(left_to_play, &u->sink->sample_spec) / PA_USEC_PER_MSEC);
#endif
} else {
left_to_play = 0; left_to_play = 0;
if (left_to_play > 0) { #ifdef DEBUG_TIMING
/* pa_log_debug("%0.2f ms left to play", (double) pa_bytes_to_usec(left_to_play, &u->sink->sample_spec) / PA_USEC_PER_MSEC); */ PA_DEBUG_TRAP;
} else if (!u->first && !u->after_rewind) { #endif
if (pa_log_ratelimit()) if (!u->first && !u->after_rewind) {
pa_log_info("Underrun!");
if (u->use_tsched) { if (pa_log_ratelimit())
size_t old_watermark = u->tsched_watermark; pa_log_info("Underrun!");
u->tsched_watermark *= 2; if (u->use_tsched)
fix_tsched_watermark(u); adjust_after_underrun(u);
if (old_watermark != u->tsched_watermark)
pa_log_notice("Increasing wakeup watermark to %0.2f ms",
(double) pa_bytes_to_usec(u->tsched_watermark, &u->sink->sample_spec) / PA_USEC_PER_MSEC);
} }
} }
@ -211,7 +252,7 @@ static size_t check_left_to_play(struct userdata *u, snd_pcm_sframes_t n) {
} }
static int mmap_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled) { static int mmap_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled) {
int work_done = 0; pa_bool_t work_done = TRUE;
pa_usec_t max_sleep_usec = 0, process_usec = 0; pa_usec_t max_sleep_usec = 0, process_usec = 0;
size_t left_to_play; size_t left_to_play;
@ -223,22 +264,27 @@ static int mmap_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polle
for (;;) { for (;;) {
snd_pcm_sframes_t n; snd_pcm_sframes_t n;
size_t n_bytes;
int r; int r;
snd_pcm_hwsync(u->pcm_handle);
/* First we determine how many samples are missing to fill the /* First we determine how many samples are missing to fill the
* buffer up to 100% */ * buffer up to 100% */
if (PA_UNLIKELY((n = pa_alsa_safe_avail_update(u->pcm_handle, u->hwbuf_size, &u->sink->sample_spec)) < 0)) { if (PA_UNLIKELY((n = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->sink->sample_spec)) < 0)) {
if ((r = try_recover(u, "snd_pcm_avail_update", (int) n)) == 0) if ((r = try_recover(u, "snd_pcm_avail", (int) n)) == 0)
continue; continue;
return r; return r;
} }
left_to_play = check_left_to_play(u, n); n_bytes = (size_t) n * u->frame_size;
#ifdef DEBUG_TIMING
pa_log_debug("avail: %lu", (unsigned long) n_bytes);
#endif
left_to_play = check_left_to_play(u, n_bytes);
if (u->use_tsched) if (u->use_tsched)
@ -249,33 +295,42 @@ static int mmap_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polle
* a single hw buffer length. */ * a single hw buffer length. */
if (!polled && if (!polled &&
pa_bytes_to_usec(left_to_play, &u->sink->sample_spec) > process_usec+max_sleep_usec/2) pa_bytes_to_usec(left_to_play, &u->sink->sample_spec) > process_usec+max_sleep_usec/2) {
#ifdef DEBUG_TIMING
pa_log_debug("Not filling up, because too early.");
#endif
break; break;
}
if (PA_UNLIKELY(n <= u->hwbuf_unused_frames)) { if (PA_UNLIKELY(n_bytes <= u->hwbuf_unused)) {
if (polled && pa_log_ratelimit()) if (polled && pa_log_ratelimit())
pa_log(_("ALSA woke us up to write new data to the device, but there was actually nothing to write! " pa_log(_("ALSA woke us up to write new data to the device, but there was actually nothing to write! "
"Most likely this is an ALSA driver bug. Please report this issue to the ALSA developers. " "Most likely this is an ALSA driver bug. Please report this issue to the ALSA developers. "
"We were woken up with POLLOUT set -- however a subsequent snd_pcm_avail_update() returned 0.")); "We were woken up with POLLOUT set -- however a subsequent snd_pcm_avail_update() returned 0."));
#ifdef DEBUG_TIMING
pa_log_debug("Not filling up, because not necessary.");
#endif
break; break;
} }
n -= u->hwbuf_unused_frames; n_bytes -= u->hwbuf_unused;
polled = FALSE; polled = FALSE;
/* pa_log_debug("Filling up"); */ #ifdef DEBUG_TIMING
pa_log_debug("Filling up");
#endif
for (;;) { for (;;) {
pa_memchunk chunk; pa_memchunk chunk;
void *p; void *p;
int err; int err;
const snd_pcm_channel_area_t *areas; const snd_pcm_channel_area_t *areas;
snd_pcm_uframes_t offset, frames = (snd_pcm_uframes_t) n; snd_pcm_uframes_t offset, frames;
snd_pcm_sframes_t sframes; snd_pcm_sframes_t sframes;
frames = (snd_pcm_uframes_t) (n_bytes / u->frame_size);
/* pa_log_debug("%lu frames to write", (unsigned long) frames); */ /* pa_log_debug("%lu frames to write", (unsigned long) frames); */
if (PA_UNLIKELY((err = pa_alsa_safe_mmap_begin(u->pcm_handle, &areas, &offset, &frames, u->hwbuf_size, &u->sink->sample_spec)) < 0)) { if (PA_UNLIKELY((err = pa_alsa_safe_mmap_begin(u->pcm_handle, &areas, &offset, &frames, u->hwbuf_size, &u->sink->sample_spec)) < 0)) {
@ -305,9 +360,6 @@ static int mmap_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polle
chunk.index = 0; chunk.index = 0;
pa_sink_render_into_full(u->sink, &chunk); pa_sink_render_into_full(u->sink, &chunk);
/* FIXME: Maybe we can do something to keep this memory block
* a little bit longer around? */
pa_memblock_unref_fixed(chunk.memblock); pa_memblock_unref_fixed(chunk.memblock);
if (PA_UNLIKELY((sframes = snd_pcm_mmap_commit(u->pcm_handle, offset, frames)) < 0)) { if (PA_UNLIKELY((sframes = snd_pcm_mmap_commit(u->pcm_handle, offset, frames)) < 0)) {
@ -318,26 +370,28 @@ static int mmap_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polle
return r; return r;
} }
work_done = 1; work_done = TRUE;
u->frame_index += (int64_t) frames; u->write_count += frames * u->frame_size;
u->since_start += frames * u->frame_size; u->since_start += frames * u->frame_size;
/* pa_log_debug("wrote %lu frames", (unsigned long) frames); */ #ifdef DEBUG_TIMING
pa_log_debug("Wrote %lu bytes", (unsigned long) (frames * u->frame_size));
#endif
if (frames >= (snd_pcm_uframes_t) n) if ((size_t) frames * u->frame_size >= n_bytes)
break; break;
n -= (snd_pcm_sframes_t) frames; n_bytes -= (size_t) frames * u->frame_size;
} }
} }
*sleep_usec = pa_bytes_to_usec(left_to_play, &u->sink->sample_spec) - process_usec; *sleep_usec = pa_bytes_to_usec(left_to_play, &u->sink->sample_spec) - process_usec;
return work_done; return work_done ? 1 : 0;
} }
static int unix_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled) { static int unix_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled) {
int work_done = 0; pa_bool_t work_done = FALSE;
pa_usec_t max_sleep_usec = 0, process_usec = 0; pa_usec_t max_sleep_usec = 0, process_usec = 0;
size_t left_to_play; size_t left_to_play;
@ -349,19 +403,19 @@ static int unix_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polle
for (;;) { for (;;) {
snd_pcm_sframes_t n; snd_pcm_sframes_t n;
size_t n_bytes;
int r; int r;
snd_pcm_hwsync(u->pcm_handle); if (PA_UNLIKELY((n = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->sink->sample_spec)) < 0)) {
if (PA_UNLIKELY((n = pa_alsa_safe_avail_update(u->pcm_handle, u->hwbuf_size, &u->sink->sample_spec)) < 0)) { if ((r = try_recover(u, "snd_pcm_avail", (int) n)) == 0)
if ((r = try_recover(u, "snd_pcm_avail_update", (int) n)) == 0)
continue; continue;
return r; return r;
} }
left_to_play = check_left_to_play(u, n); n_bytes = (size_t) n * u->frame_size;
left_to_play = check_left_to_play(u, n_bytes);
if (u->use_tsched) if (u->use_tsched)
@ -375,7 +429,7 @@ static int unix_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polle
pa_bytes_to_usec(left_to_play, &u->sink->sample_spec) > process_usec+max_sleep_usec/2) pa_bytes_to_usec(left_to_play, &u->sink->sample_spec) > process_usec+max_sleep_usec/2)
break; break;
if (PA_UNLIKELY(n <= u->hwbuf_unused_frames)) { if (PA_UNLIKELY(n_bytes <= u->hwbuf_unused)) {
if (polled && pa_log_ratelimit()) if (polled && pa_log_ratelimit())
pa_log(_("ALSA woke us up to write new data to the device, but there was actually nothing to write! " pa_log(_("ALSA woke us up to write new data to the device, but there was actually nothing to write! "
@ -385,8 +439,7 @@ static int unix_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polle
break; break;
} }
n -= u->hwbuf_unused_frames; n_bytes -= u->hwbuf_unused;
polled = FALSE; polled = FALSE;
for (;;) { for (;;) {
@ -396,14 +449,14 @@ static int unix_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polle
/* pa_log_debug("%lu frames to write", (unsigned long) frames); */ /* pa_log_debug("%lu frames to write", (unsigned long) frames); */
if (u->memchunk.length <= 0) if (u->memchunk.length <= 0)
pa_sink_render(u->sink, (size_t) n * u->frame_size, &u->memchunk); pa_sink_render(u->sink, n_bytes, &u->memchunk);
pa_assert(u->memchunk.length > 0); pa_assert(u->memchunk.length > 0);
frames = (snd_pcm_sframes_t) (u->memchunk.length / u->frame_size); frames = (snd_pcm_sframes_t) (u->memchunk.length / u->frame_size);
if (frames > n) if (frames > (snd_pcm_sframes_t) (n_bytes/u->frame_size))
frames = n; frames = (snd_pcm_sframes_t) (n_bytes/u->frame_size);
p = pa_memblock_acquire(u->memchunk.memblock); p = pa_memblock_acquire(u->memchunk.memblock);
frames = snd_pcm_writei(u->pcm_handle, (const uint8_t*) p + u->memchunk.index, (snd_pcm_uframes_t) frames); frames = snd_pcm_writei(u->pcm_handle, (const uint8_t*) p + u->memchunk.index, (snd_pcm_uframes_t) frames);
@ -427,30 +480,29 @@ static int unix_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polle
pa_memchunk_reset(&u->memchunk); pa_memchunk_reset(&u->memchunk);
} }
work_done = 1; work_done = TRUE;
u->frame_index += frames; u->write_count += frames * u->frame_size;
u->since_start += (size_t) frames * u->frame_size; u->since_start += frames * u->frame_size;
/* pa_log_debug("wrote %lu frames", (unsigned long) frames); */ /* pa_log_debug("wrote %lu frames", (unsigned long) frames); */
if (frames >= n) if ((size_t) frames * u->frame_size >= n_bytes)
break; break;
n -= frames; n_bytes -= (size_t) frames * u->frame_size;
} }
} }
*sleep_usec = pa_bytes_to_usec(left_to_play, &u->sink->sample_spec) - process_usec; *sleep_usec = pa_bytes_to_usec(left_to_play, &u->sink->sample_spec) - process_usec;
return work_done; return work_done ? 1 : 0;
} }
static void update_smoother(struct userdata *u) { static void update_smoother(struct userdata *u) {
snd_pcm_sframes_t delay = 0; snd_pcm_sframes_t delay = 0;
int64_t frames; int64_t position;
int err; int err;
pa_usec_t now1, now2; pa_usec_t now1 = 0, now2;
/* struct timeval timestamp; */
snd_pcm_status_t *status; snd_pcm_status_t *status;
snd_pcm_status_alloca(&status); snd_pcm_status_alloca(&status);
@ -460,36 +512,35 @@ static void update_smoother(struct userdata *u) {
/* Let's update the time smoother */ /* Let's update the time smoother */
snd_pcm_hwsync(u->pcm_handle);
snd_pcm_avail_update(u->pcm_handle);
/* if (PA_UNLIKELY((err = snd_pcm_status(u->pcm_handle, status)) < 0)) { */
/* pa_log("Failed to query DSP status data: %s", snd_strerror(err)); */
/* return; */
/* } */
/* delay = snd_pcm_status_get_delay(status); */
if (PA_UNLIKELY((err = snd_pcm_delay(u->pcm_handle, &delay)) < 0)) { if (PA_UNLIKELY((err = snd_pcm_delay(u->pcm_handle, &delay)) < 0)) {
pa_log("Failed to query DSP status data: %s", snd_strerror(err)); pa_log_warn("Failed to query DSP status data: %s", snd_strerror(err));
return; return;
} }
frames = u->frame_index - delay; if (PA_UNLIKELY((err = snd_pcm_status(u->pcm_handle, status)) < 0))
pa_log_warn("Failed to get timestamp: %s", snd_strerror(err));
else {
snd_htimestamp_t htstamp = { 0, 0 };
snd_pcm_status_get_htstamp(status, &htstamp);
now1 = pa_timespec_load(&htstamp);
}
/* pa_log_debug("frame_index = %llu, delay = %llu, p = %llu", (unsigned long long) u->frame_index, (unsigned long long) delay, (unsigned long long) frames); */ position = (int64_t) u->write_count - ((int64_t) delay * (int64_t) u->frame_size);
/* snd_pcm_status_get_tstamp(status, &timestamp); */ if (PA_UNLIKELY(position < 0))
/* pa_rtclock_from_wallclock(&timestamp); */ position = 0;
/* now1 = pa_timeval_load(&timestamp); */
/* Hmm, if the timestamp is 0, then it wasn't set and we take the current time */
if (now1 <= 0)
now1 = pa_rtclock_usec();
now2 = pa_bytes_to_usec((uint64_t) position, &u->sink->sample_spec);
now1 = pa_rtclock_usec();
now2 = pa_bytes_to_usec((uint64_t) frames * u->frame_size, &u->sink->sample_spec);
pa_smoother_put(u->smoother, now1, now2); pa_smoother_put(u->smoother, now1, now2);
} }
static pa_usec_t sink_get_latency(struct userdata *u) { static pa_usec_t sink_get_latency(struct userdata *u) {
pa_usec_t r = 0; pa_usec_t r;
int64_t delay; int64_t delay;
pa_usec_t now1, now2; pa_usec_t now1, now2;
@ -498,10 +549,9 @@ static pa_usec_t sink_get_latency(struct userdata *u) {
now1 = pa_rtclock_usec(); now1 = pa_rtclock_usec();
now2 = pa_smoother_get(u->smoother, now1); now2 = pa_smoother_get(u->smoother, now1);
delay = (int64_t) pa_bytes_to_usec((uint64_t) u->frame_index * u->frame_size, &u->sink->sample_spec) - (int64_t) now2; delay = (int64_t) pa_bytes_to_usec(u->write_count, &u->sink->sample_spec) - (int64_t) now2;
if (delay > 0) r = delay >= 0 ? (pa_usec_t) delay : 0;
r = (pa_usec_t) delay;
if (u->memchunk.memblock) if (u->memchunk.memblock)
r += pa_bytes_to_usec(u->memchunk.length, &u->sink->sample_spec); r += pa_bytes_to_usec(u->memchunk.length, &u->sink->sample_spec);
@ -550,7 +600,7 @@ static int update_sw_params(struct userdata *u) {
pa_assert(u); pa_assert(u);
/* Use the full buffer if noone asked us for anything specific */ /* Use the full buffer if noone asked us for anything specific */
u->hwbuf_unused_frames = 0; u->hwbuf_unused = 0;
if (u->use_tsched) { if (u->use_tsched) {
pa_usec_t latency; pa_usec_t latency;
@ -558,7 +608,7 @@ static int update_sw_params(struct userdata *u) {
if ((latency = pa_sink_get_requested_latency_within_thread(u->sink)) != (pa_usec_t) -1) { if ((latency = pa_sink_get_requested_latency_within_thread(u->sink)) != (pa_usec_t) -1) {
size_t b; size_t b;
pa_log_debug("latency set to %0.2fms", (double) latency / PA_USEC_PER_MSEC); pa_log_debug("Latency set to %0.2fms", (double) latency / PA_USEC_PER_MSEC);
b = pa_usec_to_bytes(latency, &u->sink->sample_spec); b = pa_usec_to_bytes(latency, &u->sink->sample_spec);
@ -567,18 +617,17 @@ static int update_sw_params(struct userdata *u) {
if (PA_UNLIKELY(b < u->frame_size)) if (PA_UNLIKELY(b < u->frame_size))
b = u->frame_size; b = u->frame_size;
u->hwbuf_unused_frames = (snd_pcm_sframes_t) u->hwbuf_unused = PA_LIKELY(b < u->hwbuf_size) ? (u->hwbuf_size - b) : 0;
(PA_LIKELY(b < u->hwbuf_size) ?
((u->hwbuf_size - b) / u->frame_size) : 0);
} }
fix_min_sleep_wakeup(u);
fix_tsched_watermark(u); fix_tsched_watermark(u);
} }
pa_log_debug("hwbuf_unused_frames=%lu", (unsigned long) u->hwbuf_unused_frames); pa_log_debug("hwbuf_unused=%lu", (unsigned long) u->hwbuf_unused);
/* We need at last one frame in the used part of the buffer */ /* We need at last one frame in the used part of the buffer */
avail_min = (snd_pcm_uframes_t) u->hwbuf_unused_frames + 1; avail_min = (snd_pcm_uframes_t) u->hwbuf_unused / u->frame_size + 1;
if (u->use_tsched) { if (u->use_tsched) {
pa_usec_t sleep_usec, process_usec; pa_usec_t sleep_usec, process_usec;
@ -594,7 +643,7 @@ static int update_sw_params(struct userdata *u) {
return err; return err;
} }
pa_sink_set_max_request(u->sink, u->hwbuf_size - (size_t) u->hwbuf_unused_frames * u->frame_size); pa_sink_set_max_request(u->sink, u->hwbuf_size - u->hwbuf_unused);
return 0; return 0;
} }
@ -655,8 +704,6 @@ static int unsuspend(struct userdata *u) {
if (build_pollfd(u) < 0) if (build_pollfd(u) < 0)
goto fail; goto fail;
/* FIXME: We need to reload the volume somehow */
u->first = TRUE; u->first = TRUE;
u->since_start = 0; u->since_start = 0;
@ -981,13 +1028,13 @@ static void sink_set_mute_cb(pa_sink *s) {
static void sink_update_requested_latency_cb(pa_sink *s) { static void sink_update_requested_latency_cb(pa_sink *s) {
struct userdata *u = s->userdata; struct userdata *u = s->userdata;
snd_pcm_sframes_t before; size_t before;
pa_assert(u); pa_assert(u);
if (!u->pcm_handle) if (!u->pcm_handle)
return; return;
before = u->hwbuf_unused_frames; before = u->hwbuf_unused;
update_sw_params(u); update_sw_params(u);
/* Let's check whether we now use only a smaller part of the /* Let's check whether we now use only a smaller part of the
@ -996,7 +1043,7 @@ static void sink_update_requested_latency_cb(pa_sink *s) {
current fill level. Thus, let's do a full rewind once, to clear current fill level. Thus, let's do a full rewind once, to clear
things up. */ things up. */
if (u->hwbuf_unused_frames > before) { if (u->hwbuf_unused > before) {
pa_log_debug("Requesting rewind due to latency change."); pa_log_debug("Requesting rewind due to latency change.");
pa_sink_request_rewind(s, (size_t) -1); pa_sink_request_rewind(s, (size_t) -1);
} }
@ -1051,7 +1098,7 @@ static int process_rewind(struct userdata *u) {
if (rewind_nbytes <= 0) if (rewind_nbytes <= 0)
pa_log_info("Tried rewind, but was apparently not possible."); pa_log_info("Tried rewind, but was apparently not possible.");
else { else {
u->frame_index -= out_frames; u->write_count -= out_frames * u->frame_size;
pa_log_debug("Rewound %lu bytes.", (unsigned long) rewind_nbytes); pa_log_debug("Rewound %lu bytes.", (unsigned long) rewind_nbytes);
pa_sink_process_rewind(u->sink, rewind_nbytes); pa_sink_process_rewind(u->sink, rewind_nbytes);
@ -1086,7 +1133,9 @@ static void thread_func(void *userdata) {
for (;;) { for (;;) {
int ret; int ret;
/* pa_log_debug("loop"); */ #ifdef DEBUG_TIMING
pa_log_debug("Loop");
#endif
/* Render some data and write it to the dsp */ /* Render some data and write it to the dsp */
if (PA_SINK_IS_OPENED(u->sink->thread_info.state)) { if (PA_SINK_IS_OPENED(u->sink->thread_info.state)) {
@ -1132,7 +1181,7 @@ static void thread_func(void *userdata) {
* we have filled the buffer at least once * we have filled the buffer at least once
* completely.*/ * completely.*/
/*pa_log_debug("Cutting sleep time for the initial iterations by half.");*/ pa_log_debug("Cutting sleep time for the initial iterations by half.");
sleep_usec /= 2; sleep_usec /= 2;
} }
@ -1178,16 +1227,15 @@ static void thread_func(void *userdata) {
goto fail; goto fail;
} }
if (revents & (POLLIN|POLLERR|POLLNVAL|POLLHUP|POLLPRI)) { if (revents & ~POLLOUT) {
if (pa_alsa_recover_from_poll(u->pcm_handle, revents) < 0) if (pa_alsa_recover_from_poll(u->pcm_handle, revents) < 0)
goto fail; goto fail;
u->first = TRUE; u->first = TRUE;
u->since_start = 0; u->since_start = 0;
} } else if (revents && u->use_tsched && pa_log_ratelimit())
pa_log_debug("Wakeup from ALSA!");
if (revents && u->use_tsched && pa_log_ratelimit())
pa_log_debug("Wakeup from ALSA!%s%s", (revents & POLLIN) ? " INPUT" : "", (revents & POLLOUT) ? " OUTPUT" : "");
} else } else
revents = 0; revents = 0;
} }
@ -1382,11 +1430,8 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca
u->use_mmap = use_mmap; u->use_mmap = use_mmap;
u->use_tsched = use_tsched; u->use_tsched = use_tsched;
u->first = TRUE; u->first = TRUE;
u->since_start = 0;
u->after_rewind = FALSE;
u->rtpoll = pa_rtpoll_new(); u->rtpoll = pa_rtpoll_new();
pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll); pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
u->alsa_rtpoll_item = NULL;
u->smoother = pa_smoother_new(DEFAULT_TSCHED_BUFFER_USEC*2, DEFAULT_TSCHED_BUFFER_USEC*2, TRUE, 5); u->smoother = pa_smoother_new(DEFAULT_TSCHED_BUFFER_USEC*2, DEFAULT_TSCHED_BUFFER_USEC*2, TRUE, 5);
usec = pa_rtclock_usec(); usec = pa_rtclock_usec();
@ -1503,17 +1548,13 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca
u->fragment_size = frag_size = (uint32_t) (period_frames * frame_size); u->fragment_size = frag_size = (uint32_t) (period_frames * frame_size);
u->nfragments = nfrags; u->nfragments = nfrags;
u->hwbuf_size = u->fragment_size * nfrags; u->hwbuf_size = u->fragment_size * nfrags;
u->hwbuf_unused_frames = 0;
u->tsched_watermark = tsched_watermark; u->tsched_watermark = tsched_watermark;
u->frame_index = 0;
u->hw_dB_supported = FALSE;
u->hw_dB_min = u->hw_dB_max = 0;
u->hw_volume_min = u->hw_volume_max = 0;
u->mixer_seperate_channels = FALSE;
pa_cvolume_mute(&u->hardware_volume, u->sink->sample_spec.channels); pa_cvolume_mute(&u->hardware_volume, u->sink->sample_spec.channels);
if (use_tsched) if (use_tsched) {
fix_min_sleep_wakeup(u);
fix_tsched_watermark(u); fix_tsched_watermark(u);
}
u->sink->thread_info.max_rewind = use_tsched ? u->hwbuf_size : 0; u->sink->thread_info.max_rewind = use_tsched ? u->hwbuf_size : 0;
u->sink->thread_info.max_request = u->hwbuf_size; u->sink->thread_info.max_request = u->hwbuf_size;

305
src/modules/alsa/alsa-source.c
View file

@ -57,11 +57,13 @@
#include "alsa-util.h" #include "alsa-util.h"
#include "alsa-source.h" #include "alsa-source.h"
/* #define DEBUG_TIMING */
#define DEFAULT_DEVICE "default" #define DEFAULT_DEVICE "default"
#define DEFAULT_TSCHED_BUFFER_USEC (2*PA_USEC_PER_SEC) /* 2s */ #define DEFAULT_TSCHED_BUFFER_USEC (2*PA_USEC_PER_SEC) /* 2s */
#define DEFAULT_TSCHED_WATERMARK_USEC (20*PA_USEC_PER_MSEC) /* 20ms */ #define DEFAULT_TSCHED_WATERMARK_USEC (20*PA_USEC_PER_MSEC) /* 20ms */
#define TSCHED_MIN_SLEEP_USEC (3*PA_USEC_PER_MSEC) /* 3ms */ #define TSCHED_MIN_SLEEP_USEC (10*PA_USEC_PER_MSEC) /* 10ms */
#define TSCHED_MIN_WAKEUP_USEC (3*PA_USEC_PER_MSEC) /* 3ms */ #define TSCHED_MIN_WAKEUP_USEC (4*PA_USEC_PER_MSEC) /* 4ms */
struct userdata { struct userdata {
pa_core *core; pa_core *core;
@ -79,55 +81,85 @@ struct userdata {
snd_mixer_elem_t *mixer_elem; snd_mixer_elem_t *mixer_elem;
long hw_volume_max, hw_volume_min; long hw_volume_max, hw_volume_min;
long hw_dB_max, hw_dB_min; long hw_dB_max, hw_dB_min;
pa_bool_t hw_dB_supported; pa_bool_t hw_dB_supported:1;
pa_bool_t mixer_seperate_channels; pa_bool_t mixer_seperate_channels:1;
pa_cvolume hardware_volume; pa_cvolume hardware_volume;
size_t frame_size, fragment_size, hwbuf_size, tsched_watermark; size_t frame_size, fragment_size, hwbuf_size, tsched_watermark, hwbuf_unused, min_sleep, min_wakeup;
unsigned nfragments; unsigned nfragments;
char *device_name; char *device_name;
pa_bool_t use_mmap, use_tsched; pa_bool_t use_mmap:1, use_tsched:1;
pa_rtpoll_item *alsa_rtpoll_item; pa_rtpoll_item *alsa_rtpoll_item;
snd_mixer_selem_channel_id_t mixer_map[SND_MIXER_SCHN_LAST]; snd_mixer_selem_channel_id_t mixer_map[SND_MIXER_SCHN_LAST];
pa_smoother *smoother; pa_smoother *smoother;
int64_t frame_index; uint64_t read_count;
snd_pcm_sframes_t hwbuf_unused_frames;
}; };
static void userdata_free(struct userdata *u); static void userdata_free(struct userdata *u);
static void fix_tsched_watermark(struct userdata *u) { static void fix_min_sleep_wakeup(struct userdata *u) {
size_t max_use; size_t max_use, max_use_2;
size_t min_sleep, min_wakeup;
pa_assert(u); pa_assert(u);
max_use = u->hwbuf_size - (size_t) u->hwbuf_unused_frames * u->frame_size; max_use = u->hwbuf_size - u->hwbuf_unused;
max_use_2 = pa_frame_align(max_use/2, &u->source->sample_spec);
min_sleep = pa_usec_to_bytes(TSCHED_MIN_SLEEP_USEC, &u->source->sample_spec); u->min_sleep = pa_usec_to_bytes(TSCHED_MIN_SLEEP_USEC, &u->source->sample_spec);
min_wakeup = pa_usec_to_bytes(TSCHED_MIN_WAKEUP_USEC, &u->source->sample_spec); u->min_sleep = PA_CLAMP(u->min_sleep, u->frame_size, max_use_2);
if (min_sleep > max_use/2) u->min_wakeup = pa_usec_to_bytes(TSCHED_MIN_WAKEUP_USEC, &u->source->sample_spec);
min_sleep = pa_frame_align(max_use/2, &u->source->sample_spec); u->min_wakeup = PA_CLAMP(u->min_wakeup, u->frame_size, max_use_2);
if (min_sleep < u->frame_size) }
min_sleep = u->frame_size;
if (min_wakeup > max_use/2) static void fix_tsched_watermark(struct userdata *u) {
min_wakeup = pa_frame_align(max_use/2, &u->source->sample_spec); size_t max_use;
if (min_wakeup < u->frame_size) pa_assert(u);
min_wakeup = u->frame_size;
if (u->tsched_watermark > max_use-min_sleep) max_use = u->hwbuf_size - u->hwbuf_unused;
u->tsched_watermark = max_use-min_sleep;
if (u->tsched_watermark < min_wakeup) if (u->tsched_watermark > max_use - u->min_sleep)
u->tsched_watermark = min_wakeup; u->tsched_watermark = max_use - u->min_sleep;
if (u->tsched_watermark < u->min_wakeup)
u->tsched_watermark = u->min_wakeup;
}
static void adjust_after_overrun(struct userdata *u) {
size_t old_watermark;
pa_usec_t old_min_latency, new_min_latency;
pa_assert(u);
/* First, just try to increase the watermark */
old_watermark = u->tsched_watermark;
u->tsched_watermark *= 2;
fix_tsched_watermark(u);
if (old_watermark != u->tsched_watermark) {
pa_log_notice("Increasing wakeup watermark to %0.2f ms",
(double) pa_bytes_to_usec(u->tsched_watermark, &u->source->sample_spec) / PA_USEC_PER_MSEC);
return;
}
/* Hmm, we cannot increase the watermark any further, hence let's raise the latency */
old_min_latency = u->source->thread_info.min_latency;
new_min_latency = PA_MIN(old_min_latency * 2, u->source->thread_info.max_latency);
if (old_min_latency != new_min_latency) {
pa_log_notice("Increasing minimal latency to %0.2f ms",
(double) new_min_latency / PA_USEC_PER_MSEC);
pa_source_update_latency_range(u->source, new_min_latency, u->source->thread_info.max_latency);
return;
}
/* When we reach this we're officialy fucked! */
} }
static pa_usec_t hw_sleep_time(struct userdata *u, pa_usec_t *sleep_usec, pa_usec_t*process_usec) { static pa_usec_t hw_sleep_time(struct userdata *u, pa_usec_t *sleep_usec, pa_usec_t*process_usec) {
@ -140,17 +172,20 @@ static pa_usec_t hw_sleep_time(struct userdata *u, pa_usec_t *sleep_usec, pa_use
if (usec == (pa_usec_t) -1) if (usec == (pa_usec_t) -1)
usec = pa_bytes_to_usec(u->hwbuf_size, &u->source->sample_spec); usec = pa_bytes_to_usec(u->hwbuf_size, &u->source->sample_spec);
/* pa_log_debug("hw buffer time: %u ms", (unsigned) (usec / PA_USEC_PER_MSEC)); */
wm = pa_bytes_to_usec(u->tsched_watermark, &u->source->sample_spec); wm = pa_bytes_to_usec(u->tsched_watermark, &u->source->sample_spec);
if (usec >= wm) { if (wm > usec)
*sleep_usec = usec - wm; wm = usec/2;
*process_usec = wm;
} else
*process_usec = *sleep_usec = usec /= 2;
/* pa_log_debug("after watermark: %u ms", (unsigned) (*sleep_usec / PA_USEC_PER_MSEC)); */ *sleep_usec = usec - wm;
*process_usec = wm;
#ifdef DEBUG_TIMING
pa_log_debug("Buffer time: %lu ms; Sleep time: %lu ms; Process time: %lu ms",
(unsigned long) (usec / PA_USEC_PER_MSEC),
(unsigned long) (*sleep_usec / PA_USEC_PER_MSEC),
(unsigned long) (*process_usec / PA_USEC_PER_MSEC));
#endif
return usec; return usec;
} }
@ -167,47 +202,50 @@ static int try_recover(struct userdata *u, const char *call, int err) {
if (err == -EPIPE) if (err == -EPIPE)
pa_log_debug("%s: Buffer overrun!", call); pa_log_debug("%s: Buffer overrun!", call);
if ((err = snd_pcm_recover(u->pcm_handle, err, 1)) == 0) { if ((err = snd_pcm_recover(u->pcm_handle, err, 1)) < 0) {
snd_pcm_start(u->pcm_handle); pa_log("%s: %s", call, snd_strerror(err));
return 0; return -1;
} }
pa_log("%s: %s", call, snd_strerror(err)); snd_pcm_start(u->pcm_handle);
return -1; return 0;
} }
static size_t check_left_to_record(struct userdata *u, snd_pcm_sframes_t n) { static size_t check_left_to_record(struct userdata *u, size_t n_bytes) {
size_t left_to_record; size_t left_to_record;
size_t rec_space = u->hwbuf_size - (size_t) u->hwbuf_unused_frames*u->frame_size; size_t rec_space = u->hwbuf_size - u->hwbuf_unused;
if ((size_t) n*u->frame_size < rec_space) /* We use <= instead of < for this check here because an overrun
left_to_record = rec_space - ((size_t) n*u->frame_size); * only happens after the last sample was processed, not already when
else * it is removed from the buffer. This is particularly important
* when block transfer is used. */
if (n_bytes <= rec_space) {
left_to_record = rec_space - n_bytes;
#ifdef DEBUG_TIMING
pa_log_debug("%0.2f ms left to record", (double) pa_bytes_to_usec(left_to_record, &u->source->sample_spec) / PA_USEC_PER_MSEC);
#endif
} else {
left_to_record = 0; left_to_record = 0;
if (left_to_record > 0) { #ifdef DEBUG_TIMING
/* pa_log_debug("%0.2f ms left to record", (double) pa_bytes_to_usec(left_to_record, &u->source->sample_spec) / PA_USEC_PER_MSEC); */ PA_DEBUG_TRAP;
} else { #endif
if (pa_log_ratelimit()) if (pa_log_ratelimit())
pa_log_info("Overrun!"); pa_log_info("Overrun!");
if (u->use_tsched) { if (u->use_tsched)
size_t old_watermark = u->tsched_watermark; adjust_after_overrun(u);
u->tsched_watermark *= 2;
fix_tsched_watermark(u);
if (old_watermark != u->tsched_watermark)
pa_log_notice("Increasing wakeup watermark to %0.2f ms",
(double) pa_bytes_to_usec(u->tsched_watermark, &u->source->sample_spec) / PA_USEC_PER_MSEC);
}
} }
return left_to_record; return left_to_record;
} }
static int mmap_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled) { static int mmap_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled) {
int work_done = 0; pa_bool_t work_done = FALSE;
pa_usec_t max_sleep_usec = 0, process_usec = 0; pa_usec_t max_sleep_usec = 0, process_usec = 0;
size_t left_to_record; size_t left_to_record;
@ -219,45 +257,63 @@ static int mmap_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled
for (;;) { for (;;) {
snd_pcm_sframes_t n; snd_pcm_sframes_t n;
size_t n_bytes;
int r; int r;
snd_pcm_hwsync(u->pcm_handle); if (PA_UNLIKELY((n = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->source->sample_spec)) < 0)) {
if (PA_UNLIKELY((n = pa_alsa_safe_avail_update(u->pcm_handle, u->hwbuf_size, &u->source->sample_spec)) < 0)) { if ((r = try_recover(u, "snd_pcm_avail", (int) n)) == 0)
if ((r = try_recover(u, "snd_pcm_avail_update", (int) n)) == 0)
continue; continue;
return r; return r;
} }
left_to_record = check_left_to_record(u, n); n_bytes = (size_t) n * u->frame_size;
#ifdef DEBUG_TIMING
pa_log_debug("avail: %lu", (unsigned long) n_bytes);
#endif
left_to_record = check_left_to_record(u, n_bytes);
if (u->use_tsched) if (u->use_tsched)
if (!polled && if (!polled &&
pa_bytes_to_usec(left_to_record, &u->source->sample_spec) > process_usec+max_sleep_usec/2) pa_bytes_to_usec(left_to_record, &u->source->sample_spec) > process_usec+max_sleep_usec/2) {
#ifdef DEBUG_TIMING
pa_log_debug("Not reading, because too early.");
#endif
break; break;
}
if (PA_UNLIKELY(n <= 0)) { if (PA_UNLIKELY(n_bytes <= 0)) {
if (polled && pa_log_ratelimit()) if (polled && pa_log_ratelimit())
pa_log(_("ALSA woke us up to read new data from the device, but there was actually nothing to read! " pa_log(_("ALSA woke us up to read new data from the device, but there was actually nothing to read! "
"Most likely this is an ALSA driver bug. Please report this issue to the ALSA developers. " "Most likely this is an ALSA driver bug. Please report this issue to the ALSA developers. "
"We were woken up with POLLIN set -- however a subsequent snd_pcm_avail_update() returned 0.")); "We were woken up with POLLIN set -- however a subsequent snd_pcm_avail_update() returned 0."));
#ifdef DEBUG_TIMING
pa_log_debug("Not reading, because not necessary.");
#endif
break; break;
} }
polled = FALSE; polled = FALSE;
#ifdef DEBUG_TIMING
pa_log_debug("Reading");
#endif
for (;;) { for (;;) {
int err; int err;
const snd_pcm_channel_area_t *areas; const snd_pcm_channel_area_t *areas;
snd_pcm_uframes_t offset, frames = (snd_pcm_uframes_t) n; snd_pcm_uframes_t offset, frames;
pa_memchunk chunk; pa_memchunk chunk;
void *p; void *p;
snd_pcm_sframes_t sframes; snd_pcm_sframes_t sframes;
frames = (snd_pcm_uframes_t) (n_bytes / u->frame_size);
/* pa_log_debug("%lu frames to read", (unsigned long) frames); */ /* pa_log_debug("%lu frames to read", (unsigned long) frames); */
if (PA_UNLIKELY((err = pa_alsa_safe_mmap_begin(u->pcm_handle, &areas, &offset, &frames, u->hwbuf_size, &u->source->sample_spec)) < 0)) { if (PA_UNLIKELY((err = pa_alsa_safe_mmap_begin(u->pcm_handle, &areas, &offset, &frames, u->hwbuf_size, &u->source->sample_spec)) < 0)) {
@ -297,25 +353,27 @@ static int mmap_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled
return r; return r;
} }
work_done = 1; work_done = TRUE;
u->frame_index += (int64_t) frames; u->read_count += frames * u->frame_size;
/* pa_log_debug("read %lu frames", (unsigned long) frames); */ #ifdef DEBUG_TIMING
pa_log_debug("Read %lu bytes", (unsigned long) (frames * u->frame_size));
#endif
if (frames >= (snd_pcm_uframes_t) n) if ((size_t) frames * u->frame_size >= n_bytes)
break; break;
n -= (snd_pcm_sframes_t) frames; n_bytes -= (size_t) frames * u->frame_size;
} }
} }
*sleep_usec = pa_bytes_to_usec(left_to_record, &u->source->sample_spec) - process_usec; *sleep_usec = pa_bytes_to_usec(left_to_record, &u->source->sample_spec) - process_usec;
return work_done; return work_done ? 1 : 0;
} }
static int unix_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled) { static int unix_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled) {
int work_done = 0; int work_done = FALSE;
pa_usec_t max_sleep_usec = 0, process_usec = 0; pa_usec_t max_sleep_usec = 0, process_usec = 0;
size_t left_to_record; size_t left_to_record;
@ -327,33 +385,33 @@ static int unix_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled
for (;;) { for (;;) {
snd_pcm_sframes_t n; snd_pcm_sframes_t n;
size_t n_bytes;
int r; int r;
snd_pcm_hwsync(u->pcm_handle); if (PA_UNLIKELY((n = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->source->sample_spec)) < 0)) {
if (PA_UNLIKELY((n = pa_alsa_safe_avail_update(u->pcm_handle, u->hwbuf_size, &u->source->sample_spec)) < 0)) { if ((r = try_recover(u, "snd_pcm_avail", (int) n)) == 0)
if ((r = try_recover(u, "snd_pcm_avail_update", (int) n)) == 0)
continue; continue;
return r; return r;
} }
left_to_record = check_left_to_record(u, n); n_bytes = (size_t) n * u->frame_size;
left_to_record = check_left_to_record(u, n_bytes);
if (u->use_tsched) if (u->use_tsched)
if (!polled && if (!polled &&
pa_bytes_to_usec(left_to_record, &u->source->sample_spec) > process_usec+max_sleep_usec/2) pa_bytes_to_usec(left_to_record, &u->source->sample_spec) > process_usec+max_sleep_usec/2)
break; break;
if (PA_UNLIKELY(n <= 0)) { if (PA_UNLIKELY(n_bytes <= 0)) {
if (polled && pa_log_ratelimit()) if (polled && pa_log_ratelimit())
pa_log(_("ALSA woke us up to read new data from the device, but there was actually nothing to read! " pa_log(_("ALSA woke us up to read new data from the device, but there was actually nothing to read! "
"Most likely this is an ALSA driver bug. Please report this issue to the ALSA developers. " "Most likely this is an ALSA driver bug. Please report this issue to the ALSA developers. "
"We were woken up with POLLIN set -- however a subsequent snd_pcm_avail_update() returned 0.")); "We were woken up with POLLIN set -- however a subsequent snd_pcm_avail_update() returned 0."));
return work_done; break;
} }
polled = FALSE; polled = FALSE;
@ -367,8 +425,8 @@ static int unix_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled
frames = (snd_pcm_sframes_t) (pa_memblock_get_length(chunk.memblock) / u->frame_size); frames = (snd_pcm_sframes_t) (pa_memblock_get_length(chunk.memblock) / u->frame_size);
if (frames > n) if (frames > (snd_pcm_sframes_t) (n_bytes/u->frame_size))
frames = n; frames = (snd_pcm_sframes_t) (n_bytes/u->frame_size);
/* pa_log_debug("%lu frames to read", (unsigned long) n); */ /* pa_log_debug("%lu frames to read", (unsigned long) n); */
@ -393,53 +451,63 @@ static int unix_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled
pa_source_post(u->source, &chunk); pa_source_post(u->source, &chunk);
pa_memblock_unref(chunk.memblock); pa_memblock_unref(chunk.memblock);
work_done = 1; work_done = TRUE;
u->frame_index += frames; u->read_count += frames * u->frame_size;
/* pa_log_debug("read %lu frames", (unsigned long) frames); */ /* pa_log_debug("read %lu frames", (unsigned long) frames); */
if (frames >= n) if ((size_t) frames * u->frame_size >= n_bytes)
break; break;
n -= frames; n_bytes -= (size_t) frames * u->frame_size;
} }
} }
*sleep_usec = pa_bytes_to_usec(left_to_record, &u->source->sample_spec) - process_usec; *sleep_usec = pa_bytes_to_usec(left_to_record, &u->source->sample_spec) - process_usec;
return work_done; return work_done ? 1 : 0;
} }
static void update_smoother(struct userdata *u) { static void update_smoother(struct userdata *u) {
snd_pcm_sframes_t delay = 0; snd_pcm_sframes_t delay = 0;
int64_t frames; uint64_t position;
int err; int err;
pa_usec_t now1, now2; pa_usec_t now1 = 0, now2;
snd_pcm_status_t *status;
snd_pcm_status_alloca(&status);
pa_assert(u); pa_assert(u);
pa_assert(u->pcm_handle); pa_assert(u->pcm_handle);
/* Let's update the time smoother */ /* Let's update the time smoother */
snd_pcm_hwsync(u->pcm_handle);
snd_pcm_avail_update(u->pcm_handle);
if (PA_UNLIKELY((err = snd_pcm_delay(u->pcm_handle, &delay)) < 0)) { if (PA_UNLIKELY((err = snd_pcm_delay(u->pcm_handle, &delay)) < 0)) {
pa_log_warn("Failed to get delay: %s", snd_strerror(err)); pa_log_warn("Failed to get delay: %s", snd_strerror(err));
return; return;
} }
frames = u->frame_index + delay; if (PA_UNLIKELY((err = snd_pcm_status(u->pcm_handle, status)) < 0))
pa_log_warn("Failed to get timestamp: %s", snd_strerror(err));
else {
snd_htimestamp_t htstamp = { 0, 0 };
snd_pcm_status_get_htstamp(status, &htstamp);
now1 = pa_timespec_load(&htstamp);
}
now1 = pa_rtclock_usec(); position = u->read_count + ((uint64_t) delay * (uint64_t) u->frame_size);
now2 = pa_bytes_to_usec((uint64_t) frames * u->frame_size, &u->source->sample_spec);
/* Hmm, if the timestamp is 0, then it wasn't set and we take the current time */
if (now1 <= 0)
now1 = pa_rtclock_usec();
now2 = pa_bytes_to_usec(position, &u->source->sample_spec);
pa_smoother_put(u->smoother, now1, now2); pa_smoother_put(u->smoother, now1, now2);
} }
static pa_usec_t source_get_latency(struct userdata *u) { static pa_usec_t source_get_latency(struct userdata *u) {
pa_usec_t r = 0; int64_t delay;
int64_t delay;
pa_usec_t now1, now2; pa_usec_t now1, now2;
pa_assert(u); pa_assert(u);
@ -447,12 +515,9 @@ static pa_usec_t source_get_latency(struct userdata *u) {
now1 = pa_rtclock_usec(); now1 = pa_rtclock_usec();
now2 = pa_smoother_get(u->smoother, now1); now2 = pa_smoother_get(u->smoother, now1);
delay = (int64_t) now2 - (int64_t) pa_bytes_to_usec((uint64_t) u->frame_index * u->frame_size, &u->source->sample_spec); delay = (int64_t) now2 - (int64_t) pa_bytes_to_usec(u->read_count, &u->source->sample_spec);
if (delay > 0) return delay >= 0 ? (pa_usec_t) delay : 0;
r = (pa_usec_t) delay;
return r;
} }
static int build_pollfd(struct userdata *u) { static int build_pollfd(struct userdata *u) {
@ -495,7 +560,7 @@ static int update_sw_params(struct userdata *u) {
pa_assert(u); pa_assert(u);
/* Use the full buffer if noone asked us for anything specific */ /* Use the full buffer if noone asked us for anything specific */
u->hwbuf_unused_frames = 0; u->hwbuf_unused = 0;
if (u->use_tsched) { if (u->use_tsched) {
pa_usec_t latency; pa_usec_t latency;
@ -512,15 +577,14 @@ static int update_sw_params(struct userdata *u) {
if (PA_UNLIKELY(b < u->frame_size)) if (PA_UNLIKELY(b < u->frame_size))
b = u->frame_size; b = u->frame_size;
u->hwbuf_unused_frames = (snd_pcm_sframes_t) u->hwbuf_unused = PA_LIKELY(b < u->hwbuf_size) ? (u->hwbuf_size - b) : 0;
(PA_LIKELY(b < u->hwbuf_size) ?
((u->hwbuf_size - b) / u->frame_size) : 0);
} }
fix_min_sleep_wakeup(u);
fix_tsched_watermark(u); fix_tsched_watermark(u);
} }
pa_log_debug("hwbuf_unused_frames=%lu", (unsigned long) u->hwbuf_unused_frames); pa_log_debug("hwbuf_unused=%lu", (unsigned long) u->hwbuf_unused);
avail_min = 1; avail_min = 1;
@ -952,11 +1016,13 @@ static void thread_func(void *userdata) {
for (;;) { for (;;) {
int ret; int ret;
/* pa_log_debug("loop"); */ #ifdef DEBUG_TIMING
pa_log_debug("Loop");
#endif
/* Read some data and pass it to the sources */ /* Read some data and pass it to the sources */
if (PA_SOURCE_IS_OPENED(u->source->thread_info.state)) { if (PA_SOURCE_IS_OPENED(u->source->thread_info.state)) {
int work_done = 0; int work_done;
pa_usec_t sleep_usec = 0; pa_usec_t sleep_usec = 0;
if (u->use_mmap) if (u->use_mmap)
@ -1014,15 +1080,14 @@ static void thread_func(void *userdata) {
goto fail; goto fail;
} }
if (revents & (POLLOUT|POLLERR|POLLNVAL|POLLHUP|POLLPRI)) { if (revents & ~POLLIN) {
if (pa_alsa_recover_from_poll(u->pcm_handle, revents) < 0) if (pa_alsa_recover_from_poll(u->pcm_handle, revents) < 0)
goto fail; goto fail;
snd_pcm_start(u->pcm_handle); snd_pcm_start(u->pcm_handle);
} } else if (revents && u->use_tsched && pa_log_ratelimit())
pa_log_debug("Wakeup from ALSA!");
if (revents && u->use_tsched && pa_log_ratelimit())
pa_log_debug("Wakeup from ALSA!%s%s", (revents & POLLIN) ? " INPUT" : "", (revents & POLLOUT) ? " OUTPUT" : "");
} else } else
revents = 0; revents = 0;
} }
@ -1219,7 +1284,7 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p
pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll); pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
u->alsa_rtpoll_item = NULL; u->alsa_rtpoll_item = NULL;
u->smoother = pa_smoother_new(DEFAULT_TSCHED_WATERMARK_USEC, DEFAULT_TSCHED_WATERMARK_USEC, TRUE, 5); u->smoother = pa_smoother_new(DEFAULT_TSCHED_WATERMARK_USEC*2, DEFAULT_TSCHED_WATERMARK_USEC*2, TRUE, 5);
pa_smoother_set_time_offset(u->smoother, pa_rtclock_usec()); pa_smoother_set_time_offset(u->smoother, pa_rtclock_usec());
b = use_mmap; b = use_mmap;
@ -1329,17 +1394,13 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p
u->fragment_size = frag_size = (uint32_t) (period_frames * frame_size); u->fragment_size = frag_size = (uint32_t) (period_frames * frame_size);
u->nfragments = nfrags; u->nfragments = nfrags;
u->hwbuf_size = u->fragment_size * nfrags; u->hwbuf_size = u->fragment_size * nfrags;
u->hwbuf_unused_frames = 0;
u->tsched_watermark = tsched_watermark; u->tsched_watermark = tsched_watermark;
u->frame_index = 0;
u->hw_dB_supported = FALSE;
u->hw_dB_min = u->hw_dB_max = 0;
u->hw_volume_min = u->hw_volume_max = 0;
u->mixer_seperate_channels = FALSE;
pa_cvolume_mute(&u->hardware_volume, u->source->sample_spec.channels); pa_cvolume_mute(&u->hardware_volume, u->source->sample_spec.channels);
if (use_tsched) if (use_tsched) {
fix_min_sleep_wakeup(u);
fix_tsched_watermark(u); fix_tsched_watermark(u);
}
pa_source_set_latency_range(u->source, pa_source_set_latency_range(u->source,
!use_tsched ? pa_bytes_to_usec(u->hwbuf_size, &ss) : (pa_usec_t) -1, !use_tsched ? pa_bytes_to_usec(u->hwbuf_size, &ss) : (pa_usec_t) -1,

22
src/modules/alsa/alsa-util.c
View file

@ -465,6 +465,7 @@ finish:
int pa_alsa_set_sw_params(snd_pcm_t *pcm, snd_pcm_uframes_t avail_min) { int pa_alsa_set_sw_params(snd_pcm_t *pcm, snd_pcm_uframes_t avail_min) {
snd_pcm_sw_params_t *swparams; snd_pcm_sw_params_t *swparams;
snd_pcm_uframes_t boundary;
int err; int err;
pa_assert(pcm); pa_assert(pcm);
@ -476,7 +477,22 @@ int pa_alsa_set_sw_params(snd_pcm_t *pcm, snd_pcm_uframes_t avail_min) {
return err; return err;
} }
if ((err = snd_pcm_sw_params_set_stop_threshold(pcm, swparams, (snd_pcm_uframes_t) -1)) < 0) { if ((err = snd_pcm_sw_params_set_period_event(pcm, swparams, 0)) < 0) {
pa_log_warn("Unable to disable period event: %s\n", snd_strerror(err));
return err;
}
if ((err = snd_pcm_sw_params_set_tstamp_mode(pcm, swparams, SND_PCM_TSTAMP_ENABLE)) < 0) {
pa_log_warn("Unable to enable time stamping: %s\n", snd_strerror(err));
return err;
}
if ((err = snd_pcm_sw_params_get_boundary(swparams, &boundary)) < 0) {
pa_log_warn("Unable to get boundary: %s\n", snd_strerror(err));
return err;
}
if ((err = snd_pcm_sw_params_set_stop_threshold(pcm, swparams, boundary)) < 0) {
pa_log_warn("Unable to set stop threshold: %s\n", snd_strerror(err)); pa_log_warn("Unable to set stop threshold: %s\n", snd_strerror(err));
return err; return err;
} }
@ -1534,7 +1550,7 @@ pa_rtpoll_item* pa_alsa_build_pollfd(snd_pcm_t *pcm, pa_rtpoll *rtpoll) {
return item; return item;
} }
snd_pcm_sframes_t pa_alsa_safe_avail_update(snd_pcm_t *pcm, size_t hwbuf_size, const pa_sample_spec *ss) { snd_pcm_sframes_t pa_alsa_safe_avail(snd_pcm_t *pcm, size_t hwbuf_size, const pa_sample_spec *ss) {
snd_pcm_sframes_t n; snd_pcm_sframes_t n;
size_t k; size_t k;
@ -1545,7 +1561,7 @@ snd_pcm_sframes_t pa_alsa_safe_avail_update(snd_pcm_t *pcm, size_t hwbuf_size, c
/* Some ALSA driver expose weird bugs, let's inform the user about /* Some ALSA driver expose weird bugs, let's inform the user about
* what is going on */ * what is going on */
n = snd_pcm_avail_update(pcm); n = snd_pcm_avail(pcm);
if (n <= 0) if (n <= 0)
return n; return n;

2
src/modules/alsa/alsa-util.h
View file

@ -128,7 +128,7 @@ 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); pa_rtpoll_item* pa_alsa_build_pollfd(snd_pcm_t *pcm, pa_rtpoll *rtpoll);
snd_pcm_sframes_t pa_alsa_safe_avail_update(snd_pcm_t *pcm, size_t hwbuf_size, const pa_sample_spec *ss); snd_pcm_sframes_t pa_alsa_safe_avail(snd_pcm_t *pcm, size_t hwbuf_size, const pa_sample_spec *ss);
int pa_alsa_safe_mmap_begin(snd_pcm_t *pcm, const snd_pcm_channel_area_t **areas, snd_pcm_uframes_t *offset, snd_pcm_uframes_t *frames, size_t hwbuf_size, const pa_sample_spec *ss); int pa_alsa_safe_mmap_begin(snd_pcm_t *pcm, const snd_pcm_channel_area_t **areas, snd_pcm_uframes_t *offset, snd_pcm_uframes_t *frames, size_t hwbuf_size, const pa_sample_spec *ss);
char *pa_alsa_get_driver_name(int card); char *pa_alsa_get_driver_name(int card);