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 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 theshold, 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 theshold in the verification time, decrease the watermark */
  74
  75 /* Note that TSCHED_WATERMARK_INC_THRESHOLD_USEC == 0 means tht 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 (256) /* 1.33ms @48kHz, should work for most hardware */
  90
  91 struct userdata {
  92     pa_core *core;
  93     pa_module *module;
  94     pa_sink *sink;
  95
  96     pa_thread *thread;
  97     pa_thread_mq thread_mq;
  98     pa_rtpoll *rtpoll;
  99
 100     snd_pcm_t *pcm_handle;
 101
 102     pa_alsa_fdlist *mixer_fdl;
 103     snd_mixer_t *mixer_handle;
 104     pa_alsa_path_set *mixer_path_set;
 105     pa_alsa_path *mixer_path;
 106
 107     pa_cvolume hardware_volume;
 108
 109     size_t
 110         frame_size,
 111         fragment_size,
 112         hwbuf_size,
 113         tsched_watermark,
 114         hwbuf_unused,
 115         min_sleep,
 116         min_wakeup,
 117         watermark_inc_step,
 118         watermark_dec_step,
 119         watermark_inc_threshold,
 120         watermark_dec_threshold,
 121         rewind_safeguard;
 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 (!after_avail && (int) sframes == -EAGAIN)
 617                     break;
 618
 619                 if ((r = try_recover(u, "snd_pcm_mmap_commit", (int) sframes)) == 0)
 620                     continue;
 621
 622                 return r;
 623             }
 624
 625             work_done = TRUE;
 626
 627             u->write_count += frames * u->frame_size;
 628             u->since_start += frames * u->frame_size;
 629
 630 #ifdef DEBUG_TIMING
 631             pa_log_debug("Wrote %lu bytes (of possible %lu bytes)", (unsigned long) (frames * u->frame_size), (unsigned long) n_bytes);
 632 #endif
 633
 634             if ((size_t) frames * u->frame_size >= n_bytes)
 635                 break;
 636
 637             n_bytes -= (size_t) frames * u->frame_size;
 638         }
 639     }
 640
 641     if (u->use_tsched) {
 642         *sleep_usec = pa_bytes_to_usec(left_to_play, &u->sink->sample_spec);
 643
 644         if (*sleep_usec > process_usec)
 645             *sleep_usec -= process_usec;
 646         else
 647             *sleep_usec = 0;
 648     } else
 649         *sleep_usec = 0;
 650
 651     return work_done ? 1 : 0;
 652 }
 653
 654 static int unix_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled, pa_bool_t on_timeout) {
 655     pa_bool_t work_done = FALSE;
 656     pa_usec_t max_sleep_usec = 0, process_usec = 0;
 657     size_t left_to_play;
 658     unsigned j = 0;
 659
 660     pa_assert(u);
 661     pa_sink_assert_ref(u->sink);
 662
 663     if (u->use_tsched)
 664         hw_sleep_time(u, &max_sleep_usec, &process_usec);
 665
 666     for (;;) {
 667         snd_pcm_sframes_t n;
 668         size_t n_bytes;
 669         int r;
 670         pa_bool_t after_avail = TRUE;
 671
 672         if (PA_UNLIKELY((n = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->sink->sample_spec)) < 0)) {
 673
 674             if ((r = try_recover(u, "snd_pcm_avail", (int) n)) == 0)
 675                 continue;
 676
 677             return r;
 678         }
 679
 680         n_bytes = (size_t) n * u->frame_size;
 681         left_to_play = check_left_to_play(u, n_bytes, on_timeout);
 682         on_timeout = FALSE;
 683
 684         if (u->use_tsched)
 685
 686             /* We won't fill up the playback buffer before at least
 687             * half the sleep time is over because otherwise we might
 688             * ask for more data from the clients then they expect. We
 689             * need to guarantee that clients only have to keep around
 690             * a single hw buffer length. */
 691
 692             if (!polled &&
 693                 pa_bytes_to_usec(left_to_play, &u->sink->sample_spec) > process_usec+max_sleep_usec/2)
 694                 break;
 695
 696         if (PA_UNLIKELY(n_bytes <= u->hwbuf_unused)) {
 697
 698             if (polled)
 699                 PA_ONCE_BEGIN {
 700                     char *dn = pa_alsa_get_driver_name_by_pcm(u->pcm_handle);
 701                     pa_log(_("ALSA woke us up to write new data to the device, but there was actually nothing to write!\n"
 702                              "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers.\n"
 703                              "We were woken up with POLLOUT set -- however a subsequent snd_pcm_avail() returned 0 or another value < min_avail."),
 704                            pa_strnull(dn));
 705                     pa_xfree(dn);
 706                 } PA_ONCE_END;
 707
 708             break;
 709         }
 710
 711         if (++j > 10) {
 712 #ifdef DEBUG_TIMING
 713             pa_log_debug("Not filling up, because already too many iterations.");
 714 #endif
 715
 716             break;
 717         }
 718
 719         n_bytes -= u->hwbuf_unused;
 720         polled = FALSE;
 721
 722         for (;;) {
 723             snd_pcm_sframes_t frames;
 724             void *p;
 725
 726 /*         pa_log_debug("%lu frames to write", (unsigned long) frames); */
 727
 728             if (u->memchunk.length <= 0)
 729                 pa_sink_render(u->sink, n_bytes, &u->memchunk);
 730
 731             pa_assert(u->memchunk.length > 0);
 732
 733             frames = (snd_pcm_sframes_t) (u->memchunk.length / u->frame_size);
 734
 735             if (frames > (snd_pcm_sframes_t) (n_bytes/u->frame_size))
 736                 frames = (snd_pcm_sframes_t) (n_bytes/u->frame_size);
 737
 738             p = pa_memblock_acquire(u->memchunk.memblock);
 739             frames = snd_pcm_writei(u->pcm_handle, (const uint8_t*) p + u->memchunk.index, (snd_pcm_uframes_t) frames);
 740             pa_memblock_release(u->memchunk.memblock);
 741
 742             if (PA_UNLIKELY(frames < 0)) {
 743
 744                 if (!after_avail && (int) frames == -EAGAIN)
 745                     break;
 746
 747                 if ((r = try_recover(u, "snd_pcm_writei", (int) frames)) == 0)
 748                     continue;
 749
 750                 return r;
 751             }
 752
 753             if (!after_avail && frames == 0)
 754                 break;
 755
 756             pa_assert(frames > 0);
 757             after_avail = FALSE;
 758
 759             u->memchunk.index += (size_t) frames * u->frame_size;
 760             u->memchunk.length -= (size_t) frames * u->frame_size;
 761
 762             if (u->memchunk.length <= 0) {
 763                 pa_memblock_unref(u->memchunk.memblock);
 764                 pa_memchunk_reset(&u->memchunk);
 765             }
 766
 767             work_done = TRUE;
 768
 769             u->write_count += frames * u->frame_size;
 770             u->since_start += frames * u->frame_size;
 771
 772 /*         pa_log_debug("wrote %lu frames", (unsigned long) frames); */
 773
 774             if ((size_t) frames * u->frame_size >= n_bytes)
 775                 break;
 776
 777             n_bytes -= (size_t) frames * u->frame_size;
 778         }
 779     }
 780
 781     if (u->use_tsched) {
 782         *sleep_usec = pa_bytes_to_usec(left_to_play, &u->sink->sample_spec);
 783
 784         if (*sleep_usec > process_usec)
 785             *sleep_usec -= process_usec;
 786         else
 787             *sleep_usec = 0;
 788     } else
 789         *sleep_usec = 0;
 790
 791     return work_done ? 1 : 0;
 792 }
 793
 794 static void update_smoother(struct userdata *u) {
 795     snd_pcm_sframes_t delay = 0;
 796     int64_t position;
 797     int err;
 798     pa_usec_t now1 = 0, now2;
 799     snd_pcm_status_t *status;
 800
 801     snd_pcm_status_alloca(&status);
 802
 803     pa_assert(u);
 804     pa_assert(u->pcm_handle);
 805
 806     /* Let's update the time smoother */
 807
 808     if (PA_UNLIKELY((err = pa_alsa_safe_delay(u->pcm_handle, &delay, u->hwbuf_size, &u->sink->sample_spec, FALSE)) < 0)) {
 809         pa_log_warn("Failed to query DSP status data: %s", pa_alsa_strerror(err));
 810         return;
 811     }
 812
 813     if (PA_UNLIKELY((err = snd_pcm_status(u->pcm_handle, status)) < 0))
 814         pa_log_warn("Failed to get timestamp: %s", pa_alsa_strerror(err));
 815     else {
 816         snd_htimestamp_t htstamp = { 0, 0 };
 817         snd_pcm_status_get_htstamp(status, &htstamp);
 818         now1 = pa_timespec_load(&htstamp);
 819     }
 820
 821     /* Hmm, if the timestamp is 0, then it wasn't set and we take the current time */
 822     if (now1 <= 0)
 823         now1 = pa_rtclock_now();
 824
 825     /* check if the time since the last update is bigger than the interval */
 826     if (u->last_smoother_update > 0)
 827         if (u->last_smoother_update + u->smoother_interval > now1)
 828             return;
 829
 830     position = (int64_t) u->write_count - ((int64_t) delay * (int64_t) u->frame_size);
 831
 832     if (PA_UNLIKELY(position < 0))
 833         position = 0;
 834
 835     now2 = pa_bytes_to_usec((uint64_t) position, &u->sink->sample_spec);
 836
 837     pa_smoother_put(u->smoother, now1, now2);
 838
 839     u->last_smoother_update = now1;
 840     /* exponentially increase the update interval up to the MAX limit */
 841     u->smoother_interval = PA_MIN (u->smoother_interval * 2, SMOOTHER_MAX_INTERVAL);
 842 }
 843
 844 static pa_usec_t sink_get_latency(struct userdata *u) {
 845     pa_usec_t r;
 846     int64_t delay;
 847     pa_usec_t now1, now2;
 848
 849     pa_assert(u);
 850
 851     now1 = pa_rtclock_now();
 852     now2 = pa_smoother_get(u->smoother, now1);
 853
 854     delay = (int64_t) pa_bytes_to_usec(u->write_count, &u->sink->sample_spec) - (int64_t) now2;
 855
 856     r = delay >= 0 ? (pa_usec_t) delay : 0;
 857
 858     if (u->memchunk.memblock)
 859         r += pa_bytes_to_usec(u->memchunk.length, &u->sink->sample_spec);
 860
 861     return r;
 862 }
 863
 864 static int build_pollfd(struct userdata *u) {
 865     pa_assert(u);
 866     pa_assert(u->pcm_handle);
 867
 868     if (u->alsa_rtpoll_item)
 869         pa_rtpoll_item_free(u->alsa_rtpoll_item);
 870
 871     if (!(u->alsa_rtpoll_item = pa_alsa_build_pollfd(u->pcm_handle, u->rtpoll)))
 872         return -1;
 873
 874     return 0;
 875 }
 876
 877 /* Called from IO context */
 878 static int suspend(struct userdata *u) {
 879     pa_assert(u);
 880     pa_assert(u->pcm_handle);
 881
 882     pa_smoother_pause(u->smoother, pa_rtclock_now());
 883
 884     /* Let's suspend -- we don't call snd_pcm_drain() here since that might
 885      * take awfully long with our long buffer sizes today. */
 886     snd_pcm_close(u->pcm_handle);
 887     u->pcm_handle = NULL;
 888
 889     if (u->alsa_rtpoll_item) {
 890         pa_rtpoll_item_free(u->alsa_rtpoll_item);
 891         u->alsa_rtpoll_item = NULL;
 892     }
 893
 894     /* We reset max_rewind/max_request here to make sure that while we
 895      * are suspended the old max_request/max_rewind values set before
 896      * the suspend can influence the per-stream buffer of newly
 897      * created streams, without their requirements having any
 898      * influence on them. */
 899     pa_sink_set_max_rewind_within_thread(u->sink, 0);
 900     pa_sink_set_max_request_within_thread(u->sink, 0);
 901
 902     pa_log_info("Device suspended...");
 903
 904     return 0;
 905 }
 906
 907 /* Called from IO context */
 908 static int update_sw_params(struct userdata *u) {
 909     snd_pcm_uframes_t avail_min;
 910     int err;
 911
 912     pa_assert(u);
 913
 914     /* Use the full buffer if noone asked us for anything specific */
 915     u->hwbuf_unused = 0;
 916
 917     if (u->use_tsched) {
 918         pa_usec_t latency;
 919
 920         if ((latency = pa_sink_get_requested_latency_within_thread(u->sink)) != (pa_usec_t) -1) {
 921             size_t b;
 922
 923             pa_log_debug("Latency set to %0.2fms", (double) latency / PA_USEC_PER_MSEC);
 924
 925             b = pa_usec_to_bytes(latency, &u->sink->sample_spec);
 926
 927             /* We need at least one sample in our buffer */
 928
 929             if (PA_UNLIKELY(b < u->frame_size))
 930                 b = u->frame_size;
 931
 932             u->hwbuf_unused = PA_LIKELY(b < u->hwbuf_size) ? (u->hwbuf_size - b) : 0;
 933         }
 934
 935         fix_min_sleep_wakeup(u);
 936         fix_tsched_watermark(u);
 937     }
 938
 939     pa_log_debug("hwbuf_unused=%lu", (unsigned long) u->hwbuf_unused);
 940
 941     /* We need at last one frame in the used part of the buffer */
 942     avail_min = (snd_pcm_uframes_t) u->hwbuf_unused / u->frame_size + 1;
 943
 944     if (u->use_tsched) {
 945         pa_usec_t sleep_usec, process_usec;
 946
 947         hw_sleep_time(u, &sleep_usec, &process_usec);
 948         avail_min += pa_usec_to_bytes(sleep_usec, &u->sink->sample_spec) / u->frame_size;
 949     }
 950
 951     pa_log_debug("setting avail_min=%lu", (unsigned long) avail_min);
 952
 953     if ((err = pa_alsa_set_sw_params(u->pcm_handle, avail_min, !u->use_tsched)) < 0) {
 954         pa_log("Failed to set software parameters: %s", pa_alsa_strerror(err));
 955         return err;
 956     }
 957
 958     pa_sink_set_max_request_within_thread(u->sink, u->hwbuf_size - u->hwbuf_unused);
 959      if (pa_alsa_pcm_is_hw(u->pcm_handle))
 960          pa_sink_set_max_rewind_within_thread(u->sink, u->hwbuf_size);
 961     else {
 962         pa_log_info("Disabling rewind_within_thread for device %s", u->device_name);
 963         pa_sink_set_max_rewind_within_thread(u->sink, 0);
 964     }
 965
 966     return 0;
 967 }
 968
 969 /* Called from IO context */
 970 static int unsuspend(struct userdata *u) {
 971     pa_sample_spec ss;
 972     int err;
 973     pa_bool_t b, d;
 974     snd_pcm_uframes_t period_size, buffer_size;
 975
 976     pa_assert(u);
 977     pa_assert(!u->pcm_handle);
 978
 979     pa_log_info("Trying resume...");
 980
 981     if ((err = snd_pcm_open(&u->pcm_handle, u->device_name, SND_PCM_STREAM_PLAYBACK,
 982                             SND_PCM_NONBLOCK|
 983                             SND_PCM_NO_AUTO_RESAMPLE|
 984                             SND_PCM_NO_AUTO_CHANNELS|
 985                             SND_PCM_NO_AUTO_FORMAT)) < 0) {
 986         pa_log("Error opening PCM device %s: %s", u->device_name, pa_alsa_strerror(err));
 987         goto fail;
 988     }
 989
 990     ss = u->sink->sample_spec;
 991     period_size = u->fragment_size / u->frame_size;
 992     buffer_size = u->hwbuf_size / u->frame_size;
 993     b = u->use_mmap;
 994     d = u->use_tsched;
 995
 996     if ((err = pa_alsa_set_hw_params(u->pcm_handle, &ss, &period_size, &buffer_size, 0, &b, &d, TRUE)) < 0) {
 997         pa_log("Failed to set hardware parameters: %s", pa_alsa_strerror(err));
 998         goto fail;
 999     }
1000
1001     if (b != u->use_mmap || d != u->use_tsched) {
1002         pa_log_warn("Resume failed, couldn't get original access mode.");
1003         goto fail;
1004     }
1005
1006     if (!pa_sample_spec_equal(&ss, &u->sink->sample_spec)) {
1007         pa_log_warn("Resume failed, couldn't restore original sample settings.");
1008         goto fail;
1009     }
1010
1011     if (period_size*u->frame_size != u->fragment_size ||
1012         buffer_size*u->frame_size != u->hwbuf_size) {
1013         pa_log_warn("Resume failed, couldn't restore original fragment settings. (Old: %lu/%lu, New %lu/%lu)",
1014                     (unsigned long) u->hwbuf_size, (unsigned long) u->fragment_size,
1015                     (unsigned long) (buffer_size*u->frame_size), (unsigned long) (period_size*u->frame_size));
1016         goto fail;
1017     }
1018
1019     if (update_sw_params(u) < 0)
1020         goto fail;
1021
1022     if (build_pollfd(u) < 0)
1023         goto fail;
1024
1025     u->write_count = 0;
1026     pa_smoother_reset(u->smoother, pa_rtclock_now(), TRUE);
1027     u->smoother_interval = SMOOTHER_MIN_INTERVAL;
1028     u->last_smoother_update = 0;
1029
1030     u->first = TRUE;
1031     u->since_start = 0;
1032
1033     pa_log_info("Resumed successfully...");
1034
1035     return 0;
1036
1037 fail:
1038     if (u->pcm_handle) {
1039         snd_pcm_close(u->pcm_handle);
1040         u->pcm_handle = NULL;
1041     }
1042
1043     return -PA_ERR_IO;
1044 }
1045
1046 /* Called from IO context */
1047 static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
1048     struct userdata *u = PA_SINK(o)->userdata;
1049
1050     switch (code) {
1051
1052         case PA_SINK_MESSAGE_GET_LATENCY: {
1053             pa_usec_t r = 0;
1054
1055             if (u->pcm_handle)
1056                 r = sink_get_latency(u);
1057
1058             *((pa_usec_t*) data) = r;
1059
1060             return 0;
1061         }
1062
1063         case PA_SINK_MESSAGE_SET_STATE:
1064
1065             switch ((pa_sink_state_t) PA_PTR_TO_UINT(data)) {
1066
1067                 case PA_SINK_SUSPENDED: {
1068                     int r;
1069
1070                     pa_assert(PA_SINK_IS_OPENED(u->sink->thread_info.state));
1071
1072                     if ((r = suspend(u)) < 0)
1073                         return r;
1074
1075                     break;
1076                 }
1077
1078                 case PA_SINK_IDLE:
1079                 case PA_SINK_RUNNING: {
1080                     int r;
1081
1082                     if (u->sink->thread_info.state == PA_SINK_INIT) {
1083                         if (build_pollfd(u) < 0)
1084                             return -PA_ERR_IO;
1085                     }
1086
1087                     if (u->sink->thread_info.state == PA_SINK_SUSPENDED) {
1088                         if ((r = unsuspend(u)) < 0)
1089                             return r;
1090                     }
1091
1092                     break;
1093                 }
1094
1095                 case PA_SINK_UNLINKED:
1096                 case PA_SINK_INIT:
1097                 case PA_SINK_INVALID_STATE:
1098                     ;
1099             }
1100
1101             break;
1102     }
1103
1104     return pa_sink_process_msg(o, code, data, offset, chunk);
1105 }
1106
1107 /* Called from main context */
1108 static int sink_set_state_cb(pa_sink *s, pa_sink_state_t new_state) {
1109     pa_sink_state_t old_state;
1110     struct userdata *u;
1111
1112     pa_sink_assert_ref(s);
1113     pa_assert_se(u = s->userdata);
1114
1115     old_state = pa_sink_get_state(u->sink);
1116
1117     if (PA_SINK_IS_OPENED(old_state) && new_state == PA_SINK_SUSPENDED)
1118         reserve_done(u);
1119     else if (old_state == PA_SINK_SUSPENDED && PA_SINK_IS_OPENED(new_state))
1120         if (reserve_init(u, u->device_name) < 0)
1121             return -PA_ERR_BUSY;
1122
1123     return 0;
1124 }
1125
1126 static int mixer_callback(snd_mixer_elem_t *elem, unsigned int mask) {
1127     struct userdata *u = snd_mixer_elem_get_callback_private(elem);
1128
1129     pa_assert(u);
1130     pa_assert(u->mixer_handle);
1131
1132     if (mask == SND_CTL_EVENT_MASK_REMOVE)
1133         return 0;
1134
1135     if (u->sink->suspend_cause & PA_SUSPEND_SESSION)
1136         return 0;
1137
1138     if (mask & SND_CTL_EVENT_MASK_VALUE) {
1139         pa_sink_get_volume(u->sink, TRUE);
1140         pa_sink_get_mute(u->sink, TRUE);
1141     }
1142
1143     return 0;
1144 }
1145
1146 static void sink_get_volume_cb(pa_sink *s) {
1147     struct userdata *u = s->userdata;
1148     pa_cvolume r;
1149     char t[PA_CVOLUME_SNPRINT_MAX];
1150
1151     pa_assert(u);
1152     pa_assert(u->mixer_path);
1153     pa_assert(u->mixer_handle);
1154
1155     if (pa_alsa_path_get_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r) < 0)
1156         return;
1157
1158     /* Shift down by the base volume, so that 0dB becomes maximum volume */
1159     pa_sw_cvolume_multiply_scalar(&r, &r, s->base_volume);
1160
1161     pa_log_debug("Read hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &r));
1162
1163     if (pa_cvolume_equal(&u->hardware_volume, &r))
1164         return;
1165
1166     s->real_volume = u->hardware_volume = r;
1167
1168     /* Hmm, so the hardware volume changed, let's reset our software volume */
1169     if (u->mixer_path->has_dB)
1170         pa_sink_set_soft_volume(s, NULL);
1171 }
1172
1173 static void sink_set_volume_cb(pa_sink *s) {
1174     struct userdata *u = s->userdata;
1175     pa_cvolume r;
1176     char t[PA_CVOLUME_SNPRINT_MAX];
1177
1178     pa_assert(u);
1179     pa_assert(u->mixer_path);
1180     pa_assert(u->mixer_handle);
1181
1182     /* Shift up by the base volume */
1183     pa_sw_cvolume_divide_scalar(&r, &s->real_volume, s->base_volume);
1184
1185     if (pa_alsa_path_set_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r) < 0)
1186         return;
1187
1188     /* Shift down by the base volume, so that 0dB becomes maximum volume */
1189     pa_sw_cvolume_multiply_scalar(&r, &r, s->base_volume);
1190
1191     u->hardware_volume = r;
1192
1193     if (u->mixer_path->has_dB) {
1194         pa_cvolume new_soft_volume;
1195         pa_bool_t accurate_enough;
1196
1197         /* Match exactly what the user requested by software */
1198         pa_sw_cvolume_divide(&new_soft_volume, &s->real_volume, &u->hardware_volume);
1199
1200         /* If the adjustment to do in software is only minimal we
1201          * can skip it. That saves us CPU at the expense of a bit of
1202          * accuracy */
1203         accurate_enough =
1204             (pa_cvolume_min(&new_soft_volume) >= (PA_VOLUME_NORM - VOLUME_ACCURACY)) &&
1205             (pa_cvolume_max(&new_soft_volume) <= (PA_VOLUME_NORM + VOLUME_ACCURACY));
1206
1207         pa_log_debug("Requested volume: %s", pa_cvolume_snprint(t, sizeof(t), &s->real_volume));
1208         pa_log_debug("Got hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &u->hardware_volume));
1209         pa_log_debug("Calculated software volume: %s (accurate-enough=%s)", pa_cvolume_snprint(t, sizeof(t), &new_soft_volume),
1210                      pa_yes_no(accurate_enough));
1211
1212         if (!accurate_enough)
1213             s->soft_volume = new_soft_volume;
1214
1215     } else {
1216         pa_log_debug("Wrote hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &r));
1217
1218         /* We can't match exactly what the user requested, hence let's
1219          * at least tell the user about it */
1220
1221         s->real_volume = r;
1222     }
1223 }
1224
1225 static void sink_get_mute_cb(pa_sink *s) {
1226     struct userdata *u = s->userdata;
1227     pa_bool_t b;
1228
1229     pa_assert(u);
1230     pa_assert(u->mixer_path);
1231     pa_assert(u->mixer_handle);
1232
1233     if (pa_alsa_path_get_mute(u->mixer_path, u->mixer_handle, &b) < 0)
1234         return;
1235
1236     s->muted = b;
1237 }
1238
1239 static void sink_set_mute_cb(pa_sink *s) {
1240     struct userdata *u = s->userdata;
1241
1242     pa_assert(u);
1243     pa_assert(u->mixer_path);
1244     pa_assert(u->mixer_handle);
1245
1246     pa_alsa_path_set_mute(u->mixer_path, u->mixer_handle, s->muted);
1247 }
1248
1249 static int sink_set_port_cb(pa_sink *s, pa_device_port *p) {
1250     struct userdata *u = s->userdata;
1251     pa_alsa_port_data *data;
1252
1253     pa_assert(u);
1254     pa_assert(p);
1255     pa_assert(u->mixer_handle);
1256
1257     data = PA_DEVICE_PORT_DATA(p);
1258
1259     pa_assert_se(u->mixer_path = data->path);
1260     pa_alsa_path_select(u->mixer_path, u->mixer_handle);
1261
1262     if (u->mixer_path->has_volume && u->mixer_path->has_dB) {
1263         s->base_volume = pa_sw_volume_from_dB(-u->mixer_path->max_dB);
1264         s->n_volume_steps = PA_VOLUME_NORM+1;
1265
1266         pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(s->base_volume));
1267     } else {
1268         s->base_volume = PA_VOLUME_NORM;
1269         s->n_volume_steps = u->mixer_path->max_volume - u->mixer_path->min_volume + 1;
1270     }
1271
1272     if (data->setting)
1273         pa_alsa_setting_select(data->setting, u->mixer_handle);
1274
1275     if (s->set_mute)
1276         s->set_mute(s);
1277     if (s->set_volume)
1278         s->set_volume(s);
1279
1280     return 0;
1281 }
1282
1283 static void sink_update_requested_latency_cb(pa_sink *s) {
1284     struct userdata *u = s->userdata;
1285     size_t before;
1286     pa_assert(u);
1287     pa_assert(u->use_tsched); /* only when timer scheduling is used
1288                                * we can dynamically adjust the
1289                                * latency */
1290
1291     if (!u->pcm_handle)
1292         return;
1293
1294     before = u->hwbuf_unused;
1295     update_sw_params(u);
1296
1297     /* Let's check whether we now use only a smaller part of the
1298     buffer then before. If so, we need to make sure that subsequent
1299     rewinds are relative to the new maximum fill level and not to the
1300     current fill level. Thus, let's do a full rewind once, to clear
1301     things up. */
1302
1303     if (u->hwbuf_unused > before) {
1304         pa_log_debug("Requesting rewind due to latency change.");
1305         pa_sink_request_rewind(s, (size_t) -1);
1306     }
1307 }
1308
1309 static int process_rewind(struct userdata *u) {
1310     snd_pcm_sframes_t unused;
1311     size_t rewind_nbytes, unused_nbytes, limit_nbytes;
1312     pa_assert(u);
1313
1314     /* Figure out how much we shall rewind and reset the counter */
1315     rewind_nbytes = u->sink->thread_info.rewind_nbytes;
1316
1317     pa_log_debug("Requested to rewind %lu bytes.", (unsigned long) rewind_nbytes);
1318
1319     if (PA_UNLIKELY((unused = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->sink->sample_spec)) < 0)) {
1320         pa_log("snd_pcm_avail() failed: %s", pa_alsa_strerror((int) unused));
1321         return -1;
1322     }
1323
1324     unused_nbytes = (size_t) unused * u->frame_size;
1325
1326     /* make sure rewind doesn't go too far, can cause issues with DMAs */
1327     unused_nbytes += u->rewind_safeguard;
1328
1329     if (u->hwbuf_size > unused_nbytes)
1330         limit_nbytes = u->hwbuf_size - unused_nbytes;
1331     else
1332         limit_nbytes = 0;
1333
1334     if (rewind_nbytes > limit_nbytes)
1335         rewind_nbytes = limit_nbytes;
1336
1337     if (rewind_nbytes > 0) {
1338         snd_pcm_sframes_t in_frames, out_frames;
1339
1340         pa_log_debug("Limited to %lu bytes.", (unsigned long) rewind_nbytes);
1341
1342         in_frames = (snd_pcm_sframes_t) (rewind_nbytes / u->frame_size);
1343         pa_log_debug("before: %lu", (unsigned long) in_frames);
1344         if ((out_frames = snd_pcm_rewind(u->pcm_handle, (snd_pcm_uframes_t) in_frames)) < 0) {
1345             pa_log("snd_pcm_rewind() failed: %s", pa_alsa_strerror((int) out_frames));
1346             if (try_recover(u, "process_rewind", out_frames) < 0)
1347                 return -1;
1348             out_frames = 0;
1349         }
1350
1351         pa_log_debug("after: %lu", (unsigned long) out_frames);
1352
1353         rewind_nbytes = (size_t) out_frames * u->frame_size;
1354
1355         if (rewind_nbytes <= 0)
1356             pa_log_info("Tried rewind, but was apparently not possible.");
1357         else {
1358             u->write_count -= rewind_nbytes;
1359             pa_log_debug("Rewound %lu bytes.", (unsigned long) rewind_nbytes);
1360             pa_sink_process_rewind(u->sink, rewind_nbytes);
1361
1362             u->after_rewind = TRUE;
1363             return 0;
1364         }
1365     } else
1366         pa_log_debug("Mhmm, actually there is nothing to rewind.");
1367
1368     pa_sink_process_rewind(u->sink, 0);
1369     return 0;
1370 }
1371
1372 static void thread_func(void *userdata) {
1373     struct userdata *u = userdata;
1374     unsigned short revents = 0;
1375
1376     pa_assert(u);
1377
1378     pa_log_debug("Thread starting up");
1379
1380     if (u->core->realtime_scheduling)
1381         pa_make_realtime(u->core->realtime_priority);
1382
1383     pa_thread_mq_install(&u->thread_mq);
1384
1385     for (;;) {
1386         int ret;
1387
1388 #ifdef DEBUG_TIMING
1389         pa_log_debug("Loop");
1390 #endif
1391
1392         /* Render some data and write it to the dsp */
1393         if (PA_SINK_IS_OPENED(u->sink->thread_info.state)) {
1394             int work_done;
1395             pa_usec_t sleep_usec = 0;
1396             pa_bool_t on_timeout = pa_rtpoll_timer_elapsed(u->rtpoll);
1397
1398             if (PA_UNLIKELY(u->sink->thread_info.rewind_requested))
1399                 if (process_rewind(u) < 0)
1400                         goto fail;
1401
1402             if (u->use_mmap)
1403                 work_done = mmap_write(u, &sleep_usec, revents & POLLOUT, on_timeout);
1404             else
1405                 work_done = unix_write(u, &sleep_usec, revents & POLLOUT, on_timeout);
1406
1407             if (work_done < 0)
1408                 goto fail;
1409
1410 /*             pa_log_debug("work_done = %i", work_done); */
1411
1412             if (work_done) {
1413
1414                 if (u->first) {
1415                     pa_log_info("Starting playback.");
1416                     snd_pcm_start(u->pcm_handle);
1417
1418                     pa_smoother_resume(u->smoother, pa_rtclock_now(), TRUE);
1419                 }
1420
1421                 update_smoother(u);
1422             }
1423
1424             if (u->use_tsched) {
1425                 pa_usec_t cusec;
1426
1427                 if (u->since_start <= u->hwbuf_size) {
1428
1429                     /* USB devices on ALSA seem to hit a buffer
1430                      * underrun during the first iterations much
1431                      * quicker then we calculate here, probably due to
1432                      * the transport latency. To accommodate for that
1433                      * we artificially decrease the sleep time until
1434                      * we have filled the buffer at least once
1435                      * completely.*/
1436
1437                     if (pa_log_ratelimit())
1438                         pa_log_debug("Cutting sleep time for the initial iterations by half.");
1439                     sleep_usec /= 2;
1440                 }
1441
1442                 /* OK, the playback buffer is now full, let's
1443                  * calculate when to wake up next */
1444 /*                 pa_log_debug("Waking up in %0.2fms (sound card clock).", (double) sleep_usec / PA_USEC_PER_MSEC); */
1445
1446                 /* Convert from the sound card time domain to the
1447                  * system time domain */
1448                 cusec = pa_smoother_translate(u->smoother, pa_rtclock_now(), sleep_usec);
1449
1450 /*                 pa_log_debug("Waking up in %0.2fms (system clock).", (double) cusec / PA_USEC_PER_MSEC); */
1451
1452                 /* We don't trust the conversion, so we wake up whatever comes first */
1453                 pa_rtpoll_set_timer_relative(u->rtpoll, PA_MIN(sleep_usec, cusec));
1454             }
1455
1456             u->first = FALSE;
1457             u->after_rewind = FALSE;
1458
1459         } else if (u->use_tsched)
1460
1461             /* OK, we're in an invalid state, let's disable our timers */
1462             pa_rtpoll_set_timer_disabled(u->rtpoll);
1463
1464         /* Hmm, nothing to do. Let's sleep */
1465         if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
1466             goto fail;
1467
1468         if (ret == 0)
1469             goto finish;
1470
1471         /* Tell ALSA about this and process its response */
1472         if (PA_SINK_IS_OPENED(u->sink->thread_info.state)) {
1473             struct pollfd *pollfd;
1474             int err;
1475             unsigned n;
1476
1477             pollfd = pa_rtpoll_item_get_pollfd(u->alsa_rtpoll_item, &n);
1478
1479             if ((err = snd_pcm_poll_descriptors_revents(u->pcm_handle, pollfd, n, &revents)) < 0) {
1480                 pa_log("snd_pcm_poll_descriptors_revents() failed: %s", pa_alsa_strerror(err));
1481                 goto fail;
1482             }
1483
1484             if (revents & ~POLLOUT) {
1485                 if (pa_alsa_recover_from_poll(u->pcm_handle, revents) < 0)
1486                     goto fail;
1487
1488                 u->first = TRUE;
1489                 u->since_start = 0;
1490             } else if (revents && u->use_tsched && pa_log_ratelimit())
1491                 pa_log_debug("Wakeup from ALSA!");
1492
1493         } else
1494             revents = 0;
1495     }
1496
1497 fail:
1498     /* If this was no regular exit from the loop we have to continue
1499      * processing messages until we received PA_MESSAGE_SHUTDOWN */
1500     pa_asyncmsgq_post(u->thread_mq.outq, PA_MSGOBJECT(u->core), PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0, NULL, NULL);
1501     pa_asyncmsgq_wait_for(u->thread_mq.inq, PA_MESSAGE_SHUTDOWN);
1502
1503 finish:
1504     pa_log_debug("Thread shutting down");
1505 }
1506
1507 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) {
1508     const char *n;
1509     char *t;
1510
1511     pa_assert(data);
1512     pa_assert(ma);
1513     pa_assert(device_name);
1514
1515     if ((n = pa_modargs_get_value(ma, "sink_name", NULL))) {
1516         pa_sink_new_data_set_name(data, n);
1517         data->namereg_fail = TRUE;
1518         return;
1519     }
1520
1521     if ((n = pa_modargs_get_value(ma, "name", NULL)))
1522         data->namereg_fail = TRUE;
1523     else {
1524         n = device_id ? device_id : device_name;
1525         data->namereg_fail = FALSE;
1526     }
1527
1528     if (mapping)
1529         t = pa_sprintf_malloc("alsa_output.%s.%s", n, mapping->name);
1530     else
1531         t = pa_sprintf_malloc("alsa_output.%s", n);
1532
1533     pa_sink_new_data_set_name(data, t);
1534     pa_xfree(t);
1535 }
1536
1537 static void find_mixer(struct userdata *u, pa_alsa_mapping *mapping, const char *element, pa_bool_t ignore_dB) {
1538
1539     if (!mapping && !element)
1540         return;
1541
1542     if (!(u->mixer_handle = pa_alsa_open_mixer_for_pcm(u->pcm_handle, &u->control_device))) {
1543         pa_log_info("Failed to find a working mixer device.");
1544         return;
1545     }
1546
1547     if (element) {
1548
1549         if (!(u->mixer_path = pa_alsa_path_synthesize(element, PA_ALSA_DIRECTION_OUTPUT)))
1550             goto fail;
1551
1552         if (pa_alsa_path_probe(u->mixer_path, u->mixer_handle, ignore_dB) < 0)
1553             goto fail;
1554
1555         pa_log_debug("Probed mixer path %s:", u->mixer_path->name);
1556         pa_alsa_path_dump(u->mixer_path);
1557     } else {
1558
1559         if (!(u->mixer_path_set = pa_alsa_path_set_new(mapping, PA_ALSA_DIRECTION_OUTPUT)))
1560             goto fail;
1561
1562         pa_alsa_path_set_probe(u->mixer_path_set, u->mixer_handle, ignore_dB);
1563
1564         pa_log_debug("Probed mixer paths:");
1565         pa_alsa_path_set_dump(u->mixer_path_set);
1566     }
1567
1568     return;
1569
1570 fail:
1571
1572     if (u->mixer_path_set) {
1573         pa_alsa_path_set_free(u->mixer_path_set);
1574         u->mixer_path_set = NULL;
1575     } else if (u->mixer_path) {
1576         pa_alsa_path_free(u->mixer_path);
1577         u->mixer_path = NULL;
1578     }
1579
1580     if (u->mixer_handle) {
1581         snd_mixer_close(u->mixer_handle);
1582         u->mixer_handle = NULL;
1583     }
1584 }
1585
1586 static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB) {
1587     pa_assert(u);
1588
1589     if (!u->mixer_handle)
1590         return 0;
1591
1592     if (u->sink->active_port) {
1593         pa_alsa_port_data *data;
1594
1595         /* We have a list of supported paths, so let's activate the
1596          * one that has been chosen as active */
1597
1598         data = PA_DEVICE_PORT_DATA(u->sink->active_port);
1599         u->mixer_path = data->path;
1600
1601         pa_alsa_path_select(data->path, u->mixer_handle);
1602
1603         if (data->setting)
1604             pa_alsa_setting_select(data->setting, u->mixer_handle);
1605
1606     } else {
1607
1608         if (!u->mixer_path && u->mixer_path_set)
1609             u->mixer_path = u->mixer_path_set->paths;
1610
1611         if (u->mixer_path) {
1612             /* Hmm, we have only a single path, then let's activate it */
1613
1614             pa_alsa_path_select(u->mixer_path, u->mixer_handle);
1615
1616             if (u->mixer_path->settings)
1617                 pa_alsa_setting_select(u->mixer_path->settings, u->mixer_handle);
1618         } else
1619             return 0;
1620     }
1621
1622     /* FIXME: need automatic detection rather than hard-coded path */
1623     if (!strcmp(u->mixer_path->name, "iec958-passthrough-output")) {
1624         u->sink->flags |= PA_SINK_PASSTHROUGH;
1625     } else {
1626         u->sink->flags &= ~PA_SINK_PASSTHROUGH;
1627     }
1628
1629     if (!u->mixer_path->has_volume)
1630         pa_log_info("Driver does not support hardware volume control, falling back to software volume control.");
1631     else {
1632
1633         if (u->mixer_path->has_dB) {
1634             pa_log_info("Hardware volume ranges from %0.2f dB to %0.2f dB.", u->mixer_path->min_dB, u->mixer_path->max_dB);
1635
1636             u->sink->base_volume = pa_sw_volume_from_dB(-u->mixer_path->max_dB);
1637             u->sink->n_volume_steps = PA_VOLUME_NORM+1;
1638
1639             if (u->mixer_path->max_dB > 0.0)
1640                 pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(u->sink->base_volume));
1641             else
1642                 pa_log_info("No particular base volume set, fixing to 0 dB");
1643
1644         } else {
1645             pa_log_info("Hardware volume ranges from %li to %li.", u->mixer_path->min_volume, u->mixer_path->max_volume);
1646             u->sink->base_volume = PA_VOLUME_NORM;
1647             u->sink->n_volume_steps = u->mixer_path->max_volume - u->mixer_path->min_volume + 1;
1648         }
1649
1650         u->sink->get_volume = sink_get_volume_cb;
1651         u->sink->set_volume = sink_set_volume_cb;
1652
1653         u->sink->flags |= PA_SINK_HW_VOLUME_CTRL | (u->mixer_path->has_dB ? PA_SINK_DECIBEL_VOLUME : 0);
1654         pa_log_info("Using hardware volume control. Hardware dB scale %s.", u->mixer_path->has_dB ? "supported" : "not supported");
1655     }
1656
1657     if (!u->mixer_path->has_mute) {
1658         pa_log_info("Driver does not support hardware mute control, falling back to software mute control.");
1659     } else {
1660         u->sink->get_mute = sink_get_mute_cb;
1661         u->sink->set_mute = sink_set_mute_cb;
1662         u->sink->flags |= PA_SINK_HW_MUTE_CTRL;
1663         pa_log_info("Using hardware mute control.");
1664     }
1665
1666     u->mixer_fdl = pa_alsa_fdlist_new();
1667
1668     if (pa_alsa_fdlist_set_mixer(u->mixer_fdl, u->mixer_handle, u->core->mainloop) < 0) {
1669         pa_log("Failed to initialize file descriptor monitoring");
1670         return -1;
1671     }
1672
1673     if (u->mixer_path_set)
1674         pa_alsa_path_set_set_callback(u->mixer_path_set, u->mixer_handle, mixer_callback, u);
1675     else
1676         pa_alsa_path_set_callback(u->mixer_path, u->mixer_handle, mixer_callback, u);
1677
1678     return 0;
1679 }
1680
1681 pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_card *card, pa_alsa_mapping *mapping) {
1682
1683     struct userdata *u = NULL;
1684     const char *dev_id = NULL;
1685     pa_sample_spec ss, requested_ss;
1686     pa_channel_map map;
1687     uint32_t nfrags, frag_size, buffer_size, tsched_size, tsched_watermark, rewind_safeguard;
1688     snd_pcm_uframes_t period_frames, buffer_frames, tsched_frames;
1689     size_t frame_size;
1690     pa_bool_t use_mmap = TRUE, b, use_tsched = TRUE, d, ignore_dB = FALSE, namereg_fail = FALSE;
1691     pa_sink_new_data data;
1692     pa_alsa_profile_set *profile_set = NULL;
1693
1694     pa_assert(m);
1695     pa_assert(ma);
1696
1697     ss = m->core->default_sample_spec;
1698     map = m->core->default_channel_map;
1699     if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_ALSA) < 0) {
1700         pa_log("Failed to parse sample specification and channel map");
1701         goto fail;
1702     }
1703
1704     requested_ss = ss;
1705     frame_size = pa_frame_size(&ss);
1706
1707     nfrags = m->core->default_n_fragments;
1708     frag_size = (uint32_t) pa_usec_to_bytes(m->core->default_fragment_size_msec*PA_USEC_PER_MSEC, &ss);
1709     if (frag_size <= 0)
1710         frag_size = (uint32_t) frame_size;
1711     tsched_size = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_BUFFER_USEC, &ss);
1712     tsched_watermark = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_WATERMARK_USEC, &ss);
1713
1714     if (pa_modargs_get_value_u32(ma, "fragments", &nfrags) < 0 ||
1715         pa_modargs_get_value_u32(ma, "fragment_size", &frag_size) < 0 ||
1716         pa_modargs_get_value_u32(ma, "tsched_buffer_size", &tsched_size) < 0 ||
1717         pa_modargs_get_value_u32(ma, "tsched_buffer_watermark", &tsched_watermark) < 0) {
1718         pa_log("Failed to parse buffer metrics");
1719         goto fail;
1720     }
1721
1722     buffer_size = nfrags * frag_size;
1723
1724     period_frames = frag_size/frame_size;
1725     buffer_frames = buffer_size/frame_size;
1726     tsched_frames = tsched_size/frame_size;
1727
1728     if (pa_modargs_get_value_boolean(ma, "mmap", &use_mmap) < 0) {
1729         pa_log("Failed to parse mmap argument.");
1730         goto fail;
1731     }
1732
1733     if (pa_modargs_get_value_boolean(ma, "tsched", &use_tsched) < 0) {
1734         pa_log("Failed to parse tsched argument.");
1735         goto fail;
1736     }
1737
1738     if (pa_modargs_get_value_boolean(ma, "ignore_dB", &ignore_dB) < 0) {
1739         pa_log("Failed to parse ignore_dB argument.");
1740         goto fail;
1741     }
1742
1743     rewind_safeguard = DEFAULT_REWIND_SAFEGUARD_BYTES;
1744     if (pa_modargs_get_value_u32(ma, "rewind_safeguard", &rewind_safeguard) < 0) {
1745         pa_log("Failed to parse rewind_safeguard argument");
1746         goto fail;
1747     }
1748
1749     use_tsched = pa_alsa_may_tsched(use_tsched);
1750
1751     u = pa_xnew0(struct userdata, 1);
1752     u->core = m->core;
1753     u->module = m;
1754     u->use_mmap = use_mmap;
1755     u->use_tsched = use_tsched;
1756     u->first = TRUE;
1757     u->rewind_safeguard = rewind_safeguard;
1758     u->rtpoll = pa_rtpoll_new();
1759     pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
1760
1761     u->smoother = pa_smoother_new(
1762             SMOOTHER_ADJUST_USEC,
1763             SMOOTHER_WINDOW_USEC,
1764             TRUE,
1765             TRUE,
1766             5,
1767             pa_rtclock_now(),
1768             TRUE);
1769     u->smoother_interval = SMOOTHER_MIN_INTERVAL;
1770
1771     dev_id = pa_modargs_get_value(
1772             ma, "device_id",
1773             pa_modargs_get_value(ma, "device", DEFAULT_DEVICE));
1774
1775     if (reserve_init(u, dev_id) < 0)
1776         goto fail;
1777
1778     if (reserve_monitor_init(u, dev_id) < 0)
1779         goto fail;
1780
1781     b = use_mmap;
1782     d = use_tsched;
1783
1784     if (mapping) {
1785
1786         if (!(dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
1787             pa_log("device_id= not set");
1788             goto fail;
1789         }
1790
1791         if (!(u->pcm_handle = pa_alsa_open_by_device_id_mapping(
1792                       dev_id,
1793                       &u->device_name,
1794                       &ss, &map,
1795                       SND_PCM_STREAM_PLAYBACK,
1796                       &period_frames, &buffer_frames, tsched_frames,
1797                       &b, &d, mapping)))
1798
1799             goto fail;
1800
1801     } else if ((dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
1802
1803         if (!(profile_set = pa_alsa_profile_set_new(NULL, &map)))
1804             goto fail;
1805
1806         if (!(u->pcm_handle = pa_alsa_open_by_device_id_auto(
1807                       dev_id,
1808                       &u->device_name,
1809                       &ss, &map,
1810                       SND_PCM_STREAM_PLAYBACK,
1811                       &period_frames, &buffer_frames, tsched_frames,
1812                       &b, &d, profile_set, &mapping)))
1813
1814             goto fail;
1815
1816     } else {
1817
1818         if (!(u->pcm_handle = pa_alsa_open_by_device_string(
1819                       pa_modargs_get_value(ma, "device", DEFAULT_DEVICE),
1820                       &u->device_name,
1821                       &ss, &map,
1822                       SND_PCM_STREAM_PLAYBACK,
1823                       &period_frames, &buffer_frames, tsched_frames,
1824                       &b, &d, FALSE)))
1825             goto fail;
1826     }
1827
1828     pa_assert(u->device_name);
1829     pa_log_info("Successfully opened device %s.", u->device_name);
1830
1831     if (pa_alsa_pcm_is_modem(u->pcm_handle)) {
1832         pa_log_notice("Device %s is modem, refusing further initialization.", u->device_name);
1833         goto fail;
1834     }
1835
1836     if (mapping)
1837         pa_log_info("Selected mapping '%s' (%s).", mapping->description, mapping->name);
1838
1839     if (use_mmap && !b) {
1840         pa_log_info("Device doesn't support mmap(), falling back to UNIX read/write mode.");
1841         u->use_mmap = use_mmap = FALSE;
1842     }
1843
1844     if (use_tsched && (!b || !d)) {
1845         pa_log_info("Cannot enable timer-based scheduling, falling back to sound IRQ scheduling.");
1846         u->use_tsched = use_tsched = FALSE;
1847     }
1848
1849     if (u->use_mmap)
1850         pa_log_info("Successfully enabled mmap() mode.");
1851
1852     if (u->use_tsched)
1853         pa_log_info("Successfully enabled timer-based scheduling mode.");
1854
1855     /* ALSA might tweak the sample spec, so recalculate the frame size */
1856     frame_size = pa_frame_size(&ss);
1857
1858     find_mixer(u, mapping, pa_modargs_get_value(ma, "control", NULL), ignore_dB);
1859
1860     pa_sink_new_data_init(&data);
1861     data.driver = driver;
1862     data.module = m;
1863     data.card = card;
1864     set_sink_name(&data, ma, dev_id, u->device_name, mapping);
1865
1866     /* We need to give pa_modargs_get_value_boolean() a pointer to a local
1867      * variable instead of using &data.namereg_fail directly, because
1868      * data.namereg_fail is a bitfield and taking the address of a bitfield
1869      * variable is impossible. */
1870     namereg_fail = data.namereg_fail;
1871     if (pa_modargs_get_value_boolean(ma, "namereg_fail", &namereg_fail) < 0) {
1872         pa_log("Failed to parse boolean argument namereg_fail.");
1873         pa_sink_new_data_done(&data);
1874         goto fail;
1875     }
1876     data.namereg_fail = namereg_fail;
1877
1878     pa_sink_new_data_set_sample_spec(&data, &ss);
1879     pa_sink_new_data_set_channel_map(&data, &map);
1880
1881     pa_alsa_init_proplist_pcm(m->core, data.proplist, u->pcm_handle);
1882     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, u->device_name);
1883     pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_BUFFER_SIZE, "%lu", (unsigned long) (buffer_frames * frame_size));
1884     pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZE, "%lu", (unsigned long) (period_frames * frame_size));
1885     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_ACCESS_MODE, u->use_tsched ? "mmap+timer" : (u->use_mmap ? "mmap" : "serial"));
1886
1887     if (mapping) {
1888         pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_NAME, mapping->name);
1889         pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_DESCRIPTION, mapping->description);
1890     }
1891
1892     pa_alsa_init_description(data.proplist);
1893
1894     if (u->control_device)
1895         pa_alsa_init_proplist_ctl(data.proplist, u->control_device);
1896
1897     if (pa_modargs_get_proplist(ma, "sink_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
1898         pa_log("Invalid properties");
1899         pa_sink_new_data_done(&data);
1900         goto fail;
1901     }
1902
1903     if (u->mixer_path_set)
1904         pa_alsa_add_ports(&data.ports, u->mixer_path_set);
1905
1906     u->sink = pa_sink_new(m->core, &data, PA_SINK_HARDWARE|PA_SINK_LATENCY|(u->use_tsched ? PA_SINK_DYNAMIC_LATENCY : 0));
1907     pa_sink_new_data_done(&data);
1908
1909     if (!u->sink) {
1910         pa_log("Failed to create sink object");
1911         goto fail;
1912     }
1913
1914     u->sink->parent.process_msg = sink_process_msg;
1915     if (u->use_tsched)
1916         u->sink->update_requested_latency = sink_update_requested_latency_cb;
1917     u->sink->set_state = sink_set_state_cb;
1918     u->sink->set_port = sink_set_port_cb;
1919     u->sink->userdata = u;
1920
1921     pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
1922     pa_sink_set_rtpoll(u->sink, u->rtpoll);
1923
1924     u->frame_size = frame_size;
1925     u->fragment_size = frag_size = (size_t) (period_frames * frame_size);
1926     u->hwbuf_size = buffer_size = (size_t) (buffer_frames * frame_size);
1927     pa_cvolume_mute(&u->hardware_volume, u->sink->sample_spec.channels);
1928
1929     pa_log_info("Using %0.1f fragments of size %lu bytes (%0.2fms), buffer size is %lu bytes (%0.2fms)",
1930                 (double) u->hwbuf_size / (double) u->fragment_size,
1931                 (long unsigned) u->fragment_size,
1932                 (double) pa_bytes_to_usec(u->fragment_size, &ss) / PA_USEC_PER_MSEC,
1933                 (long unsigned) u->hwbuf_size,
1934                 (double) pa_bytes_to_usec(u->hwbuf_size, &ss) / PA_USEC_PER_MSEC);
1935
1936     pa_sink_set_max_request(u->sink, u->hwbuf_size);
1937     if (pa_alsa_pcm_is_hw(u->pcm_handle))
1938         pa_sink_set_max_rewind(u->sink, u->hwbuf_size);
1939     else {
1940         pa_log_info("Disabling rewind for device %s", u->device_name);
1941         pa_sink_set_max_rewind(u->sink, 0);
1942     }
1943
1944     if (u->use_tsched) {
1945         u->tsched_watermark = pa_usec_to_bytes_round_up(pa_bytes_to_usec_round_up(tsched_watermark, &requested_ss), &u->sink->sample_spec);
1946
1947         u->watermark_inc_step = pa_usec_to_bytes(TSCHED_WATERMARK_INC_STEP_USEC, &u->sink->sample_spec);
1948         u->watermark_dec_step = pa_usec_to_bytes(TSCHED_WATERMARK_DEC_STEP_USEC, &u->sink->sample_spec);
1949
1950         u->watermark_inc_threshold = pa_usec_to_bytes_round_up(TSCHED_WATERMARK_INC_THRESHOLD_USEC, &u->sink->sample_spec);
1951         u->watermark_dec_threshold = pa_usec_to_bytes_round_up(TSCHED_WATERMARK_DEC_THRESHOLD_USEC, &u->sink->sample_spec);
1952
1953         fix_min_sleep_wakeup(u);
1954         fix_tsched_watermark(u);
1955
1956         pa_sink_set_latency_range(u->sink,
1957                                   0,
1958                                   pa_bytes_to_usec(u->hwbuf_size, &ss));
1959
1960         pa_log_info("Time scheduling watermark is %0.2fms",
1961                     (double) pa_bytes_to_usec(u->tsched_watermark, &ss) / PA_USEC_PER_MSEC);
1962     } else
1963         pa_sink_set_fixed_latency(u->sink, pa_bytes_to_usec(u->hwbuf_size, &ss));
1964
1965     reserve_update(u);
1966
1967     if (update_sw_params(u) < 0)
1968         goto fail;
1969
1970     if (setup_mixer(u, ignore_dB) < 0)
1971         goto fail;
1972
1973     pa_alsa_dump(PA_LOG_DEBUG, u->pcm_handle);
1974
1975     if (!(u->thread = pa_thread_new("alsa-sink", thread_func, u))) {
1976         pa_log("Failed to create thread.");
1977         goto fail;
1978     }
1979
1980     /* Get initial mixer settings */
1981     if (data.volume_is_set) {
1982         if (u->sink->set_volume)
1983             u->sink->set_volume(u->sink);
1984     } else {
1985         if (u->sink->get_volume)
1986             u->sink->get_volume(u->sink);
1987     }
1988
1989     if (data.muted_is_set) {
1990         if (u->sink->set_mute)
1991             u->sink->set_mute(u->sink);
1992     } else {
1993         if (u->sink->get_mute)
1994             u->sink->get_mute(u->sink);
1995     }
1996
1997     pa_sink_put(u->sink);
1998
1999     if (profile_set)
2000         pa_alsa_profile_set_free(profile_set);
2001
2002     return u->sink;
2003
2004 fail:
2005
2006     if (u)
2007         userdata_free(u);
2008
2009     if (profile_set)
2010         pa_alsa_profile_set_free(profile_set);
2011
2012     return NULL;
2013 }
2014
2015 static void userdata_free(struct userdata *u) {
2016     pa_assert(u);
2017
2018     if (u->sink)
2019         pa_sink_unlink(u->sink);
2020
2021     if (u->thread) {
2022         pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
2023         pa_thread_free(u->thread);
2024     }
2025
2026     pa_thread_mq_done(&u->thread_mq);
2027
2028     if (u->sink)
2029         pa_sink_unref(u->sink);
2030
2031     if (u->memchunk.memblock)
2032         pa_memblock_unref(u->memchunk.memblock);
2033
2034     if (u->alsa_rtpoll_item)
2035         pa_rtpoll_item_free(u->alsa_rtpoll_item);
2036
2037     if (u->rtpoll)
2038         pa_rtpoll_free(u->rtpoll);
2039
2040     if (u->pcm_handle) {
2041         snd_pcm_drop(u->pcm_handle);
2042         snd_pcm_close(u->pcm_handle);
2043     }
2044
2045     if (u->mixer_fdl)
2046         pa_alsa_fdlist_free(u->mixer_fdl);
2047
2048     if (u->mixer_path_set)
2049         pa_alsa_path_set_free(u->mixer_path_set);
2050     else if (u->mixer_path)
2051         pa_alsa_path_free(u->mixer_path);
2052
2053     if (u->mixer_handle)
2054         snd_mixer_close(u->mixer_handle);
2055
2056     if (u->smoother)
2057         pa_smoother_free(u->smoother);
2058
2059     reserve_done(u);
2060     monitor_done(u);
2061
2062     pa_xfree(u->device_name);
2063     pa_xfree(u->control_device);
2064     pa_xfree(u);
2065 }
2066
2067 void pa_alsa_sink_free(pa_sink *s) {
2068     struct userdata *u;
2069
2070     pa_sink_assert_ref(s);
2071     pa_assert_se(u = s->userdata);
2072
2073     userdata_free(u);
2074 }