4 This file is part of polypaudio.
6 polypaudio is free software; you can redistribute it and/or modify
7 it under the terms of the GNU Lesser General Public License as published
8 by the Free Software Foundation; either version 2 of the License,
9 or (at your option) any later version.
11 polypaudio is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public License
17 along with polypaudio; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
34 #include <sys/ioctl.h>
36 #include <sys/types.h>
41 #include <sys/audio.h>
43 #include <polyp/mainloop-signal.h>
44 #include <polyp/xmalloc.h>
46 #include <polypcore/iochannel.h>
47 #include <polypcore/sink.h>
48 #include <polypcore/source.h>
49 #include <polypcore/module.h>
50 #include <polypcore/sample-util.h>
51 #include <polypcore/core-util.h>
52 #include <polypcore/modargs.h>
53 #include <polypcore/log.h>
55 #include "module-solaris-symdef.h"
57 PA_MODULE_AUTHOR("Pierre Ossman")
58 PA_MODULE_DESCRIPTION("Solaris Sink/Source")
59 PA_MODULE_VERSION(PACKAGE_VERSION)
61 "sink_name=<name for the sink> "
62 "source_name=<name for the source> "
63 "device=<OSS device> record=<enable source?> "
64 "playback=<enable sink?> "
65 "format=<sample format> "
66 "channels=<number of channels> "
68 "buffer_size=<record buffer size> "
69 "channel_map=<channel map>")
77 pa_usec_t poll_timeout;
80 pa_memchunk memchunk, silence;
84 unsigned int written_bytes, read_bytes;
90 static const char* const valid_modargs[] = {
104 #define DEFAULT_SINK_NAME "solaris_output"
105 #define DEFAULT_SOURCE_NAME "solaris_input"
106 #define DEFAULT_DEVICE "/dev/audio"
108 #define CHUNK_SIZE 2048
110 static void update_usage(struct userdata *u) {
111 pa_module_set_used(u->module,
112 (u->sink ? pa_idxset_size(u->sink->inputs) : 0) +
113 (u->sink ? pa_idxset_size(u->sink->monitor_source->outputs) : 0) +
114 (u->source ? pa_idxset_size(u->source->outputs) : 0));
117 static void do_write(struct userdata *u) {
120 pa_memchunk *memchunk;
126 /* We cannot check pa_iochannel_is_writable() because of our buffer hack */
132 err = ioctl(u->fd, AUDIO_GETINFO, &info);
136 * Since we cannot modify the size of the output buffer we fake it
137 * by not filling it more than u->buffer_size.
139 len = u->buffer_size;
140 len -= u->written_bytes - (info.play.samples * u->frame_size);
142 /* The sample counter can sometimes go backwards :( */
143 if (len > u->buffer_size)
146 if (len == u->buffer_size)
147 pa_log_debug(__FILE__": Solaris buffer underflow!");
149 len -= len % u->frame_size;
154 memchunk = &u->memchunk;
156 if (!memchunk->length)
157 if (pa_sink_render(u->sink, len, memchunk) < 0)
158 memchunk = &u->silence;
160 assert(memchunk->memblock);
161 assert(memchunk->memblock->data);
162 assert(memchunk->length);
164 if (memchunk->length < len) {
165 len = memchunk->length;
166 len -= len % u->frame_size;
170 if ((r = pa_iochannel_write(u->io, (uint8_t*) memchunk->memblock->data + memchunk->index, len)) < 0) {
171 pa_log(__FILE__": write() failed: %s", strerror(errno));
175 assert(r % u->frame_size == 0);
177 if (memchunk != &u->silence) {
178 u->memchunk.index += r;
179 u->memchunk.length -= r;
181 if (u->memchunk.length <= 0) {
182 pa_memblock_unref(u->memchunk.memblock);
183 u->memchunk.memblock = NULL;
187 u->written_bytes += r;
190 static void do_read(struct userdata *u) {
191 pa_memchunk memchunk;
196 if (!u->source || !pa_iochannel_is_readable(u->io))
201 err = ioctl(u->fd, I_NREAD, &l);
204 memchunk.memblock = pa_memblock_new(l, u->core->memblock_stat);
205 assert(memchunk.memblock);
206 if ((r = pa_iochannel_read(u->io, memchunk.memblock->data, memchunk.memblock->length)) < 0) {
207 pa_memblock_unref(memchunk.memblock);
209 pa_log(__FILE__": read() failed: %s", strerror(errno));
213 assert(r <= (ssize_t) memchunk.memblock->length);
214 memchunk.length = memchunk.memblock->length = r;
217 pa_source_post(u->source, &memchunk);
218 pa_memblock_unref(memchunk.memblock);
223 static void io_callback(pa_iochannel *io, void*userdata) {
224 struct userdata *u = userdata;
230 static void timer_cb(pa_mainloop_api*a, pa_time_event *e, const struct timeval *tv, void *userdata) {
231 struct userdata *u = userdata;
238 pa_gettimeofday(&ntv);
239 pa_timeval_add(&ntv, u->poll_timeout);
241 a->time_restart(e, &ntv);
244 static void sig_callback(pa_mainloop_api *api, pa_signal_event*e, int sig, void *userdata) {
245 struct userdata *u = userdata;
251 assert(u->sink->get_hw_volume);
252 memcpy(&old_vol, &u->sink->hw_volume, sizeof(pa_cvolume));
253 if (u->sink->get_hw_volume(u->sink) < 0)
255 if (memcmp(&old_vol, &u->sink->hw_volume, sizeof(pa_cvolume)) != 0) {
256 pa_subscription_post(u->sink->core,
257 PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE,
263 assert(u->source->get_hw_volume);
264 memcpy(&old_vol, &u->source->hw_volume, sizeof(pa_cvolume));
265 if (u->source->get_hw_volume(u->source) < 0)
267 if (memcmp(&old_vol, &u->source->hw_volume, sizeof(pa_cvolume)) != 0) {
268 pa_subscription_post(u->source->core,
269 PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE,
275 static pa_usec_t sink_get_latency_cb(pa_sink *s) {
279 struct userdata *u = s->userdata;
280 assert(s && u && u->sink);
282 err = ioctl(u->fd, AUDIO_GETINFO, &info);
285 r += pa_bytes_to_usec(u->written_bytes, &s->sample_spec);
286 r -= pa_bytes_to_usec(info.play.samples * u->frame_size, &s->sample_spec);
288 if (u->memchunk.memblock)
289 r += pa_bytes_to_usec(u->memchunk.length, &s->sample_spec);
294 static pa_usec_t source_get_latency_cb(pa_source *s) {
296 struct userdata *u = s->userdata;
299 assert(s && u && u->source);
301 err = ioctl(u->fd, AUDIO_GETINFO, &info);
304 r += pa_bytes_to_usec(info.record.samples * u->frame_size, &s->sample_spec);
305 r -= pa_bytes_to_usec(u->read_bytes, &s->sample_spec);
310 static int sink_get_hw_volume_cb(pa_sink *s) {
311 struct userdata *u = s->userdata;
315 err = ioctl(u->fd, AUDIO_GETINFO, &info);
318 pa_cvolume_set(&s->hw_volume, s->hw_volume.channels,
319 info.play.gain * PA_VOLUME_NORM / AUDIO_MAX_GAIN);
324 static int sink_set_hw_volume_cb(pa_sink *s) {
325 struct userdata *u = s->userdata;
328 AUDIO_INITINFO(&info);
330 info.play.gain = pa_cvolume_avg(&s->hw_volume) * AUDIO_MAX_GAIN / PA_VOLUME_NORM;
331 assert(info.play.gain <= AUDIO_MAX_GAIN);
333 if (ioctl(u->fd, AUDIO_SETINFO, &info) < 0) {
335 pa_log(__FILE__": AUDIO_SETINFO: Unsupported volume.");
337 pa_log(__FILE__": AUDIO_SETINFO: %s", strerror(errno));
344 static int sink_get_hw_mute_cb(pa_sink *s) {
345 struct userdata *u = s->userdata;
349 err = ioctl(u->fd, AUDIO_GETINFO, &info);
352 s->hw_muted = !!info.output_muted;
357 static int sink_set_hw_mute_cb(pa_sink *s) {
358 struct userdata *u = s->userdata;
361 AUDIO_INITINFO(&info);
363 info.output_muted = !!s->hw_muted;
365 if (ioctl(u->fd, AUDIO_SETINFO, &info) < 0) {
366 pa_log(__FILE__": AUDIO_SETINFO: %s", strerror(errno));
373 static int source_get_hw_volume_cb(pa_source *s) {
374 struct userdata *u = s->userdata;
378 err = ioctl(u->fd, AUDIO_GETINFO, &info);
381 pa_cvolume_set(&s->hw_volume, s->hw_volume.channels,
382 info.record.gain * PA_VOLUME_NORM / AUDIO_MAX_GAIN);
387 static int source_set_hw_volume_cb(pa_source *s) {
388 struct userdata *u = s->userdata;
391 AUDIO_INITINFO(&info);
393 info.record.gain = pa_cvolume_avg(&s->hw_volume) * AUDIO_MAX_GAIN / PA_VOLUME_NORM;
394 assert(info.record.gain <= AUDIO_MAX_GAIN);
396 if (ioctl(u->fd, AUDIO_SETINFO, &info) < 0) {
398 pa_log(__FILE__": AUDIO_SETINFO: Unsupported volume.");
400 pa_log(__FILE__": AUDIO_SETINFO: %s", strerror(errno));
407 static int pa_solaris_auto_format(int fd, int mode, pa_sample_spec *ss) {
410 AUDIO_INITINFO(&info);
412 if (mode != O_RDONLY) {
413 info.play.sample_rate = ss->rate;
414 info.play.channels = ss->channels;
415 switch (ss->format) {
417 info.play.precision = 8;
418 info.play.encoding = AUDIO_ENCODING_LINEAR;
421 info.play.precision = 8;
422 info.play.encoding = AUDIO_ENCODING_ALAW;
425 info.play.precision = 8;
426 info.play.encoding = AUDIO_ENCODING_ULAW;
428 case PA_SAMPLE_S16NE:
429 info.play.precision = 16;
430 info.play.encoding = AUDIO_ENCODING_LINEAR;
437 if (mode != O_WRONLY) {
438 info.record.sample_rate = ss->rate;
439 info.record.channels = ss->channels;
440 switch (ss->format) {
442 info.record.precision = 8;
443 info.record.encoding = AUDIO_ENCODING_LINEAR;
446 info.record.precision = 8;
447 info.record.encoding = AUDIO_ENCODING_ALAW;
450 info.record.precision = 8;
451 info.record.encoding = AUDIO_ENCODING_ULAW;
453 case PA_SAMPLE_S16NE:
454 info.record.precision = 16;
455 info.record.encoding = AUDIO_ENCODING_LINEAR;
462 if (ioctl(fd, AUDIO_SETINFO, &info) < 0) {
464 pa_log(__FILE__": AUDIO_SETINFO: Unsupported sample format.");
466 pa_log(__FILE__": AUDIO_SETINFO: %s", strerror(errno));
473 static int pa_solaris_set_buffer(int fd, int buffer_size) {
476 AUDIO_INITINFO(&info);
478 info.record.buffer_size = buffer_size;
480 if (ioctl(fd, AUDIO_SETINFO, &info) < 0) {
482 pa_log(__FILE__": AUDIO_SETINFO: Unsupported buffer size.");
484 pa_log(__FILE__": AUDIO_SETINFO: %s", strerror(errno));
491 int pa__init(pa_core *c, pa_module*m) {
492 struct userdata *u = NULL;
497 int record = 1, playback = 1;
500 pa_modargs *ma = NULL;
504 if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
505 pa_log(__FILE__": failed to parse module arguments.");
509 if (pa_modargs_get_value_boolean(ma, "record", &record) < 0 || pa_modargs_get_value_boolean(ma, "playback", &playback) < 0) {
510 pa_log(__FILE__": record= and playback= expect numeric argument.");
514 if (!playback && !record) {
515 pa_log(__FILE__": neither playback nor record enabled for device.");
519 mode = (playback&&record) ? O_RDWR : (playback ? O_WRONLY : (record ? O_RDONLY : 0));
522 if (pa_modargs_get_value_s32(ma, "buffer_size", &buffer_size) < 0) {
523 pa_log(__FILE__": failed to parse buffer size argument");
527 ss = c->default_sample_spec;
528 if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_DEFAULT) < 0) {
529 pa_log(__FILE__": failed to parse sample specification");
533 if ((fd = open(p = pa_modargs_get_value(ma, "device", DEFAULT_DEVICE), mode | O_NONBLOCK)) < 0)
536 pa_log_info(__FILE__": device opened in %s mode.", mode == O_WRONLY ? "O_WRONLY" : (mode == O_RDONLY ? "O_RDONLY" : "O_RDWR"));
538 if (pa_solaris_auto_format(fd, mode, &ss) < 0)
541 if ((mode != O_WRONLY) && (buffer_size >= 1))
542 if (pa_solaris_set_buffer(fd, buffer_size) < 0)
545 u = pa_xmalloc(sizeof(struct userdata));
548 if (mode != O_WRONLY) {
549 u->source = pa_source_new(c, __FILE__, pa_modargs_get_value(ma, "source_name", DEFAULT_SOURCE_NAME), 0, &ss, &map);
551 u->source->userdata = u;
552 u->source->get_latency = source_get_latency_cb;
553 u->source->get_hw_volume = source_get_hw_volume_cb;
554 u->source->set_hw_volume = source_set_hw_volume_cb;
555 pa_source_set_owner(u->source, m);
556 u->source->description = pa_sprintf_malloc("Solaris PCM on '%s'", p);
560 if (mode != O_RDONLY) {
561 u->sink = pa_sink_new(c, __FILE__, pa_modargs_get_value(ma, "sink_name", DEFAULT_SINK_NAME), 0, &ss, &map);
563 u->sink->get_latency = sink_get_latency_cb;
564 u->sink->get_hw_volume = sink_get_hw_volume_cb;
565 u->sink->set_hw_volume = sink_set_hw_volume_cb;
566 u->sink->get_hw_mute = sink_get_hw_mute_cb;
567 u->sink->set_hw_mute = sink_set_hw_mute_cb;
568 u->sink->userdata = u;
569 pa_sink_set_owner(u->sink, m);
570 u->sink->description = pa_sprintf_malloc("Solaris PCM on '%s'", p);
574 assert(u->source || u->sink);
576 u->io = pa_iochannel_new(c->mainloop, u->source ? fd : -1, u->sink ? fd : 0);
578 pa_iochannel_set_callback(u->io, io_callback, u);
581 u->memchunk.memblock = NULL;
582 u->memchunk.length = 0;
583 u->frame_size = pa_frame_size(&ss);
584 u->buffer_size = buffer_size;
586 u->silence.memblock = pa_memblock_new(u->silence.length = CHUNK_SIZE, u->core->memblock_stat);
587 assert(u->silence.memblock);
588 pa_silence_memblock(u->silence.memblock, &ss);
589 u->silence.index = 0;
591 u->written_bytes = 0;
597 u->poll_timeout = pa_bytes_to_usec(u->buffer_size / 10, &ss);
599 pa_gettimeofday(&tv);
600 pa_timeval_add(&tv, u->poll_timeout);
602 u->timer = c->mainloop->time_new(c->mainloop, &tv, timer_cb, u);
605 u->sig = pa_signal_new(SIGPOLL, sig_callback, u);
607 ioctl(u->fd, I_SETSIG, S_MSG);
611 /* Read mixer settings */
613 source_get_hw_volume_cb(u->source);
615 sink_get_hw_volume_cb(u->sink);
616 sink_get_hw_mute_cb(u->sink);
631 void pa__done(pa_core *c, pa_module*m) {
635 if (!(u = m->userdata))
639 c->mainloop->time_free(u->timer);
640 ioctl(u->fd, I_SETSIG, 0);
641 pa_signal_free(u->sig);
643 if (u->memchunk.memblock)
644 pa_memblock_unref(u->memchunk.memblock);
645 if (u->silence.memblock)
646 pa_memblock_unref(u->silence.memblock);
649 pa_sink_disconnect(u->sink);
650 pa_sink_unref(u->sink);
654 pa_source_disconnect(u->source);
655 pa_source_unref(u->source);
658 pa_iochannel_free(u->io);