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