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) (struct audio_driver *drv) 40 { 41 AudioState *s = &glob_audio_state; 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 } 51 else { 52 dolog ("Driver `%s' does not support %d " NAME " voices, max %d\n", 53 drv->name, 54 glue (s->nb_hw_voices_, TYPE), 55 max_voices); 56 } 57 glue (s->nb_hw_voices_, TYPE) = max_voices; 58 } 59 60 if (audio_bug (AUDIO_FUNC, !voice_size && max_voices)) { 61 dolog ("drv=`%s' voice_size=0 max_voices=%d\n", 62 drv->name, max_voices); 63 glue (s->nb_hw_voices_, TYPE) = 0; 64 } 65 66 if (audio_bug (AUDIO_FUNC, voice_size && !max_voices)) { 67 dolog ("drv=`%s' voice_size=%d max_voices=0\n", 68 drv->name, voice_size); 69 } 70 } 71 72 static void glue (audio_pcm_hw_free_resources_, TYPE) (HW *hw) 73 { 74 if (HWBUF) { 75 g_free (HWBUF); 76 } 77 78 HWBUF = NULL; 79 } 80 81 static int glue (audio_pcm_hw_alloc_resources_, TYPE) (HW *hw) 82 { 83 HWBUF = audio_calloc (AUDIO_FUNC, hw->samples, sizeof (struct st_sample)); 84 if (!HWBUF) { 85 dolog ("Could not allocate " NAME " buffer (%d samples)\n", 86 hw->samples); 87 return -1; 88 } 89 90 return 0; 91 } 92 93 static void glue (audio_pcm_sw_free_resources_, TYPE) (SW *sw) 94 { 95 if (sw->buf) { 96 g_free (sw->buf); 97 } 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 #ifdef DAC 112 samples = sw->hw->samples; 113 #else 114 samples = ((int64_t) sw->hw->samples << 32) / sw->ratio; 115 #endif 116 117 sw->buf = audio_calloc (AUDIO_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 #ifdef DAC 158 sw->conv = mixeng_conv 159 #else 160 sw->clip = mixeng_clip 161 #endif 162 [sw->info.nchannels == 2] 163 [sw->info.sign] 164 [sw->info.swap_endianness] 165 [audio_bits_to_index (sw->info.bits)]; 166 167 sw->name = g_strdup (name); 168 err = glue (audio_pcm_sw_alloc_resources_, TYPE) (sw); 169 if (err) { 170 g_free (sw->name); 171 sw->name = NULL; 172 } 173 return err; 174 } 175 176 static void glue (audio_pcm_sw_fini_, TYPE) (SW *sw) 177 { 178 glue (audio_pcm_sw_free_resources_, TYPE) (sw); 179 if (sw->name) { 180 g_free (sw->name); 181 sw->name = NULL; 182 } 183 } 184 185 static void glue (audio_pcm_hw_add_sw_, TYPE) (HW *hw, SW *sw) 186 { 187 QLIST_INSERT_HEAD (&hw->sw_head, sw, entries); 188 } 189 190 static void glue (audio_pcm_hw_del_sw_, TYPE) (SW *sw) 191 { 192 QLIST_REMOVE (sw, entries); 193 } 194 195 static void glue (audio_pcm_hw_gc_, TYPE) (HW **hwp) 196 { 197 AudioState *s = &glob_audio_state; 198 HW *hw = *hwp; 199 200 if (!hw->sw_head.lh_first) { 201 #ifdef DAC 202 audio_detach_capture (hw); 203 #endif 204 QLIST_REMOVE (hw, entries); 205 glue (s->nb_hw_voices_, TYPE) += 1; 206 glue (audio_pcm_hw_free_resources_ ,TYPE) (hw); 207 BEGIN_NOSIGALRM 208 glue (hw->pcm_ops->fini_, TYPE) (hw); 209 END_NOSIGALRM 210 g_free (hw); 211 *hwp = NULL; 212 } 213 } 214 215 static HW *glue (audio_pcm_hw_find_any_, TYPE) (HW *hw) 216 { 217 AudioState *s = &glob_audio_state; 218 return hw ? hw->entries.le_next : glue (s->hw_head_, TYPE).lh_first; 219 } 220 221 static HW *glue (audio_pcm_hw_find_any_enabled_, TYPE) (HW *hw) 222 { 223 while ((hw = glue (audio_pcm_hw_find_any_, TYPE) (hw))) { 224 if (hw->enabled) { 225 return hw; 226 } 227 } 228 return NULL; 229 } 230 231 static HW *glue (audio_pcm_hw_find_specific_, TYPE) ( 232 HW *hw, 233 struct audsettings *as 234 ) 235 { 236 while ((hw = glue (audio_pcm_hw_find_any_, TYPE) (hw))) { 237 if (audio_pcm_info_eq (&hw->info, as)) { 238 return hw; 239 } 240 } 241 return NULL; 242 } 243 244 static HW *glue (audio_pcm_hw_add_new_, TYPE) (struct audsettings *as) 245 { 246 HW *hw; 247 AudioState *s = &glob_audio_state; 248 struct audio_driver *drv = s->drv; 249 int err; 250 251 if (!glue (s->nb_hw_voices_, TYPE)) { 252 return NULL; 253 } 254 255 if (audio_bug (AUDIO_FUNC, !drv)) { 256 dolog ("No host audio driver\n"); 257 return NULL; 258 } 259 260 if (audio_bug (AUDIO_FUNC, !drv->pcm_ops)) { 261 dolog ("Host audio driver without pcm_ops\n"); 262 return NULL; 263 } 264 265 hw = audio_calloc (AUDIO_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->pcm_ops = drv->pcm_ops; 273 QLIST_INIT (&hw->sw_head); 274 #ifdef DAC 275 QLIST_INIT (&hw->cap_head); 276 #endif 277 BEGIN_NOSIGALRM 278 err = glue (hw->pcm_ops->init_, TYPE) (hw, as); 279 END_NOSIGALRM 280 if (err) 281 goto err0; 282 283 if (audio_bug (AUDIO_FUNC, hw->samples <= 0)) { 284 dolog ("hw->samples=%d\n", hw->samples); 285 goto err1; 286 } 287 288 #ifdef DAC 289 hw->clip = mixeng_clip 290 #else 291 hw->conv = mixeng_conv 292 #endif 293 [hw->info.nchannels == 2] 294 [hw->info.sign] 295 [hw->info.swap_endianness] 296 [audio_bits_to_index (hw->info.bits)]; 297 298 if (glue (audio_pcm_hw_alloc_resources_, TYPE) (hw)) { 299 goto err1; 300 } 301 302 QLIST_INSERT_HEAD (&s->glue (hw_head_, TYPE), hw, entries); 303 glue (s->nb_hw_voices_, TYPE) -= 1; 304 #ifdef DAC 305 audio_attach_capture (hw); 306 #endif 307 return hw; 308 309 err1: 310 BEGIN_NOSIGALRM 311 glue (hw->pcm_ops->fini_, TYPE) (hw); 312 END_NOSIGALRM 313 err0: 314 g_free (hw); 315 return NULL; 316 } 317 318 static HW *glue (audio_pcm_hw_add_, TYPE) (struct audsettings *as) 319 { 320 HW *hw; 321 322 if (glue (conf.fixed_, TYPE).enabled && glue (conf.fixed_, TYPE).greedy) { 323 hw = glue (audio_pcm_hw_add_new_, TYPE) (as); 324 if (hw) { 325 return hw; 326 } 327 } 328 329 hw = glue (audio_pcm_hw_find_specific_, TYPE) (NULL, as); 330 if (hw) { 331 return hw; 332 } 333 334 hw = glue (audio_pcm_hw_add_new_, TYPE) (as); 335 if (hw) { 336 return hw; 337 } 338 339 return glue (audio_pcm_hw_find_any_, TYPE) (NULL); 340 } 341 342 static SW *glue (audio_pcm_create_voice_pair_, TYPE) ( 343 const char *sw_name, 344 struct audsettings *as 345 ) 346 { 347 SW *sw; 348 HW *hw; 349 struct audsettings hw_as; 350 351 if (glue (conf.fixed_, TYPE).enabled) { 352 hw_as = glue (conf.fixed_, TYPE).settings; 353 } 354 else { 355 hw_as = *as; 356 } 357 358 sw = audio_calloc (AUDIO_FUNC, 1, sizeof (*sw)); 359 if (!sw) { 360 dolog ("Could not allocate soft voice `%s' (%zu bytes)\n", 361 sw_name ? sw_name : "unknown", sizeof (*sw)); 362 goto err1; 363 } 364 365 hw = glue (audio_pcm_hw_add_, TYPE) (&hw_as); 366 if (!hw) { 367 goto err2; 368 } 369 370 glue (audio_pcm_hw_add_sw_, TYPE) (hw, sw); 371 372 if (glue (audio_pcm_sw_init_, TYPE) (sw, hw, sw_name, as)) { 373 goto err3; 374 } 375 376 return sw; 377 378 err3: 379 glue (audio_pcm_hw_del_sw_, TYPE) (sw); 380 glue (audio_pcm_hw_gc_, TYPE) (&hw); 381 err2: 382 g_free (sw); 383 err1: 384 return NULL; 385 } 386 387 static void glue (audio_close_, TYPE) (SW *sw) 388 { 389 glue (audio_pcm_sw_fini_, TYPE) (sw); 390 glue (audio_pcm_hw_del_sw_, TYPE) (sw); 391 glue (audio_pcm_hw_gc_, TYPE) (&sw->hw); 392 g_free (sw); 393 } 394 395 void glue (AUD_close_, TYPE) (QEMUSoundCard *card, SW *sw) 396 { 397 if (sw) { 398 if (audio_bug (AUDIO_FUNC, !card)) { 399 dolog ("card=%p\n", card); 400 return; 401 } 402 403 glue (audio_close_, TYPE) (sw); 404 } 405 } 406 407 SW *glue (AUD_open_, TYPE) ( 408 QEMUSoundCard *card, 409 SW *sw, 410 const char *name, 411 void *callback_opaque , 412 audio_callback_fn callback_fn, 413 struct audsettings *as 414 ) 415 { 416 AudioState *s = &glob_audio_state; 417 #ifdef DAC 418 int live = 0; 419 SW *old_sw = NULL; 420 #endif 421 422 ldebug ("open %s, freq %d, nchannels %d, fmt %d\n", 423 name, as->freq, as->nchannels, as->fmt); 424 425 if (audio_bug (AUDIO_FUNC, !card || !name || !callback_fn || !as)) { 426 dolog ("card=%p name=%p callback_fn=%p as=%p\n", 427 card, name, callback_fn, as); 428 goto fail; 429 } 430 431 if (audio_bug (AUDIO_FUNC, audio_validate_settings (as))) { 432 audio_print_settings (as); 433 goto fail; 434 } 435 436 if (audio_bug (AUDIO_FUNC, !s->drv)) { 437 dolog ("Can not open `%s' (no host audio driver)\n", name); 438 goto fail; 439 } 440 441 if (sw && audio_pcm_info_eq (&sw->info, as)) { 442 return sw; 443 } 444 445 #ifdef DAC 446 if (conf.plive && sw && (!sw->active && !sw->empty)) { 447 live = sw->total_hw_samples_mixed; 448 449 #ifdef DEBUG_PLIVE 450 dolog ("Replacing voice %s with %d live samples\n", SW_NAME (sw), live); 451 dolog ("Old %s freq %d, bits %d, channels %d\n", 452 SW_NAME (sw), sw->info.freq, sw->info.bits, sw->info.nchannels); 453 dolog ("New %s freq %d, bits %d, channels %d\n", 454 name, 455 as->freq, 456 (as->fmt == AUD_FMT_S16 || as->fmt == AUD_FMT_U16) ? 16 : 8, 457 as->nchannels); 458 #endif 459 460 if (live) { 461 old_sw = sw; 462 old_sw->callback.fn = NULL; 463 sw = NULL; 464 } 465 } 466 #endif 467 468 if (!glue (conf.fixed_, TYPE).enabled && sw) { 469 glue (AUD_close_, TYPE) (card, sw); 470 sw = NULL; 471 } 472 473 if (sw) { 474 HW *hw = sw->hw; 475 476 if (!hw) { 477 dolog ("Internal logic error voice `%s' has no hardware store\n", 478 SW_NAME (sw)); 479 goto fail; 480 } 481 482 glue (audio_pcm_sw_fini_, TYPE) (sw); 483 if (glue (audio_pcm_sw_init_, TYPE) (sw, hw, name, as)) { 484 goto fail; 485 } 486 } 487 else { 488 sw = glue (audio_pcm_create_voice_pair_, TYPE) (name, as); 489 if (!sw) { 490 dolog ("Failed to create voice `%s'\n", name); 491 return NULL; 492 } 493 } 494 495 sw->card = card; 496 sw->vol = nominal_volume; 497 sw->callback.fn = callback_fn; 498 sw->callback.opaque = callback_opaque; 499 #ifdef DAC 500 sw->empty = 1; 501 #endif 502 503 #ifdef DAC 504 if (live) { 505 int mixed = 506 (live << old_sw->info.shift) 507 * old_sw->info.bytes_per_second 508 / sw->info.bytes_per_second; 509 510 #ifdef DEBUG_PLIVE 511 dolog ("Silence will be mixed %d\n", mixed); 512 #endif 513 sw->total_hw_samples_mixed += mixed; 514 } 515 #endif 516 517 #ifdef DEBUG_AUDIO 518 dolog ("%s\n", name); 519 audio_pcm_print_info ("hw", &sw->hw->info); 520 audio_pcm_print_info ("sw", &sw->info); 521 #endif 522 523 return sw; 524 525 fail: 526 glue (AUD_close_, TYPE) (card, sw); 527 return NULL; 528 } 529 530 int glue (AUD_is_active_, TYPE) (SW *sw) 531 { 532 return sw ? sw->active : 0; 533 } 534 535 void glue (AUD_init_time_stamp_, TYPE) (SW *sw, QEMUAudioTimeStamp *ts) 536 { 537 if (!sw) { 538 return; 539 } 540 541 ts->old_ts = sw->hw->ts_helper; 542 } 543 544 uint64_t glue (AUD_get_elapsed_usec_, TYPE) (SW *sw, QEMUAudioTimeStamp *ts) 545 { 546 uint64_t delta, cur_ts, old_ts; 547 548 if (!sw) { 549 return 0; 550 } 551 552 cur_ts = sw->hw->ts_helper; 553 old_ts = ts->old_ts; 554 /* dolog ("cur %" PRId64 " old %" PRId64 "\n", cur_ts, old_ts); */ 555 556 if (cur_ts >= old_ts) { 557 delta = cur_ts - old_ts; 558 } 559 else { 560 delta = UINT64_MAX - old_ts + cur_ts; 561 } 562 563 if (!delta) { 564 return 0; 565 } 566 567 return muldiv64 (delta, sw->hw->info.freq, 1000000); 568 } 569 570 #undef TYPE 571 #undef HW 572 #undef SW 573 #undef HWBUF 574 #undef NAME 575