aboutsummaryrefslogtreecommitdiffstats
path: root/src/output/oss_plugin.c
diff options
context:
space:
mode:
authorMax Kellermann <max@duempel.org>2008-10-26 11:29:44 +0100
committerMax Kellermann <max@duempel.org>2008-10-26 11:29:44 +0100
commitece8c1347caae044db0fc4565ed3db6028d7b90e (patch)
tree27ec1bee18cd10b6997a9a44a4043dd4a4449153 /src/output/oss_plugin.c
parente11355f47d545fe523b019481415b1347aecd4bd (diff)
downloadmpd-ece8c1347caae044db0fc4565ed3db6028d7b90e.tar.gz
mpd-ece8c1347caae044db0fc4565ed3db6028d7b90e.tar.xz
mpd-ece8c1347caae044db0fc4565ed3db6028d7b90e.zip
renamed src/audioOutputs/ to src/output/
Again, no CamelCase in the directory name.
Diffstat (limited to 'src/output/oss_plugin.c')
-rw-r--r--src/output/oss_plugin.c571
1 files changed, 571 insertions, 0 deletions
diff --git a/src/output/oss_plugin.c b/src/output/oss_plugin.c
new file mode 100644
index 000000000..67ea11fe4
--- /dev/null
+++ b/src/output/oss_plugin.c
@@ -0,0 +1,571 @@
+/* the Music Player Daemon (MPD)
+ * Copyright (C) 2003-2007 by Warren Dukes (warren.dukes@gmail.com)
+ * This project's homepage is: http://www.musicpd.org
+ *
+ * OSS audio output (c) 2004, 2005, 2006, 2007 by Eric Wong <eric@petta-tech.com>
+ * and Warren Dukes <warren.dukes@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include "../output_api.h"
+
+#ifdef HAVE_OSS
+
+#include "../utils.h"
+#include "../log.h"
+
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <fcntl.h>
+
+#if defined(__OpenBSD__) || defined(__NetBSD__)
+# include <soundcard.h>
+#else /* !(defined(__OpenBSD__) || defined(__NetBSD__) */
+# include <sys/soundcard.h>
+#endif /* !(defined(__OpenBSD__) || defined(__NetBSD__) */
+
+#ifdef WORDS_BIGENDIAN
+# define AFMT_S16_MPD AFMT_S16_BE
+#else
+# define AFMT_S16_MPD AFMT_S16_LE
+#endif /* WORDS_BIGENDIAN */
+
+typedef struct _OssData {
+ int fd;
+ const char *device;
+ struct audio_format audio_format;
+ int bitFormat;
+ int *supported[3];
+ int numSupported[3];
+ int *unsupported[3];
+ int numUnsupported[3];
+} OssData;
+
+enum oss_support {
+ OSS_SUPPORTED = 1,
+ OSS_UNSUPPORTED = 0,
+ OSS_UNKNOWN = -1,
+};
+
+enum oss_param {
+ OSS_RATE = 0,
+ OSS_CHANNELS = 1,
+ OSS_BITS = 2,
+};
+
+static enum oss_param
+getIndexForParam(unsigned param)
+{
+ enum oss_param idx = OSS_RATE;
+
+ switch (param) {
+ case SNDCTL_DSP_SPEED:
+ idx = OSS_RATE;
+ break;
+ case SNDCTL_DSP_CHANNELS:
+ idx = OSS_CHANNELS;
+ break;
+ case SNDCTL_DSP_SAMPLESIZE:
+ idx = OSS_BITS;
+ break;
+ }
+
+ return idx;
+}
+
+static int findSupportedParam(OssData * od, unsigned param, int val)
+{
+ int i;
+ enum oss_param idx = getIndexForParam(param);
+
+ for (i = 0; i < od->numSupported[idx]; i++) {
+ if (od->supported[idx][i] == val)
+ return 1;
+ }
+
+ return 0;
+}
+
+static int canConvert(int idx, int val)
+{
+ switch (idx) {
+ case OSS_BITS:
+ if (val != 16)
+ return 0;
+ break;
+ case OSS_CHANNELS:
+ if (val != 2)
+ return 0;
+ break;
+ }
+
+ return 1;
+}
+
+static int getSupportedParam(OssData * od, unsigned param, int val)
+{
+ int i;
+ enum oss_param idx = getIndexForParam(param);
+ int ret = -1;
+ int least = val;
+ int diff;
+
+ for (i = 0; i < od->numSupported[idx]; i++) {
+ diff = od->supported[idx][i] - val;
+ if (diff < 0)
+ diff = -diff;
+ if (diff < least) {
+ if (!canConvert(idx, od->supported[idx][i])) {
+ continue;
+ }
+ least = diff;
+ ret = od->supported[idx][i];
+ }
+ }
+
+ return ret;
+}
+
+static int findUnsupportedParam(OssData * od, unsigned param, int val)
+{
+ int i;
+ enum oss_param idx = getIndexForParam(param);
+
+ for (i = 0; i < od->numUnsupported[idx]; i++) {
+ if (od->unsupported[idx][i] == val)
+ return 1;
+ }
+
+ return 0;
+}
+
+static void addSupportedParam(OssData * od, unsigned param, int val)
+{
+ enum oss_param idx = getIndexForParam(param);
+
+ od->numSupported[idx]++;
+ od->supported[idx] = xrealloc(od->supported[idx],
+ od->numSupported[idx] * sizeof(int));
+ od->supported[idx][od->numSupported[idx] - 1] = val;
+}
+
+static void addUnsupportedParam(OssData * od, unsigned param, int val)
+{
+ enum oss_param idx = getIndexForParam(param);
+
+ od->numUnsupported[idx]++;
+ od->unsupported[idx] = xrealloc(od->unsupported[idx],
+ od->numUnsupported[idx] *
+ sizeof(int));
+ od->unsupported[idx][od->numUnsupported[idx] - 1] = val;
+}
+
+static void removeSupportedParam(OssData * od, unsigned param, int val)
+{
+ int i;
+ int j = 0;
+ enum oss_param idx = getIndexForParam(param);
+
+ for (i = 0; i < od->numSupported[idx] - 1; i++) {
+ if (od->supported[idx][i] == val)
+ j = 1;
+ od->supported[idx][i] = od->supported[idx][i + j];
+ }
+
+ od->numSupported[idx]--;
+ od->supported[idx] = xrealloc(od->supported[idx],
+ od->numSupported[idx] * sizeof(int));
+}
+
+static void removeUnsupportedParam(OssData * od, unsigned param, int val)
+{
+ int i;
+ int j = 0;
+ enum oss_param idx = getIndexForParam(param);
+
+ for (i = 0; i < od->numUnsupported[idx] - 1; i++) {
+ if (od->unsupported[idx][i] == val)
+ j = 1;
+ od->unsupported[idx][i] = od->unsupported[idx][i + j];
+ }
+
+ od->numUnsupported[idx]--;
+ od->unsupported[idx] = xrealloc(od->unsupported[idx],
+ od->numUnsupported[idx] *
+ sizeof(int));
+}
+
+static enum oss_support
+isSupportedParam(OssData * od, unsigned param, int val)
+{
+ if (findSupportedParam(od, param, val))
+ return OSS_SUPPORTED;
+ if (findUnsupportedParam(od, param, val))
+ return OSS_UNSUPPORTED;
+ return OSS_UNKNOWN;
+}
+
+static void supportParam(OssData * od, unsigned param, int val)
+{
+ enum oss_support supported = isSupportedParam(od, param, val);
+
+ if (supported == OSS_SUPPORTED)
+ return;
+
+ if (supported == OSS_UNSUPPORTED) {
+ removeUnsupportedParam(od, param, val);
+ }
+
+ addSupportedParam(od, param, val);
+}
+
+static void unsupportParam(OssData * od, unsigned param, int val)
+{
+ enum oss_support supported = isSupportedParam(od, param, val);
+
+ if (supported == OSS_UNSUPPORTED)
+ return;
+
+ if (supported == OSS_SUPPORTED) {
+ removeSupportedParam(od, param, val);
+ }
+
+ addUnsupportedParam(od, param, val);
+}
+
+static OssData *newOssData(void)
+{
+ OssData *ret = xmalloc(sizeof(OssData));
+
+ ret->device = NULL;
+ ret->fd = -1;
+
+ ret->supported[OSS_RATE] = NULL;
+ ret->supported[OSS_CHANNELS] = NULL;
+ ret->supported[OSS_BITS] = NULL;
+ ret->unsupported[OSS_RATE] = NULL;
+ ret->unsupported[OSS_CHANNELS] = NULL;
+ ret->unsupported[OSS_BITS] = NULL;
+
+ ret->numSupported[OSS_RATE] = 0;
+ ret->numSupported[OSS_CHANNELS] = 0;
+ ret->numSupported[OSS_BITS] = 0;
+ ret->numUnsupported[OSS_RATE] = 0;
+ ret->numUnsupported[OSS_CHANNELS] = 0;
+ ret->numUnsupported[OSS_BITS] = 0;
+
+ supportParam(ret, SNDCTL_DSP_SPEED, 48000);
+ supportParam(ret, SNDCTL_DSP_SPEED, 44100);
+ supportParam(ret, SNDCTL_DSP_CHANNELS, 2);
+ supportParam(ret, SNDCTL_DSP_SAMPLESIZE, 16);
+
+ return ret;
+}
+
+static void freeOssData(OssData * od)
+{
+ if (od->supported[OSS_RATE])
+ free(od->supported[OSS_RATE]);
+ if (od->supported[OSS_CHANNELS])
+ free(od->supported[OSS_CHANNELS]);
+ if (od->supported[OSS_BITS])
+ free(od->supported[OSS_BITS]);
+ if (od->unsupported[OSS_RATE])
+ free(od->unsupported[OSS_RATE]);
+ if (od->unsupported[OSS_CHANNELS])
+ free(od->unsupported[OSS_CHANNELS]);
+ if (od->unsupported[OSS_BITS])
+ free(od->unsupported[OSS_BITS]);
+
+ free(od);
+}
+
+#define OSS_STAT_NO_ERROR 0
+#define OSS_STAT_NOT_CHAR_DEV -1
+#define OSS_STAT_NO_PERMS -2
+#define OSS_STAT_DOESN_T_EXIST -3
+#define OSS_STAT_OTHER -4
+
+static int oss_statDevice(const char *device, int *stErrno)
+{
+ struct stat st;
+
+ if (0 == stat(device, &st)) {
+ if (!S_ISCHR(st.st_mode)) {
+ return OSS_STAT_NOT_CHAR_DEV;
+ }
+ } else {
+ *stErrno = errno;
+
+ switch (errno) {
+ case ENOENT:
+ case ENOTDIR:
+ return OSS_STAT_DOESN_T_EXIST;
+ case EACCES:
+ return OSS_STAT_NO_PERMS;
+ default:
+ return OSS_STAT_OTHER;
+ }
+ }
+
+ return 0;
+}
+
+static const char *default_devices[] = { "/dev/sound/dsp", "/dev/dsp" };
+
+static int oss_testDefault(void)
+{
+ int fd, i;
+
+ for (i = ARRAY_SIZE(default_devices); --i >= 0; ) {
+ if ((fd = open(default_devices[i], O_WRONLY)) >= 0) {
+ xclose(fd);
+ return 0;
+ }
+ WARNING("Error opening OSS device \"%s\": %s\n",
+ default_devices[i], strerror(errno));
+ }
+
+ return -1;
+}
+
+static void *oss_open_default(ConfigParam *param)
+{
+ int i;
+ int err[ARRAY_SIZE(default_devices)];
+ int ret[ARRAY_SIZE(default_devices)];
+
+ for (i = ARRAY_SIZE(default_devices); --i >= 0; ) {
+ ret[i] = oss_statDevice(default_devices[i], &err[i]);
+ if (ret[i] == 0) {
+ OssData *od = newOssData();
+ od->device = default_devices[i];
+ return od;
+ }
+ }
+
+ if (param)
+ ERROR("error trying to open specified OSS device"
+ " at line %i\n", param->line);
+ else
+ ERROR("error trying to open default OSS device\n");
+
+ for (i = ARRAY_SIZE(default_devices); --i >= 0; ) {
+ const char *dev = default_devices[i];
+ switch(ret[i]) {
+ case OSS_STAT_DOESN_T_EXIST:
+ ERROR("%s not found\n", dev);
+ break;
+ case OSS_STAT_NOT_CHAR_DEV:
+ ERROR("%s is not a character device\n", dev);
+ break;
+ case OSS_STAT_NO_PERMS:
+ ERROR("%s: permission denied\n", dev);
+ break;
+ default:
+ ERROR("Error accessing %s: %s\n", dev, strerror(err[i]));
+ }
+ }
+ exit(EXIT_FAILURE);
+ return NULL; /* some compilers can be dumb... */
+}
+
+static void *oss_initDriver(mpd_unused struct audio_output *audioOutput,
+ mpd_unused const struct audio_format *audio_format,
+ ConfigParam * param)
+{
+ if (param) {
+ BlockParam *bp = getBlockParam(param, "device");
+ if (bp) {
+ OssData *od = newOssData();
+ od->device = bp->value;
+ return od;
+ }
+ }
+ return oss_open_default(param);
+}
+
+static void oss_finishDriver(void *data)
+{
+ OssData *od = data;
+
+ freeOssData(od);
+}
+
+static int setParam(OssData * od, unsigned param, int *value)
+{
+ int val = *value;
+ int copy;
+ enum oss_support supported = isSupportedParam(od, param, val);
+
+ do {
+ if (supported == OSS_UNSUPPORTED) {
+ val = getSupportedParam(od, param, val);
+ if (copy < 0)
+ return -1;
+ }
+ copy = val;
+ if (ioctl(od->fd, param, &copy)) {
+ unsupportParam(od, param, val);
+ supported = OSS_UNSUPPORTED;
+ } else {
+ if (supported == OSS_UNKNOWN) {
+ supportParam(od, param, val);
+ supported = OSS_SUPPORTED;
+ }
+ val = copy;
+ }
+ } while (supported == OSS_UNSUPPORTED);
+
+ *value = val;
+
+ return 0;
+}
+
+static void oss_close(OssData * od)
+{
+ if (od->fd >= 0)
+ while (close(od->fd) && errno == EINTR) ;
+ od->fd = -1;
+}
+
+static int oss_open(OssData *od)
+{
+ int tmp;
+
+ if ((od->fd = open(od->device, O_WRONLY)) < 0) {
+ ERROR("Error opening OSS device \"%s\": %s\n", od->device,
+ strerror(errno));
+ goto fail;
+ }
+
+ tmp = od->audio_format.channels;
+ if (setParam(od, SNDCTL_DSP_CHANNELS, &tmp)) {
+ ERROR("OSS device \"%s\" does not support %u channels: %s\n",
+ od->device, od->audio_format.channels, strerror(errno));
+ goto fail;
+ }
+ od->audio_format.channels = tmp;
+
+ tmp = od->audio_format.sample_rate;
+ if (setParam(od, SNDCTL_DSP_SPEED, &tmp)) {
+ ERROR("OSS device \"%s\" does not support %u Hz audio: %s\n",
+ od->device, od->audio_format.sample_rate,
+ strerror(errno));
+ goto fail;
+ }
+ od->audio_format.sample_rate = tmp;
+
+ switch (od->audio_format.bits) {
+ case 8:
+ tmp = AFMT_S8;
+ break;
+ case 16:
+ tmp = AFMT_S16_MPD;
+ }
+
+ if (setParam(od, SNDCTL_DSP_SAMPLESIZE, &tmp)) {
+ ERROR("OSS device \"%s\" does not support %u bit audio: %s\n",
+ od->device, tmp, strerror(errno));
+ goto fail;
+ }
+
+ return 0;
+
+fail:
+ oss_close(od);
+ return -1;
+}
+
+static int oss_openDevice(void *data,
+ struct audio_format *audioFormat)
+{
+ int ret;
+ OssData *od = data;
+
+ od->audio_format = *audioFormat;
+
+ if ((ret = oss_open(od)) < 0)
+ return ret;
+
+ *audioFormat = od->audio_format;
+
+ DEBUG("oss device \"%s\" will be playing %u bit %u channel audio at "
+ "%u Hz\n", od->device,
+ od->audio_format.bits, od->audio_format.channels,
+ od->audio_format.sample_rate);
+
+ return ret;
+}
+
+static void oss_closeDevice(void *data)
+{
+ OssData *od = data;
+
+ oss_close(od);
+}
+
+static void oss_dropBufferedAudio(void *data)
+{
+ OssData *od = data;
+
+ if (od->fd >= 0) {
+ ioctl(od->fd, SNDCTL_DSP_RESET, 0);
+ oss_close(od);
+ }
+}
+
+static int oss_playAudio(void *data,
+ const char *playChunk, size_t size)
+{
+ OssData *od = data;
+ ssize_t ret;
+
+ /* reopen the device since it was closed by dropBufferedAudio */
+ if (od->fd < 0 && oss_open(od) < 0)
+ return -1;
+
+ while (size > 0) {
+ ret = write(od->fd, playChunk, size);
+ if (ret < 0) {
+ if (errno == EINTR)
+ continue;
+ ERROR("closing oss device \"%s\" due to write error: "
+ "%s\n", od->device, strerror(errno));
+ oss_closeDevice(od);
+ return -1;
+ }
+ playChunk += ret;
+ size -= ret;
+ }
+
+ return 0;
+}
+
+const struct audio_output_plugin ossPlugin = {
+ .name = "oss",
+ .test_default_device = oss_testDefault,
+ .init = oss_initDriver,
+ .finish = oss_finishDriver,
+ .open = oss_openDevice,
+ .play = oss_playAudio,
+ .cancel = oss_dropBufferedAudio,
+ .close = oss_closeDevice,
+};
+
+#else /* HAVE OSS */
+
+DISABLED_AUDIO_OUTPUT_PLUGIN(ossPlugin)
+#endif /* HAVE_OSS */