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