VirtualBox

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

Last change on this file since 88158 was 88156, checked in by vboxsync, 4 years ago

DrvHostPulseAudio.cpp: Fixed bogus pCfgAcq->Backend.cFramesBufferSize assignment in paCreateStreamIn (probably harmless). bugref:9890
  • 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 88156 2021-03-17 14:29:47Z 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#include <VBox/vmm/pdmaudioinline.h>
26
27#include <stdio.h>
28
29#include <iprt/alloc.h>
30#include <iprt/mem.h>
31#include <iprt/uuid.h>
32#include <iprt/semaphore.h>
33
34RT_C_DECLS_BEGIN
35# include "pulse_mangling.h"
36# include "pulse_stubs.h"
37RT_C_DECLS_END
38
39#include <pulse/pulseaudio.h>
40
41#include "DrvAudio.h"
42#include "VBoxDD.h"
43
44
45/*********************************************************************************************************************************
46* Defines *
47*********************************************************************************************************************************/
48#define VBOX_PULSEAUDIO_MAX_LOG_REL_ERRORS 32 /** @todo Make this configurable thru driver options. */
49
50#ifndef PA_STREAM_NOFLAGS
51# define PA_STREAM_NOFLAGS (pa_context_flags_t)0x0000U /* since 0.9.19 */
52#endif
53
54#ifndef PA_CONTEXT_NOFLAGS
55# define PA_CONTEXT_NOFLAGS (pa_context_flags_t)0x0000U /* since 0.9.19 */
56#endif
57
58/** No flags specified. */
59#define PULSEAUDIOENUMCBFLAGS_NONE 0
60/** (Release) log found devices. */
61#define PULSEAUDIOENUMCBFLAGS_LOG RT_BIT(0)
62
63/** Makes DRVHOSTPULSEAUDIO out of PDMIHOSTAUDIO. */
64#define PDMIHOSTAUDIO_2_DRVHOSTPULSEAUDIO(pInterface) \
65 ( (PDRVHOSTPULSEAUDIO)((uintptr_t)pInterface - RT_UOFFSETOF(DRVHOSTPULSEAUDIO, IHostAudio)) )
66
67
68/*********************************************************************************************************************************
69* Structures *
70*********************************************************************************************************************************/
71
72/**
73 * Host Pulse audio driver instance data.
74 * @implements PDMIAUDIOCONNECTOR
75 */
76typedef struct DRVHOSTPULSEAUDIO
77{
78 /** Pointer to the driver instance structure. */
79 PPDMDRVINS pDrvIns;
80 /** Pointer to PulseAudio's threaded main loop. */
81 pa_threaded_mainloop *pMainLoop;
82 /**
83 * Pointer to our PulseAudio context.
84 * Note: We use a pMainLoop in a separate thread (pContext).
85 * So either use callback functions or protect these functions
86 * by pa_threaded_mainloop_lock() / pa_threaded_mainloop_unlock().
87 */
88 pa_context *pContext;
89 /** Shutdown indicator. */
90 volatile bool fAbortLoop;
91 /** Enumeration operation successful? */
92 volatile bool fEnumOpSuccess;
93 /** Pointer to host audio interface. */
94 PDMIHOSTAUDIO IHostAudio;
95 /** Error count for not flooding the release log.
96 * Specify UINT32_MAX for unlimited logging. */
97 uint32_t cLogErrors;
98 /** The stream (base) name; needed for distinguishing
99 * streams in the PulseAudio mixer controls if multiple
100 * VMs are running at the same time. */
101 char szStreamName[64];
102} DRVHOSTPULSEAUDIO, *PDRVHOSTPULSEAUDIO;
103
104typedef struct PULSEAUDIOSTREAM
105{
106 /** The stream's acquired configuration. */
107 PPDMAUDIOSTREAMCFG pCfg;
108 /** Pointer to driver instance. */
109 PDRVHOSTPULSEAUDIO pDrv;
110 /** Pointer to opaque PulseAudio stream. */
111 pa_stream *pStream;
112 /** Pulse sample format and attribute specification. */
113 pa_sample_spec SampleSpec;
114 /** Pulse playback and buffer metrics. */
115 pa_buffer_attr BufAttr;
116 int fOpSuccess;
117 /** Pointer to Pulse sample peeking buffer. */
118 const uint8_t *pu8PeekBuf;
119 /** Current size (in bytes) of peeking data in
120 * buffer. */
121 size_t cbPeekBuf;
122 /** Our offset (in bytes) in peeking buffer. */
123 size_t offPeekBuf;
124 pa_operation *pDrainOp;
125 /** Number of occurred audio data underflows. */
126 uint32_t cUnderflows;
127 /** Current latency (in us). */
128 uint64_t curLatencyUs;
129#ifdef LOG_ENABLED
130 /** Start time stamp (in us) of stream playback / recording. */
131 pa_usec_t tsStartUs;
132 /** Time stamp (in us) when last read from / written to the stream. */
133 pa_usec_t tsLastReadWrittenUs;
134#endif
135} PULSEAUDIOSTREAM, *PPULSEAUDIOSTREAM;
136
137/**
138 * Callback context for server enumeration callbacks.
139 */
140typedef struct PULSEAUDIOENUMCBCTX
141{
142 /** Pointer to host backend driver. */
143 PDRVHOSTPULSEAUDIO pDrv;
144 /** Enumeration flags. */
145 uint32_t fFlags;
146 /** Number of found input devices. */
147 uint8_t cDevIn;
148 /** Number of found output devices. */
149 uint8_t cDevOut;
150 /** Name of default sink being used. Must be free'd using RTStrFree(). */
151 char *pszDefaultSink;
152 /** Name of default source being used. Must be free'd using RTStrFree(). */
153 char *pszDefaultSource;
154} PULSEAUDIOENUMCBCTX, *PPULSEAUDIOENUMCBCTX;
155
156
157/**
158 * Callback context for the server init context state changed callback.
159 */
160typedef struct PULSEAUDIOSTATECHGCTX
161{
162 /** The event semaphore. */
163 RTSEMEVENT hEvtInit;
164 /** The returned context state. */
165 volatile pa_context_state_t enmCtxState;
166} PULSEAUDIOSTATECHGCTX;
167/** Pointer to a server init context state changed callback context. */
168typedef PULSEAUDIOSTATECHGCTX *PPULSEAUDIOSTATECHGCTX;
169
170
171/*
172 * To allow running on systems with PulseAudio < 0.9.11.
173 */
174#if !defined(PA_CONTEXT_IS_GOOD) && PA_API_VERSION < 12 /* 12 = 0.9.11 where PA_STREAM_IS_GOOD was added */
175DECLINLINE(bool) PA_CONTEXT_IS_GOOD(pa_context_state_t enmState)
176{
177 return enmState == PA_CONTEXT_CONNECTING
178 || enmState == PA_CONTEXT_AUTHORIZING
179 || enmState == PA_CONTEXT_SETTING_NAME
180 || enmState == PA_CONTEXT_READY;
181}
182#endif
183
184#if !defined(PA_STREAM_IS_GOOD) && PA_API_VERSION < 12 /* 12 = 0.9.11 where PA_STREAM_IS_GOOD was added */
185DECLINLINE(bool) PA_STREAM_IS_GOOD(pa_stream_state_t enmState)
186{
187 return enmState == PA_STREAM_CREATING
188 || enmState == PA_STREAM_READY;
189}
190#endif
191
192
193/*********************************************************************************************************************************
194* Prototypes *
195*********************************************************************************************************************************/
196
197static int paEnumerate(PDRVHOSTPULSEAUDIO pThis, PPDMAUDIOBACKENDCFG pCfg, uint32_t fEnum);
198static int paError(PDRVHOSTPULSEAUDIO pThis, const char *szMsg);
199#ifdef DEBUG
200static void paStreamCbUnderflow(pa_stream *pStream, void *pvContext);
201static void paStreamCbReqWrite(pa_stream *pStream, size_t cbLen, void *pvContext);
202#endif
203static void paStreamCbSuccess(pa_stream *pStream, int fSuccess, void *pvContext);
204
205
206/**
207 * Signal the main loop to abort. Just signalling isn't sufficient as the
208 * mainloop might not have been entered yet.
209 */
210static void paSignalWaiter(PDRVHOSTPULSEAUDIO pThis)
211{
212 if (!pThis)
213 return;
214
215 pThis->fAbortLoop = true;
216 pa_threaded_mainloop_signal(pThis->pMainLoop, 0);
217}
218
219
220static pa_sample_format_t paAudioPropsToPulse(PPDMAUDIOPCMPROPS pProps)
221{
222 switch (pProps->cbSample)
223 {
224 case 1:
225 if (!pProps->fSigned)
226 return PA_SAMPLE_U8;
227 break;
228
229 case 2:
230 if (pProps->fSigned)
231 return PA_SAMPLE_S16LE;
232 break;
233
234#ifdef PA_SAMPLE_S32LE
235 case 4:
236 if (pProps->fSigned)
237 return PA_SAMPLE_S32LE;
238 break;
239#endif
240
241 default:
242 break;
243 }
244
245 AssertMsgFailed(("%RU8%s not supported\n", pProps->cbSample, pProps->fSigned ? "S" : "U"));
246 return PA_SAMPLE_INVALID;
247}
248
249
250static int paPulseToAudioProps(pa_sample_format_t pulsefmt, PPDMAUDIOPCMPROPS pProps)
251{
252 /** @todo r=bird: You are assuming undocumented stuff about
253 * pProps->fSwapEndian. */
254 switch (pulsefmt)
255 {
256 case PA_SAMPLE_U8:
257 pProps->cbSample = 1;
258 pProps->fSigned = false;
259 break;
260
261 case PA_SAMPLE_S16LE:
262 pProps->cbSample = 2;
263 pProps->fSigned = true;
264 break;
265
266 case PA_SAMPLE_S16BE:
267 pProps->cbSample = 2;
268 pProps->fSigned = true;
269 /** @todo Handle Endianess. */
270 break;
271
272#ifdef PA_SAMPLE_S32LE
273 case PA_SAMPLE_S32LE:
274 pProps->cbSample = 4;
275 pProps->fSigned = true;
276 break;
277#endif
278
279#ifdef PA_SAMPLE_S32BE
280 case PA_SAMPLE_S32BE:
281 pProps->cbSample = 4;
282 pProps->fSigned = true;
283 /** @todo Handle Endianess. */
284 break;
285#endif
286
287 default:
288 AssertLogRelMsgFailed(("PulseAudio: Format (%ld) not supported\n", pulsefmt));
289 return VERR_NOT_SUPPORTED;
290 }
291
292 return VINF_SUCCESS;
293}
294
295
296/**
297 * Synchronously wait until an operation completed.
298 */
299static int paWaitForEx(PDRVHOSTPULSEAUDIO pThis, pa_operation *pOP, RTMSINTERVAL cMsTimeout)
300{
301 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
302 AssertPtrReturn(pOP, VERR_INVALID_POINTER);
303
304 int rc = VINF_SUCCESS;
305
306 uint64_t u64StartMs = RTTimeMilliTS();
307 while (pa_operation_get_state(pOP) == PA_OPERATION_RUNNING)
308 {
309 if (!pThis->fAbortLoop)
310 {
311 AssertPtr(pThis->pMainLoop);
312 pa_threaded_mainloop_wait(pThis->pMainLoop);
313 if ( !pThis->pContext
314 || pa_context_get_state(pThis->pContext) != PA_CONTEXT_READY)
315 {
316 LogRel(("PulseAudio: pa_context_get_state context not ready\n"));
317 break;
318 }
319 }
320 pThis->fAbortLoop = false;
321
322 uint64_t u64ElapsedMs = RTTimeMilliTS() - u64StartMs;
323 if (u64ElapsedMs >= cMsTimeout)
324 {
325 rc = VERR_TIMEOUT;
326 break;
327 }
328 }
329
330 pa_operation_unref(pOP);
331
332 return rc;
333}
334
335
336static int paWaitFor(PDRVHOSTPULSEAUDIO pThis, pa_operation *pOP)
337{
338 return paWaitForEx(pThis, pOP, 10 * 1000 /* 10s timeout */);
339}
340
341
342/**
343 * Context status changed, init variant signalling our own event semaphore
344 * so we can do a timed wait.
345 */
346static void paContextCbStateChangedInit(pa_context *pCtx, void *pvUser)
347{
348 AssertPtrReturnVoid(pCtx);
349
350 PPULSEAUDIOSTATECHGCTX pStateChgCtx = (PPULSEAUDIOSTATECHGCTX)pvUser;
351 pa_context_state_t enmCtxState = pa_context_get_state(pCtx);
352 switch (enmCtxState)
353 {
354 case PA_CONTEXT_READY:
355 case PA_CONTEXT_TERMINATED:
356 case PA_CONTEXT_FAILED:
357 pStateChgCtx->enmCtxState = enmCtxState;
358 RTSemEventSignal(pStateChgCtx->hEvtInit);
359 break;
360
361 default:
362 break;
363 }
364}
365
366
367/**
368 * Context status changed.
369 */
370static void paContextCbStateChanged(pa_context *pCtx, void *pvUser)
371{
372 AssertPtrReturnVoid(pCtx);
373
374 PDRVHOSTPULSEAUDIO pThis = (PDRVHOSTPULSEAUDIO)pvUser;
375 AssertPtrReturnVoid(pThis);
376
377 switch (pa_context_get_state(pCtx))
378 {
379 case PA_CONTEXT_READY:
380 case PA_CONTEXT_TERMINATED:
381 case PA_CONTEXT_FAILED:
382 paSignalWaiter(pThis);
383 break;
384
385 default:
386 break;
387 }
388}
389
390
391/**
392 * Callback called when our pa_stream_drain operation was completed.
393 */
394static void paStreamCbDrain(pa_stream *pStream, int fSuccess, void *pvUser)
395{
396 AssertPtrReturnVoid(pStream);
397
398 PPULSEAUDIOSTREAM pStreamPA = (PPULSEAUDIOSTREAM)pvUser;
399 AssertPtrReturnVoid(pStreamPA);
400
401 pStreamPA->fOpSuccess = fSuccess;
402 if (fSuccess)
403 {
404 pa_operation_unref(pa_stream_cork(pStream, 1,
405 paStreamCbSuccess, pvUser));
406 }
407 else
408 paError(pStreamPA->pDrv, "Failed to drain stream");
409
410 if (pStreamPA->pDrainOp)
411 {
412 pa_operation_unref(pStreamPA->pDrainOp);
413 pStreamPA->pDrainOp = NULL;
414 }
415}
416
417
418/**
419 * Stream status changed.
420 */
421static void paStreamCbStateChanged(pa_stream *pStream, void *pvUser)
422{
423 AssertPtrReturnVoid(pStream);
424
425 PDRVHOSTPULSEAUDIO pThis = (PDRVHOSTPULSEAUDIO)pvUser;
426 AssertPtrReturnVoid(pThis);
427
428 switch (pa_stream_get_state(pStream))
429 {
430 case PA_STREAM_READY:
431 case PA_STREAM_FAILED:
432 case PA_STREAM_TERMINATED:
433 paSignalWaiter(pThis);
434 break;
435
436 default:
437 break;
438 }
439}
440
441#ifdef DEBUG
442
443static void paStreamCbReqWrite(pa_stream *pStream, size_t cbLen, void *pvContext)
444{
445 RT_NOREF(cbLen, pvContext);
446
447 PPULSEAUDIOSTREAM pStrm = (PPULSEAUDIOSTREAM)pvContext;
448 AssertPtrReturnVoid(pStrm);
449
450 pa_usec_t usec = 0;
451 int neg = 0;
452 pa_stream_get_latency(pStream, &usec, &neg);
453
454 Log2Func(("Requested %zu bytes -- Current latency is %RU64ms\n", cbLen, usec / 1000));
455}
456
457
458static void paStreamCbUnderflow(pa_stream *pStream, void *pvContext)
459{
460 PPULSEAUDIOSTREAM pStrm = (PPULSEAUDIOSTREAM)pvContext;
461 AssertPtrReturnVoid(pStrm);
462
463 pStrm->cUnderflows++;
464
465 LogRel2(("PulseAudio: Warning: Hit underflow #%RU32\n", pStrm->cUnderflows));
466
467 if ( pStrm->cUnderflows >= 6 /** @todo Make this check configurable. */
468 && pStrm->curLatencyUs < 2000000 /* 2s */)
469 {
470 pStrm->curLatencyUs = (pStrm->curLatencyUs * 3) / 2;
471
472 LogRel2(("PulseAudio: Output latency increased to %RU64ms\n", pStrm->curLatencyUs / 1000 /* ms */));
473
474 pStrm->BufAttr.maxlength = pa_usec_to_bytes(pStrm->curLatencyUs, &pStrm->SampleSpec);
475 pStrm->BufAttr.tlength = pa_usec_to_bytes(pStrm->curLatencyUs, &pStrm->SampleSpec);
476
477 pa_stream_set_buffer_attr(pStream, &pStrm->BufAttr, NULL, NULL);
478
479 pStrm->cUnderflows = 0;
480 }
481
482 pa_usec_t curLatencyUs = 0;
483 pa_stream_get_latency(pStream, &curLatencyUs, NULL /* Neg */);
484
485 LogRel2(("PulseAudio: Latency now is %RU64ms\n", curLatencyUs / 1000 /* ms */));
486
487# ifdef LOG_ENABLED
488 const pa_timing_info *pTInfo = pa_stream_get_timing_info(pStream);
489 const pa_sample_spec *pSpec = pa_stream_get_sample_spec(pStream);
490
491 pa_usec_t curPosWritesUs = pa_bytes_to_usec(pTInfo->write_index, pSpec);
492 pa_usec_t curPosReadsUs = pa_bytes_to_usec(pTInfo->read_index, pSpec);
493 pa_usec_t curTsUs = pa_rtclock_now() - pStrm->tsStartUs;
494
495 Log2Func(("curPosWrite=%RU64ms, curPosRead=%RU64ms, curTs=%RU64ms, curLatency=%RU64ms (%RU32Hz, %RU8 channels)\n",
496 curPosWritesUs / RT_US_1MS_64, curPosReadsUs / RT_US_1MS_64,
497 curTsUs / RT_US_1MS_64, curLatencyUs / RT_US_1MS_64, pSpec->rate, pSpec->channels));
498# endif
499}
500
501
502static void paStreamCbOverflow(pa_stream *pStream, void *pvContext)
503{
504 RT_NOREF(pStream, pvContext);
505
506 Log2Func(("Warning: Hit overflow\n"));
507}
508
509#endif /* DEBUG */
510
511static void paStreamCbSuccess(pa_stream *pStream, int fSuccess, void *pvUser)
512{
513 AssertPtrReturnVoid(pStream);
514
515 PPULSEAUDIOSTREAM pStrm = (PPULSEAUDIOSTREAM)pvUser;
516 AssertPtrReturnVoid(pStrm);
517
518 pStrm->fOpSuccess = fSuccess;
519
520 if (fSuccess)
521 paSignalWaiter(pStrm->pDrv);
522 else
523 paError(pStrm->pDrv, "Failed to finish stream operation");
524}
525
526
527static int paStreamOpen(PDRVHOSTPULSEAUDIO pThis, PPULSEAUDIOSTREAM pStreamPA, bool fIn, const char *pszName)
528{
529 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
530 AssertPtrReturn(pStreamPA, VERR_INVALID_POINTER);
531 AssertPtrReturn(pszName, VERR_INVALID_POINTER);
532
533 int rc = VERR_AUDIO_STREAM_COULD_NOT_CREATE;
534 pa_stream *pStream = NULL;
535
536 pa_threaded_mainloop_lock(pThis->pMainLoop);
537
538 do /* goto avoidance non-loop */
539 {
540 pa_sample_spec *pSampleSpec = &pStreamPA->SampleSpec;
541
542 LogFunc(("Opening '%s', rate=%dHz, channels=%d, format=%s\n",
543 pszName, pSampleSpec->rate, pSampleSpec->channels,
544 pa_sample_format_to_string(pSampleSpec->format)));
545
546 if (!pa_sample_spec_valid(pSampleSpec))
547 {
548 LogRel(("PulseAudio: Unsupported sample specification for stream '%s'\n", pszName));
549 break;
550 }
551
552 pa_buffer_attr *pBufAttr = &pStreamPA->BufAttr;
553
554 /** @todo r=andy Use pa_stream_new_with_proplist instead. */
555 if (!(pStream = pa_stream_new(pThis->pContext, pszName, pSampleSpec, NULL /* pa_channel_map */)))
556 {
557 LogRel(("PulseAudio: Could not create stream '%s'\n", pszName));
558 rc = VERR_NO_MEMORY;
559 break;
560 }
561
562#ifdef DEBUG
563 pa_stream_set_write_callback (pStream, paStreamCbReqWrite, pStreamPA);
564 pa_stream_set_underflow_callback (pStream, paStreamCbUnderflow, pStreamPA);
565 if (!fIn) /* Only for output streams. */
566 pa_stream_set_overflow_callback(pStream, paStreamCbOverflow, pStreamPA);
567#endif
568 pa_stream_set_state_callback (pStream, paStreamCbStateChanged, pThis);
569
570 uint32_t flags = PA_STREAM_NOFLAGS;
571#if PA_API_VERSION >= 12
572 /* XXX */
573 flags |= PA_STREAM_ADJUST_LATENCY;
574#endif
575 /* For using pa_stream_get_latency() and pa_stream_get_time(). */
576 flags |= PA_STREAM_INTERPOLATE_TIMING | PA_STREAM_AUTO_TIMING_UPDATE;
577
578 /* No input/output right away after the stream was started. */
579 flags |= PA_STREAM_START_CORKED;
580
581 if (fIn)
582 {
583 LogFunc(("Input stream attributes: maxlength=%d fragsize=%d\n",
584 pBufAttr->maxlength, pBufAttr->fragsize));
585
586 if (pa_stream_connect_record(pStream, /*dev=*/NULL, pBufAttr, (pa_stream_flags_t)flags) < 0)
587 {
588 LogRel(("PulseAudio: Could not connect input stream '%s': %s\n",
589 pszName, pa_strerror(pa_context_errno(pThis->pContext))));
590 break;
591 }
592 }
593 else
594 {
595 LogFunc(("Output buffer attributes: maxlength=%d tlength=%d prebuf=%d minreq=%d\n",
596 pBufAttr->maxlength, pBufAttr->tlength, pBufAttr->prebuf, pBufAttr->minreq));
597
598 if (pa_stream_connect_playback(pStream, /*dev=*/NULL, pBufAttr, (pa_stream_flags_t)flags,
599 /*cvolume=*/NULL, /*sync_stream=*/NULL) < 0)
600 {
601 LogRel(("PulseAudio: Could not connect playback stream '%s': %s\n",
602 pszName, pa_strerror(pa_context_errno(pThis->pContext))));
603 break;
604 }
605 }
606
607 /* Wait until the stream is ready. */
608 pa_stream_state_t enmStreamState;
609 for (;;)
610 {
611 enmStreamState = pa_stream_get_state(pStream);
612 if ( enmStreamState == PA_STREAM_READY
613 || !PA_STREAM_IS_GOOD(enmStreamState))
614 break;
615
616 if (!pThis->fAbortLoop)
617 pa_threaded_mainloop_wait(pThis->pMainLoop);
618 pThis->fAbortLoop = false;
619 }
620 if (!PA_STREAM_IS_GOOD(enmStreamState))
621 {
622 LogRel(("PulseAudio: Failed to initialize stream '%s' (state %ld)\n", pszName, enmStreamState));
623 break;
624 }
625
626#ifdef LOG_ENABLED
627 pStreamPA->tsStartUs = pa_rtclock_now();
628#endif
629 const pa_buffer_attr *pBufAttrObtained = pa_stream_get_buffer_attr(pStream);
630 AssertPtrBreak(pBufAttrObtained);
631 memcpy(pBufAttr, pBufAttrObtained, sizeof(pa_buffer_attr));
632
633 LogFunc(("Obtained %s buffer attributes: tLength=%RU32, maxLength=%RU32, minReq=%RU32, fragSize=%RU32, preBuf=%RU32\n",
634 fIn ? "capture" : "playback",
635 pBufAttr->tlength, pBufAttr->maxlength, pBufAttr->minreq, pBufAttr->fragsize, pBufAttr->prebuf));
636
637 pStreamPA->pStream = pStream;
638
639 pa_threaded_mainloop_unlock(pThis->pMainLoop);
640 LogFlowFuncLeaveRC(VINF_SUCCESS);
641 return VINF_SUCCESS;
642
643 } while (0);
644
645 /* We failed. */
646 if (pStream)
647 pa_stream_disconnect(pStream);
648
649 pa_threaded_mainloop_unlock(pThis->pMainLoop);
650
651 if (pStream)
652 pa_stream_unref(pStream);
653 LogFlowFuncLeaveRC(rc);
654 return rc;
655}
656
657
658/**
659 * @interface_method_impl{PDMIHOSTAUDIO,pfnInit}
660 */
661static DECLCALLBACK(int) drvHostPulseAudioHA_Init(PPDMIHOSTAUDIO pInterface)
662{
663 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
664
665 PDRVHOSTPULSEAUDIO pThis = PDMIHOSTAUDIO_2_DRVHOSTPULSEAUDIO(pInterface);
666
667 LogFlowFuncEnter();
668
669 int rc = audioLoadPulseLib();
670 if (RT_FAILURE(rc))
671 {
672 LogRel(("PulseAudio: Failed to load the PulseAudio shared library! Error %Rrc\n", rc));
673 return rc;
674 }
675
676 LogRel(("PulseAudio: Using v%s\n", pa_get_library_version()));
677
678 pThis->fAbortLoop = false;
679 pThis->pMainLoop = pa_threaded_mainloop_new();
680 if (!pThis->pMainLoop)
681 {
682 LogRel(("PulseAudio: Failed to allocate main loop: %s\n", pa_strerror(pa_context_errno(pThis->pContext))));
683 return VERR_NO_MEMORY;
684 }
685
686 bool fLocked = false;
687
688 do
689 {
690 if (!(pThis->pContext = pa_context_new(pa_threaded_mainloop_get_api(pThis->pMainLoop), "VirtualBox")))
691 {
692 LogRel(("PulseAudio: Failed to allocate context: %s\n",
693 pa_strerror(pa_context_errno(pThis->pContext))));
694 rc = VERR_NO_MEMORY;
695 break;
696 }
697
698 if (pa_threaded_mainloop_start(pThis->pMainLoop) < 0)
699 {
700 LogRel(("PulseAudio: Failed to start threaded mainloop: %s\n",
701 pa_strerror(pa_context_errno(pThis->pContext))));
702 rc = VERR_AUDIO_BACKEND_INIT_FAILED;
703 break;
704 }
705
706 PULSEAUDIOSTATECHGCTX InitStateChgCtx;
707 InitStateChgCtx.hEvtInit = NIL_RTSEMEVENT;
708 InitStateChgCtx.enmCtxState = PA_CONTEXT_UNCONNECTED;
709 rc = RTSemEventCreate(&InitStateChgCtx.hEvtInit);
710 if (RT_FAILURE(rc))
711 {
712 LogRel(("PulseAudio: Failed to create init event semaphore: %Rrc\n", rc));
713 break;
714 }
715
716 /*
717 * Install a dedicated init state callback so we can do a timed wait on our own event semaphore if connecting
718 * to the pulseaudio server takes too long.
719 */
720 pa_context_set_state_callback(pThis->pContext, paContextCbStateChangedInit, &InitStateChgCtx /* pvUserData */);
721
722 pa_threaded_mainloop_lock(pThis->pMainLoop);
723 fLocked = true;
724
725 if (!pa_context_connect(pThis->pContext, NULL /* pszServer */,
726 PA_CONTEXT_NOFLAGS, NULL))
727 {
728 /* Wait on our init event semaphore and time out if connecting to the pulseaudio server takes too long. */
729 pa_threaded_mainloop_unlock(pThis->pMainLoop);
730 fLocked = false;
731
732 rc = RTSemEventWait(InitStateChgCtx.hEvtInit, RT_MS_10SEC); /* 10 seconds should be plenty. */
733 if (RT_SUCCESS(rc))
734 {
735 if (InitStateChgCtx.enmCtxState != PA_CONTEXT_READY)
736 {
737 LogRel(("PulseAudio: Failed to initialize context (state %d, rc=%Rrc)\n", InitStateChgCtx.enmCtxState, rc));
738 if (RT_SUCCESS(rc))
739 rc = VERR_AUDIO_BACKEND_INIT_FAILED;
740 }
741 else
742 {
743 pa_threaded_mainloop_lock(pThis->pMainLoop);
744 fLocked = true;
745
746 /* Install the main state changed callback to know if something happens to our acquired context. */
747 pa_context_set_state_callback(pThis->pContext, paContextCbStateChanged, pThis /* pvUserData */);
748 }
749 }
750 else
751 LogRel(("PulseAudio: Waiting for context to become ready failed with %Rrc\n", rc));
752 }
753 else
754 LogRel(("PulseAudio: Failed to connect to server: %s\n",
755 pa_strerror(pa_context_errno(pThis->pContext))));
756
757 RTSemEventDestroy(InitStateChgCtx.hEvtInit);
758 }
759 while (0);
760
761 if (fLocked)
762 pa_threaded_mainloop_unlock(pThis->pMainLoop);
763
764 if (RT_FAILURE(rc))
765 {
766 if (pThis->pMainLoop)
767 pa_threaded_mainloop_stop(pThis->pMainLoop);
768
769 if (pThis->pContext)
770 {
771 pa_context_disconnect(pThis->pContext);
772 pa_context_unref(pThis->pContext);
773 pThis->pContext = NULL;
774 }
775
776 if (pThis->pMainLoop)
777 {
778 pa_threaded_mainloop_free(pThis->pMainLoop);
779 pThis->pMainLoop = NULL;
780 }
781 }
782
783 LogFlowFuncLeaveRC(rc);
784 return rc;
785}
786
787
788static int paCreateStreamOut(PDRVHOSTPULSEAUDIO pThis, PPULSEAUDIOSTREAM pStreamPA,
789 PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
790{
791 pStreamPA->pDrainOp = NULL;
792
793 pStreamPA->SampleSpec.format = paAudioPropsToPulse(&pCfgReq->Props);
794 pStreamPA->SampleSpec.rate = pCfgReq->Props.uHz;
795 pStreamPA->SampleSpec.channels = pCfgReq->Props.cChannels;
796
797 pStreamPA->curLatencyUs = PDMAudioPropsFramesToMilli(&pCfgReq->Props, pCfgReq->Backend.cFramesBufferSize) * RT_US_1MS;
798
799 const uint32_t cbLatency = pa_usec_to_bytes(pStreamPA->curLatencyUs, &pStreamPA->SampleSpec);
800
801 LogRel2(("PulseAudio: Initial output latency is %RU64ms (%RU32 bytes)\n", pStreamPA->curLatencyUs / RT_US_1MS, cbLatency));
802
803 pStreamPA->BufAttr.tlength = cbLatency;
804 pStreamPA->BufAttr.maxlength = -1; /* Let the PulseAudio server choose the biggest size it can handle. */
805 pStreamPA->BufAttr.prebuf = cbLatency;
806 pStreamPA->BufAttr.minreq = PDMAudioPropsFramesToBytes(&pCfgReq->Props, pCfgReq->Backend.cFramesPeriod);
807
808 LogFunc(("Requested: BufAttr tlength=%RU32, maxLength=%RU32, minReq=%RU32\n",
809 pStreamPA->BufAttr.tlength, pStreamPA->BufAttr.maxlength, pStreamPA->BufAttr.minreq));
810
811 Assert(pCfgReq->enmDir == PDMAUDIODIR_OUT);
812
813 char szName[256];
814 RTStrPrintf(szName, sizeof(szName), "VirtualBox %s [%s]", PDMAudioPlaybackDstGetName(pCfgReq->u.enmDst), pThis->szStreamName);
815
816 /* Note that the struct BufAttr is updated to the obtained values after this call! */
817 int rc = paStreamOpen(pThis, pStreamPA, false /* fIn */, szName);
818 if (RT_FAILURE(rc))
819 return rc;
820
821 rc = paPulseToAudioProps(pStreamPA->SampleSpec.format, &pCfgAcq->Props);
822 if (RT_FAILURE(rc))
823 {
824 LogRel(("PulseAudio: Cannot find audio output format %ld\n", pStreamPA->SampleSpec.format));
825 return rc;
826 }
827
828 pCfgAcq->Props.uHz = pStreamPA->SampleSpec.rate;
829 pCfgAcq->Props.cChannels = pStreamPA->SampleSpec.channels;
830 pCfgAcq->Props.cShift = PDMAUDIOPCMPROPS_MAKE_SHIFT_PARMS(pCfgAcq->Props.cbSample, pCfgAcq->Props.cChannels);
831
832 LogFunc(("Acquired: BufAttr tlength=%RU32, maxLength=%RU32, minReq=%RU32\n",
833 pStreamPA->BufAttr.tlength, pStreamPA->BufAttr.maxlength, pStreamPA->BufAttr.minreq));
834
835 pCfgAcq->Backend.cFramesPeriod = PDMAUDIOSTREAMCFG_B2F(pCfgAcq, pStreamPA->BufAttr.minreq);
836 pCfgAcq->Backend.cFramesBufferSize = PDMAUDIOSTREAMCFG_B2F(pCfgAcq, pStreamPA->BufAttr.tlength);
837 pCfgAcq->Backend.cFramesPreBuffering = PDMAUDIOSTREAMCFG_B2F(pCfgAcq, pStreamPA->BufAttr.prebuf);
838
839 pStreamPA->pDrv = pThis;
840
841 return rc;
842}
843
844
845static int paCreateStreamIn(PDRVHOSTPULSEAUDIO pThis, PPULSEAUDIOSTREAM pStreamPA,
846 PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
847{
848 pStreamPA->SampleSpec.format = paAudioPropsToPulse(&pCfgReq->Props);
849 pStreamPA->SampleSpec.rate = pCfgReq->Props.uHz;
850 pStreamPA->SampleSpec.channels = pCfgReq->Props.cChannels;
851
852 pStreamPA->BufAttr.fragsize = PDMAudioPropsFramesToBytes(&pCfgReq->Props, pCfgReq->Backend.cFramesPeriod);
853 pStreamPA->BufAttr.maxlength = -1; /* Let the PulseAudio server choose the biggest size it can handle. */
854
855 Assert(pCfgReq->enmDir == PDMAUDIODIR_IN);
856
857 char szName[256];
858 RTStrPrintf(szName, sizeof(szName), "VirtualBox %s [%s]", PDMAudioRecSrcGetName(pCfgReq->u.enmSrc), pThis->szStreamName);
859
860 /* Note: Other members of BufAttr are ignored for record streams. */
861 int rc = paStreamOpen(pThis, pStreamPA, true /* fIn */, szName);
862 if (RT_FAILURE(rc))
863 return rc;
864
865 rc = paPulseToAudioProps(pStreamPA->SampleSpec.format, &pCfgAcq->Props);
866 if (RT_FAILURE(rc))
867 {
868 LogRel(("PulseAudio: Cannot find audio capture format %ld\n", pStreamPA->SampleSpec.format));
869 return rc;
870 }
871
872 pStreamPA->pDrv = pThis;
873 pStreamPA->pu8PeekBuf = NULL;
874
875 pCfgAcq->Props.uHz = pStreamPA->SampleSpec.rate;
876 pCfgAcq->Props.cChannels = pStreamPA->SampleSpec.channels;
877
878 pCfgAcq->Backend.cFramesPeriod = PDMAUDIOSTREAMCFG_B2F(pCfgAcq, pStreamPA->BufAttr.fragsize);
879 pCfgAcq->Backend.cFramesBufferSize = pCfgAcq->Backend.cFramesPeriod;
880 pCfgAcq->Backend.cFramesPreBuffering = pCfgAcq->Backend.cFramesPeriod;
881
882 LogFlowFuncLeaveRC(rc);
883 return rc;
884}
885
886
887/**
888 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamCapture}
889 */
890static DECLCALLBACK(int) drvHostPulseAudioHA_StreamCapture(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream,
891 void *pvBuf, uint32_t uBufSize, uint32_t *puRead)
892{
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 */
1007static 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. */
1077static 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
1093static 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
1122static 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
1151static 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
1183static 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
1300static 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
1320static 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
1345static 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
1400static 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 */
1444static 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 */
1475static 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 */
1489static 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 */
1501static 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 = PDMAudioStrmCfgDup(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 */
1534static 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 PDMAudioStrmCfgFree(pStreamPA->pCfg);
1556 pStreamPA->pCfg = NULL;
1557 }
1558
1559 return rc;
1560}
1561
1562
1563/**
1564 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamControl}
1565 */
1566static 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
1590static 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 */
1629static 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 */
1641static 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 */
1653static 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 */
1674static 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 */
1689static 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 */
1708static 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 */
1720static 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 */
1764const 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 */
1813static 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.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette