DrvHostPulseAudio.cpp@ 87875

Last change on this file since 87875 was 85570, checked in by vboxsync, 4 years ago
DrvHostPulseAudio.cpp: put the mainloop creatation outside the silly while-not-a-goto loop. bugref:8666
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 57.9 KB

Line
1	/* $Id: DrvHostPulseAudio.cpp 85570 2020-07-30 20:26:54Z vboxsync $ */
2	/** @file
3	* VBox audio devices: Pulse Audio audio driver.
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
26	#include <stdio.h>
27
28	#include <iprt/alloc.h>
29	#include <iprt/mem.h>
30	#include <iprt/uuid.h>
31	#include <iprt/semaphore.h>
32
33	RT_C_DECLS_BEGIN
34	#include "pulse_mangling.h"
35	#include "pulse_stubs.h"
36	RT_C_DECLS_END
37
38	#include <pulse/pulseaudio.h>
39
40	#include "DrvAudio.h"
41	#include "VBoxDD.h"
42
43
44	/*********************************************************************************************************************************
45	* Defines *
46	*********************************************************************************************************************************/
47	#define VBOX_PULSEAUDIO_MAX_LOG_REL_ERRORS 32 /** @todo Make this configurable thru driver options. */
48
49	#ifndef PA_STREAM_NOFLAGS
50	# define PA_STREAM_NOFLAGS (pa_context_flags_t)0x0000U /* since 0.9.19 */
51	#endif
52
53	#ifndef PA_CONTEXT_NOFLAGS
54	# define PA_CONTEXT_NOFLAGS (pa_context_flags_t)0x0000U /* since 0.9.19 */
55	#endif
56
57	/** No flags specified. */
58	#define PULSEAUDIOENUMCBFLAGS_NONE 0
59	/** (Release) log found devices. */
60	#define PULSEAUDIOENUMCBFLAGS_LOG RT_BIT(0)
61
62	/** Makes DRVHOSTPULSEAUDIO out of PDMIHOSTAUDIO. */
63	#define PDMIHOSTAUDIO_2_DRVHOSTPULSEAUDIO(pInterface) \
64	( (PDRVHOSTPULSEAUDIO)((uintptr_t)pInterface - RT_UOFFSETOF(DRVHOSTPULSEAUDIO, IHostAudio)) )
65
66
67	/*********************************************************************************************************************************
68	* Structures *
69	*********************************************************************************************************************************/
70
71	/**
72	* Host Pulse audio driver instance data.
73	* @implements PDMIAUDIOCONNECTOR
74	*/
75	typedef struct DRVHOSTPULSEAUDIO
76	{
77	/** Pointer to the driver instance structure. */
78	PPDMDRVINS pDrvIns;
79	/** Pointer to PulseAudio's threaded main loop. */
80	pa_threaded_mainloop *pMainLoop;
81	/**
82	* Pointer to our PulseAudio context.
83	* Note: We use a pMainLoop in a separate thread (pContext).
84	* So either use callback functions or protect these functions
85	* by pa_threaded_mainloop_lock() / pa_threaded_mainloop_unlock().
86	*/
87	pa_context *pContext;
88	/** Shutdown indicator. */
89	volatile bool fAbortLoop;
90	/** Enumeration operation successful? */
91	volatile bool fEnumOpSuccess;
92	/** Pointer to host audio interface. */
93	PDMIHOSTAUDIO IHostAudio;
94	/** Error count for not flooding the release log.
95	* Specify UINT32_MAX for unlimited logging. */
96	uint32_t cLogErrors;
97	/** The stream (base) name; needed for distinguishing
98	* streams in the PulseAudio mixer controls if multiple
99	* VMs are running at the same time. */
100	char szStreamName[64];
101	} DRVHOSTPULSEAUDIO, *PDRVHOSTPULSEAUDIO;
102
103	typedef struct PULSEAUDIOSTREAM
104	{
105	/** The stream's acquired configuration. */
106	PPDMAUDIOSTREAMCFG pCfg;
107	/** Pointer to driver instance. */
108	PDRVHOSTPULSEAUDIO pDrv;
109	/** Pointer to opaque PulseAudio stream. */
110	pa_stream *pStream;
111	/** Pulse sample format and attribute specification. */
112	pa_sample_spec SampleSpec;
113	/** Pulse playback and buffer metrics. */
114	pa_buffer_attr BufAttr;
115	int fOpSuccess;
116	/** Pointer to Pulse sample peeking buffer. */
117	const uint8_t *pu8PeekBuf;
118	/** Current size (in bytes) of peeking data in
119	* buffer. */
120	size_t cbPeekBuf;
121	/** Our offset (in bytes) in peeking buffer. */
122	size_t offPeekBuf;
123	pa_operation *pDrainOp;
124	/** Number of occurred audio data underflows. */
125	uint32_t cUnderflows;
126	/** Current latency (in us). */
127	uint64_t curLatencyUs;
128	#ifdef LOG_ENABLED
129	/** Start time stamp (in us) of stream playback / recording. */
130	pa_usec_t tsStartUs;
131	/** Time stamp (in us) when last read from / written to the stream. */
132	pa_usec_t tsLastReadWrittenUs;
133	#endif
134	} PULSEAUDIOSTREAM, *PPULSEAUDIOSTREAM;
135
136	/**
137	* Callback context for server enumeration callbacks.
138	*/
139	typedef struct PULSEAUDIOENUMCBCTX
140	{
141	/** Pointer to host backend driver. */
142	PDRVHOSTPULSEAUDIO pDrv;
143	/** Enumeration flags. */
144	uint32_t fFlags;
145	/** Number of found input devices. */
146	uint8_t cDevIn;
147	/** Number of found output devices. */
148	uint8_t cDevOut;
149	/** Name of default sink being used. Must be free'd using RTStrFree(). */
150	char *pszDefaultSink;
151	/** Name of default source being used. Must be free'd using RTStrFree(). */
152	char *pszDefaultSource;
153	} PULSEAUDIOENUMCBCTX, *PPULSEAUDIOENUMCBCTX;
154
155
156	/**
157	* Callback context for the server init context state changed callback.
158	*/
159	typedef struct PULSEAUDIOSTATECHGCTX
160	{
161	/** The event semaphore. */
162	RTSEMEVENT hEvtInit;
163	/** The returned context state. */
164	volatile pa_context_state_t enmCtxState;
165	} PULSEAUDIOSTATECHGCTX;
166	/** Pointer to a server init context state changed callback context. */
167	typedef PULSEAUDIOSTATECHGCTX *PPULSEAUDIOSTATECHGCTX;
168
169
170	/*
171	* To allow running on systems with PulseAudio < 0.9.11.
172	*/
173	#if !defined(PA_CONTEXT_IS_GOOD) && PA_API_VERSION < 12 /* 12 = 0.9.11 where PA_STREAM_IS_GOOD was added */
174	DECLINLINE(bool) PA_CONTEXT_IS_GOOD(pa_context_state_t enmState)
175	{
176	return enmState == PA_CONTEXT_CONNECTING
177	\|\| enmState == PA_CONTEXT_AUTHORIZING
178	\|\| enmState == PA_CONTEXT_SETTING_NAME
179	\|\| enmState == PA_CONTEXT_READY;
180	}
181	#endif
182
183	#if !defined(PA_STREAM_IS_GOOD) && PA_API_VERSION < 12 /* 12 = 0.9.11 where PA_STREAM_IS_GOOD was added */
184	DECLINLINE(bool) PA_STREAM_IS_GOOD(pa_stream_state_t enmState)
185	{
186	return enmState == PA_STREAM_CREATING
187	\|\| enmState == PA_STREAM_READY;
188	}
189	#endif
190
191
192	/*********************************************************************************************************************************
193	* Prototypes *
194	*********************************************************************************************************************************/
195
196	static int paEnumerate(PDRVHOSTPULSEAUDIO pThis, PPDMAUDIOBACKENDCFG pCfg, uint32_t fEnum);
197	static int paError(PDRVHOSTPULSEAUDIO pThis, const char *szMsg);
198	#ifdef DEBUG
199	static void paStreamCbUnderflow(pa_stream pStream, void pvContext);
200	static void paStreamCbReqWrite(pa_stream pStream, size_t cbLen, void pvContext);
201	#endif
202	static void paStreamCbSuccess(pa_stream pStream, int fSuccess, void pvContext);
203
204
205	/**
206	* Signal the main loop to abort. Just signalling isn't sufficient as the
207	* mainloop might not have been entered yet.
208	*/
209	static void paSignalWaiter(PDRVHOSTPULSEAUDIO pThis)
210	{
211	if (!pThis)
212	return;
213
214	pThis->fAbortLoop = true;
215	pa_threaded_mainloop_signal(pThis->pMainLoop, 0);
216	}
217
218
219	static pa_sample_format_t paAudioPropsToPulse(PPDMAUDIOPCMPROPS pProps)
220	{
221	switch (pProps->cbSample)
222	{
223	case 1:
224	if (!pProps->fSigned)
225	return PA_SAMPLE_U8;
226	break;
227
228	case 2:
229	if (pProps->fSigned)
230	return PA_SAMPLE_S16LE;
231	break;
232
233	#ifdef PA_SAMPLE_S32LE
234	case 4:
235	if (pProps->fSigned)
236	return PA_SAMPLE_S32LE;
237	break;
238	#endif
239
240	default:
241	break;
242	}
243
244	AssertMsgFailed(("%RU8%s not supported\n", pProps->cbSample, pProps->fSigned ? "S" : "U"));
245	return PA_SAMPLE_INVALID;
246	}
247
248
249	static int paPulseToAudioProps(pa_sample_format_t pulsefmt, PPDMAUDIOPCMPROPS pProps)
250	{
251	/** @todo r=bird: You are assuming undocumented stuff about
252	* pProps->fSwapEndian. */
253	switch (pulsefmt)
254	{
255	case PA_SAMPLE_U8:
256	pProps->cbSample = 1;
257	pProps->fSigned = false;
258	break;
259
260	case PA_SAMPLE_S16LE:
261	pProps->cbSample = 2;
262	pProps->fSigned = true;
263	break;
264
265	case PA_SAMPLE_S16BE:
266	pProps->cbSample = 2;
267	pProps->fSigned = true;
268	/** @todo Handle Endianess. */
269	break;
270
271	#ifdef PA_SAMPLE_S32LE
272	case PA_SAMPLE_S32LE:
273	pProps->cbSample = 4;
274	pProps->fSigned = true;
275	break;
276	#endif
277
278	#ifdef PA_SAMPLE_S32BE
279	case PA_SAMPLE_S32BE:
280	pProps->cbSample = 4;
281	pProps->fSigned = true;
282	/** @todo Handle Endianess. */
283	break;
284	#endif
285
286	default:
287	AssertLogRelMsgFailed(("PulseAudio: Format (%ld) not supported\n", pulsefmt));
288	return VERR_NOT_SUPPORTED;
289	}
290
291	return VINF_SUCCESS;
292	}
293
294
295	/**
296	* Synchronously wait until an operation completed.
297	*/
298	static int paWaitForEx(PDRVHOSTPULSEAUDIO pThis, pa_operation *pOP, RTMSINTERVAL cMsTimeout)
299	{
300	AssertPtrReturn(pThis, VERR_INVALID_POINTER);
301	AssertPtrReturn(pOP, VERR_INVALID_POINTER);
302
303	int rc = VINF_SUCCESS;
304
305	uint64_t u64StartMs = RTTimeMilliTS();
306	while (pa_operation_get_state(pOP) == PA_OPERATION_RUNNING)
307	{
308	if (!pThis->fAbortLoop)
309	{
310	AssertPtr(pThis->pMainLoop);
311	pa_threaded_mainloop_wait(pThis->pMainLoop);
312	if ( !pThis->pContext
313	\|\| pa_context_get_state(pThis->pContext) != PA_CONTEXT_READY)
314	{
315	LogRel(("PulseAudio: pa_context_get_state context not ready\n"));
316	break;
317	}
318	}
319	pThis->fAbortLoop = false;
320
321	uint64_t u64ElapsedMs = RTTimeMilliTS() - u64StartMs;
322	if (u64ElapsedMs >= cMsTimeout)
323	{
324	rc = VERR_TIMEOUT;
325	break;
326	}
327	}
328
329	pa_operation_unref(pOP);
330
331	return rc;
332	}
333
334
335	static int paWaitFor(PDRVHOSTPULSEAUDIO pThis, pa_operation *pOP)
336	{
337	return paWaitForEx(pThis, pOP, 10 * 1000 /* 10s timeout */);
338	}
339
340
341	/**
342	* Context status changed, init variant signalling our own event semaphore
343	* so we can do a timed wait.
344	*/
345	static void paContextCbStateChangedInit(pa_context pCtx, void pvUser)
346	{
347	AssertPtrReturnVoid(pCtx);
348
349	PPULSEAUDIOSTATECHGCTX pStateChgCtx = (PPULSEAUDIOSTATECHGCTX)pvUser;
350	pa_context_state_t enmCtxState = pa_context_get_state(pCtx);
351	switch (enmCtxState)
352	{
353	case PA_CONTEXT_READY:
354	case PA_CONTEXT_TERMINATED:
355	case PA_CONTEXT_FAILED:
356	pStateChgCtx->enmCtxState = enmCtxState;
357	RTSemEventSignal(pStateChgCtx->hEvtInit);
358	break;
359
360	default:
361	break;
362	}
363	}
364
365
366	/**
367	* Context status changed.
368	*/
369	static void paContextCbStateChanged(pa_context pCtx, void pvUser)
370	{
371	AssertPtrReturnVoid(pCtx);
372
373	PDRVHOSTPULSEAUDIO pThis = (PDRVHOSTPULSEAUDIO)pvUser;
374	AssertPtrReturnVoid(pThis);
375
376	switch (pa_context_get_state(pCtx))
377	{
378	case PA_CONTEXT_READY:
379	case PA_CONTEXT_TERMINATED:
380	case PA_CONTEXT_FAILED:
381	paSignalWaiter(pThis);
382	break;
383
384	default:
385	break;
386	}
387	}
388
389
390	/**
391	* Callback called when our pa_stream_drain operation was completed.
392	*/
393	static void paStreamCbDrain(pa_stream pStream, int fSuccess, void pvUser)
394	{
395	AssertPtrReturnVoid(pStream);
396
397	PPULSEAUDIOSTREAM pStreamPA = (PPULSEAUDIOSTREAM)pvUser;
398	AssertPtrReturnVoid(pStreamPA);
399
400	pStreamPA->fOpSuccess = fSuccess;
401	if (fSuccess)
402	{
403	pa_operation_unref(pa_stream_cork(pStream, 1,
404	paStreamCbSuccess, pvUser));
405	}
406	else
407	paError(pStreamPA->pDrv, "Failed to drain stream");
408
409	if (pStreamPA->pDrainOp)
410	{
411	pa_operation_unref(pStreamPA->pDrainOp);
412	pStreamPA->pDrainOp = NULL;
413	}
414	}
415
416
417	/**
418	* Stream status changed.
419	*/
420	static void paStreamCbStateChanged(pa_stream pStream, void pvUser)
421	{
422	AssertPtrReturnVoid(pStream);
423
424	PDRVHOSTPULSEAUDIO pThis = (PDRVHOSTPULSEAUDIO)pvUser;
425	AssertPtrReturnVoid(pThis);
426
427	switch (pa_stream_get_state(pStream))
428	{
429	case PA_STREAM_READY:
430	case PA_STREAM_FAILED:
431	case PA_STREAM_TERMINATED:
432	paSignalWaiter(pThis);
433	break;
434
435	default:
436	break;
437	}
438	}
439
440
441	#ifdef DEBUG
442	static void paStreamCbReqWrite(pa_stream pStream, size_t cbLen, void pvContext)
443	{
444	RT_NOREF(cbLen, pvContext);
445
446	PPULSEAUDIOSTREAM pStrm = (PPULSEAUDIOSTREAM)pvContext;
447	AssertPtrReturnVoid(pStrm);
448
449	pa_usec_t usec = 0;
450	int neg = 0;
451	pa_stream_get_latency(pStream, &usec, &neg);
452
453	Log2Func(("Requested %zu bytes -- Current latency is %RU64ms\n", cbLen, usec / 1000));
454	}
455
456
457	static void paStreamCbUnderflow(pa_stream pStream, void pvContext)
458	{
459	PPULSEAUDIOSTREAM pStrm = (PPULSEAUDIOSTREAM)pvContext;
460	AssertPtrReturnVoid(pStrm);
461
462	pStrm->cUnderflows++;
463
464	LogRel2(("PulseAudio: Warning: Hit underflow #%RU32\n", pStrm->cUnderflows));
465
466	if ( pStrm->cUnderflows >= 6 /** @todo Make this check configurable. */
467	&& pStrm->curLatencyUs < 2000000 /* 2s */)
468	{
469	pStrm->curLatencyUs = (pStrm->curLatencyUs * 3) / 2;
470
471	LogRel2(("PulseAudio: Output latency increased to %RU64ms\n", pStrm->curLatencyUs / 1000 /* ms */));
472
473	pStrm->BufAttr.maxlength = pa_usec_to_bytes(pStrm->curLatencyUs, &pStrm->SampleSpec);
474	pStrm->BufAttr.tlength = pa_usec_to_bytes(pStrm->curLatencyUs, &pStrm->SampleSpec);
475
476	pa_stream_set_buffer_attr(pStream, &pStrm->BufAttr, NULL, NULL);
477
478	pStrm->cUnderflows = 0;
479	}
480
481	pa_usec_t curLatencyUs = 0;
482	pa_stream_get_latency(pStream, &curLatencyUs, NULL /* Neg */);
483
484	LogRel2(("PulseAudio: Latency now is %RU64ms\n", curLatencyUs / 1000 /* ms */));
485
486	# ifdef LOG_ENABLED
487	const pa_timing_info *pTInfo = pa_stream_get_timing_info(pStream);
488	const pa_sample_spec *pSpec = pa_stream_get_sample_spec(pStream);
489
490	pa_usec_t curPosWritesUs = pa_bytes_to_usec(pTInfo->write_index, pSpec);
491	pa_usec_t curPosReadsUs = pa_bytes_to_usec(pTInfo->read_index, pSpec);
492	pa_usec_t curTsUs = pa_rtclock_now() - pStrm->tsStartUs;
493
494	Log2Func(("curPosWrite=%RU64ms, curPosRead=%RU64ms, curTs=%RU64ms, curLatency=%RU64ms (%RU32Hz, %RU8 channels)\n",
495	curPosWritesUs / RT_US_1MS_64, curPosReadsUs / RT_US_1MS_64,
496	curTsUs / RT_US_1MS_64, curLatencyUs / RT_US_1MS_64, pSpec->rate, pSpec->channels));
497	# endif
498	}
499
500
501	static void paStreamCbOverflow(pa_stream pStream, void pvContext)
502	{
503	RT_NOREF(pStream, pvContext);
504
505	Log2Func(("Warning: Hit overflow\n"));
506	}
507	#endif /* DEBUG */
508
509
510	static void paStreamCbSuccess(pa_stream pStream, int fSuccess, void pvUser)
511	{
512	AssertPtrReturnVoid(pStream);
513
514	PPULSEAUDIOSTREAM pStrm = (PPULSEAUDIOSTREAM)pvUser;
515	AssertPtrReturnVoid(pStrm);
516
517	pStrm->fOpSuccess = fSuccess;
518
519	if (fSuccess)
520	paSignalWaiter(pStrm->pDrv);
521	else
522	paError(pStrm->pDrv, "Failed to finish stream operation");
523	}
524
525
526	static int paStreamOpen(PDRVHOSTPULSEAUDIO pThis, PPULSEAUDIOSTREAM pStreamPA, bool fIn, const char *pszName)
527	{
528	AssertPtrReturn(pThis, VERR_INVALID_POINTER);
529	AssertPtrReturn(pStreamPA, VERR_INVALID_POINTER);
530	AssertPtrReturn(pszName, VERR_INVALID_POINTER);
531
532	int rc = VERR_AUDIO_STREAM_COULD_NOT_CREATE;
533	pa_stream *pStream = NULL;
534
535	pa_threaded_mainloop_lock(pThis->pMainLoop);
536
537	do /* goto avoidance non-loop */
538	{
539	pa_sample_spec *pSampleSpec = &pStreamPA->SampleSpec;
540
541	LogFunc(("Opening '%s', rate=%dHz, channels=%d, format=%s\n",
542	pszName, pSampleSpec->rate, pSampleSpec->channels,
543	pa_sample_format_to_string(pSampleSpec->format)));
544
545	if (!pa_sample_spec_valid(pSampleSpec))
546	{
547	LogRel(("PulseAudio: Unsupported sample specification for stream '%s'\n", pszName));
548	break;
549	}
550
551	pa_buffer_attr *pBufAttr = &pStreamPA->BufAttr;
552
553	/** @todo r=andy Use pa_stream_new_with_proplist instead. */
554	if (!(pStream = pa_stream_new(pThis->pContext, pszName, pSampleSpec, NULL /* pa_channel_map */)))
555	{
556	LogRel(("PulseAudio: Could not create stream '%s'\n", pszName));
557	rc = VERR_NO_MEMORY;
558	break;
559	}
560
561	#ifdef DEBUG
562	pa_stream_set_write_callback (pStream, paStreamCbReqWrite, pStreamPA);
563	pa_stream_set_underflow_callback (pStream, paStreamCbUnderflow, pStreamPA);
564	if (!fIn) /* Only for output streams. */
565	pa_stream_set_overflow_callback(pStream, paStreamCbOverflow, pStreamPA);
566	#endif
567	pa_stream_set_state_callback (pStream, paStreamCbStateChanged, pThis);
568
569	uint32_t flags = PA_STREAM_NOFLAGS;
570	#if PA_API_VERSION >= 12
571	/* XXX */
572	flags \|= PA_STREAM_ADJUST_LATENCY;
573	#endif
574	/* For using pa_stream_get_latency() and pa_stream_get_time(). */
575	flags \|= PA_STREAM_INTERPOLATE_TIMING \| PA_STREAM_AUTO_TIMING_UPDATE;
576
577	/* No input/output right away after the stream was started. */
578	flags \|= PA_STREAM_START_CORKED;
579
580	if (fIn)
581	{
582	LogFunc(("Input stream attributes: maxlength=%d fragsize=%d\n",
583	pBufAttr->maxlength, pBufAttr->fragsize));
584
585	if (pa_stream_connect_record(pStream, /dev=/NULL, pBufAttr, (pa_stream_flags_t)flags) < 0)
586	{
587	LogRel(("PulseAudio: Could not connect input stream '%s': %s\n",
588	pszName, pa_strerror(pa_context_errno(pThis->pContext))));
589	break;
590	}
591	}
592	else
593	{
594	LogFunc(("Output buffer attributes: maxlength=%d tlength=%d prebuf=%d minreq=%d\n",
595	pBufAttr->maxlength, pBufAttr->tlength, pBufAttr->prebuf, pBufAttr->minreq));
596
597	if (pa_stream_connect_playback(pStream, /dev=/NULL, pBufAttr, (pa_stream_flags_t)flags,
598	/cvolume=/NULL, /sync_stream=/NULL) < 0)
599	{
600	LogRel(("PulseAudio: Could not connect playback stream '%s': %s\n",
601	pszName, pa_strerror(pa_context_errno(pThis->pContext))));
602	break;
603	}
604	}
605
606	/* Wait until the stream is ready. */
607	pa_stream_state_t enmStreamState;
608	for (;;)
609	{
610	enmStreamState = pa_stream_get_state(pStream);
611	if ( enmStreamState == PA_STREAM_READY
612	\|\| !PA_STREAM_IS_GOOD(enmStreamState))
613	break;
614
615	if (!pThis->fAbortLoop)
616	pa_threaded_mainloop_wait(pThis->pMainLoop);
617	pThis->fAbortLoop = false;
618	}
619	if (!PA_STREAM_IS_GOOD(enmStreamState))
620	{
621	LogRel(("PulseAudio: Failed to initialize stream '%s' (state %ld)\n", pszName, enmStreamState));
622	break;
623	}
624
625	#ifdef LOG_ENABLED
626	pStreamPA->tsStartUs = pa_rtclock_now();
627	#endif
628	const pa_buffer_attr *pBufAttrObtained = pa_stream_get_buffer_attr(pStream);
629	AssertPtrBreak(pBufAttrObtained);
630	memcpy(pBufAttr, pBufAttrObtained, sizeof(pa_buffer_attr));
631
632	LogFunc(("Obtained %s buffer attributes: tLength=%RU32, maxLength=%RU32, minReq=%RU32, fragSize=%RU32, preBuf=%RU32\n",
633	fIn ? "capture" : "playback",
634	pBufAttr->tlength, pBufAttr->maxlength, pBufAttr->minreq, pBufAttr->fragsize, pBufAttr->prebuf));
635
636	pStreamPA->pStream = pStream;
637
638	pa_threaded_mainloop_unlock(pThis->pMainLoop);
639	LogFlowFuncLeaveRC(VINF_SUCCESS);
640	return rc;
641
642	} while (0);
643
644	/* We failed. */
645	if (pStream)
646	pa_stream_disconnect(pStream);
647
648	pa_threaded_mainloop_unlock(pThis->pMainLoop);
649
650	if (pStream)
651	pa_stream_unref(pStream);
652	LogFlowFuncLeaveRC(rc);
653	return rc;
654	}
655
656
657	/**
658	* @interface_method_impl{PDMIHOSTAUDIO,pfnInit}
659	*/
660	static DECLCALLBACK(int) drvHostPulseAudioHA_Init(PPDMIHOSTAUDIO pInterface)
661	{
662	AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
663
664	PDRVHOSTPULSEAUDIO pThis = PDMIHOSTAUDIO_2_DRVHOSTPULSEAUDIO(pInterface);
665
666	LogFlowFuncEnter();
667
668	int rc = audioLoadPulseLib();
669	if (RT_FAILURE(rc))
670	{
671	LogRel(("PulseAudio: Failed to load the PulseAudio shared library! Error %Rrc\n", rc));
672	return rc;
673	}
674
675	LogRel(("PulseAudio: Using v%s\n", pa_get_library_version()));
676
677	pThis->fAbortLoop = false;
678	pThis->pMainLoop = pa_threaded_mainloop_new();
679	if (!pThis->pMainLoop)
680	{
681	LogRel(("PulseAudio: Failed to allocate main loop: %s\n", pa_strerror(pa_context_errno(pThis->pContext))));
682	return VERR_NO_MEMORY;
683	}
684
685	bool fLocked = false;
686
687	do
688	{
689	if (!(pThis->pContext = pa_context_new(pa_threaded_mainloop_get_api(pThis->pMainLoop), "VirtualBox")))
690	{
691	LogRel(("PulseAudio: Failed to allocate context: %s\n",
692	pa_strerror(pa_context_errno(pThis->pContext))));
693	rc = VERR_NO_MEMORY;
694	break;
695	}
696
697	if (pa_threaded_mainloop_start(pThis->pMainLoop) < 0)
698	{
699	LogRel(("PulseAudio: Failed to start threaded mainloop: %s\n",
700	pa_strerror(pa_context_errno(pThis->pContext))));
701	rc = VERR_AUDIO_BACKEND_INIT_FAILED;
702	break;
703	}
704
705	PULSEAUDIOSTATECHGCTX InitStateChgCtx;
706	InitStateChgCtx.hEvtInit = NIL_RTSEMEVENT;
707	InitStateChgCtx.enmCtxState = PA_CONTEXT_UNCONNECTED;
708	rc = RTSemEventCreate(&InitStateChgCtx.hEvtInit);
709	if (RT_FAILURE(rc))
710	{
711	LogRel(("PulseAudio: Failed to create init event semaphore: %Rrc\n", rc));
712	break;
713	}
714
715	/*
716	* Install a dedicated init state callback so we can do a timed wait on our own event semaphore if connecting
717	* to the pulseaudio server takes too long.
718	*/
719	pa_context_set_state_callback(pThis->pContext, paContextCbStateChangedInit, &InitStateChgCtx /* pvUserData */);
720
721	pa_threaded_mainloop_lock(pThis->pMainLoop);
722	fLocked = true;
723
724	if (!pa_context_connect(pThis->pContext, NULL /* pszServer */,
725	PA_CONTEXT_NOFLAGS, NULL))
726	{
727	/* Wait on our init event semaphore and time out if connecting to the pulseaudio server takes too long. */
728	pa_threaded_mainloop_unlock(pThis->pMainLoop);
729	fLocked = false;
730
731	rc = RTSemEventWait(InitStateChgCtx.hEvtInit, RT_MS_10SEC); /* 10 seconds should be plenty. */
732	if (RT_SUCCESS(rc))
733	{
734	if (InitStateChgCtx.enmCtxState != PA_CONTEXT_READY)
735	{
736	LogRel(("PulseAudio: Failed to initialize context (state %d, rc=%Rrc)\n", InitStateChgCtx.enmCtxState, rc));
737	if (RT_SUCCESS(rc))
738	rc = VERR_AUDIO_BACKEND_INIT_FAILED;
739	}
740	else
741	{
742	pa_threaded_mainloop_lock(pThis->pMainLoop);
743	fLocked = true;
744
745	/* Install the main state changed callback to know if something happens to our acquired context. */
746	pa_context_set_state_callback(pThis->pContext, paContextCbStateChanged, pThis /* pvUserData */);
747	}
748	}
749	else
750	LogRel(("PulseAudio: Waiting for context to become ready failed with %Rrc\n", rc));
751	}
752	else
753	LogRel(("PulseAudio: Failed to connect to server: %s\n",
754	pa_strerror(pa_context_errno(pThis->pContext))));
755
756	RTSemEventDestroy(InitStateChgCtx.hEvtInit);
757	}
758	while (0);
759
760	if (fLocked)
761	pa_threaded_mainloop_unlock(pThis->pMainLoop);
762
763	if (RT_FAILURE(rc))
764	{
765	if (pThis->pMainLoop)
766	pa_threaded_mainloop_stop(pThis->pMainLoop);
767
768	if (pThis->pContext)
769	{
770	pa_context_disconnect(pThis->pContext);
771	pa_context_unref(pThis->pContext);
772	pThis->pContext = NULL;
773	}
774
775	if (pThis->pMainLoop)
776	{
777	pa_threaded_mainloop_free(pThis->pMainLoop);
778	pThis->pMainLoop = NULL;
779	}
780	}
781
782	LogFlowFuncLeaveRC(rc);
783	return rc;
784	}
785
786
787	static int paCreateStreamOut(PDRVHOSTPULSEAUDIO pThis, PPULSEAUDIOSTREAM pStreamPA,
788	PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
789	{
790	pStreamPA->pDrainOp = NULL;
791
792	pStreamPA->SampleSpec.format = paAudioPropsToPulse(&pCfgReq->Props);
793	pStreamPA->SampleSpec.rate = pCfgReq->Props.uHz;
794	pStreamPA->SampleSpec.channels = pCfgReq->Props.cChannels;
795
796	pStreamPA->curLatencyUs = DrvAudioHlpFramesToMilli(pCfgReq->Backend.cFramesBufferSize, &pCfgReq->Props) * RT_US_1MS;
797
798	const uint32_t cbLatency = pa_usec_to_bytes(pStreamPA->curLatencyUs, &pStreamPA->SampleSpec);
799
800	LogRel2(("PulseAudio: Initial output latency is %RU64ms (%RU32 bytes)\n", pStreamPA->curLatencyUs / RT_US_1MS, cbLatency));
801
802	pStreamPA->BufAttr.tlength = cbLatency;
803	pStreamPA->BufAttr.maxlength = -1; /* Let the PulseAudio server choose the biggest size it can handle. */
804	pStreamPA->BufAttr.prebuf = cbLatency;
805	pStreamPA->BufAttr.minreq = DrvAudioHlpFramesToBytes(pCfgReq->Backend.cFramesPeriod, &pCfgReq->Props);
806
807	LogFunc(("Requested: BufAttr tlength=%RU32, maxLength=%RU32, minReq=%RU32\n",
808	pStreamPA->BufAttr.tlength, pStreamPA->BufAttr.maxlength, pStreamPA->BufAttr.minreq));
809
810	Assert(pCfgReq->enmDir == PDMAUDIODIR_OUT);
811
812	char szName[256];
813	RTStrPrintf(szName, sizeof(szName), "VirtualBox %s [%s]", DrvAudioHlpPlaybackDstToStr(pCfgReq->u.enmDst), pThis->szStreamName);
814
815	/* Note that the struct BufAttr is updated to the obtained values after this call! */
816	int rc = paStreamOpen(pThis, pStreamPA, false /* fIn */, szName);
817	if (RT_FAILURE(rc))
818	return rc;
819
820	rc = paPulseToAudioProps(pStreamPA->SampleSpec.format, &pCfgAcq->Props);
821	if (RT_FAILURE(rc))
822	{
823	LogRel(("PulseAudio: Cannot find audio output format %ld\n", pStreamPA->SampleSpec.format));
824	return rc;
825	}
826
827	pCfgAcq->Props.uHz = pStreamPA->SampleSpec.rate;
828	pCfgAcq->Props.cChannels = pStreamPA->SampleSpec.channels;
829	pCfgAcq->Props.cShift = PDMAUDIOPCMPROPS_MAKE_SHIFT_PARMS(pCfgAcq->Props.cbSample, pCfgAcq->Props.cChannels);
830
831	LogFunc(("Acquired: BufAttr tlength=%RU32, maxLength=%RU32, minReq=%RU32\n",
832	pStreamPA->BufAttr.tlength, pStreamPA->BufAttr.maxlength, pStreamPA->BufAttr.minreq));
833
834	pCfgAcq->Backend.cFramesPeriod = PDMAUDIOSTREAMCFG_B2F(pCfgAcq, pStreamPA->BufAttr.minreq);
835	pCfgAcq->Backend.cFramesBufferSize = PDMAUDIOSTREAMCFG_B2F(pCfgAcq, pStreamPA->BufAttr.tlength);
836	pCfgAcq->Backend.cFramesPreBuffering = PDMAUDIOSTREAMCFG_B2F(pCfgAcq, pStreamPA->BufAttr.prebuf);
837
838	pStreamPA->pDrv = pThis;
839
840	return rc;
841	}
842
843
844	static int paCreateStreamIn(PDRVHOSTPULSEAUDIO pThis, PPULSEAUDIOSTREAM pStreamPA,
845	PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
846	{
847	pStreamPA->SampleSpec.format = paAudioPropsToPulse(&pCfgReq->Props);
848	pStreamPA->SampleSpec.rate = pCfgReq->Props.uHz;
849	pStreamPA->SampleSpec.channels = pCfgReq->Props.cChannels;
850
851	pStreamPA->BufAttr.fragsize = DrvAudioHlpFramesToBytes(pCfgReq->Backend.cFramesPeriod, &pCfgReq->Props);
852	pStreamPA->BufAttr.maxlength = -1; /* Let the PulseAudio server choose the biggest size it can handle. */
853
854	Assert(pCfgReq->enmDir == PDMAUDIODIR_IN);
855
856	char szName[256];
857	RTStrPrintf(szName, sizeof(szName), "VirtualBox %s [%s]", DrvAudioHlpRecSrcToStr(pCfgReq->u.enmSrc), pThis->szStreamName);
858
859	/* Note: Other members of BufAttr are ignored for record streams. */
860	int rc = paStreamOpen(pThis, pStreamPA, true /* fIn */, szName);
861	if (RT_FAILURE(rc))
862	return rc;
863
864	rc = paPulseToAudioProps(pStreamPA->SampleSpec.format, &pCfgAcq->Props);
865	if (RT_FAILURE(rc))
866	{
867	LogRel(("PulseAudio: Cannot find audio capture format %ld\n", pStreamPA->SampleSpec.format));
868	return rc;
869	}
870
871	pStreamPA->pDrv = pThis;
872	pStreamPA->pu8PeekBuf = NULL;
873
874	pCfgAcq->Props.uHz = pStreamPA->SampleSpec.rate;
875	pCfgAcq->Props.cChannels = pStreamPA->SampleSpec.channels;
876
877	pCfgAcq->Backend.cFramesPeriod = PDMAUDIOSTREAMCFG_B2F(pCfgAcq, pStreamPA->BufAttr.fragsize);
878	pCfgAcq->Backend.cFramesBufferSize = pCfgAcq->Backend.cFramesBufferSize;
879	pCfgAcq->Backend.cFramesPreBuffering = pCfgAcq->Backend.cFramesPeriod;
880
881	LogFlowFuncLeaveRC(rc);
882	return rc;
883	}
884
885
886	/**
887	* @interface_method_impl{PDMIHOSTAUDIO,pfnStreamCapture}
888	*/
889	static DECLCALLBACK(int) drvHostPulseAudioHA_StreamCapture(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream,
890	void pvBuf, uint32_t uBufSize, uint32_t puRead)
891	{
892	RT_NOREF(pvBuf, uBufSize);
893	AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
894	AssertPtrReturn(pStream, VERR_INVALID_POINTER);
895	AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
896	AssertReturn(uBufSize, VERR_INVALID_PARAMETER);
897	/* pcbRead is optional. */
898
899	PDRVHOSTPULSEAUDIO pThis = PDMIHOSTAUDIO_2_DRVHOSTPULSEAUDIO(pInterface);
900	PPULSEAUDIOSTREAM pStreamPA = (PPULSEAUDIOSTREAM)pStream;
901
902	/* We should only call pa_stream_readable_size() once and trust the first value. */
903	pa_threaded_mainloop_lock(pThis->pMainLoop);
904	size_t cbAvail = pa_stream_readable_size(pStreamPA->pStream);
905	pa_threaded_mainloop_unlock(pThis->pMainLoop);
906
907	if (cbAvail == (size_t)-1)
908	return paError(pStreamPA->pDrv, "Failed to determine input data size");
909
910	/* If the buffer was not dropped last call, add what remains. */
911	if (pStreamPA->pu8PeekBuf)
912	{
913	Assert(pStreamPA->cbPeekBuf >= pStreamPA->offPeekBuf);
914	cbAvail += (pStreamPA->cbPeekBuf - pStreamPA->offPeekBuf);
915	}
916
917	Log3Func(("cbAvail=%zu\n", cbAvail));
918
919	if (!cbAvail) /* No data? Bail out. */
920	{
921	if (puRead)
922	*puRead = 0;
923	return VINF_SUCCESS;
924	}
925
926	int rc = VINF_SUCCESS;
927
928	size_t cbToRead = RT_MIN(cbAvail, uBufSize);
929
930	Log3Func(("cbToRead=%zu, cbAvail=%zu, offPeekBuf=%zu, cbPeekBuf=%zu\n",
931	cbToRead, cbAvail, pStreamPA->offPeekBuf, pStreamPA->cbPeekBuf));
932
933	uint32_t cbReadTotal = 0;
934
935	while (cbToRead)
936	{
937	/* If there is no data, do another peek. */
938	if (!pStreamPA->pu8PeekBuf)
939	{
940	pa_threaded_mainloop_lock(pThis->pMainLoop);
941	pa_stream_peek(pStreamPA->pStream,
942	(const void**)&pStreamPA->pu8PeekBuf, &pStreamPA->cbPeekBuf);
943	pa_threaded_mainloop_unlock(pThis->pMainLoop);
944
945	pStreamPA->offPeekBuf = 0;
946
947	/* No data anymore?
948	* Note: If there's a data hole (cbPeekBuf then contains the length of the hole)
949	* we need to drop the stream lateron. */
950	if ( !pStreamPA->pu8PeekBuf
951	&& !pStreamPA->cbPeekBuf)
952	{
953	break;
954	}
955	}
956
957	Assert(pStreamPA->cbPeekBuf >= pStreamPA->offPeekBuf);
958	size_t cbToWrite = RT_MIN(pStreamPA->cbPeekBuf - pStreamPA->offPeekBuf, cbToRead);
959
960	Log3Func(("cbToRead=%zu, cbToWrite=%zu, offPeekBuf=%zu, cbPeekBuf=%zu, pu8PeekBuf=%p\n",
961	cbToRead, cbToWrite,
962	pStreamPA->offPeekBuf, pStreamPA->cbPeekBuf, pStreamPA->pu8PeekBuf));
963
964	if ( cbToWrite
965	/* Only copy data if it's not a data hole (see above). */
966	&& pStreamPA->pu8PeekBuf
967	&& pStreamPA->cbPeekBuf)
968	{
969	memcpy((uint8_t *)pvBuf + cbReadTotal, pStreamPA->pu8PeekBuf + pStreamPA->offPeekBuf, cbToWrite);
970
971	Assert(cbToRead >= cbToWrite);
972	cbToRead -= cbToWrite;
973	cbReadTotal += cbToWrite;
974
975	pStreamPA->offPeekBuf += cbToWrite;
976	Assert(pStreamPA->offPeekBuf <= pStreamPA->cbPeekBuf);
977	}
978
979	if (/* Nothing to write anymore? Drop the buffer. */
980	!cbToWrite
981	/* Was there a hole in the peeking buffer? Drop it. */
982	\|\| !pStreamPA->pu8PeekBuf
983	/* If the buffer is done, drop it. */
984	\|\| pStreamPA->offPeekBuf == pStreamPA->cbPeekBuf)
985	{
986	pa_threaded_mainloop_lock(pThis->pMainLoop);
987	pa_stream_drop(pStreamPA->pStream);
988	pa_threaded_mainloop_unlock(pThis->pMainLoop);
989
990	pStreamPA->pu8PeekBuf = NULL;
991	}
992	}
993
994	if (RT_SUCCESS(rc))
995	{
996	if (puRead)
997	*puRead = cbReadTotal;
998	}
999
1000	return rc;
1001	}
1002
1003
1004	/**
1005	* @interface_method_impl{PDMIHOSTAUDIO,pfnStreamPlay}
1006	*/
1007	static DECLCALLBACK(int) drvHostPulseAudioHA_StreamPlay(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream,
1008	const void pvBuf, uint32_t uBufSize, uint32_t puWritten)
1009	{
1010	AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
1011	AssertPtrReturn(pStream, VERR_INVALID_POINTER);
1012	AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
1013	AssertReturn(uBufSize, VERR_INVALID_PARAMETER);
1014	/* puWritten is optional. */
1015
1016	PDRVHOSTPULSEAUDIO pThis = PDMIHOSTAUDIO_2_DRVHOSTPULSEAUDIO(pInterface);
1017	PPULSEAUDIOSTREAM pPAStream = (PPULSEAUDIOSTREAM)pStream;
1018
1019	int rc = VINF_SUCCESS;
1020
1021	uint32_t cbWrittenTotal = 0;
1022
1023	pa_threaded_mainloop_lock(pThis->pMainLoop);
1024
1025	#ifdef LOG_ENABLED
1026	const pa_usec_t tsNowUs = pa_rtclock_now();
1027	const pa_usec_t tsDeltaPlayedUs = tsNowUs - pPAStream->tsLastReadWrittenUs;
1028
1029	Log3Func(("tsDeltaPlayedMs=%RU64\n", tsDeltaPlayedUs / 1000 /* ms */));
1030
1031	pPAStream->tsLastReadWrittenUs = tsNowUs;
1032	#endif
1033
1034	do
1035	{
1036	size_t cbWriteable = pa_stream_writable_size(pPAStream->pStream);
1037	if (cbWriteable == (size_t)-1)
1038	{
1039	rc = paError(pPAStream->pDrv, "Failed to determine output data size");
1040	break;
1041	}
1042
1043	size_t cbLeft = RT_MIN(cbWriteable, uBufSize);
1044	Assert(cbLeft); /* At this point we better have something to write. */
1045
1046	while (cbLeft)
1047	{
1048	uint32_t cbChunk = cbLeft; /* Write all at once for now. */
1049
1050	if (pa_stream_write(pPAStream->pStream, (uint8_t )pvBuf + cbWrittenTotal, cbChunk, NULL / Cleanup callback */,
1051	0, PA_SEEK_RELATIVE) < 0)
1052	{
1053	rc = paError(pPAStream->pDrv, "Failed to write to output stream");
1054	break;
1055	}
1056
1057	Assert(cbLeft >= cbChunk);
1058	cbLeft -= cbChunk;
1059	cbWrittenTotal += cbChunk;
1060	}
1061
1062	} while (0);
1063
1064	pa_threaded_mainloop_unlock(pThis->pMainLoop);
1065
1066	if (RT_SUCCESS(rc))
1067	{
1068	if (puWritten)
1069	*puWritten = cbWrittenTotal;
1070	}
1071
1072	return rc;
1073	}
1074
1075
1076	/** @todo Implement va handling. */
1077	static int paError(PDRVHOSTPULSEAUDIO pThis, const char *szMsg)
1078	{
1079	AssertPtrReturn(pThis, VERR_INVALID_POINTER);
1080	AssertPtrReturn(szMsg, VERR_INVALID_POINTER);
1081
1082	if (pThis->cLogErrors++ < VBOX_PULSEAUDIO_MAX_LOG_REL_ERRORS)
1083	{
1084	int rc2 = pa_context_errno(pThis->pContext);
1085	LogRel2(("PulseAudio: %s: %s\n", szMsg, pa_strerror(rc2)));
1086	}
1087
1088	/** @todo Implement some PulseAudio -> IPRT mapping here. */
1089	return VERR_GENERAL_FAILURE;
1090	}
1091
1092
1093	static void paEnumSinkCb(pa_context pCtx, const pa_sink_info pInfo, int eol, void *pvUserData)
1094	{
1095	if (eol > 0)
1096	return;
1097
1098	PPULSEAUDIOENUMCBCTX pCbCtx = (PPULSEAUDIOENUMCBCTX)pvUserData;
1099	AssertPtrReturnVoid(pCbCtx);
1100	PDRVHOSTPULSEAUDIO pThis = pCbCtx->pDrv;
1101	AssertPtrReturnVoid(pThis);
1102	if (eol < 0)
1103	{
1104	pThis->fEnumOpSuccess = false;
1105	pa_threaded_mainloop_signal(pCbCtx->pDrv->pMainLoop, 0);
1106	return;
1107	}
1108
1109	AssertPtrReturnVoid(pCtx);
1110	AssertPtrReturnVoid(pInfo);
1111
1112	LogRel2(("PulseAudio: Using output sink '%s'\n", pInfo->name));
1113
1114	/** @todo Store sinks + channel mapping in callback context as soon as we have surround support. */
1115	pCbCtx->cDevOut++;
1116
1117	pThis->fEnumOpSuccess = true;
1118	pa_threaded_mainloop_signal(pCbCtx->pDrv->pMainLoop, 0);
1119	}
1120
1121
1122	static void paEnumSourceCb(pa_context pCtx, const pa_source_info pInfo, int eol, void *pvUserData)
1123	{
1124	if (eol > 0)
1125	return;
1126
1127	PPULSEAUDIOENUMCBCTX pCbCtx = (PPULSEAUDIOENUMCBCTX)pvUserData;
1128	AssertPtrReturnVoid(pCbCtx);
1129	PDRVHOSTPULSEAUDIO pThis = pCbCtx->pDrv;
1130	AssertPtrReturnVoid(pThis);
1131	if (eol < 0)
1132	{
1133	pThis->fEnumOpSuccess = false;
1134	pa_threaded_mainloop_signal(pCbCtx->pDrv->pMainLoop, 0);
1135	return;
1136	}
1137
1138	AssertPtrReturnVoid(pCtx);
1139	AssertPtrReturnVoid(pInfo);
1140
1141	LogRel2(("PulseAudio: Using input source '%s'\n", pInfo->name));
1142
1143	/** @todo Store sources + channel mapping in callback context as soon as we have surround support. */
1144	pCbCtx->cDevIn++;
1145
1146	pThis->fEnumOpSuccess = true;
1147	pa_threaded_mainloop_signal(pCbCtx->pDrv->pMainLoop, 0);
1148	}
1149
1150
1151	static void paEnumServerCb(pa_context pCtx, const pa_server_info pInfo, void *pvUserData)
1152	{
1153	AssertPtrReturnVoid(pCtx);
1154	PPULSEAUDIOENUMCBCTX pCbCtx = (PPULSEAUDIOENUMCBCTX)pvUserData;
1155	AssertPtrReturnVoid(pCbCtx);
1156	PDRVHOSTPULSEAUDIO pThis = pCbCtx->pDrv;
1157	AssertPtrReturnVoid(pThis);
1158
1159	if (!pInfo)
1160	{
1161	pThis->fEnumOpSuccess = false;
1162	pa_threaded_mainloop_signal(pCbCtx->pDrv->pMainLoop, 0);
1163	return;
1164	}
1165
1166	if (pInfo->default_sink_name)
1167	{
1168	Assert(RTStrIsValidEncoding(pInfo->default_sink_name));
1169	pCbCtx->pszDefaultSink = RTStrDup(pInfo->default_sink_name);
1170	}
1171
1172	if (pInfo->default_sink_name)
1173	{
1174	Assert(RTStrIsValidEncoding(pInfo->default_source_name));
1175	pCbCtx->pszDefaultSource = RTStrDup(pInfo->default_source_name);
1176	}
1177
1178	pThis->fEnumOpSuccess = true;
1179	pa_threaded_mainloop_signal(pThis->pMainLoop, 0);
1180	}
1181
1182
1183	static int paEnumerate(PDRVHOSTPULSEAUDIO pThis, PPDMAUDIOBACKENDCFG pCfg, uint32_t fEnum)
1184	{
1185	AssertPtrReturn(pThis, VERR_INVALID_POINTER);
1186	AssertPtrReturn(pCfg, VERR_INVALID_POINTER);
1187
1188	PDMAUDIOBACKENDCFG Cfg;
1189	RT_ZERO(Cfg);
1190
1191	RTStrPrintf2(Cfg.szName, sizeof(Cfg.szName), "PulseAudio");
1192
1193	Cfg.cbStreamOut = sizeof(PULSEAUDIOSTREAM);
1194	Cfg.cbStreamIn = sizeof(PULSEAUDIOSTREAM);
1195	Cfg.cMaxStreamsOut = UINT32_MAX;
1196	Cfg.cMaxStreamsIn = UINT32_MAX;
1197
1198	PULSEAUDIOENUMCBCTX CbCtx;
1199	RT_ZERO(CbCtx);
1200
1201	CbCtx.pDrv = pThis;
1202	CbCtx.fFlags = fEnum;
1203
1204	bool fLog = (fEnum & PULSEAUDIOENUMCBFLAGS_LOG);
1205
1206	pa_threaded_mainloop_lock(pThis->pMainLoop);
1207
1208	pThis->fEnumOpSuccess = false;
1209
1210	LogRel(("PulseAudio: Retrieving server information ...\n"));
1211
1212	/* Check if server information is available and bail out early if it isn't. */
1213	pa_operation *paOpServerInfo = pa_context_get_server_info(pThis->pContext, paEnumServerCb, &CbCtx);
1214	if (!paOpServerInfo)
1215	{
1216	pa_threaded_mainloop_unlock(pThis->pMainLoop);
1217
1218	LogRel(("PulseAudio: Server information not available, skipping enumeration\n"));
1219	return VINF_SUCCESS;
1220	}
1221
1222	int rc = paWaitFor(pThis, paOpServerInfo);
1223	if (RT_SUCCESS(rc) && !pThis->fEnumOpSuccess)
1224	rc = VERR_AUDIO_BACKEND_INIT_FAILED; /* error code does not matter */
1225	if (RT_SUCCESS(rc))
1226	{
1227	if (CbCtx.pszDefaultSink)
1228	{
1229	if (fLog)
1230	LogRel2(("PulseAudio: Default output sink is '%s'\n", CbCtx.pszDefaultSink));
1231
1232	pThis->fEnumOpSuccess = false;
1233	rc = paWaitFor(pThis, pa_context_get_sink_info_by_name(pThis->pContext, CbCtx.pszDefaultSink,
1234	paEnumSinkCb, &CbCtx));
1235	if (RT_SUCCESS(rc) && !pThis->fEnumOpSuccess)
1236	rc = VERR_AUDIO_BACKEND_INIT_FAILED; /* error code does not matter */
1237	if ( RT_FAILURE(rc)
1238	&& fLog)
1239	{
1240	LogRel(("PulseAudio: Error enumerating properties for default output sink '%s'\n", CbCtx.pszDefaultSink));
1241	}
1242	}
1243	else if (fLog)
1244	LogRel2(("PulseAudio: No default output sink found\n"));
1245
1246	if (RT_SUCCESS(rc))
1247	{
1248	if (CbCtx.pszDefaultSource)
1249	{
1250	if (fLog)
1251	LogRel2(("PulseAudio: Default input source is '%s'\n", CbCtx.pszDefaultSource));
1252
1253	pThis->fEnumOpSuccess = false;
1254	rc = paWaitFor(pThis, pa_context_get_source_info_by_name(pThis->pContext, CbCtx.pszDefaultSource,
1255	paEnumSourceCb, &CbCtx));
1256	if ( (RT_FAILURE(rc) \|\| !pThis->fEnumOpSuccess)
1257	&& fLog)
1258	{
1259	LogRel(("PulseAudio: Error enumerating properties for default input source '%s'\n", CbCtx.pszDefaultSource));
1260	}
1261	}
1262	else if (fLog)
1263	LogRel2(("PulseAudio: No default input source found\n"));
1264	}
1265
1266	if (RT_SUCCESS(rc))
1267	{
1268	if (fLog)
1269	{
1270	LogRel2(("PulseAudio: Found %RU8 host playback device(s)\n", CbCtx.cDevOut));
1271	LogRel2(("PulseAudio: Found %RU8 host capturing device(s)\n", CbCtx.cDevIn));
1272	}
1273
1274	if (pCfg)
1275	memcpy(pCfg, &Cfg, sizeof(PDMAUDIOBACKENDCFG));
1276	}
1277
1278	if (CbCtx.pszDefaultSink)
1279	{
1280	RTStrFree(CbCtx.pszDefaultSink);
1281	CbCtx.pszDefaultSink = NULL;
1282	}
1283
1284	if (CbCtx.pszDefaultSource)
1285	{
1286	RTStrFree(CbCtx.pszDefaultSource);
1287	CbCtx.pszDefaultSource = NULL;
1288	}
1289	}
1290	else if (fLog)
1291	LogRel(("PulseAudio: Error enumerating PulseAudio server properties\n"));
1292
1293	pa_threaded_mainloop_unlock(pThis->pMainLoop);
1294
1295	LogFlowFuncLeaveRC(rc);
1296	return rc;
1297	}
1298
1299
1300	static int paDestroyStreamIn(PDRVHOSTPULSEAUDIO pThis, PPULSEAUDIOSTREAM pStreamPA)
1301	{
1302	LogFlowFuncEnter();
1303
1304	if (pStreamPA->pStream)
1305	{
1306	pa_threaded_mainloop_lock(pThis->pMainLoop);
1307
1308	pa_stream_disconnect(pStreamPA->pStream);
1309	pa_stream_unref(pStreamPA->pStream);
1310
1311	pStreamPA->pStream = NULL;
1312
1313	pa_threaded_mainloop_unlock(pThis->pMainLoop);
1314	}
1315
1316	return VINF_SUCCESS;
1317	}
1318
1319
1320	static int paDestroyStreamOut(PDRVHOSTPULSEAUDIO pThis, PPULSEAUDIOSTREAM pStreamPA)
1321	{
1322	if (pStreamPA->pStream)
1323	{
1324	pa_threaded_mainloop_lock(pThis->pMainLoop);
1325
1326	/* Make sure to cancel a pending draining operation, if any. */
1327	if (pStreamPA->pDrainOp)
1328	{
1329	pa_operation_cancel(pStreamPA->pDrainOp);
1330	pStreamPA->pDrainOp = NULL;
1331	}
1332
1333	pa_stream_disconnect(pStreamPA->pStream);
1334	pa_stream_unref(pStreamPA->pStream);
1335
1336	pStreamPA->pStream = NULL;
1337
1338	pa_threaded_mainloop_unlock(pThis->pMainLoop);
1339	}
1340
1341	return VINF_SUCCESS;
1342	}
1343
1344
1345	static int paControlStreamOut(PDRVHOSTPULSEAUDIO pThis, PPULSEAUDIOSTREAM pStreamPA, PDMAUDIOSTREAMCMD enmStreamCmd)
1346	{
1347	int rc = VINF_SUCCESS;
1348
1349	switch (enmStreamCmd)
1350	{
1351	case PDMAUDIOSTREAMCMD_ENABLE:
1352	case PDMAUDIOSTREAMCMD_RESUME:
1353	{
1354	pa_threaded_mainloop_lock(pThis->pMainLoop);
1355
1356	if ( pStreamPA->pDrainOp
1357	&& pa_operation_get_state(pStreamPA->pDrainOp) != PA_OPERATION_DONE)
1358	{
1359	pa_operation_cancel(pStreamPA->pDrainOp);
1360	pa_operation_unref(pStreamPA->pDrainOp);
1361
1362	pStreamPA->pDrainOp = NULL;
1363	}
1364	else
1365	{
1366	/* Uncork (resume) stream. */
1367	rc = paWaitFor(pThis, pa_stream_cork(pStreamPA->pStream, 0 /* Uncork */, paStreamCbSuccess, pStreamPA));
1368	}
1369
1370	pa_threaded_mainloop_unlock(pThis->pMainLoop);
1371	break;
1372	}
1373
1374	case PDMAUDIOSTREAMCMD_DISABLE:
1375	case PDMAUDIOSTREAMCMD_PAUSE:
1376	{
1377	/* Pause audio output (the Pause bit of the AC97 x_CR register is set).
1378	* Note that we must return immediately from here! */
1379	pa_threaded_mainloop_lock(pThis->pMainLoop);
1380	if (!pStreamPA->pDrainOp)
1381	{
1382	rc = paWaitFor(pThis, pa_stream_trigger(pStreamPA->pStream, paStreamCbSuccess, pStreamPA));
1383	if (RT_SUCCESS(rc))
1384	pStreamPA->pDrainOp = pa_stream_drain(pStreamPA->pStream, paStreamCbDrain, pStreamPA);
1385	}
1386	pa_threaded_mainloop_unlock(pThis->pMainLoop);
1387	break;
1388	}
1389
1390	default:
1391	rc = VERR_NOT_SUPPORTED;
1392	break;
1393	}
1394
1395	LogFlowFuncLeaveRC(rc);
1396	return rc;
1397	}
1398
1399
1400	static int paControlStreamIn(PDRVHOSTPULSEAUDIO pThis, PPULSEAUDIOSTREAM pStreamPA, PDMAUDIOSTREAMCMD enmStreamCmd)
1401	{
1402	int rc = VINF_SUCCESS;
1403
1404	LogFlowFunc(("enmStreamCmd=%ld\n", enmStreamCmd));
1405
1406	switch (enmStreamCmd)
1407	{
1408	case PDMAUDIOSTREAMCMD_ENABLE:
1409	case PDMAUDIOSTREAMCMD_RESUME:
1410	{
1411	pa_threaded_mainloop_lock(pThis->pMainLoop);
1412	rc = paWaitFor(pThis, pa_stream_cork(pStreamPA->pStream, 0 /* Play / resume */, paStreamCbSuccess, pStreamPA));
1413	pa_threaded_mainloop_unlock(pThis->pMainLoop);
1414	break;
1415	}
1416
1417	case PDMAUDIOSTREAMCMD_DISABLE:
1418	case PDMAUDIOSTREAMCMD_PAUSE:
1419	{
1420	pa_threaded_mainloop_lock(pThis->pMainLoop);
1421	if (pStreamPA->pu8PeekBuf) /* Do we need to drop the peek buffer?*/
1422	{
1423	pa_stream_drop(pStreamPA->pStream);
1424	pStreamPA->pu8PeekBuf = NULL;
1425	}
1426
1427	rc = paWaitFor(pThis, pa_stream_cork(pStreamPA->pStream, 1 /* Stop / pause */, paStreamCbSuccess, pStreamPA));
1428	pa_threaded_mainloop_unlock(pThis->pMainLoop);
1429	break;
1430	}
1431
1432	default:
1433	rc = VERR_NOT_SUPPORTED;
1434	break;
1435	}
1436
1437	return rc;
1438	}
1439
1440
1441	/**
1442	* @interface_method_impl{PDMIHOSTAUDIO,pfnShutdown}
1443	*/
1444	static DECLCALLBACK(void) drvHostPulseAudioHA_Shutdown(PPDMIHOSTAUDIO pInterface)
1445	{
1446	AssertPtrReturnVoid(pInterface);
1447
1448	PDRVHOSTPULSEAUDIO pThis = PDMIHOSTAUDIO_2_DRVHOSTPULSEAUDIO(pInterface);
1449
1450	LogFlowFuncEnter();
1451
1452	if (pThis->pMainLoop)
1453	pa_threaded_mainloop_stop(pThis->pMainLoop);
1454
1455	if (pThis->pContext)
1456	{
1457	pa_context_disconnect(pThis->pContext);
1458	pa_context_unref(pThis->pContext);
1459	pThis->pContext = NULL;
1460	}
1461
1462	if (pThis->pMainLoop)
1463	{
1464	pa_threaded_mainloop_free(pThis->pMainLoop);
1465	pThis->pMainLoop = NULL;
1466	}
1467
1468	LogFlowFuncLeave();
1469	}
1470
1471
1472	/**
1473	* @interface_method_impl{PDMIHOSTAUDIO,pfnGetConfig}
1474	*/
1475	static DECLCALLBACK(int) drvHostPulseAudioHA_GetConfig(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDCFG pBackendCfg)
1476	{
1477	AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
1478	AssertPtrReturn(pBackendCfg, VERR_INVALID_POINTER);
1479
1480	PDRVHOSTPULSEAUDIO pThis = PDMIHOSTAUDIO_2_DRVHOSTPULSEAUDIO(pInterface);
1481
1482	return paEnumerate(pThis, pBackendCfg, PULSEAUDIOENUMCBFLAGS_LOG /* fEnum */);
1483	}
1484
1485
1486	/**
1487	* @interface_method_impl{PDMIHOSTAUDIO,pfnGetStatus}
1488	*/
1489	static DECLCALLBACK(PDMAUDIOBACKENDSTS) drvHostPulseAudioHA_GetStatus(PPDMIHOSTAUDIO pInterface, PDMAUDIODIR enmDir)
1490	{
1491	RT_NOREF(enmDir);
1492	AssertPtrReturn(pInterface, PDMAUDIOBACKENDSTS_UNKNOWN);
1493
1494	return PDMAUDIOBACKENDSTS_RUNNING;
1495	}
1496
1497
1498	/**
1499	* @interface_method_impl{PDMIHOSTAUDIO,pfnStreamCreate}
1500	*/
1501	static DECLCALLBACK(int) drvHostPulseAudioHA_StreamCreate(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream,
1502	PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
1503	{
1504	AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
1505	AssertPtrReturn(pStream, VERR_INVALID_POINTER);
1506	AssertPtrReturn(pCfgReq, VERR_INVALID_POINTER);
1507	AssertPtrReturn(pCfgAcq, VERR_INVALID_POINTER);
1508
1509	PDRVHOSTPULSEAUDIO pThis = PDMIHOSTAUDIO_2_DRVHOSTPULSEAUDIO(pInterface);
1510	PPULSEAUDIOSTREAM pStreamPA = (PPULSEAUDIOSTREAM)pStream;
1511
1512	int rc;
1513	if (pCfgReq->enmDir == PDMAUDIODIR_IN)
1514	rc = paCreateStreamIn (pThis, pStreamPA, pCfgReq, pCfgAcq);
1515	else if (pCfgReq->enmDir == PDMAUDIODIR_OUT)
1516	rc = paCreateStreamOut(pThis, pStreamPA, pCfgReq, pCfgAcq);
1517	else
1518	AssertFailedReturn(VERR_NOT_IMPLEMENTED);
1519
1520	if (RT_SUCCESS(rc))
1521	{
1522	pStreamPA->pCfg = DrvAudioHlpStreamCfgDup(pCfgAcq);
1523	if (!pStreamPA->pCfg)
1524	rc = VERR_NO_MEMORY;
1525	}
1526
1527	return rc;
1528	}
1529
1530
1531	/**
1532	* @interface_method_impl{PDMIHOSTAUDIO,pfnStreamDestroy}
1533	*/
1534	static DECLCALLBACK(int) drvHostPulseAudioHA_StreamDestroy(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
1535	{
1536	AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
1537	AssertPtrReturn(pStream, VERR_INVALID_POINTER);
1538
1539	PDRVHOSTPULSEAUDIO pThis = PDMIHOSTAUDIO_2_DRVHOSTPULSEAUDIO(pInterface);
1540	PPULSEAUDIOSTREAM pStreamPA = (PPULSEAUDIOSTREAM)pStream;
1541
1542	if (!pStreamPA->pCfg) /* Not (yet) configured? Skip. */
1543	return VINF_SUCCESS;
1544
1545	int rc;
1546	if (pStreamPA->pCfg->enmDir == PDMAUDIODIR_IN)
1547	rc = paDestroyStreamIn (pThis, pStreamPA);
1548	else if (pStreamPA->pCfg->enmDir == PDMAUDIODIR_OUT)
1549	rc = paDestroyStreamOut(pThis, pStreamPA);
1550	else
1551	AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
1552
1553	if (RT_SUCCESS(rc))
1554	{
1555	DrvAudioHlpStreamCfgFree(pStreamPA->pCfg);
1556	pStreamPA->pCfg = NULL;
1557	}
1558
1559	return rc;
1560	}
1561
1562
1563	/**
1564	* @interface_method_impl{PDMIHOSTAUDIO,pfnStreamControl}
1565	*/
1566	static DECLCALLBACK(int) drvHostPulseAudioHA_StreamControl(PPDMIHOSTAUDIO pInterface,
1567	PPDMAUDIOBACKENDSTREAM pStream, PDMAUDIOSTREAMCMD enmStreamCmd)
1568	{
1569	AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
1570	AssertPtrReturn(pStream, VERR_INVALID_POINTER);
1571
1572	PDRVHOSTPULSEAUDIO pThis = PDMIHOSTAUDIO_2_DRVHOSTPULSEAUDIO(pInterface);
1573	PPULSEAUDIOSTREAM pStreamPA = (PPULSEAUDIOSTREAM)pStream;
1574
1575	if (!pStreamPA->pCfg) /* Not (yet) configured? Skip. */
1576	return VINF_SUCCESS;
1577
1578	int rc;
1579	if (pStreamPA->pCfg->enmDir == PDMAUDIODIR_IN)
1580	rc = paControlStreamIn (pThis, pStreamPA, enmStreamCmd);
1581	else if (pStreamPA->pCfg->enmDir == PDMAUDIODIR_OUT)
1582	rc = paControlStreamOut(pThis, pStreamPA, enmStreamCmd);
1583	else
1584	AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
1585
1586	return rc;
1587	}
1588
1589
1590	static uint32_t paStreamGetAvail(PDRVHOSTPULSEAUDIO pThis, PPULSEAUDIOSTREAM pStreamPA)
1591	{
1592	pa_threaded_mainloop_lock(pThis->pMainLoop);
1593
1594	uint32_t cbAvail = 0;
1595
1596	if (PA_STREAM_IS_GOOD(pa_stream_get_state(pStreamPA->pStream)))
1597	{
1598	if (pStreamPA->pCfg->enmDir == PDMAUDIODIR_IN)
1599	{
1600	cbAvail = (uint32_t)pa_stream_readable_size(pStreamPA->pStream);
1601	Log3Func(("cbReadable=%RU32\n", cbAvail));
1602	}
1603	else if (pStreamPA->pCfg->enmDir == PDMAUDIODIR_OUT)
1604	{
1605	size_t cbWritable = pa_stream_writable_size(pStreamPA->pStream);
1606
1607	Log3Func(("cbWritable=%zu, maxLength=%RU32, minReq=%RU32\n",
1608	cbWritable, pStreamPA->BufAttr.maxlength, pStreamPA->BufAttr.minreq));
1609
1610	/* Don't report more writable than the PA server can handle. */
1611	if (cbWritable > pStreamPA->BufAttr.maxlength)
1612	cbWritable = pStreamPA->BufAttr.maxlength;
1613
1614	cbAvail = (uint32_t)cbWritable;
1615	}
1616	else
1617	AssertFailed();
1618	}
1619
1620	pa_threaded_mainloop_unlock(pThis->pMainLoop);
1621
1622	return cbAvail;
1623	}
1624
1625
1626	/**
1627	* @interface_method_impl{PDMIHOSTAUDIO,pfnStreamGetReadable}
1628	*/
1629	static DECLCALLBACK(uint32_t) drvHostPulseAudioHA_StreamGetReadable(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
1630	{
1631	PDRVHOSTPULSEAUDIO pThis = PDMIHOSTAUDIO_2_DRVHOSTPULSEAUDIO(pInterface);
1632	PPULSEAUDIOSTREAM pStreamPA = (PPULSEAUDIOSTREAM)pStream;
1633
1634	return paStreamGetAvail(pThis, pStreamPA);
1635	}
1636
1637
1638	/**
1639	* @interface_method_impl{PDMIHOSTAUDIO,pfnStreamGetWritable}
1640	*/
1641	static DECLCALLBACK(uint32_t) drvHostPulseAudioHA_StreamGetWritable(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
1642	{
1643	PDRVHOSTPULSEAUDIO pThis = PDMIHOSTAUDIO_2_DRVHOSTPULSEAUDIO(pInterface);
1644	PPULSEAUDIOSTREAM pStreamPA = (PPULSEAUDIOSTREAM)pStream;
1645
1646	return paStreamGetAvail(pThis, pStreamPA);
1647	}
1648
1649
1650	/**
1651	* @interface_method_impl{PDMIHOSTAUDIO,pfnStreamGetStatus}
1652	*/
1653	static DECLCALLBACK(PDMAUDIOSTREAMSTS) drvHostPulseAudioHA_StreamGetStatus(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
1654	{
1655	AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
1656	RT_NOREF(pStream);
1657
1658	PDRVHOSTPULSEAUDIO pThis = PDMIHOSTAUDIO_2_DRVHOSTPULSEAUDIO(pInterface);
1659
1660	PDMAUDIOSTREAMSTS fStrmSts = PDMAUDIOSTREAMSTS_FLAGS_NONE;
1661
1662	/* Check PulseAudio's general status. */
1663	if ( pThis->pContext
1664	&& PA_CONTEXT_IS_GOOD(pa_context_get_state(pThis->pContext)))
1665	fStrmSts = PDMAUDIOSTREAMSTS_FLAGS_INITIALIZED \| PDMAUDIOSTREAMSTS_FLAGS_ENABLED;
1666
1667	return fStrmSts;
1668	}
1669
1670
1671	/**
1672	* @interface_method_impl{PDMIHOSTAUDIO,pfnStreamIterate}
1673	*/
1674	static DECLCALLBACK(int) drvHostPulseAudioHA_StreamIterate(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
1675	{
1676	AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
1677	AssertPtrReturn(pStream, VERR_INVALID_POINTER);
1678
1679	LogFlowFuncEnter();
1680
1681	/* Nothing to do here for PulseAudio. */
1682	return VINF_SUCCESS;
1683	}
1684
1685
1686	/**
1687	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
1688	*/
1689	static DECLCALLBACK(void ) drvHostPulseAudioQueryInterface(PPDMIBASE pInterface, const char pszIID)
1690	{
1691	AssertPtrReturn(pInterface, NULL);
1692	AssertPtrReturn(pszIID, NULL);
1693
1694	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
1695	PDRVHOSTPULSEAUDIO pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTPULSEAUDIO);
1696	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
1697	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIHOSTAUDIO, &pThis->IHostAudio);
1698
1699	return NULL;
1700	}
1701
1702
1703	/**
1704	* Destructs a PulseAudio Audio driver instance.
1705	*
1706	* @copydoc FNPDMDRVDESTRUCT
1707	*/
1708	static DECLCALLBACK(void) drvHostPulseAudioDestruct(PPDMDRVINS pDrvIns)
1709	{
1710	PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
1711	LogFlowFuncEnter();
1712	}
1713
1714
1715	/**
1716	* Constructs a PulseAudio Audio driver instance.
1717	*
1718	* @copydoc FNPDMDRVCONSTRUCT
1719	*/
1720	static DECLCALLBACK(int) drvHostPulseAudioConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
1721	{
1722	RT_NOREF(pCfg, fFlags);
1723	PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
1724	AssertPtrReturn(pDrvIns, VERR_INVALID_POINTER);
1725
1726	PDRVHOSTPULSEAUDIO pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTPULSEAUDIO);
1727	LogRel(("Audio: Initializing PulseAudio driver\n"));
1728
1729	pThis->pDrvIns = pDrvIns;
1730	/* IBase */
1731	pDrvIns->IBase.pfnQueryInterface = drvHostPulseAudioQueryInterface;
1732	/* IHostAudio */
1733	pThis->IHostAudio.pfnInit = drvHostPulseAudioHA_Init;
1734	pThis->IHostAudio.pfnShutdown = drvHostPulseAudioHA_Shutdown;
1735	pThis->IHostAudio.pfnGetConfig = drvHostPulseAudioHA_GetConfig;
1736	pThis->IHostAudio.pfnGetStatus = drvHostPulseAudioHA_GetStatus;
1737	pThis->IHostAudio.pfnStreamCreate = drvHostPulseAudioHA_StreamCreate;
1738	pThis->IHostAudio.pfnStreamDestroy = drvHostPulseAudioHA_StreamDestroy;
1739	pThis->IHostAudio.pfnStreamControl = drvHostPulseAudioHA_StreamControl;
1740	pThis->IHostAudio.pfnStreamGetReadable = drvHostPulseAudioHA_StreamGetReadable;
1741	pThis->IHostAudio.pfnStreamGetWritable = drvHostPulseAudioHA_StreamGetWritable;
1742	pThis->IHostAudio.pfnStreamGetStatus = drvHostPulseAudioHA_StreamGetStatus;
1743	pThis->IHostAudio.pfnStreamIterate = drvHostPulseAudioHA_StreamIterate;
1744	pThis->IHostAudio.pfnStreamPlay = drvHostPulseAudioHA_StreamPlay;
1745	pThis->IHostAudio.pfnStreamCapture = drvHostPulseAudioHA_StreamCapture;
1746	pThis->IHostAudio.pfnSetCallback = NULL;
1747	pThis->IHostAudio.pfnGetDevices = NULL;
1748	pThis->IHostAudio.pfnStreamGetPending = NULL;
1749	pThis->IHostAudio.pfnStreamPlayBegin = NULL;
1750	pThis->IHostAudio.pfnStreamPlayEnd = NULL;
1751	pThis->IHostAudio.pfnStreamCaptureBegin = NULL;
1752	pThis->IHostAudio.pfnStreamCaptureEnd = NULL;
1753
1754	int rc2 = CFGMR3QueryString(pCfg, "StreamName", pThis->szStreamName, sizeof(pThis->szStreamName));
1755	AssertMsgRCReturn(rc2, ("Confguration error: No/bad \"StreamName\" value, rc=%Rrc\n", rc2), rc2);
1756
1757	return VINF_SUCCESS;
1758	}
1759
1760
1761	/**
1762	* Pulse audio driver registration record.
1763	*/
1764	const PDMDRVREG g_DrvHostPulseAudio =
1765	{
1766	/* u32Version */
1767	PDM_DRVREG_VERSION,
1768	/* szName */
1769	"PulseAudio",
1770	/* szRCMod */
1771	"",
1772	/* szR0Mod */
1773	"",
1774	/* pszDescription */
1775	"Pulse Audio host driver",
1776	/* fFlags */
1777	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
1778	/* fClass. */
1779	PDM_DRVREG_CLASS_AUDIO,
1780	/* cMaxInstances */
1781	~0U,
1782	/* cbInstance */
1783	sizeof(DRVHOSTPULSEAUDIO),
1784	/* pfnConstruct */
1785	drvHostPulseAudioConstruct,
1786	/* pfnDestruct */
1787	drvHostPulseAudioDestruct,
1788	/* pfnRelocate */
1789	NULL,
1790	/* pfnIOCtl */
1791	NULL,
1792	/* pfnPowerOn */
1793	NULL,
1794	/* pfnReset */
1795	NULL,
1796	/* pfnSuspend */
1797	NULL,
1798	/* pfnResume */
1799	NULL,
1800	/* pfnAttach */
1801	NULL,
1802	/* pfnDetach */
1803	NULL,
1804	/* pfnPowerOff */
1805	NULL,
1806	/* pfnSoftReset */
1807	NULL,
1808	/* u32EndVersion */
1809	PDM_DRVREG_VERSION
1810	};
1811
1812	#if 0 /* unused */
1813	static struct audio_option pulse_options[] =
1814	{
1815	{"DAC_MS", AUD_OPT_INT, &s_pulseCfg.buffer_msecs_out,
1816	"DAC period size in milliseconds", NULL, 0},
1817	{"ADC_MS", AUD_OPT_INT, &s_pulseCfg.buffer_msecs_in,
1818	"ADC period size in milliseconds", NULL, 0}
1819	};
1820	#endif
1821

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

source: vbox/trunk/src/VBox/Devices/Audio/DrvHostPulseAudio.cpp@ 87875

Download in other formats: