src/modules/alsa/alsa-sink.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2004-2008 Lennart Poettering
   5   Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
   6
   7   PulseAudio is free software; you can redistribute it and/or modify
   8   it under the terms of the GNU Lesser General Public License as published
   9   by the Free Software Foundation; either version 2.1 of the License,
  10   or (at your option) any later version.
  11
  12   PulseAudio is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with PulseAudio; if not, write to the Free Software
  19   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  20   USA.
  21 ***/
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include <stdio.h>
  28
  29 #include <asoundlib.h>
  30
  31 #ifdef HAVE_VALGRIND_MEMCHECK_H
  32 #include <valgrind/memcheck.h>
  33 #endif
  34
  35 #include <pulse/rtclock.h>
  36 #include <pulse/timeval.h>
  37 #include <pulse/volume.h>
  38 #include <pulse/xmalloc.h>
  39 #include <pulse/internal.h>
  40
  41 #include <pulsecore/core.h>
  42 #include <pulsecore/i18n.h>
  43 #include <pulsecore/module.h>
  44 #include <pulsecore/memchunk.h>
  45 #include <pulsecore/sink.h>
  46 #include <pulsecore/modargs.h>
  47 #include <pulsecore/core-rtclock.h>
  48 #include <pulsecore/core-util.h>
  49 #include <pulsecore/sample-util.h>
  50 #include <pulsecore/log.h>
  51 #include <pulsecore/macro.h>
  52 #include <pulsecore/thread.h>
  53 #include <pulsecore/thread-mq.h>
  54 #include <pulsecore/rtpoll.h>
  55 #include <pulsecore/time-smoother.h>
  56
  57 #include <modules/reserve-wrap.h>
  58
  59 #include "alsa-util.h"
  60 #include "alsa-sink.h"
  61
  62 /* #define DEBUG_TIMING */
  63
  64 #define DEFAULT_DEVICE "default"
  65
  66 #define DEFAULT_TSCHED_BUFFER_USEC (2*PA_USEC_PER_SEC)             /* 2s    -- Overall buffer size */
  67 #define DEFAULT_TSCHED_WATERMARK_USEC (20*PA_USEC_PER_MSEC)        /* 20ms  -- Fill up when only this much is left in the buffer */
  68
  69 #define TSCHED_WATERMARK_INC_STEP_USEC (10*PA_USEC_PER_MSEC)       /* 10ms  -- On underrun, increase watermark by this */
  70 #define TSCHED_WATERMARK_DEC_STEP_USEC (5*PA_USEC_PER_MSEC)        /* 5ms   -- When everything's great, decrease watermark by this */
  71 #define TSCHED_WATERMARK_VERIFY_AFTER_USEC (20*PA_USEC_PER_SEC)    /* 20s   -- How long after a drop out recheck if things are good now */
  72 #define TSCHED_WATERMARK_INC_THRESHOLD_USEC (0*PA_USEC_PER_MSEC)   /* 0ms   -- If the buffer level ever below this threshold, increase the watermark */
  73 #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 */
  74
  75 /* Note that TSCHED_WATERMARK_INC_THRESHOLD_USEC == 0 means that we
  76  * will increase the watermark only if we hit a real underrun. */
  77
  78 #define TSCHED_MIN_SLEEP_USEC (10*PA_USEC_PER_MSEC)                /* 10ms  -- Sleep at least 10ms on each iteration */
  79 #define TSCHED_MIN_WAKEUP_USEC (4*PA_USEC_PER_MSEC)                /* 4ms   -- Wakeup at least this long before the buffer runs empty*/
  80
  81 #define SMOOTHER_WINDOW_USEC  (10*PA_USEC_PER_SEC)                 /* 10s   -- smoother windows size */
  82 #define SMOOTHER_ADJUST_USEC  (1*PA_USEC_PER_SEC)                  /* 1s    -- smoother adjust time */
  83
  84 #define SMOOTHER_MIN_INTERVAL (2*PA_USEC_PER_MSEC)                 /* 2ms   -- min smoother update interval */
  85 #define SMOOTHER_MAX_INTERVAL (200*PA_USEC_PER_MSEC)               /* 200ms -- max smoother update interval */
  86
  87 #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 */
  88
  89 #define DEFAULT_REWIND_SAFEGUARD_BYTES (256U) /* 1.33ms @48kHz, we'll never rewind less than this */
  90 #define DEFAULT_REWIND_SAFEGUARD_USEC (1330) /* 1.33ms, depending on channels/rate/sample we may rewind more than 256 above */
  91
  92 struct userdata {
  93     pa_core *core;
  94     pa_module *module;
  95     pa_sink *sink;
  96
  97     pa_thread *thread;
  98     pa_thread_mq thread_mq;
  99     pa_rtpoll *rtpoll;
 100
 101     snd_pcm_t *pcm_handle;
 102
 103     char *paths_dir;
 104     pa_alsa_fdlist *mixer_fdl;
 105     pa_alsa_mixer_pdata *mixer_pd;
 106     snd_mixer_t *mixer_handle;
 107     pa_alsa_path_set *mixer_path_set;
 108     pa_alsa_path *mixer_path;
 109
 110     pa_cvolume hardware_volume;
 111
 112     unsigned int *rates;
 113
 114     size_t
 115         frame_size,
 116         fragment_size,
 117         hwbuf_size,
 118         tsched_watermark,
 119         tsched_watermark_ref,
 120         hwbuf_unused,
 121         min_sleep,
 122         min_wakeup,
 123         watermark_inc_step,
 124         watermark_dec_step,
 125         watermark_inc_threshold,
 126         watermark_dec_threshold,
 127         rewind_safeguard;
 128
 129     pa_usec_t watermark_dec_not_before;
 130     pa_usec_t min_latency_ref;
 131
 132     pa_memchunk memchunk;
 133
 134     char *device_name;  /* name of the PCM device */
 135     char *control_device; /* name of the control device */
 136
 137     pa_bool_t use_mmap:1, use_tsched:1, deferred_volume:1, fixed_latency_range:1;
 138
 139     pa_bool_t first, after_rewind;
 140
 141     pa_rtpoll_item *alsa_rtpoll_item;
 142
 143     pa_smoother *smoother;
 144     uint64_t write_count;
 145     uint64_t since_start;
 146     pa_usec_t smoother_interval;
 147     pa_usec_t last_smoother_update;
 148
 149     pa_idxset *formats;
 150
 151     pa_reserve_wrapper *reserve;
 152     pa_hook_slot *reserve_slot;
 153     pa_reserve_monitor_wrapper *monitor;
 154     pa_hook_slot *monitor_slot;
 155 };
 156
 157 static void userdata_free(struct userdata *u);
 158
 159 /* FIXME: Is there a better way to do this than device names? */
 160 static pa_bool_t is_iec958(struct userdata *u) {
 161     return (strncmp("iec958", u->device_name, 6) == 0);
 162 }
 163
 164 static pa_bool_t is_hdmi(struct userdata *u) {
 165     return (strncmp("hdmi", u->device_name, 4) == 0);
 166 }
 167
 168 static pa_hook_result_t reserve_cb(pa_reserve_wrapper *r, void *forced, struct userdata *u) {
 169     pa_assert(r);
 170     pa_assert(u);
 171
 172     if (pa_sink_suspend(u->sink, TRUE, PA_SUSPEND_APPLICATION) < 0)
 173         return PA_HOOK_CANCEL;
 174
 175     return PA_HOOK_OK;
 176 }
 177
 178 static void reserve_done(struct userdata *u) {
 179     pa_assert(u);
 180
 181     if (u->reserve_slot) {
 182         pa_hook_slot_free(u->reserve_slot);
 183         u->reserve_slot = NULL;
 184     }
 185
 186     if (u->reserve) {
 187         pa_reserve_wrapper_unref(u->reserve);
 188         u->reserve = NULL;
 189     }
 190 }
 191
 192 static void reserve_update(struct userdata *u) {
 193     const char *description;
 194     pa_assert(u);
 195
 196     if (!u->sink || !u->reserve)
 197         return;
 198
 199     if ((description = pa_proplist_gets(u->sink->proplist, PA_PROP_DEVICE_DESCRIPTION)))
 200         pa_reserve_wrapper_set_application_device_name(u->reserve, description);
 201 }
 202
 203 static int reserve_init(struct userdata *u, const char *dname) {
 204     char *rname;
 205
 206     pa_assert(u);
 207     pa_assert(dname);
 208
 209     if (u->reserve)
 210         return 0;
 211
 212     if (pa_in_system_mode())
 213         return 0;
 214
 215     if (!(rname = pa_alsa_get_reserve_name(dname)))
 216         return 0;
 217
 218     /* We are resuming, try to lock the device */
 219     u->reserve = pa_reserve_wrapper_get(u->core, rname);
 220     pa_xfree(rname);
 221
 222     if (!(u->reserve))
 223         return -1;
 224
 225     reserve_update(u);
 226
 227     pa_assert(!u->reserve_slot);
 228     u->reserve_slot = pa_hook_connect(pa_reserve_wrapper_hook(u->reserve), PA_HOOK_NORMAL, (pa_hook_cb_t) reserve_cb, u);
 229
 230     return 0;
 231 }
 232
 233 static pa_hook_result_t monitor_cb(pa_reserve_monitor_wrapper *w, void* busy, struct userdata *u) {
 234     pa_bool_t b;
 235
 236     pa_assert(w);
 237     pa_assert(u);
 238
 239     b = PA_PTR_TO_UINT(busy) && !u->reserve;
 240
 241     pa_sink_suspend(u->sink, b, PA_SUSPEND_APPLICATION);
 242     return PA_HOOK_OK;
 243 }
 244
 245 static void monitor_done(struct userdata *u) {
 246     pa_assert(u);
 247
 248     if (u->monitor_slot) {
 249         pa_hook_slot_free(u->monitor_slot);
 250         u->monitor_slot = NULL;
 251     }
 252
 253     if (u->monitor) {
 254         pa_reserve_monitor_wrapper_unref(u->monitor);
 255         u->monitor = NULL;
 256     }
 257 }
 258
 259 static int reserve_monitor_init(struct userdata *u, const char *dname) {
 260     char *rname;
 261
 262     pa_assert(u);
 263     pa_assert(dname);
 264
 265     if (pa_in_system_mode())
 266         return 0;
 267
 268     if (!(rname = pa_alsa_get_reserve_name(dname)))
 269         return 0;
 270
 271     /* We are resuming, try to lock the device */
 272     u->monitor = pa_reserve_monitor_wrapper_get(u->core, rname);
 273     pa_xfree(rname);
 274
 275     if (!(u->monitor))
 276         return -1;
 277
 278     pa_assert(!u->monitor_slot);
 279     u->monitor_slot = pa_hook_connect(pa_reserve_monitor_wrapper_hook(u->monitor), PA_HOOK_NORMAL, (pa_hook_cb_t) monitor_cb, u);
 280
 281     return 0;
 282 }
 283
 284 static void fix_min_sleep_wakeup(struct userdata *u) {
 285     size_t max_use, max_use_2;
 286
 287     pa_assert(u);
 288     pa_assert(u->use_tsched);
 289
 290     max_use = u->hwbuf_size - u->hwbuf_unused;
 291     max_use_2 = pa_frame_align(max_use/2, &u->sink->sample_spec);
 292
 293     u->min_sleep = pa_usec_to_bytes(TSCHED_MIN_SLEEP_USEC, &u->sink->sample_spec);
 294     u->min_sleep = PA_CLAMP(u->min_sleep, u->frame_size, max_use_2);
 295
 296     u->min_wakeup = pa_usec_to_bytes(TSCHED_MIN_WAKEUP_USEC, &u->sink->sample_spec);
 297     u->min_wakeup = PA_CLAMP(u->min_wakeup, u->frame_size, max_use_2);
 298 }
 299
 300 static void fix_tsched_watermark(struct userdata *u) {
 301     size_t max_use;
 302     pa_assert(u);
 303     pa_assert(u->use_tsched);
 304
 305     max_use = u->hwbuf_size - u->hwbuf_unused;
 306
 307     if (u->tsched_watermark > max_use - u->min_sleep)
 308         u->tsched_watermark = max_use - u->min_sleep;
 309
 310     if (u->tsched_watermark < u->min_wakeup)
 311         u->tsched_watermark = u->min_wakeup;
 312 }
 313
 314 static void increase_watermark(struct userdata *u) {
 315     size_t old_watermark;
 316     pa_usec_t old_min_latency, new_min_latency;
 317
 318     pa_assert(u);
 319     pa_assert(u->use_tsched);
 320
 321     /* First, just try to increase the watermark */
 322     old_watermark = u->tsched_watermark;
 323     u->tsched_watermark = PA_MIN(u->tsched_watermark * 2, u->tsched_watermark + u->watermark_inc_step);
 324     fix_tsched_watermark(u);
 325
 326     if (old_watermark != u->tsched_watermark) {
 327         pa_log_info("Increasing wakeup watermark to %0.2f ms",
 328                     (double) pa_bytes_to_usec(u->tsched_watermark, &u->sink->sample_spec) / PA_USEC_PER_MSEC);
 329         return;
 330     }
 331
 332     /* Hmm, we cannot increase the watermark any further, hence let's
 333        raise the latency, unless doing so was disabled in
 334        configuration */
 335     if (u->fixed_latency_range)
 336         return;
 337
 338     old_min_latency = u->sink->thread_info.min_latency;
 339     new_min_latency = PA_MIN(old_min_latency * 2, old_min_latency + TSCHED_WATERMARK_INC_STEP_USEC);
 340     new_min_latency = PA_MIN(new_min_latency, u->sink->thread_info.max_latency);
 341
 342     if (old_min_latency != new_min_latency) {
 343         pa_log_info("Increasing minimal latency to %0.2f ms",
 344                     (double) new_min_latency / PA_USEC_PER_MSEC);
 345
 346         pa_sink_set_latency_range_within_thread(u->sink, new_min_latency, u->sink->thread_info.max_latency);
 347     }
 348
 349     /* When we reach this we're officialy fucked! */
 350 }
 351
 352 static void decrease_watermark(struct userdata *u) {
 353     size_t old_watermark;
 354     pa_usec_t now;
 355
 356     pa_assert(u);
 357     pa_assert(u->use_tsched);
 358
 359     now = pa_rtclock_now();
 360
 361     if (u->watermark_dec_not_before <= 0)
 362         goto restart;
 363
 364     if (u->watermark_dec_not_before > now)
 365         return;
 366
 367     old_watermark = u->tsched_watermark;
 368
 369     if (u->tsched_watermark < u->watermark_dec_step)
 370         u->tsched_watermark = u->tsched_watermark / 2;
 371     else
 372         u->tsched_watermark = PA_MAX(u->tsched_watermark / 2, u->tsched_watermark - u->watermark_dec_step);
 373
 374     fix_tsched_watermark(u);
 375
 376     if (old_watermark != u->tsched_watermark)
 377         pa_log_info("Decreasing wakeup watermark to %0.2f ms",
 378                     (double) pa_bytes_to_usec(u->tsched_watermark, &u->sink->sample_spec) / PA_USEC_PER_MSEC);
 379
 380     /* We don't change the latency range*/
 381
 382 restart:
 383     u->watermark_dec_not_before = now + TSCHED_WATERMARK_VERIFY_AFTER_USEC;
 384 }
 385
 386 static void hw_sleep_time(struct userdata *u, pa_usec_t *sleep_usec, pa_usec_t*process_usec) {
 387     pa_usec_t usec, wm;
 388
 389     pa_assert(sleep_usec);
 390     pa_assert(process_usec);
 391
 392     pa_assert(u);
 393     pa_assert(u->use_tsched);
 394
 395     usec = pa_sink_get_requested_latency_within_thread(u->sink);
 396
 397     if (usec == (pa_usec_t) -1)
 398         usec = pa_bytes_to_usec(u->hwbuf_size, &u->sink->sample_spec);
 399
 400     wm = pa_bytes_to_usec(u->tsched_watermark, &u->sink->sample_spec);
 401
 402     if (wm > usec)
 403         wm = usec/2;
 404
 405     *sleep_usec = usec - wm;
 406     *process_usec = wm;
 407
 408 #ifdef DEBUG_TIMING
 409     pa_log_debug("Buffer time: %lu ms; Sleep time: %lu ms; Process time: %lu ms",
 410                  (unsigned long) (usec / PA_USEC_PER_MSEC),
 411                  (unsigned long) (*sleep_usec / PA_USEC_PER_MSEC),
 412                  (unsigned long) (*process_usec / PA_USEC_PER_MSEC));
 413 #endif
 414 }
 415
 416 static int try_recover(struct userdata *u, const char *call, int err) {
 417     pa_assert(u);
 418     pa_assert(call);
 419     pa_assert(err < 0);
 420
 421     pa_log_debug("%s: %s", call, pa_alsa_strerror(err));
 422
 423     pa_assert(err != -EAGAIN);
 424
 425     if (err == -EPIPE)
 426         pa_log_debug("%s: Buffer underrun!", call);
 427
 428     if (err == -ESTRPIPE)
 429         pa_log_debug("%s: System suspended!", call);
 430
 431     if ((err = snd_pcm_recover(u->pcm_handle, err, 1)) < 0) {
 432         pa_log("%s: %s", call, pa_alsa_strerror(err));
 433         return -1;
 434     }
 435
 436     u->first = TRUE;
 437     u->since_start = 0;
 438     return 0;
 439 }
 440
 441 static size_t check_left_to_play(struct userdata *u, size_t n_bytes, pa_bool_t on_timeout) {
 442     size_t left_to_play;
 443     pa_bool_t underrun = FALSE;
 444
 445     /* We use <= instead of < for this check here because an underrun
 446      * only happens after the last sample was processed, not already when
 447      * it is removed from the buffer. This is particularly important
 448      * when block transfer is used. */
 449
 450     if (n_bytes <= u->hwbuf_size)
 451         left_to_play = u->hwbuf_size - n_bytes;
 452     else {
 453
 454         /* We got a dropout. What a mess! */
 455         left_to_play = 0;
 456         underrun = TRUE;
 457
 458 #if 0
 459         PA_DEBUG_TRAP;
 460 #endif
 461
 462         if (!u->first && !u->after_rewind)
 463             if (pa_log_ratelimit(PA_LOG_INFO))
 464                 pa_log_info("Underrun!");
 465     }
 466
 467 #ifdef DEBUG_TIMING
 468     pa_log_debug("%0.2f ms left to play; inc threshold = %0.2f ms; dec threshold = %0.2f ms",
 469                  (double) pa_bytes_to_usec(left_to_play, &u->sink->sample_spec) / PA_USEC_PER_MSEC,
 470                  (double) pa_bytes_to_usec(u->watermark_inc_threshold, &u->sink->sample_spec) / PA_USEC_PER_MSEC,
 471                  (double) pa_bytes_to_usec(u->watermark_dec_threshold, &u->sink->sample_spec) / PA_USEC_PER_MSEC);
 472 #endif
 473
 474     if (u->use_tsched) {
 475         pa_bool_t reset_not_before = TRUE;
 476
 477         if (!u->first && !u->after_rewind) {
 478             if (underrun || left_to_play < u->watermark_inc_threshold)
 479                 increase_watermark(u);
 480             else if (left_to_play > u->watermark_dec_threshold) {
 481                 reset_not_before = FALSE;
 482
 483                 /* We decrease the watermark only if have actually
 484                  * been woken up by a timeout. If something else woke
 485                  * us up it's too easy to fulfill the deadlines... */
 486
 487                 if (on_timeout)
 488                     decrease_watermark(u);
 489             }
 490         }
 491
 492         if (reset_not_before)
 493             u->watermark_dec_not_before = 0;
 494     }
 495
 496     return left_to_play;
 497 }
 498
 499 static int mmap_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled, pa_bool_t on_timeout) {
 500     pa_bool_t work_done = FALSE;
 501     pa_usec_t max_sleep_usec = 0, process_usec = 0;
 502     size_t left_to_play;
 503     unsigned j = 0;
 504
 505     pa_assert(u);
 506     pa_sink_assert_ref(u->sink);
 507
 508     if (u->use_tsched)
 509         hw_sleep_time(u, &max_sleep_usec, &process_usec);
 510
 511     for (;;) {
 512         snd_pcm_sframes_t n;
 513         size_t n_bytes;
 514         int r;
 515         pa_bool_t after_avail = TRUE;
 516
 517         /* First we determine how many samples are missing to fill the
 518          * buffer up to 100% */
 519
 520         if (PA_UNLIKELY((n = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->sink->sample_spec)) < 0)) {
 521
 522             if ((r = try_recover(u, "snd_pcm_avail", (int) n)) == 0)
 523                 continue;
 524
 525             return r;
 526         }
 527
 528         n_bytes = (size_t) n * u->frame_size;
 529
 530 #ifdef DEBUG_TIMING
 531         pa_log_debug("avail: %lu", (unsigned long) n_bytes);
 532 #endif
 533
 534         left_to_play = check_left_to_play(u, n_bytes, on_timeout);
 535         on_timeout = FALSE;
 536
 537         if (u->use_tsched)
 538
 539             /* We won't fill up the playback buffer before at least
 540             * half the sleep time is over because otherwise we might
 541             * ask for more data from the clients then they expect. We
 542             * need to guarantee that clients only have to keep around
 543             * a single hw buffer length. */
 544
 545             if (!polled &&
 546                 pa_bytes_to_usec(left_to_play, &u->sink->sample_spec) > process_usec+max_sleep_usec/2) {
 547 #ifdef DEBUG_TIMING
 548                 pa_log_debug("Not filling up, because too early.");
 549 #endif
 550                 break;
 551             }
 552
 553         if (PA_UNLIKELY(n_bytes <= u->hwbuf_unused)) {
 554
 555             if (polled)
 556                 PA_ONCE_BEGIN {
 557                     char *dn = pa_alsa_get_driver_name_by_pcm(u->pcm_handle);
 558                     pa_log(_("ALSA woke us up to write new data to the device, but there was actually nothing to write!\n"
 559                              "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers.\n"
 560                              "We were woken up with POLLOUT set -- however a subsequent snd_pcm_avail() returned 0 or another value < min_avail."),
 561                            pa_strnull(dn));
 562                     pa_xfree(dn);
 563                 } PA_ONCE_END;
 564
 565 #ifdef DEBUG_TIMING
 566             pa_log_debug("Not filling up, because not necessary.");
 567 #endif
 568             break;
 569         }
 570
 571
 572         if (++j > 10) {
 573 #ifdef DEBUG_TIMING
 574             pa_log_debug("Not filling up, because already too many iterations.");
 575 #endif
 576
 577             break;
 578         }
 579
 580         n_bytes -= u->hwbuf_unused;
 581         polled = FALSE;
 582
 583 #ifdef DEBUG_TIMING
 584         pa_log_debug("Filling up");
 585 #endif
 586
 587         for (;;) {
 588             pa_memchunk chunk;
 589             void *p;
 590             int err;
 591             const snd_pcm_channel_area_t *areas;
 592             snd_pcm_uframes_t offset, frames;
 593             snd_pcm_sframes_t sframes;
 594
 595             frames = (snd_pcm_uframes_t) (n_bytes / u->frame_size);
 596 /*             pa_log_debug("%lu frames to write", (unsigned long) frames); */
 597
 598             if (PA_UNLIKELY((err = pa_alsa_safe_mmap_begin(u->pcm_handle, &areas, &offset, &frames, u->hwbuf_size, &u->sink->sample_spec)) < 0)) {
 599
 600                 if (!after_avail && err == -EAGAIN)
 601                     break;
 602
 603                 if ((r = try_recover(u, "snd_pcm_mmap_begin", err)) == 0)
 604                     continue;
 605
 606                 return r;
 607             }
 608
 609             /* Make sure that if these memblocks need to be copied they will fit into one slot */
 610             if (frames > pa_mempool_block_size_max(u->core->mempool)/u->frame_size)
 611                 frames = pa_mempool_block_size_max(u->core->mempool)/u->frame_size;
 612
 613             if (!after_avail && frames == 0)
 614                 break;
 615
 616             pa_assert(frames > 0);
 617             after_avail = FALSE;
 618
 619             /* Check these are multiples of 8 bit */
 620             pa_assert((areas[0].first & 7) == 0);
 621             pa_assert((areas[0].step & 7)== 0);
 622
 623             /* We assume a single interleaved memory buffer */
 624             pa_assert((areas[0].first >> 3) == 0);
 625             pa_assert((areas[0].step >> 3) == u->frame_size);
 626
 627             p = (uint8_t*) areas[0].addr + (offset * u->frame_size);
 628
 629             chunk.memblock = pa_memblock_new_fixed(u->core->mempool, p, frames * u->frame_size, TRUE);
 630             chunk.length = pa_memblock_get_length(chunk.memblock);
 631             chunk.index = 0;
 632
 633             pa_sink_render_into_full(u->sink, &chunk);
 634             pa_memblock_unref_fixed(chunk.memblock);
 635
 636             if (PA_UNLIKELY((sframes = snd_pcm_mmap_commit(u->pcm_handle, offset, frames)) < 0)) {
 637
 638                 if (!after_avail && (int) sframes == -EAGAIN)
 639                     break;
 640
 641                 if ((r = try_recover(u, "snd_pcm_mmap_commit", (int) sframes)) == 0)
 642                     continue;
 643
 644                 return r;
 645             }
 646
 647             work_done = TRUE;
 648
 649             u->write_count += frames * u->frame_size;
 650             u->since_start += frames * u->frame_size;
 651
 652 #ifdef DEBUG_TIMING
 653             pa_log_debug("Wrote %lu bytes (of possible %lu bytes)", (unsigned long) (frames * u->frame_size), (unsigned long) n_bytes);
 654 #endif
 655
 656             if ((size_t) frames * u->frame_size >= n_bytes)
 657                 break;
 658
 659             n_bytes -= (size_t) frames * u->frame_size;
 660         }
 661     }
 662
 663     if (u->use_tsched) {
 664         *sleep_usec = pa_bytes_to_usec(left_to_play, &u->sink->sample_spec);
 665         process_usec = pa_bytes_to_usec(u->tsched_watermark, &u->sink->sample_spec);
 666
 667         if (*sleep_usec > process_usec)
 668             *sleep_usec -= process_usec;
 669         else
 670             *sleep_usec = 0;
 671     } else
 672         *sleep_usec = 0;
 673
 674     return work_done ? 1 : 0;
 675 }
 676
 677 static int unix_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled, pa_bool_t on_timeout) {
 678     pa_bool_t work_done = FALSE;
 679     pa_usec_t max_sleep_usec = 0, process_usec = 0;
 680     size_t left_to_play;
 681     unsigned j = 0;
 682
 683     pa_assert(u);
 684     pa_sink_assert_ref(u->sink);
 685
 686     if (u->use_tsched)
 687         hw_sleep_time(u, &max_sleep_usec, &process_usec);
 688
 689     for (;;) {
 690         snd_pcm_sframes_t n;
 691         size_t n_bytes;
 692         int r;
 693         pa_bool_t after_avail = TRUE;
 694
 695         if (PA_UNLIKELY((n = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->sink->sample_spec)) < 0)) {
 696
 697             if ((r = try_recover(u, "snd_pcm_avail", (int) n)) == 0)
 698                 continue;
 699
 700             return r;
 701         }
 702
 703         n_bytes = (size_t) n * u->frame_size;
 704         left_to_play = check_left_to_play(u, n_bytes, on_timeout);
 705         on_timeout = FALSE;
 706
 707         if (u->use_tsched)
 708
 709             /* We won't fill up the playback buffer before at least
 710             * half the sleep time is over because otherwise we might
 711             * ask for more data from the clients then they expect. We
 712             * need to guarantee that clients only have to keep around
 713             * a single hw buffer length. */
 714
 715             if (!polled &&
 716                 pa_bytes_to_usec(left_to_play, &u->sink->sample_spec) > process_usec+max_sleep_usec/2)
 717                 break;
 718
 719         if (PA_UNLIKELY(n_bytes <= u->hwbuf_unused)) {
 720
 721             if (polled)
 722                 PA_ONCE_BEGIN {
 723                     char *dn = pa_alsa_get_driver_name_by_pcm(u->pcm_handle);
 724                     pa_log(_("ALSA woke us up to write new data to the device, but there was actually nothing to write!\n"
 725                              "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers.\n"
 726                              "We were woken up with POLLOUT set -- however a subsequent snd_pcm_avail() returned 0 or another value < min_avail."),
 727                            pa_strnull(dn));
 728                     pa_xfree(dn);
 729                 } PA_ONCE_END;
 730
 731             break;
 732         }
 733
 734         if (++j > 10) {
 735 #ifdef DEBUG_TIMING
 736             pa_log_debug("Not filling up, because already too many iterations.");
 737 #endif
 738
 739             break;
 740         }
 741
 742         n_bytes -= u->hwbuf_unused;
 743         polled = FALSE;
 744
 745         for (;;) {
 746             snd_pcm_sframes_t frames;
 747             void *p;
 748
 749 /*         pa_log_debug("%lu frames to write", (unsigned long) frames); */
 750
 751             if (u->memchunk.length <= 0)
 752                 pa_sink_render(u->sink, n_bytes, &u->memchunk);
 753
 754             pa_assert(u->memchunk.length > 0);
 755
 756             frames = (snd_pcm_sframes_t) (u->memchunk.length / u->frame_size);
 757
 758             if (frames > (snd_pcm_sframes_t) (n_bytes/u->frame_size))
 759                 frames = (snd_pcm_sframes_t) (n_bytes/u->frame_size);
 760
 761             p = pa_memblock_acquire(u->memchunk.memblock);
 762             frames = snd_pcm_writei(u->pcm_handle, (const uint8_t*) p + u->memchunk.index, (snd_pcm_uframes_t) frames);
 763             pa_memblock_release(u->memchunk.memblock);
 764
 765             if (PA_UNLIKELY(frames < 0)) {
 766
 767                 if (!after_avail && (int) frames == -EAGAIN)
 768                     break;
 769
 770                 if ((r = try_recover(u, "snd_pcm_writei", (int) frames)) == 0)
 771                     continue;
 772
 773                 return r;
 774             }
 775
 776             if (!after_avail && frames == 0)
 777                 break;
 778
 779             pa_assert(frames > 0);
 780             after_avail = FALSE;
 781
 782             u->memchunk.index += (size_t) frames * u->frame_size;
 783             u->memchunk.length -= (size_t) frames * u->frame_size;
 784
 785             if (u->memchunk.length <= 0) {
 786                 pa_memblock_unref(u->memchunk.memblock);
 787                 pa_memchunk_reset(&u->memchunk);
 788             }
 789
 790             work_done = TRUE;
 791
 792             u->write_count += frames * u->frame_size;
 793             u->since_start += frames * u->frame_size;
 794
 795 /*         pa_log_debug("wrote %lu frames", (unsigned long) frames); */
 796
 797             if ((size_t) frames * u->frame_size >= n_bytes)
 798                 break;
 799
 800             n_bytes -= (size_t) frames * u->frame_size;
 801         }
 802     }
 803
 804     if (u->use_tsched) {
 805         *sleep_usec = pa_bytes_to_usec(left_to_play, &u->sink->sample_spec);
 806         process_usec = pa_bytes_to_usec(u->tsched_watermark, &u->sink->sample_spec);
 807
 808         if (*sleep_usec > process_usec)
 809             *sleep_usec -= process_usec;
 810         else
 811             *sleep_usec = 0;
 812     } else
 813         *sleep_usec = 0;
 814
 815     return work_done ? 1 : 0;
 816 }
 817
 818 static void update_smoother(struct userdata *u) {
 819     snd_pcm_sframes_t delay = 0;
 820     int64_t position;
 821     int err;
 822     pa_usec_t now1 = 0, now2;
 823     snd_pcm_status_t *status;
 824
 825     snd_pcm_status_alloca(&status);
 826
 827     pa_assert(u);
 828     pa_assert(u->pcm_handle);
 829
 830     /* Let's update the time smoother */
 831
 832     if (PA_UNLIKELY((err = pa_alsa_safe_delay(u->pcm_handle, &delay, u->hwbuf_size, &u->sink->sample_spec, FALSE)) < 0)) {
 833         pa_log_warn("Failed to query DSP status data: %s", pa_alsa_strerror(err));
 834         return;
 835     }
 836
 837     if (PA_UNLIKELY((err = snd_pcm_status(u->pcm_handle, status)) < 0))
 838         pa_log_warn("Failed to get timestamp: %s", pa_alsa_strerror(err));
 839     else {
 840         snd_htimestamp_t htstamp = { 0, 0 };
 841         snd_pcm_status_get_htstamp(status, &htstamp);
 842         now1 = pa_timespec_load(&htstamp);
 843     }
 844
 845     /* Hmm, if the timestamp is 0, then it wasn't set and we take the current time */
 846     if (now1 <= 0)
 847         now1 = pa_rtclock_now();
 848
 849     /* check if the time since the last update is bigger than the interval */
 850     if (u->last_smoother_update > 0)
 851         if (u->last_smoother_update + u->smoother_interval > now1)
 852             return;
 853
 854     position = (int64_t) u->write_count - ((int64_t) delay * (int64_t) u->frame_size);
 855
 856     if (PA_UNLIKELY(position < 0))
 857         position = 0;
 858
 859     now2 = pa_bytes_to_usec((uint64_t) position, &u->sink->sample_spec);
 860
 861     pa_smoother_put(u->smoother, now1, now2);
 862
 863     u->last_smoother_update = now1;
 864     /* exponentially increase the update interval up to the MAX limit */
 865     u->smoother_interval = PA_MIN (u->smoother_interval * 2, SMOOTHER_MAX_INTERVAL);
 866 }
 867
 868 static pa_usec_t sink_get_latency(struct userdata *u) {
 869     pa_usec_t r;
 870     int64_t delay;
 871     pa_usec_t now1, now2;
 872
 873     pa_assert(u);
 874
 875     now1 = pa_rtclock_now();
 876     now2 = pa_smoother_get(u->smoother, now1);
 877
 878     delay = (int64_t) pa_bytes_to_usec(u->write_count, &u->sink->sample_spec) - (int64_t) now2;
 879
 880     r = delay >= 0 ? (pa_usec_t) delay : 0;
 881
 882     if (u->memchunk.memblock)
 883         r += pa_bytes_to_usec(u->memchunk.length, &u->sink->sample_spec);
 884
 885     return r;
 886 }
 887
 888 static int build_pollfd(struct userdata *u) {
 889     pa_assert(u);
 890     pa_assert(u->pcm_handle);
 891
 892     if (u->alsa_rtpoll_item)
 893         pa_rtpoll_item_free(u->alsa_rtpoll_item);
 894
 895     if (!(u->alsa_rtpoll_item = pa_alsa_build_pollfd(u->pcm_handle, u->rtpoll)))
 896         return -1;
 897
 898     return 0;
 899 }
 900
 901 /* Called from IO context */
 902 static int suspend(struct userdata *u) {
 903     pa_assert(u);
 904     pa_assert(u->pcm_handle);
 905
 906     pa_smoother_pause(u->smoother, pa_rtclock_now());
 907
 908     /* Let's suspend -- we don't call snd_pcm_drain() here since that might
 909      * take awfully long with our long buffer sizes today. */
 910     snd_pcm_close(u->pcm_handle);
 911     u->pcm_handle = NULL;
 912
 913     if (u->alsa_rtpoll_item) {
 914         pa_rtpoll_item_free(u->alsa_rtpoll_item);
 915         u->alsa_rtpoll_item = NULL;
 916     }
 917
 918     /* We reset max_rewind/max_request here to make sure that while we
 919      * are suspended the old max_request/max_rewind values set before
 920      * the suspend can influence the per-stream buffer of newly
 921      * created streams, without their requirements having any
 922      * influence on them. */
 923     pa_sink_set_max_rewind_within_thread(u->sink, 0);
 924     pa_sink_set_max_request_within_thread(u->sink, 0);
 925
 926     pa_log_info("Device suspended...");
 927
 928     return 0;
 929 }
 930
 931 /* Called from IO context */
 932 static int update_sw_params(struct userdata *u) {
 933     snd_pcm_uframes_t avail_min;
 934     int err;
 935
 936     pa_assert(u);
 937
 938     /* Use the full buffer if no one asked us for anything specific */
 939     u->hwbuf_unused = 0;
 940
 941     if (u->use_tsched) {
 942         pa_usec_t latency;
 943
 944         if ((latency = pa_sink_get_requested_latency_within_thread(u->sink)) != (pa_usec_t) -1) {
 945             size_t b;
 946
 947             pa_log_debug("Latency set to %0.2fms", (double) latency / PA_USEC_PER_MSEC);
 948
 949             b = pa_usec_to_bytes(latency, &u->sink->sample_spec);
 950
 951             /* We need at least one sample in our buffer */
 952
 953             if (PA_UNLIKELY(b < u->frame_size))
 954                 b = u->frame_size;
 955
 956             u->hwbuf_unused = PA_LIKELY(b < u->hwbuf_size) ? (u->hwbuf_size - b) : 0;
 957         }
 958
 959         fix_min_sleep_wakeup(u);
 960         fix_tsched_watermark(u);
 961     }
 962
 963     pa_log_debug("hwbuf_unused=%lu", (unsigned long) u->hwbuf_unused);
 964
 965     /* We need at last one frame in the used part of the buffer */
 966     avail_min = (snd_pcm_uframes_t) u->hwbuf_unused / u->frame_size + 1;
 967
 968     if (u->use_tsched) {
 969         pa_usec_t sleep_usec, process_usec;
 970
 971         hw_sleep_time(u, &sleep_usec, &process_usec);
 972         avail_min += pa_usec_to_bytes(sleep_usec, &u->sink->sample_spec) / u->frame_size;
 973     }
 974
 975     pa_log_debug("setting avail_min=%lu", (unsigned long) avail_min);
 976
 977     if ((err = pa_alsa_set_sw_params(u->pcm_handle, avail_min, !u->use_tsched)) < 0) {
 978         pa_log("Failed to set software parameters: %s", pa_alsa_strerror(err));
 979         return err;
 980     }
 981
 982     pa_sink_set_max_request_within_thread(u->sink, u->hwbuf_size - u->hwbuf_unused);
 983      if (pa_alsa_pcm_is_hw(u->pcm_handle))
 984          pa_sink_set_max_rewind_within_thread(u->sink, u->hwbuf_size);
 985     else {
 986         pa_log_info("Disabling rewind_within_thread for device %s", u->device_name);
 987         pa_sink_set_max_rewind_within_thread(u->sink, 0);
 988     }
 989
 990     return 0;
 991 }
 992
 993 /* Called from IO Context on unsuspend or from main thread when creating sink */
 994 static void reset_watermark(struct userdata *u, size_t tsched_watermark, pa_sample_spec *ss,
 995                             pa_bool_t in_thread)
 996 {
 997     u->tsched_watermark = pa_usec_to_bytes_round_up(pa_bytes_to_usec_round_up(tsched_watermark, ss),
 998                                                     &u->sink->sample_spec);
 999
1000     u->watermark_inc_step = pa_usec_to_bytes(TSCHED_WATERMARK_INC_STEP_USEC, &u->sink->sample_spec);
1001     u->watermark_dec_step = pa_usec_to_bytes(TSCHED_WATERMARK_DEC_STEP_USEC, &u->sink->sample_spec);
1002
1003     u->watermark_inc_threshold = pa_usec_to_bytes_round_up(TSCHED_WATERMARK_INC_THRESHOLD_USEC, &u->sink->sample_spec);
1004     u->watermark_dec_threshold = pa_usec_to_bytes_round_up(TSCHED_WATERMARK_DEC_THRESHOLD_USEC, &u->sink->sample_spec);
1005
1006     fix_min_sleep_wakeup(u);
1007     fix_tsched_watermark(u);
1008
1009     if (in_thread)
1010         pa_sink_set_latency_range_within_thread(u->sink,
1011                                                 u->min_latency_ref,
1012                                                 pa_bytes_to_usec(u->hwbuf_size, ss));
1013     else {
1014         pa_sink_set_latency_range(u->sink,
1015                                   0,
1016                                   pa_bytes_to_usec(u->hwbuf_size, ss));
1017
1018         /* work-around assert in pa_sink_set_latency_within_thead,
1019            keep track of min_latency and reuse it when
1020            this routine is called from IO context */
1021         u->min_latency_ref = u->sink->thread_info.min_latency;
1022     }
1023
1024     pa_log_info("Time scheduling watermark is %0.2fms",
1025                 (double) pa_bytes_to_usec(u->tsched_watermark, ss) / PA_USEC_PER_MSEC);
1026 }
1027
1028 /* Called from IO context */
1029 static int unsuspend(struct userdata *u) {
1030     pa_sample_spec ss;
1031     int err;
1032     pa_bool_t b, d;
1033     snd_pcm_uframes_t period_size, buffer_size;
1034     char *device_name = NULL;
1035
1036     pa_assert(u);
1037     pa_assert(!u->pcm_handle);
1038
1039     pa_log_info("Trying resume...");
1040
1041     if ((is_iec958(u) || is_hdmi(u)) && pa_sink_is_passthrough(u->sink)) {
1042         /* Need to open device in NONAUDIO mode */
1043         int len = strlen(u->device_name) + 8;
1044
1045         device_name = pa_xmalloc(len);
1046         pa_snprintf(device_name, len, "%s,AES0=6", u->device_name);
1047     }
1048
1049     if ((err = snd_pcm_open(&u->pcm_handle, device_name ? device_name : u->device_name, SND_PCM_STREAM_PLAYBACK,
1050                             SND_PCM_NONBLOCK|
1051                             SND_PCM_NO_AUTO_RESAMPLE|
1052                             SND_PCM_NO_AUTO_CHANNELS|
1053                             SND_PCM_NO_AUTO_FORMAT)) < 0) {
1054         pa_log("Error opening PCM device %s: %s", u->device_name, pa_alsa_strerror(err));
1055         goto fail;
1056     }
1057
1058     ss = u->sink->sample_spec;
1059     period_size = u->fragment_size / u->frame_size;
1060     buffer_size = u->hwbuf_size / u->frame_size;
1061     b = u->use_mmap;
1062     d = u->use_tsched;
1063
1064     if ((err = pa_alsa_set_hw_params(u->pcm_handle, &ss, &period_size, &buffer_size, 0, &b, &d, TRUE)) < 0) {
1065         pa_log("Failed to set hardware parameters: %s", pa_alsa_strerror(err));
1066         goto fail;
1067     }
1068
1069     if (b != u->use_mmap || d != u->use_tsched) {
1070         pa_log_warn("Resume failed, couldn't get original access mode.");
1071         goto fail;
1072     }
1073
1074     if (!pa_sample_spec_equal(&ss, &u->sink->sample_spec)) {
1075         pa_log_warn("Resume failed, couldn't restore original sample settings.");
1076         goto fail;
1077     }
1078
1079     if (period_size*u->frame_size != u->fragment_size ||
1080         buffer_size*u->frame_size != u->hwbuf_size) {
1081         pa_log_warn("Resume failed, couldn't restore original fragment settings. (Old: %lu/%lu, New %lu/%lu)",
1082                     (unsigned long) u->hwbuf_size, (unsigned long) u->fragment_size,
1083                     (unsigned long) (buffer_size*u->frame_size), (unsigned long) (period_size*u->frame_size));
1084         goto fail;
1085     }
1086
1087     if (update_sw_params(u) < 0)
1088         goto fail;
1089
1090     if (build_pollfd(u) < 0)
1091         goto fail;
1092
1093     u->write_count = 0;
1094     pa_smoother_reset(u->smoother, pa_rtclock_now(), TRUE);
1095     u->smoother_interval = SMOOTHER_MIN_INTERVAL;
1096     u->last_smoother_update = 0;
1097
1098     u->first = TRUE;
1099     u->since_start = 0;
1100
1101     /* reset the watermark to the value defined when sink was created */
1102     if (u->use_tsched)
1103         reset_watermark(u, u->tsched_watermark_ref, &u->sink->sample_spec, TRUE);
1104
1105     pa_log_info("Resumed successfully...");
1106
1107     pa_xfree(device_name);
1108     return 0;
1109
1110 fail:
1111     if (u->pcm_handle) {
1112         snd_pcm_close(u->pcm_handle);
1113         u->pcm_handle = NULL;
1114     }
1115
1116     pa_xfree(device_name);
1117
1118     return -PA_ERR_IO;
1119 }
1120
1121 /* Called from IO context */
1122 static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
1123     struct userdata *u = PA_SINK(o)->userdata;
1124
1125     switch (code) {
1126
1127         case PA_SINK_MESSAGE_GET_LATENCY: {
1128             pa_usec_t r = 0;
1129
1130             if (u->pcm_handle)
1131                 r = sink_get_latency(u);
1132
1133             *((pa_usec_t*) data) = r;
1134
1135             return 0;
1136         }
1137
1138         case PA_SINK_MESSAGE_SET_STATE:
1139
1140             switch ((pa_sink_state_t) PA_PTR_TO_UINT(data)) {
1141
1142                 case PA_SINK_SUSPENDED: {
1143                     int r;
1144
1145                     pa_assert(PA_SINK_IS_OPENED(u->sink->thread_info.state));
1146
1147                     if ((r = suspend(u)) < 0)
1148                         return r;
1149
1150                     break;
1151                 }
1152
1153                 case PA_SINK_IDLE:
1154                 case PA_SINK_RUNNING: {
1155                     int r;
1156
1157                     if (u->sink->thread_info.state == PA_SINK_INIT) {
1158                         if (build_pollfd(u) < 0)
1159                             return -PA_ERR_IO;
1160                     }
1161
1162                     if (u->sink->thread_info.state == PA_SINK_SUSPENDED) {
1163                         if ((r = unsuspend(u)) < 0)
1164                             return r;
1165                     }
1166
1167                     break;
1168                 }
1169
1170                 case PA_SINK_UNLINKED:
1171                 case PA_SINK_INIT:
1172                 case PA_SINK_INVALID_STATE:
1173                     ;
1174             }
1175
1176             break;
1177     }
1178
1179     return pa_sink_process_msg(o, code, data, offset, chunk);
1180 }
1181
1182 /* Called from main context */
1183 static int sink_set_state_cb(pa_sink *s, pa_sink_state_t new_state) {
1184     pa_sink_state_t old_state;
1185     struct userdata *u;
1186
1187     pa_sink_assert_ref(s);
1188     pa_assert_se(u = s->userdata);
1189
1190     old_state = pa_sink_get_state(u->sink);
1191
1192     if (PA_SINK_IS_OPENED(old_state) && new_state == PA_SINK_SUSPENDED)
1193         reserve_done(u);
1194     else if (old_state == PA_SINK_SUSPENDED && PA_SINK_IS_OPENED(new_state))
1195         if (reserve_init(u, u->device_name) < 0)
1196             return -PA_ERR_BUSY;
1197
1198     return 0;
1199 }
1200
1201 static int ctl_mixer_callback(snd_mixer_elem_t *elem, unsigned int mask) {
1202     struct userdata *u = snd_mixer_elem_get_callback_private(elem);
1203
1204     pa_assert(u);
1205     pa_assert(u->mixer_handle);
1206
1207     if (mask == SND_CTL_EVENT_MASK_REMOVE)
1208         return 0;
1209
1210     if (!PA_SINK_IS_LINKED(u->sink->state))
1211         return 0;
1212
1213     if (u->sink->suspend_cause & PA_SUSPEND_SESSION)
1214         return 0;
1215
1216     if (mask & SND_CTL_EVENT_MASK_VALUE) {
1217         pa_sink_get_volume(u->sink, TRUE);
1218         pa_sink_get_mute(u->sink, TRUE);
1219     }
1220
1221     return 0;
1222 }
1223
1224 static int io_mixer_callback(snd_mixer_elem_t *elem, unsigned int mask) {
1225     struct userdata *u = snd_mixer_elem_get_callback_private(elem);
1226
1227     pa_assert(u);
1228     pa_assert(u->mixer_handle);
1229
1230     if (mask == SND_CTL_EVENT_MASK_REMOVE)
1231         return 0;
1232
1233     if (u->sink->suspend_cause & PA_SUSPEND_SESSION)
1234         return 0;
1235
1236     if (mask & SND_CTL_EVENT_MASK_VALUE)
1237         pa_sink_update_volume_and_mute(u->sink);
1238
1239     return 0;
1240 }
1241
1242 static void sink_get_volume_cb(pa_sink *s) {
1243     struct userdata *u = s->userdata;
1244     pa_cvolume r;
1245     char vol_str_pcnt[PA_CVOLUME_SNPRINT_MAX];
1246
1247     pa_assert(u);
1248     pa_assert(u->mixer_path);
1249     pa_assert(u->mixer_handle);
1250
1251     if (pa_alsa_path_get_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r) < 0)
1252         return;
1253
1254     /* Shift down by the base volume, so that 0dB becomes maximum volume */
1255     pa_sw_cvolume_multiply_scalar(&r, &r, s->base_volume);
1256
1257     pa_log_debug("Read hardware volume: %s", pa_cvolume_snprint(vol_str_pcnt, sizeof(vol_str_pcnt), &r));
1258
1259     if (u->mixer_path->has_dB) {
1260         char vol_str_db[PA_SW_CVOLUME_SNPRINT_DB_MAX];
1261
1262         pa_log_debug("               in dB: %s", pa_sw_cvolume_snprint_dB(vol_str_db, sizeof(vol_str_db), &r));
1263     }
1264
1265     if (pa_cvolume_equal(&u->hardware_volume, &r))
1266         return;
1267
1268     s->real_volume = u->hardware_volume = r;
1269
1270     /* Hmm, so the hardware volume changed, let's reset our software volume */
1271     if (u->mixer_path->has_dB)
1272         pa_sink_set_soft_volume(s, NULL);
1273 }
1274
1275 static void sink_set_volume_cb(pa_sink *s) {
1276     struct userdata *u = s->userdata;
1277     pa_cvolume r;
1278     char vol_str_pcnt[PA_CVOLUME_SNPRINT_MAX];
1279     pa_bool_t deferred_volume = !!(s->flags & PA_SINK_DEFERRED_VOLUME);
1280
1281     pa_assert(u);
1282     pa_assert(u->mixer_path);
1283     pa_assert(u->mixer_handle);
1284
1285     /* Shift up by the base volume */
1286     pa_sw_cvolume_divide_scalar(&r, &s->real_volume, s->base_volume);
1287
1288     if (pa_alsa_path_set_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r, deferred_volume, !deferred_volume) < 0)
1289         return;
1290
1291     /* Shift down by the base volume, so that 0dB becomes maximum volume */
1292     pa_sw_cvolume_multiply_scalar(&r, &r, s->base_volume);
1293
1294     u->hardware_volume = r;
1295
1296     if (u->mixer_path->has_dB) {
1297         pa_cvolume new_soft_volume;
1298         pa_bool_t accurate_enough;
1299         char vol_str_db[PA_SW_CVOLUME_SNPRINT_DB_MAX];
1300
1301         /* Match exactly what the user requested by software */
1302         pa_sw_cvolume_divide(&new_soft_volume, &s->real_volume, &u->hardware_volume);
1303
1304         /* If the adjustment to do in software is only minimal we
1305          * can skip it. That saves us CPU at the expense of a bit of
1306          * accuracy */
1307         accurate_enough =
1308             (pa_cvolume_min(&new_soft_volume) >= (PA_VOLUME_NORM - VOLUME_ACCURACY)) &&
1309             (pa_cvolume_max(&new_soft_volume) <= (PA_VOLUME_NORM + VOLUME_ACCURACY));
1310
1311         pa_log_debug("Requested volume: %s", pa_cvolume_snprint(vol_str_pcnt, sizeof(vol_str_pcnt), &s->real_volume));
1312         pa_log_debug("           in dB: %s", pa_sw_cvolume_snprint_dB(vol_str_db, sizeof(vol_str_db), &s->real_volume));
1313         pa_log_debug("Got hardware volume: %s", pa_cvolume_snprint(vol_str_pcnt, sizeof(vol_str_pcnt), &u->hardware_volume));
1314         pa_log_debug("              in dB: %s", pa_sw_cvolume_snprint_dB(vol_str_db, sizeof(vol_str_db), &u->hardware_volume));
1315         pa_log_debug("Calculated software volume: %s (accurate-enough=%s)",
1316                      pa_cvolume_snprint(vol_str_pcnt, sizeof(vol_str_pcnt), &new_soft_volume),
1317                      pa_yes_no(accurate_enough));
1318         pa_log_debug("                     in dB: %s", pa_sw_cvolume_snprint_dB(vol_str_db, sizeof(vol_str_db), &new_soft_volume));
1319
1320         if (!accurate_enough)
1321             s->soft_volume = new_soft_volume;
1322
1323     } else {
1324         pa_log_debug("Wrote hardware volume: %s", pa_cvolume_snprint(vol_str_pcnt, sizeof(vol_str_pcnt), &r));
1325
1326         /* We can't match exactly what the user requested, hence let's
1327          * at least tell the user about it */
1328
1329         s->real_volume = r;
1330     }
1331 }
1332
1333 static void sink_write_volume_cb(pa_sink *s) {
1334     struct userdata *u = s->userdata;
1335     pa_cvolume hw_vol = s->thread_info.current_hw_volume;
1336
1337     pa_assert(u);
1338     pa_assert(u->mixer_path);
1339     pa_assert(u->mixer_handle);
1340     pa_assert(s->flags & PA_SINK_DEFERRED_VOLUME);
1341
1342     /* Shift up by the base volume */
1343     pa_sw_cvolume_divide_scalar(&hw_vol, &hw_vol, s->base_volume);
1344
1345     if (pa_alsa_path_set_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &hw_vol, TRUE, TRUE) < 0)
1346         pa_log_error("Writing HW volume failed");
1347     else {
1348         pa_cvolume tmp_vol;
1349         pa_bool_t accurate_enough;
1350
1351         /* Shift down by the base volume, so that 0dB becomes maximum volume */
1352         pa_sw_cvolume_multiply_scalar(&hw_vol, &hw_vol, s->base_volume);
1353
1354         pa_sw_cvolume_divide(&tmp_vol, &hw_vol, &s->thread_info.current_hw_volume);
1355         accurate_enough =
1356             (pa_cvolume_min(&tmp_vol) >= (PA_VOLUME_NORM - VOLUME_ACCURACY)) &&
1357             (pa_cvolume_max(&tmp_vol) <= (PA_VOLUME_NORM + VOLUME_ACCURACY));
1358
1359         if (!accurate_enough) {
1360             union {
1361                 char db[2][PA_SW_CVOLUME_SNPRINT_DB_MAX];
1362                 char pcnt[2][PA_CVOLUME_SNPRINT_MAX];
1363             } vol;
1364
1365             pa_log_debug("Written HW volume did not match with the request: %s (request) != %s",
1366                          pa_cvolume_snprint(vol.pcnt[0], sizeof(vol.pcnt[0]), &s->thread_info.current_hw_volume),
1367                          pa_cvolume_snprint(vol.pcnt[1], sizeof(vol.pcnt[1]), &hw_vol));
1368             pa_log_debug("                                           in dB: %s (request) != %s",
1369                          pa_sw_cvolume_snprint_dB(vol.db[0], sizeof(vol.db[0]), &s->thread_info.current_hw_volume),
1370                          pa_sw_cvolume_snprint_dB(vol.db[1], sizeof(vol.db[1]), &hw_vol));
1371         }
1372     }
1373 }
1374
1375 static void sink_get_mute_cb(pa_sink *s) {
1376     struct userdata *u = s->userdata;
1377     pa_bool_t b;
1378
1379     pa_assert(u);
1380     pa_assert(u->mixer_path);
1381     pa_assert(u->mixer_handle);
1382
1383     if (pa_alsa_path_get_mute(u->mixer_path, u->mixer_handle, &b) < 0)
1384         return;
1385
1386     s->muted = b;
1387 }
1388
1389 static void sink_set_mute_cb(pa_sink *s) {
1390     struct userdata *u = s->userdata;
1391
1392     pa_assert(u);
1393     pa_assert(u->mixer_path);
1394     pa_assert(u->mixer_handle);
1395
1396     pa_alsa_path_set_mute(u->mixer_path, u->mixer_handle, s->muted);
1397 }
1398
1399 static void mixer_volume_init(struct userdata *u) {
1400     pa_assert(u);
1401
1402     if (!u->mixer_path->has_volume) {
1403         pa_sink_set_write_volume_callback(u->sink, NULL);
1404         pa_sink_set_get_volume_callback(u->sink, NULL);
1405         pa_sink_set_set_volume_callback(u->sink, NULL);
1406
1407         pa_log_info("Driver does not support hardware volume control, falling back to software volume control.");
1408     } else {
1409         pa_sink_set_get_volume_callback(u->sink, sink_get_volume_cb);
1410         pa_sink_set_set_volume_callback(u->sink, sink_set_volume_cb);
1411
1412         if (u->mixer_path->has_dB && u->deferred_volume) {
1413             pa_sink_set_write_volume_callback(u->sink, sink_write_volume_cb);
1414             pa_log_info("Successfully enabled deferred volume.");
1415         } else
1416             pa_sink_set_write_volume_callback(u->sink, NULL);
1417
1418         if (u->mixer_path->has_dB) {
1419             pa_sink_enable_decibel_volume(u->sink, TRUE);
1420             pa_log_info("Hardware volume ranges from %0.2f dB to %0.2f dB.", u->mixer_path->min_dB, u->mixer_path->max_dB);
1421
1422             u->sink->base_volume = pa_sw_volume_from_dB(-u->mixer_path->max_dB);
1423             u->sink->n_volume_steps = PA_VOLUME_NORM+1;
1424
1425             pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(u->sink->base_volume));
1426         } else {
1427             pa_sink_enable_decibel_volume(u->sink, FALSE);
1428             pa_log_info("Hardware volume ranges from %li to %li.", u->mixer_path->min_volume, u->mixer_path->max_volume);
1429
1430             u->sink->base_volume = PA_VOLUME_NORM;
1431             u->sink->n_volume_steps = u->mixer_path->max_volume - u->mixer_path->min_volume + 1;
1432         }
1433
1434         pa_log_info("Using hardware volume control. Hardware dB scale %s.", u->mixer_path->has_dB ? "supported" : "not supported");
1435     }
1436
1437     if (!u->mixer_path->has_mute) {
1438         pa_sink_set_get_mute_callback(u->sink, NULL);
1439         pa_sink_set_set_mute_callback(u->sink, NULL);
1440         pa_log_info("Driver does not support hardware mute control, falling back to software mute control.");
1441     } else {
1442         pa_sink_set_get_mute_callback(u->sink, sink_get_mute_cb);
1443         pa_sink_set_set_mute_callback(u->sink, sink_set_mute_cb);
1444         pa_log_info("Using hardware mute control.");
1445     }
1446 }
1447
1448 static int sink_set_port_cb(pa_sink *s, pa_device_port *p) {
1449     struct userdata *u = s->userdata;
1450     pa_alsa_port_data *data;
1451
1452     pa_assert(u);
1453     pa_assert(p);
1454     pa_assert(u->mixer_handle);
1455
1456     data = PA_DEVICE_PORT_DATA(p);
1457
1458     pa_assert_se(u->mixer_path = data->path);
1459     pa_alsa_path_select(u->mixer_path, u->mixer_handle);
1460
1461     mixer_volume_init(u);
1462
1463     if (data->setting)
1464         pa_alsa_setting_select(data->setting, u->mixer_handle);
1465
1466     if (s->set_mute)
1467         s->set_mute(s);
1468     if (s->flags & PA_SINK_DEFERRED_VOLUME) {
1469         if (s->write_volume)
1470             s->write_volume(s);
1471     } else {
1472         if (s->set_volume)
1473             s->set_volume(s);
1474     }
1475
1476     return 0;
1477 }
1478
1479 static void sink_update_requested_latency_cb(pa_sink *s) {
1480     struct userdata *u = s->userdata;
1481     size_t before;
1482     pa_assert(u);
1483     pa_assert(u->use_tsched); /* only when timer scheduling is used
1484                                * we can dynamically adjust the
1485                                * latency */
1486
1487     if (!u->pcm_handle)
1488         return;
1489
1490     before = u->hwbuf_unused;
1491     update_sw_params(u);
1492
1493     /* Let's check whether we now use only a smaller part of the
1494     buffer then before. If so, we need to make sure that subsequent
1495     rewinds are relative to the new maximum fill level and not to the
1496     current fill level. Thus, let's do a full rewind once, to clear
1497     things up. */
1498
1499     if (u->hwbuf_unused > before) {
1500         pa_log_debug("Requesting rewind due to latency change.");
1501         pa_sink_request_rewind(s, (size_t) -1);
1502     }
1503 }
1504
1505 static pa_idxset* sink_get_formats(pa_sink *s) {
1506     struct userdata *u = s->userdata;
1507     pa_idxset *ret = pa_idxset_new(NULL, NULL);
1508     pa_format_info *f;
1509     uint32_t idx;
1510
1511     pa_assert(u);
1512
1513     PA_IDXSET_FOREACH(f, u->formats, idx) {
1514         pa_idxset_put(ret, pa_format_info_copy(f), NULL);
1515     }
1516
1517     return ret;
1518 }
1519
1520 static pa_bool_t sink_set_formats(pa_sink *s, pa_idxset *formats) {
1521     struct userdata *u = s->userdata;
1522     pa_format_info *f, *g;
1523     uint32_t idx, n;
1524
1525     pa_assert(u);
1526
1527     /* FIXME: also validate sample rates against what the device supports */
1528     PA_IDXSET_FOREACH(f, formats, idx) {
1529         if (is_iec958(u) && f->encoding == PA_ENCODING_EAC3_IEC61937)
1530             /* EAC3 cannot be sent over over S/PDIF */
1531             return FALSE;
1532     }
1533
1534     pa_idxset_free(u->formats, (pa_free2_cb_t) pa_format_info_free2, NULL);
1535     u->formats = pa_idxset_new(NULL, NULL);
1536
1537     /* Note: the logic below won't apply if we're using software encoding.
1538      * This is fine for now since we don't support that via the passthrough
1539      * framework, but this must be changed if we do. */
1540
1541     /* Count how many sample rates we support */
1542     for (idx = 0, n = 0; u->rates[idx]; idx++)
1543         n++;
1544
1545     /* First insert non-PCM formats since we prefer those. */
1546     PA_IDXSET_FOREACH(f, formats, idx) {
1547         if (!pa_format_info_is_pcm(f)) {
1548             g = pa_format_info_copy(f);
1549             pa_format_info_set_prop_int_array(g, PA_PROP_FORMAT_RATE, (int *) u->rates, n);
1550             pa_idxset_put(u->formats, g, NULL);
1551         }
1552     }
1553
1554     /* Now add any PCM formats */
1555     PA_IDXSET_FOREACH(f, formats, idx) {
1556         if (pa_format_info_is_pcm(f)) {
1557             /* We don't set rates here since we'll just tack on a resampler for
1558              * unsupported rates */
1559             pa_idxset_put(u->formats, pa_format_info_copy(f), NULL);
1560         }
1561     }
1562
1563     return TRUE;
1564 }
1565
1566 static pa_bool_t sink_update_rate_cb(pa_sink *s, uint32_t rate)
1567 {
1568     struct userdata *u = s->userdata;
1569     int i;
1570     pa_bool_t supported = FALSE;
1571
1572     pa_assert(u);
1573
1574     for (i = 0; u->rates[i]; i++) {
1575         if (u->rates[i] == rate) {
1576             supported = TRUE;
1577             break;
1578         }
1579     }
1580
1581     if (!supported) {
1582         pa_log_info("Sink does not support sample rate of %d Hz", rate);
1583         return FALSE;
1584     }
1585
1586     if (!PA_SINK_IS_OPENED(s->state)) {
1587         pa_log_info("Updating rate for device %s, new rate is %d",u->device_name, rate);
1588         u->sink->sample_spec.rate = rate;
1589         return TRUE;
1590     }
1591
1592     return FALSE;
1593 }
1594
1595 static int process_rewind(struct userdata *u) {
1596     snd_pcm_sframes_t unused;
1597     size_t rewind_nbytes, unused_nbytes, limit_nbytes;
1598     pa_assert(u);
1599
1600     /* Figure out how much we shall rewind and reset the counter */
1601     rewind_nbytes = u->sink->thread_info.rewind_nbytes;
1602
1603     pa_log_debug("Requested to rewind %lu bytes.", (unsigned long) rewind_nbytes);
1604
1605     if (PA_UNLIKELY((unused = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->sink->sample_spec)) < 0)) {
1606         pa_log("snd_pcm_avail() failed: %s", pa_alsa_strerror((int) unused));
1607         return -1;
1608     }
1609
1610     unused_nbytes = (size_t) unused * u->frame_size;
1611
1612     /* make sure rewind doesn't go too far, can cause issues with DMAs */
1613     unused_nbytes += u->rewind_safeguard;
1614
1615     if (u->hwbuf_size > unused_nbytes)
1616         limit_nbytes = u->hwbuf_size - unused_nbytes;
1617     else
1618         limit_nbytes = 0;
1619
1620     if (rewind_nbytes > limit_nbytes)
1621         rewind_nbytes = limit_nbytes;
1622
1623     if (rewind_nbytes > 0) {
1624         snd_pcm_sframes_t in_frames, out_frames;
1625
1626         pa_log_debug("Limited to %lu bytes.", (unsigned long) rewind_nbytes);
1627
1628         in_frames = (snd_pcm_sframes_t) (rewind_nbytes / u->frame_size);
1629         pa_log_debug("before: %lu", (unsigned long) in_frames);
1630         if ((out_frames = snd_pcm_rewind(u->pcm_handle, (snd_pcm_uframes_t) in_frames)) < 0) {
1631             pa_log("snd_pcm_rewind() failed: %s", pa_alsa_strerror((int) out_frames));
1632             if (try_recover(u, "process_rewind", out_frames) < 0)
1633                 return -1;
1634             out_frames = 0;
1635         }
1636
1637         pa_log_debug("after: %lu", (unsigned long) out_frames);
1638
1639         rewind_nbytes = (size_t) out_frames * u->frame_size;
1640
1641         if (rewind_nbytes <= 0)
1642             pa_log_info("Tried rewind, but was apparently not possible.");
1643         else {
1644             u->write_count -= rewind_nbytes;
1645             pa_log_debug("Rewound %lu bytes.", (unsigned long) rewind_nbytes);
1646             pa_sink_process_rewind(u->sink, rewind_nbytes);
1647
1648             u->after_rewind = TRUE;
1649             return 0;
1650         }
1651     } else
1652         pa_log_debug("Mhmm, actually there is nothing to rewind.");
1653
1654     pa_sink_process_rewind(u->sink, 0);
1655     return 0;
1656 }
1657
1658 static void thread_func(void *userdata) {
1659     struct userdata *u = userdata;
1660     unsigned short revents = 0;
1661
1662     pa_assert(u);
1663
1664     pa_log_debug("Thread starting up");
1665
1666     if (u->core->realtime_scheduling)
1667         pa_make_realtime(u->core->realtime_priority);
1668
1669     pa_thread_mq_install(&u->thread_mq);
1670
1671     for (;;) {
1672         int ret;
1673         pa_usec_t rtpoll_sleep = 0;
1674
1675 #ifdef DEBUG_TIMING
1676         pa_log_debug("Loop");
1677 #endif
1678
1679         /* Render some data and write it to the dsp */
1680         if (PA_SINK_IS_OPENED(u->sink->thread_info.state)) {
1681             int work_done;
1682             pa_usec_t sleep_usec = 0;
1683             pa_bool_t on_timeout = pa_rtpoll_timer_elapsed(u->rtpoll);
1684
1685             if (PA_UNLIKELY(u->sink->thread_info.rewind_requested))
1686                 if (process_rewind(u) < 0)
1687                         goto fail;
1688
1689             if (u->use_mmap)
1690                 work_done = mmap_write(u, &sleep_usec, revents & POLLOUT, on_timeout);
1691             else
1692                 work_done = unix_write(u, &sleep_usec, revents & POLLOUT, on_timeout);
1693
1694             if (work_done < 0)
1695                 goto fail;
1696
1697 /*             pa_log_debug("work_done = %i", work_done); */
1698
1699             if (work_done) {
1700
1701                 if (u->first) {
1702                     pa_log_info("Starting playback.");
1703                     snd_pcm_start(u->pcm_handle);
1704
1705                     pa_smoother_resume(u->smoother, pa_rtclock_now(), TRUE);
1706
1707                     u->first = FALSE;
1708                 }
1709
1710                 update_smoother(u);
1711             }
1712
1713             if (u->use_tsched) {
1714                 pa_usec_t cusec;
1715
1716                 if (u->since_start <= u->hwbuf_size) {
1717
1718                     /* USB devices on ALSA seem to hit a buffer
1719                      * underrun during the first iterations much
1720                      * quicker then we calculate here, probably due to
1721                      * the transport latency. To accommodate for that
1722                      * we artificially decrease the sleep time until
1723                      * we have filled the buffer at least once
1724                      * completely.*/
1725
1726                     if (pa_log_ratelimit(PA_LOG_DEBUG))
1727                         pa_log_debug("Cutting sleep time for the initial iterations by half.");
1728                     sleep_usec /= 2;
1729                 }
1730
1731                 /* OK, the playback buffer is now full, let's
1732                  * calculate when to wake up next */
1733 #ifdef DEBUG_TIMING
1734                 pa_log_debug("Waking up in %0.2fms (sound card clock).", (double) sleep_usec / PA_USEC_PER_MSEC);
1735 #endif
1736
1737                 /* Convert from the sound card time domain to the
1738                  * system time domain */
1739                 cusec = pa_smoother_translate(u->smoother, pa_rtclock_now(), sleep_usec);
1740
1741 #ifdef DEBUG_TIMING
1742                 pa_log_debug("Waking up in %0.2fms (system clock).", (double) cusec / PA_USEC_PER_MSEC);
1743 #endif
1744
1745                 /* We don't trust the conversion, so we wake up whatever comes first */
1746                 rtpoll_sleep = PA_MIN(sleep_usec, cusec);
1747             }
1748
1749             u->after_rewind = FALSE;
1750
1751         }
1752
1753         if (u->sink->flags & PA_SINK_DEFERRED_VOLUME) {
1754             pa_usec_t volume_sleep;
1755             pa_sink_volume_change_apply(u->sink, &volume_sleep);
1756             if (volume_sleep > 0) {
1757                 if (rtpoll_sleep > 0)
1758                     rtpoll_sleep = PA_MIN(volume_sleep, rtpoll_sleep);
1759                 else
1760                     rtpoll_sleep = volume_sleep;
1761             }
1762         }
1763
1764         if (rtpoll_sleep > 0)
1765             pa_rtpoll_set_timer_relative(u->rtpoll, rtpoll_sleep);
1766         else
1767             pa_rtpoll_set_timer_disabled(u->rtpoll);
1768
1769         /* Hmm, nothing to do. Let's sleep */
1770         if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
1771             goto fail;
1772
1773         if (u->sink->flags & PA_SINK_DEFERRED_VOLUME)
1774             pa_sink_volume_change_apply(u->sink, NULL);
1775
1776         if (ret == 0)
1777             goto finish;
1778
1779         /* Tell ALSA about this and process its response */
1780         if (PA_SINK_IS_OPENED(u->sink->thread_info.state)) {
1781             struct pollfd *pollfd;
1782             int err;
1783             unsigned n;
1784
1785             pollfd = pa_rtpoll_item_get_pollfd(u->alsa_rtpoll_item, &n);
1786
1787             if ((err = snd_pcm_poll_descriptors_revents(u->pcm_handle, pollfd, n, &revents)) < 0) {
1788                 pa_log("snd_pcm_poll_descriptors_revents() failed: %s", pa_alsa_strerror(err));
1789                 goto fail;
1790             }
1791
1792             if (revents & ~POLLOUT) {
1793                 if (pa_alsa_recover_from_poll(u->pcm_handle, revents) < 0)
1794                     goto fail;
1795
1796                 u->first = TRUE;
1797                 u->since_start = 0;
1798                 revents = 0;
1799             } else if (revents && u->use_tsched && pa_log_ratelimit(PA_LOG_DEBUG))
1800                 pa_log_debug("Wakeup from ALSA!");
1801
1802         } else
1803             revents = 0;
1804     }
1805
1806 fail:
1807     /* If this was no regular exit from the loop we have to continue
1808      * processing messages until we received PA_MESSAGE_SHUTDOWN */
1809     pa_asyncmsgq_post(u->thread_mq.outq, PA_MSGOBJECT(u->core), PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0, NULL, NULL);
1810     pa_asyncmsgq_wait_for(u->thread_mq.inq, PA_MESSAGE_SHUTDOWN);
1811
1812 finish:
1813     pa_log_debug("Thread shutting down");
1814 }
1815
1816 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) {
1817     const char *n;
1818     char *t;
1819
1820     pa_assert(data);
1821     pa_assert(ma);
1822     pa_assert(device_name);
1823
1824     if ((n = pa_modargs_get_value(ma, "sink_name", NULL))) {
1825         pa_sink_new_data_set_name(data, n);
1826         data->namereg_fail = TRUE;
1827         return;
1828     }
1829
1830     if ((n = pa_modargs_get_value(ma, "name", NULL)))
1831         data->namereg_fail = TRUE;
1832     else {
1833         n = device_id ? device_id : device_name;
1834         data->namereg_fail = FALSE;
1835     }
1836
1837     if (mapping)
1838         t = pa_sprintf_malloc("alsa_output.%s.%s", n, mapping->name);
1839     else
1840         t = pa_sprintf_malloc("alsa_output.%s", n);
1841
1842     pa_sink_new_data_set_name(data, t);
1843     pa_xfree(t);
1844 }
1845
1846 static void find_mixer(struct userdata *u, pa_alsa_mapping *mapping, const char *element, pa_bool_t ignore_dB) {
1847     snd_hctl_t *hctl;
1848
1849     if (!mapping && !element)
1850         return;
1851
1852     if (!(u->mixer_handle = pa_alsa_open_mixer_for_pcm(u->pcm_handle, &u->control_device, &hctl))) {
1853         pa_log_info("Failed to find a working mixer device.");
1854         return;
1855     }
1856
1857     if (element) {
1858
1859         if (!(u->mixer_path = pa_alsa_path_synthesize(element, PA_ALSA_DIRECTION_OUTPUT)))
1860             goto fail;
1861
1862         if (pa_alsa_path_probe(u->mixer_path, u->mixer_handle, hctl, ignore_dB) < 0)
1863             goto fail;
1864
1865         pa_log_debug("Probed mixer path %s:", u->mixer_path->name);
1866         pa_alsa_path_dump(u->mixer_path);
1867     } else if (!(u->mixer_path_set = mapping->output_path_set))
1868         goto fail;
1869
1870     return;
1871
1872 fail:
1873
1874     if (u->mixer_path) {
1875         pa_alsa_path_free(u->mixer_path);
1876         u->mixer_path = NULL;
1877     }
1878
1879     if (u->mixer_handle) {
1880         snd_mixer_close(u->mixer_handle);
1881         u->mixer_handle = NULL;
1882     }
1883 }
1884
1885
1886 static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB) {
1887     pa_bool_t need_mixer_callback = FALSE;
1888
1889     pa_assert(u);
1890
1891     if (!u->mixer_handle)
1892         return 0;
1893
1894     if (u->sink->active_port) {
1895         pa_alsa_port_data *data;
1896
1897         /* We have a list of supported paths, so let's activate the
1898          * one that has been chosen as active */
1899
1900         data = PA_DEVICE_PORT_DATA(u->sink->active_port);
1901         u->mixer_path = data->path;
1902
1903         pa_alsa_path_select(data->path, u->mixer_handle);
1904
1905         if (data->setting)
1906             pa_alsa_setting_select(data->setting, u->mixer_handle);
1907
1908     } else {
1909
1910         if (!u->mixer_path && u->mixer_path_set)
1911             u->mixer_path = pa_hashmap_first(u->mixer_path_set->paths);
1912
1913         if (u->mixer_path) {
1914             /* Hmm, we have only a single path, then let's activate it */
1915
1916             pa_alsa_path_select(u->mixer_path, u->mixer_handle);
1917
1918             if (u->mixer_path->settings)
1919                 pa_alsa_setting_select(u->mixer_path->settings, u->mixer_handle);
1920         } else
1921             return 0;
1922     }
1923
1924     mixer_volume_init(u);
1925
1926     /* Will we need to register callbacks? */
1927     if (u->mixer_path_set && u->mixer_path_set->paths) {
1928         pa_alsa_path *p;
1929         void *state;
1930
1931         PA_HASHMAP_FOREACH(p, u->mixer_path_set->paths, state) {
1932             if (p->has_volume || p->has_mute)
1933                 need_mixer_callback = TRUE;
1934         }
1935     }
1936     else if (u->mixer_path)
1937         need_mixer_callback = u->mixer_path->has_volume || u->mixer_path->has_mute;
1938
1939     if (need_mixer_callback) {
1940         int (*mixer_callback)(snd_mixer_elem_t *, unsigned int);
1941         if (u->sink->flags & PA_SINK_DEFERRED_VOLUME) {
1942             u->mixer_pd = pa_alsa_mixer_pdata_new();
1943             mixer_callback = io_mixer_callback;
1944
1945             if (pa_alsa_set_mixer_rtpoll(u->mixer_pd, u->mixer_handle, u->rtpoll) < 0) {
1946                 pa_log("Failed to initialize file descriptor monitoring");
1947                 return -1;
1948             }
1949         } else {
1950             u->mixer_fdl = pa_alsa_fdlist_new();
1951             mixer_callback = ctl_mixer_callback;
1952
1953             if (pa_alsa_fdlist_set_handle(u->mixer_fdl, u->mixer_handle, NULL, u->core->mainloop) < 0) {
1954                 pa_log("Failed to initialize file descriptor monitoring");
1955                 return -1;
1956             }
1957         }
1958
1959         if (u->mixer_path_set)
1960             pa_alsa_path_set_set_callback(u->mixer_path_set, u->mixer_handle, mixer_callback, u);
1961         else
1962             pa_alsa_path_set_callback(u->mixer_path, u->mixer_handle, mixer_callback, u);
1963     }
1964
1965     return 0;
1966 }
1967
1968 pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_card *card, pa_alsa_mapping *mapping) {
1969
1970     struct userdata *u = NULL;
1971     const char *dev_id = NULL;
1972     pa_sample_spec ss;
1973     uint32_t alternate_sample_rate;
1974     pa_channel_map map;
1975     uint32_t nfrags, frag_size, buffer_size, tsched_size, tsched_watermark, rewind_safeguard;
1976     snd_pcm_uframes_t period_frames, buffer_frames, tsched_frames;
1977     size_t frame_size;
1978     pa_bool_t use_mmap = TRUE, b, use_tsched = TRUE, d, ignore_dB = FALSE, namereg_fail = FALSE, deferred_volume = FALSE, set_formats = FALSE, fixed_latency_range = FALSE;
1979     pa_sink_new_data data;
1980     pa_alsa_profile_set *profile_set = NULL;
1981
1982     pa_assert(m);
1983     pa_assert(ma);
1984
1985     ss = m->core->default_sample_spec;
1986     map = m->core->default_channel_map;
1987     if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_ALSA) < 0) {
1988         pa_log("Failed to parse sample specification and channel map");
1989         goto fail;
1990     }
1991
1992     alternate_sample_rate = m->core->alternate_sample_rate;
1993     if (pa_modargs_get_alternate_sample_rate(ma, &alternate_sample_rate) < 0) {
1994         pa_log("Failed to parse alternate sample rate");
1995         goto fail;
1996     }
1997
1998     frame_size = pa_frame_size(&ss);
1999
2000     nfrags = m->core->default_n_fragments;
2001     frag_size = (uint32_t) pa_usec_to_bytes(m->core->default_fragment_size_msec*PA_USEC_PER_MSEC, &ss);
2002     if (frag_size <= 0)
2003         frag_size = (uint32_t) frame_size;
2004     tsched_size = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_BUFFER_USEC, &ss);
2005     tsched_watermark = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_WATERMARK_USEC, &ss);
2006
2007     if (pa_modargs_get_value_u32(ma, "fragments", &nfrags) < 0 ||
2008         pa_modargs_get_value_u32(ma, "fragment_size", &frag_size) < 0 ||
2009         pa_modargs_get_value_u32(ma, "tsched_buffer_size", &tsched_size) < 0 ||
2010         pa_modargs_get_value_u32(ma, "tsched_buffer_watermark", &tsched_watermark) < 0) {
2011         pa_log("Failed to parse buffer metrics");
2012         goto fail;
2013     }
2014
2015     buffer_size = nfrags * frag_size;
2016
2017     period_frames = frag_size/frame_size;
2018     buffer_frames = buffer_size/frame_size;
2019     tsched_frames = tsched_size/frame_size;
2020
2021     if (pa_modargs_get_value_boolean(ma, "mmap", &use_mmap) < 0) {
2022         pa_log("Failed to parse mmap argument.");
2023         goto fail;
2024     }
2025
2026     if (pa_modargs_get_value_boolean(ma, "tsched", &use_tsched) < 0) {
2027         pa_log("Failed to parse tsched argument.");
2028         goto fail;
2029     }
2030
2031     if (pa_modargs_get_value_boolean(ma, "ignore_dB", &ignore_dB) < 0) {
2032         pa_log("Failed to parse ignore_dB argument.");
2033         goto fail;
2034     }
2035
2036     rewind_safeguard = PA_MAX(DEFAULT_REWIND_SAFEGUARD_BYTES, pa_usec_to_bytes(DEFAULT_REWIND_SAFEGUARD_USEC, &ss));
2037     if (pa_modargs_get_value_u32(ma, "rewind_safeguard", &rewind_safeguard) < 0) {
2038         pa_log("Failed to parse rewind_safeguard argument");
2039         goto fail;
2040     }
2041
2042     deferred_volume = m->core->deferred_volume;
2043     if (pa_modargs_get_value_boolean(ma, "deferred_volume", &deferred_volume) < 0) {
2044         pa_log("Failed to parse deferred_volume argument.");
2045         goto fail;
2046     }
2047
2048     if (pa_modargs_get_value_boolean(ma, "fixed_latency_range", &fixed_latency_range) < 0) {
2049         pa_log("Failed to parse fixed_latency_range argument.");
2050         goto fail;
2051     }
2052
2053     use_tsched = pa_alsa_may_tsched(use_tsched);
2054
2055     u = pa_xnew0(struct userdata, 1);
2056     u->core = m->core;
2057     u->module = m;
2058     u->use_mmap = use_mmap;
2059     u->use_tsched = use_tsched;
2060     u->deferred_volume = deferred_volume;
2061     u->fixed_latency_range = fixed_latency_range;
2062     u->first = TRUE;
2063     u->rewind_safeguard = rewind_safeguard;
2064     u->rtpoll = pa_rtpoll_new();
2065     pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
2066
2067     u->smoother = pa_smoother_new(
2068             SMOOTHER_ADJUST_USEC,
2069             SMOOTHER_WINDOW_USEC,
2070             TRUE,
2071             TRUE,
2072             5,
2073             pa_rtclock_now(),
2074             TRUE);
2075     u->smoother_interval = SMOOTHER_MIN_INTERVAL;
2076
2077     dev_id = pa_modargs_get_value(
2078             ma, "device_id",
2079             pa_modargs_get_value(ma, "device", DEFAULT_DEVICE));
2080
2081     u->paths_dir = pa_xstrdup(pa_modargs_get_value(ma, "paths_dir", NULL));
2082
2083     if (reserve_init(u, dev_id) < 0)
2084         goto fail;
2085
2086     if (reserve_monitor_init(u, dev_id) < 0)
2087         goto fail;
2088
2089     b = use_mmap;
2090     d = use_tsched;
2091
2092     if (mapping) {
2093
2094         if (!(dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
2095             pa_log("device_id= not set");
2096             goto fail;
2097         }
2098
2099         if (!(u->pcm_handle = pa_alsa_open_by_device_id_mapping(
2100                       dev_id,
2101                       &u->device_name,
2102                       &ss, &map,
2103                       SND_PCM_STREAM_PLAYBACK,
2104                       &period_frames, &buffer_frames, tsched_frames,
2105                       &b, &d, mapping)))
2106             goto fail;
2107
2108     } else if ((dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
2109
2110         if (!(profile_set = pa_alsa_profile_set_new(NULL, &map)))
2111             goto fail;
2112
2113         if (!(u->pcm_handle = pa_alsa_open_by_device_id_auto(
2114                       dev_id,
2115                       &u->device_name,
2116                       &ss, &map,
2117                       SND_PCM_STREAM_PLAYBACK,
2118                       &period_frames, &buffer_frames, tsched_frames,
2119                       &b, &d, profile_set, &mapping)))
2120             goto fail;
2121
2122     } else {
2123
2124         if (!(u->pcm_handle = pa_alsa_open_by_device_string(
2125                       pa_modargs_get_value(ma, "device", DEFAULT_DEVICE),
2126                       &u->device_name,
2127                       &ss, &map,
2128                       SND_PCM_STREAM_PLAYBACK,
2129                       &period_frames, &buffer_frames, tsched_frames,
2130                       &b, &d, FALSE)))
2131             goto fail;
2132     }
2133
2134     pa_assert(u->device_name);
2135     pa_log_info("Successfully opened device %s.", u->device_name);
2136
2137     if (pa_alsa_pcm_is_modem(u->pcm_handle)) {
2138         pa_log_notice("Device %s is modem, refusing further initialization.", u->device_name);
2139         goto fail;
2140     }
2141
2142     if (mapping)
2143         pa_log_info("Selected mapping '%s' (%s).", mapping->description, mapping->name);
2144
2145     if (use_mmap && !b) {
2146         pa_log_info("Device doesn't support mmap(), falling back to UNIX read/write mode.");
2147         u->use_mmap = use_mmap = FALSE;
2148     }
2149
2150     if (use_tsched && (!b || !d)) {
2151         pa_log_info("Cannot enable timer-based scheduling, falling back to sound IRQ scheduling.");
2152         u->use_tsched = use_tsched = FALSE;
2153     }
2154
2155     if (u->use_mmap)
2156         pa_log_info("Successfully enabled mmap() mode.");
2157
2158     if (u->use_tsched) {
2159         pa_log_info("Successfully enabled timer-based scheduling mode.");
2160
2161         if (u->fixed_latency_range)
2162             pa_log_info("Disabling latency range changes on underrun");
2163     }
2164
2165     if (is_iec958(u) || is_hdmi(u))
2166         set_formats = TRUE;
2167
2168     u->rates = pa_alsa_get_supported_rates(u->pcm_handle);
2169     if (!u->rates) {
2170         pa_log_error("Failed to find any supported sample rates.");
2171         goto fail;
2172     }
2173
2174     /* ALSA might tweak the sample spec, so recalculate the frame size */
2175     frame_size = pa_frame_size(&ss);
2176
2177     find_mixer(u, mapping, pa_modargs_get_value(ma, "control", NULL), ignore_dB);
2178
2179     pa_sink_new_data_init(&data);
2180     data.driver = driver;
2181     data.module = m;
2182     data.card = card;
2183     set_sink_name(&data, ma, dev_id, u->device_name, mapping);
2184
2185     /* We need to give pa_modargs_get_value_boolean() a pointer to a local
2186      * variable instead of using &data.namereg_fail directly, because
2187      * data.namereg_fail is a bitfield and taking the address of a bitfield
2188      * variable is impossible. */
2189     namereg_fail = data.namereg_fail;
2190     if (pa_modargs_get_value_boolean(ma, "namereg_fail", &namereg_fail) < 0) {
2191         pa_log("Failed to parse namereg_fail argument.");
2192         pa_sink_new_data_done(&data);
2193         goto fail;
2194     }
2195     data.namereg_fail = namereg_fail;
2196
2197     pa_sink_new_data_set_sample_spec(&data, &ss);
2198     pa_sink_new_data_set_channel_map(&data, &map);
2199     pa_sink_new_data_set_alternate_sample_rate(&data, alternate_sample_rate);
2200
2201     pa_alsa_init_proplist_pcm(m->core, data.proplist, u->pcm_handle);
2202     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, u->device_name);
2203     pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_BUFFER_SIZE, "%lu", (unsigned long) (buffer_frames * frame_size));
2204     pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZE, "%lu", (unsigned long) (period_frames * frame_size));
2205     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_ACCESS_MODE, u->use_tsched ? "mmap+timer" : (u->use_mmap ? "mmap" : "serial"));
2206
2207     if (mapping) {
2208         pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_NAME, mapping->name);
2209         pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_DESCRIPTION, mapping->description);
2210     }
2211
2212     pa_alsa_init_description(data.proplist);
2213
2214     if (u->control_device)
2215         pa_alsa_init_proplist_ctl(data.proplist, u->control_device);
2216
2217     if (pa_modargs_get_proplist(ma, "sink_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
2218         pa_log("Invalid properties");
2219         pa_sink_new_data_done(&data);
2220         goto fail;
2221     }
2222
2223     if (u->mixer_path_set)
2224         pa_alsa_add_ports(&data.ports, u->mixer_path_set, card);
2225
2226     u->sink = pa_sink_new(m->core, &data, PA_SINK_HARDWARE | PA_SINK_LATENCY | (u->use_tsched ? PA_SINK_DYNAMIC_LATENCY : 0) |
2227                           (set_formats ? PA_SINK_SET_FORMATS : 0));
2228     pa_sink_new_data_done(&data);
2229
2230     if (!u->sink) {
2231         pa_log("Failed to create sink object");
2232         goto fail;
2233     }
2234
2235     if (pa_modargs_get_value_u32(ma, "deferred_volume_safety_margin",
2236                                  &u->sink->thread_info.volume_change_safety_margin) < 0) {
2237         pa_log("Failed to parse deferred_volume_safety_margin parameter");
2238         goto fail;
2239     }
2240
2241     if (pa_modargs_get_value_s32(ma, "deferred_volume_extra_delay",
2242                                  &u->sink->thread_info.volume_change_extra_delay) < 0) {
2243         pa_log("Failed to parse deferred_volume_extra_delay parameter");
2244         goto fail;
2245     }
2246
2247     u->sink->parent.process_msg = sink_process_msg;
2248     if (u->use_tsched)
2249         u->sink->update_requested_latency = sink_update_requested_latency_cb;
2250     u->sink->set_state = sink_set_state_cb;
2251     u->sink->set_port = sink_set_port_cb;
2252     if (u->sink->alternate_sample_rate)
2253         u->sink->update_rate = sink_update_rate_cb;
2254     u->sink->userdata = u;
2255
2256     pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
2257     pa_sink_set_rtpoll(u->sink, u->rtpoll);
2258
2259     u->frame_size = frame_size;
2260     u->fragment_size = frag_size = (size_t) (period_frames * frame_size);
2261     u->hwbuf_size = buffer_size = (size_t) (buffer_frames * frame_size);
2262     pa_cvolume_mute(&u->hardware_volume, u->sink->sample_spec.channels);
2263
2264     pa_log_info("Using %0.1f fragments of size %lu bytes (%0.2fms), buffer size is %lu bytes (%0.2fms)",
2265                 (double) u->hwbuf_size / (double) u->fragment_size,
2266                 (long unsigned) u->fragment_size,
2267                 (double) pa_bytes_to_usec(u->fragment_size, &ss) / PA_USEC_PER_MSEC,
2268                 (long unsigned) u->hwbuf_size,
2269                 (double) pa_bytes_to_usec(u->hwbuf_size, &ss) / PA_USEC_PER_MSEC);
2270
2271     pa_sink_set_max_request(u->sink, u->hwbuf_size);
2272     if (pa_alsa_pcm_is_hw(u->pcm_handle))
2273         pa_sink_set_max_rewind(u->sink, u->hwbuf_size);
2274     else {
2275         pa_log_info("Disabling rewind for device %s", u->device_name);
2276         pa_sink_set_max_rewind(u->sink, 0);
2277     }
2278
2279     if (u->use_tsched) {
2280         u->tsched_watermark_ref = tsched_watermark;
2281         reset_watermark(u, u->tsched_watermark_ref, &ss, FALSE);
2282     } else
2283         pa_sink_set_fixed_latency(u->sink, pa_bytes_to_usec(u->hwbuf_size, &ss));
2284
2285     reserve_update(u);
2286
2287     if (update_sw_params(u) < 0)
2288         goto fail;
2289
2290     if (setup_mixer(u, ignore_dB) < 0)
2291         goto fail;
2292
2293     pa_alsa_dump(PA_LOG_DEBUG, u->pcm_handle);
2294
2295     if (!(u->thread = pa_thread_new("alsa-sink", thread_func, u))) {
2296         pa_log("Failed to create thread.");
2297         goto fail;
2298     }
2299
2300     /* Get initial mixer settings */
2301     if (data.volume_is_set) {
2302         if (u->sink->set_volume)
2303             u->sink->set_volume(u->sink);
2304     } else {
2305         if (u->sink->get_volume)
2306             u->sink->get_volume(u->sink);
2307     }
2308
2309     if (data.muted_is_set) {
2310         if (u->sink->set_mute)
2311             u->sink->set_mute(u->sink);
2312     } else {
2313         if (u->sink->get_mute)
2314             u->sink->get_mute(u->sink);
2315     }
2316
2317     if ((data.volume_is_set || data.muted_is_set) && u->sink->write_volume)
2318         u->sink->write_volume(u->sink);
2319
2320     if (set_formats) {
2321         /* For S/PDIF and HDMI, allow getting/setting custom formats */
2322         pa_format_info *format;
2323
2324         /* To start with, we only support PCM formats. Other formats may be added
2325          * with pa_sink_set_formats().*/
2326         format = pa_format_info_new();
2327         format->encoding = PA_ENCODING_PCM;
2328         u->formats = pa_idxset_new(NULL, NULL);
2329         pa_idxset_put(u->formats, format, NULL);
2330
2331         u->sink->get_formats = sink_get_formats;
2332         u->sink->set_formats = sink_set_formats;
2333     }
2334
2335     pa_sink_put(u->sink);
2336
2337     if (profile_set)
2338         pa_alsa_profile_set_free(profile_set);
2339
2340     return u->sink;
2341
2342 fail:
2343
2344     if (u)
2345         userdata_free(u);
2346
2347     if (profile_set)
2348         pa_alsa_profile_set_free(profile_set);
2349
2350     return NULL;
2351 }
2352
2353 static void userdata_free(struct userdata *u) {
2354     pa_assert(u);
2355
2356     if (u->sink)
2357         pa_sink_unlink(u->sink);
2358
2359     if (u->thread) {
2360         pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
2361         pa_thread_free(u->thread);
2362     }
2363
2364     pa_thread_mq_done(&u->thread_mq);
2365
2366     if (u->sink)
2367         pa_sink_unref(u->sink);
2368
2369     if (u->memchunk.memblock)
2370         pa_memblock_unref(u->memchunk.memblock);
2371
2372     if (u->mixer_pd)
2373         pa_alsa_mixer_pdata_free(u->mixer_pd);
2374
2375     if (u->alsa_rtpoll_item)
2376         pa_rtpoll_item_free(u->alsa_rtpoll_item);
2377
2378     if (u->rtpoll)
2379         pa_rtpoll_free(u->rtpoll);
2380
2381     if (u->pcm_handle) {
2382         snd_pcm_drop(u->pcm_handle);
2383         snd_pcm_close(u->pcm_handle);
2384     }
2385
2386     if (u->mixer_fdl)
2387         pa_alsa_fdlist_free(u->mixer_fdl);
2388
2389     if (u->mixer_path && !u->mixer_path_set)
2390         pa_alsa_path_free(u->mixer_path);
2391
2392     if (u->mixer_handle)
2393         snd_mixer_close(u->mixer_handle);
2394
2395     if (u->smoother)
2396         pa_smoother_free(u->smoother);
2397
2398     if (u->formats)
2399         pa_idxset_free(u->formats, (pa_free2_cb_t) pa_format_info_free2, NULL);
2400
2401     if (u->rates)
2402         pa_xfree(u->rates);
2403
2404     reserve_done(u);
2405     monitor_done(u);
2406
2407     pa_xfree(u->device_name);
2408     pa_xfree(u->control_device);
2409     pa_xfree(u->paths_dir);
2410     pa_xfree(u);
2411 }
2412
2413 void pa_alsa_sink_free(pa_sink *s) {
2414     struct userdata *u;
2415
2416     pa_sink_assert_ref(s);
2417     pa_assert_se(u = s->userdata);
2418
2419     userdata_free(u);
2420 }