Merge remote-tracking branch 'remotes/mst/tags/for_upstream' into staging
[qemu.git] / audio / ossaudio.c
1 /*
2 * QEMU OSS audio driver
3 *
4 * Copyright (c) 2003-2005 Vassili Karpov (malc)
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24
25 #include "qemu/osdep.h"
26 #include <sys/ioctl.h>
27 #include <sys/soundcard.h>
28 #include "qemu/main-loop.h"
29 #include "qemu/module.h"
30 #include "qemu/host-utils.h"
31 #include "audio.h"
32 #include "trace.h"
33
34 #define AUDIO_CAP "oss"
35 #include "audio_int.h"
36
37 #if defined OSS_GETVERSION && defined SNDCTL_DSP_POLICY
38 #define USE_DSP_POLICY
39 #endif
40
41 typedef struct OSSVoiceOut {
42 HWVoiceOut hw;
43 int fd;
44 int nfrags;
45 int fragsize;
46 int mmapped;
47 Audiodev *dev;
48 } OSSVoiceOut;
49
50 typedef struct OSSVoiceIn {
51 HWVoiceIn hw;
52 int fd;
53 int nfrags;
54 int fragsize;
55 Audiodev *dev;
56 } OSSVoiceIn;
57
58 struct oss_params {
59 int freq;
60 int fmt;
61 int nchannels;
62 int nfrags;
63 int fragsize;
64 };
65
66 static void GCC_FMT_ATTR (2, 3) oss_logerr (int err, const char *fmt, ...)
67 {
68 va_list ap;
69
70 va_start (ap, fmt);
71 AUD_vlog (AUDIO_CAP, fmt, ap);
72 va_end (ap);
73
74 AUD_log (AUDIO_CAP, "Reason: %s\n", strerror (err));
75 }
76
77 static void GCC_FMT_ATTR (3, 4) oss_logerr2 (
78 int err,
79 const char *typ,
80 const char *fmt,
81 ...
82 )
83 {
84 va_list ap;
85
86 AUD_log (AUDIO_CAP, "Could not initialize %s\n", typ);
87
88 va_start (ap, fmt);
89 AUD_vlog (AUDIO_CAP, fmt, ap);
90 va_end (ap);
91
92 AUD_log (AUDIO_CAP, "Reason: %s\n", strerror (err));
93 }
94
95 static void oss_anal_close (int *fdp)
96 {
97 int err;
98
99 qemu_set_fd_handler (*fdp, NULL, NULL, NULL);
100 err = close (*fdp);
101 if (err) {
102 oss_logerr (errno, "Failed to close file(fd=%d)\n", *fdp);
103 }
104 *fdp = -1;
105 }
106
107 static void oss_helper_poll_out (void *opaque)
108 {
109 AudioState *s = opaque;
110 audio_run(s, "oss_poll_out");
111 }
112
113 static void oss_helper_poll_in (void *opaque)
114 {
115 AudioState *s = opaque;
116 audio_run(s, "oss_poll_in");
117 }
118
119 static void oss_poll_out (HWVoiceOut *hw)
120 {
121 OSSVoiceOut *oss = (OSSVoiceOut *) hw;
122
123 qemu_set_fd_handler(oss->fd, NULL, oss_helper_poll_out, hw->s);
124 }
125
126 static void oss_poll_in (HWVoiceIn *hw)
127 {
128 OSSVoiceIn *oss = (OSSVoiceIn *) hw;
129
130 qemu_set_fd_handler(oss->fd, oss_helper_poll_in, NULL, hw->s);
131 }
132
133 static int aud_to_ossfmt (AudioFormat fmt, int endianness)
134 {
135 switch (fmt) {
136 case AUDIO_FORMAT_S8:
137 return AFMT_S8;
138
139 case AUDIO_FORMAT_U8:
140 return AFMT_U8;
141
142 case AUDIO_FORMAT_S16:
143 if (endianness) {
144 return AFMT_S16_BE;
145 }
146 else {
147 return AFMT_S16_LE;
148 }
149
150 case AUDIO_FORMAT_U16:
151 if (endianness) {
152 return AFMT_U16_BE;
153 }
154 else {
155 return AFMT_U16_LE;
156 }
157
158 default:
159 dolog ("Internal logic error: Bad audio format %d\n", fmt);
160 #ifdef DEBUG_AUDIO
161 abort ();
162 #endif
163 return AFMT_U8;
164 }
165 }
166
167 static int oss_to_audfmt (int ossfmt, AudioFormat *fmt, int *endianness)
168 {
169 switch (ossfmt) {
170 case AFMT_S8:
171 *endianness = 0;
172 *fmt = AUDIO_FORMAT_S8;
173 break;
174
175 case AFMT_U8:
176 *endianness = 0;
177 *fmt = AUDIO_FORMAT_U8;
178 break;
179
180 case AFMT_S16_LE:
181 *endianness = 0;
182 *fmt = AUDIO_FORMAT_S16;
183 break;
184
185 case AFMT_U16_LE:
186 *endianness = 0;
187 *fmt = AUDIO_FORMAT_U16;
188 break;
189
190 case AFMT_S16_BE:
191 *endianness = 1;
192 *fmt = AUDIO_FORMAT_S16;
193 break;
194
195 case AFMT_U16_BE:
196 *endianness = 1;
197 *fmt = AUDIO_FORMAT_U16;
198 break;
199
200 default:
201 dolog ("Unrecognized audio format %d\n", ossfmt);
202 return -1;
203 }
204
205 return 0;
206 }
207
208 #if defined DEBUG_MISMATCHES || defined DEBUG
209 static void oss_dump_info (struct oss_params *req, struct oss_params *obt)
210 {
211 dolog ("parameter | requested value | obtained value\n");
212 dolog ("format | %10d | %10d\n", req->fmt, obt->fmt);
213 dolog ("channels | %10d | %10d\n",
214 req->nchannels, obt->nchannels);
215 dolog ("frequency | %10d | %10d\n", req->freq, obt->freq);
216 dolog ("nfrags | %10d | %10d\n", req->nfrags, obt->nfrags);
217 dolog ("fragsize | %10d | %10d\n",
218 req->fragsize, obt->fragsize);
219 }
220 #endif
221
222 #ifdef USE_DSP_POLICY
223 static int oss_get_version (int fd, int *version, const char *typ)
224 {
225 if (ioctl (fd, OSS_GETVERSION, &version)) {
226 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
227 /*
228 * Looks like atm (20100109) FreeBSD knows OSS_GETVERSION
229 * since 7.x, but currently only on the mixer device (or in
230 * the Linuxolator), and in the native version that part of
231 * the code is in fact never reached so the ioctl fails anyway.
232 * Until this is fixed, just check the errno and if its what
233 * FreeBSD's sound drivers return atm assume they are new enough.
234 */
235 if (errno == EINVAL) {
236 *version = 0x040000;
237 return 0;
238 }
239 #endif
240 oss_logerr2 (errno, typ, "Failed to get OSS version\n");
241 return -1;
242 }
243 return 0;
244 }
245 #endif
246
247 static int oss_open(int in, struct oss_params *req, audsettings *as,
248 struct oss_params *obt, int *pfd, Audiodev *dev)
249 {
250 AudiodevOssOptions *oopts = &dev->u.oss;
251 AudiodevOssPerDirectionOptions *opdo = in ? oopts->in : oopts->out;
252 int fd;
253 int oflags = (oopts->has_exclusive && oopts->exclusive) ? O_EXCL : 0;
254 audio_buf_info abinfo;
255 int fmt, freq, nchannels;
256 int setfragment = 1;
257 const char *dspname = opdo->has_dev ? opdo->dev : "/dev/dsp";
258 const char *typ = in ? "ADC" : "DAC";
259 #ifdef USE_DSP_POLICY
260 int policy = oopts->has_dsp_policy ? oopts->dsp_policy : 5;
261 #endif
262
263 /* Kludge needed to have working mmap on Linux */
264 oflags |= (oopts->has_try_mmap && oopts->try_mmap) ?
265 O_RDWR : (in ? O_RDONLY : O_WRONLY);
266
267 fd = open (dspname, oflags | O_NONBLOCK);
268 if (-1 == fd) {
269 oss_logerr2 (errno, typ, "Failed to open `%s'\n", dspname);
270 return -1;
271 }
272
273 freq = req->freq;
274 nchannels = req->nchannels;
275 fmt = req->fmt;
276 req->nfrags = opdo->has_buffer_count ? opdo->buffer_count : 4;
277 req->fragsize = audio_buffer_bytes(
278 qapi_AudiodevOssPerDirectionOptions_base(opdo), as, 23220);
279
280 if (ioctl (fd, SNDCTL_DSP_SAMPLESIZE, &fmt)) {
281 oss_logerr2 (errno, typ, "Failed to set sample size %d\n", req->fmt);
282 goto err;
283 }
284
285 if (ioctl (fd, SNDCTL_DSP_CHANNELS, &nchannels)) {
286 oss_logerr2 (errno, typ, "Failed to set number of channels %d\n",
287 req->nchannels);
288 goto err;
289 }
290
291 if (ioctl (fd, SNDCTL_DSP_SPEED, &freq)) {
292 oss_logerr2 (errno, typ, "Failed to set frequency %d\n", req->freq);
293 goto err;
294 }
295
296 if (ioctl (fd, SNDCTL_DSP_NONBLOCK, NULL)) {
297 oss_logerr2 (errno, typ, "Failed to set non-blocking mode\n");
298 goto err;
299 }
300
301 #ifdef USE_DSP_POLICY
302 if (policy >= 0) {
303 int version;
304
305 if (!oss_get_version (fd, &version, typ)) {
306 trace_oss_version(version);
307
308 if (version >= 0x040000) {
309 int policy2 = policy;
310 if (ioctl(fd, SNDCTL_DSP_POLICY, &policy2)) {
311 oss_logerr2 (errno, typ,
312 "Failed to set timing policy to %d\n",
313 policy);
314 goto err;
315 }
316 setfragment = 0;
317 }
318 }
319 }
320 #endif
321
322 if (setfragment) {
323 int mmmmssss = (req->nfrags << 16) | ctz32 (req->fragsize);
324 if (ioctl (fd, SNDCTL_DSP_SETFRAGMENT, &mmmmssss)) {
325 oss_logerr2 (errno, typ, "Failed to set buffer length (%d, %d)\n",
326 req->nfrags, req->fragsize);
327 goto err;
328 }
329 }
330
331 if (ioctl (fd, in ? SNDCTL_DSP_GETISPACE : SNDCTL_DSP_GETOSPACE, &abinfo)) {
332 oss_logerr2 (errno, typ, "Failed to get buffer length\n");
333 goto err;
334 }
335
336 if (!abinfo.fragstotal || !abinfo.fragsize) {
337 AUD_log (AUDIO_CAP, "Returned bogus buffer information(%d, %d) for %s\n",
338 abinfo.fragstotal, abinfo.fragsize, typ);
339 goto err;
340 }
341
342 obt->fmt = fmt;
343 obt->nchannels = nchannels;
344 obt->freq = freq;
345 obt->nfrags = abinfo.fragstotal;
346 obt->fragsize = abinfo.fragsize;
347 *pfd = fd;
348
349 #ifdef DEBUG_MISMATCHES
350 if ((req->fmt != obt->fmt) ||
351 (req->nchannels != obt->nchannels) ||
352 (req->freq != obt->freq) ||
353 (req->fragsize != obt->fragsize) ||
354 (req->nfrags != obt->nfrags)) {
355 dolog ("Audio parameters mismatch\n");
356 oss_dump_info (req, obt);
357 }
358 #endif
359
360 #ifdef DEBUG
361 oss_dump_info (req, obt);
362 #endif
363 return 0;
364
365 err:
366 oss_anal_close (&fd);
367 return -1;
368 }
369
370 static size_t oss_get_available_bytes(OSSVoiceOut *oss)
371 {
372 int err;
373 struct count_info cntinfo;
374 assert(oss->mmapped);
375
376 err = ioctl(oss->fd, SNDCTL_DSP_GETOPTR, &cntinfo);
377 if (err < 0) {
378 oss_logerr(errno, "SNDCTL_DSP_GETOPTR failed\n");
379 return 0;
380 }
381
382 return audio_ring_dist(cntinfo.ptr, oss->hw.pos_emul, oss->hw.size_emul);
383 }
384
385 static void oss_run_buffer_out(HWVoiceOut *hw)
386 {
387 OSSVoiceOut *oss = (OSSVoiceOut *)hw;
388
389 if (!oss->mmapped) {
390 audio_generic_run_buffer_out(hw);
391 }
392 }
393
394 static void *oss_get_buffer_out(HWVoiceOut *hw, size_t *size)
395 {
396 OSSVoiceOut *oss = (OSSVoiceOut *) hw;
397 if (oss->mmapped) {
398 *size = MIN(oss_get_available_bytes(oss), hw->size_emul - hw->pos_emul);
399 return hw->buf_emul + hw->pos_emul;
400 } else {
401 return audio_generic_get_buffer_out(hw, size);
402 }
403 }
404
405 static size_t oss_put_buffer_out(HWVoiceOut *hw, void *buf, size_t size)
406 {
407 OSSVoiceOut *oss = (OSSVoiceOut *) hw;
408 if (oss->mmapped) {
409 assert(buf == hw->buf_emul + hw->pos_emul && size < hw->size_emul);
410
411 hw->pos_emul = (hw->pos_emul + size) % hw->size_emul;
412 return size;
413 } else {
414 return audio_generic_put_buffer_out(hw, buf, size);
415 }
416 }
417
418 static size_t oss_write(HWVoiceOut *hw, void *buf, size_t len)
419 {
420 OSSVoiceOut *oss = (OSSVoiceOut *) hw;
421 size_t pos;
422
423 if (oss->mmapped) {
424 size_t total_len;
425 len = MIN(len, oss_get_available_bytes(oss));
426
427 total_len = len;
428 while (len) {
429 size_t to_copy = MIN(len, hw->size_emul - hw->pos_emul);
430 memcpy(hw->buf_emul + hw->pos_emul, buf, to_copy);
431
432 hw->pos_emul = (hw->pos_emul + to_copy) % hw->size_emul;
433 buf += to_copy;
434 len -= to_copy;
435 }
436 return total_len;
437 }
438
439 pos = 0;
440 while (len) {
441 ssize_t bytes_written;
442 void *pcm = advance(buf, pos);
443
444 bytes_written = write(oss->fd, pcm, len);
445 if (bytes_written < 0) {
446 if (errno != EAGAIN) {
447 oss_logerr(errno, "failed to write %zu bytes\n",
448 len);
449 }
450 return pos;
451 }
452
453 pos += bytes_written;
454 if (bytes_written < len) {
455 break;
456 }
457 len -= bytes_written;
458 }
459 return pos;
460 }
461
462 static void oss_fini_out (HWVoiceOut *hw)
463 {
464 int err;
465 OSSVoiceOut *oss = (OSSVoiceOut *) hw;
466
467 ldebug ("oss_fini\n");
468 oss_anal_close (&oss->fd);
469
470 if (oss->mmapped && hw->buf_emul) {
471 err = munmap(hw->buf_emul, hw->size_emul);
472 if (err) {
473 oss_logerr(errno, "Failed to unmap buffer %p, size %zu\n",
474 hw->buf_emul, hw->size_emul);
475 }
476 hw->buf_emul = NULL;
477 }
478 }
479
480 static int oss_init_out(HWVoiceOut *hw, struct audsettings *as,
481 void *drv_opaque)
482 {
483 OSSVoiceOut *oss = (OSSVoiceOut *) hw;
484 struct oss_params req, obt;
485 int endianness;
486 int err;
487 int fd;
488 AudioFormat effective_fmt;
489 struct audsettings obt_as;
490 Audiodev *dev = drv_opaque;
491 AudiodevOssOptions *oopts = &dev->u.oss;
492
493 oss->fd = -1;
494
495 req.fmt = aud_to_ossfmt (as->fmt, as->endianness);
496 req.freq = as->freq;
497 req.nchannels = as->nchannels;
498
499 if (oss_open(0, &req, as, &obt, &fd, dev)) {
500 return -1;
501 }
502
503 err = oss_to_audfmt (obt.fmt, &effective_fmt, &endianness);
504 if (err) {
505 oss_anal_close (&fd);
506 return -1;
507 }
508
509 obt_as.freq = obt.freq;
510 obt_as.nchannels = obt.nchannels;
511 obt_as.fmt = effective_fmt;
512 obt_as.endianness = endianness;
513
514 audio_pcm_init_info (&hw->info, &obt_as);
515 oss->nfrags = obt.nfrags;
516 oss->fragsize = obt.fragsize;
517
518 if (obt.nfrags * obt.fragsize % hw->info.bytes_per_frame) {
519 dolog ("warning: Misaligned DAC buffer, size %d, alignment %d\n",
520 obt.nfrags * obt.fragsize, hw->info.bytes_per_frame);
521 }
522
523 hw->samples = (obt.nfrags * obt.fragsize) / hw->info.bytes_per_frame;
524
525 oss->mmapped = 0;
526 if (oopts->has_try_mmap && oopts->try_mmap) {
527 hw->size_emul = hw->samples * hw->info.bytes_per_frame;
528 hw->buf_emul = mmap(
529 NULL,
530 hw->size_emul,
531 PROT_READ | PROT_WRITE,
532 MAP_SHARED,
533 fd,
534 0
535 );
536 if (hw->buf_emul == MAP_FAILED) {
537 oss_logerr(errno, "Failed to map %zu bytes of DAC\n",
538 hw->size_emul);
539 hw->buf_emul = NULL;
540 } else {
541 int err;
542 int trig = 0;
543 if (ioctl (fd, SNDCTL_DSP_SETTRIGGER, &trig) < 0) {
544 oss_logerr (errno, "SNDCTL_DSP_SETTRIGGER 0 failed\n");
545 }
546 else {
547 trig = PCM_ENABLE_OUTPUT;
548 if (ioctl (fd, SNDCTL_DSP_SETTRIGGER, &trig) < 0) {
549 oss_logerr (
550 errno,
551 "SNDCTL_DSP_SETTRIGGER PCM_ENABLE_OUTPUT failed\n"
552 );
553 }
554 else {
555 oss->mmapped = 1;
556 }
557 }
558
559 if (!oss->mmapped) {
560 err = munmap(hw->buf_emul, hw->size_emul);
561 if (err) {
562 oss_logerr(errno, "Failed to unmap buffer %p size %zu\n",
563 hw->buf_emul, hw->size_emul);
564 }
565 hw->buf_emul = NULL;
566 }
567 }
568 }
569
570 oss->fd = fd;
571 oss->dev = dev;
572 return 0;
573 }
574
575 static void oss_enable_out(HWVoiceOut *hw, bool enable)
576 {
577 int trig;
578 OSSVoiceOut *oss = (OSSVoiceOut *) hw;
579 AudiodevOssPerDirectionOptions *opdo = oss->dev->u.oss.out;
580
581 if (enable) {
582 hw->poll_mode = opdo->try_poll;
583
584 ldebug("enabling voice\n");
585 if (hw->poll_mode) {
586 oss_poll_out(hw);
587 }
588
589 if (!oss->mmapped) {
590 return;
591 }
592
593 audio_pcm_info_clear_buf(&hw->info, hw->buf_emul, hw->samples);
594 trig = PCM_ENABLE_OUTPUT;
595 if (ioctl(oss->fd, SNDCTL_DSP_SETTRIGGER, &trig) < 0) {
596 oss_logerr(errno,
597 "SNDCTL_DSP_SETTRIGGER PCM_ENABLE_OUTPUT failed\n");
598 return;
599 }
600 } else {
601 if (hw->poll_mode) {
602 qemu_set_fd_handler (oss->fd, NULL, NULL, NULL);
603 hw->poll_mode = 0;
604 }
605
606 if (!oss->mmapped) {
607 return;
608 }
609
610 ldebug ("disabling voice\n");
611 trig = 0;
612 if (ioctl (oss->fd, SNDCTL_DSP_SETTRIGGER, &trig) < 0) {
613 oss_logerr (errno, "SNDCTL_DSP_SETTRIGGER 0 failed\n");
614 return;
615 }
616 }
617 }
618
619 static int oss_init_in(HWVoiceIn *hw, struct audsettings *as, void *drv_opaque)
620 {
621 OSSVoiceIn *oss = (OSSVoiceIn *) hw;
622 struct oss_params req, obt;
623 int endianness;
624 int err;
625 int fd;
626 AudioFormat effective_fmt;
627 struct audsettings obt_as;
628 Audiodev *dev = drv_opaque;
629
630 oss->fd = -1;
631
632 req.fmt = aud_to_ossfmt (as->fmt, as->endianness);
633 req.freq = as->freq;
634 req.nchannels = as->nchannels;
635 if (oss_open(1, &req, as, &obt, &fd, dev)) {
636 return -1;
637 }
638
639 err = oss_to_audfmt (obt.fmt, &effective_fmt, &endianness);
640 if (err) {
641 oss_anal_close (&fd);
642 return -1;
643 }
644
645 obt_as.freq = obt.freq;
646 obt_as.nchannels = obt.nchannels;
647 obt_as.fmt = effective_fmt;
648 obt_as.endianness = endianness;
649
650 audio_pcm_init_info (&hw->info, &obt_as);
651 oss->nfrags = obt.nfrags;
652 oss->fragsize = obt.fragsize;
653
654 if (obt.nfrags * obt.fragsize % hw->info.bytes_per_frame) {
655 dolog ("warning: Misaligned ADC buffer, size %d, alignment %d\n",
656 obt.nfrags * obt.fragsize, hw->info.bytes_per_frame);
657 }
658
659 hw->samples = (obt.nfrags * obt.fragsize) / hw->info.bytes_per_frame;
660
661 oss->fd = fd;
662 oss->dev = dev;
663 return 0;
664 }
665
666 static void oss_fini_in (HWVoiceIn *hw)
667 {
668 OSSVoiceIn *oss = (OSSVoiceIn *) hw;
669
670 oss_anal_close (&oss->fd);
671 }
672
673 static size_t oss_read(HWVoiceIn *hw, void *buf, size_t len)
674 {
675 OSSVoiceIn *oss = (OSSVoiceIn *) hw;
676 size_t pos = 0;
677
678 while (len) {
679 ssize_t nread;
680
681 void *dst = advance(buf, pos);
682 nread = read(oss->fd, dst, len);
683
684 if (nread == -1) {
685 switch (errno) {
686 case EINTR:
687 case EAGAIN:
688 break;
689 default:
690 oss_logerr(errno, "Failed to read %zu bytes of audio (to %p)\n",
691 len, dst);
692 break;
693 }
694 break;
695 }
696
697 pos += nread;
698 len -= nread;
699 }
700
701 return pos;
702 }
703
704 static void oss_enable_in(HWVoiceIn *hw, bool enable)
705 {
706 OSSVoiceIn *oss = (OSSVoiceIn *) hw;
707 AudiodevOssPerDirectionOptions *opdo = oss->dev->u.oss.out;
708
709 if (enable) {
710 hw->poll_mode = opdo->try_poll;
711
712 if (hw->poll_mode) {
713 oss_poll_in(hw);
714 }
715 } else {
716 if (hw->poll_mode) {
717 qemu_set_fd_handler (oss->fd, NULL, NULL, NULL);
718 hw->poll_mode = 0;
719 }
720 }
721 }
722
723 static void oss_init_per_direction(AudiodevOssPerDirectionOptions *opdo)
724 {
725 if (!opdo->has_try_poll) {
726 opdo->try_poll = true;
727 opdo->has_try_poll = true;
728 }
729 }
730
731 static void *oss_audio_init(Audiodev *dev)
732 {
733 AudiodevOssOptions *oopts;
734 assert(dev->driver == AUDIODEV_DRIVER_OSS);
735
736 oopts = &dev->u.oss;
737 oss_init_per_direction(oopts->in);
738 oss_init_per_direction(oopts->out);
739
740 if (access(oopts->in->has_dev ? oopts->in->dev : "/dev/dsp",
741 R_OK | W_OK) < 0 ||
742 access(oopts->out->has_dev ? oopts->out->dev : "/dev/dsp",
743 R_OK | W_OK) < 0) {
744 return NULL;
745 }
746 return dev;
747 }
748
749 static void oss_audio_fini (void *opaque)
750 {
751 }
752
753 static struct audio_pcm_ops oss_pcm_ops = {
754 .init_out = oss_init_out,
755 .fini_out = oss_fini_out,
756 .write = oss_write,
757 .run_buffer_out = oss_run_buffer_out,
758 .get_buffer_out = oss_get_buffer_out,
759 .put_buffer_out = oss_put_buffer_out,
760 .enable_out = oss_enable_out,
761
762 .init_in = oss_init_in,
763 .fini_in = oss_fini_in,
764 .read = oss_read,
765 .enable_in = oss_enable_in
766 };
767
768 static struct audio_driver oss_audio_driver = {
769 .name = "oss",
770 .descr = "OSS http://www.opensound.com",
771 .init = oss_audio_init,
772 .fini = oss_audio_fini,
773 .pcm_ops = &oss_pcm_ops,
774 .can_be_default = 1,
775 .max_voices_out = INT_MAX,
776 .max_voices_in = INT_MAX,
777 .voice_size_out = sizeof (OSSVoiceOut),
778 .voice_size_in = sizeof (OSSVoiceIn)
779 };
780
781 static void register_audio_oss(void)
782 {
783 audio_driver_register(&oss_audio_driver);
784 }
785 type_init(register_audio_oss);