1 | /* $Id: DrvHostPulseAudio.cpp 87979 2021-03-05 16:48:14Z 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 VINF_SUCCESS;
|
---|
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 |
|
---|