1 | /* $Id: AudioMixer.cpp 103162 2024-02-01 13:23:46Z vboxsync $ */
|
---|
2 | /** @file
|
---|
3 | * Audio mixing routines for multiplexing audio sources in device emulations.
|
---|
4 | */
|
---|
5 |
|
---|
6 | /*
|
---|
7 | * Copyright (C) 2014-2023 Oracle and/or its affiliates.
|
---|
8 | *
|
---|
9 | * This file is part of VirtualBox base platform packages, as
|
---|
10 | * available from https://www.virtualbox.org.
|
---|
11 | *
|
---|
12 | * This program is free software; you can redistribute it and/or
|
---|
13 | * modify it under the terms of the GNU General Public License
|
---|
14 | * as published by the Free Software Foundation, in version 3 of the
|
---|
15 | * License.
|
---|
16 | *
|
---|
17 | * This program is distributed in the hope that it will be useful, but
|
---|
18 | * WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
19 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
---|
20 | * General Public License for more details.
|
---|
21 | *
|
---|
22 | * You should have received a copy of the GNU General Public License
|
---|
23 | * along with this program; if not, see <https://www.gnu.org/licenses>.
|
---|
24 | *
|
---|
25 | * SPDX-License-Identifier: GPL-3.0-only
|
---|
26 | */
|
---|
27 |
|
---|
28 | /** @page pg_audio_mixer Audio Mixer
|
---|
29 | *
|
---|
30 | * @section sec_audio_mixer_overview Overview
|
---|
31 | *
|
---|
32 | * This mixer acts as a layer between the audio connector interface and the
|
---|
33 | * actual device emulation, providing mechanisms for audio input sinks (sometime
|
---|
34 | * referred to as audio sources) and audio output sinks.
|
---|
35 | *
|
---|
36 | * Think of this mixer as kind of a higher level interface for the audio device
|
---|
37 | * to use in steado of PDMIAUDIOCONNECTOR, where it works with sinks rather than
|
---|
38 | * individual PDMAUDIOSTREAM instances.
|
---|
39 | *
|
---|
40 | * How and which audio streams are connected to the sinks depends on how the
|
---|
41 | * audio mixer has been set up by the device. Though, generally, each driver
|
---|
42 | * chain (LUN) has a mixer stream for each sink.
|
---|
43 | *
|
---|
44 | * An output sink can connect multiple output streams together, whereas an input
|
---|
45 | * sink (source) does this with input streams. Each of these mixer stream will
|
---|
46 | * in turn point to actual PDMAUDIOSTREAM instances.
|
---|
47 | *
|
---|
48 | * A mixing sink employs an own audio mixing buffer in a standard format (32-bit
|
---|
49 | * signed) with the virtual device's rate and channel configuration. The mixer
|
---|
50 | * streams will convert to/from this as they write and read from it.
|
---|
51 | *
|
---|
52 | *
|
---|
53 | * @section sec_audio_mixer_playback Playback
|
---|
54 | *
|
---|
55 | * For output sinks there can be one or more mixing stream attached.
|
---|
56 | *
|
---|
57 | * The backends are the consumers here and if they don't get samples when then
|
---|
58 | * need them we'll be having cracles, distortion and/or bits of silence in the
|
---|
59 | * actual output. The guest runs independently at it's on speed (see @ref
|
---|
60 | * sec_pdm_audio_timing for more details) and we're just inbetween trying to
|
---|
61 | * shuffle the data along as best as we can. If one or more of the backends
|
---|
62 | * for some reason isn't able to process data at a nominal speed (as defined by
|
---|
63 | * the others), we'll try detect this, mark it as bad and disregard it when
|
---|
64 | * calculating how much we can write to the backends in a buffer update call.
|
---|
65 | *
|
---|
66 | * This is called synchronous multiplexing.
|
---|
67 | *
|
---|
68 | *
|
---|
69 | * @section sec_audio_mixer_recording Recording
|
---|
70 | *
|
---|
71 | * For input sinks (sources) we blend the samples of all mixing streams
|
---|
72 | * together, however ignoring silent ones to avoid too much of a hit on the
|
---|
73 | * volume level. It is otherwise very similar to playback, only the direction
|
---|
74 | * is different and we don't multicast but blend.
|
---|
75 | *
|
---|
76 | */
|
---|
77 |
|
---|
78 |
|
---|
79 | /*********************************************************************************************************************************
|
---|
80 | * Header Files *
|
---|
81 | *********************************************************************************************************************************/
|
---|
82 | #define LOG_GROUP LOG_GROUP_AUDIO_MIXER
|
---|
83 | #include <VBox/log.h>
|
---|
84 | #include "AudioMixer.h"
|
---|
85 | #include "AudioMixBuffer.h"
|
---|
86 | #include "AudioHlp.h"
|
---|
87 |
|
---|
88 | #include <VBox/vmm/pdm.h>
|
---|
89 | #include <VBox/err.h>
|
---|
90 | #include <VBox/vmm/mm.h>
|
---|
91 | #include <VBox/vmm/pdmaudioifs.h>
|
---|
92 | #include <VBox/vmm/pdmaudioinline.h>
|
---|
93 |
|
---|
94 | #include <iprt/alloc.h>
|
---|
95 | #include <iprt/asm-math.h>
|
---|
96 | #include <iprt/assert.h>
|
---|
97 | #include <iprt/semaphore.h>
|
---|
98 | #include <iprt/string.h>
|
---|
99 | #include <iprt/thread.h>
|
---|
100 |
|
---|
101 | #ifdef VBOX_WITH_DTRACE
|
---|
102 | # include "dtrace/VBoxDD.h"
|
---|
103 | #endif
|
---|
104 |
|
---|
105 |
|
---|
106 | /*********************************************************************************************************************************
|
---|
107 | * Internal Functions *
|
---|
108 | *********************************************************************************************************************************/
|
---|
109 | static int audioMixerRemoveSinkInternal(PAUDIOMIXER pMixer, PAUDMIXSINK pSink);
|
---|
110 |
|
---|
111 | static void audioMixerSinkDestroyInternal(PAUDMIXSINK pSink, PPDMDEVINS pDevIns);
|
---|
112 | static int audioMixerSinkUpdateVolume(PAUDMIXSINK pSink, PCPDMAUDIOVOLUME pVolMaster);
|
---|
113 | static int audioMixerSinkRemoveStreamInternal(PAUDMIXSINK pSink, PAUDMIXSTREAM pStream);
|
---|
114 | static void audioMixerSinkResetInternal(PAUDMIXSINK pSink);
|
---|
115 |
|
---|
116 | static int audioMixerStreamCtlInternal(PAUDMIXSTREAM pMixStream, PDMAUDIOSTREAMCMD enmCmd);
|
---|
117 | static void audioMixerStreamDestroyInternal(PAUDMIXSTREAM pStream, PPDMDEVINS pDevIns, bool fImmediate);
|
---|
118 | static int audioMixerStreamUpdateStatus(PAUDMIXSTREAM pMixStream);
|
---|
119 |
|
---|
120 |
|
---|
121 | /** size of output buffer for dbgAudioMixerSinkStatusToStr. */
|
---|
122 | #define AUDIOMIXERSINK_STATUS_STR_MAX sizeof("RUNNING DRAINING DRAINED_DMA DRAINED_MIXBUF DIRTY 0x12345678")
|
---|
123 |
|
---|
124 | /**
|
---|
125 | * Converts a mixer sink status to a string.
|
---|
126 | *
|
---|
127 | * @returns pszDst
|
---|
128 | * @param fStatus The mixer sink status.
|
---|
129 | * @param pszDst The output buffer. Must be at least
|
---|
130 | * AUDIOMIXERSINK_STATUS_STR_MAX in length.
|
---|
131 | */
|
---|
132 | static const char *dbgAudioMixerSinkStatusToStr(uint32_t fStatus, char pszDst[AUDIOMIXERSINK_STATUS_STR_MAX])
|
---|
133 | {
|
---|
134 | if (!fStatus)
|
---|
135 | return strcpy(pszDst, "NONE");
|
---|
136 | static const struct
|
---|
137 | {
|
---|
138 | const char *pszMnemonic;
|
---|
139 | uint32_t cchMnemonic;
|
---|
140 | uint32_t fStatus;
|
---|
141 | } s_aFlags[] =
|
---|
142 | {
|
---|
143 | { RT_STR_TUPLE("RUNNING "), AUDMIXSINK_STS_RUNNING },
|
---|
144 | { RT_STR_TUPLE("DRAINING "), AUDMIXSINK_STS_DRAINING },
|
---|
145 | { RT_STR_TUPLE("DRAINED_DMA "), AUDMIXSINK_STS_DRAINED_DMA },
|
---|
146 | { RT_STR_TUPLE("DRAINED_MIXBUF "), AUDMIXSINK_STS_DRAINED_MIXBUF },
|
---|
147 | { RT_STR_TUPLE("DIRTY "), AUDMIXSINK_STS_DIRTY },
|
---|
148 | };
|
---|
149 | char *psz = pszDst;
|
---|
150 | for (size_t i = 0; i < RT_ELEMENTS(s_aFlags); i++)
|
---|
151 | if (fStatus & s_aFlags[i].fStatus)
|
---|
152 | {
|
---|
153 | memcpy(psz, s_aFlags[i].pszMnemonic, s_aFlags[i].cchMnemonic);
|
---|
154 | psz += s_aFlags[i].cchMnemonic;
|
---|
155 | fStatus &= ~s_aFlags[i].fStatus;
|
---|
156 | if (!fStatus)
|
---|
157 | {
|
---|
158 | psz[-1] = '\0';
|
---|
159 | return pszDst;
|
---|
160 | }
|
---|
161 | }
|
---|
162 | RTStrPrintf(psz, AUDIOMIXERSINK_STATUS_STR_MAX - (psz - pszDst), "%#x", fStatus);
|
---|
163 | return pszDst;
|
---|
164 | }
|
---|
165 |
|
---|
166 |
|
---|
167 | /**
|
---|
168 | * Creates an audio mixer.
|
---|
169 | *
|
---|
170 | * @returns VBox status code.
|
---|
171 | * @param pszName Name of the audio mixer.
|
---|
172 | * @param fFlags Creation flags - AUDMIXER_FLAGS_XXX.
|
---|
173 | * @param ppMixer Pointer which returns the created mixer object.
|
---|
174 | */
|
---|
175 | int AudioMixerCreate(const char *pszName, uint32_t fFlags, PAUDIOMIXER *ppMixer)
|
---|
176 | {
|
---|
177 | AssertPtrReturn(pszName, VERR_INVALID_POINTER);
|
---|
178 | size_t const cchName = strlen(pszName);
|
---|
179 | AssertReturn(cchName > 0 && cchName < 128, VERR_INVALID_NAME);
|
---|
180 | AssertReturn (!(fFlags & ~AUDMIXER_FLAGS_VALID_MASK), VERR_INVALID_FLAGS);
|
---|
181 | AssertPtrReturn(ppMixer, VERR_INVALID_POINTER);
|
---|
182 |
|
---|
183 | int rc;
|
---|
184 | PAUDIOMIXER pMixer = (PAUDIOMIXER)RTMemAllocZVar(sizeof(AUDIOMIXER) + cchName + 1);
|
---|
185 | if (pMixer)
|
---|
186 | {
|
---|
187 | rc = RTCritSectInit(&pMixer->CritSect);
|
---|
188 | if (RT_SUCCESS(rc))
|
---|
189 | {
|
---|
190 | pMixer->pszName = (const char *)memcpy(pMixer + 1, pszName, cchName + 1);
|
---|
191 |
|
---|
192 | pMixer->cSinks = 0;
|
---|
193 | RTListInit(&pMixer->lstSinks);
|
---|
194 |
|
---|
195 | pMixer->fFlags = fFlags;
|
---|
196 | pMixer->uMagic = AUDIOMIXER_MAGIC;
|
---|
197 |
|
---|
198 | if (pMixer->fFlags & AUDMIXER_FLAGS_DEBUG)
|
---|
199 | LogRel(("Audio Mixer: Debug mode enabled\n"));
|
---|
200 |
|
---|
201 | /* Set master volume to the max. */
|
---|
202 | PDMAudioVolumeInitMax(&pMixer->VolMaster);
|
---|
203 |
|
---|
204 | LogFlowFunc(("Created mixer '%s'\n", pMixer->pszName));
|
---|
205 | *ppMixer = pMixer;
|
---|
206 | return VINF_SUCCESS;
|
---|
207 | }
|
---|
208 | RTMemFree(pMixer);
|
---|
209 | }
|
---|
210 | else
|
---|
211 | rc = VERR_NO_MEMORY;
|
---|
212 | LogFlowFuncLeaveRC(rc);
|
---|
213 | return rc;
|
---|
214 | }
|
---|
215 |
|
---|
216 |
|
---|
217 | /**
|
---|
218 | * Destroys an audio mixer.
|
---|
219 | *
|
---|
220 | * @param pMixer Audio mixer to destroy. NULL is ignored.
|
---|
221 | * @param pDevIns The device instance the statistics are associated with.
|
---|
222 | */
|
---|
223 | void AudioMixerDestroy(PAUDIOMIXER pMixer, PPDMDEVINS pDevIns)
|
---|
224 | {
|
---|
225 | if (!pMixer)
|
---|
226 | return;
|
---|
227 | AssertPtrReturnVoid(pMixer);
|
---|
228 | AssertReturnVoid(pMixer->uMagic == AUDIOMIXER_MAGIC);
|
---|
229 |
|
---|
230 | int rc2 = RTCritSectEnter(&pMixer->CritSect);
|
---|
231 | AssertRCReturnVoid(rc2);
|
---|
232 | Assert(pMixer->uMagic == AUDIOMIXER_MAGIC);
|
---|
233 |
|
---|
234 | LogFlowFunc(("Destroying %s ...\n", pMixer->pszName));
|
---|
235 | pMixer->uMagic = AUDIOMIXER_MAGIC_DEAD;
|
---|
236 |
|
---|
237 | PAUDMIXSINK pSink, pSinkNext;
|
---|
238 | RTListForEachSafe(&pMixer->lstSinks, pSink, pSinkNext, AUDMIXSINK, Node)
|
---|
239 | {
|
---|
240 | audioMixerRemoveSinkInternal(pMixer, pSink);
|
---|
241 | audioMixerSinkDestroyInternal(pSink, pDevIns);
|
---|
242 | }
|
---|
243 | Assert(pMixer->cSinks == 0);
|
---|
244 |
|
---|
245 | rc2 = RTCritSectLeave(&pMixer->CritSect);
|
---|
246 | AssertRC(rc2);
|
---|
247 |
|
---|
248 | RTCritSectDelete(&pMixer->CritSect);
|
---|
249 | RTMemFree(pMixer);
|
---|
250 | }
|
---|
251 |
|
---|
252 |
|
---|
253 | /**
|
---|
254 | * Helper function for the internal debugger to print the mixer's current
|
---|
255 | * state, along with the attached sinks.
|
---|
256 | *
|
---|
257 | * @param pMixer Mixer to print debug output for.
|
---|
258 | * @param pHlp Debug info helper to use.
|
---|
259 | * @param pszArgs Optional arguments. Not being used at the moment.
|
---|
260 | */
|
---|
261 | void AudioMixerDebug(PAUDIOMIXER pMixer, PCDBGFINFOHLP pHlp, const char *pszArgs)
|
---|
262 | {
|
---|
263 | RT_NOREF(pszArgs);
|
---|
264 | AssertReturnVoid(pMixer->uMagic == AUDIOMIXER_MAGIC);
|
---|
265 |
|
---|
266 | int rc = RTCritSectEnter(&pMixer->CritSect);
|
---|
267 | AssertRCReturnVoid(rc);
|
---|
268 |
|
---|
269 | /* Determin max sink name length for pretty formatting: */
|
---|
270 | size_t cchMaxName = strlen(pMixer->pszName);
|
---|
271 | PAUDMIXSINK pSink;
|
---|
272 | RTListForEach(&pMixer->lstSinks, pSink, AUDMIXSINK, Node)
|
---|
273 | {
|
---|
274 | size_t const cchMixer = strlen(pSink->pszName);
|
---|
275 | cchMaxName = RT_MAX(cchMixer, cchMaxName);
|
---|
276 | }
|
---|
277 |
|
---|
278 | /* Do the displaying. */
|
---|
279 | pHlp->pfnPrintf(pHlp, "[Master] %*s: fMuted=%#RTbool auChannels=%.*Rhxs\n", cchMaxName, pMixer->pszName,
|
---|
280 | pMixer->VolMaster.fMuted, sizeof(pMixer->VolMaster.auChannels), pMixer->VolMaster.auChannels);
|
---|
281 | unsigned iSink = 0;
|
---|
282 | RTListForEach(&pMixer->lstSinks, pSink, AUDMIXSINK, Node)
|
---|
283 | {
|
---|
284 | pHlp->pfnPrintf(pHlp, "[Sink %u] %*s: fMuted=%#RTbool auChannels=%.*Rhxs\n", iSink, cchMaxName, pSink->pszName,
|
---|
285 | pSink->Volume.fMuted, sizeof(pSink->Volume.auChannels), pSink->Volume.auChannels);
|
---|
286 | ++iSink;
|
---|
287 | }
|
---|
288 |
|
---|
289 | RTCritSectLeave(&pMixer->CritSect);
|
---|
290 | }
|
---|
291 |
|
---|
292 |
|
---|
293 | /**
|
---|
294 | * Sets the mixer's master volume.
|
---|
295 | *
|
---|
296 | * @returns VBox status code.
|
---|
297 | * @param pMixer Mixer to set master volume for.
|
---|
298 | * @param pVol Volume to set.
|
---|
299 | */
|
---|
300 | int AudioMixerSetMasterVolume(PAUDIOMIXER pMixer, PCPDMAUDIOVOLUME pVol)
|
---|
301 | {
|
---|
302 | AssertPtrReturn(pMixer, VERR_INVALID_POINTER);
|
---|
303 | AssertReturn(pMixer->uMagic == AUDIOMIXER_MAGIC, VERR_INVALID_MAGIC);
|
---|
304 | AssertPtrReturn(pVol, VERR_INVALID_POINTER);
|
---|
305 |
|
---|
306 | int rc = RTCritSectEnter(&pMixer->CritSect);
|
---|
307 | AssertRCReturn(rc, rc);
|
---|
308 |
|
---|
309 | /*
|
---|
310 | * Make a copy.
|
---|
311 | */
|
---|
312 | LogFlowFunc(("[%s] fMuted=%RTbool auChannels=%.*Rhxs => fMuted=%RTbool auChannels=%.*Rhxs\n", pMixer->pszName,
|
---|
313 | pMixer->VolMaster.fMuted, sizeof(pMixer->VolMaster.auChannels), pMixer->VolMaster.auChannels,
|
---|
314 | pVol->fMuted, sizeof(pVol->auChannels), pVol->auChannels ));
|
---|
315 | memcpy(&pMixer->VolMaster, pVol, sizeof(PDMAUDIOVOLUME));
|
---|
316 |
|
---|
317 | /*
|
---|
318 | * Propagate new master volume to all sinks.
|
---|
319 | */
|
---|
320 | PAUDMIXSINK pSink;
|
---|
321 | RTListForEach(&pMixer->lstSinks, pSink, AUDMIXSINK, Node)
|
---|
322 | {
|
---|
323 | int rc2 = audioMixerSinkUpdateVolume(pSink, &pMixer->VolMaster);
|
---|
324 | AssertRC(rc2);
|
---|
325 | }
|
---|
326 |
|
---|
327 | RTCritSectLeave(&pMixer->CritSect);
|
---|
328 | return rc;
|
---|
329 | }
|
---|
330 |
|
---|
331 |
|
---|
332 | /**
|
---|
333 | * Removes an audio sink from the given audio mixer, internal version.
|
---|
334 | *
|
---|
335 | * Used by AudioMixerDestroy and AudioMixerSinkDestroy.
|
---|
336 | *
|
---|
337 | * Caller must hold the mixer lock.
|
---|
338 | *
|
---|
339 | * @returns VBox status code.
|
---|
340 | * @param pMixer Mixer to remove sink from.
|
---|
341 | * @param pSink Sink to remove.
|
---|
342 | */
|
---|
343 | static int audioMixerRemoveSinkInternal(PAUDIOMIXER pMixer, PAUDMIXSINK pSink)
|
---|
344 | {
|
---|
345 | LogFlowFunc(("[%s] pSink=%s, cSinks=%RU8\n", pMixer->pszName, pSink->pszName, pMixer->cSinks));
|
---|
346 | Assert(RTCritSectIsOwner(&pMixer->CritSect));
|
---|
347 | AssertMsgReturn(pSink->pParent == pMixer,
|
---|
348 | ("%s: Is not part of mixer '%s'\n", pSink->pszName, pMixer->pszName), VERR_INTERNAL_ERROR_4);
|
---|
349 |
|
---|
350 | /* Remove sink from mixer. */
|
---|
351 | RTListNodeRemove(&pSink->Node);
|
---|
352 |
|
---|
353 | Assert(pMixer->cSinks);
|
---|
354 | pMixer->cSinks--;
|
---|
355 |
|
---|
356 | /* Set mixer to NULL so that we know we're not part of any mixer anymore. */
|
---|
357 | pSink->pParent = NULL;
|
---|
358 |
|
---|
359 | return VINF_SUCCESS;
|
---|
360 | }
|
---|
361 |
|
---|
362 |
|
---|
363 | /*********************************************************************************************************************************
|
---|
364 | * Mixer Sink implementation. *
|
---|
365 | *********************************************************************************************************************************/
|
---|
366 |
|
---|
367 | /**
|
---|
368 | * Creates an audio sink and attaches it to the given mixer.
|
---|
369 | *
|
---|
370 | * @returns VBox status code.
|
---|
371 | * @param pMixer Mixer to attach created sink to.
|
---|
372 | * @param pszName Name of the sink to create.
|
---|
373 | * @param enmDir Direction of the sink to create.
|
---|
374 | * @param pDevIns The device instance to register statistics under.
|
---|
375 | * @param ppSink Pointer which returns the created sink on success.
|
---|
376 | */
|
---|
377 | int AudioMixerCreateSink(PAUDIOMIXER pMixer, const char *pszName, PDMAUDIODIR enmDir, PPDMDEVINS pDevIns, PAUDMIXSINK *ppSink)
|
---|
378 | {
|
---|
379 | AssertPtrReturn(pMixer, VERR_INVALID_POINTER);
|
---|
380 | AssertPtrReturn(pszName, VERR_INVALID_POINTER);
|
---|
381 | size_t const cchName = strlen(pszName);
|
---|
382 | AssertReturn(cchName > 0 && cchName < 64, VERR_INVALID_NAME);
|
---|
383 | AssertPtrNullReturn(ppSink, VERR_INVALID_POINTER);
|
---|
384 |
|
---|
385 | int rc = RTCritSectEnter(&pMixer->CritSect);
|
---|
386 | AssertRCReturn(rc, rc);
|
---|
387 |
|
---|
388 | /** @todo limit the number of sinks? */
|
---|
389 |
|
---|
390 | /*
|
---|
391 | * Allocate the data and initialize the critsect.
|
---|
392 | */
|
---|
393 | PAUDMIXSINK pSink = (PAUDMIXSINK)RTMemAllocZVar(sizeof(AUDMIXSINK) + cchName + 1);
|
---|
394 | if (pSink)
|
---|
395 | {
|
---|
396 | rc = RTCritSectInit(&pSink->CritSect);
|
---|
397 | if (RT_SUCCESS(rc))
|
---|
398 | {
|
---|
399 | /*
|
---|
400 | * Initialize it.
|
---|
401 | */
|
---|
402 | pSink->uMagic = AUDMIXSINK_MAGIC;
|
---|
403 | pSink->pParent = NULL;
|
---|
404 | pSink->enmDir = enmDir;
|
---|
405 | pSink->pszName = (const char *)memcpy(pSink + 1, pszName, cchName + 1);
|
---|
406 | RTListInit(&pSink->lstStreams);
|
---|
407 |
|
---|
408 | /* Set initial volume to max. */
|
---|
409 | PDMAudioVolumeInitMax(&pSink->Volume);
|
---|
410 |
|
---|
411 | /* Ditto for the combined volume. */
|
---|
412 | PDMAudioVolumeInitMax(&pSink->VolumeCombined);
|
---|
413 |
|
---|
414 | /* AIO */
|
---|
415 | AssertPtr(pDevIns);
|
---|
416 | pSink->AIO.pDevIns = pDevIns;
|
---|
417 | pSink->AIO.hThread = NIL_RTTHREAD;
|
---|
418 | pSink->AIO.hEvent = NIL_RTSEMEVENT;
|
---|
419 | pSink->AIO.fStarted = false;
|
---|
420 | pSink->AIO.fShutdown = false;
|
---|
421 | pSink->AIO.cUpdateJobs = 0;
|
---|
422 |
|
---|
423 | /*
|
---|
424 | * Add it to the mixer.
|
---|
425 | */
|
---|
426 | RTListAppend(&pMixer->lstSinks, &pSink->Node);
|
---|
427 | pMixer->cSinks++;
|
---|
428 | pSink->pParent = pMixer;
|
---|
429 |
|
---|
430 | RTCritSectLeave(&pMixer->CritSect);
|
---|
431 |
|
---|
432 | /*
|
---|
433 | * Register stats and return.
|
---|
434 | */
|
---|
435 | char szPrefix[128];
|
---|
436 | RTStrPrintf(szPrefix, sizeof(szPrefix), "MixerSink-%s/", pSink->pszName);
|
---|
437 | PDMDevHlpSTAMRegisterF(pDevIns, &pSink->MixBuf.cFrames, STAMTYPE_U32, STAMVISIBILITY_USED, STAMUNIT_NONE,
|
---|
438 | "Sink mixer buffer size in frames.", "%sMixBufSize", szPrefix);
|
---|
439 | PDMDevHlpSTAMRegisterF(pDevIns, &pSink->MixBuf.cUsed, STAMTYPE_U32, STAMVISIBILITY_USED, STAMUNIT_NONE,
|
---|
440 | "Sink mixer buffer fill size in frames.", "%sMixBufUsed", szPrefix);
|
---|
441 | PDMDevHlpSTAMRegisterF(pDevIns, &pSink->cStreams, STAMTYPE_U8, STAMVISIBILITY_USED, STAMUNIT_NONE,
|
---|
442 | "Number of streams attached to the sink.", "%sStreams", szPrefix);
|
---|
443 |
|
---|
444 | if (ppSink)
|
---|
445 | *ppSink = pSink;
|
---|
446 | return VINF_SUCCESS;
|
---|
447 | }
|
---|
448 |
|
---|
449 | RTMemFree(pSink);
|
---|
450 | }
|
---|
451 | else
|
---|
452 | rc = VERR_NO_MEMORY;
|
---|
453 |
|
---|
454 | RTCritSectLeave(&pMixer->CritSect);
|
---|
455 | if (ppSink)
|
---|
456 | *ppSink = NULL;
|
---|
457 | return rc;
|
---|
458 | }
|
---|
459 |
|
---|
460 |
|
---|
461 | /**
|
---|
462 | * Starts playback/capturing on the mixer sink.
|
---|
463 | *
|
---|
464 | * @returns VBox status code. Generally always VINF_SUCCESS unless the input
|
---|
465 | * is invalid. Individual driver errors are suppressed and ignored.
|
---|
466 | * @param pSink Mixer sink to control.
|
---|
467 | */
|
---|
468 | int AudioMixerSinkStart(PAUDMIXSINK pSink)
|
---|
469 | {
|
---|
470 | AssertPtrReturn(pSink, VERR_INVALID_POINTER);
|
---|
471 | Assert(pSink->uMagic == AUDMIXSINK_MAGIC);
|
---|
472 | int rc = RTCritSectEnter(&pSink->CritSect);
|
---|
473 | AssertRCReturn(rc, rc);
|
---|
474 | char szStatus[AUDIOMIXERSINK_STATUS_STR_MAX];
|
---|
475 | LogFunc(("Starting '%s'. Old status: %s\n", pSink->pszName, dbgAudioMixerSinkStatusToStr(pSink->fStatus, szStatus)));
|
---|
476 |
|
---|
477 | AssertReturnStmt(pSink->enmDir == PDMAUDIODIR_IN || pSink->enmDir == PDMAUDIODIR_OUT,
|
---|
478 | RTCritSectLeave(&pSink->CritSect), VERR_INTERNAL_ERROR_3);
|
---|
479 |
|
---|
480 | /*
|
---|
481 | * Make sure the sink and its streams are all stopped.
|
---|
482 | */
|
---|
483 | if (!(pSink->fStatus & AUDMIXSINK_STS_RUNNING))
|
---|
484 | Assert(pSink->fStatus == AUDMIXSINK_STS_NONE);
|
---|
485 | else
|
---|
486 | {
|
---|
487 | LogFunc(("%s: This sink is still running!! Stop it before starting it again.\n", pSink->pszName));
|
---|
488 |
|
---|
489 | PAUDMIXSTREAM pStream;
|
---|
490 | RTListForEach(&pSink->lstStreams, pStream, AUDMIXSTREAM, Node)
|
---|
491 | {
|
---|
492 | /** @todo PDMAUDIOSTREAMCMD_STOP_NOW */
|
---|
493 | audioMixerStreamCtlInternal(pStream, PDMAUDIOSTREAMCMD_DISABLE);
|
---|
494 | }
|
---|
495 | audioMixerSinkResetInternal(pSink);
|
---|
496 | }
|
---|
497 |
|
---|
498 | /*
|
---|
499 | * Send the command to the streams.
|
---|
500 | */
|
---|
501 | PAUDMIXSTREAM pStream;
|
---|
502 | RTListForEach(&pSink->lstStreams, pStream, AUDMIXSTREAM, Node)
|
---|
503 | {
|
---|
504 | audioMixerStreamCtlInternal(pStream, PDMAUDIOSTREAMCMD_ENABLE);
|
---|
505 | }
|
---|
506 |
|
---|
507 | /*
|
---|
508 | * Update the sink status.
|
---|
509 | */
|
---|
510 | pSink->fStatus = AUDMIXSINK_STS_RUNNING;
|
---|
511 |
|
---|
512 | LogRel2(("Audio Mixer: Started sink '%s': %s\n", pSink->pszName, dbgAudioMixerSinkStatusToStr(pSink->fStatus, szStatus)));
|
---|
513 |
|
---|
514 | RTCritSectLeave(&pSink->CritSect);
|
---|
515 | return VINF_SUCCESS;
|
---|
516 | }
|
---|
517 |
|
---|
518 |
|
---|
519 | /**
|
---|
520 | * Helper for AudioMixerSinkDrainAndStop that calculates the max length a drain
|
---|
521 | * operation should take.
|
---|
522 | *
|
---|
523 | * @returns The drain deadline (relative to RTTimeNanoTS).
|
---|
524 | * @param pSink The sink.
|
---|
525 | * @param cbDmaLeftToDrain The number of bytes in the DMA buffer left to
|
---|
526 | * transfer into the mixbuf.
|
---|
527 | */
|
---|
528 | static uint64_t audioMixerSinkDrainDeadline(PAUDMIXSINK pSink, uint32_t cbDmaLeftToDrain)
|
---|
529 | {
|
---|
530 | /*
|
---|
531 | * Calculate the max backend buffer size in mixbuf frames.
|
---|
532 | * (This is somewhat similar to audioMixerSinkUpdateOutputCalcFramesToRead.)
|
---|
533 | */
|
---|
534 | uint32_t cFramesStreamMax = 0;
|
---|
535 | PAUDMIXSTREAM pMixStream;
|
---|
536 | RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
|
---|
537 | {
|
---|
538 | /*LogFunc(("Stream '%s': %#x (%u frames)\n", pMixStream->pszName, pMixStream->fStatus, pMixStream->cFramesBackendBuffer));*/
|
---|
539 | if (pMixStream->fStatus & AUDMIXSTREAM_STATUS_CAN_WRITE)
|
---|
540 | {
|
---|
541 | uint32_t cFrames = pMixStream->cFramesBackendBuffer;
|
---|
542 | if (PDMAudioPropsHz(&pMixStream->pStream->Cfg.Props) == PDMAudioPropsHz(&pSink->MixBuf.Props))
|
---|
543 | { /* likely */ }
|
---|
544 | else
|
---|
545 | cFrames = cFrames * PDMAudioPropsHz(&pSink->MixBuf.Props) / PDMAudioPropsHz(&pMixStream->pStream->Cfg.Props);
|
---|
546 | if (cFrames > cFramesStreamMax)
|
---|
547 | {
|
---|
548 | Log4Func(("%s: cFramesStreamMax %u -> %u; %s\n", pSink->pszName, cFramesStreamMax, cFrames, pMixStream->pszName));
|
---|
549 | cFramesStreamMax = cFrames;
|
---|
550 | }
|
---|
551 | }
|
---|
552 | }
|
---|
553 |
|
---|
554 | /*
|
---|
555 | * Combine that with the pending DMA and mixbuf content, then convert
|
---|
556 | * to nanoseconds and apply a fudge factor to get a generous deadline.
|
---|
557 | */
|
---|
558 | uint32_t const cFramesDmaAndMixBuf = PDMAudioPropsBytesToFrames(&pSink->MixBuf.Props, cbDmaLeftToDrain)
|
---|
559 | + AudioMixBufUsed(&pSink->MixBuf);
|
---|
560 | uint64_t const cNsToDrainMax = PDMAudioPropsFramesToNano(&pSink->MixBuf.Props, cFramesDmaAndMixBuf + cFramesStreamMax);
|
---|
561 | uint64_t const nsDeadline = cNsToDrainMax * 2;
|
---|
562 | LogFlowFunc(("%s: cFramesStreamMax=%#x cFramesDmaAndMixBuf=%#x -> cNsToDrainMax=%RU64 -> %RU64\n",
|
---|
563 | pSink->pszName, cFramesStreamMax, cFramesDmaAndMixBuf, cNsToDrainMax, nsDeadline));
|
---|
564 | return nsDeadline;
|
---|
565 | }
|
---|
566 |
|
---|
567 |
|
---|
568 | /**
|
---|
569 | * Kicks off the draining and stopping playback/capture on the mixer sink.
|
---|
570 | *
|
---|
571 | * For input streams this causes an immediate stop, as draining only makes sense
|
---|
572 | * to output stream in the VBox device context.
|
---|
573 | *
|
---|
574 | * @returns VBox status code. Generally always VINF_SUCCESS unless the input
|
---|
575 | * is invalid. Individual driver errors are suppressed and ignored.
|
---|
576 | * @param pSink Mixer sink to control.
|
---|
577 | * @param cbComming The number of bytes still left in the device's DMA
|
---|
578 | * buffers that the update job has yet to transfer. This
|
---|
579 | * is ignored for input streams.
|
---|
580 | */
|
---|
581 | int AudioMixerSinkDrainAndStop(PAUDMIXSINK pSink, uint32_t cbComming)
|
---|
582 | {
|
---|
583 | AssertPtrReturn(pSink, VERR_INVALID_POINTER);
|
---|
584 | Assert(pSink->uMagic == AUDMIXSINK_MAGIC);
|
---|
585 |
|
---|
586 | int rc = RTCritSectEnter(&pSink->CritSect);
|
---|
587 | AssertRCReturn(rc, rc);
|
---|
588 | char szStatus[AUDIOMIXERSINK_STATUS_STR_MAX];
|
---|
589 | LogFunc(("Draining '%s' with %#x bytes left. Old status: %s\n",
|
---|
590 | pSink->pszName, cbComming, dbgAudioMixerSinkStatusToStr(pSink->fStatus, szStatus) ));
|
---|
591 |
|
---|
592 | AssertReturnStmt(pSink->enmDir == PDMAUDIODIR_IN || pSink->enmDir == PDMAUDIODIR_OUT,
|
---|
593 | RTCritSectLeave(&pSink->CritSect), VERR_INTERNAL_ERROR_3);
|
---|
594 |
|
---|
595 | if (pSink->fStatus & AUDMIXSINK_STS_RUNNING)
|
---|
596 | {
|
---|
597 | /*
|
---|
598 | * Output streams will be drained then stopped (all by the AIO thread).
|
---|
599 | *
|
---|
600 | * For streams we define that they shouldn't not be written to after we start draining,
|
---|
601 | * so we have to hold back sending the command to them till we've processed all the
|
---|
602 | * cbComming remaining bytes in the DMA buffer.
|
---|
603 | */
|
---|
604 | if (pSink->enmDir == PDMAUDIODIR_OUT)
|
---|
605 | {
|
---|
606 | if (!(pSink->fStatus & AUDMIXSINK_STS_DRAINING))
|
---|
607 | {
|
---|
608 | Assert(!(pSink->fStatus & (AUDMIXSINK_STS_DRAINED_DMA | AUDMIXSINK_STS_DRAINED_MIXBUF)));
|
---|
609 |
|
---|
610 | /* Update the status and draining member. */
|
---|
611 | pSink->cbDmaLeftToDrain = cbComming;
|
---|
612 | pSink->nsDrainDeadline = audioMixerSinkDrainDeadline(pSink, cbComming);
|
---|
613 | if (pSink->nsDrainDeadline > 0)
|
---|
614 | {
|
---|
615 | pSink->nsDrainStarted = RTTimeNanoTS();
|
---|
616 | pSink->nsDrainDeadline += pSink->nsDrainStarted;
|
---|
617 | pSink->fStatus |= AUDMIXSINK_STS_DRAINING;
|
---|
618 |
|
---|
619 | /* Kick the AIO thread so it can keep pushing data till we're out of this
|
---|
620 | status. (The device's DMA timer won't kick it any more, so we must.) */
|
---|
621 | AudioMixerSinkSignalUpdateJob(pSink);
|
---|
622 | }
|
---|
623 | else
|
---|
624 | {
|
---|
625 | LogFunc(("%s: No active streams, doing an immediate stop.\n", pSink->pszName));
|
---|
626 | PAUDMIXSTREAM pStream;
|
---|
627 | RTListForEach(&pSink->lstStreams, pStream, AUDMIXSTREAM, Node)
|
---|
628 | {
|
---|
629 | audioMixerStreamCtlInternal(pStream, PDMAUDIOSTREAMCMD_DISABLE);
|
---|
630 | }
|
---|
631 | audioMixerSinkResetInternal(pSink);
|
---|
632 | }
|
---|
633 | }
|
---|
634 | else
|
---|
635 | AssertMsgFailed(("Already draining '%s': %s\n",
|
---|
636 | pSink->pszName, dbgAudioMixerSinkStatusToStr(pSink->fStatus, szStatus)));
|
---|
637 | }
|
---|
638 | /*
|
---|
639 | * Input sinks are stopped immediately.
|
---|
640 | *
|
---|
641 | * It's the guest giving order here and we can't force it to accept data that's
|
---|
642 | * already in the buffer pipeline or anything. So, there can be no draining here.
|
---|
643 | */
|
---|
644 | else
|
---|
645 | {
|
---|
646 | PAUDMIXSTREAM pStream;
|
---|
647 | RTListForEach(&pSink->lstStreams, pStream, AUDMIXSTREAM, Node)
|
---|
648 | {
|
---|
649 | audioMixerStreamCtlInternal(pStream, PDMAUDIOSTREAMCMD_DISABLE);
|
---|
650 | }
|
---|
651 | audioMixerSinkResetInternal(pSink);
|
---|
652 | }
|
---|
653 | }
|
---|
654 | else
|
---|
655 | LogFunc(("%s: Not running\n", pSink->pszName));
|
---|
656 |
|
---|
657 | LogRel2(("Audio Mixer: Started draining sink '%s': %s\n", pSink->pszName, dbgAudioMixerSinkStatusToStr(pSink->fStatus, szStatus)));
|
---|
658 | RTCritSectLeave(&pSink->CritSect);
|
---|
659 | return rc;
|
---|
660 | }
|
---|
661 |
|
---|
662 |
|
---|
663 | /**
|
---|
664 | * Destroys and frees a mixer sink.
|
---|
665 | *
|
---|
666 | * Worker for AudioMixerSinkDestroy(), AudioMixerCreateSink() and
|
---|
667 | * AudioMixerDestroy().
|
---|
668 | *
|
---|
669 | * @param pSink Mixer sink to destroy.
|
---|
670 | * @param pDevIns The device instance statistics are registered with.
|
---|
671 | */
|
---|
672 | static void audioMixerSinkDestroyInternal(PAUDMIXSINK pSink, PPDMDEVINS pDevIns)
|
---|
673 | {
|
---|
674 | AssertPtrReturnVoid(pSink);
|
---|
675 |
|
---|
676 | LogFunc(("%s\n", pSink->pszName));
|
---|
677 |
|
---|
678 | /*
|
---|
679 | * Invalidate the sink instance.
|
---|
680 | */
|
---|
681 | Assert(pSink->uMagic == AUDMIXSINK_MAGIC);
|
---|
682 | pSink->uMagic = AUDMIXSINK_MAGIC_DEAD;
|
---|
683 |
|
---|
684 | int rc = RTCritSectEnter(&pSink->CritSect);
|
---|
685 | AssertRCReturnVoid(rc);
|
---|
686 |
|
---|
687 | /*
|
---|
688 | * Destroy all streams.
|
---|
689 | */
|
---|
690 | PAUDMIXSTREAM pStream, pStreamNext;
|
---|
691 | RTListForEachSafe(&pSink->lstStreams, pStream, pStreamNext, AUDMIXSTREAM, Node)
|
---|
692 | {
|
---|
693 | audioMixerSinkRemoveStreamInternal(pSink, pStream);
|
---|
694 | audioMixerStreamDestroyInternal(pStream, pDevIns, true /*fImmediate*/);
|
---|
695 | }
|
---|
696 |
|
---|
697 | rc = RTCritSectLeave(&pSink->CritSect);
|
---|
698 | AssertRCReturnVoid(rc);
|
---|
699 |
|
---|
700 | /*
|
---|
701 | * Destroy debug file and statistics.
|
---|
702 | */
|
---|
703 | if (!pSink->Dbg.pFile)
|
---|
704 | { /* likely */ }
|
---|
705 | else
|
---|
706 | {
|
---|
707 | AudioHlpFileDestroy(pSink->Dbg.pFile);
|
---|
708 | pSink->Dbg.pFile = NULL;
|
---|
709 | }
|
---|
710 |
|
---|
711 | char szPrefix[128];
|
---|
712 | RTStrPrintf(szPrefix, sizeof(szPrefix), "MixerSink-%s/", pSink->pszName);
|
---|
713 | PDMDevHlpSTAMDeregisterByPrefix(pDevIns, szPrefix);
|
---|
714 |
|
---|
715 | /*
|
---|
716 | * Shutdown the AIO thread if started:
|
---|
717 | */
|
---|
718 | ASMAtomicWriteBool(&pSink->AIO.fShutdown, true);
|
---|
719 | if (pSink->AIO.hEvent != NIL_RTSEMEVENT)
|
---|
720 | {
|
---|
721 | int rc2 = RTSemEventSignal(pSink->AIO.hEvent);
|
---|
722 | AssertRC(rc2);
|
---|
723 | }
|
---|
724 | if (pSink->AIO.hThread != NIL_RTTHREAD)
|
---|
725 | {
|
---|
726 | LogFlowFunc(("Waiting for AIO thread for %s...\n", pSink->pszName));
|
---|
727 | int rc2 = RTThreadWait(pSink->AIO.hThread, RT_MS_30SEC, NULL);
|
---|
728 | AssertRC(rc2);
|
---|
729 | pSink->AIO.hThread = NIL_RTTHREAD;
|
---|
730 | }
|
---|
731 | if (pSink->AIO.hEvent != NIL_RTSEMEVENT)
|
---|
732 | {
|
---|
733 | int rc2 = RTSemEventDestroy(pSink->AIO.hEvent);
|
---|
734 | AssertRC(rc2);
|
---|
735 | pSink->AIO.hEvent = NIL_RTSEMEVENT;
|
---|
736 | }
|
---|
737 |
|
---|
738 | /*
|
---|
739 | * Mixing buffer, critsect and the structure itself.
|
---|
740 | */
|
---|
741 | AudioMixBufTerm(&pSink->MixBuf);
|
---|
742 | RTCritSectDelete(&pSink->CritSect);
|
---|
743 | RTMemFree(pSink);
|
---|
744 | }
|
---|
745 |
|
---|
746 |
|
---|
747 | /**
|
---|
748 | * Destroys a mixer sink and removes it from the attached mixer (if any).
|
---|
749 | *
|
---|
750 | * @param pSink Mixer sink to destroy. NULL is ignored.
|
---|
751 | * @param pDevIns The device instance that statistics are registered with.
|
---|
752 | */
|
---|
753 | void AudioMixerSinkDestroy(PAUDMIXSINK pSink, PPDMDEVINS pDevIns)
|
---|
754 | {
|
---|
755 | if (!pSink)
|
---|
756 | return;
|
---|
757 | AssertReturnVoid(pSink->uMagic == AUDMIXSINK_MAGIC);
|
---|
758 |
|
---|
759 | /*
|
---|
760 | * Serializing paranoia.
|
---|
761 | */
|
---|
762 | int rc = RTCritSectEnter(&pSink->CritSect);
|
---|
763 | AssertRCReturnVoid(rc);
|
---|
764 | RTCritSectLeave(&pSink->CritSect);
|
---|
765 |
|
---|
766 | /*
|
---|
767 | * Unlink from parent.
|
---|
768 | */
|
---|
769 | PAUDIOMIXER pMixer = pSink->pParent;
|
---|
770 | if ( RT_VALID_PTR(pMixer)
|
---|
771 | && pMixer->uMagic == AUDIOMIXER_MAGIC)
|
---|
772 | {
|
---|
773 | RTCritSectEnter(&pMixer->CritSect);
|
---|
774 | audioMixerRemoveSinkInternal(pMixer, pSink);
|
---|
775 | RTCritSectLeave(&pMixer->CritSect);
|
---|
776 | }
|
---|
777 | else if (pMixer)
|
---|
778 | AssertFailed();
|
---|
779 |
|
---|
780 | /*
|
---|
781 | * Actually destroy it.
|
---|
782 | */
|
---|
783 | audioMixerSinkDestroyInternal(pSink, pDevIns);
|
---|
784 | }
|
---|
785 |
|
---|
786 |
|
---|
787 | /**
|
---|
788 | * Get the number of bytes that can be read from the sink.
|
---|
789 | *
|
---|
790 | * @returns Number of bytes.
|
---|
791 | * @param pSink The mixer sink.
|
---|
792 | *
|
---|
793 | * @note Only applicable to input sinks, will assert and return zero for
|
---|
794 | * other sink directions.
|
---|
795 | */
|
---|
796 | uint32_t AudioMixerSinkGetReadable(PAUDMIXSINK pSink)
|
---|
797 | {
|
---|
798 | AssertPtrReturn(pSink, 0);
|
---|
799 | AssertReturn(pSink->uMagic == AUDMIXSINK_MAGIC, 0);
|
---|
800 | AssertMsgReturn(pSink->enmDir == PDMAUDIODIR_IN, ("%s: Can't read from a non-input sink\n", pSink->pszName), 0);
|
---|
801 |
|
---|
802 | int rc = RTCritSectEnter(&pSink->CritSect);
|
---|
803 | AssertRCReturn(rc, 0);
|
---|
804 |
|
---|
805 | uint32_t cbReadable = 0;
|
---|
806 | if (pSink->fStatus & AUDMIXSINK_STS_RUNNING)
|
---|
807 | cbReadable = AudioMixBufUsedBytes(&pSink->MixBuf);
|
---|
808 |
|
---|
809 | RTCritSectLeave(&pSink->CritSect);
|
---|
810 | Log3Func(("[%s] cbReadable=%#x\n", pSink->pszName, cbReadable));
|
---|
811 | return cbReadable;
|
---|
812 | }
|
---|
813 |
|
---|
814 |
|
---|
815 | /**
|
---|
816 | * Get the number of bytes that can be written to be sink.
|
---|
817 | *
|
---|
818 | * @returns Number of bytes.
|
---|
819 | * @param pSink The mixer sink.
|
---|
820 | *
|
---|
821 | * @note Only applicable to output sinks, will assert and return zero for
|
---|
822 | * other sink directions.
|
---|
823 | */
|
---|
824 | uint32_t AudioMixerSinkGetWritable(PAUDMIXSINK pSink)
|
---|
825 | {
|
---|
826 | AssertPtrReturn(pSink, 0);
|
---|
827 | AssertReturn(pSink->uMagic == AUDMIXSINK_MAGIC, 0);
|
---|
828 | AssertMsgReturn(pSink->enmDir == PDMAUDIODIR_OUT, ("%s: Can't write to a non-output sink\n", pSink->pszName), 0);
|
---|
829 |
|
---|
830 | int rc = RTCritSectEnter(&pSink->CritSect);
|
---|
831 | AssertRCReturn(rc, 0);
|
---|
832 |
|
---|
833 | uint32_t cbWritable = 0;
|
---|
834 | if ((pSink->fStatus & (AUDMIXSINK_STS_RUNNING | AUDMIXSINK_STS_DRAINING)) == AUDMIXSINK_STS_RUNNING)
|
---|
835 | cbWritable = AudioMixBufFreeBytes(&pSink->MixBuf);
|
---|
836 |
|
---|
837 | RTCritSectLeave(&pSink->CritSect);
|
---|
838 | Log3Func(("[%s] cbWritable=%#x (%RU64ms)\n", pSink->pszName, cbWritable,
|
---|
839 | PDMAudioPropsBytesToMilli(&pSink->PCMProps, cbWritable) ));
|
---|
840 | return cbWritable;
|
---|
841 | }
|
---|
842 |
|
---|
843 |
|
---|
844 | /**
|
---|
845 | * Get the sink's mixing direction.
|
---|
846 | *
|
---|
847 | * @returns Mixing direction.
|
---|
848 | * @param pSink The mixer sink.
|
---|
849 | */
|
---|
850 | PDMAUDIODIR AudioMixerSinkGetDir(PCAUDMIXSINK pSink)
|
---|
851 | {
|
---|
852 | AssertPtrReturn(pSink, PDMAUDIODIR_INVALID);
|
---|
853 | AssertReturn(pSink->uMagic == AUDMIXSINK_MAGIC, PDMAUDIODIR_INVALID);
|
---|
854 |
|
---|
855 | /* The sink direction cannot be changed after creation, so no need for locking here. */
|
---|
856 | return pSink->enmDir;
|
---|
857 | }
|
---|
858 |
|
---|
859 |
|
---|
860 | /**
|
---|
861 | * Get the sink status.
|
---|
862 | *
|
---|
863 | * @returns AUDMIXSINK_STS_XXX
|
---|
864 | * @param pSink The mixer sink.
|
---|
865 | */
|
---|
866 | uint32_t AudioMixerSinkGetStatus(PAUDMIXSINK pSink)
|
---|
867 | {
|
---|
868 | AssertPtrReturn(pSink, AUDMIXSINK_STS_NONE);
|
---|
869 | AssertReturn(pSink->uMagic == AUDMIXSINK_MAGIC, AUDMIXSINK_STS_NONE);
|
---|
870 |
|
---|
871 | int rc = RTCritSectEnter(&pSink->CritSect);
|
---|
872 | AssertRCReturn(rc, AUDMIXSINK_STS_NONE);
|
---|
873 |
|
---|
874 | uint32_t const fStsSink = pSink->fStatus;
|
---|
875 |
|
---|
876 | RTCritSectLeave(&pSink->CritSect);
|
---|
877 | return fStsSink;
|
---|
878 | }
|
---|
879 |
|
---|
880 |
|
---|
881 | /**
|
---|
882 | * Checks if the sink is active not.
|
---|
883 | *
|
---|
884 | * @note The pending disable state also counts as active.
|
---|
885 | *
|
---|
886 | * @retval true if active.
|
---|
887 | * @retval false if not active.
|
---|
888 | * @param pSink The mixer sink. NULL is okay (returns false).
|
---|
889 | */
|
---|
890 | bool AudioMixerSinkIsActive(PAUDMIXSINK pSink)
|
---|
891 | {
|
---|
892 | if (!pSink)
|
---|
893 | return false;
|
---|
894 | AssertPtr(pSink);
|
---|
895 | AssertReturn(pSink->uMagic == AUDMIXSINK_MAGIC, false);
|
---|
896 |
|
---|
897 | int rc = RTCritSectEnter(&pSink->CritSect);
|
---|
898 | AssertRCReturn(rc, false);
|
---|
899 |
|
---|
900 | bool const fIsActive = RT_BOOL(pSink->fStatus & AUDMIXSINK_STS_RUNNING);
|
---|
901 |
|
---|
902 | RTCritSectLeave(&pSink->CritSect);
|
---|
903 | Log3Func(("[%s] returns %RTbool\n", pSink->pszName, fIsActive));
|
---|
904 | return fIsActive;
|
---|
905 | }
|
---|
906 |
|
---|
907 |
|
---|
908 | /**
|
---|
909 | * Resets the sink's state.
|
---|
910 | *
|
---|
911 | * @param pSink The sink to reset.
|
---|
912 | * @note Must own sink lock.
|
---|
913 | */
|
---|
914 | static void audioMixerSinkResetInternal(PAUDMIXSINK pSink)
|
---|
915 | {
|
---|
916 | Assert(RTCritSectIsOwner(&pSink->CritSect));
|
---|
917 | LogFunc(("[%s]\n", pSink->pszName));
|
---|
918 |
|
---|
919 | /* Drop mixing buffer content. */
|
---|
920 | AudioMixBufDrop(&pSink->MixBuf);
|
---|
921 |
|
---|
922 | /* Reset status. */
|
---|
923 | pSink->fStatus = AUDMIXSINK_STS_NONE;
|
---|
924 | pSink->tsLastUpdatedMs = 0;
|
---|
925 | }
|
---|
926 |
|
---|
927 |
|
---|
928 | /**
|
---|
929 | * Resets a sink. This will immediately stop all processing.
|
---|
930 | *
|
---|
931 | * @param pSink Sink to reset.
|
---|
932 | */
|
---|
933 | void AudioMixerSinkReset(PAUDMIXSINK pSink)
|
---|
934 | {
|
---|
935 | if (!pSink)
|
---|
936 | return;
|
---|
937 | AssertReturnVoid(pSink->uMagic == AUDMIXSINK_MAGIC);
|
---|
938 |
|
---|
939 | int rc = RTCritSectEnter(&pSink->CritSect);
|
---|
940 | AssertRCReturnVoid(rc);
|
---|
941 |
|
---|
942 | LogFlowFunc(("[%s]\n", pSink->pszName));
|
---|
943 |
|
---|
944 | /*
|
---|
945 | * Stop any stream that's enabled before resetting the state.
|
---|
946 | */
|
---|
947 | PAUDMIXSTREAM pStream;
|
---|
948 | RTListForEach(&pSink->lstStreams, pStream, AUDMIXSTREAM, Node)
|
---|
949 | {
|
---|
950 | if (pStream->fStatus & AUDMIXSTREAM_STATUS_ENABLED)
|
---|
951 | audioMixerStreamCtlInternal(pStream, PDMAUDIOSTREAMCMD_DISABLE);
|
---|
952 | }
|
---|
953 |
|
---|
954 | /*
|
---|
955 | * Reset the state.
|
---|
956 | */
|
---|
957 | audioMixerSinkResetInternal(pSink);
|
---|
958 |
|
---|
959 | RTCritSectLeave(&pSink->CritSect);
|
---|
960 | }
|
---|
961 |
|
---|
962 |
|
---|
963 | /**
|
---|
964 | * Sets the audio format of a mixer sink.
|
---|
965 | *
|
---|
966 | * @returns VBox status code.
|
---|
967 | * @param pSink The sink to set audio format for.
|
---|
968 | * @param pProps The properties of the new audio format (guest side).
|
---|
969 | * @param cMsSchedulingHint Scheduling hint for mixer buffer sizing.
|
---|
970 | */
|
---|
971 | int AudioMixerSinkSetFormat(PAUDMIXSINK pSink, PCPDMAUDIOPCMPROPS pProps, uint32_t cMsSchedulingHint)
|
---|
972 | {
|
---|
973 | AssertPtrReturn(pSink, VERR_INVALID_POINTER);
|
---|
974 | AssertReturn(pSink->uMagic == AUDMIXSINK_MAGIC, VERR_INVALID_MAGIC);
|
---|
975 | AssertPtrReturn(pProps, VERR_INVALID_POINTER);
|
---|
976 | AssertReturn(AudioHlpPcmPropsAreValidAndSupported(pProps), VERR_INVALID_PARAMETER);
|
---|
977 |
|
---|
978 | /*
|
---|
979 | * Calculate the mixer buffer size so we can force a recreation if it changes.
|
---|
980 | *
|
---|
981 | * This used to be fixed at 100ms, however that's usually too generous and can
|
---|
982 | * in theory be too small. Generally, we size the buffer at 3 DMA periods as
|
---|
983 | * that seems reasonable. Now, since the we don't quite trust the scheduling
|
---|
984 | * hint we're getting, make sure we're got a minimum of 30ms buffer space, but
|
---|
985 | * no more than 500ms.
|
---|
986 | */
|
---|
987 | if (cMsSchedulingHint <= 10)
|
---|
988 | cMsSchedulingHint = 30;
|
---|
989 | else
|
---|
990 | {
|
---|
991 | cMsSchedulingHint *= 3;
|
---|
992 | if (cMsSchedulingHint > 500)
|
---|
993 | cMsSchedulingHint = 500;
|
---|
994 | }
|
---|
995 | uint32_t const cBufferFrames = PDMAudioPropsMilliToFrames(pProps, cMsSchedulingHint);
|
---|
996 | /** @todo configuration override on the buffer size? */
|
---|
997 |
|
---|
998 | int rc = RTCritSectEnter(&pSink->CritSect);
|
---|
999 | AssertRCReturn(rc, rc);
|
---|
1000 |
|
---|
1001 | /*
|
---|
1002 | * Do nothing unless the format actually changed.
|
---|
1003 | * The buffer size must not match exactly, within +/- 2% is okay.
|
---|
1004 | */
|
---|
1005 | uint32_t cOldBufferFrames;
|
---|
1006 | if ( !PDMAudioPropsAreEqual(&pSink->PCMProps, pProps)
|
---|
1007 | || ( cBufferFrames != (cOldBufferFrames = AudioMixBufSize(&pSink->MixBuf))
|
---|
1008 | && (uint32_t)RT_ABS((int32_t)(cBufferFrames - cOldBufferFrames)) > cBufferFrames / 50) )
|
---|
1009 | {
|
---|
1010 | #ifdef LOG_ENABLED
|
---|
1011 | char szTmp[PDMAUDIOPROPSTOSTRING_MAX];
|
---|
1012 | #endif
|
---|
1013 | if (PDMAudioPropsHz(&pSink->PCMProps) != 0)
|
---|
1014 | LogFlowFunc(("[%s] Old format: %s; buffer: %u frames\n", pSink->pszName,
|
---|
1015 | PDMAudioPropsToString(&pSink->PCMProps, szTmp, sizeof(szTmp)), AudioMixBufSize(&pSink->MixBuf) ));
|
---|
1016 | pSink->PCMProps = *pProps;
|
---|
1017 | LogFlowFunc(("[%s] New format: %s; buffer: %u frames\n", pSink->pszName,
|
---|
1018 | PDMAudioPropsToString(&pSink->PCMProps, szTmp, sizeof(szTmp)), cBufferFrames ));
|
---|
1019 |
|
---|
1020 | /*
|
---|
1021 | * Also update the sink's mixing buffer format.
|
---|
1022 | */
|
---|
1023 | AudioMixBufTerm(&pSink->MixBuf);
|
---|
1024 |
|
---|
1025 | rc = AudioMixBufInit(&pSink->MixBuf, pSink->pszName, &pSink->PCMProps, cBufferFrames);
|
---|
1026 | if (RT_SUCCESS(rc))
|
---|
1027 | {
|
---|
1028 | /*
|
---|
1029 | * Input sinks must init their (mostly dummy) peek state.
|
---|
1030 | */
|
---|
1031 | if (pSink->enmDir == PDMAUDIODIR_IN)
|
---|
1032 | rc = AudioMixBufInitPeekState(&pSink->MixBuf, &pSink->In.State, &pSink->PCMProps);
|
---|
1033 | else
|
---|
1034 | rc = AudioMixBufInitWriteState(&pSink->MixBuf, &pSink->Out.State, &pSink->PCMProps);
|
---|
1035 | if (RT_SUCCESS(rc))
|
---|
1036 | {
|
---|
1037 | /*
|
---|
1038 | * Re-initialize the peek/write states as the frequency, channel count
|
---|
1039 | * and other things may have changed now.
|
---|
1040 | */
|
---|
1041 | PAUDMIXSTREAM pMixStream;
|
---|
1042 | if (pSink->enmDir == PDMAUDIODIR_IN)
|
---|
1043 | {
|
---|
1044 | RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
|
---|
1045 | {
|
---|
1046 | int rc2 = AudioMixBufInitWriteState(&pSink->MixBuf, &pMixStream->WriteState, &pMixStream->pStream->Cfg.Props);
|
---|
1047 | /** @todo remember this. */
|
---|
1048 | AssertLogRelRC(rc2);
|
---|
1049 | }
|
---|
1050 | }
|
---|
1051 | else
|
---|
1052 | {
|
---|
1053 | RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
|
---|
1054 | {
|
---|
1055 | int rc2 = AudioMixBufInitPeekState(&pSink->MixBuf, &pMixStream->PeekState, &pMixStream->pStream->Cfg.Props);
|
---|
1056 | /** @todo remember this. */
|
---|
1057 | AssertLogRelRC(rc2);
|
---|
1058 | }
|
---|
1059 | }
|
---|
1060 |
|
---|
1061 | /*
|
---|
1062 | * Debug.
|
---|
1063 | */
|
---|
1064 | if (!(pSink->pParent->fFlags & AUDMIXER_FLAGS_DEBUG))
|
---|
1065 | { /* likely */ }
|
---|
1066 | else
|
---|
1067 | {
|
---|
1068 | AudioHlpFileClose(pSink->Dbg.pFile);
|
---|
1069 |
|
---|
1070 | char szName[64];
|
---|
1071 | RTStrPrintf(szName, sizeof(szName), "MixerSink-%s", pSink->pszName);
|
---|
1072 | AudioHlpFileCreateAndOpen(&pSink->Dbg.pFile, NULL /*pszDir - use temp dir*/, szName,
|
---|
1073 | 0 /*iInstance*/, &pSink->PCMProps);
|
---|
1074 | }
|
---|
1075 | }
|
---|
1076 | else
|
---|
1077 | LogFunc(("%s failed: %Rrc\n",
|
---|
1078 | pSink->enmDir == PDMAUDIODIR_IN ? "AudioMixBufInitPeekState" : "AudioMixBufInitWriteState", rc));
|
---|
1079 | }
|
---|
1080 | else
|
---|
1081 | LogFunc(("AudioMixBufInit failed: %Rrc\n", rc));
|
---|
1082 | }
|
---|
1083 |
|
---|
1084 | RTCritSectLeave(&pSink->CritSect);
|
---|
1085 | LogFlowFuncLeaveRC(rc);
|
---|
1086 | return rc;
|
---|
1087 | }
|
---|
1088 |
|
---|
1089 |
|
---|
1090 | /**
|
---|
1091 | * Updates the combined volume (sink + mixer) of a mixer sink.
|
---|
1092 | *
|
---|
1093 | * @returns VBox status code.
|
---|
1094 | * @param pSink The mixer sink to update volume for (valid).
|
---|
1095 | * @param pVolMaster The master (mixer) volume (valid).
|
---|
1096 | */
|
---|
1097 | static int audioMixerSinkUpdateVolume(PAUDMIXSINK pSink, PCPDMAUDIOVOLUME pVolMaster)
|
---|
1098 | {
|
---|
1099 | AssertPtr(pSink);
|
---|
1100 | Assert(pSink->uMagic == AUDMIXSINK_MAGIC);
|
---|
1101 | AssertPtr(pVolMaster);
|
---|
1102 | LogFlowFunc(("[%s] Master fMuted=%RTbool auChannels=%.*Rhxs\n",
|
---|
1103 | pSink->pszName, pVolMaster->fMuted, sizeof(pVolMaster->auChannels), pVolMaster->auChannels));
|
---|
1104 |
|
---|
1105 | PDMAudioVolumeCombine(&pSink->VolumeCombined, &pSink->Volume, pVolMaster);
|
---|
1106 |
|
---|
1107 | LogFlowFunc(("[%s] fMuted=%RTbool auChannels=%.*Rhxs -> fMuted=%RTbool auChannels=%.*Rhxs\n", pSink->pszName,
|
---|
1108 | pSink->Volume.fMuted, sizeof(pSink->Volume.auChannels), pSink->Volume.auChannels,
|
---|
1109 | pSink->VolumeCombined.fMuted, sizeof(pSink->VolumeCombined.auChannels), pSink->VolumeCombined.auChannels ));
|
---|
1110 |
|
---|
1111 | AudioMixBufSetVolume(&pSink->MixBuf, &pSink->VolumeCombined);
|
---|
1112 | return VINF_SUCCESS;
|
---|
1113 | }
|
---|
1114 |
|
---|
1115 |
|
---|
1116 | /**
|
---|
1117 | * Sets the volume a mixer sink.
|
---|
1118 | *
|
---|
1119 | * @returns VBox status code.
|
---|
1120 | * @param pSink The sink to set volume for.
|
---|
1121 | * @param pVol New volume settings.
|
---|
1122 | */
|
---|
1123 | int AudioMixerSinkSetVolume(PAUDMIXSINK pSink, PCPDMAUDIOVOLUME pVol)
|
---|
1124 | {
|
---|
1125 | AssertPtrReturn(pSink, VERR_INVALID_POINTER);
|
---|
1126 | AssertReturn(pSink->uMagic == AUDMIXSINK_MAGIC, VERR_INVALID_MAGIC);
|
---|
1127 | AssertPtrReturn(pVol, VERR_INVALID_POINTER);
|
---|
1128 |
|
---|
1129 | int rc = RTCritSectEnter(&pSink->CritSect);
|
---|
1130 | AssertRCReturn(rc, rc);
|
---|
1131 |
|
---|
1132 | memcpy(&pSink->Volume, pVol, sizeof(PDMAUDIOVOLUME));
|
---|
1133 |
|
---|
1134 | LogRel2(("Audio Mixer: Setting volume of sink '%s' to fMuted=%RTbool auChannels=%.*Rhxs\n",
|
---|
1135 | pSink->pszName, pVol->fMuted, sizeof(pVol->auChannels), pVol->auChannels));
|
---|
1136 |
|
---|
1137 | Assert(pSink->pParent);
|
---|
1138 | if (pSink->pParent)
|
---|
1139 | rc = audioMixerSinkUpdateVolume(pSink, &pSink->pParent->VolMaster);
|
---|
1140 |
|
---|
1141 | RTCritSectLeave(&pSink->CritSect);
|
---|
1142 |
|
---|
1143 | return rc;
|
---|
1144 | }
|
---|
1145 |
|
---|
1146 |
|
---|
1147 | /**
|
---|
1148 | * Helper for audioMixerSinkUpdateInput that determins now many frames it can
|
---|
1149 | * transfer from the drivers and into the sink's mixer buffer.
|
---|
1150 | *
|
---|
1151 | * This also updates the mixer stream status, which may involve stream re-inits.
|
---|
1152 | *
|
---|
1153 | * @returns Number of frames.
|
---|
1154 | * @param pSink The sink.
|
---|
1155 | * @param pcReadableStreams Where to return the number of readable streams.
|
---|
1156 | */
|
---|
1157 | static uint32_t audioMixerSinkUpdateInputCalcFramesToTransfer(PAUDMIXSINK pSink, uint32_t *pcReadableStreams)
|
---|
1158 | {
|
---|
1159 | uint32_t cFramesToRead = AudioMixBufFree(&pSink->MixBuf);
|
---|
1160 | uint32_t cReadableStreams = 0;
|
---|
1161 | PAUDMIXSTREAM pMixStream;
|
---|
1162 | RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
|
---|
1163 | {
|
---|
1164 | int rc2 = audioMixerStreamUpdateStatus(pMixStream);
|
---|
1165 | AssertRC(rc2);
|
---|
1166 |
|
---|
1167 | if (pMixStream->fStatus & AUDMIXSTREAM_STATUS_CAN_READ)
|
---|
1168 | {
|
---|
1169 | PPDMIAUDIOCONNECTOR const pIConnector = pMixStream->pConn;
|
---|
1170 | PPDMAUDIOSTREAM const pStream = pMixStream->pStream;
|
---|
1171 | pIConnector->pfnStreamIterate(pIConnector, pStream);
|
---|
1172 |
|
---|
1173 | uint32_t const cbReadable = pIConnector->pfnStreamGetReadable(pIConnector, pStream);
|
---|
1174 | uint32_t cFrames = PDMAudioPropsBytesToFrames(&pStream->Cfg.Props, cbReadable);
|
---|
1175 | pMixStream->cFramesLastAvail = cFrames;
|
---|
1176 | if (PDMAudioPropsHz(&pStream->Cfg.Props) == PDMAudioPropsHz(&pSink->MixBuf.Props))
|
---|
1177 | { /* likely */ }
|
---|
1178 | else
|
---|
1179 | {
|
---|
1180 | cFrames = cFrames * PDMAudioPropsHz(&pSink->MixBuf.Props) / PDMAudioPropsHz(&pStream->Cfg.Props);
|
---|
1181 | cFrames = cFrames > 2 ? cFrames - 2 : 0; /* rounding safety fudge */
|
---|
1182 | }
|
---|
1183 | if (cFramesToRead > cFrames && !pMixStream->fUnreliable)
|
---|
1184 | {
|
---|
1185 | Log4Func(("%s: cFramesToRead %u -> %u; %s (%u bytes readable)\n",
|
---|
1186 | pSink->pszName, cFramesToRead, cFrames, pMixStream->pszName, cbReadable));
|
---|
1187 | cFramesToRead = cFrames;
|
---|
1188 | }
|
---|
1189 | cReadableStreams++;
|
---|
1190 | }
|
---|
1191 | }
|
---|
1192 |
|
---|
1193 | *pcReadableStreams = cReadableStreams;
|
---|
1194 | return cFramesToRead;
|
---|
1195 | }
|
---|
1196 |
|
---|
1197 |
|
---|
1198 | /**
|
---|
1199 | * Updates an input mixer sink.
|
---|
1200 | *
|
---|
1201 | * @returns VBox status code.
|
---|
1202 | * @param pSink Mixer sink to update.
|
---|
1203 | * @param cbDmaBuf The number of bytes in the DMA buffer. For detecting
|
---|
1204 | * underruns. Zero if we don't know.
|
---|
1205 | * @param cbDmaPeriod The minimum number of bytes required for reliable DMA
|
---|
1206 | * operation. Zero if we don't know.
|
---|
1207 | */
|
---|
1208 | static int audioMixerSinkUpdateInput(PAUDMIXSINK pSink, uint32_t cbDmaBuf, uint32_t cbDmaPeriod)
|
---|
1209 | {
|
---|
1210 | PAUDMIXSTREAM pMixStream;
|
---|
1211 | Assert(!(pSink->fStatus & AUDMIXSINK_STS_DRAINED_MIXBUF)); /* (can't drain input sink) */
|
---|
1212 |
|
---|
1213 | /*
|
---|
1214 | * Iterate, update status and check each mixing sink stream for how much
|
---|
1215 | * we can transfer.
|
---|
1216 | *
|
---|
1217 | * We're currently using the minimum size of all streams, however this
|
---|
1218 | * isn't a smart approach as it means one disfunctional stream can block
|
---|
1219 | * working ones. So, if we end up with zero frames and a full mixer
|
---|
1220 | * buffer we'll disregard the stream that accept the smallest amount and
|
---|
1221 | * try again.
|
---|
1222 | */
|
---|
1223 | uint32_t cReadableStreams = 0;
|
---|
1224 | uint32_t cFramesToXfer = audioMixerSinkUpdateInputCalcFramesToTransfer(pSink, &cReadableStreams);
|
---|
1225 | if ( cFramesToXfer != 0
|
---|
1226 | || cReadableStreams <= 1
|
---|
1227 | || cbDmaPeriod == 0 /* Insufficient info to decide. The update function will call us again, at least for HDA. */
|
---|
1228 | || cbDmaBuf + PDMAudioPropsFramesToBytes(&pSink->PCMProps, AudioMixBufUsed(&pSink->MixBuf)) >= cbDmaPeriod)
|
---|
1229 | Log3Func(("%s: cFreeFrames=%#x cFramesToXfer=%#x cReadableStreams=%#x\n", pSink->pszName,
|
---|
1230 | AudioMixBufFree(&pSink->MixBuf), cFramesToXfer, cReadableStreams));
|
---|
1231 | else
|
---|
1232 | {
|
---|
1233 | Log3Func(("%s: MixBuf is underrunning but one or more streams only provides zero frames. Try disregarding those...\n", pSink->pszName));
|
---|
1234 | uint32_t cReliableStreams = 0;
|
---|
1235 | uint32_t cMarkedUnreliable = 0;
|
---|
1236 | PAUDMIXSTREAM pMixStreamMin = NULL;
|
---|
1237 | RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
|
---|
1238 | {
|
---|
1239 | if (pMixStream->fStatus & AUDMIXSTREAM_STATUS_CAN_READ)
|
---|
1240 | {
|
---|
1241 | if (!pMixStream->fUnreliable)
|
---|
1242 | {
|
---|
1243 | if (pMixStream->cFramesLastAvail == 0)
|
---|
1244 | {
|
---|
1245 | cMarkedUnreliable++;
|
---|
1246 | pMixStream->fUnreliable = true;
|
---|
1247 | Log3Func(("%s: Marked '%s' as unreliable.\n", pSink->pszName, pMixStream->pszName));
|
---|
1248 | pMixStreamMin = pMixStream;
|
---|
1249 | }
|
---|
1250 | else
|
---|
1251 | {
|
---|
1252 | if (!pMixStreamMin || pMixStream->cFramesLastAvail < pMixStreamMin->cFramesLastAvail)
|
---|
1253 | pMixStreamMin = pMixStream;
|
---|
1254 | cReliableStreams++;
|
---|
1255 | }
|
---|
1256 | }
|
---|
1257 | }
|
---|
1258 | }
|
---|
1259 |
|
---|
1260 | if (cMarkedUnreliable == 0 && cReliableStreams > 1 && pMixStreamMin != NULL)
|
---|
1261 | {
|
---|
1262 | cReliableStreams--;
|
---|
1263 | cMarkedUnreliable++;
|
---|
1264 | pMixStreamMin->fUnreliable = true;
|
---|
1265 | Log3Func(("%s: Marked '%s' as unreliable (%u frames).\n",
|
---|
1266 | pSink->pszName, pMixStreamMin->pszName, pMixStreamMin->cFramesLastAvail));
|
---|
1267 | }
|
---|
1268 |
|
---|
1269 | if (cMarkedUnreliable > 0)
|
---|
1270 | {
|
---|
1271 | cReadableStreams = 0;
|
---|
1272 | cFramesToXfer = audioMixerSinkUpdateInputCalcFramesToTransfer(pSink, &cReadableStreams);
|
---|
1273 | }
|
---|
1274 |
|
---|
1275 | Log3Func(("%s: cFreeFrames=%#x cFramesToXfer=%#x cReadableStreams=%#x cMarkedUnreliable=%#x cReliableStreams=%#x\n",
|
---|
1276 | pSink->pszName, AudioMixBufFree(&pSink->MixBuf), cFramesToXfer,
|
---|
1277 | cReadableStreams, cMarkedUnreliable, cReliableStreams));
|
---|
1278 | }
|
---|
1279 |
|
---|
1280 | if (cReadableStreams > 0)
|
---|
1281 | {
|
---|
1282 | if (cFramesToXfer > 0)
|
---|
1283 | {
|
---|
1284 | /*#define ELECTRIC_INPUT_BUFFER*/ /* if buffer code is misbehaving, enable this to catch overflows. */
|
---|
1285 | #ifndef ELECTRIC_INPUT_BUFFER
|
---|
1286 | union
|
---|
1287 | {
|
---|
1288 | uint8_t ab[8192];
|
---|
1289 | uint64_t au64[8192 / sizeof(uint64_t)]; /* Use uint64_t to ensure good alignment. */
|
---|
1290 | } Buf;
|
---|
1291 | void * const pvBuf = &Buf;
|
---|
1292 | uint32_t const cbBuf = sizeof(Buf);
|
---|
1293 | #else
|
---|
1294 | uint32_t const cbBuf = 0x2000 - 16;
|
---|
1295 | void * const pvBuf = RTMemEfAlloc(cbBuf, RTMEM_TAG, RT_SRC_POS);
|
---|
1296 | #endif
|
---|
1297 |
|
---|
1298 | /*
|
---|
1299 | * For each of the enabled streams, read cFramesToXfer frames worth
|
---|
1300 | * of samples from them and merge that into the mixing buffer.
|
---|
1301 | */
|
---|
1302 | bool fAssign = true;
|
---|
1303 | RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
|
---|
1304 | {
|
---|
1305 | if (pMixStream->fStatus & AUDMIXSTREAM_STATUS_CAN_READ)
|
---|
1306 | {
|
---|
1307 | PPDMIAUDIOCONNECTOR const pIConnector = pMixStream->pConn;
|
---|
1308 | PPDMAUDIOSTREAM const pStream = pMixStream->pStream;
|
---|
1309 |
|
---|
1310 | /* Calculate how many bytes we should read from this stream. */
|
---|
1311 | bool const fResampleSrc = PDMAudioPropsHz(&pStream->Cfg.Props) != PDMAudioPropsHz(&pSink->MixBuf.Props);
|
---|
1312 | uint32_t const cbSrcToXfer = !fResampleSrc
|
---|
1313 | ? PDMAudioPropsFramesToBytes(&pStream->Cfg.Props, cFramesToXfer)
|
---|
1314 | : PDMAudioPropsFramesToBytes(&pStream->Cfg.Props, /** @todo check rounding errors here... */
|
---|
1315 | cFramesToXfer * PDMAudioPropsHz(&pSink->MixBuf.Props)
|
---|
1316 | / PDMAudioPropsHz(&pStream->Cfg.Props));
|
---|
1317 |
|
---|
1318 | /* Do the reading. */
|
---|
1319 | uint32_t offSrc = 0;
|
---|
1320 | uint32_t offDstFrame = 0;
|
---|
1321 | do
|
---|
1322 | {
|
---|
1323 | /*
|
---|
1324 | * Read a chunk from the backend.
|
---|
1325 | */
|
---|
1326 | uint32_t const cbSrcToRead = RT_MIN(cbBuf, cbSrcToXfer - offSrc);
|
---|
1327 | uint32_t cbSrcRead = 0;
|
---|
1328 | if (cbSrcToRead > 0)
|
---|
1329 | {
|
---|
1330 | int rc2 = pIConnector->pfnStreamCapture(pIConnector, pStream, pvBuf, cbSrcToRead, &cbSrcRead);
|
---|
1331 | Log3Func(("%s: %#x L %#x => %#x bytes; rc2=%Rrc %s\n",
|
---|
1332 | pSink->pszName, offSrc, cbSrcToRead, cbSrcRead, rc2, pMixStream->pszName));
|
---|
1333 |
|
---|
1334 | if (RT_SUCCESS(rc2))
|
---|
1335 | AssertLogRelMsg(cbSrcRead == cbSrcToRead || pMixStream->fUnreliable,
|
---|
1336 | ("cbSrcRead=%#x cbSrcToRead=%#x - (sink '%s')\n",
|
---|
1337 | cbSrcRead, cbSrcToRead, pSink->pszName));
|
---|
1338 | else if (rc2 == VERR_AUDIO_STREAM_NOT_READY)
|
---|
1339 | {
|
---|
1340 | LogRel2(("Audio Mixer: '%s' (sink '%s'): Stream not ready - skipping.\n",
|
---|
1341 | pMixStream->pszName, pSink->pszName)); /* must've changed status, stop processing */
|
---|
1342 | break;
|
---|
1343 | }
|
---|
1344 | else
|
---|
1345 | {
|
---|
1346 | Assert(rc2 != VERR_BUFFER_OVERFLOW);
|
---|
1347 | LogRel2(("Audio Mixer: Reading from mixer stream '%s' (sink '%s') failed, rc=%Rrc\n",
|
---|
1348 | pMixStream->pszName, pSink->pszName, rc2));
|
---|
1349 | break;
|
---|
1350 | }
|
---|
1351 | offSrc += cbSrcRead;
|
---|
1352 | }
|
---|
1353 | else
|
---|
1354 | Assert(fResampleSrc); /** @todo test this case */
|
---|
1355 |
|
---|
1356 | /*
|
---|
1357 | * Assign or blend it into the mixer buffer.
|
---|
1358 | */
|
---|
1359 | uint32_t cFramesDstTransferred = 0;
|
---|
1360 | if (fAssign)
|
---|
1361 | {
|
---|
1362 | /** @todo could complicate this by detecting silence here too and stay in
|
---|
1363 | * assign mode till we get a stream with non-silence... */
|
---|
1364 | AudioMixBufWrite(&pSink->MixBuf, &pMixStream->WriteState, pvBuf, cbSrcRead,
|
---|
1365 | offDstFrame, cFramesToXfer - offDstFrame, &cFramesDstTransferred);
|
---|
1366 | }
|
---|
1367 | /* We don't need to blend silence buffers. For simplicity, always blend
|
---|
1368 | when we're resampling (for rounding). */
|
---|
1369 | else if (fResampleSrc || !PDMAudioPropsIsBufferSilence(&pStream->Cfg.Props, pvBuf, cbSrcRead))
|
---|
1370 | {
|
---|
1371 | AudioMixBufBlend(&pSink->MixBuf, &pMixStream->WriteState, pvBuf, cbSrcRead,
|
---|
1372 | offDstFrame, cFramesToXfer - offDstFrame, &cFramesDstTransferred);
|
---|
1373 | }
|
---|
1374 | else
|
---|
1375 | {
|
---|
1376 | cFramesDstTransferred = PDMAudioPropsBytesToFrames(&pStream->Cfg.Props, cbSrcRead);
|
---|
1377 | AudioMixBufBlendGap(&pSink->MixBuf, &pMixStream->WriteState, cFramesDstTransferred);
|
---|
1378 | }
|
---|
1379 | AssertBreak(cFramesDstTransferred > 0);
|
---|
1380 |
|
---|
1381 | /* Advance. */
|
---|
1382 | offDstFrame += cFramesDstTransferred;
|
---|
1383 | } while (offDstFrame < cFramesToXfer);
|
---|
1384 |
|
---|
1385 | /*
|
---|
1386 | * In case the first stream is misbehaving, make sure we written the entire area.
|
---|
1387 | */
|
---|
1388 | if (offDstFrame >= cFramesToXfer)
|
---|
1389 | { /* likely */ }
|
---|
1390 | else if (fAssign)
|
---|
1391 | AudioMixBufSilence(&pSink->MixBuf, &pMixStream->WriteState, offDstFrame, cFramesToXfer - offDstFrame);
|
---|
1392 | else
|
---|
1393 | AudioMixBufBlendGap(&pSink->MixBuf, &pMixStream->WriteState, cFramesToXfer - offDstFrame);
|
---|
1394 | fAssign = false;
|
---|
1395 | }
|
---|
1396 | }
|
---|
1397 |
|
---|
1398 | /*
|
---|
1399 | * Commit the buffer area we've written and blended into.
|
---|
1400 | */
|
---|
1401 | AudioMixBufCommit(&pSink->MixBuf, cFramesToXfer);
|
---|
1402 |
|
---|
1403 | #ifdef ELECTRIC_INPUT_BUFFER
|
---|
1404 | RTMemEfFree(pvBuf, RT_SRC_POS);
|
---|
1405 | #endif
|
---|
1406 | }
|
---|
1407 |
|
---|
1408 | /*
|
---|
1409 | * Set the dirty flag for what it's worth.
|
---|
1410 | */
|
---|
1411 | pSink->fStatus |= AUDMIXSINK_STS_DIRTY;
|
---|
1412 | }
|
---|
1413 | else
|
---|
1414 | {
|
---|
1415 | /*
|
---|
1416 | * No readable stream. Clear the dirty flag if empty (pointless flag).
|
---|
1417 | */
|
---|
1418 | if (!AudioMixBufUsed(&pSink->MixBuf))
|
---|
1419 | pSink->fStatus &= ~AUDMIXSINK_STS_DIRTY;
|
---|
1420 | }
|
---|
1421 |
|
---|
1422 | /* Update last updated timestamp. */
|
---|
1423 | pSink->tsLastUpdatedMs = RTTimeMilliTS();
|
---|
1424 |
|
---|
1425 | return VINF_SUCCESS;
|
---|
1426 | }
|
---|
1427 |
|
---|
1428 |
|
---|
1429 | /**
|
---|
1430 | * Helper for audioMixerSinkUpdateOutput that determins now many frames it
|
---|
1431 | * can transfer from the sink's mixer buffer and to the drivers.
|
---|
1432 | *
|
---|
1433 | * This also updates the mixer stream status, which may involve stream re-inits.
|
---|
1434 | *
|
---|
1435 | * @returns Number of frames.
|
---|
1436 | * @param pSink The sink.
|
---|
1437 | * @param pcWritableStreams Where to return the number of writable streams.
|
---|
1438 | */
|
---|
1439 | static uint32_t audioMixerSinkUpdateOutputCalcFramesToRead(PAUDMIXSINK pSink, uint32_t *pcWritableStreams)
|
---|
1440 | {
|
---|
1441 | uint32_t cFramesToRead = AudioMixBufUsed(&pSink->MixBuf); /* (to read from the mixing buffer) */
|
---|
1442 | uint32_t cWritableStreams = 0;
|
---|
1443 | PAUDMIXSTREAM pMixStream;
|
---|
1444 | RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
|
---|
1445 | {
|
---|
1446 | #if 0 /** @todo this conceptually makes sense, but may mess up the pending-disable logic ... */
|
---|
1447 | if (pMixStream->fStatus & AUDMIXSTREAM_STATUS_ENABLED)
|
---|
1448 | pConn->pfnStreamIterate(pConn, pStream);
|
---|
1449 | #endif
|
---|
1450 |
|
---|
1451 | int rc2 = audioMixerStreamUpdateStatus(pMixStream);
|
---|
1452 | AssertRC(rc2);
|
---|
1453 |
|
---|
1454 | if (pMixStream->fStatus & AUDMIXSTREAM_STATUS_CAN_WRITE)
|
---|
1455 | {
|
---|
1456 | uint32_t const cbWritable = pMixStream->pConn->pfnStreamGetWritable(pMixStream->pConn, pMixStream->pStream);
|
---|
1457 | uint32_t cFrames = PDMAudioPropsBytesToFrames(&pMixStream->pStream->Cfg.Props, cbWritable);
|
---|
1458 | pMixStream->cFramesLastAvail = cFrames;
|
---|
1459 | if (PDMAudioPropsHz(&pMixStream->pStream->Cfg.Props) == PDMAudioPropsHz(&pSink->MixBuf.Props))
|
---|
1460 | { /* likely */ }
|
---|
1461 | else
|
---|
1462 | {
|
---|
1463 | cFrames = cFrames * PDMAudioPropsHz(&pSink->MixBuf.Props) / PDMAudioPropsHz(&pMixStream->pStream->Cfg.Props);
|
---|
1464 | cFrames = cFrames > 2 ? cFrames - 2 : 0; /* rounding safety fudge */
|
---|
1465 | }
|
---|
1466 | if (cFramesToRead > cFrames && !pMixStream->fUnreliable)
|
---|
1467 | {
|
---|
1468 | Log4Func(("%s: cFramesToRead %u -> %u; %s (%u bytes writable)\n",
|
---|
1469 | pSink->pszName, cFramesToRead, cFrames, pMixStream->pszName, cbWritable));
|
---|
1470 | cFramesToRead = cFrames;
|
---|
1471 | }
|
---|
1472 | cWritableStreams++;
|
---|
1473 | }
|
---|
1474 | }
|
---|
1475 |
|
---|
1476 | *pcWritableStreams = cWritableStreams;
|
---|
1477 | return cFramesToRead;
|
---|
1478 | }
|
---|
1479 |
|
---|
1480 |
|
---|
1481 | /**
|
---|
1482 | * Updates an output mixer sink.
|
---|
1483 | *
|
---|
1484 | * @returns VBox status code.
|
---|
1485 | * @param pSink Mixer sink to update.
|
---|
1486 | */
|
---|
1487 | static int audioMixerSinkUpdateOutput(PAUDMIXSINK pSink)
|
---|
1488 | {
|
---|
1489 | PAUDMIXSTREAM pMixStream;
|
---|
1490 | Assert(!(pSink->fStatus & AUDMIXSINK_STS_DRAINED_MIXBUF) || AudioMixBufUsed(&pSink->MixBuf) == 0);
|
---|
1491 |
|
---|
1492 | /*
|
---|
1493 | * Update each mixing sink stream's status and check how much we can
|
---|
1494 | * write into them.
|
---|
1495 | *
|
---|
1496 | * We're currently using the minimum size of all streams, however this
|
---|
1497 | * isn't a smart approach as it means one disfunctional stream can block
|
---|
1498 | * working ones. So, if we end up with zero frames and a full mixer
|
---|
1499 | * buffer we'll disregard the stream that accept the smallest amount and
|
---|
1500 | * try again.
|
---|
1501 | */
|
---|
1502 | uint32_t cWritableStreams = 0;
|
---|
1503 | uint32_t cFramesToRead = audioMixerSinkUpdateOutputCalcFramesToRead(pSink, &cWritableStreams);
|
---|
1504 | if ( cFramesToRead != 0
|
---|
1505 | || cWritableStreams <= 1
|
---|
1506 | || AudioMixBufFree(&pSink->MixBuf) > 2)
|
---|
1507 | Log3Func(("%s: cLiveFrames=%#x cFramesToRead=%#x cWritableStreams=%#x\n", pSink->pszName,
|
---|
1508 | AudioMixBufUsed(&pSink->MixBuf), cFramesToRead, cWritableStreams));
|
---|
1509 | else
|
---|
1510 | {
|
---|
1511 | Log3Func(("%s: MixBuf is full but one or more streams only want zero frames. Try disregarding those...\n", pSink->pszName));
|
---|
1512 | uint32_t cReliableStreams = 0;
|
---|
1513 | uint32_t cMarkedUnreliable = 0;
|
---|
1514 | PAUDMIXSTREAM pMixStreamMin = NULL;
|
---|
1515 | RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
|
---|
1516 | {
|
---|
1517 | if (pMixStream->fStatus & AUDMIXSTREAM_STATUS_CAN_WRITE)
|
---|
1518 | {
|
---|
1519 | if (!pMixStream->fUnreliable)
|
---|
1520 | {
|
---|
1521 | if (pMixStream->cFramesLastAvail == 0)
|
---|
1522 | {
|
---|
1523 | cMarkedUnreliable++;
|
---|
1524 | pMixStream->fUnreliable = true;
|
---|
1525 | Log3Func(("%s: Marked '%s' as unreliable.\n", pSink->pszName, pMixStream->pszName));
|
---|
1526 | pMixStreamMin = pMixStream;
|
---|
1527 | }
|
---|
1528 | else
|
---|
1529 | {
|
---|
1530 | if (!pMixStreamMin || pMixStream->cFramesLastAvail < pMixStreamMin->cFramesLastAvail)
|
---|
1531 | pMixStreamMin = pMixStream;
|
---|
1532 | cReliableStreams++;
|
---|
1533 | }
|
---|
1534 | }
|
---|
1535 | }
|
---|
1536 | }
|
---|
1537 |
|
---|
1538 | if (cMarkedUnreliable == 0 && cReliableStreams > 1 && pMixStreamMin != NULL)
|
---|
1539 | {
|
---|
1540 | cReliableStreams--;
|
---|
1541 | cMarkedUnreliable++;
|
---|
1542 | pMixStreamMin->fUnreliable = true;
|
---|
1543 | Log3Func(("%s: Marked '%s' as unreliable (%u frames).\n",
|
---|
1544 | pSink->pszName, pMixStreamMin->pszName, pMixStreamMin->cFramesLastAvail));
|
---|
1545 | }
|
---|
1546 |
|
---|
1547 | if (cMarkedUnreliable > 0)
|
---|
1548 | {
|
---|
1549 | cWritableStreams = 0;
|
---|
1550 | cFramesToRead = audioMixerSinkUpdateOutputCalcFramesToRead(pSink, &cWritableStreams);
|
---|
1551 | }
|
---|
1552 |
|
---|
1553 | Log3Func(("%s: cLiveFrames=%#x cFramesToRead=%#x cWritableStreams=%#x cMarkedUnreliable=%#x cReliableStreams=%#x\n",
|
---|
1554 | pSink->pszName, AudioMixBufUsed(&pSink->MixBuf), cFramesToRead,
|
---|
1555 | cWritableStreams, cMarkedUnreliable, cReliableStreams));
|
---|
1556 | }
|
---|
1557 |
|
---|
1558 | if (cWritableStreams > 0)
|
---|
1559 | {
|
---|
1560 | if (cFramesToRead > 0)
|
---|
1561 | {
|
---|
1562 | /*
|
---|
1563 | * For each of the enabled streams, convert cFramesToRead frames from
|
---|
1564 | * the mixing buffer and write that to the downstream driver.
|
---|
1565 | */
|
---|
1566 | RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
|
---|
1567 | {
|
---|
1568 | if (pMixStream->fStatus & AUDMIXSTREAM_STATUS_CAN_WRITE)
|
---|
1569 | {
|
---|
1570 | uint32_t offSrcFrame = 0;
|
---|
1571 | do
|
---|
1572 | {
|
---|
1573 | /* Convert a chunk from the mixer buffer. */
|
---|
1574 | /*#define ELECTRIC_PEEK_BUFFER*/ /* if buffer code is misbehaving, enable this to catch overflows. */
|
---|
1575 | #ifndef ELECTRIC_PEEK_BUFFER
|
---|
1576 | union
|
---|
1577 | {
|
---|
1578 | uint8_t ab[8192];
|
---|
1579 | uint64_t au64[8192 / sizeof(uint64_t)]; /* Use uint64_t to ensure good alignment. */
|
---|
1580 | } Buf;
|
---|
1581 | void * const pvBuf = &Buf;
|
---|
1582 | uint32_t const cbBuf = sizeof(Buf);
|
---|
1583 | #else
|
---|
1584 | uint32_t const cbBuf = 0x2000 - 16;
|
---|
1585 | void * const pvBuf = RTMemEfAlloc(cbBuf, RTMEM_TAG, RT_SRC_POS);
|
---|
1586 | #endif
|
---|
1587 | uint32_t cbDstPeeked = cbBuf;
|
---|
1588 | uint32_t cSrcFramesPeeked = cFramesToRead - offSrcFrame;
|
---|
1589 | AudioMixBufPeek(&pSink->MixBuf, offSrcFrame, cSrcFramesPeeked, &cSrcFramesPeeked,
|
---|
1590 | &pMixStream->PeekState, pvBuf, cbBuf, &cbDstPeeked);
|
---|
1591 | offSrcFrame += cSrcFramesPeeked;
|
---|
1592 |
|
---|
1593 | /* Write it to the backend. Since've checked that there is buffer
|
---|
1594 | space available, this should always write the whole buffer unless
|
---|
1595 | it's an unreliable stream. */
|
---|
1596 | uint32_t cbDstWritten = 0;
|
---|
1597 | int rc2 = pMixStream->pConn->pfnStreamPlay(pMixStream->pConn, pMixStream->pStream,
|
---|
1598 | pvBuf, cbDstPeeked, &cbDstWritten);
|
---|
1599 | Log3Func(("%s: %#x L %#x => %#x bytes; wrote %#x rc2=%Rrc %s\n", pSink->pszName, offSrcFrame,
|
---|
1600 | cSrcFramesPeeked - cSrcFramesPeeked, cbDstPeeked, cbDstWritten, rc2, pMixStream->pszName));
|
---|
1601 | #ifdef ELECTRIC_PEEK_BUFFER
|
---|
1602 | RTMemEfFree(pvBuf, RT_SRC_POS);
|
---|
1603 | #endif
|
---|
1604 | if (RT_SUCCESS(rc2))
|
---|
1605 | AssertLogRelMsg(cbDstWritten == cbDstPeeked || pMixStream->fUnreliable,
|
---|
1606 | ("cbDstWritten=%#x cbDstPeeked=%#x - (sink '%s')\n",
|
---|
1607 | cbDstWritten, cbDstPeeked, pSink->pszName));
|
---|
1608 | else if (rc2 == VERR_AUDIO_STREAM_NOT_READY)
|
---|
1609 | {
|
---|
1610 | LogRel2(("Audio Mixer: '%s' (sink '%s'): Stream not ready - skipping.\n",
|
---|
1611 | pMixStream->pszName, pSink->pszName));
|
---|
1612 | break; /* must've changed status, stop processing */
|
---|
1613 | }
|
---|
1614 | else
|
---|
1615 | {
|
---|
1616 | Assert(rc2 != VERR_BUFFER_OVERFLOW);
|
---|
1617 | LogRel2(("Audio Mixer: Writing to mixer stream '%s' (sink '%s') failed, rc=%Rrc\n",
|
---|
1618 | pMixStream->pszName, pSink->pszName, rc2));
|
---|
1619 | break;
|
---|
1620 | }
|
---|
1621 | } while (offSrcFrame < cFramesToRead);
|
---|
1622 | }
|
---|
1623 | }
|
---|
1624 |
|
---|
1625 | AudioMixBufAdvance(&pSink->MixBuf, cFramesToRead);
|
---|
1626 | }
|
---|
1627 |
|
---|
1628 | /*
|
---|
1629 | * Update the dirty flag for what it's worth.
|
---|
1630 | */
|
---|
1631 | if (AudioMixBufUsed(&pSink->MixBuf) > 0)
|
---|
1632 | pSink->fStatus |= AUDMIXSINK_STS_DIRTY;
|
---|
1633 | else
|
---|
1634 | pSink->fStatus &= ~AUDMIXSINK_STS_DIRTY;
|
---|
1635 | }
|
---|
1636 | else
|
---|
1637 | {
|
---|
1638 | /*
|
---|
1639 | * If no writable streams, just drop the mixer buffer content.
|
---|
1640 | */
|
---|
1641 | AudioMixBufDrop(&pSink->MixBuf);
|
---|
1642 | pSink->fStatus &= ~AUDMIXSINK_STS_DIRTY;
|
---|
1643 | }
|
---|
1644 |
|
---|
1645 | /*
|
---|
1646 | * Iterate buffers.
|
---|
1647 | */
|
---|
1648 | RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
|
---|
1649 | {
|
---|
1650 | if (pMixStream->fStatus & AUDMIXSTREAM_STATUS_ENABLED)
|
---|
1651 | pMixStream->pConn->pfnStreamIterate(pMixStream->pConn, pMixStream->pStream);
|
---|
1652 | }
|
---|
1653 |
|
---|
1654 | /* Update last updated timestamp. */
|
---|
1655 | uint64_t const nsNow = RTTimeNanoTS();
|
---|
1656 | pSink->tsLastUpdatedMs = nsNow / RT_NS_1MS;
|
---|
1657 |
|
---|
1658 | /*
|
---|
1659 | * Deal with pending disable.
|
---|
1660 | * We reset the sink when all streams have been disabled.
|
---|
1661 | */
|
---|
1662 | if (!(pSink->fStatus & AUDMIXSINK_STS_DRAINING))
|
---|
1663 | { /* likely, till we get to the end */ }
|
---|
1664 | else if (nsNow <= pSink->nsDrainDeadline)
|
---|
1665 | {
|
---|
1666 | /* Have we drained the mixbuf now? If so, update status and send drain
|
---|
1667 | command to streams. (As mentioned elsewhere we don't want to confuse
|
---|
1668 | driver code by sending drain command while there is still data to write.) */
|
---|
1669 | Assert((pSink->fStatus & AUDMIXSINK_STS_DIRTY) == (AudioMixBufUsed(&pSink->MixBuf) > 0 ? AUDMIXSINK_STS_DIRTY : 0));
|
---|
1670 | if ((pSink->fStatus & (AUDMIXSINK_STS_DRAINED_MIXBUF | AUDMIXSINK_STS_DIRTY)) == 0)
|
---|
1671 | {
|
---|
1672 | LogFunc(("Sink '%s': Setting AUDMIXSINK_STS_DRAINED_MIXBUF and sending drain command to streams (after %RU64 ns).\n",
|
---|
1673 | pSink->pszName, nsNow - pSink->nsDrainStarted));
|
---|
1674 | pSink->fStatus |= AUDMIXSINK_STS_DRAINED_MIXBUF;
|
---|
1675 |
|
---|
1676 | RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
|
---|
1677 | {
|
---|
1678 | pMixStream->pConn->pfnStreamControl(pMixStream->pConn, pMixStream->pStream, PDMAUDIOSTREAMCMD_DRAIN);
|
---|
1679 | }
|
---|
1680 | }
|
---|
1681 |
|
---|
1682 | /* Check if all streams has stopped, and if so we stop the sink. */
|
---|
1683 | uint32_t const cStreams = pSink->cStreams;
|
---|
1684 | uint32_t cStreamsDisabled = pSink->cStreams;
|
---|
1685 | RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
|
---|
1686 | {
|
---|
1687 | if (pMixStream->fStatus & AUDMIXSTREAM_STATUS_ENABLED)
|
---|
1688 | {
|
---|
1689 | PDMAUDIOSTREAMSTATE const enmState = pMixStream->pConn->pfnStreamGetState(pMixStream->pConn, pMixStream->pStream);
|
---|
1690 | if (enmState >= PDMAUDIOSTREAMSTATE_ENABLED)
|
---|
1691 | cStreamsDisabled--;
|
---|
1692 | }
|
---|
1693 | }
|
---|
1694 |
|
---|
1695 | if (cStreamsDisabled != cStreams)
|
---|
1696 | Log3Func(("Sink '%s': %u out of %u streams disabled (after %RU64 ns).\n",
|
---|
1697 | pSink->pszName, cStreamsDisabled, cStreams, nsNow - pSink->nsDrainStarted));
|
---|
1698 | else
|
---|
1699 | {
|
---|
1700 | LogFunc(("Sink '%s': All %u streams disabled. Drain done after %RU64 ns.\n",
|
---|
1701 | pSink->pszName, cStreamsDisabled, nsNow - pSink->nsDrainStarted));
|
---|
1702 | audioMixerSinkResetInternal(pSink); /* clears the status */
|
---|
1703 | }
|
---|
1704 | }
|
---|
1705 | else
|
---|
1706 | {
|
---|
1707 | /* Draining timed out. Just do an instant stop. */
|
---|
1708 | LogFunc(("Sink '%s': pending disable timed out after %RU64 ns!\n", pSink->pszName, nsNow - pSink->nsDrainStarted));
|
---|
1709 | RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
|
---|
1710 | {
|
---|
1711 | pMixStream->pConn->pfnStreamControl(pMixStream->pConn, pMixStream->pStream, PDMAUDIOSTREAMCMD_DISABLE);
|
---|
1712 | }
|
---|
1713 | audioMixerSinkResetInternal(pSink); /* clears the status */
|
---|
1714 | }
|
---|
1715 |
|
---|
1716 | return VINF_SUCCESS;
|
---|
1717 | }
|
---|
1718 |
|
---|
1719 | /**
|
---|
1720 | * Updates (invalidates) a mixer sink.
|
---|
1721 | *
|
---|
1722 | * @returns VBox status code.
|
---|
1723 | * @param pSink Mixer sink to update.
|
---|
1724 | * @param cbDmaUsed The DMA buffer fill for input stream, ignored for
|
---|
1725 | * output sinks.
|
---|
1726 | * @param cbDmaPeriod The DMA period in bytes for input stream, ignored
|
---|
1727 | * for output sinks.
|
---|
1728 | */
|
---|
1729 | int AudioMixerSinkUpdate(PAUDMIXSINK pSink, uint32_t cbDmaUsed, uint32_t cbDmaPeriod)
|
---|
1730 | {
|
---|
1731 | AssertPtrReturn(pSink, VERR_INVALID_POINTER);
|
---|
1732 | Assert(pSink->uMagic == AUDMIXSINK_MAGIC);
|
---|
1733 | int rc = RTCritSectEnter(&pSink->CritSect);
|
---|
1734 | AssertRCReturn(rc, rc);
|
---|
1735 |
|
---|
1736 | #ifdef LOG_ENABLED
|
---|
1737 | char szStatus[AUDIOMIXERSINK_STATUS_STR_MAX];
|
---|
1738 | #endif
|
---|
1739 | Log3Func(("[%s] fStatus=%s\n", pSink->pszName, dbgAudioMixerSinkStatusToStr(pSink->fStatus, szStatus)));
|
---|
1740 |
|
---|
1741 | /* Only process running sinks. */
|
---|
1742 | if (pSink->fStatus & AUDMIXSINK_STS_RUNNING)
|
---|
1743 | {
|
---|
1744 | /* Do separate processing for input and output sinks. */
|
---|
1745 | if (pSink->enmDir == PDMAUDIODIR_OUT)
|
---|
1746 | rc = audioMixerSinkUpdateOutput(pSink);
|
---|
1747 | else if (pSink->enmDir == PDMAUDIODIR_IN)
|
---|
1748 | rc = audioMixerSinkUpdateInput(pSink, cbDmaUsed, cbDmaPeriod);
|
---|
1749 | else
|
---|
1750 | AssertFailedStmt(rc = VERR_INTERNAL_ERROR_3);
|
---|
1751 | }
|
---|
1752 | else
|
---|
1753 | rc = VINF_SUCCESS; /* disabled */
|
---|
1754 |
|
---|
1755 | RTCritSectLeave(&pSink->CritSect);
|
---|
1756 | return rc;
|
---|
1757 | }
|
---|
1758 |
|
---|
1759 |
|
---|
1760 | /**
|
---|
1761 | * @callback_method_impl{FNRTTHREAD, Audio Mixer Sink asynchronous I/O thread}
|
---|
1762 | */
|
---|
1763 | static DECLCALLBACK(int) audioMixerSinkAsyncIoThread(RTTHREAD hThreadSelf, void *pvUser)
|
---|
1764 | {
|
---|
1765 | PAUDMIXSINK pSink = (PAUDMIXSINK)pvUser;
|
---|
1766 | AssertPtr(pSink);
|
---|
1767 | Assert(pSink->uMagic == AUDMIXSINK_MAGIC);
|
---|
1768 | RT_NOREF(hThreadSelf);
|
---|
1769 |
|
---|
1770 | /*
|
---|
1771 | * The run loop.
|
---|
1772 | */
|
---|
1773 | LogFlowFunc(("%s: Entering run loop...\n", pSink->pszName));
|
---|
1774 | while (!pSink->AIO.fShutdown)
|
---|
1775 | {
|
---|
1776 | RTMSINTERVAL cMsSleep = RT_INDEFINITE_WAIT;
|
---|
1777 |
|
---|
1778 | RTCritSectEnter(&pSink->CritSect);
|
---|
1779 | if (pSink->fStatus & (AUDMIXSINK_STS_RUNNING | AUDMIXSINK_STS_DRAINING))
|
---|
1780 | {
|
---|
1781 | /*
|
---|
1782 | * Before doing jobs, always update input sinks.
|
---|
1783 | */
|
---|
1784 | if (pSink->enmDir == PDMAUDIODIR_IN)
|
---|
1785 | audioMixerSinkUpdateInput(pSink, 0 /*cbDmaUsed*/, 0 /*cbDmaPeriod*/);
|
---|
1786 |
|
---|
1787 | /*
|
---|
1788 | * Do the device specific updating.
|
---|
1789 | */
|
---|
1790 | uintptr_t const cUpdateJobs = RT_MIN(pSink->AIO.cUpdateJobs, RT_ELEMENTS(pSink->AIO.aUpdateJobs));
|
---|
1791 | for (uintptr_t iJob = 0; iJob < cUpdateJobs; iJob++)
|
---|
1792 | pSink->AIO.aUpdateJobs[iJob].pfnUpdate(pSink->AIO.pDevIns, pSink, pSink->AIO.aUpdateJobs[iJob].pvUser);
|
---|
1793 |
|
---|
1794 | /*
|
---|
1795 | * Update output sinks after the updating.
|
---|
1796 | */
|
---|
1797 | if (pSink->enmDir == PDMAUDIODIR_OUT)
|
---|
1798 | audioMixerSinkUpdateOutput(pSink);
|
---|
1799 |
|
---|
1800 | /*
|
---|
1801 | * If we're in draining mode, we use the smallest typical interval of the
|
---|
1802 | * jobs for the next wait as we're unlikly to be woken up again by any
|
---|
1803 | * DMA timer as it has normally stopped running at this point.
|
---|
1804 | */
|
---|
1805 | if (!(pSink->fStatus & AUDMIXSINK_STS_DRAINING))
|
---|
1806 | { /* likely */ }
|
---|
1807 | else
|
---|
1808 | {
|
---|
1809 | /** @todo Also do some kind of timeout here and do a forced stream disable w/o
|
---|
1810 | * any draining if we exceed it. */
|
---|
1811 | cMsSleep = pSink->AIO.cMsMinTypicalInterval;
|
---|
1812 | }
|
---|
1813 |
|
---|
1814 | }
|
---|
1815 | RTCritSectLeave(&pSink->CritSect);
|
---|
1816 |
|
---|
1817 | /*
|
---|
1818 | * Now block till we're signalled or
|
---|
1819 | */
|
---|
1820 | if (!pSink->AIO.fShutdown)
|
---|
1821 | {
|
---|
1822 | int rc = RTSemEventWait(pSink->AIO.hEvent, cMsSleep);
|
---|
1823 | AssertLogRelMsgReturn(RT_SUCCESS(rc) || rc == VERR_TIMEOUT, ("%s: RTSemEventWait -> %Rrc\n", pSink->pszName, rc), rc);
|
---|
1824 | }
|
---|
1825 | }
|
---|
1826 |
|
---|
1827 | LogFlowFunc(("%s: returnining normally.\n", pSink->pszName));
|
---|
1828 | return VINF_SUCCESS;
|
---|
1829 | }
|
---|
1830 |
|
---|
1831 |
|
---|
1832 | /**
|
---|
1833 | * Adds an AIO update job to the sink.
|
---|
1834 | *
|
---|
1835 | * @returns VBox status code.
|
---|
1836 | * @retval VERR_ALREADY_EXISTS if already registered job with same @a pvUser
|
---|
1837 | * and @a pfnUpdate.
|
---|
1838 | *
|
---|
1839 | * @param pSink The mixer sink to remove the AIO job from.
|
---|
1840 | * @param pfnUpdate The update callback for the job.
|
---|
1841 | * @param pvUser The user parameter to pass to @a pfnUpdate. This should
|
---|
1842 | * identify the job unique together with @a pfnUpdate.
|
---|
1843 | * @param cMsTypicalInterval A typical interval between jobs in milliseconds.
|
---|
1844 | * This is used when draining.
|
---|
1845 | */
|
---|
1846 | int AudioMixerSinkAddUpdateJob(PAUDMIXSINK pSink, PFNAUDMIXSINKUPDATE pfnUpdate, void *pvUser, uint32_t cMsTypicalInterval)
|
---|
1847 | {
|
---|
1848 | AssertPtrReturn(pSink, VERR_INVALID_POINTER);
|
---|
1849 | Assert(pSink->uMagic == AUDMIXSINK_MAGIC);
|
---|
1850 | int rc = RTCritSectEnter(&pSink->CritSect);
|
---|
1851 | AssertRCReturn(rc, rc);
|
---|
1852 |
|
---|
1853 | /*
|
---|
1854 | * Check that the job hasn't already been added.
|
---|
1855 | */
|
---|
1856 | uintptr_t const iEnd = pSink->AIO.cUpdateJobs;
|
---|
1857 | for (uintptr_t i = 0; i < iEnd; i++)
|
---|
1858 | AssertReturnStmt( pvUser != pSink->AIO.aUpdateJobs[i].pvUser
|
---|
1859 | || pfnUpdate != pSink->AIO.aUpdateJobs[i].pfnUpdate,
|
---|
1860 | RTCritSectLeave(&pSink->CritSect),
|
---|
1861 | VERR_ALREADY_EXISTS);
|
---|
1862 |
|
---|
1863 | AssertReturnStmt(iEnd < RT_ELEMENTS(pSink->AIO.aUpdateJobs),
|
---|
1864 | RTCritSectLeave(&pSink->CritSect),
|
---|
1865 | VERR_ALREADY_EXISTS);
|
---|
1866 |
|
---|
1867 | /*
|
---|
1868 | * Create the thread if not already running or if it stopped.
|
---|
1869 | */
|
---|
1870 | /** @todo move this to the sink "enable" code */
|
---|
1871 | if (pSink->AIO.hThread != NIL_RTTHREAD)
|
---|
1872 | {
|
---|
1873 | int rcThread = VINF_SUCCESS;
|
---|
1874 | rc = RTThreadWait(pSink->AIO.hThread, 0, &rcThread);
|
---|
1875 | if (RT_FAILURE_NP(rc))
|
---|
1876 | { /* likely */ }
|
---|
1877 | else
|
---|
1878 | {
|
---|
1879 | LogRel(("Audio: AIO thread for '%s' died? rcThread=%Rrc\n", pSink->pszName, rcThread));
|
---|
1880 | pSink->AIO.hThread = NIL_RTTHREAD;
|
---|
1881 | }
|
---|
1882 | }
|
---|
1883 | if (pSink->AIO.hThread == NIL_RTTHREAD)
|
---|
1884 | {
|
---|
1885 | LogFlowFunc(("%s: Starting AIO thread...\n", pSink->pszName));
|
---|
1886 | if (pSink->AIO.hEvent == NIL_RTSEMEVENT)
|
---|
1887 | {
|
---|
1888 | rc = RTSemEventCreate(&pSink->AIO.hEvent);
|
---|
1889 | AssertRCReturnStmt(rc, RTCritSectLeave(&pSink->CritSect), rc);
|
---|
1890 | }
|
---|
1891 | static uint32_t volatile s_idxThread = 0;
|
---|
1892 | uint32_t idxThread = ASMAtomicIncU32(&s_idxThread);
|
---|
1893 | rc = RTThreadCreateF(&pSink->AIO.hThread, audioMixerSinkAsyncIoThread, pSink, 0 /*cbStack*/, RTTHREADTYPE_IO,
|
---|
1894 | RTTHREADFLAGS_WAITABLE | RTTHREADFLAGS_COM_MTA, "MixAIO-%u", idxThread);
|
---|
1895 | AssertRCReturnStmt(rc, RTCritSectLeave(&pSink->CritSect), rc);
|
---|
1896 | }
|
---|
1897 |
|
---|
1898 | /*
|
---|
1899 | * Finally, actually add the job.
|
---|
1900 | */
|
---|
1901 | pSink->AIO.aUpdateJobs[iEnd].pfnUpdate = pfnUpdate;
|
---|
1902 | pSink->AIO.aUpdateJobs[iEnd].pvUser = pvUser;
|
---|
1903 | pSink->AIO.aUpdateJobs[iEnd].cMsTypicalInterval = cMsTypicalInterval;
|
---|
1904 | pSink->AIO.cUpdateJobs = (uint8_t)(iEnd + 1);
|
---|
1905 | if (cMsTypicalInterval < pSink->AIO.cMsMinTypicalInterval)
|
---|
1906 | pSink->AIO.cMsMinTypicalInterval = cMsTypicalInterval;
|
---|
1907 | LogFlowFunc(("%s: [#%zu]: Added pfnUpdate=%p pvUser=%p typically every %u ms (min %u ms)\n",
|
---|
1908 | pSink->pszName, iEnd, pfnUpdate, pvUser, cMsTypicalInterval, pSink->AIO.cMsMinTypicalInterval));
|
---|
1909 |
|
---|
1910 | RTCritSectLeave(&pSink->CritSect);
|
---|
1911 | return VINF_SUCCESS;
|
---|
1912 |
|
---|
1913 | }
|
---|
1914 |
|
---|
1915 |
|
---|
1916 | /**
|
---|
1917 | * Removes an update job previously registered via AudioMixerSinkAddUpdateJob().
|
---|
1918 | *
|
---|
1919 | * @returns VBox status code.
|
---|
1920 | * @retval VERR_NOT_FOUND if not found.
|
---|
1921 | *
|
---|
1922 | * @param pSink The mixer sink to remove the AIO job from.
|
---|
1923 | * @param pfnUpdate The update callback of the job.
|
---|
1924 | * @param pvUser The user parameter identifying the job.
|
---|
1925 | */
|
---|
1926 | int AudioMixerSinkRemoveUpdateJob(PAUDMIXSINK pSink, PFNAUDMIXSINKUPDATE pfnUpdate, void *pvUser)
|
---|
1927 | {
|
---|
1928 | AssertPtrReturn(pSink, VERR_INVALID_POINTER);
|
---|
1929 | Assert(pSink->uMagic == AUDMIXSINK_MAGIC);
|
---|
1930 | int rc = RTCritSectEnter(&pSink->CritSect);
|
---|
1931 | AssertRCReturn(rc, rc);
|
---|
1932 |
|
---|
1933 | rc = VERR_NOT_FOUND;
|
---|
1934 | for (uintptr_t iJob = 0; iJob < pSink->AIO.cUpdateJobs; iJob++)
|
---|
1935 | if ( pvUser == pSink->AIO.aUpdateJobs[iJob].pvUser
|
---|
1936 | && pfnUpdate == pSink->AIO.aUpdateJobs[iJob].pfnUpdate)
|
---|
1937 | {
|
---|
1938 | pSink->AIO.cUpdateJobs--;
|
---|
1939 | if (iJob != pSink->AIO.cUpdateJobs)
|
---|
1940 | memmove(&pSink->AIO.aUpdateJobs[iJob], &pSink->AIO.aUpdateJobs[iJob + 1],
|
---|
1941 | (pSink->AIO.cUpdateJobs - iJob) * sizeof(pSink->AIO.aUpdateJobs[0]));
|
---|
1942 | LogFlowFunc(("%s: [#%zu]: Removed pfnUpdate=%p pvUser=%p => cUpdateJobs=%u\n",
|
---|
1943 | pSink->pszName, iJob, pfnUpdate, pvUser, pSink->AIO.cUpdateJobs));
|
---|
1944 | rc = VINF_SUCCESS;
|
---|
1945 | break;
|
---|
1946 | }
|
---|
1947 | AssertRC(rc);
|
---|
1948 |
|
---|
1949 | /* Recalc the minimum sleep interval (do it always). */
|
---|
1950 | pSink->AIO.cMsMinTypicalInterval = RT_MS_1SEC / 2;
|
---|
1951 | for (uintptr_t iJob = 0; iJob < pSink->AIO.cUpdateJobs; iJob++)
|
---|
1952 | if (pSink->AIO.aUpdateJobs[iJob].cMsTypicalInterval < pSink->AIO.cMsMinTypicalInterval)
|
---|
1953 | pSink->AIO.cMsMinTypicalInterval = pSink->AIO.aUpdateJobs[iJob].cMsTypicalInterval;
|
---|
1954 |
|
---|
1955 |
|
---|
1956 | RTCritSectLeave(&pSink->CritSect);
|
---|
1957 | return rc;
|
---|
1958 | }
|
---|
1959 |
|
---|
1960 |
|
---|
1961 | /**
|
---|
1962 | * Writes data to a mixer output sink.
|
---|
1963 | *
|
---|
1964 | * @param pSink The sink to write data to.
|
---|
1965 | * @param pvBuf Buffer containing the audio data to write.
|
---|
1966 | * @param cbBuf How many bytes to write.
|
---|
1967 | * @param pcbWritten Number of bytes written.
|
---|
1968 | *
|
---|
1969 | * @todo merge with caller.
|
---|
1970 | */
|
---|
1971 | static void audioMixerSinkWrite(PAUDMIXSINK pSink, const void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten)
|
---|
1972 | {
|
---|
1973 | uint32_t cFrames = AudioMixBufFree(&pSink->MixBuf);
|
---|
1974 | uint32_t cbToWrite = PDMAudioPropsFramesToBytes(&pSink->PCMProps, cFrames);
|
---|
1975 | cbToWrite = RT_MIN(cbToWrite, cbBuf);
|
---|
1976 | AudioMixBufWrite(&pSink->MixBuf, &pSink->Out.State, pvBuf, cbToWrite, 0 /*offDstFrame*/, cFrames, &cFrames);
|
---|
1977 | Assert(cbToWrite == PDMAudioPropsFramesToBytes(&pSink->PCMProps, cFrames));
|
---|
1978 | AudioMixBufCommit(&pSink->MixBuf, cFrames);
|
---|
1979 | *pcbWritten = cbToWrite;
|
---|
1980 |
|
---|
1981 | /* Update the sink's last written time stamp. */
|
---|
1982 | pSink->tsLastReadWrittenNs = RTTimeNanoTS();
|
---|
1983 |
|
---|
1984 | Log3Func(("[%s] cbBuf=%#x -> cbWritten=%#x\n", pSink->pszName, cbBuf, cbToWrite));
|
---|
1985 | }
|
---|
1986 |
|
---|
1987 |
|
---|
1988 | /**
|
---|
1989 | * Transfer data from the device's DMA buffer and into the sink.
|
---|
1990 | *
|
---|
1991 | * The caller is already holding the mixer sink's critical section, either by
|
---|
1992 | * way of being the AIO thread doing update jobs or by explicit locking calls.
|
---|
1993 | *
|
---|
1994 | * @returns The new stream offset.
|
---|
1995 | * @param pSink The mixer sink to transfer samples to.
|
---|
1996 | * @param pCircBuf The internal DMA buffer to move samples from.
|
---|
1997 | * @param offStream The stream current offset (logging, dtrace, return).
|
---|
1998 | * @param idStream Device specific audio stream identifier (logging, dtrace).
|
---|
1999 | * @param pDbgFile Debug file, NULL if disabled.
|
---|
2000 | */
|
---|
2001 | uint64_t AudioMixerSinkTransferFromCircBuf(PAUDMIXSINK pSink, PRTCIRCBUF pCircBuf, uint64_t offStream,
|
---|
2002 | uint32_t idStream, PAUDIOHLPFILE pDbgFile)
|
---|
2003 | {
|
---|
2004 | /*
|
---|
2005 | * Sanity.
|
---|
2006 | */
|
---|
2007 | AssertReturn(pSink, offStream);
|
---|
2008 | Assert(pSink->uMagic == AUDMIXSINK_MAGIC);
|
---|
2009 | AssertReturn(pCircBuf, offStream);
|
---|
2010 | Assert(RTCritSectIsOwner(&pSink->CritSect));
|
---|
2011 | Assert(pSink->enmDir == PDMAUDIODIR_OUT);
|
---|
2012 | RT_NOREF(idStream);
|
---|
2013 |
|
---|
2014 | int rc = RTCritSectEnter(&pSink->CritSect);
|
---|
2015 | AssertRCReturn(rc, offStream);
|
---|
2016 |
|
---|
2017 | /*
|
---|
2018 | * Figure how much that we can push down.
|
---|
2019 | */
|
---|
2020 | uint32_t const cbSinkWritable = AudioMixerSinkGetWritable(pSink);
|
---|
2021 | uint32_t const cbCircBufReadable = (uint32_t)RTCircBufUsed(pCircBuf);
|
---|
2022 | uint32_t cbToTransfer = RT_MIN(cbCircBufReadable, cbSinkWritable);
|
---|
2023 | /* Make sure that we always align the number of bytes when reading to the stream's PCM properties. */
|
---|
2024 | uint32_t const cbToTransfer2 = cbToTransfer = PDMAudioPropsFloorBytesToFrame(&pSink->PCMProps, cbToTransfer);
|
---|
2025 |
|
---|
2026 | Log3Func(("idStream=%u: cbSinkWritable=%#RX32 cbCircBufReadable=%#RX32 -> cbToTransfer=%#RX32 @%#RX64\n",
|
---|
2027 | idStream, cbSinkWritable, cbCircBufReadable, cbToTransfer, offStream));
|
---|
2028 | /* Note: There now can be more data in the DMA buffer than initially announced. See @bugref{10354}. */
|
---|
2029 | AssertMsg(!(pSink->fStatus & AUDMIXSINK_STS_DRAINING) || cbCircBufReadable >= pSink->cbDmaLeftToDrain,
|
---|
2030 | ("cbCircBufReadable=%#x cbDmaLeftToDrain=%#x\n", cbCircBufReadable, pSink->cbDmaLeftToDrain));
|
---|
2031 |
|
---|
2032 | /*
|
---|
2033 | * Do the pushing.
|
---|
2034 | */
|
---|
2035 | while (cbToTransfer > 0)
|
---|
2036 | {
|
---|
2037 | void /*const*/ *pvSrcBuf;
|
---|
2038 | size_t cbSrcBuf;
|
---|
2039 | RTCircBufAcquireReadBlock(pCircBuf, cbToTransfer, &pvSrcBuf, &cbSrcBuf);
|
---|
2040 |
|
---|
2041 | uint32_t cbWritten = 0;
|
---|
2042 | audioMixerSinkWrite(pSink, pvSrcBuf, (uint32_t)cbSrcBuf, &cbWritten);
|
---|
2043 | Assert(cbWritten <= cbSrcBuf);
|
---|
2044 |
|
---|
2045 | Log2Func(("idStream=%u: %#RX32/%#zx bytes read @%#RX64\n", idStream, cbWritten, cbSrcBuf, offStream));
|
---|
2046 | #ifdef VBOX_WITH_DTRACE
|
---|
2047 | VBOXDD_AUDIO_MIXER_SINK_AIO_OUT(idStream, cbWritten, offStream);
|
---|
2048 | #endif
|
---|
2049 | offStream += cbWritten;
|
---|
2050 |
|
---|
2051 | if (!pDbgFile)
|
---|
2052 | { /* likely */ }
|
---|
2053 | else
|
---|
2054 | AudioHlpFileWrite(pDbgFile, pvSrcBuf, cbSrcBuf);
|
---|
2055 |
|
---|
2056 |
|
---|
2057 | RTCircBufReleaseReadBlock(pCircBuf, cbWritten);
|
---|
2058 |
|
---|
2059 | /* advance */
|
---|
2060 | cbToTransfer -= cbWritten;
|
---|
2061 | }
|
---|
2062 |
|
---|
2063 | /*
|
---|
2064 | * Advance drain status.
|
---|
2065 | */
|
---|
2066 | if (!(pSink->fStatus & AUDMIXSINK_STS_DRAINING))
|
---|
2067 | { /* likely for most of the playback time ... */ }
|
---|
2068 | else if (!(pSink->fStatus & AUDMIXSINK_STS_DRAINED_DMA))
|
---|
2069 | {
|
---|
2070 | if (cbToTransfer2 >= pSink->cbDmaLeftToDrain)
|
---|
2071 | {
|
---|
2072 | Assert(cbToTransfer2 == pSink->cbDmaLeftToDrain);
|
---|
2073 | Log3Func(("idStream=%u/'%s': Setting AUDMIXSINK_STS_DRAINED_DMA.\n", idStream, pSink->pszName));
|
---|
2074 | pSink->cbDmaLeftToDrain = 0;
|
---|
2075 | pSink->fStatus |= AUDMIXSINK_STS_DRAINED_DMA;
|
---|
2076 | }
|
---|
2077 | else
|
---|
2078 | {
|
---|
2079 | pSink->cbDmaLeftToDrain -= cbToTransfer2;
|
---|
2080 | Log3Func(("idStream=%u/'%s': still %#x bytes left in the DMA buffer\n",
|
---|
2081 | idStream, pSink->pszName, pSink->cbDmaLeftToDrain));
|
---|
2082 | }
|
---|
2083 | }
|
---|
2084 | else
|
---|
2085 | Assert(cbToTransfer2 == 0);
|
---|
2086 |
|
---|
2087 | Log3Func(("idStream=%u: cbCircBufUsed=%RX32 left\n", idStream, (uint32_t)RTCircBufUsed(pCircBuf)));
|
---|
2088 |
|
---|
2089 | RTCritSectLeave(&pSink->CritSect);
|
---|
2090 |
|
---|
2091 | LogFlowFuncLeave();
|
---|
2092 | return offStream;
|
---|
2093 | }
|
---|
2094 |
|
---|
2095 |
|
---|
2096 | /**
|
---|
2097 | * Transfer data to the device's DMA buffer from the sink.
|
---|
2098 | *
|
---|
2099 | * The caller is already holding the mixer sink's critical section, either by
|
---|
2100 | * way of being the AIO thread doing update jobs or by explicit locking calls.
|
---|
2101 | *
|
---|
2102 | * @returns The new stream offset.
|
---|
2103 | * @param pSink The mixer sink to transfer samples from.
|
---|
2104 | * @param pCircBuf The internal DMA buffer to move samples to.
|
---|
2105 | * @param offStream The stream current offset (logging, dtrace, return).
|
---|
2106 | * @param idStream Device specific audio stream identifier (logging, dtrace).
|
---|
2107 | * @param pDbgFile Debug file, NULL if disabled.
|
---|
2108 | */
|
---|
2109 | uint64_t AudioMixerSinkTransferToCircBuf(PAUDMIXSINK pSink, PRTCIRCBUF pCircBuf, uint64_t offStream,
|
---|
2110 | uint32_t idStream, PAUDIOHLPFILE pDbgFile)
|
---|
2111 | {
|
---|
2112 | /*
|
---|
2113 | * Sanity.
|
---|
2114 | */
|
---|
2115 | AssertReturn(pSink, offStream);
|
---|
2116 | Assert(pSink->uMagic == AUDMIXSINK_MAGIC);
|
---|
2117 | AssertReturn(pCircBuf, offStream);
|
---|
2118 | Assert(RTCritSectIsOwner(&pSink->CritSect));
|
---|
2119 |
|
---|
2120 | /*
|
---|
2121 | * Figure out how much we can transfer.
|
---|
2122 | */
|
---|
2123 | const uint32_t cbSinkReadable = AudioMixerSinkGetReadable(pSink);
|
---|
2124 | const uint32_t cbCircBufWritable = (uint32_t)RTCircBufFree(pCircBuf);
|
---|
2125 | uint32_t cbToTransfer = RT_MIN(cbCircBufWritable, cbSinkReadable);
|
---|
2126 | uint32_t cFramesToTransfer = PDMAudioPropsBytesToFrames(&pSink->PCMProps, cbToTransfer);
|
---|
2127 | cbToTransfer = PDMAudioPropsFramesToBytes(&pSink->PCMProps, cFramesToTransfer);
|
---|
2128 |
|
---|
2129 | Log3Func(("idStream=%u: cbSinkReadable=%#RX32 cbCircBufWritable=%#RX32 -> cbToTransfer=%#RX32 (%RU32 frames) @%#RX64\n",
|
---|
2130 | idStream, cbSinkReadable, cbCircBufWritable, cbToTransfer, cFramesToTransfer, offStream));
|
---|
2131 | RT_NOREF(idStream);
|
---|
2132 |
|
---|
2133 | /** @todo should we throttle (read less) this if we're far ahead? */
|
---|
2134 |
|
---|
2135 | /*
|
---|
2136 | * Copy loop.
|
---|
2137 | */
|
---|
2138 | while (cbToTransfer > 0)
|
---|
2139 | {
|
---|
2140 | /** @todo We should be able to read straight into the circular buffer here
|
---|
2141 | * as it should have a frame aligned size. */
|
---|
2142 |
|
---|
2143 | /* Read a chunk of data. */
|
---|
2144 | uint8_t abBuf[4096];
|
---|
2145 | uint32_t cbRead = 0;
|
---|
2146 | uint32_t cFramesRead = 0;
|
---|
2147 | AudioMixBufPeek(&pSink->MixBuf, 0, cFramesToTransfer, &cFramesRead,
|
---|
2148 | &pSink->In.State, abBuf, RT_MIN(cbToTransfer, sizeof(abBuf)), &cbRead);
|
---|
2149 | AssertBreak(cFramesRead > 0);
|
---|
2150 | Assert(cbRead > 0);
|
---|
2151 |
|
---|
2152 | cFramesToTransfer -= cFramesRead;
|
---|
2153 | AudioMixBufAdvance(&pSink->MixBuf, cFramesRead);
|
---|
2154 |
|
---|
2155 | /* Write it to the internal DMA buffer. */
|
---|
2156 | uint32_t off = 0;
|
---|
2157 | while (off < cbRead)
|
---|
2158 | {
|
---|
2159 | void *pvDstBuf;
|
---|
2160 | size_t cbDstBuf;
|
---|
2161 | RTCircBufAcquireWriteBlock(pCircBuf, cbRead - off, &pvDstBuf, &cbDstBuf);
|
---|
2162 |
|
---|
2163 | memcpy(pvDstBuf, &abBuf[off], cbDstBuf);
|
---|
2164 |
|
---|
2165 | #ifdef VBOX_WITH_DTRACE
|
---|
2166 | VBOXDD_AUDIO_MIXER_SINK_AIO_IN(idStream, (uint32_t)cbDstBuf, offStream);
|
---|
2167 | #endif
|
---|
2168 | offStream += cbDstBuf;
|
---|
2169 |
|
---|
2170 | RTCircBufReleaseWriteBlock(pCircBuf, cbDstBuf);
|
---|
2171 |
|
---|
2172 | off += (uint32_t)cbDstBuf;
|
---|
2173 | }
|
---|
2174 | Assert(off == cbRead);
|
---|
2175 |
|
---|
2176 | /* Write to debug file? */
|
---|
2177 | if (RT_LIKELY(!pDbgFile))
|
---|
2178 | { /* likely */ }
|
---|
2179 | else
|
---|
2180 | AudioHlpFileWrite(pDbgFile, abBuf, cbRead);
|
---|
2181 |
|
---|
2182 | /* Advance. */
|
---|
2183 | Assert(cbRead <= cbToTransfer);
|
---|
2184 | cbToTransfer -= cbRead;
|
---|
2185 | }
|
---|
2186 |
|
---|
2187 | return offStream;
|
---|
2188 | }
|
---|
2189 |
|
---|
2190 |
|
---|
2191 | /**
|
---|
2192 | * Signals the AIO thread to perform updates.
|
---|
2193 | *
|
---|
2194 | * @returns VBox status code.
|
---|
2195 | * @param pSink The mixer sink which AIO thread needs to do chores.
|
---|
2196 | */
|
---|
2197 | int AudioMixerSinkSignalUpdateJob(PAUDMIXSINK pSink)
|
---|
2198 | {
|
---|
2199 | AssertPtrReturn(pSink, VERR_INVALID_POINTER);
|
---|
2200 | Assert(pSink->uMagic == AUDMIXSINK_MAGIC);
|
---|
2201 | return RTSemEventSignal(pSink->AIO.hEvent);
|
---|
2202 | }
|
---|
2203 |
|
---|
2204 |
|
---|
2205 | /**
|
---|
2206 | * Checks if the caller is the owner of the mixer sink's critical section.
|
---|
2207 | *
|
---|
2208 | * @returns \c true if the caller is the lock owner, \c false if not.
|
---|
2209 | * @param pSink The mixer sink to check.
|
---|
2210 | */
|
---|
2211 | bool AudioMixerSinkLockIsOwner(PAUDMIXSINK pSink)
|
---|
2212 | {
|
---|
2213 | return RTCritSectIsOwner(&pSink->CritSect);
|
---|
2214 | }
|
---|
2215 |
|
---|
2216 |
|
---|
2217 | /**
|
---|
2218 | * Locks the mixer sink for purposes of serializing with the AIO thread.
|
---|
2219 | *
|
---|
2220 | * @returns VBox status code.
|
---|
2221 | * @param pSink The mixer sink to lock.
|
---|
2222 | */
|
---|
2223 | int AudioMixerSinkLock(PAUDMIXSINK pSink)
|
---|
2224 | {
|
---|
2225 | AssertPtrReturn(pSink, VERR_INVALID_POINTER);
|
---|
2226 | Assert(pSink->uMagic == AUDMIXSINK_MAGIC);
|
---|
2227 | return RTCritSectEnter(&pSink->CritSect);
|
---|
2228 | }
|
---|
2229 |
|
---|
2230 |
|
---|
2231 | /**
|
---|
2232 | * Try to lock the mixer sink for purposes of serializing with the AIO thread.
|
---|
2233 | *
|
---|
2234 | * @returns VBox status code.
|
---|
2235 | * @param pSink The mixer sink to lock.
|
---|
2236 | */
|
---|
2237 | int AudioMixerSinkTryLock(PAUDMIXSINK pSink)
|
---|
2238 | {
|
---|
2239 | AssertPtrReturn(pSink, VERR_INVALID_POINTER);
|
---|
2240 | Assert(pSink->uMagic == AUDMIXSINK_MAGIC);
|
---|
2241 | return RTCritSectTryEnter(&pSink->CritSect);
|
---|
2242 | }
|
---|
2243 |
|
---|
2244 |
|
---|
2245 | /**
|
---|
2246 | * Unlocks the sink.
|
---|
2247 | *
|
---|
2248 | * @returns VBox status code.
|
---|
2249 | * @param pSink The mixer sink to unlock.
|
---|
2250 | */
|
---|
2251 | int AudioMixerSinkUnlock(PAUDMIXSINK pSink)
|
---|
2252 | {
|
---|
2253 | AssertPtrReturn(pSink, VERR_INVALID_POINTER);
|
---|
2254 | return RTCritSectLeave(&pSink->CritSect);
|
---|
2255 | }
|
---|
2256 |
|
---|
2257 |
|
---|
2258 | /**
|
---|
2259 | * Creates an audio mixer stream.
|
---|
2260 | *
|
---|
2261 | * @returns VBox status code.
|
---|
2262 | * @param pSink Sink to use for creating the stream.
|
---|
2263 | * @param pConn Audio connector interface to use.
|
---|
2264 | * @param pCfg Audio stream configuration to use. This may be modified
|
---|
2265 | * in some unspecified way (see
|
---|
2266 | * PDMIAUDIOCONNECTOR::pfnStreamCreate).
|
---|
2267 | * @param pDevIns The device instance to register statistics with.
|
---|
2268 | * @param ppStream Pointer which receives the newly created audio stream.
|
---|
2269 | */
|
---|
2270 | int AudioMixerSinkCreateStream(PAUDMIXSINK pSink, PPDMIAUDIOCONNECTOR pConn, PCPDMAUDIOSTREAMCFG pCfg,
|
---|
2271 | PPDMDEVINS pDevIns, PAUDMIXSTREAM *ppStream)
|
---|
2272 | {
|
---|
2273 | AssertPtrReturn(pSink, VERR_INVALID_POINTER);
|
---|
2274 | Assert(pSink->uMagic == AUDMIXSINK_MAGIC);
|
---|
2275 | AssertPtrReturn(pConn, VERR_INVALID_POINTER);
|
---|
2276 | AssertPtrReturn(pCfg, VERR_INVALID_POINTER);
|
---|
2277 | AssertPtrNullReturn(ppStream, VERR_INVALID_POINTER);
|
---|
2278 | Assert(pSink->AIO.pDevIns == pDevIns); RT_NOREF(pDevIns); /* we'll probably be adding more statistics */
|
---|
2279 | AssertReturn(pCfg->enmDir == pSink->enmDir, VERR_MISMATCH);
|
---|
2280 |
|
---|
2281 | /*
|
---|
2282 | * Check status and get the host driver config.
|
---|
2283 | */
|
---|
2284 | if (pConn->pfnGetStatus(pConn, PDMAUDIODIR_DUPLEX) == PDMAUDIOBACKENDSTS_NOT_ATTACHED)
|
---|
2285 | return VERR_AUDIO_BACKEND_NOT_ATTACHED;
|
---|
2286 |
|
---|
2287 | PDMAUDIOBACKENDCFG BackendCfg;
|
---|
2288 | int rc = pConn->pfnGetConfig(pConn, &BackendCfg);
|
---|
2289 | AssertRCReturn(rc, rc);
|
---|
2290 |
|
---|
2291 | /*
|
---|
2292 | * Allocate the instance.
|
---|
2293 | */
|
---|
2294 | PAUDMIXSTREAM pMixStream = (PAUDMIXSTREAM)RTMemAllocZ(sizeof(AUDMIXSTREAM));
|
---|
2295 | AssertReturn(pMixStream, VERR_NO_MEMORY);
|
---|
2296 |
|
---|
2297 | /* Assign the backend's name to the mixer stream's name for easier identification in the (release) log. */
|
---|
2298 | pMixStream->pszName = RTStrAPrintf2("[%s] %s", pCfg->szName, BackendCfg.szName);
|
---|
2299 | pMixStream->pszStatPrefix = RTStrAPrintf2("MixerSink-%s/%s/", pSink->pszName, BackendCfg.szName);
|
---|
2300 | if (pMixStream->pszName && pMixStream->pszStatPrefix)
|
---|
2301 | {
|
---|
2302 | rc = RTCritSectInit(&pMixStream->CritSect);
|
---|
2303 | if (RT_SUCCESS(rc))
|
---|
2304 | {
|
---|
2305 | /*
|
---|
2306 | * Lock the sink so we can safely get it's properties and call
|
---|
2307 | * down into the audio driver to create that end of the stream.
|
---|
2308 | */
|
---|
2309 | rc = RTCritSectEnter(&pSink->CritSect);
|
---|
2310 | AssertRC(rc);
|
---|
2311 | if (RT_SUCCESS(rc))
|
---|
2312 | {
|
---|
2313 | LogFlowFunc(("[%s] (enmDir=%ld, %u bits, %RU8 channels, %RU32Hz)\n", pSink->pszName, pCfg->enmDir,
|
---|
2314 | PDMAudioPropsSampleBits(&pCfg->Props), PDMAudioPropsChannels(&pCfg->Props), pCfg->Props.uHz));
|
---|
2315 |
|
---|
2316 | /*
|
---|
2317 | * Initialize the host-side configuration for the stream to be created,
|
---|
2318 | * this is the sink format & direction with the src/dir, layout, name
|
---|
2319 | * and device specific config copied from the guest side config (pCfg).
|
---|
2320 | * We disregard any Backend settings here.
|
---|
2321 | *
|
---|
2322 | * (Note! pfnStreamCreate used to get both CfgHost and pCfg (aka pCfgGuest)
|
---|
2323 | * passed in, but that became unnecessary with DrvAudio stoppping
|
---|
2324 | * mixing. The mixing is done here and we bridge guest & host configs.)
|
---|
2325 | */
|
---|
2326 | AssertMsg(AudioHlpPcmPropsAreValidAndSupported(&pSink->PCMProps),
|
---|
2327 | ("%s: Does not (yet) have a (valid and supported) format set when it must\n", pSink->pszName));
|
---|
2328 |
|
---|
2329 | PDMAUDIOSTREAMCFG CfgHost;
|
---|
2330 | rc = PDMAudioStrmCfgInitWithProps(&CfgHost, &pSink->PCMProps);
|
---|
2331 | AssertRC(rc); /* cannot fail */
|
---|
2332 | CfgHost.enmDir = pSink->enmDir;
|
---|
2333 | CfgHost.enmPath = pCfg->enmPath;
|
---|
2334 | CfgHost.Device = pCfg->Device;
|
---|
2335 | RTStrCopy(CfgHost.szName, sizeof(CfgHost.szName), pCfg->szName);
|
---|
2336 |
|
---|
2337 | /*
|
---|
2338 | * Create the stream.
|
---|
2339 | *
|
---|
2340 | * Output streams are not using any mixing buffers in DrvAudio. This will
|
---|
2341 | * become the norm after we move the input mixing here and convert DevSB16
|
---|
2342 | * to use this mixer code too.
|
---|
2343 | */
|
---|
2344 | PPDMAUDIOSTREAM pStream;
|
---|
2345 | rc = pConn->pfnStreamCreate(pConn, 0 /*fFlags*/, &CfgHost, &pStream);
|
---|
2346 | if (RT_SUCCESS(rc))
|
---|
2347 | {
|
---|
2348 | pMixStream->cFramesBackendBuffer = pStream->Cfg.Backend.cFramesBufferSize;
|
---|
2349 |
|
---|
2350 | /* Set up the mixing buffer conversion state. */
|
---|
2351 | if (pSink->enmDir == PDMAUDIODIR_IN)
|
---|
2352 | rc = AudioMixBufInitWriteState(&pSink->MixBuf, &pMixStream->WriteState, &pStream->Cfg.Props);
|
---|
2353 | else
|
---|
2354 | rc = AudioMixBufInitPeekState(&pSink->MixBuf, &pMixStream->PeekState, &pStream->Cfg.Props);
|
---|
2355 | if (RT_SUCCESS(rc))
|
---|
2356 | {
|
---|
2357 | /* Save the audio stream pointer to this mixing stream. */
|
---|
2358 | pMixStream->pStream = pStream;
|
---|
2359 |
|
---|
2360 | /* Increase the stream's reference count to let others know
|
---|
2361 | * we're relying on it to be around now. */
|
---|
2362 | pConn->pfnStreamRetain(pConn, pStream);
|
---|
2363 | pMixStream->pConn = pConn;
|
---|
2364 | pMixStream->uMagic = AUDMIXSTREAM_MAGIC;
|
---|
2365 |
|
---|
2366 | RTCritSectLeave(&pSink->CritSect);
|
---|
2367 |
|
---|
2368 | if (ppStream)
|
---|
2369 | *ppStream = pMixStream;
|
---|
2370 | return VINF_SUCCESS;
|
---|
2371 | }
|
---|
2372 |
|
---|
2373 | rc = pConn->pfnStreamDestroy(pConn, pStream, true /*fImmediate*/);
|
---|
2374 | }
|
---|
2375 |
|
---|
2376 | /*
|
---|
2377 | * Failed. Tear down the stream.
|
---|
2378 | */
|
---|
2379 | int rc2 = RTCritSectLeave(&pSink->CritSect);
|
---|
2380 | AssertRC(rc2);
|
---|
2381 | }
|
---|
2382 | RTCritSectDelete(&pMixStream->CritSect);
|
---|
2383 | }
|
---|
2384 | }
|
---|
2385 | else
|
---|
2386 | rc = VERR_NO_STR_MEMORY;
|
---|
2387 |
|
---|
2388 | RTStrFree(pMixStream->pszStatPrefix);
|
---|
2389 | pMixStream->pszStatPrefix = NULL;
|
---|
2390 | RTStrFree(pMixStream->pszName);
|
---|
2391 | pMixStream->pszName = NULL;
|
---|
2392 | RTMemFree(pMixStream);
|
---|
2393 | return rc;
|
---|
2394 | }
|
---|
2395 |
|
---|
2396 |
|
---|
2397 | /**
|
---|
2398 | * Adds an audio stream to a specific audio sink.
|
---|
2399 | *
|
---|
2400 | * @returns VBox status code.
|
---|
2401 | * @param pSink Sink to add audio stream to.
|
---|
2402 | * @param pStream Stream to add.
|
---|
2403 | */
|
---|
2404 | int AudioMixerSinkAddStream(PAUDMIXSINK pSink, PAUDMIXSTREAM pStream)
|
---|
2405 | {
|
---|
2406 | LogFlowFuncEnter();
|
---|
2407 | AssertPtrReturn(pSink, VERR_INVALID_POINTER);
|
---|
2408 | Assert(pSink->uMagic == AUDMIXSINK_MAGIC);
|
---|
2409 | AssertPtrReturn(pStream, VERR_INVALID_POINTER);
|
---|
2410 | Assert(pStream->uMagic == AUDMIXSTREAM_MAGIC);
|
---|
2411 | AssertPtrReturn(pStream->pConn, VERR_AUDIO_STREAM_NOT_READY);
|
---|
2412 | AssertReturn(pStream->pSink == NULL, VERR_ALREADY_EXISTS);
|
---|
2413 |
|
---|
2414 | int rc = RTCritSectEnter(&pSink->CritSect);
|
---|
2415 | AssertRCReturn(rc, rc);
|
---|
2416 |
|
---|
2417 | AssertLogRelMsgReturnStmt(pSink->cStreams < UINT8_MAX, ("too many streams!\n"), RTCritSectLeave(&pSink->CritSect),
|
---|
2418 | VERR_TOO_MANY_OPEN_FILES);
|
---|
2419 |
|
---|
2420 | /*
|
---|
2421 | * If the sink is running and not in pending disable mode, make sure that
|
---|
2422 | * the added stream also is enabled. Ignore any failure to enable it.
|
---|
2423 | */
|
---|
2424 | if ( (pSink->fStatus & AUDMIXSINK_STS_RUNNING)
|
---|
2425 | && !(pSink->fStatus & AUDMIXSINK_STS_DRAINING))
|
---|
2426 | {
|
---|
2427 | audioMixerStreamCtlInternal(pStream, PDMAUDIOSTREAMCMD_ENABLE);
|
---|
2428 | }
|
---|
2429 |
|
---|
2430 | /* Save pointer to sink the stream is attached to. */
|
---|
2431 | pStream->pSink = pSink;
|
---|
2432 |
|
---|
2433 | /* Append stream to sink's list. */
|
---|
2434 | RTListAppend(&pSink->lstStreams, &pStream->Node);
|
---|
2435 | pSink->cStreams++;
|
---|
2436 |
|
---|
2437 | LogFlowFunc(("[%s] cStreams=%RU8, rc=%Rrc\n", pSink->pszName, pSink->cStreams, rc));
|
---|
2438 | RTCritSectLeave(&pSink->CritSect);
|
---|
2439 | return rc;
|
---|
2440 | }
|
---|
2441 |
|
---|
2442 |
|
---|
2443 | /**
|
---|
2444 | * Removes a mixer stream from a mixer sink, internal version.
|
---|
2445 | *
|
---|
2446 | * @returns VBox status code.
|
---|
2447 | * @param pSink The mixer sink (valid).
|
---|
2448 | * @param pStream The stream to remove (valid).
|
---|
2449 | *
|
---|
2450 | * @note Caller must own the sink lock.
|
---|
2451 | */
|
---|
2452 | static int audioMixerSinkRemoveStreamInternal(PAUDMIXSINK pSink, PAUDMIXSTREAM pStream)
|
---|
2453 | {
|
---|
2454 | AssertPtr(pSink);
|
---|
2455 | AssertPtr(pStream);
|
---|
2456 | AssertMsgReturn(pStream->pSink == pSink, ("Stream '%s' is not part of sink '%s'\n",
|
---|
2457 | pStream->pszName, pSink->pszName), VERR_NOT_FOUND);
|
---|
2458 | Assert(RTCritSectIsOwner(&pSink->CritSect));
|
---|
2459 | LogFlowFunc(("[%s] (Stream = %s), cStreams=%RU8\n", pSink->pszName, pStream->pStream->Cfg.szName, pSink->cStreams));
|
---|
2460 |
|
---|
2461 | /*
|
---|
2462 | * Remove stream from sink, update the count and set the pSink member to NULL.
|
---|
2463 | */
|
---|
2464 | RTListNodeRemove(&pStream->Node);
|
---|
2465 |
|
---|
2466 | Assert(pSink->cStreams > 0);
|
---|
2467 | pSink->cStreams--;
|
---|
2468 |
|
---|
2469 | pStream->pSink = NULL;
|
---|
2470 |
|
---|
2471 | return VINF_SUCCESS;
|
---|
2472 | }
|
---|
2473 |
|
---|
2474 |
|
---|
2475 | /**
|
---|
2476 | * Removes a mixer stream from a mixer sink.
|
---|
2477 | *
|
---|
2478 | * @param pSink The mixer sink.
|
---|
2479 | * @param pStream The stream to remove.
|
---|
2480 | */
|
---|
2481 | void AudioMixerSinkRemoveStream(PAUDMIXSINK pSink, PAUDMIXSTREAM pStream)
|
---|
2482 | {
|
---|
2483 | AssertPtrReturnVoid(pSink);
|
---|
2484 | AssertReturnVoid(pSink->uMagic == AUDMIXSINK_MAGIC);
|
---|
2485 | AssertPtrReturnVoid(pStream);
|
---|
2486 | AssertReturnVoid(pStream->uMagic == AUDMIXSTREAM_MAGIC);
|
---|
2487 |
|
---|
2488 | int rc = RTCritSectEnter(&pSink->CritSect);
|
---|
2489 | AssertRCReturnVoid(rc);
|
---|
2490 |
|
---|
2491 | audioMixerSinkRemoveStreamInternal(pSink, pStream);
|
---|
2492 |
|
---|
2493 | RTCritSectLeave(&pSink->CritSect);
|
---|
2494 | }
|
---|
2495 |
|
---|
2496 |
|
---|
2497 | /**
|
---|
2498 | * Removes all streams from a given sink.
|
---|
2499 | *
|
---|
2500 | * @param pSink The mixer sink. NULL is ignored.
|
---|
2501 | */
|
---|
2502 | void AudioMixerSinkRemoveAllStreams(PAUDMIXSINK pSink)
|
---|
2503 | {
|
---|
2504 | if (!pSink)
|
---|
2505 | return;
|
---|
2506 | AssertReturnVoid(pSink->uMagic == AUDMIXSINK_MAGIC);
|
---|
2507 |
|
---|
2508 | int rc = RTCritSectEnter(&pSink->CritSect);
|
---|
2509 | AssertRCReturnVoid(rc);
|
---|
2510 |
|
---|
2511 | LogFunc(("%s\n", pSink->pszName));
|
---|
2512 |
|
---|
2513 | PAUDMIXSTREAM pStream, pStreamNext;
|
---|
2514 | RTListForEachSafe(&pSink->lstStreams, pStream, pStreamNext, AUDMIXSTREAM, Node)
|
---|
2515 | {
|
---|
2516 | audioMixerSinkRemoveStreamInternal(pSink, pStream);
|
---|
2517 | }
|
---|
2518 | AssertStmt(pSink->cStreams == 0, pSink->cStreams = 0);
|
---|
2519 |
|
---|
2520 | RTCritSectLeave(&pSink->CritSect);
|
---|
2521 | }
|
---|
2522 |
|
---|
2523 |
|
---|
2524 |
|
---|
2525 | /*********************************************************************************************************************************
|
---|
2526 | * Mixer Stream implementation.
|
---|
2527 | ********************************************************************************************************************************/
|
---|
2528 |
|
---|
2529 | /**
|
---|
2530 | * Controls a mixer stream, internal version.
|
---|
2531 | *
|
---|
2532 | * @returns VBox status code (generally ignored).
|
---|
2533 | * @param pMixStream Mixer stream to control.
|
---|
2534 | * @param enmCmd Mixer stream command to use.
|
---|
2535 | */
|
---|
2536 | static int audioMixerStreamCtlInternal(PAUDMIXSTREAM pMixStream, PDMAUDIOSTREAMCMD enmCmd)
|
---|
2537 | {
|
---|
2538 | Assert(pMixStream->uMagic == AUDMIXSTREAM_MAGIC);
|
---|
2539 | AssertPtrReturn(pMixStream->pConn, VERR_AUDIO_STREAM_NOT_READY);
|
---|
2540 | AssertPtrReturn(pMixStream->pStream, VERR_AUDIO_STREAM_NOT_READY);
|
---|
2541 |
|
---|
2542 | int rc = pMixStream->pConn->pfnStreamControl(pMixStream->pConn, pMixStream->pStream, enmCmd);
|
---|
2543 |
|
---|
2544 | LogFlowFunc(("[%s] enmCmd=%d, rc=%Rrc\n", pMixStream->pszName, enmCmd, rc));
|
---|
2545 |
|
---|
2546 | return rc;
|
---|
2547 | }
|
---|
2548 |
|
---|
2549 | /**
|
---|
2550 | * Updates a mixer stream's internal status.
|
---|
2551 | *
|
---|
2552 | * This may perform a stream re-init if the driver requests it, in which case
|
---|
2553 | * this may take a little while longer than usual...
|
---|
2554 | *
|
---|
2555 | * @returns VBox status code.
|
---|
2556 | * @param pMixStream Mixer stream to to update internal status for.
|
---|
2557 | */
|
---|
2558 | static int audioMixerStreamUpdateStatus(PAUDMIXSTREAM pMixStream)
|
---|
2559 | {
|
---|
2560 | Assert(pMixStream->uMagic == AUDMIXSTREAM_MAGIC);
|
---|
2561 |
|
---|
2562 | /*
|
---|
2563 | * Reset the mixer status to start with.
|
---|
2564 | */
|
---|
2565 | pMixStream->fStatus = AUDMIXSTREAM_STATUS_NONE;
|
---|
2566 |
|
---|
2567 | PPDMIAUDIOCONNECTOR const pConn = pMixStream->pConn;
|
---|
2568 | if (pConn) /* Audio connector available? */
|
---|
2569 | {
|
---|
2570 | PPDMAUDIOSTREAM const pStream = pMixStream->pStream;
|
---|
2571 |
|
---|
2572 | /*
|
---|
2573 | * Get the stream status.
|
---|
2574 | * Do re-init if needed and fetch the status again afterwards.
|
---|
2575 | */
|
---|
2576 | PDMAUDIOSTREAMSTATE enmState = pConn->pfnStreamGetState(pConn, pStream);
|
---|
2577 | if (enmState != PDMAUDIOSTREAMSTATE_NEED_REINIT)
|
---|
2578 | { /* likely */ }
|
---|
2579 | else
|
---|
2580 | {
|
---|
2581 | LogFunc(("[%s] needs re-init...\n", pMixStream->pszName));
|
---|
2582 | int rc = pConn->pfnStreamReInit(pConn, pStream);
|
---|
2583 | enmState = pConn->pfnStreamGetState(pConn, pStream);
|
---|
2584 | LogFunc(("[%s] re-init returns %Rrc and %s.\n", pMixStream->pszName, rc, PDMAudioStreamStateGetName(enmState)));
|
---|
2585 |
|
---|
2586 | PAUDMIXSINK const pSink = pMixStream->pSink;
|
---|
2587 | AssertPtr(pSink);
|
---|
2588 | if (pSink->enmDir == PDMAUDIODIR_OUT)
|
---|
2589 | {
|
---|
2590 | rc = AudioMixBufInitPeekState(&pSink->MixBuf, &pMixStream->PeekState, &pStream->Cfg.Props);
|
---|
2591 | /** @todo we need to remember this, don't we? */
|
---|
2592 | AssertLogRelRCReturn(rc, VINF_SUCCESS);
|
---|
2593 | }
|
---|
2594 | else
|
---|
2595 | {
|
---|
2596 | rc = AudioMixBufInitWriteState(&pSink->MixBuf, &pMixStream->WriteState, &pStream->Cfg.Props);
|
---|
2597 | /** @todo we need to remember this, don't we? */
|
---|
2598 | AssertLogRelRCReturn(rc, VINF_SUCCESS);
|
---|
2599 | }
|
---|
2600 | }
|
---|
2601 |
|
---|
2602 | /*
|
---|
2603 | * Translate the status to mixer speak.
|
---|
2604 | */
|
---|
2605 | AssertMsg(enmState > PDMAUDIOSTREAMSTATE_INVALID && enmState < PDMAUDIOSTREAMSTATE_END, ("%d\n", enmState));
|
---|
2606 | switch (enmState)
|
---|
2607 | {
|
---|
2608 | case PDMAUDIOSTREAMSTATE_NOT_WORKING:
|
---|
2609 | case PDMAUDIOSTREAMSTATE_NEED_REINIT:
|
---|
2610 | case PDMAUDIOSTREAMSTATE_INACTIVE:
|
---|
2611 | pMixStream->fStatus = AUDMIXSTREAM_STATUS_NONE;
|
---|
2612 | break;
|
---|
2613 | case PDMAUDIOSTREAMSTATE_ENABLED:
|
---|
2614 | pMixStream->fStatus = AUDMIXSTREAM_STATUS_ENABLED;
|
---|
2615 | break;
|
---|
2616 | case PDMAUDIOSTREAMSTATE_ENABLED_READABLE:
|
---|
2617 | Assert(pMixStream->pSink->enmDir == PDMAUDIODIR_IN);
|
---|
2618 | pMixStream->fStatus = AUDMIXSTREAM_STATUS_ENABLED | AUDMIXSTREAM_STATUS_CAN_READ;
|
---|
2619 | break;
|
---|
2620 | case PDMAUDIOSTREAMSTATE_ENABLED_WRITABLE:
|
---|
2621 | Assert(pMixStream->pSink->enmDir == PDMAUDIODIR_OUT);
|
---|
2622 | pMixStream->fStatus = AUDMIXSTREAM_STATUS_ENABLED | AUDMIXSTREAM_STATUS_CAN_WRITE;
|
---|
2623 | break;
|
---|
2624 | /* no default */
|
---|
2625 | case PDMAUDIOSTREAMSTATE_INVALID:
|
---|
2626 | case PDMAUDIOSTREAMSTATE_END:
|
---|
2627 | case PDMAUDIOSTREAMSTATE_32BIT_HACK:
|
---|
2628 | break;
|
---|
2629 | }
|
---|
2630 | }
|
---|
2631 |
|
---|
2632 | LogFlowFunc(("[%s] -> 0x%x\n", pMixStream->pszName, pMixStream->fStatus));
|
---|
2633 | return VINF_SUCCESS;
|
---|
2634 | }
|
---|
2635 |
|
---|
2636 |
|
---|
2637 | /**
|
---|
2638 | * Destroys & frees a mixer stream, internal version.
|
---|
2639 | *
|
---|
2640 | * Worker for audioMixerSinkDestroyInternal and AudioMixerStreamDestroy.
|
---|
2641 | *
|
---|
2642 | * @param pMixStream Mixer stream to destroy.
|
---|
2643 | * @param pDevIns The device instance the statistics are registered with.
|
---|
2644 | * @param fImmediate How to handle still draining streams, whether to let
|
---|
2645 | * them complete (@c false) or destroy them immediately (@c
|
---|
2646 | * true).
|
---|
2647 | */
|
---|
2648 | static void audioMixerStreamDestroyInternal(PAUDMIXSTREAM pMixStream, PPDMDEVINS pDevIns, bool fImmediate)
|
---|
2649 | {
|
---|
2650 | AssertPtr(pMixStream);
|
---|
2651 | LogFunc(("%s\n", pMixStream->pszName));
|
---|
2652 | Assert(pMixStream->uMagic == AUDMIXSTREAM_MAGIC);
|
---|
2653 |
|
---|
2654 | /*
|
---|
2655 | * Invalidate it.
|
---|
2656 | */
|
---|
2657 | pMixStream->uMagic = AUDMIXSTREAM_MAGIC_DEAD;
|
---|
2658 |
|
---|
2659 | /*
|
---|
2660 | * Destroy the driver stream (if any).
|
---|
2661 | */
|
---|
2662 | if (pMixStream->pConn) /* Stream has a connector interface present? */
|
---|
2663 | {
|
---|
2664 | if (pMixStream->pStream)
|
---|
2665 | {
|
---|
2666 | pMixStream->pConn->pfnStreamRelease(pMixStream->pConn, pMixStream->pStream);
|
---|
2667 | pMixStream->pConn->pfnStreamDestroy(pMixStream->pConn, pMixStream->pStream, fImmediate);
|
---|
2668 |
|
---|
2669 | pMixStream->pStream = NULL;
|
---|
2670 | }
|
---|
2671 |
|
---|
2672 | pMixStream->pConn = NULL;
|
---|
2673 | }
|
---|
2674 |
|
---|
2675 | /*
|
---|
2676 | * Stats. Doing it by prefix is soo much faster than individually, btw.
|
---|
2677 | */
|
---|
2678 | if (pMixStream->pszStatPrefix)
|
---|
2679 | {
|
---|
2680 | PDMDevHlpSTAMDeregisterByPrefix(pDevIns, pMixStream->pszStatPrefix);
|
---|
2681 | RTStrFree(pMixStream->pszStatPrefix);
|
---|
2682 | pMixStream->pszStatPrefix = NULL;
|
---|
2683 | }
|
---|
2684 |
|
---|
2685 | /*
|
---|
2686 | * Delete the critsect and free the memory.
|
---|
2687 | */
|
---|
2688 | int rc2 = RTCritSectDelete(&pMixStream->CritSect);
|
---|
2689 | AssertRC(rc2);
|
---|
2690 |
|
---|
2691 | RTStrFree(pMixStream->pszName);
|
---|
2692 | pMixStream->pszName = NULL;
|
---|
2693 |
|
---|
2694 | RTMemFree(pMixStream);
|
---|
2695 | }
|
---|
2696 |
|
---|
2697 |
|
---|
2698 | /**
|
---|
2699 | * Destroys a mixer stream.
|
---|
2700 | *
|
---|
2701 | * @param pMixStream Mixer stream to destroy.
|
---|
2702 | * @param pDevIns The device instance statistics are registered with.
|
---|
2703 | * @param fImmediate How to handle still draining streams, whether to let
|
---|
2704 | * them complete (@c false) or destroy them immediately (@c
|
---|
2705 | * true).
|
---|
2706 | */
|
---|
2707 | void AudioMixerStreamDestroy(PAUDMIXSTREAM pMixStream, PPDMDEVINS pDevIns, bool fImmediate)
|
---|
2708 | {
|
---|
2709 | if (!pMixStream)
|
---|
2710 | return;
|
---|
2711 | AssertReturnVoid(pMixStream->uMagic == AUDMIXSTREAM_MAGIC);
|
---|
2712 | LogFunc(("%s\n", pMixStream->pszName));
|
---|
2713 |
|
---|
2714 | /*
|
---|
2715 | * Serializing paranoia.
|
---|
2716 | */
|
---|
2717 | int rc = RTCritSectEnter(&pMixStream->CritSect);
|
---|
2718 | AssertRCReturnVoid(rc);
|
---|
2719 | RTCritSectLeave(&pMixStream->CritSect);
|
---|
2720 |
|
---|
2721 | /*
|
---|
2722 | * Unlink from sink if associated with one.
|
---|
2723 | */
|
---|
2724 | PAUDMIXSINK pSink = pMixStream->pSink;
|
---|
2725 | if ( RT_VALID_PTR(pSink)
|
---|
2726 | && pSink->uMagic == AUDMIXSINK_MAGIC)
|
---|
2727 | {
|
---|
2728 | RTCritSectEnter(&pSink->CritSect);
|
---|
2729 | audioMixerSinkRemoveStreamInternal(pMixStream->pSink, pMixStream);
|
---|
2730 | RTCritSectLeave(&pSink->CritSect);
|
---|
2731 | }
|
---|
2732 | else if (pSink)
|
---|
2733 | AssertFailed();
|
---|
2734 |
|
---|
2735 | /*
|
---|
2736 | * Do the actual stream destruction.
|
---|
2737 | */
|
---|
2738 | audioMixerStreamDestroyInternal(pMixStream, pDevIns, fImmediate);
|
---|
2739 | LogFlowFunc(("returns\n"));
|
---|
2740 | }
|
---|
2741 |
|
---|