DrvHostAudioPulseAudio.cpp@ 88534

Last change on this file since 88534 was 88534, checked in by vboxsync, 4 years ago
Audio: Merged the cbStreamOut and cbStreamIn fields in PDMAUDIOBACKENDCFG (into cbStream). Added a fFlags member to PDMAUDIOBACKENDCFG, currently must-be-zero. bugref:9890
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 76.8 KB

Line
1	/* $Id: DrvHostAudioPulseAudio.cpp 88534 2021-04-15 12:16:56Z vboxsync $ */
2	/** @file
3	* Host audio driver - Pulse Audio.
4	*/
5
6	/*
7	* Copyright (C) 2006-2020 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 <VBox/vmm/pdmaudioifs.h>
25	#include <VBox/vmm/pdmaudioinline.h>
26	#include <VBox/vmm/pdmaudiohostenuminline.h>
27
28	#include <stdio.h>
29
30	#include <iprt/alloc.h>
31	#include <iprt/mem.h>
32	#include <iprt/uuid.h>
33	#include <iprt/semaphore.h>
34
35	#include "DrvHostAudioPulseAudioStubsMangling.h"
36	#include "DrvHostAudioPulseAudioStubs.h"
37
38	#include <pulse/pulseaudio.h>
39	#ifndef PA_STREAM_NOFLAGS
40	# define PA_STREAM_NOFLAGS (pa_context_flags_t)0x0000U /* since 0.9.19 */
41	#endif
42	#ifndef PA_CONTEXT_NOFLAGS
43	# define PA_CONTEXT_NOFLAGS (pa_context_flags_t)0x0000U /* since 0.9.19 */
44	#endif
45
46	#include "VBoxDD.h"
47
48
49	/*********************************************************************************************************************************
50	* Defines *
51	*********************************************************************************************************************************/
52	/** Max number of errors reported by drvHostAudioPaError per instance.
53	* @todo Make this configurable thru driver config. */
54	#define VBOX_PULSEAUDIO_MAX_LOG_REL_ERRORS 99
55
56
57	/** @name PULSEAUDIOENUMCBFLAGS_XXX
58	* @{ */
59	/** No flags specified. */
60	#define PULSEAUDIOENUMCBFLAGS_NONE 0
61	/** (Release) log found devices. */
62	#define PULSEAUDIOENUMCBFLAGS_LOG RT_BIT(0)
63	/** Only do default devices. */
64	#define PULSEAUDIOENUMCBFLAGS_DEFAULT_ONLY RT_BIT(1)
65	/** @} */
66
67
68	/*********************************************************************************************************************************
69	* Structures *
70	*********************************************************************************************************************************/
71	/** Pointer to the instance data for a pulse audio host audio driver. */
72	typedef struct DRVHOSTPULSEAUDIO *PDRVHOSTPULSEAUDIO;
73
74
75	/**
76	* Callback context for the server init context state changed callback.
77	*/
78	typedef struct PULSEAUDIOSTATECHGCTX
79	{
80	/** The event semaphore. */
81	RTSEMEVENT hEvtInit;
82	/** The returned context state. */
83	pa_context_state_t volatile enmCtxState;
84	} PULSEAUDIOSTATECHGCTX;
85	/** Pointer to a server init context state changed callback context. */
86	typedef PULSEAUDIOSTATECHGCTX *PPULSEAUDIOSTATECHGCTX;
87
88
89	/**
90	* Enumeration callback context used by the pfnGetConfig code.
91	*/
92	typedef struct PULSEAUDIOENUMCBCTX
93	{
94	/** Pointer to PulseAudio's threaded main loop. */
95	pa_threaded_mainloop *pMainLoop;
96	/** Enumeration flags, PULSEAUDIOENUMCBFLAGS_XXX. */
97	uint32_t fFlags;
98	/** VBox status code for the operation.
99	* The caller sets this to VERR_AUDIO_ENUMERATION_FAILED, the callback never
100	* uses that status code. */
101	int32_t rcEnum;
102	/** Name of default sink being used. Must be free'd using RTStrFree(). */
103	char *pszDefaultSink;
104	/** Name of default source being used. Must be free'd using RTStrFree(). */
105	char *pszDefaultSource;
106	/** The device enumeration to fill, NULL if pfnGetConfig context. */
107	PPDMAUDIOHOSTENUM pDeviceEnum;
108	} PULSEAUDIOENUMCBCTX;
109	/** Pointer to an enumeration callback context. */
110	typedef PULSEAUDIOENUMCBCTX *PPULSEAUDIOENUMCBCTX;
111
112
113	/**
114	* Pulse audio device enumeration entry.
115	*/
116	typedef struct PULSEAUDIODEVENTRY
117	{
118	/** The part we share with others. */
119	PDMAUDIOHOSTDEV Core;
120	/** The pulse audio name.
121	* @note Kind of must use fixed size field here as that allows
122	* PDMAudioHostDevDup() and PDMAudioHostEnumCopy() to work. */
123	RT_FLEXIBLE_ARRAY_EXTENSION
124	char szPulseName[RT_FLEXIBLE_ARRAY];
125	} PULSEAUDIODEVENTRY;
126	/** Pointer to a pulse audio device enumeration entry. */
127	typedef PULSEAUDIODEVENTRY *PPULSEAUDIODEVENTRY;
128
129
130	/**
131	* Pulse audio stream data.
132	*/
133	typedef struct PULSEAUDIOSTREAM
134	{
135	/** The stream's acquired configuration. */
136	PDMAUDIOSTREAMCFG Cfg;
137	/** Pointer to driver instance. */
138	PDRVHOSTPULSEAUDIO pDrv;
139	/** Pointer to opaque PulseAudio stream. */
140	pa_stream *pStream;
141	/** Pulse sample format and attribute specification. */
142	pa_sample_spec SampleSpec;
143	/** Pulse playback and buffer metrics. */
144	pa_buffer_attr BufAttr;
145	/** Input: Pointer to Pulse sample peek buffer. */
146	const uint8_t *pbPeekBuf;
147	/** Input: Current size (in bytes) of peeked data in buffer. */
148	size_t cbPeekBuf;
149	/** Input: Our offset (in bytes) in peek data buffer. */
150	size_t offPeekBuf;
151	/** Output: Asynchronous drain operation. This is used as an indicator of
152	* whether we're currently draining the stream (will be cleaned up before
153	* resume/re-enable). */
154	pa_operation *pDrainOp;
155	/** Asynchronous cork/uncork operation.
156	* (This solely for cancelling before destroying the stream, so the callback
157	* won't do any after-freed accesses.) */
158	pa_operation *pCorkOp;
159	/** Asynchronous trigger operation.
160	* (This solely for cancelling before destroying the stream, so the callback
161	* won't do any after-freed accesses.) */
162	pa_operation *pTriggerOp;
163	/** Output: Current latency (in microsecs). */
164	uint64_t cUsLatency;
165	#ifdef LOG_ENABLED
166	/** Creation timestamp (in microsecs) of stream playback / recording. */
167	pa_usec_t tsStartUs;
168	/** Timestamp (in microsecs) when last read from / written to the stream. */
169	pa_usec_t tsLastReadWrittenUs;
170	#endif
171	#ifdef DEBUG
172	/** Number of occurred audio data underflows. */
173	uint32_t cUnderflows;
174	#endif
175	} PULSEAUDIOSTREAM;
176	/** Pointer to pulse audio stream data. */
177	typedef PULSEAUDIOSTREAM *PPULSEAUDIOSTREAM;
178
179
180	/**
181	* Pulse audio host audio driver instance data.
182	* @implements PDMIAUDIOCONNECTOR
183	*/
184	typedef struct DRVHOSTPULSEAUDIO
185	{
186	/** Pointer to the driver instance structure. */
187	PPDMDRVINS pDrvIns;
188	/** Pointer to PulseAudio's threaded main loop. */
189	pa_threaded_mainloop *pMainLoop;
190	/**
191	* Pointer to our PulseAudio context.
192	* @note We use a pMainLoop in a separate thread (pContext).
193	* So either use callback functions or protect these functions
194	* by pa_threaded_mainloop_lock() / pa_threaded_mainloop_unlock().
195	*/
196	pa_context *pContext;
197	/** Shutdown indicator. */
198	volatile bool fAbortLoop;
199	/** Error count for not flooding the release log.
200	* Specify UINT32_MAX for unlimited logging. */
201	uint32_t cLogErrors;
202	/** The stream (base) name; needed for distinguishing
203	* streams in the PulseAudio mixer controls if multiple
204	* VMs are running at the same time. */
205	char szStreamName[64];
206	/** Don't want to put this on the stack... */
207	PULSEAUDIOSTATECHGCTX InitStateChgCtx;
208	/** Pointer to host audio interface. */
209	PDMIHOSTAUDIO IHostAudio;
210	} DRVHOSTPULSEAUDIO;
211
212
213
214	/*
215	* Glue to make the code work systems with PulseAudio < 0.9.11.
216	*/
217	#if !defined(PA_CONTEXT_IS_GOOD) && PA_API_VERSION < 12 /* 12 = 0.9.11 where PA_STREAM_IS_GOOD was added */
218	DECLINLINE(bool) PA_CONTEXT_IS_GOOD(pa_context_state_t enmState)
219	{
220	return enmState == PA_CONTEXT_CONNECTING
221	\|\| enmState == PA_CONTEXT_AUTHORIZING
222	\|\| enmState == PA_CONTEXT_SETTING_NAME
223	\|\| enmState == PA_CONTEXT_READY;
224	}
225	#endif
226
227	#if !defined(PA_STREAM_IS_GOOD) && PA_API_VERSION < 12 /* 12 = 0.9.11 where PA_STREAM_IS_GOOD was added */
228	DECLINLINE(bool) PA_STREAM_IS_GOOD(pa_stream_state_t enmState)
229	{
230	return enmState == PA_STREAM_CREATING
231	\|\| enmState == PA_STREAM_READY;
232	}
233	#endif
234
235
236	/**
237	* Converts a pulse audio error to a VBox status.
238	*
239	* @returns VBox status code.
240	* @param rcPa The error code to convert.
241	*/
242	static int drvHostAudioPaErrorToVBox(int rcPa)
243	{
244	/** @todo Implement some PulseAudio -> VBox mapping here. */
245	RT_NOREF(rcPa);
246	return VERR_GENERAL_FAILURE;
247	}
248
249
250	/**
251	* Logs a pulse audio (from context) and converts it to VBox status.
252	*
253	* @returns VBox status code.
254	* @param pThis Our instance data.
255	* @param pszFormat The format string for the release log (no newline) .
256	* @param ... Format string arguments.
257	*/
258	static int drvHostAudioPaError(PDRVHOSTPULSEAUDIO pThis, const char *pszFormat, ...)
259	{
260	AssertPtrReturn(pThis, VERR_INVALID_POINTER);
261	AssertPtr(pszFormat);
262
263	int const rcPa = pa_context_errno(pThis->pContext);
264	int const rcVBox = drvHostAudioPaErrorToVBox(rcPa);
265
266	if ( pThis->cLogErrors < VBOX_PULSEAUDIO_MAX_LOG_REL_ERRORS
267	&& LogRelIs2Enabled())
268	{
269	va_list va;
270	va_start(va, pszFormat);
271	LogRel(("PulseAudio: %N: %s (%d, %Rrc)\n", pszFormat, &va, pa_strerror(rcPa), rcPa, rcVBox));
272	va_end(va);
273
274	if (++pThis->cLogErrors == VBOX_PULSEAUDIO_MAX_LOG_REL_ERRORS)
275	LogRel(("PulseAudio: muting errors (max %u)\n", VBOX_PULSEAUDIO_MAX_LOG_REL_ERRORS));
276	}
277
278	return rcVBox;
279	}
280
281
282	/**
283	* Signal the main loop to abort. Just signalling isn't sufficient as the
284	* mainloop might not have been entered yet.
285	*/
286	static void drvHostAudioPaSignalWaiter(PDRVHOSTPULSEAUDIO pThis)
287	{
288	if (pThis)
289	{
290	pThis->fAbortLoop = true;
291	pa_threaded_mainloop_signal(pThis->pMainLoop, 0);
292	}
293	}
294
295
296	/**
297	* Wrapper around pa_threaded_mainloop_wait().
298	*/
299	static void drvHostAudioPaMainloopWait(PDRVHOSTPULSEAUDIO pThis)
300	{
301	/** @todo r=bird: explain this logic. */
302	if (!pThis->fAbortLoop)
303	pa_threaded_mainloop_wait(pThis->pMainLoop);
304	pThis->fAbortLoop = false;
305	}
306
307
308	/**
309	* Pulse audio callback for context status changes, init variant.
310	*/
311	static void drvHostAudioPaCtxCallbackStateChanged(pa_context pCtx, void pvUser)
312	{
313	AssertPtrReturnVoid(pCtx);
314
315	PDRVHOSTPULSEAUDIO pThis = (PDRVHOSTPULSEAUDIO)pvUser;
316	AssertPtrReturnVoid(pThis);
317
318	switch (pa_context_get_state(pCtx))
319	{
320	case PA_CONTEXT_READY:
321	case PA_CONTEXT_TERMINATED:
322	case PA_CONTEXT_FAILED:
323	drvHostAudioPaSignalWaiter(pThis);
324	break;
325
326	default:
327	break;
328	}
329	}
330
331
332	/**
333	* Synchronously wait until an operation completed.
334	*
335	* This will consume the pOperation reference.
336	*/
337	static int drvHostAudioPaWaitForEx(PDRVHOSTPULSEAUDIO pThis, pa_operation *pOperation, RTMSINTERVAL cMsTimeout)
338	{
339	AssertPtrReturn(pOperation, VERR_INVALID_POINTER);
340
341	uint64_t const msStart = RTTimeMilliTS();
342	pa_operation_state_t enmOpState;
343	while ((enmOpState = pa_operation_get_state(pOperation)) == PA_OPERATION_RUNNING)
344	{
345	if (!pThis->fAbortLoop) /** @todo r=bird: I do _not_ get the logic behind this fAbortLoop mechanism, it looks more
346	* than a little mixed up and too much generalized see drvHostAudioPaSignalWaiter. */
347	{
348	AssertPtr(pThis->pMainLoop);
349	pa_threaded_mainloop_wait(pThis->pMainLoop);
350	if ( !pThis->pContext
351	\|\| pa_context_get_state(pThis->pContext) != PA_CONTEXT_READY)
352	{
353	pa_operation_cancel(pOperation);
354	pa_operation_unref(pOperation);
355	LogRel(("PulseAudio: pa_context_get_state context not ready\n"));
356	return VERR_INVALID_STATE;
357	}
358	}
359	pThis->fAbortLoop = false;
360
361	/*
362	* Note! This timeout business is a bit bogus as pa_threaded_mainloop_wait is indefinite.
363	*/
364	if (RTTimeMilliTS() - msStart >= cMsTimeout)
365	{
366	enmOpState = pa_operation_get_state(pOperation);
367	if (enmOpState != PA_OPERATION_RUNNING)
368	break;
369	pa_operation_cancel(pOperation);
370	pa_operation_unref(pOperation);
371	return VERR_TIMEOUT;
372	}
373	}
374
375	pa_operation_unref(pOperation);
376	if (enmOpState == PA_OPERATION_DONE)
377	return VINF_SUCCESS;
378	return VERR_CANCELLED;
379	}
380
381
382	static int drvHostAudioPaWaitFor(PDRVHOSTPULSEAUDIO pThis, pa_operation *pOP)
383	{
384	return drvHostAudioPaWaitForEx(pThis, pOP, 10 * RT_MS_1SEC);
385	}
386
387
388
389	/*********************************************************************************************************************************
390	* PDMIHOSTAUDIO *
391	*********************************************************************************************************************************/
392
393	/**
394	* Worker for drvHostAudioPaEnumSourceCallback() and
395	* drvHostAudioPaEnumSinkCallback() that adds an entry to the enumeration
396	* result.
397	*/
398	static void drvHostAudioPaEnumAddDevice(PPULSEAUDIOENUMCBCTX pCbCtx, PDMAUDIODIR enmDir, const char *pszName,
399	const char *pszDesc, uint8_t cChannelsInput, uint8_t cChannelsOutput,
400	const char *pszDefaultName)
401	{
402	size_t const cchName = strlen(pszName);
403	PPULSEAUDIODEVENTRY pDev = (PPULSEAUDIODEVENTRY)PDMAudioHostDevAlloc(RT_UOFFSETOF(PULSEAUDIODEVENTRY, szPulseName)
404	+ RT_ALIGN_Z(cchName + 1, 16));
405	if (pDev != NULL)
406	{
407	memcpy(pDev->szPulseName, pszName, cchName);
408	pDev->szPulseName[cchName] = '\0';
409
410	pDev->Core.enmUsage = enmDir;
411	pDev->Core.enmType = RTStrIStr(pszDesc, "built-in") != NULL
412	? PDMAUDIODEVICETYPE_BUILTIN : PDMAUDIODEVICETYPE_UNKNOWN;
413	pDev->Core.fFlags = RTStrCmp(pszName, pszDefaultName) == 0
414	? PDMAUDIOHOSTDEV_F_DEFAULT : PDMAUDIOHOSTDEV_F_NONE;
415	pDev->Core.cMaxInputChannels = cChannelsInput;
416	pDev->Core.cMaxOutputChannels = cChannelsOutput;
417	RTStrCopy(pDev->Core.szName, sizeof(pDev->Core.szName),
418	pszDesc && *pszDesc ? pszDesc : pszName);
419
420	PDMAudioHostEnumAppend(pCbCtx->pDeviceEnum, &pDev->Core);
421	}
422	else
423	pCbCtx->rcEnum = VERR_NO_MEMORY;
424	}
425
426
427	/**
428	* Enumeration callback - source info.
429	*
430	* @param pCtx The context (DRVHOSTPULSEAUDIO::pContext).
431	* @param pInfo The info. NULL when @a eol is not zero.
432	* @param eol Error-or-last indicator or something like that:
433	* - 0: Normal call with info.
434	* - 1: End of list, no info.
435	* - -1: Error callback, no info.
436	* @param pvUserData Pointer to our PULSEAUDIOENUMCBCTX structure.
437	*/
438	static void drvHostAudioPaEnumSourceCallback(pa_context pCtx, const pa_source_info pInfo, int eol, void *pvUserData)
439	{
440	LogFlowFunc(("pCtx=%p pInfo=%p eol=%d pvUserData=%p\n", pCtx, pInfo, eol, pvUserData));
441	PPULSEAUDIOENUMCBCTX pCbCtx = (PPULSEAUDIOENUMCBCTX)pvUserData;
442	AssertPtrReturnVoid(pCbCtx);
443	Assert((pInfo == NULL) == (eol != 0));
444	RT_NOREF(pCtx);
445
446	if (eol == 0 && pInfo != NULL)
447	{
448	LogRel2(("Pulse Audio: Source #%u: %u Hz %uch format=%u name='%s' desc='%s' driver='%s' flags=%#x\n",
449	pInfo->index, pInfo->sample_spec.rate, pInfo->sample_spec.channels, pInfo->sample_spec.format,
450	pInfo->name, pInfo->description, pInfo->driver, pInfo->flags));
451	drvHostAudioPaEnumAddDevice(pCbCtx, PDMAUDIODIR_IN, pInfo->name, pInfo->description,
452	pInfo->sample_spec.channels, 0 /cChannelsOutput/, pCbCtx->pszDefaultSource);
453	}
454	else if (eol == 1 && !pInfo && pCbCtx->rcEnum == VERR_AUDIO_ENUMERATION_FAILED)
455	pCbCtx->rcEnum = VINF_SUCCESS;
456
457	/* Wake up the calling thread when done: */
458	if (eol != 0)
459	pa_threaded_mainloop_signal(pCbCtx->pMainLoop, 0);
460	}
461
462
463	/**
464	* Enumeration callback - sink info.
465	*
466	* @param pCtx The context (DRVHOSTPULSEAUDIO::pContext).
467	* @param pInfo The info. NULL when @a eol is not zero.
468	* @param eol Error-or-last indicator or something like that:
469	* - 0: Normal call with info.
470	* - 1: End of list, no info.
471	* - -1: Error callback, no info.
472	* @param pvUserData Pointer to our PULSEAUDIOENUMCBCTX structure.
473	*/
474	static void drvHostAudioPaEnumSinkCallback(pa_context pCtx, const pa_sink_info pInfo, int eol, void *pvUserData)
475	{
476	LogFlowFunc(("pCtx=%p pInfo=%p eol=%d pvUserData=%p\n", pCtx, pInfo, eol, pvUserData));
477	PPULSEAUDIOENUMCBCTX pCbCtx = (PPULSEAUDIOENUMCBCTX)pvUserData;
478	AssertPtrReturnVoid(pCbCtx);
479	Assert((pInfo == NULL) == (eol != 0));
480	RT_NOREF(pCtx);
481
482	if (eol == 0 && pInfo != NULL)
483	{
484	LogRel2(("Pulse Audio: Sink #%u: %u Hz %uch format=%u name='%s' desc='%s' driver='%s' flags=%#x\n",
485	pInfo->index, pInfo->sample_spec.rate, pInfo->sample_spec.channels, pInfo->sample_spec.format,
486	pInfo->name, pInfo->description, pInfo->driver, pInfo->flags));
487	drvHostAudioPaEnumAddDevice(pCbCtx, PDMAUDIODIR_OUT, pInfo->name, pInfo->description,
488	0 /cChannelsInput/, pInfo->sample_spec.channels, pCbCtx->pszDefaultSink);
489	}
490	else if (eol == 1 && !pInfo && pCbCtx->rcEnum == VERR_AUDIO_ENUMERATION_FAILED)
491	pCbCtx->rcEnum = VINF_SUCCESS;
492
493	/* Wake up the calling thread when done: */
494	if (eol != 0)
495	pa_threaded_mainloop_signal(pCbCtx->pMainLoop, 0);
496	}
497
498
499	/**
500	* Enumeration callback - service info.
501	*
502	* Copy down the default names.
503	*/
504	static void drvHostAudioPaEnumServerCallback(pa_context pCtx, const pa_server_info pInfo, void *pvUserData)
505	{
506	LogFlowFunc(("pCtx=%p pInfo=%p pvUserData=%p\n", pCtx, pInfo, pvUserData));
507	PPULSEAUDIOENUMCBCTX pCbCtx = (PPULSEAUDIOENUMCBCTX)pvUserData;
508	AssertPtrReturnVoid(pCbCtx);
509	RT_NOREF(pCtx);
510
511	if (pInfo)
512	{
513	LogRel2(("PulseAudio: Server info: user=%s host=%s ver=%s name=%s defsink=%s defsrc=%s spec: %d %uHz %uch\n",
514	pInfo->user_name, pInfo->host_name, pInfo->server_version, pInfo->server_name,
515	pInfo->default_sink_name, pInfo->default_source_name,
516	pInfo->sample_spec.format, pInfo->sample_spec.rate, pInfo->sample_spec.channels));
517
518	Assert(!pCbCtx->pszDefaultSink);
519	Assert(!pCbCtx->pszDefaultSource);
520	Assert(pCbCtx->rcEnum == VERR_AUDIO_ENUMERATION_FAILED);
521	pCbCtx->rcEnum = VINF_SUCCESS;
522
523	if (pInfo->default_sink_name)
524	{
525	Assert(RTStrIsValidEncoding(pInfo->default_sink_name));
526	pCbCtx->pszDefaultSink = RTStrDup(pInfo->default_sink_name);
527	AssertStmt(pCbCtx->pszDefaultSink, pCbCtx->rcEnum = VERR_NO_STR_MEMORY);
528	}
529
530	if (pInfo->default_source_name)
531	{
532	Assert(RTStrIsValidEncoding(pInfo->default_source_name));
533	pCbCtx->pszDefaultSource = RTStrDup(pInfo->default_source_name);
534	AssertStmt(pCbCtx->pszDefaultSource, pCbCtx->rcEnum = VERR_NO_STR_MEMORY);
535	}
536	}
537	else
538	pCbCtx->rcEnum = VERR_INVALID_POINTER;
539
540	pa_threaded_mainloop_signal(pCbCtx->pMainLoop, 0);
541	}
542
543
544	/**
545	* @note Called with the PA main loop locked.
546	*/
547	static int drvHostAudioPaEnumerate(PDRVHOSTPULSEAUDIO pThis, uint32_t fEnum, PPDMAUDIOHOSTENUM pDeviceEnum)
548	{
549	PULSEAUDIOENUMCBCTX CbCtx = { pThis->pMainLoop, fEnum, VERR_AUDIO_ENUMERATION_FAILED, NULL, NULL, pDeviceEnum };
550	bool const fLog = (fEnum & PULSEAUDIOENUMCBFLAGS_LOG);
551	bool const fOnlyDefault = (fEnum & PULSEAUDIOENUMCBFLAGS_DEFAULT_ONLY);
552	int rc;
553
554	/*
555	* Check if server information is available and bail out early if it isn't.
556	* This should give us a default (playback) sink and (recording) source.
557	*/
558	LogRel(("PulseAudio: Retrieving server information ...\n"));
559	CbCtx.rcEnum = VERR_AUDIO_ENUMERATION_FAILED;
560	pa_operation *paOpServerInfo = pa_context_get_server_info(pThis->pContext, drvHostAudioPaEnumServerCallback, &CbCtx);
561	if (paOpServerInfo)
562	rc = drvHostAudioPaWaitFor(pThis, paOpServerInfo);
563	else
564	{
565	LogRel(("PulseAudio: Server information not available, skipping enumeration.\n"));
566	return VINF_SUCCESS;
567	}
568	if (RT_SUCCESS(rc))
569	rc = CbCtx.rcEnum;
570	if (RT_FAILURE(rc))
571	{
572	if (fLog)
573	LogRel(("PulseAudio: Error enumerating PulseAudio server properties: %Rrc\n", rc));
574	return rc;
575	}
576
577	/*
578	* Get info about the playback sink.
579	*/
580	if (fLog && CbCtx.pszDefaultSink)
581	LogRel2(("PulseAudio: Default output sink is '%s'\n", CbCtx.pszDefaultSink));
582	else if (fLog)
583	LogRel2(("PulseAudio: No default output sink found\n"));
584
585	if (CbCtx.pszDefaultSink \|\| !fOnlyDefault)
586	{
587	CbCtx.rcEnum = VERR_AUDIO_ENUMERATION_FAILED;
588	if (!fOnlyDefault)
589	rc = drvHostAudioPaWaitFor(pThis,
590	pa_context_get_sink_info_list(pThis->pContext, drvHostAudioPaEnumSinkCallback, &CbCtx));
591	else
592	rc = drvHostAudioPaWaitFor(pThis, pa_context_get_sink_info_by_name(pThis->pContext, CbCtx.pszDefaultSink,
593	drvHostAudioPaEnumSinkCallback, &CbCtx));
594	if (RT_SUCCESS(rc))
595	rc = CbCtx.rcEnum;
596	if (fLog && RT_FAILURE(rc))
597	LogRel(("PulseAudio: Error enumerating properties for default output sink '%s': %Rrc\n",
598	CbCtx.pszDefaultSink, rc));
599	}
600
601	/*
602	* Get info about the recording source.
603	*/
604	if (fLog && CbCtx.pszDefaultSource)
605	LogRel2(("PulseAudio: Default input source is '%s'\n", CbCtx.pszDefaultSource));
606	else if (fLog)
607	LogRel2(("PulseAudio: No default input source found\n"));
608	if (CbCtx.pszDefaultSource \|\| !fOnlyDefault)
609	{
610	CbCtx.rcEnum = VERR_AUDIO_ENUMERATION_FAILED;
611	int rc2;
612	if (!fOnlyDefault)
613	rc2 = drvHostAudioPaWaitFor(pThis, pa_context_get_source_info_list(pThis->pContext,
614	drvHostAudioPaEnumSourceCallback, &CbCtx));
615	else
616	rc2 = drvHostAudioPaWaitFor(pThis, pa_context_get_source_info_by_name(pThis->pContext, CbCtx.pszDefaultSource,
617	drvHostAudioPaEnumSourceCallback, &CbCtx));
618	if (RT_SUCCESS(rc2))
619	rc2 = CbCtx.rcEnum;
620	if (fLog && RT_FAILURE(rc2))
621	LogRel(("PulseAudio: Error enumerating properties for default input source '%s': %Rrc\n",
622	CbCtx.pszDefaultSource, rc));
623	if (RT_SUCCESS(rc))
624	rc = rc2;
625	}
626
627	/* clean up */
628	RTStrFree(CbCtx.pszDefaultSink);
629	RTStrFree(CbCtx.pszDefaultSource);
630
631	LogFlowFuncLeaveRC(rc);
632	return rc;
633	}
634
635
636	/**
637	* @interface_method_impl{PDMIHOSTAUDIO,pfnGetConfig}
638	*/
639	static DECLCALLBACK(int) drvHostAudioPaHA_GetConfig(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDCFG pBackendCfg)
640	{
641	PDRVHOSTPULSEAUDIO pThis = RT_FROM_MEMBER(pInterface, DRVHOSTPULSEAUDIO, IHostAudio);
642	AssertPtrReturn(pBackendCfg, VERR_INVALID_POINTER);
643
644	/*
645	* The configuration.
646	*/
647	RTStrCopy(pBackendCfg->szName, sizeof(pBackendCfg->szName), "PulseAudio");
648	pBackendCfg->cbStream = sizeof(PULSEAUDIOSTREAM);
649	pBackendCfg->fFlags = 0;
650	pBackendCfg->cMaxStreamsOut = UINT32_MAX;
651	pBackendCfg->cMaxStreamsIn = UINT32_MAX;
652
653	#if 0
654	/*
655	* In case we want to gather info about default devices, we can do this:
656	*/
657	PDMAUDIOHOSTENUM DeviceEnum;
658	PDMAudioHostEnumInit(&DeviceEnum);
659	pa_threaded_mainloop_lock(pThis->pMainLoop);
660	int rc = drvHostAudioPaEnumerate(pThis, PULSEAUDIOENUMCBFLAGS_DEFAULT_ONLY \| PULSEAUDIOENUMCBFLAGS_LOG, &DeviceEnum);
661	pa_threaded_mainloop_unlock(pThis->pMainLoop);
662	AssertRCReturn(rc, rc);
663	/** @todo do stuff with DeviceEnum. */
664	PDMAudioHostEnumDelete(&DeviceEnum);
665	#else
666	RT_NOREF(pThis);
667	#endif
668	return VINF_SUCCESS;
669	}
670
671
672	/**
673	* @interface_method_impl{PDMIHOSTAUDIO,pfnGetDevices}
674	*/
675	static DECLCALLBACK(int) drvHostAudioPaHA_GetDevices(PPDMIHOSTAUDIO pInterface, PPDMAUDIOHOSTENUM pDeviceEnum)
676	{
677	PDRVHOSTPULSEAUDIO pThis = RT_FROM_MEMBER(pInterface, DRVHOSTPULSEAUDIO, IHostAudio);
678	AssertPtrReturn(pDeviceEnum, VERR_INVALID_POINTER);
679	PDMAudioHostEnumInit(pDeviceEnum);
680
681	/* Refine it or something (currently only some LogRel2 stuff): */
682	pa_threaded_mainloop_lock(pThis->pMainLoop);
683	int rc = drvHostAudioPaEnumerate(pThis, PULSEAUDIOENUMCBFLAGS_NONE, pDeviceEnum);
684	pa_threaded_mainloop_unlock(pThis->pMainLoop);
685	return rc;
686	}
687
688
689	/**
690	* @interface_method_impl{PDMIHOSTAUDIO,pfnGetStatus}
691	*/
692	static DECLCALLBACK(PDMAUDIOBACKENDSTS) drvHostAudioPaHA_GetStatus(PPDMIHOSTAUDIO pInterface, PDMAUDIODIR enmDir)
693	{
694	RT_NOREF(pInterface, enmDir);
695	return PDMAUDIOBACKENDSTS_RUNNING;
696	}
697
698
699	/**
700	* Stream status changed.
701	*/
702	static void drvHostAudioPaStreamStateChangedCallback(pa_stream pStream, void pvUser)
703	{
704	AssertPtrReturnVoid(pStream);
705
706	PDRVHOSTPULSEAUDIO pThis = (PDRVHOSTPULSEAUDIO)pvUser;
707	AssertPtrReturnVoid(pThis);
708
709	switch (pa_stream_get_state(pStream))
710	{
711	case PA_STREAM_READY:
712	case PA_STREAM_FAILED:
713	case PA_STREAM_TERMINATED:
714	drvHostAudioPaSignalWaiter(pThis);
715	break;
716
717	default:
718	break;
719	}
720	}
721
722	#ifdef DEBUG
723
724	/**
725	* Debug PA callback: Need data to output.
726	*/
727	static void drvHostAudioPaStreamReqWriteDebugCallback(pa_stream pStream, size_t cbLen, void pvContext)
728	{
729	RT_NOREF(cbLen, pvContext);
730	pa_usec_t cUsLatency = 0;
731	int fNegative = 0;
732	int rcPa = pa_stream_get_latency(pStream, &cUsLatency, &fNegative);
733	Log2Func(("Requesting %zu bytes; Latency: %'RU64 us%s\n",
734	cbLen, cUsLatency, rcPa == 0 ? " - pa_stream_get_latency failed!" : ""));
735	}
736
737
738	/**
739	* Debug PA callback: Underflow. This may happen when draing/corking.
740	*/
741	static void drvHostAudioPaStreamUnderflowDebugCallback(pa_stream pStream, void pvContext)
742	{
743	PPULSEAUDIOSTREAM pStrm = (PPULSEAUDIOSTREAM)pvContext;
744	AssertPtrReturnVoid(pStrm);
745
746	pStrm->cUnderflows++;
747
748	LogRel2(("PulseAudio: Warning: Hit underflow #%RU32\n", pStrm->cUnderflows));
749
750	if ( pStrm->cUnderflows >= 6 /** @todo Make this check configurable. */
751	&& pStrm->cUsLatency < 2U*RT_US_1SEC)
752	{
753	pStrm->cUsLatency = pStrm->cUsLatency * 3 / 2;
754	LogRel2(("PulseAudio: Increasing output latency to %'RU64 us\n", pStrm->cUsLatency));
755
756	pStrm->BufAttr.maxlength = pa_usec_to_bytes(pStrm->cUsLatency, &pStrm->SampleSpec);
757	pStrm->BufAttr.tlength = pa_usec_to_bytes(pStrm->cUsLatency, &pStrm->SampleSpec);
758	pa_operation *pOperation = pa_stream_set_buffer_attr(pStream, &pStrm->BufAttr, NULL, NULL);
759	if (pOperation)
760	pa_operation_unref(pOperation);
761	else
762	LogRel2(("pa_stream_set_buffer_attr failed!\n"));
763
764	pStrm->cUnderflows = 0;
765	}
766
767	pa_usec_t cUsLatency = 0;
768	int fNegative = 0;
769	pa_stream_get_latency(pStream, &cUsLatency, &fNegative);
770	LogRel2(("PulseAudio: Latency now is %'RU64 us\n", cUsLatency));
771
772	# ifdef LOG_ENABLED
773	if (LogIs2Enabled())
774	{
775	const pa_timing_info *pTInfo = pa_stream_get_timing_info(pStream);
776	AssertReturnVoid(pTInfo);
777	const pa_sample_spec *pSpec = pa_stream_get_sample_spec(pStream);
778	AssertReturnVoid(pSpec);
779	Log2Func(("writepos=%'RU64 us, readpost=%'RU64 us, age=%'RU64 us, latency=%'RU64 us (%RU32Hz %RU8ch)\n",
780	pa_bytes_to_usec(pTInfo->write_index, pSpec), pa_bytes_to_usec(pTInfo->read_index, pSpec),
781	pa_rtclock_now() - pStrm->tsStartUs, cUsLatency, pSpec->rate, pSpec->channels));
782	}
783	# endif
784	}
785
786
787	/**
788	* Debug PA callback: Overflow. This may happen when draing/corking.
789	*/
790	static void drvHostAudioPaStreamOverflowDebugCallback(pa_stream pStream, void pvContext)
791	{
792	RT_NOREF(pStream, pvContext);
793	Log2Func(("Warning: Hit overflow\n"));
794	}
795
796	#endif /* DEBUG */
797
798	/**
799	* Converts from PDM PCM properties to pulse audio format.
800	*
801	* Worker for the stream creation code.
802	*
803	* @returns PA format.
804	* @retval PA_SAMPLE_INVALID if format not supported.
805	* @param pProps The PDM audio source properties.
806	*/
807	static pa_sample_format_t drvHostAudioPaPropsToPulse(PCPDMAUDIOPCMPROPS pProps)
808	{
809	switch (PDMAudioPropsSampleSize(pProps))
810	{
811	case 1:
812	if (!PDMAudioPropsIsSigned(pProps))
813	return PA_SAMPLE_U8;
814	break;
815
816	case 2:
817	if (PDMAudioPropsIsSigned(pProps))
818	return PDMAudioPropsIsLittleEndian(pProps) ? PA_SAMPLE_S16LE : PA_SAMPLE_S16BE;
819	break;
820
821	#ifdef PA_SAMPLE_S32LE
822	case 4:
823	if (PDMAudioPropsIsSigned(pProps))
824	return PDMAudioPropsIsLittleEndian(pProps) ? PA_SAMPLE_S32LE : PA_SAMPLE_S32BE;
825	break;
826	#endif
827	}
828
829	AssertMsgFailed(("%RU8%s not supported\n", PDMAudioPropsSampleSize(pProps), PDMAudioPropsIsSigned(pProps) ? "S" : "U"));
830	return PA_SAMPLE_INVALID;
831	}
832
833
834	/**
835	* Converts from pulse audio sample specification to PDM PCM audio properties.
836	*
837	* Worker for the stream creation code.
838	*
839	* @returns VBox status code.
840	* @param pProps The PDM audio source properties.
841	* @param enmPulseFmt The PA format.
842	* @param cChannels The number of channels.
843	* @param uHz The frequency.
844	*/
845	static int drvHostAudioPaToAudioProps(PPDMAUDIOPCMPROPS pProps, pa_sample_format_t enmPulseFmt, uint8_t cChannels, uint32_t uHz)
846	{
847	AssertReturn(cChannels > 0, VERR_INVALID_PARAMETER);
848	AssertReturn(cChannels < 16, VERR_INVALID_PARAMETER);
849
850	switch (enmPulseFmt)
851	{
852	case PA_SAMPLE_U8:
853	PDMAudioPropsInit(pProps, 1 /8-bit/, false /signed/, cChannels, uHz);
854	break;
855
856	case PA_SAMPLE_S16LE:
857	PDMAudioPropsInitEx(pProps, 2 /16-bit/, true /signed/, cChannels, uHz, true /fLittleEndian/, false /fRaw/);
858	break;
859
860	case PA_SAMPLE_S16BE:
861	PDMAudioPropsInitEx(pProps, 2 /16-bit/, true /signed/, cChannels, uHz, false /fLittleEndian/, false /fRaw/);
862	break;
863
864	#ifdef PA_SAMPLE_S32LE
865	case PA_SAMPLE_S32LE:
866	PDMAudioPropsInitEx(pProps, 4 /32-bit/, true /signed/, cChannels, uHz, true /fLittleEndian/, false /fRaw/);
867	break;
868	#endif
869
870	#ifdef PA_SAMPLE_S32BE
871	case PA_SAMPLE_S32BE:
872	PDMAudioPropsInitEx(pProps, 4 /32-bit/, true /signed/, cChannels, uHz, false /fLittleEndian/, false /fRaw/);
873	break;
874	#endif
875
876	default:
877	AssertLogRelMsgFailed(("PulseAudio: Format (%d) not supported\n", enmPulseFmt));
878	return VERR_NOT_SUPPORTED;
879	}
880
881	return VINF_SUCCESS;
882	}
883
884
885	/**
886	* Worker that does the actual creation of an PA stream.
887	*
888	* @returns VBox status code.
889	* @param pThis Our driver instance data.
890	* @param pStreamPA Our stream data.
891	* @param pszName How we name the stream.
892	* @param pCfgAcq The requested stream properties, the Props member is
893	* updated upon successful return.
894	*
895	* @note Caller owns the mainloop lock.
896	*/
897	static int drvHostAudioPaStreamCreateLocked(PDRVHOSTPULSEAUDIO pThis, PPULSEAUDIOSTREAM pStreamPA,
898	const char *pszName, PPDMAUDIOSTREAMCFG pCfgAcq)
899	{
900	/*
901	* Create the stream.
902	*/
903	pa_stream pStream = pa_stream_new(pThis->pContext, pszName, &pStreamPA->SampleSpec, NULL / pa_channel_map */);
904	if (!pStream)
905	{
906	LogRel(("PulseAudio: Failed to create stream '%s': %s (%d)\n",
907	pszName, pa_strerror(pa_context_errno(pThis->pContext)), pa_context_errno(pThis->pContext)));
908	return VERR_AUDIO_STREAM_COULD_NOT_CREATE;
909	}
910
911	/*
912	* Set the state callback, and in debug builds a few more...
913	*/
914	#ifdef DEBUG
915	pa_stream_set_write_callback( pStream, drvHostAudioPaStreamReqWriteDebugCallback, pStreamPA);
916	pa_stream_set_underflow_callback( pStream, drvHostAudioPaStreamUnderflowDebugCallback, pStreamPA);
917	if (pCfgAcq->enmDir == PDMAUDIODIR_OUT)
918	pa_stream_set_overflow_callback(pStream, drvHostAudioPaStreamOverflowDebugCallback, pStreamPA);
919	#endif
920	pa_stream_set_state_callback( pStream, drvHostAudioPaStreamStateChangedCallback, pThis);
921
922	/*
923	* Connect the stream.
924	*/
925	int rc;
926	unsigned const fFlags = PA_STREAM_START_CORKED /* Require explicit starting (uncorking). */
927	/* For using pa_stream_get_latency() and pa_stream_get_time(). */
928	\| PA_STREAM_INTERPOLATE_TIMING \| PA_STREAM_AUTO_TIMING_UPDATE
929	#if PA_API_VERSION >= 12
930	\| PA_STREAM_ADJUST_LATENCY
931	#endif
932	;
933	if (pCfgAcq->enmDir == PDMAUDIODIR_IN)
934	{
935	LogFunc(("Input stream attributes: maxlength=%d fragsize=%d\n",
936	pStreamPA->BufAttr.maxlength, pStreamPA->BufAttr.fragsize));
937	rc = pa_stream_connect_record(pStream, NULL /dev/, &pStreamPA->BufAttr, (pa_stream_flags_t)fFlags);
938	}
939	else
940	{
941	LogFunc(("Output buffer attributes: maxlength=%d tlength=%d prebuf=%d minreq=%d\n",
942	pStreamPA->BufAttr.maxlength, pStreamPA->BufAttr.tlength, pStreamPA->BufAttr.prebuf, pStreamPA->BufAttr.minreq));
943	rc = pa_stream_connect_playback(pStream, NULL /dev/, &pStreamPA->BufAttr, (pa_stream_flags_t)fFlags,
944	NULL /volume/, NULL /sync_stream/);
945	}
946	if (rc >= 0)
947	{
948	/*
949	* Wait for the stream to become ready.
950	*/
951	uint64_t const nsStart = RTTimeNanoTS();
952	pa_stream_state_t enmStreamState;
953	while ( (enmStreamState = pa_stream_get_state(pStream)) != PA_STREAM_READY
954	&& PA_STREAM_IS_GOOD(enmStreamState)
955	&& RTTimeNanoTS() - nsStart < RT_NS_10SEC /* not really timed */ )
956	drvHostAudioPaMainloopWait(pThis);
957	if (enmStreamState == PA_STREAM_READY)
958	{
959	LogFunc(("Connecting stream took %'RU64 ns\n", RTTimeNanoTS() - nsStart));
960	#ifdef LOG_ENABLED
961	pStreamPA->tsStartUs = pa_rtclock_now();
962	#endif
963	/*
964	* Update the buffer attributes.
965	*/
966	const pa_buffer_attr *pBufAttribs = pa_stream_get_buffer_attr(pStream);
967	AssertPtr(pBufAttribs);
968	if (pBufAttribs)
969	{
970	pStreamPA->BufAttr = *pBufAttribs;
971	LogFunc(("Obtained %s buffer attributes: maxlength=%RU32 tlength=%RU32 prebuf=%RU32 minreq=%RU32 fragsize=%RU32\n",
972	pCfgAcq->enmDir == PDMAUDIODIR_IN ? "input" : "output", pBufAttribs->maxlength, pBufAttribs->tlength,
973	pBufAttribs->prebuf, pBufAttribs->minreq, pBufAttribs->fragsize));
974
975	/*
976	* Convert the sample spec back to PDM speak.
977	* Note! This isn't strictly speaking needed as SampleSpec has not been
978	* modified since the caller converted it from pCfgReq.
979	*/
980	rc = drvHostAudioPaToAudioProps(&pCfgAcq->Props, pStreamPA->SampleSpec.format,
981	pStreamPA->SampleSpec.channels, pStreamPA->SampleSpec.rate);
982	if (RT_SUCCESS(rc))
983	{
984	pStreamPA->pStream = pStream;
985	LogFlowFunc(("returns VINF_SUCCESS\n"));
986	return VINF_SUCCESS;
987	}
988	}
989	else
990	{
991	LogRelMax(99, ("PulseAudio: Failed to get buffer attribs for stream '%s': %s (%d)\n",
992	pszName, pa_strerror(pa_context_errno(pThis->pContext)), pa_context_errno(pThis->pContext)));
993	rc = VERR_AUDIO_STREAM_COULD_NOT_CREATE;
994	}
995	}
996	else
997	{
998	LogRelMax(99, ("PulseAudio: Failed to initialize stream '%s': state=%d, waited %'RU64 ns\n",
999	pszName, enmStreamState, RTTimeNanoTS() - nsStart));
1000	rc = VERR_AUDIO_STREAM_COULD_NOT_CREATE;
1001	}
1002	pa_stream_disconnect(pStream);
1003	}
1004	else
1005	{
1006	LogRelMax(99, ("PulseAudio: Could not connect %s stream '%s': %s (%d/%d)\n",
1007	pCfgAcq->enmDir == PDMAUDIODIR_IN ? "input" : "output",
1008	pszName, pa_strerror(pa_context_errno(pThis->pContext)), pa_context_errno(pThis->pContext), rc));
1009	rc = VERR_AUDIO_STREAM_COULD_NOT_CREATE;
1010	}
1011
1012	pa_stream_unref(pStream);
1013	Assert(RT_FAILURE_NP(rc));
1014	LogFlowFunc(("returns %Rrc\n", rc));
1015	return rc;
1016	}
1017
1018
1019	/**
1020	* @interface_method_impl{PDMIHOSTAUDIO,pfnStreamCreate}
1021	*/
1022	static DECLCALLBACK(int) drvHostAudioPaHA_StreamCreate(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream,
1023	PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
1024	{
1025	PDRVHOSTPULSEAUDIO pThis = RT_FROM_MEMBER(pInterface, DRVHOSTPULSEAUDIO, IHostAudio);
1026	PPULSEAUDIOSTREAM pStreamPA = (PPULSEAUDIOSTREAM)pStream;
1027	AssertPtrReturn(pStreamPA, VERR_INVALID_POINTER);
1028	AssertPtrReturn(pCfgReq, VERR_INVALID_POINTER);
1029	AssertPtrReturn(pCfgAcq, VERR_INVALID_POINTER);
1030	AssertReturn(pCfgReq->enmDir == PDMAUDIODIR_IN \|\| pCfgReq->enmDir == PDMAUDIODIR_OUT, VERR_INVALID_PARAMETER);
1031	Assert(PDMAudioStrmCfgEquals(pCfgReq, pCfgAcq));
1032	int rc;
1033
1034	/*
1035	* Prepare name, sample spec and the stream instance data.
1036	*/
1037	char szName[256];
1038	RTStrPrintf(szName, sizeof(szName), "VirtualBox %s [%s]",
1039	pCfgReq->enmDir == PDMAUDIODIR_IN
1040	? PDMAudioRecSrcGetName(pCfgReq->u.enmSrc) : PDMAudioPlaybackDstGetName(pCfgReq->u.enmDst),
1041	pThis->szStreamName);
1042
1043	pStreamPA->pDrv = pThis;
1044	pStreamPA->pDrainOp = NULL;
1045	pStreamPA->pbPeekBuf = NULL;
1046	pStreamPA->SampleSpec.rate = PDMAudioPropsHz(&pCfgReq->Props);
1047	pStreamPA->SampleSpec.channels = PDMAudioPropsChannels(&pCfgReq->Props);
1048	pStreamPA->SampleSpec.format = drvHostAudioPaPropsToPulse(&pCfgReq->Props);
1049
1050	LogFunc(("Opening '%s', rate=%dHz, channels=%d, format=%s\n", szName, pStreamPA->SampleSpec.rate,
1051	pStreamPA->SampleSpec.channels, pa_sample_format_to_string(pStreamPA->SampleSpec.format)));
1052
1053	if (pa_sample_spec_valid(&pStreamPA->SampleSpec))
1054	{
1055	/*
1056	* Set up buffer attributes according to the stream type.
1057	*
1058	* For output streams we configure pre-buffering as requested, since
1059	* there is little point in using a different size than DrvAudio. This
1060	* assumes that a 'drain' request will override the prebuf size.
1061	*/
1062	pStreamPA->BufAttr.maxlength = UINT32_MAX; /* Let the PulseAudio server choose the biggest size it can handle. */
1063	if (pCfgReq->enmDir == PDMAUDIODIR_IN)
1064	{
1065	pStreamPA->BufAttr.fragsize = PDMAudioPropsFramesToBytes(&pCfgReq->Props, pCfgReq->Backend.cFramesPeriod);
1066	LogFunc(("Requesting: BufAttr: fragsize=%RU32\n", pStreamPA->BufAttr.fragsize));
1067	/* (rlength, minreq and prebuf are playback only) */
1068	}
1069	else
1070	{
1071	pStreamPA->cUsLatency = PDMAudioPropsFramesToMicro(&pCfgReq->Props, pCfgReq->Backend.cFramesBufferSize);
1072	pStreamPA->BufAttr.tlength = pa_usec_to_bytes(pStreamPA->cUsLatency, &pStreamPA->SampleSpec);
1073	pStreamPA->BufAttr.minreq = PDMAudioPropsFramesToBytes(&pCfgReq->Props, pCfgReq->Backend.cFramesPeriod);
1074	pStreamPA->BufAttr.prebuf = pa_usec_to_bytes(PDMAudioPropsFramesToMicro(&pCfgReq->Props,
1075	pCfgReq->Backend.cFramesPreBuffering),
1076	&pStreamPA->SampleSpec);
1077	/* (fragsize is capture only) */
1078	LogRel2(("PulseAudio: Initial output latency is %RU64 us (%RU32 bytes)\n",
1079	pStreamPA->cUsLatency, pStreamPA->BufAttr.tlength));
1080	LogFunc(("Requesting: BufAttr: tlength=%RU32 maxLength=%RU32 minReq=%RU32 maxlength=-1\n",
1081	pStreamPA->BufAttr.tlength, pStreamPA->BufAttr.maxlength, pStreamPA->BufAttr.minreq));
1082	}
1083
1084	/*
1085	* Do the actual PA stream creation.
1086	*/
1087	pa_threaded_mainloop_lock(pThis->pMainLoop);
1088	rc = drvHostAudioPaStreamCreateLocked(pThis, pStreamPA, szName, pCfgAcq);
1089	pa_threaded_mainloop_unlock(pThis->pMainLoop);
1090	if (RT_SUCCESS(rc))
1091	{
1092	/*
1093	* Set the acquired stream config according to the actual buffer
1094	* attributes we got and the stream type.
1095	*/
1096	if (pCfgReq->enmDir == PDMAUDIODIR_IN)
1097	{
1098	pCfgAcq->Backend.cFramesPeriod = PDMAudioPropsBytesToFrames(&pCfgAcq->Props, pStreamPA->BufAttr.fragsize);
1099	pCfgAcq->Backend.cFramesBufferSize = pStreamPA->BufAttr.maxlength != UINT32_MAX /* paranoia */
1100	? PDMAudioPropsBytesToFrames(&pCfgAcq->Props, pStreamPA->BufAttr.maxlength)
1101	: pCfgAcq->Backend.cFramesPeriod * 2 /* whatever */;
1102	pCfgAcq->Backend.cFramesPreBuffering = pCfgAcq->Backend.cFramesPeriod;
1103	}
1104	else
1105	{
1106	pCfgAcq->Backend.cFramesPeriod = PDMAudioPropsBytesToFrames(&pCfgAcq->Props, pStreamPA->BufAttr.minreq);
1107	pCfgAcq->Backend.cFramesBufferSize = PDMAudioPropsBytesToFrames(&pCfgAcq->Props, pStreamPA->BufAttr.tlength);
1108	pCfgAcq->Backend.cFramesPreBuffering = pCfgReq->Backend.cFramesPreBuffering
1109	* pCfgAcq->Backend.cFramesBufferSize
1110	/ RT_MAX(pCfgReq->Backend.cFramesBufferSize, 1);
1111	}
1112	PDMAudioStrmCfgCopy(&pStreamPA->Cfg, pCfgAcq);
1113	}
1114	}
1115	else
1116	{
1117	LogRel(("PulseAudio: Unsupported sample specification for stream '%s'\n", szName));
1118	rc = VERR_AUDIO_STREAM_COULD_NOT_CREATE;
1119	}
1120
1121	LogFlowFuncLeaveRC(rc);
1122	return rc;
1123	}
1124
1125	/**
1126	* Cancel and release any pending stream requests (drain and cork/uncork).
1127	*
1128	* @note Caller has locked the mainloop.
1129	*/
1130	static void drvHostAudioPaStreamCancelAndReleaseOperations(PPULSEAUDIOSTREAM pStreamPA)
1131	{
1132	if (pStreamPA->pDrainOp)
1133	{
1134	LogFlowFunc(("drain operation (%p) status: %d\n", pStreamPA->pDrainOp, pa_operation_get_state(pStreamPA->pDrainOp)));
1135	pa_operation_cancel(pStreamPA->pDrainOp);
1136	pa_operation_unref(pStreamPA->pDrainOp);
1137	pStreamPA->pDrainOp = NULL;
1138	}
1139
1140	if (pStreamPA->pCorkOp)
1141	{
1142	LogFlowFunc(("cork operation (%p) status: %d\n", pStreamPA->pCorkOp, pa_operation_get_state(pStreamPA->pCorkOp)));
1143	pa_operation_cancel(pStreamPA->pCorkOp);
1144	pa_operation_unref(pStreamPA->pCorkOp);
1145	pStreamPA->pCorkOp = NULL;
1146	}
1147
1148	if (pStreamPA->pTriggerOp)
1149	{
1150	LogFlowFunc(("trigger operation (%p) status: %d\n", pStreamPA->pTriggerOp, pa_operation_get_state(pStreamPA->pTriggerOp)));
1151	pa_operation_cancel(pStreamPA->pTriggerOp);
1152	pa_operation_unref(pStreamPA->pTriggerOp);
1153	pStreamPA->pTriggerOp = NULL;
1154	}
1155	}
1156
1157
1158	/**
1159	* @interface_method_impl{PDMIHOSTAUDIO,pfnStreamDestroy}
1160	*/
1161	static DECLCALLBACK(int) drvHostAudioPaHA_StreamDestroy(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
1162	{
1163	PDRVHOSTPULSEAUDIO pThis = RT_FROM_MEMBER(pInterface, DRVHOSTPULSEAUDIO, IHostAudio);
1164	PPULSEAUDIOSTREAM pStreamPA = (PPULSEAUDIOSTREAM)pStream;
1165	AssertPtrReturn(pStreamPA, VERR_INVALID_POINTER);
1166
1167	if (pStreamPA->pStream)
1168	{
1169	pa_threaded_mainloop_lock(pThis->pMainLoop);
1170
1171	drvHostAudioPaStreamCancelAndReleaseOperations(pStreamPA);
1172	pa_stream_disconnect(pStreamPA->pStream);
1173
1174	pa_stream_unref(pStreamPA->pStream);
1175	pStreamPA->pStream = NULL;
1176
1177	pa_threaded_mainloop_unlock(pThis->pMainLoop);
1178	}
1179
1180	return VINF_SUCCESS;
1181	}
1182
1183
1184	/**
1185	* Common worker for the cork/uncork completion callbacks.
1186	* @note This is fully async, so nobody is waiting for this.
1187	*/
1188	static void drvHostAudioPaStreamCorkUncorkCommon(PPULSEAUDIOSTREAM pStreamPA, int fSuccess, const char *pszOperation)
1189	{
1190	AssertPtrReturnVoid(pStreamPA);
1191	LogFlowFunc(("%s '%s': fSuccess=%RTbool\n", pszOperation, pStreamPA->Cfg.szName, fSuccess));
1192
1193	if (!fSuccess)
1194	drvHostAudioPaError(pStreamPA->pDrv, "%s stream '%s' failed", pszOperation, pStreamPA->Cfg.szName);
1195
1196	if (pStreamPA->pCorkOp)
1197	{
1198	pa_operation_unref(pStreamPA->pCorkOp);
1199	pStreamPA->pCorkOp = NULL;
1200	}
1201	}
1202
1203
1204	/**
1205	* Completion callback used with pa_stream_cork(,false,).
1206	*/
1207	static void drvHostAudioPaStreamUncorkCompletionCallback(pa_stream pStream, int fSuccess, void pvUser)
1208	{
1209	RT_NOREF(pStream);
1210	drvHostAudioPaStreamCorkUncorkCommon((PPULSEAUDIOSTREAM)pvUser, fSuccess, "Uncorking");
1211	}
1212
1213
1214	/**
1215	* Completion callback used with pa_stream_cork(,true,).
1216	*/
1217	static void drvHostAudioPaStreamCorkCompletionCallback(pa_stream pStream, int fSuccess, void pvUser)
1218	{
1219	RT_NOREF(pStream);
1220	drvHostAudioPaStreamCorkUncorkCommon((PPULSEAUDIOSTREAM)pvUser, fSuccess, "Corking");
1221	}
1222
1223
1224	/**
1225	* @ interface_method_impl{PDMIHOSTAUDIO,pfnStreamEnable}
1226	*/
1227	static DECLCALLBACK(int) drvHostAudioPaHA_StreamEnable(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
1228	{
1229	PDRVHOSTPULSEAUDIO pThis = RT_FROM_MEMBER(pInterface, DRVHOSTPULSEAUDIO, IHostAudio);
1230	PPULSEAUDIOSTREAM pStreamPA = (PPULSEAUDIOSTREAM)pStream;
1231	LogFlowFunc(("\n"));
1232
1233	/*
1234	* Uncork (start or resume playback/capture) the stream.
1235	*/
1236	pa_threaded_mainloop_lock(pThis->pMainLoop);
1237
1238	drvHostAudioPaStreamCancelAndReleaseOperations(pStreamPA);
1239	pStreamPA->pCorkOp = pa_stream_cork(pStreamPA->pStream, 0 /uncork it/,
1240	drvHostAudioPaStreamUncorkCompletionCallback, pStreamPA);
1241	LogFlowFunc(("Uncorking '%s': %p (async)\n", pStreamPA->Cfg.szName, pStreamPA->pCorkOp));
1242	int const rc = pStreamPA->pCorkOp ? VINF_SUCCESS
1243	: drvHostAudioPaError(pThis, "pa_stream_cork('%s', 0 /uncork it/,,) failed", pStreamPA->Cfg.szName);
1244
1245
1246	pa_threaded_mainloop_unlock(pThis->pMainLoop);
1247
1248	LogFlowFunc(("returns %Rrc\n", rc));
1249	return rc;
1250	}
1251
1252
1253	/**
1254	* @ interface_method_impl{PDMIHOSTAUDIO,pfnStreamDisable}
1255	*/
1256	static DECLCALLBACK(int) drvHostAudioPaHA_StreamDisable(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
1257	{
1258	PDRVHOSTPULSEAUDIO pThis = RT_FROM_MEMBER(pInterface, DRVHOSTPULSEAUDIO, IHostAudio);
1259	PPULSEAUDIOSTREAM pStreamPA = (PPULSEAUDIOSTREAM)pStream;
1260	LogFlowFunc(("\n"));
1261
1262	pa_threaded_mainloop_lock(pThis->pMainLoop);
1263
1264	/*
1265	* For output streams, we will ignore the request if there is a pending drain
1266	* as it will cork the stream in the end.
1267	*/
1268	if (pStreamPA->Cfg.enmDir == PDMAUDIODIR_OUT)
1269	{
1270	if (pStreamPA->pDrainOp)
1271	{
1272	pa_operation_state_t const enmOpState = pa_operation_get_state(pStreamPA->pDrainOp);
1273	if (enmOpState == PA_OPERATION_RUNNING)
1274	{
1275	LogFlowFunc(("Drain (%p) already running on '%s', skipping.\n", pStreamPA->pDrainOp, pStreamPA->Cfg.szName));
1276	pa_threaded_mainloop_unlock(pThis->pMainLoop);
1277	return VINF_SUCCESS;
1278	}
1279	LogFlowFunc(("Drain (%p) not running: %d\n", pStreamPA->pDrainOp, enmOpState));
1280	}
1281	}
1282	/*
1283	* For input stream we always cork it, but we clean up the peek buffer first.
1284	*/
1285	/** @todo r=bird: It is (probably) not technically be correct to drop the peek buffer
1286	* here when we're only pausing the stream (VM paused) as it means we'll
1287	* risk underruns when later resuming. */
1288	else if (pStreamPA->pbPeekBuf) /** @todo Do we need to drop the peek buffer?*/
1289	{
1290	pStreamPA->pbPeekBuf = NULL;
1291	pStreamPA->cbPeekBuf = 0;
1292	pa_stream_drop(pStreamPA->pStream);
1293	}
1294
1295	/*
1296	* Cork (pause playback/capture) the stream.
1297	*/
1298	drvHostAudioPaStreamCancelAndReleaseOperations(pStreamPA);
1299	pStreamPA->pCorkOp = pa_stream_cork(pStreamPA->pStream, 1 /* cork it */,
1300	drvHostAudioPaStreamCorkCompletionCallback, pStreamPA);
1301	LogFlowFunc(("Corking '%s': %p (async)\n", pStreamPA->Cfg.szName, pStreamPA->pCorkOp));
1302	int const rc = pStreamPA->pCorkOp ? VINF_SUCCESS
1303	: drvHostAudioPaError(pThis, "pa_stream_cork('%s', 1 /cork/,,) failed", pStreamPA->Cfg.szName);
1304
1305	pa_threaded_mainloop_unlock(pThis->pMainLoop);
1306	LogFlowFunc(("returns %Rrc\n", rc));
1307	return rc;
1308	}
1309
1310
1311	/**
1312	* @ interface_method_impl{PDMIHOSTAUDIO,pfnStreamPause}
1313	*/
1314	static DECLCALLBACK(int) drvHostAudioPaHA_StreamPause(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
1315	{
1316	/* Same as disable. */
1317	return drvHostAudioPaHA_StreamDisable(pInterface, pStream);
1318	}
1319
1320
1321	/**
1322	* @ interface_method_impl{PDMIHOSTAUDIO,pfnStreamResume}
1323	*/
1324	static DECLCALLBACK(int) drvHostAudioPaHA_StreamResume(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
1325	{
1326	/* Same as enable. */
1327	return drvHostAudioPaHA_StreamEnable(pInterface, pStream);
1328	}
1329
1330
1331	/**
1332	* Pulse audio pa_stream_drain() completion callback.
1333	* @note This is fully async, so nobody is waiting for this.
1334	*/
1335	static void drvHostAudioPaStreamDrainCompletionCallback(pa_stream pStream, int fSuccess, void pvUser)
1336	{
1337	PPULSEAUDIOSTREAM pStreamPA = (PPULSEAUDIOSTREAM)pvUser;
1338	AssertPtrReturnVoid(pStreamPA);
1339	Assert(pStreamPA->pStream == pStream);
1340	LogFlowFunc(("'%s': fSuccess=%RTbool\n", pStreamPA->Cfg.szName, fSuccess));
1341
1342	if (!fSuccess)
1343	drvHostAudioPaError(pStreamPA->pDrv, "Draining stream '%s' failed", pStreamPA->Cfg.szName);
1344
1345	/* Now cork the stream (doing it unconditionally atm). */
1346	if (pStreamPA->pCorkOp)
1347	{
1348	LogFlowFunc(("Cancelling & releasing cork/uncork operation %p (state: %d)\n",
1349	pStreamPA->pCorkOp, pa_operation_get_state(pStreamPA->pCorkOp)));
1350	pa_operation_cancel(pStreamPA->pCorkOp);
1351	pa_operation_unref(pStreamPA->pCorkOp);
1352	}
1353
1354	pStreamPA->pCorkOp = pa_stream_cork(pStream, 1 /* cork it*/, drvHostAudioPaStreamCorkCompletionCallback, pStreamPA);
1355	if (pStreamPA->pCorkOp)
1356	LogFlowFunc(("Started cork operation %p of %s (following drain)\n", pStreamPA->pCorkOp, pStreamPA->Cfg.szName));
1357	else
1358	drvHostAudioPaError(pStreamPA->pDrv, "pa_stream_cork failed on '%s' (following drain)", pStreamPA->Cfg.szName);
1359	}
1360
1361
1362	/**
1363	* Callback used with pa_stream_tigger(), starts draining.
1364	*/
1365	static void drvHostAudioPaStreamTriggerCompletionCallback(pa_stream pStream, int fSuccess, void pvUser)
1366	{
1367	PPULSEAUDIOSTREAM pStreamPA = (PPULSEAUDIOSTREAM)pvUser;
1368	AssertPtrReturnVoid(pStreamPA);
1369	RT_NOREF(pStream);
1370	LogFlowFunc(("'%s': fSuccess=%RTbool\n", pStreamPA->Cfg.szName, fSuccess));
1371
1372	if (!fSuccess)
1373	drvHostAudioPaError(pStreamPA->pDrv, "Forcing playback before drainig '%s' failed", pStreamPA->Cfg.szName);
1374
1375	if (pStreamPA->pTriggerOp)
1376	{
1377	pa_operation_unref(pStreamPA->pTriggerOp);
1378	pStreamPA->pTriggerOp = NULL;
1379	}
1380	}
1381
1382
1383	/**
1384	* @ interface_method_impl{PDMIHOSTAUDIO,pfnStreamDrain}
1385	*/
1386	static DECLCALLBACK(int) drvHostAudioPaHA_StreamDrain(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
1387	{
1388	PDRVHOSTPULSEAUDIO pThis = RT_FROM_MEMBER(pInterface, DRVHOSTPULSEAUDIO, IHostAudio);
1389	PPULSEAUDIOSTREAM pStreamPA = (PPULSEAUDIOSTREAM)pStream;
1390	AssertReturn(pStreamPA->Cfg.enmDir == PDMAUDIODIR_OUT, VERR_INVALID_PARAMETER);
1391	LogFlowFunc(("\n"));
1392
1393	pa_threaded_mainloop_lock(pThis->pMainLoop);
1394
1395	/*
1396	* If there is a drain running already, don't try issue another as pulse
1397	* doesn't support more than one concurrent drain per stream.
1398	*/
1399	if (pStreamPA->pDrainOp)
1400	{
1401	if (pa_operation_get_state(pStreamPA->pDrainOp) == PA_OPERATION_RUNNING)
1402	{
1403	pa_threaded_mainloop_unlock(pThis->pMainLoop);
1404	LogFlowFunc(("returns VINF_SUCCESS (drain already running)\n"));
1405	return VINF_SUCCESS;
1406	}
1407	LogFlowFunc(("Releasing drain operation %p (state: %d)\n", pStreamPA->pDrainOp, pa_operation_get_state(pStreamPA->pDrainOp)));
1408	pa_operation_unref(pStreamPA->pDrainOp);
1409	pStreamPA->pDrainOp = NULL;
1410	}
1411
1412	/*
1413	* Make sure pre-buffered data is played before we drain it.
1414	*
1415	* ASSUMES that the async stream requests are executed in the order they're
1416	* issued here, so that we avoid waiting for the trigger request to complete.
1417	*/
1418	int rc = VINF_SUCCESS;
1419	if (true /** @todo skip this if we're already playing or haven't written any data to the stream since xxxx. */)
1420	{
1421	if (pStreamPA->pTriggerOp)
1422	{
1423	LogFlowFunc(("Cancelling & releasing trigger operation %p (state: %d)\n",
1424	pStreamPA->pTriggerOp, pa_operation_get_state(pStreamPA->pTriggerOp)));
1425	pa_operation_cancel(pStreamPA->pTriggerOp);
1426	pa_operation_unref(pStreamPA->pTriggerOp);
1427	}
1428	pStreamPA->pTriggerOp = pa_stream_trigger(pStreamPA->pStream, drvHostAudioPaStreamTriggerCompletionCallback, pStreamPA);
1429	if (pStreamPA->pTriggerOp)
1430	LogFlowFunc(("Started tigger operation %p on %s\n", pStreamPA->pTriggerOp, pStreamPA->Cfg.szName));
1431	else
1432	rc = drvHostAudioPaError(pStreamPA->pDrv, "pa_stream_trigger failed on '%s'", pStreamPA->Cfg.szName);
1433	}
1434
1435	/*
1436	* Initiate the draining (async), will cork the stream when it completes.
1437	*/
1438	pStreamPA->pDrainOp = pa_stream_drain(pStreamPA->pStream, drvHostAudioPaStreamDrainCompletionCallback, pStreamPA);
1439	if (pStreamPA->pDrainOp)
1440	LogFlowFunc(("Started drain operation %p of %s\n", pStreamPA->pDrainOp, pStreamPA->Cfg.szName));
1441	else
1442	rc = drvHostAudioPaError(pStreamPA->pDrv, "pa_stream_drain failed on '%s'", pStreamPA->Cfg.szName);
1443
1444	pa_threaded_mainloop_unlock(pThis->pMainLoop);
1445	LogFlowFunc(("returns %Rrc\n", rc));
1446	return rc;
1447	}
1448
1449
1450	/**
1451	* @interface_method_impl{PDMIHOSTAUDIO,pfnStreamControl}
1452	*/
1453	static DECLCALLBACK(int) drvHostAudioPaHA_StreamControl(PPDMIHOSTAUDIO pInterface,
1454	PPDMAUDIOBACKENDSTREAM pStream, PDMAUDIOSTREAMCMD enmStreamCmd)
1455	{
1456	/** @todo r=bird: I'd like to get rid of this pfnStreamControl method,
1457	* replacing it with individual StreamXxxx methods. That would save us
1458	* potentally huge switches and more easily see which drivers implement
1459	* which operations (grep for pfnStreamXxxx). */
1460	switch (enmStreamCmd)
1461	{
1462	case PDMAUDIOSTREAMCMD_ENABLE:
1463	return drvHostAudioPaHA_StreamEnable(pInterface, pStream);
1464	case PDMAUDIOSTREAMCMD_DISABLE:
1465	return drvHostAudioPaHA_StreamDisable(pInterface, pStream);
1466	case PDMAUDIOSTREAMCMD_PAUSE:
1467	return drvHostAudioPaHA_StreamPause(pInterface, pStream);
1468	case PDMAUDIOSTREAMCMD_RESUME:
1469	return drvHostAudioPaHA_StreamResume(pInterface, pStream);
1470	case PDMAUDIOSTREAMCMD_DRAIN:
1471	return drvHostAudioPaHA_StreamDrain(pInterface, pStream);
1472
1473	case PDMAUDIOSTREAMCMD_END:
1474	case PDMAUDIOSTREAMCMD_32BIT_HACK:
1475	case PDMAUDIOSTREAMCMD_INVALID:
1476	/* no default*/
1477	break;
1478	}
1479	return VERR_NOT_SUPPORTED;
1480	}
1481
1482
1483	/**
1484	* @interface_method_impl{PDMIHOSTAUDIO,pfnStreamGetReadable}
1485	*/
1486	static DECLCALLBACK(uint32_t) drvHostAudioPaHA_StreamGetReadable(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
1487	{
1488	PDRVHOSTPULSEAUDIO pThis = RT_FROM_MEMBER(pInterface, DRVHOSTPULSEAUDIO, IHostAudio);
1489	PPULSEAUDIOSTREAM pStreamPA = (PPULSEAUDIOSTREAM)pStream;
1490	uint32_t cbReadable = 0;
1491	if (pStreamPA->Cfg.enmDir == PDMAUDIODIR_IN)
1492	{
1493	pa_threaded_mainloop_lock(pThis->pMainLoop);
1494
1495	pa_stream_state_t const enmState = pa_stream_get_state(pStreamPA->pStream);
1496	if (PA_STREAM_IS_GOOD(enmState))
1497	{
1498	size_t cbReadablePa = pa_stream_readable_size(pStreamPA->pStream);
1499	if (cbReadablePa != (size_t)-1)
1500	cbReadable = (uint32_t)cbReadablePa;
1501	else
1502	drvHostAudioPaError(pThis, "pa_stream_readable_size failed on '%s'", pStreamPA->Cfg.szName);
1503	}
1504	else
1505	LogFunc(("non-good stream state: %d\n", enmState));
1506
1507	pa_threaded_mainloop_unlock(pThis->pMainLoop);
1508	}
1509	Log3Func(("returns %#x (%u)\n", cbReadable, cbReadable));
1510	return cbReadable;
1511	}
1512
1513
1514	/**
1515	* @interface_method_impl{PDMIHOSTAUDIO,pfnStreamGetWritable}
1516	*/
1517	static DECLCALLBACK(uint32_t) drvHostAudioPaHA_StreamGetWritable(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
1518	{
1519	PDRVHOSTPULSEAUDIO pThis = RT_FROM_MEMBER(pInterface, DRVHOSTPULSEAUDIO, IHostAudio);
1520	PPULSEAUDIOSTREAM pStreamPA = (PPULSEAUDIOSTREAM)pStream;
1521	uint32_t cbWritable = 0;
1522	if (pStreamPA->Cfg.enmDir == PDMAUDIODIR_OUT)
1523	{
1524	pa_threaded_mainloop_lock(pThis->pMainLoop);
1525
1526	pa_stream_state_t const enmState = pa_stream_get_state(pStreamPA->pStream);
1527	if (PA_STREAM_IS_GOOD(enmState))
1528	{
1529	size_t cbWritablePa = pa_stream_writable_size(pStreamPA->pStream);
1530	if (cbWritablePa != (size_t)-1)
1531	cbWritable = cbWritablePa <= UINT32_MAX ? (uint32_t)cbWritablePa : UINT32_MAX;
1532	else
1533	drvHostAudioPaError(pThis, "pa_stream_writable_size failed on '%s'", pStreamPA->Cfg.szName);
1534	}
1535	else
1536	LogFunc(("non-good stream state: %d\n", enmState));
1537
1538	pa_threaded_mainloop_unlock(pThis->pMainLoop);
1539	}
1540	Log3Func(("returns %#x (%u) [max=%#RX32 min=%#RX32]\n",
1541	cbWritable, cbWritable, pStreamPA->BufAttr.maxlength, pStreamPA->BufAttr.minreq));
1542	return cbWritable;
1543	}
1544
1545
1546	/**
1547	* @interface_method_impl{PDMIHOSTAUDIO,pfnStreamGetStatus}
1548	*/
1549	static DECLCALLBACK(PDMAUDIOSTREAMSTS) drvHostAudioPaHA_StreamGetStatus(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
1550	{
1551	PDRVHOSTPULSEAUDIO pThis = RT_FROM_MEMBER(pInterface, DRVHOSTPULSEAUDIO, IHostAudio);
1552	RT_NOREF(pStream);
1553
1554	/* Check PulseAudio's general status. */
1555	if (pThis->pContext)
1556	{
1557	pa_context_state_t const enmState = pa_context_get_state(pThis->pContext);
1558	if (PA_CONTEXT_IS_GOOD(enmState))
1559	{
1560	/** @todo should we check the actual stream state? */
1561	return PDMAUDIOSTREAMSTS_FLAGS_INITIALIZED \| PDMAUDIOSTREAMSTS_FLAGS_ENABLED;
1562	}
1563	LogFunc(("non-good context state: %d\n", enmState));
1564	}
1565	else
1566	LogFunc(("No context!\n"));
1567	return PDMAUDIOSTREAMSTS_FLAGS_NONE;
1568	}
1569
1570
1571	/**
1572	* @interface_method_impl{PDMIHOSTAUDIO,pfnStreamPlay}
1573	*/
1574	static DECLCALLBACK(int) drvHostAudioPaHA_StreamPlay(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream,
1575	const void pvBuf, uint32_t cbBuf, uint32_t pcbWritten)
1576	{
1577	PDRVHOSTPULSEAUDIO pThis = RT_FROM_MEMBER(pInterface, DRVHOSTPULSEAUDIO, IHostAudio);
1578	PPULSEAUDIOSTREAM pStreamPA = (PPULSEAUDIOSTREAM)pStream;
1579	AssertPtrReturn(pStreamPA, VERR_INVALID_POINTER);
1580	AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
1581	AssertReturn(cbBuf, VERR_INVALID_PARAMETER);
1582	AssertPtrReturn(pcbWritten, VERR_INVALID_POINTER);
1583
1584	pa_threaded_mainloop_lock(pThis->pMainLoop);
1585
1586	#ifdef LOG_ENABLED
1587	const pa_usec_t tsNowUs = pa_rtclock_now();
1588	Log3Func(("play delta: %'RU64 us; cbBuf=%#x\n", tsNowUs - pStreamPA->tsLastReadWrittenUs, cbBuf));
1589	pStreamPA->tsLastReadWrittenUs = tsNowUs;
1590	#endif
1591
1592	/*
1593	* Using a loop here so we can take maxlength into account when writing.
1594	*/
1595	int rc = VINF_SUCCESS;
1596	uint32_t cbTotalWritten = 0;
1597	uint32_t iLoop;
1598	for (iLoop = 0; ; iLoop++)
1599	{
1600	size_t const cbWriteable = pa_stream_writable_size(pStreamPA->pStream);
1601	if ( cbWriteable != (size_t)-1
1602	&& cbWriteable >= PDMAudioPropsFrameSize(&pStreamPA->Cfg.Props))
1603	{
1604	uint32_t cbToWrite = (uint32_t)RT_MIN(RT_MIN(cbWriteable, pStreamPA->BufAttr.maxlength), cbBuf);
1605	cbToWrite = PDMAudioPropsFloorBytesToFrame(&pStreamPA->Cfg.Props, cbToWrite);
1606	if (pa_stream_write(pStreamPA->pStream, pvBuf, cbToWrite, NULL /pfnFree/, 0 /offset/, PA_SEEK_RELATIVE) >= 0)
1607	{
1608	cbTotalWritten += cbToWrite;
1609	cbBuf -= cbToWrite;
1610	if (!cbBuf)
1611	break;
1612	pvBuf = (uint8_t const *)pvBuf + cbToWrite;
1613	Log3Func(("%#x left to write\n", cbBuf));
1614	}
1615	else
1616	{
1617	rc = drvHostAudioPaError(pStreamPA->pDrv, "Failed to write to output stream");
1618	break;
1619	}
1620	}
1621	else
1622	{
1623	if (cbWriteable == (size_t)-1)
1624	rc = drvHostAudioPaError(pStreamPA->pDrv, "pa_stream_writable_size failed on '%s'", pStreamPA->Cfg.szName);
1625	break;
1626	}
1627	}
1628
1629	pa_threaded_mainloop_unlock(pThis->pMainLoop);
1630
1631	*pcbWritten = cbTotalWritten;
1632	if (RT_SUCCESS(rc) \|\| cbTotalWritten == 0)
1633	{ /* likely */ }
1634	else
1635	{
1636	LogFunc(("Supressing %Rrc because we wrote %#x bytes\n", rc, cbTotalWritten));
1637	rc = VINF_SUCCESS;
1638	}
1639	Log3Func(("returns %Rrc *pcbWritten=%#x iLoop=%u\n", rc, cbTotalWritten, iLoop));
1640	return rc;
1641	}
1642
1643
1644	/**
1645	* @interface_method_impl{PDMIHOSTAUDIO,pfnStreamCapture}
1646	*/
1647	static DECLCALLBACK(int) drvHostAudioPaHA_StreamCapture(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream,
1648	void pvBuf, uint32_t cbBuf, uint32_t pcbRead)
1649	{
1650	PDRVHOSTPULSEAUDIO pThis = RT_FROM_MEMBER(pInterface, DRVHOSTPULSEAUDIO, IHostAudio);
1651	PPULSEAUDIOSTREAM pStreamPA = (PPULSEAUDIOSTREAM)pStream;
1652	AssertPtrReturn(pStreamPA, VERR_INVALID_POINTER);
1653	AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
1654	AssertReturn(cbBuf, VERR_INVALID_PARAMETER);
1655	AssertPtrReturn(pcbRead, VERR_INVALID_POINTER);
1656
1657	#ifdef LOG_ENABLED
1658	const pa_usec_t tsNowUs = pa_rtclock_now();
1659	Log3Func(("capture delta: %'RU64 us; cbBuf=%#x\n", tsNowUs - pStreamPA->tsLastReadWrittenUs, cbBuf));
1660	pStreamPA->tsLastReadWrittenUs = tsNowUs;
1661	#endif
1662
1663	/*
1664	* If we have left over peek buffer space from the last call,
1665	* copy out the data from there.
1666	*/
1667	uint32_t cbTotalRead = 0;
1668	if ( pStreamPA->pbPeekBuf
1669	&& pStreamPA->offPeekBuf < pStreamPA->cbPeekBuf)
1670	{
1671	uint32_t cbToCopy = pStreamPA->cbPeekBuf - pStreamPA->offPeekBuf;
1672	if (cbToCopy >= cbBuf)
1673	{
1674	memcpy(pvBuf, &pStreamPA->pbPeekBuf[pStreamPA->offPeekBuf], cbBuf);
1675	pStreamPA->offPeekBuf += cbBuf;
1676	*pcbRead = cbBuf;
1677	if (cbToCopy == cbBuf)
1678	{
1679	pa_threaded_mainloop_lock(pThis->pMainLoop);
1680	pStreamPA->pbPeekBuf = NULL;
1681	pStreamPA->cbPeekBuf = 0;
1682	pa_stream_drop(pStreamPA->pStream);
1683	pa_threaded_mainloop_unlock(pThis->pMainLoop);
1684	}
1685	Log3Func(("returns *pcbRead=%#x from prev peek buf (%#x/%#x)\n", cbBuf, pStreamPA->offPeekBuf, pStreamPA->cbPeekBuf));
1686	return VINF_SUCCESS;
1687	}
1688
1689	memcpy(pvBuf, &pStreamPA->pbPeekBuf[pStreamPA->offPeekBuf], cbToCopy);
1690	cbBuf -= cbToCopy;
1691	pvBuf = (uint8_t *)pvBuf + cbToCopy;
1692	cbTotalRead += cbToCopy;
1693	pStreamPA->offPeekBuf = pStreamPA->cbPeekBuf;
1694	}
1695
1696	/*
1697	* Copy out what we can.
1698	*/
1699	int rc = VINF_SUCCESS;
1700	pa_threaded_mainloop_lock(pThis->pMainLoop);
1701	while (cbBuf > 0)
1702	{
1703	/*
1704	* Drop the old peek buffer first, if we have one.
1705	*/
1706	if (pStreamPA->pbPeekBuf)
1707	{
1708	Assert(pStreamPA->offPeekBuf >= pStreamPA->cbPeekBuf);
1709	pStreamPA->pbPeekBuf = NULL;
1710	pStreamPA->cbPeekBuf = 0;
1711	pa_stream_drop(pStreamPA->pStream);
1712	}
1713
1714	/*
1715	* Check if there is anything to read, the get the peek buffer for it.
1716	*/
1717	size_t cbAvail = pa_stream_readable_size(pStreamPA->pStream);
1718	if (cbAvail > 0 && cbAvail != (size_t)-1)
1719	{
1720	pStreamPA->pbPeekBuf = NULL;
1721	pStreamPA->cbPeekBuf = 0;
1722	int rcPa = pa_stream_peek(pStreamPA->pStream, (const void **)&pStreamPA->pbPeekBuf, &pStreamPA->cbPeekBuf);
1723	if (rcPa == 0)
1724	{
1725	if (pStreamPA->cbPeekBuf)
1726	{
1727	if (pStreamPA->pbPeekBuf)
1728	{
1729	/*
1730	* We got data back. Copy it into the return buffer, return if it's full.
1731	*/
1732	if (cbBuf < pStreamPA->cbPeekBuf)
1733	{
1734	memcpy(pvBuf, pStreamPA->pbPeekBuf, cbBuf);
1735	cbTotalRead += cbBuf;
1736	pStreamPA->offPeekBuf = cbBuf;
1737	cbBuf = 0;
1738	break;
1739	}
1740	memcpy(pvBuf, pStreamPA->pbPeekBuf, pStreamPA->cbPeekBuf);
1741	cbBuf -= pStreamPA->cbPeekBuf;
1742	pvBuf = (uint8_t *)pvBuf + pStreamPA->cbPeekBuf;
1743	cbTotalRead += pStreamPA->cbPeekBuf;
1744
1745	pStreamPA->pbPeekBuf = NULL;
1746	}
1747	else
1748	{
1749	/*
1750	* We got a hole (drop needed). We will skip it as we leave it to
1751	* the device's DMA engine to fill in buffer gaps with silence.
1752	*/
1753	LogFunc(("pa_stream_peek returned a %#zx (%zu) byte hole - skipping.\n",
1754	pStreamPA->cbPeekBuf, pStreamPA->cbPeekBuf));
1755	}
1756	pStreamPA->cbPeekBuf = 0;
1757	pa_stream_drop(pStreamPA->pStream);
1758	}
1759	else
1760	{
1761	Assert(!pStreamPA->pbPeekBuf);
1762	LogFunc(("pa_stream_peek returned empty buffer\n"));
1763	break;
1764	}
1765	}
1766	else
1767	{
1768	rc = drvHostAudioPaError(pStreamPA->pDrv, "pa_stream_peek failed on '%s' (%d)", pStreamPA->Cfg.szName, rcPa);
1769	pStreamPA->pbPeekBuf = NULL;
1770	pStreamPA->cbPeekBuf = 0;
1771	break;
1772	}
1773	}
1774	else
1775	{
1776	if (cbAvail != (size_t)-1)
1777	rc = drvHostAudioPaError(pStreamPA->pDrv, "pa_stream_readable_size failed on '%s'", pStreamPA->Cfg.szName);
1778	break;
1779	}
1780	}
1781	pa_threaded_mainloop_unlock(pThis->pMainLoop);
1782
1783	*pcbRead = cbTotalRead;
1784	if (RT_SUCCESS(rc) \|\| cbTotalRead == 0)
1785	{ /* likely */ }
1786	else
1787	{
1788	LogFunc(("Supressing %Rrc because we're returning %#x bytes\n", rc, cbTotalRead));
1789	rc = VINF_SUCCESS;
1790	}
1791	Log3Func(("returns %Rrc *pcbRead=%#x (%#x left, peek %#x/%#x)\n",
1792	rc, cbTotalRead, cbBuf, pStreamPA->offPeekBuf, pStreamPA->cbPeekBuf));
1793	return rc;
1794	}
1795
1796
1797	/*********************************************************************************************************************************
1798	* PDMIBASE *
1799	*********************************************************************************************************************************/
1800
1801	/**
1802	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
1803	*/
1804	static DECLCALLBACK(void ) drvHostAudioPaQueryInterface(PPDMIBASE pInterface, const char pszIID)
1805	{
1806	AssertPtrReturn(pInterface, NULL);
1807	AssertPtrReturn(pszIID, NULL);
1808
1809	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
1810	PDRVHOSTPULSEAUDIO pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTPULSEAUDIO);
1811	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
1812	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIHOSTAUDIO, &pThis->IHostAudio);
1813
1814	return NULL;
1815	}
1816
1817
1818	/*********************************************************************************************************************************
1819	* PDMDRVREG *
1820	*********************************************************************************************************************************/
1821
1822	/**
1823	* @interface_method_impl{PDMDRVREG,pfnPowerOff}
1824	*/
1825	static DECLCALLBACK(void) drvHostAudioPaPowerOff(PPDMDRVINS pDrvIns)
1826	{
1827	PDRVHOSTPULSEAUDIO pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTPULSEAUDIO);
1828	LogFlowFuncEnter();
1829
1830	if (pThis->pMainLoop)
1831	pa_threaded_mainloop_stop(pThis->pMainLoop);
1832
1833	if (pThis->pContext)
1834	{
1835	pa_context_disconnect(pThis->pContext);
1836	pa_context_unref(pThis->pContext);
1837	pThis->pContext = NULL;
1838	}
1839
1840	if (pThis->pMainLoop)
1841	{
1842	pa_threaded_mainloop_free(pThis->pMainLoop);
1843	pThis->pMainLoop = NULL;
1844	}
1845
1846	LogFlowFuncLeave();
1847	}
1848
1849
1850	/**
1851	* Destructs a PulseAudio Audio driver instance.
1852	*
1853	* @copydoc FNPDMDRVDESTRUCT
1854	*/
1855	static DECLCALLBACK(void) drvHostAudioPaDestruct(PPDMDRVINS pDrvIns)
1856	{
1857	PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
1858	LogFlowFuncEnter();
1859	drvHostAudioPaPowerOff(pDrvIns);
1860	LogFlowFuncLeave();
1861	}
1862
1863
1864	/**
1865	* Pulse audio callback for context status changes, init variant.
1866	*
1867	* Signalls our event semaphore so we can do a timed wait from
1868	* drvHostAudioPaConstruct().
1869	*/
1870	static void drvHostAudioPaCtxCallbackStateChangedInit(pa_context pCtx, void pvUser)
1871	{
1872	AssertPtrReturnVoid(pCtx);
1873	PPULSEAUDIOSTATECHGCTX pStateChgCtx = (PPULSEAUDIOSTATECHGCTX)pvUser;
1874	pa_context_state_t enmCtxState = pa_context_get_state(pCtx);
1875	switch (enmCtxState)
1876	{
1877	case PA_CONTEXT_READY:
1878	case PA_CONTEXT_TERMINATED:
1879	case PA_CONTEXT_FAILED:
1880	AssertPtrReturnVoid(pStateChgCtx);
1881	pStateChgCtx->enmCtxState = enmCtxState;
1882	RTSemEventSignal(pStateChgCtx->hEvtInit);
1883	break;
1884
1885	default:
1886	break;
1887	}
1888	}
1889
1890
1891	/**
1892	* Constructs a PulseAudio Audio driver instance.
1893	*
1894	* @copydoc FNPDMDRVCONSTRUCT
1895	*/
1896	static DECLCALLBACK(int) drvHostAudioPaConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
1897	{
1898	RT_NOREF(pCfg, fFlags);
1899	PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
1900	AssertPtrReturn(pDrvIns, VERR_INVALID_POINTER);
1901
1902	PDRVHOSTPULSEAUDIO pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTPULSEAUDIO);
1903	LogRel(("Audio: Initializing PulseAudio driver\n"));
1904
1905	/*
1906	* Initialize instance data.
1907	*/
1908	pThis->pDrvIns = pDrvIns;
1909	/* IBase */
1910	pDrvIns->IBase.pfnQueryInterface = drvHostAudioPaQueryInterface;
1911	/* IHostAudio */
1912	pThis->IHostAudio.pfnGetConfig = drvHostAudioPaHA_GetConfig;
1913	pThis->IHostAudio.pfnGetDevices = drvHostAudioPaHA_GetDevices;
1914	pThis->IHostAudio.pfnGetStatus = drvHostAudioPaHA_GetStatus;
1915	pThis->IHostAudio.pfnStreamCreate = drvHostAudioPaHA_StreamCreate;
1916	pThis->IHostAudio.pfnStreamDestroy = drvHostAudioPaHA_StreamDestroy;
1917	pThis->IHostAudio.pfnStreamControl = drvHostAudioPaHA_StreamControl;
1918	pThis->IHostAudio.pfnStreamGetReadable = drvHostAudioPaHA_StreamGetReadable;
1919	pThis->IHostAudio.pfnStreamGetWritable = drvHostAudioPaHA_StreamGetWritable;
1920	pThis->IHostAudio.pfnStreamGetPending = NULL;
1921	pThis->IHostAudio.pfnStreamGetStatus = drvHostAudioPaHA_StreamGetStatus;
1922	pThis->IHostAudio.pfnStreamPlay = drvHostAudioPaHA_StreamPlay;
1923	pThis->IHostAudio.pfnStreamCapture = drvHostAudioPaHA_StreamCapture;
1924
1925	/*
1926	* Read configuration.
1927	*/
1928	int rc2 = CFGMR3QueryString(pCfg, "StreamName", pThis->szStreamName, sizeof(pThis->szStreamName));
1929	AssertMsgRCReturn(rc2, ("Confguration error: No/bad \"StreamName\" value, rc=%Rrc\n", rc2), rc2);
1930
1931	/*
1932	* Load the pulse audio library.
1933	*/
1934	int rc = audioLoadPulseLib();
1935	if (RT_SUCCESS(rc))
1936	LogRel(("PulseAudio: Using version %s\n", pa_get_library_version()));
1937	else
1938	{
1939	LogRel(("PulseAudio: Failed to load the PulseAudio shared library! Error %Rrc\n", rc));
1940	return rc;
1941	}
1942
1943	/*
1944	* Set up the basic pulse audio bits (remember the destructore is always called).
1945	*/
1946	//pThis->fAbortLoop = false;
1947	pThis->pMainLoop = pa_threaded_mainloop_new();
1948	if (!pThis->pMainLoop)
1949	{
1950	LogRel(("PulseAudio: Failed to allocate main loop: %s\n", pa_strerror(pa_context_errno(pThis->pContext))));
1951	return VERR_NO_MEMORY;
1952	}
1953
1954	pThis->pContext = pa_context_new(pa_threaded_mainloop_get_api(pThis->pMainLoop), "VirtualBox");
1955	if (!pThis->pContext)
1956	{
1957	LogRel(("PulseAudio: Failed to allocate context: %s\n", pa_strerror(pa_context_errno(pThis->pContext))));
1958	return VERR_NO_MEMORY;
1959	}
1960
1961	if (pa_threaded_mainloop_start(pThis->pMainLoop) < 0)
1962	{
1963	LogRel(("PulseAudio: Failed to start threaded mainloop: %s\n", pa_strerror(pa_context_errno(pThis->pContext))));
1964	return VERR_AUDIO_BACKEND_INIT_FAILED;
1965	}
1966
1967	/*
1968	* Connect to the pulse audio server.
1969	*
1970	* We install an init state callback so we can do a timed wait in case
1971	* connecting to the pulseaudio server should take too long.
1972	*/
1973	pThis->InitStateChgCtx.hEvtInit = NIL_RTSEMEVENT;
1974	pThis->InitStateChgCtx.enmCtxState = PA_CONTEXT_UNCONNECTED;
1975	rc = RTSemEventCreate(&pThis->InitStateChgCtx.hEvtInit);
1976	AssertLogRelRCReturn(rc, rc);
1977
1978	pa_threaded_mainloop_lock(pThis->pMainLoop);
1979	pa_context_set_state_callback(pThis->pContext, drvHostAudioPaCtxCallbackStateChangedInit, &pThis->InitStateChgCtx);
1980	if (!pa_context_connect(pThis->pContext, NULL /* pszServer */, PA_CONTEXT_NOFLAGS, NULL))
1981	{
1982	pa_threaded_mainloop_unlock(pThis->pMainLoop);
1983
1984	rc = RTSemEventWait(pThis->InitStateChgCtx.hEvtInit, RT_MS_10SEC); /* 10 seconds should be plenty. */
1985	if (RT_SUCCESS(rc))
1986	{
1987	if (pThis->InitStateChgCtx.enmCtxState == PA_CONTEXT_READY)
1988	{
1989	/* Install the main state changed callback to know if something happens to our acquired context. */
1990	pa_threaded_mainloop_lock(pThis->pMainLoop);
1991	pa_context_set_state_callback(pThis->pContext, drvHostAudioPaCtxCallbackStateChanged, pThis /* pvUserData */);
1992	pa_threaded_mainloop_unlock(pThis->pMainLoop);
1993	}
1994	else
1995	{
1996	LogRel(("PulseAudio: Failed to initialize context (state %d, rc=%Rrc)\n", pThis->InitStateChgCtx.enmCtxState, rc));
1997	rc = VERR_AUDIO_BACKEND_INIT_FAILED;
1998	}
1999	}
2000	else
2001	{
2002	LogRel(("PulseAudio: Waiting for context to become ready failed: %Rrc\n", rc));
2003	rc = VERR_AUDIO_BACKEND_INIT_FAILED;
2004	}
2005	}
2006	else
2007	{
2008	pa_threaded_mainloop_unlock(pThis->pMainLoop);
2009	LogRel(("PulseAudio: Failed to connect to server: %s\n", pa_strerror(pa_context_errno(pThis->pContext))));
2010	rc = VERR_AUDIO_BACKEND_INIT_FAILED; /* bird: This used to be VINF_SUCCESS. */
2011	}
2012
2013	RTSemEventDestroy(pThis->InitStateChgCtx.hEvtInit);
2014	pThis->InitStateChgCtx.hEvtInit = NIL_RTSEMEVENT;
2015
2016	return rc;
2017	}
2018
2019
2020	/**
2021	* Pulse audio driver registration record.
2022	*/
2023	const PDMDRVREG g_DrvHostPulseAudio =
2024	{
2025	/* u32Version */
2026	PDM_DRVREG_VERSION,
2027	/* szName */
2028	"PulseAudio",
2029	/* szRCMod */
2030	"",
2031	/* szR0Mod */
2032	"",
2033	/* pszDescription */
2034	"Pulse Audio host driver",
2035	/* fFlags */
2036	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
2037	/* fClass. */
2038	PDM_DRVREG_CLASS_AUDIO,
2039	/* cMaxInstances */
2040	~0U,
2041	/* cbInstance */
2042	sizeof(DRVHOSTPULSEAUDIO),
2043	/* pfnConstruct */
2044	drvHostAudioPaConstruct,
2045	/* pfnDestruct */
2046	drvHostAudioPaDestruct,
2047	/* pfnRelocate */
2048	NULL,
2049	/* pfnIOCtl */
2050	NULL,
2051	/* pfnPowerOn */
2052	NULL,
2053	/* pfnReset */
2054	NULL,
2055	/* pfnSuspend */
2056	NULL,
2057	/* pfnResume */
2058	NULL,
2059	/* pfnAttach */
2060	NULL,
2061	/* pfnDetach */
2062	NULL,
2063	/* pfnPowerOff */
2064	drvHostAudioPaPowerOff,
2065	/* pfnSoftReset */
2066	NULL,
2067	/* u32EndVersion */
2068	PDM_DRVREG_VERSION
2069	};
2070

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

source: vbox/trunk/src/VBox/Devices/Audio/DrvHostAudioPulseAudio.cpp@ 88534

Download in other formats: