2 This file is part of PulseAudio.
4 Copyright 2004-2008 Lennart Poettering
5 Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
7 PulseAudio is free software; you can redistribute it and/or modify
8 it under the terms of the GNU Lesser General Public License as published
9 by the Free Software Foundation; either version 2.1 of the License,
10 or (at your option) any later version.
12 PulseAudio is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public License
18 along with PulseAudio; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
29 #include <asoundlib.h>
31 #ifdef HAVE_VALGRIND_MEMCHECK_H
32 #include <valgrind/memcheck.h>
35 #include <pulse/i18n.h>
36 #include <pulse/rtclock.h>
37 #include <pulse/timeval.h>
38 #include <pulse/util.h>
39 #include <pulse/xmalloc.h>
41 #include <pulsecore/core.h>
42 #include <pulsecore/module.h>
43 #include <pulsecore/memchunk.h>
44 #include <pulsecore/sink.h>
45 #include <pulsecore/modargs.h>
46 #include <pulsecore/core-rtclock.h>
47 #include <pulsecore/core-util.h>
48 #include <pulsecore/sample-util.h>
49 #include <pulsecore/log.h>
50 #include <pulsecore/macro.h>
51 #include <pulsecore/thread.h>
52 #include <pulsecore/core-error.h>
53 #include <pulsecore/thread-mq.h>
54 #include <pulsecore/rtpoll.h>
55 #include <pulsecore/time-smoother.h>
57 #include <modules/reserve-wrap.h>
59 #include "alsa-util.h"
60 #include "alsa-sink.h"
62 /* #define DEBUG_TIMING */
64 #define DEFAULT_DEVICE "default"
66 #define DEFAULT_TSCHED_BUFFER_USEC (2*PA_USEC_PER_SEC) /* 2s -- Overall buffer size */
67 #define DEFAULT_TSCHED_WATERMARK_USEC (20*PA_USEC_PER_MSEC) /* 20ms -- Fill up when only this much is left in the buffer */
69 #define TSCHED_WATERMARK_INC_STEP_USEC (10*PA_USEC_PER_MSEC) /* 10ms -- On underrun, increase watermark by this */
70 #define TSCHED_WATERMARK_DEC_STEP_USEC (5*PA_USEC_PER_MSEC) /* 5ms -- When everything's great, decrease watermark by this */
71 #define TSCHED_WATERMARK_VERIFY_AFTER_USEC (20*PA_USEC_PER_SEC) /* 20s -- How long after a drop out recheck if things are good now */
72 #define TSCHED_WATERMARK_INC_THRESHOLD_USEC (0*PA_USEC_PER_MSEC) /* 0ms -- If the buffer level ever below this theshold, increase the watermark */
73 #define TSCHED_WATERMARK_DEC_THRESHOLD_USEC (100*PA_USEC_PER_MSEC) /* 100ms -- If the buffer level didn't drop below this theshold in the verification time, decrease the watermark */
75 /* Note that TSCHED_WATERMARK_INC_THRESHOLD_USEC == 0 means tht we
76 * will increase the watermark only if we hit a real underrun. */
78 #define TSCHED_MIN_SLEEP_USEC (10*PA_USEC_PER_MSEC) /* 10ms -- Sleep at least 10ms on each iteration */
79 #define TSCHED_MIN_WAKEUP_USEC (4*PA_USEC_PER_MSEC) /* 4ms -- Wakeup at least this long before the buffer runs empty*/
81 #define SMOOTHER_WINDOW_USEC (10*PA_USEC_PER_SEC) /* 10s -- smoother windows size */
82 #define SMOOTHER_ADJUST_USEC (1*PA_USEC_PER_SEC) /* 1s -- smoother adjust time */
84 #define SMOOTHER_MIN_INTERVAL (2*PA_USEC_PER_MSEC) /* 2ms -- min smoother update interval */
85 #define SMOOTHER_MAX_INTERVAL (200*PA_USEC_PER_MSEC) /* 200ms -- max smoother update interval */
87 #define VOLUME_ACCURACY (PA_VOLUME_NORM/100) /* don't require volume adjustments to be perfectly correct. don't necessarily extend granularity in software unless the differences get greater than this level */
89 #define DEFAULT_REWIND_SAFEGUARD_BYTES (256) /* 1.33ms @48kHz, should work for most hardware */
97 pa_thread_mq thread_mq;
100 snd_pcm_t *pcm_handle;
102 pa_alsa_fdlist *mixer_fdl;
103 snd_mixer_t *mixer_handle;
104 pa_alsa_path_set *mixer_path_set;
105 pa_alsa_path *mixer_path;
107 pa_cvolume hardware_volume;
119 watermark_inc_threshold,
120 watermark_dec_threshold,
123 pa_usec_t watermark_dec_not_before;
125 pa_memchunk memchunk;
127 char *device_name; /* name of the PCM device */
128 char *control_device; /* name of the control device */
130 pa_bool_t use_mmap:1, use_tsched:1;
132 pa_bool_t first, after_rewind;
134 pa_rtpoll_item *alsa_rtpoll_item;
136 snd_mixer_selem_channel_id_t mixer_map[SND_MIXER_SCHN_LAST];
138 pa_smoother *smoother;
139 uint64_t write_count;
140 uint64_t since_start;
141 pa_usec_t smoother_interval;
142 pa_usec_t last_smoother_update;
144 pa_reserve_wrapper *reserve;
145 pa_hook_slot *reserve_slot;
146 pa_reserve_monitor_wrapper *monitor;
147 pa_hook_slot *monitor_slot;
150 static void userdata_free(struct userdata *u);
152 static pa_hook_result_t reserve_cb(pa_reserve_wrapper *r, void *forced, struct userdata *u) {
156 if (pa_sink_suspend(u->sink, TRUE, PA_SUSPEND_APPLICATION) < 0)
157 return PA_HOOK_CANCEL;
162 static void reserve_done(struct userdata *u) {
165 if (u->reserve_slot) {
166 pa_hook_slot_free(u->reserve_slot);
167 u->reserve_slot = NULL;
171 pa_reserve_wrapper_unref(u->reserve);
176 static void reserve_update(struct userdata *u) {
177 const char *description;
180 if (!u->sink || !u->reserve)
183 if ((description = pa_proplist_gets(u->sink->proplist, PA_PROP_DEVICE_DESCRIPTION)))
184 pa_reserve_wrapper_set_application_device_name(u->reserve, description);
187 static int reserve_init(struct userdata *u, const char *dname) {
196 if (pa_in_system_mode())
199 if (!(rname = pa_alsa_get_reserve_name(dname)))
202 /* We are resuming, try to lock the device */
203 u->reserve = pa_reserve_wrapper_get(u->core, rname);
211 pa_assert(!u->reserve_slot);
212 u->reserve_slot = pa_hook_connect(pa_reserve_wrapper_hook(u->reserve), PA_HOOK_NORMAL, (pa_hook_cb_t) reserve_cb, u);
217 static pa_hook_result_t monitor_cb(pa_reserve_monitor_wrapper *w, void* busy, struct userdata *u) {
223 b = PA_PTR_TO_UINT(busy) && !u->reserve;
225 pa_sink_suspend(u->sink, b, PA_SUSPEND_APPLICATION);
229 static void monitor_done(struct userdata *u) {
232 if (u->monitor_slot) {
233 pa_hook_slot_free(u->monitor_slot);
234 u->monitor_slot = NULL;
238 pa_reserve_monitor_wrapper_unref(u->monitor);
243 static int reserve_monitor_init(struct userdata *u, const char *dname) {
249 if (pa_in_system_mode())
252 if (!(rname = pa_alsa_get_reserve_name(dname)))
255 u->monitor = pa_reserve_monitor_wrapper_get(u->core, rname);
261 pa_assert(!u->monitor_slot);
262 u->monitor_slot = pa_hook_connect(pa_reserve_monitor_wrapper_hook(u->monitor), PA_HOOK_NORMAL, (pa_hook_cb_t) monitor_cb, u);
267 static void fix_min_sleep_wakeup(struct userdata *u) {
268 size_t max_use, max_use_2;
271 pa_assert(u->use_tsched);
273 max_use = u->hwbuf_size - u->hwbuf_unused;
274 max_use_2 = pa_frame_align(max_use/2, &u->sink->sample_spec);
276 u->min_sleep = pa_usec_to_bytes(TSCHED_MIN_SLEEP_USEC, &u->sink->sample_spec);
277 u->min_sleep = PA_CLAMP(u->min_sleep, u->frame_size, max_use_2);
279 u->min_wakeup = pa_usec_to_bytes(TSCHED_MIN_WAKEUP_USEC, &u->sink->sample_spec);
280 u->min_wakeup = PA_CLAMP(u->min_wakeup, u->frame_size, max_use_2);
283 static void fix_tsched_watermark(struct userdata *u) {
286 pa_assert(u->use_tsched);
288 max_use = u->hwbuf_size - u->hwbuf_unused;
290 if (u->tsched_watermark > max_use - u->min_sleep)
291 u->tsched_watermark = max_use - u->min_sleep;
293 if (u->tsched_watermark < u->min_wakeup)
294 u->tsched_watermark = u->min_wakeup;
297 static void increase_watermark(struct userdata *u) {
298 size_t old_watermark;
299 pa_usec_t old_min_latency, new_min_latency;
302 pa_assert(u->use_tsched);
304 /* First, just try to increase the watermark */
305 old_watermark = u->tsched_watermark;
306 u->tsched_watermark = PA_MIN(u->tsched_watermark * 2, u->tsched_watermark + u->watermark_inc_step);
307 fix_tsched_watermark(u);
309 if (old_watermark != u->tsched_watermark) {
310 pa_log_info("Increasing wakeup watermark to %0.2f ms",
311 (double) pa_bytes_to_usec(u->tsched_watermark, &u->sink->sample_spec) / PA_USEC_PER_MSEC);
315 /* Hmm, we cannot increase the watermark any further, hence let's raise the latency */
316 old_min_latency = u->sink->thread_info.min_latency;
317 new_min_latency = PA_MIN(old_min_latency * 2, old_min_latency + TSCHED_WATERMARK_INC_STEP_USEC);
318 new_min_latency = PA_MIN(new_min_latency, u->sink->thread_info.max_latency);
320 if (old_min_latency != new_min_latency) {
321 pa_log_info("Increasing minimal latency to %0.2f ms",
322 (double) new_min_latency / PA_USEC_PER_MSEC);
324 pa_sink_set_latency_range_within_thread(u->sink, new_min_latency, u->sink->thread_info.max_latency);
327 /* When we reach this we're officialy fucked! */
330 static void decrease_watermark(struct userdata *u) {
331 size_t old_watermark;
335 pa_assert(u->use_tsched);
337 now = pa_rtclock_now();
339 if (u->watermark_dec_not_before <= 0)
342 if (u->watermark_dec_not_before > now)
345 old_watermark = u->tsched_watermark;
347 if (u->tsched_watermark < u->watermark_dec_step)
348 u->tsched_watermark = u->tsched_watermark / 2;
350 u->tsched_watermark = PA_MAX(u->tsched_watermark / 2, u->tsched_watermark - u->watermark_dec_step);
352 fix_tsched_watermark(u);
354 if (old_watermark != u->tsched_watermark)
355 pa_log_info("Decreasing wakeup watermark to %0.2f ms",
356 (double) pa_bytes_to_usec(u->tsched_watermark, &u->sink->sample_spec) / PA_USEC_PER_MSEC);
358 /* We don't change the latency range*/
361 u->watermark_dec_not_before = now + TSCHED_WATERMARK_VERIFY_AFTER_USEC;
364 static void hw_sleep_time(struct userdata *u, pa_usec_t *sleep_usec, pa_usec_t*process_usec) {
367 pa_assert(sleep_usec);
368 pa_assert(process_usec);
371 pa_assert(u->use_tsched);
373 usec = pa_sink_get_requested_latency_within_thread(u->sink);
375 if (usec == (pa_usec_t) -1)
376 usec = pa_bytes_to_usec(u->hwbuf_size, &u->sink->sample_spec);
378 wm = pa_bytes_to_usec(u->tsched_watermark, &u->sink->sample_spec);
383 *sleep_usec = usec - wm;
387 pa_log_debug("Buffer time: %lu ms; Sleep time: %lu ms; Process time: %lu ms",
388 (unsigned long) (usec / PA_USEC_PER_MSEC),
389 (unsigned long) (*sleep_usec / PA_USEC_PER_MSEC),
390 (unsigned long) (*process_usec / PA_USEC_PER_MSEC));
394 static int try_recover(struct userdata *u, const char *call, int err) {
399 pa_log_debug("%s: %s", call, pa_alsa_strerror(err));
401 pa_assert(err != -EAGAIN);
404 pa_log_debug("%s: Buffer underrun!", call);
406 if (err == -ESTRPIPE)
407 pa_log_debug("%s: System suspended!", call);
409 if ((err = snd_pcm_recover(u->pcm_handle, err, 1)) < 0) {
410 pa_log("%s: %s", call, pa_alsa_strerror(err));
419 static size_t check_left_to_play(struct userdata *u, size_t n_bytes, pa_bool_t on_timeout) {
421 pa_bool_t underrun = FALSE;
423 /* We use <= instead of < for this check here because an underrun
424 * only happens after the last sample was processed, not already when
425 * it is removed from the buffer. This is particularly important
426 * when block transfer is used. */
428 if (n_bytes <= u->hwbuf_size)
429 left_to_play = u->hwbuf_size - n_bytes;
432 /* We got a dropout. What a mess! */
440 if (!u->first && !u->after_rewind)
441 if (pa_log_ratelimit())
442 pa_log_info("Underrun!");
446 pa_log_debug("%0.2f ms left to play; inc threshold = %0.2f ms; dec threshold = %0.2f ms",
447 (double) pa_bytes_to_usec(left_to_play, &u->sink->sample_spec) / PA_USEC_PER_MSEC,
448 (double) pa_bytes_to_usec(u->watermark_inc_threshold, &u->sink->sample_spec) / PA_USEC_PER_MSEC,
449 (double) pa_bytes_to_usec(u->watermark_dec_threshold, &u->sink->sample_spec) / PA_USEC_PER_MSEC);
453 pa_bool_t reset_not_before = TRUE;
455 if (!u->first && !u->after_rewind) {
456 if (underrun || left_to_play < u->watermark_inc_threshold)
457 increase_watermark(u);
458 else if (left_to_play > u->watermark_dec_threshold) {
459 reset_not_before = FALSE;
461 /* We decrease the watermark only if have actually
462 * been woken up by a timeout. If something else woke
463 * us up it's too easy to fulfill the deadlines... */
466 decrease_watermark(u);
470 if (reset_not_before)
471 u->watermark_dec_not_before = 0;
477 static int mmap_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled, pa_bool_t on_timeout) {
478 pa_bool_t work_done = TRUE;
479 pa_usec_t max_sleep_usec = 0, process_usec = 0;
484 pa_sink_assert_ref(u->sink);
487 hw_sleep_time(u, &max_sleep_usec, &process_usec);
493 pa_bool_t after_avail = TRUE;
495 /* First we determine how many samples are missing to fill the
496 * buffer up to 100% */
498 if (PA_UNLIKELY((n = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->sink->sample_spec)) < 0)) {
500 if ((r = try_recover(u, "snd_pcm_avail", (int) n)) == 0)
506 n_bytes = (size_t) n * u->frame_size;
509 pa_log_debug("avail: %lu", (unsigned long) n_bytes);
512 left_to_play = check_left_to_play(u, n_bytes, on_timeout);
517 /* We won't fill up the playback buffer before at least
518 * half the sleep time is over because otherwise we might
519 * ask for more data from the clients then they expect. We
520 * need to guarantee that clients only have to keep around
521 * a single hw buffer length. */
524 pa_bytes_to_usec(left_to_play, &u->sink->sample_spec) > process_usec+max_sleep_usec/2) {
526 pa_log_debug("Not filling up, because too early.");
531 if (PA_UNLIKELY(n_bytes <= u->hwbuf_unused)) {
535 char *dn = pa_alsa_get_driver_name_by_pcm(u->pcm_handle);
536 pa_log(_("ALSA woke us up to write new data to the device, but there was actually nothing to write!\n"
537 "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers.\n"
538 "We were woken up with POLLOUT set -- however a subsequent snd_pcm_avail() returned 0 or another value < min_avail."),
544 pa_log_debug("Not filling up, because not necessary.");
552 pa_log_debug("Not filling up, because already too many iterations.");
558 n_bytes -= u->hwbuf_unused;
562 pa_log_debug("Filling up");
569 const snd_pcm_channel_area_t *areas;
570 snd_pcm_uframes_t offset, frames;
571 snd_pcm_sframes_t sframes;
573 frames = (snd_pcm_uframes_t) (n_bytes / u->frame_size);
574 /* pa_log_debug("%lu frames to write", (unsigned long) frames); */
576 if (PA_UNLIKELY((err = pa_alsa_safe_mmap_begin(u->pcm_handle, &areas, &offset, &frames, u->hwbuf_size, &u->sink->sample_spec)) < 0)) {
578 if (!after_avail && err == -EAGAIN)
581 if ((r = try_recover(u, "snd_pcm_mmap_begin", err)) == 0)
587 /* Make sure that if these memblocks need to be copied they will fit into one slot */
588 if (frames > pa_mempool_block_size_max(u->sink->core->mempool)/u->frame_size)
589 frames = pa_mempool_block_size_max(u->sink->core->mempool)/u->frame_size;
591 if (!after_avail && frames == 0)
594 pa_assert(frames > 0);
597 /* Check these are multiples of 8 bit */
598 pa_assert((areas[0].first & 7) == 0);
599 pa_assert((areas[0].step & 7)== 0);
601 /* We assume a single interleaved memory buffer */
602 pa_assert((areas[0].first >> 3) == 0);
603 pa_assert((areas[0].step >> 3) == u->frame_size);
605 p = (uint8_t*) areas[0].addr + (offset * u->frame_size);
607 chunk.memblock = pa_memblock_new_fixed(u->core->mempool, p, frames * u->frame_size, TRUE);
608 chunk.length = pa_memblock_get_length(chunk.memblock);
611 pa_sink_render_into_full(u->sink, &chunk);
612 pa_memblock_unref_fixed(chunk.memblock);
614 if (PA_UNLIKELY((sframes = snd_pcm_mmap_commit(u->pcm_handle, offset, frames)) < 0)) {
616 if (!after_avail && (int) sframes == -EAGAIN)
619 if ((r = try_recover(u, "snd_pcm_mmap_commit", (int) sframes)) == 0)
627 u->write_count += frames * u->frame_size;
628 u->since_start += frames * u->frame_size;
631 pa_log_debug("Wrote %lu bytes (of possible %lu bytes)", (unsigned long) (frames * u->frame_size), (unsigned long) n_bytes);
634 if ((size_t) frames * u->frame_size >= n_bytes)
637 n_bytes -= (size_t) frames * u->frame_size;
642 *sleep_usec = pa_bytes_to_usec(left_to_play, &u->sink->sample_spec);
644 if (*sleep_usec > process_usec)
645 *sleep_usec -= process_usec;
651 return work_done ? 1 : 0;
654 static int unix_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled, pa_bool_t on_timeout) {
655 pa_bool_t work_done = FALSE;
656 pa_usec_t max_sleep_usec = 0, process_usec = 0;
661 pa_sink_assert_ref(u->sink);
664 hw_sleep_time(u, &max_sleep_usec, &process_usec);
670 pa_bool_t after_avail = TRUE;
672 if (PA_UNLIKELY((n = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->sink->sample_spec)) < 0)) {
674 if ((r = try_recover(u, "snd_pcm_avail", (int) n)) == 0)
680 n_bytes = (size_t) n * u->frame_size;
681 left_to_play = check_left_to_play(u, n_bytes, on_timeout);
686 /* We won't fill up the playback buffer before at least
687 * half the sleep time is over because otherwise we might
688 * ask for more data from the clients then they expect. We
689 * need to guarantee that clients only have to keep around
690 * a single hw buffer length. */
693 pa_bytes_to_usec(left_to_play, &u->sink->sample_spec) > process_usec+max_sleep_usec/2)
696 if (PA_UNLIKELY(n_bytes <= u->hwbuf_unused)) {
700 char *dn = pa_alsa_get_driver_name_by_pcm(u->pcm_handle);
701 pa_log(_("ALSA woke us up to write new data to the device, but there was actually nothing to write!\n"
702 "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers.\n"
703 "We were woken up with POLLOUT set -- however a subsequent snd_pcm_avail() returned 0 or another value < min_avail."),
713 pa_log_debug("Not filling up, because already too many iterations.");
719 n_bytes -= u->hwbuf_unused;
723 snd_pcm_sframes_t frames;
726 /* pa_log_debug("%lu frames to write", (unsigned long) frames); */
728 if (u->memchunk.length <= 0)
729 pa_sink_render(u->sink, n_bytes, &u->memchunk);
731 pa_assert(u->memchunk.length > 0);
733 frames = (snd_pcm_sframes_t) (u->memchunk.length / u->frame_size);
735 if (frames > (snd_pcm_sframes_t) (n_bytes/u->frame_size))
736 frames = (snd_pcm_sframes_t) (n_bytes/u->frame_size);
738 p = pa_memblock_acquire(u->memchunk.memblock);
739 frames = snd_pcm_writei(u->pcm_handle, (const uint8_t*) p + u->memchunk.index, (snd_pcm_uframes_t) frames);
740 pa_memblock_release(u->memchunk.memblock);
742 if (PA_UNLIKELY(frames < 0)) {
744 if (!after_avail && (int) frames == -EAGAIN)
747 if ((r = try_recover(u, "snd_pcm_writei", (int) frames)) == 0)
753 if (!after_avail && frames == 0)
756 pa_assert(frames > 0);
759 u->memchunk.index += (size_t) frames * u->frame_size;
760 u->memchunk.length -= (size_t) frames * u->frame_size;
762 if (u->memchunk.length <= 0) {
763 pa_memblock_unref(u->memchunk.memblock);
764 pa_memchunk_reset(&u->memchunk);
769 u->write_count += frames * u->frame_size;
770 u->since_start += frames * u->frame_size;
772 /* pa_log_debug("wrote %lu frames", (unsigned long) frames); */
774 if ((size_t) frames * u->frame_size >= n_bytes)
777 n_bytes -= (size_t) frames * u->frame_size;
782 *sleep_usec = pa_bytes_to_usec(left_to_play, &u->sink->sample_spec);
784 if (*sleep_usec > process_usec)
785 *sleep_usec -= process_usec;
791 return work_done ? 1 : 0;
794 static void update_smoother(struct userdata *u) {
795 snd_pcm_sframes_t delay = 0;
798 pa_usec_t now1 = 0, now2;
799 snd_pcm_status_t *status;
801 snd_pcm_status_alloca(&status);
804 pa_assert(u->pcm_handle);
806 /* Let's update the time smoother */
808 if (PA_UNLIKELY((err = pa_alsa_safe_delay(u->pcm_handle, &delay, u->hwbuf_size, &u->sink->sample_spec, FALSE)) < 0)) {
809 pa_log_warn("Failed to query DSP status data: %s", pa_alsa_strerror(err));
813 if (PA_UNLIKELY((err = snd_pcm_status(u->pcm_handle, status)) < 0))
814 pa_log_warn("Failed to get timestamp: %s", pa_alsa_strerror(err));
816 snd_htimestamp_t htstamp = { 0, 0 };
817 snd_pcm_status_get_htstamp(status, &htstamp);
818 now1 = pa_timespec_load(&htstamp);
821 /* Hmm, if the timestamp is 0, then it wasn't set and we take the current time */
823 now1 = pa_rtclock_now();
825 /* check if the time since the last update is bigger than the interval */
826 if (u->last_smoother_update > 0)
827 if (u->last_smoother_update + u->smoother_interval > now1)
830 position = (int64_t) u->write_count - ((int64_t) delay * (int64_t) u->frame_size);
832 if (PA_UNLIKELY(position < 0))
835 now2 = pa_bytes_to_usec((uint64_t) position, &u->sink->sample_spec);
837 pa_smoother_put(u->smoother, now1, now2);
839 u->last_smoother_update = now1;
840 /* exponentially increase the update interval up to the MAX limit */
841 u->smoother_interval = PA_MIN (u->smoother_interval * 2, SMOOTHER_MAX_INTERVAL);
844 static pa_usec_t sink_get_latency(struct userdata *u) {
847 pa_usec_t now1, now2;
851 now1 = pa_rtclock_now();
852 now2 = pa_smoother_get(u->smoother, now1);
854 delay = (int64_t) pa_bytes_to_usec(u->write_count, &u->sink->sample_spec) - (int64_t) now2;
856 r = delay >= 0 ? (pa_usec_t) delay : 0;
858 if (u->memchunk.memblock)
859 r += pa_bytes_to_usec(u->memchunk.length, &u->sink->sample_spec);
864 static int build_pollfd(struct userdata *u) {
866 pa_assert(u->pcm_handle);
868 if (u->alsa_rtpoll_item)
869 pa_rtpoll_item_free(u->alsa_rtpoll_item);
871 if (!(u->alsa_rtpoll_item = pa_alsa_build_pollfd(u->pcm_handle, u->rtpoll)))
877 /* Called from IO context */
878 static int suspend(struct userdata *u) {
880 pa_assert(u->pcm_handle);
882 pa_smoother_pause(u->smoother, pa_rtclock_now());
884 /* Let's suspend -- we don't call snd_pcm_drain() here since that might
885 * take awfully long with our long buffer sizes today. */
886 snd_pcm_close(u->pcm_handle);
887 u->pcm_handle = NULL;
889 if (u->alsa_rtpoll_item) {
890 pa_rtpoll_item_free(u->alsa_rtpoll_item);
891 u->alsa_rtpoll_item = NULL;
894 /* We reset max_rewind/max_request here to make sure that while we
895 * are suspended the old max_request/max_rewind values set before
896 * the suspend can influence the per-stream buffer of newly
897 * created streams, without their requirements having any
898 * influence on them. */
899 pa_sink_set_max_rewind_within_thread(u->sink, 0);
900 pa_sink_set_max_request_within_thread(u->sink, 0);
902 pa_log_info("Device suspended...");
907 /* Called from IO context */
908 static int update_sw_params(struct userdata *u) {
909 snd_pcm_uframes_t avail_min;
914 /* Use the full buffer if noone asked us for anything specific */
920 if ((latency = pa_sink_get_requested_latency_within_thread(u->sink)) != (pa_usec_t) -1) {
923 pa_log_debug("Latency set to %0.2fms", (double) latency / PA_USEC_PER_MSEC);
925 b = pa_usec_to_bytes(latency, &u->sink->sample_spec);
927 /* We need at least one sample in our buffer */
929 if (PA_UNLIKELY(b < u->frame_size))
932 u->hwbuf_unused = PA_LIKELY(b < u->hwbuf_size) ? (u->hwbuf_size - b) : 0;
935 fix_min_sleep_wakeup(u);
936 fix_tsched_watermark(u);
939 pa_log_debug("hwbuf_unused=%lu", (unsigned long) u->hwbuf_unused);
941 /* We need at last one frame in the used part of the buffer */
942 avail_min = (snd_pcm_uframes_t) u->hwbuf_unused / u->frame_size + 1;
945 pa_usec_t sleep_usec, process_usec;
947 hw_sleep_time(u, &sleep_usec, &process_usec);
948 avail_min += pa_usec_to_bytes(sleep_usec, &u->sink->sample_spec) / u->frame_size;
951 pa_log_debug("setting avail_min=%lu", (unsigned long) avail_min);
953 if ((err = pa_alsa_set_sw_params(u->pcm_handle, avail_min, !u->use_tsched)) < 0) {
954 pa_log("Failed to set software parameters: %s", pa_alsa_strerror(err));
958 pa_sink_set_max_request_within_thread(u->sink, u->hwbuf_size - u->hwbuf_unused);
959 if (pa_alsa_pcm_is_hw(u->pcm_handle))
960 pa_sink_set_max_rewind_within_thread(u->sink, u->hwbuf_size);
962 pa_log_info("Disabling rewind_within_thread for device %s", u->device_name);
963 pa_sink_set_max_rewind_within_thread(u->sink, 0);
969 /* Called from IO context */
970 static int unsuspend(struct userdata *u) {
974 snd_pcm_uframes_t period_size, buffer_size;
977 pa_assert(!u->pcm_handle);
979 pa_log_info("Trying resume...");
981 if ((err = snd_pcm_open(&u->pcm_handle, u->device_name, SND_PCM_STREAM_PLAYBACK,
983 SND_PCM_NO_AUTO_RESAMPLE|
984 SND_PCM_NO_AUTO_CHANNELS|
985 SND_PCM_NO_AUTO_FORMAT)) < 0) {
986 pa_log("Error opening PCM device %s: %s", u->device_name, pa_alsa_strerror(err));
990 ss = u->sink->sample_spec;
991 period_size = u->fragment_size / u->frame_size;
992 buffer_size = u->hwbuf_size / u->frame_size;
996 if ((err = pa_alsa_set_hw_params(u->pcm_handle, &ss, &period_size, &buffer_size, 0, &b, &d, TRUE)) < 0) {
997 pa_log("Failed to set hardware parameters: %s", pa_alsa_strerror(err));
1001 if (b != u->use_mmap || d != u->use_tsched) {
1002 pa_log_warn("Resume failed, couldn't get original access mode.");
1006 if (!pa_sample_spec_equal(&ss, &u->sink->sample_spec)) {
1007 pa_log_warn("Resume failed, couldn't restore original sample settings.");
1011 if (period_size*u->frame_size != u->fragment_size ||
1012 buffer_size*u->frame_size != u->hwbuf_size) {
1013 pa_log_warn("Resume failed, couldn't restore original fragment settings. (Old: %lu/%lu, New %lu/%lu)",
1014 (unsigned long) u->hwbuf_size, (unsigned long) u->fragment_size,
1015 (unsigned long) (buffer_size*u->frame_size), (unsigned long) (period_size*u->frame_size));
1019 if (update_sw_params(u) < 0)
1022 if (build_pollfd(u) < 0)
1026 pa_smoother_reset(u->smoother, pa_rtclock_now(), TRUE);
1027 u->smoother_interval = SMOOTHER_MIN_INTERVAL;
1028 u->last_smoother_update = 0;
1033 pa_log_info("Resumed successfully...");
1038 if (u->pcm_handle) {
1039 snd_pcm_close(u->pcm_handle);
1040 u->pcm_handle = NULL;
1046 /* Called from IO context */
1047 static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
1048 struct userdata *u = PA_SINK(o)->userdata;
1052 case PA_SINK_MESSAGE_GET_LATENCY: {
1056 r = sink_get_latency(u);
1058 *((pa_usec_t*) data) = r;
1063 case PA_SINK_MESSAGE_SET_STATE:
1065 switch ((pa_sink_state_t) PA_PTR_TO_UINT(data)) {
1067 case PA_SINK_SUSPENDED: {
1070 pa_assert(PA_SINK_IS_OPENED(u->sink->thread_info.state));
1072 if ((r = suspend(u)) < 0)
1079 case PA_SINK_RUNNING: {
1082 if (u->sink->thread_info.state == PA_SINK_INIT) {
1083 if (build_pollfd(u) < 0)
1087 if (u->sink->thread_info.state == PA_SINK_SUSPENDED) {
1088 if ((r = unsuspend(u)) < 0)
1095 case PA_SINK_UNLINKED:
1097 case PA_SINK_INVALID_STATE:
1104 return pa_sink_process_msg(o, code, data, offset, chunk);
1107 /* Called from main context */
1108 static int sink_set_state_cb(pa_sink *s, pa_sink_state_t new_state) {
1109 pa_sink_state_t old_state;
1112 pa_sink_assert_ref(s);
1113 pa_assert_se(u = s->userdata);
1115 old_state = pa_sink_get_state(u->sink);
1117 if (PA_SINK_IS_OPENED(old_state) && new_state == PA_SINK_SUSPENDED)
1119 else if (old_state == PA_SINK_SUSPENDED && PA_SINK_IS_OPENED(new_state))
1120 if (reserve_init(u, u->device_name) < 0)
1121 return -PA_ERR_BUSY;
1126 static int mixer_callback(snd_mixer_elem_t *elem, unsigned int mask) {
1127 struct userdata *u = snd_mixer_elem_get_callback_private(elem);
1130 pa_assert(u->mixer_handle);
1132 if (mask == SND_CTL_EVENT_MASK_REMOVE)
1135 if (u->sink->suspend_cause & PA_SUSPEND_SESSION)
1138 if (mask & SND_CTL_EVENT_MASK_VALUE) {
1139 pa_sink_get_volume(u->sink, TRUE);
1140 pa_sink_get_mute(u->sink, TRUE);
1146 static void sink_get_volume_cb(pa_sink *s) {
1147 struct userdata *u = s->userdata;
1149 char t[PA_CVOLUME_SNPRINT_MAX];
1152 pa_assert(u->mixer_path);
1153 pa_assert(u->mixer_handle);
1155 if (pa_alsa_path_get_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r) < 0)
1158 /* Shift down by the base volume, so that 0dB becomes maximum volume */
1159 pa_sw_cvolume_multiply_scalar(&r, &r, s->base_volume);
1161 pa_log_debug("Read hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &r));
1163 if (pa_cvolume_equal(&u->hardware_volume, &r))
1166 s->real_volume = u->hardware_volume = r;
1168 /* Hmm, so the hardware volume changed, let's reset our software volume */
1169 if (u->mixer_path->has_dB)
1170 pa_sink_set_soft_volume(s, NULL);
1173 static void sink_set_volume_cb(pa_sink *s) {
1174 struct userdata *u = s->userdata;
1176 char t[PA_CVOLUME_SNPRINT_MAX];
1179 pa_assert(u->mixer_path);
1180 pa_assert(u->mixer_handle);
1182 /* Shift up by the base volume */
1183 pa_sw_cvolume_divide_scalar(&r, &s->real_volume, s->base_volume);
1185 if (pa_alsa_path_set_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r) < 0)
1188 /* Shift down by the base volume, so that 0dB becomes maximum volume */
1189 pa_sw_cvolume_multiply_scalar(&r, &r, s->base_volume);
1191 u->hardware_volume = r;
1193 if (u->mixer_path->has_dB) {
1194 pa_cvolume new_soft_volume;
1195 pa_bool_t accurate_enough;
1197 /* Match exactly what the user requested by software */
1198 pa_sw_cvolume_divide(&new_soft_volume, &s->real_volume, &u->hardware_volume);
1200 /* If the adjustment to do in software is only minimal we
1201 * can skip it. That saves us CPU at the expense of a bit of
1204 (pa_cvolume_min(&new_soft_volume) >= (PA_VOLUME_NORM - VOLUME_ACCURACY)) &&
1205 (pa_cvolume_max(&new_soft_volume) <= (PA_VOLUME_NORM + VOLUME_ACCURACY));
1207 pa_log_debug("Requested volume: %s", pa_cvolume_snprint(t, sizeof(t), &s->real_volume));
1208 pa_log_debug("Got hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &u->hardware_volume));
1209 pa_log_debug("Calculated software volume: %s (accurate-enough=%s)", pa_cvolume_snprint(t, sizeof(t), &new_soft_volume),
1210 pa_yes_no(accurate_enough));
1212 if (!accurate_enough)
1213 s->soft_volume = new_soft_volume;
1216 pa_log_debug("Wrote hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &r));
1218 /* We can't match exactly what the user requested, hence let's
1219 * at least tell the user about it */
1225 static void sink_get_mute_cb(pa_sink *s) {
1226 struct userdata *u = s->userdata;
1230 pa_assert(u->mixer_path);
1231 pa_assert(u->mixer_handle);
1233 if (pa_alsa_path_get_mute(u->mixer_path, u->mixer_handle, &b) < 0)
1239 static void sink_set_mute_cb(pa_sink *s) {
1240 struct userdata *u = s->userdata;
1243 pa_assert(u->mixer_path);
1244 pa_assert(u->mixer_handle);
1246 pa_alsa_path_set_mute(u->mixer_path, u->mixer_handle, s->muted);
1249 static int sink_set_port_cb(pa_sink *s, pa_device_port *p) {
1250 struct userdata *u = s->userdata;
1251 pa_alsa_port_data *data;
1255 pa_assert(u->mixer_handle);
1257 data = PA_DEVICE_PORT_DATA(p);
1259 pa_assert_se(u->mixer_path = data->path);
1260 pa_alsa_path_select(u->mixer_path, u->mixer_handle);
1262 if (u->mixer_path->has_volume && u->mixer_path->has_dB) {
1263 s->base_volume = pa_sw_volume_from_dB(-u->mixer_path->max_dB);
1264 s->n_volume_steps = PA_VOLUME_NORM+1;
1266 pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(s->base_volume));
1268 s->base_volume = PA_VOLUME_NORM;
1269 s->n_volume_steps = u->mixer_path->max_volume - u->mixer_path->min_volume + 1;
1273 pa_alsa_setting_select(data->setting, u->mixer_handle);
1283 static void sink_update_requested_latency_cb(pa_sink *s) {
1284 struct userdata *u = s->userdata;
1287 pa_assert(u->use_tsched); /* only when timer scheduling is used
1288 * we can dynamically adjust the
1294 before = u->hwbuf_unused;
1295 update_sw_params(u);
1297 /* Let's check whether we now use only a smaller part of the
1298 buffer then before. If so, we need to make sure that subsequent
1299 rewinds are relative to the new maximum fill level and not to the
1300 current fill level. Thus, let's do a full rewind once, to clear
1303 if (u->hwbuf_unused > before) {
1304 pa_log_debug("Requesting rewind due to latency change.");
1305 pa_sink_request_rewind(s, (size_t) -1);
1309 static int process_rewind(struct userdata *u) {
1310 snd_pcm_sframes_t unused;
1311 size_t rewind_nbytes, unused_nbytes, limit_nbytes;
1314 /* Figure out how much we shall rewind and reset the counter */
1315 rewind_nbytes = u->sink->thread_info.rewind_nbytes;
1317 pa_log_debug("Requested to rewind %lu bytes.", (unsigned long) rewind_nbytes);
1319 if (PA_UNLIKELY((unused = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->sink->sample_spec)) < 0)) {
1320 pa_log("snd_pcm_avail() failed: %s", pa_alsa_strerror((int) unused));
1324 unused_nbytes = (size_t) unused * u->frame_size;
1326 /* make sure rewind doesn't go too far, can cause issues with DMAs */
1327 unused_nbytes += u->rewind_safeguard;
1329 if (u->hwbuf_size > unused_nbytes)
1330 limit_nbytes = u->hwbuf_size - unused_nbytes;
1334 if (rewind_nbytes > limit_nbytes)
1335 rewind_nbytes = limit_nbytes;
1337 if (rewind_nbytes > 0) {
1338 snd_pcm_sframes_t in_frames, out_frames;
1340 pa_log_debug("Limited to %lu bytes.", (unsigned long) rewind_nbytes);
1342 in_frames = (snd_pcm_sframes_t) (rewind_nbytes / u->frame_size);
1343 pa_log_debug("before: %lu", (unsigned long) in_frames);
1344 if ((out_frames = snd_pcm_rewind(u->pcm_handle, (snd_pcm_uframes_t) in_frames)) < 0) {
1345 pa_log("snd_pcm_rewind() failed: %s", pa_alsa_strerror((int) out_frames));
1346 if (try_recover(u, "process_rewind", out_frames) < 0)
1351 pa_log_debug("after: %lu", (unsigned long) out_frames);
1353 rewind_nbytes = (size_t) out_frames * u->frame_size;
1355 if (rewind_nbytes <= 0)
1356 pa_log_info("Tried rewind, but was apparently not possible.");
1358 u->write_count -= rewind_nbytes;
1359 pa_log_debug("Rewound %lu bytes.", (unsigned long) rewind_nbytes);
1360 pa_sink_process_rewind(u->sink, rewind_nbytes);
1362 u->after_rewind = TRUE;
1366 pa_log_debug("Mhmm, actually there is nothing to rewind.");
1368 pa_sink_process_rewind(u->sink, 0);
1372 static void thread_func(void *userdata) {
1373 struct userdata *u = userdata;
1374 unsigned short revents = 0;
1378 pa_log_debug("Thread starting up");
1380 if (u->core->realtime_scheduling)
1381 pa_make_realtime(u->core->realtime_priority);
1383 pa_thread_mq_install(&u->thread_mq);
1389 pa_log_debug("Loop");
1392 /* Render some data and write it to the dsp */
1393 if (PA_SINK_IS_OPENED(u->sink->thread_info.state)) {
1395 pa_usec_t sleep_usec = 0;
1396 pa_bool_t on_timeout = pa_rtpoll_timer_elapsed(u->rtpoll);
1398 if (PA_UNLIKELY(u->sink->thread_info.rewind_requested))
1399 if (process_rewind(u) < 0)
1403 work_done = mmap_write(u, &sleep_usec, revents & POLLOUT, on_timeout);
1405 work_done = unix_write(u, &sleep_usec, revents & POLLOUT, on_timeout);
1410 /* pa_log_debug("work_done = %i", work_done); */
1415 pa_log_info("Starting playback.");
1416 snd_pcm_start(u->pcm_handle);
1418 pa_smoother_resume(u->smoother, pa_rtclock_now(), TRUE);
1424 if (u->use_tsched) {
1427 if (u->since_start <= u->hwbuf_size) {
1429 /* USB devices on ALSA seem to hit a buffer
1430 * underrun during the first iterations much
1431 * quicker then we calculate here, probably due to
1432 * the transport latency. To accommodate for that
1433 * we artificially decrease the sleep time until
1434 * we have filled the buffer at least once
1437 if (pa_log_ratelimit())
1438 pa_log_debug("Cutting sleep time for the initial iterations by half.");
1442 /* OK, the playback buffer is now full, let's
1443 * calculate when to wake up next */
1444 /* pa_log_debug("Waking up in %0.2fms (sound card clock).", (double) sleep_usec / PA_USEC_PER_MSEC); */
1446 /* Convert from the sound card time domain to the
1447 * system time domain */
1448 cusec = pa_smoother_translate(u->smoother, pa_rtclock_now(), sleep_usec);
1450 /* pa_log_debug("Waking up in %0.2fms (system clock).", (double) cusec / PA_USEC_PER_MSEC); */
1452 /* We don't trust the conversion, so we wake up whatever comes first */
1453 pa_rtpoll_set_timer_relative(u->rtpoll, PA_MIN(sleep_usec, cusec));
1457 u->after_rewind = FALSE;
1459 } else if (u->use_tsched)
1461 /* OK, we're in an invalid state, let's disable our timers */
1462 pa_rtpoll_set_timer_disabled(u->rtpoll);
1464 /* Hmm, nothing to do. Let's sleep */
1465 if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
1471 /* Tell ALSA about this and process its response */
1472 if (PA_SINK_IS_OPENED(u->sink->thread_info.state)) {
1473 struct pollfd *pollfd;
1477 pollfd = pa_rtpoll_item_get_pollfd(u->alsa_rtpoll_item, &n);
1479 if ((err = snd_pcm_poll_descriptors_revents(u->pcm_handle, pollfd, n, &revents)) < 0) {
1480 pa_log("snd_pcm_poll_descriptors_revents() failed: %s", pa_alsa_strerror(err));
1484 if (revents & ~POLLOUT) {
1485 if (pa_alsa_recover_from_poll(u->pcm_handle, revents) < 0)
1490 } else if (revents && u->use_tsched && pa_log_ratelimit())
1491 pa_log_debug("Wakeup from ALSA!");
1498 /* If this was no regular exit from the loop we have to continue
1499 * processing messages until we received PA_MESSAGE_SHUTDOWN */
1500 pa_asyncmsgq_post(u->thread_mq.outq, PA_MSGOBJECT(u->core), PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0, NULL, NULL);
1501 pa_asyncmsgq_wait_for(u->thread_mq.inq, PA_MESSAGE_SHUTDOWN);
1504 pa_log_debug("Thread shutting down");
1507 static void set_sink_name(pa_sink_new_data *data, pa_modargs *ma, const char *device_id, const char *device_name, pa_alsa_mapping *mapping) {
1513 pa_assert(device_name);
1515 if ((n = pa_modargs_get_value(ma, "sink_name", NULL))) {
1516 pa_sink_new_data_set_name(data, n);
1517 data->namereg_fail = TRUE;
1521 if ((n = pa_modargs_get_value(ma, "name", NULL)))
1522 data->namereg_fail = TRUE;
1524 n = device_id ? device_id : device_name;
1525 data->namereg_fail = FALSE;
1529 t = pa_sprintf_malloc("alsa_output.%s.%s", n, mapping->name);
1531 t = pa_sprintf_malloc("alsa_output.%s", n);
1533 pa_sink_new_data_set_name(data, t);
1537 static void find_mixer(struct userdata *u, pa_alsa_mapping *mapping, const char *element, pa_bool_t ignore_dB) {
1539 if (!mapping && !element)
1542 if (!(u->mixer_handle = pa_alsa_open_mixer_for_pcm(u->pcm_handle, &u->control_device))) {
1543 pa_log_info("Failed to find a working mixer device.");
1549 if (!(u->mixer_path = pa_alsa_path_synthesize(element, PA_ALSA_DIRECTION_OUTPUT)))
1552 if (pa_alsa_path_probe(u->mixer_path, u->mixer_handle, ignore_dB) < 0)
1555 pa_log_debug("Probed mixer path %s:", u->mixer_path->name);
1556 pa_alsa_path_dump(u->mixer_path);
1559 if (!(u->mixer_path_set = pa_alsa_path_set_new(mapping, PA_ALSA_DIRECTION_OUTPUT)))
1562 pa_alsa_path_set_probe(u->mixer_path_set, u->mixer_handle, ignore_dB);
1564 pa_log_debug("Probed mixer paths:");
1565 pa_alsa_path_set_dump(u->mixer_path_set);
1572 if (u->mixer_path_set) {
1573 pa_alsa_path_set_free(u->mixer_path_set);
1574 u->mixer_path_set = NULL;
1575 } else if (u->mixer_path) {
1576 pa_alsa_path_free(u->mixer_path);
1577 u->mixer_path = NULL;
1580 if (u->mixer_handle) {
1581 snd_mixer_close(u->mixer_handle);
1582 u->mixer_handle = NULL;
1586 static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB) {
1589 if (!u->mixer_handle)
1592 if (u->sink->active_port) {
1593 pa_alsa_port_data *data;
1595 /* We have a list of supported paths, so let's activate the
1596 * one that has been chosen as active */
1598 data = PA_DEVICE_PORT_DATA(u->sink->active_port);
1599 u->mixer_path = data->path;
1601 pa_alsa_path_select(data->path, u->mixer_handle);
1604 pa_alsa_setting_select(data->setting, u->mixer_handle);
1608 if (!u->mixer_path && u->mixer_path_set)
1609 u->mixer_path = u->mixer_path_set->paths;
1611 if (u->mixer_path) {
1612 /* Hmm, we have only a single path, then let's activate it */
1614 pa_alsa_path_select(u->mixer_path, u->mixer_handle);
1616 if (u->mixer_path->settings)
1617 pa_alsa_setting_select(u->mixer_path->settings, u->mixer_handle);
1622 /* FIXME: need automatic detection rather than hard-coded path */
1623 if (!strcmp(u->mixer_path->name, "iec958-passthrough-output")) {
1624 u->sink->flags |= PA_SINK_PASSTHROUGH;
1626 u->sink->flags &= ~PA_SINK_PASSTHROUGH;
1629 if (!u->mixer_path->has_volume)
1630 pa_log_info("Driver does not support hardware volume control, falling back to software volume control.");
1633 if (u->mixer_path->has_dB) {
1634 pa_log_info("Hardware volume ranges from %0.2f dB to %0.2f dB.", u->mixer_path->min_dB, u->mixer_path->max_dB);
1636 u->sink->base_volume = pa_sw_volume_from_dB(-u->mixer_path->max_dB);
1637 u->sink->n_volume_steps = PA_VOLUME_NORM+1;
1639 if (u->mixer_path->max_dB > 0.0)
1640 pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(u->sink->base_volume));
1642 pa_log_info("No particular base volume set, fixing to 0 dB");
1645 pa_log_info("Hardware volume ranges from %li to %li.", u->mixer_path->min_volume, u->mixer_path->max_volume);
1646 u->sink->base_volume = PA_VOLUME_NORM;
1647 u->sink->n_volume_steps = u->mixer_path->max_volume - u->mixer_path->min_volume + 1;
1650 u->sink->get_volume = sink_get_volume_cb;
1651 u->sink->set_volume = sink_set_volume_cb;
1653 u->sink->flags |= PA_SINK_HW_VOLUME_CTRL | (u->mixer_path->has_dB ? PA_SINK_DECIBEL_VOLUME : 0);
1654 pa_log_info("Using hardware volume control. Hardware dB scale %s.", u->mixer_path->has_dB ? "supported" : "not supported");
1657 if (!u->mixer_path->has_mute) {
1658 pa_log_info("Driver does not support hardware mute control, falling back to software mute control.");
1660 u->sink->get_mute = sink_get_mute_cb;
1661 u->sink->set_mute = sink_set_mute_cb;
1662 u->sink->flags |= PA_SINK_HW_MUTE_CTRL;
1663 pa_log_info("Using hardware mute control.");
1666 u->mixer_fdl = pa_alsa_fdlist_new();
1668 if (pa_alsa_fdlist_set_mixer(u->mixer_fdl, u->mixer_handle, u->core->mainloop) < 0) {
1669 pa_log("Failed to initialize file descriptor monitoring");
1673 if (u->mixer_path_set)
1674 pa_alsa_path_set_set_callback(u->mixer_path_set, u->mixer_handle, mixer_callback, u);
1676 pa_alsa_path_set_callback(u->mixer_path, u->mixer_handle, mixer_callback, u);
1681 pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_card *card, pa_alsa_mapping *mapping) {
1683 struct userdata *u = NULL;
1684 const char *dev_id = NULL;
1685 pa_sample_spec ss, requested_ss;
1687 uint32_t nfrags, frag_size, buffer_size, tsched_size, tsched_watermark, rewind_safeguard;
1688 snd_pcm_uframes_t period_frames, buffer_frames, tsched_frames;
1690 pa_bool_t use_mmap = TRUE, b, use_tsched = TRUE, d, ignore_dB = FALSE, namereg_fail = FALSE;
1691 pa_sink_new_data data;
1692 pa_alsa_profile_set *profile_set = NULL;
1697 ss = m->core->default_sample_spec;
1698 map = m->core->default_channel_map;
1699 if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_ALSA) < 0) {
1700 pa_log("Failed to parse sample specification and channel map");
1705 frame_size = pa_frame_size(&ss);
1707 nfrags = m->core->default_n_fragments;
1708 frag_size = (uint32_t) pa_usec_to_bytes(m->core->default_fragment_size_msec*PA_USEC_PER_MSEC, &ss);
1710 frag_size = (uint32_t) frame_size;
1711 tsched_size = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_BUFFER_USEC, &ss);
1712 tsched_watermark = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_WATERMARK_USEC, &ss);
1714 if (pa_modargs_get_value_u32(ma, "fragments", &nfrags) < 0 ||
1715 pa_modargs_get_value_u32(ma, "fragment_size", &frag_size) < 0 ||
1716 pa_modargs_get_value_u32(ma, "tsched_buffer_size", &tsched_size) < 0 ||
1717 pa_modargs_get_value_u32(ma, "tsched_buffer_watermark", &tsched_watermark) < 0) {
1718 pa_log("Failed to parse buffer metrics");
1722 buffer_size = nfrags * frag_size;
1724 period_frames = frag_size/frame_size;
1725 buffer_frames = buffer_size/frame_size;
1726 tsched_frames = tsched_size/frame_size;
1728 if (pa_modargs_get_value_boolean(ma, "mmap", &use_mmap) < 0) {
1729 pa_log("Failed to parse mmap argument.");
1733 if (pa_modargs_get_value_boolean(ma, "tsched", &use_tsched) < 0) {
1734 pa_log("Failed to parse tsched argument.");
1738 if (pa_modargs_get_value_boolean(ma, "ignore_dB", &ignore_dB) < 0) {
1739 pa_log("Failed to parse ignore_dB argument.");
1743 rewind_safeguard = DEFAULT_REWIND_SAFEGUARD_BYTES;
1744 if (pa_modargs_get_value_u32(ma, "rewind_safeguard", &rewind_safeguard) < 0) {
1745 pa_log("Failed to parse rewind_safeguard argument");
1749 use_tsched = pa_alsa_may_tsched(use_tsched);
1751 u = pa_xnew0(struct userdata, 1);
1754 u->use_mmap = use_mmap;
1755 u->use_tsched = use_tsched;
1757 u->rewind_safeguard = rewind_safeguard;
1758 u->rtpoll = pa_rtpoll_new();
1759 pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
1761 u->smoother = pa_smoother_new(
1762 SMOOTHER_ADJUST_USEC,
1763 SMOOTHER_WINDOW_USEC,
1769 u->smoother_interval = SMOOTHER_MIN_INTERVAL;
1771 dev_id = pa_modargs_get_value(
1773 pa_modargs_get_value(ma, "device", DEFAULT_DEVICE));
1775 if (reserve_init(u, dev_id) < 0)
1778 if (reserve_monitor_init(u, dev_id) < 0)
1786 if (!(dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
1787 pa_log("device_id= not set");
1791 if (!(u->pcm_handle = pa_alsa_open_by_device_id_mapping(
1795 SND_PCM_STREAM_PLAYBACK,
1796 &period_frames, &buffer_frames, tsched_frames,
1801 } else if ((dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
1803 if (!(profile_set = pa_alsa_profile_set_new(NULL, &map)))
1806 if (!(u->pcm_handle = pa_alsa_open_by_device_id_auto(
1810 SND_PCM_STREAM_PLAYBACK,
1811 &period_frames, &buffer_frames, tsched_frames,
1812 &b, &d, profile_set, &mapping)))
1818 if (!(u->pcm_handle = pa_alsa_open_by_device_string(
1819 pa_modargs_get_value(ma, "device", DEFAULT_DEVICE),
1822 SND_PCM_STREAM_PLAYBACK,
1823 &period_frames, &buffer_frames, tsched_frames,
1828 pa_assert(u->device_name);
1829 pa_log_info("Successfully opened device %s.", u->device_name);
1831 if (pa_alsa_pcm_is_modem(u->pcm_handle)) {
1832 pa_log_notice("Device %s is modem, refusing further initialization.", u->device_name);
1837 pa_log_info("Selected mapping '%s' (%s).", mapping->description, mapping->name);
1839 if (use_mmap && !b) {
1840 pa_log_info("Device doesn't support mmap(), falling back to UNIX read/write mode.");
1841 u->use_mmap = use_mmap = FALSE;
1844 if (use_tsched && (!b || !d)) {
1845 pa_log_info("Cannot enable timer-based scheduling, falling back to sound IRQ scheduling.");
1846 u->use_tsched = use_tsched = FALSE;
1850 pa_log_info("Successfully enabled mmap() mode.");
1853 pa_log_info("Successfully enabled timer-based scheduling mode.");
1855 /* ALSA might tweak the sample spec, so recalculate the frame size */
1856 frame_size = pa_frame_size(&ss);
1858 find_mixer(u, mapping, pa_modargs_get_value(ma, "control", NULL), ignore_dB);
1860 pa_sink_new_data_init(&data);
1861 data.driver = driver;
1864 set_sink_name(&data, ma, dev_id, u->device_name, mapping);
1866 /* We need to give pa_modargs_get_value_boolean() a pointer to a local
1867 * variable instead of using &data.namereg_fail directly, because
1868 * data.namereg_fail is a bitfield and taking the address of a bitfield
1869 * variable is impossible. */
1870 namereg_fail = data.namereg_fail;
1871 if (pa_modargs_get_value_boolean(ma, "namereg_fail", &namereg_fail) < 0) {
1872 pa_log("Failed to parse boolean argument namereg_fail.");
1873 pa_sink_new_data_done(&data);
1876 data.namereg_fail = namereg_fail;
1878 pa_sink_new_data_set_sample_spec(&data, &ss);
1879 pa_sink_new_data_set_channel_map(&data, &map);
1881 pa_alsa_init_proplist_pcm(m->core, data.proplist, u->pcm_handle);
1882 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, u->device_name);
1883 pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_BUFFER_SIZE, "%lu", (unsigned long) (buffer_frames * frame_size));
1884 pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZE, "%lu", (unsigned long) (period_frames * frame_size));
1885 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_ACCESS_MODE, u->use_tsched ? "mmap+timer" : (u->use_mmap ? "mmap" : "serial"));
1888 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_NAME, mapping->name);
1889 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_DESCRIPTION, mapping->description);
1892 pa_alsa_init_description(data.proplist);
1894 if (u->control_device)
1895 pa_alsa_init_proplist_ctl(data.proplist, u->control_device);
1897 if (pa_modargs_get_proplist(ma, "sink_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
1898 pa_log("Invalid properties");
1899 pa_sink_new_data_done(&data);
1903 if (u->mixer_path_set)
1904 pa_alsa_add_ports(&data.ports, u->mixer_path_set);
1906 u->sink = pa_sink_new(m->core, &data, PA_SINK_HARDWARE|PA_SINK_LATENCY|(u->use_tsched ? PA_SINK_DYNAMIC_LATENCY : 0));
1907 pa_sink_new_data_done(&data);
1910 pa_log("Failed to create sink object");
1914 u->sink->parent.process_msg = sink_process_msg;
1916 u->sink->update_requested_latency = sink_update_requested_latency_cb;
1917 u->sink->set_state = sink_set_state_cb;
1918 u->sink->set_port = sink_set_port_cb;
1919 u->sink->userdata = u;
1921 pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
1922 pa_sink_set_rtpoll(u->sink, u->rtpoll);
1924 u->frame_size = frame_size;
1925 u->fragment_size = frag_size = (size_t) (period_frames * frame_size);
1926 u->hwbuf_size = buffer_size = (size_t) (buffer_frames * frame_size);
1927 pa_cvolume_mute(&u->hardware_volume, u->sink->sample_spec.channels);
1929 pa_log_info("Using %0.1f fragments of size %lu bytes (%0.2fms), buffer size is %lu bytes (%0.2fms)",
1930 (double) u->hwbuf_size / (double) u->fragment_size,
1931 (long unsigned) u->fragment_size,
1932 (double) pa_bytes_to_usec(u->fragment_size, &ss) / PA_USEC_PER_MSEC,
1933 (long unsigned) u->hwbuf_size,
1934 (double) pa_bytes_to_usec(u->hwbuf_size, &ss) / PA_USEC_PER_MSEC);
1936 pa_sink_set_max_request(u->sink, u->hwbuf_size);
1937 if (pa_alsa_pcm_is_hw(u->pcm_handle))
1938 pa_sink_set_max_rewind(u->sink, u->hwbuf_size);
1940 pa_log_info("Disabling rewind for device %s", u->device_name);
1941 pa_sink_set_max_rewind(u->sink, 0);
1944 if (u->use_tsched) {
1945 u->tsched_watermark = pa_usec_to_bytes_round_up(pa_bytes_to_usec_round_up(tsched_watermark, &requested_ss), &u->sink->sample_spec);
1947 u->watermark_inc_step = pa_usec_to_bytes(TSCHED_WATERMARK_INC_STEP_USEC, &u->sink->sample_spec);
1948 u->watermark_dec_step = pa_usec_to_bytes(TSCHED_WATERMARK_DEC_STEP_USEC, &u->sink->sample_spec);
1950 u->watermark_inc_threshold = pa_usec_to_bytes_round_up(TSCHED_WATERMARK_INC_THRESHOLD_USEC, &u->sink->sample_spec);
1951 u->watermark_dec_threshold = pa_usec_to_bytes_round_up(TSCHED_WATERMARK_DEC_THRESHOLD_USEC, &u->sink->sample_spec);
1953 fix_min_sleep_wakeup(u);
1954 fix_tsched_watermark(u);
1956 pa_sink_set_latency_range(u->sink,
1958 pa_bytes_to_usec(u->hwbuf_size, &ss));
1960 pa_log_info("Time scheduling watermark is %0.2fms",
1961 (double) pa_bytes_to_usec(u->tsched_watermark, &ss) / PA_USEC_PER_MSEC);
1963 pa_sink_set_fixed_latency(u->sink, pa_bytes_to_usec(u->hwbuf_size, &ss));
1967 if (update_sw_params(u) < 0)
1970 if (setup_mixer(u, ignore_dB) < 0)
1973 pa_alsa_dump(PA_LOG_DEBUG, u->pcm_handle);
1975 if (!(u->thread = pa_thread_new("alsa-sink", thread_func, u))) {
1976 pa_log("Failed to create thread.");
1980 /* Get initial mixer settings */
1981 if (data.volume_is_set) {
1982 if (u->sink->set_volume)
1983 u->sink->set_volume(u->sink);
1985 if (u->sink->get_volume)
1986 u->sink->get_volume(u->sink);
1989 if (data.muted_is_set) {
1990 if (u->sink->set_mute)
1991 u->sink->set_mute(u->sink);
1993 if (u->sink->get_mute)
1994 u->sink->get_mute(u->sink);
1997 pa_sink_put(u->sink);
2000 pa_alsa_profile_set_free(profile_set);
2010 pa_alsa_profile_set_free(profile_set);
2015 static void userdata_free(struct userdata *u) {
2019 pa_sink_unlink(u->sink);
2022 pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
2023 pa_thread_free(u->thread);
2026 pa_thread_mq_done(&u->thread_mq);
2029 pa_sink_unref(u->sink);
2031 if (u->memchunk.memblock)
2032 pa_memblock_unref(u->memchunk.memblock);
2034 if (u->alsa_rtpoll_item)
2035 pa_rtpoll_item_free(u->alsa_rtpoll_item);
2038 pa_rtpoll_free(u->rtpoll);
2040 if (u->pcm_handle) {
2041 snd_pcm_drop(u->pcm_handle);
2042 snd_pcm_close(u->pcm_handle);
2046 pa_alsa_fdlist_free(u->mixer_fdl);
2048 if (u->mixer_path_set)
2049 pa_alsa_path_set_free(u->mixer_path_set);
2050 else if (u->mixer_path)
2051 pa_alsa_path_free(u->mixer_path);
2053 if (u->mixer_handle)
2054 snd_mixer_close(u->mixer_handle);
2057 pa_smoother_free(u->smoother);
2062 pa_xfree(u->device_name);
2063 pa_xfree(u->control_device);
2067 void pa_alsa_sink_free(pa_sink *s) {
2070 pa_sink_assert_ref(s);
2071 pa_assert_se(u = s->userdata);