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