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/rtclock.h>
32 #include <pulse/timeval.h>
33 #include <pulse/volume.h>
34 #include <pulse/xmalloc.h>
36 #include <pulsecore/core.h>
37 #include <pulsecore/i18n.h>
38 #include <pulsecore/module.h>
39 #include <pulsecore/memchunk.h>
40 #include <pulsecore/sink.h>
41 #include <pulsecore/modargs.h>
42 #include <pulsecore/core-rtclock.h>
43 #include <pulsecore/core-util.h>
44 #include <pulsecore/sample-util.h>
45 #include <pulsecore/log.h>
46 #include <pulsecore/macro.h>
47 #include <pulsecore/thread.h>
48 #include <pulsecore/thread-mq.h>
49 #include <pulsecore/rtpoll.h>
50 #include <pulsecore/time-smoother.h>
52 #include <modules/reserve-wrap.h>
54 #include "alsa-util.h"
55 #include "alsa-source.h"
57 /* #define DEBUG_TIMING */
59 #define DEFAULT_DEVICE "default"
61 #define DEFAULT_TSCHED_BUFFER_USEC (2*PA_USEC_PER_SEC) /* 2s */
62 #define DEFAULT_TSCHED_WATERMARK_USEC (20*PA_USEC_PER_MSEC) /* 20ms */
64 #define TSCHED_WATERMARK_INC_STEP_USEC (10*PA_USEC_PER_MSEC) /* 10ms */
65 #define TSCHED_WATERMARK_DEC_STEP_USEC (5*PA_USEC_PER_MSEC) /* 5ms */
66 #define TSCHED_WATERMARK_VERIFY_AFTER_USEC (20*PA_USEC_PER_SEC) /* 20s */
67 #define TSCHED_WATERMARK_INC_THRESHOLD_USEC (0*PA_USEC_PER_MSEC) /* 0ms */
68 #define TSCHED_WATERMARK_DEC_THRESHOLD_USEC (100*PA_USEC_PER_MSEC) /* 100ms */
69 #define TSCHED_WATERMARK_STEP_USEC (10*PA_USEC_PER_MSEC) /* 10ms */
71 #define TSCHED_MIN_SLEEP_USEC (10*PA_USEC_PER_MSEC) /* 10ms */
72 #define TSCHED_MIN_WAKEUP_USEC (4*PA_USEC_PER_MSEC) /* 4ms */
74 #define SMOOTHER_WINDOW_USEC (10*PA_USEC_PER_SEC) /* 10s */
75 #define SMOOTHER_ADJUST_USEC (1*PA_USEC_PER_SEC) /* 1s */
77 #define SMOOTHER_MIN_INTERVAL (2*PA_USEC_PER_MSEC) /* 2ms */
78 #define SMOOTHER_MAX_INTERVAL (200*PA_USEC_PER_MSEC) /* 200ms */
80 #define VOLUME_ACCURACY (PA_VOLUME_NORM/100)
88 pa_thread_mq thread_mq;
91 snd_pcm_t *pcm_handle;
94 pa_alsa_fdlist *mixer_fdl;
95 pa_alsa_mixer_pdata *mixer_pd;
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;
109 tsched_watermark_ref,
115 watermark_inc_threshold,
116 watermark_dec_threshold;
118 pa_usec_t watermark_dec_not_before;
119 pa_usec_t min_latency_ref;
121 char *device_name; /* name of the PCM device */
122 char *control_device; /* name of the control device */
124 pa_bool_t use_mmap:1, use_tsched:1, deferred_volume:1, fixed_latency_range:1;
128 pa_rtpoll_item *alsa_rtpoll_item;
130 snd_mixer_selem_channel_id_t mixer_map[SND_MIXER_SCHN_LAST];
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 static void userdata_free(struct userdata *u);
145 static pa_hook_result_t reserve_cb(pa_reserve_wrapper *r, void *forced, struct userdata *u) {
149 if (pa_source_suspend(u->source, TRUE, PA_SUSPEND_APPLICATION) < 0)
150 return PA_HOOK_CANCEL;
155 static void reserve_done(struct userdata *u) {
158 if (u->reserve_slot) {
159 pa_hook_slot_free(u->reserve_slot);
160 u->reserve_slot = NULL;
164 pa_reserve_wrapper_unref(u->reserve);
169 static void reserve_update(struct userdata *u) {
170 const char *description;
173 if (!u->source || !u->reserve)
176 if ((description = pa_proplist_gets(u->source->proplist, PA_PROP_DEVICE_DESCRIPTION)))
177 pa_reserve_wrapper_set_application_device_name(u->reserve, description);
180 static int reserve_init(struct userdata *u, const char *dname) {
189 if (pa_in_system_mode())
192 if (!(rname = pa_alsa_get_reserve_name(dname)))
195 /* We are resuming, try to lock the device */
196 u->reserve = pa_reserve_wrapper_get(u->core, rname);
204 pa_assert(!u->reserve_slot);
205 u->reserve_slot = pa_hook_connect(pa_reserve_wrapper_hook(u->reserve), PA_HOOK_NORMAL, (pa_hook_cb_t) reserve_cb, u);
210 static pa_hook_result_t monitor_cb(pa_reserve_monitor_wrapper *w, void* busy, struct userdata *u) {
216 b = PA_PTR_TO_UINT(busy) && !u->reserve;
218 pa_source_suspend(u->source, b, PA_SUSPEND_APPLICATION);
222 static void monitor_done(struct userdata *u) {
225 if (u->monitor_slot) {
226 pa_hook_slot_free(u->monitor_slot);
227 u->monitor_slot = NULL;
231 pa_reserve_monitor_wrapper_unref(u->monitor);
236 static int reserve_monitor_init(struct userdata *u, const char *dname) {
242 if (pa_in_system_mode())
245 if (!(rname = pa_alsa_get_reserve_name(dname)))
248 /* We are resuming, try to lock the device */
249 u->monitor = pa_reserve_monitor_wrapper_get(u->core, rname);
255 pa_assert(!u->monitor_slot);
256 u->monitor_slot = pa_hook_connect(pa_reserve_monitor_wrapper_hook(u->monitor), PA_HOOK_NORMAL, (pa_hook_cb_t) monitor_cb, u);
261 static void fix_min_sleep_wakeup(struct userdata *u) {
262 size_t max_use, max_use_2;
265 pa_assert(u->use_tsched);
267 max_use = u->hwbuf_size - u->hwbuf_unused;
268 max_use_2 = pa_frame_align(max_use/2, &u->source->sample_spec);
270 u->min_sleep = pa_usec_to_bytes(TSCHED_MIN_SLEEP_USEC, &u->source->sample_spec);
271 u->min_sleep = PA_CLAMP(u->min_sleep, u->frame_size, max_use_2);
273 u->min_wakeup = pa_usec_to_bytes(TSCHED_MIN_WAKEUP_USEC, &u->source->sample_spec);
274 u->min_wakeup = PA_CLAMP(u->min_wakeup, u->frame_size, max_use_2);
277 static void fix_tsched_watermark(struct userdata *u) {
280 pa_assert(u->use_tsched);
282 max_use = u->hwbuf_size - u->hwbuf_unused;
284 if (u->tsched_watermark > max_use - u->min_sleep)
285 u->tsched_watermark = max_use - u->min_sleep;
287 if (u->tsched_watermark < u->min_wakeup)
288 u->tsched_watermark = u->min_wakeup;
291 static void increase_watermark(struct userdata *u) {
292 size_t old_watermark;
293 pa_usec_t old_min_latency, new_min_latency;
296 pa_assert(u->use_tsched);
298 /* First, just try to increase the watermark */
299 old_watermark = u->tsched_watermark;
300 u->tsched_watermark = PA_MIN(u->tsched_watermark * 2, u->tsched_watermark + u->watermark_inc_step);
301 fix_tsched_watermark(u);
303 if (old_watermark != u->tsched_watermark) {
304 pa_log_info("Increasing wakeup watermark to %0.2f ms",
305 (double) pa_bytes_to_usec(u->tsched_watermark, &u->source->sample_spec) / PA_USEC_PER_MSEC);
309 /* Hmm, we cannot increase the watermark any further, hence let's
310 raise the latency unless doing so was disabled in
312 if (u->fixed_latency_range)
315 old_min_latency = u->source->thread_info.min_latency;
316 new_min_latency = PA_MIN(old_min_latency * 2, old_min_latency + TSCHED_WATERMARK_INC_STEP_USEC);
317 new_min_latency = PA_MIN(new_min_latency, u->source->thread_info.max_latency);
319 if (old_min_latency != new_min_latency) {
320 pa_log_info("Increasing minimal latency to %0.2f ms",
321 (double) new_min_latency / PA_USEC_PER_MSEC);
323 pa_source_set_latency_range_within_thread(u->source, new_min_latency, u->source->thread_info.max_latency);
326 /* When we reach this we're officialy fucked! */
329 static void decrease_watermark(struct userdata *u) {
330 size_t old_watermark;
334 pa_assert(u->use_tsched);
336 now = pa_rtclock_now();
338 if (u->watermark_dec_not_before <= 0)
341 if (u->watermark_dec_not_before > now)
344 old_watermark = u->tsched_watermark;
346 if (u->tsched_watermark < u->watermark_dec_step)
347 u->tsched_watermark = u->tsched_watermark / 2;
349 u->tsched_watermark = PA_MAX(u->tsched_watermark / 2, u->tsched_watermark - u->watermark_dec_step);
351 fix_tsched_watermark(u);
353 if (old_watermark != u->tsched_watermark)
354 pa_log_info("Decreasing wakeup watermark to %0.2f ms",
355 (double) pa_bytes_to_usec(u->tsched_watermark, &u->source->sample_spec) / PA_USEC_PER_MSEC);
357 /* We don't change the latency range*/
360 u->watermark_dec_not_before = now + TSCHED_WATERMARK_VERIFY_AFTER_USEC;
363 static void hw_sleep_time(struct userdata *u, pa_usec_t *sleep_usec, pa_usec_t*process_usec) {
366 pa_assert(sleep_usec);
367 pa_assert(process_usec);
370 pa_assert(u->use_tsched);
372 usec = pa_source_get_requested_latency_within_thread(u->source);
374 if (usec == (pa_usec_t) -1)
375 usec = pa_bytes_to_usec(u->hwbuf_size, &u->source->sample_spec);
377 wm = pa_bytes_to_usec(u->tsched_watermark, &u->source->sample_spec);
382 *sleep_usec = usec - wm;
386 pa_log_debug("Buffer time: %lu ms; Sleep time: %lu ms; Process time: %lu ms",
387 (unsigned long) (usec / PA_USEC_PER_MSEC),
388 (unsigned long) (*sleep_usec / PA_USEC_PER_MSEC),
389 (unsigned long) (*process_usec / PA_USEC_PER_MSEC));
393 static int try_recover(struct userdata *u, const char *call, int err) {
398 pa_log_debug("%s: %s", call, pa_alsa_strerror(err));
400 pa_assert(err != -EAGAIN);
403 pa_log_debug("%s: Buffer overrun!", call);
405 if (err == -ESTRPIPE)
406 pa_log_debug("%s: System suspended!", call);
408 if ((err = snd_pcm_recover(u->pcm_handle, err, 1)) < 0) {
409 pa_log("%s: %s", call, pa_alsa_strerror(err));
417 static size_t check_left_to_record(struct userdata *u, size_t n_bytes, pa_bool_t on_timeout) {
418 size_t left_to_record;
419 size_t rec_space = u->hwbuf_size - u->hwbuf_unused;
420 pa_bool_t overrun = FALSE;
422 /* We use <= instead of < for this check here because an overrun
423 * only happens after the last sample was processed, not already when
424 * it is removed from the buffer. This is particularly important
425 * when block transfer is used. */
427 if (n_bytes <= rec_space)
428 left_to_record = rec_space - n_bytes;
431 /* We got a dropout. What a mess! */
439 if (pa_log_ratelimit(PA_LOG_INFO))
440 pa_log_info("Overrun!");
444 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);
448 pa_bool_t reset_not_before = TRUE;
450 if (overrun || left_to_record < u->watermark_inc_threshold)
451 increase_watermark(u);
452 else if (left_to_record > u->watermark_dec_threshold) {
453 reset_not_before = FALSE;
455 /* We decrease the watermark only if have actually
456 * been woken up by a timeout. If something else woke
457 * us up it's too easy to fulfill the deadlines... */
460 decrease_watermark(u);
463 if (reset_not_before)
464 u->watermark_dec_not_before = 0;
467 return left_to_record;
470 static int mmap_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled, pa_bool_t on_timeout) {
471 pa_bool_t work_done = FALSE;
472 pa_usec_t max_sleep_usec = 0, process_usec = 0;
473 size_t left_to_record;
477 pa_source_assert_ref(u->source);
480 hw_sleep_time(u, &max_sleep_usec, &process_usec);
486 pa_bool_t after_avail = TRUE;
488 if (PA_UNLIKELY((n = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->source->sample_spec)) < 0)) {
490 if ((r = try_recover(u, "snd_pcm_avail", (int) n)) == 0)
496 n_bytes = (size_t) n * u->frame_size;
499 pa_log_debug("avail: %lu", (unsigned long) n_bytes);
502 left_to_record = check_left_to_record(u, n_bytes, on_timeout);
507 pa_bytes_to_usec(left_to_record, &u->source->sample_spec) > process_usec+max_sleep_usec/2) {
509 pa_log_debug("Not reading, because too early.");
514 if (PA_UNLIKELY(n_bytes <= 0)) {
518 char *dn = pa_alsa_get_driver_name_by_pcm(u->pcm_handle);
519 pa_log(_("ALSA woke us up to read new data from the device, but there was actually nothing to read!\n"
520 "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers.\n"
521 "We were woken up with POLLIN set -- however a subsequent snd_pcm_avail() returned 0 or another value < min_avail."),
527 pa_log_debug("Not reading, because not necessary.");
535 pa_log_debug("Not filling up, because already too many iterations.");
544 pa_log_debug("Reading");
551 const snd_pcm_channel_area_t *areas;
552 snd_pcm_uframes_t offset, frames;
553 snd_pcm_sframes_t sframes;
555 frames = (snd_pcm_uframes_t) (n_bytes / u->frame_size);
556 /* pa_log_debug("%lu frames to read", (unsigned long) frames); */
558 if (PA_UNLIKELY((err = pa_alsa_safe_mmap_begin(u->pcm_handle, &areas, &offset, &frames, u->hwbuf_size, &u->source->sample_spec)) < 0)) {
560 if (!after_avail && err == -EAGAIN)
563 if ((r = try_recover(u, "snd_pcm_mmap_begin", err)) == 0)
569 /* Make sure that if these memblocks need to be copied they will fit into one slot */
570 if (frames > pa_mempool_block_size_max(u->core->mempool)/u->frame_size)
571 frames = pa_mempool_block_size_max(u->core->mempool)/u->frame_size;
573 if (!after_avail && frames == 0)
576 pa_assert(frames > 0);
579 /* Check these are multiples of 8 bit */
580 pa_assert((areas[0].first & 7) == 0);
581 pa_assert((areas[0].step & 7)== 0);
583 /* We assume a single interleaved memory buffer */
584 pa_assert((areas[0].first >> 3) == 0);
585 pa_assert((areas[0].step >> 3) == u->frame_size);
587 p = (uint8_t*) areas[0].addr + (offset * u->frame_size);
589 chunk.memblock = pa_memblock_new_fixed(u->core->mempool, p, frames * u->frame_size, TRUE);
590 chunk.length = pa_memblock_get_length(chunk.memblock);
593 pa_source_post(u->source, &chunk);
594 pa_memblock_unref_fixed(chunk.memblock);
596 if (PA_UNLIKELY((sframes = snd_pcm_mmap_commit(u->pcm_handle, offset, frames)) < 0)) {
598 if ((r = try_recover(u, "snd_pcm_mmap_commit", (int) sframes)) == 0)
606 u->read_count += frames * u->frame_size;
609 pa_log_debug("Read %lu bytes (of possible %lu bytes)", (unsigned long) (frames * u->frame_size), (unsigned long) n_bytes);
612 if ((size_t) frames * u->frame_size >= n_bytes)
615 n_bytes -= (size_t) frames * u->frame_size;
620 *sleep_usec = pa_bytes_to_usec(left_to_record, &u->source->sample_spec);
621 process_usec = pa_bytes_to_usec(u->tsched_watermark, &u->source->sample_spec);
623 if (*sleep_usec > process_usec)
624 *sleep_usec -= process_usec;
629 return work_done ? 1 : 0;
632 static int unix_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled, pa_bool_t on_timeout) {
633 int work_done = FALSE;
634 pa_usec_t max_sleep_usec = 0, process_usec = 0;
635 size_t left_to_record;
639 pa_source_assert_ref(u->source);
642 hw_sleep_time(u, &max_sleep_usec, &process_usec);
648 pa_bool_t after_avail = TRUE;
650 if (PA_UNLIKELY((n = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->source->sample_spec)) < 0)) {
652 if ((r = try_recover(u, "snd_pcm_avail", (int) n)) == 0)
658 n_bytes = (size_t) n * u->frame_size;
659 left_to_record = check_left_to_record(u, n_bytes, on_timeout);
664 pa_bytes_to_usec(left_to_record, &u->source->sample_spec) > process_usec+max_sleep_usec/2)
667 if (PA_UNLIKELY(n_bytes <= 0)) {
671 char *dn = pa_alsa_get_driver_name_by_pcm(u->pcm_handle);
672 pa_log(_("ALSA woke us up to read new data from the device, but there was actually nothing to read!\n"
673 "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers.\n"
674 "We were woken up with POLLIN set -- however a subsequent snd_pcm_avail() returned 0 or another value < min_avail."),
684 pa_log_debug("Not filling up, because already too many iterations.");
694 snd_pcm_sframes_t frames;
697 chunk.memblock = pa_memblock_new(u->core->mempool, (size_t) -1);
699 frames = (snd_pcm_sframes_t) (pa_memblock_get_length(chunk.memblock) / u->frame_size);
701 if (frames > (snd_pcm_sframes_t) (n_bytes/u->frame_size))
702 frames = (snd_pcm_sframes_t) (n_bytes/u->frame_size);
704 /* pa_log_debug("%lu frames to read", (unsigned long) n); */
706 p = pa_memblock_acquire(chunk.memblock);
707 frames = snd_pcm_readi(u->pcm_handle, (uint8_t*) p, (snd_pcm_uframes_t) frames);
708 pa_memblock_release(chunk.memblock);
710 if (PA_UNLIKELY(frames < 0)) {
711 pa_memblock_unref(chunk.memblock);
713 if (!after_avail && (int) frames == -EAGAIN)
716 if ((r = try_recover(u, "snd_pcm_readi", (int) frames)) == 0)
722 if (!after_avail && frames == 0) {
723 pa_memblock_unref(chunk.memblock);
727 pa_assert(frames > 0);
731 chunk.length = (size_t) frames * u->frame_size;
733 pa_source_post(u->source, &chunk);
734 pa_memblock_unref(chunk.memblock);
738 u->read_count += frames * u->frame_size;
740 /* pa_log_debug("read %lu frames", (unsigned long) frames); */
742 if ((size_t) frames * u->frame_size >= n_bytes)
745 n_bytes -= (size_t) frames * u->frame_size;
750 *sleep_usec = pa_bytes_to_usec(left_to_record, &u->source->sample_spec);
751 process_usec = pa_bytes_to_usec(u->tsched_watermark, &u->source->sample_spec);
753 if (*sleep_usec > process_usec)
754 *sleep_usec -= process_usec;
759 return work_done ? 1 : 0;
762 static void update_smoother(struct userdata *u) {
763 snd_pcm_sframes_t delay = 0;
766 pa_usec_t now1 = 0, now2;
767 snd_pcm_status_t *status;
769 snd_pcm_status_alloca(&status);
772 pa_assert(u->pcm_handle);
774 /* Let's update the time smoother */
776 if (PA_UNLIKELY((err = pa_alsa_safe_delay(u->pcm_handle, &delay, u->hwbuf_size, &u->source->sample_spec, TRUE)) < 0)) {
777 pa_log_warn("Failed to get delay: %s", pa_alsa_strerror(err));
781 if (PA_UNLIKELY((err = snd_pcm_status(u->pcm_handle, status)) < 0))
782 pa_log_warn("Failed to get timestamp: %s", pa_alsa_strerror(err));
784 snd_htimestamp_t htstamp = { 0, 0 };
785 snd_pcm_status_get_htstamp(status, &htstamp);
786 now1 = pa_timespec_load(&htstamp);
789 /* Hmm, if the timestamp is 0, then it wasn't set and we take the current time */
791 now1 = pa_rtclock_now();
793 /* check if the time since the last update is bigger than the interval */
794 if (u->last_smoother_update > 0)
795 if (u->last_smoother_update + u->smoother_interval > now1)
798 position = u->read_count + ((uint64_t) delay * (uint64_t) u->frame_size);
799 now2 = pa_bytes_to_usec(position, &u->source->sample_spec);
801 pa_smoother_put(u->smoother, now1, now2);
803 u->last_smoother_update = now1;
804 /* exponentially increase the update interval up to the MAX limit */
805 u->smoother_interval = PA_MIN (u->smoother_interval * 2, SMOOTHER_MAX_INTERVAL);
808 static pa_usec_t source_get_latency(struct userdata *u) {
810 pa_usec_t now1, now2;
814 now1 = pa_rtclock_now();
815 now2 = pa_smoother_get(u->smoother, now1);
817 delay = (int64_t) now2 - (int64_t) pa_bytes_to_usec(u->read_count, &u->source->sample_spec);
819 return delay >= 0 ? (pa_usec_t) delay : 0;
822 static int build_pollfd(struct userdata *u) {
824 pa_assert(u->pcm_handle);
826 if (u->alsa_rtpoll_item)
827 pa_rtpoll_item_free(u->alsa_rtpoll_item);
829 if (!(u->alsa_rtpoll_item = pa_alsa_build_pollfd(u->pcm_handle, u->rtpoll)))
835 /* Called from IO context */
836 static int suspend(struct userdata *u) {
838 pa_assert(u->pcm_handle);
840 pa_smoother_pause(u->smoother, pa_rtclock_now());
843 snd_pcm_close(u->pcm_handle);
844 u->pcm_handle = NULL;
846 if (u->alsa_rtpoll_item) {
847 pa_rtpoll_item_free(u->alsa_rtpoll_item);
848 u->alsa_rtpoll_item = NULL;
851 pa_log_info("Device suspended...");
856 /* Called from IO context */
857 static int update_sw_params(struct userdata *u) {
858 snd_pcm_uframes_t avail_min;
863 /* Use the full buffer if no one asked us for anything specific */
869 if ((latency = pa_source_get_requested_latency_within_thread(u->source)) != (pa_usec_t) -1) {
872 pa_log_debug("latency set to %0.2fms", (double) latency / PA_USEC_PER_MSEC);
874 b = pa_usec_to_bytes(latency, &u->source->sample_spec);
876 /* We need at least one sample in our buffer */
878 if (PA_UNLIKELY(b < u->frame_size))
881 u->hwbuf_unused = PA_LIKELY(b < u->hwbuf_size) ? (u->hwbuf_size - b) : 0;
884 fix_min_sleep_wakeup(u);
885 fix_tsched_watermark(u);
888 pa_log_debug("hwbuf_unused=%lu", (unsigned long) u->hwbuf_unused);
893 pa_usec_t sleep_usec, process_usec;
895 hw_sleep_time(u, &sleep_usec, &process_usec);
896 avail_min += pa_usec_to_bytes(sleep_usec, &u->source->sample_spec) / u->frame_size;
899 pa_log_debug("setting avail_min=%lu", (unsigned long) avail_min);
901 if ((err = pa_alsa_set_sw_params(u->pcm_handle, avail_min, !u->use_tsched)) < 0) {
902 pa_log("Failed to set software parameters: %s", pa_alsa_strerror(err));
909 /* Called from IO Context on unsuspend or from main thread when creating source */
910 static void reset_watermark(struct userdata *u, size_t tsched_watermark, pa_sample_spec *ss,
913 u->tsched_watermark = pa_usec_to_bytes_round_up(pa_bytes_to_usec_round_up(tsched_watermark, ss),
914 &u->source->sample_spec);
916 u->watermark_inc_step = pa_usec_to_bytes(TSCHED_WATERMARK_INC_STEP_USEC, &u->source->sample_spec);
917 u->watermark_dec_step = pa_usec_to_bytes(TSCHED_WATERMARK_DEC_STEP_USEC, &u->source->sample_spec);
919 u->watermark_inc_threshold = pa_usec_to_bytes_round_up(TSCHED_WATERMARK_INC_THRESHOLD_USEC, &u->source->sample_spec);
920 u->watermark_dec_threshold = pa_usec_to_bytes_round_up(TSCHED_WATERMARK_DEC_THRESHOLD_USEC, &u->source->sample_spec);
922 fix_min_sleep_wakeup(u);
923 fix_tsched_watermark(u);
926 pa_source_set_latency_range_within_thread(u->source,
928 pa_bytes_to_usec(u->hwbuf_size, ss));
930 pa_source_set_latency_range(u->source,
932 pa_bytes_to_usec(u->hwbuf_size, ss));
934 /* work-around assert in pa_source_set_latency_within_thead,
935 keep track of min_latency and reuse it when
936 this routine is called from IO context */
937 u->min_latency_ref = u->source->thread_info.min_latency;
940 pa_log_info("Time scheduling watermark is %0.2fms",
941 (double) pa_bytes_to_usec(u->tsched_watermark, ss) / PA_USEC_PER_MSEC);
944 /* Called from IO context */
945 static int unsuspend(struct userdata *u) {
949 snd_pcm_uframes_t period_size, buffer_size;
952 pa_assert(!u->pcm_handle);
954 pa_log_info("Trying resume...");
956 if ((err = snd_pcm_open(&u->pcm_handle, u->device_name, SND_PCM_STREAM_CAPTURE,
958 SND_PCM_NO_AUTO_RESAMPLE|
959 SND_PCM_NO_AUTO_CHANNELS|
960 SND_PCM_NO_AUTO_FORMAT)) < 0) {
961 pa_log("Error opening PCM device %s: %s", u->device_name, pa_alsa_strerror(err));
965 ss = u->source->sample_spec;
966 period_size = u->fragment_size / u->frame_size;
967 buffer_size = u->hwbuf_size / u->frame_size;
971 if ((err = pa_alsa_set_hw_params(u->pcm_handle, &ss, &period_size, &buffer_size, 0, &b, &d, TRUE)) < 0) {
972 pa_log("Failed to set hardware parameters: %s", pa_alsa_strerror(err));
976 if (b != u->use_mmap || d != u->use_tsched) {
977 pa_log_warn("Resume failed, couldn't get original access mode.");
981 if (!pa_sample_spec_equal(&ss, &u->source->sample_spec)) {
982 pa_log_warn("Resume failed, couldn't restore original sample settings.");
986 if (period_size*u->frame_size != u->fragment_size ||
987 buffer_size*u->frame_size != u->hwbuf_size) {
988 pa_log_warn("Resume failed, couldn't restore original fragment settings. (Old: %lu/%lu, New %lu/%lu)",
989 (unsigned long) u->hwbuf_size, (unsigned long) u->fragment_size,
990 (unsigned long) (buffer_size*u->frame_size), (unsigned long) (period_size*u->frame_size));
994 if (update_sw_params(u) < 0)
997 if (build_pollfd(u) < 0)
1000 /* FIXME: We need to reload the volume somehow */
1003 pa_smoother_reset(u->smoother, pa_rtclock_now(), TRUE);
1004 u->smoother_interval = SMOOTHER_MIN_INTERVAL;
1005 u->last_smoother_update = 0;
1009 /* reset the watermark to the value defined when source was created */
1011 reset_watermark(u, u->tsched_watermark_ref, &u->source->sample_spec, TRUE);
1013 pa_log_info("Resumed successfully...");
1018 if (u->pcm_handle) {
1019 snd_pcm_close(u->pcm_handle);
1020 u->pcm_handle = NULL;
1026 /* Called from IO context */
1027 static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
1028 struct userdata *u = PA_SOURCE(o)->userdata;
1032 case PA_SOURCE_MESSAGE_GET_LATENCY: {
1036 r = source_get_latency(u);
1038 *((pa_usec_t*) data) = r;
1043 case PA_SOURCE_MESSAGE_SET_STATE:
1045 switch ((pa_source_state_t) PA_PTR_TO_UINT(data)) {
1047 case PA_SOURCE_SUSPENDED: {
1050 pa_assert(PA_SOURCE_IS_OPENED(u->source->thread_info.state));
1052 if ((r = suspend(u)) < 0)
1058 case PA_SOURCE_IDLE:
1059 case PA_SOURCE_RUNNING: {
1062 if (u->source->thread_info.state == PA_SOURCE_INIT) {
1063 if (build_pollfd(u) < 0)
1067 if (u->source->thread_info.state == PA_SOURCE_SUSPENDED) {
1068 if ((r = unsuspend(u)) < 0)
1075 case PA_SOURCE_UNLINKED:
1076 case PA_SOURCE_INIT:
1077 case PA_SOURCE_INVALID_STATE:
1084 return pa_source_process_msg(o, code, data, offset, chunk);
1087 /* Called from main context */
1088 static int source_set_state_cb(pa_source *s, pa_source_state_t new_state) {
1089 pa_source_state_t old_state;
1092 pa_source_assert_ref(s);
1093 pa_assert_se(u = s->userdata);
1095 old_state = pa_source_get_state(u->source);
1097 if (PA_SOURCE_IS_OPENED(old_state) && new_state == PA_SOURCE_SUSPENDED)
1099 else if (old_state == PA_SOURCE_SUSPENDED && PA_SOURCE_IS_OPENED(new_state))
1100 if (reserve_init(u, u->device_name) < 0)
1101 return -PA_ERR_BUSY;
1106 static int ctl_mixer_callback(snd_mixer_elem_t *elem, unsigned int mask) {
1107 struct userdata *u = snd_mixer_elem_get_callback_private(elem);
1110 pa_assert(u->mixer_handle);
1112 if (mask == SND_CTL_EVENT_MASK_REMOVE)
1115 if (!PA_SOURCE_IS_LINKED(u->source->state))
1118 if (u->source->suspend_cause & PA_SUSPEND_SESSION)
1121 if (mask & SND_CTL_EVENT_MASK_VALUE) {
1122 pa_source_get_volume(u->source, TRUE);
1123 pa_source_get_mute(u->source, TRUE);
1129 static int io_mixer_callback(snd_mixer_elem_t *elem, unsigned int mask) {
1130 struct userdata *u = snd_mixer_elem_get_callback_private(elem);
1133 pa_assert(u->mixer_handle);
1135 if (mask == SND_CTL_EVENT_MASK_REMOVE)
1138 if (u->source->suspend_cause & PA_SUSPEND_SESSION)
1141 if (mask & SND_CTL_EVENT_MASK_VALUE)
1142 pa_source_update_volume_and_mute(u->source);
1147 static void source_get_volume_cb(pa_source *s) {
1148 struct userdata *u = s->userdata;
1150 char vol_str_pcnt[PA_CVOLUME_SNPRINT_MAX];
1153 pa_assert(u->mixer_path);
1154 pa_assert(u->mixer_handle);
1156 if (pa_alsa_path_get_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r) < 0)
1159 /* Shift down by the base volume, so that 0dB becomes maximum volume */
1160 pa_sw_cvolume_multiply_scalar(&r, &r, s->base_volume);
1162 pa_log_debug("Read hardware volume: %s", pa_cvolume_snprint(vol_str_pcnt, sizeof(vol_str_pcnt), &r));
1164 if (u->mixer_path->has_dB) {
1165 char vol_str_db[PA_SW_CVOLUME_SNPRINT_DB_MAX];
1167 pa_log_debug(" in dB: %s", pa_sw_cvolume_snprint_dB(vol_str_db, sizeof(vol_str_db), &r));
1170 if (pa_cvolume_equal(&u->hardware_volume, &r))
1173 s->real_volume = u->hardware_volume = r;
1175 /* Hmm, so the hardware volume changed, let's reset our software volume */
1176 if (u->mixer_path->has_dB)
1177 pa_source_set_soft_volume(s, NULL);
1180 static void source_set_volume_cb(pa_source *s) {
1181 struct userdata *u = s->userdata;
1183 char vol_str_pcnt[PA_CVOLUME_SNPRINT_MAX];
1184 pa_bool_t deferred_volume = !!(s->flags & PA_SOURCE_DEFERRED_VOLUME);
1187 pa_assert(u->mixer_path);
1188 pa_assert(u->mixer_handle);
1190 /* Shift up by the base volume */
1191 pa_sw_cvolume_divide_scalar(&r, &s->real_volume, s->base_volume);
1193 if (pa_alsa_path_set_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r, deferred_volume, !deferred_volume) < 0)
1196 /* Shift down by the base volume, so that 0dB becomes maximum volume */
1197 pa_sw_cvolume_multiply_scalar(&r, &r, s->base_volume);
1199 u->hardware_volume = r;
1201 if (u->mixer_path->has_dB) {
1202 pa_cvolume new_soft_volume;
1203 pa_bool_t accurate_enough;
1204 char vol_str_db[PA_SW_CVOLUME_SNPRINT_DB_MAX];
1206 /* Match exactly what the user requested by software */
1207 pa_sw_cvolume_divide(&new_soft_volume, &s->real_volume, &u->hardware_volume);
1209 /* If the adjustment to do in software is only minimal we
1210 * can skip it. That saves us CPU at the expense of a bit of
1213 (pa_cvolume_min(&new_soft_volume) >= (PA_VOLUME_NORM - VOLUME_ACCURACY)) &&
1214 (pa_cvolume_max(&new_soft_volume) <= (PA_VOLUME_NORM + VOLUME_ACCURACY));
1216 pa_log_debug("Requested volume: %s", pa_cvolume_snprint(vol_str_pcnt, sizeof(vol_str_pcnt), &s->real_volume));
1217 pa_log_debug(" in dB: %s", pa_sw_cvolume_snprint_dB(vol_str_db, sizeof(vol_str_db), &s->real_volume));
1218 pa_log_debug("Got hardware volume: %s", pa_cvolume_snprint(vol_str_pcnt, sizeof(vol_str_pcnt), &u->hardware_volume));
1219 pa_log_debug(" in dB: %s", pa_sw_cvolume_snprint_dB(vol_str_db, sizeof(vol_str_db), &u->hardware_volume));
1220 pa_log_debug("Calculated software volume: %s (accurate-enough=%s)",
1221 pa_cvolume_snprint(vol_str_pcnt, sizeof(vol_str_pcnt), &new_soft_volume),
1222 pa_yes_no(accurate_enough));
1223 pa_log_debug(" in dB: %s", pa_sw_cvolume_snprint_dB(vol_str_db, sizeof(vol_str_db), &new_soft_volume));
1225 if (!accurate_enough)
1226 s->soft_volume = new_soft_volume;
1229 pa_log_debug("Wrote hardware volume: %s", pa_cvolume_snprint(vol_str_pcnt, sizeof(vol_str_pcnt), &r));
1231 /* We can't match exactly what the user requested, hence let's
1232 * at least tell the user about it */
1238 static void source_write_volume_cb(pa_source *s) {
1239 struct userdata *u = s->userdata;
1240 pa_cvolume hw_vol = s->thread_info.current_hw_volume;
1243 pa_assert(u->mixer_path);
1244 pa_assert(u->mixer_handle);
1245 pa_assert(s->flags & PA_SOURCE_DEFERRED_VOLUME);
1247 /* Shift up by the base volume */
1248 pa_sw_cvolume_divide_scalar(&hw_vol, &hw_vol, s->base_volume);
1250 if (pa_alsa_path_set_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &hw_vol, TRUE, TRUE) < 0)
1251 pa_log_error("Writing HW volume failed");
1254 pa_bool_t accurate_enough;
1256 /* Shift down by the base volume, so that 0dB becomes maximum volume */
1257 pa_sw_cvolume_multiply_scalar(&hw_vol, &hw_vol, s->base_volume);
1259 pa_sw_cvolume_divide(&tmp_vol, &hw_vol, &s->thread_info.current_hw_volume);
1261 (pa_cvolume_min(&tmp_vol) >= (PA_VOLUME_NORM - VOLUME_ACCURACY)) &&
1262 (pa_cvolume_max(&tmp_vol) <= (PA_VOLUME_NORM + VOLUME_ACCURACY));
1264 if (!accurate_enough) {
1266 char db[2][PA_SW_CVOLUME_SNPRINT_DB_MAX];
1267 char pcnt[2][PA_CVOLUME_SNPRINT_MAX];
1270 pa_log_debug("Written HW volume did not match with the request: %s (request) != %s",
1271 pa_cvolume_snprint(vol.pcnt[0], sizeof(vol.pcnt[0]), &s->thread_info.current_hw_volume),
1272 pa_cvolume_snprint(vol.pcnt[1], sizeof(vol.pcnt[1]), &hw_vol));
1273 pa_log_debug(" in dB: %s (request) != %s",
1274 pa_sw_cvolume_snprint_dB(vol.db[0], sizeof(vol.db[0]), &s->thread_info.current_hw_volume),
1275 pa_sw_cvolume_snprint_dB(vol.db[1], sizeof(vol.db[1]), &hw_vol));
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 synchronous 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_cb(pa_source *s, pa_device_port *p) {
1354 struct userdata *u = s->userdata;
1355 pa_alsa_port_data *data;
1359 pa_assert(u->mixer_handle);
1361 data = PA_DEVICE_PORT_DATA(p);
1363 pa_assert_se(u->mixer_path = data->path);
1364 pa_alsa_path_select(u->mixer_path, u->mixer_handle);
1366 mixer_volume_init(u);
1369 pa_alsa_setting_select(data->setting, u->mixer_handle);
1379 static void source_update_requested_latency_cb(pa_source *s) {
1380 struct userdata *u = s->userdata;
1382 pa_assert(u->use_tsched); /* only when timer scheduling is used
1383 * we can dynamically adjust the
1389 update_sw_params(u);
1392 static pa_bool_t source_update_rate_cb(pa_source *s, uint32_t rate)
1394 struct userdata *u = s->userdata;
1396 pa_bool_t supported = FALSE;
1400 for (i = 0; u->rates[i]; i++) {
1401 if (u->rates[i] == rate) {
1408 pa_log_info("Sink does not support sample rate of %d Hz", rate);
1412 if (!PA_SOURCE_IS_OPENED(s->state)) {
1413 pa_log_info("Updating rate for device %s, new rate is %d", u->device_name, rate);
1414 u->source->sample_spec.rate = rate;
1421 static void thread_func(void *userdata) {
1422 struct userdata *u = userdata;
1423 unsigned short revents = 0;
1427 pa_log_debug("Thread starting up");
1429 if (u->core->realtime_scheduling)
1430 pa_make_realtime(u->core->realtime_priority);
1432 pa_thread_mq_install(&u->thread_mq);
1436 pa_usec_t rtpoll_sleep = 0;
1439 pa_log_debug("Loop");
1442 /* Read some data and pass it to the sources */
1443 if (PA_SOURCE_IS_OPENED(u->source->thread_info.state)) {
1445 pa_usec_t sleep_usec = 0;
1446 pa_bool_t on_timeout = pa_rtpoll_timer_elapsed(u->rtpoll);
1449 pa_log_info("Starting capture.");
1450 snd_pcm_start(u->pcm_handle);
1452 pa_smoother_resume(u->smoother, pa_rtclock_now(), TRUE);
1458 work_done = mmap_read(u, &sleep_usec, revents & POLLIN, on_timeout);
1460 work_done = unix_read(u, &sleep_usec, revents & POLLIN, on_timeout);
1465 /* pa_log_debug("work_done = %i", work_done); */
1470 if (u->use_tsched) {
1473 /* OK, the capture buffer is now empty, let's
1474 * calculate when to wake up next */
1476 /* pa_log_debug("Waking up in %0.2fms (sound card clock).", (double) sleep_usec / PA_USEC_PER_MSEC); */
1478 /* Convert from the sound card time domain to the
1479 * system time domain */
1480 cusec = pa_smoother_translate(u->smoother, pa_rtclock_now(), sleep_usec);
1482 /* pa_log_debug("Waking up in %0.2fms (system clock).", (double) cusec / PA_USEC_PER_MSEC); */
1484 /* We don't trust the conversion, so we wake up whatever comes first */
1485 rtpoll_sleep = PA_MIN(sleep_usec, cusec);
1489 if (u->source->flags & PA_SOURCE_DEFERRED_VOLUME) {
1490 pa_usec_t volume_sleep;
1491 pa_source_volume_change_apply(u->source, &volume_sleep);
1492 if (volume_sleep > 0) {
1493 if (rtpoll_sleep > 0)
1494 rtpoll_sleep = PA_MIN(volume_sleep, rtpoll_sleep);
1496 rtpoll_sleep = volume_sleep;
1500 if (rtpoll_sleep > 0)
1501 pa_rtpoll_set_timer_relative(u->rtpoll, rtpoll_sleep);
1503 pa_rtpoll_set_timer_disabled(u->rtpoll);
1505 /* Hmm, nothing to do. Let's sleep */
1506 if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
1509 if (u->source->flags & PA_SOURCE_DEFERRED_VOLUME)
1510 pa_source_volume_change_apply(u->source, NULL);
1515 /* Tell ALSA about this and process its response */
1516 if (PA_SOURCE_IS_OPENED(u->source->thread_info.state)) {
1517 struct pollfd *pollfd;
1521 pollfd = pa_rtpoll_item_get_pollfd(u->alsa_rtpoll_item, &n);
1523 if ((err = snd_pcm_poll_descriptors_revents(u->pcm_handle, pollfd, n, &revents)) < 0) {
1524 pa_log("snd_pcm_poll_descriptors_revents() failed: %s", pa_alsa_strerror(err));
1528 if (revents & ~POLLIN) {
1529 if (pa_alsa_recover_from_poll(u->pcm_handle, revents) < 0)
1534 } else if (revents && u->use_tsched && pa_log_ratelimit(PA_LOG_DEBUG))
1535 pa_log_debug("Wakeup from ALSA!");
1542 /* If this was no regular exit from the loop we have to continue
1543 * processing messages until we received PA_MESSAGE_SHUTDOWN */
1544 pa_asyncmsgq_post(u->thread_mq.outq, PA_MSGOBJECT(u->core), PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0, NULL, NULL);
1545 pa_asyncmsgq_wait_for(u->thread_mq.inq, PA_MESSAGE_SHUTDOWN);
1548 pa_log_debug("Thread shutting down");
1551 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) {
1557 pa_assert(device_name);
1559 if ((n = pa_modargs_get_value(ma, "source_name", NULL))) {
1560 pa_source_new_data_set_name(data, n);
1561 data->namereg_fail = TRUE;
1565 if ((n = pa_modargs_get_value(ma, "name", NULL)))
1566 data->namereg_fail = TRUE;
1568 n = device_id ? device_id : device_name;
1569 data->namereg_fail = FALSE;
1573 t = pa_sprintf_malloc("alsa_input.%s.%s", n, mapping->name);
1575 t = pa_sprintf_malloc("alsa_input.%s", n);
1577 pa_source_new_data_set_name(data, t);
1581 static void find_mixer(struct userdata *u, pa_alsa_mapping *mapping, const char *element, pa_bool_t ignore_dB) {
1583 if (!mapping && !element)
1586 if (!(u->mixer_handle = pa_alsa_open_mixer_for_pcm(u->pcm_handle, &u->control_device))) {
1587 pa_log_info("Failed to find a working mixer device.");
1593 if (!(u->mixer_path = pa_alsa_path_synthesize(element, PA_ALSA_DIRECTION_INPUT)))
1596 if (pa_alsa_path_probe(u->mixer_path, u->mixer_handle, ignore_dB) < 0)
1599 pa_log_debug("Probed mixer path %s:", u->mixer_path->name);
1600 pa_alsa_path_dump(u->mixer_path);
1603 if (!(u->mixer_path_set = pa_alsa_path_set_new(mapping, PA_ALSA_DIRECTION_INPUT, u->paths_dir)))
1606 pa_alsa_path_set_probe(u->mixer_path_set, u->mixer_handle, ignore_dB);
1613 if (u->mixer_path_set) {
1614 pa_alsa_path_set_free(u->mixer_path_set);
1615 u->mixer_path_set = NULL;
1616 } else if (u->mixer_path) {
1617 pa_alsa_path_free(u->mixer_path);
1618 u->mixer_path = NULL;
1621 if (u->mixer_handle) {
1622 snd_mixer_close(u->mixer_handle);
1623 u->mixer_handle = NULL;
1627 static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB) {
1628 pa_bool_t need_mixer_callback = FALSE;
1632 if (!u->mixer_handle)
1635 if (u->source->active_port) {
1636 pa_alsa_port_data *data;
1638 /* We have a list of supported paths, so let's activate the
1639 * one that has been chosen as active */
1641 data = PA_DEVICE_PORT_DATA(u->source->active_port);
1642 u->mixer_path = data->path;
1644 pa_alsa_path_select(data->path, u->mixer_handle);
1647 pa_alsa_setting_select(data->setting, u->mixer_handle);
1651 if (!u->mixer_path && u->mixer_path_set)
1652 u->mixer_path = u->mixer_path_set->paths;
1654 if (u->mixer_path) {
1655 /* Hmm, we have only a single path, then let's activate it */
1657 pa_alsa_path_select(u->mixer_path, u->mixer_handle);
1659 if (u->mixer_path->settings)
1660 pa_alsa_setting_select(u->mixer_path->settings, u->mixer_handle);
1665 mixer_volume_init(u);
1667 /* Will we need to register callbacks? */
1668 if (u->mixer_path_set && u->mixer_path_set->paths) {
1671 PA_LLIST_FOREACH(p, u->mixer_path_set->paths) {
1672 if (p->has_volume || p->has_mute)
1673 need_mixer_callback = TRUE;
1676 else if (u->mixer_path)
1677 need_mixer_callback = u->mixer_path->has_volume || u->mixer_path->has_mute;
1679 if (need_mixer_callback) {
1680 int (*mixer_callback)(snd_mixer_elem_t *, unsigned int);
1681 if (u->source->flags & PA_SOURCE_DEFERRED_VOLUME) {
1682 u->mixer_pd = pa_alsa_mixer_pdata_new();
1683 mixer_callback = io_mixer_callback;
1685 if (pa_alsa_set_mixer_rtpoll(u->mixer_pd, u->mixer_handle, u->rtpoll) < 0) {
1686 pa_log("Failed to initialize file descriptor monitoring");
1690 u->mixer_fdl = pa_alsa_fdlist_new();
1691 mixer_callback = ctl_mixer_callback;
1693 if (pa_alsa_fdlist_set_mixer(u->mixer_fdl, u->mixer_handle, u->core->mainloop) < 0) {
1694 pa_log("Failed to initialize file descriptor monitoring");
1699 if (u->mixer_path_set)
1700 pa_alsa_path_set_set_callback(u->mixer_path_set, u->mixer_handle, mixer_callback, u);
1702 pa_alsa_path_set_callback(u->mixer_path, u->mixer_handle, mixer_callback, u);
1708 pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, pa_card *card, pa_alsa_mapping *mapping) {
1710 struct userdata *u = NULL;
1711 const char *dev_id = NULL;
1713 uint32_t alternate_sample_rate;
1715 uint32_t nfrags, frag_size, buffer_size, tsched_size, tsched_watermark;
1716 snd_pcm_uframes_t period_frames, buffer_frames, tsched_frames;
1718 pa_bool_t use_mmap = TRUE, b, use_tsched = TRUE, d, ignore_dB = FALSE, namereg_fail = FALSE, deferred_volume = FALSE, fixed_latency_range = FALSE;
1719 pa_source_new_data data;
1720 pa_alsa_profile_set *profile_set = NULL;
1725 ss = m->core->default_sample_spec;
1726 map = m->core->default_channel_map;
1727 if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_ALSA) < 0) {
1728 pa_log("Failed to parse sample specification and channel map");
1732 alternate_sample_rate = m->core->alternate_sample_rate;
1733 if (pa_modargs_get_alternate_sample_rate(ma, &alternate_sample_rate) < 0) {
1734 pa_log("Failed to parse alternate sample rate");
1738 frame_size = pa_frame_size(&ss);
1740 nfrags = m->core->default_n_fragments;
1741 frag_size = (uint32_t) pa_usec_to_bytes(m->core->default_fragment_size_msec*PA_USEC_PER_MSEC, &ss);
1743 frag_size = (uint32_t) frame_size;
1744 tsched_size = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_BUFFER_USEC, &ss);
1745 tsched_watermark = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_WATERMARK_USEC, &ss);
1747 if (pa_modargs_get_value_u32(ma, "fragments", &nfrags) < 0 ||
1748 pa_modargs_get_value_u32(ma, "fragment_size", &frag_size) < 0 ||
1749 pa_modargs_get_value_u32(ma, "tsched_buffer_size", &tsched_size) < 0 ||
1750 pa_modargs_get_value_u32(ma, "tsched_buffer_watermark", &tsched_watermark) < 0) {
1751 pa_log("Failed to parse buffer metrics");
1755 buffer_size = nfrags * frag_size;
1757 period_frames = frag_size/frame_size;
1758 buffer_frames = buffer_size/frame_size;
1759 tsched_frames = tsched_size/frame_size;
1761 if (pa_modargs_get_value_boolean(ma, "mmap", &use_mmap) < 0) {
1762 pa_log("Failed to parse mmap argument.");
1766 if (pa_modargs_get_value_boolean(ma, "tsched", &use_tsched) < 0) {
1767 pa_log("Failed to parse tsched argument.");
1771 if (pa_modargs_get_value_boolean(ma, "ignore_dB", &ignore_dB) < 0) {
1772 pa_log("Failed to parse ignore_dB argument.");
1776 deferred_volume = m->core->deferred_volume;
1777 if (pa_modargs_get_value_boolean(ma, "deferred_volume", &deferred_volume) < 0) {
1778 pa_log("Failed to parse deferred_volume argument.");
1782 if (pa_modargs_get_value_boolean(ma, "fixed_latency_range", &fixed_latency_range) < 0) {
1783 pa_log("Failed to parse fixed_latency_range argument.");
1787 use_tsched = pa_alsa_may_tsched(use_tsched);
1789 u = pa_xnew0(struct userdata, 1);
1792 u->use_mmap = use_mmap;
1793 u->use_tsched = use_tsched;
1794 u->deferred_volume = deferred_volume;
1795 u->fixed_latency_range = fixed_latency_range;
1797 u->rtpoll = pa_rtpoll_new();
1798 pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
1800 u->smoother = pa_smoother_new(
1801 SMOOTHER_ADJUST_USEC,
1802 SMOOTHER_WINDOW_USEC,
1808 u->smoother_interval = SMOOTHER_MIN_INTERVAL;
1810 dev_id = pa_modargs_get_value(
1812 pa_modargs_get_value(ma, "device", DEFAULT_DEVICE));
1814 u->paths_dir = pa_xstrdup(pa_modargs_get_value(ma, "paths_dir", NULL));
1816 if (reserve_init(u, dev_id) < 0)
1819 if (reserve_monitor_init(u, dev_id) < 0)
1827 if (!(dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
1828 pa_log("device_id= not set");
1832 if (!(u->pcm_handle = pa_alsa_open_by_device_id_mapping(
1836 SND_PCM_STREAM_CAPTURE,
1837 &period_frames, &buffer_frames, tsched_frames,
1841 } else if ((dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
1843 if (!(profile_set = pa_alsa_profile_set_new(NULL, &map)))
1846 if (!(u->pcm_handle = pa_alsa_open_by_device_id_auto(
1850 SND_PCM_STREAM_CAPTURE,
1851 &period_frames, &buffer_frames, tsched_frames,
1852 &b, &d, profile_set, &mapping)))
1857 if (!(u->pcm_handle = pa_alsa_open_by_device_string(
1858 pa_modargs_get_value(ma, "device", DEFAULT_DEVICE),
1861 SND_PCM_STREAM_CAPTURE,
1862 &period_frames, &buffer_frames, tsched_frames,
1867 pa_assert(u->device_name);
1868 pa_log_info("Successfully opened device %s.", u->device_name);
1870 if (pa_alsa_pcm_is_modem(u->pcm_handle)) {
1871 pa_log_notice("Device %s is modem, refusing further initialization.", u->device_name);
1876 pa_log_info("Selected mapping '%s' (%s).", mapping->description, mapping->name);
1878 if (use_mmap && !b) {
1879 pa_log_info("Device doesn't support mmap(), falling back to UNIX read/write mode.");
1880 u->use_mmap = use_mmap = FALSE;
1883 if (use_tsched && (!b || !d)) {
1884 pa_log_info("Cannot enable timer-based scheduling, falling back to sound IRQ scheduling.");
1885 u->use_tsched = use_tsched = FALSE;
1889 pa_log_info("Successfully enabled mmap() mode.");
1891 if (u->use_tsched) {
1892 pa_log_info("Successfully enabled timer-based scheduling mode.");
1893 if (u->fixed_latency_range)
1894 pa_log_info("Disabling latency range changes on overrun");
1897 u->rates = pa_alsa_get_supported_rates(u->pcm_handle);
1899 pa_log_error("Failed to find any supported sample rates.");
1903 /* ALSA might tweak the sample spec, so recalculate the frame size */
1904 frame_size = pa_frame_size(&ss);
1906 find_mixer(u, mapping, pa_modargs_get_value(ma, "control", NULL), ignore_dB);
1908 pa_source_new_data_init(&data);
1909 data.driver = driver;
1912 set_source_name(&data, ma, dev_id, u->device_name, mapping);
1914 /* We need to give pa_modargs_get_value_boolean() a pointer to a local
1915 * variable instead of using &data.namereg_fail directly, because
1916 * data.namereg_fail is a bitfield and taking the address of a bitfield
1917 * variable is impossible. */
1918 namereg_fail = data.namereg_fail;
1919 if (pa_modargs_get_value_boolean(ma, "namereg_fail", &namereg_fail) < 0) {
1920 pa_log("Failed to parse namereg_fail argument.");
1921 pa_source_new_data_done(&data);
1924 data.namereg_fail = namereg_fail;
1926 pa_source_new_data_set_sample_spec(&data, &ss);
1927 pa_source_new_data_set_channel_map(&data, &map);
1928 pa_source_new_data_set_alternate_sample_rate(&data, alternate_sample_rate);
1930 pa_alsa_init_proplist_pcm(m->core, data.proplist, u->pcm_handle);
1931 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, u->device_name);
1932 pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_BUFFER_SIZE, "%lu", (unsigned long) (buffer_frames * frame_size));
1933 pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZE, "%lu", (unsigned long) (period_frames * frame_size));
1934 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_ACCESS_MODE, u->use_tsched ? "mmap+timer" : (u->use_mmap ? "mmap" : "serial"));
1937 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_NAME, mapping->name);
1938 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_DESCRIPTION, mapping->description);
1941 pa_alsa_init_description(data.proplist);
1943 if (u->control_device)
1944 pa_alsa_init_proplist_ctl(data.proplist, u->control_device);
1946 if (pa_modargs_get_proplist(ma, "source_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
1947 pa_log("Invalid properties");
1948 pa_source_new_data_done(&data);
1952 if (u->mixer_path_set)
1953 pa_alsa_add_ports(u->core, &data.ports, u->mixer_path_set);
1955 u->source = pa_source_new(m->core, &data, PA_SOURCE_HARDWARE|PA_SOURCE_LATENCY|(u->use_tsched ? PA_SOURCE_DYNAMIC_LATENCY : 0));
1956 pa_source_new_data_done(&data);
1959 pa_log("Failed to create source object");
1963 if (pa_modargs_get_value_u32(ma, "deferred_volume_safety_margin",
1964 &u->source->thread_info.volume_change_safety_margin) < 0) {
1965 pa_log("Failed to parse deferred_volume_safety_margin parameter");
1969 if (pa_modargs_get_value_s32(ma, "deferred_volume_extra_delay",
1970 &u->source->thread_info.volume_change_extra_delay) < 0) {
1971 pa_log("Failed to parse deferred_volume_extra_delay parameter");
1975 u->source->parent.process_msg = source_process_msg;
1977 u->source->update_requested_latency = source_update_requested_latency_cb;
1978 u->source->set_state = source_set_state_cb;
1979 u->source->set_port = source_set_port_cb;
1980 if (u->source->alternate_sample_rate)
1981 u->source->update_rate = source_update_rate_cb;
1982 u->source->userdata = u;
1984 pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
1985 pa_source_set_rtpoll(u->source, u->rtpoll);
1987 u->frame_size = frame_size;
1988 u->fragment_size = frag_size = (size_t) (period_frames * frame_size);
1989 u->hwbuf_size = buffer_size = (size_t) (buffer_frames * frame_size);
1990 pa_cvolume_mute(&u->hardware_volume, u->source->sample_spec.channels);
1992 pa_log_info("Using %0.1f fragments of size %lu bytes (%0.2fms), buffer size is %lu bytes (%0.2fms)",
1993 (double) u->hwbuf_size / (double) u->fragment_size,
1994 (long unsigned) u->fragment_size,
1995 (double) pa_bytes_to_usec(u->fragment_size, &ss) / PA_USEC_PER_MSEC,
1996 (long unsigned) u->hwbuf_size,
1997 (double) pa_bytes_to_usec(u->hwbuf_size, &ss) / PA_USEC_PER_MSEC);
1999 if (u->use_tsched) {
2000 u->tsched_watermark_ref = tsched_watermark;
2001 reset_watermark(u, u->tsched_watermark_ref, &ss, FALSE);
2004 pa_source_set_fixed_latency(u->source, pa_bytes_to_usec(u->hwbuf_size, &ss));
2008 if (update_sw_params(u) < 0)
2011 if (setup_mixer(u, ignore_dB) < 0)
2014 pa_alsa_dump(PA_LOG_DEBUG, u->pcm_handle);
2016 if (!(u->thread = pa_thread_new("alsa-source", thread_func, u))) {
2017 pa_log("Failed to create thread.");
2021 /* Get initial mixer settings */
2022 if (data.volume_is_set) {
2023 if (u->source->set_volume)
2024 u->source->set_volume(u->source);
2026 if (u->source->get_volume)
2027 u->source->get_volume(u->source);
2030 if (data.muted_is_set) {
2031 if (u->source->set_mute)
2032 u->source->set_mute(u->source);
2034 if (u->source->get_mute)
2035 u->source->get_mute(u->source);
2038 if ((data.volume_is_set || data.muted_is_set) && u->source->write_volume)
2039 u->source->write_volume(u->source);
2041 pa_source_put(u->source);
2044 pa_alsa_profile_set_free(profile_set);
2054 pa_alsa_profile_set_free(profile_set);
2059 static void userdata_free(struct userdata *u) {
2063 pa_source_unlink(u->source);
2066 pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
2067 pa_thread_free(u->thread);
2070 pa_thread_mq_done(&u->thread_mq);
2073 pa_source_unref(u->source);
2076 pa_alsa_mixer_pdata_free(u->mixer_pd);
2078 if (u->alsa_rtpoll_item)
2079 pa_rtpoll_item_free(u->alsa_rtpoll_item);
2082 pa_rtpoll_free(u->rtpoll);
2084 if (u->pcm_handle) {
2085 snd_pcm_drop(u->pcm_handle);
2086 snd_pcm_close(u->pcm_handle);
2090 pa_alsa_fdlist_free(u->mixer_fdl);
2092 if (u->mixer_path_set)
2093 pa_alsa_path_set_free(u->mixer_path_set);
2094 else if (u->mixer_path)
2095 pa_alsa_path_free(u->mixer_path);
2097 if (u->mixer_handle)
2098 snd_mixer_close(u->mixer_handle);
2101 pa_smoother_free(u->smoother);
2109 pa_xfree(u->device_name);
2110 pa_xfree(u->control_device);
2111 pa_xfree(u->paths_dir);
2115 void pa_alsa_source_free(pa_source *s) {
2118 pa_source_assert_ref(s);
2119 pa_assert_se(u = s->userdata);