1 | /* $Id: AudioMixer.cpp 82406 2019-12-05 00:47:02Z vboxsync $ */
|
---|
2 | /** @file
|
---|
3 | * Audio mixing routines for multiplexing audio sources in device emulations.
|
---|
4 | *
|
---|
5 | * == Overview
|
---|
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)
|
---|
9 | * and audio sinks (output).
|
---|
10 | *
|
---|
11 | * Think of this mixer as kind of a high(er) level interface for the audio
|
---|
12 | * connector interface, abstracting common tasks such as creating and managing
|
---|
13 | * various audio sources and sinks. This mixer class is purely optional and can
|
---|
14 | * be left out when implementing a new device emulation, using only the audi
|
---|
15 | * connector interface instead. For example, the SB16 emulation does not use
|
---|
16 | * this mixer and does all its 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 | * == Playback
|
---|
31 | *
|
---|
32 | * For output sinks there can be one or more mixing stream attached.
|
---|
33 | * As the host sets the overall pace for the device emulation (virtual time
|
---|
34 | * in the guest OS vs. real time on the host OS), an output mixing sink
|
---|
35 | * needs to make sure that all connected output streams are able to accept
|
---|
36 | * all the same amount of data at a time.
|
---|
37 | *
|
---|
38 | * This is called synchronous multiplexing.
|
---|
39 | *
|
---|
40 | * A mixing sink employs an own audio mixing buffer, which in turn can convert
|
---|
41 | * the audio (output) data supplied from the device emulation into the sink's
|
---|
42 | * audio format. As all connected mixing streams in theory could have the same
|
---|
43 | * audio format as the mixing sink (parent), this can save processing time when
|
---|
44 | * it comes to serving a lot of mixing streams at once. That way only one
|
---|
45 | * conversion must be done, instead of each stream having to iterate over the
|
---|
46 | * data.
|
---|
47 | *
|
---|
48 | * == Recording
|
---|
49 | *
|
---|
50 | * For input sinks only one mixing stream at a time can be the recording
|
---|
51 | * source currently. A recording source is optional, e.g. it is possible to
|
---|
52 | * have no current recording source set. Switching to a different recording
|
---|
53 | * source at runtime is possible.
|
---|
54 | */
|
---|
55 |
|
---|
56 | /*
|
---|
57 | * Copyright (C) 2014-2019 Oracle Corporation
|
---|
58 | *
|
---|
59 | * This file is part of VirtualBox Open Source Edition (OSE), as
|
---|
60 | * available from http://www.virtualbox.org. This file is free software;
|
---|
61 | * you can redistribute it and/or modify it under the terms of the GNU
|
---|
62 | * General Public License (GPL) as published by the Free Software
|
---|
63 | * Foundation, in version 2 as it comes in the "COPYING" file of the
|
---|
64 | * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
|
---|
65 | * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
|
---|
66 | */
|
---|
67 |
|
---|
68 |
|
---|
69 | /*********************************************************************************************************************************
|
---|
70 | * Header Files *
|
---|
71 | *********************************************************************************************************************************/
|
---|
72 | #define LOG_GROUP LOG_GROUP_AUDIO_MIXER
|
---|
73 | #include <VBox/log.h>
|
---|
74 | #include "AudioMixer.h"
|
---|
75 | #include "AudioMixBuffer.h"
|
---|
76 | #include "DrvAudio.h"
|
---|
77 |
|
---|
78 | #include <VBox/vmm/pdm.h>
|
---|
79 | #include <VBox/err.h>
|
---|
80 | #include <VBox/vmm/mm.h>
|
---|
81 | #include <VBox/vmm/pdmaudioifs.h>
|
---|
82 |
|
---|
83 | #include <iprt/alloc.h>
|
---|
84 | #include <iprt/asm-math.h>
|
---|
85 | #include <iprt/assert.h>
|
---|
86 | #include <iprt/string.h>
|
---|
87 |
|
---|
88 |
|
---|
89 | /*********************************************************************************************************************************
|
---|
90 | * Internal Functions *
|
---|
91 | *********************************************************************************************************************************/
|
---|
92 | static int audioMixerRemoveSinkInternal(PAUDIOMIXER pMixer, PAUDMIXSINK pSink);
|
---|
93 |
|
---|
94 | static void audioMixerSinkDestroyInternal(PAUDMIXSINK pSink);
|
---|
95 | static int audioMixerSinkUpdateVolume(PAUDMIXSINK pSink, const PPDMAUDIOVOLUME pVolMaster);
|
---|
96 | static void audioMixerSinkRemoveAllStreamsInternal(PAUDMIXSINK pSink);
|
---|
97 | static int audioMixerSinkRemoveStreamInternal(PAUDMIXSINK pSink, PAUDMIXSTREAM pStream);
|
---|
98 | static void audioMixerSinkReset(PAUDMIXSINK pSink);
|
---|
99 | static int audioMixerSinkSetRecSourceInternal(PAUDMIXSINK pSink, PAUDMIXSTREAM pStream);
|
---|
100 | static int audioMixerSinkUpdateInternal(PAUDMIXSINK pSink);
|
---|
101 | static int audioMixerSinkMultiplexSync(PAUDMIXSINK pSink, AUDMIXOP enmOp, const void *pvBuf, uint32_t cbBuf, uint32_t *pcbWrittenMin);
|
---|
102 | static int audioMixerSinkWriteToStream(PAUDMIXSINK pSink, PAUDMIXSTREAM pMixStream);
|
---|
103 | static int audioMixerSinkWriteToStreamEx(PAUDMIXSINK pSink, PAUDMIXSTREAM pMixStream, uint32_t cbToWrite, uint32_t *pcbWritten);
|
---|
104 |
|
---|
105 | static int audioMixerStreamCtlInternal(PAUDMIXSTREAM pMixStream, PDMAUDIOSTREAMCMD enmCmd, uint32_t fCtl);
|
---|
106 | static void audioMixerStreamDestroyInternal(PAUDMIXSTREAM pStream);
|
---|
107 | static int audioMixerStreamUpdateStatus(PAUDMIXSTREAM pMixStream);
|
---|
108 |
|
---|
109 |
|
---|
110 | /**
|
---|
111 | * Converts a mixer sink status to a string.
|
---|
112 | *
|
---|
113 | * @returns Stringified mixer sink status flags. Must be free'd with RTStrFree().
|
---|
114 | * "NONE" if no flags set.
|
---|
115 | * @param fStatus Mixer sink status to convert.
|
---|
116 | */
|
---|
117 | static char *dbgAudioMixerSinkStatusToStr(AUDMIXSINKSTS fStatus)
|
---|
118 | {
|
---|
119 | #define APPEND_FLAG_TO_STR(_aFlag) \
|
---|
120 | if (fStatus & AUDMIXSINK_STS_##_aFlag) \
|
---|
121 | { \
|
---|
122 | if (pszFlags) \
|
---|
123 | { \
|
---|
124 | rc2 = RTStrAAppend(&pszFlags, " "); \
|
---|
125 | if (RT_FAILURE(rc2)) \
|
---|
126 | break; \
|
---|
127 | } \
|
---|
128 | \
|
---|
129 | rc2 = RTStrAAppend(&pszFlags, #_aFlag); \
|
---|
130 | if (RT_FAILURE(rc2)) \
|
---|
131 | break; \
|
---|
132 | } \
|
---|
133 |
|
---|
134 | char *pszFlags = NULL;
|
---|
135 | int rc2 = VINF_SUCCESS;
|
---|
136 |
|
---|
137 | if (fStatus == AUDMIXSINK_STS_NONE) /* This is special, as this is value 0. */
|
---|
138 | {
|
---|
139 | rc2 = RTStrAAppend(&pszFlags, "NONE");
|
---|
140 | }
|
---|
141 | else
|
---|
142 | {
|
---|
143 | do
|
---|
144 | {
|
---|
145 | APPEND_FLAG_TO_STR(RUNNING);
|
---|
146 | APPEND_FLAG_TO_STR(PENDING_DISABLE);
|
---|
147 | APPEND_FLAG_TO_STR(DIRTY);
|
---|
148 |
|
---|
149 | } while (0);
|
---|
150 | }
|
---|
151 |
|
---|
152 | if ( RT_FAILURE(rc2)
|
---|
153 | && pszFlags)
|
---|
154 | {
|
---|
155 | RTStrFree(pszFlags);
|
---|
156 | pszFlags = NULL;
|
---|
157 | }
|
---|
158 |
|
---|
159 | #undef APPEND_FLAG_TO_STR
|
---|
160 |
|
---|
161 | return pszFlags;
|
---|
162 | }
|
---|
163 |
|
---|
164 | /**
|
---|
165 | * Creates an audio sink and attaches it to the given mixer.
|
---|
166 | *
|
---|
167 | * @returns IPRT status code.
|
---|
168 | * @param pMixer Mixer to attach created sink to.
|
---|
169 | * @param pszName Name of the sink to create.
|
---|
170 | * @param enmDir Direction of the sink to create.
|
---|
171 | * @param ppSink Pointer which returns the created sink on success.
|
---|
172 | */
|
---|
173 | int AudioMixerCreateSink(PAUDIOMIXER pMixer, const char *pszName, AUDMIXSINKDIR enmDir, PAUDMIXSINK *ppSink)
|
---|
174 | {
|
---|
175 | AssertPtrReturn(pMixer, VERR_INVALID_POINTER);
|
---|
176 | AssertPtrReturn(pszName, VERR_INVALID_POINTER);
|
---|
177 | /* ppSink is optional. */
|
---|
178 |
|
---|
179 | int rc = RTCritSectEnter(&pMixer->CritSect);
|
---|
180 | if (RT_FAILURE(rc))
|
---|
181 | return rc;
|
---|
182 |
|
---|
183 | PAUDMIXSINK pSink = (PAUDMIXSINK)RTMemAllocZ(sizeof(AUDMIXSINK));
|
---|
184 | if (pSink)
|
---|
185 | {
|
---|
186 | pSink->pszName = RTStrDup(pszName);
|
---|
187 | if (!pSink->pszName)
|
---|
188 | rc = VERR_NO_MEMORY;
|
---|
189 |
|
---|
190 | if (RT_SUCCESS(rc))
|
---|
191 | rc = RTCritSectInit(&pSink->CritSect);
|
---|
192 |
|
---|
193 | if (RT_SUCCESS(rc))
|
---|
194 | {
|
---|
195 | pSink->pParent = pMixer;
|
---|
196 | pSink->enmDir = enmDir;
|
---|
197 | RTListInit(&pSink->lstStreams);
|
---|
198 |
|
---|
199 | /* Set initial volume to max. */
|
---|
200 | pSink->Volume.fMuted = false;
|
---|
201 | pSink->Volume.uLeft = PDMAUDIO_VOLUME_MAX;
|
---|
202 | pSink->Volume.uRight = PDMAUDIO_VOLUME_MAX;
|
---|
203 |
|
---|
204 | /* Ditto for the combined volume. */
|
---|
205 | pSink->VolumeCombined.fMuted = false;
|
---|
206 | pSink->VolumeCombined.uLeft = PDMAUDIO_VOLUME_MAX;
|
---|
207 | pSink->VolumeCombined.uRight = PDMAUDIO_VOLUME_MAX;
|
---|
208 |
|
---|
209 | RTListAppend(&pMixer->lstSinks, &pSink->Node);
|
---|
210 | pMixer->cSinks++;
|
---|
211 |
|
---|
212 | LogFlowFunc(("pMixer=%p, pSink=%p, cSinks=%RU8\n",
|
---|
213 | pMixer, pSink, pMixer->cSinks));
|
---|
214 |
|
---|
215 | if (ppSink)
|
---|
216 | *ppSink = pSink;
|
---|
217 | }
|
---|
218 |
|
---|
219 | if (RT_FAILURE(rc))
|
---|
220 | {
|
---|
221 | RTCritSectDelete(&pSink->CritSect);
|
---|
222 |
|
---|
223 | if (pSink)
|
---|
224 | {
|
---|
225 | RTMemFree(pSink);
|
---|
226 | pSink = NULL;
|
---|
227 | }
|
---|
228 | }
|
---|
229 | }
|
---|
230 | else
|
---|
231 | rc = VERR_NO_MEMORY;
|
---|
232 |
|
---|
233 | int rc2 = RTCritSectLeave(&pMixer->CritSect);
|
---|
234 | AssertRC(rc2);
|
---|
235 |
|
---|
236 | return rc;
|
---|
237 | }
|
---|
238 |
|
---|
239 | /**
|
---|
240 | * Creates an audio mixer.
|
---|
241 | *
|
---|
242 | * @returns IPRT status code.
|
---|
243 | * @param pszName Name of the audio mixer.
|
---|
244 | * @param fFlags Creation flags. Not used at the moment and must be 0.
|
---|
245 | * @param ppMixer Pointer which returns the created mixer object.
|
---|
246 | */
|
---|
247 | int AudioMixerCreate(const char *pszName, uint32_t fFlags, PAUDIOMIXER *ppMixer)
|
---|
248 | {
|
---|
249 | RT_NOREF(fFlags);
|
---|
250 | AssertPtrReturn(pszName, VERR_INVALID_POINTER);
|
---|
251 | /** @todo Add fFlags validation. */
|
---|
252 | AssertPtrReturn(ppMixer, VERR_INVALID_POINTER);
|
---|
253 |
|
---|
254 | int rc = VINF_SUCCESS;
|
---|
255 |
|
---|
256 | PAUDIOMIXER pMixer = (PAUDIOMIXER)RTMemAllocZ(sizeof(AUDIOMIXER));
|
---|
257 | if (pMixer)
|
---|
258 | {
|
---|
259 | pMixer->pszName = RTStrDup(pszName);
|
---|
260 | if (!pMixer->pszName)
|
---|
261 | rc = VERR_NO_MEMORY;
|
---|
262 |
|
---|
263 | if (RT_SUCCESS(rc))
|
---|
264 | rc = RTCritSectInit(&pMixer->CritSect);
|
---|
265 |
|
---|
266 | if (RT_SUCCESS(rc))
|
---|
267 | {
|
---|
268 | pMixer->cSinks = 0;
|
---|
269 | RTListInit(&pMixer->lstSinks);
|
---|
270 |
|
---|
271 | /* Set master volume to the max. */
|
---|
272 | pMixer->VolMaster.fMuted = false;
|
---|
273 | pMixer->VolMaster.uLeft = PDMAUDIO_VOLUME_MAX;
|
---|
274 | pMixer->VolMaster.uRight = PDMAUDIO_VOLUME_MAX;
|
---|
275 |
|
---|
276 | LogFlowFunc(("Created mixer '%s'\n", pMixer->pszName));
|
---|
277 |
|
---|
278 | *ppMixer = pMixer;
|
---|
279 | }
|
---|
280 | else
|
---|
281 | RTMemFree(pMixer);
|
---|
282 | }
|
---|
283 | else
|
---|
284 | rc = VERR_NO_MEMORY;
|
---|
285 |
|
---|
286 | LogFlowFuncLeaveRC(rc);
|
---|
287 | return rc;
|
---|
288 | }
|
---|
289 |
|
---|
290 | /**
|
---|
291 | * Helper function for the internal debugger to print the mixer's current
|
---|
292 | * state, along with the attached sinks.
|
---|
293 | *
|
---|
294 | * @param pMixer Mixer to print debug output for.
|
---|
295 | * @param pHlp Debug info helper to use.
|
---|
296 | * @param pszArgs Optional arguments. Not being used at the moment.
|
---|
297 | */
|
---|
298 | void AudioMixerDebug(PAUDIOMIXER pMixer, PCDBGFINFOHLP pHlp, const char *pszArgs)
|
---|
299 | {
|
---|
300 | RT_NOREF(pszArgs);
|
---|
301 | PAUDMIXSINK pSink;
|
---|
302 | unsigned iSink = 0;
|
---|
303 |
|
---|
304 | int rc2 = RTCritSectEnter(&pMixer->CritSect);
|
---|
305 | if (RT_FAILURE(rc2))
|
---|
306 | return;
|
---|
307 |
|
---|
308 | pHlp->pfnPrintf(pHlp, "[Master] %s: lVol=%u, rVol=%u, fMuted=%RTbool\n", pMixer->pszName,
|
---|
309 | pMixer->VolMaster.uLeft, pMixer->VolMaster.uRight, pMixer->VolMaster.fMuted);
|
---|
310 |
|
---|
311 | RTListForEach(&pMixer->lstSinks, pSink, AUDMIXSINK, Node)
|
---|
312 | {
|
---|
313 | pHlp->pfnPrintf(pHlp, "[Sink %u] %s: lVol=%u, rVol=%u, fMuted=%RTbool\n", iSink, pSink->pszName,
|
---|
314 | pSink->Volume.uLeft, pSink->Volume.uRight, pSink->Volume.fMuted);
|
---|
315 | ++iSink;
|
---|
316 | }
|
---|
317 |
|
---|
318 | rc2 = RTCritSectLeave(&pMixer->CritSect);
|
---|
319 | AssertRC(rc2);
|
---|
320 | }
|
---|
321 |
|
---|
322 | /**
|
---|
323 | * Destroys an audio mixer.
|
---|
324 | *
|
---|
325 | * @param pMixer Audio mixer to destroy.
|
---|
326 | */
|
---|
327 | void AudioMixerDestroy(PAUDIOMIXER pMixer)
|
---|
328 | {
|
---|
329 | if (!pMixer)
|
---|
330 | return;
|
---|
331 |
|
---|
332 | int rc2 = RTCritSectEnter(&pMixer->CritSect);
|
---|
333 | AssertRC(rc2);
|
---|
334 |
|
---|
335 | LogFlowFunc(("Destroying %s ...\n", pMixer->pszName));
|
---|
336 |
|
---|
337 | PAUDMIXSINK pSink, pSinkNext;
|
---|
338 | RTListForEachSafe(&pMixer->lstSinks, pSink, pSinkNext, AUDMIXSINK, Node)
|
---|
339 | {
|
---|
340 | /* Save a pointer to the sink to remove, as pSink
|
---|
341 | * will not be valid anymore after calling audioMixerRemoveSinkInternal(). */
|
---|
342 | PAUDMIXSINK pSinkToRemove = pSink;
|
---|
343 |
|
---|
344 | audioMixerRemoveSinkInternal(pMixer, pSinkToRemove);
|
---|
345 | audioMixerSinkDestroyInternal(pSinkToRemove);
|
---|
346 | }
|
---|
347 |
|
---|
348 | pMixer->cSinks = 0;
|
---|
349 |
|
---|
350 | if (pMixer->pszName)
|
---|
351 | {
|
---|
352 | RTStrFree(pMixer->pszName);
|
---|
353 | pMixer->pszName = NULL;
|
---|
354 | }
|
---|
355 |
|
---|
356 | rc2 = RTCritSectLeave(&pMixer->CritSect);
|
---|
357 | AssertRC(rc2);
|
---|
358 |
|
---|
359 | RTCritSectDelete(&pMixer->CritSect);
|
---|
360 |
|
---|
361 | RTMemFree(pMixer);
|
---|
362 | pMixer = NULL;
|
---|
363 | }
|
---|
364 |
|
---|
365 | /**
|
---|
366 | * Invalidates all internal data, internal version.
|
---|
367 | *
|
---|
368 | * @returns IPRT status code.
|
---|
369 | * @param pMixer Mixer to invalidate data for.
|
---|
370 | */
|
---|
371 | int audioMixerInvalidateInternal(PAUDIOMIXER pMixer)
|
---|
372 | {
|
---|
373 | AssertPtrReturn(pMixer, VERR_INVALID_POINTER);
|
---|
374 |
|
---|
375 | LogFlowFunc(("[%s]\n", pMixer->pszName));
|
---|
376 |
|
---|
377 | /* Propagate new master volume to all connected sinks. */
|
---|
378 | PAUDMIXSINK pSink;
|
---|
379 | RTListForEach(&pMixer->lstSinks, pSink, AUDMIXSINK, Node)
|
---|
380 | {
|
---|
381 | int rc2 = audioMixerSinkUpdateVolume(pSink, &pMixer->VolMaster);
|
---|
382 | AssertRC(rc2);
|
---|
383 | }
|
---|
384 |
|
---|
385 | return VINF_SUCCESS;
|
---|
386 | }
|
---|
387 |
|
---|
388 | /**
|
---|
389 | * Invalidates all internal data.
|
---|
390 | *
|
---|
391 | * @returns IPRT status code.
|
---|
392 | * @param pMixer Mixer to invalidate data for.
|
---|
393 | */
|
---|
394 | void AudioMixerInvalidate(PAUDIOMIXER pMixer)
|
---|
395 | {
|
---|
396 | AssertPtrReturnVoid(pMixer);
|
---|
397 |
|
---|
398 | int rc2 = RTCritSectEnter(&pMixer->CritSect);
|
---|
399 | AssertRC(rc2);
|
---|
400 |
|
---|
401 | LogFlowFunc(("[%s]\n", pMixer->pszName));
|
---|
402 |
|
---|
403 | rc2 = audioMixerInvalidateInternal(pMixer);
|
---|
404 | AssertRC(rc2);
|
---|
405 |
|
---|
406 | rc2 = RTCritSectLeave(&pMixer->CritSect);
|
---|
407 | AssertRC(rc2);
|
---|
408 | }
|
---|
409 |
|
---|
410 | /**
|
---|
411 | * Removes a formerly attached audio sink for an audio mixer, internal version.
|
---|
412 | *
|
---|
413 | * @returns IPRT status code.
|
---|
414 | * @param pMixer Mixer to remove sink from.
|
---|
415 | * @param pSink Sink to remove.
|
---|
416 | */
|
---|
417 | static int audioMixerRemoveSinkInternal(PAUDIOMIXER pMixer, PAUDMIXSINK pSink)
|
---|
418 | {
|
---|
419 | AssertPtrReturn(pMixer, VERR_INVALID_POINTER);
|
---|
420 | if (!pSink)
|
---|
421 | return VERR_NOT_FOUND;
|
---|
422 |
|
---|
423 | AssertMsgReturn(pSink->pParent == pMixer, ("%s: Is not part of mixer '%s'\n",
|
---|
424 | pSink->pszName, pMixer->pszName), VERR_NOT_FOUND);
|
---|
425 |
|
---|
426 | LogFlowFunc(("[%s] pSink=%s, cSinks=%RU8\n",
|
---|
427 | pMixer->pszName, pSink->pszName, pMixer->cSinks));
|
---|
428 |
|
---|
429 | /* Remove sink from mixer. */
|
---|
430 | RTListNodeRemove(&pSink->Node);
|
---|
431 | Assert(pMixer->cSinks);
|
---|
432 |
|
---|
433 | /* Set mixer to NULL so that we know we're not part of any mixer anymore. */
|
---|
434 | pSink->pParent = NULL;
|
---|
435 |
|
---|
436 | return VINF_SUCCESS;
|
---|
437 | }
|
---|
438 |
|
---|
439 | /**
|
---|
440 | * Removes a formerly attached audio sink for an audio mixer.
|
---|
441 | *
|
---|
442 | * @returns IPRT status code.
|
---|
443 | * @param pMixer Mixer to remove sink from.
|
---|
444 | * @param pSink Sink to remove.
|
---|
445 | */
|
---|
446 | void AudioMixerRemoveSink(PAUDIOMIXER pMixer, PAUDMIXSINK pSink)
|
---|
447 | {
|
---|
448 | int rc2 = RTCritSectEnter(&pMixer->CritSect);
|
---|
449 | AssertRC(rc2);
|
---|
450 |
|
---|
451 | audioMixerSinkRemoveAllStreamsInternal(pSink);
|
---|
452 | audioMixerRemoveSinkInternal(pMixer, pSink);
|
---|
453 |
|
---|
454 | rc2 = RTCritSectLeave(&pMixer->CritSect);
|
---|
455 | }
|
---|
456 |
|
---|
457 | /**
|
---|
458 | * Sets the mixer's master volume.
|
---|
459 | *
|
---|
460 | * @returns IPRT status code.
|
---|
461 | * @param pMixer Mixer to set master volume for.
|
---|
462 | * @param pVol Volume to set.
|
---|
463 | */
|
---|
464 | int AudioMixerSetMasterVolume(PAUDIOMIXER pMixer, PPDMAUDIOVOLUME pVol)
|
---|
465 | {
|
---|
466 | AssertPtrReturn(pMixer, VERR_INVALID_POINTER);
|
---|
467 | AssertPtrReturn(pVol, VERR_INVALID_POINTER);
|
---|
468 |
|
---|
469 | int rc = RTCritSectEnter(&pMixer->CritSect);
|
---|
470 | if (RT_FAILURE(rc))
|
---|
471 | return rc;
|
---|
472 |
|
---|
473 | memcpy(&pMixer->VolMaster, pVol, sizeof(PDMAUDIOVOLUME));
|
---|
474 |
|
---|
475 | LogFlowFunc(("[%s] lVol=%RU32, rVol=%RU32 => fMuted=%RTbool, lVol=%RU32, rVol=%RU32\n",
|
---|
476 | pMixer->pszName, pVol->uLeft, pVol->uRight,
|
---|
477 | pMixer->VolMaster.fMuted, pMixer->VolMaster.uLeft, pMixer->VolMaster.uRight));
|
---|
478 |
|
---|
479 | rc = audioMixerInvalidateInternal(pMixer);
|
---|
480 |
|
---|
481 | int rc2 = RTCritSectLeave(&pMixer->CritSect);
|
---|
482 | AssertRC(rc2);
|
---|
483 |
|
---|
484 | return rc;
|
---|
485 | }
|
---|
486 |
|
---|
487 | /*********************************************************************************************************************************
|
---|
488 | * Mixer Sink implementation.
|
---|
489 | ********************************************************************************************************************************/
|
---|
490 |
|
---|
491 | /**
|
---|
492 | * Adds an audio stream to a specific audio sink.
|
---|
493 | *
|
---|
494 | * @returns IPRT status code.
|
---|
495 | * @param pSink Sink to add audio stream to.
|
---|
496 | * @param pStream Stream to add.
|
---|
497 | */
|
---|
498 | int AudioMixerSinkAddStream(PAUDMIXSINK pSink, PAUDMIXSTREAM pStream)
|
---|
499 | {
|
---|
500 | AssertPtrReturn(pSink, VERR_INVALID_POINTER);
|
---|
501 | AssertPtrReturn(pStream, VERR_INVALID_POINTER);
|
---|
502 |
|
---|
503 | int rc = RTCritSectEnter(&pSink->CritSect);
|
---|
504 | if (RT_FAILURE(rc))
|
---|
505 | return rc;
|
---|
506 |
|
---|
507 | if (pSink->cStreams == UINT8_MAX) /* 255 streams per sink max. */
|
---|
508 | {
|
---|
509 | int rc2 = RTCritSectLeave(&pSink->CritSect);
|
---|
510 | AssertRC(rc2);
|
---|
511 |
|
---|
512 | return VERR_NO_MORE_HANDLES;
|
---|
513 | }
|
---|
514 |
|
---|
515 | LogFlowFuncEnter();
|
---|
516 |
|
---|
517 | /** @todo Check if stream already is assigned to (another) sink. */
|
---|
518 |
|
---|
519 | /* If the sink is running and not in pending disable mode,
|
---|
520 | * make sure that the added stream also is enabled. */
|
---|
521 | if ( (pSink->fStatus & AUDMIXSINK_STS_RUNNING)
|
---|
522 | && !(pSink->fStatus & AUDMIXSINK_STS_PENDING_DISABLE))
|
---|
523 | {
|
---|
524 | rc = audioMixerStreamCtlInternal(pStream, PDMAUDIOSTREAMCMD_ENABLE, AUDMIXSTRMCTL_F_NONE);
|
---|
525 | }
|
---|
526 |
|
---|
527 | if (RT_SUCCESS(rc))
|
---|
528 | {
|
---|
529 | /* Apply the sink's combined volume to the stream. */
|
---|
530 | rc = pStream->pConn->pfnStreamSetVolume(pStream->pConn, pStream->pStream, &pSink->VolumeCombined);
|
---|
531 | AssertRC(rc);
|
---|
532 | }
|
---|
533 |
|
---|
534 | if (RT_SUCCESS(rc))
|
---|
535 | {
|
---|
536 | /* Save pointer to sink the stream is attached to. */
|
---|
537 | pStream->pSink = pSink;
|
---|
538 |
|
---|
539 | /* Append stream to sink's list. */
|
---|
540 | RTListAppend(&pSink->lstStreams, &pStream->Node);
|
---|
541 | pSink->cStreams++;
|
---|
542 | }
|
---|
543 |
|
---|
544 | LogFlowFunc(("[%s] cStreams=%RU8, rc=%Rrc\n", pSink->pszName, pSink->cStreams, rc));
|
---|
545 |
|
---|
546 | int rc2 = RTCritSectLeave(&pSink->CritSect);
|
---|
547 | AssertRC(rc2);
|
---|
548 |
|
---|
549 | return rc;
|
---|
550 | }
|
---|
551 |
|
---|
552 | /**
|
---|
553 | * Creates an audio mixer stream.
|
---|
554 | *
|
---|
555 | * @returns IPRT status code.
|
---|
556 | * @param pSink Sink to use for creating the stream.
|
---|
557 | * @param pConn Audio connector interface to use.
|
---|
558 | * @param pCfg Audio stream configuration to use.
|
---|
559 | * @param fFlags Stream flags. Currently unused, set to 0.
|
---|
560 | * @param ppStream Pointer which receives the newly created audio stream.
|
---|
561 | */
|
---|
562 | int AudioMixerSinkCreateStream(PAUDMIXSINK pSink,
|
---|
563 | PPDMIAUDIOCONNECTOR pConn, PPDMAUDIOSTREAMCFG pCfg, AUDMIXSTREAMFLAGS fFlags, PAUDMIXSTREAM *ppStream)
|
---|
564 | {
|
---|
565 | AssertPtrReturn(pSink, VERR_INVALID_POINTER);
|
---|
566 | AssertPtrReturn(pConn, VERR_INVALID_POINTER);
|
---|
567 | AssertPtrReturn(pCfg, VERR_INVALID_POINTER);
|
---|
568 | /** @todo Validate fFlags. */
|
---|
569 | /* ppStream is optional. */
|
---|
570 |
|
---|
571 | if (pConn->pfnGetStatus(pConn, PDMAUDIODIR_ANY) == PDMAUDIOBACKENDSTS_NOT_ATTACHED)
|
---|
572 | return VERR_AUDIO_BACKEND_NOT_ATTACHED;
|
---|
573 |
|
---|
574 | PAUDMIXSTREAM pMixStream = (PAUDMIXSTREAM)RTMemAllocZ(sizeof(AUDMIXSTREAM));
|
---|
575 | if (!pMixStream)
|
---|
576 | return VERR_NO_MEMORY;
|
---|
577 |
|
---|
578 | pMixStream->pszName = RTStrDup(pCfg->szName);
|
---|
579 | if (!pMixStream->pszName)
|
---|
580 | {
|
---|
581 | RTMemFree(pMixStream);
|
---|
582 | return VERR_NO_MEMORY;
|
---|
583 | }
|
---|
584 |
|
---|
585 | int rc = RTCritSectEnter(&pSink->CritSect);
|
---|
586 | if (RT_FAILURE(rc))
|
---|
587 | return rc;
|
---|
588 |
|
---|
589 | LogFlowFunc(("[%s] fFlags=0x%x (enmDir=%ld, %u bits, %RU8 channels, %RU32Hz)\n",
|
---|
590 | pSink->pszName, fFlags, pCfg->enmDir, pCfg->Props.cbSample * 8, pCfg->Props.cChannels, pCfg->Props.uHz));
|
---|
591 |
|
---|
592 | /*
|
---|
593 | * Initialize the host-side configuration for the stream to be created.
|
---|
594 | * Always use the sink's PCM audio format as the host side when creating a stream for it.
|
---|
595 | */
|
---|
596 | AssertMsg(DrvAudioHlpPCMPropsAreValid(&pSink->PCMProps),
|
---|
597 | ("%s: Does not (yet) have a format set when it must\n", pSink->pszName));
|
---|
598 |
|
---|
599 | PDMAUDIOSTREAMCFG CfgHost;
|
---|
600 | rc = DrvAudioHlpPCMPropsToStreamCfg(&pSink->PCMProps, &CfgHost);
|
---|
601 | AssertRCReturn(rc, rc);
|
---|
602 |
|
---|
603 | /* Apply the sink's direction for the configuration to use to
|
---|
604 | * create the stream. */
|
---|
605 | if (pSink->enmDir == AUDMIXSINKDIR_INPUT)
|
---|
606 | {
|
---|
607 | CfgHost.enmDir = PDMAUDIODIR_IN;
|
---|
608 | CfgHost.u.enmSrc = pCfg->u.enmSrc;
|
---|
609 | CfgHost.enmLayout = pCfg->enmLayout;
|
---|
610 | }
|
---|
611 | else
|
---|
612 | {
|
---|
613 | CfgHost.enmDir = PDMAUDIODIR_OUT;
|
---|
614 | CfgHost.u.enmDst = pCfg->u.enmDst;
|
---|
615 | CfgHost.enmLayout = pCfg->enmLayout;
|
---|
616 | }
|
---|
617 |
|
---|
618 | RTStrPrintf(CfgHost.szName, sizeof(CfgHost.szName), "%s", pCfg->szName);
|
---|
619 |
|
---|
620 | rc = RTCritSectInit(&pMixStream->CritSect);
|
---|
621 | if (RT_SUCCESS(rc))
|
---|
622 | {
|
---|
623 | PPDMAUDIOSTREAM pStream;
|
---|
624 | rc = pConn->pfnStreamCreate(pConn, &CfgHost, pCfg, &pStream);
|
---|
625 | if (RT_SUCCESS(rc))
|
---|
626 | {
|
---|
627 | /* Save the audio stream pointer to this mixing stream. */
|
---|
628 | pMixStream->pStream = pStream;
|
---|
629 |
|
---|
630 | /* Increase the stream's reference count to let others know
|
---|
631 | * we're reyling on it to be around now. */
|
---|
632 | pConn->pfnStreamRetain(pConn, pStream);
|
---|
633 | }
|
---|
634 | }
|
---|
635 |
|
---|
636 | if (RT_SUCCESS(rc))
|
---|
637 | {
|
---|
638 | rc = RTCircBufCreate(&pMixStream->pCircBuf, DrvAudioHlpMilliToBytes(100 /* ms */, &pSink->PCMProps)); /** @todo Make this configurable. */
|
---|
639 | AssertRC(rc);
|
---|
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 | */
|
---|
678 | static 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 | case AUDMIXSINKCMD_DROP: return PDMAUDIOSTREAMCMD_DROP;
|
---|
687 | default: break;
|
---|
688 | }
|
---|
689 |
|
---|
690 | AssertMsgFailed(("Unsupported sink command %d\n", enmCmd));
|
---|
691 | return PDMAUDIOSTREAMCMD_UNKNOWN;
|
---|
692 | }
|
---|
693 |
|
---|
694 | /**
|
---|
695 | * Controls a mixer sink.
|
---|
696 | *
|
---|
697 | * @returns IPRT status code.
|
---|
698 | * @param pSink Mixer sink to control.
|
---|
699 | * @param enmSinkCmd Sink command to set.
|
---|
700 | */
|
---|
701 | int AudioMixerSinkCtl(PAUDMIXSINK pSink, AUDMIXSINKCMD enmSinkCmd)
|
---|
702 | {
|
---|
703 | AssertPtrReturn(pSink, VERR_INVALID_POINTER);
|
---|
704 |
|
---|
705 | PDMAUDIOSTREAMCMD enmCmdStream = audioMixerSinkToStreamCmd(enmSinkCmd);
|
---|
706 | if (enmCmdStream == PDMAUDIOSTREAMCMD_UNKNOWN)
|
---|
707 | return VERR_NOT_SUPPORTED;
|
---|
708 |
|
---|
709 | int rc = RTCritSectEnter(&pSink->CritSect);
|
---|
710 | if (RT_FAILURE(rc))
|
---|
711 | return rc;
|
---|
712 |
|
---|
713 | /* Input sink and no recording source set? Bail out early. */
|
---|
714 | if ( pSink->enmDir == AUDMIXSINKDIR_INPUT
|
---|
715 | && pSink->In.pStreamRecSource == NULL)
|
---|
716 | {
|
---|
717 | int rc2 = RTCritSectLeave(&pSink->CritSect);
|
---|
718 | AssertRC(rc2);
|
---|
719 |
|
---|
720 | return rc;
|
---|
721 | }
|
---|
722 |
|
---|
723 | PAUDMIXSTREAM pStream;
|
---|
724 | if ( pSink->enmDir == AUDMIXSINKDIR_INPUT
|
---|
725 | && pSink->In.pStreamRecSource) /* Any recording source set? */
|
---|
726 | {
|
---|
727 | RTListForEach(&pSink->lstStreams, pStream, AUDMIXSTREAM, Node)
|
---|
728 | {
|
---|
729 | if (pStream == pSink->In.pStreamRecSource)
|
---|
730 | {
|
---|
731 | int rc2 = audioMixerStreamCtlInternal(pStream, enmCmdStream, AUDMIXSTRMCTL_F_NONE);
|
---|
732 | if (rc2 == VERR_NOT_SUPPORTED)
|
---|
733 | rc2 = VINF_SUCCESS;
|
---|
734 |
|
---|
735 | if (RT_SUCCESS(rc))
|
---|
736 | rc = rc2;
|
---|
737 | /* Keep going. Flag? */
|
---|
738 | }
|
---|
739 | }
|
---|
740 | }
|
---|
741 | else if (pSink->enmDir == AUDMIXSINKDIR_OUTPUT)
|
---|
742 | {
|
---|
743 | RTListForEach(&pSink->lstStreams, pStream, AUDMIXSTREAM, Node)
|
---|
744 | {
|
---|
745 | int rc2 = audioMixerStreamCtlInternal(pStream, enmCmdStream, AUDMIXSTRMCTL_F_NONE);
|
---|
746 | if (rc2 == VERR_NOT_SUPPORTED)
|
---|
747 | rc2 = VINF_SUCCESS;
|
---|
748 |
|
---|
749 | if (RT_SUCCESS(rc))
|
---|
750 | rc = rc2;
|
---|
751 | /* Keep going. Flag? */
|
---|
752 | }
|
---|
753 | }
|
---|
754 |
|
---|
755 | switch (enmSinkCmd)
|
---|
756 | {
|
---|
757 | case AUDMIXSINKCMD_ENABLE:
|
---|
758 | {
|
---|
759 | /* Make sure to clear any other former flags again by assigning AUDMIXSINK_STS_RUNNING directly. */
|
---|
760 | pSink->fStatus = AUDMIXSINK_STS_RUNNING;
|
---|
761 | break;
|
---|
762 | }
|
---|
763 |
|
---|
764 | case AUDMIXSINKCMD_DISABLE:
|
---|
765 | {
|
---|
766 | if (pSink->fStatus & AUDMIXSINK_STS_RUNNING)
|
---|
767 | {
|
---|
768 | /* Set the sink in a pending disable state first.
|
---|
769 | * The final status (disabled) will be set in the sink's iteration. */
|
---|
770 | pSink->fStatus |= AUDMIXSINK_STS_PENDING_DISABLE;
|
---|
771 | }
|
---|
772 | break;
|
---|
773 | }
|
---|
774 |
|
---|
775 | case AUDMIXSINKCMD_DROP:
|
---|
776 | {
|
---|
777 | AudioMixBufReset(&pSink->MixBuf);
|
---|
778 |
|
---|
779 | /* Clear dirty bit, keep others. */
|
---|
780 | pSink->fStatus &= ~AUDMIXSINK_STS_DIRTY;
|
---|
781 | break;
|
---|
782 | }
|
---|
783 |
|
---|
784 | default:
|
---|
785 | AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
|
---|
786 | break;
|
---|
787 | }
|
---|
788 |
|
---|
789 | char *pszStatus = dbgAudioMixerSinkStatusToStr(pSink->fStatus);
|
---|
790 | LogRel2(("Mixer: Set new status of sink '%s' to %s\n", pSink->pszName, pszStatus));
|
---|
791 | LogFlowFunc(("[%s] enmCmd=%RU32, fStatus=%s, rc=%Rrc\n", pSink->pszName, enmSinkCmd, pszStatus, rc));
|
---|
792 | RTStrFree(pszStatus);
|
---|
793 |
|
---|
794 | int rc2 = RTCritSectLeave(&pSink->CritSect);
|
---|
795 | AssertRC(rc2);
|
---|
796 |
|
---|
797 | return rc;
|
---|
798 | }
|
---|
799 |
|
---|
800 | /**
|
---|
801 | * Destroys a mixer sink and removes it from the attached mixer (if any).
|
---|
802 | *
|
---|
803 | * @param pSink Mixer sink to destroy.
|
---|
804 | */
|
---|
805 | void AudioMixerSinkDestroy(PAUDMIXSINK pSink)
|
---|
806 | {
|
---|
807 | if (!pSink)
|
---|
808 | return;
|
---|
809 |
|
---|
810 | int rc2 = RTCritSectEnter(&pSink->CritSect);
|
---|
811 | AssertRC(rc2);
|
---|
812 |
|
---|
813 | if (pSink->pParent)
|
---|
814 | {
|
---|
815 | /* Save mixer pointer, as after audioMixerRemoveSinkInternal() the
|
---|
816 | * pointer will be gone from the stream. */
|
---|
817 | PAUDIOMIXER pMixer = pSink->pParent;
|
---|
818 | AssertPtr(pMixer);
|
---|
819 |
|
---|
820 | audioMixerRemoveSinkInternal(pMixer, pSink);
|
---|
821 |
|
---|
822 | Assert(pMixer->cSinks);
|
---|
823 | pMixer->cSinks--;
|
---|
824 | }
|
---|
825 |
|
---|
826 | rc2 = RTCritSectLeave(&pSink->CritSect);
|
---|
827 | AssertRC(rc2);
|
---|
828 |
|
---|
829 | audioMixerSinkDestroyInternal(pSink);
|
---|
830 | }
|
---|
831 |
|
---|
832 | /**
|
---|
833 | * Destroys a mixer sink.
|
---|
834 | *
|
---|
835 | * @param pSink Mixer sink to destroy.
|
---|
836 | */
|
---|
837 | static void audioMixerSinkDestroyInternal(PAUDMIXSINK pSink)
|
---|
838 | {
|
---|
839 | AssertPtrReturnVoid(pSink);
|
---|
840 |
|
---|
841 | LogFunc(("%s\n", pSink->pszName));
|
---|
842 |
|
---|
843 | PAUDMIXSTREAM pStream, pStreamNext;
|
---|
844 | RTListForEachSafe(&pSink->lstStreams, pStream, pStreamNext, AUDMIXSTREAM, Node)
|
---|
845 | {
|
---|
846 | /* Save a pointer to the stream to remove, as pStream
|
---|
847 | * will not be valid anymore after calling audioMixerSinkRemoveStreamInternal(). */
|
---|
848 | PAUDMIXSTREAM pStreamToRemove = pStream;
|
---|
849 |
|
---|
850 | audioMixerSinkRemoveStreamInternal(pSink, pStreamToRemove);
|
---|
851 | audioMixerStreamDestroyInternal(pStreamToRemove);
|
---|
852 | }
|
---|
853 |
|
---|
854 | #ifdef VBOX_AUDIO_MIXER_DEBUG
|
---|
855 | DrvAudioHlpFileDestroy(pSink->Dbg.pFile);
|
---|
856 | pSink->Dbg.pFile = NULL;
|
---|
857 | #endif
|
---|
858 |
|
---|
859 | if (pSink->pszName)
|
---|
860 | {
|
---|
861 | RTStrFree(pSink->pszName);
|
---|
862 | pSink->pszName = NULL;
|
---|
863 | }
|
---|
864 |
|
---|
865 | AudioMixBufDestroy(&pSink->MixBuf);
|
---|
866 | RTCritSectDelete(&pSink->CritSect);
|
---|
867 |
|
---|
868 | RTMemFree(pSink);
|
---|
869 | pSink = NULL;
|
---|
870 | }
|
---|
871 |
|
---|
872 | /**
|
---|
873 | * Returns the amount of bytes ready to be read from a sink since the last call
|
---|
874 | * to AudioMixerSinkUpdate().
|
---|
875 | *
|
---|
876 | * @returns Amount of bytes ready to be read from the sink.
|
---|
877 | * @param pSink Sink to return number of available bytes for.
|
---|
878 | */
|
---|
879 | uint32_t AudioMixerSinkGetReadable(PAUDMIXSINK pSink)
|
---|
880 | {
|
---|
881 | AssertPtrReturn(pSink, 0);
|
---|
882 |
|
---|
883 | AssertMsg(pSink->enmDir == AUDMIXSINKDIR_INPUT, ("%s: Can't read from a non-input sink\n", pSink->pszName));
|
---|
884 |
|
---|
885 | int rc = RTCritSectEnter(&pSink->CritSect);
|
---|
886 | if (RT_FAILURE(rc))
|
---|
887 | return 0;
|
---|
888 |
|
---|
889 | uint32_t cbReadable = 0;
|
---|
890 |
|
---|
891 | if (pSink->fStatus & AUDMIXSINK_STS_RUNNING)
|
---|
892 | {
|
---|
893 | #ifdef VBOX_AUDIO_MIXER_WITH_MIXBUF_IN
|
---|
894 | # error "Implement me!"
|
---|
895 | #else
|
---|
896 | PAUDMIXSTREAM pStreamRecSource = pSink->In.pStreamRecSource;
|
---|
897 | if (!pStreamRecSource)
|
---|
898 | {
|
---|
899 | Log3Func(("[%s] No recording source specified, skipping ...\n", pSink->pszName));
|
---|
900 | }
|
---|
901 | else
|
---|
902 | {
|
---|
903 | AssertPtr(pStreamRecSource->pConn);
|
---|
904 | cbReadable = pStreamRecSource->pConn->pfnStreamGetReadable(pStreamRecSource->pConn, pStreamRecSource->pStream);
|
---|
905 | }
|
---|
906 | #endif
|
---|
907 | }
|
---|
908 |
|
---|
909 | Log3Func(("[%s] cbReadable=%RU32\n", pSink->pszName, cbReadable));
|
---|
910 |
|
---|
911 | int rc2 = RTCritSectLeave(&pSink->CritSect);
|
---|
912 | AssertRC(rc2);
|
---|
913 |
|
---|
914 | return cbReadable;
|
---|
915 | }
|
---|
916 |
|
---|
917 | /**
|
---|
918 | * Returns the sink's current recording source.
|
---|
919 | *
|
---|
920 | * @return Mixer stream which currently is set as current recording source, NULL if none is set.
|
---|
921 | * @param pSink Audio mixer sink to return current recording source for.
|
---|
922 | */
|
---|
923 | PAUDMIXSTREAM AudioMixerSinkGetRecordingSource(PAUDMIXSINK pSink)
|
---|
924 | {
|
---|
925 | int rc = RTCritSectEnter(&pSink->CritSect);
|
---|
926 | if (RT_FAILURE(rc))
|
---|
927 | return NULL;
|
---|
928 |
|
---|
929 | AssertMsg(pSink->enmDir == AUDMIXSINKDIR_INPUT, ("Specified sink is not an input sink\n"));
|
---|
930 |
|
---|
931 | PAUDMIXSTREAM pStream = pSink->In.pStreamRecSource;
|
---|
932 |
|
---|
933 | int rc2 = RTCritSectLeave(&pSink->CritSect);
|
---|
934 | AssertRC(rc2);
|
---|
935 |
|
---|
936 | return pStream;
|
---|
937 | }
|
---|
938 |
|
---|
939 | /**
|
---|
940 | * Returns the amount of bytes ready to be written to a sink since the last call
|
---|
941 | * to AudioMixerSinkUpdate().
|
---|
942 | *
|
---|
943 | * @returns Amount of bytes ready to be written to the sink.
|
---|
944 | * @param pSink Sink to return number of available bytes for.
|
---|
945 | */
|
---|
946 | uint32_t AudioMixerSinkGetWritable(PAUDMIXSINK pSink)
|
---|
947 | {
|
---|
948 | AssertPtrReturn(pSink, 0);
|
---|
949 |
|
---|
950 | AssertMsg(pSink->enmDir == AUDMIXSINKDIR_OUTPUT, ("%s: Can't write to a non-output sink\n", pSink->pszName));
|
---|
951 |
|
---|
952 | int rc = RTCritSectEnter(&pSink->CritSect);
|
---|
953 | if (RT_FAILURE(rc))
|
---|
954 | return 0;
|
---|
955 |
|
---|
956 | uint32_t cbWritable = 0;
|
---|
957 |
|
---|
958 | if ( (pSink->fStatus & AUDMIXSINK_STS_RUNNING)
|
---|
959 | && !(pSink->fStatus & AUDMIXSINK_STS_PENDING_DISABLE))
|
---|
960 | {
|
---|
961 | cbWritable = AudioMixBufFreeBytes(&pSink->MixBuf);
|
---|
962 | }
|
---|
963 |
|
---|
964 | Log3Func(("[%s] cbWritable=%RU32 (%RU64ms)\n",
|
---|
965 | pSink->pszName, cbWritable, DrvAudioHlpBytesToMilli(cbWritable, &pSink->PCMProps)));
|
---|
966 |
|
---|
967 | int rc2 = RTCritSectLeave(&pSink->CritSect);
|
---|
968 | AssertRC(rc2);
|
---|
969 |
|
---|
970 | return cbWritable;
|
---|
971 | }
|
---|
972 |
|
---|
973 | /**
|
---|
974 | * Returns the sink's mixing direction.
|
---|
975 | *
|
---|
976 | * @returns Mixing direction.
|
---|
977 | * @param pSink Sink to return direction for.
|
---|
978 | */
|
---|
979 | AUDMIXSINKDIR AudioMixerSinkGetDir(PAUDMIXSINK pSink)
|
---|
980 | {
|
---|
981 | AssertPtrReturn(pSink, AUDMIXSINKDIR_UNKNOWN);
|
---|
982 |
|
---|
983 | int rc = RTCritSectEnter(&pSink->CritSect);
|
---|
984 | if (RT_FAILURE(rc))
|
---|
985 | return AUDMIXSINKDIR_UNKNOWN;
|
---|
986 |
|
---|
987 | AUDMIXSINKDIR enmDir = pSink->enmDir;
|
---|
988 |
|
---|
989 | int rc2 = RTCritSectLeave(&pSink->CritSect);
|
---|
990 | AssertRC(rc2);
|
---|
991 |
|
---|
992 | return enmDir;
|
---|
993 | }
|
---|
994 |
|
---|
995 | /**
|
---|
996 | * Returns the sink's (friendly) name.
|
---|
997 | *
|
---|
998 | * @returns The sink's (friendly) name.
|
---|
999 | */
|
---|
1000 | const char *AudioMixerSinkGetName(const PAUDMIXSINK pSink)
|
---|
1001 | {
|
---|
1002 | AssertPtrReturn(pSink, "<Unknown>");
|
---|
1003 |
|
---|
1004 | return pSink->pszName;
|
---|
1005 | }
|
---|
1006 |
|
---|
1007 | /**
|
---|
1008 | * Returns a specific mixer stream from a sink, based on its index.
|
---|
1009 | *
|
---|
1010 | * @returns Mixer stream if found, or NULL if not found.
|
---|
1011 | * @param pSink Sink to retrieve mixer stream from.
|
---|
1012 | * @param uIndex Index of the mixer stream to return.
|
---|
1013 | */
|
---|
1014 | PAUDMIXSTREAM AudioMixerSinkGetStream(PAUDMIXSINK pSink, uint8_t uIndex)
|
---|
1015 | {
|
---|
1016 | AssertPtrReturn(pSink, NULL);
|
---|
1017 |
|
---|
1018 | int rc = RTCritSectEnter(&pSink->CritSect);
|
---|
1019 | if (RT_FAILURE(rc))
|
---|
1020 | return NULL;
|
---|
1021 |
|
---|
1022 | AssertMsgReturn(uIndex < pSink->cStreams,
|
---|
1023 | ("Index %RU8 exceeds stream count (%RU8)", uIndex, pSink->cStreams), NULL);
|
---|
1024 |
|
---|
1025 | /* Slow lookup, d'oh. */
|
---|
1026 | PAUDMIXSTREAM pStream = RTListGetFirst(&pSink->lstStreams, AUDMIXSTREAM, Node);
|
---|
1027 | while (uIndex)
|
---|
1028 | {
|
---|
1029 | pStream = RTListGetNext(&pSink->lstStreams, pStream, AUDMIXSTREAM, Node);
|
---|
1030 | uIndex--;
|
---|
1031 | }
|
---|
1032 |
|
---|
1033 | /** @todo Do we need to raise the stream's reference count here? */
|
---|
1034 |
|
---|
1035 | int rc2 = RTCritSectLeave(&pSink->CritSect);
|
---|
1036 | AssertRC(rc2);
|
---|
1037 |
|
---|
1038 | AssertPtr(pStream);
|
---|
1039 | return pStream;
|
---|
1040 | }
|
---|
1041 |
|
---|
1042 | /**
|
---|
1043 | * Returns the current status of a mixer sink.
|
---|
1044 | *
|
---|
1045 | * @returns The sink's current status.
|
---|
1046 | * @param pSink Mixer sink to return status for.
|
---|
1047 | */
|
---|
1048 | AUDMIXSINKSTS AudioMixerSinkGetStatus(PAUDMIXSINK pSink)
|
---|
1049 | {
|
---|
1050 | if (!pSink)
|
---|
1051 | return AUDMIXSINK_STS_NONE;
|
---|
1052 |
|
---|
1053 | int rc2 = RTCritSectEnter(&pSink->CritSect);
|
---|
1054 | if (RT_FAILURE(rc2))
|
---|
1055 | return AUDMIXSINK_STS_NONE;
|
---|
1056 |
|
---|
1057 | /* If the dirty flag is set, there is unprocessed data in the sink. */
|
---|
1058 | AUDMIXSINKSTS stsSink = pSink->fStatus;
|
---|
1059 |
|
---|
1060 | rc2 = RTCritSectLeave(&pSink->CritSect);
|
---|
1061 | AssertRC(rc2);
|
---|
1062 |
|
---|
1063 | return stsSink;
|
---|
1064 | }
|
---|
1065 |
|
---|
1066 | /**
|
---|
1067 | * Returns the number of attached mixer streams to a mixer sink.
|
---|
1068 | *
|
---|
1069 | * @returns The number of attached mixer streams.
|
---|
1070 | * @param pSink Mixer sink to return number for.
|
---|
1071 | */
|
---|
1072 | uint8_t AudioMixerSinkGetStreamCount(PAUDMIXSINK pSink)
|
---|
1073 | {
|
---|
1074 | if (!pSink)
|
---|
1075 | return 0;
|
---|
1076 |
|
---|
1077 | int rc2 = RTCritSectEnter(&pSink->CritSect);
|
---|
1078 | if (RT_FAILURE(rc2))
|
---|
1079 | return 0;
|
---|
1080 |
|
---|
1081 | uint8_t cStreams = pSink->cStreams;
|
---|
1082 |
|
---|
1083 | rc2 = RTCritSectLeave(&pSink->CritSect);
|
---|
1084 | AssertRC(rc2);
|
---|
1085 |
|
---|
1086 | return cStreams;
|
---|
1087 | }
|
---|
1088 |
|
---|
1089 | /**
|
---|
1090 | * Returns whether the sink is in an active state or not.
|
---|
1091 | * Note: The pending disable state also counts as active.
|
---|
1092 | *
|
---|
1093 | * @returns True if active, false if not.
|
---|
1094 | * @param pSink Sink to return active state for.
|
---|
1095 | */
|
---|
1096 | bool AudioMixerSinkIsActive(PAUDMIXSINK pSink)
|
---|
1097 | {
|
---|
1098 | if (!pSink)
|
---|
1099 | return false;
|
---|
1100 |
|
---|
1101 | int rc2 = RTCritSectEnter(&pSink->CritSect);
|
---|
1102 | if (RT_FAILURE(rc2))
|
---|
1103 | return false;
|
---|
1104 |
|
---|
1105 | bool fIsActive = pSink->fStatus & AUDMIXSINK_STS_RUNNING;
|
---|
1106 | /* Note: AUDMIXSINK_STS_PENDING_DISABLE implies AUDMIXSINK_STS_RUNNING. */
|
---|
1107 |
|
---|
1108 | Log3Func(("[%s] fActive=%RTbool\n", pSink->pszName, fIsActive));
|
---|
1109 |
|
---|
1110 | rc2 = RTCritSectLeave(&pSink->CritSect);
|
---|
1111 | AssertRC(rc2);
|
---|
1112 |
|
---|
1113 | return fIsActive;
|
---|
1114 | }
|
---|
1115 |
|
---|
1116 | /**
|
---|
1117 | * Reads audio data from a mixer sink.
|
---|
1118 | *
|
---|
1119 | * @returns IPRT status code.
|
---|
1120 | * @param pSink Mixer sink to read data from.
|
---|
1121 | * @param enmOp Mixer operation to use for reading the data.
|
---|
1122 | * @param pvBuf Buffer where to store the read data.
|
---|
1123 | * @param cbBuf Buffer size (in bytes) where to store the data.
|
---|
1124 | * @param pcbRead Number of bytes read. Optional.
|
---|
1125 | */
|
---|
1126 | int AudioMixerSinkRead(PAUDMIXSINK pSink, AUDMIXOP enmOp, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead)
|
---|
1127 | {
|
---|
1128 | AssertPtrReturn(pSink, VERR_INVALID_POINTER);
|
---|
1129 | RT_NOREF(enmOp);
|
---|
1130 | AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
|
---|
1131 | AssertReturn(cbBuf, VERR_INVALID_PARAMETER);
|
---|
1132 | /* pcbRead is optional. */
|
---|
1133 |
|
---|
1134 | /** @todo Handle mixing operation enmOp! */
|
---|
1135 |
|
---|
1136 | int rc = RTCritSectEnter(&pSink->CritSect);
|
---|
1137 | if (RT_FAILURE(rc))
|
---|
1138 | return rc;
|
---|
1139 |
|
---|
1140 | AssertMsg(pSink->enmDir == AUDMIXSINKDIR_INPUT,
|
---|
1141 | ("Can't read from a sink which is not an input sink\n"));
|
---|
1142 |
|
---|
1143 | uint32_t cbRead = 0;
|
---|
1144 |
|
---|
1145 | /* Flag indicating whether this sink is in a 'clean' state,
|
---|
1146 | * e.g. there is no more data to read from. */
|
---|
1147 | bool fClean = true;
|
---|
1148 |
|
---|
1149 | PAUDMIXSTREAM pStreamRecSource = pSink->In.pStreamRecSource;
|
---|
1150 | if (!pStreamRecSource)
|
---|
1151 | {
|
---|
1152 | Log3Func(("[%s] No recording source specified, skipping ...\n", pSink->pszName));
|
---|
1153 | }
|
---|
1154 | else if (!(pStreamRecSource->fStatus & AUDMIXSTREAM_STATUS_ENABLED))
|
---|
1155 | {
|
---|
1156 | Log3Func(("[%s] Stream '%s' disabled, skipping ...\n", pSink->pszName, pStreamRecSource->pszName));
|
---|
1157 | }
|
---|
1158 | else
|
---|
1159 | {
|
---|
1160 | uint32_t cbToRead = cbBuf;
|
---|
1161 | while (cbToRead)
|
---|
1162 | {
|
---|
1163 | uint32_t cbReadStrm;
|
---|
1164 | AssertPtr(pStreamRecSource->pConn);
|
---|
1165 | #ifdef VBOX_AUDIO_MIXER_WITH_MIXBUF_IN
|
---|
1166 | # error "Implement me!"
|
---|
1167 | #else
|
---|
1168 | rc = pStreamRecSource->pConn->pfnStreamRead(pStreamRecSource->pConn, pStreamRecSource->pStream,
|
---|
1169 | (uint8_t *)pvBuf + cbRead, cbToRead, &cbReadStrm);
|
---|
1170 | #endif
|
---|
1171 | if (RT_FAILURE(rc))
|
---|
1172 | LogFunc(("[%s] Failed reading from stream '%s': %Rrc\n", pSink->pszName, pStreamRecSource->pszName, rc));
|
---|
1173 |
|
---|
1174 | Log3Func(("[%s] Stream '%s': Read %RU32 bytes\n", pSink->pszName, pStreamRecSource->pszName, cbReadStrm));
|
---|
1175 |
|
---|
1176 | if ( RT_FAILURE(rc)
|
---|
1177 | || !cbReadStrm)
|
---|
1178 | break;
|
---|
1179 |
|
---|
1180 | AssertBreakStmt(cbReadStrm <= cbToRead, rc = VERR_BUFFER_OVERFLOW);
|
---|
1181 | cbToRead -= cbReadStrm;
|
---|
1182 | cbRead += cbReadStrm;
|
---|
1183 | Assert(cbRead <= cbBuf);
|
---|
1184 | }
|
---|
1185 |
|
---|
1186 | uint32_t cbReadable = pStreamRecSource->pConn->pfnStreamGetReadable(pStreamRecSource->pConn, pStreamRecSource->pStream);
|
---|
1187 |
|
---|
1188 | /* Still some data available? Then sink is not clean (yet). */
|
---|
1189 | if (cbReadable)
|
---|
1190 | fClean = false;
|
---|
1191 |
|
---|
1192 | if (RT_SUCCESS(rc))
|
---|
1193 | {
|
---|
1194 | if (fClean)
|
---|
1195 | pSink->fStatus &= ~AUDMIXSINK_STS_DIRTY;
|
---|
1196 |
|
---|
1197 | /* Update our last read time stamp. */
|
---|
1198 | pSink->tsLastReadWrittenNs = RTTimeNanoTS();
|
---|
1199 |
|
---|
1200 | #ifdef VBOX_AUDIO_MIXER_DEBUG
|
---|
1201 | int rc2 = DrvAudioHlpFileWrite(pSink->Dbg.pFile, pvBuf, cbRead, 0 /* fFlags */);
|
---|
1202 | AssertRC(rc2);
|
---|
1203 | #endif
|
---|
1204 | }
|
---|
1205 | }
|
---|
1206 |
|
---|
1207 | #ifdef LOG_ENABLED
|
---|
1208 | char *pszStatus = dbgAudioMixerSinkStatusToStr(pSink->fStatus);
|
---|
1209 | Log2Func(("[%s] cbRead=%RU32, fClean=%RTbool, fStatus=%s, rc=%Rrc\n", pSink->pszName, cbRead, fClean, pszStatus, rc));
|
---|
1210 | RTStrFree(pszStatus);
|
---|
1211 | #endif
|
---|
1212 |
|
---|
1213 | if (pcbRead)
|
---|
1214 | *pcbRead = cbRead;
|
---|
1215 |
|
---|
1216 | int rc2 = RTCritSectLeave(&pSink->CritSect);
|
---|
1217 | AssertRC(rc2);
|
---|
1218 |
|
---|
1219 | return rc;
|
---|
1220 | }
|
---|
1221 |
|
---|
1222 | /**
|
---|
1223 | * Removes a mixer stream from a mixer sink, internal version.
|
---|
1224 | *
|
---|
1225 | * @returns IPRT status code.
|
---|
1226 | * @param pSink Sink to remove mixer stream from.
|
---|
1227 | * @param pStream Stream to remove.
|
---|
1228 | */
|
---|
1229 | static int audioMixerSinkRemoveStreamInternal(PAUDMIXSINK pSink, PAUDMIXSTREAM pStream)
|
---|
1230 | {
|
---|
1231 | AssertPtrReturn(pSink, VERR_INVALID_PARAMETER);
|
---|
1232 | if ( !pStream
|
---|
1233 | || !pStream->pSink) /* Not part of a sink anymore? */
|
---|
1234 | {
|
---|
1235 | return VERR_NOT_FOUND;
|
---|
1236 | }
|
---|
1237 |
|
---|
1238 | AssertMsgReturn(pStream->pSink == pSink, ("Stream '%s' is not part of sink '%s'\n",
|
---|
1239 | pStream->pszName, pSink->pszName), VERR_NOT_FOUND);
|
---|
1240 |
|
---|
1241 | LogFlowFunc(("[%s] (Stream = %s), cStreams=%RU8\n",
|
---|
1242 | pSink->pszName, pStream->pStream->szName, pSink->cStreams));
|
---|
1243 |
|
---|
1244 | /* Remove stream from sink. */
|
---|
1245 | RTListNodeRemove(&pStream->Node);
|
---|
1246 |
|
---|
1247 | int rc = VINF_SUCCESS;
|
---|
1248 |
|
---|
1249 | if (pSink->enmDir == AUDMIXSINKDIR_INPUT)
|
---|
1250 | {
|
---|
1251 | /* Make sure to also un-set the recording source if this stream was set
|
---|
1252 | * as the recording source before. */
|
---|
1253 | if (pStream == pSink->In.pStreamRecSource)
|
---|
1254 | rc = audioMixerSinkSetRecSourceInternal(pSink, NULL);
|
---|
1255 | }
|
---|
1256 |
|
---|
1257 | /* Set sink to NULL so that we know we're not part of any sink anymore. */
|
---|
1258 | pStream->pSink = NULL;
|
---|
1259 |
|
---|
1260 | return rc;
|
---|
1261 | }
|
---|
1262 |
|
---|
1263 | /**
|
---|
1264 | * Removes a mixer stream from a mixer sink.
|
---|
1265 | *
|
---|
1266 | * @param pSink Sink to remove mixer stream from.
|
---|
1267 | * @param pStream Stream to remove.
|
---|
1268 | */
|
---|
1269 | void AudioMixerSinkRemoveStream(PAUDMIXSINK pSink, PAUDMIXSTREAM pStream)
|
---|
1270 | {
|
---|
1271 | int rc2 = RTCritSectEnter(&pSink->CritSect);
|
---|
1272 | AssertRC(rc2);
|
---|
1273 |
|
---|
1274 | rc2 = audioMixerSinkRemoveStreamInternal(pSink, pStream);
|
---|
1275 | if (RT_SUCCESS(rc2))
|
---|
1276 | {
|
---|
1277 | Assert(pSink->cStreams);
|
---|
1278 | pSink->cStreams--;
|
---|
1279 | }
|
---|
1280 |
|
---|
1281 | rc2 = RTCritSectLeave(&pSink->CritSect);
|
---|
1282 | AssertRC(rc2);
|
---|
1283 | }
|
---|
1284 |
|
---|
1285 | /**
|
---|
1286 | * Removes all attached streams from a given sink.
|
---|
1287 | *
|
---|
1288 | * @param pSink Sink to remove attached streams from.
|
---|
1289 | */
|
---|
1290 | static void audioMixerSinkRemoveAllStreamsInternal(PAUDMIXSINK pSink)
|
---|
1291 | {
|
---|
1292 | if (!pSink)
|
---|
1293 | return;
|
---|
1294 |
|
---|
1295 | LogFunc(("%s\n", pSink->pszName));
|
---|
1296 |
|
---|
1297 | PAUDMIXSTREAM pStream, pStreamNext;
|
---|
1298 | RTListForEachSafe(&pSink->lstStreams, pStream, pStreamNext, AUDMIXSTREAM, Node)
|
---|
1299 | audioMixerSinkRemoveStreamInternal(pSink, pStream);
|
---|
1300 | }
|
---|
1301 |
|
---|
1302 | /**
|
---|
1303 | * Resets the sink's state.
|
---|
1304 | *
|
---|
1305 | * @param pSink Sink to reset.
|
---|
1306 | */
|
---|
1307 | static void audioMixerSinkReset(PAUDMIXSINK pSink)
|
---|
1308 | {
|
---|
1309 | if (!pSink)
|
---|
1310 | return;
|
---|
1311 |
|
---|
1312 | LogFunc(("[%s]\n", pSink->pszName));
|
---|
1313 |
|
---|
1314 | AudioMixBufReset(&pSink->MixBuf);
|
---|
1315 |
|
---|
1316 | /* Update last updated timestamp. */
|
---|
1317 | pSink->tsLastUpdatedMs = 0;
|
---|
1318 |
|
---|
1319 | /* Reset status. */
|
---|
1320 | pSink->fStatus = AUDMIXSINK_STS_NONE;
|
---|
1321 | }
|
---|
1322 |
|
---|
1323 | /**
|
---|
1324 | * Removes all attached streams from a given sink.
|
---|
1325 | *
|
---|
1326 | * @param pSink Sink to remove attached streams from.
|
---|
1327 | */
|
---|
1328 | void AudioMixerSinkRemoveAllStreams(PAUDMIXSINK pSink)
|
---|
1329 | {
|
---|
1330 | if (!pSink)
|
---|
1331 | return;
|
---|
1332 |
|
---|
1333 | int rc2 = RTCritSectEnter(&pSink->CritSect);
|
---|
1334 | AssertRC(rc2);
|
---|
1335 |
|
---|
1336 | audioMixerSinkRemoveAllStreamsInternal(pSink);
|
---|
1337 |
|
---|
1338 | pSink->cStreams = 0;
|
---|
1339 |
|
---|
1340 | rc2 = RTCritSectLeave(&pSink->CritSect);
|
---|
1341 | AssertRC(rc2);
|
---|
1342 | }
|
---|
1343 |
|
---|
1344 | /**
|
---|
1345 | * Resets a sink. This will immediately stop all processing.
|
---|
1346 | *
|
---|
1347 | * @param pSink Sink to reset.
|
---|
1348 | */
|
---|
1349 | void AudioMixerSinkReset(PAUDMIXSINK pSink)
|
---|
1350 | {
|
---|
1351 | if (!pSink)
|
---|
1352 | return;
|
---|
1353 |
|
---|
1354 | int rc2 = RTCritSectEnter(&pSink->CritSect);
|
---|
1355 | AssertRC(rc2);
|
---|
1356 |
|
---|
1357 | LogFlowFunc(("[%s]\n", pSink->pszName));
|
---|
1358 |
|
---|
1359 | audioMixerSinkReset(pSink);
|
---|
1360 |
|
---|
1361 | rc2 = RTCritSectLeave(&pSink->CritSect);
|
---|
1362 | AssertRC(rc2);
|
---|
1363 | }
|
---|
1364 |
|
---|
1365 | /**
|
---|
1366 | * Returns the audio format of a mixer sink.
|
---|
1367 | *
|
---|
1368 | * @param pSink Sink to retrieve audio format for.
|
---|
1369 | * @param pPCMProps Where to the returned audio format.
|
---|
1370 | */
|
---|
1371 | void AudioMixerSinkGetFormat(PAUDMIXSINK pSink, PPDMAUDIOPCMPROPS pPCMProps)
|
---|
1372 | {
|
---|
1373 | AssertPtrReturnVoid(pSink);
|
---|
1374 | AssertPtrReturnVoid(pPCMProps);
|
---|
1375 |
|
---|
1376 | int rc2 = RTCritSectEnter(&pSink->CritSect);
|
---|
1377 | if (RT_FAILURE(rc2))
|
---|
1378 | return;
|
---|
1379 |
|
---|
1380 | memcpy(pPCMProps, &pSink->PCMProps, sizeof(PDMAUDIOPCMPROPS));
|
---|
1381 |
|
---|
1382 | rc2 = RTCritSectLeave(&pSink->CritSect);
|
---|
1383 | AssertRC(rc2);
|
---|
1384 | }
|
---|
1385 |
|
---|
1386 | /**
|
---|
1387 | * Sets the audio format of a mixer sink.
|
---|
1388 | *
|
---|
1389 | * @returns IPRT status code.
|
---|
1390 | * @param pSink Sink to set audio format for.
|
---|
1391 | * @param pPCMProps Audio format (PCM properties) to set.
|
---|
1392 | */
|
---|
1393 | int AudioMixerSinkSetFormat(PAUDMIXSINK pSink, PPDMAUDIOPCMPROPS pPCMProps)
|
---|
1394 | {
|
---|
1395 | AssertPtrReturn(pSink, VERR_INVALID_POINTER);
|
---|
1396 | AssertPtrReturn(pPCMProps, VERR_INVALID_POINTER);
|
---|
1397 | AssertReturn(DrvAudioHlpPCMPropsAreValid(pPCMProps), VERR_INVALID_PARAMETER);
|
---|
1398 |
|
---|
1399 | int rc = RTCritSectEnter(&pSink->CritSect);
|
---|
1400 | if (RT_FAILURE(rc))
|
---|
1401 | return rc;
|
---|
1402 |
|
---|
1403 | if (DrvAudioHlpPCMPropsAreEqual(&pSink->PCMProps, pPCMProps)) /* Bail out early if PCM properties are equal. */
|
---|
1404 | {
|
---|
1405 | rc = RTCritSectLeave(&pSink->CritSect);
|
---|
1406 | AssertRC(rc);
|
---|
1407 |
|
---|
1408 | return rc;
|
---|
1409 | }
|
---|
1410 |
|
---|
1411 | if (pSink->PCMProps.uHz)
|
---|
1412 | LogFlowFunc(("[%s] Old format: %u bit, %RU8 channels, %RU32Hz\n",
|
---|
1413 | pSink->pszName, pSink->PCMProps.cbSample * 8, pSink->PCMProps.cChannels, pSink->PCMProps.uHz));
|
---|
1414 |
|
---|
1415 | memcpy(&pSink->PCMProps, pPCMProps, sizeof(PDMAUDIOPCMPROPS));
|
---|
1416 |
|
---|
1417 | LogFlowFunc(("[%s] New format %u bit, %RU8 channels, %RU32Hz\n",
|
---|
1418 | pSink->pszName, pSink->PCMProps.cbSample * 8, pSink->PCMProps.cChannels, pSink->PCMProps.uHz));
|
---|
1419 |
|
---|
1420 | /* Also update the sink's mixing buffer format. */
|
---|
1421 | AudioMixBufDestroy(&pSink->MixBuf);
|
---|
1422 | rc = AudioMixBufInit(&pSink->MixBuf, pSink->pszName, &pSink->PCMProps,
|
---|
1423 | DrvAudioHlpMilliToFrames(100 /* ms */, &pSink->PCMProps)); /** @todo Make this configurable? */
|
---|
1424 | if (RT_SUCCESS(rc))
|
---|
1425 | {
|
---|
1426 | PAUDMIXSTREAM pStream;
|
---|
1427 | RTListForEach(&pSink->lstStreams, pStream, AUDMIXSTREAM, Node)
|
---|
1428 | {
|
---|
1429 | /** @todo Invalidate mix buffers! */
|
---|
1430 | }
|
---|
1431 | }
|
---|
1432 |
|
---|
1433 | #ifdef VBOX_AUDIO_MIXER_DEBUG
|
---|
1434 | if (RT_SUCCESS(rc))
|
---|
1435 | {
|
---|
1436 | DrvAudioHlpFileClose(pSink->Dbg.pFile);
|
---|
1437 |
|
---|
1438 | char szTemp[RTPATH_MAX];
|
---|
1439 | int rc2 = RTPathTemp(szTemp, sizeof(szTemp));
|
---|
1440 | if (RT_SUCCESS(rc2))
|
---|
1441 | {
|
---|
1442 | /** @todo Sanitize sink name. */
|
---|
1443 |
|
---|
1444 | char szName[64];
|
---|
1445 | RTStrPrintf(szName, sizeof(szName), "MixerSink-%s", pSink->pszName);
|
---|
1446 |
|
---|
1447 | char szFile[RTPATH_MAX + 1];
|
---|
1448 | rc2 = DrvAudioHlpFileNameGet(szFile, RT_ELEMENTS(szFile), szTemp, szName,
|
---|
1449 | 0 /* Instance */, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAGS_NONE);
|
---|
1450 | if (RT_SUCCESS(rc2))
|
---|
1451 | {
|
---|
1452 | rc2 = DrvAudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szFile, PDMAUDIOFILE_FLAGS_NONE,
|
---|
1453 | &pSink->Dbg.pFile);
|
---|
1454 | if (RT_SUCCESS(rc2))
|
---|
1455 | rc2 = DrvAudioHlpFileOpen(pSink->Dbg.pFile, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS, &pSink->PCMProps);
|
---|
1456 | }
|
---|
1457 | }
|
---|
1458 | }
|
---|
1459 | #endif
|
---|
1460 |
|
---|
1461 | int rc2 = RTCritSectLeave(&pSink->CritSect);
|
---|
1462 | AssertRC(rc2);
|
---|
1463 |
|
---|
1464 | LogFlowFuncLeaveRC(rc);
|
---|
1465 | return rc;
|
---|
1466 | }
|
---|
1467 |
|
---|
1468 | /**
|
---|
1469 | * Set the current recording source of an input mixer sink, internal version.
|
---|
1470 | *
|
---|
1471 | * @return IPRT status code.
|
---|
1472 | * @param pSink Input mixer sink to set recording source for.
|
---|
1473 | * @param pStream Mixer stream to set as current recording source. Must be an input stream.
|
---|
1474 | * Specify NULL to un-set the current recording source.
|
---|
1475 | */
|
---|
1476 | static int audioMixerSinkSetRecSourceInternal(PAUDMIXSINK pSink, PAUDMIXSTREAM pStream)
|
---|
1477 | {
|
---|
1478 | AssertMsg(pSink->enmDir == AUDMIXSINKDIR_INPUT, ("Specified sink is not an input sink\n"));
|
---|
1479 |
|
---|
1480 | int rc;
|
---|
1481 |
|
---|
1482 | if (pSink->In.pStreamRecSource) /* Disable old recording source, if any set. */
|
---|
1483 | {
|
---|
1484 | const PPDMIAUDIOCONNECTOR pConn = pSink->In.pStreamRecSource->pConn;
|
---|
1485 | AssertPtr(pConn);
|
---|
1486 | rc = pConn->pfnEnable(pConn, PDMAUDIODIR_IN, false /* Disable */);
|
---|
1487 | }
|
---|
1488 | else
|
---|
1489 | rc = VINF_SUCCESS;
|
---|
1490 |
|
---|
1491 | if (RT_SUCCESS(rc))
|
---|
1492 | {
|
---|
1493 | if (pStream) /* Can be NULL if un-setting. */
|
---|
1494 | {
|
---|
1495 | AssertPtr(pStream->pStream);
|
---|
1496 | AssertMsg(pStream->pStream->enmDir == PDMAUDIODIR_IN, ("Specified stream is not an input stream\n"));
|
---|
1497 | }
|
---|
1498 |
|
---|
1499 | pSink->In.pStreamRecSource = pStream;
|
---|
1500 |
|
---|
1501 | if (pSink->In.pStreamRecSource)
|
---|
1502 | {
|
---|
1503 | const PPDMIAUDIOCONNECTOR pConn = pSink->In.pStreamRecSource->pConn;
|
---|
1504 | AssertPtr(pConn);
|
---|
1505 | rc = pConn->pfnEnable(pConn, PDMAUDIODIR_IN, true /* Enable */);
|
---|
1506 | }
|
---|
1507 | }
|
---|
1508 |
|
---|
1509 | LogFunc(("[%s] Recording source is now '%s', rc=%Rrc\n",
|
---|
1510 | pSink->pszName, pSink->In.pStreamRecSource ? pSink->In.pStreamRecSource->pszName : "<None>", rc));
|
---|
1511 |
|
---|
1512 | if (RT_SUCCESS(rc))
|
---|
1513 | {
|
---|
1514 | LogRel(("Mixer: Setting recording source of sink '%s' to '%s'\n",
|
---|
1515 | pSink->pszName, pSink->In.pStreamRecSource ? pSink->In.pStreamRecSource->pszName : "<None>"));
|
---|
1516 | }
|
---|
1517 | else
|
---|
1518 | LogRel(("Mixer: Setting recording source of sink '%s' to '%s' failed with %Rrc\n",
|
---|
1519 | pSink->pszName, pSink->In.pStreamRecSource ? pSink->In.pStreamRecSource->pszName : "<None>", rc));
|
---|
1520 |
|
---|
1521 | return rc;
|
---|
1522 | }
|
---|
1523 |
|
---|
1524 | /**
|
---|
1525 | * Set the current recording source of an input mixer sink.
|
---|
1526 | *
|
---|
1527 | * @return IPRT status code.
|
---|
1528 | * @param pSink Input mixer sink to set recording source for.
|
---|
1529 | * @param pStream Mixer stream to set as current recording source. Must be an input stream.
|
---|
1530 | * Set to NULL to un-set the current recording source.
|
---|
1531 | */
|
---|
1532 | int AudioMixerSinkSetRecordingSource(PAUDMIXSINK pSink, PAUDMIXSTREAM pStream)
|
---|
1533 | {
|
---|
1534 | AssertPtrReturn(pSink, VERR_INVALID_POINTER);
|
---|
1535 |
|
---|
1536 | int rc = RTCritSectEnter(&pSink->CritSect);
|
---|
1537 | if (RT_FAILURE(rc))
|
---|
1538 | return rc;
|
---|
1539 |
|
---|
1540 | rc = audioMixerSinkSetRecSourceInternal(pSink, pStream);
|
---|
1541 |
|
---|
1542 | int rc2 = RTCritSectLeave(&pSink->CritSect);
|
---|
1543 | AssertRC(rc2);
|
---|
1544 |
|
---|
1545 | return rc;
|
---|
1546 | }
|
---|
1547 |
|
---|
1548 | /**
|
---|
1549 | * Sets the volume of an individual sink.
|
---|
1550 | *
|
---|
1551 | * @returns IPRT status code.
|
---|
1552 | * @param pSink Sink to set volume for.
|
---|
1553 | * @param pVol Volume to set.
|
---|
1554 | */
|
---|
1555 | int AudioMixerSinkSetVolume(PAUDMIXSINK pSink, PPDMAUDIOVOLUME pVol)
|
---|
1556 | {
|
---|
1557 | AssertPtrReturn(pSink, VERR_INVALID_POINTER);
|
---|
1558 | AssertPtrReturn(pVol, VERR_INVALID_POINTER);
|
---|
1559 |
|
---|
1560 | int rc = RTCritSectEnter(&pSink->CritSect);
|
---|
1561 | if (RT_FAILURE(rc))
|
---|
1562 | return rc;
|
---|
1563 |
|
---|
1564 | memcpy(&pSink->Volume, pVol, sizeof(PDMAUDIOVOLUME));
|
---|
1565 |
|
---|
1566 | LogFlowFunc(("[%s] fMuted=%RTbool, lVol=%RU8, rVol=%RU8\n",
|
---|
1567 | pSink->pszName, pSink->Volume.fMuted, pSink->Volume.uLeft, pSink->Volume.uRight));
|
---|
1568 |
|
---|
1569 | LogRel2(("Mixer: Setting volume of sink '%s' to %RU8/%RU8 (%s)\n",
|
---|
1570 | pSink->pszName, pVol->uLeft, pVol->uRight, pVol->fMuted ? "Muted" : "Unmuted"));
|
---|
1571 |
|
---|
1572 | AssertPtr(pSink->pParent);
|
---|
1573 | rc = audioMixerSinkUpdateVolume(pSink, &pSink->pParent->VolMaster);
|
---|
1574 |
|
---|
1575 | int rc2 = RTCritSectLeave(&pSink->CritSect);
|
---|
1576 | AssertRC(rc2);
|
---|
1577 |
|
---|
1578 | return rc;
|
---|
1579 | }
|
---|
1580 |
|
---|
1581 | /**
|
---|
1582 | * Updates a mixer sink, internal version.
|
---|
1583 | *
|
---|
1584 | * @returns IPRT status code.
|
---|
1585 | * @param pSink Mixer sink to update.
|
---|
1586 | */
|
---|
1587 | static int audioMixerSinkUpdateInternal(PAUDMIXSINK pSink)
|
---|
1588 | {
|
---|
1589 | AssertPtrReturn(pSink, VERR_INVALID_POINTER);
|
---|
1590 |
|
---|
1591 | int rc = VINF_SUCCESS;
|
---|
1592 |
|
---|
1593 | #ifdef LOG_ENABLED
|
---|
1594 | char *pszStatus = dbgAudioMixerSinkStatusToStr(pSink->fStatus);
|
---|
1595 | Log3Func(("[%s] fStatus=%s\n", pSink->pszName, pszStatus));
|
---|
1596 | RTStrFree(pszStatus);
|
---|
1597 | #endif
|
---|
1598 |
|
---|
1599 | /* Sink disabled? Take a shortcut. */
|
---|
1600 | if (!(pSink->fStatus & AUDMIXSINK_STS_RUNNING))
|
---|
1601 | return rc;
|
---|
1602 |
|
---|
1603 | /* Input sink and no recording source set? Bail out early. */
|
---|
1604 | if ( pSink->enmDir == AUDMIXSINKDIR_INPUT
|
---|
1605 | && pSink->In.pStreamRecSource == NULL)
|
---|
1606 | return rc;
|
---|
1607 |
|
---|
1608 | /* Update each mixing sink stream's status. */
|
---|
1609 | PAUDMIXSTREAM pMixStream;
|
---|
1610 | RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
|
---|
1611 | {
|
---|
1612 | int rc2 = audioMixerStreamUpdateStatus(pMixStream);
|
---|
1613 | AssertRC(rc2);
|
---|
1614 | }
|
---|
1615 |
|
---|
1616 | /* Number of disabled streams of this sink. */
|
---|
1617 | uint8_t cStreamsDisabled = pSink->cStreams;
|
---|
1618 |
|
---|
1619 | /* Next, try to write (multiplex) as much audio data as possible to all connected mixer streams. */
|
---|
1620 | uint32_t cbToWriteToStreams = AudioMixBufUsedBytes(&pSink->MixBuf);
|
---|
1621 |
|
---|
1622 | uint8_t arrChunkBuf[_1K]; /** @todo Hm ... some zero copy / shared buffers would be nice! */
|
---|
1623 | while (cbToWriteToStreams)
|
---|
1624 | {
|
---|
1625 | uint32_t cfChunk;
|
---|
1626 | rc = AudioMixBufAcquireReadBlock(&pSink->MixBuf, arrChunkBuf, RT_MIN(cbToWriteToStreams, sizeof(arrChunkBuf)), &cfChunk);
|
---|
1627 | if (RT_FAILURE(rc))
|
---|
1628 | break;
|
---|
1629 |
|
---|
1630 | const uint32_t cbChunk = DrvAudioHlpFramesToBytes(cfChunk, &pSink->PCMProps);
|
---|
1631 | Assert(cbChunk <= sizeof(arrChunkBuf));
|
---|
1632 |
|
---|
1633 | /* Multiplex the current chunk in a synchronized fashion to all connected streams. */
|
---|
1634 | uint32_t cbChunkWrittenMin = 0;
|
---|
1635 | rc = audioMixerSinkMultiplexSync(pSink, AUDMIXOP_COPY, arrChunkBuf, cbChunk, &cbChunkWrittenMin);
|
---|
1636 | if (RT_SUCCESS(rc))
|
---|
1637 | {
|
---|
1638 | RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
|
---|
1639 | {
|
---|
1640 | int rc2 = audioMixerSinkWriteToStream(pSink, pMixStream);
|
---|
1641 | AssertRC(rc2);
|
---|
1642 | }
|
---|
1643 | }
|
---|
1644 |
|
---|
1645 | Log3Func(("[%s] cbChunk=%RU32, cbChunkWrittenMin=%RU32\n", pSink->pszName, cbChunk, cbChunkWrittenMin));
|
---|
1646 |
|
---|
1647 | AudioMixBufReleaseReadBlock(&pSink->MixBuf, AUDIOMIXBUF_B2F(&pSink->MixBuf, cbChunkWrittenMin));
|
---|
1648 |
|
---|
1649 | if ( RT_FAILURE(rc)
|
---|
1650 | || cbChunkWrittenMin == 0)
|
---|
1651 | break;
|
---|
1652 |
|
---|
1653 | Assert(cbToWriteToStreams >= cbChunkWrittenMin);
|
---|
1654 | cbToWriteToStreams -= cbChunkWrittenMin;
|
---|
1655 | }
|
---|
1656 |
|
---|
1657 | if ( !(pSink->fStatus & AUDMIXSINK_STS_DIRTY)
|
---|
1658 | && AudioMixBufUsed(&pSink->MixBuf)) /* Still audio output data left? Consider the sink as being "dirty" then. */
|
---|
1659 | {
|
---|
1660 | /* Set dirty bit. */
|
---|
1661 | pSink->fStatus |= AUDMIXSINK_STS_DIRTY;
|
---|
1662 | }
|
---|
1663 |
|
---|
1664 | RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
|
---|
1665 | {
|
---|
1666 | /* Input sink and not the recording source? Skip. */
|
---|
1667 | if ( pSink->enmDir == AUDMIXSINKDIR_INPUT
|
---|
1668 | && pSink->In.pStreamRecSource != pMixStream)
|
---|
1669 | continue;
|
---|
1670 |
|
---|
1671 | PPDMAUDIOSTREAM pStream = pMixStream->pStream;
|
---|
1672 | AssertPtr(pStream);
|
---|
1673 |
|
---|
1674 | PPDMIAUDIOCONNECTOR pConn = pMixStream->pConn;
|
---|
1675 | AssertPtr(pConn);
|
---|
1676 |
|
---|
1677 | uint32_t cfProc = 0;
|
---|
1678 |
|
---|
1679 | if (!(pMixStream->fStatus & AUDMIXSTREAM_STATUS_ENABLED))
|
---|
1680 | continue;
|
---|
1681 |
|
---|
1682 | int rc2 = pConn->pfnStreamIterate(pConn, pStream);
|
---|
1683 | if (RT_SUCCESS(rc2))
|
---|
1684 | {
|
---|
1685 | if (pSink->enmDir == AUDMIXSINKDIR_INPUT)
|
---|
1686 | {
|
---|
1687 | rc2 = pConn->pfnStreamCapture(pConn, pStream, &cfProc);
|
---|
1688 | if (RT_FAILURE(rc2))
|
---|
1689 | {
|
---|
1690 | LogFunc(("%s: Failed capturing stream '%s', rc=%Rrc\n", pSink->pszName, pStream->szName, rc2));
|
---|
1691 | continue;
|
---|
1692 | }
|
---|
1693 |
|
---|
1694 | if (cfProc)
|
---|
1695 | pSink->fStatus |= AUDMIXSINK_STS_DIRTY;
|
---|
1696 | }
|
---|
1697 | else if (pSink->enmDir == AUDMIXSINKDIR_OUTPUT)
|
---|
1698 | {
|
---|
1699 | rc2 = pConn->pfnStreamPlay(pConn, pStream, &cfProc);
|
---|
1700 | if (RT_FAILURE(rc2))
|
---|
1701 | {
|
---|
1702 | LogFunc(("%s: Failed playing stream '%s', rc=%Rrc\n", pSink->pszName, pStream->szName, rc2));
|
---|
1703 | continue;
|
---|
1704 | }
|
---|
1705 | }
|
---|
1706 | else
|
---|
1707 | {
|
---|
1708 | AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
|
---|
1709 | continue;
|
---|
1710 | }
|
---|
1711 | }
|
---|
1712 |
|
---|
1713 | const PDMAUDIOSTREAMSTS fStreamStatusNew = pConn->pfnStreamGetStatus(pConn, pStream);
|
---|
1714 |
|
---|
1715 | /* Is the stream enabled or in pending disable state?
|
---|
1716 | * Don't consider this stream as being disabled then. */
|
---|
1717 | if (fStreamStatusNew & (PDMAUDIOSTREAMSTS_FLAGS_ENABLED | PDMAUDIOSTREAMSTS_FLAGS_PENDING_DISABLE))
|
---|
1718 | cStreamsDisabled--;
|
---|
1719 | /* Note: The mixer stream's internal status will be updated in the next iteration of this function. */
|
---|
1720 |
|
---|
1721 | Log3Func(("\t%s: cPlayed/cCaptured=%RU32, rc2=%Rrc\n", pStream->szName, cfProc, rc2));
|
---|
1722 | }
|
---|
1723 |
|
---|
1724 | Log3Func(("[%s] fPendingDisable=%RTbool, %RU8/%RU8 streams disabled\n",
|
---|
1725 | pSink->pszName, RT_BOOL(pSink->fStatus & AUDMIXSINK_STS_PENDING_DISABLE), cStreamsDisabled, pSink->cStreams));
|
---|
1726 |
|
---|
1727 | /* Update last updated timestamp. */
|
---|
1728 | pSink->tsLastUpdatedMs = RTTimeMilliTS();
|
---|
1729 |
|
---|
1730 | /* All streams disabled and the sink is in pending disable mode? */
|
---|
1731 | if ( cStreamsDisabled == pSink->cStreams
|
---|
1732 | && (pSink->fStatus & AUDMIXSINK_STS_PENDING_DISABLE))
|
---|
1733 | {
|
---|
1734 | audioMixerSinkReset(pSink);
|
---|
1735 | }
|
---|
1736 |
|
---|
1737 | return rc;
|
---|
1738 | }
|
---|
1739 |
|
---|
1740 | /**
|
---|
1741 | * Updates (invalidates) a mixer sink.
|
---|
1742 | *
|
---|
1743 | * @returns IPRT status code.
|
---|
1744 | * @param pSink Mixer sink to update.
|
---|
1745 | */
|
---|
1746 | int AudioMixerSinkUpdate(PAUDMIXSINK pSink)
|
---|
1747 | {
|
---|
1748 | AssertPtrReturn(pSink, VERR_INVALID_POINTER);
|
---|
1749 |
|
---|
1750 | int rc = RTCritSectEnter(&pSink->CritSect);
|
---|
1751 | if (RT_FAILURE(rc))
|
---|
1752 | return rc;
|
---|
1753 |
|
---|
1754 | rc = audioMixerSinkUpdateInternal(pSink);
|
---|
1755 |
|
---|
1756 | int rc2 = RTCritSectLeave(&pSink->CritSect);
|
---|
1757 | AssertRC(rc2);
|
---|
1758 |
|
---|
1759 | return rc;
|
---|
1760 | }
|
---|
1761 |
|
---|
1762 | /**
|
---|
1763 | * Updates the (master) volume of a mixer sink.
|
---|
1764 | *
|
---|
1765 | * @returns IPRT status code.
|
---|
1766 | * @param pSink Mixer sink to update volume for.
|
---|
1767 | * @param pVolMaster Master volume to set.
|
---|
1768 | */
|
---|
1769 | static int audioMixerSinkUpdateVolume(PAUDMIXSINK pSink, const PPDMAUDIOVOLUME pVolMaster)
|
---|
1770 | {
|
---|
1771 | AssertPtrReturn(pSink, VERR_INVALID_POINTER);
|
---|
1772 | AssertPtrReturn(pVolMaster, VERR_INVALID_POINTER);
|
---|
1773 |
|
---|
1774 | LogFlowFunc(("[%s] Master fMuted=%RTbool, lVol=%RU32, rVol=%RU32\n",
|
---|
1775 | pSink->pszName, pVolMaster->fMuted, pVolMaster->uLeft, pVolMaster->uRight));
|
---|
1776 | LogFlowFunc(("[%s] fMuted=%RTbool, lVol=%RU32, rVol=%RU32 ",
|
---|
1777 | pSink->pszName, pSink->Volume.fMuted, pSink->Volume.uLeft, pSink->Volume.uRight));
|
---|
1778 |
|
---|
1779 | /** @todo Very crude implementation for now -- needs more work! */
|
---|
1780 |
|
---|
1781 | pSink->VolumeCombined.fMuted = pVolMaster->fMuted || pSink->Volume.fMuted;
|
---|
1782 |
|
---|
1783 | pSink->VolumeCombined.uLeft = ( (pSink->Volume.uLeft ? pSink->Volume.uLeft : 1)
|
---|
1784 | * (pVolMaster->uLeft ? pVolMaster->uLeft : 1)) / PDMAUDIO_VOLUME_MAX;
|
---|
1785 |
|
---|
1786 | pSink->VolumeCombined.uRight = ( (pSink->Volume.uRight ? pSink->Volume.uRight : 1)
|
---|
1787 | * (pVolMaster->uRight ? pVolMaster->uRight : 1)) / PDMAUDIO_VOLUME_MAX;
|
---|
1788 |
|
---|
1789 | LogFlow(("-> fMuted=%RTbool, lVol=%RU32, rVol=%RU32\n",
|
---|
1790 | pSink->VolumeCombined.fMuted, pSink->VolumeCombined.uLeft, pSink->VolumeCombined.uRight));
|
---|
1791 |
|
---|
1792 | /* Propagate new sink volume to all streams in the sink. */
|
---|
1793 | PAUDMIXSTREAM pMixStream;
|
---|
1794 | RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
|
---|
1795 | {
|
---|
1796 | int rc2 = pMixStream->pConn->pfnStreamSetVolume(pMixStream->pConn, pMixStream->pStream, &pSink->VolumeCombined);
|
---|
1797 | AssertRC(rc2);
|
---|
1798 | }
|
---|
1799 |
|
---|
1800 | return VINF_SUCCESS;
|
---|
1801 | }
|
---|
1802 |
|
---|
1803 | /**
|
---|
1804 | * Writes (buffered) output data of a sink's stream to the bound audio connector stream.
|
---|
1805 | *
|
---|
1806 | * @returns IPRT status code.
|
---|
1807 | * @param pSink Sink of stream that contains the mixer stream.
|
---|
1808 | * @param pMixStream Mixer stream to write output data for.
|
---|
1809 | */
|
---|
1810 | static int audioMixerSinkWriteToStream(PAUDMIXSINK pSink, PAUDMIXSTREAM pMixStream)
|
---|
1811 | {
|
---|
1812 | if (!pMixStream->pCircBuf)
|
---|
1813 | return VINF_SUCCESS;
|
---|
1814 |
|
---|
1815 | return audioMixerSinkWriteToStreamEx(pSink, pMixStream, (uint32_t)RTCircBufUsed(pMixStream->pCircBuf), NULL /* pcbWritten */);
|
---|
1816 | }
|
---|
1817 |
|
---|
1818 | /**
|
---|
1819 | * Writes (buffered) output data of a sink's stream to the bound audio connector stream, extended version.
|
---|
1820 | *
|
---|
1821 | * @returns IPRT status code.
|
---|
1822 | * @param pSink Sink of stream that contains the mixer stream.
|
---|
1823 | * @param pMixStream Mixer stream to write output data for.
|
---|
1824 | * @param cbToWrite Size (in bytes) to write.
|
---|
1825 | * @param pcbWritten Size (in bytes) written on success. Optional.
|
---|
1826 | */
|
---|
1827 | static int audioMixerSinkWriteToStreamEx(PAUDMIXSINK pSink, PAUDMIXSTREAM pMixStream, uint32_t cbToWrite, uint32_t *pcbWritten)
|
---|
1828 | {
|
---|
1829 | /* pcbWritten is optional. */
|
---|
1830 |
|
---|
1831 | if ( !cbToWrite
|
---|
1832 | || !(pMixStream->fStatus & AUDMIXSTREAM_STATUS_ENABLED))
|
---|
1833 | {
|
---|
1834 | if (pcbWritten)
|
---|
1835 | *pcbWritten = 0;
|
---|
1836 |
|
---|
1837 | return VINF_SUCCESS;
|
---|
1838 | }
|
---|
1839 |
|
---|
1840 | PRTCIRCBUF pCircBuf = pMixStream->pCircBuf;
|
---|
1841 |
|
---|
1842 | const uint32_t cbWritableStream = pMixStream->pConn->pfnStreamGetWritable(pMixStream->pConn, pMixStream->pStream);
|
---|
1843 | cbToWrite = RT_MIN(cbToWrite, RT_MIN((uint32_t)RTCircBufUsed(pCircBuf), cbWritableStream));
|
---|
1844 |
|
---|
1845 | Log3Func(("[%s] cbWritableStream=%RU32, cbToWrite=%RU32\n",
|
---|
1846 | pMixStream->pszName, cbWritableStream, cbToWrite));
|
---|
1847 |
|
---|
1848 | uint32_t cbWritten = 0;
|
---|
1849 |
|
---|
1850 | int rc = VINF_SUCCESS;
|
---|
1851 |
|
---|
1852 | while (cbToWrite)
|
---|
1853 | {
|
---|
1854 | void *pvChunk;
|
---|
1855 | size_t cbChunk;
|
---|
1856 | RTCircBufAcquireReadBlock(pCircBuf, cbToWrite, &pvChunk, &cbChunk);
|
---|
1857 |
|
---|
1858 | Log3Func(("[%s] cbChunk=%RU32\n", pMixStream->pszName, cbChunk));
|
---|
1859 |
|
---|
1860 | uint32_t cbChunkWritten = 0;
|
---|
1861 | if (cbChunk)
|
---|
1862 | {
|
---|
1863 | rc = pMixStream->pConn->pfnStreamWrite(pMixStream->pConn, pMixStream->pStream, pvChunk, (uint32_t)cbChunk,
|
---|
1864 | &cbChunkWritten);
|
---|
1865 | if (RT_FAILURE(rc))
|
---|
1866 | {
|
---|
1867 | if (rc == VERR_BUFFER_OVERFLOW)
|
---|
1868 | {
|
---|
1869 | LogRel2(("Mixer: Buffer overrun for mixer stream '%s' (sink '%s')\n", pMixStream->pszName, pSink->pszName));
|
---|
1870 | break;
|
---|
1871 | }
|
---|
1872 | else if (rc == VERR_AUDIO_STREAM_NOT_READY)
|
---|
1873 | {
|
---|
1874 | /* Stream is not enabled, just skip. */
|
---|
1875 | rc = VINF_SUCCESS;
|
---|
1876 | }
|
---|
1877 | else
|
---|
1878 | LogRel2(("Mixer: Writing to mixer stream '%s' (sink '%s') failed, rc=%Rrc\n",
|
---|
1879 | pMixStream->pszName, pSink->pszName, rc));
|
---|
1880 |
|
---|
1881 | if (RT_FAILURE(rc))
|
---|
1882 | LogFunc(("[%s] Failed writing to stream '%s': %Rrc\n", pSink->pszName, pMixStream->pszName, rc));
|
---|
1883 | }
|
---|
1884 | }
|
---|
1885 |
|
---|
1886 | RTCircBufReleaseReadBlock(pCircBuf, cbChunkWritten);
|
---|
1887 |
|
---|
1888 | if ( RT_FAILURE(rc)
|
---|
1889 | || !cbChunkWritten)
|
---|
1890 | break;
|
---|
1891 |
|
---|
1892 | Assert(cbToWrite >= cbChunkWritten);
|
---|
1893 | cbToWrite -= (uint32_t)cbChunkWritten;
|
---|
1894 |
|
---|
1895 | cbWritten += (uint32_t)cbChunkWritten;
|
---|
1896 | }
|
---|
1897 |
|
---|
1898 | Log3Func(("[%s] cbWritten=%RU32\n", pMixStream->pszName, cbWritten));
|
---|
1899 |
|
---|
1900 | if (pcbWritten)
|
---|
1901 | *pcbWritten = cbWritten;
|
---|
1902 |
|
---|
1903 | #ifdef DEBUG_andy
|
---|
1904 | AssertRC(rc);
|
---|
1905 | #endif
|
---|
1906 |
|
---|
1907 | return rc;
|
---|
1908 | }
|
---|
1909 |
|
---|
1910 | /**
|
---|
1911 | * Multiplexes audio output data to all connected mixer streams in a synchronized fashion, e.g.
|
---|
1912 | * only multiplex as much data as all streams can handle at this time.
|
---|
1913 | *
|
---|
1914 | * @returns IPRT status code.
|
---|
1915 | * @param pSink Sink to write audio output to.
|
---|
1916 | * @param enmOp What mixing operation to use. Currently not implemented.
|
---|
1917 | * @param pvBuf Pointer to audio data to write.
|
---|
1918 | * @param cbBuf Size (in bytes) of audio data to write.
|
---|
1919 | * @param pcbWrittenMin Returns minimum size (in bytes) successfully written to all mixer streams. Optional.
|
---|
1920 | */
|
---|
1921 | static int audioMixerSinkMultiplexSync(PAUDMIXSINK pSink, AUDMIXOP enmOp, const void *pvBuf, uint32_t cbBuf,
|
---|
1922 | uint32_t *pcbWrittenMin)
|
---|
1923 | {
|
---|
1924 | AssertReturn(cbBuf, VERR_INVALID_PARAMETER);
|
---|
1925 | RT_NOREF(enmOp);
|
---|
1926 |
|
---|
1927 | AssertMsg(pSink->enmDir == AUDMIXSINKDIR_OUTPUT,
|
---|
1928 | ("%s: Can't multiplex to a sink which is not an output sink\n", pSink->pszName));
|
---|
1929 |
|
---|
1930 | int rc = VINF_SUCCESS;
|
---|
1931 |
|
---|
1932 | uint32_t cbToWriteMin = UINT32_MAX;
|
---|
1933 |
|
---|
1934 | Log3Func(("[%s] cbBuf=%RU32\n", pSink->pszName, cbBuf));
|
---|
1935 |
|
---|
1936 | PAUDMIXSTREAM pMixStream;
|
---|
1937 | RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
|
---|
1938 | {
|
---|
1939 | if (!(pMixStream->fStatus & AUDMIXSTREAM_STATUS_ENABLED)) /* Mixing stream not enabled? Skip handling. */
|
---|
1940 | {
|
---|
1941 | Log3Func(("[%s] Stream '%s' disabled, skipping ...\n", pSink->pszName, pMixStream->pszName));
|
---|
1942 | continue;
|
---|
1943 | }
|
---|
1944 |
|
---|
1945 | cbToWriteMin = RT_MIN(cbBuf, RT_MIN(cbToWriteMin, (uint32_t)RTCircBufFree(pMixStream->pCircBuf)));
|
---|
1946 | }
|
---|
1947 |
|
---|
1948 | if (cbToWriteMin == UINT32_MAX) /* No space at all? */
|
---|
1949 | cbToWriteMin = 0;
|
---|
1950 |
|
---|
1951 | if (cbToWriteMin)
|
---|
1952 | {
|
---|
1953 | RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
|
---|
1954 | {
|
---|
1955 | if (!(pMixStream->fStatus & AUDMIXSTREAM_STATUS_ENABLED)) /* Mixing stream not enabled? Skip handling. */
|
---|
1956 | continue;
|
---|
1957 |
|
---|
1958 | PRTCIRCBUF pCircBuf = pMixStream->pCircBuf;
|
---|
1959 | void *pvChunk;
|
---|
1960 | size_t cbChunk;
|
---|
1961 |
|
---|
1962 | uint32_t cbWrittenBuf = 0;
|
---|
1963 | uint32_t cbToWriteBuf = cbToWriteMin;
|
---|
1964 |
|
---|
1965 | while (cbToWriteBuf)
|
---|
1966 | {
|
---|
1967 | RTCircBufAcquireWriteBlock(pCircBuf, cbToWriteBuf, &pvChunk, &cbChunk);
|
---|
1968 |
|
---|
1969 | if (cbChunk)
|
---|
1970 | memcpy(pvChunk, (uint8_t *)pvBuf + cbWrittenBuf, cbChunk);
|
---|
1971 |
|
---|
1972 | RTCircBufReleaseWriteBlock(pCircBuf, cbChunk);
|
---|
1973 |
|
---|
1974 | cbWrittenBuf += (uint32_t)cbChunk;
|
---|
1975 | Assert(cbWrittenBuf <= cbBuf);
|
---|
1976 |
|
---|
1977 | Assert(cbToWriteBuf >= cbChunk);
|
---|
1978 | cbToWriteBuf -= (uint32_t)cbChunk;
|
---|
1979 | }
|
---|
1980 |
|
---|
1981 | if (cbWrittenBuf) /* Update the mixer stream's last written time stamp. */
|
---|
1982 | pMixStream->tsLastReadWrittenNs = RTTimeNanoTS();
|
---|
1983 |
|
---|
1984 | Log3Func(("[%s] Mixer stream '%s' -> cbWrittenBuf=%RU32\n", pSink->pszName, pMixStream->pszName, cbWrittenBuf));
|
---|
1985 | }
|
---|
1986 | }
|
---|
1987 |
|
---|
1988 | Log3Func(("[%s] cbBuf=%RU32, cbToWriteMin=%RU32\n", pSink->pszName, cbBuf, cbToWriteMin));
|
---|
1989 |
|
---|
1990 | if (pcbWrittenMin)
|
---|
1991 | *pcbWrittenMin = cbToWriteMin;
|
---|
1992 |
|
---|
1993 | return rc;
|
---|
1994 | }
|
---|
1995 |
|
---|
1996 | /**
|
---|
1997 | * Writes data to a mixer sink.
|
---|
1998 | *
|
---|
1999 | * @returns IPRT status code.
|
---|
2000 | * @param pSink Sink to write data to.
|
---|
2001 | * @param enmOp Mixer operation to use when writing data to the sink.
|
---|
2002 | * @param pvBuf Buffer containing the audio data to write.
|
---|
2003 | * @param cbBuf Size (in bytes) of the buffer containing the audio data.
|
---|
2004 | * @param pcbWritten Number of bytes written. Optional.
|
---|
2005 | */
|
---|
2006 | int AudioMixerSinkWrite(PAUDMIXSINK pSink, AUDMIXOP enmOp, const void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten)
|
---|
2007 | {
|
---|
2008 | AssertPtrReturn(pSink, VERR_INVALID_POINTER);
|
---|
2009 | RT_NOREF(enmOp);
|
---|
2010 | AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
|
---|
2011 | AssertReturn (cbBuf, VERR_INVALID_PARAMETER);
|
---|
2012 | /* pcbWritten is optional. */
|
---|
2013 |
|
---|
2014 | int rc = RTCritSectEnter(&pSink->CritSect);
|
---|
2015 | if (RT_FAILURE(rc))
|
---|
2016 | return rc;
|
---|
2017 |
|
---|
2018 | AssertMsg(pSink->fStatus & AUDMIXSINK_STS_RUNNING,
|
---|
2019 | ("%s: Can't write to a sink which is not running (anymore) (status 0x%x)\n", pSink->pszName, pSink->fStatus));
|
---|
2020 | AssertMsg(pSink->enmDir == AUDMIXSINKDIR_OUTPUT,
|
---|
2021 | ("%s: Can't write to a sink which is not an output sink\n", pSink->pszName));
|
---|
2022 |
|
---|
2023 | uint32_t cbWritten = 0;
|
---|
2024 | uint32_t cbToWrite = RT_MIN(AudioMixBufFreeBytes(&pSink->MixBuf), cbBuf);
|
---|
2025 | while (cbToWrite)
|
---|
2026 | {
|
---|
2027 | /* First, write the data to the mixer sink's own mixing buffer.
|
---|
2028 | * Here the audio data can be transformed into the mixer sink's format. */
|
---|
2029 | uint32_t cfWritten = 0;
|
---|
2030 | rc = AudioMixBufWriteCirc(&pSink->MixBuf, (uint8_t *)pvBuf + cbWritten, cbToWrite, &cfWritten);
|
---|
2031 | if (RT_FAILURE(rc))
|
---|
2032 | break;
|
---|
2033 |
|
---|
2034 | const uint32_t cbWrittenChunk = DrvAudioHlpFramesToBytes(cfWritten, &pSink->PCMProps);
|
---|
2035 |
|
---|
2036 | Assert(cbToWrite >= cbWrittenChunk);
|
---|
2037 | cbToWrite -= cbWrittenChunk;
|
---|
2038 | cbWritten += cbWrittenChunk;
|
---|
2039 | }
|
---|
2040 |
|
---|
2041 | Log3Func(("[%s] cbBuf=%RU32 -> cbWritten=%RU32\n", pSink->pszName, cbBuf, cbWritten));
|
---|
2042 |
|
---|
2043 | /* Update the sink's last written time stamp. */
|
---|
2044 | pSink->tsLastReadWrittenNs = RTTimeNanoTS();
|
---|
2045 |
|
---|
2046 | if (pcbWritten)
|
---|
2047 | *pcbWritten = cbWritten;
|
---|
2048 |
|
---|
2049 | int rc2 = RTCritSectLeave(&pSink->CritSect);
|
---|
2050 | AssertRC(rc2);
|
---|
2051 |
|
---|
2052 | return rc;
|
---|
2053 | }
|
---|
2054 |
|
---|
2055 | /*********************************************************************************************************************************
|
---|
2056 | * Mixer Stream implementation.
|
---|
2057 | ********************************************************************************************************************************/
|
---|
2058 |
|
---|
2059 | /**
|
---|
2060 | * Controls a mixer stream, internal version.
|
---|
2061 | *
|
---|
2062 | * @returns IPRT status code.
|
---|
2063 | * @param pMixStream Mixer stream to control.
|
---|
2064 | * @param enmCmd Mixer stream command to use.
|
---|
2065 | * @param fCtl Additional control flags. Pass 0.
|
---|
2066 | */
|
---|
2067 | static int audioMixerStreamCtlInternal(PAUDMIXSTREAM pMixStream, PDMAUDIOSTREAMCMD enmCmd, uint32_t fCtl)
|
---|
2068 | {
|
---|
2069 | AssertPtr(pMixStream->pConn);
|
---|
2070 | AssertPtr(pMixStream->pStream);
|
---|
2071 |
|
---|
2072 | RT_NOREF(fCtl);
|
---|
2073 |
|
---|
2074 | int rc = pMixStream->pConn->pfnStreamControl(pMixStream->pConn, pMixStream->pStream, enmCmd);
|
---|
2075 |
|
---|
2076 | LogFlowFunc(("[%s] enmCmd=%ld, rc=%Rrc\n", pMixStream->pszName, enmCmd, rc));
|
---|
2077 |
|
---|
2078 | return rc;
|
---|
2079 | }
|
---|
2080 |
|
---|
2081 | /**
|
---|
2082 | * Updates a mixer stream's internal status.
|
---|
2083 | *
|
---|
2084 | * @returns VBox status code.
|
---|
2085 | * @param pMixStream Mixer stream to to update internal status for.
|
---|
2086 | */
|
---|
2087 | static int audioMixerStreamUpdateStatus(PAUDMIXSTREAM pMixStream)
|
---|
2088 | {
|
---|
2089 | pMixStream->fStatus = AUDMIXSTREAM_STATUS_NONE;
|
---|
2090 |
|
---|
2091 | if (pMixStream->pConn) /* Audio connector available? */
|
---|
2092 | {
|
---|
2093 | const uint32_t fStreamStatus = pMixStream->pConn->pfnStreamGetStatus(pMixStream->pConn, pMixStream->pStream);
|
---|
2094 |
|
---|
2095 | if (DrvAudioHlpStreamStatusIsReady(fStreamStatus))
|
---|
2096 | pMixStream->fStatus |= AUDMIXSTREAM_STATUS_ENABLED;
|
---|
2097 |
|
---|
2098 | AssertPtr(pMixStream->pSink);
|
---|
2099 | switch (pMixStream->pSink->enmDir)
|
---|
2100 | {
|
---|
2101 | case AUDMIXSINKDIR_INPUT:
|
---|
2102 | if (DrvAudioHlpStreamStatusCanRead(fStreamStatus))
|
---|
2103 | pMixStream->fStatus |= AUDMIXSTREAM_STATUS_CAN_READ;
|
---|
2104 | break;
|
---|
2105 |
|
---|
2106 | case AUDMIXSINKDIR_OUTPUT:
|
---|
2107 | if (DrvAudioHlpStreamStatusCanWrite(fStreamStatus))
|
---|
2108 | pMixStream->fStatus |= AUDMIXSTREAM_STATUS_CAN_WRITE;
|
---|
2109 | break;
|
---|
2110 |
|
---|
2111 | default:
|
---|
2112 | AssertFailedReturn(VERR_NOT_IMPLEMENTED);
|
---|
2113 | break;
|
---|
2114 | }
|
---|
2115 | }
|
---|
2116 |
|
---|
2117 | LogFlowFunc(("[%s] -> 0x%x\n", pMixStream->pszName, pMixStream->fStatus));
|
---|
2118 | return VINF_SUCCESS;
|
---|
2119 | }
|
---|
2120 |
|
---|
2121 | /**
|
---|
2122 | * Controls a mixer stream.
|
---|
2123 | *
|
---|
2124 | * @returns IPRT status code.
|
---|
2125 | * @param pMixStream Mixer stream to control.
|
---|
2126 | * @param enmCmd Mixer stream command to use.
|
---|
2127 | * @param fCtl Additional control flags. Pass 0.
|
---|
2128 | */
|
---|
2129 | int AudioMixerStreamCtl(PAUDMIXSTREAM pMixStream, PDMAUDIOSTREAMCMD enmCmd, uint32_t fCtl)
|
---|
2130 | {
|
---|
2131 | RT_NOREF(fCtl);
|
---|
2132 | AssertPtrReturn(pMixStream, VERR_INVALID_POINTER);
|
---|
2133 | /** @todo Validate fCtl. */
|
---|
2134 |
|
---|
2135 | int rc = RTCritSectEnter(&pMixStream->CritSect);
|
---|
2136 | if (RT_FAILURE(rc))
|
---|
2137 | return rc;
|
---|
2138 |
|
---|
2139 | rc = audioMixerStreamCtlInternal(pMixStream, enmCmd, fCtl);
|
---|
2140 |
|
---|
2141 | int rc2 = RTCritSectLeave(&pMixStream->CritSect);
|
---|
2142 | if (RT_SUCCESS(rc))
|
---|
2143 | rc = rc2;
|
---|
2144 |
|
---|
2145 | return rc;
|
---|
2146 | }
|
---|
2147 |
|
---|
2148 | /**
|
---|
2149 | * Destroys a mixer stream, internal version.
|
---|
2150 | *
|
---|
2151 | * @param pMixStream Mixer stream to destroy.
|
---|
2152 | */
|
---|
2153 | static void audioMixerStreamDestroyInternal(PAUDMIXSTREAM pMixStream)
|
---|
2154 | {
|
---|
2155 | AssertPtrReturnVoid(pMixStream);
|
---|
2156 |
|
---|
2157 | LogFunc(("%s\n", pMixStream->pszName));
|
---|
2158 |
|
---|
2159 | if (pMixStream->pConn) /* Stream has a connector interface present? */
|
---|
2160 | {
|
---|
2161 | if (pMixStream->pStream)
|
---|
2162 | {
|
---|
2163 | pMixStream->pConn->pfnStreamRelease(pMixStream->pConn, pMixStream->pStream);
|
---|
2164 | pMixStream->pConn->pfnStreamDestroy(pMixStream->pConn, pMixStream->pStream);
|
---|
2165 |
|
---|
2166 | pMixStream->pStream = NULL;
|
---|
2167 | }
|
---|
2168 |
|
---|
2169 | pMixStream->pConn = NULL;
|
---|
2170 | }
|
---|
2171 |
|
---|
2172 | if (pMixStream->pszName)
|
---|
2173 | {
|
---|
2174 | RTStrFree(pMixStream->pszName);
|
---|
2175 | pMixStream->pszName = NULL;
|
---|
2176 | }
|
---|
2177 |
|
---|
2178 | if (pMixStream->pCircBuf)
|
---|
2179 | {
|
---|
2180 | RTCircBufDestroy(pMixStream->pCircBuf);
|
---|
2181 | pMixStream->pCircBuf = NULL;
|
---|
2182 | }
|
---|
2183 |
|
---|
2184 | int rc2 = RTCritSectDelete(&pMixStream->CritSect);
|
---|
2185 | AssertRC(rc2);
|
---|
2186 |
|
---|
2187 | RTMemFree(pMixStream);
|
---|
2188 | pMixStream = NULL;
|
---|
2189 | }
|
---|
2190 |
|
---|
2191 | /**
|
---|
2192 | * Destroys a mixer stream.
|
---|
2193 | *
|
---|
2194 | * @param pMixStream Mixer stream to destroy.
|
---|
2195 | */
|
---|
2196 | void AudioMixerStreamDestroy(PAUDMIXSTREAM pMixStream)
|
---|
2197 | {
|
---|
2198 | if (!pMixStream)
|
---|
2199 | return;
|
---|
2200 |
|
---|
2201 | int rc2 = RTCritSectEnter(&pMixStream->CritSect);
|
---|
2202 | AssertRC(rc2);
|
---|
2203 |
|
---|
2204 | LogFunc(("%s\n", pMixStream->pszName));
|
---|
2205 |
|
---|
2206 | if (pMixStream->pSink) /* Is the stream part of a sink? */
|
---|
2207 | {
|
---|
2208 | /* Save sink pointer, as after audioMixerSinkRemoveStreamInternal() the
|
---|
2209 | * pointer will be gone from the stream. */
|
---|
2210 | PAUDMIXSINK pSink = pMixStream->pSink;
|
---|
2211 |
|
---|
2212 | rc2 = audioMixerSinkRemoveStreamInternal(pSink, pMixStream);
|
---|
2213 | if (RT_SUCCESS(rc2))
|
---|
2214 | {
|
---|
2215 | Assert(pSink->cStreams);
|
---|
2216 | pSink->cStreams--;
|
---|
2217 | }
|
---|
2218 | }
|
---|
2219 | else
|
---|
2220 | rc2 = VINF_SUCCESS;
|
---|
2221 |
|
---|
2222 | int rc3 = RTCritSectLeave(&pMixStream->CritSect);
|
---|
2223 | AssertRC(rc3);
|
---|
2224 |
|
---|
2225 | if (RT_SUCCESS(rc2))
|
---|
2226 | {
|
---|
2227 | audioMixerStreamDestroyInternal(pMixStream);
|
---|
2228 | pMixStream = NULL;
|
---|
2229 | }
|
---|
2230 |
|
---|
2231 | LogFlowFunc(("Returning %Rrc\n", rc2));
|
---|
2232 | }
|
---|
2233 |
|
---|
2234 | /**
|
---|
2235 | * Returns whether a mixer stream currently is active (playing/recording) or not.
|
---|
2236 | *
|
---|
2237 | * @returns @c true if playing/recording, @c false if not.
|
---|
2238 | * @param pMixStream Mixer stream to return status for.
|
---|
2239 | */
|
---|
2240 | bool AudioMixerStreamIsActive(PAUDMIXSTREAM pMixStream)
|
---|
2241 | {
|
---|
2242 | int rc2 = RTCritSectEnter(&pMixStream->CritSect);
|
---|
2243 | if (RT_FAILURE(rc2))
|
---|
2244 | return false;
|
---|
2245 |
|
---|
2246 | AssertPtr(pMixStream->pConn);
|
---|
2247 | AssertPtr(pMixStream->pStream);
|
---|
2248 |
|
---|
2249 | bool fIsActive;
|
---|
2250 |
|
---|
2251 | if ( pMixStream->pConn
|
---|
2252 | && pMixStream->pStream
|
---|
2253 | && RT_BOOL(pMixStream->pConn->pfnStreamGetStatus(pMixStream->pConn, pMixStream->pStream) & PDMAUDIOSTREAMSTS_FLAGS_ENABLED))
|
---|
2254 | {
|
---|
2255 | fIsActive = true;
|
---|
2256 | }
|
---|
2257 | else
|
---|
2258 | fIsActive = false;
|
---|
2259 |
|
---|
2260 | rc2 = RTCritSectLeave(&pMixStream->CritSect);
|
---|
2261 | AssertRC(rc2);
|
---|
2262 |
|
---|
2263 | return fIsActive;
|
---|
2264 | }
|
---|
2265 |
|
---|
2266 | /**
|
---|
2267 | * Returns whether a mixer stream is valid (e.g. initialized and in a working state) or not.
|
---|
2268 | *
|
---|
2269 | * @returns @c true if valid, @c false if not.
|
---|
2270 | * @param pMixStream Mixer stream to return status for.
|
---|
2271 | */
|
---|
2272 | bool AudioMixerStreamIsValid(PAUDMIXSTREAM pMixStream)
|
---|
2273 | {
|
---|
2274 | if (!pMixStream)
|
---|
2275 | return false;
|
---|
2276 |
|
---|
2277 | int rc2 = RTCritSectEnter(&pMixStream->CritSect);
|
---|
2278 | if (RT_FAILURE(rc2))
|
---|
2279 | return false;
|
---|
2280 |
|
---|
2281 | bool fIsValid;
|
---|
2282 |
|
---|
2283 | if ( pMixStream->pConn
|
---|
2284 | && pMixStream->pStream
|
---|
2285 | && RT_BOOL(pMixStream->pConn->pfnStreamGetStatus(pMixStream->pConn, pMixStream->pStream) & PDMAUDIOSTREAMSTS_FLAGS_INITIALIZED))
|
---|
2286 | {
|
---|
2287 | fIsValid = true;
|
---|
2288 | }
|
---|
2289 | else
|
---|
2290 | fIsValid = false;
|
---|
2291 |
|
---|
2292 | rc2 = RTCritSectLeave(&pMixStream->CritSect);
|
---|
2293 | AssertRC(rc2);
|
---|
2294 |
|
---|
2295 | return fIsValid;
|
---|
2296 | }
|
---|
2297 |
|
---|