DrvHostAudioWasApi.cpp@ 88692

Last change on this file since 88692 was 88691, checked in by vboxsync, 4 years ago
DrvHostAudioDSound, DrvHostAudioWasApi: No need to call CoInitializeEx in the constructor as all EMTs do so when they're created (MTA). (For SMP VMs it wouldn't be enough it EMTs wasn't all initialized already.) bugref:9890
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 96.0 KB

Line
1	/* $Id: DrvHostAudioWasApi.cpp 88691 2021-04-23 19:57:31Z vboxsync $ */
2	/** @file
3	* Host audio driver - Windows Audio Session API.
4	*/
5
6	/*
7	* Copyright (C) 2021 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	/#define INITGUID - defined in VBoxhostAudioDSound.cpp already /
24	#include <VBox/log.h>
25	#include <iprt/win/windows.h>
26	#include <Mmdeviceapi.h>
27	#include <iprt/win/audioclient.h>
28	#include <functiondiscoverykeys_devpkey.h>
29	#include <AudioSessionTypes.h>
30	#ifndef AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY
31	# define AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY UINT32_C(0x08000000)
32	#endif
33	#ifndef AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM
34	# define AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM UINT32_C(0x80000000)
35	#endif
36
37	#include <VBox/vmm/pdmaudioinline.h>
38	#include <VBox/vmm/pdmaudiohostenuminline.h>
39
40	#include <iprt/utf16.h>
41	#include <iprt/uuid.h>
42
43	#include <new> /* std::bad_alloc */
44
45	#include "VBoxDD.h"
46
47
48	/*********************************************************************************************************************************
49	* Defined Constants And Macros *
50	*********************************************************************************************************************************/
51	/** Max GetCurrentPadding value we accept (to make sure it's safe to convert to bytes). */
52	#define VBOX_WASAPI_MAX_PADDING UINT32_C(0x007fffff)
53
54
55	/*********************************************************************************************************************************
56	* Structures and Typedefs *
57	*********************************************************************************************************************************/
58	class DrvHostAudioWasMmNotifyClient;
59
60	/** Pointer to the cache entry for a host audio device (+dir). */
61	typedef struct DRVHOSTAUDIOWASCACHEDEV *PDRVHOSTAUDIOWASCACHEDEV;
62
63	/**
64	* Cached pre-initialized audio client for a device.
65	*
66	* The activation and initialization of an IAudioClient has been observed to be
67	* very very slow (> 100 ms) and not suitable to be done on an EMT. So, we'll
68	* pre-initialize the device clients at construction time and when the default
69	* device changes to try avoid this problem.
70	*
71	* A client is returned to the cache after we're done with it, provided it still
72	* works fine.
73	*/
74	typedef struct DRVHOSTAUDIOWASCACHEDEVCFG
75	{
76	/** Entry in DRVHOSTAUDIOWASCACHEDEV::ConfigList. */
77	RTLISTNODE ListEntry;
78	/** The device. */
79	PDRVHOSTAUDIOWASCACHEDEV pDevEntry;
80	/** The cached audio client. */
81	IAudioClient *pIAudioClient;
82	/** Output streams: The render client interface. */
83	IAudioRenderClient *pIAudioRenderClient;
84	/** Input streams: The capture client interface. */
85	IAudioCaptureClient *pIAudioCaptureClient;
86	/** The configuration. */
87	PDMAUDIOPCMPROPS Props;
88	/** The buffer size in frames. */
89	uint32_t cFramesBufferSize;
90	/** The device/whatever period in frames. */
91	uint32_t cFramesPeriod;
92	/** The stringified properties. */
93	char szProps[32];
94	} DRVHOSTAUDIOWASCACHEDEVCFG;
95	/** Pointer to a pre-initialized audio client. */
96	typedef DRVHOSTAUDIOWASCACHEDEVCFG *PDRVHOSTAUDIOWASCACHEDEVCFG;
97
98	/**
99	* Per audio device (+ direction) cache entry.
100	*/
101	typedef struct DRVHOSTAUDIOWASCACHEDEV
102	{
103	/** Entry in DRVHOSTAUDIOWAS::CacheHead. */
104	RTLISTNODE ListEntry;
105	/** The MM device associated with the stream. */
106	IMMDevice *pIDevice;
107	/** The direction of the device. */
108	PDMAUDIODIR enmDir;
109	#if 0 /* According to https://social.msdn.microsoft.com/Forums/en-US/1d974d90-6636-4121-bba3-a8861d9ab92a,
110	these were always support just missing from the SDK. */
111	/** Support for AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM: -1=unknown, 0=no, 1=yes. */
112	int8_t fSupportsAutoConvertPcm;
113	/** Support for AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY: -1=unknown, 0=no, 1=yes. */
114	int8_t fSupportsSrcDefaultQuality;
115	#endif
116	/** List of cached configurations (DRVHOSTAUDIOWASCACHEDEVCFG). */
117	RTLISTANCHOR ConfigList;
118	/** The device ID length in RTUTF16 units. */
119	size_t cwcDevId;
120	/** The device ID. */
121	RTUTF16 wszDevId[RT_FLEXIBLE_ARRAY];
122	} DRVHOSTAUDIOWASCACHEDEV;
123
124
125	/**
126	* Data for a WASABI stream.
127	*/
128	typedef struct DRVHOSTAUDIOWASSTREAM
129	{
130	/** Entry in DRVHOSTAUDIOWAS::StreamHead. */
131	RTLISTNODE ListEntry;
132	/** The stream's acquired configuration. */
133	PDMAUDIOSTREAMCFG Cfg;
134	/** Cache entry to be relased when destroying the stream. */
135	PDRVHOSTAUDIOWASCACHEDEVCFG pDevCfg;
136
137	/** Set if the stream is enabled. */
138	bool fEnabled;
139	/** Set if the stream is started (playing/capturing). */
140	bool fStarted;
141	/** Set if the stream is draining (output only). */
142	bool fDraining;
143	/** Set if we should restart the stream on resume (saved pause state). */
144	bool fRestartOnResume;
145
146	/** The RTTimeMilliTS() deadline for the draining of this stream (output). */
147	uint64_t msDrainDeadline;
148	/** Internal stream offset (bytes). */
149	uint64_t offInternal;
150	/** The RTTimeMilliTS() at the end of the last transfer. */
151	uint64_t msLastTransfer;
152
153	/** Input: Current capture buffer (advanced as we read). */
154	uint8_t *pbCapture;
155	/** Input: The number of bytes left in the current capture buffer. */
156	uint32_t cbCapture;
157	/** Input: The full size of what pbCapture is part of (for ReleaseBuffer). */
158	uint32_t cFramesCaptureToRelease;
159
160	/** Critical section protecting: . */
161	RTCRITSECT CritSect;
162	/** Buffer that drvHostWasStreamStatusString uses. */
163	char szStatus[128];
164	} DRVHOSTAUDIOWASSTREAM;
165	/** Pointer to a WASABI stream. */
166	typedef DRVHOSTAUDIOWASSTREAM *PDRVHOSTAUDIOWASSTREAM;
167
168
169	/**
170	* WASAPI-specific device entry.
171	*/
172	typedef struct DRVHOSTAUDIOWASDEV
173	{
174	/** The core structure. */
175	PDMAUDIOHOSTDEV Core;
176	/** The device ID (flexible length). */
177	RTUTF16 wszDevId[RT_FLEXIBLE_ARRAY];
178	} DRVHOSTAUDIOWASDEV;
179	/** Pointer to a DirectSound device entry. */
180	typedef DRVHOSTAUDIOWASDEV *PDRVHOSTAUDIOWASDEV;
181
182
183	/**
184	* Data for a WASAPI host audio instance.
185	*/
186	typedef struct DRVHOSTAUDIOWAS
187	{
188	/** The audio host audio interface we export. */
189	PDMIHOSTAUDIO IHostAudio;
190	/** Pointer to the PDM driver instance. */
191	PPDMDRVINS pDrvIns;
192	/** Audio device enumerator instance that we use for getting the default
193	* devices (or specific ones if overriden by config). Also used for
194	* implementing enumeration. */
195	IMMDeviceEnumerator *pIEnumerator;
196	/** Notification interface. */
197	PPDMIAUDIONOTIFYFROMHOST pIAudioNotifyFromHost;
198	/** The output device ID, NULL for default. */
199	PRTUTF16 pwszOutputDevId;
200	/** The input device ID, NULL for default. */
201	PRTUTF16 pwszInputDevId;
202
203	/** Pointer to the MM notification client instance. */
204	DrvHostAudioWasMmNotifyClient *pNotifyClient;
205	/** The input device to use. This can be NULL if there wasn't a suitable one
206	* around when we last looked or if it got removed/disabled/whatever.
207	* All access must be done inside the pNotifyClient critsect. */
208	IMMDevice *pIDeviceInput;
209	/** The output device to use. This can be NULL if there wasn't a suitable one
210	* around when we last looked or if it got removed/disabled/whatever.
211	* All access must be done inside the pNotifyClient critsect. */
212	IMMDevice *pIDeviceOutput;
213
214	/** A drain stop timer that makes sure a draining stream will be properly
215	* stopped (mainly for clean state and to reduce resource usage). */
216	TMTIMERHANDLE hDrainTimer;
217	/** List of streams (DRVHOSTAUDIOWASSTREAM).
218	* Requires CritSect ownership. */
219	RTLISTANCHOR StreamHead;
220	/** Serializing access to StreamHead. */
221	RTCRITSECTRW CritSectStreamList;
222
223	/** List of cached devices (DRVHOSTAUDIOWASCACHEDEV).
224	* Protected by CritSectCache */
225	RTLISTANCHOR CacheHead;
226	/** Serializing access to CacheHead. */
227	RTCRITSECT CritSectCache;
228
229	} DRVHOSTAUDIOWAS;
230	/** Pointer to the data for a WASAPI host audio driver instance. */
231	typedef DRVHOSTAUDIOWAS *PDRVHOSTAUDIOWAS;
232
233
234
235
236	/**
237	* Gets the stream status.
238	*
239	* @returns Pointer to stream status string.
240	* @param pStreamWas The stream to get the status for.
241	*/
242	static const char *drvHostWasStreamStatusString(PDRVHOSTAUDIOWASSTREAM pStreamWas)
243	{
244	static RTSTRTUPLE const s_aEnable[2] =
245	{
246	RT_STR_TUPLE("DISABLED"),
247	RT_STR_TUPLE("ENABLED ")
248	};
249	PCRTSTRTUPLE pTuple = &s_aEnable[pStreamWas->fEnabled];
250	memcpy(pStreamWas->szStatus, pTuple->psz, pTuple->cch);
251	size_t off = pTuple->cch;
252
253	static RTSTRTUPLE const s_aStarted[2] =
254	{
255	RT_STR_TUPLE(" STARTED"),
256	RT_STR_TUPLE(" STOPPED")
257	};
258	pTuple = &s_aStarted[pStreamWas->fStarted];
259	memcpy(&pStreamWas->szStatus[off], pTuple->psz, pTuple->cch);
260	off += pTuple->cch;
261
262	static RTSTRTUPLE const s_aDraining[2] =
263	{
264	RT_STR_TUPLE(""),
265	RT_STR_TUPLE(" DRAINING")
266	};
267	pTuple = &s_aDraining[pStreamWas->fDraining];
268	memcpy(&pStreamWas->szStatus[off], pTuple->psz, pTuple->cch);
269	off += pTuple->cch;
270
271	pStreamWas->szStatus[off] = '\0';
272	return pStreamWas->szStatus;
273	}
274
275
276	/*********************************************************************************************************************************
277	* Pre-activated audio device client cache. *
278	*********************************************************************************************************************************/
279	#define WAS_CACHE_MAX_ENTRIES_SAME_DEVICE 2
280
281	/**
282	* Converts from PDM stream config to windows WAVEFORMATEX struct.
283	*
284	* @param pCfg The PDM audio stream config to convert from.
285	* @param pFmt The windows structure to initialize.
286	*/
287	static void drvHostAudioWasWaveFmtExFromCfg(PCPDMAUDIOSTREAMCFG pCfg, PWAVEFORMATEX pFmt)
288	{
289	RT_ZERO(*pFmt);
290	pFmt->wFormatTag = WAVE_FORMAT_PCM;
291	pFmt->nChannels = PDMAudioPropsChannels(&pCfg->Props);
292	pFmt->wBitsPerSample = PDMAudioPropsSampleBits(&pCfg->Props);
293	pFmt->nSamplesPerSec = PDMAudioPropsHz(&pCfg->Props);
294	pFmt->nBlockAlign = PDMAudioPropsFrameSize(&pCfg->Props);
295	pFmt->nAvgBytesPerSec = PDMAudioPropsFramesToBytes(&pCfg->Props, PDMAudioPropsHz(&pCfg->Props));
296	pFmt->cbSize = 0; /* No extra data specified. */
297	}
298
299
300	/**
301	* Converts from windows WAVEFORMATEX and stream props to PDM audio properties.
302	*
303	* @returns VINF_SUCCESS on success, VERR_AUDIO_STREAM_COULD_NOT_CREATE if not
304	* supported.
305	* @param pCfg The stream configuration to update (input:
306	* requested config; output: acquired).
307	* @param pFmt The windows wave format structure.
308	* @param pszStream The stream name for error logging.
309	* @param pwszDevId The device ID for error logging.
310	*/
311	static int drvHostAudioWasCacheWaveFmtExToProps(PPDMAUDIOPCMPROPS pProps, WAVEFORMATEX const *pFmt,
312	const char *pszStream, PCRTUTF16 pwszDevId)
313	{
314	if (pFmt->wFormatTag == WAVE_FORMAT_PCM)
315	{
316	if ( pFmt->wBitsPerSample == 8
317	\|\| pFmt->wBitsPerSample == 16
318	\|\| pFmt->wBitsPerSample == 32)
319	{
320	if (pFmt->nChannels > 0 && pFmt->nChannels < 16)
321	{
322	if (pFmt->nSamplesPerSec >= 4096 && pFmt->nSamplesPerSec <= 768000)
323	{
324	PDMAudioPropsInit(pProps, pFmt->wBitsPerSample / 8, true /fSigned/, pFmt->nChannels, pFmt->nSamplesPerSec);
325	if (PDMAudioPropsFrameSize(pProps) == pFmt->nBlockAlign)
326	return VINF_SUCCESS;
327	}
328	}
329	}
330	}
331	LogRelMax(64, ("WasAPI: Error! Unsupported stream format for '%s' suggested by '%ls':\n"
332	"WasAPI: wFormatTag = %RU16 (expected %d)\n"
333	"WasAPI: nChannels = %RU16 (expected 1..15)\n"
334	"WasAPI: nSamplesPerSec = %RU32 (expected 4096..768000)\n"
335	"WasAPI: nAvgBytesPerSec = %RU32\n"
336	"WasAPI: nBlockAlign = %RU16\n"
337	"WasAPI: wBitsPerSample = %RU16 (expected 8, 16, or 32)\n"
338	"WasAPI: cbSize = %RU16\n",
339	pszStream, pwszDevId, pFmt->wFormatTag, WAVE_FORMAT_PCM, pFmt->nChannels, pFmt->nSamplesPerSec, pFmt->nAvgBytesPerSec,
340	pFmt->nBlockAlign, pFmt->wBitsPerSample, pFmt->cbSize));
341	return VERR_AUDIO_STREAM_COULD_NOT_CREATE;
342	}
343
344
345	/**
346	* Destroys a devie config cache entry.
347	*
348	* @param pDevCfg Device config entry. Must not be in the list.
349	*/
350	static void drvHostAudioWasCacheDestroyDevConfig(PDRVHOSTAUDIOWASCACHEDEVCFG pDevCfg)
351	{
352	uint32_t cTypeClientRefs = 0;
353	if (pDevCfg->pIAudioCaptureClient)
354	{
355	cTypeClientRefs = pDevCfg->pIAudioCaptureClient->Release();
356	pDevCfg->pIAudioCaptureClient = NULL;
357	}
358
359	if (pDevCfg->pIAudioRenderClient)
360	{
361	cTypeClientRefs = pDevCfg->pIAudioRenderClient->Release();
362	pDevCfg->pIAudioRenderClient = NULL;
363	}
364
365	uint32_t cClientRefs = 0;
366	if (pDevCfg->pIAudioClient /* paranoia */)
367	{
368	cClientRefs = pDevCfg->pIAudioClient->Release();
369	pDevCfg->pIAudioClient = NULL;
370	}
371
372	Log8Func(("Destroying cache config entry: '%ls: %s' - cClientRefs=%u cTypeClientRefs=%u\n",
373	pDevCfg->pDevEntry->wszDevId, pDevCfg->szProps, cClientRefs, cTypeClientRefs));
374	RT_NOREF(cClientRefs, cTypeClientRefs);
375
376	pDevCfg->pDevEntry = NULL;
377	RTMemFree(pDevCfg);
378	}
379
380
381	/**
382	* Destroys a device cache entry.
383	*
384	* @param pDevEntry The device entry. Must not be in the cache!
385	*/
386	static void drvHostAudioWasCacheDestroyDevEntry(PDRVHOSTAUDIOWASCACHEDEV pDevEntry)
387	{
388	Log8Func(("Destroying cache entry: %p - '%ls'\n", pDevEntry, pDevEntry->wszDevId));
389
390	PDRVHOSTAUDIOWASCACHEDEVCFG pDevCfg, pDevCfgNext;
391	RTListForEachSafe(&pDevEntry->ConfigList, pDevCfg, pDevCfgNext, DRVHOSTAUDIOWASCACHEDEVCFG, ListEntry)
392	{
393	drvHostAudioWasCacheDestroyDevConfig(pDevCfg);
394	}
395
396	uint32_t cDevRefs = 0;
397	if (pDevEntry->pIDevice /* paranoia */)
398	{
399	cDevRefs = pDevEntry->pIDevice->Release();
400	pDevEntry->pIDevice = NULL;
401	}
402
403	pDevEntry->cwcDevId = 0;
404	pDevEntry->wszDevId[0] = '\0';
405	RTMemFree(pDevEntry);
406	Log8Func(("Destroyed cache entry: %p cDevRefs=%u\n", pDevEntry, cDevRefs));
407	}
408
409
410	/**
411	* Purges all the entries in the cache.
412	*/
413	static void drvHostAudioWasCachePurge(PDRVHOSTAUDIOWAS pThis)
414	{
415	for (;;)
416	{
417	RTCritSectEnter(&pThis->CritSectCache);
418	PDRVHOSTAUDIOWASCACHEDEV pDevEntry = RTListRemoveFirst(&pThis->CacheHead, DRVHOSTAUDIOWASCACHEDEV, ListEntry);
419	RTCritSectLeave(&pThis->CritSectCache);
420	if (!pDevEntry)
421	break;
422	drvHostAudioWasCacheDestroyDevEntry(pDevEntry);
423	}
424	}
425
426
427	/**
428	* Looks up a specific configuration.
429	*
430	* @returns Pointer to the device config (removed from cache) on success. NULL
431	* if no matching config found.
432	* @param pDevEntry Where to perform the lookup.
433	* @param pProp The config properties to match.
434	*/
435	static PDRVHOSTAUDIOWASCACHEDEVCFG
436	drvHostAudioWasCacheLookupLocked(PDRVHOSTAUDIOWASCACHEDEV pDevEntry, PCPDMAUDIOPCMPROPS pProps)
437	{
438	PDRVHOSTAUDIOWASCACHEDEVCFG pDevCfg;
439	RTListForEach(&pDevEntry->ConfigList, pDevCfg, DRVHOSTAUDIOWASCACHEDEVCFG, ListEntry)
440	{
441	if (PDMAudioPropsAreEqual(&pDevCfg->Props, pProps))
442	{
443	RTListNodeRemove(&pDevCfg->ListEntry);
444	return pDevCfg;
445	}
446	}
447	return NULL;
448	}
449
450	/**
451	* Creates a device config entry using the given parameters.
452	*
453	* The entry is not added to the cache but returned.
454	*
455	* @returns Pointer to the new device config entry. NULL on failure.
456	* @param pDevEntry The device entry it belongs to.
457	* @param pCfgReq The requested configuration.
458	* @param pWaveFmtEx The actual configuration.
459	* @param pIAudioClient The audio client, reference consumed.
460	*/
461	static PDRVHOSTAUDIOWASCACHEDEVCFG
462	drvHostAudioWasCacheCreateConfig(PDRVHOSTAUDIOWASCACHEDEV pDevEntry, PCPDMAUDIOSTREAMCFG pCfgReq,
463	WAVEFORMATEX const pWaveFmtEx, IAudioClient pIAudioClient)
464	{
465	PDRVHOSTAUDIOWASCACHEDEVCFG pDevCfg = (PDRVHOSTAUDIOWASCACHEDEVCFG)RTMemAllocZ(sizeof(*pDevCfg));
466	if (pDevCfg)
467	{
468	RTListInit(&pDevCfg->ListEntry);
469	pDevCfg->pDevEntry = pDevEntry;
470	pDevCfg->pIAudioClient = pIAudioClient;
471	HRESULT hrc;
472	if (pCfgReq->enmDir == PDMAUDIODIR_IN)
473	hrc = pIAudioClient->GetService(__uuidof(IAudioCaptureClient), (void **)&pDevCfg->pIAudioCaptureClient);
474	else
475	hrc = pIAudioClient->GetService(__uuidof(IAudioRenderClient), (void **)&pDevCfg->pIAudioRenderClient);
476	Log8Func(("GetService -> %Rhrc + %p\n", hrc, pCfgReq->enmDir == PDMAUDIODIR_IN
477	? (void )pDevCfg->pIAudioCaptureClient : (void )pDevCfg->pIAudioRenderClient));
478	if (SUCCEEDED(hrc))
479	{
480	/*
481	* Obtain the actual stream format and buffer config.
482	* (A bit ugly structure here to keep it from hitting the right margin. Sorry.)
483	*/
484	UINT32 cFramesBufferSize = 0;
485	REFERENCE_TIME cDefaultPeriodInNtTicks = 0;
486	REFERENCE_TIME cMinimumPeriodInNtTicks = 0;
487	REFERENCE_TIME cLatencyinNtTicks = 0;
488	hrc = pIAudioClient->GetBufferSize(&cFramesBufferSize);
489	if (SUCCEEDED(hrc))
490	hrc = pIAudioClient->GetDevicePeriod(&cDefaultPeriodInNtTicks, &cMinimumPeriodInNtTicks);
491	else
492	LogRelMax(64, ("WasAPI: GetBufferSize failed: %Rhrc\n", hrc));
493	if (SUCCEEDED(hrc))
494	hrc = pIAudioClient->GetStreamLatency(&cLatencyinNtTicks);
495	else
496	LogRelMax(64, ("WasAPI: GetDevicePeriod failed: %Rhrc\n", hrc));
497	if (SUCCEEDED(hrc))
498	{
499	LogRel2(("WasAPI: Aquired buffer parameters for %s:\n"
500	"WasAPI: cFramesBufferSize = %RU32\n"
501	"WasAPI: cDefaultPeriodInNtTicks = %RI64\n"
502	"WasAPI: cMinimumPeriodInNtTicks = %RI64\n"
503	"WasAPI: cLatencyinNtTicks = %RI64\n",
504	pCfgReq->szName, cFramesBufferSize, cDefaultPeriodInNtTicks, cMinimumPeriodInNtTicks, cLatencyinNtTicks));
505
506	int rc = drvHostAudioWasCacheWaveFmtExToProps(&pDevCfg->Props, pWaveFmtEx, pCfgReq->szName, pDevEntry->wszDevId);
507	if (RT_SUCCESS(rc))
508	{
509	pDevCfg->cFramesBufferSize = cFramesBufferSize;
510	pDevCfg->cFramesPeriod = PDMAudioPropsNanoToFrames(&pDevCfg->Props, cDefaultPeriodInNtTicks * 100);
511
512	PDMAudioPropsToString(&pDevCfg->Props, pDevCfg->szProps, sizeof(pDevCfg->szProps));
513	return pDevCfg;
514	}
515	}
516	else
517	LogRelMax(64, ("WasAPI: GetStreamLatency failed: %Rhrc\n", hrc));
518
519	if (pDevCfg->pIAudioCaptureClient)
520	{
521	pDevCfg->pIAudioCaptureClient->Release();
522	pDevCfg->pIAudioCaptureClient = NULL;
523	}
524
525	if (pDevCfg->pIAudioRenderClient)
526	{
527	pDevCfg->pIAudioRenderClient->Release();
528	pDevCfg->pIAudioRenderClient = NULL;
529	}
530	}
531	RTMemFree(pDevCfg);
532	}
533	pIAudioClient->Release();
534	return NULL;
535	}
536
537
538	/**
539	* Worker for drvHostAudioWasCacheLookupOrCreate.
540	*
541	* If lookup fails, a new entry will be created.
542	*
543	* @note Called holding the lock, returning without holding it!
544	*/
545	static PDRVHOSTAUDIOWASCACHEDEVCFG
546	drvHostAudioWasCacheLookupOrCreateConfig(PDRVHOSTAUDIOWAS pThis, PDRVHOSTAUDIOWASCACHEDEV pDevEntry, PCPDMAUDIOSTREAMCFG pCfgReq)
547	{
548	char szProps[64];
549	PDMAudioPropsToString(&pCfgReq->Props, szProps, sizeof(szProps));
550
551	/*
552	* Check if we've got a matching config.
553	*/
554	PDRVHOSTAUDIOWASCACHEDEVCFG pDevCfg = drvHostAudioWasCacheLookupLocked(pDevEntry, &pCfgReq->Props);
555	if (pDevCfg)
556	{
557	RTCritSectLeave(&pThis->CritSectCache);
558	Log8Func(("Config cache hit '%s' (for '%s') on '%ls': %p\n", pDevCfg->szProps, szProps, pDevEntry->wszDevId, pDevCfg));
559	return pDevCfg;
560	}
561
562	/*
563	* We now need an IAudioClient interface for calling IsFormatSupported
564	* on so we can get guidance as to what to do next.
565	*
566	* Initially, I thought the AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM was not
567	* supported all the way back to Vista and that we'd had to try different
568	* things here to get the most optimal format. However, according to
569	* https://social.msdn.microsoft.com/Forums/en-US/1d974d90-6636-4121-bba3-a8861d9ab92a
570	* it is supported, just maybe missing from the SDK or something...
571	*/
572	RTCritSectLeave(&pThis->CritSectCache);
573
574	REFERENCE_TIME const cBufferSizeInNtTicks = PDMAudioPropsFramesToNtTicks(&pCfgReq->Props, pCfgReq->Backend.cFramesBufferSize);
575
576	Log8Func(("Activating an IAudioClient for '%ls' ...\n", pDevEntry->wszDevId));
577	IAudioClient *pIAudioClient = NULL;
578	HRESULT hrc = pDevEntry->pIDevice->Activate(__uuidof(IAudioClient), CLSCTX_ALL,
579	NULL /pActivationParams/, (void **)&pIAudioClient);
580	Log8Func(("Activate('%ls', IAudioClient) -> %Rhrc\n", pDevEntry->wszDevId, hrc));
581	if (FAILED(hrc))
582	{
583	LogRelMax(64, ("WasAPI: Activate(%ls, IAudioClient) failed: %Rhrc\n", pDevEntry->wszDevId, hrc));
584	return NULL;
585	}
586
587	WAVEFORMATEX WaveFmtEx;
588	drvHostAudioWasWaveFmtExFromCfg(pCfgReq, &WaveFmtEx);
589
590	PWAVEFORMATEX pClosestMatch = NULL;
591	hrc = pIAudioClient->IsFormatSupported(AUDCLNT_SHAREMODE_SHARED, &WaveFmtEx, &pClosestMatch);
592
593	/*
594	* If the format is supported, create a cache entry for it.
595	*/
596	if (SUCCEEDED(hrc))
597	{
598	if (hrc == S_OK)
599	Log8Func(("IsFormatSupport(,%s,) -> S_OK + %p: requested format is supported\n", szProps, pClosestMatch));
600	else
601	Log8Func(("IsFormatSupport(,%s,) -> %Rhrc + %p: %uch S%u %uHz\n", szProps, hrc, pClosestMatch,
602	pClosestMatch ? pClosestMatch->nChannels : 0, pClosestMatch ? pClosestMatch->wBitsPerSample : 0,
603	pClosestMatch ? pClosestMatch->nSamplesPerSec : 0));
604
605	uint32_t fInitFlags = AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM
606	\| AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY;
607	hrc = pIAudioClient->Initialize(AUDCLNT_SHAREMODE_SHARED, fInitFlags, cBufferSizeInNtTicks,
608	0 /cPeriodicityInNtTicks/, &WaveFmtEx, NULL /pAudioSessionGuid/);
609	Log8Func(("Initialize(,%x, %RI64, %s,) -> %Rhrc\n", fInitFlags, cBufferSizeInNtTicks, szProps, hrc));
610	if (SUCCEEDED(hrc))
611	{
612	if (pClosestMatch)
613	CoTaskMemFree(pClosestMatch);
614	Log8Func(("Creating new config for '%s' on '%ls': %p\n", szProps, pDevEntry->wszDevId, pDevCfg));
615	return drvHostAudioWasCacheCreateConfig(pDevEntry, pCfgReq, &WaveFmtEx, pIAudioClient);
616	}
617
618	LogRelMax(64, ("WasAPI: IAudioClient::Initialize(%s: %s) failed: %Rhrc\n", pCfgReq->szName, szProps, hrc));
619
620	#if 0 /* later if needed */
621	/*
622	* Try lookup or instantiate the closest config.
623	*/
624	PDMAUDIOSTREAMCFG ClosestCfg = *pCfgReq;
625	int rc = drvHostAudioWasCacheWaveFmtExToProps(&ClosestCfg.Props, pClosestMatch, pDevEntry->wszDevId);
626	if (RT_SUCCESS(rc))
627	{
628	RTCritSectEnter(&pThis->CritSectCache);
629	pDevCfg = drvHostAudioWasCacheLookupLocked(pDevEntry, &pCfgReq->Props);
630	if (pDevCfg)
631	{
632	CoTaskMemFree(pClosestMatch);
633	Log8Func(("Config cache hit '%s' (for '%s') on '%ls': %p\n", pDevCfg->szProps, szProps, pDevEntry->wszDevId, pDevCfg));
634	return pDevCfg;
635	}
636	RTCritSectLeave(&pThis->CritSectCache);
637	}
638	#endif
639	}
640	else
641	LogRelMax(64,("WasAPI: IAudioClient::IsFormatSupport(,%s: %s,) failed: %Rhrc\n", pCfgReq->szName, szProps, hrc));
642
643	pIAudioClient->Release();
644	if (pClosestMatch)
645	CoTaskMemFree(pClosestMatch);
646	Log8Func(("returns NULL\n"));
647	return NULL;
648	}
649
650
651	/**
652	* Looks up the given device + config combo in the cache, creating a new entry
653	* if missing.
654	*
655	* @returns Pointer to the requested device config (or closest alternative).
656	* NULL on failure (TODO: need to return why).
657	* @param pThis The WASAPI host audio driver instance data.
658	* @param pIDevice The device to look up.
659	* @param pCfgReq The configuration to look up.
660	*/
661	static PDRVHOSTAUDIOWASCACHEDEVCFG
662	drvHostAudioWasCacheLookupOrCreate(PDRVHOSTAUDIOWAS pThis, IMMDevice *pIDevice, PCPDMAUDIOSTREAMCFG pCfgReq)
663	{
664	/*
665	* Get the device ID so we can perform the lookup.
666	*/
667	LPWSTR pwszDevId = NULL;
668	HRESULT hrc = pIDevice->GetId(&pwszDevId);
669	if (SUCCEEDED(hrc))
670	{
671	size_t cwcDevId = RTUtf16Len(pwszDevId);
672
673	/*
674	* The cache has two levels, so first the device entry.
675	*/
676	PDRVHOSTAUDIOWASCACHEDEV pDevEntry;
677	RTCritSectEnter(&pThis->CritSectCache);
678	RTListForEach(&pThis->CacheHead, pDevEntry, DRVHOSTAUDIOWASCACHEDEV, ListEntry)
679	{
680	if ( pDevEntry->cwcDevId == cwcDevId
681	&& pDevEntry->enmDir == pCfgReq->enmDir
682	&& RTUtf16Cmp(pDevEntry->wszDevId, pwszDevId) == 0)
683	{
684	CoTaskMemFree(pwszDevId);
685	Log8Func(("Cache hit for device '%ls': %p\n", pDevEntry->wszDevId, pDevEntry));
686	return drvHostAudioWasCacheLookupOrCreateConfig(pThis, pDevEntry, pCfgReq);
687	}
688	}
689	RTCritSectLeave(&pThis->CritSectCache);
690
691	/*
692	* Device not in the cache, add it.
693	*/
694	pDevEntry = (PDRVHOSTAUDIOWASCACHEDEV)RTMemAllocZVar(RT_UOFFSETOF_DYN(DRVHOSTAUDIOWASCACHEDEV, wszDevId[cwcDevId + 1]));
695	if (pDevEntry)
696	{
697	pIDevice->AddRef();
698	pDevEntry->pIDevice = pIDevice;
699	pDevEntry->enmDir = pCfgReq->enmDir;
700	pDevEntry->cwcDevId = cwcDevId;
701	#if 0
702	pDevEntry->fSupportsAutoConvertPcm = -1;
703	pDevEntry->fSupportsSrcDefaultQuality = -1;
704	#endif
705	RTListInit(&pDevEntry->ConfigList);
706	memcpy(pDevEntry->wszDevId, pwszDevId, cwcDevId * sizeof(RTUTF16));
707	pDevEntry->wszDevId[cwcDevId] = '\0';
708
709	CoTaskMemFree(pwszDevId);
710	pwszDevId = NULL;
711
712	/*
713	* Before adding the device, check that someone didn't race us adding it.
714	*/
715	RTCritSectEnter(&pThis->CritSectCache);
716	PDRVHOSTAUDIOWASCACHEDEV pDevEntry2;
717	RTListForEach(&pThis->CacheHead, pDevEntry2, DRVHOSTAUDIOWASCACHEDEV, ListEntry)
718	{
719	if ( pDevEntry2->cwcDevId == cwcDevId
720	&& pDevEntry2->enmDir == pCfgReq->enmDir
721	&& RTUtf16Cmp(pDevEntry2->wszDevId, pDevEntry->wszDevId) == 0)
722	{
723	pIDevice->Release();
724	RTMemFree(pDevEntry);
725	pDevEntry = NULL;
726
727	Log8Func(("Lost race adding device '%ls': %p\n", pDevEntry2->wszDevId, pDevEntry2));
728	return drvHostAudioWasCacheLookupOrCreateConfig(pThis, pDevEntry2, pCfgReq);
729	}
730	}
731	RTListPrepend(&pThis->CacheHead, &pDevEntry->ListEntry);
732
733	Log8Func(("Added device '%ls' to cache: %p\n", pDevEntry->wszDevId, pDevEntry));
734	return drvHostAudioWasCacheLookupOrCreateConfig(pThis, pDevEntry, pCfgReq);
735	}
736	CoTaskMemFree(pwszDevId);
737	}
738	else
739	LogRelMax(64, ("WasAPI: GetId failed (lookup): %Rhrc\n", hrc));
740	return NULL;
741	}
742
743
744	/**
745	* Return the given config to the cache.
746	*
747	* @param pThis The WASAPI host audio driver instance data.
748	* @param pDevCfg The device config to put back.
749	*/
750	static void drvHostAudioWasCachePutBack(PDRVHOSTAUDIOWAS pThis, PDRVHOSTAUDIOWASCACHEDEVCFG pDevCfg)
751	{
752	/*
753	* Reset the audio client to see that it works and to make sure it's in a sensible state.
754	*/
755	HRESULT hrc = pDevCfg->pIAudioClient->Reset();
756	if (SUCCEEDED(hrc))
757	{
758	Log8Func(("Putting %p/'%s' back\n", pDevCfg, pDevCfg->szProps));
759	RTCritSectEnter(&pThis->CritSectCache);
760	RTListAppend(&pDevCfg->pDevEntry->ConfigList, &pDevCfg->ListEntry);
761	RTCritSectLeave(&pThis->CritSectCache);
762	}
763	else
764	{
765	Log8Func(("IAudioClient::Reset failed (%Rhrc) on %p/'%s', destroying it.\n", hrc, pDevCfg, pDevCfg->szProps));
766	drvHostAudioWasCacheDestroyDevConfig(pDevCfg);
767	}
768	}
769
770
771	/**
772	* Prefills the cache.
773	*
774	* @param pThis The WASAPI host audio driver instance data.
775	*/
776	static void drvHostAudioWasCacheFill(PDRVHOSTAUDIOWAS pThis)
777	{
778	#if 0 /* we don't have the buffer config nor do we really know which frequences to expect */
779	Log8Func(("enter\n"));
780	struct
781	{
782	PCRTUTF16 pwszDevId;
783	PDMAUDIODIR enmDir;
784	} aToCache[] =
785	{
786	{ pThis->pwszInputDevId, PDMAUDIODIR_IN },
787	{ pThis->pwszOutputDevId, PDMAUDIODIR_OUT }
788	};
789	for (unsigned i = 0; i < RT_ELEMENTS(aToCache); i++)
790	{
791	PCRTUTF16 pwszDevId = aToCache[i].pwszDevId;
792	IMMDevice *pIDevice = NULL;
793	HRESULT hrc;
794	if (pwszDevId)
795	hrc = pThis->pIEnumerator->GetDevice(pwszDevId, &pIDevice);
796	else
797	{
798	hrc = pThis->pIEnumerator->GetDefaultAudioEndpoint(aToCache[i].enmDir == PDMAUDIODIR_IN ? eCapture : eRender,
799	eMultimedia, &pIDevice);
800	pwszDevId = aToCache[i].enmDir == PDMAUDIODIR_IN ? L"{Default-In}" : L"{Default-Out}";
801	}
802	if (SUCCEEDED(hrc))
803	{
804	PDMAUDIOSTREAMCFG Cfg = { aToCache[i].enmDir, { PDMAUDIOPLAYBACKDST_INVALID },
805	PDMAUDIOPCMPROPS_INITIALIZER(2, true, 2, 44100, false) };
806	Cfg.Backend.cFramesBufferSize = PDMAudioPropsMilliToFrames(&Cfg.Props, 300);
807	PDRVHOSTAUDIOWASCACHEDEVCFG pDevCfg = drvHostAudioWasCacheLookupOrCreate(pThis, pIDevice, &Cfg);
808	if (pDevCfg)
809	drvHostAudioWasCachePutBack(pThis, pDevCfg);
810
811	pIDevice->Release();
812	}
813	else
814	LogRelMax(64, ("WasAPI: Failed to open audio device '%ls' (pre-caching): %Rhrc\n", pwszDevId, hrc));
815	}
816	Log8Func(("leave\n"));
817	#else
818	RT_NOREF(pThis);
819	#endif
820	}
821
822
823	/*********************************************************************************************************************************
824	* IMMNotificationClient implementation
825	*********************************************************************************************************************************/
826	/**
827	* Multimedia notification client.
828	*
829	* We want to know when the default device changes so we can switch running
830	* streams to use the new one and so we can pre-activate it in preparation
831	* for new streams.
832	*/
833	class DrvHostAudioWasMmNotifyClient : public IMMNotificationClient
834	{
835	private:
836	/** Reference counter. */
837	uint32_t volatile m_cRefs;
838	/** The WASAPI host audio driver instance data.
839	* @note This can be NULL. Only access after entering critical section. */
840	PDRVHOSTAUDIOWAS m_pDrvWas;
841	/** Critical section serializing access to m_pDrvWas. */
842	RTCRITSECT m_CritSect;
843
844	public:
845	/**
846	* @throws int on critical section init failure.
847	*/
848	DrvHostAudioWasMmNotifyClient(PDRVHOSTAUDIOWAS a_pDrvWas)
849	: m_cRefs(1)
850	, m_pDrvWas(a_pDrvWas)
851	{
852	int rc = RTCritSectInit(&m_CritSect);
853	AssertRCStmt(rc, throw(rc));
854	}
855
856	virtual ~DrvHostAudioWasMmNotifyClient() RT_NOEXCEPT
857	{
858	RTCritSectDelete(&m_CritSect);
859	}
860
861	/**
862	* Called by drvHostAudioWasDestruct to set m_pDrvWas to NULL.
863	*/
864	void notifyDriverDestroyed() RT_NOEXCEPT
865	{
866	RTCritSectEnter(&m_CritSect);
867	m_pDrvWas = NULL;
868	RTCritSectLeave(&m_CritSect);
869	}
870
871	/**
872	* Enters the notification critsect for getting at the IMMDevice members in
873	* PDMHOSTAUDIOWAS.
874	*/
875	void lockEnter() RT_NOEXCEPT
876	{
877	RTCritSectEnter(&m_CritSect);
878	}
879
880	/**
881	* Leaves the notification critsect.
882	*/
883	void lockLeave() RT_NOEXCEPT
884	{
885	RTCritSectLeave(&m_CritSect);
886	}
887
888	/** @name IUnknown interface
889	* @{ */
890	IFACEMETHODIMP_(ULONG) AddRef()
891	{
892	uint32_t cRefs = ASMAtomicIncU32(&m_cRefs);
893	AssertMsg(cRefs < 64, ("%#x\n", cRefs));
894	Log6Func(("returns %u\n", cRefs));
895	return cRefs;
896	}
897
898	IFACEMETHODIMP_(ULONG) Release()
899	{
900	uint32_t cRefs = ASMAtomicDecU32(&m_cRefs);
901	AssertMsg(cRefs < 64, ("%#x\n", cRefs));
902	if (cRefs == 0)
903	delete this;
904	Log6Func(("returns %u\n", cRefs));
905	return cRefs;
906	}
907
908	IFACEMETHODIMP QueryInterface(const IID &rIID, void **ppvInterface)
909	{
910	if (IsEqualIID(rIID, IID_IUnknown))
911	ppvInterface = static_cast<IUnknown >(this);
912	else if (IsEqualIID(rIID, __uuidof(IMMNotificationClient)))
913	ppvInterface = static_cast<IMMNotificationClient >(this);
914	else
915	{
916	LogFunc(("Unknown rIID={%RTuuid}\n", &rIID));
917	*ppvInterface = NULL;
918	return E_NOINTERFACE;
919	}
920	Log6Func(("returns S_OK + %p\n", *ppvInterface));
921	return S_OK;
922	}
923	/** @} */
924
925	/** @name IMMNotificationClient interface
926	* @{ */
927	IFACEMETHODIMP OnDeviceStateChanged(LPCWSTR pwszDeviceId, DWORD dwNewState)
928	{
929	RT_NOREF(pwszDeviceId, dwNewState);
930	Log7Func(("pwszDeviceId=%ls dwNewState=%u (%#x)\n", pwszDeviceId, dwNewState, dwNewState));
931	return S_OK;
932	}
933
934	IFACEMETHODIMP OnDeviceAdded(LPCWSTR pwszDeviceId)
935	{
936	RT_NOREF(pwszDeviceId);
937	Log7Func(("pwszDeviceId=%ls\n", pwszDeviceId));
938
939	/*
940	* Is this a device we're interested in? Grab the enumerator if it is.
941	*/
942	bool fOutput = false;
943	IMMDeviceEnumerator *pIEnumerator = NULL;
944	RTCritSectEnter(&m_CritSect);
945	if ( m_pDrvWas != NULL
946	&& ( (fOutput = RTUtf16ICmp(m_pDrvWas->pwszOutputDevId, pwszDeviceId) == 0)
947	\|\| RTUtf16ICmp(m_pDrvWas->pwszInputDevId, pwszDeviceId) == 0))
948	{
949	pIEnumerator = m_pDrvWas->pIEnumerator;
950	if (pIEnumerator /* paranoia */)
951	pIEnumerator->AddRef();
952	}
953	RTCritSectLeave(&m_CritSect);
954	if (pIEnumerator)
955	{
956	/*
957	* Get the device and update it.
958	*/
959	IMMDevice *pIDevice = NULL;
960	HRESULT hrc = pIEnumerator->GetDevice(pwszDeviceId, &pIDevice);
961	if (SUCCEEDED(hrc))
962	setDevice(fOutput, pIDevice, pwszDeviceId, __PRETTY_FUNCTION__);
963	else
964	LogRelMax(64, ("WasAPI: Failed to get %s device '%ls' (OnDeviceAdded): %Rhrc\n",
965	fOutput ? "output" : "input", pwszDeviceId, hrc));
966	pIEnumerator->Release();
967	}
968	return S_OK;
969	}
970
971	IFACEMETHODIMP OnDeviceRemoved(LPCWSTR pwszDeviceId)
972	{
973	RT_NOREF(pwszDeviceId);
974	Log7Func(("pwszDeviceId=%ls\n", pwszDeviceId));
975
976	/*
977	* Is this a device we're interested in? Then set it to NULL.
978	*/
979	bool fOutput = false;
980	RTCritSectEnter(&m_CritSect);
981	if ( m_pDrvWas != NULL
982	&& ( (fOutput = RTUtf16ICmp(m_pDrvWas->pwszOutputDevId, pwszDeviceId) == 0)
983	\|\| RTUtf16ICmp(m_pDrvWas->pwszInputDevId, pwszDeviceId) == 0))
984	setDevice(fOutput, NULL, pwszDeviceId, __PRETTY_FUNCTION__);
985	RTCritSectLeave(&m_CritSect);
986	return S_OK;
987	}
988
989	IFACEMETHODIMP OnDefaultDeviceChanged(EDataFlow enmFlow, ERole enmRole, LPCWSTR pwszDefaultDeviceId)
990	{
991	/*
992	* Are we interested in this device? If so grab the enumerator.
993	*/
994	IMMDeviceEnumerator *pIEnumerator = NULL;
995	RTCritSectEnter(&m_CritSect);
996	if ( m_pDrvWas != NULL
997	&& ( (enmFlow == eRender && enmRole == eMultimedia && !m_pDrvWas->pwszOutputDevId)
998	\|\| (enmFlow == eCapture && enmRole == eMultimedia && !m_pDrvWas->pwszInputDevId)))
999	{
1000	pIEnumerator = m_pDrvWas->pIEnumerator;
1001	if (pIEnumerator /* paranoia */)
1002	pIEnumerator->AddRef();
1003	}
1004	RTCritSectLeave(&m_CritSect);
1005	if (pIEnumerator)
1006	{
1007	/*
1008	* Get the device and update it.
1009	*/
1010	IMMDevice *pIDevice = NULL;
1011	HRESULT hrc = pIEnumerator->GetDefaultAudioEndpoint(enmFlow, enmRole, &pIDevice);
1012	if (SUCCEEDED(hrc))
1013	setDevice(enmFlow == eRender, pIDevice, pwszDefaultDeviceId, __PRETTY_FUNCTION__);
1014	else
1015	LogRelMax(64, ("WasAPI: Failed to get default %s device (OnDefaultDeviceChange): %Rhrc\n",
1016	enmFlow == eRender ? "output" : "input", hrc));
1017	pIEnumerator->Release();
1018	}
1019
1020	RT_NOREF(enmFlow, enmRole, pwszDefaultDeviceId);
1021	Log7Func(("enmFlow=%d enmRole=%d pwszDefaultDeviceId=%ls\n", enmFlow, enmRole, pwszDefaultDeviceId));
1022	return S_OK;
1023	}
1024
1025	IFACEMETHODIMP OnPropertyValueChanged(LPCWSTR pwszDeviceId, const PROPERTYKEY Key)
1026	{
1027	RT_NOREF(pwszDeviceId, Key);
1028	Log7Func(("pwszDeviceId=%ls Key={%RTuuid, %u (%#x)}\n", pwszDeviceId, &Key.fmtid, Key.pid, Key.pid));
1029	return S_OK;
1030	}
1031	/** @} */
1032
1033	private:
1034	/**
1035	* Sets DRVHOSTAUDIOWAS::pIDeviceOutput or DRVHOSTAUDIOWAS::pIDeviceInput to @a pIDevice.
1036	*/
1037	void setDevice(bool fOutput, IMMDevice pIDevice, LPCWSTR pwszDeviceId, const char pszCaller)
1038	{
1039	RT_NOREF(pszCaller, pwszDeviceId);
1040
1041	RTCritSectEnter(&m_CritSect);
1042	if (m_pDrvWas)
1043	{
1044	if (fOutput)
1045	{
1046	Log7((LOG_FN_FMT ": Changing output device from %p to %p (%ls)\n",
1047	pszCaller, m_pDrvWas->pIDeviceOutput, pIDevice, pwszDeviceId));
1048	if (m_pDrvWas->pIDeviceOutput)
1049	m_pDrvWas->pIDeviceOutput->Release();
1050	m_pDrvWas->pIDeviceOutput = pIDevice;
1051	}
1052	else
1053	{
1054	Log7((LOG_FN_FMT ": Changing input device from %p to %p (%ls)\n",
1055	pszCaller, m_pDrvWas->pIDeviceInput, pIDevice, pwszDeviceId));
1056	if (m_pDrvWas->pIDeviceInput)
1057	m_pDrvWas->pIDeviceInput->Release();
1058	m_pDrvWas->pIDeviceInput = pIDevice;
1059	}
1060
1061	/** @todo Invalid/update in-use streams. */
1062	}
1063	else if (pIDevice)
1064	pIDevice->Release();
1065	RTCritSectLeave(&m_CritSect);
1066	}
1067	};
1068
1069
1070	/*********************************************************************************************************************************
1071	* PDMIHOSTAUDIO *
1072	*********************************************************************************************************************************/
1073
1074	/**
1075	* @interface_method_impl{PDMIHOSTAUDIO,pfnGetConfig}
1076	*/
1077	static DECLCALLBACK(int) drvHostAudioWasHA_GetConfig(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDCFG pBackendCfg)
1078	{
1079	RT_NOREF(pInterface);
1080	AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
1081	AssertPtrReturn(pBackendCfg, VERR_INVALID_POINTER);
1082
1083
1084	/*
1085	* Fill in the config structure.
1086	*/
1087	RTStrCopy(pBackendCfg->szName, sizeof(pBackendCfg->szName), "WasAPI");
1088	pBackendCfg->cbStream = sizeof(DRVHOSTAUDIOWASSTREAM);
1089	pBackendCfg->fFlags = 0;
1090	pBackendCfg->cMaxStreamsIn = UINT32_MAX;
1091	pBackendCfg->cMaxStreamsOut = UINT32_MAX;
1092
1093	return VINF_SUCCESS;
1094	}
1095
1096
1097	/**
1098	* Queries information for @a pDevice and adds an entry to the enumeration.
1099	*
1100	* @returns VBox status code.
1101	* @param pDevEnm The enumeration to add the device to.
1102	* @param pIDevice The device.
1103	* @param enmType The type of device.
1104	* @param fDefault Whether it's the default device.
1105	*/
1106	static int drvHostWasEnumAddDev(PPDMAUDIOHOSTENUM pDevEnm, IMMDevice *pIDevice, EDataFlow enmType, bool fDefault)
1107	{
1108	int rc = VINF_SUCCESS; /* ignore most errors */
1109	RT_NOREF(fDefault); /** @todo default device marking/skipping. */
1110
1111	/*
1112	* Gather the necessary properties.
1113	*/
1114	IPropertyStore *pProperties = NULL;
1115	HRESULT hrc = pIDevice->OpenPropertyStore(STGM_READ, &pProperties);
1116	if (SUCCEEDED(hrc))
1117	{
1118	/* Get the friendly name (string). */
1119	PROPVARIANT VarName;
1120	PropVariantInit(&VarName);
1121	hrc = pProperties->GetValue(PKEY_Device_FriendlyName, &VarName);
1122	if (SUCCEEDED(hrc))
1123	{
1124	/* Get the device ID (string). */
1125	LPWSTR pwszDevId = NULL;
1126	hrc = pIDevice->GetId(&pwszDevId);
1127	if (SUCCEEDED(hrc))
1128	{
1129	size_t const cwcDevId = RTUtf16Len(pwszDevId);
1130
1131	/* Get the device format (blob). */
1132	PROPVARIANT VarFormat;
1133	PropVariantInit(&VarFormat);
1134	hrc = pProperties->GetValue(PKEY_AudioEngine_DeviceFormat, &VarFormat);
1135	if (SUCCEEDED(hrc))
1136	{
1137	WAVEFORMATEX const * const pFormat = (WAVEFORMATEX const *)VarFormat.blob.pBlobData;
1138	AssertPtr(pFormat);
1139
1140	/*
1141	* Create a enumeration entry for it.
1142	*/
1143	size_t const cbDev = RT_ALIGN_Z( RT_OFFSETOF(DRVHOSTAUDIOWASDEV, wszDevId)
1144	+ (cwcDevId + 1) * sizeof(RTUTF16),
1145	64);
1146	PDRVHOSTAUDIOWASDEV pDev = (PDRVHOSTAUDIOWASDEV)PDMAudioHostDevAlloc(cbDev);
1147	if (pDev)
1148	{
1149	pDev->Core.enmUsage = enmType == eRender ? PDMAUDIODIR_OUT : PDMAUDIODIR_IN;
1150	pDev->Core.enmType = PDMAUDIODEVICETYPE_BUILTIN;
1151	if (enmType == eRender)
1152	pDev->Core.cMaxOutputChannels = pFormat->nChannels;
1153	else
1154	pDev->Core.cMaxInputChannels = pFormat->nChannels;
1155
1156	memcpy(pDev->wszDevId, pwszDevId, cwcDevId * sizeof(RTUTF16));
1157	pDev->wszDevId[cwcDevId] = '\0';
1158
1159	char *pszName;
1160	rc = RTUtf16ToUtf8(VarName.pwszVal, &pszName);
1161	if (RT_SUCCESS(rc))
1162	{
1163	RTStrCopy(pDev->Core.szName, sizeof(pDev->Core.szName), pszName);
1164	RTStrFree(pszName);
1165
1166	PDMAudioHostEnumAppend(pDevEnm, &pDev->Core);
1167	}
1168	else
1169	PDMAudioHostDevFree(&pDev->Core);
1170	}
1171	else
1172	rc = VERR_NO_MEMORY;
1173	PropVariantClear(&VarFormat);
1174	}
1175	else
1176	LogFunc(("Failed to get PKEY_AudioEngine_DeviceFormat: %Rhrc\n", hrc));
1177	CoTaskMemFree(pwszDevId);
1178	}
1179	else
1180	LogFunc(("Failed to get the device ID: %Rhrc\n", hrc));
1181	PropVariantClear(&VarName);
1182	}
1183	else
1184	LogFunc(("Failed to get PKEY_Device_FriendlyName: %Rhrc\n", hrc));
1185	pProperties->Release();
1186	}
1187	else
1188	LogFunc(("OpenPropertyStore failed: %Rhrc\n", hrc));
1189
1190	if (hrc == E_OUTOFMEMORY && RT_SUCCESS_NP(rc))
1191	rc = VERR_NO_MEMORY;
1192	return rc;
1193	}
1194
1195
1196	/**
1197	* Does a (Re-)enumeration of the host's playback + capturing devices.
1198	*
1199	* @return VBox status code.
1200	* @param pThis The WASAPI host audio driver instance data.
1201	* @param pDevEnm Where to store the enumerated devices.
1202	*/
1203	static int drvHostWasEnumerateDevices(PDRVHOSTAUDIOWAS pThis, PPDMAUDIOHOSTENUM pDevEnm)
1204	{
1205	LogRel2(("WasAPI: Enumerating devices ...\n"));
1206
1207	int rc = VINF_SUCCESS;
1208	for (unsigned idxPass = 0; idxPass < 2 && RT_SUCCESS(rc); idxPass++)
1209	{
1210	EDataFlow const enmType = idxPass == 0 ? EDataFlow::eRender : EDataFlow::eCapture;
1211
1212	/* Get the default device first. */
1213	IMMDevice *pIDefaultDevice = NULL;
1214	HRESULT hrc = pThis->pIEnumerator->GetDefaultAudioEndpoint(enmType, eMultimedia, &pIDefaultDevice);
1215	if (SUCCEEDED(hrc))
1216	rc = drvHostWasEnumAddDev(pDevEnm, pIDefaultDevice, enmType, true);
1217	else
1218	pIDefaultDevice = NULL;
1219
1220	/* Enumerate the devices. */
1221	IMMDeviceCollection *pCollection = NULL;
1222	hrc = pThis->pIEnumerator->EnumAudioEndpoints(enmType, DEVICE_STATE_ACTIVE /\| DEVICE_STATE_UNPLUGGED?/, &pCollection);
1223	if (SUCCEEDED(hrc) && pCollection != NULL)
1224	{
1225	UINT cDevices = 0;
1226	hrc = pCollection->GetCount(&cDevices);
1227	if (SUCCEEDED(hrc))
1228	{
1229	for (UINT idxDevice = 0; idxDevice < cDevices && RT_SUCCESS(rc); idxDevice++)
1230	{
1231	IMMDevice *pIDevice = NULL;
1232	hrc = pCollection->Item(idxDevice, &pIDevice);
1233	if (SUCCEEDED(hrc) && pIDevice)
1234	{
1235	if (pIDevice != pIDefaultDevice)
1236	rc = drvHostWasEnumAddDev(pDevEnm, pIDevice, enmType, false);
1237	pIDevice->Release();
1238	}
1239	}
1240	}
1241	pCollection->Release();
1242	}
1243	else
1244	LogRelMax(10, ("EnumAudioEndpoints(%s) failed: %Rhrc\n", idxPass == 0 ? "output" : "input", hrc));
1245
1246	if (pIDefaultDevice)
1247	pIDefaultDevice->Release();
1248	}
1249
1250	LogRel2(("WasAPI: Enumerating devices done - %u device (%Rrc)\n", pDevEnm->cDevices, rc));
1251	return rc;
1252	}
1253
1254
1255	/**
1256	* @interface_method_impl{PDMIHOSTAUDIO,pfnGetDevices}
1257	*/
1258	static DECLCALLBACK(int) drvHostAudioWasHA_GetDevices(PPDMIHOSTAUDIO pInterface, PPDMAUDIOHOSTENUM pDeviceEnum)
1259	{
1260	PDRVHOSTAUDIOWAS pThis = RT_FROM_MEMBER(pInterface, DRVHOSTAUDIOWAS, IHostAudio);
1261	AssertPtrReturn(pDeviceEnum, VERR_INVALID_POINTER);
1262
1263	PDMAudioHostEnumInit(pDeviceEnum);
1264	int rc = drvHostWasEnumerateDevices(pThis, pDeviceEnum);
1265	if (RT_FAILURE(rc))
1266	PDMAudioHostEnumDelete(pDeviceEnum);
1267
1268	LogFlowFunc(("Returning %Rrc\n", rc));
1269	return rc;
1270	}
1271
1272
1273	/**
1274	* @interface_method_impl{PDMIHOSTAUDIO,pfnGetStatus}
1275	*/
1276	static DECLCALLBACK(PDMAUDIOBACKENDSTS) drvHostAudioWasHA_GetStatus(PPDMIHOSTAUDIO pInterface, PDMAUDIODIR enmDir)
1277	{
1278	RT_NOREF(pInterface, enmDir);
1279	return PDMAUDIOBACKENDSTS_RUNNING;
1280	}
1281
1282
1283	/**
1284	* @interface_method_impl{PDMIHOSTAUDIO,pfnStreamCreate}
1285	*/
1286	static DECLCALLBACK(int) drvHostAudioWasHA_StreamCreate(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream,
1287	PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
1288	{
1289	PDRVHOSTAUDIOWAS pThis = RT_FROM_MEMBER(pInterface, DRVHOSTAUDIOWAS, IHostAudio);
1290	PDRVHOSTAUDIOWASSTREAM pStreamWas = (PDRVHOSTAUDIOWASSTREAM)pStream;
1291	AssertPtrReturn(pStreamWas, VERR_INVALID_POINTER);
1292	AssertPtrReturn(pCfgReq, VERR_INVALID_POINTER);
1293	AssertPtrReturn(pCfgAcq, VERR_INVALID_POINTER);
1294	AssertReturn(pCfgReq->enmDir == PDMAUDIODIR_IN \|\| pCfgReq->enmDir == PDMAUDIODIR_OUT, VERR_INVALID_PARAMETER);
1295	Assert(PDMAudioStrmCfgEquals(pCfgReq, pCfgAcq));
1296
1297	const char * const pszStreamType = pCfgReq->enmDir == PDMAUDIODIR_IN ? "capture" : "playback"; RT_NOREF(pszStreamType);
1298	LogFlowFunc(("enmSrc/Dst=%s '%s'\n",
1299	pCfgReq->enmDir == PDMAUDIODIR_IN ? PDMAudioRecSrcGetName(pCfgReq->u.enmSrc)
1300	: PDMAudioPlaybackDstGetName(pCfgReq->u.enmDst), pCfgReq->szName));
1301	#if defined(RTLOG_REL_ENABLED) \|\| defined(LOG_ENABLED)
1302	char szTmp[64];
1303	#endif
1304	LogRel2(("WasAPI: Opening %s stream '%s' (%s)\n", pCfgReq->szName, pszStreamType,
1305	PDMAudioPropsToString(&pCfgReq->Props, szTmp, sizeof(szTmp))));
1306
1307	RTListInit(&pStreamWas->ListEntry);
1308
1309	/*
1310	* Do configuration conversion.
1311	*/
1312	WAVEFORMATEX WaveFmtX;
1313	drvHostAudioWasWaveFmtExFromCfg(pCfgReq, &WaveFmtX);
1314	LogRel2(("WasAPI: Requested %s format for '%s':\n"
1315	"WasAPI: wFormatTag = %RU16\n"
1316	"WasAPI: nChannels = %RU16\n"
1317	"WasAPI: nSamplesPerSec = %RU32\n"
1318	"WasAPI: nAvgBytesPerSec = %RU32\n"
1319	"WasAPI: nBlockAlign = %RU16\n"
1320	"WasAPI: wBitsPerSample = %RU16\n"
1321	"WasAPI: cbSize = %RU16\n"
1322	"WasAPI: cBufferSizeInNtTicks = %RU64\n",
1323	pszStreamType, pCfgReq->szName, WaveFmtX.wFormatTag, WaveFmtX.nChannels, WaveFmtX.nSamplesPerSec,
1324	WaveFmtX.nAvgBytesPerSec, WaveFmtX.nBlockAlign, WaveFmtX.wBitsPerSample, WaveFmtX.cbSize,
1325	PDMAudioPropsFramesToNtTicks(&pCfgReq->Props, pCfgReq->Backend.cFramesBufferSize) ));
1326
1327	/*
1328	* Get the device we're supposed to use.
1329	* (We cache this as it takes ~2ms to get the default device on a random W10 19042 system.)
1330	*/
1331	pThis->pNotifyClient->lockEnter();
1332	IMMDevice *pIDevice = pCfgReq->enmDir == PDMAUDIODIR_IN ? pThis->pIDeviceInput : pThis->pIDeviceOutput;
1333	if (pIDevice)
1334	pIDevice->AddRef();
1335	pThis->pNotifyClient->lockLeave();
1336
1337	PRTUTF16 pwszDevId = pCfgReq->enmDir == PDMAUDIODIR_IN ? pThis->pwszInputDevId : pThis->pwszOutputDevId;
1338	PRTUTF16 const pwszDevIdDesc = pwszDevId ? pwszDevId : pCfgReq->enmDir == PDMAUDIODIR_IN ? L"{Default-In}" : L"{Default-Out}";
1339	if (!pIDevice)
1340	{
1341	/** @todo we can eliminate this too... */
1342	HRESULT hrc;
1343	if (pwszDevId)
1344	hrc = pThis->pIEnumerator->GetDevice(pwszDevId, &pIDevice);
1345	else
1346	hrc = pThis->pIEnumerator->GetDefaultAudioEndpoint(pCfgReq->enmDir == PDMAUDIODIR_IN ? eCapture : eRender,
1347	eMultimedia, &pIDevice);
1348	LogFlowFunc(("Got device %p (%Rhrc)\n", pIDevice, hrc));
1349	if (FAILED(hrc))
1350	{
1351	LogRelMax(64, ("WasAPI: Failed to open audio %s device '%ls': %Rhrc\n", pszStreamType, pwszDevIdDesc, hrc));
1352	return VERR_AUDIO_STREAM_COULD_NOT_CREATE;
1353	}
1354	}
1355
1356	/*
1357	* Ask the cache to retrieve or instantiate the requested configuration.
1358	*/
1359	/** @todo make it return a status code too and retry if the default device
1360	* was invalidated/changed while we where working on it here. */
1361	int rc = VERR_AUDIO_STREAM_COULD_NOT_CREATE;
1362	PDRVHOSTAUDIOWASCACHEDEVCFG pDevCfg = drvHostAudioWasCacheLookupOrCreate(pThis, pIDevice, pCfgReq);
1363
1364	pIDevice->Release();
1365	pIDevice = NULL;
1366
1367	if (pDevCfg)
1368	{
1369	pStreamWas->pDevCfg = pDevCfg;
1370
1371	pCfgAcq->Props = pDevCfg->Props;
1372	pCfgAcq->Backend.cFramesBufferSize = pDevCfg->cFramesBufferSize;
1373	pCfgAcq->Backend.cFramesPeriod = pDevCfg->cFramesPeriod;
1374	pCfgAcq->Backend.cFramesPreBuffering = pCfgReq->Backend.cFramesPreBuffering * pDevCfg->cFramesBufferSize
1375	/ RT_MAX(pCfgReq->Backend.cFramesBufferSize, 1);
1376
1377	PDMAudioStrmCfgCopy(&pStreamWas->Cfg, pCfgAcq);
1378
1379	/* Finally, the critical section. */
1380	int rc2 = RTCritSectInit(&pStreamWas->CritSect);
1381	if (RT_SUCCESS(rc2))
1382	{
1383	RTCritSectRwEnterExcl(&pThis->CritSectStreamList);
1384	RTListAppend(&pThis->StreamHead, &pStreamWas->ListEntry);
1385	RTCritSectRwLeaveExcl(&pThis->CritSectStreamList);
1386
1387	LogFlowFunc(("returns VINF_SUCCESS\n", rc));
1388	return VINF_SUCCESS;
1389	}
1390
1391	LogRelMax(64, ("WasAPI: Failed to create critical section for stream.\n"));
1392	drvHostAudioWasCachePutBack(pThis, pDevCfg);
1393	pStreamWas->pDevCfg = NULL;
1394	}
1395	else
1396	LogRelMax(64, ("WasAPI: Failed to setup %s on audio device '%ls'.\n", pszStreamType, pwszDevIdDesc));
1397
1398	LogFlowFunc(("returns %Rrc\n", rc));
1399	return rc;
1400	}
1401
1402
1403	/**
1404	* @interface_method_impl{PDMIHOSTAUDIO,pfnStreamDestroy}
1405	*/
1406	static DECLCALLBACK(int) drvHostAudioWasHA_StreamDestroy(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
1407	{
1408	PDRVHOSTAUDIOWAS pThis = RT_FROM_MEMBER(pInterface, DRVHOSTAUDIOWAS, IHostAudio);
1409	PDRVHOSTAUDIOWASSTREAM pStreamWas = (PDRVHOSTAUDIOWASSTREAM)pStream;
1410	AssertPtrReturn(pStreamWas, VERR_INVALID_POINTER);
1411	LogFlowFunc(("Stream '%s'\n", pStreamWas->Cfg.szName));
1412	HRESULT hrc;
1413
1414	if (RTCritSectIsInitialized(&pStreamWas->CritSect))
1415	{
1416	RTCritSectRwEnterExcl(&pThis->CritSectStreamList);
1417	RTListNodeRemove(&pStreamWas->ListEntry);
1418	RTCritSectRwLeaveExcl(&pThis->CritSectStreamList);
1419
1420	RTCritSectDelete(&pStreamWas->CritSect);
1421	}
1422
1423	if (pStreamWas->fStarted && pStreamWas->pDevCfg && pStreamWas->pDevCfg->pIAudioClient)
1424	{
1425	hrc = pStreamWas->pDevCfg->pIAudioClient->Stop();
1426	LogFunc(("Stop('%s') -> %Rhrc\n", pStreamWas->Cfg.szName, hrc));
1427	pStreamWas->fStarted = false;
1428	}
1429
1430	if (pStreamWas->cFramesCaptureToRelease)
1431	{
1432	hrc = pStreamWas->pDevCfg->pIAudioCaptureClient->ReleaseBuffer(0);
1433	Log4Func(("Releasing capture buffer (%#x frames): %Rhrc\n", pStreamWas->cFramesCaptureToRelease, hrc));
1434	pStreamWas->cFramesCaptureToRelease = 0;
1435	pStreamWas->pbCapture = NULL;
1436	pStreamWas->cbCapture = 0;
1437	}
1438
1439	if (pStreamWas->pDevCfg)
1440	{
1441	drvHostAudioWasCachePutBack(pThis, pStreamWas->pDevCfg);
1442	pStreamWas->pDevCfg = NULL;
1443	}
1444
1445	LogFlowFunc(("returns\n"));
1446	return VINF_SUCCESS;
1447	}
1448
1449
1450	/**
1451	* Wrapper for starting a stream.
1452	*
1453	* @returns VBox status code.
1454	* @param pThis The WASAPI host audio driver instance data.
1455	* @param pStreamWas The stream.
1456	* @param pszOperation The operation we're doing.
1457	*/
1458	static int drvHostAudioWasStreamStartWorker(PDRVHOSTAUDIOWAS pThis, PDRVHOSTAUDIOWASSTREAM pStreamWas, const char *pszOperation)
1459	{
1460	HRESULT hrc = pStreamWas->pDevCfg->pIAudioClient->Start();
1461	LogFlow(("%s: Start(%s) returns %Rhrc\n", pszOperation, pStreamWas->Cfg.szName, hrc));
1462	AssertStmt(hrc != AUDCLNT_E_NOT_STOPPED, hrc = S_OK);
1463	if (SUCCEEDED(hrc))
1464	{
1465	pStreamWas->fStarted = true;
1466	return VINF_SUCCESS;
1467	}
1468
1469	/** @todo try re-setup the stuff on AUDCLNT_E_DEVICEINVALIDATED.
1470	* Need some way of telling the caller (e.g. playback, capture) so they can
1471	* retry what they're doing */
1472	RT_NOREF(pThis);
1473
1474	pStreamWas->fStarted = false;
1475	LogRelMax(64, ("WasAPI: Starting '%s' failed (%s): %Rhrc\n", pStreamWas->Cfg.szName, pszOperation, hrc));
1476	return VERR_AUDIO_STREAM_NOT_READY;
1477	}
1478
1479
1480	/**
1481	* @ interface_method_impl{PDMIHOSTAUDIO,pfnStreamEnable}
1482	*/
1483	static DECLCALLBACK(int) drvHostAudioWasHA_StreamEnable(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
1484	{
1485	PDRVHOSTAUDIOWAS pThis = RT_FROM_MEMBER(pInterface, DRVHOSTAUDIOWAS, IHostAudio);
1486	PDRVHOSTAUDIOWASSTREAM pStreamWas = (PDRVHOSTAUDIOWASSTREAM)pStream;
1487	LogFlowFunc(("Stream '%s' {%s}\n", pStreamWas->Cfg.szName, drvHostWasStreamStatusString(pStreamWas)));
1488	HRESULT hrc;
1489	RTCritSectEnter(&pStreamWas->CritSect);
1490
1491	Assert(!pStreamWas->fEnabled);
1492	Assert(!pStreamWas->fStarted);
1493
1494	/*
1495	* We always reset the buffer before enabling the stream (normally never necessary).
1496	*/
1497	if (pStreamWas->cFramesCaptureToRelease)
1498	{
1499	hrc = pStreamWas->pDevCfg->pIAudioCaptureClient->ReleaseBuffer(pStreamWas->cFramesCaptureToRelease);
1500	Log4Func(("Releasing capture buffer (%#x frames): %Rhrc\n", pStreamWas->cFramesCaptureToRelease, hrc));
1501	pStreamWas->cFramesCaptureToRelease = 0;
1502	pStreamWas->pbCapture = NULL;
1503	pStreamWas->cbCapture = 0;
1504	}
1505
1506	hrc = pStreamWas->pDevCfg->pIAudioClient->Reset();
1507	if (FAILED(hrc))
1508	LogRelMax(64, ("WasAPI: Stream reset failed when enabling '%s': %Rhrc\n", pStreamWas->Cfg.szName, hrc));
1509	pStreamWas->offInternal = 0;
1510	pStreamWas->fDraining = false;
1511	pStreamWas->fEnabled = true;
1512	pStreamWas->fRestartOnResume = false;
1513
1514	/*
1515	* Input streams will start capturing, while output streams will only start
1516	* playing once we get some audio data to play.
1517	*/
1518	int rc = VINF_SUCCESS;
1519	if (pStreamWas->Cfg.enmDir == PDMAUDIODIR_IN)
1520	rc = drvHostAudioWasStreamStartWorker(pThis, pStreamWas, "enable");
1521	else
1522	Assert(pStreamWas->Cfg.enmDir == PDMAUDIODIR_OUT);
1523
1524	RTCritSectLeave(&pStreamWas->CritSect);
1525	LogFlowFunc(("returns %Rrc\n", rc));
1526	return rc;
1527	}
1528
1529
1530	/**
1531	* @ interface_method_impl{PDMIHOSTAUDIO,pfnStreamDisable}
1532	*/
1533	static DECLCALLBACK(int) drvHostAudioWasHA_StreamDisable(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
1534	{
1535	RT_NOREF(pInterface);
1536	PDRVHOSTAUDIOWASSTREAM pStreamWas = (PDRVHOSTAUDIOWASSTREAM)pStream;
1537	LogFlowFunc(("cMsLastTransfer=%RI64 ms, stream '%s' {%s} \n",
1538	pStreamWas->msLastTransfer ? RTTimeMilliTS() - pStreamWas->msLastTransfer : -1,
1539	pStreamWas->Cfg.szName, drvHostWasStreamStatusString(pStreamWas) ));
1540	RTCritSectEnter(&pStreamWas->CritSect);
1541
1542	/*
1543	* We will not stop a draining output stream, otherwise the actions are the same here.
1544	*/
1545	pStreamWas->fEnabled = false;
1546	pStreamWas->fRestartOnResume = false;
1547	Assert(!pStreamWas->fDraining \|\| pStreamWas->Cfg.enmDir == PDMAUDIODIR_OUT);
1548
1549	int rc = VINF_SUCCESS;
1550	if (!pStreamWas->fDraining)
1551	{
1552	if (pStreamWas->fStarted)
1553	{
1554	HRESULT hrc = pStreamWas->pDevCfg->pIAudioClient->Stop();
1555	LogFlowFunc(("Stop(%s) returns %Rhrc\n", pStreamWas->Cfg.szName, hrc));
1556	if (FAILED(hrc))
1557	{
1558	LogRelMax(64, ("WasAPI: Stopping '%s' failed (disable): %Rhrc\n", pStreamWas->Cfg.szName, hrc));
1559	rc = VERR_GENERAL_FAILURE;
1560	}
1561	pStreamWas->fStarted = false;
1562	}
1563	}
1564	else
1565	{
1566	LogFunc(("Stream '%s' is still draining...\n", pStreamWas->Cfg.szName));
1567	Assert(pStreamWas->fStarted);
1568	}
1569
1570	RTCritSectLeave(&pStreamWas->CritSect);
1571	LogFlowFunc(("returns %Rrc {%s}\n", rc, drvHostWasStreamStatusString(pStreamWas)));
1572	return rc;
1573	}
1574
1575
1576	/**
1577	* @ interface_method_impl{PDMIHOSTAUDIO,pfnStreamPause}
1578	*
1579	* @note Basically the same as drvHostAudioWasHA_StreamDisable, just w/o the
1580	* buffer resetting and fEnabled change.
1581	*/
1582	static DECLCALLBACK(int) drvHostAudioWasHA_StreamPause(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
1583	{
1584	RT_NOREF(pInterface);
1585	PDRVHOSTAUDIOWASSTREAM pStreamWas = (PDRVHOSTAUDIOWASSTREAM)pStream;
1586	LogFlowFunc(("cMsLastTransfer=%RI64 ms, stream '%s' {%s} \n",
1587	pStreamWas->msLastTransfer ? RTTimeMilliTS() - pStreamWas->msLastTransfer : -1,
1588	pStreamWas->Cfg.szName, drvHostWasStreamStatusString(pStreamWas) ));
1589	RTCritSectEnter(&pStreamWas->CritSect);
1590
1591	/*
1592	* Unless we're draining the stream, stop it if it's started.
1593	*/
1594	int rc = VINF_SUCCESS;
1595	if (pStreamWas->fStarted && !pStreamWas->fDraining)
1596	{
1597	pStreamWas->fRestartOnResume = true;
1598
1599	HRESULT hrc = pStreamWas->pDevCfg->pIAudioClient->Stop();
1600	LogFlowFunc(("Stop(%s) returns %Rhrc\n", pStreamWas->Cfg.szName, hrc));
1601	if (FAILED(hrc))
1602	{
1603	LogRelMax(64, ("WasAPI: Stopping '%s' failed (pause): %Rhrc\n", pStreamWas->Cfg.szName, hrc));
1604	rc = VERR_GENERAL_FAILURE;
1605	}
1606	pStreamWas->fStarted = false;
1607	}
1608	else
1609	{
1610	pStreamWas->fRestartOnResume = false;
1611	if (pStreamWas->fDraining)
1612	{
1613	LogFunc(("Stream '%s' is draining\n", pStreamWas->Cfg.szName));
1614	Assert(pStreamWas->fStarted);
1615	}
1616	}
1617
1618	RTCritSectLeave(&pStreamWas->CritSect);
1619	LogFlowFunc(("returns %Rrc {%s}\n", rc, drvHostWasStreamStatusString(pStreamWas)));
1620	return rc;
1621	}
1622
1623
1624	/**
1625	* @ interface_method_impl{PDMIHOSTAUDIO,pfnStreamResume}
1626	*/
1627	static DECLCALLBACK(int) drvHostAudioWasHA_StreamResume(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
1628	{
1629	PDRVHOSTAUDIOWAS pThis = RT_FROM_MEMBER(pInterface, DRVHOSTAUDIOWAS, IHostAudio);
1630	PDRVHOSTAUDIOWASSTREAM pStreamWas = (PDRVHOSTAUDIOWASSTREAM)pStream;
1631	LogFlowFunc(("Stream '%s' {%s}\n", pStreamWas->Cfg.szName, drvHostWasStreamStatusString(pStreamWas)));
1632	RTCritSectEnter(&pStreamWas->CritSect);
1633
1634	/*
1635	* Resume according to state saved by drvHostAudioWasHA_StreamPause.
1636	*/
1637	int rc;
1638	if (pStreamWas->fRestartOnResume)
1639	rc = drvHostAudioWasStreamStartWorker(pThis, pStreamWas, "resume");
1640	else
1641	rc = VINF_SUCCESS;
1642	pStreamWas->fRestartOnResume = false;
1643
1644	RTCritSectLeave(&pStreamWas->CritSect);
1645	LogFlowFunc(("returns %Rrc {%s}\n", rc, drvHostWasStreamStatusString(pStreamWas)));
1646	return rc;
1647	}
1648
1649
1650	/**
1651	* This is used by the timer function as well as when arming the timer.
1652	*
1653	* @param pThis The DSound host audio driver instance data.
1654	* @param msNow A current RTTimeMilliTS() value.
1655	*/
1656	static void drvHostWasDrainTimerWorker(PDRVHOSTAUDIOWAS pThis, uint64_t msNow)
1657	{
1658	/*
1659	* Go thru the stream list and look at draining streams.
1660	*/
1661	uint64_t msNext = UINT64_MAX;
1662	RTCritSectRwEnterShared(&pThis->CritSectStreamList);
1663	PDRVHOSTAUDIOWASSTREAM pCur;
1664	RTListForEach(&pThis->StreamHead, pCur, DRVHOSTAUDIOWASSTREAM, ListEntry)
1665	{
1666	if ( pCur->fDraining
1667	&& pCur->Cfg.enmDir == PDMAUDIODIR_OUT)
1668	{
1669	Assert(pCur->fStarted);
1670	uint64_t msCurDeadline = pCur->msDrainDeadline;
1671	if (msCurDeadline > 0 && msCurDeadline < msNext)
1672	{
1673	/* Take the lock and recheck: */
1674	RTCritSectEnter(&pCur->CritSect);
1675	msCurDeadline = pCur->msDrainDeadline;
1676	if ( pCur->fDraining
1677	&& msCurDeadline > 0
1678	&& msCurDeadline < msNext)
1679	{
1680	if (msCurDeadline > msNow)
1681	msNext = pCur->msDrainDeadline;
1682	else
1683	{
1684	LogRel2(("WasAPI: Stopping draining of '%s' {%s} ...\n",
1685	pCur->Cfg.szName, drvHostWasStreamStatusString(pCur)));
1686	HRESULT hrc = pCur->pDevCfg->pIAudioClient->Stop();
1687	if (FAILED(hrc))
1688	LogRelMax(64, ("WasAPI: Failed to stop draining stream '%s': %Rhrc\n", pCur->Cfg.szName, hrc));
1689	pCur->fDraining = false;
1690	pCur->fStarted = false;
1691	}
1692	}
1693	RTCritSectLeave(&pCur->CritSect);
1694	}
1695	}
1696	}
1697
1698	/*
1699	* Re-arm the timer if necessary.
1700	*/
1701	if (msNext != UINT64_MAX)
1702	PDMDrvHlpTimerSetMillies(pThis->pDrvIns, pThis->hDrainTimer, msNext - msNow);
1703	RTCritSectRwLeaveShared(&pThis->CritSectStreamList);
1704	}
1705
1706
1707	/**
1708	* @callback_method_impl{FNTMTIMERDRV,
1709	* This is to ensure that draining streams stop properly.}
1710	*/
1711	static DECLCALLBACK(void) drvHostWasDrainStopTimer(PPDMDRVINS pDrvIns, TMTIMERHANDLE hTimer, void *pvUser)
1712	{
1713	PDRVHOSTAUDIOWAS pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTAUDIOWAS);
1714	RT_NOREF(hTimer, pvUser);
1715	drvHostWasDrainTimerWorker(pThis, RTTimeMilliTS());
1716	}
1717
1718
1719	/**
1720	* @ interface_method_impl{PDMIHOSTAUDIO,pfnStreamDrain}
1721	*/
1722	static DECLCALLBACK(int) drvHostAudioWasHA_StreamDrain(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
1723	{
1724	PDRVHOSTAUDIOWAS pThis = RT_FROM_MEMBER(pInterface, DRVHOSTAUDIOWAS, IHostAudio);
1725	PDRVHOSTAUDIOWASSTREAM pStreamWas = (PDRVHOSTAUDIOWASSTREAM)pStream;
1726	AssertReturn(pStreamWas->Cfg.enmDir == PDMAUDIODIR_OUT, VERR_INVALID_PARAMETER);
1727	LogFlowFunc(("cMsLastTransfer=%RI64 ms, stream '%s' {%s} \n",
1728	pStreamWas->msLastTransfer ? RTTimeMilliTS() - pStreamWas->msLastTransfer : -1,
1729	pStreamWas->Cfg.szName, drvHostWasStreamStatusString(pStreamWas) ));
1730
1731	/*
1732	* If the stram was started, calculate when the buffered data has finished
1733	* playing and switch to drain mode. Use the drain timer callback worker
1734	* to re-arm the timer or to stop the playback.
1735	*/
1736	RTCritSectEnter(&pStreamWas->CritSect);
1737	int rc = VINF_SUCCESS;
1738	if (pStreamWas->fStarted)
1739	{
1740	if (!pStreamWas->fDraining)
1741	{
1742	if (pStreamWas->fStarted)
1743	{
1744	uint64_t const msNow = RTTimeMilliTS();
1745	uint64_t msDrainDeadline = 0;
1746	UINT32 cFramesPending = 0;
1747	HRESULT hrc = pStreamWas->pDevCfg->pIAudioClient->GetCurrentPadding(&cFramesPending);
1748	if (SUCCEEDED(hrc))
1749	msDrainDeadline = msNow
1750	+ PDMAudioPropsFramesToMilli(&pStreamWas->Cfg.Props,
1751	RT_MIN(cFramesPending,
1752	pStreamWas->Cfg.Backend.cFramesBufferSize * 2))
1753	+ 1 /fudge/;
1754	else
1755	{
1756	msDrainDeadline = msNow;
1757	LogRelMax(64, ("WasAPI: GetCurrentPadding fail on '%s' when starting draining: %Rhrc\n",
1758	pStreamWas->Cfg.szName, hrc));
1759	}
1760	pStreamWas->msDrainDeadline = msDrainDeadline;
1761	pStreamWas->fDraining = true;
1762	}
1763	else
1764	LogFlowFunc(("Drain requested for '%s', but not started playback...\n", pStreamWas->Cfg.szName));
1765	}
1766	else
1767	LogFlowFunc(("Already draining '%s' ...\n", pStreamWas->Cfg.szName));
1768	}
1769	else
1770	AssertStmt(!pStreamWas->fDraining, pStreamWas->fDraining = false);
1771	RTCritSectLeave(&pStreamWas->CritSect);
1772
1773	/*
1774	* Always do drain timer processing to re-arm the timer or actually stop
1775	* this stream (and others). (Must be done _after_ unlocking the stream.)
1776	*/
1777	drvHostWasDrainTimerWorker(pThis, RTTimeMilliTS());
1778
1779	LogFlowFunc(("returns %Rrc {%s}\n", rc, drvHostWasStreamStatusString(pStreamWas)));
1780	return rc;
1781	}
1782
1783
1784	/**
1785	* @interface_method_impl{PDMIHOSTAUDIO,pfnStreamControl}
1786	*/
1787	static DECLCALLBACK(int) drvHostAudioWasHA_StreamControl(PPDMIHOSTAUDIO pInterface,
1788	PPDMAUDIOBACKENDSTREAM pStream, PDMAUDIOSTREAMCMD enmStreamCmd)
1789	{
1790	/** @todo r=bird: I'd like to get rid of this pfnStreamControl method,
1791	* replacing it with individual StreamXxxx methods. That would save us
1792	* potentally huge switches and more easily see which drivers implement
1793	* which operations (grep for pfnStreamXxxx). */
1794	switch (enmStreamCmd)
1795	{
1796	case PDMAUDIOSTREAMCMD_ENABLE:
1797	return drvHostAudioWasHA_StreamEnable(pInterface, pStream);
1798	case PDMAUDIOSTREAMCMD_DISABLE:
1799	return drvHostAudioWasHA_StreamDisable(pInterface, pStream);
1800	case PDMAUDIOSTREAMCMD_PAUSE:
1801	return drvHostAudioWasHA_StreamPause(pInterface, pStream);
1802	case PDMAUDIOSTREAMCMD_RESUME:
1803	return drvHostAudioWasHA_StreamResume(pInterface, pStream);
1804	case PDMAUDIOSTREAMCMD_DRAIN:
1805	return drvHostAudioWasHA_StreamDrain(pInterface, pStream);
1806
1807	case PDMAUDIOSTREAMCMD_END:
1808	case PDMAUDIOSTREAMCMD_32BIT_HACK:
1809	case PDMAUDIOSTREAMCMD_INVALID:
1810	/* no default*/
1811	break;
1812	}
1813	return VERR_NOT_SUPPORTED;
1814	}
1815
1816
1817	/**
1818	* @interface_method_impl{PDMIHOSTAUDIO,pfnStreamGetReadable}
1819	*/
1820	static DECLCALLBACK(uint32_t) drvHostAudioWasHA_StreamGetReadable(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
1821	{
1822	RT_NOREF(pInterface);
1823	PDRVHOSTAUDIOWASSTREAM pStreamWas = (PDRVHOSTAUDIOWASSTREAM)pStream;
1824	AssertPtrReturn(pStreamWas, 0);
1825	Assert(pStreamWas->Cfg.enmDir == PDMAUDIODIR_IN);
1826
1827	uint32_t cbReadable = 0;
1828	RTCritSectEnter(&pStreamWas->CritSect);
1829
1830	if (pStreamWas->pDevCfg->pIAudioCaptureClient /* paranoia */)
1831	{
1832	UINT32 cFramesInNextPacket = 0;
1833	HRESULT hrc = pStreamWas->pDevCfg->pIAudioCaptureClient->GetNextPacketSize(&cFramesInNextPacket);
1834	if (SUCCEEDED(hrc))
1835	cbReadable = PDMAudioPropsFramesToBytes(&pStreamWas->Cfg.Props,
1836	RT_MIN(cFramesInNextPacket,
1837	pStreamWas->Cfg.Backend.cFramesBufferSize * 16 /* paranoia */));
1838	else
1839	LogRelMax(64, ("WasAPI: GetNextPacketSize failed on '%s': %Rhrc\n", pStreamWas->Cfg.szName, hrc));
1840	}
1841
1842	RTCritSectLeave(&pStreamWas->CritSect);
1843
1844	LogFlowFunc(("returns %#x (%u) {%s}\n", cbReadable, cbReadable, drvHostWasStreamStatusString(pStreamWas)));
1845	return cbReadable;
1846	}
1847
1848
1849	/**
1850	* @interface_method_impl{PDMIHOSTAUDIO,pfnStreamGetWritable}
1851	*/
1852	static DECLCALLBACK(uint32_t) drvHostAudioWasHA_StreamGetWritable(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
1853	{
1854	RT_NOREF(pInterface);
1855	PDRVHOSTAUDIOWASSTREAM pStreamWas = (PDRVHOSTAUDIOWASSTREAM)pStream;
1856	AssertPtrReturn(pStreamWas, 0);
1857	LogFlowFunc(("Stream '%s' {%s}\n", pStreamWas->Cfg.szName, drvHostWasStreamStatusString(pStreamWas)));
1858	Assert(pStreamWas->Cfg.enmDir == PDMAUDIODIR_OUT);
1859
1860	uint32_t cbWritable = 0;
1861	RTCritSectEnter(&pStreamWas->CritSect);
1862
1863	if ( pStreamWas->Cfg.enmDir == PDMAUDIODIR_OUT
1864	&& pStreamWas->pDevCfg->pIAudioClient /* paranoia */)
1865	{
1866	UINT32 cFramesPending = 0;
1867	HRESULT hrc = pStreamWas->pDevCfg->pIAudioClient->GetCurrentPadding(&cFramesPending);
1868	if (SUCCEEDED(hrc))
1869	{
1870	if (cFramesPending < pStreamWas->Cfg.Backend.cFramesBufferSize)
1871	cbWritable = PDMAudioPropsFramesToBytes(&pStreamWas->Cfg.Props,
1872	pStreamWas->Cfg.Backend.cFramesBufferSize - cFramesPending);
1873	else if (cFramesPending > pStreamWas->Cfg.Backend.cFramesBufferSize)
1874	{
1875	LogRelMax(64, ("WasAPI: Warning! GetCurrentPadding('%s') return too high: cFramesPending=%#x > cFramesBufferSize=%#x\n",
1876	pStreamWas->Cfg.szName, cFramesPending, pStreamWas->Cfg.Backend.cFramesBufferSize));
1877	AssertMsgFailed(("cFramesPending=%#x > cFramesBufferSize=%#x\n",
1878	cFramesPending, pStreamWas->Cfg.Backend.cFramesBufferSize));
1879	}
1880	}
1881	else
1882	LogRelMax(64, ("WasAPI: GetCurrentPadding failed on '%s': %Rhrc\n", pStreamWas->Cfg.szName, hrc));
1883	}
1884
1885	RTCritSectLeave(&pStreamWas->CritSect);
1886
1887	LogFlowFunc(("returns %#x (%u) {%s}\n", cbWritable, cbWritable, drvHostWasStreamStatusString(pStreamWas)));
1888	return cbWritable;
1889	}
1890
1891
1892	/**
1893	* @interface_method_impl{PDMIHOSTAUDIO,pfnStreamGetPending}
1894	*/
1895	static DECLCALLBACK(uint32_t) drvHostAudioWasHA_StreamGetPending(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
1896	{
1897	RT_NOREF(pInterface);
1898	PDRVHOSTAUDIOWASSTREAM pStreamWas = (PDRVHOSTAUDIOWASSTREAM)pStream;
1899	AssertPtrReturn(pStreamWas, 0);
1900	LogFlowFunc(("Stream '%s' {%s}\n", pStreamWas->Cfg.szName, drvHostWasStreamStatusString(pStreamWas)));
1901	AssertReturn(pStreamWas->Cfg.enmDir == PDMAUDIODIR_OUT, 0);
1902
1903	uint32_t cbPending = 0;
1904	RTCritSectEnter(&pStreamWas->CritSect);
1905
1906	if ( pStreamWas->Cfg.enmDir == PDMAUDIODIR_OUT
1907	&& pStreamWas->pDevCfg->pIAudioClient /* paranoia */)
1908	{
1909	if (pStreamWas->fStarted)
1910	{
1911	UINT32 cFramesPending = 0;
1912	HRESULT hrc = pStreamWas->pDevCfg->pIAudioClient->GetCurrentPadding(&cFramesPending);
1913	if (SUCCEEDED(hrc))
1914	{
1915	AssertMsg(cFramesPending <= pStreamWas->Cfg.Backend.cFramesBufferSize,
1916	("cFramesPending=%#x cFramesBufferSize=%#x\n",
1917	cFramesPending, pStreamWas->Cfg.Backend.cFramesBufferSize));
1918	cbPending = PDMAudioPropsFramesToBytes(&pStreamWas->Cfg.Props, RT_MIN(cFramesPending, VBOX_WASAPI_MAX_PADDING));
1919	}
1920	else
1921	LogRelMax(64, ("WasAPI: GetCurrentPadding failed on '%s': %Rhrc\n", pStreamWas->Cfg.szName, hrc));
1922	}
1923	}
1924
1925	RTCritSectLeave(&pStreamWas->CritSect);
1926
1927	LogFlowFunc(("returns %#x (%u) {%s}\n", cbPending, cbPending, drvHostWasStreamStatusString(pStreamWas)));
1928	return cbPending;
1929	}
1930
1931
1932	/**
1933	* @interface_method_impl{PDMIHOSTAUDIO,pfnStreamGetStatus}
1934	*/
1935	static DECLCALLBACK(PDMAUDIOSTREAMSTS) drvHostAudioWasHA_StreamGetStatus(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
1936	{
1937	RT_NOREF(pInterface);
1938	PDRVHOSTAUDIOWASSTREAM pStreamWas = (PDRVHOSTAUDIOWASSTREAM)pStream;
1939	AssertPtrReturn(pStreamWas, PDMAUDIOSTREAMSTS_FLAGS_NONE);
1940
1941	PDMAUDIOSTREAMSTS fStrmStatus = PDMAUDIOSTREAMSTS_FLAGS_INITIALIZED;
1942	if (pStreamWas->fEnabled)
1943	fStrmStatus \|= PDMAUDIOSTREAMSTS_FLAGS_ENABLED;
1944	if (pStreamWas->fDraining)
1945	fStrmStatus \|= PDMAUDIOSTREAMSTS_FLAGS_PENDING_DISABLE;
1946	if (pStreamWas->fRestartOnResume)
1947	fStrmStatus \|= PDMAUDIOSTREAMSTS_FLAGS_PAUSED;
1948
1949	LogFlowFunc(("returns %#x for '%s' {%s}\n", fStrmStatus, pStreamWas->Cfg.szName, drvHostWasStreamStatusString(pStreamWas)));
1950	return fStrmStatus;
1951	}
1952
1953
1954	/**
1955	* @interface_method_impl{PDMIHOSTAUDIO,pfnStreamPlay}
1956	*/
1957	static DECLCALLBACK(int) drvHostAudioWasHA_StreamPlay(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream,
1958	const void pvBuf, uint32_t cbBuf, uint32_t pcbWritten)
1959	{
1960	PDRVHOSTAUDIOWAS pThis = RT_FROM_MEMBER(pInterface, DRVHOSTAUDIOWAS, IHostAudio);
1961	PDRVHOSTAUDIOWASSTREAM pStreamWas = (PDRVHOSTAUDIOWASSTREAM)pStream;
1962	AssertPtrReturn(pStreamWas, VERR_INVALID_POINTER);
1963	AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
1964	AssertReturn(cbBuf, VERR_INVALID_PARAMETER);
1965	AssertPtrReturn(pcbWritten, VERR_INVALID_POINTER);
1966	Assert(PDMAudioPropsIsSizeAligned(&pStreamWas->Cfg.Props, cbBuf));
1967
1968	RTCritSectEnter(&pStreamWas->CritSect);
1969	if (pStreamWas->fEnabled)
1970	{ /* likely */ }
1971	else
1972	{
1973	RTCritSectLeave(&pStreamWas->CritSect);
1974	*pcbWritten = 0;
1975	LogFunc(("Skipping %#x byte write to disabled stream {%s}\n", cbBuf, drvHostWasStreamStatusString(pStreamWas)));
1976	return VINF_SUCCESS;
1977	}
1978	Log4Func(("cbBuf=%#x stream '%s' {%s}\n", cbBuf, pStreamWas->Cfg.szName, drvHostWasStreamStatusString(pStreamWas) ));
1979
1980	/*
1981	* Transfer loop.
1982	*/
1983	int rc = VINF_SUCCESS;
1984	uint32_t cReInits = 0;
1985	uint32_t cbWritten = 0;
1986	while (cbBuf > 0)
1987	{
1988	AssertBreakStmt(pStreamWas->pDevCfg && pStreamWas->pDevCfg->pIAudioRenderClient && pStreamWas->pDevCfg->pIAudioClient,
1989	rc = VERR_AUDIO_STREAM_NOT_READY);
1990
1991	/*
1992	* Figure out how much we can possibly write.
1993	*/
1994	UINT32 cFramesPending = 0;
1995	uint32_t cbWritable = 0;
1996	HRESULT hrc = pStreamWas->pDevCfg->pIAudioClient->GetCurrentPadding(&cFramesPending);
1997	if (SUCCEEDED(hrc))
1998	cbWritable = PDMAudioPropsFramesToBytes(&pStreamWas->Cfg.Props,
1999	pStreamWas->Cfg.Backend.cFramesBufferSize
2000	- RT_MIN(cFramesPending, pStreamWas->Cfg.Backend.cFramesBufferSize));
2001	else
2002	{
2003	LogRelMax(64, ("WasAPI: GetCurrentPadding(%s) failed during playback: %Rhrc (@%#RX64)\n",
2004	pStreamWas->Cfg.szName, hrc, pStreamWas->offInternal));
2005	/** @todo reinit on AUDCLNT_E_DEVICEINVALIDATED? */
2006	rc = VERR_AUDIO_STREAM_NOT_READY;
2007	break;
2008	}
2009	if (cbWritable <= PDMAudioPropsFrameSize(&pStreamWas->Cfg.Props))
2010	break;
2011
2012	uint32_t const cbToWrite = PDMAudioPropsFloorBytesToFrame(&pStreamWas->Cfg.Props, RT_MIN(cbWritable, cbBuf));
2013	uint32_t const cFramesToWrite = PDMAudioPropsBytesToFrames(&pStreamWas->Cfg.Props, cbToWrite);
2014	Assert(PDMAudioPropsFramesToBytes(&pStreamWas->Cfg.Props, cFramesToWrite) == cbToWrite);
2015	Log3Func(("@%RX64: cFramesPending=%#x -> cbWritable=%#x cbToWrite=%#x cFramesToWrite=%#x {%s}\n",
2016	pStreamWas->offInternal, cFramesPending, cbWritable, cbToWrite, cFramesToWrite,
2017	drvHostWasStreamStatusString(pStreamWas) ));
2018
2019	/*
2020	* Get the buffer, copy the data into it, and relase it back to the WAS machinery.
2021	*/
2022	BYTE *pbData = NULL;
2023	hrc = pStreamWas->pDevCfg->pIAudioRenderClient->GetBuffer(cFramesToWrite, &pbData);
2024	if (SUCCEEDED(hrc))
2025	{
2026	memcpy(pbData, pvBuf, cbToWrite);
2027	hrc = pStreamWas->pDevCfg->pIAudioRenderClient->ReleaseBuffer(cFramesToWrite, 0 /fFlags/);
2028	if (SUCCEEDED(hrc))
2029	{
2030	/*
2031	* Before we advance the buffer position (so we can resubmit it
2032	* after re-init), make sure we've successfully started stream.
2033	*/
2034	if (pStreamWas->fStarted)
2035	{ }
2036	else
2037	{
2038	rc = drvHostAudioWasStreamStartWorker(pThis, pStreamWas, "play");
2039	if (rc == VINF_SUCCESS)
2040	{ /* likely */ }
2041	else if (RT_SUCCESS(rc) && ++cReInits < 5)
2042	continue; /* re-submit buffer after re-init */
2043	else
2044	break;
2045	}
2046
2047	/* advance. */
2048	pvBuf = (uint8_t *)pvBuf + cbToWrite;
2049	cbBuf -= cbToWrite;
2050	cbWritten += cbToWrite;
2051	pStreamWas->offInternal += cbToWrite;
2052	}
2053	else
2054	{
2055	LogRelMax(64, ("WasAPI: ReleaseBuffer(%#x) failed on '%s' during playback: %Rhrc (@%#RX64)\n",
2056	cFramesToWrite, pStreamWas->Cfg.szName, hrc, pStreamWas->offInternal));
2057	/** @todo reinit on AUDCLNT_E_DEVICEINVALIDATED? */
2058	rc = VERR_AUDIO_STREAM_NOT_READY;
2059	break;
2060	}
2061	}
2062	else
2063	{
2064	LogRelMax(64, ("WasAPI: GetBuffer(%#x) failed on '%s' during playback: %Rhrc (@%#RX64)\n",
2065	cFramesToWrite, pStreamWas->Cfg.szName, hrc, pStreamWas->offInternal));
2066	/** @todo reinit on AUDCLNT_E_DEVICEINVALIDATED? */
2067	rc = VERR_AUDIO_STREAM_NOT_READY;
2068	break;
2069	}
2070	}
2071
2072	/*
2073	* Done.
2074	*/
2075	uint64_t const msPrev = pStreamWas->msLastTransfer;
2076	uint64_t const msNow = RTTimeMilliTS();
2077	if (cbWritten)
2078	pStreamWas->msLastTransfer = msNow;
2079
2080	RTCritSectLeave(&pStreamWas->CritSect);
2081
2082	*pcbWritten = cbWritten;
2083	if (RT_SUCCESS(rc) \|\| !cbWritten)
2084	{ }
2085	else
2086	{
2087	LogFlowFunc(("Suppressing %Rrc to report %#x bytes written\n", rc, cbWritten));
2088	rc = VINF_SUCCESS;
2089	}
2090	LogFlowFunc(("@%#RX64: cbWritten=%RU32 cMsDelta=%RU64 (%RU64 -> %RU64) {%s}\n", pStreamWas->offInternal, cbWritten,
2091	msPrev ? msNow - msPrev : 0, msPrev, pStreamWas->msLastTransfer, drvHostWasStreamStatusString(pStreamWas) ));
2092	return VINF_SUCCESS;
2093	}
2094
2095
2096	/**
2097	* @interface_method_impl{PDMIHOSTAUDIO,pfnStreamCapture}
2098	*/
2099	static DECLCALLBACK(int) drvHostAudioWasHA_StreamCapture(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream,
2100	void pvBuf, uint32_t cbBuf, uint32_t pcbRead)
2101	{
2102	RT_NOREF(pInterface); //PDRVHOSTAUDIOWAS pThis = RT_FROM_MEMBER(pInterface, DRVHOSTAUDIOWAS, IHostAudio);
2103	PDRVHOSTAUDIOWASSTREAM pStreamWas = (PDRVHOSTAUDIOWASSTREAM)pStream;
2104	AssertPtrReturn(pStreamWas, 0);
2105	AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
2106	AssertReturn(cbBuf, VERR_INVALID_PARAMETER);
2107	AssertPtrReturn(pcbRead, VERR_INVALID_POINTER);
2108	Assert(PDMAudioPropsIsSizeAligned(&pStreamWas->Cfg.Props, cbBuf));
2109
2110	RTCritSectEnter(&pStreamWas->CritSect);
2111	if (pStreamWas->fEnabled)
2112	{ /* likely */ }
2113	else
2114	{
2115	RTCritSectLeave(&pStreamWas->CritSect);
2116	*pcbRead = 0;
2117	LogFunc(("Skipping %#x byte read from disabled stream {%s}\n", cbBuf, drvHostWasStreamStatusString(pStreamWas)));
2118	return VINF_SUCCESS;
2119	}
2120	Log4Func(("cbBuf=%#x stream '%s' {%s}\n", cbBuf, pStreamWas->Cfg.szName, drvHostWasStreamStatusString(pStreamWas) ));
2121
2122
2123	/*
2124	* Transfer loop.
2125	*/
2126	int rc = VINF_SUCCESS;
2127	//uint32_t cReInits = 0;
2128	uint32_t cbRead = 0;
2129	uint32_t const cbFrame = PDMAudioPropsFrameSize(&pStreamWas->Cfg.Props);
2130	while (cbBuf > cbFrame)
2131	{
2132	AssertBreakStmt(pStreamWas->pDevCfg->pIAudioCaptureClient && pStreamWas->pDevCfg->pIAudioClient, rc = VERR_AUDIO_STREAM_NOT_READY);
2133
2134	/*
2135	* Anything pending from last call?
2136	* (This is rather similar to the Pulse interface.)
2137	*/
2138	if (pStreamWas->cFramesCaptureToRelease)
2139	{
2140	uint32_t const cbToCopy = RT_MIN(pStreamWas->cbCapture, cbBuf);
2141	memcpy(pvBuf, pStreamWas->pbCapture, cbToCopy);
2142	pvBuf = (uint8_t *)pvBuf + cbToCopy;
2143	cbBuf -= cbToCopy;
2144	cbRead += cbToCopy;
2145	pStreamWas->offInternal += cbToCopy;
2146	pStreamWas->pbCapture += cbToCopy;
2147	pStreamWas->cbCapture -= cbToCopy;
2148	if (!pStreamWas->cbCapture)
2149	{
2150	HRESULT hrc = pStreamWas->pDevCfg->pIAudioCaptureClient->ReleaseBuffer(pStreamWas->cFramesCaptureToRelease);
2151	Log4Func(("@%#RX64: Releasing capture buffer (%#x frames): %Rhrc\n",
2152	pStreamWas->offInternal, pStreamWas->cFramesCaptureToRelease, hrc));
2153	if (SUCCEEDED(hrc))
2154	{
2155	pStreamWas->cFramesCaptureToRelease = 0;
2156	pStreamWas->pbCapture = NULL;
2157	}
2158	else
2159	{
2160	LogRelMax(64, ("WasAPI: ReleaseBuffer(%s) failed during capture: %Rhrc (@%#RX64)\n",
2161	pStreamWas->Cfg.szName, hrc, pStreamWas->offInternal));
2162	/** @todo reinit on AUDCLNT_E_DEVICEINVALIDATED? */
2163	rc = VERR_AUDIO_STREAM_NOT_READY;
2164	break;
2165	}
2166	}
2167	if (cbBuf < cbFrame)
2168	break;
2169	}
2170
2171	/*
2172	* Figure out if there is any data available to be read now. (Docs hint that we can not
2173	* skip this and go straight for GetBuffer or we risk getting unwritten buffer space back).
2174	*/
2175	UINT32 cFramesCaptured = 0;
2176	HRESULT hrc = pStreamWas->pDevCfg->pIAudioCaptureClient->GetNextPacketSize(&cFramesCaptured);
2177	if (SUCCEEDED(hrc))
2178	{
2179	if (!cFramesCaptured)
2180	break;
2181	}
2182	else
2183	{
2184	LogRelMax(64, ("WasAPI: GetNextPacketSize(%s) failed during capture: %Rhrc (@%#RX64)\n",
2185	pStreamWas->Cfg.szName, hrc, pStreamWas->offInternal));
2186	/** @todo reinit on AUDCLNT_E_DEVICEINVALIDATED? */
2187	rc = VERR_AUDIO_STREAM_NOT_READY;
2188	break;
2189	}
2190
2191	/*
2192	* Get the buffer.
2193	*/
2194	cFramesCaptured = 0;
2195	UINT64 uQpsNtTicks = 0;
2196	UINT64 offDevice = 0;
2197	DWORD fBufFlags = 0;
2198	BYTE *pbData = NULL;
2199	hrc = pStreamWas->pDevCfg->pIAudioCaptureClient->GetBuffer(&pbData, &cFramesCaptured, &fBufFlags, &offDevice, &uQpsNtTicks);
2200	Log4Func(("@%#RX64: GetBuffer -> %Rhrc pbData=%p cFramesCaptured=%#x fBufFlags=%#x offDevice=%#RX64 uQpcNtTicks=%#RX64\n",
2201	pStreamWas->offInternal, hrc, pbData, cFramesCaptured, fBufFlags, offDevice, uQpsNtTicks));
2202	if (SUCCEEDED(hrc))
2203	{
2204	Assert(cFramesCaptured < VBOX_WASAPI_MAX_PADDING);
2205	pStreamWas->pbCapture = pbData;
2206	pStreamWas->cFramesCaptureToRelease = cFramesCaptured;
2207	pStreamWas->cbCapture = PDMAudioPropsFramesToBytes(&pStreamWas->Cfg.Props, cFramesCaptured);
2208	/* Just loop and re-use the copying code above. Can optimize later. */
2209	}
2210	else
2211	{
2212	LogRelMax(64, ("WasAPI: GetBuffer() failed on '%s' during capture: %Rhrc (@%#RX64)\n",
2213	pStreamWas->Cfg.szName, hrc, pStreamWas->offInternal));
2214	/** @todo reinit on AUDCLNT_E_DEVICEINVALIDATED? */
2215	rc = VERR_AUDIO_STREAM_NOT_READY;
2216	break;
2217	}
2218	}
2219
2220	/*
2221	* Done.
2222	*/
2223	uint64_t const msPrev = pStreamWas->msLastTransfer;
2224	uint64_t const msNow = RTTimeMilliTS();
2225	if (cbRead)
2226	pStreamWas->msLastTransfer = msNow;
2227
2228	RTCritSectLeave(&pStreamWas->CritSect);
2229
2230	*pcbRead = cbRead;
2231	if (RT_SUCCESS(rc) \|\| !cbRead)
2232	{ }
2233	else
2234	{
2235	LogFlowFunc(("Suppressing %Rrc to report %#x bytes read\n", rc, cbRead));
2236	rc = VINF_SUCCESS;
2237	}
2238	LogFlowFunc(("@%#RX64: cbRead=%RU32 cMsDelta=%RU64 (%RU64 -> %RU64) {%s}\n", pStreamWas->offInternal, cbRead,
2239	msPrev ? msNow - msPrev : 0, msPrev, pStreamWas->msLastTransfer, drvHostWasStreamStatusString(pStreamWas) ));
2240	return rc;
2241	}
2242
2243
2244	/*********************************************************************************************************************************
2245	* PDMDRVINS::IBase Interface *
2246	*********************************************************************************************************************************/
2247
2248	/**
2249	* @callback_method_impl{PDMIBASE,pfnQueryInterface}
2250	*/
2251	static DECLCALLBACK(void ) drvHostAudioWasQueryInterface(PPDMIBASE pInterface, const char pszIID)
2252	{
2253	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
2254	PDRVHOSTAUDIOWAS pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTAUDIOWAS);
2255
2256	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
2257	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIHOSTAUDIO, &pThis->IHostAudio);
2258	return NULL;
2259	}
2260
2261
2262	/*********************************************************************************************************************************
2263	* PDMDRVREG Interface *
2264	*********************************************************************************************************************************/
2265
2266	/**
2267	* @callback_method_impl{FNPDMDRVDESTRUCT, pfnDestruct}
2268	*/
2269	static DECLCALLBACK(void) drvHostAudioWasDestruct(PPDMDRVINS pDrvIns)
2270	{
2271	PDRVHOSTAUDIOWAS pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTAUDIOWAS);
2272	PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
2273	LogFlowFuncEnter();
2274
2275	if (pThis->pNotifyClient)
2276	{
2277	pThis->pNotifyClient->notifyDriverDestroyed();
2278	pThis->pIEnumerator->UnregisterEndpointNotificationCallback(pThis->pNotifyClient);
2279	pThis->pNotifyClient->Release();
2280	}
2281
2282	if (RTCritSectIsInitialized(&pThis->CritSectCache))
2283	{
2284	drvHostAudioWasCachePurge(pThis);
2285	RTCritSectDelete(&pThis->CritSectCache);
2286	}
2287
2288	if (pThis->pIEnumerator)
2289	{
2290	uint32_t cRefs = pThis->pIEnumerator->Release(); RT_NOREF(cRefs);
2291	LogFlowFunc(("cRefs=%d\n", cRefs));
2292	}
2293
2294	if (pThis->pIDeviceOutput)
2295	{
2296	pThis->pIDeviceOutput->Release();
2297	pThis->pIDeviceOutput = NULL;
2298	}
2299
2300	if (pThis->pIDeviceInput)
2301	{
2302	pThis->pIDeviceInput->Release();
2303	pThis->pIDeviceInput = NULL;
2304	}
2305
2306	if (RTCritSectRwIsInitialized(&pThis->CritSectStreamList))
2307	RTCritSectRwDelete(&pThis->CritSectStreamList);
2308
2309	LogFlowFuncLeave();
2310	}
2311
2312
2313	/**
2314	* @callback_method_impl{FNPDMDRVCONSTRUCT, pfnConstruct}
2315	*/
2316	static DECLCALLBACK(int) drvHostAudioWasConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
2317	{
2318	PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
2319	PDRVHOSTAUDIOWAS pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTAUDIOWAS);
2320	RT_NOREF(fFlags, pCfg);
2321
2322	/*
2323	* Init basic data members and interfaces.
2324	*/
2325	pThis->pDrvIns = pDrvIns;
2326	pThis->hDrainTimer = NIL_TMTIMERHANDLE;
2327	RTListInit(&pThis->StreamHead);
2328	RTListInit(&pThis->CacheHead);
2329	/* IBase */
2330	pDrvIns->IBase.pfnQueryInterface = drvHostAudioWasQueryInterface;
2331	/* IHostAudio */
2332	pThis->IHostAudio.pfnGetConfig = drvHostAudioWasHA_GetConfig;
2333	pThis->IHostAudio.pfnGetDevices = drvHostAudioWasHA_GetDevices;
2334	pThis->IHostAudio.pfnGetStatus = drvHostAudioWasHA_GetStatus;
2335	pThis->IHostAudio.pfnStreamCreate = drvHostAudioWasHA_StreamCreate;
2336	pThis->IHostAudio.pfnStreamDestroy = drvHostAudioWasHA_StreamDestroy;
2337	pThis->IHostAudio.pfnStreamControl = drvHostAudioWasHA_StreamControl;
2338	pThis->IHostAudio.pfnStreamGetReadable = drvHostAudioWasHA_StreamGetReadable;
2339	pThis->IHostAudio.pfnStreamGetWritable = drvHostAudioWasHA_StreamGetWritable;
2340	pThis->IHostAudio.pfnStreamGetPending = drvHostAudioWasHA_StreamGetPending;
2341	pThis->IHostAudio.pfnStreamGetStatus = drvHostAudioWasHA_StreamGetStatus;
2342	pThis->IHostAudio.pfnStreamPlay = drvHostAudioWasHA_StreamPlay;
2343	pThis->IHostAudio.pfnStreamCapture = drvHostAudioWasHA_StreamCapture;
2344
2345	/*
2346	* Validate and read the configuration.
2347	*/
2348	/** @todo We need a UUID for the session, while Pulse want some kind of name
2349	* when creating the streams. "StreamName" is confusing and a little
2350	* misleading though, unless used only for Pulse. Simply "VmName"
2351	* would be a lot better and more generic. */
2352	PDMDRV_VALIDATE_CONFIG_RETURN(pDrvIns, "VmName\|VmUuid", "");
2353	/** @todo make it possible to override the default device selection. */
2354
2355	/*
2356	* Initialize the critical sections early.
2357	*/
2358	int rc = RTCritSectRwInit(&pThis->CritSectStreamList);
2359	AssertRCReturn(rc, rc);
2360
2361	rc = RTCritSectInit(&pThis->CritSectCache);
2362	AssertRCReturn(rc, rc);
2363
2364	/*
2365	* Create an enumerator instance that we can get the default devices from
2366	* as well as do enumeration thru.
2367	*/
2368	HRESULT hrc = CoCreateInstance(__uuidof(MMDeviceEnumerator), 0, CLSCTX_ALL, __uuidof(IMMDeviceEnumerator),
2369	(void **)&pThis->pIEnumerator);
2370	if (FAILED(hrc))
2371	{
2372	pThis->pIEnumerator = NULL;
2373	LogRel(("WasAPI: Failed to create an MMDeviceEnumerator object: %Rhrc\n", hrc));
2374	return VERR_AUDIO_BACKEND_INIT_FAILED;
2375	}
2376	AssertPtr(pThis->pIEnumerator);
2377
2378	/*
2379	* Resolve the notification interface.
2380	*/
2381	pThis->pIAudioNotifyFromHost = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIAUDIONOTIFYFROMHOST);
2382	# ifdef VBOX_WITH_AUDIO_CALLBACKS
2383	AssertPtr(pThis->pIAudioNotifyFromHost);
2384	# endif
2385
2386	/*
2387	* Instantiate and register the notification client with the enumerator.
2388	*
2389	* Failure here isn't considered fatal at this time as we'll just miss
2390	* default device changes.
2391	*/
2392	try
2393	{
2394	pThis->pNotifyClient = new DrvHostAudioWasMmNotifyClient(pThis);
2395	}
2396	catch (std::bad_alloc &)
2397	{
2398	return VERR_NO_MEMORY;
2399	}
2400	catch (int rcXcpt)
2401	{
2402	return rcXcpt;
2403	}
2404	hrc = pThis->pIEnumerator->RegisterEndpointNotificationCallback(pThis->pNotifyClient);
2405	AssertMsg(SUCCEEDED(hrc), ("%Rhrc\n", hrc));
2406	if (FAILED(hrc))
2407	{
2408	LogRel(("WasAPI: RegisterEndpointNotificationCallback failed: %Rhrc (ignored)\n"
2409	"WasAPI: Warning! Will not be able to detect default device changes!\n"));
2410	pThis->pNotifyClient->notifyDriverDestroyed();
2411	pThis->pNotifyClient->Release();
2412	pThis->pNotifyClient = NULL;
2413	}
2414
2415	/*
2416	* Retrieve the input and output device.
2417	*/
2418	IMMDevice *pIDeviceInput = NULL;
2419	if (pThis->pwszInputDevId)
2420	hrc = pThis->pIEnumerator->GetDevice(pThis->pwszInputDevId, &pIDeviceInput);
2421	else
2422	hrc = pThis->pIEnumerator->GetDefaultAudioEndpoint(eCapture, eMultimedia, &pIDeviceInput);
2423	if (SUCCEEDED(hrc))
2424	LogFlowFunc(("pIDeviceInput=%p\n", pIDeviceInput));
2425	else
2426	{
2427	LogRel(("WasAPI: Failed to get audio input device '%ls': %Rhrc\n",
2428	pThis->pwszInputDevId ? pThis->pwszInputDevId : L"{Default}", hrc));
2429	pIDeviceInput = NULL;
2430	}
2431
2432	IMMDevice *pIDeviceOutput = NULL;
2433	if (pThis->pwszOutputDevId)
2434	hrc = pThis->pIEnumerator->GetDevice(pThis->pwszOutputDevId, &pIDeviceOutput);
2435	else
2436	hrc = pThis->pIEnumerator->GetDefaultAudioEndpoint(eRender, eMultimedia, &pIDeviceOutput);
2437	if (SUCCEEDED(hrc))
2438	LogFlowFunc(("pIDeviceOutput=%p\n", pIDeviceOutput));
2439	else
2440	{
2441	LogRel(("WasAPI: Failed to get audio output device '%ls': %Rhrc\n",
2442	pThis->pwszOutputDevId ? pThis->pwszOutputDevId : L"{Default}", hrc));
2443	pIDeviceOutput = NULL;
2444	}
2445
2446	/* Carefully place them in the instance data: */
2447	pThis->pNotifyClient->lockEnter();
2448
2449	if (pThis->pIDeviceInput)
2450	pThis->pIDeviceInput->Release();
2451	pThis->pIDeviceInput = pIDeviceInput;
2452
2453	if (pThis->pIDeviceOutput)
2454	pThis->pIDeviceOutput->Release();
2455	pThis->pIDeviceOutput = pIDeviceOutput;
2456
2457	pThis->pNotifyClient->lockLeave();
2458
2459	/*
2460	* We need a timer and a R/W critical section for draining streams.
2461	*/
2462	rc = PDMDrvHlpTMTimerCreate(pDrvIns, TMCLOCK_REAL, drvHostWasDrainStopTimer, NULL /pvUser/, 0 /fFlags/,
2463	"WasAPI drain", &pThis->hDrainTimer);
2464	AssertRCReturn(rc, rc);
2465
2466	/*
2467	* Prime the cache.
2468	*/
2469	drvHostAudioWasCacheFill(pThis);
2470
2471	return VINF_SUCCESS;
2472	}
2473
2474
2475	/**
2476	* PDM driver registration for WasAPI.
2477	*/
2478	const PDMDRVREG g_DrvHostAudioWas =
2479	{
2480	/* u32Version */
2481	PDM_DRVREG_VERSION,
2482	/* szName */
2483	"HostAudioWas",
2484	/* szRCMod */
2485	"",
2486	/* szR0Mod */
2487	"",
2488	/* pszDescription */
2489	"Windows Audio Session API (WASAPI) host audio driver",
2490	/* fFlags */
2491	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
2492	/* fClass. */
2493	PDM_DRVREG_CLASS_AUDIO,
2494	/* cMaxInstances */
2495	~0U,
2496	/* cbInstance */
2497	sizeof(DRVHOSTAUDIOWAS),
2498	/* pfnConstruct */
2499	drvHostAudioWasConstruct,
2500	/* pfnDestruct */
2501	drvHostAudioWasDestruct,
2502	/* pfnRelocate */
2503	NULL,
2504	/* pfnIOCtl */
2505	NULL,
2506	/* pfnPowerOn */
2507	NULL,
2508	/* pfnReset */
2509	NULL,
2510	/* pfnSuspend */
2511	NULL,
2512	/* pfnResume */
2513	NULL,
2514	/* pfnAttach */
2515	NULL,
2516	/* pfnDetach */
2517	NULL,
2518	/* pfnPowerOff */
2519	NULL,
2520	/* pfnSoftReset */
2521	NULL,
2522	/* u32EndVersion */
2523	PDM_DRVREG_VERSION
2524	};

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

source: vbox/trunk/src/VBox/Devices/Audio/DrvHostAudioWasApi.cpp@ 88692

Download in other formats: