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, !u->use_tsched)) < 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->frame_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 -PA_ERR_IO;
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                     int r;
1040
1041                     pa_assert(PA_SINK_IS_OPENED(u->sink->thread_info.state));
1042
1043                     if ((r = suspend(u)) < 0)
1044                         return r;
1045
1046                     break;
1047                 }
1048
1049                 case PA_SINK_IDLE:
1050                 case PA_SINK_RUNNING: {
1051                     int r;
1052
1053                     if (u->sink->thread_info.state == PA_SINK_INIT) {
1054                         if (build_pollfd(u) < 0)
1055                             return -PA_ERR_IO;
1056                     }
1057
1058                     if (u->sink->thread_info.state == PA_SINK_SUSPENDED) {
1059                         if ((r = unsuspend(u)) < 0)
1060                             return r;
1061                     }
1062
1063                     break;
1064                 }
1065
1066                 case PA_SINK_UNLINKED:
1067                 case PA_SINK_INIT:
1068                 case PA_SINK_INVALID_STATE:
1069                     ;
1070             }
1071
1072             break;
1073     }
1074
1075     return pa_sink_process_msg(o, code, data, offset, chunk);
1076 }
1077
1078 /* Called from main context */
1079 static int sink_set_state_cb(pa_sink *s, pa_sink_state_t new_state) {
1080     pa_sink_state_t old_state;
1081     struct userdata *u;
1082
1083     pa_sink_assert_ref(s);
1084     pa_assert_se(u = s->userdata);
1085
1086     old_state = pa_sink_get_state(u->sink);
1087
1088     if (PA_SINK_IS_OPENED(old_state) && new_state == PA_SINK_SUSPENDED)
1089         reserve_done(u);
1090     else if (old_state == PA_SINK_SUSPENDED && PA_SINK_IS_OPENED(new_state))
1091         if (reserve_init(u, u->device_name) < 0)
1092             return -PA_ERR_BUSY;
1093
1094     return 0;
1095 }
1096
1097 static int mixer_callback(snd_mixer_elem_t *elem, unsigned int mask) {
1098     struct userdata *u = snd_mixer_elem_get_callback_private(elem);
1099
1100     pa_assert(u);
1101     pa_assert(u->mixer_handle);
1102
1103     if (mask == SND_CTL_EVENT_MASK_REMOVE)
1104         return 0;
1105
1106     if (mask & SND_CTL_EVENT_MASK_VALUE) {
1107         pa_sink_get_volume(u->sink, TRUE);
1108         pa_sink_get_mute(u->sink, TRUE);
1109     }
1110
1111     return 0;
1112 }
1113
1114 static void sink_get_volume_cb(pa_sink *s) {
1115     struct userdata *u = s->userdata;
1116     pa_cvolume r;
1117     char t[PA_CVOLUME_SNPRINT_MAX];
1118
1119     pa_assert(u);
1120     pa_assert(u->mixer_path);
1121     pa_assert(u->mixer_handle);
1122
1123     if (pa_alsa_path_get_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r) < 0)
1124         return;
1125
1126     /* Shift down by the base volume, so that 0dB becomes maximum volume */
1127     pa_sw_cvolume_multiply_scalar(&r, &r, s->base_volume);
1128
1129     pa_log_debug("Read hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &r));
1130
1131     if (pa_cvolume_equal(&u->hardware_volume, &r))
1132         return;
1133
1134     s->real_volume = u->hardware_volume = r;
1135
1136     /* Hmm, so the hardware volume changed, let's reset our software volume */
1137     if (u->mixer_path->has_dB)
1138         pa_sink_set_soft_volume(s, NULL);
1139 }
1140
1141 static void sink_set_volume_cb(pa_sink *s) {
1142     struct userdata *u = s->userdata;
1143     pa_cvolume r;
1144     char t[PA_CVOLUME_SNPRINT_MAX];
1145
1146     pa_assert(u);
1147     pa_assert(u->mixer_path);
1148     pa_assert(u->mixer_handle);
1149
1150     /* Shift up by the base volume */
1151     pa_sw_cvolume_divide_scalar(&r, &s->real_volume, s->base_volume);
1152
1153     if (pa_alsa_path_set_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r) < 0)
1154         return;
1155
1156     /* Shift down by the base volume, so that 0dB becomes maximum volume */
1157     pa_sw_cvolume_multiply_scalar(&r, &r, s->base_volume);
1158
1159     u->hardware_volume = r;
1160
1161     if (u->mixer_path->has_dB) {
1162         pa_cvolume new_soft_volume;
1163         pa_bool_t accurate_enough;
1164
1165         /* Match exactly what the user requested by software */
1166         pa_sw_cvolume_divide(&new_soft_volume, &s->real_volume, &u->hardware_volume);
1167
1168         /* If the adjustment to do in software is only minimal we
1169          * can skip it. That saves us CPU at the expense of a bit of
1170          * accuracy */
1171         accurate_enough =
1172             (pa_cvolume_min(&new_soft_volume) >= (PA_VOLUME_NORM - VOLUME_ACCURACY)) &&
1173             (pa_cvolume_max(&new_soft_volume) <= (PA_VOLUME_NORM + VOLUME_ACCURACY));
1174
1175         pa_log_debug("Requested volume: %s", pa_cvolume_snprint(t, sizeof(t), &s->real_volume));
1176         pa_log_debug("Got hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &u->hardware_volume));
1177         pa_log_debug("Calculated software volume: %s (accurate-enough=%s)", pa_cvolume_snprint(t, sizeof(t), &new_soft_volume),
1178                      pa_yes_no(accurate_enough));
1179
1180         if (!accurate_enough)
1181             s->soft_volume = new_soft_volume;
1182
1183     } else {
1184         pa_log_debug("Wrote hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &r));
1185
1186         /* We can't match exactly what the user requested, hence let's
1187          * at least tell the user about it */
1188
1189         s->real_volume = r;
1190     }
1191 }
1192
1193 static void sink_get_mute_cb(pa_sink *s) {
1194     struct userdata *u = s->userdata;
1195     pa_bool_t b;
1196
1197     pa_assert(u);
1198     pa_assert(u->mixer_path);
1199     pa_assert(u->mixer_handle);
1200
1201     if (pa_alsa_path_get_mute(u->mixer_path, u->mixer_handle, &b) < 0)
1202         return;
1203
1204     s->muted = b;
1205 }
1206
1207 static void sink_set_mute_cb(pa_sink *s) {
1208     struct userdata *u = s->userdata;
1209
1210     pa_assert(u);
1211     pa_assert(u->mixer_path);
1212     pa_assert(u->mixer_handle);
1213
1214     pa_alsa_path_set_mute(u->mixer_path, u->mixer_handle, s->muted);
1215 }
1216
1217 static int sink_set_port_cb(pa_sink *s, pa_device_port *p) {
1218     struct userdata *u = s->userdata;
1219     pa_alsa_port_data *data;
1220
1221     pa_assert(u);
1222     pa_assert(p);
1223     pa_assert(u->mixer_handle);
1224
1225     data = PA_DEVICE_PORT_DATA(p);
1226
1227     pa_assert_se(u->mixer_path = data->path);
1228     pa_alsa_path_select(u->mixer_path, u->mixer_handle);
1229
1230     if (u->mixer_path->has_volume && u->mixer_path->has_dB) {
1231         s->base_volume = pa_sw_volume_from_dB(-u->mixer_path->max_dB);
1232         s->n_volume_steps = PA_VOLUME_NORM+1;
1233
1234         if (u->mixer_path->max_dB > 0.0)
1235             pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(s->base_volume));
1236         else
1237             pa_log_info("No particular base volume set, fixing to 0 dB");
1238     } else {
1239         s->base_volume = PA_VOLUME_NORM;
1240         s->n_volume_steps = u->mixer_path->max_volume - u->mixer_path->min_volume + 1;
1241     }
1242
1243     if (data->setting)
1244         pa_alsa_setting_select(data->setting, u->mixer_handle);
1245
1246     if (s->set_mute)
1247         s->set_mute(s);
1248     if (s->set_volume)
1249         s->set_volume(s);
1250
1251     return 0;
1252 }
1253
1254 static void sink_update_requested_latency_cb(pa_sink *s) {
1255     struct userdata *u = s->userdata;
1256     size_t before;
1257     pa_assert(u);
1258
1259     if (!u->pcm_handle)
1260         return;
1261
1262     before = u->hwbuf_unused;
1263     update_sw_params(u);
1264
1265     /* Let's check whether we now use only a smaller part of the
1266     buffer then before. If so, we need to make sure that subsequent
1267     rewinds are relative to the new maximum fill level and not to the
1268     current fill level. Thus, let's do a full rewind once, to clear
1269     things up. */
1270
1271     if (u->hwbuf_unused > before) {
1272         pa_log_debug("Requesting rewind due to latency change.");
1273         pa_sink_request_rewind(s, (size_t) -1);
1274     }
1275 }
1276
1277 static int process_rewind(struct userdata *u) {
1278     snd_pcm_sframes_t unused;
1279     size_t rewind_nbytes, unused_nbytes, limit_nbytes;
1280     pa_assert(u);
1281
1282     /* Figure out how much we shall rewind and reset the counter */
1283     rewind_nbytes = u->sink->thread_info.rewind_nbytes;
1284
1285     pa_log_debug("Requested to rewind %lu bytes.", (unsigned long) rewind_nbytes);
1286
1287     if (PA_UNLIKELY((unused = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->sink->sample_spec)) < 0)) {
1288         pa_log("snd_pcm_avail() failed: %s", pa_alsa_strerror((int) unused));
1289         return -1;
1290     }
1291
1292     unused_nbytes = u->tsched_watermark + (size_t) unused * u->frame_size;
1293
1294     if (u->hwbuf_size > unused_nbytes)
1295         limit_nbytes = u->hwbuf_size - unused_nbytes;
1296     else
1297         limit_nbytes = 0;
1298
1299     if (rewind_nbytes > limit_nbytes)
1300         rewind_nbytes = limit_nbytes;
1301
1302     if (rewind_nbytes > 0) {
1303         snd_pcm_sframes_t in_frames, out_frames;
1304
1305         pa_log_debug("Limited to %lu bytes.", (unsigned long) rewind_nbytes);
1306
1307         in_frames = (snd_pcm_sframes_t) (rewind_nbytes / u->frame_size);
1308         pa_log_debug("before: %lu", (unsigned long) in_frames);
1309         if ((out_frames = snd_pcm_rewind(u->pcm_handle, (snd_pcm_uframes_t) in_frames)) < 0) {
1310             pa_log("snd_pcm_rewind() failed: %s", pa_alsa_strerror((int) out_frames));
1311             if (try_recover(u, "process_rewind", out_frames) < 0)
1312                 return -1;
1313             out_frames = 0;
1314         }
1315
1316         pa_log_debug("after: %lu", (unsigned long) out_frames);
1317
1318         rewind_nbytes = (size_t) out_frames * u->frame_size;
1319
1320         if (rewind_nbytes <= 0)
1321             pa_log_info("Tried rewind, but was apparently not possible.");
1322         else {
1323             u->write_count -= rewind_nbytes;
1324             pa_log_debug("Rewound %lu bytes.", (unsigned long) rewind_nbytes);
1325             pa_sink_process_rewind(u->sink, rewind_nbytes);
1326
1327             u->after_rewind = TRUE;
1328             return 0;
1329         }
1330     } else
1331         pa_log_debug("Mhmm, actually there is nothing to rewind.");
1332
1333     pa_sink_process_rewind(u->sink, 0);
1334     return 0;
1335 }
1336
1337 static void thread_func(void *userdata) {
1338     struct userdata *u = userdata;
1339     unsigned short revents = 0;
1340
1341     pa_assert(u);
1342
1343     pa_log_debug("Thread starting up");
1344
1345     if (u->core->realtime_scheduling)
1346         pa_make_realtime(u->core->realtime_priority);
1347
1348     pa_thread_mq_install(&u->thread_mq);
1349
1350     for (;;) {
1351         int ret;
1352
1353 #ifdef DEBUG_TIMING
1354         pa_log_debug("Loop");
1355 #endif
1356
1357         /* Render some data and write it to the dsp */
1358         if (PA_SINK_IS_OPENED(u->sink->thread_info.state)) {
1359             int work_done;
1360             pa_usec_t sleep_usec = 0;
1361             pa_bool_t on_timeout = pa_rtpoll_timer_elapsed(u->rtpoll);
1362
1363             if (PA_UNLIKELY(u->sink->thread_info.rewind_requested))
1364                 if (process_rewind(u) < 0)
1365                         goto fail;
1366
1367             if (u->use_mmap)
1368                 work_done = mmap_write(u, &sleep_usec, revents & POLLOUT, on_timeout);
1369             else
1370                 work_done = unix_write(u, &sleep_usec, revents & POLLOUT, on_timeout);
1371
1372             if (work_done < 0)
1373                 goto fail;
1374
1375 /*             pa_log_debug("work_done = %i", work_done); */
1376
1377             if (work_done) {
1378
1379                 if (u->first) {
1380                     pa_log_info("Starting playback.");
1381                     snd_pcm_start(u->pcm_handle);
1382
1383                     pa_smoother_resume(u->smoother, pa_rtclock_now(), TRUE);
1384                 }
1385
1386                 update_smoother(u);
1387             }
1388
1389             if (u->use_tsched) {
1390                 pa_usec_t cusec;
1391
1392                 if (u->since_start <= u->hwbuf_size) {
1393
1394                     /* USB devices on ALSA seem to hit a buffer
1395                      * underrun during the first iterations much
1396                      * quicker then we calculate here, probably due to
1397                      * the transport latency. To accommodate for that
1398                      * we artificially decrease the sleep time until
1399                      * we have filled the buffer at least once
1400                      * completely.*/
1401
1402                     if (pa_log_ratelimit())
1403                         pa_log_debug("Cutting sleep time for the initial iterations by half.");
1404                     sleep_usec /= 2;
1405                 }
1406
1407                 /* OK, the playback buffer is now full, let's
1408                  * calculate when to wake up next */
1409 /*                 pa_log_debug("Waking up in %0.2fms (sound card clock).", (double) sleep_usec / PA_USEC_PER_MSEC); */
1410
1411                 /* Convert from the sound card time domain to the
1412                  * system time domain */
1413                 cusec = pa_smoother_translate(u->smoother, pa_rtclock_now(), sleep_usec);
1414
1415 /*                 pa_log_debug("Waking up in %0.2fms (system clock).", (double) cusec / PA_USEC_PER_MSEC); */
1416
1417                 /* We don't trust the conversion, so we wake up whatever comes first */
1418                 pa_rtpoll_set_timer_relative(u->rtpoll, PA_MIN(sleep_usec, cusec));
1419             }
1420
1421             u->first = FALSE;
1422             u->after_rewind = FALSE;
1423
1424         } else if (u->use_tsched)
1425
1426             /* OK, we're in an invalid state, let's disable our timers */
1427             pa_rtpoll_set_timer_disabled(u->rtpoll);
1428
1429         /* Hmm, nothing to do. Let's sleep */
1430         if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
1431             goto fail;
1432
1433         if (ret == 0)
1434             goto finish;
1435
1436         /* Tell ALSA about this and process its response */
1437         if (PA_SINK_IS_OPENED(u->sink->thread_info.state)) {
1438             struct pollfd *pollfd;
1439             int err;
1440             unsigned n;
1441
1442             pollfd = pa_rtpoll_item_get_pollfd(u->alsa_rtpoll_item, &n);
1443
1444             if ((err = snd_pcm_poll_descriptors_revents(u->pcm_handle, pollfd, n, &revents)) < 0) {
1445                 pa_log("snd_pcm_poll_descriptors_revents() failed: %s", pa_alsa_strerror(err));
1446                 goto fail;
1447             }
1448
1449             if (revents & ~POLLOUT) {
1450                 if (pa_alsa_recover_from_poll(u->pcm_handle, revents) < 0)
1451                     goto fail;
1452
1453                 u->first = TRUE;
1454                 u->since_start = 0;
1455             } else if (revents && u->use_tsched && pa_log_ratelimit())
1456                 pa_log_debug("Wakeup from ALSA!");
1457
1458         } else
1459             revents = 0;
1460     }
1461
1462 fail:
1463     /* If this was no regular exit from the loop we have to continue
1464      * processing messages until we received PA_MESSAGE_SHUTDOWN */
1465     pa_asyncmsgq_post(u->thread_mq.outq, PA_MSGOBJECT(u->core), PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0, NULL, NULL);
1466     pa_asyncmsgq_wait_for(u->thread_mq.inq, PA_MESSAGE_SHUTDOWN);
1467
1468 finish:
1469     pa_log_debug("Thread shutting down");
1470 }
1471
1472 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) {
1473     const char *n;
1474     char *t;
1475
1476     pa_assert(data);
1477     pa_assert(ma);
1478     pa_assert(device_name);
1479
1480     if ((n = pa_modargs_get_value(ma, "sink_name", NULL))) {
1481         pa_sink_new_data_set_name(data, n);
1482         data->namereg_fail = TRUE;
1483         return;
1484     }
1485
1486     if ((n = pa_modargs_get_value(ma, "name", NULL)))
1487         data->namereg_fail = TRUE;
1488     else {
1489         n = device_id ? device_id : device_name;
1490         data->namereg_fail = FALSE;
1491     }
1492
1493     if (mapping)
1494         t = pa_sprintf_malloc("alsa_output.%s.%s", n, mapping->name);
1495     else
1496         t = pa_sprintf_malloc("alsa_output.%s", n);
1497
1498     pa_sink_new_data_set_name(data, t);
1499     pa_xfree(t);
1500 }
1501
1502 static void find_mixer(struct userdata *u, pa_alsa_mapping *mapping, const char *element, pa_bool_t ignore_dB) {
1503
1504     if (!mapping && !element)
1505         return;
1506
1507     if (!(u->mixer_handle = pa_alsa_open_mixer_for_pcm(u->pcm_handle, &u->control_device))) {
1508         pa_log_info("Failed to find a working mixer device.");
1509         return;
1510     }
1511
1512     if (element) {
1513
1514         if (!(u->mixer_path = pa_alsa_path_synthesize(element, PA_ALSA_DIRECTION_OUTPUT)))
1515             goto fail;
1516
1517         if (pa_alsa_path_probe(u->mixer_path, u->mixer_handle, ignore_dB) < 0)
1518             goto fail;
1519
1520         pa_log_debug("Probed mixer path %s:", u->mixer_path->name);
1521         pa_alsa_path_dump(u->mixer_path);
1522     } else {
1523
1524         if (!(u->mixer_path_set = pa_alsa_path_set_new(mapping, PA_ALSA_DIRECTION_OUTPUT)))
1525             goto fail;
1526
1527         pa_alsa_path_set_probe(u->mixer_path_set, u->mixer_handle, ignore_dB);
1528
1529         pa_log_debug("Probed mixer paths:");
1530         pa_alsa_path_set_dump(u->mixer_path_set);
1531     }
1532
1533     return;
1534
1535 fail:
1536
1537     if (u->mixer_path_set) {
1538         pa_alsa_path_set_free(u->mixer_path_set);
1539         u->mixer_path_set = NULL;
1540     } else if (u->mixer_path) {
1541         pa_alsa_path_free(u->mixer_path);
1542         u->mixer_path = NULL;
1543     }
1544
1545     if (u->mixer_handle) {
1546         snd_mixer_close(u->mixer_handle);
1547         u->mixer_handle = NULL;
1548     }
1549 }
1550
1551 static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB) {
1552     pa_assert(u);
1553
1554     if (!u->mixer_handle)
1555         return 0;
1556
1557     if (u->sink->active_port) {
1558         pa_alsa_port_data *data;
1559
1560         /* We have a list of supported paths, so let's activate the
1561          * one that has been chosen as active */
1562
1563         data = PA_DEVICE_PORT_DATA(u->sink->active_port);
1564         u->mixer_path = data->path;
1565
1566         pa_alsa_path_select(data->path, u->mixer_handle);
1567
1568         if (data->setting)
1569             pa_alsa_setting_select(data->setting, u->mixer_handle);
1570
1571     } else {
1572
1573         if (!u->mixer_path && u->mixer_path_set)
1574             u->mixer_path = u->mixer_path_set->paths;
1575
1576         if (u->mixer_path) {
1577             /* Hmm, we have only a single path, then let's activate it */
1578
1579             pa_alsa_path_select(u->mixer_path, u->mixer_handle);
1580
1581             if (u->mixer_path->settings)
1582                 pa_alsa_setting_select(u->mixer_path->settings, u->mixer_handle);
1583         } else
1584             return 0;
1585     }
1586
1587     if (!u->mixer_path->has_volume)
1588         pa_log_info("Driver does not support hardware volume control, falling back to software volume control.");
1589     else {
1590
1591         if (u->mixer_path->has_dB) {
1592             pa_log_info("Hardware volume ranges from %0.2f dB to %0.2f dB.", u->mixer_path->min_dB, u->mixer_path->max_dB);
1593
1594             u->sink->base_volume = pa_sw_volume_from_dB(-u->mixer_path->max_dB);
1595             u->sink->n_volume_steps = PA_VOLUME_NORM+1;
1596
1597             if (u->mixer_path->max_dB > 0.0)
1598                 pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(u->sink->base_volume));
1599             else
1600                 pa_log_info("No particular base volume set, fixing to 0 dB");
1601
1602         } else {
1603             pa_log_info("Hardware volume ranges from %li to %li.", u->mixer_path->min_volume, u->mixer_path->max_volume);
1604             u->sink->base_volume = PA_VOLUME_NORM;
1605             u->sink->n_volume_steps = u->mixer_path->max_volume - u->mixer_path->min_volume + 1;
1606         }
1607
1608         u->sink->get_volume = sink_get_volume_cb;
1609         u->sink->set_volume = sink_set_volume_cb;
1610
1611         u->sink->flags |= PA_SINK_HW_VOLUME_CTRL | (u->mixer_path->has_dB ? PA_SINK_DECIBEL_VOLUME : 0);
1612         pa_log_info("Using hardware volume control. Hardware dB scale %s.", u->mixer_path->has_dB ? "supported" : "not supported");
1613     }
1614
1615     if (!u->mixer_path->has_mute) {
1616         pa_log_info("Driver does not support hardware mute control, falling back to software mute control.");
1617     } else {
1618         u->sink->get_mute = sink_get_mute_cb;
1619         u->sink->set_mute = sink_set_mute_cb;
1620         u->sink->flags |= PA_SINK_HW_MUTE_CTRL;
1621         pa_log_info("Using hardware mute control.");
1622     }
1623
1624     u->mixer_fdl = pa_alsa_fdlist_new();
1625
1626     if (pa_alsa_fdlist_set_mixer(u->mixer_fdl, u->mixer_handle, u->core->mainloop) < 0) {
1627         pa_log("Failed to initialize file descriptor monitoring");
1628         return -1;
1629     }
1630
1631     if (u->mixer_path_set)
1632         pa_alsa_path_set_set_callback(u->mixer_path_set, u->mixer_handle, mixer_callback, u);
1633     else
1634         pa_alsa_path_set_callback(u->mixer_path, u->mixer_handle, mixer_callback, u);
1635
1636     return 0;
1637 }
1638
1639 pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_card *card, pa_alsa_mapping *mapping) {
1640
1641     struct userdata *u = NULL;
1642     const char *dev_id = NULL;
1643     pa_sample_spec ss, requested_ss;
1644     pa_channel_map map;
1645     uint32_t nfrags, frag_size, buffer_size, tsched_size, tsched_watermark;
1646     snd_pcm_uframes_t period_frames, buffer_frames, tsched_frames;
1647     size_t frame_size;
1648     pa_bool_t use_mmap = TRUE, b, use_tsched = TRUE, d, ignore_dB = FALSE;
1649     pa_sink_new_data data;
1650     pa_alsa_profile_set *profile_set = NULL;
1651
1652     pa_assert(m);
1653     pa_assert(ma);
1654
1655     ss = m->core->default_sample_spec;
1656     map = m->core->default_channel_map;
1657     if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_ALSA) < 0) {
1658         pa_log("Failed to parse sample specification and channel map");
1659         goto fail;
1660     }
1661
1662     requested_ss = ss;
1663     frame_size = pa_frame_size(&ss);
1664
1665     nfrags = m->core->default_n_fragments;
1666     frag_size = (uint32_t) pa_usec_to_bytes(m->core->default_fragment_size_msec*PA_USEC_PER_MSEC, &ss);
1667     if (frag_size <= 0)
1668         frag_size = (uint32_t) frame_size;
1669     tsched_size = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_BUFFER_USEC, &ss);
1670     tsched_watermark = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_WATERMARK_USEC, &ss);
1671
1672     if (pa_modargs_get_value_u32(ma, "fragments", &nfrags) < 0 ||
1673         pa_modargs_get_value_u32(ma, "fragment_size", &frag_size) < 0 ||
1674         pa_modargs_get_value_u32(ma, "tsched_buffer_size", &tsched_size) < 0 ||
1675         pa_modargs_get_value_u32(ma, "tsched_buffer_watermark", &tsched_watermark) < 0) {
1676         pa_log("Failed to parse buffer metrics");
1677         goto fail;
1678     }
1679
1680     buffer_size = nfrags * frag_size;
1681
1682     period_frames = frag_size/frame_size;
1683     buffer_frames = buffer_size/frame_size;
1684     tsched_frames = tsched_size/frame_size;
1685
1686     if (pa_modargs_get_value_boolean(ma, "mmap", &use_mmap) < 0) {
1687         pa_log("Failed to parse mmap argument.");
1688         goto fail;
1689     }
1690
1691     if (pa_modargs_get_value_boolean(ma, "tsched", &use_tsched) < 0) {
1692         pa_log("Failed to parse tsched argument.");
1693         goto fail;
1694     }
1695
1696     if (pa_modargs_get_value_boolean(ma, "ignore_dB", &ignore_dB) < 0) {
1697         pa_log("Failed to parse ignore_dB argument.");
1698         goto fail;
1699     }
1700
1701     use_tsched = pa_alsa_may_tsched(use_tsched);
1702
1703     u = pa_xnew0(struct userdata, 1);
1704     u->core = m->core;
1705     u->module = m;
1706     u->use_mmap = use_mmap;
1707     u->use_tsched = use_tsched;
1708     u->first = TRUE;
1709     u->rtpoll = pa_rtpoll_new();
1710     pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
1711
1712     u->smoother = pa_smoother_new(
1713             DEFAULT_TSCHED_BUFFER_USEC*2,
1714             DEFAULT_TSCHED_BUFFER_USEC*2,
1715             TRUE,
1716             TRUE,
1717             5,
1718             pa_rtclock_now(),
1719             TRUE);
1720     u->smoother_interval = SMOOTHER_MIN_INTERVAL;
1721
1722     dev_id = pa_modargs_get_value(
1723             ma, "device_id",
1724             pa_modargs_get_value(ma, "device", DEFAULT_DEVICE));
1725
1726     if (reserve_init(u, dev_id) < 0)
1727         goto fail;
1728
1729     if (reserve_monitor_init(u, dev_id) < 0)
1730         goto fail;
1731
1732     b = use_mmap;
1733     d = use_tsched;
1734
1735     if (mapping) {
1736
1737         if (!(dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
1738             pa_log("device_id= not set");
1739             goto fail;
1740         }
1741
1742         if (!(u->pcm_handle = pa_alsa_open_by_device_id_mapping(
1743                       dev_id,
1744                       &u->device_name,
1745                       &ss, &map,
1746                       SND_PCM_STREAM_PLAYBACK,
1747                       &period_frames, &buffer_frames, tsched_frames,
1748                       &b, &d, mapping)))
1749
1750             goto fail;
1751
1752     } else if ((dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
1753
1754         if (!(profile_set = pa_alsa_profile_set_new(NULL, &map)))
1755             goto fail;
1756
1757         if (!(u->pcm_handle = pa_alsa_open_by_device_id_auto(
1758                       dev_id,
1759                       &u->device_name,
1760                       &ss, &map,
1761                       SND_PCM_STREAM_PLAYBACK,
1762                       &period_frames, &buffer_frames, tsched_frames,
1763                       &b, &d, profile_set, &mapping)))
1764
1765             goto fail;
1766
1767     } else {
1768
1769         if (!(u->pcm_handle = pa_alsa_open_by_device_string(
1770                       pa_modargs_get_value(ma, "device", DEFAULT_DEVICE),
1771                       &u->device_name,
1772                       &ss, &map,
1773                       SND_PCM_STREAM_PLAYBACK,
1774                       &period_frames, &buffer_frames, tsched_frames,
1775                       &b, &d, FALSE)))
1776             goto fail;
1777     }
1778
1779     pa_assert(u->device_name);
1780     pa_log_info("Successfully opened device %s.", u->device_name);
1781
1782     if (pa_alsa_pcm_is_modem(u->pcm_handle)) {
1783         pa_log_notice("Device %s is modem, refusing further initialization.", u->device_name);
1784         goto fail;
1785     }
1786
1787     if (mapping)
1788         pa_log_info("Selected mapping '%s' (%s).", mapping->description, mapping->name);
1789
1790     if (use_mmap && !b) {
1791         pa_log_info("Device doesn't support mmap(), falling back to UNIX read/write mode.");
1792         u->use_mmap = use_mmap = FALSE;
1793     }
1794
1795     if (use_tsched && (!b || !d)) {
1796         pa_log_info("Cannot enable timer-based scheduling, falling back to sound IRQ scheduling.");
1797         u->use_tsched = use_tsched = FALSE;
1798     }
1799
1800     if (u->use_mmap)
1801         pa_log_info("Successfully enabled mmap() mode.");
1802
1803     if (u->use_tsched)
1804         pa_log_info("Successfully enabled timer-based scheduling mode.");
1805
1806     /* ALSA might tweak the sample spec, so recalculate the frame size */
1807     frame_size = pa_frame_size(&ss);
1808
1809     find_mixer(u, mapping, pa_modargs_get_value(ma, "control", NULL), ignore_dB);
1810
1811     pa_sink_new_data_init(&data);
1812     data.driver = driver;
1813     data.module = m;
1814     data.card = card;
1815     set_sink_name(&data, ma, dev_id, u->device_name, mapping);
1816     pa_sink_new_data_set_sample_spec(&data, &ss);
1817     pa_sink_new_data_set_channel_map(&data, &map);
1818
1819     pa_alsa_init_proplist_pcm(m->core, data.proplist, u->pcm_handle);
1820     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, u->device_name);
1821     pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_BUFFER_SIZE, "%lu", (unsigned long) (buffer_frames * frame_size));
1822     pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZE, "%lu", (unsigned long) (period_frames * frame_size));
1823     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_ACCESS_MODE, u->use_tsched ? "mmap+timer" : (u->use_mmap ? "mmap" : "serial"));
1824
1825     if (mapping) {
1826         pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_NAME, mapping->name);
1827         pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_DESCRIPTION, mapping->description);
1828     }
1829
1830     pa_alsa_init_description(data.proplist);
1831
1832     if (u->control_device)
1833         pa_alsa_init_proplist_ctl(data.proplist, u->control_device);
1834
1835     if (pa_modargs_get_proplist(ma, "sink_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
1836         pa_log("Invalid properties");
1837         pa_sink_new_data_done(&data);
1838         goto fail;
1839     }
1840
1841     if (u->mixer_path_set)
1842         pa_alsa_add_ports(&data.ports, u->mixer_path_set);
1843
1844     u->sink = pa_sink_new(m->core, &data, PA_SINK_HARDWARE|PA_SINK_LATENCY|(u->use_tsched ? PA_SINK_DYNAMIC_LATENCY : 0));
1845     pa_sink_new_data_done(&data);
1846
1847     if (!u->sink) {
1848         pa_log("Failed to create sink object");
1849         goto fail;
1850     }
1851
1852     u->sink->parent.process_msg = sink_process_msg;
1853     u->sink->update_requested_latency = sink_update_requested_latency_cb;
1854     u->sink->set_state = sink_set_state_cb;
1855     u->sink->set_port = sink_set_port_cb;
1856     u->sink->userdata = u;
1857
1858     pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
1859     pa_sink_set_rtpoll(u->sink, u->rtpoll);
1860
1861     u->frame_size = frame_size;
1862     u->fragment_size = frag_size = (size_t) (period_frames * frame_size);
1863     u->hwbuf_size = buffer_size = (size_t) (buffer_frames * frame_size);
1864     pa_cvolume_mute(&u->hardware_volume, u->sink->sample_spec.channels);
1865
1866     pa_log_info("Using %0.1f fragments of size %lu bytes (%0.2fms), buffer size is %lu bytes (%0.2fms)",
1867                 (double) u->hwbuf_size / (double) u->fragment_size,
1868                 (long unsigned) u->fragment_size,
1869                 (double) pa_bytes_to_usec(u->fragment_size, &ss) / PA_USEC_PER_MSEC,
1870                 (long unsigned) u->hwbuf_size,
1871                 (double) pa_bytes_to_usec(u->hwbuf_size, &ss) / PA_USEC_PER_MSEC);
1872
1873     pa_sink_set_max_request(u->sink, u->hwbuf_size);
1874     pa_sink_set_max_rewind(u->sink, u->hwbuf_size);
1875
1876     if (u->use_tsched) {
1877         u->tsched_watermark = pa_usec_to_bytes_round_up(pa_bytes_to_usec_round_up(tsched_watermark, &requested_ss), &u->sink->sample_spec);
1878
1879         u->watermark_inc_step = pa_usec_to_bytes(TSCHED_WATERMARK_INC_STEP_USEC, &u->sink->sample_spec);
1880         u->watermark_dec_step = pa_usec_to_bytes(TSCHED_WATERMARK_DEC_STEP_USEC, &u->sink->sample_spec);
1881
1882         u->watermark_inc_threshold = pa_usec_to_bytes_round_up(TSCHED_WATERMARK_INC_THRESHOLD_USEC, &u->sink->sample_spec);
1883         u->watermark_dec_threshold = pa_usec_to_bytes_round_up(TSCHED_WATERMARK_DEC_THRESHOLD_USEC, &u->sink->sample_spec);
1884
1885         fix_min_sleep_wakeup(u);
1886         fix_tsched_watermark(u);
1887
1888         pa_sink_set_latency_range(u->sink,
1889                                   0,
1890                                   pa_bytes_to_usec(u->hwbuf_size, &ss));
1891
1892         pa_log_info("Time scheduling watermark is %0.2fms",
1893                     (double) pa_bytes_to_usec(u->tsched_watermark, &ss) / PA_USEC_PER_MSEC);
1894     } else
1895         pa_sink_set_fixed_latency(u->sink, pa_bytes_to_usec(u->hwbuf_size, &ss));
1896
1897
1898     reserve_update(u);
1899
1900     if (update_sw_params(u) < 0)
1901         goto fail;
1902
1903     if (setup_mixer(u, ignore_dB) < 0)
1904         goto fail;
1905
1906     pa_alsa_dump(PA_LOG_DEBUG, u->pcm_handle);
1907
1908     if (!(u->thread = pa_thread_new(thread_func, u))) {
1909         pa_log("Failed to create thread.");
1910         goto fail;
1911     }
1912
1913     /* Get initial mixer settings */
1914     if (data.volume_is_set) {
1915         if (u->sink->set_volume)
1916             u->sink->set_volume(u->sink);
1917     } else {
1918         if (u->sink->get_volume)
1919             u->sink->get_volume(u->sink);
1920     }
1921
1922     if (data.muted_is_set) {
1923         if (u->sink->set_mute)
1924             u->sink->set_mute(u->sink);
1925     } else {
1926         if (u->sink->get_mute)
1927             u->sink->get_mute(u->sink);
1928     }
1929
1930     pa_sink_put(u->sink);
1931
1932     if (profile_set)
1933         pa_alsa_profile_set_free(profile_set);
1934
1935     return u->sink;
1936
1937 fail:
1938
1939     if (u)
1940         userdata_free(u);
1941
1942     if (profile_set)
1943         pa_alsa_profile_set_free(profile_set);
1944
1945     return NULL;
1946 }
1947
1948 static void userdata_free(struct userdata *u) {
1949     pa_assert(u);
1950
1951     if (u->sink)
1952         pa_sink_unlink(u->sink);
1953
1954     if (u->thread) {
1955         pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
1956         pa_thread_free(u->thread);
1957     }
1958
1959     pa_thread_mq_done(&u->thread_mq);
1960
1961     if (u->sink)
1962         pa_sink_unref(u->sink);
1963
1964     if (u->memchunk.memblock)
1965         pa_memblock_unref(u->memchunk.memblock);
1966
1967     if (u->alsa_rtpoll_item)
1968         pa_rtpoll_item_free(u->alsa_rtpoll_item);
1969
1970     if (u->rtpoll)
1971         pa_rtpoll_free(u->rtpoll);
1972
1973     if (u->pcm_handle) {
1974         snd_pcm_drop(u->pcm_handle);
1975         snd_pcm_close(u->pcm_handle);
1976     }
1977
1978     if (u->mixer_fdl)
1979         pa_alsa_fdlist_free(u->mixer_fdl);
1980
1981     if (u->mixer_path_set)
1982         pa_alsa_path_set_free(u->mixer_path_set);
1983     else if (u->mixer_path)
1984         pa_alsa_path_free(u->mixer_path);
1985
1986     if (u->mixer_handle)
1987         snd_mixer_close(u->mixer_handle);
1988
1989     if (u->smoother)
1990         pa_smoother_free(u->smoother);
1991
1992     reserve_done(u);
1993     monitor_done(u);
1994
1995     pa_xfree(u->device_name);
1996     pa_xfree(u->control_device);
1997     pa_xfree(u);
1998 }
1999
2000 void pa_alsa_sink_free(pa_sink *s) {
2001     struct userdata *u;
2002
2003     pa_sink_assert_ref(s);
2004     pa_assert_se(u = s->userdata);
2005
2006     userdata_free(u);
2007 }