src/module-oss.c

   1 #include <sys/soundcard.h>
   2 #include <sys/ioctl.h>
   3 #include <stdlib.h>
   4 #include <sys/stat.h>
   5 #include <stdio.h>
   6 #include <assert.h>
   7 #include <errno.h>
   8 #include <string.h>
   9 #include <fcntl.h>
  10 #include <unistd.h>
  11 #include <limits.h>
  12
  13 #include "iochannel.h"
  14 #include "sink.h"
  15 #include "source.h"
  16 #include "module.h"
  17 #include "oss-util.h"
  18 #include "sample-util.h"
  19 #include "util.h"
  20 #include "modargs.h"
  21
  22 struct userdata {
  23     struct pa_sink *sink;
  24     struct pa_source *source;
  25     struct pa_iochannel *io;
  26     struct pa_core *core;
  27
  28     struct pa_memchunk memchunk, silence;
  29
  30     uint32_t in_fragment_size, out_fragment_size, sample_size;
  31
  32     int fd;
  33 };
  34
  35 static const char* const valid_modargs[] = {
  36     "sink_name",
  37     "source_name",
  38     "device",
  39     "record",
  40     "playback",
  41     NULL
  42 };
  43
  44 #define DEFAULT_SINK_NAME "oss_output"
  45 #define DEFAULT_SOURCE_NAME "oss_input"
  46 #define DEFAULT_DEVICE "/dev/dsp"
  47
  48 static void do_write(struct userdata *u) {
  49     struct pa_memchunk *memchunk;
  50     ssize_t r;
  51     assert(u);
  52
  53     if (!u->sink || !pa_iochannel_is_writable(u->io))
  54         return;
  55
  56     if (!u->memchunk.length) {
  57         if (pa_sink_render(u->sink, u->out_fragment_size, &u->memchunk) < 0)
  58             memchunk = &u->silence;
  59         else
  60             memchunk = &u->memchunk;
  61     }
  62
  63     assert(memchunk->memblock && memchunk->length);
  64
  65     if ((r = pa_iochannel_write(u->io, memchunk->memblock->data + memchunk->index, memchunk->length)) < 0) {
  66         fprintf(stderr, "write() failed: %s\n", strerror(errno));
  67         return;
  68     }
  69
  70     if (memchunk == &u->silence)
  71         assert(r % u->sample_size == 0);
  72     else {
  73         u->memchunk.index += r;
  74         u->memchunk.length -= r;
  75
  76         if (u->memchunk.length <= 0) {
  77             pa_memblock_unref(u->memchunk.memblock);
  78             u->memchunk.memblock = NULL;
  79         }
  80     }
  81 }
  82
  83 static void do_read(struct userdata *u) {
  84     struct pa_memchunk memchunk;
  85     ssize_t r;
  86     assert(u);
  87
  88     if (!u->source || !pa_iochannel_is_readable(u->io))
  89         return;
  90
  91     memchunk.memblock = pa_memblock_new(u->in_fragment_size);
  92     assert(memchunk.memblock);
  93     if ((r = pa_iochannel_read(u->io, memchunk.memblock->data, memchunk.memblock->length)) < 0) {
  94         pa_memblock_unref(memchunk.memblock);
  95         if (errno != EAGAIN)
  96             fprintf(stderr, "read() failed: %s\n", strerror(errno));
  97         return;
  98     }
  99
 100     assert(r <= (ssize_t) memchunk.memblock->length);
 101     memchunk.length = memchunk.memblock->length = r;
 102     memchunk.index = 0;
 103
 104     pa_source_post(u->source, &memchunk);
 105     pa_memblock_unref(memchunk.memblock);
 106 };
 107
 108 static void io_callback(struct pa_iochannel *io, void*userdata) {
 109     struct userdata *u = userdata;
 110     assert(u);
 111     do_write(u);
 112     do_read(u);
 113 }
 114
 115 static uint32_t sink_get_latency_cb(struct pa_sink *s) {
 116     int arg;
 117     struct userdata *u = s->userdata;
 118     assert(s && u && u->sink);
 119
 120     if (ioctl(u->fd, SNDCTL_DSP_GETODELAY, &arg) < 0) {
 121         fprintf(stderr, "module-oss: device doesn't support SNDCTL_DSP_GETODELAY.\n");
 122         s->get_latency = NULL;
 123         return 0;
 124     }
 125
 126     return pa_samples_usec(arg, &s->sample_spec);
 127 }
 128
 129 int pa_module_init(struct pa_core *c, struct pa_module*m) {
 130     struct audio_buf_info info;
 131     struct userdata *u = NULL;
 132     const char *p;
 133     int fd = -1;
 134     int frag_size, in_frag_size, out_frag_size;
 135     int mode;
 136     uint32_t record = 1, playback = 1;
 137     struct pa_sample_spec ss;
 138     struct pa_modargs *ma = NULL;
 139     assert(c && m);
 140
 141     if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
 142         fprintf(stderr, __FILE__": failed to parse module arguments.\n");
 143         goto fail;
 144     }
 145
 146     if (pa_modargs_get_value_u32(ma, "record", &record) < 0 || pa_modargs_get_value_u32(ma, "playback", &playback) < 0) {
 147         fprintf(stderr, __FILE__": record= and playback= expect numeric argument.\n");
 148         goto fail;
 149     }
 150
 151     mode = (playback&&record) ? O_RDWR : (playback ? O_WRONLY : (record ? O_RDONLY : 0));
 152     if (mode == 0) {
 153         fprintf(stderr, __FILE__": neither playback nor record enabled for device.\n");
 154         goto fail;
 155     }
 156
 157     if ((fd = pa_oss_open(p = pa_modargs_get_value(ma, "device", DEFAULT_DEVICE), &mode, NULL)) < 0)
 158         goto fail;
 159
 160     fprintf(stderr, "module-oss: device opened in %s mode.\n", mode == O_WRONLY ? "O_WRONLY" : (mode == O_RDONLY ? "O_RDONLY" : "O_RDWR"));
 161
 162     frag_size = ((int) 12 << 16) | 10; /* nfrags = 12; frag_size = 2^10 */
 163     if (ioctl(fd, SNDCTL_DSP_SETFRAGMENT, &frag_size) < 0) {
 164         fprintf(stderr, "SNDCTL_DSP_SETFRAGMENT: %s\n", strerror(errno));
 165         goto fail;
 166     }
 167
 168     if (pa_oss_auto_format(fd, &ss) < 0)
 169         goto fail;
 170
 171     if (ioctl(fd, SNDCTL_DSP_GETBLKSIZE, &frag_size) < 0) {
 172         fprintf(stderr, "SNDCTL_DSP_GETBLKSIZE: %s\n", strerror(errno));
 173         goto fail;
 174     }
 175     assert(frag_size);
 176     in_frag_size = out_frag_size = frag_size;
 177
 178     if (ioctl(fd, SNDCTL_DSP_GETISPACE, &info) >= 0) {
 179         fprintf(stderr, "module-oss: input -- %u fragments of size %u.\n", info.fragstotal, info.fragsize);
 180         in_frag_size = info.fragsize;
 181     }
 182
 183     if (ioctl(fd, SNDCTL_DSP_GETOSPACE, &info) >= 0) {
 184         fprintf(stderr, "module-oss: output -- %u fragments of size %u.\n", info.fragstotal, info.fragsize);
 185         out_frag_size = info.fragsize;
 186     }
 187
 188     u = malloc(sizeof(struct userdata));
 189     assert(u);
 190
 191     u->core = c;
 192
 193     if (mode != O_WRONLY) {
 194         u->source = pa_source_new(c, pa_modargs_get_value(ma, "source_name", DEFAULT_SOURCE_NAME), 0, &ss);
 195         assert(u->source);
 196         u->source->userdata = u;
 197         pa_source_set_owner(u->source, m);
 198         u->source->description = pa_sprintf_malloc("Open Sound System PCM on '%s'", p);
 199     } else
 200         u->source = NULL;
 201
 202     if (mode != O_RDONLY) {
 203         u->sink = pa_sink_new(c, pa_modargs_get_value(ma, "sink_name", DEFAULT_SINK_NAME), 0, &ss);
 204         assert(u->sink);
 205         u->sink->get_latency = sink_get_latency_cb;
 206         u->sink->userdata = u;
 207         pa_sink_set_owner(u->sink, m);
 208         u->sink->description = pa_sprintf_malloc("Open Sound System PCM on '%s'", p);
 209     } else
 210         u->sink = NULL;
 211
 212     assert(u->source || u->sink);
 213
 214     u->io = pa_iochannel_new(c->mainloop, u->source ? fd : -1, u->sink ? fd : 0);
 215     assert(u->io);
 216     pa_iochannel_set_callback(u->io, io_callback, u);
 217     u->fd = fd;
 218
 219     u->memchunk.memblock = NULL;
 220     u->memchunk.length = 0;
 221     u->sample_size = pa_sample_size(&ss);
 222
 223     u->out_fragment_size = out_frag_size;
 224     u->in_fragment_size = in_frag_size;
 225     u->silence.memblock = pa_memblock_new(u->silence.length = u->out_fragment_size);
 226     assert(u->silence.memblock);
 227     pa_silence_memblock(u->silence.memblock, &ss);
 228     u->silence.index = 0;
 229
 230     m->userdata = u;
 231
 232     return 0;
 233
 234 fail:
 235     if (fd >= 0)
 236         close(fd);
 237
 238     if (ma)
 239         pa_modargs_free(ma);
 240
 241     return -1;
 242 }
 243
 244 void pa_module_done(struct pa_core *c, struct pa_module*m) {
 245     struct userdata *u;
 246     assert(c && m);
 247
 248     u = m->userdata;
 249     assert(u);
 250
 251     if (u->memchunk.memblock)
 252         pa_memblock_unref(u->memchunk.memblock);
 253     if (u->silence.memblock)
 254         pa_memblock_unref(u->silence.memblock);
 255
 256     if (u->sink)
 257         pa_sink_free(u->sink);
 258     if (u->source)
 259         pa_source_free(u->source);
 260     pa_iochannel_free(u->io);
 261     free(u);
 262 }