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 }; 945