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