2 This file is part of PulseAudio.
4 Copyright 2004-2008 Lennart Poettering
5 Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
7 PulseAudio is free software; you can redistribute it and/or modify
8 it under the terms of the GNU Lesser General Public License as published
9 by the Free Software Foundation; either version 2.1 of the License,
10 or (at your option) any later version.
12 PulseAudio is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public License
18 along with PulseAudio; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
29 #include <asoundlib.h>
31 #include <pulse/i18n.h>
32 #include <pulse/rtclock.h>
33 #include <pulse/timeval.h>
34 #include <pulse/util.h>
35 #include <pulse/xmalloc.h>
37 #include <pulsecore/core-error.h>
38 #include <pulsecore/core.h>
39 #include <pulsecore/module.h>
40 #include <pulsecore/memchunk.h>
41 #include <pulsecore/sink.h>
42 #include <pulsecore/modargs.h>
43 #include <pulsecore/core-rtclock.h>
44 #include <pulsecore/core-util.h>
45 #include <pulsecore/sample-util.h>
46 #include <pulsecore/log.h>
47 #include <pulsecore/macro.h>
48 #include <pulsecore/thread.h>
49 #include <pulsecore/core-error.h>
50 #include <pulsecore/thread-mq.h>
51 #include <pulsecore/rtpoll.h>
52 #include <pulsecore/time-smoother.h>
54 #include <modules/reserve-wrap.h>
56 #include "alsa-util.h"
57 #include "alsa-source.h"
59 /* #define DEBUG_TIMING */
61 #define DEFAULT_DEVICE "default"
62 #define DEFAULT_TSCHED_BUFFER_USEC (2*PA_USEC_PER_SEC) /* 2s */
63 #define DEFAULT_TSCHED_WATERMARK_USEC (20*PA_USEC_PER_MSEC) /* 20ms */
64 #define TSCHED_WATERMARK_STEP_USEC (10*PA_USEC_PER_MSEC) /* 10ms */
65 #define TSCHED_MIN_SLEEP_USEC (10*PA_USEC_PER_MSEC) /* 10ms */
66 #define TSCHED_MIN_WAKEUP_USEC (4*PA_USEC_PER_MSEC) /* 4ms */
68 #define SMOOTHER_MIN_INTERVAL (2*PA_USEC_PER_MSEC) /* 2ms */
69 #define SMOOTHER_MAX_INTERVAL (200*PA_USEC_PER_MSEC) /* 200ms */
71 #define VOLUME_ACCURACY (PA_VOLUME_NORM/100)
79 pa_thread_mq thread_mq;
82 snd_pcm_t *pcm_handle;
84 pa_alsa_fdlist *mixer_fdl;
85 snd_mixer_t *mixer_handle;
86 pa_alsa_path_set *mixer_path_set;
87 pa_alsa_path *mixer_path;
89 pa_cvolume hardware_volume;
104 char *control_device;
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;
114 pa_usec_t smoother_interval;
115 pa_usec_t last_smoother_update;
117 pa_reserve_wrapper *reserve;
118 pa_hook_slot *reserve_slot;
119 pa_reserve_monitor_wrapper *monitor;
120 pa_hook_slot *monitor_slot;
123 static void userdata_free(struct userdata *u);
125 static pa_hook_result_t reserve_cb(pa_reserve_wrapper *r, void *forced, struct userdata *u) {
129 if (pa_source_suspend(u->source, TRUE, PA_SUSPEND_APPLICATION) < 0)
130 return PA_HOOK_CANCEL;
135 static void reserve_done(struct userdata *u) {
138 if (u->reserve_slot) {
139 pa_hook_slot_free(u->reserve_slot);
140 u->reserve_slot = NULL;
144 pa_reserve_wrapper_unref(u->reserve);
149 static void reserve_update(struct userdata *u) {
150 const char *description;
153 if (!u->source || !u->reserve)
156 if ((description = pa_proplist_gets(u->source->proplist, PA_PROP_DEVICE_DESCRIPTION)))
157 pa_reserve_wrapper_set_application_device_name(u->reserve, description);
160 static int reserve_init(struct userdata *u, const char *dname) {
169 if (pa_in_system_mode())
172 /* We are resuming, try to lock the device */
173 if (!(rname = pa_alsa_get_reserve_name(dname)))
176 u->reserve = pa_reserve_wrapper_get(u->core, rname);
184 pa_assert(!u->reserve_slot);
185 u->reserve_slot = pa_hook_connect(pa_reserve_wrapper_hook(u->reserve), PA_HOOK_NORMAL, (pa_hook_cb_t) reserve_cb, u);
190 static pa_hook_result_t monitor_cb(pa_reserve_monitor_wrapper *w, void* busy, struct userdata *u) {
196 b = PA_PTR_TO_UINT(busy) && !u->reserve;
198 pa_source_suspend(u->source, b, PA_SUSPEND_APPLICATION);
202 static void monitor_done(struct userdata *u) {
205 if (u->monitor_slot) {
206 pa_hook_slot_free(u->monitor_slot);
207 u->monitor_slot = NULL;
211 pa_reserve_monitor_wrapper_unref(u->monitor);
216 static int reserve_monitor_init(struct userdata *u, const char *dname) {
222 if (pa_in_system_mode())
225 /* We are resuming, try to lock the device */
226 if (!(rname = pa_alsa_get_reserve_name(dname)))
229 u->monitor = pa_reserve_monitor_wrapper_get(u->core, rname);
235 pa_assert(!u->monitor_slot);
236 u->monitor_slot = pa_hook_connect(pa_reserve_monitor_wrapper_hook(u->monitor), PA_HOOK_NORMAL, (pa_hook_cb_t) monitor_cb, u);
241 static void fix_min_sleep_wakeup(struct userdata *u) {
242 size_t max_use, max_use_2;
245 max_use = u->hwbuf_size - u->hwbuf_unused;
246 max_use_2 = pa_frame_align(max_use/2, &u->source->sample_spec);
248 u->min_sleep = pa_usec_to_bytes(TSCHED_MIN_SLEEP_USEC, &u->source->sample_spec);
249 u->min_sleep = PA_CLAMP(u->min_sleep, u->frame_size, max_use_2);
251 u->min_wakeup = pa_usec_to_bytes(TSCHED_MIN_WAKEUP_USEC, &u->source->sample_spec);
252 u->min_wakeup = PA_CLAMP(u->min_wakeup, u->frame_size, max_use_2);
255 static void fix_tsched_watermark(struct userdata *u) {
259 max_use = u->hwbuf_size - u->hwbuf_unused;
261 if (u->tsched_watermark > max_use - u->min_sleep)
262 u->tsched_watermark = max_use - u->min_sleep;
264 if (u->tsched_watermark < u->min_wakeup)
265 u->tsched_watermark = u->min_wakeup;
268 static void adjust_after_overrun(struct userdata *u) {
269 size_t old_watermark;
270 pa_usec_t old_min_latency, new_min_latency;
273 pa_assert(u->use_tsched);
275 /* First, just try to increase the watermark */
276 old_watermark = u->tsched_watermark;
277 u->tsched_watermark = PA_MIN(u->tsched_watermark * 2, u->tsched_watermark + u->watermark_step);
279 fix_tsched_watermark(u);
281 if (old_watermark != u->tsched_watermark) {
282 pa_log_notice("Increasing wakeup watermark to %0.2f ms",
283 (double) pa_bytes_to_usec(u->tsched_watermark, &u->source->sample_spec) / PA_USEC_PER_MSEC);
287 /* Hmm, we cannot increase the watermark any further, hence let's raise the latency */
288 old_min_latency = u->source->thread_info.min_latency;
289 new_min_latency = PA_MIN(old_min_latency * 2, old_min_latency + TSCHED_WATERMARK_STEP_USEC);
290 new_min_latency = PA_MIN(new_min_latency, u->source->thread_info.max_latency);
292 if (old_min_latency != new_min_latency) {
293 pa_log_notice("Increasing minimal latency to %0.2f ms",
294 (double) new_min_latency / PA_USEC_PER_MSEC);
296 pa_source_set_latency_range_within_thread(u->source, new_min_latency, u->source->thread_info.max_latency);
300 /* When we reach this we're officialy fucked! */
303 static pa_usec_t hw_sleep_time(struct userdata *u, pa_usec_t *sleep_usec, pa_usec_t*process_usec) {
308 usec = pa_source_get_requested_latency_within_thread(u->source);
310 if (usec == (pa_usec_t) -1)
311 usec = pa_bytes_to_usec(u->hwbuf_size, &u->source->sample_spec);
313 wm = pa_bytes_to_usec(u->tsched_watermark, &u->source->sample_spec);
318 *sleep_usec = usec - wm;
322 pa_log_debug("Buffer time: %lu ms; Sleep time: %lu ms; Process time: %lu ms",
323 (unsigned long) (usec / PA_USEC_PER_MSEC),
324 (unsigned long) (*sleep_usec / PA_USEC_PER_MSEC),
325 (unsigned long) (*process_usec / PA_USEC_PER_MSEC));
331 static int try_recover(struct userdata *u, const char *call, int err) {
336 pa_log_debug("%s: %s", call, pa_alsa_strerror(err));
338 pa_assert(err != -EAGAIN);
341 pa_log_debug("%s: Buffer overrun!", call);
343 if (err == -ESTRPIPE)
344 pa_log_debug("%s: System suspended!", call);
346 if ((err = snd_pcm_recover(u->pcm_handle, err, 1)) < 0) {
347 pa_log("%s: %s", call, pa_alsa_strerror(err));
351 snd_pcm_start(u->pcm_handle);
355 static size_t check_left_to_record(struct userdata *u, size_t n_bytes) {
356 size_t left_to_record;
357 size_t rec_space = u->hwbuf_size - u->hwbuf_unused;
359 /* We use <= instead of < for this check here because an overrun
360 * only happens after the last sample was processed, not already when
361 * it is removed from the buffer. This is particularly important
362 * when block transfer is used. */
364 if (n_bytes <= rec_space) {
365 left_to_record = rec_space - n_bytes;
368 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);
378 if (pa_log_ratelimit())
379 pa_log_info("Overrun!");
382 adjust_after_overrun(u);
385 return left_to_record;
388 static int mmap_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled) {
389 pa_bool_t work_done = FALSE;
390 pa_usec_t max_sleep_usec = 0, process_usec = 0;
391 size_t left_to_record;
395 pa_source_assert_ref(u->source);
398 hw_sleep_time(u, &max_sleep_usec, &process_usec);
404 pa_bool_t after_avail = TRUE;
406 if (PA_UNLIKELY((n = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->source->sample_spec)) < 0)) {
408 if ((r = try_recover(u, "snd_pcm_avail", (int) n)) == 0)
414 n_bytes = (size_t) n * u->frame_size;
417 pa_log_debug("avail: %lu", (unsigned long) n_bytes);
420 left_to_record = check_left_to_record(u, n_bytes);
424 pa_bytes_to_usec(left_to_record, &u->source->sample_spec) > process_usec+max_sleep_usec/2) {
426 pa_log_debug("Not reading, because too early.");
431 if (PA_UNLIKELY(n_bytes <= 0)) {
435 char *dn = pa_alsa_get_driver_name_by_pcm(u->pcm_handle);
436 pa_log(_("ALSA woke us up to read new data from the device, but there was actually nothing to read!\n"
437 "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers.\n"
438 "We were woken up with POLLIN set -- however a subsequent snd_pcm_avail() returned 0 or another value < min_avail."),
444 pa_log_debug("Not reading, because not necessary.");
451 pa_log_debug("Not filling up, because already too many iterations.");
460 pa_log_debug("Reading");
465 const snd_pcm_channel_area_t *areas;
466 snd_pcm_uframes_t offset, frames;
469 snd_pcm_sframes_t sframes;
471 frames = (snd_pcm_uframes_t) (n_bytes / u->frame_size);
473 /* pa_log_debug("%lu frames to read", (unsigned long) frames); */
475 if (PA_UNLIKELY((err = pa_alsa_safe_mmap_begin(u->pcm_handle, &areas, &offset, &frames, u->hwbuf_size, &u->source->sample_spec)) < 0)) {
477 if (!after_avail && err == -EAGAIN)
480 if ((r = try_recover(u, "snd_pcm_mmap_begin", err)) == 0)
486 /* Make sure that if these memblocks need to be copied they will fit into one slot */
487 if (frames > pa_mempool_block_size_max(u->source->core->mempool)/u->frame_size)
488 frames = pa_mempool_block_size_max(u->source->core->mempool)/u->frame_size;
490 if (!after_avail && frames == 0)
493 pa_assert(frames > 0);
496 /* Check these are multiples of 8 bit */
497 pa_assert((areas[0].first & 7) == 0);
498 pa_assert((areas[0].step & 7)== 0);
500 /* We assume a single interleaved memory buffer */
501 pa_assert((areas[0].first >> 3) == 0);
502 pa_assert((areas[0].step >> 3) == u->frame_size);
504 p = (uint8_t*) areas[0].addr + (offset * u->frame_size);
506 chunk.memblock = pa_memblock_new_fixed(u->core->mempool, p, frames * u->frame_size, TRUE);
507 chunk.length = pa_memblock_get_length(chunk.memblock);
510 pa_source_post(u->source, &chunk);
511 pa_memblock_unref_fixed(chunk.memblock);
513 if (PA_UNLIKELY((sframes = snd_pcm_mmap_commit(u->pcm_handle, offset, frames)) < 0)) {
515 if ((r = try_recover(u, "snd_pcm_mmap_commit", (int) sframes)) == 0)
523 u->read_count += frames * u->frame_size;
526 pa_log_debug("Read %lu bytes (of possible %lu bytes)", (unsigned long) (frames * u->frame_size), (unsigned long) n_bytes);
529 if ((size_t) frames * u->frame_size >= n_bytes)
532 n_bytes -= (size_t) frames * u->frame_size;
536 *sleep_usec = pa_bytes_to_usec(left_to_record, &u->source->sample_spec);
538 if (*sleep_usec > process_usec)
539 *sleep_usec -= process_usec;
543 return work_done ? 1 : 0;
546 static int unix_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled) {
547 int work_done = FALSE;
548 pa_usec_t max_sleep_usec = 0, process_usec = 0;
549 size_t left_to_record;
553 pa_source_assert_ref(u->source);
556 hw_sleep_time(u, &max_sleep_usec, &process_usec);
562 pa_bool_t after_avail = TRUE;
564 if (PA_UNLIKELY((n = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->source->sample_spec)) < 0)) {
566 if ((r = try_recover(u, "snd_pcm_avail", (int) n)) == 0)
572 n_bytes = (size_t) n * u->frame_size;
573 left_to_record = check_left_to_record(u, n_bytes);
577 pa_bytes_to_usec(left_to_record, &u->source->sample_spec) > process_usec+max_sleep_usec/2)
580 if (PA_UNLIKELY(n_bytes <= 0)) {
584 char *dn = pa_alsa_get_driver_name_by_pcm(u->pcm_handle);
585 pa_log(_("ALSA woke us up to read new data from the device, but there was actually nothing to read!\n"
586 "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers.\n"
587 "We were woken up with POLLIN set -- however a subsequent snd_pcm_avail() returned 0 or another value < min_avail."),
597 pa_log_debug("Not filling up, because already too many iterations.");
607 snd_pcm_sframes_t frames;
610 chunk.memblock = pa_memblock_new(u->core->mempool, (size_t) -1);
612 frames = (snd_pcm_sframes_t) (pa_memblock_get_length(chunk.memblock) / u->frame_size);
614 if (frames > (snd_pcm_sframes_t) (n_bytes/u->frame_size))
615 frames = (snd_pcm_sframes_t) (n_bytes/u->frame_size);
617 /* pa_log_debug("%lu frames to read", (unsigned long) n); */
619 p = pa_memblock_acquire(chunk.memblock);
620 frames = snd_pcm_readi(u->pcm_handle, (uint8_t*) p, (snd_pcm_uframes_t) frames);
621 pa_memblock_release(chunk.memblock);
623 if (PA_UNLIKELY(frames < 0)) {
624 pa_memblock_unref(chunk.memblock);
626 if (!after_avail && (int) frames == -EAGAIN)
629 if ((r = try_recover(u, "snd_pcm_readi", (int) frames)) == 0)
635 if (!after_avail && frames == 0) {
636 pa_memblock_unref(chunk.memblock);
640 pa_assert(frames > 0);
644 chunk.length = (size_t) frames * u->frame_size;
646 pa_source_post(u->source, &chunk);
647 pa_memblock_unref(chunk.memblock);
651 u->read_count += frames * u->frame_size;
653 /* pa_log_debug("read %lu frames", (unsigned long) frames); */
655 if ((size_t) frames * u->frame_size >= n_bytes)
658 n_bytes -= (size_t) frames * u->frame_size;
662 *sleep_usec = pa_bytes_to_usec(left_to_record, &u->source->sample_spec);
664 if (*sleep_usec > process_usec)
665 *sleep_usec -= process_usec;
669 return work_done ? 1 : 0;
672 static void update_smoother(struct userdata *u) {
673 snd_pcm_sframes_t delay = 0;
676 pa_usec_t now1 = 0, now2;
677 snd_pcm_status_t *status;
679 snd_pcm_status_alloca(&status);
682 pa_assert(u->pcm_handle);
684 /* Let's update the time smoother */
686 if (PA_UNLIKELY((err = pa_alsa_safe_delay(u->pcm_handle, &delay, u->hwbuf_size, &u->source->sample_spec)) < 0)) {
687 pa_log_warn("Failed to get delay: %s", pa_alsa_strerror(err));
691 if (PA_UNLIKELY((err = snd_pcm_status(u->pcm_handle, status)) < 0))
692 pa_log_warn("Failed to get timestamp: %s", pa_alsa_strerror(err));
694 snd_htimestamp_t htstamp = { 0, 0 };
695 snd_pcm_status_get_htstamp(status, &htstamp);
696 now1 = pa_timespec_load(&htstamp);
699 /* Hmm, if the timestamp is 0, then it wasn't set and we take the current time */
701 now1 = pa_rtclock_now();
703 /* check if the time since the last update is bigger than the interval */
704 if (u->last_smoother_update > 0)
705 if (u->last_smoother_update + u->smoother_interval > now1)
708 position = u->read_count + ((uint64_t) delay * (uint64_t) u->frame_size);
709 now2 = pa_bytes_to_usec(position, &u->source->sample_spec);
711 pa_smoother_put(u->smoother, now1, now2);
713 u->last_smoother_update = now1;
714 /* exponentially increase the update interval up to the MAX limit */
715 u->smoother_interval = PA_MIN (u->smoother_interval * 2, SMOOTHER_MAX_INTERVAL);
718 static pa_usec_t source_get_latency(struct userdata *u) {
720 pa_usec_t now1, now2;
724 now1 = pa_rtclock_now();
725 now2 = pa_smoother_get(u->smoother, now1);
727 delay = (int64_t) now2 - (int64_t) pa_bytes_to_usec(u->read_count, &u->source->sample_spec);
729 return delay >= 0 ? (pa_usec_t) delay : 0;
732 static int build_pollfd(struct userdata *u) {
734 pa_assert(u->pcm_handle);
736 if (u->alsa_rtpoll_item)
737 pa_rtpoll_item_free(u->alsa_rtpoll_item);
739 if (!(u->alsa_rtpoll_item = pa_alsa_build_pollfd(u->pcm_handle, u->rtpoll)))
745 static int suspend(struct userdata *u) {
747 pa_assert(u->pcm_handle);
749 pa_smoother_pause(u->smoother, pa_rtclock_now());
752 snd_pcm_close(u->pcm_handle);
753 u->pcm_handle = NULL;
755 if (u->alsa_rtpoll_item) {
756 pa_rtpoll_item_free(u->alsa_rtpoll_item);
757 u->alsa_rtpoll_item = NULL;
760 pa_log_info("Device suspended...");
765 static int update_sw_params(struct userdata *u) {
766 snd_pcm_uframes_t avail_min;
771 /* Use the full buffer if noone asked us for anything specific */
777 if ((latency = pa_source_get_requested_latency_within_thread(u->source)) != (pa_usec_t) -1) {
780 pa_log_debug("latency set to %0.2fms", (double) latency / PA_USEC_PER_MSEC);
782 b = pa_usec_to_bytes(latency, &u->source->sample_spec);
784 /* We need at least one sample in our buffer */
786 if (PA_UNLIKELY(b < u->frame_size))
789 u->hwbuf_unused = PA_LIKELY(b < u->hwbuf_size) ? (u->hwbuf_size - b) : 0;
792 fix_min_sleep_wakeup(u);
793 fix_tsched_watermark(u);
796 pa_log_debug("hwbuf_unused=%lu", (unsigned long) u->hwbuf_unused);
801 pa_usec_t sleep_usec, process_usec;
803 hw_sleep_time(u, &sleep_usec, &process_usec);
804 avail_min += pa_usec_to_bytes(sleep_usec, &u->source->sample_spec) / u->frame_size;
807 pa_log_debug("setting avail_min=%lu", (unsigned long) avail_min);
809 if ((err = pa_alsa_set_sw_params(u->pcm_handle, avail_min)) < 0) {
810 pa_log("Failed to set software parameters: %s", pa_alsa_strerror(err));
817 static int unsuspend(struct userdata *u) {
822 snd_pcm_uframes_t period_size;
825 pa_assert(!u->pcm_handle);
827 pa_log_info("Trying resume...");
829 if ((err = snd_pcm_open(&u->pcm_handle, u->device_name, SND_PCM_STREAM_CAPTURE,
830 /*SND_PCM_NONBLOCK|*/
831 SND_PCM_NO_AUTO_RESAMPLE|
832 SND_PCM_NO_AUTO_CHANNELS|
833 SND_PCM_NO_AUTO_FORMAT)) < 0) {
834 pa_log("Error opening PCM device %s: %s", u->device_name, pa_alsa_strerror(err));
838 ss = u->source->sample_spec;
839 nfrags = u->nfragments;
840 period_size = u->fragment_size / u->frame_size;
844 if ((err = pa_alsa_set_hw_params(u->pcm_handle, &ss, &nfrags, &period_size, u->hwbuf_size / u->frame_size, &b, &d, TRUE)) < 0) {
845 pa_log("Failed to set hardware parameters: %s", pa_alsa_strerror(err));
849 if (b != u->use_mmap || d != u->use_tsched) {
850 pa_log_warn("Resume failed, couldn't get original access mode.");
854 if (!pa_sample_spec_equal(&ss, &u->source->sample_spec)) {
855 pa_log_warn("Resume failed, couldn't restore original sample settings.");
859 if (nfrags != u->nfragments || period_size*u->frame_size != u->fragment_size) {
860 pa_log_warn("Resume failed, couldn't restore original fragment settings. (Old: %lu*%lu, New %lu*%lu)",
861 (unsigned long) u->nfragments, (unsigned long) u->fragment_size,
862 (unsigned long) nfrags, period_size * u->frame_size);
866 if (update_sw_params(u) < 0)
869 if (build_pollfd(u) < 0)
872 /* FIXME: We need to reload the volume somehow */
874 snd_pcm_start(u->pcm_handle);
877 pa_smoother_reset(u->smoother, pa_rtclock_now(), TRUE);
878 u->smoother_interval = SMOOTHER_MIN_INTERVAL;
879 u->last_smoother_update = 0;
881 pa_log_info("Resumed successfully...");
887 snd_pcm_close(u->pcm_handle);
888 u->pcm_handle = NULL;
894 static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
895 struct userdata *u = PA_SOURCE(o)->userdata;
899 case PA_SOURCE_MESSAGE_GET_LATENCY: {
903 r = source_get_latency(u);
905 *((pa_usec_t*) data) = r;
910 case PA_SOURCE_MESSAGE_SET_STATE:
912 switch ((pa_source_state_t) PA_PTR_TO_UINT(data)) {
914 case PA_SOURCE_SUSPENDED:
915 pa_assert(PA_SOURCE_IS_OPENED(u->source->thread_info.state));
923 case PA_SOURCE_RUNNING:
925 if (u->source->thread_info.state == PA_SOURCE_INIT) {
926 if (build_pollfd(u) < 0)
929 snd_pcm_start(u->pcm_handle);
932 if (u->source->thread_info.state == PA_SOURCE_SUSPENDED) {
933 if (unsuspend(u) < 0)
939 case PA_SOURCE_UNLINKED:
941 case PA_SOURCE_INVALID_STATE:
948 return pa_source_process_msg(o, code, data, offset, chunk);
951 /* Called from main context */
952 static int source_set_state_cb(pa_source *s, pa_source_state_t new_state) {
953 pa_source_state_t old_state;
956 pa_source_assert_ref(s);
957 pa_assert_se(u = s->userdata);
959 old_state = pa_source_get_state(u->source);
961 if (PA_SINK_IS_OPENED(old_state) && new_state == PA_SINK_SUSPENDED)
963 else if (old_state == PA_SINK_SUSPENDED && PA_SINK_IS_OPENED(new_state))
964 if (reserve_init(u, u->device_name) < 0)
970 static int mixer_callback(snd_mixer_elem_t *elem, unsigned int mask) {
971 struct userdata *u = snd_mixer_elem_get_callback_private(elem);
974 pa_assert(u->mixer_handle);
976 if (mask == SND_CTL_EVENT_MASK_REMOVE)
979 if (mask & SND_CTL_EVENT_MASK_VALUE) {
980 pa_source_get_volume(u->source, TRUE);
981 pa_source_get_mute(u->source, TRUE);
987 static void source_get_volume_cb(pa_source *s) {
988 struct userdata *u = s->userdata;
990 char t[PA_CVOLUME_SNPRINT_MAX];
993 pa_assert(u->mixer_path);
994 pa_assert(u->mixer_handle);
996 if (pa_alsa_path_get_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r) < 0)
999 /* Shift down by the base volume, so that 0dB becomes maximum volume */
1000 pa_sw_cvolume_multiply_scalar(&r, &r, s->base_volume);
1002 pa_log_debug("Read hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &r));
1004 if (pa_cvolume_equal(&u->hardware_volume, &r))
1007 s->volume = u->hardware_volume = r;
1009 /* Hmm, so the hardware volume changed, let's reset our software volume */
1010 if (u->mixer_path->has_dB)
1011 pa_source_set_soft_volume(s, NULL);
1014 static void source_set_volume_cb(pa_source *s) {
1015 struct userdata *u = s->userdata;
1017 char t[PA_CVOLUME_SNPRINT_MAX];
1020 pa_assert(u->mixer_path);
1021 pa_assert(u->mixer_handle);
1023 /* Shift up by the base volume */
1024 pa_sw_cvolume_divide_scalar(&r, &s->volume, s->base_volume);
1026 if (pa_alsa_path_set_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r) < 0)
1029 /* Shift down by the base volume, so that 0dB becomes maximum volume */
1030 pa_sw_cvolume_multiply_scalar(&r, &r, s->base_volume);
1032 u->hardware_volume = r;
1034 if (u->mixer_path->has_dB) {
1035 pa_cvolume new_soft_volume;
1036 pa_bool_t accurate_enough;
1038 /* Match exactly what the user requested by software */
1039 pa_sw_cvolume_divide(&new_soft_volume, &s->volume, &u->hardware_volume);
1041 /* If the adjustment to do in software is only minimal we
1042 * can skip it. That saves us CPU at the expense of a bit of
1045 (pa_cvolume_min(&new_soft_volume) >= (PA_VOLUME_NORM - VOLUME_ACCURACY)) &&
1046 (pa_cvolume_max(&new_soft_volume) <= (PA_VOLUME_NORM + VOLUME_ACCURACY));
1048 pa_log_debug("Requested volume: %s", pa_cvolume_snprint(t, sizeof(t), &s->volume));
1049 pa_log_debug("Got hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &u->hardware_volume));
1050 pa_log_debug("Calculated software volume: %s (accurate-enough=%s)", pa_cvolume_snprint(t, sizeof(t), &new_soft_volume),
1051 pa_yes_no(accurate_enough));
1053 if (!accurate_enough)
1054 s->soft_volume = new_soft_volume;
1057 pa_log_debug("Wrote hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &r));
1059 /* We can't match exactly what the user requested, hence let's
1060 * at least tell the user about it */
1066 static void source_get_mute_cb(pa_source *s) {
1067 struct userdata *u = s->userdata;
1071 pa_assert(u->mixer_path);
1072 pa_assert(u->mixer_handle);
1074 if (pa_alsa_path_get_mute(u->mixer_path, u->mixer_handle, &b) < 0)
1080 static void source_set_mute_cb(pa_source *s) {
1081 struct userdata *u = s->userdata;
1084 pa_assert(u->mixer_path);
1085 pa_assert(u->mixer_handle);
1087 pa_alsa_path_set_mute(u->mixer_path, u->mixer_handle, s->muted);
1090 static int source_set_port_cb(pa_source *s, pa_device_port *p) {
1091 struct userdata *u = s->userdata;
1092 pa_alsa_port_data *data;
1096 pa_assert(u->mixer_handle);
1098 data = PA_DEVICE_PORT_DATA(p);
1100 pa_assert_se(u->mixer_path = data->path);
1101 pa_alsa_path_select(u->mixer_path, u->mixer_handle);
1103 if (u->mixer_path->has_volume && u->mixer_path->has_dB) {
1104 s->base_volume = pa_sw_volume_from_dB(-u->mixer_path->max_dB);
1105 s->n_volume_steps = PA_VOLUME_NORM+1;
1107 if (u->mixer_path->max_dB > 0.0)
1108 pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(s->base_volume));
1110 pa_log_info("No particular base volume set, fixing to 0 dB");
1112 s->base_volume = PA_VOLUME_NORM;
1113 s->n_volume_steps = u->mixer_path->max_volume - u->mixer_path->min_volume + 1;
1117 pa_alsa_setting_select(data->setting, u->mixer_handle);
1127 static void source_update_requested_latency_cb(pa_source *s) {
1128 struct userdata *u = s->userdata;
1134 update_sw_params(u);
1137 static void thread_func(void *userdata) {
1138 struct userdata *u = userdata;
1139 unsigned short revents = 0;
1143 pa_log_debug("Thread starting up");
1145 if (u->core->realtime_scheduling)
1146 pa_make_realtime(u->core->realtime_priority);
1148 pa_thread_mq_install(&u->thread_mq);
1154 pa_log_debug("Loop");
1157 /* Read some data and pass it to the sources */
1158 if (PA_SOURCE_IS_OPENED(u->source->thread_info.state)) {
1160 pa_usec_t sleep_usec = 0;
1163 work_done = mmap_read(u, &sleep_usec, revents & POLLIN);
1165 work_done = unix_read(u, &sleep_usec, revents & POLLIN);
1170 /* pa_log_debug("work_done = %i", work_done); */
1175 if (u->use_tsched) {
1178 /* OK, the capture buffer is now empty, let's
1179 * calculate when to wake up next */
1181 /* pa_log_debug("Waking up in %0.2fms (sound card clock).", (double) sleep_usec / PA_USEC_PER_MSEC); */
1183 /* Convert from the sound card time domain to the
1184 * system time domain */
1185 cusec = pa_smoother_translate(u->smoother, pa_rtclock_now(), sleep_usec);
1187 /* pa_log_debug("Waking up in %0.2fms (system clock).", (double) cusec / PA_USEC_PER_MSEC); */
1189 /* We don't trust the conversion, so we wake up whatever comes first */
1190 pa_rtpoll_set_timer_relative(u->rtpoll, PA_MIN(sleep_usec, cusec));
1192 } else if (u->use_tsched)
1194 /* OK, we're in an invalid state, let's disable our timers */
1195 pa_rtpoll_set_timer_disabled(u->rtpoll);
1197 /* Hmm, nothing to do. Let's sleep */
1198 if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
1204 /* Tell ALSA about this and process its response */
1205 if (PA_SOURCE_IS_OPENED(u->source->thread_info.state)) {
1206 struct pollfd *pollfd;
1210 pollfd = pa_rtpoll_item_get_pollfd(u->alsa_rtpoll_item, &n);
1212 if ((err = snd_pcm_poll_descriptors_revents(u->pcm_handle, pollfd, n, &revents)) < 0) {
1213 pa_log("snd_pcm_poll_descriptors_revents() failed: %s", pa_alsa_strerror(err));
1217 if (revents & ~POLLIN) {
1218 if (pa_alsa_recover_from_poll(u->pcm_handle, revents) < 0)
1221 snd_pcm_start(u->pcm_handle);
1222 } else if (revents && u->use_tsched && pa_log_ratelimit())
1223 pa_log_debug("Wakeup from ALSA!");
1230 /* If this was no regular exit from the loop we have to continue
1231 * processing messages until we received PA_MESSAGE_SHUTDOWN */
1232 pa_asyncmsgq_post(u->thread_mq.outq, PA_MSGOBJECT(u->core), PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0, NULL, NULL);
1233 pa_asyncmsgq_wait_for(u->thread_mq.inq, PA_MESSAGE_SHUTDOWN);
1236 pa_log_debug("Thread shutting down");
1239 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) {
1245 pa_assert(device_name);
1247 if ((n = pa_modargs_get_value(ma, "source_name", NULL))) {
1248 pa_source_new_data_set_name(data, n);
1249 data->namereg_fail = TRUE;
1253 if ((n = pa_modargs_get_value(ma, "name", NULL)))
1254 data->namereg_fail = TRUE;
1256 n = device_id ? device_id : device_name;
1257 data->namereg_fail = FALSE;
1261 t = pa_sprintf_malloc("alsa_input.%s.%s", n, mapping->name);
1263 t = pa_sprintf_malloc("alsa_input.%s", n);
1265 pa_source_new_data_set_name(data, t);
1269 static void find_mixer(struct userdata *u, pa_alsa_mapping *mapping, const char *element, pa_bool_t ignore_dB) {
1271 if (!mapping && !element)
1274 if (!(u->mixer_handle = pa_alsa_open_mixer_for_pcm(u->pcm_handle, &u->control_device))) {
1275 pa_log_info("Failed to find a working mixer device.");
1281 if (!(u->mixer_path = pa_alsa_path_synthesize(element, PA_ALSA_DIRECTION_INPUT)))
1284 if (pa_alsa_path_probe(u->mixer_path, u->mixer_handle, ignore_dB) < 0)
1287 pa_log_debug("Probed mixer path %s:", u->mixer_path->name);
1288 pa_alsa_path_dump(u->mixer_path);
1291 if (!(u->mixer_path_set = pa_alsa_path_set_new(mapping, PA_ALSA_DIRECTION_INPUT)))
1294 pa_alsa_path_set_probe(u->mixer_path_set, u->mixer_handle, ignore_dB);
1296 pa_log_debug("Probed mixer paths:");
1297 pa_alsa_path_set_dump(u->mixer_path_set);
1304 if (u->mixer_path_set) {
1305 pa_alsa_path_set_free(u->mixer_path_set);
1306 u->mixer_path_set = NULL;
1307 } else if (u->mixer_path) {
1308 pa_alsa_path_free(u->mixer_path);
1309 u->mixer_path = NULL;
1312 if (u->mixer_handle) {
1313 snd_mixer_close(u->mixer_handle);
1314 u->mixer_handle = NULL;
1318 static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB) {
1321 if (!u->mixer_handle)
1324 if (u->source->active_port) {
1325 pa_alsa_port_data *data;
1327 /* We have a list of supported paths, so let's activate the
1328 * one that has been chosen as active */
1330 data = PA_DEVICE_PORT_DATA(u->source->active_port);
1331 u->mixer_path = data->path;
1333 pa_alsa_path_select(data->path, u->mixer_handle);
1336 pa_alsa_setting_select(data->setting, u->mixer_handle);
1340 if (!u->mixer_path && u->mixer_path_set)
1341 u->mixer_path = u->mixer_path_set->paths;
1343 if (u->mixer_path) {
1344 /* Hmm, we have only a single path, then let's activate it */
1346 pa_alsa_path_select(u->mixer_path, u->mixer_handle);
1348 if (u->mixer_path->settings)
1349 pa_alsa_setting_select(u->mixer_path->settings, u->mixer_handle);
1354 if (!u->mixer_path->has_volume)
1355 pa_log_info("Driver does not support hardware volume control, falling back to software volume control.");
1358 if (u->mixer_path->has_dB) {
1359 pa_log_info("Hardware volume ranges from %0.2f dB to %0.2f dB.", u->mixer_path->min_dB, u->mixer_path->max_dB);
1361 u->source->base_volume = pa_sw_volume_from_dB(-u->mixer_path->max_dB);
1362 u->source->n_volume_steps = PA_VOLUME_NORM+1;
1364 if (u->mixer_path->max_dB > 0.0)
1365 pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(u->source->base_volume));
1367 pa_log_info("No particular base volume set, fixing to 0 dB");
1370 pa_log_info("Hardware volume ranges from %li to %li.", u->mixer_path->min_volume, u->mixer_path->max_volume);
1371 u->source->base_volume = PA_VOLUME_NORM;
1372 u->source->n_volume_steps = u->mixer_path->max_volume - u->mixer_path->min_volume + 1;
1375 u->source->get_volume = source_get_volume_cb;
1376 u->source->set_volume = source_set_volume_cb;
1378 u->source->flags |= PA_SOURCE_HW_VOLUME_CTRL | (u->mixer_path->has_dB ? PA_SOURCE_DECIBEL_VOLUME : 0);
1379 pa_log_info("Using hardware volume control. Hardware dB scale %s.", u->mixer_path->has_dB ? "supported" : "not supported");
1382 if (!u->mixer_path->has_mute) {
1383 pa_log_info("Driver does not support hardware mute control, falling back to software mute control.");
1385 u->source->get_mute = source_get_mute_cb;
1386 u->source->set_mute = source_set_mute_cb;
1387 u->source->flags |= PA_SOURCE_HW_MUTE_CTRL;
1388 pa_log_info("Using hardware mute control.");
1391 u->mixer_fdl = pa_alsa_fdlist_new();
1393 if (pa_alsa_fdlist_set_mixer(u->mixer_fdl, u->mixer_handle, u->core->mainloop) < 0) {
1394 pa_log("Failed to initialize file descriptor monitoring");
1398 if (u->mixer_path_set)
1399 pa_alsa_path_set_set_callback(u->mixer_path_set, u->mixer_handle, mixer_callback, u);
1401 pa_alsa_path_set_callback(u->mixer_path, u->mixer_handle, mixer_callback, u);
1406 pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, pa_card *card, pa_alsa_mapping *mapping) {
1408 struct userdata *u = NULL;
1409 const char *dev_id = NULL;
1410 pa_sample_spec ss, requested_ss;
1412 uint32_t nfrags, hwbuf_size, frag_size, tsched_size, tsched_watermark;
1413 snd_pcm_uframes_t period_frames, tsched_frames;
1415 pa_bool_t use_mmap = TRUE, b, use_tsched = TRUE, d, ignore_dB = FALSE;
1416 pa_source_new_data data;
1417 pa_alsa_profile_set *profile_set = NULL;
1422 ss = m->core->default_sample_spec;
1423 map = m->core->default_channel_map;
1424 if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_ALSA) < 0) {
1425 pa_log("Failed to parse sample specification");
1430 frame_size = pa_frame_size(&ss);
1432 nfrags = m->core->default_n_fragments;
1433 frag_size = (uint32_t) pa_usec_to_bytes(m->core->default_fragment_size_msec*PA_USEC_PER_MSEC, &ss);
1435 frag_size = (uint32_t) frame_size;
1436 tsched_size = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_BUFFER_USEC, &ss);
1437 tsched_watermark = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_WATERMARK_USEC, &ss);
1439 if (pa_modargs_get_value_u32(ma, "fragments", &nfrags) < 0 ||
1440 pa_modargs_get_value_u32(ma, "fragment_size", &frag_size) < 0 ||
1441 pa_modargs_get_value_u32(ma, "tsched_buffer_size", &tsched_size) < 0 ||
1442 pa_modargs_get_value_u32(ma, "tsched_buffer_watermark", &tsched_watermark) < 0) {
1443 pa_log("Failed to parse buffer metrics");
1447 hwbuf_size = frag_size * nfrags;
1448 period_frames = frag_size/frame_size;
1449 tsched_frames = tsched_size/frame_size;
1451 if (pa_modargs_get_value_boolean(ma, "mmap", &use_mmap) < 0) {
1452 pa_log("Failed to parse mmap argument.");
1456 if (pa_modargs_get_value_boolean(ma, "tsched", &use_tsched) < 0) {
1457 pa_log("Failed to parse timer_scheduling argument.");
1461 if (pa_modargs_get_value_boolean(ma, "ignore_dB", &ignore_dB) < 0) {
1462 pa_log("Failed to parse ignore_dB argument.");
1466 if (use_tsched && !pa_rtclock_hrtimer()) {
1467 pa_log_notice("Disabling timer-based scheduling because high-resolution timers are not available from the kernel.");
1471 u = pa_xnew0(struct userdata, 1);
1474 u->use_mmap = use_mmap;
1475 u->use_tsched = use_tsched;
1476 u->rtpoll = pa_rtpoll_new();
1477 pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
1479 u->smoother = pa_smoother_new(
1480 DEFAULT_TSCHED_WATERMARK_USEC*2,
1481 DEFAULT_TSCHED_WATERMARK_USEC*2,
1487 u->smoother_interval = SMOOTHER_MIN_INTERVAL;
1489 dev_id = pa_modargs_get_value(
1491 pa_modargs_get_value(ma, "device", DEFAULT_DEVICE));
1493 if (reserve_init(u, dev_id) < 0)
1496 if (reserve_monitor_init(u, dev_id) < 0)
1504 if (!(dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
1505 pa_log("device_id= not set");
1509 if (!(u->pcm_handle = pa_alsa_open_by_device_id_mapping(
1513 SND_PCM_STREAM_CAPTURE,
1514 &nfrags, &period_frames, tsched_frames,
1518 } else if ((dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
1520 if (!(profile_set = pa_alsa_profile_set_new(NULL, &map)))
1523 if (!(u->pcm_handle = pa_alsa_open_by_device_id_auto(
1527 SND_PCM_STREAM_CAPTURE,
1528 &nfrags, &period_frames, tsched_frames,
1529 &b, &d, profile_set, &mapping)))
1534 if (!(u->pcm_handle = pa_alsa_open_by_device_string(
1535 pa_modargs_get_value(ma, "device", DEFAULT_DEVICE),
1538 SND_PCM_STREAM_CAPTURE,
1539 &nfrags, &period_frames, tsched_frames,
1544 pa_assert(u->device_name);
1545 pa_log_info("Successfully opened device %s.", u->device_name);
1547 if (pa_alsa_pcm_is_modem(u->pcm_handle)) {
1548 pa_log_notice("Device %s is modem, refusing further initialization.", u->device_name);
1553 pa_log_info("Selected mapping '%s' (%s).", mapping->description, mapping->name);
1555 if (use_mmap && !b) {
1556 pa_log_info("Device doesn't support mmap(), falling back to UNIX read/write mode.");
1557 u->use_mmap = use_mmap = FALSE;
1560 if (use_tsched && (!b || !d)) {
1561 pa_log_info("Cannot enable timer-based scheduling, falling back to sound IRQ scheduling.");
1562 u->use_tsched = use_tsched = FALSE;
1565 if (use_tsched && !pa_alsa_pcm_is_hw(u->pcm_handle)) {
1566 pa_log_info("Device is not a hardware device, disabling timer-based scheduling.");
1567 u->use_tsched = use_tsched = FALSE;
1571 pa_log_info("Successfully enabled mmap() mode.");
1574 pa_log_info("Successfully enabled timer-based scheduling mode.");
1576 /* ALSA might tweak the sample spec, so recalculate the frame size */
1577 frame_size = pa_frame_size(&ss);
1579 find_mixer(u, mapping, pa_modargs_get_value(ma, "control", NULL), ignore_dB);
1581 pa_source_new_data_init(&data);
1582 data.driver = driver;
1585 set_source_name(&data, ma, dev_id, u->device_name, mapping);
1586 pa_source_new_data_set_sample_spec(&data, &ss);
1587 pa_source_new_data_set_channel_map(&data, &map);
1589 pa_alsa_init_proplist_pcm(m->core, data.proplist, u->pcm_handle);
1590 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, u->device_name);
1591 pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_BUFFER_SIZE, "%lu", (unsigned long) (period_frames * frame_size * nfrags));
1592 pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZE, "%lu", (unsigned long) (period_frames * frame_size));
1593 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_ACCESS_MODE, u->use_tsched ? "mmap+timer" : (u->use_mmap ? "mmap" : "serial"));
1596 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_NAME, mapping->name);
1597 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_DESCRIPTION, mapping->description);
1600 pa_alsa_init_description(data.proplist);
1602 if (u->control_device)
1603 pa_alsa_init_proplist_ctl(data.proplist, u->control_device);
1605 if (pa_modargs_get_proplist(ma, "source_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
1606 pa_log("Invalid properties");
1607 pa_source_new_data_done(&data);
1611 if (u->mixer_path_set)
1612 pa_alsa_add_ports(&data.ports, u->mixer_path_set);
1614 u->source = pa_source_new(m->core, &data, PA_SOURCE_HARDWARE|PA_SOURCE_LATENCY|(u->use_tsched ? PA_SOURCE_DYNAMIC_LATENCY : 0));
1615 pa_source_new_data_done(&data);
1618 pa_log("Failed to create source object");
1622 u->source->parent.process_msg = source_process_msg;
1623 u->source->update_requested_latency = source_update_requested_latency_cb;
1624 u->source->set_state = source_set_state_cb;
1625 u->source->set_port = source_set_port_cb;
1626 u->source->userdata = u;
1628 pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
1629 pa_source_set_rtpoll(u->source, u->rtpoll);
1631 u->frame_size = frame_size;
1632 u->fragment_size = frag_size = (uint32_t) (period_frames * frame_size);
1633 u->nfragments = nfrags;
1634 u->hwbuf_size = u->fragment_size * nfrags;
1635 u->tsched_watermark = pa_usec_to_bytes_round_up(pa_bytes_to_usec_round_up(tsched_watermark, &requested_ss), &u->source->sample_spec);
1636 pa_cvolume_mute(&u->hardware_volume, u->source->sample_spec.channels);
1638 pa_log_info("Using %u fragments of size %lu bytes, buffer time is %0.2fms",
1639 nfrags, (long unsigned) u->fragment_size,
1640 (double) pa_bytes_to_usec(u->hwbuf_size, &ss) / PA_USEC_PER_MSEC);
1642 if (u->use_tsched) {
1643 u->watermark_step = pa_usec_to_bytes(TSCHED_WATERMARK_STEP_USEC, &u->source->sample_spec);
1645 fix_min_sleep_wakeup(u);
1646 fix_tsched_watermark(u);
1648 pa_source_set_latency_range(u->source,
1650 pa_bytes_to_usec(u->hwbuf_size, &ss));
1652 pa_log_info("Time scheduling watermark is %0.2fms",
1653 (double) pa_bytes_to_usec(u->tsched_watermark, &ss) / PA_USEC_PER_MSEC);
1655 pa_source_set_fixed_latency(u->source, pa_bytes_to_usec(u->hwbuf_size, &ss));
1659 if (update_sw_params(u) < 0)
1662 if (setup_mixer(u, ignore_dB) < 0)
1665 pa_alsa_dump(PA_LOG_DEBUG, u->pcm_handle);
1667 if (!(u->thread = pa_thread_new(thread_func, u))) {
1668 pa_log("Failed to create thread.");
1671 /* Get initial mixer settings */
1672 if (data.volume_is_set) {
1673 if (u->source->set_volume)
1674 u->source->set_volume(u->source);
1676 if (u->source->get_volume)
1677 u->source->get_volume(u->source);
1680 if (data.muted_is_set) {
1681 if (u->source->set_mute)
1682 u->source->set_mute(u->source);
1684 if (u->source->get_mute)
1685 u->source->get_mute(u->source);
1688 pa_source_put(u->source);
1691 pa_alsa_profile_set_free(profile_set);
1701 pa_alsa_profile_set_free(profile_set);
1706 static void userdata_free(struct userdata *u) {
1710 pa_source_unlink(u->source);
1713 pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
1714 pa_thread_free(u->thread);
1717 pa_thread_mq_done(&u->thread_mq);
1720 pa_source_unref(u->source);
1722 if (u->alsa_rtpoll_item)
1723 pa_rtpoll_item_free(u->alsa_rtpoll_item);
1726 pa_rtpoll_free(u->rtpoll);
1728 if (u->pcm_handle) {
1729 snd_pcm_drop(u->pcm_handle);
1730 snd_pcm_close(u->pcm_handle);
1734 pa_alsa_fdlist_free(u->mixer_fdl);
1736 if (u->mixer_path_set)
1737 pa_alsa_path_set_free(u->mixer_path_set);
1738 else if (u->mixer_path)
1739 pa_alsa_path_free(u->mixer_path);
1741 if (u->mixer_handle)
1742 snd_mixer_close(u->mixer_handle);
1745 pa_smoother_free(u->smoother);
1750 pa_xfree(u->device_name);
1751 pa_xfree(u->control_device);
1755 void pa_alsa_source_free(pa_source *s) {
1758 pa_source_assert_ref(s);
1759 pa_assert_se(u = s->userdata);