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 #include <pulse/i18n.h>
32 #include <pulse/rtclock.h>
33 #include <pulse/timeval.h>
34 #include <pulse/util.h>
35 #include <pulse/xmalloc.h>
37 #include <pulsecore/core-error.h>
38 #include <pulsecore/core.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/core-error.h>
50 #include <pulsecore/thread-mq.h>
51 #include <pulsecore/rtpoll.h>
52 #include <pulsecore/time-smoother.h>
54 #include <modules/reserve-wrap.h>
56 #include "alsa-util.h"
57 #include "alsa-source.h"
59 /* #define DEBUG_TIMING */
61 #define DEFAULT_DEVICE "default"
63 #define DEFAULT_TSCHED_BUFFER_USEC (2*PA_USEC_PER_SEC) /* 2s */
64 #define DEFAULT_TSCHED_WATERMARK_USEC (20*PA_USEC_PER_MSEC) /* 20ms */
66 #define TSCHED_WATERMARK_INC_STEP_USEC (10*PA_USEC_PER_MSEC) /* 10ms */
67 #define TSCHED_WATERMARK_DEC_STEP_USEC (5*PA_USEC_PER_MSEC) /* 5ms */
68 #define TSCHED_WATERMARK_VERIFY_AFTER_USEC (20*PA_USEC_PER_SEC) /* 20s */
69 #define TSCHED_WATERMARK_INC_THRESHOLD_USEC (0*PA_USEC_PER_MSEC) /* 0ms */
70 #define TSCHED_WATERMARK_DEC_THRESHOLD_USEC (100*PA_USEC_PER_MSEC) /* 100ms */
71 #define TSCHED_WATERMARK_STEP_USEC (10*PA_USEC_PER_MSEC) /* 10ms */
73 #define TSCHED_MIN_SLEEP_USEC (10*PA_USEC_PER_MSEC) /* 10ms */
74 #define TSCHED_MIN_WAKEUP_USEC (4*PA_USEC_PER_MSEC) /* 4ms */
76 #define SMOOTHER_WINDOW_USEC (10*PA_USEC_PER_SEC) /* 10s */
77 #define SMOOTHER_ADJUST_USEC (1*PA_USEC_PER_SEC) /* 1s */
79 #define SMOOTHER_MIN_INTERVAL (2*PA_USEC_PER_MSEC) /* 2ms */
80 #define SMOOTHER_MAX_INTERVAL (200*PA_USEC_PER_MSEC) /* 200ms */
82 #define VOLUME_ACCURACY (PA_VOLUME_NORM/100)
90 pa_thread_mq thread_mq
;
93 snd_pcm_t
*pcm_handle
;
95 pa_alsa_fdlist
*mixer_fdl
;
96 snd_mixer_t
*mixer_handle
;
97 pa_alsa_path_set
*mixer_path_set
;
98 pa_alsa_path
*mixer_path
;
100 pa_cvolume hardware_volume
;
112 watermark_inc_threshold
,
113 watermark_dec_threshold
;
115 pa_usec_t watermark_dec_not_before
;
118 char *control_device
;
120 pa_bool_t use_mmap
:1, use_tsched
:1;
124 pa_rtpoll_item
*alsa_rtpoll_item
;
126 snd_mixer_selem_channel_id_t mixer_map
[SND_MIXER_SCHN_LAST
];
128 pa_smoother
*smoother
;
130 pa_usec_t smoother_interval
;
131 pa_usec_t last_smoother_update
;
133 pa_reserve_wrapper
*reserve
;
134 pa_hook_slot
*reserve_slot
;
135 pa_reserve_monitor_wrapper
*monitor
;
136 pa_hook_slot
*monitor_slot
;
139 static void userdata_free(struct userdata
*u
);
141 static pa_hook_result_t
reserve_cb(pa_reserve_wrapper
*r
, void *forced
, struct userdata
*u
) {
145 if (pa_source_suspend(u
->source
, TRUE
, PA_SUSPEND_APPLICATION
) < 0)
146 return PA_HOOK_CANCEL
;
151 static void reserve_done(struct userdata
*u
) {
154 if (u
->reserve_slot
) {
155 pa_hook_slot_free(u
->reserve_slot
);
156 u
->reserve_slot
= NULL
;
160 pa_reserve_wrapper_unref(u
->reserve
);
165 static void reserve_update(struct userdata
*u
) {
166 const char *description
;
169 if (!u
->source
|| !u
->reserve
)
172 if ((description
= pa_proplist_gets(u
->source
->proplist
, PA_PROP_DEVICE_DESCRIPTION
)))
173 pa_reserve_wrapper_set_application_device_name(u
->reserve
, description
);
176 static int reserve_init(struct userdata
*u
, const char *dname
) {
185 if (pa_in_system_mode())
188 /* We are resuming, try to lock the device */
189 if (!(rname
= pa_alsa_get_reserve_name(dname
)))
192 u
->reserve
= pa_reserve_wrapper_get(u
->core
, rname
);
200 pa_assert(!u
->reserve_slot
);
201 u
->reserve_slot
= pa_hook_connect(pa_reserve_wrapper_hook(u
->reserve
), PA_HOOK_NORMAL
, (pa_hook_cb_t
) reserve_cb
, u
);
206 static pa_hook_result_t
monitor_cb(pa_reserve_monitor_wrapper
*w
, void* busy
, struct userdata
*u
) {
212 b
= PA_PTR_TO_UINT(busy
) && !u
->reserve
;
214 pa_source_suspend(u
->source
, b
, PA_SUSPEND_APPLICATION
);
218 static void monitor_done(struct userdata
*u
) {
221 if (u
->monitor_slot
) {
222 pa_hook_slot_free(u
->monitor_slot
);
223 u
->monitor_slot
= NULL
;
227 pa_reserve_monitor_wrapper_unref(u
->monitor
);
232 static int reserve_monitor_init(struct userdata
*u
, const char *dname
) {
238 if (pa_in_system_mode())
241 /* We are resuming, try to lock the device */
242 if (!(rname
= pa_alsa_get_reserve_name(dname
)))
245 u
->monitor
= pa_reserve_monitor_wrapper_get(u
->core
, rname
);
251 pa_assert(!u
->monitor_slot
);
252 u
->monitor_slot
= pa_hook_connect(pa_reserve_monitor_wrapper_hook(u
->monitor
), PA_HOOK_NORMAL
, (pa_hook_cb_t
) monitor_cb
, u
);
257 static void fix_min_sleep_wakeup(struct userdata
*u
) {
258 size_t max_use
, max_use_2
;
260 pa_assert(u
->use_tsched
);
262 max_use
= u
->hwbuf_size
- u
->hwbuf_unused
;
263 max_use_2
= pa_frame_align(max_use
/2, &u
->source
->sample_spec
);
265 u
->min_sleep
= pa_usec_to_bytes(TSCHED_MIN_SLEEP_USEC
, &u
->source
->sample_spec
);
266 u
->min_sleep
= PA_CLAMP(u
->min_sleep
, u
->frame_size
, max_use_2
);
268 u
->min_wakeup
= pa_usec_to_bytes(TSCHED_MIN_WAKEUP_USEC
, &u
->source
->sample_spec
);
269 u
->min_wakeup
= PA_CLAMP(u
->min_wakeup
, u
->frame_size
, max_use_2
);
272 static void fix_tsched_watermark(struct userdata
*u
) {
275 pa_assert(u
->use_tsched
);
277 max_use
= u
->hwbuf_size
- u
->hwbuf_unused
;
279 if (u
->tsched_watermark
> max_use
- u
->min_sleep
)
280 u
->tsched_watermark
= max_use
- u
->min_sleep
;
282 if (u
->tsched_watermark
< u
->min_wakeup
)
283 u
->tsched_watermark
= u
->min_wakeup
;
286 static void increase_watermark(struct userdata
*u
) {
287 size_t old_watermark
;
288 pa_usec_t old_min_latency
, new_min_latency
;
291 pa_assert(u
->use_tsched
);
293 /* First, just try to increase the watermark */
294 old_watermark
= u
->tsched_watermark
;
295 u
->tsched_watermark
= PA_MIN(u
->tsched_watermark
* 2, u
->tsched_watermark
+ u
->watermark_inc_step
);
296 fix_tsched_watermark(u
);
298 if (old_watermark
!= u
->tsched_watermark
) {
299 pa_log_info("Increasing wakeup watermark to %0.2f ms",
300 (double) pa_bytes_to_usec(u
->tsched_watermark
, &u
->source
->sample_spec
) / PA_USEC_PER_MSEC
);
304 /* Hmm, we cannot increase the watermark any further, hence let's raise the latency */
305 old_min_latency
= u
->source
->thread_info
.min_latency
;
306 new_min_latency
= PA_MIN(old_min_latency
* 2, old_min_latency
+ TSCHED_WATERMARK_INC_STEP_USEC
);
307 new_min_latency
= PA_MIN(new_min_latency
, u
->source
->thread_info
.max_latency
);
309 if (old_min_latency
!= new_min_latency
) {
310 pa_log_info("Increasing minimal latency to %0.2f ms",
311 (double) new_min_latency
/ PA_USEC_PER_MSEC
);
313 pa_source_set_latency_range_within_thread(u
->source
, new_min_latency
, u
->source
->thread_info
.max_latency
);
316 /* When we reach this we're officialy fucked! */
319 static void decrease_watermark(struct userdata
*u
) {
320 size_t old_watermark
;
324 pa_assert(u
->use_tsched
);
326 now
= pa_rtclock_now();
328 if (u
->watermark_dec_not_before
<= 0)
331 if (u
->watermark_dec_not_before
> now
)
334 old_watermark
= u
->tsched_watermark
;
336 if (u
->tsched_watermark
< u
->watermark_dec_step
)
337 u
->tsched_watermark
= u
->tsched_watermark
/ 2;
339 u
->tsched_watermark
= PA_MAX(u
->tsched_watermark
/ 2, u
->tsched_watermark
- u
->watermark_dec_step
);
341 fix_tsched_watermark(u
);
343 if (old_watermark
!= u
->tsched_watermark
)
344 pa_log_info("Decreasing wakeup watermark to %0.2f ms",
345 (double) pa_bytes_to_usec(u
->tsched_watermark
, &u
->source
->sample_spec
) / PA_USEC_PER_MSEC
);
347 /* We don't change the latency range*/
350 u
->watermark_dec_not_before
= now
+ TSCHED_WATERMARK_VERIFY_AFTER_USEC
;
353 static pa_usec_t
hw_sleep_time(struct userdata
*u
, pa_usec_t
*sleep_usec
, pa_usec_t
*process_usec
) {
356 pa_assert(sleep_usec
);
357 pa_assert(process_usec
);
360 pa_assert(u
->use_tsched
);
362 usec
= pa_source_get_requested_latency_within_thread(u
->source
);
364 if (usec
== (pa_usec_t
) -1)
365 usec
= pa_bytes_to_usec(u
->hwbuf_size
, &u
->source
->sample_spec
);
367 wm
= pa_bytes_to_usec(u
->tsched_watermark
, &u
->source
->sample_spec
);
372 *sleep_usec
= usec
- wm
;
376 pa_log_debug("Buffer time: %lu ms; Sleep time: %lu ms; Process time: %lu ms",
377 (unsigned long) (usec
/ PA_USEC_PER_MSEC
),
378 (unsigned long) (*sleep_usec
/ PA_USEC_PER_MSEC
),
379 (unsigned long) (*process_usec
/ PA_USEC_PER_MSEC
));
385 static int try_recover(struct userdata
*u
, const char *call
, int err
) {
390 pa_log_debug("%s: %s", call
, pa_alsa_strerror(err
));
392 pa_assert(err
!= -EAGAIN
);
395 pa_log_debug("%s: Buffer overrun!", call
);
397 if (err
== -ESTRPIPE
)
398 pa_log_debug("%s: System suspended!", call
);
400 if ((err
= snd_pcm_recover(u
->pcm_handle
, err
, 1)) < 0) {
401 pa_log("%s: %s", call
, pa_alsa_strerror(err
));
409 static size_t check_left_to_record(struct userdata
*u
, size_t n_bytes
, pa_bool_t on_timeout
) {
410 size_t left_to_record
;
411 size_t rec_space
= u
->hwbuf_size
- u
->hwbuf_unused
;
412 pa_bool_t overrun
= FALSE
;
414 /* We use <= instead of < for this check here because an overrun
415 * only happens after the last sample was processed, not already when
416 * it is removed from the buffer. This is particularly important
417 * when block transfer is used. */
419 if (n_bytes
<= rec_space
)
420 left_to_record
= rec_space
- n_bytes
;
423 /* We got a dropout. What a mess! */
431 if (pa_log_ratelimit())
432 pa_log_info("Overrun!");
436 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
);
440 pa_bool_t reset_not_before
= TRUE
;
442 if (overrun
|| left_to_record
< u
->watermark_inc_threshold
)
443 increase_watermark(u
);
444 else if (left_to_record
> u
->watermark_dec_threshold
) {
445 reset_not_before
= FALSE
;
447 /* We decrease the watermark only if have actually been
448 * woken up by a timeout. If something else woke us up
449 * it's too easy to fulfill the deadlines... */
452 decrease_watermark(u
);
455 if (reset_not_before
)
456 u
->watermark_dec_not_before
= 0;
459 return left_to_record
;
462 static int mmap_read(struct userdata
*u
, pa_usec_t
*sleep_usec
, pa_bool_t polled
, pa_bool_t on_timeout
) {
463 pa_bool_t work_done
= FALSE
;
464 pa_usec_t max_sleep_usec
= 0, process_usec
= 0;
465 size_t left_to_record
;
469 pa_source_assert_ref(u
->source
);
472 hw_sleep_time(u
, &max_sleep_usec
, &process_usec
);
478 pa_bool_t after_avail
= TRUE
;
480 if (PA_UNLIKELY((n
= pa_alsa_safe_avail(u
->pcm_handle
, u
->hwbuf_size
, &u
->source
->sample_spec
)) < 0)) {
482 if ((r
= try_recover(u
, "snd_pcm_avail", (int) n
)) == 0)
488 n_bytes
= (size_t) n
* u
->frame_size
;
491 pa_log_debug("avail: %lu", (unsigned long) n_bytes
);
494 left_to_record
= check_left_to_record(u
, n_bytes
, on_timeout
);
499 pa_bytes_to_usec(left_to_record
, &u
->source
->sample_spec
) > process_usec
+max_sleep_usec
/2) {
501 pa_log_debug("Not reading, because too early.");
506 if (PA_UNLIKELY(n_bytes
<= 0)) {
510 char *dn
= pa_alsa_get_driver_name_by_pcm(u
->pcm_handle
);
511 pa_log(_("ALSA woke us up to read new data from the device, but there was actually nothing to read!\n"
512 "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers.\n"
513 "We were woken up with POLLIN set -- however a subsequent snd_pcm_avail() returned 0 or another value < min_avail."),
519 pa_log_debug("Not reading, because not necessary.");
526 pa_log_debug("Not filling up, because already too many iterations.");
535 pa_log_debug("Reading");
540 const snd_pcm_channel_area_t
*areas
;
541 snd_pcm_uframes_t offset
, frames
;
544 snd_pcm_sframes_t sframes
;
546 frames
= (snd_pcm_uframes_t
) (n_bytes
/ u
->frame_size
);
548 /* pa_log_debug("%lu frames to read", (unsigned long) frames); */
550 if (PA_UNLIKELY((err
= pa_alsa_safe_mmap_begin(u
->pcm_handle
, &areas
, &offset
, &frames
, u
->hwbuf_size
, &u
->source
->sample_spec
)) < 0)) {
552 if (!after_avail
&& err
== -EAGAIN
)
555 if ((r
= try_recover(u
, "snd_pcm_mmap_begin", err
)) == 0)
561 /* Make sure that if these memblocks need to be copied they will fit into one slot */
562 if (frames
> pa_mempool_block_size_max(u
->source
->core
->mempool
)/u
->frame_size
)
563 frames
= pa_mempool_block_size_max(u
->source
->core
->mempool
)/u
->frame_size
;
565 if (!after_avail
&& frames
== 0)
568 pa_assert(frames
> 0);
571 /* Check these are multiples of 8 bit */
572 pa_assert((areas
[0].first
& 7) == 0);
573 pa_assert((areas
[0].step
& 7)== 0);
575 /* We assume a single interleaved memory buffer */
576 pa_assert((areas
[0].first
>> 3) == 0);
577 pa_assert((areas
[0].step
>> 3) == u
->frame_size
);
579 p
= (uint8_t*) areas
[0].addr
+ (offset
* u
->frame_size
);
581 chunk
.memblock
= pa_memblock_new_fixed(u
->core
->mempool
, p
, frames
* u
->frame_size
, TRUE
);
582 chunk
.length
= pa_memblock_get_length(chunk
.memblock
);
585 pa_source_post(u
->source
, &chunk
);
586 pa_memblock_unref_fixed(chunk
.memblock
);
588 if (PA_UNLIKELY((sframes
= snd_pcm_mmap_commit(u
->pcm_handle
, offset
, frames
)) < 0)) {
590 if ((r
= try_recover(u
, "snd_pcm_mmap_commit", (int) sframes
)) == 0)
598 u
->read_count
+= frames
* u
->frame_size
;
601 pa_log_debug("Read %lu bytes (of possible %lu bytes)", (unsigned long) (frames
* u
->frame_size
), (unsigned long) n_bytes
);
604 if ((size_t) frames
* u
->frame_size
>= n_bytes
)
607 n_bytes
-= (size_t) frames
* u
->frame_size
;
612 *sleep_usec
= pa_bytes_to_usec(left_to_record
, &u
->source
->sample_spec
);
614 if (*sleep_usec
> process_usec
)
615 *sleep_usec
-= process_usec
;
620 return work_done
? 1 : 0;
623 static int unix_read(struct userdata
*u
, pa_usec_t
*sleep_usec
, pa_bool_t polled
, pa_bool_t on_timeout
) {
624 int work_done
= FALSE
;
625 pa_usec_t max_sleep_usec
= 0, process_usec
= 0;
626 size_t left_to_record
;
630 pa_source_assert_ref(u
->source
);
633 hw_sleep_time(u
, &max_sleep_usec
, &process_usec
);
639 pa_bool_t after_avail
= TRUE
;
641 if (PA_UNLIKELY((n
= pa_alsa_safe_avail(u
->pcm_handle
, u
->hwbuf_size
, &u
->source
->sample_spec
)) < 0)) {
643 if ((r
= try_recover(u
, "snd_pcm_avail", (int) n
)) == 0)
649 n_bytes
= (size_t) n
* u
->frame_size
;
650 left_to_record
= check_left_to_record(u
, n_bytes
, on_timeout
);
655 pa_bytes_to_usec(left_to_record
, &u
->source
->sample_spec
) > process_usec
+max_sleep_usec
/2)
658 if (PA_UNLIKELY(n_bytes
<= 0)) {
662 char *dn
= pa_alsa_get_driver_name_by_pcm(u
->pcm_handle
);
663 pa_log(_("ALSA woke us up to read new data from the device, but there was actually nothing to read!\n"
664 "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers.\n"
665 "We were woken up with POLLIN set -- however a subsequent snd_pcm_avail() returned 0 or another value < min_avail."),
675 pa_log_debug("Not filling up, because already too many iterations.");
685 snd_pcm_sframes_t frames
;
688 chunk
.memblock
= pa_memblock_new(u
->core
->mempool
, (size_t) -1);
690 frames
= (snd_pcm_sframes_t
) (pa_memblock_get_length(chunk
.memblock
) / u
->frame_size
);
692 if (frames
> (snd_pcm_sframes_t
) (n_bytes
/u
->frame_size
))
693 frames
= (snd_pcm_sframes_t
) (n_bytes
/u
->frame_size
);
695 /* pa_log_debug("%lu frames to read", (unsigned long) n); */
697 p
= pa_memblock_acquire(chunk
.memblock
);
698 frames
= snd_pcm_readi(u
->pcm_handle
, (uint8_t*) p
, (snd_pcm_uframes_t
) frames
);
699 pa_memblock_release(chunk
.memblock
);
701 if (PA_UNLIKELY(frames
< 0)) {
702 pa_memblock_unref(chunk
.memblock
);
704 if (!after_avail
&& (int) frames
== -EAGAIN
)
707 if ((r
= try_recover(u
, "snd_pcm_readi", (int) frames
)) == 0)
713 if (!after_avail
&& frames
== 0) {
714 pa_memblock_unref(chunk
.memblock
);
718 pa_assert(frames
> 0);
722 chunk
.length
= (size_t) frames
* u
->frame_size
;
724 pa_source_post(u
->source
, &chunk
);
725 pa_memblock_unref(chunk
.memblock
);
729 u
->read_count
+= frames
* u
->frame_size
;
731 /* pa_log_debug("read %lu frames", (unsigned long) frames); */
733 if ((size_t) frames
* u
->frame_size
>= n_bytes
)
736 n_bytes
-= (size_t) frames
* u
->frame_size
;
741 *sleep_usec
= pa_bytes_to_usec(left_to_record
, &u
->source
->sample_spec
);
743 if (*sleep_usec
> process_usec
)
744 *sleep_usec
-= process_usec
;
749 return work_done
? 1 : 0;
752 static void update_smoother(struct userdata
*u
) {
753 snd_pcm_sframes_t delay
= 0;
756 pa_usec_t now1
= 0, now2
;
757 snd_pcm_status_t
*status
;
759 snd_pcm_status_alloca(&status
);
762 pa_assert(u
->pcm_handle
);
764 /* Let's update the time smoother */
766 if (PA_UNLIKELY((err
= pa_alsa_safe_delay(u
->pcm_handle
, &delay
, u
->hwbuf_size
, &u
->source
->sample_spec
, TRUE
)) < 0)) {
767 pa_log_warn("Failed to get delay: %s", pa_alsa_strerror(err
));
771 if (PA_UNLIKELY((err
= snd_pcm_status(u
->pcm_handle
, status
)) < 0))
772 pa_log_warn("Failed to get timestamp: %s", pa_alsa_strerror(err
));
774 snd_htimestamp_t htstamp
= { 0, 0 };
775 snd_pcm_status_get_htstamp(status
, &htstamp
);
776 now1
= pa_timespec_load(&htstamp
);
779 /* Hmm, if the timestamp is 0, then it wasn't set and we take the current time */
781 now1
= pa_rtclock_now();
783 /* check if the time since the last update is bigger than the interval */
784 if (u
->last_smoother_update
> 0)
785 if (u
->last_smoother_update
+ u
->smoother_interval
> now1
)
788 position
= u
->read_count
+ ((uint64_t) delay
* (uint64_t) u
->frame_size
);
789 now2
= pa_bytes_to_usec(position
, &u
->source
->sample_spec
);
791 pa_smoother_put(u
->smoother
, now1
, now2
);
793 u
->last_smoother_update
= now1
;
794 /* exponentially increase the update interval up to the MAX limit */
795 u
->smoother_interval
= PA_MIN (u
->smoother_interval
* 2, SMOOTHER_MAX_INTERVAL
);
798 static pa_usec_t
source_get_latency(struct userdata
*u
) {
800 pa_usec_t now1
, now2
;
804 now1
= pa_rtclock_now();
805 now2
= pa_smoother_get(u
->smoother
, now1
);
807 delay
= (int64_t) now2
- (int64_t) pa_bytes_to_usec(u
->read_count
, &u
->source
->sample_spec
);
809 return delay
>= 0 ? (pa_usec_t
) delay
: 0;
812 static int build_pollfd(struct userdata
*u
) {
814 pa_assert(u
->pcm_handle
);
816 if (u
->alsa_rtpoll_item
)
817 pa_rtpoll_item_free(u
->alsa_rtpoll_item
);
819 if (!(u
->alsa_rtpoll_item
= pa_alsa_build_pollfd(u
->pcm_handle
, u
->rtpoll
)))
825 static int suspend(struct userdata
*u
) {
827 pa_assert(u
->pcm_handle
);
829 pa_smoother_pause(u
->smoother
, pa_rtclock_now());
832 snd_pcm_close(u
->pcm_handle
);
833 u
->pcm_handle
= NULL
;
835 if (u
->alsa_rtpoll_item
) {
836 pa_rtpoll_item_free(u
->alsa_rtpoll_item
);
837 u
->alsa_rtpoll_item
= NULL
;
840 pa_log_info("Device suspended...");
845 static int update_sw_params(struct userdata
*u
) {
846 snd_pcm_uframes_t avail_min
;
851 /* Use the full buffer if noone asked us for anything specific */
857 if ((latency
= pa_source_get_requested_latency_within_thread(u
->source
)) != (pa_usec_t
) -1) {
860 pa_log_debug("latency set to %0.2fms", (double) latency
/ PA_USEC_PER_MSEC
);
862 b
= pa_usec_to_bytes(latency
, &u
->source
->sample_spec
);
864 /* We need at least one sample in our buffer */
866 if (PA_UNLIKELY(b
< u
->frame_size
))
869 u
->hwbuf_unused
= PA_LIKELY(b
< u
->hwbuf_size
) ? (u
->hwbuf_size
- b
) : 0;
872 fix_min_sleep_wakeup(u
);
873 fix_tsched_watermark(u
);
876 pa_log_debug("hwbuf_unused=%lu", (unsigned long) u
->hwbuf_unused
);
881 pa_usec_t sleep_usec
, process_usec
;
883 hw_sleep_time(u
, &sleep_usec
, &process_usec
);
884 avail_min
+= pa_usec_to_bytes(sleep_usec
, &u
->source
->sample_spec
) / u
->frame_size
;
887 pa_log_debug("setting avail_min=%lu", (unsigned long) avail_min
);
889 if ((err
= pa_alsa_set_sw_params(u
->pcm_handle
, avail_min
, !u
->use_tsched
)) < 0) {
890 pa_log("Failed to set software parameters: %s", pa_alsa_strerror(err
));
897 static int unsuspend(struct userdata
*u
) {
901 snd_pcm_uframes_t period_size
, buffer_size
;
904 pa_assert(!u
->pcm_handle
);
906 pa_log_info("Trying resume...");
908 if ((err
= snd_pcm_open(&u
->pcm_handle
, u
->device_name
, SND_PCM_STREAM_CAPTURE
,
910 SND_PCM_NO_AUTO_RESAMPLE
|
911 SND_PCM_NO_AUTO_CHANNELS
|
912 SND_PCM_NO_AUTO_FORMAT
)) < 0) {
913 pa_log("Error opening PCM device %s: %s", u
->device_name
, pa_alsa_strerror(err
));
917 ss
= u
->source
->sample_spec
;
918 period_size
= u
->fragment_size
/ u
->frame_size
;
919 buffer_size
= u
->hwbuf_size
/ u
->frame_size
;
923 if ((err
= pa_alsa_set_hw_params(u
->pcm_handle
, &ss
, &period_size
, &buffer_size
, 0, &b
, &d
, TRUE
)) < 0) {
924 pa_log("Failed to set hardware parameters: %s", pa_alsa_strerror(err
));
928 if (b
!= u
->use_mmap
|| d
!= u
->use_tsched
) {
929 pa_log_warn("Resume failed, couldn't get original access mode.");
933 if (!pa_sample_spec_equal(&ss
, &u
->source
->sample_spec
)) {
934 pa_log_warn("Resume failed, couldn't restore original sample settings.");
938 if (period_size
*u
->frame_size
!= u
->fragment_size
||
939 buffer_size
*u
->frame_size
!= u
->hwbuf_size
) {
940 pa_log_warn("Resume failed, couldn't restore original fragment settings. (Old: %lu/%lu, New %lu/%lu)",
941 (unsigned long) u
->hwbuf_size
, (unsigned long) u
->fragment_size
,
942 (unsigned long) (buffer_size
*u
->frame_size
), (unsigned long) (period_size
*u
->frame_size
));
946 if (update_sw_params(u
) < 0)
949 if (build_pollfd(u
) < 0)
952 /* FIXME: We need to reload the volume somehow */
955 pa_smoother_reset(u
->smoother
, pa_rtclock_now(), TRUE
);
956 u
->smoother_interval
= SMOOTHER_MIN_INTERVAL
;
957 u
->last_smoother_update
= 0;
961 pa_log_info("Resumed successfully...");
967 snd_pcm_close(u
->pcm_handle
);
968 u
->pcm_handle
= NULL
;
974 static int source_process_msg(pa_msgobject
*o
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
975 struct userdata
*u
= PA_SOURCE(o
)->userdata
;
979 case PA_SOURCE_MESSAGE_GET_LATENCY
: {
983 r
= source_get_latency(u
);
985 *((pa_usec_t
*) data
) = r
;
990 case PA_SOURCE_MESSAGE_SET_STATE
:
992 switch ((pa_source_state_t
) PA_PTR_TO_UINT(data
)) {
994 case PA_SOURCE_SUSPENDED
: {
996 pa_assert(PA_SOURCE_IS_OPENED(u
->source
->thread_info
.state
));
998 if ((r
= suspend(u
)) < 0)
1004 case PA_SOURCE_IDLE
:
1005 case PA_SOURCE_RUNNING
: {
1008 if (u
->source
->thread_info
.state
== PA_SOURCE_INIT
) {
1009 if (build_pollfd(u
) < 0)
1013 if (u
->source
->thread_info
.state
== PA_SOURCE_SUSPENDED
) {
1014 if ((r
= unsuspend(u
)) < 0)
1021 case PA_SOURCE_UNLINKED
:
1022 case PA_SOURCE_INIT
:
1023 case PA_SOURCE_INVALID_STATE
:
1030 return pa_source_process_msg(o
, code
, data
, offset
, chunk
);
1033 /* Called from main context */
1034 static int source_set_state_cb(pa_source
*s
, pa_source_state_t new_state
) {
1035 pa_source_state_t old_state
;
1038 pa_source_assert_ref(s
);
1039 pa_assert_se(u
= s
->userdata
);
1041 old_state
= pa_source_get_state(u
->source
);
1043 if (PA_SINK_IS_OPENED(old_state
) && new_state
== PA_SINK_SUSPENDED
)
1045 else if (old_state
== PA_SINK_SUSPENDED
&& PA_SINK_IS_OPENED(new_state
))
1046 if (reserve_init(u
, u
->device_name
) < 0)
1047 return -PA_ERR_BUSY
;
1052 static int mixer_callback(snd_mixer_elem_t
*elem
, unsigned int mask
) {
1053 struct userdata
*u
= snd_mixer_elem_get_callback_private(elem
);
1056 pa_assert(u
->mixer_handle
);
1058 if (mask
== SND_CTL_EVENT_MASK_REMOVE
)
1061 if (u
->source
->suspend_cause
& PA_SUSPEND_SESSION
)
1064 if (mask
& SND_CTL_EVENT_MASK_VALUE
) {
1065 pa_source_get_volume(u
->source
, TRUE
);
1066 pa_source_get_mute(u
->source
, TRUE
);
1072 static void source_get_volume_cb(pa_source
*s
) {
1073 struct userdata
*u
= s
->userdata
;
1075 char t
[PA_CVOLUME_SNPRINT_MAX
];
1078 pa_assert(u
->mixer_path
);
1079 pa_assert(u
->mixer_handle
);
1081 if (pa_alsa_path_get_volume(u
->mixer_path
, u
->mixer_handle
, &s
->channel_map
, &r
) < 0)
1084 /* Shift down by the base volume, so that 0dB becomes maximum volume */
1085 pa_sw_cvolume_multiply_scalar(&r
, &r
, s
->base_volume
);
1087 pa_log_debug("Read hardware volume: %s", pa_cvolume_snprint(t
, sizeof(t
), &r
));
1089 if (pa_cvolume_equal(&u
->hardware_volume
, &r
))
1092 s
->volume
= u
->hardware_volume
= r
;
1094 /* Hmm, so the hardware volume changed, let's reset our software volume */
1095 if (u
->mixer_path
->has_dB
)
1096 pa_source_set_soft_volume(s
, NULL
);
1099 static void source_set_volume_cb(pa_source
*s
) {
1100 struct userdata
*u
= s
->userdata
;
1102 char t
[PA_CVOLUME_SNPRINT_MAX
];
1105 pa_assert(u
->mixer_path
);
1106 pa_assert(u
->mixer_handle
);
1108 /* Shift up by the base volume */
1109 pa_sw_cvolume_divide_scalar(&r
, &s
->volume
, s
->base_volume
);
1111 if (pa_alsa_path_set_volume(u
->mixer_path
, u
->mixer_handle
, &s
->channel_map
, &r
) < 0)
1114 /* Shift down by the base volume, so that 0dB becomes maximum volume */
1115 pa_sw_cvolume_multiply_scalar(&r
, &r
, s
->base_volume
);
1117 u
->hardware_volume
= r
;
1119 if (u
->mixer_path
->has_dB
) {
1120 pa_cvolume new_soft_volume
;
1121 pa_bool_t accurate_enough
;
1123 /* Match exactly what the user requested by software */
1124 pa_sw_cvolume_divide(&new_soft_volume
, &s
->volume
, &u
->hardware_volume
);
1126 /* If the adjustment to do in software is only minimal we
1127 * can skip it. That saves us CPU at the expense of a bit of
1130 (pa_cvolume_min(&new_soft_volume
) >= (PA_VOLUME_NORM
- VOLUME_ACCURACY
)) &&
1131 (pa_cvolume_max(&new_soft_volume
) <= (PA_VOLUME_NORM
+ VOLUME_ACCURACY
));
1133 pa_log_debug("Requested volume: %s", pa_cvolume_snprint(t
, sizeof(t
), &s
->volume
));
1134 pa_log_debug("Got hardware volume: %s", pa_cvolume_snprint(t
, sizeof(t
), &u
->hardware_volume
));
1135 pa_log_debug("Calculated software volume: %s (accurate-enough=%s)", pa_cvolume_snprint(t
, sizeof(t
), &new_soft_volume
),
1136 pa_yes_no(accurate_enough
));
1138 if (!accurate_enough
)
1139 s
->soft_volume
= new_soft_volume
;
1142 pa_log_debug("Wrote hardware volume: %s", pa_cvolume_snprint(t
, sizeof(t
), &r
));
1144 /* We can't match exactly what the user requested, hence let's
1145 * at least tell the user about it */
1151 static void source_get_mute_cb(pa_source
*s
) {
1152 struct userdata
*u
= s
->userdata
;
1156 pa_assert(u
->mixer_path
);
1157 pa_assert(u
->mixer_handle
);
1159 if (pa_alsa_path_get_mute(u
->mixer_path
, u
->mixer_handle
, &b
) < 0)
1165 static void source_set_mute_cb(pa_source
*s
) {
1166 struct userdata
*u
= s
->userdata
;
1169 pa_assert(u
->mixer_path
);
1170 pa_assert(u
->mixer_handle
);
1172 pa_alsa_path_set_mute(u
->mixer_path
, u
->mixer_handle
, s
->muted
);
1175 static int source_set_port_cb(pa_source
*s
, pa_device_port
*p
) {
1176 struct userdata
*u
= s
->userdata
;
1177 pa_alsa_port_data
*data
;
1181 pa_assert(u
->mixer_handle
);
1183 data
= PA_DEVICE_PORT_DATA(p
);
1185 pa_assert_se(u
->mixer_path
= data
->path
);
1186 pa_alsa_path_select(u
->mixer_path
, u
->mixer_handle
);
1188 if (u
->mixer_path
->has_volume
&& u
->mixer_path
->has_dB
) {
1189 s
->base_volume
= pa_sw_volume_from_dB(-u
->mixer_path
->max_dB
);
1190 s
->n_volume_steps
= PA_VOLUME_NORM
+1;
1192 pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(s
->base_volume
));
1194 s
->base_volume
= PA_VOLUME_NORM
;
1195 s
->n_volume_steps
= u
->mixer_path
->max_volume
- u
->mixer_path
->min_volume
+ 1;
1199 pa_alsa_setting_select(data
->setting
, u
->mixer_handle
);
1209 static void source_update_requested_latency_cb(pa_source
*s
) {
1210 struct userdata
*u
= s
->userdata
;
1212 pa_assert(u
->use_tsched
);
1217 update_sw_params(u
);
1220 static void thread_func(void *userdata
) {
1221 struct userdata
*u
= userdata
;
1222 unsigned short revents
= 0;
1226 pa_log_debug("Thread starting up");
1228 if (u
->core
->realtime_scheduling
)
1229 pa_make_realtime(u
->core
->realtime_priority
);
1231 pa_thread_mq_install(&u
->thread_mq
);
1237 pa_log_debug("Loop");
1240 /* Read some data and pass it to the sources */
1241 if (PA_SOURCE_IS_OPENED(u
->source
->thread_info
.state
)) {
1243 pa_usec_t sleep_usec
= 0;
1244 pa_bool_t on_timeout
= pa_rtpoll_timer_elapsed(u
->rtpoll
);
1247 pa_log_info("Starting capture.");
1248 snd_pcm_start(u
->pcm_handle
);
1250 pa_smoother_resume(u
->smoother
, pa_rtclock_now(), TRUE
);
1256 work_done
= mmap_read(u
, &sleep_usec
, revents
& POLLIN
, on_timeout
);
1258 work_done
= unix_read(u
, &sleep_usec
, revents
& POLLIN
, on_timeout
);
1263 /* pa_log_debug("work_done = %i", work_done); */
1268 if (u
->use_tsched
) {
1271 /* OK, the capture buffer is now empty, let's
1272 * calculate when to wake up next */
1274 /* pa_log_debug("Waking up in %0.2fms (sound card clock).", (double) sleep_usec / PA_USEC_PER_MSEC); */
1276 /* Convert from the sound card time domain to the
1277 * system time domain */
1278 cusec
= pa_smoother_translate(u
->smoother
, pa_rtclock_now(), sleep_usec
);
1280 /* pa_log_debug("Waking up in %0.2fms (system clock).", (double) cusec / PA_USEC_PER_MSEC); */
1282 /* We don't trust the conversion, so we wake up whatever comes first */
1283 pa_rtpoll_set_timer_relative(u
->rtpoll
, PA_MIN(sleep_usec
, cusec
));
1285 } else if (u
->use_tsched
)
1287 /* OK, we're in an invalid state, let's disable our timers */
1288 pa_rtpoll_set_timer_disabled(u
->rtpoll
);
1290 /* Hmm, nothing to do. Let's sleep */
1291 if ((ret
= pa_rtpoll_run(u
->rtpoll
, TRUE
)) < 0)
1297 /* Tell ALSA about this and process its response */
1298 if (PA_SOURCE_IS_OPENED(u
->source
->thread_info
.state
)) {
1299 struct pollfd
*pollfd
;
1303 pollfd
= pa_rtpoll_item_get_pollfd(u
->alsa_rtpoll_item
, &n
);
1305 if ((err
= snd_pcm_poll_descriptors_revents(u
->pcm_handle
, pollfd
, n
, &revents
)) < 0) {
1306 pa_log("snd_pcm_poll_descriptors_revents() failed: %s", pa_alsa_strerror(err
));
1310 if (revents
& ~POLLIN
) {
1311 if (pa_alsa_recover_from_poll(u
->pcm_handle
, revents
) < 0)
1315 } else if (revents
&& u
->use_tsched
&& pa_log_ratelimit())
1316 pa_log_debug("Wakeup from ALSA!");
1323 /* If this was no regular exit from the loop we have to continue
1324 * processing messages until we received PA_MESSAGE_SHUTDOWN */
1325 pa_asyncmsgq_post(u
->thread_mq
.outq
, PA_MSGOBJECT(u
->core
), PA_CORE_MESSAGE_UNLOAD_MODULE
, u
->module
, 0, NULL
, NULL
);
1326 pa_asyncmsgq_wait_for(u
->thread_mq
.inq
, PA_MESSAGE_SHUTDOWN
);
1329 pa_log_debug("Thread shutting down");
1332 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
) {
1338 pa_assert(device_name
);
1340 if ((n
= pa_modargs_get_value(ma
, "source_name", NULL
))) {
1341 pa_source_new_data_set_name(data
, n
);
1342 data
->namereg_fail
= TRUE
;
1346 if ((n
= pa_modargs_get_value(ma
, "name", NULL
)))
1347 data
->namereg_fail
= TRUE
;
1349 n
= device_id
? device_id
: device_name
;
1350 data
->namereg_fail
= FALSE
;
1354 t
= pa_sprintf_malloc("alsa_input.%s.%s", n
, mapping
->name
);
1356 t
= pa_sprintf_malloc("alsa_input.%s", n
);
1358 pa_source_new_data_set_name(data
, t
);
1362 static void find_mixer(struct userdata
*u
, pa_alsa_mapping
*mapping
, const char *element
, pa_bool_t ignore_dB
) {
1364 if (!mapping
&& !element
)
1367 if (!(u
->mixer_handle
= pa_alsa_open_mixer_for_pcm(u
->pcm_handle
, &u
->control_device
))) {
1368 pa_log_info("Failed to find a working mixer device.");
1374 if (!(u
->mixer_path
= pa_alsa_path_synthesize(element
, PA_ALSA_DIRECTION_INPUT
)))
1377 if (pa_alsa_path_probe(u
->mixer_path
, u
->mixer_handle
, ignore_dB
) < 0)
1380 pa_log_debug("Probed mixer path %s:", u
->mixer_path
->name
);
1381 pa_alsa_path_dump(u
->mixer_path
);
1384 if (!(u
->mixer_path_set
= pa_alsa_path_set_new(mapping
, PA_ALSA_DIRECTION_INPUT
)))
1387 pa_alsa_path_set_probe(u
->mixer_path_set
, u
->mixer_handle
, ignore_dB
);
1389 pa_log_debug("Probed mixer paths:");
1390 pa_alsa_path_set_dump(u
->mixer_path_set
);
1397 if (u
->mixer_path_set
) {
1398 pa_alsa_path_set_free(u
->mixer_path_set
);
1399 u
->mixer_path_set
= NULL
;
1400 } else if (u
->mixer_path
) {
1401 pa_alsa_path_free(u
->mixer_path
);
1402 u
->mixer_path
= NULL
;
1405 if (u
->mixer_handle
) {
1406 snd_mixer_close(u
->mixer_handle
);
1407 u
->mixer_handle
= NULL
;
1411 static int setup_mixer(struct userdata
*u
, pa_bool_t ignore_dB
) {
1414 if (!u
->mixer_handle
)
1417 if (u
->source
->active_port
) {
1418 pa_alsa_port_data
*data
;
1420 /* We have a list of supported paths, so let's activate the
1421 * one that has been chosen as active */
1423 data
= PA_DEVICE_PORT_DATA(u
->source
->active_port
);
1424 u
->mixer_path
= data
->path
;
1426 pa_alsa_path_select(data
->path
, u
->mixer_handle
);
1429 pa_alsa_setting_select(data
->setting
, u
->mixer_handle
);
1433 if (!u
->mixer_path
&& u
->mixer_path_set
)
1434 u
->mixer_path
= u
->mixer_path_set
->paths
;
1436 if (u
->mixer_path
) {
1437 /* Hmm, we have only a single path, then let's activate it */
1439 pa_alsa_path_select(u
->mixer_path
, u
->mixer_handle
);
1441 if (u
->mixer_path
->settings
)
1442 pa_alsa_setting_select(u
->mixer_path
->settings
, u
->mixer_handle
);
1447 if (!u
->mixer_path
->has_volume
)
1448 pa_log_info("Driver does not support hardware volume control, falling back to software volume control.");
1451 if (u
->mixer_path
->has_dB
) {
1452 pa_log_info("Hardware volume ranges from %0.2f dB to %0.2f dB.", u
->mixer_path
->min_dB
, u
->mixer_path
->max_dB
);
1454 u
->source
->base_volume
= pa_sw_volume_from_dB(-u
->mixer_path
->max_dB
);
1455 u
->source
->n_volume_steps
= PA_VOLUME_NORM
+1;
1457 if (u
->mixer_path
->max_dB
> 0.0)
1458 pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(u
->source
->base_volume
));
1460 pa_log_info("No particular base volume set, fixing to 0 dB");
1463 pa_log_info("Hardware volume ranges from %li to %li.", u
->mixer_path
->min_volume
, u
->mixer_path
->max_volume
);
1464 u
->source
->base_volume
= PA_VOLUME_NORM
;
1465 u
->source
->n_volume_steps
= u
->mixer_path
->max_volume
- u
->mixer_path
->min_volume
+ 1;
1468 u
->source
->get_volume
= source_get_volume_cb
;
1469 u
->source
->set_volume
= source_set_volume_cb
;
1471 u
->source
->flags
|= PA_SOURCE_HW_VOLUME_CTRL
| (u
->mixer_path
->has_dB
? PA_SOURCE_DECIBEL_VOLUME
: 0);
1472 pa_log_info("Using hardware volume control. Hardware dB scale %s.", u
->mixer_path
->has_dB
? "supported" : "not supported");
1475 if (!u
->mixer_path
->has_mute
) {
1476 pa_log_info("Driver does not support hardware mute control, falling back to software mute control.");
1478 u
->source
->get_mute
= source_get_mute_cb
;
1479 u
->source
->set_mute
= source_set_mute_cb
;
1480 u
->source
->flags
|= PA_SOURCE_HW_MUTE_CTRL
;
1481 pa_log_info("Using hardware mute control.");
1484 u
->mixer_fdl
= pa_alsa_fdlist_new();
1486 if (pa_alsa_fdlist_set_mixer(u
->mixer_fdl
, u
->mixer_handle
, u
->core
->mainloop
) < 0) {
1487 pa_log("Failed to initialize file descriptor monitoring");
1491 if (u
->mixer_path_set
)
1492 pa_alsa_path_set_set_callback(u
->mixer_path_set
, u
->mixer_handle
, mixer_callback
, u
);
1494 pa_alsa_path_set_callback(u
->mixer_path
, u
->mixer_handle
, mixer_callback
, u
);
1499 pa_source
*pa_alsa_source_new(pa_module
*m
, pa_modargs
*ma
, const char*driver
, pa_card
*card
, pa_alsa_mapping
*mapping
) {
1501 struct userdata
*u
= NULL
;
1502 const char *dev_id
= NULL
;
1503 pa_sample_spec ss
, requested_ss
;
1505 uint32_t nfrags
, frag_size
, buffer_size
, tsched_size
, tsched_watermark
;
1506 snd_pcm_uframes_t period_frames
, buffer_frames
, tsched_frames
;
1508 pa_bool_t use_mmap
= TRUE
, b
, use_tsched
= TRUE
, d
, ignore_dB
= FALSE
, namereg_fail
= FALSE
;
1509 pa_source_new_data data
;
1510 pa_alsa_profile_set
*profile_set
= NULL
;
1515 ss
= m
->core
->default_sample_spec
;
1516 map
= m
->core
->default_channel_map
;
1517 if (pa_modargs_get_sample_spec_and_channel_map(ma
, &ss
, &map
, PA_CHANNEL_MAP_ALSA
) < 0) {
1518 pa_log("Failed to parse sample specification");
1523 frame_size
= pa_frame_size(&ss
);
1525 nfrags
= m
->core
->default_n_fragments
;
1526 frag_size
= (uint32_t) pa_usec_to_bytes(m
->core
->default_fragment_size_msec
*PA_USEC_PER_MSEC
, &ss
);
1528 frag_size
= (uint32_t) frame_size
;
1529 tsched_size
= (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_BUFFER_USEC
, &ss
);
1530 tsched_watermark
= (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_WATERMARK_USEC
, &ss
);
1532 if (pa_modargs_get_value_u32(ma
, "fragments", &nfrags
) < 0 ||
1533 pa_modargs_get_value_u32(ma
, "fragment_size", &frag_size
) < 0 ||
1534 pa_modargs_get_value_u32(ma
, "tsched_buffer_size", &tsched_size
) < 0 ||
1535 pa_modargs_get_value_u32(ma
, "tsched_buffer_watermark", &tsched_watermark
) < 0) {
1536 pa_log("Failed to parse buffer metrics");
1540 buffer_size
= nfrags
* frag_size
;
1542 period_frames
= frag_size
/frame_size
;
1543 buffer_frames
= buffer_size
/frame_size
;
1544 tsched_frames
= tsched_size
/frame_size
;
1546 if (pa_modargs_get_value_boolean(ma
, "mmap", &use_mmap
) < 0) {
1547 pa_log("Failed to parse mmap argument.");
1551 if (pa_modargs_get_value_boolean(ma
, "tsched", &use_tsched
) < 0) {
1552 pa_log("Failed to parse timer_scheduling argument.");
1556 if (pa_modargs_get_value_boolean(ma
, "ignore_dB", &ignore_dB
) < 0) {
1557 pa_log("Failed to parse ignore_dB argument.");
1561 use_tsched
= pa_alsa_may_tsched(use_tsched
);
1563 u
= pa_xnew0(struct userdata
, 1);
1566 u
->use_mmap
= use_mmap
;
1567 u
->use_tsched
= use_tsched
;
1569 u
->rtpoll
= pa_rtpoll_new();
1570 pa_thread_mq_init(&u
->thread_mq
, m
->core
->mainloop
, u
->rtpoll
);
1572 u
->smoother
= pa_smoother_new(
1573 SMOOTHER_ADJUST_USEC
,
1574 SMOOTHER_WINDOW_USEC
,
1580 u
->smoother_interval
= SMOOTHER_MIN_INTERVAL
;
1582 dev_id
= pa_modargs_get_value(
1584 pa_modargs_get_value(ma
, "device", DEFAULT_DEVICE
));
1586 if (reserve_init(u
, dev_id
) < 0)
1589 if (reserve_monitor_init(u
, dev_id
) < 0)
1597 if (!(dev_id
= pa_modargs_get_value(ma
, "device_id", NULL
))) {
1598 pa_log("device_id= not set");
1602 if (!(u
->pcm_handle
= pa_alsa_open_by_device_id_mapping(
1606 SND_PCM_STREAM_CAPTURE
,
1607 &period_frames
, &buffer_frames
, tsched_frames
,
1611 } else if ((dev_id
= pa_modargs_get_value(ma
, "device_id", NULL
))) {
1613 if (!(profile_set
= pa_alsa_profile_set_new(NULL
, &map
)))
1616 if (!(u
->pcm_handle
= pa_alsa_open_by_device_id_auto(
1620 SND_PCM_STREAM_CAPTURE
,
1621 &period_frames
, &buffer_frames
, tsched_frames
,
1622 &b
, &d
, profile_set
, &mapping
)))
1627 if (!(u
->pcm_handle
= pa_alsa_open_by_device_string(
1628 pa_modargs_get_value(ma
, "device", DEFAULT_DEVICE
),
1631 SND_PCM_STREAM_CAPTURE
,
1632 &period_frames
, &buffer_frames
, tsched_frames
,
1637 pa_assert(u
->device_name
);
1638 pa_log_info("Successfully opened device %s.", u
->device_name
);
1640 if (pa_alsa_pcm_is_modem(u
->pcm_handle
)) {
1641 pa_log_notice("Device %s is modem, refusing further initialization.", u
->device_name
);
1646 pa_log_info("Selected mapping '%s' (%s).", mapping
->description
, mapping
->name
);
1648 if (use_mmap
&& !b
) {
1649 pa_log_info("Device doesn't support mmap(), falling back to UNIX read/write mode.");
1650 u
->use_mmap
= use_mmap
= FALSE
;
1653 if (use_tsched
&& (!b
|| !d
)) {
1654 pa_log_info("Cannot enable timer-based scheduling, falling back to sound IRQ scheduling.");
1655 u
->use_tsched
= use_tsched
= FALSE
;
1659 pa_log_info("Successfully enabled mmap() mode.");
1662 pa_log_info("Successfully enabled timer-based scheduling mode.");
1664 /* ALSA might tweak the sample spec, so recalculate the frame size */
1665 frame_size
= pa_frame_size(&ss
);
1667 find_mixer(u
, mapping
, pa_modargs_get_value(ma
, "control", NULL
), ignore_dB
);
1669 pa_source_new_data_init(&data
);
1670 data
.driver
= driver
;
1673 set_source_name(&data
, ma
, dev_id
, u
->device_name
, mapping
);
1675 /* We need to give pa_modargs_get_value_boolean() a pointer to a local
1676 * variable instead of using &data.namereg_fail directly, because
1677 * data.namereg_fail is a bitfield and taking the address of a bitfield
1678 * variable is impossible. */
1679 namereg_fail
= data
.namereg_fail
;
1680 if (pa_modargs_get_value_boolean(ma
, "namereg_fail", &namereg_fail
) < 0) {
1681 pa_log("Failed to parse boolean argument namereg_fail.");
1682 pa_source_new_data_done(&data
);
1685 data
.namereg_fail
= namereg_fail
;
1687 pa_source_new_data_set_sample_spec(&data
, &ss
);
1688 pa_source_new_data_set_channel_map(&data
, &map
);
1690 pa_alsa_init_proplist_pcm(m
->core
, data
.proplist
, u
->pcm_handle
);
1691 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_STRING
, u
->device_name
);
1692 pa_proplist_setf(data
.proplist
, PA_PROP_DEVICE_BUFFERING_BUFFER_SIZE
, "%lu", (unsigned long) (buffer_frames
* frame_size
));
1693 pa_proplist_setf(data
.proplist
, PA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZE
, "%lu", (unsigned long) (period_frames
* frame_size
));
1694 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_ACCESS_MODE
, u
->use_tsched
? "mmap+timer" : (u
->use_mmap
? "mmap" : "serial"));
1697 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_PROFILE_NAME
, mapping
->name
);
1698 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_PROFILE_DESCRIPTION
, mapping
->description
);
1701 pa_alsa_init_description(data
.proplist
);
1703 if (u
->control_device
)
1704 pa_alsa_init_proplist_ctl(data
.proplist
, u
->control_device
);
1706 if (pa_modargs_get_proplist(ma
, "source_properties", data
.proplist
, PA_UPDATE_REPLACE
) < 0) {
1707 pa_log("Invalid properties");
1708 pa_source_new_data_done(&data
);
1712 if (u
->mixer_path_set
)
1713 pa_alsa_add_ports(&data
.ports
, u
->mixer_path_set
);
1715 u
->source
= pa_source_new(m
->core
, &data
, PA_SOURCE_HARDWARE
|PA_SOURCE_LATENCY
|(u
->use_tsched
? PA_SOURCE_DYNAMIC_LATENCY
: 0));
1716 pa_source_new_data_done(&data
);
1719 pa_log("Failed to create source object");
1723 u
->source
->parent
.process_msg
= source_process_msg
;
1725 u
->source
->update_requested_latency
= source_update_requested_latency_cb
;
1726 u
->source
->set_state
= source_set_state_cb
;
1727 u
->source
->set_port
= source_set_port_cb
;
1728 u
->source
->userdata
= u
;
1730 pa_source_set_asyncmsgq(u
->source
, u
->thread_mq
.inq
);
1731 pa_source_set_rtpoll(u
->source
, u
->rtpoll
);
1733 u
->frame_size
= frame_size
;
1734 u
->fragment_size
= frag_size
= (size_t) (period_frames
* frame_size
);
1735 u
->hwbuf_size
= buffer_size
= (size_t) (buffer_frames
* frame_size
);
1736 pa_cvolume_mute(&u
->hardware_volume
, u
->source
->sample_spec
.channels
);
1738 pa_log_info("Using %0.1f fragments of size %lu bytes (%0.2fms), buffer size is %lu bytes (%0.2fms)",
1739 (double) u
->hwbuf_size
/ (double) u
->fragment_size
,
1740 (long unsigned) u
->fragment_size
,
1741 (double) pa_bytes_to_usec(u
->fragment_size
, &ss
) / PA_USEC_PER_MSEC
,
1742 (long unsigned) u
->hwbuf_size
,
1743 (double) pa_bytes_to_usec(u
->hwbuf_size
, &ss
) / PA_USEC_PER_MSEC
);
1745 if (u
->use_tsched
) {
1746 u
->tsched_watermark
= pa_usec_to_bytes_round_up(pa_bytes_to_usec_round_up(tsched_watermark
, &requested_ss
), &u
->source
->sample_spec
);
1748 u
->watermark_inc_step
= pa_usec_to_bytes(TSCHED_WATERMARK_INC_STEP_USEC
, &u
->source
->sample_spec
);
1749 u
->watermark_dec_step
= pa_usec_to_bytes(TSCHED_WATERMARK_DEC_STEP_USEC
, &u
->source
->sample_spec
);
1751 u
->watermark_inc_threshold
= pa_usec_to_bytes_round_up(TSCHED_WATERMARK_INC_THRESHOLD_USEC
, &u
->source
->sample_spec
);
1752 u
->watermark_dec_threshold
= pa_usec_to_bytes_round_up(TSCHED_WATERMARK_DEC_THRESHOLD_USEC
, &u
->source
->sample_spec
);
1754 fix_min_sleep_wakeup(u
);
1755 fix_tsched_watermark(u
);
1757 pa_source_set_latency_range(u
->source
,
1759 pa_bytes_to_usec(u
->hwbuf_size
, &ss
));
1761 pa_log_info("Time scheduling watermark is %0.2fms",
1762 (double) pa_bytes_to_usec(u
->tsched_watermark
, &ss
) / PA_USEC_PER_MSEC
);
1764 pa_source_set_fixed_latency(u
->source
, pa_bytes_to_usec(u
->hwbuf_size
, &ss
));
1768 if (update_sw_params(u
) < 0)
1771 if (setup_mixer(u
, ignore_dB
) < 0)
1774 pa_alsa_dump(PA_LOG_DEBUG
, u
->pcm_handle
);
1776 if (!(u
->thread
= pa_thread_new("alsa-source", thread_func
, u
))) {
1777 pa_log("Failed to create thread.");
1780 /* Get initial mixer settings */
1781 if (data
.volume_is_set
) {
1782 if (u
->source
->set_volume
)
1783 u
->source
->set_volume(u
->source
);
1785 if (u
->source
->get_volume
)
1786 u
->source
->get_volume(u
->source
);
1789 if (data
.muted_is_set
) {
1790 if (u
->source
->set_mute
)
1791 u
->source
->set_mute(u
->source
);
1793 if (u
->source
->get_mute
)
1794 u
->source
->get_mute(u
->source
);
1797 pa_source_put(u
->source
);
1800 pa_alsa_profile_set_free(profile_set
);
1810 pa_alsa_profile_set_free(profile_set
);
1815 static void userdata_free(struct userdata
*u
) {
1819 pa_source_unlink(u
->source
);
1822 pa_asyncmsgq_send(u
->thread_mq
.inq
, NULL
, PA_MESSAGE_SHUTDOWN
, NULL
, 0, NULL
);
1823 pa_thread_free(u
->thread
);
1826 pa_thread_mq_done(&u
->thread_mq
);
1829 pa_source_unref(u
->source
);
1831 if (u
->alsa_rtpoll_item
)
1832 pa_rtpoll_item_free(u
->alsa_rtpoll_item
);
1835 pa_rtpoll_free(u
->rtpoll
);
1837 if (u
->pcm_handle
) {
1838 snd_pcm_drop(u
->pcm_handle
);
1839 snd_pcm_close(u
->pcm_handle
);
1843 pa_alsa_fdlist_free(u
->mixer_fdl
);
1845 if (u
->mixer_path_set
)
1846 pa_alsa_path_set_free(u
->mixer_path_set
);
1847 else if (u
->mixer_path
)
1848 pa_alsa_path_free(u
->mixer_path
);
1850 if (u
->mixer_handle
)
1851 snd_mixer_close(u
->mixer_handle
);
1854 pa_smoother_free(u
->smoother
);
1859 pa_xfree(u
->device_name
);
1860 pa_xfree(u
->control_device
);
1864 void pa_alsa_source_free(pa_source
*s
) {
1867 pa_source_assert_ref(s
);
1868 pa_assert_se(u
= s
->userdata
);