audio/winwaveaudio.c

   1 /* public domain */
   2
   3 #include "qemu-common.h"
   4 #include "sysemu.h"
   5 #include "audio.h"
   6
   7 #define AUDIO_CAP "winwave"
   8 #include "audio_int.h"
   9
  10 #include <windows.h>
  11 #include <mmsystem.h>
  12
  13 #include "audio_win_int.h"
  14
  15 static struct {
  16     int dac_headers;
  17     int dac_samples;
  18     int adc_headers;
  19     int adc_samples;
  20 } conf = {
  21     .dac_headers = 4,
  22     .dac_samples = 1024,
  23     .adc_headers = 4,
  24     .adc_samples = 1024
  25 };
  26
  27 typedef struct {
  28     HWVoiceOut hw;
  29     HWAVEOUT hwo;
  30     WAVEHDR *hdrs;
  31     HANDLE event;
  32     void *pcm_buf;
  33     int avail;
  34     int pending;
  35     int curhdr;
  36     int paused;
  37     CRITICAL_SECTION crit_sect;
  38 } WaveVoiceOut;
  39
  40 typedef struct {
  41     HWVoiceIn hw;
  42     HWAVEIN hwi;
  43     WAVEHDR *hdrs;
  44     HANDLE event;
  45     void *pcm_buf;
  46     int curhdr;
  47     int paused;
  48     int rpos;
  49     int avail;
  50     CRITICAL_SECTION crit_sect;
  51 } WaveVoiceIn;
  52
  53 static void winwave_log_mmresult (MMRESULT mr)
  54 {
  55     const char *str = "BUG";
  56
  57     switch (mr) {
  58     case MMSYSERR_NOERROR:
  59         str = "Success";
  60         break;
  61
  62     case MMSYSERR_INVALHANDLE:
  63         str = "Specified device handle is invalid";
  64         break;
  65
  66     case MMSYSERR_BADDEVICEID:
  67         str = "Specified device id is out of range";
  68         break;
  69
  70     case MMSYSERR_NODRIVER:
  71         str = "No device driver is present";
  72         break;
  73
  74     case MMSYSERR_NOMEM:
  75         str = "Unable to allocate or lock memory";
  76         break;
  77
  78     case WAVERR_SYNC:
  79         str = "Device is synchronous but waveOutOpen was called "
  80             "without using the WINWAVE_ALLOWSYNC flag";
  81         break;
  82
  83     case WAVERR_UNPREPARED:
  84         str = "The data block pointed to by the pwh parameter "
  85             "hasn't been prepared";
  86         break;
  87
  88     case WAVERR_STILLPLAYING:
  89         str = "There are still buffers in the queue";
  90         break;
  91
  92     default:
  93         dolog ("Reason: Unknown (MMRESULT %#x)\n", mr);
  94         return;
  95     }
  96
  97     dolog ("Reason: %s\n", str);
  98 }
  99
 100 static void GCC_FMT_ATTR (2, 3) winwave_logerr (
 101     MMRESULT mr,
 102     const char *fmt,
 103     ...
 104     )
 105 {
 106     va_list ap;
 107
 108     va_start (ap, fmt);
 109     AUD_vlog (AUDIO_CAP, fmt, ap);
 110     va_end (ap);
 111
 112     AUD_log (NULL, " failed\n");
 113     winwave_log_mmresult (mr);
 114 }
 115
 116 static void winwave_anal_close_out (WaveVoiceOut *wave)
 117 {
 118     MMRESULT mr;
 119
 120     mr = waveOutClose (wave->hwo);
 121     if (mr != MMSYSERR_NOERROR) {
 122         winwave_logerr (mr, "waveOutClose");
 123     }
 124     wave->hwo = NULL;
 125 }
 126
 127 static void CALLBACK winwave_callback_out (
 128     HWAVEOUT hwo,
 129     UINT msg,
 130     DWORD_PTR dwInstance,
 131     DWORD_PTR dwParam1,
 132     DWORD_PTR dwParam2
 133     )
 134 {
 135     WaveVoiceOut *wave = (WaveVoiceOut *) dwInstance;
 136
 137     switch (msg) {
 138     case WOM_DONE:
 139         {
 140             WAVEHDR *h = (WAVEHDR *) dwParam1;
 141             if (!h->dwUser) {
 142                 h->dwUser = 1;
 143                 EnterCriticalSection (&wave->crit_sect);
 144                 {
 145                     wave->avail += conf.dac_samples;
 146                 }
 147                 LeaveCriticalSection (&wave->crit_sect);
 148                 if (wave->hw.poll_mode) {
 149                     if (!SetEvent (wave->event)) {
 150                         dolog ("DAC SetEvent failed %lx\n", GetLastError ());
 151                     }
 152                 }
 153             }
 154         }
 155         break;
 156
 157     case WOM_CLOSE:
 158     case WOM_OPEN:
 159         break;
 160
 161     default:
 162         dolog ("unknown wave out callback msg %x\n", msg);
 163     }
 164 }
 165
 166 static int winwave_init_out (HWVoiceOut *hw, struct audsettings *as)
 167 {
 168     int i;
 169     int err;
 170     MMRESULT mr;
 171     WAVEFORMATEX wfx;
 172     WaveVoiceOut *wave;
 173
 174     wave = (WaveVoiceOut *) hw;
 175
 176     InitializeCriticalSection (&wave->crit_sect);
 177
 178     err = waveformat_from_audio_settings (&wfx, as);
 179     if (err) {
 180         goto err0;
 181     }
 182
 183     mr = waveOutOpen (&wave->hwo, WAVE_MAPPER, &wfx,
 184                       (DWORD_PTR) winwave_callback_out,
 185                       (DWORD_PTR) wave, CALLBACK_FUNCTION);
 186     if (mr != MMSYSERR_NOERROR) {
 187         winwave_logerr (mr, "waveOutOpen");
 188         goto err1;
 189     }
 190
 191     wave->hdrs = audio_calloc (AUDIO_FUNC, conf.dac_headers,
 192                                sizeof (*wave->hdrs));
 193     if (!wave->hdrs) {
 194         goto err2;
 195     }
 196
 197     audio_pcm_init_info (&hw->info, as);
 198     hw->samples = conf.dac_samples * conf.dac_headers;
 199     wave->avail = hw->samples;
 200
 201     wave->pcm_buf = audio_calloc (AUDIO_FUNC, conf.dac_samples,
 202                                   conf.dac_headers << hw->info.shift);
 203     if (!wave->pcm_buf) {
 204         goto err3;
 205     }
 206
 207     for (i = 0; i < conf.dac_headers; ++i) {
 208         WAVEHDR *h = &wave->hdrs[i];
 209
 210         h->dwUser = 0;
 211         h->dwBufferLength = conf.dac_samples << hw->info.shift;
 212         h->lpData = advance (wave->pcm_buf, i * h->dwBufferLength);
 213         h->dwFlags = 0;
 214
 215         mr = waveOutPrepareHeader (wave->hwo, h, sizeof (*h));
 216         if (mr != MMSYSERR_NOERROR) {
 217             winwave_logerr (mr, "waveOutPrepareHeader(%d)", i);
 218             goto err4;
 219         }
 220     }
 221
 222     return 0;
 223
 224  err4:
 225     g_free (wave->pcm_buf);
 226  err3:
 227     g_free (wave->hdrs);
 228  err2:
 229     winwave_anal_close_out (wave);
 230  err1:
 231  err0:
 232     return -1;
 233 }
 234
 235 static int winwave_write (SWVoiceOut *sw, void *buf, int len)
 236 {
 237     return audio_pcm_sw_write (sw, buf, len);
 238 }
 239
 240 static int winwave_run_out (HWVoiceOut *hw, int live)
 241 {
 242     WaveVoiceOut *wave = (WaveVoiceOut *) hw;
 243     int decr;
 244     int doreset;
 245
 246     EnterCriticalSection (&wave->crit_sect);
 247     {
 248         decr = audio_MIN (live, wave->avail);
 249         decr = audio_pcm_hw_clip_out (hw, wave->pcm_buf, decr, wave->pending);
 250         wave->pending += decr;
 251         wave->avail -= decr;
 252     }
 253     LeaveCriticalSection (&wave->crit_sect);
 254
 255     doreset = hw->poll_mode && (wave->pending >= conf.dac_samples);
 256     if (doreset && !ResetEvent (wave->event)) {
 257         dolog ("DAC ResetEvent failed %lx\n", GetLastError ());
 258     }
 259
 260     while (wave->pending >= conf.dac_samples) {
 261         MMRESULT mr;
 262         WAVEHDR *h = &wave->hdrs[wave->curhdr];
 263
 264         h->dwUser = 0;
 265         mr = waveOutWrite (wave->hwo, h, sizeof (*h));
 266         if (mr != MMSYSERR_NOERROR) {
 267             winwave_logerr (mr, "waveOutWrite(%d)", wave->curhdr);
 268             break;
 269         }
 270
 271         wave->pending -= conf.dac_samples;
 272         wave->curhdr = (wave->curhdr + 1) % conf.dac_headers;
 273     }
 274
 275     return decr;
 276 }
 277
 278 static void winwave_poll (void *opaque)
 279 {
 280     (void) opaque;
 281     audio_run ("winwave_poll");
 282 }
 283
 284 static void winwave_fini_out (HWVoiceOut *hw)
 285 {
 286     int i;
 287     MMRESULT mr;
 288     WaveVoiceOut *wave = (WaveVoiceOut *) hw;
 289
 290     mr = waveOutReset (wave->hwo);
 291     if (mr != MMSYSERR_NOERROR) {
 292         winwave_logerr (mr, "waveOutReset");
 293     }
 294
 295     for (i = 0; i < conf.dac_headers; ++i) {
 296         mr = waveOutUnprepareHeader (wave->hwo, &wave->hdrs[i],
 297                                      sizeof (wave->hdrs[i]));
 298         if (mr != MMSYSERR_NOERROR) {
 299             winwave_logerr (mr, "waveOutUnprepareHeader(%d)", i);
 300         }
 301     }
 302
 303     winwave_anal_close_out (wave);
 304
 305     if (wave->event) {
 306         qemu_del_wait_object (wave->event, winwave_poll, wave);
 307         if (!CloseHandle (wave->event)) {
 308             dolog ("DAC CloseHandle failed %lx\n", GetLastError ());
 309         }
 310         wave->event = NULL;
 311     }
 312
 313     g_free (wave->pcm_buf);
 314     wave->pcm_buf = NULL;
 315
 316     g_free (wave->hdrs);
 317     wave->hdrs = NULL;
 318 }
 319
 320 static int winwave_ctl_out (HWVoiceOut *hw, int cmd, ...)
 321 {
 322     MMRESULT mr;
 323     WaveVoiceOut *wave = (WaveVoiceOut *) hw;
 324
 325     switch (cmd) {
 326     case VOICE_ENABLE:
 327         {
 328             va_list ap;
 329             int poll_mode;
 330
 331             va_start (ap, cmd);
 332             poll_mode = va_arg (ap, int);
 333             va_end (ap);
 334
 335             if (poll_mode && !wave->event) {
 336                 wave->event = CreateEvent (NULL, TRUE, TRUE, NULL);
 337                 if (!wave->event) {
 338                     dolog ("DAC CreateEvent: %lx, poll mode will be disabled\n",
 339                            GetLastError ());
 340                 }
 341             }
 342
 343             if (wave->event) {
 344                 int ret;
 345
 346                 ret = qemu_add_wait_object (wave->event, winwave_poll, wave);
 347                 hw->poll_mode = (ret == 0);
 348             }
 349             else {
 350                 hw->poll_mode = 0;
 351             }
 352             wave->paused = 0;
 353         }
 354         return 0;
 355
 356     case VOICE_DISABLE:
 357         if (!wave->paused) {
 358             mr = waveOutReset (wave->hwo);
 359             if (mr != MMSYSERR_NOERROR) {
 360                 winwave_logerr (mr, "waveOutReset");
 361             }
 362             else {
 363                 wave->paused = 1;
 364             }
 365         }
 366         if (wave->event) {
 367             qemu_del_wait_object (wave->event, winwave_poll, wave);
 368         }
 369         return 0;
 370     }
 371     return -1;
 372 }
 373
 374 static void winwave_anal_close_in (WaveVoiceIn *wave)
 375 {
 376     MMRESULT mr;
 377
 378     mr = waveInClose (wave->hwi);
 379     if (mr != MMSYSERR_NOERROR) {
 380         winwave_logerr (mr, "waveInClose");
 381     }
 382     wave->hwi = NULL;
 383 }
 384
 385 static void CALLBACK winwave_callback_in (
 386     HWAVEIN *hwi,
 387     UINT msg,
 388     DWORD_PTR dwInstance,
 389     DWORD_PTR dwParam1,
 390     DWORD_PTR dwParam2
 391     )
 392 {
 393     WaveVoiceIn *wave = (WaveVoiceIn *) dwInstance;
 394
 395     switch (msg) {
 396     case WIM_DATA:
 397         {
 398             WAVEHDR *h = (WAVEHDR *) dwParam1;
 399             if (!h->dwUser) {
 400                 h->dwUser = 1;
 401                 EnterCriticalSection (&wave->crit_sect);
 402                 {
 403                     wave->avail += conf.adc_samples;
 404                 }
 405                 LeaveCriticalSection (&wave->crit_sect);
 406                 if (wave->hw.poll_mode) {
 407                     if (!SetEvent (wave->event)) {
 408                         dolog ("ADC SetEvent failed %lx\n", GetLastError ());
 409                     }
 410                 }
 411             }
 412         }
 413         break;
 414
 415     case WIM_CLOSE:
 416     case WIM_OPEN:
 417         break;
 418
 419     default:
 420         dolog ("unknown wave in callback msg %x\n", msg);
 421     }
 422 }
 423
 424 static void winwave_add_buffers (WaveVoiceIn *wave, int samples)
 425 {
 426     int doreset;
 427
 428     doreset = wave->hw.poll_mode && (samples >= conf.adc_samples);
 429     if (doreset && !ResetEvent (wave->event)) {
 430         dolog ("ADC ResetEvent failed %lx\n", GetLastError ());
 431     }
 432
 433     while (samples >= conf.adc_samples) {
 434         MMRESULT mr;
 435         WAVEHDR *h = &wave->hdrs[wave->curhdr];
 436
 437         h->dwUser = 0;
 438         mr = waveInAddBuffer (wave->hwi, h, sizeof (*h));
 439         if (mr != MMSYSERR_NOERROR) {
 440             winwave_logerr (mr, "waveInAddBuffer(%d)", wave->curhdr);
 441         }
 442         wave->curhdr = (wave->curhdr + 1) % conf.adc_headers;
 443         samples -= conf.adc_samples;
 444     }
 445 }
 446
 447 static int winwave_init_in (HWVoiceIn *hw, struct audsettings *as)
 448 {
 449     int i;
 450     int err;
 451     MMRESULT mr;
 452     WAVEFORMATEX wfx;
 453     WaveVoiceIn *wave;
 454
 455     wave = (WaveVoiceIn *) hw;
 456
 457     InitializeCriticalSection (&wave->crit_sect);
 458
 459     err = waveformat_from_audio_settings (&wfx, as);
 460     if (err) {
 461         goto err0;
 462     }
 463
 464     mr = waveInOpen (&wave->hwi, WAVE_MAPPER, &wfx,
 465                      (DWORD_PTR) winwave_callback_in,
 466                      (DWORD_PTR) wave, CALLBACK_FUNCTION);
 467     if (mr != MMSYSERR_NOERROR) {
 468         winwave_logerr (mr, "waveInOpen");
 469         goto err1;
 470     }
 471
 472     wave->hdrs = audio_calloc (AUDIO_FUNC, conf.dac_headers,
 473                                sizeof (*wave->hdrs));
 474     if (!wave->hdrs) {
 475         goto err2;
 476     }
 477
 478     audio_pcm_init_info (&hw->info, as);
 479     hw->samples = conf.adc_samples * conf.adc_headers;
 480     wave->avail = 0;
 481
 482     wave->pcm_buf = audio_calloc (AUDIO_FUNC, conf.adc_samples,
 483                                   conf.adc_headers << hw->info.shift);
 484     if (!wave->pcm_buf) {
 485         goto err3;
 486     }
 487
 488     for (i = 0; i < conf.adc_headers; ++i) {
 489         WAVEHDR *h = &wave->hdrs[i];
 490
 491         h->dwUser = 0;
 492         h->dwBufferLength = conf.adc_samples << hw->info.shift;
 493         h->lpData = advance (wave->pcm_buf, i * h->dwBufferLength);
 494         h->dwFlags = 0;
 495
 496         mr = waveInPrepareHeader (wave->hwi, h, sizeof (*h));
 497         if (mr != MMSYSERR_NOERROR) {
 498             winwave_logerr (mr, "waveInPrepareHeader(%d)", i);
 499             goto err4;
 500         }
 501     }
 502
 503     wave->paused = 1;
 504     winwave_add_buffers (wave, hw->samples);
 505     return 0;
 506
 507  err4:
 508     g_free (wave->pcm_buf);
 509  err3:
 510     g_free (wave->hdrs);
 511  err2:
 512     winwave_anal_close_in (wave);
 513  err1:
 514  err0:
 515     return -1;
 516 }
 517
 518 static void winwave_fini_in (HWVoiceIn *hw)
 519 {
 520     int i;
 521     MMRESULT mr;
 522     WaveVoiceIn *wave = (WaveVoiceIn *) hw;
 523
 524     mr = waveInReset (wave->hwi);
 525     if (mr != MMSYSERR_NOERROR) {
 526         winwave_logerr (mr, "waveInReset");
 527     }
 528
 529     for (i = 0; i < conf.adc_headers; ++i) {
 530         mr = waveInUnprepareHeader (wave->hwi, &wave->hdrs[i],
 531                                      sizeof (wave->hdrs[i]));
 532         if (mr != MMSYSERR_NOERROR) {
 533             winwave_logerr (mr, "waveInUnprepareHeader(%d)", i);
 534         }
 535     }
 536
 537     winwave_anal_close_in (wave);
 538
 539     if (wave->event) {
 540         qemu_del_wait_object (wave->event, winwave_poll, wave);
 541         if (!CloseHandle (wave->event)) {
 542             dolog ("ADC CloseHandle failed %lx\n", GetLastError ());
 543         }
 544         wave->event = NULL;
 545     }
 546
 547     g_free (wave->pcm_buf);
 548     wave->pcm_buf = NULL;
 549
 550     g_free (wave->hdrs);
 551     wave->hdrs = NULL;
 552 }
 553
 554 static int winwave_run_in (HWVoiceIn *hw)
 555 {
 556     WaveVoiceIn *wave = (WaveVoiceIn *) hw;
 557     int live = audio_pcm_hw_get_live_in (hw);
 558     int dead = hw->samples - live;
 559     int decr, ret;
 560
 561     if (!dead) {
 562         return 0;
 563     }
 564
 565     EnterCriticalSection (&wave->crit_sect);
 566     {
 567         decr = audio_MIN (dead, wave->avail);
 568         wave->avail -= decr;
 569     }
 570     LeaveCriticalSection (&wave->crit_sect);
 571
 572     ret = decr;
 573     while (decr) {
 574         int left = hw->samples - hw->wpos;
 575         int conv = audio_MIN (left, decr);
 576         hw->conv (hw->conv_buf + hw->wpos,
 577                   advance (wave->pcm_buf, wave->rpos << hw->info.shift),
 578                   conv);
 579
 580         wave->rpos = (wave->rpos + conv) % hw->samples;
 581         hw->wpos = (hw->wpos + conv) % hw->samples;
 582         decr -= conv;
 583     }
 584
 585     winwave_add_buffers (wave, ret);
 586     return ret;
 587 }
 588
 589 static int winwave_read (SWVoiceIn *sw, void *buf, int size)
 590 {
 591     return audio_pcm_sw_read (sw, buf, size);
 592 }
 593
 594 static int winwave_ctl_in (HWVoiceIn *hw, int cmd, ...)
 595 {
 596     MMRESULT mr;
 597     WaveVoiceIn *wave = (WaveVoiceIn *) hw;
 598
 599     switch (cmd) {
 600     case VOICE_ENABLE:
 601         {
 602             va_list ap;
 603             int poll_mode;
 604
 605             va_start (ap, cmd);
 606             poll_mode = va_arg (ap, int);
 607             va_end (ap);
 608
 609             if (poll_mode && !wave->event) {
 610                 wave->event = CreateEvent (NULL, TRUE, TRUE, NULL);
 611                 if (!wave->event) {
 612                     dolog ("ADC CreateEvent: %lx, poll mode will be disabled\n",
 613                            GetLastError ());
 614                 }
 615             }
 616
 617             if (wave->event) {
 618                 int ret;
 619
 620                 ret = qemu_add_wait_object (wave->event, winwave_poll, wave);
 621                 hw->poll_mode = (ret == 0);
 622             }
 623             else {
 624                 hw->poll_mode = 0;
 625             }
 626             if (wave->paused) {
 627                 mr = waveInStart (wave->hwi);
 628                 if (mr != MMSYSERR_NOERROR) {
 629                     winwave_logerr (mr, "waveInStart");
 630                 }
 631                 wave->paused = 0;
 632             }
 633         }
 634         return 0;
 635
 636     case VOICE_DISABLE:
 637         if (!wave->paused) {
 638             mr = waveInStop (wave->hwi);
 639             if (mr != MMSYSERR_NOERROR) {
 640                 winwave_logerr (mr, "waveInStop");
 641             }
 642             else {
 643                 wave->paused = 1;
 644             }
 645         }
 646         if (wave->event) {
 647             qemu_del_wait_object (wave->event, winwave_poll, wave);
 648         }
 649         return 0;
 650     }
 651     return 0;
 652 }
 653
 654 static void *winwave_audio_init (void)
 655 {
 656     return &conf;
 657 }
 658
 659 static void winwave_audio_fini (void *opaque)
 660 {
 661     (void) opaque;
 662 }
 663
 664 static struct audio_option winwave_options[] = {
 665     {
 666         .name        = "DAC_HEADERS",
 667         .tag         = AUD_OPT_INT,
 668         .valp        = &conf.dac_headers,
 669         .descr       = "DAC number of headers",
 670     },
 671     {
 672         .name        = "DAC_SAMPLES",
 673         .tag         = AUD_OPT_INT,
 674         .valp        = &conf.dac_samples,
 675         .descr       = "DAC number of samples per header",
 676     },
 677     {
 678         .name        = "ADC_HEADERS",
 679         .tag         = AUD_OPT_INT,
 680         .valp        = &conf.adc_headers,
 681         .descr       = "ADC number of headers",
 682     },
 683     {
 684         .name        = "ADC_SAMPLES",
 685         .tag         = AUD_OPT_INT,
 686         .valp        = &conf.adc_samples,
 687         .descr       = "ADC number of samples per header",
 688     },
 689     { /* End of list */ }
 690 };
 691
 692 static struct audio_pcm_ops winwave_pcm_ops = {
 693     .init_out = winwave_init_out,
 694     .fini_out = winwave_fini_out,
 695     .run_out  = winwave_run_out,
 696     .write    = winwave_write,
 697     .ctl_out  = winwave_ctl_out,
 698     .init_in  = winwave_init_in,
 699     .fini_in  = winwave_fini_in,
 700     .run_in   = winwave_run_in,
 701     .read     = winwave_read,
 702     .ctl_in   = winwave_ctl_in
 703 };
 704
 705 struct audio_driver winwave_audio_driver = {
 706     .name           = "winwave",
 707     .descr          = "Windows Waveform Audio http://msdn.microsoft.com",
 708     .options        = winwave_options,
 709     .init           = winwave_audio_init,
 710     .fini           = winwave_audio_fini,
 711     .pcm_ops        = &winwave_pcm_ops,
 712     .can_be_default = 1,
 713     .max_voices_out = INT_MAX,
 714     .max_voices_in  = INT_MAX,
 715     .voice_size_out = sizeof (WaveVoiceOut),
 716     .voice_size_in  = sizeof (WaveVoiceIn)
 717 };