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