VirtualBox

source: vbox/trunk/src/VBox/Devices/Audio/DrvHostDSound.cpp@ 73643

Last change on this file since 73643 was 73563, checked in by vboxsync, 7 years ago

Audio/DrvHostDSound.cpp: Cleaned up internal state handling by having a dedicated reset and enable/disable function.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 82.3 KB
Line 
1/* $Id: DrvHostDSound.cpp 73563 2018-08-08 13:39:53Z vboxsync $ */
2/** @file
3 * Windows host backend driver using DirectSound.
4 */
5
6/*
7 * Copyright (C) 2006-2018 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18
19/*********************************************************************************************************************************
20* Header Files *
21*********************************************************************************************************************************/
22#define LOG_GROUP LOG_GROUP_DRV_HOST_AUDIO
23#include <VBox/log.h>
24#include <iprt/win/windows.h>
25#include <dsound.h>
26
27#include <iprt/alloc.h>
28#include <iprt/system.h>
29#include <iprt/uuid.h>
30
31#include "DrvAudio.h"
32#include "VBoxDD.h"
33#ifdef VBOX_WITH_AUDIO_MMNOTIFICATION_CLIENT
34# include <new> /* For bad_alloc. */
35# include "VBoxMMNotificationClient.h"
36#endif
37
38
39/*********************************************************************************************************************************
40* Defined Constants And Macros *
41*********************************************************************************************************************************/
42/*
43 * IDirectSound* interface uses HRESULT status codes and the driver callbacks use
44 * the IPRT status codes. To minimize HRESULT->IPRT conversion most internal functions
45 * in the driver return HRESULT and conversion is done in the driver callbacks.
46 *
47 * Naming convention:
48 * 'dsound*' functions return IPRT status code;
49 * 'directSound*' - return HRESULT.
50 */
51
52/*
53 * Optional release logging, which a user can turn on with the
54 * 'VBoxManage debugvm' command.
55 * Debug logging still uses the common Log* macros from IPRT.
56 * Messages which always should go to the release log use LogRel.
57 */
58/* General code behavior. */
59#define DSLOG(a) do { LogRel2(a); } while(0)
60/* Something which produce a lot of logging during playback/recording. */
61#define DSLOGF(a) do { LogRel3(a); } while(0)
62/* Important messages like errors. Limited in the default release log to avoid log flood. */
63#define DSLOGREL(a) \
64 do { \
65 static int8_t s_cLogged = 0; \
66 if (s_cLogged < 8) { \
67 ++s_cLogged; \
68 LogRel(a); \
69 } else DSLOG(a); \
70 } while (0)
71
72/** Maximum number of attempts to restore the sound buffer before giving up. */
73#define DRV_DSOUND_RESTORE_ATTEMPTS_MAX 3
74/** Default input latency (in ms). */
75#define DRV_DSOUND_DEFAULT_LATENCY_MS_IN 50
76/** Default output latency (in ms). */
77#define DRV_DSOUND_DEFAULT_LATENCY_MS_OUT 50
78
79/** Makes DRVHOSTDSOUND out of PDMIHOSTAUDIO. */
80#define PDMIHOSTAUDIO_2_DRVHOSTDSOUND(pInterface) \
81 ( (PDRVHOSTDSOUND)((uintptr_t)pInterface - RT_UOFFSETOF(DRVHOSTDSOUND, IHostAudio)) )
82
83
84/*********************************************************************************************************************************
85* Structures and Typedefs *
86*********************************************************************************************************************************/
87/* Dynamically load dsound.dll. */
88typedef HRESULT WINAPI FNDIRECTSOUNDENUMERATEW(LPDSENUMCALLBACKW pDSEnumCallback, PVOID pContext);
89typedef FNDIRECTSOUNDENUMERATEW *PFNDIRECTSOUNDENUMERATEW;
90typedef HRESULT WINAPI FNDIRECTSOUNDCAPTUREENUMERATEW(LPDSENUMCALLBACKW pDSEnumCallback, PVOID pContext);
91typedef FNDIRECTSOUNDCAPTUREENUMERATEW *PFNDIRECTSOUNDCAPTUREENUMERATEW;
92typedef HRESULT WINAPI FNDIRECTSOUNDCAPTURECREATE8(LPCGUID lpcGUID, LPDIRECTSOUNDCAPTURE8 *lplpDSC, LPUNKNOWN pUnkOuter);
93typedef FNDIRECTSOUNDCAPTURECREATE8 *PFNDIRECTSOUNDCAPTURECREATE8;
94
95#define VBOX_DSOUND_MAX_EVENTS 3
96
97typedef enum DSOUNDEVENT
98{
99 DSOUNDEVENT_NOTIFY = 0,
100 DSOUNDEVENT_INPUT,
101 DSOUNDEVENT_OUTPUT,
102} DSOUNDEVENT;
103
104typedef struct DSOUNDHOSTCFG
105{
106 RTUUID uuidPlay;
107 LPCGUID pGuidPlay;
108 RTUUID uuidCapture;
109 LPCGUID pGuidCapture;
110} DSOUNDHOSTCFG, *PDSOUNDHOSTCFG;
111
112typedef struct DSOUNDSTREAM
113{
114 /** The stream's acquired configuration. */
115 PDMAUDIOSTREAMCFG Cfg;
116 /** Buffer alignment. */
117 uint8_t uAlign;
118 /** Whether this stream is in an enable state on the DirectSound side. */
119 bool fEnabled;
120 /** The stream's critical section for synchronizing access. */
121 RTCRITSECT CritSect;
122 /** The internal playback / capturing buffer. */
123 PRTCIRCBUF pCircBuf;
124 /** Size (in bytes) of the DirectSound buffer.
125 * Note: This in *not* the size of the circular buffer above! */
126 DWORD cbBufSize;
127 union
128 {
129 struct
130 {
131 /** The actual DirectSound Buffer (DSB) used for the capturing.
132 * This is a secondary buffer and is used as a streaming buffer. */
133 LPDIRECTSOUNDCAPTUREBUFFER8 pDSCB;
134 /** Current read offset (in bytes) within the DSB. */
135 DWORD offReadPos;
136 /** Number of buffer overruns happened. Used for logging. */
137 uint8_t cOverruns;
138 } In;
139 struct
140 {
141 /** The actual DirectSound Buffer (DSB) used for playback.
142 * This is a secondary buffer and is used as a streaming buffer. */
143 LPDIRECTSOUNDBUFFER8 pDSB;
144 /** Current write offset (in bytes) within the DSB. */
145 DWORD offWritePos;
146 /** Offset of last play cursor within the DSB when checked for pending. */
147 DWORD offPlayCursorLastPending;
148 /** Offset of last play cursor within the DSB when last played. */
149 DWORD offPlayCursorLastPlayed;
150 /** Total amount (in bytes) written to our internal ring buffer. */
151 uint64_t cbWritten;
152 /** Total amount (in bytes) played (to the DirectSound buffer). */
153 uint64_t cbTransferred;
154 /** Flag indicating whether playback was just (re)started. */
155 bool fFirstTransfer;
156 /** Flag indicating whether this stream is in draining mode, e.g. no new
157 * data is being written to it but DirectSound still needs to be able to
158 * play its remaining (buffered) data. */
159 bool fDrain;
160 /** How much (in bytes) the last transfer from the internal buffer
161 * to the DirectSound buffer was. */
162 uint32_t cbLastTransferred;
163 /** Timestamp (in ms) of the last transfer from the internal buffer
164 * to the DirectSound buffer. */
165 uint64_t tsLastTransferred;
166 /** Number of buffer underruns happened. Used for logging. */
167 uint8_t cUnderruns;
168 } Out;
169 };
170#ifdef LOG_ENABLED
171 struct
172 {
173 uint64_t tsLastTransferredMs;
174 } Dbg;
175#endif
176} DSOUNDSTREAM, *PDSOUNDSTREAM;
177
178typedef struct DRVHOSTDSOUND
179{
180 /** Pointer to the driver instance structure. */
181 PPDMDRVINS pDrvIns;
182 /** Our audio host audio interface. */
183 PDMIHOSTAUDIO IHostAudio;
184 /** Critical section to serialize access. */
185 RTCRITSECT CritSect;
186 /** List of found host input devices. */
187 RTLISTANCHOR lstDevInput;
188 /** List of found host output devices. */
189 RTLISTANCHOR lstDevOutput;
190 /** DirectSound configuration options. */
191 DSOUNDHOSTCFG Cfg;
192 /** Whether this backend supports any audio input. */
193 bool fEnabledIn;
194 /** Whether this backend supports any audio output. */
195 bool fEnabledOut;
196 /** The Direct Sound playback interface. */
197 LPDIRECTSOUND8 pDS;
198 /** The Direct Sound capturing interface. */
199 LPDIRECTSOUNDCAPTURE8 pDSC;
200#ifdef VBOX_WITH_AUDIO_MMNOTIFICATION_CLIENT
201 VBoxMMNotificationClient *m_pNotificationClient;
202#endif
203#ifdef VBOX_WITH_AUDIO_CALLBACKS
204 /** Callback function to the upper driver.
205 * Can be NULL if not being used / registered. */
206 PFNPDMHOSTAUDIOCALLBACK pfnCallback;
207#endif
208 /** Pointer to the input stream. */
209 PDSOUNDSTREAM pDSStrmIn;
210 /** Pointer to the output stream. */
211 PDSOUNDSTREAM pDSStrmOut;
212} DRVHOSTDSOUND, *PDRVHOSTDSOUND;
213
214/** No flags specified. */
215#define DSOUNDENUMCBFLAGS_NONE 0
216/** (Release) log found devices. */
217#define DSOUNDENUMCBFLAGS_LOG RT_BIT(0)
218
219/**
220 * Callback context for enumeration callbacks
221 */
222typedef struct DSOUNDENUMCBCTX
223{
224 /** Pointer to host backend driver. */
225 PDRVHOSTDSOUND pDrv;
226 /** Enumeration flags. */
227 uint32_t fFlags;
228 /** Number of found input devices. */
229 uint8_t cDevIn;
230 /** Number of found output devices. */
231 uint8_t cDevOut;
232} DSOUNDENUMCBCTX, *PDSOUNDENUMCBCTX;
233
234typedef struct DSOUNDDEV
235{
236 RTLISTNODE Node;
237 char *pszName;
238 GUID Guid;
239} DSOUNDDEV, *PDSOUNDDEV;
240
241
242/*********************************************************************************************************************************
243* Internal Functions *
244*********************************************************************************************************************************/
245static HRESULT directSoundPlayRestore(PDRVHOSTDSOUND pThis, LPDIRECTSOUNDBUFFER8 pDSB);
246static HRESULT directSoundPlayStart(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS);
247static HRESULT directSoundPlayStop(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS, bool fFlush);
248static HRESULT directSoundCaptureStop(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS, bool fFlush);
249
250static void dsoundDeviceRemove(PDSOUNDDEV pDev);
251static int dsoundDevicesEnumerate(PDRVHOSTDSOUND pThis, PPDMAUDIOBACKENDCFG pCfg);
252
253static int dsoundStreamEnable(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS, bool fEnable);
254static void dsoundStreamReset(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS);
255static void dsoundUpdateStatusInternal(PDRVHOSTDSOUND pThis);
256static void dsoundUpdateStatusInternalEx(PDRVHOSTDSOUND pThis, PPDMAUDIOBACKENDCFG pCfg, uint32_t fEnum);
257
258
259static DWORD dsoundRingDistance(DWORD offEnd, DWORD offBegin, DWORD cSize)
260{
261 AssertReturn(offEnd <= cSize, 0);
262 AssertReturn(offBegin <= cSize, 0);
263
264 return offEnd >= offBegin ? offEnd - offBegin : cSize - offBegin + offEnd;
265}
266
267static int dsoundWaveFmtFromCfg(PPDMAUDIOSTREAMCFG pCfg, PWAVEFORMATEX pFmt)
268{
269 AssertPtrReturn(pCfg, VERR_INVALID_POINTER);
270 AssertPtrReturn(pFmt, VERR_INVALID_POINTER);
271
272 RT_BZERO(pFmt, sizeof(WAVEFORMATEX));
273
274 pFmt->wFormatTag = WAVE_FORMAT_PCM;
275 pFmt->nChannels = pCfg->Props.cChannels;
276 pFmt->wBitsPerSample = pCfg->Props.cBytes * 8;
277 pFmt->nSamplesPerSec = pCfg->Props.uHz;
278 pFmt->nBlockAlign = pFmt->nChannels * pFmt->wBitsPerSample / 8;
279 pFmt->nAvgBytesPerSec = pFmt->nSamplesPerSec * pFmt->nBlockAlign;
280 pFmt->cbSize = 0; /* No extra data specified. */
281
282 return VINF_SUCCESS;
283}
284
285/**
286 * Retrieves the number of free bytes available for writing to a DirectSound output stream.
287 *
288 * @return IPRT status code. VERR_NOT_AVAILABLE if unable to determine or the buffer was not recoverable.
289 * @param pThis Host audio driver instance.
290 * @param pStreamDS DirectSound output stream to retrieve number for.
291 * @param pdwFree Where to return the free amount on success.
292 */
293static int dsoundGetFreeOut(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS, DWORD *pdwFree)
294{
295 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
296 AssertPtrReturn(pStreamDS, VERR_INVALID_POINTER);
297 AssertPtrReturn(pdwFree, VERR_INVALID_POINTER);
298
299 Assert(pStreamDS->Cfg.enmDir == PDMAUDIODIR_OUT); /* Paranoia. */
300
301 LPDIRECTSOUNDBUFFER8 pDSB = pStreamDS->Out.pDSB;
302 if (!pDSB)
303 {
304 AssertPtr(pDSB);
305 return VERR_INVALID_POINTER;
306 }
307
308 HRESULT hr = S_OK;
309
310 /* Get the current play position which is used for calculating the free space in the buffer. */
311 for (unsigned i = 0; i < DRV_DSOUND_RESTORE_ATTEMPTS_MAX; i++)
312 {
313 DWORD cbPlayCursor, cbWriteCursor;
314 hr = IDirectSoundBuffer8_GetCurrentPosition(pDSB, &cbPlayCursor, &cbWriteCursor);
315 if (SUCCEEDED(hr))
316 {
317 int32_t cbDiff = cbWriteCursor - cbPlayCursor;
318 if (cbDiff < 0)
319 cbDiff += pStreamDS->cbBufSize;
320
321 int32_t cbFree = cbPlayCursor - pStreamDS->Out.offWritePos;
322 if (cbFree < 0)
323 cbFree += pStreamDS->cbBufSize;
324
325 if (cbFree > (int32_t)pStreamDS->cbBufSize - cbDiff)
326 {
327 pStreamDS->Out.offWritePos = cbWriteCursor;
328 cbFree = pStreamDS->cbBufSize - cbDiff;
329 }
330
331 /* When starting to use a DirectSound buffer, cbPlayCursor and cbWriteCursor
332 * both point at position 0, so we won't be able to detect how many bytes
333 * are writable that way.
334 *
335 * So use our per-stream written indicator to see if we just started a stream. */
336 if (pStreamDS->Out.cbWritten == 0)
337 cbFree = pStreamDS->cbBufSize;
338
339 DSLOGREL(("DSound: cbPlayCursor=%RU32, cbWriteCursor=%RU32, offWritePos=%RU32 -> cbFree=%RI32\n",
340 cbPlayCursor, cbWriteCursor, pStreamDS->Out.offWritePos, cbFree));
341
342 *pdwFree = cbFree;
343
344 return VINF_SUCCESS;
345 }
346
347 if (hr != DSERR_BUFFERLOST) /** @todo MSDN doesn't state this error for GetCurrentPosition(). */
348 break;
349
350 LogFunc(("Getting playing position failed due to lost buffer, restoring ...\n"));
351
352 directSoundPlayRestore(pThis, pDSB);
353 }
354
355 if (hr != DSERR_BUFFERLOST) /* Avoid log flooding if the error is still there. */
356 DSLOGREL(("DSound: Getting current playback position failed with %Rhrc\n", hr));
357
358 LogFunc(("Failed with %Rhrc\n", hr));
359
360 return VERR_NOT_AVAILABLE;
361}
362
363static char *dsoundGUIDToUtf8StrA(LPCGUID pGUID)
364{
365 if (pGUID)
366 {
367 LPOLESTR lpOLEStr;
368 HRESULT hr = StringFromCLSID(*pGUID, &lpOLEStr);
369 if (SUCCEEDED(hr))
370 {
371 char *pszGUID;
372 int rc = RTUtf16ToUtf8(lpOLEStr, &pszGUID);
373 CoTaskMemFree(lpOLEStr);
374
375 return RT_SUCCESS(rc) ? pszGUID : NULL;
376 }
377 }
378
379 return RTStrDup("{Default device}");
380}
381
382/**
383 * Clears the list of the host's playback + capturing devices.
384 *
385 * @param pThis Host audio driver instance.
386 */
387static void dsoundDevicesClear(PDRVHOSTDSOUND pThis)
388{
389 AssertPtrReturnVoid(pThis);
390
391 PDSOUNDDEV pDev, pDevNext;
392 RTListForEachSafe(&pThis->lstDevInput, pDev, pDevNext, DSOUNDDEV, Node)
393 dsoundDeviceRemove(pDev);
394
395 Assert(RTListIsEmpty(&pThis->lstDevInput));
396
397 RTListForEachSafe(&pThis->lstDevOutput, pDev, pDevNext, DSOUNDDEV, Node)
398 dsoundDeviceRemove(pDev);
399
400 Assert(RTListIsEmpty(&pThis->lstDevOutput));
401}
402
403static HRESULT directSoundPlayRestore(PDRVHOSTDSOUND pThis, LPDIRECTSOUNDBUFFER8 pDSB)
404{
405 RT_NOREF(pThis);
406 HRESULT hr = IDirectSoundBuffer8_Restore(pDSB);
407 if (FAILED(hr))
408 DSLOG(("DSound: Restoring playback buffer\n"));
409 else
410 DSLOGREL(("DSound: Restoring playback buffer failed with %Rhrc\n", hr));
411
412 return hr;
413}
414
415static HRESULT directSoundPlayUnlock(PDRVHOSTDSOUND pThis, LPDIRECTSOUNDBUFFER8 pDSB,
416 PVOID pv1, PVOID pv2,
417 DWORD cb1, DWORD cb2)
418{
419 RT_NOREF(pThis);
420 HRESULT hr = IDirectSoundBuffer8_Unlock(pDSB, pv1, cb1, pv2, cb2);
421 if (FAILED(hr))
422 DSLOGREL(("DSound: Unlocking playback buffer failed with %Rhrc\n", hr));
423 return hr;
424}
425
426static HRESULT directSoundCaptureUnlock(LPDIRECTSOUNDCAPTUREBUFFER8 pDSCB,
427 PVOID pv1, PVOID pv2,
428 DWORD cb1, DWORD cb2)
429{
430 HRESULT hr = IDirectSoundCaptureBuffer8_Unlock(pDSCB, pv1, cb1, pv2, cb2);
431 if (FAILED(hr))
432 DSLOGREL(("DSound: Unlocking capture buffer failed with %Rhrc\n", hr));
433 return hr;
434}
435
436static HRESULT directSoundPlayLock(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS,
437 DWORD dwOffset, DWORD dwBytes,
438 PVOID *ppv1, PVOID *ppv2,
439 DWORD *pcb1, DWORD *pcb2,
440 DWORD dwFlags)
441{
442 AssertReturn(dwBytes, VERR_INVALID_PARAMETER);
443
444 HRESULT hr = E_FAIL;
445 AssertCompile(DRV_DSOUND_RESTORE_ATTEMPTS_MAX > 0);
446 for (unsigned i = 0; i < DRV_DSOUND_RESTORE_ATTEMPTS_MAX; i++)
447 {
448 PVOID pv1, pv2;
449 DWORD cb1, cb2;
450 hr = IDirectSoundBuffer8_Lock(pStreamDS->Out.pDSB, dwOffset, dwBytes, &pv1, &cb1, &pv2, &cb2, dwFlags);
451 if (SUCCEEDED(hr))
452 {
453 if ( (!pv1 || !(cb1 & pStreamDS->uAlign))
454 && (!pv2 || !(cb2 & pStreamDS->uAlign)))
455 {
456 if (ppv1)
457 *ppv1 = pv1;
458 if (ppv2)
459 *ppv2 = pv2;
460 if (pcb1)
461 *pcb1 = cb1;
462 if (pcb2)
463 *pcb2 = cb2;
464 return S_OK;
465 }
466 DSLOGREL(("DSound: Locking playback buffer returned misaligned buffer: cb1=%#RX32, cb2=%#RX32 (alignment: %#RX32)\n",
467 *pcb1, *pcb2, pStreamDS->uAlign));
468 directSoundPlayUnlock(pThis, pStreamDS->Out.pDSB, pv1, pv2, cb1, cb2);
469 return E_FAIL;
470 }
471
472 if (hr != DSERR_BUFFERLOST)
473 break;
474
475 LogFlowFunc(("Locking failed due to lost buffer, restoring ...\n"));
476 directSoundPlayRestore(pThis, pStreamDS->Out.pDSB);
477 }
478
479 DSLOGREL(("DSound: Locking playback buffer failed with %Rhrc (dwOff=%ld, dwBytes=%ld)\n", hr, dwOffset, dwBytes));
480 return hr;
481}
482
483static HRESULT directSoundCaptureLock(PDSOUNDSTREAM pStreamDS,
484 DWORD dwOffset, DWORD dwBytes,
485 PVOID *ppv1, PVOID *ppv2,
486 DWORD *pcb1, DWORD *pcb2,
487 DWORD dwFlags)
488{
489 PVOID pv1 = NULL;
490 PVOID pv2 = NULL;
491 DWORD cb1 = 0;
492 DWORD cb2 = 0;
493
494 HRESULT hr = IDirectSoundCaptureBuffer8_Lock(pStreamDS->In.pDSCB, dwOffset, dwBytes,
495 &pv1, &cb1, &pv2, &cb2, dwFlags);
496 if (FAILED(hr))
497 {
498 DSLOGREL(("DSound: Locking capture buffer failed with %Rhrc\n", hr));
499 return hr;
500 }
501
502 if ( (pv1 && (cb1 & pStreamDS->uAlign))
503 || (pv2 && (cb2 & pStreamDS->uAlign)))
504 {
505 DSLOGREL(("DSound: Locking capture buffer returned misaligned buffer: cb1=%RI32, cb2=%RI32 (alignment: %RU32)\n",
506 cb1, cb2, pStreamDS->uAlign));
507 directSoundCaptureUnlock(pStreamDS->In.pDSCB, pv1, pv2, cb1, cb2);
508 return E_FAIL;
509 }
510
511 *ppv1 = pv1;
512 *ppv2 = pv2;
513 *pcb1 = cb1;
514 *pcb2 = cb2;
515
516 return S_OK;
517}
518
519/*
520 * DirectSound playback
521 */
522
523static void directSoundPlayInterfaceDestroy(PDRVHOSTDSOUND pThis)
524{
525 if (pThis->pDS)
526 {
527 LogFlowFuncEnter();
528
529 IDirectSound8_Release(pThis->pDS);
530 pThis->pDS = NULL;
531 }
532}
533
534static HRESULT directSoundPlayInterfaceCreate(PDRVHOSTDSOUND pThis)
535{
536 if (pThis->pDS != NULL)
537 return S_OK;
538
539 LogFlowFuncEnter();
540
541 HRESULT hr = CoCreateInstance(CLSID_DirectSound8, NULL, CLSCTX_ALL,
542 IID_IDirectSound8, (void **)&pThis->pDS);
543 if (FAILED(hr))
544 {
545 DSLOGREL(("DSound: Creating playback instance failed with %Rhrc\n", hr));
546 }
547 else
548 {
549 hr = IDirectSound8_Initialize(pThis->pDS, pThis->Cfg.pGuidPlay);
550 if (SUCCEEDED(hr))
551 {
552 HWND hWnd = GetDesktopWindow();
553 hr = IDirectSound8_SetCooperativeLevel(pThis->pDS, hWnd, DSSCL_PRIORITY);
554 if (FAILED(hr))
555 DSLOGREL(("DSound: Setting cooperative level for window %p failed with %Rhrc\n", hWnd, hr));
556 }
557
558 if (FAILED(hr))
559 {
560 if (hr == DSERR_NODRIVER) /* Usually means that no playback devices are attached. */
561 DSLOGREL(("DSound: DirectSound playback is currently unavailable\n"));
562 else
563 DSLOGREL(("DSound: DirectSound playback initialization failed with %Rhrc\n", hr));
564
565 directSoundPlayInterfaceDestroy(pThis);
566 }
567 }
568
569 LogFlowFunc(("Returning %Rhrc\n", hr));
570 return hr;
571}
572
573static HRESULT directSoundPlayClose(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS)
574{
575 AssertPtrReturn(pThis, E_POINTER);
576 AssertPtrReturn(pStreamDS, E_POINTER);
577
578 LogFlowFuncEnter();
579
580 HRESULT hr = directSoundPlayStop(pThis, pStreamDS, true /* fFlush */);
581 if (FAILED(hr))
582 return hr;
583
584 DSLOG(("DSound: Closing playback stream\n"));
585
586 if (pStreamDS->pCircBuf)
587 Assert(RTCircBufUsed(pStreamDS->pCircBuf) == 0);
588
589 if (SUCCEEDED(hr))
590 {
591 RTCritSectEnter(&pThis->CritSect);
592
593 if (pStreamDS->pCircBuf)
594 {
595 RTCircBufDestroy(pStreamDS->pCircBuf);
596 pStreamDS->pCircBuf = NULL;
597 }
598
599 if (pStreamDS->Out.pDSB)
600 {
601 IDirectSoundBuffer8_Release(pStreamDS->Out.pDSB);
602 pStreamDS->Out.pDSB = NULL;
603 }
604
605 pThis->pDSStrmOut = NULL;
606
607 RTCritSectLeave(&pThis->CritSect);
608 }
609
610 if (FAILED(hr))
611 DSLOGREL(("DSound: Stopping playback stream %p failed with %Rhrc\n", pStreamDS, hr));
612
613 return hr;
614}
615
616static HRESULT directSoundPlayOpen(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS,
617 PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
618{
619 AssertPtrReturn(pThis, E_POINTER);
620 AssertPtrReturn(pStreamDS, E_POINTER);
621 AssertPtrReturn(pCfgReq, E_POINTER);
622 AssertPtrReturn(pCfgAcq, E_POINTER);
623
624 LogFlowFuncEnter();
625
626 Assert(pStreamDS->Out.pDSB == NULL);
627
628 DSLOG(("DSound: Opening playback stream (uHz=%RU32, cChannels=%RU8, cBits=%RU8, fSigned=%RTbool)\n",
629 pCfgReq->Props.uHz,
630 pCfgReq->Props.cChannels,
631 pCfgReq->Props.cBytes * 8,
632 pCfgReq->Props.fSigned));
633
634 WAVEFORMATEX wfx;
635 int rc = dsoundWaveFmtFromCfg(pCfgReq, &wfx);
636 if (RT_FAILURE(rc))
637 return E_INVALIDARG;
638
639 DSLOG(("DSound: Requested playback format:\n"
640 " wFormatTag = %RI16\n"
641 " nChannels = %RI16\n"
642 " nSamplesPerSec = %RU32\n"
643 " nAvgBytesPerSec = %RU32\n"
644 " nBlockAlign = %RI16\n"
645 " wBitsPerSample = %RI16\n"
646 " cbSize = %RI16\n",
647 wfx.wFormatTag,
648 wfx.nChannels,
649 wfx.nSamplesPerSec,
650 wfx.nAvgBytesPerSec,
651 wfx.nBlockAlign,
652 wfx.wBitsPerSample,
653 wfx.cbSize));
654
655 dsoundUpdateStatusInternal(pThis);
656
657 HRESULT hr = directSoundPlayInterfaceCreate(pThis);
658 if (FAILED(hr))
659 return hr;
660
661 do /* To use breaks. */
662 {
663 LPDIRECTSOUNDBUFFER pDSB = NULL;
664
665 DSBUFFERDESC bd;
666 RT_ZERO(bd);
667 bd.dwSize = sizeof(bd);
668 bd.lpwfxFormat = &wfx;
669
670 /*
671 * As we reuse our (secondary) buffer for playing out data as it comes in,
672 * we're using this buffer as a so-called streaming buffer.
673 *
674 * See https://msdn.microsoft.com/en-us/library/windows/desktop/ee419014(v=vs.85).aspx
675 *
676 * However, as we do not want to use memory on the sound device directly
677 * (as most modern audio hardware on the host doesn't have this anyway),
678 * we're *not* going to use DSBCAPS_STATIC for that.
679 *
680 * Instead we're specifying DSBCAPS_LOCSOFTWARE, as this fits the bill
681 * of copying own buffer data to our secondary's Direct Sound buffer.
682 */
683 bd.dwFlags = DSBCAPS_GLOBALFOCUS | DSBCAPS_GETCURRENTPOSITION2 | DSBCAPS_LOCSOFTWARE;
684 bd.dwBufferBytes = DrvAudioHlpFramesToBytes(pCfgReq->Backend.cfBufferSize, &pCfgReq->Props);
685
686 DSLOG(("DSound: Requested playback buffer is %RU64ms (%ld bytes)\n",
687 DrvAudioHlpBytesToMilli(bd.dwBufferBytes, &pCfgReq->Props), bd.dwBufferBytes));
688
689 hr = IDirectSound8_CreateSoundBuffer(pThis->pDS, &bd, &pDSB, NULL);
690 if (FAILED(hr))
691 {
692 DSLOGREL(("DSound: Creating playback sound buffer failed with %Rhrc\n", hr));
693 break;
694 }
695
696 /* "Upgrade" to IDirectSoundBuffer8 interface. */
697 hr = IDirectSoundBuffer_QueryInterface(pDSB, IID_IDirectSoundBuffer8, (PVOID *)&pStreamDS->Out.pDSB);
698 IDirectSoundBuffer_Release(pDSB);
699 if (FAILED(hr))
700 {
701 DSLOGREL(("DSound: Querying playback sound buffer interface failed with %Rhrc\n", hr));
702 break;
703 }
704
705 /*
706 * Query the actual parameters set for this stream.
707 * Those might be different than the initially requested parameters.
708 */
709 RT_ZERO(wfx);
710 hr = IDirectSoundBuffer8_GetFormat(pStreamDS->Out.pDSB, &wfx, sizeof(wfx), NULL);
711 if (FAILED(hr))
712 {
713 DSLOGREL(("DSound: Getting playback format failed with %Rhrc\n", hr));
714 break;
715 }
716
717 DSBCAPS bc;
718 RT_ZERO(bc);
719 bc.dwSize = sizeof(bc);
720
721 hr = IDirectSoundBuffer8_GetCaps(pStreamDS->Out.pDSB, &bc);
722 if (FAILED(hr))
723 {
724 DSLOGREL(("DSound: Getting playback capabilities failed with %Rhrc\n", hr));
725 break;
726 }
727
728 DSLOG(("DSound: Acquired playback buffer is %RU64ms (%ld bytes)\n",
729 DrvAudioHlpBytesToMilli(bc.dwBufferBytes, &pCfgReq->Props), bc.dwBufferBytes));
730
731 DSLOG(("DSound: Acquired playback format:\n"
732 " dwBufferBytes = %RI32\n"
733 " dwFlags = 0x%x\n"
734 " wFormatTag = %RI16\n"
735 " nChannels = %RI16\n"
736 " nSamplesPerSec = %RU32\n"
737 " nAvgBytesPerSec = %RU32\n"
738 " nBlockAlign = %RI16\n"
739 " wBitsPerSample = %RI16\n"
740 " cbSize = %RI16\n",
741 bc.dwBufferBytes,
742 bc.dwFlags,
743 wfx.wFormatTag,
744 wfx.nChannels,
745 wfx.nSamplesPerSec,
746 wfx.nAvgBytesPerSec,
747 wfx.nBlockAlign,
748 wfx.wBitsPerSample,
749 wfx.cbSize));
750
751 if (bc.dwBufferBytes & pStreamDS->uAlign)
752 DSLOGREL(("DSound: Playback capabilities returned misaligned buffer: size %RU32, alignment %RU32\n",
753 bc.dwBufferBytes, pStreamDS->uAlign + 1));
754
755 /*
756 * Initial state.
757 * dsoundPlayStart initializes part of it to make sure that Stop/Start continues with a correct
758 * playback buffer position.
759 */
760 pStreamDS->cbBufSize = bc.dwBufferBytes;
761
762 rc = RTCircBufCreate(&pStreamDS->pCircBuf, pStreamDS->cbBufSize) * 2; /* Use "double buffering" */
763 AssertRC(rc);
764
765 pThis->pDSStrmOut = pStreamDS;
766
767 pCfgAcq->Backend.cfBufferSize = PDMAUDIOSTREAMCFG_B2F(pCfgAcq, pStreamDS->cbBufSize);
768 pCfgAcq->Backend.cfPeriod = pCfgAcq->Backend.cfBufferSize / 2;
769 pCfgAcq->Backend.cfPreBuf = pCfgAcq->Backend.cfBufferSize;
770
771 } while (0);
772
773 if (FAILED(hr))
774 directSoundPlayClose(pThis, pStreamDS);
775
776 return hr;
777}
778
779static void dsoundPlayClearBuffer(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS)
780{
781 AssertPtrReturnVoid(pStreamDS);
782
783 PPDMAUDIOPCMPROPS pProps = &pStreamDS->Cfg.Props;
784
785 HRESULT hr = IDirectSoundBuffer_SetCurrentPosition(pStreamDS->Out.pDSB, 0 /* Position */);
786 if (FAILED(hr))
787 DSLOGREL(("DSound: Setting current position to 0 when clearing buffer failed with %Rhrc\n", hr));
788
789 PVOID pv1;
790 hr = directSoundPlayLock(pThis, pStreamDS,
791 0 /* dwOffset */, pStreamDS->cbBufSize,
792 &pv1, NULL, 0, 0, DSBLOCK_ENTIREBUFFER);
793 if (SUCCEEDED(hr))
794 {
795 DrvAudioHlpClearBuf(pProps, pv1, pStreamDS->cbBufSize, PDMAUDIOPCMPROPS_B2F(pProps, pStreamDS->cbBufSize));
796
797 directSoundPlayUnlock(pThis, pStreamDS->Out.pDSB, pv1, NULL, 0, 0);
798
799 /* Make sure to get the last playback position and current write position from DirectSound again.
800 * Those positions in theory could have changed, re-fetch them to be sure. */
801 hr = IDirectSoundBuffer_GetCurrentPosition(pStreamDS->Out.pDSB,
802 &pStreamDS->Out.offPlayCursorLastPlayed, &pStreamDS->Out.offWritePos);
803 if (FAILED(hr))
804 DSLOGREL(("DSound: Re-fetching current position when clearing buffer failed with %Rhrc\n", hr));
805 }
806}
807
808/**
809 * Transfers audio data from the internal buffer to the DirectSound playback instance.
810 * Due to internal accounting and querying DirectSound, this function knows how much it can transfer at once.
811 *
812 * @return IPRT status code.
813 * @param pThis Host audio driver instance.
814 * @param pStreamDS Stream to transfer playback data for.
815 */
816static int dsoundPlayTransfer(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS)
817{
818 if (!pStreamDS->fEnabled)
819 {
820 Log2Func(("Stream disabled, skipping\n"));
821 return VINF_SUCCESS;
822 }
823
824 uint32_t cbTransferred = 0;
825
826 PRTCIRCBUF pCircBuf = pStreamDS->pCircBuf;
827 AssertPtr(pCircBuf);
828
829 LPDIRECTSOUNDBUFFER8 pDSB = pStreamDS->Out.pDSB;
830 AssertPtr(pDSB);
831
832 int rc = VINF_SUCCESS;
833
834 DWORD offPlayCursor, offWriteCursor;
835 HRESULT hr = IDirectSoundBuffer8_GetCurrentPosition(pDSB, &offPlayCursor, &offWriteCursor);
836 if (FAILED(hr))
837 {
838 rc = VERR_ACCESS_DENIED; /** @todo Find a better rc. */
839 return rc;
840 }
841
842 DWORD cbFree, cbRemaining;
843 if (pStreamDS->Out.fFirstTransfer)
844 {
845 cbRemaining = 0;
846 cbFree = pStreamDS->cbBufSize;
847 }
848 else
849 {
850 cbFree = dsoundRingDistance(offPlayCursor, pStreamDS->Out.offWritePos, pStreamDS->cbBufSize);
851 cbRemaining = dsoundRingDistance(pStreamDS->Out.offWritePos, offPlayCursor, pStreamDS->cbBufSize);
852 }
853
854 uint32_t cbAvail = (uint32_t)RTCircBufUsed(pCircBuf);
855 uint32_t cbToTransfer = RT_MIN(cbFree, cbAvail);
856
857#ifdef LOG_ENABLED
858 if (!pStreamDS->Dbg.tsLastTransferredMs)
859 pStreamDS->Dbg.tsLastTransferredMs = RTTimeMilliTS();
860 Log3Func(("offPlay=%RU32, offWrite=%RU32, tsLastTransferredMs=%RU64ms, cbAvail=%RU32, cbFree=%RU32 -> cbToTransfer=%RU32 "
861 "(fFirst=%RTbool, fDrain=%RTbool)\n",
862 offPlayCursor, offWriteCursor, RTTimeMilliTS() - pStreamDS->Dbg.tsLastTransferredMs, cbAvail, cbFree, cbToTransfer,
863 pStreamDS->Out.fFirstTransfer, pStreamDS->Out.fDrain));
864 pStreamDS->Dbg.tsLastTransferredMs = RTTimeMilliTS();
865#endif
866
867 /* Only transfer anything if we have enough data for a DirectSound stream's period *and* are not
868 * in draining mode (already). */
869 if ( !pStreamDS->Out.fDrain
870 && cbToTransfer < DrvAudioHlpFramesToBytes(pStreamDS->Cfg.Backend.cfPeriod, &pStreamDS->Cfg.Props))
871 return VINF_SUCCESS;
872
873 while (cbToTransfer)
874 {
875 DWORD cb1 = 0;
876 DWORD cb2 = 0;
877
878 void *pvBuf;
879 size_t cbBuf;
880 RTCircBufAcquireReadBlock(pCircBuf, cbToTransfer, &pvBuf, &cbBuf);
881
882 if (cbBuf)
883 {
884 PVOID pv1, pv2;
885 hr = directSoundPlayLock(pThis, pStreamDS, pStreamDS->Out.offWritePos, (DWORD)cbBuf,
886 &pv1, &pv2, &cb1, &cb2, 0 /* dwFlags */);
887 if (FAILED(hr))
888 {
889 rc = VERR_ACCESS_DENIED;
890 break;
891 }
892
893 AssertPtr(pv1);
894 Assert(cb1);
895
896 memcpy(pv1, pvBuf, cb1);
897
898 if (pv2 && cb2) /* Buffer wrap-around? Write second part. */
899 memcpy(pv2, (uint8_t *)pvBuf + cb1, cb2);
900
901 directSoundPlayUnlock(pThis, pDSB, pv1, pv2, cb1, cb2);
902
903 pStreamDS->Out.offWritePos = (pStreamDS->Out.offWritePos + cb1 + cb2) % pStreamDS->cbBufSize;
904
905 Assert(cbToTransfer >= cbBuf);
906 cbToTransfer -= (uint32_t)cbBuf;
907
908 cbTransferred += cb1 + cb2;
909 }
910
911 RTCircBufReleaseReadBlock(pCircBuf, cb1 + cb2);
912 }
913
914 pStreamDS->Out.cbTransferred += cbTransferred;
915
916 if ( pStreamDS->Out.fFirstTransfer
917 && pStreamDS->Out.cbTransferred >= DrvAudioHlpFramesToBytes(pStreamDS->Cfg.Backend.cfPreBuf, &pStreamDS->Cfg.Props))
918 {
919 hr = directSoundPlayStart(pThis, pStreamDS);
920 if (SUCCEEDED(hr))
921 {
922 pStreamDS->Out.fFirstTransfer = false;
923 }
924 else
925 rc = VERR_ACCESS_DENIED; /** @todo Find a better rc. */
926 }
927
928 cbAvail = (uint32_t)RTCircBufUsed(pCircBuf);
929 if ( !cbAvail
930 && cbTransferred)
931 {
932 pStreamDS->Out.cbLastTransferred = cbTransferred;
933 pStreamDS->Out.tsLastTransferred = RTTimeMilliTS();
934 }
935
936 LogFlowFunc(("cbTransferred=%RU32, cbAvail=%RU32, rc=%Rrc\n", cbTransferred, cbAvail, rc));
937 return rc;
938}
939
940static HRESULT directSoundPlayGetStatus(PDRVHOSTDSOUND pThis, LPDIRECTSOUNDBUFFER8 pDSB, DWORD *pdwStatus)
941{
942 AssertPtrReturn(pThis, E_POINTER);
943 AssertPtrReturn(pDSB, E_POINTER);
944
945 AssertPtrNull(pdwStatus);
946
947 DWORD dwStatus = 0;
948 HRESULT hr = E_FAIL;
949 for (unsigned i = 0; i < DRV_DSOUND_RESTORE_ATTEMPTS_MAX; i++)
950 {
951 hr = IDirectSoundBuffer8_GetStatus(pDSB, &dwStatus);
952 if ( hr == DSERR_BUFFERLOST
953 || ( SUCCEEDED(hr)
954 && (dwStatus & DSBSTATUS_BUFFERLOST)))
955 {
956 LogFlowFunc(("Getting status failed due to lost buffer, restoring ...\n"));
957 directSoundPlayRestore(pThis, pDSB);
958 }
959 else
960 break;
961 }
962
963 if (SUCCEEDED(hr))
964 {
965 if (pdwStatus)
966 *pdwStatus = dwStatus;
967 }
968 else
969 DSLOGREL(("DSound: Retrieving playback status failed with %Rhrc\n", hr));
970
971 return hr;
972}
973
974static HRESULT directSoundPlayStop(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS, bool fFlush)
975{
976 AssertPtrReturn(pThis, E_POINTER);
977 AssertPtrReturn(pStreamDS, E_POINTER);
978
979 HRESULT hr = S_OK;
980
981 if (pStreamDS->Out.pDSB)
982 {
983 DSLOG(("DSound: Stopping playback\n"));
984 hr = IDirectSoundBuffer8_Stop(pStreamDS->Out.pDSB);
985 if (FAILED(hr))
986 {
987 hr = directSoundPlayRestore(pThis, pStreamDS->Out.pDSB);
988 if (FAILED(hr))
989 hr = IDirectSoundBuffer8_Stop(pStreamDS->Out.pDSB);
990 }
991 }
992
993 if (SUCCEEDED(hr))
994 {
995 if (fFlush)
996 dsoundStreamReset(pThis, pStreamDS);
997 }
998
999 if (FAILED(hr))
1000 DSLOGREL(("DSound: %s playback failed with %Rhrc\n", fFlush ? "Stopping" : "Pausing", hr));
1001
1002 return hr;
1003}
1004
1005/**
1006 * Enables or disables a stream.
1007 *
1008 * @return IPRT status code.
1009 * @param pThis Host audio driver instance.
1010 * @param pStreamDS Stream to enable / disable.
1011 * @param fEnable Whether to enable or disable the stream.
1012 */
1013static int dsoundStreamEnable(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS, bool fEnable)
1014{
1015 RT_NOREF(pThis);
1016
1017 LogFunc(("%s %s\n",
1018 fEnable ? "Enabling" : "Disabling",
1019 pStreamDS->Cfg.enmDir == PDMAUDIODIR_IN ? "capture" : "playback"));
1020
1021 pStreamDS->fEnabled = fEnable;
1022
1023 return VINF_SUCCESS;
1024}
1025
1026
1027/**
1028 * Resets the state of a DirectSound stream.
1029 *
1030 * @param pThis Host audio driver instance.
1031 * @param pStreamDS Stream to reset state for.
1032 */
1033static void dsoundStreamReset(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS)
1034{
1035 RT_NOREF(pThis);
1036
1037 LogFunc(("Resetting %s\n",
1038 pStreamDS->Cfg.enmDir == PDMAUDIODIR_IN ? "capture" : "playback"));
1039
1040 if (pStreamDS->pCircBuf)
1041 RTCircBufReset(pStreamDS->pCircBuf);
1042
1043 if (pStreamDS->Cfg.enmDir == PDMAUDIODIR_IN)
1044 {
1045 pStreamDS->In.offReadPos = 0;
1046 pStreamDS->In.cOverruns = 0;
1047 }
1048 else if (pStreamDS->Cfg.enmDir == PDMAUDIODIR_OUT)
1049 {
1050 pStreamDS->Out.fFirstTransfer = true;
1051 pStreamDS->Out.fDrain = false;
1052 pStreamDS->Out.cUnderruns = 0;
1053
1054 pStreamDS->Out.cbLastTransferred = 0;
1055 pStreamDS->Out.tsLastTransferred = 0;
1056
1057 pStreamDS->Out.cbTransferred = 0;
1058 pStreamDS->Out.cbWritten = 0;
1059
1060 pStreamDS->Out.offWritePos = 0;
1061 pStreamDS->Out.offPlayCursorLastPending = 0;
1062 pStreamDS->Out.offPlayCursorLastPlayed = 0;
1063 }
1064 else
1065 AssertFailed();
1066
1067#ifdef LOG_ENABLED
1068 pStreamDS->Dbg.tsLastTransferredMs = 0;
1069#endif
1070}
1071
1072
1073/**
1074 * Starts playing a DirectSound stream.
1075 *
1076 * @return HRESULT
1077 * @param pThis Host audio driver instance.
1078 * @param pStreamDS Stream to start playing.
1079 */
1080static HRESULT directSoundPlayStart(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS)
1081{
1082 HRESULT hr = S_OK;
1083
1084 DWORD fFlags = DSCBSTART_LOOPING;
1085
1086 for (unsigned i = 0; i < DRV_DSOUND_RESTORE_ATTEMPTS_MAX; i++)
1087 {
1088 DSLOG(("DSound: Starting playback\n"));
1089 hr = IDirectSoundBuffer8_Play(pStreamDS->Out.pDSB, 0, 0, fFlags);
1090 if ( SUCCEEDED(hr)
1091 || hr != DSERR_BUFFERLOST)
1092 break;
1093 else
1094 {
1095 LogFunc(("Restarting playback failed due to lost buffer, restoring ...\n"));
1096 directSoundPlayRestore(pThis, pStreamDS->Out.pDSB);
1097 }
1098 }
1099
1100 return hr;
1101}
1102
1103
1104/*
1105 * DirectSoundCapture
1106 */
1107
1108static LPCGUID dsoundCaptureSelectDevice(PDRVHOSTDSOUND pThis, PPDMAUDIOSTREAMCFG pCfg)
1109{
1110 AssertPtrReturn(pThis, NULL);
1111 AssertPtrReturn(pCfg, NULL);
1112
1113 int rc = VINF_SUCCESS;
1114
1115 LPCGUID pGUID = pThis->Cfg.pGuidCapture;
1116 if (!pGUID)
1117 {
1118 PDSOUNDDEV pDev = NULL;
1119
1120 switch (pCfg->DestSource.Source)
1121 {
1122 case PDMAUDIORECSOURCE_LINE:
1123 /*
1124 * At the moment we're only supporting line-in in the HDA emulation,
1125 * and line-in + mic-in in the AC'97 emulation both are expected
1126 * to use the host's mic-in as well.
1127 *
1128 * So the fall through here is intentional for now.
1129 */
1130 case PDMAUDIORECSOURCE_MIC:
1131 {
1132 RTListForEach(&pThis->lstDevInput, pDev, DSOUNDDEV, Node)
1133 {
1134 if (RTStrIStr(pDev->pszName, "Mic")) /** @todo What is with non en_us windows versions? */
1135 break;
1136 }
1137
1138 if (RTListNodeIsDummy(&pThis->lstDevInput, pDev, DSOUNDDEV, Node))
1139 pDev = NULL; /* Found nothing. */
1140
1141 break;
1142 }
1143
1144 default:
1145 AssertFailedStmt(rc = VERR_NOT_SUPPORTED);
1146 break;
1147 }
1148
1149 if ( RT_SUCCESS(rc)
1150 && pDev)
1151 {
1152 DSLOG(("DSound: Guest source '%s' is using host recording device '%s'\n",
1153 DrvAudioHlpRecSrcToStr(pCfg->DestSource.Source), pDev->pszName));
1154
1155 pGUID = &pDev->Guid;
1156 }
1157 }
1158
1159 if (RT_FAILURE(rc))
1160 {
1161 LogRel(("DSound: Selecting recording device failed with %Rrc\n", rc));
1162 return NULL;
1163 }
1164
1165 char *pszGUID = dsoundGUIDToUtf8StrA(pGUID);
1166
1167 /* This always has to be in the release log. */
1168 LogRel(("DSound: Guest source '%s' is using host recording device with GUID '%s'\n",
1169 DrvAudioHlpRecSrcToStr(pCfg->DestSource.Source), pszGUID ? pszGUID: "{?}"));
1170
1171 if (pszGUID)
1172 {
1173 RTStrFree(pszGUID);
1174 pszGUID = NULL;
1175 }
1176
1177 return pGUID;
1178}
1179
1180/**
1181 * Transfers audio data from the DirectSound capture instance to the internal buffer.
1182 * Due to internal accounting and querying DirectSound, this function knows how much it can transfer at once.
1183 *
1184 * @return IPRT status code.
1185 * @param pThis Host audio driver instance.
1186 * @param pStreamDS Stream to capture audio data for.
1187 */
1188static int dsoundCaptureTransfer(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS)
1189{
1190 RT_NOREF(pThis);
1191
1192 LPDIRECTSOUNDCAPTUREBUFFER8 pDSCB = pStreamDS->In.pDSCB;
1193 AssertPtr(pDSCB);
1194
1195 DWORD offCaptureCursor;
1196 HRESULT hr = IDirectSoundCaptureBuffer_GetCurrentPosition(pDSCB, NULL, &offCaptureCursor);
1197 if (FAILED(hr))
1198 {
1199 AssertFailed();
1200 return VERR_ACCESS_DENIED; /** @todo Find a better rc. */
1201 }
1202
1203 DWORD cbUsed = dsoundRingDistance(offCaptureCursor, pStreamDS->In.offReadPos, pStreamDS->cbBufSize);
1204
1205 PRTCIRCBUF pCircBuf = pStreamDS->pCircBuf;
1206 AssertPtr(pCircBuf);
1207
1208 uint32_t cbFree = (uint32_t)RTCircBufFree(pCircBuf);
1209 if ( !cbFree
1210 || pStreamDS->In.cOverruns < 32) /** @todo Make this configurable. */
1211 {
1212 DSLOG(("DSound: Warning: Capture buffer full, skipping to record data (%RU32 bytes)\n", cbUsed));
1213 pStreamDS->In.cOverruns++;
1214 }
1215
1216 DWORD cbToCapture = RT_MIN(cbUsed, cbFree);
1217
1218 Log3Func(("cbUsed=%ld, cbToCapture=%ld\n", cbUsed, cbToCapture));
1219
1220 while (cbToCapture)
1221 {
1222 void *pvBuf;
1223 size_t cbBuf;
1224 RTCircBufAcquireWriteBlock(pCircBuf, cbToCapture, &pvBuf, &cbBuf);
1225
1226 if (cbBuf)
1227 {
1228 PVOID pv1, pv2;
1229 DWORD cb1, cb2;
1230 hr = directSoundCaptureLock(pStreamDS, pStreamDS->In.offReadPos, (DWORD)cbBuf,
1231 &pv1, &pv2, &cb1, &cb2, 0 /* dwFlags */);
1232 if (FAILED(hr))
1233 break;
1234
1235 AssertPtr(pv1);
1236 Assert(cb1);
1237
1238 memcpy(pvBuf, pv1, cb1);
1239
1240 if (pv2 && cb2) /* Buffer wrap-around? Write second part. */
1241 memcpy((uint8_t *)pvBuf + cb1, pv2, cb2);
1242
1243 directSoundCaptureUnlock(pDSCB, pv1, pv2, cb1, cb2);
1244
1245 pStreamDS->In.offReadPos = (pStreamDS->In.offReadPos + cb1 + cb2) % pStreamDS->cbBufSize;
1246
1247 Assert(cbToCapture >= cbBuf);
1248 cbToCapture -= (uint32_t)cbBuf;
1249 }
1250
1251#ifdef VBOX_AUDIO_DEBUG_DUMP_PCM_DATA
1252 if (cbBuf)
1253 {
1254 RTFILE fh;
1255 int rc2 = RTFileOpen(&fh, VBOX_AUDIO_DEBUG_DUMP_PCM_DATA_PATH "dsoundCapture.pcm",
1256 RTFILE_O_OPEN_CREATE | RTFILE_O_APPEND | RTFILE_O_WRITE | RTFILE_O_DENY_NONE);
1257 if (RT_SUCCESS(rc2))
1258 {
1259 RTFileWrite(fh, pvBuf, cbBuf, NULL);
1260 RTFileClose(fh);
1261 }
1262 }
1263#endif
1264 RTCircBufReleaseWriteBlock(pCircBuf, cbBuf);
1265 }
1266
1267 return VINF_SUCCESS;
1268}
1269
1270/**
1271 * Destroys the DirectSound capturing interface.
1272 *
1273 * @return IPRT status code.
1274 * @param pThis Driver instance to destroy capturing interface for.
1275 */
1276static void directSoundCaptureInterfaceDestroy(PDRVHOSTDSOUND pThis)
1277{
1278 if (pThis->pDSC)
1279 {
1280 LogFlowFuncEnter();
1281
1282 IDirectSoundCapture_Release(pThis->pDSC);
1283 pThis->pDSC = NULL;
1284 }
1285}
1286
1287/**
1288 * Creates the DirectSound capturing interface.
1289 *
1290 * @return IPRT status code.
1291 * @param pThis Driver instance to create the capturing interface for.
1292 * @param pCfg Audio stream to use for creating the capturing interface.
1293 */
1294static HRESULT directSoundCaptureInterfaceCreate(PDRVHOSTDSOUND pThis, PPDMAUDIOSTREAMCFG pCfg)
1295{
1296 AssertPtrReturn(pThis, E_POINTER);
1297 AssertPtrReturn(pCfg, E_POINTER);
1298
1299 if (pThis->pDSC)
1300 return S_OK;
1301
1302 LogFlowFuncEnter();
1303
1304 HRESULT hr = CoCreateInstance(CLSID_DirectSoundCapture8, NULL, CLSCTX_ALL,
1305 IID_IDirectSoundCapture8, (void **)&pThis->pDSC);
1306 if (FAILED(hr))
1307 {
1308 DSLOGREL(("DSound: Creating capture instance failed with %Rhrc\n", hr));
1309 }
1310 else
1311 {
1312 LPCGUID pGUID = dsoundCaptureSelectDevice(pThis, pCfg);
1313 /* pGUID can be NULL when using the default device. */
1314
1315 hr = IDirectSoundCapture_Initialize(pThis->pDSC, pGUID);
1316 if (FAILED(hr))
1317 {
1318 if (hr == DSERR_NODRIVER) /* Usually means that no capture devices are attached. */
1319 DSLOGREL(("DSound: Capture device currently is unavailable\n"));
1320 else
1321 DSLOGREL(("DSound: Initializing capturing device failed with %Rhrc\n", hr));
1322
1323 directSoundCaptureInterfaceDestroy(pThis);
1324 }
1325 }
1326
1327 LogFlowFunc(("Returning %Rhrc\n", hr));
1328 return hr;
1329}
1330
1331static HRESULT directSoundCaptureClose(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS)
1332{
1333 AssertPtrReturn(pThis, E_POINTER);
1334 AssertPtrReturn(pStreamDS, E_POINTER);
1335
1336 LogFlowFuncEnter();
1337
1338 HRESULT hr = directSoundCaptureStop(pThis, pStreamDS, true /* fFlush */);
1339 if (FAILED(hr))
1340 return hr;
1341
1342 if ( pStreamDS
1343 && pStreamDS->In.pDSCB)
1344 {
1345 DSLOG(("DSound: Closing capturing stream\n"));
1346
1347 IDirectSoundCaptureBuffer8_Release(pStreamDS->In.pDSCB);
1348 pStreamDS->In.pDSCB = NULL;
1349 }
1350
1351 LogFlowFunc(("Returning %Rhrc\n", hr));
1352 return hr;
1353}
1354
1355static HRESULT directSoundCaptureOpen(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS,
1356 PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
1357{
1358 AssertPtrReturn(pThis, E_POINTER);
1359 AssertPtrReturn(pStreamDS, E_POINTER);
1360 AssertPtrReturn(pCfgReq, E_POINTER);
1361 AssertPtrReturn(pCfgAcq, E_POINTER);
1362
1363 LogFlowFuncEnter();
1364
1365 Assert(pStreamDS->In.pDSCB == NULL);
1366
1367 DSLOG(("DSound: Opening capturing stream (uHz=%RU32, cChannels=%RU8, cBits=%RU8, fSigned=%RTbool)\n",
1368 pCfgReq->Props.uHz,
1369 pCfgReq->Props.cChannels,
1370 pCfgReq->Props.cBytes * 8,
1371 pCfgReq->Props.fSigned));
1372
1373 WAVEFORMATEX wfx;
1374 int rc = dsoundWaveFmtFromCfg(pCfgReq, &wfx);
1375 if (RT_FAILURE(rc))
1376 return E_INVALIDARG;
1377
1378 dsoundUpdateStatusInternalEx(pThis, NULL /* Cfg */, DSOUNDENUMCBFLAGS_LOG /* fEnum */);
1379
1380 HRESULT hr = directSoundCaptureInterfaceCreate(pThis, pCfgReq);
1381 if (FAILED(hr))
1382 return hr;
1383
1384 do /* To use breaks. */
1385 {
1386 DSCBUFFERDESC bd;
1387 RT_ZERO(bd);
1388
1389 bd.dwSize = sizeof(bd);
1390 bd.lpwfxFormat = &wfx;
1391 bd.dwBufferBytes = DrvAudioHlpFramesToBytes(pCfgReq->Backend.cfBufferSize, &pCfgReq->Props);
1392
1393 DSLOG(("DSound: Requested capture buffer is %RU64ms (%ld bytes)\n",
1394 DrvAudioHlpBytesToMilli(bd.dwBufferBytes, &pCfgReq->Props), bd.dwBufferBytes));
1395
1396 LPDIRECTSOUNDCAPTUREBUFFER pDSCB;
1397 hr = IDirectSoundCapture_CreateCaptureBuffer(pThis->pDSC, &bd, &pDSCB, NULL);
1398 if (FAILED(hr))
1399 {
1400 if (hr == E_ACCESSDENIED)
1401 {
1402 DSLOGREL(("DSound: Capturing input from host not possible, access denied\n"));
1403 }
1404 else
1405 DSLOGREL(("DSound: Creating capture buffer failed with %Rhrc\n", hr));
1406 break;
1407 }
1408
1409 hr = IDirectSoundCaptureBuffer_QueryInterface(pDSCB, IID_IDirectSoundCaptureBuffer8, (void **)&pStreamDS->In.pDSCB);
1410 IDirectSoundCaptureBuffer_Release(pDSCB);
1411 if (FAILED(hr))
1412 {
1413 DSLOGREL(("DSound: Querying interface for capture buffer failed with %Rhrc\n", hr));
1414 break;
1415 }
1416
1417 /*
1418 * Query the actual parameters.
1419 */
1420 DWORD offByteReadPos = 0;
1421 hr = IDirectSoundCaptureBuffer8_GetCurrentPosition(pStreamDS->In.pDSCB, NULL, &offByteReadPos);
1422 if (FAILED(hr))
1423 {
1424 offByteReadPos = 0;
1425 DSLOGREL(("DSound: Getting capture position failed with %Rhrc\n", hr));
1426 }
1427
1428 RT_ZERO(wfx);
1429 hr = IDirectSoundCaptureBuffer8_GetFormat(pStreamDS->In.pDSCB, &wfx, sizeof(wfx), NULL);
1430 if (FAILED(hr))
1431 {
1432 DSLOGREL(("DSound: Getting capture format failed with %Rhrc\n", hr));
1433 break;
1434 }
1435
1436 DSCBCAPS bc;
1437 RT_ZERO(bc);
1438 bc.dwSize = sizeof(bc);
1439 hr = IDirectSoundCaptureBuffer8_GetCaps(pStreamDS->In.pDSCB, &bc);
1440 if (FAILED(hr))
1441 {
1442 DSLOGREL(("DSound: Getting capture capabilities failed with %Rhrc\n", hr));
1443 break;
1444 }
1445
1446 DSLOG(("DSound: Acquired capture buffer is %RU64ms (%ld bytes)\n",
1447 DrvAudioHlpBytesToMilli(bc.dwBufferBytes, &pCfgReq->Props), bc.dwBufferBytes));
1448
1449 DSLOG(("DSound: Capture format:\n"
1450 " dwBufferBytes = %RI32\n"
1451 " dwFlags = 0x%x\n"
1452 " wFormatTag = %RI16\n"
1453 " nChannels = %RI16\n"
1454 " nSamplesPerSec = %RU32\n"
1455 " nAvgBytesPerSec = %RU32\n"
1456 " nBlockAlign = %RI16\n"
1457 " wBitsPerSample = %RI16\n"
1458 " cbSize = %RI16\n",
1459 bc.dwBufferBytes,
1460 bc.dwFlags,
1461 wfx.wFormatTag,
1462 wfx.nChannels,
1463 wfx.nSamplesPerSec,
1464 wfx.nAvgBytesPerSec,
1465 wfx.nBlockAlign,
1466 wfx.wBitsPerSample,
1467 wfx.cbSize));
1468
1469 if (bc.dwBufferBytes & pStreamDS->uAlign)
1470 DSLOGREL(("DSound: Capture GetCaps returned misaligned buffer: size %RU32, alignment %RU32\n",
1471 bc.dwBufferBytes, pStreamDS->uAlign + 1));
1472
1473 /* Initial state: reading at the initial capture position, no error. */
1474 pStreamDS->In.offReadPos = 0;
1475 pStreamDS->cbBufSize = bc.dwBufferBytes;
1476
1477 rc = RTCircBufCreate(&pStreamDS->pCircBuf, pStreamDS->cbBufSize) * 2; /* Use "double buffering". */
1478 AssertRC(rc);
1479
1480 pThis->pDSStrmIn = pStreamDS;
1481
1482 pCfgAcq->Backend.cfBufferSize = PDMAUDIOSTREAMCFG_B2F(pCfgAcq, pStreamDS->cbBufSize);
1483
1484 } while (0);
1485
1486 if (FAILED(hr))
1487 directSoundCaptureClose(pThis, pStreamDS);
1488
1489 LogFlowFunc(("Returning %Rhrc\n", hr));
1490 return hr;
1491}
1492
1493static HRESULT directSoundCaptureStop(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS, bool fFlush)
1494{
1495 AssertPtrReturn(pThis, E_POINTER);
1496 AssertPtrReturn(pStreamDS, E_POINTER);
1497
1498 RT_NOREF(pThis);
1499
1500 HRESULT hr = S_OK;
1501
1502 if (pStreamDS->In.pDSCB)
1503 {
1504 DSLOG(("DSound: Stopping capture\n"));
1505 hr = IDirectSoundCaptureBuffer_Stop(pStreamDS->In.pDSCB);
1506 }
1507
1508 if (SUCCEEDED(hr))
1509 {
1510 if (fFlush)
1511 dsoundStreamReset(pThis, pStreamDS);
1512 }
1513
1514 if (FAILED(hr))
1515 DSLOGREL(("DSound: Stopping capture buffer failed with %Rhrc\n", hr));
1516
1517 return hr;
1518}
1519
1520static HRESULT directSoundCaptureStart(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS)
1521{
1522 AssertPtrReturn(pThis, E_POINTER);
1523 AssertPtrReturn(pStreamDS, E_POINTER);
1524
1525 HRESULT hr;
1526 if (pStreamDS->In.pDSCB)
1527 {
1528 DWORD dwStatus;
1529 hr = IDirectSoundCaptureBuffer8_GetStatus(pStreamDS->In.pDSCB, &dwStatus);
1530 if (FAILED(hr))
1531 {
1532 DSLOGREL(("DSound: Retrieving capture status failed with %Rhrc\n", hr));
1533 }
1534 else
1535 {
1536 if (dwStatus & DSCBSTATUS_CAPTURING)
1537 {
1538 DSLOG(("DSound: Already capturing\n"));
1539 }
1540 else
1541 {
1542 const DWORD fFlags = DSCBSTART_LOOPING;
1543
1544 DSLOG(("DSound: Starting to capture\n"));
1545 hr = IDirectSoundCaptureBuffer8_Start(pStreamDS->In.pDSCB, fFlags);
1546 if (FAILED(hr))
1547 DSLOGREL(("DSound: Starting to capture failed with %Rhrc\n", hr));
1548 }
1549 }
1550 }
1551 else
1552 hr = E_UNEXPECTED;
1553
1554 LogFlowFunc(("Returning %Rhrc\n", hr));
1555 return hr;
1556}
1557
1558static int dsoundDevAdd(PRTLISTANCHOR pList, LPGUID pGUID, LPCWSTR pwszDescription, PDSOUNDDEV *ppDev)
1559{
1560 AssertPtrReturn(pList, VERR_INVALID_POINTER);
1561 AssertPtrReturn(pGUID, VERR_INVALID_POINTER);
1562 AssertPtrReturn(pwszDescription, VERR_INVALID_POINTER);
1563
1564 PDSOUNDDEV pDev = (PDSOUNDDEV)RTMemAlloc(sizeof(DSOUNDDEV));
1565 if (!pDev)
1566 return VERR_NO_MEMORY;
1567
1568 int rc = RTUtf16ToUtf8(pwszDescription, &pDev->pszName);
1569 if ( RT_SUCCESS(rc)
1570 && pGUID)
1571 {
1572 memcpy(&pDev->Guid, pGUID, sizeof(GUID));
1573 }
1574
1575 if (RT_SUCCESS(rc))
1576 RTListAppend(pList, &pDev->Node);
1577
1578 if (ppDev)
1579 *ppDev = pDev;
1580
1581 return rc;
1582}
1583
1584static void dsoundDeviceRemove(PDSOUNDDEV pDev)
1585{
1586 if (pDev)
1587 {
1588 if (pDev->pszName)
1589 {
1590 RTStrFree(pDev->pszName);
1591 pDev->pszName = NULL;
1592 }
1593
1594 RTListNodeRemove(&pDev->Node);
1595
1596 RTMemFree(pDev);
1597 pDev = NULL;
1598 }
1599}
1600
1601static void dsoundLogDevice(const char *pszType, LPGUID pGUID, LPCWSTR pwszDescription, LPCWSTR pwszModule)
1602{
1603 char *pszGUID = dsoundGUIDToUtf8StrA(pGUID);
1604 /* This always has to be in the release log.
1605 * Only print this when we're running in verbose (audio debug) mode, as this can generate a lot of content. */
1606 LogRel2(("DSound: %s: GUID: %s [%ls] (Module: %ls)\n", pszType, pszGUID ? pszGUID : "{?}", pwszDescription, pwszModule));
1607 RTStrFree(pszGUID);
1608}
1609
1610static BOOL CALLBACK dsoundDevicesEnumCbPlayback(LPGUID pGUID, LPCWSTR pwszDescription, LPCWSTR pwszModule, PVOID lpContext)
1611{
1612 PDSOUNDENUMCBCTX pCtx = (PDSOUNDENUMCBCTX)lpContext;
1613 AssertPtrReturn(pCtx, FALSE);
1614 AssertPtrReturn(pCtx->pDrv, FALSE);
1615
1616 if (!pGUID)
1617 return TRUE;
1618
1619 AssertPtrReturn(pwszDescription, FALSE);
1620 /* Do not care about pwszModule. */
1621
1622 if (pCtx->fFlags & DSOUNDENUMCBFLAGS_LOG)
1623 dsoundLogDevice("Output", pGUID, pwszDescription, pwszModule);
1624
1625 int rc = dsoundDevAdd(&pCtx->pDrv->lstDevOutput,
1626 pGUID, pwszDescription, NULL /* ppDev */);
1627 if (RT_FAILURE(rc))
1628 return FALSE; /* Abort enumeration. */
1629
1630 pCtx->cDevOut++;
1631
1632 return TRUE;
1633}
1634
1635static BOOL CALLBACK dsoundDevicesEnumCbCapture(LPGUID pGUID, LPCWSTR pwszDescription, LPCWSTR pwszModule, PVOID lpContext)
1636{
1637 PDSOUNDENUMCBCTX pCtx = (PDSOUNDENUMCBCTX)lpContext;
1638 AssertPtrReturn(pCtx, FALSE);
1639 AssertPtrReturn(pCtx->pDrv, FALSE);
1640
1641 if (!pGUID)
1642 return TRUE;
1643
1644 if (pCtx->fFlags & DSOUNDENUMCBFLAGS_LOG)
1645 dsoundLogDevice("Input", pGUID, pwszDescription, pwszModule);
1646
1647 int rc = dsoundDevAdd(&pCtx->pDrv->lstDevInput,
1648 pGUID, pwszDescription, NULL /* ppDev */);
1649 if (RT_FAILURE(rc))
1650 return FALSE; /* Abort enumeration. */
1651
1652 pCtx->cDevIn++;
1653
1654 return TRUE;
1655}
1656
1657/**
1658 * Does a (Re-)enumeration of the host's playback + capturing devices.
1659 *
1660 * @return IPRT status code.
1661 * @param pThis Host audio driver instance.
1662 * @param pEnmCtx Enumeration context to use.
1663 * @param fEnum Enumeration flags.
1664 */
1665static int dsoundDevicesEnumerate(PDRVHOSTDSOUND pThis, PDSOUNDENUMCBCTX pEnmCtx, uint32_t fEnum)
1666{
1667 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
1668 AssertPtrReturn(pEnmCtx, VERR_INVALID_POINTER);
1669
1670 dsoundDevicesClear(pThis);
1671
1672 RTLDRMOD hDSound = NULL;
1673 int rc = RTLdrLoadSystem("dsound.dll", true /*fNoUnload*/, &hDSound);
1674 if (RT_SUCCESS(rc))
1675 {
1676 PFNDIRECTSOUNDENUMERATEW pfnDirectSoundEnumerateW = NULL;
1677 PFNDIRECTSOUNDCAPTUREENUMERATEW pfnDirectSoundCaptureEnumerateW = NULL;
1678
1679 rc = RTLdrGetSymbol(hDSound, "DirectSoundEnumerateW", (void**)&pfnDirectSoundEnumerateW);
1680 if (RT_SUCCESS(rc))
1681 rc = RTLdrGetSymbol(hDSound, "DirectSoundCaptureEnumerateW", (void**)&pfnDirectSoundCaptureEnumerateW);
1682
1683 if (RT_SUCCESS(rc))
1684 {
1685 HRESULT hr = pfnDirectSoundEnumerateW(&dsoundDevicesEnumCbPlayback, pEnmCtx);
1686 if (FAILED(hr))
1687 LogRel2(("DSound: Error enumerating host playback devices: %Rhrc\n", hr));
1688
1689 hr = pfnDirectSoundCaptureEnumerateW(&dsoundDevicesEnumCbCapture, pEnmCtx);
1690 if (FAILED(hr))
1691 LogRel2(("DSound: Error enumerating host capturing devices: %Rhrc\n", hr));
1692
1693 if (fEnum & DSOUNDENUMCBFLAGS_LOG)
1694 {
1695 LogRel2(("DSound: Found %RU8 host playback devices\n", pEnmCtx->cDevOut));
1696 LogRel2(("DSound: Found %RU8 host capturing devices\n", pEnmCtx->cDevIn));
1697 }
1698 }
1699
1700 RTLdrClose(hDSound);
1701 }
1702 else
1703 {
1704 /* No dsound.dll on this system. */
1705 LogRel2(("DSound: Could not load dsound.dll: %Rrc\n", rc));
1706 }
1707
1708 return rc;
1709}
1710
1711/**
1712 * Updates this host driver's internal status, according to the global, overall input/output
1713 * state and all connected (native) audio streams.
1714 *
1715 * @param pThis Host audio driver instance.
1716 * @param pCfg Where to store the backend configuration. Optional.
1717 * @param fEnum Enumeration flags.
1718 */
1719static void dsoundUpdateStatusInternalEx(PDRVHOSTDSOUND pThis, PPDMAUDIOBACKENDCFG pCfg, uint32_t fEnum)
1720{
1721 AssertPtrReturnVoid(pThis);
1722 /* pCfg is optional. */
1723
1724 PDMAUDIOBACKENDCFG Cfg;
1725 RT_ZERO(Cfg);
1726
1727 Cfg.cbStreamOut = sizeof(DSOUNDSTREAM);
1728 Cfg.cbStreamIn = sizeof(DSOUNDSTREAM);
1729
1730 DSOUNDENUMCBCTX cbCtx = { pThis, fEnum, 0, 0 };
1731
1732 int rc = dsoundDevicesEnumerate(pThis, &cbCtx, fEnum);
1733 if (RT_SUCCESS(rc))
1734 {
1735#if 0
1736 if ( pThis->fEnabledOut != RT_BOOL(cbCtx.cDevOut)
1737 || pThis->fEnabledIn != RT_BOOL(cbCtx.cDevIn))
1738 {
1739 /** @todo Use a registered callback to the audio connector (e.g "OnConfigurationChanged") to
1740 * let the connector know that something has changed within the host backend. */
1741 }
1742#endif
1743 pThis->fEnabledOut = RT_BOOL(cbCtx.cDevOut);
1744 pThis->fEnabledIn = RT_BOOL(cbCtx.cDevIn);
1745
1746 Cfg.cMaxStreamsIn = UINT32_MAX;
1747 Cfg.cMaxStreamsOut = UINT32_MAX;
1748
1749 if (pCfg)
1750 memcpy(pCfg, &Cfg, sizeof(PDMAUDIOBACKENDCFG));
1751 }
1752
1753 LogFlowFuncLeaveRC(rc);
1754}
1755
1756static void dsoundUpdateStatusInternal(PDRVHOSTDSOUND pThis)
1757{
1758 dsoundUpdateStatusInternalEx(pThis, NULL /* pCfg */, 0 /* fEnum */);
1759}
1760
1761static int dsoundCreateStreamOut(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS,
1762 PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
1763{
1764 LogFlowFunc(("pStreamDS=%p, pCfgReq=%p\n", pStreamDS, pCfgReq));
1765
1766 int rc = VINF_SUCCESS;
1767
1768 /* Try to open playback in case the device is already there. */
1769 HRESULT hr = directSoundPlayOpen(pThis, pStreamDS, pCfgReq, pCfgAcq);
1770 if (SUCCEEDED(hr))
1771 {
1772 rc = DrvAudioHlpStreamCfgCopy(&pStreamDS->Cfg, pCfgAcq);
1773 if (RT_SUCCESS(rc))
1774 dsoundStreamReset(pThis, pStreamDS);
1775 }
1776 else
1777 rc = VERR_GENERAL_FAILURE; /** @todo Fudge! */
1778
1779 LogFlowFuncLeaveRC(rc);
1780 return rc;
1781}
1782
1783static int dsoundControlStreamOut(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS, PDMAUDIOSTREAMCMD enmStreamCmd)
1784{
1785 LogFlowFunc(("pStreamDS=%p, cmd=%d\n", pStreamDS, enmStreamCmd));
1786
1787 int rc = VINF_SUCCESS;
1788
1789 HRESULT hr;
1790 switch (enmStreamCmd)
1791 {
1792 case PDMAUDIOSTREAMCMD_ENABLE:
1793 {
1794 dsoundStreamEnable(pThis, pStreamDS, true /* fEnable */);
1795 break;
1796 }
1797
1798 case PDMAUDIOSTREAMCMD_RESUME:
1799 {
1800 hr = directSoundPlayStart(pThis, pStreamDS);
1801 if (FAILED(hr))
1802 rc = VERR_NOT_SUPPORTED; /** @todo Fix this. */
1803 break;
1804 }
1805
1806 case PDMAUDIOSTREAMCMD_DISABLE:
1807 {
1808 dsoundStreamEnable(pThis, pStreamDS, false /* fEnable */);
1809 hr = directSoundPlayStop(pThis, pStreamDS, true /* fFlush */);
1810 if (FAILED(hr))
1811 rc = VERR_NOT_SUPPORTED;
1812 break;
1813 }
1814
1815 case PDMAUDIOSTREAMCMD_PAUSE:
1816 {
1817 hr = directSoundPlayStop(pThis, pStreamDS, false /* fFlush */);
1818 if (FAILED(hr))
1819 rc = VERR_NOT_SUPPORTED;
1820 break;
1821 }
1822
1823 case PDMAUDIOSTREAMCMD_DRAIN:
1824 {
1825 /* Make sure we transferred everything. */
1826 pStreamDS->fEnabled = true;
1827 pStreamDS->Out.fDrain = true;
1828 rc = dsoundPlayTransfer(pThis, pStreamDS);
1829 if ( RT_SUCCESS(rc)
1830 && pStreamDS->Out.fFirstTransfer)
1831 {
1832 /* If this was the first transfer ever for this stream, make sure to also play the (short) audio data. */
1833 DSLOG(("DSound: Started playing output (short sound)\n"));
1834
1835 pStreamDS->Out.fFirstTransfer = false;
1836 pStreamDS->Out.cbLastTransferred = pStreamDS->Out.cbTransferred; /* All transferred audio data must be played. */
1837 pStreamDS->Out.tsLastTransferred = RTTimeMilliTS();
1838
1839 hr = directSoundPlayStart(pThis, pStreamDS);
1840 if (FAILED(hr))
1841 rc = VERR_ACCESS_DENIED; /** @todo Find a better rc. */
1842 }
1843 break;
1844 }
1845
1846 default:
1847 rc = VERR_NOT_SUPPORTED;
1848 break;
1849 }
1850
1851 LogFlowFuncLeaveRC(rc);
1852 return rc;
1853}
1854
1855/**
1856 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamPlay}
1857 */
1858int drvHostDSoundStreamPlay(PPDMIHOSTAUDIO pInterface,
1859 PPDMAUDIOBACKENDSTREAM pStream, const void *pvBuf, uint32_t cxBuf, uint32_t *pcxWritten)
1860{
1861 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
1862 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
1863 AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
1864 AssertReturn(cxBuf, VERR_INVALID_PARAMETER);
1865 /* pcxWritten is optional. */
1866
1867 PDRVHOSTDSOUND pThis = PDMIHOSTAUDIO_2_DRVHOSTDSOUND(pInterface);
1868 PDSOUNDSTREAM pStreamDS = (PDSOUNDSTREAM)pStream;
1869
1870 int rc = VINF_SUCCESS;
1871
1872 uint32_t cbWrittenTotal = 0;
1873
1874 uint8_t *pbBuf = (uint8_t *)pvBuf;
1875 PRTCIRCBUF pCircBuf = pStreamDS->pCircBuf;
1876
1877 uint32_t cbToPlay = RT_MIN(cxBuf, (uint32_t)RTCircBufFree(pCircBuf));
1878 while (cbToPlay)
1879 {
1880 void *pvChunk;
1881 size_t cbChunk;
1882 RTCircBufAcquireWriteBlock(pCircBuf, cbToPlay, &pvChunk, &cbChunk);
1883
1884 if (cbChunk)
1885 {
1886 memcpy(pvChunk, pbBuf, cbChunk);
1887
1888 pbBuf += cbChunk;
1889 Assert(cbToPlay >= cbChunk);
1890 cbToPlay -= (uint32_t)cbChunk;
1891
1892 cbWrittenTotal += (uint32_t)cbChunk;
1893 }
1894
1895 RTCircBufReleaseWriteBlock(pCircBuf, cbChunk);
1896 }
1897
1898 Assert(cbWrittenTotal <= cxBuf);
1899 Assert(cbWrittenTotal == cxBuf);
1900
1901 pStreamDS->Out.cbWritten += cbWrittenTotal;
1902
1903 rc = dsoundPlayTransfer(pThis, pStreamDS);
1904 AssertRC(rc);
1905
1906 if (RT_SUCCESS(rc))
1907 {
1908 if (pcxWritten)
1909 *pcxWritten = cbWrittenTotal;
1910 }
1911 else
1912 dsoundUpdateStatusInternal(pThis);
1913
1914 return rc;
1915}
1916
1917static int dsoundDestroyStreamOut(PDRVHOSTDSOUND pThis, PPDMAUDIOBACKENDSTREAM pStream)
1918{
1919 PDSOUNDSTREAM pStreamDS = (PDSOUNDSTREAM)pStream;
1920
1921 LogFlowFuncEnter();
1922
1923 HRESULT hr = directSoundPlayStop(pThis, pStreamDS, true /* fFlush */);
1924 if (SUCCEEDED(hr))
1925 {
1926 hr = directSoundPlayClose(pThis, pStreamDS);
1927 if (FAILED(hr))
1928 return VERR_GENERAL_FAILURE; /** @todo Fix. */
1929 }
1930
1931 return VINF_SUCCESS;
1932}
1933
1934static int dsoundCreateStreamIn(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS,
1935 PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
1936{
1937 LogFunc(("pStreamDS=%p, pCfgReq=%p, enmRecSource=%s\n",
1938 pStreamDS, pCfgReq, DrvAudioHlpRecSrcToStr(pCfgReq->DestSource.Source)));
1939
1940 int rc = VINF_SUCCESS;
1941
1942 /* Try to open capture in case the device is already there. */
1943 HRESULT hr = directSoundCaptureOpen(pThis, pStreamDS, pCfgReq, pCfgAcq);
1944 if (SUCCEEDED(hr))
1945 {
1946 rc = DrvAudioHlpStreamCfgCopy(&pStreamDS->Cfg, pCfgAcq);
1947 if (RT_SUCCESS(rc))
1948 dsoundStreamReset(pThis, pStreamDS);
1949 }
1950 else
1951 rc = VERR_GENERAL_FAILURE; /** @todo Fudge! */
1952
1953 return rc;
1954}
1955
1956static int dsoundControlStreamIn(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS, PDMAUDIOSTREAMCMD enmStreamCmd)
1957{
1958 LogFlowFunc(("pStreamDS=%p, enmStreamCmd=%ld\n", pStreamDS, enmStreamCmd));
1959
1960 int rc = VINF_SUCCESS;
1961
1962 HRESULT hr;
1963 switch (enmStreamCmd)
1964 {
1965 case PDMAUDIOSTREAMCMD_ENABLE:
1966 dsoundStreamEnable(pThis, pStreamDS, true /* fEnable */);
1967 RT_FALL_THROUGH();
1968 case PDMAUDIOSTREAMCMD_RESUME:
1969 {
1970 /* Try to start capture. If it fails, then reopen and try again. */
1971 hr = directSoundCaptureStart(pThis, pStreamDS);
1972 if (FAILED(hr))
1973 {
1974 hr = directSoundCaptureClose(pThis, pStreamDS);
1975 if (SUCCEEDED(hr))
1976 {
1977 PDMAUDIOSTREAMCFG CfgAcq;
1978 hr = directSoundCaptureOpen(pThis, pStreamDS, &pStreamDS->Cfg /* pCfgReq */, &CfgAcq);
1979 if (SUCCEEDED(hr))
1980 {
1981 rc = DrvAudioHlpStreamCfgCopy(&pStreamDS->Cfg, &CfgAcq);
1982 if (RT_FAILURE(rc))
1983 break;
1984
1985 /** @todo What to do if the format has changed? */
1986
1987 hr = directSoundCaptureStart(pThis, pStreamDS);
1988 }
1989 }
1990 }
1991
1992 if (FAILED(hr))
1993 rc = VERR_NOT_SUPPORTED;
1994 break;
1995 }
1996
1997 case PDMAUDIOSTREAMCMD_DISABLE:
1998 dsoundStreamEnable(pThis, pStreamDS, false /* fEnable */);
1999 RT_FALL_THROUGH();
2000 case PDMAUDIOSTREAMCMD_PAUSE:
2001 {
2002 directSoundCaptureStop(pThis, pStreamDS,
2003 enmStreamCmd == PDMAUDIOSTREAMCMD_DISABLE /* fFlush */);
2004
2005 /* Return success in any case, as stopping the capture can fail if
2006 * the capture buffer is not around anymore.
2007 *
2008 * This can happen if the host's capturing device has been changed suddenly. */
2009 rc = VINF_SUCCESS;
2010 break;
2011 }
2012
2013 default:
2014 rc = VERR_NOT_SUPPORTED;
2015 break;
2016 }
2017
2018 return rc;
2019}
2020
2021/**
2022 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamCapture}
2023 */
2024int drvHostDSoundStreamCapture(PPDMIHOSTAUDIO pInterface,
2025 PPDMAUDIOBACKENDSTREAM pStream, void *pvBuf, uint32_t cxBuf, uint32_t *pcxRead)
2026{
2027
2028 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
2029 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
2030 AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
2031 AssertReturn(cxBuf, VERR_INVALID_PARAMETER);
2032
2033 PDRVHOSTDSOUND pThis = PDMIHOSTAUDIO_2_DRVHOSTDSOUND(pInterface);
2034 PDSOUNDSTREAM pStreamDS = (PDSOUNDSTREAM)pStream;
2035
2036 int rc = VINF_SUCCESS;
2037
2038 uint32_t cbReadTotal = 0;
2039
2040 uint32_t cbToRead = RT_MIN((uint32_t)RTCircBufUsed(pStreamDS->pCircBuf), cxBuf);
2041 while (cbToRead)
2042 {
2043 void *pvChunk;
2044 size_t cbChunk;
2045 RTCircBufAcquireReadBlock(pStreamDS->pCircBuf, cbToRead, &pvChunk, &cbChunk);
2046
2047 if (cbChunk)
2048 {
2049 memcpy((uint8_t *)pvBuf + cbReadTotal, pvChunk, cbChunk);
2050 cbReadTotal += (uint32_t)cbChunk;
2051 Assert(cbToRead >= cbChunk);
2052 cbToRead -= (uint32_t)cbChunk;
2053 }
2054
2055 RTCircBufReleaseReadBlock(pStreamDS->pCircBuf, cbChunk);
2056 }
2057
2058 if (RT_SUCCESS(rc))
2059 {
2060 if (pcxRead)
2061 *pcxRead = cbReadTotal;
2062 }
2063 else
2064 dsoundUpdateStatusInternal(pThis);
2065
2066 return rc;
2067}
2068
2069static int dsoundDestroyStreamIn(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS)
2070{
2071 LogFlowFuncEnter();
2072
2073 directSoundCaptureClose(pThis, pStreamDS);
2074
2075 return VINF_SUCCESS;
2076}
2077
2078/**
2079 * @interface_method_impl{PDMIHOSTAUDIO,pfnGetConfig}
2080 */
2081int drvHostDSoundGetConfig(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDCFG pBackendCfg)
2082{
2083 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
2084 AssertPtrReturn(pBackendCfg, VERR_INVALID_POINTER);
2085
2086 PDRVHOSTDSOUND pThis = PDMIHOSTAUDIO_2_DRVHOSTDSOUND(pInterface);
2087
2088 dsoundUpdateStatusInternalEx(pThis, pBackendCfg, 0 /* fEnum */);
2089
2090 return VINF_SUCCESS;
2091}
2092
2093/**
2094 * @interface_method_impl{PDMIHOSTAUDIO,pfnShutdown}
2095 */
2096void drvHostDSoundShutdown(PPDMIHOSTAUDIO pInterface)
2097{
2098 PDRVHOSTDSOUND pThis = PDMIHOSTAUDIO_2_DRVHOSTDSOUND(pInterface);
2099
2100 LogFlowFuncEnter();
2101
2102 RT_NOREF(pThis);
2103
2104 LogFlowFuncLeave();
2105}
2106
2107/**
2108 * @interface_method_impl{PDMIHOSTAUDIO,pfnInit}
2109 */
2110static DECLCALLBACK(int) drvHostDSoundInit(PPDMIHOSTAUDIO pInterface)
2111{
2112 PDRVHOSTDSOUND pThis = PDMIHOSTAUDIO_2_DRVHOSTDSOUND(pInterface);
2113 LogFlowFuncEnter();
2114
2115 int rc;
2116
2117 /* Verify that IDirectSound is available. */
2118 LPDIRECTSOUND pDirectSound = NULL;
2119 HRESULT hr = CoCreateInstance(CLSID_DirectSound, NULL, CLSCTX_ALL, IID_IDirectSound, (void **)&pDirectSound);
2120 if (SUCCEEDED(hr))
2121 {
2122 IDirectSound_Release(pDirectSound);
2123
2124 rc = VINF_SUCCESS;
2125
2126 dsoundUpdateStatusInternalEx(pThis, NULL /* pCfg */, DSOUNDENUMCBFLAGS_LOG /* fEnum */);
2127 }
2128 else
2129 {
2130 DSLOGREL(("DSound: DirectSound not available: %Rhrc\n", hr));
2131 rc = VERR_NOT_SUPPORTED;
2132 }
2133
2134 LogFlowFuncLeaveRC(rc);
2135 return rc;
2136}
2137
2138static LPCGUID dsoundConfigQueryGUID(PCFGMNODE pCfg, const char *pszName, RTUUID *pUuid)
2139{
2140 LPCGUID pGuid = NULL;
2141
2142 char *pszGuid = NULL;
2143 int rc = CFGMR3QueryStringAlloc(pCfg, pszName, &pszGuid);
2144 if (RT_SUCCESS(rc))
2145 {
2146 rc = RTUuidFromStr(pUuid, pszGuid);
2147 if (RT_SUCCESS(rc))
2148 pGuid = (LPCGUID)&pUuid;
2149 else
2150 DSLOGREL(("DSound: Error parsing device GUID for device '%s': %Rrc\n", pszName, rc));
2151
2152 RTStrFree(pszGuid);
2153 }
2154
2155 return pGuid;
2156}
2157
2158static int dsoundConfigInit(PDRVHOSTDSOUND pThis, PCFGMNODE pCfg)
2159{
2160 pThis->Cfg.pGuidPlay = dsoundConfigQueryGUID(pCfg, "DeviceGuidOut", &pThis->Cfg.uuidPlay);
2161 pThis->Cfg.pGuidCapture = dsoundConfigQueryGUID(pCfg, "DeviceGuidIn", &pThis->Cfg.uuidCapture);
2162
2163 DSLOG(("DSound: Configuration: DeviceGuidOut {%RTuuid}, DeviceGuidIn {%RTuuid}\n",
2164 &pThis->Cfg.uuidPlay,
2165 &pThis->Cfg.uuidCapture));
2166
2167 return VINF_SUCCESS;
2168}
2169
2170/**
2171 * @interface_method_impl{PDMIHOSTAUDIO,pfnGetStatus}
2172 */
2173static DECLCALLBACK(PDMAUDIOBACKENDSTS) drvHostDSoundGetStatus(PPDMIHOSTAUDIO pInterface, PDMAUDIODIR enmDir)
2174{
2175 RT_NOREF(enmDir);
2176 AssertPtrReturn(pInterface, PDMAUDIOBACKENDSTS_UNKNOWN);
2177
2178 return PDMAUDIOBACKENDSTS_RUNNING;
2179}
2180
2181/**
2182 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamCreate}
2183 */
2184static DECLCALLBACK(int) drvHostDSoundStreamCreate(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream,
2185 PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
2186{
2187 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
2188 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
2189 AssertPtrReturn(pCfgReq, VERR_INVALID_POINTER);
2190 AssertPtrReturn(pCfgAcq, VERR_INVALID_POINTER);
2191
2192 PDRVHOSTDSOUND pThis = PDMIHOSTAUDIO_2_DRVHOSTDSOUND(pInterface);
2193 PDSOUNDSTREAM pStreamDS = (PDSOUNDSTREAM)pStream;
2194
2195 int rc;
2196 if (pCfgReq->enmDir == PDMAUDIODIR_IN)
2197 rc = dsoundCreateStreamIn(pThis, pStreamDS, pCfgReq, pCfgAcq);
2198 else
2199 rc = dsoundCreateStreamOut(pThis, pStreamDS, pCfgReq, pCfgAcq);
2200
2201 if (RT_SUCCESS(rc))
2202 {
2203 rc = DrvAudioHlpStreamCfgCopy(&pStreamDS->Cfg, pCfgAcq);
2204 if (RT_SUCCESS(rc))
2205 rc = RTCritSectInit(&pStreamDS->CritSect);
2206 }
2207
2208 return rc;
2209}
2210
2211/**
2212 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamDestroy}
2213 */
2214static DECLCALLBACK(int) drvHostDSoundStreamDestroy(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
2215{
2216 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
2217 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
2218
2219 PDRVHOSTDSOUND pThis = PDMIHOSTAUDIO_2_DRVHOSTDSOUND(pInterface);
2220 PDSOUNDSTREAM pStreamDS = (PDSOUNDSTREAM)pStream;
2221
2222 int rc;
2223 if (pStreamDS->Cfg.enmDir == PDMAUDIODIR_IN)
2224 rc = dsoundDestroyStreamIn(pThis, pStreamDS);
2225 else
2226 rc = dsoundDestroyStreamOut(pThis, pStreamDS);
2227
2228 if (RT_SUCCESS(rc))
2229 {
2230 if (RTCritSectIsInitialized(&pStreamDS->CritSect))
2231 rc = RTCritSectDelete(&pStreamDS->CritSect);
2232 }
2233
2234 return rc;
2235}
2236
2237/**
2238 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamControl}
2239 */
2240static DECLCALLBACK(int) drvHostDSoundStreamControl(PPDMIHOSTAUDIO pInterface,
2241 PPDMAUDIOBACKENDSTREAM pStream, PDMAUDIOSTREAMCMD enmStreamCmd)
2242{
2243 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
2244 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
2245
2246 PDRVHOSTDSOUND pThis = PDMIHOSTAUDIO_2_DRVHOSTDSOUND(pInterface);
2247 PDSOUNDSTREAM pStreamDS = (PDSOUNDSTREAM)pStream;
2248
2249 int rc;
2250 if (pStreamDS->Cfg.enmDir == PDMAUDIODIR_IN)
2251 rc = dsoundControlStreamIn(pThis, pStreamDS, enmStreamCmd);
2252 else
2253 rc = dsoundControlStreamOut(pThis, pStreamDS, enmStreamCmd);
2254
2255 return rc;
2256}
2257
2258/**
2259 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamGetReadable}
2260 */
2261static DECLCALLBACK(uint32_t) drvHostDSoundStreamGetReadable(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
2262{
2263 RT_NOREF(pInterface);
2264 AssertPtrReturn(pStream, PDMAUDIOSTREAMSTS_FLAG_NONE);
2265
2266 PDSOUNDSTREAM pStreamDS = (PDSOUNDSTREAM)pStream;
2267
2268 if ( pStreamDS->fEnabled
2269 && pStreamDS->pCircBuf)
2270 {
2271 return (uint32_t)RTCircBufUsed(pStreamDS->pCircBuf);
2272 }
2273
2274 return 0;
2275}
2276
2277/**
2278 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamGetWritable}
2279 */
2280static DECLCALLBACK(uint32_t) drvHostDSoundStreamGetWritable(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
2281{
2282 AssertPtrReturn(pInterface, PDMAUDIOSTREAMSTS_FLAG_NONE);
2283 AssertPtrReturn(pStream, PDMAUDIOSTREAMSTS_FLAG_NONE);
2284
2285 PDSOUNDSTREAM pStreamDS = (PDSOUNDSTREAM)pStream;
2286
2287 if (pStreamDS->fEnabled)
2288 return (uint32_t)RTCircBufFree(pStreamDS->pCircBuf);
2289
2290 return 0;
2291}
2292
2293/**
2294 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamGetPending}
2295 */
2296static DECLCALLBACK(uint32_t) drvHostDSoundStreamGetPending(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
2297{
2298 RT_NOREF(pInterface);
2299 AssertPtrReturn(pStream, 0);
2300
2301 PDSOUNDSTREAM pStreamDS = (PDSOUNDSTREAM)pStream;
2302
2303 if (pStreamDS->Cfg.enmDir == PDMAUDIODIR_OUT)
2304 {
2305 uint32_t cbPending = 0;
2306
2307 /* Any uncommitted data left? */
2308 if (pStreamDS->pCircBuf)
2309 cbPending = (uint32_t)RTCircBufUsed(pStreamDS->pCircBuf);
2310
2311 /* Check if we have committed data which still needs to be played by
2312 * by DirectSound's streaming buffer. */
2313 if (!cbPending)
2314 {
2315 const uint64_t diffLastTransferredMs = RTTimeMilliTS() - pStreamDS->Out.tsLastTransferred;
2316 const uint64_t uLastTranserredChunkMs = DrvAudioHlpBytesToMilli(pStreamDS->Out.cbLastTransferred, &pStreamDS->Cfg.Props);
2317 if ( uLastTranserredChunkMs
2318 && diffLastTransferredMs < uLastTranserredChunkMs)
2319 cbPending = 1;
2320
2321 Log3Func(("diffLastTransferredMs=%RU64ms, uLastTranserredChunkMs=%RU64ms (%RU32 bytes) -> cbPending=%RU32\n",
2322 diffLastTransferredMs, uLastTranserredChunkMs, pStreamDS->Out.cbLastTransferred, cbPending));
2323 }
2324 else
2325 Log3Func(("cbPending=%RU32\n", cbPending));
2326
2327 return cbPending;
2328 }
2329 /* Note: For input streams we never have pending data left. */
2330
2331 return 0;
2332}
2333
2334/**
2335 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamGetStatus}
2336 */
2337static DECLCALLBACK(PDMAUDIOSTREAMSTS) drvHostDSoundStreamGetStatus(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
2338{
2339 RT_NOREF(pInterface);
2340 AssertPtrReturn(pStream, PDMAUDIOSTREAMSTS_FLAG_NONE);
2341
2342 PDSOUNDSTREAM pStreamDS = (PDSOUNDSTREAM)pStream;
2343
2344 PDMAUDIOSTREAMSTS strmSts = PDMAUDIOSTREAMSTS_FLAG_INITIALIZED;
2345
2346 if (pStreamDS->fEnabled)
2347 strmSts |= PDMAUDIOSTREAMSTS_FLAG_ENABLED;
2348
2349 return strmSts;
2350}
2351
2352/**
2353 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamIterate}
2354 */
2355static DECLCALLBACK(int) drvHostDSoundStreamIterate(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
2356{
2357 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
2358 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
2359
2360 PDRVHOSTDSOUND pThis = PDMIHOSTAUDIO_2_DRVHOSTDSOUND(pInterface);
2361 PDSOUNDSTREAM pStreamDS = (PDSOUNDSTREAM)pStream;
2362
2363 if (pStreamDS->Cfg.enmDir == PDMAUDIODIR_IN)
2364 return dsoundCaptureTransfer(pThis, pStreamDS);
2365
2366 return VINF_SUCCESS;
2367}
2368
2369#ifdef VBOX_WITH_AUDIO_CALLBACKS
2370/**
2371 * @interface_method_impl{PDMIHOSTAUDIO,pfnSetCallback}
2372 */
2373static DECLCALLBACK(int) drvHostDSoundSetCallback(PPDMIHOSTAUDIO pInterface, PFNPDMHOSTAUDIOCALLBACK pfnCallback)
2374{
2375 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
2376 /* pfnCallback will be handled below. */
2377
2378 PDRVHOSTDSOUND pThis = PDMIHOSTAUDIO_2_DRVHOSTDSOUND(pInterface);
2379
2380 int rc = RTCritSectEnter(&pThis->CritSect);
2381 if (RT_SUCCESS(rc))
2382 {
2383 LogFunc(("pfnCallback=%p\n", pfnCallback));
2384
2385 if (pfnCallback) /* Register. */
2386 {
2387 Assert(pThis->pfnCallback == NULL);
2388 pThis->pfnCallback = pfnCallback;
2389
2390#ifdef VBOX_WITH_AUDIO_MMNOTIFICATION_CLIENT
2391 if (pThis->m_pNotificationClient)
2392 pThis->m_pNotificationClient->RegisterCallback(pThis->pDrvIns, pfnCallback);
2393#endif
2394 }
2395 else /* Unregister. */
2396 {
2397 if (pThis->pfnCallback)
2398 pThis->pfnCallback = NULL;
2399
2400#ifdef VBOX_WITH_AUDIO_MMNOTIFICATION_CLIENT
2401 if (pThis->m_pNotificationClient)
2402 pThis->m_pNotificationClient->UnregisterCallback();
2403#endif
2404 }
2405
2406 int rc2 = RTCritSectLeave(&pThis->CritSect);
2407 AssertRC(rc2);
2408 }
2409
2410 return rc;
2411}
2412#endif
2413
2414
2415/*********************************************************************************************************************************
2416* PDMDRVINS::IBase Interface *
2417*********************************************************************************************************************************/
2418
2419/**
2420 * @callback_method_impl{PDMIBASE,pfnQueryInterface}
2421 */
2422static DECLCALLBACK(void *) drvHostDSoundQueryInterface(PPDMIBASE pInterface, const char *pszIID)
2423{
2424 PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
2425 PDRVHOSTDSOUND pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTDSOUND);
2426
2427 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
2428 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIHOSTAUDIO, &pThis->IHostAudio);
2429 return NULL;
2430}
2431
2432
2433/*********************************************************************************************************************************
2434* PDMDRVREG Interface *
2435*********************************************************************************************************************************/
2436
2437/**
2438 * @callback_method_impl{FNPDMDRVDESTRUCT, pfnDestruct}
2439 */
2440static DECLCALLBACK(void) drvHostDSoundDestruct(PPDMDRVINS pDrvIns)
2441{
2442 PDRVHOSTDSOUND pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTDSOUND);
2443 PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
2444
2445 LogFlowFuncEnter();
2446
2447#ifdef VBOX_WITH_AUDIO_MMNOTIFICATION_CLIENT
2448 if (pThis->m_pNotificationClient)
2449 {
2450 pThis->m_pNotificationClient->Dispose();
2451 pThis->m_pNotificationClient->Release();
2452
2453 pThis->m_pNotificationClient = NULL;
2454 }
2455#endif
2456
2457 if (pThis->pDrvIns)
2458 CoUninitialize();
2459
2460 int rc2 = RTCritSectDelete(&pThis->CritSect);
2461 AssertRC(rc2);
2462
2463 LogFlowFuncLeave();
2464}
2465
2466/**
2467 * @callback_method_impl{FNPDMDRVCONSTRUCT,
2468 * Construct a DirectSound Audio driver instance.}
2469 */
2470static DECLCALLBACK(int) drvHostDSoundConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
2471{
2472 RT_NOREF(fFlags);
2473 PDRVHOSTDSOUND pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTDSOUND);
2474
2475 LogRel(("Audio: Initializing DirectSound audio driver\n"));
2476
2477 PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
2478
2479 HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
2480 if (FAILED(hr))
2481 {
2482 DSLOGREL(("DSound: CoInitializeEx failed with %Rhrc\n", hr));
2483 return VERR_NOT_SUPPORTED;
2484 }
2485
2486 /*
2487 * Init basic data members and interfaces.
2488 */
2489 pThis->pDrvIns = pDrvIns;
2490 /* IBase */
2491 pDrvIns->IBase.pfnQueryInterface = drvHostDSoundQueryInterface;
2492 /* IHostAudio */
2493 PDMAUDIO_IHOSTAUDIO_CALLBACKS(drvHostDSound);
2494 pThis->IHostAudio.pfnStreamGetPending = drvHostDSoundStreamGetPending;
2495
2496#ifdef VBOX_WITH_AUDIO_CALLBACKS
2497 /* This backend supports host audio callbacks. */
2498 pThis->IHostAudio.pfnSetCallback = drvHostDSoundSetCallback;
2499 pThis->pfnCallback = NULL;
2500#endif
2501
2502 /*
2503 * Init the static parts.
2504 */
2505 RTListInit(&pThis->lstDevInput);
2506 RTListInit(&pThis->lstDevOutput);
2507
2508 pThis->fEnabledIn = false;
2509 pThis->fEnabledOut = false;
2510
2511 int rc = VINF_SUCCESS;
2512
2513#ifdef VBOX_WITH_AUDIO_MMNOTIFICATION_CLIENT
2514 bool fUseNotificationClient = false;
2515
2516 char szOSVersion[32];
2517 rc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szOSVersion, sizeof(szOSVersion));
2518 if (RT_SUCCESS(rc))
2519 {
2520 /* IMMNotificationClient is available starting at Windows Vista. */
2521 if (RTStrVersionCompare(szOSVersion, "6.0") >= 0)
2522 fUseNotificationClient = true;
2523 }
2524
2525 if (fUseNotificationClient)
2526 {
2527 try
2528 {
2529 pThis->m_pNotificationClient = new VBoxMMNotificationClient();
2530
2531 HRESULT hr = pThis->m_pNotificationClient->Initialize();
2532 if (FAILED(hr))
2533 rc = VERR_AUDIO_BACKEND_INIT_FAILED;
2534 }
2535 catch (std::bad_alloc &ex)
2536 {
2537 NOREF(ex);
2538 rc = VERR_NO_MEMORY;
2539 }
2540 }
2541
2542 LogRel2(("DSound: Notification client is %s\n", fUseNotificationClient ? "enabled" : "disabled"));
2543#endif
2544
2545 if (RT_SUCCESS(rc))
2546 {
2547 /*
2548 * Initialize configuration values.
2549 */
2550 rc = dsoundConfigInit(pThis, pCfg);
2551 if (RT_SUCCESS(rc))
2552 rc = RTCritSectInit(&pThis->CritSect);
2553 }
2554
2555 return rc;
2556}
2557
2558
2559/**
2560 * PDM driver registration.
2561 */
2562const PDMDRVREG g_DrvHostDSound =
2563{
2564 /* u32Version */
2565 PDM_DRVREG_VERSION,
2566 /* szName */
2567 "DSoundAudio",
2568 /* szRCMod */
2569 "",
2570 /* szR0Mod */
2571 "",
2572 /* pszDescription */
2573 "DirectSound Audio host driver",
2574 /* fFlags */
2575 PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
2576 /* fClass. */
2577 PDM_DRVREG_CLASS_AUDIO,
2578 /* cMaxInstances */
2579 ~0U,
2580 /* cbInstance */
2581 sizeof(DRVHOSTDSOUND),
2582 /* pfnConstruct */
2583 drvHostDSoundConstruct,
2584 /* pfnDestruct */
2585 drvHostDSoundDestruct,
2586 /* pfnRelocate */
2587 NULL,
2588 /* pfnIOCtl */
2589 NULL,
2590 /* pfnPowerOn */
2591 NULL,
2592 /* pfnReset */
2593 NULL,
2594 /* pfnSuspend */
2595 NULL,
2596 /* pfnResume */
2597 NULL,
2598 /* pfnAttach */
2599 NULL,
2600 /* pfnDetach */
2601 NULL,
2602 /* pfnPowerOff */
2603 NULL,
2604 /* pfnSoftReset */
2605 NULL,
2606 /* u32EndVersion */
2607 PDM_DRVREG_VERSION
2608};
2609
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette