VirtualBox

source: vbox/trunk/src/VBox/Devices/Audio/AudioMixer.cpp@ 67584

Last change on this file since 67584 was 67444, checked in by vboxsync, 8 years ago

Audio/AudioMixer: Renaming. No actual code changes.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 54.7 KB
Line 
1/* $Id: AudioMixer.cpp 67444 2017-06-16 14:12:16Z vboxsync $ */
2/** @file
3 * VBox audio: Mixing routines, mainly used by the various audio device
4 * emulations to achieve proper multiplexing from/to attached
5 * devices LUNs.
6 *
7 * This mixer acts as a layer between the audio connector interface and
8 * the actual device emulation, providing mechanisms for audio sources (input) and
9 * audio sinks (output).
10 *
11 * Think of this mixer as kind of a high(er) level interface for the audio connector
12 * interface, abstracting common tasks such as creating and managing various audio
13 * sources and sinks. This mixer class is purely optional and can be left out when
14 * implementing a new device emulation, using only the audi connector interface
15 * instead. For example, the SB16 emulation does not use this mixer and does all its
16 * stream management on its own.
17 *
18 * As audio driver instances are handled as LUNs on the device level, this
19 * audio mixer then can take care of e.g. mixing various inputs/outputs to/from
20 * a specific source/sink.
21 *
22 * How and which audio streams are connected to sinks/sources depends on how
23 * the audio mixer has been set up.
24 *
25 * A sink can connect multiple output streams together, whereas a source
26 * does this with input streams. Each sink / source consists of one or more
27 * so-called mixer streams, which then in turn have pointers to the actual
28 * PDM audio input/output streams.
29 */
30
31/*
32 * Copyright (C) 2014-2017 Oracle Corporation
33 *
34 * This file is part of VirtualBox Open Source Edition (OSE), as
35 * available from http://www.virtualbox.org. This file is free software;
36 * you can redistribute it and/or modify it under the terms of the GNU
37 * General Public License (GPL) as published by the Free Software
38 * Foundation, in version 2 as it comes in the "COPYING" file of the
39 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
40 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
41 */
42#define LOG_GROUP LOG_GROUP_AUDIO_MIXER
43#include <VBox/log.h>
44#include "AudioMixer.h"
45#include "AudioMixBuffer.h"
46#include "DrvAudio.h"
47
48#include <VBox/vmm/pdm.h>
49#include <VBox/err.h>
50#include <VBox/vmm/mm.h>
51#include <VBox/vmm/pdmaudioifs.h>
52
53#include <iprt/alloc.h>
54#include <iprt/asm-math.h>
55#include <iprt/assert.h>
56#include <iprt/string.h>
57
58static int audioMixerRemoveSinkInternal(PAUDIOMIXER pMixer, PAUDMIXSINK pSink);
59
60static void audioMixerSinkDestroyInternal(PAUDMIXSINK pSink);
61static int audioMixerSinkUpdateVolume(PAUDMIXSINK pSink, const PPDMAUDIOVOLUME pVolMaster);
62static void audioMixerSinkRemoveAllStreamsInternal(PAUDMIXSINK pSink);
63static int audioMixerSinkRemoveStreamInternal(PAUDMIXSINK pSink, PAUDMIXSTREAM pStream);
64static void audioMixerSinkReset(PAUDMIXSINK pSink);
65static int audioMixerSinkUpdateInternal(PAUDMIXSINK pSink);
66
67int audioMixerStreamCtlInternal(PAUDMIXSTREAM pMixStream, PDMAUDIOSTREAMCMD enmCmd, uint32_t fCtl);
68static void audioMixerStreamDestroyInternal(PAUDMIXSTREAM pStream);
69
70
71#ifdef LOG_ENABLED
72/**
73 * Converts a mixer sink status to a string.
74 *
75 * @returns Stringified mixer sink flags. Must be free'd with RTStrFree().
76 * "NONE" if no flags set.
77 * @param fFlags Mixer sink flags to convert.
78 */
79static char *dbgAudioMixerSinkStatusToStr(AUDMIXSINKSTS fStatus)
80{
81#define APPEND_FLAG_TO_STR(_aFlag) \
82 if (fStatus & AUDMIXSINK_STS_##_aFlag) \
83 { \
84 if (pszFlags) \
85 { \
86 rc2 = RTStrAAppend(&pszFlags, " "); \
87 if (RT_FAILURE(rc2)) \
88 break; \
89 } \
90 \
91 rc2 = RTStrAAppend(&pszFlags, #_aFlag); \
92 if (RT_FAILURE(rc2)) \
93 break; \
94 } \
95
96 char *pszFlags = NULL;
97 int rc2 = VINF_SUCCESS;
98
99 do
100 {
101 APPEND_FLAG_TO_STR(NONE);
102 APPEND_FLAG_TO_STR(RUNNING);
103 APPEND_FLAG_TO_STR(PENDING_DISABLE);
104 APPEND_FLAG_TO_STR(DIRTY);
105
106 } while (0);
107
108 if ( RT_FAILURE(rc2)
109 && pszFlags)
110 {
111 RTStrFree(pszFlags);
112 pszFlags = NULL;
113 }
114
115#undef APPEND_FLAG_TO_STR
116
117 return pszFlags;
118}
119#endif /* DEBUG */
120
121/**
122 * Creates an audio sink and attaches it to the given mixer.
123 *
124 * @returns IPRT status code.
125 * @param pMixer Mixer to attach created sink to.
126 * @param pszName Name of the sink to create.
127 * @param enmDir Direction of the sink to create.
128 * @param ppSink Pointer which returns the created sink on success.
129 */
130int AudioMixerCreateSink(PAUDIOMIXER pMixer, const char *pszName, AUDMIXSINKDIR enmDir, PAUDMIXSINK *ppSink)
131{
132 AssertPtrReturn(pMixer, VERR_INVALID_POINTER);
133 AssertPtrReturn(pszName, VERR_INVALID_POINTER);
134 /* ppSink is optional. */
135
136 int rc = RTCritSectEnter(&pMixer->CritSect);
137 if (RT_FAILURE(rc))
138 return rc;
139
140 PAUDMIXSINK pSink = (PAUDMIXSINK)RTMemAllocZ(sizeof(AUDMIXSINK));
141 if (pSink)
142 {
143 pSink->pszName = RTStrDup(pszName);
144 if (!pSink->pszName)
145 rc = VERR_NO_MEMORY;
146
147 if (RT_SUCCESS(rc))
148 rc = RTCritSectInit(&pSink->CritSect);
149
150 if (RT_SUCCESS(rc))
151 {
152 pSink->pParent = pMixer;
153 pSink->enmDir = enmDir;
154 RTListInit(&pSink->lstStreams);
155
156 /* Set initial volume to max. */
157 pSink->Volume.fMuted = false;
158 pSink->Volume.uLeft = PDMAUDIO_VOLUME_MAX;
159 pSink->Volume.uRight = PDMAUDIO_VOLUME_MAX;
160
161 /* Ditto for the combined volume. */
162 pSink->VolumeCombined.fMuted = false;
163 pSink->VolumeCombined.uLeft = PDMAUDIO_VOLUME_MAX;
164 pSink->VolumeCombined.uRight = PDMAUDIO_VOLUME_MAX;
165
166 RTListAppend(&pMixer->lstSinks, &pSink->Node);
167 pMixer->cSinks++;
168
169 LogFlowFunc(("pMixer=%p, pSink=%p, cSinks=%RU8\n",
170 pMixer, pSink, pMixer->cSinks));
171
172 if (ppSink)
173 *ppSink = pSink;
174 }
175
176 if (RT_FAILURE(rc))
177 {
178 RTCritSectDelete(&pSink->CritSect);
179
180 if (pSink)
181 {
182 RTMemFree(pSink);
183 pSink = NULL;
184 }
185 }
186 }
187 else
188 rc = VERR_NO_MEMORY;
189
190 int rc2 = RTCritSectLeave(&pMixer->CritSect);
191 AssertRC(rc2);
192
193 return rc;
194}
195
196/**
197 * Creates an audio mixer.
198 *
199 * @returns IPRT status code.
200 * @param pszName Name of the audio mixer.
201 * @param fFlags Creation flags. Not used at the moment and must be 0.
202 * @param ppMixer Pointer which returns the created mixer object.
203 */
204int AudioMixerCreate(const char *pszName, uint32_t fFlags, PAUDIOMIXER *ppMixer)
205{
206 RT_NOREF(fFlags);
207 AssertPtrReturn(pszName, VERR_INVALID_POINTER);
208 /** @todo Add fFlags validation. */
209 AssertPtrReturn(ppMixer, VERR_INVALID_POINTER);
210
211 int rc = VINF_SUCCESS;
212
213 PAUDIOMIXER pMixer = (PAUDIOMIXER)RTMemAllocZ(sizeof(AUDIOMIXER));
214 if (pMixer)
215 {
216 pMixer->pszName = RTStrDup(pszName);
217 if (!pMixer->pszName)
218 rc = VERR_NO_MEMORY;
219
220 if (RT_SUCCESS(rc))
221 rc = RTCritSectInit(&pMixer->CritSect);
222
223 if (RT_SUCCESS(rc))
224 {
225 pMixer->cSinks = 0;
226 RTListInit(&pMixer->lstSinks);
227
228 /* Set master volume to the max. */
229 pMixer->VolMaster.fMuted = false;
230 pMixer->VolMaster.uLeft = PDMAUDIO_VOLUME_MAX;
231 pMixer->VolMaster.uRight = PDMAUDIO_VOLUME_MAX;
232
233 LogFlowFunc(("Created mixer '%s'\n", pMixer->pszName));
234
235 *ppMixer = pMixer;
236 }
237 else
238 RTMemFree(pMixer);
239 }
240 else
241 rc = VERR_NO_MEMORY;
242
243 LogFlowFuncLeaveRC(rc);
244 return rc;
245}
246
247/**
248 * Helper function for the internal debugger to print the mixer's current
249 * state, along with the attached sinks.
250 *
251 * @param pMixer Mixer to print debug output for.
252 * @param pHlp Debug info helper to use.
253 * @param pszArgs Optional arguments. Not being used at the moment.
254 */
255void AudioMixerDebug(PAUDIOMIXER pMixer, PCDBGFINFOHLP pHlp, const char *pszArgs)
256{
257 RT_NOREF(pszArgs);
258 PAUDMIXSINK pSink;
259 unsigned iSink = 0;
260
261 int rc2 = RTCritSectEnter(&pMixer->CritSect);
262 if (RT_FAILURE(rc2))
263 return;
264
265 pHlp->pfnPrintf(pHlp, "[Master] %s: lVol=%u, rVol=%u, fMuted=%RTbool\n", pMixer->pszName,
266 pMixer->VolMaster.uLeft, pMixer->VolMaster.uRight, pMixer->VolMaster.fMuted);
267
268 RTListForEach(&pMixer->lstSinks, pSink, AUDMIXSINK, Node)
269 {
270 pHlp->pfnPrintf(pHlp, "[Sink %u] %s: lVol=%u, rVol=%u, fMuted=%RTbool\n", iSink, pSink->pszName,
271 pSink->Volume.uLeft, pSink->Volume.uRight, pSink->Volume.fMuted);
272 ++iSink;
273 }
274
275 rc2 = RTCritSectLeave(&pMixer->CritSect);
276 AssertRC(rc2);
277}
278
279/**
280 * Destroys an audio mixer.
281 *
282 * @param pMixer Audio mixer to destroy.
283 */
284void AudioMixerDestroy(PAUDIOMIXER pMixer)
285{
286 if (!pMixer)
287 return;
288
289 int rc2 = RTCritSectEnter(&pMixer->CritSect);
290 AssertRC(rc2);
291
292 LogFlowFunc(("Destroying %s ...\n", pMixer->pszName));
293
294 PAUDMIXSINK pSink, pSinkNext;
295 RTListForEachSafe(&pMixer->lstSinks, pSink, pSinkNext, AUDMIXSINK, Node)
296 {
297 /* Save a pointer to the sink to remove, as pSink
298 * will not be valid anymore after calling audioMixerRemoveSinkInternal(). */
299 PAUDMIXSINK pSinkToRemove = pSink;
300
301 audioMixerRemoveSinkInternal(pMixer, pSinkToRemove);
302 audioMixerSinkDestroyInternal(pSinkToRemove);
303 }
304
305 pMixer->cSinks = 0;
306
307 if (pMixer->pszName)
308 {
309 RTStrFree(pMixer->pszName);
310 pMixer->pszName = NULL;
311 }
312
313 rc2 = RTCritSectLeave(&pMixer->CritSect);
314 AssertRC(rc2);
315
316 RTCritSectDelete(&pMixer->CritSect);
317
318 RTMemFree(pMixer);
319 pMixer = NULL;
320}
321
322/**
323 * Invalidates all internal data, internal version.
324 *
325 * @returns IPRT status code.
326 * @param pMixer Mixer to invalidate data for.
327 */
328int audioMixerInvalidateInternal(PAUDIOMIXER pMixer)
329{
330 AssertPtrReturn(pMixer, VERR_INVALID_POINTER);
331
332 LogFlowFunc(("[%s]\n", pMixer->pszName));
333
334 /* Propagate new master volume to all connected sinks. */
335 PAUDMIXSINK pSink;
336 RTListForEach(&pMixer->lstSinks, pSink, AUDMIXSINK, Node)
337 {
338 int rc2 = audioMixerSinkUpdateVolume(pSink, &pMixer->VolMaster);
339 AssertRC(rc2);
340 }
341
342 return VINF_SUCCESS;
343}
344
345/**
346 * Invalidates all internal data.
347 *
348 * @returns IPRT status code.
349 * @param pMixer Mixer to invalidate data for.
350 */
351void AudioMixerInvalidate(PAUDIOMIXER pMixer)
352{
353 AssertPtrReturnVoid(pMixer);
354
355 int rc2 = RTCritSectEnter(&pMixer->CritSect);
356 AssertRC(rc2);
357
358 LogFlowFunc(("[%s]\n", pMixer->pszName));
359
360 rc2 = audioMixerInvalidateInternal(pMixer);
361 AssertRC(rc2);
362
363 rc2 = RTCritSectLeave(&pMixer->CritSect);
364 AssertRC(rc2);
365}
366
367/**
368 * Removes a formerly attached audio sink for an audio mixer, internal version.
369 *
370 * @returns IPRT status code.
371 * @param pMixer Mixer to remove sink from.
372 * @param pSink Sink to remove.
373 */
374static int audioMixerRemoveSinkInternal(PAUDIOMIXER pMixer, PAUDMIXSINK pSink)
375{
376 AssertPtrReturn(pMixer, VERR_INVALID_POINTER);
377 if (!pSink)
378 return VERR_NOT_FOUND;
379
380 AssertMsgReturn(pSink->pParent == pMixer, ("%s: Is not part of mixer '%s'\n",
381 pSink->pszName, pMixer->pszName), VERR_NOT_FOUND);
382
383 LogFlowFunc(("[%s]: pSink=%s, cSinks=%RU8\n",
384 pMixer->pszName, pSink->pszName, pMixer->cSinks));
385
386 /* Remove sink from mixer. */
387 RTListNodeRemove(&pSink->Node);
388 Assert(pMixer->cSinks);
389
390 /* Set mixer to NULL so that we know we're not part of any mixer anymore. */
391 pSink->pParent = NULL;
392
393 return VINF_SUCCESS;
394}
395
396/**
397 * Removes a formerly attached audio sink for an audio mixer.
398 *
399 * @returns IPRT status code.
400 * @param pMixer Mixer to remove sink from.
401 * @param pSink Sink to remove.
402 */
403
404void AudioMixerRemoveSink(PAUDIOMIXER pMixer, PAUDMIXSINK pSink)
405{
406 int rc2 = RTCritSectEnter(&pMixer->CritSect);
407 AssertRC(rc2);
408
409 audioMixerSinkRemoveAllStreamsInternal(pSink);
410 audioMixerRemoveSinkInternal(pMixer, pSink);
411
412 rc2 = RTCritSectLeave(&pMixer->CritSect);
413}
414
415/**
416 * Sets the mixer's master volume.
417 *
418 * @returns IPRT status code.
419 * @param pMixer Mixer to set master volume for.
420 * @param pVol Volume to set.
421 */
422int AudioMixerSetMasterVolume(PAUDIOMIXER pMixer, PPDMAUDIOVOLUME pVol)
423{
424 AssertPtrReturn(pMixer, VERR_INVALID_POINTER);
425 AssertPtrReturn(pVol, VERR_INVALID_POINTER);
426
427 int rc = RTCritSectEnter(&pMixer->CritSect);
428 if (RT_FAILURE(rc))
429 return rc;
430
431 memcpy(&pMixer->VolMaster, pVol, sizeof(PDMAUDIOVOLUME));
432
433 LogFlowFunc(("[%s]: lVol=%RU32, rVol=%RU32 => fMuted=%RTbool, lVol=%RU32, rVol=%RU32\n",
434 pMixer->pszName, pVol->uLeft, pVol->uRight,
435 pMixer->VolMaster.fMuted, pMixer->VolMaster.uLeft, pMixer->VolMaster.uRight));
436
437 rc = audioMixerInvalidateInternal(pMixer);
438
439 int rc2 = RTCritSectLeave(&pMixer->CritSect);
440 AssertRC(rc2);
441
442 return rc;
443}
444
445/*********************************************************************************************************************************
446 * Mixer Sink implementation.
447 ********************************************************************************************************************************/
448
449/**
450 * Adds an audio stream to a specific audio sink.
451 *
452 * @returns IPRT status code.
453 * @param pSink Sink to add audio stream to.
454 * @param pStream Stream to add.
455 */
456int AudioMixerSinkAddStream(PAUDMIXSINK pSink, PAUDMIXSTREAM pStream)
457{
458 AssertPtrReturn(pSink, VERR_INVALID_POINTER);
459 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
460
461 int rc = RTCritSectEnter(&pSink->CritSect);
462 if (RT_FAILURE(rc))
463 return rc;
464
465 if (pSink->cStreams == UINT8_MAX) /* 255 streams per sink max. */
466 {
467 int rc2 = RTCritSectLeave(&pSink->CritSect);
468 AssertRC(rc2);
469
470 return VERR_NO_MORE_HANDLES;
471 }
472
473 LogFlowFuncEnter();
474
475#ifdef VBOX_AUDIO_MIXER_WITH_MIXBUF
476 /* Make sure only compatible streams are added. */
477 if (pStream->enmDir == PDMAUDIODIR_IN)
478 {
479 if (DrvAudioHlpPCMPropsAreEqual(&pSink->PCMProps, &pStream->InOut.pIn->Props))
480 {
481#ifdef VBOX_AUDIO_MIXER_WITH_MIXBUF
482 /* Chain: Stream (Child) -> Sink (Child) -> Guest (Parent). */
483 PPDMAUDIOMIXBUF pHstIn = &pStream->InOut.pIn->pHstStrmIn->MixBuf;
484 PPDMAUDIOMIXBUF pGstIn = &pStream->InOut.pIn->MixBuf;
485
486 /* Unlink any former parent from host input. */
487 AudioMixBufUnlink(pHstIn);
488
489 /* Link host input to this sink as a parent. */
490 rc = AudioMixBufLinkTo(pHstIn, &pSink->MixBuf);
491 AssertRC(rc);
492
493 /* Unlink any former parent from this sink. */
494 AudioMixBufUnlink(&pSink->MixBuf);
495
496 /* Link guest input to this sink as a parent. */
497 rc = AudioMixBufLinkTo(&pSink->MixBuf, pGstIn);
498 AssertRC(rc);
499# ifdef DEBUG
500 AudioMixBufDbgPrintChain(&pStream->InOut.pIn->MixBuf);
501# endif
502#endif /* VBOX_AUDIO_MIXER_WITH_MIXBUF */
503 }
504 else
505 AssertFailedStmt(rc = VERR_WRONG_TYPE);
506 }
507 else if (pStream->enmDir == PDMAUDIODIR_OUT)
508 {
509 if (DrvAudioHlpPCMPropsAreEqual(&pSink->PCMProps, &pStream->InOut.pOut->Props))
510 {
511#ifdef VBOX_AUDIO_MIXER_WITH_MIXBUF
512 /* Chain: Guest (Child) -> Sink (Child) -> Stream (Parent). */
513 rc = AudioMixBufLinkTo(&pStream->InOut.pOut->pHstStrmOut->MixBuf, &pSink->MixBuf);
514# ifdef DEBUG
515 AudioMixBufDbgPrintChain(&pSink->MixBuf);
516# endif
517#endif /* VBOX_AUDIO_MIXER_WITH_MIXBUF */
518 }
519 else
520 AssertFailedStmt(rc = VERR_WRONG_TYPE);
521 }
522 else
523 AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
524#else
525 rc = VINF_SUCCESS;
526#endif
527
528 if (RT_SUCCESS(rc))
529 {
530 /** @todo Check if stream already is assigned to (another) sink. */
531
532 /* If the sink is running and not in pending disable mode,
533 * make sure that the added stream also is enabled. */
534 if ( (pSink->fStatus & AUDMIXSINK_STS_RUNNING)
535 && !(pSink->fStatus & AUDMIXSINK_STS_PENDING_DISABLE))
536 {
537 rc = audioMixerStreamCtlInternal(pStream, PDMAUDIOSTREAMCMD_ENABLE, AUDMIXSTRMCTL_FLAG_NONE);
538 }
539
540 if (RT_SUCCESS(rc))
541 {
542 /* Apply the sink's combined volume to the stream. */
543 rc = pStream->pConn->pfnStreamSetVolume(pStream->pConn, pStream->pStream, &pSink->VolumeCombined);
544 AssertRC(rc);
545 }
546
547 if (RT_SUCCESS(rc))
548 {
549 /* Save pointer to sink the stream is attached to. */
550 pStream->pSink = pSink;
551
552 /* Append stream to sink's list. */
553 RTListAppend(&pSink->lstStreams, &pStream->Node);
554 pSink->cStreams++;
555 }
556 }
557
558 LogFlowFunc(("[%s]: cStreams=%RU8, rc=%Rrc\n", pSink->pszName, pSink->cStreams, rc));
559
560 int rc2 = RTCritSectLeave(&pSink->CritSect);
561 AssertRC(rc2);
562
563 return rc;
564}
565
566/**
567 * Creates an audio mixer stream.
568 *
569 * @returns IPRT status code.
570 * @param pSink Sink to use for creating the stream.
571 * @param pConn Audio connector interface to use.
572 * @param pCfg Audio stream configuration to use.
573 * @param fFlags Stream creation flags. Currently unused, set to 0.
574 * @param ppStream Pointer which receives the newly created audio stream.
575 */
576int AudioMixerSinkCreateStream(PAUDMIXSINK pSink,
577 PPDMIAUDIOCONNECTOR pConn, PPDMAUDIOSTREAMCFG pCfg, uint32_t fFlags, PAUDMIXSTREAM *ppStream)
578{
579 AssertPtrReturn(pSink, VERR_INVALID_POINTER);
580 AssertPtrReturn(pConn, VERR_INVALID_POINTER);
581 AssertPtrReturn(pCfg, VERR_INVALID_POINTER);
582 /** @todo Validate fFlags. */
583 /* ppStream is optional. */
584
585 PAUDMIXSTREAM pMixStream = (PAUDMIXSTREAM)RTMemAllocZ(sizeof(AUDMIXSTREAM));
586 if (!pMixStream)
587 return VERR_NO_MEMORY;
588
589 pMixStream->pszName = RTStrDup(pCfg->szName);
590 if (!pMixStream->pszName)
591 {
592 RTMemFree(pMixStream);
593 return VERR_NO_MEMORY;
594 }
595
596 int rc = RTCritSectEnter(&pSink->CritSect);
597 if (RT_FAILURE(rc))
598 return rc;
599
600 LogFlowFunc(("[%s]: fFlags=0x%x (enmDir=%ld, %RU8 bits, %RU8 channels, %RU32Hz)\n",
601 pSink->pszName, fFlags, pCfg->enmDir, pCfg->Props.cBits, pCfg->Props.cChannels, pCfg->Props.uHz));
602
603 /*
604 * Initialize the host-side configuration for the stream to be created.
605 * Always use the sink's PCM audio format as the host side when creating a stream for it.
606 */
607 PDMAUDIOSTREAMCFG CfgHost;
608 rc = DrvAudioHlpPCMPropsToStreamCfg(&pSink->PCMProps, &CfgHost);
609 AssertRCReturn(rc, rc);
610
611 /* Apply the sink's direction for the configuration to use to
612 * create the stream. */
613 if (pSink->enmDir == AUDMIXSINKDIR_INPUT)
614 {
615 CfgHost.DestSource.Source = pCfg->DestSource.Source;
616 CfgHost.enmDir = PDMAUDIODIR_IN;
617 }
618 else
619 {
620 CfgHost.DestSource.Dest = pCfg->DestSource.Dest;
621 CfgHost.enmDir = PDMAUDIODIR_OUT;
622 }
623
624 RTStrPrintf(CfgHost.szName, sizeof(CfgHost.szName), "%s", pCfg->szName);
625
626 rc = RTCritSectInit(&pMixStream->CritSect);
627 if (RT_SUCCESS(rc))
628 {
629 PPDMAUDIOSTREAM pStream;
630 rc = pConn->pfnStreamCreate(pConn, &CfgHost, pCfg, &pStream);
631 if (RT_SUCCESS(rc))
632 {
633 /* Save the audio stream pointer to this mixing stream. */
634 pMixStream->pStream = pStream;
635
636 /* Increase the stream's reference count to let others know
637 * we're reyling on it to be around now. */
638 pConn->pfnStreamRetain(pConn, pStream);
639 }
640 }
641
642 if (RT_SUCCESS(rc))
643 {
644 pMixStream->fFlags = fFlags;
645 pMixStream->pConn = pConn;
646
647 if (ppStream)
648 *ppStream = pMixStream;
649 }
650 else if (pMixStream)
651 {
652 int rc2 = RTCritSectDelete(&pMixStream->CritSect);
653 AssertRC(rc2);
654
655 if (pMixStream->pszName)
656 {
657 RTStrFree(pMixStream->pszName);
658 pMixStream->pszName = NULL;
659 }
660
661 RTMemFree(pMixStream);
662 pMixStream = NULL;
663 }
664
665 int rc2 = RTCritSectLeave(&pSink->CritSect);
666 AssertRC(rc2);
667
668 return rc;
669}
670
671/**
672 * Static helper function to translate a sink command
673 * to a PDM audio stream command.
674 *
675 * @returns PDM audio stream command, or PDMAUDIOSTREAMCMD_UNKNOWN if not found.
676 * @param enmCmd Mixer sink command to translate.
677 */
678static PDMAUDIOSTREAMCMD audioMixerSinkToStreamCmd(AUDMIXSINKCMD enmCmd)
679{
680 switch (enmCmd)
681 {
682 case AUDMIXSINKCMD_ENABLE: return PDMAUDIOSTREAMCMD_ENABLE;
683 case AUDMIXSINKCMD_DISABLE: return PDMAUDIOSTREAMCMD_DISABLE;
684 case AUDMIXSINKCMD_PAUSE: return PDMAUDIOSTREAMCMD_PAUSE;
685 case AUDMIXSINKCMD_RESUME: return PDMAUDIOSTREAMCMD_RESUME;
686 default: break;
687 }
688
689 AssertMsgFailed(("Unsupported sink command %d\n", enmCmd));
690 return PDMAUDIOSTREAMCMD_UNKNOWN;
691}
692
693/**
694 * Controls a mixer sink.
695 *
696 * @returns IPRT status code.
697 * @param pSink Mixer sink to control.
698 * @param enmSinkCmd Sink command to set.
699 */
700int AudioMixerSinkCtl(PAUDMIXSINK pSink, AUDMIXSINKCMD enmSinkCmd)
701{
702 AssertPtrReturn(pSink, VERR_INVALID_POINTER);
703
704 PDMAUDIOSTREAMCMD enmCmdStream = audioMixerSinkToStreamCmd(enmSinkCmd);
705 if (enmCmdStream == PDMAUDIOSTREAMCMD_UNKNOWN)
706 return VERR_NOT_SUPPORTED;
707
708 int rc = RTCritSectEnter(&pSink->CritSect);
709 if (RT_FAILURE(rc))
710 return rc;
711
712 PAUDMIXSTREAM pStream;
713 RTListForEach(&pSink->lstStreams, pStream, AUDMIXSTREAM, Node)
714 {
715 int rc2 = audioMixerStreamCtlInternal(pStream, enmCmdStream, AUDMIXSTRMCTL_FLAG_NONE);
716 if (RT_SUCCESS(rc))
717 rc = rc2;
718 /* Keep going. Flag? */
719 }
720
721 if (enmSinkCmd == AUDMIXSINKCMD_ENABLE)
722 {
723 /* Make sure to clear any other former flags again by assigning AUDMIXSINK_STS_RUNNING directly. */
724 pSink->fStatus = AUDMIXSINK_STS_RUNNING;
725 }
726 else if (enmSinkCmd == AUDMIXSINKCMD_DISABLE)
727 {
728 /* Set the sink in a pending disable state first.
729 * The final status (disabled) will be set in the sink's iteration. */
730 pSink->fStatus |= AUDMIXSINK_STS_PENDING_DISABLE;
731 }
732
733#ifdef LOG_ENABLED
734 char *pszStatus = dbgAudioMixerSinkStatusToStr(pSink->fStatus);
735 LogFlowFunc(("[%s]: enmCmd=%d, fStatus=%s, rc=%Rrc\n", pSink->pszName, enmSinkCmd, pszStatus, rc));
736 RTStrFree(pszStatus);
737#endif
738
739 int rc2 = RTCritSectLeave(&pSink->CritSect);
740 AssertRC(rc2);
741
742 return rc;
743}
744
745/**
746 * Destroys a mixer sink and removes it from the attached mixer (if any).
747 *
748 * @param pSink Mixer sink to destroy.
749 */
750void AudioMixerSinkDestroy(PAUDMIXSINK pSink)
751{
752 if (!pSink)
753 return;
754
755 int rc2 = RTCritSectEnter(&pSink->CritSect);
756 AssertRC(rc2);
757
758 if (pSink->pParent)
759 {
760 /* Save mixer pointer, as after audioMixerRemoveSinkInternal() the
761 * pointer will be gone from the stream. */
762 PAUDIOMIXER pMixer = pSink->pParent;
763 AssertPtr(pMixer);
764
765 audioMixerRemoveSinkInternal(pMixer, pSink);
766
767 Assert(pMixer->cSinks);
768 pMixer->cSinks--;
769 }
770
771 rc2 = RTCritSectLeave(&pSink->CritSect);
772 AssertRC(rc2);
773
774 audioMixerSinkDestroyInternal(pSink);
775}
776
777/**
778 * Destroys a mixer sink.
779 *
780 * @param pSink Mixer sink to destroy.
781 */
782static void audioMixerSinkDestroyInternal(PAUDMIXSINK pSink)
783{
784 AssertPtrReturnVoid(pSink);
785
786 LogFunc(("%s\n", pSink->pszName));
787
788 PAUDMIXSTREAM pStream, pStreamNext;
789 RTListForEachSafe(&pSink->lstStreams, pStream, pStreamNext, AUDMIXSTREAM, Node)
790 {
791 /* Save a pointer to the stream to remove, as pStream
792 * will not be valid anymore after calling audioMixerSinkRemoveStreamInternal(). */
793 PAUDMIXSTREAM pStreamToRemove = pStream;
794
795 audioMixerSinkRemoveStreamInternal(pSink, pStreamToRemove);
796 audioMixerStreamDestroyInternal(pStreamToRemove);
797 }
798
799 if (pSink->pszName)
800 {
801 RTStrFree(pSink->pszName);
802 pSink->pszName = NULL;
803 }
804
805 RTCritSectDelete(&pSink->CritSect);
806
807 RTMemFree(pSink);
808 pSink = NULL;
809}
810
811/**
812 * Returns the amount of bytes ready to be read from a sink since the last call
813 * to AudioMixerSinkUpdate().
814 *
815 * @returns Amount of bytes ready to be read from the sink.
816 * @param pSink Sink to return number of available bytes for.
817 */
818uint32_t AudioMixerSinkGetReadable(PAUDMIXSINK pSink)
819{
820 AssertPtrReturn(pSink, 0);
821
822 AssertMsg(pSink->enmDir == AUDMIXSINKDIR_INPUT, ("%s: Can't read from a non-input sink\n", pSink->pszName));
823
824 int rc = RTCritSectEnter(&pSink->CritSect);
825 if (RT_FAILURE(rc))
826 return 0;
827
828 uint32_t cbReadable = 0;
829
830#ifdef VBOX_AUDIO_MIXER_WITH_MIXBUF
831# error "Implement me!"
832#else
833 /* The hosts sets the pace --
834 * so we try to find the maximum of readable data of all connected streams to this sink. */
835 PAUDMIXSTREAM pMixStream;
836 RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
837 {
838 if (!(pMixStream->pConn->pfnStreamGetStatus(pMixStream->pConn, pMixStream->pStream) & PDMAUDIOSTRMSTS_FLAG_ENABLED))
839 {
840 Log3Func(("[%s] Stream '%s' disabled, skipping ...\n", pSink->pszName, pMixStream->pszName));
841 continue;
842 }
843
844 cbReadable = RT_MAX(cbReadable,
845 pMixStream->pConn->pfnStreamGetReadable(pMixStream->pConn, pMixStream->pStream));
846
847 break; /** @todo For now we only support recording by the first stream added. */
848 }
849#endif
850
851 Log3Func(("[%s] cbReadable=%RU32\n", pSink->pszName, cbReadable));
852
853 int rc2 = RTCritSectLeave(&pSink->CritSect);
854 AssertRC(rc2);
855
856 return cbReadable;
857}
858
859/**
860 * Returns the amount of bytes ready to be written to a sink since the last call
861 * to AudioMixerSinkUpdate().
862 *
863 * @returns Amount of bytes ready to be written to the sink.
864 * @param pSink Sink to return number of available bytes for.
865 */
866uint32_t AudioMixerSinkGetWritable(PAUDMIXSINK pSink)
867{
868 AssertPtrReturn(pSink, 0);
869
870 AssertMsg(pSink->enmDir == AUDMIXSINKDIR_OUTPUT, ("%s: Can't write to a non-output sink\n", pSink->pszName));
871
872 int rc = RTCritSectEnter(&pSink->CritSect);
873 if (RT_FAILURE(rc))
874 return 0;
875
876 uint32_t cbWritable = 0;
877
878 if ( (pSink->fStatus & AUDMIXSINK_STS_RUNNING)
879 && !(pSink->fStatus & AUDMIXSINK_STS_PENDING_DISABLE))
880 {
881#ifdef VBOX_AUDIO_MIXER_WITH_MIXBUF
882# error "Implement me!"
883#else
884 /* The hosts sets the pace --
885 * so we try to find the minimum of writable data to all connected streams to this sink. */
886 PAUDMIXSTREAM pMixStream;
887 RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
888 {
889 if (!(pMixStream->pConn->pfnStreamGetStatus(pMixStream->pConn, pMixStream->pStream) & PDMAUDIOSTRMSTS_FLAG_ENABLED))
890 {
891 Log3Func(("[%s] Stream '%s' disabled, skipping ...\n", pSink->pszName, pMixStream->pszName));
892 continue;
893 }
894
895 const uint32_t cbWritableStream = pMixStream->pConn->pfnStreamGetWritable(pMixStream->pConn, pMixStream->pStream);
896
897 if (cbWritable < cbWritableStream)
898 cbWritable = cbWritableStream;
899
900 break; /** @todo For now the first stream sets the pace. */
901 }
902#endif
903 }
904
905 Log3Func(("[%s] cbWritable=%RU32\n", pSink->pszName, cbWritable));
906
907 int rc2 = RTCritSectLeave(&pSink->CritSect);
908 AssertRC(rc2);
909
910 return cbWritable;
911}
912
913/**
914 * Returns the sink's mixing direction.
915 *
916 * @returns Mixing direction.
917 * @param pSink Sink to return direction for.
918 */
919AUDMIXSINKDIR AudioMixerSinkGetDir(PAUDMIXSINK pSink)
920{
921 AssertPtrReturn(pSink, AUDMIXSINKDIR_UNKNOWN);
922
923 int rc = RTCritSectEnter(&pSink->CritSect);
924 if (RT_FAILURE(rc))
925 return AUDMIXSINKDIR_UNKNOWN;
926
927 AUDMIXSINKDIR enmDir = pSink->enmDir;
928
929 int rc2 = RTCritSectLeave(&pSink->CritSect);
930 AssertRC(rc2);
931
932 return enmDir;
933}
934
935/**
936 * Returns a specific mixer stream from a sink, based on its index.
937 *
938 * @returns Mixer stream if found, or NULL if not found.
939 * @param pSink Sink to retrieve mixer stream from.
940 * @param uIndex Index of the mixer stream to return.
941 */
942PAUDMIXSTREAM AudioMixerSinkGetStream(PAUDMIXSINK pSink, uint8_t uIndex)
943{
944 AssertPtrReturn(pSink, NULL);
945
946 int rc = RTCritSectEnter(&pSink->CritSect);
947 if (RT_FAILURE(rc))
948 return NULL;
949
950 AssertMsgReturn(uIndex < pSink->cStreams,
951 ("Index %RU8 exceeds stream count (%RU8)", uIndex, pSink->cStreams), NULL);
952
953 /* Slow lookup, d'oh. */
954 PAUDMIXSTREAM pStream = RTListGetFirst(&pSink->lstStreams, AUDMIXSTREAM, Node);
955 while (uIndex)
956 {
957 pStream = RTListGetNext(&pSink->lstStreams, pStream, AUDMIXSTREAM, Node);
958 uIndex--;
959 }
960
961 /** @todo Do we need to raise the stream's reference count here? */
962
963 int rc2 = RTCritSectLeave(&pSink->CritSect);
964 AssertRC(rc2);
965
966 AssertPtr(pStream);
967 return pStream;
968}
969
970/**
971 * Returns the current status of a mixer sink.
972 *
973 * @returns The sink's current status.
974 * @param pSink Mixer sink to return status for.
975 */
976AUDMIXSINKSTS AudioMixerSinkGetStatus(PAUDMIXSINK pSink)
977{
978 if (!pSink)
979 return AUDMIXSINK_STS_NONE;
980
981 int rc2 = RTCritSectEnter(&pSink->CritSect);
982 if (RT_FAILURE(rc2))
983 return AUDMIXSINK_STS_NONE;
984
985 /* If the dirty flag is set, there is unprocessed data in the sink. */
986 AUDMIXSINKSTS stsSink = pSink->fStatus;
987
988 rc2 = RTCritSectLeave(&pSink->CritSect);
989 AssertRC(rc2);
990
991 return stsSink;
992}
993
994/**
995 * Returns the number of attached mixer streams to a mixer sink.
996 *
997 * @returns The number of attached mixer streams.
998 * @param pSink Mixer sink to return number for.
999 */
1000uint8_t AudioMixerSinkGetStreamCount(PAUDMIXSINK pSink)
1001{
1002 if (!pSink)
1003 return 0;
1004
1005 int rc2 = RTCritSectEnter(&pSink->CritSect);
1006 if (RT_FAILURE(rc2))
1007 return 0;
1008
1009 uint8_t cStreams = pSink->cStreams;
1010
1011 rc2 = RTCritSectLeave(&pSink->CritSect);
1012 AssertRC(rc2);
1013
1014 return cStreams;
1015}
1016
1017/**
1018 * Returns whether the sink is in an active state or not.
1019 * Note: The pending disable state also counts as active.
1020 *
1021 * @returns True if active, false if not.
1022 * @param pSink Sink to return active state for.
1023 */
1024bool AudioMixerSinkIsActive(PAUDMIXSINK pSink)
1025{
1026 if (!pSink)
1027 return false;
1028
1029 int rc2 = RTCritSectEnter(&pSink->CritSect);
1030 if (RT_FAILURE(rc2))
1031 return 0;
1032
1033 bool fIsActive = (pSink->fStatus & AUDMIXSINK_STS_RUNNING);
1034
1035 rc2 = RTCritSectLeave(&pSink->CritSect);
1036 AssertRC(rc2);
1037
1038 return fIsActive;
1039}
1040
1041/**
1042 * Reads audio data from a mixer sink.
1043 *
1044 * @returns IPRT status code.
1045 * @param pSink Mixer sink to read data from.
1046 * @param enmOp Mixer operation to use for reading the data.
1047 * @param pvBuf Buffer where to store the read data.
1048 * @param cbBuf Buffer size (in bytes) where to store the data.
1049 * @param pcbRead Number of bytes read. Optional.
1050 */
1051int AudioMixerSinkRead(PAUDMIXSINK pSink, AUDMIXOP enmOp, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead)
1052{
1053 RT_NOREF(enmOp);
1054 AssertPtrReturn(pSink, VERR_INVALID_POINTER);
1055 AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
1056 AssertReturn(cbBuf, VERR_INVALID_PARAMETER);
1057 /* pcbRead is optional. */
1058
1059 /** @todo Handle mixing operation enmOp! */
1060
1061 int rc = RTCritSectEnter(&pSink->CritSect);
1062 if (RT_FAILURE(rc))
1063 return rc;
1064
1065 AssertMsg(pSink->enmDir == AUDMIXSINKDIR_INPUT,
1066 ("Can't read from a sink which is not an input sink\n"));
1067
1068#ifdef VBOX_AUDIO_MIXER_WITH_MIXBUF
1069# error "Implement me!"
1070#else
1071 uint8_t *pvMixBuf = (uint8_t *)RTMemAlloc(cbBuf);
1072 if (!pvMixBuf)
1073 {
1074 int rc2 = RTCritSectLeave(&pSink->CritSect);
1075 AssertRC(rc2);
1076
1077 return VERR_NO_MEMORY;
1078 }
1079#endif
1080
1081 uint32_t cbRead = 0;
1082
1083 /* Flag indicating whether this sink is in a 'clean' state,
1084 * e.g. there is no more data to read from. */
1085 bool fClean = true;
1086
1087 PAUDMIXSTREAM pMixStream;
1088 RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
1089 {
1090 if (!(pMixStream->pConn->pfnStreamGetStatus(pMixStream->pConn, pMixStream->pStream) & PDMAUDIOSTRMSTS_FLAG_ENABLED))
1091 {
1092 Log3Func(("[%s] Stream '%s' disabled, skipping ...\n", pSink->pszName, pMixStream->pszName));
1093 continue;
1094 }
1095
1096 uint32_t cbTotalRead = 0;
1097 uint32_t cbToRead = cbBuf;
1098
1099 int rc2 = VINF_SUCCESS;
1100
1101 while (cbToRead)
1102 {
1103 uint32_t cbReadStrm;
1104 AssertPtr(pMixStream->pConn);
1105#ifdef VBOX_AUDIO_MIXER_WITH_MIXBUF
1106# error "Implement me!"
1107#else
1108 rc2 = pMixStream->pConn->pfnStreamRead(pMixStream->pConn, pMixStream->pStream,
1109 (uint8_t *)pvMixBuf + cbTotalRead, cbToRead, &cbReadStrm);
1110#endif
1111 if (RT_FAILURE(rc2))
1112 LogFunc(("[%s] Failed reading from stream '%s': %Rrc\n", pSink->pszName, pMixStream->pszName, rc2));
1113
1114 Log3Func(("[%s] Stream '%s': Read %RU32 bytes\n", pSink->pszName, pMixStream->pszName, cbReadStrm));
1115
1116 if ( RT_FAILURE(rc2)
1117 || !cbReadStrm)
1118 break;
1119
1120 /** @todo Right now we only handle one stream (the last one added in fact). */
1121
1122 AssertBreakStmt(cbReadStrm <= cbToRead, rc = VERR_BUFFER_OVERFLOW);
1123 cbToRead -= cbReadStrm;
1124 cbTotalRead += cbReadStrm;
1125 }
1126
1127 if (RT_FAILURE(rc2))
1128 continue;
1129
1130 cbRead = RT_MAX(cbRead, cbTotalRead);
1131
1132 uint32_t cbReadable = pMixStream->pConn->pfnStreamGetReadable(pMixStream->pConn, pMixStream->pStream);
1133
1134 /* Still some data available? Then sink is not clean (yet). */
1135 if (cbReadable)
1136 fClean = false;
1137 }
1138
1139 if (RT_SUCCESS(rc))
1140 {
1141 if (fClean)
1142 pSink->fStatus &= ~AUDMIXSINK_STS_DIRTY;
1143
1144#ifdef VBOX_AUDIO_MIXER_WITH_MIXBUF
1145# error "Implement me!"
1146#else
1147 if (cbRead)
1148 memcpy(pvBuf, pvMixBuf, cbRead);
1149#endif
1150 if (pcbRead)
1151 *pcbRead = cbRead;
1152 }
1153
1154#ifndef VBOX_AUDIO_MIXER_WITH_MIXBUF
1155 RTMemFree(pvMixBuf);
1156#endif
1157
1158
1159#ifdef LOG_ENABLED
1160 char *pszStatus = dbgAudioMixerSinkStatusToStr(pSink->fStatus);
1161 Log2Func(("[%s] cbRead=%RU32, fClean=%RTbool, fStatus=%s, rc=%Rrc\n", pSink->pszName, cbRead, fClean, pszStatus, rc));
1162 RTStrFree(pszStatus);
1163#endif
1164
1165 int rc2 = RTCritSectLeave(&pSink->CritSect);
1166 AssertRC(rc2);
1167
1168 return rc;
1169}
1170
1171/**
1172 * Removes a mixer stream from a mixer sink, internal version.
1173 *
1174 * @returns IPRT status code.
1175 * @param pSink Sink to remove mixer stream from.
1176 * @param pStream Stream to remove.
1177 */
1178static int audioMixerSinkRemoveStreamInternal(PAUDMIXSINK pSink, PAUDMIXSTREAM pStream)
1179{
1180 AssertPtrReturn(pSink, VERR_INVALID_PARAMETER);
1181 if ( !pStream
1182 || !pStream->pSink) /* Not part of a sink anymore? */
1183 {
1184 return VERR_NOT_FOUND;
1185 }
1186
1187 AssertMsgReturn(pStream->pSink == pSink, ("Stream '%s' is not part of sink '%s'\n",
1188 pStream->pszName, pSink->pszName), VERR_NOT_FOUND);
1189
1190 LogFlowFunc(("[%s]: (Stream = %s), cStreams=%RU8\n",
1191 pSink->pszName, pStream->pStream->szName, pSink->cStreams));
1192
1193#ifdef VBOX_AUDIO_MIXER_WITH_MIXBUF
1194 /* Unlink mixing buffer. */
1195 AudioMixBufUnlink(&pStream->pStream->MixBuf);
1196#endif
1197
1198 /* Remove stream from sink. */
1199 RTListNodeRemove(&pStream->Node);
1200
1201 /* Set sink to NULL so that we know we're not part of any sink anymore. */
1202 pStream->pSink = NULL;
1203
1204 return VINF_SUCCESS;
1205}
1206
1207/**
1208 * Removes a mixer stream from a mixer sink.
1209 *
1210 * @param pSink Sink to remove mixer stream from.
1211 * @param pStream Stream to remove.
1212 */
1213void AudioMixerSinkRemoveStream(PAUDMIXSINK pSink, PAUDMIXSTREAM pStream)
1214{
1215 int rc2 = RTCritSectEnter(&pSink->CritSect);
1216 AssertRC(rc2);
1217
1218 rc2 = audioMixerSinkRemoveStreamInternal(pSink, pStream);
1219 if (RT_SUCCESS(rc2))
1220 {
1221 Assert(pSink->cStreams);
1222 pSink->cStreams--;
1223 }
1224
1225 rc2 = RTCritSectLeave(&pSink->CritSect);
1226 AssertRC(rc2);
1227}
1228
1229/**
1230 * Removes all attached streams from a given sink.
1231 *
1232 * @param pSink Sink to remove attached streams from.
1233 */
1234static void audioMixerSinkRemoveAllStreamsInternal(PAUDMIXSINK pSink)
1235{
1236 if (!pSink)
1237 return;
1238
1239 LogFunc(("%s\n", pSink->pszName));
1240
1241 PAUDMIXSTREAM pStream, pStreamNext;
1242 RTListForEachSafe(&pSink->lstStreams, pStream, pStreamNext, AUDMIXSTREAM, Node)
1243 audioMixerSinkRemoveStreamInternal(pSink, pStream);
1244}
1245
1246/**
1247 * Resets the sink's state.
1248 *
1249 * @param pSink Sink to reset.
1250 */
1251static void audioMixerSinkReset(PAUDMIXSINK pSink)
1252{
1253 if (!pSink)
1254 return;
1255
1256 LogFunc(("[%s]\n", pSink->pszName));
1257
1258 if (pSink->enmDir == AUDMIXSINKDIR_INPUT)
1259 {
1260#ifdef VBOX_AUDIO_MIXER_WITH_MIXBUF
1261 AudioMixBufReset(&pSink->MixBuf);
1262#else
1263 pSink->In.cbReadable = 0;
1264#endif
1265 }
1266 else if (pSink->enmDir == AUDMIXSINKDIR_OUTPUT)
1267 {
1268#ifdef VBOX_AUDIO_MIXER_WITH_MIXBUF
1269 AudioMixBufReset(&pSink->MixBuf);
1270#else
1271 pSink->Out.cbWritable = 0;
1272#endif
1273 }
1274
1275 /* Update last updated timestamp. */
1276 pSink->tsLastUpdatedMS = RTTimeMilliTS();
1277
1278 /* Reset status. */
1279 pSink->fStatus = AUDMIXSINK_STS_NONE;
1280}
1281
1282/**
1283 * Removes all attached streams from a given sink.
1284 *
1285 * @param pSink Sink to remove attached streams from.
1286 */
1287void AudioMixerSinkRemoveAllStreams(PAUDMIXSINK pSink)
1288{
1289 if (!pSink)
1290 return;
1291
1292 int rc2 = RTCritSectEnter(&pSink->CritSect);
1293 AssertRC(rc2);
1294
1295 audioMixerSinkRemoveAllStreamsInternal(pSink);
1296
1297 pSink->cStreams = 0;
1298
1299 rc2 = RTCritSectLeave(&pSink->CritSect);
1300 AssertRC(rc2);
1301}
1302
1303/**
1304 * Resets a sink. This will immediately stop all processing.
1305 *
1306 * @param pSink Sink to reset.
1307 */
1308void AudioMixerSinkReset(PAUDMIXSINK pSink)
1309{
1310 if (!pSink)
1311 return;
1312
1313 int rc2 = RTCritSectEnter(&pSink->CritSect);
1314 AssertRC(rc2);
1315
1316 audioMixerSinkReset(pSink);
1317
1318 rc2 = RTCritSectLeave(&pSink->CritSect);
1319 AssertRC(rc2);
1320}
1321
1322/**
1323 * Sets the audio format of a mixer sink.
1324 *
1325 * @returns IPRT status code.
1326 * @param pSink Sink to set audio format for.
1327 * @param pPCMProps Audio format (PCM properties) to set.
1328 */
1329int AudioMixerSinkSetFormat(PAUDMIXSINK pSink, PPDMAUDIOPCMPROPS pPCMProps)
1330{
1331 AssertPtrReturn(pSink, VERR_INVALID_POINTER);
1332 AssertPtrReturn(pPCMProps, VERR_INVALID_POINTER);
1333
1334 int rc = RTCritSectEnter(&pSink->CritSect);
1335 if (RT_FAILURE(rc))
1336 return rc;
1337
1338 if (DrvAudioHlpPCMPropsAreEqual(&pSink->PCMProps, pPCMProps)) /* Bail out early if PCM properties are equal. */
1339 {
1340 rc = RTCritSectLeave(&pSink->CritSect);
1341 AssertRC(rc);
1342
1343 return rc;
1344 }
1345
1346 if (pSink->PCMProps.uHz)
1347 LogFlowFunc(("[%s]: Old format: %RU8 bit, %RU8 channels, %RU32Hz\n",
1348 pSink->pszName, pSink->PCMProps.cBits, pSink->PCMProps.cChannels, pSink->PCMProps.uHz));
1349
1350 memcpy(&pSink->PCMProps, pPCMProps, sizeof(PDMAUDIOPCMPROPS));
1351
1352 LogFlowFunc(("[%s]: New format %RU8 bit, %RU8 channels, %RU32Hz\n",
1353 pSink->pszName, pSink->PCMProps.cBits, pSink->PCMProps.cChannels, pSink->PCMProps.uHz));
1354
1355#ifdef VBOX_AUDIO_MIXER_WITH_MIXBUF
1356 /* Also update the sink's mixing buffer format. */
1357 AudioMixBufDestroy(&pSink->MixBuf);
1358 rc = AudioMixBufInit(&pSink->MixBuf, pSink->pszName, pPCMProps, _4K /** @todo Make configurable? */);
1359 if (RT_SUCCESS(rc))
1360 {
1361 PAUDMIXSTREAM pStream;
1362 RTListForEach(&pSink->lstStreams, pStream, AUDMIXSTREAM, Node)
1363 {
1364 /** @todo Invalidate mix buffers! */
1365 }
1366 }
1367#endif /* VBOX_AUDIO_MIXER_WITH_MIXBUF */
1368
1369 int rc2 = RTCritSectLeave(&pSink->CritSect);
1370 AssertRC(rc2);
1371
1372 LogFlowFuncLeaveRC(rc);
1373 return rc;
1374}
1375
1376/**
1377 * Set the volume of an individual sink.
1378 *
1379 * @returns IPRT status code.
1380 * @param pSink Sink to set volume for.
1381 * @param pVol Volume to set.
1382 */
1383int AudioMixerSinkSetVolume(PAUDMIXSINK pSink, PPDMAUDIOVOLUME pVol)
1384{
1385 AssertPtrReturn(pSink, VERR_INVALID_POINTER);
1386 AssertPtrReturn(pVol, VERR_INVALID_POINTER);
1387
1388 int rc = RTCritSectEnter(&pSink->CritSect);
1389 if (RT_FAILURE(rc))
1390 return rc;
1391
1392 memcpy(&pSink->Volume, pVol, sizeof(PDMAUDIOVOLUME));
1393
1394 LogFlowFunc(("[%s]: fMuted=%RTbool, lVol=%RU32, rVol=%RU32\n",
1395 pSink->pszName, pSink->Volume.fMuted, pSink->Volume.uLeft, pSink->Volume.uRight));
1396
1397 AssertPtr(pSink->pParent);
1398 rc = audioMixerSinkUpdateVolume(pSink, &pSink->pParent->VolMaster);
1399
1400 int rc2 = RTCritSectLeave(&pSink->CritSect);
1401 AssertRC(rc2);
1402
1403 return rc;
1404}
1405
1406/**
1407 * Updates a mixer sink, internal version.
1408 *
1409 * @returns IPRT status code.
1410 * @param pSink Mixer sink to update.
1411 */
1412static int audioMixerSinkUpdateInternal(PAUDMIXSINK pSink)
1413{
1414 AssertPtrReturn(pSink, VERR_INVALID_POINTER);
1415
1416 int rc = VINF_SUCCESS;
1417
1418#ifdef LOG_ENABLED
1419 char *pszStatus = dbgAudioMixerSinkStatusToStr(pSink->fStatus);
1420 Log3Func(("[%s] fStatus=%s\n", pSink->pszName, pszStatus));
1421 RTStrFree(pszStatus);
1422#endif
1423
1424 /* Sink disabled? Take a shortcut. */
1425 if (!(pSink->fStatus & AUDMIXSINK_STS_RUNNING))
1426 return rc;
1427
1428 /* Number of detected disabled streams of this sink. */
1429 uint8_t cStreamsDisabled = 0;
1430
1431 PAUDMIXSTREAM pMixStream, pMixStreamNext;
1432 RTListForEachSafe(&pSink->lstStreams, pMixStream, pMixStreamNext, AUDMIXSTREAM, Node)
1433 {
1434 PPDMAUDIOSTREAM pStream = pMixStream->pStream;
1435 AssertPtr(pStream);
1436
1437 PPDMIAUDIOCONNECTOR pConn = pMixStream->pConn;
1438 AssertPtr(pConn);
1439
1440 uint32_t csProc = 0;
1441
1442 int rc2 = pConn->pfnStreamIterate(pConn, pStream);
1443 if (RT_SUCCESS(rc2))
1444 {
1445 if (pSink->enmDir == AUDMIXSINKDIR_INPUT)
1446 {
1447 rc = pConn->pfnStreamCapture(pConn, pStream, &csProc);
1448 if (RT_FAILURE(rc2))
1449 {
1450 LogFunc(("%s: Failed capturing stream '%s', rc=%Rrc\n", pSink->pszName, pStream->szName, rc2));
1451 if (RT_SUCCESS(rc))
1452 rc = rc2;
1453 continue;
1454 }
1455
1456 if (csProc)
1457 pSink->fStatus |= AUDMIXSINK_STS_DIRTY;
1458 }
1459 else if (pSink->enmDir == AUDMIXSINKDIR_OUTPUT)
1460 {
1461 rc2 = pConn->pfnStreamPlay(pConn, pStream, &csProc);
1462 if (RT_FAILURE(rc2))
1463 {
1464 LogFunc(("%s: Failed playing stream '%s', rc=%Rrc\n", pSink->pszName, pStream->szName, rc2));
1465 if (RT_SUCCESS(rc))
1466 rc = rc2;
1467 continue;
1468 }
1469 }
1470 else
1471 {
1472 AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
1473 continue;
1474 }
1475
1476 rc2 = pConn->pfnStreamIterate(pConn, pStream);
1477 if (RT_FAILURE(rc2))
1478 {
1479 LogFunc(("%s: Failed re-iterating stream '%s', rc=%Rrc\n", pSink->pszName, pStream->szName, rc2));
1480 if (RT_SUCCESS(rc))
1481 rc = rc2;
1482 continue;
1483 }
1484
1485 PDMAUDIOSTRMSTS strmSts = pConn->pfnStreamGetStatus(pConn, pStream);
1486
1487 /* Is the stream not enabled and also is not in a pending disable state anymore? */
1488 if ( !(strmSts & PDMAUDIOSTRMSTS_FLAG_ENABLED)
1489 && !(strmSts & PDMAUDIOSTRMSTS_FLAG_PENDING_DISABLE))
1490 {
1491 cStreamsDisabled++;
1492 }
1493 }
1494
1495 Log3Func(("\t%s: cPlayed/cCaptured=%RU32, rc2=%Rrc\n", pStream->szName, csProc, rc2));
1496 }
1497
1498 Log3Func(("[%s] fPendingDisable=%RTbool, %RU8/%RU8 streams disabled\n",
1499 pSink->pszName, RT_BOOL(pSink->fStatus & AUDMIXSINK_STS_PENDING_DISABLE), cStreamsDisabled, pSink->cStreams));
1500
1501 /* Update last updated timestamp. */
1502 pSink->tsLastUpdatedMS = RTTimeMilliTS();
1503
1504 /* All streams disabled and the sink is in pending disable mode? */
1505 if ( cStreamsDisabled == pSink->cStreams
1506 && (pSink->fStatus & AUDMIXSINK_STS_PENDING_DISABLE))
1507 {
1508 audioMixerSinkReset(pSink);
1509 }
1510
1511 Log3Func(("[%s] cbReadable=%RU32, cbWritable=%RU32, rc=%Rrc\n",
1512 pSink->pszName, pSink->In.cbReadable, pSink->Out.cbWritable, rc));
1513
1514 return rc;
1515}
1516
1517/**
1518 * Updates (invalidates) a mixer sink.
1519 *
1520 * @returns IPRT status code.
1521 * @param pSink Mixer sink to update.
1522 */
1523int AudioMixerSinkUpdate(PAUDMIXSINK pSink)
1524{
1525 AssertPtrReturn(pSink, VERR_INVALID_POINTER);
1526
1527 int rc = RTCritSectEnter(&pSink->CritSect);
1528 if (RT_FAILURE(rc))
1529 return rc;
1530
1531 rc = audioMixerSinkUpdateInternal(pSink);
1532
1533 int rc2 = RTCritSectLeave(&pSink->CritSect);
1534 AssertRC(rc2);
1535
1536 return rc;
1537}
1538
1539/**
1540 * Updates the (master) volume of a mixer sink.
1541 *
1542 * @returns IPRT status code.
1543 * @param pSink Mixer sink to update volume for.
1544 * @param pVolMaster Master volume to set.
1545 */
1546static int audioMixerSinkUpdateVolume(PAUDMIXSINK pSink, const PPDMAUDIOVOLUME pVolMaster)
1547{
1548 AssertPtrReturn(pSink, VERR_INVALID_POINTER);
1549 AssertPtrReturn(pVolMaster, VERR_INVALID_POINTER);
1550
1551 LogFlowFunc(("[%s] Master fMuted=%RTbool, lVol=%RU32, rVol=%RU32\n",
1552 pSink->pszName, pVolMaster->fMuted, pVolMaster->uLeft, pVolMaster->uRight));
1553 LogFlowFunc(("[%s] fMuted=%RTbool, lVol=%RU32, rVol=%RU32 ",
1554 pSink->pszName, pSink->Volume.fMuted, pSink->Volume.uLeft, pSink->Volume.uRight));
1555
1556 /** @todo Very crude implementation for now -- needs more work! */
1557
1558 pSink->VolumeCombined.fMuted = pVolMaster->fMuted || pSink->Volume.fMuted;
1559
1560 pSink->VolumeCombined.uLeft = ( (pSink->Volume.uLeft ? pSink->Volume.uLeft : 1)
1561 * (pVolMaster->uLeft ? pVolMaster->uLeft : 1)) / PDMAUDIO_VOLUME_MAX;
1562
1563 pSink->VolumeCombined.uRight = ( (pSink->Volume.uRight ? pSink->Volume.uRight : 1)
1564 * (pVolMaster->uRight ? pVolMaster->uRight : 1)) / PDMAUDIO_VOLUME_MAX;
1565
1566 LogFlow(("-> fMuted=%RTbool, lVol=%RU32, rVol=%RU32\n",
1567 pSink->VolumeCombined.fMuted, pSink->VolumeCombined.uLeft, pSink->VolumeCombined.uRight));
1568
1569 /* Propagate new sink volume to all streams in the sink. */
1570 PAUDMIXSTREAM pMixStream;
1571 RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
1572 {
1573 int rc2 = pMixStream->pConn->pfnStreamSetVolume(pMixStream->pConn, pMixStream->pStream, &pSink->VolumeCombined);
1574 AssertRC(rc2);
1575 }
1576
1577 return VINF_SUCCESS;
1578}
1579
1580/**
1581 * Writes data to a mixer sink.
1582 *
1583 * @returns IPRT status code.
1584 * @param pSink Sink to write data to.
1585 * @param enmOp Mixer operation to use when writing data to the sink.
1586 * @param pvBuf Buffer containing the audio data to write.
1587 * @param cbBuf Size (in bytes) of the buffer containing the audio data.
1588 * @param pcbWritten Number of bytes written. Optional.
1589 */
1590int AudioMixerSinkWrite(PAUDMIXSINK pSink, AUDMIXOP enmOp, const void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten)
1591{
1592 RT_NOREF(enmOp);
1593 AssertPtrReturn(pSink, VERR_INVALID_POINTER);
1594 /* pcbWritten is optional. */
1595
1596 if (!pvBuf || !cbBuf)
1597 {
1598 if (pcbWritten)
1599 *pcbWritten = 0;
1600 return VINF_SUCCESS;
1601 }
1602
1603 int rc = RTCritSectEnter(&pSink->CritSect);
1604 if (RT_FAILURE(rc))
1605 return rc;
1606
1607 AssertMsg(pSink->fStatus & AUDMIXSINK_STS_RUNNING,
1608 ("%s: Can't write to a sink which is not running (anymore) (status 0x%x)\n", pSink->pszName, pSink->fStatus));
1609 AssertMsg(pSink->enmDir == AUDMIXSINKDIR_OUTPUT,
1610 ("%s: Can't write to a sink which is not an output sink\n", pSink->pszName));
1611
1612 Log3Func(("[%s] enmOp=%d, cbBuf=%RU32\n", pSink->pszName, enmOp, cbBuf));
1613
1614 uint32_t cbWritten = 0;
1615
1616 PAUDMIXSTREAM pMixStream;
1617 RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
1618 {
1619 if (!(pMixStream->pConn->pfnStreamGetStatus(pMixStream->pConn, pMixStream->pStream) & PDMAUDIOSTRMSTS_FLAG_ENABLED))
1620 {
1621 Log3Func(("\t%s: Stream '%s' disabled, skipping ...\n", pMixStream->pszName, pMixStream->pszName));
1622 continue;
1623 }
1624
1625 uint32_t cbProcessed = 0;
1626 int rc2 = pMixStream->pConn->pfnStreamWrite(pMixStream->pConn, pMixStream->pStream, pvBuf, cbBuf, &cbProcessed);
1627 if (RT_FAILURE(rc2))
1628 LogFunc(("[%s] Failed writing to stream '%s': %Rrc\n", pSink->pszName, pMixStream->pszName, rc2));
1629
1630 if (cbProcessed < cbBuf)
1631 LogFunc(("[%s] Only written %RU32/%RU32 bytes for stream '%s', rc=%Rrc\n",
1632 pSink->pszName, cbProcessed, cbBuf, pMixStream->pszName, rc2));
1633
1634 if (cbProcessed)
1635 {
1636 /* Set dirty bit. */
1637 pSink->fStatus |= AUDMIXSINK_STS_DIRTY;
1638 }
1639
1640 Log3Func(("\t%s: cbProcessed=%RU32\n", pMixStream->pszName, cbProcessed));
1641
1642 /*
1643 * Return the maximum bytes processed by all connected streams.
1644 * Streams which have processed less than the current maximum have to deal with
1645 * this themselves.
1646 */
1647 cbWritten = RT_MAX(cbWritten, cbProcessed);
1648 }
1649
1650 if (pcbWritten)
1651 *pcbWritten = cbWritten;
1652
1653 int rc2 = RTCritSectLeave(&pSink->CritSect);
1654 AssertRC(rc2);
1655
1656 return rc;
1657}
1658
1659/*********************************************************************************************************************************
1660 * Mixer Stream implementation.
1661 ********************************************************************************************************************************/
1662
1663/**
1664 * Controls a mixer stream, internal version.
1665 *
1666 * @returns IPRT status code.
1667 * @param pMixStream Mixer stream to control.
1668 * @param enmCmd Mixer stream command to use.
1669 * @param fCtl Additional control flags. Pass 0.
1670 */
1671int audioMixerStreamCtlInternal(PAUDMIXSTREAM pMixStream, PDMAUDIOSTREAMCMD enmCmd, uint32_t fCtl)
1672{
1673 AssertPtr(pMixStream->pConn);
1674 AssertPtr(pMixStream->pStream);
1675
1676 RT_NOREF(fCtl);
1677
1678 int rc = pMixStream->pConn->pfnStreamControl(pMixStream->pConn, pMixStream->pStream, enmCmd);
1679
1680 LogFlowFunc(("[%s] enmCmd=%ld, rc=%Rrc\n", pMixStream->pszName, enmCmd, rc));
1681
1682 return rc;
1683}
1684
1685/**
1686 * Controls a mixer stream.
1687 *
1688 * @returns IPRT status code.
1689 * @param pMixStream Mixer stream to control.
1690 * @param enmCmd Mixer stream command to use.
1691 * @param fCtl Additional control flags. Pass 0.
1692 */
1693int AudioMixerStreamCtl(PAUDMIXSTREAM pMixStream, PDMAUDIOSTREAMCMD enmCmd, uint32_t fCtl)
1694{
1695 RT_NOREF(fCtl);
1696 AssertPtrReturn(pMixStream, VERR_INVALID_POINTER);
1697 /** @todo Validate fCtl. */
1698
1699 int rc = RTCritSectEnter(&pMixStream->CritSect);
1700 if (RT_FAILURE(rc))
1701 return rc;
1702
1703 rc = audioMixerStreamCtlInternal(pMixStream, enmCmd, fCtl);
1704
1705 int rc2 = RTCritSectLeave(&pMixStream->CritSect);
1706 if (RT_SUCCESS(rc))
1707 rc = rc2;
1708
1709 return rc;
1710}
1711
1712/**
1713 * Destroys a mixer stream, internal version.
1714 *
1715 * @param pMixStream Mixer stream to destroy.
1716 */
1717static void audioMixerStreamDestroyInternal(PAUDMIXSTREAM pMixStream)
1718{
1719 AssertPtrReturnVoid(pMixStream);
1720
1721 LogFunc(("%s\n", pMixStream->pszName));
1722
1723 if (pMixStream->pConn) /* Stream has a connector interface present? */
1724 {
1725 if (pMixStream->pStream)
1726 {
1727 pMixStream->pConn->pfnStreamRelease(pMixStream->pConn, pMixStream->pStream);
1728 pMixStream->pConn->pfnStreamDestroy(pMixStream->pConn, pMixStream->pStream);
1729
1730 pMixStream->pStream = NULL;
1731 }
1732
1733 pMixStream->pConn = NULL;
1734 }
1735
1736 if (pMixStream->pszName)
1737 {
1738 RTStrFree(pMixStream->pszName);
1739 pMixStream->pszName = NULL;
1740 }
1741
1742 int rc2 = RTCritSectDelete(&pMixStream->CritSect);
1743 AssertRC(rc2);
1744
1745 RTMemFree(pMixStream);
1746 pMixStream = NULL;
1747}
1748
1749/**
1750 * Destroys a mixer stream.
1751 *
1752 * @param pMixStream Mixer stream to destroy.
1753 */
1754void AudioMixerStreamDestroy(PAUDMIXSTREAM pMixStream)
1755{
1756 if (!pMixStream)
1757 return;
1758
1759 int rc2 = RTCritSectEnter(&pMixStream->CritSect);
1760 AssertRC(rc2);
1761
1762 LogFunc(("%s\n", pMixStream->pszName));
1763
1764 if (pMixStream->pSink) /* Is the stream part of a sink? */
1765 {
1766 /* Save sink pointer, as after audioMixerSinkRemoveStreamInternal() the
1767 * pointer will be gone from the stream. */
1768 PAUDMIXSINK pSink = pMixStream->pSink;
1769
1770 rc2 = audioMixerSinkRemoveStreamInternal(pSink, pMixStream);
1771 if (RT_SUCCESS(rc2))
1772 {
1773 Assert(pSink->cStreams);
1774 pSink->cStreams--;
1775 }
1776 }
1777 else
1778 rc2 = VINF_SUCCESS;
1779
1780 int rc3 = RTCritSectLeave(&pMixStream->CritSect);
1781 AssertRC(rc3);
1782
1783 if (RT_SUCCESS(rc2))
1784 {
1785 audioMixerStreamDestroyInternal(pMixStream);
1786 pMixStream = NULL;
1787 }
1788
1789 LogFlowFunc(("Returning %Rrc\n", rc2));
1790}
1791
1792/**
1793 * Returns whether a mixer stream currently is active (playing/recording) or not.
1794 *
1795 * @returns @c true if playing/recording, @c false if not.
1796 * @param pMixStream Mixer stream to return status for.
1797 */
1798bool AudioMixerStreamIsActive(PAUDMIXSTREAM pMixStream)
1799{
1800 int rc2 = RTCritSectEnter(&pMixStream->CritSect);
1801 if (RT_FAILURE(rc2))
1802 return false;
1803
1804 AssertPtr(pMixStream->pConn);
1805 AssertPtr(pMixStream->pStream);
1806
1807 bool fIsActive;
1808
1809 if ( pMixStream->pConn
1810 && pMixStream->pStream
1811 && RT_BOOL(pMixStream->pConn->pfnStreamGetStatus(pMixStream->pConn, pMixStream->pStream) & PDMAUDIOSTRMSTS_FLAG_ENABLED))
1812 {
1813 fIsActive = true;
1814 }
1815 else
1816 fIsActive = false;
1817
1818 rc2 = RTCritSectLeave(&pMixStream->CritSect);
1819 AssertRC(rc2);
1820
1821 return fIsActive;
1822}
1823
1824/**
1825 * Returns whether a mixer stream is valid (e.g. initialized and in a working state) or not.
1826 *
1827 * @returns @c true if valid, @c false if not.
1828 * @param pMixStream Mixer stream to return status for.
1829 */
1830bool AudioMixerStreamIsValid(PAUDMIXSTREAM pMixStream)
1831{
1832 if (!pMixStream)
1833 return false;
1834
1835 int rc2 = RTCritSectEnter(&pMixStream->CritSect);
1836 if (RT_FAILURE(rc2))
1837 return false;
1838
1839 bool fIsValid;
1840
1841 if ( pMixStream->pConn
1842 && pMixStream->pStream
1843 && RT_BOOL(pMixStream->pConn->pfnStreamGetStatus(pMixStream->pConn, pMixStream->pStream) & PDMAUDIOSTRMSTS_FLAG_INITIALIZED))
1844 {
1845 fIsValid = true;
1846 }
1847 else
1848 fIsValid = false;
1849
1850 rc2 = RTCritSectLeave(&pMixStream->CritSect);
1851 AssertRC(rc2);
1852
1853 return fIsValid;
1854}
1855
Note: See TracBrowser for help on using the repository browser.

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