From 181e9c6d5d11cb1e5d36a2777eeb233ad8ed00e5 Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Thu, 9 Oct 2008 18:15:23 +0200 Subject: big pile of updates to match more what happened with libcanberra --- src/oss.c | 403 ++++++++++++++++++++++++++++++++++---------------------------- 1 file changed, 219 insertions(+), 184 deletions(-) (limited to 'src/oss.c') diff --git a/src/oss.c b/src/oss.c index 410fa45..a60412b 100644 --- a/src/oss.c +++ b/src/oss.c @@ -1,3 +1,23 @@ +/*** + This file is part of libsydney. + + Copyright 2007-2008 Lennart Poettering + + libsydney is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as + published by the Free Software Foundation, either version 2.1 of the + License, or (at your option) any later version. + + libsydney 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with libsydney. If not, see + . +***/ + #ifdef HAVE_CONFIG_H #include #endif @@ -13,6 +33,17 @@ #include #include +#ifdef HAVE_MACHINE_SOUNDCARD_H +# include +#else +# ifdef HAVE_SOUNDCARD_H +# include +# else +# include +# endif +#endif + + #include "sydney.h" #include "common.h" #include "macro.h" @@ -23,13 +54,9 @@ #include "bufferq.h" #define DEFAULT_DEVICE "/dev/dsp" -#define DRIVER_NAME "oss" - -typedef struct oss_stream oss_stream_t; -#define OSS_STREAM(x) ((oss_stream_t*) (x->private)) -struct oss_stream { - sa_stream_t *parent; +struct private { + sa_stream *parent; int fd; pcm_attrs_t real_pcm_attrs; sa_converter_t converter_read, converter_write; @@ -42,27 +69,37 @@ struct oss_stream { void *cdata; }; -static int simple_log2(int v) { - int k = 0; +#define PRIVATE(c) ((struct private *) ((c)->private)) + +static inline unsigned ulog2(unsigned n) { + + if (n <= 1) + return 0; + +#if __GNUC__ >= 4 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) + return 8U * (unsigned) sizeof(unsigned) - (unsigned) __builtin_clz(n) - 1; +#else +{ + unsigned r = 0; for (;;) { - v >>= 1; - if (!v) break; - k++; - } + n = n >> 1; + + if (!n) + return r; - return k; + r++; + } } -#ifdef HAVE_CONFIG_H -#include #endif +} static size_t fixup_bps(size_t s, size_t bps1, size_t bps2) { return (s*bps2)/bps1; } -int driver_open(sa_stream_t *s) { - oss_stream_t *oss; +int driver_open(sa_stream *s) { + struct private *p; char *n; int f, arg, bs, r, phase, i, found, suggested, fs, l, m; unsigned c; @@ -84,14 +121,14 @@ int driver_open(sa_stream_t *s) { }; static const int try_rates[] = { 8000, 16000, 32000, 44100, 48000, 96000, 192000 }; - if (s->driver && strcmp(s->driver, DRIVER_NAME)) - return SA_ERROR_NO_DRIVER; + if (s->driver && !sa_streq(s->driver, "oss")) + return SA_ERROR_NODRIVER; - if (!(s->private = oss = sa_new0(oss_stream_t, 1))) + if (!(s->private = p = sa_new0(struct private, 1))) return SA_ERROR_OOM; - oss->parent = s; - oss->socket_fds[0] = oss->socket_fds[1] = -1; + p->parent = s; + p->socket_fds[0] = p->socket_fds[1] = -1; n = s->device ? s->device : (char*) DEFAULT_DEVICE; if (!s->codec) @@ -106,17 +143,17 @@ int driver_open(sa_stream_t *s) { * SETFRAGMENT again which can do only after reopening the * device again. */ - if ((oss->fd = open(n, s->mode == SA_MODE_RDONLY ? O_RDONLY : (s->mode == SA_MODE_WRONLY ? O_WRONLY : O_RDWR) | O_NOCTTY | O_NONBLOCK)) < 0) { + if ((p->fd = open(n, s->mode == SA_MODE_RDONLY ? O_RDONLY : (s->mode == SA_MODE_WRONLY ? O_WRONLY : O_RDWR) | O_NOCTTY | O_NONBLOCK)) < 0) { if (errno == ENODEV || errno == ENOENT) - r = SA_ERROR_NO_DEVICE; + r = SA_ERROR_NODEVICE; else r = SA_ERROR_SYSTEM; goto fail; } - fcntl(oss->fd, F_SETFL, fcntl(oss->fd, F_GETFL) & ~O_NONBLOCK); /* FIXME*/ + fcntl(p->fd, F_SETFL, fcntl(p->fd, F_GETFL) & ~O_NONBLOCK); /* FIXME*/ if (!s->device) { if (!(n = sa_strdup(n))) { @@ -146,10 +183,10 @@ int driver_open(sa_stream_t *s) { } if (!s->codec && real_bps) - bs = fixup_bps(bs, bps, real_bps); + bs = (int) fixup_bps((size_t) bs, bps, real_bps); fs = bs/4; - l = simple_log2(fs); + l = ulog2(fs); if (l < 1) l = 1; m = (bs+(1<fd, SNDCTL_DSP_SETFRAGMENT, &arg); + ioctl(p->fd, SNDCTL_DSP_SETFRAGMENT, &arg); /* We ignore errors on this call, since it's merely a hint anyway */ if (s->codec) { @@ -169,7 +206,7 @@ int driver_open(sa_stream_t *s) { else if (strcmp(s->codec, SA_CODEC_MPEG) == 0) f = AFMT_MPEG; else { - r = SA_ERROR_NO_CODEC; + r = SA_ERROR_NOCODEC; goto fail; } @@ -181,7 +218,7 @@ int driver_open(sa_stream_t *s) { for (;;) { arg = f; - if (ioctl(oss->fd, SNDCTL_DSP_SETFMT, &arg) < 0) { + if (ioctl(p->fd, SNDCTL_DSP_SETFMT, &arg) < 0) { r = SA_ERROR_SYSTEM; goto fail; } @@ -210,10 +247,10 @@ int driver_open(sa_stream_t *s) { } else if (f == AFMT_A_LAW || f == AFMT_MU_LAW) { f = AFMT_U8; } else if (f == AFMT_AC3 || f == AFMT_MPEG) { - r = SA_ERROR_NO_CODEC; + r = SA_ERROR_NOCODEC; goto fail; } else { - r = SA_ERROR_NO_PCM_FORMAT; + r = SA_ERROR_NOPCMFORMAT; goto fail; } } @@ -222,23 +259,23 @@ int driver_open(sa_stream_t *s) { switch (f) { case AFMT_MU_LAW: - oss->real_pcm_attrs.format = SA_PCM_FORMAT_ULAW; + p->real_pcm_attrs.format = SA_PCM_FORMAT_ULAW; break; case AFMT_A_LAW: - oss->real_pcm_attrs.format = SA_PCM_FORMAT_ALAW; + p->real_pcm_attrs.format = SA_PCM_FORMAT_ALAW; break; case AFMT_U8: - oss->real_pcm_attrs.format = SA_PCM_FORMAT_U8; + p->real_pcm_attrs.format = SA_PCM_FORMAT_U8; break; case AFMT_S16_LE: - oss->real_pcm_attrs.format = SA_PCM_FORMAT_S16_LE; + p->real_pcm_attrs.format = SA_PCM_FORMAT_S16_LE; break; case AFMT_S16_BE: - oss->real_pcm_attrs.format = SA_PCM_FORMAT_S16_BE; + p->real_pcm_attrs.format = SA_PCM_FORMAT_S16_BE; break; default: @@ -252,8 +289,8 @@ int driver_open(sa_stream_t *s) { /* First try more channels ... */ for (c = s->pcm_attrs.nchannels; c < 8 || c == s->pcm_attrs.nchannels; c ++) { - arg = c; - if (ioctl(oss->fd, SNDCTL_DSP_CHANNELS, &arg) < 0) { + arg = (int) c; + if (ioctl(p->fd, SNDCTL_DSP_CHANNELS, &arg) < 0) { r = SA_ERROR_SYSTEM; goto fail; } @@ -267,8 +304,8 @@ int driver_open(sa_stream_t *s) { /* ... then try less channels */ if (!found) { for (c = s->pcm_attrs.nchannels - 1; c > 0; c --) { - arg = c; - if (ioctl(oss->fd, SNDCTL_DSP_CHANNELS, &arg) < 0) { + arg = (int) c; + if (ioctl(p->fd, SNDCTL_DSP_CHANNELS, &arg) < 0) { r = SA_ERROR_SYSTEM; goto fail; } @@ -283,8 +320,8 @@ int driver_open(sa_stream_t *s) { /* First try less channels ... */ for (c = s->pcm_attrs.nchannels; c > 0; c --) { - arg = c; - if (ioctl(oss->fd, SNDCTL_DSP_CHANNELS, &arg) < 0) { + arg = (int) c; + if (ioctl(p->fd, SNDCTL_DSP_CHANNELS, &arg) < 0) { r = SA_ERROR_SYSTEM; goto fail; } @@ -299,7 +336,7 @@ int driver_open(sa_stream_t *s) { if (!found) { for (c = s->pcm_attrs.nchannels + 1; c < 8; c ++) { arg = c; - if (ioctl(oss->fd, SNDCTL_DSP_CHANNELS, &arg) < 0) { + if (ioctl(p->fd, SNDCTL_DSP_CHANNELS, &arg) < 0) { r = SA_ERROR_SYSTEM; goto fail; } @@ -318,32 +355,32 @@ int driver_open(sa_stream_t *s) { goto fail; } - oss->real_pcm_attrs.nchannels = c; + p->real_pcm_attrs.nchannels = c; - if (!(oss->real_pcm_attrs.channel_map = sa_new(sa_channel_t, c))) { + if (!(p->real_pcm_attrs.channel_map = sa_new(sa_channel_t, c))) { r = SA_ERROR_OOM; goto fail; } switch (c) { case 8: - oss->real_pcm_attrs.channel_map[7] = SA_CHANNEL_REAR_RIGHT; + p->real_pcm_attrs.channel_map[7] = SA_CHANNEL_REAR_RIGHT; case 7: - oss->real_pcm_attrs.channel_map[6] = SA_CHANNEL_REAR_LEFT; + p->real_pcm_attrs.channel_map[6] = SA_CHANNEL_REAR_LEFT; case 6: - oss->real_pcm_attrs.channel_map[5] = SA_CHANNEL_FRONT_LEFT; + p->real_pcm_attrs.channel_map[5] = SA_CHANNEL_FRONT_LEFT; case 5: - oss->real_pcm_attrs.channel_map[4] = SA_CHANNEL_FRONT_RIGHT; + p->real_pcm_attrs.channel_map[4] = SA_CHANNEL_FRONT_RIGHT; case 4: - oss->real_pcm_attrs.channel_map[3] = SA_CHANNEL_LFE; + p->real_pcm_attrs.channel_map[3] = SA_CHANNEL_LFE; case 3: - oss->real_pcm_attrs.channel_map[2] = SA_CHANNEL_CENTER; + p->real_pcm_attrs.channel_map[2] = SA_CHANNEL_CENTER; case 2: - oss->real_pcm_attrs.channel_map[1] = SA_CHANNEL_RIGHT; - oss->real_pcm_attrs.channel_map[0] = SA_CHANNEL_LEFT; + p->real_pcm_attrs.channel_map[1] = SA_CHANNEL_RIGHT; + p->real_pcm_attrs.channel_map[0] = SA_CHANNEL_LEFT; break; case 1: - oss->real_pcm_attrs.channel_map[0] = SA_CHANNEL_MONO; + p->real_pcm_attrs.channel_map[0] = SA_CHANNEL_MONO; break; } @@ -358,7 +395,7 @@ int driver_open(sa_stream_t *s) { for (;;) { arg = r; - if (ioctl(oss->fd, SNDCTL_DSP_SPEED, &arg) < 0) { + if (ioctl(p->fd, SNDCTL_DSP_SPEED, &arg) < 0) { r = SA_ERROR_SYSTEM; goto fail; } @@ -446,19 +483,19 @@ int driver_open(sa_stream_t *s) { } - oss->real_pcm_attrs.rate = r; + p->real_pcm_attrs.rate = r; - printf("Chosen: %u channels, %uHz, format=%u\n", oss->real_pcm_attrs.nchannels, oss->real_pcm_attrs.rate, oss->real_pcm_attrs.format); + printf("Chosen: %u channels, %uHz, format=%u\n", p->real_pcm_attrs.nchannels, p->real_pcm_attrs.rate, p->real_pcm_attrs.format); - real_bps = oss->real_pcm_attrs.nchannels * oss->real_pcm_attrs.rate * sa_get_pcm_sample_size(oss->real_pcm_attrs.format); + real_bps = p->real_pcm_attrs.nchannels * p->real_pcm_attrs.rate * sa_get_pcm_sample_size(p->real_pcm_attrs.format); if (real_bps != bps && loops < 1) { loops++; - sa_free(oss->real_pcm_attrs.channel_map); - oss->real_pcm_attrs.channel_map = NULL; + sa_free(p->real_pcm_attrs.channel_map); + p->real_pcm_attrs.channel_map = NULL; - close(oss->fd); + close(p->fd); printf("bps changed, retrying...\n"); continue; @@ -469,15 +506,15 @@ int driver_open(sa_stream_t *s) { } /* First, let's try GETBLKSIZE */ - if (ioctl(oss->fd, SNDCTL_DSP_GETBLKSIZE, &arg) >= 0) { + if (ioctl(p->fd, SNDCTL_DSP_GETBLKSIZE, &arg) >= 0) { if (s->mode & SA_MODE_RDONLY) { - oss->read_fragment_size = arg; - oss->read_nfragments = 2; + p->read_fragment_size = arg; + p->read_nfragments = 2; } if (s->mode & SA_MODE_WRONLY) { - oss->write_fragment_size = arg; - oss->write_nfragments = 2; + p->write_fragment_size = arg; + p->write_nfragments = 2; } } @@ -485,28 +522,28 @@ int driver_open(sa_stream_t *s) { if (s->mode & SA_MODE_RDONLY) { audio_buf_info info; - if (ioctl(oss->fd, SNDCTL_DSP_GETISPACE, &info) >= 0) { - oss->read_fragment_size = info.fragsize; - oss->read_nfragments = info.fragstotal; + if (ioctl(p->fd, SNDCTL_DSP_GETISPACE, &info) >= 0) { + p->read_fragment_size = info.fragsize; + p->read_nfragments = info.fragstotal; } } if (s->mode & SA_MODE_WRONLY) { audio_buf_info info; - if (ioctl(oss->fd, SNDCTL_DSP_GETOSPACE, &info) >= 0) { - oss->write_fragment_size = info.fragsize; - oss->write_nfragments = info.fragstotal; + if (ioctl(p->fd, SNDCTL_DSP_GETOSPACE, &info) >= 0) { + p->write_fragment_size = info.fragsize; + p->write_nfragments = info.fragstotal; } } - if (s->mode & SA_MODE_WRONLY && (oss->write_fragment_size <= 0 || oss->write_nfragments <= 1)) { + if (s->mode & SA_MODE_WRONLY && (p->write_fragment_size <= 0 || p->write_nfragments <= 1)) { errno = EIO; r = SA_ERROR_SYSTEM; goto fail; } - if (s->mode & SA_MODE_RDONLY && (oss->read_fragment_size <= 0 || oss->read_nfragments <= 1)) { + if (s->mode & SA_MODE_RDONLY && (p->read_fragment_size <= 0 || p->read_nfragments <= 1)) { errno = EIO; r = SA_ERROR_SYSTEM; goto fail; @@ -517,7 +554,7 @@ int driver_open(sa_stream_t *s) { if (s->adjust_nchannels != 0) { sa_channel_t *cm; - if (!(cm = sa_newdup(sa_channel_t, oss->real_pcm_attrs.channel_map, oss->real_pcm_attrs.nchannels))) { + if (!(cm = sa_newdup(sa_channel_t, p->real_pcm_attrs.channel_map, p->real_pcm_attrs.nchannels))) { r = SA_ERROR_OOM; goto fail; } @@ -525,45 +562,45 @@ int driver_open(sa_stream_t *s) { sa_free(s->pcm_attrs.channel_map); s->pcm_attrs.channel_map = cm; - s->pcm_attrs.nchannels = oss->real_pcm_attrs.nchannels; + s->pcm_attrs.nchannels = p->real_pcm_attrs.nchannels; } if (s->adjust_rate != 0) - s->pcm_attrs.rate = oss->real_pcm_attrs.rate; + s->pcm_attrs.rate = p->real_pcm_attrs.rate; if (s->adjust_pcm_format != 0) - s->pcm_attrs.format = oss->real_pcm_attrs.format; + s->pcm_attrs.format = p->real_pcm_attrs.format; if (s->mode & SA_MODE_RDONLY) - if ((r = sa_converter_init(&oss->converter_read, &oss->real_pcm_attrs, &s->pcm_attrs, s->dynamic_rate_enabled)) < 0) + if ((r = sa_converter_init(&p->converter_read, &p->real_pcm_attrs, &s->pcm_attrs, s->dynamic_rate_enabled)) < 0) goto fail; if (s->mode & SA_MODE_WRONLY) - if ((r = sa_converter_init(&oss->converter_write, &s->pcm_attrs, &oss->real_pcm_attrs, s->dynamic_rate_enabled)) < 0) + if ((r = sa_converter_init(&p->converter_write, &s->pcm_attrs, &p->real_pcm_attrs, s->dynamic_rate_enabled)) < 0) goto fail; } /* if (s->adjust_watermarks) { */ /* if (s->mode & SA_MODE_RDONLY) { */ -/* s->read_lower_watermark = oss->read_fragment_size; */ -/* s->read_upper_watermark = oss->read_fragment_size * oss->read_nfragments; */ +/* s->read_lower_watermark = p->read_fragment_size; */ +/* s->read_upper_watermark = p->read_fragment_size * p->read_nfragments; */ /* } */ /* if (s->mode & SA_MODE_WRONLY) { */ -/* s->write_lower_watermark = oss->write_fragment_size; */ -/* s->write_upper_watermark = oss->write_fragment_size * oss->write_nfragments; */ +/* s->write_lower_watermark = p->write_fragment_size; */ +/* s->write_upper_watermark = p->write_fragment_size * p->write_nfragments; */ /* } */ /* } */ if (s->mode & SA_MODE_RDONLY) - printf("Chosen for read: %u fragments, %u fragsize\n", oss->read_nfragments, oss->read_fragment_size); + printf("Chosen for read: %u fragments, %lu fragsize\n", p->read_nfragments, (unsigned long) p->read_fragment_size); if (s->mode & SA_MODE_WRONLY) - printf("Chosen for write: %u fragments, %u fragsize\n", oss->write_nfragments, oss->write_fragment_size); + printf("Chosen for write: %u fragments, %lu fragsize\n", p->write_nfragments, (unsigned long) p->write_fragment_size); - if (sa_bufferq_init(&oss->bufferq, s->ni_enabled ? s->pcm_attrs.nchannels : 1) < 0) + if (sa_bufferq_init(&p->bufferq, s->ni_enabled ? s->pcm_attrs.nchannels : 1) < 0) goto fail; - if ((oss->cdata = pa_new(void*, s->ni_enabled ? s->pcm_attrs.nchannels : 1) < 0) + if (!(p->cdata = sa_new(void*, s->ni_enabled ? s->pcm_attrs.nchannels : 1))) goto fail; return SA_SUCCESS; @@ -573,33 +610,33 @@ fail: return r; } -int driver_destroy(sa_stream_t *s) { - oss_stream_t *oss = OSS_STREAM(s); +int driver_destroy(sa_stream *s) { + struct private *p = PRIVATE(s); - if (oss) { + if (p) { - if (oss->thread) - driver_stop_thread(s); + if (p->thread) + sa_thread_free(p->thread); - if (oss->fd >= 0) - close(oss->fd); + if (p->fd >= 0) + close(p->fd); - sa_bufferq_done(&oss->bufferq); + sa_bufferq_done(&p->bufferq); - sa_free(oss->real_pcm_attrs.channel_map); - sa_converter_done(&oss->converter_read); - sa_converter_done(&oss->converter_write); + sa_free(p->real_pcm_attrs.channel_map); + sa_converter_done(&p->converter_read); + sa_converter_done(&p->converter_write); - sa_free(oss->cdata); + sa_free(p->cdata); - sa_free(oss); + sa_free(p); } return SA_SUCCESS; } -static int feed(sa_stream_t *s) { - oss_stream_t *oss = OSS_STREAM(s); +static int feed(sa_stream *s) { + struct private *p = PRIVATE(s); size_t w; int ret; @@ -613,8 +650,9 @@ static int feed(sa_stream_t *s) { size_t nbytes; uint8_t *d; sa_bool_t drop; + void *cdata; - sa_bufferq_get(&oss->bufferq, cdata, &nbytes); + sa_bufferq_get(&p->bufferq, cdata, &nbytes); if (nbytes > 0) { void **dst; @@ -622,11 +660,11 @@ static int feed(sa_stream_t *s) { if (s->ni_enabled) { - if ((ret = sa_converter_go(&oss->converter_write, cdata, &dst, &stride, +/* if ((ret = sa_converter_go(&p->converter_write, cdata, &dst, &stride, */ } else { - if ((ret = sa_converter_go_interleaved(&oss->converter_write, cdata, &dst, &stride, 1, &nbytes))) + if ((ret = sa_converter_go_interleaved(&p->converter_write, cdata, &dst, &stride, 1, &nbytes))) goto fail; d = dst[0]; @@ -636,11 +674,12 @@ static int feed(sa_stream_t *s) { s->state = SA_STATE_RUNNING; } else { - nbytes = w > oss->write_fragment_size ? oss->write_fragment_size : w; + nbytes = w > p->write_fragment_size ? p->write_fragment_size : w; - if (!(d = sa_converter_get_zero_buffer(&oss->converter_write, nbytes))) { + if (!(d = sa_converter_get_zero_buffer(&p->converter_write, nbytes))) { ret = SA_ERROR_OOM; goto fail; + } drop = s->xrun_mode == SA_XRUN_MODE_SPIN; @@ -651,7 +690,7 @@ static int feed(sa_stream_t *s) { while (nbytes > 0) { ssize_t l; - if ((l = write(oss->fd, d, nbytes)) < 0) { + if ((l = write(p->fd, d, nbytes)) < 0) { ret = SA_ERROR_SYSTEM; goto fail; } @@ -664,7 +703,7 @@ static int feed(sa_stream_t *s) { w -= 1; if (drop) - sa_bufferq_drop(&oss->bufferq, l); + sa_bufferq_drop(&p->bufferq, l); } } } @@ -673,21 +712,21 @@ static int feed(sa_stream_t *s) { fail: - sa_free(i); +/* sa_free(i); */ return ret; } enum { POLLFD_OSS_FD, - POLLFD_PIPE_FD, + POLLFD_SOCKET_FD, POLLFD_MAX }; static void thread_func(void *data) { struct pollfd pollfds[POLLFD_MAX]; - sa_stream_t *s = data; - oss_stream_t *oss = OSS_STREAM(s); + sa_stream *s = data; + struct private *p = PRIVATE(s); sigset_t mask; sa_assert_se(sigfillset(&mask) == 0); @@ -701,10 +740,10 @@ static void thread_func(void *data) { memset(pollfds, 0, sizeof(pollfds)); - pollfds[POLLFD_SOCKET_FD].fd = oss->socket_fds[0]; + pollfds[POLLFD_SOCKET_FD].fd = p->socket_fds[0]; pollfds[POLLFD_SOCKET_FD].events = POLLIN; - pollfds[POLLFD_OSS_FD].fd = oss->fd; + pollfds[POLLFD_OSS_FD].fd = p->fd; pollfds[POLLFD_OSS_FD].events = ((s->mode & SA_MODE_RDONLY) ? POLLIN : 0) | ((s->mode & SA_MODE_WRONLY) ? POLLOUT : 0); for (;;) { @@ -753,127 +792,127 @@ static void thread_func(void *data) { } } -int driver_start_thread(sa_stream_t *s, sa_event_callback_t callback) { - oss_stream_t *oss = OSS_STREAM(s); - sa_return_val_if_fail(!oss->thread, SA_ERROR_STATE); +/* int driver_start_thread(sa_stream *s, sa_event_callback_t callback) { */ +/* struct private *p = PRIVATE(s); */ +/* sa_return_val_if_fail(!p->thread, SA_ERROR_STATE); */ - s->callback = callback; +/* s->callback = callback; */ - if ((socketpair(AF_UNIX, SOCK_DGRAM, 0, oss->socket_fds)) < 0) - return SA_ERROR_SYSTEM; +/* if ((socketpair(AF_UNIX, SOCK_DGRAM, 0, p->socket_fds)) < 0) */ +/* return SA_ERROR_SYSTEM; */ - if (!(oss->thread = sa_thread_new(thread_func, s))) - return SA_ERROR_OOM; +/* if (!(p->thread = sa_thread_new(thread_func, s))) */ +/* return SA_ERROR_OOM; */ - return SA_SUCCESS; -} +/* return SA_SUCCESS; */ +/* } */ -int driver_stop_thread(sa_stream_t *s) { - oss_stream_t *oss = OSS_STREAM(s); - sa_return_val_if_fail(oss->thread, SA_ERROR_STATE); - sa_return_val_if_fail(oss->thread != sa_thread_self(), SA_ERROR_STATE); +/* int driver_stop_thread(sa_stream *s) { */ +/* struct private *p = PRIVATE(s); */ +/* sa_return_val_if_fail(p->thread, SA_ERROR_STATE); */ +/* sa_return_val_if_fail(p->thread != sa_thread_self(), SA_ERROR_STATE); */ - if (oss->socket_fds[0] >= 0) - close(oss->socket_fds[0]); +/* if (p->socket_fds[0] >= 0) */ +/* close(p->socket_fds[0]); */ - if (oss->socket_fds[1] >= 0) - close(oss->socket_fds[1]); +/* if (p->socket_fds[1] >= 0) */ +/* close(p->socket_fds[1]); */ - if (oss->thread) - sa_thread_free(oss->thread); +/* if (p->thread) */ +/* sa_thread_free(p->thread); */ - oss->thread = NULL; - oss->socket_fds[0] = oss->socket_fds[1] = -1; +/* p->thread = NULL; */ +/* p->socket_fds[0] = p->socket_fds[1] = -1; */ - return SA_SUCCESS; -} +/* return SA_SUCCESS; */ +/* } */ -int driver_change_read_volume(sa_stream_t *s, const int32_t vol[]) { - oss_stream_t *oss = OSS_STREAM(s); +int driver_change_read_volume(sa_stream *s, const int32_t vol[]) { + struct private *p = PRIVATE(s); - sa_return_val_if_fail(!s->codec, SA_ERROR_NOT_SUPPORTED); + sa_return_val_if_fail(!s->codec, SA_ERROR_NOTSUPPORTED); - sa_converter_set_volume(&oss->converter_read, vol); + sa_converter_set_volume(&p->converter_read, vol); return SA_SUCCESS; } -int driver_change_write_volume(sa_stream_t *s, const int32_t vol[]) { - oss_stream_t *oss = OSS_STREAM(s); +int driver_change_write_volume(sa_stream *s, const int32_t vol[]) { + struct private *p = PRIVATE(s); - sa_return_val_if_fail(!s->codec, SA_ERROR_NOT_SUPPORTED); + sa_return_val_if_fail(!s->codec, SA_ERROR_NOTSUPPORTED); - sa_converter_set_volume(&oss->converter_write, vol); + sa_converter_set_volume(&p->converter_write, vol); return SA_SUCCESS; } -int driver_change_rate(sa_stream_t *s, unsigned rate) { - oss_stream_t *oss = OSS_STREAM(s); +int driver_change_pcm_rate(sa_stream *s, unsigned rate) { + struct private *p = PRIVATE(s); if (s->mode & SA_MODE_RDONLY) - sa_converter_set_ratio(&oss->converter_read, oss->real_pcm_attrs.rate, s->pcm_attrs.rate); + sa_converter_set_ratio(&p->converter_read, p->real_pcm_attrs.rate, s->pcm_attrs.rate); if (s->mode & SA_MODE_WRONLY) - sa_converter_set_ratio(&oss->converter_write, s->pcm_attrs.rate, oss->real_pcm_attrs.rate); + sa_converter_set_ratio(&p->converter_write, s->pcm_attrs.rate, p->real_pcm_attrs.rate); return SA_SUCCESS; } -int driver_get_state(sa_stream_t *s, sa_state_t *state) { +int driver_get_state(sa_stream *s, sa_state_t *state) { *state = s->state; return SA_SUCCESS; } -int driver_get_position(sa_stream_t *s, sa_position_t position, int64_t *pos) { - return SA_ERROR_NOT_SUPPORTED; +int driver_get_position(sa_stream *s, sa_position_t position, int64_t *pos) { + return SA_ERROR_NOTSUPPORTED; } -int driver_read(sa_stream_t *s, void *data, size_t nbytes) { - return SA_ERROR_NOT_SUPPORTED; +int driver_read(sa_stream *s, void *data, size_t nbytes) { + return SA_ERROR_NOTSUPPORTED; } -int driver_pwrite(sa_stream_t *s, const void *data, size_t nbytes, int64_t offset, sa_seek_t whence) { - oss_stream_t *oss = OSS_STREAM(s); +int driver_pwrite(sa_stream *s, const void *data, size_t nbytes, int64_t offset, sa_seek_t whence) { + struct private *p = PRIVATE(s); int ret, ret2; - if ((ret = sa_bufferq_push(&oss->bufferq, 0, data, nbytes, offset, whence, SA_BUFFERQ_ITEM_STATIC))) + if ((ret = sa_bufferq_push(&p->bufferq, 0, data, nbytes, offset, whence, SA_BUFFERQ_ITEM_STATIC))) return ret; ret = feed(s); - ret2 = sa_bufferq_realloc(&oss->bufferq); + ret2 = sa_bufferq_realloc(&p->bufferq); return ret ? ret : ret2; } -int driver_read_ni(sa_stream_t *s, unsigned channel, void *data, size_t nbytes) { - return SA_ERROR_NOT_SUPPORTED; +int driver_read_ni(sa_stream *s, unsigned channel, void *data, size_t nbytes) { + return SA_ERROR_NOTSUPPORTED; } -int driver_pwrite_ni(sa_stream_t *s, unsigned channel, const void *data, size_t nbytes, int64_t offset, sa_seek_t whence) { - return SA_ERROR_NOT_SUPPORTED; +int driver_pwrite_ni(sa_stream *s, unsigned channel, const void *data, size_t nbytes, int64_t offset, sa_seek_t whence) { + return SA_ERROR_NOTSUPPORTED; } -int driver_get_read_size(sa_stream_t *s, size_t *size) { - return SA_ERROR_NOT_SUPPORTED; +int driver_get_read_size(sa_stream *s, size_t *size) { + return SA_ERROR_NOTSUPPORTED; } -int driver_get_write_size(sa_stream_t *s, size_t *size) { - return SA_ERROR_NOT_SUPPORTED; +int driver_get_write_size(sa_stream *s, size_t *size) { + return SA_ERROR_NOTSUPPORTED; } -int driver_resume(sa_stream_t *s) { - return SA_ERROR_NOT_SUPPORTED; +int driver_resume(sa_stream *s) { + return SA_ERROR_NOTSUPPORTED; } -int driver_pause(sa_stream_t *s) { - return SA_ERROR_NOT_SUPPORTED; +int driver_pause(sa_stream *s) { + return SA_ERROR_NOTSUPPORTED; } -int driver_drain(sa_stream_t *s) { - oss_stream_t *oss = OSS_STREAM(s); - sa_return_val_if_fail(!oss->thread, SA_ERROR_STATE); +int driver_drain(sa_stream *s) { + struct private *p = PRIVATE(s); + sa_return_val_if_fail(!p->thread, SA_ERROR_STATE); - if (ioctl(oss->fd, SNDCTL_DSP_SYNC, NULL) < 0) + if (ioctl(p->fd, SNDCTL_DSP_SYNC, NULL) < 0) return SA_ERROR_SYSTEM; return SA_SUCCESS; @@ -881,10 +920,6 @@ int driver_drain(sa_stream_t *s) { /* Unsupported operations */ -int driver_change_device(sa_stream_t *s, const char *device) { - return SA_ERROR_NOT_SUPPORTED; -} - -int driver_change_meta_data(sa_stream_t *s, const char *name, const void *data, size_t size) { - return SA_ERROR_NOT_SUPPORTED; +int driver_change_device(sa_stream *s, const char *device) { + return SA_ERROR_NOTSUPPORTED; } -- cgit