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
30 #include <asoundlib.h>
32 #include <pulse/rtclock.h>
33 #include <pulse/timeval.h>
34 #include <pulse/volume.h>
35 #include <pulse/xmalloc.h>
37 #include <pulsecore/core.h>
38 #include <pulsecore/i18n.h>
39 #include <pulsecore/module.h>
40 #include <pulsecore/memchunk.h>
41 #include <pulsecore/sink.h>
42 #include <pulsecore/modargs.h>
43 #include <pulsecore/core-rtclock.h>
44 #include <pulsecore/core-util.h>
45 #include <pulsecore/sample-util.h>
46 #include <pulsecore/log.h>
47 #include <pulsecore/macro.h>
48 #include <pulsecore/thread.h>
49 #include <pulsecore/thread-mq.h>
50 #include <pulsecore/rtpoll.h>
51 #include <pulsecore/time-smoother.h>
53 #include <modules/reserve-wrap.h>
55 #include "alsa-util.h"
56 #include "alsa-source.h"
58 /* #define DEBUG_TIMING */
60 #define DEFAULT_DEVICE "default"
62 #define DEFAULT_TSCHED_BUFFER_USEC (2*PA_USEC_PER_SEC) /* 2s */
63 #define DEFAULT_TSCHED_WATERMARK_USEC (20*PA_USEC_PER_MSEC) /* 20ms */
65 #define TSCHED_WATERMARK_INC_STEP_USEC (10*PA_USEC_PER_MSEC) /* 10ms */
66 #define TSCHED_WATERMARK_DEC_STEP_USEC (5*PA_USEC_PER_MSEC) /* 5ms */
67 #define TSCHED_WATERMARK_VERIFY_AFTER_USEC (20*PA_USEC_PER_SEC) /* 20s */
68 #define TSCHED_WATERMARK_INC_THRESHOLD_USEC (0*PA_USEC_PER_MSEC) /* 0ms */
69 #define TSCHED_WATERMARK_DEC_THRESHOLD_USEC (100*PA_USEC_PER_MSEC) /* 100ms */
70 #define TSCHED_WATERMARK_STEP_USEC (10*PA_USEC_PER_MSEC) /* 10ms */
72 #define TSCHED_MIN_SLEEP_USEC (10*PA_USEC_PER_MSEC) /* 10ms */
73 #define TSCHED_MIN_WAKEUP_USEC (4*PA_USEC_PER_MSEC) /* 4ms */
75 #define SMOOTHER_WINDOW_USEC (10*PA_USEC_PER_SEC) /* 10s */
76 #define SMOOTHER_ADJUST_USEC (1*PA_USEC_PER_SEC) /* 1s */
78 #define SMOOTHER_MIN_INTERVAL (2*PA_USEC_PER_MSEC) /* 2ms */
79 #define SMOOTHER_MAX_INTERVAL (200*PA_USEC_PER_MSEC) /* 200ms */
81 #define VOLUME_ACCURACY (PA_VOLUME_NORM/100)
89 pa_thread_mq thread_mq
;
92 snd_pcm_t
*pcm_handle
;
95 pa_alsa_fdlist
*mixer_fdl
;
96 pa_alsa_mixer_pdata
*mixer_pd
;
97 snd_mixer_t
*mixer_handle
;
98 pa_alsa_path_set
*mixer_path_set
;
99 pa_alsa_path
*mixer_path
;
101 pa_cvolume hardware_volume
;
110 tsched_watermark_ref
,
116 watermark_inc_threshold
,
117 watermark_dec_threshold
;
119 pa_usec_t watermark_dec_not_before
;
120 pa_usec_t min_latency_ref
;
121 pa_usec_t tsched_watermark_usec
;
123 char *device_name
; /* name of the PCM device */
124 char *control_device
; /* name of the control device */
126 bool use_mmap
:1, use_tsched
:1, deferred_volume
:1, fixed_latency_range
:1;
130 pa_rtpoll_item
*alsa_rtpoll_item
;
132 pa_smoother
*smoother
;
134 pa_usec_t smoother_interval
;
135 pa_usec_t last_smoother_update
;
137 pa_reserve_wrapper
*reserve
;
138 pa_hook_slot
*reserve_slot
;
139 pa_reserve_monitor_wrapper
*monitor
;
140 pa_hook_slot
*monitor_slot
;
143 pa_alsa_ucm_mapping_context
*ucm_context
;
146 static void userdata_free(struct userdata
*u
);
148 static pa_hook_result_t
reserve_cb(pa_reserve_wrapper
*r
, void *forced
, struct userdata
*u
) {
152 pa_log_debug("Suspending source %s, because another application requested us to release the device.", u
->source
->name
);
154 if (pa_source_suspend(u
->source
, true, PA_SUSPEND_APPLICATION
) < 0)
155 return PA_HOOK_CANCEL
;
160 static void reserve_done(struct userdata
*u
) {
163 if (u
->reserve_slot
) {
164 pa_hook_slot_free(u
->reserve_slot
);
165 u
->reserve_slot
= NULL
;
169 pa_reserve_wrapper_unref(u
->reserve
);
174 static void reserve_update(struct userdata
*u
) {
175 const char *description
;
178 if (!u
->source
|| !u
->reserve
)
181 if ((description
= pa_proplist_gets(u
->source
->proplist
, PA_PROP_DEVICE_DESCRIPTION
)))
182 pa_reserve_wrapper_set_application_device_name(u
->reserve
, description
);
185 static int reserve_init(struct userdata
*u
, const char *dname
) {
194 if (pa_in_system_mode())
197 if (!(rname
= pa_alsa_get_reserve_name(dname
)))
200 /* We are resuming, try to lock the device */
201 u
->reserve
= pa_reserve_wrapper_get(u
->core
, rname
);
209 pa_assert(!u
->reserve_slot
);
210 u
->reserve_slot
= pa_hook_connect(pa_reserve_wrapper_hook(u
->reserve
), PA_HOOK_NORMAL
, (pa_hook_cb_t
) reserve_cb
, u
);
215 static pa_hook_result_t
monitor_cb(pa_reserve_monitor_wrapper
*w
, void* busy
, struct userdata
*u
) {
219 if (PA_PTR_TO_UINT(busy
) && !u
->reserve
) {
220 pa_log_debug("Suspending source %s, because another application is blocking the access to the device.", u
->source
->name
);
221 pa_source_suspend(u
->source
, true, PA_SUSPEND_APPLICATION
);
223 pa_log_debug("Resuming source %s, because other applications aren't blocking access to the device any more.", u
->source
->name
);
224 pa_source_suspend(u
->source
, false, 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 /* We are resuming, try to lock the device */
257 u
->monitor
= pa_reserve_monitor_wrapper_get(u
->core
, rname
);
263 pa_assert(!u
->monitor_slot
);
264 u
->monitor_slot
= pa_hook_connect(pa_reserve_monitor_wrapper_hook(u
->monitor
), PA_HOOK_NORMAL
, (pa_hook_cb_t
) monitor_cb
, u
);
269 static void fix_min_sleep_wakeup(struct userdata
*u
) {
270 size_t max_use
, max_use_2
;
273 pa_assert(u
->use_tsched
);
275 max_use
= u
->hwbuf_size
- u
->hwbuf_unused
;
276 max_use_2
= pa_frame_align(max_use
/2, &u
->source
->sample_spec
);
278 u
->min_sleep
= pa_usec_to_bytes(TSCHED_MIN_SLEEP_USEC
, &u
->source
->sample_spec
);
279 u
->min_sleep
= PA_CLAMP(u
->min_sleep
, u
->frame_size
, max_use_2
);
281 u
->min_wakeup
= pa_usec_to_bytes(TSCHED_MIN_WAKEUP_USEC
, &u
->source
->sample_spec
);
282 u
->min_wakeup
= PA_CLAMP(u
->min_wakeup
, u
->frame_size
, max_use_2
);
285 static void fix_tsched_watermark(struct userdata
*u
) {
288 pa_assert(u
->use_tsched
);
290 max_use
= u
->hwbuf_size
- u
->hwbuf_unused
;
292 if (u
->tsched_watermark
> max_use
- u
->min_sleep
)
293 u
->tsched_watermark
= max_use
- u
->min_sleep
;
295 if (u
->tsched_watermark
< u
->min_wakeup
)
296 u
->tsched_watermark
= u
->min_wakeup
;
298 u
->tsched_watermark_usec
= pa_bytes_to_usec(u
->tsched_watermark
, &u
->source
->sample_spec
);
301 static void increase_watermark(struct userdata
*u
) {
302 size_t old_watermark
;
303 pa_usec_t old_min_latency
, new_min_latency
;
306 pa_assert(u
->use_tsched
);
308 /* First, just try to increase the watermark */
309 old_watermark
= u
->tsched_watermark
;
310 u
->tsched_watermark
= PA_MIN(u
->tsched_watermark
* 2, u
->tsched_watermark
+ u
->watermark_inc_step
);
311 fix_tsched_watermark(u
);
313 if (old_watermark
!= u
->tsched_watermark
) {
314 pa_log_info("Increasing wakeup watermark to %0.2f ms",
315 (double) u
->tsched_watermark_usec
/ PA_USEC_PER_MSEC
);
319 /* Hmm, we cannot increase the watermark any further, hence let's
320 raise the latency unless doing so was disabled in
322 if (u
->fixed_latency_range
)
325 old_min_latency
= u
->source
->thread_info
.min_latency
;
326 new_min_latency
= PA_MIN(old_min_latency
* 2, old_min_latency
+ TSCHED_WATERMARK_INC_STEP_USEC
);
327 new_min_latency
= PA_MIN(new_min_latency
, u
->source
->thread_info
.max_latency
);
329 if (old_min_latency
!= new_min_latency
) {
330 pa_log_info("Increasing minimal latency to %0.2f ms",
331 (double) new_min_latency
/ PA_USEC_PER_MSEC
);
333 pa_source_set_latency_range_within_thread(u
->source
, new_min_latency
, u
->source
->thread_info
.max_latency
);
336 /* When we reach this we're officialy fucked! */
339 static void decrease_watermark(struct userdata
*u
) {
340 size_t old_watermark
;
344 pa_assert(u
->use_tsched
);
346 now
= pa_rtclock_now();
348 if (u
->watermark_dec_not_before
<= 0)
351 if (u
->watermark_dec_not_before
> now
)
354 old_watermark
= u
->tsched_watermark
;
356 if (u
->tsched_watermark
< u
->watermark_dec_step
)
357 u
->tsched_watermark
= u
->tsched_watermark
/ 2;
359 u
->tsched_watermark
= PA_MAX(u
->tsched_watermark
/ 2, u
->tsched_watermark
- u
->watermark_dec_step
);
361 fix_tsched_watermark(u
);
363 if (old_watermark
!= u
->tsched_watermark
)
364 pa_log_info("Decreasing wakeup watermark to %0.2f ms",
365 (double) u
->tsched_watermark_usec
/ PA_USEC_PER_MSEC
);
367 /* We don't change the latency range*/
370 u
->watermark_dec_not_before
= now
+ TSCHED_WATERMARK_VERIFY_AFTER_USEC
;
373 static void hw_sleep_time(struct userdata
*u
, pa_usec_t
*sleep_usec
, pa_usec_t
*process_usec
) {
376 pa_assert(sleep_usec
);
377 pa_assert(process_usec
);
380 pa_assert(u
->use_tsched
);
382 usec
= pa_source_get_requested_latency_within_thread(u
->source
);
384 if (usec
== (pa_usec_t
) -1)
385 usec
= pa_bytes_to_usec(u
->hwbuf_size
, &u
->source
->sample_spec
);
387 wm
= u
->tsched_watermark_usec
;
392 *sleep_usec
= usec
- wm
;
396 pa_log_debug("Buffer time: %lu ms; Sleep time: %lu ms; Process time: %lu ms",
397 (unsigned long) (usec
/ PA_USEC_PER_MSEC
),
398 (unsigned long) (*sleep_usec
/ PA_USEC_PER_MSEC
),
399 (unsigned long) (*process_usec
/ PA_USEC_PER_MSEC
));
403 static int try_recover(struct userdata
*u
, const char *call
, int err
) {
408 pa_log_debug("%s: %s", call
, pa_alsa_strerror(err
));
410 pa_assert(err
!= -EAGAIN
);
413 pa_log_debug("%s: Buffer overrun!", call
);
415 if (err
== -ESTRPIPE
)
416 pa_log_debug("%s: System suspended!", call
);
418 if ((err
= snd_pcm_recover(u
->pcm_handle
, err
, 1)) < 0) {
419 pa_log("%s: %s", call
, pa_alsa_strerror(err
));
427 static size_t check_left_to_record(struct userdata
*u
, size_t n_bytes
, bool on_timeout
) {
428 size_t left_to_record
;
429 size_t rec_space
= u
->hwbuf_size
- u
->hwbuf_unused
;
430 bool overrun
= false;
432 /* We use <= instead of < for this check here because an overrun
433 * only happens after the last sample was processed, not already when
434 * it is removed from the buffer. This is particularly important
435 * when block transfer is used. */
437 if (n_bytes
<= rec_space
)
438 left_to_record
= rec_space
- n_bytes
;
441 /* We got a dropout. What a mess! */
449 if (pa_log_ratelimit(PA_LOG_INFO
))
450 pa_log_info("Overrun!");
454 pa_log_debug("%0.2f ms left to record", (double) pa_bytes_to_usec(left_to_record
, &u
->source
->sample_spec
) / PA_USEC_PER_MSEC
);
458 bool reset_not_before
= true;
460 if (overrun
|| left_to_record
< u
->watermark_inc_threshold
)
461 increase_watermark(u
);
462 else if (left_to_record
> u
->watermark_dec_threshold
) {
463 reset_not_before
= false;
465 /* We decrease the watermark only if have actually
466 * been woken up by a timeout. If something else woke
467 * us up it's too easy to fulfill the deadlines... */
470 decrease_watermark(u
);
473 if (reset_not_before
)
474 u
->watermark_dec_not_before
= 0;
477 return left_to_record
;
480 static int mmap_read(struct userdata
*u
, pa_usec_t
*sleep_usec
, bool polled
, bool on_timeout
) {
481 bool work_done
= false;
482 pa_usec_t max_sleep_usec
= 0, process_usec
= 0;
483 size_t left_to_record
;
487 pa_source_assert_ref(u
->source
);
490 hw_sleep_time(u
, &max_sleep_usec
, &process_usec
);
496 bool after_avail
= true;
498 if (PA_UNLIKELY((n
= pa_alsa_safe_avail(u
->pcm_handle
, u
->hwbuf_size
, &u
->source
->sample_spec
)) < 0)) {
500 if ((r
= try_recover(u
, "snd_pcm_avail", (int) n
)) == 0)
506 n_bytes
= (size_t) n
* u
->frame_size
;
509 pa_log_debug("avail: %lu", (unsigned long) n_bytes
);
512 left_to_record
= check_left_to_record(u
, n_bytes
, on_timeout
);
517 pa_bytes_to_usec(left_to_record
, &u
->source
->sample_spec
) > process_usec
+max_sleep_usec
/2) {
519 pa_log_debug("Not reading, because too early.");
524 if (PA_UNLIKELY(n_bytes
<= 0)) {
528 char *dn
= pa_alsa_get_driver_name_by_pcm(u
->pcm_handle
);
529 pa_log(_("ALSA woke us up to read new data from the device, but there was actually nothing to read!\n"
530 "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers.\n"
531 "We were woken up with POLLIN set -- however a subsequent snd_pcm_avail() returned 0 or another value < min_avail."),
537 pa_log_debug("Not reading, because not necessary.");
544 pa_log_debug("Not filling up, because already too many iterations.");
553 pa_log_debug("Reading");
560 const snd_pcm_channel_area_t
*areas
;
561 snd_pcm_uframes_t offset
, frames
;
562 snd_pcm_sframes_t sframes
;
564 frames
= (snd_pcm_uframes_t
) (n_bytes
/ u
->frame_size
);
565 /* pa_log_debug("%lu frames to read", (unsigned long) frames); */
567 if (PA_UNLIKELY((err
= pa_alsa_safe_mmap_begin(u
->pcm_handle
, &areas
, &offset
, &frames
, u
->hwbuf_size
, &u
->source
->sample_spec
)) < 0)) {
569 if (!after_avail
&& err
== -EAGAIN
)
572 if ((r
= try_recover(u
, "snd_pcm_mmap_begin", err
)) == 0)
578 /* Make sure that if these memblocks need to be copied they will fit into one slot */
579 if (frames
> pa_mempool_block_size_max(u
->core
->mempool
)/u
->frame_size
)
580 frames
= pa_mempool_block_size_max(u
->core
->mempool
)/u
->frame_size
;
582 if (!after_avail
&& frames
== 0)
585 pa_assert(frames
> 0);
588 /* Check these are multiples of 8 bit */
589 pa_assert((areas
[0].first
& 7) == 0);
590 pa_assert((areas
[0].step
& 7)== 0);
592 /* We assume a single interleaved memory buffer */
593 pa_assert((areas
[0].first
>> 3) == 0);
594 pa_assert((areas
[0].step
>> 3) == u
->frame_size
);
596 p
= (uint8_t*) areas
[0].addr
+ (offset
* u
->frame_size
);
598 chunk
.memblock
= pa_memblock_new_fixed(u
->core
->mempool
, p
, frames
* u
->frame_size
, true);
599 chunk
.length
= pa_memblock_get_length(chunk
.memblock
);
602 pa_source_post(u
->source
, &chunk
);
603 pa_memblock_unref_fixed(chunk
.memblock
);
605 if (PA_UNLIKELY((sframes
= snd_pcm_mmap_commit(u
->pcm_handle
, offset
, frames
)) < 0)) {
607 if ((r
= try_recover(u
, "snd_pcm_mmap_commit", (int) sframes
)) == 0)
615 u
->read_count
+= frames
* u
->frame_size
;
618 pa_log_debug("Read %lu bytes (of possible %lu bytes)", (unsigned long) (frames
* u
->frame_size
), (unsigned long) n_bytes
);
621 if ((size_t) frames
* u
->frame_size
>= n_bytes
)
624 n_bytes
-= (size_t) frames
* u
->frame_size
;
629 *sleep_usec
= pa_bytes_to_usec(left_to_record
, &u
->source
->sample_spec
);
630 process_usec
= u
->tsched_watermark_usec
;
632 if (*sleep_usec
> process_usec
)
633 *sleep_usec
-= process_usec
;
638 return work_done
? 1 : 0;
641 static int unix_read(struct userdata
*u
, pa_usec_t
*sleep_usec
, bool polled
, bool on_timeout
) {
642 int work_done
= false;
643 pa_usec_t max_sleep_usec
= 0, process_usec
= 0;
644 size_t left_to_record
;
648 pa_source_assert_ref(u
->source
);
651 hw_sleep_time(u
, &max_sleep_usec
, &process_usec
);
657 bool after_avail
= true;
659 if (PA_UNLIKELY((n
= pa_alsa_safe_avail(u
->pcm_handle
, u
->hwbuf_size
, &u
->source
->sample_spec
)) < 0)) {
661 if ((r
= try_recover(u
, "snd_pcm_avail", (int) n
)) == 0)
667 n_bytes
= (size_t) n
* u
->frame_size
;
668 left_to_record
= check_left_to_record(u
, n_bytes
, on_timeout
);
673 pa_bytes_to_usec(left_to_record
, &u
->source
->sample_spec
) > process_usec
+max_sleep_usec
/2)
676 if (PA_UNLIKELY(n_bytes
<= 0)) {
680 char *dn
= pa_alsa_get_driver_name_by_pcm(u
->pcm_handle
);
681 pa_log(_("ALSA woke us up to read new data from the device, but there was actually nothing to read!\n"
682 "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers.\n"
683 "We were woken up with POLLIN set -- however a subsequent snd_pcm_avail() returned 0 or another value < min_avail."),
693 pa_log_debug("Not filling up, because already too many iterations.");
703 snd_pcm_sframes_t frames
;
706 chunk
.memblock
= pa_memblock_new(u
->core
->mempool
, (size_t) -1);
708 frames
= (snd_pcm_sframes_t
) (pa_memblock_get_length(chunk
.memblock
) / u
->frame_size
);
710 if (frames
> (snd_pcm_sframes_t
) (n_bytes
/u
->frame_size
))
711 frames
= (snd_pcm_sframes_t
) (n_bytes
/u
->frame_size
);
713 /* pa_log_debug("%lu frames to read", (unsigned long) n); */
715 p
= pa_memblock_acquire(chunk
.memblock
);
716 frames
= snd_pcm_readi(u
->pcm_handle
, (uint8_t*) p
, (snd_pcm_uframes_t
) frames
);
717 pa_memblock_release(chunk
.memblock
);
719 if (PA_UNLIKELY(frames
< 0)) {
720 pa_memblock_unref(chunk
.memblock
);
722 if (!after_avail
&& (int) frames
== -EAGAIN
)
725 if ((r
= try_recover(u
, "snd_pcm_readi", (int) frames
)) == 0)
731 if (!after_avail
&& frames
== 0) {
732 pa_memblock_unref(chunk
.memblock
);
736 pa_assert(frames
> 0);
740 chunk
.length
= (size_t) frames
* u
->frame_size
;
742 pa_source_post(u
->source
, &chunk
);
743 pa_memblock_unref(chunk
.memblock
);
747 u
->read_count
+= frames
* u
->frame_size
;
749 /* pa_log_debug("read %lu frames", (unsigned long) frames); */
751 if ((size_t) frames
* u
->frame_size
>= n_bytes
)
754 n_bytes
-= (size_t) frames
* u
->frame_size
;
759 *sleep_usec
= pa_bytes_to_usec(left_to_record
, &u
->source
->sample_spec
);
760 process_usec
= u
->tsched_watermark_usec
;
762 if (*sleep_usec
> process_usec
)
763 *sleep_usec
-= process_usec
;
768 return work_done
? 1 : 0;
771 static void update_smoother(struct userdata
*u
) {
772 snd_pcm_sframes_t delay
= 0;
775 pa_usec_t now1
= 0, now2
;
776 snd_pcm_status_t
*status
;
777 snd_htimestamp_t htstamp
= { 0, 0 };
779 snd_pcm_status_alloca(&status
);
782 pa_assert(u
->pcm_handle
);
784 /* Let's update the time smoother */
786 if (PA_UNLIKELY((err
= pa_alsa_safe_delay(u
->pcm_handle
, status
, &delay
, u
->hwbuf_size
, &u
->source
->sample_spec
, true)) < 0)) {
787 pa_log_warn("Failed to get delay: %s", pa_alsa_strerror(err
));
791 snd_pcm_status_get_htstamp(status
, &htstamp
);
792 now1
= pa_timespec_load(&htstamp
);
794 /* Hmm, if the timestamp is 0, then it wasn't set and we take the current time */
796 now1
= pa_rtclock_now();
798 /* check if the time since the last update is bigger than the interval */
799 if (u
->last_smoother_update
> 0)
800 if (u
->last_smoother_update
+ u
->smoother_interval
> now1
)
803 position
= u
->read_count
+ ((uint64_t) delay
* (uint64_t) u
->frame_size
);
804 now2
= pa_bytes_to_usec(position
, &u
->source
->sample_spec
);
806 pa_smoother_put(u
->smoother
, now1
, now2
);
808 u
->last_smoother_update
= now1
;
809 /* exponentially increase the update interval up to the MAX limit */
810 u
->smoother_interval
= PA_MIN (u
->smoother_interval
* 2, SMOOTHER_MAX_INTERVAL
);
813 static pa_usec_t
source_get_latency(struct userdata
*u
) {
815 pa_usec_t now1
, now2
;
819 now1
= pa_rtclock_now();
820 now2
= pa_smoother_get(u
->smoother
, now1
);
822 delay
= (int64_t) now2
- (int64_t) pa_bytes_to_usec(u
->read_count
, &u
->source
->sample_spec
);
824 return delay
>= 0 ? (pa_usec_t
) delay
: 0;
827 static int build_pollfd(struct userdata
*u
) {
829 pa_assert(u
->pcm_handle
);
831 if (u
->alsa_rtpoll_item
)
832 pa_rtpoll_item_free(u
->alsa_rtpoll_item
);
834 if (!(u
->alsa_rtpoll_item
= pa_alsa_build_pollfd(u
->pcm_handle
, u
->rtpoll
)))
840 /* Called from IO context */
841 static int suspend(struct userdata
*u
) {
843 pa_assert(u
->pcm_handle
);
845 pa_smoother_pause(u
->smoother
, pa_rtclock_now());
848 snd_pcm_close(u
->pcm_handle
);
849 u
->pcm_handle
= NULL
;
851 if (u
->alsa_rtpoll_item
) {
852 pa_rtpoll_item_free(u
->alsa_rtpoll_item
);
853 u
->alsa_rtpoll_item
= NULL
;
856 pa_log_info("Device suspended...");
861 /* Called from IO context */
862 static int update_sw_params(struct userdata
*u
) {
863 snd_pcm_uframes_t avail_min
;
868 /* Use the full buffer if no one asked us for anything specific */
874 if ((latency
= pa_source_get_requested_latency_within_thread(u
->source
)) != (pa_usec_t
) -1) {
877 pa_log_debug("latency set to %0.2fms", (double) latency
/ PA_USEC_PER_MSEC
);
879 b
= pa_usec_to_bytes(latency
, &u
->source
->sample_spec
);
881 /* We need at least one sample in our buffer */
883 if (PA_UNLIKELY(b
< u
->frame_size
))
886 u
->hwbuf_unused
= PA_LIKELY(b
< u
->hwbuf_size
) ? (u
->hwbuf_size
- b
) : 0;
889 fix_min_sleep_wakeup(u
);
890 fix_tsched_watermark(u
);
893 pa_log_debug("hwbuf_unused=%lu", (unsigned long) u
->hwbuf_unused
);
898 pa_usec_t sleep_usec
, process_usec
;
900 hw_sleep_time(u
, &sleep_usec
, &process_usec
);
901 avail_min
+= pa_usec_to_bytes(sleep_usec
, &u
->source
->sample_spec
) / u
->frame_size
;
904 pa_log_debug("setting avail_min=%lu", (unsigned long) avail_min
);
906 if ((err
= pa_alsa_set_sw_params(u
->pcm_handle
, avail_min
, !u
->use_tsched
)) < 0) {
907 pa_log("Failed to set software parameters: %s", pa_alsa_strerror(err
));
914 /* Called from IO Context on unsuspend or from main thread when creating source */
915 static void reset_watermark(struct userdata
*u
, size_t tsched_watermark
, pa_sample_spec
*ss
,
917 u
->tsched_watermark
= pa_usec_to_bytes_round_up(pa_bytes_to_usec_round_up(tsched_watermark
, ss
),
918 &u
->source
->sample_spec
);
920 u
->watermark_inc_step
= pa_usec_to_bytes(TSCHED_WATERMARK_INC_STEP_USEC
, &u
->source
->sample_spec
);
921 u
->watermark_dec_step
= pa_usec_to_bytes(TSCHED_WATERMARK_DEC_STEP_USEC
, &u
->source
->sample_spec
);
923 u
->watermark_inc_threshold
= pa_usec_to_bytes_round_up(TSCHED_WATERMARK_INC_THRESHOLD_USEC
, &u
->source
->sample_spec
);
924 u
->watermark_dec_threshold
= pa_usec_to_bytes_round_up(TSCHED_WATERMARK_DEC_THRESHOLD_USEC
, &u
->source
->sample_spec
);
926 fix_min_sleep_wakeup(u
);
927 fix_tsched_watermark(u
);
930 pa_source_set_latency_range_within_thread(u
->source
,
932 pa_bytes_to_usec(u
->hwbuf_size
, ss
));
934 pa_source_set_latency_range(u
->source
,
936 pa_bytes_to_usec(u
->hwbuf_size
, ss
));
938 /* work-around assert in pa_source_set_latency_within_thead,
939 keep track of min_latency and reuse it when
940 this routine is called from IO context */
941 u
->min_latency_ref
= u
->source
->thread_info
.min_latency
;
944 pa_log_info("Time scheduling watermark is %0.2fms",
945 (double) u
->tsched_watermark_usec
/ PA_USEC_PER_MSEC
);
948 /* Called from IO context */
949 static int unsuspend(struct userdata
*u
) {
953 snd_pcm_uframes_t period_size
, buffer_size
;
956 pa_assert(!u
->pcm_handle
);
958 pa_log_info("Trying resume...");
960 if ((err
= snd_pcm_open(&u
->pcm_handle
, u
->device_name
, SND_PCM_STREAM_CAPTURE
,
962 SND_PCM_NO_AUTO_RESAMPLE
|
963 SND_PCM_NO_AUTO_CHANNELS
|
964 SND_PCM_NO_AUTO_FORMAT
)) < 0) {
965 pa_log("Error opening PCM device %s: %s", u
->device_name
, pa_alsa_strerror(err
));
969 ss
= u
->source
->sample_spec
;
970 period_size
= u
->fragment_size
/ u
->frame_size
;
971 buffer_size
= u
->hwbuf_size
/ u
->frame_size
;
975 if ((err
= pa_alsa_set_hw_params(u
->pcm_handle
, &ss
, &period_size
, &buffer_size
, 0, &b
, &d
, true)) < 0) {
976 pa_log("Failed to set hardware parameters: %s", pa_alsa_strerror(err
));
980 if (b
!= u
->use_mmap
|| d
!= u
->use_tsched
) {
981 pa_log_warn("Resume failed, couldn't get original access mode.");
985 if (!pa_sample_spec_equal(&ss
, &u
->source
->sample_spec
)) {
986 pa_log_warn("Resume failed, couldn't restore original sample settings.");
990 if (period_size
*u
->frame_size
!= u
->fragment_size
||
991 buffer_size
*u
->frame_size
!= u
->hwbuf_size
) {
992 pa_log_warn("Resume failed, couldn't restore original fragment settings. (Old: %lu/%lu, New %lu/%lu)",
993 (unsigned long) u
->hwbuf_size
, (unsigned long) u
->fragment_size
,
994 (unsigned long) (buffer_size
*u
->frame_size
), (unsigned long) (period_size
*u
->frame_size
));
998 if (update_sw_params(u
) < 0)
1001 if (build_pollfd(u
) < 0)
1004 /* FIXME: We need to reload the volume somehow */
1007 pa_smoother_reset(u
->smoother
, pa_rtclock_now(), true);
1008 u
->smoother_interval
= SMOOTHER_MIN_INTERVAL
;
1009 u
->last_smoother_update
= 0;
1013 /* reset the watermark to the value defined when source was created */
1015 reset_watermark(u
, u
->tsched_watermark_ref
, &u
->source
->sample_spec
, true);
1017 pa_log_info("Resumed successfully...");
1022 if (u
->pcm_handle
) {
1023 snd_pcm_close(u
->pcm_handle
);
1024 u
->pcm_handle
= NULL
;
1030 /* Called from IO context */
1031 static int source_process_msg(pa_msgobject
*o
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
1032 struct userdata
*u
= PA_SOURCE(o
)->userdata
;
1036 case PA_SOURCE_MESSAGE_GET_LATENCY
: {
1040 r
= source_get_latency(u
);
1042 *((pa_usec_t
*) data
) = r
;
1047 case PA_SOURCE_MESSAGE_SET_STATE
:
1049 switch ((pa_source_state_t
) PA_PTR_TO_UINT(data
)) {
1051 case PA_SOURCE_SUSPENDED
: {
1054 pa_assert(PA_SOURCE_IS_OPENED(u
->source
->thread_info
.state
));
1056 if ((r
= suspend(u
)) < 0)
1062 case PA_SOURCE_IDLE
:
1063 case PA_SOURCE_RUNNING
: {
1066 if (u
->source
->thread_info
.state
== PA_SOURCE_INIT
) {
1067 if (build_pollfd(u
) < 0)
1071 if (u
->source
->thread_info
.state
== PA_SOURCE_SUSPENDED
) {
1072 if ((r
= unsuspend(u
)) < 0)
1079 case PA_SOURCE_UNLINKED
:
1080 case PA_SOURCE_INIT
:
1081 case PA_SOURCE_INVALID_STATE
:
1088 return pa_source_process_msg(o
, code
, data
, offset
, chunk
);
1091 /* Called from main context */
1092 static int source_set_state_cb(pa_source
*s
, pa_source_state_t new_state
) {
1093 pa_source_state_t old_state
;
1096 pa_source_assert_ref(s
);
1097 pa_assert_se(u
= s
->userdata
);
1099 old_state
= pa_source_get_state(u
->source
);
1101 if (PA_SOURCE_IS_OPENED(old_state
) && new_state
== PA_SOURCE_SUSPENDED
)
1103 else if (old_state
== PA_SOURCE_SUSPENDED
&& PA_SOURCE_IS_OPENED(new_state
))
1104 if (reserve_init(u
, u
->device_name
) < 0)
1105 return -PA_ERR_BUSY
;
1110 static int ctl_mixer_callback(snd_mixer_elem_t
*elem
, unsigned int mask
) {
1111 struct userdata
*u
= snd_mixer_elem_get_callback_private(elem
);
1114 pa_assert(u
->mixer_handle
);
1116 if (mask
== SND_CTL_EVENT_MASK_REMOVE
)
1119 if (!PA_SOURCE_IS_LINKED(u
->source
->state
))
1122 if (u
->source
->suspend_cause
& PA_SUSPEND_SESSION
) {
1123 pa_source_set_mixer_dirty(u
->source
, true);
1127 if (mask
& SND_CTL_EVENT_MASK_VALUE
) {
1128 pa_source_get_volume(u
->source
, true);
1129 pa_source_get_mute(u
->source
, true);
1135 static int io_mixer_callback(snd_mixer_elem_t
*elem
, unsigned int mask
) {
1136 struct userdata
*u
= snd_mixer_elem_get_callback_private(elem
);
1139 pa_assert(u
->mixer_handle
);
1141 if (mask
== SND_CTL_EVENT_MASK_REMOVE
)
1144 if (u
->source
->suspend_cause
& PA_SUSPEND_SESSION
) {
1145 pa_source_set_mixer_dirty(u
->source
, true);
1149 if (mask
& SND_CTL_EVENT_MASK_VALUE
)
1150 pa_source_update_volume_and_mute(u
->source
);
1155 static void source_get_volume_cb(pa_source
*s
) {
1156 struct userdata
*u
= s
->userdata
;
1158 char volume_buf
[PA_CVOLUME_SNPRINT_VERBOSE_MAX
];
1161 pa_assert(u
->mixer_path
);
1162 pa_assert(u
->mixer_handle
);
1164 if (pa_alsa_path_get_volume(u
->mixer_path
, u
->mixer_handle
, &s
->channel_map
, &r
) < 0)
1167 /* Shift down by the base volume, so that 0dB becomes maximum volume */
1168 pa_sw_cvolume_multiply_scalar(&r
, &r
, s
->base_volume
);
1170 pa_log_debug("Read hardware volume: %s",
1171 pa_cvolume_snprint_verbose(volume_buf
, sizeof(volume_buf
), &r
, &s
->channel_map
, u
->mixer_path
->has_dB
));
1173 if (pa_cvolume_equal(&u
->hardware_volume
, &r
))
1176 s
->real_volume
= u
->hardware_volume
= r
;
1178 /* Hmm, so the hardware volume changed, let's reset our software volume */
1179 if (u
->mixer_path
->has_dB
)
1180 pa_source_set_soft_volume(s
, NULL
);
1183 static void source_set_volume_cb(pa_source
*s
) {
1184 struct userdata
*u
= s
->userdata
;
1186 char volume_buf
[PA_CVOLUME_SNPRINT_VERBOSE_MAX
];
1187 bool deferred_volume
= !!(s
->flags
& PA_SOURCE_DEFERRED_VOLUME
);
1190 pa_assert(u
->mixer_path
);
1191 pa_assert(u
->mixer_handle
);
1193 /* Shift up by the base volume */
1194 pa_sw_cvolume_divide_scalar(&r
, &s
->real_volume
, s
->base_volume
);
1196 if (pa_alsa_path_set_volume(u
->mixer_path
, u
->mixer_handle
, &s
->channel_map
, &r
, deferred_volume
, !deferred_volume
) < 0)
1199 /* Shift down by the base volume, so that 0dB becomes maximum volume */
1200 pa_sw_cvolume_multiply_scalar(&r
, &r
, s
->base_volume
);
1202 u
->hardware_volume
= r
;
1204 if (u
->mixer_path
->has_dB
) {
1205 pa_cvolume new_soft_volume
;
1206 bool accurate_enough
;
1208 /* Match exactly what the user requested by software */
1209 pa_sw_cvolume_divide(&new_soft_volume
, &s
->real_volume
, &u
->hardware_volume
);
1211 /* If the adjustment to do in software is only minimal we
1212 * can skip it. That saves us CPU at the expense of a bit of
1215 (pa_cvolume_min(&new_soft_volume
) >= (PA_VOLUME_NORM
- VOLUME_ACCURACY
)) &&
1216 (pa_cvolume_max(&new_soft_volume
) <= (PA_VOLUME_NORM
+ VOLUME_ACCURACY
));
1218 pa_log_debug("Requested volume: %s",
1219 pa_cvolume_snprint_verbose(volume_buf
, sizeof(volume_buf
), &s
->real_volume
, &s
->channel_map
, true));
1220 pa_log_debug("Got hardware volume: %s",
1221 pa_cvolume_snprint_verbose(volume_buf
, sizeof(volume_buf
), &u
->hardware_volume
, &s
->channel_map
, true));
1222 pa_log_debug("Calculated software volume: %s (accurate-enough=%s)",
1223 pa_cvolume_snprint_verbose(volume_buf
, sizeof(volume_buf
), &new_soft_volume
, &s
->channel_map
, true),
1224 pa_yes_no(accurate_enough
));
1226 if (!accurate_enough
)
1227 s
->soft_volume
= new_soft_volume
;
1230 pa_log_debug("Wrote hardware volume: %s",
1231 pa_cvolume_snprint_verbose(volume_buf
, sizeof(volume_buf
), &r
, &s
->channel_map
, false));
1233 /* We can't match exactly what the user requested, hence let's
1234 * at least tell the user about it */
1240 static void source_write_volume_cb(pa_source
*s
) {
1241 struct userdata
*u
= s
->userdata
;
1242 pa_cvolume hw_vol
= s
->thread_info
.current_hw_volume
;
1245 pa_assert(u
->mixer_path
);
1246 pa_assert(u
->mixer_handle
);
1247 pa_assert(s
->flags
& PA_SOURCE_DEFERRED_VOLUME
);
1249 /* Shift up by the base volume */
1250 pa_sw_cvolume_divide_scalar(&hw_vol
, &hw_vol
, s
->base_volume
);
1252 if (pa_alsa_path_set_volume(u
->mixer_path
, u
->mixer_handle
, &s
->channel_map
, &hw_vol
, true, true) < 0)
1253 pa_log_error("Writing HW volume failed");
1256 bool accurate_enough
;
1258 /* Shift down by the base volume, so that 0dB becomes maximum volume */
1259 pa_sw_cvolume_multiply_scalar(&hw_vol
, &hw_vol
, s
->base_volume
);
1261 pa_sw_cvolume_divide(&tmp_vol
, &hw_vol
, &s
->thread_info
.current_hw_volume
);
1263 (pa_cvolume_min(&tmp_vol
) >= (PA_VOLUME_NORM
- VOLUME_ACCURACY
)) &&
1264 (pa_cvolume_max(&tmp_vol
) <= (PA_VOLUME_NORM
+ VOLUME_ACCURACY
));
1266 if (!accurate_enough
) {
1267 char volume_buf
[2][PA_CVOLUME_SNPRINT_VERBOSE_MAX
];
1269 pa_log_debug("Written HW volume did not match with the request: %s (request) != %s",
1270 pa_cvolume_snprint_verbose(volume_buf
[0],
1271 sizeof(volume_buf
[0]),
1272 &s
->thread_info
.current_hw_volume
,
1275 pa_cvolume_snprint_verbose(volume_buf
[1], sizeof(volume_buf
[1]), &hw_vol
, &s
->channel_map
, true));
1280 static void source_get_mute_cb(pa_source
*s
) {
1281 struct userdata
*u
= s
->userdata
;
1285 pa_assert(u
->mixer_path
);
1286 pa_assert(u
->mixer_handle
);
1288 if (pa_alsa_path_get_mute(u
->mixer_path
, u
->mixer_handle
, &b
) < 0)
1294 static void source_set_mute_cb(pa_source
*s
) {
1295 struct userdata
*u
= s
->userdata
;
1298 pa_assert(u
->mixer_path
);
1299 pa_assert(u
->mixer_handle
);
1301 pa_alsa_path_set_mute(u
->mixer_path
, u
->mixer_handle
, s
->muted
);
1304 static void mixer_volume_init(struct userdata
*u
) {
1307 if (!u
->mixer_path
->has_volume
) {
1308 pa_source_set_write_volume_callback(u
->source
, NULL
);
1309 pa_source_set_get_volume_callback(u
->source
, NULL
);
1310 pa_source_set_set_volume_callback(u
->source
, NULL
);
1312 pa_log_info("Driver does not support hardware volume control, falling back to software volume control.");
1314 pa_source_set_get_volume_callback(u
->source
, source_get_volume_cb
);
1315 pa_source_set_set_volume_callback(u
->source
, source_set_volume_cb
);
1317 if (u
->mixer_path
->has_dB
&& u
->deferred_volume
) {
1318 pa_source_set_write_volume_callback(u
->source
, source_write_volume_cb
);
1319 pa_log_info("Successfully enabled deferred volume.");
1321 pa_source_set_write_volume_callback(u
->source
, NULL
);
1323 if (u
->mixer_path
->has_dB
) {
1324 pa_source_enable_decibel_volume(u
->source
, true);
1325 pa_log_info("Hardware volume ranges from %0.2f dB to %0.2f dB.", u
->mixer_path
->min_dB
, u
->mixer_path
->max_dB
);
1327 u
->source
->base_volume
= pa_sw_volume_from_dB(-u
->mixer_path
->max_dB
);
1328 u
->source
->n_volume_steps
= PA_VOLUME_NORM
+1;
1330 pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(u
->source
->base_volume
));
1332 pa_source_enable_decibel_volume(u
->source
, false);
1333 pa_log_info("Hardware volume ranges from %li to %li.", u
->mixer_path
->min_volume
, u
->mixer_path
->max_volume
);
1335 u
->source
->base_volume
= PA_VOLUME_NORM
;
1336 u
->source
->n_volume_steps
= u
->mixer_path
->max_volume
- u
->mixer_path
->min_volume
+ 1;
1339 pa_log_info("Using hardware volume control. Hardware dB scale %s.", u
->mixer_path
->has_dB
? "supported" : "not supported");
1342 if (!u
->mixer_path
->has_mute
) {
1343 pa_source_set_get_mute_callback(u
->source
, NULL
);
1344 pa_source_set_set_mute_callback(u
->source
, NULL
);
1345 pa_log_info("Driver does not support hardware mute control, falling back to software mute control.");
1347 pa_source_set_get_mute_callback(u
->source
, source_get_mute_cb
);
1348 pa_source_set_set_mute_callback(u
->source
, source_set_mute_cb
);
1349 pa_log_info("Using hardware mute control.");
1353 static int source_set_port_ucm_cb(pa_source
*s
, pa_device_port
*p
) {
1354 struct userdata
*u
= s
->userdata
;
1358 pa_assert(u
->ucm_context
);
1360 return pa_alsa_ucm_set_port(u
->ucm_context
, p
, false);
1363 static int source_set_port_cb(pa_source
*s
, pa_device_port
*p
) {
1364 struct userdata
*u
= s
->userdata
;
1365 pa_alsa_port_data
*data
;
1369 pa_assert(u
->mixer_handle
);
1371 data
= PA_DEVICE_PORT_DATA(p
);
1373 pa_assert_se(u
->mixer_path
= data
->path
);
1374 pa_alsa_path_select(u
->mixer_path
, data
->setting
, u
->mixer_handle
, s
->muted
);
1376 mixer_volume_init(u
);
1380 if (s
->flags
& PA_SOURCE_DEFERRED_VOLUME
) {
1381 if (s
->write_volume
)
1391 static void source_update_requested_latency_cb(pa_source
*s
) {
1392 struct userdata
*u
= s
->userdata
;
1394 pa_assert(u
->use_tsched
); /* only when timer scheduling is used
1395 * we can dynamically adjust the
1401 update_sw_params(u
);
1404 static int source_update_rate_cb(pa_source
*s
, uint32_t rate
) {
1405 struct userdata
*u
= s
->userdata
;
1407 bool supported
= false;
1411 for (i
= 0; u
->rates
[i
]; i
++) {
1412 if (u
->rates
[i
] == rate
) {
1419 pa_log_info("Source does not support sample rate of %d Hz", rate
);
1423 if (!PA_SOURCE_IS_OPENED(s
->state
)) {
1424 pa_log_info("Updating rate for device %s, new rate is %d", u
->device_name
, rate
);
1425 u
->source
->sample_spec
.rate
= rate
;
1432 static void thread_func(void *userdata
) {
1433 struct userdata
*u
= userdata
;
1434 unsigned short revents
= 0;
1438 pa_log_debug("Thread starting up");
1440 if (u
->core
->realtime_scheduling
)
1441 pa_make_realtime(u
->core
->realtime_priority
);
1443 pa_thread_mq_install(&u
->thread_mq
);
1447 pa_usec_t rtpoll_sleep
= 0, real_sleep
;
1450 pa_log_debug("Loop");
1453 /* Read some data and pass it to the sources */
1454 if (PA_SOURCE_IS_OPENED(u
->source
->thread_info
.state
)) {
1456 pa_usec_t sleep_usec
= 0;
1457 bool on_timeout
= pa_rtpoll_timer_elapsed(u
->rtpoll
);
1460 pa_log_info("Starting capture.");
1461 snd_pcm_start(u
->pcm_handle
);
1463 pa_smoother_resume(u
->smoother
, pa_rtclock_now(), true);
1469 work_done
= mmap_read(u
, &sleep_usec
, revents
& POLLIN
, on_timeout
);
1471 work_done
= unix_read(u
, &sleep_usec
, revents
& POLLIN
, on_timeout
);
1476 /* pa_log_debug("work_done = %i", work_done); */
1481 if (u
->use_tsched
) {
1484 /* OK, the capture buffer is now empty, let's
1485 * calculate when to wake up next */
1487 /* pa_log_debug("Waking up in %0.2fms (sound card clock).", (double) sleep_usec / PA_USEC_PER_MSEC); */
1489 /* Convert from the sound card time domain to the
1490 * system time domain */
1491 cusec
= pa_smoother_translate(u
->smoother
, pa_rtclock_now(), sleep_usec
);
1493 /* pa_log_debug("Waking up in %0.2fms (system clock).", (double) cusec / PA_USEC_PER_MSEC); */
1495 /* We don't trust the conversion, so we wake up whatever comes first */
1496 rtpoll_sleep
= PA_MIN(sleep_usec
, cusec
);
1500 if (u
->source
->flags
& PA_SOURCE_DEFERRED_VOLUME
) {
1501 pa_usec_t volume_sleep
;
1502 pa_source_volume_change_apply(u
->source
, &volume_sleep
);
1503 if (volume_sleep
> 0) {
1504 if (rtpoll_sleep
> 0)
1505 rtpoll_sleep
= PA_MIN(volume_sleep
, rtpoll_sleep
);
1507 rtpoll_sleep
= volume_sleep
;
1511 if (rtpoll_sleep
> 0) {
1512 pa_rtpoll_set_timer_relative(u
->rtpoll
, rtpoll_sleep
);
1513 real_sleep
= pa_rtclock_now();
1516 pa_rtpoll_set_timer_disabled(u
->rtpoll
);
1518 /* Hmm, nothing to do. Let's sleep */
1519 if ((ret
= pa_rtpoll_run(u
->rtpoll
, true)) < 0)
1522 if (rtpoll_sleep
> 0) {
1523 real_sleep
= pa_rtclock_now() - real_sleep
;
1525 pa_log_debug("Expected sleep: %0.2fms, real sleep: %0.2fms (diff %0.2f ms)",
1526 (double) rtpoll_sleep
/ PA_USEC_PER_MSEC
, (double) real_sleep
/ PA_USEC_PER_MSEC
,
1527 (double) ((int64_t) real_sleep
- (int64_t) rtpoll_sleep
) / PA_USEC_PER_MSEC
);
1529 if (u
->use_tsched
&& real_sleep
> rtpoll_sleep
+ u
->tsched_watermark_usec
)
1530 pa_log_info("Scheduling delay of %0.2f ms > %0.2f ms, you might want to investigate this to improve latency...",
1531 (double) (real_sleep
- rtpoll_sleep
) / PA_USEC_PER_MSEC
,
1532 (double) (u
->tsched_watermark_usec
) / PA_USEC_PER_MSEC
);
1535 if (u
->source
->flags
& PA_SOURCE_DEFERRED_VOLUME
)
1536 pa_source_volume_change_apply(u
->source
, NULL
);
1541 /* Tell ALSA about this and process its response */
1542 if (PA_SOURCE_IS_OPENED(u
->source
->thread_info
.state
)) {
1543 struct pollfd
*pollfd
;
1547 pollfd
= pa_rtpoll_item_get_pollfd(u
->alsa_rtpoll_item
, &n
);
1549 if ((err
= snd_pcm_poll_descriptors_revents(u
->pcm_handle
, pollfd
, n
, &revents
)) < 0) {
1550 pa_log("snd_pcm_poll_descriptors_revents() failed: %s", pa_alsa_strerror(err
));
1554 if (revents
& ~POLLIN
) {
1555 if (pa_alsa_recover_from_poll(u
->pcm_handle
, revents
) < 0)
1560 } else if (revents
&& u
->use_tsched
&& pa_log_ratelimit(PA_LOG_DEBUG
))
1561 pa_log_debug("Wakeup from ALSA!");
1568 /* If this was no regular exit from the loop we have to continue
1569 * processing messages until we received PA_MESSAGE_SHUTDOWN */
1570 pa_asyncmsgq_post(u
->thread_mq
.outq
, PA_MSGOBJECT(u
->core
), PA_CORE_MESSAGE_UNLOAD_MODULE
, u
->module
, 0, NULL
, NULL
);
1571 pa_asyncmsgq_wait_for(u
->thread_mq
.inq
, PA_MESSAGE_SHUTDOWN
);
1574 pa_log_debug("Thread shutting down");
1577 static void set_source_name(pa_source_new_data
*data
, pa_modargs
*ma
, const char *device_id
, const char *device_name
, pa_alsa_mapping
*mapping
) {
1583 pa_assert(device_name
);
1585 if ((n
= pa_modargs_get_value(ma
, "source_name", NULL
))) {
1586 pa_source_new_data_set_name(data
, n
);
1587 data
->namereg_fail
= true;
1591 if ((n
= pa_modargs_get_value(ma
, "name", NULL
)))
1592 data
->namereg_fail
= true;
1594 n
= device_id
? device_id
: device_name
;
1595 data
->namereg_fail
= false;
1599 t
= pa_sprintf_malloc("alsa_input.%s.%s", n
, mapping
->name
);
1601 t
= pa_sprintf_malloc("alsa_input.%s", n
);
1603 pa_source_new_data_set_name(data
, t
);
1607 static void find_mixer(struct userdata
*u
, pa_alsa_mapping
*mapping
, const char *element
, bool ignore_dB
) {
1610 if (!mapping
&& !element
)
1613 if (!(u
->mixer_handle
= pa_alsa_open_mixer_for_pcm(u
->pcm_handle
, &u
->control_device
, &hctl
))) {
1614 pa_log_info("Failed to find a working mixer device.");
1620 if (!(u
->mixer_path
= pa_alsa_path_synthesize(element
, PA_ALSA_DIRECTION_INPUT
)))
1623 if (pa_alsa_path_probe(u
->mixer_path
, u
->mixer_handle
, hctl
, ignore_dB
) < 0)
1626 pa_log_debug("Probed mixer path %s:", u
->mixer_path
->name
);
1627 pa_alsa_path_dump(u
->mixer_path
);
1628 } else if (!(u
->mixer_path_set
= mapping
->input_path_set
))
1635 if (u
->mixer_path
) {
1636 pa_alsa_path_free(u
->mixer_path
);
1637 u
->mixer_path
= NULL
;
1640 if (u
->mixer_handle
) {
1641 snd_mixer_close(u
->mixer_handle
);
1642 u
->mixer_handle
= NULL
;
1646 static int setup_mixer(struct userdata
*u
, bool ignore_dB
) {
1647 bool need_mixer_callback
= false;
1651 if (!u
->mixer_handle
)
1654 if (u
->source
->active_port
) {
1655 pa_alsa_port_data
*data
;
1657 /* We have a list of supported paths, so let's activate the
1658 * one that has been chosen as active */
1660 data
= PA_DEVICE_PORT_DATA(u
->source
->active_port
);
1661 u
->mixer_path
= data
->path
;
1663 pa_alsa_path_select(data
->path
, data
->setting
, u
->mixer_handle
, u
->source
->muted
);
1667 if (!u
->mixer_path
&& u
->mixer_path_set
)
1668 u
->mixer_path
= pa_hashmap_first(u
->mixer_path_set
->paths
);
1670 if (u
->mixer_path
) {
1671 /* Hmm, we have only a single path, then let's activate it */
1673 pa_alsa_path_select(u
->mixer_path
, u
->mixer_path
->settings
, u
->mixer_handle
, u
->source
->muted
);
1678 mixer_volume_init(u
);
1680 /* Will we need to register callbacks? */
1681 if (u
->mixer_path_set
&& u
->mixer_path_set
->paths
) {
1685 PA_HASHMAP_FOREACH(p
, u
->mixer_path_set
->paths
, state
) {
1686 if (p
->has_volume
|| p
->has_mute
)
1687 need_mixer_callback
= true;
1690 else if (u
->mixer_path
)
1691 need_mixer_callback
= u
->mixer_path
->has_volume
|| u
->mixer_path
->has_mute
;
1693 if (need_mixer_callback
) {
1694 int (*mixer_callback
)(snd_mixer_elem_t
*, unsigned int);
1695 if (u
->source
->flags
& PA_SOURCE_DEFERRED_VOLUME
) {
1696 u
->mixer_pd
= pa_alsa_mixer_pdata_new();
1697 mixer_callback
= io_mixer_callback
;
1699 if (pa_alsa_set_mixer_rtpoll(u
->mixer_pd
, u
->mixer_handle
, u
->rtpoll
) < 0) {
1700 pa_log("Failed to initialize file descriptor monitoring");
1704 u
->mixer_fdl
= pa_alsa_fdlist_new();
1705 mixer_callback
= ctl_mixer_callback
;
1707 if (pa_alsa_fdlist_set_handle(u
->mixer_fdl
, u
->mixer_handle
, NULL
, u
->core
->mainloop
) < 0) {
1708 pa_log("Failed to initialize file descriptor monitoring");
1713 if (u
->mixer_path_set
)
1714 pa_alsa_path_set_set_callback(u
->mixer_path_set
, u
->mixer_handle
, mixer_callback
, u
);
1716 pa_alsa_path_set_callback(u
->mixer_path
, u
->mixer_handle
, mixer_callback
, u
);
1722 pa_source
*pa_alsa_source_new(pa_module
*m
, pa_modargs
*ma
, const char*driver
, pa_card
*card
, pa_alsa_mapping
*mapping
) {
1724 struct userdata
*u
= NULL
;
1725 const char *dev_id
= NULL
, *key
, *mod_name
;
1727 char *thread_name
= NULL
;
1728 uint32_t alternate_sample_rate
;
1730 uint32_t nfrags
, frag_size
, buffer_size
, tsched_size
, tsched_watermark
;
1731 snd_pcm_uframes_t period_frames
, buffer_frames
, tsched_frames
;
1733 bool use_mmap
= true, b
, use_tsched
= true, d
, ignore_dB
= false, namereg_fail
= false, deferred_volume
= false, fixed_latency_range
= false;
1734 pa_source_new_data data
;
1735 pa_alsa_profile_set
*profile_set
= NULL
;
1741 ss
= m
->core
->default_sample_spec
;
1742 map
= m
->core
->default_channel_map
;
1744 /* Pick sample spec overrides from the mapping, if any */
1745 if (mapping
->sample_spec
.format
!= PA_SAMPLE_INVALID
)
1746 ss
.format
= mapping
->sample_spec
.format
;
1747 if (mapping
->sample_spec
.rate
!= 0)
1748 ss
.rate
= mapping
->sample_spec
.rate
;
1749 if (mapping
->sample_spec
.channels
!= 0) {
1750 ss
.channels
= mapping
->sample_spec
.channels
;
1751 if (pa_channel_map_valid(&mapping
->channel_map
))
1752 pa_assert(pa_channel_map_compatible(&mapping
->channel_map
, &ss
));
1755 /* Override with modargs if provided */
1756 if (pa_modargs_get_sample_spec_and_channel_map(ma
, &ss
, &map
, PA_CHANNEL_MAP_ALSA
) < 0) {
1757 pa_log("Failed to parse sample specification and channel map");
1761 alternate_sample_rate
= m
->core
->alternate_sample_rate
;
1762 if (pa_modargs_get_alternate_sample_rate(ma
, &alternate_sample_rate
) < 0) {
1763 pa_log("Failed to parse alternate sample rate");
1767 frame_size
= pa_frame_size(&ss
);
1769 nfrags
= m
->core
->default_n_fragments
;
1770 frag_size
= (uint32_t) pa_usec_to_bytes(m
->core
->default_fragment_size_msec
*PA_USEC_PER_MSEC
, &ss
);
1772 frag_size
= (uint32_t) frame_size
;
1773 tsched_size
= (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_BUFFER_USEC
, &ss
);
1774 tsched_watermark
= (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_WATERMARK_USEC
, &ss
);
1776 if (pa_modargs_get_value_u32(ma
, "fragments", &nfrags
) < 0 ||
1777 pa_modargs_get_value_u32(ma
, "fragment_size", &frag_size
) < 0 ||
1778 pa_modargs_get_value_u32(ma
, "tsched_buffer_size", &tsched_size
) < 0 ||
1779 pa_modargs_get_value_u32(ma
, "tsched_buffer_watermark", &tsched_watermark
) < 0) {
1780 pa_log("Failed to parse buffer metrics");
1784 buffer_size
= nfrags
* frag_size
;
1786 period_frames
= frag_size
/frame_size
;
1787 buffer_frames
= buffer_size
/frame_size
;
1788 tsched_frames
= tsched_size
/frame_size
;
1790 if (pa_modargs_get_value_boolean(ma
, "mmap", &use_mmap
) < 0) {
1791 pa_log("Failed to parse mmap argument.");
1795 if (pa_modargs_get_value_boolean(ma
, "tsched", &use_tsched
) < 0) {
1796 pa_log("Failed to parse tsched argument.");
1800 if (pa_modargs_get_value_boolean(ma
, "ignore_dB", &ignore_dB
) < 0) {
1801 pa_log("Failed to parse ignore_dB argument.");
1805 deferred_volume
= m
->core
->deferred_volume
;
1806 if (pa_modargs_get_value_boolean(ma
, "deferred_volume", &deferred_volume
) < 0) {
1807 pa_log("Failed to parse deferred_volume argument.");
1811 if (pa_modargs_get_value_boolean(ma
, "fixed_latency_range", &fixed_latency_range
) < 0) {
1812 pa_log("Failed to parse fixed_latency_range argument.");
1816 use_tsched
= pa_alsa_may_tsched(use_tsched
);
1818 u
= pa_xnew0(struct userdata
, 1);
1821 u
->use_mmap
= use_mmap
;
1822 u
->use_tsched
= use_tsched
;
1823 u
->deferred_volume
= deferred_volume
;
1824 u
->fixed_latency_range
= fixed_latency_range
;
1826 u
->rtpoll
= pa_rtpoll_new();
1827 pa_thread_mq_init(&u
->thread_mq
, m
->core
->mainloop
, u
->rtpoll
);
1829 u
->smoother
= pa_smoother_new(
1830 SMOOTHER_ADJUST_USEC
,
1831 SMOOTHER_WINDOW_USEC
,
1837 u
->smoother_interval
= SMOOTHER_MIN_INTERVAL
;
1840 if (mapping
&& mapping
->ucm_context
.ucm
)
1841 u
->ucm_context
= &mapping
->ucm_context
;
1843 dev_id
= pa_modargs_get_value(
1845 pa_modargs_get_value(ma
, "device", DEFAULT_DEVICE
));
1847 u
->paths_dir
= pa_xstrdup(pa_modargs_get_value(ma
, "paths_dir", NULL
));
1849 if (reserve_init(u
, dev_id
) < 0)
1852 if (reserve_monitor_init(u
, dev_id
) < 0)
1860 if (!(dev_id
= pa_modargs_get_value(ma
, "device_id", NULL
))) {
1861 pa_log("device_id= not set");
1865 if ((mod_name
= pa_proplist_gets(mapping
->proplist
, PA_ALSA_PROP_UCM_MODIFIER
))) {
1866 if (snd_use_case_set(u
->ucm_context
->ucm
->ucm_mgr
, "_enamod", mod_name
) < 0)
1867 pa_log("Failed to enable ucm modifier %s", mod_name
);
1869 pa_log_debug("Enabled ucm modifier %s", mod_name
);
1872 if (!(u
->pcm_handle
= pa_alsa_open_by_device_id_mapping(
1876 SND_PCM_STREAM_CAPTURE
,
1877 &period_frames
, &buffer_frames
, tsched_frames
,
1881 } else if ((dev_id
= pa_modargs_get_value(ma
, "device_id", NULL
))) {
1883 if (!(profile_set
= pa_alsa_profile_set_new(NULL
, &map
)))
1886 if (!(u
->pcm_handle
= pa_alsa_open_by_device_id_auto(
1890 SND_PCM_STREAM_CAPTURE
,
1891 &period_frames
, &buffer_frames
, tsched_frames
,
1892 &b
, &d
, profile_set
, &mapping
)))
1897 if (!(u
->pcm_handle
= pa_alsa_open_by_device_string(
1898 pa_modargs_get_value(ma
, "device", DEFAULT_DEVICE
),
1901 SND_PCM_STREAM_CAPTURE
,
1902 &period_frames
, &buffer_frames
, tsched_frames
,
1907 pa_assert(u
->device_name
);
1908 pa_log_info("Successfully opened device %s.", u
->device_name
);
1910 if (pa_alsa_pcm_is_modem(u
->pcm_handle
)) {
1911 pa_log_notice("Device %s is modem, refusing further initialization.", u
->device_name
);
1916 pa_log_info("Selected mapping '%s' (%s).", mapping
->description
, mapping
->name
);
1918 if (use_mmap
&& !b
) {
1919 pa_log_info("Device doesn't support mmap(), falling back to UNIX read/write mode.");
1920 u
->use_mmap
= use_mmap
= false;
1923 if (use_tsched
&& (!b
|| !d
)) {
1924 pa_log_info("Cannot enable timer-based scheduling, falling back to sound IRQ scheduling.");
1925 u
->use_tsched
= use_tsched
= false;
1929 pa_log_info("Successfully enabled mmap() mode.");
1931 if (u
->use_tsched
) {
1932 pa_log_info("Successfully enabled timer-based scheduling mode.");
1933 if (u
->fixed_latency_range
)
1934 pa_log_info("Disabling latency range changes on overrun");
1937 u
->rates
= pa_alsa_get_supported_rates(u
->pcm_handle
, ss
.rate
);
1939 pa_log_error("Failed to find any supported sample rates.");
1943 /* ALSA might tweak the sample spec, so recalculate the frame size */
1944 frame_size
= pa_frame_size(&ss
);
1946 if (!u
->ucm_context
)
1947 find_mixer(u
, mapping
, pa_modargs_get_value(ma
, "control", NULL
), ignore_dB
);
1949 pa_source_new_data_init(&data
);
1950 data
.driver
= driver
;
1953 set_source_name(&data
, ma
, dev_id
, u
->device_name
, mapping
);
1955 /* We need to give pa_modargs_get_value_boolean() a pointer to a local
1956 * variable instead of using &data.namereg_fail directly, because
1957 * data.namereg_fail is a bitfield and taking the address of a bitfield
1958 * variable is impossible. */
1959 namereg_fail
= data
.namereg_fail
;
1960 if (pa_modargs_get_value_boolean(ma
, "namereg_fail", &namereg_fail
) < 0) {
1961 pa_log("Failed to parse namereg_fail argument.");
1962 pa_source_new_data_done(&data
);
1965 data
.namereg_fail
= namereg_fail
;
1967 pa_source_new_data_set_sample_spec(&data
, &ss
);
1968 pa_source_new_data_set_channel_map(&data
, &map
);
1969 pa_source_new_data_set_alternate_sample_rate(&data
, alternate_sample_rate
);
1971 pa_alsa_init_proplist_pcm(m
->core
, data
.proplist
, u
->pcm_handle
);
1972 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_STRING
, u
->device_name
);
1973 pa_proplist_setf(data
.proplist
, PA_PROP_DEVICE_BUFFERING_BUFFER_SIZE
, "%lu", (unsigned long) (buffer_frames
* frame_size
));
1974 pa_proplist_setf(data
.proplist
, PA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZE
, "%lu", (unsigned long) (period_frames
* frame_size
));
1975 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_ACCESS_MODE
, u
->use_tsched
? "mmap+timer" : (u
->use_mmap
? "mmap" : "serial"));
1978 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_PROFILE_NAME
, mapping
->name
);
1979 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_PROFILE_DESCRIPTION
, mapping
->description
);
1981 while ((key
= pa_proplist_iterate(mapping
->proplist
, &state
)))
1982 pa_proplist_sets(data
.proplist
, key
, pa_proplist_gets(mapping
->proplist
, key
));
1985 pa_alsa_init_description(data
.proplist
);
1987 if (u
->control_device
)
1988 pa_alsa_init_proplist_ctl(data
.proplist
, u
->control_device
);
1990 if (pa_modargs_get_proplist(ma
, "source_properties", data
.proplist
, PA_UPDATE_REPLACE
) < 0) {
1991 pa_log("Invalid properties");
1992 pa_source_new_data_done(&data
);
1997 pa_alsa_ucm_add_ports(&data
.ports
, data
.proplist
, u
->ucm_context
, false, card
);
1998 else if (u
->mixer_path_set
)
1999 pa_alsa_add_ports(&data
, u
->mixer_path_set
, card
);
2001 u
->source
= pa_source_new(m
->core
, &data
, PA_SOURCE_HARDWARE
|PA_SOURCE_LATENCY
|(u
->use_tsched
? PA_SOURCE_DYNAMIC_LATENCY
: 0));
2002 pa_source_new_data_done(&data
);
2005 pa_log("Failed to create source object");
2009 if (pa_modargs_get_value_u32(ma
, "deferred_volume_safety_margin",
2010 &u
->source
->thread_info
.volume_change_safety_margin
) < 0) {
2011 pa_log("Failed to parse deferred_volume_safety_margin parameter");
2015 if (pa_modargs_get_value_s32(ma
, "deferred_volume_extra_delay",
2016 &u
->source
->thread_info
.volume_change_extra_delay
) < 0) {
2017 pa_log("Failed to parse deferred_volume_extra_delay parameter");
2021 u
->source
->parent
.process_msg
= source_process_msg
;
2023 u
->source
->update_requested_latency
= source_update_requested_latency_cb
;
2024 u
->source
->set_state
= source_set_state_cb
;
2026 u
->source
->set_port
= source_set_port_ucm_cb
;
2028 u
->source
->set_port
= source_set_port_cb
;
2029 if (u
->source
->alternate_sample_rate
)
2030 u
->source
->update_rate
= source_update_rate_cb
;
2031 u
->source
->userdata
= u
;
2033 pa_source_set_asyncmsgq(u
->source
, u
->thread_mq
.inq
);
2034 pa_source_set_rtpoll(u
->source
, u
->rtpoll
);
2036 u
->frame_size
= frame_size
;
2037 u
->fragment_size
= frag_size
= (size_t) (period_frames
* frame_size
);
2038 u
->hwbuf_size
= buffer_size
= (size_t) (buffer_frames
* frame_size
);
2039 pa_cvolume_mute(&u
->hardware_volume
, u
->source
->sample_spec
.channels
);
2041 pa_log_info("Using %0.1f fragments of size %lu bytes (%0.2fms), buffer size is %lu bytes (%0.2fms)",
2042 (double) u
->hwbuf_size
/ (double) u
->fragment_size
,
2043 (long unsigned) u
->fragment_size
,
2044 (double) pa_bytes_to_usec(u
->fragment_size
, &ss
) / PA_USEC_PER_MSEC
,
2045 (long unsigned) u
->hwbuf_size
,
2046 (double) pa_bytes_to_usec(u
->hwbuf_size
, &ss
) / PA_USEC_PER_MSEC
);
2048 if (u
->use_tsched
) {
2049 u
->tsched_watermark_ref
= tsched_watermark
;
2050 reset_watermark(u
, u
->tsched_watermark_ref
, &ss
, false);
2053 pa_source_set_fixed_latency(u
->source
, pa_bytes_to_usec(u
->hwbuf_size
, &ss
));
2057 if (update_sw_params(u
) < 0)
2060 if (u
->ucm_context
) {
2061 if (u
->source
->active_port
&& pa_alsa_ucm_set_port(u
->ucm_context
, u
->source
->active_port
, false) < 0)
2063 } else if (setup_mixer(u
, ignore_dB
) < 0)
2066 pa_alsa_dump(PA_LOG_DEBUG
, u
->pcm_handle
);
2068 thread_name
= pa_sprintf_malloc("alsa-source-%s", pa_strnull(pa_proplist_gets(u
->source
->proplist
, "alsa.id")));
2069 if (!(u
->thread
= pa_thread_new(thread_name
, thread_func
, u
))) {
2070 pa_log("Failed to create thread.");
2073 pa_xfree(thread_name
);
2076 /* Get initial mixer settings */
2077 if (data
.volume_is_set
) {
2078 if (u
->source
->set_volume
)
2079 u
->source
->set_volume(u
->source
);
2081 if (u
->source
->get_volume
)
2082 u
->source
->get_volume(u
->source
);
2085 if (data
.muted_is_set
) {
2086 if (u
->source
->set_mute
)
2087 u
->source
->set_mute(u
->source
);
2089 if (u
->source
->get_mute
)
2090 u
->source
->get_mute(u
->source
);
2093 if ((data
.volume_is_set
|| data
.muted_is_set
) && u
->source
->write_volume
)
2094 u
->source
->write_volume(u
->source
);
2096 pa_source_put(u
->source
);
2099 pa_alsa_profile_set_free(profile_set
);
2104 pa_xfree(thread_name
);
2110 pa_alsa_profile_set_free(profile_set
);
2115 static void userdata_free(struct userdata
*u
) {
2119 pa_source_unlink(u
->source
);
2122 pa_asyncmsgq_send(u
->thread_mq
.inq
, NULL
, PA_MESSAGE_SHUTDOWN
, NULL
, 0, NULL
);
2123 pa_thread_free(u
->thread
);
2126 pa_thread_mq_done(&u
->thread_mq
);
2129 pa_source_unref(u
->source
);
2132 pa_alsa_mixer_pdata_free(u
->mixer_pd
);
2134 if (u
->alsa_rtpoll_item
)
2135 pa_rtpoll_item_free(u
->alsa_rtpoll_item
);
2138 pa_rtpoll_free(u
->rtpoll
);
2140 if (u
->pcm_handle
) {
2141 snd_pcm_drop(u
->pcm_handle
);
2142 snd_pcm_close(u
->pcm_handle
);
2146 pa_alsa_fdlist_free(u
->mixer_fdl
);
2148 if (u
->mixer_path
&& !u
->mixer_path_set
)
2149 pa_alsa_path_free(u
->mixer_path
);
2151 if (u
->mixer_handle
)
2152 snd_mixer_close(u
->mixer_handle
);
2155 pa_smoother_free(u
->smoother
);
2163 pa_xfree(u
->device_name
);
2164 pa_xfree(u
->control_device
);
2165 pa_xfree(u
->paths_dir
);
2169 void pa_alsa_source_free(pa_source
*s
) {
2172 pa_source_assert_ref(s
);
2173 pa_assert_se(u
= s
->userdata
);