Changeset 89489 in vbox

Timestamp:

Jun 3, 2021 11:00:02 PM (3 years ago)

Author:

vboxsync

Message:

Audio: Simplified PDMIAUDIOCONNECTOR::pfnStreamCreate by moving the acquired configuration to the resulting stream (PDMAUDIOSTREAM::Cfg). bugref:9890

Location:

trunk

Files:

• include/VBox/vmm/pdmaudioifs.h (modified) (11 diffs)
• src/VBox/Devices/Audio/AudioMixer.cpp (modified) (14 diffs)
• src/VBox/Devices/Audio/DrvAudio.cpp (modified) (125 diffs)
• src/VBox/Devices/Audio/DrvHostAudioNull.cpp (modified) (1 diff)
• src/VBox/Main/src-client/DrvAudioVRDE.cpp (modified) (1 diff)

trunk/include/VBox/vmm/pdmaudioifs.h

@@ -641 +641 @@
 typedef struct PDMAUDIOSTREAMCFG
 {
+    /** The stream's PCM properties. */
+    PDMAUDIOPCMPROPS        Props;
     /** Direction of the stream. */
     PDMAUDIODIR             enmDir;
     /** Destination / source path. */
     PDMAUDIOPATH            enmPath;
-    /** The stream's PCM properties. */
-    PDMAUDIOPCMPROPS        Props;
     /** Device emulation-specific data needed for the audio connector. */
     struct
@@ -874 +874 @@
      *          - Before DRVAUDIO::CritSectHotPlug. */
     RTCRITSECT              CritSect;
+    /** Stream configuration. */
+    PDMAUDIOSTREAMCFG       Cfg;
     /** Magic value (PDMAUDIOSTREAM_MAGIC). */
     uint32_t                uMagic;
-    /** Audio direction of this stream. */
-    PDMAUDIODIR             enmDir;
     /** Size (in bytes) of the backend-specific stream data. */
     uint32_t                cbBackend;
@@ -883 +883 @@
      *  See PDMAUDIOSTREAM_WARN_FLAGS_XXX. */
     uint32_t                fWarningsShown;
-    /** The stream properties. */
-    PDMAUDIOPCMPROPS        Props;
-
-    /** Name of this stream. */
-    char                    szName[64];
 } PDMAUDIOSTREAM;
 /** Pointer to an audio stream. */
@@ -960 +955 @@
      * configuring host audio.
      *
-     * @param   pInterface      Pointer to this interface.
-     * @param   pCfg            The typical configuration.  Can be modified by the
-     *                          drivers in unspecified ways.
+     * @param   pInterface  Pointer to this interface.
+     * @param   pCfg        The typical configuration.  Can be modified by the
+     *                      drivers in unspecified ways.
      */
     DECLR3CALLBACKMEMBER(void, pfnStreamConfigHint, (PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOSTREAMCFG pCfg));
@@ -970 +965 @@
      *
      * @returns VBox status code.
-     * @param   pInterface      Pointer to the interface structure containing the called function pointer.
-     * @param   fFlags          PDMAUDIOSTREAM_CREATE_F_XXX.
-     * @param   pCfgHost        Stream configuration for host side.
-     * @param   pCfgGuest       Stream configuration for guest side.
-     * @param   ppStream        Pointer where to return the created audio stream on success.
-     * @todo r=bird: It is not documented how pCfgHost and pCfgGuest can be
-     *       modified the DrvAudio...
-     */
-    DECLR3CALLBACKMEMBER(int, pfnStreamCreate, (PPDMIAUDIOCONNECTOR pInterface, uint32_t fFlags, PPDMAUDIOSTREAMCFG pCfgHost,
-                                                PPDMAUDIOSTREAMCFG pCfgGuest, PPDMAUDIOSTREAM *ppStream));
+     * @param   pInterface  Pointer to this interface.
+     * @param   fFlags      PDMAUDIOSTREAM_CREATE_F_XXX.
+     * @param   pCfgReq     The requested stream configuration.  The actual stream
+     *                      configuration can be found in pStream->Cfg on success.
+     * @param   ppStream    Pointer where to return the created audio stream on
+     *                      success.
+     */
+    DECLR3CALLBACKMEMBER(int, pfnStreamCreate, (PPDMIAUDIOCONNECTOR pInterface, uint32_t fFlags, PCPDMAUDIOSTREAMCFG pCfgReq,
+                                                PPDMAUDIOSTREAM *ppStream));
 
 
@@ -1097 +1091 @@
 
 /** PDMIAUDIOCONNECTOR interface ID. */
-#define PDMIAUDIOCONNECTOR_IID                  "ae82616d-0da7-489a-aa4c-3e74d112ca9c"
+#define PDMIAUDIOCONNECTOR_IID                  "2900fe2a-6aeb-4953-ac12-f8965612f446"
 
 
@@ -1315 +1309 @@
                                                  PDMAUDIOSTREAMCMD enmStreamCmd));
 
-    /**
-     * Returns the amount which is readable from the audio (input) stream.
-     *
-     * @returns For non-raw layout streams: Number of readable bytes.
-     *          for raw layout streams    : Number of readable audio frames.
-     * @param   pInterface          Pointer to the interface structure containing the called function pointer.
-     * @param   pStream             Pointer to audio stream.
-     */
-    DECLR3CALLBACKMEMBER(uint32_t, pfnStreamGetReadable, (PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream));
-
-    /**
-     * Returns the amount which is writable to the audio (output) stream.
-     *
-     * @returns Number of writable bytes.
-     * @param   pInterface          Pointer to the interface structure containing the called function pointer.
-     * @param   pStream             Pointer to audio stream.
-     */
-    DECLR3CALLBACKMEMBER(uint32_t, pfnStreamGetWritable, (PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream));
-
-    /**
-     * Returns the number of buffered bytes that hasn't been played yet (optional).
-     *
-     * Is not valid on an input stream, implementions shall assert and return zero.
-     *
-     * @returns Number of pending bytes.
-     * @param   pInterface          Pointer to this interface.
-     * @param   pStream             Pointer to audio stream.
-     *
-     * @todo This is no longer not used by DrvAudio and can probably be removed.
-     */
-    DECLR3CALLBACKMEMBER(uint32_t, pfnStreamGetPending, (PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream));
 
     /**
@@ -1356 +1319 @@
      */
     DECLR3CALLBACKMEMBER(PDMHOSTAUDIOSTREAMSTATE, pfnStreamGetState, (PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream));
+
+    /**
+     * Returns the number of buffered bytes that hasn't been played yet (optional).
+     *
+     * Is not valid on an input stream, implementions shall assert and return zero.
+     *
+     * @returns Number of pending bytes.
+     * @param   pInterface          Pointer to this interface.
+     * @param   pStream             Pointer to audio stream.
+     *
+     * @todo This is no longer not used by DrvAudio and can probably be removed.
+     */
+    DECLR3CALLBACKMEMBER(uint32_t, pfnStreamGetPending, (PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream));
+
+    /**
+     * Returns the amount which is writable to the audio (output) stream.
+     *
+     * @returns Number of writable bytes.
+     * @param   pInterface          Pointer to the interface structure containing the called function pointer.
+     * @param   pStream             Pointer to audio stream.
+     */
+    DECLR3CALLBACKMEMBER(uint32_t, pfnStreamGetWritable, (PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream));
 
     /**
@@ -1378 +1363 @@
 
     /**
+     * Returns the amount which is readable from the audio (input) stream.
+     *
+     * @returns For non-raw layout streams: Number of readable bytes.
+     *          for raw layout streams    : Number of readable audio frames.
+     * @param   pInterface          Pointer to the interface structure containing the called function pointer.
+     * @param   pStream             Pointer to audio stream.
+     */
+    DECLR3CALLBACKMEMBER(uint32_t, pfnStreamGetReadable, (PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream));
+
+    /**
      * Captures (reads from) an audio (input) stream.
      *
@@ -1392 +1387 @@
 
 /** PDMIHOSTAUDIO interface ID. */
-#define PDMIHOSTAUDIO_IID                           "0625ae75-491b-428b-836e-4f8a9869788f"
+#define PDMIHOSTAUDIO_IID                           "147dedd7-cac1-469b-b545-335dbe90abf6"
 
 
@@ -1477 +1472 @@
 
 /** PDMIHOSTAUDIOPORT interface ID. */
-#define PDMIHOSTAUDIOPORT_IID                    "d42144e9-867e-4d1c-86d4-acb92b47f013"
+#define PDMIHOSTAUDIOPORT_IID                    "92ea5169-8271-402d-99a7-9de26a52acaf"
 
 /** @} */

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

@@ -532 +532 @@
         {
             uint32_t cFrames = pMixStream->cFramesBackendBuffer;
-            if (PDMAudioPropsHz(&pMixStream->pStream->Props) == PDMAudioPropsHz(&pSink->MixBuf.Props))
+            if (PDMAudioPropsHz(&pMixStream->pStream->Cfg.Props) == PDMAudioPropsHz(&pSink->MixBuf.Props))
             { /* likely */ }
             else
-                cFrames = cFrames * PDMAudioPropsHz(&pSink->MixBuf.Props) / PDMAudioPropsHz(&pMixStream->pStream->Props);
+                cFrames = cFrames * PDMAudioPropsHz(&pSink->MixBuf.Props) / PDMAudioPropsHz(&pMixStream->pStream->Cfg.Props);
             if (cFrames > cFramesStreamMax)
             {
@@ -1006 +1006 @@
                     RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
                     {
-                        int rc2 = AudioMixBufInitWriteState(&pSink->MixBuf, &pMixStream->WriteState, &pMixStream->pStream->Props);
+                        int rc2 = AudioMixBufInitWriteState(&pSink->MixBuf, &pMixStream->WriteState, &pMixStream->pStream->Cfg.Props);
                         /** @todo remember this. */
                         AssertLogRelRC(rc2);
@@ -1015 +1015 @@
                     RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
                     {
-                        int rc2 = AudioMixBufInitPeekState(&pSink->MixBuf, &pMixStream->PeekState, &pMixStream->pStream->Props);
+                        int rc2 = AudioMixBufInitPeekState(&pSink->MixBuf, &pMixStream->PeekState, &pMixStream->pStream->Cfg.Props);
                         /** @todo remember this. */
                         AssertLogRelRC(rc2);
@@ -1137 +1137 @@
 
             uint32_t const cbReadable = pIConnector->pfnStreamGetReadable(pIConnector, pStream);
-            uint32_t cFrames = PDMAudioPropsBytesToFrames(&pStream->Props, cbReadable);
+            uint32_t cFrames = PDMAudioPropsBytesToFrames(&pStream->Cfg.Props, cbReadable);
             pMixStream->cFramesLastAvail = cFrames;
-            if (PDMAudioPropsHz(&pStream->Props) == PDMAudioPropsHz(&pSink->MixBuf.Props))
+            if (PDMAudioPropsHz(&pStream->Cfg.Props) == PDMAudioPropsHz(&pSink->MixBuf.Props))
             { /* likely */ }
             else
             {
-                cFrames = cFrames * PDMAudioPropsHz(&pSink->MixBuf.Props) / PDMAudioPropsHz(&pStream->Props);
+                cFrames = cFrames * PDMAudioPropsHz(&pSink->MixBuf.Props) / PDMAudioPropsHz(&pStream->Cfg.Props);
                 cFrames = cFrames > 2 ? cFrames - 2 : 0; /* rounding safety fudge */
             }
@@ -1274 +1274 @@
 
                     /* Calculate how many bytes we should read from this stream. */
-                    bool const     fResampleSrc = PDMAudioPropsHz(&pStream->Props) != PDMAudioPropsHz(&pSink->MixBuf.Props);
+                    bool const     fResampleSrc = PDMAudioPropsHz(&pStream->Cfg.Props) != PDMAudioPropsHz(&pSink->MixBuf.Props);
                     uint32_t const cbSrcToXfer  = !fResampleSrc
-                                                ? PDMAudioPropsFramesToBytes(&pStream->Props, cFramesToXfer)
-                                                : PDMAudioPropsFramesToBytes(&pStream->Props, /** @todo check rounding errors here... */
+                                                ? PDMAudioPropsFramesToBytes(&pStream->Cfg.Props, cFramesToXfer)
+                                                : PDMAudioPropsFramesToBytes(&pStream->Cfg.Props, /** @todo check rounding errors here... */
                                                                              cFramesToXfer * PDMAudioPropsHz(&pSink->MixBuf.Props)
-                                                                             / PDMAudioPropsHz(&pStream->Props));
+                                                                             / PDMAudioPropsHz(&pStream->Cfg.Props));
 
                     /* Do the reading. */
@@ -1332 +1332 @@
                         /* We don't need to blend silence buffers.  For simplicity, always blend
                            when we're resampling (for rounding). */
-                        else if (fResampleSrc || !PDMAudioPropsIsBufferSilence(&pStream->Props, pvBuf, cbSrcRead))
+                        else if (fResampleSrc || !PDMAudioPropsIsBufferSilence(&pStream->Cfg.Props, pvBuf, cbSrcRead))
                         {
                             AudioMixBufBlend(&pSink->MixBuf, &pMixStream->WriteState, pvBuf, cbSrcRead,
@@ -1339 +1339 @@
                         else
                         {
-                            cFramesDstTransferred = PDMAudioPropsBytesToFrames(&pStream->Props, cbSrcRead);
+                            cFramesDstTransferred = PDMAudioPropsBytesToFrames(&pStream->Cfg.Props, cbSrcRead);
                             AudioMixBufBlendGap(&pSink->MixBuf, &pMixStream->WriteState, cFramesDstTransferred);
                         }
@@ -1420 +1420 @@
         {
             uint32_t const cbWritable = pMixStream->pConn->pfnStreamGetWritable(pMixStream->pConn, pMixStream->pStream);
-            uint32_t cFrames = PDMAudioPropsBytesToFrames(&pMixStream->pStream->Props, cbWritable);
+            uint32_t cFrames = PDMAudioPropsBytesToFrames(&pMixStream->pStream->Cfg.Props, cbWritable);
             pMixStream->cFramesLastAvail = cFrames;
-            if (PDMAudioPropsHz(&pMixStream->pStream->Props) == PDMAudioPropsHz(&pSink->MixBuf.Props))
+            if (PDMAudioPropsHz(&pMixStream->pStream->Cfg.Props) == PDMAudioPropsHz(&pSink->MixBuf.Props))
             { /* likely */ }
             else
             {
-                cFrames = cFrames * PDMAudioPropsHz(&pSink->MixBuf.Props) / PDMAudioPropsHz(&pMixStream->pStream->Props);
+                cFrames = cFrames * PDMAudioPropsHz(&pSink->MixBuf.Props) / PDMAudioPropsHz(&pMixStream->pStream->Cfg.Props);
                 cFrames = cFrames > 2 ? cFrames - 2 : 0; /* rounding safety fudge */
             }
@@ -2262 +2262 @@
                  * this is the sink format & direction with the src/dir, layout, name
                  * and device specific config copied from the guest side config (pCfg).
+                 * We disregard any Backend settings here.
+                 *
+                 * (Note! pfnStreamCreate used to get both CfgHost and pCfg (aka pCfgGuest)
+                 *        passed in, but that became unnecessary with DrvAudio stoppping
+                 *        mixing.  The mixing is done here and we bridge guest & host configs.)
                  */
                 AssertMsg(AudioHlpPcmPropsAreValid(&pSink->PCMProps),
@@ -2282 +2287 @@
                  */
                 PPDMAUDIOSTREAM pStream;
-                rc = pConn->pfnStreamCreate(pConn, 0 /*fFlags*/, &CfgHost, pCfg, &pStream);
+                rc = pConn->pfnStreamCreate(pConn, 0 /*fFlags*/, &CfgHost, &pStream);
                 if (RT_SUCCESS(rc))
                 {
@@ -2289 +2294 @@
                     /* Set up the mixing buffer conversion state. */
                     if (pSink->enmDir == PDMAUDIODIR_IN)
-                        rc = AudioMixBufInitWriteState(&pSink->MixBuf, &pMixStream->WriteState, &pStream->Props);
+                        rc = AudioMixBufInitWriteState(&pSink->MixBuf, &pMixStream->WriteState, &pStream->Cfg.Props);
                     else
-                        rc = AudioMixBufInitPeekState(&pSink->MixBuf, &pMixStream->PeekState, &pStream->Props);
+                        rc = AudioMixBufInitPeekState(&pSink->MixBuf, &pMixStream->PeekState, &pStream->Cfg.Props);
                     if (RT_SUCCESS(rc))
                     {
@@ -2396 +2401 @@
                                               pStream->pszName, pSink->pszName), VERR_NOT_FOUND);
     Assert(RTCritSectIsOwner(&pSink->CritSect));
-    LogFlowFunc(("[%s] (Stream = %s), cStreams=%RU8\n", pSink->pszName, pStream->pStream->szName, pSink->cStreams));
+    LogFlowFunc(("[%s] (Stream = %s), cStreams=%RU8\n", pSink->pszName, pStream->pStream->Cfg.szName, pSink->cStreams));
 
     /*
@@ -2527 +2532 @@
             if (pSink->enmDir == PDMAUDIODIR_OUT)
             {
-                rc = AudioMixBufInitPeekState(&pSink->MixBuf, &pMixStream->PeekState, &pStream->Props);
+                rc = AudioMixBufInitPeekState(&pSink->MixBuf, &pMixStream->PeekState, &pStream->Cfg.Props);
                 /** @todo we need to remember this, don't we? */
                 AssertLogRelRCReturn(rc, VINF_SUCCESS);
@@ -2533 +2538 @@
             else
             {
-                rc = AudioMixBufInitWriteState(&pSink->MixBuf, &pMixStream->WriteState, &pStream->Props);
+                rc = AudioMixBufInitWriteState(&pSink->MixBuf, &pMixStream->WriteState, &pStream->Cfg.Props);
                 /** @todo we need to remember this, don't we? */
                 AssertLogRelRCReturn(rc, VINF_SUCCESS);

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

@@ -201 +201 @@
     PRTREQ                  hReqInitAsync;
 
-    /** @todo The guest and host fields only contains the stream config now that
-     *        the mixing buffer is gone, so we can probably combine them into a
-     *        single Cfg member. */
-    /** The guest side of the stream. */
-    DRVAUDIOSTREAMCTX       Guest;
-    /** The host side of the stream. */
-    DRVAUDIOSTREAMCTX       Host;
-
-
     /** The nanosecond timestamp when the stream was started. */
     uint64_t                nsStarted;
@@ -600 +591 @@
     {
         PDMHOSTAUDIOSTREAMSTATE enmState = pThis->pHostDrvAudio->pfnStreamGetState(pThis->pHostDrvAudio, pStreamEx->pBackend);
-        Log9Func(("%s: %s\n", pStreamEx->Core.szName, PDMHostAudioStreamStateGetName(enmState) ));
+        Log9Func(("%s: %s\n", pStreamEx->Core.Cfg.szName, PDMHostAudioStreamStateGetName(enmState) ));
         Assert(   enmState > PDMHOSTAUDIOSTREAMSTATE_INVALID
                && enmState < PDMHOSTAUDIOSTREAMSTATE_END
-               && (enmState != PDMHOSTAUDIOSTREAMSTATE_DRAINING || pStreamEx->Guest.Cfg.enmDir == PDMAUDIODIR_OUT));
+               && (enmState != PDMHOSTAUDIOSTREAMSTATE_DRAINING || pStreamEx->Core.Cfg.enmDir == PDMAUDIODIR_OUT));
         return enmState;
     }
-    Log9Func(("%s: not-working\n", pStreamEx->Core.szName));
+    Log9Func(("%s: not-working\n", pStreamEx->Core.Cfg.szName));
     return PDMHOSTAUDIOSTREAMSTATE_NOT_WORKING;
 }
@@ -616 +607 @@
 DECLINLINE(void) drvAudioStreamProcessBackendStateChangeWasDraining(PDRVAUDIOSTREAM pStreamEx)
 {
-    Log(("drvAudioStreamProcessBackendStateChange: Stream '%s': Done draining - disabling stream.\n", pStreamEx->Core.szName));
+    Log(("drvAudioStreamProcessBackendStateChange: Stream '%s': Done draining - disabling stream.\n", pStreamEx->Core.Cfg.szName));
     pStreamEx->fStatus &= ~(PDMAUDIOSTREAM_STS_ENABLED | PDMAUDIOSTREAM_STS_PENDING_DISABLE);
     drvAudioStreamResetInternal(pStreamEx);
@@ -631 +622 @@
                                                                        PDMHOSTAUDIOSTREAMSTATE enmOldState)
 {
-    PDMAUDIODIR const           enmDir          = pStreamEx->Guest.Cfg.enmDir;
+    PDMAUDIODIR const           enmDir          = pStreamEx->Core.Cfg.enmDir;
 #ifdef LOG_ENABLED
     DRVAUDIOPLAYSTATE const     enmPlayState    = enmDir == PDMAUDIODIR_OUT
@@ -704 +695 @@
 
     if (enmDir == PDMAUDIODIR_OUT)
-        LogFunc(("Output stream '%s': %s/%s -> %s/%s\n", pStreamEx->Core.szName,
+        LogFunc(("Output stream '%s': %s/%s -> %s/%s\n", pStreamEx->Core.Cfg.szName,
                  PDMHostAudioStreamStateGetName(enmOldState), drvAudioPlayStateName(enmPlayState),
                  PDMHostAudioStreamStateGetName(enmNewState), drvAudioPlayStateName(pStreamEx->Out.enmPlayState) ));
     else
-        LogFunc(("Input stream '%s': %s/%s -> %s/%s\n", pStreamEx->Core.szName,
+        LogFunc(("Input stream '%s': %s/%s -> %s/%s\n", pStreamEx->Core.Cfg.szName,
                  PDMHostAudioStreamStateGetName(enmOldState), drvAudioCaptureStateName(enmCaptureState),
                  PDMHostAudioStreamStateGetName(enmNewState), drvAudioCaptureStateName(pStreamEx->In.enmCaptureState) ));
@@ -864 +855 @@
         RTListForEach(&pThis->LstStreams, pStreamEx, DRVAUDIOSTREAM, ListEntry)
         {
-            if (pStreamEx->Core.enmDir == enmDir)
+            if (pStreamEx->Core.Cfg.enmDir == enmDir)
             {
                 /*
@@ -911 +902 @@
                     {
                         LogRel(("Audio: Failed to %s %s stream '%s': %Rrc\n",
-                                pszOperation, enmDir == PDMAUDIODIR_IN ? "input" : "output", pStreamEx->Core.szName, rc2));
+                                pszOperation, enmDir == PDMAUDIODIR_IN ? "input" : "output", pStreamEx->Core.Cfg.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
@@ -1016 +1007 @@
     if (pStreamEx)
     {
-        LogFunc(("[%s]\n", pStreamEx->Core.szName));
+        LogFunc(("[%s]\n", pStreamEx->Core.Cfg.szName));
         Assert(pStreamEx->Core.uMagic == PDMAUDIOSTREAM_MAGIC);
         Assert(pStreamEx->uMagic      == DRVAUDIOSTREAM_MAGIC);
@@ -1040 +1031 @@
  * @returns VBox status code.
  * @param   pThis       Pointer to the DrvAudio instance data.
- * @param   pCfgReq     The request configuration that should be adjusted.
+ * @param   pCfg        The configuration that should be adjusted.
  * @param   pszName     Stream name to use when logging warnings and errors.
  */
-static int drvAudioStreamAdjustConfig(PCDRVAUDIO pThis, PPDMAUDIOSTREAMCFG pCfgReq, const char *pszName)
+static int drvAudioStreamAdjustConfig(PCDRVAUDIO pThis, PPDMAUDIOSTREAMCFG pCfg, const char *pszName)
 {
     /* Get the right configuration for the stream to be created. */
-    PCDRVAUDIOCFG pDrvCfg = pCfgReq->enmDir == PDMAUDIODIR_IN ? &pThis->CfgIn: &pThis->CfgOut;
+    PCDRVAUDIOCFG pDrvCfg = pCfg->enmDir == PDMAUDIODIR_IN ? &pThis->CfgIn: &pThis->CfgOut;
 
     /* Fill in the tweakable parameters into the requested host configuration.
@@ -1056 +1047 @@
     if (PDMAudioPropsSampleSize(&pDrvCfg->Props) != 0) /* Anything set via custom extra-data? */
     {
-        PDMAudioPropsSetSampleSize(&pCfgReq->Props, PDMAudioPropsSampleSize(&pDrvCfg->Props));
+        PDMAudioPropsSetSampleSize(&pCfg->Props, PDMAudioPropsSampleSize(&pDrvCfg->Props));
         LogRel2(("Audio: Using custom sample size of %RU8 bytes for stream '%s'\n",
-                 PDMAudioPropsSampleSize(&pCfgReq->Props), pszName));
+                 PDMAudioPropsSampleSize(&pCfg->Props), pszName));
     }
 
     if (pDrvCfg->Props.uHz) /* Anything set via custom extra-data? */
     {
-        pCfgReq->Props.uHz = pDrvCfg->Props.uHz;
-        LogRel2(("Audio: Using custom Hz rate %RU32 for stream '%s'\n", pCfgReq->Props.uHz, pszName));
+        pCfg->Props.uHz = pDrvCfg->Props.uHz;
+        LogRel2(("Audio: Using custom Hz rate %RU32 for stream '%s'\n", pCfg->Props.uHz, pszName));
     }
 
     if (pDrvCfg->uSigned != UINT8_MAX) /* Anything set via custom extra-data? */
     {
-        pCfgReq->Props.fSigned = RT_BOOL(pDrvCfg->uSigned);
+        pCfg->Props.fSigned = RT_BOOL(pDrvCfg->uSigned);
         LogRel2(("Audio: Using custom %s sample format for stream '%s'\n",
-                 pCfgReq->Props.fSigned ? "signed" : "unsigned", pszName));
+                 pCfg->Props.fSigned ? "signed" : "unsigned", pszName));
     }
 
     if (pDrvCfg->uSwapEndian != UINT8_MAX) /* Anything set via custom extra-data? */
     {
-        pCfgReq->Props.fSwapEndian = RT_BOOL(pDrvCfg->uSwapEndian);
+        pCfg->Props.fSwapEndian = RT_BOOL(pDrvCfg->uSwapEndian);
         LogRel2(("Audio: Using custom %s endianess for samples of stream '%s'\n",
-                 pCfgReq->Props.fSwapEndian ? "swapped" : "original", pszName));
+                 pCfg->Props.fSwapEndian ? "swapped" : "original", pszName));
     }
 
     if (PDMAudioPropsChannels(&pDrvCfg->Props) != 0) /* Anything set via custom extra-data? */
     {
-        PDMAudioPropsSetChannels(&pCfgReq->Props, PDMAudioPropsChannels(&pDrvCfg->Props));
+        PDMAudioPropsSetChannels(&pCfg->Props, PDMAudioPropsChannels(&pDrvCfg->Props));
         LogRel2(("Audio: Using custom %RU8 channel(s) for stream '%s'\n", PDMAudioPropsChannels(&pDrvCfg->Props), pszName));
     }
 
     /* Validate PCM properties. */
-    if (!AudioHlpPcmPropsAreValid(&pCfgReq->Props))
+    if (!AudioHlpPcmPropsAreValid(&pCfg->Props))
     {
         LogRel(("Audio: Invalid custom PCM properties set for stream '%s', cannot create stream\n", pszName));
@@ -1100 +1091 @@
     if (pDrvCfg->uPeriodSizeMs)
     {
-        pCfgReq->Backend.cFramesPeriod = PDMAudioPropsMilliToFrames(&pCfgReq->Props, pDrvCfg->uPeriodSizeMs);
+        pCfg->Backend.cFramesPeriod = PDMAudioPropsMilliToFrames(&pCfg->Props, pDrvCfg->uPeriodSizeMs);
         pszWhat = "custom";
     }
 
-    if (!pCfgReq->Backend.cFramesPeriod) /* Set default period size if nothing explicitly is set. */
-    {
-        pCfgReq->Backend.cFramesPeriod = PDMAudioPropsMilliToFrames(&pCfgReq->Props, 150 /*ms*/);
+    if (!pCfg->Backend.cFramesPeriod) /* Set default period size if nothing explicitly is set. */
+    {
+        pCfg->Backend.cFramesPeriod = PDMAudioPropsMilliToFrames(&pCfg->Props, 150 /*ms*/);
         pszWhat = "default";
     }
 
     LogRel2(("Audio: Using %s period size %RU64 ms / %RU32 frames for stream '%s'\n",
-             pszWhat, PDMAudioPropsFramesToMilli(&pCfgReq->Props, pCfgReq->Backend.cFramesPeriod),
-             pCfgReq->Backend.cFramesPeriod, pszName));
+             pszWhat, PDMAudioPropsFramesToMilli(&pCfg->Props, pCfg->Backend.cFramesPeriod),
+             pCfg->Backend.cFramesPeriod, pszName));
 
     /*
@@ -1120 +1111 @@
     if (pDrvCfg->uBufferSizeMs)
     {
-        pCfgReq->Backend.cFramesBufferSize = PDMAudioPropsMilliToFrames(&pCfgReq->Props, pDrvCfg->uBufferSizeMs);
+        pCfg->Backend.cFramesBufferSize = PDMAudioPropsMilliToFrames(&pCfg->Props, pDrvCfg->uBufferSizeMs);
         pszWhat = "custom";
     }
 
-    if (!pCfgReq->Backend.cFramesBufferSize) /* Set default buffer size if nothing explicitly is set. */
-    {
-        pCfgReq->Backend.cFramesBufferSize = PDMAudioPropsMilliToFrames(&pCfgReq->Props, 300 /*ms*/);
+    if (!pCfg->Backend.cFramesBufferSize) /* Set default buffer size if nothing explicitly is set. */
+    {
+        pCfg->Backend.cFramesBufferSize = PDMAudioPropsMilliToFrames(&pCfg->Props, 300 /*ms*/);
         pszWhat = "default";
     }
 
     LogRel2(("Audio: Using %s buffer size %RU64 ms / %RU32 frames for stream '%s'\n",
-             pszWhat, PDMAudioPropsFramesToMilli(&pCfgReq->Props, pCfgReq->Backend.cFramesBufferSize),
-             pCfgReq->Backend.cFramesBufferSize, pszName));
+             pszWhat, PDMAudioPropsFramesToMilli(&pCfg->Props, pCfg->Backend.cFramesBufferSize),
+             pCfg->Backend.cFramesBufferSize, pszName));
 
     /*
@@ -1140 +1131 @@
     if (pDrvCfg->uPreBufSizeMs != UINT32_MAX) /* Anything set via global / per-VM extra-data? */
     {
-        pCfgReq->Backend.cFramesPreBuffering = PDMAudioPropsMilliToFrames(&pCfgReq->Props, pDrvCfg->uPreBufSizeMs);
+        pCfg->Backend.cFramesPreBuffering = PDMAudioPropsMilliToFrames(&pCfg->Props, pDrvCfg->uPreBufSizeMs);
         pszWhat = "custom";
     }
     else /* No, then either use the default or device-specific settings (if any). */
     {
-        if (pCfgReq->Backend.cFramesPreBuffering == UINT32_MAX) /* Set default pre-buffering size if nothing explicitly is set. */
+        if (pCfg->Backend.cFramesPreBuffering == UINT32_MAX) /* Set default pre-buffering size if nothing explicitly is set. */
         {
             /* Pre-buffer 66% of the buffer for output streams, but only 50% for input. Capping both at 200ms. */
-            if (pCfgReq->enmDir == PDMAUDIODIR_OUT)
-                pCfgReq->Backend.cFramesPreBuffering = pCfgReq->Backend.cFramesBufferSize * 2 / 3;
+            if (pCfg->enmDir == PDMAUDIODIR_OUT)
+                pCfg->Backend.cFramesPreBuffering = pCfg->Backend.cFramesBufferSize * 2 / 3;
             else
-                pCfgReq->Backend.cFramesPreBuffering = pCfgReq->Backend.cFramesBufferSize / 2;
-            uint32_t const cFramesMax = PDMAudioPropsMilliToFrames(&pCfgReq->Props, 200);
-            pCfgReq->Backend.cFramesPreBuffering = RT_MIN(pCfgReq->Backend.cFramesPreBuffering, cFramesMax);
+                pCfg->Backend.cFramesPreBuffering = pCfg->Backend.cFramesBufferSize / 2;
+            uint32_t const cFramesMax = PDMAudioPropsMilliToFrames(&pCfg->Props, 200);
+            pCfg->Backend.cFramesPreBuffering = RT_MIN(pCfg->Backend.cFramesPreBuffering, cFramesMax);
             pszWhat = "default";
         }
@@ -1159 +1150 @@
 
     LogRel2(("Audio: Using %s pre-buffering size %RU64 ms / %RU32 frames for stream '%s'\n",
-             pszWhat, PDMAudioPropsFramesToMilli(&pCfgReq->Props, pCfgReq->Backend.cFramesPreBuffering),
-             pCfgReq->Backend.cFramesPreBuffering, pszName));
+             pszWhat, PDMAudioPropsFramesToMilli(&pCfg->Props, pCfg->Backend.cFramesPreBuffering),
+             pCfg->Backend.cFramesPreBuffering, pszName));
 
     /*
      * Validate input.
      */
-    if (pCfgReq->Backend.cFramesBufferSize < pCfgReq->Backend.cFramesPeriod)
+    if (pCfg->Backend.cFramesBufferSize < pCfg->Backend.cFramesPeriod)
     {
         LogRel(("Audio: Error for stream '%s': Buffering size (%RU64ms) must not be smaller than the period size (%RU64ms)\n",
-                pszName, PDMAudioPropsFramesToMilli(&pCfgReq->Props, pCfgReq->Backend.cFramesBufferSize),
-                PDMAudioPropsFramesToMilli(&pCfgReq->Props, pCfgReq->Backend.cFramesPeriod)));
+                pszName, PDMAudioPropsFramesToMilli(&pCfg->Props, pCfg->Backend.cFramesBufferSize),
+                PDMAudioPropsFramesToMilli(&pCfg->Props, pCfg->Backend.cFramesPeriod)));
         return VERR_INVALID_PARAMETER;
     }
 
-    if (   pCfgReq->Backend.cFramesPreBuffering != UINT32_MAX /* Custom pre-buffering set? */
-        && pCfgReq->Backend.cFramesPreBuffering)
-    {
-        if (pCfgReq->Backend.cFramesBufferSize < pCfgReq->Backend.cFramesPreBuffering)
+    if (   pCfg->Backend.cFramesPreBuffering != UINT32_MAX /* Custom pre-buffering set? */
+        && pCfg->Backend.cFramesPreBuffering)
+    {
+        if (pCfg->Backend.cFramesBufferSize < pCfg->Backend.cFramesPreBuffering)
         {
             LogRel(("Audio: Error for stream '%s': Buffering size (%RU64ms) must not be smaller than the pre-buffering size (%RU64ms)\n",
-                    pszName, PDMAudioPropsFramesToMilli(&pCfgReq->Props, pCfgReq->Backend.cFramesPreBuffering),
-                    PDMAudioPropsFramesToMilli(&pCfgReq->Props, pCfgReq->Backend.cFramesBufferSize)));
+                    pszName, PDMAudioPropsFramesToMilli(&pCfg->Props, pCfg->Backend.cFramesPreBuffering),
+                    PDMAudioPropsFramesToMilli(&pCfg->Props, pCfg->Backend.cFramesBufferSize)));
             return VERR_INVALID_PARAMETER;
         }
@@ -1292 +1283 @@
                 rc = drvAudioStreamControlInternalBackend(pThis, pStreamEx, PDMAUDIOSTREAMCMD_PAUSE);
                 if (RT_FAILURE(rc))
-                    LogRelMax(64, ("Audio: Failed to pause stream '%s' after %s: %Rrc\n", pStreamEx->Core.szName, pszWhen, rc));
+                    LogRelMax(64, ("Audio: Failed to pause stream '%s' after %s: %Rrc\n", pStreamEx->Core.Cfg.szName, pszWhen, rc));
             }
         }
         else
-            LogRelMax(64, ("Audio: Failed to enable stream '%s' after %s: %Rrc\n", pStreamEx->Core.szName, pszWhen, rc));
+            LogRelMax(64, ("Audio: Failed to enable stream '%s' after %s: %Rrc\n", pStreamEx->Core.Cfg.szName, pszWhen, rc));
     }
     return rc;
@@ -1310 +1301 @@
 static DECLCALLBACK(void) drvAudioStreamInitAsync(PDRVAUDIO pThis, PDRVAUDIOSTREAM pStreamEx)
 {
-    LogFlow(("pThis=%p pStreamEx=%p (%s)\n", pThis, pStreamEx, pStreamEx->Core.szName));
+    LogFlow(("pThis=%p pStreamEx=%p (%s)\n", pThis, pStreamEx, pStreamEx->Core.Cfg.szName));
 
     int rc = RTCritSectRwEnterShared(&pThis->CritSectHotPlug);
@@ -1353 +1344 @@
          * Modify the play state if output stream.
          */
-        if (pStreamEx->Core.enmDir == PDMAUDIODIR_OUT)
+        if (pStreamEx->Core.Cfg.enmDir == PDMAUDIODIR_OUT)
         {
             DRVAUDIOPLAYSTATE const enmPlayState = pStreamEx->Out.enmPlayState;
@@ -1392 +1383 @@
     else if (!fDestroyed)
     {
-        LogRelMax(64, ("Audio: Failed to initialize stream '%s': %Rrc\n", pStreamEx->Core.szName, rc));
+        LogRelMax(64, ("Audio: Failed to initialize stream '%s': %Rrc\n", pStreamEx->Core.Cfg.szName, rc));
     }
 
@@ -1421 +1412 @@
  * @returns VBox status code.
  * @param   pThis       Pointer to driver instance.
- * @param   pStreamEx   Audio stream to create the backend side for.
- * @param   pCfgReq     Requested audio stream configuration to use for
- *                      stream creation.
- * @param   pCfgAcq     Acquired audio stream configuration returned by
- *                      the backend.
+ * @param   pStreamEx   Stream to create backend for.  The Core.Cfg field
+ *                      contains the requested configuration when we're called
+ *                      and the actual configuration when successfully
+ *                      returning.
  *
  * @note    Configuration precedence for requested audio stream configuration (first has highest priority, if set):
@@ -1433 +1423 @@
  *          - default value
  */
-static int drvAudioStreamCreateInternalBackend(PDRVAUDIO pThis, PDRVAUDIOSTREAM pStreamEx,
-                                               PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
+static int drvAudioStreamCreateInternalBackend(PDRVAUDIO pThis, PDRVAUDIOSTREAM pStreamEx)
 {
     AssertMsg((pStreamEx->fStatus & PDMAUDIOSTREAM_STS_BACKEND_CREATED) == 0,
-              ("Stream '%s' already initialized in backend\n", pStreamEx->Core.szName));
-
-    /*
-     * Adjust the requested stream config, applying our settings.
-     */
-    int rc = drvAudioStreamAdjustConfig(pThis, pCfgReq, pStreamEx->Core.szName);
+              ("Stream '%s' already initialized in backend\n", pStreamEx->Core.Cfg.szName));
+
+    /*
+     * Adjust the stream config, applying defaults and any overriding settings.
+     */
+    int rc = drvAudioStreamAdjustConfig(pThis, &pStreamEx->Core.Cfg, pStreamEx->Core.Cfg.szName);
     if (RT_FAILURE(rc))
         return rc;
-
-    /*
-     * Make the acquired host configuration the requested host configuration initially,
-     * in case the backend does not report back an acquired configuration.
-     */
-    /** @todo r=bird: This is conveniently not documented in the interface... */
-    rc = PDMAudioStrmCfgCopy(pCfgAcq, pCfgReq);
-    if (RT_FAILURE(rc))
-    {
-        LogRel(("Audio: Creating stream '%s' with an invalid backend configuration not possible, skipping\n",
-                pStreamEx->Core.szName));
-        return rc;
-    }
+    PDMAUDIOSTREAMCFG const CfgReq = pStreamEx->Core.Cfg;
 
     /*
@@ -1472 +1449 @@
                             rc = VERR_STATE_CHANGED);
     if (RT_SUCCESS(rc))
-        rc = pThis->pHostDrvAudio->pfnStreamCreate(pThis->pHostDrvAudio, pStreamEx->pBackend, pCfgReq, pCfgAcq);
+        rc = pThis->pHostDrvAudio->pfnStreamCreate(pThis->pHostDrvAudio, pStreamEx->pBackend, &CfgReq, &pStreamEx->Core.Cfg);
     if (RT_SUCCESS(rc))
     {
@@ -1491 +1468 @@
         RTCritSectRwLeaveShared(&pThis->CritSectHotPlug);
         if (rc == VERR_NOT_SUPPORTED)
-            LogRel2(("Audio: Creating stream '%s' in backend not supported\n", pStreamEx->Core.szName));
+            LogRel2(("Audio: Creating stream '%s' in backend not supported\n", pStreamEx->Core.Cfg.szName));
         else if (rc == VERR_AUDIO_STREAM_COULD_NOT_CREATE)
-            LogRel2(("Audio: Stream '%s' could not be created in backend because of missing hardware / drivers\n", pStreamEx->Core.szName));
+            LogRel2(("Audio: Stream '%s' could not be created in backend because of missing hardware / drivers\n",
+                     pStreamEx->Core.Cfg.szName));
         else
-            LogRel(("Audio: Creating stream '%s' in backend failed with %Rrc\n", pStreamEx->Core.szName, rc));
+            LogRel(("Audio: Creating stream '%s' in backend failed with %Rrc\n", pStreamEx->Core.Cfg.szName, rc));
         return rc;
     }
@@ -1507 +1485 @@
              ("rc=%Rrc %s\n", rc, PDMHostAudioStreamStateGetName(pStreamEx->enmLastBackendState)));
 
-    /* Validate acquired configuration. */
+    PPDMAUDIOSTREAMCFG const pCfgAcq = &pStreamEx->Core.Cfg;
+
+    /*
+     * Validate acquired configuration.
+     */
     char szTmp[PDMAUDIOPROPSTOSTRING_MAX];
+    LogFunc(("Backend returned: %s\n", PDMAudioStrmCfgToString(pCfgAcq, szTmp, sizeof(szTmp)) ));
     AssertLogRelMsgReturn(AudioHlpStreamCfgIsValid(pCfgAcq),
                           ("Audio: Creating stream '%s' returned an invalid backend configuration (%s), skipping\n",
-                           pStreamEx->Core.szName, PDMAudioPropsToString(&pCfgAcq->Props, szTmp, sizeof(szTmp))),
+                           pCfgAcq->szName, PDMAudioPropsToString(&pCfgAcq->Props, szTmp, sizeof(szTmp))),
                           VERR_INVALID_PARAMETER);
 
     /* Let the user know that the backend changed one of the values requested above. */
-    if (pCfgAcq->Backend.cFramesBufferSize != pCfgReq->Backend.cFramesBufferSize)
-        LogRel2(("Audio: Buffer size overwritten by backend for stream '%s' (now %RU64ms, %RU32 frames)\n",
-                 pStreamEx->Core.szName, PDMAudioPropsFramesToMilli(&pCfgAcq->Props, pCfgAcq->Backend.cFramesBufferSize), pCfgAcq->Backend.cFramesBufferSize));
-
-    if (pCfgAcq->Backend.cFramesPeriod != pCfgReq->Backend.cFramesPeriod)
-        LogRel2(("Audio: Period size overwritten by backend for stream '%s' (now %RU64ms, %RU32 frames)\n",
-                 pStreamEx->Core.szName, PDMAudioPropsFramesToMilli(&pCfgAcq->Props, pCfgAcq->Backend.cFramesPeriod), pCfgAcq->Backend.cFramesPeriod));
+    if (pCfgAcq->Backend.cFramesBufferSize != CfgReq.Backend.cFramesBufferSize)
+        LogRel2(("Audio: Backend changed buffer size from %RU64ms (%RU32 frames) to %RU64ms (%RU32 frames)\n",
+                 PDMAudioPropsFramesToMilli(&CfgReq.Props, CfgReq.Backend.cFramesBufferSize), CfgReq.Backend.cFramesBufferSize,
+                 PDMAudioPropsFramesToMilli(&pCfgAcq->Props, pCfgAcq->Backend.cFramesBufferSize), pCfgAcq->Backend.cFramesBufferSize));
+
+    if (pCfgAcq->Backend.cFramesPeriod != CfgReq.Backend.cFramesPeriod)
+        LogRel2(("Audio: Backend changed period size from %RU64ms (%RU32 frames) to %RU64ms (%RU32 frames)\n",
+                 PDMAudioPropsFramesToMilli(&CfgReq.Props, CfgReq.Backend.cFramesPeriod), CfgReq.Backend.cFramesPeriod,
+                 PDMAudioPropsFramesToMilli(&pCfgAcq->Props, pCfgAcq->Backend.cFramesPeriod), pCfgAcq->Backend.cFramesPeriod));
 
     /* Was pre-buffering requested, but the acquired configuration from the backend told us something else? */
-    if (pCfgReq->Backend.cFramesPreBuffering)
-    {
-        if (pCfgAcq->Backend.cFramesPreBuffering != pCfgReq->Backend.cFramesPreBuffering)
-            LogRel2(("Audio: Pre-buffering size overwritten by backend for stream '%s' (now %RU64ms, %RU32 frames)\n",
-                     pStreamEx->Core.szName, PDMAudioPropsFramesToMilli(&pCfgAcq->Props, pCfgAcq->Backend.cFramesPreBuffering), pCfgAcq->Backend.cFramesPreBuffering));
+    if (CfgReq.Backend.cFramesPreBuffering)
+    {
+        if (pCfgAcq->Backend.cFramesPreBuffering != CfgReq.Backend.cFramesPreBuffering)
+            LogRel2(("Audio: Backend changed pre-buffering size from %RU64ms (%RU32 frames) to %RU64ms (%RU32 frames)\n",
+                     PDMAudioPropsFramesToMilli(&CfgReq.Props, CfgReq.Backend.cFramesPreBuffering), CfgReq.Backend.cFramesPreBuffering,
+                     PDMAudioPropsFramesToMilli(&pCfgAcq->Props, pCfgAcq->Backend.cFramesPreBuffering), pCfgAcq->Backend.cFramesPreBuffering));
 
         if (pCfgAcq->Backend.cFramesPreBuffering > pCfgAcq->Backend.cFramesBufferSize)
         {
             pCfgAcq->Backend.cFramesPreBuffering = pCfgAcq->Backend.cFramesBufferSize;
-            LogRel2(("Audio: Pre-buffering size bigger than buffer size for stream '%s', adjusting to %RU64ms (%RU32 frames)\n",
-                     pStreamEx->Core.szName, PDMAudioPropsFramesToMilli(&pCfgAcq->Props, pCfgAcq->Backend.cFramesPreBuffering), pCfgAcq->Backend.cFramesPreBuffering));
+            LogRel2(("Audio: Pre-buffering size bigger than buffer size for stream '%s', adjusting to %RU64ms (%RU32 frames)\n", pCfgAcq->szName,
+                     PDMAudioPropsFramesToMilli(&pCfgAcq->Props, pCfgAcq->Backend.cFramesPreBuffering), pCfgAcq->Backend.cFramesPreBuffering));
         }
     }
-    else if (pCfgReq->Backend.cFramesPreBuffering == 0) /* Was the pre-buffering requested as being disabeld? Tell the users. */
-    {
-        LogRel2(("Audio: Pre-buffering is disabled for stream '%s'\n", pStreamEx->Core.szName));
+    else if (CfgReq.Backend.cFramesPreBuffering == 0) /* Was the pre-buffering requested as being disabeld? Tell the users. */
+    {
+        LogRel2(("Audio: Pre-buffering is disabled for stream '%s'\n", pCfgAcq->szName));
         pCfgAcq->Backend.cFramesPreBuffering = 0;
     }
@@ -1551 +1537 @@
                     VERR_INVALID_PARAMETER);
 
+    /*
+     * Check if the backend did return sane values and correct if necessary.
+     * Should never happen with our own backends, but you never know ...
+     */
+    uint32_t const cFramesPreBufferingMax = pCfgAcq->Backend.cFramesBufferSize - RT_MIN(16, pCfgAcq->Backend.cFramesBufferSize);
+    if (pCfgAcq->Backend.cFramesPreBuffering > cFramesPreBufferingMax)
+    {
+        LogRel2(("Audio: Warning: Pre-buffering size of %RU32 frames for stream '%s' is too close to or larger than the %RU32 frames buffer size, reducing it to %RU32 frames!\n",
+                 pCfgAcq->Backend.cFramesPreBuffering, pCfgAcq->szName, pCfgAcq->Backend.cFramesBufferSize, cFramesPreBufferingMax));
+        AssertFailed();
+        pCfgAcq->Backend.cFramesPreBuffering = cFramesPreBufferingMax;
+    }
+
+    if (pCfgAcq->Backend.cFramesPeriod > pCfgAcq->Backend.cFramesBufferSize)
+    {
+        LogRel2(("Audio: Warning: Period size of %RU32 frames for stream '%s' is larger than the %RU32 frames buffer size, reducing it to %RU32 frames!\n",
+                 pCfgAcq->Backend.cFramesPeriod, pCfgAcq->szName, pCfgAcq->Backend.cFramesBufferSize, pCfgAcq->Backend.cFramesBufferSize / 2));
+        AssertFailed();
+        pCfgAcq->Backend.cFramesPeriod = pCfgAcq->Backend.cFramesBufferSize / 2;
+    }
+
+    LogRel2(("Audio: Buffer size for stream '%s' is %RU64 ms / %RU32 frames\n", pCfgAcq->szName,
+             PDMAudioPropsFramesToMilli(&pCfgAcq->Props, pCfgAcq->Backend.cFramesBufferSize), pCfgAcq->Backend.cFramesBufferSize));
+    LogRel2(("Audio: Pre-buffering size for stream '%s' is %RU64 ms / %RU32 frames\n", pCfgAcq->szName,
+             PDMAudioPropsFramesToMilli(&pCfgAcq->Props, pCfgAcq->Backend.cFramesPreBuffering), pCfgAcq->Backend.cFramesPreBuffering));
+    LogRel2(("Audio: Scheduling hint for stream '%s' is %RU32ms / %RU32 frames\n", pCfgAcq->szName,
+             pCfgAcq->Device.cMsSchedulingHint, PDMAudioPropsMilliToFrames(&pCfgAcq->Props, pCfgAcq->Device.cMsSchedulingHint)));
+
+    /* Make sure the configured buffer size by the backend at least can hold the configured latency. */
+    uint32_t const cMsPeriod = PDMAudioPropsFramesToMilli(&pCfgAcq->Props, pCfgAcq->Backend.cFramesPeriod);
+    LogRel2(("Audio: Period size of stream '%s' is %RU64 ms / %RU32 frames\n",
+             pCfgAcq->szName, cMsPeriod, pCfgAcq->Backend.cFramesPeriod));
+    /** @todo r=bird: This is probably a misleading/harmless warning as we'd just
+     *        have to transfer more each time we move data.  The period is generally
+     *        pure irrelevant fiction anyway.  A more relevant comparison would
+     *        be to half the buffer size, i.e. making sure we get scheduled often
+     *        enough to keep the buffer at least half full (probably more
+     *        sensible if the buffer size was more than 2x scheduling periods). */
+    if (   CfgReq.Device.cMsSchedulingHint              /* Any scheduling hint set? */
+        && CfgReq.Device.cMsSchedulingHint > cMsPeriod) /* This might lead to buffer underflows. */
+        LogRel(("Audio: Warning: Scheduling hint of stream '%s' is bigger (%RU64ms) than used period size (%RU64ms)\n",
+                pCfgAcq->szName, CfgReq.Device.cMsSchedulingHint, cMsPeriod));
+
+    /*
+     * Done, just log the result:
+     */
+    LogFunc(("[%s] Acquired format: %s\n",  pCfgAcq->szName,
+             PDMAudioStrmCfgToString(&pStreamEx->Core.Cfg, szTmp, sizeof(szTmp)) ));
+    LogRel2(("Audio: Acquired format: %s\n", PDMAudioStrmCfgToString(&pStreamEx->Core.Cfg, szTmp, sizeof(szTmp)) ));
+
     return VINF_SUCCESS;
 }
@@ -1560 +1596 @@
  * @returns VBox status code.
  * @param   pThis       Pointer to driver instance.
- * @param   pStreamEx   Stream to initialize.
- * @param   pCfgHost    Stream configuration to use for the host side (backend).
- *                      This will be adjusted.
- * @param   pCfgGuest   Stream configuration to use for the guest side.
- */
-static int drvAudioStreamInitInternal(PDRVAUDIO pThis, PDRVAUDIOSTREAM pStreamEx,
-                                      PPDMAUDIOSTREAMCFG pCfgHost, PCPDMAUDIOSTREAMCFG pCfgGuest)
+ * @param   pStreamEx   Stream to initialize.  Caller already set a few fields.
+ *                      The Core.Cfg field contains the requested configuration
+ *                      when we're called and the actual configuration when
+ *                      successfully returning.
+ */
+static int drvAudioStreamInitInternal(PDRVAUDIO pThis, PDRVAUDIOSTREAM pStreamEx)
 {
     /*
@@ -1573 +1608 @@
     pStreamEx->Core.uMagic = PDMAUDIOSTREAM_MAGIC;
 
-#ifdef LOG_ENABLED
-    LogFunc(("[%s] Requested host format:\n", pStreamEx->Core.szName));
-    PDMAudioStrmCfgLog(pCfgHost);
-#endif
-
-    LogRel2(("Audio: Creating stream '%s'\n", pStreamEx->Core.szName));
-    LogRel2(("Audio: Guest %s format for '%s': %RU32Hz, %u%s, %RU8 channel%s\n",
-             pCfgGuest->enmDir == PDMAUDIODIR_IN ? "recording" : "playback", pStreamEx->Core.szName,
-             pCfgGuest->Props.uHz, PDMAudioPropsSampleBits(&pCfgGuest->Props), pCfgGuest->Props.fSigned ? "S" : "U",
-             PDMAudioPropsChannels(&pCfgGuest->Props), PDMAudioPropsChannels(&pCfgGuest->Props) == 1 ? "" : "s"));
-    LogRel2(("Audio: Requested host %s format for '%s': %RU32Hz, %u%s, %RU8 channel%s\n",
-             pCfgHost->enmDir == PDMAUDIODIR_IN ? "recording" : "playback", pStreamEx->Core.szName,
-             pCfgHost->Props.uHz, PDMAudioPropsSampleBits(&pCfgHost->Props), pCfgHost->Props.fSigned ? "S" : "U",
-             PDMAudioPropsChannels(&pCfgHost->Props), PDMAudioPropsChannels(&pCfgHost->Props) == 1 ? "" : "s"));
-
-    PDMAUDIOSTREAMCFG CfgHostAcq;
-    int rc = drvAudioStreamCreateInternalBackend(pThis, pStreamEx, pCfgHost, &CfgHostAcq);
+    char szTmp[PDMAUDIOSTRMCFGTOSTRING_MAX];
+    LogFunc(("[%s] Requested host format: %s\n", pStreamEx->Core.Cfg.szName,
+             PDMAudioStrmCfgToString(&pStreamEx->Core.Cfg, szTmp, sizeof(szTmp)) ));
+    LogRel2(("Audio: Creating stream: %s\n", PDMAudioStrmCfgToString(&pStreamEx->Core.Cfg, szTmp, sizeof(szTmp))));
+
+    int rc = drvAudioStreamCreateInternalBackend(pThis, pStreamEx);
     if (RT_FAILURE(rc))
         return rc;
 
-    LogFunc(("[%s] Acquired host format:\n",  pStreamEx->Core.szName));
-    PDMAudioStrmCfgLog(&CfgHostAcq);
-    LogRel2(("Audio: Acquired host %s format for '%s': %RU32Hz, %u%s, %RU8 channel%s\n",
-             CfgHostAcq.enmDir == PDMAUDIODIR_IN ? "recording" : "playback",  pStreamEx->Core.szName,
-             CfgHostAcq.Props.uHz, PDMAudioPropsSampleBits(&CfgHostAcq.Props), CfgHostAcq.Props.fSigned ? "S" : "U",
-             PDMAudioPropsChannels(&CfgHostAcq.Props), PDMAudioPropsChannels(&CfgHostAcq.Props) == 1 ? "" : "s"));
-    Assert(PDMAudioPropsAreValid(&CfgHostAcq.Props));
-
-    /* Set the stream properties. */
-    pStreamEx->Core.Props = CfgHostAcq.Props;
-
-    /* Let the user know if the backend changed some of the tweakable values. */
-    if (CfgHostAcq.Backend.cFramesBufferSize != pCfgHost->Backend.cFramesBufferSize)
-        LogRel2(("Audio: Backend changed buffer size from %RU64ms (%RU32 frames) to %RU64ms (%RU32 frames)\n",
-                 PDMAudioPropsFramesToMilli(&pCfgHost->Props, pCfgHost->Backend.cFramesBufferSize), pCfgHost->Backend.cFramesBufferSize,
-                 PDMAudioPropsFramesToMilli(&CfgHostAcq.Props, CfgHostAcq.Backend.cFramesBufferSize), CfgHostAcq.Backend.cFramesBufferSize));
-
-    if (CfgHostAcq.Backend.cFramesPeriod != pCfgHost->Backend.cFramesPeriod)
-        LogRel2(("Audio: Backend changed period size from %RU64ms (%RU32 frames) to %RU64ms (%RU32 frames)\n",
-                 PDMAudioPropsFramesToMilli(&pCfgHost->Props, pCfgHost->Backend.cFramesPeriod), pCfgHost->Backend.cFramesPeriod,
-                 PDMAudioPropsFramesToMilli(&CfgHostAcq.Props, CfgHostAcq.Backend.cFramesPeriod), CfgHostAcq.Backend.cFramesPeriod));
-
-    if (CfgHostAcq.Backend.cFramesPreBuffering != pCfgHost->Backend.cFramesPreBuffering)
-        LogRel2(("Audio: Backend changed pre-buffering size from %RU64ms (%RU32 frames) to %RU64ms (%RU32 frames)\n",
-                 PDMAudioPropsFramesToMilli(&pCfgHost->Props, pCfgHost->Backend.cFramesPreBuffering), pCfgHost->Backend.cFramesPreBuffering,
-                 PDMAudioPropsFramesToMilli(&CfgHostAcq.Props, CfgHostAcq.Backend.cFramesPreBuffering), CfgHostAcq.Backend.cFramesPreBuffering));
-
-    /*
-     * Check if the backend did return sane values and correct if necessary.
-     * Should never happen with our own backends, but you never know ...
-     */
-    uint32_t const cFramesPreBufferingMax = CfgHostAcq.Backend.cFramesBufferSize - RT_MIN(16, CfgHostAcq.Backend.cFramesBufferSize);
-    if (CfgHostAcq.Backend.cFramesPreBuffering > cFramesPreBufferingMax)
-    {
-        LogRel2(("Audio: Warning: Pre-buffering size of %RU32 frames for stream '%s' is too close to or larger than the %RU32 frames buffer size, reducing it to %RU32 frames!\n",
-                 CfgHostAcq.Backend.cFramesPreBuffering, pStreamEx->Core.szName, CfgHostAcq.Backend.cFramesBufferSize, cFramesPreBufferingMax));
-        AssertFailed();
-        CfgHostAcq.Backend.cFramesPreBuffering = cFramesPreBufferingMax;
-    }
-
-    if (CfgHostAcq.Backend.cFramesPeriod > CfgHostAcq.Backend.cFramesBufferSize)
-    {
-        LogRel2(("Audio: Warning: Period size of %RU32 frames for stream '%s' is larger than the %RU32 frames buffer size, reducing it to %RU32 frames!\n",
-                 CfgHostAcq.Backend.cFramesPeriod, pStreamEx->Core.szName, CfgHostAcq.Backend.cFramesBufferSize, CfgHostAcq.Backend.cFramesBufferSize / 2));
-        AssertFailed();
-        CfgHostAcq.Backend.cFramesPeriod = CfgHostAcq.Backend.cFramesBufferSize / 2;
-    }
-
-    LogRel2(("Audio: Buffer size of stream '%s' is %RU64 ms / %RU32 frames\n", pStreamEx->Core.szName,
-             PDMAudioPropsFramesToMilli(&CfgHostAcq.Props, CfgHostAcq.Backend.cFramesBufferSize), CfgHostAcq.Backend.cFramesBufferSize));
-    LogRel2(("Audio: Pre-buffering size of stream '%s' is %RU64 ms / %RU32 frames\n", pStreamEx->Core.szName,
-             PDMAudioPropsFramesToMilli(&CfgHostAcq.Props, CfgHostAcq.Backend.cFramesPreBuffering), CfgHostAcq.Backend.cFramesPreBuffering));
-
-    /* Make sure the configured buffer size by the backend at least can hold the configured latency. */
-    const uint32_t msPeriod = PDMAudioPropsFramesToMilli(&CfgHostAcq.Props, CfgHostAcq.Backend.cFramesPeriod);
-    LogRel2(("Audio: Period size of stream '%s' is %RU64 ms / %RU32 frames\n",
-             pStreamEx->Core.szName, msPeriod, CfgHostAcq.Backend.cFramesPeriod));
-
-    if (   pCfgGuest->Device.cMsSchedulingHint             /* Any scheduling hint set? */
-        && pCfgGuest->Device.cMsSchedulingHint > msPeriod) /* This might lead to buffer underflows. */
-        LogRel(("Audio: Warning: Scheduling hint of stream '%s' is bigger (%RU64ms) than used period size (%RU64ms)\n",
-                pStreamEx->Core.szName, pCfgGuest->Device.cMsSchedulingHint, msPeriod));
-
-    /*
-     * Make a copy of the acquired host stream configuration and the guest side one.
-     */
-    rc = PDMAudioStrmCfgCopy(&pStreamEx->Host.Cfg, &CfgHostAcq);
-    AssertRC(rc);
-
-    rc = PDMAudioStrmCfgCopy(&pStreamEx->Guest.Cfg, pCfgGuest);
-    AssertRC(rc);
-
     /*
      * Configure host buffers.
      */
     Assert(pStreamEx->cbPreBufThreshold == 0);
-    if (CfgHostAcq.Backend.cFramesPreBuffering != 0)
-        pStreamEx->cbPreBufThreshold = PDMAudioPropsFramesToBytes(&CfgHostAcq.Props, CfgHostAcq.Backend.cFramesPreBuffering);
+    if (pStreamEx->Core.Cfg.Backend.cFramesPreBuffering != 0)
+        pStreamEx->cbPreBufThreshold = PDMAudioPropsFramesToBytes(&pStreamEx->Core.Cfg.Props,
+                                                                  pStreamEx->Core.Cfg.Backend.cFramesPreBuffering);
 
     /* Allocate space for pre-buffering of output stream w/o mixing buffers. */
-    if (pCfgHost->enmDir == PDMAUDIODIR_OUT)
+    if (pStreamEx->Core.Cfg.enmDir == PDMAUDIODIR_OUT)
     {
         Assert(pStreamEx->Out.cbPreBufAlloc == 0);
         Assert(pStreamEx->Out.cbPreBuffered == 0);
         Assert(pStreamEx->Out.offPreBuf == 0);
-        if (CfgHostAcq.Backend.cFramesPreBuffering != 0)
+        if (pStreamEx->Core.Cfg.Backend.cFramesPreBuffering != 0)
         {
-            pStreamEx->Out.cbPreBufAlloc     = PDMAudioPropsFramesToBytes(&CfgHostAcq.Props,
-                                                                          CfgHostAcq.Backend.cFramesBufferSize - 2);
+            pStreamEx->Out.cbPreBufAlloc     = PDMAudioPropsFramesToBytes(&pStreamEx->Core.Cfg.Props,
+                                                                          pStreamEx->Core.Cfg.Backend.cFramesBufferSize - 2);
             pStreamEx->Out.cbPreBufAlloc     = RT_MIN(RT_ALIGN_32(pStreamEx->cbPreBufThreshold + _8K, _4K),
                                                       pStreamEx->Out.cbPreBufAlloc);
@@ -1691 +1644 @@
 
     /*
-     * Init guest stream.
-     */
-    if (pCfgGuest->Device.cMsSchedulingHint)
-        LogRel2(("Audio: Stream '%s' got a scheduling hint of %RU32ms (%RU32 bytes)\n",
-                 pStreamEx->Core.szName, pCfgGuest->Device.cMsSchedulingHint,
-                 PDMAudioPropsMilliToBytes(&pCfgGuest->Props, pCfgGuest->Device.cMsSchedulingHint)));
-
-    /*
      * Register statistics.
      */
     PPDMDRVINS const pDrvIns = pThis->pDrvIns;
     /** @todo expose config and more. */
-    PDMDrvHlpSTAMRegisterF(pDrvIns, &pStreamEx->Host.Cfg.Backend.cFramesBufferSize, STAMTYPE_U32, STAMVISIBILITY_USED, STAMUNIT_NONE,
-                           "Host side: The size of the backend buffer (in frames)", "%s/0-HostBackendBufSize", pStreamEx->Core.szName);
-    if (pCfgGuest->enmDir == PDMAUDIODIR_IN)
+    PDMDrvHlpSTAMRegisterF(pDrvIns, &pStreamEx->Core.Cfg.Backend.cFramesBufferSize, STAMTYPE_U32, STAMVISIBILITY_USED, STAMUNIT_NONE,
+                           "Host side: The size of the backend buffer (in frames)", "%s/0-HostBackendBufSize", pStreamEx->Core.Cfg.szName);
+    if (pStreamEx->Core.Cfg.enmDir == PDMAUDIODIR_IN)
     {
         /** @todo later? */
@@ -1712 +1657 @@
     {
         PDMDrvHlpSTAMRegisterF(pDrvIns, &pStreamEx->Out.Stats.cbBackendWritableBefore, STAMTYPE_U32, STAMVISIBILITY_USED, STAMUNIT_NONE,
-                               "Host side: Free space in backend buffer before play", "%s/0-HostBackendBufFreeBefore", pStreamEx->Core.szName);
+                               "Host side: Free space in backend buffer before play", "%s/0-HostBackendBufFreeBefore", pStreamEx->Core.Cfg.szName);
         PDMDrvHlpSTAMRegisterF(pDrvIns, &pStreamEx->Out.Stats.cbBackendWritableAfter, STAMTYPE_U32, STAMVISIBILITY_USED, STAMUNIT_NONE,
-                               "Host side: Free space in backend buffer after play",  "%s/0-HostBackendBufFreeAfter", pStreamEx->Core.szName);
+                               "Host side: Free space in backend buffer after play",  "%s/0-HostBackendBufFreeAfter", pStreamEx->Core.Cfg.szName);
     }
 
 #ifdef VBOX_WITH_STATISTICS
-    if (pCfgGuest->enmDir == PDMAUDIODIR_IN)
+    if (pStreamEx->Core.Cfg.enmDir == PDMAUDIODIR_IN)
     {
         PDMDrvHlpSTAMRegisterF(pDrvIns, &pStreamEx->In.Stats.TotalFramesCaptured, STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_NONE,
-                               "Total frames played.", "%s/TotalFramesCaptured", pStreamEx->Core.szName);
+                               "Total frames played.", "%s/TotalFramesCaptured", pStreamEx->Core.Cfg.szName);
         PDMDrvHlpSTAMRegisterF(pDrvIns, &pStreamEx->In.Stats.TotalTimesCaptured, STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_NONE,
-                               "Total number of playbacks.", "%s/TotalTimesCaptured", pStreamEx->Core.szName);
+                               "Total number of playbacks.", "%s/TotalTimesCaptured", pStreamEx->Core.Cfg.szName);
         PDMDrvHlpSTAMRegisterF(pDrvIns, &pStreamEx->In.Stats.TotalTimesRead, STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_NONE,
-                               "Total number of reads.", "%s/TotalTimesRead", pStreamEx->Core.szName);
+                               "Total number of reads.", "%s/TotalTimesRead", pStreamEx->Core.Cfg.szName);
     }
     else
     {
-        Assert(pCfgGuest->enmDir == PDMAUDIODIR_OUT);
+        Assert(pStreamEx->Core.Cfg.enmDir == PDMAUDIODIR_OUT);
     }
 #endif /* VBOX_WITH_STATISTICS */
 
-    LogFlowFunc(("[%s] Returning %Rrc\n", pStreamEx->Core.szName, rc));
+    LogFlowFunc(("[%s] Returning %Rrc\n", pStreamEx->Core.Cfg.szName, rc));
     return rc;
 }
@@ -1741 +1686 @@
  * @interface_method_impl{PDMIAUDIOCONNECTOR,pfnStreamCreate}
  */
-static DECLCALLBACK(int) drvAudioStreamCreate(PPDMIAUDIOCONNECTOR pInterface, uint32_t fFlags, PPDMAUDIOSTREAMCFG pCfgHost,
-                                              PPDMAUDIOSTREAMCFG pCfgGuest, PPDMAUDIOSTREAM *ppStream)
+static DECLCALLBACK(int) drvAudioStreamCreate(PPDMIAUDIOCONNECTOR pInterface, uint32_t fFlags, PCPDMAUDIOSTREAMCFG pCfgReq,
+                                              PPDMAUDIOSTREAM *ppStream)
 {
     PDRVAUDIO pThis = RT_FROM_MEMBER(pInterface, DRVAUDIO, IAudioConnector);
@@ -1751 +1696 @@
      */
     AssertReturn(!(fFlags & ~PDMAUDIOSTREAM_CREATE_F_NO_MIXBUF), VERR_INVALID_FLAGS);
-    AssertPtrReturn(pCfgHost,   VERR_INVALID_POINTER);
-    AssertPtrReturn(pCfgGuest,  VERR_INVALID_POINTER);
-    AssertPtrReturn(ppStream,   VERR_INVALID_POINTER);
-    LogFlowFunc(("Host=%s, Guest=%s\n", pCfgHost->szName, pCfgGuest->szName));
+    AssertPtrReturn(pCfgReq, VERR_INVALID_POINTER);
+    AssertPtrReturn(ppStream, VERR_INVALID_POINTER);
+    *ppStream = NULL;
+    LogFlowFunc(("pCfgReq=%s\n", pCfgReq->szName));
 #ifdef LOG_ENABLED
-    PDMAudioStrmCfgLog(pCfgHost);
-    PDMAudioStrmCfgLog(pCfgGuest);
+    PDMAudioStrmCfgLog(pCfgReq);
 #endif
-    AssertReturn(AudioHlpStreamCfgIsValid(pCfgHost), VERR_INVALID_PARAMETER);
-    AssertReturn(AudioHlpStreamCfgIsValid(pCfgGuest), VERR_INVALID_PARAMETER);
-    AssertReturn(pCfgHost->enmDir == pCfgGuest->enmDir, VERR_MISMATCH);
-    AssertReturn(pCfgHost->enmDir == PDMAUDIODIR_IN || pCfgHost->enmDir == PDMAUDIODIR_OUT, VERR_NOT_SUPPORTED);
+    AssertReturn(AudioHlpStreamCfgIsValid(pCfgReq), VERR_INVALID_PARAMETER);
+    AssertReturn(pCfgReq->enmDir == PDMAUDIODIR_IN || pCfgReq->enmDir == PDMAUDIODIR_OUT, VERR_NOT_SUPPORTED);
 
     /*
@@ -1770 +1712 @@
     AssertRCReturn(rc, rc);
 
-    uint32_t * const pcFreeStreams = pCfgHost->enmDir == PDMAUDIODIR_IN ? &pThis->In.cStreamsFree : &pThis->Out.cStreamsFree;
+    uint32_t * const pcFreeStreams = pCfgReq->enmDir == PDMAUDIODIR_IN ? &pThis->In.cStreamsFree : &pThis->Out.cStreamsFree;
     if (*pcFreeStreams > 0)
         *pcFreeStreams -= 1;
@@ -1776 +1718 @@
     {
         RTCritSectRwLeaveExcl(&pThis->CritSectGlobals);
-        LogFlowFunc(("Maximum number of host %s streams reached\n", PDMAudioDirGetName(pCfgHost->enmDir) ));
-        return pCfgHost->enmDir == PDMAUDIODIR_IN ? VERR_AUDIO_NO_FREE_INPUT_STREAMS : VERR_AUDIO_NO_FREE_OUTPUT_STREAMS;
+        LogFlowFunc(("Maximum number of host %s streams reached\n", PDMAudioDirGetName(pCfgReq->enmDir) ));
+        return pCfgReq->enmDir == PDMAUDIODIR_IN ? VERR_AUDIO_NO_FREE_INPUT_STREAMS : VERR_AUDIO_NO_FREE_OUTPUT_STREAMS;
     }
 
@@ -1811 +1753 @@
 
                 pStreamEx->pBackend             = pBackend;
-                pStreamEx->Core.enmDir          = pCfgHost->enmDir;
+                pStreamEx->Core.Cfg             = *pCfgReq;
                 pStreamEx->Core.cbBackend       = (uint32_t)cbHstStrm;
                 pStreamEx->fDestroyImmediate    = true;
@@ -1819 +1761 @@
                 /* Make a unqiue stream name including the host (backend) driver name. */
                 AssertPtr(pThis->pHostDrvAudio);
-                size_t cchName = RTStrPrintf(pStreamEx->Core.szName, RT_ELEMENTS(pStreamEx->Core.szName), "[%s] %s:0",
-                                             pThis->BackendCfg.szName, pCfgHost->szName[0] != '\0' ? pCfgHost->szName : "<NoName>");
-                if (cchName < sizeof(pStreamEx->Core.szName))
+                size_t cchName = RTStrPrintf(pStreamEx->Core.Cfg.szName, RT_ELEMENTS(pStreamEx->Core.Cfg.szName), "[%s] %s:0",
+                                             pThis->BackendCfg.szName, pCfgReq->szName[0] != '\0' ? pCfgReq->szName : "<NoName>");
+                if (cchName < sizeof(pStreamEx->Core.Cfg.szName))
                 {
                     RTCritSectRwEnterShared(&pThis->CritSectGlobals);
@@ -1830 +1772 @@
                         RTListForEach(&pThis->LstStreams, pIt, DRVAUDIOSTREAM, ListEntry)
                         {
-                            if (strcmp(pIt->Core.szName, pStreamEx->Core.szName) == 0)
+                            if (strcmp(pIt->Core.Cfg.szName, pStreamEx->Core.Cfg.szName) == 0)
                             {
-                                RTStrPrintf(pStreamEx->Core.szName, RT_ELEMENTS(pStreamEx->Core.szName), "[%s] %s:%u",
-                                            pThis->BackendCfg.szName, pCfgHost->szName[0] != '\0' ? pCfgHost->szName : "<NoName>",
+                                RTStrPrintf(pStreamEx->Core.Cfg.szName, RT_ELEMENTS(pStreamEx->Core.Cfg.szName), "[%s] %s:%u",
+                                            pThis->BackendCfg.szName, pCfgReq->szName[0] != '\0' ? pCfgReq->szName : "<NoName>",
                                             i);
                                 fDone = false;
@@ -1848 +1790 @@
                  * Try to init the rest.
                  */
-                rc = drvAudioStreamInitInternal(pThis, pStreamEx, pCfgHost, pCfgGuest);
+                rc = drvAudioStreamInitInternal(pThis, pStreamEx);
                 if (RT_SUCCESS(rc))
                 {
@@ -1866 +1808 @@
                      * Init debug stuff if enabled (ignore failures).
                      */
-                    if (pCfgHost->enmDir == PDMAUDIODIR_IN)
+                    if (pCfgReq->enmDir == PDMAUDIODIR_IN)
                     {
                         if (pThis->CfgIn.Dbg.fEnabled)
                             AudioHlpFileCreateAndOpen(&pStreamEx->In.Dbg.pFileCapture, pThis->CfgIn.Dbg.szPathOut,
-                                                      "DrvAudioCapture", pThis->pDrvIns->iInstance, &pStreamEx->Host.Cfg.Props);
+                                                      "DrvAudioCapture", pThis->pDrvIns->iInstance, &pStreamEx->Core.Cfg.Props);
                     }
                     else /* Out */
@@ -1876 +1818 @@
                         if (pThis->CfgOut.Dbg.fEnabled)
                             AudioHlpFileCreateAndOpen(&pStreamEx->Out.Dbg.pFilePlay, pThis->CfgOut.Dbg.szPathOut,
-                                                      "DrvAudioPlay", pThis->pDrvIns->iInstance, &pStreamEx->Host.Cfg.Props);
+                                                      "DrvAudioPlay", pThis->pDrvIns->iInstance, &pStreamEx->Core.Cfg.Props);
                     }
 
@@ -1957 +1899 @@
     char szStreamSts[DRVAUDIO_STATUS_STR_MAX];
 #endif
-    LogFunc(("[%s] fStatus=%s\n", pStreamEx->Core.szName, drvAudioStreamStatusToStr(szStreamSts, pStreamEx->fStatus)));
+    LogFunc(("[%s] fStatus=%s\n", pStreamEx->Core.Cfg.szName, drvAudioStreamStatusToStr(szStreamSts, pStreamEx->fStatus)));
 
     if (pStreamEx->fStatus & PDMAUDIOSTREAM_STS_BACKEND_CREATED)
@@ -1974 +1916 @@
     }
 
-    LogFlowFunc(("[%s] Returning %Rrc\n", pStreamEx->Core.szName, rc));
+    LogFlowFunc(("[%s] Returning %Rrc\n", pStreamEx->Core.Cfg.szName, rc));
     return rc;
 }
@@ -1991 +1933 @@
     AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
     AssertMsgReturn(pStreamEx->cRefs <= 1,
-                    ("Stream '%s' still has %RU32 references held when uninitializing\n", pStreamEx->Core.szName, pStreamEx->cRefs),
+                    ("Stream '%s' still has %RU32 references held when uninitializing\n", pStreamEx->Core.Cfg.szName, pStreamEx->cRefs),
                     VERR_WRONG_ORDER);
-    LogFlowFunc(("[%s] cRefs=%RU32\n", pStreamEx->Core.szName, pStreamEx->cRefs));
+    LogFlowFunc(("[%s] cRefs=%RU32\n", pStreamEx->Core.Cfg.szName, pStreamEx->cRefs));
 
     RTCritSectEnter(&pStreamEx->Core.CritSect);
@@ -2005 +1947 @@
 
     /* Free pre-buffer space. */
-    if (   pStreamEx->Core.enmDir == PDMAUDIODIR_OUT
+    if (   pStreamEx->Core.Cfg.enmDir == PDMAUDIODIR_OUT
         && pStreamEx->Out.pbPreBuf)
     {
@@ -2022 +1964 @@
             char szStreamSts[DRVAUDIO_STATUS_STR_MAX];
             LogFunc(("[%s] Warning: Still has %s set when uninitializing\n",
-                     pStreamEx->Core.szName, drvAudioStreamStatusToStr(szStreamSts, pStreamEx->fStatus)));
+                     pStreamEx->Core.Cfg.szName, drvAudioStreamStatusToStr(szStreamSts, pStreamEx->fStatus)));
         }
 #endif
@@ -2029 +1971 @@
 
     PPDMDRVINS const pDrvIns = pThis->pDrvIns;
-    PDMDrvHlpSTAMDeregisterByPrefix(pDrvIns, pStreamEx->Core.szName);
-
-    if (pStreamEx->Core.enmDir == PDMAUDIODIR_IN)
+    PDMDrvHlpSTAMDeregisterByPrefix(pDrvIns, pStreamEx->Core.Cfg.szName);
+
+    if (pStreamEx->Core.Cfg.enmDir == PDMAUDIODIR_IN)
     {
         if (pThis->CfgIn.Dbg.fEnabled)
@@ -2041 +1983 @@
     else
     {
-        Assert(pStreamEx->Core.enmDir == PDMAUDIODIR_OUT);
+        Assert(pStreamEx->Core.Cfg.enmDir == PDMAUDIODIR_OUT);
         if (pThis->CfgOut.Dbg.fEnabled)
         {
@@ -2087 +2029 @@
             RTCritSectRwEnterExcl(&pThis->CritSectGlobals);
 
-            if (pStreamEx->Core.enmDir == PDMAUDIODIR_IN)
+            if (pStreamEx->Core.Cfg.enmDir == PDMAUDIODIR_IN)
                 pThis->In.cStreamsFree++;
             else /* Out */
@@ -2101 +2043 @@
         else
         {
-            LogRel(("Audio: Uninitializing stream '%s' failed with %Rrc\n", pStreamEx->Core.szName, rc));
+            LogRel(("Audio: Uninitializing stream '%s' failed with %Rrc\n", pStreamEx->Core.Cfg.szName, rc));
             /** @todo r=bird: What's the plan now? */
         }
@@ -2111 +2053 @@
     }
 
-    Log12Func(("returns %u (%s)\n", cRefs, cRefs > 0 ? pStreamEx->Core.szName : "destroyed"));
+    Log12Func(("returns %u (%s)\n", cRefs, cRefs > 0 ? pStreamEx->Core.Cfg.szName : "destroyed"));
     return cRefs;
 }
@@ -2127 +2069 @@
 static DECLCALLBACK(void) drvAudioStreamDestroyAsync(PDRVAUDIO pThis, PDRVAUDIOSTREAM pStreamEx, bool fImmediate)
 {
-    LogFlowFunc(("pThis=%p pStreamEx=%p (%s) fImmediate=%RTbool\n", pThis, pStreamEx, pStreamEx->Core.szName, fImmediate));
+    LogFlowFunc(("pThis=%p pStreamEx=%p (%s) fImmediate=%RTbool\n", pThis, pStreamEx, pStreamEx->Core.Cfg.szName, fImmediate));
 #ifdef LOG_ENABLED
     uint64_t const nsStart = RTTimeNanoTS();
@@ -2166 +2108 @@
     PDRVAUDIOSTREAM pStreamEx = (PDRVAUDIOSTREAM)pStream;   /* Note! Do not touch pStream after this! */
     AssertPtrReturn(pStreamEx, VERR_INVALID_POINTER);
-    LogFlowFunc(("ENTER - %p (%s) fImmediate=%RTbool\n", pStreamEx, pStreamEx->Core.szName, fImmediate));
+    LogFlowFunc(("ENTER - %p (%s) fImmediate=%RTbool\n", pStreamEx, pStreamEx->Core.Cfg.szName, fImmediate));
     AssertReturn(pStreamEx->Core.uMagic == PDMAUDIOSTREAM_MAGIC, VERR_INVALID_MAGIC);
     AssertReturn(pStreamEx->uMagic == DRVAUDIOSTREAM_MAGIC, VERR_INVALID_MAGIC);
@@ -2185 +2127 @@
             char szStatus[DRVAUDIO_STATUS_STR_MAX];
             LogRel2(("Audio: Destroying stream '%s': cRefs=%u; status: %s; backend: %s; hReqInitAsync=%p\n",
-                     pStreamEx->Core.szName, pStreamEx->cRefs, drvAudioStreamStatusToStr(szStatus, pStreamEx->fStatus),
+                     pStreamEx->Core.Cfg.szName, pStreamEx->cRefs, drvAudioStreamStatusToStr(szStatus, pStreamEx->fStatus),
                      PDMHostAudioStreamStateGetName(drvAudioStreamGetBackendState(pThis, pStreamEx)),
                      pStreamEx->hReqInitAsync));
@@ -2263 +2205 @@
 static void drvAudioStreamResetInternal(PDRVAUDIOSTREAM pStreamEx)
 {
-    LogFunc(("[%s]\n", pStreamEx->Core.szName));
+    LogFunc(("[%s]\n", pStreamEx->Core.Cfg.szName));
     Assert(RTCritSectIsOwner(&pStreamEx->Core.CritSect));
 
@@ -2269 +2211 @@
     pStreamEx->nsLastPlayedCaptured = 0;
     pStreamEx->nsLastReadWritten    = 0;
-    if (pStreamEx->Host.Cfg.enmDir == PDMAUDIODIR_OUT)
+    if (pStreamEx->Core.Cfg.enmDir == PDMAUDIODIR_OUT)
     {
         pStreamEx->Out.cbPreBuffered = 0;
@@ -2298 +2240 @@
 {
     char szTmp[RT_MAX(PDMAUDIOSTRMCFGTOSTRING_MAX, DRVAUDIO_STATUS_STR_MAX)];
-    LogFlowFunc(("[%s] status: %s\n", pStreamEx->Core.szName, drvAudioStreamStatusToStr(szTmp, pStreamEx->fStatus) ));
+    LogFlowFunc(("[%s] status: %s\n", pStreamEx->Core.Cfg.szName, drvAudioStreamStatusToStr(szTmp, pStreamEx->fStatus) ));
     Assert(RTCritSectIsOwner(&pStreamEx->Core.CritSect));
     RTCritSectRwEnterShared(&pThis->CritSectHotPlug);
@@ -2317 +2259 @@
         drvAudioStreamResetInternal(pStreamEx);
 
-/** @todo
- *  We need to zero the backend storage here!!
- *  We need to zero the backend storage here!!
- *  We need to zero the backend storage here!!
- *  We need to zero the backend storage here!!
- *  We need to zero the backend storage here!!
- *  We need to zero the backend storage here!!
- *  We need to zero the backend storage here!!
- *   */
-        PDMAUDIOSTREAMCFG CfgHostAcq;
-        rc = drvAudioStreamCreateInternalBackend(pThis, pStreamEx, &pStreamEx->Host.Cfg, &CfgHostAcq);
+        RT_BZERO(pStreamEx->pBackend + 1, pStreamEx->Core.cbBackend - sizeof(*pStreamEx->pBackend));
+
+        rc = drvAudioStreamCreateInternalBackend(pThis, pStreamEx);
         if (RT_SUCCESS(rc))
         {
             LogFunc(("[%s] Acquired host format: %s\n",
-                     pStreamEx->Core.szName, PDMAudioStrmCfgToString(&CfgHostAcq, szTmp, sizeof(szTmp)) ));
-            /** @todo Validate (re-)acquired configuration with pStreamEx->Core.Host.Cfg?
+                     pStreamEx->Core.Cfg.szName, PDMAudioStrmCfgToString(&pStreamEx->Core.Cfg, szTmp, sizeof(szTmp)) ));
+            /** @todo Validate (re-)acquired configuration with pStreamEx->Core.Core.Cfg?
              * drvAudioStreamInitInternal() does some setup and a bunch of
              * validations + adjustments of the stream config, so this surely is quite
@@ -2373 +2307 @@
                 else
                 {
-                    LogRel(("Audio: Re-initializing stream '%s' somehow failed, status: %s\n", pStreamEx->Core.szName,
+                    LogRel(("Audio: Re-initializing stream '%s' somehow failed, status: %s\n", pStreamEx->Core.Cfg.szName,
                             drvAudioStreamStatusToStr(szTmp, pStreamEx->fStatus) ));
                     AssertFailed();
@@ -2381 +2315 @@
         }
         else
-            LogRel(("Audio: Re-initializing stream '%s' failed with %Rrc\n", pStreamEx->Core.szName, rc));
+            LogRel(("Audio: Re-initializing stream '%s' failed with %Rrc\n", pStreamEx->Core.Cfg.szName, rc));
     }
     else
     {
-        LogRel(("Audio: Re-initializing stream '%s' failed to destroy previous backend.\n", pStreamEx->Core.szName));
+        LogRel(("Audio: Re-initializing stream '%s' failed to destroy previous backend.\n", pStreamEx->Core.Cfg.szName));
         AssertFailed();
     }
 
     RTCritSectRwLeaveShared(&pThis->CritSectHotPlug);
-    LogFunc(("[%s] Returning %Rrc\n", pStreamEx->Core.szName, rc));
+    LogFunc(("[%s] Returning %Rrc\n", pStreamEx->Core.Cfg.szName, rc));
     return rc;
 }
@@ -2439 +2373 @@
                 {
                     LogRel(("Audio: Re-initializing stream '%s' exceeded maximum retries (%u), leaving as disabled\n",
-                            pStreamEx->Core.szName, cMaxTries));
+                            pStreamEx->Core.Cfg.szName, cMaxTries));
 
                     /* Don't try to re-initialize anymore and mark as disabled. */
@@ -2457 +2391 @@
         char szStreamSts[DRVAUDIO_STATUS_STR_MAX];
 #endif
-        Log3Func(("[%s] fStatus=%s\n", pStreamEx->Core.szName, drvAudioStreamStatusToStr(szStreamSts, pStreamEx->fStatus)));
+        Log3Func(("[%s] fStatus=%s\n", pStreamEx->Core.Cfg.szName, drvAudioStreamStatusToStr(szStreamSts, pStreamEx->fStatus)));
     }
     else
@@ -2488 +2422 @@
     Assert(cRefs < _1K);
 
-    Log12Func(("returns %u (%s)\n", cRefs, pStreamEx->Core.szName));
+    Log12Func(("returns %u (%s)\n", cRefs, pStreamEx->Core.Cfg.szName));
     return cRefs;
 }
@@ -2547 +2481 @@
      *         finish initializing the stream, we'll update it about the stream state.
      */
-    bool const                     fDirEnabled     = pStreamEx->Core.enmDir == PDMAUDIODIR_IN
+    bool const                     fDirEnabled     = pStreamEx->Core.Cfg.enmDir == PDMAUDIODIR_IN
                                                    ? pThis->In.fEnabled : pThis->Out.fEnabled;
     PDMHOSTAUDIOSTREAMSTATE const  enmBackendState = drvAudioStreamGetBackendState(pThis, pStreamEx);
@@ -2554 +2488 @@
     char szStreamSts[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),
+             PDMAudioStrmCmdGetName(enmStreamCmd), pStreamEx->Core.Cfg.szName, PDMAudioDirGetName(pStreamEx->Core.Cfg.enmDir),
              fDirEnabled ? "enabled" : "disabled",  drvAudioStreamStatusToStr(szStreamSts, pStreamEx->fStatus),
              PDMHostAudioStreamStateGetName(enmBackendState) ));
@@ -2597 +2531 @@
             }
             if (RT_SUCCESS(rc))
-                Log2Func(("[%s] %s succeeded (%Rrc)\n", pStreamEx->Core.szName, PDMAudioStrmCmdGetName(enmStreamCmd), rc));
+                Log2Func(("[%s] %s succeeded (%Rrc)\n", pStreamEx->Core.Cfg.szName, PDMAudioStrmCmdGetName(enmStreamCmd), rc));
             else
             {
-                LogFunc(("[%s] %s failed with %Rrc\n", pStreamEx->Core.szName, PDMAudioStrmCmdGetName(enmStreamCmd), rc));
+                LogFunc(("[%s] %s failed with %Rrc\n", pStreamEx->Core.Cfg.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));
+                    LogRel(("Audio: %s stream '%s' failed with %Rrc\n", PDMAudioStrmCmdGetName(enmStreamCmd), pStreamEx->Core.Cfg.szName, rc));
             }
         }
@@ -2628 +2562 @@
     drvAudioStreamResetInternal(pStreamEx);
 
-    LogFunc(("[%s]\n", pStreamEx->Core.szName));
+    LogFunc(("[%s]\n", pStreamEx->Core.Cfg.szName));
 
     pStreamEx->fStatus            &= PDMAUDIOSTREAM_STS_BACKEND_CREATED | PDMAUDIOSTREAM_STS_BACKEND_READY;
@@ -2637 +2571 @@
      * Reset statistics.
      */
-    if (pStreamEx->Core.enmDir == PDMAUDIODIR_IN)
+    if (pStreamEx->Core.Cfg.enmDir == PDMAUDIODIR_IN)
     {
         STAM_COUNTER_RESET(&pStreamEx->In.Stats.TotalFramesCaptured);
@@ -2643 +2577 @@
         STAM_COUNTER_RESET(&pStreamEx->In.Stats.TotalTimesRead);
     }
-    else if (pStreamEx->Core.enmDir == PDMAUDIODIR_OUT)
+    else if (pStreamEx->Core.Cfg.enmDir == PDMAUDIODIR_OUT)
     {
     }
@@ -2669 +2603 @@
     char szStreamSts[DRVAUDIO_STATUS_STR_MAX];
 #endif
-    LogFunc(("[%s] enmStreamCmd=%s fStatus=%s\n", pStreamEx->Core.szName, PDMAudioStrmCmdGetName(enmStreamCmd),
+    LogFunc(("[%s] enmStreamCmd=%s fStatus=%s\n", pStreamEx->Core.Cfg.szName, PDMAudioStrmCmdGetName(enmStreamCmd),
              drvAudioStreamStatusToStr(szStreamSts, pStreamEx->fStatus)));
 
@@ -2682 +2616 @@
                 if (pStreamEx->fStatus & PDMAUDIOSTREAM_STS_PENDING_DISABLE)
                 {
-                    LogFunc(("Stream '%s' is still draining - disabling...\n", pStreamEx->Core.szName));
+                    LogFunc(("Stream '%s' is still draining - disabling...\n", pStreamEx->Core.Cfg.szName));
                     rc = drvAudioStreamControlInternalBackend(pThis, pStreamEx, PDMAUDIOSTREAMCMD_DISABLE);
                     AssertRC(rc);
@@ -2700 +2634 @@
                     pStreamEx->offInternal         = 0;
 
-                    if (pStreamEx->Core.enmDir == PDMAUDIODIR_OUT)
+                    if (pStreamEx->Core.Cfg.enmDir == PDMAUDIODIR_OUT)
                     {
                         pStreamEx->Out.cbPreBuffered = 0;
@@ -2773 +2707 @@
             {
                 rc = drvAudioStreamControlInternalBackend(pThis, pStreamEx, PDMAUDIOSTREAMCMD_DISABLE);
-                LogFunc(("DISABLE '%s': Backend DISABLE -> %Rrc\n", pStreamEx->Core.szName, rc));
+                LogFunc(("DISABLE '%s': Backend DISABLE -> %Rrc\n", pStreamEx->Core.Cfg.szName, rc));
                 if (RT_SUCCESS(rc)) /** @todo ignore this and reset it anyway? */
                     drvAudioStreamResetOnDisable(pStreamEx);
@@ -2808 +2742 @@
              * Only for output streams and we don't want this command more than once.
              */
-            AssertReturn(pStreamEx->Core.enmDir == PDMAUDIODIR_OUT, VERR_INVALID_FUNCTION);
+            AssertReturn(pStreamEx->Core.Cfg.enmDir == PDMAUDIODIR_OUT, VERR_INVALID_FUNCTION);
             AssertBreak(!(pStreamEx->fStatus & PDMAUDIOSTREAM_STS_PENDING_DISABLE));
             if (pStreamEx->fStatus & PDMAUDIOSTREAM_STS_ENABLED)
@@ -2818 +2752 @@
                         if (pStreamEx->Out.cbPreBuffered > 0)
                         {
-                            LogFunc(("DRAIN '%s': Initiating draining of pre-buffered data...\n", pStreamEx->Core.szName));
+                            LogFunc(("DRAIN '%s': Initiating draining of pre-buffered data...\n", pStreamEx->Core.Cfg.szName));
                             pStreamEx->Out.enmPlayState = DRVAUDIOPLAYSTATE_PREBUF_COMMITTING;
                             pStreamEx->fStatus |= PDMAUDIOSTREAM_STS_PENDING_DISABLE;
@@ -2830 +2764 @@
                     case DRVAUDIOPLAYSTATE_PREBUF_OVERDUE:
                         LogFunc(("DRAIN '%s': Nothing to drain (enmPlayState=%s)\n",
-                                 pStreamEx->Core.szName, drvAudioPlayStateName(pStreamEx->Out.enmPlayState)));
+                                 pStreamEx->Core.Cfg.szName, drvAudioPlayStateName(pStreamEx->Out.enmPlayState)));
                         rc = drvAudioStreamControlInternalBackend(pThis, pStreamEx, PDMAUDIOSTREAMCMD_DISABLE);
                         AssertRC(rc);
@@ -2839 +2773 @@
                     case DRVAUDIOPLAYSTATE_PLAY_PREBUF:
                         LogFunc(("DRAIN '%s': Initiating backend draining (enmPlayState=%s -> NOPLAY) ...\n",
-                                 pStreamEx->Core.szName, drvAudioPlayStateName(pStreamEx->Out.enmPlayState)));
+                                 pStreamEx->Core.Cfg.szName, drvAudioPlayStateName(pStreamEx->Out.enmPlayState)));
                         pStreamEx->Out.enmPlayState = DRVAUDIOPLAYSTATE_NOPLAY;
                         rc = drvAudioStreamControlInternalBackend(pThis, pStreamEx, PDMAUDIOSTREAMCMD_DRAIN);
@@ -2850 +2784 @@
                         {
                             LogFunc(("DRAIN '%s': Backend DRAIN failed with %Rrc, disabling the stream instead...\n",
-                                     pStreamEx->Core.szName, rc));
+                                     pStreamEx->Core.Cfg.szName, rc));
                             rc = drvAudioStreamControlInternalBackend(pThis, pStreamEx, PDMAUDIOSTREAMCMD_DISABLE);
                             AssertRC(rc);
@@ -2859 +2793 @@
                     case DRVAUDIOPLAYSTATE_PREBUF_COMMITTING:
                         LogFunc(("DRAIN '%s': Initiating draining of pre-buffered data (already committing)...\n",
-                                 pStreamEx->Core.szName));
+                                 pStreamEx->Core.Cfg.szName));
                         pStreamEx->fStatus |= PDMAUDIOSTREAM_STS_PENDING_DISABLE;
                         PDMAUDIOSTREAM_STS_ASSERT_VALID(pStreamEx->fStatus);
@@ -2879 +2813 @@
 
     if (RT_FAILURE(rc))
-        LogFunc(("[%s] Failed with %Rrc\n", pStreamEx->Core.szName, rc));
+        LogFunc(("[%s] Failed with %Rrc\n", pStreamEx->Core.Cfg.szName, rc));
 
     return rc;
@@ -2905 +2839 @@
     AssertRCReturn(rc, rc);
 
-    LogFlowFunc(("[%s] enmStreamCmd=%s\n", pStream->szName, PDMAudioStrmCmdGetName(enmStreamCmd)));
+    LogFlowFunc(("[%s] enmStreamCmd=%s\n", pStreamEx->Core.Cfg.szName, PDMAudioStrmCmdGetName(enmStreamCmd)));
 
     rc = drvAudioStreamControlInternal(pThis, pStreamEx, enmStreamCmd);
@@ -2982 +2916 @@
                                     const uint8_t *pbBuf, uint32_t cbBuf, uint32_t *pcbWritten)
 {
-    Log3Func(("%s: @%#RX64: cbBuf=%#x\n", pStreamEx->Core.szName, pStreamEx->offInternal, cbBuf));
+    Log3Func(("%s: @%#RX64: cbBuf=%#x\n", pStreamEx->Core.Cfg.szName, pStreamEx->offInternal, cbBuf));
 
     uint32_t      cbWritable = pThis->pHostDrvAudio->pfnStreamGetWritable(pThis->pHostDrvAudio, pStreamEx->pBackend);
@@ -2989 +2923 @@
     uint32_t      cbWritten  = 0;
     int           rc         = VINF_SUCCESS;
-    uint8_t const cbFrame    = PDMAudioPropsFrameSize(&pStreamEx->Core.Props);
+    uint8_t const cbFrame    = PDMAudioPropsFrameSize(&pStreamEx->Core.Cfg.Props);
     while (cbBuf >= cbFrame && cbWritable >= cbFrame)
     {
-        uint32_t const cbToWrite    = PDMAudioPropsFloorBytesToFrame(&pStreamEx->Core.Props, RT_MIN(cbBuf, cbWritable));
+        uint32_t const cbToWrite    = PDMAudioPropsFloorBytesToFrame(&pStreamEx->Core.Cfg.Props, RT_MIN(cbBuf, cbWritable));
         uint32_t       cbWrittenNow = 0;
         rc = pThis->pHostDrvAudio->pfnStreamPlay(pThis->pHostDrvAudio, pStreamEx->pBackend, pbBuf, cbToWrite, &cbWrittenNow);
@@ -2999 +2933 @@
             if (cbWrittenNow != cbToWrite)
                 Log3Func(("%s: @%#RX64: Wrote fewer bytes than requested: %#x, requested %#x\n",
-                          pStreamEx->Core.szName, pStreamEx->offInternal, cbWrittenNow, cbToWrite));
+                          pStreamEx->Core.Cfg.szName, pStreamEx->offInternal, cbWrittenNow, cbToWrite));
 #ifdef DEBUG_bird
             Assert(cbWrittenNow == cbToWrite);
@@ -3013 +2947 @@
             *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));
+                     pStreamEx->Core.Cfg.szName, pStreamEx->offInternal, cbToWrite, cbWritten, cbWritable, rc));
             return cbWritten ? VINF_SUCCESS : rc;
         }
@@ -3025 +2959 @@
         pStreamEx->nsLastPlayedCaptured = RTTimeNanoTS();
 
-    Log3Func(("%s: @%#RX64: Wrote %#x bytes (%#x bytes left)\n", pStreamEx->Core.szName, pStreamEx->offInternal, cbWritten, cbBuf));
+    Log3Func(("%s: @%#RX64: Wrote %#x bytes (%#x bytes left)\n", pStreamEx->Core.Cfg.szName, pStreamEx->offInternal, cbWritten, cbBuf));
     return rc;
 }
@@ -3042 +2976 @@
         pStreamEx->offInternal += cbBuf;
         Log3Func(("[%s] Pre-buffering (%s): wrote %#x bytes => %#x bytes / %u%%\n",
-                  pStreamEx->Core.szName, drvAudioPlayStateName(pStreamEx->Out.enmPlayState), cbBuf, pStreamEx->Out.cbPreBuffered,
+                  pStreamEx->Core.Cfg.szName, drvAudioPlayStateName(pStreamEx->Out.enmPlayState), cbBuf, pStreamEx->Out.cbPreBuffered,
                   pStreamEx->Out.cbPreBuffered * 100 / RT_MAX(pStreamEx->cbPreBufThreshold, 1)));
 
@@ -3140 +3074 @@
 
         LogRel2(("Audio: @%#RX64: Stream '%s' pre-buffering commit problem: wrote %#x out of %#x + %#x - rc=%Rrc *pcbWritten=%#x %s -> PREBUF_COMMITTING\n",
-                 pStreamEx->offInternal, pStreamEx->Core.szName, pStreamEx->Out.cbPreBuffered - cbLeft,
+                 pStreamEx->offInternal, pStreamEx->Core.Cfg.szName, pStreamEx->Out.cbPreBuffered - cbLeft,
                  pStreamEx->Out.cbPreBuffered, cbBuf, rc, *pcbWritten, drvAudioPlayStateName(pStreamEx->Out.enmPlayState) ));
         AssertMsg(   pStreamEx->Out.enmPlayState == DRVAUDIOPLAYSTATE_PREBUF_COMMITTING
@@ -3174 +3108 @@
     char szStreamSts[DRVAUDIO_STATUS_STR_MAX];
 #endif
-    Log3Func(("[%s] fStatus=%s\n", pStreamEx->Core.szName, drvAudioStreamStatusToStr(szStreamSts, pStreamEx->fStatus)));
+    Log3Func(("[%s] fStatus=%s\n", pStreamEx->Core.Cfg.szName, drvAudioStreamStatusToStr(szStreamSts, pStreamEx->fStatus)));
 
     /* Not enabled or paused? Skip iteration. */
@@ -3190 +3124 @@
     else
     {
-        AssertReturn(pStreamEx->Core.enmDir == PDMAUDIODIR_OUT, VINF_SUCCESS);
+        AssertReturn(pStreamEx->Core.Cfg.enmDir == PDMAUDIODIR_OUT, VINF_SUCCESS);
         RTCritSectRwEnterShared(&pThis->CritSectHotPlug);
 
@@ -3202 +3136 @@
                 uint32_t cbIgnored = 0;
                 drvAudioStreamPreBufComitting(pThis, pStreamEx, NULL, 0, &cbIgnored);
-                Log3Func(("Stream '%s': Transferred %#x bytes\n", pStreamEx->Core.szName, cbIgnored));
+                Log3Func(("Stream '%s': Transferred %#x bytes\n", pStreamEx->Core.Cfg.szName, cbIgnored));
             }
             if (pStreamEx->Out.cbPreBuffered == 0)
             {
-                Log3Func(("Stream '%s': No more pre-buffered data -> NOPLAY + backend DRAIN\n", pStreamEx->Core.szName));
+                Log3Func(("Stream '%s': No more pre-buffered data -> NOPLAY + backend DRAIN\n", pStreamEx->Core.Cfg.szName));
                 pStreamEx->Out.enmPlayState = DRVAUDIOPLAYSTATE_NOPLAY;
 
@@ -3213 +3147 @@
                 {
                     LogFunc(("Stream '%s': Backend DRAIN failed with %Rrc, disabling the stream instead...\n",
-                             pStreamEx->Core.szName, rc));
+                             pStreamEx->Core.Cfg.szName, rc));
                     rc = drvAudioStreamControlInternalBackend(pThis, pStreamEx, PDMAUDIOSTREAMCMD_DISABLE);
                     AssertRC(rc);
@@ -3235 +3169 @@
         else
         {
-            LogFunc(("Stream '%s': Backend finished draining.\n", pStreamEx->Core.szName));
+            LogFunc(("Stream '%s': Backend finished draining.\n", pStreamEx->Core.Cfg.szName));
             drvAudioStreamResetOnDisable(pStreamEx);
         }
@@ -3294 +3228 @@
     PDMHOSTAUDIOSTREAMSTATE const enmBackendState = drvAudioStreamGetBackendStateAndProcessChanges(pThis, pStreamEx);
     uint32_t const                fStrmStatus     = pStreamEx->fStatus;
-    PDMAUDIODIR const             enmDir          = pStreamEx->Guest.Cfg.enmDir;
+    PDMAUDIODIR const             enmDir          = pStreamEx->Core.Cfg.enmDir;
     Assert(enmDir == PDMAUDIODIR_IN || enmDir == PDMAUDIODIR_OUT);
 
@@ -3326 +3260 @@
     char szStreamSts[DRVAUDIO_STATUS_STR_MAX];
 #endif
-    Log3Func(("[%s] returns %s (status: %s)\n", pStreamEx->Core.szName, PDMAudioStreamStateGetName(enmState),
+    Log3Func(("[%s] returns %s (status: %s)\n", pStreamEx->Core.Cfg.szName, PDMAudioStreamStateGetName(enmState),
               drvAudioStreamStatusToStr(szStreamSts, fStrmStatus)));
     return enmState;
@@ -3343 +3277 @@
     AssertReturn(pStreamEx->Core.uMagic == PDMAUDIOSTREAM_MAGIC, 0);
     AssertReturn(pStreamEx->uMagic      == DRVAUDIOSTREAM_MAGIC, 0);
-    AssertMsgReturn(pStreamEx->Core.enmDir == PDMAUDIODIR_OUT, ("Can't write to a non-output stream\n"), 0);
+    AssertMsgReturn(pStreamEx->Core.Cfg.enmDir == PDMAUDIODIR_OUT, ("Can't write to a non-output stream\n"), 0);
 
     int rc = RTCritSectEnter(&pStreamEx->Core.CritSect);
@@ -3381 +3315 @@
                 cbWritable = pStreamEx->Out.cbPreBufAlloc - pStreamEx->Out.cbPreBuffered;
                 if (!cbWritable)
-                    cbWritable = PDMAudioPropsFramesToBytes(&pStreamEx->Core.Props, 2);
+                    cbWritable = PDMAudioPropsFramesToBytes(&pStreamEx->Core.Cfg.Props, 2);
                 break;
 
@@ -3392 +3326 @@
             case DRVAUDIOPLAYSTATE_PREBUF_OVERDUE:
             case DRVAUDIOPLAYSTATE_PREBUF_SWITCHING:
-                cbWritable = PDMAudioPropsFramesToBytes(&pStreamEx->Core.Props,
-                                                        RT_MAX(pStreamEx->Host.Cfg.Backend.cFramesBufferSize,
-                                                               pStreamEx->Host.Cfg.Backend.cFramesPreBuffering));
+                cbWritable = PDMAudioPropsFramesToBytes(&pStreamEx->Core.Cfg.Props,
+                                                        RT_MAX(pStreamEx->Core.Cfg.Backend.cFramesBufferSize,
+                                                               pStreamEx->Core.Cfg.Backend.cFramesPreBuffering));
                 break;
 
@@ -3406 +3340 @@
                 Assert(pStreamEx->fStatus & PDMAUDIOSTREAM_STS_BACKEND_READY);
                 Assert(enmBackendState == PDMHOSTAUDIOSTREAMSTATE_OKAY /* potential unplug race */);
-                uint32_t const cbMin = PDMAudioPropsFramesToBytes(&pStreamEx->Core.Props, 8);
+                uint32_t const cbMin = PDMAudioPropsFramesToBytes(&pStreamEx->Core.Cfg.Props, 8);
                 cbWritable = pThis->pHostDrvAudio->pfnStreamGetWritable(pThis->pHostDrvAudio, pStreamEx->pBackend);
                 if (cbWritable >= pStreamEx->Out.cbPreBuffered + cbMin)
@@ -3425 +3359 @@
 
         /* Make sure to align the writable size to the host's frame size. */
-        cbWritable = PDMAudioPropsFloorBytesToFrame(&pStreamEx->Core.Props, cbWritable);
+        cbWritable = PDMAudioPropsFloorBytesToFrame(&pStreamEx->Core.Cfg.Props, cbWritable);
     }
 
@@ -3431 +3365 @@
     RTCritSectLeave(&pStreamEx->Core.CritSect);
     Log3Func(("[%s] cbWritable=%#RX32 (%RU64ms) enmPlayMode=%s enmBackendState=%s\n",
-              pStreamEx->Core.szName, cbWritable, PDMAudioPropsBytesToMilli(&pStreamEx->Core.Props, cbWritable),
+              pStreamEx->Core.Cfg.szName, cbWritable, PDMAudioPropsBytesToMilli(&pStreamEx->Core.Cfg.Props, cbWritable),
               drvAudioPlayStateName(enmPlayMode), PDMHostAudioStreamStateGetName(enmBackendState) ));
     return cbWritable;
@@ -3462 +3396 @@
     AssertReturn(pStreamEx->Core.uMagic == PDMAUDIOSTREAM_MAGIC, VERR_INVALID_MAGIC);
     AssertReturn(pStreamEx->uMagic      == DRVAUDIOSTREAM_MAGIC, VERR_INVALID_MAGIC);
-    AssertMsgReturn(pStreamEx->Core.enmDir == PDMAUDIODIR_OUT,
+    AssertMsgReturn(pStreamEx->Core.Cfg.enmDir == PDMAUDIODIR_OUT,
                     ("Stream '%s' is not an output stream and therefore cannot be written to (direction is '%s')\n",
-                     pStreamEx->Core.szName, PDMAudioDirGetName(pStreamEx->Core.enmDir)), VERR_ACCESS_DENIED);
-
-    AssertMsg(PDMAudioPropsIsSizeAligned(&pStreamEx->Core.Props, cbBuf),
-              ("Stream '%s' got a non-frame-aligned write (%#RX32 bytes)\n", pStreamEx->Core.szName, cbBuf));
+                     pStreamEx->Core.Cfg.szName, PDMAudioDirGetName(pStreamEx->Core.Cfg.enmDir)), VERR_ACCESS_DENIED);
+
+    AssertMsg(PDMAudioPropsIsSizeAligned(&pStreamEx->Core.Cfg.Props, cbBuf),
+              ("Stream '%s' got a non-frame-aligned write (%#RX32 bytes)\n", pStreamEx->Core.Cfg.szName, cbBuf));
 
     int rc = RTCritSectEnter(&pStreamEx->Core.CritSect);
@@ -3512 +3446 @@
                     {
                         Log3Func(("[%s] Pre-buffering completing: cbBuf=%#x cbPreBuffered=%#x => %#x vs cbPreBufThreshold=%#x\n",
-                                  pStreamEx->Core.szName, cbBuf, pStreamEx->Out.cbPreBuffered,
+                                  pStreamEx->Core.Cfg.szName, cbBuf, pStreamEx->Out.cbPreBuffered,
                                   cbBuf + pStreamEx->Out.cbPreBuffered, pStreamEx->cbPreBufThreshold));
                         rc = drvAudioStreamPreBufComitting(pThis, pStreamEx, (uint8_t const *)pvBuf, cbBuf, pcbWritten);
@@ -3519 +3453 @@
                     {
                         Log3Func(("[%s] Pre-buffering completing but device not ready: cbBuf=%#x cbPreBuffered=%#x => %#x vs cbPreBufThreshold=%#x; PREBUF -> PREBUF_OVERDUE\n",
-                                  pStreamEx->Core.szName, cbBuf, pStreamEx->Out.cbPreBuffered,
+                                  pStreamEx->Core.Cfg.szName, cbBuf, pStreamEx->Out.cbPreBuffered,
                                   cbBuf + pStreamEx->Out.cbPreBuffered, pStreamEx->cbPreBufThreshold));
                         pStreamEx->Out.enmPlayState = DRVAUDIOPLAYSTATE_PREBUF_OVERDUE;
@@ -3543 +3477 @@
                     *pcbWritten = cbBuf;
                     pStreamEx->offInternal += cbBuf;
-                    Log3Func(("[%s] Discarding the data, backend state: %s\n", pStreamEx->Core.szName,
+                    Log3Func(("[%s] Discarding the data, backend state: %s\n", pStreamEx->Core.Cfg.szName,
                               PDMHostAudioStreamStateGetName(enmBackendState) ));
                     break;
@@ -3561 +3495 @@
             *pcbWritten = cbBuf;
             pStreamEx->offInternal += cbBuf;
-            Log3Func(("[%s] Backend stream %s, discarding the data\n", pStreamEx->Core.szName,
+            Log3Func(("[%s] Backend stream %s, discarding the data\n", pStreamEx->Core.Cfg.szName,
                       !pThis->Out.fEnabled ? "disabled" : !pThis->pHostDrvAudio ? "not attached" : "not ready yet"));
         }
@@ -3585 +3519 @@
     AssertReturn(pStreamEx->Core.uMagic == PDMAUDIOSTREAM_MAGIC, 0);
     AssertReturn(pStreamEx->uMagic      == DRVAUDIOSTREAM_MAGIC, 0);
-    AssertMsg(pStreamEx->Core.enmDir == PDMAUDIODIR_IN, ("Can't read from a non-input stream\n"));
+    AssertMsg(pStreamEx->Core.Cfg.enmDir == PDMAUDIODIR_IN, ("Can't read from a non-input stream\n"));
 
 
@@ -3620 +3554 @@
             {
                 uint64_t const cNsStream = RTTimeNanoTS() - pStreamEx->nsStarted;
-                uint64_t const offCur    = PDMAudioPropsNanoToBytes64(&pStreamEx->Core.Props, cNsStream);
+                uint64_t const offCur    = PDMAudioPropsNanoToBytes64(&pStreamEx->Core.Cfg.Props, cNsStream);
                 if (offCur > pStreamEx->offInternal)
                 {
@@ -3639 +3573 @@
 
         /* Make sure to align the readable size to the host's frame size. */
-        cbReadable = PDMAudioPropsFloorBytesToFrame(&pStreamEx->Core.Props, cbReadable);
+        cbReadable = PDMAudioPropsFloorBytesToFrame(&pStreamEx->Core.Cfg.Props, cbReadable);
     }
 
@@ -3645 +3579 @@
     RTCritSectLeave(&pStreamEx->Core.CritSect);
     Log3Func(("[%s] cbReadable=%#RX32 (%RU64ms) enmCaptureMode=%s enmBackendState=%s\n",
-              pStreamEx->Core.szName, cbReadable, PDMAudioPropsBytesToMilli(&pStreamEx->Core.Props, cbReadable),
+              pStreamEx->Core.Cfg.szName, cbReadable, PDMAudioPropsBytesToMilli(&pStreamEx->Core.Cfg.Props, cbReadable),
               drvAudioCaptureStateName(enmCaptureState), PDMHostAudioStreamStateGetName(enmBackendState) ));
     return cbReadable;
@@ -3667 +3601 @@
     /** @todo  Does not take paused time into account...  */
     uint64_t const cNsStream = RTTimeNanoTS() - pStreamEx->nsStarted;
-    uint64_t const offCur    = PDMAudioPropsNanoToBytes64(&pStreamEx->Core.Props, cNsStream);
+    uint64_t const offCur    = PDMAudioPropsNanoToBytes64(&pStreamEx->Core.Cfg.Props, cNsStream);
     if (offCur > pStreamEx->offInternal)
     {
@@ -3675 +3609 @@
         pStreamEx->offInternal  += cbToClear;
         cbBuf                   -= cbToClear;
-        PDMAudioPropsClearBuffer(&pStreamEx->Core.Props, pbBuf, cbToClear,
-                                 PDMAudioPropsBytesToFrames(&pStreamEx->Core.Props, cbToClear));
+        PDMAudioPropsClearBuffer(&pStreamEx->Core.Cfg.Props, pbBuf, cbToClear,
+                                 PDMAudioPropsBytesToFrames(&pStreamEx->Core.Cfg.Props, cbToClear));
     }
     else
         *pcbRead = 0;
     Log4Func(("%s: @%#RX64: Read %#x bytes of silence (%#x bytes left)\n",
-              pStreamEx->Core.szName, pStreamEx->offInternal, *pcbRead, cbBuf));
+              pStreamEx->Core.Cfg.szName, pStreamEx->offInternal, *pcbRead, cbBuf));
     return VINF_SUCCESS;
 }
@@ -3692 +3626 @@
                                        uint8_t *pbBuf, uint32_t cbBuf, uint32_t *pcbRead)
 {
-    Log4Func(("%s: @%#RX64: cbBuf=%#x\n", pStreamEx->Core.szName, pStreamEx->offInternal, cbBuf));
+    Log4Func(("%s: @%#RX64: cbBuf=%#x\n", pStreamEx->Core.Cfg.szName, pStreamEx->offInternal, cbBuf));
 
     uint32_t      cbReadable = pThis->pHostDrvAudio->pfnStreamGetReadable(pThis->pHostDrvAudio, pStreamEx->pBackend);
@@ -3699 +3633 @@
     uint32_t      cbRead     = 0;
     int           rc         = VINF_SUCCESS;
-    uint8_t const cbFrame    = PDMAudioPropsFrameSize(&pStreamEx->Core.Props);
+    uint8_t const cbFrame    = PDMAudioPropsFrameSize(&pStreamEx->Core.Cfg.Props);
     while (cbBuf >= cbFrame && cbReadable >= cbFrame)
     {
-        uint32_t const cbToRead  = PDMAudioPropsFloorBytesToFrame(&pStreamEx->Core.Props, RT_MIN(cbBuf, cbReadable));
+        uint32_t const cbToRead  = PDMAudioPropsFloorBytesToFrame(&pStreamEx->Core.Cfg.Props, RT_MIN(cbBuf, cbReadable));
         uint32_t       cbReadNow = 0;
         rc = pThis->pHostDrvAudio->pfnStreamCapture(pThis->pHostDrvAudio, pStreamEx->pBackend, pbBuf, cbToRead, &cbReadNow);
@@ -3709 +3643 @@
             if (cbReadNow != cbToRead)
                 Log4Func(("%s: @%#RX64: Read fewer bytes than requested: %#x, requested %#x\n",
-                          pStreamEx->Core.szName, pStreamEx->offInternal, cbReadNow, cbToRead));
+                          pStreamEx->Core.Cfg.szName, pStreamEx->offInternal, cbReadNow, cbToRead));
 #ifdef DEBUG_bird
             Assert(cbReadNow == cbToRead);
@@ -3723 +3657 @@
             *pcbRead = cbRead;
             LogFunc(("%s: @%#RX64: pfnStreamCapture failed read %#x bytes (%#x previous read, %#x readable): %Rrc\n",
-                     pStreamEx->Core.szName, pStreamEx->offInternal, cbToRead, cbRead, cbReadable, rc));
+                     pStreamEx->Core.Cfg.szName, pStreamEx->offInternal, cbToRead, cbRead, cbReadable, rc));
             return cbRead ? VINF_SUCCESS : rc;
         }
@@ -3735 +3669 @@
         pStreamEx->nsLastPlayedCaptured = RTTimeNanoTS();
 
-    Log4Func(("%s: @%#RX64: Read %#x bytes (%#x bytes left)\n", pStreamEx->Core.szName, pStreamEx->offInternal, cbRead, cbBuf));
+    Log4Func(("%s: @%#RX64: Read %#x bytes (%#x bytes left)\n", pStreamEx->Core.Cfg.szName, pStreamEx->offInternal, cbRead, cbBuf));
     return rc;
 }
@@ -3765 +3699 @@
     AssertReturn(pStreamEx->Core.uMagic == PDMAUDIOSTREAM_MAGIC, VERR_INVALID_MAGIC);
     AssertReturn(pStreamEx->uMagic      == DRVAUDIOSTREAM_MAGIC, VERR_INVALID_MAGIC);
-    AssertMsgReturn(pStreamEx->Core.enmDir == PDMAUDIODIR_IN,
+    AssertMsgReturn(pStreamEx->Core.Cfg.enmDir == PDMAUDIODIR_IN,
                     ("Stream '%s' is not an input stream and therefore cannot be read from (direction is '%s')\n",
-                     pStreamEx->Core.szName, PDMAudioDirGetName(pStreamEx->Core.enmDir)), VERR_ACCESS_DENIED);
-
-    AssertMsg(PDMAudioPropsIsSizeAligned(&pStreamEx->Core.Props, cbBuf),
-              ("Stream '%s' got a non-frame-aligned write (%#RX32 bytes)\n", pStreamEx->Core.szName, cbBuf));
+                     pStreamEx->Core.Cfg.szName, PDMAudioDirGetName(pStreamEx->Core.Cfg.enmDir)), VERR_ACCESS_DENIED);
+
+    AssertMsg(PDMAudioPropsIsSizeAligned(&pStreamEx->Core.Cfg.Props, cbBuf),
+              ("Stream '%s' got a non-frame-aligned write (%#RX32 bytes)\n", pStreamEx->Core.Cfg.szName, cbBuf));
 
     int rc = RTCritSectEnter(&pStreamEx->Core.CritSect);
@@ -3809 +3743 @@
                         {
                             Log4Func(("[%s] Pre-buffering completed: cbReadable=%#x vs cbPreBufThreshold=%#x (cbBuf=%#x)\n",
-                                      pStreamEx->Core.szName, cbReadable, pStreamEx->cbPreBufThreshold, cbBuf));
+                                      pStreamEx->Core.Cfg.szName, cbReadable, pStreamEx->cbPreBufThreshold, cbBuf));
                             pStreamEx->In.enmCaptureState = DRVAUDIOCAPTURESTATE_CAPTURING;
                             rc = drvAudioStreamCaptureLocked(pThis, pStreamEx, (uint8_t *)pvBuf, cbBuf, pcbRead);
@@ -3817 +3751 @@
                         pStreamEx->In.Stats.cbBackendReadableAfter  = cbReadable;
                         Log4Func(("[%s] Pre-buffering: Got %#x out of %#x\n",
-                                  pStreamEx->Core.szName, cbReadable, pStreamEx->cbPreBufThreshold));
+                                  pStreamEx->Core.Cfg.szName, cbReadable, pStreamEx->cbPreBufThreshold));
                     }
                     else
                         Log4Func(("[%s] Pre-buffering: Backend status %s\n",
-                                  pStreamEx->Core.szName, PDMHostAudioStreamStateGetName(enmBackendState) ));
+                                  pStreamEx->Core.Cfg.szName, PDMHostAudioStreamStateGetName(enmBackendState) ));
                     drvAudioStreamCaptureSilence(pStreamEx, (uint8_t *)pvBuf, cbBuf, pcbRead);
                     break;
@@ -3828 +3762 @@
                     *pcbRead = 0;
                     Log4Func(("[%s] Not capturing - backend state: %s\n",
-                              pStreamEx->Core.szName, PDMHostAudioStreamStateGetName(enmBackendState) ));
+                              pStreamEx->Core.Cfg.szName, PDMHostAudioStreamStateGetName(enmBackendState) ));
                     break;
 
@@ -3844 +3778 @@
         {
             *pcbRead = 0;
-            Log4Func(("[%s] Backend stream %s, returning no data\n", pStreamEx->Core.szName,
+            Log4Func(("[%s] Backend stream %s, returning no data\n", pStreamEx->Core.Cfg.szName,
                       !pThis->Out.fEnabled ? "disabled" : !pThis->pHostDrvAudio ? "not attached" : "not ready yet"));
         }
@@ -3996 +3930 @@
 static void drvAudioStreamMarkNeedReInit(PDRVAUDIOSTREAM pStreamEx, const char *pszCaller)
 {
-    LogFlow((LOG_FN_FMT ": Flagging %s for re-init.\n", pszCaller, pStreamEx->Core.szName)); RT_NOREF(pszCaller);
+    LogFlow((LOG_FN_FMT ": Flagging %s for re-init.\n", pszCaller, pStreamEx->Core.Cfg.szName)); RT_NOREF(pszCaller);
     Assert(RTCritSectIsOwner(&pStreamEx->Core.CritSect));
 
@@ -4024 +3958 @@
     RTListForEach(&pThis->LstStreams, pStreamEx, DRVAUDIOSTREAM, ListEntry)
     {
-        if (pStreamEx->Core.enmDir == enmDir)
+        if (pStreamEx->Core.Cfg.enmDir == enmDir)
         {
             RTCritSectEnter(&pStreamEx->Core.CritSect);
@@ -4031 +3965 @@
             if (pThis->pHostDrvAudio->pfnStreamNotifyDeviceChanged)
             {
-                LogFlowFunc(("Calling pfnStreamNotifyDeviceChanged on %s, old backend state: %s...\n", pStreamEx->Core.szName,
+                LogFlowFunc(("Calling pfnStreamNotifyDeviceChanged on %s, old backend state: %s...\n", pStreamEx->Core.Cfg.szName,
                              PDMHostAudioStreamStateGetName(drvAudioStreamGetBackendState(pThis, pStreamEx)) ));
                 pThis->pHostDrvAudio->pfnStreamNotifyDeviceChanged(pThis->pHostDrvAudio, pStreamEx->pBackend, pvUser);
@@ -4066 +4000 @@
     AssertReturnVoid(pStreamEx->Core.uMagic == PDMAUDIOSTREAM_MAGIC);
     AssertReturnVoid(pStreamEx->uMagic == DRVAUDIOSTREAM_MAGIC);
-    LogFlowFunc(("pStreamEx=%p '%s'\n", pStreamEx, pStreamEx->Core.szName));
+    LogFlowFunc(("pStreamEx=%p '%s'\n", pStreamEx, pStreamEx->Core.Cfg.szName));
 
     /*
@@ -4074 +4008 @@
     AssertReturnVoidStmt(pStreamEx->uMagic == DRVAUDIOSTREAM_MAGIC, RTCritSectLeave(&pStreamEx->Core.CritSect)); /* paranoia */
 
-    if (pStreamEx->Core.enmDir == PDMAUDIODIR_OUT)
+    if (pStreamEx->Core.Cfg.enmDir == PDMAUDIODIR_OUT)
     {
         if (pStreamEx->cbPreBufThreshold > 0)
@@ -4149 +4083 @@
 
 
-        if (pStreamEx->Core.enmDir == PDMAUDIODIR_OUT)
+        if (pStreamEx->Core.Cfg.enmDir == PDMAUDIODIR_OUT)
         {
             DRVAUDIOPLAYSTATE const enmPlayState = pStreamEx->Out.enmPlayState;
             pStreamEx->Out.enmPlayState = DRVAUDIOPLAYSTATE_PREBUF;
-            LogFunc(("%s: %s -> %s\n", pStreamEx->Core.szName, drvAudioPlayStateName(enmPlayState),
+            LogFunc(("%s: %s -> %s\n", pStreamEx->Core.Cfg.szName, drvAudioPlayStateName(enmPlayState),
                      drvAudioPlayStateName(pStreamEx->Out.enmPlayState) ));
             RT_NOREF(enmPlayState);

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

@@ -248 +248 @@
     /* .pfnStreamNotifyDeviceChanged =*/ NULL,
     /* .pfnStreamControl             =*/ drvHstAudNullHA_StreamControl,
+    /* .pfnStreamGetState            =*/ drvHstAudNullHA_StreamGetState,
+    /* .pfnStreamGetPending          =*/ drvHstAudNullHA_StreamGetPending,
+    /* .pfnStreamGetWritable         =*/ drvHstAudNullHA_StreamGetWritable,
+    /* .pfnStreamPlay                =*/ drvHstAudNullHA_StreamPlay,
     /* .pfnStreamGetReadable         =*/ drvHstAudNullHA_StreamGetReadable,
-    /* .pfnStreamGetWritable         =*/ drvHstAudNullHA_StreamGetWritable,
-    /* .pfnStreamGetPending          =*/ drvHstAudNullHA_StreamGetPending,
-    /* .pfnStreamGetState            =*/ drvHstAudNullHA_StreamGetState,
-    /* .pfnStreamPlay                =*/ drvHstAudNullHA_StreamPlay,
     /* .pfnStreamCapture             =*/ drvHstAudNullHA_StreamCapture,
 };

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

@@ -633 +633 @@
      *        sensible, so I've removed it. */
 
-    uint32_t cFrames = PDMAudioPropsBytesToFrames(&pStream->pStream->Props, cbBuf);
+    uint32_t cFrames = PDMAudioPropsBytesToFrames(&pStream->pStream->Cfg.Props, cbBuf);
     Assert(cFrames == cbBuf / (sizeof(uint64_t) * 2));
     pDrv->pConsoleVRDPServer->SendAudioSamples(pvBuf, cFrames, uVrdpFormat);
 
     Log3Func(("cFramesWritten=%RU32\n", cFrames));
-    *pcbWritten = PDMAudioPropsFramesToBytes(&pStream->pStream->Props, cFrames);
+    *pcbWritten = PDMAudioPropsFramesToBytes(&pStream->pStream->Cfg.Props, cFrames);
     Assert(*pcbWritten == cbBuf);
     return VINF_SUCCESS;