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