code.delx.au - pulseaudio/blob - src/modules/oss/module-oss.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2004-2006 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 /* General power management rules:
  24  *
  25  *   When SUSPENDED we close the audio device.
  26  *
  27  *   We make no difference between IDLE and RUNNING in our handling.
  28  *
  29  *   As long as we are in RUNNING/IDLE state we will *always* write data to
  30  *   the device. If none is avilable from the inputs, we write silence
  31  *   instead.
  32  *
  33  *   If power should be saved on IDLE module-suspend-on-idle should be used.
  34  *
  35  */
  36
  37 #ifdef HAVE_CONFIG_H
  38 #include <config.h>
  39 #endif
  40
  41 #ifdef HAVE_SYS_MMAN_H
  42 #include <sys/mman.h>
  43 #endif
  44
  45 #include <sys/soundcard.h>
  46 #include <sys/ioctl.h>
  47 #include <stdlib.h>
  48 #include <sys/stat.h>
  49 #include <stdio.h>
  50 #include <errno.h>
  51 #include <string.h>
  52 #include <fcntl.h>
  53 #include <unistd.h>
  54 #include <limits.h>
  55 #include <signal.h>
  56 #include <poll.h>
  57
  58 #include <pulse/xmalloc.h>
  59 #include <pulse/util.h>
  60
  61 #include <pulsecore/core-error.h>
  62 #include <pulsecore/thread.h>
  63 #include <pulsecore/sink.h>
  64 #include <pulsecore/source.h>
  65 #include <pulsecore/module.h>
  66 #include <pulsecore/sample-util.h>
  67 #include <pulsecore/core-util.h>
  68 #include <pulsecore/modargs.h>
  69 #include <pulsecore/log.h>
  70 #include <pulsecore/macro.h>
  71 #include <pulsecore/thread-mq.h>
  72 #include <pulsecore/rtpoll.h>
  73
  74 #if defined(__NetBSD__) && !defined(SNDCTL_DSP_GETODELAY)
  75 #include <sys/audioio.h>
  76 #include <sys/syscall.h>
  77 #endif
  78
  79 #include "oss-util.h"
  80 #include "module-oss-symdef.h"
  81
  82 PA_MODULE_AUTHOR("Lennart Poettering");
  83 PA_MODULE_DESCRIPTION("OSS Sink/Source");
  84 PA_MODULE_VERSION(PACKAGE_VERSION);
  85 PA_MODULE_LOAD_ONCE(FALSE);
  86 PA_MODULE_USAGE(
  87         "sink_name=<name for the sink> "
  88         "source_name=<name for the source> "
  89         "device=<OSS device> "
  90         "record=<enable source?> "
  91         "playback=<enable sink?> "
  92         "format=<sample format> "
  93         "channels=<number of channels> "
  94         "rate=<sample rate> "
  95         "fragments=<number of fragments> "
  96         "fragment_size=<fragment size> "
  97         "channel_map=<channel map> "
  98         "mmap=<enable memory mapping?>");
  99
 100 #define DEFAULT_DEVICE "/dev/dsp"
 101
 102 struct userdata {
 103     pa_core *core;
 104     pa_module *module;
 105     pa_sink *sink;
 106     pa_source *source;
 107
 108     pa_thread *thread;
 109     pa_thread_mq thread_mq;
 110     pa_rtpoll *rtpoll;
 111
 112     char *device_name;
 113
 114     pa_memchunk memchunk;
 115
 116     size_t frame_size;
 117     uint32_t in_fragment_size, out_fragment_size, in_nfrags, out_nfrags, in_hwbuf_size, out_hwbuf_size;
 118     pa_bool_t use_getospace, use_getispace;
 119     pa_bool_t use_getodelay;
 120
 121     pa_bool_t sink_suspended, source_suspended;
 122
 123     int fd;
 124     int mode;
 125
 126     int mixer_fd;
 127     int mixer_devmask;
 128
 129     int nfrags, frag_size, orig_frag_size;
 130
 131     pa_bool_t use_mmap;
 132     unsigned out_mmap_current, in_mmap_current;
 133     void *in_mmap, *out_mmap;
 134     pa_memblock **in_mmap_memblocks, **out_mmap_memblocks;
 135
 136     int in_mmap_saved_nfrags, out_mmap_saved_nfrags;
 137
 138     pa_rtpoll_item *rtpoll_item;
 139 };
 140
 141 static const char* const valid_modargs[] = {
 142     "sink_name",
 143     "source_name",
 144     "device",
 145     "record",
 146     "playback",
 147     "fragments",
 148     "fragment_size",
 149     "format",
 150     "rate",
 151     "channels",
 152     "channel_map",
 153     "mmap",
 154     NULL
 155 };
 156
 157 static void trigger(struct userdata *u, pa_bool_t quick) {
 158     int enable_bits = 0, zero = 0;
 159
 160     pa_assert(u);
 161
 162     if (u->fd < 0)
 163         return;
 164
 165      pa_log_debug("trigger");
 166
 167     if (u->source && PA_SOURCE_IS_OPENED(u->source->thread_info.state))
 168         enable_bits |= PCM_ENABLE_INPUT;
 169
 170     if (u->sink && PA_SINK_IS_OPENED(u->sink->thread_info.state))
 171         enable_bits |= PCM_ENABLE_OUTPUT;
 172
 173     pa_log_debug("trigger: %i", enable_bits);
 174
 175
 176     if (u->use_mmap) {
 177
 178         if (!quick)
 179             ioctl(u->fd, SNDCTL_DSP_SETTRIGGER, &zero);
 180
 181 #ifdef SNDCTL_DSP_HALT
 182         if (enable_bits == 0)
 183             if (ioctl(u->fd, SNDCTL_DSP_HALT, NULL) < 0)
 184                 pa_log_warn("SNDCTL_DSP_HALT: %s", pa_cstrerror(errno));
 185 #endif
 186
 187         if (ioctl(u->fd, SNDCTL_DSP_SETTRIGGER, &enable_bits) < 0)
 188             pa_log_warn("SNDCTL_DSP_SETTRIGGER: %s", pa_cstrerror(errno));
 189
 190         if (u->sink && !(enable_bits & PCM_ENABLE_OUTPUT)) {
 191             pa_log_debug("clearing playback buffer");
 192             pa_silence_memory(u->out_mmap, u->out_hwbuf_size, &u->sink->sample_spec);
 193         }
 194
 195     } else {
 196
 197         if (enable_bits)
 198             if (ioctl(u->fd, SNDCTL_DSP_POST, NULL) < 0)
 199                 pa_log_warn("SNDCTL_DSP_POST: %s", pa_cstrerror(errno));
 200
 201         if (!quick) {
 202             /*
 203              * Some crappy drivers do not start the recording until we
 204              * read something.  Without this snippet, poll will never
 205              * register the fd as ready.
 206              */
 207
 208             if (u->source && PA_SOURCE_IS_OPENED(u->source->thread_info.state)) {
 209                 uint8_t *buf = pa_xnew(uint8_t, u->in_fragment_size);
 210                 pa_read(u->fd, buf, u->in_fragment_size, NULL);
 211                 pa_xfree(buf);
 212             }
 213         }
 214     }
 215 }
 216
 217 static void mmap_fill_memblocks(struct userdata *u, unsigned n) {
 218     pa_assert(u);
 219     pa_assert(u->out_mmap_memblocks);
 220
 221 /*     pa_log("Mmmap writing %u blocks", n); */
 222
 223     while (n > 0) {
 224         pa_memchunk chunk;
 225
 226         if (u->out_mmap_memblocks[u->out_mmap_current])
 227             pa_memblock_unref_fixed(u->out_mmap_memblocks[u->out_mmap_current]);
 228
 229         chunk.memblock = u->out_mmap_memblocks[u->out_mmap_current] =
 230             pa_memblock_new_fixed(
 231                     u->core->mempool,
 232                     (uint8_t*) u->out_mmap + u->out_fragment_size * u->out_mmap_current,
 233                     u->out_fragment_size,
 234                     1);
 235
 236         chunk.length = pa_memblock_get_length(chunk.memblock);
 237         chunk.index = 0;
 238
 239         pa_sink_render_into_full(u->sink, &chunk);
 240
 241         u->out_mmap_current++;
 242         while (u->out_mmap_current >= u->out_nfrags)
 243             u->out_mmap_current -= u->out_nfrags;
 244
 245         n--;
 246     }
 247 }
 248
 249 static int mmap_write(struct userdata *u) {
 250     struct count_info info;
 251
 252     pa_assert(u);
 253     pa_assert(u->sink);
 254
 255 /*     pa_log("Mmmap writing..."); */
 256
 257     if (ioctl(u->fd, SNDCTL_DSP_GETOPTR, &info) < 0) {
 258         pa_log("SNDCTL_DSP_GETOPTR: %s", pa_cstrerror(errno));
 259         return -1;
 260     }
 261
 262     info.blocks += u->out_mmap_saved_nfrags;
 263     u->out_mmap_saved_nfrags = 0;
 264
 265     if (info.blocks > 0)
 266         mmap_fill_memblocks(u, (unsigned) info.blocks);
 267
 268     return info.blocks;
 269 }
 270
 271 static void mmap_post_memblocks(struct userdata *u, unsigned n) {
 272     pa_assert(u);
 273     pa_assert(u->in_mmap_memblocks);
 274
 275 /*     pa_log("Mmmap reading %u blocks", n); */
 276
 277     while (n > 0) {
 278         pa_memchunk chunk;
 279
 280         if (!u->in_mmap_memblocks[u->in_mmap_current]) {
 281
 282             chunk.memblock = u->in_mmap_memblocks[u->in_mmap_current] =
 283                 pa_memblock_new_fixed(
 284                         u->core->mempool,
 285                         (uint8_t*) u->in_mmap + u->in_fragment_size*u->in_mmap_current,
 286                         u->in_fragment_size,
 287                         1);
 288
 289             chunk.length = pa_memblock_get_length(chunk.memblock);
 290             chunk.index = 0;
 291
 292             pa_source_post(u->source, &chunk);
 293         }
 294
 295         u->in_mmap_current++;
 296         while (u->in_mmap_current >= u->in_nfrags)
 297             u->in_mmap_current -= u->in_nfrags;
 298
 299         n--;
 300     }
 301 }
 302
 303 static void mmap_clear_memblocks(struct userdata*u, unsigned n) {
 304     unsigned i = u->in_mmap_current;
 305
 306     pa_assert(u);
 307     pa_assert(u->in_mmap_memblocks);
 308
 309     if (n > u->in_nfrags)
 310         n = u->in_nfrags;
 311
 312     while (n > 0) {
 313         if (u->in_mmap_memblocks[i]) {
 314             pa_memblock_unref_fixed(u->in_mmap_memblocks[i]);
 315             u->in_mmap_memblocks[i] = NULL;
 316         }
 317
 318         i++;
 319         while (i >= u->in_nfrags)
 320             i -= u->in_nfrags;
 321
 322         n--;
 323     }
 324 }
 325
 326 static int mmap_read(struct userdata *u) {
 327     struct count_info info;
 328     pa_assert(u);
 329     pa_assert(u->source);
 330
 331 /*     pa_log("Mmmap reading..."); */
 332
 333     if (ioctl(u->fd, SNDCTL_DSP_GETIPTR, &info) < 0) {
 334         pa_log("SNDCTL_DSP_GETIPTR: %s", pa_cstrerror(errno));
 335         return -1;
 336     }
 337
 338 /*     pa_log("... %i", info.blocks); */
 339
 340     info.blocks += u->in_mmap_saved_nfrags;
 341     u->in_mmap_saved_nfrags = 0;
 342
 343     if (info.blocks > 0) {
 344         mmap_post_memblocks(u, (unsigned) info.blocks);
 345         mmap_clear_memblocks(u, u->in_nfrags/2);
 346     }
 347
 348     return info.blocks;
 349 }
 350
 351 static pa_usec_t mmap_sink_get_latency(struct userdata *u) {
 352     struct count_info info;
 353     size_t bpos, n;
 354
 355     pa_assert(u);
 356
 357     if (ioctl(u->fd, SNDCTL_DSP_GETOPTR, &info) < 0) {
 358         pa_log("SNDCTL_DSP_GETOPTR: %s", pa_cstrerror(errno));
 359         return 0;
 360     }
 361
 362     u->out_mmap_saved_nfrags += info.blocks;
 363
 364     bpos = ((u->out_mmap_current + (unsigned) u->out_mmap_saved_nfrags) * u->out_fragment_size) % u->out_hwbuf_size;
 365
 366     if (bpos <= (size_t) info.ptr)
 367         n = u->out_hwbuf_size - ((size_t) info.ptr - bpos);
 368     else
 369         n = bpos - (size_t) info.ptr;
 370
 371 /*     pa_log("n = %u, bpos = %u, ptr = %u, total=%u, fragsize = %u, n_frags = %u\n", n, bpos, (unsigned) info.ptr, total, u->out_fragment_size, u->out_fragments); */
 372
 373     return pa_bytes_to_usec(n, &u->sink->sample_spec);
 374 }
 375
 376 static pa_usec_t mmap_source_get_latency(struct userdata *u) {
 377     struct count_info info;
 378     size_t bpos, n;
 379
 380     pa_assert(u);
 381
 382     if (ioctl(u->fd, SNDCTL_DSP_GETIPTR, &info) < 0) {
 383         pa_log("SNDCTL_DSP_GETIPTR: %s", pa_cstrerror(errno));
 384         return 0;
 385     }
 386
 387     u->in_mmap_saved_nfrags += info.blocks;
 388     bpos = ((u->in_mmap_current + (unsigned) u->in_mmap_saved_nfrags) * u->in_fragment_size) % u->in_hwbuf_size;
 389
 390     if (bpos <= (size_t) info.ptr)
 391         n = (size_t) info.ptr - bpos;
 392     else
 393         n = u->in_hwbuf_size - bpos + (size_t) info.ptr;
 394
 395 /*     pa_log("n = %u, bpos = %u, ptr = %u, total=%u, fragsize = %u, n_frags = %u\n", n, bpos, (unsigned) info.ptr, total, u->in_fragment_size, u->in_fragments);  */
 396
 397     return pa_bytes_to_usec(n, &u->source->sample_spec);
 398 }
 399
 400 static pa_usec_t io_sink_get_latency(struct userdata *u) {
 401     pa_usec_t r = 0;
 402
 403     pa_assert(u);
 404
 405     if (u->use_getodelay) {
 406         int arg;
 407 #if defined(__NetBSD__) && !defined(SNDCTL_DSP_GETODELAY)
 408 #if defined(AUDIO_GETBUFINFO)
 409         struct audio_info info;
 410         if (syscall(SYS_ioctl, u->fd, AUDIO_GETBUFINFO, &info) < 0) {
 411             pa_log_info("Device doesn't support AUDIO_GETBUFINFO: %s", pa_cstrerror(errno));
 412             u->use_getodelay = 0;
 413         } else {
 414             arg = info.play.seek + info.blocksize / 2;
 415             r = pa_bytes_to_usec((size_t) arg, &u->sink->sample_spec);
 416         }
 417 #else
 418         pa_log_info("System doesn't support AUDIO_GETBUFINFO");
 419         u->use_getodelay = 0;
 420 #endif
 421 #else
 422         if (ioctl(u->fd, SNDCTL_DSP_GETODELAY, &arg) < 0) {
 423             pa_log_info("Device doesn't support SNDCTL_DSP_GETODELAY: %s", pa_cstrerror(errno));
 424             u->use_getodelay = 0;
 425         } else
 426             r = pa_bytes_to_usec((size_t) arg, &u->sink->sample_spec);
 427 #endif
 428     }
 429
 430     if (!u->use_getodelay && u->use_getospace) {
 431         struct audio_buf_info info;
 432
 433         if (ioctl(u->fd, SNDCTL_DSP_GETOSPACE, &info) < 0) {
 434             pa_log_info("Device doesn't support SNDCTL_DSP_GETOSPACE: %s", pa_cstrerror(errno));
 435             u->use_getospace = 0;
 436         } else
 437             r = pa_bytes_to_usec((size_t) info.bytes, &u->sink->sample_spec);
 438     }
 439
 440     if (u->memchunk.memblock)
 441         r += pa_bytes_to_usec(u->memchunk.length, &u->sink->sample_spec);
 442
 443     return r;
 444 }
 445
 446 static pa_usec_t io_source_get_latency(struct userdata *u) {
 447     pa_usec_t r = 0;
 448
 449     pa_assert(u);
 450
 451     if (u->use_getispace) {
 452         struct audio_buf_info info;
 453
 454         if (ioctl(u->fd, SNDCTL_DSP_GETISPACE, &info) < 0) {
 455             pa_log_info("Device doesn't support SNDCTL_DSP_GETISPACE: %s", pa_cstrerror(errno));
 456             u->use_getispace = 0;
 457         } else
 458             r = pa_bytes_to_usec((size_t) info.bytes, &u->source->sample_spec);
 459     }
 460
 461     return r;
 462 }
 463
 464 static void build_pollfd(struct userdata *u) {
 465     struct pollfd *pollfd;
 466
 467     pa_assert(u);
 468     pa_assert(u->fd >= 0);
 469
 470     if (u->rtpoll_item)
 471         pa_rtpoll_item_free(u->rtpoll_item);
 472
 473     u->rtpoll_item = pa_rtpoll_item_new(u->rtpoll, PA_RTPOLL_NEVER, 1);
 474     pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL);
 475     pollfd->fd = u->fd;
 476     pollfd->events = 0;
 477     pollfd->revents = 0;
 478 }
 479
 480 static int suspend(struct userdata *u) {
 481     pa_assert(u);
 482     pa_assert(u->fd >= 0);
 483
 484     pa_log_info("Suspending...");
 485
 486     if (u->out_mmap_memblocks) {
 487         unsigned i;
 488         for (i = 0; i < u->out_nfrags; i++)
 489             if (u->out_mmap_memblocks[i]) {
 490                 pa_memblock_unref_fixed(u->out_mmap_memblocks[i]);
 491                 u->out_mmap_memblocks[i] = NULL;
 492             }
 493     }
 494
 495     if (u->in_mmap_memblocks) {
 496         unsigned i;
 497         for (i = 0; i < u->in_nfrags; i++)
 498             if (u->in_mmap_memblocks[i]) {
 499                 pa_memblock_unref_fixed(u->in_mmap_memblocks[i]);
 500                 u->in_mmap_memblocks[i] = NULL;
 501             }
 502     }
 503
 504     if (u->in_mmap && u->in_mmap != MAP_FAILED) {
 505         munmap(u->in_mmap, u->in_hwbuf_size);
 506         u->in_mmap = NULL;
 507     }
 508
 509     if (u->out_mmap && u->out_mmap != MAP_FAILED) {
 510         munmap(u->out_mmap, u->out_hwbuf_size);
 511         u->out_mmap = NULL;
 512     }
 513
 514     /* Let's suspend */
 515     ioctl(u->fd, SNDCTL_DSP_SYNC, NULL);
 516     pa_close(u->fd);
 517     u->fd = -1;
 518
 519     if (u->rtpoll_item) {
 520         pa_rtpoll_item_free(u->rtpoll_item);
 521         u->rtpoll_item = NULL;
 522     }
 523
 524     pa_log_info("Device suspended...");
 525
 526     return 0;
 527 }
 528
 529 static int unsuspend(struct userdata *u) {
 530     int m;
 531     pa_sample_spec ss, *ss_original;
 532     int frag_size, in_frag_size, out_frag_size;
 533     int in_nfrags, out_nfrags;
 534     struct audio_buf_info info;
 535
 536     pa_assert(u);
 537     pa_assert(u->fd < 0);
 538
 539     m = u->mode;
 540
 541     pa_log_info("Trying resume...");
 542
 543     if ((u->fd = pa_oss_open(u->device_name, &m, NULL)) < 0) {
 544         pa_log_warn("Resume failed, device busy (%s)", pa_cstrerror(errno));
 545         return -1;
 546     }
 547
 548     if (m != u->mode) {
 549         pa_log_warn("Resume failed, couldn't open device with original access mode.");
 550         goto fail;
 551     }
 552
 553     if (u->nfrags >= 2 && u->frag_size >= 1)
 554         if (pa_oss_set_fragments(u->fd, u->nfrags, u->orig_frag_size) < 0) {
 555             pa_log_warn("Resume failed, couldn't set original fragment settings.");
 556             goto fail;
 557         }
 558
 559     ss = *(ss_original = u->sink ? &u->sink->sample_spec : &u->source->sample_spec);
 560     if (pa_oss_auto_format(u->fd, &ss) < 0 || !pa_sample_spec_equal(&ss, ss_original)) {
 561         pa_log_warn("Resume failed, couldn't set original sample format settings.");
 562         goto fail;
 563     }
 564
 565     if (ioctl(u->fd, SNDCTL_DSP_GETBLKSIZE, &frag_size) < 0) {
 566         pa_log_warn("SNDCTL_DSP_GETBLKSIZE: %s", pa_cstrerror(errno));
 567         goto fail;
 568     }
 569
 570     in_frag_size = out_frag_size = frag_size;
 571     in_nfrags = out_nfrags = u->nfrags;
 572
 573     if (ioctl(u->fd, SNDCTL_DSP_GETISPACE, &info) >= 0) {
 574         in_frag_size = info.fragsize;
 575         in_nfrags = info.fragstotal;
 576     }
 577
 578     if (ioctl(u->fd, SNDCTL_DSP_GETOSPACE, &info) >= 0) {
 579         out_frag_size = info.fragsize;
 580         out_nfrags = info.fragstotal;
 581     }
 582
 583     if ((u->source && (in_frag_size != (int) u->in_fragment_size || in_nfrags != (int) u->in_nfrags)) ||
 584         (u->sink && (out_frag_size != (int) u->out_fragment_size || out_nfrags != (int) u->out_nfrags))) {
 585         pa_log_warn("Resume failed, input fragment settings don't match.");
 586         goto fail;
 587     }
 588
 589     if (u->use_mmap) {
 590         if (u->source) {
 591             if ((u->in_mmap = mmap(NULL, u->in_hwbuf_size, PROT_READ, MAP_SHARED, u->fd, 0)) == MAP_FAILED) {
 592                 pa_log("Resume failed, mmap(): %s", pa_cstrerror(errno));
 593                 goto fail;
 594             }
 595         }
 596
 597         if (u->sink) {
 598             if ((u->out_mmap = mmap(NULL, u->out_hwbuf_size, PROT_WRITE, MAP_SHARED, u->fd, 0)) == MAP_FAILED) {
 599                 pa_log("Resume failed, mmap(): %s", pa_cstrerror(errno));
 600                 if (u->in_mmap && u->in_mmap != MAP_FAILED) {
 601                     munmap(u->in_mmap, u->in_hwbuf_size);
 602                     u->in_mmap = NULL;
 603                 }
 604
 605                 goto fail;
 606             }
 607
 608             pa_silence_memory(u->out_mmap, u->out_hwbuf_size, &ss);
 609         }
 610     }
 611
 612     u->out_mmap_current = u->in_mmap_current = 0;
 613     u->out_mmap_saved_nfrags = u->in_mmap_saved_nfrags = 0;
 614
 615     pa_assert(!u->rtpoll_item);
 616
 617     build_pollfd(u);
 618
 619     if (u->sink)
 620         pa_sink_get_volume(u->sink, TRUE);
 621     if (u->source)
 622         pa_source_get_volume(u->source, TRUE);
 623
 624     pa_log_info("Resumed successfully...");
 625
 626     return 0;
 627
 628 fail:
 629     pa_close(u->fd);
 630     u->fd = -1;
 631     return -1;
 632 }
 633
 634 static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
 635     struct userdata *u = PA_SINK(o)->userdata;
 636     int ret;
 637     pa_bool_t do_trigger = FALSE, quick = TRUE;
 638
 639     switch (code) {
 640
 641         case PA_SINK_MESSAGE_GET_LATENCY: {
 642             pa_usec_t r = 0;
 643
 644             if (u->fd >= 0) {
 645                 if (u->use_mmap)
 646                     r = mmap_sink_get_latency(u);
 647                 else
 648                     r = io_sink_get_latency(u);
 649             }
 650
 651             *((pa_usec_t*) data) = r;
 652
 653             return 0;
 654         }
 655
 656         case PA_SINK_MESSAGE_SET_STATE:
 657
 658             switch ((pa_sink_state_t) PA_PTR_TO_UINT(data)) {
 659
 660                 case PA_SINK_SUSPENDED:
 661                     pa_assert(PA_SINK_IS_OPENED(u->sink->thread_info.state));
 662
 663                     if (!u->source || u->source_suspended) {
 664                         if (suspend(u) < 0)
 665                             return -1;
 666                     }
 667
 668                     do_trigger = TRUE;
 669
 670                     u->sink_suspended = TRUE;
 671                     break;
 672
 673                 case PA_SINK_IDLE:
 674                 case PA_SINK_RUNNING:
 675
 676                     if (u->sink->thread_info.state == PA_SINK_INIT) {
 677                         do_trigger = TRUE;
 678                         quick = u->source && PA_SOURCE_IS_OPENED(u->source->thread_info.state);
 679                     }
 680
 681                     if (u->sink->thread_info.state == PA_SINK_SUSPENDED) {
 682
 683                         if (!u->source || u->source_suspended) {
 684                             if (unsuspend(u) < 0)
 685                                 return -1;
 686                             quick = FALSE;
 687                         }
 688
 689                         do_trigger = TRUE;
 690
 691                         u->out_mmap_current = 0;
 692                         u->out_mmap_saved_nfrags = 0;
 693
 694                         u->sink_suspended = FALSE;
 695                     }
 696
 697                     break;
 698
 699                 case PA_SINK_INVALID_STATE:
 700                 case PA_SINK_UNLINKED:
 701                 case PA_SINK_INIT:
 702                     ;
 703             }
 704
 705             break;
 706
 707     }
 708
 709     ret = pa_sink_process_msg(o, code, data, offset, chunk);
 710
 711     if (do_trigger)
 712         trigger(u, quick);
 713
 714     return ret;
 715 }
 716
 717 static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
 718     struct userdata *u = PA_SOURCE(o)->userdata;
 719     int ret;
 720     int do_trigger = FALSE, quick = TRUE;
 721
 722     switch (code) {
 723
 724         case PA_SOURCE_MESSAGE_GET_LATENCY: {
 725             pa_usec_t r = 0;
 726
 727             if (u->fd >= 0) {
 728                 if (u->use_mmap)
 729                     r = mmap_source_get_latency(u);
 730                 else
 731                     r = io_source_get_latency(u);
 732             }
 733
 734             *((pa_usec_t*) data) = r;
 735             return 0;
 736         }
 737
 738         case PA_SOURCE_MESSAGE_SET_STATE:
 739
 740             switch ((pa_source_state_t) PA_PTR_TO_UINT(data)) {
 741                 case PA_SOURCE_SUSPENDED:
 742                     pa_assert(PA_SOURCE_IS_OPENED(u->source->thread_info.state));
 743
 744                     if (!u->sink || u->sink_suspended) {
 745                         if (suspend(u) < 0)
 746                             return -1;
 747                     }
 748
 749                     do_trigger = TRUE;
 750
 751                     u->source_suspended = TRUE;
 752                     break;
 753
 754                 case PA_SOURCE_IDLE:
 755                 case PA_SOURCE_RUNNING:
 756
 757                     if (u->source->thread_info.state == PA_SOURCE_INIT) {
 758                         do_trigger = TRUE;
 759                         quick = u->sink && PA_SINK_IS_OPENED(u->sink->thread_info.state);
 760                     }
 761
 762                     if (u->source->thread_info.state == PA_SOURCE_SUSPENDED) {
 763
 764                         if (!u->sink || u->sink_suspended) {
 765                             if (unsuspend(u) < 0)
 766                                 return -1;
 767                             quick = FALSE;
 768                         }
 769
 770                         do_trigger = TRUE;
 771
 772                         u->in_mmap_current = 0;
 773                         u->in_mmap_saved_nfrags = 0;
 774
 775                         u->source_suspended = FALSE;
 776                     }
 777                     break;
 778
 779                 case PA_SOURCE_UNLINKED:
 780                 case PA_SOURCE_INIT:
 781                 case PA_SOURCE_INVALID_STATE:
 782                     ;
 783
 784             }
 785             break;
 786
 787     }
 788
 789     ret = pa_source_process_msg(o, code, data, offset, chunk);
 790
 791     if (do_trigger)
 792         trigger(u, quick);
 793
 794     return ret;
 795 }
 796
 797 static void sink_get_volume(pa_sink *s) {
 798     struct userdata *u;
 799
 800     pa_assert_se(u = s->userdata);
 801
 802     pa_assert(u->mixer_devmask & (SOUND_MASK_VOLUME|SOUND_MASK_PCM));
 803
 804     if (u->mixer_devmask & SOUND_MASK_VOLUME)
 805         if (pa_oss_get_volume(u->mixer_fd, SOUND_MIXER_READ_VOLUME, &s->sample_spec, &s->virtual_volume) >= 0)
 806             return;
 807
 808     if (u->mixer_devmask & SOUND_MASK_PCM)
 809         if (pa_oss_get_volume(u->mixer_fd, SOUND_MIXER_READ_PCM, &s->sample_spec, &s->virtual_volume) >= 0)
 810             return;
 811
 812     pa_log_info("Device doesn't support reading mixer settings: %s", pa_cstrerror(errno));
 813 }
 814
 815 static void sink_set_volume(pa_sink *s) {
 816     struct userdata *u;
 817
 818     pa_assert_se(u = s->userdata);
 819
 820     pa_assert(u->mixer_devmask & (SOUND_MASK_VOLUME|SOUND_MASK_PCM));
 821
 822     if (u->mixer_devmask & SOUND_MASK_VOLUME)
 823         if (pa_oss_set_volume(u->mixer_fd, SOUND_MIXER_WRITE_VOLUME, &s->sample_spec, &s->virtual_volume) >= 0)
 824             return;
 825
 826     if (u->mixer_devmask & SOUND_MASK_PCM)
 827         if (pa_oss_get_volume(u->mixer_fd, SOUND_MIXER_WRITE_PCM, &s->sample_spec, &s->virtual_volume) >= 0)
 828             return;
 829
 830     pa_log_info("Device doesn't support writing mixer settings: %s", pa_cstrerror(errno));
 831 }
 832
 833 static void source_get_volume(pa_source *s) {
 834     struct userdata *u;
 835
 836     pa_assert_se(u = s->userdata);
 837
 838     pa_assert(u->mixer_devmask & (SOUND_MASK_IGAIN|SOUND_MASK_RECLEV));
 839
 840     if (u->mixer_devmask & SOUND_MASK_IGAIN)
 841         if (pa_oss_get_volume(u->mixer_fd, SOUND_MIXER_READ_IGAIN, &s->sample_spec, &s->virtual_volume) >= 0)
 842             return;
 843
 844     if (u->mixer_devmask & SOUND_MASK_RECLEV)
 845         if (pa_oss_get_volume(u->mixer_fd, SOUND_MIXER_READ_RECLEV, &s->sample_spec, &s->virtual_volume) >= 0)
 846             return;
 847
 848     pa_log_info("Device doesn't support reading mixer settings: %s", pa_cstrerror(errno));
 849 }
 850
 851 static void source_set_volume(pa_source *s) {
 852     struct userdata *u;
 853
 854     pa_assert_se(u = s->userdata);
 855
 856     pa_assert(u->mixer_devmask & (SOUND_MASK_IGAIN|SOUND_MASK_RECLEV));
 857
 858     if (u->mixer_devmask & SOUND_MASK_IGAIN)
 859         if (pa_oss_set_volume(u->mixer_fd, SOUND_MIXER_WRITE_IGAIN, &s->sample_spec, &s->virtual_volume) >= 0)
 860             return;
 861
 862     if (u->mixer_devmask & SOUND_MASK_RECLEV)
 863         if (pa_oss_get_volume(u->mixer_fd, SOUND_MIXER_WRITE_RECLEV, &s->sample_spec, &s->virtual_volume) >= 0)
 864             return;
 865
 866     pa_log_info("Device doesn't support writing mixer settings: %s", pa_cstrerror(errno));
 867 }
 868
 869 static void thread_func(void *userdata) {
 870     struct userdata *u = userdata;
 871     int write_type = 0, read_type = 0;
 872     short revents = 0;
 873
 874     pa_assert(u);
 875
 876     pa_log_debug("Thread starting up");
 877
 878     if (u->core->realtime_scheduling)
 879         pa_make_realtime(u->core->realtime_priority);
 880
 881     pa_thread_mq_install(&u->thread_mq);
 882     pa_rtpoll_install(u->rtpoll);
 883
 884     for (;;) {
 885         int ret;
 886
 887 /*        pa_log("loop");    */
 888
 889         if (u->sink && PA_SINK_IS_OPENED(u->sink->thread_info.state))
 890             if (u->sink->thread_info.rewind_requested)
 891                 pa_sink_process_rewind(u->sink, 0);
 892
 893         /* Render some data and write it to the dsp */
 894
 895         if (u->sink && PA_SINK_IS_OPENED(u->sink->thread_info.state) && ((revents & POLLOUT) || u->use_mmap || u->use_getospace)) {
 896
 897             if (u->use_mmap) {
 898
 899                 if ((ret = mmap_write(u)) < 0)
 900                     goto fail;
 901
 902                 revents &= ~POLLOUT;
 903
 904                 if (ret > 0)
 905                     continue;
 906
 907             } else {
 908                 ssize_t l;
 909                 pa_bool_t loop = FALSE, work_done = FALSE;
 910
 911                 l = (ssize_t) u->out_fragment_size;
 912
 913                 if (u->use_getospace) {
 914                     audio_buf_info info;
 915
 916                     if (ioctl(u->fd, SNDCTL_DSP_GETOSPACE, &info) < 0) {
 917                         pa_log_info("Device doesn't support SNDCTL_DSP_GETOSPACE: %s", pa_cstrerror(errno));
 918                         u->use_getospace = FALSE;
 919                     } else {
 920                         l = info.bytes;
 921
 922                         /* We loop only if GETOSPACE worked and we
 923                          * actually *know* that we can write more than
 924                          * one fragment at a time */
 925                         loop = TRUE;
 926                     }
 927                 }
 928
 929                 /* Round down to multiples of the fragment size,
 930                  * because OSS needs that (at least some versions
 931                  * do) */
 932                 l = (l/(ssize_t) u->out_fragment_size) * (ssize_t) u->out_fragment_size;
 933
 934                 /* Hmm, so poll() signalled us that we can read
 935                  * something, but GETOSPACE told us there was nothing?
 936                  * Hmm, make the best of it, try to read some data, to
 937                  * avoid spinning forever. */
 938                 if (l <= 0 && (revents & POLLOUT)) {
 939                     l = (ssize_t) u->out_fragment_size;
 940                     loop = FALSE;
 941                 }
 942
 943                 while (l > 0) {
 944                     void *p;
 945                     ssize_t t;
 946
 947                     if (u->memchunk.length <= 0)
 948                         pa_sink_render(u->sink, (size_t) l, &u->memchunk);
 949
 950                     pa_assert(u->memchunk.length > 0);
 951
 952                     p = pa_memblock_acquire(u->memchunk.memblock);
 953                     t = pa_write(u->fd, (uint8_t*) p + u->memchunk.index, u->memchunk.length, &write_type);
 954                     pa_memblock_release(u->memchunk.memblock);
 955
 956 /*                     pa_log("wrote %i bytes of %u", t, l); */
 957
 958                     pa_assert(t != 0);
 959
 960                     if (t < 0) {
 961
 962                         if (errno == EINTR)
 963                             continue;
 964
 965                         else if (errno == EAGAIN) {
 966                             pa_log_debug("EAGAIN");
 967
 968                             revents &= ~POLLOUT;
 969                             break;
 970
 971                         } else {
 972                             pa_log("Failed to write data to DSP: %s", pa_cstrerror(errno));
 973                             goto fail;
 974                         }
 975
 976                     } else {
 977
 978                         u->memchunk.index += (size_t) t;
 979                         u->memchunk.length -= (size_t) t;
 980
 981                         if (u->memchunk.length <= 0) {
 982                             pa_memblock_unref(u->memchunk.memblock);
 983                             pa_memchunk_reset(&u->memchunk);
 984                         }
 985
 986                         l -= t;
 987
 988                         revents &= ~POLLOUT;
 989                         work_done = TRUE;
 990                     }
 991
 992                     if (!loop)
 993                         break;
 994                 }
 995
 996                 if (work_done)
 997                     continue;
 998             }
 999         }
1000
1001         /* Try to read some data and pass it on to the source driver. */
1002
1003         if (u->source && PA_SOURCE_IS_OPENED(u->source->thread_info.state) && ((revents & POLLIN) || u->use_mmap || u->use_getispace)) {
1004
1005             if (u->use_mmap) {
1006
1007                 if ((ret = mmap_read(u)) < 0)
1008                     goto fail;
1009
1010                 revents &= ~POLLIN;
1011
1012                 if (ret > 0)
1013                     continue;
1014
1015             } else {
1016
1017                 void *p;
1018                 ssize_t l;
1019                 pa_memchunk memchunk;
1020                 pa_bool_t loop = FALSE, work_done = FALSE;
1021
1022                 l = (ssize_t) u->in_fragment_size;
1023
1024                 if (u->use_getispace) {
1025                     audio_buf_info info;
1026
1027                     if (ioctl(u->fd, SNDCTL_DSP_GETISPACE, &info) < 0) {
1028                         pa_log_info("Device doesn't support SNDCTL_DSP_GETISPACE: %s", pa_cstrerror(errno));
1029                         u->use_getispace = FALSE;
1030                     } else {
1031                         l = info.bytes;
1032                         loop = TRUE;
1033                     }
1034                 }
1035
1036                 l = (l/(ssize_t) u->in_fragment_size) * (ssize_t) u->in_fragment_size;
1037
1038                 if (l <= 0 && (revents & POLLIN)) {
1039                     l = (ssize_t) u->in_fragment_size;
1040                     loop = FALSE;
1041                 }
1042
1043                 while (l > 0) {
1044                     ssize_t t;
1045                     size_t k;
1046
1047                     pa_assert(l > 0);
1048
1049                     memchunk.memblock = pa_memblock_new(u->core->mempool, (size_t) -1);
1050
1051                     k = pa_memblock_get_length(memchunk.memblock);
1052
1053                     if (k > (size_t) l)
1054                         k = (size_t) l;
1055
1056                     k = (k/u->frame_size)*u->frame_size;
1057
1058                     p = pa_memblock_acquire(memchunk.memblock);
1059                     t = pa_read(u->fd, p, k, &read_type);
1060                     pa_memblock_release(memchunk.memblock);
1061
1062                     pa_assert(t != 0); /* EOF cannot happen */
1063
1064 /*                     pa_log("read %i bytes of %u", t, l); */
1065
1066                     if (t < 0) {
1067                         pa_memblock_unref(memchunk.memblock);
1068
1069                         if (errno == EINTR)
1070                             continue;
1071
1072                         else if (errno == EAGAIN) {
1073                             pa_log_debug("EAGAIN");
1074
1075                             revents &= ~POLLIN;
1076                             break;
1077
1078                         } else {
1079                             pa_log("Failed to read data from DSP: %s", pa_cstrerror(errno));
1080                             goto fail;
1081                         }
1082
1083                     } else {
1084                         memchunk.index = 0;
1085                         memchunk.length = (size_t) t;
1086
1087                         pa_source_post(u->source, &memchunk);
1088                         pa_memblock_unref(memchunk.memblock);
1089
1090                         l -= t;
1091
1092                         revents &= ~POLLIN;
1093                         work_done = TRUE;
1094                     }
1095
1096                     if (!loop)
1097                         break;
1098                 }
1099
1100                 if (work_done)
1101                     continue;
1102             }
1103         }
1104
1105 /*         pa_log("loop2 revents=%i", revents); */
1106
1107         if (u->rtpoll_item) {
1108             struct pollfd *pollfd;
1109
1110             pa_assert(u->fd >= 0);
1111
1112             pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL);
1113             pollfd->events = (short)
1114                 (((u->source && PA_SOURCE_IS_OPENED(u->source->thread_info.state)) ? POLLIN : 0) |
1115                  ((u->sink && PA_SINK_IS_OPENED(u->sink->thread_info.state)) ? POLLOUT : 0));
1116         }
1117
1118         /* Hmm, nothing to do. Let's sleep */
1119         if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
1120             goto fail;
1121
1122         if (ret == 0)
1123             goto finish;
1124
1125         if (u->rtpoll_item) {
1126             struct pollfd *pollfd;
1127
1128             pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL);
1129
1130             if (pollfd->revents & ~(POLLOUT|POLLIN)) {
1131                 pa_log("DSP shutdown.");
1132                 goto fail;
1133             }
1134
1135             revents = pollfd->revents;
1136         } else
1137             revents = 0;
1138     }
1139
1140 fail:
1141     /* If this was no regular exit from the loop we have to continue
1142      * processing messages until we received PA_MESSAGE_SHUTDOWN */
1143     pa_asyncmsgq_post(u->thread_mq.outq, PA_MSGOBJECT(u->core), PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0, NULL, NULL);
1144     pa_asyncmsgq_wait_for(u->thread_mq.inq, PA_MESSAGE_SHUTDOWN);
1145
1146 finish:
1147     pa_log_debug("Thread shutting down");
1148 }
1149
1150 int pa__init(pa_module*m) {
1151
1152     struct audio_buf_info info;
1153     struct userdata *u = NULL;
1154     const char *dev;
1155     int fd = -1;
1156     int nfrags, orig_frag_size, frag_size;
1157     int mode, caps;
1158     pa_bool_t record = TRUE, playback = TRUE, use_mmap = TRUE;
1159     pa_sample_spec ss;
1160     pa_channel_map map;
1161     pa_modargs *ma = NULL;
1162     char hwdesc[64];
1163     const char *name;
1164     pa_bool_t namereg_fail;
1165     pa_sink_new_data sink_new_data;
1166     pa_source_new_data source_new_data;
1167
1168     pa_assert(m);
1169
1170     if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
1171         pa_log("Failed to parse module arguments.");
1172         goto fail;
1173     }
1174
1175     if (pa_modargs_get_value_boolean(ma, "record", &record) < 0 || pa_modargs_get_value_boolean(ma, "playback", &playback) < 0) {
1176         pa_log("record= and playback= expect boolean argument.");
1177         goto fail;
1178     }
1179
1180     if (!playback && !record) {
1181         pa_log("Neither playback nor record enabled for device.");
1182         goto fail;
1183     }
1184
1185     mode = (playback && record) ? O_RDWR : (playback ? O_WRONLY : (record ? O_RDONLY : 0));
1186
1187     ss = m->core->default_sample_spec;
1188     map = m->core->default_channel_map;
1189     if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_OSS) < 0) {
1190         pa_log("Failed to parse sample specification or channel map");
1191         goto fail;
1192     }
1193
1194     nfrags = (int) m->core->default_n_fragments;
1195     frag_size = (int) pa_usec_to_bytes(m->core->default_fragment_size_msec*1000, &ss);
1196     if (frag_size <= 0)
1197         frag_size = (int) pa_frame_size(&ss);
1198
1199     if (pa_modargs_get_value_s32(ma, "fragments", &nfrags) < 0 || pa_modargs_get_value_s32(ma, "fragment_size", &frag_size) < 0) {
1200         pa_log("Failed to parse fragments arguments");
1201         goto fail;
1202     }
1203
1204     if (pa_modargs_get_value_boolean(ma, "mmap", &use_mmap) < 0) {
1205         pa_log("Failed to parse mmap argument.");
1206         goto fail;
1207     }
1208
1209     if ((fd = pa_oss_open(dev = pa_modargs_get_value(ma, "device", DEFAULT_DEVICE), &mode, &caps)) < 0)
1210         goto fail;
1211
1212     if (use_mmap && (!(caps & DSP_CAP_MMAP) || !(caps & DSP_CAP_TRIGGER))) {
1213         pa_log_info("OSS device not mmap capable, falling back to UNIX read/write mode.");
1214         use_mmap = FALSE;
1215     }
1216
1217     if (use_mmap && mode == O_WRONLY) {
1218         pa_log_info("Device opened for playback only, cannot do memory mapping, falling back to UNIX write() mode.");
1219         use_mmap = FALSE;
1220     }
1221
1222     if (pa_oss_get_hw_description(dev, hwdesc, sizeof(hwdesc)) >= 0)
1223         pa_log_info("Hardware name is '%s'.", hwdesc);
1224     else
1225         hwdesc[0] = 0;
1226
1227     pa_log_info("Device opened in %s mode.", mode == O_WRONLY ? "O_WRONLY" : (mode == O_RDONLY ? "O_RDONLY" : "O_RDWR"));
1228
1229     orig_frag_size = frag_size;
1230     if (nfrags >= 2 && frag_size >= 1)
1231         if (pa_oss_set_fragments(fd, nfrags, frag_size) < 0)
1232             goto fail;
1233
1234     if (pa_oss_auto_format(fd, &ss) < 0)
1235         goto fail;
1236
1237     if (ioctl(fd, SNDCTL_DSP_GETBLKSIZE, &frag_size) < 0) {
1238         pa_log("SNDCTL_DSP_GETBLKSIZE: %s", pa_cstrerror(errno));
1239         goto fail;
1240     }
1241     pa_assert(frag_size > 0);
1242
1243     u = pa_xnew0(struct userdata, 1);
1244     u->core = m->core;
1245     u->module = m;
1246     m->userdata = u;
1247     u->fd = fd;
1248     u->mixer_fd = -1;
1249     u->mixer_devmask = 0;
1250     u->use_getospace = u->use_getispace = TRUE;
1251     u->use_getodelay = TRUE;
1252     u->mode = mode;
1253     u->frame_size = pa_frame_size(&ss);
1254     u->device_name = pa_xstrdup(dev);
1255     u->in_nfrags = u->out_nfrags = (uint32_t) (u->nfrags = nfrags);
1256     u->out_fragment_size = u->in_fragment_size = (uint32_t) (u->frag_size = frag_size);
1257     u->orig_frag_size = orig_frag_size;
1258     u->use_mmap = use_mmap;
1259     u->rtpoll = pa_rtpoll_new();
1260     pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
1261     u->rtpoll_item = NULL;
1262     build_pollfd(u);
1263
1264     if (ioctl(fd, SNDCTL_DSP_GETISPACE, &info) >= 0) {
1265         pa_log_info("Input -- %u fragments of size %u.", info.fragstotal, info.fragsize);
1266         u->in_fragment_size = (uint32_t) info.fragsize;
1267         u->in_nfrags = (uint32_t) info.fragstotal;
1268         u->use_getispace = TRUE;
1269     }
1270
1271     if (ioctl(fd, SNDCTL_DSP_GETOSPACE, &info) >= 0) {
1272         pa_log_info("Output -- %u fragments of size %u.", info.fragstotal, info.fragsize);
1273         u->out_fragment_size = (uint32_t) info.fragsize;
1274         u->out_nfrags = (uint32_t) info.fragstotal;
1275         u->use_getospace = TRUE;
1276     }
1277
1278     u->in_hwbuf_size = u->in_nfrags * u->in_fragment_size;
1279     u->out_hwbuf_size = u->out_nfrags * u->out_fragment_size;
1280
1281     if (mode != O_WRONLY) {
1282         char *name_buf = NULL;
1283
1284         if (use_mmap) {
1285             if ((u->in_mmap = mmap(NULL, u->in_hwbuf_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
1286                 pa_log_warn("mmap(PROT_READ) failed, reverting to non-mmap mode: %s", pa_cstrerror(errno));
1287                 use_mmap = u->use_mmap = FALSE;
1288                 u->in_mmap = NULL;
1289             } else
1290                 pa_log_debug("Successfully mmap()ed input buffer.");
1291         }
1292
1293         if ((name = pa_modargs_get_value(ma, "source_name", NULL)))
1294             namereg_fail = TRUE;
1295         else {
1296             name = name_buf = pa_sprintf_malloc("oss_input.%s", pa_path_get_filename(dev));
1297             namereg_fail = FALSE;
1298         }
1299
1300         pa_source_new_data_init(&source_new_data);
1301         source_new_data.driver = __FILE__;
1302         source_new_data.module = m;
1303         pa_source_new_data_set_name(&source_new_data, name);
1304         source_new_data.namereg_fail = namereg_fail;
1305         pa_source_new_data_set_sample_spec(&source_new_data, &ss);
1306         pa_source_new_data_set_channel_map(&source_new_data, &map);
1307         pa_proplist_sets(source_new_data.proplist, PA_PROP_DEVICE_STRING, dev);
1308         pa_proplist_sets(source_new_data.proplist, PA_PROP_DEVICE_API, "oss");
1309         pa_proplist_sets(source_new_data.proplist, PA_PROP_DEVICE_DESCRIPTION, hwdesc[0] ? hwdesc : dev);
1310         pa_proplist_sets(source_new_data.proplist, PA_PROP_DEVICE_ACCESS_MODE, use_mmap ? "mmap" : "serial");
1311         pa_proplist_setf(source_new_data.proplist, PA_PROP_DEVICE_BUFFERING_BUFFER_SIZE, "%lu", (unsigned long) (u->in_hwbuf_size));
1312         pa_proplist_setf(source_new_data.proplist, PA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZE, "%lu", (unsigned long) (u->in_fragment_size));
1313
1314         u->source = pa_source_new(m->core, &source_new_data, PA_SOURCE_HARDWARE|PA_SOURCE_LATENCY);
1315         pa_source_new_data_done(&source_new_data);
1316         pa_xfree(name_buf);
1317
1318         if (!u->source) {
1319             pa_log("Failed to create source object");
1320             goto fail;
1321         }
1322
1323         u->source->parent.process_msg = source_process_msg;
1324         u->source->userdata = u;
1325
1326         pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
1327         pa_source_set_rtpoll(u->source, u->rtpoll);
1328         u->source->refresh_volume = TRUE;
1329
1330         if (use_mmap)
1331             u->in_mmap_memblocks = pa_xnew0(pa_memblock*, u->in_nfrags);
1332     }
1333
1334     if (mode != O_RDONLY) {
1335         char *name_buf = NULL;
1336
1337         if (use_mmap) {
1338             if ((u->out_mmap = mmap(NULL, u->out_hwbuf_size, PROT_WRITE, MAP_SHARED, fd, 0)) == MAP_FAILED) {
1339                 if (mode == O_RDWR) {
1340                     pa_log_debug("mmap() failed for input. Changing to O_WRONLY mode.");
1341                     mode = O_WRONLY;
1342                     goto go_on;
1343                 } else {
1344                     pa_log_warn("mmap(PROT_WRITE) failed, reverting to non-mmap mode: %s", pa_cstrerror(errno));
1345                     u->use_mmap = use_mmap = FALSE;
1346                     u->out_mmap = NULL;
1347                 }
1348             } else {
1349                 pa_log_debug("Successfully mmap()ed output buffer.");
1350                 pa_silence_memory(u->out_mmap, u->out_hwbuf_size, &ss);
1351             }
1352         }
1353
1354         if ((name = pa_modargs_get_value(ma, "sink_name", NULL)))
1355             namereg_fail = TRUE;
1356         else {
1357             name = name_buf = pa_sprintf_malloc("oss_output.%s", pa_path_get_filename(dev));
1358             namereg_fail = FALSE;
1359         }
1360
1361         pa_sink_new_data_init(&sink_new_data);
1362         sink_new_data.driver = __FILE__;
1363         sink_new_data.module = m;
1364         pa_sink_new_data_set_name(&sink_new_data, name);
1365         sink_new_data.namereg_fail = namereg_fail;
1366         pa_sink_new_data_set_sample_spec(&sink_new_data, &ss);
1367         pa_sink_new_data_set_channel_map(&sink_new_data, &map);
1368         pa_proplist_sets(sink_new_data.proplist, PA_PROP_DEVICE_STRING, dev);
1369         pa_proplist_sets(sink_new_data.proplist, PA_PROP_DEVICE_API, "oss");
1370         pa_proplist_sets(sink_new_data.proplist, PA_PROP_DEVICE_DESCRIPTION, hwdesc[0] ? hwdesc : dev);
1371         pa_proplist_sets(sink_new_data.proplist, PA_PROP_DEVICE_ACCESS_MODE, use_mmap ? "mmap" : "serial");
1372         pa_proplist_setf(sink_new_data.proplist, PA_PROP_DEVICE_BUFFERING_BUFFER_SIZE, "%lu", (unsigned long) (u->out_hwbuf_size));
1373         pa_proplist_setf(sink_new_data.proplist, PA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZE, "%lu", (unsigned long) (u->out_fragment_size));
1374
1375         u->sink = pa_sink_new(m->core, &sink_new_data, PA_SINK_HARDWARE|PA_SINK_LATENCY);
1376         pa_sink_new_data_done(&sink_new_data);
1377         pa_xfree(name_buf);
1378
1379         if (!u->sink) {
1380             pa_log("Failed to create sink object");
1381             goto fail;
1382         }
1383
1384         u->sink->parent.process_msg = sink_process_msg;
1385         u->sink->userdata = u;
1386
1387         pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
1388         pa_sink_set_rtpoll(u->sink, u->rtpoll);
1389         u->sink->refresh_volume = TRUE;
1390
1391         u->sink->thread_info.max_request = u->out_hwbuf_size;
1392
1393         if (use_mmap)
1394             u->out_mmap_memblocks = pa_xnew0(pa_memblock*, u->out_nfrags);
1395     }
1396
1397     if ((u->mixer_fd = pa_oss_open_mixer_for_device(u->device_name)) >= 0) {
1398         pa_bool_t do_close = TRUE;
1399
1400         if (ioctl(fd, SOUND_MIXER_READ_DEVMASK, &u->mixer_devmask) < 0)
1401             pa_log_warn("SOUND_MIXER_READ_DEVMASK failed: %s", pa_cstrerror(errno));
1402
1403         else {
1404             if (u->sink && (u->mixer_devmask & (SOUND_MASK_VOLUME|SOUND_MASK_PCM))) {
1405                 pa_log_debug("Found hardware mixer track for playback.");
1406                 u->sink->flags |= PA_SINK_HW_VOLUME_CTRL;
1407                 u->sink->get_volume = sink_get_volume;
1408                 u->sink->set_volume = sink_set_volume;
1409                 u->sink->n_volume_steps = 101;
1410                 do_close = FALSE;
1411             }
1412
1413             if (u->source && (u->mixer_devmask & (SOUND_MASK_RECLEV|SOUND_MASK_IGAIN))) {
1414                 pa_log_debug("Found hardware mixer track for recording.");
1415                 u->source->flags |= PA_SOURCE_HW_VOLUME_CTRL;
1416                 u->source->get_volume = source_get_volume;
1417                 u->source->set_volume = source_set_volume;
1418                 u->source->n_volume_steps = 101;
1419                 do_close = FALSE;
1420             }
1421         }
1422
1423         if (do_close) {
1424             pa_close(u->mixer_fd);
1425             u->mixer_fd = -1;
1426             u->mixer_devmask = 0;
1427         }
1428     }
1429
1430 go_on:
1431
1432     pa_assert(u->source || u->sink);
1433
1434     pa_memchunk_reset(&u->memchunk);
1435
1436     if (!(u->thread = pa_thread_new(thread_func, u))) {
1437         pa_log("Failed to create thread.");
1438         goto fail;
1439     }
1440
1441     /* Read mixer settings */
1442     if (u->sink) {
1443         if (sink_new_data.volume_is_set) {
1444             if (u->sink->set_volume)
1445                 u->sink->set_volume(u->sink);
1446         } else {
1447             if (u->sink->get_volume)
1448                 u->sink->get_volume(u->sink);
1449         }
1450     }
1451
1452     if (u->source) {
1453         if (source_new_data.volume_is_set) {
1454             if (u->source->set_volume)
1455                 u->source->set_volume(u->source);
1456         } else {
1457             if (u->source->get_volume)
1458                 u->source->get_volume(u->source);
1459         }
1460     }
1461
1462     if (u->sink)
1463         pa_sink_put(u->sink);
1464     if (u->source)
1465         pa_source_put(u->source);
1466
1467     pa_modargs_free(ma);
1468
1469     return 0;
1470
1471 fail:
1472
1473     if (u)
1474         pa__done(m);
1475     else if (fd >= 0)
1476         pa_close(fd);
1477
1478     if (ma)
1479         pa_modargs_free(ma);
1480
1481     return -1;
1482 }
1483
1484 void pa__done(pa_module*m) {
1485     struct userdata *u;
1486
1487     pa_assert(m);
1488
1489     if (!(u = m->userdata))
1490         return;
1491
1492     if (u->sink)
1493         pa_sink_unlink(u->sink);
1494
1495     if (u->source)
1496         pa_source_unlink(u->source);
1497
1498     if (u->thread) {
1499         pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
1500         pa_thread_free(u->thread);
1501     }
1502
1503     pa_thread_mq_done(&u->thread_mq);
1504
1505     if (u->sink)
1506         pa_sink_unref(u->sink);
1507
1508     if (u->source)
1509         pa_source_unref(u->source);
1510
1511     if (u->memchunk.memblock)
1512         pa_memblock_unref(u->memchunk.memblock);
1513
1514     if (u->rtpoll_item)
1515         pa_rtpoll_item_free(u->rtpoll_item);
1516
1517     if (u->rtpoll)
1518         pa_rtpoll_free(u->rtpoll);
1519
1520     if (u->out_mmap_memblocks) {
1521         unsigned i;
1522         for (i = 0; i < u->out_nfrags; i++)
1523             if (u->out_mmap_memblocks[i])
1524                 pa_memblock_unref_fixed(u->out_mmap_memblocks[i]);
1525         pa_xfree(u->out_mmap_memblocks);
1526     }
1527
1528     if (u->in_mmap_memblocks) {
1529         unsigned i;
1530         for (i = 0; i < u->in_nfrags; i++)
1531             if (u->in_mmap_memblocks[i])
1532                 pa_memblock_unref_fixed(u->in_mmap_memblocks[i]);
1533         pa_xfree(u->in_mmap_memblocks);
1534     }
1535
1536     if (u->in_mmap && u->in_mmap != MAP_FAILED)
1537         munmap(u->in_mmap, u->in_hwbuf_size);
1538
1539     if (u->out_mmap && u->out_mmap != MAP_FAILED)
1540         munmap(u->out_mmap, u->out_hwbuf_size);
1541
1542     if (u->fd >= 0)
1543         pa_close(u->fd);
1544
1545     if (u->mixer_fd >= 0)
1546         pa_close(u->mixer_fd);
1547
1548     pa_xfree(u->device_name);
1549
1550     pa_xfree(u);
1551 }