X-Git-Url: https://code.delx.au/pulseaudio/blobdiff_plain/4d623f0d4442148f20f2ffdc85cf95e54ef83721..5cc2187bec5923e13fb3958d57a5243aaa57b982:/src/modules/module-oss.c diff --git a/src/modules/module-oss.c b/src/modules/module-oss.c index bbb1e0d2..15b1e956 100644 --- a/src/modules/module-oss.c +++ b/src/modules/module-oss.c @@ -1,5 +1,3 @@ -/* $Id$ */ - /*** This file is part of PulseAudio. @@ -36,8 +34,6 @@ * */ -/* TODO: handle restoring of volume after suspend */ - #ifdef HAVE_CONFIG_H #include #endif @@ -57,6 +53,7 @@ #include #include #include +#include #include #include @@ -77,9 +74,10 @@ #include "oss-util.h" #include "module-oss-symdef.h" -PA_MODULE_AUTHOR("Lennart Poettering") -PA_MODULE_DESCRIPTION("OSS Sink/Source") -PA_MODULE_VERSION(PACKAGE_VERSION) +PA_MODULE_AUTHOR("Lennart Poettering"); +PA_MODULE_DESCRIPTION("OSS Sink/Source"); +PA_MODULE_VERSION(PACKAGE_VERSION); +PA_MODULE_LOAD_ONCE(FALSE); PA_MODULE_USAGE( "sink_name= " "source_name= " @@ -92,7 +90,7 @@ PA_MODULE_USAGE( "fragments= " "fragment_size= " "channel_map= " - "mmap=") + "mmap="); #define DEFAULT_DEVICE "/dev/dsp" @@ -101,30 +99,31 @@ struct userdata { pa_module *module; pa_sink *sink; pa_source *source; - + pa_thread *thread; pa_thread_mq thread_mq; pa_rtpoll *rtpoll; char *device_name; - + pa_memchunk memchunk; + size_t frame_size; uint32_t in_fragment_size, out_fragment_size, in_nfrags, out_nfrags, in_hwbuf_size, out_hwbuf_size; - int use_getospace, use_getispace; - int use_getodelay; + pa_bool_t use_getospace, use_getispace; + pa_bool_t use_getodelay; - int use_pcm_volume; - int use_input_volume; - - int sink_suspended, source_suspended; + pa_bool_t sink_suspended, source_suspended; int fd; int mode; + int mixer_fd; + int mixer_devmask; + int nfrags, frag_size; - int use_mmap; + pa_bool_t use_mmap; unsigned out_mmap_current, in_mmap_current; void *in_mmap, *out_mmap; pa_memblock **in_mmap_memblocks, **out_mmap_memblocks; @@ -150,22 +149,25 @@ static const char* const valid_modargs[] = { NULL }; -static void trigger(struct userdata *u, int quick) { +static void trigger(struct userdata *u, pa_bool_t quick) { int enable_bits = 0, zero = 0; pa_assert(u); - + if (u->fd < 0) return; -/* pa_log_debug("trigger"); */ + pa_log_debug("trigger"); - if (u->source && PA_SOURCE_OPENED(u->source->thread_info.state)) + if (u->source && PA_SOURCE_IS_OPENED(u->source->thread_info.state)) enable_bits |= PCM_ENABLE_INPUT; - - if (u->sink && PA_SINK_OPENED(u->sink->thread_info.state)) + + if (u->sink && PA_SINK_IS_OPENED(u->sink->thread_info.state)) enable_bits |= PCM_ENABLE_OUTPUT; - + + pa_log_debug("trigger: %i", enable_bits); + + if (u->use_mmap) { if (!quick) @@ -176,29 +178,29 @@ static void trigger(struct userdata *u, int quick) { if (ioctl(u->fd, SNDCTL_DSP_HALT, NULL) < 0) pa_log_warn("SNDCTL_DSP_HALT: %s", pa_cstrerror(errno)); #endif - + if (ioctl(u->fd, SNDCTL_DSP_SETTRIGGER, &enable_bits) < 0) pa_log_warn("SNDCTL_DSP_SETTRIGGER: %s", pa_cstrerror(errno)); - + if (u->sink && !(enable_bits & PCM_ENABLE_OUTPUT)) { pa_log_debug("clearing playback buffer"); pa_silence_memory(u->out_mmap, u->out_hwbuf_size, &u->sink->sample_spec); } - + } else { if (enable_bits) if (ioctl(u->fd, SNDCTL_DSP_POST, NULL) < 0) pa_log_warn("SNDCTL_DSP_POST: %s", pa_cstrerror(errno)); - + if (!quick) { /* * Some crappy drivers do not start the recording until we * read something. Without this snippet, poll will never * register the fd as ready. */ - - if (u->source && PA_SOURCE_OPENED(u->source->thread_info.state)) { + + if (u->source && PA_SOURCE_IS_OPENED(u->source->thread_info.state)) { uint8_t *buf = pa_xnew(uint8_t, u->in_fragment_size); pa_read(u->fd, buf, u->in_fragment_size, NULL); pa_xfree(buf); @@ -212,7 +214,7 @@ static void mmap_fill_memblocks(struct userdata *u, unsigned n) { pa_assert(u->out_mmap_memblocks); /* pa_log("Mmmap writing %u blocks", n); */ - + while (n > 0) { pa_memchunk chunk; @@ -241,12 +243,12 @@ static void mmap_fill_memblocks(struct userdata *u, unsigned n) { static int mmap_write(struct userdata *u) { struct count_info info; - + pa_assert(u); pa_assert(u->sink); /* pa_log("Mmmap writing..."); */ - + if (ioctl(u->fd, SNDCTL_DSP_GETOPTR, &info) < 0) { pa_log("SNDCTL_DSP_GETOPTR: %s", pa_cstrerror(errno)); return -1; @@ -257,7 +259,7 @@ static int mmap_write(struct userdata *u) { if (info.blocks > 0) mmap_fill_memblocks(u, info.blocks); - + return info.blocks; } @@ -271,14 +273,14 @@ static void mmap_post_memblocks(struct userdata *u, unsigned n) { pa_memchunk chunk; if (!u->in_mmap_memblocks[u->in_mmap_current]) { - + chunk.memblock = u->in_mmap_memblocks[u->in_mmap_current] = pa_memblock_new_fixed( u->core->mempool, (uint8_t*) u->in_mmap + u->in_fragment_size*u->in_mmap_current, u->in_fragment_size, 1); - + chunk.length = pa_memblock_get_length(chunk.memblock); chunk.index = 0; @@ -295,7 +297,7 @@ static void mmap_post_memblocks(struct userdata *u, unsigned n) { static void mmap_clear_memblocks(struct userdata*u, unsigned n) { unsigned i = u->in_mmap_current; - + pa_assert(u); pa_assert(u->in_mmap_memblocks); @@ -322,12 +324,14 @@ static int mmap_read(struct userdata *u) { pa_assert(u->source); /* pa_log("Mmmap reading..."); */ - + if (ioctl(u->fd, SNDCTL_DSP_GETIPTR, &info) < 0) { pa_log("SNDCTL_DSP_GETIPTR: %s", pa_cstrerror(errno)); return -1; } +/* pa_log("... %i", info.blocks); */ + info.blocks += u->in_mmap_saved_nfrags; u->in_mmap_saved_nfrags = 0; @@ -335,14 +339,14 @@ static int mmap_read(struct userdata *u) { mmap_post_memblocks(u, info.blocks); mmap_clear_memblocks(u, u->in_nfrags/2); } - + return info.blocks; } static pa_usec_t mmap_sink_get_latency(struct userdata *u) { struct count_info info; size_t bpos, n; - + pa_assert(u); if (ioctl(u->fd, SNDCTL_DSP_GETOPTR, &info) < 0) { @@ -390,23 +394,23 @@ static pa_usec_t mmap_source_get_latency(struct userdata *u) { static pa_usec_t io_sink_get_latency(struct userdata *u) { pa_usec_t r = 0; - + pa_assert(u); - + if (u->use_getodelay) { int arg; - + if (ioctl(u->fd, SNDCTL_DSP_GETODELAY, &arg) < 0) { pa_log_info("Device doesn't support SNDCTL_DSP_GETODELAY: %s", pa_cstrerror(errno)); u->use_getodelay = 0; } else r = pa_bytes_to_usec(arg, &u->sink->sample_spec); - + } - + if (!u->use_getodelay && u->use_getospace) { struct audio_buf_info info; - + if (ioctl(u->fd, SNDCTL_DSP_GETOSPACE, &info) < 0) { pa_log_info("Device doesn't support SNDCTL_DSP_GETOSPACE: %s", pa_cstrerror(errno)); u->use_getospace = 0; @@ -423,9 +427,9 @@ static pa_usec_t io_sink_get_latency(struct userdata *u) { static pa_usec_t io_source_get_latency(struct userdata *u) { pa_usec_t r = 0; - + pa_assert(u); - + if (u->use_getispace) { struct audio_buf_info info; @@ -439,12 +443,28 @@ static pa_usec_t io_source_get_latency(struct userdata *u) { return r; } +static void build_pollfd(struct userdata *u) { + struct pollfd *pollfd; + + pa_assert(u); + pa_assert(u->fd >= 0); + + if (u->rtpoll_item) + pa_rtpoll_item_free(u->rtpoll_item); + + u->rtpoll_item = pa_rtpoll_item_new(u->rtpoll, PA_RTPOLL_NEVER, 1); + pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL); + pollfd->fd = u->fd; + pollfd->events = 0; + pollfd->revents = 0; +} + static int suspend(struct userdata *u) { pa_assert(u); pa_assert(u->fd >= 0); pa_log_info("Suspending..."); - + if (u->out_mmap_memblocks) { unsigned i; for (i = 0; i < u->out_nfrags; i++) @@ -462,12 +482,12 @@ static int suspend(struct userdata *u) { u->in_mmap_memblocks[i] = NULL; } } - + if (u->in_mmap && u->in_mmap != MAP_FAILED) { munmap(u->in_mmap, u->in_hwbuf_size); u->in_mmap = NULL; } - + if (u->out_mmap && u->out_mmap != MAP_FAILED) { munmap(u->out_mmap, u->out_hwbuf_size); u->out_mmap = NULL; @@ -475,26 +495,28 @@ static int suspend(struct userdata *u) { /* Let's suspend */ ioctl(u->fd, SNDCTL_DSP_SYNC, NULL); - close(u->fd); + pa_close(u->fd); u->fd = -1; if (u->rtpoll_item) { pa_rtpoll_item_free(u->rtpoll_item); u->rtpoll_item = NULL; } - + pa_log_info("Device suspended..."); - + return 0; } +static int sink_get_volume(pa_sink *s); +static int source_get_volume(pa_source *s); + static int unsuspend(struct userdata *u) { int m; pa_sample_spec ss, *ss_original; int frag_size, in_frag_size, out_frag_size; int in_nfrags, out_nfrags; struct audio_buf_info info; - struct pollfd *pollfd; pa_assert(u); pa_assert(u->fd < 0); @@ -566,7 +588,7 @@ static int unsuspend(struct userdata *u) { goto fail; } - + pa_silence_memory(u->out_mmap, u->out_hwbuf_size, &ss); } } @@ -575,26 +597,28 @@ static int unsuspend(struct userdata *u) { u->out_mmap_saved_nfrags = u->in_mmap_saved_nfrags = 0; pa_assert(!u->rtpoll_item); - - u->rtpoll_item = pa_rtpoll_item_new(u->rtpoll, 1); - pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL); - pollfd->fd = u->fd; - pollfd->events = 0; - pollfd->revents = 0; + + build_pollfd(u); + + if (u->sink) + sink_get_volume(u->sink); + if (u->source) + source_get_volume(u->source); pa_log_info("Resumed successfully..."); return 0; fail: - close(u->fd); + pa_close(u->fd); u->fd = -1; return -1; } static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) { struct userdata *u = PA_SINK(o)->userdata; - int do_trigger = 0, ret, quick = 1; + int ret; + pa_bool_t do_trigger = FALSE, quick = TRUE; switch (code) { @@ -618,35 +642,40 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse switch ((pa_sink_state_t) PA_PTR_TO_UINT(data)) { case PA_SINK_SUSPENDED: - pa_assert(PA_SINK_OPENED(u->sink->thread_info.state)); + pa_assert(PA_SINK_IS_OPENED(u->sink->thread_info.state)); if (!u->source || u->source_suspended) { if (suspend(u) < 0) return -1; - } + } - do_trigger = 1; + do_trigger = TRUE; - u->sink_suspended = 1; + u->sink_suspended = TRUE; break; - + case PA_SINK_IDLE: case PA_SINK_RUNNING: - + + if (u->sink->thread_info.state == PA_SINK_INIT) { + do_trigger = TRUE; + quick = u->source && PA_SOURCE_IS_OPENED(u->source->thread_info.state); + } + if (u->sink->thread_info.state == PA_SINK_SUSPENDED) { - + if (!u->source || u->source_suspended) { - if (unsuspend(u) < 0) + if (unsuspend(u) < 0) return -1; - quick = 0; + quick = FALSE; } - do_trigger = 1; - + do_trigger = TRUE; + u->out_mmap_current = 0; u->out_mmap_saved_nfrags = 0; - - u->sink_suspended = 0; + + u->sink_suspended = FALSE; } break; @@ -655,47 +684,23 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse case PA_SINK_INIT: ; } - - break; - - case PA_SINK_MESSAGE_SET_VOLUME: - - if (u->use_pcm_volume && u->fd >= 0) { - - if (pa_oss_set_pcm_volume(u->fd, &u->sink->sample_spec, ((pa_cvolume*) data)) < 0) { - pa_log_info("Device doesn't support setting mixer settings: %s", pa_cstrerror(errno)); - u->use_pcm_volume = 0; - } else - return 0; - } break; - case PA_SINK_MESSAGE_GET_VOLUME: - - if (u->use_pcm_volume && u->fd >= 0) { - - if (pa_oss_get_pcm_volume(u->fd, &u->sink->sample_spec, ((pa_cvolume*) data)) < 0) { - pa_log_info("Device doesn't support reading mixer settings: %s", pa_cstrerror(errno)); - u->use_pcm_volume = 0; - } else - return 0; - } - - break; } ret = pa_sink_process_msg(o, code, data, offset, chunk); if (do_trigger) trigger(u, quick); - + return ret; } static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) { struct userdata *u = PA_SOURCE(o)->userdata; - int do_trigger = 0, ret, quick = 1; + int ret; + int do_trigger = FALSE, quick = TRUE; switch (code) { @@ -708,44 +713,49 @@ static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t off else r = io_source_get_latency(u); } - + *((pa_usec_t*) data) = r; - break; + return 0; } case PA_SOURCE_MESSAGE_SET_STATE: switch ((pa_source_state_t) PA_PTR_TO_UINT(data)) { case PA_SOURCE_SUSPENDED: - pa_assert(PA_SOURCE_OPENED(u->source->thread_info.state)); + pa_assert(PA_SOURCE_IS_OPENED(u->source->thread_info.state)); if (!u->sink || u->sink_suspended) { - if (suspend(u) < 0) + if (suspend(u) < 0) return -1; - } + } - do_trigger = 1; - - u->source_suspended = 1; + do_trigger = TRUE; + + u->source_suspended = TRUE; break; case PA_SOURCE_IDLE: case PA_SOURCE_RUNNING: - + + if (u->source->thread_info.state == PA_SOURCE_INIT) { + do_trigger = TRUE; + quick = u->sink && PA_SINK_IS_OPENED(u->sink->thread_info.state); + } + if (u->source->thread_info.state == PA_SOURCE_SUSPENDED) { if (!u->sink || u->sink_suspended) { - if (unsuspend(u) < 0) + if (unsuspend(u) < 0) return -1; - quick = 0; - } + quick = FALSE; + } + + do_trigger = TRUE; - do_trigger = 1; - u->in_mmap_current = 0; u->in_mmap_saved_nfrags = 0; - - u->source_suspended = 0; + + u->source_suspended = FALSE; } break; @@ -756,39 +766,94 @@ static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t off } break; - case PA_SOURCE_MESSAGE_SET_VOLUME: + } - if (u->use_input_volume && u->fd >= 0) { + ret = pa_source_process_msg(o, code, data, offset, chunk); - if (pa_oss_set_input_volume(u->fd, &u->source->sample_spec, ((pa_cvolume*) data)) < 0) { - pa_log_info("Device doesn't support setting mixer settings: %s", pa_cstrerror(errno)); - u->use_input_volume = 0; - } else - return 0; - } + if (do_trigger) + trigger(u, quick); - break; + return ret; +} - case PA_SOURCE_MESSAGE_GET_VOLUME: +static int sink_get_volume(pa_sink *s) { + struct userdata *u; + int r; - if (u->use_input_volume && u->fd >= 0) { + pa_assert_se(u = s->userdata); - if (pa_oss_get_input_volume(u->fd, &u->source->sample_spec, ((pa_cvolume*) data)) < 0) { - pa_log_info("Device doesn't support reading mixer settings: %s", pa_cstrerror(errno)); - u->use_input_volume = 0; - } else - return 0; - } + pa_assert(u->mixer_devmask & (SOUND_MASK_VOLUME|SOUND_MASK_PCM)); - break; - } + if (u->mixer_devmask & SOUND_MASK_VOLUME) + if ((r = pa_oss_get_volume(u->mixer_fd, SOUND_MIXER_READ_VOLUME, &s->sample_spec, &s->volume)) >= 0) + return r; - ret = pa_source_process_msg(o, code, data, offset, chunk); + if (u->mixer_devmask & SOUND_MASK_PCM) + if ((r = pa_oss_get_volume(u->mixer_fd, SOUND_MIXER_READ_PCM, &s->sample_spec, &s->volume)) >= 0) + return r; - if (do_trigger) - trigger(u, quick); + pa_log_info("Device doesn't support reading mixer settings: %s", pa_cstrerror(errno)); + return -1; +} - return ret; +static int sink_set_volume(pa_sink *s) { + struct userdata *u; + int r; + + pa_assert_se(u = s->userdata); + + pa_assert(u->mixer_devmask & (SOUND_MASK_VOLUME|SOUND_MASK_PCM)); + + if (u->mixer_devmask & SOUND_MASK_VOLUME) + if ((r = pa_oss_set_volume(u->mixer_fd, SOUND_MIXER_WRITE_VOLUME, &s->sample_spec, &s->volume)) >= 0) + return r; + + if (u->mixer_devmask & SOUND_MASK_PCM) + if ((r = pa_oss_get_volume(u->mixer_fd, SOUND_MIXER_WRITE_PCM, &s->sample_spec, &s->volume)) >= 0) + return r; + + pa_log_info("Device doesn't support writing mixer settings: %s", pa_cstrerror(errno)); + return -1; +} + +static int source_get_volume(pa_source *s) { + struct userdata *u; + int r; + + pa_assert_se(u = s->userdata); + + pa_assert(u->mixer_devmask & (SOUND_MASK_IGAIN|SOUND_MASK_RECLEV)); + + if (u->mixer_devmask & SOUND_MASK_IGAIN) + if ((r = pa_oss_get_volume(u->mixer_fd, SOUND_MIXER_READ_IGAIN, &s->sample_spec, &s->volume)) >= 0) + return r; + + if (u->mixer_devmask & SOUND_MASK_RECLEV) + if ((r = pa_oss_get_volume(u->mixer_fd, SOUND_MIXER_READ_RECLEV, &s->sample_spec, &s->volume)) >= 0) + return r; + + pa_log_info("Device doesn't support reading mixer settings: %s", pa_cstrerror(errno)); + return -1; +} + +static int source_set_volume(pa_source *s) { + struct userdata *u; + int r; + + pa_assert_se(u = s->userdata); + + pa_assert(u->mixer_devmask & (SOUND_MASK_IGAIN|SOUND_MASK_RECLEV)); + + if (u->mixer_devmask & SOUND_MASK_IGAIN) + if ((r = pa_oss_set_volume(u->mixer_fd, SOUND_MIXER_WRITE_IGAIN, &s->sample_spec, &s->volume)) >= 0) + return r; + + if (u->mixer_devmask & SOUND_MASK_RECLEV) + if ((r = pa_oss_get_volume(u->mixer_fd, SOUND_MIXER_WRITE_RECLEV, &s->sample_spec, &s->volume)) >= 0) + return r; + + pa_log_info("Device doesn't support writing mixer settings: %s", pa_cstrerror(errno)); + return -1; } static void thread_func(void *userdata) { @@ -800,22 +865,24 @@ static void thread_func(void *userdata) { pa_log_debug("Thread starting up"); - if (u->core->high_priority) - pa_make_realtime(); + if (u->core->realtime_scheduling) + pa_make_realtime(u->core->realtime_priority); pa_thread_mq_install(&u->thread_mq); pa_rtpoll_install(u->rtpoll); - trigger(u, 0); - for (;;) { int ret; /* pa_log("loop"); */ - + + if (PA_SINK_IS_OPENED(u->sink->thread_info.state)) + if (u->sink->thread_info.rewind_requested) + pa_sink_process_rewind(u->sink, 0); + /* Render some data and write it to the dsp */ - if (u->sink && u->sink->thread_info.state != PA_SINK_UNLINKED && u->fd >= 0 && (revents & POLLOUT)) { + if (u->sink && PA_SINK_IS_OPENED(u->sink->thread_info.state) && ((revents & POLLOUT) || u->use_mmap || u->use_getospace)) { if (u->use_mmap) { @@ -823,89 +890,107 @@ static void thread_func(void *userdata) { goto fail; revents &= ~POLLOUT; - + if (ret > 0) continue; } else { ssize_t l; - int loop = 0; - + pa_bool_t loop = FALSE, work_done = FALSE; + l = u->out_fragment_size; - + if (u->use_getospace) { audio_buf_info info; - + if (ioctl(u->fd, SNDCTL_DSP_GETOSPACE, &info) < 0) { pa_log_info("Device doesn't support SNDCTL_DSP_GETOSPACE: %s", pa_cstrerror(errno)); - u->use_getospace = 0; + u->use_getospace = FALSE; } else { - if (info.bytes >= l) { - l = (info.bytes/l)*l; - loop = 1; - } + l = info.bytes; + + /* We loop only if GETOSPACE worked and we + * actually *know* that we can write more than + * one fragment at a time */ + loop = TRUE; } } - - do { + + /* Round down to multiples of the fragment size, + * because OSS needs that (at least some versions + * do) */ + l = (l/u->out_fragment_size) * u->out_fragment_size; + + /* Hmm, so poll() signalled us that we can read + * something, but GETOSPACE told us there was nothing? + * Hmm, make the best of it, try to read some data, to + * avoid spinning forever. */ + if (l <= 0 && (revents & POLLOUT)) { + l = u->out_fragment_size; + loop = FALSE; + } + + while (l > 0) { void *p; ssize_t t; - - pa_assert(l > 0); - + if (u->memchunk.length <= 0) pa_sink_render(u->sink, l, &u->memchunk); - + pa_assert(u->memchunk.length > 0); - + p = pa_memblock_acquire(u->memchunk.memblock); t = pa_write(u->fd, (uint8_t*) p + u->memchunk.index, u->memchunk.length, &write_type); pa_memblock_release(u->memchunk.memblock); - + /* pa_log("wrote %i bytes of %u", t, l); */ - + pa_assert(t != 0); - + if (t < 0) { - + if (errno == EINTR) continue; - + else if (errno == EAGAIN) { - pa_log_debug("EAGAIN"); - + pa_log_debug("EAGAIN"); + revents &= ~POLLOUT; break; - + } else { pa_log("Failed to write data to DSP: %s", pa_cstrerror(errno)); goto fail; } - + } else { - + u->memchunk.index += t; u->memchunk.length -= t; - + if (u->memchunk.length <= 0) { pa_memblock_unref(u->memchunk.memblock); pa_memchunk_reset(&u->memchunk); } - + l -= t; - + revents &= ~POLLOUT; + work_done = TRUE; } - - } while (loop && l > 0); - - continue; + + if (!loop) + break; + } + + if (work_done) + continue; } } - /* Try to read some data and pass it on to the source driver */ + /* Try to read some data and pass it on to the source driver. */ - if (u->source && u->source->thread_info.state != PA_SOURCE_UNLINKED && u->fd >= 0 && ((revents & POLLIN))) { + if (u->source && PA_SOURCE_IS_OPENED(u->source->thread_info.state) && ((revents & POLLIN) || u->use_mmap || u->use_getispace)) { if (u->use_mmap) { @@ -913,7 +998,7 @@ static void thread_func(void *userdata) { goto fail; revents &= ~POLLIN; - + if (ret > 0) continue; @@ -922,7 +1007,7 @@ static void thread_func(void *userdata) { void *p; ssize_t l; pa_memchunk memchunk; - int loop = 0; + pa_bool_t loop = FALSE, work_done = FALSE; l = u->in_fragment_size; @@ -931,30 +1016,42 @@ static void thread_func(void *userdata) { if (ioctl(u->fd, SNDCTL_DSP_GETISPACE, &info) < 0) { pa_log_info("Device doesn't support SNDCTL_DSP_GETISPACE: %s", pa_cstrerror(errno)); - u->use_getispace = 0; + u->use_getispace = FALSE; } else { - if (info.bytes >= l) { - l = (info.bytes/l)*l; - loop = 1; - } + l = info.bytes; + loop = TRUE; } } - do { - ssize_t t; + l = (l/u->in_fragment_size) * u->in_fragment_size; + + if (l <= 0 && (revents & POLLIN)) { + l = u->in_fragment_size; + loop = FALSE; + } + + while (l > 0) { + ssize_t t, k; pa_assert(l > 0); - memchunk.memblock = pa_memblock_new(u->core->mempool, l); + memchunk.memblock = pa_memblock_new(u->core->mempool, (size_t) -1); + + k = pa_memblock_get_length(memchunk.memblock); + + if (k > l) + k = l; + + k = (k/u->frame_size)*u->frame_size; p = pa_memblock_acquire(memchunk.memblock); - t = pa_read(u->fd, p, l, &read_type); + t = pa_read(u->fd, p, k, &read_type); pa_memblock_release(memchunk.memblock); pa_assert(t != 0); /* EOF cannot happen */ /* pa_log("read %i bytes of %u", t, l); */ - + if (t < 0) { pa_memblock_unref(memchunk.memblock); @@ -962,7 +1059,7 @@ static void thread_func(void *userdata) { continue; else if (errno == EAGAIN) { - pa_log_debug("EAGAIN"); + pa_log_debug("EAGAIN"); revents &= ~POLLIN; break; @@ -982,53 +1079,43 @@ static void thread_func(void *userdata) { l -= t; revents &= ~POLLIN; + work_done = TRUE; } - } while (loop && l > 0); - continue; + if (!loop) + break; + } + + if (work_done) + continue; } } -/* pa_log("loop2"); */ - - /* Now give the sink inputs some to time to process their data */ - if ((ret = pa_sink_process_inputs(u->sink)) < 0) - goto fail; - if (ret > 0) - continue; +/* pa_log("loop2 revents=%i", revents); */ - /* Now give the source outputs some to time to process their data */ - if ((ret = pa_source_process_outputs(u->source)) < 0) - goto fail; - if (ret > 0) - continue; - - /* Check whether there is a message for us to process */ - if ((ret = pa_thread_mq_process(&u->thread_mq) < 0)) - goto finish; - if (ret > 0) - continue; - - if (u->fd >= 0) { + if (u->rtpoll_item) { struct pollfd *pollfd; + pa_assert(u->fd >= 0); + pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL); pollfd->events = - ((u->source && PA_SOURCE_OPENED(u->source->thread_info.state)) ? POLLIN : 0) | - ((u->sink && PA_SINK_OPENED(u->sink->thread_info.state)) ? POLLOUT : 0); + ((u->source && PA_SOURCE_IS_OPENED(u->source->thread_info.state)) ? POLLIN : 0) | + ((u->sink && PA_SINK_IS_OPENED(u->sink->thread_info.state)) ? POLLOUT : 0); } - + /* Hmm, nothing to do. Let's sleep */ - if (pa_rtpoll_run(u->rtpoll) < 0) { - pa_log("poll() failed: %s", pa_cstrerror(errno)); + if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0) goto fail; - } - if (u->fd >= 0) { + if (ret == 0) + goto finish; + + if (u->rtpoll_item) { struct pollfd *pollfd; - + pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL); - + if (pollfd->revents & ~(POLLOUT|POLLIN)) { pa_log("DSP shutdown."); goto fail; @@ -1040,8 +1127,8 @@ static void thread_func(void *userdata) { } fail: - /* We have to continue processing messages until we receive the - * SHUTDOWN message */ + /* If this was no regular exit from the loop we have to continue + * processing messages until we received PA_MESSAGE_SHUTDOWN */ pa_asyncmsgq_post(u->thread_mq.outq, PA_MSGOBJECT(u->core), PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0, NULL, NULL); pa_asyncmsgq_wait_for(u->thread_mq.inq, PA_MESSAGE_SHUTDOWN); @@ -1050,21 +1137,22 @@ finish: } int pa__init(pa_module*m) { - + struct audio_buf_info info; struct userdata *u = NULL; const char *dev; int fd = -1; int nfrags, frag_size; int mode, caps; - int record = 1, playback = 1, use_mmap = 1; + pa_bool_t record = TRUE, playback = TRUE, use_mmap = TRUE; pa_sample_spec ss; pa_channel_map map; pa_modargs *ma = NULL; - char hwdesc[64], *t; + char hwdesc[64]; const char *name; - int namereg_fail; - struct pollfd *pollfd; + pa_bool_t namereg_fail; + pa_sink_new_data sink_new_data; + pa_source_new_data source_new_data; pa_assert(m); @@ -1074,7 +1162,7 @@ int pa__init(pa_module*m) { } if (pa_modargs_get_value_boolean(ma, "record", &record) < 0 || pa_modargs_get_value_boolean(ma, "playback", &playback) < 0) { - pa_log("record= and playback= expect numeric argument."); + pa_log("record= and playback= expect boolean argument."); goto fail; } @@ -1105,7 +1193,7 @@ int pa__init(pa_module*m) { pa_log("Failed to parse mmap argument."); goto fail; } - + if ((fd = pa_oss_open(dev = pa_modargs_get_value(ma, "device", DEFAULT_DEVICE), &mode, &caps)) < 0) goto fail; @@ -1113,7 +1201,7 @@ int pa__init(pa_module*m) { pa_log_info("OSS device not mmap capable, falling back to UNIX read/write mode."); use_mmap = 0; } - + if (use_mmap && mode == O_WRONLY) { pa_log_info("Device opened for playback only, cannot do memory mapping, falling back to UNIX write() mode."); use_mmap = 0; @@ -1144,61 +1232,74 @@ int pa__init(pa_module*m) { u->module = m; m->userdata = u; u->fd = fd; - u->use_getospace = u->use_getispace = 1; - u->use_getodelay = 1; - u->use_input_volume = u->use_pcm_volume = 1; + u->mixer_fd = -1; + u->use_getospace = u->use_getispace = TRUE; + u->use_getodelay = TRUE; u->mode = mode; + u->frame_size = pa_frame_size(&ss); u->device_name = pa_xstrdup(dev); u->in_nfrags = u->out_nfrags = u->nfrags = nfrags; u->out_fragment_size = u->in_fragment_size = u->frag_size = frag_size; u->use_mmap = use_mmap; - pa_thread_mq_init(&u->thread_mq, m->core->mainloop); u->rtpoll = pa_rtpoll_new(); - pa_rtpoll_item_new_asyncmsgq(u->rtpoll, u->thread_mq.inq); - u->rtpoll_item = pa_rtpoll_item_new(u->rtpoll, 1); - pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL); - pollfd->fd = fd; - pollfd->events = 0; - pollfd->revents = 0; - + pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll); + u->rtpoll_item = NULL; + build_pollfd(u); + if (ioctl(fd, SNDCTL_DSP_GETISPACE, &info) >= 0) { pa_log_info("Input -- %u fragments of size %u.", info.fragstotal, info.fragsize); u->in_fragment_size = info.fragsize; u->in_nfrags = info.fragstotal; - u->use_getispace = 1; + u->use_getispace = TRUE; } if (ioctl(fd, SNDCTL_DSP_GETOSPACE, &info) >= 0) { pa_log_info("Output -- %u fragments of size %u.", info.fragstotal, info.fragsize); u->out_fragment_size = info.fragsize; u->out_nfrags = info.fragstotal; - u->use_getospace = 1; + u->use_getospace = TRUE; } u->in_hwbuf_size = u->in_nfrags * u->in_fragment_size; u->out_hwbuf_size = u->out_nfrags * u->out_fragment_size; - + if (mode != O_WRONLY) { char *name_buf = NULL; if (use_mmap) { if ((u->in_mmap = mmap(NULL, u->in_hwbuf_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) { pa_log_warn("mmap(PROT_READ) failed, reverting to non-mmap mode: %s", pa_cstrerror(errno)); - use_mmap = u->use_mmap = 0; + use_mmap = u->use_mmap = FALSE; u->in_mmap = NULL; } else pa_log_debug("Successfully mmap()ed input buffer."); } if ((name = pa_modargs_get_value(ma, "source_name", NULL))) - namereg_fail = 1; + namereg_fail = TRUE; else { name = name_buf = pa_sprintf_malloc("oss_input.%s", pa_path_get_filename(dev)); - namereg_fail = 0; + namereg_fail = FALSE; } - u->source = pa_source_new(m->core, __FILE__, name, namereg_fail, &ss, &map); + pa_source_new_data_init(&source_new_data); + source_new_data.driver = __FILE__; + source_new_data.module = m; + pa_source_new_data_set_name(&source_new_data, name); + source_new_data.namereg_fail = namereg_fail; + pa_source_new_data_set_sample_spec(&source_new_data, &ss); + pa_source_new_data_set_channel_map(&source_new_data, &map); + pa_proplist_sets(source_new_data.proplist, PA_PROP_DEVICE_STRING, dev); + pa_proplist_sets(source_new_data.proplist, PA_PROP_DEVICE_API, "oss"); + pa_proplist_sets(source_new_data.proplist, PA_PROP_DEVICE_DESCRIPTION, hwdesc[0] ? hwdesc : dev); + pa_proplist_sets(source_new_data.proplist, PA_PROP_DEVICE_ACCESS_MODE, use_mmap ? "mmap" : "serial"); + pa_proplist_setf(source_new_data.proplist, PA_PROP_DEVICE_BUFFERING_BUFFER_SIZE, "%lu", (unsigned long) (u->in_hwbuf_size)); + pa_proplist_setf(source_new_data.proplist, PA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZE, "%lu", (unsigned long) (u->in_fragment_size)); + + u->source = pa_source_new(m->core, &source_new_data, PA_SOURCE_HARDWARE|PA_SOURCE_LATENCY); + pa_source_new_data_done(&source_new_data); pa_xfree(name_buf); + if (!u->source) { pa_log("Failed to create source object"); goto fail; @@ -1207,19 +1308,9 @@ int pa__init(pa_module*m) { u->source->parent.process_msg = source_process_msg; u->source->userdata = u; - pa_source_set_module(u->source, m); pa_source_set_asyncmsgq(u->source, u->thread_mq.inq); pa_source_set_rtpoll(u->source, u->rtpoll); - pa_source_set_description(u->source, t = pa_sprintf_malloc( - "OSS PCM on %s%s%s%s%s", - dev, - hwdesc[0] ? " (" : "", - hwdesc[0] ? hwdesc : "", - hwdesc[0] ? ")" : "", - use_mmap ? " via DMA" : "")); - pa_xfree(t); - u->source->flags = PA_SOURCE_HARDWARE|PA_SOURCE_CAN_SUSPEND|PA_SOURCE_LATENCY|PA_SOURCE_HW_VOLUME_CTRL; - u->source->refresh_volume = 1; + u->source->refresh_volume = TRUE; if (use_mmap) u->in_mmap_memblocks = pa_xnew0(pa_memblock*, u->in_nfrags); @@ -1236,7 +1327,7 @@ int pa__init(pa_module*m) { goto go_on; } else { pa_log_warn("mmap(PROT_WRITE) failed, reverting to non-mmap mode: %s", pa_cstrerror(errno)); - u->use_mmap = use_mmap = 0; + u->use_mmap = use_mmap = FALSE; u->out_mmap = NULL; } } else { @@ -1244,16 +1335,32 @@ int pa__init(pa_module*m) { pa_silence_memory(u->out_mmap, u->out_hwbuf_size, &ss); } } - + if ((name = pa_modargs_get_value(ma, "sink_name", NULL))) - namereg_fail = 1; + namereg_fail = TRUE; else { name = name_buf = pa_sprintf_malloc("oss_output.%s", pa_path_get_filename(dev)); - namereg_fail = 0; + namereg_fail = FALSE; } - u->sink = pa_sink_new(m->core, __FILE__, name, namereg_fail, &ss, &map); + pa_sink_new_data_init(&sink_new_data); + sink_new_data.driver = __FILE__; + sink_new_data.module = m; + pa_sink_new_data_set_name(&sink_new_data, name); + sink_new_data.namereg_fail = namereg_fail; + pa_sink_new_data_set_sample_spec(&sink_new_data, &ss); + pa_sink_new_data_set_channel_map(&sink_new_data, &map); + pa_proplist_sets(sink_new_data.proplist, PA_PROP_DEVICE_STRING, dev); + pa_proplist_sets(sink_new_data.proplist, PA_PROP_DEVICE_API, "oss"); + pa_proplist_sets(sink_new_data.proplist, PA_PROP_DEVICE_DESCRIPTION, hwdesc[0] ? hwdesc : dev); + pa_proplist_sets(sink_new_data.proplist, PA_PROP_DEVICE_ACCESS_MODE, use_mmap ? "mmap" : "serial"); + pa_proplist_setf(sink_new_data.proplist, PA_PROP_DEVICE_BUFFERING_BUFFER_SIZE, "%lu", (unsigned long) (u->out_hwbuf_size)); + pa_proplist_setf(sink_new_data.proplist, PA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZE, "%lu", (unsigned long) (u->out_fragment_size)); + + u->sink = pa_sink_new(m->core, &sink_new_data, PA_SINK_HARDWARE|PA_SINK_LATENCY); + pa_sink_new_data_done(&sink_new_data); pa_xfree(name_buf); + if (!u->sink) { pa_log("Failed to create sink object"); goto fail; @@ -1261,27 +1368,50 @@ int pa__init(pa_module*m) { u->sink->parent.process_msg = sink_process_msg; u->sink->userdata = u; - - pa_sink_set_module(u->sink, m); + pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq); pa_sink_set_rtpoll(u->sink, u->rtpoll); - pa_sink_set_description(u->sink, t = pa_sprintf_malloc( - "OSS PCM on %s%s%s%s%s", - dev, - hwdesc[0] ? " (" : "", - hwdesc[0] ? hwdesc : "", - hwdesc[0] ? ")" : "", - use_mmap ? " via DMA" : "")); - pa_xfree(t); - u->sink->flags = PA_SINK_HARDWARE|PA_SINK_CAN_SUSPEND|PA_SINK_LATENCY|PA_SINK_HW_VOLUME_CTRL; - u->sink->refresh_volume = 1; + u->sink->refresh_volume = TRUE; + + u->sink->thread_info.max_request = u->out_hwbuf_size; if (use_mmap) u->out_mmap_memblocks = pa_xnew0(pa_memblock*, u->out_nfrags); } + if ((u->mixer_fd = pa_oss_open_mixer_for_device(u->device_name)) >= 0) { + pa_bool_t do_close = TRUE; + u->mixer_devmask = 0; + + if (ioctl(fd, SOUND_MIXER_READ_DEVMASK, &u->mixer_devmask) < 0) + pa_log_warn("SOUND_MIXER_READ_DEVMASK failed: %s", pa_cstrerror(errno)); + + else { + if (u->sink && (u->mixer_devmask & (SOUND_MASK_VOLUME|SOUND_MASK_PCM))) { + pa_log_debug("Found hardware mixer track for playback."); + u->sink->flags |= PA_SINK_HW_VOLUME_CTRL; + u->sink->get_volume = sink_get_volume; + u->sink->set_volume = sink_set_volume; + do_close = FALSE; + } + + if (u->source && (u->mixer_devmask & (SOUND_MASK_RECLEV|SOUND_MASK_IGAIN))) { + pa_log_debug("Found hardware mixer track for recording."); + u->source->flags |= PA_SOURCE_HW_VOLUME_CTRL; + u->source->get_volume = source_get_volume; + u->source->set_volume = source_set_volume; + do_close = FALSE; + } + } + + if (do_close) { + pa_close(u->mixer_fd); + u->mixer_fd = -1; + } + } + go_on: - + pa_assert(u->source || u->sink); pa_memchunk_reset(&u->memchunk); @@ -1292,16 +1422,31 @@ go_on: } /* Read mixer settings */ - if (u->source) - pa_asyncmsgq_post(u->thread_mq.inq, PA_MSGOBJECT(u->source), PA_SOURCE_MESSAGE_GET_VOLUME, &u->source->volume, 0, NULL, NULL); - if (u->sink) - pa_asyncmsgq_post(u->thread_mq.inq, PA_MSGOBJECT(u->sink), PA_SINK_MESSAGE_GET_VOLUME, &u->sink->volume, 0, NULL, NULL); + if (u->sink) { + if (sink_new_data.volume_is_set) { + if (u->sink->set_volume) + u->sink->set_volume(u->sink); + } else { + if (u->sink->get_volume) + u->sink->get_volume(u->sink); + } + } + + if (u->source) { + if (source_new_data.volume_is_set) { + if (u->source->set_volume) + u->source->set_volume(u->source); + } else { + if (u->source->get_volume) + u->source->get_volume(u->source); + } + } if (u->sink) pa_sink_put(u->sink); if (u->source) pa_source_put(u->source); - + pa_modargs_free(ma); return 0; @@ -1311,7 +1456,7 @@ fail: if (u) pa__done(m); else if (fd >= 0) - close(fd); + pa_close(fd); if (ma) pa_modargs_free(ma); @@ -1345,16 +1490,16 @@ void pa__done(pa_module*m) { if (u->source) pa_source_unref(u->source); - + if (u->memchunk.memblock) pa_memblock_unref(u->memchunk.memblock); if (u->rtpoll_item) pa_rtpoll_item_free(u->rtpoll_item); - + if (u->rtpoll) pa_rtpoll_free(u->rtpoll); - + if (u->out_mmap_memblocks) { unsigned i; for (i = 0; i < u->out_nfrags; i++) @@ -1376,11 +1521,14 @@ void pa__done(pa_module*m) { if (u->out_mmap && u->out_mmap != MAP_FAILED) munmap(u->out_mmap, u->out_hwbuf_size); - + if (u->fd >= 0) - close(u->fd); + pa_close(u->fd); + + if (u->mixer_fd >= 0) + pa_close(u->mixer_fd); pa_xfree(u->device_name); - + pa_xfree(u); }