VirtualBox

source: vbox/trunk/src/VBox/Devices/Audio/DrvAudio.cpp@ 73643

Last change on this file since 73643 was 73640, checked in by vboxsync, 7 years ago

Audio/DrvAudio: Logging.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 123.9 KB
Line 
1/* $Id: DrvAudio.cpp 73640 2018-08-13 16:54:40Z vboxsync $ */
2/** @file
3 * Intermediate audio driver header.
4 *
5 * @remarks Intermediate audio driver for connecting the audio device emulation
6 * with the host backend.
7 */
8
9/*
10 * Copyright (C) 2006-2018 Oracle Corporation
11 *
12 * This file is part of VirtualBox Open Source Edition (OSE), as
13 * available from http://www.virtualbox.org. This file is free software;
14 * you can redistribute it and/or modify it under the terms of the GNU
15 * General Public License (GPL) as published by the Free Software
16 * Foundation, in version 2 as it comes in the "COPYING" file of the
17 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
18 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
19 */
20
21#define LOG_GROUP LOG_GROUP_DRV_AUDIO
22#include <VBox/log.h>
23#include <VBox/vmm/pdm.h>
24#include <VBox/err.h>
25#include <VBox/vmm/mm.h>
26#include <VBox/vmm/pdmaudioifs.h>
27
28#include <iprt/alloc.h>
29#include <iprt/asm-math.h>
30#include <iprt/assert.h>
31#include <iprt/circbuf.h>
32#include <iprt/string.h>
33#include <iprt/uuid.h>
34
35#include "VBoxDD.h"
36
37#include <ctype.h>
38#include <stdlib.h>
39
40#include "DrvAudio.h"
41#include "AudioMixBuffer.h"
42
43#ifdef VBOX_WITH_AUDIO_ENUM
44static int drvAudioDevicesEnumerateInternal(PDRVAUDIO pThis, bool fLog, PPDMAUDIODEVICEENUM pDevEnum);
45#endif
46
47static DECLCALLBACK(int) drvAudioStreamDestroy(PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOSTREAM pStream);
48static int drvAudioStreamControlInternalBackend(PDRVAUDIO pThis, PPDMAUDIOSTREAM pStream, PDMAUDIOSTREAMCMD enmStreamCmd);
49static int drvAudioStreamControlInternal(PDRVAUDIO pThis, PPDMAUDIOSTREAM pStream, PDMAUDIOSTREAMCMD enmStreamCmd);
50static int drvAudioStreamCreateInternalBackend(PDRVAUDIO pThis, PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq);
51static int drvAudioStreamDestroyInternalBackend(PDRVAUDIO pThis, PPDMAUDIOSTREAM pStream);
52static void drvAudioStreamFree(PPDMAUDIOSTREAM pStream);
53static int drvAudioStreamUninitInternal(PDRVAUDIO pThis, PPDMAUDIOSTREAM pStream);
54static int drvAudioStreamInitInternal(PDRVAUDIO pThis, PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfgHost, PPDMAUDIOSTREAMCFG pCfgGuest);
55static int drvAudioStreamIterateInternal(PDRVAUDIO pThis, PPDMAUDIOSTREAM pStream);
56static int drvAudioStreamReInitInternal(PDRVAUDIO pThis, PPDMAUDIOSTREAM pStream);
57static void drvAudioStreamResetInternal(PDRVAUDIO pThis, PPDMAUDIOSTREAM pStream);
58
59#ifndef VBOX_AUDIO_TESTCASE
60
61# if 0 /* unused */
62
63static PDMAUDIOFMT drvAudioGetConfFormat(PCFGMNODE pCfgHandle, const char *pszKey,
64 PDMAUDIOFMT enmDefault, bool *pfDefault)
65{
66 if ( pCfgHandle == NULL
67 || pszKey == NULL)
68 {
69 *pfDefault = true;
70 return enmDefault;
71 }
72
73 char *pszValue = NULL;
74 int rc = CFGMR3QueryStringAlloc(pCfgHandle, pszKey, &pszValue);
75 if (RT_FAILURE(rc))
76 {
77 *pfDefault = true;
78 return enmDefault;
79 }
80
81 PDMAUDIOFMT fmt = DrvAudioHlpStrToAudFmt(pszValue);
82 if (fmt == PDMAUDIOFMT_INVALID)
83 {
84 *pfDefault = true;
85 return enmDefault;
86 }
87
88 *pfDefault = false;
89 return fmt;
90}
91
92static int drvAudioGetConfInt(PCFGMNODE pCfgHandle, const char *pszKey,
93 int iDefault, bool *pfDefault)
94{
95
96 if ( pCfgHandle == NULL
97 || pszKey == NULL)
98 {
99 *pfDefault = true;
100 return iDefault;
101 }
102
103 uint64_t u64Data = 0;
104 int rc = CFGMR3QueryInteger(pCfgHandle, pszKey, &u64Data);
105 if (RT_FAILURE(rc))
106 {
107 *pfDefault = true;
108 return iDefault;
109
110 }
111
112 *pfDefault = false;
113 return u64Data;
114}
115
116static const char *drvAudioGetConfStr(PCFGMNODE pCfgHandle, const char *pszKey,
117 const char *pszDefault, bool *pfDefault)
118{
119 if ( pCfgHandle == NULL
120 || pszKey == NULL)
121 {
122 *pfDefault = true;
123 return pszDefault;
124 }
125
126 char *pszValue = NULL;
127 int rc = CFGMR3QueryStringAlloc(pCfgHandle, pszKey, &pszValue);
128 if (RT_FAILURE(rc))
129 {
130 *pfDefault = true;
131 return pszDefault;
132 }
133
134 *pfDefault = false;
135 return pszValue;
136}
137
138# endif /* unused */
139
140#ifdef LOG_ENABLED
141/**
142 * Converts an audio stream status to a string.
143 *
144 * @returns Stringified stream status flags. Must be free'd with RTStrFree().
145 * "NONE" if no flags set.
146 * @param fStatus Stream status flags to convert.
147 */
148static char *dbgAudioStreamStatusToStr(PDMAUDIOSTREAMSTS fStatus)
149{
150#define APPEND_FLAG_TO_STR(_aFlag) \
151 if (fStatus & PDMAUDIOSTREAMSTS_FLAG_##_aFlag) \
152 { \
153 if (pszFlags) \
154 { \
155 rc2 = RTStrAAppend(&pszFlags, " "); \
156 if (RT_FAILURE(rc2)) \
157 break; \
158 } \
159 \
160 rc2 = RTStrAAppend(&pszFlags, #_aFlag); \
161 if (RT_FAILURE(rc2)) \
162 break; \
163 } \
164
165 char *pszFlags = NULL;
166 int rc2 = VINF_SUCCESS;
167
168 do
169 {
170 APPEND_FLAG_TO_STR(INITIALIZED );
171 APPEND_FLAG_TO_STR(ENABLED );
172 APPEND_FLAG_TO_STR(PAUSED );
173 APPEND_FLAG_TO_STR(PENDING_DISABLE);
174 APPEND_FLAG_TO_STR(PENDING_REINIT );
175 } while (0);
176
177 if (!pszFlags)
178 rc2 = RTStrAAppend(&pszFlags, "NONE");
179
180 if ( RT_FAILURE(rc2)
181 && pszFlags)
182 {
183 RTStrFree(pszFlags);
184 pszFlags = NULL;
185 }
186
187#undef APPEND_FLAG_TO_STR
188
189 return pszFlags;
190}
191#endif /* defined(VBOX_STRICT) || defined(LOG_ENABLED) */
192
193# if 0 /* unused */
194static int drvAudioProcessOptions(PCFGMNODE pCfgHandle, const char *pszPrefix, audio_option *paOpts, size_t cOpts)
195{
196 AssertPtrReturn(pCfgHandle, VERR_INVALID_POINTER);
197 AssertPtrReturn(pszPrefix, VERR_INVALID_POINTER);
198 /* oaOpts and cOpts are optional. */
199
200 PCFGMNODE pCfgChildHandle = NULL;
201 PCFGMNODE pCfgChildChildHandle = NULL;
202
203 /* If pCfgHandle is NULL, let NULL be passed to get int and get string functions..
204 * The getter function will return default values.
205 */
206 if (pCfgHandle != NULL)
207 {
208 /* If its audio general setting, need to traverse to one child node.
209 * /Devices/ichac97/0/LUN#0/Config/Audio
210 */
211 if(!strncmp(pszPrefix, "AUDIO", 5)) /** @todo Use a \#define */
212 {
213 pCfgChildHandle = CFGMR3GetFirstChild(pCfgHandle);
214 if(pCfgChildHandle)
215 pCfgHandle = pCfgChildHandle;
216 }
217 else
218 {
219 /* If its driver specific configuration , then need to traverse two level deep child
220 * child nodes. for eg. in case of DirectSoundConfiguration item
221 * /Devices/ichac97/0/LUN#0/Config/Audio/DirectSoundConfig
222 */
223 pCfgChildHandle = CFGMR3GetFirstChild(pCfgHandle);
224 if (pCfgChildHandle)
225 {
226 pCfgChildChildHandle = CFGMR3GetFirstChild(pCfgChildHandle);
227 if (pCfgChildChildHandle)
228 pCfgHandle = pCfgChildChildHandle;
229 }
230 }
231 }
232
233 for (size_t i = 0; i < cOpts; i++)
234 {
235 audio_option *pOpt = &paOpts[i];
236 if (!pOpt->valp)
237 {
238 LogFlowFunc(("Option value pointer for `%s' is not set\n", pOpt->name));
239 continue;
240 }
241
242 bool fUseDefault;
243
244 switch (pOpt->tag)
245 {
246 case AUD_OPT_BOOL:
247 case AUD_OPT_INT:
248 {
249 int *intp = (int *)pOpt->valp;
250 *intp = drvAudioGetConfInt(pCfgHandle, pOpt->name, *intp, &fUseDefault);
251
252 break;
253 }
254
255 case AUD_OPT_FMT:
256 {
257 PDMAUDIOFMT *fmtp = (PDMAUDIOFMT *)pOpt->valp;
258 *fmtp = drvAudioGetConfFormat(pCfgHandle, pOpt->name, *fmtp, &fUseDefault);
259
260 break;
261 }
262
263 case AUD_OPT_STR:
264 {
265 const char **strp = (const char **)pOpt->valp;
266 *strp = drvAudioGetConfStr(pCfgHandle, pOpt->name, *strp, &fUseDefault);
267
268 break;
269 }
270
271 default:
272 LogFlowFunc(("Bad value tag for option `%s' - %d\n", pOpt->name, pOpt->tag));
273 fUseDefault = false;
274 break;
275 }
276
277 if (!pOpt->overridenp)
278 pOpt->overridenp = &pOpt->overriden;
279
280 *pOpt->overridenp = !fUseDefault;
281 }
282
283 return VINF_SUCCESS;
284}
285# endif /* unused */
286#endif /* !VBOX_AUDIO_TESTCASE */
287
288/**
289 * @interface_method_impl{PDMIAUDIOCONNECTOR,pfnStreamControl}
290 */
291static DECLCALLBACK(int) drvAudioStreamControl(PPDMIAUDIOCONNECTOR pInterface,
292 PPDMAUDIOSTREAM pStream, PDMAUDIOSTREAMCMD enmStreamCmd)
293{
294 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
295
296 if (!pStream)
297 return VINF_SUCCESS;
298
299 PDRVAUDIO pThis = PDMIAUDIOCONNECTOR_2_DRVAUDIO(pInterface);
300
301 int rc = RTCritSectEnter(&pThis->CritSect);
302 if (RT_FAILURE(rc))
303 return rc;
304
305 LogFlowFunc(("[%s] enmStreamCmd=%s\n", pStream->szName, DrvAudioHlpStreamCmdToStr(enmStreamCmd)));
306
307 rc = drvAudioStreamControlInternal(pThis, pStream, enmStreamCmd);
308
309 int rc2 = RTCritSectLeave(&pThis->CritSect);
310 if (RT_SUCCESS(rc))
311 rc = rc2;
312
313 return rc;
314}
315
316/**
317 * Controls an audio stream.
318 *
319 * @returns IPRT status code.
320 * @param pThis Pointer to driver instance.
321 * @param pStream Stream to control.
322 * @param enmStreamCmd Control command.
323 */
324static int drvAudioStreamControlInternal(PDRVAUDIO pThis, PPDMAUDIOSTREAM pStream, PDMAUDIOSTREAMCMD enmStreamCmd)
325{
326 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
327 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
328
329 LogFunc(("[%s] enmStreamCmd=%s\n", pStream->szName, DrvAudioHlpStreamCmdToStr(enmStreamCmd)));
330
331#ifdef LOG_ENABLED
332 char *pszStreamSts = dbgAudioStreamStatusToStr(pStream->fStatus);
333 LogFlowFunc(("fStatus=%s\n", pszStreamSts));
334 RTStrFree(pszStreamSts);
335#endif /* LOG_ENABLED */
336
337 int rc = VINF_SUCCESS;
338
339 switch (enmStreamCmd)
340 {
341 case PDMAUDIOSTREAMCMD_ENABLE:
342 {
343 if (!(pStream->fStatus & PDMAUDIOSTREAMSTS_FLAG_ENABLED))
344 {
345 /* Is a pending disable outstanding? Then disable first. */
346 if (pStream->fStatus & PDMAUDIOSTREAMSTS_FLAG_PENDING_DISABLE)
347 rc = drvAudioStreamControlInternalBackend(pThis, pStream, PDMAUDIOSTREAMCMD_DISABLE);
348
349 if (RT_SUCCESS(rc))
350 rc = drvAudioStreamControlInternalBackend(pThis, pStream, PDMAUDIOSTREAMCMD_ENABLE);
351
352 if (RT_SUCCESS(rc))
353 pStream->fStatus |= PDMAUDIOSTREAMSTS_FLAG_ENABLED;
354 }
355 break;
356 }
357
358 case PDMAUDIOSTREAMCMD_DISABLE:
359 {
360 if (pStream->fStatus & PDMAUDIOSTREAMSTS_FLAG_ENABLED)
361 {
362 /*
363 * For playback (output) streams first mark the host stream as pending disable,
364 * so that the rest of the remaining audio data will be played first before
365 * closing the stream.
366 */
367 if (pStream->enmDir == PDMAUDIODIR_OUT)
368 {
369 LogFunc(("[%s] Pending disable/pause\n", pStream->szName));
370 pStream->fStatus |= PDMAUDIOSTREAMSTS_FLAG_PENDING_DISABLE;
371 }
372
373 /* Can we close the host stream as well (not in pending disable mode)? */
374 if (!(pStream->fStatus & PDMAUDIOSTREAMSTS_FLAG_PENDING_DISABLE))
375 {
376 rc = drvAudioStreamControlInternalBackend(pThis, pStream, PDMAUDIOSTREAMCMD_DISABLE);
377 if (RT_SUCCESS(rc))
378 pStream->fStatus &= ~PDMAUDIOSTREAMSTS_FLAG_ENABLED;
379 }
380 }
381 break;
382 }
383
384 case PDMAUDIOSTREAMCMD_PAUSE:
385 {
386 if (!(pStream->fStatus & PDMAUDIOSTREAMSTS_FLAG_PAUSED))
387 {
388 rc = drvAudioStreamControlInternalBackend(pThis, pStream, PDMAUDIOSTREAMCMD_PAUSE);
389 if (RT_SUCCESS(rc))
390 pStream->fStatus |= PDMAUDIOSTREAMSTS_FLAG_PAUSED;
391 }
392 break;
393 }
394
395 case PDMAUDIOSTREAMCMD_RESUME:
396 {
397 if (pStream->fStatus & PDMAUDIOSTREAMSTS_FLAG_PAUSED)
398 {
399 rc = drvAudioStreamControlInternalBackend(pThis, pStream, PDMAUDIOSTREAMCMD_RESUME);
400 if (RT_SUCCESS(rc))
401 pStream->fStatus &= ~PDMAUDIOSTREAMSTS_FLAG_PAUSED;
402 }
403 break;
404 }
405
406 default:
407 AssertMsgFailed(("Command %s (%RU32) not implemented\n", DrvAudioHlpStreamCmdToStr(enmStreamCmd), enmStreamCmd));
408 rc = VERR_NOT_IMPLEMENTED;
409 break;
410 }
411
412 if (RT_FAILURE(rc))
413 LogFunc(("[%s] Failed with %Rrc\n", pStream->szName, rc));
414
415 return rc;
416}
417
418/**
419 * Controls a stream's backend.
420 * If the stream has no backend available, VERR_NOT_FOUND is returned.
421 *
422 * @returns IPRT status code.
423 * @param pThis Pointer to driver instance.
424 * @param pStream Stream to control.
425 * @param enmStreamCmd Control command.
426 */
427static int drvAudioStreamControlInternalBackend(PDRVAUDIO pThis, PPDMAUDIOSTREAM pStream, PDMAUDIOSTREAMCMD enmStreamCmd)
428{
429 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
430 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
431
432#ifdef LOG_ENABLED
433 char *pszStreamSts = dbgAudioStreamStatusToStr(pStream->fStatus);
434 LogFlowFunc(("[%s] enmStreamCmd=%s, fStatus=%s\n", pStream->szName, DrvAudioHlpStreamCmdToStr(enmStreamCmd), pszStreamSts));
435 RTStrFree(pszStreamSts);
436#endif /* LOG_ENABLED */
437
438 if (!pThis->pHostDrvAudio) /* If not lower driver is configured, bail out. */
439 return VINF_SUCCESS;
440
441 LogRel2(("Audio: %s stream '%s'\n", DrvAudioHlpStreamCmdToStr(enmStreamCmd), pStream->szName));
442
443 int rc = VINF_SUCCESS;
444
445 switch (enmStreamCmd)
446 {
447 case PDMAUDIOSTREAMCMD_ENABLE:
448 {
449 if (!(pStream->fStatus & PDMAUDIOSTREAMSTS_FLAG_ENABLED))
450 rc = pThis->pHostDrvAudio->pfnStreamControl(pThis->pHostDrvAudio, pStream->pvBackend, PDMAUDIOSTREAMCMD_ENABLE);
451 break;
452 }
453
454 case PDMAUDIOSTREAMCMD_DISABLE:
455 {
456 if (pStream->fStatus & PDMAUDIOSTREAMSTS_FLAG_ENABLED)
457 {
458 rc = pThis->pHostDrvAudio->pfnStreamControl(pThis->pHostDrvAudio, pStream->pvBackend, PDMAUDIOSTREAMCMD_DISABLE);
459 if (RT_SUCCESS(rc))
460 AudioMixBufReset(&pStream->Host.MixBuf);
461 }
462 break;
463 }
464
465 case PDMAUDIOSTREAMCMD_PAUSE:
466 {
467 /* Only pause if the stream is enabled. */
468 if (!(pStream->fStatus & PDMAUDIOSTREAMSTS_FLAG_ENABLED))
469 break;
470
471 if (!(pStream->fStatus & PDMAUDIOSTREAMSTS_FLAG_PAUSED))
472 rc = pThis->pHostDrvAudio->pfnStreamControl(pThis->pHostDrvAudio, pStream->pvBackend, PDMAUDIOSTREAMCMD_PAUSE);
473 break;
474 }
475
476 case PDMAUDIOSTREAMCMD_RESUME:
477 {
478 /* Only need to resume if the stream is enabled. */
479 if (!(pStream->fStatus & PDMAUDIOSTREAMSTS_FLAG_ENABLED))
480 break;
481
482 if (pStream->fStatus & PDMAUDIOSTREAMSTS_FLAG_PAUSED)
483 rc = pThis->pHostDrvAudio->pfnStreamControl(pThis->pHostDrvAudio, pStream->pvBackend, PDMAUDIOSTREAMCMD_RESUME);
484 break;
485 }
486
487 case PDMAUDIOSTREAMCMD_DRAIN:
488 {
489 rc = pThis->pHostDrvAudio->pfnStreamControl(pThis->pHostDrvAudio, pStream->pvBackend, PDMAUDIOSTREAMCMD_DRAIN);
490 break;
491 }
492
493 default:
494 {
495 AssertMsgFailed(("Command %RU32 not implemented\n", enmStreamCmd));
496 rc = VERR_NOT_IMPLEMENTED;
497 break;
498 }
499 }
500
501 if (RT_FAILURE(rc))
502 {
503 if ( rc != VERR_NOT_IMPLEMENTED
504 && rc != VERR_NOT_SUPPORTED)
505 LogRel(("Audio: %s stream '%s' failed with %Rrc\n", DrvAudioHlpStreamCmdToStr(enmStreamCmd), pStream->szName, rc));
506
507 LogFunc(("[%s] %s failed with %Rrc\n", pStream->szName, DrvAudioHlpStreamCmdToStr(enmStreamCmd), rc));
508 }
509
510 return rc;
511}
512
513/**
514 * Initializes an audio stream with a given host and guest stream configuration.
515 *
516 * @returns IPRT status code.
517 * @param pThis Pointer to driver instance.
518 * @param pStream Stream to initialize.
519 * @param pCfgHost Stream configuration to use for the host side (backend).
520 * @param pCfgGuest Stream configuration to use for the guest side.
521 */
522static int drvAudioStreamInitInternal(PDRVAUDIO pThis,
523 PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfgHost, PPDMAUDIOSTREAMCFG pCfgGuest)
524{
525 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
526 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
527 AssertPtrReturn(pCfgHost, VERR_INVALID_POINTER);
528 AssertPtrReturn(pCfgGuest, VERR_INVALID_POINTER);
529
530 /*
531 * Init host stream.
532 */
533
534 /* Set the host's default audio data layout. */
535 pCfgHost->enmLayout = PDMAUDIOSTREAMLAYOUT_NON_INTERLEAVED;
536
537#ifdef DEBUG
538 LogFunc(("[%s] Requested host format:\n", pStream->szName));
539 DrvAudioHlpStreamCfgPrint(pCfgHost);
540#endif
541
542 LogRel2(("Audio: Creating stream '%s'\n", pStream->szName));
543 LogRel2(("Audio: Guest %s format for '%s': %RU32Hz, %RU8%s, %RU8 %s\n",
544 pCfgGuest->enmDir == PDMAUDIODIR_IN ? "recording" : "playback", pStream->szName,
545 pCfgGuest->Props.uHz, pCfgGuest->Props.cBytes * 8, pCfgGuest->Props.fSigned ? "S" : "U",
546 pCfgGuest->Props.cChannels, pCfgGuest->Props.cChannels == 1 ? "Channel" : "Channels"));
547 LogRel2(("Audio: Requested host %s format for '%s': %RU32Hz, %RU8%s, %RU8 %s\n",
548 pCfgHost->enmDir == PDMAUDIODIR_IN ? "recording" : "playback", pStream->szName,
549 pCfgHost->Props.uHz, pCfgHost->Props.cBytes * 8, pCfgHost->Props.fSigned ? "S" : "U",
550 pCfgHost->Props.cChannels, pCfgHost->Props.cChannels == 1 ? "Channel" : "Channels"));
551
552 PDMAUDIOSTREAMCFG CfgHostAcq;
553 int rc = drvAudioStreamCreateInternalBackend(pThis, pStream, pCfgHost, &CfgHostAcq);
554 if (RT_FAILURE(rc))
555 return rc;
556
557#ifdef DEBUG
558 LogFunc(("[%s] Acquired host format:\n", pStream->szName));
559 DrvAudioHlpStreamCfgPrint(&CfgHostAcq);
560#endif
561
562 LogRel2(("Audio: Acquired host %s format for '%s': %RU32Hz, %RU8%s, %RU8 %s\n",
563 CfgHostAcq.enmDir == PDMAUDIODIR_IN ? "recording" : "playback", pStream->szName,
564 CfgHostAcq.Props.uHz, CfgHostAcq.Props.cBytes * 8, CfgHostAcq.Props.fSigned ? "S" : "U",
565 CfgHostAcq.Props.cChannels, CfgHostAcq.Props.cChannels == 1 ? "Channel" : "Channels"));
566
567 /* Let the user know if the backend changed some of the tweakable values. */
568 if (CfgHostAcq.Backend.cfBufferSize != pCfgHost->Backend.cfBufferSize)
569 LogRel2(("Audio: Backend changed buffer size from %RU64ms (%RU32 frames) to %RU64ms (%RU32 frames)\n",
570 DrvAudioHlpFramesToMilli(pCfgHost->Backend.cfBufferSize, &pCfgHost->Props), pCfgHost->Backend.cfBufferSize,
571 DrvAudioHlpFramesToMilli(CfgHostAcq.Backend.cfBufferSize, &CfgHostAcq.Props), CfgHostAcq.Backend.cfBufferSize));
572
573 if (CfgHostAcq.Backend.cfPeriod != pCfgHost->Backend.cfPeriod)
574 LogRel2(("Audio: Backend changed period size from %RU64ms (%RU32 frames) to %RU64ms (%RU32 frames)\n",
575 DrvAudioHlpFramesToMilli(pCfgHost->Backend.cfPeriod, &pCfgHost->Props), pCfgHost->Backend.cfPeriod,
576 DrvAudioHlpFramesToMilli(CfgHostAcq.Backend.cfPeriod, &CfgHostAcq.Props), CfgHostAcq.Backend.cfPeriod));
577
578 if (CfgHostAcq.Backend.cfPreBuf != pCfgHost->Backend.cfPreBuf)
579 LogRel2(("Audio: Backend changed pre-buffering size from %RU64ms (%RU32 frames) to %RU64ms (%RU32 frames)\n",
580 DrvAudioHlpFramesToMilli(pCfgHost->Backend.cfPreBuf, &pCfgHost->Props), pCfgHost->Backend.cfPreBuf,
581 DrvAudioHlpFramesToMilli(CfgHostAcq.Backend.cfPreBuf, &CfgHostAcq.Props), CfgHostAcq.Backend.cfPreBuf));
582 /*
583 * Configure host buffers.
584 */
585
586 /* Check if the backend did return sane values and correct if necessary.
587 * Should never happen with our own backends, but you never know ... */
588 if (CfgHostAcq.Backend.cfBufferSize < CfgHostAcq.Backend.cfPreBuf)
589 {
590 LogRel2(("Audio: Warning: Pre-buffering size (%RU32 frames) of stream '%s' does not match buffer size (%RU32 frames), "
591 "setting pre-buffering size to %RU32 frames\n",
592 CfgHostAcq.Backend.cfPreBuf, pStream->szName, CfgHostAcq.Backend.cfBufferSize, CfgHostAcq.Backend.cfBufferSize));
593 CfgHostAcq.Backend.cfPreBuf = CfgHostAcq.Backend.cfBufferSize;
594 }
595
596 if (CfgHostAcq.Backend.cfPeriod > CfgHostAcq.Backend.cfBufferSize)
597 {
598 LogRel2(("Audio: Warning: Period size (%RU32 frames) of stream '%s' does not match buffer size (%RU32 frames), setting to %RU32 frames\n",
599 CfgHostAcq.Backend.cfPeriod, pStream->szName, CfgHostAcq.Backend.cfBufferSize, CfgHostAcq.Backend.cfBufferSize));
600 CfgHostAcq.Backend.cfPeriod = CfgHostAcq.Backend.cfBufferSize;
601 }
602
603 uint64_t msBufferSize = DrvAudioHlpFramesToMilli(CfgHostAcq.Backend.cfBufferSize, &pCfgHost->Props);
604
605 LogRel2(("Audio: Buffer size of stream '%s' is %RU64ms (%RU32 frames)\n",
606 pStream->szName, msBufferSize, CfgHostAcq.Backend.cfBufferSize));
607
608 /* If no own pre-buffer is set, let the backend choose. */
609 uint64_t msPreBuf = DrvAudioHlpFramesToMilli(CfgHostAcq.Backend.cfPreBuf, &pCfgHost->Props);
610 LogRel2(("Audio: Pre-buffering size of stream '%s' is %RU64ms (%RU32 frames)\n",
611 pStream->szName, msPreBuf, CfgHostAcq.Backend.cfPreBuf));
612
613 /* Make sure the configured buffer size by the backend at least can hold the configured latency. */
614 const uint32_t msPeriod = DrvAudioHlpFramesToMilli(CfgHostAcq.Backend.cfPeriod, &pCfgHost->Props);
615
616 LogRel2(("Audio: Period size of stream '%s' is %RU64ms (%RU32 frames)\n",
617 pStream->szName, msPeriod, CfgHostAcq.Backend.cfPeriod));
618
619 /* Set set host buffer size multiplicator. */
620 const unsigned cHstBufferFactor = 2; /** @todo Make this configurable. */
621
622 /* Destroy any former mixing buffer. */
623 AudioMixBufDestroy(&pStream->Host.MixBuf);
624
625 /* Make sure to (re-)set the host buffer's shift size. */
626 CfgHostAcq.Props.cShift = PDMAUDIOPCMPROPS_MAKE_SHIFT_PARMS(CfgHostAcq.Props.cBytes, CfgHostAcq.Props.cChannels);
627
628 rc = AudioMixBufInit(&pStream->Host.MixBuf, pStream->szName, &CfgHostAcq.Props,
629 CfgHostAcq.Backend.cfBufferSize * cHstBufferFactor);
630 AssertRC(rc);
631
632 /* Make a copy of the acquired host stream configuration. */
633 rc = DrvAudioHlpStreamCfgCopy(&pStream->Host.Cfg, &CfgHostAcq);
634 AssertRC(rc);
635
636 /*
637 * Init guest stream.
638 */
639
640 if (pCfgGuest->Device.uSchedulingHintMs)
641 LogRel2(("Audio: Stream '%s' got a scheduling hint of %RU32ms (%RU32 bytes)\n",
642 pStream->szName, pCfgGuest->Device.uSchedulingHintMs,
643 DrvAudioHlpMilliToBytes(pCfgGuest->Device.uSchedulingHintMs, &pCfgGuest->Props)));
644
645 /* Destroy any former mixing buffer. */
646 AudioMixBufDestroy(&pStream->Guest.MixBuf);
647
648 /* Set the guests's default audio data layout. */
649 pCfgGuest->enmLayout = PDMAUDIOSTREAMLAYOUT_NON_INTERLEAVED;
650
651 /* Make sure to (re-)set the guest buffer's shift size. */
652 pCfgGuest->Props.cShift = PDMAUDIOPCMPROPS_MAKE_SHIFT_PARMS(pCfgGuest->Props.cBytes, pCfgGuest->Props.cChannels);
653
654 /* Set set guest buffer size multiplicator. */
655 const unsigned cGstBufferFactor = 4; /** @todo Make this configurable. */
656
657 rc = AudioMixBufInit(&pStream->Guest.MixBuf, pStream->szName, &pCfgGuest->Props,
658 CfgHostAcq.Backend.cfBufferSize * cGstBufferFactor);
659 AssertRC(rc);
660
661 /* Make a copy of the guest stream configuration. */
662 rc = DrvAudioHlpStreamCfgCopy(&pStream->Guest.Cfg, pCfgGuest);
663 AssertRC(rc);
664
665 if (RT_FAILURE(rc))
666 LogRel(("Audio: Creating stream '%s' failed with %Rrc\n", pStream->szName, rc));
667
668 if (pCfgGuest->enmDir == PDMAUDIODIR_IN)
669 {
670 /* Host (Parent) -> Guest (Child). */
671 rc = AudioMixBufLinkTo(&pStream->Host.MixBuf, &pStream->Guest.MixBuf);
672 AssertRC(rc);
673 }
674 else
675 {
676 /* Guest (Parent) -> Host (Child). */
677 rc = AudioMixBufLinkTo(&pStream->Guest.MixBuf, &pStream->Host.MixBuf);
678 AssertRC(rc);
679 }
680
681#ifdef VBOX_WITH_STATISTICS
682 char szStatName[255];
683
684 if (pCfgGuest->enmDir == PDMAUDIODIR_IN)
685 {
686 RTStrPrintf(szStatName, sizeof(szStatName), "Guest/%s/BytesElapsed", pStream->szName);
687 PDMDrvHlpSTAMRegCounterEx(pThis->pDrvIns, &pStream->In.Stats.BytesElapsed,
688 szStatName, STAMUNIT_BYTES, "Elapsed bytes read.");
689
690 RTStrPrintf(szStatName, sizeof(szStatName), "Guest/%s/BytesRead", pStream->szName);
691 PDMDrvHlpSTAMRegCounterEx(pThis->pDrvIns, &pStream->In.Stats.BytesTotalRead,
692 szStatName, STAMUNIT_BYTES, "Total bytes read.");
693
694 RTStrPrintf(szStatName, sizeof(szStatName), "Host/%s/FramesCaptured", pStream->szName);
695 PDMDrvHlpSTAMRegCounterEx(pThis->pDrvIns, &pStream->In.Stats.FramesCaptured,
696 szStatName, STAMUNIT_COUNT, "Total frames captured.");
697 }
698 else if (pCfgGuest->enmDir == PDMAUDIODIR_OUT)
699 {
700 RTStrPrintf(szStatName, sizeof(szStatName), "Guest/%s/BytesElapsed", pStream->szName);
701 PDMDrvHlpSTAMRegCounterEx(pThis->pDrvIns, &pStream->Out.Stats.BytesElapsed,
702 szStatName, STAMUNIT_BYTES, "Elapsed bytes written.");
703
704 RTStrPrintf(szStatName, sizeof(szStatName), "Guest/%s/BytesWritten", pStream->szName);
705 PDMDrvHlpSTAMRegCounterEx(pThis->pDrvIns, &pStream->Out.Stats.BytesTotalWritten,
706 szStatName, STAMUNIT_BYTES, "Total bytes written.");
707
708 RTStrPrintf(szStatName, sizeof(szStatName), "Host/%s/FramesPlayed", pStream->szName);
709 PDMDrvHlpSTAMRegCounterEx(pThis->pDrvIns, &pStream->Out.Stats.FramesPlayed,
710 szStatName, STAMUNIT_COUNT, "Total frames played.");
711 }
712 else
713 AssertFailed();
714#endif
715
716 LogFlowFunc(("[%s] Returning %Rrc\n", pStream->szName, rc));
717 return rc;
718}
719
720/**
721 * Frees an audio stream and its allocated resources.
722 *
723 * @param pStream Audio stream to free.
724 * After this call the pointer will not be valid anymore.
725 */
726static void drvAudioStreamFree(PPDMAUDIOSTREAM pStream)
727{
728 if (!pStream)
729 return;
730
731 if (pStream->pvBackend)
732 {
733 Assert(pStream->cbBackend);
734 RTMemFree(pStream->pvBackend);
735 pStream->pvBackend = NULL;
736 }
737
738 RTMemFree(pStream);
739 pStream = NULL;
740}
741
742#ifdef VBOX_WITH_AUDIO_CALLBACKS
743/**
744 * Schedules a re-initialization of all current audio streams.
745 * The actual re-initialization will happen at some later point in time.
746 *
747 * @returns IPRT status code.
748 * @param pThis Pointer to driver instance.
749 */
750static int drvAudioScheduleReInitInternal(PDRVAUDIO pThis)
751{
752 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
753
754 LogFunc(("\n"));
755
756 /* Mark all host streams to re-initialize. */
757 PPDMAUDIOSTREAM pStream;
758 RTListForEach(&pThis->lstStreams, pStream, PDMAUDIOSTREAM, Node)
759 pStream->fStatus |= PDMAUDIOSTREAMSTS_FLAG_PENDING_REINIT;
760
761# ifdef VBOX_WITH_AUDIO_ENUM
762 /* Re-enumerate all host devices as soon as possible. */
763 pThis->fEnumerateDevices = true;
764# endif
765
766 return VINF_SUCCESS;
767}
768#endif /* VBOX_WITH_AUDIO_CALLBACKS */
769
770/**
771 * Re-initializes an audio stream with its existing host and guest stream configuration.
772 * This might be the case if the backend told us we need to re-initialize because something
773 * on the host side has changed.
774 *
775 * @returns IPRT status code.
776 * @param pThis Pointer to driver instance.
777 * @param pStream Stream to re-initialize.
778 */
779static int drvAudioStreamReInitInternal(PDRVAUDIO pThis, PPDMAUDIOSTREAM pStream)
780{
781 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
782 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
783
784 LogFlowFunc(("[%s]\n", pStream->szName));
785
786 /*
787 * Gather current stream status.
788 */
789 bool fIsEnabled = RT_BOOL(pStream->fStatus & PDMAUDIOSTREAMSTS_FLAG_ENABLED); /* Stream is enabled? */
790
791 /*
792 * Destroy and re-create stream on backend side.
793 */
794 int rc = drvAudioStreamControlInternalBackend(pThis, pStream, PDMAUDIOSTREAMCMD_DISABLE);
795 if (RT_SUCCESS(rc))
796 {
797 rc = drvAudioStreamDestroyInternalBackend(pThis, pStream);
798 if (RT_SUCCESS(rc))
799 {
800 rc = drvAudioStreamCreateInternalBackend(pThis, pStream, &pStream->Host.Cfg, NULL /* pCfgAcq */);
801 /** @todo Validate (re-)acquired configuration with pStream->Host.Cfg? */
802 }
803 }
804
805 /* Do the internal reset. */
806 drvAudioStreamResetInternal(pThis, pStream);
807
808 /*
809 * Restore previous stream state.
810 */
811 if (fIsEnabled)
812 rc = drvAudioStreamControlInternalBackend(pThis, pStream, PDMAUDIOSTREAMCMD_ENABLE);
813
814 if (RT_FAILURE(rc))
815 LogRel(("Audio: Re-initializing stream '%s' failed with %Rrc\n", pStream->szName, rc));
816
817 LogFunc(("[%s] Returning %Rrc\n", pStream->szName, rc));
818 return rc;
819}
820
821static void drvAudioStreamResetInternal(PDRVAUDIO pThis, PPDMAUDIOSTREAM pStream)
822{
823 RT_NOREF(pThis);
824
825 AudioMixBufReset(&pStream->Guest.MixBuf);
826 AudioMixBufReset(&pStream->Host.MixBuf);
827
828#ifdef VBOX_WITH_STATISTICS
829 /*
830 * Reset statistics.
831 */
832 if (pStream->enmDir == PDMAUDIODIR_IN)
833 {
834 STAM_COUNTER_RESET(&pStream->In.Stats.BytesElapsed);
835 STAM_COUNTER_RESET(&pStream->In.Stats.BytesTotalRead);
836 STAM_COUNTER_RESET(&pStream->In.Stats.FramesCaptured);
837 }
838 else if (pStream->enmDir == PDMAUDIODIR_OUT)
839 {
840 STAM_COUNTER_RESET(&pStream->Out.Stats.BytesElapsed);
841 STAM_COUNTER_RESET(&pStream->Out.Stats.BytesTotalWritten);
842 STAM_COUNTER_RESET(&pStream->Out.Stats.FramesPlayed);
843 }
844 else
845 AssertFailed();
846#endif
847}
848
849/**
850 * @interface_method_impl{PDMIAUDIOCONNECTOR,pfnStreamWrite}
851 */
852static DECLCALLBACK(int) drvAudioStreamWrite(PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOSTREAM pStream,
853 const void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten)
854{
855 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
856 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
857 AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
858 AssertReturn(cbBuf, VERR_INVALID_PARAMETER);
859 /* pcbWritten is optional. */
860
861 PDRVAUDIO pThis = PDMIAUDIOCONNECTOR_2_DRVAUDIO(pInterface);
862
863 AssertMsg(pStream->enmDir == PDMAUDIODIR_OUT,
864 ("Stream '%s' is not an output stream and therefore cannot be written to (direction is 0x%x)\n",
865 pStream->szName, pStream->enmDir));
866
867 AssertMsg(DrvAudioHlpBytesIsAligned(cbBuf, &pStream->Guest.Cfg.Props),
868 ("Writing audio data (%RU32 bytes) to stream '%s' is not properly aligned\n", cbBuf, pStream->szName));
869
870 uint32_t cbWrittenTotal = 0;
871
872 int rc = RTCritSectEnter(&pThis->CritSect);
873 if (RT_FAILURE(rc))
874 return rc;
875
876#ifdef VBOX_WITH_STATISTICS
877 STAM_PROFILE_ADV_START(&pThis->Stats.DelayOut, out);
878#endif
879
880#ifdef LOG_ENABLED
881 char *pszStreamSts = dbgAudioStreamStatusToStr(pStream->fStatus);
882 AssertPtr(pszStreamSts);
883#endif
884
885 do
886 {
887 if ( !pThis->Out.fEnabled
888 || !DrvAudioHlpStreamStatusIsReady(pStream->fStatus))
889 {
890 rc = VERR_AUDIO_STREAM_NOT_READY;
891 break;
892 }
893
894 if ( pThis->pHostDrvAudio
895 && pThis->pHostDrvAudio->pfnGetStatus
896 && pThis->pHostDrvAudio->pfnGetStatus(pThis->pHostDrvAudio, PDMAUDIODIR_OUT) != PDMAUDIOBACKENDSTS_RUNNING)
897 {
898 rc = VERR_AUDIO_STREAM_NOT_READY;
899 break;
900 }
901
902 const uint32_t cbFree = AudioMixBufFreeBytes(&pStream->Host.MixBuf);
903 if (cbFree < cbBuf)
904 LogRel2(("Audio: Lost audio output (%RU64ms, %RU32 free but needs %RU32) due to full host stream buffer '%s'\n",
905 DrvAudioHlpBytesToMilli(cbBuf - cbFree, &pStream->Host.Cfg.Props), cbFree, cbBuf, pStream->szName));
906
907 uint32_t cbToWrite = RT_MIN(cbBuf, cbFree);
908 if (cbToWrite > cbBuf) /* Paranoia. */
909 cbToWrite = cbBuf;
910
911 if (!cbToWrite)
912 {
913 rc = VERR_BUFFER_OVERFLOW;
914 break;
915 }
916
917 /* We use the guest side mixing buffer as an intermediate buffer to do some
918 * (first) processing (if needed), so always write the incoming data at offset 0. */
919 uint32_t cfGstWritten = 0;
920 rc = AudioMixBufWriteAt(&pStream->Guest.MixBuf, 0 /* offFrames */, pvBuf, cbToWrite, &cfGstWritten);
921 if ( RT_FAILURE(rc)
922 || !cfGstWritten)
923 {
924 AssertMsgFailed(("[%s] Write failed: cbToWrite=%RU32, cfWritten=%RU32, rc=%Rrc\n",
925 pStream->szName, cbToWrite, cfGstWritten, rc));
926 break;
927 }
928
929 if (pThis->Out.Cfg.Dbg.fEnabled)
930 DrvAudioHlpFileWrite(pStream->Out.Dbg.pFileStreamWrite, pvBuf, cbToWrite, 0 /* fFlags */);
931
932#ifdef VBOX_WITH_STATISTICS
933 STAM_COUNTER_ADD(&pThis->Stats.TotalFramesWritten, cfGstWritten);
934#endif
935 uint32_t cfGstMixed = 0;
936 if (cfGstWritten)
937 {
938 int rc2 = AudioMixBufMixToParentEx(&pStream->Guest.MixBuf, 0 /* cSrcOffset */, cfGstWritten /* cSrcFrames */,
939 &cfGstMixed /* pcSrcMixed */);
940 if (RT_FAILURE(rc2))
941 {
942 AssertMsgFailed(("[%s] Mixing failed: cbToWrite=%RU32, cfWritten=%RU32, cfMixed=%RU32, rc=%Rrc\n",
943 pStream->szName, cbToWrite, cfGstWritten, cfGstMixed, rc2));
944 }
945 else
946 {
947 Log3Func(("[%s] Buffer: Writing %RU32 frames (%RU64ms), now filled with %RU64ms -- %RU8%%\n",
948 pStream->szName, cfGstWritten, DrvAudioHlpFramesToMilli(cfGstWritten, &pStream->Guest.Cfg.Props),
949 DrvAudioHlpFramesToMilli(AudioMixBufUsed(&pStream->Host.MixBuf), &pStream->Host.Cfg.Props),
950 AudioMixBufUsed(&pStream->Host.MixBuf) * 100 / AudioMixBufSize(&pStream->Host.MixBuf)));
951
952 pStream->tsLastReadWrittenNs = RTTimeNanoTS();
953
954 /* Keep going. */
955 }
956
957 if (RT_SUCCESS(rc))
958 rc = rc2;
959
960 cbWrittenTotal = AUDIOMIXBUF_F2B(&pStream->Guest.MixBuf, cfGstWritten);
961#ifdef DEBUG
962 if (pStream->fThresholdReached)
963 pStream->Out.Dbg.cbJitterWrittenPlayed += cbWrittenTotal;
964#endif
965
966#ifdef VBOX_WITH_STATISTICS
967 STAM_COUNTER_ADD(&pThis->Stats.TotalFramesMixedOut, cfGstMixed);
968 Assert(cfGstWritten >= cfGstMixed);
969 STAM_COUNTER_ADD(&pThis->Stats.TotalFramesLostOut, cfGstWritten - cfGstMixed);
970 STAM_COUNTER_ADD(&pThis->Stats.TotalBytesWritten, cbWrittenTotal);
971 STAM_COUNTER_ADD(&pStream->Out.Stats.BytesTotalWritten, cbWrittenTotal);
972#endif
973 }
974
975 Log3Func(("[%s] cbToWrite=%RU32, cfHstUsed=%RU32, cfHstfLive=%RU32, cfGstWritten=%RU32, cfGstMixed=%RU32, rc=%Rrc\n",
976 pStream->szName, cbToWrite, AudioMixBufUsed(&pStream->Host.MixBuf),
977 AudioMixBufLive(&pStream->Host.MixBuf), cfGstWritten, cfGstMixed, rc));
978
979 } while (0);
980
981 Log3Func(("[%s] cbWrittenTotal=%RU32, rc=%Rrc\n", pStream->szName, cbWrittenTotal, rc));
982
983#ifdef LOG_ENABLED
984 RTStrFree(pszStreamSts);
985#endif
986
987 int rc2 = RTCritSectLeave(&pThis->CritSect);
988 if (RT_SUCCESS(rc))
989 rc = rc2;
990
991 if (RT_SUCCESS(rc))
992 {
993 if (pcbWritten)
994 *pcbWritten = cbWrittenTotal;
995 }
996
997 return rc;
998}
999
1000/**
1001 * @interface_method_impl{PDMIAUDIOCONNECTOR,pfnStreamRetain}
1002 */
1003static DECLCALLBACK(uint32_t) drvAudioStreamRetain(PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOSTREAM pStream)
1004{
1005 AssertPtrReturn(pInterface, UINT32_MAX);
1006 AssertPtrReturn(pStream, UINT32_MAX);
1007
1008 NOREF(pInterface);
1009
1010 return ++pStream->cRefs;
1011}
1012
1013/**
1014 * @interface_method_impl{PDMIAUDIOCONNECTOR,pfnStreamRelease}
1015 */
1016static DECLCALLBACK(uint32_t) drvAudioStreamRelease(PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOSTREAM pStream)
1017{
1018 AssertPtrReturn(pInterface, UINT32_MAX);
1019 AssertPtrReturn(pStream, UINT32_MAX);
1020
1021 NOREF(pInterface);
1022
1023 if (pStream->cRefs > 1) /* 1 reference always is kept by this audio driver. */
1024 pStream->cRefs--;
1025
1026 return pStream->cRefs;
1027}
1028
1029/**
1030 * @interface_method_impl{PDMIAUDIOCONNECTOR,pfnStreamIterate}
1031 */
1032static DECLCALLBACK(int) drvAudioStreamIterate(PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOSTREAM pStream)
1033{
1034 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
1035 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
1036
1037 PDRVAUDIO pThis = PDMIAUDIOCONNECTOR_2_DRVAUDIO(pInterface);
1038
1039 int rc = RTCritSectEnter(&pThis->CritSect);
1040 if (RT_FAILURE(rc))
1041 return rc;
1042
1043 rc = drvAudioStreamIterateInternal(pThis, pStream);
1044
1045 int rc2 = RTCritSectLeave(&pThis->CritSect);
1046 if (RT_SUCCESS(rc))
1047 rc = rc2;
1048
1049 if (RT_FAILURE(rc))
1050 LogFlowFuncLeaveRC(rc);
1051
1052 return rc;
1053}
1054
1055/**
1056 * Does one iteration of an audio stream.
1057 * This function gives the backend the chance of iterating / altering data and
1058 * does the actual mixing between the guest <-> host mixing buffers.
1059 *
1060 * @returns IPRT status code.
1061 * @param pThis Pointer to driver instance.
1062 * @param pStream Stream to iterate.
1063 */
1064static int drvAudioStreamIterateInternal(PDRVAUDIO pThis, PPDMAUDIOSTREAM pStream)
1065{
1066 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
1067
1068 if (!pThis->pHostDrvAudio)
1069 return VINF_SUCCESS;
1070
1071 if (!pStream)
1072 return VINF_SUCCESS;
1073
1074 int rc;
1075
1076 /* Is the stream scheduled for re-initialization? Do so now. */
1077 if (pStream->fStatus & PDMAUDIOSTREAMSTS_FLAG_PENDING_REINIT)
1078 {
1079#ifdef VBOX_WITH_AUDIO_ENUM
1080 if (pThis->fEnumerateDevices)
1081 {
1082 /* Re-enumerate all host devices. */
1083 drvAudioDevicesEnumerateInternal(pThis, true /* fLog */, NULL /* pDevEnum */);
1084
1085 pThis->fEnumerateDevices = false;
1086 }
1087#endif /* VBOX_WITH_AUDIO_ENUM */
1088
1089 /* Remove the pending re-init flag in any case, regardless whether the actual re-initialization succeeded
1090 * or not. If it failed, the backend needs to notify us again to try again at some later point in time. */
1091 pStream->fStatus &= ~PDMAUDIOSTREAMSTS_FLAG_PENDING_REINIT;
1092
1093 rc = drvAudioStreamReInitInternal(pThis, pStream);
1094 if (RT_FAILURE(rc))
1095 return rc;
1096 }
1097
1098#ifdef LOG_ENABLED
1099 char *pszStreamSts = dbgAudioStreamStatusToStr(pStream->fStatus);
1100 Log3Func(("[%s] fStatus=%s\n", pStream->szName, pszStreamSts));
1101 RTStrFree(pszStreamSts);
1102#endif /* LOG_ENABLED */
1103
1104 /* Not enabled or paused? Skip iteration. */
1105 if ( !(pStream->fStatus & PDMAUDIOSTREAMSTS_FLAG_ENABLED)
1106 || (pStream->fStatus & PDMAUDIOSTREAMSTS_FLAG_PAUSED))
1107 {
1108 return VINF_SUCCESS;
1109 }
1110
1111 /* Whether to try closing a pending to close stream. */
1112 bool fTryClosePending = false;
1113
1114 do
1115 {
1116 rc = pThis->pHostDrvAudio->pfnStreamIterate(pThis->pHostDrvAudio, pStream->pvBackend);
1117 if (RT_FAILURE(rc))
1118 break;
1119
1120 if (pStream->enmDir == PDMAUDIODIR_OUT)
1121 {
1122 /* No audio frames to transfer from guest to host (anymore)?
1123 * Then try closing this stream if marked so in the next block. */
1124 const uint32_t cfLive = AudioMixBufLive(&pStream->Host.MixBuf);
1125 fTryClosePending = cfLive == 0;
1126 Log3Func(("[%s] fTryClosePending=%RTbool, cfLive=%RU32\n", pStream->szName, fTryClosePending, cfLive));
1127 }
1128
1129 /* Has the host stream marked as pending to disable?
1130 * Try disabling the stream then. */
1131 if ( pStream->fStatus & PDMAUDIOSTREAMSTS_FLAG_PENDING_DISABLE
1132 && fTryClosePending)
1133 {
1134 /* Tell the backend to drain the stream, that is, play the remaining (buffered) data
1135 * on the backend side. */
1136 rc = drvAudioStreamControlInternalBackend(pThis, pStream, PDMAUDIOSTREAMCMD_DRAIN);
1137 if (rc == VERR_NOT_SUPPORTED) /* Not all backends support draining. */
1138 rc = VINF_SUCCESS;
1139
1140 if (RT_SUCCESS(rc))
1141 {
1142 if (pThis->pHostDrvAudio->pfnStreamGetPending) /* Optional to implement. */
1143 {
1144 const uint32_t cxPending = pThis->pHostDrvAudio->pfnStreamGetPending(pThis->pHostDrvAudio, pStream->pvBackend);
1145 Log3Func(("[%s] cxPending=%RU32\n", pStream->szName, cxPending));
1146
1147 /* Only try close pending if no audio data is pending on the backend-side anymore. */
1148 fTryClosePending = cxPending == 0;
1149 }
1150
1151 if (fTryClosePending)
1152 {
1153 LogFunc(("[%s] Closing pending stream\n", pStream->szName));
1154 rc = drvAudioStreamControlInternalBackend(pThis, pStream, PDMAUDIOSTREAMCMD_DISABLE);
1155 if (RT_SUCCESS(rc))
1156 {
1157 pStream->fStatus &= ~(PDMAUDIOSTREAMSTS_FLAG_ENABLED | PDMAUDIOSTREAMSTS_FLAG_PENDING_DISABLE);
1158 }
1159 else
1160 LogFunc(("[%s] Backend vetoed against closing pending input stream, rc=%Rrc\n", pStream->szName, rc));
1161 }
1162 }
1163 }
1164
1165 } while (0);
1166
1167 /* Update timestamps. */
1168 pStream->tsLastIteratedNs = RTTimeNanoTS();
1169
1170 if (RT_FAILURE(rc))
1171 LogFunc(("[%s] Failed with %Rrc\n", pStream->szName, rc));
1172
1173 return rc;
1174}
1175
1176/**
1177 * Plays an audio host output stream which has been configured for non-interleaved (layout) data.
1178 *
1179 * @return IPRT status code.
1180 * @param pThis Pointer to driver instance.
1181 * @param pStream Stream to play.
1182 * @param cfToPlay Number of audio frames to play.
1183 * @param pcfPlayed Returns number of audio frames played. Optional.
1184 */
1185static int drvAudioStreamPlayNonInterleaved(PDRVAUDIO pThis,
1186 PPDMAUDIOSTREAM pStream, uint32_t cfToPlay, uint32_t *pcfPlayed)
1187{
1188 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
1189 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
1190 /* pcfPlayed is optional. */
1191
1192 if (!cfToPlay)
1193 {
1194 if (pcfPlayed)
1195 *pcfPlayed = 0;
1196 return VINF_SUCCESS;
1197 }
1198
1199 /* Sanity. */
1200 Assert(pStream->enmDir == PDMAUDIODIR_OUT);
1201 Assert(pStream->Host.Cfg.enmLayout == PDMAUDIOSTREAMLAYOUT_NON_INTERLEAVED);
1202
1203 int rc = VINF_SUCCESS;
1204
1205 uint32_t cfPlayedTotal = 0;
1206
1207 AssertPtr(pThis->pHostDrvAudio->pfnStreamGetWritable);
1208 uint32_t cfWritable = AUDIOMIXBUF_B2F(&pStream->Host.MixBuf,
1209 pThis->pHostDrvAudio->pfnStreamGetWritable(pThis->pHostDrvAudio, pStream->pvBackend));
1210
1211 Log3Func(("[%s] cfToPlay=%RU32 (%RU64ms), cfWritable=%RU32 (%RU64ms)\n", pStream->szName,
1212 cfToPlay, DrvAudioHlpFramesToMilli(cfToPlay, &pStream->Host.Cfg.Props),
1213 cfWritable, DrvAudioHlpFramesToMilli(cfWritable, &pStream->Host.Cfg.Props)));
1214
1215 if (cfWritable)
1216 {
1217 if (cfToPlay > cfWritable) /* More frames available than we can write? Limit. */
1218 cfToPlay = cfWritable;
1219
1220 if (cfToPlay)
1221 {
1222 uint8_t auBuf[256]; /** @todo Get rid of this here. */
1223
1224 uint32_t cfLeft = cfToPlay;
1225 uint32_t cbChunk = sizeof(auBuf);
1226
1227 while (cfLeft)
1228 {
1229 uint32_t cfRead = 0;
1230 rc = AudioMixBufAcquireReadBlock(&pStream->Host.MixBuf,
1231 auBuf, RT_MIN(cbChunk, AUDIOMIXBUF_F2B(&pStream->Host.MixBuf, cfLeft)),
1232 &cfRead);
1233 if (RT_FAILURE(rc))
1234 break;
1235
1236 uint32_t cbRead = AUDIOMIXBUF_F2B(&pStream->Host.MixBuf, cfRead);
1237 Assert(cbRead <= cbChunk);
1238
1239 uint32_t cfPlayed = 0;
1240 uint32_t cbPlayed = 0;
1241 rc = pThis->pHostDrvAudio->pfnStreamPlay(pThis->pHostDrvAudio, pStream->pvBackend,
1242 auBuf, cbRead, &cbPlayed);
1243 if ( RT_SUCCESS(rc)
1244 && cbPlayed)
1245 {
1246 if (pThis->Out.Cfg.Dbg.fEnabled)
1247 DrvAudioHlpFileWrite(pStream->Out.Dbg.pFilePlayNonInterleaved, auBuf, cbPlayed, 0 /* fFlags */);
1248
1249 if (cbRead != cbPlayed)
1250 LogRel2(("Audio: Host stream '%s' played wrong amount (%RU32 bytes read but played %RU32)\n",
1251 pStream->szName, cbRead, cbPlayed));
1252
1253 cfPlayed = AUDIOMIXBUF_B2F(&pStream->Host.MixBuf, cbPlayed);
1254 cfPlayedTotal += cfPlayed;
1255
1256 Assert(cfLeft >= cfPlayed);
1257 cfLeft -= cfPlayed;
1258 }
1259
1260 AudioMixBufReleaseReadBlock(&pStream->Host.MixBuf, cfPlayed);
1261
1262 if (RT_FAILURE(rc))
1263 break;
1264 }
1265 }
1266 }
1267
1268 Log3Func(("[%s] Played %RU32/%RU32 frames, rc=%Rrc\n", pStream->szName, cfPlayedTotal, cfToPlay, rc));
1269
1270 if (RT_SUCCESS(rc))
1271 {
1272 if (pcfPlayed)
1273 *pcfPlayed = cfPlayedTotal;
1274 }
1275
1276 return rc;
1277}
1278
1279/**
1280 * Plays an audio host output stream which has been configured for raw audio (layout) data.
1281 *
1282 * @return IPRT status code.
1283 * @param pThis Pointer to driver instance.
1284 * @param pStream Stream to play.
1285 * @param cfToPlay Number of audio frames to play.
1286 * @param pcfPlayed Returns number of audio frames played. Optional.
1287 */
1288static int drvAudioStreamPlayRaw(PDRVAUDIO pThis,
1289 PPDMAUDIOSTREAM pStream, uint32_t cfToPlay, uint32_t *pcfPlayed)
1290{
1291 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
1292 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
1293 /* pcfPlayed is optional. */
1294
1295 /* Sanity. */
1296 Assert(pStream->enmDir == PDMAUDIODIR_OUT);
1297 Assert(pStream->Host.Cfg.enmLayout == PDMAUDIOSTREAMLAYOUT_RAW);
1298
1299 if (!cfToPlay)
1300 {
1301 if (pcfPlayed)
1302 *pcfPlayed = 0;
1303 return VINF_SUCCESS;
1304 }
1305
1306 int rc = VINF_SUCCESS;
1307
1308 uint32_t cfPlayedTotal = 0;
1309
1310 AssertPtr(pThis->pHostDrvAudio->pfnStreamGetWritable);
1311 uint32_t cfWritable = pThis->pHostDrvAudio->pfnStreamGetWritable(pThis->pHostDrvAudio, pStream->pvBackend);
1312 if (cfWritable)
1313 {
1314 if (cfToPlay > cfWritable) /* More frames available than we can write? Limit. */
1315 cfToPlay = cfWritable;
1316
1317 PDMAUDIOFRAME aFrameBuf[_4K]; /** @todo Get rid of this here. */
1318
1319 uint32_t cfLeft = cfToPlay;
1320 while (cfLeft)
1321 {
1322 uint32_t cfRead = 0;
1323 rc = AudioMixBufPeek(&pStream->Host.MixBuf, cfLeft, aFrameBuf,
1324 RT_MIN(cfLeft, RT_ELEMENTS(aFrameBuf)), &cfRead);
1325
1326 if (RT_SUCCESS(rc))
1327 {
1328 if (cfRead)
1329 {
1330 uint32_t cfPlayed;
1331
1332 /* Note: As the stream layout is RPDMAUDIOSTREAMLAYOUT_RAW, operate on audio frames
1333 * rather on bytes. */
1334 Assert(cfRead <= RT_ELEMENTS(aFrameBuf));
1335 rc = pThis->pHostDrvAudio->pfnStreamPlay(pThis->pHostDrvAudio, pStream->pvBackend,
1336 aFrameBuf, cfRead, &cfPlayed);
1337 if ( RT_FAILURE(rc)
1338 || !cfPlayed)
1339 {
1340 break;
1341 }
1342
1343 cfPlayedTotal += cfPlayed;
1344 Assert(cfPlayedTotal <= cfToPlay);
1345
1346 Assert(cfLeft >= cfRead);
1347 cfLeft -= cfRead;
1348 }
1349 else
1350 {
1351 if (rc == VINF_AUDIO_MORE_DATA_AVAILABLE) /* Do another peeking round if there is more data available. */
1352 continue;
1353
1354 break;
1355 }
1356 }
1357 else if (RT_FAILURE(rc))
1358 break;
1359 }
1360 }
1361
1362 Log3Func(("[%s] Played %RU32/%RU32 frames, rc=%Rrc\n", pStream->szName, cfPlayedTotal, cfToPlay, rc));
1363
1364 if (RT_SUCCESS(rc))
1365 {
1366 if (pcfPlayed)
1367 *pcfPlayed = cfPlayedTotal;
1368
1369 }
1370
1371 return rc;
1372}
1373
1374/**
1375 * @interface_method_impl{PDMIAUDIOCONNECTOR,pfnStreamPlay}
1376 */
1377static DECLCALLBACK(int) drvAudioStreamPlay(PPDMIAUDIOCONNECTOR pInterface,
1378 PPDMAUDIOSTREAM pStream, uint32_t *pcFramesPlayed)
1379{
1380 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
1381 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
1382 /* pcFramesPlayed is optional. */
1383
1384 PDRVAUDIO pThis = PDMIAUDIOCONNECTOR_2_DRVAUDIO(pInterface);
1385
1386 int rc = RTCritSectEnter(&pThis->CritSect);
1387 if (RT_FAILURE(rc))
1388 return rc;
1389
1390 AssertMsg(pStream->enmDir == PDMAUDIODIR_OUT,
1391 ("Stream '%s' is not an output stream and therefore cannot be played back (direction is 0x%x)\n",
1392 pStream->szName, pStream->enmDir));
1393
1394 uint32_t cfPlayedTotal = 0;
1395
1396 PDMAUDIOSTREAMSTS stsStream = pStream->fStatus;
1397#ifdef LOG_ENABLED
1398 char *pszStreamSts = dbgAudioStreamStatusToStr(stsStream);
1399 Log3Func(("[%s] Start fStatus=%s\n", pStream->szName, pszStreamSts));
1400 RTStrFree(pszStreamSts);
1401#endif /* LOG_ENABLED */
1402
1403 do
1404 {
1405 if (!pThis->pHostDrvAudio)
1406 {
1407 rc = VERR_AUDIO_STREAM_NOT_READY;
1408 break;
1409 }
1410
1411 if ( !pThis->Out.fEnabled
1412 || !DrvAudioHlpStreamStatusIsReady(stsStream))
1413 {
1414 rc = VERR_AUDIO_STREAM_NOT_READY;
1415 break;
1416 }
1417 uint32_t cfLive = AudioMixBufLive(&pStream->Host.MixBuf);
1418 const uint8_t uLivePercent = (100 * cfLive) / AudioMixBufSize(&pStream->Host.MixBuf);
1419
1420 const uint64_t tsDeltaPlayedCapturedNs = RTTimeNanoTS() - pStream->tsLastPlayedCapturedNs;
1421
1422 pStream->tsLastPlayedCapturedNs = RTTimeNanoTS();
1423
1424 Log3Func(("[%s] Last played %RU64ns (%RU64ms), filled with %RU64ms (%RU8%%) total, "
1425 "(cfLive=%RU32, fThresholdReached=%RTbool)\n",
1426 pStream->szName, tsDeltaPlayedCapturedNs, tsDeltaPlayedCapturedNs / RT_NS_1MS_64,
1427 DrvAudioHlpFramesToMilli(cfLive, &pStream->Host.Cfg.Props),
1428 uLivePercent, cfLive, pStream->fThresholdReached));
1429
1430 bool fDoPlay = pStream->fThresholdReached;
1431 bool fJustStarted = false;
1432 if (!fDoPlay)
1433 {
1434 /* Did we reach the backend's playback (pre-buffering) threshold? Can be 0 if no threshold set. */
1435 if (cfLive >= pStream->Host.Cfg.Backend.cfPreBuf)
1436 {
1437 LogRel2(("Audio: Stream '%s' buffering complete\n", pStream->szName));
1438 fDoPlay = true;
1439 }
1440 /* Some audio files are shorter than the pre-buffering level (e.g. the "click" Explorer sounds on some Windows guests),
1441 * so make sure that we also play those by checking if the stream already is pending disable mode, even if we didn't
1442 * hit the pre-buffering watermark yet.
1443 *
1444 * To reproduce, use "Windows Navigation Start.wav" on Windows 7 (2824 samples). */
1445 else if ( cfLive
1446 && pStream->fStatus & PDMAUDIOSTREAMSTS_FLAG_PENDING_DISABLE)
1447 {
1448 LogRel2(("Audio: Stream '%s' buffering complete (short sound)\n", pStream->szName));
1449 fDoPlay = true;
1450 }
1451
1452 if (fDoPlay)
1453 {
1454 pStream->fThresholdReached = true;
1455 fJustStarted = true;
1456 LogRel2(("Audio: Stream '%s' started playing\n", pStream->szName));
1457 }
1458 else /* Not yet, so still buffering audio data. */
1459 LogRel2(("Audio: Stream '%s' is buffering (%RU8%% complete)\n",
1460 pStream->szName, (100 * cfLive) / pStream->Host.Cfg.Backend.cfPreBuf));
1461 }
1462
1463 if (fDoPlay)
1464 {
1465 uint32_t cfToPlay = 0;
1466 if (fJustStarted)
1467 cfToPlay = pStream->Host.Cfg.Backend.cfPeriod; /* cfPeriod can be 0. */
1468
1469 if (!cfToPlay)
1470 {
1471 cfToPlay = DrvAudioHlpNanoToFrames(tsDeltaPlayedCapturedNs, &pStream->Host.Cfg.Props);
1472 if (pStream->Host.Cfg.Device.uSchedulingHintMs)
1473 cfToPlay = RT_MIN(cfToPlay, DrvAudioHlpMilliToFrames(pStream->Host.Cfg.Device.uSchedulingHintMs, &pStream->Host.Cfg.Props));
1474 }
1475
1476 Log3Func(("[%s] fJustStarted=%RTbool, cfLive=%RU32, cfToPlay=%RU32\n",
1477 pStream->szName, fJustStarted, cfLive, cfToPlay));
1478
1479 /* Did we reach a buffer underrun? Do pre-buffering again.
1480 * If we're in pending disabled mode, try to play (drain) the remaining audio data. */
1481 if ( !(pStream->fStatus & PDMAUDIOSTREAMSTS_FLAG_PENDING_DISABLE)
1482 && !fJustStarted)
1483 {
1484 if (cfLive < cfToPlay)
1485 {
1486 pStream->fThresholdReached = false;
1487 Log3Func(("[%s] Warning: Buffer underrun (cfLive=%RU32, cfToPlay=%RU32)\n", pStream->szName, cfLive, cfToPlay));
1488 LogRel2(("Audio: Stream '%s' buffer underrun (total %RU8%%, which is %RU8%% of a period), buffering ...\n",
1489 pStream->szName, uLivePercent, (100 * cfLive) / pStream->Host.Cfg.Backend.cfPeriod));
1490 break;
1491 }
1492 }
1493
1494 if (cfToPlay > cfLive) /* Don't try to play more than available. */
1495 cfToPlay = cfLive;
1496
1497 if (!cfToPlay)
1498 break;
1499#ifdef DEBUG
1500 if (!fJustStarted)
1501 pStream->Out.Dbg.cbJitterWrittenPlayed -= AUDIOMIXBUF_F2B(&pStream->Host.MixBuf, cfToPlay);
1502 Log3Func(("[%s] Playing %RU32 frames (%RU64ms), now filled with %RU64ms -- %RU8%% (cbJitterWrittenPlayed=%RI64)\n",
1503 pStream->szName, cfToPlay, DrvAudioHlpFramesToMilli(cfToPlay, &pStream->Host.Cfg.Props),
1504 DrvAudioHlpFramesToMilli(AudioMixBufUsed(&pStream->Host.MixBuf), &pStream->Host.Cfg.Props),
1505 AudioMixBufUsed(&pStream->Host.MixBuf) * 100 / AudioMixBufSize(&pStream->Host.MixBuf),
1506 pStream->Out.Dbg.cbJitterWrittenPlayed));
1507#endif
1508 if (pThis->pHostDrvAudio->pfnStreamPlayBegin)
1509 pThis->pHostDrvAudio->pfnStreamPlayBegin(pThis->pHostDrvAudio, pStream->pvBackend);
1510
1511 if (RT_LIKELY(pStream->Host.Cfg.enmLayout == PDMAUDIOSTREAMLAYOUT_NON_INTERLEAVED))
1512 {
1513 rc = drvAudioStreamPlayNonInterleaved(pThis, pStream, cfToPlay, &cfPlayedTotal);
1514 }
1515 else if (pStream->Host.Cfg.enmLayout == PDMAUDIOSTREAMLAYOUT_RAW)
1516 {
1517 rc = drvAudioStreamPlayRaw(pThis, pStream, cfToPlay, &cfPlayedTotal);
1518 }
1519 else
1520 AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
1521
1522 if (pThis->pHostDrvAudio->pfnStreamPlayEnd)
1523 pThis->pHostDrvAudio->pfnStreamPlayEnd(pThis->pHostDrvAudio, pStream->pvBackend);
1524 }
1525
1526 if (RT_SUCCESS(rc))
1527 {
1528 AudioMixBufFinish(&pStream->Host.MixBuf, cfPlayedTotal);
1529
1530#ifdef VBOX_WITH_STATISTICS
1531 STAM_COUNTER_ADD (&pThis->Stats.TotalFramesOut, cfPlayedTotal);
1532 STAM_PROFILE_ADV_STOP(&pThis->Stats.DelayOut, out);
1533 STAM_COUNTER_ADD (&pStream->Out.Stats.FramesPlayed, cfPlayedTotal);
1534#endif
1535 }
1536
1537 } while (0);
1538
1539#ifdef LOG_ENABLED
1540 uint32_t cfLive = AudioMixBufLive(&pStream->Host.MixBuf);
1541 pszStreamSts = dbgAudioStreamStatusToStr(stsStream);
1542 Log3Func(("[%s] End fStatus=%s, cfLive=%RU32, cfPlayedTotal=%RU32, rc=%Rrc\n",
1543 pStream->szName, pszStreamSts, cfLive, cfPlayedTotal, rc));
1544 RTStrFree(pszStreamSts);
1545#endif /* LOG_ENABLED */
1546
1547 int rc2 = RTCritSectLeave(&pThis->CritSect);
1548 if (RT_SUCCESS(rc))
1549 rc = rc2;
1550
1551 if (RT_SUCCESS(rc))
1552 {
1553 if (pcFramesPlayed)
1554 *pcFramesPlayed = cfPlayedTotal;
1555 }
1556
1557 if (RT_FAILURE(rc))
1558 LogFlowFunc(("[%s] Failed with %Rrc\n", pStream->szName, rc));
1559
1560 return rc;
1561}
1562
1563/**
1564 * Captures non-interleaved input from a host stream.
1565 *
1566 * @returns IPRT status code.
1567 * @param pThis Driver instance.
1568 * @param pStream Stream to capture from.
1569 * @param pcfCaptured Number of (host) audio frames captured. Optional.
1570 */
1571static int drvAudioStreamCaptureNonInterleaved(PDRVAUDIO pThis, PPDMAUDIOSTREAM pStream, uint32_t *pcfCaptured)
1572{
1573 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
1574 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
1575 /* pcfCaptured is optional. */
1576
1577 /* Sanity. */
1578 Assert(pStream->enmDir == PDMAUDIODIR_IN);
1579 Assert(pStream->Host.Cfg.enmLayout == PDMAUDIOSTREAMLAYOUT_NON_INTERLEAVED);
1580
1581 int rc = VINF_SUCCESS;
1582
1583 uint32_t cfCapturedTotal = 0;
1584
1585 AssertPtr(pThis->pHostDrvAudio->pfnStreamGetReadable);
1586
1587 uint8_t auBuf[_1K]; /** @todo Get rid of this. */
1588 uint32_t cbBuf = sizeof(auBuf);
1589
1590 uint32_t cbReadable = pThis->pHostDrvAudio->pfnStreamGetReadable(pThis->pHostDrvAudio, pStream->pvBackend);
1591 if (!cbReadable)
1592 Log2Func(("[%s] No readable data available\n", pStream->szName));
1593
1594 uint32_t cbFree = AudioMixBufFreeBytes(&pStream->Guest.MixBuf); /* Parent */
1595 if (!cbFree)
1596 Log2Func(("[%s] Buffer full\n", pStream->szName));
1597
1598 if (cbReadable > cbFree) /* More data readable than we can store at the moment? Limit. */
1599 cbReadable = cbFree;
1600
1601 while (cbReadable)
1602 {
1603 uint32_t cbCaptured;
1604 rc = pThis->pHostDrvAudio->pfnStreamCapture(pThis->pHostDrvAudio, pStream->pvBackend,
1605 auBuf, RT_MIN(cbReadable, cbBuf), &cbCaptured);
1606 if (RT_FAILURE(rc))
1607 {
1608 int rc2 = drvAudioStreamControlInternalBackend(pThis, pStream, PDMAUDIOSTREAMCMD_DISABLE);
1609 AssertRC(rc2);
1610
1611 break;
1612 }
1613
1614 Assert(cbCaptured <= cbBuf);
1615 if (cbCaptured > cbBuf) /* Paranoia. */
1616 cbCaptured = cbBuf;
1617
1618 /* We use the host side mixing buffer as an intermediate buffer to do some
1619 * (first) processing (if needed), so always write the incoming data at offset 0. */
1620 uint32_t cfHstWritten = 0;
1621 rc = AudioMixBufWriteAt(&pStream->Host.MixBuf, 0 /* offFrames */, auBuf, cbCaptured, &cfHstWritten);
1622 if ( RT_FAILURE(rc)
1623 || !cfHstWritten)
1624 {
1625 AssertMsgFailed(("[%s] Write failed: cbCaptured=%RU32, cfHstWritten=%RU32, rc=%Rrc\n",
1626 pStream->szName, cbCaptured, cfHstWritten, rc));
1627 break;
1628 }
1629
1630 if (pThis->In.Cfg.Dbg.fEnabled)
1631 DrvAudioHlpFileWrite(pStream->In.Dbg.pFileCaptureNonInterleaved, auBuf, cbCaptured, 0 /* fFlags */);
1632
1633 uint32_t cfHstMixed = 0;
1634 if (cfHstWritten)
1635 {
1636 int rc2 = AudioMixBufMixToParentEx(&pStream->Host.MixBuf, 0 /* cSrcOffset */, cfHstWritten /* cSrcFrames */,
1637 &cfHstMixed /* pcSrcMixed */);
1638 Log3Func(("[%s] cbCaptured=%RU32, cfWritten=%RU32, cfMixed=%RU32, rc=%Rrc\n",
1639 pStream->szName, cbCaptured, cfHstWritten, cfHstMixed, rc2));
1640 AssertRC(rc2);
1641 }
1642
1643 Assert(cbReadable >= cbCaptured);
1644 cbReadable -= cbCaptured;
1645 cfCapturedTotal += cfHstMixed;
1646 }
1647
1648 if (RT_SUCCESS(rc))
1649 {
1650 if (cfCapturedTotal)
1651 Log2Func(("[%s] %RU32 frames captured, rc=%Rrc\n", pStream->szName, cfCapturedTotal, rc));
1652 }
1653 else
1654 LogFunc(("[%s] Capturing failed with rc=%Rrc\n", pStream->szName, rc));
1655
1656 if (pcfCaptured)
1657 *pcfCaptured = cfCapturedTotal;
1658
1659 return rc;
1660}
1661
1662/**
1663 * Captures raw input from a host stream.
1664 * Raw input means that the backend directly operates on PDMAUDIOFRAME structs without
1665 * no data layout processing done in between.
1666 *
1667 * Needed for e.g. the VRDP audio backend (in Main).
1668 *
1669 * @returns IPRT status code.
1670 * @param pThis Driver instance.
1671 * @param pStream Stream to capture from.
1672 * @param pcfCaptured Number of (host) audio frames captured. Optional.
1673 */
1674static int drvAudioStreamCaptureRaw(PDRVAUDIO pThis, PPDMAUDIOSTREAM pStream, uint32_t *pcfCaptured)
1675{
1676 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
1677 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
1678 /* pcfCaptured is optional. */
1679
1680 /* Sanity. */
1681 Assert(pStream->enmDir == PDMAUDIODIR_IN);
1682 Assert(pStream->Host.Cfg.enmLayout == PDMAUDIOSTREAMLAYOUT_RAW);
1683
1684 int rc = VINF_SUCCESS;
1685
1686 uint32_t cfCapturedTotal = 0;
1687
1688 AssertPtr(pThis->pHostDrvAudio->pfnStreamGetReadable);
1689
1690 /* Note: Raw means *audio frames*, not bytes! */
1691 uint32_t cfReadable = pThis->pHostDrvAudio->pfnStreamGetReadable(pThis->pHostDrvAudio, pStream->pvBackend);
1692 if (!cfReadable)
1693 Log2Func(("[%s] No readable data available\n", pStream->szName));
1694
1695 const uint32_t cfFree = AudioMixBufFree(&pStream->Guest.MixBuf); /* Parent */
1696 if (!cfFree)
1697 Log2Func(("[%s] Buffer full\n", pStream->szName));
1698
1699 if (cfReadable > cfFree) /* More data readable than we can store at the moment? Limit. */
1700 cfReadable = cfFree;
1701
1702 while (cfReadable)
1703 {
1704 PPDMAUDIOFRAME paFrames;
1705 uint32_t cfWritable;
1706 rc = AudioMixBufPeekMutable(&pStream->Host.MixBuf, cfReadable, &paFrames, &cfWritable);
1707 if ( RT_FAILURE(rc)
1708 || !cfWritable)
1709 {
1710 break;
1711 }
1712
1713 uint32_t cfCaptured;
1714 rc = pThis->pHostDrvAudio->pfnStreamCapture(pThis->pHostDrvAudio, pStream->pvBackend,
1715 paFrames, cfWritable, &cfCaptured);
1716 if (RT_FAILURE(rc))
1717 {
1718 int rc2 = drvAudioStreamControlInternalBackend(pThis, pStream, PDMAUDIOSTREAMCMD_DISABLE);
1719 AssertRC(rc2);
1720
1721 break;
1722 }
1723
1724 Assert(cfCaptured <= cfWritable);
1725 if (cfCaptured > cfWritable) /* Paranoia. */
1726 cfCaptured = cfWritable;
1727
1728 Assert(cfReadable >= cfCaptured);
1729 cfReadable -= cfCaptured;
1730 cfCapturedTotal += cfCaptured;
1731 }
1732
1733 Log2Func(("[%s] %RU32 frames captured, rc=%Rrc\n", pStream->szName, cfCapturedTotal, rc));
1734
1735 if (pcfCaptured)
1736 *pcfCaptured = cfCapturedTotal;
1737
1738 return rc;
1739}
1740
1741/**
1742 * @interface_method_impl{PDMIAUDIOCONNECTOR,pfnStreamCapture}
1743 */
1744static DECLCALLBACK(int) drvAudioStreamCapture(PPDMIAUDIOCONNECTOR pInterface,
1745 PPDMAUDIOSTREAM pStream, uint32_t *pcFramesCaptured)
1746{
1747 PDRVAUDIO pThis = PDMIAUDIOCONNECTOR_2_DRVAUDIO(pInterface);
1748
1749 int rc = RTCritSectEnter(&pThis->CritSect);
1750 if (RT_FAILURE(rc))
1751 return rc;
1752
1753 AssertMsg(pStream->enmDir == PDMAUDIODIR_IN,
1754 ("Stream '%s' is not an input stream and therefore cannot be captured (direction is 0x%x)\n",
1755 pStream->szName, pStream->enmDir));
1756
1757 uint32_t cfCaptured = 0;
1758
1759#ifdef LOG_ENABLED
1760 char *pszStreamSts = dbgAudioStreamStatusToStr(pStream->fStatus);
1761 Log3Func(("[%s] fStatus=%s\n", pStream->szName, pszStreamSts));
1762 RTStrFree(pszStreamSts);
1763#endif /* LOG_ENABLED */
1764
1765 do
1766 {
1767 if (!pThis->pHostDrvAudio)
1768 {
1769 rc = VERR_AUDIO_STREAM_NOT_READY;
1770 break;
1771 }
1772
1773 if ( !pThis->In.fEnabled
1774 || !DrvAudioHlpStreamStatusCanRead(pStream->fStatus))
1775 {
1776 rc = VERR_AUDIO_STREAM_NOT_READY;
1777 break;
1778 }
1779
1780 /*
1781 * Do the actual capturing.
1782 */
1783
1784 if (pThis->pHostDrvAudio->pfnStreamCaptureBegin)
1785 pThis->pHostDrvAudio->pfnStreamCaptureBegin(pThis->pHostDrvAudio, pStream->pvBackend);
1786
1787 if (RT_LIKELY(pStream->Host.Cfg.enmLayout == PDMAUDIOSTREAMLAYOUT_NON_INTERLEAVED))
1788 {
1789 rc = drvAudioStreamCaptureNonInterleaved(pThis, pStream, &cfCaptured);
1790 }
1791 else if (pStream->Host.Cfg.enmLayout == PDMAUDIOSTREAMLAYOUT_RAW)
1792 {
1793 rc = drvAudioStreamCaptureRaw(pThis, pStream, &cfCaptured);
1794 }
1795 else
1796 AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
1797
1798 if (pThis->pHostDrvAudio->pfnStreamCaptureEnd)
1799 pThis->pHostDrvAudio->pfnStreamCaptureEnd(pThis->pHostDrvAudio, pStream->pvBackend);
1800
1801 if (RT_SUCCESS(rc))
1802 {
1803 Log3Func(("[%s] %RU32 frames captured, rc=%Rrc\n", pStream->szName, cfCaptured, rc));
1804
1805#ifdef VBOX_WITH_STATISTICS
1806 STAM_COUNTER_ADD(&pThis->Stats.TotalFramesIn, cfCaptured);
1807 STAM_COUNTER_ADD(&pStream->In.Stats.FramesCaptured, cfCaptured);
1808#endif
1809 }
1810 else if (RT_UNLIKELY(RT_FAILURE(rc)))
1811 {
1812 LogRel(("Audio: Capturing stream '%s' failed with %Rrc\n", pStream->szName, rc));
1813 }
1814
1815 } while (0);
1816
1817 if (pcFramesCaptured)
1818 *pcFramesCaptured = cfCaptured;
1819
1820 int rc2 = RTCritSectLeave(&pThis->CritSect);
1821 if (RT_SUCCESS(rc))
1822 rc = rc2;
1823
1824 if (RT_FAILURE(rc))
1825 LogFlowFuncLeaveRC(rc);
1826
1827 return rc;
1828}
1829
1830#ifdef VBOX_WITH_AUDIO_CALLBACKS
1831/**
1832 * Duplicates an audio callback.
1833 *
1834 * @returns Pointer to duplicated callback, or NULL on failure.
1835 * @param pCB Callback to duplicate.
1836 */
1837static PPDMAUDIOCBRECORD drvAudioCallbackDuplicate(PPDMAUDIOCBRECORD pCB)
1838{
1839 AssertPtrReturn(pCB, NULL);
1840
1841 PPDMAUDIOCBRECORD pCBCopy = (PPDMAUDIOCBRECORD)RTMemDup((void *)pCB, sizeof(PDMAUDIOCBRECORD));
1842 if (!pCBCopy)
1843 return NULL;
1844
1845 if (pCB->pvCtx)
1846 {
1847 pCBCopy->pvCtx = RTMemDup(pCB->pvCtx, pCB->cbCtx);
1848 if (!pCBCopy->pvCtx)
1849 {
1850 RTMemFree(pCBCopy);
1851 return NULL;
1852 }
1853
1854 pCBCopy->cbCtx = pCB->cbCtx;
1855 }
1856
1857 return pCBCopy;
1858}
1859
1860/**
1861 * Destroys a given callback.
1862 *
1863 * @param pCB Callback to destroy.
1864 */
1865static void drvAudioCallbackDestroy(PPDMAUDIOCBRECORD pCB)
1866{
1867 if (!pCB)
1868 return;
1869
1870 RTListNodeRemove(&pCB->Node);
1871 if (pCB->pvCtx)
1872 {
1873 Assert(pCB->cbCtx);
1874 RTMemFree(pCB->pvCtx);
1875 }
1876 RTMemFree(pCB);
1877}
1878
1879/**
1880 * @interface_method_impl{PDMIAUDIOCONNECTOR,pfnRegisterCallbacks}
1881 */
1882static DECLCALLBACK(int) drvAudioRegisterCallbacks(PPDMIAUDIOCONNECTOR pInterface,
1883 PPDMAUDIOCBRECORD paCallbacks, size_t cCallbacks)
1884{
1885 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
1886 AssertPtrReturn(paCallbacks, VERR_INVALID_POINTER);
1887 AssertReturn(cCallbacks, VERR_INVALID_PARAMETER);
1888
1889 PDRVAUDIO pThis = PDMIAUDIOCONNECTOR_2_DRVAUDIO(pInterface);
1890
1891 int rc = RTCritSectEnter(&pThis->CritSect);
1892 if (RT_FAILURE(rc))
1893 return rc;
1894
1895 for (size_t i = 0; i < cCallbacks; i++)
1896 {
1897 PPDMAUDIOCBRECORD pCB = drvAudioCallbackDuplicate(&paCallbacks[i]);
1898 if (!pCB)
1899 {
1900 rc = VERR_NO_MEMORY;
1901 break;
1902 }
1903
1904 switch (pCB->enmSource)
1905 {
1906 case PDMAUDIOCBSOURCE_DEVICE:
1907 {
1908 switch (pCB->Device.enmType)
1909 {
1910 case PDMAUDIODEVICECBTYPE_DATA_INPUT:
1911 RTListAppend(&pThis->In.lstCB, &pCB->Node);
1912 break;
1913
1914 case PDMAUDIODEVICECBTYPE_DATA_OUTPUT:
1915 RTListAppend(&pThis->Out.lstCB, &pCB->Node);
1916 break;
1917
1918 default:
1919 AssertMsgFailed(("Not supported\n"));
1920 break;
1921 }
1922
1923 break;
1924 }
1925
1926 default:
1927 AssertMsgFailed(("Not supported\n"));
1928 break;
1929 }
1930 }
1931
1932 /** @todo Undo allocations on error. */
1933
1934 int rc2 = RTCritSectLeave(&pThis->CritSect);
1935 if (RT_SUCCESS(rc))
1936 rc = rc2;
1937
1938 return rc;
1939}
1940#endif /* VBOX_WITH_AUDIO_CALLBACKS */
1941
1942#ifdef VBOX_WITH_AUDIO_CALLBACKS
1943/**
1944 * Backend callback implementation.
1945 *
1946 * Important: No calls back to the backend within this function, as the backend
1947 * might hold any locks / critical sections while executing this callback.
1948 * Will result in some ugly deadlocks (or at least locking order violations) then.
1949 *
1950 * @copydoc FNPDMHOSTAUDIOCALLBACK
1951 */
1952static DECLCALLBACK(int) drvAudioBackendCallback(PPDMDRVINS pDrvIns,
1953 PDMAUDIOBACKENDCBTYPE enmType, void *pvUser, size_t cbUser)
1954{
1955 AssertPtrReturn(pDrvIns, VERR_INVALID_POINTER);
1956 RT_NOREF(pvUser, cbUser);
1957 /* pvUser and cbUser are optional. */
1958
1959 /* Get the upper driver (PDMIAUDIOCONNECTOR). */
1960 AssertPtr(pDrvIns->pUpBase);
1961 PPDMIAUDIOCONNECTOR pInterface = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIAUDIOCONNECTOR);
1962 AssertPtr(pInterface);
1963 PDRVAUDIO pThis = PDMIAUDIOCONNECTOR_2_DRVAUDIO(pInterface);
1964
1965 int rc = RTCritSectEnter(&pThis->CritSect);
1966 AssertRCReturn(rc, rc);
1967
1968 LogFunc(("pThis=%p, enmType=%RU32, pvUser=%p, cbUser=%zu\n", pThis, enmType, pvUser, cbUser));
1969
1970 switch (enmType)
1971 {
1972 case PDMAUDIOBACKENDCBTYPE_DEVICES_CHANGED:
1973 LogRel(("Audio: Host audio device configuration has changed\n"));
1974 rc = drvAudioScheduleReInitInternal(pThis);
1975 break;
1976
1977 default:
1978 AssertMsgFailed(("Not supported\n"));
1979 break;
1980 }
1981
1982 int rc2 = RTCritSectLeave(&pThis->CritSect);
1983 if (RT_SUCCESS(rc))
1984 rc = rc2;
1985
1986 LogFlowFunc(("Returning %Rrc\n", rc));
1987 return rc;
1988}
1989#endif /* VBOX_WITH_AUDIO_CALLBACKS */
1990
1991#ifdef VBOX_WITH_AUDIO_ENUM
1992/**
1993 * Enumerates all host audio devices.
1994 * This functionality might not be implemented by all backends and will return VERR_NOT_SUPPORTED
1995 * if not being supported.
1996 *
1997 * @returns IPRT status code.
1998 * @param pThis Driver instance to be called.
1999 * @param fLog Whether to print the enumerated device to the release log or not.
2000 * @param pDevEnum Where to store the device enumeration.
2001 */
2002static int drvAudioDevicesEnumerateInternal(PDRVAUDIO pThis, bool fLog, PPDMAUDIODEVICEENUM pDevEnum)
2003{
2004 int rc;
2005
2006 /*
2007 * If the backend supports it, do a device enumeration.
2008 */
2009 if (pThis->pHostDrvAudio->pfnGetDevices)
2010 {
2011 PDMAUDIODEVICEENUM DevEnum;
2012 rc = pThis->pHostDrvAudio->pfnGetDevices(pThis->pHostDrvAudio, &DevEnum);
2013 if (RT_SUCCESS(rc))
2014 {
2015 if (fLog)
2016 LogRel(("Audio: Found %RU16 devices\n", DevEnum.cDevices));
2017
2018 PPDMAUDIODEVICE pDev;
2019 RTListForEach(&DevEnum.lstDevices, pDev, PDMAUDIODEVICE, Node)
2020 {
2021 if (fLog)
2022 {
2023 char *pszFlags = DrvAudioHlpAudDevFlagsToStrA(pDev->fFlags);
2024
2025 LogRel(("Audio: Device '%s':\n", pDev->szName));
2026 LogRel(("Audio: \tUsage = %s\n", DrvAudioHlpAudDirToStr(pDev->enmUsage)));
2027 LogRel(("Audio: \tFlags = %s\n", pszFlags ? pszFlags : "<NONE>"));
2028 LogRel(("Audio: \tInput channels = %RU8\n", pDev->cMaxInputChannels));
2029 LogRel(("Audio: \tOutput channels = %RU8\n", pDev->cMaxOutputChannels));
2030
2031 if (pszFlags)
2032 RTStrFree(pszFlags);
2033 }
2034 }
2035
2036 if (pDevEnum)
2037 rc = DrvAudioHlpDeviceEnumCopy(pDevEnum, &DevEnum);
2038
2039 DrvAudioHlpDeviceEnumFree(&DevEnum);
2040 }
2041 else
2042 {
2043 if (fLog)
2044 LogRel(("Audio: Device enumeration failed with %Rrc\n", rc));
2045 /* Not fatal. */
2046 }
2047 }
2048 else
2049 {
2050 rc = VERR_NOT_SUPPORTED;
2051
2052 if (fLog)
2053 LogRel3(("Audio: Host audio backend does not support audio device enumeration, skipping\n"));
2054 }
2055
2056 LogFunc(("Returning %Rrc\n", rc));
2057 return rc;
2058}
2059#endif /* VBOX_WITH_AUDIO_ENUM */
2060
2061/**
2062 * Initializes the host backend and queries its initial configuration.
2063 * If the host backend fails, VERR_AUDIO_BACKEND_INIT_FAILED will be returned.
2064 *
2065 * Note: As this routine is called when attaching to the device LUN in the
2066 * device emulation, we either check for success or VERR_AUDIO_BACKEND_INIT_FAILED.
2067 * Everything else is considered as fatal and must be handled separately in
2068 * the device emulation!
2069 *
2070 * @return IPRT status code.
2071 * @param pThis Driver instance to be called.
2072 * @param pCfgHandle CFGM configuration handle to use for this driver.
2073 */
2074static int drvAudioHostInit(PDRVAUDIO pThis, PCFGMNODE pCfgHandle)
2075{
2076 /* pCfgHandle is optional. */
2077 NOREF(pCfgHandle);
2078 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
2079
2080 LogFlowFuncEnter();
2081
2082 AssertPtr(pThis->pHostDrvAudio);
2083 int rc = pThis->pHostDrvAudio->pfnInit(pThis->pHostDrvAudio);
2084 if (RT_FAILURE(rc))
2085 {
2086 LogRel(("Audio: Initialization of host backend failed with %Rrc\n", rc));
2087 return VERR_AUDIO_BACKEND_INIT_FAILED;
2088 }
2089
2090 /*
2091 * Get the backend configuration.
2092 */
2093 rc = pThis->pHostDrvAudio->pfnGetConfig(pThis->pHostDrvAudio, &pThis->BackendCfg);
2094 if (RT_FAILURE(rc))
2095 {
2096 LogRel(("Audio: Getting host backend configuration failed with %Rrc\n", rc));
2097 return VERR_AUDIO_BACKEND_INIT_FAILED;
2098 }
2099
2100 pThis->In.cStreamsFree = pThis->BackendCfg.cMaxStreamsIn;
2101 pThis->Out.cStreamsFree = pThis->BackendCfg.cMaxStreamsOut;
2102
2103 LogFlowFunc(("cStreamsFreeIn=%RU8, cStreamsFreeOut=%RU8\n", pThis->In.cStreamsFree, pThis->Out.cStreamsFree));
2104
2105 LogRel2(("Audio: Host audio backend supports %RU32 input streams and %RU32 output streams at once\n",
2106 /* Clamp for logging. Unlimited streams are defined by UINT32_MAX. */
2107 RT_MIN(64, pThis->In.cStreamsFree), RT_MIN(64, pThis->Out.cStreamsFree)));
2108
2109#ifdef VBOX_WITH_AUDIO_ENUM
2110 int rc2 = drvAudioDevicesEnumerateInternal(pThis, true /* fLog */, NULL /* pDevEnum */);
2111 if (rc2 != VERR_NOT_SUPPORTED) /* Some backends don't implement device enumeration. */
2112 AssertRC(rc2);
2113
2114 RT_NOREF(rc2);
2115 /* Ignore rc. */
2116#endif
2117
2118#ifdef VBOX_WITH_AUDIO_CALLBACKS
2119 /*
2120 * If the backend supports it, offer a callback to this connector.
2121 */
2122 if (pThis->pHostDrvAudio->pfnSetCallback)
2123 {
2124 rc2 = pThis->pHostDrvAudio->pfnSetCallback(pThis->pHostDrvAudio, drvAudioBackendCallback);
2125 if (RT_FAILURE(rc2))
2126 LogRel(("Audio: Error registering backend callback, rc=%Rrc\n", rc2));
2127 /* Not fatal. */
2128 }
2129#endif
2130
2131 LogFlowFuncLeave();
2132 return VINF_SUCCESS;
2133}
2134
2135/**
2136 * Handles state changes for all audio streams.
2137 *
2138 * @param pDrvIns Pointer to driver instance.
2139 * @param enmCmd Stream command to set for all streams.
2140 */
2141static void drvAudioStateHandler(PPDMDRVINS pDrvIns, PDMAUDIOSTREAMCMD enmCmd)
2142{
2143 PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
2144 PDRVAUDIO pThis = PDMINS_2_DATA(pDrvIns, PDRVAUDIO);
2145
2146 LogFlowFunc(("enmCmd=%s\n", DrvAudioHlpStreamCmdToStr(enmCmd)));
2147
2148 int rc2 = RTCritSectEnter(&pThis->CritSect);
2149 AssertRC(rc2);
2150
2151 if (pThis->pHostDrvAudio)
2152 {
2153 PPDMAUDIOSTREAM pStream;
2154 RTListForEach(&pThis->lstStreams, pStream, PDMAUDIOSTREAM, Node)
2155 drvAudioStreamControlInternal(pThis, pStream, enmCmd);
2156 }
2157
2158 rc2 = RTCritSectLeave(&pThis->CritSect);
2159 AssertRC(rc2);
2160}
2161
2162/**
2163 * Retrieves an audio configuration from the specified CFGM node.
2164 *
2165 * @return VBox status code.
2166 * @param pThis Driver instance to be called.
2167 * @param pCfg Where to store the retrieved audio configuration to.
2168 * @param pNode Where to get the audio configuration from.
2169 */
2170static int drvAudioGetCfgFromCFGM(PDRVAUDIO pThis, PDRVAUDIOCFG pCfg, PCFGMNODE pNode)
2171{
2172 RT_NOREF(pThis);
2173
2174 /* Debug stuff. */
2175 CFGMR3QueryBoolDef(pNode, "DebugEnabled", &pCfg->Dbg.fEnabled, false);
2176 int rc2 = CFGMR3QueryString(pNode, "DebugPathOut", pCfg->Dbg.szPathOut, sizeof(pCfg->Dbg.szPathOut));
2177 if ( RT_FAILURE(rc2)
2178 || !strlen(pCfg->Dbg.szPathOut))
2179 {
2180 RTStrPrintf(pCfg->Dbg.szPathOut, sizeof(pCfg->Dbg.szPathOut), VBOX_AUDIO_DEBUG_DUMP_PCM_DATA_PATH);
2181 }
2182
2183 if (pCfg->Dbg.fEnabled)
2184 LogRel(("Audio: Debugging enabled (audio data written to '%s')\n", pCfg->Dbg.szPathOut));
2185
2186 /* Buffering stuff. */
2187 CFGMR3QueryU32Def(pNode, "PeriodSizeMs", &pCfg->uPeriodSizeMs, 0);
2188 CFGMR3QueryU32Def(pNode, "BufferSizeMs", &pCfg->uBufferSizeMs, 0);
2189 CFGMR3QueryU32Def(pNode, "PreBufferSizeMs", &pCfg->uPreBufSizeMs, UINT32_MAX /* No custom value set */);
2190
2191 LogFunc(("pCfg=%p, uPeriodSizeMs=%RU32, uBufferSizeMs=%RU32, uPreBufSizeMs=%RU32\n",
2192 pCfg, pCfg->uPeriodSizeMs, pCfg->uBufferSizeMs, pCfg->uPreBufSizeMs));
2193
2194 return VINF_SUCCESS;
2195}
2196
2197/**
2198 * Intializes an audio driver instance.
2199 *
2200 * @returns IPRT status code.
2201 * @param pDrvIns Pointer to driver instance.
2202 * @param pCfgHandle CFGM handle to use for configuration.
2203 */
2204static int drvAudioInit(PPDMDRVINS pDrvIns, PCFGMNODE pCfgHandle)
2205{
2206 AssertPtrReturn(pCfgHandle, VERR_INVALID_POINTER);
2207 AssertPtrReturn(pDrvIns, VERR_INVALID_POINTER);
2208
2209 LogRel2(("Audio: Verbose logging enabled\n"));
2210
2211 PDRVAUDIO pThis = PDMINS_2_DATA(pDrvIns, PDRVAUDIO);
2212
2213 int rc = RTCritSectInit(&pThis->CritSect);
2214 AssertRCReturn(rc, rc);
2215
2216 /*
2217 * Configure driver from CFGM.
2218 */
2219#ifdef DEBUG
2220 CFGMR3Dump(pCfgHandle);
2221#endif
2222
2223 pThis->fTerminate = false;
2224 pThis->pCFGMNode = pCfgHandle;
2225
2226 int rc2 = CFGMR3QueryString(pThis->pCFGMNode, "DriverName", pThis->szName, sizeof(pThis->szName));
2227 if (RT_FAILURE(rc2))
2228 RTStrPrintf(pThis->szName, sizeof(pThis->szName), "Untitled");
2229
2230 /* By default we don't enable anything if wrongly / not set-up. */
2231 CFGMR3QueryBoolDef(pThis->pCFGMNode, "InputEnabled", &pThis->In.fEnabled, false);
2232 CFGMR3QueryBoolDef(pThis->pCFGMNode, "OutputEnabled", &pThis->Out.fEnabled, false);
2233
2234 LogRel2(("Audio: Initial status for driver '%s': Input is %s, output is %s\n",
2235 pThis->szName, pThis->In.fEnabled ? "enabled" : "disabled", pThis->Out.fEnabled ? "enabled" : "disabled"));
2236
2237 /*
2238 * Load configurations.
2239 */
2240 rc = drvAudioGetCfgFromCFGM(pThis, &pThis->In.Cfg, pThis->pCFGMNode);
2241 if (RT_SUCCESS(rc))
2242 rc = drvAudioGetCfgFromCFGM(pThis, &pThis->Out.Cfg, pThis->pCFGMNode);
2243
2244 LogFunc(("[%s] rc=%Rrc\n", pThis->szName, rc));
2245 return rc;
2246}
2247
2248/**
2249 * @interface_method_impl{PDMIAUDIOCONNECTOR,pfnStreamRead}
2250 */
2251static DECLCALLBACK(int) drvAudioStreamRead(PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOSTREAM pStream,
2252 void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead)
2253{
2254 PDRVAUDIO pThis = PDMIAUDIOCONNECTOR_2_DRVAUDIO(pInterface);
2255 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
2256
2257 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
2258 AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
2259 AssertReturn(cbBuf, VERR_INVALID_PARAMETER);
2260 /* pcbRead is optional. */
2261
2262 AssertMsg(pStream->enmDir == PDMAUDIODIR_IN,
2263 ("Stream '%s' is not an input stream and therefore cannot be read from (direction is 0x%x)\n",
2264 pStream->szName, pStream->enmDir));
2265
2266 uint32_t cbReadTotal = 0;
2267
2268 int rc = RTCritSectEnter(&pThis->CritSect);
2269 if (RT_FAILURE(rc))
2270 return rc;
2271
2272 do
2273 {
2274 if ( !pThis->In.fEnabled
2275 || !DrvAudioHlpStreamStatusCanRead(pStream->fStatus))
2276 {
2277 rc = VERR_AUDIO_STREAM_NOT_READY;
2278 break;
2279 }
2280
2281 /*
2282 * Read from the parent buffer (that is, the guest buffer) which
2283 * should have the audio data in the format the guest needs.
2284 */
2285 uint32_t cfReadTotal = 0;
2286
2287 const uint32_t cfBuf = AUDIOMIXBUF_B2F(&pStream->Guest.MixBuf, cbBuf);
2288
2289 uint32_t cfToRead = RT_MIN(cfBuf, AudioMixBufLive(&pStream->Guest.MixBuf));
2290 while (cfToRead)
2291 {
2292 uint32_t cfRead;
2293 rc = AudioMixBufAcquireReadBlock(&pStream->Guest.MixBuf,
2294 (uint8_t *)pvBuf + AUDIOMIXBUF_F2B(&pStream->Guest.MixBuf, cfReadTotal),
2295 AUDIOMIXBUF_F2B(&pStream->Guest.MixBuf, cfToRead), &cfRead);
2296 if (RT_FAILURE(rc))
2297 break;
2298
2299#ifdef VBOX_WITH_STATISTICS
2300 const uint32_t cbRead = AUDIOMIXBUF_F2B(&pStream->Guest.MixBuf, cfRead);
2301
2302 STAM_COUNTER_ADD(&pThis->Stats.TotalBytesRead, cbRead);
2303 STAM_COUNTER_ADD(&pStream->In.Stats.BytesTotalRead, cbRead);
2304#endif
2305 Assert(cfToRead >= cfRead);
2306 cfToRead -= cfRead;
2307
2308 cfReadTotal += cfRead;
2309
2310 AudioMixBufReleaseReadBlock(&pStream->Guest.MixBuf, cfRead);
2311 }
2312
2313 /* If we were not able to read as much data as requested, fill up the returned
2314 * data with silence.
2315 *
2316 * This is needed to keep the device emulation DMA transfers up and running at a constant rate. */
2317 if (cfReadTotal < cfBuf)
2318 {
2319 Log3Func(("[%s] Filling in silence (%RU64ms / %RU64ms)\n", pStream->szName,
2320 DrvAudioHlpFramesToMilli(cfBuf - cfReadTotal, &pStream->Guest.Cfg.Props),
2321 DrvAudioHlpFramesToMilli(cfBuf, &pStream->Guest.Cfg.Props)));
2322
2323 DrvAudioHlpClearBuf(&pStream->Guest.Cfg.Props,
2324 (uint8_t *)pvBuf + AUDIOMIXBUF_F2B(&pStream->Guest.MixBuf, cfReadTotal),
2325 AUDIOMIXBUF_F2B(&pStream->Guest.MixBuf, cfBuf - cfReadTotal),
2326 cfBuf - cfReadTotal);
2327
2328 cfReadTotal = cfBuf;
2329 }
2330
2331 if (cfReadTotal)
2332 {
2333 if (pThis->In.Cfg.Dbg.fEnabled)
2334 DrvAudioHlpFileWrite(pStream->In.Dbg.pFileStreamRead,
2335 pvBuf, AUDIOMIXBUF_F2B(&pStream->Guest.MixBuf, cfReadTotal), 0 /* fFlags */);
2336
2337 AudioMixBufFinish(&pStream->Guest.MixBuf, cfReadTotal);
2338
2339 cbReadTotal = AUDIOMIXBUF_F2B(&pStream->Guest.MixBuf, cfReadTotal);
2340 }
2341
2342 pStream->tsLastReadWrittenNs = RTTimeNanoTS();
2343
2344 Log3Func(("[%s] fEnabled=%RTbool, cbReadTotal=%RU32, rc=%Rrc\n", pStream->szName, pThis->In.fEnabled, cbReadTotal, rc));
2345
2346 } while (0);
2347
2348
2349 int rc2 = RTCritSectLeave(&pThis->CritSect);
2350 if (RT_SUCCESS(rc))
2351 rc = rc2;
2352
2353 if (RT_SUCCESS(rc))
2354 {
2355 if (pcbRead)
2356 *pcbRead = cbReadTotal;
2357 }
2358
2359 return rc;
2360}
2361
2362/**
2363 * @interface_method_impl{PDMIAUDIOCONNECTOR,pfnStreamCreate}
2364 */
2365static DECLCALLBACK(int) drvAudioStreamCreate(PPDMIAUDIOCONNECTOR pInterface,
2366 PPDMAUDIOSTREAMCFG pCfgHost, PPDMAUDIOSTREAMCFG pCfgGuest,
2367 PPDMAUDIOSTREAM *ppStream)
2368{
2369 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
2370 AssertPtrReturn(pCfgHost, VERR_INVALID_POINTER);
2371 AssertPtrReturn(pCfgGuest, VERR_INVALID_POINTER);
2372 AssertPtrReturn(ppStream, VERR_INVALID_POINTER);
2373
2374 PDRVAUDIO pThis = PDMIAUDIOCONNECTOR_2_DRVAUDIO(pInterface);
2375
2376 int rc = RTCritSectEnter(&pThis->CritSect);
2377 if (RT_FAILURE(rc))
2378 return rc;
2379
2380 LogFlowFunc(("Host=%s, Guest=%s\n", pCfgHost->szName, pCfgGuest->szName));
2381#ifdef DEBUG
2382 DrvAudioHlpStreamCfgPrint(pCfgHost);
2383 DrvAudioHlpStreamCfgPrint(pCfgGuest);
2384#endif
2385
2386 PPDMAUDIOSTREAM pStream = NULL;
2387
2388#define RC_BREAK(x) { rc = x; break; }
2389
2390 do
2391 {
2392 if ( !DrvAudioHlpStreamCfgIsValid(pCfgHost)
2393 || !DrvAudioHlpStreamCfgIsValid(pCfgGuest))
2394 {
2395 RC_BREAK(VERR_INVALID_PARAMETER);
2396 }
2397
2398 /* Make sure that both configurations actually intend the same thing. */
2399 if (pCfgHost->enmDir != pCfgGuest->enmDir)
2400 {
2401 AssertMsgFailed(("Stream configuration directions do not match\n"));
2402 RC_BREAK(VERR_INVALID_PARAMETER);
2403 }
2404
2405 /* Note: cbHstStrm will contain the size of the data the backend needs to operate on. */
2406 size_t cbHstStrm = 0;
2407 if (pCfgHost->enmDir == PDMAUDIODIR_IN)
2408 {
2409 if (!pThis->In.cStreamsFree)
2410 LogFunc(("Warning: No more input streams free to use\n"));
2411
2412 cbHstStrm = pThis->BackendCfg.cbStreamIn;
2413 }
2414 else /* Out */
2415 {
2416 if (!pThis->Out.cStreamsFree)
2417 {
2418 LogFlowFunc(("Maximum number of host output streams reached\n"));
2419 RC_BREAK(VERR_AUDIO_NO_FREE_OUTPUT_STREAMS);
2420 }
2421
2422 cbHstStrm = pThis->BackendCfg.cbStreamOut;
2423 }
2424
2425 /*
2426 * Allocate and initialize common state.
2427 */
2428
2429 pStream = (PPDMAUDIOSTREAM)RTMemAllocZ(sizeof(PDMAUDIOSTREAM));
2430 AssertPtrBreakStmt(pStream, rc = VERR_NO_MEMORY);
2431
2432 /* Retrieve host driver name for easier identification. */
2433 AssertPtr(pThis->pHostDrvAudio);
2434 PPDMDRVINS pDrvAudioInst = PDMIBASE_2_PDMDRV(pThis->pDrvIns->pDownBase);
2435 AssertPtr(pDrvAudioInst);
2436 AssertPtr(pDrvAudioInst->pReg);
2437
2438 char szDriver[64];
2439 RTStrPrintf(szDriver, RT_ELEMENTS(szDriver), "%s", pDrvAudioInst->pReg->szName);
2440 if (!strlen(szDriver))
2441 {
2442 RTStrPrintf(szDriver, RT_ELEMENTS(szDriver), "Untitled");
2443 AssertFailed(); /* Should never happen. */
2444 }
2445
2446 RTStrPrintf(pStream->szName, RT_ELEMENTS(pStream->szName), "[%s] %s",
2447 szDriver, strlen(pCfgHost->szName) ? pCfgHost->szName : "<Untitled>");
2448 pStream->enmDir = pCfgHost->enmDir;
2449
2450 /*
2451 * Allocate and init backend-specific data.
2452 */
2453
2454 if (cbHstStrm) /* High unlikely that backends do not have an own space for data, but better check. */
2455 {
2456 pStream->pvBackend = RTMemAllocZ(cbHstStrm);
2457 AssertPtrBreakStmt(pStream->pvBackend, rc = VERR_NO_MEMORY);
2458
2459 pStream->cbBackend = cbHstStrm;
2460 }
2461
2462 /*
2463 * Try to init the rest.
2464 */
2465
2466 rc = drvAudioStreamInitInternal(pThis, pStream, pCfgHost, pCfgGuest);
2467 if (RT_FAILURE(rc))
2468 break;
2469
2470 } while (0);
2471
2472#undef RC_BREAK
2473
2474 if (RT_FAILURE(rc))
2475 {
2476 if (pStream)
2477 {
2478 int rc2 = drvAudioStreamUninitInternal(pThis, pStream);
2479 if (RT_SUCCESS(rc2))
2480 {
2481 drvAudioStreamFree(pStream);
2482 pStream = NULL;
2483 }
2484 }
2485 }
2486 else
2487 {
2488 /* Append the stream to our stream list. */
2489 RTListAppend(&pThis->lstStreams, &pStream->Node);
2490
2491 /* Set initial reference counts. */
2492 pStream->cRefs = 1;
2493
2494 if (pCfgHost->enmDir == PDMAUDIODIR_IN)
2495 {
2496 if (pThis->In.Cfg.Dbg.fEnabled)
2497 {
2498 char szFile[RTPATH_MAX + 1];
2499
2500 int rc2 = DrvAudioHlpFileNameGet(szFile, RT_ELEMENTS(szFile), pThis->In.Cfg.Dbg.szPathOut, "CaptureNonInterleaved",
2501 pThis->pDrvIns->iInstance, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAG_NONE);
2502 if (RT_SUCCESS(rc2))
2503 {
2504 rc2 = DrvAudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szFile, PDMAUDIOFILE_FLAG_NONE,
2505 &pStream->In.Dbg.pFileCaptureNonInterleaved);
2506 if (RT_SUCCESS(rc2))
2507 rc2 = DrvAudioHlpFileOpen(pStream->In.Dbg.pFileCaptureNonInterleaved, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS,
2508 &pStream->Host.Cfg.Props);
2509 }
2510
2511 if (RT_SUCCESS(rc2))
2512 {
2513 rc2 = DrvAudioHlpFileNameGet(szFile, RT_ELEMENTS(szFile), pThis->In.Cfg.Dbg.szPathOut, "StreamRead",
2514 pThis->pDrvIns->iInstance, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAG_NONE);
2515 if (RT_SUCCESS(rc2))
2516 {
2517 rc2 = DrvAudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szFile, PDMAUDIOFILE_FLAG_NONE,
2518 &pStream->In.Dbg.pFileStreamRead);
2519 if (RT_SUCCESS(rc2))
2520 rc2 = DrvAudioHlpFileOpen(pStream->In.Dbg.pFileStreamRead, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS,
2521 &pStream->Host.Cfg.Props);
2522 }
2523 }
2524 }
2525
2526 if (pThis->In.cStreamsFree)
2527 pThis->In.cStreamsFree--;
2528 }
2529 else /* Out */
2530 {
2531 if (pThis->Out.Cfg.Dbg.fEnabled)
2532 {
2533 char szFile[RTPATH_MAX + 1];
2534
2535 int rc2 = DrvAudioHlpFileNameGet(szFile, RT_ELEMENTS(szFile), pThis->Out.Cfg.Dbg.szPathOut, "PlayNonInterleaved",
2536 pThis->pDrvIns->iInstance, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAG_NONE);
2537 if (RT_SUCCESS(rc2))
2538 {
2539 rc2 = DrvAudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szFile, PDMAUDIOFILE_FLAG_NONE,
2540 &pStream->Out.Dbg.pFilePlayNonInterleaved);
2541 if (RT_SUCCESS(rc2))
2542 rc = DrvAudioHlpFileOpen(pStream->Out.Dbg.pFilePlayNonInterleaved, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS,
2543 &pStream->Host.Cfg.Props);
2544 }
2545
2546 if (RT_SUCCESS(rc2))
2547 {
2548 rc2 = DrvAudioHlpFileNameGet(szFile, RT_ELEMENTS(szFile), pThis->Out.Cfg.Dbg.szPathOut, "StreamWrite",
2549 pThis->pDrvIns->iInstance, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAG_NONE);
2550 if (RT_SUCCESS(rc2))
2551 {
2552 rc2 = DrvAudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szFile, PDMAUDIOFILE_FLAG_NONE,
2553 &pStream->Out.Dbg.pFileStreamWrite);
2554 if (RT_SUCCESS(rc2))
2555 rc2 = DrvAudioHlpFileOpen(pStream->Out.Dbg.pFileStreamWrite, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS,
2556 &pStream->Host.Cfg.Props);
2557 }
2558 }
2559 }
2560
2561 if (pThis->Out.cStreamsFree)
2562 pThis->Out.cStreamsFree--;
2563 }
2564
2565#ifdef VBOX_WITH_STATISTICS
2566 STAM_COUNTER_ADD(&pThis->Stats.TotalStreamsCreated, 1);
2567#endif
2568 *ppStream = pStream;
2569 }
2570
2571 int rc2 = RTCritSectLeave(&pThis->CritSect);
2572 if (RT_SUCCESS(rc))
2573 rc = rc2;
2574
2575 LogFlowFuncLeaveRC(rc);
2576 return rc;
2577}
2578
2579/**
2580 * @interface_method_impl{PDMIAUDIOCONNECTOR,pfnEnable}
2581 */
2582static DECLCALLBACK(int) drvAudioEnable(PPDMIAUDIOCONNECTOR pInterface, PDMAUDIODIR enmDir, bool fEnable)
2583{
2584 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
2585
2586 PDRVAUDIO pThis = PDMIAUDIOCONNECTOR_2_DRVAUDIO(pInterface);
2587
2588 int rc = RTCritSectEnter(&pThis->CritSect);
2589 if (RT_FAILURE(rc))
2590 return rc;
2591
2592 bool *pfEnabled;
2593 if (enmDir == PDMAUDIODIR_IN)
2594 pfEnabled = &pThis->In.fEnabled;
2595 else if (enmDir == PDMAUDIODIR_OUT)
2596 pfEnabled = &pThis->Out.fEnabled;
2597 else
2598 AssertFailedReturn(VERR_INVALID_PARAMETER);
2599
2600 if (fEnable != *pfEnabled)
2601 {
2602 LogRel(("Audio: %s %s\n",
2603 fEnable ? "Enabling" : "Disabling", enmDir == PDMAUDIODIR_IN ? "input" : "output"));
2604
2605 PPDMAUDIOSTREAM pStream;
2606 RTListForEach(&pThis->lstStreams, pStream, PDMAUDIOSTREAM, Node)
2607 {
2608 if (pStream->enmDir != enmDir) /* Skip unwanted streams. */
2609 continue;
2610
2611 int rc2 = drvAudioStreamControlInternal(pThis, pStream,
2612 fEnable ? PDMAUDIOSTREAMCMD_ENABLE : PDMAUDIOSTREAMCMD_DISABLE);
2613 if (RT_FAILURE(rc2))
2614 LogRel(("Audio: Failed to %s %s stream '%s', rc=%Rrc\n",
2615 fEnable ? "enable" : "disable", enmDir == PDMAUDIODIR_IN ? "input" : "output", pStream->szName, rc2));
2616
2617 if (RT_SUCCESS(rc))
2618 rc = rc2;
2619
2620 /* Keep going. */
2621 }
2622
2623 *pfEnabled = fEnable;
2624 }
2625
2626 int rc3 = RTCritSectLeave(&pThis->CritSect);
2627 if (RT_SUCCESS(rc))
2628 rc = rc3;
2629
2630 LogFlowFuncLeaveRC(rc);
2631 return rc;
2632}
2633
2634/**
2635 * @interface_method_impl{PDMIAUDIOCONNECTOR,pfnIsEnabled}
2636 */
2637static DECLCALLBACK(bool) drvAudioIsEnabled(PPDMIAUDIOCONNECTOR pInterface, PDMAUDIODIR enmDir)
2638{
2639 AssertPtrReturn(pInterface, false);
2640
2641 PDRVAUDIO pThis = PDMIAUDIOCONNECTOR_2_DRVAUDIO(pInterface);
2642
2643 int rc2 = RTCritSectEnter(&pThis->CritSect);
2644 if (RT_FAILURE(rc2))
2645 return false;
2646
2647 bool *pfEnabled;
2648 if (enmDir == PDMAUDIODIR_IN)
2649 pfEnabled = &pThis->In.fEnabled;
2650 else if (enmDir == PDMAUDIODIR_OUT)
2651 pfEnabled = &pThis->Out.fEnabled;
2652 else
2653 AssertFailedReturn(false);
2654
2655 const bool fIsEnabled = *pfEnabled;
2656
2657 rc2 = RTCritSectLeave(&pThis->CritSect);
2658 AssertRC(rc2);
2659
2660 return fIsEnabled;
2661}
2662
2663/**
2664 * @interface_method_impl{PDMIAUDIOCONNECTOR,pfnGetConfig}
2665 */
2666static DECLCALLBACK(int) drvAudioGetConfig(PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOBACKENDCFG pCfg)
2667{
2668 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
2669 AssertPtrReturn(pCfg, VERR_INVALID_POINTER);
2670
2671 PDRVAUDIO pThis = PDMIAUDIOCONNECTOR_2_DRVAUDIO(pInterface);
2672
2673 int rc = RTCritSectEnter(&pThis->CritSect);
2674 if (RT_FAILURE(rc))
2675 return rc;
2676
2677 if (pThis->pHostDrvAudio)
2678 {
2679 if (pThis->pHostDrvAudio->pfnGetConfig)
2680 rc = pThis->pHostDrvAudio->pfnGetConfig(pThis->pHostDrvAudio, pCfg);
2681 else
2682 rc = VERR_NOT_SUPPORTED;
2683 }
2684 else
2685 AssertFailed();
2686
2687 int rc2 = RTCritSectLeave(&pThis->CritSect);
2688 if (RT_SUCCESS(rc))
2689 rc = rc2;
2690
2691 LogFlowFuncLeaveRC(rc);
2692 return rc;
2693}
2694
2695/**
2696 * @interface_method_impl{PDMIAUDIOCONNECTOR,pfnGetStatus}
2697 */
2698static DECLCALLBACK(PDMAUDIOBACKENDSTS) drvAudioGetStatus(PPDMIAUDIOCONNECTOR pInterface, PDMAUDIODIR enmDir)
2699{
2700 AssertPtrReturn(pInterface, PDMAUDIOBACKENDSTS_UNKNOWN);
2701
2702 PDRVAUDIO pThis = PDMIAUDIOCONNECTOR_2_DRVAUDIO(pInterface);
2703
2704 PDMAUDIOBACKENDSTS backendSts = PDMAUDIOBACKENDSTS_UNKNOWN;
2705
2706 int rc = RTCritSectEnter(&pThis->CritSect);
2707 if (RT_SUCCESS(rc))
2708 {
2709 if (pThis->pHostDrvAudio)
2710 {
2711 if (pThis->pHostDrvAudio->pfnGetStatus)
2712 backendSts = pThis->pHostDrvAudio->pfnGetStatus(pThis->pHostDrvAudio, enmDir);
2713 }
2714 else
2715 backendSts = PDMAUDIOBACKENDSTS_NOT_ATTACHED;
2716
2717 int rc2 = RTCritSectLeave(&pThis->CritSect);
2718 if (RT_SUCCESS(rc))
2719 rc = rc2;
2720 }
2721
2722 LogFlowFuncLeaveRC(rc);
2723 return backendSts;
2724}
2725
2726/**
2727 * @interface_method_impl{PDMIAUDIOCONNECTOR,pfnStreamGetReadable}
2728 */
2729static DECLCALLBACK(uint32_t) drvAudioStreamGetReadable(PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOSTREAM pStream)
2730{
2731 AssertPtrReturn(pInterface, 0);
2732 AssertPtrReturn(pStream, 0);
2733
2734 PDRVAUDIO pThis = PDMIAUDIOCONNECTOR_2_DRVAUDIO(pInterface);
2735
2736 int rc2 = RTCritSectEnter(&pThis->CritSect);
2737 AssertRC(rc2);
2738
2739 AssertMsg(pStream->enmDir == PDMAUDIODIR_IN, ("Can't read from a non-input stream\n"));
2740
2741 uint32_t cbReadable = 0;
2742
2743 if (DrvAudioHlpStreamStatusCanRead(pStream->fStatus))
2744 {
2745 const uint32_t cfReadable = AudioMixBufLive(&pStream->Guest.MixBuf);
2746
2747 cbReadable = AUDIOMIXBUF_F2B(&pStream->Guest.MixBuf, cfReadable);
2748
2749 if (!cbReadable)
2750 {
2751 /*
2752 * If Nothing is readable, check if the stream on the backend side is ready to be read from.
2753 * If it isn't, return the number of bytes readable since the last read from this stream.
2754 *
2755 * This is needed for backends (e.g. VRDE) which do not provide any input data in certain
2756 * situations, but the device emulation needs input data to keep the DMA transfers moving.
2757 * Reading the actual data from a stream then will return silence then.
2758 */
2759 if (!DrvAudioHlpStreamStatusCanRead(
2760 pThis->pHostDrvAudio->pfnStreamGetStatus(pThis->pHostDrvAudio, pStream->pvBackend)))
2761 {
2762 cbReadable = DrvAudioHlpNanoToBytes(RTTimeNanoTS() - pStream->tsLastReadWrittenNs,
2763 &pStream->Host.Cfg.Props);
2764 Log3Func(("[%s] Backend stream not ready, returning silence\n", pStream->szName));
2765 }
2766 }
2767
2768 /* Make sure to align the readable size to the guest's frame size. */
2769 cbReadable = DrvAudioHlpBytesAlign(cbReadable, &pStream->Guest.Cfg.Props);
2770 }
2771
2772 Log3Func(("[%s] cbReadable=%RU32 (%RU64ms)\n",
2773 pStream->szName, cbReadable, DrvAudioHlpBytesToMilli(cbReadable, &pStream->Host.Cfg.Props)));
2774
2775 rc2 = RTCritSectLeave(&pThis->CritSect);
2776 AssertRC(rc2);
2777
2778 /* Return bytes instead of audio frames. */
2779 return cbReadable;
2780}
2781
2782/**
2783 * @interface_method_impl{PDMIAUDIOCONNECTOR,pfnStreamGetWritable}
2784 */
2785static DECLCALLBACK(uint32_t) drvAudioStreamGetWritable(PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOSTREAM pStream)
2786{
2787 AssertPtrReturn(pInterface, 0);
2788 AssertPtrReturn(pStream, 0);
2789
2790 PDRVAUDIO pThis = PDMIAUDIOCONNECTOR_2_DRVAUDIO(pInterface);
2791
2792 int rc2 = RTCritSectEnter(&pThis->CritSect);
2793 AssertRC(rc2);
2794
2795 AssertMsg(pStream->enmDir == PDMAUDIODIR_OUT, ("Can't write to a non-output stream\n"));
2796
2797 uint32_t cbWritable = 0;
2798
2799 if (DrvAudioHlpStreamStatusCanWrite(pStream->fStatus))
2800 {
2801 cbWritable = AudioMixBufFreeBytes(&pStream->Host.MixBuf);
2802
2803 /* Make sure to align the writable size to the guest's frame size. */
2804 cbWritable = DrvAudioHlpBytesAlign(cbWritable, &pStream->Guest.Cfg.Props);
2805 }
2806
2807 Log3Func(("[%s] cbWritable=%RU32 (%RU64ms2)\n",
2808 pStream->szName, cbWritable, DrvAudioHlpBytesToMilli(cbWritable, &pStream->Host.Cfg.Props)));
2809
2810 rc2 = RTCritSectLeave(&pThis->CritSect);
2811 AssertRC(rc2);
2812
2813 return cbWritable;
2814}
2815
2816/**
2817 * @interface_method_impl{PDMIAUDIOCONNECTOR,pfnStreamGetStatus}
2818 */
2819static DECLCALLBACK(PDMAUDIOSTREAMSTS) drvAudioStreamGetStatus(PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOSTREAM pStream)
2820{
2821 AssertPtrReturn(pInterface, false);
2822
2823 if (!pStream)
2824 return PDMAUDIOSTREAMSTS_FLAG_NONE;
2825
2826 PDRVAUDIO pThis = PDMIAUDIOCONNECTOR_2_DRVAUDIO(pInterface);
2827
2828 int rc2 = RTCritSectEnter(&pThis->CritSect);
2829 AssertRC(rc2);
2830
2831 PDMAUDIOSTREAMSTS stsStream = pStream->fStatus;
2832
2833#ifdef LOG_ENABLED
2834 char *pszStreamSts = dbgAudioStreamStatusToStr(stsStream);
2835 Log3Func(("[%s] %s\n", pStream->szName, pszStreamSts));
2836 RTStrFree(pszStreamSts);
2837#endif
2838
2839 rc2 = RTCritSectLeave(&pThis->CritSect);
2840 AssertRC(rc2);
2841
2842 return stsStream;
2843}
2844
2845/**
2846 * @interface_method_impl{PDMIAUDIOCONNECTOR,pfnStreamSetVolume}
2847 */
2848static DECLCALLBACK(int) drvAudioStreamSetVolume(PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOSTREAM pStream, PPDMAUDIOVOLUME pVol)
2849{
2850 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
2851 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
2852 AssertPtrReturn(pVol, VERR_INVALID_POINTER);
2853
2854 LogFlowFunc(("[%s] volL=%RU32, volR=%RU32, fMute=%RTbool\n", pStream->szName, pVol->uLeft, pVol->uRight, pVol->fMuted));
2855
2856 AudioMixBufSetVolume(&pStream->Guest.MixBuf, pVol);
2857 AudioMixBufSetVolume(&pStream->Host.MixBuf, pVol);
2858
2859 return VINF_SUCCESS;
2860}
2861
2862/**
2863 * @interface_method_impl{PDMIAUDIOCONNECTOR,pfnStreamDestroy}
2864 */
2865static DECLCALLBACK(int) drvAudioStreamDestroy(PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOSTREAM pStream)
2866{
2867 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
2868 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
2869
2870 PDRVAUDIO pThis = PDMIAUDIOCONNECTOR_2_DRVAUDIO(pInterface);
2871
2872 int rc = RTCritSectEnter(&pThis->CritSect);
2873 AssertRC(rc);
2874
2875 LogRel2(("Audio: Destroying stream '%s'\n", pStream->szName));
2876
2877 LogFlowFunc(("[%s] cRefs=%RU32\n", pStream->szName, pStream->cRefs));
2878 if (pStream->cRefs > 1)
2879 rc = VERR_WRONG_ORDER;
2880
2881 if (RT_SUCCESS(rc))
2882 {
2883 rc = drvAudioStreamUninitInternal(pThis, pStream);
2884 if (RT_FAILURE(rc))
2885 LogRel(("Audio: Uninitializing stream '%s' failed with %Rrc\n", pStream->szName, rc));
2886 }
2887
2888 if (RT_SUCCESS(rc))
2889 {
2890 if (pStream->enmDir == PDMAUDIODIR_IN)
2891 {
2892 pThis->In.cStreamsFree++;
2893 }
2894 else /* Out */
2895 {
2896 pThis->Out.cStreamsFree++;
2897 }
2898
2899 RTListNodeRemove(&pStream->Node);
2900
2901 drvAudioStreamFree(pStream);
2902 pStream = NULL;
2903 }
2904
2905 int rc2 = RTCritSectLeave(&pThis->CritSect);
2906 if (RT_SUCCESS(rc))
2907 rc = rc2;
2908
2909 LogFlowFuncLeaveRC(rc);
2910 return rc;
2911}
2912
2913/**
2914 * Creates an audio stream on the backend side.
2915 *
2916 * @returns IPRT status code.
2917 * @param pThis Pointer to driver instance.
2918 * @param pStream Audio stream to create the backend side for.
2919 * @param pCfgReq Requested audio stream configuration to use for stream creation.
2920 * @param pCfgAcq Acquired audio stream configuration returned by the backend.
2921 */
2922static int drvAudioStreamCreateInternalBackend(PDRVAUDIO pThis,
2923 PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
2924{
2925 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
2926 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
2927 AssertPtrReturn(pCfgReq, VERR_INVALID_POINTER);
2928 AssertPtrReturn(pCfgAcq, VERR_INVALID_POINTER);
2929
2930 AssertMsg((pStream->fStatus & PDMAUDIOSTREAMSTS_FLAG_INITIALIZED) == 0,
2931 ("Stream '%s' already initialized in backend\n", pStream->szName));
2932
2933 /* Get the right configuration for the stream to be created. */
2934 PDRVAUDIOCFG pDrvCfg = pCfgReq->enmDir == PDMAUDIODIR_IN ? &pThis->In.Cfg : &pThis->Out.Cfg;
2935
2936 /* Fill in the tweakable parameters into the requested host configuration.
2937 * All parameters in principle can be changed and returned by the backend via the acquired configuration. */
2938
2939 /*
2940 * Period size
2941 */
2942 if (pDrvCfg->uPeriodSizeMs)
2943 pCfgReq->Backend.cfPeriod = DrvAudioHlpMilliToFrames(pDrvCfg->uPeriodSizeMs, &pCfgReq->Props);
2944 else /* Set default period size. */
2945 pCfgReq->Backend.cfPeriod = DrvAudioHlpMilliToFrames(200 /* ms */, &pCfgReq->Props);
2946
2947 LogRel2(("Audio: Using %s period size (%RU64ms, %RU32 frames) for stream '%s'\n",
2948 pDrvCfg->uPeriodSizeMs ? "custom" : "default", DrvAudioHlpFramesToMilli(pCfgReq->Backend.cfPeriod, &pCfgReq->Props),
2949 pCfgReq->Backend.cfPeriod, pStream->szName));
2950
2951 /*
2952 * Buffer size
2953 */
2954 if (pDrvCfg->uBufferSizeMs)
2955 pCfgReq->Backend.cfBufferSize = DrvAudioHlpMilliToFrames(pDrvCfg->uBufferSizeMs, &pCfgReq->Props);
2956 else /* Set default buffer size. */
2957 pCfgReq->Backend.cfBufferSize = DrvAudioHlpMilliToFrames(400 /* ms */, &pCfgReq->Props);
2958
2959 LogRel2(("Audio: Using %s buffer size (%RU64ms, %RU32 frames) for stream '%s'\n",
2960 pDrvCfg->uBufferSizeMs ? "custom" : "default", DrvAudioHlpFramesToMilli(pCfgReq->Backend.cfBufferSize, &pCfgReq->Props),
2961 pCfgReq->Backend.cfBufferSize, pStream->szName));
2962
2963 /*
2964 * Pre-buffering size
2965 */
2966 if (pDrvCfg->uPreBufSizeMs != UINT32_MAX)
2967 {
2968 if (!pDrvCfg->uPreBufSizeMs) /* Pre-buffering is set to disabled. */
2969 LogRel2(("Audio: Using custom pre-buffering (disabled) for stream '%s'\n", pStream->szName));
2970 pCfgReq->Backend.cfPreBuf = DrvAudioHlpMilliToFrames(pDrvCfg->uPreBufSizeMs, &pCfgReq->Props);
2971 }
2972 else /* Set default pre-buffering size. */
2973 pCfgReq->Backend.cfPreBuf = pCfgReq->Backend.cfBufferSize;
2974
2975 LogRel2(("Audio: Using %s pre-buffering size (%RU64ms, %RU32 frames) for stream '%s'\n",
2976 pDrvCfg->uPreBufSizeMs != UINT32_MAX ? "custom" : "default", DrvAudioHlpFramesToMilli(pCfgReq->Backend.cfPreBuf, &pCfgReq->Props),
2977 pCfgReq->Backend.cfPreBuf, pStream->szName));
2978
2979 /*
2980 * Validate input.
2981 */
2982 if (pCfgReq->Backend.cfBufferSize < pCfgReq->Backend.cfPeriod)
2983 {
2984 LogRel(("Audio: Error for stream '%s': Buffer size (%RU64ms) must not be smaller than the period size (%RU64ms)\n",
2985 pStream->szName, DrvAudioHlpFramesToMilli(pCfgReq->Backend.cfBufferSize, &pCfgReq->Props),
2986 DrvAudioHlpFramesToMilli(pCfgReq->Backend.cfPeriod, &pCfgReq->Props)));
2987 return VERR_INVALID_PARAMETER;
2988 }
2989
2990 if ( pCfgReq->Backend.cfPreBuf != UINT32_MAX /* Custom pre-buffering set? */
2991 && pCfgReq->Backend.cfPreBuf)
2992 {
2993 if (pCfgReq->Backend.cfBufferSize < pCfgReq->Backend.cfPreBuf)
2994 {
2995 LogRel(("Audio: Error for stream '%s': Pre-buffering size (%RU64ms) must not be bigger than the buffer size (%RU64ms)\n",
2996 pStream->szName, DrvAudioHlpFramesToMilli(pCfgReq->Backend.cfPreBuf, &pCfgReq->Props),
2997 DrvAudioHlpFramesToMilli(pCfgReq->Backend.cfBufferSize, &pCfgReq->Props)));
2998 return VERR_INVALID_PARAMETER;
2999 }
3000 }
3001
3002 /* Make the acquired host configuration the requested host configuration initially,
3003 * in case the backend does not report back an acquired configuration. */
3004 int rc = DrvAudioHlpStreamCfgCopy(pCfgAcq, pCfgReq);
3005 if (RT_FAILURE(rc))
3006 {
3007 LogRel(("Audio: Creating stream '%s' with an invalid backend configuration not possible, skipping\n",
3008 pStream->szName));
3009 return rc;
3010 }
3011
3012 rc = pThis->pHostDrvAudio->pfnStreamCreate(pThis->pHostDrvAudio, pStream->pvBackend, pCfgReq, pCfgAcq);
3013 if (RT_FAILURE(rc))
3014 {
3015 if (rc == VERR_NOT_SUPPORTED)
3016 LogRel2(("Audio: Creating stream '%s' in backend not supported, skipping\n", pStream->szName));
3017 else
3018 LogRel(("Audio: Creating stream '%s' in backend failed with %Rrc\n", pStream->szName, rc));
3019
3020 return rc;
3021 }
3022
3023 /* Validate acquired configuration. */
3024 if (!DrvAudioHlpStreamCfgIsValid(pCfgAcq))
3025 {
3026 LogRel(("Audio: Creating stream '%s' returned an invalid backend configuration, skipping\n", pStream->szName));
3027 return VERR_INVALID_PARAMETER;
3028 }
3029
3030 /* Let the user know that the backend changed one of the user's custom values requested above. */
3031 if ( pDrvCfg->uBufferSizeMs
3032 && pCfgAcq->Backend.cfBufferSize != pCfgReq->Backend.cfBufferSize)
3033 {
3034 LogRel2(("Audio: Custom buffer size overwritten by backend for stream '%s' (now %RU64ms, %RU32 frames)\n",
3035 pStream->szName, DrvAudioHlpFramesToMilli(pCfgAcq->Backend.cfBufferSize, &pCfgAcq->Props), pCfgAcq->Backend.cfBufferSize));
3036 }
3037
3038 if ( pDrvCfg->uPeriodSizeMs
3039 && pCfgAcq->Backend.cfPeriod != pCfgReq->Backend.cfPeriod)
3040 {
3041 LogRel2(("Audio: Custom period size overwritten by backend for stream '%s' (now %RU64ms, %RU32 frames)\n",
3042 pStream->szName, DrvAudioHlpFramesToMilli(pCfgAcq->Backend.cfPeriod, &pCfgAcq->Props), pCfgAcq->Backend.cfPeriod));
3043 }
3044
3045 if ( pDrvCfg->uPreBufSizeMs != UINT32_MAX
3046 && pCfgAcq->Backend.cfPreBuf != pCfgReq->Backend.cfPreBuf)
3047 {
3048 LogRel2(("Audio: Custom pre-buffering size overwritten by backend for stream '%s' (now %RU64ms, %RU32 frames)\n",
3049 pStream->szName, DrvAudioHlpFramesToMilli(pCfgAcq->Backend.cfPreBuf, &pCfgAcq->Props), pCfgAcq->Backend.cfPreBuf));
3050 }
3051
3052 pStream->fStatus |= PDMAUDIOSTREAMSTS_FLAG_INITIALIZED;
3053
3054 return VINF_SUCCESS;
3055}
3056
3057/**
3058 * Calls the backend to give it the chance to destroy its part of the audio stream.
3059 *
3060 * @returns IPRT status code.
3061 * @param pThis Pointer to driver instance.
3062 * @param pStream Audio stream destruct backend for.
3063 */
3064static int drvAudioStreamDestroyInternalBackend(PDRVAUDIO pThis, PPDMAUDIOSTREAM pStream)
3065{
3066 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
3067 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
3068
3069 int rc = VINF_SUCCESS;
3070
3071#ifdef LOG_ENABLED
3072 char *pszStreamSts = dbgAudioStreamStatusToStr(pStream->fStatus);
3073 LogFunc(("[%s] fStatus=%s\n", pStream->szName, pszStreamSts));
3074#endif
3075
3076 if (pStream->pvBackend)
3077 {
3078 /* Check if the pointer to the host audio driver is still valid.
3079 * It can be NULL if we were called in drvAudioDestruct, for example. */
3080 if (pThis->pHostDrvAudio)
3081 rc = pThis->pHostDrvAudio->pfnStreamDestroy(pThis->pHostDrvAudio, pStream->pvBackend);
3082
3083 pStream->pvBackend = NULL;
3084 pStream->cbBackend = 0;
3085 }
3086
3087#ifdef LOG_ENABLED
3088 RTStrFree(pszStreamSts);
3089#endif
3090
3091 LogFlowFunc(("[%s] Returning %Rrc\n", pStream->szName, rc));
3092 return rc;
3093}
3094
3095/**
3096 * Uninitializes an audio stream.
3097 *
3098 * @returns IPRT status code.
3099 * @param pThis Pointer to driver instance.
3100 * @param pStream Pointer to audio stream to uninitialize.
3101 */
3102static int drvAudioStreamUninitInternal(PDRVAUDIO pThis, PPDMAUDIOSTREAM pStream)
3103{
3104 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
3105 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
3106
3107 LogFlowFunc(("[%s] cRefs=%RU32\n", pStream->szName, pStream->cRefs));
3108
3109 if (pStream->cRefs > 1)
3110 return VERR_WRONG_ORDER;
3111
3112 int rc = drvAudioStreamControlInternal(pThis, pStream, PDMAUDIOSTREAMCMD_DISABLE);
3113 if (RT_SUCCESS(rc))
3114 rc = drvAudioStreamDestroyInternalBackend(pThis, pStream);
3115
3116 /* Destroy mixing buffers. */
3117 AudioMixBufDestroy(&pStream->Guest.MixBuf);
3118 AudioMixBufDestroy(&pStream->Host.MixBuf);
3119
3120 if (RT_SUCCESS(rc))
3121 {
3122 /* Reset status. */
3123 pStream->fStatus &= ~PDMAUDIOSTREAMSTS_FLAG_INITIALIZED;
3124
3125#ifdef LOG_ENABLED
3126 if (pStream->fStatus != PDMAUDIOSTREAMSTS_FLAG_NONE)
3127 {
3128 char *pszStreamSts = dbgAudioStreamStatusToStr(pStream->fStatus);
3129 LogFunc(("[%s] Warning: Still has %s set when uninitializing\n", pStream->szName, pszStreamSts));
3130 RTStrFree(pszStreamSts);
3131 }
3132#endif
3133 pStream->fStatus = PDMAUDIOSTREAMSTS_FLAG_NONE;
3134 }
3135
3136 if (pStream->enmDir == PDMAUDIODIR_IN)
3137 {
3138#ifdef VBOX_WITH_STATISTICS
3139 PDMDrvHlpSTAMDeregister(pThis->pDrvIns, &pStream->In.Stats.BytesElapsed);
3140 PDMDrvHlpSTAMDeregister(pThis->pDrvIns, &pStream->In.Stats.BytesTotalRead);
3141 PDMDrvHlpSTAMDeregister(pThis->pDrvIns, &pStream->In.Stats.FramesCaptured);
3142#endif
3143 if (pThis->In.Cfg.Dbg.fEnabled)
3144 {
3145 DrvAudioHlpFileDestroy(pStream->In.Dbg.pFileCaptureNonInterleaved);
3146 pStream->In.Dbg.pFileCaptureNonInterleaved = NULL;
3147
3148 DrvAudioHlpFileDestroy(pStream->In.Dbg.pFileStreamRead);
3149 pStream->In.Dbg.pFileStreamRead = NULL;
3150 }
3151 }
3152 else if (pStream->enmDir == PDMAUDIODIR_OUT)
3153 {
3154#ifdef VBOX_WITH_STATISTICS
3155 PDMDrvHlpSTAMDeregister(pThis->pDrvIns, &pStream->Out.Stats.BytesElapsed);
3156 PDMDrvHlpSTAMDeregister(pThis->pDrvIns, &pStream->Out.Stats.BytesTotalWritten);
3157 PDMDrvHlpSTAMDeregister(pThis->pDrvIns, &pStream->Out.Stats.FramesPlayed);
3158#endif
3159 if (pThis->Out.Cfg.Dbg.fEnabled)
3160 {
3161 DrvAudioHlpFileDestroy(pStream->Out.Dbg.pFilePlayNonInterleaved);
3162 pStream->Out.Dbg.pFilePlayNonInterleaved = NULL;
3163
3164 DrvAudioHlpFileDestroy(pStream->Out.Dbg.pFileStreamWrite);
3165 pStream->Out.Dbg.pFileStreamWrite = NULL;
3166 }
3167 }
3168 else
3169 AssertFailed();
3170
3171 LogFlowFunc(("Returning %Rrc\n", rc));
3172 return rc;
3173}
3174
3175/**
3176 * Does the actual backend driver attaching and queries the backend's interface.
3177 *
3178 * @return VBox status code.
3179 * @param pThis Pointer to driver instance.
3180 * @param fFlags Attach flags; see PDMDrvHlpAttach().
3181 */
3182static int drvAudioDoAttachInternal(PDRVAUDIO pThis, uint32_t fFlags)
3183{
3184 Assert(pThis->pHostDrvAudio == NULL); /* No nested attaching. */
3185
3186 /*
3187 * Attach driver below and query its connector interface.
3188 */
3189 PPDMIBASE pDownBase;
3190 int rc = PDMDrvHlpAttach(pThis->pDrvIns, fFlags, &pDownBase);
3191 if (RT_SUCCESS(rc))
3192 {
3193 pThis->pHostDrvAudio = PDMIBASE_QUERY_INTERFACE(pDownBase, PDMIHOSTAUDIO);
3194 if (!pThis->pHostDrvAudio)
3195 {
3196 LogRel(("Audio: Failed to query interface for underlying host driver\n"));
3197 rc = PDMDRV_SET_ERROR(pThis->pDrvIns, VERR_PDM_MISSING_INTERFACE_BELOW,
3198 N_("Host audio backend missing or invalid"));
3199 }
3200 }
3201
3202 if (RT_SUCCESS(rc))
3203 {
3204 /*
3205 * If everything went well, initialize the lower driver.
3206 */
3207 AssertPtr(pThis->pCFGMNode);
3208 rc = drvAudioHostInit(pThis, pThis->pCFGMNode);
3209 }
3210
3211 LogFunc(("[%s] rc=%Rrc\n", pThis->szName, rc));
3212 return rc;
3213}
3214
3215
3216/********************************************************************/
3217
3218/**
3219 * @interface_method_impl{PDMIBASE,pfnQueryInterface}
3220 */
3221static DECLCALLBACK(void *) drvAudioQueryInterface(PPDMIBASE pInterface, const char *pszIID)
3222{
3223 LogFlowFunc(("pInterface=%p, pszIID=%s\n", pInterface, pszIID));
3224
3225 PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
3226 PDRVAUDIO pThis = PDMINS_2_DATA(pDrvIns, PDRVAUDIO);
3227
3228 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
3229 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIAUDIOCONNECTOR, &pThis->IAudioConnector);
3230
3231 return NULL;
3232}
3233
3234/**
3235 * Power Off notification.
3236 *
3237 * @param pDrvIns The driver instance data.
3238 */
3239static DECLCALLBACK(void) drvAudioPowerOff(PPDMDRVINS pDrvIns)
3240{
3241 PDRVAUDIO pThis = PDMINS_2_DATA(pDrvIns, PDRVAUDIO);
3242
3243 LogFlowFuncEnter();
3244
3245 if (!pThis->pHostDrvAudio) /* If not lower driver is configured, bail out. */
3246 return;
3247
3248 /* Just destroy the host stream on the backend side.
3249 * The rest will either be destructed by the device emulation or
3250 * in drvAudioDestruct(). */
3251 PPDMAUDIOSTREAM pStream;
3252 RTListForEach(&pThis->lstStreams, pStream, PDMAUDIOSTREAM, Node)
3253 {
3254 drvAudioStreamControlInternalBackend(pThis, pStream, PDMAUDIOSTREAMCMD_DISABLE);
3255 drvAudioStreamDestroyInternalBackend(pThis, pStream);
3256 }
3257
3258 /*
3259 * Last call for the driver below us.
3260 * Let it know that we reached end of life.
3261 */
3262 if (pThis->pHostDrvAudio->pfnShutdown)
3263 pThis->pHostDrvAudio->pfnShutdown(pThis->pHostDrvAudio);
3264
3265 pThis->pHostDrvAudio = NULL;
3266
3267 LogFlowFuncLeave();
3268}
3269
3270/**
3271 * Constructs an audio driver instance.
3272 *
3273 * @copydoc FNPDMDRVCONSTRUCT
3274 */
3275static DECLCALLBACK(int) drvAudioConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
3276{
3277 LogFlowFunc(("pDrvIns=%#p, pCfgHandle=%#p, fFlags=%x\n", pDrvIns, pCfg, fFlags));
3278
3279 PDRVAUDIO pThis = PDMINS_2_DATA(pDrvIns, PDRVAUDIO);
3280 PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
3281
3282 RTListInit(&pThis->lstStreams);
3283#ifdef VBOX_WITH_AUDIO_CALLBACKS
3284 RTListInit(&pThis->In.lstCB);
3285 RTListInit(&pThis->Out.lstCB);
3286#endif
3287
3288 /*
3289 * Init the static parts.
3290 */
3291 pThis->pDrvIns = pDrvIns;
3292 /* IBase. */
3293 pDrvIns->IBase.pfnQueryInterface = drvAudioQueryInterface;
3294 /* IAudioConnector. */
3295 pThis->IAudioConnector.pfnEnable = drvAudioEnable;
3296 pThis->IAudioConnector.pfnIsEnabled = drvAudioIsEnabled;
3297 pThis->IAudioConnector.pfnGetConfig = drvAudioGetConfig;
3298 pThis->IAudioConnector.pfnGetStatus = drvAudioGetStatus;
3299 pThis->IAudioConnector.pfnStreamCreate = drvAudioStreamCreate;
3300 pThis->IAudioConnector.pfnStreamDestroy = drvAudioStreamDestroy;
3301 pThis->IAudioConnector.pfnStreamRetain = drvAudioStreamRetain;
3302 pThis->IAudioConnector.pfnStreamRelease = drvAudioStreamRelease;
3303 pThis->IAudioConnector.pfnStreamControl = drvAudioStreamControl;
3304 pThis->IAudioConnector.pfnStreamRead = drvAudioStreamRead;
3305 pThis->IAudioConnector.pfnStreamWrite = drvAudioStreamWrite;
3306 pThis->IAudioConnector.pfnStreamIterate = drvAudioStreamIterate;
3307 pThis->IAudioConnector.pfnStreamGetReadable = drvAudioStreamGetReadable;
3308 pThis->IAudioConnector.pfnStreamGetWritable = drvAudioStreamGetWritable;
3309 pThis->IAudioConnector.pfnStreamGetStatus = drvAudioStreamGetStatus;
3310 pThis->IAudioConnector.pfnStreamSetVolume = drvAudioStreamSetVolume;
3311 pThis->IAudioConnector.pfnStreamPlay = drvAudioStreamPlay;
3312 pThis->IAudioConnector.pfnStreamCapture = drvAudioStreamCapture;
3313#ifdef VBOX_WITH_AUDIO_CALLBACKS
3314 pThis->IAudioConnector.pfnRegisterCallbacks = drvAudioRegisterCallbacks;
3315#endif
3316
3317 int rc = drvAudioInit(pDrvIns, pCfg);
3318 if (RT_SUCCESS(rc))
3319 {
3320#ifdef VBOX_WITH_STATISTICS
3321 PDMDrvHlpSTAMRegCounterEx(pDrvIns, &pThis->Stats.TotalStreamsActive, "TotalStreamsActive",
3322 STAMUNIT_COUNT, "Total active audio streams.");
3323 PDMDrvHlpSTAMRegCounterEx(pDrvIns, &pThis->Stats.TotalStreamsCreated, "TotalStreamsCreated",
3324 STAMUNIT_COUNT, "Total created audio streams.");
3325 PDMDrvHlpSTAMRegCounterEx(pDrvIns, &pThis->Stats.TotalFramesRead, "TotalFramesRead",
3326 STAMUNIT_COUNT, "Total frames read by device emulation.");
3327 PDMDrvHlpSTAMRegCounterEx(pDrvIns, &pThis->Stats.TotalFramesWritten, "TotalFramesWritten",
3328 STAMUNIT_COUNT, "Total frames written by device emulation ");
3329 PDMDrvHlpSTAMRegCounterEx(pDrvIns, &pThis->Stats.TotalFramesMixedIn, "TotalFramesMixedIn",
3330 STAMUNIT_COUNT, "Total input frames mixed.");
3331 PDMDrvHlpSTAMRegCounterEx(pDrvIns, &pThis->Stats.TotalFramesMixedOut, "TotalFramesMixedOut",
3332 STAMUNIT_COUNT, "Total output frames mixed.");
3333 PDMDrvHlpSTAMRegCounterEx(pDrvIns, &pThis->Stats.TotalFramesLostIn, "TotalFramesLostIn",
3334 STAMUNIT_COUNT, "Total input frames lost.");
3335 PDMDrvHlpSTAMRegCounterEx(pDrvIns, &pThis->Stats.TotalFramesLostOut, "TotalFramesLostOut",
3336 STAMUNIT_COUNT, "Total output frames lost.");
3337 PDMDrvHlpSTAMRegCounterEx(pDrvIns, &pThis->Stats.TotalFramesOut, "TotalFramesOut",
3338 STAMUNIT_COUNT, "Total frames played by backend.");
3339 PDMDrvHlpSTAMRegCounterEx(pDrvIns, &pThis->Stats.TotalFramesIn, "TotalFramesIn",
3340 STAMUNIT_COUNT, "Total frames captured by backend.");
3341 PDMDrvHlpSTAMRegCounterEx(pDrvIns, &pThis->Stats.TotalBytesRead, "TotalBytesRead",
3342 STAMUNIT_BYTES, "Total bytes read.");
3343 PDMDrvHlpSTAMRegCounterEx(pDrvIns, &pThis->Stats.TotalBytesWritten, "TotalBytesWritten",
3344 STAMUNIT_BYTES, "Total bytes written.");
3345
3346 PDMDrvHlpSTAMRegProfileAdvEx(pDrvIns, &pThis->Stats.DelayIn, "DelayIn",
3347 STAMUNIT_NS_PER_CALL, "Profiling of input data processing.");
3348 PDMDrvHlpSTAMRegProfileAdvEx(pDrvIns, &pThis->Stats.DelayOut, "DelayOut",
3349 STAMUNIT_NS_PER_CALL, "Profiling of output data processing.");
3350#endif
3351 }
3352
3353 rc = drvAudioDoAttachInternal(pThis, fFlags);
3354 if (RT_FAILURE(rc))
3355 {
3356 /* No lower attached driver (yet)? Not a failure, might get attached later at runtime, just skip. */
3357 if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
3358 rc = VINF_SUCCESS;
3359 }
3360
3361 LogFlowFuncLeaveRC(rc);
3362 return rc;
3363}
3364
3365/**
3366 * Destructs an audio driver instance.
3367 *
3368 * @copydoc FNPDMDRVDESTRUCT
3369 */
3370static DECLCALLBACK(void) drvAudioDestruct(PPDMDRVINS pDrvIns)
3371{
3372 PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
3373 PDRVAUDIO pThis = PDMINS_2_DATA(pDrvIns, PDRVAUDIO);
3374
3375 LogFlowFuncEnter();
3376
3377 int rc2;
3378
3379 if (RTCritSectIsInitialized(&pThis->CritSect))
3380 {
3381 rc2 = RTCritSectEnter(&pThis->CritSect);
3382 AssertRC(rc2);
3383 }
3384
3385 /*
3386 * Note: No calls here to the driver below us anymore,
3387 * as PDM already has destroyed it.
3388 * If you need to call something from the host driver,
3389 * do this in drvAudioPowerOff() instead.
3390 */
3391
3392 /* Thus, NULL the pointer to the host audio driver first,
3393 * so that routines like drvAudioStreamDestroyInternal() don't call the driver(s) below us anymore. */
3394 pThis->pHostDrvAudio = NULL;
3395
3396 PPDMAUDIOSTREAM pStream, pStreamNext;
3397 RTListForEachSafe(&pThis->lstStreams, pStream, pStreamNext, PDMAUDIOSTREAM, Node)
3398 {
3399 rc2 = drvAudioStreamUninitInternal(pThis, pStream);
3400 if (RT_SUCCESS(rc2))
3401 {
3402 RTListNodeRemove(&pStream->Node);
3403
3404 drvAudioStreamFree(pStream);
3405 pStream = NULL;
3406 }
3407 }
3408
3409 /* Sanity. */
3410 Assert(RTListIsEmpty(&pThis->lstStreams));
3411
3412#ifdef VBOX_WITH_AUDIO_CALLBACKS
3413 /*
3414 * Destroy callbacks, if any.
3415 */
3416 PPDMAUDIOCBRECORD pCB, pCBNext;
3417 RTListForEachSafe(&pThis->In.lstCB, pCB, pCBNext, PDMAUDIOCBRECORD, Node)
3418 drvAudioCallbackDestroy(pCB);
3419
3420 RTListForEachSafe(&pThis->Out.lstCB, pCB, pCBNext, PDMAUDIOCBRECORD, Node)
3421 drvAudioCallbackDestroy(pCB);
3422#endif
3423
3424 if (RTCritSectIsInitialized(&pThis->CritSect))
3425 {
3426 rc2 = RTCritSectLeave(&pThis->CritSect);
3427 AssertRC(rc2);
3428
3429 rc2 = RTCritSectDelete(&pThis->CritSect);
3430 AssertRC(rc2);
3431 }
3432
3433#ifdef VBOX_WITH_STATISTICS
3434 PDMDrvHlpSTAMDeregister(pThis->pDrvIns, &pThis->Stats.TotalStreamsActive);
3435 PDMDrvHlpSTAMDeregister(pThis->pDrvIns, &pThis->Stats.TotalStreamsCreated);
3436 PDMDrvHlpSTAMDeregister(pThis->pDrvIns, &pThis->Stats.TotalFramesRead);
3437 PDMDrvHlpSTAMDeregister(pThis->pDrvIns, &pThis->Stats.TotalFramesWritten);
3438 PDMDrvHlpSTAMDeregister(pThis->pDrvIns, &pThis->Stats.TotalFramesMixedIn);
3439 PDMDrvHlpSTAMDeregister(pThis->pDrvIns, &pThis->Stats.TotalFramesMixedOut);
3440 PDMDrvHlpSTAMDeregister(pThis->pDrvIns, &pThis->Stats.TotalFramesLostIn);
3441 PDMDrvHlpSTAMDeregister(pThis->pDrvIns, &pThis->Stats.TotalFramesLostOut);
3442 PDMDrvHlpSTAMDeregister(pThis->pDrvIns, &pThis->Stats.TotalFramesOut);
3443 PDMDrvHlpSTAMDeregister(pThis->pDrvIns, &pThis->Stats.TotalFramesIn);
3444 PDMDrvHlpSTAMDeregister(pThis->pDrvIns, &pThis->Stats.TotalBytesRead);
3445 PDMDrvHlpSTAMDeregister(pThis->pDrvIns, &pThis->Stats.TotalBytesWritten);
3446 PDMDrvHlpSTAMDeregister(pThis->pDrvIns, &pThis->Stats.DelayIn);
3447 PDMDrvHlpSTAMDeregister(pThis->pDrvIns, &pThis->Stats.DelayOut);
3448#endif
3449
3450 LogFlowFuncLeave();
3451}
3452
3453/**
3454 * Suspend notification.
3455 *
3456 * @param pDrvIns The driver instance data.
3457 */
3458static DECLCALLBACK(void) drvAudioSuspend(PPDMDRVINS pDrvIns)
3459{
3460 drvAudioStateHandler(pDrvIns, PDMAUDIOSTREAMCMD_PAUSE);
3461}
3462
3463/**
3464 * Resume notification.
3465 *
3466 * @param pDrvIns The driver instance data.
3467 */
3468static DECLCALLBACK(void) drvAudioResume(PPDMDRVINS pDrvIns)
3469{
3470 drvAudioStateHandler(pDrvIns, PDMAUDIOSTREAMCMD_RESUME);
3471}
3472
3473/**
3474 * Attach notification.
3475 *
3476 * @param pDrvIns The driver instance data.
3477 * @param fFlags Attach flags.
3478 */
3479static DECLCALLBACK(int) drvAudioAttach(PPDMDRVINS pDrvIns, uint32_t fFlags)
3480{
3481 RT_NOREF(fFlags);
3482
3483 PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
3484 PDRVAUDIO pThis = PDMINS_2_DATA(pDrvIns, PDRVAUDIO);
3485
3486 int rc2 = RTCritSectEnter(&pThis->CritSect);
3487 AssertRC(rc2);
3488
3489 LogFunc(("%s\n", pThis->szName));
3490
3491 int rc = drvAudioDoAttachInternal(pThis, fFlags);
3492
3493 rc2 = RTCritSectLeave(&pThis->CritSect);
3494 if (RT_SUCCESS(rc))
3495 rc = rc2;
3496
3497 return rc;
3498}
3499
3500/**
3501 * Detach notification.
3502 *
3503 * @param pDrvIns The driver instance data.
3504 * @param fFlags Detach flags.
3505 */
3506static DECLCALLBACK(void) drvAudioDetach(PPDMDRVINS pDrvIns, uint32_t fFlags)
3507{
3508 RT_NOREF(fFlags);
3509
3510 PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
3511 PDRVAUDIO pThis = PDMINS_2_DATA(pDrvIns, PDRVAUDIO);
3512
3513 int rc2 = RTCritSectEnter(&pThis->CritSect);
3514 AssertRC(rc2);
3515
3516 pThis->pHostDrvAudio = NULL;
3517
3518 LogFunc(("%s\n", pThis->szName));
3519
3520 rc2 = RTCritSectLeave(&pThis->CritSect);
3521 AssertRC(rc2);
3522}
3523
3524/**
3525 * Audio driver registration record.
3526 */
3527const PDMDRVREG g_DrvAUDIO =
3528{
3529 /* u32Version */
3530 PDM_DRVREG_VERSION,
3531 /* szName */
3532 "AUDIO",
3533 /* szRCMod */
3534 "",
3535 /* szR0Mod */
3536 "",
3537 /* pszDescription */
3538 "Audio connector driver",
3539 /* fFlags */
3540 PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
3541 /* fClass */
3542 PDM_DRVREG_CLASS_AUDIO,
3543 /* cMaxInstances */
3544 UINT32_MAX,
3545 /* cbInstance */
3546 sizeof(DRVAUDIO),
3547 /* pfnConstruct */
3548 drvAudioConstruct,
3549 /* pfnDestruct */
3550 drvAudioDestruct,
3551 /* pfnRelocate */
3552 NULL,
3553 /* pfnIOCtl */
3554 NULL,
3555 /* pfnPowerOn */
3556 NULL,
3557 /* pfnReset */
3558 NULL,
3559 /* pfnSuspend */
3560 drvAudioSuspend,
3561 /* pfnResume */
3562 drvAudioResume,
3563 /* pfnAttach */
3564 drvAudioAttach,
3565 /* pfnDetach */
3566 drvAudioDetach,
3567 /* pfnPowerOff */
3568 drvAudioPowerOff,
3569 /* pfnSoftReset */
3570 NULL,
3571 /* u32EndVersion */
3572 PDM_DRVREG_VERSION
3573};
3574
Note: See TracBrowser for help on using the repository browser.

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