DrvHostDSound.cpp@ 73476

Last change on this file since 73476 was 73408, checked in by vboxsync, 7 years ago
Audio: Renamed Ms (milliseconds) timing helper functions to Milli.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 81.3 KB

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

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: