GRLIB UART: Add RX channel
[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 #include <stdlib.h>
25 #include <sys/mman.h>
26 #include <sys/types.h>
27 #include <sys/ioctl.h>
28 #ifdef __OpenBSD__
29 #include <soundcard.h>
30 #else
31 #include <sys/soundcard.h>
32 #endif
33 #include "qemu-common.h"
34 #include "host-utils.h"
35 #include "qemu-char.h"
36 #include "audio.h"
37
38 #define AUDIO_CAP "oss"
39 #include "audio_int.h"
40
41 #if defined OSS_GETVERSION && defined SNDCTL_DSP_POLICY
42 #define USE_DSP_POLICY
43 #endif
44
45 typedef struct OSSVoiceOut {
46 HWVoiceOut hw;
47 void *pcm_buf;
48 int fd;
49 int wpos;
50 int nfrags;
51 int fragsize;
52 int mmapped;
53 int pending;
54 } OSSVoiceOut;
55
56 typedef struct OSSVoiceIn {
57 HWVoiceIn hw;
58 void *pcm_buf;
59 int fd;
60 int nfrags;
61 int fragsize;
62 } OSSVoiceIn;
63
64 static struct {
65 int try_mmap;
66 int nfrags;
67 int fragsize;
68 const char *devpath_out;
69 const char *devpath_in;
70 int debug;
71 int exclusive;
72 int policy;
73 } conf = {
74 .try_mmap = 0,
75 .nfrags = 4,
76 .fragsize = 4096,
77 .devpath_out = "/dev/dsp",
78 .devpath_in = "/dev/dsp",
79 .debug = 0,
80 .exclusive = 0,
81 .policy = 5
82 };
83
84 struct oss_params {
85 int freq;
86 audfmt_e fmt;
87 int nchannels;
88 int nfrags;
89 int fragsize;
90 };
91
92 static void GCC_FMT_ATTR (2, 3) oss_logerr (int err, const char *fmt, ...)
93 {
94 va_list ap;
95
96 va_start (ap, fmt);
97 AUD_vlog (AUDIO_CAP, fmt, ap);
98 va_end (ap);
99
100 AUD_log (AUDIO_CAP, "Reason: %s\n", strerror (err));
101 }
102
103 static void GCC_FMT_ATTR (3, 4) oss_logerr2 (
104 int err,
105 const char *typ,
106 const char *fmt,
107 ...
108 )
109 {
110 va_list ap;
111
112 AUD_log (AUDIO_CAP, "Could not initialize %s\n", typ);
113
114 va_start (ap, fmt);
115 AUD_vlog (AUDIO_CAP, fmt, ap);
116 va_end (ap);
117
118 AUD_log (AUDIO_CAP, "Reason: %s\n", strerror (err));
119 }
120
121 static void oss_anal_close (int *fdp)
122 {
123 int err;
124
125 qemu_set_fd_handler (*fdp, NULL, NULL, NULL);
126 err = close (*fdp);
127 if (err) {
128 oss_logerr (errno, "Failed to close file(fd=%d)\n", *fdp);
129 }
130 *fdp = -1;
131 }
132
133 static void oss_helper_poll_out (void *opaque)
134 {
135 (void) opaque;
136 audio_run ("oss_poll_out");
137 }
138
139 static void oss_helper_poll_in (void *opaque)
140 {
141 (void) opaque;
142 audio_run ("oss_poll_in");
143 }
144
145 static int oss_poll_out (HWVoiceOut *hw)
146 {
147 OSSVoiceOut *oss = (OSSVoiceOut *) hw;
148
149 return qemu_set_fd_handler (oss->fd, NULL, oss_helper_poll_out, NULL);
150 }
151
152 static int oss_poll_in (HWVoiceIn *hw)
153 {
154 OSSVoiceIn *oss = (OSSVoiceIn *) hw;
155
156 return qemu_set_fd_handler (oss->fd, oss_helper_poll_in, NULL, NULL);
157 }
158
159 static int oss_write (SWVoiceOut *sw, void *buf, int len)
160 {
161 return audio_pcm_sw_write (sw, buf, len);
162 }
163
164 static int aud_to_ossfmt (audfmt_e fmt, int endianness)
165 {
166 switch (fmt) {
167 case AUD_FMT_S8:
168 return AFMT_S8;
169
170 case AUD_FMT_U8:
171 return AFMT_U8;
172
173 case AUD_FMT_S16:
174 if (endianness) {
175 return AFMT_S16_BE;
176 }
177 else {
178 return AFMT_S16_LE;
179 }
180
181 case AUD_FMT_U16:
182 if (endianness) {
183 return AFMT_U16_BE;
184 }
185 else {
186 return AFMT_U16_LE;
187 }
188
189 default:
190 dolog ("Internal logic error: Bad audio format %d\n", fmt);
191 #ifdef DEBUG_AUDIO
192 abort ();
193 #endif
194 return AFMT_U8;
195 }
196 }
197
198 static int oss_to_audfmt (int ossfmt, audfmt_e *fmt, int *endianness)
199 {
200 switch (ossfmt) {
201 case AFMT_S8:
202 *endianness = 0;
203 *fmt = AUD_FMT_S8;
204 break;
205
206 case AFMT_U8:
207 *endianness = 0;
208 *fmt = AUD_FMT_U8;
209 break;
210
211 case AFMT_S16_LE:
212 *endianness = 0;
213 *fmt = AUD_FMT_S16;
214 break;
215
216 case AFMT_U16_LE:
217 *endianness = 0;
218 *fmt = AUD_FMT_U16;
219 break;
220
221 case AFMT_S16_BE:
222 *endianness = 1;
223 *fmt = AUD_FMT_S16;
224 break;
225
226 case AFMT_U16_BE:
227 *endianness = 1;
228 *fmt = AUD_FMT_U16;
229 break;
230
231 default:
232 dolog ("Unrecognized audio format %d\n", ossfmt);
233 return -1;
234 }
235
236 return 0;
237 }
238
239 #if defined DEBUG_MISMATCHES || defined DEBUG
240 static void oss_dump_info (struct oss_params *req, struct oss_params *obt)
241 {
242 dolog ("parameter | requested value | obtained value\n");
243 dolog ("format | %10d | %10d\n", req->fmt, obt->fmt);
244 dolog ("channels | %10d | %10d\n",
245 req->nchannels, obt->nchannels);
246 dolog ("frequency | %10d | %10d\n", req->freq, obt->freq);
247 dolog ("nfrags | %10d | %10d\n", req->nfrags, obt->nfrags);
248 dolog ("fragsize | %10d | %10d\n",
249 req->fragsize, obt->fragsize);
250 }
251 #endif
252
253 #ifdef USE_DSP_POLICY
254 static int oss_get_version (int fd, int *version, const char *typ)
255 {
256 if (ioctl (fd, OSS_GETVERSION, &version)) {
257 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
258 /*
259 * Looks like atm (20100109) FreeBSD knows OSS_GETVERSION
260 * since 7.x, but currently only on the mixer device (or in
261 * the Linuxolator), and in the native version that part of
262 * the code is in fact never reached so the ioctl fails anyway.
263 * Until this is fixed, just check the errno and if its what
264 * FreeBSD's sound drivers return atm assume they are new enough.
265 */
266 if (errno == EINVAL) {
267 *version = 0x040000;
268 return 0;
269 }
270 #endif
271 oss_logerr2 (errno, typ, "Failed to get OSS version\n");
272 return -1;
273 }
274 return 0;
275 }
276 #endif
277
278 static int oss_open (int in, struct oss_params *req,
279 struct oss_params *obt, int *pfd)
280 {
281 int fd;
282 int oflags = conf.exclusive ? O_EXCL : 0;
283 audio_buf_info abinfo;
284 int fmt, freq, nchannels;
285 int setfragment = 1;
286 const char *dspname = in ? conf.devpath_in : conf.devpath_out;
287 const char *typ = in ? "ADC" : "DAC";
288
289 /* Kludge needed to have working mmap on Linux */
290 oflags |= conf.try_mmap ? O_RDWR : (in ? O_RDONLY : O_WRONLY);
291
292 fd = open (dspname, oflags | O_NONBLOCK);
293 if (-1 == fd) {
294 oss_logerr2 (errno, typ, "Failed to open `%s'\n", dspname);
295 return -1;
296 }
297
298 freq = req->freq;
299 nchannels = req->nchannels;
300 fmt = req->fmt;
301
302 if (ioctl (fd, SNDCTL_DSP_SAMPLESIZE, &fmt)) {
303 oss_logerr2 (errno, typ, "Failed to set sample size %d\n", req->fmt);
304 goto err;
305 }
306
307 if (ioctl (fd, SNDCTL_DSP_CHANNELS, &nchannels)) {
308 oss_logerr2 (errno, typ, "Failed to set number of channels %d\n",
309 req->nchannels);
310 goto err;
311 }
312
313 if (ioctl (fd, SNDCTL_DSP_SPEED, &freq)) {
314 oss_logerr2 (errno, typ, "Failed to set frequency %d\n", req->freq);
315 goto err;
316 }
317
318 if (ioctl (fd, SNDCTL_DSP_NONBLOCK, NULL)) {
319 oss_logerr2 (errno, typ, "Failed to set non-blocking mode\n");
320 goto err;
321 }
322
323 #ifdef USE_DSP_POLICY
324 if (conf.policy >= 0) {
325 int version;
326
327 if (!oss_get_version (fd, &version, typ)) {
328 if (conf.debug) {
329 dolog ("OSS version = %#x\n", version);
330 }
331
332 if (version >= 0x040000) {
333 int policy = conf.policy;
334 if (ioctl (fd, SNDCTL_DSP_POLICY, &policy)) {
335 oss_logerr2 (errno, typ,
336 "Failed to set timing policy to %d\n",
337 conf.policy);
338 goto err;
339 }
340 setfragment = 0;
341 }
342 }
343 }
344 #endif
345
346 if (setfragment) {
347 int mmmmssss = (req->nfrags << 16) | ctz32 (req->fragsize);
348 if (ioctl (fd, SNDCTL_DSP_SETFRAGMENT, &mmmmssss)) {
349 oss_logerr2 (errno, typ, "Failed to set buffer length (%d, %d)\n",
350 req->nfrags, req->fragsize);
351 goto err;
352 }
353 }
354
355 if (ioctl (fd, in ? SNDCTL_DSP_GETISPACE : SNDCTL_DSP_GETOSPACE, &abinfo)) {
356 oss_logerr2 (errno, typ, "Failed to get buffer length\n");
357 goto err;
358 }
359
360 if (!abinfo.fragstotal || !abinfo.fragsize) {
361 AUD_log (AUDIO_CAP, "Returned bogus buffer information(%d, %d) for %s\n",
362 abinfo.fragstotal, abinfo.fragsize, typ);
363 goto err;
364 }
365
366 obt->fmt = fmt;
367 obt->nchannels = nchannels;
368 obt->freq = freq;
369 obt->nfrags = abinfo.fragstotal;
370 obt->fragsize = abinfo.fragsize;
371 *pfd = fd;
372
373 #ifdef DEBUG_MISMATCHES
374 if ((req->fmt != obt->fmt) ||
375 (req->nchannels != obt->nchannels) ||
376 (req->freq != obt->freq) ||
377 (req->fragsize != obt->fragsize) ||
378 (req->nfrags != obt->nfrags)) {
379 dolog ("Audio parameters mismatch\n");
380 oss_dump_info (req, obt);
381 }
382 #endif
383
384 #ifdef DEBUG
385 oss_dump_info (req, obt);
386 #endif
387 return 0;
388
389 err:
390 oss_anal_close (&fd);
391 return -1;
392 }
393
394 static void oss_write_pending (OSSVoiceOut *oss)
395 {
396 HWVoiceOut *hw = &oss->hw;
397
398 if (oss->mmapped) {
399 return;
400 }
401
402 while (oss->pending) {
403 int samples_written;
404 ssize_t bytes_written;
405 int samples_till_end = hw->samples - oss->wpos;
406 int samples_to_write = audio_MIN (oss->pending, samples_till_end);
407 int bytes_to_write = samples_to_write << hw->info.shift;
408 void *pcm = advance (oss->pcm_buf, oss->wpos << hw->info.shift);
409
410 bytes_written = write (oss->fd, pcm, bytes_to_write);
411 if (bytes_written < 0) {
412 if (errno != EAGAIN) {
413 oss_logerr (errno, "failed to write %d bytes\n",
414 bytes_to_write);
415 }
416 break;
417 }
418
419 if (bytes_written & hw->info.align) {
420 dolog ("misaligned write asked for %d, but got %zd\n",
421 bytes_to_write, bytes_written);
422 return;
423 }
424
425 samples_written = bytes_written >> hw->info.shift;
426 oss->pending -= samples_written;
427 oss->wpos = (oss->wpos + samples_written) % hw->samples;
428 if (bytes_written - bytes_to_write) {
429 break;
430 }
431 }
432 }
433
434 static int oss_run_out (HWVoiceOut *hw, int live)
435 {
436 OSSVoiceOut *oss = (OSSVoiceOut *) hw;
437 int err, decr;
438 struct audio_buf_info abinfo;
439 struct count_info cntinfo;
440 int bufsize;
441
442 bufsize = hw->samples << hw->info.shift;
443
444 if (oss->mmapped) {
445 int bytes, pos;
446
447 err = ioctl (oss->fd, SNDCTL_DSP_GETOPTR, &cntinfo);
448 if (err < 0) {
449 oss_logerr (errno, "SNDCTL_DSP_GETOPTR failed\n");
450 return 0;
451 }
452
453 pos = hw->rpos << hw->info.shift;
454 bytes = audio_ring_dist (cntinfo.ptr, pos, bufsize);
455 decr = audio_MIN (bytes >> hw->info.shift, live);
456 }
457 else {
458 err = ioctl (oss->fd, SNDCTL_DSP_GETOSPACE, &abinfo);
459 if (err < 0) {
460 oss_logerr (errno, "SNDCTL_DSP_GETOPTR failed\n");
461 return 0;
462 }
463
464 if (abinfo.bytes > bufsize) {
465 if (conf.debug) {
466 dolog ("warning: Invalid available size, size=%d bufsize=%d\n"
467 "please report your OS/audio hw to av1474@comtv.ru\n",
468 abinfo.bytes, bufsize);
469 }
470 abinfo.bytes = bufsize;
471 }
472
473 if (abinfo.bytes < 0) {
474 if (conf.debug) {
475 dolog ("warning: Invalid available size, size=%d bufsize=%d\n",
476 abinfo.bytes, bufsize);
477 }
478 return 0;
479 }
480
481 decr = audio_MIN (abinfo.bytes >> hw->info.shift, live);
482 if (!decr) {
483 return 0;
484 }
485 }
486
487 decr = audio_pcm_hw_clip_out (hw, oss->pcm_buf, decr, oss->pending);
488 oss->pending += decr;
489 oss_write_pending (oss);
490
491 return decr;
492 }
493
494 static void oss_fini_out (HWVoiceOut *hw)
495 {
496 int err;
497 OSSVoiceOut *oss = (OSSVoiceOut *) hw;
498
499 ldebug ("oss_fini\n");
500 oss_anal_close (&oss->fd);
501
502 if (oss->pcm_buf) {
503 if (oss->mmapped) {
504 err = munmap (oss->pcm_buf, hw->samples << hw->info.shift);
505 if (err) {
506 oss_logerr (errno, "Failed to unmap buffer %p, size %d\n",
507 oss->pcm_buf, hw->samples << hw->info.shift);
508 }
509 }
510 else {
511 g_free (oss->pcm_buf);
512 }
513 oss->pcm_buf = NULL;
514 }
515 }
516
517 static int oss_init_out (HWVoiceOut *hw, struct audsettings *as)
518 {
519 OSSVoiceOut *oss = (OSSVoiceOut *) hw;
520 struct oss_params req, obt;
521 int endianness;
522 int err;
523 int fd;
524 audfmt_e effective_fmt;
525 struct audsettings obt_as;
526
527 oss->fd = -1;
528
529 req.fmt = aud_to_ossfmt (as->fmt, as->endianness);
530 req.freq = as->freq;
531 req.nchannels = as->nchannels;
532 req.fragsize = conf.fragsize;
533 req.nfrags = conf.nfrags;
534
535 if (oss_open (0, &req, &obt, &fd)) {
536 return -1;
537 }
538
539 err = oss_to_audfmt (obt.fmt, &effective_fmt, &endianness);
540 if (err) {
541 oss_anal_close (&fd);
542 return -1;
543 }
544
545 obt_as.freq = obt.freq;
546 obt_as.nchannels = obt.nchannels;
547 obt_as.fmt = effective_fmt;
548 obt_as.endianness = endianness;
549
550 audio_pcm_init_info (&hw->info, &obt_as);
551 oss->nfrags = obt.nfrags;
552 oss->fragsize = obt.fragsize;
553
554 if (obt.nfrags * obt.fragsize & hw->info.align) {
555 dolog ("warning: Misaligned DAC buffer, size %d, alignment %d\n",
556 obt.nfrags * obt.fragsize, hw->info.align + 1);
557 }
558
559 hw->samples = (obt.nfrags * obt.fragsize) >> hw->info.shift;
560
561 oss->mmapped = 0;
562 if (conf.try_mmap) {
563 oss->pcm_buf = mmap (
564 NULL,
565 hw->samples << hw->info.shift,
566 PROT_READ | PROT_WRITE,
567 MAP_SHARED,
568 fd,
569 0
570 );
571 if (oss->pcm_buf == MAP_FAILED) {
572 oss_logerr (errno, "Failed to map %d bytes of DAC\n",
573 hw->samples << hw->info.shift);
574 }
575 else {
576 int err;
577 int trig = 0;
578 if (ioctl (fd, SNDCTL_DSP_SETTRIGGER, &trig) < 0) {
579 oss_logerr (errno, "SNDCTL_DSP_SETTRIGGER 0 failed\n");
580 }
581 else {
582 trig = PCM_ENABLE_OUTPUT;
583 if (ioctl (fd, SNDCTL_DSP_SETTRIGGER, &trig) < 0) {
584 oss_logerr (
585 errno,
586 "SNDCTL_DSP_SETTRIGGER PCM_ENABLE_OUTPUT failed\n"
587 );
588 }
589 else {
590 oss->mmapped = 1;
591 }
592 }
593
594 if (!oss->mmapped) {
595 err = munmap (oss->pcm_buf, hw->samples << hw->info.shift);
596 if (err) {
597 oss_logerr (errno, "Failed to unmap buffer %p size %d\n",
598 oss->pcm_buf, hw->samples << hw->info.shift);
599 }
600 }
601 }
602 }
603
604 if (!oss->mmapped) {
605 oss->pcm_buf = audio_calloc (
606 AUDIO_FUNC,
607 hw->samples,
608 1 << hw->info.shift
609 );
610 if (!oss->pcm_buf) {
611 dolog (
612 "Could not allocate DAC buffer (%d samples, each %d bytes)\n",
613 hw->samples,
614 1 << hw->info.shift
615 );
616 oss_anal_close (&fd);
617 return -1;
618 }
619 }
620
621 oss->fd = fd;
622 return 0;
623 }
624
625 static int oss_ctl_out (HWVoiceOut *hw, int cmd, ...)
626 {
627 int trig;
628 OSSVoiceOut *oss = (OSSVoiceOut *) hw;
629
630 switch (cmd) {
631 case VOICE_ENABLE:
632 {
633 va_list ap;
634 int poll_mode;
635
636 va_start (ap, cmd);
637 poll_mode = va_arg (ap, int);
638 va_end (ap);
639
640 ldebug ("enabling voice\n");
641 if (poll_mode && oss_poll_out (hw)) {
642 poll_mode = 0;
643 }
644 hw->poll_mode = poll_mode;
645
646 if (!oss->mmapped) {
647 return 0;
648 }
649
650 audio_pcm_info_clear_buf (&hw->info, oss->pcm_buf, hw->samples);
651 trig = PCM_ENABLE_OUTPUT;
652 if (ioctl (oss->fd, SNDCTL_DSP_SETTRIGGER, &trig) < 0) {
653 oss_logerr (
654 errno,
655 "SNDCTL_DSP_SETTRIGGER PCM_ENABLE_OUTPUT failed\n"
656 );
657 return -1;
658 }
659 }
660 break;
661
662 case VOICE_DISABLE:
663 if (hw->poll_mode) {
664 qemu_set_fd_handler (oss->fd, NULL, NULL, NULL);
665 hw->poll_mode = 0;
666 }
667
668 if (!oss->mmapped) {
669 return 0;
670 }
671
672 ldebug ("disabling voice\n");
673 trig = 0;
674 if (ioctl (oss->fd, SNDCTL_DSP_SETTRIGGER, &trig) < 0) {
675 oss_logerr (errno, "SNDCTL_DSP_SETTRIGGER 0 failed\n");
676 return -1;
677 }
678 break;
679 }
680 return 0;
681 }
682
683 static int oss_init_in (HWVoiceIn *hw, struct audsettings *as)
684 {
685 OSSVoiceIn *oss = (OSSVoiceIn *) hw;
686 struct oss_params req, obt;
687 int endianness;
688 int err;
689 int fd;
690 audfmt_e effective_fmt;
691 struct audsettings obt_as;
692
693 oss->fd = -1;
694
695 req.fmt = aud_to_ossfmt (as->fmt, as->endianness);
696 req.freq = as->freq;
697 req.nchannels = as->nchannels;
698 req.fragsize = conf.fragsize;
699 req.nfrags = conf.nfrags;
700 if (oss_open (1, &req, &obt, &fd)) {
701 return -1;
702 }
703
704 err = oss_to_audfmt (obt.fmt, &effective_fmt, &endianness);
705 if (err) {
706 oss_anal_close (&fd);
707 return -1;
708 }
709
710 obt_as.freq = obt.freq;
711 obt_as.nchannels = obt.nchannels;
712 obt_as.fmt = effective_fmt;
713 obt_as.endianness = endianness;
714
715 audio_pcm_init_info (&hw->info, &obt_as);
716 oss->nfrags = obt.nfrags;
717 oss->fragsize = obt.fragsize;
718
719 if (obt.nfrags * obt.fragsize & hw->info.align) {
720 dolog ("warning: Misaligned ADC buffer, size %d, alignment %d\n",
721 obt.nfrags * obt.fragsize, hw->info.align + 1);
722 }
723
724 hw->samples = (obt.nfrags * obt.fragsize) >> hw->info.shift;
725 oss->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);
726 if (!oss->pcm_buf) {
727 dolog ("Could not allocate ADC buffer (%d samples, each %d bytes)\n",
728 hw->samples, 1 << hw->info.shift);
729 oss_anal_close (&fd);
730 return -1;
731 }
732
733 oss->fd = fd;
734 return 0;
735 }
736
737 static void oss_fini_in (HWVoiceIn *hw)
738 {
739 OSSVoiceIn *oss = (OSSVoiceIn *) hw;
740
741 oss_anal_close (&oss->fd);
742
743 if (oss->pcm_buf) {
744 g_free (oss->pcm_buf);
745 oss->pcm_buf = NULL;
746 }
747 }
748
749 static int oss_run_in (HWVoiceIn *hw)
750 {
751 OSSVoiceIn *oss = (OSSVoiceIn *) hw;
752 int hwshift = hw->info.shift;
753 int i;
754 int live = audio_pcm_hw_get_live_in (hw);
755 int dead = hw->samples - live;
756 size_t read_samples = 0;
757 struct {
758 int add;
759 int len;
760 } bufs[2] = {
761 { .add = hw->wpos, .len = 0 },
762 { .add = 0, .len = 0 }
763 };
764
765 if (!dead) {
766 return 0;
767 }
768
769 if (hw->wpos + dead > hw->samples) {
770 bufs[0].len = (hw->samples - hw->wpos) << hwshift;
771 bufs[1].len = (dead - (hw->samples - hw->wpos)) << hwshift;
772 }
773 else {
774 bufs[0].len = dead << hwshift;
775 }
776
777 for (i = 0; i < 2; ++i) {
778 ssize_t nread;
779
780 if (bufs[i].len) {
781 void *p = advance (oss->pcm_buf, bufs[i].add << hwshift);
782 nread = read (oss->fd, p, bufs[i].len);
783
784 if (nread > 0) {
785 if (nread & hw->info.align) {
786 dolog ("warning: Misaligned read %zd (requested %d), "
787 "alignment %d\n", nread, bufs[i].add << hwshift,
788 hw->info.align + 1);
789 }
790 read_samples += nread >> hwshift;
791 hw->conv (hw->conv_buf + bufs[i].add, p, nread >> hwshift);
792 }
793
794 if (bufs[i].len - nread) {
795 if (nread == -1) {
796 switch (errno) {
797 case EINTR:
798 case EAGAIN:
799 break;
800 default:
801 oss_logerr (
802 errno,
803 "Failed to read %d bytes of audio (to %p)\n",
804 bufs[i].len, p
805 );
806 break;
807 }
808 }
809 break;
810 }
811 }
812 }
813
814 hw->wpos = (hw->wpos + read_samples) % hw->samples;
815 return read_samples;
816 }
817
818 static int oss_read (SWVoiceIn *sw, void *buf, int size)
819 {
820 return audio_pcm_sw_read (sw, buf, size);
821 }
822
823 static int oss_ctl_in (HWVoiceIn *hw, int cmd, ...)
824 {
825 OSSVoiceIn *oss = (OSSVoiceIn *) hw;
826
827 switch (cmd) {
828 case VOICE_ENABLE:
829 {
830 va_list ap;
831 int poll_mode;
832
833 va_start (ap, cmd);
834 poll_mode = va_arg (ap, int);
835 va_end (ap);
836
837 if (poll_mode && oss_poll_in (hw)) {
838 poll_mode = 0;
839 }
840 hw->poll_mode = poll_mode;
841 }
842 break;
843
844 case VOICE_DISABLE:
845 if (hw->poll_mode) {
846 hw->poll_mode = 0;
847 qemu_set_fd_handler (oss->fd, NULL, NULL, NULL);
848 }
849 break;
850 }
851 return 0;
852 }
853
854 static void *oss_audio_init (void)
855 {
856 return &conf;
857 }
858
859 static void oss_audio_fini (void *opaque)
860 {
861 (void) opaque;
862 }
863
864 static struct audio_option oss_options[] = {
865 {
866 .name = "FRAGSIZE",
867 .tag = AUD_OPT_INT,
868 .valp = &conf.fragsize,
869 .descr = "Fragment size in bytes"
870 },
871 {
872 .name = "NFRAGS",
873 .tag = AUD_OPT_INT,
874 .valp = &conf.nfrags,
875 .descr = "Number of fragments"
876 },
877 {
878 .name = "MMAP",
879 .tag = AUD_OPT_BOOL,
880 .valp = &conf.try_mmap,
881 .descr = "Try using memory mapped access"
882 },
883 {
884 .name = "DAC_DEV",
885 .tag = AUD_OPT_STR,
886 .valp = &conf.devpath_out,
887 .descr = "Path to DAC device"
888 },
889 {
890 .name = "ADC_DEV",
891 .tag = AUD_OPT_STR,
892 .valp = &conf.devpath_in,
893 .descr = "Path to ADC device"
894 },
895 {
896 .name = "EXCLUSIVE",
897 .tag = AUD_OPT_BOOL,
898 .valp = &conf.exclusive,
899 .descr = "Open device in exclusive mode (vmix wont work)"
900 },
901 #ifdef USE_DSP_POLICY
902 {
903 .name = "POLICY",
904 .tag = AUD_OPT_INT,
905 .valp = &conf.policy,
906 .descr = "Set the timing policy of the device, -1 to use fragment mode",
907 },
908 #endif
909 {
910 .name = "DEBUG",
911 .tag = AUD_OPT_BOOL,
912 .valp = &conf.debug,
913 .descr = "Turn on some debugging messages"
914 },
915 { /* End of list */ }
916 };
917
918 static struct audio_pcm_ops oss_pcm_ops = {
919 .init_out = oss_init_out,
920 .fini_out = oss_fini_out,
921 .run_out = oss_run_out,
922 .write = oss_write,
923 .ctl_out = oss_ctl_out,
924
925 .init_in = oss_init_in,
926 .fini_in = oss_fini_in,
927 .run_in = oss_run_in,
928 .read = oss_read,
929 .ctl_in = oss_ctl_in
930 };
931
932 struct audio_driver oss_audio_driver = {
933 .name = "oss",
934 .descr = "OSS http://www.opensound.com",
935 .options = oss_options,
936 .init = oss_audio_init,
937 .fini = oss_audio_fini,
938 .pcm_ops = &oss_pcm_ops,
939 .can_be_default = 1,
940 .max_voices_out = INT_MAX,
941 .max_voices_in = INT_MAX,
942 .voice_size_out = sizeof (OSSVoiceOut),
943 .voice_size_in = sizeof (OSSVoiceIn)
944 };