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