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_SPICE: 340 return dev->u.spice.TYPE; 341 case AUDIODEV_DRIVER_WAV: 342 return dev->u.wav.TYPE; 343 344 case AUDIODEV_DRIVER__MAX: 345 break; 346 } 347 abort(); 348 } 349 350 static HW *glue(audio_pcm_hw_add_, TYPE)(AudioState *s, struct audsettings *as) 351 { 352 HW *hw; 353 AudiodevPerDirectionOptions *pdo = glue(audio_get_pdo_, TYPE)(s->dev); 354 355 if (!pdo->mixing_engine || pdo->fixed_settings) { 356 hw = glue(audio_pcm_hw_add_new_, TYPE)(s, as); 357 if (!pdo->mixing_engine || hw) { 358 return hw; 359 } 360 } 361 362 hw = glue(audio_pcm_hw_find_specific_, TYPE)(s, NULL, as); 363 if (hw) { 364 return hw; 365 } 366 367 hw = glue(audio_pcm_hw_add_new_, TYPE)(s, as); 368 if (hw) { 369 return hw; 370 } 371 372 return glue(audio_pcm_hw_find_any_, TYPE)(s, NULL); 373 } 374 375 static SW *glue(audio_pcm_create_voice_pair_, TYPE)( 376 AudioState *s, 377 const char *sw_name, 378 struct audsettings *as 379 ) 380 { 381 SW *sw; 382 HW *hw; 383 struct audsettings hw_as; 384 AudiodevPerDirectionOptions *pdo = glue(audio_get_pdo_, TYPE)(s->dev); 385 386 if (pdo->fixed_settings) { 387 hw_as = audiodev_to_audsettings(pdo); 388 } else { 389 hw_as = *as; 390 } 391 392 sw = audio_calloc(__func__, 1, sizeof(*sw)); 393 if (!sw) { 394 dolog ("Could not allocate soft voice `%s' (%zu bytes)\n", 395 sw_name ? sw_name : "unknown", sizeof (*sw)); 396 goto err1; 397 } 398 sw->s = s; 399 400 hw = glue(audio_pcm_hw_add_, TYPE)(s, &hw_as); 401 if (!hw) { 402 goto err2; 403 } 404 405 glue (audio_pcm_hw_add_sw_, TYPE) (hw, sw); 406 407 if (glue (audio_pcm_sw_init_, TYPE) (sw, hw, sw_name, as)) { 408 goto err3; 409 } 410 411 return sw; 412 413 err3: 414 glue (audio_pcm_hw_del_sw_, TYPE) (sw); 415 glue (audio_pcm_hw_gc_, TYPE) (&hw); 416 err2: 417 g_free (sw); 418 err1: 419 return NULL; 420 } 421 422 static void glue (audio_close_, TYPE) (SW *sw) 423 { 424 glue (audio_pcm_sw_fini_, TYPE) (sw); 425 glue (audio_pcm_hw_del_sw_, TYPE) (sw); 426 glue (audio_pcm_hw_gc_, TYPE) (&sw->hw); 427 g_free (sw); 428 } 429 430 void glue (AUD_close_, TYPE) (QEMUSoundCard *card, SW *sw) 431 { 432 if (sw) { 433 if (audio_bug(__func__, !card)) { 434 dolog ("card=%p\n", card); 435 abort(); 436 } 437 438 glue (audio_close_, TYPE) (sw); 439 } 440 } 441 442 SW *glue (AUD_open_, TYPE) ( 443 QEMUSoundCard *card, 444 SW *sw, 445 const char *name, 446 void *callback_opaque , 447 audio_callback_fn callback_fn, 448 struct audsettings *as 449 ) 450 { 451 AudioState *s; 452 AudiodevPerDirectionOptions *pdo; 453 454 if (audio_bug(__func__, !card || !name || !callback_fn || !as)) { 455 dolog ("card=%p name=%p callback_fn=%p as=%p\n", 456 card, name, callback_fn, as); 457 abort(); 458 } 459 460 s = card->state; 461 pdo = glue(audio_get_pdo_, TYPE)(s->dev); 462 463 ldebug ("open %s, freq %d, nchannels %d, fmt %d\n", 464 name, as->freq, as->nchannels, as->fmt); 465 466 if (audio_bug(__func__, audio_validate_settings(as))) { 467 audio_print_settings (as); 468 abort(); 469 } 470 471 if (audio_bug(__func__, !s->drv)) { 472 dolog ("Can not open `%s' (no host audio driver)\n", name); 473 abort(); 474 } 475 476 if (sw && audio_pcm_info_eq (&sw->info, as)) { 477 return sw; 478 } 479 480 if (!pdo->fixed_settings && sw) { 481 glue (AUD_close_, TYPE) (card, sw); 482 sw = NULL; 483 } 484 485 if (sw) { 486 HW *hw = sw->hw; 487 488 if (!hw) { 489 dolog ("Internal logic error voice `%s' has no hardware store\n", 490 SW_NAME (sw)); 491 goto fail; 492 } 493 494 glue (audio_pcm_sw_fini_, TYPE) (sw); 495 if (glue (audio_pcm_sw_init_, TYPE) (sw, hw, name, as)) { 496 goto fail; 497 } 498 } else { 499 sw = glue(audio_pcm_create_voice_pair_, TYPE)(s, name, as); 500 if (!sw) { 501 dolog ("Failed to create voice `%s'\n", name); 502 return NULL; 503 } 504 } 505 506 sw->card = card; 507 sw->vol = nominal_volume; 508 sw->callback.fn = callback_fn; 509 sw->callback.opaque = callback_opaque; 510 511 #ifdef DEBUG_AUDIO 512 dolog ("%s\n", name); 513 audio_pcm_print_info ("hw", &sw->hw->info); 514 audio_pcm_print_info ("sw", &sw->info); 515 #endif 516 517 return sw; 518 519 fail: 520 glue (AUD_close_, TYPE) (card, sw); 521 return NULL; 522 } 523 524 int glue (AUD_is_active_, TYPE) (SW *sw) 525 { 526 return sw ? sw->active : 0; 527 } 528 529 void glue (AUD_init_time_stamp_, TYPE) (SW *sw, QEMUAudioTimeStamp *ts) 530 { 531 if (!sw) { 532 return; 533 } 534 535 ts->old_ts = sw->hw->ts_helper; 536 } 537 538 uint64_t glue (AUD_get_elapsed_usec_, TYPE) (SW *sw, QEMUAudioTimeStamp *ts) 539 { 540 uint64_t delta, cur_ts, old_ts; 541 542 if (!sw) { 543 return 0; 544 } 545 546 cur_ts = sw->hw->ts_helper; 547 old_ts = ts->old_ts; 548 /* dolog ("cur %" PRId64 " old %" PRId64 "\n", cur_ts, old_ts); */ 549 550 if (cur_ts >= old_ts) { 551 delta = cur_ts - old_ts; 552 } else { 553 delta = UINT64_MAX - old_ts + cur_ts; 554 } 555 556 if (!delta) { 557 return 0; 558 } 559 560 return muldiv64 (delta, sw->hw->info.freq, 1000000); 561 } 562 563 #undef TYPE 564 #undef HW 565 #undef SW 566 #undef HWBUF 567 #undef NAME 568