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, see <http://www.gnu.org/licenses/>.
28 #include <asoundlib.h>
30 #include <pulse/rtclock.h>
31 #include <pulse/timeval.h>
32 #include <pulse/volume.h>
33 #include <pulse/xmalloc.h>
35 #include <pulsecore/core.h>
36 #include <pulsecore/i18n.h>
37 #include <pulsecore/module.h>
38 #include <pulsecore/memchunk.h>
39 #include <pulsecore/sink.h>
40 #include <pulsecore/modargs.h>
41 #include <pulsecore/core-rtclock.h>
42 #include <pulsecore/core-util.h>
43 #include <pulsecore/sample-util.h>
44 #include <pulsecore/log.h>
45 #include <pulsecore/macro.h>
46 #include <pulsecore/thread.h>
47 #include <pulsecore/thread-mq.h>
48 #include <pulsecore/rtpoll.h>
49 #include <pulsecore/time-smoother.h>
51 #include <modules/reserve-wrap.h>
53 #include "alsa-util.h"
54 #include "alsa-source.h"
56 /* #define DEBUG_TIMING */
58 #define DEFAULT_DEVICE "default"
60 #define DEFAULT_TSCHED_BUFFER_USEC (2*PA_USEC_PER_SEC) /* 2s */
61 #define DEFAULT_TSCHED_WATERMARK_USEC (20*PA_USEC_PER_MSEC) /* 20ms */
63 #define TSCHED_WATERMARK_INC_STEP_USEC (10*PA_USEC_PER_MSEC) /* 10ms */
64 #define TSCHED_WATERMARK_DEC_STEP_USEC (5*PA_USEC_PER_MSEC) /* 5ms */
65 #define TSCHED_WATERMARK_VERIFY_AFTER_USEC (20*PA_USEC_PER_SEC) /* 20s */
66 #define TSCHED_WATERMARK_INC_THRESHOLD_USEC (0*PA_USEC_PER_MSEC) /* 0ms */
67 #define TSCHED_WATERMARK_DEC_THRESHOLD_USEC (100*PA_USEC_PER_MSEC) /* 100ms */
68 #define TSCHED_WATERMARK_STEP_USEC (10*PA_USEC_PER_MSEC) /* 10ms */
70 #define TSCHED_MIN_SLEEP_USEC (10*PA_USEC_PER_MSEC) /* 10ms */
71 #define TSCHED_MIN_WAKEUP_USEC (4*PA_USEC_PER_MSEC) /* 4ms */
73 #define SMOOTHER_WINDOW_USEC (10*PA_USEC_PER_SEC) /* 10s */
74 #define SMOOTHER_ADJUST_USEC (1*PA_USEC_PER_SEC) /* 1s */
76 #define SMOOTHER_MIN_INTERVAL (2*PA_USEC_PER_MSEC) /* 2ms */
77 #define SMOOTHER_MAX_INTERVAL (200*PA_USEC_PER_MSEC) /* 200ms */
79 #define VOLUME_ACCURACY (PA_VOLUME_NORM/100)
87 pa_thread_mq thread_mq;
90 snd_pcm_t *pcm_handle;
93 pa_alsa_fdlist *mixer_fdl;
94 pa_alsa_mixer_pdata *mixer_pd;
95 snd_mixer_t *mixer_handle;
96 pa_alsa_path_set *mixer_path_set;
97 pa_alsa_path *mixer_path;
99 pa_cvolume hardware_volume;
108 tsched_watermark_ref,
114 watermark_inc_threshold,
115 watermark_dec_threshold;
117 snd_pcm_uframes_t frames_per_block;
119 pa_usec_t watermark_dec_not_before;
120 pa_usec_t min_latency_ref;
121 pa_usec_t tsched_watermark_usec;
123 char *device_name; /* name of the PCM device */
124 char *control_device; /* name of the control device */
126 bool use_mmap:1, use_tsched:1, deferred_volume:1, fixed_latency_range:1;
130 pa_rtpoll_item *alsa_rtpoll_item;
132 pa_smoother *smoother;
134 pa_usec_t smoother_interval;
135 pa_usec_t last_smoother_update;
137 pa_reserve_wrapper *reserve;
138 pa_hook_slot *reserve_slot;
139 pa_reserve_monitor_wrapper *monitor;
140 pa_hook_slot *monitor_slot;
143 pa_alsa_ucm_mapping_context *ucm_context;
147 SOURCE_MESSAGE_SYNC_MIXER = PA_SOURCE_MESSAGE_MAX
150 static void userdata_free(struct userdata *u);
152 static pa_hook_result_t reserve_cb(pa_reserve_wrapper *r, void *forced, struct userdata *u) {
156 pa_log_debug("Suspending source %s, because another application requested us to release the device.", u->source->name);
158 if (pa_source_suspend(u->source, true, PA_SUSPEND_APPLICATION) < 0)
159 return PA_HOOK_CANCEL;
164 static void reserve_done(struct userdata *u) {
167 if (u->reserve_slot) {
168 pa_hook_slot_free(u->reserve_slot);
169 u->reserve_slot = NULL;
173 pa_reserve_wrapper_unref(u->reserve);
178 static void reserve_update(struct userdata *u) {
179 const char *description;
182 if (!u->source || !u->reserve)
185 if ((description = pa_proplist_gets(u->source->proplist, PA_PROP_DEVICE_DESCRIPTION)))
186 pa_reserve_wrapper_set_application_device_name(u->reserve, description);
189 static int reserve_init(struct userdata *u, const char *dname) {
198 if (pa_in_system_mode())
201 if (!(rname = pa_alsa_get_reserve_name(dname)))
204 /* We are resuming, try to lock the device */
205 u->reserve = pa_reserve_wrapper_get(u->core, rname);
213 pa_assert(!u->reserve_slot);
214 u->reserve_slot = pa_hook_connect(pa_reserve_wrapper_hook(u->reserve), PA_HOOK_NORMAL, (pa_hook_cb_t) reserve_cb, u);
219 static pa_hook_result_t monitor_cb(pa_reserve_monitor_wrapper *w, void* busy, struct userdata *u) {
223 if (PA_PTR_TO_UINT(busy) && !u->reserve) {
224 pa_log_debug("Suspending source %s, because another application is blocking the access to the device.", u->source->name);
225 pa_source_suspend(u->source, true, PA_SUSPEND_APPLICATION);
227 pa_log_debug("Resuming source %s, because other applications aren't blocking access to the device any more.", u->source->name);
228 pa_source_suspend(u->source, false, PA_SUSPEND_APPLICATION);
234 static void monitor_done(struct userdata *u) {
237 if (u->monitor_slot) {
238 pa_hook_slot_free(u->monitor_slot);
239 u->monitor_slot = NULL;
243 pa_reserve_monitor_wrapper_unref(u->monitor);
248 static int reserve_monitor_init(struct userdata *u, const char *dname) {
254 if (pa_in_system_mode())
257 if (!(rname = pa_alsa_get_reserve_name(dname)))
260 /* We are resuming, try to lock the device */
261 u->monitor = pa_reserve_monitor_wrapper_get(u->core, rname);
267 pa_assert(!u->monitor_slot);
268 u->monitor_slot = pa_hook_connect(pa_reserve_monitor_wrapper_hook(u->monitor), PA_HOOK_NORMAL, (pa_hook_cb_t) monitor_cb, u);
273 static void fix_min_sleep_wakeup(struct userdata *u) {
274 size_t max_use, max_use_2;
277 pa_assert(u->use_tsched);
279 max_use = u->hwbuf_size - u->hwbuf_unused;
280 max_use_2 = pa_frame_align(max_use/2, &u->source->sample_spec);
282 u->min_sleep = pa_usec_to_bytes(TSCHED_MIN_SLEEP_USEC, &u->source->sample_spec);
283 u->min_sleep = PA_CLAMP(u->min_sleep, u->frame_size, max_use_2);
285 u->min_wakeup = pa_usec_to_bytes(TSCHED_MIN_WAKEUP_USEC, &u->source->sample_spec);
286 u->min_wakeup = PA_CLAMP(u->min_wakeup, u->frame_size, max_use_2);
289 static void fix_tsched_watermark(struct userdata *u) {
292 pa_assert(u->use_tsched);
294 max_use = u->hwbuf_size - u->hwbuf_unused;
296 if (u->tsched_watermark > max_use - u->min_sleep)
297 u->tsched_watermark = max_use - u->min_sleep;
299 if (u->tsched_watermark < u->min_wakeup)
300 u->tsched_watermark = u->min_wakeup;
302 u->tsched_watermark_usec = pa_bytes_to_usec(u->tsched_watermark, &u->source->sample_spec);
305 static void increase_watermark(struct userdata *u) {
306 size_t old_watermark;
307 pa_usec_t old_min_latency, new_min_latency;
310 pa_assert(u->use_tsched);
312 /* First, just try to increase the watermark */
313 old_watermark = u->tsched_watermark;
314 u->tsched_watermark = PA_MIN(u->tsched_watermark * 2, u->tsched_watermark + u->watermark_inc_step);
315 fix_tsched_watermark(u);
317 if (old_watermark != u->tsched_watermark) {
318 pa_log_info("Increasing wakeup watermark to %0.2f ms",
319 (double) u->tsched_watermark_usec / PA_USEC_PER_MSEC);
323 /* Hmm, we cannot increase the watermark any further, hence let's
324 raise the latency unless doing so was disabled in
326 if (u->fixed_latency_range)
329 old_min_latency = u->source->thread_info.min_latency;
330 new_min_latency = PA_MIN(old_min_latency * 2, old_min_latency + TSCHED_WATERMARK_INC_STEP_USEC);
331 new_min_latency = PA_MIN(new_min_latency, u->source->thread_info.max_latency);
333 if (old_min_latency != new_min_latency) {
334 pa_log_info("Increasing minimal latency to %0.2f ms",
335 (double) new_min_latency / PA_USEC_PER_MSEC);
337 pa_source_set_latency_range_within_thread(u->source, new_min_latency, u->source->thread_info.max_latency);
340 /* When we reach this we're officially fucked! */
343 static void decrease_watermark(struct userdata *u) {
344 size_t old_watermark;
348 pa_assert(u->use_tsched);
350 now = pa_rtclock_now();
352 if (u->watermark_dec_not_before <= 0)
355 if (u->watermark_dec_not_before > now)
358 old_watermark = u->tsched_watermark;
360 if (u->tsched_watermark < u->watermark_dec_step)
361 u->tsched_watermark = u->tsched_watermark / 2;
363 u->tsched_watermark = PA_MAX(u->tsched_watermark / 2, u->tsched_watermark - u->watermark_dec_step);
365 fix_tsched_watermark(u);
367 if (old_watermark != u->tsched_watermark)
368 pa_log_info("Decreasing wakeup watermark to %0.2f ms",
369 (double) u->tsched_watermark_usec / PA_USEC_PER_MSEC);
371 /* We don't change the latency range*/
374 u->watermark_dec_not_before = now + TSCHED_WATERMARK_VERIFY_AFTER_USEC;
377 static void hw_sleep_time(struct userdata *u, pa_usec_t *sleep_usec, pa_usec_t*process_usec) {
380 pa_assert(sleep_usec);
381 pa_assert(process_usec);
384 pa_assert(u->use_tsched);
386 usec = pa_source_get_requested_latency_within_thread(u->source);
388 if (usec == (pa_usec_t) -1)
389 usec = pa_bytes_to_usec(u->hwbuf_size, &u->source->sample_spec);
391 wm = u->tsched_watermark_usec;
396 *sleep_usec = usec - wm;
400 pa_log_debug("Buffer time: %lu ms; Sleep time: %lu ms; Process time: %lu ms",
401 (unsigned long) (usec / PA_USEC_PER_MSEC),
402 (unsigned long) (*sleep_usec / PA_USEC_PER_MSEC),
403 (unsigned long) (*process_usec / PA_USEC_PER_MSEC));
407 static int try_recover(struct userdata *u, const char *call, int err) {
412 pa_log_debug("%s: %s", call, pa_alsa_strerror(err));
414 pa_assert(err != -EAGAIN);
417 pa_log_debug("%s: Buffer overrun!", call);
419 if (err == -ESTRPIPE)
420 pa_log_debug("%s: System suspended!", call);
422 if ((err = snd_pcm_recover(u->pcm_handle, err, 1)) < 0) {
423 pa_log("%s: %s", call, pa_alsa_strerror(err));
431 static size_t check_left_to_record(struct userdata *u, size_t n_bytes, bool on_timeout) {
432 size_t left_to_record;
433 size_t rec_space = u->hwbuf_size - u->hwbuf_unused;
434 bool overrun = false;
436 /* We use <= instead of < for this check here because an overrun
437 * only happens after the last sample was processed, not already when
438 * it is removed from the buffer. This is particularly important
439 * when block transfer is used. */
441 if (n_bytes <= rec_space)
442 left_to_record = rec_space - n_bytes;
445 /* We got a dropout. What a mess! */
453 if (pa_log_ratelimit(PA_LOG_INFO))
454 pa_log_info("Overrun!");
458 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);
462 bool reset_not_before = true;
464 if (overrun || left_to_record < u->watermark_inc_threshold)
465 increase_watermark(u);
466 else if (left_to_record > u->watermark_dec_threshold) {
467 reset_not_before = false;
469 /* We decrease the watermark only if have actually
470 * been woken up by a timeout. If something else woke
471 * us up it's too easy to fulfill the deadlines... */
474 decrease_watermark(u);
477 if (reset_not_before)
478 u->watermark_dec_not_before = 0;
481 return left_to_record;
484 static int mmap_read(struct userdata *u, pa_usec_t *sleep_usec, bool polled, bool on_timeout) {
485 bool work_done = false;
486 pa_usec_t max_sleep_usec = 0, process_usec = 0;
487 size_t left_to_record;
491 pa_source_assert_ref(u->source);
494 hw_sleep_time(u, &max_sleep_usec, &process_usec);
500 bool after_avail = true;
502 if (PA_UNLIKELY((n = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->source->sample_spec)) < 0)) {
504 if ((r = try_recover(u, "snd_pcm_avail", (int) n)) == 0)
510 n_bytes = (size_t) n * u->frame_size;
513 pa_log_debug("avail: %lu", (unsigned long) n_bytes);
516 left_to_record = check_left_to_record(u, n_bytes, on_timeout);
521 pa_bytes_to_usec(left_to_record, &u->source->sample_spec) > process_usec+max_sleep_usec/2) {
523 pa_log_debug("Not reading, because too early.");
528 if (PA_UNLIKELY(n_bytes <= 0)) {
532 char *dn = pa_alsa_get_driver_name_by_pcm(u->pcm_handle);
533 pa_log(_("ALSA woke us up to read new data from the device, but there was actually nothing to read.\n"
534 "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers.\n"
535 "We were woken up with POLLIN set -- however a subsequent snd_pcm_avail() returned 0 or another value < min_avail."),
541 pa_log_debug("Not reading, because not necessary.");
548 pa_log_debug("Not filling up, because already too many iterations.");
557 pa_log_debug("Reading");
564 const snd_pcm_channel_area_t *areas;
565 snd_pcm_uframes_t offset, frames;
566 snd_pcm_sframes_t sframes;
568 frames = (snd_pcm_uframes_t) (n_bytes / u->frame_size);
569 /* pa_log_debug("%lu frames to read", (unsigned long) frames); */
571 if (PA_UNLIKELY((err = pa_alsa_safe_mmap_begin(u->pcm_handle, &areas, &offset, &frames, u->hwbuf_size, &u->source->sample_spec)) < 0)) {
573 if (!after_avail && err == -EAGAIN)
576 if ((r = try_recover(u, "snd_pcm_mmap_begin", err)) == 0)
582 /* Make sure that if these memblocks need to be copied they will fit into one slot */
583 frames = PA_MIN(frames, u->frames_per_block);
585 if (!after_avail && frames == 0)
588 pa_assert(frames > 0);
591 /* Check these are multiples of 8 bit */
592 pa_assert((areas[0].first & 7) == 0);
593 pa_assert((areas[0].step & 7) == 0);
595 /* We assume a single interleaved memory buffer */
596 pa_assert((areas[0].first >> 3) == 0);
597 pa_assert((areas[0].step >> 3) == u->frame_size);
599 p = (uint8_t*) areas[0].addr + (offset * u->frame_size);
601 chunk.memblock = pa_memblock_new_fixed(u->core->mempool, p, frames * u->frame_size, true);
602 chunk.length = pa_memblock_get_length(chunk.memblock);
605 pa_source_post(u->source, &chunk);
606 pa_memblock_unref_fixed(chunk.memblock);
608 if (PA_UNLIKELY((sframes = snd_pcm_mmap_commit(u->pcm_handle, offset, frames)) < 0)) {
610 if ((r = try_recover(u, "snd_pcm_mmap_commit", (int) sframes)) == 0)
618 u->read_count += frames * u->frame_size;
621 pa_log_debug("Read %lu bytes (of possible %lu bytes)", (unsigned long) (frames * u->frame_size), (unsigned long) n_bytes);
624 if ((size_t) frames * u->frame_size >= n_bytes)
627 n_bytes -= (size_t) frames * u->frame_size;
632 *sleep_usec = pa_bytes_to_usec(left_to_record, &u->source->sample_spec);
633 process_usec = u->tsched_watermark_usec;
635 if (*sleep_usec > process_usec)
636 *sleep_usec -= process_usec;
641 return work_done ? 1 : 0;
644 static int unix_read(struct userdata *u, pa_usec_t *sleep_usec, bool polled, bool on_timeout) {
645 int work_done = false;
646 pa_usec_t max_sleep_usec = 0, process_usec = 0;
647 size_t left_to_record;
651 pa_source_assert_ref(u->source);
654 hw_sleep_time(u, &max_sleep_usec, &process_usec);
660 bool after_avail = true;
662 if (PA_UNLIKELY((n = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->source->sample_spec)) < 0)) {
664 if ((r = try_recover(u, "snd_pcm_avail", (int) n)) == 0)
670 n_bytes = (size_t) n * u->frame_size;
671 left_to_record = check_left_to_record(u, n_bytes, on_timeout);
676 pa_bytes_to_usec(left_to_record, &u->source->sample_spec) > process_usec+max_sleep_usec/2)
679 if (PA_UNLIKELY(n_bytes <= 0)) {
683 char *dn = pa_alsa_get_driver_name_by_pcm(u->pcm_handle);
684 pa_log(_("ALSA woke us up to read new data from the device, but there was actually nothing to read!\n"
685 "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers.\n"
686 "We were woken up with POLLIN set -- however a subsequent snd_pcm_avail() returned 0 or another value < min_avail."),
696 pa_log_debug("Not filling up, because already too many iterations.");
706 snd_pcm_sframes_t frames;
709 chunk.memblock = pa_memblock_new(u->core->mempool, (size_t) -1);
711 frames = (snd_pcm_sframes_t) (pa_memblock_get_length(chunk.memblock) / u->frame_size);
713 if (frames > (snd_pcm_sframes_t) (n_bytes/u->frame_size))
714 frames = (snd_pcm_sframes_t) (n_bytes/u->frame_size);
716 /* pa_log_debug("%lu frames to read", (unsigned long) n); */
718 p = pa_memblock_acquire(chunk.memblock);
719 frames = snd_pcm_readi(u->pcm_handle, (uint8_t*) p, (snd_pcm_uframes_t) frames);
720 pa_memblock_release(chunk.memblock);
722 if (PA_UNLIKELY(frames < 0)) {
723 pa_memblock_unref(chunk.memblock);
725 if (!after_avail && (int) frames == -EAGAIN)
728 if ((r = try_recover(u, "snd_pcm_readi", (int) frames)) == 0)
734 if (!after_avail && frames == 0) {
735 pa_memblock_unref(chunk.memblock);
739 pa_assert(frames > 0);
743 chunk.length = (size_t) frames * u->frame_size;
745 pa_source_post(u->source, &chunk);
746 pa_memblock_unref(chunk.memblock);
750 u->read_count += frames * u->frame_size;
752 /* pa_log_debug("read %lu frames", (unsigned long) frames); */
754 if ((size_t) frames * u->frame_size >= n_bytes)
757 n_bytes -= (size_t) frames * u->frame_size;
762 *sleep_usec = pa_bytes_to_usec(left_to_record, &u->source->sample_spec);
763 process_usec = u->tsched_watermark_usec;
765 if (*sleep_usec > process_usec)
766 *sleep_usec -= process_usec;
771 return work_done ? 1 : 0;
774 static void update_smoother(struct userdata *u) {
775 snd_pcm_sframes_t delay = 0;
778 pa_usec_t now1 = 0, now2;
779 snd_pcm_status_t *status;
780 snd_htimestamp_t htstamp = { 0, 0 };
782 snd_pcm_status_alloca(&status);
785 pa_assert(u->pcm_handle);
787 /* Let's update the time smoother */
789 if (PA_UNLIKELY((err = pa_alsa_safe_delay(u->pcm_handle, status, &delay, u->hwbuf_size, &u->source->sample_spec, true)) < 0)) {
790 pa_log_warn("Failed to get delay: %s", pa_alsa_strerror(err));
794 snd_pcm_status_get_htstamp(status, &htstamp);
795 now1 = pa_timespec_load(&htstamp);
797 /* Hmm, if the timestamp is 0, then it wasn't set and we take the current time */
799 now1 = pa_rtclock_now();
801 /* check if the time since the last update is bigger than the interval */
802 if (u->last_smoother_update > 0)
803 if (u->last_smoother_update + u->smoother_interval > now1)
806 position = u->read_count + ((uint64_t) delay * (uint64_t) u->frame_size);
807 now2 = pa_bytes_to_usec(position, &u->source->sample_spec);
809 pa_smoother_put(u->smoother, now1, now2);
811 u->last_smoother_update = now1;
812 /* exponentially increase the update interval up to the MAX limit */
813 u->smoother_interval = PA_MIN (u->smoother_interval * 2, SMOOTHER_MAX_INTERVAL);
816 static int64_t source_get_latency(struct userdata *u) {
818 pa_usec_t now1, now2;
822 now1 = pa_rtclock_now();
823 now2 = pa_smoother_get(u->smoother, now1);
825 delay = (int64_t) now2 - (int64_t) pa_bytes_to_usec(u->read_count, &u->source->sample_spec);
830 static int build_pollfd(struct userdata *u) {
832 pa_assert(u->pcm_handle);
834 if (u->alsa_rtpoll_item)
835 pa_rtpoll_item_free(u->alsa_rtpoll_item);
837 if (!(u->alsa_rtpoll_item = pa_alsa_build_pollfd(u->pcm_handle, u->rtpoll)))
843 /* Called from IO context */
844 static void suspend(struct userdata *u) {
846 pa_assert(u->pcm_handle);
848 pa_smoother_pause(u->smoother, pa_rtclock_now());
851 snd_pcm_close(u->pcm_handle);
852 u->pcm_handle = NULL;
854 if (u->alsa_rtpoll_item) {
855 pa_rtpoll_item_free(u->alsa_rtpoll_item);
856 u->alsa_rtpoll_item = NULL;
859 pa_log_info("Device suspended...");
862 /* Called from IO context */
863 static int update_sw_params(struct userdata *u) {
864 snd_pcm_uframes_t avail_min;
869 /* Use the full buffer if no one asked us for anything specific */
875 if ((latency = pa_source_get_requested_latency_within_thread(u->source)) != (pa_usec_t) -1) {
878 pa_log_debug("latency set to %0.2fms", (double) latency / PA_USEC_PER_MSEC);
880 b = pa_usec_to_bytes(latency, &u->source->sample_spec);
882 /* We need at least one sample in our buffer */
884 if (PA_UNLIKELY(b < u->frame_size))
887 u->hwbuf_unused = PA_LIKELY(b < u->hwbuf_size) ? (u->hwbuf_size - b) : 0;
890 fix_min_sleep_wakeup(u);
891 fix_tsched_watermark(u);
894 pa_log_debug("hwbuf_unused=%lu", (unsigned long) u->hwbuf_unused);
899 pa_usec_t sleep_usec, process_usec;
901 hw_sleep_time(u, &sleep_usec, &process_usec);
902 avail_min += pa_usec_to_bytes(sleep_usec, &u->source->sample_spec) / u->frame_size;
905 pa_log_debug("setting avail_min=%lu", (unsigned long) avail_min);
907 if ((err = pa_alsa_set_sw_params(u->pcm_handle, avail_min, !u->use_tsched)) < 0) {
908 pa_log("Failed to set software parameters: %s", pa_alsa_strerror(err));
915 /* Called from IO Context on unsuspend or from main thread when creating source */
916 static void reset_watermark(struct userdata *u, size_t tsched_watermark, pa_sample_spec *ss,
918 u->tsched_watermark = pa_convert_size(tsched_watermark, ss, &u->source->sample_spec);
920 u->watermark_inc_step = pa_usec_to_bytes(TSCHED_WATERMARK_INC_STEP_USEC, &u->source->sample_spec);
921 u->watermark_dec_step = pa_usec_to_bytes(TSCHED_WATERMARK_DEC_STEP_USEC, &u->source->sample_spec);
923 u->watermark_inc_threshold = pa_usec_to_bytes_round_up(TSCHED_WATERMARK_INC_THRESHOLD_USEC, &u->source->sample_spec);
924 u->watermark_dec_threshold = pa_usec_to_bytes_round_up(TSCHED_WATERMARK_DEC_THRESHOLD_USEC, &u->source->sample_spec);
926 fix_min_sleep_wakeup(u);
927 fix_tsched_watermark(u);
930 pa_source_set_latency_range_within_thread(u->source,
932 pa_bytes_to_usec(u->hwbuf_size, ss));
934 pa_source_set_latency_range(u->source,
936 pa_bytes_to_usec(u->hwbuf_size, ss));
938 /* work-around assert in pa_source_set_latency_within_thead,
939 keep track of min_latency and reuse it when
940 this routine is called from IO context */
941 u->min_latency_ref = u->source->thread_info.min_latency;
944 pa_log_info("Time scheduling watermark is %0.2fms",
945 (double) u->tsched_watermark_usec / PA_USEC_PER_MSEC);
948 /* Called from IO context */
949 static int unsuspend(struct userdata *u) {
953 snd_pcm_uframes_t period_size, buffer_size;
956 pa_assert(!u->pcm_handle);
958 pa_log_info("Trying resume...");
960 if ((err = snd_pcm_open(&u->pcm_handle, u->device_name, SND_PCM_STREAM_CAPTURE,
962 SND_PCM_NO_AUTO_RESAMPLE|
963 SND_PCM_NO_AUTO_CHANNELS|
964 SND_PCM_NO_AUTO_FORMAT)) < 0) {
965 pa_log("Error opening PCM device %s: %s", u->device_name, pa_alsa_strerror(err));
969 ss = u->source->sample_spec;
970 period_size = u->fragment_size / u->frame_size;
971 buffer_size = u->hwbuf_size / u->frame_size;
975 if ((err = pa_alsa_set_hw_params(u->pcm_handle, &ss, &period_size, &buffer_size, 0, &b, &d, true)) < 0) {
976 pa_log("Failed to set hardware parameters: %s", pa_alsa_strerror(err));
980 if (b != u->use_mmap || d != u->use_tsched) {
981 pa_log_warn("Resume failed, couldn't get original access mode.");
985 if (!pa_sample_spec_equal(&ss, &u->source->sample_spec)) {
986 pa_log_warn("Resume failed, couldn't restore original sample settings.");
990 if (period_size*u->frame_size != u->fragment_size ||
991 buffer_size*u->frame_size != u->hwbuf_size) {
992 pa_log_warn("Resume failed, couldn't restore original fragment settings. (Old: %lu/%lu, New %lu/%lu)",
993 (unsigned long) u->hwbuf_size, (unsigned long) u->fragment_size,
994 (unsigned long) (buffer_size*u->frame_size), (unsigned long) (period_size*u->frame_size));
998 if (update_sw_params(u) < 0)
1001 if (build_pollfd(u) < 0)
1004 /* FIXME: We need to reload the volume somehow */
1007 pa_smoother_reset(u->smoother, pa_rtclock_now(), true);
1008 u->smoother_interval = SMOOTHER_MIN_INTERVAL;
1009 u->last_smoother_update = 0;
1013 /* reset the watermark to the value defined when source was created */
1015 reset_watermark(u, u->tsched_watermark_ref, &u->source->sample_spec, true);
1017 pa_log_info("Resumed successfully...");
1022 if (u->pcm_handle) {
1023 snd_pcm_close(u->pcm_handle);
1024 u->pcm_handle = NULL;
1030 /* Called from the IO thread or the main thread depending on whether deferred
1031 * volume is enabled or not (with deferred volume all mixer handling is done
1032 * from the IO thread).
1034 * Sets the mixer settings to match the current source and port state (the port
1035 * is given as an argument, because active_port may still point to the old
1036 * port, if we're switching ports). */
1037 static void sync_mixer(struct userdata *u, pa_device_port *port) {
1038 pa_alsa_setting *setting = NULL;
1045 /* port may be NULL, because if we use a synthesized mixer path, then the
1046 * source has no ports. */
1048 pa_alsa_port_data *data;
1050 data = PA_DEVICE_PORT_DATA(port);
1051 setting = data->setting;
1054 pa_alsa_path_select(u->mixer_path, setting, u->mixer_handle, u->source->muted);
1056 if (u->source->set_mute)
1057 u->source->set_mute(u->source);
1058 if (u->source->flags & PA_SOURCE_DEFERRED_VOLUME) {
1059 if (u->source->write_volume)
1060 u->source->write_volume(u->source);
1062 if (u->source->set_volume)
1063 u->source->set_volume(u->source);
1067 /* Called from IO context */
1068 static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
1069 struct userdata *u = PA_SOURCE(o)->userdata;
1073 case PA_SOURCE_MESSAGE_GET_LATENCY: {
1077 r = source_get_latency(u);
1079 *((int64_t*) data) = r;
1084 case SOURCE_MESSAGE_SYNC_MIXER: {
1085 pa_device_port *port = data;
1087 sync_mixer(u, port);
1092 return pa_source_process_msg(o, code, data, offset, chunk);
1095 /* Called from main context */
1096 static int source_set_state_in_main_thread_cb(pa_source *s, pa_source_state_t new_state, pa_suspend_cause_t new_suspend_cause) {
1097 pa_source_state_t old_state;
1100 pa_source_assert_ref(s);
1101 pa_assert_se(u = s->userdata);
1103 /* When our session becomes active, we need to sync the mixer, because
1104 * another user may have changed the mixer settings.
1106 * If deferred volume is enabled, the syncing is done in the
1107 * set_state_in_io_thread() callback instead. */
1108 if (!(s->flags & PA_SOURCE_DEFERRED_VOLUME)
1109 && (s->suspend_cause & PA_SUSPEND_SESSION)
1110 && !(new_suspend_cause & PA_SUSPEND_SESSION))
1111 sync_mixer(u, s->active_port);
1113 old_state = pa_source_get_state(u->source);
1115 if (PA_SOURCE_IS_OPENED(old_state) && new_state == PA_SOURCE_SUSPENDED)
1117 else if (old_state == PA_SOURCE_SUSPENDED && PA_SOURCE_IS_OPENED(new_state))
1118 if (reserve_init(u, u->device_name) < 0)
1119 return -PA_ERR_BUSY;
1124 /* Called from the IO thread. */
1125 static int source_set_state_in_io_thread_cb(pa_source *s, pa_source_state_t new_state, pa_suspend_cause_t new_suspend_cause) {
1129 pa_assert_se(u = s->userdata);
1131 /* When our session becomes active, we need to sync the mixer, because
1132 * another user may have changed the mixer settings.
1134 * If deferred volume is disabled, the syncing is done in the
1135 * set_state_in_main_thread() callback instead. */
1136 if ((s->flags & PA_SOURCE_DEFERRED_VOLUME)
1137 && (s->suspend_cause & PA_SUSPEND_SESSION)
1138 && !(new_suspend_cause & PA_SUSPEND_SESSION))
1139 sync_mixer(u, s->active_port);
1141 /* It may be that only the suspend cause is changing, in which case there's
1142 * nothing more to do. */
1143 if (new_state == s->thread_info.state)
1146 switch (new_state) {
1148 case PA_SOURCE_SUSPENDED: {
1149 pa_assert(PA_SOURCE_IS_OPENED(u->source->thread_info.state));
1156 case PA_SOURCE_IDLE:
1157 case PA_SOURCE_RUNNING: {
1160 if (u->source->thread_info.state == PA_SOURCE_INIT) {
1161 if (build_pollfd(u) < 0)
1162 /* FIXME: This will cause an assertion failure, because
1163 * with the current design pa_source_put() is not allowed
1164 * to fail and pa_source_put() has no fallback code that
1165 * would start the source suspended if opening the device
1170 if (u->source->thread_info.state == PA_SOURCE_SUSPENDED) {
1171 if ((r = unsuspend(u)) < 0)
1178 case PA_SOURCE_UNLINKED:
1179 case PA_SOURCE_INIT:
1180 case PA_SOURCE_INVALID_STATE:
1187 static int ctl_mixer_callback(snd_mixer_elem_t *elem, unsigned int mask) {
1188 struct userdata *u = snd_mixer_elem_get_callback_private(elem);
1191 pa_assert(u->mixer_handle);
1193 if (mask == SND_CTL_EVENT_MASK_REMOVE)
1196 if (!PA_SOURCE_IS_LINKED(u->source->state))
1199 if (u->source->suspend_cause & PA_SUSPEND_SESSION)
1202 if (mask & SND_CTL_EVENT_MASK_VALUE) {
1203 pa_source_get_volume(u->source, true);
1204 pa_source_get_mute(u->source, true);
1210 static int io_mixer_callback(snd_mixer_elem_t *elem, unsigned int mask) {
1211 struct userdata *u = snd_mixer_elem_get_callback_private(elem);
1214 pa_assert(u->mixer_handle);
1216 if (mask == SND_CTL_EVENT_MASK_REMOVE)
1219 if (u->source->suspend_cause & PA_SUSPEND_SESSION)
1222 if (mask & SND_CTL_EVENT_MASK_VALUE)
1223 pa_source_update_volume_and_mute(u->source);
1228 static void source_get_volume_cb(pa_source *s) {
1229 struct userdata *u = s->userdata;
1231 char volume_buf[PA_CVOLUME_SNPRINT_VERBOSE_MAX];
1234 pa_assert(u->mixer_path);
1235 pa_assert(u->mixer_handle);
1237 if (pa_alsa_path_get_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r) < 0)
1240 /* Shift down by the base volume, so that 0dB becomes maximum volume */
1241 pa_sw_cvolume_multiply_scalar(&r, &r, s->base_volume);
1243 pa_log_debug("Read hardware volume: %s",
1244 pa_cvolume_snprint_verbose(volume_buf, sizeof(volume_buf), &r, &s->channel_map, u->mixer_path->has_dB));
1246 if (pa_cvolume_equal(&u->hardware_volume, &r))
1249 s->real_volume = u->hardware_volume = r;
1251 /* Hmm, so the hardware volume changed, let's reset our software volume */
1252 if (u->mixer_path->has_dB)
1253 pa_source_set_soft_volume(s, NULL);
1256 static void source_set_volume_cb(pa_source *s) {
1257 struct userdata *u = s->userdata;
1259 char volume_buf[PA_CVOLUME_SNPRINT_VERBOSE_MAX];
1260 bool deferred_volume = !!(s->flags & PA_SOURCE_DEFERRED_VOLUME);
1263 pa_assert(u->mixer_path);
1264 pa_assert(u->mixer_handle);
1266 /* Shift up by the base volume */
1267 pa_sw_cvolume_divide_scalar(&r, &s->real_volume, s->base_volume);
1269 if (pa_alsa_path_set_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r, deferred_volume, !deferred_volume) < 0)
1272 /* Shift down by the base volume, so that 0dB becomes maximum volume */
1273 pa_sw_cvolume_multiply_scalar(&r, &r, s->base_volume);
1275 u->hardware_volume = r;
1277 if (u->mixer_path->has_dB) {
1278 pa_cvolume new_soft_volume;
1279 bool accurate_enough;
1281 /* Match exactly what the user requested by software */
1282 pa_sw_cvolume_divide(&new_soft_volume, &s->real_volume, &u->hardware_volume);
1284 /* If the adjustment to do in software is only minimal we
1285 * can skip it. That saves us CPU at the expense of a bit of
1288 (pa_cvolume_min(&new_soft_volume) >= (PA_VOLUME_NORM - VOLUME_ACCURACY)) &&
1289 (pa_cvolume_max(&new_soft_volume) <= (PA_VOLUME_NORM + VOLUME_ACCURACY));
1291 pa_log_debug("Requested volume: %s",
1292 pa_cvolume_snprint_verbose(volume_buf, sizeof(volume_buf), &s->real_volume, &s->channel_map, true));
1293 pa_log_debug("Got hardware volume: %s",
1294 pa_cvolume_snprint_verbose(volume_buf, sizeof(volume_buf), &u->hardware_volume, &s->channel_map, true));
1295 pa_log_debug("Calculated software volume: %s (accurate-enough=%s)",
1296 pa_cvolume_snprint_verbose(volume_buf, sizeof(volume_buf), &new_soft_volume, &s->channel_map, true),
1297 pa_yes_no(accurate_enough));
1299 if (!accurate_enough)
1300 s->soft_volume = new_soft_volume;
1303 pa_log_debug("Wrote hardware volume: %s",
1304 pa_cvolume_snprint_verbose(volume_buf, sizeof(volume_buf), &r, &s->channel_map, false));
1306 /* We can't match exactly what the user requested, hence let's
1307 * at least tell the user about it */
1313 static void source_write_volume_cb(pa_source *s) {
1314 struct userdata *u = s->userdata;
1315 pa_cvolume hw_vol = s->thread_info.current_hw_volume;
1318 pa_assert(u->mixer_path);
1319 pa_assert(u->mixer_handle);
1320 pa_assert(s->flags & PA_SOURCE_DEFERRED_VOLUME);
1322 /* Shift up by the base volume */
1323 pa_sw_cvolume_divide_scalar(&hw_vol, &hw_vol, s->base_volume);
1325 if (pa_alsa_path_set_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &hw_vol, true, true) < 0)
1326 pa_log_error("Writing HW volume failed");
1329 bool accurate_enough;
1331 /* Shift down by the base volume, so that 0dB becomes maximum volume */
1332 pa_sw_cvolume_multiply_scalar(&hw_vol, &hw_vol, s->base_volume);
1334 pa_sw_cvolume_divide(&tmp_vol, &hw_vol, &s->thread_info.current_hw_volume);
1336 (pa_cvolume_min(&tmp_vol) >= (PA_VOLUME_NORM - VOLUME_ACCURACY)) &&
1337 (pa_cvolume_max(&tmp_vol) <= (PA_VOLUME_NORM + VOLUME_ACCURACY));
1339 if (!accurate_enough) {
1340 char volume_buf[2][PA_CVOLUME_SNPRINT_VERBOSE_MAX];
1342 pa_log_debug("Written HW volume did not match with the request: %s (request) != %s",
1343 pa_cvolume_snprint_verbose(volume_buf[0],
1344 sizeof(volume_buf[0]),
1345 &s->thread_info.current_hw_volume,
1348 pa_cvolume_snprint_verbose(volume_buf[1], sizeof(volume_buf[1]), &hw_vol, &s->channel_map, true));
1353 static int source_get_mute_cb(pa_source *s, bool *mute) {
1354 struct userdata *u = s->userdata;
1357 pa_assert(u->mixer_path);
1358 pa_assert(u->mixer_handle);
1360 if (pa_alsa_path_get_mute(u->mixer_path, u->mixer_handle, mute) < 0)
1366 static void source_set_mute_cb(pa_source *s) {
1367 struct userdata *u = s->userdata;
1370 pa_assert(u->mixer_path);
1371 pa_assert(u->mixer_handle);
1373 pa_alsa_path_set_mute(u->mixer_path, u->mixer_handle, s->muted);
1376 static void mixer_volume_init(struct userdata *u) {
1379 if (!u->mixer_path->has_volume) {
1380 pa_source_set_write_volume_callback(u->source, NULL);
1381 pa_source_set_get_volume_callback(u->source, NULL);
1382 pa_source_set_set_volume_callback(u->source, NULL);
1384 pa_log_info("Driver does not support hardware volume control, falling back to software volume control.");
1386 pa_source_set_get_volume_callback(u->source, source_get_volume_cb);
1387 pa_source_set_set_volume_callback(u->source, source_set_volume_cb);
1389 if (u->mixer_path->has_dB && u->deferred_volume) {
1390 pa_source_set_write_volume_callback(u->source, source_write_volume_cb);
1391 pa_log_info("Successfully enabled deferred volume.");
1393 pa_source_set_write_volume_callback(u->source, NULL);
1395 if (u->mixer_path->has_dB) {
1396 pa_source_enable_decibel_volume(u->source, true);
1397 pa_log_info("Hardware volume ranges from %0.2f dB to %0.2f dB.", u->mixer_path->min_dB, u->mixer_path->max_dB);
1399 u->source->base_volume = pa_sw_volume_from_dB(-u->mixer_path->max_dB);
1400 u->source->n_volume_steps = PA_VOLUME_NORM+1;
1402 pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(u->source->base_volume));
1404 pa_source_enable_decibel_volume(u->source, false);
1405 pa_log_info("Hardware volume ranges from %li to %li.", u->mixer_path->min_volume, u->mixer_path->max_volume);
1407 u->source->base_volume = PA_VOLUME_NORM;
1408 u->source->n_volume_steps = u->mixer_path->max_volume - u->mixer_path->min_volume + 1;
1411 pa_log_info("Using hardware volume control. Hardware dB scale %s.", u->mixer_path->has_dB ? "supported" : "not supported");
1414 if (!u->mixer_path->has_mute) {
1415 pa_source_set_get_mute_callback(u->source, NULL);
1416 pa_source_set_set_mute_callback(u->source, NULL);
1417 pa_log_info("Driver does not support hardware mute control, falling back to software mute control.");
1419 pa_source_set_get_mute_callback(u->source, source_get_mute_cb);
1420 pa_source_set_set_mute_callback(u->source, source_set_mute_cb);
1421 pa_log_info("Using hardware mute control.");
1425 static int source_set_port_ucm_cb(pa_source *s, pa_device_port *p) {
1426 struct userdata *u = s->userdata;
1430 pa_assert(u->ucm_context);
1432 return pa_alsa_ucm_set_port(u->ucm_context, p, false);
1435 static int source_set_port_cb(pa_source *s, pa_device_port *p) {
1436 struct userdata *u = s->userdata;
1437 pa_alsa_port_data *data;
1441 pa_assert(u->mixer_handle);
1443 data = PA_DEVICE_PORT_DATA(p);
1444 pa_assert_se(u->mixer_path = data->path);
1445 mixer_volume_init(u);
1447 if (s->flags & PA_SOURCE_DEFERRED_VOLUME)
1448 pa_asyncmsgq_send(u->source->asyncmsgq, PA_MSGOBJECT(u->source), SOURCE_MESSAGE_SYNC_MIXER, p, 0, NULL);
1455 static void source_update_requested_latency_cb(pa_source *s) {
1456 struct userdata *u = s->userdata;
1458 pa_assert(u->use_tsched); /* only when timer scheduling is used
1459 * we can dynamically adjust the
1465 update_sw_params(u);
1468 static int source_reconfigure_cb(pa_source *s, pa_sample_spec *spec, bool passthrough) {
1469 struct userdata *u = s->userdata;
1471 bool supported = false;
1473 /* FIXME: we only update rate for now */
1477 for (i = 0; u->rates[i]; i++) {
1478 if (u->rates[i] == spec->rate) {
1485 pa_log_info("Source does not support sample rate of %d Hz", spec->rate);
1489 if (!PA_SOURCE_IS_OPENED(s->state)) {
1490 pa_log_info("Updating rate for device %s, new rate is %d", u->device_name, spec->rate);
1491 u->source->sample_spec.rate = spec->rate;
1498 static void thread_func(void *userdata) {
1499 struct userdata *u = userdata;
1500 unsigned short revents = 0;
1504 pa_log_debug("Thread starting up");
1506 if (u->core->realtime_scheduling)
1507 pa_make_realtime(u->core->realtime_priority);
1509 pa_thread_mq_install(&u->thread_mq);
1513 pa_usec_t rtpoll_sleep = 0, real_sleep;
1516 pa_log_debug("Loop");
1519 /* Read some data and pass it to the sources */
1520 if (PA_SOURCE_IS_OPENED(u->source->thread_info.state)) {
1522 pa_usec_t sleep_usec = 0;
1523 bool on_timeout = pa_rtpoll_timer_elapsed(u->rtpoll);
1526 pa_log_info("Starting capture.");
1527 snd_pcm_start(u->pcm_handle);
1529 pa_smoother_resume(u->smoother, pa_rtclock_now(), true);
1535 work_done = mmap_read(u, &sleep_usec, revents & POLLIN, on_timeout);
1537 work_done = unix_read(u, &sleep_usec, revents & POLLIN, on_timeout);
1542 /* pa_log_debug("work_done = %i", work_done); */
1547 if (u->use_tsched) {
1550 /* OK, the capture buffer is now empty, let's
1551 * calculate when to wake up next */
1553 /* pa_log_debug("Waking up in %0.2fms (sound card clock).", (double) sleep_usec / PA_USEC_PER_MSEC); */
1555 /* Convert from the sound card time domain to the
1556 * system time domain */
1557 cusec = pa_smoother_translate(u->smoother, pa_rtclock_now(), sleep_usec);
1559 /* pa_log_debug("Waking up in %0.2fms (system clock).", (double) cusec / PA_USEC_PER_MSEC); */
1561 /* We don't trust the conversion, so we wake up whatever comes first */
1562 rtpoll_sleep = PA_MIN(sleep_usec, cusec);
1566 if (u->source->flags & PA_SOURCE_DEFERRED_VOLUME) {
1567 pa_usec_t volume_sleep;
1568 pa_source_volume_change_apply(u->source, &volume_sleep);
1569 if (volume_sleep > 0) {
1570 if (rtpoll_sleep > 0)
1571 rtpoll_sleep = PA_MIN(volume_sleep, rtpoll_sleep);
1573 rtpoll_sleep = volume_sleep;
1577 if (rtpoll_sleep > 0) {
1578 pa_rtpoll_set_timer_relative(u->rtpoll, rtpoll_sleep);
1579 real_sleep = pa_rtclock_now();
1582 pa_rtpoll_set_timer_disabled(u->rtpoll);
1584 /* Hmm, nothing to do. Let's sleep */
1585 if ((ret = pa_rtpoll_run(u->rtpoll)) < 0)
1588 if (rtpoll_sleep > 0) {
1589 real_sleep = pa_rtclock_now() - real_sleep;
1591 pa_log_debug("Expected sleep: %0.2fms, real sleep: %0.2fms (diff %0.2f ms)",
1592 (double) rtpoll_sleep / PA_USEC_PER_MSEC, (double) real_sleep / PA_USEC_PER_MSEC,
1593 (double) ((int64_t) real_sleep - (int64_t) rtpoll_sleep) / PA_USEC_PER_MSEC);
1595 if (u->use_tsched && real_sleep > rtpoll_sleep + u->tsched_watermark_usec)
1596 pa_log_info("Scheduling delay of %0.2f ms > %0.2f ms, you might want to investigate this to improve latency...",
1597 (double) (real_sleep - rtpoll_sleep) / PA_USEC_PER_MSEC,
1598 (double) (u->tsched_watermark_usec) / PA_USEC_PER_MSEC);
1601 if (u->source->flags & PA_SOURCE_DEFERRED_VOLUME)
1602 pa_source_volume_change_apply(u->source, NULL);
1607 /* Tell ALSA about this and process its response */
1608 if (PA_SOURCE_IS_OPENED(u->source->thread_info.state)) {
1609 struct pollfd *pollfd;
1613 pollfd = pa_rtpoll_item_get_pollfd(u->alsa_rtpoll_item, &n);
1615 if ((err = snd_pcm_poll_descriptors_revents(u->pcm_handle, pollfd, n, &revents)) < 0) {
1616 pa_log("snd_pcm_poll_descriptors_revents() failed: %s", pa_alsa_strerror(err));
1620 if (revents & ~POLLIN) {
1621 if (pa_alsa_recover_from_poll(u->pcm_handle, revents) < 0)
1626 } else if (revents && u->use_tsched && pa_log_ratelimit(PA_LOG_DEBUG))
1627 pa_log_debug("Wakeup from ALSA!");
1634 /* If this was no regular exit from the loop we have to continue
1635 * processing messages until we received PA_MESSAGE_SHUTDOWN */
1636 pa_asyncmsgq_post(u->thread_mq.outq, PA_MSGOBJECT(u->core), PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0, NULL, NULL);
1637 pa_asyncmsgq_wait_for(u->thread_mq.inq, PA_MESSAGE_SHUTDOWN);
1640 pa_log_debug("Thread shutting down");
1643 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) {
1649 pa_assert(device_name);
1651 if ((n = pa_modargs_get_value(ma, "source_name", NULL))) {
1652 pa_source_new_data_set_name(data, n);
1653 data->namereg_fail = true;
1657 if ((n = pa_modargs_get_value(ma, "name", NULL)))
1658 data->namereg_fail = true;
1660 n = device_id ? device_id : device_name;
1661 data->namereg_fail = false;
1665 t = pa_sprintf_malloc("alsa_input.%s.%s", n, mapping->name);
1667 t = pa_sprintf_malloc("alsa_input.%s", n);
1669 pa_source_new_data_set_name(data, t);
1673 static void find_mixer(struct userdata *u, pa_alsa_mapping *mapping, const char *element, bool ignore_dB) {
1674 if (!mapping && !element)
1677 if (!(u->mixer_handle = pa_alsa_open_mixer_for_pcm(u->pcm_handle, &u->control_device))) {
1678 pa_log_info("Failed to find a working mixer device.");
1684 if (!(u->mixer_path = pa_alsa_path_synthesize(element, PA_ALSA_DIRECTION_INPUT)))
1687 if (pa_alsa_path_probe(u->mixer_path, NULL, u->mixer_handle, ignore_dB) < 0)
1690 pa_log_debug("Probed mixer path %s:", u->mixer_path->name);
1691 pa_alsa_path_dump(u->mixer_path);
1692 } else if (!(u->mixer_path_set = mapping->input_path_set))
1699 if (u->mixer_path) {
1700 pa_alsa_path_free(u->mixer_path);
1701 u->mixer_path = NULL;
1704 if (u->mixer_handle) {
1705 snd_mixer_close(u->mixer_handle);
1706 u->mixer_handle = NULL;
1710 static int setup_mixer(struct userdata *u, bool ignore_dB) {
1711 bool need_mixer_callback = false;
1715 if (!u->mixer_handle)
1718 if (u->source->active_port) {
1719 pa_alsa_port_data *data;
1721 /* We have a list of supported paths, so let's activate the
1722 * one that has been chosen as active */
1724 data = PA_DEVICE_PORT_DATA(u->source->active_port);
1725 u->mixer_path = data->path;
1727 pa_alsa_path_select(data->path, data->setting, u->mixer_handle, u->source->muted);
1731 if (!u->mixer_path && u->mixer_path_set)
1732 u->mixer_path = pa_hashmap_first(u->mixer_path_set->paths);
1734 if (u->mixer_path) {
1735 /* Hmm, we have only a single path, then let's activate it */
1737 pa_alsa_path_select(u->mixer_path, u->mixer_path->settings, u->mixer_handle, u->source->muted);
1742 mixer_volume_init(u);
1744 /* Will we need to register callbacks? */
1745 if (u->mixer_path_set && u->mixer_path_set->paths) {
1749 PA_HASHMAP_FOREACH(p, u->mixer_path_set->paths, state) {
1750 if (p->has_volume || p->has_mute)
1751 need_mixer_callback = true;
1754 else if (u->mixer_path)
1755 need_mixer_callback = u->mixer_path->has_volume || u->mixer_path->has_mute;
1757 if (need_mixer_callback) {
1758 int (*mixer_callback)(snd_mixer_elem_t *, unsigned int);
1759 if (u->source->flags & PA_SOURCE_DEFERRED_VOLUME) {
1760 u->mixer_pd = pa_alsa_mixer_pdata_new();
1761 mixer_callback = io_mixer_callback;
1763 if (pa_alsa_set_mixer_rtpoll(u->mixer_pd, u->mixer_handle, u->rtpoll) < 0) {
1764 pa_log("Failed to initialize file descriptor monitoring");
1768 u->mixer_fdl = pa_alsa_fdlist_new();
1769 mixer_callback = ctl_mixer_callback;
1771 if (pa_alsa_fdlist_set_handle(u->mixer_fdl, u->mixer_handle, NULL, u->core->mainloop) < 0) {
1772 pa_log("Failed to initialize file descriptor monitoring");
1777 if (u->mixer_path_set)
1778 pa_alsa_path_set_set_callback(u->mixer_path_set, u->mixer_handle, mixer_callback, u);
1780 pa_alsa_path_set_callback(u->mixer_path, u->mixer_handle, mixer_callback, u);
1786 pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, pa_card *card, pa_alsa_mapping *mapping) {
1788 struct userdata *u = NULL;
1789 const char *dev_id = NULL, *key, *mod_name;
1791 char *thread_name = NULL;
1792 uint32_t alternate_sample_rate;
1794 uint32_t nfrags, frag_size, buffer_size, tsched_size, tsched_watermark;
1795 snd_pcm_uframes_t period_frames, buffer_frames, tsched_frames;
1797 bool use_mmap = true, b, use_tsched = true, d, ignore_dB = false, namereg_fail = false, deferred_volume = false, fixed_latency_range = false;
1798 pa_source_new_data data;
1801 pa_alsa_profile_set *profile_set = NULL;
1807 ss = m->core->default_sample_spec;
1808 map = m->core->default_channel_map;
1810 /* Pick sample spec overrides from the mapping, if any */
1812 if (mapping->sample_spec.format != PA_SAMPLE_INVALID)
1813 ss.format = mapping->sample_spec.format;
1814 if (mapping->sample_spec.rate != 0)
1815 ss.rate = mapping->sample_spec.rate;
1816 if (mapping->sample_spec.channels != 0) {
1817 ss.channels = mapping->sample_spec.channels;
1818 if (pa_channel_map_valid(&mapping->channel_map))
1819 pa_assert(pa_channel_map_compatible(&mapping->channel_map, &ss));
1823 /* Override with modargs if provided */
1824 if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_ALSA) < 0) {
1825 pa_log("Failed to parse sample specification and channel map");
1829 alternate_sample_rate = m->core->alternate_sample_rate;
1830 if (pa_modargs_get_alternate_sample_rate(ma, &alternate_sample_rate) < 0) {
1831 pa_log("Failed to parse alternate sample rate");
1835 frame_size = pa_frame_size(&ss);
1837 nfrags = m->core->default_n_fragments;
1838 frag_size = (uint32_t) pa_usec_to_bytes(m->core->default_fragment_size_msec*PA_USEC_PER_MSEC, &ss);
1840 frag_size = (uint32_t) frame_size;
1841 tsched_size = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_BUFFER_USEC, &ss);
1842 tsched_watermark = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_WATERMARK_USEC, &ss);
1844 if (pa_modargs_get_value_u32(ma, "fragments", &nfrags) < 0 ||
1845 pa_modargs_get_value_u32(ma, "fragment_size", &frag_size) < 0 ||
1846 pa_modargs_get_value_u32(ma, "tsched_buffer_size", &tsched_size) < 0 ||
1847 pa_modargs_get_value_u32(ma, "tsched_buffer_watermark", &tsched_watermark) < 0) {
1848 pa_log("Failed to parse buffer metrics");
1852 buffer_size = nfrags * frag_size;
1854 period_frames = frag_size/frame_size;
1855 buffer_frames = buffer_size/frame_size;
1856 tsched_frames = tsched_size/frame_size;
1858 if (pa_modargs_get_value_boolean(ma, "mmap", &use_mmap) < 0) {
1859 pa_log("Failed to parse mmap argument.");
1863 if (pa_modargs_get_value_boolean(ma, "tsched", &use_tsched) < 0) {
1864 pa_log("Failed to parse tsched argument.");
1868 if (pa_modargs_get_value_boolean(ma, "ignore_dB", &ignore_dB) < 0) {
1869 pa_log("Failed to parse ignore_dB argument.");
1873 deferred_volume = m->core->deferred_volume;
1874 if (pa_modargs_get_value_boolean(ma, "deferred_volume", &deferred_volume) < 0) {
1875 pa_log("Failed to parse deferred_volume argument.");
1879 if (pa_modargs_get_value_boolean(ma, "fixed_latency_range", &fixed_latency_range) < 0) {
1880 pa_log("Failed to parse fixed_latency_range argument.");
1884 use_tsched = pa_alsa_may_tsched(use_tsched);
1886 u = pa_xnew0(struct userdata, 1);
1889 u->use_mmap = use_mmap;
1890 u->use_tsched = use_tsched;
1891 u->deferred_volume = deferred_volume;
1892 u->fixed_latency_range = fixed_latency_range;
1894 u->rtpoll = pa_rtpoll_new();
1896 if (pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll) < 0) {
1897 pa_log("pa_thread_mq_init() failed.");
1901 u->smoother = pa_smoother_new(
1902 SMOOTHER_ADJUST_USEC,
1903 SMOOTHER_WINDOW_USEC,
1909 u->smoother_interval = SMOOTHER_MIN_INTERVAL;
1912 if (mapping && mapping->ucm_context.ucm)
1913 u->ucm_context = &mapping->ucm_context;
1915 dev_id = pa_modargs_get_value(
1917 pa_modargs_get_value(ma, "device", DEFAULT_DEVICE));
1919 u->paths_dir = pa_xstrdup(pa_modargs_get_value(ma, "paths_dir", NULL));
1921 if (reserve_init(u, dev_id) < 0)
1924 if (reserve_monitor_init(u, dev_id) < 0)
1930 /* Force ALSA to reread its configuration if module-alsa-card didn't
1931 * do it for us. This matters if our device was hot-plugged after ALSA
1932 * has already read its configuration - see
1933 * https://bugs.freedesktop.org/show_bug.cgi?id=54029
1937 snd_config_update_free_global();
1941 if (!(dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
1942 pa_log("device_id= not set");
1946 if ((mod_name = pa_proplist_gets(mapping->proplist, PA_ALSA_PROP_UCM_MODIFIER))) {
1947 if (snd_use_case_set(u->ucm_context->ucm->ucm_mgr, "_enamod", mod_name) < 0)
1948 pa_log("Failed to enable ucm modifier %s", mod_name);
1950 pa_log_debug("Enabled ucm modifier %s", mod_name);
1953 if (!(u->pcm_handle = pa_alsa_open_by_device_id_mapping(
1957 SND_PCM_STREAM_CAPTURE,
1958 &period_frames, &buffer_frames, tsched_frames,
1962 } else if ((dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
1964 if (!(profile_set = pa_alsa_profile_set_new(NULL, &map)))
1967 if (!(u->pcm_handle = pa_alsa_open_by_device_id_auto(
1971 SND_PCM_STREAM_CAPTURE,
1972 &period_frames, &buffer_frames, tsched_frames,
1973 &b, &d, profile_set, &mapping)))
1978 if (!(u->pcm_handle = pa_alsa_open_by_device_string(
1979 pa_modargs_get_value(ma, "device", DEFAULT_DEVICE),
1982 SND_PCM_STREAM_CAPTURE,
1983 &period_frames, &buffer_frames, tsched_frames,
1988 pa_assert(u->device_name);
1989 pa_log_info("Successfully opened device %s.", u->device_name);
1991 if (pa_alsa_pcm_is_modem(u->pcm_handle)) {
1992 pa_log_notice("Device %s is modem, refusing further initialization.", u->device_name);
1997 pa_log_info("Selected mapping '%s' (%s).", mapping->description, mapping->name);
1999 if (use_mmap && !b) {
2000 pa_log_info("Device doesn't support mmap(), falling back to UNIX read/write mode.");
2001 u->use_mmap = use_mmap = false;
2004 if (use_tsched && (!b || !d)) {
2005 pa_log_info("Cannot enable timer-based scheduling, falling back to sound IRQ scheduling.");
2006 u->use_tsched = use_tsched = false;
2010 pa_log_info("Successfully enabled mmap() mode.");
2012 if (u->use_tsched) {
2013 pa_log_info("Successfully enabled timer-based scheduling mode.");
2014 if (u->fixed_latency_range)
2015 pa_log_info("Disabling latency range changes on overrun");
2018 u->rates = pa_alsa_get_supported_rates(u->pcm_handle, ss.rate);
2020 pa_log_error("Failed to find any supported sample rates.");
2024 /* ALSA might tweak the sample spec, so recalculate the frame size */
2025 frame_size = pa_frame_size(&ss);
2027 if (!u->ucm_context)
2028 find_mixer(u, mapping, pa_modargs_get_value(ma, "control", NULL), ignore_dB);
2030 pa_source_new_data_init(&data);
2031 data.driver = driver;
2034 set_source_name(&data, ma, dev_id, u->device_name, mapping);
2036 /* We need to give pa_modargs_get_value_boolean() a pointer to a local
2037 * variable instead of using &data.namereg_fail directly, because
2038 * data.namereg_fail is a bitfield and taking the address of a bitfield
2039 * variable is impossible. */
2040 namereg_fail = data.namereg_fail;
2041 if (pa_modargs_get_value_boolean(ma, "namereg_fail", &namereg_fail) < 0) {
2042 pa_log("Failed to parse namereg_fail argument.");
2043 pa_source_new_data_done(&data);
2046 data.namereg_fail = namereg_fail;
2048 pa_source_new_data_set_sample_spec(&data, &ss);
2049 pa_source_new_data_set_channel_map(&data, &map);
2050 pa_source_new_data_set_alternate_sample_rate(&data, alternate_sample_rate);
2052 pa_alsa_init_proplist_pcm(m->core, data.proplist, u->pcm_handle);
2053 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, u->device_name);
2054 pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_BUFFER_SIZE, "%lu", (unsigned long) (buffer_frames * frame_size));
2055 pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZE, "%lu", (unsigned long) (period_frames * frame_size));
2056 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_ACCESS_MODE, u->use_tsched ? "mmap+timer" : (u->use_mmap ? "mmap" : "serial"));
2059 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_NAME, mapping->name);
2060 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_DESCRIPTION, mapping->description);
2062 while ((key = pa_proplist_iterate(mapping->proplist, &state)))
2063 pa_proplist_sets(data.proplist, key, pa_proplist_gets(mapping->proplist, key));
2066 pa_alsa_init_description(data.proplist, card);
2068 if (u->control_device)
2069 pa_alsa_init_proplist_ctl(data.proplist, u->control_device);
2071 if (pa_modargs_get_proplist(ma, "source_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
2072 pa_log("Invalid properties");
2073 pa_source_new_data_done(&data);
2078 pa_alsa_ucm_add_ports(&data.ports, data.proplist, u->ucm_context, false, card);
2079 else if (u->mixer_path_set)
2080 pa_alsa_add_ports(&data, u->mixer_path_set, card);
2082 u->source = pa_source_new(m->core, &data, PA_SOURCE_HARDWARE|PA_SOURCE_LATENCY|(u->use_tsched ? PA_SOURCE_DYNAMIC_LATENCY : 0));
2083 volume_is_set = data.volume_is_set;
2084 mute_is_set = data.muted_is_set;
2085 pa_source_new_data_done(&data);
2088 pa_log("Failed to create source object");
2092 if (pa_modargs_get_value_u32(ma, "deferred_volume_safety_margin",
2093 &u->source->thread_info.volume_change_safety_margin) < 0) {
2094 pa_log("Failed to parse deferred_volume_safety_margin parameter");
2098 if (pa_modargs_get_value_s32(ma, "deferred_volume_extra_delay",
2099 &u->source->thread_info.volume_change_extra_delay) < 0) {
2100 pa_log("Failed to parse deferred_volume_extra_delay parameter");
2104 u->source->parent.process_msg = source_process_msg;
2106 u->source->update_requested_latency = source_update_requested_latency_cb;
2107 u->source->set_state_in_main_thread = source_set_state_in_main_thread_cb;
2108 u->source->set_state_in_io_thread = source_set_state_in_io_thread_cb;
2110 u->source->set_port = source_set_port_ucm_cb;
2112 u->source->set_port = source_set_port_cb;
2113 if (u->source->alternate_sample_rate)
2114 u->source->reconfigure = source_reconfigure_cb;
2115 u->source->userdata = u;
2117 pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
2118 pa_source_set_rtpoll(u->source, u->rtpoll);
2120 u->frame_size = frame_size;
2121 u->frames_per_block = pa_mempool_block_size_max(m->core->mempool) / frame_size;
2122 u->fragment_size = frag_size = (size_t) (period_frames * frame_size);
2123 u->hwbuf_size = buffer_size = (size_t) (buffer_frames * frame_size);
2124 pa_cvolume_mute(&u->hardware_volume, u->source->sample_spec.channels);
2126 pa_log_info("Using %0.1f fragments of size %lu bytes (%0.2fms), buffer size is %lu bytes (%0.2fms)",
2127 (double) u->hwbuf_size / (double) u->fragment_size,
2128 (long unsigned) u->fragment_size,
2129 (double) pa_bytes_to_usec(u->fragment_size, &ss) / PA_USEC_PER_MSEC,
2130 (long unsigned) u->hwbuf_size,
2131 (double) pa_bytes_to_usec(u->hwbuf_size, &ss) / PA_USEC_PER_MSEC);
2133 if (u->use_tsched) {
2134 u->tsched_watermark_ref = tsched_watermark;
2135 reset_watermark(u, u->tsched_watermark_ref, &ss, false);
2138 pa_source_set_fixed_latency(u->source, pa_bytes_to_usec(u->hwbuf_size, &ss));
2142 if (update_sw_params(u) < 0)
2145 if (u->ucm_context) {
2146 if (u->source->active_port && pa_alsa_ucm_set_port(u->ucm_context, u->source->active_port, false) < 0)
2148 } else if (setup_mixer(u, ignore_dB) < 0)
2151 pa_alsa_dump(PA_LOG_DEBUG, u->pcm_handle);
2153 thread_name = pa_sprintf_malloc("alsa-source-%s", pa_strnull(pa_proplist_gets(u->source->proplist, "alsa.id")));
2154 if (!(u->thread = pa_thread_new(thread_name, thread_func, u))) {
2155 pa_log("Failed to create thread.");
2158 pa_xfree(thread_name);
2161 /* Get initial mixer settings */
2162 if (volume_is_set) {
2163 if (u->source->set_volume)
2164 u->source->set_volume(u->source);
2166 if (u->source->get_volume)
2167 u->source->get_volume(u->source);
2171 if (u->source->set_mute)
2172 u->source->set_mute(u->source);
2174 if (u->source->get_mute) {
2177 if (u->source->get_mute(u->source, &mute) >= 0)
2178 pa_source_set_mute(u->source, mute, false);
2182 if ((volume_is_set || mute_is_set) && u->source->write_volume)
2183 u->source->write_volume(u->source);
2185 pa_source_put(u->source);
2188 pa_alsa_profile_set_free(profile_set);
2193 pa_xfree(thread_name);
2199 pa_alsa_profile_set_free(profile_set);
2204 static void userdata_free(struct userdata *u) {
2208 pa_source_unlink(u->source);
2211 pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
2212 pa_thread_free(u->thread);
2215 pa_thread_mq_done(&u->thread_mq);
2218 pa_source_unref(u->source);
2221 pa_alsa_mixer_pdata_free(u->mixer_pd);
2223 if (u->alsa_rtpoll_item)
2224 pa_rtpoll_item_free(u->alsa_rtpoll_item);
2227 pa_rtpoll_free(u->rtpoll);
2229 if (u->pcm_handle) {
2230 snd_pcm_drop(u->pcm_handle);
2231 snd_pcm_close(u->pcm_handle);
2235 pa_alsa_fdlist_free(u->mixer_fdl);
2237 if (u->mixer_path && !u->mixer_path_set)
2238 pa_alsa_path_free(u->mixer_path);
2240 if (u->mixer_handle)
2241 snd_mixer_close(u->mixer_handle);
2244 pa_smoother_free(u->smoother);
2252 pa_xfree(u->device_name);
2253 pa_xfree(u->control_device);
2254 pa_xfree(u->paths_dir);
2258 void pa_alsa_source_free(pa_source *s) {
2261 pa_source_assert_ref(s);
2262 pa_assert_se(u = s->userdata);