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     if (u->use_tsched) {
 607         *sleep_usec = pa_bytes_to_usec(left_to_record, &u->source->sample_spec);
 608
 609         if (*sleep_usec > process_usec)
 610             *sleep_usec -= process_usec;
 611         else
 612             *sleep_usec = 0;
 613     }
 614
 615     return work_done ? 1 : 0;
 616 }
 617
 618 static int unix_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled, pa_bool_t on_timeout) {
 619     int work_done = FALSE;
 620     pa_usec_t max_sleep_usec = 0, process_usec = 0;
 621     size_t left_to_record;
 622     unsigned j = 0;
 623
 624     pa_assert(u);
 625     pa_source_assert_ref(u->source);
 626
 627     if (u->use_tsched)
 628         hw_sleep_time(u, &max_sleep_usec, &process_usec);
 629
 630     for (;;) {
 631         snd_pcm_sframes_t n;
 632         size_t n_bytes;
 633         int r;
 634         pa_bool_t after_avail = TRUE;
 635
 636         if (PA_UNLIKELY((n = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->source->sample_spec)) < 0)) {
 637
 638             if ((r = try_recover(u, "snd_pcm_avail", (int) n)) == 0)
 639                 continue;
 640
 641             return r;
 642         }
 643
 644         n_bytes = (size_t) n * u->frame_size;
 645         left_to_record = check_left_to_record(u, n_bytes, on_timeout);
 646         on_timeout = FALSE;
 647
 648         if (u->use_tsched)
 649             if (!polled &&
 650                 pa_bytes_to_usec(left_to_record, &u->source->sample_spec) > process_usec+max_sleep_usec/2)
 651                 break;
 652
 653         if (PA_UNLIKELY(n_bytes <= 0)) {
 654
 655             if (polled)
 656                 PA_ONCE_BEGIN {
 657                     char *dn = pa_alsa_get_driver_name_by_pcm(u->pcm_handle);
 658                     pa_log(_("ALSA woke us up to read new data from the device, but there was actually nothing to read!\n"
 659                              "Most likely this is a bug in the ALSA driver '%s'. Please report this issue to the ALSA developers.\n"
 660                              "We were woken up with POLLIN set -- however a subsequent snd_pcm_avail() returned 0 or another value < min_avail."),
 661                            pa_strnull(dn));
 662                     pa_xfree(dn);
 663                 } PA_ONCE_END;
 664
 665             break;
 666         }
 667
 668         if (++j > 10) {
 669 #ifdef DEBUG_TIMING
 670             pa_log_debug("Not filling up, because already too many iterations.");
 671 #endif
 672
 673             break;
 674         }
 675
 676         polled = FALSE;
 677
 678         for (;;) {
 679             void *p;
 680             snd_pcm_sframes_t frames;
 681             pa_memchunk chunk;
 682
 683             chunk.memblock = pa_memblock_new(u->core->mempool, (size_t) -1);
 684
 685             frames = (snd_pcm_sframes_t) (pa_memblock_get_length(chunk.memblock) / u->frame_size);
 686
 687             if (frames > (snd_pcm_sframes_t) (n_bytes/u->frame_size))
 688                 frames = (snd_pcm_sframes_t) (n_bytes/u->frame_size);
 689
 690 /*             pa_log_debug("%lu frames to read", (unsigned long) n); */
 691
 692             p = pa_memblock_acquire(chunk.memblock);
 693             frames = snd_pcm_readi(u->pcm_handle, (uint8_t*) p, (snd_pcm_uframes_t) frames);
 694             pa_memblock_release(chunk.memblock);
 695
 696             if (PA_UNLIKELY(frames < 0)) {
 697                 pa_memblock_unref(chunk.memblock);
 698
 699                 if (!after_avail && (int) frames == -EAGAIN)
 700                     break;
 701
 702                 if ((r = try_recover(u, "snd_pcm_readi", (int) frames)) == 0)
 703                     continue;
 704
 705                 return r;
 706             }
 707
 708             if (!after_avail && frames == 0) {
 709                 pa_memblock_unref(chunk.memblock);
 710                 break;
 711             }
 712
 713             pa_assert(frames > 0);
 714             after_avail = FALSE;
 715
 716             chunk.index = 0;
 717             chunk.length = (size_t) frames * u->frame_size;
 718
 719             pa_source_post(u->source, &chunk);
 720             pa_memblock_unref(chunk.memblock);
 721
 722             work_done = TRUE;
 723
 724             u->read_count += frames * u->frame_size;
 725
 726 /*             pa_log_debug("read %lu frames", (unsigned long) frames); */
 727
 728             if ((size_t) frames * u->frame_size >= n_bytes)
 729                 break;
 730
 731             n_bytes -= (size_t) frames * u->frame_size;
 732         }
 733     }
 734
 735     if (u->use_tsched) {
 736         *sleep_usec = pa_bytes_to_usec(left_to_record, &u->source->sample_spec);
 737
 738         if (*sleep_usec > process_usec)
 739             *sleep_usec -= process_usec;
 740         else
 741             *sleep_usec = 0;
 742     }
 743
 744     return work_done ? 1 : 0;
 745 }
 746
 747 static void update_smoother(struct userdata *u) {
 748     snd_pcm_sframes_t delay = 0;
 749     uint64_t position;
 750     int err;
 751     pa_usec_t now1 = 0, now2;
 752     snd_pcm_status_t *status;
 753
 754     snd_pcm_status_alloca(&status);
 755
 756     pa_assert(u);
 757     pa_assert(u->pcm_handle);
 758
 759     /* Let's update the time smoother */
 760
 761     if (PA_UNLIKELY((err = pa_alsa_safe_delay(u->pcm_handle, &delay, u->hwbuf_size, &u->source->sample_spec)) < 0)) {
 762         pa_log_warn("Failed to get delay: %s", pa_alsa_strerror(err));
 763         return;
 764     }
 765
 766     if (PA_UNLIKELY((err = snd_pcm_status(u->pcm_handle, status)) < 0))
 767         pa_log_warn("Failed to get timestamp: %s", pa_alsa_strerror(err));
 768     else {
 769         snd_htimestamp_t htstamp = { 0, 0 };
 770         snd_pcm_status_get_htstamp(status, &htstamp);
 771         now1 = pa_timespec_load(&htstamp);
 772     }
 773
 774     /* Hmm, if the timestamp is 0, then it wasn't set and we take the current time */
 775     if (now1 <= 0)
 776         now1 = pa_rtclock_now();
 777
 778     /* check if the time since the last update is bigger than the interval */
 779     if (u->last_smoother_update > 0)
 780         if (u->last_smoother_update + u->smoother_interval > now1)
 781             return;
 782
 783     position = u->read_count + ((uint64_t) delay * (uint64_t) u->frame_size);
 784     now2 = pa_bytes_to_usec(position, &u->source->sample_spec);
 785
 786     pa_smoother_put(u->smoother, now1, now2);
 787
 788     u->last_smoother_update = now1;
 789     /* exponentially increase the update interval up to the MAX limit */
 790     u->smoother_interval = PA_MIN (u->smoother_interval * 2, SMOOTHER_MAX_INTERVAL);
 791 }
 792
 793 static pa_usec_t source_get_latency(struct userdata *u) {
 794    int64_t delay;
 795     pa_usec_t now1, now2;
 796
 797     pa_assert(u);
 798
 799     now1 = pa_rtclock_now();
 800     now2 = pa_smoother_get(u->smoother, now1);
 801
 802     delay = (int64_t) now2 - (int64_t) pa_bytes_to_usec(u->read_count, &u->source->sample_spec);
 803
 804     return delay >= 0 ? (pa_usec_t) delay : 0;
 805 }
 806
 807 static int build_pollfd(struct userdata *u) {
 808     pa_assert(u);
 809     pa_assert(u->pcm_handle);
 810
 811     if (u->alsa_rtpoll_item)
 812         pa_rtpoll_item_free(u->alsa_rtpoll_item);
 813
 814     if (!(u->alsa_rtpoll_item = pa_alsa_build_pollfd(u->pcm_handle, u->rtpoll)))
 815         return -1;
 816
 817     return 0;
 818 }
 819
 820 static int suspend(struct userdata *u) {
 821     pa_assert(u);
 822     pa_assert(u->pcm_handle);
 823
 824     pa_smoother_pause(u->smoother, pa_rtclock_now());
 825
 826     /* Let's suspend */
 827     snd_pcm_close(u->pcm_handle);
 828     u->pcm_handle = NULL;
 829
 830     if (u->alsa_rtpoll_item) {
 831         pa_rtpoll_item_free(u->alsa_rtpoll_item);
 832         u->alsa_rtpoll_item = NULL;
 833     }
 834
 835     pa_log_info("Device suspended...");
 836
 837     return 0;
 838 }
 839
 840 static int update_sw_params(struct userdata *u) {
 841     snd_pcm_uframes_t avail_min;
 842     int err;
 843
 844     pa_assert(u);
 845
 846     /* Use the full buffer if noone asked us for anything specific */
 847     u->hwbuf_unused = 0;
 848
 849     if (u->use_tsched) {
 850         pa_usec_t latency;
 851
 852         if ((latency = pa_source_get_requested_latency_within_thread(u->source)) != (pa_usec_t) -1) {
 853             size_t b;
 854
 855             pa_log_debug("latency set to %0.2fms", (double) latency / PA_USEC_PER_MSEC);
 856
 857             b = pa_usec_to_bytes(latency, &u->source->sample_spec);
 858
 859             /* We need at least one sample in our buffer */
 860
 861             if (PA_UNLIKELY(b < u->frame_size))
 862                 b = u->frame_size;
 863
 864             u->hwbuf_unused = PA_LIKELY(b < u->hwbuf_size) ? (u->hwbuf_size - b) : 0;
 865         }
 866
 867         fix_min_sleep_wakeup(u);
 868         fix_tsched_watermark(u);
 869     }
 870
 871     pa_log_debug("hwbuf_unused=%lu", (unsigned long) u->hwbuf_unused);
 872
 873     avail_min = 1;
 874
 875     if (u->use_tsched) {
 876         pa_usec_t sleep_usec, process_usec;
 877
 878         hw_sleep_time(u, &sleep_usec, &process_usec);
 879         avail_min += pa_usec_to_bytes(sleep_usec, &u->source->sample_spec) / u->frame_size;
 880     }
 881
 882     pa_log_debug("setting avail_min=%lu", (unsigned long) avail_min);
 883
 884     if ((err = pa_alsa_set_sw_params(u->pcm_handle, avail_min, !u->use_tsched)) < 0) {
 885         pa_log("Failed to set software parameters: %s", pa_alsa_strerror(err));
 886         return err;
 887     }
 888
 889     return 0;
 890 }
 891
 892 static int unsuspend(struct userdata *u) {
 893     pa_sample_spec ss;
 894     int err;
 895     pa_bool_t b, d;
 896     snd_pcm_uframes_t period_size, buffer_size;
 897
 898     pa_assert(u);
 899     pa_assert(!u->pcm_handle);
 900
 901     pa_log_info("Trying resume...");
 902
 903     if ((err = snd_pcm_open(&u->pcm_handle, u->device_name, SND_PCM_STREAM_CAPTURE,
 904                             SND_PCM_NONBLOCK|
 905                             SND_PCM_NO_AUTO_RESAMPLE|
 906                             SND_PCM_NO_AUTO_CHANNELS|
 907                             SND_PCM_NO_AUTO_FORMAT)) < 0) {
 908         pa_log("Error opening PCM device %s: %s", u->device_name, pa_alsa_strerror(err));
 909         goto fail;
 910     }
 911
 912     ss = u->source->sample_spec;
 913     period_size = u->fragment_size / u->frame_size;
 914     buffer_size = u->hwbuf_size / u->frame_size;
 915     b = u->use_mmap;
 916     d = u->use_tsched;
 917
 918     if ((err = pa_alsa_set_hw_params(u->pcm_handle, &ss, &period_size, &buffer_size, 0, &b, &d, TRUE)) < 0) {
 919         pa_log("Failed to set hardware parameters: %s", pa_alsa_strerror(err));
 920         goto fail;
 921     }
 922
 923     if (b != u->use_mmap || d != u->use_tsched) {
 924         pa_log_warn("Resume failed, couldn't get original access mode.");
 925         goto fail;
 926     }
 927
 928     if (!pa_sample_spec_equal(&ss, &u->source->sample_spec)) {
 929         pa_log_warn("Resume failed, couldn't restore original sample settings.");
 930         goto fail;
 931     }
 932
 933     if (period_size*u->frame_size != u->fragment_size ||
 934         buffer_size*u->frame_size != u->hwbuf_size) {
 935         pa_log_warn("Resume failed, couldn't restore original fragment settings. (Old: %lu/%lu, New %lu/%lu)",
 936                     (unsigned long) u->hwbuf_size, (unsigned long) u->fragment_size,
 937                     (unsigned long) (buffer_size*u->frame_size), (unsigned long) (period_size*u->frame_size));
 938         goto fail;
 939     }
 940
 941     if (update_sw_params(u) < 0)
 942         goto fail;
 943
 944     if (build_pollfd(u) < 0)
 945         goto fail;
 946
 947     /* FIXME: We need to reload the volume somehow */
 948
 949     snd_pcm_start(u->pcm_handle);
 950
 951     u->read_count = 0;
 952     pa_smoother_reset(u->smoother, pa_rtclock_now(), TRUE);
 953     u->smoother_interval = SMOOTHER_MIN_INTERVAL;
 954     u->last_smoother_update = 0;
 955
 956     pa_log_info("Resumed successfully...");
 957
 958     return 0;
 959
 960 fail:
 961     if (u->pcm_handle) {
 962         snd_pcm_close(u->pcm_handle);
 963         u->pcm_handle = NULL;
 964     }
 965
 966     return -PA_ERR_IO;
 967 }
 968
 969 static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
 970     struct userdata *u = PA_SOURCE(o)->userdata;
 971
 972     switch (code) {
 973
 974         case PA_SOURCE_MESSAGE_GET_LATENCY: {
 975             pa_usec_t r = 0;
 976
 977             if (u->pcm_handle)
 978                 r = source_get_latency(u);
 979
 980             *((pa_usec_t*) data) = r;
 981
 982             return 0;
 983         }
 984
 985         case PA_SOURCE_MESSAGE_SET_STATE:
 986
 987             switch ((pa_source_state_t) PA_PTR_TO_UINT(data)) {
 988
 989                 case PA_SOURCE_SUSPENDED: {
 990                     int r;
 991                     pa_assert(PA_SOURCE_IS_OPENED(u->source->thread_info.state));
 992
 993                     if ((r = suspend(u)) < 0)
 994                         return r;
 995
 996                     break;
 997                 }
 998
 999                 case PA_SOURCE_IDLE:
1000                 case PA_SOURCE_RUNNING: {
1001                     int r;
1002
1003                     if (u->source->thread_info.state == PA_SOURCE_INIT) {
1004                         if (build_pollfd(u) < 0)
1005                             return -PA_ERR_IO;
1006
1007                         snd_pcm_start(u->pcm_handle);
1008                     }
1009
1010                     if (u->source->thread_info.state == PA_SOURCE_SUSPENDED) {
1011                         if ((r = unsuspend(u)) < 0)
1012                             return r;
1013                     }
1014
1015                     break;
1016                 }
1017
1018                 case PA_SOURCE_UNLINKED:
1019                 case PA_SOURCE_INIT:
1020                 case PA_SOURCE_INVALID_STATE:
1021                     ;
1022             }
1023
1024             break;
1025     }
1026
1027     return pa_source_process_msg(o, code, data, offset, chunk);
1028 }
1029
1030 /* Called from main context */
1031 static int source_set_state_cb(pa_source *s, pa_source_state_t new_state) {
1032     pa_source_state_t old_state;
1033     struct userdata *u;
1034
1035     pa_source_assert_ref(s);
1036     pa_assert_se(u = s->userdata);
1037
1038     old_state = pa_source_get_state(u->source);
1039
1040     if (PA_SINK_IS_OPENED(old_state) && new_state == PA_SINK_SUSPENDED)
1041         reserve_done(u);
1042     else if (old_state == PA_SINK_SUSPENDED && PA_SINK_IS_OPENED(new_state))
1043         if (reserve_init(u, u->device_name) < 0)
1044             return -PA_ERR_BUSY;
1045
1046     return 0;
1047 }
1048
1049 static int mixer_callback(snd_mixer_elem_t *elem, unsigned int mask) {
1050     struct userdata *u = snd_mixer_elem_get_callback_private(elem);
1051
1052     pa_assert(u);
1053     pa_assert(u->mixer_handle);
1054
1055     if (mask == SND_CTL_EVENT_MASK_REMOVE)
1056         return 0;
1057
1058     if (u->source->suspend_cause & PA_SUSPEND_SESSION)
1059         return 0;
1060
1061     if (mask & SND_CTL_EVENT_MASK_VALUE) {
1062         pa_source_get_volume(u->source, TRUE);
1063         pa_source_get_mute(u->source, TRUE);
1064     }
1065
1066     return 0;
1067 }
1068
1069 static void source_get_volume_cb(pa_source *s) {
1070     struct userdata *u = s->userdata;
1071     pa_cvolume r;
1072     char t[PA_CVOLUME_SNPRINT_MAX];
1073
1074     pa_assert(u);
1075     pa_assert(u->mixer_path);
1076     pa_assert(u->mixer_handle);
1077
1078     if (pa_alsa_path_get_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r) < 0)
1079         return;
1080
1081     /* Shift down by the base volume, so that 0dB becomes maximum volume */
1082     pa_sw_cvolume_multiply_scalar(&r, &r, s->base_volume);
1083
1084     pa_log_debug("Read hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &r));
1085
1086     if (pa_cvolume_equal(&u->hardware_volume, &r))
1087         return;
1088
1089     s->volume = u->hardware_volume = r;
1090
1091     /* Hmm, so the hardware volume changed, let's reset our software volume */
1092     if (u->mixer_path->has_dB)
1093         pa_source_set_soft_volume(s, NULL);
1094 }
1095
1096 static void source_set_volume_cb(pa_source *s) {
1097     struct userdata *u = s->userdata;
1098     pa_cvolume r;
1099     char t[PA_CVOLUME_SNPRINT_MAX];
1100
1101     pa_assert(u);
1102     pa_assert(u->mixer_path);
1103     pa_assert(u->mixer_handle);
1104
1105     /* Shift up by the base volume */
1106     pa_sw_cvolume_divide_scalar(&r, &s->volume, s->base_volume);
1107
1108     if (pa_alsa_path_set_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r) < 0)
1109         return;
1110
1111     /* Shift down by the base volume, so that 0dB becomes maximum volume */
1112     pa_sw_cvolume_multiply_scalar(&r, &r, s->base_volume);
1113
1114     u->hardware_volume = r;
1115
1116     if (u->mixer_path->has_dB) {
1117         pa_cvolume new_soft_volume;
1118         pa_bool_t accurate_enough;
1119
1120         /* Match exactly what the user requested by software */
1121         pa_sw_cvolume_divide(&new_soft_volume, &s->volume, &u->hardware_volume);
1122
1123         /* If the adjustment to do in software is only minimal we
1124          * can skip it. That saves us CPU at the expense of a bit of
1125          * accuracy */
1126         accurate_enough =
1127             (pa_cvolume_min(&new_soft_volume) >= (PA_VOLUME_NORM - VOLUME_ACCURACY)) &&
1128             (pa_cvolume_max(&new_soft_volume) <= (PA_VOLUME_NORM + VOLUME_ACCURACY));
1129
1130         pa_log_debug("Requested volume: %s", pa_cvolume_snprint(t, sizeof(t), &s->volume));
1131         pa_log_debug("Got hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &u->hardware_volume));
1132         pa_log_debug("Calculated software volume: %s (accurate-enough=%s)", pa_cvolume_snprint(t, sizeof(t), &new_soft_volume),
1133                      pa_yes_no(accurate_enough));
1134
1135         if (!accurate_enough)
1136             s->soft_volume = new_soft_volume;
1137
1138     } else {
1139         pa_log_debug("Wrote hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &r));
1140
1141         /* We can't match exactly what the user requested, hence let's
1142          * at least tell the user about it */
1143
1144         s->volume = r;
1145     }
1146 }
1147
1148 static void source_get_mute_cb(pa_source *s) {
1149     struct userdata *u = s->userdata;
1150     pa_bool_t b;
1151
1152     pa_assert(u);
1153     pa_assert(u->mixer_path);
1154     pa_assert(u->mixer_handle);
1155
1156     if (pa_alsa_path_get_mute(u->mixer_path, u->mixer_handle, &b) < 0)
1157         return;
1158
1159     s->muted = b;
1160 }
1161
1162 static void source_set_mute_cb(pa_source *s) {
1163     struct userdata *u = s->userdata;
1164
1165     pa_assert(u);
1166     pa_assert(u->mixer_path);
1167     pa_assert(u->mixer_handle);
1168
1169     pa_alsa_path_set_mute(u->mixer_path, u->mixer_handle, s->muted);
1170 }
1171
1172 static int source_set_port_cb(pa_source *s, pa_device_port *p) {
1173     struct userdata *u = s->userdata;
1174     pa_alsa_port_data *data;
1175
1176     pa_assert(u);
1177     pa_assert(p);
1178     pa_assert(u->mixer_handle);
1179
1180     data = PA_DEVICE_PORT_DATA(p);
1181
1182     pa_assert_se(u->mixer_path = data->path);
1183     pa_alsa_path_select(u->mixer_path, u->mixer_handle);
1184
1185     if (u->mixer_path->has_volume && u->mixer_path->has_dB) {
1186         s->base_volume = pa_sw_volume_from_dB(-u->mixer_path->max_dB);
1187         s->n_volume_steps = PA_VOLUME_NORM+1;
1188
1189         if (u->mixer_path->max_dB > 0.0)
1190             pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(s->base_volume));
1191         else
1192             pa_log_info("No particular base volume set, fixing to 0 dB");
1193     } else {
1194         s->base_volume = PA_VOLUME_NORM;
1195         s->n_volume_steps = u->mixer_path->max_volume - u->mixer_path->min_volume + 1;
1196     }
1197
1198     if (data->setting)
1199         pa_alsa_setting_select(data->setting, u->mixer_handle);
1200
1201     if (s->set_mute)
1202         s->set_mute(s);
1203     if (s->set_volume)
1204         s->set_volume(s);
1205
1206     return 0;
1207 }
1208
1209 static void source_update_requested_latency_cb(pa_source *s) {
1210     struct userdata *u = s->userdata;
1211     pa_assert(u);
1212     pa_assert(u->use_tsched);
1213
1214     if (!u->pcm_handle)
1215         return;
1216
1217     update_sw_params(u);
1218 }
1219
1220 static void thread_func(void *userdata) {
1221     struct userdata *u = userdata;
1222     unsigned short revents = 0;
1223
1224     pa_assert(u);
1225
1226     pa_log_debug("Thread starting up");
1227
1228     if (u->core->realtime_scheduling)
1229         pa_make_realtime(u->core->realtime_priority);
1230
1231     pa_thread_mq_install(&u->thread_mq);
1232
1233     for (;;) {
1234         int ret;
1235
1236 #ifdef DEBUG_TIMING
1237         pa_log_debug("Loop");
1238 #endif
1239
1240         /* Read some data and pass it to the sources */
1241         if (PA_SOURCE_IS_OPENED(u->source->thread_info.state)) {
1242             int work_done;
1243             pa_usec_t sleep_usec = 0;
1244             pa_bool_t on_timeout = pa_rtpoll_timer_elapsed(u->rtpoll);
1245
1246             if (u->use_mmap)
1247                 work_done = mmap_read(u, &sleep_usec, revents & POLLIN, on_timeout);
1248             else
1249                 work_done = unix_read(u, &sleep_usec, revents & POLLIN, on_timeout);
1250
1251             if (work_done < 0)
1252                 goto fail;
1253
1254 /*             pa_log_debug("work_done = %i", work_done); */
1255
1256             if (work_done)
1257                 update_smoother(u);
1258
1259             if (u->use_tsched) {
1260                 pa_usec_t cusec;
1261
1262                 /* OK, the capture buffer is now empty, let's
1263                  * calculate when to wake up next */
1264
1265 /*                 pa_log_debug("Waking up in %0.2fms (sound card clock).", (double) sleep_usec / PA_USEC_PER_MSEC); */
1266
1267                 /* Convert from the sound card time domain to the
1268                  * system time domain */
1269                 cusec = pa_smoother_translate(u->smoother, pa_rtclock_now(), sleep_usec);
1270
1271 /*                 pa_log_debug("Waking up in %0.2fms (system clock).", (double) cusec / PA_USEC_PER_MSEC); */
1272
1273                 /* We don't trust the conversion, so we wake up whatever comes first */
1274                 pa_rtpoll_set_timer_relative(u->rtpoll, PA_MIN(sleep_usec, cusec));
1275             }
1276         } else if (u->use_tsched)
1277
1278             /* OK, we're in an invalid state, let's disable our timers */
1279             pa_rtpoll_set_timer_disabled(u->rtpoll);
1280
1281         /* Hmm, nothing to do. Let's sleep */
1282         if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
1283             goto fail;
1284
1285         if (ret == 0)
1286             goto finish;
1287
1288         /* Tell ALSA about this and process its response */
1289         if (PA_SOURCE_IS_OPENED(u->source->thread_info.state)) {
1290             struct pollfd *pollfd;
1291             int err;
1292             unsigned n;
1293
1294             pollfd = pa_rtpoll_item_get_pollfd(u->alsa_rtpoll_item, &n);
1295
1296             if ((err = snd_pcm_poll_descriptors_revents(u->pcm_handle, pollfd, n, &revents)) < 0) {
1297                 pa_log("snd_pcm_poll_descriptors_revents() failed: %s", pa_alsa_strerror(err));
1298                 goto fail;
1299             }
1300
1301             if (revents & ~POLLIN) {
1302                 if (pa_alsa_recover_from_poll(u->pcm_handle, revents) < 0)
1303                     goto fail;
1304
1305                 snd_pcm_start(u->pcm_handle);
1306             } else if (revents && u->use_tsched && pa_log_ratelimit())
1307                 pa_log_debug("Wakeup from ALSA!");
1308
1309         } else
1310             revents = 0;
1311     }
1312
1313 fail:
1314     /* If this was no regular exit from the loop we have to continue
1315      * processing messages until we received PA_MESSAGE_SHUTDOWN */
1316     pa_asyncmsgq_post(u->thread_mq.outq, PA_MSGOBJECT(u->core), PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0, NULL, NULL);
1317     pa_asyncmsgq_wait_for(u->thread_mq.inq, PA_MESSAGE_SHUTDOWN);
1318
1319 finish:
1320     pa_log_debug("Thread shutting down");
1321 }
1322
1323 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) {
1324     const char *n;
1325     char *t;
1326
1327     pa_assert(data);
1328     pa_assert(ma);
1329     pa_assert(device_name);
1330
1331     if ((n = pa_modargs_get_value(ma, "source_name", NULL))) {
1332         pa_source_new_data_set_name(data, n);
1333         data->namereg_fail = TRUE;
1334         return;
1335     }
1336
1337     if ((n = pa_modargs_get_value(ma, "name", NULL)))
1338         data->namereg_fail = TRUE;
1339     else {
1340         n = device_id ? device_id : device_name;
1341         data->namereg_fail = FALSE;
1342     }
1343
1344     if (mapping)
1345         t = pa_sprintf_malloc("alsa_input.%s.%s", n, mapping->name);
1346     else
1347         t = pa_sprintf_malloc("alsa_input.%s", n);
1348
1349     pa_source_new_data_set_name(data, t);
1350     pa_xfree(t);
1351 }
1352
1353 static void find_mixer(struct userdata *u, pa_alsa_mapping *mapping, const char *element, pa_bool_t ignore_dB) {
1354
1355     if (!mapping && !element)
1356         return;
1357
1358     if (!(u->mixer_handle = pa_alsa_open_mixer_for_pcm(u->pcm_handle, &u->control_device))) {
1359         pa_log_info("Failed to find a working mixer device.");
1360         return;
1361     }
1362
1363     if (element) {
1364
1365         if (!(u->mixer_path = pa_alsa_path_synthesize(element, PA_ALSA_DIRECTION_INPUT)))
1366             goto fail;
1367
1368         if (pa_alsa_path_probe(u->mixer_path, u->mixer_handle, ignore_dB) < 0)
1369             goto fail;
1370
1371         pa_log_debug("Probed mixer path %s:", u->mixer_path->name);
1372         pa_alsa_path_dump(u->mixer_path);
1373     } else {
1374
1375         if (!(u->mixer_path_set = pa_alsa_path_set_new(mapping, PA_ALSA_DIRECTION_INPUT)))
1376             goto fail;
1377
1378         pa_alsa_path_set_probe(u->mixer_path_set, u->mixer_handle, ignore_dB);
1379
1380         pa_log_debug("Probed mixer paths:");
1381         pa_alsa_path_set_dump(u->mixer_path_set);
1382     }
1383
1384     return;
1385
1386 fail:
1387
1388     if (u->mixer_path_set) {
1389         pa_alsa_path_set_free(u->mixer_path_set);
1390         u->mixer_path_set = NULL;
1391     } else if (u->mixer_path) {
1392         pa_alsa_path_free(u->mixer_path);
1393         u->mixer_path = NULL;
1394     }
1395
1396     if (u->mixer_handle) {
1397         snd_mixer_close(u->mixer_handle);
1398         u->mixer_handle = NULL;
1399     }
1400 }
1401
1402 static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB) {
1403     pa_assert(u);
1404
1405     if (!u->mixer_handle)
1406         return 0;
1407
1408     if (u->source->active_port) {
1409         pa_alsa_port_data *data;
1410
1411         /* We have a list of supported paths, so let's activate the
1412          * one that has been chosen as active */
1413
1414         data = PA_DEVICE_PORT_DATA(u->source->active_port);
1415         u->mixer_path = data->path;
1416
1417         pa_alsa_path_select(data->path, u->mixer_handle);
1418
1419         if (data->setting)
1420             pa_alsa_setting_select(data->setting, u->mixer_handle);
1421
1422     } else {
1423
1424         if (!u->mixer_path && u->mixer_path_set)
1425             u->mixer_path = u->mixer_path_set->paths;
1426
1427         if (u->mixer_path) {
1428             /* Hmm, we have only a single path, then let's activate it */
1429
1430             pa_alsa_path_select(u->mixer_path, u->mixer_handle);
1431
1432             if (u->mixer_path->settings)
1433                 pa_alsa_setting_select(u->mixer_path->settings, u->mixer_handle);
1434         } else
1435             return 0;
1436     }
1437
1438     if (!u->mixer_path->has_volume)
1439         pa_log_info("Driver does not support hardware volume control, falling back to software volume control.");
1440     else {
1441
1442         if (u->mixer_path->has_dB) {
1443             pa_log_info("Hardware volume ranges from %0.2f dB to %0.2f dB.", u->mixer_path->min_dB, u->mixer_path->max_dB);
1444
1445             u->source->base_volume = pa_sw_volume_from_dB(-u->mixer_path->max_dB);
1446             u->source->n_volume_steps = PA_VOLUME_NORM+1;
1447
1448             if (u->mixer_path->max_dB > 0.0)
1449                 pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(u->source->base_volume));
1450             else
1451                 pa_log_info("No particular base volume set, fixing to 0 dB");
1452
1453         } else {
1454             pa_log_info("Hardware volume ranges from %li to %li.", u->mixer_path->min_volume, u->mixer_path->max_volume);
1455             u->source->base_volume = PA_VOLUME_NORM;
1456             u->source->n_volume_steps = u->mixer_path->max_volume - u->mixer_path->min_volume + 1;
1457         }
1458
1459         u->source->get_volume = source_get_volume_cb;
1460         u->source->set_volume = source_set_volume_cb;
1461
1462         u->source->flags |= PA_SOURCE_HW_VOLUME_CTRL | (u->mixer_path->has_dB ? PA_SOURCE_DECIBEL_VOLUME : 0);
1463         pa_log_info("Using hardware volume control. Hardware dB scale %s.", u->mixer_path->has_dB ? "supported" : "not supported");
1464     }
1465
1466     if (!u->mixer_path->has_mute) {
1467         pa_log_info("Driver does not support hardware mute control, falling back to software mute control.");
1468     } else {
1469         u->source->get_mute = source_get_mute_cb;
1470         u->source->set_mute = source_set_mute_cb;
1471         u->source->flags |= PA_SOURCE_HW_MUTE_CTRL;
1472         pa_log_info("Using hardware mute control.");
1473     }
1474
1475     u->mixer_fdl = pa_alsa_fdlist_new();
1476
1477     if (pa_alsa_fdlist_set_mixer(u->mixer_fdl, u->mixer_handle, u->core->mainloop) < 0) {
1478         pa_log("Failed to initialize file descriptor monitoring");
1479         return -1;
1480     }
1481
1482     if (u->mixer_path_set)
1483         pa_alsa_path_set_set_callback(u->mixer_path_set, u->mixer_handle, mixer_callback, u);
1484     else
1485         pa_alsa_path_set_callback(u->mixer_path, u->mixer_handle, mixer_callback, u);
1486
1487     return 0;
1488 }
1489
1490 pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, pa_card *card, pa_alsa_mapping *mapping) {
1491
1492     struct userdata *u = NULL;
1493     const char *dev_id = NULL;
1494     pa_sample_spec ss, requested_ss;
1495     pa_channel_map map;
1496     uint32_t nfrags, frag_size, buffer_size, tsched_size, tsched_watermark;
1497     snd_pcm_uframes_t period_frames, buffer_frames, tsched_frames;
1498     size_t frame_size;
1499     pa_bool_t use_mmap = TRUE, b, use_tsched = TRUE, d, ignore_dB = FALSE;
1500     pa_source_new_data data;
1501     pa_alsa_profile_set *profile_set = NULL;
1502
1503     pa_assert(m);
1504     pa_assert(ma);
1505
1506     ss = m->core->default_sample_spec;
1507     map = m->core->default_channel_map;
1508     if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_ALSA) < 0) {
1509         pa_log("Failed to parse sample specification");
1510         goto fail;
1511     }
1512
1513     requested_ss = ss;
1514     frame_size = pa_frame_size(&ss);
1515
1516     nfrags = m->core->default_n_fragments;
1517     frag_size = (uint32_t) pa_usec_to_bytes(m->core->default_fragment_size_msec*PA_USEC_PER_MSEC, &ss);
1518     if (frag_size <= 0)
1519         frag_size = (uint32_t) frame_size;
1520     tsched_size = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_BUFFER_USEC, &ss);
1521     tsched_watermark = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_WATERMARK_USEC, &ss);
1522
1523     if (pa_modargs_get_value_u32(ma, "fragments", &nfrags) < 0 ||
1524         pa_modargs_get_value_u32(ma, "fragment_size", &frag_size) < 0 ||
1525         pa_modargs_get_value_u32(ma, "tsched_buffer_size", &tsched_size) < 0 ||
1526         pa_modargs_get_value_u32(ma, "tsched_buffer_watermark", &tsched_watermark) < 0) {
1527         pa_log("Failed to parse buffer metrics");
1528         goto fail;
1529     }
1530
1531     buffer_size = nfrags * frag_size;
1532
1533     period_frames = frag_size/frame_size;
1534     buffer_frames = buffer_size/frame_size;
1535     tsched_frames = tsched_size/frame_size;
1536
1537     if (pa_modargs_get_value_boolean(ma, "mmap", &use_mmap) < 0) {
1538         pa_log("Failed to parse mmap argument.");
1539         goto fail;
1540     }
1541
1542     if (pa_modargs_get_value_boolean(ma, "tsched", &use_tsched) < 0) {
1543         pa_log("Failed to parse timer_scheduling argument.");
1544         goto fail;
1545     }
1546
1547     if (pa_modargs_get_value_boolean(ma, "ignore_dB", &ignore_dB) < 0) {
1548         pa_log("Failed to parse ignore_dB argument.");
1549         goto fail;
1550     }
1551
1552     use_tsched = pa_alsa_may_tsched(use_tsched);
1553
1554     u = pa_xnew0(struct userdata, 1);
1555     u->core = m->core;
1556     u->module = m;
1557     u->use_mmap = use_mmap;
1558     u->use_tsched = use_tsched;
1559     u->rtpoll = pa_rtpoll_new();
1560     pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
1561
1562     u->smoother = pa_smoother_new(
1563             DEFAULT_TSCHED_WATERMARK_USEC*2,
1564             DEFAULT_TSCHED_WATERMARK_USEC*2,
1565             TRUE,
1566             TRUE,
1567             5,
1568             pa_rtclock_now(),
1569             FALSE);
1570     u->smoother_interval = SMOOTHER_MIN_INTERVAL;
1571
1572     dev_id = pa_modargs_get_value(
1573             ma, "device_id",
1574             pa_modargs_get_value(ma, "device", DEFAULT_DEVICE));
1575
1576     if (reserve_init(u, dev_id) < 0)
1577         goto fail;
1578
1579     if (reserve_monitor_init(u, dev_id) < 0)
1580         goto fail;
1581
1582     b = use_mmap;
1583     d = use_tsched;
1584
1585     if (mapping) {
1586
1587         if (!(dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
1588             pa_log("device_id= not set");
1589             goto fail;
1590         }
1591
1592         if (!(u->pcm_handle = pa_alsa_open_by_device_id_mapping(
1593                       dev_id,
1594                       &u->device_name,
1595                       &ss, &map,
1596                       SND_PCM_STREAM_CAPTURE,
1597                       &period_frames, &buffer_frames, tsched_frames,
1598                       &b, &d, mapping)))
1599             goto fail;
1600
1601     } else if ((dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
1602
1603         if (!(profile_set = pa_alsa_profile_set_new(NULL, &map)))
1604             goto fail;
1605
1606         if (!(u->pcm_handle = pa_alsa_open_by_device_id_auto(
1607                       dev_id,
1608                       &u->device_name,
1609                       &ss, &map,
1610                       SND_PCM_STREAM_CAPTURE,
1611                       &period_frames, &buffer_frames, tsched_frames,
1612                       &b, &d, profile_set, &mapping)))
1613             goto fail;
1614
1615     } else {
1616
1617         if (!(u->pcm_handle = pa_alsa_open_by_device_string(
1618                       pa_modargs_get_value(ma, "device", DEFAULT_DEVICE),
1619                       &u->device_name,
1620                       &ss, &map,
1621                       SND_PCM_STREAM_CAPTURE,
1622                       &period_frames, &buffer_frames, tsched_frames,
1623                       &b, &d, FALSE)))
1624             goto fail;
1625     }
1626
1627     pa_assert(u->device_name);
1628     pa_log_info("Successfully opened device %s.", u->device_name);
1629
1630     if (pa_alsa_pcm_is_modem(u->pcm_handle)) {
1631         pa_log_notice("Device %s is modem, refusing further initialization.", u->device_name);
1632         goto fail;
1633     }
1634
1635     if (mapping)
1636         pa_log_info("Selected mapping '%s' (%s).", mapping->description, mapping->name);
1637
1638     if (use_mmap && !b) {
1639         pa_log_info("Device doesn't support mmap(), falling back to UNIX read/write mode.");
1640         u->use_mmap = use_mmap = FALSE;
1641     }
1642
1643     if (use_tsched && (!b || !d)) {
1644         pa_log_info("Cannot enable timer-based scheduling, falling back to sound IRQ scheduling.");
1645         u->use_tsched = use_tsched = FALSE;
1646     }
1647
1648     if (u->use_mmap)
1649         pa_log_info("Successfully enabled mmap() mode.");
1650
1651     if (u->use_tsched)
1652         pa_log_info("Successfully enabled timer-based scheduling mode.");
1653
1654     /* ALSA might tweak the sample spec, so recalculate the frame size */
1655     frame_size = pa_frame_size(&ss);
1656
1657     find_mixer(u, mapping, pa_modargs_get_value(ma, "control", NULL), ignore_dB);
1658
1659     pa_source_new_data_init(&data);
1660     data.driver = driver;
1661     data.module = m;
1662     data.card = card;
1663     set_source_name(&data, ma, dev_id, u->device_name, mapping);
1664     pa_source_new_data_set_sample_spec(&data, &ss);
1665     pa_source_new_data_set_channel_map(&data, &map);
1666
1667     pa_alsa_init_proplist_pcm(m->core, data.proplist, u->pcm_handle);
1668     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, u->device_name);
1669     pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_BUFFER_SIZE, "%lu", (unsigned long) (buffer_frames * frame_size));
1670     pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZE, "%lu", (unsigned long) (period_frames * frame_size));
1671     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_ACCESS_MODE, u->use_tsched ? "mmap+timer" : (u->use_mmap ? "mmap" : "serial"));
1672
1673     if (mapping) {
1674         pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_NAME, mapping->name);
1675         pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_DESCRIPTION, mapping->description);
1676     }
1677
1678     pa_alsa_init_description(data.proplist);
1679
1680     if (u->control_device)
1681         pa_alsa_init_proplist_ctl(data.proplist, u->control_device);
1682
1683     if (pa_modargs_get_proplist(ma, "source_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
1684         pa_log("Invalid properties");
1685         pa_source_new_data_done(&data);
1686         goto fail;
1687     }
1688
1689     if (u->mixer_path_set)
1690         pa_alsa_add_ports(&data.ports, u->mixer_path_set);
1691
1692     u->source = pa_source_new(m->core, &data, PA_SOURCE_HARDWARE|PA_SOURCE_LATENCY|(u->use_tsched ? PA_SOURCE_DYNAMIC_LATENCY : 0));
1693     pa_source_new_data_done(&data);
1694
1695     if (!u->source) {
1696         pa_log("Failed to create source object");
1697         goto fail;
1698     }
1699
1700     u->source->parent.process_msg = source_process_msg;
1701     if (u->use_tsched)
1702         u->source->update_requested_latency = source_update_requested_latency_cb;
1703     u->source->set_state = source_set_state_cb;
1704     u->source->set_port = source_set_port_cb;
1705     u->source->userdata = u;
1706
1707     pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
1708     pa_source_set_rtpoll(u->source, u->rtpoll);
1709
1710     u->frame_size = frame_size;
1711     u->fragment_size = frag_size = (size_t) (period_frames * frame_size);
1712     u->hwbuf_size = buffer_size = (size_t) (buffer_frames * frame_size);
1713     pa_cvolume_mute(&u->hardware_volume, u->source->sample_spec.channels);
1714
1715     pa_log_info("Using %0.1f fragments of size %lu bytes (%0.2fms), buffer size is %lu bytes (%0.2fms)",
1716                 (double) u->hwbuf_size / (double) u->fragment_size,
1717                 (long unsigned) u->fragment_size,
1718                 (double) pa_bytes_to_usec(u->fragment_size, &ss) / PA_USEC_PER_MSEC,
1719                 (long unsigned) u->hwbuf_size,
1720                 (double) pa_bytes_to_usec(u->hwbuf_size, &ss) / PA_USEC_PER_MSEC);
1721
1722     if (u->use_tsched) {
1723         u->tsched_watermark = pa_usec_to_bytes_round_up(pa_bytes_to_usec_round_up(tsched_watermark, &requested_ss), &u->source->sample_spec);
1724
1725         u->watermark_inc_step = pa_usec_to_bytes(TSCHED_WATERMARK_INC_STEP_USEC, &u->source->sample_spec);
1726         u->watermark_dec_step = pa_usec_to_bytes(TSCHED_WATERMARK_DEC_STEP_USEC, &u->source->sample_spec);
1727
1728         u->watermark_inc_threshold = pa_usec_to_bytes_round_up(TSCHED_WATERMARK_INC_THRESHOLD_USEC, &u->source->sample_spec);
1729         u->watermark_dec_threshold = pa_usec_to_bytes_round_up(TSCHED_WATERMARK_DEC_THRESHOLD_USEC, &u->source->sample_spec);
1730
1731         fix_min_sleep_wakeup(u);
1732         fix_tsched_watermark(u);
1733
1734         pa_source_set_latency_range(u->source,
1735                                     0,
1736                                     pa_bytes_to_usec(u->hwbuf_size, &ss));
1737
1738         pa_log_info("Time scheduling watermark is %0.2fms",
1739                     (double) pa_bytes_to_usec(u->tsched_watermark, &ss) / PA_USEC_PER_MSEC);
1740     } else
1741         pa_source_set_fixed_latency(u->source, pa_bytes_to_usec(u->hwbuf_size, &ss));
1742
1743     reserve_update(u);
1744
1745     if (update_sw_params(u) < 0)
1746         goto fail;
1747
1748     if (setup_mixer(u, ignore_dB) < 0)
1749         goto fail;
1750
1751     pa_alsa_dump(PA_LOG_DEBUG, u->pcm_handle);
1752
1753     if (!(u->thread = pa_thread_new("alsa-source", thread_func, u))) {
1754         pa_log("Failed to create thread.");
1755         goto fail;
1756     }
1757     /* Get initial mixer settings */
1758     if (data.volume_is_set) {
1759         if (u->source->set_volume)
1760             u->source->set_volume(u->source);
1761     } else {
1762         if (u->source->get_volume)
1763             u->source->get_volume(u->source);
1764     }
1765
1766     if (data.muted_is_set) {
1767         if (u->source->set_mute)
1768             u->source->set_mute(u->source);
1769     } else {
1770         if (u->source->get_mute)
1771             u->source->get_mute(u->source);
1772     }
1773
1774     pa_source_put(u->source);
1775
1776     if (profile_set)
1777         pa_alsa_profile_set_free(profile_set);
1778
1779     return u->source;
1780
1781 fail:
1782
1783     if (u)
1784         userdata_free(u);
1785
1786     if (profile_set)
1787         pa_alsa_profile_set_free(profile_set);
1788
1789     return NULL;
1790 }
1791
1792 static void userdata_free(struct userdata *u) {
1793     pa_assert(u);
1794
1795     if (u->source)
1796         pa_source_unlink(u->source);
1797
1798     if (u->thread) {
1799         pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
1800         pa_thread_free(u->thread);
1801     }
1802
1803     pa_thread_mq_done(&u->thread_mq);
1804
1805     if (u->source)
1806         pa_source_unref(u->source);
1807
1808     if (u->alsa_rtpoll_item)
1809         pa_rtpoll_item_free(u->alsa_rtpoll_item);
1810
1811     if (u->rtpoll)
1812         pa_rtpoll_free(u->rtpoll);
1813
1814     if (u->pcm_handle) {
1815         snd_pcm_drop(u->pcm_handle);
1816         snd_pcm_close(u->pcm_handle);
1817     }
1818
1819     if (u->mixer_fdl)
1820         pa_alsa_fdlist_free(u->mixer_fdl);
1821
1822     if (u->mixer_path_set)
1823         pa_alsa_path_set_free(u->mixer_path_set);
1824     else if (u->mixer_path)
1825         pa_alsa_path_free(u->mixer_path);
1826
1827     if (u->mixer_handle)
1828         snd_mixer_close(u->mixer_handle);
1829
1830     if (u->smoother)
1831         pa_smoother_free(u->smoother);
1832
1833     reserve_done(u);
1834     monitor_done(u);
1835
1836     pa_xfree(u->device_name);
1837     pa_xfree(u->control_device);
1838     pa_xfree(u);
1839 }
1840
1841 void pa_alsa_source_free(pa_source *s) {
1842     struct userdata *u;
1843
1844     pa_source_assert_ref(s);
1845     pa_assert_se(u = s->userdata);
1846
1847     userdata_free(u);
1848 }