src/modules/module-alsa-sink.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 of the License,
  10   or (at your option) any later version.
  11
  12   PulseAudio is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with PulseAudio; if not, write to the Free Software
  19   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  20   USA.
  21 ***/
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include <stdio.h>
  28
  29 #include <asoundlib.h>
  30
  31 #ifdef HAVE_VALGRIND_MEMCHECK_H
  32 #include <valgrind/memcheck.h>
  33 #endif
  34
  35 #include <pulse/xmalloc.h>
  36 #include <pulse/util.h>
  37 #include <pulse/timeval.h>
  38
  39 #include <pulsecore/core.h>
  40 #include <pulsecore/module.h>
  41 #include <pulsecore/memchunk.h>
  42 #include <pulsecore/sink.h>
  43 #include <pulsecore/modargs.h>
  44 #include <pulsecore/core-util.h>
  45 #include <pulsecore/sample-util.h>
  46 #include <pulsecore/log.h>
  47 #include <pulsecore/macro.h>
  48 #include <pulsecore/thread.h>
  49 #include <pulsecore/core-error.h>
  50 #include <pulsecore/thread-mq.h>
  51 #include <pulsecore/rtpoll.h>
  52 #include <pulsecore/rtclock.h>
  53 #include <pulsecore/time-smoother.h>
  54
  55 #include "alsa-util.h"
  56 #include "module-alsa-sink-symdef.h"
  57
  58 PA_MODULE_AUTHOR("Lennart Poettering");
  59 PA_MODULE_DESCRIPTION("ALSA Sink");
  60 PA_MODULE_VERSION(PACKAGE_VERSION);
  61 PA_MODULE_LOAD_ONCE(FALSE);
  62 PA_MODULE_USAGE(
  63         "sink_name=<name for the sink> "
  64         "device=<ALSA device> "
  65         "device_id=<ALSA card index> "
  66         "format=<sample format> "
  67         "rate=<sample rate> "
  68         "channels=<number of channels> "
  69         "channel_map=<channel map> "
  70         "fragments=<number of fragments> "
  71         "fragment_size=<fragment size> "
  72         "mmap=<enable memory mapping?> "
  73         "tsched=<enable system timer based scheduling mode?> "
  74         "tsched_buffer_size=<buffer size when using timer based scheduling> "
  75         "tsched_buffer_watermark=<lower fill watermark>");
  76
  77 static const char* const valid_modargs[] = {
  78     "sink_name",
  79     "device",
  80     "device_id",
  81     "format",
  82     "rate",
  83     "channels",
  84     "channel_map",
  85     "fragments",
  86     "fragment_size",
  87     "mmap",
  88     "tsched",
  89     "tsched_buffer_size",
  90     "tsched_buffer_watermark",
  91     NULL
  92 };
  93
  94 #define DEFAULT_DEVICE "default"
  95 #define DEFAULT_TSCHED_BUFFER_USEC (2*PA_USEC_PER_SEC)            /* 2s */
  96 #define DEFAULT_TSCHED_WATERMARK_USEC (20*PA_USEC_PER_MSEC)       /* 20ms */
  97 #define TSCHED_MIN_SLEEP_USEC (3*PA_USEC_PER_MSEC)                /* 3ms */
  98 #define TSCHED_MIN_WAKEUP_USEC (3*PA_USEC_PER_MSEC)               /* 3ms */
  99
 100 struct userdata {
 101     pa_core *core;
 102     pa_module *module;
 103     pa_sink *sink;
 104
 105     pa_thread *thread;
 106     pa_thread_mq thread_mq;
 107     pa_rtpoll *rtpoll;
 108
 109     snd_pcm_t *pcm_handle;
 110
 111     pa_alsa_fdlist *mixer_fdl;
 112     snd_mixer_t *mixer_handle;
 113     snd_mixer_elem_t *mixer_elem;
 114     long hw_volume_max, hw_volume_min;
 115     long hw_dB_max, hw_dB_min;
 116     pa_bool_t hw_dB_supported;
 117     pa_bool_t mixer_seperate_channels;
 118     pa_cvolume hardware_volume;
 119
 120     size_t frame_size, fragment_size, hwbuf_size, tsched_watermark;
 121     unsigned nfragments;
 122     pa_memchunk memchunk;
 123
 124     char *device_name;
 125
 126     pa_bool_t use_mmap, use_tsched;
 127
 128     pa_bool_t first, after_rewind;
 129
 130     pa_rtpoll_item *alsa_rtpoll_item;
 131
 132     snd_mixer_selem_channel_id_t mixer_map[SND_MIXER_SCHN_LAST];
 133
 134     pa_smoother *smoother;
 135     int64_t frame_index;
 136     uint64_t since_start;
 137
 138     snd_pcm_sframes_t hwbuf_unused_frames;
 139 };
 140
 141 static void fix_tsched_watermark(struct userdata *u) {
 142     size_t max_use;
 143     size_t min_sleep, min_wakeup;
 144     pa_assert(u);
 145
 146     max_use = u->hwbuf_size - (size_t) u->hwbuf_unused_frames * u->frame_size;
 147
 148     min_sleep = pa_usec_to_bytes(TSCHED_MIN_SLEEP_USEC, &u->sink->sample_spec);
 149     min_wakeup = pa_usec_to_bytes(TSCHED_MIN_WAKEUP_USEC, &u->sink->sample_spec);
 150
 151     if (min_sleep > max_use/2)
 152         min_sleep = pa_frame_align(max_use/2, &u->sink->sample_spec);
 153     if (min_sleep < u->frame_size)
 154         min_sleep = u->frame_size;
 155
 156     if (min_wakeup > max_use/2)
 157         min_wakeup = pa_frame_align(max_use/2, &u->sink->sample_spec);
 158     if (min_wakeup < u->frame_size)
 159         min_wakeup = u->frame_size;
 160
 161     if (u->tsched_watermark > max_use-min_sleep)
 162         u->tsched_watermark = max_use-min_sleep;
 163
 164     if (u->tsched_watermark < min_wakeup)
 165         u->tsched_watermark = min_wakeup;
 166 }
 167
 168 static void hw_sleep_time(struct userdata *u, pa_usec_t *sleep_usec, pa_usec_t*process_usec) {
 169     pa_usec_t usec, wm;
 170
 171     pa_assert(sleep_usec);
 172     pa_assert(process_usec);
 173
 174     pa_assert(u);
 175
 176     usec = pa_sink_get_requested_latency_within_thread(u->sink);
 177
 178     if (usec == (pa_usec_t) -1)
 179         usec = pa_bytes_to_usec(u->hwbuf_size, &u->sink->sample_spec);
 180
 181 /*     pa_log_debug("hw buffer time: %u ms", (unsigned) (usec / PA_USEC_PER_MSEC)); */
 182
 183     wm = pa_bytes_to_usec(u->tsched_watermark, &u->sink->sample_spec);
 184
 185     if (usec >= wm) {
 186         *sleep_usec = usec - wm;
 187         *process_usec = wm;
 188     } else
 189         *process_usec = *sleep_usec = usec / 2;
 190
 191 /*     pa_log_debug("after watermark: %u ms", (unsigned) (*sleep_usec / PA_USEC_PER_MSEC)); */
 192 }
 193
 194 static int try_recover(struct userdata *u, const char *call, int err) {
 195     pa_assert(u);
 196     pa_assert(call);
 197     pa_assert(err < 0);
 198
 199     pa_log_debug("%s: %s", call, snd_strerror(err));
 200
 201     pa_assert(err != -EAGAIN);
 202
 203     if (err == -EPIPE)
 204         pa_log_debug("%s: Buffer underrun!", call);
 205
 206     if ((err = snd_pcm_recover(u->pcm_handle, err, 1)) == 0) {
 207         u->first = TRUE;
 208         u->since_start = 0;
 209         return 0;
 210     }
 211
 212     pa_log("%s: %s", call, snd_strerror(err));
 213     return -1;
 214 }
 215
 216 static size_t check_left_to_play(struct userdata *u, snd_pcm_sframes_t n) {
 217     size_t left_to_play;
 218
 219     if ((size_t) n*u->frame_size < u->hwbuf_size)
 220         left_to_play = u->hwbuf_size - ((size_t) n*u->frame_size);
 221     else
 222         left_to_play = 0;
 223
 224     if (left_to_play > 0) {
 225 /*         pa_log_debug("%0.2f ms left to play", (double) pa_bytes_to_usec(left_to_play, &u->sink->sample_spec) / PA_USEC_PER_MSEC); */
 226     } else if (!u->first && !u->after_rewind) {
 227         pa_log_info("Underrun!");
 228
 229         if (u->use_tsched) {
 230             size_t old_watermark = u->tsched_watermark;
 231
 232             u->tsched_watermark *= 2;
 233             fix_tsched_watermark(u);
 234
 235             if (old_watermark != u->tsched_watermark)
 236                 pa_log_notice("Increasing wakeup watermark to %0.2f ms",
 237                               (double) pa_bytes_to_usec(u->tsched_watermark, &u->sink->sample_spec) / PA_USEC_PER_MSEC);
 238         }
 239     }
 240
 241     return left_to_play;
 242 }
 243
 244 static int mmap_write(struct userdata *u, pa_usec_t *sleep_usec) {
 245     int work_done = 0;
 246     pa_usec_t max_sleep_usec = 0, process_usec = 0;
 247     size_t left_to_play;
 248
 249     pa_assert(u);
 250     pa_sink_assert_ref(u->sink);
 251
 252     if (u->use_tsched)
 253         hw_sleep_time(u, &max_sleep_usec, &process_usec);
 254
 255     for (;;) {
 256         snd_pcm_sframes_t n;
 257         int r;
 258
 259         snd_pcm_hwsync(u->pcm_handle);
 260
 261         /* First we determine how many samples are missing to fill the
 262          * buffer up to 100% */
 263
 264         if (PA_UNLIKELY((n = snd_pcm_avail_update(u->pcm_handle)) < 0)) {
 265
 266             if ((r = try_recover(u, "snd_pcm_avail_update", (int) n)) == 0)
 267                 continue;
 268
 269             return r;
 270         }
 271
 272         left_to_play = check_left_to_play(u, n);
 273
 274         if (u->use_tsched)
 275
 276             /* We won't fill up the playback buffer before at least
 277             * half the sleep time is over because otherwise we might
 278             * ask for more data from the clients then they expect. We
 279             * need to guarantee that clients only have to keep around
 280             * a single hw buffer length. */
 281
 282             if (pa_bytes_to_usec(left_to_play, &u->sink->sample_spec) > process_usec+max_sleep_usec/2)
 283                 break;
 284
 285         if (PA_UNLIKELY(n <= u->hwbuf_unused_frames))
 286             break;
 287
 288         n -= u->hwbuf_unused_frames;
 289
 290 /*         pa_log_debug("Filling up"); */
 291
 292         for (;;) {
 293             pa_memchunk chunk;
 294             void *p;
 295             int err;
 296             const snd_pcm_channel_area_t *areas;
 297             snd_pcm_uframes_t offset, frames = (snd_pcm_uframes_t) n;
 298             snd_pcm_sframes_t sframes;
 299
 300 /*             pa_log_debug("%lu frames to write", (unsigned long) frames); */
 301
 302             if (PA_UNLIKELY((err = snd_pcm_mmap_begin(u->pcm_handle, &areas, &offset, &frames)) < 0)) {
 303
 304                 if ((r = try_recover(u, "snd_pcm_mmap_begin", err)) == 0)
 305                     continue;
 306
 307                 return r;
 308             }
 309
 310             /* Make sure that if these memblocks need to be copied they will fit into one slot */
 311             if (frames > pa_mempool_block_size_max(u->sink->core->mempool)/u->frame_size)
 312                 frames = pa_mempool_block_size_max(u->sink->core->mempool)/u->frame_size;
 313
 314             /* Check these are multiples of 8 bit */
 315             pa_assert((areas[0].first & 7) == 0);
 316             pa_assert((areas[0].step & 7)== 0);
 317
 318             /* We assume a single interleaved memory buffer */
 319             pa_assert((areas[0].first >> 3) == 0);
 320             pa_assert((areas[0].step >> 3) == u->frame_size);
 321
 322             p = (uint8_t*) areas[0].addr + (offset * u->frame_size);
 323
 324             chunk.memblock = pa_memblock_new_fixed(u->core->mempool, p, frames * u->frame_size, TRUE);
 325             chunk.length = pa_memblock_get_length(chunk.memblock);
 326             chunk.index = 0;
 327
 328             pa_sink_render_into_full(u->sink, &chunk);
 329
 330             /* FIXME: Maybe we can do something to keep this memory block
 331              * a little bit longer around? */
 332             pa_memblock_unref_fixed(chunk.memblock);
 333
 334             if (PA_UNLIKELY((sframes = snd_pcm_mmap_commit(u->pcm_handle, offset, frames)) < 0)) {
 335
 336                 if ((r = try_recover(u, "snd_pcm_mmap_commit", (int) sframes)) == 0)
 337                     continue;
 338
 339                 return r;
 340             }
 341
 342             work_done = 1;
 343
 344             u->frame_index += (int64_t) frames;
 345             u->since_start += frames * u->frame_size;
 346
 347 /*             pa_log_debug("wrote %lu frames", (unsigned long) frames); */
 348
 349             if (frames >= (snd_pcm_uframes_t) n)
 350                 break;
 351
 352             n -= (snd_pcm_sframes_t) frames;
 353         }
 354     }
 355
 356     *sleep_usec = pa_bytes_to_usec(left_to_play, &u->sink->sample_spec) - process_usec;
 357     return work_done;
 358 }
 359
 360 static int unix_write(struct userdata *u, pa_usec_t *sleep_usec) {
 361     int work_done = 0;
 362     pa_usec_t max_sleep_usec = 0, process_usec = 0;
 363     size_t left_to_play;
 364
 365     pa_assert(u);
 366     pa_sink_assert_ref(u->sink);
 367
 368     if (u->use_tsched)
 369         hw_sleep_time(u, &max_sleep_usec, &process_usec);
 370
 371     for (;;) {
 372         snd_pcm_sframes_t n;
 373         int r;
 374
 375         snd_pcm_hwsync(u->pcm_handle);
 376
 377         if (PA_UNLIKELY((n = snd_pcm_avail_update(u->pcm_handle)) < 0)) {
 378
 379             if ((r = try_recover(u, "snd_pcm_avail_update", (int) n)) == 0)
 380                 continue;
 381
 382             return r;
 383         }
 384
 385         left_to_play = check_left_to_play(u, n);
 386
 387         if (u->use_tsched)
 388
 389             /* We won't fill up the playback buffer before at least
 390             * half the sleep time is over because otherwise we might
 391             * ask for more data from the clients then they expect. We
 392             * need to guarantee that clients only have to keep around
 393             * a single hw buffer length. */
 394
 395             if (pa_bytes_to_usec(left_to_play, &u->sink->sample_spec) > process_usec+max_sleep_usec/2)
 396                 break;
 397
 398         if (PA_UNLIKELY(n <= u->hwbuf_unused_frames))
 399             break;
 400
 401         n -= u->hwbuf_unused_frames;
 402
 403         for (;;) {
 404             snd_pcm_sframes_t frames;
 405             void *p;
 406
 407 /*         pa_log_debug("%lu frames to write", (unsigned long) frames); */
 408
 409             if (u->memchunk.length <= 0)
 410                 pa_sink_render(u->sink, (size_t) n * u->frame_size, &u->memchunk);
 411
 412             pa_assert(u->memchunk.length > 0);
 413
 414             frames = (snd_pcm_sframes_t) (u->memchunk.length / u->frame_size);
 415
 416             if (frames > n)
 417                 frames = n;
 418
 419             p = pa_memblock_acquire(u->memchunk.memblock);
 420             frames = snd_pcm_writei(u->pcm_handle, (const uint8_t*) p + u->memchunk.index, (snd_pcm_uframes_t) frames);
 421             pa_memblock_release(u->memchunk.memblock);
 422
 423             pa_assert(frames != 0);
 424
 425             if (PA_UNLIKELY(frames < 0)) {
 426
 427                 if ((r = try_recover(u, "snd_pcm_writei", (int) frames)) == 0)
 428                     continue;
 429
 430                 return r;
 431             }
 432
 433             u->memchunk.index += (size_t) frames * u->frame_size;
 434             u->memchunk.length -= (size_t) frames * u->frame_size;
 435
 436             if (u->memchunk.length <= 0) {
 437                 pa_memblock_unref(u->memchunk.memblock);
 438                 pa_memchunk_reset(&u->memchunk);
 439             }
 440
 441             work_done = 1;
 442
 443             u->frame_index += frames;
 444             u->since_start += (size_t) frames * u->frame_size;
 445
 446 /*         pa_log_debug("wrote %lu frames", (unsigned long) frames); */
 447
 448             if (frames >= n)
 449                 break;
 450
 451             n -= frames;
 452         }
 453     }
 454
 455     *sleep_usec = pa_bytes_to_usec(left_to_play, &u->sink->sample_spec) - process_usec;
 456     return work_done;
 457 }
 458
 459 static void update_smoother(struct userdata *u) {
 460     snd_pcm_sframes_t delay  = 0;
 461     int64_t frames;
 462     int err;
 463     pa_usec_t now1, now2;
 464 /*     struct timeval timestamp; */
 465     snd_pcm_status_t *status;
 466
 467     snd_pcm_status_alloca(&status);
 468
 469     pa_assert(u);
 470     pa_assert(u->pcm_handle);
 471
 472     /* Let's update the time smoother */
 473
 474     snd_pcm_hwsync(u->pcm_handle);
 475     snd_pcm_avail_update(u->pcm_handle);
 476
 477 /*     if (PA_UNLIKELY((err = snd_pcm_status(u->pcm_handle, status)) < 0)) { */
 478 /*         pa_log("Failed to query DSP status data: %s", snd_strerror(err)); */
 479 /*         return; */
 480 /*     } */
 481
 482 /*     delay = snd_pcm_status_get_delay(status); */
 483
 484     if (PA_UNLIKELY((err = snd_pcm_delay(u->pcm_handle, &delay)) < 0)) {
 485         pa_log("Failed to query DSP status data: %s", snd_strerror(err));
 486         return;
 487     }
 488
 489     frames = u->frame_index - delay;
 490
 491 /*     pa_log_debug("frame_index = %llu, delay = %llu, p = %llu", (unsigned long long) u->frame_index, (unsigned long long) delay, (unsigned long long) frames); */
 492
 493 /*     snd_pcm_status_get_tstamp(status, &timestamp); */
 494 /*     pa_rtclock_from_wallclock(&timestamp); */
 495 /*     now1 = pa_timeval_load(&timestamp); */
 496
 497     now1 = pa_rtclock_usec();
 498     now2 = pa_bytes_to_usec((uint64_t) frames * u->frame_size, &u->sink->sample_spec);
 499     pa_smoother_put(u->smoother, now1, now2);
 500 }
 501
 502 static pa_usec_t sink_get_latency(struct userdata *u) {
 503     pa_usec_t r = 0;
 504     int64_t delay;
 505     pa_usec_t now1, now2;
 506
 507     pa_assert(u);
 508
 509     now1 = pa_rtclock_usec();
 510     now2 = pa_smoother_get(u->smoother, now1);
 511
 512     delay = (int64_t) pa_bytes_to_usec((uint64_t) u->frame_index * u->frame_size, &u->sink->sample_spec) - (int64_t) now2;
 513
 514     if (delay > 0)
 515         r = (pa_usec_t) delay;
 516
 517     if (u->memchunk.memblock)
 518         r += pa_bytes_to_usec(u->memchunk.length, &u->sink->sample_spec);
 519
 520     return r;
 521 }
 522
 523 static int build_pollfd(struct userdata *u) {
 524     pa_assert(u);
 525     pa_assert(u->pcm_handle);
 526
 527     if (u->alsa_rtpoll_item)
 528         pa_rtpoll_item_free(u->alsa_rtpoll_item);
 529
 530     if (!(u->alsa_rtpoll_item = pa_alsa_build_pollfd(u->pcm_handle, u->rtpoll)))
 531         return -1;
 532
 533     return 0;
 534 }
 535
 536 static int suspend(struct userdata *u) {
 537     pa_assert(u);
 538     pa_assert(u->pcm_handle);
 539
 540     pa_smoother_pause(u->smoother, pa_rtclock_usec());
 541
 542     /* Let's suspend */
 543     snd_pcm_drain(u->pcm_handle);
 544     snd_pcm_close(u->pcm_handle);
 545     u->pcm_handle = NULL;
 546
 547     if (u->alsa_rtpoll_item) {
 548         pa_rtpoll_item_free(u->alsa_rtpoll_item);
 549         u->alsa_rtpoll_item = NULL;
 550     }
 551
 552     pa_log_info("Device suspended...");
 553
 554     return 0;
 555 }
 556
 557 static int update_sw_params(struct userdata *u) {
 558     snd_pcm_uframes_t avail_min;
 559     int err;
 560
 561     pa_assert(u);
 562
 563     /* Use the full buffer if noone asked us for anything specific */
 564     u->hwbuf_unused_frames = 0;
 565
 566     if (u->use_tsched) {
 567         pa_usec_t latency;
 568
 569         if ((latency = pa_sink_get_requested_latency_within_thread(u->sink)) != (pa_usec_t) -1) {
 570             size_t b;
 571
 572             pa_log_debug("latency set to %0.2f", (double) latency / PA_USEC_PER_MSEC);
 573
 574             b = pa_usec_to_bytes(latency, &u->sink->sample_spec);
 575
 576             /* We need at least one sample in our buffer */
 577
 578             if (PA_UNLIKELY(b < u->frame_size))
 579                 b = u->frame_size;
 580
 581             u->hwbuf_unused_frames = (snd_pcm_sframes_t)
 582                 (PA_LIKELY(b < u->hwbuf_size) ?
 583                  ((u->hwbuf_size - b) / u->frame_size) : 0);
 584
 585             fix_tsched_watermark(u);
 586         }
 587     }
 588
 589     pa_log_debug("hwbuf_unused_frames=%lu", (unsigned long) u->hwbuf_unused_frames);
 590
 591     /* We need at last one frame in the used part of the buffer */
 592     avail_min = (snd_pcm_uframes_t) u->hwbuf_unused_frames + 1;
 593
 594     if (u->use_tsched) {
 595         pa_usec_t sleep_usec, process_usec;
 596
 597         hw_sleep_time(u, &sleep_usec, &process_usec);
 598         avail_min += pa_usec_to_bytes(sleep_usec, &u->sink->sample_spec);
 599     }
 600
 601     pa_log_debug("setting avail_min=%lu", (unsigned long) avail_min);
 602
 603     if ((err = pa_alsa_set_sw_params(u->pcm_handle, avail_min)) < 0) {
 604         pa_log("Failed to set software parameters: %s", snd_strerror(err));
 605         return err;
 606     }
 607
 608     pa_sink_set_max_request(u->sink, u->hwbuf_size - (size_t) u->hwbuf_unused_frames * u->frame_size);
 609
 610     return 0;
 611 }
 612
 613 static int unsuspend(struct userdata *u) {
 614     pa_sample_spec ss;
 615     int err;
 616     pa_bool_t b, d;
 617     unsigned nfrags;
 618     snd_pcm_uframes_t period_size;
 619
 620     pa_assert(u);
 621     pa_assert(!u->pcm_handle);
 622
 623     pa_log_info("Trying resume...");
 624
 625     snd_config_update_free_global();
 626     if ((err = snd_pcm_open(&u->pcm_handle, u->device_name, SND_PCM_STREAM_PLAYBACK,
 627                             /*SND_PCM_NONBLOCK|*/
 628                             SND_PCM_NO_AUTO_RESAMPLE|
 629                             SND_PCM_NO_AUTO_CHANNELS|
 630                             SND_PCM_NO_AUTO_FORMAT)) < 0) {
 631         pa_log("Error opening PCM device %s: %s", u->device_name, snd_strerror(err));
 632         goto fail;
 633     }
 634
 635     ss = u->sink->sample_spec;
 636     nfrags = u->nfragments;
 637     period_size = u->fragment_size / u->frame_size;
 638     b = u->use_mmap;
 639     d = u->use_tsched;
 640
 641     if ((err = pa_alsa_set_hw_params(u->pcm_handle, &ss, &nfrags, &period_size, u->hwbuf_size / u->frame_size, &b, &d, TRUE)) < 0) {
 642         pa_log("Failed to set hardware parameters: %s", snd_strerror(err));
 643         goto fail;
 644     }
 645
 646     if (b != u->use_mmap || d != u->use_tsched) {
 647         pa_log_warn("Resume failed, couldn't get original access mode.");
 648         goto fail;
 649     }
 650
 651     if (!pa_sample_spec_equal(&ss, &u->sink->sample_spec)) {
 652         pa_log_warn("Resume failed, couldn't restore original sample settings.");
 653         goto fail;
 654     }
 655
 656     if (nfrags != u->nfragments || period_size*u->frame_size != u->fragment_size) {
 657         pa_log_warn("Resume failed, couldn't restore original fragment settings. (Old: %lu*%lu, New %lu*%lu)",
 658                     (unsigned long) u->nfragments, (unsigned long) u->fragment_size,
 659                     (unsigned long) nfrags, period_size * u->frame_size);
 660         goto fail;
 661     }
 662
 663     if (update_sw_params(u) < 0)
 664         goto fail;
 665
 666     if (build_pollfd(u) < 0)
 667         goto fail;
 668
 669     /* FIXME: We need to reload the volume somehow */
 670
 671     u->first = TRUE;
 672     u->since_start = 0;
 673
 674     pa_log_info("Resumed successfully...");
 675
 676     return 0;
 677
 678 fail:
 679     if (u->pcm_handle) {
 680         snd_pcm_close(u->pcm_handle);
 681         u->pcm_handle = NULL;
 682     }
 683
 684     return -1;
 685 }
 686
 687 static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
 688     struct userdata *u = PA_SINK(o)->userdata;
 689
 690     switch (code) {
 691
 692         case PA_SINK_MESSAGE_GET_LATENCY: {
 693             pa_usec_t r = 0;
 694
 695             if (u->pcm_handle)
 696                 r = sink_get_latency(u);
 697
 698             *((pa_usec_t*) data) = r;
 699
 700             return 0;
 701         }
 702
 703         case PA_SINK_MESSAGE_SET_STATE:
 704
 705             switch ((pa_sink_state_t) PA_PTR_TO_UINT(data)) {
 706
 707                 case PA_SINK_SUSPENDED:
 708                     pa_assert(PA_SINK_IS_OPENED(u->sink->thread_info.state));
 709
 710                     if (suspend(u) < 0)
 711                         return -1;
 712
 713                     break;
 714
 715                 case PA_SINK_IDLE:
 716                 case PA_SINK_RUNNING:
 717
 718                     if (u->sink->thread_info.state == PA_SINK_INIT) {
 719                         if (build_pollfd(u) < 0)
 720                             return -1;
 721                     }
 722
 723                     if (u->sink->thread_info.state == PA_SINK_SUSPENDED) {
 724                         if (unsuspend(u) < 0)
 725                             return -1;
 726                     }
 727
 728                     break;
 729
 730                 case PA_SINK_UNLINKED:
 731                 case PA_SINK_INIT:
 732                     ;
 733             }
 734
 735             break;
 736     }
 737
 738     return pa_sink_process_msg(o, code, data, offset, chunk);
 739 }
 740
 741 static int mixer_callback(snd_mixer_elem_t *elem, unsigned int mask) {
 742     struct userdata *u = snd_mixer_elem_get_callback_private(elem);
 743
 744     pa_assert(u);
 745     pa_assert(u->mixer_handle);
 746
 747     if (mask == SND_CTL_EVENT_MASK_REMOVE)
 748         return 0;
 749
 750     if (mask & SND_CTL_EVENT_MASK_VALUE) {
 751         pa_sink_get_volume(u->sink, TRUE);
 752         pa_sink_get_mute(u->sink, TRUE);
 753     }
 754
 755     return 0;
 756 }
 757
 758 static pa_volume_t from_alsa_volume(struct userdata *u, long alsa_vol) {
 759
 760     return (pa_volume_t) round(((double) (alsa_vol - u->hw_volume_min) * PA_VOLUME_NORM) /
 761                                (double) (u->hw_volume_max - u->hw_volume_min));
 762 }
 763
 764 static long to_alsa_volume(struct userdata *u, pa_volume_t vol) {
 765     long alsa_vol;
 766
 767     alsa_vol = (long) round(((double) vol * (double) (u->hw_volume_max - u->hw_volume_min))
 768                             / PA_VOLUME_NORM) + u->hw_volume_min;
 769
 770     return PA_CLAMP_UNLIKELY(alsa_vol, u->hw_volume_min, u->hw_volume_max);
 771 }
 772
 773 static int sink_get_volume_cb(pa_sink *s) {
 774     struct userdata *u = s->userdata;
 775     int err;
 776     unsigned i;
 777     pa_cvolume r;
 778     char t[PA_CVOLUME_SNPRINT_MAX];
 779
 780     pa_assert(u);
 781     pa_assert(u->mixer_elem);
 782
 783     if (u->mixer_seperate_channels) {
 784
 785         r.channels = s->sample_spec.channels;
 786
 787         for (i = 0; i < s->sample_spec.channels; i++) {
 788             long alsa_vol;
 789
 790             if (u->hw_dB_supported) {
 791
 792                 if ((err = snd_mixer_selem_get_playback_dB(u->mixer_elem, u->mixer_map[i], &alsa_vol)) < 0)
 793                     goto fail;
 794
 795 #ifdef HAVE_VALGRIND_MEMCHECK_H
 796                 VALGRIND_MAKE_MEM_DEFINED(&alsa_vol, sizeof(alsa_vol));
 797 #endif
 798
 799                 r.values[i] = pa_sw_volume_from_dB((double) alsa_vol / 100.0);
 800             } else {
 801
 802                 if ((err = snd_mixer_selem_get_playback_volume(u->mixer_elem, u->mixer_map[i], &alsa_vol)) < 0)
 803                     goto fail;
 804
 805                 r.values[i] = from_alsa_volume(u, alsa_vol);
 806             }
 807         }
 808
 809     } else {
 810         long alsa_vol;
 811
 812         if (u->hw_dB_supported) {
 813
 814             if ((err = snd_mixer_selem_get_playback_dB(u->mixer_elem, SND_MIXER_SCHN_MONO, &alsa_vol)) < 0)
 815                 goto fail;
 816
 817 #ifdef HAVE_VALGRIND_MEMCHECK_H
 818             VALGRIND_MAKE_MEM_DEFINED(&alsa_vol, sizeof(alsa_vol));
 819 #endif
 820
 821             pa_cvolume_set(&r, s->sample_spec.channels, pa_sw_volume_from_dB((double) alsa_vol / 100.0));
 822
 823         } else {
 824
 825             if ((err = snd_mixer_selem_get_playback_volume(u->mixer_elem, SND_MIXER_SCHN_MONO, &alsa_vol)) < 0)
 826                 goto fail;
 827
 828             pa_cvolume_set(&r, s->sample_spec.channels, from_alsa_volume(u, alsa_vol));
 829         }
 830     }
 831
 832     pa_log_debug("Read hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &r));
 833
 834     if (!pa_cvolume_equal(&u->hardware_volume, &r)) {
 835
 836         u->hardware_volume = s->volume = r;
 837
 838         if (u->hw_dB_supported) {
 839             pa_cvolume reset;
 840
 841             /* Hmm, so the hardware volume changed, let's reset our software volume */
 842
 843             pa_cvolume_reset(&reset, s->sample_spec.channels);
 844             pa_sink_set_soft_volume(s, &reset);
 845         }
 846     }
 847
 848     return 0;
 849
 850 fail:
 851     pa_log_error("Unable to read volume: %s", snd_strerror(err));
 852
 853     return -1;
 854 }
 855
 856 static int sink_set_volume_cb(pa_sink *s) {
 857     struct userdata *u = s->userdata;
 858     int err;
 859     unsigned i;
 860     pa_cvolume r;
 861
 862     pa_assert(u);
 863     pa_assert(u->mixer_elem);
 864
 865     if (u->mixer_seperate_channels) {
 866
 867         r.channels = s->sample_spec.channels;
 868
 869         for (i = 0; i < s->sample_spec.channels; i++) {
 870             long alsa_vol;
 871             pa_volume_t vol;
 872
 873             vol = s->volume.values[i];
 874
 875             if (u->hw_dB_supported) {
 876
 877                 alsa_vol = (long) (pa_sw_volume_to_dB(vol) * 100);
 878                 alsa_vol = PA_CLAMP_UNLIKELY(alsa_vol, u->hw_dB_min, u->hw_dB_max);
 879
 880                 if ((err = snd_mixer_selem_set_playback_dB(u->mixer_elem, u->mixer_map[i], alsa_vol, 1)) < 0)
 881                     goto fail;
 882
 883                 if ((err = snd_mixer_selem_get_playback_dB(u->mixer_elem, u->mixer_map[i], &alsa_vol)) < 0)
 884                     goto fail;
 885
 886                 r.values[i] = pa_sw_volume_from_dB((double) alsa_vol / 100.0);
 887
 888             } else {
 889                 alsa_vol = to_alsa_volume(u, vol);
 890
 891                 if ((err = snd_mixer_selem_set_playback_volume(u->mixer_elem, u->mixer_map[i], alsa_vol)) < 0)
 892                     goto fail;
 893
 894                 if ((err = snd_mixer_selem_get_playback_volume(u->mixer_elem, u->mixer_map[i], &alsa_vol)) < 0)
 895                     goto fail;
 896
 897                 r.values[i] = from_alsa_volume(u, alsa_vol);
 898             }
 899         }
 900
 901     } else {
 902         pa_volume_t vol;
 903         long alsa_vol;
 904
 905         vol = pa_cvolume_max(&s->volume);
 906
 907         if (u->hw_dB_supported) {
 908             alsa_vol = (long) (pa_sw_volume_to_dB(vol) * 100);
 909             alsa_vol = PA_CLAMP_UNLIKELY(alsa_vol, u->hw_dB_min, u->hw_dB_max);
 910
 911             if ((err = snd_mixer_selem_set_playback_dB_all(u->mixer_elem, alsa_vol, 1)) < 0)
 912                 goto fail;
 913
 914             if ((err = snd_mixer_selem_get_playback_dB(u->mixer_elem, SND_MIXER_SCHN_MONO, &alsa_vol)) < 0)
 915                 goto fail;
 916
 917             pa_cvolume_set(&r, s->volume.channels, pa_sw_volume_from_dB((double) alsa_vol / 100.0));
 918
 919         } else {
 920             alsa_vol = to_alsa_volume(u, vol);
 921
 922             if ((err = snd_mixer_selem_set_playback_volume_all(u->mixer_elem, alsa_vol)) < 0)
 923                 goto fail;
 924
 925             if ((err = snd_mixer_selem_get_playback_volume(u->mixer_elem, SND_MIXER_SCHN_MONO, &alsa_vol)) < 0)
 926                 goto fail;
 927
 928             pa_cvolume_set(&r, s->sample_spec.channels, from_alsa_volume(u, alsa_vol));
 929         }
 930     }
 931
 932     u->hardware_volume = r;
 933
 934     if (u->hw_dB_supported) {
 935         char t[PA_CVOLUME_SNPRINT_MAX];
 936
 937         /* Match exactly what the user requested by software */
 938
 939         pa_alsa_volume_divide(&r, &s->volume);
 940         pa_sink_set_soft_volume(s, &r);
 941
 942         pa_log_debug("Requested volume: %s", pa_cvolume_snprint(t, sizeof(t), &s->volume));
 943         pa_log_debug("Got hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &u->hardware_volume));
 944         pa_log_debug("Calculated software volume: %s", pa_cvolume_snprint(t, sizeof(t), &r));
 945
 946     } else
 947
 948         /* We can't match exactly what the user requested, hence let's
 949          * at least tell the user about it */
 950
 951         s->volume = r;
 952
 953     return 0;
 954
 955 fail:
 956     pa_log_error("Unable to set volume: %s", snd_strerror(err));
 957
 958     return -1;
 959 }
 960
 961 static int sink_get_mute_cb(pa_sink *s) {
 962     struct userdata *u = s->userdata;
 963     int err, sw;
 964
 965     pa_assert(u);
 966     pa_assert(u->mixer_elem);
 967
 968     if ((err = snd_mixer_selem_get_playback_switch(u->mixer_elem, 0, &sw)) < 0) {
 969         pa_log_error("Unable to get switch: %s", snd_strerror(err));
 970         return -1;
 971     }
 972
 973     s->muted = !sw;
 974
 975     return 0;
 976 }
 977
 978 static int sink_set_mute_cb(pa_sink *s) {
 979     struct userdata *u = s->userdata;
 980     int err;
 981
 982     pa_assert(u);
 983     pa_assert(u->mixer_elem);
 984
 985     if ((err = snd_mixer_selem_set_playback_switch_all(u->mixer_elem, !s->muted)) < 0) {
 986         pa_log_error("Unable to set switch: %s", snd_strerror(err));
 987         return -1;
 988     }
 989
 990     return 0;
 991 }
 992
 993 static void sink_update_requested_latency_cb(pa_sink *s) {
 994     struct userdata *u = s->userdata;
 995     snd_pcm_sframes_t before;
 996     pa_assert(u);
 997
 998     if (!u->pcm_handle)
 999         return;
1000
1001     before = u->hwbuf_unused_frames;
1002     update_sw_params(u);
1003
1004     /* Let's check whether we now use only a smaller part of the
1005     buffer then before. If so, we need to make sure that subsequent
1006     rewinds are relative to the new maxium fill level and not to the
1007     current fill level. Thus, let's do a full rewind once, to clear
1008     things up. */
1009
1010     if (u->hwbuf_unused_frames > before) {
1011         pa_log_debug("Requesting rewind due to latency change.");
1012         pa_sink_request_rewind(s, (size_t) -1);
1013     }
1014 }
1015
1016 static int process_rewind(struct userdata *u) {
1017     snd_pcm_sframes_t unused;
1018     size_t rewind_nbytes, unused_nbytes, limit_nbytes;
1019     pa_assert(u);
1020
1021     /* Figure out how much we shall rewind and reset the counter */
1022     rewind_nbytes = u->sink->thread_info.rewind_nbytes;
1023     u->sink->thread_info.rewind_nbytes = 0;
1024
1025     if (rewind_nbytes <= 0)
1026         goto finish;
1027
1028     pa_assert(rewind_nbytes > 0);
1029     pa_log_debug("Requested to rewind %lu bytes.", (unsigned long) rewind_nbytes);
1030
1031     snd_pcm_hwsync(u->pcm_handle);
1032     if ((unused = snd_pcm_avail_update(u->pcm_handle)) < 0) {
1033         pa_log("snd_pcm_avail_update() failed: %s", snd_strerror((int) unused));
1034         return -1;
1035     }
1036
1037     unused_nbytes = u->tsched_watermark + (size_t) unused * u->frame_size;
1038
1039     if (u->hwbuf_size > unused_nbytes)
1040         limit_nbytes = u->hwbuf_size - unused_nbytes;
1041     else
1042         limit_nbytes = 0;
1043
1044     if (rewind_nbytes > limit_nbytes)
1045         rewind_nbytes = limit_nbytes;
1046
1047     if (rewind_nbytes > 0) {
1048         snd_pcm_sframes_t in_frames, out_frames;
1049
1050         pa_log_debug("Limited to %lu bytes.", (unsigned long) rewind_nbytes);
1051
1052         in_frames = (snd_pcm_sframes_t) (rewind_nbytes / u->frame_size);
1053         pa_log_debug("before: %lu", (unsigned long) in_frames);
1054         if ((out_frames = snd_pcm_rewind(u->pcm_handle, (snd_pcm_uframes_t) in_frames)) < 0) {
1055             pa_log("snd_pcm_rewind() failed: %s", snd_strerror((int) out_frames));
1056             return -1;
1057         }
1058         pa_log_debug("after: %lu", (unsigned long) out_frames);
1059
1060         rewind_nbytes = (size_t) out_frames * u->frame_size;
1061
1062         if (rewind_nbytes <= 0)
1063             pa_log_info("Tried rewind, but was apparently not possible.");
1064         else {
1065             u->frame_index -= out_frames;
1066             pa_log_debug("Rewound %lu bytes.", (unsigned long) rewind_nbytes);
1067             pa_sink_process_rewind(u->sink, rewind_nbytes);
1068
1069             u->after_rewind = TRUE;
1070             return 0;
1071         }
1072     } else
1073         pa_log_debug("Mhmm, actually there is nothing to rewind.");
1074
1075 finish:
1076
1077     pa_sink_process_rewind(u->sink, 0);
1078
1079     return 0;
1080
1081 }
1082
1083 static void thread_func(void *userdata) {
1084     struct userdata *u = userdata;
1085
1086     pa_assert(u);
1087
1088     pa_log_debug("Thread starting up");
1089
1090     if (u->core->realtime_scheduling)
1091         pa_make_realtime(u->core->realtime_priority);
1092
1093     pa_thread_mq_install(&u->thread_mq);
1094     pa_rtpoll_install(u->rtpoll);
1095
1096     for (;;) {
1097         int ret;
1098
1099 /*         pa_log_debug("loop"); */
1100
1101         /* Render some data and write it to the dsp */
1102         if (PA_SINK_IS_OPENED(u->sink->thread_info.state)) {
1103             int work_done;
1104             pa_usec_t sleep_usec = 0;
1105
1106             if (u->sink->thread_info.rewind_requested)
1107                 if (process_rewind(u) < 0)
1108                         goto fail;
1109
1110             if (u->use_mmap)
1111                 work_done = mmap_write(u, &sleep_usec);
1112             else
1113                 work_done = unix_write(u, &sleep_usec);
1114
1115             if (work_done < 0)
1116                 goto fail;
1117
1118 /*             pa_log_debug("work_done = %i", work_done); */
1119
1120             if (work_done) {
1121
1122                 if (u->first) {
1123                     pa_log_info("Starting playback.");
1124                     snd_pcm_start(u->pcm_handle);
1125
1126                     pa_smoother_resume(u->smoother, pa_rtclock_usec());
1127                 }
1128
1129                 update_smoother(u);
1130             }
1131
1132             if (u->use_tsched) {
1133                 pa_usec_t cusec;
1134
1135                 if (u->since_start <= u->hwbuf_size) {
1136
1137                     /* USB devices on ALSA seem to hit a buffer
1138                      * underrun during the first iterations much
1139                      * quicker then we calculate here, probably due to
1140                      * the transport latency. To accomodate for that
1141                      * we artificially decrease the sleep time until
1142                      * we have filled the buffer at least once
1143                      * completely.*/
1144
1145                     /*pa_log_debug("Cutting sleep time for the initial iterations by half.");*/
1146                     sleep_usec /= 2;
1147                 }
1148
1149                 /* OK, the playback buffer is now full, let's
1150                  * calculate when to wake up next */
1151 /*                 pa_log_debug("Waking up in %0.2fms (sound card clock).", (double) sleep_usec / PA_USEC_PER_MSEC); */
1152
1153                 /* Convert from the sound card time domain to the
1154                  * system time domain */
1155                 cusec = pa_smoother_translate(u->smoother, pa_rtclock_usec(), sleep_usec);
1156
1157 /*                 pa_log_debug("Waking up in %0.2fms (system clock).", (double) cusec / PA_USEC_PER_MSEC); */
1158
1159                 /* We don't trust the conversion, so we wake up whatever comes first */
1160                 pa_rtpoll_set_timer_relative(u->rtpoll, PA_MIN(sleep_usec, cusec));
1161             }
1162
1163             u->first = FALSE;
1164             u->after_rewind = FALSE;
1165
1166         } else if (u->use_tsched)
1167
1168             /* OK, we're in an invalid state, let's disable our timers */
1169             pa_rtpoll_set_timer_disabled(u->rtpoll);
1170
1171         /* Hmm, nothing to do. Let's sleep */
1172         if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
1173             goto fail;
1174
1175         if (ret == 0)
1176             goto finish;
1177
1178         /* Tell ALSA about this and process its response */
1179         if (PA_SINK_IS_OPENED(u->sink->thread_info.state)) {
1180             struct pollfd *pollfd;
1181             unsigned short revents = 0;
1182             int err;
1183             unsigned n;
1184
1185             pollfd = pa_rtpoll_item_get_pollfd(u->alsa_rtpoll_item, &n);
1186
1187             if ((err = snd_pcm_poll_descriptors_revents(u->pcm_handle, pollfd, n, &revents)) < 0) {
1188                 pa_log("snd_pcm_poll_descriptors_revents() failed: %s", snd_strerror(err));
1189                 goto fail;
1190             }
1191
1192             if (revents & (POLLERR|POLLNVAL|POLLHUP|POLLPRI)) {
1193                 if (pa_alsa_recover_from_poll(u->pcm_handle, revents) < 0)
1194                     goto fail;
1195
1196                 u->first = TRUE;
1197                 u->since_start = 0;
1198             }
1199
1200             if (revents && u->use_tsched)
1201                 pa_log_debug("Wakeup from ALSA!%s%s", (revents & POLLIN) ? " INPUT" : "", (revents & POLLOUT) ? " OUTPUT" : "");
1202         }
1203     }
1204
1205 fail:
1206     /* If this was no regular exit from the loop we have to continue
1207      * processing messages until we received PA_MESSAGE_SHUTDOWN */
1208     pa_asyncmsgq_post(u->thread_mq.outq, PA_MSGOBJECT(u->core), PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0, NULL, NULL);
1209     pa_asyncmsgq_wait_for(u->thread_mq.inq, PA_MESSAGE_SHUTDOWN);
1210
1211 finish:
1212     pa_log_debug("Thread shutting down");
1213 }
1214
1215 int pa__init(pa_module*m) {
1216
1217     pa_modargs *ma = NULL;
1218     struct userdata *u = NULL;
1219     const char *dev_id;
1220     pa_sample_spec ss;
1221     pa_channel_map map;
1222     uint32_t nfrags, hwbuf_size, frag_size, tsched_size, tsched_watermark;
1223     snd_pcm_uframes_t period_frames, tsched_frames;
1224     size_t frame_size;
1225     snd_pcm_info_t *pcm_info = NULL;
1226     int err;
1227     const char *name;
1228     char *name_buf = NULL;
1229     pa_bool_t namereg_fail;
1230     pa_bool_t use_mmap = TRUE, b, use_tsched = TRUE, d;
1231     pa_usec_t usec;
1232     pa_sink_new_data data;
1233
1234     snd_pcm_info_alloca(&pcm_info);
1235
1236     pa_assert(m);
1237
1238     pa_alsa_redirect_errors_inc();
1239
1240     if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
1241         pa_log("Failed to parse module arguments");
1242         goto fail;
1243     }
1244
1245     ss = m->core->default_sample_spec;
1246     if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_ALSA) < 0) {
1247         pa_log("Failed to parse sample specification and channel map");
1248         goto fail;
1249     }
1250
1251     frame_size = pa_frame_size(&ss);
1252
1253     nfrags = m->core->default_n_fragments;
1254     frag_size = (uint32_t) pa_usec_to_bytes(m->core->default_fragment_size_msec*PA_USEC_PER_MSEC, &ss);
1255     if (frag_size <= 0)
1256         frag_size = (uint32_t) frame_size;
1257     tsched_size = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_BUFFER_USEC, &ss);
1258     tsched_watermark = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_WATERMARK_USEC, &ss);
1259
1260     if (pa_modargs_get_value_u32(ma, "fragments", &nfrags) < 0 ||
1261         pa_modargs_get_value_u32(ma, "fragment_size", &frag_size) < 0 ||
1262         pa_modargs_get_value_u32(ma, "tsched_buffer_size", &tsched_size) < 0 ||
1263         pa_modargs_get_value_u32(ma, "tsched_buffer_watermark", &tsched_watermark) < 0) {
1264         pa_log("Failed to parse buffer metrics");
1265         goto fail;
1266     }
1267
1268     hwbuf_size = frag_size * nfrags;
1269     period_frames = frag_size/frame_size;
1270     tsched_frames = tsched_size/frame_size;
1271
1272     if (pa_modargs_get_value_boolean(ma, "mmap", &use_mmap) < 0) {
1273         pa_log("Failed to parse mmap argument.");
1274         goto fail;
1275     }
1276
1277     if (pa_modargs_get_value_boolean(ma, "tsched", &use_tsched) < 0) {
1278         pa_log("Failed to parse tsched argument.");
1279         goto fail;
1280     }
1281
1282     if (use_tsched && !pa_rtclock_hrtimer()) {
1283         pa_log_notice("Disabling timer-based scheduling because high-resolution timers are not available from the kernel.");
1284         use_tsched = FALSE;
1285     }
1286
1287     u = pa_xnew0(struct userdata, 1);
1288     u->core = m->core;
1289     u->module = m;
1290     m->userdata = u;
1291     u->use_mmap = use_mmap;
1292     u->use_tsched = use_tsched;
1293     u->first = TRUE;
1294     u->since_start = 0;
1295     u->after_rewind = FALSE;
1296     u->rtpoll = pa_rtpoll_new();
1297     pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
1298     u->alsa_rtpoll_item = NULL;
1299
1300     u->smoother = pa_smoother_new(DEFAULT_TSCHED_BUFFER_USEC*2, DEFAULT_TSCHED_BUFFER_USEC*2, TRUE, 5);
1301     usec = pa_rtclock_usec();
1302     pa_smoother_set_time_offset(u->smoother, usec);
1303     pa_smoother_pause(u->smoother, usec);
1304
1305     snd_config_update_free_global();
1306
1307     b = use_mmap;
1308     d = use_tsched;
1309
1310     if ((dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
1311
1312         if (!(u->pcm_handle = pa_alsa_open_by_device_id(
1313                       dev_id,
1314                       &u->device_name,
1315                       &ss, &map,
1316                       SND_PCM_STREAM_PLAYBACK,
1317                       &nfrags, &period_frames, tsched_frames,
1318                       &b, &d)))
1319
1320             goto fail;
1321
1322     } else {
1323
1324         if (!(u->pcm_handle = pa_alsa_open_by_device_string(
1325                       pa_modargs_get_value(ma, "device", DEFAULT_DEVICE),
1326                       &u->device_name,
1327                       &ss, &map,
1328                       SND_PCM_STREAM_PLAYBACK,
1329                       &nfrags, &period_frames, tsched_frames,
1330                       &b, &d)))
1331             goto fail;
1332
1333     }
1334
1335     pa_assert(u->device_name);
1336     pa_log_info("Successfully opened device %s.", u->device_name);
1337
1338     if (use_mmap && !b) {
1339         pa_log_info("Device doesn't support mmap(), falling back to UNIX read/write mode.");
1340         u->use_mmap = use_mmap = FALSE;
1341     }
1342
1343     if (use_tsched && (!b || !d)) {
1344         pa_log_info("Cannot enabled timer-based scheduling, falling back to sound IRQ scheduling.");
1345         u->use_tsched = use_tsched = FALSE;
1346     }
1347
1348     if (u->use_mmap)
1349         pa_log_info("Successfully enabled mmap() mode.");
1350
1351     if (u->use_tsched)
1352         pa_log_info("Successfully enabled timer-based scheduling mode.");
1353
1354     if ((err = snd_pcm_info(u->pcm_handle, pcm_info)) < 0) {
1355         pa_log("Error fetching PCM info: %s", snd_strerror(err));
1356         goto fail;
1357     }
1358
1359     /* ALSA might tweak the sample spec, so recalculate the frame size */
1360     frame_size = pa_frame_size(&ss);
1361
1362     if ((err = snd_mixer_open(&u->mixer_handle, 0)) < 0)
1363         pa_log_warn("Error opening mixer: %s", snd_strerror(err));
1364     else {
1365         pa_bool_t found = FALSE;
1366
1367         if (pa_alsa_prepare_mixer(u->mixer_handle, u->device_name) >= 0)
1368             found = TRUE;
1369         else {
1370             snd_pcm_info_t *info;
1371
1372             snd_pcm_info_alloca(&info);
1373
1374             if (snd_pcm_info(u->pcm_handle, info) >= 0) {
1375                 char *md;
1376                 int card;
1377
1378                 if ((card = snd_pcm_info_get_card(info)) >= 0) {
1379
1380                     md = pa_sprintf_malloc("hw:%i", card);
1381
1382                     if (strcmp(u->device_name, md))
1383                         if (pa_alsa_prepare_mixer(u->mixer_handle, md) >= 0)
1384                             found = TRUE;
1385                     pa_xfree(md);
1386                 }
1387             }
1388         }
1389
1390         if (found)
1391             if (!(u->mixer_elem = pa_alsa_find_elem(u->mixer_handle, "Master", "PCM")))
1392                 found = FALSE;
1393
1394         if (!found) {
1395             snd_mixer_close(u->mixer_handle);
1396             u->mixer_handle = NULL;
1397         }
1398     }
1399
1400     if ((name = pa_modargs_get_value(ma, "sink_name", NULL)))
1401         namereg_fail = TRUE;
1402     else {
1403         name = name_buf = pa_sprintf_malloc("alsa_output.%s", u->device_name);
1404         namereg_fail = FALSE;
1405     }
1406
1407     pa_sink_new_data_init(&data);
1408     data.driver = __FILE__;
1409     data.module = m;
1410     pa_sink_new_data_set_name(&data, name);
1411     data.namereg_fail = namereg_fail;
1412     pa_sink_new_data_set_sample_spec(&data, &ss);
1413     pa_sink_new_data_set_channel_map(&data, &map);
1414
1415     pa_alsa_init_proplist(data.proplist, pcm_info);
1416     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, u->device_name);
1417     pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_BUFFER_SIZE, "%lu", (unsigned long) (period_frames * frame_size * nfrags));
1418     pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZE, "%lu", (unsigned long) (period_frames * frame_size));
1419     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_ACCESS_MODE, u->use_tsched ? "mmap+timer" : (u->use_mmap ? "mmap" : "serial"));
1420
1421     u->sink = pa_sink_new(m->core, &data, PA_SINK_HARDWARE|PA_SINK_LATENCY);
1422     pa_sink_new_data_done(&data);
1423     pa_xfree(name_buf);
1424
1425     if (!u->sink) {
1426         pa_log("Failed to create sink object");
1427         goto fail;
1428     }
1429
1430     u->sink->parent.process_msg = sink_process_msg;
1431     u->sink->update_requested_latency = sink_update_requested_latency_cb;
1432     u->sink->userdata = u;
1433
1434     pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
1435     pa_sink_set_rtpoll(u->sink, u->rtpoll);
1436
1437     u->frame_size = frame_size;
1438     u->fragment_size = frag_size = (uint32_t) (period_frames * frame_size);
1439     u->nfragments = nfrags;
1440     u->hwbuf_size = u->fragment_size * nfrags;
1441     u->hwbuf_unused_frames = 0;
1442     u->tsched_watermark = tsched_watermark;
1443     u->frame_index = 0;
1444     u->hw_dB_supported = FALSE;
1445     u->hw_dB_min = u->hw_dB_max = 0;
1446     u->hw_volume_min = u->hw_volume_max = 0;
1447     u->mixer_seperate_channels = FALSE;
1448     pa_cvolume_mute(&u->hardware_volume, u->sink->sample_spec.channels);
1449
1450     if (use_tsched)
1451         fix_tsched_watermark(u);
1452
1453     u->sink->thread_info.max_rewind = use_tsched ? u->hwbuf_size : 0;
1454     u->sink->thread_info.max_request = u->hwbuf_size;
1455
1456     pa_sink_set_latency_range(u->sink,
1457                               !use_tsched ? pa_bytes_to_usec(u->hwbuf_size, &ss) : (pa_usec_t) -1,
1458                               pa_bytes_to_usec(u->hwbuf_size, &ss));
1459
1460     pa_log_info("Using %u fragments of size %lu bytes, buffer time is %0.2fms",
1461                 nfrags, (long unsigned) u->fragment_size,
1462                 (double) pa_bytes_to_usec(u->hwbuf_size, &ss) / PA_USEC_PER_MSEC);
1463
1464     if (use_tsched)
1465         pa_log_info("Time scheduling watermark is %0.2fms",
1466                     (double) pa_bytes_to_usec(u->tsched_watermark, &ss) / PA_USEC_PER_MSEC);
1467
1468     if (update_sw_params(u) < 0)
1469         goto fail;
1470
1471     pa_memchunk_reset(&u->memchunk);
1472
1473     if (u->mixer_handle) {
1474         pa_assert(u->mixer_elem);
1475
1476         if (snd_mixer_selem_has_playback_volume(u->mixer_elem)) {
1477             pa_bool_t suitable = TRUE;
1478
1479             if (snd_mixer_selem_get_playback_volume_range(u->mixer_elem, &u->hw_volume_min, &u->hw_volume_max) < 0) {
1480                 pa_log_info("Failed to get volume range. Falling back to software volume control.");
1481                 suitable = FALSE;
1482             } else {
1483                 pa_log_info("Volume ranges from %li to %li.", u->hw_volume_min, u->hw_volume_max);
1484                 pa_assert(u->hw_volume_min < u->hw_volume_max);
1485             }
1486
1487             if (snd_mixer_selem_get_playback_dB_range(u->mixer_elem, &u->hw_dB_min, &u->hw_dB_max) < 0)
1488                 pa_log_info("Mixer doesn't support dB information.");
1489             else {
1490 #ifdef HAVE_VALGRIND_MEMCHECK_H
1491                 VALGRIND_MAKE_MEM_DEFINED(&u->hw_dB_min, sizeof(u->hw_dB_min));
1492                 VALGRIND_MAKE_MEM_DEFINED(&u->hw_dB_max, sizeof(u->hw_dB_max));
1493 #endif
1494
1495                 pa_log_info("Volume ranges from %0.2f dB to %0.2f dB.", (double) u->hw_dB_min/100.0, (double) u->hw_dB_max/100.0);
1496                 pa_assert(u->hw_dB_min < u->hw_dB_max);
1497                 u->hw_dB_supported = TRUE;
1498             }
1499
1500             if (suitable &&
1501                 !u->hw_dB_supported &&
1502                 u->hw_volume_max - u->hw_volume_min < 3) {
1503
1504                 pa_log_info("Device doesn't do dB volume and has less than 4 volume levels. Falling back to software volume control.");
1505                 suitable = FALSE;
1506             }
1507
1508             if (suitable) {
1509                 u->mixer_seperate_channels = pa_alsa_calc_mixer_map(u->mixer_elem, &map, u->mixer_map, TRUE) >= 0;
1510
1511                 u->sink->get_volume = sink_get_volume_cb;
1512                 u->sink->set_volume = sink_set_volume_cb;
1513                 u->sink->flags |= PA_SINK_HW_VOLUME_CTRL | (u->hw_dB_supported ? PA_SINK_DECIBEL_VOLUME : 0);
1514                 pa_log_info("Using hardware volume control. Hardware dB scale %s.", u->hw_dB_supported ? "supported" : "not supported");
1515
1516             } else
1517                 pa_log_info("Using software volume control.");
1518         }
1519
1520         if (snd_mixer_selem_has_playback_switch(u->mixer_elem)) {
1521             u->sink->get_mute = sink_get_mute_cb;
1522             u->sink->set_mute = sink_set_mute_cb;
1523             u->sink->flags |= PA_SINK_HW_MUTE_CTRL;
1524         } else
1525             pa_log_info("Using software mute control.");
1526
1527         u->mixer_fdl = pa_alsa_fdlist_new();
1528
1529         if (pa_alsa_fdlist_set_mixer(u->mixer_fdl, u->mixer_handle, m->core->mainloop) < 0) {
1530             pa_log("Failed to initialize file descriptor monitoring");
1531             goto fail;
1532         }
1533
1534         snd_mixer_elem_set_callback(u->mixer_elem, mixer_callback);
1535         snd_mixer_elem_set_callback_private(u->mixer_elem, u);
1536     } else
1537         u->mixer_fdl = NULL;
1538
1539     pa_alsa_dump(u->pcm_handle);
1540
1541     if (!(u->thread = pa_thread_new(thread_func, u))) {
1542         pa_log("Failed to create thread.");
1543         goto fail;
1544     }
1545
1546     /* Get initial mixer settings */
1547     if (data.volume_is_set) {
1548         if (u->sink->set_volume)
1549             u->sink->set_volume(u->sink);
1550     } else {
1551         if (u->sink->get_volume)
1552             u->sink->get_volume(u->sink);
1553     }
1554
1555     if (data.muted_is_set) {
1556         if (u->sink->set_mute)
1557             u->sink->set_mute(u->sink);
1558     } else {
1559         if (u->sink->get_mute)
1560             u->sink->get_mute(u->sink);
1561     }
1562
1563     pa_sink_put(u->sink);
1564
1565     pa_modargs_free(ma);
1566
1567     return 0;
1568
1569 fail:
1570
1571     if (ma)
1572         pa_modargs_free(ma);
1573
1574     pa__done(m);
1575
1576     return -1;
1577 }
1578
1579 void pa__done(pa_module*m) {
1580     struct userdata *u;
1581
1582     pa_assert(m);
1583
1584     if (!(u = m->userdata)) {
1585         pa_alsa_redirect_errors_dec();
1586         return;
1587     }
1588
1589     if (u->sink)
1590         pa_sink_unlink(u->sink);
1591
1592     if (u->thread) {
1593         pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
1594         pa_thread_free(u->thread);
1595     }
1596
1597     pa_thread_mq_done(&u->thread_mq);
1598
1599     if (u->sink)
1600         pa_sink_unref(u->sink);
1601
1602     if (u->memchunk.memblock)
1603         pa_memblock_unref(u->memchunk.memblock);
1604
1605     if (u->alsa_rtpoll_item)
1606         pa_rtpoll_item_free(u->alsa_rtpoll_item);
1607
1608     if (u->rtpoll)
1609         pa_rtpoll_free(u->rtpoll);
1610
1611     if (u->mixer_fdl)
1612         pa_alsa_fdlist_free(u->mixer_fdl);
1613
1614     if (u->mixer_handle)
1615         snd_mixer_close(u->mixer_handle);
1616
1617     if (u->pcm_handle) {
1618         snd_pcm_drop(u->pcm_handle);
1619         snd_pcm_close(u->pcm_handle);
1620     }
1621
1622     if (u->smoother)
1623         pa_smoother_free(u->smoother);
1624
1625     pa_xfree(u->device_name);
1626     pa_xfree(u);
1627
1628     snd_config_update_free_global();
1629
1630     pa_alsa_redirect_errors_dec();
1631 }