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 inteval */
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 pa_log_info("Device suspended...");
884 /* Called from IO context */
885 static int update_sw_params(struct userdata
*u
) {
886 snd_pcm_uframes_t avail_min
;
891 /* Use the full buffer if noone asked us for anything specific */
897 if ((latency
= pa_sink_get_requested_latency_within_thread(u
->sink
)) != (pa_usec_t
) -1) {
900 pa_log_debug("Latency set to %0.2fms", (double) latency
/ PA_USEC_PER_MSEC
);
902 b
= pa_usec_to_bytes(latency
, &u
->sink
->sample_spec
);
904 /* We need at least one sample in our buffer */
906 if (PA_UNLIKELY(b
< u
->frame_size
))
909 u
->hwbuf_unused
= PA_LIKELY(b
< u
->hwbuf_size
) ? (u
->hwbuf_size
- b
) : 0;
912 fix_min_sleep_wakeup(u
);
913 fix_tsched_watermark(u
);
916 pa_log_debug("hwbuf_unused=%lu", (unsigned long) u
->hwbuf_unused
);
918 /* We need at last one frame in the used part of the buffer */
919 avail_min
= (snd_pcm_uframes_t
) u
->hwbuf_unused
/ u
->frame_size
+ 1;
922 pa_usec_t sleep_usec
, process_usec
;
924 hw_sleep_time(u
, &sleep_usec
, &process_usec
);
925 avail_min
+= pa_usec_to_bytes(sleep_usec
, &u
->sink
->sample_spec
) / u
->frame_size
;
928 pa_log_debug("setting avail_min=%lu", (unsigned long) avail_min
);
930 if ((err
= pa_alsa_set_sw_params(u
->pcm_handle
, avail_min
)) < 0) {
931 pa_log("Failed to set software parameters: %s", pa_alsa_strerror(err
));
935 pa_sink_set_max_request_within_thread(u
->sink
, u
->hwbuf_size
- u
->hwbuf_unused
);
940 /* Called from IO context */
941 static int unsuspend(struct userdata
*u
) {
945 snd_pcm_uframes_t period_size
, buffer_size
;
948 pa_assert(!u
->pcm_handle
);
950 pa_log_info("Trying resume...");
952 if ((err
= snd_pcm_open(&u
->pcm_handle
, u
->device_name
, SND_PCM_STREAM_PLAYBACK
,
954 SND_PCM_NO_AUTO_RESAMPLE
|
955 SND_PCM_NO_AUTO_CHANNELS
|
956 SND_PCM_NO_AUTO_FORMAT
)) < 0) {
957 pa_log("Error opening PCM device %s: %s", u
->device_name
, pa_alsa_strerror(err
));
961 ss
= u
->sink
->sample_spec
;
962 period_size
= u
->fragment_size
/ u
->frame_size
;
963 buffer_size
= u
->hwbuf_size
/ u
->frame_size
;
967 if ((err
= pa_alsa_set_hw_params(u
->pcm_handle
, &ss
, &period_size
, &buffer_size
, 0, &b
, &d
, TRUE
)) < 0) {
968 pa_log("Failed to set hardware parameters: %s", pa_alsa_strerror(err
));
972 if (b
!= u
->use_mmap
|| d
!= u
->use_tsched
) {
973 pa_log_warn("Resume failed, couldn't get original access mode.");
977 if (!pa_sample_spec_equal(&ss
, &u
->sink
->sample_spec
)) {
978 pa_log_warn("Resume failed, couldn't restore original sample settings.");
982 if (period_size
*u
->frame_size
!= u
->fragment_size
||
983 buffer_size
*u
->frame_size
!= u
->hwbuf_size
) {
984 pa_log_warn("Resume failed, couldn't restore original fragment settings. (Old: %lu/%lu, New %lu/%lu)",
985 (unsigned long) u
->hwbuf_size
, (unsigned long) u
->fragment_size
,
986 (unsigned long) (buffer_size
*u
->fragment_size
), (unsigned long) (period_size
*u
->frame_size
));
990 if (update_sw_params(u
) < 0)
993 if (build_pollfd(u
) < 0)
997 pa_smoother_reset(u
->smoother
, pa_rtclock_now(), TRUE
);
998 u
->smoother_interval
= SMOOTHER_MIN_INTERVAL
;
999 u
->last_smoother_update
= 0;
1004 pa_log_info("Resumed successfully...");
1009 if (u
->pcm_handle
) {
1010 snd_pcm_close(u
->pcm_handle
);
1011 u
->pcm_handle
= NULL
;
1017 /* Called from IO context */
1018 static int sink_process_msg(pa_msgobject
*o
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
1019 struct userdata
*u
= PA_SINK(o
)->userdata
;
1023 case PA_SINK_MESSAGE_GET_LATENCY
: {
1027 r
= sink_get_latency(u
);
1029 *((pa_usec_t
*) data
) = r
;
1034 case PA_SINK_MESSAGE_SET_STATE
:
1036 switch ((pa_sink_state_t
) PA_PTR_TO_UINT(data
)) {
1038 case PA_SINK_SUSPENDED
:
1039 pa_assert(PA_SINK_IS_OPENED(u
->sink
->thread_info
.state
));
1047 case PA_SINK_RUNNING
:
1049 if (u
->sink
->thread_info
.state
== PA_SINK_INIT
) {
1050 if (build_pollfd(u
) < 0)
1054 if (u
->sink
->thread_info
.state
== PA_SINK_SUSPENDED
) {
1055 if (unsuspend(u
) < 0)
1061 case PA_SINK_UNLINKED
:
1063 case PA_SINK_INVALID_STATE
:
1070 return pa_sink_process_msg(o
, code
, data
, offset
, chunk
);
1073 /* Called from main context */
1074 static int sink_set_state_cb(pa_sink
*s
, pa_sink_state_t new_state
) {
1075 pa_sink_state_t old_state
;
1078 pa_sink_assert_ref(s
);
1079 pa_assert_se(u
= s
->userdata
);
1081 old_state
= pa_sink_get_state(u
->sink
);
1083 if (PA_SINK_IS_OPENED(old_state
) && new_state
== PA_SINK_SUSPENDED
)
1085 else if (old_state
== PA_SINK_SUSPENDED
&& PA_SINK_IS_OPENED(new_state
))
1086 if (reserve_init(u
, u
->device_name
) < 0)
1092 static int mixer_callback(snd_mixer_elem_t
*elem
, unsigned int mask
) {
1093 struct userdata
*u
= snd_mixer_elem_get_callback_private(elem
);
1096 pa_assert(u
->mixer_handle
);
1098 if (mask
== SND_CTL_EVENT_MASK_REMOVE
)
1101 if (mask
& SND_CTL_EVENT_MASK_VALUE
) {
1102 pa_sink_get_volume(u
->sink
, TRUE
);
1103 pa_sink_get_mute(u
->sink
, TRUE
);
1109 static void sink_get_volume_cb(pa_sink
*s
) {
1110 struct userdata
*u
= s
->userdata
;
1112 char t
[PA_CVOLUME_SNPRINT_MAX
];
1115 pa_assert(u
->mixer_path
);
1116 pa_assert(u
->mixer_handle
);
1118 if (pa_alsa_path_get_volume(u
->mixer_path
, u
->mixer_handle
, &s
->channel_map
, &r
) < 0)
1121 /* Shift down by the base volume, so that 0dB becomes maximum volume */
1122 pa_sw_cvolume_multiply_scalar(&r
, &r
, s
->base_volume
);
1124 pa_log_debug("Read hardware volume: %s", pa_cvolume_snprint(t
, sizeof(t
), &r
));
1126 if (pa_cvolume_equal(&u
->hardware_volume
, &r
))
1129 s
->real_volume
= u
->hardware_volume
= r
;
1131 /* Hmm, so the hardware volume changed, let's reset our software volume */
1132 if (u
->mixer_path
->has_dB
)
1133 pa_sink_set_soft_volume(s
, NULL
);
1136 static void sink_set_volume_cb(pa_sink
*s
) {
1137 struct userdata
*u
= s
->userdata
;
1139 char t
[PA_CVOLUME_SNPRINT_MAX
];
1142 pa_assert(u
->mixer_path
);
1143 pa_assert(u
->mixer_handle
);
1145 /* Shift up by the base volume */
1146 pa_sw_cvolume_divide_scalar(&r
, &s
->real_volume
, s
->base_volume
);
1148 if (pa_alsa_path_set_volume(u
->mixer_path
, u
->mixer_handle
, &s
->channel_map
, &r
) < 0)
1151 /* Shift down by the base volume, so that 0dB becomes maximum volume */
1152 pa_sw_cvolume_multiply_scalar(&r
, &r
, s
->base_volume
);
1154 u
->hardware_volume
= r
;
1156 if (u
->mixer_path
->has_dB
) {
1157 pa_cvolume new_soft_volume
;
1158 pa_bool_t accurate_enough
;
1160 /* Match exactly what the user requested by software */
1161 pa_sw_cvolume_divide(&new_soft_volume
, &s
->real_volume
, &u
->hardware_volume
);
1163 /* If the adjustment to do in software is only minimal we
1164 * can skip it. That saves us CPU at the expense of a bit of
1167 (pa_cvolume_min(&new_soft_volume
) >= (PA_VOLUME_NORM
- VOLUME_ACCURACY
)) &&
1168 (pa_cvolume_max(&new_soft_volume
) <= (PA_VOLUME_NORM
+ VOLUME_ACCURACY
));
1170 pa_log_debug("Requested volume: %s", pa_cvolume_snprint(t
, sizeof(t
), &s
->real_volume
));
1171 pa_log_debug("Got hardware volume: %s", pa_cvolume_snprint(t
, sizeof(t
), &u
->hardware_volume
));
1172 pa_log_debug("Calculated software volume: %s (accurate-enough=%s)", pa_cvolume_snprint(t
, sizeof(t
), &new_soft_volume
),
1173 pa_yes_no(accurate_enough
));
1175 if (!accurate_enough
)
1176 s
->soft_volume
= new_soft_volume
;
1179 pa_log_debug("Wrote hardware volume: %s", pa_cvolume_snprint(t
, sizeof(t
), &r
));
1181 /* We can't match exactly what the user requested, hence let's
1182 * at least tell the user about it */
1188 static void sink_get_mute_cb(pa_sink
*s
) {
1189 struct userdata
*u
= s
->userdata
;
1193 pa_assert(u
->mixer_path
);
1194 pa_assert(u
->mixer_handle
);
1196 if (pa_alsa_path_get_mute(u
->mixer_path
, u
->mixer_handle
, &b
) < 0)
1202 static void sink_set_mute_cb(pa_sink
*s
) {
1203 struct userdata
*u
= s
->userdata
;
1206 pa_assert(u
->mixer_path
);
1207 pa_assert(u
->mixer_handle
);
1209 pa_alsa_path_set_mute(u
->mixer_path
, u
->mixer_handle
, s
->muted
);
1212 static int sink_set_port_cb(pa_sink
*s
, pa_device_port
*p
) {
1213 struct userdata
*u
= s
->userdata
;
1214 pa_alsa_port_data
*data
;
1218 pa_assert(u
->mixer_handle
);
1220 data
= PA_DEVICE_PORT_DATA(p
);
1222 pa_assert_se(u
->mixer_path
= data
->path
);
1223 pa_alsa_path_select(u
->mixer_path
, u
->mixer_handle
);
1225 if (u
->mixer_path
->has_volume
&& u
->mixer_path
->has_dB
) {
1226 s
->base_volume
= pa_sw_volume_from_dB(-u
->mixer_path
->max_dB
);
1227 s
->n_volume_steps
= PA_VOLUME_NORM
+1;
1229 if (u
->mixer_path
->max_dB
> 0.0)
1230 pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(s
->base_volume
));
1232 pa_log_info("No particular base volume set, fixing to 0 dB");
1234 s
->base_volume
= PA_VOLUME_NORM
;
1235 s
->n_volume_steps
= u
->mixer_path
->max_volume
- u
->mixer_path
->min_volume
+ 1;
1239 pa_alsa_setting_select(data
->setting
, u
->mixer_handle
);
1249 static void sink_update_requested_latency_cb(pa_sink
*s
) {
1250 struct userdata
*u
= s
->userdata
;
1257 before
= u
->hwbuf_unused
;
1258 update_sw_params(u
);
1260 /* Let's check whether we now use only a smaller part of the
1261 buffer then before. If so, we need to make sure that subsequent
1262 rewinds are relative to the new maximum fill level and not to the
1263 current fill level. Thus, let's do a full rewind once, to clear
1266 if (u
->hwbuf_unused
> before
) {
1267 pa_log_debug("Requesting rewind due to latency change.");
1268 pa_sink_request_rewind(s
, (size_t) -1);
1272 static int process_rewind(struct userdata
*u
) {
1273 snd_pcm_sframes_t unused
;
1274 size_t rewind_nbytes
, unused_nbytes
, limit_nbytes
;
1277 /* Figure out how much we shall rewind and reset the counter */
1278 rewind_nbytes
= u
->sink
->thread_info
.rewind_nbytes
;
1280 pa_log_debug("Requested to rewind %lu bytes.", (unsigned long) rewind_nbytes
);
1282 if (PA_UNLIKELY((unused
= pa_alsa_safe_avail(u
->pcm_handle
, u
->hwbuf_size
, &u
->sink
->sample_spec
)) < 0)) {
1283 pa_log("snd_pcm_avail() failed: %s", pa_alsa_strerror((int) unused
));
1287 unused_nbytes
= u
->tsched_watermark
+ (size_t) unused
* u
->frame_size
;
1289 if (u
->hwbuf_size
> unused_nbytes
)
1290 limit_nbytes
= u
->hwbuf_size
- unused_nbytes
;
1294 if (rewind_nbytes
> limit_nbytes
)
1295 rewind_nbytes
= limit_nbytes
;
1297 if (rewind_nbytes
> 0) {
1298 snd_pcm_sframes_t in_frames
, out_frames
;
1300 pa_log_debug("Limited to %lu bytes.", (unsigned long) rewind_nbytes
);
1302 in_frames
= (snd_pcm_sframes_t
) (rewind_nbytes
/ u
->frame_size
);
1303 pa_log_debug("before: %lu", (unsigned long) in_frames
);
1304 if ((out_frames
= snd_pcm_rewind(u
->pcm_handle
, (snd_pcm_uframes_t
) in_frames
)) < 0) {
1305 pa_log("snd_pcm_rewind() failed: %s", pa_alsa_strerror((int) out_frames
));
1306 if (try_recover(u
, "process_rewind", out_frames
) < 0)
1311 pa_log_debug("after: %lu", (unsigned long) out_frames
);
1313 rewind_nbytes
= (size_t) out_frames
* u
->frame_size
;
1315 if (rewind_nbytes
<= 0)
1316 pa_log_info("Tried rewind, but was apparently not possible.");
1318 u
->write_count
-= rewind_nbytes
;
1319 pa_log_debug("Rewound %lu bytes.", (unsigned long) rewind_nbytes
);
1320 pa_sink_process_rewind(u
->sink
, rewind_nbytes
);
1322 u
->after_rewind
= TRUE
;
1326 pa_log_debug("Mhmm, actually there is nothing to rewind.");
1328 pa_sink_process_rewind(u
->sink
, 0);
1332 static void thread_func(void *userdata
) {
1333 struct userdata
*u
= userdata
;
1334 unsigned short revents
= 0;
1338 pa_log_debug("Thread starting up");
1340 if (u
->core
->realtime_scheduling
)
1341 pa_make_realtime(u
->core
->realtime_priority
);
1343 pa_thread_mq_install(&u
->thread_mq
);
1349 pa_log_debug("Loop");
1352 /* Render some data and write it to the dsp */
1353 if (PA_SINK_IS_OPENED(u
->sink
->thread_info
.state
)) {
1355 pa_usec_t sleep_usec
= 0;
1356 pa_bool_t on_timeout
= pa_rtpoll_timer_elapsed(u
->rtpoll
);
1358 if (PA_UNLIKELY(u
->sink
->thread_info
.rewind_requested
))
1359 if (process_rewind(u
) < 0)
1363 work_done
= mmap_write(u
, &sleep_usec
, revents
& POLLOUT
, on_timeout
);
1365 work_done
= unix_write(u
, &sleep_usec
, revents
& POLLOUT
, on_timeout
);
1370 /* pa_log_debug("work_done = %i", work_done); */
1375 pa_log_info("Starting playback.");
1376 snd_pcm_start(u
->pcm_handle
);
1378 pa_smoother_resume(u
->smoother
, pa_rtclock_now(), TRUE
);
1384 if (u
->use_tsched
) {
1387 if (u
->since_start
<= u
->hwbuf_size
) {
1389 /* USB devices on ALSA seem to hit a buffer
1390 * underrun during the first iterations much
1391 * quicker then we calculate here, probably due to
1392 * the transport latency. To accommodate for that
1393 * we artificially decrease the sleep time until
1394 * we have filled the buffer at least once
1397 if (pa_log_ratelimit())
1398 pa_log_debug("Cutting sleep time for the initial iterations by half.");
1402 /* OK, the playback buffer is now full, let's
1403 * calculate when to wake up next */
1404 /* pa_log_debug("Waking up in %0.2fms (sound card clock).", (double) sleep_usec / PA_USEC_PER_MSEC); */
1406 /* Convert from the sound card time domain to the
1407 * system time domain */
1408 cusec
= pa_smoother_translate(u
->smoother
, pa_rtclock_now(), sleep_usec
);
1410 /* pa_log_debug("Waking up in %0.2fms (system clock).", (double) cusec / PA_USEC_PER_MSEC); */
1412 /* We don't trust the conversion, so we wake up whatever comes first */
1413 pa_rtpoll_set_timer_relative(u
->rtpoll
, PA_MIN(sleep_usec
, cusec
));
1417 u
->after_rewind
= FALSE
;
1419 } else if (u
->use_tsched
)
1421 /* OK, we're in an invalid state, let's disable our timers */
1422 pa_rtpoll_set_timer_disabled(u
->rtpoll
);
1424 /* Hmm, nothing to do. Let's sleep */
1425 if ((ret
= pa_rtpoll_run(u
->rtpoll
, TRUE
)) < 0)
1431 /* Tell ALSA about this and process its response */
1432 if (PA_SINK_IS_OPENED(u
->sink
->thread_info
.state
)) {
1433 struct pollfd
*pollfd
;
1437 pollfd
= pa_rtpoll_item_get_pollfd(u
->alsa_rtpoll_item
, &n
);
1439 if ((err
= snd_pcm_poll_descriptors_revents(u
->pcm_handle
, pollfd
, n
, &revents
)) < 0) {
1440 pa_log("snd_pcm_poll_descriptors_revents() failed: %s", pa_alsa_strerror(err
));
1444 if (revents
& ~POLLOUT
) {
1445 if (pa_alsa_recover_from_poll(u
->pcm_handle
, revents
) < 0)
1450 } else if (revents
&& u
->use_tsched
&& pa_log_ratelimit())
1451 pa_log_debug("Wakeup from ALSA!");
1458 /* If this was no regular exit from the loop we have to continue
1459 * processing messages until we received PA_MESSAGE_SHUTDOWN */
1460 pa_asyncmsgq_post(u
->thread_mq
.outq
, PA_MSGOBJECT(u
->core
), PA_CORE_MESSAGE_UNLOAD_MODULE
, u
->module
, 0, NULL
, NULL
);
1461 pa_asyncmsgq_wait_for(u
->thread_mq
.inq
, PA_MESSAGE_SHUTDOWN
);
1464 pa_log_debug("Thread shutting down");
1467 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
) {
1473 pa_assert(device_name
);
1475 if ((n
= pa_modargs_get_value(ma
, "sink_name", NULL
))) {
1476 pa_sink_new_data_set_name(data
, n
);
1477 data
->namereg_fail
= TRUE
;
1481 if ((n
= pa_modargs_get_value(ma
, "name", NULL
)))
1482 data
->namereg_fail
= TRUE
;
1484 n
= device_id
? device_id
: device_name
;
1485 data
->namereg_fail
= FALSE
;
1489 t
= pa_sprintf_malloc("alsa_output.%s.%s", n
, mapping
->name
);
1491 t
= pa_sprintf_malloc("alsa_output.%s", n
);
1493 pa_sink_new_data_set_name(data
, t
);
1497 static void find_mixer(struct userdata
*u
, pa_alsa_mapping
*mapping
, const char *element
, pa_bool_t ignore_dB
) {
1499 if (!mapping
&& !element
)
1502 if (!(u
->mixer_handle
= pa_alsa_open_mixer_for_pcm(u
->pcm_handle
, &u
->control_device
))) {
1503 pa_log_info("Failed to find a working mixer device.");
1509 if (!(u
->mixer_path
= pa_alsa_path_synthesize(element
, PA_ALSA_DIRECTION_OUTPUT
)))
1512 if (pa_alsa_path_probe(u
->mixer_path
, u
->mixer_handle
, ignore_dB
) < 0)
1515 pa_log_debug("Probed mixer path %s:", u
->mixer_path
->name
);
1516 pa_alsa_path_dump(u
->mixer_path
);
1519 if (!(u
->mixer_path_set
= pa_alsa_path_set_new(mapping
, PA_ALSA_DIRECTION_OUTPUT
)))
1522 pa_alsa_path_set_probe(u
->mixer_path_set
, u
->mixer_handle
, ignore_dB
);
1524 pa_log_debug("Probed mixer paths:");
1525 pa_alsa_path_set_dump(u
->mixer_path_set
);
1532 if (u
->mixer_path_set
) {
1533 pa_alsa_path_set_free(u
->mixer_path_set
);
1534 u
->mixer_path_set
= NULL
;
1535 } else if (u
->mixer_path
) {
1536 pa_alsa_path_free(u
->mixer_path
);
1537 u
->mixer_path
= NULL
;
1540 if (u
->mixer_handle
) {
1541 snd_mixer_close(u
->mixer_handle
);
1542 u
->mixer_handle
= NULL
;
1546 static int setup_mixer(struct userdata
*u
, pa_bool_t ignore_dB
) {
1549 if (!u
->mixer_handle
)
1552 if (u
->sink
->active_port
) {
1553 pa_alsa_port_data
*data
;
1555 /* We have a list of supported paths, so let's activate the
1556 * one that has been chosen as active */
1558 data
= PA_DEVICE_PORT_DATA(u
->sink
->active_port
);
1559 u
->mixer_path
= data
->path
;
1561 pa_alsa_path_select(data
->path
, u
->mixer_handle
);
1564 pa_alsa_setting_select(data
->setting
, u
->mixer_handle
);
1568 if (!u
->mixer_path
&& u
->mixer_path_set
)
1569 u
->mixer_path
= u
->mixer_path_set
->paths
;
1571 if (u
->mixer_path
) {
1572 /* Hmm, we have only a single path, then let's activate it */
1574 pa_alsa_path_select(u
->mixer_path
, u
->mixer_handle
);
1576 if (u
->mixer_path
->settings
)
1577 pa_alsa_setting_select(u
->mixer_path
->settings
, u
->mixer_handle
);
1582 if (!u
->mixer_path
->has_volume
)
1583 pa_log_info("Driver does not support hardware volume control, falling back to software volume control.");
1586 if (u
->mixer_path
->has_dB
) {
1587 pa_log_info("Hardware volume ranges from %0.2f dB to %0.2f dB.", u
->mixer_path
->min_dB
, u
->mixer_path
->max_dB
);
1589 u
->sink
->base_volume
= pa_sw_volume_from_dB(-u
->mixer_path
->max_dB
);
1590 u
->sink
->n_volume_steps
= PA_VOLUME_NORM
+1;
1592 if (u
->mixer_path
->max_dB
> 0.0)
1593 pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(u
->sink
->base_volume
));
1595 pa_log_info("No particular base volume set, fixing to 0 dB");
1598 pa_log_info("Hardware volume ranges from %li to %li.", u
->mixer_path
->min_volume
, u
->mixer_path
->max_volume
);
1599 u
->sink
->base_volume
= PA_VOLUME_NORM
;
1600 u
->sink
->n_volume_steps
= u
->mixer_path
->max_volume
- u
->mixer_path
->min_volume
+ 1;
1603 u
->sink
->get_volume
= sink_get_volume_cb
;
1604 u
->sink
->set_volume
= sink_set_volume_cb
;
1606 u
->sink
->flags
|= PA_SINK_HW_VOLUME_CTRL
| (u
->mixer_path
->has_dB
? PA_SINK_DECIBEL_VOLUME
: 0);
1607 pa_log_info("Using hardware volume control. Hardware dB scale %s.", u
->mixer_path
->has_dB
? "supported" : "not supported");
1610 if (!u
->mixer_path
->has_mute
) {
1611 pa_log_info("Driver does not support hardware mute control, falling back to software mute control.");
1613 u
->sink
->get_mute
= sink_get_mute_cb
;
1614 u
->sink
->set_mute
= sink_set_mute_cb
;
1615 u
->sink
->flags
|= PA_SINK_HW_MUTE_CTRL
;
1616 pa_log_info("Using hardware mute control.");
1619 u
->mixer_fdl
= pa_alsa_fdlist_new();
1621 if (pa_alsa_fdlist_set_mixer(u
->mixer_fdl
, u
->mixer_handle
, u
->core
->mainloop
) < 0) {
1622 pa_log("Failed to initialize file descriptor monitoring");
1626 if (u
->mixer_path_set
)
1627 pa_alsa_path_set_set_callback(u
->mixer_path_set
, u
->mixer_handle
, mixer_callback
, u
);
1629 pa_alsa_path_set_callback(u
->mixer_path
, u
->mixer_handle
, mixer_callback
, u
);
1634 pa_sink
*pa_alsa_sink_new(pa_module
*m
, pa_modargs
*ma
, const char*driver
, pa_card
*card
, pa_alsa_mapping
*mapping
) {
1636 struct userdata
*u
= NULL
;
1637 const char *dev_id
= NULL
;
1638 pa_sample_spec ss
, requested_ss
;
1640 uint32_t nfrags
, frag_size
, buffer_size
, tsched_size
, tsched_watermark
;
1641 snd_pcm_uframes_t period_frames
, buffer_frames
, tsched_frames
;
1643 pa_bool_t use_mmap
= TRUE
, b
, use_tsched
= TRUE
, d
, ignore_dB
= FALSE
;
1644 pa_sink_new_data data
;
1645 pa_alsa_profile_set
*profile_set
= NULL
;
1650 ss
= m
->core
->default_sample_spec
;
1651 map
= m
->core
->default_channel_map
;
1652 if (pa_modargs_get_sample_spec_and_channel_map(ma
, &ss
, &map
, PA_CHANNEL_MAP_ALSA
) < 0) {
1653 pa_log("Failed to parse sample specification and channel map");
1658 frame_size
= pa_frame_size(&ss
);
1660 nfrags
= m
->core
->default_n_fragments
;
1661 frag_size
= (uint32_t) pa_usec_to_bytes(m
->core
->default_fragment_size_msec
*PA_USEC_PER_MSEC
, &ss
);
1663 frag_size
= (uint32_t) frame_size
;
1664 tsched_size
= (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_BUFFER_USEC
, &ss
);
1665 tsched_watermark
= (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_WATERMARK_USEC
, &ss
);
1667 if (pa_modargs_get_value_u32(ma
, "fragments", &nfrags
) < 0 ||
1668 pa_modargs_get_value_u32(ma
, "fragment_size", &frag_size
) < 0 ||
1669 pa_modargs_get_value_u32(ma
, "tsched_buffer_size", &tsched_size
) < 0 ||
1670 pa_modargs_get_value_u32(ma
, "tsched_buffer_watermark", &tsched_watermark
) < 0) {
1671 pa_log("Failed to parse buffer metrics");
1675 buffer_size
= nfrags
* frag_size
;
1677 period_frames
= frag_size
/frame_size
;
1678 buffer_frames
= buffer_size
/frame_size
;
1679 tsched_frames
= tsched_size
/frame_size
;
1681 if (pa_modargs_get_value_boolean(ma
, "mmap", &use_mmap
) < 0) {
1682 pa_log("Failed to parse mmap argument.");
1686 if (pa_modargs_get_value_boolean(ma
, "tsched", &use_tsched
) < 0) {
1687 pa_log("Failed to parse tsched argument.");
1691 if (pa_modargs_get_value_boolean(ma
, "ignore_dB", &ignore_dB
) < 0) {
1692 pa_log("Failed to parse ignore_dB argument.");
1696 if (use_tsched
&& !pa_rtclock_hrtimer()) {
1697 pa_log_notice("Disabling timer-based scheduling because high-resolution timers are not available from the kernel.");
1701 u
= pa_xnew0(struct userdata
, 1);
1704 u
->use_mmap
= use_mmap
;
1705 u
->use_tsched
= use_tsched
;
1707 u
->rtpoll
= pa_rtpoll_new();
1708 pa_thread_mq_init(&u
->thread_mq
, m
->core
->mainloop
, u
->rtpoll
);
1710 u
->smoother
= pa_smoother_new(
1711 DEFAULT_TSCHED_BUFFER_USEC
*2,
1712 DEFAULT_TSCHED_BUFFER_USEC
*2,
1718 u
->smoother_interval
= SMOOTHER_MIN_INTERVAL
;
1720 dev_id
= pa_modargs_get_value(
1722 pa_modargs_get_value(ma
, "device", DEFAULT_DEVICE
));
1724 if (reserve_init(u
, dev_id
) < 0)
1727 if (reserve_monitor_init(u
, dev_id
) < 0)
1735 if (!(dev_id
= pa_modargs_get_value(ma
, "device_id", NULL
))) {
1736 pa_log("device_id= not set");
1740 if (!(u
->pcm_handle
= pa_alsa_open_by_device_id_mapping(
1744 SND_PCM_STREAM_PLAYBACK
,
1745 &period_frames
, &buffer_frames
, tsched_frames
,
1750 } else if ((dev_id
= pa_modargs_get_value(ma
, "device_id", NULL
))) {
1752 if (!(profile_set
= pa_alsa_profile_set_new(NULL
, &map
)))
1755 if (!(u
->pcm_handle
= pa_alsa_open_by_device_id_auto(
1759 SND_PCM_STREAM_PLAYBACK
,
1760 &period_frames
, &buffer_frames
, tsched_frames
,
1761 &b
, &d
, profile_set
, &mapping
)))
1767 if (!(u
->pcm_handle
= pa_alsa_open_by_device_string(
1768 pa_modargs_get_value(ma
, "device", DEFAULT_DEVICE
),
1771 SND_PCM_STREAM_PLAYBACK
,
1772 &period_frames
, &buffer_frames
, tsched_frames
,
1777 pa_assert(u
->device_name
);
1778 pa_log_info("Successfully opened device %s.", u
->device_name
);
1780 if (pa_alsa_pcm_is_modem(u
->pcm_handle
)) {
1781 pa_log_notice("Device %s is modem, refusing further initialization.", u
->device_name
);
1786 pa_log_info("Selected mapping '%s' (%s).", mapping
->description
, mapping
->name
);
1788 if (use_mmap
&& !b
) {
1789 pa_log_info("Device doesn't support mmap(), falling back to UNIX read/write mode.");
1790 u
->use_mmap
= use_mmap
= FALSE
;
1793 if (use_tsched
&& (!b
|| !d
)) {
1794 pa_log_info("Cannot enable timer-based scheduling, falling back to sound IRQ scheduling.");
1795 u
->use_tsched
= use_tsched
= FALSE
;
1799 pa_log_info("Successfully enabled mmap() mode.");
1802 pa_log_info("Successfully enabled timer-based scheduling mode.");
1804 /* ALSA might tweak the sample spec, so recalculate the frame size */
1805 frame_size
= pa_frame_size(&ss
);
1807 find_mixer(u
, mapping
, pa_modargs_get_value(ma
, "control", NULL
), ignore_dB
);
1809 pa_sink_new_data_init(&data
);
1810 data
.driver
= driver
;
1813 set_sink_name(&data
, ma
, dev_id
, u
->device_name
, mapping
);
1814 pa_sink_new_data_set_sample_spec(&data
, &ss
);
1815 pa_sink_new_data_set_channel_map(&data
, &map
);
1817 pa_alsa_init_proplist_pcm(m
->core
, data
.proplist
, u
->pcm_handle
);
1818 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_STRING
, u
->device_name
);
1819 pa_proplist_setf(data
.proplist
, PA_PROP_DEVICE_BUFFERING_BUFFER_SIZE
, "%lu", (unsigned long) (buffer_frames
* frame_size
));
1820 pa_proplist_setf(data
.proplist
, PA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZE
, "%lu", (unsigned long) (period_frames
* frame_size
));
1821 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_ACCESS_MODE
, u
->use_tsched
? "mmap+timer" : (u
->use_mmap
? "mmap" : "serial"));
1824 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_PROFILE_NAME
, mapping
->name
);
1825 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_PROFILE_DESCRIPTION
, mapping
->description
);
1828 pa_alsa_init_description(data
.proplist
);
1830 if (u
->control_device
)
1831 pa_alsa_init_proplist_ctl(data
.proplist
, u
->control_device
);
1833 if (pa_modargs_get_proplist(ma
, "sink_properties", data
.proplist
, PA_UPDATE_REPLACE
) < 0) {
1834 pa_log("Invalid properties");
1835 pa_sink_new_data_done(&data
);
1839 if (u
->mixer_path_set
)
1840 pa_alsa_add_ports(&data
.ports
, u
->mixer_path_set
);
1842 u
->sink
= pa_sink_new(m
->core
, &data
, PA_SINK_HARDWARE
|PA_SINK_LATENCY
|(u
->use_tsched
? PA_SINK_DYNAMIC_LATENCY
: 0));
1843 pa_sink_new_data_done(&data
);
1846 pa_log("Failed to create sink object");
1850 u
->sink
->parent
.process_msg
= sink_process_msg
;
1851 u
->sink
->update_requested_latency
= sink_update_requested_latency_cb
;
1852 u
->sink
->set_state
= sink_set_state_cb
;
1853 u
->sink
->set_port
= sink_set_port_cb
;
1854 u
->sink
->userdata
= u
;
1856 pa_sink_set_asyncmsgq(u
->sink
, u
->thread_mq
.inq
);
1857 pa_sink_set_rtpoll(u
->sink
, u
->rtpoll
);
1859 u
->frame_size
= frame_size
;
1860 u
->fragment_size
= frag_size
= (size_t) (period_frames
* frame_size
);
1861 u
->hwbuf_size
= buffer_size
= (size_t) (buffer_frames
* frame_size
);
1862 pa_cvolume_mute(&u
->hardware_volume
, u
->sink
->sample_spec
.channels
);
1864 pa_log_info("Using %0.1f fragments of size %lu bytes (%0.2fms), buffer size is %lu bytes (%0.2fms)",
1865 (double) u
->hwbuf_size
/ (double) u
->fragment_size
,
1866 (long unsigned) u
->fragment_size
,
1867 (double) pa_bytes_to_usec(u
->fragment_size
, &ss
) / PA_USEC_PER_MSEC
,
1868 (long unsigned) u
->hwbuf_size
,
1869 (double) pa_bytes_to_usec(u
->hwbuf_size
, &ss
) / PA_USEC_PER_MSEC
);
1871 pa_sink_set_max_request(u
->sink
, u
->hwbuf_size
);
1872 pa_sink_set_max_rewind(u
->sink
, u
->hwbuf_size
);
1874 if (u
->use_tsched
) {
1875 u
->tsched_watermark
= pa_usec_to_bytes_round_up(pa_bytes_to_usec_round_up(tsched_watermark
, &requested_ss
), &u
->sink
->sample_spec
);
1877 u
->watermark_inc_step
= pa_usec_to_bytes(TSCHED_WATERMARK_INC_STEP_USEC
, &u
->sink
->sample_spec
);
1878 u
->watermark_dec_step
= pa_usec_to_bytes(TSCHED_WATERMARK_DEC_STEP_USEC
, &u
->sink
->sample_spec
);
1880 u
->watermark_inc_threshold
= pa_usec_to_bytes_round_up(TSCHED_WATERMARK_INC_THRESHOLD_USEC
, &u
->sink
->sample_spec
);
1881 u
->watermark_dec_threshold
= pa_usec_to_bytes_round_up(TSCHED_WATERMARK_DEC_THRESHOLD_USEC
, &u
->sink
->sample_spec
);
1883 fix_min_sleep_wakeup(u
);
1884 fix_tsched_watermark(u
);
1886 pa_sink_set_latency_range(u
->sink
,
1888 pa_bytes_to_usec(u
->hwbuf_size
, &ss
));
1890 pa_log_info("Time scheduling watermark is %0.2fms",
1891 (double) pa_bytes_to_usec(u
->tsched_watermark
, &ss
) / PA_USEC_PER_MSEC
);
1893 pa_sink_set_fixed_latency(u
->sink
, pa_bytes_to_usec(u
->hwbuf_size
, &ss
));
1898 if (update_sw_params(u
) < 0)
1901 if (setup_mixer(u
, ignore_dB
) < 0)
1904 pa_alsa_dump(PA_LOG_DEBUG
, u
->pcm_handle
);
1906 if (!(u
->thread
= pa_thread_new(thread_func
, u
))) {
1907 pa_log("Failed to create thread.");
1911 /* Get initial mixer settings */
1912 if (data
.volume_is_set
) {
1913 if (u
->sink
->set_volume
)
1914 u
->sink
->set_volume(u
->sink
);
1916 if (u
->sink
->get_volume
)
1917 u
->sink
->get_volume(u
->sink
);
1920 if (data
.muted_is_set
) {
1921 if (u
->sink
->set_mute
)
1922 u
->sink
->set_mute(u
->sink
);
1924 if (u
->sink
->get_mute
)
1925 u
->sink
->get_mute(u
->sink
);
1928 pa_sink_put(u
->sink
);
1931 pa_alsa_profile_set_free(profile_set
);
1941 pa_alsa_profile_set_free(profile_set
);
1946 static void userdata_free(struct userdata
*u
) {
1950 pa_sink_unlink(u
->sink
);
1953 pa_asyncmsgq_send(u
->thread_mq
.inq
, NULL
, PA_MESSAGE_SHUTDOWN
, NULL
, 0, NULL
);
1954 pa_thread_free(u
->thread
);
1957 pa_thread_mq_done(&u
->thread_mq
);
1960 pa_sink_unref(u
->sink
);
1962 if (u
->memchunk
.memblock
)
1963 pa_memblock_unref(u
->memchunk
.memblock
);
1965 if (u
->alsa_rtpoll_item
)
1966 pa_rtpoll_item_free(u
->alsa_rtpoll_item
);
1969 pa_rtpoll_free(u
->rtpoll
);
1971 if (u
->pcm_handle
) {
1972 snd_pcm_drop(u
->pcm_handle
);
1973 snd_pcm_close(u
->pcm_handle
);
1977 pa_alsa_fdlist_free(u
->mixer_fdl
);
1979 if (u
->mixer_path_set
)
1980 pa_alsa_path_set_free(u
->mixer_path_set
);
1981 else if (u
->mixer_path
)
1982 pa_alsa_path_free(u
->mixer_path
);
1984 if (u
->mixer_handle
)
1985 snd_mixer_close(u
->mixer_handle
);
1988 pa_smoother_free(u
->smoother
);
1993 pa_xfree(u
->device_name
);
1994 pa_xfree(u
->control_device
);
1998 void pa_alsa_sink_free(pa_sink
*s
) {
2001 pa_sink_assert_ref(s
);
2002 pa_assert_se(u
= s
->userdata
);