oss.c

   1 /*
   2  * Copyright (C) 2008 Mark Hills <mark@pogo.org.uk>
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * version 2, as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  11  * General Public License version 2 for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * version 2 along with this program; if not, write to the Free
  15  * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  16  * MA 02110-1301, USA.
  17  *
  18  */
  19
  20 #include <fcntl.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25 #include <sys/ioctl.h>
  26 #include <sys/poll.h>
  27 #include <sys/soundcard.h>
  28
  29 #include "device.h"
  30 #include "timecoder.h"
  31 #include "player.h"
  32
  33 #define DEFAULT_OSS_BUFFERS 8
  34 #define DEFAULT_OSS_FRAGMENT 7
  35
  36 static guint oss_fragment = DEFAULT_OSS_FRAGMENT;
  37 static guint oss_buffers = DEFAULT_OSS_BUFFERS;
  38
  39 struct oss_t {
  40     int fd;
  41     struct pollfd *pe;
  42 };
  43
  44
  45 static int clear(struct device_t *dv)
  46 {
  47     int r;
  48     struct oss_t *oss = (struct oss_t*)dv->local;
  49
  50     r = close(oss->fd);
  51     if(r == -1)
  52         perror("close");
  53
  54     free(dv->local);
  55
  56     return r;
  57 }
  58
  59
  60 /* Push audio into the device's buffer, for playback */
  61
  62 static int push(int fd, signed short *pcm, int samples)
  63 {
  64     int r, bytes;
  65
  66     bytes = samples * DEVICE_CHANNELS * sizeof(short);
  67
  68     r = write(fd, pcm, bytes);
  69
  70     if(r == -1) {
  71         perror("write");
  72         return -1;
  73     }
  74
  75     if(r < bytes)
  76         fprintf(stderr, "Device output overrun.\n");
  77
  78     return r / DEVICE_CHANNELS / sizeof(short);
  79 }
  80
  81
  82 /* Pull audio from the device, for recording */
  83
  84 static int pull(int fd, signed short *pcm, int samples)
  85 {
  86     int r, bytes;
  87
  88     bytes = samples * DEVICE_CHANNELS * sizeof(short);
  89
  90     r = read(fd, pcm, bytes);
  91
  92     if(r == -1) {
  93         perror("read");
  94         return -1;
  95     }
  96
  97     if(r < bytes)
  98         fprintf(stderr, "Device input underrun.\n");
  99
 100     return r / DEVICE_CHANNELS / sizeof(short);
 101 }
 102
 103
 104 static int handle(struct device_t *dv)
 105 {
 106     signed short pcm[DEVICE_FRAME * DEVICE_CHANNELS];
 107     int samples;
 108     struct oss_t *oss = (struct oss_t*)dv->local;
 109
 110     /* Check input buffer for recording */
 111
 112     if(oss->pe->revents & POLLIN) {
 113         samples = pull(oss->fd, pcm, DEVICE_FRAME);
 114         if(samples == -1)
 115             return -1;
 116
 117         if(dv->timecoder)
 118             timecoder_submit(dv->timecoder, pcm, samples);
 119     }
 120
 121     /* Check the output buffer for playback */
 122
 123     if(oss->pe->revents & POLLOUT) {
 124
 125         /* Always push some audio to the soundcard, even if it means
 126          * silence. This has shown itself to be much more reliable
 127          * than starting and stopping -- which can affect other
 128          * devices in the system. */
 129
 130         if(dv->player)
 131             player_collect(dv->player, pcm, DEVICE_FRAME);
 132         else
 133             memset(pcm, 0, DEVICE_FRAME * DEVICE_CHANNELS * sizeof(short));
 134
 135         samples = push(oss->fd, pcm, DEVICE_FRAME);
 136
 137         if(samples == -1)
 138             return -1;
 139     }
 140
 141     return 0;
 142 }
 143
 144
 145 int pollfds(struct device_t *dv, struct pollfd *pe, int n)
 146 {
 147     struct oss_t *oss = (struct oss_t*)dv->local;
 148
 149     if(n < 1)
 150         return -1;
 151
 152     pe->fd = oss->fd;
 153     pe->events = POLLIN | POLLOUT | POLLHUP;
 154
 155     oss->pe = pe;
 156
 157     return 1;
 158 }
 159
 160
 161 int oss_init(struct device_t *dv, const char *filename,
 162              unsigned short buffers, unsigned short fragment)
 163 {
 164     int p, fd;
 165     struct oss_t *oss;
 166
 167     fd = open(filename, O_RDWR, 0);
 168     if(fd == -1) {
 169         perror("open");
 170         return -1;
 171     }
 172
 173     /* Ideally would set independent settings for the record and
 174      * playback buffers. Recording needs to buffer where necessary, as
 175      * lost audio results in zero-crossings which corrupt the
 176      * timecode. Playback buffer neews to be short to avoid high
 177      * latency */
 178
 179     p = (buffers << 16) | fragment;
 180     if(ioctl(fd, SNDCTL_DSP_SETFRAGMENT, &p) == -1) {
 181         perror("SNDCTL_DSP_SETFRAGMENT");
 182         goto fail;
 183     }
 184
 185     p = AFMT_S16_LE;
 186     if(ioctl(fd, SNDCTL_DSP_SETFMT, &p) == -1) {
 187         perror("SNDCTL_DSP_SETFMT");
 188         goto fail;
 189     }
 190
 191     p = DEVICE_CHANNELS;
 192     if(ioctl(fd, SNDCTL_DSP_CHANNELS, &p) == -1) {
 193         perror("SNDCTL_DSP_CHANNELS");
 194         goto fail;
 195     }
 196
 197     p = DEVICE_RATE;
 198     if(ioctl(fd, SNDCTL_DSP_SPEED, &p) == -1) {
 199         perror("SNDCTL_DSP_SPEED");
 200         goto fail;
 201     }
 202
 203     if(fcntl(fd, F_SETFL, O_NONBLOCK) == -1) {
 204         perror("fcntl");
 205         return -1;
 206     }
 207
 208     dv->local = malloc(sizeof(struct oss_t));
 209     if(!dv->local) {
 210         perror("malloc");
 211         goto fail;
 212     }
 213
 214     oss = (struct oss_t*)dv->local;
 215
 216     oss->fd = fd;
 217     oss->pe = NULL;
 218
 219     dv->pollfds = pollfds;
 220     dv->handle = handle;
 221     dv->start = NULL;
 222     dv->stop = NULL;
 223     dv->clear = clear;
 224
 225     return 0;
 226
 227  fail:
 228     close(fd);
 229     return -1;
 230 }
 231
 232 static gboolean parse_oss_device(const gchar *option_name, const gchar *value, gpointer data, GError **error)
 233 {
 234         struct device_t* device = createDevice(error);
 235
 236         if(!device)
 237                 return FALSE;
 238
 239         return connectAudio(device, oss_init(device, value, oss_buffers, oss_fragment));
 240 }
 241
 242 static GOptionEntry ossOptions[] =
 243 {
 244         { "oss_device", 'o', 0, G_OPTION_ARG_CALLBACK, &parse_oss_device, "Build a deck connected to OSS audio device", "/dev/dsp"},
 245         // Set number of buffers for subsequent devices
 246         { "buffer_count", 'b', 0, G_OPTION_ARG_INT, &oss_buffers, "Number of buffers", NULL},
 247         { "buffer_size", 'f', 0, G_OPTION_ARG_INT, &oss_fragment, "Buffer size to request (2^n bytes)", NULL},
 248         { NULL }
 249 };
 250
 251 GOptionGroup* get_oss_option_group()
 252 {
 253         GOptionGroup* group = g_option_group_new
 254         (
 255                 "oss",
 256                 "OSS device options",
 257                 "Show OSS help options",
 258                 NULL,
 259                 NULL
 260         );
 261
 262         if(ossOptions[1].arg_description == NULL)
 263                 ossOptions[1].arg_description = g_strdup_printf("%u", DEFAULT_OSS_BUFFERS);
 264
 265         if(ossOptions[2].arg_description == NULL)
 266                 ossOptions[2].arg_description = g_strdup_printf("%u", DEFAULT_OSS_FRAGMENT);
 267
 268         g_option_group_add_entries(group, ossOptions);
 269         return group;
 270 }
 271