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, pa_alsa_mapping *mapping) {
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     if (mapping)
1212         t = pa_sprintf_malloc("alsa_input.%s.%s", n, mapping->name);
1213     else
1214         t = pa_sprintf_malloc("alsa_input.%s", n);
1215
1216     pa_source_new_data_set_name(data, t);
1217     pa_xfree(t);
1218 }
1219
1220 static void find_mixer(struct userdata *u, pa_alsa_mapping *mapping, const char *element, pa_bool_t ignore_dB) {
1221
1222     if (!mapping && !element)
1223         return;
1224
1225     if (!(u->mixer_handle = pa_alsa_open_mixer_for_pcm(u->pcm_handle, &u->control_device))) {
1226         pa_log_info("Failed to find a working mixer device.");
1227         return;
1228     }
1229
1230     if (element) {
1231
1232         if (!(u->mixer_path = pa_alsa_path_synthesize(element, PA_ALSA_DIRECTION_INPUT)))
1233             goto fail;
1234
1235         if (pa_alsa_path_probe(u->mixer_path, u->mixer_handle, ignore_dB) < 0)
1236             goto fail;
1237
1238         pa_log_debug("Probed mixer path %s:", u->mixer_path->name);
1239         pa_alsa_path_dump(u->mixer_path);
1240     } else {
1241
1242         if (!(u->mixer_path_set = pa_alsa_path_set_new(mapping, PA_ALSA_DIRECTION_INPUT)))
1243             goto fail;
1244
1245         pa_alsa_path_set_probe(u->mixer_path_set, u->mixer_handle, ignore_dB);
1246
1247         pa_log_debug("Probed mixer paths:");
1248         pa_alsa_path_set_dump(u->mixer_path_set);
1249     }
1250
1251     return;
1252
1253 fail:
1254
1255     if (u->mixer_path_set) {
1256         pa_alsa_path_set_free(u->mixer_path_set);
1257         u->mixer_path_set = NULL;
1258     } else if (u->mixer_path) {
1259         pa_alsa_path_free(u->mixer_path);
1260         u->mixer_path = NULL;
1261     }
1262
1263     if (u->mixer_handle) {
1264         snd_mixer_close(u->mixer_handle);
1265         u->mixer_handle = NULL;
1266     }
1267 }
1268
1269 static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB) {
1270     pa_assert(u);
1271
1272     if (!u->mixer_handle)
1273         return 0;
1274
1275     if (u->source->active_port) {
1276         pa_alsa_port_data *data;
1277
1278         /* We have a list of supported paths, so let's activate the
1279          * one that has been chosen as active */
1280
1281         data = PA_DEVICE_PORT_DATA(u->source->active_port);
1282         u->mixer_path = data->path;
1283
1284         pa_alsa_path_select(data->path, u->mixer_handle);
1285
1286         if (data->setting)
1287             pa_alsa_setting_select(data->setting, u->mixer_handle);
1288
1289     } else {
1290
1291         if (!u->mixer_path && u->mixer_path_set)
1292             u->mixer_path = u->mixer_path_set->paths;
1293
1294         if (u->mixer_path) {
1295             /* Hmm, we have only a single path, then let's activate it */
1296
1297             pa_alsa_path_select(u->mixer_path, u->mixer_handle);
1298
1299             if (u->mixer_path->settings)
1300                 pa_alsa_setting_select(u->mixer_path->settings, u->mixer_handle);
1301         } else
1302             return 0;
1303     }
1304
1305     if (!u->mixer_path->has_volume)
1306         pa_log_info("Driver does not support hardware volume control, falling back to software volume control.");
1307     else {
1308
1309         if (u->mixer_path->has_dB) {
1310             pa_log_info("Hardware volume ranges from %0.2f dB to %0.2f dB.", u->mixer_path->min_dB, u->mixer_path->max_dB);
1311
1312             u->source->base_volume = pa_sw_volume_from_dB(-u->mixer_path->max_dB);
1313             u->source->n_volume_steps = PA_VOLUME_NORM+1;
1314
1315             if (u->mixer_path->max_dB > 0.0)
1316                 pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(u->source->base_volume));
1317             else
1318                 pa_log_info("No particular base volume set, fixing to 0 dB");
1319
1320         } else {
1321             pa_log_info("Hardware volume ranges from %li to %li.", u->mixer_path->min_volume, u->mixer_path->max_volume);
1322             u->source->base_volume = PA_VOLUME_NORM;
1323             u->source->n_volume_steps = u->mixer_path->max_volume - u->mixer_path->min_volume + 1;
1324         }
1325
1326         u->source->get_volume = source_get_volume_cb;
1327         u->source->set_volume = source_set_volume_cb;
1328
1329         u->source->flags |= PA_SOURCE_HW_VOLUME_CTRL | (u->mixer_path->has_dB ? PA_SOURCE_DECIBEL_VOLUME : 0);
1330         pa_log_info("Using hardware volume control. Hardware dB scale %s.", u->mixer_path->has_dB ? "supported" : "not supported");
1331     }
1332
1333     if (!u->mixer_path->has_mute) {
1334         pa_log_info("Driver does not support hardware mute control, falling back to software mute control.");
1335     } else {
1336         u->source->get_mute = source_get_mute_cb;
1337         u->source->set_mute = source_set_mute_cb;
1338         u->source->flags |= PA_SOURCE_HW_MUTE_CTRL;
1339         pa_log_info("Using hardware mute control.");
1340     }
1341
1342     u->mixer_fdl = pa_alsa_fdlist_new();
1343
1344     if (pa_alsa_fdlist_set_mixer(u->mixer_fdl, u->mixer_handle, u->core->mainloop) < 0) {
1345         pa_log("Failed to initialize file descriptor monitoring");
1346         return -1;
1347     }
1348
1349     if (u->mixer_path_set)
1350         pa_alsa_path_set_set_callback(u->mixer_path_set, u->mixer_handle, mixer_callback, u);
1351     else
1352         pa_alsa_path_set_callback(u->mixer_path, u->mixer_handle, mixer_callback, u);
1353
1354     return 0;
1355 }
1356
1357 pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, pa_card *card, pa_alsa_mapping *mapping) {
1358
1359     struct userdata *u = NULL;
1360     const char *dev_id = NULL;
1361     pa_sample_spec ss, requested_ss;
1362     pa_channel_map map;
1363     uint32_t nfrags, hwbuf_size, frag_size, tsched_size, tsched_watermark;
1364     snd_pcm_uframes_t period_frames, tsched_frames;
1365     size_t frame_size;
1366     pa_bool_t use_mmap = TRUE, b, use_tsched = TRUE, d, ignore_dB = FALSE;
1367     pa_source_new_data data;
1368     pa_alsa_profile_set *profile_set = NULL;
1369
1370     pa_assert(m);
1371     pa_assert(ma);
1372
1373     ss = m->core->default_sample_spec;
1374     map = m->core->default_channel_map;
1375     if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_ALSA) < 0) {
1376         pa_log("Failed to parse sample specification");
1377         goto fail;
1378     }
1379
1380     requested_ss = ss;
1381     frame_size = pa_frame_size(&ss);
1382
1383     nfrags = m->core->default_n_fragments;
1384     frag_size = (uint32_t) pa_usec_to_bytes(m->core->default_fragment_size_msec*PA_USEC_PER_MSEC, &ss);
1385     if (frag_size <= 0)
1386         frag_size = (uint32_t) frame_size;
1387     tsched_size = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_BUFFER_USEC, &ss);
1388     tsched_watermark = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_WATERMARK_USEC, &ss);
1389
1390     if (pa_modargs_get_value_u32(ma, "fragments", &nfrags) < 0 ||
1391         pa_modargs_get_value_u32(ma, "fragment_size", &frag_size) < 0 ||
1392         pa_modargs_get_value_u32(ma, "tsched_buffer_size", &tsched_size) < 0 ||
1393         pa_modargs_get_value_u32(ma, "tsched_buffer_watermark", &tsched_watermark) < 0) {
1394         pa_log("Failed to parse buffer metrics");
1395         goto fail;
1396     }
1397
1398     hwbuf_size = frag_size * nfrags;
1399     period_frames = frag_size/frame_size;
1400     tsched_frames = tsched_size/frame_size;
1401
1402     if (pa_modargs_get_value_boolean(ma, "mmap", &use_mmap) < 0) {
1403         pa_log("Failed to parse mmap argument.");
1404         goto fail;
1405     }
1406
1407     if (pa_modargs_get_value_boolean(ma, "tsched", &use_tsched) < 0) {
1408         pa_log("Failed to parse timer_scheduling argument.");
1409         goto fail;
1410     }
1411
1412     if (pa_modargs_get_value_boolean(ma, "ignore_dB", &ignore_dB) < 0) {
1413         pa_log("Failed to parse ignore_dB argument.");
1414         goto fail;
1415     }
1416
1417     if (use_tsched && !pa_rtclock_hrtimer()) {
1418         pa_log_notice("Disabling timer-based scheduling because high-resolution timers are not available from the kernel.");
1419         use_tsched = FALSE;
1420     }
1421
1422     u = pa_xnew0(struct userdata, 1);
1423     u->core = m->core;
1424     u->module = m;
1425     u->use_mmap = use_mmap;
1426     u->use_tsched = use_tsched;
1427     u->rtpoll = pa_rtpoll_new();
1428     pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
1429
1430     u->smoother = pa_smoother_new(
1431             DEFAULT_TSCHED_WATERMARK_USEC*2,
1432             DEFAULT_TSCHED_WATERMARK_USEC*2,
1433             TRUE,
1434             TRUE,
1435             5,
1436             pa_rtclock_usec(),
1437             FALSE);
1438
1439     dev_id = pa_modargs_get_value(
1440             ma, "device_id",
1441             pa_modargs_get_value(ma, "device", DEFAULT_DEVICE));
1442
1443     if (reserve_init(u, dev_id) < 0)
1444         goto fail;
1445
1446     if (reserve_monitor_init(u, dev_id) < 0)
1447         goto fail;
1448
1449     b = use_mmap;
1450     d = use_tsched;
1451
1452     if (mapping) {
1453
1454         if (!(dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
1455             pa_log("device_id= not set");
1456             goto fail;
1457         }
1458
1459         if (!(u->pcm_handle = pa_alsa_open_by_device_id_mapping(
1460                       dev_id,
1461                       &u->device_name,
1462                       &ss, &map,
1463                       SND_PCM_STREAM_CAPTURE,
1464                       &nfrags, &period_frames, tsched_frames,
1465                       &b, &d, mapping)))
1466             goto fail;
1467
1468     } else if ((dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
1469
1470         if (!(profile_set = pa_alsa_profile_set_new(NULL, &map)))
1471             goto fail;
1472
1473         if (!(u->pcm_handle = pa_alsa_open_by_device_id_auto(
1474                       dev_id,
1475                       &u->device_name,
1476                       &ss, &map,
1477                       SND_PCM_STREAM_CAPTURE,
1478                       &nfrags, &period_frames, tsched_frames,
1479                       &b, &d, profile_set, &mapping)))
1480             goto fail;
1481
1482     } else {
1483
1484         if (!(u->pcm_handle = pa_alsa_open_by_device_string(
1485                       pa_modargs_get_value(ma, "device", DEFAULT_DEVICE),
1486                       &u->device_name,
1487                       &ss, &map,
1488                       SND_PCM_STREAM_CAPTURE,
1489                       &nfrags, &period_frames, tsched_frames,
1490                       &b, &d, FALSE)))
1491             goto fail;
1492     }
1493
1494     pa_assert(u->device_name);
1495     pa_log_info("Successfully opened device %s.", u->device_name);
1496
1497     if (pa_alsa_pcm_is_modem(u->pcm_handle)) {
1498         pa_log_notice("Device %s is modem, refusing further initialization.", u->device_name);
1499         goto fail;
1500     }
1501
1502     if (mapping)
1503         pa_log_info("Selected mapping '%s' (%s).", mapping->description, mapping->name);
1504
1505     if (use_mmap && !b) {
1506         pa_log_info("Device doesn't support mmap(), falling back to UNIX read/write mode.");
1507         u->use_mmap = use_mmap = FALSE;
1508     }
1509
1510     if (use_tsched && (!b || !d)) {
1511         pa_log_info("Cannot enable timer-based scheduling, falling back to sound IRQ scheduling.");
1512         u->use_tsched = use_tsched = FALSE;
1513     }
1514
1515     if (use_tsched && !pa_alsa_pcm_is_hw(u->pcm_handle)) {
1516         pa_log_info("Device is not a hardware device, disabling timer-based scheduling.");
1517         u->use_tsched = use_tsched = FALSE;
1518     }
1519
1520     if (u->use_mmap)
1521         pa_log_info("Successfully enabled mmap() mode.");
1522
1523     if (u->use_tsched)
1524         pa_log_info("Successfully enabled timer-based scheduling mode.");
1525
1526     /* ALSA might tweak the sample spec, so recalculate the frame size */
1527     frame_size = pa_frame_size(&ss);
1528
1529     find_mixer(u, mapping, pa_modargs_get_value(ma, "control", NULL), ignore_dB);
1530
1531     pa_source_new_data_init(&data);
1532     data.driver = driver;
1533     data.module = m;
1534     data.card = card;
1535     set_source_name(&data, ma, dev_id, u->device_name, mapping);
1536     pa_source_new_data_set_sample_spec(&data, &ss);
1537     pa_source_new_data_set_channel_map(&data, &map);
1538
1539     pa_alsa_init_proplist_pcm(m->core, data.proplist, u->pcm_handle);
1540     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, u->device_name);
1541     pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_BUFFER_SIZE, "%lu", (unsigned long) (period_frames * frame_size * nfrags));
1542     pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZE, "%lu", (unsigned long) (period_frames * frame_size));
1543     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_ACCESS_MODE, u->use_tsched ? "mmap+timer" : (u->use_mmap ? "mmap" : "serial"));
1544
1545     if (mapping) {
1546         pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_NAME, mapping->name);
1547         pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_DESCRIPTION, mapping->description);
1548     }
1549
1550     pa_alsa_init_description(data.proplist);
1551
1552     if (u->control_device)
1553         pa_alsa_init_proplist_ctl(data.proplist, u->control_device);
1554
1555     if (pa_modargs_get_proplist(ma, "source_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
1556         pa_log("Invalid properties");
1557         pa_source_new_data_done(&data);
1558         goto fail;
1559     }
1560
1561     if (u->mixer_path_set)
1562         pa_alsa_add_ports(&data.ports, u->mixer_path_set);
1563
1564     u->source = pa_source_new(m->core, &data, PA_SOURCE_HARDWARE|PA_SOURCE_LATENCY|(u->use_tsched ? PA_SOURCE_DYNAMIC_LATENCY : 0));
1565     pa_source_new_data_done(&data);
1566
1567     if (!u->source) {
1568         pa_log("Failed to create source object");
1569         goto fail;
1570     }
1571
1572     u->source->parent.process_msg = source_process_msg;
1573     u->source->update_requested_latency = source_update_requested_latency_cb;
1574     u->source->set_state = source_set_state_cb;
1575     u->source->set_port = source_set_port_cb;
1576     u->source->userdata = u;
1577
1578     pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
1579     pa_source_set_rtpoll(u->source, u->rtpoll);
1580
1581     u->frame_size = frame_size;
1582     u->fragment_size = frag_size = (uint32_t) (period_frames * frame_size);
1583     u->nfragments = nfrags;
1584     u->hwbuf_size = u->fragment_size * nfrags;
1585     u->tsched_watermark = pa_usec_to_bytes_round_up(pa_bytes_to_usec_round_up(tsched_watermark, &requested_ss), &u->source->sample_spec);
1586     pa_cvolume_mute(&u->hardware_volume, u->source->sample_spec.channels);
1587
1588     pa_log_info("Using %u fragments of size %lu bytes, buffer time is %0.2fms",
1589                 nfrags, (long unsigned) u->fragment_size,
1590                 (double) pa_bytes_to_usec(u->hwbuf_size, &ss) / PA_USEC_PER_MSEC);
1591
1592     if (u->use_tsched) {
1593         u->watermark_step = pa_usec_to_bytes(TSCHED_WATERMARK_STEP_USEC, &u->source->sample_spec);
1594
1595         fix_min_sleep_wakeup(u);
1596         fix_tsched_watermark(u);
1597
1598         pa_source_set_latency_range(u->source,
1599                                     0,
1600                                     pa_bytes_to_usec(u->hwbuf_size, &ss));
1601
1602         pa_log_info("Time scheduling watermark is %0.2fms",
1603                     (double) pa_bytes_to_usec(u->tsched_watermark, &ss) / PA_USEC_PER_MSEC);
1604     } else
1605         pa_source_set_fixed_latency(u->source, pa_bytes_to_usec(u->hwbuf_size, &ss));
1606
1607     reserve_update(u);
1608
1609     if (update_sw_params(u) < 0)
1610         goto fail;
1611
1612     if (setup_mixer(u, ignore_dB) < 0)
1613         goto fail;
1614
1615     pa_alsa_dump(PA_LOG_DEBUG, u->pcm_handle);
1616
1617     if (!(u->thread = pa_thread_new(thread_func, u))) {
1618         pa_log("Failed to create thread.");
1619         goto fail;
1620     }
1621     /* Get initial mixer settings */
1622     if (data.volume_is_set) {
1623         if (u->source->set_volume)
1624             u->source->set_volume(u->source);
1625     } else {
1626         if (u->source->get_volume)
1627             u->source->get_volume(u->source);
1628     }
1629
1630     if (data.muted_is_set) {
1631         if (u->source->set_mute)
1632             u->source->set_mute(u->source);
1633     } else {
1634         if (u->source->get_mute)
1635             u->source->get_mute(u->source);
1636     }
1637
1638     pa_source_put(u->source);
1639
1640     if (profile_set)
1641         pa_alsa_profile_set_free(profile_set);
1642
1643     return u->source;
1644
1645 fail:
1646
1647     if (u)
1648         userdata_free(u);
1649
1650     if (profile_set)
1651         pa_alsa_profile_set_free(profile_set);
1652
1653     return NULL;
1654 }
1655
1656 static void userdata_free(struct userdata *u) {
1657     pa_assert(u);
1658
1659     if (u->source)
1660         pa_source_unlink(u->source);
1661
1662     if (u->thread) {
1663         pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
1664         pa_thread_free(u->thread);
1665     }
1666
1667     pa_thread_mq_done(&u->thread_mq);
1668
1669     if (u->source)
1670         pa_source_unref(u->source);
1671
1672     if (u->alsa_rtpoll_item)
1673         pa_rtpoll_item_free(u->alsa_rtpoll_item);
1674
1675     if (u->rtpoll)
1676         pa_rtpoll_free(u->rtpoll);
1677
1678     if (u->pcm_handle) {
1679         snd_pcm_drop(u->pcm_handle);
1680         snd_pcm_close(u->pcm_handle);
1681     }
1682
1683     if (u->mixer_fdl)
1684         pa_alsa_fdlist_free(u->mixer_fdl);
1685
1686     if (u->mixer_path_set)
1687         pa_alsa_path_set_free(u->mixer_path_set);
1688     else if (u->mixer_path)
1689         pa_alsa_path_free(u->mixer_path);
1690
1691     if (u->mixer_handle)
1692         snd_mixer_close(u->mixer_handle);
1693
1694     if (u->smoother)
1695         pa_smoother_free(u->smoother);
1696
1697     reserve_done(u);
1698     monitor_done(u);
1699
1700     pa_xfree(u->device_name);
1701     pa_xfree(u->control_device);
1702     pa_xfree(u);
1703 }
1704
1705 void pa_alsa_source_free(pa_source *s) {
1706     struct userdata *u;
1707
1708     pa_source_assert_ref(s);
1709     pa_assert_se(u = s->userdata);
1710
1711     userdata_free(u);
1712 }