]>
Commit | Line | Data |
---|---|---|
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 "audio.h" | |
35 | ||
36 | #define AUDIO_CAP "oss" | |
37 | #include "audio_int.h" | |
38 | ||
39 | typedef struct OSSVoiceOut { | |
40 | HWVoiceOut hw; | |
41 | void *pcm_buf; | |
42 | int fd; | |
43 | int nfrags; | |
44 | int fragsize; | |
45 | int mmapped; | |
46 | int old_optr; | |
47 | } OSSVoiceOut; | |
48 | ||
49 | typedef struct OSSVoiceIn { | |
50 | HWVoiceIn hw; | |
51 | void *pcm_buf; | |
52 | int fd; | |
53 | int nfrags; | |
54 | int fragsize; | |
55 | int old_optr; | |
56 | } OSSVoiceIn; | |
57 | ||
58 | static struct { | |
59 | int try_mmap; | |
60 | int nfrags; | |
61 | int fragsize; | |
62 | const char *devpath_out; | |
63 | const char *devpath_in; | |
64 | int debug; | |
65 | } conf = { | |
66 | .try_mmap = 0, | |
67 | .nfrags = 4, | |
68 | .fragsize = 4096, | |
69 | .devpath_out = "/dev/dsp", | |
70 | .devpath_in = "/dev/dsp", | |
71 | .debug = 0 | |
72 | }; | |
73 | ||
74 | struct oss_params { | |
75 | int freq; | |
76 | audfmt_e fmt; | |
77 | int nchannels; | |
78 | int nfrags; | |
79 | int fragsize; | |
80 | }; | |
81 | ||
82 | static void GCC_FMT_ATTR (2, 3) oss_logerr (int err, const char *fmt, ...) | |
83 | { | |
84 | va_list ap; | |
85 | ||
86 | va_start (ap, fmt); | |
87 | AUD_vlog (AUDIO_CAP, fmt, ap); | |
88 | va_end (ap); | |
89 | ||
90 | AUD_log (AUDIO_CAP, "Reason: %s\n", strerror (err)); | |
91 | } | |
92 | ||
93 | static void GCC_FMT_ATTR (3, 4) oss_logerr2 ( | |
94 | int err, | |
95 | const char *typ, | |
96 | const char *fmt, | |
97 | ... | |
98 | ) | |
99 | { | |
100 | va_list ap; | |
101 | ||
102 | AUD_log (AUDIO_CAP, "Could not initialize %s\n", typ); | |
103 | ||
104 | va_start (ap, fmt); | |
105 | AUD_vlog (AUDIO_CAP, fmt, ap); | |
106 | va_end (ap); | |
107 | ||
108 | AUD_log (AUDIO_CAP, "Reason: %s\n", strerror (err)); | |
109 | } | |
110 | ||
111 | static void oss_anal_close (int *fdp) | |
112 | { | |
113 | int err = close (*fdp); | |
114 | if (err) { | |
115 | oss_logerr (errno, "Failed to close file(fd=%d)\n", *fdp); | |
116 | } | |
117 | *fdp = -1; | |
118 | } | |
119 | ||
120 | static int oss_write (SWVoiceOut *sw, void *buf, int len) | |
121 | { | |
122 | return audio_pcm_sw_write (sw, buf, len); | |
123 | } | |
124 | ||
125 | static int aud_to_ossfmt (audfmt_e fmt) | |
126 | { | |
127 | switch (fmt) { | |
128 | case AUD_FMT_S8: | |
129 | return AFMT_S8; | |
130 | ||
131 | case AUD_FMT_U8: | |
132 | return AFMT_U8; | |
133 | ||
134 | case AUD_FMT_S16: | |
135 | return AFMT_S16_LE; | |
136 | ||
137 | case AUD_FMT_U16: | |
138 | return AFMT_U16_LE; | |
139 | ||
140 | default: | |
141 | dolog ("Internal logic error: Bad audio format %d\n", fmt); | |
142 | #ifdef DEBUG_AUDIO | |
143 | abort (); | |
144 | #endif | |
145 | return AFMT_U8; | |
146 | } | |
147 | } | |
148 | ||
149 | static int oss_to_audfmt (int ossfmt, audfmt_e *fmt, int *endianness) | |
150 | { | |
151 | switch (ossfmt) { | |
152 | case AFMT_S8: | |
153 | *endianness = 0; | |
154 | *fmt = AUD_FMT_S8; | |
155 | break; | |
156 | ||
157 | case AFMT_U8: | |
158 | *endianness = 0; | |
159 | *fmt = AUD_FMT_U8; | |
160 | break; | |
161 | ||
162 | case AFMT_S16_LE: | |
163 | *endianness = 0; | |
164 | *fmt = AUD_FMT_S16; | |
165 | break; | |
166 | ||
167 | case AFMT_U16_LE: | |
168 | *endianness = 0; | |
169 | *fmt = AUD_FMT_U16; | |
170 | break; | |
171 | ||
172 | case AFMT_S16_BE: | |
173 | *endianness = 1; | |
174 | *fmt = AUD_FMT_S16; | |
175 | break; | |
176 | ||
177 | case AFMT_U16_BE: | |
178 | *endianness = 1; | |
179 | *fmt = AUD_FMT_U16; | |
180 | break; | |
181 | ||
182 | default: | |
183 | dolog ("Unrecognized audio format %d\n", ossfmt); | |
184 | return -1; | |
185 | } | |
186 | ||
187 | return 0; | |
188 | } | |
189 | ||
190 | #if defined DEBUG_MISMATCHES || defined DEBUG | |
191 | static void oss_dump_info (struct oss_params *req, struct oss_params *obt) | |
192 | { | |
193 | dolog ("parameter | requested value | obtained value\n"); | |
194 | dolog ("format | %10d | %10d\n", req->fmt, obt->fmt); | |
195 | dolog ("channels | %10d | %10d\n", | |
196 | req->nchannels, obt->nchannels); | |
197 | dolog ("frequency | %10d | %10d\n", req->freq, obt->freq); | |
198 | dolog ("nfrags | %10d | %10d\n", req->nfrags, obt->nfrags); | |
199 | dolog ("fragsize | %10d | %10d\n", | |
200 | req->fragsize, obt->fragsize); | |
201 | } | |
202 | #endif | |
203 | ||
204 | static int oss_open (int in, struct oss_params *req, | |
205 | struct oss_params *obt, int *pfd) | |
206 | { | |
207 | int fd; | |
208 | int mmmmssss; | |
209 | audio_buf_info abinfo; | |
210 | int fmt, freq, nchannels; | |
211 | const char *dspname = in ? conf.devpath_in : conf.devpath_out; | |
212 | const char *typ = in ? "ADC" : "DAC"; | |
213 | ||
214 | fd = open (dspname, (in ? O_RDONLY : O_WRONLY) | O_NONBLOCK); | |
215 | if (-1 == fd) { | |
216 | oss_logerr2 (errno, typ, "Failed to open `%s'\n", dspname); | |
217 | return -1; | |
218 | } | |
219 | ||
220 | freq = req->freq; | |
221 | nchannels = req->nchannels; | |
222 | fmt = req->fmt; | |
223 | ||
224 | if (ioctl (fd, SNDCTL_DSP_SAMPLESIZE, &fmt)) { | |
225 | oss_logerr2 (errno, typ, "Failed to set sample size %d\n", req->fmt); | |
226 | goto err; | |
227 | } | |
228 | ||
229 | if (ioctl (fd, SNDCTL_DSP_CHANNELS, &nchannels)) { | |
230 | oss_logerr2 (errno, typ, "Failed to set number of channels %d\n", | |
231 | req->nchannels); | |
232 | goto err; | |
233 | } | |
234 | ||
235 | if (ioctl (fd, SNDCTL_DSP_SPEED, &freq)) { | |
236 | oss_logerr2 (errno, typ, "Failed to set frequency %d\n", req->freq); | |
237 | goto err; | |
238 | } | |
239 | ||
240 | if (ioctl (fd, SNDCTL_DSP_NONBLOCK, NULL)) { | |
241 | oss_logerr2 (errno, typ, "Failed to set non-blocking mode\n"); | |
242 | goto err; | |
243 | } | |
244 | ||
245 | mmmmssss = (req->nfrags << 16) | lsbindex (req->fragsize); | |
246 | if (ioctl (fd, SNDCTL_DSP_SETFRAGMENT, &mmmmssss)) { | |
247 | oss_logerr2 (errno, typ, "Failed to set buffer length (%d, %d)\n", | |
248 | req->nfrags, req->fragsize); | |
249 | goto err; | |
250 | } | |
251 | ||
252 | if (ioctl (fd, in ? SNDCTL_DSP_GETISPACE : SNDCTL_DSP_GETOSPACE, &abinfo)) { | |
253 | oss_logerr2 (errno, typ, "Failed to get buffer length\n"); | |
254 | goto err; | |
255 | } | |
256 | ||
257 | if (!abinfo.fragstotal || !abinfo.fragsize) { | |
258 | AUD_log (AUDIO_CAP, "Returned bogus buffer information(%d, %d) for %s\n", | |
259 | abinfo.fragstotal, abinfo.fragsize, typ); | |
260 | goto err; | |
261 | } | |
262 | ||
263 | obt->fmt = fmt; | |
264 | obt->nchannels = nchannels; | |
265 | obt->freq = freq; | |
266 | obt->nfrags = abinfo.fragstotal; | |
267 | obt->fragsize = abinfo.fragsize; | |
268 | *pfd = fd; | |
269 | ||
270 | #ifdef DEBUG_MISMATCHES | |
271 | if ((req->fmt != obt->fmt) || | |
272 | (req->nchannels != obt->nchannels) || | |
273 | (req->freq != obt->freq) || | |
274 | (req->fragsize != obt->fragsize) || | |
275 | (req->nfrags != obt->nfrags)) { | |
276 | dolog ("Audio parameters mismatch\n"); | |
277 | oss_dump_info (req, obt); | |
278 | } | |
279 | #endif | |
280 | ||
281 | #ifdef DEBUG | |
282 | oss_dump_info (req, obt); | |
283 | #endif | |
284 | return 0; | |
285 | ||
286 | err: | |
287 | oss_anal_close (&fd); | |
288 | return -1; | |
289 | } | |
290 | ||
291 | static int oss_run_out (HWVoiceOut *hw) | |
292 | { | |
293 | OSSVoiceOut *oss = (OSSVoiceOut *) hw; | |
294 | int err, rpos, live, decr; | |
295 | int samples; | |
296 | uint8_t *dst; | |
297 | struct st_sample *src; | |
298 | struct audio_buf_info abinfo; | |
299 | struct count_info cntinfo; | |
300 | int bufsize; | |
301 | ||
302 | live = audio_pcm_hw_get_live_out (hw); | |
303 | if (!live) { | |
304 | return 0; | |
305 | } | |
306 | ||
307 | bufsize = hw->samples << hw->info.shift; | |
308 | ||
309 | if (oss->mmapped) { | |
310 | int bytes; | |
311 | ||
312 | err = ioctl (oss->fd, SNDCTL_DSP_GETOPTR, &cntinfo); | |
313 | if (err < 0) { | |
314 | oss_logerr (errno, "SNDCTL_DSP_GETOPTR failed\n"); | |
315 | return 0; | |
316 | } | |
317 | ||
318 | if (cntinfo.ptr == oss->old_optr) { | |
319 | if (abs (hw->samples - live) < 64) { | |
320 | dolog ("warning: Overrun\n"); | |
321 | } | |
322 | return 0; | |
323 | } | |
324 | ||
325 | if (cntinfo.ptr > oss->old_optr) { | |
326 | bytes = cntinfo.ptr - oss->old_optr; | |
327 | } | |
328 | else { | |
329 | bytes = bufsize + cntinfo.ptr - oss->old_optr; | |
330 | } | |
331 | ||
332 | decr = audio_MIN (bytes >> hw->info.shift, live); | |
333 | } | |
334 | else { | |
335 | err = ioctl (oss->fd, SNDCTL_DSP_GETOSPACE, &abinfo); | |
336 | if (err < 0) { | |
337 | oss_logerr (errno, "SNDCTL_DSP_GETOPTR failed\n"); | |
338 | return 0; | |
339 | } | |
340 | ||
341 | if (abinfo.bytes > bufsize) { | |
342 | if (conf.debug) { | |
343 | dolog ("warning: Invalid available size, size=%d bufsize=%d\n" | |
344 | "please report your OS/audio hw to malc@pulsesoft.com\n", | |
345 | abinfo.bytes, bufsize); | |
346 | } | |
347 | abinfo.bytes = bufsize; | |
348 | } | |
349 | ||
350 | if (abinfo.bytes < 0) { | |
351 | if (conf.debug) { | |
352 | dolog ("warning: Invalid available size, size=%d bufsize=%d\n", | |
353 | abinfo.bytes, bufsize); | |
354 | } | |
355 | return 0; | |
356 | } | |
357 | ||
358 | decr = audio_MIN (abinfo.bytes >> hw->info.shift, live); | |
359 | if (!decr) { | |
360 | return 0; | |
361 | } | |
362 | } | |
363 | ||
364 | samples = decr; | |
365 | rpos = hw->rpos; | |
366 | while (samples) { | |
367 | int left_till_end_samples = hw->samples - rpos; | |
368 | int convert_samples = audio_MIN (samples, left_till_end_samples); | |
369 | ||
370 | src = hw->mix_buf + rpos; | |
371 | dst = advance (oss->pcm_buf, rpos << hw->info.shift); | |
372 | ||
373 | hw->clip (dst, src, convert_samples); | |
374 | if (!oss->mmapped) { | |
375 | int written; | |
376 | ||
377 | written = write (oss->fd, dst, convert_samples << hw->info.shift); | |
378 | /* XXX: follow errno recommendations ? */ | |
379 | if (written == -1) { | |
380 | oss_logerr ( | |
381 | errno, | |
382 | "Failed to write %d bytes of audio data from %p\n", | |
383 | convert_samples << hw->info.shift, | |
384 | dst | |
385 | ); | |
386 | continue; | |
387 | } | |
388 | ||
389 | if (written != convert_samples << hw->info.shift) { | |
390 | int wsamples = written >> hw->info.shift; | |
391 | int wbytes = wsamples << hw->info.shift; | |
392 | if (wbytes != written) { | |
393 | dolog ("warning: Misaligned write %d (requested %d), " | |
394 | "alignment %d\n", | |
395 | wbytes, written, hw->info.align + 1); | |
396 | } | |
397 | decr -= wsamples; | |
398 | rpos = (rpos + wsamples) % hw->samples; | |
399 | break; | |
400 | } | |
401 | } | |
402 | ||
403 | rpos = (rpos + convert_samples) % hw->samples; | |
404 | samples -= convert_samples; | |
405 | } | |
406 | if (oss->mmapped) { | |
407 | oss->old_optr = cntinfo.ptr; | |
408 | } | |
409 | ||
410 | hw->rpos = rpos; | |
411 | return decr; | |
412 | } | |
413 | ||
414 | static void oss_fini_out (HWVoiceOut *hw) | |
415 | { | |
416 | int err; | |
417 | OSSVoiceOut *oss = (OSSVoiceOut *) hw; | |
418 | ||
419 | ldebug ("oss_fini\n"); | |
420 | oss_anal_close (&oss->fd); | |
421 | ||
422 | if (oss->pcm_buf) { | |
423 | if (oss->mmapped) { | |
424 | err = munmap (oss->pcm_buf, hw->samples << hw->info.shift); | |
425 | if (err) { | |
426 | oss_logerr (errno, "Failed to unmap buffer %p, size %d\n", | |
427 | oss->pcm_buf, hw->samples << hw->info.shift); | |
428 | } | |
429 | } | |
430 | else { | |
431 | qemu_free (oss->pcm_buf); | |
432 | } | |
433 | oss->pcm_buf = NULL; | |
434 | } | |
435 | } | |
436 | ||
437 | static int oss_init_out (HWVoiceOut *hw, struct audsettings *as) | |
438 | { | |
439 | OSSVoiceOut *oss = (OSSVoiceOut *) hw; | |
440 | struct oss_params req, obt; | |
441 | int endianness; | |
442 | int err; | |
443 | int fd; | |
444 | audfmt_e effective_fmt; | |
445 | struct audsettings obt_as; | |
446 | ||
447 | oss->fd = -1; | |
448 | ||
449 | req.fmt = aud_to_ossfmt (as->fmt); | |
450 | req.freq = as->freq; | |
451 | req.nchannels = as->nchannels; | |
452 | req.fragsize = conf.fragsize; | |
453 | req.nfrags = conf.nfrags; | |
454 | ||
455 | if (oss_open (0, &req, &obt, &fd)) { | |
456 | return -1; | |
457 | } | |
458 | ||
459 | err = oss_to_audfmt (obt.fmt, &effective_fmt, &endianness); | |
460 | if (err) { | |
461 | oss_anal_close (&fd); | |
462 | return -1; | |
463 | } | |
464 | ||
465 | obt_as.freq = obt.freq; | |
466 | obt_as.nchannels = obt.nchannels; | |
467 | obt_as.fmt = effective_fmt; | |
468 | obt_as.endianness = endianness; | |
469 | ||
470 | audio_pcm_init_info (&hw->info, &obt_as); | |
471 | oss->nfrags = obt.nfrags; | |
472 | oss->fragsize = obt.fragsize; | |
473 | ||
474 | if (obt.nfrags * obt.fragsize & hw->info.align) { | |
475 | dolog ("warning: Misaligned DAC buffer, size %d, alignment %d\n", | |
476 | obt.nfrags * obt.fragsize, hw->info.align + 1); | |
477 | } | |
478 | ||
479 | hw->samples = (obt.nfrags * obt.fragsize) >> hw->info.shift; | |
480 | ||
481 | oss->mmapped = 0; | |
482 | if (conf.try_mmap) { | |
483 | oss->pcm_buf = mmap ( | |
484 | NULL, | |
485 | hw->samples << hw->info.shift, | |
486 | PROT_READ | PROT_WRITE, | |
487 | MAP_SHARED, | |
488 | fd, | |
489 | 0 | |
490 | ); | |
491 | if (oss->pcm_buf == MAP_FAILED) { | |
492 | oss_logerr (errno, "Failed to map %d bytes of DAC\n", | |
493 | hw->samples << hw->info.shift); | |
494 | } else { | |
495 | int err; | |
496 | int trig = 0; | |
497 | if (ioctl (fd, SNDCTL_DSP_SETTRIGGER, &trig) < 0) { | |
498 | oss_logerr (errno, "SNDCTL_DSP_SETTRIGGER 0 failed\n"); | |
499 | } | |
500 | else { | |
501 | trig = PCM_ENABLE_OUTPUT; | |
502 | if (ioctl (fd, SNDCTL_DSP_SETTRIGGER, &trig) < 0) { | |
503 | oss_logerr ( | |
504 | errno, | |
505 | "SNDCTL_DSP_SETTRIGGER PCM_ENABLE_OUTPUT failed\n" | |
506 | ); | |
507 | } | |
508 | else { | |
509 | oss->mmapped = 1; | |
510 | } | |
511 | } | |
512 | ||
513 | if (!oss->mmapped) { | |
514 | err = munmap (oss->pcm_buf, hw->samples << hw->info.shift); | |
515 | if (err) { | |
516 | oss_logerr (errno, "Failed to unmap buffer %p size %d\n", | |
517 | oss->pcm_buf, hw->samples << hw->info.shift); | |
518 | } | |
519 | } | |
520 | } | |
521 | } | |
522 | ||
523 | if (!oss->mmapped) { | |
524 | oss->pcm_buf = audio_calloc ( | |
525 | AUDIO_FUNC, | |
526 | hw->samples, | |
527 | 1 << hw->info.shift | |
528 | ); | |
529 | if (!oss->pcm_buf) { | |
530 | dolog ( | |
531 | "Could not allocate DAC buffer (%d samples, each %d bytes)\n", | |
532 | hw->samples, | |
533 | 1 << hw->info.shift | |
534 | ); | |
535 | oss_anal_close (&fd); | |
536 | return -1; | |
537 | } | |
538 | } | |
539 | ||
540 | oss->fd = fd; | |
541 | return 0; | |
542 | } | |
543 | ||
544 | static int oss_ctl_out (HWVoiceOut *hw, int cmd, ...) | |
545 | { | |
546 | int trig; | |
547 | OSSVoiceOut *oss = (OSSVoiceOut *) hw; | |
548 | ||
549 | if (!oss->mmapped) { | |
550 | return 0; | |
551 | } | |
552 | ||
553 | switch (cmd) { | |
554 | case VOICE_ENABLE: | |
555 | ldebug ("enabling voice\n"); | |
556 | audio_pcm_info_clear_buf (&hw->info, oss->pcm_buf, hw->samples); | |
557 | trig = PCM_ENABLE_OUTPUT; | |
558 | if (ioctl (oss->fd, SNDCTL_DSP_SETTRIGGER, &trig) < 0) { | |
559 | oss_logerr ( | |
560 | errno, | |
561 | "SNDCTL_DSP_SETTRIGGER PCM_ENABLE_OUTPUT failed\n" | |
562 | ); | |
563 | return -1; | |
564 | } | |
565 | break; | |
566 | ||
567 | case VOICE_DISABLE: | |
568 | ldebug ("disabling voice\n"); | |
569 | trig = 0; | |
570 | if (ioctl (oss->fd, SNDCTL_DSP_SETTRIGGER, &trig) < 0) { | |
571 | oss_logerr (errno, "SNDCTL_DSP_SETTRIGGER 0 failed\n"); | |
572 | return -1; | |
573 | } | |
574 | break; | |
575 | } | |
576 | return 0; | |
577 | } | |
578 | ||
579 | static int oss_init_in (HWVoiceIn *hw, struct audsettings *as) | |
580 | { | |
581 | OSSVoiceIn *oss = (OSSVoiceIn *) hw; | |
582 | struct oss_params req, obt; | |
583 | int endianness; | |
584 | int err; | |
585 | int fd; | |
586 | audfmt_e effective_fmt; | |
587 | struct audsettings obt_as; | |
588 | ||
589 | oss->fd = -1; | |
590 | ||
591 | req.fmt = aud_to_ossfmt (as->fmt); | |
592 | req.freq = as->freq; | |
593 | req.nchannels = as->nchannels; | |
594 | req.fragsize = conf.fragsize; | |
595 | req.nfrags = conf.nfrags; | |
596 | if (oss_open (1, &req, &obt, &fd)) { | |
597 | return -1; | |
598 | } | |
599 | ||
600 | err = oss_to_audfmt (obt.fmt, &effective_fmt, &endianness); | |
601 | if (err) { | |
602 | oss_anal_close (&fd); | |
603 | return -1; | |
604 | } | |
605 | ||
606 | obt_as.freq = obt.freq; | |
607 | obt_as.nchannels = obt.nchannels; | |
608 | obt_as.fmt = effective_fmt; | |
609 | obt_as.endianness = endianness; | |
610 | ||
611 | audio_pcm_init_info (&hw->info, &obt_as); | |
612 | oss->nfrags = obt.nfrags; | |
613 | oss->fragsize = obt.fragsize; | |
614 | ||
615 | if (obt.nfrags * obt.fragsize & hw->info.align) { | |
616 | dolog ("warning: Misaligned ADC buffer, size %d, alignment %d\n", | |
617 | obt.nfrags * obt.fragsize, hw->info.align + 1); | |
618 | } | |
619 | ||
620 | hw->samples = (obt.nfrags * obt.fragsize) >> hw->info.shift; | |
621 | oss->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift); | |
622 | if (!oss->pcm_buf) { | |
623 | dolog ("Could not allocate ADC buffer (%d samples, each %d bytes)\n", | |
624 | hw->samples, 1 << hw->info.shift); | |
625 | oss_anal_close (&fd); | |
626 | return -1; | |
627 | } | |
628 | ||
629 | oss->fd = fd; | |
630 | return 0; | |
631 | } | |
632 | ||
633 | static void oss_fini_in (HWVoiceIn *hw) | |
634 | { | |
635 | OSSVoiceIn *oss = (OSSVoiceIn *) hw; | |
636 | ||
637 | oss_anal_close (&oss->fd); | |
638 | ||
639 | if (oss->pcm_buf) { | |
640 | qemu_free (oss->pcm_buf); | |
641 | oss->pcm_buf = NULL; | |
642 | } | |
643 | } | |
644 | ||
645 | static int oss_run_in (HWVoiceIn *hw) | |
646 | { | |
647 | OSSVoiceIn *oss = (OSSVoiceIn *) hw; | |
648 | int hwshift = hw->info.shift; | |
649 | int i; | |
650 | int live = audio_pcm_hw_get_live_in (hw); | |
651 | int dead = hw->samples - live; | |
652 | size_t read_samples = 0; | |
653 | struct { | |
654 | int add; | |
655 | int len; | |
656 | } bufs[2] = { | |
657 | { hw->wpos, 0 }, | |
658 | { 0, 0 } | |
659 | }; | |
660 | ||
661 | if (!dead) { | |
662 | return 0; | |
663 | } | |
664 | ||
665 | if (hw->wpos + dead > hw->samples) { | |
666 | bufs[0].len = (hw->samples - hw->wpos) << hwshift; | |
667 | bufs[1].len = (dead - (hw->samples - hw->wpos)) << hwshift; | |
668 | } | |
669 | else { | |
670 | bufs[0].len = dead << hwshift; | |
671 | } | |
672 | ||
673 | ||
674 | for (i = 0; i < 2; ++i) { | |
675 | ssize_t nread; | |
676 | ||
677 | if (bufs[i].len) { | |
678 | void *p = advance (oss->pcm_buf, bufs[i].add << hwshift); | |
679 | nread = read (oss->fd, p, bufs[i].len); | |
680 | ||
681 | if (nread > 0) { | |
682 | if (nread & hw->info.align) { | |
683 | dolog ("warning: Misaligned read %zd (requested %d), " | |
684 | "alignment %d\n", nread, bufs[i].add << hwshift, | |
685 | hw->info.align + 1); | |
686 | } | |
687 | read_samples += nread >> hwshift; | |
688 | hw->conv (hw->conv_buf + bufs[i].add, p, nread >> hwshift, | |
689 | &nominal_volume); | |
690 | } | |
691 | ||
692 | if (bufs[i].len - nread) { | |
693 | if (nread == -1) { | |
694 | switch (errno) { | |
695 | case EINTR: | |
696 | case EAGAIN: | |
697 | break; | |
698 | default: | |
699 | oss_logerr ( | |
700 | errno, | |
701 | "Failed to read %d bytes of audio (to %p)\n", | |
702 | bufs[i].len, p | |
703 | ); | |
704 | break; | |
705 | } | |
706 | } | |
707 | break; | |
708 | } | |
709 | } | |
710 | } | |
711 | ||
712 | hw->wpos = (hw->wpos + read_samples) % hw->samples; | |
713 | return read_samples; | |
714 | } | |
715 | ||
716 | static int oss_read (SWVoiceIn *sw, void *buf, int size) | |
717 | { | |
718 | return audio_pcm_sw_read (sw, buf, size); | |
719 | } | |
720 | ||
721 | static int oss_ctl_in (HWVoiceIn *hw, int cmd, ...) | |
722 | { | |
723 | (void) hw; | |
724 | (void) cmd; | |
725 | return 0; | |
726 | } | |
727 | ||
728 | static void *oss_audio_init (void) | |
729 | { | |
730 | return &conf; | |
731 | } | |
732 | ||
733 | static void oss_audio_fini (void *opaque) | |
734 | { | |
735 | (void) opaque; | |
736 | } | |
737 | ||
738 | static struct audio_option oss_options[] = { | |
739 | {.name = "FRAGSIZE", | |
740 | .tag = AUD_OPT_INT, | |
741 | .valp = &conf.fragsize, | |
742 | .descr = "Fragment size in bytes"}, | |
743 | {.name = "NFRAGS", | |
744 | .tag = AUD_OPT_INT, | |
745 | .valp = &conf.nfrags, | |
746 | .descr = "Number of fragments"}, | |
747 | {.name = "MMAP", | |
748 | .tag = AUD_OPT_BOOL, | |
749 | .valp = &conf.try_mmap, | |
750 | .descr = "Try using memory mapped access"}, | |
751 | {.name = "DAC_DEV", | |
752 | .tag = AUD_OPT_STR, | |
753 | .valp = &conf.devpath_out, | |
754 | .descr = "Path to DAC device"}, | |
755 | {.name = "ADC_DEV", | |
756 | .tag = AUD_OPT_STR, | |
757 | .valp = &conf.devpath_in, | |
758 | .descr = "Path to ADC device"}, | |
759 | {.name = "DEBUG", | |
760 | .tag = AUD_OPT_BOOL, | |
761 | .valp = &conf.debug, | |
762 | .descr = "Turn on some debugging messages"}, | |
763 | { /* End of list */ } | |
764 | }; | |
765 | ||
766 | static struct audio_pcm_ops oss_pcm_ops = { | |
767 | oss_init_out, | |
768 | oss_fini_out, | |
769 | oss_run_out, | |
770 | oss_write, | |
771 | oss_ctl_out, | |
772 | ||
773 | oss_init_in, | |
774 | oss_fini_in, | |
775 | oss_run_in, | |
776 | oss_read, | |
777 | oss_ctl_in | |
778 | }; | |
779 | ||
780 | struct audio_driver oss_audio_driver = { | |
781 | .name = "oss", | |
782 | .descr = "OSS http://www.opensound.com", | |
783 | .options = oss_options, | |
784 | .init = oss_audio_init, | |
785 | .fini = oss_audio_fini, | |
786 | .pcm_ops = &oss_pcm_ops, | |
787 | .can_be_default = 1, | |
788 | .max_voices_out = INT_MAX, | |
789 | .max_voices_in = INT_MAX, | |
790 | .voice_size_out = sizeof (OSSVoiceOut), | |
791 | .voice_size_in = sizeof (OSSVoiceIn) | |
792 | }; |