2 This file is part of PulseAudio.
4 Copyright 2004-2008 Lennart Poettering
5 Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
7 PulseAudio is free software; you can redistribute it and/or modify
8 it under the terms of the GNU Lesser General Public License as published
9 by the Free Software Foundation; either version 2.1 of the License,
10 or (at your option) any later version.
12 PulseAudio is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public License
18 along with PulseAudio; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
29 #include <asoundlib.h>
31 #ifdef HAVE_VALGRIND_MEMCHECK_H
32 #include <valgrind/memcheck.h>
35 #include <pulse/xmalloc.h>
36 #include <pulse/util.h>
37 #include <pulse/timeval.h>
38 #include <pulse/i18n.h>
40 #include <pulsecore/core-error.h>
41 #include <pulsecore/core.h>
42 #include <pulsecore/module.h>
43 #include <pulsecore/memchunk.h>
44 #include <pulsecore/sink.h>
45 #include <pulsecore/modargs.h>
46 #include <pulsecore/core-util.h>
47 #include <pulsecore/sample-util.h>
48 #include <pulsecore/log.h>
49 #include <pulsecore/macro.h>
50 #include <pulsecore/thread.h>
51 #include <pulsecore/core-error.h>
52 #include <pulsecore/thread-mq.h>
53 #include <pulsecore/rtpoll.h>
54 #include <pulsecore/time-smoother.h>
55 #include <pulsecore/rtclock.h>
57 #include <modules/reserve-wrap.h>
59 #include "alsa-util.h"
60 #include "alsa-source.h"
62 /* #define DEBUG_TIMING */
64 #define DEFAULT_DEVICE "default"
65 #define DEFAULT_TSCHED_BUFFER_USEC (2*PA_USEC_PER_SEC) /* 2s */
66 #define DEFAULT_TSCHED_WATERMARK_USEC (20*PA_USEC_PER_MSEC) /* 20ms */
67 #define TSCHED_WATERMARK_STEP_USEC (10*PA_USEC_PER_MSEC) /* 10ms */
68 #define TSCHED_MIN_SLEEP_USEC (10*PA_USEC_PER_MSEC) /* 10ms */
69 #define TSCHED_MIN_WAKEUP_USEC (4*PA_USEC_PER_MSEC) /* 4ms */
77 pa_thread_mq thread_mq;
80 snd_pcm_t *pcm_handle;
82 pa_alsa_fdlist *mixer_fdl;
83 snd_mixer_t *mixer_handle;
84 snd_mixer_elem_t *mixer_elem;
85 long hw_volume_max, hw_volume_min;
86 long hw_dB_max, hw_dB_min;
87 pa_bool_t hw_dB_supported:1;
88 pa_bool_t mixer_seperate_channels:1;
90 pa_cvolume hardware_volume;
106 pa_bool_t use_mmap:1, use_tsched:1;
108 pa_rtpoll_item *alsa_rtpoll_item;
110 snd_mixer_selem_channel_id_t mixer_map[SND_MIXER_SCHN_LAST];
112 pa_smoother *smoother;
115 pa_reserve_wrapper *reserve;
116 pa_hook_slot *reserve_slot;
119 static void userdata_free(struct userdata *u);
121 static pa_hook_result_t reserve_cb(pa_reserve_wrapper *r, void *forced, struct userdata *u) {
125 if (pa_source_suspend(u->source, TRUE, PA_SUSPEND_APPLICATION) < 0)
126 return PA_HOOK_CANCEL;
131 static void reserve_done(struct userdata *u) {
134 if (u->reserve_slot) {
135 pa_hook_slot_free(u->reserve_slot);
136 u->reserve_slot = NULL;
140 pa_reserve_wrapper_unref(u->reserve);
145 static void reserve_update(struct userdata *u) {
146 const char *description;
149 if (!u->source || !u->reserve)
152 if ((description = pa_proplist_gets(u->source->proplist, PA_PROP_DEVICE_DESCRIPTION)))
153 pa_reserve_wrapper_set_application_device_name(u->reserve, description);
156 static int reserve_init(struct userdata *u, const char *dname) {
165 if (pa_in_system_mode())
168 /* We are resuming, try to lock the device */
169 if (!(rname = pa_alsa_get_reserve_name(dname)))
172 u->reserve = pa_reserve_wrapper_get(u->core, rname);
180 pa_assert(!u->reserve_slot);
181 u->reserve_slot = pa_hook_connect(pa_reserve_wrapper_hook(u->reserve), PA_HOOK_NORMAL, (pa_hook_cb_t) reserve_cb, u);
186 static void fix_min_sleep_wakeup(struct userdata *u) {
187 size_t max_use, max_use_2;
190 max_use = u->hwbuf_size - u->hwbuf_unused;
191 max_use_2 = pa_frame_align(max_use/2, &u->source->sample_spec);
193 u->min_sleep = pa_usec_to_bytes(TSCHED_MIN_SLEEP_USEC, &u->source->sample_spec);
194 u->min_sleep = PA_CLAMP(u->min_sleep, u->frame_size, max_use_2);
196 u->min_wakeup = pa_usec_to_bytes(TSCHED_MIN_WAKEUP_USEC, &u->source->sample_spec);
197 u->min_wakeup = PA_CLAMP(u->min_wakeup, u->frame_size, max_use_2);
200 static void fix_tsched_watermark(struct userdata *u) {
204 max_use = u->hwbuf_size - u->hwbuf_unused;
206 if (u->tsched_watermark > max_use - u->min_sleep)
207 u->tsched_watermark = max_use - u->min_sleep;
209 if (u->tsched_watermark < u->min_wakeup)
210 u->tsched_watermark = u->min_wakeup;
213 static void adjust_after_overrun(struct userdata *u) {
214 size_t old_watermark;
215 pa_usec_t old_min_latency, new_min_latency;
218 pa_assert(u->use_tsched);
220 /* First, just try to increase the watermark */
221 old_watermark = u->tsched_watermark;
222 u->tsched_watermark = PA_MIN(u->tsched_watermark * 2, u->tsched_watermark + u->watermark_step);
224 fix_tsched_watermark(u);
226 if (old_watermark != u->tsched_watermark) {
227 pa_log_notice("Increasing wakeup watermark to %0.2f ms",
228 (double) pa_bytes_to_usec(u->tsched_watermark, &u->source->sample_spec) / PA_USEC_PER_MSEC);
232 /* Hmm, we cannot increase the watermark any further, hence let's raise the latency */
233 old_min_latency = u->source->thread_info.min_latency;
234 new_min_latency = PA_MIN(old_min_latency * 2, old_min_latency + TSCHED_WATERMARK_STEP_USEC);
235 new_min_latency = PA_MIN(new_min_latency, u->source->thread_info.max_latency);
237 if (old_min_latency != new_min_latency) {
238 pa_log_notice("Increasing minimal latency to %0.2f ms",
239 (double) new_min_latency / PA_USEC_PER_MSEC);
241 pa_source_set_latency_range_within_thread(u->source, new_min_latency, u->source->thread_info.max_latency);
245 /* When we reach this we're officialy fucked! */
248 static pa_usec_t hw_sleep_time(struct userdata *u, pa_usec_t *sleep_usec, pa_usec_t*process_usec) {
253 usec = pa_source_get_requested_latency_within_thread(u->source);
255 if (usec == (pa_usec_t) -1)
256 usec = pa_bytes_to_usec(u->hwbuf_size, &u->source->sample_spec);
258 wm = pa_bytes_to_usec(u->tsched_watermark, &u->source->sample_spec);
263 *sleep_usec = usec - wm;
267 pa_log_debug("Buffer time: %lu ms; Sleep time: %lu ms; Process time: %lu ms",
268 (unsigned long) (usec / PA_USEC_PER_MSEC),
269 (unsigned long) (*sleep_usec / PA_USEC_PER_MSEC),
270 (unsigned long) (*process_usec / PA_USEC_PER_MSEC));
276 static int try_recover(struct userdata *u, const char *call, int err) {
281 pa_log_debug("%s: %s", call, pa_alsa_strerror(err));
283 pa_assert(err != -EAGAIN);
286 pa_log_debug("%s: Buffer overrun!", call);
288 if ((err = snd_pcm_recover(u->pcm_handle, err, 1)) < 0) {
289 pa_log("%s: %s", call, pa_alsa_strerror(err));
293 snd_pcm_start(u->pcm_handle);
297 static size_t check_left_to_record(struct userdata *u, size_t n_bytes) {
298 size_t left_to_record;
299 size_t rec_space = u->hwbuf_size - u->hwbuf_unused;
301 /* We use <= instead of < for this check here because an overrun
302 * only happens after the last sample was processed, not already when
303 * it is removed from the buffer. This is particularly important
304 * when block transfer is used. */
306 if (n_bytes <= rec_space) {
307 left_to_record = rec_space - n_bytes;
310 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);
320 if (pa_log_ratelimit())
321 pa_log_info("Overrun!");
324 adjust_after_overrun(u);
327 return left_to_record;
330 static int mmap_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled) {
331 pa_bool_t work_done = FALSE;
332 pa_usec_t max_sleep_usec = 0, process_usec = 0;
333 size_t left_to_record;
337 pa_source_assert_ref(u->source);
340 hw_sleep_time(u, &max_sleep_usec, &process_usec);
347 if (PA_UNLIKELY((n = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->source->sample_spec)) < 0)) {
349 if ((r = try_recover(u, "snd_pcm_avail", (int) n)) == 0)
355 n_bytes = (size_t) n * u->frame_size;
358 pa_log_debug("avail: %lu", (unsigned long) n_bytes);
361 left_to_record = check_left_to_record(u, n_bytes);
365 pa_bytes_to_usec(left_to_record, &u->source->sample_spec) > process_usec+max_sleep_usec/2) {
367 pa_log_debug("Not reading, because too early.");
372 if (PA_UNLIKELY(n_bytes <= 0)) {
376 char *dn = pa_alsa_get_driver_name_by_pcm(u->pcm_handle);
377 pa_log(_("ALSA woke us up to read new data from the device, but there was actually nothing to read!\n"
378 "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers.\n"
379 "We were woken up with POLLIN set -- however a subsequent snd_pcm_avail() returned 0 or another value < min_avail."),
385 pa_log_debug("Not reading, because not necessary.");
392 pa_log_debug("Not filling up, because already too many iterations.");
401 pa_log_debug("Reading");
406 const snd_pcm_channel_area_t *areas;
407 snd_pcm_uframes_t offset, frames;
410 snd_pcm_sframes_t sframes;
412 frames = (snd_pcm_uframes_t) (n_bytes / u->frame_size);
414 /* pa_log_debug("%lu frames to read", (unsigned long) frames); */
416 if (PA_UNLIKELY((err = pa_alsa_safe_mmap_begin(u->pcm_handle, &areas, &offset, &frames, u->hwbuf_size, &u->source->sample_spec)) < 0)) {
418 if ((r = try_recover(u, "snd_pcm_mmap_begin", err)) == 0)
424 /* Make sure that if these memblocks need to be copied they will fit into one slot */
425 if (frames > pa_mempool_block_size_max(u->source->core->mempool)/u->frame_size)
426 frames = pa_mempool_block_size_max(u->source->core->mempool)/u->frame_size;
428 /* Check these are multiples of 8 bit */
429 pa_assert((areas[0].first & 7) == 0);
430 pa_assert((areas[0].step & 7)== 0);
432 /* We assume a single interleaved memory buffer */
433 pa_assert((areas[0].first >> 3) == 0);
434 pa_assert((areas[0].step >> 3) == u->frame_size);
436 p = (uint8_t*) areas[0].addr + (offset * u->frame_size);
438 chunk.memblock = pa_memblock_new_fixed(u->core->mempool, p, frames * u->frame_size, TRUE);
439 chunk.length = pa_memblock_get_length(chunk.memblock);
442 pa_source_post(u->source, &chunk);
443 pa_memblock_unref_fixed(chunk.memblock);
445 if (PA_UNLIKELY((sframes = snd_pcm_mmap_commit(u->pcm_handle, offset, frames)) < 0)) {
447 if ((r = try_recover(u, "snd_pcm_mmap_commit", (int) sframes)) == 0)
455 u->read_count += frames * u->frame_size;
458 pa_log_debug("Read %lu bytes (of possible %lu bytes)", (unsigned long) (frames * u->frame_size), (unsigned long) n_bytes);
461 if ((size_t) frames * u->frame_size >= n_bytes)
464 n_bytes -= (size_t) frames * u->frame_size;
468 *sleep_usec = pa_bytes_to_usec(left_to_record, &u->source->sample_spec);
470 if (*sleep_usec > process_usec)
471 *sleep_usec -= process_usec;
475 return work_done ? 1 : 0;
478 static int unix_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled) {
479 int work_done = FALSE;
480 pa_usec_t max_sleep_usec = 0, process_usec = 0;
481 size_t left_to_record;
485 pa_source_assert_ref(u->source);
488 hw_sleep_time(u, &max_sleep_usec, &process_usec);
495 if (PA_UNLIKELY((n = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->source->sample_spec)) < 0)) {
497 if ((r = try_recover(u, "snd_pcm_avail", (int) n)) == 0)
503 n_bytes = (size_t) n * u->frame_size;
504 left_to_record = check_left_to_record(u, n_bytes);
508 pa_bytes_to_usec(left_to_record, &u->source->sample_spec) > process_usec+max_sleep_usec/2)
511 if (PA_UNLIKELY(n_bytes <= 0)) {
515 char *dn = pa_alsa_get_driver_name_by_pcm(u->pcm_handle);
516 pa_log(_("ALSA woke us up to read new data from the device, but there was actually nothing to read!\n"
517 "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers.\n"
518 "We were woken up with POLLIN set -- however a subsequent snd_pcm_avail() returned 0 or another value < min_avail."),
528 pa_log_debug("Not filling up, because already too many iterations.");
538 snd_pcm_sframes_t frames;
541 chunk.memblock = pa_memblock_new(u->core->mempool, (size_t) -1);
543 frames = (snd_pcm_sframes_t) (pa_memblock_get_length(chunk.memblock) / u->frame_size);
545 if (frames > (snd_pcm_sframes_t) (n_bytes/u->frame_size))
546 frames = (snd_pcm_sframes_t) (n_bytes/u->frame_size);
548 /* pa_log_debug("%lu frames to read", (unsigned long) n); */
550 p = pa_memblock_acquire(chunk.memblock);
551 frames = snd_pcm_readi(u->pcm_handle, (uint8_t*) p, (snd_pcm_uframes_t) frames);
552 pa_memblock_release(chunk.memblock);
554 pa_assert(frames != 0);
556 if (PA_UNLIKELY(frames < 0)) {
557 pa_memblock_unref(chunk.memblock);
559 if ((r = try_recover(u, "snd_pcm_readi", (int) (frames))) == 0)
566 chunk.length = (size_t) frames * u->frame_size;
568 pa_source_post(u->source, &chunk);
569 pa_memblock_unref(chunk.memblock);
573 u->read_count += frames * u->frame_size;
575 /* pa_log_debug("read %lu frames", (unsigned long) frames); */
577 if ((size_t) frames * u->frame_size >= n_bytes)
580 n_bytes -= (size_t) frames * u->frame_size;
584 *sleep_usec = pa_bytes_to_usec(left_to_record, &u->source->sample_spec);
586 if (*sleep_usec > process_usec)
587 *sleep_usec -= process_usec;
591 return work_done ? 1 : 0;
594 static void update_smoother(struct userdata *u) {
595 snd_pcm_sframes_t delay = 0;
598 pa_usec_t now1 = 0, now2;
599 snd_pcm_status_t *status;
601 snd_pcm_status_alloca(&status);
604 pa_assert(u->pcm_handle);
606 /* Let's update the time smoother */
608 if (PA_UNLIKELY((err = pa_alsa_safe_delay(u->pcm_handle, &delay, u->hwbuf_size, &u->source->sample_spec)) < 0)) {
609 pa_log_warn("Failed to get delay: %s", pa_alsa_strerror(err));
613 if (PA_UNLIKELY((err = snd_pcm_status(u->pcm_handle, status)) < 0))
614 pa_log_warn("Failed to get timestamp: %s", pa_alsa_strerror(err));
616 snd_htimestamp_t htstamp = { 0, 0 };
617 snd_pcm_status_get_htstamp(status, &htstamp);
618 now1 = pa_timespec_load(&htstamp);
621 position = u->read_count + ((uint64_t) delay * (uint64_t) u->frame_size);
623 /* Hmm, if the timestamp is 0, then it wasn't set and we take the current time */
625 now1 = pa_rtclock_usec();
627 now2 = pa_bytes_to_usec(position, &u->source->sample_spec);
629 pa_smoother_put(u->smoother, now1, now2);
632 static pa_usec_t source_get_latency(struct userdata *u) {
634 pa_usec_t now1, now2;
638 now1 = pa_rtclock_usec();
639 now2 = pa_smoother_get(u->smoother, now1);
641 delay = (int64_t) now2 - (int64_t) pa_bytes_to_usec(u->read_count, &u->source->sample_spec);
643 return delay >= 0 ? (pa_usec_t) delay : 0;
646 static int build_pollfd(struct userdata *u) {
648 pa_assert(u->pcm_handle);
650 if (u->alsa_rtpoll_item)
651 pa_rtpoll_item_free(u->alsa_rtpoll_item);
653 if (!(u->alsa_rtpoll_item = pa_alsa_build_pollfd(u->pcm_handle, u->rtpoll)))
659 static int suspend(struct userdata *u) {
661 pa_assert(u->pcm_handle);
663 pa_smoother_pause(u->smoother, pa_rtclock_usec());
666 snd_pcm_close(u->pcm_handle);
667 u->pcm_handle = NULL;
669 if (u->alsa_rtpoll_item) {
670 pa_rtpoll_item_free(u->alsa_rtpoll_item);
671 u->alsa_rtpoll_item = NULL;
674 pa_log_info("Device suspended...");
679 static int update_sw_params(struct userdata *u) {
680 snd_pcm_uframes_t avail_min;
685 /* Use the full buffer if noone asked us for anything specific */
691 if ((latency = pa_source_get_requested_latency_within_thread(u->source)) != (pa_usec_t) -1) {
694 pa_log_debug("latency set to %0.2fms", (double) latency / PA_USEC_PER_MSEC);
696 b = pa_usec_to_bytes(latency, &u->source->sample_spec);
698 /* We need at least one sample in our buffer */
700 if (PA_UNLIKELY(b < u->frame_size))
703 u->hwbuf_unused = PA_LIKELY(b < u->hwbuf_size) ? (u->hwbuf_size - b) : 0;
706 fix_min_sleep_wakeup(u);
707 fix_tsched_watermark(u);
710 pa_log_debug("hwbuf_unused=%lu", (unsigned long) u->hwbuf_unused);
715 pa_usec_t sleep_usec, process_usec;
717 hw_sleep_time(u, &sleep_usec, &process_usec);
718 avail_min += pa_usec_to_bytes(sleep_usec, &u->source->sample_spec) / u->frame_size;
721 pa_log_debug("setting avail_min=%lu", (unsigned long) avail_min);
723 if ((err = pa_alsa_set_sw_params(u->pcm_handle, avail_min)) < 0) {
724 pa_log("Failed to set software parameters: %s", pa_alsa_strerror(err));
731 static int unsuspend(struct userdata *u) {
736 snd_pcm_uframes_t period_size;
739 pa_assert(!u->pcm_handle);
741 pa_log_info("Trying resume...");
743 snd_config_update_free_global();
745 if ((err = snd_pcm_open(&u->pcm_handle, u->device_name, SND_PCM_STREAM_CAPTURE,
746 /*SND_PCM_NONBLOCK|*/
747 SND_PCM_NO_AUTO_RESAMPLE|
748 SND_PCM_NO_AUTO_CHANNELS|
749 SND_PCM_NO_AUTO_FORMAT)) < 0) {
750 pa_log("Error opening PCM device %s: %s", u->device_name, pa_alsa_strerror(err));
754 ss = u->source->sample_spec;
755 nfrags = u->nfragments;
756 period_size = u->fragment_size / u->frame_size;
760 if ((err = pa_alsa_set_hw_params(u->pcm_handle, &ss, &nfrags, &period_size, u->hwbuf_size / u->frame_size, &b, &d, TRUE)) < 0) {
761 pa_log("Failed to set hardware parameters: %s", pa_alsa_strerror(err));
765 if (b != u->use_mmap || d != u->use_tsched) {
766 pa_log_warn("Resume failed, couldn't get original access mode.");
770 if (!pa_sample_spec_equal(&ss, &u->source->sample_spec)) {
771 pa_log_warn("Resume failed, couldn't restore original sample settings.");
775 if (nfrags != u->nfragments || period_size*u->frame_size != u->fragment_size) {
776 pa_log_warn("Resume failed, couldn't restore original fragment settings. (Old: %lu*%lu, New %lu*%lu)",
777 (unsigned long) u->nfragments, (unsigned long) u->fragment_size,
778 (unsigned long) nfrags, period_size * u->frame_size);
782 if (update_sw_params(u) < 0)
785 if (build_pollfd(u) < 0)
788 /* FIXME: We need to reload the volume somehow */
790 snd_pcm_start(u->pcm_handle);
791 pa_smoother_resume(u->smoother, pa_rtclock_usec(), TRUE);
793 pa_log_info("Resumed successfully...");
799 snd_pcm_close(u->pcm_handle);
800 u->pcm_handle = NULL;
806 static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
807 struct userdata *u = PA_SOURCE(o)->userdata;
811 case PA_SOURCE_MESSAGE_GET_LATENCY: {
815 r = source_get_latency(u);
817 *((pa_usec_t*) data) = r;
822 case PA_SOURCE_MESSAGE_SET_STATE:
824 switch ((pa_source_state_t) PA_PTR_TO_UINT(data)) {
826 case PA_SOURCE_SUSPENDED:
827 pa_assert(PA_SOURCE_IS_OPENED(u->source->thread_info.state));
835 case PA_SOURCE_RUNNING:
837 if (u->source->thread_info.state == PA_SOURCE_INIT) {
838 if (build_pollfd(u) < 0)
841 snd_pcm_start(u->pcm_handle);
844 if (u->source->thread_info.state == PA_SOURCE_SUSPENDED) {
845 if (unsuspend(u) < 0)
851 case PA_SOURCE_UNLINKED:
853 case PA_SOURCE_INVALID_STATE:
860 return pa_source_process_msg(o, code, data, offset, chunk);
863 /* Called from main context */
864 static int source_set_state_cb(pa_source *s, pa_source_state_t new_state) {
865 pa_source_state_t old_state;
868 pa_source_assert_ref(s);
869 pa_assert_se(u = s->userdata);
871 old_state = pa_source_get_state(u->source);
873 if (PA_SINK_IS_OPENED(old_state) && new_state == PA_SINK_SUSPENDED)
875 else if (old_state == PA_SINK_SUSPENDED && PA_SINK_IS_OPENED(new_state))
876 if (reserve_init(u, u->device_name) < 0)
882 static int mixer_callback(snd_mixer_elem_t *elem, unsigned int mask) {
883 struct userdata *u = snd_mixer_elem_get_callback_private(elem);
886 pa_assert(u->mixer_handle);
888 if (mask == SND_CTL_EVENT_MASK_REMOVE)
891 if (mask & SND_CTL_EVENT_MASK_VALUE) {
892 pa_source_get_volume(u->source, TRUE);
893 pa_source_get_mute(u->source, TRUE);
899 static pa_volume_t from_alsa_volume(struct userdata *u, long alsa_vol) {
901 return (pa_volume_t) round(((double) (alsa_vol - u->hw_volume_min) * PA_VOLUME_NORM) /
902 (double) (u->hw_volume_max - u->hw_volume_min));
905 static long to_alsa_volume(struct userdata *u, pa_volume_t vol) {
908 alsa_vol = (long) round(((double) vol * (double) (u->hw_volume_max - u->hw_volume_min))
909 / PA_VOLUME_NORM) + u->hw_volume_min;
911 return PA_CLAMP_UNLIKELY(alsa_vol, u->hw_volume_min, u->hw_volume_max);
914 static void source_get_volume_cb(pa_source *s) {
915 struct userdata *u = s->userdata;
919 char t[PA_CVOLUME_SNPRINT_MAX];
922 pa_assert(u->mixer_elem);
924 if (u->mixer_seperate_channels) {
926 r.channels = s->sample_spec.channels;
928 for (i = 0; i < s->sample_spec.channels; i++) {
931 if (u->hw_dB_supported) {
933 if ((err = snd_mixer_selem_get_capture_dB(u->mixer_elem, u->mixer_map[i], &alsa_vol)) < 0)
936 #ifdef HAVE_VALGRIND_MEMCHECK_H
937 VALGRIND_MAKE_MEM_DEFINED(&alsa_vol, sizeof(alsa_vol));
940 r.values[i] = pa_sw_volume_from_dB((double) (alsa_vol - u->hw_dB_max) / 100.0);
943 if ((err = snd_mixer_selem_get_capture_volume(u->mixer_elem, u->mixer_map[i], &alsa_vol)) < 0)
946 r.values[i] = from_alsa_volume(u, alsa_vol);
953 if (u->hw_dB_supported) {
955 if ((err = snd_mixer_selem_get_capture_dB(u->mixer_elem, SND_MIXER_SCHN_MONO, &alsa_vol)) < 0)
958 #ifdef HAVE_VALGRIND_MEMCHECK_H
959 VALGRIND_MAKE_MEM_DEFINED(&alsa_vol, sizeof(alsa_vol));
962 pa_cvolume_set(&r, s->sample_spec.channels, pa_sw_volume_from_dB((double) (alsa_vol - u->hw_dB_max) / 100.0));
966 if ((err = snd_mixer_selem_get_capture_volume(u->mixer_elem, SND_MIXER_SCHN_MONO, &alsa_vol)) < 0)
969 pa_cvolume_set(&r, s->sample_spec.channels, from_alsa_volume(u, alsa_vol));
973 pa_log_debug("Read hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &r));
975 if (!pa_cvolume_equal(&u->hardware_volume, &r)) {
977 s->virtual_volume = u->hardware_volume = r;
979 if (u->hw_dB_supported) {
982 /* Hmm, so the hardware volume changed, let's reset our software volume */
983 pa_cvolume_reset(&reset, s->sample_spec.channels);
984 pa_source_set_soft_volume(s, &reset);
991 pa_log_error("Unable to read volume: %s", pa_alsa_strerror(err));
994 static void source_set_volume_cb(pa_source *s) {
995 struct userdata *u = s->userdata;
1001 pa_assert(u->mixer_elem);
1003 if (u->mixer_seperate_channels) {
1005 r.channels = s->sample_spec.channels;
1007 for (i = 0; i < s->sample_spec.channels; i++) {
1011 vol = s->virtual_volume.values[i];
1013 if (u->hw_dB_supported) {
1015 alsa_vol = (long) (pa_sw_volume_to_dB(vol) * 100);
1016 alsa_vol += u->hw_dB_max;
1017 alsa_vol = PA_CLAMP_UNLIKELY(alsa_vol, u->hw_dB_min, u->hw_dB_max);
1019 if ((err = snd_mixer_selem_set_capture_dB(u->mixer_elem, u->mixer_map[i], alsa_vol, 1)) < 0)
1022 if ((err = snd_mixer_selem_get_capture_dB(u->mixer_elem, u->mixer_map[i], &alsa_vol)) < 0)
1025 #ifdef HAVE_VALGRIND_MEMCHECK_H
1026 VALGRIND_MAKE_MEM_DEFINED(&alsa_vol, sizeof(alsa_vol));
1029 r.values[i] = pa_sw_volume_from_dB((double) (alsa_vol - u->hw_dB_max) / 100.0);
1032 alsa_vol = to_alsa_volume(u, vol);
1034 if ((err = snd_mixer_selem_set_capture_volume(u->mixer_elem, u->mixer_map[i], alsa_vol)) < 0)
1037 if ((err = snd_mixer_selem_get_capture_volume(u->mixer_elem, u->mixer_map[i], &alsa_vol)) < 0)
1040 r.values[i] = from_alsa_volume(u, alsa_vol);
1048 vol = pa_cvolume_max(&s->virtual_volume);
1050 if (u->hw_dB_supported) {
1051 alsa_vol = (long) (pa_sw_volume_to_dB(vol) * 100);
1052 alsa_vol += u->hw_dB_max;
1053 alsa_vol = PA_CLAMP_UNLIKELY(alsa_vol, u->hw_dB_min, u->hw_dB_max);
1055 if ((err = snd_mixer_selem_set_capture_dB_all(u->mixer_elem, alsa_vol, 1)) < 0)
1058 if ((err = snd_mixer_selem_get_capture_dB(u->mixer_elem, SND_MIXER_SCHN_MONO, &alsa_vol)) < 0)
1061 #ifdef HAVE_VALGRIND_MEMCHECK_H
1062 VALGRIND_MAKE_MEM_DEFINED(&alsa_vol, sizeof(alsa_vol));
1065 pa_cvolume_set(&r, s->sample_spec.channels, pa_sw_volume_from_dB((double) (alsa_vol - u->hw_dB_max) / 100.0));
1068 alsa_vol = to_alsa_volume(u, vol);
1070 if ((err = snd_mixer_selem_set_capture_volume_all(u->mixer_elem, alsa_vol)) < 0)
1073 if ((err = snd_mixer_selem_get_capture_volume(u->mixer_elem, SND_MIXER_SCHN_MONO, &alsa_vol)) < 0)
1076 pa_cvolume_set(&r, s->sample_spec.channels, from_alsa_volume(u, alsa_vol));
1080 u->hardware_volume = r;
1082 if (u->hw_dB_supported) {
1083 char t[PA_CVOLUME_SNPRINT_MAX];
1085 /* Match exactly what the user requested by software */
1087 pa_sw_cvolume_divide(&s->soft_volume, &s->virtual_volume, &u->hardware_volume);
1089 pa_log_debug("Requested volume: %s", pa_cvolume_snprint(t, sizeof(t), &s->virtual_volume));
1090 pa_log_debug("Got hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &u->hardware_volume));
1091 pa_log_debug("Calculated software volume: %s", pa_cvolume_snprint(t, sizeof(t), &s->soft_volume));
1095 /* We can't match exactly what the user requested, hence let's
1096 * at least tell the user about it */
1098 s->virtual_volume = r;
1103 pa_log_error("Unable to set volume: %s", pa_alsa_strerror(err));
1106 static void source_get_mute_cb(pa_source *s) {
1107 struct userdata *u = s->userdata;
1111 pa_assert(u->mixer_elem);
1113 if ((err = snd_mixer_selem_get_capture_switch(u->mixer_elem, 0, &sw)) < 0) {
1114 pa_log_error("Unable to get switch: %s", pa_alsa_strerror(err));
1121 static void source_set_mute_cb(pa_source *s) {
1122 struct userdata *u = s->userdata;
1126 pa_assert(u->mixer_elem);
1128 if ((err = snd_mixer_selem_set_capture_switch_all(u->mixer_elem, !s->muted)) < 0) {
1129 pa_log_error("Unable to set switch: %s", pa_alsa_strerror(err));
1134 static void source_update_requested_latency_cb(pa_source *s) {
1135 struct userdata *u = s->userdata;
1141 update_sw_params(u);
1144 static void thread_func(void *userdata) {
1145 struct userdata *u = userdata;
1146 unsigned short revents = 0;
1150 pa_log_debug("Thread starting up");
1152 if (u->core->realtime_scheduling)
1153 pa_make_realtime(u->core->realtime_priority);
1155 pa_thread_mq_install(&u->thread_mq);
1156 pa_rtpoll_install(u->rtpoll);
1162 pa_log_debug("Loop");
1165 /* Read some data and pass it to the sources */
1166 if (PA_SOURCE_IS_OPENED(u->source->thread_info.state)) {
1168 pa_usec_t sleep_usec = 0;
1171 work_done = mmap_read(u, &sleep_usec, revents & POLLIN);
1173 work_done = unix_read(u, &sleep_usec, revents & POLLIN);
1178 /* pa_log_debug("work_done = %i", work_done); */
1183 if (u->use_tsched) {
1186 /* OK, the capture buffer is now empty, let's
1187 * calculate when to wake up next */
1189 /* pa_log_debug("Waking up in %0.2fms (sound card clock).", (double) sleep_usec / PA_USEC_PER_MSEC); */
1191 /* Convert from the sound card time domain to the
1192 * system time domain */
1193 cusec = pa_smoother_translate(u->smoother, pa_rtclock_usec(), sleep_usec);
1195 /* pa_log_debug("Waking up in %0.2fms (system clock).", (double) cusec / PA_USEC_PER_MSEC); */
1197 /* We don't trust the conversion, so we wake up whatever comes first */
1198 pa_rtpoll_set_timer_relative(u->rtpoll, PA_MIN(sleep_usec, cusec));
1200 } else if (u->use_tsched)
1202 /* OK, we're in an invalid state, let's disable our timers */
1203 pa_rtpoll_set_timer_disabled(u->rtpoll);
1205 /* Hmm, nothing to do. Let's sleep */
1206 if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
1212 /* Tell ALSA about this and process its response */
1213 if (PA_SOURCE_IS_OPENED(u->source->thread_info.state)) {
1214 struct pollfd *pollfd;
1218 pollfd = pa_rtpoll_item_get_pollfd(u->alsa_rtpoll_item, &n);
1220 if ((err = snd_pcm_poll_descriptors_revents(u->pcm_handle, pollfd, n, &revents)) < 0) {
1221 pa_log("snd_pcm_poll_descriptors_revents() failed: %s", pa_alsa_strerror(err));
1225 if (revents & ~POLLIN) {
1226 if (pa_alsa_recover_from_poll(u->pcm_handle, revents) < 0)
1229 snd_pcm_start(u->pcm_handle);
1230 } else if (revents && u->use_tsched && pa_log_ratelimit())
1231 pa_log_debug("Wakeup from ALSA!");
1238 /* If this was no regular exit from the loop we have to continue
1239 * processing messages until we received PA_MESSAGE_SHUTDOWN */
1240 pa_asyncmsgq_post(u->thread_mq.outq, PA_MSGOBJECT(u->core), PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0, NULL, NULL);
1241 pa_asyncmsgq_wait_for(u->thread_mq.inq, PA_MESSAGE_SHUTDOWN);
1244 pa_log_debug("Thread shutting down");
1247 static void set_source_name(pa_source_new_data *data, pa_modargs *ma, const char *device_id, const char *device_name) {
1253 pa_assert(device_name);
1255 if ((n = pa_modargs_get_value(ma, "source_name", NULL))) {
1256 pa_source_new_data_set_name(data, n);
1257 data->namereg_fail = TRUE;
1261 if ((n = pa_modargs_get_value(ma, "name", NULL)))
1262 data->namereg_fail = TRUE;
1264 n = device_id ? device_id : device_name;
1265 data->namereg_fail = FALSE;
1268 t = pa_sprintf_malloc("alsa_input.%s", n);
1269 pa_source_new_data_set_name(data, t);
1273 static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB) {
1276 if (!u->mixer_handle)
1279 pa_assert(u->mixer_elem);
1281 if (snd_mixer_selem_has_capture_volume(u->mixer_elem)) {
1282 pa_bool_t suitable = FALSE;
1284 if (snd_mixer_selem_get_capture_volume_range(u->mixer_elem, &u->hw_volume_min, &u->hw_volume_max) < 0)
1285 pa_log_info("Failed to get volume range. Falling back to software volume control.");
1286 else if (u->hw_volume_min >= u->hw_volume_max)
1287 pa_log_warn("Your kernel driver is broken: it reports a volume range from %li to %li which makes no sense.", u->hw_volume_min, u->hw_volume_max);
1289 pa_log_info("Volume ranges from %li to %li.", u->hw_volume_min, u->hw_volume_max);
1294 if (ignore_dB || snd_mixer_selem_get_capture_dB_range(u->mixer_elem, &u->hw_dB_min, &u->hw_dB_max) < 0)
1295 pa_log_info("Mixer doesn't support dB information or data is ignored.");
1297 #ifdef HAVE_VALGRIND_MEMCHECK_H
1298 VALGRIND_MAKE_MEM_DEFINED(&u->hw_dB_min, sizeof(u->hw_dB_min));
1299 VALGRIND_MAKE_MEM_DEFINED(&u->hw_dB_max, sizeof(u->hw_dB_max));
1302 if (u->hw_dB_min >= u->hw_dB_max)
1303 pa_log_warn("Your kernel driver is broken: it reports a volume range from %0.2f dB to %0.2f dB which makes no sense.", (double) u->hw_dB_min/100.0, (double) u->hw_dB_max/100.0);
1305 pa_log_info("Volume ranges from %0.2f dB to %0.2f dB.", (double) u->hw_dB_min/100.0, (double) u->hw_dB_max/100.0);
1306 u->hw_dB_supported = TRUE;
1308 if (u->hw_dB_max > 0) {
1309 u->source->base_volume = pa_sw_volume_from_dB(- (double) u->hw_dB_max/100.0);
1310 pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(u->source->base_volume));
1312 pa_log_info("No particular base volume set, fixing to 0 dB");
1316 if (!u->hw_dB_supported &&
1317 u->hw_volume_max - u->hw_volume_min < 3) {
1319 pa_log_info("Device has less than 4 volume levels. Falling back to software volume control.");
1325 u->mixer_seperate_channels = pa_alsa_calc_mixer_map(u->mixer_elem, &u->source->channel_map, u->mixer_map, FALSE) >= 0;
1327 u->source->get_volume = source_get_volume_cb;
1328 u->source->set_volume = source_set_volume_cb;
1329 u->source->flags |= PA_SOURCE_HW_VOLUME_CTRL | (u->hw_dB_supported ? PA_SOURCE_DECIBEL_VOLUME : 0);
1330 pa_log_info("Using hardware volume control. Hardware dB scale %s.", u->hw_dB_supported ? "supported" : "not supported");
1332 if (!u->hw_dB_supported)
1333 u->source->n_volume_steps = u->hw_volume_max - u->hw_volume_min + 1;
1335 pa_log_info("Using software volume control.");
1338 if (snd_mixer_selem_has_capture_switch(u->mixer_elem)) {
1339 u->source->get_mute = source_get_mute_cb;
1340 u->source->set_mute = source_set_mute_cb;
1341 u->source->flags |= PA_SOURCE_HW_MUTE_CTRL;
1343 pa_log_info("Using software mute control.");
1345 u->mixer_fdl = pa_alsa_fdlist_new();
1347 if (pa_alsa_fdlist_set_mixer(u->mixer_fdl, u->mixer_handle, u->core->mainloop) < 0) {
1348 pa_log("Failed to initialize file descriptor monitoring");
1352 snd_mixer_elem_set_callback(u->mixer_elem, mixer_callback);
1353 snd_mixer_elem_set_callback_private(u->mixer_elem, u);
1358 pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, pa_card *card, const pa_alsa_profile_info *profile) {
1360 struct userdata *u = NULL;
1361 const char *dev_id = NULL;
1362 pa_sample_spec ss, requested_ss;
1364 uint32_t nfrags, hwbuf_size, frag_size, tsched_size, tsched_watermark;
1365 snd_pcm_uframes_t period_frames, tsched_frames;
1367 pa_bool_t use_mmap = TRUE, b, use_tsched = TRUE, d, ignore_dB = FALSE;
1368 pa_source_new_data data;
1369 char *control_device = NULL;
1374 ss = m->core->default_sample_spec;
1375 map = m->core->default_channel_map;
1376 if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_ALSA) < 0) {
1377 pa_log("Failed to parse sample specification");
1382 frame_size = pa_frame_size(&ss);
1384 nfrags = m->core->default_n_fragments;
1385 frag_size = (uint32_t) pa_usec_to_bytes(m->core->default_fragment_size_msec*PA_USEC_PER_MSEC, &ss);
1387 frag_size = (uint32_t) frame_size;
1388 tsched_size = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_BUFFER_USEC, &ss);
1389 tsched_watermark = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_WATERMARK_USEC, &ss);
1391 if (pa_modargs_get_value_u32(ma, "fragments", &nfrags) < 0 ||
1392 pa_modargs_get_value_u32(ma, "fragment_size", &frag_size) < 0 ||
1393 pa_modargs_get_value_u32(ma, "tsched_buffer_size", &tsched_size) < 0 ||
1394 pa_modargs_get_value_u32(ma, "tsched_buffer_watermark", &tsched_watermark) < 0) {
1395 pa_log("Failed to parse buffer metrics");
1399 hwbuf_size = frag_size * nfrags;
1400 period_frames = frag_size/frame_size;
1401 tsched_frames = tsched_size/frame_size;
1403 if (pa_modargs_get_value_boolean(ma, "mmap", &use_mmap) < 0) {
1404 pa_log("Failed to parse mmap argument.");
1408 if (pa_modargs_get_value_boolean(ma, "tsched", &use_tsched) < 0) {
1409 pa_log("Failed to parse timer_scheduling argument.");
1413 if (pa_modargs_get_value_boolean(ma, "ignore_dB", &ignore_dB) < 0) {
1414 pa_log("Failed to parse ignore_dB argument.");
1418 if (use_tsched && !pa_rtclock_hrtimer()) {
1419 pa_log_notice("Disabling timer-based scheduling because high-resolution timers are not available from the kernel.");
1423 u = pa_xnew0(struct userdata, 1);
1426 u->use_mmap = use_mmap;
1427 u->use_tsched = use_tsched;
1428 u->rtpoll = pa_rtpoll_new();
1429 pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
1430 u->alsa_rtpoll_item = NULL;
1432 u->smoother = pa_smoother_new(
1433 DEFAULT_TSCHED_WATERMARK_USEC*2,
1434 DEFAULT_TSCHED_WATERMARK_USEC*2,
1441 if (reserve_init(u, pa_modargs_get_value(
1443 pa_modargs_get_value(ma, "device", DEFAULT_DEVICE))) < 0)
1451 if (!(dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
1452 pa_log("device_id= not set");
1456 if (!(u->pcm_handle = pa_alsa_open_by_device_id_profile(
1460 SND_PCM_STREAM_CAPTURE,
1461 &nfrags, &period_frames, tsched_frames,
1465 } else if ((dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
1467 if (!(u->pcm_handle = pa_alsa_open_by_device_id_auto(
1471 SND_PCM_STREAM_CAPTURE,
1472 &nfrags, &period_frames, tsched_frames,
1478 if (!(u->pcm_handle = pa_alsa_open_by_device_string(
1479 pa_modargs_get_value(ma, "device", DEFAULT_DEVICE),
1482 SND_PCM_STREAM_CAPTURE,
1483 &nfrags, &period_frames, tsched_frames,
1488 pa_assert(u->device_name);
1489 pa_log_info("Successfully opened device %s.", u->device_name);
1491 if (pa_alsa_pcm_is_modem(u->pcm_handle)) {
1492 pa_log_notice("Device %s is modem, refusing further initialization.", u->device_name);
1497 pa_log_info("Selected configuration '%s' (%s).", profile->description, profile->name);
1499 if (use_mmap && !b) {
1500 pa_log_info("Device doesn't support mmap(), falling back to UNIX read/write mode.");
1501 u->use_mmap = use_mmap = FALSE;
1504 if (use_tsched && (!b || !d)) {
1505 pa_log_info("Cannot enable timer-based scheduling, falling back to sound IRQ scheduling.");
1506 u->use_tsched = use_tsched = FALSE;
1509 if (use_tsched && !pa_alsa_pcm_is_hw(u->pcm_handle)) {
1510 pa_log_info("Device is not a hardware device, disabling timer-based scheduling.");
1511 u->use_tsched = use_tsched = FALSE;
1515 pa_log_info("Successfully enabled mmap() mode.");
1518 pa_log_info("Successfully enabled timer-based scheduling mode.");
1520 /* ALSA might tweak the sample spec, so recalculate the frame size */
1521 frame_size = pa_frame_size(&ss);
1523 pa_alsa_find_mixer_and_elem(u->pcm_handle, &control_device, &u->mixer_handle, &u->mixer_elem, pa_modargs_get_value(ma, "control", NULL), profile);
1525 pa_source_new_data_init(&data);
1526 data.driver = driver;
1529 set_source_name(&data, ma, dev_id, u->device_name);
1530 pa_source_new_data_set_sample_spec(&data, &ss);
1531 pa_source_new_data_set_channel_map(&data, &map);
1533 pa_alsa_init_proplist_pcm(m->core, data.proplist, u->pcm_handle, u->mixer_elem);
1534 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, u->device_name);
1535 pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_BUFFER_SIZE, "%lu", (unsigned long) (period_frames * frame_size * nfrags));
1536 pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZE, "%lu", (unsigned long) (period_frames * frame_size));
1537 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_ACCESS_MODE, u->use_tsched ? "mmap+timer" : (u->use_mmap ? "mmap" : "serial"));
1540 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_NAME, profile->name);
1541 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_DESCRIPTION, profile->description);
1544 pa_alsa_init_description(data.proplist);
1546 if (control_device) {
1547 pa_alsa_init_proplist_ctl(data.proplist, control_device);
1548 pa_xfree(control_device);
1551 if (pa_modargs_get_proplist(ma, "source_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
1552 pa_log("Invalid properties");
1553 pa_source_new_data_done(&data);
1557 u->source = pa_source_new(m->core, &data, PA_SOURCE_HARDWARE|PA_SOURCE_LATENCY|(u->use_tsched ? PA_SOURCE_DYNAMIC_LATENCY : 0));
1558 pa_source_new_data_done(&data);
1561 pa_log("Failed to create source object");
1565 u->source->parent.process_msg = source_process_msg;
1566 u->source->update_requested_latency = source_update_requested_latency_cb;
1567 u->source->set_state = source_set_state_cb;
1568 u->source->userdata = u;
1570 pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
1571 pa_source_set_rtpoll(u->source, u->rtpoll);
1573 u->frame_size = frame_size;
1574 u->fragment_size = frag_size = (uint32_t) (period_frames * frame_size);
1575 u->nfragments = nfrags;
1576 u->hwbuf_size = u->fragment_size * nfrags;
1577 u->tsched_watermark = pa_usec_to_bytes_round_up(pa_bytes_to_usec_round_up(tsched_watermark, &requested_ss), &u->source->sample_spec);
1578 pa_cvolume_mute(&u->hardware_volume, u->source->sample_spec.channels);
1580 pa_log_info("Using %u fragments of size %lu bytes, buffer time is %0.2fms",
1581 nfrags, (long unsigned) u->fragment_size,
1582 (double) pa_bytes_to_usec(u->hwbuf_size, &ss) / PA_USEC_PER_MSEC);
1584 if (u->use_tsched) {
1585 u->watermark_step = pa_usec_to_bytes(TSCHED_WATERMARK_STEP_USEC, &u->source->sample_spec);
1587 fix_min_sleep_wakeup(u);
1588 fix_tsched_watermark(u);
1590 pa_source_set_latency_range(u->source,
1592 pa_bytes_to_usec(u->hwbuf_size, &ss));
1594 pa_log_info("Time scheduling watermark is %0.2fms",
1595 (double) pa_bytes_to_usec(u->tsched_watermark, &ss) / PA_USEC_PER_MSEC);
1597 pa_source_set_fixed_latency(u->source, pa_bytes_to_usec(u->hwbuf_size, &ss));
1601 if (update_sw_params(u) < 0)
1604 if (setup_mixer(u, ignore_dB) < 0)
1607 pa_alsa_dump(PA_LOG_DEBUG, u->pcm_handle);
1609 if (!(u->thread = pa_thread_new(thread_func, u))) {
1610 pa_log("Failed to create thread.");
1613 /* Get initial mixer settings */
1614 if (data.volume_is_set) {
1615 if (u->source->set_volume)
1616 u->source->set_volume(u->source);
1618 if (u->source->get_volume)
1619 u->source->get_volume(u->source);
1622 if (data.muted_is_set) {
1623 if (u->source->set_mute)
1624 u->source->set_mute(u->source);
1626 if (u->source->get_mute)
1627 u->source->get_mute(u->source);
1630 pa_source_put(u->source);
1642 static void userdata_free(struct userdata *u) {
1646 pa_source_unlink(u->source);
1649 pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
1650 pa_thread_free(u->thread);
1653 pa_thread_mq_done(&u->thread_mq);
1656 pa_source_unref(u->source);
1658 if (u->alsa_rtpoll_item)
1659 pa_rtpoll_item_free(u->alsa_rtpoll_item);
1662 pa_rtpoll_free(u->rtpoll);
1665 pa_alsa_fdlist_free(u->mixer_fdl);
1667 if (u->mixer_handle)
1668 snd_mixer_close(u->mixer_handle);
1670 if (u->pcm_handle) {
1671 snd_pcm_drop(u->pcm_handle);
1672 snd_pcm_close(u->pcm_handle);
1676 pa_smoother_free(u->smoother);
1680 pa_xfree(u->device_name);
1684 void pa_alsa_source_free(pa_source *s) {
1687 pa_source_assert_ref(s);
1688 pa_assert_se(u = s->userdata);