Return to winwaveaudio.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / audio

Annotation of qemu/audio/winwaveaudio.c, revision 1.1

1.1     ! root        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 locl 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:     qemu_free (wave->pcm_buf);
        !           226:  err3:
        !           227:     qemu_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:     qemu_free (wave->pcm_buf);
        !           314:     wave->pcm_buf = NULL;
        !           315: 
        !           316:     qemu_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:             if (wave->paused) {
        !           353:                 mr = waveOutRestart (wave->hwo);
        !           354:                 if (mr != MMSYSERR_NOERROR) {
        !           355:                     winwave_logerr (mr, "waveOutRestart");
        !           356:                 }
        !           357:                 wave->paused = 0;
        !           358:             }
        !           359:         }
        !           360:         return 0;
        !           361: 
        !           362:     case VOICE_DISABLE:
        !           363:         if (!wave->paused) {
        !           364:             mr = waveOutPause (wave->hwo);
        !           365:             if (mr != MMSYSERR_NOERROR) {
        !           366:                 winwave_logerr (mr, "waveOutPause");
        !           367:             }
        !           368:             else {
        !           369:                 wave->paused = 1;
        !           370:             }
        !           371:         }
        !           372:         if (wave->event) {
        !           373:             qemu_del_wait_object (wave->event, winwave_poll, wave);
        !           374:         }
        !           375:         return 0;
        !           376:     }
        !           377:     return -1;
        !           378: }
        !           379: 
        !           380: static void winwave_anal_close_in (WaveVoiceIn *wave)
        !           381: {
        !           382:     MMRESULT mr;
        !           383: 
        !           384:     mr = waveInClose (wave->hwi);
        !           385:     if (mr != MMSYSERR_NOERROR) {
        !           386:         winwave_logerr (mr, "waveInClose");
        !           387:     }
        !           388:     wave->hwi = NULL;
        !           389: }
        !           390: 
        !           391: static void CALLBACK winwave_callback_in (
        !           392:     HWAVEIN *hwi,
        !           393:     UINT msg,
        !           394:     DWORD_PTR dwInstance,
        !           395:     DWORD_PTR dwParam1,
        !           396:     DWORD_PTR dwParam2
        !           397:     )
        !           398: {
        !           399:     WaveVoiceIn *wave = (WaveVoiceIn *) dwInstance;
        !           400: 
        !           401:     switch (msg) {
        !           402:     case WIM_DATA:
        !           403:         {
        !           404:             WAVEHDR *h = (WAVEHDR *) dwParam1;
        !           405:             if (!h->dwUser) {
        !           406:                 h->dwUser = 1;
        !           407:                 EnterCriticalSection (&wave->crit_sect);
        !           408:                 {
        !           409:                     wave->avail += conf.adc_samples;
        !           410:                 }
        !           411:                 LeaveCriticalSection (&wave->crit_sect);
        !           412:                 if (wave->hw.poll_mode) {
        !           413:                     if (!SetEvent (wave->event)) {
        !           414:                         dolog ("ADC SetEvent failed %lx\n", GetLastError ());
        !           415:                     }
        !           416:                 }
        !           417:             }
        !           418:         }
        !           419:         break;
        !           420: 
        !           421:     case WIM_CLOSE:
        !           422:     case WIM_OPEN:
        !           423:         break;
        !           424: 
        !           425:     default:
        !           426:         dolog ("unknown wave in callback msg %x\n", msg);
        !           427:     }
        !           428: }
        !           429: 
        !           430: static void winwave_add_buffers (WaveVoiceIn *wave, int samples)
        !           431: {
        !           432:     int doreset;
        !           433: 
        !           434:     doreset = wave->hw.poll_mode && (samples >= conf.adc_samples);
        !           435:     if (doreset && !ResetEvent (wave->event)) {
        !           436:         dolog ("ADC ResetEvent failed %lx\n", GetLastError ());
        !           437:     }
        !           438: 
        !           439:     while (samples >= conf.adc_samples) {
        !           440:         MMRESULT mr;
        !           441:         WAVEHDR *h = &wave->hdrs[wave->curhdr];
        !           442: 
        !           443:         h->dwUser = 0;
        !           444:         mr = waveInAddBuffer (wave->hwi, h, sizeof (*h));
        !           445:         if (mr != MMSYSERR_NOERROR) {
        !           446:             winwave_logerr (mr, "waveInAddBuffer(%d)", wave->curhdr);
        !           447:         }
        !           448:         wave->curhdr = (wave->curhdr + 1) % conf.adc_headers;
        !           449:         samples -= conf.adc_samples;
        !           450:     }
        !           451: }
        !           452: 
        !           453: static int winwave_init_in (HWVoiceIn *hw, struct audsettings *as)
        !           454: {
        !           455:     int i;
        !           456:     int err;
        !           457:     MMRESULT mr;
        !           458:     WAVEFORMATEX wfx;
        !           459:     WaveVoiceIn *wave;
        !           460: 
        !           461:     wave = (WaveVoiceIn *) hw;
        !           462: 
        !           463:     InitializeCriticalSection (&wave->crit_sect);
        !           464: 
        !           465:     err = waveformat_from_audio_settings (&wfx, as);
        !           466:     if (err) {
        !           467:         goto err0;
        !           468:     }
        !           469: 
        !           470:     mr = waveInOpen (&wave->hwi, WAVE_MAPPER, &wfx,
        !           471:                      (DWORD_PTR) winwave_callback_in,
        !           472:                      (DWORD_PTR) wave, CALLBACK_FUNCTION);
        !           473:     if (mr != MMSYSERR_NOERROR) {
        !           474:         winwave_logerr (mr, "waveInOpen");
        !           475:         goto err1;
        !           476:     }
        !           477: 
        !           478:     wave->hdrs = audio_calloc (AUDIO_FUNC, conf.dac_headers,
        !           479:                                sizeof (*wave->hdrs));
        !           480:     if (!wave->hdrs) {
        !           481:         goto err2;
        !           482:     }
        !           483: 
        !           484:     audio_pcm_init_info (&hw->info, as);
        !           485:     hw->samples = conf.adc_samples * conf.adc_headers;
        !           486:     wave->avail = 0;
        !           487: 
        !           488:     wave->pcm_buf = audio_calloc (AUDIO_FUNC, conf.adc_samples,
        !           489:                                   conf.adc_headers << hw->info.shift);
        !           490:     if (!wave->pcm_buf) {
        !           491:         goto err3;
        !           492:     }
        !           493: 
        !           494:     for (i = 0; i < conf.adc_headers; ++i) {
        !           495:         WAVEHDR *h = &wave->hdrs[i];
        !           496: 
        !           497:         h->dwUser = 0;
        !           498:         h->dwBufferLength = conf.adc_samples << hw->info.shift;
        !           499:         h->lpData = advance (wave->pcm_buf, i * h->dwBufferLength);
        !           500:         h->dwFlags = 0;
        !           501: 
        !           502:         mr = waveInPrepareHeader (wave->hwi, h, sizeof (*h));
        !           503:         if (mr != MMSYSERR_NOERROR) {
        !           504:             winwave_logerr (mr, "waveInPrepareHeader(%d)", i);
        !           505:             goto err4;
        !           506:         }
        !           507:     }
        !           508: 
        !           509:     wave->paused = 1;
        !           510:     winwave_add_buffers (wave, hw->samples);
        !           511:     return 0;
        !           512: 
        !           513:  err4:
        !           514:     qemu_free (wave->pcm_buf);
        !           515:  err3:
        !           516:     qemu_free (wave->hdrs);
        !           517:  err2:
        !           518:     winwave_anal_close_in (wave);
        !           519:  err1:
        !           520:  err0:
        !           521:     return -1;
        !           522: }
        !           523: 
        !           524: static void winwave_fini_in (HWVoiceIn *hw)
        !           525: {
        !           526:     int i;
        !           527:     MMRESULT mr;
        !           528:     WaveVoiceIn *wave = (WaveVoiceIn *) hw;
        !           529: 
        !           530:     mr = waveInReset (wave->hwi);
        !           531:     if (mr != MMSYSERR_NOERROR) {
        !           532:         winwave_logerr (mr, "waveInReset");
        !           533:     }
        !           534: 
        !           535:     for (i = 0; i < conf.adc_headers; ++i) {
        !           536:         mr = waveInUnprepareHeader (wave->hwi, &wave->hdrs[i],
        !           537:                                      sizeof (wave->hdrs[i]));
        !           538:         if (mr != MMSYSERR_NOERROR) {
        !           539:             winwave_logerr (mr, "waveInUnprepareHeader(%d)", i);
        !           540:         }
        !           541:     }
        !           542: 
        !           543:     winwave_anal_close_in (wave);
        !           544: 
        !           545:     if (wave->event) {
        !           546:         qemu_del_wait_object (wave->event, winwave_poll, wave);
        !           547:         if (!CloseHandle (wave->event)) {
        !           548:             dolog ("ADC CloseHandle failed %lx\n", GetLastError ());
        !           549:         }
        !           550:         wave->event = NULL;
        !           551:     }
        !           552: 
        !           553:     qemu_free (wave->pcm_buf);
        !           554:     wave->pcm_buf = NULL;
        !           555: 
        !           556:     qemu_free (wave->hdrs);
        !           557:     wave->hdrs = NULL;
        !           558: }
        !           559: 
        !           560: static int winwave_run_in (HWVoiceIn *hw)
        !           561: {
        !           562:     WaveVoiceIn *wave = (WaveVoiceIn *) hw;
        !           563:     int live = audio_pcm_hw_get_live_in (hw);
        !           564:     int dead = hw->samples - live;
        !           565:     int decr, ret;
        !           566: 
        !           567:     if (!dead) {
        !           568:         return 0;
        !           569:     }
        !           570: 
        !           571:     EnterCriticalSection (&wave->crit_sect);
        !           572:     {
        !           573:         decr = audio_MIN (dead, wave->avail);
        !           574:         wave->avail -= decr;
        !           575:     }
        !           576:     LeaveCriticalSection (&wave->crit_sect);
        !           577: 
        !           578:     ret = decr;
        !           579:     while (decr) {
        !           580:         int left = hw->samples - hw->wpos;
        !           581:         int conv = audio_MIN (left, decr);
        !           582:         hw->conv (hw->conv_buf + hw->wpos,
        !           583:                   advance (wave->pcm_buf, wave->rpos << hw->info.shift),
        !           584:                   conv,
        !           585:                   &nominal_volume);
        !           586: 
        !           587:         wave->rpos = (wave->rpos + conv) % hw->samples;
        !           588:         hw->wpos = (hw->wpos + conv) % hw->samples;
        !           589:         decr -= conv;
        !           590:     }
        !           591: 
        !           592:     winwave_add_buffers (wave, ret);
        !           593:     return ret;
        !           594: }
        !           595: 
        !           596: static int winwave_read (SWVoiceIn *sw, void *buf, int size)
        !           597: {
        !           598:     return audio_pcm_sw_read (sw, buf, size);
        !           599: }
        !           600: 
        !           601: static int winwave_ctl_in (HWVoiceIn *hw, int cmd, ...)
        !           602: {
        !           603:     MMRESULT mr;
        !           604:     WaveVoiceIn *wave = (WaveVoiceIn *) hw;
        !           605: 
        !           606:     switch (cmd) {
        !           607:     case VOICE_ENABLE:
        !           608:         {
        !           609:             va_list ap;
        !           610:             int poll_mode;
        !           611: 
        !           612:             va_start (ap, cmd);
        !           613:             poll_mode = va_arg (ap, int);
        !           614:             va_end (ap);
        !           615: 
        !           616:             if (poll_mode && !wave->event) {
        !           617:                 wave->event = CreateEvent (NULL, TRUE, TRUE, NULL);
        !           618:                 if (!wave->event) {
        !           619:                     dolog ("ADC CreateEvent: %lx, poll mode will be disabled\n",
        !           620:                            GetLastError ());
        !           621:                 }
        !           622:             }
        !           623: 
        !           624:             if (wave->event) {
        !           625:                 int ret;
        !           626: 
        !           627:                 ret = qemu_add_wait_object (wave->event, winwave_poll, wave);
        !           628:                 hw->poll_mode = (ret == 0);
        !           629:             }
        !           630:             else {
        !           631:                 hw->poll_mode = 0;
        !           632:             }
        !           633:             if (wave->paused) {
        !           634:                 mr = waveInStart (wave->hwi);
        !           635:                 if (mr != MMSYSERR_NOERROR) {
        !           636:                     winwave_logerr (mr, "waveInStart");
        !           637:                 }
        !           638:                 wave->paused = 0;
        !           639:             }
        !           640:         }
        !           641:         return 0;
        !           642: 
        !           643:     case VOICE_DISABLE:
        !           644:         if (!wave->paused) {
        !           645:             mr = waveInStop (wave->hwi);
        !           646:             if (mr != MMSYSERR_NOERROR) {
        !           647:                 winwave_logerr (mr, "waveInStop");
        !           648:             }
        !           649:             else {
        !           650:                 wave->paused = 1;
        !           651:             }
        !           652:         }
        !           653:         if (wave->event) {
        !           654:             qemu_del_wait_object (wave->event, winwave_poll, wave);
        !           655:         }
        !           656:         return 0;
        !           657:     }
        !           658:     return 0;
        !           659: }
        !           660: 
        !           661: static void *winwave_audio_init (void)
        !           662: {
        !           663:     return &conf;
        !           664: }
        !           665: 
        !           666: static void winwave_audio_fini (void *opaque)
        !           667: {
        !           668:     (void) opaque;
        !           669: }
        !           670: 
        !           671: static struct audio_option winwave_options[] = {
        !           672:     {
        !           673:         .name        = "DAC_HEADERS",
        !           674:         .tag         = AUD_OPT_INT,
        !           675:         .valp        = &conf.dac_headers,
        !           676:         .descr       = "DAC number of headers",
        !           677:     },
        !           678:     {
        !           679:         .name        = "DAC_SAMPLES",
        !           680:         .tag         = AUD_OPT_INT,
        !           681:         .valp        = &conf.dac_samples,
        !           682:         .descr       = "DAC number of samples per header",
        !           683:     },
        !           684:     {
        !           685:         .name        = "ADC_HEADERS",
        !           686:         .tag         = AUD_OPT_INT,
        !           687:         .valp        = &conf.adc_headers,
        !           688:         .descr       = "ADC number of headers",
        !           689:     },
        !           690:     {
        !           691:         .name        = "ADC_SAMPLES",
        !           692:         .tag         = AUD_OPT_INT,
        !           693:         .valp        = &conf.adc_samples,
        !           694:         .descr       = "ADC number of samples per header",
        !           695:     },
        !           696:     { /* End of list */ }
        !           697: };
        !           698: 
        !           699: static struct audio_pcm_ops winwave_pcm_ops = {
        !           700:     .init_out = winwave_init_out,
        !           701:     .fini_out = winwave_fini_out,
        !           702:     .run_out  = winwave_run_out,
        !           703:     .write    = winwave_write,
        !           704:     .ctl_out  = winwave_ctl_out,
        !           705:     .init_in  = winwave_init_in,
        !           706:     .fini_in  = winwave_fini_in,
        !           707:     .run_in   = winwave_run_in,
        !           708:     .read     = winwave_read,
        !           709:     .ctl_in   = winwave_ctl_in
        !           710: };
        !           711: 
        !           712: struct audio_driver winwave_audio_driver = {
        !           713:     .name           = "winwave",
        !           714:     .descr          = "Windows Waveform Audio http://msdn.microsoft.com",
        !           715:     .options        = winwave_options,
        !           716:     .init           = winwave_audio_init,
        !           717:     .fini           = winwave_audio_fini,
        !           718:     .pcm_ops        = &winwave_pcm_ops,
        !           719:     .can_be_default = 1,
        !           720:     .max_voices_out = INT_MAX,
        !           721:     .max_voices_in  = INT_MAX,
        !           722:     .voice_size_out = sizeof (WaveVoiceOut),
        !           723:     .voice_size_in  = sizeof (WaveVoiceIn)
        !           724: };

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.