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 VOLUME_ACCURACY (PA_VOLUME_NORM/100)
76 pa_thread_mq thread_mq;
79 snd_pcm_t *pcm_handle;
81 pa_alsa_fdlist *mixer_fdl;
82 snd_mixer_t *mixer_handle;
83 pa_alsa_path_set *mixer_path_set;
84 pa_alsa_path *mixer_path;
86 pa_cvolume hardware_volume;
101 char *control_device;
103 pa_bool_t use_mmap:1, use_tsched:1;
105 pa_rtpoll_item *alsa_rtpoll_item;
107 snd_mixer_selem_channel_id_t mixer_map[SND_MIXER_SCHN_LAST];
109 pa_smoother *smoother;
112 pa_reserve_wrapper *reserve;
113 pa_hook_slot *reserve_slot;
114 pa_reserve_monitor_wrapper *monitor;
115 pa_hook_slot *monitor_slot;
118 static void userdata_free(struct userdata *u);
120 static pa_hook_result_t reserve_cb(pa_reserve_wrapper *r, void *forced, struct userdata *u) {
124 if (pa_source_suspend(u->source, TRUE, PA_SUSPEND_APPLICATION) < 0)
125 return PA_HOOK_CANCEL;
130 static void reserve_done(struct userdata *u) {
133 if (u->reserve_slot) {
134 pa_hook_slot_free(u->reserve_slot);
135 u->reserve_slot = NULL;
139 pa_reserve_wrapper_unref(u->reserve);
144 static void reserve_update(struct userdata *u) {
145 const char *description;
148 if (!u->source || !u->reserve)
151 if ((description = pa_proplist_gets(u->source->proplist, PA_PROP_DEVICE_DESCRIPTION)))
152 pa_reserve_wrapper_set_application_device_name(u->reserve, description);
155 static int reserve_init(struct userdata *u, const char *dname) {
164 if (pa_in_system_mode())
167 /* We are resuming, try to lock the device */
168 if (!(rname = pa_alsa_get_reserve_name(dname)))
171 u->reserve = pa_reserve_wrapper_get(u->core, rname);
179 pa_assert(!u->reserve_slot);
180 u->reserve_slot = pa_hook_connect(pa_reserve_wrapper_hook(u->reserve), PA_HOOK_NORMAL, (pa_hook_cb_t) reserve_cb, u);
185 static pa_hook_result_t monitor_cb(pa_reserve_monitor_wrapper *w, void* busy, struct userdata *u) {
191 b = PA_PTR_TO_UINT(busy) && !u->reserve;
193 pa_source_suspend(u->source, b, PA_SUSPEND_APPLICATION);
197 static void monitor_done(struct userdata *u) {
200 if (u->monitor_slot) {
201 pa_hook_slot_free(u->monitor_slot);
202 u->monitor_slot = NULL;
206 pa_reserve_monitor_wrapper_unref(u->monitor);
211 static int reserve_monitor_init(struct userdata *u, const char *dname) {
217 if (pa_in_system_mode())
220 /* We are resuming, try to lock the device */
221 if (!(rname = pa_alsa_get_reserve_name(dname)))
224 u->monitor = pa_reserve_monitor_wrapper_get(u->core, rname);
230 pa_assert(!u->monitor_slot);
231 u->monitor_slot = pa_hook_connect(pa_reserve_monitor_wrapper_hook(u->monitor), PA_HOOK_NORMAL, (pa_hook_cb_t) monitor_cb, u);
236 static void fix_min_sleep_wakeup(struct userdata *u) {
237 size_t max_use, max_use_2;
240 max_use = u->hwbuf_size - u->hwbuf_unused;
241 max_use_2 = pa_frame_align(max_use/2, &u->source->sample_spec);
243 u->min_sleep = pa_usec_to_bytes(TSCHED_MIN_SLEEP_USEC, &u->source->sample_spec);
244 u->min_sleep = PA_CLAMP(u->min_sleep, u->frame_size, max_use_2);
246 u->min_wakeup = pa_usec_to_bytes(TSCHED_MIN_WAKEUP_USEC, &u->source->sample_spec);
247 u->min_wakeup = PA_CLAMP(u->min_wakeup, u->frame_size, max_use_2);
250 static void fix_tsched_watermark(struct userdata *u) {
254 max_use = u->hwbuf_size - u->hwbuf_unused;
256 if (u->tsched_watermark > max_use - u->min_sleep)
257 u->tsched_watermark = max_use - u->min_sleep;
259 if (u->tsched_watermark < u->min_wakeup)
260 u->tsched_watermark = u->min_wakeup;
263 static void adjust_after_overrun(struct userdata *u) {
264 size_t old_watermark;
265 pa_usec_t old_min_latency, new_min_latency;
268 pa_assert(u->use_tsched);
270 /* First, just try to increase the watermark */
271 old_watermark = u->tsched_watermark;
272 u->tsched_watermark = PA_MIN(u->tsched_watermark * 2, u->tsched_watermark + u->watermark_step);
274 fix_tsched_watermark(u);
276 if (old_watermark != u->tsched_watermark) {
277 pa_log_notice("Increasing wakeup watermark to %0.2f ms",
278 (double) pa_bytes_to_usec(u->tsched_watermark, &u->source->sample_spec) / PA_USEC_PER_MSEC);
282 /* Hmm, we cannot increase the watermark any further, hence let's raise the latency */
283 old_min_latency = u->source->thread_info.min_latency;
284 new_min_latency = PA_MIN(old_min_latency * 2, old_min_latency + TSCHED_WATERMARK_STEP_USEC);
285 new_min_latency = PA_MIN(new_min_latency, u->source->thread_info.max_latency);
287 if (old_min_latency != new_min_latency) {
288 pa_log_notice("Increasing minimal latency to %0.2f ms",
289 (double) new_min_latency / PA_USEC_PER_MSEC);
291 pa_source_set_latency_range_within_thread(u->source, new_min_latency, u->source->thread_info.max_latency);
295 /* When we reach this we're officialy fucked! */
298 static pa_usec_t hw_sleep_time(struct userdata *u, pa_usec_t *sleep_usec, pa_usec_t*process_usec) {
303 usec = pa_source_get_requested_latency_within_thread(u->source);
305 if (usec == (pa_usec_t) -1)
306 usec = pa_bytes_to_usec(u->hwbuf_size, &u->source->sample_spec);
308 wm = pa_bytes_to_usec(u->tsched_watermark, &u->source->sample_spec);
313 *sleep_usec = usec - wm;
317 pa_log_debug("Buffer time: %lu ms; Sleep time: %lu ms; Process time: %lu ms",
318 (unsigned long) (usec / PA_USEC_PER_MSEC),
319 (unsigned long) (*sleep_usec / PA_USEC_PER_MSEC),
320 (unsigned long) (*process_usec / PA_USEC_PER_MSEC));
326 static int try_recover(struct userdata *u, const char *call, int err) {
331 pa_log_debug("%s: %s", call, pa_alsa_strerror(err));
333 pa_assert(err != -EAGAIN);
336 pa_log_debug("%s: Buffer overrun!", call);
338 if (err == -ESTRPIPE)
339 pa_log_debug("%s: System suspended!", call);
341 if ((err = snd_pcm_recover(u->pcm_handle, err, 1)) < 0) {
342 pa_log("%s: %s", call, pa_alsa_strerror(err));
346 snd_pcm_start(u->pcm_handle);
350 static size_t check_left_to_record(struct userdata *u, size_t n_bytes) {
351 size_t left_to_record;
352 size_t rec_space = u->hwbuf_size - u->hwbuf_unused;
354 /* We use <= instead of < for this check here because an overrun
355 * only happens after the last sample was processed, not already when
356 * it is removed from the buffer. This is particularly important
357 * when block transfer is used. */
359 if (n_bytes <= rec_space) {
360 left_to_record = rec_space - n_bytes;
363 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);
373 if (pa_log_ratelimit())
374 pa_log_info("Overrun!");
377 adjust_after_overrun(u);
380 return left_to_record;
383 static int mmap_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled) {
384 pa_bool_t work_done = FALSE;
385 pa_usec_t max_sleep_usec = 0, process_usec = 0;
386 size_t left_to_record;
390 pa_source_assert_ref(u->source);
393 hw_sleep_time(u, &max_sleep_usec, &process_usec);
399 pa_bool_t after_avail = TRUE;
401 if (PA_UNLIKELY((n = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->source->sample_spec)) < 0)) {
403 if ((r = try_recover(u, "snd_pcm_avail", (int) n)) == 0)
409 n_bytes = (size_t) n * u->frame_size;
412 pa_log_debug("avail: %lu", (unsigned long) n_bytes);
415 left_to_record = check_left_to_record(u, n_bytes);
419 pa_bytes_to_usec(left_to_record, &u->source->sample_spec) > process_usec+max_sleep_usec/2) {
421 pa_log_debug("Not reading, because too early.");
426 if (PA_UNLIKELY(n_bytes <= 0)) {
430 char *dn = pa_alsa_get_driver_name_by_pcm(u->pcm_handle);
431 pa_log(_("ALSA woke us up to read new data from the device, but there was actually nothing to read!\n"
432 "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers.\n"
433 "We were woken up with POLLIN set -- however a subsequent snd_pcm_avail() returned 0 or another value < min_avail."),
439 pa_log_debug("Not reading, because not necessary.");
446 pa_log_debug("Not filling up, because already too many iterations.");
455 pa_log_debug("Reading");
460 const snd_pcm_channel_area_t *areas;
461 snd_pcm_uframes_t offset, frames;
464 snd_pcm_sframes_t sframes;
466 frames = (snd_pcm_uframes_t) (n_bytes / u->frame_size);
468 /* pa_log_debug("%lu frames to read", (unsigned long) frames); */
470 if (PA_UNLIKELY((err = pa_alsa_safe_mmap_begin(u->pcm_handle, &areas, &offset, &frames, u->hwbuf_size, &u->source->sample_spec)) < 0)) {
472 if (!after_avail && err == -EAGAIN)
475 if ((r = try_recover(u, "snd_pcm_mmap_begin", err)) == 0)
481 /* Make sure that if these memblocks need to be copied they will fit into one slot */
482 if (frames > pa_mempool_block_size_max(u->source->core->mempool)/u->frame_size)
483 frames = pa_mempool_block_size_max(u->source->core->mempool)/u->frame_size;
485 if (!after_avail && frames == 0)
488 pa_assert(frames > 0);
491 /* Check these are multiples of 8 bit */
492 pa_assert((areas[0].first & 7) == 0);
493 pa_assert((areas[0].step & 7)== 0);
495 /* We assume a single interleaved memory buffer */
496 pa_assert((areas[0].first >> 3) == 0);
497 pa_assert((areas[0].step >> 3) == u->frame_size);
499 p = (uint8_t*) areas[0].addr + (offset * u->frame_size);
501 chunk.memblock = pa_memblock_new_fixed(u->core->mempool, p, frames * u->frame_size, TRUE);
502 chunk.length = pa_memblock_get_length(chunk.memblock);
505 pa_source_post(u->source, &chunk);
506 pa_memblock_unref_fixed(chunk.memblock);
508 if (PA_UNLIKELY((sframes = snd_pcm_mmap_commit(u->pcm_handle, offset, frames)) < 0)) {
510 if ((r = try_recover(u, "snd_pcm_mmap_commit", (int) sframes)) == 0)
518 u->read_count += frames * u->frame_size;
521 pa_log_debug("Read %lu bytes (of possible %lu bytes)", (unsigned long) (frames * u->frame_size), (unsigned long) n_bytes);
524 if ((size_t) frames * u->frame_size >= n_bytes)
527 n_bytes -= (size_t) frames * u->frame_size;
531 *sleep_usec = pa_bytes_to_usec(left_to_record, &u->source->sample_spec);
533 if (*sleep_usec > process_usec)
534 *sleep_usec -= process_usec;
538 return work_done ? 1 : 0;
541 static int unix_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled) {
542 int work_done = FALSE;
543 pa_usec_t max_sleep_usec = 0, process_usec = 0;
544 size_t left_to_record;
548 pa_source_assert_ref(u->source);
551 hw_sleep_time(u, &max_sleep_usec, &process_usec);
557 pa_bool_t after_avail = TRUE;
559 if (PA_UNLIKELY((n = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->source->sample_spec)) < 0)) {
561 if ((r = try_recover(u, "snd_pcm_avail", (int) n)) == 0)
567 n_bytes = (size_t) n * u->frame_size;
568 left_to_record = check_left_to_record(u, n_bytes);
572 pa_bytes_to_usec(left_to_record, &u->source->sample_spec) > process_usec+max_sleep_usec/2)
575 if (PA_UNLIKELY(n_bytes <= 0)) {
579 char *dn = pa_alsa_get_driver_name_by_pcm(u->pcm_handle);
580 pa_log(_("ALSA woke us up to read new data from the device, but there was actually nothing to read!\n"
581 "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers.\n"
582 "We were woken up with POLLIN set -- however a subsequent snd_pcm_avail() returned 0 or another value < min_avail."),
592 pa_log_debug("Not filling up, because already too many iterations.");
602 snd_pcm_sframes_t frames;
605 chunk.memblock = pa_memblock_new(u->core->mempool, (size_t) -1);
607 frames = (snd_pcm_sframes_t) (pa_memblock_get_length(chunk.memblock) / u->frame_size);
609 if (frames > (snd_pcm_sframes_t) (n_bytes/u->frame_size))
610 frames = (snd_pcm_sframes_t) (n_bytes/u->frame_size);
612 /* pa_log_debug("%lu frames to read", (unsigned long) n); */
614 p = pa_memblock_acquire(chunk.memblock);
615 frames = snd_pcm_readi(u->pcm_handle, (uint8_t*) p, (snd_pcm_uframes_t) frames);
616 pa_memblock_release(chunk.memblock);
618 if (PA_UNLIKELY(frames < 0)) {
619 pa_memblock_unref(chunk.memblock);
621 if (!after_avail && (int) frames == -EAGAIN)
624 if ((r = try_recover(u, "snd_pcm_readi", (int) frames)) == 0)
630 if (!after_avail && frames == 0) {
631 pa_memblock_unref(chunk.memblock);
635 pa_assert(frames > 0);
639 chunk.length = (size_t) frames * u->frame_size;
641 pa_source_post(u->source, &chunk);
642 pa_memblock_unref(chunk.memblock);
646 u->read_count += frames * u->frame_size;
648 /* pa_log_debug("read %lu frames", (unsigned long) frames); */
650 if ((size_t) frames * u->frame_size >= n_bytes)
653 n_bytes -= (size_t) frames * u->frame_size;
657 *sleep_usec = pa_bytes_to_usec(left_to_record, &u->source->sample_spec);
659 if (*sleep_usec > process_usec)
660 *sleep_usec -= process_usec;
664 return work_done ? 1 : 0;
667 static void update_smoother(struct userdata *u) {
668 snd_pcm_sframes_t delay = 0;
671 pa_usec_t now1 = 0, now2;
672 snd_pcm_status_t *status;
674 snd_pcm_status_alloca(&status);
677 pa_assert(u->pcm_handle);
679 /* Let's update the time smoother */
681 if (PA_UNLIKELY((err = pa_alsa_safe_delay(u->pcm_handle, &delay, u->hwbuf_size, &u->source->sample_spec)) < 0)) {
682 pa_log_warn("Failed to get delay: %s", pa_alsa_strerror(err));
686 if (PA_UNLIKELY((err = snd_pcm_status(u->pcm_handle, status)) < 0))
687 pa_log_warn("Failed to get timestamp: %s", pa_alsa_strerror(err));
689 snd_htimestamp_t htstamp = { 0, 0 };
690 snd_pcm_status_get_htstamp(status, &htstamp);
691 now1 = pa_timespec_load(&htstamp);
694 position = u->read_count + ((uint64_t) delay * (uint64_t) u->frame_size);
696 /* Hmm, if the timestamp is 0, then it wasn't set and we take the current time */
698 now1 = pa_rtclock_now();
700 now2 = pa_bytes_to_usec(position, &u->source->sample_spec);
702 pa_smoother_put(u->smoother, now1, now2);
705 static pa_usec_t source_get_latency(struct userdata *u) {
707 pa_usec_t now1, now2;
711 now1 = pa_rtclock_now();
712 now2 = pa_smoother_get(u->smoother, now1);
714 delay = (int64_t) now2 - (int64_t) pa_bytes_to_usec(u->read_count, &u->source->sample_spec);
716 return delay >= 0 ? (pa_usec_t) delay : 0;
719 static int build_pollfd(struct userdata *u) {
721 pa_assert(u->pcm_handle);
723 if (u->alsa_rtpoll_item)
724 pa_rtpoll_item_free(u->alsa_rtpoll_item);
726 if (!(u->alsa_rtpoll_item = pa_alsa_build_pollfd(u->pcm_handle, u->rtpoll)))
732 static int suspend(struct userdata *u) {
734 pa_assert(u->pcm_handle);
736 pa_smoother_pause(u->smoother, pa_rtclock_now());
739 snd_pcm_close(u->pcm_handle);
740 u->pcm_handle = NULL;
742 if (u->alsa_rtpoll_item) {
743 pa_rtpoll_item_free(u->alsa_rtpoll_item);
744 u->alsa_rtpoll_item = NULL;
747 pa_log_info("Device suspended...");
752 static int update_sw_params(struct userdata *u) {
753 snd_pcm_uframes_t avail_min;
758 /* Use the full buffer if noone asked us for anything specific */
764 if ((latency = pa_source_get_requested_latency_within_thread(u->source)) != (pa_usec_t) -1) {
767 pa_log_debug("latency set to %0.2fms", (double) latency / PA_USEC_PER_MSEC);
769 b = pa_usec_to_bytes(latency, &u->source->sample_spec);
771 /* We need at least one sample in our buffer */
773 if (PA_UNLIKELY(b < u->frame_size))
776 u->hwbuf_unused = PA_LIKELY(b < u->hwbuf_size) ? (u->hwbuf_size - b) : 0;
779 fix_min_sleep_wakeup(u);
780 fix_tsched_watermark(u);
783 pa_log_debug("hwbuf_unused=%lu", (unsigned long) u->hwbuf_unused);
788 pa_usec_t sleep_usec, process_usec;
790 hw_sleep_time(u, &sleep_usec, &process_usec);
791 avail_min += pa_usec_to_bytes(sleep_usec, &u->source->sample_spec) / u->frame_size;
794 pa_log_debug("setting avail_min=%lu", (unsigned long) avail_min);
796 if ((err = pa_alsa_set_sw_params(u->pcm_handle, avail_min)) < 0) {
797 pa_log("Failed to set software parameters: %s", pa_alsa_strerror(err));
804 static int unsuspend(struct userdata *u) {
809 snd_pcm_uframes_t period_size;
812 pa_assert(!u->pcm_handle);
814 pa_log_info("Trying resume...");
816 if ((err = snd_pcm_open(&u->pcm_handle, u->device_name, SND_PCM_STREAM_CAPTURE,
817 /*SND_PCM_NONBLOCK|*/
818 SND_PCM_NO_AUTO_RESAMPLE|
819 SND_PCM_NO_AUTO_CHANNELS|
820 SND_PCM_NO_AUTO_FORMAT)) < 0) {
821 pa_log("Error opening PCM device %s: %s", u->device_name, pa_alsa_strerror(err));
825 ss = u->source->sample_spec;
826 nfrags = u->nfragments;
827 period_size = u->fragment_size / u->frame_size;
831 if ((err = pa_alsa_set_hw_params(u->pcm_handle, &ss, &nfrags, &period_size, u->hwbuf_size / u->frame_size, &b, &d, TRUE)) < 0) {
832 pa_log("Failed to set hardware parameters: %s", pa_alsa_strerror(err));
836 if (b != u->use_mmap || d != u->use_tsched) {
837 pa_log_warn("Resume failed, couldn't get original access mode.");
841 if (!pa_sample_spec_equal(&ss, &u->source->sample_spec)) {
842 pa_log_warn("Resume failed, couldn't restore original sample settings.");
846 if (nfrags != u->nfragments || period_size*u->frame_size != u->fragment_size) {
847 pa_log_warn("Resume failed, couldn't restore original fragment settings. (Old: %lu*%lu, New %lu*%lu)",
848 (unsigned long) u->nfragments, (unsigned long) u->fragment_size,
849 (unsigned long) nfrags, period_size * u->frame_size);
853 if (update_sw_params(u) < 0)
856 if (build_pollfd(u) < 0)
859 /* FIXME: We need to reload the volume somehow */
861 snd_pcm_start(u->pcm_handle);
864 pa_smoother_reset(u->smoother, pa_rtclock_now(), TRUE);
866 pa_log_info("Resumed successfully...");
872 snd_pcm_close(u->pcm_handle);
873 u->pcm_handle = NULL;
879 static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
880 struct userdata *u = PA_SOURCE(o)->userdata;
884 case PA_SOURCE_MESSAGE_GET_LATENCY: {
888 r = source_get_latency(u);
890 *((pa_usec_t*) data) = r;
895 case PA_SOURCE_MESSAGE_SET_STATE:
897 switch ((pa_source_state_t) PA_PTR_TO_UINT(data)) {
899 case PA_SOURCE_SUSPENDED:
900 pa_assert(PA_SOURCE_IS_OPENED(u->source->thread_info.state));
908 case PA_SOURCE_RUNNING:
910 if (u->source->thread_info.state == PA_SOURCE_INIT) {
911 if (build_pollfd(u) < 0)
914 snd_pcm_start(u->pcm_handle);
917 if (u->source->thread_info.state == PA_SOURCE_SUSPENDED) {
918 if (unsuspend(u) < 0)
924 case PA_SOURCE_UNLINKED:
926 case PA_SOURCE_INVALID_STATE:
933 return pa_source_process_msg(o, code, data, offset, chunk);
936 /* Called from main context */
937 static int source_set_state_cb(pa_source *s, pa_source_state_t new_state) {
938 pa_source_state_t old_state;
941 pa_source_assert_ref(s);
942 pa_assert_se(u = s->userdata);
944 old_state = pa_source_get_state(u->source);
946 if (PA_SINK_IS_OPENED(old_state) && new_state == PA_SINK_SUSPENDED)
948 else if (old_state == PA_SINK_SUSPENDED && PA_SINK_IS_OPENED(new_state))
949 if (reserve_init(u, u->device_name) < 0)
955 static int mixer_callback(snd_mixer_elem_t *elem, unsigned int mask) {
956 struct userdata *u = snd_mixer_elem_get_callback_private(elem);
959 pa_assert(u->mixer_handle);
961 if (mask == SND_CTL_EVENT_MASK_REMOVE)
964 if (mask & SND_CTL_EVENT_MASK_VALUE) {
965 pa_source_get_volume(u->source, TRUE);
966 pa_source_get_mute(u->source, TRUE);
972 static void source_get_volume_cb(pa_source *s) {
973 struct userdata *u = s->userdata;
975 char t[PA_CVOLUME_SNPRINT_MAX];
978 pa_assert(u->mixer_path);
979 pa_assert(u->mixer_handle);
981 if (pa_alsa_path_get_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r) < 0)
984 /* Shift down by the base volume, so that 0dB becomes maximum volume */
985 pa_sw_cvolume_multiply_scalar(&r, &r, s->base_volume);
987 pa_log_debug("Read hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &r));
989 if (pa_cvolume_equal(&u->hardware_volume, &r))
992 s->volume = u->hardware_volume = r;
994 /* Hmm, so the hardware volume changed, let's reset our software volume */
995 if (u->mixer_path->has_dB)
996 pa_source_set_soft_volume(s, NULL);
999 static void source_set_volume_cb(pa_source *s) {
1000 struct userdata *u = s->userdata;
1002 char t[PA_CVOLUME_SNPRINT_MAX];
1005 pa_assert(u->mixer_path);
1006 pa_assert(u->mixer_handle);
1008 /* Shift up by the base volume */
1009 pa_sw_cvolume_divide_scalar(&r, &s->volume, s->base_volume);
1011 if (pa_alsa_path_set_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r) < 0)
1014 /* Shift down by the base volume, so that 0dB becomes maximum volume */
1015 pa_sw_cvolume_multiply_scalar(&r, &r, s->base_volume);
1017 u->hardware_volume = r;
1019 if (u->mixer_path->has_dB) {
1020 pa_cvolume new_soft_volume;
1021 pa_bool_t accurate_enough;
1023 /* Match exactly what the user requested by software */
1024 pa_sw_cvolume_divide(&new_soft_volume, &s->volume, &u->hardware_volume);
1026 /* If the adjustment to do in software is only minimal we
1027 * can skip it. That saves us CPU at the expense of a bit of
1030 (pa_cvolume_min(&new_soft_volume) >= (PA_VOLUME_NORM - VOLUME_ACCURACY)) &&
1031 (pa_cvolume_max(&new_soft_volume) <= (PA_VOLUME_NORM + VOLUME_ACCURACY));
1033 pa_log_debug("Requested volume: %s", pa_cvolume_snprint(t, sizeof(t), &s->volume));
1034 pa_log_debug("Got hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &u->hardware_volume));
1035 pa_log_debug("Calculated software volume: %s (accurate-enough=%s)", pa_cvolume_snprint(t, sizeof(t), &new_soft_volume),
1036 pa_yes_no(accurate_enough));
1038 if (!accurate_enough)
1039 s->soft_volume = new_soft_volume;
1042 pa_log_debug("Wrote hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &r));
1044 /* We can't match exactly what the user requested, hence let's
1045 * at least tell the user about it */
1051 static void source_get_mute_cb(pa_source *s) {
1052 struct userdata *u = s->userdata;
1056 pa_assert(u->mixer_path);
1057 pa_assert(u->mixer_handle);
1059 if (pa_alsa_path_get_mute(u->mixer_path, u->mixer_handle, &b) < 0)
1065 static void source_set_mute_cb(pa_source *s) {
1066 struct userdata *u = s->userdata;
1069 pa_assert(u->mixer_path);
1070 pa_assert(u->mixer_handle);
1072 pa_alsa_path_set_mute(u->mixer_path, u->mixer_handle, s->muted);
1075 static int source_set_port_cb(pa_source *s, pa_device_port *p) {
1076 struct userdata *u = s->userdata;
1077 pa_alsa_port_data *data;
1081 pa_assert(u->mixer_handle);
1083 data = PA_DEVICE_PORT_DATA(p);
1085 pa_assert_se(u->mixer_path = data->path);
1086 pa_alsa_path_select(u->mixer_path, u->mixer_handle);
1088 if (u->mixer_path->has_volume && u->mixer_path->has_dB) {
1089 s->base_volume = pa_sw_volume_from_dB(-u->mixer_path->max_dB);
1090 s->n_volume_steps = PA_VOLUME_NORM+1;
1092 if (u->mixer_path->max_dB > 0.0)
1093 pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(s->base_volume));
1095 pa_log_info("No particular base volume set, fixing to 0 dB");
1097 s->base_volume = PA_VOLUME_NORM;
1098 s->n_volume_steps = u->mixer_path->max_volume - u->mixer_path->min_volume + 1;
1102 pa_alsa_setting_select(data->setting, u->mixer_handle);
1112 static void source_update_requested_latency_cb(pa_source *s) {
1113 struct userdata *u = s->userdata;
1119 update_sw_params(u);
1122 static void thread_func(void *userdata) {
1123 struct userdata *u = userdata;
1124 unsigned short revents = 0;
1128 pa_log_debug("Thread starting up");
1130 if (u->core->realtime_scheduling)
1131 pa_make_realtime(u->core->realtime_priority);
1133 pa_thread_mq_install(&u->thread_mq);
1139 pa_log_debug("Loop");
1142 /* Read some data and pass it to the sources */
1143 if (PA_SOURCE_IS_OPENED(u->source->thread_info.state)) {
1145 pa_usec_t sleep_usec = 0;
1148 work_done = mmap_read(u, &sleep_usec, revents & POLLIN);
1150 work_done = unix_read(u, &sleep_usec, revents & POLLIN);
1155 /* pa_log_debug("work_done = %i", work_done); */
1160 if (u->use_tsched) {
1163 /* OK, the capture buffer is now empty, let's
1164 * calculate when to wake up next */
1166 /* pa_log_debug("Waking up in %0.2fms (sound card clock).", (double) sleep_usec / PA_USEC_PER_MSEC); */
1168 /* Convert from the sound card time domain to the
1169 * system time domain */
1170 cusec = pa_smoother_translate(u->smoother, pa_rtclock_now(), sleep_usec);
1172 /* pa_log_debug("Waking up in %0.2fms (system clock).", (double) cusec / PA_USEC_PER_MSEC); */
1174 /* We don't trust the conversion, so we wake up whatever comes first */
1175 pa_rtpoll_set_timer_relative(u->rtpoll, PA_MIN(sleep_usec, cusec));
1177 } else if (u->use_tsched)
1179 /* OK, we're in an invalid state, let's disable our timers */
1180 pa_rtpoll_set_timer_disabled(u->rtpoll);
1182 /* Hmm, nothing to do. Let's sleep */
1183 if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
1189 /* Tell ALSA about this and process its response */
1190 if (PA_SOURCE_IS_OPENED(u->source->thread_info.state)) {
1191 struct pollfd *pollfd;
1195 pollfd = pa_rtpoll_item_get_pollfd(u->alsa_rtpoll_item, &n);
1197 if ((err = snd_pcm_poll_descriptors_revents(u->pcm_handle, pollfd, n, &revents)) < 0) {
1198 pa_log("snd_pcm_poll_descriptors_revents() failed: %s", pa_alsa_strerror(err));
1202 if (revents & ~POLLIN) {
1203 if (pa_alsa_recover_from_poll(u->pcm_handle, revents) < 0)
1206 snd_pcm_start(u->pcm_handle);
1207 } else if (revents && u->use_tsched && pa_log_ratelimit())
1208 pa_log_debug("Wakeup from ALSA!");
1215 /* If this was no regular exit from the loop we have to continue
1216 * processing messages until we received PA_MESSAGE_SHUTDOWN */
1217 pa_asyncmsgq_post(u->thread_mq.outq, PA_MSGOBJECT(u->core), PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0, NULL, NULL);
1218 pa_asyncmsgq_wait_for(u->thread_mq.inq, PA_MESSAGE_SHUTDOWN);
1221 pa_log_debug("Thread shutting down");
1224 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) {
1230 pa_assert(device_name);
1232 if ((n = pa_modargs_get_value(ma, "source_name", NULL))) {
1233 pa_source_new_data_set_name(data, n);
1234 data->namereg_fail = TRUE;
1238 if ((n = pa_modargs_get_value(ma, "name", NULL)))
1239 data->namereg_fail = TRUE;
1241 n = device_id ? device_id : device_name;
1242 data->namereg_fail = FALSE;
1246 t = pa_sprintf_malloc("alsa_input.%s.%s", n, mapping->name);
1248 t = pa_sprintf_malloc("alsa_input.%s", n);
1250 pa_source_new_data_set_name(data, t);
1254 static void find_mixer(struct userdata *u, pa_alsa_mapping *mapping, const char *element, pa_bool_t ignore_dB) {
1256 if (!mapping && !element)
1259 if (!(u->mixer_handle = pa_alsa_open_mixer_for_pcm(u->pcm_handle, &u->control_device))) {
1260 pa_log_info("Failed to find a working mixer device.");
1266 if (!(u->mixer_path = pa_alsa_path_synthesize(element, PA_ALSA_DIRECTION_INPUT)))
1269 if (pa_alsa_path_probe(u->mixer_path, u->mixer_handle, ignore_dB) < 0)
1272 pa_log_debug("Probed mixer path %s:", u->mixer_path->name);
1273 pa_alsa_path_dump(u->mixer_path);
1276 if (!(u->mixer_path_set = pa_alsa_path_set_new(mapping, PA_ALSA_DIRECTION_INPUT)))
1279 pa_alsa_path_set_probe(u->mixer_path_set, u->mixer_handle, ignore_dB);
1281 pa_log_debug("Probed mixer paths:");
1282 pa_alsa_path_set_dump(u->mixer_path_set);
1289 if (u->mixer_path_set) {
1290 pa_alsa_path_set_free(u->mixer_path_set);
1291 u->mixer_path_set = NULL;
1292 } else if (u->mixer_path) {
1293 pa_alsa_path_free(u->mixer_path);
1294 u->mixer_path = NULL;
1297 if (u->mixer_handle) {
1298 snd_mixer_close(u->mixer_handle);
1299 u->mixer_handle = NULL;
1303 static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB) {
1306 if (!u->mixer_handle)
1309 if (u->source->active_port) {
1310 pa_alsa_port_data *data;
1312 /* We have a list of supported paths, so let's activate the
1313 * one that has been chosen as active */
1315 data = PA_DEVICE_PORT_DATA(u->source->active_port);
1316 u->mixer_path = data->path;
1318 pa_alsa_path_select(data->path, u->mixer_handle);
1321 pa_alsa_setting_select(data->setting, u->mixer_handle);
1325 if (!u->mixer_path && u->mixer_path_set)
1326 u->mixer_path = u->mixer_path_set->paths;
1328 if (u->mixer_path) {
1329 /* Hmm, we have only a single path, then let's activate it */
1331 pa_alsa_path_select(u->mixer_path, u->mixer_handle);
1333 if (u->mixer_path->settings)
1334 pa_alsa_setting_select(u->mixer_path->settings, u->mixer_handle);
1339 if (!u->mixer_path->has_volume)
1340 pa_log_info("Driver does not support hardware volume control, falling back to software volume control.");
1343 if (u->mixer_path->has_dB) {
1344 pa_log_info("Hardware volume ranges from %0.2f dB to %0.2f dB.", u->mixer_path->min_dB, u->mixer_path->max_dB);
1346 u->source->base_volume = pa_sw_volume_from_dB(-u->mixer_path->max_dB);
1347 u->source->n_volume_steps = PA_VOLUME_NORM+1;
1349 if (u->mixer_path->max_dB > 0.0)
1350 pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(u->source->base_volume));
1352 pa_log_info("No particular base volume set, fixing to 0 dB");
1355 pa_log_info("Hardware volume ranges from %li to %li.", u->mixer_path->min_volume, u->mixer_path->max_volume);
1356 u->source->base_volume = PA_VOLUME_NORM;
1357 u->source->n_volume_steps = u->mixer_path->max_volume - u->mixer_path->min_volume + 1;
1360 u->source->get_volume = source_get_volume_cb;
1361 u->source->set_volume = source_set_volume_cb;
1363 u->source->flags |= PA_SOURCE_HW_VOLUME_CTRL | (u->mixer_path->has_dB ? PA_SOURCE_DECIBEL_VOLUME : 0);
1364 pa_log_info("Using hardware volume control. Hardware dB scale %s.", u->mixer_path->has_dB ? "supported" : "not supported");
1367 if (!u->mixer_path->has_mute) {
1368 pa_log_info("Driver does not support hardware mute control, falling back to software mute control.");
1370 u->source->get_mute = source_get_mute_cb;
1371 u->source->set_mute = source_set_mute_cb;
1372 u->source->flags |= PA_SOURCE_HW_MUTE_CTRL;
1373 pa_log_info("Using hardware mute control.");
1376 u->mixer_fdl = pa_alsa_fdlist_new();
1378 if (pa_alsa_fdlist_set_mixer(u->mixer_fdl, u->mixer_handle, u->core->mainloop) < 0) {
1379 pa_log("Failed to initialize file descriptor monitoring");
1383 if (u->mixer_path_set)
1384 pa_alsa_path_set_set_callback(u->mixer_path_set, u->mixer_handle, mixer_callback, u);
1386 pa_alsa_path_set_callback(u->mixer_path, u->mixer_handle, mixer_callback, u);
1391 pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, pa_card *card, pa_alsa_mapping *mapping) {
1393 struct userdata *u = NULL;
1394 const char *dev_id = NULL;
1395 pa_sample_spec ss, requested_ss;
1397 uint32_t nfrags, hwbuf_size, frag_size, tsched_size, tsched_watermark;
1398 snd_pcm_uframes_t period_frames, tsched_frames;
1400 pa_bool_t use_mmap = TRUE, b, use_tsched = TRUE, d, ignore_dB = FALSE;
1401 pa_source_new_data data;
1402 pa_alsa_profile_set *profile_set = NULL;
1407 ss = m->core->default_sample_spec;
1408 map = m->core->default_channel_map;
1409 if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_ALSA) < 0) {
1410 pa_log("Failed to parse sample specification");
1415 frame_size = pa_frame_size(&ss);
1417 nfrags = m->core->default_n_fragments;
1418 frag_size = (uint32_t) pa_usec_to_bytes(m->core->default_fragment_size_msec*PA_USEC_PER_MSEC, &ss);
1420 frag_size = (uint32_t) frame_size;
1421 tsched_size = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_BUFFER_USEC, &ss);
1422 tsched_watermark = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_WATERMARK_USEC, &ss);
1424 if (pa_modargs_get_value_u32(ma, "fragments", &nfrags) < 0 ||
1425 pa_modargs_get_value_u32(ma, "fragment_size", &frag_size) < 0 ||
1426 pa_modargs_get_value_u32(ma, "tsched_buffer_size", &tsched_size) < 0 ||
1427 pa_modargs_get_value_u32(ma, "tsched_buffer_watermark", &tsched_watermark) < 0) {
1428 pa_log("Failed to parse buffer metrics");
1432 hwbuf_size = frag_size * nfrags;
1433 period_frames = frag_size/frame_size;
1434 tsched_frames = tsched_size/frame_size;
1436 if (pa_modargs_get_value_boolean(ma, "mmap", &use_mmap) < 0) {
1437 pa_log("Failed to parse mmap argument.");
1441 if (pa_modargs_get_value_boolean(ma, "tsched", &use_tsched) < 0) {
1442 pa_log("Failed to parse timer_scheduling argument.");
1446 if (pa_modargs_get_value_boolean(ma, "ignore_dB", &ignore_dB) < 0) {
1447 pa_log("Failed to parse ignore_dB argument.");
1451 if (use_tsched && !pa_rtclock_hrtimer()) {
1452 pa_log_notice("Disabling timer-based scheduling because high-resolution timers are not available from the kernel.");
1456 u = pa_xnew0(struct userdata, 1);
1459 u->use_mmap = use_mmap;
1460 u->use_tsched = use_tsched;
1461 u->rtpoll = pa_rtpoll_new();
1462 pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
1464 u->smoother = pa_smoother_new(
1465 DEFAULT_TSCHED_WATERMARK_USEC*2,
1466 DEFAULT_TSCHED_WATERMARK_USEC*2,
1473 dev_id = pa_modargs_get_value(
1475 pa_modargs_get_value(ma, "device", DEFAULT_DEVICE));
1477 if (reserve_init(u, dev_id) < 0)
1480 if (reserve_monitor_init(u, dev_id) < 0)
1488 if (!(dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
1489 pa_log("device_id= not set");
1493 if (!(u->pcm_handle = pa_alsa_open_by_device_id_mapping(
1497 SND_PCM_STREAM_CAPTURE,
1498 &nfrags, &period_frames, tsched_frames,
1502 } else if ((dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
1504 if (!(profile_set = pa_alsa_profile_set_new(NULL, &map)))
1507 if (!(u->pcm_handle = pa_alsa_open_by_device_id_auto(
1511 SND_PCM_STREAM_CAPTURE,
1512 &nfrags, &period_frames, tsched_frames,
1513 &b, &d, profile_set, &mapping)))
1518 if (!(u->pcm_handle = pa_alsa_open_by_device_string(
1519 pa_modargs_get_value(ma, "device", DEFAULT_DEVICE),
1522 SND_PCM_STREAM_CAPTURE,
1523 &nfrags, &period_frames, tsched_frames,
1528 pa_assert(u->device_name);
1529 pa_log_info("Successfully opened device %s.", u->device_name);
1531 if (pa_alsa_pcm_is_modem(u->pcm_handle)) {
1532 pa_log_notice("Device %s is modem, refusing further initialization.", u->device_name);
1537 pa_log_info("Selected mapping '%s' (%s).", mapping->description, mapping->name);
1539 if (use_mmap && !b) {
1540 pa_log_info("Device doesn't support mmap(), falling back to UNIX read/write mode.");
1541 u->use_mmap = use_mmap = FALSE;
1544 if (use_tsched && (!b || !d)) {
1545 pa_log_info("Cannot enable timer-based scheduling, falling back to sound IRQ scheduling.");
1546 u->use_tsched = use_tsched = FALSE;
1549 if (use_tsched && !pa_alsa_pcm_is_hw(u->pcm_handle)) {
1550 pa_log_info("Device is not a hardware device, disabling timer-based scheduling.");
1551 u->use_tsched = use_tsched = FALSE;
1555 pa_log_info("Successfully enabled mmap() mode.");
1558 pa_log_info("Successfully enabled timer-based scheduling mode.");
1560 /* ALSA might tweak the sample spec, so recalculate the frame size */
1561 frame_size = pa_frame_size(&ss);
1563 find_mixer(u, mapping, pa_modargs_get_value(ma, "control", NULL), ignore_dB);
1565 pa_source_new_data_init(&data);
1566 data.driver = driver;
1569 set_source_name(&data, ma, dev_id, u->device_name, mapping);
1570 pa_source_new_data_set_sample_spec(&data, &ss);
1571 pa_source_new_data_set_channel_map(&data, &map);
1573 pa_alsa_init_proplist_pcm(m->core, data.proplist, u->pcm_handle);
1574 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, u->device_name);
1575 pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_BUFFER_SIZE, "%lu", (unsigned long) (period_frames * frame_size * nfrags));
1576 pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZE, "%lu", (unsigned long) (period_frames * frame_size));
1577 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_ACCESS_MODE, u->use_tsched ? "mmap+timer" : (u->use_mmap ? "mmap" : "serial"));
1580 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_NAME, mapping->name);
1581 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_DESCRIPTION, mapping->description);
1584 pa_alsa_init_description(data.proplist);
1586 if (u->control_device)
1587 pa_alsa_init_proplist_ctl(data.proplist, u->control_device);
1589 if (pa_modargs_get_proplist(ma, "source_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
1590 pa_log("Invalid properties");
1591 pa_source_new_data_done(&data);
1595 if (u->mixer_path_set)
1596 pa_alsa_add_ports(&data.ports, u->mixer_path_set);
1598 u->source = pa_source_new(m->core, &data, PA_SOURCE_HARDWARE|PA_SOURCE_LATENCY|(u->use_tsched ? PA_SOURCE_DYNAMIC_LATENCY : 0));
1599 pa_source_new_data_done(&data);
1602 pa_log("Failed to create source object");
1606 u->source->parent.process_msg = source_process_msg;
1607 u->source->update_requested_latency = source_update_requested_latency_cb;
1608 u->source->set_state = source_set_state_cb;
1609 u->source->set_port = source_set_port_cb;
1610 u->source->userdata = u;
1612 pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
1613 pa_source_set_rtpoll(u->source, u->rtpoll);
1615 u->frame_size = frame_size;
1616 u->fragment_size = frag_size = (uint32_t) (period_frames * frame_size);
1617 u->nfragments = nfrags;
1618 u->hwbuf_size = u->fragment_size * nfrags;
1619 u->tsched_watermark = pa_usec_to_bytes_round_up(pa_bytes_to_usec_round_up(tsched_watermark, &requested_ss), &u->source->sample_spec);
1620 pa_cvolume_mute(&u->hardware_volume, u->source->sample_spec.channels);
1622 pa_log_info("Using %u fragments of size %lu bytes, buffer time is %0.2fms",
1623 nfrags, (long unsigned) u->fragment_size,
1624 (double) pa_bytes_to_usec(u->hwbuf_size, &ss) / PA_USEC_PER_MSEC);
1626 if (u->use_tsched) {
1627 u->watermark_step = pa_usec_to_bytes(TSCHED_WATERMARK_STEP_USEC, &u->source->sample_spec);
1629 fix_min_sleep_wakeup(u);
1630 fix_tsched_watermark(u);
1632 pa_source_set_latency_range(u->source,
1634 pa_bytes_to_usec(u->hwbuf_size, &ss));
1636 pa_log_info("Time scheduling watermark is %0.2fms",
1637 (double) pa_bytes_to_usec(u->tsched_watermark, &ss) / PA_USEC_PER_MSEC);
1639 pa_source_set_fixed_latency(u->source, pa_bytes_to_usec(u->hwbuf_size, &ss));
1643 if (update_sw_params(u) < 0)
1646 if (setup_mixer(u, ignore_dB) < 0)
1649 pa_alsa_dump(PA_LOG_DEBUG, u->pcm_handle);
1651 if (!(u->thread = pa_thread_new(thread_func, u))) {
1652 pa_log("Failed to create thread.");
1655 /* Get initial mixer settings */
1656 if (data.volume_is_set) {
1657 if (u->source->set_volume)
1658 u->source->set_volume(u->source);
1660 if (u->source->get_volume)
1661 u->source->get_volume(u->source);
1664 if (data.muted_is_set) {
1665 if (u->source->set_mute)
1666 u->source->set_mute(u->source);
1668 if (u->source->get_mute)
1669 u->source->get_mute(u->source);
1672 pa_source_put(u->source);
1675 pa_alsa_profile_set_free(profile_set);
1685 pa_alsa_profile_set_free(profile_set);
1690 static void userdata_free(struct userdata *u) {
1694 pa_source_unlink(u->source);
1697 pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
1698 pa_thread_free(u->thread);
1701 pa_thread_mq_done(&u->thread_mq);
1704 pa_source_unref(u->source);
1706 if (u->alsa_rtpoll_item)
1707 pa_rtpoll_item_free(u->alsa_rtpoll_item);
1710 pa_rtpoll_free(u->rtpoll);
1712 if (u->pcm_handle) {
1713 snd_pcm_drop(u->pcm_handle);
1714 snd_pcm_close(u->pcm_handle);
1718 pa_alsa_fdlist_free(u->mixer_fdl);
1720 if (u->mixer_path_set)
1721 pa_alsa_path_set_free(u->mixer_path_set);
1722 else if (u->mixer_path)
1723 pa_alsa_path_free(u->mixer_path);
1725 if (u->mixer_handle)
1726 snd_mixer_close(u->mixer_handle);
1729 pa_smoother_free(u->smoother);
1734 pa_xfree(u->device_name);
1735 pa_xfree(u->control_device);
1739 void pa_alsa_source_free(pa_source *s) {
1742 pa_source_assert_ref(s);
1743 pa_assert_se(u = s->userdata);