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