Author: Gary Mills <gary_mills@fastmail.fm>
Date: Tue Sep 22 13:16:06 2020 -0500
bug #9732: pulseaudio always uses the first audio device
diff --git a/src/modules/oss/module-oss.c b/src/modules/oss/module-oss.c
index 048822c..1146666 100644
--- a/src/modules/oss/module-oss.c
+++ b/src/modules/oss/module-oss.c
@@ -32,6 +32,8 @@
*
*/
+#define HAVE_OSSV4
+
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
@@ -122,7 +124,18 @@ struct userdata {
int mode;
int mixer_fd;
+
+#ifdef HAVE_OSSV4
+ int mixer_dev;
+ int mixer_sink_control;
+ int mixer_source_control;
+ int mixer_cmax;
+ int mixer_dsp_fd;
+ oss_mixext sink_mixext;
+ oss_mixext source_mixext;
+#else
int mixer_devmask;
+#endif
int nfrags, frag_size, orig_frag_size;
@@ -199,8 +212,13 @@ static void trigger(struct userdata *u, pa_sink_state_t sink_state, pa_source_st
} else {
if (enable_bits)
+#ifdef HAVE_OSSV4
+ if (ioctl(u->fd, SNDCTL_DSP_SYNC, NULL) < 0)
+ pa_log_warn("SNDCTL_DSP_SYNC: %s", pa_cstrerror(errno));
+#else
if (ioctl(u->fd, SNDCTL_DSP_POST, NULL) < 0)
pa_log_warn("SNDCTL_DSP_POST: %s", pa_cstrerror(errno));
+#endif
if (!quick) {
/*
@@ -819,6 +837,160 @@ static int source_set_state_in_io_thread_cb(pa_source *s, pa_source_state_t new_
return 0;
}
+#ifdef HAVE_OSSV4
+
+static const char *
+mixer_ext_type_get_name (int type)
+{
+ switch (type) {
+ case MIXT_DEVROOT:
+ return "Device root entry";
+ case MIXT_GROUP:
+ return "Controller group";
+ case MIXT_ONOFF:
+ return "On/Off switch";
+ case MIXT_ENUM:
+ return "Enumeration control";
+ case MIXT_MONOSLIDER:
+ return "Mono slider (0-255)";
+ case MIXT_STEREOSLIDER:
+ return "Stereo slider (0-255)";
+ case MIXT_MESSAGE:
+ return "Textual message";
+ case MIXT_MONOVU:
+ return "Mono VU meter value";
+ case MIXT_STEREOVU:
+ return "Stereo VU meter value";
+ case MIXT_MONOPEAK:
+ return "Mono VU meter peak value";
+ case MIXT_STEREOPEAK:
+ return "Stereo VU meter peak value";
+ case MIXT_RADIOGROUP:
+ return "Radio button group";
+ case MIXT_MARKER:
+ /* Separator between normal and extension entries */
+ return "Separator";
+ case MIXT_VALUE:
+ return "Decimal value entry";
+ case MIXT_HEXVALUE:
+ return "Hex value entry";
+ case MIXT_SLIDER:
+ return "Mono slider (31-bit value range)";
+ case MIXT_3D:
+ return "3D";
+ case MIXT_MONOSLIDER16:
+ return "Mono slider (0-32767)";
+ case MIXT_STEREOSLIDER16:
+ return "Stereo slider (0-32767)";
+ case MIXT_MUTE:
+ return "Mute switch";
+ default:
+ break;
+ }
+
+ return "Unknown";
+}
+
+void
+mixer_showflags (int flags)
+{
+ struct
+ {
+ int flag;
+ char nick[16];
+ } all_flags[] = {
+ /* first the important ones */
+ {
+ MIXF_MAINVOL, "MAINVOL"}, {
+ MIXF_PCMVOL, "PCMVOL"}, {
+ MIXF_RECVOL, "RECVOL"}, {
+ MIXF_MONVOL, "MONVOL"}, {
+ MIXF_DESCR, "DESCR"},
+
+ /* now the rest in the right order */
+ {
+ MIXF_READABLE, "READABLE"}, {
+ MIXF_WRITEABLE, "WRITABLE"}, {
+ MIXF_POLL, "POLL"}, {
+ MIXF_HZ, "HZ"}, {
+ MIXF_STRING, "STRING"}, {
+ MIXF_DYNAMIC, "DYNAMIC"}, {
+ MIXF_OKFAIL, "OKFAIL"}, {
+ MIXF_FLAT, "FLAT"}, {
+ MIXF_LEGACY, "LEGACY"}, {
+ MIXF_CENTIBEL, "CENTIBEL"}, {
+ MIXF_DECIBEL, "DECIBEL"}, {
+ MIXF_WIDE, "WIDE"}
+ };
+ int num_flags = (sizeof (all_flags) / sizeof ((all_flags)[0]));
+ int i;
+
+ if (flags == 0) {
+ pa_log_debug (" flags : None");
+ return;
+ }
+
+ for (i=0; i < num_flags; i++) {
+ if ((flags & all_flags[i].flag)) {
+ pa_log_debug (" flag : %s", all_flags[i].nick);
+ flags &= ~all_flags[i].flag; /* unset */
+ }
+ }
+
+ /* Unknown flags? */
+ if (flags != 0) {
+ pa_log_debug (" flag : ????");
+ }
+
+ return;
+}
+
+static void sink_get_volume(pa_sink *s) {
+ struct userdata *u;
+
+ pa_assert_se(u = s->userdata);
+
+ if (pa_oss_get_volume(u->mixer_dsp_fd, &(u->sink_mixext), &s->sample_spec, &s->real_volume) >= 0)
+ return;
+
+ pa_log_info("Device doesn't support reading mixer settings: %s", pa_cstrerror(errno));
+}
+
+static void sink_set_volume(pa_sink *s) {
+ struct userdata *u;
+
+ pa_assert_se(u = s->userdata);
+
+ if (pa_oss_set_volume(u->mixer_dsp_fd, &(u->sink_mixext), &s->sample_spec, &s->real_volume) >= 0)
+ return;
+
+ pa_log_info("Device doesn't support writing mixer settings: %s", pa_cstrerror(errno));
+}
+
+static void source_get_volume(pa_source *s) {
+ struct userdata *u;
+
+ pa_assert_se(u = s->userdata);
+
+ if (pa_oss_get_volume(u->mixer_dsp_fd, &(u->source_mixext), &s->sample_spec, &s->real_volume) >= 0)
+ return;
+
+ pa_log_info("Device doesn't support reading mixer settings: %s", pa_cstrerror(errno));
+}
+
+static void source_set_volume(pa_source *s) {
+ struct userdata *u;
+
+ pa_assert_se(u = s->userdata);
+
+ if (pa_oss_set_volume(u->mixer_dsp_fd, &(u->source_mixext), &s->sample_spec, &s->real_volume) >= 0)
+ return;
+
+ pa_log_info("Device doesn't support writing mixer settings: %s", pa_cstrerror(errno));
+}
+
+#else
+
static void sink_get_volume(pa_sink *s) {
struct userdata *u;
@@ -889,6 +1061,7 @@ static void source_set_volume(pa_source *s) {
if (u->mixer_devmask & SOUND_MASK_MIC)
(void) pa_oss_set_volume(u->mixer_fd, SOUND_MIXER_WRITE_MIC, &s->sample_spec, &s->real_volume);
}
+#endif
static void thread_func(void *userdata) {
struct userdata *u = userdata;
@@ -1179,6 +1352,11 @@ fail:
int pa__init(pa_module*m) {
+#ifdef HAVE_OSSV4
+ struct oss_sysinfo si = { {0,}, };
+ struct oss_mixerinfo mi = { 0, };
+#endif
+
struct audio_buf_info info;
struct userdata *u = NULL;
const char *dev;
@@ -1278,7 +1456,9 @@ int pa__init(pa_module*m) {
m->userdata = u;
u->fd = fd;
u->mixer_fd = -1;
+#ifndef HAVE_OSSV4
u->mixer_devmask = 0;
+#endif
u->use_getospace = u->use_getispace = true;
u->use_getodelay = true;
u->mode = mode;
@@ -1452,6 +1632,179 @@ int pa__init(pa_module*m) {
if ((u->mixer_fd = pa_oss_open_mixer_for_device(u->device_name)) >= 0) {
bool do_close = true;
+#ifdef HAVE_OSSV4
+#define IGNORE_DEV 1
+ int i;
+
+ u->mixer_dsp_fd = -1;
+
+ if (ioctl (u->mixer_fd, SNDCTL_SYSINFO, &si) < 0) {
+ pa_log_debug ("SNDCTL_SYSINFO failed");
+ goto fail;
+ }
+
+ i = pa_oss_get_device_number(u->device_name);
+ if (i >= 0 && i < si.nummixers) {
+ mi.dev = i;
+ if (ioctl (u->mixer_fd, SNDCTL_MIXERINFO, &mi) < 0) {
+ pa_log_debug("SNDCTL_MIXERINFO failed");
+ goto fail;
+ }
+ }
+
+ if (i < si.nummixers) {
+ struct stat sbuf;
+
+ if ((stat(mi.devnode, &sbuf) != 0) ||
+ ((sbuf.st_mode & S_IFCHR) == 0)) {
+ pa_log("Failed to get mixer dsp device.");
+ i = si.nummixers;
+ }
+ }
+
+ if (i < si.nummixers &&
+ (u->mixer_dsp_fd = pa_oss_open_mixer(mi.devnode)) >= 0) {
+
+ /* Will cause for loop to exit if not filled in by OSS */
+ u->mixer_cmax = -1;
+ if (ioctl(u->mixer_dsp_fd, SNDCTL_MIX_NREXT, &u->mixer_cmax) < 0) {
+ pa_log("Failed to get max control.");
+ goto fail;
+ }
+
+ pa_log_debug ("Opened mixer device %d with %d controls\n",
+ mi.dev, mi.nrext);
+
+ u->mixer_sink_control = -1;
+ u->mixer_source_control = -1;
+
+ for (i=0; i < u->mixer_cmax; i++) {
+ memset (&(u->sink_mixext), 0, sizeof (oss_mixext));
+
+#ifdef IGNORE_DEV
+ /* This will cause dev to be ignored */
+ u->sink_mixext.dev = -1;
+#else
+ u->sink_mixext.dev = mi.dev;
+#endif
+
+ /*
+ * The real way to pick a control on a mixer is with this
+ * number. Note that control numbers are unique across all
+ * mixers. So dev can just be ignored. When dev is included
+ * it will only be used to check for correct dev from
+ * userland. But it will not be used to select a mixer.
+ */
+ u->sink_mixext.ctrl = i;
+
+ pa_log_debug ("Control %d", u->sink_mixext.ctrl);
+
+ if (ioctl (u->mixer_dsp_fd, SNDCTL_MIX_EXTINFO,
+ &(u->sink_mixext)) < 0) {
+ pa_log_debug ("SNDCTL_MIX_EXTINFO failed");
+ continue;
+ }
+
+ pa_log_debug (" name : %s", u->sink_mixext.extname);
+ pa_log_debug (" type : %s (%d)",
+ mixer_ext_type_get_name (u->sink_mixext.type),
+ u->sink_mixext.type);
+ pa_log_debug (" maxval : %d", u->sink_mixext.maxvalue);
+ pa_log_debug (" parent : %d", u->sink_mixext.parent);
+ mixer_showflags (u->sink_mixext.flags);
+
+ if ((u->sink_mixext.flags & MIXF_PCMVOL)) {
+ pa_log_debug ("First PCM control: %d", i);
+ u->mixer_sink_control = i;
+ break;
+ }
+
+ /*
+ * Note that MIXF_MAINVOL may not be an exclusive single
+ * control. For example on AudioHD there will be one for each
+ * output jack (Green, Black, Orange...). So to really do a
+ * master volume you would need to do all MIXF_MAINVOL at the
+ * same time...
+ */
+ if (((u->sink_mixext.flags & MIXF_MAINVOL)) &&
+ u->mixer_sink_control == -1) {
+ pa_log_debug ("First main volume control: %d", i);
+ u->mixer_sink_control = i;
+ }
+ }
+
+ if (u->mixer_sink_control != -1) {
+ pa_log_debug ("Setting OSS sink callbacks.");
+ pa_sink_set_get_volume_callback(u->sink, sink_get_volume);
+ pa_sink_set_set_volume_callback(u->sink, sink_set_volume);
+ u->sink->n_volume_steps = 101;
+ do_close = false;
+ } else {
+ pa_log_debug ("Not setting OSS sink callbacks.");
+ }
+
+ for (i=0; i < mi.nrext; i++) {
+ memset (&(u->source_mixext), 0, sizeof (oss_mixext));
+#ifdef IGNORE_DEV
+ /* This will cause dev to be ignored */
+ u->source_mixext.dev = -1;
+#else
+ u->source_mixext.dev = mi.dev;
+#endif
+ /*
+ * The real way to pick a control on a mixer is with this
+ * number. Note that control numbers are unique across all
+ * mixers. So dev can just be ignored. When dev is included
+ * it will only be used to check for correct dev from userland.
+ * But it will not be used to select a mixer.
+ */
+ u->source_mixext.ctrl = i;
+
+ pa_log_debug ("Control %d", u->source_mixext.ctrl);
+
+ if (ioctl (u->mixer_dsp_fd, SNDCTL_MIX_EXTINFO,
+ &(u->source_mixext)) == -1) {
+ pa_log_debug ("SNDCTL_MIX_EXTINFO failed");
+ continue;
+ }
+
+ pa_log_debug (" name : %s", u->source_mixext.extname);
+ pa_log_debug (" type : %s (%d)",
+ mixer_ext_type_get_name (u->source_mixext.type),
+ u->source_mixext.type);
+ pa_log_debug (" maxval : %d", u->source_mixext.maxvalue);
+ pa_log_debug (" parent : %d", u->source_mixext.parent);
+ mixer_showflags (u->source_mixext.flags);
+
+ /*
+ * There may be more then one MIXF_RECVOL on a mixer. In fact
+ * for audioHD the can be three (line-in, mix-in, and cd-in).
+ * For a master gain it may be good to adjust all...
+ */
+ if ((u->source_mixext.flags & MIXF_RECVOL)) {
+ pa_log_debug ("First REC control: %d", i);
+ u->mixer_source_control = i;
+ break;
+ }
+ }
+
+ if (u->mixer_source_control != -1) {
+ pa_log_debug ("Setting OSS source callbacks.");
+ pa_source_set_get_volume_callback(u->source, source_get_volume);
+ pa_source_set_set_volume_callback(u->source, source_set_volume);
+ u->source->n_volume_steps = 101;
+ do_close = false;
+ } else {
+ pa_log_debug ("Not setting OSS source callbacks.");
+ }
+
+ if (do_close == true) {
+ pa_close(u->mixer_dsp_fd);
+ u->mixer_dsp_fd = -1;
+ }
+ }
+
+#else
if (ioctl(u->mixer_fd, SOUND_MIXER_READ_DEVMASK, &u->mixer_devmask) < 0)
pa_log_warn("SOUND_MIXER_READ_DEVMASK failed: %s", pa_cstrerror(errno));
else {
@@ -1471,11 +1824,14 @@ int pa__init(pa_module*m) {
do_close = false;
}
}
+#endif
if (do_close) {
pa_close(u->mixer_fd);
u->mixer_fd = -1;
+#ifndef HAVE_OSSV4
u->mixer_devmask = 0;
+#endif
}
}
@@ -1595,6 +1951,10 @@ void pa__done(pa_module*m) {
if (u->fd >= 0)
pa_close(u->fd);
+#ifdef HAVE_OSSV4
+ if (u->mixer_dsp_fd >= 0)
+ pa_close(u->mixer_dsp_fd);
+#endif
if (u->mixer_fd >= 0)
pa_close(u->mixer_fd);
diff --git a/src/modules/oss/oss-util.c b/src/modules/oss/oss-util.c
index 80b6c8c..69c702a 100644
--- a/src/modules/oss/oss-util.c
+++ b/src/modules/oss/oss-util.c
@@ -30,6 +30,7 @@
#include <unistd.h>
#include <sys/types.h>
#include <fcntl.h>
+#include <sys/filio.h>
#include <pulse/xmalloc.h>
#include <pulsecore/core-error.h>
@@ -90,10 +91,7 @@ int pa_oss_open(const char *device, int *mode, int* pcaps) {
}
success:
- if (ioctl(fd, FIONBIO, &nonblock_io) < 0) {
- pa_log("FIONBIO: %s", pa_cstrerror(errno));
- goto fail;
- }
+ pa_make_fd_nonblock(fd);
t = pa_sprintf_malloc(
"%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
@@ -256,6 +254,190 @@ int pa_oss_set_fragments(int fd, int nfrags, int frag_size) {
return 0;
}
+#ifdef HAVE_OSSV4
+static int
+oss4_mixer_slider_pack_volume (oss_mixext *mixext, int channels, const pa_cvolume *volume)
+{
+ int val = 0;
+ int lvol = 0;
+ int rvol = 0;
+ int lval = 0;
+ int rval = 0;
+
+ switch (mixext->type) {
+ case MIXT_MONOSLIDER:
+ case MIXT_MONOSLIDER16:
+ case MIXT_SLIDER:
+ lvol = volume->values[0] > PA_VOLUME_NORM ? PA_VOLUME_NORM : volume->values[0];
+ val = (lvol*mixext->maxvalue)/PA_VOLUME_NORM;
+ break;
+
+ case MIXT_STEREOSLIDER:
+ lvol = volume->values[0] > PA_VOLUME_NORM ? PA_VOLUME_NORM : volume->values[0];
+ lval = (lvol*mixext->maxvalue)/PA_VOLUME_NORM;
+ if (channels >= 2) {
+ rvol = volume->values[1] > PA_VOLUME_NORM ? PA_VOLUME_NORM : volume->values[1];
+ rval = (rvol*mixext->maxvalue)/PA_VOLUME_NORM;
+ }
+
+ val = ((rval & 0xff) << 8) | (lval & 0xff);
+ break;
+
+ case MIXT_STEREOSLIDER16:
+ lvol = volume->values[0] > PA_VOLUME_NORM ? PA_VOLUME_NORM : volume->values[0];
+ lval = (lvol*mixext->maxvalue)/PA_VOLUME_NORM;
+ if (channels >= 2) {
+ rvol = volume->values[1] > PA_VOLUME_NORM ? PA_VOLUME_NORM : volume->values[1];
+ rval = (rvol*mixext->maxvalue)/PA_VOLUME_NORM;
+ }
+
+ val = ((rval & 0xffff) << 16) | (lval & 0xffff);
+
+ break;
+
+ default:
+ return 0;
+ }
+
+ return val;
+}
+
+static void
+oss4_mixer_slider_unpack_volume (oss_mixext *mixext, int v, pa_cvolume * volume)
+{
+ uint32_t val, vol;
+
+ val = (uint32_t) v;
+ switch (mixext->type) {
+ case MIXT_SLIDER:
+ vol = val;
+ volume->values[0] = PA_CLAMP_VOLUME((vol * PA_VOLUME_NORM) / mixext->maxvalue);
+ if (volume->channels >= 2) {
+ volume->values[1] = volume->values[0];
+ }
+ break;
+ case MIXT_MONOSLIDER:
+ /* oss repeats the value in the upper bits, as if it was stereo */
+ vol = val & 0x00ff;
+ volume->values[0] = PA_CLAMP_VOLUME((vol * PA_VOLUME_NORM) / mixext->maxvalue);
+ if (volume->channels >= 2) {
+ volume->values[1] = volume->values[0];
+ }
+ break;
+ case MIXT_MONOSLIDER16:
+ /* oss repeats the value in the upper bits, as if it was stereo */
+ vol = val & 0x0000ffff;
+ volume->values[0] = PA_CLAMP_VOLUME((vol * PA_VOLUME_NORM) / mixext->maxvalue);
+ if (volume->channels >= 2) {
+ volume->values[1] = volume->values[0];
+ }
+ break;
+ case MIXT_STEREOSLIDER:
+ vol = (val & 0x00ff);
+ volume->values[0] = PA_CLAMP_VOLUME((vol * PA_VOLUME_NORM) / mixext->maxvalue);
+ if (volume->channels >= 2) {
+ vol = (val & 0xff00) >> 8;
+ volume->values[1] = PA_CLAMP_VOLUME((vol * PA_VOLUME_NORM) / mixext->maxvalue);
+ }
+ break;
+ case MIXT_STEREOSLIDER16:
+ vol = (val & 0x0000ffff);
+ volume->values[0] = PA_CLAMP_VOLUME((vol * PA_VOLUME_NORM) / mixext->maxvalue);
+ if (volume->channels >= 2) {
+ vol = (val & 0xffff0000) >> 16;
+ volume->values[1] = PA_CLAMP_VOLUME((vol * PA_VOLUME_NORM) / mixext->maxvalue);
+ }
+ break;
+ default:
+ return;
+ }
+}
+
+static int
+oss4_mixer_get_control_val (int fd, oss_mixext *mixext, int *val)
+{
+ oss_mixer_value ossval = { 0, };
+
+ /* ossval.dev = mixext->dev; */
+ ossval.dev = -1; /* if -1 on entry then is ignored */
+ /*
+ * The real way to pick a control on a mixer is with this number.
+ * Note that control numbers are uniq across all mixers. So dev
+ * can just be ignored. When dev is included it will only be used
+ * to check for correct dev from userland. But it will not be used
+ * to select a mixer.
+ */
+ ossval.ctrl = mixext->ctrl;
+ ossval.timestamp = mixext->timestamp;
+
+ if (ioctl (fd, SNDCTL_MIX_READ, &ossval) == -1) {
+ pa_log_debug ("SNDCTL_MIX_READ failed");
+ *val = 0;
+ return -1;
+ }
+
+ *val = ossval.value;
+ pa_log_debug ("got value 0x%08x from %s", *val, mixext->extname);
+ return 0;
+}
+
+static int
+oss4_mixer_set_control_val (int fd, oss_mixext *mixext, int val)
+{
+ oss_mixer_value ossval = { 0, };
+
+ /* ossval.dev = mixext->dev; */
+ ossval.dev = -1; /* if -1 on entry then is ignored */
+ /*
+ * The real way to pick a control on a mixer is with this number.
+ * Note that control numbers are uniq across all mixers. So dev
+ * can just be ignored. When dev is included it will only be used
+ * to check for correct dev from userland. But it will not be used
+ * to select a mixer.
+ */
+ ossval.ctrl = mixext->ctrl;
+ ossval.timestamp = mixext->timestamp;
+ ossval.value = val;
+
+ if (ioctl (fd, SNDCTL_MIX_WRITE, &ossval) == -1) {
+ pa_log_debug ("SNDCTL_MIX_WRITE failed");
+ return -1;
+ }
+
+ pa_log_debug ("set value 0x%08x on %s", val, mixext->extname);
+ return 0;
+}
+
+int pa_oss_get_volume(int fd, oss_mixext *mixext, const pa_sample_spec *ss, pa_cvolume *volume) {
+ int v = 0;
+
+ if (oss4_mixer_get_control_val (fd, mixext, &v) != 0) {
+ pa_log_debug ("Getting volume failed");
+ return -1;
+ }
+
+ pa_cvolume_reset(volume, ss->channels);
+
+ oss4_mixer_slider_unpack_volume (mixext, v, volume);
+
+ return 0;
+}
+
+int pa_oss_set_volume(int fd, oss_mixext *mixext, const pa_sample_spec *ss, const pa_cvolume *volume) {
+ int val = 0;
+
+ val = oss4_mixer_slider_pack_volume (mixext, ss->channels, volume);
+
+ if (oss4_mixer_set_control_val (fd, mixext, val) != 0) {
+ pa_log_debug ("Setting volume failed");
+ return -1;
+ }
+
+ return 0;
+}
+
+#else
+
int pa_oss_get_volume(int fd, unsigned long mixer, const pa_sample_spec *ss, pa_cvolume *volume) {
char cv[PA_CVOLUME_SNPRINT_VERBOSE_MAX];
unsigned vol;
@@ -298,6 +480,7 @@ int pa_oss_set_volume(int fd, unsigned long mixer, const pa_sample_spec *ss, con
pa_log_debug("Wrote mixer settings: %s", pa_cvolume_snprint(cv, sizeof(cv), volume));
return 0;
}
+#endif
static int get_device_number(const char *dev) {
const char *p;
@@ -305,10 +488,16 @@ static int get_device_number(const char *dev) {
char *rp = NULL;
int r = -1;
- if (!(p = rp = pa_readlink(dev))) {
- if (errno != EINVAL && errno != ENOLINK)
- return -2;
- p = dev;
+ p = strchr(dev, '\0') - 1;
+ if (*p >= '0' && *p <= '9') {
+ p = dev;
+ } else {
+ /* We need to resolve the symlink */
+ if (!(p = rp = pa_readlink(dev))) {
+ if (errno != EINVAL && errno != ENOLINK)
+ return -2;
+ p = dev;
+ }
}
/* find the last forward slash */
@@ -333,6 +522,10 @@ static int get_device_number(const char *dev) {
return r;
}
+int pa_oss_get_device_number(const char *dev) {
+ return (get_device_number(dev));
+}
+
int pa_oss_get_hw_description(const char *dev, char *name, size_t l) {
FILE *f;
int n, r = -1;
@@ -407,15 +602,17 @@ int pa_oss_open_mixer_for_device(const char *device) {
char *fn;
int fd;
- if ((n = get_device_number(device)) == -2)
+ if ((n = get_device_number(device)) == -2) {
+ pa_log_warn ("Cannot find number for device '%s'", device);
return -1;
+ }
if (n == -1)
- if ((fd = open_mixer("/dev/mixer")) >= 0)
+ if ((fd = pa_oss_open_mixer("/dev/mixer")) >= 0)
return fd;
fn = pa_sprintf_malloc("/dev/mixer%i", n);
- fd = open_mixer(fn);
+ fd = pa_oss_open_mixer(fn);
pa_xfree(fn);
if (fd < 0)
diff --git a/src/modules/oss/oss-util.h b/src/modules/oss/oss-util.h
index 8af27de..120fc5d 100644
--- a/src/modules/oss/oss-util.h
+++ b/src/modules/oss/oss-util.h
@@ -29,11 +29,22 @@ int pa_oss_auto_format(int fd, pa_sample_spec *ss);
int pa_oss_set_fragments(int fd, int frags, int frag_size);
+#define HAVE_OSSV4
+
+#ifdef HAVE_OSSV4
+int pa_oss_set_volume(int fd, oss_mixext *mixext, const pa_sample_spec *ss, const pa_cvolume *volume);
+int pa_oss_get_volume(int fd, oss_mixext *mixext, const pa_sample_spec *ss, pa_cvolume *volume);
+
+#else
+
int pa_oss_set_volume(int fd, unsigned long mixer, const pa_sample_spec *ss, const pa_cvolume *volume);
int pa_oss_get_volume(int fd, unsigned long mixer, const pa_sample_spec *ss, pa_cvolume *volume);
+#endif
int pa_oss_get_hw_description(const char *dev, char *name, size_t l);
+int pa_oss_get_device_number(const char *dev);
int pa_oss_open_mixer_for_device(const char *device);
+int pa_oss_open_mixer(const char *device);
#endif