VirtualBox

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

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

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