1 /* 2 * QEMU Audio subsystem header 3 * 4 * Copyright (c) 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 #ifdef DAC 26 #define NAME "playback" 27 #define HWBUF hw->mix_buf 28 #define TYPE out 29 #define HW HWVoiceOut 30 #define SW SWVoiceOut 31 #else 32 #define NAME "capture" 33 #define TYPE in 34 #define HW HWVoiceIn 35 #define SW SWVoiceIn 36 #define HWBUF hw->conv_buf 37 #endif 38 39 static void glue(audio_init_nb_voices_, TYPE)(AudioState *s, 40 struct audio_driver *drv) 41 { 42 int max_voices = glue (drv->max_voices_, TYPE); 43 int voice_size = glue (drv->voice_size_, TYPE); 44 45 if (glue (s->nb_hw_voices_, TYPE) > max_voices) { 46 if (!max_voices) { 47 #ifdef DAC 48 dolog ("Driver `%s' does not support " NAME "\n", drv->name); 49 #endif 50 } else { 51 dolog ("Driver `%s' does not support %d " NAME " voices, max %d\n", 52 drv->name, 53 glue (s->nb_hw_voices_, TYPE), 54 max_voices); 55 } 56 glue (s->nb_hw_voices_, TYPE) = max_voices; 57 } 58 59 if (audio_bug(__func__, !voice_size && max_voices)) { 60 dolog ("drv=`%s' voice_size=0 max_voices=%d\n", 61 drv->name, max_voices); 62 abort(); 63 } 64 65 if (audio_bug(__func__, voice_size && !max_voices)) { 66 dolog ("drv=`%s' voice_size=%d max_voices=0\n", 67 drv->name, voice_size); 68 abort(); 69 } 70 } 71 72 static void glue (audio_pcm_hw_free_resources_, TYPE) (HW *hw) 73 { 74 g_free(hw->buf_emul); 75 g_free (HWBUF); 76 HWBUF = NULL; 77 } 78 79 static void glue(audio_pcm_hw_alloc_resources_, TYPE)(HW *hw) 80 { 81 if (glue(audio_get_pdo_, TYPE)(hw->s->dev)->mixing_engine) { 82 size_t samples = hw->samples; 83 if (audio_bug(__func__, samples == 0)) { 84 dolog("Attempted to allocate empty buffer\n"); 85 abort(); 86 } 87 88 HWBUF = g_malloc0(sizeof(STSampleBuffer) + sizeof(st_sample) * samples); 89 HWBUF->size = samples; 90 } else { 91 HWBUF = NULL; 92 } 93 } 94 95 static void glue (audio_pcm_sw_free_resources_, TYPE) (SW *sw) 96 { 97 g_free (sw->buf); 98 99 if (sw->rate) { 100 st_rate_stop (sw->rate); 101 } 102 103 sw->buf = NULL; 104 sw->rate = NULL; 105 } 106 107 static int glue (audio_pcm_sw_alloc_resources_, TYPE) (SW *sw) 108 { 109 int samples; 110 111 if (!glue(audio_get_pdo_, TYPE)(sw->s->dev)->mixing_engine) { 112 return 0; 113 } 114 115 samples = ((int64_t) sw->HWBUF->size << 32) / sw->ratio; 116 117 sw->buf = audio_calloc(__func__, samples, sizeof(struct st_sample)); 118 if (!sw->buf) { 119 dolog ("Could not allocate buffer for `%s' (%d samples)\n", 120 SW_NAME (sw), samples); 121 return -1; 122 } 123 124 #ifdef DAC 125 sw->rate = st_rate_start (sw->info.freq, sw->hw->info.freq); 126 #else 127 sw->rate = st_rate_start (sw->hw->info.freq, sw->info.freq); 128 #endif 129 if (!sw->rate) { 130 g_free (sw->buf); 131 sw->buf = NULL; 132 return -1; 133 } 134 return 0; 135 } 136 137 static int glue (audio_pcm_sw_init_, TYPE) ( 138 SW *sw, 139 HW *hw, 140 const char *name, 141 struct audsettings *as 142 ) 143 { 144 int err; 145 146 audio_pcm_init_info (&sw->info, as); 147 sw->hw = hw; 148 sw->active = 0; 149 #ifdef DAC 150 sw->ratio = ((int64_t) sw->hw->info.freq << 32) / sw->info.freq; 151 sw->total_hw_samples_mixed = 0; 152 sw->empty = 1; 153 #else 154 sw->ratio = ((int64_t) sw->info.freq << 32) / sw->hw->info.freq; 155 #endif 156 157 if (sw->info.is_float) { 158 #ifdef DAC 159 sw->conv = mixeng_conv_float[sw->info.nchannels == 2]; 160 #else 161 sw->clip = mixeng_clip_float[sw->info.nchannels == 2]; 162 #endif 163 } else { 164 #ifdef DAC 165 sw->conv = mixeng_conv 166 #else 167 sw->clip = mixeng_clip 168 #endif 169 [sw->info.nchannels == 2] 170 [sw->info.is_signed] 171 [sw->info.swap_endianness] 172 [audio_bits_to_index(sw->info.bits)]; 173 } 174 175 sw->name = g_strdup (name); 176 err = glue (audio_pcm_sw_alloc_resources_, TYPE) (sw); 177 if (err) { 178 g_free (sw->name); 179 sw->name = NULL; 180 } 181 return err; 182 } 183 184 static void glue (audio_pcm_sw_fini_, TYPE) (SW *sw) 185 { 186 glue (audio_pcm_sw_free_resources_, TYPE) (sw); 187 g_free (sw->name); 188 sw->name = NULL; 189 } 190 191 static void glue (audio_pcm_hw_add_sw_, TYPE) (HW *hw, SW *sw) 192 { 193 QLIST_INSERT_HEAD (&hw->sw_head, sw, entries); 194 } 195 196 static void glue (audio_pcm_hw_del_sw_, TYPE) (SW *sw) 197 { 198 QLIST_REMOVE (sw, entries); 199 } 200 201 static void glue (audio_pcm_hw_gc_, TYPE) (HW **hwp) 202 { 203 HW *hw = *hwp; 204 AudioState *s = hw->s; 205 206 if (!hw->sw_head.lh_first) { 207 #ifdef DAC 208 audio_detach_capture(hw); 209 #endif 210 QLIST_REMOVE(hw, entries); 211 glue(hw->pcm_ops->fini_, TYPE) (hw); 212 glue(s->nb_hw_voices_, TYPE) += 1; 213 glue(audio_pcm_hw_free_resources_ , TYPE) (hw); 214 g_free(hw); 215 *hwp = NULL; 216 } 217 } 218 219 static HW *glue(audio_pcm_hw_find_any_, TYPE)(AudioState *s, HW *hw) 220 { 221 return hw ? hw->entries.le_next : glue (s->hw_head_, TYPE).lh_first; 222 } 223 224 static HW *glue(audio_pcm_hw_find_any_enabled_, TYPE)(AudioState *s, HW *hw) 225 { 226 while ((hw = glue(audio_pcm_hw_find_any_, TYPE)(s, hw))) { 227 if (hw->enabled) { 228 return hw; 229 } 230 } 231 return NULL; 232 } 233 234 static HW *glue(audio_pcm_hw_find_specific_, TYPE)(AudioState *s, HW *hw, 235 struct audsettings *as) 236 { 237 while ((hw = glue(audio_pcm_hw_find_any_, TYPE)(s, hw))) { 238 if (audio_pcm_info_eq (&hw->info, as)) { 239 return hw; 240 } 241 } 242 return NULL; 243 } 244 245 static HW *glue(audio_pcm_hw_add_new_, TYPE)(AudioState *s, 246 struct audsettings *as) 247 { 248 HW *hw; 249 struct audio_driver *drv = s->drv; 250 251 if (!glue (s->nb_hw_voices_, TYPE)) { 252 return NULL; 253 } 254 255 if (audio_bug(__func__, !drv)) { 256 dolog ("No host audio driver\n"); 257 abort(); 258 } 259 260 if (audio_bug(__func__, !drv->pcm_ops)) { 261 dolog ("Host audio driver without pcm_ops\n"); 262 abort(); 263 } 264 265 hw = audio_calloc(__func__, 1, glue(drv->voice_size_, TYPE)); 266 if (!hw) { 267 dolog ("Can not allocate voice `%s' size %d\n", 268 drv->name, glue (drv->voice_size_, TYPE)); 269 return NULL; 270 } 271 272 hw->s = s; 273 hw->pcm_ops = drv->pcm_ops; 274 275 QLIST_INIT (&hw->sw_head); 276 #ifdef DAC 277 QLIST_INIT (&hw->cap_head); 278 #endif 279 if (glue (hw->pcm_ops->init_, TYPE) (hw, as, s->drv_opaque)) { 280 g_free(hw); 281 return NULL; 282 } 283 284 if (audio_bug(__func__, hw->samples <= 0)) { 285 dolog("hw->samples=%zd\n", hw->samples); 286 abort(); 287 } 288 289 if (hw->info.is_float) { 290 #ifdef DAC 291 hw->clip = mixeng_clip_float[hw->info.nchannels == 2]; 292 #else 293 hw->conv = mixeng_conv_float[hw->info.nchannels == 2]; 294 #endif 295 } else { 296 #ifdef DAC 297 hw->clip = mixeng_clip 298 #else 299 hw->conv = mixeng_conv 300 #endif 301 [hw->info.nchannels == 2] 302 [hw->info.is_signed] 303 [hw->info.swap_endianness] 304 [audio_bits_to_index(hw->info.bits)]; 305 } 306 307 glue(audio_pcm_hw_alloc_resources_, TYPE)(hw); 308 309 QLIST_INSERT_HEAD (&s->glue (hw_head_, TYPE), hw, entries); 310 glue (s->nb_hw_voices_, TYPE) -= 1; 311 #ifdef DAC 312 audio_attach_capture (hw); 313 #endif 314 return hw; 315 } 316 317 AudiodevPerDirectionOptions *glue(audio_get_pdo_, TYPE)(Audiodev *dev) 318 { 319 switch (dev->driver) { 320 case AUDIODEV_DRIVER_NONE: 321 return dev->u.none.TYPE; 322 case AUDIODEV_DRIVER_ALSA: 323 return qapi_AudiodevAlsaPerDirectionOptions_base(dev->u.alsa.TYPE); 324 case AUDIODEV_DRIVER_COREAUDIO: 325 return qapi_AudiodevCoreaudioPerDirectionOptions_base( 326 dev->u.coreaudio.TYPE); 327 case AUDIODEV_DRIVER_DBUS: 328 return dev->u.dbus.TYPE; 329 case AUDIODEV_DRIVER_DSOUND: 330 return dev->u.dsound.TYPE; 331 case AUDIODEV_DRIVER_JACK: 332 return qapi_AudiodevJackPerDirectionOptions_base(dev->u.jack.TYPE); 333 case AUDIODEV_DRIVER_OSS: 334 return qapi_AudiodevOssPerDirectionOptions_base(dev->u.oss.TYPE); 335 case AUDIODEV_DRIVER_PA: 336 return qapi_AudiodevPaPerDirectionOptions_base(dev->u.pa.TYPE); 337 case AUDIODEV_DRIVER_SDL: 338 return qapi_AudiodevSdlPerDirectionOptions_base(dev->u.sdl.TYPE); 339 case AUDIODEV_DRIVER_SNDIO: 340 return dev->u.sndio.TYPE; 341 case AUDIODEV_DRIVER_SPICE: 342 return dev->u.spice.TYPE; 343 case AUDIODEV_DRIVER_WAV: 344 return dev->u.wav.TYPE; 345 346 case AUDIODEV_DRIVER__MAX: 347 break; 348 } 349 abort(); 350 } 351 352 static HW *glue(audio_pcm_hw_add_, TYPE)(AudioState *s, struct audsettings *as) 353 { 354 HW *hw; 355 AudiodevPerDirectionOptions *pdo = glue(audio_get_pdo_, TYPE)(s->dev); 356 357 if (!pdo->mixing_engine || pdo->fixed_settings) { 358 hw = glue(audio_pcm_hw_add_new_, TYPE)(s, as); 359 if (!pdo->mixing_engine || hw) { 360 return hw; 361 } 362 } 363 364 hw = glue(audio_pcm_hw_find_specific_, TYPE)(s, NULL, as); 365 if (hw) { 366 return hw; 367 } 368 369 hw = glue(audio_pcm_hw_add_new_, TYPE)(s, as); 370 if (hw) { 371 return hw; 372 } 373 374 return glue(audio_pcm_hw_find_any_, TYPE)(s, NULL); 375 } 376 377 static SW *glue(audio_pcm_create_voice_pair_, TYPE)( 378 AudioState *s, 379 const char *sw_name, 380 struct audsettings *as 381 ) 382 { 383 SW *sw; 384 HW *hw; 385 struct audsettings hw_as; 386 AudiodevPerDirectionOptions *pdo = glue(audio_get_pdo_, TYPE)(s->dev); 387 388 if (pdo->fixed_settings) { 389 hw_as = audiodev_to_audsettings(pdo); 390 } else { 391 hw_as = *as; 392 } 393 394 sw = audio_calloc(__func__, 1, sizeof(*sw)); 395 if (!sw) { 396 dolog ("Could not allocate soft voice `%s' (%zu bytes)\n", 397 sw_name ? sw_name : "unknown", sizeof (*sw)); 398 goto err1; 399 } 400 sw->s = s; 401 402 hw = glue(audio_pcm_hw_add_, TYPE)(s, &hw_as); 403 if (!hw) { 404 goto err2; 405 } 406 407 glue (audio_pcm_hw_add_sw_, TYPE) (hw, sw); 408 409 if (glue (audio_pcm_sw_init_, TYPE) (sw, hw, sw_name, as)) { 410 goto err3; 411 } 412 413 return sw; 414 415 err3: 416 glue (audio_pcm_hw_del_sw_, TYPE) (sw); 417 glue (audio_pcm_hw_gc_, TYPE) (&hw); 418 err2: 419 g_free (sw); 420 err1: 421 return NULL; 422 } 423 424 static void glue (audio_close_, TYPE) (SW *sw) 425 { 426 glue (audio_pcm_sw_fini_, TYPE) (sw); 427 glue (audio_pcm_hw_del_sw_, TYPE) (sw); 428 glue (audio_pcm_hw_gc_, TYPE) (&sw->hw); 429 g_free (sw); 430 } 431 432 void glue (AUD_close_, TYPE) (QEMUSoundCard *card, SW *sw) 433 { 434 if (sw) { 435 if (audio_bug(__func__, !card)) { 436 dolog ("card=%p\n", card); 437 abort(); 438 } 439 440 glue (audio_close_, TYPE) (sw); 441 } 442 } 443 444 SW *glue (AUD_open_, TYPE) ( 445 QEMUSoundCard *card, 446 SW *sw, 447 const char *name, 448 void *callback_opaque , 449 audio_callback_fn callback_fn, 450 struct audsettings *as 451 ) 452 { 453 AudioState *s; 454 AudiodevPerDirectionOptions *pdo; 455 456 if (audio_bug(__func__, !card || !name || !callback_fn || !as)) { 457 dolog ("card=%p name=%p callback_fn=%p as=%p\n", 458 card, name, callback_fn, as); 459 abort(); 460 } 461 462 s = card->state; 463 pdo = glue(audio_get_pdo_, TYPE)(s->dev); 464 465 ldebug ("open %s, freq %d, nchannels %d, fmt %d\n", 466 name, as->freq, as->nchannels, as->fmt); 467 468 if (audio_bug(__func__, audio_validate_settings(as))) { 469 audio_print_settings (as); 470 abort(); 471 } 472 473 if (audio_bug(__func__, !s->drv)) { 474 dolog ("Can not open `%s' (no host audio driver)\n", name); 475 abort(); 476 } 477 478 if (sw && audio_pcm_info_eq (&sw->info, as)) { 479 return sw; 480 } 481 482 if (!pdo->fixed_settings && sw) { 483 glue (AUD_close_, TYPE) (card, sw); 484 sw = NULL; 485 } 486 487 if (sw) { 488 HW *hw = sw->hw; 489 490 if (!hw) { 491 dolog ("Internal logic error voice `%s' has no hardware store\n", 492 SW_NAME (sw)); 493 goto fail; 494 } 495 496 glue (audio_pcm_sw_fini_, TYPE) (sw); 497 if (glue (audio_pcm_sw_init_, TYPE) (sw, hw, name, as)) { 498 goto fail; 499 } 500 } else { 501 sw = glue(audio_pcm_create_voice_pair_, TYPE)(s, name, as); 502 if (!sw) { 503 dolog ("Failed to create voice `%s'\n", name); 504 return NULL; 505 } 506 } 507 508 sw->card = card; 509 sw->vol = nominal_volume; 510 sw->callback.fn = callback_fn; 511 sw->callback.opaque = callback_opaque; 512 513 #ifdef DEBUG_AUDIO 514 dolog ("%s\n", name); 515 audio_pcm_print_info ("hw", &sw->hw->info); 516 audio_pcm_print_info ("sw", &sw->info); 517 #endif 518 519 return sw; 520 521 fail: 522 glue (AUD_close_, TYPE) (card, sw); 523 return NULL; 524 } 525 526 int glue (AUD_is_active_, TYPE) (SW *sw) 527 { 528 return sw ? sw->active : 0; 529 } 530 531 void glue (AUD_init_time_stamp_, TYPE) (SW *sw, QEMUAudioTimeStamp *ts) 532 { 533 if (!sw) { 534 return; 535 } 536 537 ts->old_ts = sw->hw->ts_helper; 538 } 539 540 uint64_t glue (AUD_get_elapsed_usec_, TYPE) (SW *sw, QEMUAudioTimeStamp *ts) 541 { 542 uint64_t delta, cur_ts, old_ts; 543 544 if (!sw) { 545 return 0; 546 } 547 548 cur_ts = sw->hw->ts_helper; 549 old_ts = ts->old_ts; 550 /* dolog ("cur %" PRId64 " old %" PRId64 "\n", cur_ts, old_ts); */ 551 552 if (cur_ts >= old_ts) { 553 delta = cur_ts - old_ts; 554 } else { 555 delta = UINT64_MAX - old_ts + cur_ts; 556 } 557 558 if (!delta) { 559 return 0; 560 } 561 562 return muldiv64 (delta, sw->hw->info.freq, 1000000); 563 } 564 565 #undef TYPE 566 #undef HW 567 #undef SW 568 #undef HWBUF 569 #undef NAME 570