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