VirtualBox

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

Last change on this file since 72919 was 70994, checked in by vboxsync, 7 years ago

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