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