VirtualBox

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

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

DrvHostPulseAudio.cpp: Another attempt at fixing 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: 58.1 KB
Line 
1/* $Id: DrvHostPulseAudio.cpp 88161 2021-03-17 16:43:36Z 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 = pStreamPA->BufAttr.maxlength != UINT32_MAX /* paranoia */
880 ? PDMAUDIOSTREAMCFG_B2F(pCfgAcq, pStreamPA->BufAttr.maxlength)
881 : pCfgAcq->Backend.cFramesPeriod * 2 /* whatever */;
882 pCfgAcq->Backend.cFramesPreBuffering = pCfgAcq->Backend.cFramesPeriod;
883
884 LogFlowFuncLeaveRC(rc);
885 return rc;
886}
887
888
889/**
890 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamCapture}
891 */
892static DECLCALLBACK(int) drvHostPulseAudioHA_StreamCapture(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream,
893 void *pvBuf, uint32_t uBufSize, uint32_t *puRead)
894{
895 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
896 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
897 AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
898 AssertReturn(uBufSize, VERR_INVALID_PARAMETER);
899 /* pcbRead is optional. */
900
901 PDRVHOSTPULSEAUDIO pThis = PDMIHOSTAUDIO_2_DRVHOSTPULSEAUDIO(pInterface);
902 PPULSEAUDIOSTREAM pStreamPA = (PPULSEAUDIOSTREAM)pStream;
903
904 /* We should only call pa_stream_readable_size() once and trust the first value. */
905 pa_threaded_mainloop_lock(pThis->pMainLoop);
906 size_t cbAvail = pa_stream_readable_size(pStreamPA->pStream);
907 pa_threaded_mainloop_unlock(pThis->pMainLoop);
908
909 if (cbAvail == (size_t)-1)
910 return paError(pStreamPA->pDrv, "Failed to determine input data size");
911
912 /* If the buffer was not dropped last call, add what remains. */
913 if (pStreamPA->pu8PeekBuf)
914 {
915 Assert(pStreamPA->cbPeekBuf >= pStreamPA->offPeekBuf);
916 cbAvail += (pStreamPA->cbPeekBuf - pStreamPA->offPeekBuf);
917 }
918
919 Log3Func(("cbAvail=%zu\n", cbAvail));
920
921 if (!cbAvail) /* No data? Bail out. */
922 {
923 if (puRead)
924 *puRead = 0;
925 return VINF_SUCCESS;
926 }
927
928 int rc = VINF_SUCCESS;
929
930 size_t cbToRead = RT_MIN(cbAvail, uBufSize);
931
932 Log3Func(("cbToRead=%zu, cbAvail=%zu, offPeekBuf=%zu, cbPeekBuf=%zu\n",
933 cbToRead, cbAvail, pStreamPA->offPeekBuf, pStreamPA->cbPeekBuf));
934
935 uint32_t cbReadTotal = 0;
936
937 while (cbToRead)
938 {
939 /* If there is no data, do another peek. */
940 if (!pStreamPA->pu8PeekBuf)
941 {
942 pa_threaded_mainloop_lock(pThis->pMainLoop);
943 pa_stream_peek(pStreamPA->pStream,
944 (const void**)&pStreamPA->pu8PeekBuf, &pStreamPA->cbPeekBuf);
945 pa_threaded_mainloop_unlock(pThis->pMainLoop);
946
947 pStreamPA->offPeekBuf = 0;
948
949 /* No data anymore?
950 * Note: If there's a data hole (cbPeekBuf then contains the length of the hole)
951 * we need to drop the stream lateron. */
952 if ( !pStreamPA->pu8PeekBuf
953 && !pStreamPA->cbPeekBuf)
954 {
955 break;
956 }
957 }
958
959 Assert(pStreamPA->cbPeekBuf >= pStreamPA->offPeekBuf);
960 size_t cbToWrite = RT_MIN(pStreamPA->cbPeekBuf - pStreamPA->offPeekBuf, cbToRead);
961
962 Log3Func(("cbToRead=%zu, cbToWrite=%zu, offPeekBuf=%zu, cbPeekBuf=%zu, pu8PeekBuf=%p\n",
963 cbToRead, cbToWrite,
964 pStreamPA->offPeekBuf, pStreamPA->cbPeekBuf, pStreamPA->pu8PeekBuf));
965
966 if ( cbToWrite
967 /* Only copy data if it's not a data hole (see above). */
968 && pStreamPA->pu8PeekBuf
969 && pStreamPA->cbPeekBuf)
970 {
971 memcpy((uint8_t *)pvBuf + cbReadTotal, pStreamPA->pu8PeekBuf + pStreamPA->offPeekBuf, cbToWrite);
972
973 Assert(cbToRead >= cbToWrite);
974 cbToRead -= cbToWrite;
975 cbReadTotal += cbToWrite;
976
977 pStreamPA->offPeekBuf += cbToWrite;
978 Assert(pStreamPA->offPeekBuf <= pStreamPA->cbPeekBuf);
979 }
980
981 if (/* Nothing to write anymore? Drop the buffer. */
982 !cbToWrite
983 /* Was there a hole in the peeking buffer? Drop it. */
984 || !pStreamPA->pu8PeekBuf
985 /* If the buffer is done, drop it. */
986 || pStreamPA->offPeekBuf == pStreamPA->cbPeekBuf)
987 {
988 pa_threaded_mainloop_lock(pThis->pMainLoop);
989 pa_stream_drop(pStreamPA->pStream);
990 pa_threaded_mainloop_unlock(pThis->pMainLoop);
991
992 pStreamPA->pu8PeekBuf = NULL;
993 }
994 }
995
996 if (RT_SUCCESS(rc))
997 {
998 if (puRead)
999 *puRead = cbReadTotal;
1000 }
1001
1002 return rc;
1003}
1004
1005
1006/**
1007 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamPlay}
1008 */
1009static DECLCALLBACK(int) drvHostPulseAudioHA_StreamPlay(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream,
1010 const void *pvBuf, uint32_t uBufSize, uint32_t *puWritten)
1011{
1012 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
1013 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
1014 AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
1015 AssertReturn(uBufSize, VERR_INVALID_PARAMETER);
1016 /* puWritten is optional. */
1017
1018 PDRVHOSTPULSEAUDIO pThis = PDMIHOSTAUDIO_2_DRVHOSTPULSEAUDIO(pInterface);
1019 PPULSEAUDIOSTREAM pPAStream = (PPULSEAUDIOSTREAM)pStream;
1020
1021 int rc = VINF_SUCCESS;
1022
1023 uint32_t cbWrittenTotal = 0;
1024
1025 pa_threaded_mainloop_lock(pThis->pMainLoop);
1026
1027#ifdef LOG_ENABLED
1028 const pa_usec_t tsNowUs = pa_rtclock_now();
1029 const pa_usec_t tsDeltaPlayedUs = tsNowUs - pPAStream->tsLastReadWrittenUs;
1030
1031 Log3Func(("tsDeltaPlayedMs=%RU64\n", tsDeltaPlayedUs / 1000 /* ms */));
1032
1033 pPAStream->tsLastReadWrittenUs = tsNowUs;
1034#endif
1035
1036 do
1037 {
1038 size_t cbWriteable = pa_stream_writable_size(pPAStream->pStream);
1039 if (cbWriteable == (size_t)-1)
1040 {
1041 rc = paError(pPAStream->pDrv, "Failed to determine output data size");
1042 break;
1043 }
1044
1045 size_t cbLeft = RT_MIN(cbWriteable, uBufSize);
1046 Assert(cbLeft); /* At this point we better have *something* to write. */
1047
1048 while (cbLeft)
1049 {
1050 uint32_t cbChunk = cbLeft; /* Write all at once for now. */
1051
1052 if (pa_stream_write(pPAStream->pStream, (uint8_t *)pvBuf + cbWrittenTotal, cbChunk, NULL /* Cleanup callback */,
1053 0, PA_SEEK_RELATIVE) < 0)
1054 {
1055 rc = paError(pPAStream->pDrv, "Failed to write to output stream");
1056 break;
1057 }
1058
1059 Assert(cbLeft >= cbChunk);
1060 cbLeft -= cbChunk;
1061 cbWrittenTotal += cbChunk;
1062 }
1063
1064 } while (0);
1065
1066 pa_threaded_mainloop_unlock(pThis->pMainLoop);
1067
1068 if (RT_SUCCESS(rc))
1069 {
1070 if (puWritten)
1071 *puWritten = cbWrittenTotal;
1072 }
1073
1074 return rc;
1075}
1076
1077
1078/** @todo Implement va handling. */
1079static int paError(PDRVHOSTPULSEAUDIO pThis, const char *szMsg)
1080{
1081 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
1082 AssertPtrReturn(szMsg, VERR_INVALID_POINTER);
1083
1084 if (pThis->cLogErrors++ < VBOX_PULSEAUDIO_MAX_LOG_REL_ERRORS)
1085 {
1086 int rc2 = pa_context_errno(pThis->pContext);
1087 LogRel2(("PulseAudio: %s: %s\n", szMsg, pa_strerror(rc2)));
1088 }
1089
1090 /** @todo Implement some PulseAudio -> IPRT mapping here. */
1091 return VERR_GENERAL_FAILURE;
1092}
1093
1094
1095static void paEnumSinkCb(pa_context *pCtx, const pa_sink_info *pInfo, int eol, void *pvUserData)
1096{
1097 if (eol > 0)
1098 return;
1099
1100 PPULSEAUDIOENUMCBCTX pCbCtx = (PPULSEAUDIOENUMCBCTX)pvUserData;
1101 AssertPtrReturnVoid(pCbCtx);
1102 PDRVHOSTPULSEAUDIO pThis = pCbCtx->pDrv;
1103 AssertPtrReturnVoid(pThis);
1104 if (eol < 0)
1105 {
1106 pThis->fEnumOpSuccess = false;
1107 pa_threaded_mainloop_signal(pCbCtx->pDrv->pMainLoop, 0);
1108 return;
1109 }
1110
1111 AssertPtrReturnVoid(pCtx);
1112 AssertPtrReturnVoid(pInfo);
1113
1114 LogRel2(("PulseAudio: Using output sink '%s'\n", pInfo->name));
1115
1116 /** @todo Store sinks + channel mapping in callback context as soon as we have surround support. */
1117 pCbCtx->cDevOut++;
1118
1119 pThis->fEnumOpSuccess = true;
1120 pa_threaded_mainloop_signal(pCbCtx->pDrv->pMainLoop, 0);
1121}
1122
1123
1124static void paEnumSourceCb(pa_context *pCtx, const pa_source_info *pInfo, int eol, void *pvUserData)
1125{
1126 if (eol > 0)
1127 return;
1128
1129 PPULSEAUDIOENUMCBCTX pCbCtx = (PPULSEAUDIOENUMCBCTX)pvUserData;
1130 AssertPtrReturnVoid(pCbCtx);
1131 PDRVHOSTPULSEAUDIO pThis = pCbCtx->pDrv;
1132 AssertPtrReturnVoid(pThis);
1133 if (eol < 0)
1134 {
1135 pThis->fEnumOpSuccess = false;
1136 pa_threaded_mainloop_signal(pCbCtx->pDrv->pMainLoop, 0);
1137 return;
1138 }
1139
1140 AssertPtrReturnVoid(pCtx);
1141 AssertPtrReturnVoid(pInfo);
1142
1143 LogRel2(("PulseAudio: Using input source '%s'\n", pInfo->name));
1144
1145 /** @todo Store sources + channel mapping in callback context as soon as we have surround support. */
1146 pCbCtx->cDevIn++;
1147
1148 pThis->fEnumOpSuccess = true;
1149 pa_threaded_mainloop_signal(pCbCtx->pDrv->pMainLoop, 0);
1150}
1151
1152
1153static void paEnumServerCb(pa_context *pCtx, const pa_server_info *pInfo, void *pvUserData)
1154{
1155 AssertPtrReturnVoid(pCtx);
1156 PPULSEAUDIOENUMCBCTX pCbCtx = (PPULSEAUDIOENUMCBCTX)pvUserData;
1157 AssertPtrReturnVoid(pCbCtx);
1158 PDRVHOSTPULSEAUDIO pThis = pCbCtx->pDrv;
1159 AssertPtrReturnVoid(pThis);
1160
1161 if (!pInfo)
1162 {
1163 pThis->fEnumOpSuccess = false;
1164 pa_threaded_mainloop_signal(pCbCtx->pDrv->pMainLoop, 0);
1165 return;
1166 }
1167
1168 if (pInfo->default_sink_name)
1169 {
1170 Assert(RTStrIsValidEncoding(pInfo->default_sink_name));
1171 pCbCtx->pszDefaultSink = RTStrDup(pInfo->default_sink_name);
1172 }
1173
1174 if (pInfo->default_sink_name)
1175 {
1176 Assert(RTStrIsValidEncoding(pInfo->default_source_name));
1177 pCbCtx->pszDefaultSource = RTStrDup(pInfo->default_source_name);
1178 }
1179
1180 pThis->fEnumOpSuccess = true;
1181 pa_threaded_mainloop_signal(pThis->pMainLoop, 0);
1182}
1183
1184
1185static int paEnumerate(PDRVHOSTPULSEAUDIO pThis, PPDMAUDIOBACKENDCFG pCfg, uint32_t fEnum)
1186{
1187 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
1188 AssertPtrReturn(pCfg, VERR_INVALID_POINTER);
1189
1190 PDMAUDIOBACKENDCFG Cfg;
1191 RT_ZERO(Cfg);
1192
1193 RTStrPrintf2(Cfg.szName, sizeof(Cfg.szName), "PulseAudio");
1194
1195 Cfg.cbStreamOut = sizeof(PULSEAUDIOSTREAM);
1196 Cfg.cbStreamIn = sizeof(PULSEAUDIOSTREAM);
1197 Cfg.cMaxStreamsOut = UINT32_MAX;
1198 Cfg.cMaxStreamsIn = UINT32_MAX;
1199
1200 PULSEAUDIOENUMCBCTX CbCtx;
1201 RT_ZERO(CbCtx);
1202
1203 CbCtx.pDrv = pThis;
1204 CbCtx.fFlags = fEnum;
1205
1206 bool fLog = (fEnum & PULSEAUDIOENUMCBFLAGS_LOG);
1207
1208 pa_threaded_mainloop_lock(pThis->pMainLoop);
1209
1210 pThis->fEnumOpSuccess = false;
1211
1212 LogRel(("PulseAudio: Retrieving server information ...\n"));
1213
1214 /* Check if server information is available and bail out early if it isn't. */
1215 pa_operation *paOpServerInfo = pa_context_get_server_info(pThis->pContext, paEnumServerCb, &CbCtx);
1216 if (!paOpServerInfo)
1217 {
1218 pa_threaded_mainloop_unlock(pThis->pMainLoop);
1219
1220 LogRel(("PulseAudio: Server information not available, skipping enumeration\n"));
1221 return VINF_SUCCESS;
1222 }
1223
1224 int rc = paWaitFor(pThis, paOpServerInfo);
1225 if (RT_SUCCESS(rc) && !pThis->fEnumOpSuccess)
1226 rc = VERR_AUDIO_BACKEND_INIT_FAILED; /* error code does not matter */
1227 if (RT_SUCCESS(rc))
1228 {
1229 if (CbCtx.pszDefaultSink)
1230 {
1231 if (fLog)
1232 LogRel2(("PulseAudio: Default output sink is '%s'\n", CbCtx.pszDefaultSink));
1233
1234 pThis->fEnumOpSuccess = false;
1235 rc = paWaitFor(pThis, pa_context_get_sink_info_by_name(pThis->pContext, CbCtx.pszDefaultSink,
1236 paEnumSinkCb, &CbCtx));
1237 if (RT_SUCCESS(rc) && !pThis->fEnumOpSuccess)
1238 rc = VERR_AUDIO_BACKEND_INIT_FAILED; /* error code does not matter */
1239 if ( RT_FAILURE(rc)
1240 && fLog)
1241 {
1242 LogRel(("PulseAudio: Error enumerating properties for default output sink '%s'\n", CbCtx.pszDefaultSink));
1243 }
1244 }
1245 else if (fLog)
1246 LogRel2(("PulseAudio: No default output sink found\n"));
1247
1248 if (RT_SUCCESS(rc))
1249 {
1250 if (CbCtx.pszDefaultSource)
1251 {
1252 if (fLog)
1253 LogRel2(("PulseAudio: Default input source is '%s'\n", CbCtx.pszDefaultSource));
1254
1255 pThis->fEnumOpSuccess = false;
1256 rc = paWaitFor(pThis, pa_context_get_source_info_by_name(pThis->pContext, CbCtx.pszDefaultSource,
1257 paEnumSourceCb, &CbCtx));
1258 if ( (RT_FAILURE(rc) || !pThis->fEnumOpSuccess)
1259 && fLog)
1260 {
1261 LogRel(("PulseAudio: Error enumerating properties for default input source '%s'\n", CbCtx.pszDefaultSource));
1262 }
1263 }
1264 else if (fLog)
1265 LogRel2(("PulseAudio: No default input source found\n"));
1266 }
1267
1268 if (RT_SUCCESS(rc))
1269 {
1270 if (fLog)
1271 {
1272 LogRel2(("PulseAudio: Found %RU8 host playback device(s)\n", CbCtx.cDevOut));
1273 LogRel2(("PulseAudio: Found %RU8 host capturing device(s)\n", CbCtx.cDevIn));
1274 }
1275
1276 if (pCfg)
1277 memcpy(pCfg, &Cfg, sizeof(PDMAUDIOBACKENDCFG));
1278 }
1279
1280 if (CbCtx.pszDefaultSink)
1281 {
1282 RTStrFree(CbCtx.pszDefaultSink);
1283 CbCtx.pszDefaultSink = NULL;
1284 }
1285
1286 if (CbCtx.pszDefaultSource)
1287 {
1288 RTStrFree(CbCtx.pszDefaultSource);
1289 CbCtx.pszDefaultSource = NULL;
1290 }
1291 }
1292 else if (fLog)
1293 LogRel(("PulseAudio: Error enumerating PulseAudio server properties\n"));
1294
1295 pa_threaded_mainloop_unlock(pThis->pMainLoop);
1296
1297 LogFlowFuncLeaveRC(rc);
1298 return rc;
1299}
1300
1301
1302static int paDestroyStreamIn(PDRVHOSTPULSEAUDIO pThis, PPULSEAUDIOSTREAM pStreamPA)
1303{
1304 LogFlowFuncEnter();
1305
1306 if (pStreamPA->pStream)
1307 {
1308 pa_threaded_mainloop_lock(pThis->pMainLoop);
1309
1310 pa_stream_disconnect(pStreamPA->pStream);
1311 pa_stream_unref(pStreamPA->pStream);
1312
1313 pStreamPA->pStream = NULL;
1314
1315 pa_threaded_mainloop_unlock(pThis->pMainLoop);
1316 }
1317
1318 return VINF_SUCCESS;
1319}
1320
1321
1322static int paDestroyStreamOut(PDRVHOSTPULSEAUDIO pThis, PPULSEAUDIOSTREAM pStreamPA)
1323{
1324 if (pStreamPA->pStream)
1325 {
1326 pa_threaded_mainloop_lock(pThis->pMainLoop);
1327
1328 /* Make sure to cancel a pending draining operation, if any. */
1329 if (pStreamPA->pDrainOp)
1330 {
1331 pa_operation_cancel(pStreamPA->pDrainOp);
1332 pStreamPA->pDrainOp = NULL;
1333 }
1334
1335 pa_stream_disconnect(pStreamPA->pStream);
1336 pa_stream_unref(pStreamPA->pStream);
1337
1338 pStreamPA->pStream = NULL;
1339
1340 pa_threaded_mainloop_unlock(pThis->pMainLoop);
1341 }
1342
1343 return VINF_SUCCESS;
1344}
1345
1346
1347static int paControlStreamOut(PDRVHOSTPULSEAUDIO pThis, PPULSEAUDIOSTREAM pStreamPA, PDMAUDIOSTREAMCMD enmStreamCmd)
1348{
1349 int rc = VINF_SUCCESS;
1350
1351 switch (enmStreamCmd)
1352 {
1353 case PDMAUDIOSTREAMCMD_ENABLE:
1354 case PDMAUDIOSTREAMCMD_RESUME:
1355 {
1356 pa_threaded_mainloop_lock(pThis->pMainLoop);
1357
1358 if ( pStreamPA->pDrainOp
1359 && pa_operation_get_state(pStreamPA->pDrainOp) != PA_OPERATION_DONE)
1360 {
1361 pa_operation_cancel(pStreamPA->pDrainOp);
1362 pa_operation_unref(pStreamPA->pDrainOp);
1363
1364 pStreamPA->pDrainOp = NULL;
1365 }
1366 else
1367 {
1368 /* Uncork (resume) stream. */
1369 rc = paWaitFor(pThis, pa_stream_cork(pStreamPA->pStream, 0 /* Uncork */, paStreamCbSuccess, pStreamPA));
1370 }
1371
1372 pa_threaded_mainloop_unlock(pThis->pMainLoop);
1373 break;
1374 }
1375
1376 case PDMAUDIOSTREAMCMD_DISABLE:
1377 case PDMAUDIOSTREAMCMD_PAUSE:
1378 {
1379 /* Pause audio output (the Pause bit of the AC97 x_CR register is set).
1380 * Note that we must return immediately from here! */
1381 pa_threaded_mainloop_lock(pThis->pMainLoop);
1382 if (!pStreamPA->pDrainOp)
1383 {
1384 rc = paWaitFor(pThis, pa_stream_trigger(pStreamPA->pStream, paStreamCbSuccess, pStreamPA));
1385 if (RT_SUCCESS(rc))
1386 pStreamPA->pDrainOp = pa_stream_drain(pStreamPA->pStream, paStreamCbDrain, pStreamPA);
1387 }
1388 pa_threaded_mainloop_unlock(pThis->pMainLoop);
1389 break;
1390 }
1391
1392 default:
1393 rc = VERR_NOT_SUPPORTED;
1394 break;
1395 }
1396
1397 LogFlowFuncLeaveRC(rc);
1398 return rc;
1399}
1400
1401
1402static int paControlStreamIn(PDRVHOSTPULSEAUDIO pThis, PPULSEAUDIOSTREAM pStreamPA, PDMAUDIOSTREAMCMD enmStreamCmd)
1403{
1404 int rc = VINF_SUCCESS;
1405
1406 LogFlowFunc(("enmStreamCmd=%ld\n", enmStreamCmd));
1407
1408 switch (enmStreamCmd)
1409 {
1410 case PDMAUDIOSTREAMCMD_ENABLE:
1411 case PDMAUDIOSTREAMCMD_RESUME:
1412 {
1413 pa_threaded_mainloop_lock(pThis->pMainLoop);
1414 rc = paWaitFor(pThis, pa_stream_cork(pStreamPA->pStream, 0 /* Play / resume */, paStreamCbSuccess, pStreamPA));
1415 pa_threaded_mainloop_unlock(pThis->pMainLoop);
1416 break;
1417 }
1418
1419 case PDMAUDIOSTREAMCMD_DISABLE:
1420 case PDMAUDIOSTREAMCMD_PAUSE:
1421 {
1422 pa_threaded_mainloop_lock(pThis->pMainLoop);
1423 if (pStreamPA->pu8PeekBuf) /* Do we need to drop the peek buffer?*/
1424 {
1425 pa_stream_drop(pStreamPA->pStream);
1426 pStreamPA->pu8PeekBuf = NULL;
1427 }
1428
1429 rc = paWaitFor(pThis, pa_stream_cork(pStreamPA->pStream, 1 /* Stop / pause */, paStreamCbSuccess, pStreamPA));
1430 pa_threaded_mainloop_unlock(pThis->pMainLoop);
1431 break;
1432 }
1433
1434 default:
1435 rc = VERR_NOT_SUPPORTED;
1436 break;
1437 }
1438
1439 return rc;
1440}
1441
1442
1443/**
1444 * @interface_method_impl{PDMIHOSTAUDIO,pfnShutdown}
1445 */
1446static DECLCALLBACK(void) drvHostPulseAudioHA_Shutdown(PPDMIHOSTAUDIO pInterface)
1447{
1448 AssertPtrReturnVoid(pInterface);
1449
1450 PDRVHOSTPULSEAUDIO pThis = PDMIHOSTAUDIO_2_DRVHOSTPULSEAUDIO(pInterface);
1451
1452 LogFlowFuncEnter();
1453
1454 if (pThis->pMainLoop)
1455 pa_threaded_mainloop_stop(pThis->pMainLoop);
1456
1457 if (pThis->pContext)
1458 {
1459 pa_context_disconnect(pThis->pContext);
1460 pa_context_unref(pThis->pContext);
1461 pThis->pContext = NULL;
1462 }
1463
1464 if (pThis->pMainLoop)
1465 {
1466 pa_threaded_mainloop_free(pThis->pMainLoop);
1467 pThis->pMainLoop = NULL;
1468 }
1469
1470 LogFlowFuncLeave();
1471}
1472
1473
1474/**
1475 * @interface_method_impl{PDMIHOSTAUDIO,pfnGetConfig}
1476 */
1477static DECLCALLBACK(int) drvHostPulseAudioHA_GetConfig(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDCFG pBackendCfg)
1478{
1479 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
1480 AssertPtrReturn(pBackendCfg, VERR_INVALID_POINTER);
1481
1482 PDRVHOSTPULSEAUDIO pThis = PDMIHOSTAUDIO_2_DRVHOSTPULSEAUDIO(pInterface);
1483
1484 return paEnumerate(pThis, pBackendCfg, PULSEAUDIOENUMCBFLAGS_LOG /* fEnum */);
1485}
1486
1487
1488/**
1489 * @interface_method_impl{PDMIHOSTAUDIO,pfnGetStatus}
1490 */
1491static DECLCALLBACK(PDMAUDIOBACKENDSTS) drvHostPulseAudioHA_GetStatus(PPDMIHOSTAUDIO pInterface, PDMAUDIODIR enmDir)
1492{
1493 RT_NOREF(enmDir);
1494 AssertPtrReturn(pInterface, PDMAUDIOBACKENDSTS_UNKNOWN);
1495
1496 return PDMAUDIOBACKENDSTS_RUNNING;
1497}
1498
1499
1500/**
1501 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamCreate}
1502 */
1503static DECLCALLBACK(int) drvHostPulseAudioHA_StreamCreate(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream,
1504 PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
1505{
1506 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
1507 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
1508 AssertPtrReturn(pCfgReq, VERR_INVALID_POINTER);
1509 AssertPtrReturn(pCfgAcq, VERR_INVALID_POINTER);
1510
1511 PDRVHOSTPULSEAUDIO pThis = PDMIHOSTAUDIO_2_DRVHOSTPULSEAUDIO(pInterface);
1512 PPULSEAUDIOSTREAM pStreamPA = (PPULSEAUDIOSTREAM)pStream;
1513
1514 int rc;
1515 if (pCfgReq->enmDir == PDMAUDIODIR_IN)
1516 rc = paCreateStreamIn (pThis, pStreamPA, pCfgReq, pCfgAcq);
1517 else if (pCfgReq->enmDir == PDMAUDIODIR_OUT)
1518 rc = paCreateStreamOut(pThis, pStreamPA, pCfgReq, pCfgAcq);
1519 else
1520 AssertFailedReturn(VERR_NOT_IMPLEMENTED);
1521
1522 if (RT_SUCCESS(rc))
1523 {
1524 pStreamPA->pCfg = PDMAudioStrmCfgDup(pCfgAcq);
1525 if (!pStreamPA->pCfg)
1526 rc = VERR_NO_MEMORY;
1527 }
1528
1529 return rc;
1530}
1531
1532
1533/**
1534 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamDestroy}
1535 */
1536static DECLCALLBACK(int) drvHostPulseAudioHA_StreamDestroy(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
1537{
1538 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
1539 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
1540
1541 PDRVHOSTPULSEAUDIO pThis = PDMIHOSTAUDIO_2_DRVHOSTPULSEAUDIO(pInterface);
1542 PPULSEAUDIOSTREAM pStreamPA = (PPULSEAUDIOSTREAM)pStream;
1543
1544 if (!pStreamPA->pCfg) /* Not (yet) configured? Skip. */
1545 return VINF_SUCCESS;
1546
1547 int rc;
1548 if (pStreamPA->pCfg->enmDir == PDMAUDIODIR_IN)
1549 rc = paDestroyStreamIn (pThis, pStreamPA);
1550 else if (pStreamPA->pCfg->enmDir == PDMAUDIODIR_OUT)
1551 rc = paDestroyStreamOut(pThis, pStreamPA);
1552 else
1553 AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
1554
1555 if (RT_SUCCESS(rc))
1556 {
1557 PDMAudioStrmCfgFree(pStreamPA->pCfg);
1558 pStreamPA->pCfg = NULL;
1559 }
1560
1561 return rc;
1562}
1563
1564
1565/**
1566 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamControl}
1567 */
1568static DECLCALLBACK(int) drvHostPulseAudioHA_StreamControl(PPDMIHOSTAUDIO pInterface,
1569 PPDMAUDIOBACKENDSTREAM pStream, PDMAUDIOSTREAMCMD enmStreamCmd)
1570{
1571 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
1572 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
1573
1574 PDRVHOSTPULSEAUDIO pThis = PDMIHOSTAUDIO_2_DRVHOSTPULSEAUDIO(pInterface);
1575 PPULSEAUDIOSTREAM pStreamPA = (PPULSEAUDIOSTREAM)pStream;
1576
1577 if (!pStreamPA->pCfg) /* Not (yet) configured? Skip. */
1578 return VINF_SUCCESS;
1579
1580 int rc;
1581 if (pStreamPA->pCfg->enmDir == PDMAUDIODIR_IN)
1582 rc = paControlStreamIn (pThis, pStreamPA, enmStreamCmd);
1583 else if (pStreamPA->pCfg->enmDir == PDMAUDIODIR_OUT)
1584 rc = paControlStreamOut(pThis, pStreamPA, enmStreamCmd);
1585 else
1586 AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
1587
1588 return rc;
1589}
1590
1591
1592static uint32_t paStreamGetAvail(PDRVHOSTPULSEAUDIO pThis, PPULSEAUDIOSTREAM pStreamPA)
1593{
1594 pa_threaded_mainloop_lock(pThis->pMainLoop);
1595
1596 uint32_t cbAvail = 0;
1597
1598 if (PA_STREAM_IS_GOOD(pa_stream_get_state(pStreamPA->pStream)))
1599 {
1600 if (pStreamPA->pCfg->enmDir == PDMAUDIODIR_IN)
1601 {
1602 cbAvail = (uint32_t)pa_stream_readable_size(pStreamPA->pStream);
1603 Log3Func(("cbReadable=%RU32\n", cbAvail));
1604 }
1605 else if (pStreamPA->pCfg->enmDir == PDMAUDIODIR_OUT)
1606 {
1607 size_t cbWritable = pa_stream_writable_size(pStreamPA->pStream);
1608
1609 Log3Func(("cbWritable=%zu, maxLength=%RU32, minReq=%RU32\n",
1610 cbWritable, pStreamPA->BufAttr.maxlength, pStreamPA->BufAttr.minreq));
1611
1612 /* Don't report more writable than the PA server can handle. */
1613 if (cbWritable > pStreamPA->BufAttr.maxlength)
1614 cbWritable = pStreamPA->BufAttr.maxlength;
1615
1616 cbAvail = (uint32_t)cbWritable;
1617 }
1618 else
1619 AssertFailed();
1620 }
1621
1622 pa_threaded_mainloop_unlock(pThis->pMainLoop);
1623
1624 return cbAvail;
1625}
1626
1627
1628/**
1629 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamGetReadable}
1630 */
1631static DECLCALLBACK(uint32_t) drvHostPulseAudioHA_StreamGetReadable(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
1632{
1633 PDRVHOSTPULSEAUDIO pThis = PDMIHOSTAUDIO_2_DRVHOSTPULSEAUDIO(pInterface);
1634 PPULSEAUDIOSTREAM pStreamPA = (PPULSEAUDIOSTREAM)pStream;
1635
1636 return paStreamGetAvail(pThis, pStreamPA);
1637}
1638
1639
1640/**
1641 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamGetWritable}
1642 */
1643static DECLCALLBACK(uint32_t) drvHostPulseAudioHA_StreamGetWritable(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
1644{
1645 PDRVHOSTPULSEAUDIO pThis = PDMIHOSTAUDIO_2_DRVHOSTPULSEAUDIO(pInterface);
1646 PPULSEAUDIOSTREAM pStreamPA = (PPULSEAUDIOSTREAM)pStream;
1647
1648 return paStreamGetAvail(pThis, pStreamPA);
1649}
1650
1651
1652/**
1653 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamGetStatus}
1654 */
1655static DECLCALLBACK(PDMAUDIOSTREAMSTS) drvHostPulseAudioHA_StreamGetStatus(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
1656{
1657 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
1658 RT_NOREF(pStream);
1659
1660 PDRVHOSTPULSEAUDIO pThis = PDMIHOSTAUDIO_2_DRVHOSTPULSEAUDIO(pInterface);
1661
1662 PDMAUDIOSTREAMSTS fStrmSts = PDMAUDIOSTREAMSTS_FLAGS_NONE;
1663
1664 /* Check PulseAudio's general status. */
1665 if ( pThis->pContext
1666 && PA_CONTEXT_IS_GOOD(pa_context_get_state(pThis->pContext)))
1667 fStrmSts = PDMAUDIOSTREAMSTS_FLAGS_INITIALIZED | PDMAUDIOSTREAMSTS_FLAGS_ENABLED;
1668
1669 return fStrmSts;
1670}
1671
1672
1673/**
1674 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamIterate}
1675 */
1676static DECLCALLBACK(int) drvHostPulseAudioHA_StreamIterate(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
1677{
1678 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
1679 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
1680
1681 LogFlowFuncEnter();
1682
1683 /* Nothing to do here for PulseAudio. */
1684 return VINF_SUCCESS;
1685}
1686
1687
1688/**
1689 * @interface_method_impl{PDMIBASE,pfnQueryInterface}
1690 */
1691static DECLCALLBACK(void *) drvHostPulseAudioQueryInterface(PPDMIBASE pInterface, const char *pszIID)
1692{
1693 AssertPtrReturn(pInterface, NULL);
1694 AssertPtrReturn(pszIID, NULL);
1695
1696 PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
1697 PDRVHOSTPULSEAUDIO pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTPULSEAUDIO);
1698 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
1699 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIHOSTAUDIO, &pThis->IHostAudio);
1700
1701 return NULL;
1702}
1703
1704
1705/**
1706 * Destructs a PulseAudio Audio driver instance.
1707 *
1708 * @copydoc FNPDMDRVDESTRUCT
1709 */
1710static DECLCALLBACK(void) drvHostPulseAudioDestruct(PPDMDRVINS pDrvIns)
1711{
1712 PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
1713 LogFlowFuncEnter();
1714}
1715
1716
1717/**
1718 * Constructs a PulseAudio Audio driver instance.
1719 *
1720 * @copydoc FNPDMDRVCONSTRUCT
1721 */
1722static DECLCALLBACK(int) drvHostPulseAudioConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
1723{
1724 RT_NOREF(pCfg, fFlags);
1725 PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
1726 AssertPtrReturn(pDrvIns, VERR_INVALID_POINTER);
1727
1728 PDRVHOSTPULSEAUDIO pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTPULSEAUDIO);
1729 LogRel(("Audio: Initializing PulseAudio driver\n"));
1730
1731 pThis->pDrvIns = pDrvIns;
1732 /* IBase */
1733 pDrvIns->IBase.pfnQueryInterface = drvHostPulseAudioQueryInterface;
1734 /* IHostAudio */
1735 pThis->IHostAudio.pfnInit = drvHostPulseAudioHA_Init;
1736 pThis->IHostAudio.pfnShutdown = drvHostPulseAudioHA_Shutdown;
1737 pThis->IHostAudio.pfnGetConfig = drvHostPulseAudioHA_GetConfig;
1738 pThis->IHostAudio.pfnGetStatus = drvHostPulseAudioHA_GetStatus;
1739 pThis->IHostAudio.pfnStreamCreate = drvHostPulseAudioHA_StreamCreate;
1740 pThis->IHostAudio.pfnStreamDestroy = drvHostPulseAudioHA_StreamDestroy;
1741 pThis->IHostAudio.pfnStreamControl = drvHostPulseAudioHA_StreamControl;
1742 pThis->IHostAudio.pfnStreamGetReadable = drvHostPulseAudioHA_StreamGetReadable;
1743 pThis->IHostAudio.pfnStreamGetWritable = drvHostPulseAudioHA_StreamGetWritable;
1744 pThis->IHostAudio.pfnStreamGetStatus = drvHostPulseAudioHA_StreamGetStatus;
1745 pThis->IHostAudio.pfnStreamIterate = drvHostPulseAudioHA_StreamIterate;
1746 pThis->IHostAudio.pfnStreamPlay = drvHostPulseAudioHA_StreamPlay;
1747 pThis->IHostAudio.pfnStreamCapture = drvHostPulseAudioHA_StreamCapture;
1748 pThis->IHostAudio.pfnSetCallback = NULL;
1749 pThis->IHostAudio.pfnGetDevices = NULL;
1750 pThis->IHostAudio.pfnStreamGetPending = NULL;
1751 pThis->IHostAudio.pfnStreamPlayBegin = NULL;
1752 pThis->IHostAudio.pfnStreamPlayEnd = NULL;
1753 pThis->IHostAudio.pfnStreamCaptureBegin = NULL;
1754 pThis->IHostAudio.pfnStreamCaptureEnd = NULL;
1755
1756 int rc2 = CFGMR3QueryString(pCfg, "StreamName", pThis->szStreamName, sizeof(pThis->szStreamName));
1757 AssertMsgRCReturn(rc2, ("Confguration error: No/bad \"StreamName\" value, rc=%Rrc\n", rc2), rc2);
1758
1759 return VINF_SUCCESS;
1760}
1761
1762
1763/**
1764 * Pulse audio driver registration record.
1765 */
1766const PDMDRVREG g_DrvHostPulseAudio =
1767{
1768 /* u32Version */
1769 PDM_DRVREG_VERSION,
1770 /* szName */
1771 "PulseAudio",
1772 /* szRCMod */
1773 "",
1774 /* szR0Mod */
1775 "",
1776 /* pszDescription */
1777 "Pulse Audio host driver",
1778 /* fFlags */
1779 PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
1780 /* fClass. */
1781 PDM_DRVREG_CLASS_AUDIO,
1782 /* cMaxInstances */
1783 ~0U,
1784 /* cbInstance */
1785 sizeof(DRVHOSTPULSEAUDIO),
1786 /* pfnConstruct */
1787 drvHostPulseAudioConstruct,
1788 /* pfnDestruct */
1789 drvHostPulseAudioDestruct,
1790 /* pfnRelocate */
1791 NULL,
1792 /* pfnIOCtl */
1793 NULL,
1794 /* pfnPowerOn */
1795 NULL,
1796 /* pfnReset */
1797 NULL,
1798 /* pfnSuspend */
1799 NULL,
1800 /* pfnResume */
1801 NULL,
1802 /* pfnAttach */
1803 NULL,
1804 /* pfnDetach */
1805 NULL,
1806 /* pfnPowerOff */
1807 NULL,
1808 /* pfnSoftReset */
1809 NULL,
1810 /* u32EndVersion */
1811 PDM_DRVREG_VERSION
1812};
1813
1814#if 0 /* unused */
1815static struct audio_option pulse_options[] =
1816{
1817 {"DAC_MS", AUD_OPT_INT, &s_pulseCfg.buffer_msecs_out,
1818 "DAC period size in milliseconds", NULL, 0},
1819 {"ADC_MS", AUD_OPT_INT, &s_pulseCfg.buffer_msecs_in,
1820 "ADC period size in milliseconds", NULL, 0}
1821};
1822#endif
1823
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