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