![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to audio.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / audio|
Return to audio.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / audio |
1.1 ! root 1: /* ! 2: * QEMU Audio subsystem ! 3: * ! 4: * Copyright (c) 2003-2004 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: #include <assert.h> ! 25: #include "vl.h" ! 26: ! 27: #define USE_WAV_AUDIO ! 28: ! 29: #include "audio/audio_int.h" ! 30: ! 31: #define dolog(...) AUD_log ("audio", __VA_ARGS__) ! 32: #ifdef DEBUG ! 33: #define ldebug(...) dolog (__VA_ARGS__) ! 34: #else ! 35: #define ldebug(...) ! 36: #endif ! 37: ! 38: #define QC_AUDIO_DRV "QEMU_AUDIO_DRV" ! 39: #define QC_VOICES "QEMU_VOICES" ! 40: #define QC_FIXED_FORMAT "QEMU_FIXED_FORMAT" ! 41: #define QC_FIXED_FREQ "QEMU_FIXED_FREQ" ! 42: ! 43: static HWVoice *hw_voices; ! 44: ! 45: AudioState audio_state = { ! 46: 1, /* use fixed settings */ ! 47: 44100, /* fixed frequency */ ! 48: 2, /* fixed channels */ ! 49: AUD_FMT_S16, /* fixed format */ ! 50: 1, /* number of hw voices */ ! 51: -1 /* voice size */ ! 52: }; ! 53: ! 54: /* http://www.df.lth.se/~john_e/gems/gem002d.html */ ! 55: /* http://www.multi-platforms.com/Tips/PopCount.htm */ ! 56: uint32_t popcount (uint32_t u) ! 57: { ! 58: u = ((u&0x55555555) + ((u>>1)&0x55555555)); ! 59: u = ((u&0x33333333) + ((u>>2)&0x33333333)); ! 60: u = ((u&0x0f0f0f0f) + ((u>>4)&0x0f0f0f0f)); ! 61: u = ((u&0x00ff00ff) + ((u>>8)&0x00ff00ff)); ! 62: u = ( u&0x0000ffff) + (u>>16); ! 63: return u; ! 64: } ! 65: ! 66: inline uint32_t lsbindex (uint32_t u) ! 67: { ! 68: return popcount ((u&-u)-1); ! 69: } ! 70: ! 71: int audio_get_conf_int (const char *key, int defval) ! 72: { ! 73: int val = defval; ! 74: char *strval; ! 75: ! 76: strval = getenv (key); ! 77: if (strval) { ! 78: val = atoi (strval); ! 79: } ! 80: ! 81: return val; ! 82: } ! 83: ! 84: const char *audio_get_conf_str (const char *key, const char *defval) ! 85: { ! 86: const char *val = getenv (key); ! 87: if (!val) ! 88: return defval; ! 89: else ! 90: return val; ! 91: } ! 92: ! 93: void AUD_log (const char *cap, const char *fmt, ...) ! 94: { ! 95: va_list ap; ! 96: fprintf (stderr, "%s: ", cap); ! 97: va_start (ap, fmt); ! 98: vfprintf (stderr, fmt, ap); ! 99: va_end (ap); ! 100: } ! 101: ! 102: /* ! 103: * Soft Voice ! 104: */ ! 105: void pcm_sw_free_resources (SWVoice *sw) ! 106: { ! 107: if (sw->buf) qemu_free (sw->buf); ! 108: if (sw->rate) st_rate_stop (sw->rate); ! 109: sw->buf = NULL; ! 110: sw->rate = NULL; ! 111: } ! 112: ! 113: int pcm_sw_alloc_resources (SWVoice *sw) ! 114: { ! 115: sw->buf = qemu_mallocz (sw->hw->samples * sizeof (st_sample_t)); ! 116: if (!sw->buf) ! 117: return -1; ! 118: ! 119: sw->rate = st_rate_start (sw->freq, sw->hw->freq); ! 120: if (!sw->rate) { ! 121: qemu_free (sw->buf); ! 122: sw->buf = NULL; ! 123: return -1; ! 124: } ! 125: return 0; ! 126: } ! 127: ! 128: void pcm_sw_fini (SWVoice *sw) ! 129: { ! 130: pcm_sw_free_resources (sw); ! 131: } ! 132: ! 133: int pcm_sw_init (SWVoice *sw, HWVoice *hw, int freq, ! 134: int nchannels, audfmt_e fmt) ! 135: { ! 136: int bits = 8, sign = 0; ! 137: ! 138: switch (fmt) { ! 139: case AUD_FMT_S8: ! 140: sign = 1; ! 141: case AUD_FMT_U8: ! 142: break; ! 143: ! 144: case AUD_FMT_S16: ! 145: sign = 1; ! 146: case AUD_FMT_U16: ! 147: bits = 16; ! 148: break; ! 149: } ! 150: ! 151: sw->hw = hw; ! 152: sw->freq = freq; ! 153: sw->fmt = fmt; ! 154: sw->nchannels = nchannels; ! 155: sw->shift = (nchannels == 2) + (bits == 16); ! 156: sw->align = (1 << sw->shift) - 1; ! 157: sw->left = 0; ! 158: sw->pos = 0; ! 159: sw->wpos = 0; ! 160: sw->live = 0; ! 161: sw->ratio = (sw->hw->freq * ((int64_t) INT_MAX)) / sw->freq; ! 162: sw->bytes_per_second = sw->freq << sw->shift; ! 163: sw->conv = mixeng_conv[nchannels == 2][sign][bits == 16]; ! 164: ! 165: pcm_sw_free_resources (sw); ! 166: return pcm_sw_alloc_resources (sw); ! 167: } ! 168: ! 169: /* Hard voice */ ! 170: void pcm_hw_free_resources (HWVoice *hw) ! 171: { ! 172: if (hw->mix_buf) ! 173: qemu_free (hw->mix_buf); ! 174: hw->mix_buf = NULL; ! 175: } ! 176: ! 177: int pcm_hw_alloc_resources (HWVoice *hw) ! 178: { ! 179: hw->mix_buf = qemu_mallocz (hw->samples * sizeof (st_sample_t)); ! 180: if (!hw->mix_buf) ! 181: return -1; ! 182: return 0; ! 183: } ! 184: ! 185: void pcm_hw_fini (HWVoice *hw) ! 186: { ! 187: if (hw->active) { ! 188: ldebug ("pcm_hw_fini: %d %d %d\n", hw->freq, hw->nchannels, hw->fmt); ! 189: pcm_hw_free_resources (hw); ! 190: hw->pcm_ops->fini (hw); ! 191: memset (hw, 0, audio_state.drv->voice_size); ! 192: } ! 193: } ! 194: ! 195: void pcm_hw_gc (HWVoice *hw) ! 196: { ! 197: if (hw->nb_voices) ! 198: return; ! 199: ! 200: pcm_hw_fini (hw); ! 201: } ! 202: ! 203: int pcm_hw_get_live (HWVoice *hw) ! 204: { ! 205: int i, alive = 0, live = hw->samples; ! 206: ! 207: for (i = 0; i < hw->nb_voices; i++) { ! 208: if (hw->pvoice[i]->live) { ! 209: live = audio_MIN (hw->pvoice[i]->live, live); ! 210: alive += 1; ! 211: } ! 212: } ! 213: ! 214: if (alive) ! 215: return live; ! 216: else ! 217: return -1; ! 218: } ! 219: ! 220: int pcm_hw_get_live2 (HWVoice *hw, int *nb_active) ! 221: { ! 222: int i, alive = 0, live = hw->samples; ! 223: ! 224: *nb_active = 0; ! 225: for (i = 0; i < hw->nb_voices; i++) { ! 226: if (hw->pvoice[i]->live) { ! 227: if (hw->pvoice[i]->live < live) { ! 228: *nb_active = hw->pvoice[i]->active != 0; ! 229: live = hw->pvoice[i]->live; ! 230: } ! 231: alive += 1; ! 232: } ! 233: } ! 234: ! 235: if (alive) ! 236: return live; ! 237: else ! 238: return -1; ! 239: } ! 240: ! 241: void pcm_hw_dec_live (HWVoice *hw, int decr) ! 242: { ! 243: int i; ! 244: ! 245: for (i = 0; i < hw->nb_voices; i++) { ! 246: if (hw->pvoice[i]->live) { ! 247: hw->pvoice[i]->live -= decr; ! 248: } ! 249: } ! 250: } ! 251: ! 252: void pcm_hw_clear (HWVoice *hw, void *buf, int len) ! 253: { ! 254: if (!len) ! 255: return; ! 256: ! 257: switch (hw->fmt) { ! 258: case AUD_FMT_S16: ! 259: case AUD_FMT_S8: ! 260: memset (buf, len << hw->shift, 0x00); ! 261: break; ! 262: ! 263: case AUD_FMT_U8: ! 264: memset (buf, len << hw->shift, 0x80); ! 265: break; ! 266: ! 267: case AUD_FMT_U16: ! 268: { ! 269: unsigned int i; ! 270: uint16_t *p = buf; ! 271: int shift = hw->nchannels - 1; ! 272: ! 273: for (i = 0; i < len << shift; i++) { ! 274: p[i] = INT16_MAX; ! 275: } ! 276: } ! 277: break; ! 278: } ! 279: } ! 280: ! 281: int pcm_hw_write (SWVoice *sw, void *buf, int size) ! 282: { ! 283: int hwsamples, samples, isamp, osamp, wpos, live, dead, left, swlim, blck; ! 284: int ret = 0, pos = 0; ! 285: if (!sw) ! 286: return size; ! 287: ! 288: hwsamples = sw->hw->samples; ! 289: samples = size >> sw->shift; ! 290: ! 291: if (!sw->live) { ! 292: sw->wpos = sw->hw->rpos; ! 293: } ! 294: wpos = sw->wpos; ! 295: live = sw->live; ! 296: dead = hwsamples - live; ! 297: swlim = (dead * ((int64_t) INT_MAX)) / sw->ratio; ! 298: swlim = audio_MIN (swlim, samples); ! 299: ! 300: ldebug ("size=%d live=%d dead=%d swlim=%d wpos=%d\n", ! 301: size, live, dead, swlim, wpos); ! 302: if (swlim) ! 303: sw->conv (sw->buf, buf, swlim); ! 304: ! 305: while (swlim) { ! 306: dead = hwsamples - live; ! 307: left = hwsamples - wpos; ! 308: blck = audio_MIN (dead, left); ! 309: if (!blck) { ! 310: /* dolog ("swlim=%d\n", swlim); */ ! 311: break; ! 312: } ! 313: isamp = swlim; ! 314: osamp = blck; ! 315: st_rate_flow (sw->rate, sw->buf + pos, sw->hw->mix_buf + wpos, &isamp, &osamp); ! 316: ret += isamp; ! 317: swlim -= isamp; ! 318: pos += isamp; ! 319: live += osamp; ! 320: wpos = (wpos + osamp) % hwsamples; ! 321: } ! 322: ! 323: sw->wpos = wpos; ! 324: sw->live = live; ! 325: return ret << sw->shift; ! 326: } ! 327: ! 328: int pcm_hw_init (HWVoice *hw, int freq, int nchannels, audfmt_e fmt) ! 329: { ! 330: int sign = 0, bits = 8; ! 331: ! 332: pcm_hw_fini (hw); ! 333: ldebug ("pcm_hw_init: %d %d %d\n", freq, nchannels, fmt); ! 334: if (hw->pcm_ops->init (hw, freq, nchannels, fmt)) { ! 335: memset (hw, 0, audio_state.drv->voice_size); ! 336: return -1; ! 337: } ! 338: ! 339: switch (hw->fmt) { ! 340: case AUD_FMT_S8: ! 341: sign = 1; ! 342: case AUD_FMT_U8: ! 343: break; ! 344: ! 345: case AUD_FMT_S16: ! 346: sign = 1; ! 347: case AUD_FMT_U16: ! 348: bits = 16; ! 349: break; ! 350: } ! 351: ! 352: hw->nb_voices = 0; ! 353: hw->active = 1; ! 354: hw->shift = (hw->nchannels == 2) + (bits == 16); ! 355: hw->bytes_per_second = hw->freq << hw->shift; ! 356: hw->align = (1 << hw->shift) - 1; ! 357: hw->samples = hw->bufsize >> hw->shift; ! 358: hw->clip = mixeng_clip[hw->nchannels == 2][sign][bits == 16]; ! 359: if (pcm_hw_alloc_resources (hw)) { ! 360: pcm_hw_fini (hw); ! 361: return -1; ! 362: } ! 363: return 0; ! 364: } ! 365: ! 366: static int dist (void *hw) ! 367: { ! 368: if (hw) { ! 369: return (((uint8_t *) hw - (uint8_t *) hw_voices) ! 370: / audio_state.drv->voice_size) + 1; ! 371: } ! 372: else { ! 373: return 0; ! 374: } ! 375: } ! 376: ! 377: #define ADVANCE(hw) \ ! 378: ((hw) ? advance (hw, audio_state.drv->voice_size) : hw_voices) ! 379: ! 380: HWVoice *pcm_hw_find_any (HWVoice *hw) ! 381: { ! 382: int i = dist (hw); ! 383: for (; i < audio_state.nb_hw_voices; i++) { ! 384: hw = ADVANCE (hw); ! 385: return hw; ! 386: } ! 387: return NULL; ! 388: } ! 389: ! 390: HWVoice *pcm_hw_find_any_active (HWVoice *hw) ! 391: { ! 392: int i = dist (hw); ! 393: for (; i < audio_state.nb_hw_voices; i++) { ! 394: hw = ADVANCE (hw); ! 395: if (hw->active) ! 396: return hw; ! 397: } ! 398: return NULL; ! 399: } ! 400: ! 401: HWVoice *pcm_hw_find_any_active_enabled (HWVoice *hw) ! 402: { ! 403: int i = dist (hw); ! 404: for (; i < audio_state.nb_hw_voices; i++) { ! 405: hw = ADVANCE (hw); ! 406: if (hw->active && hw->enabled) ! 407: return hw; ! 408: } ! 409: return NULL; ! 410: } ! 411: ! 412: HWVoice *pcm_hw_find_any_passive (HWVoice *hw) ! 413: { ! 414: int i = dist (hw); ! 415: for (; i < audio_state.nb_hw_voices; i++) { ! 416: hw = ADVANCE (hw); ! 417: if (!hw->active) ! 418: return hw; ! 419: } ! 420: return NULL; ! 421: } ! 422: ! 423: HWVoice *pcm_hw_find_specific (HWVoice *hw, int freq, ! 424: int nchannels, audfmt_e fmt) ! 425: { ! 426: while ((hw = pcm_hw_find_any_active (hw))) { ! 427: if (hw->freq == freq && ! 428: hw->nchannels == nchannels && ! 429: hw->fmt == fmt) ! 430: return hw; ! 431: } ! 432: return NULL; ! 433: } ! 434: ! 435: HWVoice *pcm_hw_add (int freq, int nchannels, audfmt_e fmt) ! 436: { ! 437: HWVoice *hw; ! 438: ! 439: if (audio_state.fixed_format) { ! 440: freq = audio_state.fixed_freq; ! 441: nchannels = audio_state.fixed_channels; ! 442: fmt = audio_state.fixed_fmt; ! 443: } ! 444: ! 445: hw = pcm_hw_find_specific (NULL, freq, nchannels, fmt); ! 446: ! 447: if (hw) ! 448: return hw; ! 449: ! 450: hw = pcm_hw_find_any_passive (NULL); ! 451: if (hw) { ! 452: hw->pcm_ops = audio_state.drv->pcm_ops; ! 453: if (!hw->pcm_ops) ! 454: return NULL; ! 455: ! 456: if (pcm_hw_init (hw, freq, nchannels, fmt)) { ! 457: pcm_hw_gc (hw); ! 458: return NULL; ! 459: } ! 460: else ! 461: return hw; ! 462: } ! 463: ! 464: return pcm_hw_find_any (NULL); ! 465: } ! 466: ! 467: int pcm_hw_add_sw (HWVoice *hw, SWVoice *sw) ! 468: { ! 469: SWVoice **pvoice = qemu_mallocz ((hw->nb_voices + 1) * sizeof (sw)); ! 470: if (!pvoice) ! 471: return -1; ! 472: ! 473: memcpy (pvoice, hw->pvoice, hw->nb_voices * sizeof (sw)); ! 474: qemu_free (hw->pvoice); ! 475: hw->pvoice = pvoice; ! 476: hw->pvoice[hw->nb_voices++] = sw; ! 477: return 0; ! 478: } ! 479: ! 480: int pcm_hw_del_sw (HWVoice *hw, SWVoice *sw) ! 481: { ! 482: int i, j; ! 483: if (hw->nb_voices > 1) { ! 484: SWVoice **pvoice = qemu_mallocz ((hw->nb_voices - 1) * sizeof (sw)); ! 485: ! 486: if (!pvoice) { ! 487: dolog ("Can not maintain consistent state (not enough memory)\n"); ! 488: return -1; ! 489: } ! 490: ! 491: for (i = 0, j = 0; i < hw->nb_voices; i++) { ! 492: if (j >= hw->nb_voices - 1) { ! 493: dolog ("Can not maintain consistent state " ! 494: "(invariant violated)\n"); ! 495: return -1; ! 496: } ! 497: if (hw->pvoice[i] != sw) ! 498: pvoice[j++] = hw->pvoice[i]; ! 499: } ! 500: qemu_free (hw->pvoice); ! 501: hw->pvoice = pvoice; ! 502: hw->nb_voices -= 1; ! 503: } ! 504: else { ! 505: qemu_free (hw->pvoice); ! 506: hw->pvoice = NULL; ! 507: hw->nb_voices = 0; ! 508: } ! 509: return 0; ! 510: } ! 511: ! 512: SWVoice *pcm_create_voice_pair (int freq, int nchannels, audfmt_e fmt) ! 513: { ! 514: SWVoice *sw; ! 515: HWVoice *hw; ! 516: ! 517: sw = qemu_mallocz (sizeof (*sw)); ! 518: if (!sw) ! 519: goto err1; ! 520: ! 521: hw = pcm_hw_add (freq, nchannels, fmt); ! 522: if (!hw) ! 523: goto err2; ! 524: ! 525: if (pcm_hw_add_sw (hw, sw)) ! 526: goto err3; ! 527: ! 528: if (pcm_sw_init (sw, hw, freq, nchannels, fmt)) ! 529: goto err4; ! 530: ! 531: return sw; ! 532: ! 533: err4: ! 534: pcm_hw_del_sw (hw, sw); ! 535: err3: ! 536: pcm_hw_gc (hw); ! 537: err2: ! 538: qemu_free (sw); ! 539: err1: ! 540: return NULL; ! 541: } ! 542: ! 543: SWVoice *AUD_open (SWVoice *sw, const char *name, ! 544: int freq, int nchannels, audfmt_e fmt) ! 545: { ! 546: if (!audio_state.drv) { ! 547: return NULL; ! 548: } ! 549: ! 550: if (sw && freq == sw->freq && sw->nchannels == nchannels && sw->fmt == fmt) { ! 551: return sw; ! 552: } ! 553: ! 554: if (sw) { ! 555: ldebug ("Different format %s %d %d %d\n", ! 556: name, ! 557: sw->freq == freq, ! 558: sw->nchannels == nchannels, ! 559: sw->fmt == fmt); ! 560: } ! 561: ! 562: if (nchannels != 1 && nchannels != 2) { ! 563: dolog ("Bogus channel count %d for voice %s\n", nchannels, name); ! 564: return NULL; ! 565: } ! 566: ! 567: if (!audio_state.fixed_format && sw) { ! 568: pcm_sw_fini (sw); ! 569: pcm_hw_del_sw (sw->hw, sw); ! 570: pcm_hw_gc (sw->hw); ! 571: if (sw->name) { ! 572: qemu_free (sw->name); ! 573: sw->name = NULL; ! 574: } ! 575: qemu_free (sw); ! 576: sw = NULL; ! 577: } ! 578: ! 579: if (sw) { ! 580: HWVoice *hw = sw->hw; ! 581: if (!hw) { ! 582: dolog ("Internal logic error voice %s has no hardware store\n", ! 583: name); ! 584: return sw; ! 585: } ! 586: ! 587: if (pcm_sw_init (sw, hw, freq, nchannels, fmt)) { ! 588: pcm_sw_fini (sw); ! 589: pcm_hw_del_sw (hw, sw); ! 590: pcm_hw_gc (hw); ! 591: if (sw->name) { ! 592: qemu_free (sw->name); ! 593: sw->name = NULL; ! 594: } ! 595: qemu_free (sw); ! 596: return NULL; ! 597: } ! 598: } ! 599: else { ! 600: sw = pcm_create_voice_pair (freq, nchannels, fmt); ! 601: if (!sw) { ! 602: dolog ("Failed to create voice %s\n", name); ! 603: return NULL; ! 604: } ! 605: } ! 606: ! 607: if (sw->name) { ! 608: qemu_free (sw->name); ! 609: sw->name = NULL; ! 610: } ! 611: sw->name = qemu_strdup (name); ! 612: return sw; ! 613: } ! 614: ! 615: void AUD_close (SWVoice *sw) ! 616: { ! 617: if (!sw) ! 618: return; ! 619: ! 620: pcm_sw_fini (sw); ! 621: pcm_hw_del_sw (sw->hw, sw); ! 622: pcm_hw_gc (sw->hw); ! 623: if (sw->name) { ! 624: qemu_free (sw->name); ! 625: sw->name = NULL; ! 626: } ! 627: qemu_free (sw); ! 628: } ! 629: ! 630: int AUD_write (SWVoice *sw, void *buf, int size) ! 631: { ! 632: int bytes; ! 633: ! 634: if (!sw->hw->enabled) ! 635: dolog ("Writing to disabled voice %s\n", sw->name); ! 636: bytes = sw->hw->pcm_ops->write (sw, buf, size); ! 637: return bytes; ! 638: } ! 639: ! 640: void AUD_run (void) ! 641: { ! 642: HWVoice *hw = NULL; ! 643: ! 644: while ((hw = pcm_hw_find_any_active_enabled (hw))) { ! 645: int i; ! 646: if (hw->pending_disable && pcm_hw_get_live (hw) <= 0) { ! 647: hw->enabled = 0; ! 648: hw->pcm_ops->ctl (hw, VOICE_DISABLE); ! 649: for (i = 0; i < hw->nb_voices; i++) { ! 650: hw->pvoice[i]->live = 0; ! 651: /* hw->pvoice[i]->old_ticks = 0; */ ! 652: } ! 653: continue; ! 654: } ! 655: ! 656: hw->pcm_ops->run (hw); ! 657: assert (hw->rpos < hw->samples); ! 658: for (i = 0; i < hw->nb_voices; i++) { ! 659: SWVoice *sw = hw->pvoice[i]; ! 660: if (!sw->active && !sw->live && sw->old_ticks) { ! 661: int64_t delta = qemu_get_clock (vm_clock) - sw->old_ticks; ! 662: if (delta > audio_state.ticks_threshold) { ! 663: ldebug ("resetting old_ticks for %s\n", sw->name); ! 664: sw->old_ticks = 0; ! 665: } ! 666: } ! 667: } ! 668: } ! 669: } ! 670: ! 671: int AUD_get_free (SWVoice *sw) ! 672: { ! 673: int free; ! 674: ! 675: if (!sw) ! 676: return 4096; ! 677: ! 678: free = ((sw->hw->samples - sw->live) << sw->hw->shift) * sw->ratio ! 679: / INT_MAX; ! 680: ! 681: free &= ~sw->hw->align; ! 682: if (!free) return 0; ! 683: ! 684: return free; ! 685: } ! 686: ! 687: int AUD_get_buffer_size (SWVoice *sw) ! 688: { ! 689: return sw->hw->bufsize; ! 690: } ! 691: ! 692: void AUD_adjust (SWVoice *sw, int bytes) ! 693: { ! 694: if (!sw) ! 695: return; ! 696: sw->old_ticks += (ticks_per_sec * (int64_t) bytes) / sw->bytes_per_second; ! 697: } ! 698: ! 699: void AUD_reset (SWVoice *sw) ! 700: { ! 701: sw->active = 0; ! 702: sw->old_ticks = 0; ! 703: } ! 704: ! 705: int AUD_calc_elapsed (SWVoice *sw) ! 706: { ! 707: int64_t now, delta, bytes; ! 708: int dead, swlim; ! 709: ! 710: if (!sw) ! 711: return 0; ! 712: ! 713: now = qemu_get_clock (vm_clock); ! 714: delta = now - sw->old_ticks; ! 715: bytes = (delta * sw->bytes_per_second) / ticks_per_sec; ! 716: if (delta < 0) { ! 717: dolog ("whoops delta(<0)=%lld\n", delta); ! 718: return 0; ! 719: } ! 720: ! 721: dead = sw->hw->samples - sw->live; ! 722: swlim = ((dead * (int64_t) INT_MAX) / sw->ratio); ! 723: ! 724: if (bytes > swlim) { ! 725: return swlim; ! 726: } ! 727: else { ! 728: return bytes; ! 729: } ! 730: } ! 731: ! 732: void AUD_enable (SWVoice *sw, int on) ! 733: { ! 734: int i; ! 735: HWVoice *hw; ! 736: ! 737: if (!sw) ! 738: return; ! 739: ! 740: hw = sw->hw; ! 741: if (on) { ! 742: if (!sw->live) ! 743: sw->wpos = sw->hw->rpos; ! 744: if (!sw->old_ticks) { ! 745: sw->old_ticks = qemu_get_clock (vm_clock); ! 746: } ! 747: } ! 748: ! 749: if (sw->active != on) { ! 750: if (on) { ! 751: hw->pending_disable = 0; ! 752: if (!hw->enabled) { ! 753: hw->enabled = 1; ! 754: for (i = 0; i < hw->nb_voices; i++) { ! 755: ldebug ("resetting voice\n"); ! 756: sw = hw->pvoice[i]; ! 757: sw->old_ticks = qemu_get_clock (vm_clock); ! 758: } ! 759: hw->pcm_ops->ctl (hw, VOICE_ENABLE); ! 760: } ! 761: } ! 762: else { ! 763: if (hw->enabled && !hw->pending_disable) { ! 764: int nb_active = 0; ! 765: for (i = 0; i < hw->nb_voices; i++) { ! 766: nb_active += hw->pvoice[i]->active != 0; ! 767: } ! 768: ! 769: if (nb_active == 1) { ! 770: hw->pending_disable = 1; ! 771: } ! 772: } ! 773: } ! 774: sw->active = on; ! 775: } ! 776: } ! 777: ! 778: static struct audio_output_driver *drvtab[] = { ! 779: #ifdef CONFIG_OSS ! 780: &oss_output_driver, ! 781: #endif ! 782: #ifdef CONFIG_FMOD ! 783: &fmod_output_driver, ! 784: #endif ! 785: #ifdef CONFIG_SDL ! 786: &sdl_output_driver, ! 787: #endif ! 788: &no_output_driver, ! 789: #ifdef USE_WAV_AUDIO ! 790: &wav_output_driver, ! 791: #endif ! 792: }; ! 793: ! 794: static int voice_init (struct audio_output_driver *drv) ! 795: { ! 796: audio_state.opaque = drv->init (); ! 797: if (audio_state.opaque) { ! 798: if (audio_state.nb_hw_voices > drv->max_voices) { ! 799: dolog ("`%s' does not support %d multiple hardware channels\n" ! 800: "Resetting to %d\n", ! 801: drv->name, audio_state.nb_hw_voices, drv->max_voices); ! 802: audio_state.nb_hw_voices = drv->max_voices; ! 803: } ! 804: hw_voices = qemu_mallocz (audio_state.nb_hw_voices * drv->voice_size); ! 805: if (hw_voices) { ! 806: audio_state.drv = drv; ! 807: return 1; ! 808: } ! 809: else { ! 810: dolog ("Not enough memory for %d `%s' voices (each %d bytes)\n", ! 811: audio_state.nb_hw_voices, drv->name, drv->voice_size); ! 812: drv->fini (audio_state.opaque); ! 813: return 0; ! 814: } ! 815: } ! 816: else { ! 817: dolog ("Could not init `%s' audio\n", drv->name); ! 818: return 0; ! 819: } ! 820: } ! 821: ! 822: static void audio_vm_stop_handler (void *opaque, int reason) ! 823: { ! 824: HWVoice *hw = NULL; ! 825: ! 826: while ((hw = pcm_hw_find_any (hw))) { ! 827: if (!hw->pcm_ops) ! 828: continue; ! 829: ! 830: hw->pcm_ops->ctl (hw, reason ? VOICE_ENABLE : VOICE_DISABLE); ! 831: } ! 832: } ! 833: ! 834: static void audio_atexit (void) ! 835: { ! 836: HWVoice *hw = NULL; ! 837: ! 838: while ((hw = pcm_hw_find_any (hw))) { ! 839: if (!hw->pcm_ops) ! 840: continue; ! 841: ! 842: hw->pcm_ops->ctl (hw, VOICE_DISABLE); ! 843: hw->pcm_ops->fini (hw); ! 844: } ! 845: audio_state.drv->fini (audio_state.opaque); ! 846: } ! 847: ! 848: static void audio_save (QEMUFile *f, void *opaque) ! 849: { ! 850: } ! 851: ! 852: static int audio_load (QEMUFile *f, void *opaque, int version_id) ! 853: { ! 854: if (version_id != 1) ! 855: return -EINVAL; ! 856: ! 857: return 0; ! 858: } ! 859: ! 860: void AUD_init (void) ! 861: { ! 862: int i; ! 863: int done = 0; ! 864: const char *drvname; ! 865: ! 866: audio_state.fixed_format = ! 867: !!audio_get_conf_int (QC_FIXED_FORMAT, audio_state.fixed_format); ! 868: audio_state.fixed_freq = ! 869: audio_get_conf_int (QC_FIXED_FREQ, audio_state.fixed_freq); ! 870: audio_state.nb_hw_voices = ! 871: audio_get_conf_int (QC_VOICES, audio_state.nb_hw_voices); ! 872: ! 873: if (audio_state.nb_hw_voices <= 0) { ! 874: dolog ("Bogus number of voices %d, resetting to 1\n", ! 875: audio_state.nb_hw_voices); ! 876: } ! 877: ! 878: drvname = audio_get_conf_str (QC_AUDIO_DRV, NULL); ! 879: if (drvname) { ! 880: int found = 0; ! 881: for (i = 0; i < sizeof (drvtab) / sizeof (drvtab[0]); i++) { ! 882: if (!strcmp (drvname, drvtab[i]->name)) { ! 883: done = voice_init (drvtab[i]); ! 884: found = 1; ! 885: break; ! 886: } ! 887: } ! 888: if (!found) { ! 889: dolog ("Unknown audio driver `%s'\n", drvname); ! 890: } ! 891: } ! 892: ! 893: qemu_add_vm_stop_handler (audio_vm_stop_handler, NULL); ! 894: atexit (audio_atexit); ! 895: ! 896: if (!done) { ! 897: for (i = 0; !done && i < sizeof (drvtab) / sizeof (drvtab[0]); i++) { ! 898: if (drvtab[i]->can_be_default) ! 899: done = voice_init (drvtab[i]); ! 900: } ! 901: } ! 902: ! 903: audio_state.ticks_threshold = ticks_per_sec / 50; ! 904: audio_state.freq_threshold = 100; ! 905: ! 906: register_savevm ("audio", 0, 1, audio_save, audio_load, NULL); ! 907: if (!done) { ! 908: dolog ("Can not initialize audio subsystem\n"); ! 909: voice_init (&no_output_driver); ! 910: } ! 911: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.