]> code.delx.au - pulseaudio/blob - src/modules/oss/module-oss.c
delx.au / code / pulseaudio / blob


7271a0875f45b29502f6fb2c6237099029126a42
[pulseaudio] / src / modules / oss / module-oss.c
1 /***
2 This file is part of PulseAudio.
3
4 Copyright 2004-2006 Lennart Poettering
5 Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
6
7 PulseAudio is free software; you can redistribute it and/or modify
8 it under the terms of the GNU Lesser General Public License as published
9 by the Free Software Foundation; either version 2 of the License,
10 or (at your option) any later version.
11
12 PulseAudio is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
16
17 You should have received a copy of the GNU Lesser General Public License
18 along with PulseAudio; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
20 USA.
21 ***/
22
23 /* General power management rules:
24 *
25 * When SUSPENDED we close the audio device.
26 *
27 * We make no difference between IDLE and RUNNING in our handling.
28 *
29 * As long as we are in RUNNING/IDLE state we will *always* write data to
30 * the device. If none is avilable from the inputs, we write silence
31 * instead.
32 *
33 * If power should be saved on IDLE module-suspend-on-idle should be used.
34 *
35 */
36
37 #ifdef HAVE_CONFIG_H
38 #include <config.h>
39 #endif
40
41 #ifdef HAVE_SYS_MMAN_H
42 #include <sys/mman.h>
43 #endif
44
45 #include <sys/soundcard.h>
46 #include <sys/ioctl.h>
47 #include <stdlib.h>
48 #include <sys/stat.h>
49 #include <stdio.h>
50 #include <errno.h>
51 #include <string.h>
52 #include <fcntl.h>
53 #include <unistd.h>
54 #include <limits.h>
55 #include <signal.h>
56 #include <poll.h>
57
58 #include <pulse/xmalloc.h>
59 #include <pulse/util.h>
60
61 #include <pulsecore/core-error.h>
62 #include <pulsecore/thread.h>
63 #include <pulsecore/sink.h>
64 #include <pulsecore/source.h>
65 #include <pulsecore/module.h>
66 #include <pulsecore/sample-util.h>
67 #include <pulsecore/core-util.h>
68 #include <pulsecore/modargs.h>
69 #include <pulsecore/log.h>
70 #include <pulsecore/macro.h>
71 #include <pulsecore/thread-mq.h>
72 #include <pulsecore/rtpoll.h>
73
74 #if defined(__NetBSD__) && !defined(SNDCTL_DSP_GETODELAY)
75 #include <sys/audioio.h>
76 #include <sys/syscall.h>
77 #endif
78
79 #include "oss-util.h"
80 #include "module-oss-symdef.h"
81
82 PA_MODULE_AUTHOR("Lennart Poettering");
83 PA_MODULE_DESCRIPTION("OSS Sink/Source");
84 PA_MODULE_VERSION(PACKAGE_VERSION);
85 PA_MODULE_LOAD_ONCE(FALSE);
86 PA_MODULE_USAGE(
87 "sink_name=<name for the sink> "
88 "source_name=<name for the source> "
89 "device=<OSS device> "
90 "record=<enable source?> "
91 "playback=<enable sink?> "
92 "format=<sample format> "
93 "channels=<number of channels> "
94 "rate=<sample rate> "
95 "fragments=<number of fragments> "
96 "fragment_size=<fragment size> "
97 "channel_map=<channel map> "
98 "mmap=<enable memory mapping?>");
99
100 #define DEFAULT_DEVICE "/dev/dsp"
101
102 struct userdata {
103 pa_core *core;
104 pa_module *module;
105 pa_sink *sink;
106 pa_source *source;
107
108 pa_thread *thread;
109 pa_thread_mq thread_mq;
110 pa_rtpoll *rtpoll;
111
112 char *device_name;
113
114 pa_memchunk memchunk;
115
116 size_t frame_size;
117 uint32_t in_fragment_size, out_fragment_size, in_nfrags, out_nfrags, in_hwbuf_size, out_hwbuf_size;
118 pa_bool_t use_getospace, use_getispace;
119 pa_bool_t use_getodelay;
120
121 pa_bool_t sink_suspended, source_suspended;
122
123 int fd;
124 int mode;
125
126 int mixer_fd;
127 int mixer_devmask;
128
129 int nfrags, frag_size, orig_frag_size;
130
131 pa_bool_t use_mmap;
132 unsigned out_mmap_current, in_mmap_current;
133 void *in_mmap, *out_mmap;
134 pa_memblock **in_mmap_memblocks, **out_mmap_memblocks;
135
136 int in_mmap_saved_nfrags, out_mmap_saved_nfrags;
137
138 pa_rtpoll_item *rtpoll_item;
139 };
140
141 static const char* const valid_modargs[] = {
142 "sink_name",
143 "source_name",
144 "device",
145 "record",
146 "playback",
147 "fragments",
148 "fragment_size",
149 "format",
150 "rate",
151 "channels",
152 "channel_map",
153 "mmap",
154 NULL
155 };
156
157 static void trigger(struct userdata *u, pa_bool_t quick) {
158 int enable_bits = 0, zero = 0;
159
160 pa_assert(u);
161
162 if (u->fd < 0)
163 return;
164
165 pa_log_debug("trigger");
166
167 if (u->source && PA_SOURCE_IS_OPENED(u->source->thread_info.state))
168 enable_bits |= PCM_ENABLE_INPUT;
169
170 if (u->sink && PA_SINK_IS_OPENED(u->sink->thread_info.state))
171 enable_bits |= PCM_ENABLE_OUTPUT;
172
173 pa_log_debug("trigger: %i", enable_bits);
174
175
176 if (u->use_mmap) {
177
178 if (!quick)
179 ioctl(u->fd, SNDCTL_DSP_SETTRIGGER, &zero);
180
181 #ifdef SNDCTL_DSP_HALT
182 if (enable_bits == 0)
183 if (ioctl(u->fd, SNDCTL_DSP_HALT, NULL) < 0)
184 pa_log_warn("SNDCTL_DSP_HALT: %s", pa_cstrerror(errno));
185 #endif
186
187 if (ioctl(u->fd, SNDCTL_DSP_SETTRIGGER, &enable_bits) < 0)
188 pa_log_warn("SNDCTL_DSP_SETTRIGGER: %s", pa_cstrerror(errno));
189
190 if (u->sink && !(enable_bits & PCM_ENABLE_OUTPUT)) {
191 pa_log_debug("clearing playback buffer");
192 pa_silence_memory(u->out_mmap, u->out_hwbuf_size, &u->sink->sample_spec);
193 }
194
195 } else {
196
197 if (enable_bits)
198 if (ioctl(u->fd, SNDCTL_DSP_POST, NULL) < 0)
199 pa_log_warn("SNDCTL_DSP_POST: %s", pa_cstrerror(errno));
200
201 if (!quick) {
202 /*
203 * Some crappy drivers do not start the recording until we
204 * read something. Without this snippet, poll will never
205 * register the fd as ready.
206 */
207
208 if (u->source && PA_SOURCE_IS_OPENED(u->source->thread_info.state)) {
209 uint8_t *buf = pa_xnew(uint8_t, u->in_fragment_size);
210 pa_read(u->fd, buf, u->in_fragment_size, NULL);
211 pa_xfree(buf);
212 }
213 }
214 }
215 }
216
217 static void mmap_fill_memblocks(struct userdata *u, unsigned n) {
218 pa_assert(u);
219 pa_assert(u->out_mmap_memblocks);
220
221 /* pa_log("Mmmap writing %u blocks", n); */
222
223 while (n > 0) {
224 pa_memchunk chunk;
225
226 if (u->out_mmap_memblocks[u->out_mmap_current])
227 pa_memblock_unref_fixed(u->out_mmap_memblocks[u->out_mmap_current]);
228
229 chunk.memblock = u->out_mmap_memblocks[u->out_mmap_current] =
230 pa_memblock_new_fixed(
231 u->core->mempool,
232 (uint8_t*) u->out_mmap + u->out_fragment_size * u->out_mmap_current,
233 u->out_fragment_size,
234 1);
235
236 chunk.length = pa_memblock_get_length(chunk.memblock);
237 chunk.index = 0;
238
239 pa_sink_render_into_full(u->sink, &chunk);
240
241 u->out_mmap_current++;
242 while (u->out_mmap_current >= u->out_nfrags)
243 u->out_mmap_current -= u->out_nfrags;
244
245 n--;
246 }
247 }
248
249 static int mmap_write(struct userdata *u) {
250 struct count_info info;
251
252 pa_assert(u);
253 pa_assert(u->sink);
254
255 /* pa_log("Mmmap writing..."); */
256
257 if (ioctl(u->fd, SNDCTL_DSP_GETOPTR, &info) < 0) {
258 pa_log("SNDCTL_DSP_GETOPTR: %s", pa_cstrerror(errno));
259 return -1;
260 }
261
262 info.blocks += u->out_mmap_saved_nfrags;
263 u->out_mmap_saved_nfrags = 0;
264
265 if (info.blocks > 0)
266 mmap_fill_memblocks(u, (unsigned) info.blocks);
267
268 return info.blocks;
269 }
270
271 static void mmap_post_memblocks(struct userdata *u, unsigned n) {
272 pa_assert(u);
273 pa_assert(u->in_mmap_memblocks);
274
275 /* pa_log("Mmmap reading %u blocks", n); */
276
277 while (n > 0) {
278 pa_memchunk chunk;
279
280 if (!u->in_mmap_memblocks[u->in_mmap_current]) {
281
282 chunk.memblock = u->in_mmap_memblocks[u->in_mmap_current] =
283 pa_memblock_new_fixed(
284 u->core->mempool,
285 (uint8_t*) u->in_mmap + u->in_fragment_size*u->in_mmap_current,
286 u->in_fragment_size,
287 1);
288
289 chunk.length = pa_memblock_get_length(chunk.memblock);
290 chunk.index = 0;
291
292 pa_source_post(u->source, &chunk);
293 }
294
295 u->in_mmap_current++;
296 while (u->in_mmap_current >= u->in_nfrags)
297 u->in_mmap_current -= u->in_nfrags;
298
299 n--;
300 }
301 }
302
303 static void mmap_clear_memblocks(struct userdata*u, unsigned n) {
304 unsigned i = u->in_mmap_current;
305
306 pa_assert(u);
307 pa_assert(u->in_mmap_memblocks);
308
309 if (n > u->in_nfrags)
310 n = u->in_nfrags;
311
312 while (n > 0) {
313 if (u->in_mmap_memblocks[i]) {
314 pa_memblock_unref_fixed(u->in_mmap_memblocks[i]);
315 u->in_mmap_memblocks[i] = NULL;
316 }
317
318 i++;
319 while (i >= u->in_nfrags)
320 i -= u->in_nfrags;
321
322 n--;
323 }
324 }
325
326 static int mmap_read(struct userdata *u) {
327 struct count_info info;
328 pa_assert(u);
329 pa_assert(u->source);
330
331 /* pa_log("Mmmap reading..."); */
332
333 if (ioctl(u->fd, SNDCTL_DSP_GETIPTR, &info) < 0) {
334 pa_log("SNDCTL_DSP_GETIPTR: %s", pa_cstrerror(errno));
335 return -1;
336 }
337
338 /* pa_log("... %i", info.blocks); */
339
340 info.blocks += u->in_mmap_saved_nfrags;
341 u->in_mmap_saved_nfrags = 0;
342
343 if (info.blocks > 0) {
344 mmap_post_memblocks(u, (unsigned) info.blocks);
345 mmap_clear_memblocks(u, u->in_nfrags/2);
346 }
347
348 return info.blocks;
349 }
350
351 static pa_usec_t mmap_sink_get_latency(struct userdata *u) {
352 struct count_info info;
353 size_t bpos, n;
354
355 pa_assert(u);
356
357 if (ioctl(u->fd, SNDCTL_DSP_GETOPTR, &info) < 0) {
358 pa_log("SNDCTL_DSP_GETOPTR: %s", pa_cstrerror(errno));
359 return 0;
360 }
361
362 u->out_mmap_saved_nfrags += info.blocks;
363
364 bpos = ((u->out_mmap_current + (unsigned) u->out_mmap_saved_nfrags) * u->out_fragment_size) % u->out_hwbuf_size;
365
366 if (bpos <= (size_t) info.ptr)
367 n = u->out_hwbuf_size - ((size_t) info.ptr - bpos);
368 else
369 n = bpos - (size_t) info.ptr;
370
371 /* pa_log("n = %u, bpos = %u, ptr = %u, total=%u, fragsize = %u, n_frags = %u\n", n, bpos, (unsigned) info.ptr, total, u->out_fragment_size, u->out_fragments); */
372
373 return pa_bytes_to_usec(n, &u->sink->sample_spec);
374 }
375
376 static pa_usec_t mmap_source_get_latency(struct userdata *u) {
377 struct count_info info;
378 size_t bpos, n;
379
380 pa_assert(u);
381
382 if (ioctl(u->fd, SNDCTL_DSP_GETIPTR, &info) < 0) {
383 pa_log("SNDCTL_DSP_GETIPTR: %s", pa_cstrerror(errno));
384 return 0;
385 }
386
387 u->in_mmap_saved_nfrags += info.blocks;
388 bpos = ((u->in_mmap_current + (unsigned) u->in_mmap_saved_nfrags) * u->in_fragment_size) % u->in_hwbuf_size;
389
390 if (bpos <= (size_t) info.ptr)
391 n = (size_t) info.ptr - bpos;
392 else
393 n = u->in_hwbuf_size - bpos + (size_t) info.ptr;
394
395 /* pa_log("n = %u, bpos = %u, ptr = %u, total=%u, fragsize = %u, n_frags = %u\n", n, bpos, (unsigned) info.ptr, total, u->in_fragment_size, u->in_fragments); */
396
397 return pa_bytes_to_usec(n, &u->source->sample_spec);
398 }
399
400 static pa_usec_t io_sink_get_latency(struct userdata *u) {
401 pa_usec_t r = 0;
402
403 pa_assert(u);
404
405 if (u->use_getodelay) {
406 int arg;
407 #if defined(__NetBSD__) && !defined(SNDCTL_DSP_GETODELAY)
408 #if defined(AUDIO_GETBUFINFO)
409 struct audio_info info;
410 if (syscall(SYS_ioctl, u->fd, AUDIO_GETBUFINFO, &info) < 0) {
411 pa_log_info("Device doesn't support AUDIO_GETBUFINFO: %s", pa_cstrerror(errno));
412 u->use_getodelay = 0;
413 } else {
414 arg = info.play.seek + info.blocksize / 2;
415 r = pa_bytes_to_usec((size_t) arg, &u->sink->sample_spec);
416 }
417 #else
418 pa_log_info("System doesn't support AUDIO_GETBUFINFO");
419 u->use_getodelay = 0;
420 #endif
421 #else
422 if (ioctl(u->fd, SNDCTL_DSP_GETODELAY, &arg) < 0) {
423 pa_log_info("Device doesn't support SNDCTL_DSP_GETODELAY: %s", pa_cstrerror(errno));
424 u->use_getodelay = 0;
425 } else
426 r = pa_bytes_to_usec((size_t) arg, &u->sink->sample_spec);
427 #endif
428 }
429
430 if (!u->use_getodelay && u->use_getospace) {
431 struct audio_buf_info info;
432
433 if (ioctl(u->fd, SNDCTL_DSP_GETOSPACE, &info) < 0) {
434 pa_log_info("Device doesn't support SNDCTL_DSP_GETOSPACE: %s", pa_cstrerror(errno));
435 u->use_getospace = 0;
436 } else
437 r = pa_bytes_to_usec((size_t) info.bytes, &u->sink->sample_spec);
438 }
439
440 if (u->memchunk.memblock)
441 r += pa_bytes_to_usec(u->memchunk.length, &u->sink->sample_spec);
442
443 return r;
444 }
445
446
447 static pa_usec_t io_source_get_latency(struct userdata *u) {
448 pa_usec_t r = 0;
449
450 pa_assert(u);
451
452 if (u->use_getispace) {
453 struct audio_buf_info info;
454
455 if (ioctl(u->fd, SNDCTL_DSP_GETISPACE, &info) < 0) {
456 pa_log_info("Device doesn't support SNDCTL_DSP_GETISPACE: %s", pa_cstrerror(errno));
457 u->use_getispace = 0;
458 } else
459 r = pa_bytes_to_usec((size_t) info.bytes, &u->source->sample_spec);
460 }
461
462 return r;
463 }
464
465 static void build_pollfd(struct userdata *u) {
466 struct pollfd *pollfd;
467
468 pa_assert(u);
469 pa_assert(u->fd >= 0);
470
471 if (u->rtpoll_item)
472 pa_rtpoll_item_free(u->rtpoll_item);
473
474 u->rtpoll_item = pa_rtpoll_item_new(u->rtpoll, PA_RTPOLL_NEVER, 1);
475 pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL);
476 pollfd->fd = u->fd;
477 pollfd->events = 0;
478 pollfd->revents = 0;
479 }
480
481 static int suspend(struct userdata *u) {
482 pa_assert(u);
483 pa_assert(u->fd >= 0);
484
485 pa_log_info("Suspending...");
486
487 if (u->out_mmap_memblocks) {
488 unsigned i;
489 for (i = 0; i < u->out_nfrags; i++)
490 if (u->out_mmap_memblocks[i]) {
491 pa_memblock_unref_fixed(u->out_mmap_memblocks[i]);
492 u->out_mmap_memblocks[i] = NULL;
493 }
494 }
495
496 if (u->in_mmap_memblocks) {
497 unsigned i;
498 for (i = 0; i < u->in_nfrags; i++)
499 if (u->in_mmap_memblocks[i]) {
500 pa_memblock_unref_fixed(u->in_mmap_memblocks[i]);
501 u->in_mmap_memblocks[i] = NULL;
502 }
503 }
504
505 if (u->in_mmap && u->in_mmap != MAP_FAILED) {
506 munmap(u->in_mmap, u->in_hwbuf_size);
507 u->in_mmap = NULL;
508 }
509
510 if (u->out_mmap && u->out_mmap != MAP_FAILED) {
511 munmap(u->out_mmap, u->out_hwbuf_size);
512 u->out_mmap = NULL;
513 }
514
515 /* Let's suspend */
516 ioctl(u->fd, SNDCTL_DSP_SYNC, NULL);
517 pa_close(u->fd);
518 u->fd = -1;
519
520 if (u->rtpoll_item) {
521 pa_rtpoll_item_free(u->rtpoll_item);
522 u->rtpoll_item = NULL;
523 }
524
525 pa_log_info("Device suspended...");
526
527 return 0;
528 }
529
530 static int sink_get_volume(pa_sink *s);
531 static int source_get_volume(pa_source *s);
532
533 static int unsuspend(struct userdata *u) {
534 int m;
535 pa_sample_spec ss, *ss_original;
536 int frag_size, in_frag_size, out_frag_size;
537 int in_nfrags, out_nfrags;
538 struct audio_buf_info info;
539
540 pa_assert(u);
541 pa_assert(u->fd < 0);
542
543 m = u->mode;
544
545 pa_log_info("Trying resume...");
546
547 if ((u->fd = pa_oss_open(u->device_name, &m, NULL)) < 0) {
548 pa_log_warn("Resume failed, device busy (%s)", pa_cstrerror(errno));
549 return -1;
550 }
551
552 if (m != u->mode) {
553 pa_log_warn("Resume failed, couldn't open device with original access mode.");
554 goto fail;
555 }
556
557 if (u->nfrags >= 2 && u->frag_size >= 1)
558 if (pa_oss_set_fragments(u->fd, u->nfrags, u->orig_frag_size) < 0) {
559 pa_log_warn("Resume failed, couldn't set original fragment settings.");
560 goto fail;
561 }
562
563 ss = *(ss_original = u->sink ? &u->sink->sample_spec : &u->source->sample_spec);
564 if (pa_oss_auto_format(u->fd, &ss) < 0 || !pa_sample_spec_equal(&ss, ss_original)) {
565 pa_log_warn("Resume failed, couldn't set original sample format settings.");
566 goto fail;
567 }
568
569 if (ioctl(u->fd, SNDCTL_DSP_GETBLKSIZE, &frag_size) < 0) {
570 pa_log_warn("SNDCTL_DSP_GETBLKSIZE: %s", pa_cstrerror(errno));
571 goto fail;
572 }
573
574 in_frag_size = out_frag_size = frag_size;
575 in_nfrags = out_nfrags = u->nfrags;
576
577 if (ioctl(u->fd, SNDCTL_DSP_GETISPACE, &info) >= 0) {
578 in_frag_size = info.fragsize;
579 in_nfrags = info.fragstotal;
580 }
581
582 if (ioctl(u->fd, SNDCTL_DSP_GETOSPACE, &info) >= 0) {
583 out_frag_size = info.fragsize;
584 out_nfrags = info.fragstotal;
585 }
586
587 if ((u->source && (in_frag_size != (int) u->in_fragment_size || in_nfrags != (int) u->in_nfrags)) ||
588 (u->sink && (out_frag_size != (int) u->out_fragment_size || out_nfrags != (int) u->out_nfrags))) {
589 pa_log_warn("Resume failed, input fragment settings don't match.");
590 goto fail;
591 }
592
593 if (u->use_mmap) {
594 if (u->source) {
595 if ((u->in_mmap = mmap(NULL, u->in_hwbuf_size, PROT_READ, MAP_SHARED, u->fd, 0)) == MAP_FAILED) {
596 pa_log("Resume failed, mmap(): %s", pa_cstrerror(errno));
597 goto fail;
598 }
599 }
600
601 if (u->sink) {
602 if ((u->out_mmap = mmap(NULL, u->out_hwbuf_size, PROT_WRITE, MAP_SHARED, u->fd, 0)) == MAP_FAILED) {
603 pa_log("Resume failed, mmap(): %s", pa_cstrerror(errno));
604 if (u->in_mmap && u->in_mmap != MAP_FAILED) {
605 munmap(u->in_mmap, u->in_hwbuf_size);
606 u->in_mmap = NULL;
607 }
608
609 goto fail;
610 }
611
612 pa_silence_memory(u->out_mmap, u->out_hwbuf_size, &ss);
613 }
614 }
615
616 u->out_mmap_current = u->in_mmap_current = 0;
617 u->out_mmap_saved_nfrags = u->in_mmap_saved_nfrags = 0;
618
619 pa_assert(!u->rtpoll_item);
620
621 build_pollfd(u);
622
623 if (u->sink && u->sink->get_volume)
624 u->sink->get_volume(u->sink);
625 if (u->source && u->source->get_volume)
626 u->source->get_volume(u->source);
627
628 pa_log_info("Resumed successfully...");
629
630 return 0;
631
632 fail:
633 pa_close(u->fd);
634 u->fd = -1;
635 return -1;
636 }
637
638 static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
639 struct userdata *u = PA_SINK(o)->userdata;
640 int ret;
641 pa_bool_t do_trigger = FALSE, quick = TRUE;
642
643 switch (code) {
644
645 case PA_SINK_MESSAGE_GET_LATENCY: {
646 pa_usec_t r = 0;
647
648 if (u->fd >= 0) {
649 if (u->use_mmap)
650 r = mmap_sink_get_latency(u);
651 else
652 r = io_sink_get_latency(u);
653 }
654
655 *((pa_usec_t*) data) = r;
656
657 return 0;
658 }
659
660 case PA_SINK_MESSAGE_SET_STATE:
661
662 switch ((pa_sink_state_t) PA_PTR_TO_UINT(data)) {
663
664 case PA_SINK_SUSPENDED:
665 pa_assert(PA_SINK_IS_OPENED(u->sink->thread_info.state));
666
667 if (!u->source || u->source_suspended) {
668 if (suspend(u) < 0)
669 return -1;
670 }
671
672 do_trigger = TRUE;
673
674 u->sink_suspended = TRUE;
675 break;
676
677 case PA_SINK_IDLE:
678 case PA_SINK_RUNNING:
679
680 if (u->sink->thread_info.state == PA_SINK_INIT) {
681 do_trigger = TRUE;
682 quick = u->source && PA_SOURCE_IS_OPENED(u->source->thread_info.state);
683 }
684
685 if (u->sink->thread_info.state == PA_SINK_SUSPENDED) {
686
687 if (!u->source || u->source_suspended) {
688 if (unsuspend(u) < 0)
689 return -1;
690 quick = FALSE;
691 }
692
693 do_trigger = TRUE;
694
695 u->out_mmap_current = 0;
696 u->out_mmap_saved_nfrags = 0;
697
698 u->sink_suspended = FALSE;
699 }
700
701 break;
702
703 case PA_SINK_INVALID_STATE:
704 case PA_SINK_UNLINKED:
705 case PA_SINK_INIT:
706 ;
707 }
708
709 break;
710
711 }
712
713 ret = pa_sink_process_msg(o, code, data, offset, chunk);
714
715 if (do_trigger)
716 trigger(u, quick);
717
718 return ret;
719 }
720
721 static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
722 struct userdata *u = PA_SOURCE(o)->userdata;
723 int ret;
724 int do_trigger = FALSE, quick = TRUE;
725
726 switch (code) {
727
728 case PA_SOURCE_MESSAGE_GET_LATENCY: {
729 pa_usec_t r = 0;
730
731 if (u->fd >= 0) {
732 if (u->use_mmap)
733 r = mmap_source_get_latency(u);
734 else
735 r = io_source_get_latency(u);
736 }
737
738 *((pa_usec_t*) data) = r;
739 return 0;
740 }
741
742 case PA_SOURCE_MESSAGE_SET_STATE:
743
744 switch ((pa_source_state_t) PA_PTR_TO_UINT(data)) {
745 case PA_SOURCE_SUSPENDED:
746 pa_assert(PA_SOURCE_IS_OPENED(u->source->thread_info.state));
747
748 if (!u->sink || u->sink_suspended) {
749 if (suspend(u) < 0)
750 return -1;
751 }
752
753 do_trigger = TRUE;
754
755 u->source_suspended = TRUE;
756 break;
757
758 case PA_SOURCE_IDLE:
759 case PA_SOURCE_RUNNING:
760
761 if (u->source->thread_info.state == PA_SOURCE_INIT) {
762 do_trigger = TRUE;
763 quick = u->sink && PA_SINK_IS_OPENED(u->sink->thread_info.state);
764 }
765
766 if (u->source->thread_info.state == PA_SOURCE_SUSPENDED) {
767
768 if (!u->sink || u->sink_suspended) {
769 if (unsuspend(u) < 0)
770 return -1;
771 quick = FALSE;
772 }
773
774 do_trigger = TRUE;
775
776 u->in_mmap_current = 0;
777 u->in_mmap_saved_nfrags = 0;
778
779 u->source_suspended = FALSE;
780 }
781 break;
782
783 case PA_SOURCE_UNLINKED:
784 case PA_SOURCE_INIT:
785 case PA_SOURCE_INVALID_STATE:
786 ;
787
788 }
789 break;
790
791 }
792
793 ret = pa_source_process_msg(o, code, data, offset, chunk);
794
795 if (do_trigger)
796 trigger(u, quick);
797
798 return ret;
799 }
800
801 static int sink_get_volume(pa_sink *s) {
802 struct userdata *u;
803 int r;
804
805 pa_assert_se(u = s->userdata);
806
807 pa_assert(u->mixer_devmask & (SOUND_MASK_VOLUME|SOUND_MASK_PCM));
808
809 if (u->mixer_devmask & SOUND_MASK_VOLUME)
810 if ((r = pa_oss_get_volume(u->mixer_fd, SOUND_MIXER_READ_VOLUME, &s->sample_spec, &s->volume)) >= 0)
811 return r;
812
813 if (u->mixer_devmask & SOUND_MASK_PCM)
814 if ((r = pa_oss_get_volume(u->mixer_fd, SOUND_MIXER_READ_PCM, &s->sample_spec, &s->volume)) >= 0)
815 return r;
816
817 pa_log_info("Device doesn't support reading mixer settings: %s", pa_cstrerror(errno));
818 return -1;
819 }
820
821 static int sink_set_volume(pa_sink *s) {
822 struct userdata *u;
823 int r;
824
825 pa_assert_se(u = s->userdata);
826
827 pa_assert(u->mixer_devmask & (SOUND_MASK_VOLUME|SOUND_MASK_PCM));
828
829 if (u->mixer_devmask & SOUND_MASK_VOLUME)
830 if ((r = pa_oss_set_volume(u->mixer_fd, SOUND_MIXER_WRITE_VOLUME, &s->sample_spec, &s->volume)) >= 0)
831 return r;
832
833 if (u->mixer_devmask & SOUND_MASK_PCM)
834 if ((r = pa_oss_get_volume(u->mixer_fd, SOUND_MIXER_WRITE_PCM, &s->sample_spec, &s->volume)) >= 0)
835 return r;
836
837 pa_log_info("Device doesn't support writing mixer settings: %s", pa_cstrerror(errno));
838 return -1;
839 }
840
841 static int source_get_volume(pa_source *s) {
842 struct userdata *u;
843 int r;
844
845 pa_assert_se(u = s->userdata);
846
847 pa_assert(u->mixer_devmask & (SOUND_MASK_IGAIN|SOUND_MASK_RECLEV));
848
849 if (u->mixer_devmask & SOUND_MASK_IGAIN)
850 if ((r = pa_oss_get_volume(u->mixer_fd, SOUND_MIXER_READ_IGAIN, &s->sample_spec, &s->volume)) >= 0)
851 return r;
852
853 if (u->mixer_devmask & SOUND_MASK_RECLEV)
854 if ((r = pa_oss_get_volume(u->mixer_fd, SOUND_MIXER_READ_RECLEV, &s->sample_spec, &s->volume)) >= 0)
855 return r;
856
857 pa_log_info("Device doesn't support reading mixer settings: %s", pa_cstrerror(errno));
858 return -1;
859 }
860
861 static int source_set_volume(pa_source *s) {
862 struct userdata *u;
863 int r;
864
865 pa_assert_se(u = s->userdata);
866
867 pa_assert(u->mixer_devmask & (SOUND_MASK_IGAIN|SOUND_MASK_RECLEV));
868
869 if (u->mixer_devmask & SOUND_MASK_IGAIN)
870 if ((r = pa_oss_set_volume(u->mixer_fd, SOUND_MIXER_WRITE_IGAIN, &s->sample_spec, &s->volume)) >= 0)
871 return r;
872
873 if (u->mixer_devmask & SOUND_MASK_RECLEV)
874 if ((r = pa_oss_get_volume(u->mixer_fd, SOUND_MIXER_WRITE_RECLEV, &s->sample_spec, &s->volume)) >= 0)
875 return r;
876
877 pa_log_info("Device doesn't support writing mixer settings: %s", pa_cstrerror(errno));
878 return -1;
879 }
880
881 static void thread_func(void *userdata) {
882 struct userdata *u = userdata;
883 int write_type = 0, read_type = 0;
884 short revents = 0;
885
886 pa_assert(u);
887
888 pa_log_debug("Thread starting up");
889
890 if (u->core->realtime_scheduling)
891 pa_make_realtime(u->core->realtime_priority);
892
893 pa_thread_mq_install(&u->thread_mq);
894 pa_rtpoll_install(u->rtpoll);
895
896 for (;;) {
897 int ret;
898
899 /* pa_log("loop"); */
900
901 if (u->sink && PA_SINK_IS_OPENED(u->sink->thread_info.state))
902 if (u->sink->thread_info.rewind_requested)
903 pa_sink_process_rewind(u->sink, 0);
904
905 /* Render some data and write it to the dsp */
906
907 if (u->sink && PA_SINK_IS_OPENED(u->sink->thread_info.state) && ((revents & POLLOUT) || u->use_mmap || u->use_getospace)) {
908
909 if (u->use_mmap) {
910
911 if ((ret = mmap_write(u)) < 0)
912 goto fail;
913
914 revents &= ~POLLOUT;
915
916 if (ret > 0)
917 continue;
918
919 } else {
920 ssize_t l;
921 pa_bool_t loop = FALSE, work_done = FALSE;
922
923 l = (ssize_t) u->out_fragment_size;
924
925 if (u->use_getospace) {
926 audio_buf_info info;
927
928 if (ioctl(u->fd, SNDCTL_DSP_GETOSPACE, &info) < 0) {
929 pa_log_info("Device doesn't support SNDCTL_DSP_GETOSPACE: %s", pa_cstrerror(errno));
930 u->use_getospace = FALSE;
931 } else {
932 l = info.bytes;
933
934 /* We loop only if GETOSPACE worked and we
935 * actually *know* that we can write more than
936 * one fragment at a time */
937 loop = TRUE;
938 }
939 }
940
941 /* Round down to multiples of the fragment size,
942 * because OSS needs that (at least some versions
943 * do) */
944 l = (l/(ssize_t) u->out_fragment_size) * (ssize_t) u->out_fragment_size;
945
946 /* Hmm, so poll() signalled us that we can read
947 * something, but GETOSPACE told us there was nothing?
948 * Hmm, make the best of it, try to read some data, to
949 * avoid spinning forever. */
950 if (l <= 0 && (revents & POLLOUT)) {
951 l = (ssize_t) u->out_fragment_size;
952 loop = FALSE;
953 }
954
955 while (l > 0) {
956 void *p;
957 ssize_t t;
958
959 if (u->memchunk.length <= 0)
960 pa_sink_render(u->sink, (size_t) l, &u->memchunk);
961
962 pa_assert(u->memchunk.length > 0);
963
964 p = pa_memblock_acquire(u->memchunk.memblock);
965 t = pa_write(u->fd, (uint8_t*) p + u->memchunk.index, u->memchunk.length, &write_type);
966 pa_memblock_release(u->memchunk.memblock);
967
968 /* pa_log("wrote %i bytes of %u", t, l); */
969
970 pa_assert(t != 0);
971
972 if (t < 0) {
973
974 if (errno == EINTR)
975 continue;
976
977 else if (errno == EAGAIN) {
978 pa_log_debug("EAGAIN");
979
980 revents &= ~POLLOUT;
981 break;
982
983 } else {
984 pa_log("Failed to write data to DSP: %s", pa_cstrerror(errno));
985 goto fail;
986 }
987
988 } else {
989
990 u->memchunk.index += (size_t) t;
991 u->memchunk.length -= (size_t) t;
992
993 if (u->memchunk.length <= 0) {
994 pa_memblock_unref(u->memchunk.memblock);
995 pa_memchunk_reset(&u->memchunk);
996 }
997
998 l -= t;
999
1000 revents &= ~POLLOUT;
1001 work_done = TRUE;
1002 }
1003
1004 if (!loop)
1005 break;
1006 }
1007
1008 if (work_done)
1009 continue;
1010 }
1011 }
1012
1013 /* Try to read some data and pass it on to the source driver. */
1014
1015 if (u->source && PA_SOURCE_IS_OPENED(u->source->thread_info.state) && ((revents & POLLIN) || u->use_mmap || u->use_getispace)) {
1016
1017 if (u->use_mmap) {
1018
1019 if ((ret = mmap_read(u)) < 0)
1020 goto fail;
1021
1022 revents &= ~POLLIN;
1023
1024 if (ret > 0)
1025 continue;
1026
1027 } else {
1028
1029 void *p;
1030 ssize_t l;
1031 pa_memchunk memchunk;
1032 pa_bool_t loop = FALSE, work_done = FALSE;
1033
1034 l = (ssize_t) u->in_fragment_size;
1035
1036 if (u->use_getispace) {
1037 audio_buf_info info;
1038
1039 if (ioctl(u->fd, SNDCTL_DSP_GETISPACE, &info) < 0) {
1040 pa_log_info("Device doesn't support SNDCTL_DSP_GETISPACE: %s", pa_cstrerror(errno));
1041 u->use_getispace = FALSE;
1042 } else {
1043 l = info.bytes;
1044 loop = TRUE;
1045 }
1046 }
1047
1048 l = (l/(ssize_t) u->in_fragment_size) * (ssize_t) u->in_fragment_size;
1049
1050 if (l <= 0 && (revents & POLLIN)) {
1051 l = (ssize_t) u->in_fragment_size;
1052 loop = FALSE;
1053 }
1054
1055 while (l > 0) {
1056 ssize_t t;
1057 size_t k;
1058
1059 pa_assert(l > 0);
1060
1061 memchunk.memblock = pa_memblock_new(u->core->mempool, (size_t) -1);
1062
1063 k = pa_memblock_get_length(memchunk.memblock);
1064
1065 if (k > (size_t) l)
1066 k = (size_t) l;
1067
1068 k = (k/u->frame_size)*u->frame_size;
1069
1070 p = pa_memblock_acquire(memchunk.memblock);
1071 t = pa_read(u->fd, p, k, &read_type);
1072 pa_memblock_release(memchunk.memblock);
1073
1074 pa_assert(t != 0); /* EOF cannot happen */
1075
1076 /* pa_log("read %i bytes of %u", t, l); */
1077
1078 if (t < 0) {
1079 pa_memblock_unref(memchunk.memblock);
1080
1081 if (errno == EINTR)
1082 continue;
1083
1084 else if (errno == EAGAIN) {
1085 pa_log_debug("EAGAIN");
1086
1087 revents &= ~POLLIN;
1088 break;
1089
1090 } else {
1091 pa_log("Failed to read data from DSP: %s", pa_cstrerror(errno));
1092 goto fail;
1093 }
1094
1095 } else {
1096 memchunk.index = 0;
1097 memchunk.length = (size_t) t;
1098
1099 pa_source_post(u->source, &memchunk);
1100 pa_memblock_unref(memchunk.memblock);
1101
1102 l -= t;
1103
1104 revents &= ~POLLIN;
1105 work_done = TRUE;
1106 }
1107
1108 if (!loop)
1109 break;
1110 }
1111
1112 if (work_done)
1113 continue;
1114 }
1115 }
1116
1117 /* pa_log("loop2 revents=%i", revents); */
1118
1119 if (u->rtpoll_item) {
1120 struct pollfd *pollfd;
1121
1122 pa_assert(u->fd >= 0);
1123
1124 pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL);
1125 pollfd->events = (short)
1126 (((u->source && PA_SOURCE_IS_OPENED(u->source->thread_info.state)) ? POLLIN : 0) |
1127 ((u->sink && PA_SINK_IS_OPENED(u->sink->thread_info.state)) ? POLLOUT : 0));
1128 }
1129
1130 /* Hmm, nothing to do. Let's sleep */
1131 if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
1132 goto fail;
1133
1134 if (ret == 0)
1135 goto finish;
1136
1137 if (u->rtpoll_item) {
1138 struct pollfd *pollfd;
1139
1140 pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL);
1141
1142 if (pollfd->revents & ~(POLLOUT|POLLIN)) {
1143 pa_log("DSP shutdown.");
1144 goto fail;
1145 }
1146
1147 revents = pollfd->revents;
1148 } else
1149 revents = 0;
1150 }
1151
1152 fail:
1153 /* If this was no regular exit from the loop we have to continue
1154 * processing messages until we received PA_MESSAGE_SHUTDOWN */
1155 pa_asyncmsgq_post(u->thread_mq.outq, PA_MSGOBJECT(u->core), PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0, NULL, NULL);
1156 pa_asyncmsgq_wait_for(u->thread_mq.inq, PA_MESSAGE_SHUTDOWN);
1157
1158 finish:
1159 pa_log_debug("Thread shutting down");
1160 }
1161
1162 int pa__init(pa_module*m) {
1163
1164 struct audio_buf_info info;
1165 struct userdata *u = NULL;
1166 const char *dev;
1167 int fd = -1;
1168 int nfrags, orig_frag_size, frag_size;
1169 int mode, caps;
1170 pa_bool_t record = TRUE, playback = TRUE, use_mmap = TRUE;
1171 pa_sample_spec ss;
1172 pa_channel_map map;
1173 pa_modargs *ma = NULL;
1174 char hwdesc[64];
1175 const char *name;
1176 pa_bool_t namereg_fail;
1177 pa_sink_new_data sink_new_data;
1178 pa_source_new_data source_new_data;
1179
1180 pa_assert(m);
1181
1182 if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
1183 pa_log("Failed to parse module arguments.");
1184 goto fail;
1185 }
1186
1187 if (pa_modargs_get_value_boolean(ma, "record", &record) < 0 || pa_modargs_get_value_boolean(ma, "playback", &playback) < 0) {
1188 pa_log("record= and playback= expect boolean argument.");
1189 goto fail;
1190 }
1191
1192 if (!playback && !record) {
1193 pa_log("Neither playback nor record enabled for device.");
1194 goto fail;
1195 }
1196
1197 mode = (playback && record) ? O_RDWR : (playback ? O_WRONLY : (record ? O_RDONLY : 0));
1198
1199 ss = m->core->default_sample_spec;
1200 if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_OSS) < 0) {
1201 pa_log("Failed to parse sample specification or channel map");
1202 goto fail;
1203 }
1204
1205 nfrags = (int) m->core->default_n_fragments;
1206 frag_size = (int) pa_usec_to_bytes(m->core->default_fragment_size_msec*1000, &ss);
1207 if (frag_size <= 0)
1208 frag_size = (int) pa_frame_size(&ss);
1209
1210 if (pa_modargs_get_value_s32(ma, "fragments", &nfrags) < 0 || pa_modargs_get_value_s32(ma, "fragment_size", &frag_size) < 0) {
1211 pa_log("Failed to parse fragments arguments");
1212 goto fail;
1213 }
1214
1215 if (pa_modargs_get_value_boolean(ma, "mmap", &use_mmap) < 0) {
1216 pa_log("Failed to parse mmap argument.");
1217 goto fail;
1218 }
1219
1220 if ((fd = pa_oss_open(dev = pa_modargs_get_value(ma, "device", DEFAULT_DEVICE), &mode, &caps)) < 0)
1221 goto fail;
1222
1223 if (use_mmap && (!(caps & DSP_CAP_MMAP) || !(caps & DSP_CAP_TRIGGER))) {
1224 pa_log_info("OSS device not mmap capable, falling back to UNIX read/write mode.");
1225 use_mmap = FALSE;
1226 }
1227
1228 if (use_mmap && mode == O_WRONLY) {
1229 pa_log_info("Device opened for playback only, cannot do memory mapping, falling back to UNIX write() mode.");
1230 use_mmap = FALSE;
1231 }
1232
1233 if (pa_oss_get_hw_description(dev, hwdesc, sizeof(hwdesc)) >= 0)
1234 pa_log_info("Hardware name is '%s'.", hwdesc);
1235 else
1236 hwdesc[0] = 0;
1237
1238 pa_log_info("Device opened in %s mode.", mode == O_WRONLY ? "O_WRONLY" : (mode == O_RDONLY ? "O_RDONLY" : "O_RDWR"));
1239
1240 orig_frag_size = frag_size;
1241 if (nfrags >= 2 && frag_size >= 1)
1242 if (pa_oss_set_fragments(fd, nfrags, frag_size) < 0)
1243 goto fail;
1244
1245 if (pa_oss_auto_format(fd, &ss) < 0)
1246 goto fail;
1247
1248 if (ioctl(fd, SNDCTL_DSP_GETBLKSIZE, &frag_size) < 0) {
1249 pa_log("SNDCTL_DSP_GETBLKSIZE: %s", pa_cstrerror(errno));
1250 goto fail;
1251 }
1252 pa_assert(frag_size > 0);
1253
1254 u = pa_xnew0(struct userdata, 1);
1255 u->core = m->core;
1256 u->module = m;
1257 m->userdata = u;
1258 u->fd = fd;
1259 u->mixer_fd = -1;
1260 u->mixer_devmask = 0;
1261 u->use_getospace = u->use_getispace = TRUE;
1262 u->use_getodelay = TRUE;
1263 u->mode = mode;
1264 u->frame_size = pa_frame_size(&ss);
1265 u->device_name = pa_xstrdup(dev);
1266 u->in_nfrags = u->out_nfrags = (uint32_t) (u->nfrags = nfrags);
1267 u->out_fragment_size = u->in_fragment_size = (uint32_t) (u->frag_size = frag_size);
1268 u->orig_frag_size = orig_frag_size;
1269 u->use_mmap = use_mmap;
1270 u->rtpoll = pa_rtpoll_new();
1271 pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
1272 u->rtpoll_item = NULL;
1273 build_pollfd(u);
1274
1275 if (ioctl(fd, SNDCTL_DSP_GETISPACE, &info) >= 0) {
1276 pa_log_info("Input -- %u fragments of size %u.", info.fragstotal, info.fragsize);
1277 u->in_fragment_size = (uint32_t) info.fragsize;
1278 u->in_nfrags = (uint32_t) info.fragstotal;
1279 u->use_getispace = TRUE;
1280 }
1281
1282 if (ioctl(fd, SNDCTL_DSP_GETOSPACE, &info) >= 0) {
1283 pa_log_info("Output -- %u fragments of size %u.", info.fragstotal, info.fragsize);
1284 u->out_fragment_size = (uint32_t) info.fragsize;
1285 u->out_nfrags = (uint32_t) info.fragstotal;
1286 u->use_getospace = TRUE;
1287 }
1288
1289 u->in_hwbuf_size = u->in_nfrags * u->in_fragment_size;
1290 u->out_hwbuf_size = u->out_nfrags * u->out_fragment_size;
1291
1292 if (mode != O_WRONLY) {
1293 char *name_buf = NULL;
1294
1295 if (use_mmap) {
1296 if ((u->in_mmap = mmap(NULL, u->in_hwbuf_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
1297 pa_log_warn("mmap(PROT_READ) failed, reverting to non-mmap mode: %s", pa_cstrerror(errno));
1298 use_mmap = u->use_mmap = FALSE;
1299 u->in_mmap = NULL;
1300 } else
1301 pa_log_debug("Successfully mmap()ed input buffer.");
1302 }
1303
1304 if ((name = pa_modargs_get_value(ma, "source_name", NULL)))
1305 namereg_fail = TRUE;
1306 else {
1307 name = name_buf = pa_sprintf_malloc("oss_input.%s", pa_path_get_filename(dev));
1308 namereg_fail = FALSE;
1309 }
1310
1311 pa_source_new_data_init(&source_new_data);
1312 source_new_data.driver = __FILE__;
1313 source_new_data.module = m;
1314 pa_source_new_data_set_name(&source_new_data, name);
1315 source_new_data.namereg_fail = namereg_fail;
1316 pa_source_new_data_set_sample_spec(&source_new_data, &ss);
1317 pa_source_new_data_set_channel_map(&source_new_data, &map);
1318 pa_proplist_sets(source_new_data.proplist, PA_PROP_DEVICE_STRING, dev);
1319 pa_proplist_sets(source_new_data.proplist, PA_PROP_DEVICE_API, "oss");
1320 pa_proplist_sets(source_new_data.proplist, PA_PROP_DEVICE_DESCRIPTION, hwdesc[0] ? hwdesc : dev);
1321 pa_proplist_sets(source_new_data.proplist, PA_PROP_DEVICE_ACCESS_MODE, use_mmap ? "mmap" : "serial");
1322 pa_proplist_setf(source_new_data.proplist, PA_PROP_DEVICE_BUFFERING_BUFFER_SIZE, "%lu", (unsigned long) (u->in_hwbuf_size));
1323 pa_proplist_setf(source_new_data.proplist, PA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZE, "%lu", (unsigned long) (u->in_fragment_size));
1324
1325 u->source = pa_source_new(m->core, &source_new_data, PA_SOURCE_HARDWARE|PA_SOURCE_LATENCY);
1326 pa_source_new_data_done(&source_new_data);
1327 pa_xfree(name_buf);
1328
1329 if (!u->source) {
1330 pa_log("Failed to create source object");
1331 goto fail;
1332 }
1333
1334 u->source->parent.process_msg = source_process_msg;
1335 u->source->userdata = u;
1336
1337 pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
1338 pa_source_set_rtpoll(u->source, u->rtpoll);
1339 u->source->refresh_volume = TRUE;
1340
1341 if (use_mmap)
1342 u->in_mmap_memblocks = pa_xnew0(pa_memblock*, u->in_nfrags);
1343 }
1344
1345 if (mode != O_RDONLY) {
1346 char *name_buf = NULL;
1347
1348 if (use_mmap) {
1349 if ((u->out_mmap = mmap(NULL, u->out_hwbuf_size, PROT_WRITE, MAP_SHARED, fd, 0)) == MAP_FAILED) {
1350 if (mode == O_RDWR) {
1351 pa_log_debug("mmap() failed for input. Changing to O_WRONLY mode.");
1352 mode = O_WRONLY;
1353 goto go_on;
1354 } else {
1355 pa_log_warn("mmap(PROT_WRITE) failed, reverting to non-mmap mode: %s", pa_cstrerror(errno));
1356 u->use_mmap = use_mmap = FALSE;
1357 u->out_mmap = NULL;
1358 }
1359 } else {
1360 pa_log_debug("Successfully mmap()ed output buffer.");
1361 pa_silence_memory(u->out_mmap, u->out_hwbuf_size, &ss);
1362 }
1363 }
1364
1365 if ((name = pa_modargs_get_value(ma, "sink_name", NULL)))
1366 namereg_fail = TRUE;
1367 else {
1368 name = name_buf = pa_sprintf_malloc("oss_output.%s", pa_path_get_filename(dev));
1369 namereg_fail = FALSE;
1370 }
1371
1372 pa_sink_new_data_init(&sink_new_data);
1373 sink_new_data.driver = __FILE__;
1374 sink_new_data.module = m;
1375 pa_sink_new_data_set_name(&sink_new_data, name);
1376 sink_new_data.namereg_fail = namereg_fail;
1377 pa_sink_new_data_set_sample_spec(&sink_new_data, &ss);
1378 pa_sink_new_data_set_channel_map(&sink_new_data, &map);
1379 pa_proplist_sets(sink_new_data.proplist, PA_PROP_DEVICE_STRING, dev);
1380 pa_proplist_sets(sink_new_data.proplist, PA_PROP_DEVICE_API, "oss");
1381 pa_proplist_sets(sink_new_data.proplist, PA_PROP_DEVICE_DESCRIPTION, hwdesc[0] ? hwdesc : dev);
1382 pa_proplist_sets(sink_new_data.proplist, PA_PROP_DEVICE_ACCESS_MODE, use_mmap ? "mmap" : "serial");
1383 pa_proplist_setf(sink_new_data.proplist, PA_PROP_DEVICE_BUFFERING_BUFFER_SIZE, "%lu", (unsigned long) (u->out_hwbuf_size));
1384 pa_proplist_setf(sink_new_data.proplist, PA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZE, "%lu", (unsigned long) (u->out_fragment_size));
1385
1386 u->sink = pa_sink_new(m->core, &sink_new_data, PA_SINK_HARDWARE|PA_SINK_LATENCY);
1387 pa_sink_new_data_done(&sink_new_data);
1388 pa_xfree(name_buf);
1389
1390 if (!u->sink) {
1391 pa_log("Failed to create sink object");
1392 goto fail;
1393 }
1394
1395 u->sink->parent.process_msg = sink_process_msg;
1396 u->sink->userdata = u;
1397
1398 pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
1399 pa_sink_set_rtpoll(u->sink, u->rtpoll);
1400 u->sink->refresh_volume = TRUE;
1401
1402 u->sink->thread_info.max_request = u->out_hwbuf_size;
1403
1404 if (use_mmap)
1405 u->out_mmap_memblocks = pa_xnew0(pa_memblock*, u->out_nfrags);
1406 }
1407
1408 if ((u->mixer_fd = pa_oss_open_mixer_for_device(u->device_name)) >= 0) {
1409 pa_bool_t do_close = TRUE;
1410
1411 if (ioctl(fd, SOUND_MIXER_READ_DEVMASK, &u->mixer_devmask) < 0)
1412 pa_log_warn("SOUND_MIXER_READ_DEVMASK failed: %s", pa_cstrerror(errno));
1413
1414 else {
1415 if (u->sink && (u->mixer_devmask & (SOUND_MASK_VOLUME|SOUND_MASK_PCM))) {
1416 pa_log_debug("Found hardware mixer track for playback.");
1417 u->sink->flags |= PA_SINK_HW_VOLUME_CTRL;
1418 u->sink->get_volume = sink_get_volume;
1419 u->sink->set_volume = sink_set_volume;
1420 do_close = FALSE;
1421 }
1422
1423 if (u->source && (u->mixer_devmask & (SOUND_MASK_RECLEV|SOUND_MASK_IGAIN))) {
1424 pa_log_debug("Found hardware mixer track for recording.");
1425 u->source->flags |= PA_SOURCE_HW_VOLUME_CTRL;
1426 u->source->get_volume = source_get_volume;
1427 u->source->set_volume = source_set_volume;
1428 do_close = FALSE;
1429 }
1430 }
1431
1432 if (do_close) {
1433 pa_close(u->mixer_fd);
1434 u->mixer_fd = -1;
1435 u->mixer_devmask = 0;
1436 }
1437 }
1438
1439 go_on:
1440
1441 pa_assert(u->source || u->sink);
1442
1443 pa_memchunk_reset(&u->memchunk);
1444
1445 if (!(u->thread = pa_thread_new(thread_func, u))) {
1446 pa_log("Failed to create thread.");
1447 goto fail;
1448 }
1449
1450 /* Read mixer settings */
1451 if (u->sink) {
1452 if (sink_new_data.volume_is_set) {
1453 if (u->sink->set_volume)
1454 u->sink->set_volume(u->sink);
1455 } else {
1456 if (u->sink->get_volume)
1457 u->sink->get_volume(u->sink);
1458 }
1459 }
1460
1461 if (u->source) {
1462 if (source_new_data.volume_is_set) {
1463 if (u->source->set_volume)
1464 u->source->set_volume(u->source);
1465 } else {
1466 if (u->source->get_volume)
1467 u->source->get_volume(u->source);
1468 }
1469 }
1470
1471 if (u->sink)
1472 pa_sink_put(u->sink);
1473 if (u->source)
1474 pa_source_put(u->source);
1475
1476 pa_modargs_free(ma);
1477
1478 return 0;
1479
1480 fail:
1481
1482 if (u)
1483 pa__done(m);
1484 else if (fd >= 0)
1485 pa_close(fd);
1486
1487 if (ma)
1488 pa_modargs_free(ma);
1489
1490 return -1;
1491 }
1492
1493 void pa__done(pa_module*m) {
1494 struct userdata *u;
1495
1496 pa_assert(m);
1497
1498 if (!(u = m->userdata))
1499 return;
1500
1501 if (u->sink)
1502 pa_sink_unlink(u->sink);
1503
1504 if (u->source)
1505 pa_source_unlink(u->source);
1506
1507 if (u->thread) {
1508 pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
1509 pa_thread_free(u->thread);
1510 }
1511
1512 pa_thread_mq_done(&u->thread_mq);
1513
1514 if (u->sink)
1515 pa_sink_unref(u->sink);
1516
1517 if (u->source)
1518 pa_source_unref(u->source);
1519
1520 if (u->memchunk.memblock)
1521 pa_memblock_unref(u->memchunk.memblock);
1522
1523 if (u->rtpoll_item)
1524 pa_rtpoll_item_free(u->rtpoll_item);
1525
1526 if (u->rtpoll)
1527 pa_rtpoll_free(u->rtpoll);
1528
1529 if (u->out_mmap_memblocks) {
1530 unsigned i;
1531 for (i = 0; i < u->out_nfrags; i++)
1532 if (u->out_mmap_memblocks[i])
1533 pa_memblock_unref_fixed(u->out_mmap_memblocks[i]);
1534 pa_xfree(u->out_mmap_memblocks);
1535 }
1536
1537 if (u->in_mmap_memblocks) {
1538 unsigned i;
1539 for (i = 0; i < u->in_nfrags; i++)
1540 if (u->in_mmap_memblocks[i])
1541 pa_memblock_unref_fixed(u->in_mmap_memblocks[i]);
1542 pa_xfree(u->in_mmap_memblocks);
1543 }
1544
1545 if (u->in_mmap && u->in_mmap != MAP_FAILED)
1546 munmap(u->in_mmap, u->in_hwbuf_size);
1547
1548 if (u->out_mmap && u->out_mmap != MAP_FAILED)
1549 munmap(u->out_mmap, u->out_hwbuf_size);
1550
1551 if (u->fd >= 0)
1552 pa_close(u->fd);
1553
1554 if (u->mixer_fd >= 0)
1555 pa_close(u->mixer_fd);
1556
1557 pa_xfree(u->device_name);
1558
1559 pa_xfree(u);
1560 }