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     snd_config_update_free_global();
 791
 792     if ((err = snd_pcm_open(&u->pcm_handle, u->device_name, SND_PCM_STREAM_CAPTURE,
 793                             /*SND_PCM_NONBLOCK|*/
 794                             SND_PCM_NO_AUTO_RESAMPLE|
 795                             SND_PCM_NO_AUTO_CHANNELS|
 796                             SND_PCM_NO_AUTO_FORMAT)) < 0) {
 797         pa_log("Error opening PCM device %s: %s", u->device_name, pa_alsa_strerror(err));
 798         goto fail;
 799     }
 800
 801     ss = u->source->sample_spec;
 802     nfrags = u->nfragments;
 803     period_size = u->fragment_size / u->frame_size;
 804     b = u->use_mmap;
 805     d = u->use_tsched;
 806
 807     if ((err = pa_alsa_set_hw_params(u->pcm_handle, &ss, &nfrags, &period_size, u->hwbuf_size / u->frame_size, &b, &d, TRUE)) < 0) {
 808         pa_log("Failed to set hardware parameters: %s", pa_alsa_strerror(err));
 809         goto fail;
 810     }
 811
 812     if (b != u->use_mmap || d != u->use_tsched) {
 813         pa_log_warn("Resume failed, couldn't get original access mode.");
 814         goto fail;
 815     }
 816
 817     if (!pa_sample_spec_equal(&ss, &u->source->sample_spec)) {
 818         pa_log_warn("Resume failed, couldn't restore original sample settings.");
 819         goto fail;
 820     }
 821
 822     if (nfrags != u->nfragments || period_size*u->frame_size != u->fragment_size) {
 823         pa_log_warn("Resume failed, couldn't restore original fragment settings. (Old: %lu*%lu, New %lu*%lu)",
 824                     (unsigned long) u->nfragments, (unsigned long) u->fragment_size,
 825                     (unsigned long) nfrags, period_size * u->frame_size);
 826         goto fail;
 827     }
 828
 829     if (update_sw_params(u) < 0)
 830         goto fail;
 831
 832     if (build_pollfd(u) < 0)
 833         goto fail;
 834
 835     /* FIXME: We need to reload the volume somehow */
 836
 837     snd_pcm_start(u->pcm_handle);
 838     pa_smoother_resume(u->smoother, pa_rtclock_usec(), TRUE);
 839
 840     pa_log_info("Resumed successfully...");
 841
 842     return 0;
 843
 844 fail:
 845     if (u->pcm_handle) {
 846         snd_pcm_close(u->pcm_handle);
 847         u->pcm_handle = NULL;
 848     }
 849
 850     return -1;
 851 }
 852
 853 static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
 854     struct userdata *u = PA_SOURCE(o)->userdata;
 855
 856     switch (code) {
 857
 858         case PA_SOURCE_MESSAGE_GET_LATENCY: {
 859             pa_usec_t r = 0;
 860
 861             if (u->pcm_handle)
 862                 r = source_get_latency(u);
 863
 864             *((pa_usec_t*) data) = r;
 865
 866             return 0;
 867         }
 868
 869         case PA_SOURCE_MESSAGE_SET_STATE:
 870
 871             switch ((pa_source_state_t) PA_PTR_TO_UINT(data)) {
 872
 873                 case PA_SOURCE_SUSPENDED:
 874                     pa_assert(PA_SOURCE_IS_OPENED(u->source->thread_info.state));
 875
 876                     if (suspend(u) < 0)
 877                         return -1;
 878
 879                     break;
 880
 881                 case PA_SOURCE_IDLE:
 882                 case PA_SOURCE_RUNNING:
 883
 884                     if (u->source->thread_info.state == PA_SOURCE_INIT) {
 885                         if (build_pollfd(u) < 0)
 886                             return -1;
 887
 888                         snd_pcm_start(u->pcm_handle);
 889                     }
 890
 891                     if (u->source->thread_info.state == PA_SOURCE_SUSPENDED) {
 892                         if (unsuspend(u) < 0)
 893                             return -1;
 894                     }
 895
 896                     break;
 897
 898                 case PA_SOURCE_UNLINKED:
 899                 case PA_SOURCE_INIT:
 900                 case PA_SOURCE_INVALID_STATE:
 901                     ;
 902             }
 903
 904             break;
 905     }
 906
 907     return pa_source_process_msg(o, code, data, offset, chunk);
 908 }
 909
 910 /* Called from main context */
 911 static int source_set_state_cb(pa_source *s, pa_source_state_t new_state) {
 912     pa_source_state_t old_state;
 913     struct userdata *u;
 914
 915     pa_source_assert_ref(s);
 916     pa_assert_se(u = s->userdata);
 917
 918     old_state = pa_source_get_state(u->source);
 919
 920     if (PA_SINK_IS_OPENED(old_state) && new_state == PA_SINK_SUSPENDED)
 921         reserve_done(u);
 922     else if (old_state == PA_SINK_SUSPENDED && PA_SINK_IS_OPENED(new_state))
 923         if (reserve_init(u, u->device_name) < 0)
 924             return -1;
 925
 926     return 0;
 927 }
 928
 929 static int mixer_callback(snd_mixer_elem_t *elem, unsigned int mask) {
 930     struct userdata *u = snd_mixer_elem_get_callback_private(elem);
 931
 932     pa_assert(u);
 933     pa_assert(u->mixer_handle);
 934
 935     if (mask == SND_CTL_EVENT_MASK_REMOVE)
 936         return 0;
 937
 938     if (mask & SND_CTL_EVENT_MASK_VALUE) {
 939         pa_source_get_volume(u->source, TRUE);
 940         pa_source_get_mute(u->source, TRUE);
 941     }
 942
 943     return 0;
 944 }
 945
 946 static void source_get_volume_cb(pa_source *s) {
 947     struct userdata *u = s->userdata;
 948     pa_cvolume r;
 949     char t[PA_CVOLUME_SNPRINT_MAX];
 950
 951     pa_assert(u);
 952     pa_assert(u->mixer_path);
 953     pa_assert(u->mixer_handle);
 954
 955     if (pa_alsa_path_get_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r) < 0)
 956         return;
 957
 958     /* Shift down by the base volume, so that 0dB becomes maximum volume */
 959     pa_sw_cvolume_multiply_scalar(&r, &r, s->base_volume);
 960
 961     pa_log_debug("Read hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &r));
 962
 963     if (pa_cvolume_equal(&u->hardware_volume, &r))
 964         return;
 965
 966     s->virtual_volume = u->hardware_volume = r;
 967
 968     if (u->mixer_path->has_dB) {
 969         pa_cvolume reset;
 970
 971         /* Hmm, so the hardware volume changed, let's reset our software volume */
 972         pa_cvolume_reset(&reset, s->sample_spec.channels);
 973         pa_source_set_soft_volume(s, &reset);
 974     }
 975 }
 976
 977 static void source_set_volume_cb(pa_source *s) {
 978     struct userdata *u = s->userdata;
 979     pa_cvolume r;
 980     char t[PA_CVOLUME_SNPRINT_MAX];
 981
 982     pa_assert(u);
 983     pa_assert(u->mixer_path);
 984     pa_assert(u->mixer_handle);
 985
 986     /* Shift up by the base volume */
 987     pa_sw_cvolume_divide_scalar(&r, &s->virtual_volume, s->base_volume);
 988
 989     if (pa_alsa_path_set_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r) < 0)
 990         return;
 991
 992     /* Shift down by the base volume, so that 0dB becomes maximum volume */
 993     pa_sw_cvolume_multiply_scalar(&r, &r, s->base_volume);
 994
 995     u->hardware_volume = r;
 996
 997     if (u->mixer_path->has_dB) {
 998
 999         /* Match exactly what the user requested by software */
1000         pa_sw_cvolume_divide(&s->soft_volume, &s->virtual_volume, &u->hardware_volume);
1001
1002         pa_log_debug("Requested volume: %s", pa_cvolume_snprint(t, sizeof(t), &s->virtual_volume));
1003         pa_log_debug("Got hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &u->hardware_volume));
1004         pa_log_debug("Calculated software volume: %s", pa_cvolume_snprint(t, sizeof(t), &s->soft_volume));
1005
1006     } else {
1007         pa_log_debug("Wrote hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &r));
1008
1009         /* We can't match exactly what the user requested, hence let's
1010          * at least tell the user about it */
1011
1012         s->virtual_volume = r;
1013     }
1014 }
1015
1016 static void source_get_mute_cb(pa_source *s) {
1017     struct userdata *u = s->userdata;
1018     pa_bool_t b;
1019
1020     pa_assert(u);
1021     pa_assert(u->mixer_path);
1022     pa_assert(u->mixer_handle);
1023
1024     if (pa_alsa_path_get_mute(u->mixer_path, u->mixer_handle, &b) < 0)
1025         return;
1026
1027     s->muted = b;
1028 }
1029
1030 static void source_set_mute_cb(pa_source *s) {
1031     struct userdata *u = s->userdata;
1032
1033     pa_assert(u);
1034     pa_assert(u->mixer_path);
1035     pa_assert(u->mixer_handle);
1036
1037     pa_alsa_path_set_mute(u->mixer_path, u->mixer_handle, s->muted);
1038 }
1039
1040 static int source_set_port_cb(pa_source *s, pa_device_port *p) {
1041     struct userdata *u = s->userdata;
1042     pa_alsa_port_data *data;
1043
1044     pa_assert(u);
1045     pa_assert(p);
1046     pa_assert(u->mixer_handle);
1047
1048     data = PA_DEVICE_PORT_DATA(p);
1049
1050     pa_assert_se(u->mixer_path = data->path);
1051     pa_alsa_path_select(u->mixer_path, u->mixer_handle);
1052
1053     if (u->mixer_path->has_volume && u->mixer_path->has_dB) {
1054         s->base_volume = pa_sw_volume_from_dB(-u->mixer_path->max_dB);
1055         s->n_volume_steps = PA_VOLUME_NORM+1;
1056
1057         if (u->mixer_path->max_dB > 0.0)
1058             pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(s->base_volume));
1059         else
1060             pa_log_info("No particular base volume set, fixing to 0 dB");
1061     } else {
1062         s->base_volume = PA_VOLUME_NORM;
1063         s->n_volume_steps = u->mixer_path->max_volume - u->mixer_path->min_volume + 1;
1064     }
1065
1066     if (data->setting)
1067         pa_alsa_setting_select(data->setting, u->mixer_handle);
1068
1069     if (s->set_mute)
1070         s->set_mute(s);
1071     if (s->set_volume)
1072         s->set_volume(s);
1073
1074     return 0;
1075 }
1076
1077 static void source_update_requested_latency_cb(pa_source *s) {
1078     struct userdata *u = s->userdata;
1079     pa_assert(u);
1080
1081     if (!u->pcm_handle)
1082         return;
1083
1084     update_sw_params(u);
1085 }
1086
1087 static void thread_func(void *userdata) {
1088     struct userdata *u = userdata;
1089     unsigned short revents = 0;
1090
1091     pa_assert(u);
1092
1093     pa_log_debug("Thread starting up");
1094
1095     if (u->core->realtime_scheduling)
1096         pa_make_realtime(u->core->realtime_priority);
1097
1098     pa_thread_mq_install(&u->thread_mq);
1099     pa_rtpoll_install(u->rtpoll);
1100
1101     for (;;) {
1102         int ret;
1103
1104 #ifdef DEBUG_TIMING
1105         pa_log_debug("Loop");
1106 #endif
1107
1108         /* Read some data and pass it to the sources */
1109         if (PA_SOURCE_IS_OPENED(u->source->thread_info.state)) {
1110             int work_done;
1111             pa_usec_t sleep_usec = 0;
1112
1113             if (u->use_mmap)
1114                 work_done = mmap_read(u, &sleep_usec, revents & POLLIN);
1115             else
1116                 work_done = unix_read(u, &sleep_usec, revents & POLLIN);
1117
1118             if (work_done < 0)
1119                 goto fail;
1120
1121 /*             pa_log_debug("work_done = %i", work_done); */
1122
1123             if (work_done)
1124                 update_smoother(u);
1125
1126             if (u->use_tsched) {
1127                 pa_usec_t cusec;
1128
1129                 /* OK, the capture buffer is now empty, let's
1130                  * calculate when to wake up next */
1131
1132 /*                 pa_log_debug("Waking up in %0.2fms (sound card clock).", (double) sleep_usec / PA_USEC_PER_MSEC); */
1133
1134                 /* Convert from the sound card time domain to the
1135                  * system time domain */
1136                 cusec = pa_smoother_translate(u->smoother, pa_rtclock_usec(), sleep_usec);
1137
1138 /*                 pa_log_debug("Waking up in %0.2fms (system clock).", (double) cusec / PA_USEC_PER_MSEC); */
1139
1140                 /* We don't trust the conversion, so we wake up whatever comes first */
1141                 pa_rtpoll_set_timer_relative(u->rtpoll, PA_MIN(sleep_usec, cusec));
1142             }
1143         } else if (u->use_tsched)
1144
1145             /* OK, we're in an invalid state, let's disable our timers */
1146             pa_rtpoll_set_timer_disabled(u->rtpoll);
1147
1148         /* Hmm, nothing to do. Let's sleep */
1149         if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
1150             goto fail;
1151
1152         if (ret == 0)
1153             goto finish;
1154
1155         /* Tell ALSA about this and process its response */
1156         if (PA_SOURCE_IS_OPENED(u->source->thread_info.state)) {
1157             struct pollfd *pollfd;
1158             int err;
1159             unsigned n;
1160
1161             pollfd = pa_rtpoll_item_get_pollfd(u->alsa_rtpoll_item, &n);
1162
1163             if ((err = snd_pcm_poll_descriptors_revents(u->pcm_handle, pollfd, n, &revents)) < 0) {
1164                 pa_log("snd_pcm_poll_descriptors_revents() failed: %s", pa_alsa_strerror(err));
1165                 goto fail;
1166             }
1167
1168             if (revents & ~POLLIN) {
1169                 if (pa_alsa_recover_from_poll(u->pcm_handle, revents) < 0)
1170                     goto fail;
1171
1172                 snd_pcm_start(u->pcm_handle);
1173             } else if (revents && u->use_tsched && pa_log_ratelimit())
1174                 pa_log_debug("Wakeup from ALSA!");
1175
1176         } else
1177             revents = 0;
1178     }
1179
1180 fail:
1181     /* If this was no regular exit from the loop we have to continue
1182      * processing messages until we received PA_MESSAGE_SHUTDOWN */
1183     pa_asyncmsgq_post(u->thread_mq.outq, PA_MSGOBJECT(u->core), PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0, NULL, NULL);
1184     pa_asyncmsgq_wait_for(u->thread_mq.inq, PA_MESSAGE_SHUTDOWN);
1185
1186 finish:
1187     pa_log_debug("Thread shutting down");
1188 }
1189
1190 static void set_source_name(pa_source_new_data *data, pa_modargs *ma, const char *device_id, const char *device_name) {
1191     const char *n;
1192     char *t;
1193
1194     pa_assert(data);
1195     pa_assert(ma);
1196     pa_assert(device_name);
1197
1198     if ((n = pa_modargs_get_value(ma, "source_name", NULL))) {
1199         pa_source_new_data_set_name(data, n);
1200         data->namereg_fail = TRUE;
1201         return;
1202     }
1203
1204     if ((n = pa_modargs_get_value(ma, "name", NULL)))
1205         data->namereg_fail = TRUE;
1206     else {
1207         n = device_id ? device_id : device_name;
1208         data->namereg_fail = FALSE;
1209     }
1210
1211     t = pa_sprintf_malloc("alsa_input.%s", n);
1212     pa_source_new_data_set_name(data, t);
1213     pa_xfree(t);
1214 }
1215
1216 static void find_mixer(struct userdata *u, pa_alsa_mapping *mapping, const char *element, pa_bool_t ignore_dB) {
1217
1218     if (!mapping && !element)
1219         return;
1220
1221     if (!(u->mixer_handle = pa_alsa_open_mixer_for_pcm(u->pcm_handle, &u->control_device))) {
1222         pa_log_info("Failed to find a working mixer device.");
1223         return;
1224     }
1225
1226     if (element) {
1227
1228         if (!(u->mixer_path = pa_alsa_path_synthesize(element, PA_ALSA_DIRECTION_INPUT)))
1229             goto fail;
1230
1231         if (pa_alsa_path_probe(u->mixer_path, u->mixer_handle, ignore_dB) < 0)
1232             goto fail;
1233
1234         pa_log_debug("Probed mixer path %s:", u->mixer_path->name);
1235         pa_alsa_path_dump(u->mixer_path);
1236     } else {
1237
1238         if (!(u->mixer_path_set = pa_alsa_path_set_new(mapping, PA_ALSA_DIRECTION_INPUT)))
1239             goto fail;
1240
1241         pa_alsa_path_set_probe(u->mixer_path_set, u->mixer_handle, ignore_dB);
1242
1243         pa_log_debug("Probed mixer paths:");
1244         pa_alsa_path_set_dump(u->mixer_path_set);
1245     }
1246
1247     return;
1248
1249 fail:
1250
1251     if (u->mixer_path_set) {
1252         pa_alsa_path_set_free(u->mixer_path_set);
1253         u->mixer_path_set = NULL;
1254     } else if (u->mixer_path) {
1255         pa_alsa_path_free(u->mixer_path);
1256         u->mixer_path = NULL;
1257     }
1258
1259     if (u->mixer_handle) {
1260         snd_mixer_close(u->mixer_handle);
1261         u->mixer_handle = NULL;
1262     }
1263 }
1264
1265 static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB) {
1266     pa_assert(u);
1267
1268     if (!u->mixer_handle)
1269         return 0;
1270
1271     if (u->source->active_port) {
1272         pa_alsa_port_data *data;
1273
1274         /* We have a list of supported paths, so let's activate the
1275          * one that has been chosen as active */
1276
1277         data = PA_DEVICE_PORT_DATA(u->source->active_port);
1278         u->mixer_path = data->path;
1279
1280         pa_alsa_path_select(data->path, u->mixer_handle);
1281
1282         if (data->setting)
1283             pa_alsa_setting_select(data->setting, u->mixer_handle);
1284
1285     } else {
1286
1287         if (!u->mixer_path && u->mixer_path_set)
1288             u->mixer_path = u->mixer_path_set->paths;
1289
1290         if (u->mixer_path) {
1291             /* Hmm, we have only a single path, then let's activate it */
1292
1293             pa_alsa_path_select(u->mixer_path, u->mixer_handle);
1294
1295             if (u->mixer_path->settings)
1296                 pa_alsa_setting_select(u->mixer_path->settings, u->mixer_handle);
1297         } else
1298             return 0;
1299     }
1300
1301     if (!u->mixer_path->has_volume)
1302         pa_log_info("Driver does not support hardware volume control, falling back to software volume control.");
1303     else {
1304
1305         if (u->mixer_path->has_dB) {
1306             pa_log_info("Hardware volume ranges from %0.2f dB to %0.2f dB.", u->mixer_path->min_dB, u->mixer_path->max_dB);
1307
1308             u->source->base_volume = pa_sw_volume_from_dB(-u->mixer_path->max_dB);
1309             u->source->n_volume_steps = PA_VOLUME_NORM+1;
1310
1311             if (u->mixer_path->max_dB > 0.0)
1312                 pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(u->source->base_volume));
1313             else
1314                 pa_log_info("No particular base volume set, fixing to 0 dB");
1315
1316         } else {
1317             pa_log_info("Hardware volume ranges from %li to %li.", u->mixer_path->min_volume, u->mixer_path->max_volume);
1318             u->source->base_volume = PA_VOLUME_NORM;
1319             u->source->n_volume_steps = u->mixer_path->max_volume - u->mixer_path->min_volume + 1;
1320         }
1321
1322         u->source->get_volume = source_get_volume_cb;
1323         u->source->set_volume = source_set_volume_cb;
1324
1325         u->source->flags |= PA_SOURCE_HW_VOLUME_CTRL | (u->mixer_path->has_dB ? PA_SOURCE_DECIBEL_VOLUME : 0);
1326         pa_log_info("Using hardware volume control. Hardware dB scale %s.", u->mixer_path->has_dB ? "supported" : "not supported");
1327     }
1328
1329     if (!u->mixer_path->has_mute) {
1330         pa_log_info("Driver does not support hardware mute control, falling back to software mute control.");
1331     } else {
1332         u->source->get_mute = source_get_mute_cb;
1333         u->source->set_mute = source_set_mute_cb;
1334         u->source->flags |= PA_SOURCE_HW_MUTE_CTRL;
1335         pa_log_info("Using hardware mute control.");
1336     }
1337
1338     u->mixer_fdl = pa_alsa_fdlist_new();
1339
1340     if (pa_alsa_fdlist_set_mixer(u->mixer_fdl, u->mixer_handle, u->core->mainloop) < 0) {
1341         pa_log("Failed to initialize file descriptor monitoring");
1342         return -1;
1343     }
1344
1345     if (u->mixer_path_set)
1346         pa_alsa_path_set_set_callback(u->mixer_path_set, u->mixer_handle, mixer_callback, u);
1347     else
1348         pa_alsa_path_set_callback(u->mixer_path, u->mixer_handle, mixer_callback, u);
1349
1350     return 0;
1351 }
1352
1353 pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, pa_card *card, pa_alsa_mapping *mapping) {
1354
1355     struct userdata *u = NULL;
1356     const char *dev_id = NULL;
1357     pa_sample_spec ss, requested_ss;
1358     pa_channel_map map;
1359     uint32_t nfrags, hwbuf_size, frag_size, tsched_size, tsched_watermark;
1360     snd_pcm_uframes_t period_frames, tsched_frames;
1361     size_t frame_size;
1362     pa_bool_t use_mmap = TRUE, b, use_tsched = TRUE, d, ignore_dB = FALSE;
1363     pa_source_new_data data;
1364     pa_alsa_profile_set *profile_set = NULL;
1365
1366     pa_assert(m);
1367     pa_assert(ma);
1368
1369     ss = m->core->default_sample_spec;
1370     map = m->core->default_channel_map;
1371     if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_ALSA) < 0) {
1372         pa_log("Failed to parse sample specification");
1373         goto fail;
1374     }
1375
1376     requested_ss = ss;
1377     frame_size = pa_frame_size(&ss);
1378
1379     nfrags = m->core->default_n_fragments;
1380     frag_size = (uint32_t) pa_usec_to_bytes(m->core->default_fragment_size_msec*PA_USEC_PER_MSEC, &ss);
1381     if (frag_size <= 0)
1382         frag_size = (uint32_t) frame_size;
1383     tsched_size = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_BUFFER_USEC, &ss);
1384     tsched_watermark = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_WATERMARK_USEC, &ss);
1385
1386     if (pa_modargs_get_value_u32(ma, "fragments", &nfrags) < 0 ||
1387         pa_modargs_get_value_u32(ma, "fragment_size", &frag_size) < 0 ||
1388         pa_modargs_get_value_u32(ma, "tsched_buffer_size", &tsched_size) < 0 ||
1389         pa_modargs_get_value_u32(ma, "tsched_buffer_watermark", &tsched_watermark) < 0) {
1390         pa_log("Failed to parse buffer metrics");
1391         goto fail;
1392     }
1393
1394     hwbuf_size = frag_size * nfrags;
1395     period_frames = frag_size/frame_size;
1396     tsched_frames = tsched_size/frame_size;
1397
1398     if (pa_modargs_get_value_boolean(ma, "mmap", &use_mmap) < 0) {
1399         pa_log("Failed to parse mmap argument.");
1400         goto fail;
1401     }
1402
1403     if (pa_modargs_get_value_boolean(ma, "tsched", &use_tsched) < 0) {
1404         pa_log("Failed to parse timer_scheduling argument.");
1405         goto fail;
1406     }
1407
1408     if (pa_modargs_get_value_boolean(ma, "ignore_dB", &ignore_dB) < 0) {
1409         pa_log("Failed to parse ignore_dB argument.");
1410         goto fail;
1411     }
1412
1413     if (use_tsched && !pa_rtclock_hrtimer()) {
1414         pa_log_notice("Disabling timer-based scheduling because high-resolution timers are not available from the kernel.");
1415         use_tsched = FALSE;
1416     }
1417
1418     u = pa_xnew0(struct userdata, 1);
1419     u->core = m->core;
1420     u->module = m;
1421     u->use_mmap = use_mmap;
1422     u->use_tsched = use_tsched;
1423     u->rtpoll = pa_rtpoll_new();
1424     pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
1425
1426     u->smoother = pa_smoother_new(
1427             DEFAULT_TSCHED_WATERMARK_USEC*2,
1428             DEFAULT_TSCHED_WATERMARK_USEC*2,
1429             TRUE,
1430             TRUE,
1431             5,
1432             pa_rtclock_usec(),
1433             FALSE);
1434
1435     dev_id = pa_modargs_get_value(
1436             ma, "device_id",
1437             pa_modargs_get_value(ma, "device", DEFAULT_DEVICE));
1438
1439     if (reserve_init(u, dev_id) < 0)
1440         goto fail;
1441
1442     if (reserve_monitor_init(u, dev_id) < 0)
1443         goto fail;
1444
1445     b = use_mmap;
1446     d = use_tsched;
1447
1448     if (mapping) {
1449
1450         if (!(dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
1451             pa_log("device_id= not set");
1452             goto fail;
1453         }
1454
1455         if (!(u->pcm_handle = pa_alsa_open_by_device_id_mapping(
1456                       dev_id,
1457                       &u->device_name,
1458                       &ss, &map,
1459                       SND_PCM_STREAM_CAPTURE,
1460                       &nfrags, &period_frames, tsched_frames,
1461                       &b, &d, mapping)))
1462             goto fail;
1463
1464     } else if ((dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
1465
1466         if (!(profile_set = pa_alsa_profile_set_new(NULL, &map)))
1467             goto fail;
1468
1469         if (!(u->pcm_handle = pa_alsa_open_by_device_id_auto(
1470                       dev_id,
1471                       &u->device_name,
1472                       &ss, &map,
1473                       SND_PCM_STREAM_CAPTURE,
1474                       &nfrags, &period_frames, tsched_frames,
1475                       &b, &d, profile_set, &mapping)))
1476             goto fail;
1477
1478     } else {
1479
1480         if (!(u->pcm_handle = pa_alsa_open_by_device_string(
1481                       pa_modargs_get_value(ma, "device", DEFAULT_DEVICE),
1482                       &u->device_name,
1483                       &ss, &map,
1484                       SND_PCM_STREAM_CAPTURE,
1485                       &nfrags, &period_frames, tsched_frames,
1486                       &b, &d, FALSE)))
1487             goto fail;
1488     }
1489
1490     pa_assert(u->device_name);
1491     pa_log_info("Successfully opened device %s.", u->device_name);
1492
1493     if (pa_alsa_pcm_is_modem(u->pcm_handle)) {
1494         pa_log_notice("Device %s is modem, refusing further initialization.", u->device_name);
1495         goto fail;
1496     }
1497
1498     if (mapping)
1499         pa_log_info("Selected mapping '%s' (%s).", mapping->description, mapping->name);
1500
1501     if (use_mmap && !b) {
1502         pa_log_info("Device doesn't support mmap(), falling back to UNIX read/write mode.");
1503         u->use_mmap = use_mmap = FALSE;
1504     }
1505
1506     if (use_tsched && (!b || !d)) {
1507         pa_log_info("Cannot enable timer-based scheduling, falling back to sound IRQ scheduling.");
1508         u->use_tsched = use_tsched = FALSE;
1509     }
1510
1511     if (use_tsched && !pa_alsa_pcm_is_hw(u->pcm_handle)) {
1512         pa_log_info("Device is not a hardware device, disabling timer-based scheduling.");
1513         u->use_tsched = use_tsched = FALSE;
1514     }
1515
1516     if (u->use_mmap)
1517         pa_log_info("Successfully enabled mmap() mode.");
1518
1519     if (u->use_tsched)
1520         pa_log_info("Successfully enabled timer-based scheduling mode.");
1521
1522     /* ALSA might tweak the sample spec, so recalculate the frame size */
1523     frame_size = pa_frame_size(&ss);
1524
1525     find_mixer(u, mapping, pa_modargs_get_value(ma, "control", NULL), ignore_dB);
1526
1527     pa_source_new_data_init(&data);
1528     data.driver = driver;
1529     data.module = m;
1530     data.card = card;
1531     set_source_name(&data, ma, dev_id, u->device_name);
1532     pa_source_new_data_set_sample_spec(&data, &ss);
1533     pa_source_new_data_set_channel_map(&data, &map);
1534
1535     pa_alsa_init_proplist_pcm(m->core, data.proplist, u->pcm_handle);
1536     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, u->device_name);
1537     pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_BUFFER_SIZE, "%lu", (unsigned long) (period_frames * frame_size * nfrags));
1538     pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZE, "%lu", (unsigned long) (period_frames * frame_size));
1539     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_ACCESS_MODE, u->use_tsched ? "mmap+timer" : (u->use_mmap ? "mmap" : "serial"));
1540
1541     if (mapping) {
1542         pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_NAME, mapping->name);
1543         pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_DESCRIPTION, mapping->description);
1544     }
1545
1546     pa_alsa_init_description(data.proplist);
1547
1548     if (u->control_device)
1549         pa_alsa_init_proplist_ctl(data.proplist, u->control_device);
1550
1551     if (pa_modargs_get_proplist(ma, "source_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
1552         pa_log("Invalid properties");
1553         pa_source_new_data_done(&data);
1554         goto fail;
1555     }
1556
1557     if (u->mixer_path_set)
1558         pa_alsa_add_ports(&data.ports, u->mixer_path_set);
1559
1560     u->source = pa_source_new(m->core, &data, PA_SOURCE_HARDWARE|PA_SOURCE_LATENCY|(u->use_tsched ? PA_SOURCE_DYNAMIC_LATENCY : 0));
1561     pa_source_new_data_done(&data);
1562
1563     if (!u->source) {
1564         pa_log("Failed to create source object");
1565         goto fail;
1566     }
1567
1568     u->source->parent.process_msg = source_process_msg;
1569     u->source->update_requested_latency = source_update_requested_latency_cb;
1570     u->source->set_state = source_set_state_cb;
1571     u->source->set_port = source_set_port_cb;
1572     u->source->userdata = u;
1573
1574     pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
1575     pa_source_set_rtpoll(u->source, u->rtpoll);
1576
1577     u->frame_size = frame_size;
1578     u->fragment_size = frag_size = (uint32_t) (period_frames * frame_size);
1579     u->nfragments = nfrags;
1580     u->hwbuf_size = u->fragment_size * nfrags;
1581     u->tsched_watermark = pa_usec_to_bytes_round_up(pa_bytes_to_usec_round_up(tsched_watermark, &requested_ss), &u->source->sample_spec);
1582     pa_cvolume_mute(&u->hardware_volume, u->source->sample_spec.channels);
1583
1584     pa_log_info("Using %u fragments of size %lu bytes, buffer time is %0.2fms",
1585                 nfrags, (long unsigned) u->fragment_size,
1586                 (double) pa_bytes_to_usec(u->hwbuf_size, &ss) / PA_USEC_PER_MSEC);
1587
1588     if (u->use_tsched) {
1589         u->watermark_step = pa_usec_to_bytes(TSCHED_WATERMARK_STEP_USEC, &u->source->sample_spec);
1590
1591         fix_min_sleep_wakeup(u);
1592         fix_tsched_watermark(u);
1593
1594         pa_source_set_latency_range(u->source,
1595                                     0,
1596                                     pa_bytes_to_usec(u->hwbuf_size, &ss));
1597
1598         pa_log_info("Time scheduling watermark is %0.2fms",
1599                     (double) pa_bytes_to_usec(u->tsched_watermark, &ss) / PA_USEC_PER_MSEC);
1600     } else
1601         pa_source_set_fixed_latency(u->source, pa_bytes_to_usec(u->hwbuf_size, &ss));
1602
1603     reserve_update(u);
1604
1605     if (update_sw_params(u) < 0)
1606         goto fail;
1607
1608     if (setup_mixer(u, ignore_dB) < 0)
1609         goto fail;
1610
1611     pa_alsa_dump(PA_LOG_DEBUG, u->pcm_handle);
1612
1613     if (!(u->thread = pa_thread_new(thread_func, u))) {
1614         pa_log("Failed to create thread.");
1615         goto fail;
1616     }
1617     /* Get initial mixer settings */
1618     if (data.volume_is_set) {
1619         if (u->source->set_volume)
1620             u->source->set_volume(u->source);
1621     } else {
1622         if (u->source->get_volume)
1623             u->source->get_volume(u->source);
1624     }
1625
1626     if (data.muted_is_set) {
1627         if (u->source->set_mute)
1628             u->source->set_mute(u->source);
1629     } else {
1630         if (u->source->get_mute)
1631             u->source->get_mute(u->source);
1632     }
1633
1634     pa_source_put(u->source);
1635
1636     if (profile_set)
1637         pa_alsa_profile_set_free(profile_set);
1638
1639     return u->source;
1640
1641 fail:
1642
1643     if (u)
1644         userdata_free(u);
1645
1646     if (profile_set)
1647         pa_alsa_profile_set_free(profile_set);
1648
1649     return NULL;
1650 }
1651
1652 static void userdata_free(struct userdata *u) {
1653     pa_assert(u);
1654
1655     if (u->source)
1656         pa_source_unlink(u->source);
1657
1658     if (u->thread) {
1659         pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
1660         pa_thread_free(u->thread);
1661     }
1662
1663     pa_thread_mq_done(&u->thread_mq);
1664
1665     if (u->source)
1666         pa_source_unref(u->source);
1667
1668     if (u->alsa_rtpoll_item)
1669         pa_rtpoll_item_free(u->alsa_rtpoll_item);
1670
1671     if (u->rtpoll)
1672         pa_rtpoll_free(u->rtpoll);
1673
1674     if (u->pcm_handle) {
1675         snd_pcm_drop(u->pcm_handle);
1676         snd_pcm_close(u->pcm_handle);
1677     }
1678
1679     if (u->mixer_fdl)
1680         pa_alsa_fdlist_free(u->mixer_fdl);
1681
1682     if (u->mixer_path_set)
1683         pa_alsa_path_set_free(u->mixer_path_set);
1684     else if (u->mixer_path)
1685         pa_alsa_path_free(u->mixer_path);
1686
1687     if (u->mixer_handle)
1688         snd_mixer_close(u->mixer_handle);
1689
1690     if (u->smoother)
1691         pa_smoother_free(u->smoother);
1692
1693     reserve_done(u);
1694     monitor_done(u);
1695
1696     pa_xfree(u->device_name);
1697     pa_xfree(u->control_device);
1698     pa_xfree(u);
1699 }
1700
1701 void pa_alsa_source_free(pa_source *s) {
1702     struct userdata *u;
1703
1704     pa_source_assert_ref(s);
1705     pa_assert_se(u = s->userdata);
1706
1707     userdata_free(u);
1708 }