Changeset 73370 in vbox

Timestamp:

Jul 26, 2018 1:52:12 PM (7 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

123987

Message:

Audio: Implemented backend-independent (pre-)buffering support. Work in progress.

Location:

trunk

Files:

• include/VBox/vmm/pdmaudioifs.h (modified) (5 diffs)
• src/VBox/Devices/Audio/AudioMixer.cpp (modified) (7 diffs)
• src/VBox/Devices/Audio/AudioMixer.h (modified) (1 diff)
• src/VBox/Devices/Audio/DevIchAc97.cpp (modified) (1 diff)
• src/VBox/Devices/Audio/DevSB16.cpp (modified) (1 diff)
• src/VBox/Devices/Audio/DrvAudio.cpp (modified) (26 diffs)
• src/VBox/Devices/Audio/DrvAudio.h (modified) (1 diff)
• src/VBox/Devices/Audio/DrvHostALSAAudio.cpp (modified) (21 diffs)
• src/VBox/Devices/Audio/DrvHostCoreAudio.cpp (modified) (5 diffs)
• src/VBox/Devices/Audio/DrvHostDSound.cpp (modified) (36 diffs)
• src/VBox/Devices/Audio/DrvHostDebugAudio.cpp (modified) (2 diffs)
• src/VBox/Devices/Audio/DrvHostNullAudio.cpp (modified) (2 diffs)
• src/VBox/Devices/Audio/DrvHostOSSAudio.cpp (modified) (8 diffs)
• src/VBox/Devices/Audio/DrvHostPulseAudio.cpp (modified) (4 diffs)
• src/VBox/Devices/Audio/DrvHostValidationKit.cpp (modified) (2 diffs)
• src/VBox/Devices/Audio/HDAStream.cpp (modified) (1 diff)
• src/VBox/Devices/Audio/HDAStream.h (modified) (2 diffs)
• src/VBox/Main/include/DrvAudioVRDE.h (modified) (1 diff)
• src/VBox/Main/src-client/ConsoleVRDPServer.cpp (modified) (2 diffs)
• src/VBox/Main/src-client/DrvAudioVRDE.cpp (modified) (14 diffs)
• src/VBox/Main/src-client/DrvAudioVideoRec.cpp (modified) (2 diffs)

trunk/include/VBox/vmm/pdmaudioifs.h

@@ -4 +4 @@
 
 /*
- * Copyright (C) 2006-2017 Oracle Corporation
+ * Copyright (C) 2006-2018 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -82 +82 @@
  * A PDMAUDIOFRAME is the internal representation of a single audio frame, which consists of a single left
  * and right audio sample in time. Only mono (1) and stereo (2) channel(s) currently are supported.
+ *
+ *
+ * == Timing
+ *
+ * Handling audio data in a virtual environment is hard, as the human perception is very sensitive
+ * to the slightest cracks and stutters in the audible data. This can happen if the VM's timing is
+ * lagging behind or not within the expected time frame.
+ *
+ * The two main components which unfortunately contradict each other is a) the audio device emulation
+ * and b) the audio backend(s) on the host. Those need to be served in a timely manner to function correctly.
+ * To make e.g. the device emulation rely on the pace the host backend(s) set - or vice versa - will not work,
+ * as the guest's audio system / drivers then will not be able to compensate this accordingly.
+ *
+ * So each component, the device emulation, the audio connector(s) and the backend(s) must do its thing
+ * *when* it needs to do it, independently of the others. For that we use various (small) ring buffers to
+ * (hopefully) serve all components with the amount of data *when* they need it.
+ *
+ * Additionally, the device emulation can run with a different audio frame size, while the backends(s) may
+ * require a different frame size (16 bit stereo -> 8 bit mono, for example).
+ *
+ * The device emulation can give the audio connector(s) a scheduling hint (optional), e.g. in which interval
+ * it expects any data processing.
+ *
+ * A data transfer for playing audio data from the guest on the host looks like this:
+ * (RB = Ring Buffer, MB = Mixing Buffer)
+ *
+ * (A) Device DMA -> (B) Device RB -> (C) Audio Connector Guest MB -> (D) Audio Connector Host MB -> \
+ * (E) Backend RB (optional, up to the backend) > (F) Backend audio framework
+ *
+ * For capturing audio data the above chain is similar, just in a different direction, of course.
+ *
+ * The audio connector hereby plays a key role when it comes to (pre-) buffering data to minimize any audio stutters
+ * and/or cracks. The following values, which also can be tweaked via CFGM / extra-data are available:
+ *
+ * - The pre-buffering time (in ms): Audio data which needs to be buffered before any playback (or capturing) can happen.
+ * - The actual buffer size (in ms): How big the mixing buffer (for C and D) will be.
+ * - The period size (in ms): How big a chunk of audio (often called period or fragment) for F must be to get handled correctly.
+ *
+ * The above values can be set on a per-driver level, whereas input and output streams for a driver also can be handled
+ * set independently. The verbose audio (release) log will tell about the (final) state of each audio stream.
  *
  *
@@ -535 +575 @@
      *      The audio data will get handled as PDMAUDIOFRAME frames without any modification done. */
     PDMAUDIOSTREAMLAYOUT     enmLayout;
-    /** Hint about the optimal frame buffer size (in audio frames).
-     *  0 if no hint is given. */
-    uint32_t                 cFrameBufferHint;
+    /** Device emulation-specific data needed for the audio connector. */
     struct
     {
-        /** Scheduling hint given from the device emulation about when this stream is being served on average.
+        /** Scheduling hint set by the device emulation about when this stream is being served on average (in ms).
          *  Can be 0 if not hint given or some other mechanism (e.g. callbacks) is being used. */
         uint32_t             uSchedulingHintMs;
@@ -546 +584 @@
     /**
      * Backend-specific data for the stream.
+     * On input (requested configuration) those values are set by the audio connector to let the backend know what we expect.
+     * On output (acquired configuration) those values reflect the values set and used by the backend.
      * Set by the backend on return. Not all backends support all values / features.
      */
@@ -999 +1039 @@
     PDMAUDIOSTREAMCTX      enmCtx;
     /** Timestamp (in ms) since last iteration. */
-    uint64_t               tsLastIterateMS;
+    uint64_t               tsLastIteratedMs;
+    /** Timestamp (in ms) since last playback / capture. */
+    uint64_t               tsLastPlayedCapturedMs;
+    /** Timestamp (in ms) since last read (input streams) or
+     *  write (output streams). */
+    uint64_t               tsLastReadWrittenMs;
+    /** For output streams this indicates whether the stream has reached
+     *  its playback threshold, e.g. is playing audio.
+     *  For input streams this  indicates whether the stream has enough input
+     *  data to actually start reading audio. */
+    bool                   fThresholdReached;
     /** Union for input/output specifics. */
     union

trunk/src/VBox/Devices/Audio/AudioMixer.cpp

@@ -853 +853 @@
     uint32_t cbReadable = 0;
 
+    if (pSink->fStatus & AUDMIXSINK_STS_RUNNING)
+    {
 #ifdef VBOX_AUDIO_MIXER_WITH_MIXBUF
 # error "Implement me!"
 #else
-    /* The hosts sets the pace --
-     * so we try to find the maximum of readable data of all connected streams to this sink. */
-    PAUDMIXSTREAM pMixStream;
-    RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
-    {
-        if (!(pMixStream->pConn->pfnStreamGetStatus(pMixStream->pConn, pMixStream->pStream) & PDMAUDIOSTREAMSTS_FLAG_ENABLED))
-        {
-            Log3Func(("[%s] Stream '%s' disabled, skipping ...\n", pSink->pszName, pMixStream->pszName));
-            continue;
-        }
-
-        cbReadable = RT_MAX(cbReadable,
-                            pMixStream->pConn->pfnStreamGetReadable(pMixStream->pConn, pMixStream->pStream));
-
-        break; /** @todo For now we only support recording by the first stream added. */
-    }
+        /* Return how much data we can deliver since the last read. */
+        cbReadable = DrvAudioHlpMsToBytes(&pSink->PCMProps, RTTimeMilliTS() - pSink->tsLastReadWrittenMs);
 #endif
+    }
 
     Log3Func(("[%s] cbReadable=%RU32\n", pSink->pszName, cbReadable));
@@ -899 +888 @@
         return 0;
 
-    uint32_t cbWritable = UINT32_MAX;
+    uint32_t cbWritable = 0;
 
     if (    (pSink->fStatus & AUDMIXSINK_STS_RUNNING)
@@ -907 +896 @@
 # error "Implement me!"
 #else
-        /* The hosts sets the pace --
-         * so we try to find the minimum of writable data to all connected streams to this sink. */
-        PAUDMIXSTREAM pMixStream;
-        RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
-        {
-            const uint32_t cbWritableStream = pMixStream->pConn->pfnStreamGetWritable(pMixStream->pConn, pMixStream->pStream);
-
-            Log3Func(("[%s] Stream '%s' cbWritableStream=%RU32\n", pSink->pszName, pMixStream->pszName, cbWritableStream));
-
-            if (cbWritableStream < cbWritable)
-                cbWritable = cbWritableStream;
-        }
+        /* Return how much data we expect since the last write. */
+        cbWritable = DrvAudioHlpMsToBytes(&pSink->PCMProps, RTTimeMilliTS() - pSink->tsLastReadWrittenMs);
 #endif
     }
-
-    if (cbWritable == UINT32_MAX)
-        cbWritable = 0;
 
     Log3Func(("[%s] cbWritable=%RU32\n", pSink->pszName, cbWritable));
@@ -1167 +1143 @@
             pSink->fStatus &= ~AUDMIXSINK_STS_DIRTY;
 
+        /* Update our last read time stamp. */
+        pSink->tsLastReadWrittenMs = RTTimeMilliTS();
+
 #ifdef VBOX_AUDIO_MIXER_WITH_MIXBUF
 # error "Implement me!"
@@ -1304 +1283 @@
 
     /* Update last updated timestamp. */
-    pSink->tsLastUpdatedMS = RTTimeMilliTS();
+    pSink->tsLastUpdatedMs = RTTimeMilliTS();
 
     /* Reset status. */
@@ -1581 +1560 @@
 
     /* Update last updated timestamp. */
-    pSink->tsLastUpdatedMS = RTTimeMilliTS();
+    pSink->tsLastUpdatedMs = RTTimeMilliTS();
 
     /* All streams disabled and the sink is in pending disable mode? */
@@ -1758 +1737 @@
     }
 
+    /* Update our last written time stamp. */
+    pSink->tsLastReadWrittenMs = RTTimeMilliTS();
+
     if (pcbWritten)
         *pcbWritten = cbBuf; /* Always report everything written, as the backends need to keep up themselves. */

trunk/src/VBox/Devices/Audio/AudioMixer.h

@@ -196 +196 @@
     /** The volume of this sink, combined with the last set  master volume. */
     PDMAUDIOVOLUME          VolumeCombined;
-    /** Timestamp (in ms) since last update. */
-    uint64_t                tsLastUpdatedMS;
+    /** Timestamp since last update (in ms). */
+    uint64_t                tsLastUpdatedMs;
+    /** Last read (recording) / written (playback) timestamp (in ms). */
+    uint64_t                tsLastReadWrittenMs;
 #ifdef VBOX_AUDIO_MIXER_DEBUG
     struct

trunk/src/VBox/Devices/Audio/DevIchAc97.cpp

@@ -313 +313 @@
     /** The stream's current configuration. */
     PDMAUDIOSTREAMCFG     Cfg; //+104
+    uint32_t              Padding2;
 #ifdef VBOX_WITH_AUDIO_AC97_ASYNC_IO
     /** Asynchronous I/O state members. */

trunk/src/VBox/Devices/Audio/DevSB16.cpp

@@ -1605 +1605 @@
         pThis->left_till_irq = pThis->block_size;
 
-    uint32_t cbOutMin = UINT32_MAX;
-
-    PSB16DRIVER pDrv;
-    RTListForEach(&pThis->lstDrv, pDrv, SB16DRIVER, Node)
-    {
-        if (!pDrv->Out.pStream)
-            continue;
-
-        uint32_t cbOut = pDrv->pConnector->pfnStreamGetWritable(pDrv->pConnector, pDrv->Out.pStream);
-
-        if (cbOut < cbOutMin)
-            cbOutMin = cbOut;
-    }
-
-    LogFlowFunc(("cbOutMin=%RU32\n", cbOutMin));
-    if (cbOutMin == UINT32_MAX)
-    {
-        free = dma_len;
-    }
-    else
-    {
-        free = cbOutMin & ~pThis->align; /** @todo int vs. uint32. */
-        if ((free <= 0) || !dma_len)
-            return dma_pos;
-    }
+    free = dma_len;
 
     copy = free;

trunk/src/VBox/Devices/Audio/DrvAudio.cpp

@@ -560 +560 @@
         }
 
+        case PDMAUDIOSTREAMCMD_DRAIN:
+        {
+            rc = pThis->pHostDrvAudio->pfnStreamControl(pThis->pHostDrvAudio, pHstStream->pvBackend, PDMAUDIOSTREAMCMD_DRAIN);
+            break;
+        }
+
         default:
         {
@@ -570 +576 @@
     if (RT_FAILURE(rc))
     {
-        LogRel(("Audio: %s stream '%s' failed with %Rrc\n", DrvAudioHlpStreamCmdToStr(enmStreamCmd), pHstStream->szName, rc));
+        if (   rc != VERR_NOT_IMPLEMENTED
+            && rc != VERR_NOT_SUPPORTED)
+            LogRel(("Audio: %s stream '%s' failed with %Rrc\n", DrvAudioHlpStreamCmdToStr(enmStreamCmd), pHstStream->szName, rc));
+
         LogFunc(("[%s] %s failed with %Rrc\n", pStream->szName, DrvAudioHlpStreamCmdToStr(enmStreamCmd), rc));
     }
@@ -598 +607 @@
     AssertPtr(pGstStream);
 
+/*    pCfgHost->Backend.cfPreBuf = DrvAudioHlpMsToFrames(&pCfgHost->Props,
+                                                       pCfgGuest->enmDir == PDMAUDIODIR_IN
+                                                       ? pThis->In.msLatencyHost : pThis->Out.msLatencyHost);*/
+    /* Latency can be 0 if not configured. */
+
     /*
      * Init host stream.
@@ -606 +620 @@
 
 #ifdef DEBUG
-    LogFunc(("[%s] Requested host format:\n", pStream->szName));
+    LogFunc(("[%s] Requested host format:\n", pHstStream->szName));
     DrvAudioHlpStreamCfgPrint(pCfgHost);
-#else
-    LogRel2(("Audio: Creating stream '%s'\n", pStream->szName));
-    LogRel2(("Audio: Requested %s host format for '%s': %RU32Hz, %RU8%s, %RU8 %s\n",
-             pCfgGuest->enmDir == PDMAUDIODIR_IN ? "recording" : "playback", pStream->szName,
+#endif
+
+    LogRel2(("Audio: Creating stream '%s'\n", pHstStream->szName));
+    LogRel2(("Audio: Guest %s format for '%s': %RU32Hz, %RU8%s, %RU8 %s\n",
+             pCfgGuest->enmDir == PDMAUDIODIR_IN ? "recording" : "playback", pGstStream->szName,
+             pCfgGuest->Props.uHz, pCfgGuest->Props.cBits, pCfgGuest->Props.fSigned ? "S" : "U",
+             pCfgGuest->Props.cChannels, pCfgGuest->Props.cChannels == 1 ? "Channel" : "Channels"));
+    LogRel2(("Audio: Requested host %s format for '%s': %RU32Hz, %RU8%s, %RU8 %s\n",
+             pCfgHost->enmDir == PDMAUDIODIR_IN ? "recording" : "playback", pHstStream->szName,
              pCfgHost->Props.uHz, pCfgHost->Props.cBits, pCfgHost->Props.fSigned ? "S" : "U",
-             pCfgHost->Props.cChannels, pCfgHost->Props.cChannels == 0 ? "Channel" : "Channels"));
-#endif
+             pCfgHost->Props.cChannels, pCfgHost->Props.cChannels == 1 ? "Channel" : "Channels"));
 
     PDMAUDIOSTREAMCFG CfgHostAcq;
@@ -622 +640 @@
 
 #ifdef DEBUG
-    LogFunc(("[%s] Acquired host format:\n",  pStream->szName));
+    LogFunc(("[%s] Acquired host format:\n",  pHstStream->szName));
     DrvAudioHlpStreamCfgPrint(&CfgHostAcq);
-#else
-    LogRel2(("Audio: Acquired %s host format for '%s': %RU32Hz, %RU8%s, %RU8 %s\n",
+#endif
+
+    LogRel2(("Audio: Acquired host %s format for '%s': %RU32Hz, %RU8%s, %RU8 %s\n",
              CfgHostAcq.enmDir == PDMAUDIODIR_IN ? "recording" : "playback",  pStream->szName,
              CfgHostAcq.Props.uHz, CfgHostAcq.Props.cBits, CfgHostAcq.Props.fSigned ? "S" : "U",
-             CfgHostAcq.Props.cChannels, CfgHostAcq.Props.cChannels == 0 ? "Channel" : "Channels"));
-#endif
-
-    /* No frame buffer size hint given by the backend? Default to some sane value. */
-    if (!CfgHostAcq.cFrameBufferHint)
-    {
-        CfgHostAcq.cFrameBufferHint = _1K; /** @todo Make this configurable? */
-    }
+             CfgHostAcq.Props.cChannels, CfgHostAcq.Props.cChannels == 1 ? "Channel" : "Channels"));
+
+    /* Let the user know if the backend changed some of the tweakable values. */
+    if (CfgHostAcq.Backend.cfBufferSize != pCfgHost->Backend.cfBufferSize)
+        LogRel2(("Audio: Backend changed buffer size from %RU32 to %RU32 frames\n",
+                 pCfgHost->Backend.cfBufferSize, CfgHostAcq.Backend.cfBufferSize));
+
+    if (CfgHostAcq.Backend.cfPeriod != pCfgHost->Backend.cfPeriod)
+        LogRel2(("Audio: Backend changed period size from %RU32 to %RU32 frames\n",
+                 pCfgHost->Backend.cfPeriod, CfgHostAcq.Backend.cfPeriod));
+
+    if (CfgHostAcq.Backend.cfPreBuf != pCfgHost->Backend.cfPreBuf)
+        LogRel2(("Audio: Backend changed pre-buffering size from %RU32 to %RU32 frames\n",
+                 pCfgHost->Backend.cfPreBuf, CfgHostAcq.Backend.cfPreBuf));
+
+    /*
+     * Configure host buffers.
+     */
+
+    /* If no own pre-buffer is set, let the backend choose. */
+    uint32_t msPreBuf = DrvAudioHlpFramesToMs(&pCfgHost->Props, CfgHostAcq.Backend.cfPreBuf);
+    LogRel2(("Audio: Pre-buffering size of stream '%s' is %RU32ms (%RU32 frames)\n",
+             pHstStream->szName, msPreBuf, CfgHostAcq.Backend.cfPreBuf));
+
+    /* Make sure the configured buffer size by the backend at least can hold the configured latency. */
+    const uint32_t msPeriod = DrvAudioHlpFramesToMs(&pCfgHost->Props, CfgHostAcq.Backend.cfPeriod);
+
+    LogRel2(("Audio: Period size of stream '%s' is %RU32ms (%RU32 frames)\n",
+             pHstStream->szName, msPeriod, CfgHostAcq.Backend.cfPeriod));
+
+    /* Check if the backend did return sane values and correct if necessary. */
+    if (CfgHostAcq.Backend.cfBufferSize < CfgHostAcq.Backend.cfPeriod)
+    {
+        LogRel2(("Audio: Warning: Backend of stream '%s' did not set a valid buffer size (%RU32 frames), setting to %RU32 frames",
+                 pHstStream->szName, CfgHostAcq.Backend.cfBufferSize, CfgHostAcq.Backend.cfPeriod));
+        AssertFailed(); /* Should never happen. */
+    }
+
+    uint32_t msBufferSize = DrvAudioHlpFramesToMs(&pCfgHost->Props, CfgHostAcq.Backend.cfBufferSize);
+
+    LogRel2(("Audio: Buffer size of stream '%s' is %RU32ms (%RU32 frames)\n",
+             pHstStream->szName, msBufferSize, CfgHostAcq.Backend.cfBufferSize));
+
+    /* Set set host buffer size multiplicator. */
+    const unsigned cHstBufferFactor = 2; /** @todo Make this configurable. */
 
     /* Destroy any former mixing buffer. */
@@ -643 +699 @@
     CfgHostAcq.Props.cShift = PDMAUDIOPCMPROPS_MAKE_SHIFT_PARMS(CfgHostAcq.Props.cBits, CfgHostAcq.Props.cChannels);
 
-    /* Set set host buffer size multiplicator. */
-    const unsigned cFrameBufferHostFactor = 2; /** @todo Make this configurable. */
-
-    LogFunc(("[%s] cFrames=%RU32 (x %u)\n", pHstStream->szName, CfgHostAcq.cFrameBufferHint, cFrameBufferHostFactor));
-
     int rc2 = AudioMixBufInit(&pHstStream->MixBuf, pHstStream->szName, &CfgHostAcq.Props,
-                              CfgHostAcq.cFrameBufferHint * cFrameBufferHostFactor);
+                              CfgHostAcq.Backend.cfBufferSize * cHstBufferFactor);
     AssertRC(rc2);
 
@@ -660 +711 @@
      */
 
+    if (pCfgGuest->Device.uSchedulingHintMs)
+        LogRel2(("Audio: Stream '%s' got a scheduling hint of %RU32ms\n", pGstStream->szName, pCfgGuest->Device.uSchedulingHintMs));
+
     /* Destroy any former mixing buffer. */
     AudioMixBufDestroy(&pGstStream->MixBuf);
 
     /* Set the guests's default audio data layout. */
-    pCfgHost->enmLayout = PDMAUDIOSTREAMLAYOUT_NON_INTERLEAVED;
+    pCfgGuest->enmLayout = PDMAUDIOSTREAMLAYOUT_NON_INTERLEAVED;
 
     /* Make sure to (re-)set the guest buffer's shift size. */
@@ -670 +724 @@
 
     /* Set set guest buffer size multiplicator. */
-    const unsigned cFrameBufferGuestFactor = 10; /** @todo Make this configurable. */
-
-    LogFunc(("[%s] cFrames=%RU32 (x %u)\n", pGstStream->szName, CfgHostAcq.cFrameBufferHint, cFrameBufferGuestFactor));
+    const unsigned cGstBufferFactor = 4; /** @todo Make this configurable. */
 
     rc2 = AudioMixBufInit(&pGstStream->MixBuf, pGstStream->szName, &pCfgGuest->Props,
-                          CfgHostAcq.cFrameBufferHint * cFrameBufferGuestFactor);
+                          CfgHostAcq.Backend.cfBufferSize * cGstBufferFactor);
     AssertRC(rc2);
 
@@ -938 +990 @@
         }
 
-        const uint32_t cbFree = AudioMixBufFreeBytes(&pGstStream->MixBuf);
-        if (!cbFree) /* No free guest side buffer space, bail out. */
-        {
-            AssertMsgFailed(("[%s] Stream full\n", pGstStream->szName));
+        const uint32_t cbFree = AudioMixBufFreeBytes(&pHstStream->MixBuf);
+        if (cbFree < cbBuf) /* No space left on host side? Bail out. */
+            LogRel2(("Audio: Lost audio frames (%RU32) due to full host stream '%s', expect stuttering audio output\n",
+                     DrvAudioHlpBytesToFrames(&pHstStream->Cfg.Props, cbBuf - cbFree), pHstStream->szName));
+
+        uint32_t cbToWrite = RT_MIN(cbBuf, cbFree);
+        if (cbToWrite > cbBuf) /* Paranoia. */
+            cbToWrite = cbBuf;
+
+        if (!cbToWrite)
             break;
-        }
-
-        /* Do not attempt to write more than the guest side currently can handle. */
-        if (cbBuf > cbFree)
-            cbBuf = cbFree;
+
+        uint64_t tsDeltaWrittenMs = RTTimeMilliTS() - pHstStream->tsLastReadWrittenMs;
+
+        Log3Func(("[%s] fThresholdReached=%RTbool, tsDeltaWrittenMs=%RU64\n",
+                  pHstStream->szName, pHstStream->fThresholdReached, tsDeltaWrittenMs));
+
+        if (   pHstStream->fThresholdReached
+            && tsDeltaWrittenMs < pGstStream->Cfg.Device.uSchedulingHintMs)
+        {
+            break;
+        }
 
         /* We use the guest side mixing buffer as an intermediate buffer to do some
          * (first) processing (if needed), so always write the incoming data at offset 0. */
-        uint32_t cfWritten = 0;
-        rc = AudioMixBufWriteAt(&pGstStream->MixBuf, 0 /* offFrames */, pvBuf, cbBuf, &cfWritten);
+        uint32_t cfGstWritten = 0;
+        rc = AudioMixBufWriteAt(&pGstStream->MixBuf, 0 /* offFrames */, pvBuf, cbToWrite, &cfGstWritten);
         if (   RT_FAILURE(rc)
-            || !cfWritten)
-        {
-            AssertMsgFailed(("[%s] Write failed: cbBuf=%RU32, cfWritten=%RU32, rc=%Rrc\n",
-                             pGstStream->szName, cbBuf, cfWritten, rc));
+            || !cfGstWritten)
+        {
+            AssertMsgFailed(("[%s] Write failed: cbToWrite=%RU32, cfWritten=%RU32, rc=%Rrc\n",
+                             pGstStream->szName, cbToWrite, cfGstWritten, rc));
             break;
         }
 
         if (pThis->Out.Cfg.Dbg.fEnabled)
-            DrvAudioHlpFileWrite(pHstStream->Out.Dbg.pFileStreamWrite, pvBuf, cbBuf, 0 /* fFlags */);
+            DrvAudioHlpFileWrite(pHstStream->Out.Dbg.pFileStreamWrite, pvBuf, cbToWrite, 0 /* fFlags */);
 
 #ifdef VBOX_WITH_STATISTICS
-        STAM_COUNTER_ADD(&pThis->Stats.TotalFramesWritten, cfWritten);
+        STAM_COUNTER_ADD(&pThis->Stats.TotalFramesWritten, cfGstWritten);
 #endif
-        uint32_t cfMixed = 0;
-        if (cfWritten)
-        {
-            int rc2 = AudioMixBufMixToParentEx(&pGstStream->MixBuf, 0 /* cSrcOffset */, cfWritten /* cSrcFrames */,
-                                               &cfMixed /* pcSrcMixed */);
-            if (   RT_FAILURE(rc2)
-                || cfMixed < cfWritten)
+        uint32_t cfGstMixed = 0;
+        if (cfGstWritten)
+        {
+            int rc2 = AudioMixBufMixToParentEx(&pGstStream->MixBuf, 0 /* cSrcOffset */, cfGstWritten /* cSrcFrames */,
+                                               &cfGstMixed /* pcSrcMixed */);
+            if (RT_FAILURE(rc2))
             {
-                AssertMsgFailed(("[%s] Mixing failed: cbBuf=%RU32, cfWritten=%RU32, cfMixed=%RU32, rc=%Rrc\n",
-                                 pGstStream->szName, cbBuf, cfWritten, cfMixed, rc2));
-
-                LogRel2(("Audio: Lost audio frames (%RU32) due to full host stream '%s', expect stuttering audio output\n",
-                         cfWritten - cfMixed, pHstStream->szName));
+                AssertMsgFailed(("[%s] Mixing failed: cbToWrite=%RU32, cfWritten=%RU32, cfMixed=%RU32, rc=%Rrc\n",
+                                 pGstStream->szName, cbToWrite, cfGstWritten, cfGstMixed, rc2));
+            }
+            else
+            {
+                Log3Func(("[%s] Buffer: Last written %RU64ms, writing %RU32 frames (%RU64ms), now filled with %RU64ms -- %RU8%%\n",
+                          pHstStream->szName, tsDeltaWrittenMs, cfGstWritten, DrvAudioHlpFramesToMs(&pHstStream->Cfg.Props, cfGstWritten),
+                          DrvAudioHlpFramesToMs(&pHstStream->Cfg.Props, AudioMixBufUsed(&pHstStream->MixBuf)),
+                          AudioMixBufUsed(&pHstStream->MixBuf) * 100 / AudioMixBufSize(&pHstStream->MixBuf)));
+
+                pHstStream->tsLastReadWrittenMs = RTTimeMilliTS();
 
                 /* Keep going. */
@@ -987 +1056 @@
                 rc = rc2;
 
-            cbWrittenTotal = AUDIOMIXBUF_F2B(&pGstStream->MixBuf, cfWritten);
+            cbWrittenTotal = AUDIOMIXBUF_F2B(&pGstStream->MixBuf, cfGstWritten);
 
 #ifdef VBOX_WITH_STATISTICS
-            STAM_COUNTER_ADD(&pThis->Stats.TotalFramesMixedOut,      cfMixed);
-            Assert(cfWritten >= cfMixed);
-            STAM_COUNTER_ADD(&pThis->Stats.TotalFramesLostOut,       cfWritten - cfMixed);
+            STAM_COUNTER_ADD(&pThis->Stats.TotalFramesMixedOut,      cfGstMixed);
+            Assert(cfGstWritten >= cfGstMixed);
+            STAM_COUNTER_ADD(&pThis->Stats.TotalFramesLostOut,       cfGstWritten - cfGstMixed);
             STAM_COUNTER_ADD(&pThis->Stats.TotalBytesWritten,        cbWrittenTotal);
             STAM_COUNTER_ADD(&pGstStream->Out.StatBytesTotalWritten, cbWrittenTotal);
@@ -998 +1067 @@
         }
 
-        Log3Func(("[%s] cbBuf=%RU32, cUsed=%RU32, cLive=%RU32, cWritten=%RU32, cMixed=%RU32, rc=%Rrc\n",
-                  pGstStream->szName,
-                  cbBuf, AudioMixBufUsed(&pGstStream->MixBuf), AudioMixBufLive(&pGstStream->MixBuf), cfWritten, cfMixed, rc));
+        Log3Func(("[%s] cbToWrite=%RU32, cfUsed=%RU32, cfLive=%RU32, cfWritten=%RU32, cfMixed=%RU32, rc=%Rrc\n",
+                  pGstStream->szName, cbToWrite, AudioMixBufUsed(&pGstStream->MixBuf),
+                  AudioMixBufLive(&pGstStream->MixBuf), cfGstWritten, cfGstMixed, rc));
 
     } while (0);
@@ -1189 +1258 @@
             /* No audio frames to transfer from guest to host (anymore)?
              * Then try closing this stream if marked so in the next block. */
-            fTryClosePending = AudioMixBufLive(&pHstStream->MixBuf) == 0;
+            const uint32_t cfLive = AudioMixBufLive(&pHstStream->MixBuf);
+            fTryClosePending = cfLive == 0;
+            Log3Func(("[%s] fTryClosePending=%RTbool, cfLive=%RU32\n", pHstStream->szName, fTryClosePending, cfLive));
         }
         else
@@ -1199 +1270 @@
             && fTryClosePending)
         {
-            if (pThis->pHostDrvAudio->pfnStreamGetPending) /* Optional to implement. */
+            /* Tell the backend to drain the stream, that is, play the remaining (buffered) data
+             * on the backend side. */
+            rc = drvAudioStreamControlInternalBackend(pThis, pHstStream, PDMAUDIOSTREAMCMD_DRAIN);
+            if (rc == VERR_NOT_SUPPORTED) /* Not all backends support draining. */
+                rc = VINF_SUCCESS;
+
+            if (RT_SUCCESS(rc))
             {
-                const uint32_t cxPending = pThis->pHostDrvAudio->pfnStreamGetPending(pThis->pHostDrvAudio, pHstStream->pvBackend);
-                Log3Func(("[%s] cxPending=%RU32\n", pHstStream->szName, cxPending));
-
-                /* Only try close pending if no audio data is pending on the backend-side anymore. */
-                fTryClosePending = cxPending == 0;
+                if (pThis->pHostDrvAudio->pfnStreamGetPending) /* Optional to implement. */
+                {
+                    const uint32_t cxPending = pThis->pHostDrvAudio->pfnStreamGetPending(pThis->pHostDrvAudio, pHstStream->pvBackend);
+                    Log3Func(("[%s] cxPending=%RU32\n", pHstStream->szName, cxPending));
+
+                    /* Only try close pending if no audio data is pending on the backend-side anymore. */
+                    fTryClosePending = cxPending == 0;
+                }
+
+                if (fTryClosePending)
+                {
+                    LogFunc(("[%s] Closing pending stream\n", pHstStream->szName));
+                    rc = drvAudioStreamControlInternalBackend(pThis, pHstStream, PDMAUDIOSTREAMCMD_DISABLE);
+                    if (RT_FAILURE(rc))
+                        LogFunc(("[%s] Backend vetoed against closing pending input stream, rc=%Rrc\n", pHstStream->szName, rc));
+                }
             }
-
-            if (fTryClosePending)
-            {
-                LogFunc(("[%s] Closing pending stream\n", pHstStream->szName));
-                rc = drvAudioStreamControlInternalBackend(pThis, pHstStream, PDMAUDIOSTREAMCMD_DISABLE);
-                if (RT_FAILURE(rc))
-                    LogFunc(("[%s] Backend vetoed against closing pending input stream, rc=%Rrc\n", pHstStream->szName, rc));
-            }
         }
 
@@ -1220 +1300 @@
 
     /* Update timestamps. */
-    pHstStream->tsLastIterateMS = RTTimeMilliTS();
-    pGstStream->tsLastIterateMS = RTTimeMilliTS();
+    pGstStream->tsLastIteratedMs = RTTimeMilliTS();
 
     if (RT_FAILURE(rc))
@@ -1477 +1556 @@
     uint32_t cfPlayedTotal = 0;
 
+    if (!pThis->pHostDrvAudio)
+        return VINF_SUCCESS;
+
+    PPDMAUDIOSTREAM pHstStream = drvAudioGetHostStream(pStream);
+    AssertPtr(pHstStream);
+    PPDMAUDIOSTREAM pGstStream = pHstStream ? pHstStream->pPair : NULL;
+    AssertPtr(pGstStream);
+
+    AssertReleaseMsgReturn(pHstStream != NULL,
+                              ("[%s] Host stream is NULL (cRefs=%RU32, fStatus=%x, enmCtx=%ld)\n",
+                               pStream->szName, pStream->cRefs, pStream->fStatus, pStream->enmCtx),
+                              VERR_NOT_AVAILABLE);
+    AssertReleaseMsgReturn(pGstStream != NULL,
+                            ("[%s] Guest stream is NULL (cRefs=%RU32, fStatus=%x, enmCtx=%ld)\n",
+                               pStream->szName, pStream->cRefs, pStream->fStatus, pStream->enmCtx),
+                               VERR_NOT_AVAILABLE);
+
+    PDMAUDIOSTREAMSTS stsHstStream = pHstStream->fStatus;
+#ifdef LOG_ENABLED
+    char *pszStreamSts = dbgAudioStreamStatusToStr(stsHstStream);
+    Log3Func(("[%s] Start: stsHstStream=%s\n", pHstStream->szName, pszStreamSts));
+    RTStrFree(pszStreamSts);
+#endif /* LOG_ENABLED */
+
     do
     {
-        if (!pThis->pHostDrvAudio)
-            break;
-
-        PPDMAUDIOSTREAM pHstStream = drvAudioGetHostStream(pStream);
-        AssertPtr(pHstStream);
-        PPDMAUDIOSTREAM pGstStream = pHstStream ? pHstStream->pPair : NULL;
-        AssertPtr(pGstStream);
-
-        AssertReleaseMsgBreakStmt(pHstStream != NULL,
-                                  ("[%s] Host stream is NULL (cRefs=%RU32, fStatus=%x, enmCtx=%ld)\n",
-                                   pStream->szName, pStream->cRefs, pStream->fStatus, pStream->enmCtx),
-                                  rc = VERR_NOT_AVAILABLE);
-        AssertReleaseMsgBreakStmt(pGstStream != NULL,
-                                  ("[%s] Guest stream is NULL (cRefs=%RU32, fStatus=%x, enmCtx=%ld)\n",
-                                   pStream->szName, pStream->cRefs, pStream->fStatus, pStream->enmCtx),
-                                  rc = VERR_NOT_AVAILABLE);
-
         /*
          * Check if the backend is ready to operate.
          */
-
-        AssertPtr(pThis->pHostDrvAudio->pfnStreamGetStatus);
-        PDMAUDIOSTREAMSTS stsBackend = pThis->pHostDrvAudio->pfnStreamGetStatus(pThis->pHostDrvAudio, pHstStream->pvBackend);
+        if (!(stsHstStream & PDMAUDIOSTREAMSTS_FLAG_ENABLED)) /* Stream disabled? Bail out. */
+            break;
+
+              uint32_t cfLive       = AudioMixBufLive(&pHstStream->MixBuf);
+        const uint8_t  uLivePercent = (100 * cfLive) / AudioMixBufSize(&pHstStream->MixBuf);
+
+        if (!pHstStream->tsLastPlayedCapturedMs)
+            pHstStream->tsLastPlayedCapturedMs = RTTimeMilliTS();
+        uint64_t tsDeltaPlayedCapturedMs = RTTimeMilliTS() - pHstStream->tsLastPlayedCapturedMs;
+        pHstStream->tsLastPlayedCapturedMs = RTTimeMilliTS();
+
 #ifdef LOG_ENABLED
-        char *pszBackendSts = dbgAudioStreamStatusToStr(stsBackend);
-        Log3Func(("[%s] Start: stsBackend=%s\n", pHstStream->szName, pszBackendSts));
-        RTStrFree(pszBackendSts);
-#endif /* LOG_ENABLED */
-        if (!(stsBackend & PDMAUDIOSTREAMSTS_FLAG_ENABLED)) /* Backend disabled? Bail out. */
-            break;
-
-        uint32_t cfToPlay = AudioMixBufLive(&pHstStream->MixBuf);
-
-        if (pThis->pHostDrvAudio->pfnStreamPlayBegin)
-            pThis->pHostDrvAudio->pfnStreamPlayBegin(pThis->pHostDrvAudio, pHstStream->pvBackend);
-
-        if (RT_LIKELY(pHstStream->Cfg.enmLayout == PDMAUDIOSTREAMLAYOUT_NON_INTERLEAVED))
-        {
-            rc = drvAudioStreamPlayNonInterleaved(pThis, pHstStream, cfToPlay, &cfPlayedTotal);
-        }
-        else if (pHstStream->Cfg.enmLayout == PDMAUDIOSTREAMLAYOUT_RAW)
-        {
-            rc = drvAudioStreamPlayRaw(pThis, pHstStream, cfToPlay, &cfPlayedTotal);
-        }
-        else
-            AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
-
-        if (pThis->pHostDrvAudio->pfnStreamPlayEnd)
-            pThis->pHostDrvAudio->pfnStreamPlayEnd(pThis->pHostDrvAudio, pHstStream->pvBackend);
-
-#ifdef LOG_ENABLED
-        uint32_t cfLive = 0;
+        Log3Func(("[%s] Buffer: Last played %RU64ms, filled with %RU64ms (%RU8%%) total, "
+                  "(cfLive=%RU32, fThresholdReached=%RTbool)\n",
+                  pHstStream->szName, tsDeltaPlayedCapturedMs, DrvAudioHlpFramesToMs(&pHstStream->Cfg.Props, cfLive),
+                  uLivePercent, cfLive, pHstStream->fThresholdReached));
 #endif
+        bool fDoPlay      = pHstStream->fThresholdReached;
+        bool fJustStarted = false;
+        if (!fDoPlay)
+        {
+            /* Did we reach the backend's playback (pre-buffering) threshold? Can be 0 if no threshold set. */
+            if (cfLive >= pHstStream->Cfg.Backend.cfPreBuf)
+            {
+                LogRel2(("Audio: Stream '%s' buffering complete\n", pHstStream->szName));
+                fDoPlay = true;
+            }
+
+            /* Some audio files are shorter than the pre-buffering level (e.g. the "click" Explorer sounds on some Windows guests),
+             * so make sure that we also play those by checking if the stream already is pending disable mode, even if we didn't
+             * hit the pre-buffering watermark yet.
+             *
+             * To reproduce, use "Windows Navigation Start.wav" on Windows 7 (2824 samples). */
+            if (   cfLive
+                && pHstStream->fStatus & PDMAUDIOSTREAMSTS_FLAG_PENDING_DISABLE)
+            {
+                LogRel2(("Audio: Stream '%s' buffering complete (short sound)\n", pHstStream->szName));
+                fDoPlay = true;
+            }
+
+            if (fDoPlay)
+            {
+                pHstStream->fThresholdReached = true;
+                fJustStarted = true;
+                LogRel2(("Audio: Stream '%s' started playing\n", pHstStream->szName));
+            }
+            else /* Not yet, so still buffering audio data. */
+                LogRel2(("Audio: Stream '%s' is buffering (%RU8%% complete)\n",
+                         pHstStream->szName, (100 * cfLive) / pHstStream->Cfg.Backend.cfPreBuf));
+        }
+
+        if (fDoPlay)
+        {
+            if (pHstStream->tsLastPlayedCapturedMs < 2)
+                break;
+
+            uint32_t cfToPlay;
+            if (fJustStarted)
+                cfToPlay = pHstStream->Cfg.Backend.cfPeriod;
+            else
+                cfToPlay = DrvAudioHlpMsToFrames(&pHstStream->Cfg.Props, tsDeltaPlayedCapturedMs);
+
+            Log3Func(("[%s] Buffer: fJustStarted=%RTbool, cfLive=%RU32, cfToPlay=%RU32\n",
+                      pHstStream->szName, fJustStarted, cfLive, cfToPlay));
+
+            /* Did we reach a buffer underrun? Do pre-buffering again.
+             * If we're in pending disabled mode, try to play (drain) the remaining audio data. */
+            if (   !(pHstStream->fStatus & PDMAUDIOSTREAMSTS_FLAG_PENDING_DISABLE)
+                && !fJustStarted
+                && cfLive < cfToPlay)
+            {
+                pHstStream->fThresholdReached = false;
+                LogRel2(("Audio: Stream '%s' buffer underrun (total %RU8%%, which is %RU8%% of a period), buffering ...\n",
+                         pHstStream->szName, uLivePercent, (100 * cfLive) / pHstStream->Cfg.Backend.cfPeriod));
+                break;
+            }
+
+            if (cfToPlay > cfLive) /* Don't try to play more than available. */
+                cfToPlay = cfLive;
+
+            Log3Func(("[%s] Buffer: Playing %RU32 frames (%RU64ms since last playback)\n",
+                      pHstStream->szName, cfToPlay, tsDeltaPlayedCapturedMs));
+
+            if (pThis->pHostDrvAudio->pfnStreamPlayBegin)
+                pThis->pHostDrvAudio->pfnStreamPlayBegin(pThis->pHostDrvAudio, pHstStream->pvBackend);
+
+            if (RT_LIKELY(pHstStream->Cfg.enmLayout == PDMAUDIOSTREAMLAYOUT_NON_INTERLEAVED))
+            {
+                rc = drvAudioStreamPlayNonInterleaved(pThis, pHstStream, cfToPlay, &cfPlayedTotal);
+            }
+            else if (pHstStream->Cfg.enmLayout == PDMAUDIOSTREAMLAYOUT_RAW)
+            {
+                rc = drvAudioStreamPlayRaw(pThis, pHstStream, cfToPlay, &cfPlayedTotal);
+            }
+            else
+                AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
+
+            if (pThis->pHostDrvAudio->pfnStreamPlayEnd)
+                pThis->pHostDrvAudio->pfnStreamPlayEnd(pThis->pHostDrvAudio, pHstStream->pvBackend);
+        }
+
         if (RT_SUCCESS(rc))
         {
@@ -1541 +1695 @@
             STAM_COUNTER_ADD     (&pHstStream->Out.StatFramesPlayed, cfPlayedTotal);
 #endif
+        }
+
+    } while (0);
 
 #ifdef LOG_ENABLED
-            cfLive = AudioMixBufLive(&pHstStream->MixBuf);
-#endif
-        }
-
-#ifdef LOG_ENABLED
-        pszBackendSts = dbgAudioStreamStatusToStr(stsBackend);
-        Log3Func(("[%s] End: stsBackend=%s, cfLive=%RU32, cfPlayedTotal=%RU32, rc=%Rrc\n",
-                  pHstStream->szName, pszBackendSts, cfLive, cfPlayedTotal, rc));
-        RTStrFree(pszBackendSts);
+    uint32_t cfLive = AudioMixBufLive(&pHstStream->MixBuf);
+    pszStreamSts  = dbgAudioStreamStatusToStr(stsHstStream);
+    Log3Func(("[%s] End: stsHstStream=%s, cfLive=%RU32, cfPlayedTotal=%RU32, rc=%Rrc\n",
+              pHstStream->szName, pszStreamSts, cfLive, cfPlayedTotal, rc));
+    RTStrFree(pszStreamSts);
 #endif /* LOG_ENABLED */
-
-    } while (0);
 
     int rc2 = RTCritSectLeave(&pThis->CritSect);
@@ -1791 +1942 @@
          */
 
-        AssertPtr(pThis->pHostDrvAudio->pfnStreamGetStatus);
-        PDMAUDIOSTREAMSTS stsBackend = pThis->pHostDrvAudio->pfnStreamGetStatus(pThis->pHostDrvAudio, pHstStream->pvBackend);
+        PDMAUDIOSTREAMSTS stsHstStream = pHstStream->fStatus;
 #ifdef LOG_ENABLED
-        char *pszBackendSts = dbgAudioStreamStatusToStr(stsBackend);
-        Log3Func(("[%s] Start: stsBackend=%s\n", pHstStream->szName, pszBackendSts));
-        RTStrFree(pszBackendSts);
+        char *pszStreamSts = dbgAudioStreamStatusToStr(stsHstStream);
+        Log3Func(("[%s] Start: stsHstStream=%s\n", pHstStream->szName, pszStreamSts));
+        RTStrFree(pszStreamSts);
 #endif /* LOG_ENABLED */
-        if (!(stsBackend & PDMAUDIOSTREAMSTS_FLAG_ENABLED)) /* Backend disabled? Bail out. */
+        if (!(stsHstStream & PDMAUDIOSTREAMSTS_FLAG_ENABLED)) /* Stream disabled? Bail out. */
             break;
 
@@ -1823 +1973 @@
 
 #ifdef LOG_ENABLED
-        pszBackendSts = dbgAudioStreamStatusToStr(stsBackend);
-        Log3Func(("[%s] End: stsBackend=%s, cfCaptured=%RU32, rc=%Rrc\n",
-                  pHstStream->szName, pszBackendSts, cfCaptured, rc));
-        RTStrFree(pszBackendSts);
+        pszStreamSts = dbgAudioStreamStatusToStr(stsHstStream);
+        Log3Func(("[%s] End: stsHstStream=%s, cfCaptured=%RU32, rc=%Rrc\n",
+                  pHstStream->szName, pszStreamSts, cfCaptured, rc));
+        RTStrFree(pszStreamSts);
 #endif /* LOG_ENABLED */
 
@@ -2191 +2341 @@
 
 /**
+ * Retrieves an audio configuration from the specified CFGM node.
+ *
+ * @return VBox status code.
+ * @param  pThis                Driver instance to be called.
+ * @param  pCfg                 Where to store the retrieved audio configuration to.
+ * @param  pNode                Where to get the audio configuration from.
+ */
+static int drvAudioGetCfgFromCFGM(PDRVAUDIO pThis, PDRVAUDIOCFG pCfg, PCFGMNODE pNode)
+{
+    RT_NOREF(pThis);
+
+    /* Debug stuff. */
+    CFGMR3QueryBoolDef(pNode, "DebugEnabled",      &pCfg->Dbg.fEnabled,  false);
+    int rc2 = CFGMR3QueryString(pNode, "DebugPathOut", pCfg->Dbg.szPathOut, sizeof(pCfg->Dbg.szPathOut));
+    if (   RT_FAILURE(rc2)
+        || !strlen(pCfg->Dbg.szPathOut))
+    {
+        RTStrPrintf(pCfg->Dbg.szPathOut, sizeof(pCfg->Dbg.szPathOut), VBOX_AUDIO_DEBUG_DUMP_PCM_DATA_PATH);
+    }
+
+    if (pCfg->Dbg.fEnabled)
+        LogRel(("Audio: Debugging enabled (audio data written to '%s')\n", pCfg->Dbg.szPathOut));
+
+    /* Buffering stuff. */
+    CFGMR3QueryU32Def(pNode, "PeriodMs",     &pCfg->uPeriodMs, 0);
+    CFGMR3QueryU32Def(pNode, "BufferSizeMs", &pCfg->uBufferSizeMs, 0);
+    CFGMR3QueryU32Def(pNode, "PreBufferMs",  &pCfg->uPreBufMs, UINT32_MAX /* No custom value set */);
+
+    LogFunc(("pCfg=%p, uPeriodMs=%RU32, uBufferSizeMs=%RU32, uPreBufMs=%RU32\n",
+             pCfg, pCfg->uPeriodMs, pCfg->uBufferSizeMs, pCfg->uPreBufMs));
+
+    return VINF_SUCCESS;
+}
+
+/**
  * Intializes an audio driver instance.
  *
@@ -2227 +2412 @@
     CFGMR3QueryBoolDef(pThis->pCFGMNode, "OutputEnabled", &pThis->Out.fEnabled,  false);
 
-    /* Input configuration. */
-    /** @todo Separate debugging stuff if needed. Later. */
-    CFGMR3QueryBoolDef(pThis->pCFGMNode, "DebugEnabled",      &pThis->In.Cfg.Dbg.fEnabled,  false);
-    rc2 = CFGMR3QueryString(pThis->pCFGMNode, "DebugPathOut", pThis->In.Cfg.Dbg.szPathOut, sizeof(pThis->In.Cfg.Dbg.szPathOut));
-    if (   RT_FAILURE(rc2)
-        || !strlen(pThis->In.Cfg.Dbg.szPathOut))
-    {
-        RTStrPrintf(pThis->In.Cfg.Dbg.szPathOut, sizeof(pThis->In.Cfg.Dbg.szPathOut), VBOX_AUDIO_DEBUG_DUMP_PCM_DATA_PATH);
-    }
-
-    if (pThis->In.Cfg.Dbg.fEnabled)
-        LogRel(("Audio: Debugging input enabled (audio data written to '%s')\n", pThis->In.Cfg.Dbg.szPathOut));
-
-    /* Output configuration. */
-    CFGMR3QueryBoolDef(pThis->pCFGMNode, "DebugEnabled",      &pThis->Out.Cfg.Dbg.fEnabled, false);
-    rc2 = CFGMR3QueryString(pThis->pCFGMNode, "DebugPathOut", pThis->Out.Cfg.Dbg.szPathOut, sizeof(pThis->Out.Cfg.Dbg.szPathOut));
-    if (   RT_FAILURE(rc2)
-        || !strlen(pThis->Out.Cfg.Dbg.szPathOut))
-    {
-        RTStrPrintf(pThis->Out.Cfg.Dbg.szPathOut, sizeof(pThis->Out.Cfg.Dbg.szPathOut), VBOX_AUDIO_DEBUG_DUMP_PCM_DATA_PATH);
-    }
-
-    if (pThis->Out.Cfg.Dbg.fEnabled)
-        LogRel(("Audio: Debugging output enabled (audio data written to '%s')\n", pThis->Out.Cfg.Dbg.szPathOut));
-
     LogRel2(("Audio: Initial status for driver '%s': Input is %s, output is %s\n",
              pThis->szName, pThis->In.fEnabled ? "enabled" : "disabled", pThis->Out.fEnabled ? "enabled" : "disabled"));
+
+    /*
+     * Load configurations.
+     */
+    rc = drvAudioGetCfgFromCFGM(pThis, &pThis->In.Cfg, pThis->pCFGMNode);
+    if (RT_SUCCESS(rc))
+        rc = drvAudioGetCfgFromCFGM(pThis, &pThis->Out.Cfg, pThis->pCFGMNode);
 
     LogFunc(("[%s] rc=%Rrc\n", pThis->szName, rc));
@@ -3063 +3230 @@
  * @param   pHstStream          (Host) audio stream to use for creating the stream on the backend side.
  * @param   pCfgReq             Requested audio stream configuration to use for stream creation.
- * @param   pCfgAcq             Acquired audio stream configuration returned by the backend. Optional, can be NULL.
+ * @param   pCfgAcq             Acquired audio stream configuration returned by the backend.
  */
 static int drvAudioStreamCreateInternalBackend(PDRVAUDIO pThis,
@@ -3071 +3238 @@
     AssertPtrReturn(pHstStream, VERR_INVALID_POINTER);
     AssertPtrReturn(pCfgReq,    VERR_INVALID_POINTER);
-    /* pCfgAcq is optional. */
+    AssertPtrReturn(pCfgAcq,    VERR_INVALID_POINTER);
 
     AssertMsg(pHstStream->enmCtx == PDMAUDIOSTREAMCTX_HOST,
@@ -3079 +3246 @@
               ("Stream '%s' already initialized in backend\n", pHstStream->szName));
 
+    /* Get the right configuration for the stream to be created. */
+    PDRVAUDIOCFG pDrvCfg = pCfgReq->enmDir == PDMAUDIODIR_IN ? &pThis->In.Cfg : &pThis->Out.Cfg;
+
+    /* Fill in the tweakable parameters into the requested host configuration.
+     * All parameters in principle can be changed and returned by the backend via the acquired configuration. */
+
+    /*
+     * Period size
+     */
+    if (pDrvCfg->uPeriodMs)
+        pCfgReq->Backend.cfPeriod = DrvAudioHlpMsToFrames(&pCfgReq->Props, pDrvCfg->uPeriodMs);
+    else /* Set default period size. */
+        pCfgReq->Backend.cfPeriod = DrvAudioHlpMsToFrames(&pCfgReq->Props, 50 /* ms */);
+
+    LogRel2(("Audio: Using %s period size (%RU32ms, %RU32 frames) for stream '%s'\n",
+             pDrvCfg->uPeriodMs ? "custom" : "default", DrvAudioHlpFramesToMs(&pCfgReq->Props, pCfgReq->Backend.cfPeriod),
+             pCfgReq->Backend.cfPeriod, pHstStream->szName));
+
+    /*
+     * Buffer size
+     */
+    if (pDrvCfg->uBufferSizeMs)
+        pCfgReq->Backend.cfBufferSize = DrvAudioHlpMsToFrames(&pCfgReq->Props, pDrvCfg->uBufferSizeMs);
+    else /* Set default buffer size. */
+        pCfgReq->Backend.cfBufferSize = DrvAudioHlpMsToFrames(&pCfgReq->Props, 200 /* ms */);
+
+    LogRel2(("Audio: Using %s buffer size (%RU32ms, %RU32 frames) for stream '%s'\n",
+             pDrvCfg->uBufferSizeMs ? "custom" : "default", DrvAudioHlpFramesToMs(&pCfgReq->Props, pCfgReq->Backend.cfBufferSize),
+             pCfgReq->Backend.cfBufferSize, pHstStream->szName));
+
+    /*
+     * Pre-buffering size
+     */
+    if (pDrvCfg->uPreBufMs != UINT32_MAX)
+    {
+        if (!pDrvCfg->uPreBufMs) /* Pre-buffering is set to disabled. */
+            LogRel2(("Audio: Using custom pre-buffering (disabled) for stream '%s'\n", pHstStream->szName));
+        pCfgReq->Backend.cfPreBuf = DrvAudioHlpMsToFrames(&pCfgReq->Props, pDrvCfg->uPreBufMs);
+    }
+    else /* Set default pre-buffering size. */
+        pCfgReq->Backend.cfPreBuf = pCfgReq->Backend.cfBufferSize;
+
+    LogRel2(("Audio: Using %s pre-buffering size (%RU32ms, %RU32 frames) for stream '%s'\n",
+             pDrvCfg->uPreBufMs != UINT32_MAX ? "custom" : "default", DrvAudioHlpFramesToMs(&pCfgReq->Props, pCfgReq->Backend.cfPreBuf),
+             pCfgReq->Backend.cfPreBuf, pHstStream->szName));
+
+    /*
+     * Validate input.
+     */
+    if (pCfgReq->Backend.cfBufferSize < pCfgReq->Backend.cfPeriod)
+    {
+        LogRel(("Audio: Error for stream '%s': Buffer size (%RU32ms) must not be smaller than the period size (%RU32ms)\n",
+                pHstStream->szName, DrvAudioHlpFramesToMs(&pCfgReq->Props, pCfgReq->Backend.cfBufferSize),
+                DrvAudioHlpFramesToMs(&pCfgReq->Props, pCfgReq->Backend.cfPeriod)));
+        return VERR_INVALID_PARAMETER;
+    }
+
+    if (   pCfgReq->Backend.cfPreBuf != UINT32_MAX /* Custom pre-buffering set? */
+        && pCfgReq->Backend.cfPreBuf)
+    {
+        if (pCfgReq->Backend.cfBufferSize < pCfgReq->Backend.cfPreBuf)
+        {
+            LogRel(("Audio: Error for stream '%s': Pre-buffering size (%RU32ms) must not be bigger than the buffer size (%RU32ms)\n",
+                    pHstStream->szName, DrvAudioHlpFramesToMs(&pCfgReq->Props, pCfgReq->Backend.cfPreBuf),
+                    DrvAudioHlpFramesToMs(&pCfgReq->Props, pCfgReq->Backend.cfBufferSize)));
+            return VERR_INVALID_PARAMETER;
+        }
+    }
+
     /* Make the acquired host configuration the requested host configuration initially,
      * in case the backend does not report back an acquired configuration. */
-    PDMAUDIOSTREAMCFG CfgAcq;
-    int rc = DrvAudioHlpStreamCfgCopy(&CfgAcq, pCfgReq);
+    int rc = DrvAudioHlpStreamCfgCopy(pCfgAcq, pCfgReq);
     if (RT_FAILURE(rc))
     {
@@ -3090 +3325 @@
     }
 
-    rc = pThis->pHostDrvAudio->pfnStreamCreate(pThis->pHostDrvAudio, pHstStream->pvBackend, pCfgReq, &CfgAcq);
+    rc = pThis->pHostDrvAudio->pfnStreamCreate(pThis->pHostDrvAudio, pHstStream->pvBackend, pCfgReq, pCfgAcq);
     if (RT_FAILURE(rc))
     {
@@ -3102 +3337 @@
 
     /* Validate acquired configuration. */
-    if (!DrvAudioHlpStreamCfgIsValid(&CfgAcq))
+    if (!DrvAudioHlpStreamCfgIsValid(pCfgAcq))
     {
         LogRel(("Audio: Creating stream '%s' returned an invalid backend configuration, skipping\n", pHstStream->szName));
         return VERR_INVALID_PARAMETER;
+    }
+
+    /* Let the user know that the backend changed one of the user's custom values requested above. */
+    if (   pDrvCfg->uBufferSizeMs
+        && pCfgAcq->Backend.cfBufferSize != pCfgReq->Backend.cfBufferSize)
+    {
+        LogRel2(("Audio: Custom buffer size overwritten by backend for stream '%s' (now %RU64ms, %RU32 frames)\n",
+                 pHstStream->szName, DrvAudioHlpFramesToMs(&pCfgAcq->Props, pCfgAcq->Backend.cfBufferSize), pCfgAcq->Backend.cfBufferSize));
+    }
+
+    if (   pDrvCfg->uPeriodMs
+        && pCfgAcq->Backend.cfPeriod != pCfgReq->Backend.cfPeriod)
+    {
+        LogRel2(("Audio: Custom period size overwritten by backend for stream '%s' (now %RU64ms, %RU32 frames)\n",
+                 pHstStream->szName, DrvAudioHlpFramesToMs(&pCfgAcq->Props, pCfgAcq->Backend.cfPeriod), pCfgAcq->Backend.cfPeriod));
+    }
+
+    if (   pDrvCfg->uPreBufMs != UINT32_MAX
+        && pCfgAcq->Backend.cfPreBuf != pCfgReq->Backend.cfPreBuf)
+    {
+        LogRel2(("Audio: Custom pre-buffering size overwritten by backend for stream '%s' (now %RU64ms, %RU32 frames)\n",
+                 pHstStream->szName, DrvAudioHlpFramesToMs(&pCfgAcq->Props, pCfgAcq->Backend.cfPreBuf), pCfgAcq->Backend.cfPreBuf));
     }
 
@@ -3112 +3369 @@
      * at some later point in time. */
     pHstStream->fStatus |= PDMAUDIOSTREAMSTS_FLAG_INITIALIZED;
-
-    if (pCfgAcq)
-    {
-        int rc2 = DrvAudioHlpStreamCfgCopy(pCfgAcq, &CfgAcq);
-        AssertRC(rc2);
-    }
 
     return VINF_SUCCESS;

trunk/src/VBox/Devices/Audio/DrvAudio.h

@@ -79 +79 @@
 typedef struct DRVAUDIOCFG
 {
-    /** Configures the period size (in audio frames).
-     *  This value reflects the number of audio frames in between each hardware interrupt on the
+    /** Configures the period size (in ms).
+     *  This value reflects the time in between each hardware interrupt on the
      *  backend (host) side. */
-    uint32_t             cfPeriod;
-    /** Configures the (ring) buffer size (in audio frames). Often is a multiple of cfPeriod. */
-    uint32_t             cfBufferSize;
-    /** Configures the pre-buffering size (in audio frames).
-     *  Frames needed in buffer before the stream becomes active (pre buffering).
-     *  The bigger this value is, the more latency for the stream will occur. */
-    uint32_t             cfPreBuf;
+    uint32_t             uPeriodMs;
+    /** Configures the (ring) buffer size (in ms). Often is a multiple of uPeriodMs. */
+    uint32_t             uBufferSizeMs;
+    /** Configures the pre-buffering size (in ms).
+     *  Time needed in buffer before the stream becomes active (pre buffering).
+     *  The bigger this value is, the more latency for the stream will occur.
+     *  Set to 0 to disable pre-buffering completely.
+     *  By default set to UINT32_MAX if not set to a custom value. */
+    uint32_t             uPreBufMs;
     /** The driver's debugging configuration. */
     struct

trunk/src/VBox/Devices/Audio/DrvHostALSAAudio.cpp

@@ -123 +123 @@
 static ALSAAUDIOCFG s_ALSAConf =
 {
-#ifdef HIGH_LATENCY
-    1,
-    1,
-#else
     0,
     0,
-#endif
     "default",
     "default",
-#ifdef HIGH_LATENCY
-    400000,
-    400000 / 4,
-    400000,
-    400000 / 4,
-#else
-# define DEFAULT_BUFFER_SIZE 1024
-# define DEFAULT_PERIOD_SIZE 256
-    DEFAULT_BUFFER_SIZE * 4,
-    DEFAULT_PERIOD_SIZE * 4,
-    DEFAULT_BUFFER_SIZE,
-    DEFAULT_PERIOD_SIZE,
-#endif
-    0,
+# define DEFAULT_PERIOD_FRAMES 4410                      /* 100ms for 44,1 kHz. */
+# define DEFAULT_BUFFER_FRAMES DEFAULT_PERIOD_FRAMES * 2 /* Double (buffering) the period size. */
+    DEFAULT_BUFFER_FRAMES,
+    DEFAULT_PERIOD_FRAMES,
+    DEFAULT_BUFFER_FRAMES,
+    DEFAULT_PERIOD_FRAMES,
+    DEFAULT_PERIOD_FRAMES * 2,                           /* Threshold, using double the period size to avoid stutters. */
     0,
     0,
@@ -180 +168 @@
     int                 resample;
     int                 nchannels;
+    /** Buffer size (in audio frames). */
     unsigned long       buffer_size;
+    /** Periods (in audio frames). */
     unsigned long       period_size;
-    snd_pcm_uframes_t   samples;
+    /** For playback: Starting to play threshold (in audio frames).
+     *  For Capturing: Starting to capture threshold (in audio frames). */
+    unsigned long       threshold;
 } ALSAAUDIOSTREAMCFG, *PALSAAUDIOSTREAMCFG;
 
@@ -288 +280 @@
 
 
-static int alsaGetSampleShift(snd_pcm_format_t fmt, unsigned *puShift)
-{
-    AssertPtrReturn(puShift, VERR_INVALID_POINTER);
-
-    switch (fmt)
-    {
-        case SND_PCM_FORMAT_S8:
-        case SND_PCM_FORMAT_U8:
-            *puShift = 0;
-            break;
-
-        case SND_PCM_FORMAT_S16_LE:
-        case SND_PCM_FORMAT_U16_LE:
-        case SND_PCM_FORMAT_S16_BE:
-        case SND_PCM_FORMAT_U16_BE:
-            *puShift = 1;
-            break;
-
-        case SND_PCM_FORMAT_S32_LE:
-        case SND_PCM_FORMAT_U32_LE:
-        case SND_PCM_FORMAT_S32_BE:
-        case SND_PCM_FORMAT_U32_BE:
-            *puShift = 2;
-            break;
-
-        default:
-            AssertMsgFailed(("Format %ld not supported\n", fmt));
-            return VERR_NOT_SUPPORTED;
-    }
-
-    return VINF_SUCCESS;
-}
-
-
 static int alsaStreamSetThreshold(snd_pcm_t *phPCM, snd_pcm_uframes_t threshold)
 {
@@ -395 +353 @@
     }
 
+    LogFlowFuncLeaveRC(rc);
     return rc;
 }
@@ -612 +571 @@
         }
 
+        LogRel(("ALSA: Using %s device \"%s\"\n", fIn ? "input" : "output", pszDev));
+
         int err = snd_pcm_open(&phPCM, pszDev,
                                fIn ? SND_PCM_STREAM_CAPTURE : SND_PCM_STREAM_PLAYBACK,
@@ -622 +583 @@
         }
 
-        LogRel(("ALSA: Using %s device \"%s\"\n", fIn ? "input" : "output", pszDev));
+        err = snd_pcm_nonblock(phPCM, 1);
+        if (err < 0)
+        {
+            LogRel(("ALSA: Error setting output non-blocking mode: %s\n", snd_strerror(err)));
+            rc = VERR_ACCESS_DENIED; /** @todo Find a better rc. */
+            break;
+        }
 
         snd_pcm_hw_params_t *pHWParms;
@@ -683 +650 @@
             if (!buffer_size)
             {
-                buffer_size = DEFAULT_BUFFER_SIZE;
-                period_size = DEFAULT_PERIOD_SIZE;
+                buffer_size = DEFAULT_BUFFER_FRAMES;
+                period_size = DEFAULT_PERIOD_FRAMES;
             }
         }
@@ -792 +759 @@
                 err = snd_pcm_hw_params_set_buffer_size_near(phPCM,
                                                              pHWParms, &buffer_size_f);
-                LogFunc(("Buffer size is: %RU32\n", buffer_size_f));
                 if (err < 0)
                 {
-                    LogRel(("ALSA: Failed to set buffer size %d: %s\n",
-                            buffer_size_f, snd_strerror(err)));
+                    LogRel(("ALSA: Failed to set near buffer size %RU32: %s\n", buffer_size_f, snd_strerror(err)));
                     rc = VERR_AUDIO_BACKEND_INIT_FAILED;
                     break;
@@ -821 +786 @@
         }
 
-        LogFunc(("Buffer sample size is: %RU32\n", obt_buffer_size));
-
         snd_pcm_uframes_t obt_period_size;
         int dir = 0;
@@ -833 +796 @@
         }
 
-        LogFunc(("Freq=%dHz, period size=%RU32, buffer size=%RU32\n",
+        LogRel2(("ALSA: Frequency is %dHz, period size is %RU32 frames, buffer size is %RU32 fames\n",
                  pCfgReq->freq, obt_period_size, obt_buffer_size));
 
@@ -845 +808 @@
 
         if (   !fIn
-            && s_ALSAConf.threshold)
-        {
-            unsigned uShift;
-            rc = alsaGetSampleShift(pCfgReq->fmt, &uShift);
-            if (RT_SUCCESS(rc))
-            {
-                int bytes_per_sec = uFreq
-                    << (cChannels == 2)
-                    << uShift;
-
-                snd_pcm_uframes_t threshold
-                    = (s_ALSAConf.threshold * bytes_per_sec) / 1000;
-
-                rc = alsaStreamSetThreshold(phPCM, threshold);
-            }
-        }
-        else
-            rc = VINF_SUCCESS;
+            && pCfgReq->threshold)
+        {
+            rc = alsaStreamSetThreshold(phPCM, pCfgReq->threshold);
+            if (RT_FAILURE(rc))
+                break;
+
+            LogRel2(("ALSA: Threshold for playback set to %RU32 frames\n", pCfgReq->threshold));
+        }
+
+        pCfgObt->fmt         = pCfgReq->fmt;
+        pCfgObt->nchannels   = cChannels;
+        pCfgObt->freq        = uFreq;
+        pCfgObt->period_size = obt_period_size;
+        pCfgObt->buffer_size = obt_buffer_size;
+        pCfgObt->threshold   = pCfgReq->threshold;
+
+        rc = VINF_SUCCESS;
     }
     while (0);
@@ -868 +830 @@
     if (RT_SUCCESS(rc))
     {
-        pCfgObt->fmt       = pCfgReq->fmt;
-        pCfgObt->nchannels = cChannels;
-        pCfgObt->freq      = uFreq;
-        pCfgObt->samples   = obt_buffer_size;
-
         *pphPCM = phPCM;
     }
@@ -953 +910 @@
 
     return VINF_SUCCESS;
-}
-
-
-static int drvHostALSAAudioStreamCtl(PALSAAUDIOSTREAM pStreamALSA, bool fPause)
-{
-    int rc = VINF_SUCCESS;
-
-    const bool fInput = pStreamALSA->pCfg->enmDir == PDMAUDIODIR_IN;
-
-    int err;
-    if (fPause)
-    {
-        err = snd_pcm_drop(pStreamALSA->phPCM);
-        if (err < 0)
-        {
-            LogRel(("ALSA: Error stopping %s stream: %s\n", fInput ? "input" : "output", snd_strerror(err)));
-            rc = VERR_ACCESS_DENIED; /** @todo Find a better rc. */
-        }
-    }
-    else
-    {
-        err = snd_pcm_prepare(pStreamALSA->phPCM);
-        if (err < 0)
-        {
-            LogRel(("ALSA: Error preparing %s stream: %s\n", fInput ? "input" : "output", snd_strerror(err)));
-            rc = VERR_ACCESS_DENIED; /** @todo Find a better rc. */
-        }
-        else
-        {
-            Assert(snd_pcm_state(pStreamALSA->phPCM) == SND_PCM_STATE_PREPARED);
-
-            if (fInput) /* Only start the PCM stream for input streams. */
-            {
-                err = snd_pcm_start(pStreamALSA->phPCM);
-                if (err < 0)
-                {
-                    LogRel(("ALSA: Error starting input stream: %s\n", snd_strerror(err)));
-                    rc = VERR_ACCESS_DENIED; /** @todo Find a better rc. */
-                }
-            }
-        }
-    }
-
-    return rc;
 }
 
@@ -1324 +1237 @@
         req.freq        = pCfgReq->Props.uHz;
         req.nchannels   = pCfgReq->Props.cChannels;
-        req.period_size = s_ALSAConf.period_size_out; /** @todo Make this configurable. */
-        req.buffer_size = s_ALSAConf.buffer_size_out; /** @todo Make this configurable. */
+        req.period_size = pCfgReq->Backend.cfPeriod;
+        req.buffer_size = pCfgReq->Backend.cfBufferSize;
+        req.threshold   = pCfgReq->Backend.cfPreBuf;
 
         ALSAAUDIOSTREAMCFG obt;
@@ -1339 +1253 @@
             break;
 
-        pCfgAcq->cFrameBufferHint = obt.samples * 4;
-
-        AssertBreakStmt(obt.samples, rc = VERR_INVALID_PARAMETER);
-
-        size_t cbBuf = obt.samples * PDMAUDIOSTREAMCFG_F2B(pCfgAcq, 1);
-        AssertBreakStmt(cbBuf, rc = VERR_INVALID_PARAMETER);
-
-        pStreamALSA->pvBuf = RTMemAllocZ(cbBuf);
+        pCfgAcq->Backend.cfPeriod     = obt.period_size;
+        pCfgAcq->Backend.cfBufferSize = obt.buffer_size;
+        pCfgAcq->Backend.cfPreBuf     = obt.threshold;
+
+        pStreamALSA->cbBuf = pCfgAcq->Backend.cfBufferSize * DrvAudioHlpPCMPropsBytesPerFrame(&pCfgAcq->Props);
+        pStreamALSA->pvBuf = RTMemAllocZ(pStreamALSA->cbBuf);
         if (!pStreamALSA->pvBuf)
         {
-            LogRel(("ALSA: Not enough memory for output DAC buffer (%RU32 samples, %zu bytes)\n", obt.samples, cbBuf));
+            LogRel(("ALSA: Not enough memory for output DAC buffer (%zu frames)\n", pCfgAcq->Backend.cfBufferSize));
             rc = VERR_NO_MEMORY;
             break;
         }
 
-        pStreamALSA->cbBuf = cbBuf;
         pStreamALSA->phPCM = phPCM;
     }
@@ -1379 +1290 @@
         req.freq        = pCfgReq->Props.uHz;
         req.nchannels   = pCfgReq->Props.cChannels;
-        req.period_size = s_ALSAConf.period_size_in; /** @todo Make this configurable. */
-        req.buffer_size = s_ALSAConf.buffer_size_in; /** @todo Make this configurable. */
+        req.period_size = DrvAudioHlpMsToFrames(&pCfgReq->Props, 50 /* ms */); /** @todo Make this configurable. */
+        req.buffer_size = req.period_size * 2; /** @todo Make this configurable. */
+        req.threshold   = req.period_size;
 
         ALSAAUDIOSTREAMCFG obt;
@@ -1394 +1306 @@
             break;
 
-        pCfgAcq->cFrameBufferHint = obt.samples;
-
-        AssertBreakStmt(obt.samples, rc = VERR_INVALID_PARAMETER);
-
-        size_t cbBuf = obt.samples * PDMAUDIOSTREAMCFG_F2B(pCfgAcq, 1);
-        AssertBreakStmt(cbBuf, rc = VERR_INVALID_PARAMETER);
-
-        pStreamALSA->pvBuf = RTMemAlloc(cbBuf);
+        pCfgAcq->Backend.cfPeriod     = obt.period_size;
+        pCfgAcq->Backend.cfBufferSize = obt.buffer_size;
+        /* No pre-buffering. */
+
+        pStreamALSA->cbBuf = pCfgAcq->Backend.cfBufferSize * DrvAudioHlpPCMPropsBytesPerFrame(&pCfgAcq->Props);
+        pStreamALSA->pvBuf = RTMemAlloc(pStreamALSA->cbBuf);
         if (!pStreamALSA->pvBuf)
         {
-            LogRel(("ALSA: Not enough memory for input ADC buffer (%RU32 samples, %zu bytes)\n", obt.samples, cbBuf));
+            LogRel(("ALSA: Not enough memory for input ADC buffer (%zu frames)\n", pCfgAcq->Backend.cfBufferSize));
             rc = VERR_NO_MEMORY;
             break;
         }
 
-        pStreamALSA->cbBuf = cbBuf;
         pStreamALSA->phPCM = phPCM;
     }
@@ -1424 +1333 @@
 static int alsaControlStreamIn(PALSAAUDIOSTREAM pStreamALSA, PDMAUDIOSTREAMCMD enmStreamCmd)
 {
-    int rc;
+    int rc = VINF_SUCCESS;
+
+    int err;
+
     switch (enmStreamCmd)
     {
         case PDMAUDIOSTREAMCMD_ENABLE:
         case PDMAUDIOSTREAMCMD_RESUME:
-            rc = drvHostALSAAudioStreamCtl(pStreamALSA, false /* fStop */);
-            break;
+        {
+            err = snd_pcm_prepare(pStreamALSA->phPCM);
+            if (err < 0)
+            {
+                LogRel(("ALSA: Error preparing input stream: %s\n", snd_strerror(err)));
+                rc = VERR_ACCESS_DENIED; /** @todo Find a better rc. */
+            }
+            else
+            {
+                Assert(snd_pcm_state(pStreamALSA->phPCM) == SND_PCM_STATE_PREPARED);
+
+                /* Only start the PCM stream for input streams. */
+                err = snd_pcm_start(pStreamALSA->phPCM);
+                if (err < 0)
+                {
+                    LogRel(("ALSA: Error starting input stream: %s\n", snd_strerror(err)));
+                    rc = VERR_ACCESS_DENIED; /** @todo Find a better rc. */
+                }
+            }
+
+            break;
+        }
 
         case PDMAUDIOSTREAMCMD_DISABLE:
+        {
+            err = snd_pcm_drop(pStreamALSA->phPCM);
+            if (err < 0)
+            {
+                LogRel(("ALSA: Error disabling input %s stream: %s\n", snd_strerror(err)));
+                rc = VERR_ACCESS_DENIED; /** @todo Find a better rc. */
+            }
+            break;
+        }
+
         case PDMAUDIOSTREAMCMD_PAUSE:
-            rc = drvHostALSAAudioStreamCtl(pStreamALSA, true /* fStop */);
-            break;
+        {
+            err = snd_pcm_drop(pStreamALSA->phPCM);
+            if (err < 0)
+            {
+                LogRel(("ALSA: Error pausing input stream: %s\n", snd_strerror(err)));
+                rc = VERR_ACCESS_DENIED; /** @todo Find a better rc. */
+            }
+            break;
+        }
 
         default:
-            AssertMsgFailed(("Invalid command %ld\n", enmStreamCmd));
-            rc = VERR_INVALID_PARAMETER;
-            break;
-    }
-
+            rc = VERR_NOT_SUPPORTED;
+            break;
+    }
+
+    LogFlowFuncLeaveRC(rc);
     return rc;
 }
@@ -1449 +1398 @@
 static int alsaControlStreamOut(PALSAAUDIOSTREAM pStreamALSA, PDMAUDIOSTREAMCMD enmStreamCmd)
 {
-    int rc;
+    int rc = VINF_SUCCESS;
+
+    int err;
+
     switch (enmStreamCmd)
     {
         case PDMAUDIOSTREAMCMD_ENABLE:
         case PDMAUDIOSTREAMCMD_RESUME:
-            rc = drvHostALSAAudioStreamCtl(pStreamALSA, false /* fStop */);
-            break;
+        {
+            err = snd_pcm_prepare(pStreamALSA->phPCM);
+            if (err < 0)
+            {
+                LogRel(("ALSA: Error preparing output stream: %s\n", snd_strerror(err)));
+                rc = VERR_ACCESS_DENIED; /** @todo Find a better rc. */
+            }
+            else
+            {
+                Assert(snd_pcm_state(pStreamALSA->phPCM) == SND_PCM_STATE_PREPARED);
+            }
+
+            break;
+        }
 
         case PDMAUDIOSTREAMCMD_DISABLE:
+        {
+            err = snd_pcm_drop(pStreamALSA->phPCM);
+            if (err < 0)
+            {
+                LogRel(("ALSA: Error disabling output stream: %s\n", snd_strerror(err)));
+                rc = VERR_ACCESS_DENIED; /** @todo Find a better rc. */
+            }
+            break;
+        }
+
         case PDMAUDIOSTREAMCMD_PAUSE:
-            rc = drvHostALSAAudioStreamCtl(pStreamALSA, true /* fStop */);
-            break;
+        {
+            err = snd_pcm_drop(pStreamALSA->phPCM);
+            if (err < 0)
+            {
+                LogRel(("ALSA: Error pausing output stream: %s\n", snd_strerror(err)));
+                rc = VERR_ACCESS_DENIED; /** @todo Find a better rc. */
+            }
+            break;
+        }
+
+        case PDMAUDIOSTREAMCMD_DRAIN:
+        {
+            snd_pcm_state_t streamState = snd_pcm_state(pStreamALSA->phPCM);
+            Log2Func(("Stream state is: %d\n", streamState));
+
+            if (   streamState == SND_PCM_STATE_PREPARED
+                || streamState == SND_PCM_STATE_RUNNING)
+            {
+                err = snd_pcm_nonblock(pStreamALSA->phPCM, 0);
+                if (err < 0)
+                {
+                    LogRel(("ALSA: Error disabling output non-blocking mode: %s\n", snd_strerror(err)));
+                    rc = VERR_ACCESS_DENIED; /** @todo Find a better rc. */
+                    break;
+                }
+
+                err = snd_pcm_drain(pStreamALSA->phPCM);
+                if (err < 0)
+                {
+                    LogRel(("ALSA: Error draining output: %s\n", snd_strerror(err)));
+                    rc = VERR_ACCESS_DENIED; /** @todo Find a better rc. */
+                    break;
+                }
+
+                err = snd_pcm_nonblock(pStreamALSA->phPCM, 1);
+                if (err < 0)
+                {
+                    LogRel(("ALSA: Error re-enabling output non-blocking mode: %s\n", snd_strerror(err)));
+                    rc = VERR_ACCESS_DENIED; /** @todo Find a better rc. */
+                }
+            }
+            break;
+        }
 
         default:
-            AssertMsgFailed(("Invalid command %ld\n", enmStreamCmd));
-            rc = VERR_INVALID_PARAMETER;
-            break;
-    }
-
+            rc = VERR_NOT_SUPPORTED;
+            break;
+    }
+
+    LogFlowFuncLeaveRC(rc);
     return rc;
 }
@@ -1693 +1708 @@
 
 /**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamGetPending}
+ */
+static DECLCALLBACK(uint32_t) drvHostALSAStreamGetPending(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
+{
+    RT_NOREF(pInterface);
+    AssertPtrReturn(pStream, 0);
+
+    PALSAAUDIOSTREAM pStreamALSA = (PALSAAUDIOSTREAM)pStream;
+
+    snd_pcm_sframes_t cfDelay  = 0;
+    snd_pcm_state_t   enmState = snd_pcm_state(pStreamALSA->phPCM);
+
+    int rc = VINF_SUCCESS;
+
+    AssertPtr(pStreamALSA->pCfg);
+    if (pStreamALSA->pCfg->enmDir == PDMAUDIODIR_OUT)
+    {
+        int rc2 = snd_pcm_delay(pStreamALSA->phPCM, &cfDelay);
+        if (RT_SUCCESS(rc))
+            rc = rc2;
+
+        /* Make sure to check the stream's status.
+         * If it's anything but SND_PCM_STATE_RUNNING, the delay is meaningless and therefore 0. */
+        if (enmState != SND_PCM_STATE_RUNNING)
+            cfDelay = 0;
+    }
+
+    /* Note: For input streams we never have pending data left. */
+
+    Log2Func(("cfDelay=%RI32, enmState=%d, rc=%d\n", cfDelay, enmState, rc));
+
+    return DrvAudioHlpFramesToBytes(&pStreamALSA->pCfg->Props, cfDelay);
+}
+
+
+/**
  * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamGetStatus}
  */
@@ -1752 +1803 @@
     /* IHostAudio */
     PDMAUDIO_IHOSTAUDIO_CALLBACKS(drvHostALSAAudio);
+    pThis->IHostAudio.pfnStreamGetPending = drvHostALSAStreamGetPending;
 
     return VINF_SUCCESS;

trunk/src/VBox/Devices/Audio/DrvHostCoreAudio.cpp

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2010-2017 Oracle Corporation
+ * Copyright (C) 2010-2018 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -40 +40 @@
 
 
-/* Audio Queue buffer configuration. */
-#define AQ_BUF_COUNT    32      /* Number of buffers. */
-#define AQ_BUF_SIZE     512     /* Size of each buffer in bytes. */
-#define AQ_BUF_TOTAL    (AQ_BUF_COUNT * AQ_BUF_SIZE)
-#define AQ_BUF_SAMPLES  (AQ_BUF_TOTAL / 4)  /* Hardcoded 4 bytes per sample! */
 
 /* Enables utilizing the Core Audio converter unit for converting
@@ -379 +374 @@
     AudioQueueRef               audioQueue;
     /** The audio buffers which are used with the above audio queue. */
-    AudioQueueBufferRef         audioBuffer[AQ_BUF_COUNT];
+    AudioQueueBufferRef         audioBuffer[2];
     /** The acquired (final) audio format for this stream. */
     AudioStreamBasicDescription asbdStream;
@@ -1303 +1298 @@
         return VERR_GENERAL_FAILURE; /** @todo Fudge! */
 
-    const size_t cbBufSize = AQ_BUF_SIZE; /** @todo Make this configurable! */
+    const size_t cbBufSize = DrvAudioHlpFramesToBytes(&pCAStream->pCfg->Props, pCAStream->pCfg->Backend.cfPeriod);
 
     /*
@@ -2326 +2321 @@
 
             rc = coreAudioStreamInitQueue(pCAStream, pCfgReq, pCfgAcq);
-            if (RT_SUCCESS(rc))
-            {
-                pCfgAcq->cFrameBufferHint = AQ_BUF_SAMPLES; /** @todo Make this configurable. */
-            }
             if (RT_SUCCESS(rc))
             {

trunk/src/VBox/Devices/Audio/DrvHostDSound.cpp

@@ -104 +104 @@
 typedef struct DSOUNDHOSTCFG
 {
-    unsigned int    msLatencyIn;
-    unsigned int    msLatencyOut;
     RTUUID          uuidPlay;
     LPCGUID         pGuidPlay;
@@ -115 +113 @@
 {
     /** The stream's acquired configuration. */
-    PPDMAUDIOSTREAMCFG pCfg;
+    PDMAUDIOSTREAMCFG  Cfg;
     /** Buffer alignment. */
     uint8_t            uAlign;
@@ -150 +148 @@
             /** Offset of last play cursor within the DSB when last played. */
             DWORD                       offPlayCursorLastPlayed;
-            /** Total amount (in bytes) written. */
+            /** Total amount (in bytes) written to our internal ring buffer. */
             uint64_t                    cbWritten;
             /** Total amount (in bytes) played (to the DirectSound buffer). */
-            uint64_t                    cbPlayed;
-            /** Flag indicating whether playback was (re)started. */
-            bool                        fFirstPlayback;
-            /** Timestamp (in ms) of When the last playback has happened. */
-            uint64_t                    tsLastPlayMs;
+            uint64_t                    cbTransferred;
+            /** Flag indicating whether playback was just (re)started. */
+            bool                        fFirstTransfer;
+            /** How much (in bytes) the last transfer from the internal buffer
+             *  to the DirectSound buffer was. */
+            uint32_t                    cbLastTransferred;
+            /** Timestamp (in ms) of the last transfer from the internal buffer
+             *  to the DirectSound buffer. */
+            uint64_t                    tsLastTransferred;
             /** Number of buffer underruns happened. Used for logging. */
             uint8_t                     cUnderruns;
         } Out;
     };
+    struct
+    {
+        uint64_t tsLastTransferredMs;
+    } Dbg;
 } DSOUNDSTREAM, *PDSOUNDSTREAM;
 
@@ -194 +200 @@
     PFNPDMHOSTAUDIOCALLBACK     pfnCallback;
 #endif
-    /** Stopped indicator. */
-    bool                        fStopped;
-    /** Shutdown indicator. */
-    bool                        fShutdown;
-    /** Notification thread. */
-    RTTHREAD                    Thread;
-    /** Array of events to wait for in notification thread. */
-    HANDLE                      aEvents[VBOX_DSOUND_MAX_EVENTS];
     /** Pointer to the input stream. */
     PDSOUNDSTREAM               pDSStrmIn;
@@ -240 +238 @@
 *********************************************************************************************************************************/
 static HRESULT  directSoundPlayRestore(PDRVHOSTDSOUND pThis, LPDIRECTSOUNDBUFFER8 pDSB);
+static HRESULT  directSoundPlayStart(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS);
 static HRESULT  directSoundPlayStop(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS, bool fFlush);
 static HRESULT  directSoundCaptureStop(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS, bool fFlush);
@@ -245 +244 @@
 static void     dsoundDeviceRemove(PDSOUNDDEV pDev);
 static int      dsoundDevicesEnumerate(PDRVHOSTDSOUND pThis, PPDMAUDIOBACKENDCFG pCfg);
-
-static int      dsoundNotifyThread(PDRVHOSTDSOUND pThis, bool fShutdown);
 
 static void     dsoundUpdateStatusInternal(PDRVHOSTDSOUND pThis);
@@ -292 +289 @@
     AssertPtrReturn(pdwFree,   VERR_INVALID_POINTER);
 
-    Assert(pStreamDS->pCfg->enmDir == PDMAUDIODIR_OUT); /* Paranoia. */
+    Assert(pStreamDS->Cfg.enmDir == PDMAUDIODIR_OUT); /* Paranoia. */
 
     LPDIRECTSOUNDBUFFER8 pDSB = pStreamDS->Out.pDSB;
@@ -601 +598 @@
 
         RTCritSectLeave(&pThis->CritSect);
-
-        int rc2 = dsoundNotifyThread(pThis, false /* fShutdown */);
-        AssertRC(rc2);
     }
 
@@ -679 +673 @@
          * of copying own buffer data to our secondary's Direct Sound buffer.
          */
-        bd.dwFlags     = DSBCAPS_GLOBALFOCUS | DSBCAPS_GETCURRENTPOSITION2 | DSBCAPS_LOCSOFTWARE;
-        bd.dwFlags    |= DSBCAPS_CTRLPOSITIONNOTIFY;
-
-        bd.dwBufferBytes = DrvAudioHlpMsToBytes(&pCfgReq->Props, pThis->Cfg.msLatencyOut);
-
-        DSLOG(("DSound: Playback buffer is %ld bytes\n", bd.dwBufferBytes));
+        bd.dwFlags       = DSBCAPS_GLOBALFOCUS | DSBCAPS_GETCURRENTPOSITION2 | DSBCAPS_LOCSOFTWARE;
+        bd.dwBufferBytes = DrvAudioHlpFramesToBytes(&pCfgReq->Props, pCfgReq->Backend.cfBufferSize);
+
+        DSLOG(("DSound: Requested playback buffer is %RU64ms (%ld bytes)\n",
+               pCfgReq->Backend.cfBufferSize, DrvAudioHlpBytesToMs(&pCfgReq->Props, bd.dwBufferBytes), bd.dwBufferBytes));
 
         hr = IDirectSound8_CreateSoundBuffer(pThis->pDS, &bd, &pDSB, NULL);
@@ -724 +717 @@
             break;
         }
+
+        DSLOG(("DSound: Acquired playback buffer is %RU64ms (%ld bytes)\n",
+               DrvAudioHlpBytesToMs(&pCfgReq->Props, bc.dwBufferBytes), bc.dwBufferBytes));
 
         DSLOG(("DSound: Acquired playback format:\n"
@@ -756 +752 @@
         pStreamDS->cbBufSize = bc.dwBufferBytes;
 
-        RTCritSectEnter(&pThis->CritSect);
-
-        rc = RTCircBufCreate(&pStreamDS->pCircBuf, pStreamDS->cbBufSize * 2 /* Double buffering */);
+        rc = RTCircBufCreate(&pStreamDS->pCircBuf, pStreamDS->cbBufSize) * 2; /* Use "double buffering" */
         AssertRC(rc);
 
-        /*
-         * Install notification.
-         */
-        LPDIRECTSOUNDNOTIFY8 pNotify;
-        hr = IDirectSoundNotify_QueryInterface(pStreamDS->Out.pDSB, IID_IDirectSoundNotify8, (PVOID *)&pNotify);
-        if (SUCCEEDED(hr))
-        {
-            DSBPOSITIONNOTIFY dsPosNotify[3];
-            RT_ZERO(dsPosNotify);
-
-            dsPosNotify[0].dwOffset     = 0;
-            dsPosNotify[0].hEventNotify = pThis->aEvents[DSOUNDEVENT_OUTPUT];
-
-            dsPosNotify[1].dwOffset     = float(pStreamDS->cbBufSize * 0.3);
-            dsPosNotify[1].hEventNotify = pThis->aEvents[DSOUNDEVENT_OUTPUT];
-
-            dsPosNotify[2].dwOffset     = float(pStreamDS->cbBufSize * 0.6);
-            dsPosNotify[2].hEventNotify = pThis->aEvents[DSOUNDEVENT_OUTPUT];
-
-            hr = IDirectSoundNotify_SetNotificationPositions(pNotify, RT_ELEMENTS(dsPosNotify), dsPosNotify);
-            if (FAILED(hr))
-                DSLOGREL(("DSound: Setting playback position notification failed with %Rhrc\n", hr));
-
-            IDirectSoundNotify_Release(pNotify);
-
-            pThis->pDSStrmOut = pStreamDS;
-        }
-        else
-            DSLOGREL(("DSound: Querying interface for position notification failed with %Rhrc\n", hr));
-
-        RTCritSectLeave(&pThis->CritSect);
-
-        pCfgAcq->cFrameBufferHint = PDMAUDIOSTREAMCFG_B2F(pCfgAcq, pStreamDS->cbBufSize);
+        pThis->pDSStrmOut = pStreamDS;
+
+        pCfgAcq->Backend.cfBufferSize = PDMAUDIOSTREAMCFG_B2F(pCfgAcq, pStreamDS->cbBufSize);
+        pCfgAcq->Backend.cfPeriod     = pCfgAcq->Backend.cfBufferSize / 2;
+        pCfgAcq->Backend.cfPreBuf     = pCfgAcq->Backend.cfBufferSize;
 
     } while (0);
@@ -807 +773 @@
     AssertPtrReturnVoid(pStreamDS);
 
-    AssertPtr(pStreamDS->pCfg);
-    PPDMAUDIOPCMPROPS pProps = &pStreamDS->pCfg->Props;
+    PPDMAUDIOPCMPROPS pProps = &pStreamDS->Cfg.Props;
 
     HRESULT hr = IDirectSoundBuffer_SetCurrentPosition(pStreamDS->Out.pDSB, 0 /* Position */);
@@ -831 +796 @@
             DSLOGREL(("DSound: Re-fetching current position when clearing buffer failed with %Rhrc\n", hr));
     }
+}
+
+/**
+ * Transfers audio data from the internal buffer to the DirectSound playback instance.
+ * Due to internal accounting and querying DirectSound, this function knows how much it can transfer at once.
+ *
+ * @return  IPRT status code.
+ * @param   pThis               Host audio driver instance.
+ */
+static int dsoundPlayTransfer(PDRVHOSTDSOUND pThis)
+{
+    PDSOUNDSTREAM pStreamDS = pThis->pDSStrmOut;
+
+    if (   !pStreamDS
+        || !pStreamDS->fEnabled)
+    {
+        return VINF_SUCCESS;
+    }
+
+    uint32_t cbTransferred = 0;
+
+    PRTCIRCBUF pCircBuf = pStreamDS->pCircBuf;
+    AssertPtr(pCircBuf);
+
+    LPDIRECTSOUNDBUFFER8 pDSB = pStreamDS->Out.pDSB;
+    AssertPtr(pDSB);
+
+    int rc = VINF_SUCCESS;
+
+    DWORD offPlayCursor, offWriteCursor;
+    HRESULT hr = IDirectSoundBuffer8_GetCurrentPosition(pDSB, &offPlayCursor, &offWriteCursor);
+    if (FAILED(hr))
+    {
+        rc = VERR_ACCESS_DENIED; /** @todo Find a better rc. */
+        return rc;
+    }
+
+    DWORD cbFree, cbRemaining;
+    if (pStreamDS->Out.fFirstTransfer)
+    {
+        cbRemaining = 0;
+        cbFree      = pStreamDS->cbBufSize;
+    }
+    else
+    {
+        cbFree      = dsoundRingDistance(offPlayCursor, pStreamDS->Out.offWritePos, pStreamDS->cbBufSize);
+        cbRemaining = dsoundRingDistance(pStreamDS->Out.offWritePos, offPlayCursor, pStreamDS->cbBufSize);
+    }
+
+    uint32_t cbAvail      = (uint32_t)RTCircBufUsed(pCircBuf);
+    uint32_t cbToTransfer = RT_MIN(cbFree, cbAvail);
+
+#ifdef LOG_ENABLED
+    if (!pStreamDS->Dbg.tsLastTransferredMs)
+        pStreamDS->Dbg.tsLastTransferredMs = RTTimeMilliTS();
+    Log3Func(("tsLastTransferredMs=%RU64ms, cbAvail=%RU32, cbFree=%RU32 -> cbToTransfer=%RU32\n",
+              RTTimeMilliTS() - pStreamDS->Dbg.tsLastTransferredMs, cbAvail, cbFree, cbToTransfer));
+    pStreamDS->Dbg.tsLastTransferredMs = RTTimeMilliTS();
+#endif
+
+#if 0
+    if (cbToTransfer > cbAvail) /* Paranoia. */
+        cbToTransfer = cbAvail;
+
+    if (cbToTransfer > cbFree)
+        cbToTransfer = cbFree;
+#endif
+
+    while (cbToTransfer)
+    {
+        DWORD cb1 = 0;
+        DWORD cb2 = 0;
+
+        void  *pvBuf;
+        size_t cbBuf;
+        RTCircBufAcquireReadBlock(pCircBuf, cbToTransfer, &pvBuf, &cbBuf);
+
+        if (cbBuf)
+        {
+            PVOID pv1, pv2;
+            hr = directSoundPlayLock(pThis, pStreamDS, pStreamDS->Out.offWritePos, (DWORD)cbBuf,
+                                     &pv1, &pv2, &cb1, &cb2, 0 /* dwFlags */);
+            if (FAILED(hr))
+            {
+                rc = VERR_ACCESS_DENIED;
+                break;
+            }
+
+            AssertPtr(pv1);
+            Assert(cb1);
+
+            memcpy(pv1, pvBuf, cb1);
+
+            if (pv2 && cb2) /* Buffer wrap-around? Write second part. */
+                memcpy(pv2, (uint8_t *)pvBuf + cb1, cb2);
+
+            directSoundPlayUnlock(pThis, pDSB, pv1, pv2, cb1, cb2);
+
+            pStreamDS->Out.offWritePos = (pStreamDS->Out.offWritePos + cb1 + cb2) % pStreamDS->cbBufSize;
+
+            Assert(cbToTransfer >= cbBuf);
+            cbToTransfer -= (uint32_t)cbBuf;
+
+            cbTransferred += cb1 + cb2;
+        }
+
+        RTCircBufReleaseReadBlock(pCircBuf, cb1 + cb2);
+    }
+
+    pStreamDS->Out.cbTransferred += cbTransferred;
+
+    if (   pStreamDS->Out.fFirstTransfer
+        && pStreamDS->Out.cbTransferred >= DrvAudioHlpFramesToBytes(&pStreamDS->Cfg.Props, pStreamDS->Cfg.Backend.cfPreBuf))
+    {
+        hr = directSoundPlayStart(pThis, pStreamDS);
+        if (SUCCEEDED(hr))
+        {
+            DSLOG(("DSound: Started playing output\n"));
+            pStreamDS->Out.fFirstTransfer = false;
+        }
+        else
+            rc = VERR_ACCESS_DENIED; /** @todo Find a better rc. */
+    }
+
+    cbAvail = (uint32_t)RTCircBufUsed(pCircBuf);
+    if (   !cbAvail
+        && cbTransferred)
+    {
+        pStreamDS->Out.cbLastTransferred = cbTransferred;
+        pStreamDS->Out.tsLastTransferred = RTTimeMilliTS();
+    }
+
+    LogFlowFunc(("cbTransferred=%RU32, cbAvail=%RU32, rc=%Rrc\n", cbTransferred, cbAvail, rc));
+    return rc;
 }
 
@@ -908 +1007 @@
 
 
-static HRESULT directSoundPlayStart(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS)
+/**
+ * Resets the state of a DirectSound stream.
+ *
+ * @return  HRESULT
+ * @param   pThis               Host audio driver instance.
+ * @param   pStreamDS           Stream to reset state for.
+ */
+static HRESULT directSoundPlayReset(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS)
 {
     AssertPtrReturn(pThis,     E_POINTER);
@@ -919 +1025 @@
      *       once enough audio output data is available. */
 
-    pStreamDS->Out.fFirstPlayback = true;
-    pStreamDS->Out.cUnderruns     = 0;
-
-    DSLOG(("DSound: Playback started\n"));
+    if (pStreamDS->Cfg.enmDir == PDMAUDIODIR_OUT)
+    {
+        pStreamDS->Out.fFirstTransfer = true;
+        pStreamDS->Out.cUnderruns     = 0;
+
+        pStreamDS->Out.cbLastTransferred = 0;
+        pStreamDS->Out.tsLastTransferred = 0;
+
+        pStreamDS->Out.cbTransferred = 0;
+        pStreamDS->Out.cbWritten = 0;
+
+        pStreamDS->Out.offPlayCursorLastPending = 0;
+        pStreamDS->Out.offPlayCursorLastPlayed = 0;
+    }
 
     return S_OK;
 }
+
+
+/**
+ * Starts playing a DirectSound stream.
+ *
+ * @return  HRESULT
+ * @param   pThis               Host audio driver instance.
+ * @param   pStreamDS           Stream to start playing.
+ */
+static HRESULT directSoundPlayStart(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS)
+{
+    HRESULT hr = S_OK;
+
+    DWORD fFlags = DSCBSTART_LOOPING;
+
+    for (unsigned i = 0; i < DRV_DSOUND_RESTORE_ATTEMPTS_MAX; i++)
+    {
+        hr = IDirectSoundBuffer8_Play(pStreamDS->Out.pDSB, 0, 0, fFlags);
+        if (   SUCCEEDED(hr)
+            || hr != DSERR_BUFFERLOST)
+            break;
+        else
+        {
+            LogFunc(("Restarting playback failed due to lost buffer, restoring ...\n"));
+            directSoundPlayRestore(pThis, pStreamDS->Out.pDSB);
+        }
+    }
+
+    return hr;
+}
+
 
 /*
@@ -1124 +1271 @@
         bd.dwSize        = sizeof(bd);
         bd.lpwfxFormat   = &wfx;
-        bd.dwBufferBytes = DrvAudioHlpMsToBytes(&pCfgReq->Props, pThis->Cfg.msLatencyIn);
-
-        DSLOG(("DSound: Capture buffer is %ld bytes\n", bd.dwBufferBytes));
+        bd.dwBufferBytes = DrvAudioHlpFramesToBytes(&pCfgReq->Props, pCfgReq->Backend.cfBufferSize);
+
+        DSLOG(("DSound: Requested capture buffer is %RU64ms (%ld bytes)\n",
+               pCfgReq->Backend.cfBufferSize, DrvAudioHlpBytesToMs(&pCfgReq->Props, bd.dwBufferBytes), bd.dwBufferBytes));
 
         LPDIRECTSOUNDCAPTUREBUFFER pDSCB;
@@ -1177 +1325 @@
             break;
         }
+
+        DSLOG(("DSound: Acquired capture buffer is %RU64ms (%ld bytes)\n",
+               DrvAudioHlpBytesToMs(&pCfgReq->Props, bc.dwBufferBytes), bc.dwBufferBytes));
 
         DSLOG(("DSound: Capture format:\n"
@@ -1206 +1357 @@
         pStreamDS->cbBufSize     = bc.dwBufferBytes;
 
-        rc = RTCircBufCreate(&pStreamDS->pCircBuf, pStreamDS->cbBufSize * 2 /* Double buffering */);
+        rc = RTCircBufCreate(&pStreamDS->pCircBuf, pStreamDS->cbBufSize) * 2; /* Use "double buffering". */
         AssertRC(rc);
 
-        /*
-         * Install notification.
-         */
-        LPDIRECTSOUNDNOTIFY8 pNotify;
-        hr = IDirectSoundNotify_QueryInterface(pStreamDS->In.pDSCB, IID_IDirectSoundNotify8, (PVOID *)&pNotify);
-        if (SUCCEEDED(hr))
-        {
-            DSBPOSITIONNOTIFY dsPosNotify[3];
-            RT_ZERO(dsPosNotify);
-
-            dsPosNotify[0].dwOffset     = 0;
-            dsPosNotify[0].hEventNotify = pThis->aEvents[DSOUNDEVENT_INPUT];
-
-            dsPosNotify[1].dwOffset     = float(pStreamDS->cbBufSize * 0.3);
-            dsPosNotify[1].hEventNotify = pThis->aEvents[DSOUNDEVENT_INPUT];
-
-            dsPosNotify[2].dwOffset     = float(pStreamDS->cbBufSize * 0.6);
-            dsPosNotify[2].hEventNotify = pThis->aEvents[DSOUNDEVENT_INPUT];
-
-            hr = IDirectSoundNotify_SetNotificationPositions(pNotify, 3 /* Count */, dsPosNotify);
-            if (FAILED(hr))
-                DSLOGREL(("DSound: Setting capture position notification failed with %Rhrc\n", hr));
-
-            IDirectSoundNotify_Release(pNotify);
-
-            pThis->pDSStrmIn = pStreamDS;
-        }
-
-        pCfgAcq->cFrameBufferHint = PDMAUDIOSTREAMCFG_B2F(pCfgAcq, pStreamDS->cbBufSize);
+        pThis->pDSStrmIn = pStreamDS;
+
+        pCfgAcq->Backend.cfBufferSize = PDMAUDIOSTREAMCFG_B2F(pCfgAcq, pStreamDS->cbBufSize);
 
     } while (0);
@@ -1546 +1671 @@
     pStreamDS->Out.offPlayCursorLastPending = 0;
     pStreamDS->Out.cbWritten = 0;
-    pStreamDS->Out.cbPlayed = 0;
-    pStreamDS->Out.fFirstPlayback = true;
-    pStreamDS->Out.tsLastPlayMs = 0;
+    pStreamDS->Out.cbTransferred = 0;
+    pStreamDS->Out.fFirstTransfer = true;
+    pStreamDS->Out.cbLastTransferred = 0;
+    pStreamDS->Out.tsLastTransferred = 0;
 
     int rc = VINF_SUCCESS;
@@ -1572 +1698 @@
         case PDMAUDIOSTREAMCMD_ENABLE:
         {
+            hr = directSoundPlayReset(pThis, pStreamDS);
+            if (FAILED(hr))
+                rc = VERR_NOT_SUPPORTED; /** @todo Fix this. */
+            break;
+        }
+
+        case PDMAUDIOSTREAMCMD_RESUME:
+        {
             hr = directSoundPlayStart(pThis, pStreamDS);
             if (FAILED(hr))
@@ -1578 +1712 @@
         }
 
-        case PDMAUDIOSTREAMCMD_RESUME:
-        {
-            hr = directSoundPlayStart(pThis, pStreamDS);
-            if (SUCCEEDED(hr))
-            {
-                BOOL fRc = SetEvent(pThis->aEvents[DSOUNDEVENT_OUTPUT]);
-                RT_NOREF(fRc);
-                Assert(fRc);
-            }
-
-            if (FAILED(hr))
-                rc = VERR_NOT_SUPPORTED; /** @todo Fix this. */
-            break;
-        }
-
         case PDMAUDIOSTREAMCMD_DISABLE:
         case PDMAUDIOSTREAMCMD_PAUSE:
@@ -1602 +1721 @@
         }
 
+        case PDMAUDIOSTREAMCMD_DRAIN:
+        {
+            /* Make sure we transferred everything. */
+            rc = dsoundPlayTransfer(pThis);
+            if (   RT_SUCCESS(rc)
+                && pStreamDS->Out.fFirstTransfer)
+            {
+                /* If this was the first transfer ever for this stream, make sure to also play the (short) audio data. */
+                DSLOG(("DSound: Started playing output (short sound)\n"));
+
+                pStreamDS->Out.fFirstTransfer    = false;
+                pStreamDS->Out.cbLastTransferred = pStreamDS->Out.cbTransferred; /* All transferred audio data must be played. */
+                pStreamDS->Out.tsLastTransferred = RTTimeMilliTS();
+
+                hr = directSoundPlayStart(pThis, pStreamDS);
+                if (FAILED(hr))
+                    rc = VERR_ACCESS_DENIED; /** @todo Find a better rc. */
+            }
+            break;
+        }
+
         default:
-        {
-            AssertMsgFailed(("Invalid command: %ld\n", enmStreamCmd));
-            rc = VERR_INVALID_PARAMETER;
+            rc = VERR_NOT_SUPPORTED;
             break;
-        }
     }
 
@@ -1658 +1795 @@
 
     Assert(cbWrittenTotal <= cxBuf);
+    Assert(cbWrittenTotal == cxBuf);
 
     pStreamDS->Out.cbWritten += cbWrittenTotal;
 
-    if (   pStreamDS->Out.fFirstPlayback
-        && pStreamDS->Out.cbWritten >= pStreamDS->cbBufSize)
-    {
-        BOOL fRc = SetEvent(pThis->aEvents[DSOUNDEVENT_OUTPUT]);
-        RT_NOREF(fRc);
-        Assert(fRc);
-    }
+    rc = dsoundPlayTransfer(pThis);
+    AssertRC(rc);
 
     if (RT_SUCCESS(rc))
@@ -1740 +1873 @@
                 {
                     PDMAUDIOSTREAMCFG CfgAcq;
-                    hr = directSoundCaptureOpen(pThis, pStreamDS, pStreamDS->pCfg /* pCfgReq */, &CfgAcq);
+                    hr = directSoundCaptureOpen(pThis, pStreamDS, &pStreamDS->Cfg /* pCfgReq */, &CfgAcq);
                     if (SUCCEEDED(hr))
                     {
-                        DrvAudioHlpStreamCfgFree(pStreamDS->pCfg);
-
-                        pStreamDS->pCfg = DrvAudioHlpStreamCfgDup(&CfgAcq);
-                        AssertPtr(pStreamDS->pCfg);
+                        rc = DrvAudioHlpStreamCfgCopy(&pStreamDS->Cfg, &CfgAcq);
+                        if (RT_FAILURE(rc))
+                            break;
 
                         /** @todo What to do if the format has changed? */
@@ -1777 +1909 @@
 
         default:
-        {
-            AssertMsgFailed(("Invalid command %ld\n", enmStreamCmd));
-            rc = VERR_INVALID_PARAMETER;
+            rc = VERR_NOT_SUPPORTED;
             break;
-        }
     }
 
@@ -1859 +1988 @@
 }
 
-static int dsoundNotifyThread(PDRVHOSTDSOUND pThis, bool fShutdown)
-{
-    AssertPtrReturn(pThis, VERR_INVALID_POINTER);
-
-    if (fShutdown)
-    {
-        LogFlowFunc(("Shutting down thread ...\n"));
-        pThis->fShutdown = fShutdown;
-    }
-
-    /* Set the notification event so that the thread is being notified. */
-    BOOL fRc = SetEvent(pThis->aEvents[DSOUNDEVENT_NOTIFY]);
-    RT_NOREF(fRc);
-    Assert(fRc);
-
-    return VINF_SUCCESS;
-}
-
-
-static DECLCALLBACK(int) dsoundThread(RTTHREAD hThreadSelf, void *pvUser)
-{
-    PDRVHOSTDSOUND pThis = (PDRVHOSTDSOUND)pvUser;
-    AssertPtr(pThis);
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnShutdown}
+ */
+void drvHostDSoundShutdown(PPDMIHOSTAUDIO pInterface)
+{
+    PDRVHOSTDSOUND pThis = PDMIHOSTAUDIO_2_DRVHOSTDSOUND(pInterface);
 
     LogFlowFuncEnter();
 
-    /* Let caller know that we're done initializing, regardless of the result. */
-    int rc = RTThreadUserSignal(hThreadSelf);
-    AssertRC(rc);
-
-    for (;;)
-    {
-        RTCritSectEnter(&pThis->CritSect);
-
-        HANDLE aEvents[VBOX_DSOUND_MAX_EVENTS];
-        DWORD  cEvents = 0;
-        for (uint8_t i = 0; i < VBOX_DSOUND_MAX_EVENTS; i++)
-        {
-            if (pThis->aEvents[i])
-                aEvents[cEvents++] = pThis->aEvents[i];
-        }
-        Assert(cEvents);
-
-        RTCritSectLeave(&pThis->CritSect);
-
-        DWORD dwObj = WaitForMultipleObjects(cEvents, aEvents, FALSE /* bWaitAll */, INFINITE);
-
-        RTCritSectEnter(&pThis->CritSect);
-
-        switch (dwObj)
-        {
-            case WAIT_FAILED:
-            {
-                rc = VERR_CANCELLED;
-                break;
-            }
-
-            case WAIT_TIMEOUT:
-            {
-                rc = VERR_TIMEOUT;
-                break;
-            }
-
-            case WAIT_OBJECT_0:
-            case WAIT_OBJECT_0 + 1:
-            case WAIT_OBJECT_0 + 2:
-            case WAIT_OBJECT_0 + 3:
-            case WAIT_OBJECT_0 + 4:
-            {
-                dwObj -= WAIT_OBJECT_0;
-
-                if (dwObj == DSOUNDEVENT_NOTIFY)
-                {
-                    Log3Func(("Notify\n"));
-                }
-                else if (dwObj == DSOUNDEVENT_INPUT)
-                {
-                    PDSOUNDSTREAM pStreamDS = pThis->pDSStrmIn;
-
-                    if (   !pStreamDS
-                        || !pStreamDS->fEnabled)
-                    {
-                        Log3Func(("Skipping capture\n"));
-                        break;
-                    }
-
-                    LPDIRECTSOUNDCAPTUREBUFFER8 pDSCB = pStreamDS->In.pDSCB;
-                    AssertPtr(pDSCB);
-
-                    DWORD offCaptureCursor;
-                    HRESULT hr = IDirectSoundCaptureBuffer_GetCurrentPosition(pDSCB, NULL, &offCaptureCursor);
-                    if (FAILED(hr))
-                        break;
-
-                    DWORD cbUsed = dsoundRingDistance(offCaptureCursor, pStreamDS->In.offReadPos, pStreamDS->cbBufSize);
-
-                    PRTCIRCBUF pCircBuf = pStreamDS->pCircBuf;
-                    AssertPtr(pCircBuf);
-
-                    uint32_t cbFree = (uint32_t)RTCircBufFree(pCircBuf);
-                    if (   !cbFree
-                        || pStreamDS->In.cOverruns < 32) /** @todo Make this configurable. */
-                    {
-                        DSLOG(("DSound: Warning: Capture buffer full, skipping to record data (%RU32 bytes)\n", cbUsed));
-                        pStreamDS->In.cOverruns++;
-                    }
-
-                    DWORD cbToCapture = RT_MIN(cbUsed, cbFree);
-
-                    Log3Func(("cbUsed=%ld, cbToCapture=%ld\n", cbUsed, cbToCapture));
-
-                    while (cbToCapture)
-                    {
-                        void  *pvBuf;
-                        size_t cbBuf;
-                        RTCircBufAcquireWriteBlock(pCircBuf, cbToCapture, &pvBuf, &cbBuf);
-
-                        if (cbBuf)
-                        {
-                            PVOID pv1, pv2;
-                            DWORD cb1, cb2;
-                            hr = directSoundCaptureLock(pStreamDS, pStreamDS->In.offReadPos, (DWORD)cbBuf,
-                                                        &pv1, &pv2, &cb1, &cb2, 0 /* dwFlags */);
-                            if (FAILED(hr))
-                                break;
-
-                            AssertPtr(pv1);
-                            Assert(cb1);
-
-                            memcpy(pvBuf, pv1, cb1);
-
-                            if (pv2 && cb2) /* Buffer wrap-around? Write second part. */
-                                memcpy((uint8_t *)pvBuf + cb1, pv2, cb2);
-
-                            directSoundCaptureUnlock(pDSCB, pv1, pv2, cb1, cb2);
-
-                            pStreamDS->In.offReadPos = (pStreamDS->In.offReadPos + cb1 + cb2) % pStreamDS->cbBufSize;
-
-                            Assert(cbToCapture >= cbBuf);
-                            cbToCapture -= (uint32_t)cbBuf;
-                        }
-
-#ifdef VBOX_AUDIO_DEBUG_DUMP_PCM_DATA
-                        if (cbBuf)
-                        {
-                            RTFILE fh;
-                            int rc2 = RTFileOpen(&fh, VBOX_AUDIO_DEBUG_DUMP_PCM_DATA_PATH "dsoundCapture.pcm",
-                                                 RTFILE_O_OPEN_CREATE | RTFILE_O_APPEND | RTFILE_O_WRITE | RTFILE_O_DENY_NONE);
-                            if (RT_SUCCESS(rc2))
-                            {
-                                RTFileWrite(fh, pvBuf, cbBuf, NULL);
-                                RTFileClose(fh);
-                            }
-                        }
-#endif
-                        RTCircBufReleaseWriteBlock(pCircBuf, cbBuf);
-                    }
-                }
-                else if (dwObj == DSOUNDEVENT_OUTPUT)
-                {
-                    PDSOUNDSTREAM pStreamDS = pThis->pDSStrmOut;
-
-                    if (   !pStreamDS
-                        || !pStreamDS->fEnabled)
-                    {
-                        Log3Func(("Skipping playback\n"));
-                        break;
-                    }
-
-                    LPDIRECTSOUNDBUFFER8 pDSB = pStreamDS->Out.pDSB;
-                    AssertPtr(pDSB);
-
-                    HRESULT hr;
-
-                    DWORD offPlayCursor, offWriteCursor;
-                    hr = IDirectSoundBuffer8_GetCurrentPosition(pDSB, &offPlayCursor, &offWriteCursor);
-                    if (FAILED(hr))
-                        break;
-
-                    DWORD cbFree, cbRemaining;
-                    if (pStreamDS->Out.fFirstPlayback)
-                    {
-                        cbRemaining = 0;
-                        cbFree      = dsoundRingDistance(pStreamDS->Out.offWritePos, 0, pStreamDS->cbBufSize);
-                    }
-                    else
-                    {
-                        cbFree      = dsoundRingDistance(offPlayCursor, pStreamDS->Out.offWritePos, pStreamDS->cbBufSize);
-                        cbRemaining = dsoundRingDistance(pStreamDS->Out.offWritePos, offPlayCursor, pStreamDS->cbBufSize);
-                    }
-
-                    PRTCIRCBUF pCircBuf = pStreamDS->pCircBuf;
-                    AssertPtr(pCircBuf);
-
-                    DWORD cbUsed   = (uint32_t)RTCircBufUsed(pCircBuf);
-                    DWORD cbToPlay = RT_MIN(cbFree, cbUsed);
-
-                    if (   !cbUsed
-                        && pStreamDS->Out.cbWritten
-                        && pStreamDS->Out.cUnderruns < 32) /** @todo Make this configurable. */
-                    {
-                        //DSLOG(("DSound: Warning: No more playback data available within time (%RU32 bytes free)\n", cbFree));
-                        Log3Func(("Underrun (cbFree=%ld, cbRemaining=%ld, cbUsed=%ld, cbToPlay=%ld, offPlay=%ld, offWrite=%ld)\n",
-                                  cbFree, cbRemaining, cbUsed, cbToPlay, offPlayCursor, offWriteCursor));
-                        pStreamDS->Out.cUnderruns++;
-                    }
-
-                    while (cbToPlay)
-                    {
-                        void  *pvBuf;
-                        size_t cbBuf;
-                        RTCircBufAcquireReadBlock(pCircBuf, cbToPlay, &pvBuf, &cbBuf);
-
-                        if (cbBuf)
-                        {
-                            PVOID pv1, pv2;
-                            DWORD cb1, cb2;
-                            hr = directSoundPlayLock(pThis, pStreamDS, pStreamDS->Out.offWritePos, (DWORD)cbBuf,
-                                                     &pv1, &pv2, &cb1, &cb2, 0 /* dwFlags */);
-                            if (FAILED(hr))
-                                break;
-
-                            AssertPtr(pv1);
-                            Assert(cb1);
-
-                            memcpy(pv1, pvBuf, cb1);
-
-                            if (pv2 && cb2) /* Buffer wrap-around? Write second part. */
-                                memcpy(pv2, (uint8_t *)pvBuf + cb1, cb2);
-
-                            directSoundPlayUnlock(pThis, pDSB, pv1, pv2, cb1, cb2);
-
-                            pStreamDS->Out.offWritePos = (pStreamDS->Out.offWritePos + cb1 + cb2) % pStreamDS->cbBufSize;
-
-                            Assert(cbToPlay >= cbBuf);
-                            cbToPlay -= (uint32_t)cbBuf;
-
-                            pStreamDS->Out.cbPlayed += cb1 + cb2;
-                        }
-
-                        RTCircBufReleaseReadBlock(pCircBuf, cbBuf);
-                    }
-
-                    if (   pStreamDS->Out.fFirstPlayback
-                        && RTCircBufUsed(pCircBuf) >= pStreamDS->cbBufSize)
-                    {
-                        DWORD fFlags = DSCBSTART_LOOPING;
-
-                        for (unsigned i = 0; i < DRV_DSOUND_RESTORE_ATTEMPTS_MAX; i++)
-                        {
-                            hr = IDirectSoundBuffer8_Play(pDSB, 0, 0, fFlags);
-                            if (   SUCCEEDED(hr)
-                                || hr != DSERR_BUFFERLOST)
-                                break;
-                            else
-                            {
-                                LogFunc(("Restarting playback failed due to lost buffer, restoring ...\n"));
-                                directSoundPlayRestore(pThis, pDSB);
-                            }
-                        }
-
-                        if (SUCCEEDED(hr))
-                        {
-                            DSLOG(("DSound: Started playing output\n"));
-                            pStreamDS->Out.fFirstPlayback = false;
-                        }
-                    }
-                }
-                break;
-            }
-
-            default:
-                AssertFailed();
-                break;
-        }
-
-        RTCritSectLeave(&pThis->CritSect);
-
-        if (pThis->fShutdown)
-            break;
-
-    } /* for */
-
-    pThis->fStopped = true;
-
-    LogFlowFunc(("Exited with fShutdown=%RTbool, rc=%Rrc\n", pThis->fShutdown, rc));
-    return rc;
-}
-
-/**
- * @interface_method_impl{PDMIHOSTAUDIO,pfnShutdown}
- */
-void drvHostDSoundShutdown(PPDMIHOSTAUDIO pInterface)
-{
-    PDRVHOSTDSOUND pThis = PDMIHOSTAUDIO_2_DRVHOSTDSOUND(pInterface);
-
-    LogFlowFuncEnter();
-
-    int rc = dsoundNotifyThread(pThis, true /* fShutdown */);
-    AssertRC(rc);
-
-    int rcThread;
-    rc = RTThreadWait(pThis->Thread,  15 * 1000 /* 15s timeout */, &rcThread);
-    LogFlowFunc(("rc=%Rrc, rcThread=%Rrc\n", rc, rcThread));
-
-    Assert(pThis->fStopped);
-
-    for (int i = 0; i < VBOX_DSOUND_MAX_EVENTS; i++)
-    {
-        if (pThis->aEvents[i])
-            CloseHandle(pThis->aEvents[i]);
-    }
+    RT_NOREF(pThis);
 
     LogFlowFuncLeave();
@@ -2192 +2019 @@
         IDirectSound_Release(pDirectSound);
 
-        /* Create notification events. */
-        for (int i = 0; i < VBOX_DSOUND_MAX_EVENTS; i++)
-        {
-            pThis->aEvents[i] = CreateEvent(NULL /* Security attribute */,
-                                            FALSE /* bManualReset */, FALSE /* bInitialState */,
-                                            NULL /* lpName */);
-            Assert(pThis->aEvents[i] != NULL);
-        }
-
-        /* Start notification thread. */
-        rc = RTThreadCreate(&pThis->Thread, dsoundThread,
-                            pThis /*pvUser*/, 0 /*cbStack*/,
-                            RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "dsoundNtfy");
-        if (RT_SUCCESS(rc))
-        {
-            /* Wait for the thread to initialize. */
-            rc = RTThreadUserWait(pThis->Thread, RT_MS_1MIN);
-            if (RT_FAILURE(rc))
-                DSLOGREL(("DSound: Waiting for thread to initialize failed with rc=%Rrc\n", rc));
-        }
-        else
-            DSLOGREL(("DSound: Creating thread failed with rc=%Rrc\n", rc));
+        rc = VINF_SUCCESS;
 
         dsoundUpdateStatusInternalEx(pThis, NULL /* pCfg */, DSOUNDENUMCBFLAGS_LOG /* fEnum */);
@@ -2249 +2055 @@
 static int dsoundConfigInit(PDRVHOSTDSOUND pThis, PCFGMNODE pCfg)
 {
-    CFGMR3QueryUIntDef(pCfg, "LatencyMsIn",  &pThis->Cfg.msLatencyIn,  DRV_DSOUND_DEFAULT_LATENCY_MS_IN);
-    CFGMR3QueryUIntDef(pCfg, "LatencyMsOut", &pThis->Cfg.msLatencyOut, DRV_DSOUND_DEFAULT_LATENCY_MS_OUT);
-
     pThis->Cfg.pGuidPlay    = dsoundConfigQueryGUID(pCfg, "DeviceGuidOut", &pThis->Cfg.uuidPlay);
     pThis->Cfg.pGuidCapture = dsoundConfigQueryGUID(pCfg, "DeviceGuidIn",  &pThis->Cfg.uuidCapture);
 
-    DSLOG(("DSound: Configuration: Input latency = %ums, Output latency = %ums, DeviceGuidOut {%RTuuid}, DeviceGuidIn {%RTuuid}\n",
-           pThis->Cfg.msLatencyIn,
-           pThis->Cfg.msLatencyOut,
+    DSLOG(("DSound: Configuration: DeviceGuidOut {%RTuuid}, DeviceGuidIn {%RTuuid}\n",
            &pThis->Cfg.uuidPlay,
            &pThis->Cfg.uuidCapture));
@@ -2297 +2098 @@
     if (RT_SUCCESS(rc))
     {
-        pStreamDS->pCfg = DrvAudioHlpStreamCfgDup(pCfgAcq);
-        if (pStreamDS->pCfg)
-        {
+        rc = DrvAudioHlpStreamCfgCopy(&pStreamDS->Cfg, pCfgAcq);
+        if (RT_SUCCESS(rc))
             rc = RTCritSectInit(&pStreamDS->CritSect);
-        }
-        else
-            rc = VERR_NO_MEMORY;
     }
 
@@ -2320 +2117 @@
     PDSOUNDSTREAM  pStreamDS = (PDSOUNDSTREAM)pStream;
 
-    if (!pStreamDS->pCfg) /* Not (yet) configured? Skip. */
-        return VINF_SUCCESS;
-
     int rc;
-    if (pStreamDS->pCfg->enmDir == PDMAUDIODIR_IN)
+    if (pStreamDS->Cfg.enmDir == PDMAUDIODIR_IN)
         rc = dsoundDestroyStreamIn(pThis, pStreamDS);
     else
@@ -2332 +2126 @@
     {
         rc = RTCritSectDelete(&pStreamDS->CritSect);
-
-        DrvAudioHlpStreamCfgFree(pStreamDS->pCfg);
-        pStreamDS->pCfg = NULL;
     }
 
@@ -2352 +2143 @@
     PDSOUNDSTREAM  pStreamDS = (PDSOUNDSTREAM)pStream;
 
-    if (!pStreamDS->pCfg) /* Not (yet) configured? Skip. */
-        return VINF_SUCCESS;
-
     int rc;
-    if (pStreamDS->pCfg->enmDir == PDMAUDIODIR_IN)
+    if (pStreamDS->Cfg.enmDir == PDMAUDIODIR_IN)
         rc = dsoundControlStreamIn(pThis,  pStreamDS, enmStreamCmd);
     else
@@ -2409 +2197 @@
     PDSOUNDSTREAM  pStreamDS = (PDSOUNDSTREAM)pStream;
 
-    if (pStreamDS->pCfg->enmDir == PDMAUDIODIR_OUT)
+    if (pStreamDS->Cfg.enmDir == PDMAUDIODIR_OUT)
     {
         uint32_t cbPending = 0;
@@ -2421 +2209 @@
         if (!cbPending)
         {
-            const uint64_t tsNowMs = RTTimeMilliTS();
-            if (pStreamDS->Out.tsLastPlayMs == 0)
-                pStreamDS->Out.tsLastPlayMs = tsNowMs;
-
-            PDRVHOSTDSOUND pThis = PDMIHOSTAUDIO_2_DRVHOSTDSOUND(pInterface);
-
-            const uint64_t diffLastPlayMs = tsNowMs - pStreamDS->Out.tsLastPlayMs;
-            const uint64_t msThreshold    = pThis->Cfg.msLatencyOut;
-
-            Log2Func(("diffLastPlayMs=%RU64ms\n", diffLastPlayMs));
-
-            cbPending = (diffLastPlayMs >= msThreshold) ? 0 : 1;
-        }
+            const uint64_t diffLastTransferredMs  = RTTimeMilliTS() - pStreamDS->Out.tsLastTransferred;
+            const uint64_t uLastTranserredChunkMs = DrvAudioHlpBytesToMs(&pStreamDS->Cfg.Props, pStreamDS->Out.cbLastTransferred);
+            if (   uLastTranserredChunkMs
+                && diffLastTransferredMs < uLastTranserredChunkMs)
+                cbPending = 1;
+
+            Log3Func(("diffLastTransferredMs=%RU64ms, uLastTranserredChunkMs=%RU64ms (%RU32 bytes) -> cbPending=%RU32\n",
+                      diffLastTransferredMs, uLastTranserredChunkMs, pStreamDS->Out.cbLastTransferred, cbPending));
+        }
+        else
+            Log3Func(("cbPending=%RU32\n", cbPending));
 
         return cbPending;
@@ -2452 +2238 @@
     PDSOUNDSTREAM pStreamDS = (PDSOUNDSTREAM)pStream;
 
-    if (!pStreamDS->pCfg) /* Not (yet) configured? Skip. */
-        return PDMAUDIOSTREAMSTS_FLAG_NONE;
-
     PDMAUDIOSTREAMSTS strmSts = PDMAUDIOSTREAMSTS_FLAG_INITIALIZED;
-    if (pStreamDS->pCfg->enmDir == PDMAUDIODIR_IN)
+    if (pStreamDS->Cfg.enmDir == PDMAUDIODIR_IN)
     {
         if (pStreamDS->fEnabled)
@@ -2623 +2406 @@
     pThis->fEnabledIn  = false;
     pThis->fEnabledOut = false;
-    pThis->fStopped    = false;
-    pThis->fShutdown   = false;
-
-    RT_ZERO(pThis->aEvents);
 
     int rc = VINF_SUCCESS;

trunk/src/VBox/Devices/Audio/DrvHostDebugAudio.cpp

@@ -120 +120 @@
 
     if (pCfgAcq)
-        pCfgAcq->cFrameBufferHint = _1K;
+    {
+        pCfgAcq->Backend.cfPeriod     = DrvAudioHlpMsToFrames(&pCfgReq->Props, 1000 /* ms */);
+        pCfgAcq->Backend.cfBufferSize = pCfgAcq->Backend.cfPeriod * 2; /* Use "double buffering". */
+    }
 
     return VINF_SUCCESS;
@@ -159 +162 @@
     {
         if (pCfgAcq)
-            pCfgAcq->cFrameBufferHint = _1K;
+        {
+            pCfgAcq->Backend.cfPeriod     = DrvAudioHlpBytesToFrames(&pCfgReq->Props, 50 /* ms */);
+            pCfgAcq->Backend.cfBufferSize = pCfgAcq->Backend.cfPeriod * 2; /* Use "double buffering". */
+        }
     }
 

trunk/src/VBox/Devices/Audio/DrvHostNullAudio.cpp

@@ -174 +174 @@
 static int nullCreateStreamIn(PNULLAUDIOSTREAM pStreamNull, PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
 {
-    RT_NOREF(pStreamNull, pCfgReq);
-
-    if (pCfgAcq)
-        pCfgAcq->cFrameBufferHint = _1K;
+    RT_NOREF(pStreamNull, pCfgReq, pCfgAcq);
 
     return VINF_SUCCESS;
@@ -185 +182 @@
 static int nullCreateStreamOut(PNULLAUDIOSTREAM pStreamNull, PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
 {
-    RT_NOREF(pStreamNull, pCfgReq);
-
-    if (pCfgAcq)
-        pCfgAcq->cFrameBufferHint = _1K; /** @todo Make this configurable. */
+    RT_NOREF(pStreamNull, pCfgReq, pCfgAcq);
 
     return VINF_SUCCESS;

trunk/src/VBox/Devices/Audio/DrvHostOSSAudio.cpp

@@ -386 +386 @@
 
         default:
-            AssertMsgFailed(("Invalid command %ld\n", enmStreamCmd));
-            rc = VERR_INVALID_PARAMETER;
+            rc = VERR_NOT_SUPPORTED;
             break;
     }
@@ -650 +649 @@
             }
 
-            uint32_t cSamples = PDMAUDIOSTREAMCFG_B2F(pCfgAcq, ossAcq.cFragments * ossAcq.cbFragmentSize);
-            if (!cSamples)
-                rc = VERR_INVALID_PARAMETER;
-
             if (RT_SUCCESS(rc))
             {
-                size_t cbBuf = PDMAUDIOSTREAMCFG_F2B(pCfgAcq, cSamples);
+                size_t cbBuf = PDMAUDIOSTREAMCFG_F2B(pCfgAcq, ossAcq.cFragments * ossAcq.cbFragmentSize);
                 void  *pvBuf = RTMemAlloc(cbBuf);
                 if (!pvBuf)
@@ -668 +663 @@
                 pStreamOSS->cbBuf = cbBuf;
 
-                pCfgAcq->cFrameBufferHint = cSamples;
+                pCfgAcq->Backend.cfPeriod     = PDMAUDIOSTREAMCFG_B2F(pCfgAcq, ossAcq.cbFragmentSize);
+                pCfgAcq->Backend.cfBufferSize = pCfgAcq->Backend.cfPeriod * 2; /* Use "double buffering". */
+                /** @todo Pre-buffering required? */
             }
         }
@@ -689 +686 @@
     do
     {
-        uint32_t cSamples;
-
         OSSAUDIOSTREAMCFG reqStream, obtStream;
 
@@ -703 +698 @@
             memcpy(&pCfgAcq->Props, &obtStream.Props, sizeof(PDMAUDIOPCMPROPS));
 
-            cSamples = PDMAUDIOSTREAMCFG_B2F(pCfgAcq, obtStream.cFragments * obtStream.cbFragmentSize);
-
             if (obtStream.cFragments * obtStream.cbFragmentSize & pStreamOSS->uAlign)
             {
@@ -716 +709 @@
             pStreamOSS->Out.fMMIO = false;
 
-            size_t cbBuf = PDMAUDIOSTREAMCFG_F2B(pCfgAcq, cSamples);
+            size_t cbBuf = PDMAUDIOSTREAMCFG_F2B(pCfgAcq, obtStream.cFragments * obtStream.cbFragmentSize);
             Assert(cbBuf);
 
@@ -773 +766 @@
                 if (!pvBuf)
                 {
-                    LogRel(("OSS: Failed allocating playback buffer with %RU32 samples (%zu bytes)\n", cSamples, cbBuf));
+                    LogRel(("OSS: Failed allocating playback buffer with %zu bytes\n", cbBuf));
                     rc = VERR_NO_MEMORY;
                     break;
@@ -784 +777 @@
             }
 #endif
-            pCfgAcq->cFrameBufferHint = cSamples;
+            pCfgAcq->Backend.cfPeriod     = PDMAUDIOSTREAMCFG_B2F(pCfgAcq, obtStream.cbFragmentSize);
+            pCfgAcq->Backend.cfBufferSize = pCfgAcq->Backend.cfPeriod * 2; /* Use "double buffering" */
         }
 

trunk/src/VBox/Devices/Audio/DrvHostPulseAudio.cpp

@@ -788 +788 @@
     if (cbBuf)
     {
-        pCfgAcq->cFrameBufferHint = PDMAUDIOSTREAMCFG_B2F(pCfgAcq, cbBuf);
+        pCfgAcq->Backend.cfPeriod     = PDMAUDIOSTREAMCFG_B2F(pCfgAcq, pStreamPA->BufAttr.minreq);
+        pCfgAcq->Backend.cfBufferSize = PDMAUDIOSTREAMCFG_B2F(pCfgAcq, pStreamPA->BufAttr.tlength);
+        pCfgAcq->Backend.cfPreBuf     = PDMAUDIOSTREAMCFG_B2F(pCfgAcq, pStreamPA->BufAttr.prebuf);
 
         pStreamPA->pDrv = pThis;
@@ -833 +835 @@
     pCfgAcq->Props.uHz         = pStreamPA->SampleSpec.rate;
     pCfgAcq->Props.cChannels   = pStreamPA->SampleSpec.channels;
-    pCfgAcq->cFrameBufferHint = PDMAUDIOSTREAMCFG_B2F(pCfgAcq,
-                                                       RT_MIN(pStreamPA->BufAttr.fragsize * 10, pStreamPA->BufAttr.maxlength));
+
+    pCfgAcq->Backend.cfPeriod     = PDMAUDIOSTREAMCFG_B2F(pCfgAcq, pStreamPA->BufAttr.fragsize);
+    pCfgAcq->Backend.cfBufferSize = pCfgAcq->Backend.cfPeriod * 2; /* Use double buffering. */
 
     LogFlowFuncLeaveRC(rc);
@@ -1332 +1335 @@
 
         default:
-            AssertMsgFailed(("Invalid command %ld\n", enmStreamCmd));
-            rc = VERR_INVALID_PARAMETER;
+            rc = VERR_NOT_SUPPORTED;
             break;
     }
@@ -1375 +1377 @@
 
         default:
-            AssertMsgFailed(("Invalid command %ld\n", enmStreamCmd));
-            rc = VERR_INVALID_PARAMETER;
+            rc = VERR_NOT_SUPPORTED;
             break;
     }

trunk/src/VBox/Devices/Audio/DrvHostValidationKit.cpp

@@ -132 +132 @@
 
     if (pCfgAcq)
-        pCfgAcq->cFrameBufferHint = _1K;
+        pCfgAcq->cfPeriod = _1K;
 
     return VINF_SUCCESS;
@@ -194 +194 @@
     {
         if (pCfgAcq)
-            pCfgAcq->cFrameBufferHint = PDMAUDIOSTREAMCFG_B2F(pCfgAcq, pStreamDbg->Out.cbPlayBuffer);
+            pCfgAcq->cfPeriod = PDMAUDIOSTREAMCFG_B2F(pCfgAcq, pStreamDbg->Out.cbPlayBuffer);
     }
 

trunk/src/VBox/Devices/Audio/HDAStream.cpp

@@ -197 +197 @@
     /* Set scheduling hint (if available). */
     if (pThis->u16TimerHz)
-        pCfg->Device.uSchedulingHintMs = 1000 /*ms */ / pThis->u16TimerHz;
+        pCfg->Device.uSchedulingHintMs = 1000 /* ms */ / pThis->u16TimerHz;
 
     /* (Re-)Allocate the stream's internal DMA buffer, based on the PCM  properties we just got above. */

trunk/src/VBox/Devices/Audio/HDAStream.h

@@ -165 +165 @@
      *  Should match SDFMT. */
     PDMAUDIOSTREAMCFG       Cfg;
+    uint32_t                Padding3;
 #ifdef HDA_USE_DMA_ACCESS_HANDLER
     /** List of DMA handlers. */
@@ -175 +176 @@
     uint16_t                cbDMALeft;
     /** Unused, padding. */
-    uint8_t                 abPadding3[2+4];
+    uint8_t                 abPadding4[2+4];
 } HDASTREAMSTATE;
 AssertCompileSizeAlignment(HDASTREAMSTATE, 8);

trunk/src/VBox/Main/include/DrvAudioVRDE.h

@@ -47 +47 @@
 public:
 
+    void onVRDEClientConnect(uint32_t uClientID);
+    void onVRDEClientDisconnect(uint32_t uClientID);
     int onVRDEControl(bool fEnable, uint32_t uFlags);
     int onVRDEInputBegin(void *pvContext, PVRDEAUDIOINBEGIN pVRDEAudioBegin);

trunk/src/VBox/Main/src-client/ConsoleVRDPServer.cpp

@@ -933 +933 @@
 DECLCALLBACK(void) ConsoleVRDPServer::VRDPCallbackClientConnect(void *pvCallback, uint32_t u32ClientId)
 {
-    ConsoleVRDPServer *server = static_cast<ConsoleVRDPServer*>(pvCallback);
-
-    server->mConsole->i_VRDPClientConnect(u32ClientId);
+    ConsoleVRDPServer *pServer = static_cast<ConsoleVRDPServer*>(pvCallback);
+
+    pServer->mConsole->i_VRDPClientConnect(u32ClientId);
 
     /* Should the server report usage of an interface for each client?
      * Similar to Intercept.
      */
-    int c = ASMAtomicIncS32(&server->mcClients);
+    int c = ASMAtomicIncS32(&pServer->mcClients);
     if (c == 1)
     {
         /* Features which should be enabled only if there is a client. */
-        server->remote3DRedirect(true);
-    }
+        pServer->remote3DRedirect(true);
+    }
+
+#ifdef VBOX_WITH_AUDIO_VRDE
+    AudioVRDE *pVRDE = pServer->mConsole->i_getAudioVRDE();
+    if (pVRDE)
+        pVRDE->onVRDEClientConnect(u32ClientId);
+#endif
 }
 
@@ -964 +970 @@
         AudioVRDE *pVRDE = pServer->mConsole->i_getAudioVRDE();
         if (pVRDE)
+        {
             pVRDE->onVRDEInputIntercept(false /* fIntercept */);
+            pVRDE->onVRDEClientDisconnect(u32ClientId);
+        }
 #endif
     }

trunk/src/VBox/Main/src-client/DrvAudioVRDE.cpp

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2013-2017 Oracle Corporation
+ * Copyright (C) 2013-2018 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -59 +59 @@
     /** Pointer to the DrvAudio port interface that is above us. */
     PPDMIAUDIOCONNECTOR  pDrvAudio;
+    /** Number of connected clients to this VRDE instance. */
+    uint32_t             cClients;
 } DRVAUDIOVRDE, *PDRVAUDIOVRDE;
 
@@ -69 +71 @@
         struct
         {
-            /** Number of audio frames this stream can handle at once. */
-            uint32_t    cfMax;
             /** Circular buffer for holding the recorded audio frames from the host. */
             PRTCIRCBUF  pCircBuf;
@@ -76 +76 @@
         struct
         {
-            /** Timestamp (in virtual time ticks) of the last audio playback (of the VRDP server). */
-            uint64_t    ticksPlayedLast;
-            /** Internal counter (in audio frames) to track if and how much we can write to the VRDP server
-             *  for the current time period. */
-            uint64_t    cfToWrite;
+            uint32_t last;
         } Out;
     };
@@ -90 +86 @@
 static int vrdeCreateStreamIn(PVRDESTREAM pStreamVRDE, PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
 {
-    pStreamVRDE->In.cfMax = _1K; /** @todo Make this configurable. */
-
-    int rc = RTCircBufCreate(&pStreamVRDE->In.pCircBuf, pStreamVRDE->In.cfMax * (pCfgReq->Props.cBits / 8) /* Bytes */);
+    RT_NOREF(pCfgReq);
+    AssertPtrReturn(pCfgAcq, VERR_INVALID_POINTER);
+
+    pCfgAcq->Props.uHz       = 22050; /* The VRDP server's internal frequency. */
+    pCfgAcq->Props.cChannels = 2;
+    pCfgAcq->Props.cBits     = 16;
+    pCfgAcq->Props.fSigned   = true;
+
+    /* According to the VRDP docs, the VRDP server stores audio in 200ms chunks. */
+    const uint32_t cfVRDPServer = DrvAudioHlpMsToFrames(&pCfgAcq->Props, 200  /* ms */);
+
+    int rc = RTCircBufCreate(&pStreamVRDE->In.pCircBuf, DrvAudioHlpFramesToBytes(&pCfgAcq->Props, cfVRDPServer));
     if (RT_SUCCESS(rc))
-    {
-        if (pCfgAcq)
-        {
-            /*
-             * Because of historical reasons the VRDP server operates on st_sample_t structures internally,
-             * which is 2 * int64_t for left/right (stereo) channels.
-             *
-             * As the audio connector also uses this format, set the layout to "raw" and just let pass through
-             * the data without any layout modification needed.
-             */
-            pCfgAcq->enmLayout        = PDMAUDIOSTREAMLAYOUT_RAW;
-            pCfgAcq->cFrameBufferHint = pStreamVRDE->In.cfMax;
-        }
-    }
-
-    return rc;
-}
-
-
-static int vrdeCreateStreamOut(PVRDESTREAM pStreamVRDE, PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
-{
-    RT_NOREF(pStreamVRDE, pCfgReq);
-
-    if (pCfgAcq)
     {
         /*
@@ -126 +107 @@
          * the data without any layout modification needed.
          */
-        pCfgAcq->enmLayout         = PDMAUDIOSTREAMLAYOUT_RAW;
-        pCfgAcq->cFrameBufferHint = _4K; /** @todo Make this configurable. */
+        pCfgAcq->enmLayout        = PDMAUDIOSTREAMLAYOUT_RAW;
+
+        pCfgAcq->Backend.cfPeriod     = cfVRDPServer;
+        pCfgAcq->Backend.cfBufferSize = pCfgAcq->Backend.cfPeriod * 2; /* Use "double buffering". */
+        pCfgAcq->Backend.cfPreBuf     = pCfgAcq->Backend.cfPeriod;
+    }
+
+    return rc;
+}
+
+
+static int vrdeCreateStreamOut(PVRDESTREAM pStreamVRDE, PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
+{
+    RT_NOREF(pStreamVRDE, pCfgReq);
+
+    if (pCfgAcq)
+    {
+        /*
+         * Because of historical reasons the VRDP server operates on st_sample_t structures internally,
+         * which is 2 * int64_t for left/right (stereo) channels.
+         *
+         * As the audio connector also uses this format, set the layout to "raw" and just let pass through
+         * the data without any layout modification needed.
+         */
+        pCfgAcq->enmLayout = PDMAUDIOSTREAMLAYOUT_RAW;
+
+        pCfgAcq->Props.uHz       = 22050; /* The VRDP server's internal frequency. */
+        pCfgAcq->Props.cChannels = 2;
+        pCfgAcq->Props.cBits     = 16;
+        pCfgAcq->Props.fSigned   = true;
+        pCfgAcq->Props.cShift    = PDMAUDIOPCMPROPS_MAKE_SHIFT_PARMS(pCfgAcq->Props.cBits, pCfgAcq->Props.cChannels);
+
+        /* According to the VRDP docs, the VRDP server stores audio in 200ms chunks. */
+        pCfgAcq->Backend.cfPeriod     = DrvAudioHlpMsToFrames(&pCfgAcq->Props, 10  /* ms */);
+        pCfgAcq->Backend.cfBufferSize = DrvAudioHlpMsToFrames(&pCfgAcq->Props, 200  /* ms */);
+        pCfgAcq->Backend.cfPreBuf     = pCfgAcq->Backend.cfBufferSize;
     }
 
@@ -158 +173 @@
         case PDMAUDIOSTREAMCMD_ENABLE:
         {
-            rc = pDrv->pConsoleVRDPServer->SendAudioInputBegin(NULL, pStreamVRDE, pStreamVRDE->In.cfMax,
+            rc = pDrv->pConsoleVRDPServer->SendAudioInputBegin(NULL, pStreamVRDE,
+                                                               DrvAudioHlpMsToFrames(&pStreamVRDE->pCfg->Props, 200 /* ms */),
                                                                pStreamVRDE->pCfg->Props.uHz, pStreamVRDE->pCfg->Props.cChannels,
                                                                pStreamVRDE->pCfg->Props.cBits);
@@ -280 +296 @@
                                                  pProps->fSigned);
 
+    const uint64_t ticksNow     = PDMDrvHlpTMGetVirtualTime(pDrv->pDrvIns);
+    const uint64_t ticksElapsed = ticksNow  - pStreamVRDE->Out.last;
+    const uint64_t ticksPerSec  = PDMDrvHlpTMGetVirtualFreq(pDrv->pDrvIns);
+
+    /* Remember when frames were consumed. */
+    pStreamVRDE->Out.last = PDMDrvHlpTMGetVirtualTime(pDrv->pDrvIns);
+
+    Log3Func(("FOOO -- %d\n", (int)((2 * ticksElapsed * pProps->uHz + ticksPerSec) / ticksPerSec / 2)));
+
     /* Use the internal counter to track if we (still) can write to the VRDP server
      * or if we need to wait another round (time slot). */
-    uint32_t cfToWrite = pStreamVRDE->Out.cfToWrite;
+    uint32_t cfToWrite = cfLive; //pStreamVRDE->Out.cfToWrite;
 
     Log3Func(("cfLive=%RU32, cfToWrite=%RU32\n", cfLive, cfToWrite));
@@ -319 +344 @@
     if (RT_SUCCESS(rc))
     {
-        /* Subtract written frames from the counter. */
-        Assert(pStreamVRDE->Out.cfToWrite >= cfWritten);
-        pStreamVRDE->Out.cfToWrite      -= cfWritten;
-
-        /* Remember when frames were consumed. */
-        pStreamVRDE->Out.ticksPlayedLast = PDMDrvHlpTMGetVirtualTime(pDrv->pDrvIns);
-
         /* Return frames instead of bytes here
          * (since we specified PDMAUDIOSTREAMLAYOUT_RAW as the audio data layout). */
@@ -394 +412 @@
 static DECLCALLBACK(PDMAUDIOBACKENDSTS) drvAudioVRDEGetStatus(PPDMIHOSTAUDIO pInterface, PDMAUDIODIR enmDir)
 {
+    PDRVAUDIOVRDE pDrv = RT_FROM_MEMBER(pInterface, DRVAUDIOVRDE, IHostAudio);
+    AssertPtrReturn(pDrv, PDMAUDIOBACKENDSTS_ERROR);
+
     RT_NOREF(enmDir);
-    AssertPtrReturn(pInterface, PDMAUDIOBACKENDSTS_UNKNOWN);
 
     return PDMAUDIOBACKENDSTS_RUNNING;
@@ -516 +536 @@
     PVRDESTREAM   pStreamVRDE = (PVRDESTREAM)pStream;
 
-    const uint64_t ticksNow     = PDMDrvHlpTMGetVirtualTime(pDrv->pDrvIns);
-    const uint64_t ticksElapsed = ticksNow  - pStreamVRDE->Out.ticksPlayedLast;
-    const uint64_t ticksPerSec  = PDMDrvHlpTMGetVirtualFreq(pDrv->pDrvIns);
-
     PPDMAUDIOPCMPROPS pProps  = &pStreamVRDE->pCfg->Props;
 
-    /* Minimize the rounding error: frames = int((ticks * freq) / ticks_per_second + 0.5). */
-    pStreamVRDE->Out.cfToWrite = (int)((2 * ticksElapsed * pProps->uHz + ticksPerSec) / ticksPerSec / 2);
+    RT_NOREF(pDrv,  pProps);
 
     /* Return frames instead of bytes here
      * (since we specified PDMAUDIOSTREAMLAYOUT_RAW as the audio data layout). */
-    return pStreamVRDE->Out.cfToWrite;
+    return _16K; // pStreamVRDE->Out.cfToWrite;
 }
 
@@ -536 +551 @@
 static DECLCALLBACK(PDMAUDIOSTREAMSTS) drvAudioVRDEStreamGetStatus(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
 {
-    RT_NOREF(pInterface, pStream);
-
-    return (PDMAUDIOSTREAMSTS_FLAG_INITIALIZED | PDMAUDIOSTREAMSTS_FLAG_ENABLED);
+    PDRVAUDIOVRDE pDrv = RT_FROM_MEMBER(pInterface, DRVAUDIOVRDE, IHostAudio);
+    RT_NOREF(pStream);
+
+    PDMAUDIOSTREAMSTS streamSts = PDMAUDIOSTREAMSTS_FLAG_INITIALIZED;
+
+    if (pDrv->cClients) /* If any clients are connected, flag the stream as enabled. */
+      streamSts |= PDMAUDIOSTREAMSTS_FLAG_ENABLED;
+
+    return streamSts;
 }
 
@@ -595 +616 @@
 
     return VINF_SUCCESS;
+}
+
+
+void AudioVRDE::onVRDEClientConnect(uint32_t uClientID)
+{
+    RT_NOREF(uClientID);
+
+    LogRel2(("Audio: VRDE client connected\n"));
+    mpDrv->cClients++;
+}
+
+
+void AudioVRDE::onVRDEClientDisconnect(uint32_t uClientID)
+{
+    RT_NOREF(uClientID);
+
+    LogRel2(("Audio: VRDE client disconnected\n"));
+    Assert(mpDrv->cClients);
+    mpDrv->cClients--;
 }
 
@@ -719 +759 @@
     /* CFGM tree saves the pointer to ConsoleVRDPServer in the Object node of AudioVRDE. */
     pThis->pConsoleVRDPServer = (ConsoleVRDPServer *)pvUser;
+    pThis->cClients = 0;
 
     /*

trunk/src/VBox/Main/src-client/DrvAudioVideoRec.cpp

@@ -498 +498 @@
         AssertFailed();
 
-        if (pCfgAcq)
-            pCfgAcq->cFrameBufferHint = 0;
-
         LogRel2(("VideoRec: Support for surround audio not implemented yet\n"));
         return VERR_NOT_SUPPORTED;
@@ -525 +522 @@
             pCfgAcq->Props.uHz         = pSink->Codec.Parms.uHz;
             pCfgAcq->Props.cShift      = PDMAUDIOPCMPROPS_MAKE_SHIFT_PARMS(pCfgAcq->Props.cBits, pCfgAcq->Props.cChannels);
-            pCfgAcq->cFrameBufferHint = _4K; /** @todo Make this configurable. */
+
+            /* Every Opus frame marks a period for now. Optimize this later. */
+            pCfgAcq->Backend.cfPeriod  = DrvAudioHlpMsToFrames(&pCfgAcq->Props, pSink->Codec.Opus.msFrame); /** @todo Make this configurable. */
         }
     }