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