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_MIN_INTERVAL (2*PA_USEC_PER_MSEC) /* 2ms -- min smoother update interval */
82 #define SMOOTHER_MAX_INTERVAL (200*PA_USEC_PER_MSEC) /* 200ms -- max smoother update interval */
84 #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 */
92 pa_thread_mq thread_mq
;
95 snd_pcm_t
*pcm_handle
;
97 pa_alsa_fdlist
*mixer_fdl
;
98 snd_mixer_t
*mixer_handle
;
99 pa_alsa_path_set
*mixer_path_set
;
100 pa_alsa_path
*mixer_path
;
102 pa_cvolume hardware_volume
;
114 watermark_inc_threshold
,
115 watermark_dec_threshold
;
117 pa_usec_t watermark_dec_not_before
;
119 pa_memchunk memchunk
;
121 char *device_name
; /* name of the PCM device */
122 char *control_device
; /* name of the control device */
124 pa_bool_t use_mmap
:1, use_tsched
:1;
126 pa_bool_t first
, after_rewind
;
128 pa_rtpoll_item
*alsa_rtpoll_item
;
130 snd_mixer_selem_channel_id_t mixer_map
[SND_MIXER_SCHN_LAST
];
132 pa_smoother
*smoother
;
133 uint64_t write_count
;
134 uint64_t since_start
;
135 pa_usec_t smoother_interval
;
136 pa_usec_t last_smoother_update
;
138 pa_reserve_wrapper
*reserve
;
139 pa_hook_slot
*reserve_slot
;
140 pa_reserve_monitor_wrapper
*monitor
;
141 pa_hook_slot
*monitor_slot
;
144 static void userdata_free(struct userdata
*u
);
146 static pa_hook_result_t
reserve_cb(pa_reserve_wrapper
*r
, void *forced
, struct userdata
*u
) {
150 if (pa_sink_suspend(u
->sink
, TRUE
, PA_SUSPEND_APPLICATION
) < 0)
151 return PA_HOOK_CANCEL
;
156 static void reserve_done(struct userdata
*u
) {
159 if (u
->reserve_slot
) {
160 pa_hook_slot_free(u
->reserve_slot
);
161 u
->reserve_slot
= NULL
;
165 pa_reserve_wrapper_unref(u
->reserve
);
170 static void reserve_update(struct userdata
*u
) {
171 const char *description
;
174 if (!u
->sink
|| !u
->reserve
)
177 if ((description
= pa_proplist_gets(u
->sink
->proplist
, PA_PROP_DEVICE_DESCRIPTION
)))
178 pa_reserve_wrapper_set_application_device_name(u
->reserve
, description
);
181 static int reserve_init(struct userdata
*u
, const char *dname
) {
190 if (pa_in_system_mode())
193 if (!(rname
= pa_alsa_get_reserve_name(dname
)))
196 /* We are resuming, try to lock the device */
197 u
->reserve
= pa_reserve_wrapper_get(u
->core
, rname
);
205 pa_assert(!u
->reserve_slot
);
206 u
->reserve_slot
= pa_hook_connect(pa_reserve_wrapper_hook(u
->reserve
), PA_HOOK_NORMAL
, (pa_hook_cb_t
) reserve_cb
, u
);
211 static pa_hook_result_t
monitor_cb(pa_reserve_monitor_wrapper
*w
, void* busy
, struct userdata
*u
) {
217 b
= PA_PTR_TO_UINT(busy
) && !u
->reserve
;
219 pa_sink_suspend(u
->sink
, b
, PA_SUSPEND_APPLICATION
);
223 static void monitor_done(struct userdata
*u
) {
226 if (u
->monitor_slot
) {
227 pa_hook_slot_free(u
->monitor_slot
);
228 u
->monitor_slot
= NULL
;
232 pa_reserve_monitor_wrapper_unref(u
->monitor
);
237 static int reserve_monitor_init(struct userdata
*u
, const char *dname
) {
243 if (pa_in_system_mode())
246 if (!(rname
= pa_alsa_get_reserve_name(dname
)))
249 u
->monitor
= pa_reserve_monitor_wrapper_get(u
->core
, rname
);
255 pa_assert(!u
->monitor_slot
);
256 u
->monitor_slot
= pa_hook_connect(pa_reserve_monitor_wrapper_hook(u
->monitor
), PA_HOOK_NORMAL
, (pa_hook_cb_t
) monitor_cb
, u
);
261 static void fix_min_sleep_wakeup(struct userdata
*u
) {
262 size_t max_use
, max_use_2
;
265 pa_assert(u
->use_tsched
);
267 max_use
= u
->hwbuf_size
- u
->hwbuf_unused
;
268 max_use_2
= pa_frame_align(max_use
/2, &u
->sink
->sample_spec
);
270 u
->min_sleep
= pa_usec_to_bytes(TSCHED_MIN_SLEEP_USEC
, &u
->sink
->sample_spec
);
271 u
->min_sleep
= PA_CLAMP(u
->min_sleep
, u
->frame_size
, max_use_2
);
273 u
->min_wakeup
= pa_usec_to_bytes(TSCHED_MIN_WAKEUP_USEC
, &u
->sink
->sample_spec
);
274 u
->min_wakeup
= PA_CLAMP(u
->min_wakeup
, u
->frame_size
, max_use_2
);
277 static void fix_tsched_watermark(struct userdata
*u
) {
280 pa_assert(u
->use_tsched
);
282 max_use
= u
->hwbuf_size
- u
->hwbuf_unused
;
284 if (u
->tsched_watermark
> max_use
- u
->min_sleep
)
285 u
->tsched_watermark
= max_use
- u
->min_sleep
;
287 if (u
->tsched_watermark
< u
->min_wakeup
)
288 u
->tsched_watermark
= u
->min_wakeup
;
291 static void increase_watermark(struct userdata
*u
) {
292 size_t old_watermark
;
293 pa_usec_t old_min_latency
, new_min_latency
;
296 pa_assert(u
->use_tsched
);
298 /* First, just try to increase the watermark */
299 old_watermark
= u
->tsched_watermark
;
300 u
->tsched_watermark
= PA_MIN(u
->tsched_watermark
* 2, u
->tsched_watermark
+ u
->watermark_inc_step
);
301 fix_tsched_watermark(u
);
303 if (old_watermark
!= u
->tsched_watermark
) {
304 pa_log_info("Increasing wakeup watermark to %0.2f ms",
305 (double) pa_bytes_to_usec(u
->tsched_watermark
, &u
->sink
->sample_spec
) / PA_USEC_PER_MSEC
);
309 /* Hmm, we cannot increase the watermark any further, hence let's raise the latency */
310 old_min_latency
= u
->sink
->thread_info
.min_latency
;
311 new_min_latency
= PA_MIN(old_min_latency
* 2, old_min_latency
+ TSCHED_WATERMARK_INC_STEP_USEC
);
312 new_min_latency
= PA_MIN(new_min_latency
, u
->sink
->thread_info
.max_latency
);
314 if (old_min_latency
!= new_min_latency
) {
315 pa_log_info("Increasing minimal latency to %0.2f ms",
316 (double) new_min_latency
/ PA_USEC_PER_MSEC
);
318 pa_sink_set_latency_range_within_thread(u
->sink
, new_min_latency
, u
->sink
->thread_info
.max_latency
);
321 /* When we reach this we're officialy fucked! */
324 static void decrease_watermark(struct userdata
*u
) {
325 size_t old_watermark
;
329 pa_assert(u
->use_tsched
);
331 now
= pa_rtclock_now();
333 if (u
->watermark_dec_not_before
<= 0)
336 if (u
->watermark_dec_not_before
> now
)
339 old_watermark
= u
->tsched_watermark
;
341 if (u
->tsched_watermark
< u
->watermark_dec_step
)
342 u
->tsched_watermark
= u
->tsched_watermark
/ 2;
344 u
->tsched_watermark
= PA_MAX(u
->tsched_watermark
/ 2, u
->tsched_watermark
- u
->watermark_dec_step
);
346 fix_tsched_watermark(u
);
348 if (old_watermark
!= u
->tsched_watermark
)
349 pa_log_info("Decreasing wakeup watermark to %0.2f ms",
350 (double) pa_bytes_to_usec(u
->tsched_watermark
, &u
->sink
->sample_spec
) / PA_USEC_PER_MSEC
);
352 /* We don't change the latency range*/
355 u
->watermark_dec_not_before
= now
+ TSCHED_WATERMARK_VERIFY_AFTER_USEC
;
358 static void hw_sleep_time(struct userdata
*u
, pa_usec_t
*sleep_usec
, pa_usec_t
*process_usec
) {
361 pa_assert(sleep_usec
);
362 pa_assert(process_usec
);
365 pa_assert(u
->use_tsched
);
367 usec
= pa_sink_get_requested_latency_within_thread(u
->sink
);
369 if (usec
== (pa_usec_t
) -1)
370 usec
= pa_bytes_to_usec(u
->hwbuf_size
, &u
->sink
->sample_spec
);
372 wm
= pa_bytes_to_usec(u
->tsched_watermark
, &u
->sink
->sample_spec
);
377 *sleep_usec
= usec
- wm
;
381 pa_log_debug("Buffer time: %lu ms; Sleep time: %lu ms; Process time: %lu ms",
382 (unsigned long) (usec
/ PA_USEC_PER_MSEC
),
383 (unsigned long) (*sleep_usec
/ PA_USEC_PER_MSEC
),
384 (unsigned long) (*process_usec
/ PA_USEC_PER_MSEC
));
388 static int try_recover(struct userdata
*u
, const char *call
, int err
) {
393 pa_log_debug("%s: %s", call
, pa_alsa_strerror(err
));
395 pa_assert(err
!= -EAGAIN
);
398 pa_log_debug("%s: Buffer underrun!", call
);
400 if (err
== -ESTRPIPE
)
401 pa_log_debug("%s: System suspended!", call
);
403 if ((err
= snd_pcm_recover(u
->pcm_handle
, err
, 1)) < 0) {
404 pa_log("%s: %s", call
, pa_alsa_strerror(err
));
413 static size_t check_left_to_play(struct userdata
*u
, size_t n_bytes
, pa_bool_t on_timeout
) {
415 pa_bool_t underrun
= FALSE
;
417 /* We use <= instead of < for this check here because an underrun
418 * only happens after the last sample was processed, not already when
419 * it is removed from the buffer. This is particularly important
420 * when block transfer is used. */
422 if (n_bytes
<= u
->hwbuf_size
)
423 left_to_play
= u
->hwbuf_size
- n_bytes
;
426 /* We got a dropout. What a mess! */
434 if (!u
->first
&& !u
->after_rewind
)
435 if (pa_log_ratelimit())
436 pa_log_info("Underrun!");
440 pa_log_debug("%0.2f ms left to play; inc threshold = %0.2f ms; dec threshold = %0.2f ms",
441 (double) pa_bytes_to_usec(left_to_play
, &u
->sink
->sample_spec
) / PA_USEC_PER_MSEC
,
442 (double) pa_bytes_to_usec(u
->watermark_inc_threshold
, &u
->sink
->sample_spec
) / PA_USEC_PER_MSEC
,
443 (double) pa_bytes_to_usec(u
->watermark_dec_threshold
, &u
->sink
->sample_spec
) / PA_USEC_PER_MSEC
);
447 pa_bool_t reset_not_before
= TRUE
;
449 if (!u
->first
&& !u
->after_rewind
) {
450 if (underrun
|| left_to_play
< u
->watermark_inc_threshold
)
451 increase_watermark(u
);
452 else if (left_to_play
> u
->watermark_dec_threshold
) {
453 reset_not_before
= FALSE
;
455 /* We decrease the watermark only if have actually
456 * been woken up by a timeout. If something else woke
457 * us up it's too easy to fulfill the deadlines... */
460 decrease_watermark(u
);
464 if (reset_not_before
)
465 u
->watermark_dec_not_before
= 0;
471 static int mmap_write(struct userdata
*u
, pa_usec_t
*sleep_usec
, pa_bool_t polled
, pa_bool_t on_timeout
) {
472 pa_bool_t work_done
= TRUE
;
473 pa_usec_t max_sleep_usec
= 0, process_usec
= 0;
478 pa_sink_assert_ref(u
->sink
);
481 hw_sleep_time(u
, &max_sleep_usec
, &process_usec
);
487 pa_bool_t after_avail
= TRUE
;
489 /* First we determine how many samples are missing to fill the
490 * buffer up to 100% */
492 if (PA_UNLIKELY((n
= pa_alsa_safe_avail(u
->pcm_handle
, u
->hwbuf_size
, &u
->sink
->sample_spec
)) < 0)) {
494 if ((r
= try_recover(u
, "snd_pcm_avail", (int) n
)) == 0)
500 n_bytes
= (size_t) n
* u
->frame_size
;
503 pa_log_debug("avail: %lu", (unsigned long) n_bytes
);
506 left_to_play
= check_left_to_play(u
, n_bytes
, on_timeout
);
511 /* We won't fill up the playback buffer before at least
512 * half the sleep time is over because otherwise we might
513 * ask for more data from the clients then they expect. We
514 * need to guarantee that clients only have to keep around
515 * a single hw buffer length. */
518 pa_bytes_to_usec(left_to_play
, &u
->sink
->sample_spec
) > process_usec
+max_sleep_usec
/2) {
520 pa_log_debug("Not filling up, because too early.");
525 if (PA_UNLIKELY(n_bytes
<= u
->hwbuf_unused
)) {
529 char *dn
= pa_alsa_get_driver_name_by_pcm(u
->pcm_handle
);
530 pa_log(_("ALSA woke us up to write new data to the device, but there was actually nothing to write!\n"
531 "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers.\n"
532 "We were woken up with POLLOUT set -- however a subsequent snd_pcm_avail() returned 0 or another value < min_avail."),
538 pa_log_debug("Not filling up, because not necessary.");
546 pa_log_debug("Not filling up, because already too many iterations.");
552 n_bytes
-= u
->hwbuf_unused
;
556 pa_log_debug("Filling up");
563 const snd_pcm_channel_area_t
*areas
;
564 snd_pcm_uframes_t offset
, frames
;
565 snd_pcm_sframes_t sframes
;
567 frames
= (snd_pcm_uframes_t
) (n_bytes
/ u
->frame_size
);
568 /* pa_log_debug("%lu frames to write", (unsigned long) frames); */
570 if (PA_UNLIKELY((err
= pa_alsa_safe_mmap_begin(u
->pcm_handle
, &areas
, &offset
, &frames
, u
->hwbuf_size
, &u
->sink
->sample_spec
)) < 0)) {
572 if (!after_avail
&& err
== -EAGAIN
)
575 if ((r
= try_recover(u
, "snd_pcm_mmap_begin", err
)) == 0)
581 /* Make sure that if these memblocks need to be copied they will fit into one slot */
582 if (frames
> pa_mempool_block_size_max(u
->sink
->core
->mempool
)/u
->frame_size
)
583 frames
= pa_mempool_block_size_max(u
->sink
->core
->mempool
)/u
->frame_size
;
585 if (!after_avail
&& frames
== 0)
588 pa_assert(frames
> 0);
591 /* Check these are multiples of 8 bit */
592 pa_assert((areas
[0].first
& 7) == 0);
593 pa_assert((areas
[0].step
& 7)== 0);
595 /* We assume a single interleaved memory buffer */
596 pa_assert((areas
[0].first
>> 3) == 0);
597 pa_assert((areas
[0].step
>> 3) == u
->frame_size
);
599 p
= (uint8_t*) areas
[0].addr
+ (offset
* u
->frame_size
);
601 chunk
.memblock
= pa_memblock_new_fixed(u
->core
->mempool
, p
, frames
* u
->frame_size
, TRUE
);
602 chunk
.length
= pa_memblock_get_length(chunk
.memblock
);
605 pa_sink_render_into_full(u
->sink
, &chunk
);
606 pa_memblock_unref_fixed(chunk
.memblock
);
608 if (PA_UNLIKELY((sframes
= snd_pcm_mmap_commit(u
->pcm_handle
, offset
, frames
)) < 0)) {
610 if ((r
= try_recover(u
, "snd_pcm_mmap_commit", (int) sframes
)) == 0)
618 u
->write_count
+= frames
* u
->frame_size
;
619 u
->since_start
+= frames
* u
->frame_size
;
622 pa_log_debug("Wrote %lu bytes (of possible %lu bytes)", (unsigned long) (frames
* u
->frame_size
), (unsigned long) n_bytes
);
625 if ((size_t) frames
* u
->frame_size
>= n_bytes
)
628 n_bytes
-= (size_t) frames
* u
->frame_size
;
632 *sleep_usec
= pa_bytes_to_usec(left_to_play
, &u
->sink
->sample_spec
);
634 if (*sleep_usec
> process_usec
)
635 *sleep_usec
-= process_usec
;
639 return work_done
? 1 : 0;
642 static int unix_write(struct userdata
*u
, pa_usec_t
*sleep_usec
, pa_bool_t polled
, pa_bool_t on_timeout
) {
643 pa_bool_t work_done
= FALSE
;
644 pa_usec_t max_sleep_usec
= 0, process_usec
= 0;
649 pa_sink_assert_ref(u
->sink
);
652 hw_sleep_time(u
, &max_sleep_usec
, &process_usec
);
658 pa_bool_t after_avail
= TRUE
;
660 if (PA_UNLIKELY((n
= pa_alsa_safe_avail(u
->pcm_handle
, u
->hwbuf_size
, &u
->sink
->sample_spec
)) < 0)) {
662 if ((r
= try_recover(u
, "snd_pcm_avail", (int) n
)) == 0)
668 n_bytes
= (size_t) n
* u
->frame_size
;
669 left_to_play
= check_left_to_play(u
, n_bytes
, on_timeout
);
674 /* We won't fill up the playback buffer before at least
675 * half the sleep time is over because otherwise we might
676 * ask for more data from the clients then they expect. We
677 * need to guarantee that clients only have to keep around
678 * a single hw buffer length. */
681 pa_bytes_to_usec(left_to_play
, &u
->sink
->sample_spec
) > process_usec
+max_sleep_usec
/2)
684 if (PA_UNLIKELY(n_bytes
<= u
->hwbuf_unused
)) {
688 char *dn
= pa_alsa_get_driver_name_by_pcm(u
->pcm_handle
);
689 pa_log(_("ALSA woke us up to write new data to the device, but there was actually nothing to write!\n"
690 "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers.\n"
691 "We were woken up with POLLOUT set -- however a subsequent snd_pcm_avail() returned 0 or another value < min_avail."),
701 pa_log_debug("Not filling up, because already too many iterations.");
707 n_bytes
-= u
->hwbuf_unused
;
711 snd_pcm_sframes_t frames
;
714 /* pa_log_debug("%lu frames to write", (unsigned long) frames); */
716 if (u
->memchunk
.length
<= 0)
717 pa_sink_render(u
->sink
, n_bytes
, &u
->memchunk
);
719 pa_assert(u
->memchunk
.length
> 0);
721 frames
= (snd_pcm_sframes_t
) (u
->memchunk
.length
/ u
->frame_size
);
723 if (frames
> (snd_pcm_sframes_t
) (n_bytes
/u
->frame_size
))
724 frames
= (snd_pcm_sframes_t
) (n_bytes
/u
->frame_size
);
726 p
= pa_memblock_acquire(u
->memchunk
.memblock
);
727 frames
= snd_pcm_writei(u
->pcm_handle
, (const uint8_t*) p
+ u
->memchunk
.index
, (snd_pcm_uframes_t
) frames
);
728 pa_memblock_release(u
->memchunk
.memblock
);
730 if (PA_UNLIKELY(frames
< 0)) {
732 if (!after_avail
&& (int) frames
== -EAGAIN
)
735 if ((r
= try_recover(u
, "snd_pcm_writei", (int) frames
)) == 0)
741 if (!after_avail
&& frames
== 0)
744 pa_assert(frames
> 0);
747 u
->memchunk
.index
+= (size_t) frames
* u
->frame_size
;
748 u
->memchunk
.length
-= (size_t) frames
* u
->frame_size
;
750 if (u
->memchunk
.length
<= 0) {
751 pa_memblock_unref(u
->memchunk
.memblock
);
752 pa_memchunk_reset(&u
->memchunk
);
757 u
->write_count
+= frames
* u
->frame_size
;
758 u
->since_start
+= frames
* u
->frame_size
;
760 /* pa_log_debug("wrote %lu frames", (unsigned long) frames); */
762 if ((size_t) frames
* u
->frame_size
>= n_bytes
)
765 n_bytes
-= (size_t) frames
* u
->frame_size
;
769 *sleep_usec
= pa_bytes_to_usec(left_to_play
, &u
->sink
->sample_spec
);
771 if (*sleep_usec
> process_usec
)
772 *sleep_usec
-= process_usec
;
776 return work_done
? 1 : 0;
779 static void update_smoother(struct userdata
*u
) {
780 snd_pcm_sframes_t delay
= 0;
783 pa_usec_t now1
= 0, now2
;
784 snd_pcm_status_t
*status
;
786 snd_pcm_status_alloca(&status
);
789 pa_assert(u
->pcm_handle
);
791 /* Let's update the time smoother */
793 if (PA_UNLIKELY((err
= pa_alsa_safe_delay(u
->pcm_handle
, &delay
, u
->hwbuf_size
, &u
->sink
->sample_spec
)) < 0)) {
794 pa_log_warn("Failed to query DSP status data: %s", pa_alsa_strerror(err
));
798 if (PA_UNLIKELY((err
= snd_pcm_status(u
->pcm_handle
, status
)) < 0))
799 pa_log_warn("Failed to get timestamp: %s", pa_alsa_strerror(err
));
801 snd_htimestamp_t htstamp
= { 0, 0 };
802 snd_pcm_status_get_htstamp(status
, &htstamp
);
803 now1
= pa_timespec_load(&htstamp
);
806 /* Hmm, if the timestamp is 0, then it wasn't set and we take the current time */
808 now1
= pa_rtclock_now();
810 /* check if the time since the last update is bigger than the interval */
811 if (u
->last_smoother_update
> 0)
812 if (u
->last_smoother_update
+ u
->smoother_interval
> now1
)
815 position
= (int64_t) u
->write_count
- ((int64_t) delay
* (int64_t) u
->frame_size
);
817 if (PA_UNLIKELY(position
< 0))
820 now2
= pa_bytes_to_usec((uint64_t) position
, &u
->sink
->sample_spec
);
822 pa_smoother_put(u
->smoother
, now1
, now2
);
824 u
->last_smoother_update
= now1
;
825 /* exponentially increase the update interval up to the MAX limit */
826 u
->smoother_interval
= PA_MIN (u
->smoother_interval
* 2, SMOOTHER_MAX_INTERVAL
);
829 static pa_usec_t
sink_get_latency(struct userdata
*u
) {
832 pa_usec_t now1
, now2
;
836 now1
= pa_rtclock_now();
837 now2
= pa_smoother_get(u
->smoother
, now1
);
839 delay
= (int64_t) pa_bytes_to_usec(u
->write_count
, &u
->sink
->sample_spec
) - (int64_t) now2
;
841 r
= delay
>= 0 ? (pa_usec_t
) delay
: 0;
843 if (u
->memchunk
.memblock
)
844 r
+= pa_bytes_to_usec(u
->memchunk
.length
, &u
->sink
->sample_spec
);
849 static int build_pollfd(struct userdata
*u
) {
851 pa_assert(u
->pcm_handle
);
853 if (u
->alsa_rtpoll_item
)
854 pa_rtpoll_item_free(u
->alsa_rtpoll_item
);
856 if (!(u
->alsa_rtpoll_item
= pa_alsa_build_pollfd(u
->pcm_handle
, u
->rtpoll
)))
862 /* Called from IO context */
863 static int suspend(struct userdata
*u
) {
865 pa_assert(u
->pcm_handle
);
867 pa_smoother_pause(u
->smoother
, pa_rtclock_now());
869 /* Let's suspend -- we don't call snd_pcm_drain() here since that might
870 * take awfully long with our long buffer sizes today. */
871 snd_pcm_close(u
->pcm_handle
);
872 u
->pcm_handle
= NULL
;
874 if (u
->alsa_rtpoll_item
) {
875 pa_rtpoll_item_free(u
->alsa_rtpoll_item
);
876 u
->alsa_rtpoll_item
= NULL
;
879 /* We reset max_rewind/max_request here to make sure that while we
880 * are suspended the old max_request/max_rewind values set before
881 * the suspend can influence the per-stream buffer of newly
882 * created streams, without their requirements having any
883 * influence on them. */
884 pa_sink_set_max_rewind_within_thread(u
->sink
, 0);
885 pa_sink_set_max_request_within_thread(u
->sink
, 0);
887 pa_log_info("Device suspended...");
892 /* Called from IO context */
893 static int update_sw_params(struct userdata
*u
) {
894 snd_pcm_uframes_t avail_min
;
899 /* Use the full buffer if noone asked us for anything specific */
905 if ((latency
= pa_sink_get_requested_latency_within_thread(u
->sink
)) != (pa_usec_t
) -1) {
908 pa_log_debug("Latency set to %0.2fms", (double) latency
/ PA_USEC_PER_MSEC
);
910 b
= pa_usec_to_bytes(latency
, &u
->sink
->sample_spec
);
912 /* We need at least one sample in our buffer */
914 if (PA_UNLIKELY(b
< u
->frame_size
))
917 u
->hwbuf_unused
= PA_LIKELY(b
< u
->hwbuf_size
) ? (u
->hwbuf_size
- b
) : 0;
920 fix_min_sleep_wakeup(u
);
921 fix_tsched_watermark(u
);
924 pa_log_debug("hwbuf_unused=%lu", (unsigned long) u
->hwbuf_unused
);
926 /* We need at last one frame in the used part of the buffer */
927 avail_min
= (snd_pcm_uframes_t
) u
->hwbuf_unused
/ u
->frame_size
+ 1;
930 pa_usec_t sleep_usec
, process_usec
;
932 hw_sleep_time(u
, &sleep_usec
, &process_usec
);
933 avail_min
+= pa_usec_to_bytes(sleep_usec
, &u
->sink
->sample_spec
) / u
->frame_size
;
936 pa_log_debug("setting avail_min=%lu", (unsigned long) avail_min
);
938 if ((err
= pa_alsa_set_sw_params(u
->pcm_handle
, avail_min
, !u
->use_tsched
)) < 0) {
939 pa_log("Failed to set software parameters: %s", pa_alsa_strerror(err
));
943 pa_sink_set_max_request_within_thread(u
->sink
, u
->hwbuf_size
- u
->hwbuf_unused
);
944 pa_sink_set_max_rewind_within_thread(u
->sink
, u
->hwbuf_size
);
949 /* Called from IO context */
950 static int unsuspend(struct userdata
*u
) {
954 snd_pcm_uframes_t period_size
, buffer_size
;
957 pa_assert(!u
->pcm_handle
);
959 pa_log_info("Trying resume...");
961 if ((err
= snd_pcm_open(&u
->pcm_handle
, u
->device_name
, SND_PCM_STREAM_PLAYBACK
,
963 SND_PCM_NO_AUTO_RESAMPLE
|
964 SND_PCM_NO_AUTO_CHANNELS
|
965 SND_PCM_NO_AUTO_FORMAT
)) < 0) {
966 pa_log("Error opening PCM device %s: %s", u
->device_name
, pa_alsa_strerror(err
));
970 ss
= u
->sink
->sample_spec
;
971 period_size
= u
->fragment_size
/ u
->frame_size
;
972 buffer_size
= u
->hwbuf_size
/ u
->frame_size
;
976 if ((err
= pa_alsa_set_hw_params(u
->pcm_handle
, &ss
, &period_size
, &buffer_size
, 0, &b
, &d
, TRUE
)) < 0) {
977 pa_log("Failed to set hardware parameters: %s", pa_alsa_strerror(err
));
981 if (b
!= u
->use_mmap
|| d
!= u
->use_tsched
) {
982 pa_log_warn("Resume failed, couldn't get original access mode.");
986 if (!pa_sample_spec_equal(&ss
, &u
->sink
->sample_spec
)) {
987 pa_log_warn("Resume failed, couldn't restore original sample settings.");
991 if (period_size
*u
->frame_size
!= u
->fragment_size
||
992 buffer_size
*u
->frame_size
!= u
->hwbuf_size
) {
993 pa_log_warn("Resume failed, couldn't restore original fragment settings. (Old: %lu/%lu, New %lu/%lu)",
994 (unsigned long) u
->hwbuf_size
, (unsigned long) u
->fragment_size
,
995 (unsigned long) (buffer_size
*u
->frame_size
), (unsigned long) (period_size
*u
->frame_size
));
999 if (update_sw_params(u
) < 0)
1002 if (build_pollfd(u
) < 0)
1006 pa_smoother_reset(u
->smoother
, pa_rtclock_now(), TRUE
);
1007 u
->smoother_interval
= SMOOTHER_MIN_INTERVAL
;
1008 u
->last_smoother_update
= 0;
1013 pa_log_info("Resumed successfully...");
1018 if (u
->pcm_handle
) {
1019 snd_pcm_close(u
->pcm_handle
);
1020 u
->pcm_handle
= NULL
;
1026 /* Called from IO context */
1027 static int sink_process_msg(pa_msgobject
*o
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
1028 struct userdata
*u
= PA_SINK(o
)->userdata
;
1032 case PA_SINK_MESSAGE_GET_LATENCY
: {
1036 r
= sink_get_latency(u
);
1038 *((pa_usec_t
*) data
) = r
;
1043 case PA_SINK_MESSAGE_SET_STATE
:
1045 switch ((pa_sink_state_t
) PA_PTR_TO_UINT(data
)) {
1047 case PA_SINK_SUSPENDED
: {
1050 pa_assert(PA_SINK_IS_OPENED(u
->sink
->thread_info
.state
));
1052 if ((r
= suspend(u
)) < 0)
1059 case PA_SINK_RUNNING
: {
1062 if (u
->sink
->thread_info
.state
== PA_SINK_INIT
) {
1063 if (build_pollfd(u
) < 0)
1067 if (u
->sink
->thread_info
.state
== PA_SINK_SUSPENDED
) {
1068 if ((r
= unsuspend(u
)) < 0)
1075 case PA_SINK_UNLINKED
:
1077 case PA_SINK_INVALID_STATE
:
1084 return pa_sink_process_msg(o
, code
, data
, offset
, chunk
);
1087 /* Called from main context */
1088 static int sink_set_state_cb(pa_sink
*s
, pa_sink_state_t new_state
) {
1089 pa_sink_state_t old_state
;
1092 pa_sink_assert_ref(s
);
1093 pa_assert_se(u
= s
->userdata
);
1095 old_state
= pa_sink_get_state(u
->sink
);
1097 if (PA_SINK_IS_OPENED(old_state
) && new_state
== PA_SINK_SUSPENDED
)
1099 else if (old_state
== PA_SINK_SUSPENDED
&& PA_SINK_IS_OPENED(new_state
))
1100 if (reserve_init(u
, u
->device_name
) < 0)
1101 return -PA_ERR_BUSY
;
1106 static int mixer_callback(snd_mixer_elem_t
*elem
, unsigned int mask
) {
1107 struct userdata
*u
= snd_mixer_elem_get_callback_private(elem
);
1110 pa_assert(u
->mixer_handle
);
1112 if (mask
== SND_CTL_EVENT_MASK_REMOVE
)
1115 if (u
->sink
->suspend_cause
& PA_SUSPEND_SESSION
)
1118 if (mask
& SND_CTL_EVENT_MASK_VALUE
) {
1119 pa_sink_get_volume(u
->sink
, TRUE
);
1120 pa_sink_get_mute(u
->sink
, TRUE
);
1126 static void sink_get_volume_cb(pa_sink
*s
) {
1127 struct userdata
*u
= s
->userdata
;
1129 char t
[PA_CVOLUME_SNPRINT_MAX
];
1132 pa_assert(u
->mixer_path
);
1133 pa_assert(u
->mixer_handle
);
1135 if (pa_alsa_path_get_volume(u
->mixer_path
, u
->mixer_handle
, &s
->channel_map
, &r
) < 0)
1138 /* Shift down by the base volume, so that 0dB becomes maximum volume */
1139 pa_sw_cvolume_multiply_scalar(&r
, &r
, s
->base_volume
);
1141 pa_log_debug("Read hardware volume: %s", pa_cvolume_snprint(t
, sizeof(t
), &r
));
1143 if (pa_cvolume_equal(&u
->hardware_volume
, &r
))
1146 s
->real_volume
= u
->hardware_volume
= r
;
1148 /* Hmm, so the hardware volume changed, let's reset our software volume */
1149 if (u
->mixer_path
->has_dB
)
1150 pa_sink_set_soft_volume(s
, NULL
);
1153 static void sink_set_volume_cb(pa_sink
*s
) {
1154 struct userdata
*u
= s
->userdata
;
1156 char t
[PA_CVOLUME_SNPRINT_MAX
];
1159 pa_assert(u
->mixer_path
);
1160 pa_assert(u
->mixer_handle
);
1162 /* Shift up by the base volume */
1163 pa_sw_cvolume_divide_scalar(&r
, &s
->real_volume
, s
->base_volume
);
1165 if (pa_alsa_path_set_volume(u
->mixer_path
, u
->mixer_handle
, &s
->channel_map
, &r
) < 0)
1168 /* Shift down by the base volume, so that 0dB becomes maximum volume */
1169 pa_sw_cvolume_multiply_scalar(&r
, &r
, s
->base_volume
);
1171 u
->hardware_volume
= r
;
1173 if (u
->mixer_path
->has_dB
) {
1174 pa_cvolume new_soft_volume
;
1175 pa_bool_t accurate_enough
;
1177 /* Match exactly what the user requested by software */
1178 pa_sw_cvolume_divide(&new_soft_volume
, &s
->real_volume
, &u
->hardware_volume
);
1180 /* If the adjustment to do in software is only minimal we
1181 * can skip it. That saves us CPU at the expense of a bit of
1184 (pa_cvolume_min(&new_soft_volume
) >= (PA_VOLUME_NORM
- VOLUME_ACCURACY
)) &&
1185 (pa_cvolume_max(&new_soft_volume
) <= (PA_VOLUME_NORM
+ VOLUME_ACCURACY
));
1187 pa_log_debug("Requested volume: %s", pa_cvolume_snprint(t
, sizeof(t
), &s
->real_volume
));
1188 pa_log_debug("Got hardware volume: %s", pa_cvolume_snprint(t
, sizeof(t
), &u
->hardware_volume
));
1189 pa_log_debug("Calculated software volume: %s (accurate-enough=%s)", pa_cvolume_snprint(t
, sizeof(t
), &new_soft_volume
),
1190 pa_yes_no(accurate_enough
));
1192 if (!accurate_enough
)
1193 s
->soft_volume
= new_soft_volume
;
1196 pa_log_debug("Wrote hardware volume: %s", pa_cvolume_snprint(t
, sizeof(t
), &r
));
1198 /* We can't match exactly what the user requested, hence let's
1199 * at least tell the user about it */
1205 static void sink_get_mute_cb(pa_sink
*s
) {
1206 struct userdata
*u
= s
->userdata
;
1210 pa_assert(u
->mixer_path
);
1211 pa_assert(u
->mixer_handle
);
1213 if (pa_alsa_path_get_mute(u
->mixer_path
, u
->mixer_handle
, &b
) < 0)
1219 static void sink_set_mute_cb(pa_sink
*s
) {
1220 struct userdata
*u
= s
->userdata
;
1223 pa_assert(u
->mixer_path
);
1224 pa_assert(u
->mixer_handle
);
1226 pa_alsa_path_set_mute(u
->mixer_path
, u
->mixer_handle
, s
->muted
);
1229 static int sink_set_port_cb(pa_sink
*s
, pa_device_port
*p
) {
1230 struct userdata
*u
= s
->userdata
;
1231 pa_alsa_port_data
*data
;
1235 pa_assert(u
->mixer_handle
);
1237 data
= PA_DEVICE_PORT_DATA(p
);
1239 pa_assert_se(u
->mixer_path
= data
->path
);
1240 pa_alsa_path_select(u
->mixer_path
, u
->mixer_handle
);
1242 if (u
->mixer_path
->has_volume
&& u
->mixer_path
->has_dB
) {
1243 s
->base_volume
= pa_sw_volume_from_dB(-u
->mixer_path
->max_dB
);
1244 s
->n_volume_steps
= PA_VOLUME_NORM
+1;
1246 if (u
->mixer_path
->max_dB
> 0.0)
1247 pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(s
->base_volume
));
1249 pa_log_info("No particular base volume set, fixing to 0 dB");
1251 s
->base_volume
= PA_VOLUME_NORM
;
1252 s
->n_volume_steps
= u
->mixer_path
->max_volume
- u
->mixer_path
->min_volume
+ 1;
1256 pa_alsa_setting_select(data
->setting
, u
->mixer_handle
);
1266 static void sink_update_requested_latency_cb(pa_sink
*s
) {
1267 struct userdata
*u
= s
->userdata
;
1274 before
= u
->hwbuf_unused
;
1275 update_sw_params(u
);
1277 /* Let's check whether we now use only a smaller part of the
1278 buffer then before. If so, we need to make sure that subsequent
1279 rewinds are relative to the new maximum fill level and not to the
1280 current fill level. Thus, let's do a full rewind once, to clear
1283 if (u
->hwbuf_unused
> before
) {
1284 pa_log_debug("Requesting rewind due to latency change.");
1285 pa_sink_request_rewind(s
, (size_t) -1);
1289 static int process_rewind(struct userdata
*u
) {
1290 snd_pcm_sframes_t unused
;
1291 size_t rewind_nbytes
, unused_nbytes
, limit_nbytes
;
1294 /* Figure out how much we shall rewind and reset the counter */
1295 rewind_nbytes
= u
->sink
->thread_info
.rewind_nbytes
;
1297 pa_log_debug("Requested to rewind %lu bytes.", (unsigned long) rewind_nbytes
);
1299 if (PA_UNLIKELY((unused
= pa_alsa_safe_avail(u
->pcm_handle
, u
->hwbuf_size
, &u
->sink
->sample_spec
)) < 0)) {
1300 pa_log("snd_pcm_avail() failed: %s", pa_alsa_strerror((int) unused
));
1304 unused_nbytes
= u
->tsched_watermark
+ (size_t) unused
* u
->frame_size
;
1306 if (u
->hwbuf_size
> unused_nbytes
)
1307 limit_nbytes
= u
->hwbuf_size
- unused_nbytes
;
1311 if (rewind_nbytes
> limit_nbytes
)
1312 rewind_nbytes
= limit_nbytes
;
1314 if (rewind_nbytes
> 0) {
1315 snd_pcm_sframes_t in_frames
, out_frames
;
1317 pa_log_debug("Limited to %lu bytes.", (unsigned long) rewind_nbytes
);
1319 in_frames
= (snd_pcm_sframes_t
) (rewind_nbytes
/ u
->frame_size
);
1320 pa_log_debug("before: %lu", (unsigned long) in_frames
);
1321 if ((out_frames
= snd_pcm_rewind(u
->pcm_handle
, (snd_pcm_uframes_t
) in_frames
)) < 0) {
1322 pa_log("snd_pcm_rewind() failed: %s", pa_alsa_strerror((int) out_frames
));
1323 if (try_recover(u
, "process_rewind", out_frames
) < 0)
1328 pa_log_debug("after: %lu", (unsigned long) out_frames
);
1330 rewind_nbytes
= (size_t) out_frames
* u
->frame_size
;
1332 if (rewind_nbytes
<= 0)
1333 pa_log_info("Tried rewind, but was apparently not possible.");
1335 u
->write_count
-= rewind_nbytes
;
1336 pa_log_debug("Rewound %lu bytes.", (unsigned long) rewind_nbytes
);
1337 pa_sink_process_rewind(u
->sink
, rewind_nbytes
);
1339 u
->after_rewind
= TRUE
;
1343 pa_log_debug("Mhmm, actually there is nothing to rewind.");
1345 pa_sink_process_rewind(u
->sink
, 0);
1349 static void thread_func(void *userdata
) {
1350 struct userdata
*u
= userdata
;
1351 unsigned short revents
= 0;
1355 pa_log_debug("Thread starting up");
1357 if (u
->core
->realtime_scheduling
)
1358 pa_make_realtime(u
->core
->realtime_priority
);
1360 pa_thread_mq_install(&u
->thread_mq
);
1366 pa_log_debug("Loop");
1369 /* Render some data and write it to the dsp */
1370 if (PA_SINK_IS_OPENED(u
->sink
->thread_info
.state
)) {
1372 pa_usec_t sleep_usec
= 0;
1373 pa_bool_t on_timeout
= pa_rtpoll_timer_elapsed(u
->rtpoll
);
1375 if (PA_UNLIKELY(u
->sink
->thread_info
.rewind_requested
))
1376 if (process_rewind(u
) < 0)
1380 work_done
= mmap_write(u
, &sleep_usec
, revents
& POLLOUT
, on_timeout
);
1382 work_done
= unix_write(u
, &sleep_usec
, revents
& POLLOUT
, on_timeout
);
1387 /* pa_log_debug("work_done = %i", work_done); */
1392 pa_log_info("Starting playback.");
1393 snd_pcm_start(u
->pcm_handle
);
1395 pa_smoother_resume(u
->smoother
, pa_rtclock_now(), TRUE
);
1401 if (u
->use_tsched
) {
1404 if (u
->since_start
<= u
->hwbuf_size
) {
1406 /* USB devices on ALSA seem to hit a buffer
1407 * underrun during the first iterations much
1408 * quicker then we calculate here, probably due to
1409 * the transport latency. To accommodate for that
1410 * we artificially decrease the sleep time until
1411 * we have filled the buffer at least once
1414 if (pa_log_ratelimit())
1415 pa_log_debug("Cutting sleep time for the initial iterations by half.");
1419 /* OK, the playback buffer is now full, let's
1420 * calculate when to wake up next */
1421 /* pa_log_debug("Waking up in %0.2fms (sound card clock).", (double) sleep_usec / PA_USEC_PER_MSEC); */
1423 /* Convert from the sound card time domain to the
1424 * system time domain */
1425 cusec
= pa_smoother_translate(u
->smoother
, pa_rtclock_now(), sleep_usec
);
1427 /* pa_log_debug("Waking up in %0.2fms (system clock).", (double) cusec / PA_USEC_PER_MSEC); */
1429 /* We don't trust the conversion, so we wake up whatever comes first */
1430 pa_rtpoll_set_timer_relative(u
->rtpoll
, PA_MIN(sleep_usec
, cusec
));
1434 u
->after_rewind
= FALSE
;
1436 } else if (u
->use_tsched
)
1438 /* OK, we're in an invalid state, let's disable our timers */
1439 pa_rtpoll_set_timer_disabled(u
->rtpoll
);
1441 /* Hmm, nothing to do. Let's sleep */
1442 if ((ret
= pa_rtpoll_run(u
->rtpoll
, TRUE
)) < 0)
1448 /* Tell ALSA about this and process its response */
1449 if (PA_SINK_IS_OPENED(u
->sink
->thread_info
.state
)) {
1450 struct pollfd
*pollfd
;
1454 pollfd
= pa_rtpoll_item_get_pollfd(u
->alsa_rtpoll_item
, &n
);
1456 if ((err
= snd_pcm_poll_descriptors_revents(u
->pcm_handle
, pollfd
, n
, &revents
)) < 0) {
1457 pa_log("snd_pcm_poll_descriptors_revents() failed: %s", pa_alsa_strerror(err
));
1461 if (revents
& ~POLLOUT
) {
1462 if (pa_alsa_recover_from_poll(u
->pcm_handle
, revents
) < 0)
1467 } else if (revents
&& u
->use_tsched
&& pa_log_ratelimit())
1468 pa_log_debug("Wakeup from ALSA!");
1475 /* If this was no regular exit from the loop we have to continue
1476 * processing messages until we received PA_MESSAGE_SHUTDOWN */
1477 pa_asyncmsgq_post(u
->thread_mq
.outq
, PA_MSGOBJECT(u
->core
), PA_CORE_MESSAGE_UNLOAD_MODULE
, u
->module
, 0, NULL
, NULL
);
1478 pa_asyncmsgq_wait_for(u
->thread_mq
.inq
, PA_MESSAGE_SHUTDOWN
);
1481 pa_log_debug("Thread shutting down");
1484 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
) {
1490 pa_assert(device_name
);
1492 if ((n
= pa_modargs_get_value(ma
, "sink_name", NULL
))) {
1493 pa_sink_new_data_set_name(data
, n
);
1494 data
->namereg_fail
= TRUE
;
1498 if ((n
= pa_modargs_get_value(ma
, "name", NULL
)))
1499 data
->namereg_fail
= TRUE
;
1501 n
= device_id
? device_id
: device_name
;
1502 data
->namereg_fail
= FALSE
;
1506 t
= pa_sprintf_malloc("alsa_output.%s.%s", n
, mapping
->name
);
1508 t
= pa_sprintf_malloc("alsa_output.%s", n
);
1510 pa_sink_new_data_set_name(data
, t
);
1514 static void find_mixer(struct userdata
*u
, pa_alsa_mapping
*mapping
, const char *element
, pa_bool_t ignore_dB
) {
1516 if (!mapping
&& !element
)
1519 if (!(u
->mixer_handle
= pa_alsa_open_mixer_for_pcm(u
->pcm_handle
, &u
->control_device
))) {
1520 pa_log_info("Failed to find a working mixer device.");
1526 if (!(u
->mixer_path
= pa_alsa_path_synthesize(element
, PA_ALSA_DIRECTION_OUTPUT
)))
1529 if (pa_alsa_path_probe(u
->mixer_path
, u
->mixer_handle
, ignore_dB
) < 0)
1532 pa_log_debug("Probed mixer path %s:", u
->mixer_path
->name
);
1533 pa_alsa_path_dump(u
->mixer_path
);
1536 if (!(u
->mixer_path_set
= pa_alsa_path_set_new(mapping
, PA_ALSA_DIRECTION_OUTPUT
)))
1539 pa_alsa_path_set_probe(u
->mixer_path_set
, u
->mixer_handle
, ignore_dB
);
1541 pa_log_debug("Probed mixer paths:");
1542 pa_alsa_path_set_dump(u
->mixer_path_set
);
1549 if (u
->mixer_path_set
) {
1550 pa_alsa_path_set_free(u
->mixer_path_set
);
1551 u
->mixer_path_set
= NULL
;
1552 } else if (u
->mixer_path
) {
1553 pa_alsa_path_free(u
->mixer_path
);
1554 u
->mixer_path
= NULL
;
1557 if (u
->mixer_handle
) {
1558 snd_mixer_close(u
->mixer_handle
);
1559 u
->mixer_handle
= NULL
;
1563 static int setup_mixer(struct userdata
*u
, pa_bool_t ignore_dB
) {
1566 if (!u
->mixer_handle
)
1569 if (u
->sink
->active_port
) {
1570 pa_alsa_port_data
*data
;
1572 /* We have a list of supported paths, so let's activate the
1573 * one that has been chosen as active */
1575 data
= PA_DEVICE_PORT_DATA(u
->sink
->active_port
);
1576 u
->mixer_path
= data
->path
;
1578 pa_alsa_path_select(data
->path
, u
->mixer_handle
);
1581 pa_alsa_setting_select(data
->setting
, u
->mixer_handle
);
1585 if (!u
->mixer_path
&& u
->mixer_path_set
)
1586 u
->mixer_path
= u
->mixer_path_set
->paths
;
1588 if (u
->mixer_path
) {
1589 /* Hmm, we have only a single path, then let's activate it */
1591 pa_alsa_path_select(u
->mixer_path
, u
->mixer_handle
);
1593 if (u
->mixer_path
->settings
)
1594 pa_alsa_setting_select(u
->mixer_path
->settings
, u
->mixer_handle
);
1599 if (!u
->mixer_path
->has_volume
)
1600 pa_log_info("Driver does not support hardware volume control, falling back to software volume control.");
1603 if (u
->mixer_path
->has_dB
) {
1604 pa_log_info("Hardware volume ranges from %0.2f dB to %0.2f dB.", u
->mixer_path
->min_dB
, u
->mixer_path
->max_dB
);
1606 u
->sink
->base_volume
= pa_sw_volume_from_dB(-u
->mixer_path
->max_dB
);
1607 u
->sink
->n_volume_steps
= PA_VOLUME_NORM
+1;
1609 if (u
->mixer_path
->max_dB
> 0.0)
1610 pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(u
->sink
->base_volume
));
1612 pa_log_info("No particular base volume set, fixing to 0 dB");
1615 pa_log_info("Hardware volume ranges from %li to %li.", u
->mixer_path
->min_volume
, u
->mixer_path
->max_volume
);
1616 u
->sink
->base_volume
= PA_VOLUME_NORM
;
1617 u
->sink
->n_volume_steps
= u
->mixer_path
->max_volume
- u
->mixer_path
->min_volume
+ 1;
1620 u
->sink
->get_volume
= sink_get_volume_cb
;
1621 u
->sink
->set_volume
= sink_set_volume_cb
;
1623 u
->sink
->flags
|= PA_SINK_HW_VOLUME_CTRL
| (u
->mixer_path
->has_dB
? PA_SINK_DECIBEL_VOLUME
: 0);
1624 pa_log_info("Using hardware volume control. Hardware dB scale %s.", u
->mixer_path
->has_dB
? "supported" : "not supported");
1627 if (!u
->mixer_path
->has_mute
) {
1628 pa_log_info("Driver does not support hardware mute control, falling back to software mute control.");
1630 u
->sink
->get_mute
= sink_get_mute_cb
;
1631 u
->sink
->set_mute
= sink_set_mute_cb
;
1632 u
->sink
->flags
|= PA_SINK_HW_MUTE_CTRL
;
1633 pa_log_info("Using hardware mute control.");
1636 u
->mixer_fdl
= pa_alsa_fdlist_new();
1638 if (pa_alsa_fdlist_set_mixer(u
->mixer_fdl
, u
->mixer_handle
, u
->core
->mainloop
) < 0) {
1639 pa_log("Failed to initialize file descriptor monitoring");
1643 if (u
->mixer_path_set
)
1644 pa_alsa_path_set_set_callback(u
->mixer_path_set
, u
->mixer_handle
, mixer_callback
, u
);
1646 pa_alsa_path_set_callback(u
->mixer_path
, u
->mixer_handle
, mixer_callback
, u
);
1651 pa_sink
*pa_alsa_sink_new(pa_module
*m
, pa_modargs
*ma
, const char*driver
, pa_card
*card
, pa_alsa_mapping
*mapping
) {
1653 struct userdata
*u
= NULL
;
1654 const char *dev_id
= NULL
;
1655 pa_sample_spec ss
, requested_ss
;
1657 uint32_t nfrags
, frag_size
, buffer_size
, tsched_size
, tsched_watermark
;
1658 snd_pcm_uframes_t period_frames
, buffer_frames
, tsched_frames
;
1660 pa_bool_t use_mmap
= TRUE
, b
, use_tsched
= TRUE
, d
, ignore_dB
= FALSE
;
1661 pa_sink_new_data data
;
1662 pa_alsa_profile_set
*profile_set
= NULL
;
1667 ss
= m
->core
->default_sample_spec
;
1668 map
= m
->core
->default_channel_map
;
1669 if (pa_modargs_get_sample_spec_and_channel_map(ma
, &ss
, &map
, PA_CHANNEL_MAP_ALSA
) < 0) {
1670 pa_log("Failed to parse sample specification and channel map");
1675 frame_size
= pa_frame_size(&ss
);
1677 nfrags
= m
->core
->default_n_fragments
;
1678 frag_size
= (uint32_t) pa_usec_to_bytes(m
->core
->default_fragment_size_msec
*PA_USEC_PER_MSEC
, &ss
);
1680 frag_size
= (uint32_t) frame_size
;
1681 tsched_size
= (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_BUFFER_USEC
, &ss
);
1682 tsched_watermark
= (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_WATERMARK_USEC
, &ss
);
1684 if (pa_modargs_get_value_u32(ma
, "fragments", &nfrags
) < 0 ||
1685 pa_modargs_get_value_u32(ma
, "fragment_size", &frag_size
) < 0 ||
1686 pa_modargs_get_value_u32(ma
, "tsched_buffer_size", &tsched_size
) < 0 ||
1687 pa_modargs_get_value_u32(ma
, "tsched_buffer_watermark", &tsched_watermark
) < 0) {
1688 pa_log("Failed to parse buffer metrics");
1692 buffer_size
= nfrags
* frag_size
;
1694 period_frames
= frag_size
/frame_size
;
1695 buffer_frames
= buffer_size
/frame_size
;
1696 tsched_frames
= tsched_size
/frame_size
;
1698 if (pa_modargs_get_value_boolean(ma
, "mmap", &use_mmap
) < 0) {
1699 pa_log("Failed to parse mmap argument.");
1703 if (pa_modargs_get_value_boolean(ma
, "tsched", &use_tsched
) < 0) {
1704 pa_log("Failed to parse tsched argument.");
1708 if (pa_modargs_get_value_boolean(ma
, "ignore_dB", &ignore_dB
) < 0) {
1709 pa_log("Failed to parse ignore_dB argument.");
1713 use_tsched
= pa_alsa_may_tsched(use_tsched
);
1715 u
= pa_xnew0(struct userdata
, 1);
1718 u
->use_mmap
= use_mmap
;
1719 u
->use_tsched
= use_tsched
;
1721 u
->rtpoll
= pa_rtpoll_new();
1722 pa_thread_mq_init(&u
->thread_mq
, m
->core
->mainloop
, u
->rtpoll
);
1724 u
->smoother
= pa_smoother_new(
1725 DEFAULT_TSCHED_BUFFER_USEC
*2,
1726 DEFAULT_TSCHED_BUFFER_USEC
*2,
1732 u
->smoother_interval
= SMOOTHER_MIN_INTERVAL
;
1734 dev_id
= pa_modargs_get_value(
1736 pa_modargs_get_value(ma
, "device", DEFAULT_DEVICE
));
1738 if (reserve_init(u
, dev_id
) < 0)
1741 if (reserve_monitor_init(u
, dev_id
) < 0)
1749 if (!(dev_id
= pa_modargs_get_value(ma
, "device_id", NULL
))) {
1750 pa_log("device_id= not set");
1754 if (!(u
->pcm_handle
= pa_alsa_open_by_device_id_mapping(
1758 SND_PCM_STREAM_PLAYBACK
,
1759 &period_frames
, &buffer_frames
, tsched_frames
,
1764 } else if ((dev_id
= pa_modargs_get_value(ma
, "device_id", NULL
))) {
1766 if (!(profile_set
= pa_alsa_profile_set_new(NULL
, &map
)))
1769 if (!(u
->pcm_handle
= pa_alsa_open_by_device_id_auto(
1773 SND_PCM_STREAM_PLAYBACK
,
1774 &period_frames
, &buffer_frames
, tsched_frames
,
1775 &b
, &d
, profile_set
, &mapping
)))
1781 if (!(u
->pcm_handle
= pa_alsa_open_by_device_string(
1782 pa_modargs_get_value(ma
, "device", DEFAULT_DEVICE
),
1785 SND_PCM_STREAM_PLAYBACK
,
1786 &period_frames
, &buffer_frames
, tsched_frames
,
1791 pa_assert(u
->device_name
);
1792 pa_log_info("Successfully opened device %s.", u
->device_name
);
1794 if (pa_alsa_pcm_is_modem(u
->pcm_handle
)) {
1795 pa_log_notice("Device %s is modem, refusing further initialization.", u
->device_name
);
1800 pa_log_info("Selected mapping '%s' (%s).", mapping
->description
, mapping
->name
);
1802 if (use_mmap
&& !b
) {
1803 pa_log_info("Device doesn't support mmap(), falling back to UNIX read/write mode.");
1804 u
->use_mmap
= use_mmap
= FALSE
;
1807 if (use_tsched
&& (!b
|| !d
)) {
1808 pa_log_info("Cannot enable timer-based scheduling, falling back to sound IRQ scheduling.");
1809 u
->use_tsched
= use_tsched
= FALSE
;
1813 pa_log_info("Successfully enabled mmap() mode.");
1816 pa_log_info("Successfully enabled timer-based scheduling mode.");
1818 /* ALSA might tweak the sample spec, so recalculate the frame size */
1819 frame_size
= pa_frame_size(&ss
);
1821 find_mixer(u
, mapping
, pa_modargs_get_value(ma
, "control", NULL
), ignore_dB
);
1823 pa_sink_new_data_init(&data
);
1824 data
.driver
= driver
;
1827 set_sink_name(&data
, ma
, dev_id
, u
->device_name
, mapping
);
1828 pa_sink_new_data_set_sample_spec(&data
, &ss
);
1829 pa_sink_new_data_set_channel_map(&data
, &map
);
1831 pa_alsa_init_proplist_pcm(m
->core
, data
.proplist
, u
->pcm_handle
);
1832 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_STRING
, u
->device_name
);
1833 pa_proplist_setf(data
.proplist
, PA_PROP_DEVICE_BUFFERING_BUFFER_SIZE
, "%lu", (unsigned long) (buffer_frames
* frame_size
));
1834 pa_proplist_setf(data
.proplist
, PA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZE
, "%lu", (unsigned long) (period_frames
* frame_size
));
1835 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_ACCESS_MODE
, u
->use_tsched
? "mmap+timer" : (u
->use_mmap
? "mmap" : "serial"));
1838 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_PROFILE_NAME
, mapping
->name
);
1839 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_PROFILE_DESCRIPTION
, mapping
->description
);
1842 pa_alsa_init_description(data
.proplist
);
1844 if (u
->control_device
)
1845 pa_alsa_init_proplist_ctl(data
.proplist
, u
->control_device
);
1847 if (pa_modargs_get_proplist(ma
, "sink_properties", data
.proplist
, PA_UPDATE_REPLACE
) < 0) {
1848 pa_log("Invalid properties");
1849 pa_sink_new_data_done(&data
);
1853 if (u
->mixer_path_set
)
1854 pa_alsa_add_ports(&data
.ports
, u
->mixer_path_set
);
1856 u
->sink
= pa_sink_new(m
->core
, &data
, PA_SINK_HARDWARE
|PA_SINK_LATENCY
|(u
->use_tsched
? PA_SINK_DYNAMIC_LATENCY
: 0));
1857 pa_sink_new_data_done(&data
);
1860 pa_log("Failed to create sink object");
1864 u
->sink
->parent
.process_msg
= sink_process_msg
;
1865 u
->sink
->update_requested_latency
= sink_update_requested_latency_cb
;
1866 u
->sink
->set_state
= sink_set_state_cb
;
1867 u
->sink
->set_port
= sink_set_port_cb
;
1868 u
->sink
->userdata
= u
;
1870 pa_sink_set_asyncmsgq(u
->sink
, u
->thread_mq
.inq
);
1871 pa_sink_set_rtpoll(u
->sink
, u
->rtpoll
);
1873 u
->frame_size
= frame_size
;
1874 u
->fragment_size
= frag_size
= (size_t) (period_frames
* frame_size
);
1875 u
->hwbuf_size
= buffer_size
= (size_t) (buffer_frames
* frame_size
);
1876 pa_cvolume_mute(&u
->hardware_volume
, u
->sink
->sample_spec
.channels
);
1878 pa_log_info("Using %0.1f fragments of size %lu bytes (%0.2fms), buffer size is %lu bytes (%0.2fms)",
1879 (double) u
->hwbuf_size
/ (double) u
->fragment_size
,
1880 (long unsigned) u
->fragment_size
,
1881 (double) pa_bytes_to_usec(u
->fragment_size
, &ss
) / PA_USEC_PER_MSEC
,
1882 (long unsigned) u
->hwbuf_size
,
1883 (double) pa_bytes_to_usec(u
->hwbuf_size
, &ss
) / PA_USEC_PER_MSEC
);
1885 pa_sink_set_max_request(u
->sink
, u
->hwbuf_size
);
1886 pa_sink_set_max_rewind(u
->sink
, u
->hwbuf_size
);
1888 if (u
->use_tsched
) {
1889 u
->tsched_watermark
= pa_usec_to_bytes_round_up(pa_bytes_to_usec_round_up(tsched_watermark
, &requested_ss
), &u
->sink
->sample_spec
);
1891 u
->watermark_inc_step
= pa_usec_to_bytes(TSCHED_WATERMARK_INC_STEP_USEC
, &u
->sink
->sample_spec
);
1892 u
->watermark_dec_step
= pa_usec_to_bytes(TSCHED_WATERMARK_DEC_STEP_USEC
, &u
->sink
->sample_spec
);
1894 u
->watermark_inc_threshold
= pa_usec_to_bytes_round_up(TSCHED_WATERMARK_INC_THRESHOLD_USEC
, &u
->sink
->sample_spec
);
1895 u
->watermark_dec_threshold
= pa_usec_to_bytes_round_up(TSCHED_WATERMARK_DEC_THRESHOLD_USEC
, &u
->sink
->sample_spec
);
1897 fix_min_sleep_wakeup(u
);
1898 fix_tsched_watermark(u
);
1900 pa_sink_set_latency_range(u
->sink
,
1902 pa_bytes_to_usec(u
->hwbuf_size
, &ss
));
1904 pa_log_info("Time scheduling watermark is %0.2fms",
1905 (double) pa_bytes_to_usec(u
->tsched_watermark
, &ss
) / PA_USEC_PER_MSEC
);
1907 pa_sink_set_fixed_latency(u
->sink
, pa_bytes_to_usec(u
->hwbuf_size
, &ss
));
1912 if (update_sw_params(u
) < 0)
1915 if (setup_mixer(u
, ignore_dB
) < 0)
1918 pa_alsa_dump(PA_LOG_DEBUG
, u
->pcm_handle
);
1920 if (!(u
->thread
= pa_thread_new(thread_func
, u
))) {
1921 pa_log("Failed to create thread.");
1925 /* Get initial mixer settings */
1926 if (data
.volume_is_set
) {
1927 if (u
->sink
->set_volume
)
1928 u
->sink
->set_volume(u
->sink
);
1930 if (u
->sink
->get_volume
)
1931 u
->sink
->get_volume(u
->sink
);
1934 if (data
.muted_is_set
) {
1935 if (u
->sink
->set_mute
)
1936 u
->sink
->set_mute(u
->sink
);
1938 if (u
->sink
->get_mute
)
1939 u
->sink
->get_mute(u
->sink
);
1942 pa_sink_put(u
->sink
);
1945 pa_alsa_profile_set_free(profile_set
);
1955 pa_alsa_profile_set_free(profile_set
);
1960 static void userdata_free(struct userdata
*u
) {
1964 pa_sink_unlink(u
->sink
);
1967 pa_asyncmsgq_send(u
->thread_mq
.inq
, NULL
, PA_MESSAGE_SHUTDOWN
, NULL
, 0, NULL
);
1968 pa_thread_free(u
->thread
);
1971 pa_thread_mq_done(&u
->thread_mq
);
1974 pa_sink_unref(u
->sink
);
1976 if (u
->memchunk
.memblock
)
1977 pa_memblock_unref(u
->memchunk
.memblock
);
1979 if (u
->alsa_rtpoll_item
)
1980 pa_rtpoll_item_free(u
->alsa_rtpoll_item
);
1983 pa_rtpoll_free(u
->rtpoll
);
1985 if (u
->pcm_handle
) {
1986 snd_pcm_drop(u
->pcm_handle
);
1987 snd_pcm_close(u
->pcm_handle
);
1991 pa_alsa_fdlist_free(u
->mixer_fdl
);
1993 if (u
->mixer_path_set
)
1994 pa_alsa_path_set_free(u
->mixer_path_set
);
1995 else if (u
->mixer_path
)
1996 pa_alsa_path_free(u
->mixer_path
);
1998 if (u
->mixer_handle
)
1999 snd_mixer_close(u
->mixer_handle
);
2002 pa_smoother_free(u
->smoother
);
2007 pa_xfree(u
->device_name
);
2008 pa_xfree(u
->control_device
);
2012 void pa_alsa_sink_free(pa_sink
*s
) {
2015 pa_sink_assert_ref(s
);
2016 pa_assert_se(u
= s
->userdata
);