Merge tag 'pull-request-2022-09-28' of https://gitlab.com/thuth/qemu into staging
[qemu.git] / audio / dsoundaudio.c
1 /*
2 * QEMU DirectSound audio driver
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 /*
26 * SEAL 1.07 by Carlos 'pel' Hasan was used as documentation
27 */
28
29 #include "qemu/osdep.h"
30 #include "audio.h"
31
32 #define AUDIO_CAP "dsound"
33 #include "audio_int.h"
34 #include "qemu/host-utils.h"
35 #include "qemu/module.h"
36
37 #include <windows.h>
38 #include <mmsystem.h>
39 #include <objbase.h>
40 #include <dsound.h>
41
42 #include "audio_win_int.h"
43
44 /* #define DEBUG_DSOUND */
45
46 typedef struct {
47 LPDIRECTSOUND dsound;
48 LPDIRECTSOUNDCAPTURE dsound_capture;
49 struct audsettings settings;
50 Audiodev *dev;
51 } dsound;
52
53 typedef struct {
54 HWVoiceOut hw;
55 LPDIRECTSOUNDBUFFER dsound_buffer;
56 bool first_time;
57 dsound *s;
58 } DSoundVoiceOut;
59
60 typedef struct {
61 HWVoiceIn hw;
62 LPDIRECTSOUNDCAPTUREBUFFER dsound_capture_buffer;
63 bool first_time;
64 dsound *s;
65 } DSoundVoiceIn;
66
67 static void dsound_log_hresult (HRESULT hr)
68 {
69 const char *str = "BUG";
70
71 switch (hr) {
72 case DS_OK:
73 str = "The method succeeded";
74 break;
75 #ifdef DS_NO_VIRTUALIZATION
76 case DS_NO_VIRTUALIZATION:
77 str = "The buffer was created, but another 3D algorithm was substituted";
78 break;
79 #endif
80 #ifdef DS_INCOMPLETE
81 case DS_INCOMPLETE:
82 str = "The method succeeded, but not all the optional effects were obtained";
83 break;
84 #endif
85 #ifdef DSERR_ACCESSDENIED
86 case DSERR_ACCESSDENIED:
87 str = "The request failed because access was denied";
88 break;
89 #endif
90 #ifdef DSERR_ALLOCATED
91 case DSERR_ALLOCATED:
92 str = "The request failed because resources, "
93 "such as a priority level, were already in use "
94 "by another caller";
95 break;
96 #endif
97 #ifdef DSERR_ALREADYINITIALIZED
98 case DSERR_ALREADYINITIALIZED:
99 str = "The object is already initialized";
100 break;
101 #endif
102 #ifdef DSERR_BADFORMAT
103 case DSERR_BADFORMAT:
104 str = "The specified wave format is not supported";
105 break;
106 #endif
107 #ifdef DSERR_BADSENDBUFFERGUID
108 case DSERR_BADSENDBUFFERGUID:
109 str = "The GUID specified in an audiopath file "
110 "does not match a valid mix-in buffer";
111 break;
112 #endif
113 #ifdef DSERR_BUFFERLOST
114 case DSERR_BUFFERLOST:
115 str = "The buffer memory has been lost and must be restored";
116 break;
117 #endif
118 #ifdef DSERR_BUFFERTOOSMALL
119 case DSERR_BUFFERTOOSMALL:
120 str = "The buffer size is not great enough to "
121 "enable effects processing";
122 break;
123 #endif
124 #ifdef DSERR_CONTROLUNAVAIL
125 case DSERR_CONTROLUNAVAIL:
126 str = "The buffer control (volume, pan, and so on) "
127 "requested by the caller is not available. "
128 "Controls must be specified when the buffer is created, "
129 "using the dwFlags member of DSBUFFERDESC";
130 break;
131 #endif
132 #ifdef DSERR_DS8_REQUIRED
133 case DSERR_DS8_REQUIRED:
134 str = "A DirectSound object of class CLSID_DirectSound8 or later "
135 "is required for the requested functionality. "
136 "For more information, see IDirectSound8 Interface";
137 break;
138 #endif
139 #ifdef DSERR_FXUNAVAILABLE
140 case DSERR_FXUNAVAILABLE:
141 str = "The effects requested could not be found on the system, "
142 "or they are in the wrong order or in the wrong location; "
143 "for example, an effect expected in hardware "
144 "was found in software";
145 break;
146 #endif
147 #ifdef DSERR_GENERIC
148 case DSERR_GENERIC:
149 str = "An undetermined error occurred inside the DirectSound subsystem";
150 break;
151 #endif
152 #ifdef DSERR_INVALIDCALL
153 case DSERR_INVALIDCALL:
154 str = "This function is not valid for the current state of this object";
155 break;
156 #endif
157 #ifdef DSERR_INVALIDPARAM
158 case DSERR_INVALIDPARAM:
159 str = "An invalid parameter was passed to the returning function";
160 break;
161 #endif
162 #ifdef DSERR_NOAGGREGATION
163 case DSERR_NOAGGREGATION:
164 str = "The object does not support aggregation";
165 break;
166 #endif
167 #ifdef DSERR_NODRIVER
168 case DSERR_NODRIVER:
169 str = "No sound driver is available for use, "
170 "or the given GUID is not a valid DirectSound device ID";
171 break;
172 #endif
173 #ifdef DSERR_NOINTERFACE
174 case DSERR_NOINTERFACE:
175 str = "The requested COM interface is not available";
176 break;
177 #endif
178 #ifdef DSERR_OBJECTNOTFOUND
179 case DSERR_OBJECTNOTFOUND:
180 str = "The requested object was not found";
181 break;
182 #endif
183 #ifdef DSERR_OTHERAPPHASPRIO
184 case DSERR_OTHERAPPHASPRIO:
185 str = "Another application has a higher priority level, "
186 "preventing this call from succeeding";
187 break;
188 #endif
189 #ifdef DSERR_OUTOFMEMORY
190 case DSERR_OUTOFMEMORY:
191 str = "The DirectSound subsystem could not allocate "
192 "sufficient memory to complete the caller's request";
193 break;
194 #endif
195 #ifdef DSERR_PRIOLEVELNEEDED
196 case DSERR_PRIOLEVELNEEDED:
197 str = "A cooperative level of DSSCL_PRIORITY or higher is required";
198 break;
199 #endif
200 #ifdef DSERR_SENDLOOP
201 case DSERR_SENDLOOP:
202 str = "A circular loop of send effects was detected";
203 break;
204 #endif
205 #ifdef DSERR_UNINITIALIZED
206 case DSERR_UNINITIALIZED:
207 str = "The Initialize method has not been called "
208 "or has not been called successfully "
209 "before other methods were called";
210 break;
211 #endif
212 #ifdef DSERR_UNSUPPORTED
213 case DSERR_UNSUPPORTED:
214 str = "The function called is not supported at this time";
215 break;
216 #endif
217 default:
218 AUD_log (AUDIO_CAP, "Reason: Unknown (HRESULT 0x%lx)\n", hr);
219 return;
220 }
221
222 AUD_log (AUDIO_CAP, "Reason: %s\n", str);
223 }
224
225 static void G_GNUC_PRINTF (2, 3) dsound_logerr (
226 HRESULT hr,
227 const char *fmt,
228 ...
229 )
230 {
231 va_list ap;
232
233 va_start (ap, fmt);
234 AUD_vlog (AUDIO_CAP, fmt, ap);
235 va_end (ap);
236
237 dsound_log_hresult (hr);
238 }
239
240 static void G_GNUC_PRINTF (3, 4) dsound_logerr2 (
241 HRESULT hr,
242 const char *typ,
243 const char *fmt,
244 ...
245 )
246 {
247 va_list ap;
248
249 AUD_log (AUDIO_CAP, "Could not initialize %s\n", typ);
250 va_start (ap, fmt);
251 AUD_vlog (AUDIO_CAP, fmt, ap);
252 va_end (ap);
253
254 dsound_log_hresult (hr);
255 }
256
257 #ifdef DEBUG_DSOUND
258 static void print_wave_format (WAVEFORMATEX *wfx)
259 {
260 dolog ("tag = %d\n", wfx->wFormatTag);
261 dolog ("nChannels = %d\n", wfx->nChannels);
262 dolog ("nSamplesPerSec = %ld\n", wfx->nSamplesPerSec);
263 dolog ("nAvgBytesPerSec = %ld\n", wfx->nAvgBytesPerSec);
264 dolog ("nBlockAlign = %d\n", wfx->nBlockAlign);
265 dolog ("wBitsPerSample = %d\n", wfx->wBitsPerSample);
266 dolog ("cbSize = %d\n", wfx->cbSize);
267 }
268 #endif
269
270 static int dsound_restore_out (LPDIRECTSOUNDBUFFER dsb, dsound *s)
271 {
272 HRESULT hr;
273
274 hr = IDirectSoundBuffer_Restore (dsb);
275
276 if (hr != DS_OK) {
277 dsound_logerr (hr, "Could not restore playback buffer\n");
278 return -1;
279 }
280 return 0;
281 }
282
283 #include "dsound_template.h"
284 #define DSBTYPE_IN
285 #include "dsound_template.h"
286 #undef DSBTYPE_IN
287
288 static int dsound_get_status_out (LPDIRECTSOUNDBUFFER dsb, DWORD *statusp,
289 dsound *s)
290 {
291 HRESULT hr;
292
293 hr = IDirectSoundBuffer_GetStatus (dsb, statusp);
294 if (FAILED (hr)) {
295 dsound_logerr (hr, "Could not get playback buffer status\n");
296 return -1;
297 }
298
299 if (*statusp & DSBSTATUS_BUFFERLOST) {
300 dsound_restore_out(dsb, s);
301 return -1;
302 }
303
304 return 0;
305 }
306
307 static int dsound_get_status_in (LPDIRECTSOUNDCAPTUREBUFFER dscb,
308 DWORD *statusp)
309 {
310 HRESULT hr;
311
312 hr = IDirectSoundCaptureBuffer_GetStatus (dscb, statusp);
313 if (FAILED (hr)) {
314 dsound_logerr (hr, "Could not get capture buffer status\n");
315 return -1;
316 }
317
318 return 0;
319 }
320
321 static void dsound_clear_sample (HWVoiceOut *hw, LPDIRECTSOUNDBUFFER dsb,
322 dsound *s)
323 {
324 int err;
325 LPVOID p1, p2;
326 DWORD blen1, blen2, len1, len2;
327
328 err = dsound_lock_out (
329 dsb,
330 &hw->info,
331 0,
332 hw->size_emul,
333 &p1, &p2,
334 &blen1, &blen2,
335 1,
336 s
337 );
338 if (err) {
339 return;
340 }
341
342 len1 = blen1 / hw->info.bytes_per_frame;
343 len2 = blen2 / hw->info.bytes_per_frame;
344
345 #ifdef DEBUG_DSOUND
346 dolog ("clear %p,%ld,%ld %p,%ld,%ld\n",
347 p1, blen1, len1,
348 p2, blen2, len2);
349 #endif
350
351 if (p1 && len1) {
352 audio_pcm_info_clear_buf (&hw->info, p1, len1);
353 }
354
355 if (p2 && len2) {
356 audio_pcm_info_clear_buf (&hw->info, p2, len2);
357 }
358
359 dsound_unlock_out (dsb, p1, p2, blen1, blen2);
360 }
361
362 static int dsound_set_cooperative_level(dsound *s)
363 {
364 HRESULT hr;
365 HWND hwnd;
366
367 hwnd = GetDesktopWindow();
368 hr = IDirectSound_SetCooperativeLevel (
369 s->dsound,
370 hwnd,
371 DSSCL_PRIORITY
372 );
373
374 if (FAILED (hr)) {
375 dsound_logerr (hr, "Could not set cooperative level for window %p\n",
376 hwnd);
377 return -1;
378 }
379
380 return 0;
381 }
382
383 static void dsound_enable_out(HWVoiceOut *hw, bool enable)
384 {
385 HRESULT hr;
386 DWORD status;
387 DSoundVoiceOut *ds = (DSoundVoiceOut *) hw;
388 LPDIRECTSOUNDBUFFER dsb = ds->dsound_buffer;
389 dsound *s = ds->s;
390
391 if (!dsb) {
392 dolog ("Attempt to control voice without a buffer\n");
393 return;
394 }
395
396 if (enable) {
397 if (dsound_get_status_out (dsb, &status, s)) {
398 return;
399 }
400
401 if (status & DSBSTATUS_PLAYING) {
402 dolog ("warning: Voice is already playing\n");
403 return;
404 }
405
406 dsound_clear_sample (hw, dsb, s);
407
408 hr = IDirectSoundBuffer_Play (dsb, 0, 0, DSBPLAY_LOOPING);
409 if (FAILED (hr)) {
410 dsound_logerr (hr, "Could not start playing buffer\n");
411 return;
412 }
413 } else {
414 if (dsound_get_status_out (dsb, &status, s)) {
415 return;
416 }
417
418 if (status & DSBSTATUS_PLAYING) {
419 hr = IDirectSoundBuffer_Stop (dsb);
420 if (FAILED (hr)) {
421 dsound_logerr (hr, "Could not stop playing buffer\n");
422 return;
423 }
424 } else {
425 dolog ("warning: Voice is not playing\n");
426 }
427 }
428 }
429
430 static size_t dsound_buffer_get_free(HWVoiceOut *hw)
431 {
432 DSoundVoiceOut *ds = (DSoundVoiceOut *) hw;
433 LPDIRECTSOUNDBUFFER dsb = ds->dsound_buffer;
434 HRESULT hr;
435 DWORD ppos, wpos;
436
437 hr = IDirectSoundBuffer_GetCurrentPosition(
438 dsb, &ppos, ds->first_time ? &wpos : NULL);
439 if (FAILED(hr)) {
440 dsound_logerr(hr, "Could not get playback buffer position\n");
441 return 0;
442 }
443
444 if (ds->first_time) {
445 hw->pos_emul = wpos;
446 ds->first_time = false;
447 }
448
449 return audio_ring_dist(ppos, hw->pos_emul, hw->size_emul);
450 }
451
452 static void *dsound_get_buffer_out(HWVoiceOut *hw, size_t *size)
453 {
454 DSoundVoiceOut *ds = (DSoundVoiceOut *)hw;
455 LPDIRECTSOUNDBUFFER dsb = ds->dsound_buffer;
456 DWORD act_size;
457 size_t req_size;
458 int err;
459 void *ret;
460
461 req_size = MIN(*size, hw->size_emul - hw->pos_emul);
462 assert(req_size > 0);
463
464 err = dsound_lock_out(dsb, &hw->info, hw->pos_emul, req_size, &ret, NULL,
465 &act_size, NULL, false, ds->s);
466 if (err) {
467 dolog("Failed to lock buffer\n");
468 *size = 0;
469 return NULL;
470 }
471
472 *size = act_size;
473 return ret;
474 }
475
476 static size_t dsound_put_buffer_out(HWVoiceOut *hw, void *buf, size_t len)
477 {
478 DSoundVoiceOut *ds = (DSoundVoiceOut *) hw;
479 LPDIRECTSOUNDBUFFER dsb = ds->dsound_buffer;
480 int err = dsound_unlock_out(dsb, buf, NULL, len, 0);
481
482 if (err) {
483 dolog("Failed to unlock buffer!!\n");
484 return 0;
485 }
486 hw->pos_emul = (hw->pos_emul + len) % hw->size_emul;
487
488 return len;
489 }
490
491 static void dsound_enable_in(HWVoiceIn *hw, bool enable)
492 {
493 HRESULT hr;
494 DWORD status;
495 DSoundVoiceIn *ds = (DSoundVoiceIn *) hw;
496 LPDIRECTSOUNDCAPTUREBUFFER dscb = ds->dsound_capture_buffer;
497
498 if (!dscb) {
499 dolog ("Attempt to control capture voice without a buffer\n");
500 return;
501 }
502
503 if (enable) {
504 if (dsound_get_status_in (dscb, &status)) {
505 return;
506 }
507
508 if (status & DSCBSTATUS_CAPTURING) {
509 dolog ("warning: Voice is already capturing\n");
510 return;
511 }
512
513 /* clear ?? */
514
515 hr = IDirectSoundCaptureBuffer_Start (dscb, DSCBSTART_LOOPING);
516 if (FAILED (hr)) {
517 dsound_logerr (hr, "Could not start capturing\n");
518 return;
519 }
520 } else {
521 if (dsound_get_status_in (dscb, &status)) {
522 return;
523 }
524
525 if (status & DSCBSTATUS_CAPTURING) {
526 hr = IDirectSoundCaptureBuffer_Stop (dscb);
527 if (FAILED (hr)) {
528 dsound_logerr (hr, "Could not stop capturing\n");
529 return;
530 }
531 } else {
532 dolog ("warning: Voice is not capturing\n");
533 }
534 }
535 }
536
537 static void *dsound_get_buffer_in(HWVoiceIn *hw, size_t *size)
538 {
539 DSoundVoiceIn *ds = (DSoundVoiceIn *) hw;
540 LPDIRECTSOUNDCAPTUREBUFFER dscb = ds->dsound_capture_buffer;
541 HRESULT hr;
542 DWORD rpos, act_size;
543 size_t req_size;
544 int err;
545 void *ret;
546
547 hr = IDirectSoundCaptureBuffer_GetCurrentPosition(dscb, NULL, &rpos);
548 if (FAILED(hr)) {
549 dsound_logerr(hr, "Could not get capture buffer position\n");
550 *size = 0;
551 return NULL;
552 }
553
554 if (ds->first_time) {
555 hw->pos_emul = rpos;
556 ds->first_time = false;
557 }
558
559 req_size = audio_ring_dist(rpos, hw->pos_emul, hw->size_emul);
560 req_size = MIN(*size, MIN(req_size, hw->size_emul - hw->pos_emul));
561
562 if (req_size == 0) {
563 *size = 0;
564 return NULL;
565 }
566
567 err = dsound_lock_in(dscb, &hw->info, hw->pos_emul, req_size, &ret, NULL,
568 &act_size, NULL, false, ds->s);
569 if (err) {
570 dolog("Failed to lock buffer\n");
571 *size = 0;
572 return NULL;
573 }
574
575 *size = act_size;
576 return ret;
577 }
578
579 static void dsound_put_buffer_in(HWVoiceIn *hw, void *buf, size_t len)
580 {
581 DSoundVoiceIn *ds = (DSoundVoiceIn *) hw;
582 LPDIRECTSOUNDCAPTUREBUFFER dscb = ds->dsound_capture_buffer;
583 int err = dsound_unlock_in(dscb, buf, NULL, len, 0);
584
585 if (err) {
586 dolog("Failed to unlock buffer!!\n");
587 return;
588 }
589 hw->pos_emul = (hw->pos_emul + len) % hw->size_emul;
590 }
591
592 static void dsound_audio_fini (void *opaque)
593 {
594 HRESULT hr;
595 dsound *s = opaque;
596
597 if (!s->dsound) {
598 g_free(s);
599 return;
600 }
601
602 hr = IDirectSound_Release (s->dsound);
603 if (FAILED (hr)) {
604 dsound_logerr (hr, "Could not release DirectSound\n");
605 }
606 s->dsound = NULL;
607
608 if (!s->dsound_capture) {
609 g_free(s);
610 return;
611 }
612
613 hr = IDirectSoundCapture_Release (s->dsound_capture);
614 if (FAILED (hr)) {
615 dsound_logerr (hr, "Could not release DirectSoundCapture\n");
616 }
617 s->dsound_capture = NULL;
618
619 g_free(s);
620 }
621
622 static void *dsound_audio_init(Audiodev *dev)
623 {
624 int err;
625 HRESULT hr;
626 dsound *s = g_new0(dsound, 1);
627 AudiodevDsoundOptions *dso;
628
629 assert(dev->driver == AUDIODEV_DRIVER_DSOUND);
630 s->dev = dev;
631 dso = &dev->u.dsound;
632
633 if (!dso->has_latency) {
634 dso->has_latency = true;
635 dso->latency = 10000; /* 10 ms */
636 }
637
638 hr = CoInitialize (NULL);
639 if (FAILED (hr)) {
640 dsound_logerr (hr, "Could not initialize COM\n");
641 g_free(s);
642 return NULL;
643 }
644
645 hr = CoCreateInstance (
646 &CLSID_DirectSound,
647 NULL,
648 CLSCTX_ALL,
649 &IID_IDirectSound,
650 (void **) &s->dsound
651 );
652 if (FAILED (hr)) {
653 dsound_logerr (hr, "Could not create DirectSound instance\n");
654 g_free(s);
655 return NULL;
656 }
657
658 hr = IDirectSound_Initialize (s->dsound, NULL);
659 if (FAILED (hr)) {
660 dsound_logerr (hr, "Could not initialize DirectSound\n");
661
662 hr = IDirectSound_Release (s->dsound);
663 if (FAILED (hr)) {
664 dsound_logerr (hr, "Could not release DirectSound\n");
665 }
666 g_free(s);
667 return NULL;
668 }
669
670 hr = CoCreateInstance (
671 &CLSID_DirectSoundCapture,
672 NULL,
673 CLSCTX_ALL,
674 &IID_IDirectSoundCapture,
675 (void **) &s->dsound_capture
676 );
677 if (FAILED (hr)) {
678 dsound_logerr (hr, "Could not create DirectSoundCapture instance\n");
679 } else {
680 hr = IDirectSoundCapture_Initialize (s->dsound_capture, NULL);
681 if (FAILED (hr)) {
682 dsound_logerr (hr, "Could not initialize DirectSoundCapture\n");
683
684 hr = IDirectSoundCapture_Release (s->dsound_capture);
685 if (FAILED (hr)) {
686 dsound_logerr (hr, "Could not release DirectSoundCapture\n");
687 }
688 s->dsound_capture = NULL;
689 }
690 }
691
692 err = dsound_set_cooperative_level(s);
693 if (err) {
694 dsound_audio_fini (s);
695 return NULL;
696 }
697
698 return s;
699 }
700
701 static struct audio_pcm_ops dsound_pcm_ops = {
702 .init_out = dsound_init_out,
703 .fini_out = dsound_fini_out,
704 .write = audio_generic_write,
705 .buffer_get_free = dsound_buffer_get_free,
706 .get_buffer_out = dsound_get_buffer_out,
707 .put_buffer_out = dsound_put_buffer_out,
708 .enable_out = dsound_enable_out,
709
710 .init_in = dsound_init_in,
711 .fini_in = dsound_fini_in,
712 .read = audio_generic_read,
713 .get_buffer_in = dsound_get_buffer_in,
714 .put_buffer_in = dsound_put_buffer_in,
715 .enable_in = dsound_enable_in,
716 };
717
718 static struct audio_driver dsound_audio_driver = {
719 .name = "dsound",
720 .descr = "DirectSound http://wikipedia.org/wiki/DirectSound",
721 .init = dsound_audio_init,
722 .fini = dsound_audio_fini,
723 .pcm_ops = &dsound_pcm_ops,
724 .can_be_default = 1,
725 .max_voices_out = INT_MAX,
726 .max_voices_in = 1,
727 .voice_size_out = sizeof (DSoundVoiceOut),
728 .voice_size_in = sizeof (DSoundVoiceIn)
729 };
730
731 static void register_audio_dsound(void)
732 {
733 audio_driver_register(&dsound_audio_driver);
734 }
735 type_init(register_audio_dsound);