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