path: root/src/modules/alsa/alsa-sink.c

/***
  This file is part of PulseAudio.

  Copyright 2004-2008 Lennart Poettering
  Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB

  PulseAudio is free software; you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published
  by the Free Software Foundation; either version 2.1 of the License,
  or (at your option) any later version.

  PulseAudio is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with PulseAudio; if not, see <http://www.gnu.org/licenses/>.
***/

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <signal.h>
#include <stdio.h>

#include <alsa/asoundlib.h>

#ifdef HAVE_VALGRIND_MEMCHECK_H
#include <valgrind/memcheck.h>
#endif

#include <pulse/rtclock.h>
#include <pulse/timeval.h>
#include <pulse/util.h>
#include <pulse/volume.h>
#include <pulse/xmalloc.h>
#include <pulse/internal.h>

#include <pulsecore/core.h>
#include <pulsecore/i18n.h>
#include <pulsecore/module.h>
#include <pulsecore/memchunk.h>
#include <pulsecore/sink.h>
#include <pulsecore/modargs.h>
#include <pulsecore/core-rtclock.h>
#include <pulsecore/core-util.h>
#include <pulsecore/sample-util.h>
#include <pulsecore/log.h>
#include <pulsecore/macro.h>
#include <pulsecore/thread.h>
#include <pulsecore/thread-mq.h>
#include <pulsecore/rtpoll.h>
#include <pulsecore/time-smoother.h>

#include <modules/reserve-wrap.h>

#include "alsa-util.h"
#include "alsa-sink.h"

/* #define DEBUG_TIMING */

#define DEFAULT_DEVICE "default"

#define DEFAULT_TSCHED_BUFFER_USEC (2*PA_USEC_PER_SEC)             /* 2s    -- Overall buffer size */
#define DEFAULT_TSCHED_WATERMARK_USEC (20*PA_USEC_PER_MSEC)        /* 20ms  -- Fill up when only this much is left in the buffer */

#define TSCHED_WATERMARK_INC_STEP_USEC (10*PA_USEC_PER_MSEC)       /* 10ms  -- On underrun, increase watermark by this */
#define TSCHED_WATERMARK_DEC_STEP_USEC (5*PA_USEC_PER_MSEC)        /* 5ms   -- When everything's great, decrease watermark by this */
#define TSCHED_WATERMARK_VERIFY_AFTER_USEC (20*PA_USEC_PER_SEC)    /* 20s   -- How long after a drop out recheck if things are good now */
#define TSCHED_WATERMARK_INC_THRESHOLD_USEC (0*PA_USEC_PER_MSEC)   /* 0ms   -- If the buffer level ever below this threshold, increase the watermark */
#define TSCHED_WATERMARK_DEC_THRESHOLD_USEC (100*PA_USEC_PER_MSEC) /* 100ms -- If the buffer level didn't drop below this threshold in the verification time, decrease the watermark */

/* Note that TSCHED_WATERMARK_INC_THRESHOLD_USEC == 0 means that we
 * will increase the watermark only if we hit a real underrun. */

#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 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 */

#define DEFAULT_WRITE_ITERATION_THRESHOLD 0.03 /* don't iterate write if < 3% of the buffer is available */

struct userdata {
    pa_core *core;
    pa_module *module;
    pa_sink *sink;

    pa_thread *thread;
    pa_thread_mq thread_mq;
    pa_rtpoll *rtpoll;

    snd_pcm_t *pcm_handle;

    char *paths_dir;
    pa_alsa_fdlist *mixer_fdl;
    pa_alsa_mixer_pdata *mixer_pd;
    pa_hashmap *mixers;
    snd_mixer_t *mixer_handle;
    pa_alsa_path_set *mixer_path_set;
    pa_alsa_path *mixer_path;

    pa_cvolume hardware_volume;

    pa_sample_spec verified_sample_spec;
    pa_sample_format_t *supported_formats;
    unsigned int *supported_rates;
    struct {
        size_t fragment_size;
        size_t nfrags;
        size_t tsched_size;
        size_t tsched_watermark;
        size_t rewind_safeguard;
    } initial_info;

    size_t
        frame_size,
        fragment_size,
        hwbuf_size,
        tsched_size,
        tsched_watermark,
        tsched_watermark_ref,
        hwbuf_unused,
        min_sleep,
        min_wakeup,
        watermark_inc_step,
        watermark_dec_step,
        watermark_inc_threshold,
        watermark_dec_threshold,
        rewind_safeguard;

    snd_pcm_uframes_t frames_per_block;

    pa_usec_t watermark_dec_not_before;
    pa_usec_t min_latency_ref;
    pa_usec_t tsched_watermark_usec;

    pa_memchunk memchunk;

    char *device_name;  /* name of the PCM device */
    char *control_device; /* name of the control device */

    bool use_mmap:1, use_tsched:1, deferred_volume:1, fixed_latency_range:1;

    bool first, after_rewind;

    pa_rtpoll_item *alsa_rtpoll_item;

    pa_smoother *smoother;
    uint64_t write_count;
    uint64_t since_start;
    pa_usec_t smoother_interval;
    pa_usec_t last_smoother_update;

    pa_idxset *formats;

    pa_reserve_wrapper *reserve;
    pa_hook_slot *reserve_slot;
    pa_reserve_monitor_wrapper *monitor;
    pa_hook_slot *monitor_slot;

    /* ucm context */
    pa_alsa_ucm_mapping_context *ucm_context;
};

enum {
    SINK_MESSAGE_SYNC_MIXER = PA_SINK_MESSAGE_MAX
};

static void userdata_free(struct userdata *u);
static int unsuspend(struct userdata *u, bool recovering);

/* FIXME: Is there a better way to do this than device names? */
static bool is_iec958(struct userdata *u) {
    return (strncmp("iec958", u->device_name, 6) == 0);
}

static bool is_hdmi(struct userdata *u) {
    return (strncmp("hdmi", u->device_name, 4) == 0);
}

static pa_hook_result_t reserve_cb(pa_reserve_wrapper *r, void *forced, struct userdata *u) {
    pa_assert(r);
    pa_assert(u);

    pa_log_debug("Suspending sink %s, because another application requested us to release the device.", u->sink->name);

    if (pa_sink_suspend(u->sink, true, PA_SUSPEND_APPLICATION) < 0)
        return PA_HOOK_CANCEL;

    return PA_HOOK_OK;
}

static void reserve_done(struct userdata *u) {
    pa_assert(u);

    if (u->reserve_slot) {
        pa_hook_slot_free(u->reserve_slot);
        u->reserve_slot = NULL;
    }

    if (u->reserve) {
        pa_reserve_wrapper_unref(u->reserve);
        u->reserve = NULL;
    }
}

static void reserve_update(struct userdata *u) {
    const char *description;
    pa_assert(u);

    if (!u->sink || !u->reserve)
        return;

    if ((description = pa_proplist_gets(u->sink->proplist, PA_PROP_DEVICE_DESCRIPTION)))
        pa_reserve_wrapper_set_application_device_name(u->reserve, description);
}

static int reserve_init(struct userdata *u, const char *dname) {
    char *rname;

    pa_assert(u);
    pa_assert(dname);

    if (u->reserve)
        return 0;

    if (pa_in_system_mode())
        return 0;

    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);

    if (!(u->reserve))
        return -1;

    reserve_update(u);

    pa_assert(!u->reserve_slot);
    u->reserve_slot = pa_hook_connect(pa_reserve_wrapper_hook(u->reserve), PA_HOOK_NORMAL, (pa_hook_cb_t) reserve_cb, u);

    return 0;
}

static pa_hook_result_t monitor_cb(pa_reserve_monitor_wrapper *w, void* busy, struct userdata *u) {
    pa_assert(w);
    pa_assert(u);

    if (PA_PTR_TO_UINT(busy) && !u->reserve) {
        pa_log_debug("Suspending sink %s, because another application is blocking the access to the device.", u->sink->name);
        pa_sink_suspend(u->sink, true, PA_SUSPEND_APPLICATION);
    } else {
        pa_log_debug("Resuming sink %s, because other applications aren't blocking access to the device any more.", u->sink->name);
        pa_sink_suspend(u->sink, false, PA_SUSPEND_APPLICATION);
    }

    return PA_HOOK_OK;
}

static void monitor_done(struct userdata *u) {
    pa_assert(u);

    if (u->monitor_slot) {
        pa_hook_slot_free(u->monitor_slot);
        u->monitor_slot = NULL;
    }

    if (u->monitor) {
        pa_reserve_monitor_wrapper_unref(u->monitor);
        u->monitor = NULL;
    }
}

static int reserve_monitor_init(struct userdata *u, const char *dname) {
    char *rname;

    pa_assert(u);
    pa_assert(dname);

    if (pa_in_system_mode())
        return 0;

    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);

    if (!(u->monitor))
        return -1;

    pa_assert(!u->monitor_slot);
    u->monitor_slot = pa_hook_connect(pa_reserve_monitor_wrapper_hook(u->monitor), PA_HOOK_NORMAL, (pa_hook_cb_t) monitor_cb, u);

    return 0;
}

static void fix_min_sleep_wakeup(struct userdata *u) {
    size_t max_use, max_use_2;

    pa_assert(u);
    pa_assert(u->use_tsched);

    max_use = u->hwbuf_size - u->hwbuf_unused;
    max_use_2 = pa_frame_align(max_use/2, &u->sink->sample_spec);

    u->min_sleep = pa_usec_to_bytes(TSCHED_MIN_SLEEP_USEC, &u->sink->sample_spec);
    u->min_sleep = PA_CLAMP(u->min_sleep, u->frame_size, max_use_2);

    u->min_wakeup = pa_usec_to_bytes(TSCHED_MIN_WAKEUP_USEC, &u->sink->sample_spec);
    u->min_wakeup = PA_CLAMP(u->min_wakeup, u->frame_size, max_use_2);
}

static void fix_tsched_watermark(struct userdata *u) {
    size_t max_use;
    pa_assert(u);
    pa_assert(u->use_tsched);

    max_use = u->hwbuf_size - u->hwbuf_unused;

    if (u->tsched_watermark > max_use - u->min_sleep)
        u->tsched_watermark = max_use - u->min_sleep;

    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->sink->sample_spec);
}

static void increase_watermark(struct userdata *u) {
    size_t old_watermark;
    pa_usec_t old_min_latency, new_min_latency;

    pa_assert(u);
    pa_assert(u->use_tsched);

    /* First, just try to increase the watermark */
    old_watermark = u->tsched_watermark;
    u->tsched_watermark = PA_MIN(u->tsched_watermark * 2, u->tsched_watermark + u->watermark_inc_step);
    fix_tsched_watermark(u);

    if (old_watermark != u->tsched_watermark) {
        pa_log_info("Increasing wakeup watermark to %0.2f ms",
                    (double) u->tsched_watermark_usec / PA_USEC_PER_MSEC);
        return;
    }

    /* 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->sink->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->sink->thread_info.max_latency);

    if (old_min_latency != new_min_latency) {
        pa_log_info("Increasing minimal latency to %0.2f ms",
                    (double) new_min_latency / PA_USEC_PER_MSEC);

        pa_sink_set_latency_range_within_thread(u->sink, new_min_latency, u->sink->thread_info.max_latency);
    }

    /* When we reach this we're officially fucked! */
}

static void decrease_watermark(struct userdata *u) {
    size_t old_watermark;
    pa_usec_t now;

    pa_assert(u);
    pa_assert(u->use_tsched);

    now = pa_rtclock_now();

    if (u->watermark_dec_not_before <= 0)
        goto restart;

    if (u->watermark_dec_not_before > now)
        return;

    old_watermark = u->tsched_watermark;

    if (u->tsched_watermark < u->watermark_dec_step)
        u->tsched_watermark = u->tsched_watermark / 2;
    else
        u->tsched_watermark = PA_MAX(u->tsched_watermark / 2, u->tsched_watermark - u->watermark_dec_step);

    fix_tsched_watermark(u);

    if (old_watermark != u->tsched_watermark)
        pa_log_info("Decreasing wakeup watermark to %0.2f ms",
                    (double) u->tsched_watermark_usec / PA_USEC_PER_MSEC);

    /* We don't change the latency range*/

restart:
    u->watermark_dec_not_before = now + TSCHED_WATERMARK_VERIFY_AFTER_USEC;
}

/* Called from IO Context on unsuspend or from main thread when creating sink */
static void reset_watermark(struct userdata *u, size_t tsched_watermark, pa_sample_spec *ss,
                            bool in_thread) {
    u->tsched_watermark = pa_convert_size(tsched_watermark, ss, &u->sink->sample_spec);

    u->watermark_inc_step = pa_usec_to_bytes(TSCHED_WATERMARK_INC_STEP_USEC, &u->sink->sample_spec);
    u->watermark_dec_step = pa_usec_to_bytes(TSCHED_WATERMARK_DEC_STEP_USEC, &u->sink->sample_spec);

    u->watermark_inc_threshold = pa_usec_to_bytes_round_up(TSCHED_WATERMARK_INC_THRESHOLD_USEC, &u->sink->sample_spec);
    u->watermark_dec_threshold = pa_usec_to_bytes_round_up(TSCHED_WATERMARK_DEC_THRESHOLD_USEC, &u->sink->sample_spec);

    fix_min_sleep_wakeup(u);
    fix_tsched_watermark(u);

    if (in_thread)
        pa_sink_set_latency_range_within_thread(u->sink,
                                                u->min_latency_ref,
                                                pa_bytes_to_usec(u->hwbuf_size, ss));
    else {
        pa_sink_set_latency_range(u->sink,
                                  0,
                                  pa_bytes_to_usec(u->hwbuf_size, ss));

        /* work-around assert in pa_sink_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->sink->thread_info.min_latency;
    }

    pa_log_info("Time scheduling watermark is %0.2fms",
                (double) u->tsched_watermark_usec / PA_USEC_PER_MSEC);
}

static void hw_sleep_time(struct userdata *u, pa_usec_t *sleep_usec, pa_usec_t*process_usec) {
    pa_usec_t usec, wm;

    pa_assert(sleep_usec);
    pa_assert(process_usec);

    pa_assert(u);
    pa_assert(u->use_tsched);

    usec = pa_sink_get_requested_latency_within_thread(u->sink);

    if (usec == (pa_usec_t) -1)
        usec = pa_bytes_to_usec(u->hwbuf_size, &u->sink->sample_spec);

    wm = u->tsched_watermark_usec;

    if (wm > usec)
        wm = usec/2;

    *sleep_usec = usec - wm;
    *process_usec = wm;

#ifdef DEBUG_TIMING
    pa_log_debug("Buffer time: %lu ms; Sleep time: %lu ms; Process time: %lu ms",
                 (unsigned long) (usec / PA_USEC_PER_MSEC),
                 (unsigned long) (*sleep_usec / PA_USEC_PER_MSEC),
                 (unsigned long) (*process_usec / PA_USEC_PER_MSEC));
#endif
}

/* Reset smoother and counters */
static void reset_vars(struct userdata *u) {

    pa_smoother_reset(u->smoother, pa_rtclock_now(), true);
    u->smoother_interval = SMOOTHER_MIN_INTERVAL;
    u->last_smoother_update = 0;

    u->first = true;
    u->since_start = 0;
    u->write_count = 0;
}

/* Called from IO context */
static void close_pcm(struct userdata *u) {
    /* Let's suspend -- we don't call snd_pcm_drain() here since that might
     * take awfully long with our long buffer sizes today. */
    snd_pcm_close(u->pcm_handle);
    u->pcm_handle = NULL;

    if (u->alsa_rtpoll_item) {
        pa_rtpoll_item_free(u->alsa_rtpoll_item);
        u->alsa_rtpoll_item = NULL;
    }
}

static int try_recover(struct userdata *u, const char *call, int err) {
    pa_assert(u);
    pa_assert(call);
    pa_assert(err < 0);

    pa_log_debug("%s: %s", call, pa_alsa_strerror(err));

    pa_assert(err != -EAGAIN);

    if (err == -EPIPE)
        pa_log_debug("%s: Buffer underrun!", call);

    if (err == -ESTRPIPE)
        pa_log_debug("%s: System suspended!", call);

    if ((err = snd_pcm_recover(u->pcm_handle, err, 1)) < 0) {
        pa_log("%s: %s, trying to restart PCM", call, pa_alsa_strerror(err));

        /* As a last measure, restart the PCM and inform the caller about it. */
        close_pcm(u);
        if (unsuspend(u, true) < 0)
            return -1;

        return 1;
    }

    reset_vars(u);
    return 0;
}

static size_t check_left_to_play(struct userdata *u, size_t n_bytes, bool on_timeout) {
    size_t left_to_play;
    bool underrun = false;

    /* We use <= instead of < for this check here because an underrun
     * only happens after the last sample was processed, not already when
     * it is removed from the buffer. This is particularly important
     * when block transfer is used. */

    if (n_bytes <= u->hwbuf_size)
        left_to_play = u->hwbuf_size - n_bytes;
    else {

        /* We got a dropout. What a mess! */
        left_to_play = 0;
        underrun = true;

#if 0
        PA_DEBUG_TRAP;
#endif

        if (!u->first && !u->after_rewind)
            if (pa_log_ratelimit(PA_LOG_INFO))
                pa_log_info("Underrun!");
    }

#ifdef DEBUG_TIMING
    pa_log_debug("%0.2f ms left to play; inc threshold = %0.2f ms; dec threshold = %0.2f ms",
                 (double) pa_bytes_to_usec(left_to_play, &u->sink->sample_spec) / PA_USEC_PER_MSEC,
                 (double) pa_bytes_to_usec(u->watermark_inc_threshold, &u->sink->sample_spec) / PA_USEC_PER_MSEC,
                 (double) pa_bytes_to_usec(u->watermark_dec_threshold, &u->sink->sample_spec) / PA_USEC_PER_MSEC);
#endif

    if (u->use_tsched) {
        bool reset_not_before = true;

        if (!u->first && !u->after_rewind) {
            if (underrun || left_to_play < u->watermark_inc_threshold)
                increase_watermark(u);
            else if (left_to_play > u->watermark_dec_threshold) {
                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... */

                if (on_timeout)
                    decrease_watermark(u);
            }
        }

        if (reset_not_before)
            u->watermark_dec_not_before = 0;
    }

    return left_to_play;
}

static int mmap_write(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_play, input_underrun;
    unsigned j = 0;

    pa_assert(u);
    pa_sink_assert_ref(u->sink);

    if (u->use_tsched)
        hw_sleep_time(u, &max_sleep_usec, &process_usec);

    for (;;) {
        snd_pcm_sframes_t n;
        size_t n_bytes;
        int r;
        bool after_avail = true;

        /* First we determine how many samples are missing to fill the
         * buffer up to 100% */

        if (PA_UNLIKELY((n = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->sink->sample_spec)) < 0)) {

            if ((r = try_recover(u, "snd_pcm_avail", (int) n)) >= 0)
                continue;

            return r;
        }

        n_bytes = (size_t) n * u->frame_size;

#ifdef DEBUG_TIMING
        pa_log_debug("avail: %lu", (unsigned long) n_bytes);
#endif

        left_to_play = check_left_to_play(u, n_bytes, on_timeout);
        on_timeout = false;

        if (u->use_tsched)

            /* We won't fill up the playback buffer before at least
            * half the sleep time is over because otherwise we might
            * ask for more data from the clients then they expect. We
            * need to guarantee that clients only have to keep around
            * a single hw buffer length. */

            if (!polled &&
                pa_bytes_to_usec(left_to_play, &u->sink->sample_spec) > process_usec+max_sleep_usec/2) {
#ifdef DEBUG_TIMING
                pa_log_debug("Not filling up, because too early.");
#endif
                break;
            }

        if (PA_UNLIKELY(n_bytes <= u->hwbuf_unused)) {

            if (polled)
                PA_ONCE_BEGIN {
                    char *dn = pa_alsa_get_driver_name_by_pcm(u->pcm_handle);
                    pa_log(_("ALSA woke us up to write new data to the device, but there was actually nothing to write.\n"
                             "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers.\n"
                             "We were woken up with POLLOUT set -- however a subsequent snd_pcm_avail() returned 0 or another value < min_avail."),
                           pa_strnull(dn));
                    pa_xfree(dn);
                } PA_ONCE_END;

#ifdef DEBUG_TIMING
            pa_log_debug("Not filling up, because not necessary.");
#endif
            break;
        }

        j++;

        if (j > 10) {
#ifdef DEBUG_TIMING
            pa_log_debug("Not filling up, because already too many iterations.");
#endif

            break;
        } else if (j >= 2 && (n_bytes < (DEFAULT_WRITE_ITERATION_THRESHOLD * (u->hwbuf_size - u->hwbuf_unused)))) {
#ifdef DEBUG_TIMING
            pa_log_debug("Not filling up, because <%g%% available.", DEFAULT_WRITE_ITERATION_THRESHOLD * 100);
#endif
            break;
        }

        n_bytes -= u->hwbuf_unused;
        polled = false;

#ifdef DEBUG_TIMING
        pa_log_debug("Filling up");
#endif

        for (;;) {
            pa_memchunk chunk;
            void *p;
            int err;
            const snd_pcm_channel_area_t *areas;
            snd_pcm_uframes_t offset, frames;
            snd_pcm_sframes_t sframes;
            size_t written;

            frames = (snd_pcm_uframes_t) (n_bytes / u->frame_size);
/*             pa_log_debug("%lu frames to write", (unsigned long) frames); */

            if (PA_UNLIKELY((err = pa_alsa_safe_mmap_begin(u->pcm_handle, &areas, &offset, &frames, u->hwbuf_size, &u->sink->sample_spec)) < 0)) {

                if (!after_avail && err == -EAGAIN)
                    break;

                if ((r = try_recover(u, "snd_pcm_mmap_begin", err)) == 0)
                    continue;

                if (r == 1)
                    break;

                return r;
            }

            /* Make sure that if these memblocks need to be copied they will fit into one slot */
            frames = PA_MIN(frames, u->frames_per_block);

            if (!after_avail && frames == 0)
                break;

            pa_assert(frames > 0);
            after_avail = false;

            /* Check these are multiples of 8 bit */
            pa_assert((areas[0].first & 7) == 0);
            pa_assert((areas[0].step & 7) == 0);

            /* We assume a single interleaved memory buffer */
            pa_assert((areas[0].first >> 3) == 0);
            pa_assert((areas[0].step >> 3) == u->frame_size);

            p = (uint8_t*) areas[0].addr + (offset * u->frame_size);

            written = frames * u->frame_size;
            chunk.memblock = pa_memblock_new_fixed(u->core->mempool, p, written, true);
            chunk.length = pa_memblock_get_length(chunk.memblock);
            chunk.index = 0;

            pa_sink_render_into_full(u->sink, &chunk);
            pa_memblock_unref_fixed(chunk.memblock);

            if (PA_UNLIKELY((sframes = snd_pcm_mmap_commit(u->pcm_handle, offset, frames)) < 0)) {

                if ((int) sframes == -EAGAIN)
                    break;

                if ((r = try_recover(u, "snd_pcm_mmap_commit", (int) sframes)) == 0)
                    continue;

                if (r == 1)
                    break;

                return r;
            }

            work_done = true;

            u->write_count += written;
            u->since_start += written;

#ifdef DEBUG_TIMING
            pa_log_debug("Wrote %lu bytes (of possible %lu bytes)", (unsigned long) written, (unsigned long) n_bytes);
#endif

            if (written >= n_bytes)
                break;

            n_bytes -= written;
        }
    }

    input_underrun = pa_sink_process_input_underruns(u->sink, left_to_play);

    if (u->use_tsched) {
        pa_usec_t underrun_sleep = pa_bytes_to_usec_round_up(input_underrun, &u->sink->sample_spec);

        *sleep_usec = pa_bytes_to_usec(left_to_play, &u->sink->sample_spec);
        process_usec = u->tsched_watermark_usec;

        if (*sleep_usec > process_usec)
            *sleep_usec -= process_usec;
        else
            *sleep_usec = 0;

        *sleep_usec = PA_MIN(*sleep_usec, underrun_sleep);
    } else
        *sleep_usec = 0;

    return work_done ? 1 : 0;
}

static int unix_write(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_play, input_underrun;
    unsigned j = 0;

    pa_assert(u);
    pa_sink_assert_ref(u->sink);

    if (u->use_tsched)
        hw_sleep_time(u, &max_sleep_usec, &process_usec);

    for (;;) {
        snd_pcm_sframes_t n;
        size_t n_bytes;
        int r;
        bool after_avail = true;

        if (PA_UNLIKELY((n = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->sink->sample_spec)) < 0)) {

            if ((r = try_recover(u, "snd_pcm_avail", (int) n)) >= 0)
                continue;

            return r;
        }

        n_bytes = (size_t) n * u->frame_size;

#ifdef DEBUG_TIMING
        pa_log_debug("avail: %lu", (unsigned long) n_bytes);
#endif

        left_to_play = check_left_to_play(u, n_bytes, on_timeout);
        on_timeout = false;

        if (u->use_tsched)

            /* We won't fill up the playback buffer before at least
            * half the sleep time is over because otherwise we might
            * ask for more data from the clients then they expect. We
            * need to guarantee that clients only have to keep around
            * a single hw buffer length. */

            if (!polled &&
                pa_bytes_to_usec(left_to_play, &u->sink->sample_spec) > process_usec+max_sleep_usec/2)
                break;

        if (PA_UNLIKELY(n_bytes <= u->hwbuf_unused)) {

            if (polled)
                PA_ONCE_BEGIN {
                    char *dn = pa_alsa_get_driver_name_by_pcm(u->pcm_handle);
                    pa_log(_("ALSA woke us up to write new data to the device, but there was actually nothing to write.\n"
                             "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers.\n"
                             "We were woken up with POLLOUT set -- however a subsequent snd_pcm_avail() returned 0 or another value < min_avail."),
                           pa_strnull(dn));
                    pa_xfree(dn);
                } PA_ONCE_END;

            break;
        }

        j++;

        if (j > 10) {
#ifdef DEBUG_TIMING
            pa_log_debug("Not filling up, because already too many iterations.");
#endif

            break;
        } else if (j >= 2 && (n_bytes < (DEFAULT_WRITE_ITERATION_THRESHOLD * (u->hwbuf_size - u->hwbuf_unused)))) {
#ifdef DEBUG_TIMING
            pa_log_debug("Not filling up, because <%g%% available.", DEFAULT_WRITE_ITERATION_THRESHOLD * 100);
#endif
            break;
        }

        n_bytes -= u->hwbuf_unused;
        polled = false;

        for (;;) {
            snd_pcm_sframes_t frames;
            void *p;
            size_t written;

/*         pa_log_debug("%lu frames to write", (unsigned long) frames); */

            if (u->memchunk.length <= 0)
                pa_sink_render(u->sink, n_bytes, &u->memchunk);

            pa_assert(u->memchunk.length > 0);

            frames = (snd_pcm_sframes_t) (u->memchunk.length / u->frame_size);

            if (frames > (snd_pcm_sframes_t) (n_bytes/u->frame_size))
                frames = (snd_pcm_sframes_t) (n_bytes/u->frame_size);

            p = pa_memblock_acquire(u->memchunk.memblock);
            frames = snd_pcm_writei(u->pcm_handle, (const uint8_t*) p + u->memchunk.index, (snd_pcm_uframes_t) frames);
            pa_memblock_release(u->memchunk.memblock);

            if (PA_UNLIKELY(frames < 0)) {

                if (!after_avail && (int) frames == -EAGAIN)
                    break;

                if ((r = try_recover(u, "snd_pcm_writei", (int) frames)) == 0)
                    continue;

                if (r == 1)
                    break;

                return r;
            }

            if (!after_avail && frames == 0)
                break;

            pa_assert(frames > 0);
            after_avail = false;

            written = frames * u->frame_size;
            u->memchunk.index += written;
            u->memchunk.length -= written;

            if (u->memchunk.length <= 0) {
                pa_memblock_unref(u->memchunk.memblock);
                pa_memchunk_reset(&u->memchunk);
            }

            work_done = true;

            u->write_count += written;
            u->since_start += written;

/*         pa_log_debug("wrote %lu frames", (unsigned long) frames); */

            if (written >= n_bytes)
                break;

            n_bytes -= written;
        }
    }

    input_underrun = pa_sink_process_input_underruns(u->sink, left_to_play);

    if (u->use_tsched) {
        pa_usec_t underrun_sleep = pa_bytes_to_usec_round_up(input_underrun, &u->sink->sample_spec);

        *sleep_usec = pa_bytes_to_usec(left_to_play, &u->sink->sample_spec);
        process_usec = u->tsched_watermark_usec;

        if (*sleep_usec > process_usec)
            *sleep_usec -= process_usec;
        else
            *sleep_usec = 0;

        *sleep_usec = PA_MIN(*sleep_usec, underrun_sleep);
    } else
        *sleep_usec = 0;

    return work_done ? 1 : 0;
}

static void update_smoother(struct userdata *u) {
    snd_pcm_sframes_t delay = 0;
    int64_t position;
    int err;
    pa_usec_t now1 = 0, now2;
    snd_pcm_status_t *status;
    snd_htimestamp_t htstamp = { 0, 0 };

    snd_pcm_status_alloca(&status);

    pa_assert(u);
    pa_assert(u->pcm_handle);

    /* Let's update the time smoother */

    if (PA_UNLIKELY((err = pa_alsa_safe_delay(u->pcm_handle, status, &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;
    }

    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)
        now1 = pa_rtclock_now();

    /* check if the time since the last update is bigger than the interval */
    if (u->last_smoother_update > 0)
        if (u->last_smoother_update + u->smoother_interval > now1)
            return;

    position = (int64_t) u->write_count - ((int64_t) delay * (int64_t) u->frame_size);

    if (PA_UNLIKELY(position < 0))
        position = 0;

    now2 = pa_bytes_to_usec((uint64_t) position, &u->sink->sample_spec);

    pa_smoother_put(u->smoother, now1, now2);

    u->last_smoother_update = now1;
    /* exponentially increase the update interval up to the MAX limit */
    u->smoother_interval = PA_MIN (u->smoother_interval * 2, SMOOTHER_MAX_INTERVAL);
}

static int64_t sink_get_latency(struct userdata *u) {
    int64_t delay;
    pa_usec_t now1, now2;

    pa_assert(u);

    now1 = pa_rtclock_now();
    now2 = pa_smoother_get(u->smoother, now1);

    delay = (int64_t) pa_bytes_to_usec(u->write_count, &u->sink->sample_spec) - (int64_t) now2;

    if (u->memchunk.memblock)
        delay += pa_bytes_to_usec(u->memchunk.length, &u->sink->sample_spec);

    return delay;
}

static int build_pollfd(struct userdata *u) {
    pa_assert(u);
    pa_assert(u->pcm_handle);

    if (u->alsa_rtpoll_item)
        pa_rtpoll_item_free(u->alsa_rtpoll_item);

    if (!(u->alsa_rtpoll_item = pa_alsa_build_pollfd(u->pcm_handle, u->rtpoll)))
        return -1;

    return 0;
}

/* Called from IO context */
static void suspend(struct userdata *u) {
    pa_assert(u);

    /* Handle may have been invalidated due to a device failure.
     * In that case there is nothing to do. */
    if (!u->pcm_handle)
        return;

    pa_smoother_pause(u->smoother, pa_rtclock_now());

    /* Close PCM device */
    close_pcm(u);

    /* 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...");
}

/* Called from IO context */
static int update_sw_params(struct userdata *u, bool may_need_rewind) {
    size_t old_unused;
    snd_pcm_uframes_t avail_min;
    int err;

    pa_assert(u);

    /* Use the full buffer if no one asked us for anything specific */
    old_unused = u->hwbuf_unused;
    u->hwbuf_unused = 0;

    if (u->use_tsched) {
        pa_usec_t latency;

        if ((latency = pa_sink_get_requested_latency_within_thread(u->sink)) != (pa_usec_t) -1) {
            size_t b;

            pa_log_debug("Latency set to %0.2fms", (double) latency / PA_USEC_PER_MSEC);

            b = pa_usec_to_bytes(latency, &u->sink->sample_spec);

            /* We need at least one sample in our buffer */

            if (PA_UNLIKELY(b < u->frame_size))
                b = u->frame_size;

            u->hwbuf_unused = PA_LIKELY(b < u->hwbuf_size) ? (u->hwbuf_size - b) : 0;
        }

        fix_min_sleep_wakeup(u);
        fix_tsched_watermark(u);
    }

    pa_log_debug("hwbuf_unused=%lu", (unsigned long) u->hwbuf_unused);

    /* We need at last one frame in the used part of the buffer */
    avail_min = (snd_pcm_uframes_t) u->hwbuf_unused / u->frame_size + 1;

    if (u->use_tsched) {
        pa_usec_t sleep_usec, process_usec;

        hw_sleep_time(u, &sleep_usec, &process_usec);
        avail_min += pa_usec_to_bytes(sleep_usec, &u->sink->sample_spec) / u->frame_size;
    }

    pa_log_debug("setting avail_min=%lu", (unsigned long) avail_min);

    if ((err = pa_alsa_set_sw_params(u->pcm_handle, avail_min, !u->use_tsched)) < 0) {
        pa_log("Failed to set software parameters: %s", pa_alsa_strerror(err));
        return err;
    }

    /* If we're lowering the latency, we need to do a rewind, because otherwise
     * we might end up in a situation where the hw buffer contains more data
     * than the new configured latency. The rewind has to be requested before
     * updating max_rewind, because the rewind amount is limited to max_rewind.
     *
     * If may_need_rewind is false, it means that we're just starting playback,
     * and rewinding is never needed in that situation. */
    if (may_need_rewind && u->hwbuf_unused > old_unused) {
        pa_log_debug("Requesting rewind due to latency change.");
        pa_sink_request_rewind(u->sink, (size_t) -1);
    }

    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 - u->hwbuf_unused);
    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;
}

/* Called from IO Context on unsuspend */
static void update_size(struct userdata *u, pa_sample_spec *ss) {
    pa_assert(u);
    pa_assert(ss);

    u->frame_size = pa_frame_size(ss);
    u->frames_per_block = pa_mempool_block_size_max(u->core->mempool) / u->frame_size;

    /* use initial values including module arguments */
    u->fragment_size = u->initial_info.fragment_size;
    u->hwbuf_size = u->initial_info.nfrags * u->fragment_size;
    u->tsched_size = u->initial_info.tsched_size;
    u->tsched_watermark = u->initial_info.tsched_watermark;
    u->rewind_safeguard = u->initial_info.rewind_safeguard;

    u->tsched_watermark_ref = u->tsched_watermark;

    pa_log_info("Updated frame_size %zu, frames_per_block %lu, fragment_size %zu, hwbuf_size %zu, tsched(size %zu, watermark %zu), rewind_safeguard %zu",
                u->frame_size, (unsigned long) u->frames_per_block, u->fragment_size, u->hwbuf_size, u->tsched_size, u->tsched_watermark, u->rewind_safeguard);
}

/* Called from IO context */
static int unsuspend(struct userdata *u, bool recovering) {
    pa_sample_spec ss;
    int err, i;
    bool b, d;
    snd_pcm_uframes_t period_frames, buffer_frames;
    snd_pcm_uframes_t tsched_frames = 0;
    char *device_name = NULL;
    bool frame_size_changed = false;

    pa_assert(u);
    pa_assert(!u->pcm_handle);

    pa_log_info("Trying resume...");

    if ((is_iec958(u) || is_hdmi(u)) && pa_sink_is_passthrough(u->sink)) {
        /* Need to open device in NONAUDIO mode */
        int len = strlen(u->device_name) + 8;

        device_name = pa_xmalloc(len);
        pa_snprintf(device_name, len, "%s,AES0=6", u->device_name);
    }

    /*
     * On some machines, during the system suspend and resume, the thread_func could receive
     * POLLERR events before the dev nodes in /dev/snd/ are accessible, and thread_func calls
     * the unsuspend() to try to recover the PCM, this will make the snd_pcm_open() fail, here
     * we add msleep and retry to make sure those nodes are accessible.
     */
    for (i = 0; i < 4; i++) {
	if ((err = snd_pcm_open(&u->pcm_handle, device_name ? device_name : u->device_name, SND_PCM_STREAM_PLAYBACK,
				SND_PCM_NONBLOCK|
				SND_PCM_NO_AUTO_RESAMPLE|
				SND_PCM_NO_AUTO_CHANNELS|
				SND_PCM_NO_AUTO_FORMAT)) < 0 && recovering)
	    pa_msleep(25);
	else
	    break;
    }

    if (err < 0) {
	pa_log("Error opening PCM device %s: %s", u->device_name, pa_alsa_strerror(err));
	goto fail;
    }

    if (pa_frame_size(&u->sink->sample_spec) != u->frame_size) {
        update_size(u, &u->sink->sample_spec);
        tsched_frames = u->tsched_size / u->frame_size;
        frame_size_changed = true;
    }

    ss = u->sink->sample_spec;
    period_frames = u->fragment_size / u->frame_size;
    buffer_frames = u->hwbuf_size / u->frame_size;
    b = u->use_mmap;
    d = u->use_tsched;

    if ((err = pa_alsa_set_hw_params(u->pcm_handle, &ss, &period_frames, &buffer_frames, tsched_frames, &b, &d, true)) < 0) {
        pa_log("Failed to set hardware parameters: %s", pa_alsa_strerror(err));
        goto fail;
    }

    if (b != u->use_mmap || d != u->use_tsched) {
        pa_log_warn("Resume failed, couldn't get original access mode.");
        goto fail;
    }

    if (!pa_sample_spec_equal(&ss, &u->sink->sample_spec)) {
        pa_log_warn("Resume failed, couldn't restore original sample settings.");
        goto fail;
    }

    if (frame_size_changed) {
        u->fragment_size = (size_t)(period_frames * u->frame_size);
        u->hwbuf_size = (size_t)(buffer_frames * u->frame_size);
        pa_proplist_setf(u->sink->proplist, PA_PROP_DEVICE_BUFFERING_BUFFER_SIZE, "%zu", u->hwbuf_size);
        pa_proplist_setf(u->sink->proplist, PA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZE, "%zu", u->fragment_size);

    } else if (period_frames * u->frame_size != u->fragment_size ||
                buffer_frames * u->frame_size != u->hwbuf_size) {
        pa_log_warn("Resume failed, couldn't restore original fragment settings. (Old: %zu/%zu, New %lu/%lu)",
                    u->hwbuf_size, u->fragment_size,
                    (unsigned long) buffer_frames * u->frame_size, (unsigned long) period_frames * u->frame_size);
        goto fail;
    }

    if (update_sw_params(u, false) < 0)
        goto fail;

    if (build_pollfd(u) < 0)
        goto fail;

    reset_vars(u);

    /* reset the watermark to the value defined when sink was created */
    if (u->use_tsched && !recovering)
        reset_watermark(u, u->tsched_watermark_ref, &u->sink->sample_spec, true);

    pa_log_info("Resumed successfully...");

    pa_xfree(device_name);
    return 0;

fail:
    if (u->pcm_handle) {
        snd_pcm_close(u->pcm_handle);
        u->pcm_handle = NULL;
    }

    pa_xfree(device_name);

    return -PA_ERR_IO;
}

/* Called from the IO thread or the main thread depending on whether deferred
 * volume is enabled or not (with deferred volume all mixer handling is done
 * from the IO thread).
 *
 * Sets the mixer settings to match the current sink and port state (the port
 * is given as an argument, because active_port may still point to the old
 * port, if we're switching ports). */
static void sync_mixer(struct userdata *u, pa_device_port *port) {
    pa_alsa_setting *setting = NULL;

    pa_assert(u);

    if (!u->mixer_path)
        return;

    /* port may be NULL, because if we use a synthesized mixer path, then the
     * sink has no ports. */
    if (port && !u->ucm_context) {
        pa_alsa_port_data *data;

        data = PA_DEVICE_PORT_DATA(port);
        setting = data->setting;
    }

    pa_alsa_path_select(u->mixer_path, setting, u->mixer_handle, u->sink->muted);

    if (u->sink->set_mute)
        u->sink->set_mute(u->sink);
    if (u->sink->flags & PA_SINK_DEFERRED_VOLUME) {
        if (u->sink->write_volume)
            u->sink->write_volume(u->sink);
    } else {
        if (u->sink->set_volume)
            u->sink->set_volume(u->sink);
    }
}

/* Called from IO context */
static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
    struct userdata *u = PA_SINK(o)->userdata;

    switch (code) {

        case PA_SINK_MESSAGE_GET_LATENCY: {
            int64_t r = 0;

            if (u->pcm_handle)
                r = sink_get_latency(u);

            *((int64_t*) data) = r;

            return 0;
        }

        case SINK_MESSAGE_SYNC_MIXER: {
            pa_device_port *port = data;

            sync_mixer(u, port);
            return 0;
        }
    }

    return pa_sink_process_msg(o, code, data, offset, chunk);
}

/* Called from main context */
static int sink_set_state_in_main_thread_cb(pa_sink *s, pa_sink_state_t new_state, pa_suspend_cause_t new_suspend_cause) {
    pa_sink_state_t old_state;
    struct userdata *u;

    pa_sink_assert_ref(s);
    pa_assert_se(u = s->userdata);

    /* When our session becomes active, we need to sync the mixer, because
     * another user may have changed the mixer settings.
     *
     * If deferred volume is enabled, the syncing is done in the
     * set_state_in_io_thread() callback instead. */
    if (!(s->flags & PA_SINK_DEFERRED_VOLUME)
            && (s->suspend_cause & PA_SUSPEND_SESSION)
            && !(new_suspend_cause & PA_SUSPEND_SESSION))
        sync_mixer(u, s->active_port);

    old_state = u->sink->state;

    if (PA_SINK_IS_OPENED(old_state) && new_state == PA_SINK_SUSPENDED)
        reserve_done(u);
    else if (old_state == PA_SINK_SUSPENDED && PA_SINK_IS_OPENED(new_state))
        if (reserve_init(u, u->device_name) < 0)
            return -PA_ERR_BUSY;

    return 0;
}

/* Called from the IO thread. */
static int sink_set_state_in_io_thread_cb(pa_sink *s, pa_sink_state_t new_state, pa_suspend_cause_t new_suspend_cause) {
    struct userdata *u;

    pa_assert(s);
    pa_assert_se(u = s->userdata);

    /* When our session becomes active, we need to sync the mixer, because
     * another user may have changed the mixer settings.
     *
     * If deferred volume is disabled, the syncing is done in the
     * set_state_in_main_thread() callback instead. */
    if ((s->flags & PA_SINK_DEFERRED_VOLUME)
            && (s->suspend_cause & PA_SUSPEND_SESSION)
            && !(new_suspend_cause & PA_SUSPEND_SESSION))
        sync_mixer(u, s->active_port);

    /* It may be that only the suspend cause is changing, in which case there's
     * nothing more to do. */
    if (new_state == s->thread_info.state)
        return 0;

    switch (new_state) {

        case PA_SINK_SUSPENDED: {
            pa_assert(PA_SINK_IS_OPENED(s->thread_info.state));

            suspend(u);

            break;
        }

        case PA_SINK_IDLE:
        case PA_SINK_RUNNING: {
            int r;

            if (s->thread_info.state == PA_SINK_INIT) {
                if (build_pollfd(u) < 0)
                    /* FIXME: This will cause an assertion failure, because
                     * with the current design pa_sink_put() is not allowed
                     * to fail and pa_sink_put() has no fallback code that
                     * would start the sink suspended if opening the device
                     * fails. */
                    return -PA_ERR_IO;
            }

            if (s->thread_info.state == PA_SINK_SUSPENDED) {
                if ((r = unsuspend(u, false)) < 0)
                    return r;
            }

            break;
        }

        case PA_SINK_UNLINKED:
        case PA_SINK_INIT:
        case PA_SINK_INVALID_STATE:
            break;
    }

    return 0;
}

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);
    pa_assert(u->mixer_handle);

    if (mask == SND_CTL_EVENT_MASK_REMOVE)
        return 0;

    if (!PA_SINK_IS_LINKED(u->sink->state))
        return 0;

    if (u->sink->suspend_cause & PA_SUSPEND_SESSION)
        return 0;

    if (mask & SND_CTL_EVENT_MASK_VALUE) {
        pa_sink_get_volume(u->sink, true);
        pa_sink_get_mute(u->sink, 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->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 volume_buf[PA_CVOLUME_SNPRINT_VERBOSE_MAX];

    pa_assert(u);
    pa_assert(u->mixer_path);
    pa_assert(u->mixer_handle);

    if (pa_alsa_path_get_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r) < 0)
        return;

    /* 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_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->real_volume = u->hardware_volume = r;

    /* Hmm, so the hardware volume changed, let's reset our software volume */
    if (u->mixer_path->has_dB)
        pa_sink_set_soft_volume(s, NULL);
}

static void sink_set_volume_cb(pa_sink *s) {
    struct userdata *u = s->userdata;
    pa_cvolume r;
    char volume_buf[PA_CVOLUME_SNPRINT_VERBOSE_MAX];
    bool deferred_volume = !!(s->flags & PA_SINK_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->real_volume, s->base_volume);

    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 */
    pa_sw_cvolume_multiply_scalar(&r, &r, s->base_volume);

    u->hardware_volume = r;

    if (u->mixer_path->has_dB) {
        pa_cvolume new_soft_volume;
        bool accurate_enough;

        /* Match exactly what the user requested by software */
        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
         * accuracy */
        accurate_enough =
            (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_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_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->real_volume = r;
    }
}

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_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 int sink_get_mute_cb(pa_sink *s, bool *mute) {
    struct userdata *u = s->userdata;

    pa_assert(u);
    pa_assert(u->mixer_path);
    pa_assert(u->mixer_handle);

    if (pa_alsa_path_get_mute(u->mixer_path, u->mixer_handle, mute) < 0)
        return -1;

    return 0;
}

static void sink_set_mute_cb(pa_sink *s) {
    struct userdata *u = s->userdata;

    pa_assert(u);
    pa_assert(u->mixer_path);
    pa_assert(u->mixer_handle);

    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 || !u->mixer_path->has_volume) {
        pa_sink_set_write_volume_callback(u->sink, NULL);
        pa_sink_set_get_volume_callback(u->sink, NULL);
        pa_sink_set_set_volume_callback(u->sink, NULL);

        pa_log_info("Driver does not support hardware volume control, falling back to software volume control.");
    } else {
        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->deferred_volume) {
            pa_sink_set_write_volume_callback(u->sink, sink_write_volume_cb);
            pa_log_info("Successfully enabled deferred volume.");
        } else
            pa_sink_set_write_volume_callback(u->sink, NULL);

        if (u->mixer_path->has_dB) {
            pa_sink_enable_decibel_volume(u->sink, 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->sink->base_volume = pa_sw_volume_from_dB(-u->mixer_path->max_dB);
            u->sink->n_volume_steps = PA_VOLUME_NORM+1;

            pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(u->sink->base_volume));
        } else {
            pa_sink_enable_decibel_volume(u->sink, false);
            pa_log_info("Hardware volume ranges from %li to %li.", u->mixer_path->min_volume, u->mixer_path->max_volume);

            u->sink->base_volume = PA_VOLUME_NORM;
            u->sink->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 || !u->mixer_path->has_mute) {
        pa_sink_set_get_mute_callback(u->sink, NULL);
        pa_sink_set_set_mute_callback(u->sink, NULL);
        pa_log_info("Driver does not support hardware mute control, falling back to software mute control.");
    } else {
        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.");
    }
}

static int sink_set_port_ucm_cb(pa_sink *s, pa_device_port *p) {
    struct userdata *u = s->userdata;
    pa_alsa_ucm_port_data *data;

    pa_assert(u);
    pa_assert(p);
    pa_assert(u->ucm_context);

    data = PA_DEVICE_PORT_DATA(p);
    u->mixer_path = data->path;
    mixer_volume_init(u);

    if (s->flags & PA_SINK_DEFERRED_VOLUME)
        pa_asyncmsgq_send(u->sink->asyncmsgq, PA_MSGOBJECT(u->sink), SINK_MESSAGE_SYNC_MIXER, p, 0, NULL);
    else
        sync_mixer(u, p);

    return pa_alsa_ucm_set_port(u->ucm_context, p, true);
}

static int sink_set_port_cb(pa_sink *s, pa_device_port *p) {
    struct userdata *u = s->userdata;
    pa_alsa_port_data *data;

    pa_assert(u);
    pa_assert(p);
    pa_assert(u->mixer_handle);
    pa_assert(!u->ucm_context);

    data = PA_DEVICE_PORT_DATA(p);
    pa_assert_se(u->mixer_path = data->path);
    mixer_volume_init(u);

    if (s->flags & PA_SINK_DEFERRED_VOLUME)
        pa_asyncmsgq_send(u->sink->asyncmsgq, PA_MSGOBJECT(u->sink), SINK_MESSAGE_SYNC_MIXER, p, 0, NULL);
    else
        sync_mixer(u, p);

    if (data->suspend_when_unavailable && p->available == PA_AVAILABLE_NO)
        pa_sink_suspend(s, true, PA_SUSPEND_UNAVAILABLE);
    else
        pa_sink_suspend(s, false, PA_SUSPEND_UNAVAILABLE);

    return 0;
}

static void sink_update_requested_latency_cb(pa_sink *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;

    update_sw_params(u, true);
}

static pa_idxset* sink_get_formats(pa_sink *s) {
    struct userdata *u = s->userdata;

    pa_assert(u);

    return pa_idxset_copy(u->formats, (pa_copy_func_t) pa_format_info_copy);
}

static bool sink_set_formats(pa_sink *s, pa_idxset *formats) {
    struct userdata *u = s->userdata;
    pa_format_info *f, *g;
    uint32_t idx, n;

    pa_assert(u);

    /* FIXME: also validate sample rates against what the device supports */
    PA_IDXSET_FOREACH(f, formats, idx) {
        if (is_iec958(u) && f->encoding == PA_ENCODING_EAC3_IEC61937)
            /* EAC3 cannot be sent over over S/PDIF */
            return false;
    }

    pa_idxset_free(u->formats, (pa_free_cb_t) pa_format_info_free);
    u->formats = pa_idxset_new(NULL, NULL);

    /* Note: the logic below won't apply if we're using software encoding.
     * This is fine for now since we don't support that via the passthrough
     * framework, but this must be changed if we do. */

    /* Count how many sample rates we support */
    for (idx = 0, n = 0; u->supported_rates[idx]; idx++)
        n++;

    /* First insert non-PCM formats since we prefer those. */
    PA_IDXSET_FOREACH(f, formats, idx) {
        if (!pa_format_info_is_pcm(f)) {
            g = pa_format_info_copy(f);
            pa_format_info_set_prop_int_array(g, PA_PROP_FORMAT_RATE, (int *) u->supported_rates, n);
            pa_idxset_put(u->formats, g, NULL);
        }
    }

    /* Now add any PCM formats */
    PA_IDXSET_FOREACH(f, formats, idx) {
        if (pa_format_info_is_pcm(f)) {
            /* We don't set rates here since we'll just tack on a resampler for
             * unsupported rates */
            pa_idxset_put(u->formats, pa_format_info_copy(f), NULL);
        }
    }

    return true;
}

static void sink_reconfigure_cb(pa_sink *s, pa_sample_spec *spec, bool passthrough) {
    struct userdata *u = s->userdata;
    int i;
    bool format_supported = false;
    bool rate_supported = false;

    pa_assert(u);

    for (i = 0; u->supported_formats[i] != PA_SAMPLE_MAX; i++) {
        if (u->supported_formats[i] == spec->format) {
            pa_sink_set_sample_format(u->sink, spec->format);
            format_supported = true;
            break;
        }
    }

    if (!format_supported) {
        pa_log_info("Sink does not support sample format of %s, set it to a verified value",
                    pa_sample_format_to_string(spec->format));
        pa_sink_set_sample_format(u->sink, u->verified_sample_spec.format);
    }

    for (i = 0; u->supported_rates[i]; i++) {
        if (u->supported_rates[i] == spec->rate) {
            pa_sink_set_sample_rate(u->sink, spec->rate);
            rate_supported = true;
            break;
        }
    }

    if (!rate_supported) {
        pa_log_info("Sink does not support sample rate of %u, set it to a verified value", spec->rate);
        pa_sink_set_sample_rate(u->sink, u->verified_sample_spec.rate);
    }

    /* Passthrough status change is handled during unsuspend */
}

static int process_rewind(struct userdata *u) {
    snd_pcm_sframes_t unused;
    size_t rewind_nbytes, unused_nbytes, limit_nbytes;
    int err;
    pa_assert(u);

    if (!PA_SINK_IS_OPENED(u->sink->thread_info.state)) {
        pa_sink_process_rewind(u->sink, 0);
        return 0;
    }

    /* Figure out how much we shall rewind and reset the counter */
    rewind_nbytes = u->sink->thread_info.rewind_nbytes;

    pa_log_debug("Requested to rewind %lu bytes.", (unsigned long) rewind_nbytes);

    if (PA_UNLIKELY((unused = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->sink->sample_spec)) < 0)) {
        if ((err = try_recover(u, "snd_pcm_avail", (int) unused)) < 0) {
            pa_log_warn("Trying to recover from underrun failed during rewind");
            return -1;
        }
        if (err == 1)
            goto rewind_done;
    }

    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;
    else
        limit_nbytes = 0;

    if (rewind_nbytes > limit_nbytes)
        rewind_nbytes = limit_nbytes;

    if (rewind_nbytes > 0) {
        snd_pcm_sframes_t in_frames, out_frames;

        pa_log_debug("Limited to %lu bytes.", (unsigned long) rewind_nbytes);

        in_frames = (snd_pcm_sframes_t) (rewind_nbytes / u->frame_size);
        pa_log_debug("before: %lu", (unsigned long) in_frames);
        if ((out_frames = snd_pcm_rewind(u->pcm_handle, (snd_pcm_uframes_t) in_frames)) < 0) {
            pa_log("snd_pcm_rewind() failed: %s", pa_alsa_strerror((int) out_frames));
            if ((err = try_recover(u, "process_rewind", out_frames)) < 0)
                return -1;
            if (err == 1)
                goto rewind_done;
            out_frames = 0;
        }

        pa_log_debug("after: %lu", (unsigned long) out_frames);

        rewind_nbytes = (size_t) out_frames * u->frame_size;

        if (rewind_nbytes <= 0)
            pa_log_info("Tried rewind, but was apparently not possible.");
        else {
            u->write_count -= rewind_nbytes;
            pa_log_debug("Rewound %lu bytes.", (unsigned long) rewind_nbytes);
            pa_sink_process_rewind(u->sink, rewind_nbytes);

            u->after_rewind = true;
            return 0;
        }
    } else
        pa_log_debug("Mhmm, actually there is nothing to rewind.");

rewind_done:
    pa_sink_process_rewind(u->sink, 0);
    return 0;
}

static void thread_func(void *userdata) {
    struct userdata *u = userdata;
    unsigned short revents = 0;

    pa_assert(u);

    pa_log_debug("Thread starting up");

    if (u->core->realtime_scheduling)
        pa_thread_make_realtime(u->core->realtime_priority);

    pa_thread_mq_install(&u->thread_mq);

    for (;;) {
        int ret;
        pa_usec_t rtpoll_sleep = 0, real_sleep;

#ifdef DEBUG_TIMING
        pa_log_debug("Loop");
#endif

        if (PA_UNLIKELY(u->sink->thread_info.rewind_requested)) {
            if (process_rewind(u) < 0)
                goto fail;
        }

        /* Render some data and write it to the dsp */
        if (PA_SINK_IS_OPENED(u->sink->thread_info.state)) {
            int work_done;
            pa_usec_t sleep_usec = 0;
            bool on_timeout = pa_rtpoll_timer_elapsed(u->rtpoll);

            if (u->use_mmap)
                work_done = mmap_write(u, &sleep_usec, revents & POLLOUT, on_timeout);
            else
                work_done = unix_write(u, &sleep_usec, revents & POLLOUT, on_timeout);

            if (work_done < 0)
                goto fail;

/*             pa_log_debug("work_done = %i", work_done); */

            if (work_done) {

                if (u->first) {
                    pa_log_info("Starting playback.");
                    snd_pcm_start(u->pcm_handle);

                    pa_smoother_resume(u->smoother, pa_rtclock_now(), true);

                    u->first = false;
                }

                update_smoother(u);
            }

            if (u->use_tsched) {
                pa_usec_t cusec;

                if (u->since_start <= u->hwbuf_size) {

                    /* USB devices on ALSA seem to hit a buffer
                     * underrun during the first iterations much
                     * quicker then we calculate here, probably due to
                     * the transport latency. To accommodate for that
                     * we artificially decrease the sleep time until
                     * we have filled the buffer at least once
                     * completely.*/

                    if (pa_log_ratelimit(PA_LOG_DEBUG))
                        pa_log_debug("Cutting sleep time for the initial iterations by half.");
                    sleep_usec /= 2;
                }

                /* OK, the playback buffer is now full, let's
                 * calculate when to wake up next */
#ifdef DEBUG_TIMING
                pa_log_debug("Waking up in %0.2fms (sound card clock).", (double) sleep_usec / PA_USEC_PER_MSEC);
#endif

                /* Convert from the sound card time domain to the
                 * system time domain */
                cusec = pa_smoother_translate(u->smoother, pa_rtclock_now(), sleep_usec);

#ifdef DEBUG_TIMING
                pa_log_debug("Waking up in %0.2fms (system clock).", (double) cusec / PA_USEC_PER_MSEC);
#endif

                /* We don't trust the conversion, so we wake up whatever comes first */
                rtpoll_sleep = PA_MIN(sleep_usec, cusec);
            }

            u->after_rewind = false;

        }

        if (u->sink->flags & PA_SINK_DEFERRED_VOLUME) {
            pa_usec_t volume_sleep;
            pa_sink_volume_change_apply(u->sink, &volume_sleep);
            if (volume_sleep > 0) {
                if (rtpoll_sleep > 0)
                    rtpoll_sleep = PA_MIN(volume_sleep, rtpoll_sleep);
                else
                    rtpoll_sleep = volume_sleep;
            }
        }

        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)) < 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->sink->flags & PA_SINK_DEFERRED_VOLUME)
            pa_sink_volume_change_apply(u->sink, NULL);

        if (ret == 0)
            goto finish;

        /* Tell ALSA about this and process its response */
        if (PA_SINK_IS_OPENED(u->sink->thread_info.state)) {
            struct pollfd *pollfd;
            int err;
            unsigned n;

            pollfd = pa_rtpoll_item_get_pollfd(u->alsa_rtpoll_item, &n);

            if ((err = snd_pcm_poll_descriptors_revents(u->pcm_handle, pollfd, n, &revents)) < 0) {
                pa_log("snd_pcm_poll_descriptors_revents() failed: %s", pa_alsa_strerror(err));
                goto fail;
            }

            if (revents & ~POLLOUT) {
                if ((err = pa_alsa_recover_from_poll(u->pcm_handle, revents)) < 0)
                    goto fail;

                /* Stream needs to be restarted */
                if (err == 1) {
                    close_pcm(u);
                    if (unsuspend(u, true) < 0)
                        goto fail;
                } else
                    reset_vars(u);

                revents = 0;
            } else if (revents && u->use_tsched && pa_log_ratelimit(PA_LOG_DEBUG))
                pa_log_debug("Wakeup from ALSA!");

        } else
            revents = 0;
    }

fail:
    /* If this was no regular exit from the loop we have to continue
     * processing messages until we received PA_MESSAGE_SHUTDOWN */
    pa_asyncmsgq_post(u->thread_mq.outq, PA_MSGOBJECT(u->core), PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0, NULL, NULL);
    pa_asyncmsgq_wait_for(u->thread_mq.inq, PA_MESSAGE_SHUTDOWN);

finish:
    pa_log_debug("Thread shutting down");
}

static void set_sink_name(pa_sink_new_data *data, pa_modargs *ma, const char *device_id, const char *device_name, pa_alsa_mapping *mapping) {
    const char *n;
    char *t;

    pa_assert(data);
    pa_assert(ma);
    pa_assert(device_name);

    if ((n = pa_modargs_get_value(ma, "sink_name", NULL))) {
        pa_sink_new_data_set_name(data, n);
        data->namereg_fail = true;
        return;
    }

    if ((n = pa_modargs_get_value(ma, "name", NULL)))
        data->namereg_fail = true;
    else {
        n = device_id ? device_id : device_name;
        data->namereg_fail = false;
    }

    if (mapping)
        t = pa_sprintf_malloc("alsa_output.%s.%s", n, mapping->name);
    else
        t = pa_sprintf_malloc("alsa_output.%s", n);

    pa_sink_new_data_set_name(data, t);
    pa_xfree(t);
}

static void find_mixer(struct userdata *u, pa_alsa_mapping *mapping, const char *element, bool ignore_dB) {
    const char *mdev;

    if (!mapping && !element)
        return;

    if (!element && mapping && pa_alsa_path_set_is_empty(mapping->output_path_set))
        return;

    u->mixers = pa_hashmap_new_full(pa_idxset_string_hash_func, pa_idxset_string_compare_func,
                                    NULL, (pa_free_cb_t) pa_alsa_mixer_free);

    mdev = pa_proplist_gets(mapping->proplist, "alsa.mixer_device");
    if (mdev) {
        u->mixer_handle = pa_alsa_open_mixer_by_name(u->mixers, mdev, true);
    } else {
        u->mixer_handle = pa_alsa_open_mixer_for_pcm(u->mixers, u->pcm_handle, true);
    }
    if (!u->mixer_handle) {
        pa_log_info("Failed to find a working mixer device.");
        return;
    }

    if (element) {

        if (!(u->mixer_path = pa_alsa_path_synthesize(element, PA_ALSA_DIRECTION_OUTPUT)))
            goto fail;

        if (pa_alsa_path_probe(u->mixer_path, NULL, u->mixer_handle, ignore_dB) < 0)
            goto fail;

        pa_log_debug("Probed mixer path %s:", u->mixer_path->name);
        pa_alsa_path_dump(u->mixer_path);
    } else {
        u->mixer_path_set = mapping->output_path_set;
    }

    return;

fail:

    if (u->mixer_path) {
        pa_alsa_path_free(u->mixer_path);
        u->mixer_path = NULL;
    }

    u->mixer_handle = NULL;
    pa_hashmap_free(u->mixers);
    u->mixers = NULL;
}

static int setup_mixer(struct userdata *u, bool ignore_dB) {
    bool need_mixer_callback = false;

    pa_assert(u);

    /* This code is before the u->mixer_handle check, because if the UCM
     * configuration doesn't specify volume or mute controls, u->mixer_handle
     * will be NULL, but the UCM device enable sequence will still need to be
     * executed. */
    if (u->sink->active_port && u->ucm_context) {
        if (pa_alsa_ucm_set_port(u->ucm_context, u->sink->active_port, true) < 0)
            return -1;
    }

    if (!u->mixer_handle)
        return 0;

    if (u->sink->active_port) {
        if (!u->ucm_context) {
            pa_alsa_port_data *data;

            /* We have a list of supported paths, so let's activate the
             * one that has been chosen as active */

            data = PA_DEVICE_PORT_DATA(u->sink->active_port);
            u->mixer_path = data->path;

            pa_alsa_path_select(data->path, data->setting, u->mixer_handle, u->sink->muted);
        } else {
            pa_alsa_ucm_port_data *data;

            data = PA_DEVICE_PORT_DATA(u->sink->active_port);

            /* Now activate volume controls, if any */
            if (data->path) {
                u->mixer_path = data->path;
                pa_alsa_path_select(u->mixer_path, NULL, u->mixer_handle, u->sink->muted);
            }
        }
    } else {

        if (!u->mixer_path && u->mixer_path_set)
            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_path->settings, u->mixer_handle, u->sink->muted);
        } else
            return 0;
    }

    mixer_volume_init(u);

    /* Will we need to register callbacks? */
    if (u->mixer_path_set && u->mixer_path_set->paths) {
        pa_alsa_path *p;
        void *state;

        PA_HASHMAP_FOREACH(p, u->mixer_path_set->paths, state) {
            if (p->has_volume || p->has_mute)
                need_mixer_callback = true;
        }
    }
    else if (u->mixer_path)
        need_mixer_callback = u->mixer_path->has_volume || u->mixer_path->has_mute;

    if (need_mixer_callback) {
        int (*mixer_callback)(snd_mixer_elem_t *, unsigned int);
        if (u->sink->flags & PA_SINK_DEFERRED_VOLUME) {
            u->mixer_pd = pa_alsa_mixer_pdata_new();
            mixer_callback = io_mixer_callback;

            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_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);
    }

    return 0;
}

pa_sink *pa_alsa_sink_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, *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, rewind_safeguard;
    snd_pcm_uframes_t period_frames, buffer_frames, tsched_frames;
    size_t frame_size;
    bool use_mmap = true;
    bool use_tsched = true;
    bool ignore_dB = false;
    bool namereg_fail = false;
    bool deferred_volume = false;
    bool set_formats = false;
    bool fixed_latency_range = false;
    bool b;
    bool d;
    bool avoid_resampling;
    pa_sink_new_data data;
    bool volume_is_set;
    bool mute_is_set;
    pa_alsa_profile_set *profile_set = NULL;
    void *state;

    pa_assert(m);
    pa_assert(ma);

    ss = m->core->default_sample_spec;
    map = m->core->default_channel_map;
    avoid_resampling = m->core->avoid_resampling;

    /* 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 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;
    }

    frame_size = pa_frame_size(&ss);

    nfrags = m->core->default_n_fragments;
    frag_size = (uint32_t) pa_usec_to_bytes(m->core->default_fragment_size_msec*PA_USEC_PER_MSEC, &ss);
    if (frag_size <= 0)
        frag_size = (uint32_t) frame_size;
    tsched_size = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_BUFFER_USEC, &ss);
    tsched_watermark = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_WATERMARK_USEC, &ss);

    if (pa_modargs_get_value_u32(ma, "fragments", &nfrags) < 0 ||
        pa_modargs_get_value_u32(ma, "fragment_size", &frag_size) < 0 ||
        pa_modargs_get_value_u32(ma, "tsched_buffer_size", &tsched_size) < 0 ||
        pa_modargs_get_value_u32(ma, "tsched_buffer_watermark", &tsched_watermark) < 0) {
        pa_log("Failed to parse buffer metrics");
        goto fail;
    }

    buffer_size = nfrags * frag_size;

    period_frames = frag_size/frame_size;
    buffer_frames = buffer_size/frame_size;
    tsched_frames = tsched_size/frame_size;

    if (pa_modargs_get_value_boolean(ma, "mmap", &use_mmap) < 0) {
        pa_log("Failed to parse mmap argument.");
        goto fail;
    }

    if (pa_modargs_get_value_boolean(ma, "tsched", &use_tsched) < 0) {
        pa_log("Failed to parse tsched argument.");
        goto fail;
    }

    if (pa_modargs_get_value_boolean(ma, "ignore_dB", &ignore_dB) < 0) {
        pa_log("Failed to parse ignore_dB argument.");
        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;
    }

    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);
    u->core = m->core;
    u->module = m;
    u->use_mmap = use_mmap;
    u->use_tsched = use_tsched;
    u->tsched_size = tsched_size;
    u->initial_info.nfrags = (size_t) nfrags;
    u->initial_info.fragment_size = (size_t) frag_size;
    u->initial_info.tsched_size = (size_t) tsched_size;
    u->initial_info.tsched_watermark = (size_t) tsched_watermark;
    u->initial_info.rewind_safeguard = (size_t) rewind_safeguard;
    u->deferred_volume = deferred_volume;
    u->fixed_latency_range = fixed_latency_range;
    u->first = true;
    u->rewind_safeguard = rewind_safeguard;
    u->rtpoll = pa_rtpoll_new();

    if (pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll) < 0) {
        pa_log("pa_thread_mq_init() failed.");
        goto fail;
    }

    u->smoother = pa_smoother_new(
            SMOOTHER_ADJUST_USEC,
            SMOOTHER_WINDOW_USEC,
            true,
            true,
            5,
            pa_rtclock_now(),
            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;

    if (reserve_monitor_init(u, dev_id) < 0)
        goto fail;

    b = use_mmap;
    d = use_tsched;

    /* Force ALSA to reread its configuration if module-alsa-card didn't
     * do it for us. This matters if our device was hot-plugged after ALSA
     * has already read its configuration - see
     * https://bugs.freedesktop.org/show_bug.cgi?id=54029
     */

    if (!card)
        snd_config_update_free_global();

    if (mapping) {

        if (!(dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
            pa_log("device_id= not set");
            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,
                      &ss, &map,
                      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))) {

        if (!(profile_set = pa_alsa_profile_set_new(NULL, &map)))
            goto fail;

        if (!(u->pcm_handle = pa_alsa_open_by_device_id_auto(
                      dev_id,
                      &u->device_name,
                      &ss, &map,
                      SND_PCM_STREAM_PLAYBACK,
                      &period_frames, &buffer_frames, tsched_frames,
                      &b, &d, profile_set, &mapping)))
            goto fail;

    } else {

        if (!(u->pcm_handle = pa_alsa_open_by_device_string(
                      pa_modargs_get_value(ma, "device", DEFAULT_DEVICE),
                      &u->device_name,
                      &ss, &map,
                      SND_PCM_STREAM_PLAYBACK,
                      &period_frames, &buffer_frames, tsched_frames,
                      &b, &d, false)))
            goto fail;
    }

    pa_assert(u->device_name);
    pa_log_info("Successfully opened device %s.", u->device_name);

    if (pa_alsa_pcm_is_modem(u->pcm_handle)) {
        pa_log_notice("Device %s is modem, refusing further initialization.", u->device_name);
        goto fail;
    }

    if (mapping)
        pa_log_info("Selected mapping '%s' (%s).", mapping->description, mapping->name);

    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;
    }

    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;
    }

    if (u->use_mmap)
        pa_log_info("Successfully enabled mmap() mode.");

    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 underrun");
    }

    /* All passthrough formats supported by PulseAudio require
     * IEC61937 framing with two fake channels. So, passthrough
     * clients will always send two channels. Multichannel sinks
     * cannot accept that, because nobody implemented sink channel count
     * switching so far. So just don't show known non-working settings
     * to the user. */
    if ((is_iec958(u) || is_hdmi(u)) && ss.channels == 2)
        set_formats = true;

    u->verified_sample_spec = ss;

    u->supported_formats = pa_alsa_get_supported_formats(u->pcm_handle, ss.format);
    if (!u->supported_formats) {
        pa_log_error("Failed to find any supported sample formats.");
        goto fail;
    }

    u->supported_rates = pa_alsa_get_supported_rates(u->pcm_handle, ss.rate);
    if (!u->supported_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);

    pa_sink_new_data_init(&data);
    data.driver = driver;
    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 namereg_fail argument.");
        pa_sink_new_data_done(&data);
        goto fail;
    }
    data.namereg_fail = namereg_fail;

    if (pa_modargs_get_value_boolean(ma, "avoid_resampling", &avoid_resampling) < 0) {
        pa_log("Failed to parse avoid_resampling argument.");
        pa_sink_new_data_done(&data);
        goto fail;
    }
    pa_sink_new_data_set_avoid_resampling(&data, avoid_resampling);

    pa_sink_new_data_set_sample_spec(&data, &ss);
    pa_sink_new_data_set_channel_map(&data, &map);
    pa_sink_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);
    pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_BUFFER_SIZE, "%lu", (unsigned long) (buffer_frames * frame_size));
    pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZE, "%lu", (unsigned long) (period_frames * frame_size));
    pa_proplist_sets(data.proplist, PA_PROP_DEVICE_ACCESS_MODE, u->use_tsched ? "mmap+timer" : (u->use_mmap ? "mmap" : "serial"));

    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);

        state = NULL;
        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, card);

    if (u->control_device)
        pa_alsa_init_proplist_ctl(data.proplist, u->control_device);

    if (pa_modargs_get_proplist(ma, "sink_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
        pa_log("Invalid properties");
        pa_sink_new_data_done(&data);
        goto fail;
    }

    if (u->ucm_context) {
        pa_alsa_ucm_add_ports(&data.ports, data.proplist, u->ucm_context, true, card, u->pcm_handle, ignore_dB);
        find_mixer(u, mapping, pa_modargs_get_value(ma, "control", NULL), ignore_dB);
    } else {
        find_mixer(u, mapping, pa_modargs_get_value(ma, "control", NULL), ignore_dB);
        if (u->mixer_path_set)
            pa_alsa_add_ports(&data, u->mixer_path_set, card);
    }

    u->sink = pa_sink_new(m->core, &data, PA_SINK_HARDWARE | PA_SINK_LATENCY | (u->use_tsched ? PA_SINK_DYNAMIC_LATENCY : 0) |
                          (set_formats ? PA_SINK_SET_FORMATS : 0));
    volume_is_set = data.volume_is_set;
    mute_is_set = data.muted_is_set;
    pa_sink_new_data_done(&data);

    if (!u->sink) {
        pa_log("Failed to create sink object");
        goto fail;
    }

    if (u->ucm_context) {
        pa_device_port *port;
        unsigned h_prio = 0;
        PA_HASHMAP_FOREACH(port, u->sink->ports, state) {
            if (!h_prio || port->priority > h_prio)
                h_prio = port->priority;
        }
        /* ucm ports prioriy is 100, 200, ..., 900, change it to units digit */
        h_prio = h_prio / 100;
        u->sink->priority += h_prio;
    }

    if (pa_modargs_get_value_u32(ma, "deferred_volume_safety_margin",
                                 &u->sink->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->sink->thread_info.volume_change_extra_delay) < 0) {
        pa_log("Failed to parse deferred_volume_extra_delay parameter");
        goto fail;
    }

    u->sink->parent.process_msg = sink_process_msg;
    if (u->use_tsched)
        u->sink->update_requested_latency = sink_update_requested_latency_cb;
    u->sink->set_state_in_main_thread = sink_set_state_in_main_thread_cb;
    u->sink->set_state_in_io_thread = sink_set_state_in_io_thread_cb;
    if (u->ucm_context)
        u->sink->set_port = sink_set_port_ucm_cb;
    else
        u->sink->set_port = sink_set_port_cb;
    u->sink->reconfigure = sink_reconfigure_cb;
    u->sink->userdata = u;

    pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
    pa_sink_set_rtpoll(u->sink, u->rtpoll);

    u->frame_size = frame_size;
    u->frames_per_block = pa_mempool_block_size_max(m->core->mempool) / frame_size;
    u->fragment_size = frag_size = (size_t) (period_frames * frame_size);
    u->hwbuf_size = buffer_size = (size_t) (buffer_frames * frame_size);
    pa_cvolume_mute(&u->hardware_volume, u->sink->sample_spec.channels);

    pa_log_info("Using %0.1f fragments of size %lu bytes (%0.2fms), buffer size is %lu bytes (%0.2fms)",
                (double) u->hwbuf_size / (double) u->fragment_size,
                (long unsigned) u->fragment_size,
                (double) pa_bytes_to_usec(u->fragment_size, &ss) / PA_USEC_PER_MSEC,
                (long unsigned) u->hwbuf_size,
                (double) pa_bytes_to_usec(u->hwbuf_size, &ss) / PA_USEC_PER_MSEC);

    pa_sink_set_max_request(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_ref = tsched_watermark;
        reset_watermark(u, u->tsched_watermark_ref, &ss, false);
    } else
        pa_sink_set_fixed_latency(u->sink, pa_bytes_to_usec(u->hwbuf_size, &ss));

    reserve_update(u);

    if (update_sw_params(u, false) < 0)
        goto fail;

    if (setup_mixer(u, ignore_dB) < 0)
        goto fail;

    pa_alsa_dump(PA_LOG_DEBUG, u->pcm_handle);

    thread_name = pa_sprintf_malloc("alsa-sink-%s", pa_strnull(pa_proplist_gets(u->sink->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 (volume_is_set) {
        if (u->sink->set_volume)
            u->sink->set_volume(u->sink);
    } else {
        if (u->sink->get_volume)
            u->sink->get_volume(u->sink);
    }

    if (mute_is_set) {
        if (u->sink->set_mute)
            u->sink->set_mute(u->sink);
    } else {
        if (u->sink->get_mute) {
            bool mute;

            if (u->sink->get_mute(u->sink, &mute) >= 0)
                pa_sink_set_mute(u->sink, mute, false);
        }
    }

    if ((volume_is_set || mute_is_set) && u->sink->write_volume)
        u->sink->write_volume(u->sink);

    if (set_formats) {
        /* For S/PDIF and HDMI, allow getting/setting custom formats */
        pa_format_info *format;

        /* To start with, we only support PCM formats. Other formats may be added
         * with pa_sink_set_formats().*/
        format = pa_format_info_new();
        format->encoding = PA_ENCODING_PCM;
        u->formats = pa_idxset_new(NULL, NULL);
        pa_idxset_put(u->formats, format, NULL);

        u->sink->get_formats = sink_get_formats;
        u->sink->set_formats = sink_set_formats;
    }

    pa_sink_put(u->sink);

    if (profile_set)
        pa_alsa_profile_set_free(profile_set);

    /* Suspend if necessary. FIXME: It would be better to start suspended, but
     * that would require some core changes. It's possible to set
     * pa_sink_new_data.suspend_cause, but that has to be done before the
     * pa_sink_new() call, and we know if we need to suspend only after the
     * pa_sink_new() call when the initial port has been chosen. Calling
     * pa_sink_suspend() between pa_sink_new() and pa_sink_put() would
     * otherwise work, but currently pa_sink_suspend() will crash if
     * pa_sink_put() hasn't been called. */
    if (u->sink->active_port && !u->ucm_context) {
        pa_alsa_port_data *port_data;

        port_data = PA_DEVICE_PORT_DATA(u->sink->active_port);

        if (port_data->suspend_when_unavailable && u->sink->active_port->available == PA_AVAILABLE_NO)
            pa_sink_suspend(u->sink, true, PA_SUSPEND_UNAVAILABLE);
    }

    return u->sink;

fail:
    pa_xfree(thread_name);

    if (u)
        userdata_free(u);

    if (profile_set)
        pa_alsa_profile_set_free(profile_set);

    return NULL;
}

static void userdata_free(struct userdata *u) {
    pa_assert(u);

    if (u->sink)
        pa_sink_unlink(u->sink);

    if (u->thread) {
        pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
        pa_thread_free(u->thread);
    }

    pa_thread_mq_done(&u->thread_mq);

    if (u->sink)
        pa_sink_unref(u->sink);

    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);

    if (u->rtpoll)
        pa_rtpoll_free(u->rtpoll);

    if (u->pcm_handle) {
        snd_pcm_drop(u->pcm_handle);
        snd_pcm_close(u->pcm_handle);
    }

    if (u->mixer_fdl)
        pa_alsa_fdlist_free(u->mixer_fdl);

    /* Only free the mixer_path if the sink owns it */
    if (u->mixer_path && !u->mixer_path_set && !u->ucm_context)
        pa_alsa_path_free(u->mixer_path);

    if (u->mixers)
        pa_hashmap_free(u->mixers);

    if (u->smoother)
        pa_smoother_free(u->smoother);

    if (u->formats)
        pa_idxset_free(u->formats, (pa_free_cb_t) pa_format_info_free);

    if (u->supported_formats)
        pa_xfree(u->supported_formats);

    if (u->supported_rates)
        pa_xfree(u->supported_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);
}

void pa_alsa_sink_free(pa_sink *s) {
    struct userdata *u;

    pa_sink_assert_ref(s);
    pa_assert_se(u = s->userdata);

    userdata_free(u);
}