src/modules/alsa/alsa-sink.c

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