1 /* 2 * QEMU ESD audio driver 3 * 4 * Copyright (c) 2008-2009 The Android Open Source Project 5 * Copyright (c) 2006 Frederick Reeve (brushed up by malc) 6 * 7 * Permission is hereby granted, free of charge, to any person obtaining a copy 8 * of this software and associated documentation files (the "Software"), to deal 9 * in the Software without restriction, including without limitation the rights 10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 11 * copies of the Software, and to permit persons to whom the Software is 12 * furnished to do so, subject to the following conditions: 13 * 14 * The above copyright notice and this permission notice shall be included in 15 * all copies or substantial portions of the Software. 16 * 17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 23 * THE SOFTWARE. 24 */ 25 #include <esd.h> 26 #include "qemu-common.h" 27 #include "audio.h" 28 29 #define AUDIO_CAP "esd" 30 #include "audio_int.h" 31 #include "audio_pt_int.h" 32 33 #include "android/qemu-debug.h" 34 35 #define DEBUG 1 36 37 #if DEBUG 38 # include <stdio.h> 39 # define D(...) VERBOSE_PRINT(audio,__VA_ARGS__) 40 # define D_ACTIVE VERBOSE_CHECK(audio) 41 # define O(...) VERBOSE_PRINT(audioout,__VA_ARGS__) 42 # define I(...) VERBOSE_PRINT(audioin,__VA_ARGS__) 43 #else 44 # define D(...) ((void)0) 45 # define D_ACTIVE 0 46 # define O(...) ((void)0) 47 # define I(...) ((void)0) 48 #endif 49 50 #define STRINGIFY_(x) #x 51 #define STRINGIFY(x) STRINGIFY_(x) 52 53 #include <dlfcn.h> 54 /* link dynamically to the libesd.so */ 55 56 #define DYNLINK_FUNCTIONS \ 57 DYNLINK_FUNC(int,esd_play_stream,(esd_format_t,int,const char*,const char*)) \ 58 DYNLINK_FUNC(int,esd_record_stream,(esd_format_t,int,const char*,const char*)) \ 59 DYNLINK_FUNC(int,esd_open_sound,( const char *host )) \ 60 DYNLINK_FUNC(int,esd_close,(int)) \ 61 62 #define DYNLINK_FUNCTIONS_INIT \ 63 esd_dynlink_init 64 65 #include "android/dynlink.h" 66 67 static void* esd_lib; 68 69 70 typedef struct { 71 HWVoiceOut hw; 72 int done; 73 int live; 74 int decr; 75 int rpos; 76 void *pcm_buf; 77 int fd; 78 struct audio_pt pt; 79 } ESDVoiceOut; 80 81 typedef struct { 82 HWVoiceIn hw; 83 int done; 84 int dead; 85 int incr; 86 int wpos; 87 void *pcm_buf; 88 int fd; 89 struct audio_pt pt; 90 } ESDVoiceIn; 91 92 static struct { 93 int samples; 94 int divisor; 95 char *dac_host; 96 char *adc_host; 97 } conf = { 98 .samples = 1024, 99 .divisor = 2, 100 }; 101 102 static void GCC_FMT_ATTR (2, 3) qesd_logerr (int err, const char *fmt, ...) 103 { 104 va_list ap; 105 106 va_start (ap, fmt); 107 AUD_vlog (AUDIO_CAP, fmt, ap); 108 va_end (ap); 109 110 AUD_log (AUDIO_CAP, "Reason: %s\n", strerror (err)); 111 } 112 113 /* playback */ 114 static void *qesd_thread_out (void *arg) 115 { 116 ESDVoiceOut *esd = arg; 117 HWVoiceOut *hw = &esd->hw; 118 int threshold; 119 120 threshold = conf.divisor ? hw->samples / conf.divisor : 0; 121 122 if (audio_pt_lock (&esd->pt, AUDIO_FUNC)) { 123 return NULL; 124 } 125 126 for (;;) { 127 int decr, to_mix, rpos; 128 129 for (;;) { 130 if (esd->done) { 131 goto exit; 132 } 133 134 if (esd->live > threshold) { 135 break; 136 } 137 138 if (audio_pt_wait (&esd->pt, AUDIO_FUNC)) { 139 goto exit; 140 } 141 } 142 143 decr = to_mix = esd->live; 144 rpos = hw->rpos; 145 146 if (audio_pt_unlock (&esd->pt, AUDIO_FUNC)) { 147 return NULL; 148 } 149 150 while (to_mix) { 151 ssize_t written; 152 int chunk = audio_MIN (to_mix, hw->samples - rpos); 153 struct st_sample *src = hw->mix_buf + rpos; 154 155 hw->clip (esd->pcm_buf, src, chunk); 156 157 again: 158 written = write (esd->fd, esd->pcm_buf, chunk << hw->info.shift); 159 if (written == -1) { 160 if (errno == EINTR || errno == EAGAIN) { 161 goto again; 162 } 163 qesd_logerr (errno, "write failed\n"); 164 return NULL; 165 } 166 167 if (written != chunk << hw->info.shift) { 168 int wsamples = written >> hw->info.shift; 169 int wbytes = wsamples << hw->info.shift; 170 if (wbytes != written) { 171 dolog ("warning: Misaligned write %d (requested %zd), " 172 "alignment %d\n", 173 wbytes, written, hw->info.align + 1); 174 } 175 to_mix -= wsamples; 176 rpos = (rpos + wsamples) % hw->samples; 177 break; 178 } 179 180 rpos = (rpos + chunk) % hw->samples; 181 to_mix -= chunk; 182 } 183 184 if (audio_pt_lock (&esd->pt, AUDIO_FUNC)) { 185 return NULL; 186 } 187 188 esd->rpos = rpos; 189 esd->live -= decr; 190 esd->decr += decr; 191 } 192 193 exit: 194 audio_pt_unlock (&esd->pt, AUDIO_FUNC); 195 return NULL; 196 } 197 198 static int qesd_run_out (HWVoiceOut *hw, int live) 199 { 200 int decr; 201 ESDVoiceOut *esd = (ESDVoiceOut *) hw; 202 203 if (audio_pt_lock (&esd->pt, AUDIO_FUNC)) { 204 return 0; 205 } 206 207 decr = audio_MIN (live, esd->decr); 208 esd->decr -= decr; 209 esd->live = live - decr; 210 hw->rpos = esd->rpos; 211 if (esd->live > 0) { 212 audio_pt_unlock_and_signal (&esd->pt, AUDIO_FUNC); 213 } 214 else { 215 audio_pt_unlock (&esd->pt, AUDIO_FUNC); 216 } 217 return decr; 218 } 219 220 static int qesd_write (SWVoiceOut *sw, void *buf, int len) 221 { 222 return audio_pcm_sw_write (sw, buf, len); 223 } 224 225 static int qesd_init_out (HWVoiceOut *hw, struct audsettings *as) 226 { 227 ESDVoiceOut *esd = (ESDVoiceOut *) hw; 228 struct audsettings obt_as = *as; 229 int esdfmt = ESD_STREAM | ESD_PLAY; 230 231 esdfmt |= (as->nchannels == 2) ? ESD_STEREO : ESD_MONO; 232 switch (as->fmt) { 233 case AUD_FMT_S8: 234 case AUD_FMT_U8: 235 esdfmt |= ESD_BITS8; 236 obt_as.fmt = AUD_FMT_U8; 237 break; 238 239 case AUD_FMT_S32: 240 case AUD_FMT_U32: 241 dolog ("Will use 16 instead of 32 bit samples\n"); 242 243 case AUD_FMT_S16: 244 case AUD_FMT_U16: 245 deffmt: 246 esdfmt |= ESD_BITS16; 247 obt_as.fmt = AUD_FMT_S16; 248 break; 249 250 default: 251 dolog ("Internal logic error: Bad audio format %d\n", as->fmt); 252 goto deffmt; 253 254 } 255 obt_as.endianness = AUDIO_HOST_ENDIANNESS; 256 257 audio_pcm_init_info (&hw->info, &obt_as); 258 259 hw->samples = conf.samples; 260 esd->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift); 261 if (!esd->pcm_buf) { 262 dolog ("Could not allocate buffer (%d bytes)\n", 263 hw->samples << hw->info.shift); 264 return -1; 265 } 266 267 esd->fd = FF(esd_play_stream) (esdfmt, as->freq, conf.dac_host, NULL); 268 if (esd->fd < 0) { 269 qesd_logerr (errno, "esd_play_stream failed\n"); 270 goto fail1; 271 } 272 273 if (audio_pt_init (&esd->pt, qesd_thread_out, esd, AUDIO_CAP, AUDIO_FUNC)) { 274 goto fail2; 275 } 276 277 return 0; 278 279 fail2: 280 if (close (esd->fd)) { 281 qesd_logerr (errno, "%s: close on esd socket(%d) failed\n", 282 AUDIO_FUNC, esd->fd); 283 } 284 esd->fd = -1; 285 286 fail1: 287 g_free (esd->pcm_buf); 288 esd->pcm_buf = NULL; 289 return -1; 290 } 291 292 static void qesd_fini_out (HWVoiceOut *hw) 293 { 294 void *ret; 295 ESDVoiceOut *esd = (ESDVoiceOut *) hw; 296 297 audio_pt_lock (&esd->pt, AUDIO_FUNC); 298 esd->done = 1; 299 audio_pt_unlock_and_signal (&esd->pt, AUDIO_FUNC); 300 audio_pt_join (&esd->pt, &ret, AUDIO_FUNC); 301 302 if (esd->fd >= 0) { 303 if (close (esd->fd)) { 304 qesd_logerr (errno, "failed to close esd socket\n"); 305 } 306 esd->fd = -1; 307 } 308 309 audio_pt_fini (&esd->pt, AUDIO_FUNC); 310 311 g_free (esd->pcm_buf); 312 esd->pcm_buf = NULL; 313 } 314 315 static int qesd_ctl_out (HWVoiceOut *hw, int cmd, ...) 316 { 317 (void) hw; 318 (void) cmd; 319 return 0; 320 } 321 322 /* capture */ 323 static void *qesd_thread_in (void *arg) 324 { 325 ESDVoiceIn *esd = arg; 326 HWVoiceIn *hw = &esd->hw; 327 int threshold; 328 329 threshold = conf.divisor ? hw->samples / conf.divisor : 0; 330 331 if (audio_pt_lock (&esd->pt, AUDIO_FUNC)) { 332 return NULL; 333 } 334 335 for (;;) { 336 int incr, to_grab, wpos; 337 338 for (;;) { 339 if (esd->done) { 340 goto exit; 341 } 342 343 if (esd->dead > threshold) { 344 break; 345 } 346 347 if (audio_pt_wait (&esd->pt, AUDIO_FUNC)) { 348 goto exit; 349 } 350 } 351 352 incr = to_grab = esd->dead; 353 wpos = hw->wpos; 354 355 if (audio_pt_unlock (&esd->pt, AUDIO_FUNC)) { 356 return NULL; 357 } 358 359 while (to_grab) { 360 ssize_t nread; 361 int chunk = audio_MIN (to_grab, hw->samples - wpos); 362 void *buf = advance (esd->pcm_buf, wpos); 363 364 again: 365 nread = read (esd->fd, buf, chunk << hw->info.shift); 366 if (nread == -1) { 367 if (errno == EINTR || errno == EAGAIN) { 368 goto again; 369 } 370 qesd_logerr (errno, "read failed\n"); 371 return NULL; 372 } 373 374 if (nread != chunk << hw->info.shift) { 375 int rsamples = nread >> hw->info.shift; 376 int rbytes = rsamples << hw->info.shift; 377 if (rbytes != nread) { 378 dolog ("warning: Misaligned write %d (requested %zd), " 379 "alignment %d\n", 380 rbytes, nread, hw->info.align + 1); 381 } 382 to_grab -= rsamples; 383 wpos = (wpos + rsamples) % hw->samples; 384 break; 385 } 386 387 hw->conv (hw->conv_buf + wpos, buf, nread >> hw->info.shift, 388 &nominal_volume); 389 wpos = (wpos + chunk) % hw->samples; 390 to_grab -= chunk; 391 } 392 393 if (audio_pt_lock (&esd->pt, AUDIO_FUNC)) { 394 return NULL; 395 } 396 397 esd->wpos = wpos; 398 esd->dead -= incr; 399 esd->incr += incr; 400 } 401 402 exit: 403 audio_pt_unlock (&esd->pt, AUDIO_FUNC); 404 return NULL; 405 } 406 407 static int qesd_run_in (HWVoiceIn *hw) 408 { 409 int live, incr, dead; 410 ESDVoiceIn *esd = (ESDVoiceIn *) hw; 411 412 if (audio_pt_lock (&esd->pt, AUDIO_FUNC)) { 413 return 0; 414 } 415 416 live = audio_pcm_hw_get_live_in (hw); 417 dead = hw->samples - live; 418 incr = audio_MIN (dead, esd->incr); 419 esd->incr -= incr; 420 esd->dead = dead - incr; 421 hw->wpos = esd->wpos; 422 if (esd->dead > 0) { 423 audio_pt_unlock_and_signal (&esd->pt, AUDIO_FUNC); 424 } 425 else { 426 audio_pt_unlock (&esd->pt, AUDIO_FUNC); 427 } 428 return incr; 429 } 430 431 static int qesd_read (SWVoiceIn *sw, void *buf, int len) 432 { 433 return audio_pcm_sw_read (sw, buf, len); 434 } 435 436 static int qesd_init_in (HWVoiceIn *hw, struct audsettings *as) 437 { 438 ESDVoiceIn *esd = (ESDVoiceIn *) hw; 439 struct audsettings obt_as = *as; 440 int esdfmt = ESD_STREAM | ESD_RECORD; 441 442 esdfmt |= (as->nchannels == 2) ? ESD_STEREO : ESD_MONO; 443 switch (as->fmt) { 444 case AUD_FMT_S8: 445 case AUD_FMT_U8: 446 esdfmt |= ESD_BITS8; 447 obt_as.fmt = AUD_FMT_U8; 448 break; 449 450 case AUD_FMT_S16: 451 case AUD_FMT_U16: 452 esdfmt |= ESD_BITS16; 453 obt_as.fmt = AUD_FMT_S16; 454 break; 455 456 case AUD_FMT_S32: 457 case AUD_FMT_U32: 458 dolog ("Will use 16 instead of 32 bit samples\n"); 459 esdfmt |= ESD_BITS16; 460 obt_as.fmt = AUD_FMT_S16; 461 break; 462 } 463 obt_as.endianness = AUDIO_HOST_ENDIANNESS; 464 465 audio_pcm_init_info (&hw->info, &obt_as); 466 467 hw->samples = conf.samples; 468 esd->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift); 469 if (!esd->pcm_buf) { 470 dolog ("Could not allocate buffer (%d bytes)\n", 471 hw->samples << hw->info.shift); 472 return -1; 473 } 474 475 esd->fd = FF(esd_record_stream) (esdfmt, as->freq, conf.adc_host, NULL); 476 if (esd->fd < 0) { 477 qesd_logerr (errno, "esd_record_stream failed\n"); 478 goto fail1; 479 } 480 481 if (audio_pt_init (&esd->pt, qesd_thread_in, esd, AUDIO_CAP, AUDIO_FUNC)) { 482 goto fail2; 483 } 484 485 return 0; 486 487 fail2: 488 if (close (esd->fd)) { 489 qesd_logerr (errno, "%s: close on esd socket(%d) failed\n", 490 AUDIO_FUNC, esd->fd); 491 } 492 esd->fd = -1; 493 494 fail1: 495 g_free (esd->pcm_buf); 496 esd->pcm_buf = NULL; 497 return -1; 498 } 499 500 static void qesd_fini_in (HWVoiceIn *hw) 501 { 502 void *ret; 503 ESDVoiceIn *esd = (ESDVoiceIn *) hw; 504 505 audio_pt_lock (&esd->pt, AUDIO_FUNC); 506 esd->done = 1; 507 audio_pt_unlock_and_signal (&esd->pt, AUDIO_FUNC); 508 audio_pt_join (&esd->pt, &ret, AUDIO_FUNC); 509 510 if (esd->fd >= 0) { 511 if (close (esd->fd)) { 512 qesd_logerr (errno, "failed to close esd socket\n"); 513 } 514 esd->fd = -1; 515 } 516 517 audio_pt_fini (&esd->pt, AUDIO_FUNC); 518 519 g_free (esd->pcm_buf); 520 esd->pcm_buf = NULL; 521 } 522 523 static int qesd_ctl_in (HWVoiceIn *hw, int cmd, ...) 524 { 525 (void) hw; 526 (void) cmd; 527 return 0; 528 } 529 530 /* common */ 531 static void *qesd_audio_init (void) 532 { 533 void* result = NULL; 534 535 D("%s: entering", __FUNCTION__); 536 537 if (esd_lib == NULL) { 538 int fd; 539 540 esd_lib = dlopen( "libesd.so", RTLD_NOW ); 541 if (esd_lib == NULL) 542 esd_lib = dlopen( "libesd.so.0", RTLD_NOW ); 543 544 if (esd_lib == NULL) { 545 D("could not find libesd on this system"); 546 goto Exit; 547 } 548 549 if (esd_dynlink_init(esd_lib) < 0) 550 goto Fail; 551 552 fd = FF(esd_open_sound)(conf.dac_host); 553 if (fd < 0) { 554 D("%s: could not open direct sound server connection, trying localhost", 555 __FUNCTION__); 556 fd = FF(esd_open_sound)("localhost"); 557 if (fd < 0) { 558 D("%s: could not open localhost sound server connection", __FUNCTION__); 559 goto Fail; 560 } 561 } 562 563 D("%s: EsounD server connection succeeded", __FUNCTION__); 564 /* FF(esd_close)(fd); */ 565 } 566 result = &conf; 567 goto Exit; 568 569 Fail: 570 D("%s: failed to open library", __FUNCTION__); 571 dlclose(esd_lib); 572 esd_lib = NULL; 573 574 Exit: 575 return result; 576 } 577 578 static void qesd_audio_fini (void *opaque) 579 { 580 (void) opaque; 581 if (esd_lib != NULL) { 582 dlclose(esd_lib); 583 esd_lib = NULL; 584 } 585 ldebug ("esd_fini"); 586 } 587 588 struct audio_option qesd_options[] = { 589 { 590 .name = "SAMPLES", 591 .tag = AUD_OPT_INT, 592 .valp = &conf.samples, 593 .descr = "buffer size in samples" 594 }, 595 { 596 .name = "DIVISOR", 597 .tag = AUD_OPT_INT, 598 .valp = &conf.divisor, 599 .descr = "threshold divisor" 600 }, 601 { 602 .name = "DAC_HOST", 603 .tag = AUD_OPT_STR, 604 .valp = &conf.dac_host, 605 .descr = "playback host" 606 }, 607 { 608 .name = "ADC_HOST", 609 .tag = AUD_OPT_STR, 610 .valp = &conf.adc_host, 611 .descr = "capture host" 612 }, 613 { /* End of list */ } 614 }; 615 616 static struct audio_pcm_ops qesd_pcm_ops = { 617 .init_out = qesd_init_out, 618 .fini_out = qesd_fini_out, 619 .run_out = qesd_run_out, 620 .write = qesd_write, 621 .ctl_out = qesd_ctl_out, 622 623 .init_in = qesd_init_in, 624 .fini_in = qesd_fini_in, 625 .run_in = qesd_run_in, 626 .read = qesd_read, 627 .ctl_in = qesd_ctl_in, 628 }; 629 630 struct audio_driver esd_audio_driver = { 631 .name = "esd", 632 .descr = "http://en.wikipedia.org/wiki/Esound", 633 .options = qesd_options, 634 .init = qesd_audio_init, 635 .fini = qesd_audio_fini, 636 .pcm_ops = &qesd_pcm_ops, 637 .can_be_default = 0, 638 .max_voices_out = INT_MAX, 639 .max_voices_in = INT_MAX, 640 .voice_size_out = sizeof (ESDVoiceOut), 641 .voice_size_in = sizeof (ESDVoiceIn) 642 }; 643
