X-Git-Url: https://code.delx.au/pulseaudio/blobdiff_plain/fc4cf275696c05345ae2e609eac1ad3b05570ca1..f4f4c42fc611b0bca2293e9b517a88a525f2c1fb:/src/modules/alsa/alsa-source.c diff --git a/src/modules/alsa/alsa-source.c b/src/modules/alsa/alsa-source.c index 157698e3..2e93e0fe 100644 --- a/src/modules/alsa/alsa-source.c +++ b/src/modules/alsa/alsa-source.c @@ -24,18 +24,18 @@ #include #endif +#include #include #include -#include #include #include -#include +#include #include -#include #include +#include #include #include #include @@ -46,7 +46,6 @@ #include #include #include -#include #include #include #include @@ -73,6 +72,9 @@ #define TSCHED_MIN_SLEEP_USEC (10*PA_USEC_PER_MSEC) /* 10ms */ #define TSCHED_MIN_WAKEUP_USEC (4*PA_USEC_PER_MSEC) /* 4ms */ +#define SMOOTHER_WINDOW_USEC (10*PA_USEC_PER_SEC) /* 10s */ +#define SMOOTHER_ADJUST_USEC (1*PA_USEC_PER_SEC) /* 1s */ + #define SMOOTHER_MIN_INTERVAL (2*PA_USEC_PER_MSEC) /* 2ms */ #define SMOOTHER_MAX_INTERVAL (200*PA_USEC_PER_MSEC) /* 200ms */ @@ -89,18 +91,23 @@ struct userdata { snd_pcm_t *pcm_handle; + char *paths_dir; pa_alsa_fdlist *mixer_fdl; + pa_alsa_mixer_pdata *mixer_pd; snd_mixer_t *mixer_handle; pa_alsa_path_set *mixer_path_set; pa_alsa_path *mixer_path; pa_cvolume hardware_volume; + unsigned int *rates; + size_t frame_size, fragment_size, hwbuf_size, tsched_watermark, + tsched_watermark_ref, hwbuf_unused, min_sleep, min_wakeup, @@ -110,15 +117,17 @@ struct userdata { watermark_dec_threshold; pa_usec_t watermark_dec_not_before; + pa_usec_t min_latency_ref; + pa_usec_t tsched_watermark_usec; - char *device_name; - char *control_device; + char *device_name; /* name of the PCM device */ + char *control_device; /* name of the control device */ - pa_bool_t use_mmap:1, use_tsched:1; + bool use_mmap:1, use_tsched:1, deferred_volume:1, fixed_latency_range:1; - pa_rtpoll_item *alsa_rtpoll_item; + bool first; - snd_mixer_selem_channel_id_t mixer_map[SND_MIXER_SCHN_LAST]; + pa_rtpoll_item *alsa_rtpoll_item; pa_smoother *smoother; uint64_t read_count; @@ -129,6 +138,9 @@ struct userdata { pa_hook_slot *reserve_slot; pa_reserve_monitor_wrapper *monitor; pa_hook_slot *monitor_slot; + + /* ucm context */ + pa_alsa_ucm_mapping_context *ucm_context; }; static void userdata_free(struct userdata *u); @@ -137,7 +149,9 @@ static pa_hook_result_t reserve_cb(pa_reserve_wrapper *r, void *forced, struct u pa_assert(r); pa_assert(u); - if (pa_source_suspend(u->source, TRUE, PA_SUSPEND_APPLICATION) < 0) + pa_log_debug("Suspending source %s, because another application requested us to release the device.", u->source->name); + + if (pa_source_suspend(u->source, true, PA_SUSPEND_APPLICATION) < 0) return PA_HOOK_CANCEL; return PA_HOOK_OK; @@ -180,10 +194,10 @@ static int reserve_init(struct userdata *u, const char *dname) { if (pa_in_system_mode()) return 0; - /* We are resuming, try to lock the device */ if (!(rname = pa_alsa_get_reserve_name(dname))) return 0; + /* We are resuming, try to lock the device */ u->reserve = pa_reserve_wrapper_get(u->core, rname); pa_xfree(rname); @@ -199,14 +213,17 @@ static int reserve_init(struct userdata *u, const char *dname) { } static pa_hook_result_t monitor_cb(pa_reserve_monitor_wrapper *w, void* busy, struct userdata *u) { - pa_bool_t b; - pa_assert(w); pa_assert(u); - b = PA_PTR_TO_UINT(busy) && !u->reserve; + if (PA_PTR_TO_UINT(busy) && !u->reserve) { + pa_log_debug("Suspending source %s, because another application is blocking the access to the device.", u->source->name); + pa_source_suspend(u->source, true, PA_SUSPEND_APPLICATION); + } else { + pa_log_debug("Resuming source %s, because other applications aren't blocking access to the device any more.", u->source->name); + pa_source_suspend(u->source, false, PA_SUSPEND_APPLICATION); + } - pa_source_suspend(u->source, b, PA_SUSPEND_APPLICATION); return PA_HOOK_OK; } @@ -233,10 +250,10 @@ static int reserve_monitor_init(struct userdata *u, const char *dname) { if (pa_in_system_mode()) return 0; - /* We are resuming, try to lock the device */ if (!(rname = pa_alsa_get_reserve_name(dname))) return 0; + /* We are resuming, try to lock the device */ u->monitor = pa_reserve_monitor_wrapper_get(u->core, rname); pa_xfree(rname); @@ -251,6 +268,7 @@ static int reserve_monitor_init(struct userdata *u, const char *dname) { static void fix_min_sleep_wakeup(struct userdata *u) { size_t max_use, max_use_2; + pa_assert(u); pa_assert(u->use_tsched); @@ -276,6 +294,8 @@ static void fix_tsched_watermark(struct userdata *u) { if (u->tsched_watermark < u->min_wakeup) u->tsched_watermark = u->min_wakeup; + + u->tsched_watermark_usec = pa_bytes_to_usec(u->tsched_watermark, &u->source->sample_spec); } static void increase_watermark(struct userdata *u) { @@ -292,11 +312,16 @@ static void increase_watermark(struct userdata *u) { if (old_watermark != u->tsched_watermark) { pa_log_info("Increasing wakeup watermark to %0.2f ms", - (double) pa_bytes_to_usec(u->tsched_watermark, &u->source->sample_spec) / PA_USEC_PER_MSEC); + (double) u->tsched_watermark_usec / PA_USEC_PER_MSEC); return; } - /* Hmm, we cannot increase the watermark any further, hence let's raise the latency */ + /* Hmm, we cannot increase the watermark any further, hence let's + raise the latency unless doing so was disabled in + configuration */ + if (u->fixed_latency_range) + return; + old_min_latency = u->source->thread_info.min_latency; new_min_latency = PA_MIN(old_min_latency * 2, old_min_latency + TSCHED_WATERMARK_INC_STEP_USEC); new_min_latency = PA_MIN(new_min_latency, u->source->thread_info.max_latency); @@ -337,7 +362,7 @@ static void decrease_watermark(struct userdata *u) { if (old_watermark != u->tsched_watermark) pa_log_info("Decreasing wakeup watermark to %0.2f ms", - (double) pa_bytes_to_usec(u->tsched_watermark, &u->source->sample_spec) / PA_USEC_PER_MSEC); + (double) u->tsched_watermark_usec / PA_USEC_PER_MSEC); /* We don't change the latency range*/ @@ -345,7 +370,7 @@ restart: u->watermark_dec_not_before = now + TSCHED_WATERMARK_VERIFY_AFTER_USEC; } -static pa_usec_t hw_sleep_time(struct userdata *u, pa_usec_t *sleep_usec, pa_usec_t*process_usec) { +static void hw_sleep_time(struct userdata *u, pa_usec_t *sleep_usec, pa_usec_t*process_usec) { pa_usec_t wm, usec; pa_assert(sleep_usec); @@ -359,7 +384,7 @@ static pa_usec_t hw_sleep_time(struct userdata *u, pa_usec_t *sleep_usec, pa_use if (usec == (pa_usec_t) -1) usec = pa_bytes_to_usec(u->hwbuf_size, &u->source->sample_spec); - wm = pa_bytes_to_usec(u->tsched_watermark, &u->source->sample_spec); + wm = u->tsched_watermark_usec; if (wm > usec) wm = usec/2; @@ -373,8 +398,6 @@ static pa_usec_t hw_sleep_time(struct userdata *u, pa_usec_t *sleep_usec, pa_use (unsigned long) (*sleep_usec / PA_USEC_PER_MSEC), (unsigned long) (*process_usec / PA_USEC_PER_MSEC)); #endif - - return usec; } static int try_recover(struct userdata *u, const char *call, int err) { @@ -397,14 +420,14 @@ static int try_recover(struct userdata *u, const char *call, int err) { return -1; } - snd_pcm_start(u->pcm_handle); + u->first = true; return 0; } -static size_t check_left_to_record(struct userdata *u, size_t n_bytes, pa_bool_t on_timeout) { +static size_t check_left_to_record(struct userdata *u, size_t n_bytes, bool on_timeout) { size_t left_to_record; size_t rec_space = u->hwbuf_size - u->hwbuf_unused; - pa_bool_t overrun = FALSE; + bool overrun = false; /* We use <= instead of < for this check here because an overrun * only happens after the last sample was processed, not already when @@ -417,13 +440,13 @@ static size_t check_left_to_record(struct userdata *u, size_t n_bytes, pa_bool_t /* We got a dropout. What a mess! */ left_to_record = 0; - overrun = TRUE; + overrun = true; #ifdef DEBUG_TIMING PA_DEBUG_TRAP; #endif - if (pa_log_ratelimit()) + if (pa_log_ratelimit(PA_LOG_INFO)) pa_log_info("Overrun!"); } @@ -432,16 +455,16 @@ static size_t check_left_to_record(struct userdata *u, size_t n_bytes, pa_bool_t #endif if (u->use_tsched) { - pa_bool_t reset_not_before = TRUE; + bool reset_not_before = true; if (overrun || left_to_record < u->watermark_inc_threshold) increase_watermark(u); else if (left_to_record > u->watermark_dec_threshold) { - reset_not_before = FALSE; + reset_not_before = false; - /* We decrease the watermark only if have actually been - * woken up by a timeout. If something else woke us up - * it's too easy to fulfill the deadlines... */ + /* We decrease the watermark only if have actually + * been woken up by a timeout. If something else woke + * us up it's too easy to fulfill the deadlines... */ if (on_timeout) decrease_watermark(u); @@ -454,8 +477,8 @@ static size_t check_left_to_record(struct userdata *u, size_t n_bytes, pa_bool_t return left_to_record; } -static int mmap_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled, pa_bool_t on_timeout) { - pa_bool_t work_done = FALSE; +static int mmap_read(struct userdata *u, pa_usec_t *sleep_usec, bool polled, bool on_timeout) { + bool work_done = false; pa_usec_t max_sleep_usec = 0, process_usec = 0; size_t left_to_record; unsigned j = 0; @@ -470,7 +493,7 @@ static int mmap_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled snd_pcm_sframes_t n; size_t n_bytes; int r; - pa_bool_t after_avail = TRUE; + bool after_avail = true; if (PA_UNLIKELY((n = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->source->sample_spec)) < 0)) { @@ -487,7 +510,7 @@ static int mmap_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled #endif left_to_record = check_left_to_record(u, n_bytes, on_timeout); - on_timeout = FALSE; + on_timeout = false; if (u->use_tsched) if (!polled && @@ -524,22 +547,21 @@ static int mmap_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled break; } - polled = FALSE; + polled = false; #ifdef DEBUG_TIMING pa_log_debug("Reading"); #endif for (;;) { + pa_memchunk chunk; + void *p; int err; const snd_pcm_channel_area_t *areas; snd_pcm_uframes_t offset, frames; - pa_memchunk chunk; - void *p; snd_pcm_sframes_t sframes; frames = (snd_pcm_uframes_t) (n_bytes / u->frame_size); - /* pa_log_debug("%lu frames to read", (unsigned long) frames); */ if (PA_UNLIKELY((err = pa_alsa_safe_mmap_begin(u->pcm_handle, &areas, &offset, &frames, u->hwbuf_size, &u->source->sample_spec)) < 0)) { @@ -554,14 +576,14 @@ static int mmap_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled } /* Make sure that if these memblocks need to be copied they will fit into one slot */ - if (frames > pa_mempool_block_size_max(u->source->core->mempool)/u->frame_size) - frames = pa_mempool_block_size_max(u->source->core->mempool)/u->frame_size; + if (frames > pa_mempool_block_size_max(u->core->mempool)/u->frame_size) + frames = pa_mempool_block_size_max(u->core->mempool)/u->frame_size; if (!after_avail && frames == 0) break; pa_assert(frames > 0); - after_avail = FALSE; + after_avail = false; /* Check these are multiples of 8 bit */ pa_assert((areas[0].first & 7) == 0); @@ -573,7 +595,7 @@ static int mmap_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled p = (uint8_t*) areas[0].addr + (offset * u->frame_size); - chunk.memblock = pa_memblock_new_fixed(u->core->mempool, p, frames * u->frame_size, TRUE); + chunk.memblock = pa_memblock_new_fixed(u->core->mempool, p, frames * u->frame_size, true); chunk.length = pa_memblock_get_length(chunk.memblock); chunk.index = 0; @@ -588,7 +610,7 @@ static int mmap_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled return r; } - work_done = TRUE; + work_done = true; u->read_count += frames * u->frame_size; @@ -603,18 +625,21 @@ static int mmap_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled } } - *sleep_usec = pa_bytes_to_usec(left_to_record, &u->source->sample_spec); + if (u->use_tsched) { + *sleep_usec = pa_bytes_to_usec(left_to_record, &u->source->sample_spec); + process_usec = u->tsched_watermark_usec; - if (*sleep_usec > process_usec) - *sleep_usec -= process_usec; - else - *sleep_usec = 0; + if (*sleep_usec > process_usec) + *sleep_usec -= process_usec; + else + *sleep_usec = 0; + } return work_done ? 1 : 0; } -static int unix_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled, pa_bool_t on_timeout) { - int work_done = FALSE; +static int unix_read(struct userdata *u, pa_usec_t *sleep_usec, bool polled, bool on_timeout) { + int work_done = false; pa_usec_t max_sleep_usec = 0, process_usec = 0; size_t left_to_record; unsigned j = 0; @@ -629,7 +654,7 @@ static int unix_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled snd_pcm_sframes_t n; size_t n_bytes; int r; - pa_bool_t after_avail = TRUE; + bool after_avail = true; if (PA_UNLIKELY((n = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->source->sample_spec)) < 0)) { @@ -641,7 +666,7 @@ static int unix_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled n_bytes = (size_t) n * u->frame_size; left_to_record = check_left_to_record(u, n_bytes, on_timeout); - on_timeout = FALSE; + on_timeout = false; if (u->use_tsched) if (!polled && @@ -671,7 +696,7 @@ static int unix_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled break; } - polled = FALSE; + polled = false; for (;;) { void *p; @@ -709,7 +734,7 @@ static int unix_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled } pa_assert(frames > 0); - after_avail = FALSE; + after_avail = false; chunk.index = 0; chunk.length = (size_t) frames * u->frame_size; @@ -717,7 +742,7 @@ static int unix_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled pa_source_post(u->source, &chunk); pa_memblock_unref(chunk.memblock); - work_done = TRUE; + work_done = true; u->read_count += frames * u->frame_size; @@ -730,12 +755,15 @@ static int unix_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled } } - *sleep_usec = pa_bytes_to_usec(left_to_record, &u->source->sample_spec); + if (u->use_tsched) { + *sleep_usec = pa_bytes_to_usec(left_to_record, &u->source->sample_spec); + process_usec = u->tsched_watermark_usec; - if (*sleep_usec > process_usec) - *sleep_usec -= process_usec; - else - *sleep_usec = 0; + if (*sleep_usec > process_usec) + *sleep_usec -= process_usec; + else + *sleep_usec = 0; + } return work_done ? 1 : 0; } @@ -746,6 +774,7 @@ static void update_smoother(struct userdata *u) { int err; pa_usec_t now1 = 0, now2; snd_pcm_status_t *status; + snd_htimestamp_t htstamp = { 0, 0 }; snd_pcm_status_alloca(&status); @@ -754,18 +783,13 @@ static void update_smoother(struct userdata *u) { /* Let's update the time smoother */ - if (PA_UNLIKELY((err = pa_alsa_safe_delay(u->pcm_handle, &delay, u->hwbuf_size, &u->source->sample_spec)) < 0)) { + if (PA_UNLIKELY((err = pa_alsa_safe_delay(u->pcm_handle, status, &delay, u->hwbuf_size, &u->source->sample_spec, true)) < 0)) { pa_log_warn("Failed to get delay: %s", pa_alsa_strerror(err)); return; } - if (PA_UNLIKELY((err = snd_pcm_status(u->pcm_handle, status)) < 0)) - pa_log_warn("Failed to get timestamp: %s", pa_alsa_strerror(err)); - else { - snd_htimestamp_t htstamp = { 0, 0 }; - snd_pcm_status_get_htstamp(status, &htstamp); - now1 = pa_timespec_load(&htstamp); - } + snd_pcm_status_get_htstamp(status, &htstamp); + now1 = pa_timespec_load(&htstamp); /* Hmm, if the timestamp is 0, then it wasn't set and we take the current time */ if (now1 <= 0) @@ -787,7 +811,7 @@ static void update_smoother(struct userdata *u) { } static pa_usec_t source_get_latency(struct userdata *u) { - int64_t delay; + int64_t delay; pa_usec_t now1, now2; pa_assert(u); @@ -813,6 +837,7 @@ static int build_pollfd(struct userdata *u) { return 0; } +/* Called from IO context */ static int suspend(struct userdata *u) { pa_assert(u); pa_assert(u->pcm_handle); @@ -833,13 +858,14 @@ static int suspend(struct userdata *u) { return 0; } +/* Called from IO context */ static int update_sw_params(struct userdata *u) { snd_pcm_uframes_t avail_min; int err; pa_assert(u); - /* Use the full buffer if noone asked us for anything specific */ + /* Use the full buffer if no one asked us for anything specific */ u->hwbuf_unused = 0; if (u->use_tsched) { @@ -885,10 +911,45 @@ static int update_sw_params(struct userdata *u) { return 0; } +/* Called from IO Context on unsuspend or from main thread when creating source */ +static void reset_watermark(struct userdata *u, size_t tsched_watermark, pa_sample_spec *ss, + bool in_thread) { + u->tsched_watermark = pa_usec_to_bytes_round_up(pa_bytes_to_usec_round_up(tsched_watermark, ss), + &u->source->sample_spec); + + u->watermark_inc_step = pa_usec_to_bytes(TSCHED_WATERMARK_INC_STEP_USEC, &u->source->sample_spec); + u->watermark_dec_step = pa_usec_to_bytes(TSCHED_WATERMARK_DEC_STEP_USEC, &u->source->sample_spec); + + u->watermark_inc_threshold = pa_usec_to_bytes_round_up(TSCHED_WATERMARK_INC_THRESHOLD_USEC, &u->source->sample_spec); + u->watermark_dec_threshold = pa_usec_to_bytes_round_up(TSCHED_WATERMARK_DEC_THRESHOLD_USEC, &u->source->sample_spec); + + fix_min_sleep_wakeup(u); + fix_tsched_watermark(u); + + if (in_thread) + pa_source_set_latency_range_within_thread(u->source, + u->min_latency_ref, + pa_bytes_to_usec(u->hwbuf_size, ss)); + else { + pa_source_set_latency_range(u->source, + 0, + pa_bytes_to_usec(u->hwbuf_size, ss)); + + /* work-around assert in pa_source_set_latency_within_thead, + keep track of min_latency and reuse it when + this routine is called from IO context */ + u->min_latency_ref = u->source->thread_info.min_latency; + } + + pa_log_info("Time scheduling watermark is %0.2fms", + (double) u->tsched_watermark_usec / PA_USEC_PER_MSEC); +} + +/* Called from IO context */ static int unsuspend(struct userdata *u) { pa_sample_spec ss; int err; - pa_bool_t b, d; + bool b, d; snd_pcm_uframes_t period_size, buffer_size; pa_assert(u); @@ -911,7 +972,7 @@ static int unsuspend(struct userdata *u) { b = u->use_mmap; d = u->use_tsched; - if ((err = pa_alsa_set_hw_params(u->pcm_handle, &ss, &period_size, &buffer_size, 0, &b, &d, TRUE)) < 0) { + if ((err = pa_alsa_set_hw_params(u->pcm_handle, &ss, &period_size, &buffer_size, 0, &b, &d, true)) < 0) { pa_log("Failed to set hardware parameters: %s", pa_alsa_strerror(err)); goto fail; } @@ -942,13 +1003,17 @@ static int unsuspend(struct userdata *u) { /* FIXME: We need to reload the volume somehow */ - snd_pcm_start(u->pcm_handle); - u->read_count = 0; - pa_smoother_reset(u->smoother, pa_rtclock_now(), TRUE); + pa_smoother_reset(u->smoother, pa_rtclock_now(), true); u->smoother_interval = SMOOTHER_MIN_INTERVAL; u->last_smoother_update = 0; + u->first = true; + + /* reset the watermark to the value defined when source was created */ + if (u->use_tsched) + reset_watermark(u, u->tsched_watermark_ref, &u->source->sample_spec, true); + pa_log_info("Resumed successfully..."); return 0; @@ -962,6 +1027,7 @@ fail: return -PA_ERR_IO; } +/* Called from IO context */ static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) { struct userdata *u = PA_SOURCE(o)->userdata; @@ -984,6 +1050,7 @@ static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t off case PA_SOURCE_SUSPENDED: { int r; + pa_assert(PA_SOURCE_IS_OPENED(u->source->thread_info.state)); if ((r = suspend(u)) < 0) @@ -999,8 +1066,6 @@ static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t off if (u->source->thread_info.state == PA_SOURCE_INIT) { if (build_pollfd(u) < 0) return -PA_ERR_IO; - - snd_pcm_start(u->pcm_handle); } if (u->source->thread_info.state == PA_SOURCE_SUSPENDED) { @@ -1033,16 +1098,16 @@ static int source_set_state_cb(pa_source *s, pa_source_state_t new_state) { old_state = pa_source_get_state(u->source); - if (PA_SINK_IS_OPENED(old_state) && new_state == PA_SINK_SUSPENDED) + if (PA_SOURCE_IS_OPENED(old_state) && new_state == PA_SOURCE_SUSPENDED) reserve_done(u); - else if (old_state == PA_SINK_SUSPENDED && PA_SINK_IS_OPENED(new_state)) + else if (old_state == PA_SOURCE_SUSPENDED && PA_SOURCE_IS_OPENED(new_state)) if (reserve_init(u, u->device_name) < 0) return -PA_ERR_BUSY; return 0; } -static int mixer_callback(snd_mixer_elem_t *elem, unsigned int mask) { +static int ctl_mixer_callback(snd_mixer_elem_t *elem, unsigned int mask) { struct userdata *u = snd_mixer_elem_get_callback_private(elem); pa_assert(u); @@ -1051,18 +1116,46 @@ static int mixer_callback(snd_mixer_elem_t *elem, unsigned int mask) { if (mask == SND_CTL_EVENT_MASK_REMOVE) return 0; + if (!PA_SOURCE_IS_LINKED(u->source->state)) + return 0; + + if (u->source->suspend_cause & PA_SUSPEND_SESSION) { + pa_source_set_mixer_dirty(u->source, true); + return 0; + } + if (mask & SND_CTL_EVENT_MASK_VALUE) { - pa_source_get_volume(u->source, TRUE); - pa_source_get_mute(u->source, TRUE); + pa_source_get_volume(u->source, true); + pa_source_get_mute(u->source, true); + } + + return 0; +} + +static int io_mixer_callback(snd_mixer_elem_t *elem, unsigned int mask) { + struct userdata *u = snd_mixer_elem_get_callback_private(elem); + + pa_assert(u); + pa_assert(u->mixer_handle); + + if (mask == SND_CTL_EVENT_MASK_REMOVE) + return 0; + + if (u->source->suspend_cause & PA_SUSPEND_SESSION) { + pa_source_set_mixer_dirty(u->source, true); + return 0; } + if (mask & SND_CTL_EVENT_MASK_VALUE) + pa_source_update_volume_and_mute(u->source); + return 0; } static void source_get_volume_cb(pa_source *s) { struct userdata *u = s->userdata; pa_cvolume r; - char t[PA_CVOLUME_SNPRINT_MAX]; + char volume_buf[PA_CVOLUME_SNPRINT_VERBOSE_MAX]; pa_assert(u); pa_assert(u->mixer_path); @@ -1074,12 +1167,13 @@ static void source_get_volume_cb(pa_source *s) { /* Shift down by the base volume, so that 0dB becomes maximum volume */ pa_sw_cvolume_multiply_scalar(&r, &r, s->base_volume); - pa_log_debug("Read hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &r)); + pa_log_debug("Read hardware volume: %s", + pa_cvolume_snprint_verbose(volume_buf, sizeof(volume_buf), &r, &s->channel_map, u->mixer_path->has_dB)); if (pa_cvolume_equal(&u->hardware_volume, &r)) return; - s->volume = u->hardware_volume = r; + s->real_volume = u->hardware_volume = r; /* Hmm, so the hardware volume changed, let's reset our software volume */ if (u->mixer_path->has_dB) @@ -1089,16 +1183,17 @@ static void source_get_volume_cb(pa_source *s) { static void source_set_volume_cb(pa_source *s) { struct userdata *u = s->userdata; pa_cvolume r; - char t[PA_CVOLUME_SNPRINT_MAX]; + char volume_buf[PA_CVOLUME_SNPRINT_VERBOSE_MAX]; + bool deferred_volume = !!(s->flags & PA_SOURCE_DEFERRED_VOLUME); pa_assert(u); pa_assert(u->mixer_path); pa_assert(u->mixer_handle); /* Shift up by the base volume */ - pa_sw_cvolume_divide_scalar(&r, &s->volume, s->base_volume); + pa_sw_cvolume_divide_scalar(&r, &s->real_volume, s->base_volume); - if (pa_alsa_path_set_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r) < 0) + if (pa_alsa_path_set_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r, deferred_volume, !deferred_volume) < 0) return; /* Shift down by the base volume, so that 0dB becomes maximum volume */ @@ -1108,10 +1203,10 @@ static void source_set_volume_cb(pa_source *s) { if (u->mixer_path->has_dB) { pa_cvolume new_soft_volume; - pa_bool_t accurate_enough; + bool accurate_enough; /* Match exactly what the user requested by software */ - pa_sw_cvolume_divide(&new_soft_volume, &s->volume, &u->hardware_volume); + pa_sw_cvolume_divide(&new_soft_volume, &s->real_volume, &u->hardware_volume); /* If the adjustment to do in software is only minimal we * can skip it. That saves us CPU at the expense of a bit of @@ -1120,27 +1215,71 @@ static void source_set_volume_cb(pa_source *s) { (pa_cvolume_min(&new_soft_volume) >= (PA_VOLUME_NORM - VOLUME_ACCURACY)) && (pa_cvolume_max(&new_soft_volume) <= (PA_VOLUME_NORM + VOLUME_ACCURACY)); - pa_log_debug("Requested volume: %s", pa_cvolume_snprint(t, sizeof(t), &s->volume)); - pa_log_debug("Got hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &u->hardware_volume)); - pa_log_debug("Calculated software volume: %s (accurate-enough=%s)", pa_cvolume_snprint(t, sizeof(t), &new_soft_volume), + pa_log_debug("Requested volume: %s", + pa_cvolume_snprint_verbose(volume_buf, sizeof(volume_buf), &s->real_volume, &s->channel_map, true)); + pa_log_debug("Got hardware volume: %s", + pa_cvolume_snprint_verbose(volume_buf, sizeof(volume_buf), &u->hardware_volume, &s->channel_map, true)); + pa_log_debug("Calculated software volume: %s (accurate-enough=%s)", + pa_cvolume_snprint_verbose(volume_buf, sizeof(volume_buf), &new_soft_volume, &s->channel_map, true), pa_yes_no(accurate_enough)); if (!accurate_enough) s->soft_volume = new_soft_volume; } else { - pa_log_debug("Wrote hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &r)); + pa_log_debug("Wrote hardware volume: %s", + pa_cvolume_snprint_verbose(volume_buf, sizeof(volume_buf), &r, &s->channel_map, false)); /* We can't match exactly what the user requested, hence let's * at least tell the user about it */ - s->volume = r; + s->real_volume = r; + } +} + +static void source_write_volume_cb(pa_source *s) { + struct userdata *u = s->userdata; + pa_cvolume hw_vol = s->thread_info.current_hw_volume; + + pa_assert(u); + pa_assert(u->mixer_path); + pa_assert(u->mixer_handle); + pa_assert(s->flags & PA_SOURCE_DEFERRED_VOLUME); + + /* Shift up by the base volume */ + pa_sw_cvolume_divide_scalar(&hw_vol, &hw_vol, s->base_volume); + + if (pa_alsa_path_set_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &hw_vol, true, true) < 0) + pa_log_error("Writing HW volume failed"); + else { + pa_cvolume tmp_vol; + bool accurate_enough; + + /* Shift down by the base volume, so that 0dB becomes maximum volume */ + pa_sw_cvolume_multiply_scalar(&hw_vol, &hw_vol, s->base_volume); + + pa_sw_cvolume_divide(&tmp_vol, &hw_vol, &s->thread_info.current_hw_volume); + accurate_enough = + (pa_cvolume_min(&tmp_vol) >= (PA_VOLUME_NORM - VOLUME_ACCURACY)) && + (pa_cvolume_max(&tmp_vol) <= (PA_VOLUME_NORM + VOLUME_ACCURACY)); + + if (!accurate_enough) { + char volume_buf[2][PA_CVOLUME_SNPRINT_VERBOSE_MAX]; + + pa_log_debug("Written HW volume did not match with the request: %s (request) != %s", + pa_cvolume_snprint_verbose(volume_buf[0], + sizeof(volume_buf[0]), + &s->thread_info.current_hw_volume, + &s->channel_map, + true), + pa_cvolume_snprint_verbose(volume_buf[1], sizeof(volume_buf[1]), &hw_vol, &s->channel_map, true)); + } } } static void source_get_mute_cb(pa_source *s) { struct userdata *u = s->userdata; - pa_bool_t b; + bool b; pa_assert(u); pa_assert(u->mixer_path); @@ -1162,6 +1301,65 @@ static void source_set_mute_cb(pa_source *s) { pa_alsa_path_set_mute(u->mixer_path, u->mixer_handle, s->muted); } +static void mixer_volume_init(struct userdata *u) { + pa_assert(u); + + if (!u->mixer_path->has_volume) { + pa_source_set_write_volume_callback(u->source, NULL); + pa_source_set_get_volume_callback(u->source, NULL); + pa_source_set_set_volume_callback(u->source, NULL); + + pa_log_info("Driver does not support hardware volume control, falling back to software volume control."); + } else { + pa_source_set_get_volume_callback(u->source, source_get_volume_cb); + pa_source_set_set_volume_callback(u->source, source_set_volume_cb); + + if (u->mixer_path->has_dB && u->deferred_volume) { + pa_source_set_write_volume_callback(u->source, source_write_volume_cb); + pa_log_info("Successfully enabled deferred volume."); + } else + pa_source_set_write_volume_callback(u->source, NULL); + + if (u->mixer_path->has_dB) { + pa_source_enable_decibel_volume(u->source, true); + pa_log_info("Hardware volume ranges from %0.2f dB to %0.2f dB.", u->mixer_path->min_dB, u->mixer_path->max_dB); + + u->source->base_volume = pa_sw_volume_from_dB(-u->mixer_path->max_dB); + u->source->n_volume_steps = PA_VOLUME_NORM+1; + + pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(u->source->base_volume)); + } else { + pa_source_enable_decibel_volume(u->source, false); + pa_log_info("Hardware volume ranges from %li to %li.", u->mixer_path->min_volume, u->mixer_path->max_volume); + + u->source->base_volume = PA_VOLUME_NORM; + u->source->n_volume_steps = u->mixer_path->max_volume - u->mixer_path->min_volume + 1; + } + + pa_log_info("Using hardware volume control. Hardware dB scale %s.", u->mixer_path->has_dB ? "supported" : "not supported"); + } + + if (!u->mixer_path->has_mute) { + pa_source_set_get_mute_callback(u->source, NULL); + pa_source_set_set_mute_callback(u->source, NULL); + pa_log_info("Driver does not support hardware mute control, falling back to software mute control."); + } else { + pa_source_set_get_mute_callback(u->source, source_get_mute_cb); + pa_source_set_set_mute_callback(u->source, source_set_mute_cb); + pa_log_info("Using hardware mute control."); + } +} + +static int source_set_port_ucm_cb(pa_source *s, pa_device_port *p) { + struct userdata *u = s->userdata; + + pa_assert(u); + pa_assert(p); + pa_assert(u->ucm_context); + + return pa_alsa_ucm_set_port(u->ucm_context, p, false); +} + static int source_set_port_cb(pa_source *s, pa_device_port *p) { struct userdata *u = s->userdata; pa_alsa_port_data *data; @@ -1173,28 +1371,19 @@ static int source_set_port_cb(pa_source *s, pa_device_port *p) { data = PA_DEVICE_PORT_DATA(p); pa_assert_se(u->mixer_path = data->path); - pa_alsa_path_select(u->mixer_path, u->mixer_handle); - - if (u->mixer_path->has_volume && u->mixer_path->has_dB) { - s->base_volume = pa_sw_volume_from_dB(-u->mixer_path->max_dB); - s->n_volume_steps = PA_VOLUME_NORM+1; - - if (u->mixer_path->max_dB > 0.0) - pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(s->base_volume)); - else - pa_log_info("No particular base volume set, fixing to 0 dB"); - } else { - s->base_volume = PA_VOLUME_NORM; - s->n_volume_steps = u->mixer_path->max_volume - u->mixer_path->min_volume + 1; - } + pa_alsa_path_select(u->mixer_path, data->setting, u->mixer_handle, s->muted); - if (data->setting) - pa_alsa_setting_select(data->setting, u->mixer_handle); + mixer_volume_init(u); if (s->set_mute) s->set_mute(s); - if (s->set_volume) - s->set_volume(s); + if (s->flags & PA_SOURCE_DEFERRED_VOLUME) { + if (s->write_volume) + s->write_volume(s); + } else { + if (s->set_volume) + s->set_volume(s); + } return 0; } @@ -1202,6 +1391,9 @@ static int source_set_port_cb(pa_source *s, pa_device_port *p) { static void source_update_requested_latency_cb(pa_source *s) { struct userdata *u = s->userdata; pa_assert(u); + pa_assert(u->use_tsched); /* only when timer scheduling is used + * we can dynamically adjust the + * latency */ if (!u->pcm_handle) return; @@ -1209,6 +1401,34 @@ static void source_update_requested_latency_cb(pa_source *s) { update_sw_params(u); } +static int source_update_rate_cb(pa_source *s, uint32_t rate) { + struct userdata *u = s->userdata; + int i; + bool supported = false; + + pa_assert(u); + + for (i = 0; u->rates[i]; i++) { + if (u->rates[i] == rate) { + supported = true; + break; + } + } + + if (!supported) { + pa_log_info("Source does not support sample rate of %d Hz", rate); + return -1; + } + + if (!PA_SOURCE_IS_OPENED(s->state)) { + pa_log_info("Updating rate for device %s, new rate is %d", u->device_name, rate); + u->source->sample_spec.rate = rate; + return 0; + } + + return -1; +} + static void thread_func(void *userdata) { struct userdata *u = userdata; unsigned short revents = 0; @@ -1224,6 +1444,7 @@ static void thread_func(void *userdata) { for (;;) { int ret; + pa_usec_t rtpoll_sleep = 0, real_sleep; #ifdef DEBUG_TIMING pa_log_debug("Loop"); @@ -1233,7 +1454,16 @@ static void thread_func(void *userdata) { if (PA_SOURCE_IS_OPENED(u->source->thread_info.state)) { int work_done; pa_usec_t sleep_usec = 0; - pa_bool_t on_timeout = pa_rtpoll_timer_elapsed(u->rtpoll); + bool on_timeout = pa_rtpoll_timer_elapsed(u->rtpoll); + + if (u->first) { + pa_log_info("Starting capture."); + snd_pcm_start(u->pcm_handle); + + pa_smoother_resume(u->smoother, pa_rtclock_now(), true); + + u->first = false; + } if (u->use_mmap) work_done = mmap_read(u, &sleep_usec, revents & POLLIN, on_timeout); @@ -1263,17 +1493,48 @@ static void thread_func(void *userdata) { /* pa_log_debug("Waking up in %0.2fms (system clock).", (double) cusec / PA_USEC_PER_MSEC); */ /* We don't trust the conversion, so we wake up whatever comes first */ - pa_rtpoll_set_timer_relative(u->rtpoll, PA_MIN(sleep_usec, cusec)); + rtpoll_sleep = PA_MIN(sleep_usec, cusec); + } + } + + if (u->source->flags & PA_SOURCE_DEFERRED_VOLUME) { + pa_usec_t volume_sleep; + pa_source_volume_change_apply(u->source, &volume_sleep); + if (volume_sleep > 0) { + if (rtpoll_sleep > 0) + rtpoll_sleep = PA_MIN(volume_sleep, rtpoll_sleep); + else + rtpoll_sleep = volume_sleep; } - } else if (u->use_tsched) + } - /* OK, we're in an invalid state, let's disable our timers */ + if (rtpoll_sleep > 0) { + pa_rtpoll_set_timer_relative(u->rtpoll, rtpoll_sleep); + real_sleep = pa_rtclock_now(); + } + else pa_rtpoll_set_timer_disabled(u->rtpoll); /* Hmm, nothing to do. Let's sleep */ - if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0) + if ((ret = pa_rtpoll_run(u->rtpoll, true)) < 0) goto fail; + if (rtpoll_sleep > 0) { + real_sleep = pa_rtclock_now() - real_sleep; +#ifdef DEBUG_TIMING + pa_log_debug("Expected sleep: %0.2fms, real sleep: %0.2fms (diff %0.2f ms)", + (double) rtpoll_sleep / PA_USEC_PER_MSEC, (double) real_sleep / PA_USEC_PER_MSEC, + (double) ((int64_t) real_sleep - (int64_t) rtpoll_sleep) / PA_USEC_PER_MSEC); +#endif + if (u->use_tsched && real_sleep > rtpoll_sleep + u->tsched_watermark_usec) + pa_log_info("Scheduling delay of %0.2f ms > %0.2f ms, you might want to investigate this to improve latency...", + (double) (real_sleep - rtpoll_sleep) / PA_USEC_PER_MSEC, + (double) (u->tsched_watermark_usec) / PA_USEC_PER_MSEC); + } + + if (u->source->flags & PA_SOURCE_DEFERRED_VOLUME) + pa_source_volume_change_apply(u->source, NULL); + if (ret == 0) goto finish; @@ -1294,8 +1555,9 @@ static void thread_func(void *userdata) { if (pa_alsa_recover_from_poll(u->pcm_handle, revents) < 0) goto fail; - snd_pcm_start(u->pcm_handle); - } else if (revents && u->use_tsched && pa_log_ratelimit()) + u->first = true; + revents = 0; + } else if (revents && u->use_tsched && pa_log_ratelimit(PA_LOG_DEBUG)) pa_log_debug("Wakeup from ALSA!"); } else @@ -1322,15 +1584,15 @@ static void set_source_name(pa_source_new_data *data, pa_modargs *ma, const char if ((n = pa_modargs_get_value(ma, "source_name", NULL))) { pa_source_new_data_set_name(data, n); - data->namereg_fail = TRUE; + data->namereg_fail = true; return; } if ((n = pa_modargs_get_value(ma, "name", NULL))) - data->namereg_fail = TRUE; + data->namereg_fail = true; else { n = device_id ? device_id : device_name; - data->namereg_fail = FALSE; + data->namereg_fail = false; } if (mapping) @@ -1342,12 +1604,13 @@ static void set_source_name(pa_source_new_data *data, pa_modargs *ma, const char pa_xfree(t); } -static void find_mixer(struct userdata *u, pa_alsa_mapping *mapping, const char *element, pa_bool_t ignore_dB) { +static void find_mixer(struct userdata *u, pa_alsa_mapping *mapping, const char *element, bool ignore_dB) { + snd_hctl_t *hctl; if (!mapping && !element) return; - if (!(u->mixer_handle = pa_alsa_open_mixer_for_pcm(u->pcm_handle, &u->control_device))) { + if (!(u->mixer_handle = pa_alsa_open_mixer_for_pcm(u->pcm_handle, &u->control_device, &hctl))) { pa_log_info("Failed to find a working mixer device."); return; } @@ -1357,30 +1620,19 @@ static void find_mixer(struct userdata *u, pa_alsa_mapping *mapping, const char if (!(u->mixer_path = pa_alsa_path_synthesize(element, PA_ALSA_DIRECTION_INPUT))) goto fail; - if (pa_alsa_path_probe(u->mixer_path, u->mixer_handle, ignore_dB) < 0) + if (pa_alsa_path_probe(u->mixer_path, u->mixer_handle, hctl, ignore_dB) < 0) goto fail; pa_log_debug("Probed mixer path %s:", u->mixer_path->name); pa_alsa_path_dump(u->mixer_path); - } else { - - if (!(u->mixer_path_set = pa_alsa_path_set_new(mapping, PA_ALSA_DIRECTION_INPUT))) - goto fail; - - pa_alsa_path_set_probe(u->mixer_path_set, u->mixer_handle, ignore_dB); - - pa_log_debug("Probed mixer paths:"); - pa_alsa_path_set_dump(u->mixer_path_set); - } + } else if (!(u->mixer_path_set = mapping->input_path_set)) + goto fail; return; fail: - if (u->mixer_path_set) { - pa_alsa_path_set_free(u->mixer_path_set); - u->mixer_path_set = NULL; - } else if (u->mixer_path) { + if (u->mixer_path) { pa_alsa_path_free(u->mixer_path); u->mixer_path = NULL; } @@ -1391,7 +1643,9 @@ fail: } } -static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB) { +static int setup_mixer(struct userdata *u, bool ignore_dB) { + bool need_mixer_callback = false; + pa_assert(u); if (!u->mixer_handle) @@ -1406,75 +1660,61 @@ static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB) { data = PA_DEVICE_PORT_DATA(u->source->active_port); u->mixer_path = data->path; - pa_alsa_path_select(data->path, u->mixer_handle); - - if (data->setting) - pa_alsa_setting_select(data->setting, u->mixer_handle); + pa_alsa_path_select(data->path, data->setting, u->mixer_handle, u->source->muted); } else { if (!u->mixer_path && u->mixer_path_set) - u->mixer_path = u->mixer_path_set->paths; + u->mixer_path = pa_hashmap_first(u->mixer_path_set->paths); if (u->mixer_path) { /* Hmm, we have only a single path, then let's activate it */ - pa_alsa_path_select(u->mixer_path, u->mixer_handle); - - if (u->mixer_path->settings) - pa_alsa_setting_select(u->mixer_path->settings, u->mixer_handle); + pa_alsa_path_select(u->mixer_path, u->mixer_path->settings, u->mixer_handle, u->source->muted); } else return 0; } - if (!u->mixer_path->has_volume) - pa_log_info("Driver does not support hardware volume control, falling back to software volume control."); - else { + mixer_volume_init(u); - if (u->mixer_path->has_dB) { - pa_log_info("Hardware volume ranges from %0.2f dB to %0.2f dB.", u->mixer_path->min_dB, u->mixer_path->max_dB); + /* Will we need to register callbacks? */ + if (u->mixer_path_set && u->mixer_path_set->paths) { + pa_alsa_path *p; + void *state; - u->source->base_volume = pa_sw_volume_from_dB(-u->mixer_path->max_dB); - u->source->n_volume_steps = PA_VOLUME_NORM+1; - - if (u->mixer_path->max_dB > 0.0) - pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(u->source->base_volume)); - else - pa_log_info("No particular base volume set, fixing to 0 dB"); - - } else { - pa_log_info("Hardware volume ranges from %li to %li.", u->mixer_path->min_volume, u->mixer_path->max_volume); - u->source->base_volume = PA_VOLUME_NORM; - u->source->n_volume_steps = u->mixer_path->max_volume - u->mixer_path->min_volume + 1; + PA_HASHMAP_FOREACH(p, u->mixer_path_set->paths, state) { + if (p->has_volume || p->has_mute) + need_mixer_callback = true; } - - u->source->get_volume = source_get_volume_cb; - u->source->set_volume = source_set_volume_cb; - - u->source->flags |= PA_SOURCE_HW_VOLUME_CTRL | (u->mixer_path->has_dB ? PA_SOURCE_DECIBEL_VOLUME : 0); - pa_log_info("Using hardware volume control. Hardware dB scale %s.", u->mixer_path->has_dB ? "supported" : "not supported"); } + else if (u->mixer_path) + need_mixer_callback = u->mixer_path->has_volume || u->mixer_path->has_mute; - if (!u->mixer_path->has_mute) { - pa_log_info("Driver does not support hardware mute control, falling back to software mute control."); - } else { - u->source->get_mute = source_get_mute_cb; - u->source->set_mute = source_set_mute_cb; - u->source->flags |= PA_SOURCE_HW_MUTE_CTRL; - pa_log_info("Using hardware mute control."); - } + if (need_mixer_callback) { + int (*mixer_callback)(snd_mixer_elem_t *, unsigned int); + if (u->source->flags & PA_SOURCE_DEFERRED_VOLUME) { + u->mixer_pd = pa_alsa_mixer_pdata_new(); + mixer_callback = io_mixer_callback; - u->mixer_fdl = pa_alsa_fdlist_new(); + if (pa_alsa_set_mixer_rtpoll(u->mixer_pd, u->mixer_handle, u->rtpoll) < 0) { + pa_log("Failed to initialize file descriptor monitoring"); + return -1; + } + } else { + u->mixer_fdl = pa_alsa_fdlist_new(); + mixer_callback = ctl_mixer_callback; - if (pa_alsa_fdlist_set_mixer(u->mixer_fdl, u->mixer_handle, u->core->mainloop) < 0) { - pa_log("Failed to initialize file descriptor monitoring"); - return -1; - } + if (pa_alsa_fdlist_set_handle(u->mixer_fdl, u->mixer_handle, NULL, u->core->mainloop) < 0) { + pa_log("Failed to initialize file descriptor monitoring"); + return -1; + } + } - if (u->mixer_path_set) - pa_alsa_path_set_set_callback(u->mixer_path_set, u->mixer_handle, mixer_callback, u); - else - pa_alsa_path_set_callback(u->mixer_path, u->mixer_handle, mixer_callback, u); + if (u->mixer_path_set) + pa_alsa_path_set_set_callback(u->mixer_path_set, u->mixer_handle, mixer_callback, u); + else + pa_alsa_path_set_callback(u->mixer_path, u->mixer_handle, mixer_callback, u); + } return 0; } @@ -1482,27 +1722,50 @@ static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB) { pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, pa_card *card, pa_alsa_mapping *mapping) { struct userdata *u = NULL; - const char *dev_id = NULL; - pa_sample_spec ss, requested_ss; + const char *dev_id = NULL, *key, *mod_name; + pa_sample_spec ss; + char *thread_name = NULL; + uint32_t alternate_sample_rate; pa_channel_map map; uint32_t nfrags, frag_size, buffer_size, tsched_size, tsched_watermark; snd_pcm_uframes_t period_frames, buffer_frames, tsched_frames; size_t frame_size; - pa_bool_t use_mmap = TRUE, b, use_tsched = TRUE, d, ignore_dB = FALSE; + bool use_mmap = true, b, use_tsched = true, d, ignore_dB = false, namereg_fail = false, deferred_volume = false, fixed_latency_range = false; pa_source_new_data data; pa_alsa_profile_set *profile_set = NULL; + void *state = NULL; pa_assert(m); pa_assert(ma); ss = m->core->default_sample_spec; map = m->core->default_channel_map; + + /* Pick sample spec overrides from the mapping, if any */ + if (mapping) { + if (mapping->sample_spec.format != PA_SAMPLE_INVALID) + ss.format = mapping->sample_spec.format; + if (mapping->sample_spec.rate != 0) + ss.rate = mapping->sample_spec.rate; + if (mapping->sample_spec.channels != 0) { + ss.channels = mapping->sample_spec.channels; + if (pa_channel_map_valid(&mapping->channel_map)) + pa_assert(pa_channel_map_compatible(&mapping->channel_map, &ss)); + } + } + + /* Override with modargs if provided */ if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_ALSA) < 0) { - pa_log("Failed to parse sample specification"); + pa_log("Failed to parse sample specification and channel map"); + goto fail; + } + + alternate_sample_rate = m->core->alternate_sample_rate; + if (pa_modargs_get_alternate_sample_rate(ma, &alternate_sample_rate) < 0) { + pa_log("Failed to parse alternate sample rate"); goto fail; } - requested_ss = ss; frame_size = pa_frame_size(&ss); nfrags = m->core->default_n_fragments; @@ -1532,7 +1795,7 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p } if (pa_modargs_get_value_boolean(ma, "tsched", &use_tsched) < 0) { - pa_log("Failed to parse timer_scheduling argument."); + pa_log("Failed to parse tsched argument."); goto fail; } @@ -1541,6 +1804,17 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p goto fail; } + deferred_volume = m->core->deferred_volume; + if (pa_modargs_get_value_boolean(ma, "deferred_volume", &deferred_volume) < 0) { + pa_log("Failed to parse deferred_volume argument."); + goto fail; + } + + if (pa_modargs_get_value_boolean(ma, "fixed_latency_range", &fixed_latency_range) < 0) { + pa_log("Failed to parse fixed_latency_range argument."); + goto fail; + } + use_tsched = pa_alsa_may_tsched(use_tsched); u = pa_xnew0(struct userdata, 1); @@ -1548,23 +1822,32 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p u->module = m; u->use_mmap = use_mmap; u->use_tsched = use_tsched; + u->deferred_volume = deferred_volume; + u->fixed_latency_range = fixed_latency_range; + u->first = true; u->rtpoll = pa_rtpoll_new(); pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll); u->smoother = pa_smoother_new( - DEFAULT_TSCHED_WATERMARK_USEC*2, - DEFAULT_TSCHED_WATERMARK_USEC*2, - TRUE, - TRUE, + SMOOTHER_ADJUST_USEC, + SMOOTHER_WINDOW_USEC, + true, + true, 5, pa_rtclock_now(), - FALSE); + true); u->smoother_interval = SMOOTHER_MIN_INTERVAL; + /* use ucm */ + if (mapping && mapping->ucm_context.ucm) + u->ucm_context = &mapping->ucm_context; + dev_id = pa_modargs_get_value( ma, "device_id", pa_modargs_get_value(ma, "device", DEFAULT_DEVICE)); + u->paths_dir = pa_xstrdup(pa_modargs_get_value(ma, "paths_dir", NULL)); + if (reserve_init(u, dev_id) < 0) goto fail; @@ -1581,6 +1864,13 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p goto fail; } + if ((mod_name = pa_proplist_gets(mapping->proplist, PA_ALSA_PROP_UCM_MODIFIER))) { + if (snd_use_case_set(u->ucm_context->ucm->ucm_mgr, "_enamod", mod_name) < 0) + pa_log("Failed to enable ucm modifier %s", mod_name); + else + pa_log_debug("Enabled ucm modifier %s", mod_name); + } + if (!(u->pcm_handle = pa_alsa_open_by_device_id_mapping( dev_id, &u->device_name, @@ -1612,7 +1902,7 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p &ss, &map, SND_PCM_STREAM_CAPTURE, &period_frames, &buffer_frames, tsched_frames, - &b, &d, FALSE))) + &b, &d, false))) goto fail; } @@ -1629,32 +1919,56 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p if (use_mmap && !b) { pa_log_info("Device doesn't support mmap(), falling back to UNIX read/write mode."); - u->use_mmap = use_mmap = FALSE; + u->use_mmap = use_mmap = false; } if (use_tsched && (!b || !d)) { pa_log_info("Cannot enable timer-based scheduling, falling back to sound IRQ scheduling."); - u->use_tsched = use_tsched = FALSE; + u->use_tsched = use_tsched = false; } if (u->use_mmap) pa_log_info("Successfully enabled mmap() mode."); - if (u->use_tsched) + if (u->use_tsched) { pa_log_info("Successfully enabled timer-based scheduling mode."); + if (u->fixed_latency_range) + pa_log_info("Disabling latency range changes on overrun"); + } + + u->rates = pa_alsa_get_supported_rates(u->pcm_handle, ss.rate); + if (!u->rates) { + pa_log_error("Failed to find any supported sample rates."); + goto fail; + } /* ALSA might tweak the sample spec, so recalculate the frame size */ frame_size = pa_frame_size(&ss); - find_mixer(u, mapping, pa_modargs_get_value(ma, "control", NULL), ignore_dB); + if (!u->ucm_context) + find_mixer(u, mapping, pa_modargs_get_value(ma, "control", NULL), ignore_dB); pa_source_new_data_init(&data); data.driver = driver; data.module = m; data.card = card; set_source_name(&data, ma, dev_id, u->device_name, mapping); + + /* We need to give pa_modargs_get_value_boolean() a pointer to a local + * variable instead of using &data.namereg_fail directly, because + * data.namereg_fail is a bitfield and taking the address of a bitfield + * variable is impossible. */ + namereg_fail = data.namereg_fail; + if (pa_modargs_get_value_boolean(ma, "namereg_fail", &namereg_fail) < 0) { + pa_log("Failed to parse namereg_fail argument."); + pa_source_new_data_done(&data); + goto fail; + } + data.namereg_fail = namereg_fail; + pa_source_new_data_set_sample_spec(&data, &ss); pa_source_new_data_set_channel_map(&data, &map); + pa_source_new_data_set_alternate_sample_rate(&data, alternate_sample_rate); pa_alsa_init_proplist_pcm(m->core, data.proplist, u->pcm_handle); pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, u->device_name); @@ -1665,6 +1979,9 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p if (mapping) { pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_NAME, mapping->name); pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_DESCRIPTION, mapping->description); + + while ((key = pa_proplist_iterate(mapping->proplist, &state))) + pa_proplist_sets(data.proplist, key, pa_proplist_gets(mapping->proplist, key)); } pa_alsa_init_description(data.proplist); @@ -1678,8 +1995,10 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p goto fail; } - if (u->mixer_path_set) - pa_alsa_add_ports(&data.ports, u->mixer_path_set); + if (u->ucm_context) + pa_alsa_ucm_add_ports(&data.ports, data.proplist, u->ucm_context, false, card); + else if (u->mixer_path_set) + pa_alsa_add_ports(&data, u->mixer_path_set, card); u->source = pa_source_new(m->core, &data, PA_SOURCE_HARDWARE|PA_SOURCE_LATENCY|(u->use_tsched ? PA_SOURCE_DYNAMIC_LATENCY : 0)); pa_source_new_data_done(&data); @@ -1689,10 +2008,28 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p goto fail; } + if (pa_modargs_get_value_u32(ma, "deferred_volume_safety_margin", + &u->source->thread_info.volume_change_safety_margin) < 0) { + pa_log("Failed to parse deferred_volume_safety_margin parameter"); + goto fail; + } + + if (pa_modargs_get_value_s32(ma, "deferred_volume_extra_delay", + &u->source->thread_info.volume_change_extra_delay) < 0) { + pa_log("Failed to parse deferred_volume_extra_delay parameter"); + goto fail; + } + u->source->parent.process_msg = source_process_msg; - u->source->update_requested_latency = source_update_requested_latency_cb; + if (u->use_tsched) + u->source->update_requested_latency = source_update_requested_latency_cb; u->source->set_state = source_set_state_cb; - u->source->set_port = source_set_port_cb; + if (u->ucm_context) + u->source->set_port = source_set_port_ucm_cb; + else + u->source->set_port = source_set_port_cb; + if (u->source->alternate_sample_rate) + u->source->update_rate = source_update_rate_cb; u->source->userdata = u; pa_source_set_asyncmsgq(u->source, u->thread_mq.inq); @@ -1711,24 +2048,10 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p (double) pa_bytes_to_usec(u->hwbuf_size, &ss) / PA_USEC_PER_MSEC); if (u->use_tsched) { - u->tsched_watermark = pa_usec_to_bytes_round_up(pa_bytes_to_usec_round_up(tsched_watermark, &requested_ss), &u->source->sample_spec); - - u->watermark_inc_step = pa_usec_to_bytes(TSCHED_WATERMARK_INC_STEP_USEC, &u->source->sample_spec); - u->watermark_dec_step = pa_usec_to_bytes(TSCHED_WATERMARK_DEC_STEP_USEC, &u->source->sample_spec); - - u->watermark_inc_threshold = pa_usec_to_bytes_round_up(TSCHED_WATERMARK_INC_THRESHOLD_USEC, &u->source->sample_spec); - u->watermark_dec_threshold = pa_usec_to_bytes_round_up(TSCHED_WATERMARK_DEC_THRESHOLD_USEC, &u->source->sample_spec); - - fix_min_sleep_wakeup(u); - fix_tsched_watermark(u); - - pa_source_set_latency_range(u->source, - 0, - pa_bytes_to_usec(u->hwbuf_size, &ss)); - - pa_log_info("Time scheduling watermark is %0.2fms", - (double) pa_bytes_to_usec(u->tsched_watermark, &ss) / PA_USEC_PER_MSEC); - } else + u->tsched_watermark_ref = tsched_watermark; + reset_watermark(u, u->tsched_watermark_ref, &ss, false); + } + else pa_source_set_fixed_latency(u->source, pa_bytes_to_usec(u->hwbuf_size, &ss)); reserve_update(u); @@ -1736,15 +2059,22 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p if (update_sw_params(u) < 0) goto fail; - if (setup_mixer(u, ignore_dB) < 0) + if (u->ucm_context) { + if (u->source->active_port && pa_alsa_ucm_set_port(u->ucm_context, u->source->active_port, false) < 0) + goto fail; + } else if (setup_mixer(u, ignore_dB) < 0) goto fail; pa_alsa_dump(PA_LOG_DEBUG, u->pcm_handle); - if (!(u->thread = pa_thread_new(thread_func, u))) { + thread_name = pa_sprintf_malloc("alsa-source-%s", pa_strnull(pa_proplist_gets(u->source->proplist, "alsa.id"))); + if (!(u->thread = pa_thread_new(thread_name, thread_func, u))) { pa_log("Failed to create thread."); goto fail; } + pa_xfree(thread_name); + thread_name = NULL; + /* Get initial mixer settings */ if (data.volume_is_set) { if (u->source->set_volume) @@ -1762,6 +2092,9 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p u->source->get_mute(u->source); } + if ((data.volume_is_set || data.muted_is_set) && u->source->write_volume) + u->source->write_volume(u->source); + pa_source_put(u->source); if (profile_set) @@ -1770,6 +2103,7 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p return u->source; fail: + pa_xfree(thread_name); if (u) userdata_free(u); @@ -1796,6 +2130,9 @@ static void userdata_free(struct userdata *u) { if (u->source) pa_source_unref(u->source); + if (u->mixer_pd) + pa_alsa_mixer_pdata_free(u->mixer_pd); + if (u->alsa_rtpoll_item) pa_rtpoll_item_free(u->alsa_rtpoll_item); @@ -1810,9 +2147,7 @@ static void userdata_free(struct userdata *u) { if (u->mixer_fdl) pa_alsa_fdlist_free(u->mixer_fdl); - if (u->mixer_path_set) - pa_alsa_path_set_free(u->mixer_path_set); - else if (u->mixer_path) + if (u->mixer_path && !u->mixer_path_set) pa_alsa_path_free(u->mixer_path); if (u->mixer_handle) @@ -1821,11 +2156,15 @@ static void userdata_free(struct userdata *u) { if (u->smoother) pa_smoother_free(u->smoother); + if (u->rates) + pa_xfree(u->rates); + reserve_done(u); monitor_done(u); pa_xfree(u->device_name); pa_xfree(u->control_device); + pa_xfree(u->paths_dir); pa_xfree(u); }