root / oss.c @ c94c8d64
History | View | Annotate | Download (13.5 kB)
1 |
/*
|
---|---|
2 |
* QEMU OSS Audio output driver
|
3 |
*
|
4 |
* Copyright (c) 2003 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 "vl.h" |
25 |
|
26 |
#if !defined(_WIN32) && !defined(__APPLE__)
|
27 |
#include <ctype.h> |
28 |
#include <fcntl.h> |
29 |
#include <errno.h> |
30 |
#include <stdio.h> |
31 |
#include <unistd.h> |
32 |
#include <string.h> |
33 |
#include <stdlib.h> |
34 |
#include <limits.h> |
35 |
#include <inttypes.h> |
36 |
#include <sys/mman.h> |
37 |
#include <sys/types.h> |
38 |
#include <sys/ioctl.h> |
39 |
#include <sys/soundcard.h> |
40 |
|
41 |
|
42 |
/* http://www.df.lth.se/~john_e/gems/gem002d.html */
|
43 |
/* http://www.multi-platforms.com/Tips/PopCount.htm */
|
44 |
static inline uint32_t popcount (uint32_t u) |
45 |
{ |
46 |
u = ((u&0x55555555) + ((u>>1)&0x55555555)); |
47 |
u = ((u&0x33333333) + ((u>>2)&0x33333333)); |
48 |
u = ((u&0x0f0f0f0f) + ((u>>4)&0x0f0f0f0f)); |
49 |
u = ((u&0x00ff00ff) + ((u>>8)&0x00ff00ff)); |
50 |
u = ( u&0x0000ffff) + (u>>16); |
51 |
return u;
|
52 |
} |
53 |
|
54 |
static inline uint32_t lsbindex (uint32_t u) |
55 |
{ |
56 |
return popcount ((u&-u)-1); |
57 |
} |
58 |
|
59 |
#define MIN(a, b) ((a)>(b)?(b):(a))
|
60 |
#define MAX(a, b) ((a)<(b)?(b):(a))
|
61 |
|
62 |
#define DEREF(x) (void)x |
63 |
#define log(...) fprintf (stderr, "oss: " __VA_ARGS__) |
64 |
#define ERRFail(...) do { \ |
65 |
int _errno = errno; \
|
66 |
fprintf (stderr, "oss: " __VA_ARGS__); \
|
67 |
fprintf (stderr, "system error: %s\n", strerror (_errno)); \
|
68 |
abort (); \ |
69 |
} while (0) |
70 |
#define Fail(...) do { \ |
71 |
fprintf (stderr, "oss: " __VA_ARGS__); \
|
72 |
fprintf (stderr, "\n"); \
|
73 |
abort (); \ |
74 |
} while (0) |
75 |
|
76 |
#ifdef DEBUG_OSS
|
77 |
#define lwarn(...) fprintf (stderr, "oss: " __VA_ARGS__) |
78 |
#define linfo(...) fprintf (stderr, "oss: " __VA_ARGS__) |
79 |
#define ldebug(...) fprintf (stderr, "oss: " __VA_ARGS__) |
80 |
#else
|
81 |
#define lwarn(...)
|
82 |
#define linfo(...)
|
83 |
#define ldebug(...)
|
84 |
#endif
|
85 |
|
86 |
|
87 |
#define IOCTL(args) do { \ |
88 |
int ret = ioctl args; \
|
89 |
if (-1 == ret) { \ |
90 |
ERRFail (#args); \
|
91 |
} \ |
92 |
ldebug ("ioctl " #args " = %d\n", ret); \ |
93 |
} while (0) |
94 |
|
95 |
static struct { |
96 |
int fd;
|
97 |
int freq;
|
98 |
int bits16;
|
99 |
int nchannels;
|
100 |
int rpos;
|
101 |
int wpos;
|
102 |
int live;
|
103 |
int oss_fmt;
|
104 |
int bytes_per_second;
|
105 |
int is_mapped;
|
106 |
void *buf;
|
107 |
int bufsize;
|
108 |
int nfrags;
|
109 |
int fragsize;
|
110 |
int old_optr;
|
111 |
int leftover;
|
112 |
uint64_t old_ticks; |
113 |
void (*copy_fn)(void *, void *, int); |
114 |
} oss = { .fd = -1 };
|
115 |
|
116 |
static struct { |
117 |
int try_mmap;
|
118 |
int nfrags;
|
119 |
int fragsize;
|
120 |
} conf = { |
121 |
.try_mmap = 0,
|
122 |
.nfrags = 4,
|
123 |
.fragsize = 4096
|
124 |
}; |
125 |
|
126 |
static enum {DONT, DSP, TID} est = DONT; |
127 |
|
128 |
static void copy_no_conversion (void *dst, void *src, int size) |
129 |
{ |
130 |
memcpy (dst, src, size); |
131 |
} |
132 |
|
133 |
static void copy_u16_to_s16 (void *dst, void *src, int size) |
134 |
{ |
135 |
int i;
|
136 |
uint16_t *out, *in; |
137 |
|
138 |
out = dst; |
139 |
in = src; |
140 |
|
141 |
for (i = 0; i < size / 2; i++) { |
142 |
out[i] = in[i] + 0x8000;
|
143 |
} |
144 |
} |
145 |
|
146 |
static void pab (struct audio_buf_info *abinfo) |
147 |
{ |
148 |
DEREF (abinfo); |
149 |
|
150 |
ldebug ("fragments %d, fragstotal %d, fragsize %d, bytes %d\n"
|
151 |
"rpos %d, wpos %d, live %d\n",
|
152 |
abinfo->fragments, |
153 |
abinfo->fragstotal, |
154 |
abinfo->fragsize, |
155 |
abinfo->bytes, |
156 |
rpos, wpos, live); |
157 |
} |
158 |
|
159 |
static void do_open () |
160 |
{ |
161 |
int mmmmssss;
|
162 |
audio_buf_info abinfo; |
163 |
int fmt, freq, nchannels;
|
164 |
|
165 |
if (oss.buf) {
|
166 |
if (-1 == munmap (oss.buf, oss.bufsize)) { |
167 |
ERRFail ("failed to unmap audio buffer %p %d",
|
168 |
oss.buf, oss.bufsize); |
169 |
} |
170 |
oss.buf = NULL;
|
171 |
} |
172 |
|
173 |
if (-1 != oss.fd) |
174 |
close (oss.fd); |
175 |
|
176 |
oss.fd = open ("/dev/dsp", O_RDWR | O_NONBLOCK);
|
177 |
if (-1 == oss.fd) { |
178 |
ERRFail ("can not open /dev/dsp");
|
179 |
} |
180 |
|
181 |
fmt = oss.oss_fmt; |
182 |
freq = oss.freq; |
183 |
nchannels = oss.nchannels; |
184 |
|
185 |
IOCTL ((oss.fd, SNDCTL_DSP_RESET, 1));
|
186 |
IOCTL ((oss.fd, SNDCTL_DSP_SAMPLESIZE, &fmt)); |
187 |
IOCTL ((oss.fd, SNDCTL_DSP_CHANNELS, &nchannels)); |
188 |
IOCTL ((oss.fd, SNDCTL_DSP_SPEED, &freq)); |
189 |
IOCTL ((oss.fd, SNDCTL_DSP_NONBLOCK)); |
190 |
|
191 |
mmmmssss = (conf.nfrags << 16) | conf.fragsize;
|
192 |
IOCTL ((oss.fd, SNDCTL_DSP_SETFRAGMENT, &mmmmssss)); |
193 |
|
194 |
if ((oss.oss_fmt != fmt)
|
195 |
|| (oss.nchannels != nchannels) |
196 |
|| (oss.freq != freq)) { |
197 |
Fail ("failed to set audio parameters\n"
|
198 |
"parameter | requested value | obtained value\n"
|
199 |
"format | %10d | %10d\n"
|
200 |
"channels | %10d | %10d\n"
|
201 |
"frequency | %10d | %10d\n",
|
202 |
oss.oss_fmt, fmt, |
203 |
oss.nchannels, nchannels, |
204 |
oss.freq, freq); |
205 |
} |
206 |
|
207 |
IOCTL ((oss.fd, SNDCTL_DSP_GETOSPACE, &abinfo)); |
208 |
|
209 |
oss.nfrags = abinfo.fragstotal; |
210 |
oss.fragsize = abinfo.fragsize; |
211 |
oss.bufsize = oss.nfrags * oss.fragsize; |
212 |
oss.old_optr = 0;
|
213 |
|
214 |
oss.bytes_per_second = (freq << (nchannels >> 1)) << oss.bits16;
|
215 |
|
216 |
linfo ("bytes per second %d\n", oss.bytes_per_second);
|
217 |
|
218 |
linfo ("fragments %d, fragstotal %d, fragsize %d, bytes %d, bufsize %d\n",
|
219 |
abinfo.fragments, |
220 |
abinfo.fragstotal, |
221 |
abinfo.fragsize, |
222 |
abinfo.bytes, |
223 |
oss.bufsize); |
224 |
|
225 |
oss.buf = MAP_FAILED; |
226 |
oss.is_mapped = 0;
|
227 |
|
228 |
if (conf.try_mmap) {
|
229 |
oss.buf = mmap (NULL, oss.bufsize, PROT_WRITE, MAP_SHARED, oss.fd, 0); |
230 |
if (MAP_FAILED == oss.buf) {
|
231 |
int err;
|
232 |
|
233 |
err = errno; |
234 |
log ("failed to mmap audio, size %d, fd %d\n"
|
235 |
"syserr: %s\n",
|
236 |
oss.bufsize, oss.fd, strerror (err)); |
237 |
} |
238 |
else {
|
239 |
est = TID; |
240 |
oss.is_mapped = 1;
|
241 |
} |
242 |
} |
243 |
|
244 |
if (MAP_FAILED == oss.buf) {
|
245 |
est = TID; |
246 |
oss.buf = mmap (NULL, oss.bufsize, PROT_READ | PROT_WRITE,
|
247 |
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0); |
248 |
if (MAP_FAILED == oss.buf) {
|
249 |
ERRFail ("mmap audio buf, size %d", oss.bufsize);
|
250 |
} |
251 |
} |
252 |
|
253 |
oss.rpos = 0;
|
254 |
oss.wpos = 0;
|
255 |
oss.live = 0;
|
256 |
|
257 |
if (oss.is_mapped) {
|
258 |
int trig;
|
259 |
|
260 |
trig = 0;
|
261 |
IOCTL ((oss.fd, SNDCTL_DSP_SETTRIGGER, &trig)); |
262 |
trig = PCM_ENABLE_OUTPUT; |
263 |
IOCTL ((oss.fd, SNDCTL_DSP_SETTRIGGER, &trig)); |
264 |
} |
265 |
} |
266 |
|
267 |
static void maybe_open (int req_freq, int req_nchannels, |
268 |
audfmt_e req_fmt, int force_open)
|
269 |
{ |
270 |
int oss_fmt, bits16;
|
271 |
|
272 |
switch (req_fmt) {
|
273 |
case AUD_FMT_U8:
|
274 |
bits16 = 0;
|
275 |
oss_fmt = AFMT_U8; |
276 |
oss.copy_fn = copy_no_conversion; |
277 |
break;
|
278 |
|
279 |
case AUD_FMT_S8:
|
280 |
Fail ("can not play 8bit signed");
|
281 |
|
282 |
case AUD_FMT_S16:
|
283 |
bits16 = 1;
|
284 |
oss_fmt = AFMT_S16_LE; |
285 |
oss.copy_fn = copy_no_conversion; |
286 |
break;
|
287 |
|
288 |
case AUD_FMT_U16:
|
289 |
bits16 = 1;
|
290 |
oss_fmt = AFMT_S16_LE; |
291 |
oss.copy_fn = copy_u16_to_s16; |
292 |
break;
|
293 |
|
294 |
default:
|
295 |
abort (); |
296 |
} |
297 |
|
298 |
if (force_open
|
299 |
|| (-1 == oss.fd)
|
300 |
|| (oss_fmt != oss.oss_fmt) |
301 |
|| (req_nchannels != oss.nchannels) |
302 |
|| (req_freq != oss.freq) |
303 |
|| (bits16 != oss.bits16)) { |
304 |
oss.oss_fmt = oss_fmt; |
305 |
oss.nchannels = req_nchannels; |
306 |
oss.freq = req_freq; |
307 |
oss.bits16 = bits16; |
308 |
do_open (); |
309 |
} |
310 |
} |
311 |
|
312 |
void AUD_reset (int req_freq, int req_nchannels, audfmt_e req_fmt) |
313 |
{ |
314 |
maybe_open (req_freq, req_nchannels, req_fmt, 0);
|
315 |
} |
316 |
|
317 |
void AUD_open (int req_freq, int req_nchannels, audfmt_e req_fmt) |
318 |
{ |
319 |
maybe_open (req_freq, req_nchannels, req_fmt, 1);
|
320 |
} |
321 |
|
322 |
int AUD_write (void *in_buf, int size) |
323 |
{ |
324 |
int to_copy, temp;
|
325 |
uint8_t *in, *out; |
326 |
|
327 |
to_copy = MIN (oss.bufsize - oss.live, size); |
328 |
|
329 |
temp = to_copy; |
330 |
|
331 |
in = in_buf; |
332 |
out = oss.buf; |
333 |
|
334 |
while (temp) {
|
335 |
int copy;
|
336 |
|
337 |
copy = MIN (temp, oss.bufsize - oss.wpos); |
338 |
oss.copy_fn (out + oss.wpos, in, copy); |
339 |
|
340 |
oss.wpos += copy; |
341 |
if (oss.wpos == oss.bufsize) {
|
342 |
oss.wpos = 0;
|
343 |
} |
344 |
|
345 |
temp -= copy; |
346 |
in += copy; |
347 |
oss.live += copy; |
348 |
} |
349 |
|
350 |
return to_copy;
|
351 |
} |
352 |
|
353 |
void AUD_run (void) |
354 |
{ |
355 |
int res;
|
356 |
int bytes;
|
357 |
struct audio_buf_info abinfo;
|
358 |
|
359 |
if (0 == oss.live) |
360 |
return;
|
361 |
|
362 |
if (oss.is_mapped) {
|
363 |
count_info info; |
364 |
|
365 |
res = ioctl (oss.fd, SNDCTL_DSP_GETOPTR, &info); |
366 |
if (-1 == res) { |
367 |
int err;
|
368 |
|
369 |
err = errno; |
370 |
lwarn ("SNDCTL_DSP_GETOPTR failed with %s\n", strerror (err));
|
371 |
return;
|
372 |
} |
373 |
|
374 |
if (info.ptr > oss.old_optr) {
|
375 |
bytes = info.ptr - oss.old_optr; |
376 |
} |
377 |
else {
|
378 |
bytes = oss.bufsize + info.ptr - oss.old_optr; |
379 |
} |
380 |
|
381 |
oss.old_optr = info.ptr; |
382 |
oss.live -= bytes; |
383 |
return;
|
384 |
} |
385 |
|
386 |
res = ioctl (oss.fd, SNDCTL_DSP_GETOSPACE, &abinfo); |
387 |
|
388 |
if (-1 == res) { |
389 |
int err;
|
390 |
|
391 |
err = errno; |
392 |
lwarn ("SNDCTL_DSP_GETOSPACE failed with %s\n", strerror (err));
|
393 |
} |
394 |
|
395 |
bytes = abinfo.bytes; |
396 |
bytes = MIN (oss.live, bytes); |
397 |
#if 0
|
398 |
bytes = (bytes / fragsize) * fragsize;
|
399 |
#endif
|
400 |
|
401 |
while (bytes) {
|
402 |
int left, play, written;
|
403 |
|
404 |
left = oss.bufsize - oss.rpos; |
405 |
play = MIN (left, bytes); |
406 |
written = write (oss.fd, (void *) ((uint32_t) oss.buf + oss.rpos), play);
|
407 |
|
408 |
if (-1 == written) { |
409 |
if (EAGAIN == errno || EINTR == errno) {
|
410 |
return;
|
411 |
} |
412 |
else {
|
413 |
ERRFail ("write audio");
|
414 |
} |
415 |
} |
416 |
|
417 |
play = written; |
418 |
oss.live -= play; |
419 |
oss.rpos += play; |
420 |
bytes -= play; |
421 |
|
422 |
if (oss.rpos == oss.bufsize) {
|
423 |
oss.rpos = 0;
|
424 |
} |
425 |
} |
426 |
} |
427 |
|
428 |
static int get_dsp_bytes (void) |
429 |
{ |
430 |
int res;
|
431 |
struct count_info info;
|
432 |
|
433 |
res = ioctl (oss.fd, SNDCTL_DSP_GETOPTR, &info); |
434 |
if (-1 == res) { |
435 |
int err;
|
436 |
|
437 |
err = errno; |
438 |
lwarn ("SNDCTL_DSP_GETOPTR failed with %s\n", strerror (err));
|
439 |
return -1; |
440 |
} |
441 |
else {
|
442 |
ldebug ("bytes %d\n", info.bytes);
|
443 |
return info.bytes;
|
444 |
} |
445 |
} |
446 |
|
447 |
void AUD_adjust_estimate (int leftover) |
448 |
{ |
449 |
oss.leftover = leftover; |
450 |
} |
451 |
|
452 |
int AUD_get_free (void) |
453 |
{ |
454 |
int free, elapsed;
|
455 |
|
456 |
free = oss.bufsize - oss.live; |
457 |
|
458 |
if (0 == free) |
459 |
return 0; |
460 |
|
461 |
elapsed = free; |
462 |
switch (est) {
|
463 |
case DONT:
|
464 |
break;
|
465 |
|
466 |
case DSP:
|
467 |
{ |
468 |
static int old_bytes; |
469 |
int bytes;
|
470 |
|
471 |
bytes = get_dsp_bytes (); |
472 |
if (bytes <= 0) |
473 |
return free;
|
474 |
|
475 |
elapsed = bytes - old_bytes; |
476 |
old_bytes = bytes; |
477 |
ldebug ("dsp elapsed %d bytes\n", elapsed);
|
478 |
break;
|
479 |
} |
480 |
|
481 |
case TID:
|
482 |
{ |
483 |
uint64_t ticks, delta; |
484 |
uint64_t ua_elapsed; |
485 |
uint64_t al_elapsed; |
486 |
|
487 |
ticks = qemu_get_clock(rt_clock); |
488 |
delta = ticks - oss.old_ticks; |
489 |
oss.old_ticks = ticks; |
490 |
|
491 |
ua_elapsed = (delta * oss.bytes_per_second) / 1000;
|
492 |
al_elapsed = ua_elapsed & ~3ULL;
|
493 |
|
494 |
ldebug ("tid elapsed %llu bytes\n", ua_elapsed);
|
495 |
|
496 |
if (al_elapsed > (uint64_t) INT_MAX)
|
497 |
elapsed = INT_MAX; |
498 |
else
|
499 |
elapsed = al_elapsed; |
500 |
|
501 |
elapsed += oss.leftover; |
502 |
} |
503 |
} |
504 |
|
505 |
if (elapsed > free) {
|
506 |
lwarn ("audio can not keep up elapsed %d free %d\n", elapsed, free);
|
507 |
return free;
|
508 |
} |
509 |
else {
|
510 |
return elapsed;
|
511 |
} |
512 |
} |
513 |
|
514 |
int AUD_get_live (void) |
515 |
{ |
516 |
return oss.live;
|
517 |
} |
518 |
|
519 |
int AUD_get_buffer_size (void) |
520 |
{ |
521 |
return oss.bufsize;
|
522 |
} |
523 |
|
524 |
#define QC_OSS_FRAGSIZE "QEMU_OSS_FRAGSIZE" |
525 |
#define QC_OSS_NFRAGS "QEMU_OSS_NFRAGS" |
526 |
#define QC_OSS_MMAP "QEMU_OSS_MMAP" |
527 |
|
528 |
static int get_conf_val (const char *key, int defval) |
529 |
{ |
530 |
int val = defval;
|
531 |
char *strval;
|
532 |
|
533 |
strval = getenv (key); |
534 |
if (strval) {
|
535 |
val = atoi (strval); |
536 |
} |
537 |
|
538 |
return val;
|
539 |
} |
540 |
|
541 |
void AUD_init (void) |
542 |
{ |
543 |
int fsp;
|
544 |
|
545 |
DEREF (pab); |
546 |
|
547 |
conf.fragsize = get_conf_val (QC_OSS_FRAGSIZE, conf.fragsize); |
548 |
conf.nfrags = get_conf_val (QC_OSS_NFRAGS, conf.nfrags); |
549 |
conf.try_mmap = get_conf_val (QC_OSS_MMAP, conf.try_mmap); |
550 |
|
551 |
fsp = conf.fragsize; |
552 |
if (0 != (fsp & (fsp - 1))) { |
553 |
Fail ("fragment size %d is not power of 2", fsp);
|
554 |
} |
555 |
|
556 |
conf.fragsize = lsbindex (fsp); |
557 |
} |
558 |
|
559 |
#else
|
560 |
|
561 |
void AUD_run (void) |
562 |
{ |
563 |
} |
564 |
|
565 |
int AUD_write (void *in_buf, int size) |
566 |
{ |
567 |
return 0; |
568 |
} |
569 |
|
570 |
void AUD_reset (int rfreq, int rnchannels, audfmt_e rfmt) |
571 |
{ |
572 |
} |
573 |
|
574 |
void AUD_adjust_estimate (int _leftover) |
575 |
{ |
576 |
} |
577 |
|
578 |
int AUD_get_free (void) |
579 |
{ |
580 |
return 0; |
581 |
} |
582 |
|
583 |
int AUD_get_live (void) |
584 |
{ |
585 |
return 0; |
586 |
} |
587 |
|
588 |
int AUD_get_buffer_size (void) |
589 |
{ |
590 |
return 0; |
591 |
} |
592 |
|
593 |
void AUD_init (void) |
594 |
{ |
595 |
} |
596 |
|
597 |
#endif
|