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 G_GNUC_PRINTF (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 G_GNUC_PRINTF (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 } else { 146 return AFMT_S16_LE; 147 } 148 149 case AUDIO_FORMAT_U16: 150 if (endianness) { 151 return AFMT_U16_BE; 152 } else { 153 return AFMT_U16_LE; 154 } 155 156 default: 157 dolog ("Internal logic error: Bad audio format %d\n", fmt); 158 #ifdef DEBUG_AUDIO 159 abort (); 160 #endif 161 return AFMT_U8; 162 } 163 } 164 165 static int oss_to_audfmt (int ossfmt, AudioFormat *fmt, int *endianness) 166 { 167 switch (ossfmt) { 168 case AFMT_S8: 169 *endianness = 0; 170 *fmt = AUDIO_FORMAT_S8; 171 break; 172 173 case AFMT_U8: 174 *endianness = 0; 175 *fmt = AUDIO_FORMAT_U8; 176 break; 177 178 case AFMT_S16_LE: 179 *endianness = 0; 180 *fmt = AUDIO_FORMAT_S16; 181 break; 182 183 case AFMT_U16_LE: 184 *endianness = 0; 185 *fmt = AUDIO_FORMAT_U16; 186 break; 187 188 case AFMT_S16_BE: 189 *endianness = 1; 190 *fmt = AUDIO_FORMAT_S16; 191 break; 192 193 case AFMT_U16_BE: 194 *endianness = 1; 195 *fmt = AUDIO_FORMAT_U16; 196 break; 197 198 default: 199 dolog ("Unrecognized audio format %d\n", ossfmt); 200 return -1; 201 } 202 203 return 0; 204 } 205 206 #if defined DEBUG_MISMATCHES || defined DEBUG 207 static void oss_dump_info (struct oss_params *req, struct oss_params *obt) 208 { 209 dolog ("parameter | requested value | obtained value\n"); 210 dolog ("format | %10d | %10d\n", req->fmt, obt->fmt); 211 dolog ("channels | %10d | %10d\n", 212 req->nchannels, obt->nchannels); 213 dolog ("frequency | %10d | %10d\n", req->freq, obt->freq); 214 dolog ("nfrags | %10d | %10d\n", req->nfrags, obt->nfrags); 215 dolog ("fragsize | %10d | %10d\n", 216 req->fragsize, obt->fragsize); 217 } 218 #endif 219 220 #ifdef USE_DSP_POLICY 221 static int oss_get_version (int fd, int *version, const char *typ) 222 { 223 if (ioctl (fd, OSS_GETVERSION, &version)) { 224 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) 225 /* 226 * Looks like atm (20100109) FreeBSD knows OSS_GETVERSION 227 * since 7.x, but currently only on the mixer device (or in 228 * the Linuxolator), and in the native version that part of 229 * the code is in fact never reached so the ioctl fails anyway. 230 * Until this is fixed, just check the errno and if its what 231 * FreeBSD's sound drivers return atm assume they are new enough. 232 */ 233 if (errno == EINVAL) { 234 *version = 0x040000; 235 return 0; 236 } 237 #endif 238 oss_logerr2 (errno, typ, "Failed to get OSS version\n"); 239 return -1; 240 } 241 return 0; 242 } 243 #endif 244 245 static int oss_open(int in, struct oss_params *req, audsettings *as, 246 struct oss_params *obt, int *pfd, Audiodev *dev) 247 { 248 AudiodevOssOptions *oopts = &dev->u.oss; 249 AudiodevOssPerDirectionOptions *opdo = in ? oopts->in : oopts->out; 250 int fd; 251 int oflags = (oopts->has_exclusive && oopts->exclusive) ? O_EXCL : 0; 252 audio_buf_info abinfo; 253 int fmt, freq, nchannels; 254 int setfragment = 1; 255 const char *dspname = opdo->dev ?: "/dev/dsp"; 256 const char *typ = in ? "ADC" : "DAC"; 257 #ifdef USE_DSP_POLICY 258 int policy = oopts->has_dsp_policy ? oopts->dsp_policy : 5; 259 #endif 260 261 /* Kludge needed to have working mmap on Linux */ 262 oflags |= (oopts->has_try_mmap && oopts->try_mmap) ? 263 O_RDWR : (in ? O_RDONLY : O_WRONLY); 264 265 fd = open (dspname, oflags | O_NONBLOCK); 266 if (-1 == fd) { 267 oss_logerr2 (errno, typ, "Failed to open `%s'\n", dspname); 268 return -1; 269 } 270 271 freq = req->freq; 272 nchannels = req->nchannels; 273 fmt = req->fmt; 274 req->nfrags = opdo->has_buffer_count ? opdo->buffer_count : 4; 275 req->fragsize = audio_buffer_bytes( 276 qapi_AudiodevOssPerDirectionOptions_base(opdo), as, 23220); 277 278 if (ioctl (fd, SNDCTL_DSP_SAMPLESIZE, &fmt)) { 279 oss_logerr2 (errno, typ, "Failed to set sample size %d\n", req->fmt); 280 goto err; 281 } 282 283 if (ioctl (fd, SNDCTL_DSP_CHANNELS, &nchannels)) { 284 oss_logerr2 (errno, typ, "Failed to set number of channels %d\n", 285 req->nchannels); 286 goto err; 287 } 288 289 if (ioctl (fd, SNDCTL_DSP_SPEED, &freq)) { 290 oss_logerr2 (errno, typ, "Failed to set frequency %d\n", req->freq); 291 goto err; 292 } 293 294 if (ioctl (fd, SNDCTL_DSP_NONBLOCK, NULL)) { 295 oss_logerr2 (errno, typ, "Failed to set non-blocking mode\n"); 296 goto err; 297 } 298 299 #ifdef USE_DSP_POLICY 300 if (policy >= 0) { 301 int version; 302 303 if (!oss_get_version (fd, &version, typ)) { 304 trace_oss_version(version); 305 306 if (version >= 0x040000) { 307 int policy2 = policy; 308 if (ioctl(fd, SNDCTL_DSP_POLICY, &policy2)) { 309 oss_logerr2 (errno, typ, 310 "Failed to set timing policy to %d\n", 311 policy); 312 goto err; 313 } 314 setfragment = 0; 315 } 316 } 317 } 318 #endif 319 320 if (setfragment) { 321 int mmmmssss = (req->nfrags << 16) | ctz32 (req->fragsize); 322 if (ioctl (fd, SNDCTL_DSP_SETFRAGMENT, &mmmmssss)) { 323 oss_logerr2 (errno, typ, "Failed to set buffer length (%d, %d)\n", 324 req->nfrags, req->fragsize); 325 goto err; 326 } 327 } 328 329 if (ioctl (fd, in ? SNDCTL_DSP_GETISPACE : SNDCTL_DSP_GETOSPACE, &abinfo)) { 330 oss_logerr2 (errno, typ, "Failed to get buffer length\n"); 331 goto err; 332 } 333 334 if (!abinfo.fragstotal || !abinfo.fragsize) { 335 AUD_log (AUDIO_CAP, "Returned bogus buffer information(%d, %d) for %s\n", 336 abinfo.fragstotal, abinfo.fragsize, typ); 337 goto err; 338 } 339 340 obt->fmt = fmt; 341 obt->nchannels = nchannels; 342 obt->freq = freq; 343 obt->nfrags = abinfo.fragstotal; 344 obt->fragsize = abinfo.fragsize; 345 *pfd = fd; 346 347 #ifdef DEBUG_MISMATCHES 348 if ((req->fmt != obt->fmt) || 349 (req->nchannels != obt->nchannels) || 350 (req->freq != obt->freq) || 351 (req->fragsize != obt->fragsize) || 352 (req->nfrags != obt->nfrags)) { 353 dolog ("Audio parameters mismatch\n"); 354 oss_dump_info (req, obt); 355 } 356 #endif 357 358 #ifdef DEBUG 359 oss_dump_info (req, obt); 360 #endif 361 return 0; 362 363 err: 364 oss_anal_close (&fd); 365 return -1; 366 } 367 368 static size_t oss_get_available_bytes(OSSVoiceOut *oss) 369 { 370 int err; 371 struct count_info cntinfo; 372 assert(oss->mmapped); 373 374 err = ioctl(oss->fd, SNDCTL_DSP_GETOPTR, &cntinfo); 375 if (err < 0) { 376 oss_logerr(errno, "SNDCTL_DSP_GETOPTR failed\n"); 377 return 0; 378 } 379 380 return audio_ring_dist(cntinfo.ptr, oss->hw.pos_emul, oss->hw.size_emul); 381 } 382 383 static void oss_run_buffer_out(HWVoiceOut *hw) 384 { 385 OSSVoiceOut *oss = (OSSVoiceOut *)hw; 386 387 if (!oss->mmapped) { 388 audio_generic_run_buffer_out(hw); 389 } 390 } 391 392 static size_t oss_buffer_get_free(HWVoiceOut *hw) 393 { 394 OSSVoiceOut *oss = (OSSVoiceOut *)hw; 395 396 if (oss->mmapped) { 397 return oss_get_available_bytes(oss); 398 } else { 399 return audio_generic_buffer_get_free(hw); 400 } 401 } 402 403 static void *oss_get_buffer_out(HWVoiceOut *hw, size_t *size) 404 { 405 OSSVoiceOut *oss = (OSSVoiceOut *)hw; 406 407 if (oss->mmapped) { 408 *size = hw->size_emul - hw->pos_emul; 409 return hw->buf_emul + hw->pos_emul; 410 } else { 411 return audio_generic_get_buffer_out(hw, size); 412 } 413 } 414 415 static size_t oss_put_buffer_out(HWVoiceOut *hw, void *buf, size_t size) 416 { 417 OSSVoiceOut *oss = (OSSVoiceOut *) hw; 418 if (oss->mmapped) { 419 assert(buf == hw->buf_emul + hw->pos_emul && size < hw->size_emul); 420 421 hw->pos_emul = (hw->pos_emul + size) % hw->size_emul; 422 return size; 423 } else { 424 return audio_generic_put_buffer_out(hw, buf, size); 425 } 426 } 427 428 static size_t oss_write(HWVoiceOut *hw, void *buf, size_t len) 429 { 430 OSSVoiceOut *oss = (OSSVoiceOut *) hw; 431 size_t pos; 432 433 if (oss->mmapped) { 434 size_t total_len; 435 len = MIN(len, oss_get_available_bytes(oss)); 436 437 total_len = len; 438 while (len) { 439 size_t to_copy = MIN(len, hw->size_emul - hw->pos_emul); 440 memcpy(hw->buf_emul + hw->pos_emul, buf, to_copy); 441 442 hw->pos_emul = (hw->pos_emul + to_copy) % hw->size_emul; 443 buf += to_copy; 444 len -= to_copy; 445 } 446 return total_len; 447 } 448 449 pos = 0; 450 while (len) { 451 ssize_t bytes_written; 452 void *pcm = advance(buf, pos); 453 454 bytes_written = write(oss->fd, pcm, len); 455 if (bytes_written < 0) { 456 if (errno != EAGAIN) { 457 oss_logerr(errno, "failed to write %zu bytes\n", 458 len); 459 } 460 return pos; 461 } 462 463 pos += bytes_written; 464 if (bytes_written < len) { 465 break; 466 } 467 len -= bytes_written; 468 } 469 return pos; 470 } 471 472 static void oss_fini_out (HWVoiceOut *hw) 473 { 474 int err; 475 OSSVoiceOut *oss = (OSSVoiceOut *) hw; 476 477 ldebug ("oss_fini\n"); 478 oss_anal_close (&oss->fd); 479 480 if (oss->mmapped && hw->buf_emul) { 481 err = munmap(hw->buf_emul, hw->size_emul); 482 if (err) { 483 oss_logerr(errno, "Failed to unmap buffer %p, size %zu\n", 484 hw->buf_emul, hw->size_emul); 485 } 486 hw->buf_emul = NULL; 487 } 488 } 489 490 static int oss_init_out(HWVoiceOut *hw, struct audsettings *as, 491 void *drv_opaque) 492 { 493 OSSVoiceOut *oss = (OSSVoiceOut *) hw; 494 struct oss_params req, obt; 495 int endianness; 496 int err; 497 int fd; 498 AudioFormat effective_fmt; 499 struct audsettings obt_as; 500 Audiodev *dev = drv_opaque; 501 AudiodevOssOptions *oopts = &dev->u.oss; 502 503 oss->fd = -1; 504 505 req.fmt = aud_to_ossfmt (as->fmt, as->endianness); 506 req.freq = as->freq; 507 req.nchannels = as->nchannels; 508 509 if (oss_open(0, &req, as, &obt, &fd, dev)) { 510 return -1; 511 } 512 513 err = oss_to_audfmt (obt.fmt, &effective_fmt, &endianness); 514 if (err) { 515 oss_anal_close (&fd); 516 return -1; 517 } 518 519 obt_as.freq = obt.freq; 520 obt_as.nchannels = obt.nchannels; 521 obt_as.fmt = effective_fmt; 522 obt_as.endianness = endianness; 523 524 audio_pcm_init_info (&hw->info, &obt_as); 525 oss->nfrags = obt.nfrags; 526 oss->fragsize = obt.fragsize; 527 528 if (obt.nfrags * obt.fragsize % hw->info.bytes_per_frame) { 529 dolog ("warning: Misaligned DAC buffer, size %d, alignment %d\n", 530 obt.nfrags * obt.fragsize, hw->info.bytes_per_frame); 531 } 532 533 hw->samples = (obt.nfrags * obt.fragsize) / hw->info.bytes_per_frame; 534 535 oss->mmapped = 0; 536 if (oopts->has_try_mmap && oopts->try_mmap) { 537 hw->size_emul = hw->samples * hw->info.bytes_per_frame; 538 hw->buf_emul = mmap( 539 NULL, 540 hw->size_emul, 541 PROT_READ | PROT_WRITE, 542 MAP_SHARED, 543 fd, 544 0 545 ); 546 if (hw->buf_emul == MAP_FAILED) { 547 oss_logerr(errno, "Failed to map %zu bytes of DAC\n", 548 hw->size_emul); 549 hw->buf_emul = NULL; 550 } else { 551 int err; 552 int trig = 0; 553 if (ioctl (fd, SNDCTL_DSP_SETTRIGGER, &trig) < 0) { 554 oss_logerr (errno, "SNDCTL_DSP_SETTRIGGER 0 failed\n"); 555 } else { 556 trig = PCM_ENABLE_OUTPUT; 557 if (ioctl (fd, SNDCTL_DSP_SETTRIGGER, &trig) < 0) { 558 oss_logerr ( 559 errno, 560 "SNDCTL_DSP_SETTRIGGER PCM_ENABLE_OUTPUT failed\n" 561 ); 562 } else { 563 oss->mmapped = 1; 564 } 565 } 566 567 if (!oss->mmapped) { 568 err = munmap(hw->buf_emul, hw->size_emul); 569 if (err) { 570 oss_logerr(errno, "Failed to unmap buffer %p size %zu\n", 571 hw->buf_emul, hw->size_emul); 572 } 573 hw->buf_emul = NULL; 574 } 575 } 576 } 577 578 oss->fd = fd; 579 oss->dev = dev; 580 return 0; 581 } 582 583 static void oss_enable_out(HWVoiceOut *hw, bool enable) 584 { 585 int trig; 586 OSSVoiceOut *oss = (OSSVoiceOut *) hw; 587 AudiodevOssPerDirectionOptions *opdo = oss->dev->u.oss.out; 588 589 if (enable) { 590 hw->poll_mode = opdo->try_poll; 591 592 ldebug("enabling voice\n"); 593 if (hw->poll_mode) { 594 oss_poll_out(hw); 595 } 596 597 if (!oss->mmapped) { 598 return; 599 } 600 601 audio_pcm_info_clear_buf(&hw->info, hw->buf_emul, hw->samples); 602 trig = PCM_ENABLE_OUTPUT; 603 if (ioctl(oss->fd, SNDCTL_DSP_SETTRIGGER, &trig) < 0) { 604 oss_logerr(errno, 605 "SNDCTL_DSP_SETTRIGGER PCM_ENABLE_OUTPUT failed\n"); 606 return; 607 } 608 } else { 609 if (hw->poll_mode) { 610 qemu_set_fd_handler (oss->fd, NULL, NULL, NULL); 611 hw->poll_mode = 0; 612 } 613 614 if (!oss->mmapped) { 615 return; 616 } 617 618 ldebug ("disabling voice\n"); 619 trig = 0; 620 if (ioctl (oss->fd, SNDCTL_DSP_SETTRIGGER, &trig) < 0) { 621 oss_logerr (errno, "SNDCTL_DSP_SETTRIGGER 0 failed\n"); 622 return; 623 } 624 } 625 } 626 627 static int oss_init_in(HWVoiceIn *hw, struct audsettings *as, void *drv_opaque) 628 { 629 OSSVoiceIn *oss = (OSSVoiceIn *) hw; 630 struct oss_params req, obt; 631 int endianness; 632 int err; 633 int fd; 634 AudioFormat effective_fmt; 635 struct audsettings obt_as; 636 Audiodev *dev = drv_opaque; 637 638 oss->fd = -1; 639 640 req.fmt = aud_to_ossfmt (as->fmt, as->endianness); 641 req.freq = as->freq; 642 req.nchannels = as->nchannels; 643 if (oss_open(1, &req, as, &obt, &fd, dev)) { 644 return -1; 645 } 646 647 err = oss_to_audfmt (obt.fmt, &effective_fmt, &endianness); 648 if (err) { 649 oss_anal_close (&fd); 650 return -1; 651 } 652 653 obt_as.freq = obt.freq; 654 obt_as.nchannels = obt.nchannels; 655 obt_as.fmt = effective_fmt; 656 obt_as.endianness = endianness; 657 658 audio_pcm_init_info (&hw->info, &obt_as); 659 oss->nfrags = obt.nfrags; 660 oss->fragsize = obt.fragsize; 661 662 if (obt.nfrags * obt.fragsize % hw->info.bytes_per_frame) { 663 dolog ("warning: Misaligned ADC buffer, size %d, alignment %d\n", 664 obt.nfrags * obt.fragsize, hw->info.bytes_per_frame); 665 } 666 667 hw->samples = (obt.nfrags * obt.fragsize) / hw->info.bytes_per_frame; 668 669 oss->fd = fd; 670 oss->dev = dev; 671 return 0; 672 } 673 674 static void oss_fini_in (HWVoiceIn *hw) 675 { 676 OSSVoiceIn *oss = (OSSVoiceIn *) hw; 677 678 oss_anal_close (&oss->fd); 679 } 680 681 static size_t oss_read(HWVoiceIn *hw, void *buf, size_t len) 682 { 683 OSSVoiceIn *oss = (OSSVoiceIn *) hw; 684 size_t pos = 0; 685 686 while (len) { 687 ssize_t nread; 688 689 void *dst = advance(buf, pos); 690 nread = read(oss->fd, dst, len); 691 692 if (nread == -1) { 693 switch (errno) { 694 case EINTR: 695 case EAGAIN: 696 break; 697 default: 698 oss_logerr(errno, "Failed to read %zu bytes of audio (to %p)\n", 699 len, dst); 700 break; 701 } 702 break; 703 } 704 705 pos += nread; 706 len -= nread; 707 } 708 709 return pos; 710 } 711 712 static void oss_enable_in(HWVoiceIn *hw, bool enable) 713 { 714 OSSVoiceIn *oss = (OSSVoiceIn *) hw; 715 AudiodevOssPerDirectionOptions *opdo = oss->dev->u.oss.out; 716 717 if (enable) { 718 hw->poll_mode = opdo->try_poll; 719 720 if (hw->poll_mode) { 721 oss_poll_in(hw); 722 } 723 } else { 724 if (hw->poll_mode) { 725 qemu_set_fd_handler (oss->fd, NULL, NULL, NULL); 726 hw->poll_mode = 0; 727 } 728 } 729 } 730 731 static void oss_init_per_direction(AudiodevOssPerDirectionOptions *opdo) 732 { 733 if (!opdo->has_try_poll) { 734 opdo->try_poll = true; 735 opdo->has_try_poll = true; 736 } 737 } 738 739 static void *oss_audio_init(Audiodev *dev) 740 { 741 AudiodevOssOptions *oopts; 742 assert(dev->driver == AUDIODEV_DRIVER_OSS); 743 744 oopts = &dev->u.oss; 745 oss_init_per_direction(oopts->in); 746 oss_init_per_direction(oopts->out); 747 748 if (access(oopts->in->dev ?: "/dev/dsp", R_OK | W_OK) < 0 || 749 access(oopts->out->dev ?: "/dev/dsp", R_OK | W_OK) < 0) { 750 return NULL; 751 } 752 return dev; 753 } 754 755 static void oss_audio_fini (void *opaque) 756 { 757 } 758 759 static struct audio_pcm_ops oss_pcm_ops = { 760 .init_out = oss_init_out, 761 .fini_out = oss_fini_out, 762 .write = oss_write, 763 .buffer_get_free = oss_buffer_get_free, 764 .run_buffer_out = oss_run_buffer_out, 765 .get_buffer_out = oss_get_buffer_out, 766 .put_buffer_out = oss_put_buffer_out, 767 .enable_out = oss_enable_out, 768 769 .init_in = oss_init_in, 770 .fini_in = oss_fini_in, 771 .read = oss_read, 772 .run_buffer_in = audio_generic_run_buffer_in, 773 .enable_in = oss_enable_in 774 }; 775 776 static struct audio_driver oss_audio_driver = { 777 .name = "oss", 778 .descr = "OSS http://www.opensound.com", 779 .init = oss_audio_init, 780 .fini = oss_audio_fini, 781 .pcm_ops = &oss_pcm_ops, 782 .can_be_default = 1, 783 .max_voices_out = INT_MAX, 784 .max_voices_in = INT_MAX, 785 .voice_size_out = sizeof (OSSVoiceOut), 786 .voice_size_in = sizeof (OSSVoiceIn) 787 }; 788 789 static void register_audio_oss(void) 790 { 791 audio_driver_register(&oss_audio_driver); 792 } 793 type_init(register_audio_oss); 794