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