2 This file is part of PulseAudio.
4 Copyright 2004-2008 Lennart Poettering
5 Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
7 PulseAudio is free software; you can redistribute it and/or modify
8 it under the terms of the GNU Lesser General Public License as published
9 by the Free Software Foundation; either version 2.1 of the License,
10 or (at your option) any later version.
12 PulseAudio is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public License
18 along with PulseAudio; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
29 #include <asoundlib.h>
31 #ifdef HAVE_VALGRIND_MEMCHECK_H
32 #include <valgrind/memcheck.h>
35 #include <pulse/i18n.h>
36 #include <pulse/rtclock.h>
37 #include <pulse/timeval.h>
38 #include <pulse/util.h>
39 #include <pulse/xmalloc.h>
41 #include <pulsecore/core.h>
42 #include <pulsecore/module.h>
43 #include <pulsecore/memchunk.h>
44 #include <pulsecore/sink.h>
45 #include <pulsecore/modargs.h>
46 #include <pulsecore/core-rtclock.h>
47 #include <pulsecore/core-util.h>
48 #include <pulsecore/sample-util.h>
49 #include <pulsecore/log.h>
50 #include <pulsecore/macro.h>
51 #include <pulsecore/thread.h>
52 #include <pulsecore/core-error.h>
53 #include <pulsecore/thread-mq.h>
54 #include <pulsecore/rtpoll.h>
55 #include <pulsecore/time-smoother.h>
57 #include <modules/reserve-wrap.h>
59 #include "alsa-util.h"
60 #include "alsa-sink.h"
62 /* #define DEBUG_TIMING */
64 #define DEFAULT_DEVICE "default"
66 #define DEFAULT_TSCHED_BUFFER_USEC (2*PA_USEC_PER_SEC) /* 2s -- Overall buffer size */
67 #define DEFAULT_TSCHED_WATERMARK_USEC (20*PA_USEC_PER_MSEC) /* 20ms -- Fill up when only this much is left in the buffer */
69 #define TSCHED_WATERMARK_INC_STEP_USEC (10*PA_USEC_PER_MSEC) /* 10ms -- On underrun, increase watermark by this */
70 #define TSCHED_WATERMARK_DEC_STEP_USEC (5*PA_USEC_PER_MSEC) /* 5ms -- When everything's great, decrease watermark by this */
71 #define TSCHED_WATERMARK_VERIFY_AFTER_USEC (20*PA_USEC_PER_SEC) /* 20s -- How long after a drop out recheck if things are good now */
72 #define TSCHED_WATERMARK_INC_THRESHOLD_USEC (0*PA_USEC_PER_MSEC) /* 0ms -- If the buffer level ever below this theshold, increase the watermark */
73 #define TSCHED_WATERMARK_DEC_THRESHOLD_USEC (100*PA_USEC_PER_MSEC) /* 100ms -- If the buffer level didn't drop below this theshold in the verification time, decrease the watermark */
75 /* Note that TSCHED_WATERMARK_INC_THRESHOLD_USEC == 0 means tht we
76 * will increase the watermark only if we hit a real underrun. */
78 #define TSCHED_MIN_SLEEP_USEC (10*PA_USEC_PER_MSEC) /* 10ms -- Sleep at least 10ms on each iteration */
79 #define TSCHED_MIN_WAKEUP_USEC (4*PA_USEC_PER_MSEC) /* 4ms -- Wakeup at least this long before the buffer runs empty*/
81 #define SMOOTHER_WINDOW_USEC (10*PA_USEC_PER_SEC) /* 10s -- smoother windows size */
82 #define SMOOTHER_ADJUST_USEC (1*PA_USEC_PER_SEC) /* 1s -- smoother adjust time */
84 #define SMOOTHER_MIN_INTERVAL (2*PA_USEC_PER_MSEC) /* 2ms -- min smoother update interval */
85 #define SMOOTHER_MAX_INTERVAL (200*PA_USEC_PER_MSEC) /* 200ms -- max smoother update interval */
87 #define VOLUME_ACCURACY (PA_VOLUME_NORM/100) /* don't require volume adjustments to be perfectly correct. don't necessarily extend granularity in software unless the differences get greater than this level */
89 #define DEFAULT_REWIND_SAFEGUARD_BYTES (256U) /* 1.33ms @48kHz, we'll never rewind less than this */
90 #define DEFAULT_REWIND_SAFEGUARD_USEC (1330) /* 1.33ms, depending on channels/rate/sample we may rewind more than 256 above */
98 pa_thread_mq thread_mq
;
101 snd_pcm_t
*pcm_handle
;
103 pa_alsa_fdlist
*mixer_fdl
;
104 snd_mixer_t
*mixer_handle
;
105 pa_alsa_path_set
*mixer_path_set
;
106 pa_alsa_path
*mixer_path
;
108 pa_cvolume hardware_volume
;
120 watermark_inc_threshold
,
121 watermark_dec_threshold
,
124 pa_usec_t watermark_dec_not_before
;
126 pa_memchunk memchunk
;
128 char *device_name
; /* name of the PCM device */
129 char *control_device
; /* name of the control device */
131 pa_bool_t use_mmap
:1, use_tsched
:1;
133 pa_bool_t first
, after_rewind
;
135 pa_rtpoll_item
*alsa_rtpoll_item
;
137 snd_mixer_selem_channel_id_t mixer_map
[SND_MIXER_SCHN_LAST
];
139 pa_smoother
*smoother
;
140 uint64_t write_count
;
141 uint64_t since_start
;
142 pa_usec_t smoother_interval
;
143 pa_usec_t last_smoother_update
;
145 pa_reserve_wrapper
*reserve
;
146 pa_hook_slot
*reserve_slot
;
147 pa_reserve_monitor_wrapper
*monitor
;
148 pa_hook_slot
*monitor_slot
;
151 static void userdata_free(struct userdata
*u
);
153 static pa_hook_result_t
reserve_cb(pa_reserve_wrapper
*r
, void *forced
, struct userdata
*u
) {
157 if (pa_sink_suspend(u
->sink
, TRUE
, PA_SUSPEND_APPLICATION
) < 0)
158 return PA_HOOK_CANCEL
;
163 static void reserve_done(struct userdata
*u
) {
166 if (u
->reserve_slot
) {
167 pa_hook_slot_free(u
->reserve_slot
);
168 u
->reserve_slot
= NULL
;
172 pa_reserve_wrapper_unref(u
->reserve
);
177 static void reserve_update(struct userdata
*u
) {
178 const char *description
;
181 if (!u
->sink
|| !u
->reserve
)
184 if ((description
= pa_proplist_gets(u
->sink
->proplist
, PA_PROP_DEVICE_DESCRIPTION
)))
185 pa_reserve_wrapper_set_application_device_name(u
->reserve
, description
);
188 static int reserve_init(struct userdata
*u
, const char *dname
) {
197 if (pa_in_system_mode())
200 if (!(rname
= pa_alsa_get_reserve_name(dname
)))
203 /* We are resuming, try to lock the device */
204 u
->reserve
= pa_reserve_wrapper_get(u
->core
, rname
);
212 pa_assert(!u
->reserve_slot
);
213 u
->reserve_slot
= pa_hook_connect(pa_reserve_wrapper_hook(u
->reserve
), PA_HOOK_NORMAL
, (pa_hook_cb_t
) reserve_cb
, u
);
218 static pa_hook_result_t
monitor_cb(pa_reserve_monitor_wrapper
*w
, void* busy
, struct userdata
*u
) {
224 b
= PA_PTR_TO_UINT(busy
) && !u
->reserve
;
226 pa_sink_suspend(u
->sink
, b
, PA_SUSPEND_APPLICATION
);
230 static void monitor_done(struct userdata
*u
) {
233 if (u
->monitor_slot
) {
234 pa_hook_slot_free(u
->monitor_slot
);
235 u
->monitor_slot
= NULL
;
239 pa_reserve_monitor_wrapper_unref(u
->monitor
);
244 static int reserve_monitor_init(struct userdata
*u
, const char *dname
) {
250 if (pa_in_system_mode())
253 if (!(rname
= pa_alsa_get_reserve_name(dname
)))
256 u
->monitor
= pa_reserve_monitor_wrapper_get(u
->core
, rname
);
262 pa_assert(!u
->monitor_slot
);
263 u
->monitor_slot
= pa_hook_connect(pa_reserve_monitor_wrapper_hook(u
->monitor
), PA_HOOK_NORMAL
, (pa_hook_cb_t
) monitor_cb
, u
);
268 static void fix_min_sleep_wakeup(struct userdata
*u
) {
269 size_t max_use
, max_use_2
;
272 pa_assert(u
->use_tsched
);
274 max_use
= u
->hwbuf_size
- u
->hwbuf_unused
;
275 max_use_2
= pa_frame_align(max_use
/2, &u
->sink
->sample_spec
);
277 u
->min_sleep
= pa_usec_to_bytes(TSCHED_MIN_SLEEP_USEC
, &u
->sink
->sample_spec
);
278 u
->min_sleep
= PA_CLAMP(u
->min_sleep
, u
->frame_size
, max_use_2
);
280 u
->min_wakeup
= pa_usec_to_bytes(TSCHED_MIN_WAKEUP_USEC
, &u
->sink
->sample_spec
);
281 u
->min_wakeup
= PA_CLAMP(u
->min_wakeup
, u
->frame_size
, max_use_2
);
284 static void fix_tsched_watermark(struct userdata
*u
) {
287 pa_assert(u
->use_tsched
);
289 max_use
= u
->hwbuf_size
- u
->hwbuf_unused
;
291 if (u
->tsched_watermark
> max_use
- u
->min_sleep
)
292 u
->tsched_watermark
= max_use
- u
->min_sleep
;
294 if (u
->tsched_watermark
< u
->min_wakeup
)
295 u
->tsched_watermark
= u
->min_wakeup
;
298 static void increase_watermark(struct userdata
*u
) {
299 size_t old_watermark
;
300 pa_usec_t old_min_latency
, new_min_latency
;
303 pa_assert(u
->use_tsched
);
305 /* First, just try to increase the watermark */
306 old_watermark
= u
->tsched_watermark
;
307 u
->tsched_watermark
= PA_MIN(u
->tsched_watermark
* 2, u
->tsched_watermark
+ u
->watermark_inc_step
);
308 fix_tsched_watermark(u
);
310 if (old_watermark
!= u
->tsched_watermark
) {
311 pa_log_info("Increasing wakeup watermark to %0.2f ms",
312 (double) pa_bytes_to_usec(u
->tsched_watermark
, &u
->sink
->sample_spec
) / PA_USEC_PER_MSEC
);
316 /* Hmm, we cannot increase the watermark any further, hence let's raise the latency */
317 old_min_latency
= u
->sink
->thread_info
.min_latency
;
318 new_min_latency
= PA_MIN(old_min_latency
* 2, old_min_latency
+ TSCHED_WATERMARK_INC_STEP_USEC
);
319 new_min_latency
= PA_MIN(new_min_latency
, u
->sink
->thread_info
.max_latency
);
321 if (old_min_latency
!= new_min_latency
) {
322 pa_log_info("Increasing minimal latency to %0.2f ms",
323 (double) new_min_latency
/ PA_USEC_PER_MSEC
);
325 pa_sink_set_latency_range_within_thread(u
->sink
, new_min_latency
, u
->sink
->thread_info
.max_latency
);
328 /* When we reach this we're officialy fucked! */
331 static void decrease_watermark(struct userdata
*u
) {
332 size_t old_watermark
;
336 pa_assert(u
->use_tsched
);
338 now
= pa_rtclock_now();
340 if (u
->watermark_dec_not_before
<= 0)
343 if (u
->watermark_dec_not_before
> now
)
346 old_watermark
= u
->tsched_watermark
;
348 if (u
->tsched_watermark
< u
->watermark_dec_step
)
349 u
->tsched_watermark
= u
->tsched_watermark
/ 2;
351 u
->tsched_watermark
= PA_MAX(u
->tsched_watermark
/ 2, u
->tsched_watermark
- u
->watermark_dec_step
);
353 fix_tsched_watermark(u
);
355 if (old_watermark
!= u
->tsched_watermark
)
356 pa_log_info("Decreasing wakeup watermark to %0.2f ms",
357 (double) pa_bytes_to_usec(u
->tsched_watermark
, &u
->sink
->sample_spec
) / PA_USEC_PER_MSEC
);
359 /* We don't change the latency range*/
362 u
->watermark_dec_not_before
= now
+ TSCHED_WATERMARK_VERIFY_AFTER_USEC
;
365 static void hw_sleep_time(struct userdata
*u
, pa_usec_t
*sleep_usec
, pa_usec_t
*process_usec
) {
368 pa_assert(sleep_usec
);
369 pa_assert(process_usec
);
372 pa_assert(u
->use_tsched
);
374 usec
= pa_sink_get_requested_latency_within_thread(u
->sink
);
376 if (usec
== (pa_usec_t
) -1)
377 usec
= pa_bytes_to_usec(u
->hwbuf_size
, &u
->sink
->sample_spec
);
379 wm
= pa_bytes_to_usec(u
->tsched_watermark
, &u
->sink
->sample_spec
);
384 *sleep_usec
= usec
- wm
;
388 pa_log_debug("Buffer time: %lu ms; Sleep time: %lu ms; Process time: %lu ms",
389 (unsigned long) (usec
/ PA_USEC_PER_MSEC
),
390 (unsigned long) (*sleep_usec
/ PA_USEC_PER_MSEC
),
391 (unsigned long) (*process_usec
/ PA_USEC_PER_MSEC
));
395 static int try_recover(struct userdata
*u
, const char *call
, int err
) {
400 pa_log_debug("%s: %s", call
, pa_alsa_strerror(err
));
402 pa_assert(err
!= -EAGAIN
);
405 pa_log_debug("%s: Buffer underrun!", call
);
407 if (err
== -ESTRPIPE
)
408 pa_log_debug("%s: System suspended!", call
);
410 if ((err
= snd_pcm_recover(u
->pcm_handle
, err
, 1)) < 0) {
411 pa_log("%s: %s", call
, pa_alsa_strerror(err
));
420 static size_t check_left_to_play(struct userdata
*u
, size_t n_bytes
, pa_bool_t on_timeout
) {
422 pa_bool_t underrun
= FALSE
;
424 /* We use <= instead of < for this check here because an underrun
425 * only happens after the last sample was processed, not already when
426 * it is removed from the buffer. This is particularly important
427 * when block transfer is used. */
429 if (n_bytes
<= u
->hwbuf_size
)
430 left_to_play
= u
->hwbuf_size
- n_bytes
;
433 /* We got a dropout. What a mess! */
441 if (!u
->first
&& !u
->after_rewind
)
442 if (pa_log_ratelimit())
443 pa_log_info("Underrun!");
447 pa_log_debug("%0.2f ms left to play; inc threshold = %0.2f ms; dec threshold = %0.2f ms",
448 (double) pa_bytes_to_usec(left_to_play
, &u
->sink
->sample_spec
) / PA_USEC_PER_MSEC
,
449 (double) pa_bytes_to_usec(u
->watermark_inc_threshold
, &u
->sink
->sample_spec
) / PA_USEC_PER_MSEC
,
450 (double) pa_bytes_to_usec(u
->watermark_dec_threshold
, &u
->sink
->sample_spec
) / PA_USEC_PER_MSEC
);
454 pa_bool_t reset_not_before
= TRUE
;
456 if (!u
->first
&& !u
->after_rewind
) {
457 if (underrun
|| left_to_play
< u
->watermark_inc_threshold
)
458 increase_watermark(u
);
459 else if (left_to_play
> u
->watermark_dec_threshold
) {
460 reset_not_before
= FALSE
;
462 /* We decrease the watermark only if have actually
463 * been woken up by a timeout. If something else woke
464 * us up it's too easy to fulfill the deadlines... */
467 decrease_watermark(u
);
471 if (reset_not_before
)
472 u
->watermark_dec_not_before
= 0;
478 static int mmap_write(struct userdata
*u
, pa_usec_t
*sleep_usec
, pa_bool_t polled
, pa_bool_t on_timeout
) {
479 pa_bool_t work_done
= TRUE
;
480 pa_usec_t max_sleep_usec
= 0, process_usec
= 0;
485 pa_sink_assert_ref(u
->sink
);
488 hw_sleep_time(u
, &max_sleep_usec
, &process_usec
);
494 pa_bool_t after_avail
= TRUE
;
496 /* First we determine how many samples are missing to fill the
497 * buffer up to 100% */
499 if (PA_UNLIKELY((n
= pa_alsa_safe_avail(u
->pcm_handle
, u
->hwbuf_size
, &u
->sink
->sample_spec
)) < 0)) {
501 if ((r
= try_recover(u
, "snd_pcm_avail", (int) n
)) == 0)
507 n_bytes
= (size_t) n
* u
->frame_size
;
510 pa_log_debug("avail: %lu", (unsigned long) n_bytes
);
513 left_to_play
= check_left_to_play(u
, n_bytes
, on_timeout
);
518 /* We won't fill up the playback buffer before at least
519 * half the sleep time is over because otherwise we might
520 * ask for more data from the clients then they expect. We
521 * need to guarantee that clients only have to keep around
522 * a single hw buffer length. */
525 pa_bytes_to_usec(left_to_play
, &u
->sink
->sample_spec
) > process_usec
+max_sleep_usec
/2) {
527 pa_log_debug("Not filling up, because too early.");
532 if (PA_UNLIKELY(n_bytes
<= u
->hwbuf_unused
)) {
536 char *dn
= pa_alsa_get_driver_name_by_pcm(u
->pcm_handle
);
537 pa_log(_("ALSA woke us up to write new data to the device, but there was actually nothing to write!\n"
538 "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers.\n"
539 "We were woken up with POLLOUT set -- however a subsequent snd_pcm_avail() returned 0 or another value < min_avail."),
545 pa_log_debug("Not filling up, because not necessary.");
553 pa_log_debug("Not filling up, because already too many iterations.");
559 n_bytes
-= u
->hwbuf_unused
;
563 pa_log_debug("Filling up");
570 const snd_pcm_channel_area_t
*areas
;
571 snd_pcm_uframes_t offset
, frames
;
572 snd_pcm_sframes_t sframes
;
574 frames
= (snd_pcm_uframes_t
) (n_bytes
/ u
->frame_size
);
575 /* pa_log_debug("%lu frames to write", (unsigned long) frames); */
577 if (PA_UNLIKELY((err
= pa_alsa_safe_mmap_begin(u
->pcm_handle
, &areas
, &offset
, &frames
, u
->hwbuf_size
, &u
->sink
->sample_spec
)) < 0)) {
579 if (!after_avail
&& err
== -EAGAIN
)
582 if ((r
= try_recover(u
, "snd_pcm_mmap_begin", err
)) == 0)
588 /* Make sure that if these memblocks need to be copied they will fit into one slot */
589 if (frames
> pa_mempool_block_size_max(u
->sink
->core
->mempool
)/u
->frame_size
)
590 frames
= pa_mempool_block_size_max(u
->sink
->core
->mempool
)/u
->frame_size
;
592 if (!after_avail
&& frames
== 0)
595 pa_assert(frames
> 0);
598 /* Check these are multiples of 8 bit */
599 pa_assert((areas
[0].first
& 7) == 0);
600 pa_assert((areas
[0].step
& 7)== 0);
602 /* We assume a single interleaved memory buffer */
603 pa_assert((areas
[0].first
>> 3) == 0);
604 pa_assert((areas
[0].step
>> 3) == u
->frame_size
);
606 p
= (uint8_t*) areas
[0].addr
+ (offset
* u
->frame_size
);
608 chunk
.memblock
= pa_memblock_new_fixed(u
->core
->mempool
, p
, frames
* u
->frame_size
, TRUE
);
609 chunk
.length
= pa_memblock_get_length(chunk
.memblock
);
612 pa_sink_render_into_full(u
->sink
, &chunk
);
613 pa_memblock_unref_fixed(chunk
.memblock
);
615 if (PA_UNLIKELY((sframes
= snd_pcm_mmap_commit(u
->pcm_handle
, offset
, frames
)) < 0)) {
617 if (!after_avail
&& (int) sframes
== -EAGAIN
)
620 if ((r
= try_recover(u
, "snd_pcm_mmap_commit", (int) sframes
)) == 0)
628 u
->write_count
+= frames
* u
->frame_size
;
629 u
->since_start
+= frames
* u
->frame_size
;
632 pa_log_debug("Wrote %lu bytes (of possible %lu bytes)", (unsigned long) (frames
* u
->frame_size
), (unsigned long) n_bytes
);
635 if ((size_t) frames
* u
->frame_size
>= n_bytes
)
638 n_bytes
-= (size_t) frames
* u
->frame_size
;
643 *sleep_usec
= pa_bytes_to_usec(left_to_play
, &u
->sink
->sample_spec
);
645 if (*sleep_usec
> process_usec
)
646 *sleep_usec
-= process_usec
;
652 return work_done
? 1 : 0;
655 static int unix_write(struct userdata
*u
, pa_usec_t
*sleep_usec
, pa_bool_t polled
, pa_bool_t on_timeout
) {
656 pa_bool_t work_done
= FALSE
;
657 pa_usec_t max_sleep_usec
= 0, process_usec
= 0;
662 pa_sink_assert_ref(u
->sink
);
665 hw_sleep_time(u
, &max_sleep_usec
, &process_usec
);
671 pa_bool_t after_avail
= TRUE
;
673 if (PA_UNLIKELY((n
= pa_alsa_safe_avail(u
->pcm_handle
, u
->hwbuf_size
, &u
->sink
->sample_spec
)) < 0)) {
675 if ((r
= try_recover(u
, "snd_pcm_avail", (int) n
)) == 0)
681 n_bytes
= (size_t) n
* u
->frame_size
;
682 left_to_play
= check_left_to_play(u
, n_bytes
, on_timeout
);
687 /* We won't fill up the playback buffer before at least
688 * half the sleep time is over because otherwise we might
689 * ask for more data from the clients then they expect. We
690 * need to guarantee that clients only have to keep around
691 * a single hw buffer length. */
694 pa_bytes_to_usec(left_to_play
, &u
->sink
->sample_spec
) > process_usec
+max_sleep_usec
/2)
697 if (PA_UNLIKELY(n_bytes
<= u
->hwbuf_unused
)) {
701 char *dn
= pa_alsa_get_driver_name_by_pcm(u
->pcm_handle
);
702 pa_log(_("ALSA woke us up to write new data to the device, but there was actually nothing to write!\n"
703 "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers.\n"
704 "We were woken up with POLLOUT set -- however a subsequent snd_pcm_avail() returned 0 or another value < min_avail."),
714 pa_log_debug("Not filling up, because already too many iterations.");
720 n_bytes
-= u
->hwbuf_unused
;
724 snd_pcm_sframes_t frames
;
727 /* pa_log_debug("%lu frames to write", (unsigned long) frames); */
729 if (u
->memchunk
.length
<= 0)
730 pa_sink_render(u
->sink
, n_bytes
, &u
->memchunk
);
732 pa_assert(u
->memchunk
.length
> 0);
734 frames
= (snd_pcm_sframes_t
) (u
->memchunk
.length
/ u
->frame_size
);
736 if (frames
> (snd_pcm_sframes_t
) (n_bytes
/u
->frame_size
))
737 frames
= (snd_pcm_sframes_t
) (n_bytes
/u
->frame_size
);
739 p
= pa_memblock_acquire(u
->memchunk
.memblock
);
740 frames
= snd_pcm_writei(u
->pcm_handle
, (const uint8_t*) p
+ u
->memchunk
.index
, (snd_pcm_uframes_t
) frames
);
741 pa_memblock_release(u
->memchunk
.memblock
);
743 if (PA_UNLIKELY(frames
< 0)) {
745 if (!after_avail
&& (int) frames
== -EAGAIN
)
748 if ((r
= try_recover(u
, "snd_pcm_writei", (int) frames
)) == 0)
754 if (!after_avail
&& frames
== 0)
757 pa_assert(frames
> 0);
760 u
->memchunk
.index
+= (size_t) frames
* u
->frame_size
;
761 u
->memchunk
.length
-= (size_t) frames
* u
->frame_size
;
763 if (u
->memchunk
.length
<= 0) {
764 pa_memblock_unref(u
->memchunk
.memblock
);
765 pa_memchunk_reset(&u
->memchunk
);
770 u
->write_count
+= frames
* u
->frame_size
;
771 u
->since_start
+= frames
* u
->frame_size
;
773 /* pa_log_debug("wrote %lu frames", (unsigned long) frames); */
775 if ((size_t) frames
* u
->frame_size
>= n_bytes
)
778 n_bytes
-= (size_t) frames
* u
->frame_size
;
783 *sleep_usec
= pa_bytes_to_usec(left_to_play
, &u
->sink
->sample_spec
);
785 if (*sleep_usec
> process_usec
)
786 *sleep_usec
-= process_usec
;
792 return work_done
? 1 : 0;
795 static void update_smoother(struct userdata
*u
) {
796 snd_pcm_sframes_t delay
= 0;
799 pa_usec_t now1
= 0, now2
;
800 snd_pcm_status_t
*status
;
802 snd_pcm_status_alloca(&status
);
805 pa_assert(u
->pcm_handle
);
807 /* Let's update the time smoother */
809 if (PA_UNLIKELY((err
= pa_alsa_safe_delay(u
->pcm_handle
, &delay
, u
->hwbuf_size
, &u
->sink
->sample_spec
, FALSE
)) < 0)) {
810 pa_log_warn("Failed to query DSP status data: %s", pa_alsa_strerror(err
));
814 if (PA_UNLIKELY((err
= snd_pcm_status(u
->pcm_handle
, status
)) < 0))
815 pa_log_warn("Failed to get timestamp: %s", pa_alsa_strerror(err
));
817 snd_htimestamp_t htstamp
= { 0, 0 };
818 snd_pcm_status_get_htstamp(status
, &htstamp
);
819 now1
= pa_timespec_load(&htstamp
);
822 /* Hmm, if the timestamp is 0, then it wasn't set and we take the current time */
824 now1
= pa_rtclock_now();
826 /* check if the time since the last update is bigger than the interval */
827 if (u
->last_smoother_update
> 0)
828 if (u
->last_smoother_update
+ u
->smoother_interval
> now1
)
831 position
= (int64_t) u
->write_count
- ((int64_t) delay
* (int64_t) u
->frame_size
);
833 if (PA_UNLIKELY(position
< 0))
836 now2
= pa_bytes_to_usec((uint64_t) position
, &u
->sink
->sample_spec
);
838 pa_smoother_put(u
->smoother
, now1
, now2
);
840 u
->last_smoother_update
= now1
;
841 /* exponentially increase the update interval up to the MAX limit */
842 u
->smoother_interval
= PA_MIN (u
->smoother_interval
* 2, SMOOTHER_MAX_INTERVAL
);
845 static pa_usec_t
sink_get_latency(struct userdata
*u
) {
848 pa_usec_t now1
, now2
;
852 now1
= pa_rtclock_now();
853 now2
= pa_smoother_get(u
->smoother
, now1
);
855 delay
= (int64_t) pa_bytes_to_usec(u
->write_count
, &u
->sink
->sample_spec
) - (int64_t) now2
;
857 r
= delay
>= 0 ? (pa_usec_t
) delay
: 0;
859 if (u
->memchunk
.memblock
)
860 r
+= pa_bytes_to_usec(u
->memchunk
.length
, &u
->sink
->sample_spec
);
865 static int build_pollfd(struct userdata
*u
) {
867 pa_assert(u
->pcm_handle
);
869 if (u
->alsa_rtpoll_item
)
870 pa_rtpoll_item_free(u
->alsa_rtpoll_item
);
872 if (!(u
->alsa_rtpoll_item
= pa_alsa_build_pollfd(u
->pcm_handle
, u
->rtpoll
)))
878 /* Called from IO context */
879 static int suspend(struct userdata
*u
) {
881 pa_assert(u
->pcm_handle
);
883 pa_smoother_pause(u
->smoother
, pa_rtclock_now());
885 /* Let's suspend -- we don't call snd_pcm_drain() here since that might
886 * take awfully long with our long buffer sizes today. */
887 snd_pcm_close(u
->pcm_handle
);
888 u
->pcm_handle
= NULL
;
890 if (u
->alsa_rtpoll_item
) {
891 pa_rtpoll_item_free(u
->alsa_rtpoll_item
);
892 u
->alsa_rtpoll_item
= NULL
;
895 /* We reset max_rewind/max_request here to make sure that while we
896 * are suspended the old max_request/max_rewind values set before
897 * the suspend can influence the per-stream buffer of newly
898 * created streams, without their requirements having any
899 * influence on them. */
900 pa_sink_set_max_rewind_within_thread(u
->sink
, 0);
901 pa_sink_set_max_request_within_thread(u
->sink
, 0);
903 pa_log_info("Device suspended...");
908 /* Called from IO context */
909 static int update_sw_params(struct userdata
*u
) {
910 snd_pcm_uframes_t avail_min
;
915 /* Use the full buffer if noone asked us for anything specific */
921 if ((latency
= pa_sink_get_requested_latency_within_thread(u
->sink
)) != (pa_usec_t
) -1) {
924 pa_log_debug("Latency set to %0.2fms", (double) latency
/ PA_USEC_PER_MSEC
);
926 b
= pa_usec_to_bytes(latency
, &u
->sink
->sample_spec
);
928 /* We need at least one sample in our buffer */
930 if (PA_UNLIKELY(b
< u
->frame_size
))
933 u
->hwbuf_unused
= PA_LIKELY(b
< u
->hwbuf_size
) ? (u
->hwbuf_size
- b
) : 0;
936 fix_min_sleep_wakeup(u
);
937 fix_tsched_watermark(u
);
940 pa_log_debug("hwbuf_unused=%lu", (unsigned long) u
->hwbuf_unused
);
942 /* We need at last one frame in the used part of the buffer */
943 avail_min
= (snd_pcm_uframes_t
) u
->hwbuf_unused
/ u
->frame_size
+ 1;
946 pa_usec_t sleep_usec
, process_usec
;
948 hw_sleep_time(u
, &sleep_usec
, &process_usec
);
949 avail_min
+= pa_usec_to_bytes(sleep_usec
, &u
->sink
->sample_spec
) / u
->frame_size
;
952 pa_log_debug("setting avail_min=%lu", (unsigned long) avail_min
);
954 if ((err
= pa_alsa_set_sw_params(u
->pcm_handle
, avail_min
, !u
->use_tsched
)) < 0) {
955 pa_log("Failed to set software parameters: %s", pa_alsa_strerror(err
));
959 pa_sink_set_max_request_within_thread(u
->sink
, u
->hwbuf_size
- u
->hwbuf_unused
);
960 if (pa_alsa_pcm_is_hw(u
->pcm_handle
))
961 pa_sink_set_max_rewind_within_thread(u
->sink
, u
->hwbuf_size
);
963 pa_log_info("Disabling rewind_within_thread for device %s", u
->device_name
);
964 pa_sink_set_max_rewind_within_thread(u
->sink
, 0);
970 /* Called from IO context */
971 static int unsuspend(struct userdata
*u
) {
975 snd_pcm_uframes_t period_size
, buffer_size
;
978 pa_assert(!u
->pcm_handle
);
980 pa_log_info("Trying resume...");
982 if ((err
= snd_pcm_open(&u
->pcm_handle
, u
->device_name
, SND_PCM_STREAM_PLAYBACK
,
984 SND_PCM_NO_AUTO_RESAMPLE
|
985 SND_PCM_NO_AUTO_CHANNELS
|
986 SND_PCM_NO_AUTO_FORMAT
)) < 0) {
987 pa_log("Error opening PCM device %s: %s", u
->device_name
, pa_alsa_strerror(err
));
991 ss
= u
->sink
->sample_spec
;
992 period_size
= u
->fragment_size
/ u
->frame_size
;
993 buffer_size
= u
->hwbuf_size
/ u
->frame_size
;
997 if ((err
= pa_alsa_set_hw_params(u
->pcm_handle
, &ss
, &period_size
, &buffer_size
, 0, &b
, &d
, TRUE
)) < 0) {
998 pa_log("Failed to set hardware parameters: %s", pa_alsa_strerror(err
));
1002 if (b
!= u
->use_mmap
|| d
!= u
->use_tsched
) {
1003 pa_log_warn("Resume failed, couldn't get original access mode.");
1007 if (!pa_sample_spec_equal(&ss
, &u
->sink
->sample_spec
)) {
1008 pa_log_warn("Resume failed, couldn't restore original sample settings.");
1012 if (period_size
*u
->frame_size
!= u
->fragment_size
||
1013 buffer_size
*u
->frame_size
!= u
->hwbuf_size
) {
1014 pa_log_warn("Resume failed, couldn't restore original fragment settings. (Old: %lu/%lu, New %lu/%lu)",
1015 (unsigned long) u
->hwbuf_size
, (unsigned long) u
->fragment_size
,
1016 (unsigned long) (buffer_size
*u
->frame_size
), (unsigned long) (period_size
*u
->frame_size
));
1020 if (update_sw_params(u
) < 0)
1023 if (build_pollfd(u
) < 0)
1027 pa_smoother_reset(u
->smoother
, pa_rtclock_now(), TRUE
);
1028 u
->smoother_interval
= SMOOTHER_MIN_INTERVAL
;
1029 u
->last_smoother_update
= 0;
1034 pa_log_info("Resumed successfully...");
1039 if (u
->pcm_handle
) {
1040 snd_pcm_close(u
->pcm_handle
);
1041 u
->pcm_handle
= NULL
;
1047 /* Called from IO context */
1048 static int sink_process_msg(pa_msgobject
*o
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
1049 struct userdata
*u
= PA_SINK(o
)->userdata
;
1053 case PA_SINK_MESSAGE_GET_LATENCY
: {
1057 r
= sink_get_latency(u
);
1059 *((pa_usec_t
*) data
) = r
;
1064 case PA_SINK_MESSAGE_SET_STATE
:
1066 switch ((pa_sink_state_t
) PA_PTR_TO_UINT(data
)) {
1068 case PA_SINK_SUSPENDED
: {
1071 pa_assert(PA_SINK_IS_OPENED(u
->sink
->thread_info
.state
));
1073 if ((r
= suspend(u
)) < 0)
1080 case PA_SINK_RUNNING
: {
1083 if (u
->sink
->thread_info
.state
== PA_SINK_INIT
) {
1084 if (build_pollfd(u
) < 0)
1088 if (u
->sink
->thread_info
.state
== PA_SINK_SUSPENDED
) {
1089 if ((r
= unsuspend(u
)) < 0)
1096 case PA_SINK_UNLINKED
:
1098 case PA_SINK_INVALID_STATE
:
1105 return pa_sink_process_msg(o
, code
, data
, offset
, chunk
);
1108 /* Called from main context */
1109 static int sink_set_state_cb(pa_sink
*s
, pa_sink_state_t new_state
) {
1110 pa_sink_state_t old_state
;
1113 pa_sink_assert_ref(s
);
1114 pa_assert_se(u
= s
->userdata
);
1116 old_state
= pa_sink_get_state(u
->sink
);
1118 if (PA_SINK_IS_OPENED(old_state
) && new_state
== PA_SINK_SUSPENDED
)
1120 else if (old_state
== PA_SINK_SUSPENDED
&& PA_SINK_IS_OPENED(new_state
))
1121 if (reserve_init(u
, u
->device_name
) < 0)
1122 return -PA_ERR_BUSY
;
1127 static int mixer_callback(snd_mixer_elem_t
*elem
, unsigned int mask
) {
1128 struct userdata
*u
= snd_mixer_elem_get_callback_private(elem
);
1131 pa_assert(u
->mixer_handle
);
1133 if (mask
== SND_CTL_EVENT_MASK_REMOVE
)
1136 if (u
->sink
->suspend_cause
& PA_SUSPEND_SESSION
)
1139 if (mask
& SND_CTL_EVENT_MASK_VALUE
) {
1140 pa_sink_get_volume(u
->sink
, TRUE
);
1141 pa_sink_get_mute(u
->sink
, TRUE
);
1147 static void sink_get_volume_cb(pa_sink
*s
) {
1148 struct userdata
*u
= s
->userdata
;
1150 char t
[PA_CVOLUME_SNPRINT_MAX
];
1153 pa_assert(u
->mixer_path
);
1154 pa_assert(u
->mixer_handle
);
1156 if (pa_alsa_path_get_volume(u
->mixer_path
, u
->mixer_handle
, &s
->channel_map
, &r
) < 0)
1159 /* Shift down by the base volume, so that 0dB becomes maximum volume */
1160 pa_sw_cvolume_multiply_scalar(&r
, &r
, s
->base_volume
);
1162 pa_log_debug("Read hardware volume: %s", pa_cvolume_snprint(t
, sizeof(t
), &r
));
1164 if (pa_cvolume_equal(&u
->hardware_volume
, &r
))
1167 s
->real_volume
= u
->hardware_volume
= r
;
1169 /* Hmm, so the hardware volume changed, let's reset our software volume */
1170 if (u
->mixer_path
->has_dB
)
1171 pa_sink_set_soft_volume(s
, NULL
);
1174 static void sink_set_volume_cb(pa_sink
*s
) {
1175 struct userdata
*u
= s
->userdata
;
1177 char t
[PA_CVOLUME_SNPRINT_MAX
];
1180 pa_assert(u
->mixer_path
);
1181 pa_assert(u
->mixer_handle
);
1183 /* Shift up by the base volume */
1184 pa_sw_cvolume_divide_scalar(&r
, &s
->real_volume
, s
->base_volume
);
1186 if (pa_alsa_path_set_volume(u
->mixer_path
, u
->mixer_handle
, &s
->channel_map
, &r
) < 0)
1189 /* Shift down by the base volume, so that 0dB becomes maximum volume */
1190 pa_sw_cvolume_multiply_scalar(&r
, &r
, s
->base_volume
);
1192 u
->hardware_volume
= r
;
1194 if (u
->mixer_path
->has_dB
) {
1195 pa_cvolume new_soft_volume
;
1196 pa_bool_t accurate_enough
;
1198 /* Match exactly what the user requested by software */
1199 pa_sw_cvolume_divide(&new_soft_volume
, &s
->real_volume
, &u
->hardware_volume
);
1201 /* If the adjustment to do in software is only minimal we
1202 * can skip it. That saves us CPU at the expense of a bit of
1205 (pa_cvolume_min(&new_soft_volume
) >= (PA_VOLUME_NORM
- VOLUME_ACCURACY
)) &&
1206 (pa_cvolume_max(&new_soft_volume
) <= (PA_VOLUME_NORM
+ VOLUME_ACCURACY
));
1208 pa_log_debug("Requested volume: %s", pa_cvolume_snprint(t
, sizeof(t
), &s
->real_volume
));
1209 pa_log_debug("Got hardware volume: %s", pa_cvolume_snprint(t
, sizeof(t
), &u
->hardware_volume
));
1210 pa_log_debug("Calculated software volume: %s (accurate-enough=%s)", pa_cvolume_snprint(t
, sizeof(t
), &new_soft_volume
),
1211 pa_yes_no(accurate_enough
));
1213 if (!accurate_enough
)
1214 s
->soft_volume
= new_soft_volume
;
1217 pa_log_debug("Wrote hardware volume: %s", pa_cvolume_snprint(t
, sizeof(t
), &r
));
1219 /* We can't match exactly what the user requested, hence let's
1220 * at least tell the user about it */
1226 static void sink_get_mute_cb(pa_sink
*s
) {
1227 struct userdata
*u
= s
->userdata
;
1231 pa_assert(u
->mixer_path
);
1232 pa_assert(u
->mixer_handle
);
1234 if (pa_alsa_path_get_mute(u
->mixer_path
, u
->mixer_handle
, &b
) < 0)
1240 static void sink_set_mute_cb(pa_sink
*s
) {
1241 struct userdata
*u
= s
->userdata
;
1244 pa_assert(u
->mixer_path
);
1245 pa_assert(u
->mixer_handle
);
1247 pa_alsa_path_set_mute(u
->mixer_path
, u
->mixer_handle
, s
->muted
);
1250 static int sink_set_port_cb(pa_sink
*s
, pa_device_port
*p
) {
1251 struct userdata
*u
= s
->userdata
;
1252 pa_alsa_port_data
*data
;
1256 pa_assert(u
->mixer_handle
);
1258 data
= PA_DEVICE_PORT_DATA(p
);
1260 pa_assert_se(u
->mixer_path
= data
->path
);
1261 pa_alsa_path_select(u
->mixer_path
, u
->mixer_handle
);
1263 if (u
->mixer_path
->has_volume
&& u
->mixer_path
->has_dB
) {
1264 s
->base_volume
= pa_sw_volume_from_dB(-u
->mixer_path
->max_dB
);
1265 s
->n_volume_steps
= PA_VOLUME_NORM
+1;
1267 pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(s
->base_volume
));
1269 s
->base_volume
= PA_VOLUME_NORM
;
1270 s
->n_volume_steps
= u
->mixer_path
->max_volume
- u
->mixer_path
->min_volume
+ 1;
1274 pa_alsa_setting_select(data
->setting
, u
->mixer_handle
);
1284 static void sink_update_requested_latency_cb(pa_sink
*s
) {
1285 struct userdata
*u
= s
->userdata
;
1288 pa_assert(u
->use_tsched
); /* only when timer scheduling is used
1289 * we can dynamically adjust the
1295 before
= u
->hwbuf_unused
;
1296 update_sw_params(u
);
1298 /* Let's check whether we now use only a smaller part of the
1299 buffer then before. If so, we need to make sure that subsequent
1300 rewinds are relative to the new maximum fill level and not to the
1301 current fill level. Thus, let's do a full rewind once, to clear
1304 if (u
->hwbuf_unused
> before
) {
1305 pa_log_debug("Requesting rewind due to latency change.");
1306 pa_sink_request_rewind(s
, (size_t) -1);
1310 static int process_rewind(struct userdata
*u
) {
1311 snd_pcm_sframes_t unused
;
1312 size_t rewind_nbytes
, unused_nbytes
, limit_nbytes
;
1315 /* Figure out how much we shall rewind and reset the counter */
1316 rewind_nbytes
= u
->sink
->thread_info
.rewind_nbytes
;
1318 pa_log_debug("Requested to rewind %lu bytes.", (unsigned long) rewind_nbytes
);
1320 if (PA_UNLIKELY((unused
= pa_alsa_safe_avail(u
->pcm_handle
, u
->hwbuf_size
, &u
->sink
->sample_spec
)) < 0)) {
1321 pa_log("snd_pcm_avail() failed: %s", pa_alsa_strerror((int) unused
));
1325 unused_nbytes
= (size_t) unused
* u
->frame_size
;
1327 /* make sure rewind doesn't go too far, can cause issues with DMAs */
1328 unused_nbytes
+= u
->rewind_safeguard
;
1330 if (u
->hwbuf_size
> unused_nbytes
)
1331 limit_nbytes
= u
->hwbuf_size
- unused_nbytes
;
1335 if (rewind_nbytes
> limit_nbytes
)
1336 rewind_nbytes
= limit_nbytes
;
1338 if (rewind_nbytes
> 0) {
1339 snd_pcm_sframes_t in_frames
, out_frames
;
1341 pa_log_debug("Limited to %lu bytes.", (unsigned long) rewind_nbytes
);
1343 in_frames
= (snd_pcm_sframes_t
) (rewind_nbytes
/ u
->frame_size
);
1344 pa_log_debug("before: %lu", (unsigned long) in_frames
);
1345 if ((out_frames
= snd_pcm_rewind(u
->pcm_handle
, (snd_pcm_uframes_t
) in_frames
)) < 0) {
1346 pa_log("snd_pcm_rewind() failed: %s", pa_alsa_strerror((int) out_frames
));
1347 if (try_recover(u
, "process_rewind", out_frames
) < 0)
1352 pa_log_debug("after: %lu", (unsigned long) out_frames
);
1354 rewind_nbytes
= (size_t) out_frames
* u
->frame_size
;
1356 if (rewind_nbytes
<= 0)
1357 pa_log_info("Tried rewind, but was apparently not possible.");
1359 u
->write_count
-= rewind_nbytes
;
1360 pa_log_debug("Rewound %lu bytes.", (unsigned long) rewind_nbytes
);
1361 pa_sink_process_rewind(u
->sink
, rewind_nbytes
);
1363 u
->after_rewind
= TRUE
;
1367 pa_log_debug("Mhmm, actually there is nothing to rewind.");
1369 pa_sink_process_rewind(u
->sink
, 0);
1373 static void thread_func(void *userdata
) {
1374 struct userdata
*u
= userdata
;
1375 unsigned short revents
= 0;
1379 pa_log_debug("Thread starting up");
1381 if (u
->core
->realtime_scheduling
)
1382 pa_make_realtime(u
->core
->realtime_priority
);
1384 pa_thread_mq_install(&u
->thread_mq
);
1390 pa_log_debug("Loop");
1393 /* Render some data and write it to the dsp */
1394 if (PA_SINK_IS_OPENED(u
->sink
->thread_info
.state
)) {
1396 pa_usec_t sleep_usec
= 0;
1397 pa_bool_t on_timeout
= pa_rtpoll_timer_elapsed(u
->rtpoll
);
1399 if (PA_UNLIKELY(u
->sink
->thread_info
.rewind_requested
))
1400 if (process_rewind(u
) < 0)
1404 work_done
= mmap_write(u
, &sleep_usec
, revents
& POLLOUT
, on_timeout
);
1406 work_done
= unix_write(u
, &sleep_usec
, revents
& POLLOUT
, on_timeout
);
1411 /* pa_log_debug("work_done = %i", work_done); */
1416 pa_log_info("Starting playback.");
1417 snd_pcm_start(u
->pcm_handle
);
1419 pa_smoother_resume(u
->smoother
, pa_rtclock_now(), TRUE
);
1425 if (u
->use_tsched
) {
1428 if (u
->since_start
<= u
->hwbuf_size
) {
1430 /* USB devices on ALSA seem to hit a buffer
1431 * underrun during the first iterations much
1432 * quicker then we calculate here, probably due to
1433 * the transport latency. To accommodate for that
1434 * we artificially decrease the sleep time until
1435 * we have filled the buffer at least once
1438 if (pa_log_ratelimit())
1439 pa_log_debug("Cutting sleep time for the initial iterations by half.");
1443 /* OK, the playback buffer is now full, let's
1444 * calculate when to wake up next */
1445 /* pa_log_debug("Waking up in %0.2fms (sound card clock).", (double) sleep_usec / PA_USEC_PER_MSEC); */
1447 /* Convert from the sound card time domain to the
1448 * system time domain */
1449 cusec
= pa_smoother_translate(u
->smoother
, pa_rtclock_now(), sleep_usec
);
1451 /* pa_log_debug("Waking up in %0.2fms (system clock).", (double) cusec / PA_USEC_PER_MSEC); */
1453 /* We don't trust the conversion, so we wake up whatever comes first */
1454 pa_rtpoll_set_timer_relative(u
->rtpoll
, PA_MIN(sleep_usec
, cusec
));
1458 u
->after_rewind
= FALSE
;
1460 } else if (u
->use_tsched
)
1462 /* OK, we're in an invalid state, let's disable our timers */
1463 pa_rtpoll_set_timer_disabled(u
->rtpoll
);
1465 /* Hmm, nothing to do. Let's sleep */
1466 if ((ret
= pa_rtpoll_run(u
->rtpoll
, TRUE
)) < 0)
1472 /* Tell ALSA about this and process its response */
1473 if (PA_SINK_IS_OPENED(u
->sink
->thread_info
.state
)) {
1474 struct pollfd
*pollfd
;
1478 pollfd
= pa_rtpoll_item_get_pollfd(u
->alsa_rtpoll_item
, &n
);
1480 if ((err
= snd_pcm_poll_descriptors_revents(u
->pcm_handle
, pollfd
, n
, &revents
)) < 0) {
1481 pa_log("snd_pcm_poll_descriptors_revents() failed: %s", pa_alsa_strerror(err
));
1485 if (revents
& ~POLLOUT
) {
1486 if (pa_alsa_recover_from_poll(u
->pcm_handle
, revents
) < 0)
1491 } else if (revents
&& u
->use_tsched
&& pa_log_ratelimit())
1492 pa_log_debug("Wakeup from ALSA!");
1499 /* If this was no regular exit from the loop we have to continue
1500 * processing messages until we received PA_MESSAGE_SHUTDOWN */
1501 pa_asyncmsgq_post(u
->thread_mq
.outq
, PA_MSGOBJECT(u
->core
), PA_CORE_MESSAGE_UNLOAD_MODULE
, u
->module
, 0, NULL
, NULL
);
1502 pa_asyncmsgq_wait_for(u
->thread_mq
.inq
, PA_MESSAGE_SHUTDOWN
);
1505 pa_log_debug("Thread shutting down");
1508 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
) {
1514 pa_assert(device_name
);
1516 if ((n
= pa_modargs_get_value(ma
, "sink_name", NULL
))) {
1517 pa_sink_new_data_set_name(data
, n
);
1518 data
->namereg_fail
= TRUE
;
1522 if ((n
= pa_modargs_get_value(ma
, "name", NULL
)))
1523 data
->namereg_fail
= TRUE
;
1525 n
= device_id
? device_id
: device_name
;
1526 data
->namereg_fail
= FALSE
;
1530 t
= pa_sprintf_malloc("alsa_output.%s.%s", n
, mapping
->name
);
1532 t
= pa_sprintf_malloc("alsa_output.%s", n
);
1534 pa_sink_new_data_set_name(data
, t
);
1538 static void find_mixer(struct userdata
*u
, pa_alsa_mapping
*mapping
, const char *element
, pa_bool_t ignore_dB
) {
1540 if (!mapping
&& !element
)
1543 if (!(u
->mixer_handle
= pa_alsa_open_mixer_for_pcm(u
->pcm_handle
, &u
->control_device
))) {
1544 pa_log_info("Failed to find a working mixer device.");
1550 if (!(u
->mixer_path
= pa_alsa_path_synthesize(element
, PA_ALSA_DIRECTION_OUTPUT
)))
1553 if (pa_alsa_path_probe(u
->mixer_path
, u
->mixer_handle
, ignore_dB
) < 0)
1556 pa_log_debug("Probed mixer path %s:", u
->mixer_path
->name
);
1557 pa_alsa_path_dump(u
->mixer_path
);
1560 if (!(u
->mixer_path_set
= pa_alsa_path_set_new(mapping
, PA_ALSA_DIRECTION_OUTPUT
)))
1563 pa_alsa_path_set_probe(u
->mixer_path_set
, u
->mixer_handle
, ignore_dB
);
1565 pa_log_debug("Probed mixer paths:");
1566 pa_alsa_path_set_dump(u
->mixer_path_set
);
1573 if (u
->mixer_path_set
) {
1574 pa_alsa_path_set_free(u
->mixer_path_set
);
1575 u
->mixer_path_set
= NULL
;
1576 } else if (u
->mixer_path
) {
1577 pa_alsa_path_free(u
->mixer_path
);
1578 u
->mixer_path
= NULL
;
1581 if (u
->mixer_handle
) {
1582 snd_mixer_close(u
->mixer_handle
);
1583 u
->mixer_handle
= NULL
;
1587 static int setup_mixer(struct userdata
*u
, pa_bool_t ignore_dB
) {
1590 if (!u
->mixer_handle
)
1593 if (u
->sink
->active_port
) {
1594 pa_alsa_port_data
*data
;
1596 /* We have a list of supported paths, so let's activate the
1597 * one that has been chosen as active */
1599 data
= PA_DEVICE_PORT_DATA(u
->sink
->active_port
);
1600 u
->mixer_path
= data
->path
;
1602 pa_alsa_path_select(data
->path
, u
->mixer_handle
);
1605 pa_alsa_setting_select(data
->setting
, u
->mixer_handle
);
1609 if (!u
->mixer_path
&& u
->mixer_path_set
)
1610 u
->mixer_path
= u
->mixer_path_set
->paths
;
1612 if (u
->mixer_path
) {
1613 /* Hmm, we have only a single path, then let's activate it */
1615 pa_alsa_path_select(u
->mixer_path
, u
->mixer_handle
);
1617 if (u
->mixer_path
->settings
)
1618 pa_alsa_setting_select(u
->mixer_path
->settings
, u
->mixer_handle
);
1623 /* FIXME: need automatic detection rather than hard-coded path */
1624 if (!strcmp(u
->mixer_path
->name
, "iec958-passthrough-output")) {
1625 u
->sink
->flags
|= PA_SINK_PASSTHROUGH
;
1627 u
->sink
->flags
&= ~PA_SINK_PASSTHROUGH
;
1630 if (!u
->mixer_path
->has_volume
)
1631 pa_log_info("Driver does not support hardware volume control, falling back to software volume control.");
1634 if (u
->mixer_path
->has_dB
) {
1635 pa_log_info("Hardware volume ranges from %0.2f dB to %0.2f dB.", u
->mixer_path
->min_dB
, u
->mixer_path
->max_dB
);
1637 u
->sink
->base_volume
= pa_sw_volume_from_dB(-u
->mixer_path
->max_dB
);
1638 u
->sink
->n_volume_steps
= PA_VOLUME_NORM
+1;
1640 if (u
->mixer_path
->max_dB
> 0.0)
1641 pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(u
->sink
->base_volume
));
1643 pa_log_info("No particular base volume set, fixing to 0 dB");
1646 pa_log_info("Hardware volume ranges from %li to %li.", u
->mixer_path
->min_volume
, u
->mixer_path
->max_volume
);
1647 u
->sink
->base_volume
= PA_VOLUME_NORM
;
1648 u
->sink
->n_volume_steps
= u
->mixer_path
->max_volume
- u
->mixer_path
->min_volume
+ 1;
1651 u
->sink
->get_volume
= sink_get_volume_cb
;
1652 u
->sink
->set_volume
= sink_set_volume_cb
;
1654 u
->sink
->flags
|= PA_SINK_HW_VOLUME_CTRL
| (u
->mixer_path
->has_dB
? PA_SINK_DECIBEL_VOLUME
: 0);
1655 pa_log_info("Using hardware volume control. Hardware dB scale %s.", u
->mixer_path
->has_dB
? "supported" : "not supported");
1658 if (!u
->mixer_path
->has_mute
) {
1659 pa_log_info("Driver does not support hardware mute control, falling back to software mute control.");
1661 u
->sink
->get_mute
= sink_get_mute_cb
;
1662 u
->sink
->set_mute
= sink_set_mute_cb
;
1663 u
->sink
->flags
|= PA_SINK_HW_MUTE_CTRL
;
1664 pa_log_info("Using hardware mute control.");
1667 u
->mixer_fdl
= pa_alsa_fdlist_new();
1669 if (pa_alsa_fdlist_set_mixer(u
->mixer_fdl
, u
->mixer_handle
, u
->core
->mainloop
) < 0) {
1670 pa_log("Failed to initialize file descriptor monitoring");
1674 if (u
->mixer_path_set
)
1675 pa_alsa_path_set_set_callback(u
->mixer_path_set
, u
->mixer_handle
, mixer_callback
, u
);
1677 pa_alsa_path_set_callback(u
->mixer_path
, u
->mixer_handle
, mixer_callback
, u
);
1682 pa_sink
*pa_alsa_sink_new(pa_module
*m
, pa_modargs
*ma
, const char*driver
, pa_card
*card
, pa_alsa_mapping
*mapping
) {
1684 struct userdata
*u
= NULL
;
1685 const char *dev_id
= NULL
;
1686 pa_sample_spec ss
, requested_ss
;
1688 uint32_t nfrags
, frag_size
, buffer_size
, tsched_size
, tsched_watermark
, rewind_safeguard
;
1689 snd_pcm_uframes_t period_frames
, buffer_frames
, tsched_frames
;
1691 pa_bool_t use_mmap
= TRUE
, b
, use_tsched
= TRUE
, d
, ignore_dB
= FALSE
, namereg_fail
= FALSE
;
1692 pa_sink_new_data data
;
1693 pa_alsa_profile_set
*profile_set
= NULL
;
1698 ss
= m
->core
->default_sample_spec
;
1699 map
= m
->core
->default_channel_map
;
1700 if (pa_modargs_get_sample_spec_and_channel_map(ma
, &ss
, &map
, PA_CHANNEL_MAP_ALSA
) < 0) {
1701 pa_log("Failed to parse sample specification and channel map");
1706 frame_size
= pa_frame_size(&ss
);
1708 nfrags
= m
->core
->default_n_fragments
;
1709 frag_size
= (uint32_t) pa_usec_to_bytes(m
->core
->default_fragment_size_msec
*PA_USEC_PER_MSEC
, &ss
);
1711 frag_size
= (uint32_t) frame_size
;
1712 tsched_size
= (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_BUFFER_USEC
, &ss
);
1713 tsched_watermark
= (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_WATERMARK_USEC
, &ss
);
1715 if (pa_modargs_get_value_u32(ma
, "fragments", &nfrags
) < 0 ||
1716 pa_modargs_get_value_u32(ma
, "fragment_size", &frag_size
) < 0 ||
1717 pa_modargs_get_value_u32(ma
, "tsched_buffer_size", &tsched_size
) < 0 ||
1718 pa_modargs_get_value_u32(ma
, "tsched_buffer_watermark", &tsched_watermark
) < 0) {
1719 pa_log("Failed to parse buffer metrics");
1723 buffer_size
= nfrags
* frag_size
;
1725 period_frames
= frag_size
/frame_size
;
1726 buffer_frames
= buffer_size
/frame_size
;
1727 tsched_frames
= tsched_size
/frame_size
;
1729 if (pa_modargs_get_value_boolean(ma
, "mmap", &use_mmap
) < 0) {
1730 pa_log("Failed to parse mmap argument.");
1734 if (pa_modargs_get_value_boolean(ma
, "tsched", &use_tsched
) < 0) {
1735 pa_log("Failed to parse tsched argument.");
1739 if (pa_modargs_get_value_boolean(ma
, "ignore_dB", &ignore_dB
) < 0) {
1740 pa_log("Failed to parse ignore_dB argument.");
1744 rewind_safeguard
= PA_MAX(DEFAULT_REWIND_SAFEGUARD_BYTES
, pa_usec_to_bytes(DEFAULT_REWIND_SAFEGUARD_USEC
, &ss
));
1745 if (pa_modargs_get_value_u32(ma
, "rewind_safeguard", &rewind_safeguard
) < 0) {
1746 pa_log("Failed to parse rewind_safeguard argument");
1750 use_tsched
= pa_alsa_may_tsched(use_tsched
);
1752 u
= pa_xnew0(struct userdata
, 1);
1755 u
->use_mmap
= use_mmap
;
1756 u
->use_tsched
= use_tsched
;
1758 u
->rewind_safeguard
= rewind_safeguard
;
1759 u
->rtpoll
= pa_rtpoll_new();
1760 pa_thread_mq_init(&u
->thread_mq
, m
->core
->mainloop
, u
->rtpoll
);
1762 u
->smoother
= pa_smoother_new(
1763 SMOOTHER_ADJUST_USEC
,
1764 SMOOTHER_WINDOW_USEC
,
1770 u
->smoother_interval
= SMOOTHER_MIN_INTERVAL
;
1772 dev_id
= pa_modargs_get_value(
1774 pa_modargs_get_value(ma
, "device", DEFAULT_DEVICE
));
1776 if (reserve_init(u
, dev_id
) < 0)
1779 if (reserve_monitor_init(u
, dev_id
) < 0)
1787 if (!(dev_id
= pa_modargs_get_value(ma
, "device_id", NULL
))) {
1788 pa_log("device_id= not set");
1792 if (!(u
->pcm_handle
= pa_alsa_open_by_device_id_mapping(
1796 SND_PCM_STREAM_PLAYBACK
,
1797 &period_frames
, &buffer_frames
, tsched_frames
,
1802 } else if ((dev_id
= pa_modargs_get_value(ma
, "device_id", NULL
))) {
1804 if (!(profile_set
= pa_alsa_profile_set_new(NULL
, &map
)))
1807 if (!(u
->pcm_handle
= pa_alsa_open_by_device_id_auto(
1811 SND_PCM_STREAM_PLAYBACK
,
1812 &period_frames
, &buffer_frames
, tsched_frames
,
1813 &b
, &d
, profile_set
, &mapping
)))
1819 if (!(u
->pcm_handle
= pa_alsa_open_by_device_string(
1820 pa_modargs_get_value(ma
, "device", DEFAULT_DEVICE
),
1823 SND_PCM_STREAM_PLAYBACK
,
1824 &period_frames
, &buffer_frames
, tsched_frames
,
1829 pa_assert(u
->device_name
);
1830 pa_log_info("Successfully opened device %s.", u
->device_name
);
1832 if (pa_alsa_pcm_is_modem(u
->pcm_handle
)) {
1833 pa_log_notice("Device %s is modem, refusing further initialization.", u
->device_name
);
1838 pa_log_info("Selected mapping '%s' (%s).", mapping
->description
, mapping
->name
);
1840 if (use_mmap
&& !b
) {
1841 pa_log_info("Device doesn't support mmap(), falling back to UNIX read/write mode.");
1842 u
->use_mmap
= use_mmap
= FALSE
;
1845 if (use_tsched
&& (!b
|| !d
)) {
1846 pa_log_info("Cannot enable timer-based scheduling, falling back to sound IRQ scheduling.");
1847 u
->use_tsched
= use_tsched
= FALSE
;
1851 pa_log_info("Successfully enabled mmap() mode.");
1854 pa_log_info("Successfully enabled timer-based scheduling mode.");
1856 /* ALSA might tweak the sample spec, so recalculate the frame size */
1857 frame_size
= pa_frame_size(&ss
);
1859 find_mixer(u
, mapping
, pa_modargs_get_value(ma
, "control", NULL
), ignore_dB
);
1861 pa_sink_new_data_init(&data
);
1862 data
.driver
= driver
;
1865 set_sink_name(&data
, ma
, dev_id
, u
->device_name
, mapping
);
1867 /* We need to give pa_modargs_get_value_boolean() a pointer to a local
1868 * variable instead of using &data.namereg_fail directly, because
1869 * data.namereg_fail is a bitfield and taking the address of a bitfield
1870 * variable is impossible. */
1871 namereg_fail
= data
.namereg_fail
;
1872 if (pa_modargs_get_value_boolean(ma
, "namereg_fail", &namereg_fail
) < 0) {
1873 pa_log("Failed to parse boolean argument namereg_fail.");
1874 pa_sink_new_data_done(&data
);
1877 data
.namereg_fail
= namereg_fail
;
1879 pa_sink_new_data_set_sample_spec(&data
, &ss
);
1880 pa_sink_new_data_set_channel_map(&data
, &map
);
1882 pa_alsa_init_proplist_pcm(m
->core
, data
.proplist
, u
->pcm_handle
);
1883 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_STRING
, u
->device_name
);
1884 pa_proplist_setf(data
.proplist
, PA_PROP_DEVICE_BUFFERING_BUFFER_SIZE
, "%lu", (unsigned long) (buffer_frames
* frame_size
));
1885 pa_proplist_setf(data
.proplist
, PA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZE
, "%lu", (unsigned long) (period_frames
* frame_size
));
1886 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_ACCESS_MODE
, u
->use_tsched
? "mmap+timer" : (u
->use_mmap
? "mmap" : "serial"));
1889 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_PROFILE_NAME
, mapping
->name
);
1890 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_PROFILE_DESCRIPTION
, mapping
->description
);
1893 pa_alsa_init_description(data
.proplist
);
1895 if (u
->control_device
)
1896 pa_alsa_init_proplist_ctl(data
.proplist
, u
->control_device
);
1898 if (pa_modargs_get_proplist(ma
, "sink_properties", data
.proplist
, PA_UPDATE_REPLACE
) < 0) {
1899 pa_log("Invalid properties");
1900 pa_sink_new_data_done(&data
);
1904 if (u
->mixer_path_set
)
1905 pa_alsa_add_ports(&data
.ports
, u
->mixer_path_set
);
1907 u
->sink
= pa_sink_new(m
->core
, &data
, PA_SINK_HARDWARE
|PA_SINK_LATENCY
|(u
->use_tsched
? PA_SINK_DYNAMIC_LATENCY
: 0));
1908 pa_sink_new_data_done(&data
);
1911 pa_log("Failed to create sink object");
1915 u
->sink
->parent
.process_msg
= sink_process_msg
;
1917 u
->sink
->update_requested_latency
= sink_update_requested_latency_cb
;
1918 u
->sink
->set_state
= sink_set_state_cb
;
1919 u
->sink
->set_port
= sink_set_port_cb
;
1920 u
->sink
->userdata
= u
;
1922 pa_sink_set_asyncmsgq(u
->sink
, u
->thread_mq
.inq
);
1923 pa_sink_set_rtpoll(u
->sink
, u
->rtpoll
);
1925 u
->frame_size
= frame_size
;
1926 u
->fragment_size
= frag_size
= (size_t) (period_frames
* frame_size
);
1927 u
->hwbuf_size
= buffer_size
= (size_t) (buffer_frames
* frame_size
);
1928 pa_cvolume_mute(&u
->hardware_volume
, u
->sink
->sample_spec
.channels
);
1930 pa_log_info("Using %0.1f fragments of size %lu bytes (%0.2fms), buffer size is %lu bytes (%0.2fms)",
1931 (double) u
->hwbuf_size
/ (double) u
->fragment_size
,
1932 (long unsigned) u
->fragment_size
,
1933 (double) pa_bytes_to_usec(u
->fragment_size
, &ss
) / PA_USEC_PER_MSEC
,
1934 (long unsigned) u
->hwbuf_size
,
1935 (double) pa_bytes_to_usec(u
->hwbuf_size
, &ss
) / PA_USEC_PER_MSEC
);
1937 pa_sink_set_max_request(u
->sink
, u
->hwbuf_size
);
1938 if (pa_alsa_pcm_is_hw(u
->pcm_handle
))
1939 pa_sink_set_max_rewind(u
->sink
, u
->hwbuf_size
);
1941 pa_log_info("Disabling rewind for device %s", u
->device_name
);
1942 pa_sink_set_max_rewind(u
->sink
, 0);
1945 if (u
->use_tsched
) {
1946 u
->tsched_watermark
= pa_usec_to_bytes_round_up(pa_bytes_to_usec_round_up(tsched_watermark
, &requested_ss
), &u
->sink
->sample_spec
);
1948 u
->watermark_inc_step
= pa_usec_to_bytes(TSCHED_WATERMARK_INC_STEP_USEC
, &u
->sink
->sample_spec
);
1949 u
->watermark_dec_step
= pa_usec_to_bytes(TSCHED_WATERMARK_DEC_STEP_USEC
, &u
->sink
->sample_spec
);
1951 u
->watermark_inc_threshold
= pa_usec_to_bytes_round_up(TSCHED_WATERMARK_INC_THRESHOLD_USEC
, &u
->sink
->sample_spec
);
1952 u
->watermark_dec_threshold
= pa_usec_to_bytes_round_up(TSCHED_WATERMARK_DEC_THRESHOLD_USEC
, &u
->sink
->sample_spec
);
1954 fix_min_sleep_wakeup(u
);
1955 fix_tsched_watermark(u
);
1957 pa_sink_set_latency_range(u
->sink
,
1959 pa_bytes_to_usec(u
->hwbuf_size
, &ss
));
1961 pa_log_info("Time scheduling watermark is %0.2fms",
1962 (double) pa_bytes_to_usec(u
->tsched_watermark
, &ss
) / PA_USEC_PER_MSEC
);
1964 pa_sink_set_fixed_latency(u
->sink
, pa_bytes_to_usec(u
->hwbuf_size
, &ss
));
1968 if (update_sw_params(u
) < 0)
1971 if (setup_mixer(u
, ignore_dB
) < 0)
1974 pa_alsa_dump(PA_LOG_DEBUG
, u
->pcm_handle
);
1976 if (!(u
->thread
= pa_thread_new("alsa-sink", thread_func
, u
))) {
1977 pa_log("Failed to create thread.");
1981 /* Get initial mixer settings */
1982 if (data
.volume_is_set
) {
1983 if (u
->sink
->set_volume
)
1984 u
->sink
->set_volume(u
->sink
);
1986 if (u
->sink
->get_volume
)
1987 u
->sink
->get_volume(u
->sink
);
1990 if (data
.muted_is_set
) {
1991 if (u
->sink
->set_mute
)
1992 u
->sink
->set_mute(u
->sink
);
1994 if (u
->sink
->get_mute
)
1995 u
->sink
->get_mute(u
->sink
);
1998 pa_sink_put(u
->sink
);
2001 pa_alsa_profile_set_free(profile_set
);
2011 pa_alsa_profile_set_free(profile_set
);
2016 static void userdata_free(struct userdata
*u
) {
2020 pa_sink_unlink(u
->sink
);
2023 pa_asyncmsgq_send(u
->thread_mq
.inq
, NULL
, PA_MESSAGE_SHUTDOWN
, NULL
, 0, NULL
);
2024 pa_thread_free(u
->thread
);
2027 pa_thread_mq_done(&u
->thread_mq
);
2030 pa_sink_unref(u
->sink
);
2032 if (u
->memchunk
.memblock
)
2033 pa_memblock_unref(u
->memchunk
.memblock
);
2035 if (u
->alsa_rtpoll_item
)
2036 pa_rtpoll_item_free(u
->alsa_rtpoll_item
);
2039 pa_rtpoll_free(u
->rtpoll
);
2041 if (u
->pcm_handle
) {
2042 snd_pcm_drop(u
->pcm_handle
);
2043 snd_pcm_close(u
->pcm_handle
);
2047 pa_alsa_fdlist_free(u
->mixer_fdl
);
2049 if (u
->mixer_path_set
)
2050 pa_alsa_path_set_free(u
->mixer_path_set
);
2051 else if (u
->mixer_path
)
2052 pa_alsa_path_free(u
->mixer_path
);
2054 if (u
->mixer_handle
)
2055 snd_mixer_close(u
->mixer_handle
);
2058 pa_smoother_free(u
->smoother
);
2063 pa_xfree(u
->device_name
);
2064 pa_xfree(u
->control_device
);
2068 void pa_alsa_sink_free(pa_sink
*s
) {
2071 pa_sink_assert_ref(s
);
2072 pa_assert_se(u
= s
->userdata
);