Changeset 88819 in vbox for trunk/src/VBox

Timestamp:

May 3, 2021 10:26:28 AM (4 years ago)

Author:

vboxsync

Message:

Audio: Added geberuc asynchronous init to DrvAudio for use in WAS (and maybe others). bugref:9890

• Added optional asynchronous init via a worker thread pool in DrvAudio (pfnStreamInitAsync).
• Added interface for the backend to use the thread pool from the backend (pfnDoOnWorkerThread).
• s/PDMIAUDIONOTIFYFROMHOST/PDMIHOSTAUDIOPORT/g
• New BACKEND_READY state flag (a bit confusing wrt to INITIALIZED, but whatever).
• Don't RESUME streams which aren't actually paused (on VM resume).
• Restore the backend state correctly when the per-direction enable flag is changed in DrvAudio. Would enable the streams regardless of actual state.
• Move more PDMAUDIOSTREAM members from the public structure and into the DRVAUDIOSTREAM.
• ++

Location:

trunk/src/VBox

Files:

• Devices/Audio/DrvAudio.cpp (modified) (98 diffs)
• Devices/Audio/DrvHostAudioAlsa.cpp (modified) (1 diff)
• Devices/Audio/DrvHostAudioCoreAudio.cpp (modified) (1 diff)
• Devices/Audio/DrvHostAudioDSound.cpp (modified) (2 diffs)
• Devices/Audio/DrvHostAudioDSoundMMNotifClient.cpp (modified) (1 diff)
• Devices/Audio/DrvHostAudioDSoundMMNotifClient.h (modified) (2 diffs)
• Devices/Audio/DrvHostAudioDebug.cpp (modified) (1 diff)
• Devices/Audio/DrvHostAudioNull.cpp (modified) (1 diff)
• Devices/Audio/DrvHostAudioOss.cpp (modified) (1 diff)
• Devices/Audio/DrvHostAudioPulseAudio.cpp (modified) (1 diff)
• Devices/Audio/DrvHostAudioValidationKit.cpp (modified) (1 diff)
• Devices/Audio/DrvHostAudioWasApi.cpp (modified) (39 diffs)
• Main/src-client/DrvAudioRec.cpp (modified) (1 diff)
• Main/src-client/DrvAudioVRDE.cpp (modified) (1 diff)

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

@@ -33 +33 @@
 #include <iprt/assert.h>
 #include <iprt/circbuf.h>
+#include <iprt/req.h>
 #include <iprt/string.h>
+#include <iprt/thread.h>
 #include <iprt/uuid.h>
 
@@ -99 +101 @@
 {
     /** The publicly visible bit. */
-    PDMAUDIOSTREAM      Core;
+    PDMAUDIOSTREAM          Core;
 
     /** Just an extra magic to verify that we allocated the stream rather than some
      * faked up stuff from the device (DRVAUDIOSTREAM_MAGIC). */
-    uintptr_t           uMagic;
+    uintptr_t               uMagic;
 
     /** List entry in DRVAUDIO::lstStreams. */
-    RTLISTNODE          ListEntry;
+    RTLISTNODE              ListEntry;
+
+    /** Number of references to this stream.
+     *  Only can be destroyed when the reference count reaches 0. */
+    uint32_t volatile       cRefs;
+    /** Stream status - PDMAUDIOSTREAM_STS_XXX. */
+    uint32_t                fStatus;
 
     /** Data to backend-specific stream data.
@@ -112 +120 @@
      *
      *  That way the backends do not have access to the audio connector's data. */
-    PPDMAUDIOBACKENDSTREAM pBackend;
+    PPDMAUDIOBACKENDSTREAM  pBackend;
 
     /** Do not use the mixing buffers (Guest::MixBuf, Host::MixBuf). */
-    bool                fNoMixBufs;
-    bool                afPadding[3];
+    bool                    fNoMixBufs;
+    /** Set if pfnStreamCreate returned VINF_AUDIO_STREAM_ASYNC_INIT_NEEDED. */
+    bool                    fNeedAsyncInit;
+    bool                    afPadding[2];
 
     /** Number of (re-)tries while re-initializing the stream. */
-    uint32_t            cTriesReInit;
+    uint32_t                cTriesReInit;
 
     /** The backend status at the last play or capture call.
      * This is used to detect state changes.  */
-    uint32_t            fLastBackendStatus;
+    uint32_t                fLastBackendStatus;
+
+    /** The pfnStreamInitAsync request handle. */
+    PRTREQ                  hReqInitAsync;
 
     /** The guest side of the stream. */
-    DRVAUDIOSTREAMCTX   Guest;
+    DRVAUDIOSTREAMCTX       Guest;
     /** The host side of the stream. */
-    DRVAUDIOSTREAMCTX   Host;
+    DRVAUDIOSTREAMCTX       Host;
 
 
     /** Timestamp (in ns) since last trying to re-initialize.
      *  Might be 0 if has not been tried yet. */
-    uint64_t            nsLastReInit;
+    uint64_t                nsLastReInit;
     /** Timestamp (in ns) since last iteration. */
-    uint64_t            nsLastIterated;
+    uint64_t                nsLastIterated;
     /** Timestamp (in ns) since last playback / capture. */
-    uint64_t            nsLastPlayedCaptured;
+    uint64_t                nsLastPlayedCaptured;
     /** Timestamp (in ns) since last read (input streams) or
      *  write (output streams). */
-    uint64_t            nsLastReadWritten;
+    uint64_t                nsLastReadWritten;
     /** Internal stream position (as per pfnStreamWrite/Read). */
-    uint64_t            offInternal;
-
+    uint64_t                offInternal;
 
     /** Union for input/output specifics depending on enmDir. */
@@ -275 +287 @@
     PDMIAUDIOCONNECTOR      IAudioConnector;
     /** Interface used by the host backend. */
-    PDMIAUDIONOTIFYFROMHOST IAudioNotifyFromHost;
+    PDMIHOSTAUDIOPORT       IHostAudioPort;
     /** Pointer to the driver instance. */
     PPDMDRVINS              pDrvIns;
@@ -309 +321 @@
     } Out;
 
+    /** Request pool if the backend needs it for async stream creation. */
+    RTREQPOOL               hReqPool;
+
     /** Handle to the disable-iteration timer. */
     TMTIMERHANDLE           hTimer;
@@ -338 +353 @@
 static int drvAudioStreamControlInternal(PDRVAUDIO pThis, PDRVAUDIOSTREAM pStreamEx, PDMAUDIOSTREAMCMD enmStreamCmd);
 static int drvAudioStreamUninitInternal(PDRVAUDIO pThis, PDRVAUDIOSTREAM pStreamEx);
+static uint32_t drvAudioStreamReleaseInternal(PDRVAUDIO pThis, PDRVAUDIOSTREAM pStreamEx, bool fMayDestroy);
 static int drvAudioStreamIterateInternal(PDRVAUDIO pThis, PDRVAUDIOSTREAM pStreamEx);
 
-
-#ifdef LOG_ENABLED
-
 /** Buffer size for dbgAudioStreamStatusToStr.  */
-# define DRVAUDIO_STATUS_STR_MAX sizeof("INITIALIZED ENABLED PAUSED PENDING_DISABLED NEED_REINIT PREPARING_SWITCH 0x12345678")
+# define DRVAUDIO_STATUS_STR_MAX sizeof("INITIALIZED ENABLED PAUSED PENDING_DISABLED NEED_REINIT BACKEND_READY PREPARING_SWITCH 0x12345678")
 
 /**
@@ -368 +381 @@
         { RT_STR_TUPLE("PENDING_DISABLE "),  PDMAUDIOSTREAM_STS_PENDING_DISABLE  },
         { RT_STR_TUPLE("NEED_REINIT "),      PDMAUDIOSTREAM_STS_NEED_REINIT      },
+        { RT_STR_TUPLE("BACKEND_READY "),    PDMAUDIOSTREAM_STS_BACKEND_READY    },
         { RT_STR_TUPLE("PREPARING_SWITCH "), PDMAUDIOSTREAM_STS_PREPARING_SWITCH },
     };
@@ -393 +407 @@
 }
 
-#endif /* defined(LOG_ENABLED) */
 
 /**
@@ -426 +439 @@
 DECLINLINE(uint32_t) drvAudioStreamGetBackendStatus(PDRVAUDIO pThis, PDRVAUDIOSTREAM pStreamEx)
 {
-    Assert(pThis->pHostDrvAudio);
-    uint32_t fBackendStatus = pThis->pHostDrvAudio->pfnStreamGetStatus(pThis->pHostDrvAudio, pStreamEx->pBackend);
+    uint32_t fBackendStatus = pThis->pHostDrvAudio
+                            ? pThis->pHostDrvAudio->pfnStreamGetStatus(pThis->pHostDrvAudio, pStreamEx->pBackend)
+                            : 0;
     PDMAUDIOSTREAM_STS_ASSERT_VALID_BACKEND(fBackendStatus);
     return fBackendStatus;
@@ -518 +532 @@
     PDRVAUDIO pThis = RT_FROM_MEMBER(pInterface, DRVAUDIO, IAudioConnector);
     AssertPtr(pThis);
-
+    LogFlowFunc(("enmDir=%s fEnable=%d\n", PDMAudioDirGetName(enmDir), fEnable));
+
+    /*
+     * Figure which status flag variable is being updated.
+     */
     bool *pfEnabled;
     if (enmDir == PDMAUDIODIR_IN)
@@ -527 +545 @@
         AssertFailedReturn(VERR_INVALID_PARAMETER);
 
+    /*
+     * Grab the driver wide lock and check it.  Ignore call if no change.
+     */
     int rc = RTCritSectEnter(&pThis->CritSect);
     AssertRCReturn(rc, rc);
@@ -535 +556 @@
                 fEnable ? "Enabling" : "Disabling", enmDir == PDMAUDIODIR_IN ? "input" : "output", pThis->szName));
 
-        /* Update the status first, as this will be checked for in drvAudioStreamControlInternalBackend() below. */
-        *pfEnabled = fEnable;
-
+        /*
+         * When enabling, we must update flag before calling drvAudioStreamControlInternalBackend.
+         */
+        if (fEnable)
+            *pfEnabled = true;
+
+        /*
+         * Update the backend status for the streams in the given direction.
+         *
+         * The pThis->Out.fEnable / pThis->In.fEnable status flags only reflect in the
+         * direction of the backend, drivers and devices above us in the chain does not
+         * know about this.  When disabled playback goes to /dev/null and we capture
+         * only silence.  This means pStreamEx->fStatus holds the nominal status
+         * and we'll use it to restore the operation.  (See also @bugref{9882}.)
+         */
         PDRVAUDIOSTREAM pStreamEx;
         RTListForEach(&pThis->lstStreams, pStreamEx, DRVAUDIOSTREAM, ListEntry)
         {
-            if (pStreamEx->Core.enmDir != enmDir) /* Skip unwanted streams. */
-                continue;
-
-            /* Note: Only enable / disable the backend, do *not* change the stream's internal status.
-             *       Callers (device emulation, mixer, ...) from outside will not see any status or behavior change,
-             *       to not confuse the rest of the state machine.
-             *
-             *       When disabling:
-             *          - playing back audo data would go to /dev/null
-             *          - recording audio data would return silence instead
-             *
-             * See @bugref{9882}.
-             */
-            int rc2 = drvAudioStreamControlInternalBackend(pThis, pStreamEx,
-                                                           fEnable ? PDMAUDIOSTREAMCMD_ENABLE : PDMAUDIOSTREAMCMD_DISABLE);
-            if (RT_FAILURE(rc2))
+            if (pStreamEx->Core.enmDir == enmDir)
             {
-                if (rc2 == VERR_AUDIO_STREAM_NOT_READY)
-                    LogRel(("Audio: Stream '%s' not available\n", pStreamEx->Core.szName));
-                else
-                    LogRel(("Audio: Failed to %s %s stream '%s', rc=%Rrc\n", fEnable ? "enable" : "disable",
-                            enmDir == PDMAUDIODIR_IN ? "input" : "output", pStreamEx->Core.szName, rc2));
-            }
-            else
-            {
-                /* When (re-)enabling a stream, clear the disabled warning bit again. */
+                /*
+                 * When (re-)enabling a stream, clear the disabled warning bit again.
+                 */
                 if (fEnable)
                     pStreamEx->Core.fWarningsShown &= ~PDMAUDIOSTREAM_WARN_FLAGS_DISABLED;
+
+                /*
+                 * We don't need to do anything unless the stream is enabled.
+                 * Paused includes enabled, as does draining, but we only want the former.
+                 */
+                uint32_t const fStatus = pStreamEx->fStatus;
+                if (fStatus & PDMAUDIOSTREAM_STS_ENABLED)
+                {
+                    const char *pszOperation;
+                    int         rc2;
+                    if (fEnable)
+                    {
+                        if (!(fStatus & PDMAUDIOSTREAM_STS_PENDING_DISABLE))
+                        {
+                            rc2 = drvAudioStreamControlInternalBackend(pThis, pStreamEx, PDMAUDIOSTREAMCMD_ENABLE);
+                            pszOperation = "enable";
+                            if (RT_SUCCESS(rc2) && (fStatus & PDMAUDIOSTREAM_STS_PAUSED))
+                            {
+                                rc2 = drvAudioStreamControlInternalBackend(pThis, pStreamEx, PDMAUDIOSTREAMCMD_PAUSE);
+                                pszOperation = "pause";
+                            }
+                        }
+                        else
+                        {
+                            rc2 = VINF_SUCCESS;
+                            pszOperation = NULL;
+                        }
+                    }
+                    else
+                    {
+                        rc2 = drvAudioStreamControlInternalBackend(pThis, pStreamEx, PDMAUDIOSTREAMCMD_DISABLE);
+                        pszOperation = "disable";
+                    }
+                    if (RT_FAILURE(rc2))
+                    {
+                        LogRel(("Audio: Failed to %s %s stream '%s': %Rrc\n",
+                                pszOperation, enmDir == PDMAUDIODIR_IN ? "input" : "output", pStreamEx->Core.szName, rc2));
+                        if (RT_SUCCESS(rc))
+                            rc = rc2;  /** @todo r=bird: This isn't entirely helpful to the caller since we'll update the status
+                                        * regardless of the status code we return.  And anyway, there is nothing that can be done
+                                        * about individual stream by the caller... */
+                    }
+                }
             }
-
-            if (RT_SUCCESS(rc))
-                rc = rc2;
-
-            /* Keep going. */
-        }
+        }
+
+        /*
+         * When disabling, we must update the status flag after the
+         * drvAudioStreamControlInternalBackend(DISABLE) calls.
+         */
+        *pfEnabled = fEnable;
     }
 
@@ -840 +896 @@
  * @interface_method_impl{PDMIAUDIOCONNECTOR,pfnStreamConfigHint}
  */
+static DECLCALLBACK(void) drvAudioStreamConfigHintWorker(PPDMIHOSTAUDIO pHostDrvAudio, PPDMAUDIOSTREAMCFG pCfg)
+{
+    LogFlowFunc(("pHostDrvAudio=%p pCfg=%p\n", pHostDrvAudio, pCfg));
+    AssertPtrReturnVoid(pCfg);
+    AssertPtrReturnVoid(pHostDrvAudio);
+    AssertPtrReturnVoid(pHostDrvAudio->pfnStreamConfigHint);
+
+    pHostDrvAudio->pfnStreamConfigHint(pHostDrvAudio, pCfg);
+    PDMAudioStrmCfgFree(pCfg);
+    LogFlowFunc(("returns\n"));
+}
+
+
+/**
+ * @interface_method_impl{PDMIAUDIOCONNECTOR,pfnStreamConfigHint}
+ */
 static DECLCALLBACK(void) drvAudioStreamConfigHint(PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOSTREAMCFG pCfg)
 {
@@ -863 +935 @@
             AssertLogRelRC(rc);
             if (RT_SUCCESS(rc))
-                pThis->pHostDrvAudio->pfnStreamConfigHint(pThis->pHostDrvAudio, pCfg);
+            {
+                rc = VERR_CALLBACK_RETURN;
+                if (pThis->BackendCfg.fFlags & PDMAUDIOBACKEND_F_ASYNC_HINT)
+                {
+                    PPDMAUDIOSTREAMCFG pDupCfg = PDMAudioStrmCfgDup(pCfg);
+                    if (pDupCfg)
+                    {
+                        rc = RTReqPoolCallVoidNoWait(pThis->hReqPool, (PFNRT)drvAudioStreamConfigHintWorker,
+                                                     2, pThis->pHostDrvAudio, pDupCfg);
+                        if (RT_SUCCESS(rc))
+                            LogFlowFunc(("Asynchronous call running on worker thread.\n"));
+                        else
+                            PDMAudioStrmCfgFree(pDupCfg);
+                    }
+                }
+                if (RT_FAILURE_NP(rc))
+                {
+                    LogFlowFunc(("Doing synchronous call...\n"));
+                    pThis->pHostDrvAudio->pfnStreamConfigHint(pThis->pHostDrvAudio, pCfg);
+                }
+            }
         }
         else
@@ -872 +964 @@
 
     RTCritSectLeave(&pThis->CritSect);
+}
+
+
+/**
+ * For performing PDMIHOSTAUDIO::pfnStreamInitAsync on a worker thread.
+ *
+ * @param   pThis       Pointer to the DrvAudio instance data.
+ * @param   pStreamEx   The stream.  One reference for us to release.
+ */
+static DECLCALLBACK(void) drvAudioStreamInitAsync(PDRVAUDIO pThis, PDRVAUDIOSTREAM pStreamEx)
+{
+    LogFlow(("pThis=%p pStreamEx=%p (%s)\n", pThis, pStreamEx->Core.szName));
+
+    /*
+     * Do the init job.
+     *
+     * This critsect entering and leaving here isn't really necessary,
+     * but well, I'm a bit paranoid, so sue me.
+     */
+    RTCritSectEnter(&pThis->CritSect);
+    PPDMIHOSTAUDIO pIHostDrvAudio = pThis->pHostDrvAudio;
+    RTCritSectLeave(&pThis->CritSect);
+    AssertPtr(pIHostDrvAudio);
+    int rc;
+    bool fDestroyed;
+    if (pIHostDrvAudio && pIHostDrvAudio->pfnStreamInitAsync)
+    {
+        fDestroyed = pStreamEx->cRefs <= 1;
+        rc = pIHostDrvAudio->pfnStreamInitAsync(pIHostDrvAudio, pStreamEx->pBackend, fDestroyed);
+        LogFlow(("pfnStreamInitAsync returns %Rrc (on %p, fDestroyed=%d)\n", rc, pStreamEx, fDestroyed));
+    }
+    else
+    {
+        fDestroyed = true;
+        rc = VERR_AUDIO_STREAM_COULD_NOT_CREATE;
+    }
+
+    /*
+     * On success, update the backend on the stream status and mark it ready for business.
+     */
+    RTCritSectEnter(&pThis->CritSect);
+    if (RT_SUCCESS(rc) && !fDestroyed)
+    {
+
+        /*
+         * Update the backend state.
+         */
+        pStreamEx->fStatus |= PDMAUDIOSTREAM_STS_BACKEND_READY; /* before the backend control call! */
+
+        if (pStreamEx->fStatus & PDMAUDIOSTREAM_STS_ENABLED)
+        {
+            rc = drvAudioStreamControlInternalBackend(pThis, pStreamEx, PDMAUDIOSTREAMCMD_ENABLE);
+            if (RT_SUCCESS(rc))
+            {
+                if (pStreamEx->fStatus & PDMAUDIOSTREAM_STS_PAUSED)
+                {
+                    rc = drvAudioStreamControlInternalBackend(pThis, pStreamEx, PDMAUDIOSTREAMCMD_PAUSE);
+                    if (RT_FAILURE(rc))
+                        LogRelMax(64, ("Audio: Failed to pause stream '%s' after initialization completed: %Rrc\n",
+                                       pStreamEx->Core.szName, rc));
+                }
+            }
+            else
+                LogRelMax(64, ("Audio: Failed to enable stream '%s' after initialization completed: %Rrc\n",
+                               pStreamEx->Core.szName, rc));
+        }
+
+        /*
+         * Modify the play state if output stream.
+         */
+        if (pStreamEx->Core.enmDir == PDMAUDIODIR_OUT)
+        {
+            DRVAUDIOPLAYSTATE const enmPlayState = pStreamEx->Out.enmPlayState;
+            switch (enmPlayState)
+            {
+                case DRVAUDIOPLAYSTATE_PREBUF:
+                case DRVAUDIOPLAYSTATE_PREBUF_SWITCHING:
+                    break;
+                case DRVAUDIOPLAYSTATE_PREBUF_OVERDUE:
+                    pStreamEx->Out.enmPlayState = DRVAUDIOPLAYSTATE_PREBUF_COMMITTING;
+                    break;
+                case DRVAUDIOPLAYSTATE_NOPLAY:
+                    pStreamEx->Out.enmPlayState = DRVAUDIOPLAYSTATE_PREBUF;
+                    break;
+                case DRVAUDIOPLAYSTATE_PLAY:
+                case DRVAUDIOPLAYSTATE_PLAY_PREBUF:
+                case DRVAUDIOPLAYSTATE_PREBUF_COMMITTING:
+                    AssertFailedBreak();
+                /* no default */
+                case DRVAUDIOPLAYSTATE_END:
+                case DRVAUDIOPLAYSTATE_INVALID:
+                    break;
+            }
+            LogFunc(("enmPlayState: %s -> %s\n", drvAudioPlayStateName(enmPlayState),
+                     drvAudioPlayStateName(pStreamEx->Out.enmPlayState) ));
+        }
+
+        /*
+         * Tweak the last backend status to asserting in
+         * drvAudioStreamPlayProcessBackendStateChange().
+         */
+        pStreamEx->fLastBackendStatus |=   drvAudioStreamGetBackendStatus(pThis, pStreamEx)
+                                         & PDMAUDIOSTREAM_STS_INITIALIZED;
+    }
+    /*
+     * Don't quite know what to do on failure...
+     */
+    else if (!fDestroyed)
+    {
+        LogRelMax(64, ("Audio: Failed to initialize stream '%s': %Rrc\n", pStreamEx->Core.szName, rc));
+    }
+
+    /*
+     * Release the request handle, must be done while inside the critical section.
+     */
+    if (pStreamEx->hReqInitAsync != NIL_RTREQ)
+    {
+        LogFlowFunc(("Releasing hReqInitAsync=%p\n", pStreamEx->hReqInitAsync));
+        RTReqRelease(pStreamEx->hReqInitAsync);
+        pStreamEx->hReqInitAsync = NIL_RTREQ;
+    }
+
+    RTCritSectLeave(&pThis->CritSect);
+
+    /*
+     * Release our stream reference.
+     */
+    uint32_t cRefs = drvAudioStreamReleaseInternal(pThis, pStreamEx, true /*fMayDestroy*/);
+    LogFlowFunc(("returns (fDestroyed=%d, cRefs=%u)\n", fDestroyed, cRefs)); RT_NOREF(cRefs);
 }
 
@@ -896 +1117 @@
                                                PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
 {
-    AssertMsg((pStreamEx->Core.fStatus & PDMAUDIOSTREAM_STS_INITIALIZED) == 0,
+    AssertMsg((pStreamEx->fStatus & PDMAUDIOSTREAM_STS_INITIALIZED) == 0,
               ("Stream '%s' already initialized in backend\n", pStreamEx->Core.szName));
 
@@ -922 +1143 @@
      * Call the host driver to create the stream.
      */
-    AssertPtr(pThis->pHostDrvAudio);
-    if (pThis->pHostDrvAudio)
-        rc = pThis->pHostDrvAudio->pfnStreamCreate(pThis->pHostDrvAudio, pStreamEx->pBackend, pCfgReq, pCfgAcq);
+    AssertLogRelMsgReturn(RT_VALID_PTR(pThis->pHostDrvAudio), ("Audio: %p\n", pThis->pHostDrvAudio), VERR_PDM_NO_ATTACHED_DRIVER);
+    rc = pThis->pHostDrvAudio->pfnStreamCreate(pThis->pHostDrvAudio, pStreamEx->pBackend, pCfgReq, pCfgAcq);
+    if (RT_SUCCESS(rc))
+    {
+        AssertLogRelReturn(pStreamEx->pBackend->uMagic  == PDMAUDIOBACKENDSTREAM_MAGIC, VERR_INTERNAL_ERROR_3);
+        AssertLogRelReturn(pStreamEx->pBackend->pStream == &pStreamEx->Core, VERR_INTERNAL_ERROR_3);
+
+        /* Must set the backend-initialized flag now or the backend won't be
+           destroyed (this used to be done at the end of this function, with
+           several possible early return paths before it). */
+        pStreamEx->fStatus |= PDMAUDIOSTREAM_STS_INITIALIZED;
+
+        pStreamEx->fLastBackendStatus = drvAudioStreamGetBackendStatus(pThis, pStreamEx);
+        PDMAUDIOSTREAM_STS_ASSERT_VALID(pStreamEx->fStatus);
+    }
     else
-        rc = VERR_PDM_NO_ATTACHED_DRIVER;
-    if (RT_FAILURE(rc))
     {
         if (rc == VERR_NOT_SUPPORTED)
@@ -937 +1168 @@
         return rc;
     }
-    AssertLogRelReturn(pStreamEx->pBackend->uMagic  == PDMAUDIOBACKENDSTREAM_MAGIC, VERR_INTERNAL_ERROR_3);
-    AssertLogRelReturn(pStreamEx->pBackend->pStream == &pStreamEx->Core, VERR_INTERNAL_ERROR_3);
+
+    /* Remember if we need to call pfnStreamInitAsync. */
+    pStreamEx->fNeedAsyncInit = rc == VINF_AUDIO_STREAM_ASYNC_INIT_NEEDED;
+    AssertStmt(rc != VINF_AUDIO_STREAM_ASYNC_INIT_NEEDED || pThis->pHostDrvAudio->pfnStreamInitAsync != NULL,
+               pStreamEx->fNeedAsyncInit = false);
+    Assert(rc != VINF_AUDIO_STREAM_ASYNC_INIT_NEEDED || !(pStreamEx->fLastBackendStatus & PDMAUDIOSTREAM_STS_INITIALIZED));
 
     /* Validate acquired configuration. */
@@ -983 +1218 @@
                     ("Acquired pre-buffering size must be smaller or as big as the buffer size\n"),
                     VERR_INVALID_PARAMETER);
-
-    pStreamEx->fLastBackendStatus = drvAudioStreamGetBackendStatus(pThis, pStreamEx);
-    pStreamEx->Core.fStatus      |= PDMAUDIOSTREAM_STS_INITIALIZED;
-    PDMAUDIOSTREAM_STS_ASSERT_VALID(pStreamEx->Core.fStatus);
 
     return VINF_SUCCESS;
@@ -1295 +1526 @@
         if (pStreamEx)
         {
-            /* Retrieve host driver name for easier identification. */
+            /* Make a unqiue stream name including the host (backend) driver name. */
             AssertPtr(pThis->pHostDrvAudio);
-            RTStrPrintf(pStreamEx->Core.szName, RT_ELEMENTS(pStreamEx->Core.szName), "[%s] %s",
-                        pThis->BackendCfg.szName, pCfgHost->szName[0] != '\0' ? pCfgHost->szName : "<Untitled>");
+            size_t cchName = RTStrPrintf(pStreamEx->Core.szName, RT_ELEMENTS(pStreamEx->Core.szName), "[%s] %s:0",
+                                         pThis->BackendCfg.szName, pCfgHost->szName[0] != '\0' ? pCfgHost->szName : "<Untitled>");
+            if (cchName < sizeof(pStreamEx->Core.szName))
+            {
+                for (uint32_t i = 0; i < 256; i++)
+                {
+                    bool fDone = true;
+                    PDRVAUDIOSTREAM pIt;
+                    RTListForEach(&pThis->lstStreams, pIt, DRVAUDIOSTREAM, ListEntry)
+                    {
+                        if (strcmp(pIt->Core.szName, pStreamEx->Core.szName) == 0)
+                        {
+                            RTStrPrintf(pStreamEx->Core.szName, RT_ELEMENTS(pStreamEx->Core.szName), "[%s] %s:%u",
+                                        pThis->BackendCfg.szName, pCfgHost->szName[0] != '\0' ? pCfgHost->szName : "<Untitled>",
+                                        i);
+                            fDone = false;
+                            break;
+                        }
+                    }
+                    if (fDone)
+                        break;
+                }
+            }
 
             PPDMAUDIOBACKENDSTREAM pBackend = (PPDMAUDIOBACKENDSTREAM)(pStreamEx + 1);
@@ -1307 +1559 @@
             pStreamEx->Core.cbBackend   = (uint32_t)cbHstStrm;
             pStreamEx->fNoMixBufs       = RT_BOOL(fFlags & PDMAUDIOSTREAM_CREATE_F_NO_MIXBUF);
+            pStreamEx->hReqInitAsync    = NIL_RTREQ;
             pStreamEx->uMagic           = DRVAUDIOSTREAM_MAGIC;
 
@@ -1316 +1569 @@
             {
                 /* Set initial reference counts. */
-                pStreamEx->Core.cRefs = 1;
+                pStreamEx->cRefs = pStreamEx->fNeedAsyncInit ? 2 : 1;
 
                 /* Decrement the free stream counter. */
@@ -1352 +1605 @@
                     }
                 }
+
+                /*
+                 * Kick off the asynchronous init.
+                 */
+                if (!pStreamEx->fNeedAsyncInit)
+                {
+                    pStreamEx->fStatus |= PDMAUDIOSTREAM_STS_BACKEND_READY;
+                    PDMAUDIOSTREAM_STS_ASSERT_VALID(pStreamEx->fStatus);
+                }
+                else
+                {
+                    int rc2 = RTReqPoolCallEx(pThis->hReqPool, 0 /*cMillies*/, &pStreamEx->hReqInitAsync,
+                                              RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
+                                              (PFNRT)drvAudioStreamInitAsync, 2, pThis, pStreamEx);
+                    LogFlowFunc(("hReqInitAsync=%p rc2=%Rrc\n", pStreamEx->hReqInitAsync, rc2));
+                    AssertRCStmt(rc2, drvAudioStreamInitAsync(pThis, pStreamEx));
+                }
             }
             else
@@ -1391 +1661 @@
     char szStreamSts[DRVAUDIO_STATUS_STR_MAX];
 #endif
-    LogFunc(("[%s] fStatus=%s\n", pStreamEx->Core.szName, dbgAudioStreamStatusToStr(szStreamSts, pStreamEx->Core.fStatus)));
-
-    if (pStreamEx->Core.fStatus & PDMAUDIOSTREAM_STS_INITIALIZED)
+    LogFunc(("[%s] fStatus=%s\n", pStreamEx->Core.szName, dbgAudioStreamStatusToStr(szStreamSts, pStreamEx->fStatus)));
+
+    if (pStreamEx->fStatus & PDMAUDIOSTREAM_STS_INITIALIZED)
     {
         AssertPtr(pStreamEx->pBackend);
@@ -1402 +1672 @@
             rc = pThis->pHostDrvAudio->pfnStreamDestroy(pThis->pHostDrvAudio, pStreamEx->pBackend);
 
-        pStreamEx->Core.fStatus &= ~PDMAUDIOSTREAM_STS_INITIALIZED;
-        PDMAUDIOSTREAM_STS_ASSERT_VALID(pStreamEx->Core.fStatus);
+        pStreamEx->fStatus &= ~(PDMAUDIOSTREAM_STS_INITIALIZED | PDMAUDIOSTREAM_STS_BACKEND_READY);
+        PDMAUDIOSTREAM_STS_ASSERT_VALID(pStreamEx->fStatus);
     }
 
@@ -1424 +1694 @@
 {
     AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
-    AssertMsgReturn(pStreamEx->Core.cRefs <= 1,
-                    ("Stream '%s' still has %RU32 references held when uninitializing\n", pStreamEx->Core.szName, pStreamEx->Core.cRefs),
+    AssertMsgReturn(pStreamEx->cRefs <= 1,
+                    ("Stream '%s' still has %RU32 references held when uninitializing\n", pStreamEx->Core.szName, pStreamEx->cRefs),
                     VERR_WRONG_ORDER);
-    LogFlowFunc(("[%s] cRefs=%RU32\n", pStreamEx->Core.szName, pStreamEx->Core.cRefs));
+    LogFlowFunc(("[%s] cRefs=%RU32\n", pStreamEx->Core.szName, pStreamEx->cRefs));
 
     /*
@@ -1454 +1724 @@
     {
 #ifdef LOG_ENABLED
-        if (pStreamEx->Core.fStatus != PDMAUDIOSTREAM_STS_NONE)
+        if (pStreamEx->fStatus != PDMAUDIOSTREAM_STS_NONE)
         {
             char szStreamSts[DRVAUDIO_STATUS_STR_MAX];
             LogFunc(("[%s] Warning: Still has %s set when uninitializing\n",
-                     pStreamEx->Core.szName, dbgAudioStreamStatusToStr(szStreamSts, pStreamEx->Core.fStatus)));
+                     pStreamEx->Core.szName, dbgAudioStreamStatusToStr(szStreamSts, pStreamEx->fStatus)));
         }
 #endif
-        pStreamEx->Core.fStatus = PDMAUDIOSTREAM_STS_NONE;
+        pStreamEx->fStatus = PDMAUDIOSTREAM_STS_NONE;
     }
 
@@ -1496 +1766 @@
 
 /**
- * @interface_method_impl{PDMIAUDIOCONNECTOR,pfnStreamDestroy}
- */
-static DECLCALLBACK(int) drvAudioStreamDestroy(PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOSTREAM pStream)
-{
-    PDRVAUDIO pThis = RT_FROM_MEMBER(pInterface, DRVAUDIO, IAudioConnector);
-    AssertPtr(pThis);
-
-    if (!pStream)
-        return VINF_SUCCESS;
-    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
-    PDRVAUDIOSTREAM pStreamEx = (PDRVAUDIOSTREAM)pStream;   /* Note! Do not touch pStream after this! */
-    Assert(pStreamEx->Core.uMagic == PDMAUDIOSTREAM_MAGIC);
-    Assert(pStreamEx->uMagic == DRVAUDIOSTREAM_MAGIC);
-    Assert(pStreamEx->pBackend && pStreamEx->pBackend->uMagic == PDMAUDIOBACKENDSTREAM_MAGIC);
-
-    int rc = RTCritSectEnter(&pThis->CritSect);
-    AssertRCReturn(rc, rc);
-
-    LogRel2(("Audio: Destroying stream '%s'\n", pStreamEx->Core.szName));
-
-    LogFlowFunc(("[%s] cRefs=%RU32\n", pStreamEx->Core.szName, pStreamEx->Core.cRefs));
-    AssertMsg(pStreamEx->Core.cRefs <= 1, ("%u %s\n", pStreamEx->Core.cRefs, pStreamEx->Core.szName));
-    if (pStreamEx->Core.cRefs <= 1)
-    {
+ * Internal release function.
+ *
+ * @returns New reference count, UINT32_MAX if bad stream.
+ * @param   pThis           Pointer to the DrvAudio instance data.
+ * @param   pStreamEx       The stream to reference.
+ * @param   fMayDestroy     Whether the caller is allowed to implicitly destroy
+ *                          the stream or not.
+ */
+static uint32_t drvAudioStreamReleaseInternal(PDRVAUDIO pThis, PDRVAUDIOSTREAM pStreamEx, bool fMayDestroy)
+{
+    AssertPtrReturn(pStreamEx, UINT32_MAX);
+    AssertReturn(pStreamEx->Core.uMagic == PDMAUDIOSTREAM_MAGIC, UINT32_MAX);
+    AssertReturn(pStreamEx->uMagic == DRVAUDIOSTREAM_MAGIC, UINT32_MAX);
+
+    uint32_t cRefs = ASMAtomicDecU32(&pStreamEx->cRefs);
+    if (cRefs != 0)
+        Assert(cRefs < _1K);
+    else if (fMayDestroy)
+    {
+/** @todo r=bird: Caching one stream in each direction for some time,
+ * depending on the time it took to create it.  drvAudioStreamCreate can use it
+ * if the configuration matches, otherwise it'll throw it away.  This will
+ * provide a general speedup independ of device (HDA used to do this, but
+ * doesn't) and backend implementation.  Ofc, the backend probably needs an
+ * opt-out here. */
+        int rc = RTCritSectEnter(&pThis->CritSect);
+        AssertRC(rc);
+
         rc = drvAudioStreamUninitInternal(pThis, pStreamEx);
         if (RT_SUCCESS(rc))
@@ -1531 +1805 @@
 
             drvAudioStreamFree(pStreamEx);
-            pStreamEx = NULL;
-            pStream = NULL;
         }
         else
+        {
             LogRel(("Audio: Uninitializing stream '%s' failed with %Rrc\n", pStreamEx->Core.szName, rc));
+            /** @todo r=bird: What's the plan now? */
+        }
+
+        RTCritSectLeave(&pThis->CritSect);
     }
     else
-        rc = VERR_WRONG_ORDER;
+    {
+        cRefs = ASMAtomicIncU32(&pStreamEx->cRefs);
+        AssertFailed();
+    }
+
+    Log12Func(("returns %u (%s)\n", cRefs, cRefs > 0 ? pStreamEx->Core.szName : "destroyed"));
+    return cRefs;
+}
+
+
+/**
+ * @interface_method_impl{PDMIAUDIOCONNECTOR,pfnStreamDestroy}
+ */
+static DECLCALLBACK(int) drvAudioStreamDestroy(PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOSTREAM pStream)
+{
+    PDRVAUDIO pThis = RT_FROM_MEMBER(pInterface, DRVAUDIO, IAudioConnector);
+    AssertPtr(pThis);
+
+    /* Ignore NULL streams. */
+    if (!pStream)
+        return VINF_SUCCESS;
+
+    PDRVAUDIOSTREAM pStreamEx = (PDRVAUDIOSTREAM)pStream;   /* Note! Do not touch pStream after this! */
+    AssertPtrReturn(pStreamEx, VERR_INVALID_POINTER);
+    LogFlowFunc(("ENTER - %p %s\n", pStreamEx, pStreamEx->Core.szName));
+    AssertReturn(pStreamEx->Core.uMagic == PDMAUDIOSTREAM_MAGIC, VERR_INVALID_MAGIC);
+    AssertReturn(pStreamEx->uMagic == DRVAUDIOSTREAM_MAGIC, VERR_INVALID_MAGIC);
+    AssertReturn(pStreamEx->pBackend && pStreamEx->pBackend->uMagic == PDMAUDIOBACKENDSTREAM_MAGIC, VERR_INVALID_MAGIC);
+
+    /*
+     * The main difference from a regular release is that this will disable
+     * (or drain if we could) the stream and we can cancel any pending
+     * pfnStreamInitAsync call.
+     */
+    int rc = RTCritSectEnter(&pThis->CritSect);
+    AssertRCReturn(rc, rc);
+
+    if (pStreamEx->uMagic == DRVAUDIOSTREAM_MAGIC)
+    {
+        if (pStreamEx->cRefs > 0 && pStreamEx->cRefs < UINT32_MAX / 4)
+        {
+            char szStatus[DRVAUDIO_STATUS_STR_MAX], szBackendStatus[DRVAUDIO_STATUS_STR_MAX];
+            LogRel2(("Audio: Destroying stream '%s': cRefs=%u; status: %s; backend: %s; hReqInitAsync=%p\n",
+                     pStreamEx->Core.szName, pStreamEx->cRefs, dbgAudioStreamStatusToStr(szStatus, pStreamEx->fStatus),
+                     dbgAudioStreamStatusToStr(szBackendStatus, drvAudioStreamGetBackendStatus(pThis, pStreamEx)),
+                     pStreamEx->hReqInitAsync));
+
+            /* Try cancel pending async init request and release the it. */
+            if (pStreamEx->hReqInitAsync != NIL_RTREQ)
+            {
+                Assert(pStreamEx->cRefs >= 2);
+                int rc2 = RTReqCancel(pStreamEx->hReqInitAsync);
+                if (RT_SUCCESS(rc2))
+                {
+                    LogFlowFunc(("Successfully cancelled pending pfnStreamInitAsync call (hReqInitAsync=%p).\n",
+                                 pStreamEx->hReqInitAsync));
+                    drvAudioStreamReleaseInternal(pThis, pStreamEx, true /*fMayDestroy*/);
+                }
+                else
+                {
+                    LogFlowFunc(("Failed to cancel pending pfnStreamInitAsync call (hReqInitAsync=%p): %Rrc\n",
+                                 pStreamEx->hReqInitAsync, rc2));
+                    Assert(rc2 == VERR_RT_REQUEST_STATE);
+                }
+
+                RTReqRelease(pStreamEx->hReqInitAsync);
+                pStreamEx->hReqInitAsync = NIL_RTREQ;
+            }
+
+            /* We don't really care about the status here as we'll release a reference regardless of the state. */
+            /** @todo can we somehow drain it instead? */
+            int rc2 = drvAudioStreamControlInternal(pThis, pStreamEx, PDMAUDIOSTREAMCMD_DISABLE);
+            AssertRC(rc2);
+
+            drvAudioStreamReleaseInternal(pThis, pStreamEx, true /*fMayDestroy*/);
+        }
+        else
+            AssertLogRelMsgFailedStmt(("%p cRefs=%#x\n", pStreamEx, pStreamEx->cRefs), rc = VERR_CALLER_NO_REFERENCE);
+    }
+    else
+        AssertLogRelMsgFailedStmt(("%p uMagic=%#x\n", pStreamEx, pStreamEx->uMagic), rc = VERR_INVALID_MAGIC);
 
     RTCritSectLeave(&pThis->CritSect);
@@ -1600 +1957 @@
      * Gather current stream status.
      */
-    const bool fIsEnabled = RT_BOOL(pStreamEx->Core.fStatus & PDMAUDIOSTREAM_STS_ENABLED); /* Stream is enabled? */
+    const bool fIsEnabled = RT_BOOL(pStreamEx->fStatus & PDMAUDIOSTREAM_STS_ENABLED); /* Stream is enabled? */
 
 /** @todo r=bird: this is retried a bit too indiscriminately for my taste ... */
@@ -1625 +1982 @@
     }
 
+/** @todo r=bird: Why do we do the dropping and re-enabling of the stream
+ *        regardless of how the above went?  It'll overwrite any above
+ *        failures for starters... */
     /* Drop all old data. */
     drvAudioStreamDropInternal(pStreamEx);
@@ -1631 +1991 @@
      * Restore previous stream state.
      */
+    /** @todo this isn't taking PAUSED or PENDING_DISABLE into consideration.   */
     if (fIsEnabled)
         rc = drvAudioStreamControlInternalBackend(pThis, pStreamEx, PDMAUDIOSTREAMCMD_ENABLE);
@@ -1652 +2013 @@
     AssertReturn(pStreamEx->Core.uMagic == PDMAUDIOSTREAM_MAGIC, VERR_INVALID_MAGIC);
     AssertReturn(pStreamEx->uMagic == DRVAUDIOSTREAM_MAGIC, VERR_INVALID_MAGIC);
-    AssertReturn(pStreamEx->Core.fStatus & PDMAUDIOSTREAM_STS_NEED_REINIT, VERR_INVALID_STATE);
+    AssertReturn(pStreamEx->fStatus & PDMAUDIOSTREAM_STS_NEED_REINIT, VERR_INVALID_STATE);
     LogFlowFunc(("\n"));
 
@@ -1658 +2019 @@
     AssertRCReturn(rc, rc);
 
-    if (pStreamEx->Core.fStatus & PDMAUDIOSTREAM_STS_NEED_REINIT)
+    if (pStreamEx->fStatus & PDMAUDIOSTREAM_STS_NEED_REINIT)
     {
         const unsigned cMaxTries = 3; /** @todo Make this configurable? */
         const uint64_t tsNowNs   = RTTimeNanoTS();
+
+/** @todo r=bird: Must postpone if hReqInitAsync isn't NIL or cancellable. */
 
         /* Throttle re-initializing streams on failure. */
@@ -1691 +2054 @@
             {
                 /* Remove the pending re-init flag on success. */
-                pStreamEx->Core.fStatus &= ~PDMAUDIOSTREAM_STS_NEED_REINIT;
-                PDMAUDIOSTREAM_STS_ASSERT_VALID(pStreamEx->Core.fStatus);
+                pStreamEx->fStatus &= ~PDMAUDIOSTREAM_STS_NEED_REINIT;
+                PDMAUDIOSTREAM_STS_ASSERT_VALID(pStreamEx->fStatus);
             }
             else
@@ -1712 +2075 @@
                 /* Don't try to re-initialize anymore and mark as disabled. */
                 /** @todo should mark it as not-initialized too, shouldn't we?   */
-                pStreamEx->Core.fStatus &= ~(PDMAUDIOSTREAM_STS_NEED_REINIT | PDMAUDIOSTREAM_STS_ENABLED);
-                PDMAUDIOSTREAM_STS_ASSERT_VALID(pStreamEx->Core.fStatus);
+                pStreamEx->fStatus &= ~(PDMAUDIOSTREAM_STS_NEED_REINIT | PDMAUDIOSTREAM_STS_ENABLED);
+                PDMAUDIOSTREAM_STS_ASSERT_VALID(pStreamEx->fStatus);
 
                 /* Note: Further writes to this stream go to / will be read from the bit bucket (/dev/null) from now on. */
@@ -1722 +2085 @@
         char szStreamSts[DRVAUDIO_STATUS_STR_MAX];
 #endif
-        Log3Func(("[%s] fStatus=%s\n", pStreamEx->Core.szName, dbgAudioStreamStatusToStr(szStreamSts, pStreamEx->Core.fStatus)));
+        Log3Func(("[%s] fStatus=%s\n", pStreamEx->Core.szName, dbgAudioStreamStatusToStr(szStreamSts, pStreamEx->fStatus)));
     }
     else
@@ -1737 +2100 @@
 
 /**
+ * Internal retain function.
+ *
+ * @returns New reference count, UINT32_MAX if bad stream.
+ * @param   pStreamEx           The stream to reference.
+ */
+static uint32_t drvAudioStreamRetainInternal(PDRVAUDIOSTREAM pStreamEx)
+{
+    AssertPtrReturn(pStreamEx, UINT32_MAX);
+    AssertReturn(pStreamEx->Core.uMagic == PDMAUDIOSTREAM_MAGIC, UINT32_MAX);
+    AssertReturn(pStreamEx->uMagic == DRVAUDIOSTREAM_MAGIC, UINT32_MAX);
+
+    uint32_t const cRefs = ASMAtomicIncU32(&pStreamEx->cRefs);
+    Assert(cRefs > 1);
+    Assert(cRefs < _1K);
+
+    Log12Func(("returns %u (%s)\n", cRefs, pStreamEx->Core.szName));
+    return cRefs;
+}
+
+
+/**
  * @interface_method_impl{PDMIAUDIOCONNECTOR,pfnStreamRetain}
  */
 static DECLCALLBACK(uint32_t) drvAudioStreamRetain(PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOSTREAM pStream)
 {
-   AssertPtrReturn(pInterface, UINT32_MAX);
-   AssertPtrReturn(pStream,    UINT32_MAX);
-   AssertReturn(pStream->uMagic == PDMAUDIOSTREAM_MAGIC, UINT32_MAX);
-   AssertReturn(((PDRVAUDIOSTREAM)pStream)->uMagic == DRVAUDIOSTREAM_MAGIC, UINT32_MAX);
-   RT_NOREF(pInterface);
-
-   uint32_t const cRefs = ASMAtomicIncU32(&pStream->cRefs);
-   Assert(cRefs > 1);
-   Assert(cRefs < _1K);
-
-   return cRefs;
+    RT_NOREF(pInterface);
+    return drvAudioStreamRetainInternal((PDRVAUDIOSTREAM)pStream);
 }
 
@@ -1760 +2135 @@
 static DECLCALLBACK(uint32_t) drvAudioStreamRelease(PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOSTREAM pStream)
 {
-   AssertPtrReturn(pInterface, UINT32_MAX);
-   AssertPtrReturn(pStream,    UINT32_MAX);
-   AssertReturn(pStream->uMagic == PDMAUDIOSTREAM_MAGIC, UINT32_MAX);
-   AssertReturn(((PDRVAUDIOSTREAM)pStream)->uMagic == DRVAUDIOSTREAM_MAGIC, UINT32_MAX);
-   RT_NOREF(pInterface);
-
-   uint32_t cRefs = ASMAtomicDecU32(&pStream->cRefs);
-   AssertStmt(cRefs >= 1, cRefs = ASMAtomicIncU32(&pStream->cRefs));
-   Assert(cRefs < _1K);
-
-   return cRefs;
+    return drvAudioStreamReleaseInternal(RT_FROM_MEMBER(pInterface, DRVAUDIO, IAudioConnector),
+                                         (PDRVAUDIOSTREAM)pStream,
+                                         false /*fMayDestroy*/);
 }
 
@@ -1776 +2143 @@
 /**
  * Controls a stream's backend.
- *
- * If the stream has no backend available, VERR_NOT_FOUND is returned
- * (bird: actually the code returns VINF_SUCCESS).
  *
  * @returns VBox status code.
@@ -1784 +2148 @@
  * @param   pStreamEx       Stream to control.
  * @param   enmStreamCmd    Control command.
+ *
+ * @note    Caller has entered the critical section.
  */
 static int drvAudioStreamControlInternalBackend(PDRVAUDIO pThis, PDRVAUDIOSTREAM pStreamEx, PDMAUDIOSTREAMCMD enmStreamCmd)
@@ -1790 +2156 @@
     AssertPtr(pStreamEx);
 
-#ifdef LOG_ENABLED
-    char szStreamSts[DRVAUDIO_STATUS_STR_MAX];
-#endif
-    LogFlowFunc(("[%s] enmStreamCmd=%s, fStatus=%s\n", pStreamEx->Core.szName, PDMAudioStrmCmdGetName(enmStreamCmd),
-                 dbgAudioStreamStatusToStr(szStreamSts, pStreamEx->Core.fStatus)));
-
-    if (!pThis->pHostDrvAudio) /* If not lower driver is configured, bail out. */
-        return VINF_SUCCESS;
-
-
     /*
      * Whether to propagate commands down to the backend.
      *
-     * This is needed for critical operations like recording audio if audio input is disabled on a per-driver level.
+     *      1. If the stream direction is disabled on the driver level, we should
+     *         obviously not call the backend.  Our stream status will reflect the
+     *         actual state so drvAudioEnable() can tell the backend if the user
+     *         re-enables the stream direction.
      *
-     * Note that not all commands will be covered by this, such as operations like stopping, draining and droppping,
-     * which are considered uncritical and sometimes even are required for certain backends (like DirectSound on Windows).
-     *
-     * The actual stream state will be untouched to not make the state machine handling more complicated than
-     * it already is.
-     *
-     * See @bugref{9882}.
-     */
-    const bool fEnabled =    (   pStreamEx->Core.enmDir == PDMAUDIODIR_IN
-                              && pThis->In.fEnabled)
-                          || (   pStreamEx->Core.enmDir == PDMAUDIODIR_OUT
-                              && pThis->Out.fEnabled);
-
-    LogRel2(("Audio: %s stream '%s' in backend (%s is %s)\n", PDMAudioStrmCmdGetName(enmStreamCmd), pStreamEx->Core.szName,
-                                                              PDMAudioDirGetName(pStreamEx->Core.enmDir),
-                                                              fEnabled ? "enabled" : "disabled"));
-    int rc = VINF_SUCCESS;
-    switch (enmStreamCmd)
-    {
-        case PDMAUDIOSTREAMCMD_ENABLE:
-        {
-            if (fEnabled)
-                rc = pThis->pHostDrvAudio->pfnStreamControl(pThis->pHostDrvAudio, pStreamEx->pBackend, PDMAUDIOSTREAMCMD_ENABLE);
-            break;
-        }
-
-        case PDMAUDIOSTREAMCMD_DISABLE:
-        {
-            rc = pThis->pHostDrvAudio->pfnStreamControl(pThis->pHostDrvAudio, pStreamEx->pBackend, PDMAUDIOSTREAMCMD_DISABLE);
-            break;
-        }
-
-        case PDMAUDIOSTREAMCMD_PAUSE:
-        {
-            if (fEnabled) /* Needed, as resume below also is being checked for. */
-                rc = pThis->pHostDrvAudio->pfnStreamControl(pThis->pHostDrvAudio, pStreamEx->pBackend, PDMAUDIOSTREAMCMD_PAUSE);
-            break;
-        }
-
-        case PDMAUDIOSTREAMCMD_RESUME:
-        {
-            if (fEnabled)
-                rc = pThis->pHostDrvAudio->pfnStreamControl(pThis->pHostDrvAudio, pStreamEx->pBackend, PDMAUDIOSTREAMCMD_RESUME);
-            break;
-        }
-
-        case PDMAUDIOSTREAMCMD_DRAIN:
-        {
-            rc = pThis->pHostDrvAudio->pfnStreamControl(pThis->pHostDrvAudio, pStreamEx->pBackend, PDMAUDIOSTREAMCMD_DRAIN);
-            break;
-        }
-
-        default:
-            AssertMsgFailedReturn(("Command %RU32 not implemented\n", enmStreamCmd), VERR_INTERNAL_ERROR_2);
-    }
-
-    if (RT_FAILURE(rc))
-    {
-        if (   rc != VERR_NOT_IMPLEMENTED
-            && rc != VERR_NOT_SUPPORTED
-            && rc != VERR_AUDIO_STREAM_NOT_READY)
-        {
-            LogRel(("Audio: %s stream '%s' failed with %Rrc\n", PDMAudioStrmCmdGetName(enmStreamCmd), pStreamEx->Core.szName, rc));
-        }
-
-        LogFunc(("[%s] %s failed with %Rrc\n", pStreamEx->Core.szName, PDMAudioStrmCmdGetName(enmStreamCmd), rc));
-    }
-
+     *      2. If the backend hasn't finished initializing yet, don't try call
+     *         it to start/stop/pause/whatever the stream.  (Better to do it here
+     *         than to replicate this in the relevant backends.)  When the backend
+     *         finish initializing the stream, we'll update it about the stream state.
+     */
+    int             rc             = VINF_SUCCESS;
+    uint32_t const  fBackendStatus = drvAudioStreamGetBackendStatus(pThis, pStreamEx); /* (checks pThis->pHostDrvAudio too) */
+    bool const      fDirEnabled    = pStreamEx->Core.enmDir == PDMAUDIODIR_IN ? pThis->In.fEnabled : pThis->Out.fEnabled;
+
+    char szStreamSts[DRVAUDIO_STATUS_STR_MAX], szBackendStreamSts[DRVAUDIO_STATUS_STR_MAX];
+    LogRel2(("Audio: %s stream '%s' backend (%s is %s; status: %s; backend-status: %s)\n",
+             PDMAudioStrmCmdGetName(enmStreamCmd), pStreamEx->Core.szName, PDMAudioDirGetName(pStreamEx->Core.enmDir),
+             fDirEnabled ? "enabled" : "disabled",  dbgAudioStreamStatusToStr(szStreamSts, pStreamEx->fStatus),
+             dbgAudioStreamStatusToStr(szBackendStreamSts, fBackendStatus) ));
+
+    if (fDirEnabled)
+    {
+        if (   (pStreamEx->fStatus & PDMAUDIOSTREAM_STS_BACKEND_READY)
+            && (fBackendStatus & PDMAUDIOSTREAM_STS_INITIALIZED))
+        {
+            /** @todo Backend will change to explicit methods here, so please don't simplify
+             *        the switch. */
+            switch (enmStreamCmd)
+            {
+                case PDMAUDIOSTREAMCMD_ENABLE:
+                    rc = pThis->pHostDrvAudio->pfnStreamControl(pThis->pHostDrvAudio, pStreamEx->pBackend,
+                                                                PDMAUDIOSTREAMCMD_ENABLE);
+                    break;
+
+                case PDMAUDIOSTREAMCMD_DISABLE:
+                    rc = pThis->pHostDrvAudio->pfnStreamControl(pThis->pHostDrvAudio, pStreamEx->pBackend,
+                                                                PDMAUDIOSTREAMCMD_DISABLE);
+                    break;
+
+                case PDMAUDIOSTREAMCMD_PAUSE:
+                    rc = pThis->pHostDrvAudio->pfnStreamControl(pThis->pHostDrvAudio, pStreamEx->pBackend,
+                                                                PDMAUDIOSTREAMCMD_PAUSE);
+                    break;
+
+                case PDMAUDIOSTREAMCMD_RESUME:
+                    rc = pThis->pHostDrvAudio->pfnStreamControl(pThis->pHostDrvAudio, pStreamEx->pBackend,
+                                                                PDMAUDIOSTREAMCMD_RESUME);
+                    break;
+
+                case PDMAUDIOSTREAMCMD_DRAIN:
+                    rc = pThis->pHostDrvAudio->pfnStreamControl(pThis->pHostDrvAudio, pStreamEx->pBackend,
+                                                                PDMAUDIOSTREAMCMD_DRAIN);
+                    break;
+
+                default:
+                    AssertMsgFailedReturn(("Command %RU32 not implemented\n", enmStreamCmd), VERR_INTERNAL_ERROR_2);
+            }
+            if (RT_SUCCESS(rc))
+                Log2Func(("[%s] %s succeeded (%Rrc)\n", pStreamEx->Core.szName, PDMAudioStrmCmdGetName(enmStreamCmd), rc));
+            else
+            {
+                LogFunc(("[%s] %s failed with %Rrc\n", pStreamEx->Core.szName, PDMAudioStrmCmdGetName(enmStreamCmd), rc));
+                if (   rc != VERR_NOT_IMPLEMENTED
+                    && rc != VERR_NOT_SUPPORTED
+                    && rc != VERR_AUDIO_STREAM_NOT_READY)
+                    LogRel(("Audio: %s stream '%s' failed with %Rrc\n", PDMAudioStrmCmdGetName(enmStreamCmd), pStreamEx->Core.szName, rc));
+            }
+        }
+    }
     return rc;
 }
@@ -1888 +2243 @@
     LogFunc(("[%s]\n", pStreamEx->Core.szName));
 
-    pStreamEx->Core.fStatus        = PDMAUDIOSTREAM_STS_INITIALIZED;
+    pStreamEx->fStatus            &= PDMAUDIOSTREAM_STS_INITIALIZED | PDMAUDIOSTREAM_STS_BACKEND_READY;
     pStreamEx->Core.fWarningsShown = PDMAUDIOSTREAM_WARN_FLAGS_NONE;
 
@@ -1927 +2282 @@
     {
         if (   pStreamEx->uMagic == DRVAUDIOSTREAM_MAGIC
-            && pStreamEx->Core.cRefs >= 1)
-        {
-            if (pStreamEx->Core.fStatus & PDMAUDIOSTREAM_STS_PENDING_DISABLE)
+            && pStreamEx->cRefs >= 1)
+        {
+            if (pStreamEx->fStatus & PDMAUDIOSTREAM_STS_PENDING_DISABLE)
             {
                 drvAudioStreamIterateInternal(pThis, pStreamEx);
 
-                if (pStreamEx->Core.fStatus & PDMAUDIOSTREAM_STS_PENDING_DISABLE)
+                if (pStreamEx->fStatus & PDMAUDIOSTREAM_STS_PENDING_DISABLE)
                     cMilliesToNext = 10;
             }
@@ -1971 +2326 @@
 #endif
     LogFunc(("[%s] enmStreamCmd=%s fStatus=%s\n", pStreamEx->Core.szName, PDMAudioStrmCmdGetName(enmStreamCmd),
-             dbgAudioStreamStatusToStr(szStreamSts, pStreamEx->Core.fStatus)));
+             dbgAudioStreamStatusToStr(szStreamSts, pStreamEx->fStatus)));
 
     int rc = VINF_SUCCESS;
@@ -1978 +2333 @@
     {
         case PDMAUDIOSTREAMCMD_ENABLE:
-            if (!(pStreamEx->Core.fStatus & PDMAUDIOSTREAM_STS_ENABLED))
+            if (!(pStreamEx->fStatus & PDMAUDIOSTREAM_STS_ENABLED))
             {
                 /* Is a pending disable outstanding? Then disable first. */
-                if (pStreamEx->Core.fStatus & PDMAUDIOSTREAM_STS_PENDING_DISABLE)
+                if (pStreamEx->fStatus & PDMAUDIOSTREAM_STS_PENDING_DISABLE)
                     rc = drvAudioStreamControlInternalBackend(pThis, pStreamEx, PDMAUDIOSTREAMCMD_DISABLE);
                 if (RT_SUCCESS(rc))
@@ -1993 +2348 @@
                         pStreamEx->Out.enmPlayState  = pStreamEx->Out.cbPreBufThreshold > 0
                                                      ? DRVAUDIOPLAYSTATE_PREBUF
-                                                     : pStreamEx->fLastBackendStatus & PDMAUDIOSTREAM_STS_INITIALIZED
+                                                     :    (pStreamEx->fStatus & PDMAUDIOSTREAM_STS_BACKEND_READY)
+                                                       && (pStreamEx->fLastBackendStatus & PDMAUDIOSTREAM_STS_INITIALIZED)
                                                      ? DRVAUDIOPLAYSTATE_PLAY
                                                      : DRVAUDIOPLAYSTATE_NOPLAY;
@@ -2005 +2361 @@
                     if (RT_SUCCESS(rc))
                     {
-                        pStreamEx->Core.fStatus |= PDMAUDIOSTREAM_STS_ENABLED;
-                        PDMAUDIOSTREAM_STS_ASSERT_VALID(pStreamEx->Core.fStatus);
+                        pStreamEx->fStatus |= PDMAUDIOSTREAM_STS_ENABLED;
+                        PDMAUDIOSTREAM_STS_ASSERT_VALID(pStreamEx->fStatus);
                     }
                 }
@@ -2013 +2369 @@
 
         case PDMAUDIOSTREAMCMD_DISABLE:
-            if (pStreamEx->Core.fStatus & PDMAUDIOSTREAM_STS_ENABLED)
+            if (pStreamEx->fStatus & PDMAUDIOSTREAM_STS_ENABLED)
             {
                 /*
@@ -2023 +2379 @@
                 {
                     LogFunc(("[%s] Pending disable/pause\n", pStreamEx->Core.szName));
-                    pStreamEx->Core.fStatus |= PDMAUDIOSTREAM_STS_PENDING_DISABLE;
-                    PDMAUDIOSTREAM_STS_ASSERT_VALID(pStreamEx->Core.fStatus);
+                    pStreamEx->fStatus |= PDMAUDIOSTREAM_STS_PENDING_DISABLE;
+                    PDMAUDIOSTREAM_STS_ASSERT_VALID(pStreamEx->fStatus);
 
                     /* Schedule a follow up timer to the pending-disable state.  We cannot rely
@@ -2040 +2396 @@
 
                 /* Can we close the host stream as well (not in pending disable mode)? */
-                if (!(pStreamEx->Core.fStatus & PDMAUDIOSTREAM_STS_PENDING_DISABLE))
+                if (!(pStreamEx->fStatus & PDMAUDIOSTREAM_STS_PENDING_DISABLE))
                 {
                     rc = drvAudioStreamControlInternalBackend(pThis, pStreamEx, PDMAUDIOSTREAMCMD_DISABLE);
@@ -2050 +2406 @@
 
         case PDMAUDIOSTREAMCMD_PAUSE:
-            if (   (pStreamEx->Core.fStatus & (PDMAUDIOSTREAM_STS_ENABLED | PDMAUDIOSTREAM_STS_PAUSED))
-                ==                             PDMAUDIOSTREAM_STS_ENABLED)
+            if ((pStreamEx->fStatus & (PDMAUDIOSTREAM_STS_ENABLED | PDMAUDIOSTREAM_STS_PAUSED)) == PDMAUDIOSTREAM_STS_ENABLED)
             {
                 rc = drvAudioStreamControlInternalBackend(pThis, pStreamEx, PDMAUDIOSTREAMCMD_PAUSE);
                 if (RT_SUCCESS(rc))
                 {
-                    pStreamEx->Core.fStatus |= PDMAUDIOSTREAM_STS_PAUSED;
-                    PDMAUDIOSTREAM_STS_ASSERT_VALID(pStreamEx->Core.fStatus);
+                    pStreamEx->fStatus |= PDMAUDIOSTREAM_STS_PAUSED;
+                    PDMAUDIOSTREAM_STS_ASSERT_VALID(pStreamEx->fStatus);
                 }
             }
@@ -2063 +2418 @@
 
         case PDMAUDIOSTREAMCMD_RESUME:
-            if (pStreamEx->Core.fStatus & PDMAUDIOSTREAM_STS_PAUSED)
+            if (pStreamEx->fStatus & PDMAUDIOSTREAM_STS_PAUSED)
             {
-                Assert(pStreamEx->Core.fStatus & PDMAUDIOSTREAM_STS_ENABLED);
+                Assert(pStreamEx->fStatus & PDMAUDIOSTREAM_STS_ENABLED);
                 rc = drvAudioStreamControlInternalBackend(pThis, pStreamEx, PDMAUDIOSTREAMCMD_RESUME);
                 if (RT_SUCCESS(rc))
                 {
-                    pStreamEx->Core.fStatus &= ~PDMAUDIOSTREAM_STS_PAUSED;
-                    PDMAUDIOSTREAM_STS_ASSERT_VALID(pStreamEx->Core.fStatus);
+                    pStreamEx->fStatus &= ~PDMAUDIOSTREAM_STS_PAUSED;
+                    PDMAUDIOSTREAM_STS_ASSERT_VALID(pStreamEx->fStatus);
                 }
             }
@@ -2178 +2533 @@
      * Update the pre-buffering size and position.
      */
-    pStreamEx->Out.cbPreBuffered = cbCur;
+    pStreamEx->Out.cbPreBuffered = RT_MIN(cbCur, cbMax);
     pStreamEx->Out.offPreBuf     = offRead;
     return VINF_SUCCESS;
@@ -2184 +2539 @@
 
 
-#if 0
-/**
- * Worker for drvAudioStreamPlay() and drvAudioStreamIterateInternal().
- *
- * The buffer is NULL and has a zero length when called from the interate
- * function.  This only occures when there is pre-buffered audio data that need
- * to be pushed to the backend due to a pending disabling of the stream.
- *
- * Caller owns the lock.
- */
-static int drvAudioStreamPlayLocked(PDRVAUDIO pThis, PDRVAUDIOSTREAM pStreamEx, uint32_t fBackStatus,
-                                    const uint8_t *pbBuf, uint32_t cbBuf, uint32_t *pcbWritten)
-{
-    Log3Func(("%s: @%#RX64: cbBuf=%#x fBackStatus=%#x\n", pStreamEx->Core.szName, pStreamEx->offInternal, cbBuf, fBackStatus));
-    RT_NOREF(fBackStatus);
-
-    /*
-     * Are we pre-buffering?
-     *
-     * Note! We do not restart pre-buffering in this version, as we'd
-     *       need some kind of cooperation with the backend buffer
-     *       managment to correctly detect an underrun.
-     */
-    bool     fJustStarted = false;
-    uint32_t cbWritten = 0;
-    int      rc;
-    if (   pStreamEx->fThresholdReached
-        && pStreamEx->Out.cbPreBuffered == 0)
-    {
-        /* not-prebuffering, likely after a while at least */
-        rc = VINF_SUCCESS;
-    }
-    else
-    {
-        /*
-         * Copy as much as we can to the pre-buffer.
-         */
-        uint32_t cbFree = pStreamEx->Out.cbPreBufAlloc - pStreamEx->Out.cbPreBuffered;
-        AssertReturn((int32_t)cbFree >= 0, VERR_INTERNAL_ERROR_2);
-        if (cbFree > 0 && cbBuf > 0)
-        {
-            cbWritten = RT_MIN(cbFree, cbBuf);
-            cbWritten = PDMAudioPropsFloorBytesToFrame(&pStreamEx->Core.Props, cbWritten);
-            if (pStreamEx->Out.offPreBuf == 0)
-                memcpy(&pStreamEx->Out.pbPreBuf[pStreamEx->Out.cbPreBuffered], pbBuf, cbWritten);
-            else
-            {
-
-            }
-
-            pStreamEx->Out.cbPreBuffered += cbWritten;
-            cbBuf                        -= cbWritten;
-            pbBuf                        += cbWritten;
-            pStreamEx->offInternal       += cbWritten;
-        }
-
-        /*
-         * Get the special case of buggy backend drivers out of the way.
-         * We get here if we couldn't write out all the pre-buffered data when
-         * we hit the threshold.
-         */
-        if (pStreamEx->fThresholdReached)
-            LogRel2(("Audio: @%#RX64: Stream '%s' pre-buffering commit problem: cbBuf=%#x cbPreBuffered=%#x\n",
-                     pStreamEx->offInternal, pStreamEx->Core.szName, cbBuf, pStreamEx->Out.cbPreBuffered));
-        /*
-         * Did we reach the backend's playback (pre-buffering) threshold?
-         * Can be 0 if no pre-buffering desired.
-         */
-        else if (pStreamEx->Out.cbPreBuffered + cbBuf >= pStreamEx->Out.cbPreBufThreshold)
-        {
-            LogRel2(("Audio: @%#RX64: Stream '%s' buffering complete! (%#x + %#x bytes)\n",
-                     pStreamEx->offInternal, pStreamEx->Core.szName, pStreamEx->Out.cbPreBuffered, cbBuf));
-            pStreamEx->fThresholdReached = fJustStarted = 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.
-         *
-         * Try play "Windows Navigation Start.wav" on Windows 7 (2824 samples).
-         */
-        else if (   (pStreamEx->Core.fStatus & PDMAUDIOSTREAM_STS_PENDING_DISABLE)
-                 && pStreamEx->Out.cbPreBuffered > 0)
-        {
-            LogRel2(("Audio: @%#RX64: Stream '%s' buffering complete - short sound! (%#x + %#x bytes)\n",
-                     pStreamEx->offInternal, pStreamEx->Core.szName, pStreamEx->Out.cbPreBuffered, cbBuf));
-            pStreamEx->fThresholdReached = fJustStarted = true;
-        }
-        /*
-         * Not yet, so still buffering audio data.
-         */
-        else
-        {
-            LogRel2(("Audio: @%#RX64: Stream '%s' is buffering (%RU8%% complete)...\n", pStreamEx->offInternal,
-                     pStreamEx->Core.szName, (100 * pStreamEx->Out.cbPreBuffered) / pStreamEx->Out.cbPreBufThreshold));
-            Assert(cbBuf == 0);
-            *pcbWritten = cbWritten;
-            return VINF_SUCCESS;
-        }
-
-        /*
-         * Write the pre-buffered chunk.
-         */
-        uint32_t off = 0;
-        uint32_t cbPreBufWritten;
-        do
-        {
-            cbPreBufWritten = 0;
-            rc = pThis->pHostDrvAudio->pfnStreamPlay(pThis->pHostDrvAudio, pStreamEx->pBackend, &pStreamEx->Out.pbPreBuf[off],
-                                                     pStreamEx->Out.cbPreBuffered - off, &cbPreBufWritten);
-            AssertRCBreak(rc);
-            off += cbPreBufWritten;
-        } while (off < pStreamEx->Out.cbPreBuffered && cbPreBufWritten != 0);
-
-        if (off >= pStreamEx->Out.cbPreBuffered)
-        {
-            Assert(off == pStreamEx->Out.cbPreBuffered);
-            LogFunc(("@%#RX64: Wrote all %#x bytes of pre-buffered audio data.\n", pStreamEx->offInternal, off));
-            pStreamEx->Out.cbPreBuffered = 0;
-        }
-        else
-        {
-            LogRel2(("Audio: @%#RX64: Stream '%s' pre-buffering commit problem: wrote %#x out of %#x + %#x%s - rc=%Rrc *pcbWritten=%#x\n",
-                     pStreamEx->offInternal, pStreamEx->Core.szName, off, pStreamEx->Out.cbPreBuffered, cbBuf,
-                     fJustStarted ? " (just started)" : "", rc, cbWritten));
-            AssertMsg(!fJustStarted || RT_FAILURE(rc),
-                      ("Buggy host driver buffer reporting: off=%#x cbPreBuffered=%#x\n", off, pStreamEx->Out.cbPreBuffered));
-            if (off > 0)
-            {
-                memmove(pStreamEx->Out.pbPreBuf, &pStreamEx->Out.pbPreBuf[off], pStreamEx->Out.cbPreBuffered - off);
-                pStreamEx->Out.cbPreBuffered -= off;
-            }
-            pStreamEx->nsLastPlayedCaptured = RTTimeNanoTS();
-            *pcbWritten = cbWritten;
-            return cbWritten ? VINF_SUCCESS : rc;
-        }
-
-        if (RT_FAILURE(rc))
-        {
-            *pcbWritten = cbWritten;
-            return rc;
-        }
-    }
-
-    /*
-     * Do the writing.
-     */
-    uint32_t cbWritable = pThis->pHostDrvAudio->pfnStreamGetWritable(pThis->pHostDrvAudio, pStreamEx->pBackend);
-    pStreamEx->Out.Stats.cbBackendWritableBefore = cbWritable;
-
-    uint8_t const cbFrame = PDMAudioPropsFrameSize(&pStreamEx->Core.Props);
-    while (cbBuf >= cbFrame && cbWritable >= cbFrame)
-    {
-        uint32_t const cbToWrite    = PDMAudioPropsFloorBytesToFrame(&pStreamEx->Core.Props, RT_MIN(cbBuf, cbWritable));
-        uint32_t       cbWrittenNow = 0;
-        rc = pThis->pHostDrvAudio->pfnStreamPlay(pThis->pHostDrvAudio, pStreamEx->pBackend, pbBuf, cbToWrite, &cbWrittenNow);
-        if (RT_SUCCESS(rc))
-        {
-            if (cbWrittenNow != cbToWrite)
-                Log3Func(("%s: @%#RX64: Wrote less bytes than requested: %#x, requested %#x\n",
-                          pStreamEx->Core.szName, pStreamEx->offInternal, cbWrittenNow, cbToWrite));
-#ifdef DEBUG_bird
-            Assert(cbWrittenNow == cbToWrite);
-#endif
-            AssertStmt(cbWrittenNow <= cbToWrite, cbWrittenNow = cbToWrite);
-            cbWritten += cbWrittenNow;
-            cbBuf     -= cbWrittenNow;
-            pbBuf     += cbWrittenNow;
-            pStreamEx->offInternal += cbWrittenNow;
-        }
-        else
-        {
-            *pcbWritten = cbWritten;
-            LogFunc(("%s: @%#RX64: pfnStreamPlay failed writing %#x bytes (%#x previous written, %#x writable): %Rrc\n",
-                     pStreamEx->Core.szName, pStreamEx->offInternal, cbToWrite, cbWritten, cbWritable, rc));
-            return cbWritten ? VINF_SUCCESS : rc;
-        }
-        cbWritable = pThis->pHostDrvAudio->pfnStreamGetWritable(pThis->pHostDrvAudio, pStreamEx->pBackend);
-    }
-
-    *pcbWritten = cbWritten;
-    pStreamEx->Out.Stats.cbBackendWritableAfter = cbWritable;
-    if (cbWritten)
-        pStreamEx->nsLastPlayedCaptured = RTTimeNanoTS();
-
-    Log3Func(("%s: @%#RX64: Wrote %#x bytes (%#x bytes left)\n", pStreamEx->Core.szName, pStreamEx->offInternal, cbWritten, cbBuf));
-    return rc;
-}
-#endif
-
-
-/**
- * Worker for drvAudioStreamPlay() and drvAudioStreamIterateInternal().
+/**
+ * Worker for drvAudioStreamPlay() and drvAudioStreamPreBufComitting().
  *
  * Caller owns the lock.
@@ -2432 +2595 @@
 
 
+/**
+ * Worker for drvAudioStreamPlay() and drvAudioStreamPreBufComitting().
+ */
 static int drvAudioStreamPlayToPreBuffer(PDRVAUDIOSTREAM pStreamEx, const void *pvBuf, uint32_t cbBuf, uint32_t cbMax,
                                          uint32_t *pcbWritten)
@@ -2563 +2729 @@
     AssertPtrReturn(pThis, VERR_INVALID_POINTER);
 
-    if (!pThis->pHostDrvAudio)
-        return VINF_SUCCESS;
-
 #ifdef LOG_ENABLED
     char szStreamSts[DRVAUDIO_STATUS_STR_MAX];
 #endif
-    Log3Func(("[%s] fStatus=%s\n", pStreamEx->Core.szName, dbgAudioStreamStatusToStr(szStreamSts, pStreamEx->Core.fStatus)));
+    Log3Func(("[%s] fStatus=%s\n", pStreamEx->Core.szName, dbgAudioStreamStatusToStr(szStreamSts, pStreamEx->fStatus)));
 
     /* Not enabled or paused? Skip iteration. */
-    if (   !(pStreamEx->Core.fStatus & PDMAUDIOSTREAM_STS_ENABLED)
-        ||  (pStreamEx->Core.fStatus & PDMAUDIOSTREAM_STS_PAUSED))
-    {
+    if ((pStreamEx->fStatus & (PDMAUDIOSTREAM_STS_ENABLED | PDMAUDIOSTREAM_STS_PAUSED)) != PDMAUDIOSTREAM_STS_ENABLED)
         return VINF_SUCCESS;
-    }
 
     /*
@@ -2582 +2742 @@
      */
     int rc = VINF_SUCCESS;
-    if (!(pStreamEx->Core.fStatus & PDMAUDIOSTREAM_STS_PENDING_DISABLE))
+    if (!(pStreamEx->fStatus & PDMAUDIOSTREAM_STS_PENDING_DISABLE))
     { /* likely until we get to the end of the stream at least. */ }
     else
@@ -2617 +2777 @@
                 if (pStreamEx->Out.cbPreBuffered > 0)
                 {
-                    uint32_t cbIgnored = 0;
-                    drvAudioStreamPreBufComitting(pThis, pStreamEx, NULL, 0, &cbIgnored);
-                    cFramesLive = PDMAudioPropsBytesToFrames(&pStreamEx->Core.Props, pStreamEx->Out.cbPreBuffered);
+                    /* Must check the backend state here first and only try commit the
+                       pre-buffered samples if the backend is in working order. */
+                    uint32_t const fBackendStatus = drvAudioStreamGetBackendStatus(pThis, pStreamEx); /* (checks pThis->pHostDrvAudio too) */
+                    if (   (pStreamEx->fStatus & PDMAUDIOSTREAM_STS_BACKEND_READY)
+                        && (fBackendStatus & PDMAUDIOSTREAM_STS_INITIALIZED))
+                    {
+                        uint32_t cbIgnored = 0;
+                        drvAudioStreamPreBufComitting(pThis, pStreamEx, NULL, 0, &cbIgnored);
+                        cFramesLive = PDMAudioPropsBytesToFrames(&pStreamEx->Core.Props, pStreamEx->Out.cbPreBuffered);
+                    }
+                    else
+                        Log3Func(("[%s] Skipping committing pre-buffered samples, backend not initialized (%#x)!\n",
+                                  pStreamEx->Core.szName, fBackendStatus));
                 }
                 break;
@@ -2633 +2803 @@
             if (rc == VERR_NOT_SUPPORTED) /* Not all backends support draining yet. */
                 rc = VINF_SUCCESS;
+            /** @todo r=bird: We could probably just skip this next check, as if drainig
+             *        failes, we should definitely try disable the stream.  Maybe the
+             *        host audio device was unplugged and we're leaving this stream in a
+             *        bogus state. */
             if (RT_SUCCESS(rc))
             {
                 /*
-                 * Before we disable the stream, check if the backend has
-                 * finished playing the buffered data.
+                 * Before we disable the stream, check if the backend has finished playing the buffered data.
                  */
                 uint32_t cbPending;
-                if (!pThis->pHostDrvAudio->pfnStreamGetPending) /* Optional. */
+                if (!pThis->pHostDrvAudio || !pThis->pHostDrvAudio->pfnStreamGetPending) /* Optional. */
                     cbPending = 0;
                 else
@@ -2656 +2829 @@
                     if (RT_SUCCESS(rc))
                     {
-                        pStreamEx->Core.fStatus &= ~(PDMAUDIOSTREAM_STS_ENABLED | PDMAUDIOSTREAM_STS_PENDING_DISABLE);
-                        PDMAUDIOSTREAM_STS_ASSERT_VALID(pStreamEx->Core.fStatus);
+                        pStreamEx->fStatus &= ~(PDMAUDIOSTREAM_STS_ENABLED | PDMAUDIOSTREAM_STS_PENDING_DISABLE);
+                        PDMAUDIOSTREAM_STS_ASSERT_VALID(pStreamEx->fStatus);
                         drvAudioStreamDropInternal(pStreamEx); /* Not a DROP command, just a stream reset. */
                     }
+                    /** @todo r=bird: This log entry sounds a rather fishy to be honest...  Any
+                     *        backend which would do that, or genuinely need this?  */
                     else
                         LogFunc(("[%s] Backend vetoed against closing pending input stream, rc=%Rrc\n", pStreamEx->Core.szName, rc));
@@ -2665 +2840 @@
             }
         }
-
     }
 
@@ -2727 +2901 @@
 
     if (   pThis->pHostDrvAudio
-        && (   PDMAudioStrmStatusCanRead(pStreamEx->Core.fStatus)
+        && (   PDMAudioStrmStatusCanRead(pStreamEx->fStatus)
             || fDisabled)
        )
     {
+        uint32_t const fBackendStatus = drvAudioStreamGetBackendStatus(pThis, pStreamEx);
+
         if (pStreamEx->fNoMixBufs)
-            cbReadable = pThis->pHostDrvAudio
-                       ? pThis->pHostDrvAudio->pfnStreamGetReadable(pThis->pHostDrvAudio, pStreamEx->pBackend) : 0;
+            cbReadable =    pThis->pHostDrvAudio
+                         && (pStreamEx->fStatus & PDMAUDIOSTREAM_STS_BACKEND_READY)
+                         && (fBackendStatus & PDMAUDIOSTREAM_STS_INITIALIZED)
+                         && !fDisabled
+                       ? pThis->pHostDrvAudio->pfnStreamGetReadable(pThis->pHostDrvAudio, pStreamEx->pBackend)
+                       : 0;
         else
         {
@@ -2739 +2919 @@
             cbReadable = AUDIOMIXBUF_F2B(&pStreamEx->Guest.MixBuf, cfReadable);
         }
-
         if (!cbReadable)
         {
@@ -2750 +2929 @@
              * Reading the actual data from a stream then will return silence then.
              */
-            uint32_t fStatus = drvAudioStreamGetBackendStatus(pThis, pStreamEx);
-            if (   !PDMAudioStrmStatusBackendCanRead(fStatus)
+            if (   !PDMAudioStrmStatusBackendCanRead(fBackendStatus)
                 || fDisabled)
             {
@@ -2762 +2940 @@
                     else
                         LogRel(("Audio: Warning: Input for stream '%s' of driver '%s' not ready (current input status is %#x), returning silence\n",
-                                pStreamEx->Core.szName, pThis->szName, fStatus));
+                                pStreamEx->Core.szName, pThis->szName, fBackendStatus));
 
                     pStreamEx->Core.fWarningsShown |= PDMAUDIOSTREAM_WARN_FLAGS_DISABLED;
@@ -2803 +2981 @@
      */
     uint32_t cbWritable = 0;
-    if (   PDMAudioStrmStatusCanWrite(pStreamEx->Core.fStatus)
+    if (   PDMAudioStrmStatusCanWrite(pStreamEx->fStatus)
         && pThis->pHostDrvAudio != NULL)
     {
-        Assert(pThis->pHostDrvAudio);
         switch (pStreamEx->Out.enmPlayState)
         {
@@ -2814 +2991 @@
             case DRVAUDIOPLAYSTATE_PLAY:
             case DRVAUDIOPLAYSTATE_PLAY_PREBUF:
+                Assert(pStreamEx->fStatus & PDMAUDIOSTREAM_STS_BACKEND_READY);
+                Assert(drvAudioStreamGetBackendStatus(pThis, pStreamEx) & PDMAUDIOSTREAM_STS_INITIALIZED);
                 cbWritable = pThis->pHostDrvAudio->pfnStreamGetWritable(pThis->pHostDrvAudio, pStreamEx->pBackend);
                 break;
@@ -2850 +3029 @@
                    as long as there is space for it, as we need the pfnStreamWrite call
                    to move the data. */
+                Assert(pStreamEx->fStatus & PDMAUDIOSTREAM_STS_BACKEND_READY);
+                Assert(drvAudioStreamGetBackendStatus(pThis, pStreamEx) & PDMAUDIOSTREAM_STS_INITIALIZED);
                 uint32_t const cbMin = PDMAudioPropsFramesToBytes(&pStreamEx->Core.Props, 8);
                 cbWritable = pThis->pHostDrvAudio->pfnStreamGetWritable(pThis->pHostDrvAudio, pStreamEx->pBackend);
@@ -2899 +3080 @@
     AssertRCReturn(rc, PDMAUDIOSTREAM_STS_NONE);
 
-    uint32_t fStrmStatus = pStreamEx->Core.fStatus;
+    uint32_t fStrmStatus = pStreamEx->fStatus;
 
     RTCritSectLeave(&pThis->CritSect);
@@ -2932 +3113 @@
 
 
+/**
+ * Processes backend status change.
+ *
+ * @todo bird: I'm more and more of the opinion that the backend should
+ *       explicitly notify us about these changes, rather that we polling them
+ *       via PDMIHOSTAUDIO::pfnStreamGetStatus...
+ */
 static void drvAudioStreamPlayProcessBackendStateChange(PDRVAUDIOSTREAM pStreamEx, uint32_t fNewState, uint32_t fOldState)
 {
@@ -2943 +3131 @@
         if (fOldState & PDMAUDIOSTREAM_STS_INITIALIZED)
         {
+            /* Pulse audio clear INITIALIZED. */
             switch (enmPlayState)
             {
@@ -2970 +3159 @@
         else
         {
-            switch (enmPlayState)
+            if (pStreamEx->fStatus & PDMAUDIOSTREAM_STS_BACKEND_READY)
             {
-                case DRVAUDIOPLAYSTATE_PREBUF:
-                case DRVAUDIOPLAYSTATE_PREBUF_SWITCHING:
-                    break;
-                case DRVAUDIOPLAYSTATE_PREBUF_OVERDUE:
-                    pStreamEx->Out.enmPlayState = DRVAUDIOPLAYSTATE_PREBUF_COMMITTING;
-                    break;
-                case DRVAUDIOPLAYSTATE_NOPLAY:
-                    pStreamEx->Out.enmPlayState = DRVAUDIOPLAYSTATE_PREBUF;
-                    break;
-                case DRVAUDIOPLAYSTATE_PLAY:
-                case DRVAUDIOPLAYSTATE_PLAY_PREBUF:
-                case DRVAUDIOPLAYSTATE_PREBUF_COMMITTING:
-                    AssertFailedBreak();
-                /* no default */
-                case DRVAUDIOPLAYSTATE_END:
-                case DRVAUDIOPLAYSTATE_INVALID:
-                    break;
+    /** @todo We need to resync the stream status somewhere...  */
+                switch (enmPlayState)
+                {
+                    case DRVAUDIOPLAYSTATE_PREBUF:
+                    case DRVAUDIOPLAYSTATE_PREBUF_SWITCHING:
+                        break;
+                    case DRVAUDIOPLAYSTATE_PREBUF_OVERDUE:
+                        pStreamEx->Out.enmPlayState = DRVAUDIOPLAYSTATE_PREBUF_COMMITTING;
+                        break;
+                    case DRVAUDIOPLAYSTATE_NOPLAY:
+                        pStreamEx->Out.enmPlayState = DRVAUDIOPLAYSTATE_PREBUF;
+                        break;
+                    case DRVAUDIOPLAYSTATE_PLAY:
+                    case DRVAUDIOPLAYSTATE_PLAY_PREBUF:
+                    case DRVAUDIOPLAYSTATE_PREBUF_COMMITTING:
+                        AssertFailedBreak();
+                    /* no default */
+                    case DRVAUDIOPLAYSTATE_END:
+                    case DRVAUDIOPLAYSTATE_INVALID:
+                        break;
+                }
+                LogFunc(("PDMAUDIOSTREAM_STS_INITIALIZED was set: %s -> %s\n",
+                         drvAudioPlayStateName(enmPlayState), drvAudioPlayStateName(pStreamEx->Out.enmPlayState) ));
             }
-            LogFunc(("PDMAUDIOSTREAM_STS_INITIALIZED was set: %s -> %s\n",
-                     drvAudioPlayStateName(enmPlayState), drvAudioPlayStateName(pStreamEx->Out.enmPlayState) ));
+            else
+                LogFunc(("PDMAUDIOSTREAM_STS_INITIALIZED was set (enmPlayState=%s), but PDMAUDIOSTREAM_STS_BACKEND_READY is not.\n",
+                         drvAudioPlayStateName(enmPlayState) ));
         }
     }
@@ -2999 +3195 @@
      *
      * Note! We don't care if it's cleared as the backend will call
-     *       PDMIAUDIONOTIFYFROMHOST::pfnStreamNotifyDeviceChanged when that takes place.
+     *       PDMIHOSTAUDIOPORT::pfnStreamNotifyDeviceChanged when that takes place.
      */
     if (   !(fOldState & PDMAUDIOSTREAM_STS_PREPARING_SWITCH)
@@ -3073 +3269 @@
      * whether to just drop the input into the bit bucket.
      */
-    if (PDMAudioStrmStatusIsReady(pStreamEx->Core.fStatus))
+    if (PDMAudioStrmStatusIsReady(pStreamEx->fStatus))
     {
         if (   pThis->Out.fEnabled /* (see @bugref{9882}) */
@@ -3097 +3293 @@
              */
             uint32_t const fBackendStatus = drvAudioStreamGetBackendStatus(pThis, pStreamEx);
-            Assert(   (fBackendStatus          & (PDMAUDIOSTREAM_STS_ENABLED | PDMAUDIOSTREAM_STS_PAUSED))
-                   == (pStreamEx->Core.fStatus & (PDMAUDIOSTREAM_STS_ENABLED | PDMAUDIOSTREAM_STS_PAUSED)) );
+            Assert(      (fBackendStatus     & (PDMAUDIOSTREAM_STS_ENABLED | PDMAUDIOSTREAM_STS_PAUSED))
+                      == (pStreamEx->fStatus & (PDMAUDIOSTREAM_STS_ENABLED | PDMAUDIOSTREAM_STS_PAUSED))
+                   || !(pStreamEx->fStatus & PDMAUDIOSTREAM_STS_BACKEND_READY)
+                   || !(fBackendStatus & PDMAUDIOSTREAM_STS_INITIALIZED) );
 
             if (!(  (pStreamEx->fLastBackendStatus ^ fBackendStatus)
@@ -3115 +3313 @@
             {
                 case DRVAUDIOPLAYSTATE_PLAY:
+                    Assert(pStreamEx->fStatus & PDMAUDIOSTREAM_STS_BACKEND_READY);
+                    Assert(fBackendStatus & PDMAUDIOSTREAM_STS_INITIALIZED);
                     rc = drvAudioStreamPlayLocked(pThis, pStreamEx, (uint8_t const *)pvBuf, cbBuf, pcbWritten);
                     break;
 
                 case DRVAUDIOPLAYSTATE_PLAY_PREBUF:
+                    Assert(pStreamEx->fStatus & PDMAUDIOSTREAM_STS_BACKEND_READY);
+                    Assert(fBackendStatus & PDMAUDIOSTREAM_STS_INITIALIZED);
                     rc = drvAudioStreamPlayLocked(pThis, pStreamEx, (uint8_t const *)pvBuf, cbBuf, pcbWritten);
                     drvAudioStreamPreBuffer(pStreamEx, (uint8_t const *)pvBuf, *pcbWritten, pStreamEx->Out.cbPreBufThreshold);
@@ -3144 +3346 @@
 
                 case DRVAUDIOPLAYSTATE_PREBUF_OVERDUE:
+                    Assert(!(pStreamEx->fStatus & PDMAUDIOSTREAM_STS_BACKEND_READY));
                     Assert(!(fBackendStatus & PDMAUDIOSTREAM_STS_INITIALIZED));
                     RT_FALL_THRU();
@@ -3151 +3354 @@
 
                 case DRVAUDIOPLAYSTATE_PREBUF_COMMITTING:
+                    Assert(pStreamEx->fStatus & PDMAUDIOSTREAM_STS_BACKEND_READY);
+                    Assert(fBackendStatus & PDMAUDIOSTREAM_STS_INITIALIZED);
                     rc = drvAudioStreamPreBufComitting(pThis, pStreamEx, (uint8_t const *)pvBuf, cbBuf, pcbWritten);
                     break;
@@ -3222 +3427 @@
         if (pThis->In.fEnabled) /* Input for this audio driver enabled? See #9822. */
         {
-            if (!PDMAudioStrmStatusCanRead(pStream->fStatus))
+            if (!PDMAudioStrmStatusCanRead(pStreamEx->fStatus))
             {
                 rc = VERR_AUDIO_STREAM_NOT_READY;
@@ -3316 +3521 @@
      * ...
      */
-    AssertPtr(pThis->pHostDrvAudio->pfnStreamGetReadable);
     uint32_t cbReadable = pThis->pHostDrvAudio->pfnStreamGetReadable(pThis->pHostDrvAudio, pStreamEx->pBackend);
     if (!cbReadable)
@@ -3494 +3698 @@
     char szStreamSts[DRVAUDIO_STATUS_STR_MAX];
 #endif
-    Log3Func(("[%s] fStatus=%s\n", pStreamEx->Core.szName, dbgAudioStreamStatusToStr(szStreamSts, pStreamEx->Core.fStatus)));
+    Log3Func(("[%s] fStatus=%s\n", pStreamEx->Core.szName, dbgAudioStreamStatusToStr(szStreamSts, pStreamEx->fStatus)));
 
     /*
@@ -3509 +3713 @@
 
         if (   !pThis->In.fEnabled
-            || !PDMAudioStrmStatusCanRead(pStreamEx->Core.fStatus))
+            || !PDMAudioStrmStatusCanRead(pStreamEx->fStatus)
+            || !(pStreamEx->fStatus & PDMAUDIOSTREAM_STS_BACKEND_READY))
         {
             rc = VERR_AUDIO_STREAM_NOT_READY;
@@ -3515 +3720 @@
         }
 
-        /*
-         * Do the actual capturing.
-         */
-        if (RT_LIKELY(pStreamEx->Host.Cfg.enmLayout == PDMAUDIOSTREAMLAYOUT_NON_INTERLEAVED))
-            rc = drvAudioStreamCaptureNonInterleaved(pThis, pStreamEx, &cfCaptured);
-        else if (pStreamEx->Host.Cfg.enmLayout == PDMAUDIOSTREAMLAYOUT_RAW)
-            rc = drvAudioStreamCaptureRaw(pThis, pStreamEx, &cfCaptured);
+        uint32_t const fBackendStatus = drvAudioStreamGetBackendStatus(pThis, pStreamEx);
+        if (fBackendStatus & PDMAUDIOSTREAM_STS_INITIALIZED)
+        {
+            /*
+             * Do the actual capturing.
+             */
+            if (RT_LIKELY(pStreamEx->Host.Cfg.enmLayout == PDMAUDIOSTREAMLAYOUT_NON_INTERLEAVED))
+                rc = drvAudioStreamCaptureNonInterleaved(pThis, pStreamEx, &cfCaptured);
+            else if (pStreamEx->Host.Cfg.enmLayout == PDMAUDIOSTREAMLAYOUT_RAW)
+                rc = drvAudioStreamCaptureRaw(pThis, pStreamEx, &cfCaptured);
+            else
+                AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
+
+            if (RT_SUCCESS(rc))
+            {
+                Log3Func(("[%s] %RU32 frames captured, rc=%Rrc\n", pStreamEx->Core.szName, cfCaptured, rc));
+
+                STAM_COUNTER_ADD(&pThis->Stats.TotalFramesIn,              cfCaptured);
+                STAM_COUNTER_ADD(&pStreamEx->In.Stats.TotalFramesCaptured, cfCaptured);
+            }
+            else if (RT_UNLIKELY(RT_FAILURE(rc)))
+                LogRel(("Audio: Capturing stream '%s' failed with %Rrc\n", pStreamEx->Core.szName, rc));
+        }
         else
-            AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
-
-        if (RT_SUCCESS(rc))
-        {
-            Log3Func(("[%s] %RU32 frames captured, rc=%Rrc\n", pStreamEx->Core.szName, cfCaptured, rc));
-
-            STAM_COUNTER_ADD(&pThis->Stats.TotalFramesIn,              cfCaptured);
-            STAM_COUNTER_ADD(&pStreamEx->In.Stats.TotalFramesCaptured, cfCaptured);
-        }
-        else if (RT_UNLIKELY(RT_FAILURE(rc)))
-            LogRel(("Audio: Capturing stream '%s' failed with %Rrc\n", pStreamEx->Core.szName, rc));
+            rc = VERR_AUDIO_STREAM_NOT_READY;
     } while (0);
 
@@ -3548 +3759 @@
 
 /*********************************************************************************************************************************
-*   PDMIAUDIONOTIFYFROMHOST interface implementation.                                                                            *
+*   PDMIHOSTAUDIOPORT interface implementation.                                                                                   *
 *********************************************************************************************************************************/
 
 /**
+ * Worker for drvAudioHostPort_DoOnWorkerThread with stream argument, called on
+ * worker thread.
+ */
+static DECLCALLBACK(void) drvAudioHostPort_DoOnWorkerThreadStreamWorker(PDRVAUDIO pThis, PDRVAUDIOSTREAM pStreamEx,
+                                                                        uintptr_t uUser, void *pvUser)
+{
+    LogFlowFunc(("pThis=%p uUser=%#zx pvUser=%p\n", pThis, uUser, pvUser));
+    AssertPtrReturnVoid(pThis);
+    AssertPtrReturnVoid(pStreamEx);
+    AssertReturnVoid(pStreamEx->uMagic == DRVAUDIOSTREAM_MAGIC);
+    PPDMIHOSTAUDIO const pIHostDrvAudio = pThis->pHostDrvAudio;
+    AssertPtrReturnVoid(pIHostDrvAudio);
+    AssertPtrReturnVoid(pIHostDrvAudio->pfnDoOnWorkerThread);
+
+    pIHostDrvAudio->pfnDoOnWorkerThread(pIHostDrvAudio, pStreamEx->pBackend, uUser, pvUser);
+
+    drvAudioStreamReleaseInternal(pThis, pStreamEx, true /*fMayDestroy*/);
+    LogFlowFunc(("returns\n"));
+}
+
+
+/**
+ * Worker for drvAudioHostPort_DoOnWorkerThread without stream argument, called
+ * on worker thread.
+ *
+ * This wrapper isn't technically required, but it helps with logging and a few
+ * extra sanity checks.
+ */
+static DECLCALLBACK(void) drvAudioHostPort_DoOnWorkerThreadWorker(PDRVAUDIO pThis, uintptr_t uUser, void *pvUser)
+{
+    LogFlowFunc(("pThis=%p uUser=%#zx pvUser=%p\n", pThis, uUser, pvUser));
+    AssertPtrReturnVoid(pThis);
+    PPDMIHOSTAUDIO const pIHostDrvAudio = pThis->pHostDrvAudio;
+    AssertPtrReturnVoid(pIHostDrvAudio);
+    AssertPtrReturnVoid(pIHostDrvAudio->pfnDoOnWorkerThread);
+
+    pIHostDrvAudio->pfnDoOnWorkerThread(pIHostDrvAudio, NULL, uUser, pvUser);
+
+    LogFlowFunc(("returns\n"));
+}
+
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIOPORT,pfnDoOnWorkerThread}
+ */
+static DECLCALLBACK(int) drvAudioHostPort_DoOnWorkerThread(PPDMIHOSTAUDIOPORT pInterface, PPDMAUDIOBACKENDSTREAM pStream,
+                                                           uintptr_t uUser, void *pvUser)
+{
+    PDRVAUDIO pThis = RT_FROM_MEMBER(pInterface, DRVAUDIO, IHostAudioPort);
+    LogFlowFunc(("pStream=%p uUser=%#zx pvUser=%p\n", pStream, uUser, pvUser));
+
+    /*
+     * Assert some sanity and do the work.
+     */
+    AssertReturn(pThis->pHostDrvAudio, VERR_INTERNAL_ERROR_3);
+    AssertReturn(pThis->pHostDrvAudio->pfnDoOnWorkerThread, VERR_INVALID_FUNCTION);
+    AssertReturn(pThis->hReqPool != NIL_RTREQPOOL, VERR_INVALID_FUNCTION);
+    int rc;
+    if (!pStream)
+    {
+        rc = RTReqPoolCallEx(pThis->hReqPool, 0 /*cMillies*/, NULL /*phReq*/, RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
+                             (PFNRT)drvAudioHostPort_DoOnWorkerThreadWorker, 3, pThis, uUser, pvUser);
+        AssertRC(rc);
+    }
+    else
+    {
+        AssertPtrReturn(pStream, VERR_INVALID_POINTER);
+        AssertReturn(pStream->uMagic == PDMAUDIOBACKENDSTREAM_MAGIC, VERR_INVALID_MAGIC);
+        PDRVAUDIOSTREAM pStreamEx = (PDRVAUDIOSTREAM)pStream->pStream;
+        AssertPtrReturn(pStreamEx, VERR_INVALID_POINTER);
+        AssertReturn(pStreamEx->uMagic == DRVAUDIOSTREAM_MAGIC, VERR_INVALID_MAGIC);
+        AssertReturn(pStreamEx->Core.uMagic == PDMAUDIOSTREAM_MAGIC, VERR_INVALID_MAGIC);
+
+        uint32_t cRefs = drvAudioStreamRetainInternal(pStreamEx);
+        if (cRefs != UINT32_MAX)
+        {
+            rc = RTReqPoolCallEx(pThis->hReqPool, 0 /*cMillies*/, NULL, RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
+                                 (PFNRT)drvAudioHostPort_DoOnWorkerThreadStreamWorker,
+                                 4, pThis, pStreamEx, uUser, pvUser);
+            AssertRC(rc);
+            if (RT_FAILURE(rc))
+                drvAudioStreamReleaseInternal(pThis, pStreamEx, true /*fMayDestroy*/);
+        }
+        else
+            rc = VERR_INVALID_PARAMETER;
+    }
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+/**
  * Marks a stream for re-init.
  */
@@ -3557 +3860 @@
 {
     LogFlow((LOG_FN_FMT ": Flagging %s for re-init.\n", pszCaller, pStreamEx->Core.szName)); RT_NOREF(pszCaller);
-    pStreamEx->Core.fStatus |= PDMAUDIOSTREAM_STS_NEED_REINIT;
-    PDMAUDIOSTREAM_STS_ASSERT_VALID(pStreamEx->Core.fStatus);
+    pStreamEx->fStatus      |= PDMAUDIOSTREAM_STS_NEED_REINIT;
+    PDMAUDIOSTREAM_STS_ASSERT_VALID(pStreamEx->fStatus);
     pStreamEx->cTriesReInit  = 0;
     pStreamEx->nsLastReInit  = 0;
@@ -3565 +3868 @@
 
 /**
- * @interface_method_impl{PDMIAUDIONOTIFYFROMHOST,pfnNotifyDeviceChanged}
- */
-static DECLCALLBACK(void) drvAudioNotifyFromHost_NotifyDeviceChanged(PPDMIAUDIONOTIFYFROMHOST pInterface,
-                                                                     PDMAUDIODIR enmDir, void *pvUser)
-{
-    PDRVAUDIO pThis = RT_FROM_MEMBER(pInterface, DRVAUDIO, IAudioNotifyFromHost);
+ * @interface_method_impl{PDMIHOSTAUDIOPORT,pfnNotifyDeviceChanged}
+ */
+static DECLCALLBACK(void) drvAudioHostPort_NotifyDeviceChanged(PPDMIHOSTAUDIOPORT pInterface, PDMAUDIODIR enmDir, void *pvUser)
+{
+    PDRVAUDIO pThis = RT_FROM_MEMBER(pInterface, DRVAUDIO, IHostAudioPort);
     AssertReturnVoid(enmDir == PDMAUDIODIR_IN || enmDir == PDMAUDIODIR_OUT);
     LogRel(("Audio: The %s device for %s is changing.\n", enmDir == PDMAUDIODIR_IN ? "input" : "output", pThis->szName));
@@ -3596 +3898 @@
 
 /**
- * @interface_method_impl{PDMIAUDIONOTIFYFROMHOST,pfnStreamNotifyDeviceChanged}
- */
-static DECLCALLBACK(void) drvAudioNotifyFromHost_StreamNotifyDeviceChanged(PPDMIAUDIONOTIFYFROMHOST pInterface,
-                                                                           PPDMAUDIOBACKENDSTREAM pStream, bool fReInit)
-{
-    PDRVAUDIO pThis = RT_FROM_MEMBER(pInterface, DRVAUDIO, IAudioNotifyFromHost);
+ * @interface_method_impl{PDMIHOSTAUDIOPORT,pfnStreamNotifyDeviceChanged}
+ */
+static DECLCALLBACK(void) drvAudioHostPort_StreamNotifyDeviceChanged(PPDMIHOSTAUDIOPORT pInterface,
+                                                                     PPDMAUDIOBACKENDSTREAM pStream, bool fReInit)
+{
+    PDRVAUDIO pThis = RT_FROM_MEMBER(pInterface, DRVAUDIO, IHostAudioPort);
 
     /*
@@ -3630 +3932 @@
          * know which thread we're on, do we now).
          */
-        AssertStmt(!(pStreamEx->Core.fStatus & PDMAUDIOSTREAM_STS_NEED_REINIT),
-                   pStreamEx->Core.fStatus &= ~PDMAUDIOSTREAM_STS_NEED_REINIT);
+        AssertStmt(!(pStreamEx->fStatus & PDMAUDIOSTREAM_STS_NEED_REINIT),
+                   pStreamEx->fStatus &= ~PDMAUDIOSTREAM_STS_NEED_REINIT);
 
         if (   pStreamEx->Core.enmDir == PDMAUDIODIR_OUT
-            && (pStreamEx->Core.fStatus & PDMAUDIOSTREAM_STS_ENABLED))
+            && (pStreamEx->fStatus & PDMAUDIOSTREAM_STS_ENABLED))
         {
             DRVAUDIOPLAYSTATE const enmPlayState = pStreamEx->Out.enmPlayState;
@@ -3648 +3950 @@
 
 /**
- * @interface_method_impl{PDMIAUDIONOTIFYFROMHOST,pfnNotifyDevicesChanged}
- */
-static DECLCALLBACK(void) drvAudioNotifyFromHost_NotifyDevicesChanged(PPDMIAUDIONOTIFYFROMHOST pInterface)
-{
-    PDRVAUDIO pThis = RT_FROM_MEMBER(pInterface, DRVAUDIO, IAudioNotifyFromHost);
+ * @interface_method_impl{PDMIHOSTAUDIOPORT,pfnNotifyDevicesChanged}
+ */
+static DECLCALLBACK(void) drvAudioHostPort_NotifyDevicesChanged(PPDMIHOSTAUDIOPORT pInterface)
+{
+    PDRVAUDIO pThis = RT_FROM_MEMBER(pInterface, DRVAUDIO, IHostAudioPort);
     LogRel(("Audio: Device configuration of driver '%s' has changed\n", pThis->szName));
 
@@ -3690 +3992 @@
     PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
     PDMIBASE_RETURN_INTERFACE(pszIID, PDMIAUDIOCONNECTOR, &pThis->IAudioConnector);
-    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIAUDIONOTIFYFROMHOST, &pThis->IAudioNotifyFromHost);
+    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIHOSTAUDIOPORT, &pThis->IHostAudioPort);
 
     return NULL;
@@ -3723 +4025 @@
         {
             drvAudioStreamControlInternalBackend(pThis, pStreamEx, PDMAUDIOSTREAMCMD_DISABLE);
+#if 0 /* This leads to double destruction. Also in the backend when we don't set pHostDrvAudio to NULL below. */
             drvAudioStreamDestroyInternalBackend(pThis, pStreamEx);
-        }
-
+#endif
+        }
+
+#if 0 /* Messes up using drvAudioHostPort_DoOnWorkerThread from the backend drivers' power off callback.  */
         pThis->pHostDrvAudio = NULL;
+#endif
     }
 
@@ -3748 +4054 @@
     AssertRC(rc);
 
-    LogFunc(("%s (detached %p)\n", pThis->szName, pThis->pHostDrvAudio));
+    LogFunc(("%s (detached %p, hReqPool=%p)\n", pThis->szName, pThis->pHostDrvAudio, pThis->hReqPool));
+
+    /*
+     * Must first destroy the thread pool first so we are certain no threads
+     * are still using the instance being detached.  Release lock while doing
+     * this as the thread functions may need to take it to complete.
+     */
+    if (pThis->pHostDrvAudio && pThis->hReqPool != NIL_RTREQPOOL)
+    {
+        RTREQPOOL hReqPool = pThis->hReqPool;
+        pThis->hReqPool = NIL_RTREQPOOL;
+        RTCritSectLeave(&pThis->CritSect);
+
+        RTReqPoolRelease(hReqPool);
+
+        RTCritSectEnter(&pThis->CritSect);
+    }
+
+    /*
+     * Now we can safely set pHostDrvAudio to NULL.
+     */
     pThis->pHostDrvAudio = NULL;
 
@@ -3769 +4095 @@
      * mandatory are present.
      */
-    PPDMIHOSTAUDIO pHostDrvAudio = pThis->pHostDrvAudio;
-    AssertPtrReturn(pHostDrvAudio, VERR_INVALID_POINTER);
-    AssertPtrReturn(pHostDrvAudio->pfnGetConfig, VERR_INVALID_POINTER);
-    AssertPtrNullReturn(pHostDrvAudio->pfnGetDevices, VERR_INVALID_POINTER);
-    AssertPtrNullReturn(pHostDrvAudio->pfnGetStatus, VERR_INVALID_POINTER);
-    AssertPtrNullReturn(pHostDrvAudio->pfnStreamConfigHint, VERR_INVALID_POINTER);
-    AssertPtrReturn(pHostDrvAudio->pfnStreamCreate, VERR_INVALID_POINTER);
-    AssertPtrReturn(pHostDrvAudio->pfnStreamDestroy, VERR_INVALID_POINTER);
-    AssertPtrNullReturn(pHostDrvAudio->pfnStreamNotifyDeviceChanged, VERR_INVALID_POINTER);
-    AssertPtrReturn(pHostDrvAudio->pfnStreamControl, VERR_INVALID_POINTER);
-    AssertPtrReturn(pHostDrvAudio->pfnStreamGetReadable, VERR_INVALID_POINTER);
-    AssertPtrReturn(pHostDrvAudio->pfnStreamGetWritable, VERR_INVALID_POINTER);
-    AssertPtrNullReturn(pHostDrvAudio->pfnStreamGetPending, VERR_INVALID_POINTER);
-    AssertPtrReturn(pHostDrvAudio->pfnStreamGetStatus, VERR_INVALID_POINTER);
-    AssertPtrReturn(pHostDrvAudio->pfnStreamPlay, VERR_INVALID_POINTER);
-    AssertPtrReturn(pHostDrvAudio->pfnStreamCapture, VERR_INVALID_POINTER);
+    PPDMIHOSTAUDIO pIHostDrvAudio = pThis->pHostDrvAudio;
+    AssertPtrReturn(pIHostDrvAudio, VERR_INVALID_POINTER);
+    AssertPtrReturn(pIHostDrvAudio->pfnGetConfig, VERR_INVALID_POINTER);
+    AssertPtrNullReturn(pIHostDrvAudio->pfnGetDevices, VERR_INVALID_POINTER);
+    AssertPtrNullReturn(pIHostDrvAudio->pfnGetStatus, VERR_INVALID_POINTER);
+    AssertPtrNullReturn(pIHostDrvAudio->pfnDoOnWorkerThread, VERR_INVALID_POINTER);
+    AssertPtrNullReturn(pIHostDrvAudio->pfnStreamConfigHint, VERR_INVALID_POINTER);
+    AssertPtrReturn(pIHostDrvAudio->pfnStreamCreate, VERR_INVALID_POINTER);
+    AssertPtrNullReturn(pIHostDrvAudio->pfnStreamInitAsync, VERR_INVALID_POINTER);
+    AssertPtrReturn(pIHostDrvAudio->pfnStreamDestroy, VERR_INVALID_POINTER);
+    AssertPtrNullReturn(pIHostDrvAudio->pfnStreamNotifyDeviceChanged, VERR_INVALID_POINTER);
+    AssertPtrReturn(pIHostDrvAudio->pfnStreamControl, VERR_INVALID_POINTER);
+    AssertPtrReturn(pIHostDrvAudio->pfnStreamGetReadable, VERR_INVALID_POINTER);
+    AssertPtrReturn(pIHostDrvAudio->pfnStreamGetWritable, VERR_INVALID_POINTER);
+    AssertPtrNullReturn(pIHostDrvAudio->pfnStreamGetPending, VERR_INVALID_POINTER);
+    AssertPtrReturn(pIHostDrvAudio->pfnStreamGetStatus, VERR_INVALID_POINTER);
+    AssertPtrReturn(pIHostDrvAudio->pfnStreamPlay, VERR_INVALID_POINTER);
+    AssertPtrReturn(pIHostDrvAudio->pfnStreamCapture, VERR_INVALID_POINTER);
 
     /*
      * Get the backend configuration.
      */
-    int rc = pThis->pHostDrvAudio->pfnGetConfig(pThis->pHostDrvAudio, &pThis->BackendCfg);
+    int rc = pIHostDrvAudio->pfnGetConfig(pIHostDrvAudio, &pThis->BackendCfg);
     if (RT_FAILURE(rc))
     {
@@ -3808 +4136 @@
     if (rc2 != VERR_NOT_SUPPORTED) /* Some backends don't implement device enumeration. */
         AssertRC(rc2);
-
-    RT_NOREF(rc2);
-    /* Ignore rc. */
+    /* Ignore rc2. */
 #endif
+
+    /*
+     * Create a thread pool if stream creation can be asynchronous.
+     *
+     * The pool employs no pushback as the caller is typically EMT and
+     * shouldn't be delayed.
+     *
+     * The number of threads limits and the device implementations use
+     * of pfnStreamDestroy limits the number of streams pending async
+     * init.  We use RTReqCancel in drvAudioStreamDestroy to allow us
+     * to release extra reference held by the pfnStreamInitAsync call
+     * if successful.  Cancellation will only be possible if the call
+     * hasn't been picked up by a worker thread yet, so the max number
+     * of threads in the pool defines how many destroyed streams that
+     * can be lingering.  (We must keep this under control, otherwise
+     * an evil guest could just rapidly trigger stream creation and
+     * destruction to consume host heap and hog CPU resources for
+     * configuring audio backends.)
+     */
+    if (   pThis->hReqPool == NIL_RTREQPOOL
+        && (   pIHostDrvAudio->pfnStreamInitAsync
+            || pIHostDrvAudio->pfnDoOnWorkerThread
+            || (pThis->BackendCfg.fFlags & PDMAUDIOBACKEND_F_ASYNC_HINT) ))
+    {
+        char szName[16];
+        RTStrPrintf(szName, sizeof(szName), "Aud%uWr", pThis->pDrvIns->iInstance);
+        RTREQPOOL hReqPool = NIL_RTREQPOOL;
+        rc = RTReqPoolCreate(3 /*cMaxThreads*/, RT_MS_30SEC /*cMsMinIdle*/, UINT32_MAX /*cThreadsPushBackThreshold*/,
+                             1 /*cMsMaxPushBack*/, szName, &hReqPool);
+        LogFlowFunc(("Creating thread pool '%s': %Rrc, hReqPool=%p\n", szName, rc, hReqPool));
+        AssertRCReturn(rc, rc);
+
+        rc = RTReqPoolSetCfgVar(hReqPool, RTREQPOOLCFGVAR_THREAD_FLAGS, RTTHREADFLAGS_COM_MTA);
+        AssertRCReturnStmt(rc, RTReqPoolRelease(hReqPool), rc);
+
+        rc = RTReqPoolSetCfgVar(hReqPool, RTREQPOOLCFGVAR_MIN_THREADS, 1);
+        AssertRC(rc); /* harmless */
+
+        pThis->hReqPool = hReqPool;
+    }
+    else
+        LogFlowFunc(("No thread pool.\n"));
 
     LogFlowFuncLeave();
@@ -4022 +4390 @@
 #endif
 
+    if (pThis->hReqPool != NIL_RTREQPOOL)
+    {
+        uint32_t cRefs = RTReqPoolRelease(pThis->hReqPool);
+        Assert(cRefs == 0); RT_NOREF(cRefs);
+        pThis->hReqPool = NIL_RTREQPOOL;
+    }
+
     LogFlowFuncLeave();
 }
@@ -4041 +4416 @@
      */
     RTListInit(&pThis->lstStreams);
+    pThis->hReqPool = NIL_RTREQPOOL;
 
     /*
@@ -4221 +4597 @@
     pThis->IAudioConnector.pfnStreamRead        = drvAudioStreamRead;
     pThis->IAudioConnector.pfnStreamCapture     = drvAudioStreamCapture;
-    /* IAudioNotifyFromHost */
-    pThis->IAudioNotifyFromHost.pfnNotifyDeviceChanged          = drvAudioNotifyFromHost_NotifyDeviceChanged;
-    pThis->IAudioNotifyFromHost.pfnStreamNotifyDeviceChanged    = drvAudioNotifyFromHost_StreamNotifyDeviceChanged;
-    pThis->IAudioNotifyFromHost.pfnNotifyDevicesChanged         = drvAudioNotifyFromHost_NotifyDevicesChanged;
+    /* IHostAudioPort */
+    pThis->IHostAudioPort.pfnDoOnWorkerThread           = drvAudioHostPort_DoOnWorkerThread;
+    pThis->IHostAudioPort.pfnNotifyDeviceChanged        = drvAudioHostPort_NotifyDeviceChanged;
+    pThis->IHostAudioPort.pfnStreamNotifyDeviceChanged  = drvAudioHostPort_StreamNotifyDeviceChanged;
+    pThis->IHostAudioPort.pfnNotifyDevicesChanged       = drvAudioHostPort_NotifyDevicesChanged;
 
     /*

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

@@ -1408 +1408 @@
     pThis->IHostAudio.pfnGetDevices                 = drvHostAlsaAudioHA_GetDevices;
     pThis->IHostAudio.pfnGetStatus                  = drvHostAlsaAudioHA_GetStatus;
+    pThis->IHostAudio.pfnDoOnWorkerThread           = NULL;
+    pThis->IHostAudio.pfnStreamConfigHint           = NULL;
     pThis->IHostAudio.pfnStreamCreate               = drvHostAlsaAudioHA_StreamCreate;
+    pThis->IHostAudio.pfnStreamInitAsync            = NULL;
     pThis->IHostAudio.pfnStreamDestroy              = drvHostAlsaAudioHA_StreamDestroy;
     pThis->IHostAudio.pfnStreamNotifyDeviceChanged  = NULL;

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

@@ -2547 +2547 @@
     pThis->IHostAudio.pfnGetConfig                  = drvHostCoreAudioHA_GetConfig;
     pThis->IHostAudio.pfnGetStatus                  = drvHostCoreAudioHA_GetStatus;
+    pThis->IHostAudio.pfnDoOnWorkerThread           = NULL;
+    pThis->IHostAudio.pfnStreamConfigHint           = NULL;
     pThis->IHostAudio.pfnStreamCreate               = drvHostCoreAudioHA_StreamCreate;
+    pThis->IHostAudio.pfnStreamInitAsync            = NULL;
     pThis->IHostAudio.pfnStreamDestroy              = drvHostCoreAudioHA_StreamDestroy;
     pThis->IHostAudio.pfnStreamNotifyDeviceChanged  = NULL;

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

@@ -2761 +2761 @@
     pThis->IHostAudio.pfnGetDevices                 = drvHostDSoundHA_GetDevices;
     pThis->IHostAudio.pfnGetStatus                  = drvHostDSoundHA_GetStatus;
+    pThis->IHostAudio.pfnDoOnWorkerThread           = NULL;
+    pThis->IHostAudio.pfnStreamConfigHint           = NULL;
     pThis->IHostAudio.pfnStreamCreate               = drvHostDSoundHA_StreamCreate;
+    pThis->IHostAudio.pfnStreamInitAsync            = NULL;
     pThis->IHostAudio.pfnStreamDestroy              = drvHostDSoundHA_StreamDestroy;
     pThis->IHostAudio.pfnStreamNotifyDeviceChanged  = NULL;
@@ -2801 +2804 @@
         /* Get the notification interface (from DrvAudio). */
 # ifdef VBOX_WITH_AUDIO_CALLBACKS
-        PPDMIAUDIONOTIFYFROMHOST pIAudioNotifyFromHost = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIAUDIONOTIFYFROMHOST);
-        Assert(pIAudioNotifyFromHost);
+        PPDMIHOSTAUDIOPORT pIHostAudioPort = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIHOSTAUDIOPORT);
+        Assert(pIHostAudioPort);
 # else
-        PPDMIAUDIONOTIFYFROMHOST pIAudioNotifyFromHost = NULL;
+        PPDMIHOSTAUDIOPORT pIHostAudioPort = NULL;
 # endif
         try
         {
-            pThis->m_pNotificationClient = new DrvHostAudioDSoundMMNotifClient(pIAudioNotifyFromHost);
+            pThis->m_pNotificationClient = new DrvHostAudioDSoundMMNotifClient(pIHostAudioPort);
         }
         catch (std::bad_alloc &)

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

@@ -30 +30 @@
 
 
-DrvHostAudioDSoundMMNotifClient::DrvHostAudioDSoundMMNotifClient(PPDMIAUDIONOTIFYFROMHOST pInterface)
+DrvHostAudioDSoundMMNotifClient::DrvHostAudioDSoundMMNotifClient(PPDMIHOSTAUDIOPORT pInterface)
     : m_fRegisteredClient(false)
     , m_cRef(1)

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

@@ -43 +43 @@
 public:
 
-    DrvHostAudioDSoundMMNotifClient(PPDMIAUDIONOTIFYFROMHOST pInterface);
+    DrvHostAudioDSoundMMNotifClient(PPDMIHOSTAUDIOPORT pInterface);
     virtual ~DrvHostAudioDSoundMMNotifClient();
 
@@ -64 +64 @@
     long                        m_cRef;
 
-    PPDMIAUDIONOTIFYFROMHOST    m_pIAudioNotifyFromHost;
+    PPDMIHOSTAUDIOPORT           m_pIAudioNotifyFromHost;
 
     HRESULT AttachToDefaultEndpoint();

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

@@ -438 +438 @@
     pThis->IHostAudio.pfnGetDevices                 = NULL;
     pThis->IHostAudio.pfnGetStatus                  = drvHostDebugAudioHA_GetStatus;
+    pThis->IHostAudio.pfnDoOnWorkerThread           = NULL;
+    pThis->IHostAudio.pfnStreamConfigHint           = NULL;
     pThis->IHostAudio.pfnStreamCreate               = drvHostDebugAudioHA_StreamCreate;
+    pThis->IHostAudio.pfnStreamInitAsync            = NULL;
     pThis->IHostAudio.pfnStreamDestroy              = drvHostDebugAudioHA_StreamDestroy;
     pThis->IHostAudio.pfnStreamNotifyDeviceChanged  = NULL;

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

@@ -232 +232 @@
     /* .pfnGetDevices                =*/ NULL,
     /* .pfnGetStatus                 =*/ drvHostNullAudioHA_GetStatus,
+    /* .pfnDoOnWorkerThread          =*/ NULL,
     /* .pfnStreamConfigHint          =*/ NULL,
     /* .pfnStreamCreate              =*/ drvHostNullAudioHA_StreamCreate,
+    /* .pfnStreamInitAsync           =*/ NULL,
     /* .pfnStreamDestroy             =*/ drvHostNullAudioHA_StreamDestroy,
     /* .pfnStreamNotifyDeviceChanged =*/ NULL,

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

@@ -861 +861 @@
     pThis->IHostAudio.pfnGetDevices                 = NULL;
     pThis->IHostAudio.pfnGetStatus                  = drvHostOssAudioHA_GetStatus;
+    pThis->IHostAudio.pfnDoOnWorkerThread           = NULL;
+    pThis->IHostAudio.pfnStreamConfigHint           = NULL;
     pThis->IHostAudio.pfnStreamCreate               = drvHostOssAudioHA_StreamCreate;
+    pThis->IHostAudio.pfnStreamInitAsync            = NULL;
     pThis->IHostAudio.pfnStreamDestroy              = drvHostOssAudioHA_StreamDestroy;
     pThis->IHostAudio.pfnStreamNotifyDeviceChanged  = NULL;

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

@@ -1915 +1915 @@
     pThis->IHostAudio.pfnGetDevices                 = drvHostAudioPaHA_GetDevices;
     pThis->IHostAudio.pfnGetStatus                  = drvHostAudioPaHA_GetStatus;
+    pThis->IHostAudio.pfnDoOnWorkerThread           = NULL;
+    pThis->IHostAudio.pfnStreamConfigHint           = NULL;
     pThis->IHostAudio.pfnStreamCreate               = drvHostAudioPaHA_StreamCreate;
+    pThis->IHostAudio.pfnStreamInitAsync            = NULL;
     pThis->IHostAudio.pfnStreamDestroy              = drvHostAudioPaHA_StreamDestroy;
     pThis->IHostAudio.pfnStreamNotifyDeviceChanged  = NULL;

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

@@ -435 +435 @@
     pThis->IHostAudio.pfnGetDevices                 = NULL;
     pThis->IHostAudio.pfnGetStatus                  = drvHostValKitAudioHA_GetStatus;
+    pThis->IHostAudio.pfnDoOnWorkerThread           = NULL;
+    pThis->IHostAudio.pfnStreamConfigHint           = NULL;
     pThis->IHostAudio.pfnStreamCreate               = drvHostValKitAudioHA_StreamCreate;
+    pThis->IHostAudio.pfnStreamInitAsync            = NULL;
     pThis->IHostAudio.pfnStreamDestroy              = drvHostValKitAudioHA_StreamDestroy;
     pThis->IHostAudio.pfnStreamNotifyDeviceChanged  = NULL;

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

@@ -53 +53 @@
 #define VBOX_WASAPI_MAX_PADDING         UINT32_C(0x007fffff)
 
+#if 0
 /** @name WM_DRVHOSTAUDIOWAS_XXX - Worker thread messages.
  * @{ */
-/** Adds entry to the cache.
- * lParam points to a PDMAUDIOSTREAMCFG structure with the details. RTMemFree
- * when done. */
-#define WM_DRVHOSTAUDIOWAS_HINT         (WM_APP + 2)
-#define WM_DRVHOSTAUDIOWAS_PURGE_CACHE  (WM_APP + 1)
+#define WM_DRVHOSTAUDIOWAS_PURGE_CACHE  (WM_APP + 3)
+/** @} */
+#endif
+
+
+/** @name DRVHOSTAUDIOWAS_DO_XXX - Worker thread operations.
+ * @{ */
+#define DRVHOSTAUDIOWAS_DO_PURGE_CACHE      ((uintptr_t)0x49f37300 + 1)
 /** @} */
 
@@ -100 +104 @@
     /** The device/whatever period in frames. */
     uint32_t                    cFramesPeriod;
+    /** The setup status code.
+     * This is set to VERR_AUDIO_STREAM_INIT_IN_PROGRESS while the asynchronous
+     * initialization is still running. */
+    int volatile                rcSetup;
+    /** Creation timestamp (just for reference). */
+    uint64_t                    nsCreated;
+    /** Init complete timestamp (just for reference). */
+    uint64_t                    nsInited;
     /** The stringified properties. */
     char                        szProps[32];
@@ -207 +219 @@
      * implementing enumeration. */
     IMMDeviceEnumerator            *pIEnumerator;
-    /** Notification interface.   */
-    PPDMIAUDIONOTIFYFROMHOST        pIAudioNotifyFromHost;
+    /** The upwards interface. */
+    PPDMIHOSTAUDIOPORT              pIHostAudioPort;
     /** The output device ID, NULL for default. */
     PRTUTF16                        pwszOutputDevId;
@@ -240 +252 @@
     RTCRITSECT                      CritSectCache;
 
+#if 0
     /** The worker thread. */
     RTTHREAD                        hWorkerThread;
@@ -246 +259 @@
     /** The fixed wParam value for the worker thread. */
     WPARAM                          uWorkerThreadFixedParam;
-
+#endif
 } DRVHOSTAUDIOWAS;
 /** Pointer to the data for a WASAPI host audio driver instance. */
@@ -273 +286 @@
     static RTSTRTUPLE const s_aStarted[2] =
     {
-        RT_STR_TUPLE(" STARTED"),
-        RT_STR_TUPLE(" STOPPED")
+        RT_STR_TUPLE(" STOPPED"),
+        RT_STR_TUPLE(" STARTED")
     };
     pTuple = &s_aStarted[pStreamWas->fStarted];
@@ -549 +562 @@
  * Converts from PDM stream config to windows WAVEFORMATEX struct.
  *
- * @param   pCfg    The PDM audio stream config to convert from.
+ * @param   pProps  The PDM audio PCM properties to convert from.
  * @param   pFmt    The windows structure to initialize.
  */
-static void drvHostAudioWasWaveFmtExFromCfg(PCPDMAUDIOSTREAMCFG pCfg, PWAVEFORMATEX pFmt)
+static void drvHostAudioWasWaveFmtExFromProps(PCPDMAUDIOPCMPROPS pProps, PWAVEFORMATEX pFmt)
 {
     RT_ZERO(*pFmt);
     pFmt->wFormatTag      = WAVE_FORMAT_PCM;
-    pFmt->nChannels       = PDMAudioPropsChannels(&pCfg->Props);
-    pFmt->wBitsPerSample  = PDMAudioPropsSampleBits(&pCfg->Props);
-    pFmt->nSamplesPerSec  = PDMAudioPropsHz(&pCfg->Props);
-    pFmt->nBlockAlign     = PDMAudioPropsFrameSize(&pCfg->Props);
-    pFmt->nAvgBytesPerSec = PDMAudioPropsFramesToBytes(&pCfg->Props, PDMAudioPropsHz(&pCfg->Props));
+    pFmt->nChannels       = PDMAudioPropsChannels(pProps);
+    pFmt->wBitsPerSample  = PDMAudioPropsSampleBits(pProps);
+    pFmt->nSamplesPerSec  = PDMAudioPropsHz(pProps);
+    pFmt->nBlockAlign     = PDMAudioPropsFrameSize(pProps);
+    pFmt->nAvgBytesPerSec = PDMAudioPropsFramesToBytes(pProps, PDMAudioPropsHz(pProps));
     pFmt->cbSize          = 0; /* No extra data specified. */
 }
 
 
+#if 0 /* unused */
 /**
  * Converts from windows WAVEFORMATEX and stream props to PDM audio properties.
@@ -607 +621 @@
     return VERR_AUDIO_STREAM_COULD_NOT_CREATE;
 }
+#endif
 
 
@@ -714 +729 @@
 }
 
-/**
- * Creates a device config entry using the given parameters.
+
+/**
+ * Initializes a device config entry.
  *
- * The entry is not added to the cache but returned.
+ * This is usually done on the worker thread.
  *
- * @returns Pointer to the new device config entry. NULL on failure.
- * @param   pDevEntry       The device entry it belongs to.
- * @param   pCfgReq         The requested configuration.
- * @param   pWaveFmtEx      The actual configuration.
- * @param   pIAudioClient   The audio client, reference consumed.
- */
-static PDRVHOSTAUDIOWASCACHEDEVCFG
-drvHostAudioWasCacheCreateConfig(PDRVHOSTAUDIOWASCACHEDEV pDevEntry, PCPDMAUDIOSTREAMCFG pCfgReq,
-                                 WAVEFORMATEX const *pWaveFmtEx, IAudioClient *pIAudioClient)
-{
-    PDRVHOSTAUDIOWASCACHEDEVCFG pDevCfg = (PDRVHOSTAUDIOWASCACHEDEVCFG)RTMemAllocZ(sizeof(*pDevCfg));
-    if (pDevCfg)
-    {
-        RTListInit(&pDevCfg->ListEntry);
-        pDevCfg->pDevEntry          = pDevEntry;
-        pDevCfg->pIAudioClient      = pIAudioClient;
-        HRESULT hrc;
-        if (pCfgReq->enmDir == PDMAUDIODIR_IN)
-            hrc = pIAudioClient->GetService(__uuidof(IAudioCaptureClient), (void **)&pDevCfg->pIAudioCaptureClient);
-        else
-            hrc = pIAudioClient->GetService(__uuidof(IAudioRenderClient), (void **)&pDevCfg->pIAudioRenderClient);
-        Log8Func(("GetService -> %Rhrc + %p\n", hrc, pCfgReq->enmDir == PDMAUDIODIR_IN
-                  ? (void *)pDevCfg->pIAudioCaptureClient : (void *)pDevCfg->pIAudioRenderClient));
-        if (SUCCEEDED(hrc))
-        {
-            /*
-             * Obtain the actual stream format and buffer config.
-             * (A bit ugly structure here to keep it from hitting the right margin. Sorry.)
-             */
-            UINT32          cFramesBufferSize       = 0;
-            REFERENCE_TIME  cDefaultPeriodInNtTicks = 0;
-            REFERENCE_TIME  cMinimumPeriodInNtTicks = 0;
-            REFERENCE_TIME  cLatencyinNtTicks       = 0;
-            hrc = pIAudioClient->GetBufferSize(&cFramesBufferSize);
-            if (SUCCEEDED(hrc))
-                hrc = pIAudioClient->GetDevicePeriod(&cDefaultPeriodInNtTicks, &cMinimumPeriodInNtTicks);
-            else
-                LogRelMax(64, ("WasAPI: GetBufferSize failed: %Rhrc\n", hrc));
-            if (SUCCEEDED(hrc))
-                hrc = pIAudioClient->GetStreamLatency(&cLatencyinNtTicks);
-            else
-                LogRelMax(64, ("WasAPI: GetDevicePeriod failed: %Rhrc\n", hrc));
-            if (SUCCEEDED(hrc))
-            {
-                LogRel2(("WasAPI: Aquired buffer parameters for %s:\n"
-                         "WasAPI:   cFramesBufferSize       = %RU32\n"
-                         "WasAPI:   cDefaultPeriodInNtTicks = %RI64\n"
-                         "WasAPI:   cMinimumPeriodInNtTicks = %RI64\n"
-                         "WasAPI:   cLatencyinNtTicks       = %RI64\n",
-                         pCfgReq->szName, cFramesBufferSize, cDefaultPeriodInNtTicks, cMinimumPeriodInNtTicks, cLatencyinNtTicks));
-
-                int rc = drvHostAudioWasCacheWaveFmtExToProps(&pDevCfg->Props, pWaveFmtEx, pCfgReq->szName, pDevEntry->wszDevId);
-                if (RT_SUCCESS(rc))
-                {
-                    pDevCfg->cFramesBufferSize = cFramesBufferSize;
-                    pDevCfg->cFramesPeriod     = PDMAudioPropsNanoToFrames(&pDevCfg->Props, cDefaultPeriodInNtTicks * 100);
-
-                    PDMAudioPropsToString(&pDevCfg->Props, pDevCfg->szProps, sizeof(pDevCfg->szProps));
-                    return pDevCfg;
-                }
-            }
-            else
-                LogRelMax(64, ("WasAPI: GetStreamLatency failed: %Rhrc\n", hrc));
-
-            if (pDevCfg->pIAudioCaptureClient)
-            {
-                pDevCfg->pIAudioCaptureClient->Release();
-                pDevCfg->pIAudioCaptureClient = NULL;
-            }
-
-            if (pDevCfg->pIAudioRenderClient)
-            {
-                pDevCfg->pIAudioRenderClient->Release();
-                pDevCfg->pIAudioRenderClient = NULL;
-            }
-        }
-        RTMemFree(pDevCfg);
-    }
-    pIAudioClient->Release();
-    return NULL;
-}
-
-
-/**
- * Worker for drvHostAudioWasCacheLookupOrCreate.
- *
- * If lookup fails, a new entry will be created.
- *
- * @note    Called holding the lock, returning without holding it!
- */
-static PDRVHOSTAUDIOWASCACHEDEVCFG
-drvHostAudioWasCacheLookupOrCreateConfig(PDRVHOSTAUDIOWAS pThis, PDRVHOSTAUDIOWASCACHEDEV pDevEntry, PCPDMAUDIOSTREAMCFG pCfgReq)
-{
-    char szProps[64];
-    PDMAudioPropsToString(&pCfgReq->Props, szProps, sizeof(szProps));
-
-    /*
-     * Check if we've got a matching config.
-     */
-    PDRVHOSTAUDIOWASCACHEDEVCFG pDevCfg = drvHostAudioWasCacheLookupLocked(pDevEntry, &pCfgReq->Props);
-    if (pDevCfg)
-    {
-        RTCritSectLeave(&pThis->CritSectCache);
-        Log8Func(("Config cache hit '%s' (for '%s') on '%ls': %p\n", pDevCfg->szProps, szProps, pDevEntry->wszDevId, pDevCfg));
-        return pDevCfg;
-    }
-
-    /*
-     * We now need an IAudioClient interface for calling IsFormatSupported
+ * @returns VBox status code.
+ * @param   pDevCfg         The device configuration entry to initialize.
+ */
+static int drvHostAudioWasCacheInitConfig(PDRVHOSTAUDIOWASCACHEDEVCFG pDevCfg)
+{
+    /*
+     * Assert some sanity given that we migth be called on the worker thread
+     * and pDevCfg being a message parameter.
+     */
+    AssertPtrReturn(pDevCfg, VERR_INTERNAL_ERROR_2);
+    AssertReturn(pDevCfg->rcSetup == VERR_AUDIO_STREAM_INIT_IN_PROGRESS, VERR_INTERNAL_ERROR_2);
+    AssertReturn(pDevCfg->pIAudioClient == NULL, VERR_INTERNAL_ERROR_2);
+    AssertReturn(pDevCfg->pIAudioCaptureClient == NULL, VERR_INTERNAL_ERROR_2);
+    AssertReturn(pDevCfg->pIAudioRenderClient == NULL, VERR_INTERNAL_ERROR_2);
+    AssertReturn(PDMAudioPropsAreValid(&pDevCfg->Props), VERR_INTERNAL_ERROR_2);
+
+    PDRVHOSTAUDIOWASCACHEDEV pDevEntry = pDevCfg->pDevEntry;
+    AssertPtrReturn(pDevEntry, VERR_INTERNAL_ERROR_2);
+    AssertPtrReturn(pDevEntry->pIDevice, VERR_INTERNAL_ERROR_2);
+    AssertReturn(pDevEntry->enmDir == PDMAUDIODIR_IN || pDevEntry->enmDir == PDMAUDIODIR_OUT, VERR_INTERNAL_ERROR_2);
+
+    /*
+     * First we need an IAudioClient interface for calling IsFormatSupported
      * on so we can get guidance as to what to do next.
      *
@@ -835 +765 @@
      * https://social.msdn.microsoft.com/Forums/en-US/1d974d90-6636-4121-bba3-a8861d9ab92a
      * it is supported, just maybe missing from the SDK or something...
-     */
-    RTCritSectLeave(&pThis->CritSectCache);
-
-    REFERENCE_TIME const cBufferSizeInNtTicks = PDMAudioPropsFramesToNtTicks(&pCfgReq->Props, pCfgReq->Backend.cFramesBufferSize);
-
+     *
+     * I'll leave the IsFormatSupported call here as it gives us a clue as to
+     * what exactly the WAS needs to convert our audio stream into/from.
+     */
     Log8Func(("Activating an IAudioClient for '%ls' ...\n", pDevEntry->wszDevId));
     IAudioClient *pIAudioClient = NULL;
@@ -848 +777 @@
     {
         LogRelMax(64, ("WasAPI: Activate(%ls, IAudioClient) failed: %Rhrc\n", pDevEntry->wszDevId, hrc));
-        return NULL;
+        pDevCfg->nsInited = RTTimeNanoTS();
+        return pDevCfg->rcSetup = VERR_AUDIO_STREAM_COULD_NOT_CREATE;
     }
 
     WAVEFORMATEX  WaveFmtEx;
-    drvHostAudioWasWaveFmtExFromCfg(pCfgReq, &WaveFmtEx);
+    drvHostAudioWasWaveFmtExFromProps(&pDevCfg->Props, &WaveFmtEx);
 
     PWAVEFORMATEX pClosestMatch = NULL;
@@ -858 +788 @@
 
     /*
-     * If the format is supported, create a cache entry for it.
+     * If the format is supported, go ahead and initialize the client instance.
      */
     if (SUCCEEDED(hrc))
     {
         if (hrc == S_OK)
-            Log8Func(("IsFormatSupport(,%s,) -> S_OK + %p: requested format is supported\n", szProps, pClosestMatch));
+            Log8Func(("IsFormatSupport(,%s,) -> S_OK + %p: requested format is supported\n", pDevCfg->szProps, pClosestMatch));
         else
-            Log8Func(("IsFormatSupport(,%s,) -> %Rhrc + %p: %uch S%u %uHz\n", szProps, hrc, pClosestMatch,
+            Log8Func(("IsFormatSupport(,%s,) -> %Rhrc + %p: %uch S%u %uHz\n", pDevCfg->szProps, hrc, pClosestMatch,
                       pClosestMatch ? pClosestMatch->nChannels : 0, pClosestMatch ? pClosestMatch->wBitsPerSample : 0,
                       pClosestMatch ? pClosestMatch->nSamplesPerSec : 0));
 
-        uint32_t fInitFlags = AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM
-                            | AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY;
+        REFERENCE_TIME const cBufferSizeInNtTicks = PDMAudioPropsFramesToNtTicks(&pDevCfg->Props, pDevCfg->cFramesBufferSize);
+        uint32_t             fInitFlags           = AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM
+                                                  | AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY;
         hrc = pIAudioClient->Initialize(AUDCLNT_SHAREMODE_SHARED, fInitFlags, cBufferSizeInNtTicks,
                                         0 /*cPeriodicityInNtTicks*/, &WaveFmtEx, NULL /*pAudioSessionGuid*/);
-        Log8Func(("Initialize(,%x, %RI64, %s,) -> %Rhrc\n", fInitFlags, cBufferSizeInNtTicks, szProps, hrc));
+        Log8Func(("Initialize(,%x, %RI64, %s,) -> %Rhrc\n", fInitFlags, cBufferSizeInNtTicks, pDevCfg->szProps, hrc));
         if (SUCCEEDED(hrc))
         {
-            if (pClosestMatch)
-                CoTaskMemFree(pClosestMatch);
-            Log8Func(("Creating new config for '%s' on '%ls': %p\n", szProps, pDevEntry->wszDevId, pDevCfg));
-            return drvHostAudioWasCacheCreateConfig(pDevEntry, pCfgReq, &WaveFmtEx, pIAudioClient);
-        }
-
-        LogRelMax(64, ("WasAPI: IAudioClient::Initialize(%s: %s) failed: %Rhrc\n", pCfgReq->szName, szProps, hrc));
-
-#if 0 /* later if needed */
-        /*
-         * Try lookup or instantiate the closest config.
-         */
-        PDMAUDIOSTREAMCFG ClosestCfg = *pCfgReq;
-        int rc = drvHostAudioWasCacheWaveFmtExToProps(&ClosestCfg.Props, pClosestMatch, pDevEntry->wszDevId);
-        if (RT_SUCCESS(rc))
-        {
-            RTCritSectEnter(&pThis->CritSectCache);
-            pDevCfg = drvHostAudioWasCacheLookupLocked(pDevEntry, &pCfgReq->Props);
-            if (pDevCfg)
+            /*
+             * The direction specific client interface.
+             */
+            if (pDevEntry->enmDir == PDMAUDIODIR_IN)
+                hrc = pIAudioClient->GetService(__uuidof(IAudioCaptureClient), (void **)&pDevCfg->pIAudioCaptureClient);
+            else
+                hrc = pIAudioClient->GetService(__uuidof(IAudioRenderClient), (void **)&pDevCfg->pIAudioRenderClient);
+            Log8Func(("GetService -> %Rhrc + %p\n", hrc, pDevEntry->enmDir == PDMAUDIODIR_IN
+                      ? (void *)pDevCfg->pIAudioCaptureClient : (void *)pDevCfg->pIAudioRenderClient));
+            if (SUCCEEDED(hrc))
             {
-                CoTaskMemFree(pClosestMatch);
-                Log8Func(("Config cache hit '%s' (for '%s') on '%ls': %p\n", pDevCfg->szProps, szProps, pDevEntry->wszDevId, pDevCfg));
-                return pDevCfg;
+                /*
+                 * Obtain the actual stream format and buffer config.
+                 */
+                UINT32          cFramesBufferSize       = 0;
+                REFERENCE_TIME  cDefaultPeriodInNtTicks = 0;
+                REFERENCE_TIME  cMinimumPeriodInNtTicks = 0;
+                REFERENCE_TIME  cLatencyinNtTicks       = 0;
+                hrc = pIAudioClient->GetBufferSize(&cFramesBufferSize);
+                if (SUCCEEDED(hrc))
+                {
+                    hrc = pIAudioClient->GetDevicePeriod(&cDefaultPeriodInNtTicks, &cMinimumPeriodInNtTicks);
+                    if (SUCCEEDED(hrc))
+                    {
+                        hrc = pIAudioClient->GetStreamLatency(&cLatencyinNtTicks);
+                        if (SUCCEEDED(hrc))
+                        {
+                            LogRel2(("WasAPI: Aquired buffer parameters for %s:\n"
+                                     "WasAPI:   cFramesBufferSize       = %RU32\n"
+                                     "WasAPI:   cDefaultPeriodInNtTicks = %RI64\n"
+                                     "WasAPI:   cMinimumPeriodInNtTicks = %RI64\n"
+                                     "WasAPI:   cLatencyinNtTicks       = %RI64\n",
+                                     pDevCfg->szProps, cFramesBufferSize, cDefaultPeriodInNtTicks,
+                                     cMinimumPeriodInNtTicks, cLatencyinNtTicks));
+
+                            pDevCfg->pIAudioClient      = pIAudioClient;
+                            pDevCfg->cFramesBufferSize  = cFramesBufferSize;
+                            pDevCfg->cFramesPeriod      = PDMAudioPropsNanoToFrames(&pDevCfg->Props,
+                                                                                    cDefaultPeriodInNtTicks * 100);
+                            pDevCfg->nsInited           = RTTimeNanoTS();
+                            pDevCfg->rcSetup            = VINF_SUCCESS;
+
+                            if (pClosestMatch)
+                                CoTaskMemFree(pClosestMatch);
+                            Log8Func(("returns VINF_SUCCESS (%p (%s) inited in %'RU64 ns)\n",
+                                      pDevCfg, pDevCfg->szProps, pDevCfg->nsInited - pDevCfg->nsCreated));
+                            return VINF_SUCCESS;
+                        }
+                        LogRelMax(64, ("WasAPI: GetStreamLatency failed: %Rhrc\n", hrc));
+                    }
+                    else
+                        LogRelMax(64, ("WasAPI: GetDevicePeriod failed: %Rhrc\n", hrc));
+                }
+                else
+                    LogRelMax(64, ("WasAPI: GetBufferSize failed: %Rhrc\n", hrc));
+
+                if (pDevCfg->pIAudioCaptureClient)
+                {
+                    pDevCfg->pIAudioCaptureClient->Release();
+                    pDevCfg->pIAudioCaptureClient = NULL;
+                }
+
+                if (pDevCfg->pIAudioRenderClient)
+                {
+                    pDevCfg->pIAudioRenderClient->Release();
+                    pDevCfg->pIAudioRenderClient = NULL;
+                }
             }
-            RTCritSectLeave(&pThis->CritSectCache);
-        }
-#endif
+            else
+                LogRelMax(64, ("WasAPI: IAudioClient::GetService(%s) failed: %Rhrc\n", pDevCfg->szProps, hrc));
+        }
+        else
+            LogRelMax(64, ("WasAPI: IAudioClient::Initialize(%s) failed: %Rhrc\n", pDevCfg->szProps, hrc));
     }
     else
-        LogRelMax(64,("WasAPI: IAudioClient::IsFormatSupport(,%s: %s,) failed: %Rhrc\n", pCfgReq->szName, szProps, hrc));
+        LogRelMax(64,("WasAPI: IAudioClient::IsFormatSupport(,%s,) failed: %Rhrc\n", pDevCfg->szProps, hrc));
 
     pIAudioClient->Release();
     if (pClosestMatch)
         CoTaskMemFree(pClosestMatch);
-    Log8Func(("returns NULL\n"));
-    return NULL;
+    pDevCfg->nsInited = RTTimeNanoTS();
+    Log8Func(("returns VERR_AUDIO_STREAM_COULD_NOT_CREATE (inited in %'RU64 ns)\n", pDevCfg->nsInited - pDevCfg->nsCreated));
+    return pDevCfg->rcSetup = VERR_AUDIO_STREAM_COULD_NOT_CREATE;
+}
+
+
+/**
+ * Worker for drvHostAudioWasCacheLookupOrCreate.
+ *
+ * If lookup fails, a new entry will be created.
+ *
+ * @note    Called holding the lock, returning without holding it!
+ */
+static int drvHostAudioWasCacheLookupOrCreateConfig(PDRVHOSTAUDIOWAS pThis, PDRVHOSTAUDIOWASCACHEDEV pDevEntry,
+                                                    PCPDMAUDIOSTREAMCFG pCfgReq, bool fOnWorker,
+                                                    PDRVHOSTAUDIOWASCACHEDEVCFG *ppDevCfg)
+{
+    /*
+     * Check if we've got a matching config.
+     */
+    PDRVHOSTAUDIOWASCACHEDEVCFG pDevCfg = drvHostAudioWasCacheLookupLocked(pDevEntry, &pCfgReq->Props);
+    if (pDevCfg)
+    {
+        *ppDevCfg = pDevCfg;
+        RTCritSectLeave(&pThis->CritSectCache);
+        Log8Func(("Config cache hit '%s' on '%ls': %p\n", pDevCfg->szProps, pDevEntry->wszDevId, pDevCfg));
+        return VINF_SUCCESS;
+    }
+
+    RTCritSectLeave(&pThis->CritSectCache);
+
+    /*
+     * Allocate an device config entry and hand the creation task over to the
+     * worker thread, unless we're already on it.
+     */
+    pDevCfg = (PDRVHOSTAUDIOWASCACHEDEVCFG)RTMemAllocZ(sizeof(*pDevCfg));
+    AssertReturn(pDevCfg, VERR_NO_MEMORY);
+    RTListInit(&pDevCfg->ListEntry);
+    pDevCfg->pDevEntry         = pDevEntry;
+    pDevCfg->rcSetup           = VERR_AUDIO_STREAM_INIT_IN_PROGRESS;
+    pDevCfg->Props             = pCfgReq->Props;
+    pDevCfg->cFramesBufferSize = pCfgReq->Backend.cFramesBufferSize;
+    PDMAudioPropsToString(&pDevCfg->Props, pDevCfg->szProps, sizeof(pDevCfg->szProps));
+    pDevCfg->nsCreated         = RTTimeNanoTS();
+
+    if (!fOnWorker)
+    {
+        *ppDevCfg = pDevCfg;
+        LogFlowFunc(("Doing the rest of the work on %p via pfnStreamInitAsync...\n", pDevCfg));
+        return VINF_AUDIO_STREAM_ASYNC_INIT_NEEDED;
+    }
+
+    /*
+     * Initialize the entry on the calling thread.
+     */
+    int rc = drvHostAudioWasCacheInitConfig(pDevCfg);
+    AssertRC(pDevCfg->rcSetup == rc);
+    if (RT_SUCCESS(rc))
+        rc = pDevCfg->rcSetup; /* paranoia */
+    if (RT_SUCCESS(rc))
+    {
+        *ppDevCfg = pDevCfg;
+        LogFlowFunc(("Returning %p\n", pDevCfg));
+        return VINF_SUCCESS;
+    }
+    RTMemFree(pDevCfg);
+    *ppDevCfg = NULL;
+    return rc;
 }
 
@@ -919 +962 @@
  * if missing.
  *
- * @returns Pointer to the requested device config (or closest alternative).
- *          NULL on failure (TODO: need to return why).
+ * @returns VBox status code.
  * @param   pThis       The WASAPI host audio driver instance data.
  * @param   pIDevice    The device to look up.
  * @param   pCfgReq     The configuration to look up.
- */
-static PDRVHOSTAUDIOWASCACHEDEVCFG
-drvHostAudioWasCacheLookupOrCreate(PDRVHOSTAUDIOWAS pThis, IMMDevice *pIDevice, PCPDMAUDIOSTREAMCFG pCfgReq)
-{
+ * @param   fOnWorker   Set if we're on a worker thread, otherwise false.
+ * @param   ppDevCfg    Where to return the requested device config.
+ */
+static int drvHostAudioWasCacheLookupOrCreate(PDRVHOSTAUDIOWAS pThis, IMMDevice *pIDevice, PCPDMAUDIOSTREAMCFG pCfgReq,
+                                              bool fOnWorker, PDRVHOSTAUDIOWASCACHEDEVCFG *ppDevCfg)
+{
+    *ppDevCfg = NULL;
+
     /*
      * Get the device ID so we can perform the lookup.
      */
+    int     rc        = VERR_AUDIO_STREAM_COULD_NOT_CREATE;
     LPWSTR  pwszDevId = NULL;
     HRESULT hrc = pIDevice->GetId(&pwszDevId);
@@ -950 +997 @@
                 CoTaskMemFree(pwszDevId);
                 Log8Func(("Cache hit for device '%ls': %p\n", pDevEntry->wszDevId, pDevEntry));
-                return drvHostAudioWasCacheLookupOrCreateConfig(pThis, pDevEntry, pCfgReq);
+                return drvHostAudioWasCacheLookupOrCreateConfig(pThis, pDevEntry, pCfgReq, fOnWorker, ppDevCfg);
             }
         }
@@ -992 +1039 @@
 
                     Log8Func(("Lost race adding device '%ls': %p\n", pDevEntry2->wszDevId, pDevEntry2));
-                    return drvHostAudioWasCacheLookupOrCreateConfig(pThis, pDevEntry2, pCfgReq);
+                    return drvHostAudioWasCacheLookupOrCreateConfig(pThis, pDevEntry2, pCfgReq, fOnWorker, ppDevCfg);
                 }
             }
@@ -998 +1045 @@
 
             Log8Func(("Added device '%ls' to cache: %p\n", pDevEntry->wszDevId, pDevEntry));
-            return drvHostAudioWasCacheLookupOrCreateConfig(pThis, pDevEntry, pCfgReq);
+            return drvHostAudioWasCacheLookupOrCreateConfig(pThis, pDevEntry, pCfgReq, fOnWorker, ppDevCfg);
         }
         CoTaskMemFree(pwszDevId);
@@ -1004 +1051 @@
     else
         LogRelMax(64, ("WasAPI: GetId failed (lookup): %Rhrc\n", hrc));
-    return NULL;
+    return rc;
 }
 
@@ -1019 +1066 @@
      * Reset the audio client to see that it works and to make sure it's in a sensible state.
      */
-    HRESULT hrc = pDevCfg->pIAudioClient->Reset();
+    HRESULT hrc = pDevCfg->pIAudioClient ? pDevCfg->pIAudioClient->Reset()
+                : pDevCfg->rcSetup == VERR_AUDIO_STREAM_INIT_IN_PROGRESS ? S_OK : E_FAIL;
     if (SUCCEEDED(hrc))
     {
@@ -1035 +1083 @@
 
 
-static void drvHostWasCacheConfigHinting(PDRVHOSTAUDIOWAS pThis, PPDMAUDIOSTREAMCFG pCfgReq)
+static void drvHostWasCacheConfigHinting(PDRVHOSTAUDIOWAS pThis, PPDMAUDIOSTREAMCFG pCfgReq, bool fOnWorker)
 {
     /*
@@ -1050 +1098 @@
          * Look up the config and put it back.
          */
-        PDRVHOSTAUDIOWASCACHEDEVCFG pDevCfg = drvHostAudioWasCacheLookupOrCreate(pThis, pIDevice, pCfgReq);
-        LogFlowFunc(("pDevCfg=%p\n"));
-        if (pDevCfg)
+        PDRVHOSTAUDIOWASCACHEDEVCFG pDevCfg = NULL;
+        int rc = drvHostAudioWasCacheLookupOrCreate(pThis, pIDevice, pCfgReq, fOnWorker, &pDevCfg);
+        LogFlowFunc(("pDevCfg=%p rc=%Rrc\n", pDevCfg, rc));
+        if (pDevCfg && RT_SUCCESS(rc))
             drvHostAudioWasCachePutBack(pThis, pDevCfg);
         pIDevice->Release();
@@ -1114 +1163 @@
 *   Worker thread                                                                                                                *
 *********************************************************************************************************************************/
+#if 0
 
 /**
@@ -1148 +1198 @@
             switch (Msg.message)
             {
-                case WM_DRVHOSTAUDIOWAS_HINT:
-                {
-                    AssertMsgBreak(Msg.wParam == pThis->uWorkerThreadFixedParam, ("%p\n", Msg.wParam));
-                    AssertBreak(Msg.hwnd == NULL);
-                    PPDMAUDIOSTREAMCFG pCfgReq = (PPDMAUDIOSTREAMCFG)Msg.lParam;
-                    AssertPtrBreak(pCfgReq);
-
-                    drvHostWasCacheConfigHinting(pThis, pCfgReq);
-                    RTMemFree(pCfgReq);
-                    break;
-                }
-
                 case WM_DRVHOSTAUDIOWAS_PURGE_CACHE:
                 {
@@ -1185 +1223 @@
     return VINF_SUCCESS;
 }
-
+#endif
 
 /*********************************************************************************************************************************
@@ -1206 +1244 @@
     RTStrCopy(pBackendCfg->szName, sizeof(pBackendCfg->szName), "WasAPI");
     pBackendCfg->cbStream       = sizeof(DRVHOSTAUDIOWASSTREAM);
-    pBackendCfg->fFlags         = 0;
+    pBackendCfg->fFlags         = PDMAUDIOBACKEND_F_ASYNC_HINT;
     pBackendCfg->cMaxStreamsIn  = UINT32_MAX;
     pBackendCfg->cMaxStreamsOut = UINT32_MAX;
@@ -1401 +1439 @@
 
 /**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnDoOnWorkerThread}
+ */
+static DECLCALLBACK(void) drvHostAudioWasHA_DoOnWorkerThread(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream,
+                                                             uintptr_t uUser, void *pvUser)
+{
+    PDRVHOSTAUDIOWAS pThis = RT_FROM_MEMBER(pInterface, DRVHOSTAUDIOWAS, IHostAudio);
+    RT_NOREF(pStream, pvUser);
+    LogFlowFunc(("uUser=%#zx pStream=%p pvUser=%p\n", uUser, pStream, pvUser));
+
+    switch (uUser)
+    {
+        case DRVHOSTAUDIOWAS_DO_PURGE_CACHE:
+            Assert(pStream == NULL);
+            Assert(pvUser == NULL);
+            drvHostAudioWasCachePurge(pThis);
+            break;
+
+        default:
+            AssertMsgFailedBreak(("%#zx\n", uUser));
+    }
+}
+
+
+/**
  * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamConfigHint}
+ *
+ * @note This is called on a DrvAudio worker thread.
  */
 static DECLCALLBACK(void) drvHostAudioWasHA_StreamConfigHint(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAMCFG pCfg)
 {
+#if 0 /* disable to test async stream creation. */
     PDRVHOSTAUDIOWAS pThis = RT_FROM_MEMBER(pInterface, DRVHOSTAUDIOWAS, IHostAudio);
     LogFlowFunc(("pCfg=%p\n", pCfg));
 
-    if (pThis->hWorkerThread != NIL_RTTHREAD)
-    {
-        PPDMAUDIOSTREAMCFG pCfgCopy = PDMAudioStrmCfgDup(pCfg);
-        if (pCfgCopy)
-        {
-            if (PostThreadMessageW(pThis->idWorkerThread, WM_DRVHOSTAUDIOWAS_HINT,
-                                   pThis->uWorkerThreadFixedParam, (LPARAM)pCfgCopy))
-                LogFlowFunc(("Posted %p to worker thread\n", pCfgCopy));
-            else
-            {
-                LogRelMax(64, ("WasAPI: PostThreadMessageW failed: %u\n", GetLastError()));
-                PDMAudioStrmCfgFree(pCfgCopy);
-            }
-        }
-    }
-    else
-        drvHostWasCacheConfigHinting(pThis, pCfg);
+    drvHostWasCacheConfigHinting(pThis, pCfg);
+#else
+    RT_NOREF(pInterface, pCfg);
+#endif
 }
 
@@ -1458 +1510 @@
      */
     WAVEFORMATEX WaveFmtX;
-    drvHostAudioWasWaveFmtExFromCfg(pCfgReq, &WaveFmtX);
+    drvHostAudioWasWaveFmtExFromProps(&pCfgReq->Props, &WaveFmtX);
     LogRel2(("WasAPI: Requested %s format for '%s':\n"
              "WasAPI:   wFormatTag      = %RU16\n"
@@ -1506 +1558 @@
     /** @todo make it return a status code too and retry if the default device
      *        was invalidated/changed while we where working on it here. */
-    int rc = VERR_AUDIO_STREAM_COULD_NOT_CREATE;
-    PDRVHOSTAUDIOWASCACHEDEVCFG pDevCfg = drvHostAudioWasCacheLookupOrCreate(pThis, pIDevice, pCfgReq);
+    PDRVHOSTAUDIOWASCACHEDEVCFG pDevCfg = NULL;
+    int rc = drvHostAudioWasCacheLookupOrCreate(pThis, pIDevice, pCfgReq, false /*fOnWorker*/, &pDevCfg);
 
     pIDevice->Release();
     pIDevice = NULL;
 
-    if (pDevCfg)
+    if (pDevCfg && RT_SUCCESS(rc))
     {
         pStreamWas->pDevCfg = pDevCfg;
 
-        pCfgAcq->Props = pDevCfg->Props;
+        pCfgAcq->Props                       = pDevCfg->Props;
         pCfgAcq->Backend.cFramesBufferSize   = pDevCfg->cFramesBufferSize;
         pCfgAcq->Backend.cFramesPeriod       = pDevCfg->cFramesPeriod;
@@ -1532 +1584 @@
             RTCritSectRwLeaveExcl(&pThis->CritSectStreamList);
 
-            LogFlowFunc(("returns VINF_SUCCESS\n", rc));
-            return VINF_SUCCESS;
+            if (pStreamWas->pDevCfg->pIAudioClient != NULL)
+            {
+                LogFlowFunc(("returns VINF_SUCCESS\n", rc));
+                return VINF_SUCCESS;
+            }
+            LogFlowFunc(("returns VINF_AUDIO_STREAM_ASYNC_INIT_NEEDED\n", rc));
+            return VINF_AUDIO_STREAM_ASYNC_INIT_NEEDED;
         }
 
@@ -1541 +1598 @@
     }
     else
-        LogRelMax(64, ("WasAPI: Failed to setup %s on audio device '%ls'.\n", pszStreamType, pwszDevIdDesc));
+        LogRelMax(64, ("WasAPI: Failed to setup %s on audio device '%ls' (%Rrc).\n", pszStreamType, pwszDevIdDesc, rc));
 
     LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamInitAsync}
+ */
+static DECLCALLBACK(int) drvHostAudioWasHA_StreamInitAsync(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream,
+                                                           bool fDestroyed)
+{
+    RT_NOREF(pInterface);
+    PDRVHOSTAUDIOWASSTREAM pStreamWas = (PDRVHOSTAUDIOWASSTREAM)pStream;
+    AssertPtrReturn(pStreamWas, VERR_INVALID_POINTER);
+    LogFlowFunc(("Stream '%s'%s\n", pStreamWas->Cfg.szName, fDestroyed ? " - destroyed!" : ""));
+
+    /*
+     * Assert sane preconditions for this call.
+     */
+    AssertPtrReturn(pStreamWas->Core.pStream, VERR_INTERNAL_ERROR);
+    AssertPtrReturn(pStreamWas->pDevCfg, VERR_INTERNAL_ERROR_2);
+    AssertPtrReturn(pStreamWas->pDevCfg->pDevEntry, VERR_INTERNAL_ERROR_3);
+    AssertPtrReturn(pStreamWas->pDevCfg->pDevEntry->pIDevice, VERR_INTERNAL_ERROR_4);
+    AssertReturn(pStreamWas->pDevCfg->pDevEntry->enmDir == pStreamWas->Core.pStream->enmDir, VERR_INTERNAL_ERROR_4);
+    AssertReturn(pStreamWas->pDevCfg->pIAudioClient == NULL, VERR_INTERNAL_ERROR_5);
+    AssertReturn(pStreamWas->pDevCfg->pIAudioRenderClient == NULL, VERR_INTERNAL_ERROR_5);
+    AssertReturn(pStreamWas->pDevCfg->pIAudioCaptureClient == NULL, VERR_INTERNAL_ERROR_5);
+
+    /*
+     * Do the job.
+     */
+    int rc;
+    if (!fDestroyed)
+        rc = drvHostAudioWasCacheInitConfig(pStreamWas->pDevCfg);
+    else
+    {
+        AssertReturn(pStreamWas->pDevCfg->rcSetup == VERR_AUDIO_STREAM_INIT_IN_PROGRESS, VERR_INTERNAL_ERROR_2);
+        pStreamWas->pDevCfg->rcSetup = VERR_WRONG_ORDER;
+        rc = VINF_SUCCESS;
+    }
+
+    LogFlowFunc(("returns %Rrc (%s)\n", rc, pStreamWas->Cfg.szName));
     return rc;
 }
@@ -2086 +2184 @@
     AssertPtrReturn(pStreamWas, PDMAUDIOSTREAM_STS_NONE);
 
-    uint32_t fStrmStatus = PDMAUDIOSTREAM_STS_INITIALIZED;
+    uint32_t fStrmStatus = 0;
+    AssertPtr(pStreamWas->pDevCfg);
+    if (pStreamWas->pDevCfg /*paranoia*/)
+    {
+        if (RT_SUCCESS(pStreamWas->pDevCfg->rcSetup))
+            fStrmStatus |= PDMAUDIOSTREAM_STS_INITIALIZED;
+        else if (pStreamWas->pDevCfg->rcSetup != VERR_AUDIO_STREAM_INIT_IN_PROGRESS)
+        {
+            /** @todo trigger device reset? Probably won't help, so what to do?  */
+        }
+    }
     if (pStreamWas->fEnabled)
         fStrmStatus |= PDMAUDIOSTREAM_STS_ENABLED;
@@ -2418 +2526 @@
     PDRVHOSTAUDIOWAS pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTAUDIOWAS);
 
+    /*
+     * Start purging the cache asynchronously before we get to destruct.
+     * This might speed up VM shutdown a tiny fraction and also stress
+     * the shutting down of the thread pool a little.
+     */
+#if 0
     if (pThis->hWorkerThread != NIL_RTTHREAD)
     {
@@ -2424 +2538 @@
         Assert(fRc); RT_NOREF(fRc);
     }
+#else
+    if (!RTListIsEmpty(&pThis->CacheHead) && pThis->pIHostAudioPort)
+    {
+        int rc = pThis->pIHostAudioPort->pfnDoOnWorkerThread(pThis->pIHostAudioPort, NULL/*pStream*/,
+                                                             DRVHOSTAUDIOWAS_DO_PURGE_CACHE, NULL /*pvUser*/);
+        AssertRC(rc);
+    }
+#endif
 }
 
@@ -2443 +2565 @@
     }
 
+#if 0
     if (pThis->hWorkerThread != NIL_RTTHREAD)
     {
@@ -2451 +2574 @@
         AssertRC(rc);
     }
+#endif
 
     if (RTCritSectIsInitialized(&pThis->CritSectCache))
@@ -2498 +2622 @@
     pThis->pDrvIns                          = pDrvIns;
     pThis->hDrainTimer                      = NIL_TMTIMERHANDLE;
+#if 0
     pThis->hWorkerThread                    = NIL_RTTHREAD;
     pThis->idWorkerThread                   = 0;
+#endif
     RTListInit(&pThis->StreamHead);
     RTListInit(&pThis->CacheHead);
@@ -2508 +2634 @@
     pThis->IHostAudio.pfnGetDevices                 = drvHostAudioWasHA_GetDevices;
     pThis->IHostAudio.pfnGetStatus                  = drvHostAudioWasHA_GetStatus;
+    pThis->IHostAudio.pfnDoOnWorkerThread           = drvHostAudioWasHA_DoOnWorkerThread;
     pThis->IHostAudio.pfnStreamConfigHint           = drvHostAudioWasHA_StreamConfigHint;
     pThis->IHostAudio.pfnStreamCreate               = drvHostAudioWasHA_StreamCreate;
+    pThis->IHostAudio.pfnStreamInitAsync            = drvHostAudioWasHA_StreamInitAsync;
     pThis->IHostAudio.pfnStreamDestroy              = drvHostAudioWasHA_StreamDestroy;
     pThis->IHostAudio.pfnStreamNotifyDeviceChanged  = NULL;
@@ -2560 +2688 @@
      * Resolve the notification interface.
      */
-    pThis->pIAudioNotifyFromHost = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIAUDIONOTIFYFROMHOST);
+    pThis->pIHostAudioPort = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIHOSTAUDIOPORT);
 # ifdef VBOX_WITH_AUDIO_CALLBACKS
-    AssertPtr(pThis->pIAudioNotifyFromHost);
+    AssertPtr(pThis->pIHostAudioPort);
 # endif
 
@@ -2645 +2773 @@
     AssertRCReturn(rc, rc);
 
+#if 0
     /*
      * Create the worker thread.  This thread has a message loop and will be
@@ -2657 +2786 @@
     rc = RTThreadUserWait(pThis->hWorkerThread, RT_MS_10SEC);
     AssertRC(rc);
+#endif
 
     /*

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

@@ -1102 +1102 @@
     pThis->IHostAudio.pfnGetDevices                 = NULL;
     pThis->IHostAudio.pfnGetStatus                  = drvAudioVideoRecHA_GetStatus;
+    pThis->IHostAudio.pfnDoOnWorkerThread           = NULL;
+    pThis->IHostAudio.pfnStreamConfigHint           = NULL;
     pThis->IHostAudio.pfnStreamCreate               = drvAudioVideoRecHA_StreamCreate;
+    pThis->IHostAudio.pfnStreamInitAsync            = NULL;
     pThis->IHostAudio.pfnStreamDestroy              = drvAudioVideoRecHA_StreamDestroy;
     pThis->IHostAudio.pfnStreamNotifyDeviceChanged  = NULL;

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

@@ -725 +725 @@
     pThis->IHostAudio.pfnGetDevices                 = NULL;
     pThis->IHostAudio.pfnGetStatus                  = drvAudioVrdeHA_GetStatus;
+    pThis->IHostAudio.pfnDoOnWorkerThread           = NULL;
+    pThis->IHostAudio.pfnStreamConfigHint           = NULL;
     pThis->IHostAudio.pfnStreamCreate               = drvAudioVrdeHA_StreamCreate;
+    pThis->IHostAudio.pfnStreamInitAsync            = NULL;
     pThis->IHostAudio.pfnStreamDestroy              = drvAudioVrdeHA_StreamDestroy;
     pThis->IHostAudio.pfnStreamNotifyDeviceChanged  = NULL;