X-Git-Url: https://code.delx.au/pulseaudio/blobdiff_plain/c88e4680f050a6ac65335b1d8148287cc4566b00..a9cf320bc15a95599a2fe1c7a4357c62555f82ca:/src/modules/alsa/alsa-sink.c diff --git a/src/modules/alsa/alsa-sink.c b/src/modules/alsa/alsa-sink.c index 690480f7..0dd1840a 100644 --- a/src/modules/alsa/alsa-sink.c +++ b/src/modules/alsa/alsa-sink.c @@ -35,7 +35,7 @@ #include #include #include -#include +#include #include #include @@ -49,7 +49,6 @@ #include #include #include -#include #include #include #include @@ -78,11 +77,17 @@ #define TSCHED_MIN_SLEEP_USEC (10*PA_USEC_PER_MSEC) /* 10ms -- Sleep at least 10ms on each iteration */ #define TSCHED_MIN_WAKEUP_USEC (4*PA_USEC_PER_MSEC) /* 4ms -- Wakeup at least this long before the buffer runs empty*/ +#define SMOOTHER_WINDOW_USEC (10*PA_USEC_PER_SEC) /* 10s -- smoother windows size */ +#define SMOOTHER_ADJUST_USEC (1*PA_USEC_PER_SEC) /* 1s -- smoother adjust time */ + #define SMOOTHER_MIN_INTERVAL (2*PA_USEC_PER_MSEC) /* 2ms -- min smoother update interval */ -#define SMOOTHER_MAX_INTERVAL (200*PA_USEC_PER_MSEC) /* 200ms -- max smoother update inteval */ +#define SMOOTHER_MAX_INTERVAL (200*PA_USEC_PER_MSEC) /* 200ms -- max smoother update interval */ #define VOLUME_ACCURACY (PA_VOLUME_NORM/100) /* don't require volume adjustments to be perfectly correct. don't necessarily extend granularity in software unless the differences get greater than this level */ +#define DEFAULT_REWIND_SAFEGUARD_BYTES (256U) /* 1.33ms @48kHz, we'll never rewind less than this */ +#define DEFAULT_REWIND_SAFEGUARD_USEC (1330) /* 1.33ms, depending on channels/rate/sample we may rewind more than 256 above */ + struct userdata { pa_core *core; pa_module *module; @@ -95,12 +100,15 @@ struct userdata { snd_pcm_t *pcm_handle; 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; + uint32_t old_rate; + size_t frame_size, fragment_size, @@ -112,7 +120,8 @@ struct userdata { watermark_inc_step, watermark_dec_step, watermark_inc_threshold, - watermark_dec_threshold; + watermark_dec_threshold, + rewind_safeguard; pa_usec_t watermark_dec_not_before; @@ -246,6 +255,7 @@ static int reserve_monitor_init(struct userdata *u, const char *dname) { 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); @@ -432,7 +442,7 @@ static size_t check_left_to_play(struct userdata *u, size_t n_bytes, pa_bool_t o #endif if (!u->first && !u->after_rewind) - if (pa_log_ratelimit()) + if (pa_log_ratelimit(PA_LOG_INFO)) pa_log_info("Underrun!"); } @@ -469,7 +479,7 @@ static size_t check_left_to_play(struct userdata *u, size_t n_bytes, pa_bool_t o } static int mmap_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled, pa_bool_t on_timeout) { - pa_bool_t work_done = TRUE; + pa_bool_t work_done = FALSE; pa_usec_t max_sleep_usec = 0, process_usec = 0; size_t left_to_play; unsigned j = 0; @@ -607,6 +617,9 @@ static int mmap_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polle if (PA_UNLIKELY((sframes = snd_pcm_mmap_commit(u->pcm_handle, offset, frames)) < 0)) { + if (!after_avail && (int) sframes == -EAGAIN) + break; + if ((r = try_recover(u, "snd_pcm_mmap_commit", (int) sframes)) == 0) continue; @@ -629,11 +642,14 @@ static int mmap_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polle } } - *sleep_usec = pa_bytes_to_usec(left_to_play, &u->sink->sample_spec); + if (u->use_tsched) { + *sleep_usec = pa_bytes_to_usec(left_to_play, &u->sink->sample_spec); - if (*sleep_usec > process_usec) - *sleep_usec -= process_usec; - else + if (*sleep_usec > process_usec) + *sleep_usec -= process_usec; + else + *sleep_usec = 0; + } else *sleep_usec = 0; return work_done ? 1 : 0; @@ -766,11 +782,14 @@ static int unix_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polle } } - *sleep_usec = pa_bytes_to_usec(left_to_play, &u->sink->sample_spec); + if (u->use_tsched) { + *sleep_usec = pa_bytes_to_usec(left_to_play, &u->sink->sample_spec); - if (*sleep_usec > process_usec) - *sleep_usec -= process_usec; - else + if (*sleep_usec > process_usec) + *sleep_usec -= process_usec; + else + *sleep_usec = 0; + } else *sleep_usec = 0; return work_done ? 1 : 0; @@ -790,7 +809,7 @@ 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->sink->sample_spec)) < 0)) { + if (PA_UNLIKELY((err = pa_alsa_safe_delay(u->pcm_handle, &delay, u->hwbuf_size, &u->sink->sample_spec, FALSE)) < 0)) { pa_log_warn("Failed to query DSP status data: %s", pa_alsa_strerror(err)); return; } @@ -876,6 +895,14 @@ static int suspend(struct userdata *u) { u->alsa_rtpoll_item = NULL; } + /* We reset max_rewind/max_request here to make sure that while we + * are suspended the old max_request/max_rewind values set before + * the suspend can influence the per-stream buffer of newly + * created streams, without their requirements having any + * influence on them. */ + pa_sink_set_max_rewind_within_thread(u->sink, 0); + pa_sink_set_max_request_within_thread(u->sink, 0); + pa_log_info("Device suspended..."); return 0; @@ -933,6 +960,12 @@ static int update_sw_params(struct userdata *u) { } pa_sink_set_max_request_within_thread(u->sink, u->hwbuf_size - u->hwbuf_unused); + if (pa_alsa_pcm_is_hw(u->pcm_handle)) + pa_sink_set_max_rewind_within_thread(u->sink, u->hwbuf_size); + else { + pa_log_info("Disabling rewind_within_thread for device %s", u->device_name); + pa_sink_set_max_rewind_within_thread(u->sink, 0); + } return 0; } @@ -1020,6 +1053,56 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse switch (code) { + case PA_SINK_MESSAGE_FINISH_MOVE: + case PA_SINK_MESSAGE_ADD_INPUT: { + pa_sink_input *i = PA_SINK_INPUT(data); + int r = 0; + + if (PA_LIKELY(!pa_sink_input_is_passthrough(i))) + break; + + u->old_rate = u->sink->sample_spec.rate; + + /* Passthrough format, see if we need to reset sink sample rate */ + if (u->sink->sample_spec.rate == i->thread_info.sample_spec.rate) + break; + + /* .. we do */ + if ((r = suspend(u)) < 0) + return r; + + u->sink->sample_spec.rate = i->thread_info.sample_spec.rate; + + if ((r = unsuspend(u)) < 0) + return r; + + break; + } + + case PA_SINK_MESSAGE_START_MOVE: + case PA_SINK_MESSAGE_REMOVE_INPUT: { + pa_sink_input *i = PA_SINK_INPUT(data); + int r = 0; + + if (PA_LIKELY(!pa_sink_input_is_passthrough(i))) + break; + + /* Passthrough format, see if we need to reset sink sample rate */ + if (u->sink->sample_spec.rate == u->old_rate) + break; + + /* .. we do */ + if ((r = suspend(u)) < 0) + return r; + + u->sink->sample_spec.rate = u->old_rate; + + if ((r = unsuspend(u)) < 0) + return r; + + break; + } + case PA_SINK_MESSAGE_GET_LATENCY: { pa_usec_t r = 0; @@ -1094,7 +1177,7 @@ static int sink_set_state_cb(pa_sink *s, pa_sink_state_t new_state) { 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); @@ -1114,10 +1197,28 @@ static int mixer_callback(snd_mixer_elem_t *elem, unsigned int mask) { 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->sink->suspend_cause & PA_SUSPEND_SESSION) + return 0; + + if (mask & SND_CTL_EVENT_MASK_VALUE) + pa_sink_update_volume_and_mute(u->sink); + + return 0; +} + static void sink_get_volume_cb(pa_sink *s) { struct userdata *u = s->userdata; pa_cvolume r; - char t[PA_CVOLUME_SNPRINT_MAX]; + char vol_str_pcnt[PA_CVOLUME_SNPRINT_MAX]; pa_assert(u); pa_assert(u->mixer_path); @@ -1129,7 +1230,13 @@ static void sink_get_volume_cb(pa_sink *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(vol_str_pcnt, sizeof(vol_str_pcnt), &r)); + + if (u->mixer_path->has_dB) { + char vol_str_db[PA_SW_CVOLUME_SNPRINT_DB_MAX]; + + pa_log_debug(" in dB: %s", pa_sw_cvolume_snprint_dB(vol_str_db, sizeof(vol_str_db), &r)); + } if (pa_cvolume_equal(&u->hardware_volume, &r)) return; @@ -1144,7 +1251,8 @@ static void sink_get_volume_cb(pa_sink *s) { static void sink_set_volume_cb(pa_sink *s) { struct userdata *u = s->userdata; pa_cvolume r; - char t[PA_CVOLUME_SNPRINT_MAX]; + char vol_str_pcnt[PA_CVOLUME_SNPRINT_MAX]; + pa_bool_t sync_volume = !!(s->flags & PA_SINK_SYNC_VOLUME); pa_assert(u); pa_assert(u->mixer_path); @@ -1153,7 +1261,7 @@ static void sink_set_volume_cb(pa_sink *s) { /* Shift up by the 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, sync_volume, !sync_volume) < 0) return; /* Shift down by the base volume, so that 0dB becomes maximum volume */ @@ -1164,6 +1272,7 @@ static void sink_set_volume_cb(pa_sink *s) { if (u->mixer_path->has_dB) { pa_cvolume new_soft_volume; pa_bool_t accurate_enough; + char vol_str_db[PA_SW_CVOLUME_SNPRINT_DB_MAX]; /* Match exactly what the user requested by software */ pa_sw_cvolume_divide(&new_soft_volume, &s->real_volume, &u->hardware_volume); @@ -1175,16 +1284,20 @@ static void sink_set_volume_cb(pa_sink *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->real_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(vol_str_pcnt, sizeof(vol_str_pcnt), &s->real_volume)); + pa_log_debug(" in dB: %s", pa_sw_cvolume_snprint_dB(vol_str_db, sizeof(vol_str_db), &s->real_volume)); + pa_log_debug("Got hardware volume: %s", pa_cvolume_snprint(vol_str_pcnt, sizeof(vol_str_pcnt), &u->hardware_volume)); + pa_log_debug(" in dB: %s", pa_sw_cvolume_snprint_dB(vol_str_db, sizeof(vol_str_db), &u->hardware_volume)); + pa_log_debug("Calculated software volume: %s (accurate-enough=%s)", + pa_cvolume_snprint(vol_str_pcnt, sizeof(vol_str_pcnt), &new_soft_volume), pa_yes_no(accurate_enough)); + pa_log_debug(" in dB: %s", pa_sw_cvolume_snprint_dB(vol_str_db, sizeof(vol_str_db), &new_soft_volume)); 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(vol_str_pcnt, sizeof(vol_str_pcnt), &r)); /* We can't match exactly what the user requested, hence let's * at least tell the user about it */ @@ -1193,6 +1306,48 @@ static void sink_set_volume_cb(pa_sink *s) { } } +static void sink_write_volume_cb(pa_sink *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_SINK_SYNC_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; + pa_bool_t 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) { + union { + char db[2][PA_SW_CVOLUME_SNPRINT_DB_MAX]; + char pcnt[2][PA_CVOLUME_SNPRINT_MAX]; + } vol; + + pa_log_debug("Written HW volume did not match with the request: %s (request) != %s", + pa_cvolume_snprint(vol.pcnt[0], sizeof(vol.pcnt[0]), &s->thread_info.current_hw_volume), + pa_cvolume_snprint(vol.pcnt[1], sizeof(vol.pcnt[1]), &hw_vol)); + pa_log_debug(" in dB: %s (request) != %s", + pa_sw_cvolume_snprint_dB(vol.db[0], sizeof(vol.db[0]), &s->thread_info.current_hw_volume), + pa_sw_cvolume_snprint_dB(vol.db[1], sizeof(vol.db[1]), &hw_vol)); + } + } +} + static void sink_get_mute_cb(pa_sink *s) { struct userdata *u = s->userdata; pa_bool_t b; @@ -1234,10 +1389,7 @@ static int sink_set_port_cb(pa_sink *s, pa_device_port *p) { 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"); + pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(s->base_volume)); } else { s->base_volume = PA_VOLUME_NORM; s->n_volume_steps = u->mixer_path->max_volume - u->mixer_path->min_volume + 1; @@ -1258,6 +1410,9 @@ static void sink_update_requested_latency_cb(pa_sink *s) { struct userdata *u = s->userdata; size_t before; 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; @@ -1292,7 +1447,10 @@ static int process_rewind(struct userdata *u) { return -1; } - unused_nbytes = u->tsched_watermark + (size_t) unused * u->frame_size; + unused_nbytes = (size_t) unused * u->frame_size; + + /* make sure rewind doesn't go too far, can cause issues with DMAs */ + unused_nbytes += u->rewind_safeguard; if (u->hwbuf_size > unused_nbytes) limit_nbytes = u->hwbuf_size - unused_nbytes; @@ -1352,6 +1510,7 @@ static void thread_func(void *userdata) { for (;;) { int ret; + pa_usec_t rtpoll_sleep = 0; #ifdef DEBUG_TIMING pa_log_debug("Loop"); @@ -1384,6 +1543,8 @@ static void thread_func(void *userdata) { snd_pcm_start(u->pcm_handle); pa_smoother_resume(u->smoother, pa_rtclock_now(), TRUE); + + u->first = FALSE; } update_smoother(u); @@ -1402,7 +1563,7 @@ static void thread_func(void *userdata) { * we have filled the buffer at least once * completely.*/ - if (pa_log_ratelimit()) + if (pa_log_ratelimit(PA_LOG_DEBUG)) pa_log_debug("Cutting sleep time for the initial iterations by half."); sleep_usec /= 2; } @@ -1418,21 +1579,32 @@ 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); } - u->first = FALSE; u->after_rewind = FALSE; - } else if (u->use_tsched) + } + + if (u->sink->flags & PA_SINK_SYNC_VOLUME) { + pa_usec_t volume_sleep; + pa_sink_volume_change_apply(u->sink, &volume_sleep); + if (volume_sleep > 0) + rtpoll_sleep = PA_MIN(volume_sleep, rtpoll_sleep); + } - /* 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); + else pa_rtpoll_set_timer_disabled(u->rtpoll); /* Hmm, nothing to do. Let's sleep */ if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0) goto fail; + if (u->sink->flags & PA_SINK_SYNC_VOLUME) + pa_sink_volume_change_apply(u->sink, NULL); + if (ret == 0) goto finish; @@ -1455,7 +1627,7 @@ static void thread_func(void *userdata) { u->first = TRUE; u->since_start = 0; - } else if (revents && u->use_tsched && pa_log_ratelimit()) + } else if (revents && u->use_tsched && pa_log_ratelimit(PA_LOG_DEBUG)) pa_log_debug("Wakeup from ALSA!"); } else @@ -1551,7 +1723,7 @@ fail: } } -static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB) { +static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB, pa_bool_t sync_volume) { pa_assert(u); if (!u->mixer_handle) @@ -1587,9 +1759,9 @@ static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB) { return 0; } - if (!u->mixer_path->has_volume) + if (!u->mixer_path->has_volume) { pa_log_info("Driver does not support hardware volume control, falling back to software volume control."); - else { + } else { 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); @@ -1597,10 +1769,7 @@ static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB) { u->sink->base_volume = pa_sw_volume_from_dB(-u->mixer_path->max_dB); u->sink->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->sink->base_volume)); - else - pa_log_info("No particular base volume set, fixing to 0 dB"); + pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(u->sink->base_volume)); } else { pa_log_info("Hardware volume ranges from %li to %li.", u->mixer_path->min_volume, u->mixer_path->max_volume); @@ -1608,33 +1777,53 @@ static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB) { u->sink->n_volume_steps = u->mixer_path->max_volume - u->mixer_path->min_volume + 1; } - u->sink->get_volume = sink_get_volume_cb; - u->sink->set_volume = sink_set_volume_cb; + pa_sink_set_get_volume_callback(u->sink, sink_get_volume_cb); + pa_sink_set_set_volume_callback(u->sink, sink_set_volume_cb); + + if (u->mixer_path->has_dB) { + u->sink->flags |= PA_SINK_DECIBEL_VOLUME; + if (sync_volume) { + pa_sink_set_write_volume_callback(u->sink, sink_write_volume_cb); + pa_log_info("Successfully enabled synchronous volume."); + } + } - u->sink->flags |= PA_SINK_HW_VOLUME_CTRL | (u->mixer_path->has_dB ? PA_SINK_DECIBEL_VOLUME : 0); 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_log_info("Driver does not support hardware mute control, falling back to software mute control."); } else { - u->sink->get_mute = sink_get_mute_cb; - u->sink->set_mute = sink_set_mute_cb; - u->sink->flags |= PA_SINK_HW_MUTE_CTRL; + pa_sink_set_get_mute_callback(u->sink, sink_get_mute_cb); + pa_sink_set_set_mute_callback(u->sink, sink_set_mute_cb); pa_log_info("Using hardware mute control."); } - u->mixer_fdl = pa_alsa_fdlist_new(); + if (u->mixer_path->has_volume || u->mixer_path->has_mute) { + int (*mixer_callback)(snd_mixer_elem_t *, unsigned int); + if (u->sink->flags & PA_SINK_SYNC_VOLUME) { + u->mixer_pd = pa_alsa_mixer_pdata_new(); + mixer_callback = io_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_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 (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 (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 (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; } @@ -1645,10 +1834,10 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca const char *dev_id = NULL; pa_sample_spec ss, requested_ss; pa_channel_map map; - uint32_t nfrags, frag_size, buffer_size, tsched_size, tsched_watermark; + uint32_t nfrags, frag_size, buffer_size, tsched_size, tsched_watermark, rewind_safeguard; 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; + pa_bool_t use_mmap = TRUE, b, use_tsched = TRUE, d, ignore_dB = FALSE, namereg_fail = FALSE, sync_volume = FALSE; pa_sink_new_data data; pa_alsa_profile_set *profile_set = NULL; @@ -1701,6 +1890,18 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca goto fail; } + rewind_safeguard = PA_MAX(DEFAULT_REWIND_SAFEGUARD_BYTES, pa_usec_to_bytes(DEFAULT_REWIND_SAFEGUARD_USEC, &ss)); + if (pa_modargs_get_value_u32(ma, "rewind_safeguard", &rewind_safeguard) < 0) { + pa_log("Failed to parse rewind_safeguard argument"); + goto fail; + } + + sync_volume = m->core->sync_volume; + if (pa_modargs_get_value_boolean(ma, "sync_volume", &sync_volume) < 0) { + pa_log("Failed to parse sync_volume argument."); + goto fail; + } + use_tsched = pa_alsa_may_tsched(use_tsched); u = pa_xnew0(struct userdata, 1); @@ -1709,12 +1910,13 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca u->use_mmap = use_mmap; u->use_tsched = use_tsched; u->first = TRUE; + u->rewind_safeguard = rewind_safeguard; u->rtpoll = pa_rtpoll_new(); pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll); u->smoother = pa_smoother_new( - DEFAULT_TSCHED_BUFFER_USEC*2, - DEFAULT_TSCHED_BUFFER_USEC*2, + SMOOTHER_ADJUST_USEC, + SMOOTHER_WINDOW_USEC, TRUE, TRUE, 5, @@ -1749,7 +1951,6 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca SND_PCM_STREAM_PLAYBACK, &period_frames, &buffer_frames, tsched_frames, &b, &d, mapping))) - goto fail; } else if ((dev_id = pa_modargs_get_value(ma, "device_id", NULL))) { @@ -1764,7 +1965,6 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca SND_PCM_STREAM_PLAYBACK, &period_frames, &buffer_frames, tsched_frames, &b, &d, profile_set, &mapping))) - goto fail; } else { @@ -1816,6 +2016,19 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca data.module = m; data.card = card; set_sink_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 boolean argument namereg_fail."); + pa_sink_new_data_done(&data); + goto fail; + } + data.namereg_fail = namereg_fail; + pa_sink_new_data_set_sample_spec(&data, &ss); pa_sink_new_data_set_channel_map(&data, &map); @@ -1852,8 +2065,21 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca goto fail; } + if (pa_modargs_get_value_u32(ma, "sync_volume_safety_margin", + &u->sink->thread_info.volume_change_safety_margin) < 0) { + pa_log("Failed to parse sync_volume_safety_margin parameter"); + goto fail; + } + + if (pa_modargs_get_value_s32(ma, "sync_volume_extra_delay", + &u->sink->thread_info.volume_change_extra_delay) < 0) { + pa_log("Failed to parse sync_volume_extra_delay parameter"); + goto fail; + } + u->sink->parent.process_msg = sink_process_msg; - u->sink->update_requested_latency = sink_update_requested_latency_cb; + if (u->use_tsched) + u->sink->update_requested_latency = sink_update_requested_latency_cb; u->sink->set_state = sink_set_state_cb; u->sink->set_port = sink_set_port_cb; u->sink->userdata = u; @@ -1874,7 +2100,12 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca (double) pa_bytes_to_usec(u->hwbuf_size, &ss) / PA_USEC_PER_MSEC); pa_sink_set_max_request(u->sink, u->hwbuf_size); - pa_sink_set_max_rewind(u->sink, u->hwbuf_size); + if (pa_alsa_pcm_is_hw(u->pcm_handle)) + pa_sink_set_max_rewind(u->sink, u->hwbuf_size); + else { + pa_log_info("Disabling rewind for device %s", u->device_name); + pa_sink_set_max_rewind(u->sink, 0); + } if (u->use_tsched) { u->tsched_watermark = pa_usec_to_bytes_round_up(pa_bytes_to_usec_round_up(tsched_watermark, &requested_ss), &u->sink->sample_spec); @@ -1897,18 +2128,17 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca } else pa_sink_set_fixed_latency(u->sink, pa_bytes_to_usec(u->hwbuf_size, &ss)); - reserve_update(u); if (update_sw_params(u) < 0) goto fail; - if (setup_mixer(u, ignore_dB) < 0) + if (setup_mixer(u, ignore_dB, sync_volume) < 0) goto fail; pa_alsa_dump(PA_LOG_DEBUG, u->pcm_handle); - if (!(u->thread = pa_thread_new(thread_func, u))) { + if (!(u->thread = pa_thread_new("alsa-sink", thread_func, u))) { pa_log("Failed to create thread."); goto fail; } @@ -1967,6 +2197,9 @@ static void userdata_free(struct userdata *u) { if (u->memchunk.memblock) pa_memblock_unref(u->memchunk.memblock); + 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);