VirtualBox

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

Last change on this file since 86075 was 82987, checked in by vboxsync, 5 years ago

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

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