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