src/modules/alsa/alsa-source.c

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