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