Changeset 60925 in vbox for trunk

Timestamp:

May 10, 2016 1:27:44 PM (9 years ago)

Author:

vboxsync

Message:

Audio: Update on infrastructure:

• More work on HDA stream interleaving + surround support
• The mixer can now (optionally) act as a supplemental layer between audio connector interface and device emulation (where applicable)
• Multiple LUN streams can be bound to a certain sink, which in turn then can be treated as separate input/output channels
• Unified more code which was duplicated between different audio device emulations
• Tiny bit of documentation

Work in progress.

Location:

trunk

Files:

• include/VBox/vmm/pdmaudioifs.h (modified) (13 diffs)
• src/VBox/Devices/Audio/AudioMixBuffer.cpp (modified) (6 diffs)
• src/VBox/Devices/Audio/AudioMixer.cpp (modified) (14 diffs)
• src/VBox/Devices/Audio/AudioMixer.h (modified) (6 diffs)
• src/VBox/Devices/Audio/DevIchAc97.cpp (modified) (71 diffs)
• src/VBox/Devices/Audio/DevIchHda.cpp (modified) (99 diffs)
• src/VBox/Devices/Audio/DevIchHdaCodec.cpp (modified) (93 diffs)
• src/VBox/Devices/Audio/DevIchHdaCodec.h (modified) (4 diffs)
• src/VBox/Devices/Audio/DevSB16.cpp (modified) (10 diffs)
• src/VBox/Devices/Audio/DrvAudio.cpp (modified) (74 diffs)
• src/VBox/Devices/Audio/DrvAudio.h (modified) (1 diff)
• src/VBox/Devices/Audio/DrvAudioCommon.cpp (modified) (8 diffs)
• src/VBox/Devices/Audio/DrvHostALSAAudio.cpp (modified) (13 diffs)
• src/VBox/Devices/Audio/DrvHostDSound.cpp (modified) (4 diffs)
• src/VBox/Devices/Audio/DrvHostNullAudio.cpp (modified) (6 diffs)
• src/VBox/Devices/Audio/DrvHostOSSAudio.cpp (modified) (7 diffs)
• src/VBox/Devices/Audio/DrvHostPulseAudio.cpp (modified) (5 diffs)
• src/VBox/Devices/Audio/testcase/tstAudioMixBuffer.cpp (modified) (9 diffs)
• src/VBox/Devices/Makefile.kmk (modified) (1 diff)
• src/VBox/Devices/testcase/tstDeviceStructSizeRC.cpp (modified) (3 diffs)
• src/VBox/Main/src-client/DrvAudioVideoRec.cpp (modified) (1 diff)

trunk/include/VBox/vmm/pdmaudioifs.h

@@ -28 +28 @@
 
 #include <VBox/types.h>
+#include <iprt/circbuf.h>
 #include <iprt/critsect.h>
 #include <iprt/list.h>
@@ -52 +53 @@
 typedef enum PDMAUDIOFMT
 {
-    AUD_FMT_INVALID,
-    AUD_FMT_U8,
-    AUD_FMT_S8,
-    AUD_FMT_U16,
-    AUD_FMT_S16,
-    AUD_FMT_U32,
-    AUD_FMT_S32,
+    PDMAUDIOFMT_INVALID,
+    PDMAUDIOFMT_U8,
+    PDMAUDIOFMT_S8,
+    PDMAUDIOFMT_U16,
+    PDMAUDIOFMT_S16,
+    PDMAUDIOFMT_U32,
+    PDMAUDIOFMT_S32,
     /** Hack to blow the type up to 32-bit. */
-    AUD_FMT_32BIT_HACK = 0x7fffffff
+    PDMAUDIOFMT_32BIT_HACK = 0x7fffffff
 } PDMAUDIOFMT;
 
@@ -152 +153 @@
 
 /**
+ * Audio stream (data) layout.
+ */
+typedef enum PDMAUDIOSTREAMLAYOUT
+{
+    /** Unknown access type; do not use. */
+    PDMAUDIOSTREAMLAYOUT_UNKNOWN = 0,
+    /** Non-interleaved access, that is, consecutive
+     *  access to the data. */
+    PDMAUDIOSTREAMLAYOUT_NON_INTERLEAVED,
+    /** Interleaved access, where the data can be
+     *  mixed together with data of other audio streams. */
+    PDMAUDIOSTREAMLAYOUT_INTERLEAVED
+} PDMAUDIOSTREAMLAYOUT, *PPDMAUDIOSTREAMLAYOUT;
+
+/** No stream channel data flags defined. */
+#define PDMAUDIOSTREAMCHANNELDATA_FLAG_NONE      0
+
+/**
+ * Structure for keeping a stream channel data block around.
+ */
+typedef struct PDMAUDIOSTREAMCHANNELDATA
+{
+    /** Circular buffer for the channel data. */
+    PRTCIRCBUF pCircBuf;
+    size_t     cbAcq;
+    /** Channel data flags. */
+    uint32_t   fFlags;
+} PDMAUDIOSTREAMCHANNELDATA, *PPDMAUDIOSTREAMCHANNELDATA;
+
+/**
+ * Structure for a single channel of an audio stream.
+ * An audio stream consists of one or multiple channels,
+ * depending on the configuration.
+ */
+typedef struct PDMAUDIOSTREAMCHANNEL
+{
+    /** Channel ID. */
+    uint8_t                   uChannel;
+    /** Step size (in bytes) to the channel's next frame. */
+    size_t                    cbStep;
+    /** Frame size (in bytes) of this channel. */
+    size_t                    cbFrame;
+    /** Offset (in bytes) to first sample in the data block. */
+    size_t                    cbFirst;
+    /** Currente offset (in bytes) in the data stream. */
+    size_t                    cbOff;
+    /** Associated data buffer. */
+    PDMAUDIOSTREAMCHANNELDATA Data;
+} PDMAUDIOSTREAMCHANNEL, *PPDMAUDIOSTREAMCHANNEL;
+
+/**
  * Structure for keeping an audio stream configuration.
  */
@@ -157 +209 @@
 {
     /** Friendly name of the stream. */
-    const char               *pszName;
+    char                     szName[64];
     /** Direction of the stream. */
     PDMAUDIODIR              enmDir;
@@ -169 +221 @@
     /** Frequency in Hertz (Hz). */
     uint32_t                 uHz;
-    /** Number of channels (2 for stereo, 1 for mono). */
+    /** Number of audio channels (2 for stereo, 1 for mono). */
     uint8_t                  cChannels;
     /** Audio format. */
@@ -337 +389 @@
      */
     int64_t                iFreqRatio;
-    /* For quickly converting samples <-> bytes and
-     * vice versa. */
+    /** For quickly converting samples <-> bytes and vice versa. */
     uint8_t                cShift;
 } PDMAUDIOMIXBUF;
@@ -347 +398 @@
 /** No flags being set. */
 #define PDMAUDIOSTRMSTS_FLAG_NONE            0
+/** Whether this stream has been initialized by the
+ *  backend or not. */
+#define PDMAUDIOSTRMSTS_FLAG_INITIALIZED     RT_BIT_32(0)
 /** Whether this stream is enabled or disabled. */
-#define PDMAUDIOSTRMSTS_FLAG_ENABLED         RT_BIT_32(0)
+#define PDMAUDIOSTRMSTS_FLAG_ENABLED         RT_BIT_32(1)
 /** Whether this stream has been paused or not. This also implies
  *  that this is an enabled stream! */
-#define PDMAUDIOSTRMSTS_FLAG_PAUSED          RT_BIT_32(1)
+#define PDMAUDIOSTRMSTS_FLAG_PAUSED          RT_BIT_32(2)
 /** Whether this stream was marked as being disabled
  *  but there are still associated guest output streams
  *  which rely on its data. */
-#define PDMAUDIOSTRMSTS_FLAG_PENDING_DISABLE RT_BIT_32(2)
+#define PDMAUDIOSTRMSTS_FLAG_PENDING_DISABLE RT_BIT_32(3)
 /** Validation mask. */
-#define PDMAUDIOSTRMSTS_VALID_MASK           UINT32_C(0x00000007)
+#define PDMAUDIOSTRMSTS_VALID_MASK           UINT32_C(0x0000000F)
 
 /**
@@ -418 +472 @@
     bool                   fEmpty;
     /** Name of this stream. */
-    char                  *pszName;
+    char                   szName[64];
     /** Number of references to this stream. Only can be
      *  destroyed if the reference count is reaching 0. */
-    uint8_t                cRefs;
+    uint32_t               cRefs;
 } PDMAUDIOGSTSTRMSTATE, *PPDMAUDIOGSTSTRMSTATE;
 
@@ -515 +569 @@
 /**
  * Audio connector interface (up).
+ ** @todo Get rid of the separate XXXIn and XXXOut methods and unify the In/Out structs with a union,
+ **       so that we only have one guest and one host stream ultimately.
  */
 typedef struct PDMIAUDIOCONNECTOR
 {
     DECLR3CALLBACKMEMBER(int, pfnQueryStatus, (PPDMIAUDIOCONNECTOR pInterface, uint32_t *pcbAvailIn, uint32_t *pcbFreeOut, uint32_t *pcSamplesLive));
+
+    /**
+     * Adds a reference to the specified input stream.
+     *
+     * @returns New reference count.
+     * @param   pInterface      Pointer to the interface structure containing the called function pointer.
+     * @param   pGstStrmIn      Pointer to guest input stream adding the reference to.
+     */
+    DECLR3CALLBACKMEMBER(uint32_t, pfnAddRefIn, (PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOGSTSTRMIN pGstStrmIn));
+
+    /**
+     * Adds a reference to the specified output stream.
+     *
+     * @returns New reference count.
+     * @param   pInterface      Pointer to the interface structure containing the called function pointer.
+     * @param   pGstStrmOut     Pointer to guest output stream adding the reference to.
+     */
+    DECLR3CALLBACKMEMBER(uint32_t, pfnAddRefOut, (PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOGSTSTRMOUT pGstStrmOut));
+
+    /**
+     * Releases a reference from the input specified stream.
+     *
+     * @returns New reference count.
+     * @param   pInterface      Pointer to the interface structure containing the called function pointer.
+     * @param   pGstStrmIn      Pointer to guest input stream releasing a reference from.
+     */
+    DECLR3CALLBACKMEMBER(uint32_t, pfnReleaseIn, (PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOGSTSTRMIN pGstStrmIn));
+
+    /**
+     * Releases a reference from the output specified stream.
+     *
+     * @returns New reference count.
+     * @param   pInterface      Pointer to the interface structure containing the called function pointer.
+     * @param   pGstStrmOut     Pointer to guest output stream releasing a reference from.
+     */
+    DECLR3CALLBACKMEMBER(uint32_t, pfnReleaseOut, (PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOGSTSTRMOUT pGstStrmOut));
 
     /**
@@ -552 +644 @@
      * @param   pCfg            Where to store the host audio backend configuration data.
      */
-    DECLR3CALLBACKMEMBER(int, pfnGetConfiguration, (PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOBACKENDCFG pCfg));
+    DECLR3CALLBACKMEMBER(int, pfnGetConfig, (PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOBACKENDCFG pCfg));
 
     /**
@@ -616 +708 @@
      * @param   pInterface           Pointer to the interface structure containing the called function pointer.
      * @param   pszName              Friendly name of this input stream.
-     * @param   pCfg                 Pointer to PDMAUDIOSTREAMCFG to use.
      * @param   ppGstStrmIn          Pointer where to return the guest guest input stream on success.
      */
-    DECLR3CALLBACKMEMBER(int, pfnCreateIn, (PPDMIAUDIOCONNECTOR pInterface, const char *pszName,
-                                            PPDMAUDIOSTREAMCFG pCfg, PPDMAUDIOGSTSTRMIN *ppGstStrmIn));
+    DECLR3CALLBACKMEMBER(int, pfnCreateIn, (PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOSTREAMCFG pCfg,
+                                            PPDMAUDIOGSTSTRMIN *ppGstStrmIn));
     /**
      * Creates a guest output stream.
@@ -626 +717 @@
      * @returns VBox status code.
      * @param   pInterface           Pointer to the interface structure containing the called function pointer.
-     * @param   pszName              Friendly name of this output stream.
      * @param   pCfg                 Pointer to PDMAUDIOSTREAMCFG to use.
      * @param   ppGstStrmOut         Pointer where to return the guest guest input stream on success.
      */
-    DECLR3CALLBACKMEMBER(int, pfnCreateOut, (PPDMIAUDIOCONNECTOR pInterface, const char *pszName,
-                                             PPDMAUDIOSTREAMCFG pCfg, PPDMAUDIOGSTSTRMOUT *ppGstStrmOut));
-
+    DECLR3CALLBACKMEMBER(int, pfnCreateOut, (PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOSTREAMCFG pCfg,
+                                             PPDMAUDIOGSTSTRMOUT *ppGstStrmOut));
     /**
      * Destroys a guest input stream.
@@ -666 +755 @@
 
 /** PDMIAUDIOCONNECTOR interface ID. */
-#define PDMIAUDIOCONNECTOR_IID                  "f0ef4012-ae89-4528-9dad-4ef496894df8"
+#define PDMIAUDIOCONNECTOR_IID                  "5bba362c-092a-493b-854b-5d0ad3acecc4"
 
 

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

@@ -19 +19 @@
 #include <VBox/log.h>
 
-#if 0
+#if 1
 /*
  * DEBUG_DUMP_PCM_DATA enables dumping the raw PCM data
@@ -230 +230 @@
 uint32_t AudioMixBufAvail(PPDMAUDIOMIXBUF pMixBuf)
 {
-    AssertPtrReturn(pMixBuf, true);
+    AssertPtrReturn(pMixBuf, 0);
 
     uint32_t cAvail;
-    if (pMixBuf->pParent) /* Child */
+    if (pMixBuf->pParent) /* Is this a child buffer? */
         cAvail = pMixBuf->cMixed;
     else
@@ -975 +975 @@
 static int audioMixBufMixTo(PPDMAUDIOMIXBUF pDst, PPDMAUDIOMIXBUF pSrc, uint32_t cSamples, uint32_t *pcProcessed)
 {
-    AssertPtrReturn(pDst, VERR_INVALID_POINTER);
-    AssertPtrReturn(pSrc, VERR_INVALID_POINTER);
+    AssertPtrReturn(pDst,  VERR_INVALID_POINTER);
+    AssertPtrReturn(pSrc,  VERR_INVALID_POINTER);
     AssertReturn(cSamples, VERR_INVALID_PARAMETER);
     /* pcProcessed is optional. */
@@ -1021 +1021 @@
 
         Assert(offWrite + cToWrite <= pDst->cSamples);
-        Assert(offRead + cToRead <= pSrc->cSamples);
+        Assert(offRead  + cToRead  <= pSrc->cSamples);
 
         AUDMIXBUF_LOG(("\t%RU32Hz -> %RU32Hz\n", AUDMIXBUF_FMT_SAMPLE_FREQ(pSrc->AudioFmt), AUDMIXBUF_FMT_SAMPLE_FREQ(pDst->AudioFmt)));
@@ -1046 +1046 @@
 
     pSrc->cMixed     += cWrittenTotal;
+
     pDst->cProcessed += cWrittenTotal;
+
+#if 0
+    /**
+     * Note: pDst->cProcessed can be bigger than pDst->cSamples if there
+     *       was a wrap-around. In that case samples were lost,
+     *       e.g. not consumed (yet).
+     *
+     *       So adjust the current read/write offset to match the current
+     *       position, minus the dropped samples. */
+    if (pDst->cProcessed > pDst->cSamples)
+    {
+        LogFlowFunc(("%s: %RU32 / %RU32\n", pDst->pszName, pDst->cProcessed, pDst->cSamples));
+        pSrc->cMixed       = pDst->cSamples;
+        pDst->offReadWrite = 0;
+        pDst->cProcessed   = pDst->cSamples;
+    }
+#endif
+
 #ifdef DEBUG
     s_cSamplesMixedTotal += cWrittenTotal;
@@ -1135 +1154 @@
 
     AUDMIXBUF_LOG(("********************************************\n"));
-    AUDMIXBUF_LOG(("[PARENT] %s: offReadWrite=%RU32, cProcessed=%RU32, cMixed=%RU32 (BpS=%RU32)\n",
-                   pParent->pszName,
+    AUDMIXBUF_LOG(("[PARENT] %s (%RU32): offReadWrite=%RU32, cProcessed=%RU32, cMixed=%RU32 (BpS=%RU32)\n",
+                   pParent->pszName, pParent->cSamples,
                    pParent->offReadWrite, pParent->cProcessed, pParent->cMixed,
                    AUDIOMIXBUF_S2B(pParent, 1)));
 
+    size_t cChildren = 0;
+
     PPDMAUDIOMIXBUF pIter;
     RTListForEach(&pParent->lstBuffers, pIter, PDMAUDIOMIXBUF, Node)
     {
-        AUDMIXBUF_LOG(("\t[CHILD] %s: offReadWrite=%RU32, cProcessed=%RU32, cMixed=%RU32 (BpS=%RU32)\n",
-                       pIter->pszName,
+        AUDMIXBUF_LOG(("\t[CHILD] %s (%RU32): offReadWrite=%RU32, cProcessed=%RU32, cMixed=%RU32 (BpS=%RU32)\n",
+                       pIter->pszName, pIter->cSamples,
                        pIter->offReadWrite, pIter->cProcessed, pIter->cMixed,
                        AUDIOMIXBUF_S2B(pIter, 1)));
-    }
-    AUDMIXBUF_LOG(("Total samples mixed: %RU64\n", s_cSamplesMixedTotal));
+        cChildren++;
+    }
+    AUDMIXBUF_LOG(("Children: %zu - Total samples mixed: %RU64\n", cChildren, s_cSamplesMixedTotal));
     AUDMIXBUF_LOG(("********************************************\n"));
 }

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

@@ -4 +4 @@
  *             emulations to achieve proper multiplexing from/to attached
  *             devices LUNs.
+ *
+ * This mixer acts as a layer between the audio connector interface and
+ * the actual device emulation, providing mechanisms for audio sources (input) and
+ * audio sinks (output).
+ *
+ * As audio driver instances are handled as LUNs on the device level, this
+ * audio mixer then can take care of e.g. mixing various inputs/outputs to/from
+ * a specific source/sink.
+ *
+ * How and which audio streams are connected to sinks/sources depends on how
+ * the audio mixer has been set up.
+ *
+ * A sink can connect multiple output streams together, whereas a source
+ * does this with input streams. Each sink / source consists of one or more
+ * so-called mixer streams, which then in turn have pointers to the actual
+ * PDM audio input/output streams.
  */
 
@@ -32 +48 @@
 #include <iprt/string.h>
 
-static int audioMixerUpdateSinkVolume(PAUDMIXSINK pSink, const PPDMAUDIOVOLUME pVolMaster);
-
-
-int AudioMixerAddSink(PAUDIOMIXER pMixer, const char *pszName, AUDMIXSINKDIR enmDir, PAUDMIXSINK *ppSink)
+static void audioMixerSinkDestroyInternal(PAUDMIXSINK pSink);
+static int audioMixerSinkUpdateVolume(PAUDMIXSINK pSink, const PPDMAUDIOVOLUME pVolMaster);
+static void audioMixerSinkRemoveStreamInternal(PAUDMIXSINK pSink, PAUDMIXSTREAM pStream);
+
+static void audioMixerStreamDestroyInternal(PAUDMIXSTREAM pStream);
+static void audioMixerStreamFree(PAUDMIXSTREAM pStream);
+
+int AudioMixerCreateSink(PAUDIOMIXER pMixer, const char *pszName, AUDMIXSINKDIR enmDir, PAUDMIXSINK *ppSink)
 {
     AssertPtrReturn(pMixer, VERR_INVALID_POINTER);
     AssertPtrReturn(pszName, VERR_INVALID_POINTER);
-    /** ppSink is optional. */
+    /* ppSink is optional. */
 
     int rc = VINF_SUCCESS;
@@ -80 +100 @@
 }
 
-int AudioMixerAddStreamIn(PAUDMIXSINK pSink, PPDMIAUDIOCONNECTOR pConnector, PPDMAUDIOGSTSTRMIN pStream,
-                          uint32_t uFlags, PAUDMIXSTREAM *ppStream)
-{
-    AssertPtrReturn(pSink, VERR_INVALID_POINTER);
-    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
-    /** @todo Add flag validation. */
-    /* ppStream is optional. */
-
-    int rc;
-
-    if (pSink->cStreams == UINT8_MAX) /* 255 streams per sink max. */
-        return VERR_TOO_MUCH_DATA;
-
-    PAUDMIXSTREAM pMixStream
-        = (PAUDMIXSTREAM)RTMemAllocZ(sizeof(AUDMIXSTREAM));
-    if (pMixStream)
-    {
-        pMixStream->pConn = pConnector;
-        pMixStream->pIn   = pStream;
-        /** @todo Process flags. */
-
-        RTListAppend(&pSink->lstStreams, &pMixStream->Node);
-        pSink->cStreams++;
-
-        LogFlowFunc(("%s: pStream=%p, cStreams=%RU8\n",
-                     pSink->pszName, pMixStream, pSink->cStreams));
-
-        /* Increase the stream's reference count to let others know
-         * we're reyling on it to be around now. */
-        pStream->State.cRefs++;
-
-        if (ppStream)
-            *ppStream = pMixStream;
-
-        rc = VINF_SUCCESS;
-    }
-    else
-        rc = VERR_NO_MEMORY;
-
-    return rc;
-}
-
-int AudioMixerAddStreamOut(PAUDMIXSINK pSink, PPDMIAUDIOCONNECTOR pConnector, PPDMAUDIOGSTSTRMOUT pStream,
-                           uint32_t uFlags, PAUDMIXSTREAM *ppStream)
-{
-    AssertPtrReturn(pSink, VERR_INVALID_POINTER);
-    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
-    /** @todo Add flag validation. */
-    /* ppStream is optional. */
-
-    int rc;
-
-    if (pSink->cStreams == UINT8_MAX) /* 255 streams per sink max. */
-        return VERR_TOO_MUCH_DATA;
-
-    PAUDMIXSTREAM pMixStream
-        = (PAUDMIXSTREAM)RTMemAllocZ(sizeof(AUDMIXSTREAM));
-    if (pMixStream)
-    {
-        pMixStream->pConn = pConnector;
-        pMixStream->pOut  = pStream;
-        /** @todo Process flags. */
-
-        RTListAppend(&pSink->lstStreams, &pMixStream->Node);
-        pSink->cStreams++;
-
-        LogFlowFunc(("%s: pStream=%p, cStreams=%RU8\n",
-                     pSink->pszName, pMixStream, pSink->cStreams));
-
-        /* Increase the stream's reference count to let others know
-         * we're reyling on it to be around now. */
-        pStream->State.cRefs++;
-
-        if (ppStream)
-            *ppStream = pMixStream;
-
-        rc = VINF_SUCCESS;
-    }
-    else
-        rc = VERR_NO_MEMORY;
-
-    return rc;
-}
-
-int AudioMixerControlStream(PAUDIOMIXER pMixer, PAUDMIXSTREAM pHandle)
-{
-    return VERR_NOT_IMPLEMENTED;
-}
-
 int AudioMixerCreate(const char *pszName, uint32_t uFlags, PAUDIOMIXER *ppMixer)
 {
@@ -207 +138 @@
 }
 
+void AudioMixerDebug(PAUDIOMIXER pMixer, PCDBGFINFOHLP pHlp, const char *pszArgs)
+{
+    PAUDMIXSINK pSink;
+    unsigned    iSink = 0;
+
+    pHlp->pfnPrintf(pHlp, "[Master] %s: lVol=%u, rVol=%u, fMuted=%RTbool\n", pMixer->pszName,
+                    pMixer->VolMaster.uLeft, pMixer->VolMaster.uRight, pMixer->VolMaster.fMuted);
+
+    RTListForEach(&pMixer->lstSinks, pSink, AUDMIXSINK, Node)
+    {
+        pHlp->pfnPrintf(pHlp, "[Sink %u] %s: lVol=%u, rVol=%u, fMuted=%RTbool\n", iSink, pSink->pszName,
+                        pSink->Volume.uLeft, pSink->Volume.uRight, pSink->Volume.fMuted);
+        ++iSink;
+    }
+}
+
 void AudioMixerDestroy(PAUDIOMIXER pMixer)
 {
@@ -216 +163 @@
     PAUDMIXSINK pSink, pSinkNext;
     RTListForEachSafe(&pMixer->lstSinks, pSink, pSinkNext, AUDMIXSINK, Node)
-        AudioMixerRemoveSink(pMixer, pSink);
-
-    Assert(pMixer->cSinks == 0);
+        audioMixerSinkDestroyInternal(pSink);
 
     if (pMixer->pszName)
@@ -227 +172 @@
 
     RTMemFree(pMixer);
-}
-
-static void audioMixerDestroySink(PAUDMIXSINK pSink)
+    pMixer = NULL;
+}
+
+int AudioMixerGetDeviceFormat(PAUDIOMIXER pMixer, PPDMAUDIOSTREAMCFG pCfg)
+{
+    AssertPtrReturn(pMixer, VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfg,   VERR_INVALID_POINTER);
+
+    /** @todo Perform a deep copy, if needed. */
+    *pCfg = pMixer->devFmt;
+
+    return VINF_SUCCESS;
+}
+
+void AudioMixerInvalidate(PAUDIOMIXER pMixer)
+{
+    AssertPtrReturnVoid(pMixer);
+
+    LogFlowFunc(("%s: Invalidating ...\n", pMixer->pszName));
+
+    /* Propagate new master volume to all connected sinks. */
+    PAUDMIXSINK pSink;
+    RTListForEach(&pMixer->lstSinks, pSink, AUDMIXSINK, Node)
+    {
+        int rc2 = audioMixerSinkUpdateVolume(pSink, &pMixer->VolMaster);
+        AssertRC(rc2);
+    }
+}
+
+void AudioMixerRemoveSink(PAUDIOMIXER pMixer, PAUDMIXSINK pSink)
+{
+    AssertPtrReturnVoid(pMixer);
+    if (!pSink)
+        return;
+
+    /** @todo Check if pSink is part of pMixer. */
+
+    AudioMixerSinkRemoveAllStreams(pSink);
+
+    Assert(pSink->cStreams == 0);
+
+    RTListNodeRemove(&pSink->Node);
+
+    Assert(pMixer->cSinks);
+    pMixer->cSinks--;
+
+    LogFlowFunc(("%s: pSink=%s, cSinks=%RU8\n",
+                 pMixer->pszName, pSink->pszName, pMixer->cSinks));
+}
+
+int AudioMixerSetDeviceFormat(PAUDIOMIXER pMixer, PPDMAUDIOSTREAMCFG pCfg)
+{
+    AssertPtrReturn(pMixer, VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfg, VERR_INVALID_POINTER);
+
+    /** @todo Perform a deep copy, if needed. */
+    pMixer->devFmt = *pCfg;
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * Sets the mixer's master volume.
+ *
+ * @returns IPRT status code.
+ * @param   pMixer          Mixer to set master volume for.
+ * @param   pVol            Volume to set.
+ */
+int AudioMixerSetMasterVolume(PAUDIOMIXER pMixer, PPDMAUDIOVOLUME pVol)
+{
+    AssertPtrReturn(pMixer, VERR_INVALID_POINTER);
+    AssertPtrReturn(pVol,   VERR_INVALID_POINTER);
+
+    pMixer->VolMaster = *pVol;
+
+    LogFlowFunc(("%s: lVol=%RU32, rVol=%RU32 => fMuted=%RTbool, lVol=%RU32, rVol=%RU32\n",
+                 pMixer->pszName, pVol->uLeft, pVol->uRight,
+                 pMixer->VolMaster.fMuted, pMixer->VolMaster.uLeft, pMixer->VolMaster.uRight));
+
+    AudioMixerInvalidate(pMixer);
+    return VINF_SUCCESS;
+}
+
+/*****************************************************************************
+ * Mixer Sink implementation.
+ *****************************************************************************/
+
+int AudioMixerSinkAddStream(PAUDMIXSINK pSink, PAUDMIXSTREAM pStream)
+{
+    AssertPtrReturn(pSink,   VERR_INVALID_POINTER);
+    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
+
+    if (pSink->cStreams == UINT8_MAX) /* 255 streams per sink max. */
+        return VERR_NO_MORE_HANDLES;
+
+    /** @todo Check if stream already is assigned to (another) sink. */
+
+    RTListAppend(&pSink->lstStreams, &pStream->Node);
+    pSink->cStreams++;
+
+    LogFlowFunc(("%s: cStreams=%RU8\n", pSink->pszName, pSink->cStreams));
+
+    return VINF_SUCCESS;
+}
+
+static PDMAUDIOSTREAMCMD audioMixerSinkToStreamCmd(AUDMIXSINKCMD enmCmd)
+{
+    switch (enmCmd)
+    {
+        case AUDMIXSINKCMD_ENABLE:   return PDMAUDIOSTREAMCMD_ENABLE;
+        case AUDMIXSINKCMD_DISABLE:  return PDMAUDIOSTREAMCMD_DISABLE;
+        case AUDMIXSINKCMD_PAUSE:    return PDMAUDIOSTREAMCMD_PAUSE;
+        case AUDMIXSINKCMD_RESUME:   return PDMAUDIOSTREAMCMD_RESUME;
+        default:                     break;
+    }
+
+    AssertMsgFailed(("Unsupported sink command %ld\n", enmCmd));
+    return PDMAUDIOSTREAMCMD_UNKNOWN;
+}
+
+int AudioMixerSinkCtl(PAUDMIXSINK pSink, AUDMIXSINKCMD enmCmd)
+{
+    AssertPtrReturn(pSink, VERR_INVALID_POINTER);
+
+    PDMAUDIOSTREAMCMD enmCmdStream = audioMixerSinkToStreamCmd(enmCmd);
+    if (enmCmdStream == PDMAUDIOSTREAMCMD_UNKNOWN)
+        return VERR_NOT_SUPPORTED;
+
+    int rc = VINF_SUCCESS;
+
+    PAUDMIXSTREAM pStream;
+    RTListForEach(&pSink->lstStreams, pStream, AUDMIXSTREAM, Node)
+    {
+        int rc2 = AudioMixerStreamCtl(pStream, enmCmdStream, AUDMIXSTRMCTL_FLAG_NONE);
+        if (RT_SUCCESS(rc))
+            rc = rc2;
+        /* Keep going. Flag? */
+    }
+
+    LogFlowFunc(("Sink=%s, Cmd=%ld, rc=%Rrc\n", pSink->pszName, enmCmd, rc));
+    return rc;
+}
+
+void AudioMixerSinkDestroy(PAUDMIXSINK pSink)
+{
+    audioMixerSinkDestroyInternal(pSink);
+}
+
+static void audioMixerSinkDestroyInternal(PAUDMIXSINK pSink)
 {
     AssertPtrReturnVoid(pSink);
@@ -235 +326 @@
         return;
 
+    LogFunc(("%s\n", pSink->pszName));
+
+    PAUDMIXSTREAM pStream, pStreamNext;
+    RTListForEachSafe(&pSink->lstStreams, pStream, pStreamNext, AUDMIXSTREAM, Node)
+    {
+        audioMixerSinkRemoveStreamInternal(pSink, pStream);
+        audioMixerStreamDestroyInternal(pStream);
+    }
+
+    Assert(pSink->cStreams == 0);
+
     if (pSink->pszName)
         RTStrFree(pSink->pszName);
@@ -241 +343 @@
 }
 
-static void audioMixerDestroyStream(PAUDMIXSTREAM pStream)
-{
-    AssertPtrReturnVoid(pStream);
-    if (!pStream)
-        return;
-
-    RTMemFree(pStream);
-}
-
-int AudioMixerGetDeviceFormat(PAUDIOMIXER pMixer, PPDMAUDIOSTREAMCFG pCfg)
-{
-    AssertPtrReturn(pMixer, VERR_INVALID_POINTER);
-    AssertPtrReturn(pCfg, VERR_INVALID_POINTER);
-
-    /** @todo Perform a deep copy, if needed. */
-    *pCfg = pMixer->devFmt;
-
-    return VINF_SUCCESS;
-}
-
-uint32_t AudioMixerGetStreamCount(PAUDIOMIXER pMixer)
-{
-    AssertPtrReturn(pMixer, 0);
-
-    uint32_t cStreams = 0;
-
-    PAUDMIXSINK pSink;
-    RTListForEach(&pMixer->lstSinks, pSink, AUDMIXSINK, Node)
-        cStreams += pSink->cStreams;
-
-    return cStreams;
-}
-
-void AudioMixerInvalidate(PAUDIOMIXER pMixer)
-{
-    AssertPtrReturnVoid(pMixer);
-
-    LogFlowFunc(("%s: Invalidating ...\n", pMixer->pszName));
-
-    /* Propagate new master volume to all connected sinks. */
-    PAUDMIXSINK pSink;
-    RTListForEach(&pMixer->lstSinks, pSink, AUDMIXSINK, Node)
-    {
-        int rc2 = audioMixerUpdateSinkVolume(pSink, &pMixer->VolMaster);
-        AssertRC(rc2);
-    }
-}
-
-int AudioMixerProcessSinkIn(PAUDMIXSINK pSink, AUDMIXOP enmOp, void *pvBuf, uint32_t cbBuf, uint32_t *pcbProcessed)
+PAUDMIXSTREAM AudioMixerSinkGetStream(PAUDMIXSINK pSink, uint8_t uIndex)
+{
+    AssertPtrReturn(pSink, NULL);
+    AssertMsgReturn(uIndex < pSink->cStreams,
+                    ("Index %RU8 exceeds stream count (%RU8)", uIndex, pSink->cStreams), NULL);
+
+    /* Slow lookup, d'oh. */
+    PAUDMIXSTREAM pStream = RTListGetFirst(&pSink->lstStreams, AUDMIXSTREAM, Node);
+    while (uIndex)
+    {
+        pStream = RTListGetNext(&pSink->lstStreams, pStream, AUDMIXSTREAM, Node);
+        uIndex--;
+    }
+
+    AssertPtr(pStream);
+    return pStream;
+}
+
+uint8_t AudioMixerSinkGetStreamCount(PAUDMIXSINK pSink)
+{
+    if (!pSink)
+        return 0;
+
+    return pSink->cStreams;
+}
+
+int AudioMixerSinkRead(PAUDMIXSINK pSink, AUDMIXOP enmOp, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead)
 {
     AssertPtrReturn(pSink, VERR_INVALID_POINTER);
     AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
-    AssertReturn(cbBuf, VERR_INVALID_PARAMETER);
-    /* pcbProcessed is optional. */
+    AssertReturn(cbBuf,    VERR_INVALID_PARAMETER);
+    /* pcbRead is optional. */
 
     /** @todo Handle mixing operation enmOp! */
@@ -303 +383 @@
 
     int rc = VERR_NOT_FOUND;
-    uint32_t cbProcessed = 0;
-
-    LogFlowFunc(("%s: pvBuf=%p, cbBuf=%zu\n", pSink->pszName, pvBuf, cbBuf));
+    uint32_t cbRead = 0;
 
     PAUDMIXSTREAM pStream;
     RTListForEach(&pSink->lstStreams, pStream, AUDMIXSTREAM, Node)
     {
-        if (!pStream->pConn->pfnIsActiveIn(pStream->pConn, pStream->pIn))
+        if (!pStream->pConn->pfnIsActiveIn(pStream->pConn, pStream->InOut.pIn))
             continue;
 
@@ -318 +396 @@
         while (cbToRead)
         {
-            uint32_t cbRead;
+            uint32_t cbReadStrm;
             AssertPtr(pStream->pConn);
-            rc = pStream->pConn->pfnRead(pStream->pConn, pStream->pIn,
-                                         (uint8_t *)pvMixBuf + cbTotalRead, cbToRead, &cbRead);
+            rc = pStream->pConn->pfnRead(pStream->pConn, pStream->InOut.pIn,
+                                         (uint8_t *)pvMixBuf + cbTotalRead, cbToRead, &cbReadStrm);
             if (   RT_FAILURE(rc)
-                || !cbRead)
+                || !cbReadStrm)
                 break;
 
             /** @todo Right now we only handle one stream (the last one added in fact). */
 
-            AssertBreakStmt(cbRead <= cbToRead, rc = VERR_BUFFER_OVERFLOW);
-            cbToRead -= cbRead;
-            cbTotalRead += cbRead;
+            AssertBreakStmt(cbReadStrm <= cbToRead, rc = VERR_BUFFER_OVERFLOW);
+            cbToRead    -= cbReadStrm;
+            cbTotalRead += cbReadStrm;
         }
 
@@ -336 +414 @@
             continue;
 
-        cbProcessed = RT_MAX(cbProcessed, cbTotalRead);
+        cbRead = RT_MAX(cbRead, cbTotalRead);
     }
 
     if (RT_SUCCESS(rc))
     {
-        memcpy(pvBuf, pvMixBuf, cbProcessed); /* @todo Use an intermediate mixing buffer per sink! */
-
-        if (pcbProcessed)
-            *pcbProcessed = cbProcessed;
+        memcpy(pvBuf, pvMixBuf, cbRead); /* @todo Use an intermediate mixing buffer per sink! */
+
+        if (pcbRead)
+            *pcbRead = cbRead;
     }
 
     RTMemFree(pvMixBuf);
 
-    LogFlowFunc(("cbProcessed=%RU32, rc=%Rrc\n", cbProcessed, rc));
+    Log3Func(("%s: cbRead=%RU32, rc=%Rrc\n", pSink->pszName, cbRead, rc));
     return rc;
 }
 
-int AudioMixerProcessSinkOut(PAUDMIXSINK pSink, AUDMIXOP enmOp, const void *pvBuf, uint32_t cbBuf, uint32_t *pcbProcessed)
-{
-    return VERR_NOT_IMPLEMENTED;
-}
-
-void AudioMixerRemoveSink(PAUDIOMIXER pMixer, PAUDMIXSINK pSink)
-{
-    AssertPtrReturnVoid(pMixer);
-    if (!pSink)
-        return;
-
-    PAUDMIXSTREAM pStream, pStreamNext;
-    RTListForEachSafe(&pSink->lstStreams, pStream, pStreamNext, AUDMIXSTREAM, Node)
-        AudioMixerRemoveStream(pSink, pStream);
-
-    Assert(pSink->cStreams == 0);
-
-    RTListNodeRemove(&pSink->Node);
-    Assert(pMixer->cSinks);
-    pMixer->cSinks--;
-
-    LogFlowFunc(("%s: pSink=%s, cSinks=%RU8\n",
-                 pMixer->pszName, pSink->pszName, pMixer->cSinks));
-
-    audioMixerDestroySink(pSink);
-}
-
-void AudioMixerRemoveStream(PAUDMIXSINK pSink, PAUDMIXSTREAM pStream)
+static void audioMixerSinkRemoveStreamInternal(PAUDMIXSINK pSink, PAUDMIXSTREAM pStream)
 {
     AssertPtrReturnVoid(pSink);
@@ -386 +437 @@
         return;
 
+    /** @todo Check if pStream is part of pSink. */
+
     Assert(pSink->cStreams);
-    RTListNodeRemove(&pStream->Node);
-    pSink->cStreams--;
 
 #ifdef DEBUG
     const char *pszStream = pSink->enmDir == AUDMIXSINKDIR_INPUT
-                          ? pStream->pIn->MixBuf.pszName : pStream->pOut->MixBuf.pszName;
-
-    LogFlowFunc(("%s: pStream=%s, cStreams=%RU8\n",
+                          ? pStream->InOut.pIn->MixBuf.pszName : pStream->InOut.pOut->MixBuf.pszName;
+
+    LogFlowFunc(("%s: (Stream = %s), cStreams=%RU8\n",
                  pSink->pszName, pszStream ? pszStream : "<Unnamed>", pSink->cStreams));
 #endif
 
-    /* Decrease the reference count again. */
-    switch (pSink->enmDir)
-    {
-        case AUDMIXSINKDIR_INPUT:
-        {
-            Assert(pStream->pIn->State.cRefs);
-            pStream->pIn->State.cRefs--;
-            break;
-        }
-
-        case AUDMIXSINKDIR_OUTPUT:
-        {
-            Assert(pStream->pOut->State.cRefs);
-            pStream->pOut->State.cRefs--;
-            break;
-        }
-
-        default:
-            AssertMsgFailed(("Not implemented\n"));
-            break;
-    }
-
-    audioMixerDestroyStream(pStream);
-}
-
-int AudioMixerSetDeviceFormat(PAUDIOMIXER pMixer, PPDMAUDIOSTREAMCFG pCfg)
-{
-    AssertPtrReturn(pMixer, VERR_INVALID_POINTER);
-    AssertPtrReturn(pCfg, VERR_INVALID_POINTER);
-
-    /** @todo Perform a deep copy, if needed. */
-    pMixer->devFmt = *pCfg;
+    /* Remove stream from sink. */
+    RTListNodeRemove(&pStream->Node);
+
+    Assert(pSink->cStreams);
+    pSink->cStreams--;
+}
+
+void AudioMixerSinkRemoveStream(PAUDMIXSINK pSink, PAUDMIXSTREAM pStream)
+{
+    audioMixerSinkRemoveStreamInternal(pSink, pStream);
+}
+
+/**
+ * Removes all attached streams from a given sink.
+ *
+ * @param pSink         Sink to remove attached streams from.
+ */
+void AudioMixerSinkRemoveAllStreams(PAUDMIXSINK pSink)
+{
+    if (!pSink)
+        return;
+
+    LogFunc(("%s\n", pSink->pszName));
+
+    PAUDMIXSTREAM pStream, pStreamNext;
+    RTListForEachSafe(&pSink->lstStreams, pStream, pStreamNext, AUDMIXSTREAM, Node)
+        audioMixerSinkRemoveStreamInternal(pSink, pStream);
+
+    Assert(pSink->cStreams == 0);
+}
+
+int AudioMixerSinkSetFormat(PAUDMIXSINK pSink, PPDMPCMPROPS pPCMProps)
+{
+    AssertPtrReturn(pSink,     VERR_INVALID_POINTER);
+    AssertPtrReturn(pPCMProps, VERR_INVALID_POINTER);
+
+    memcpy(&pSink->PCMProps, pPCMProps, sizeof(PDMPCMPROPS));
+
+    PAUDMIXSTREAM pStream;
+    RTListForEach(&pSink->lstStreams, pStream, AUDMIXSTREAM, Node)
+    {
+        /** @todo Invalidate mix buffers! */
+    }
 
     return VINF_SUCCESS;
 }
 
-static int audioMixerUpdateSinkVolume(PAUDMIXSINK pSink, const PPDMAUDIOVOLUME pVolMaster)
+/**
+ * Set the volume of an individual sink.
+ *
+ * @returns IPRT status code.
+ * @param   pSink           Sink to set volume for.
+ * @param   pVol            Volume to set.
+ */
+int AudioMixerSinkSetVolume(PAUDMIXSINK pSink, PPDMAUDIOVOLUME pVol)
+{
+    AssertPtrReturn(pSink, VERR_INVALID_POINTER);
+    AssertPtrReturn(pVol,  VERR_INVALID_POINTER);
+    AssertPtr(pSink->pParent);
+
+    LogFlowFunc(("%s: fMuted=%RTbool, lVol=%RU32, rVol=%RU32\n", pSink->pszName, pVol->fMuted, pVol->uLeft, pVol->uRight));
+
+    pSink->Volume = *pVol;
+
+    return audioMixerSinkUpdateVolume(pSink, &pSink->pParent->VolMaster);
+}
+
+int AudioMixerSinkUpdate(PAUDMIXSINK pSink)
+{
+    AssertPtrReturn(pSink, VERR_INVALID_POINTER);
+
+    PAUDMIXSTREAM pStream;
+    RTListForEach(&pSink->lstStreams, pStream, AUDMIXSTREAM, Node)
+    {
+        uint32_t cbIn, cbOut;
+        uint32_t cSamplesLive;
+        int rc2 = pStream->pConn->pfnQueryStatus(pStream->pConn,
+                                                 &cbIn, &cbOut, &cSamplesLive);
+#ifdef DEBUG
+        if (   cbIn
+            || cbOut
+            || cSamplesLive)
+        {
+            Log3Func(("cbIn=%RU32, cbOut=%RU32, cSamplesLive=%RU32, rc2=%Rrc\n", cbIn, cbOut, cSamplesLive, rc2));
+        }
+#endif
+        if (pSink->enmDir == AUDMIXSINKDIR_OUTPUT)
+        {
+            rc2 = pStream->pConn->pfnPlayOut(pStream->pConn, NULL /* pcSamplesPlayed */);
+            if (RT_FAILURE(rc2))
+                Log3Func(("rc2=%Rrc\n", rc2));
+        }
+        else if (pSink->enmDir == AUDMIXSINKDIR_INPUT)
+        {
+            //int rc2 = pStream->pConn->pfnCaptureIn(pStream->pConn, NULL /* pcSamplesCaptured */);
+            //Log3Func(("rc2=%Rrc\n", rc2));
+        }
+        else
+            AssertMsgFailed(("Direction not implemented\n"));
+    }
+
+    return VINF_SUCCESS;
+}
+
+static int audioMixerSinkUpdateVolume(PAUDMIXSINK pSink, const PPDMAUDIOVOLUME pVolMaster)
 {
     AssertPtrReturn(pSink,      VERR_INVALID_POINTER);
@@ -461 +580 @@
     {
         if (fOut)
-            AudioMixBufSetVolume(&pStream->pOut->MixBuf, &volSink);
+            AudioMixBufSetVolume(&pStream->InOut.pOut->MixBuf, &volSink);
         else
-            AudioMixBufSetVolume(&pStream->pIn->MixBuf,  &volSink);
+            AudioMixBufSetVolume(&pStream->InOut.pIn->MixBuf,  &volSink);
     }
 
@@ -469 +588 @@
 }
 
-/** Set the master volume of the mixer. */
-int AudioMixerSetMasterVolume(PAUDIOMIXER pMixer, PPDMAUDIOVOLUME pVol)
-{
-    AssertPtrReturn(pMixer, VERR_INVALID_POINTER);
-    AssertPtrReturn(pVol,   VERR_INVALID_POINTER);
-
-    pMixer->VolMaster = *pVol;
-
-    LogFlowFunc(("%s: lVol=%RU32, rVol=%RU32 => fMuted=%RTbool, lVol=%RU32, rVol=%RU32\n",
-                 pMixer->pszName, pVol->uLeft, pVol->uRight,
-                 pMixer->VolMaster.fMuted, pMixer->VolMaster.uLeft, pMixer->VolMaster.uRight));
-
-    AudioMixerInvalidate(pMixer);
+int AudioMixerSinkWrite(PAUDMIXSINK pSink, AUDMIXOP enmOp, const void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten)
+{
+    AssertPtrReturn(pSink, VERR_INVALID_POINTER);
+    /* pcbWritten is optional. */
+
+    if (!pvBuf || !cbBuf)
+    {
+        if (pcbWritten)
+            *pcbWritten = 0;
+        return VINF_SUCCESS;
+    }
+
+    uint32_t cbProcessed = 0;
+
+    PAUDMIXSTREAM pStream;
+    RTListForEach(&pSink->lstStreams, pStream, AUDMIXSTREAM, Node)
+    {
+        int rc2 = pStream->pConn->pfnWrite(pStream->pConn, pStream->InOut.pOut, pvBuf, cbBuf, &cbProcessed);
+        if (   RT_FAILURE(rc2)
+            || cbProcessed < cbBuf)
+        {
+            LogFlowFunc(("rc=%Rrc, cbBuf=%RU32, cbProcessed=%RU32\n", rc2, cbBuf, cbProcessed));
+        }
+    }
+
+    if (pcbWritten)
+        *pcbWritten = cbBuf; /* Always report back a complete write for now. */
+
     return VINF_SUCCESS;
 }
 
-/** Set the volume of an individual sink. */
-int AudioMixerSetSinkVolume(PAUDMIXSINK pSink, PPDMAUDIOVOLUME pVol)
-{
-    AssertPtrReturn(pSink, VERR_INVALID_POINTER);
-    AssertPtrReturn(pVol,  VERR_INVALID_POINTER);
-    AssertPtr(pSink->pParent);
-
-    LogFlowFunc(("%s: fMuted=%RTbool, lVol=%RU32, rVol=%RU32\n", pSink->pszName, pVol->fMuted, pVol->uLeft, pVol->uRight));
-
-    pSink->Volume = *pVol;
-
-    return audioMixerUpdateSinkVolume(pSink, &pSink->pParent->VolMaster);
-}
-
-void AudioMixerDebug(PAUDIOMIXER pMixer, PCDBGFINFOHLP pHlp, const char *pszArgs)
-{
-    PAUDMIXSINK pSink;
-    unsigned    iSink = 0;
-
-    pHlp->pfnPrintf(pHlp, "[Master] %s: lVol=%u, rVol=%u, fMuted=%RTbool\n", pMixer->pszName,
-                    pMixer->VolMaster.uLeft, pMixer->VolMaster.uRight, pMixer->VolMaster.fMuted);
-
-    RTListForEach(&pMixer->lstSinks, pSink, AUDMIXSINK, Node)
-    {
-        pHlp->pfnPrintf(pHlp, "[Sink %u] %s: lVol=%u, rVol=%u, fMuted=%RTbool\n", iSink, pSink->pszName,
-                        pSink->Volume.uLeft, pSink->Volume.uRight, pSink->Volume.fMuted);
-        ++iSink;
-    }
-}
+/*****************************************************************************
+ * Mixer Stream implementation.
+ *****************************************************************************/
+
+int AudioMixerStreamCtl(PAUDMIXSTREAM pStream, PDMAUDIOSTREAMCMD enmCmd, uint32_t fCtl)
+{
+    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
+    /** @todo Validate fCtl. */
+
+    int rc;
+    switch (pStream->enmDir)
+    {
+        case PDMAUDIODIR_IN:
+        {
+            if (   enmCmd == PDMAUDIOSTREAMCMD_ENABLE
+                || enmCmd == PDMAUDIOSTREAMCMD_DISABLE)
+            {
+                rc = pStream->pConn->pfnEnableIn(pStream->pConn, pStream->InOut.pIn,
+                                                 enmCmd == PDMAUDIOSTREAMCMD_ENABLE);
+            }
+            else
+                AssertFailed();
+            break;
+        }
+
+        case PDMAUDIODIR_OUT:
+        {
+            if (   enmCmd == PDMAUDIOSTREAMCMD_ENABLE
+                || enmCmd == PDMAUDIOSTREAMCMD_DISABLE)
+            {
+                rc = pStream->pConn->pfnEnableOut(pStream->pConn, pStream->InOut.pOut,
+                                                  enmCmd == PDMAUDIOSTREAMCMD_ENABLE);
+            }
+            else
+                AssertFailed();
+            break;
+        }
+
+        default:
+            AssertMsgFailed(("Not implemented\n"));
+            break;
+    }
+
+    return rc;
+}
+
+int AudioMixerStreamCreate(PPDMIAUDIOCONNECTOR pConn, PPDMAUDIOSTREAMCFG pCfg, uint32_t fFlags, PAUDMIXSTREAM *ppStream)
+{
+    AssertPtrReturn(pConn, VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfg,  VERR_INVALID_POINTER);
+    /** @todo Validate fFlags. */
+    /* ppStream is optional. */
+
+    PAUDMIXSTREAM pMixStream = (PAUDMIXSTREAM)RTMemAllocZ(sizeof(AUDMIXSTREAM));
+    if (!pMixStream)
+        return VERR_NO_MEMORY;
+
+    pMixStream->pszName = RTStrDup(pCfg->szName);
+    if (!pMixStream->pszName)
+    {
+        RTMemFree(pMixStream);
+        return VERR_NO_MEMORY;
+    }
+
+    int rc;
+    if (pCfg->enmDir == PDMAUDIODIR_IN)
+    {
+        PPDMAUDIOGSTSTRMIN pGstStrm;
+        rc = pConn->pfnCreateIn(pConn, pCfg, &pGstStrm);
+        if (RT_SUCCESS(rc))
+        {
+            pMixStream->InOut.pIn = pGstStrm;
+
+            /* Increase the stream's reference count to let others know
+             * we're reyling on it to be around now. */
+            pConn->pfnAddRefIn(pConn, pGstStrm);
+        }
+    }
+    else if (pCfg->enmDir == PDMAUDIODIR_OUT)
+    {
+        PPDMAUDIOGSTSTRMOUT pGstStrm;
+        rc = pConn->pfnCreateOut(pConn, pCfg, &pGstStrm);
+        if (RT_SUCCESS(rc))
+        {
+            pMixStream->InOut.pOut = pGstStrm;
+
+            /* Increase the stream's reference count to let others know
+             * we're reyling on it to be around now. */
+            pConn->pfnAddRefOut(pConn, pGstStrm);
+        }
+    }
+    else
+        rc = VERR_NOT_SUPPORTED;
+
+    if (RT_SUCCESS(rc))
+    {
+        pMixStream->fFlags = fFlags;
+        pMixStream->enmDir = pCfg->enmDir;
+        pMixStream->pConn  = pConn;
+
+        if (ppStream)
+            *ppStream = pMixStream;
+    }
+    else if (pMixStream)
+    {
+        RTStrFree(pMixStream->pszName);
+        pMixStream->pszName = NULL;
+
+        RTMemFree(pMixStream);
+        pMixStream = NULL;
+    }
+
+    return rc;
+}
+
+static void audioMixerStreamDestroyInternal(PAUDMIXSTREAM pStream)
+{
+    if (!pStream)
+        return;
+
+    LogFunc(("%s\n", pStream->pszName));
+
+    if (pStream->pConn) /* Stream has a connector interface present? */
+    {
+        if (   pStream->enmDir == PDMAUDIODIR_IN
+            && pStream->pConn->pfnDestroyIn)
+        {
+            if (pStream->InOut.pIn)
+            {
+                pStream->pConn->pfnReleaseIn(pStream->pConn, pStream->InOut.pIn);
+                pStream->pConn->pfnDestroyIn(pStream->pConn, pStream->InOut.pIn);
+            }
+        }
+        else if (   pStream->enmDir == PDMAUDIODIR_OUT
+                 && pStream->pConn->pfnDestroyOut)
+        {
+            if (pStream->InOut.pOut)
+            {
+                pStream->pConn->pfnReleaseOut(pStream->pConn, pStream->InOut.pOut);
+                pStream->pConn->pfnDestroyOut(pStream->pConn, pStream->InOut.pOut);
+            }
+        }
+        else
+            AssertFailed();
+    }
+
+    audioMixerStreamFree(pStream);
+}
+
+void AudioMixerStreamDestroy(PAUDMIXSTREAM pStream)
+{
+    audioMixerStreamDestroyInternal(pStream);
+}
+
+static void audioMixerStreamFree(PAUDMIXSTREAM pStream)
+{
+    if (pStream)
+    {
+        LogFunc(("%s\n", pStream->pszName));
+
+        if (pStream->pszName)
+        {
+            RTStrFree(pStream->pszName);
+            pStream->pszName = NULL;
+        }
+
+        RTMemFree(pStream);
+        pStream = NULL;
+    }
+}
+
+bool AudioMixerStreamIsActive(PAUDMIXSTREAM pStream)
+{
+    if (!pStream)
+        return false;
+
+    bool fIsValid;
+    switch (pStream->enmDir)
+    {
+        case PDMAUDIODIR_IN:
+        {
+            fIsValid = pStream->pConn->pfnIsActiveIn(pStream->pConn, pStream->InOut.pIn);
+            break;
+        }
+
+        case PDMAUDIODIR_OUT:
+        {
+            fIsValid = pStream->pConn->pfnIsActiveOut(pStream->pConn, pStream->InOut.pOut);
+            break;
+        }
+
+        default:
+            fIsValid = false;
+            AssertMsgFailed(("Not implemented\n"));
+            break;
+    }
+
+    return fIsValid;
+}
+
+bool AudioMixerStreamIsValid(PAUDMIXSTREAM pStream)
+{
+    if (!pStream)
+        return false;
+
+    bool fIsValid;
+    switch (pStream->enmDir)
+    {
+        case PDMAUDIODIR_IN:
+        {
+            fIsValid = pStream->pConn->pfnIsValidIn(pStream->pConn, pStream->InOut.pIn);
+            break;
+        }
+
+        case PDMAUDIODIR_OUT:
+        {
+            fIsValid = pStream->pConn->pfnIsValidOut(pStream->pConn, pStream->InOut.pOut);
+            break;
+        }
+
+        default:
+            fIsValid = false;
+            AssertMsgFailed(("Not implemented\n"));
+            break;
+    }
+
+    return fIsValid;
+}
+

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

@@ -24 +24 @@
 #include <VBox/vmm/pdmaudioifs.h>
 
+/**
+ * Structure for maintaining an audio mixer instance.
+ */
 typedef struct AUDIOMIXER
 {
@@ -40 +43 @@
 } AUDIOMIXER, *PAUDIOMIXER;
 
+/** No flags specified. */
+#define AUDMIXSTREAM_FLAG_NONE                  0
+
+/**
+ * Structure for maintaining an audio mixer stream.
+ */
 typedef struct AUDMIXSTREAM
 {
+    /** List node. */
     RTLISTNODE              Node;
+    /** Name of this stream. */
+    char                   *pszName;
+    /** Stream flags of type AUDMIXSTREAM_FLAG_. */
+    uint32_t                fFlags;
+    /** Pointer to audio connector being used. */
     PPDMIAUDIOCONNECTOR     pConn;
+    /** Audio direction of this stream. */
+    PDMAUDIODIR             enmDir;
+    /** Union of PDM input/output streams for this stream. */
     union
     {
         PPDMAUDIOGSTSTRMIN  pIn;
         PPDMAUDIOGSTSTRMOUT pOut;
-    };
+    } InOut;
 } AUDMIXSTREAM, *PAUDMIXSTREAM;
 
+/**
+ * Audio mixer sink direction.
+ */
 typedef enum AUDMIXSINKDIR
 {
@@ -60 +81 @@
 } AUDMIXSINKDIR;
 
+/**
+ * Audio mixer sink command.
+ */
+typedef enum AUDMIXSINKCMD
+{
+    /** Unknown command, do not use. */
+    AUDMIXSINKCMD_UNKNOWN = 0,
+    /** Enables the sink. */
+    AUDMIXSINKCMD_ENABLE,
+    /** Disables the sink. */
+    AUDMIXSINKCMD_DISABLE,
+    /** Pauses the sink. */
+    AUDMIXSINKCMD_PAUSE,
+    /** Resumes the sink. */
+    AUDMIXSINKCMD_RESUME,
+    /** Hack to blow the type up to 32-bit. */
+    AUDMIXSINKCMD_32BIT_HACK = 0x7fffffff
+} AUDMIXSINKCMD;
+
+/**
+ * Structure for maintaining an audio mixer sink.
+ */
 typedef struct AUDMIXSINK
 {
     RTLISTNODE              Node;
+    /** Pointer to mixer object this sink is bound to. */
+    PAUDIOMIXER             pParent;
     /** Name of this sink. */
     char                   *pszName;
@@ -68 +113 @@
      *  if this sink handles input or output. */
     AUDMIXSINKDIR           enmDir;
-    /** Pointer to mixer object this sink is bound
-     *  to. */
-    PAUDIOMIXER             pParent;
+    /** The sink's PCM format. */
+    PDMPCMPROPS             PCMProps;
     /** Number of streams assigned. */
     uint8_t                 cStreams;
     /** List of assigned streams. */
+    /** @todo Use something faster -- vector maybe? */
     RTLISTANCHOR            lstStreams;
     /** This sink's mixing buffer. */
@@ -82 +127 @@
 } AUDMIXSINK, *PAUDMIXSINK;
 
+/**
+ * Audio mixer operation.
+ */
 typedef enum AUDMIXOP
 {
-    AUDMIXOP_NONE = 0,
+    /** Invalid operation, do not use. */
+    AUDMIXOP_INVALID = 0,
     AUDMIXOP_COPY,
     AUDMIXOP_BLEND,
@@ -91 +140 @@
 } AUDMIXOP;
 
+/** No flags specified. */
+#define AUDMIXSTRMCTL_FLAG_NONE         0
 
-int AudioMixerAddSink(PAUDIOMIXER pMixer, const char *pszName, AUDMIXSINKDIR enmDir, PAUDMIXSINK *ppSink);
-int AudioMixerAddStreamIn(PAUDMIXSINK pSink, PPDMIAUDIOCONNECTOR pConnector, PPDMAUDIOGSTSTRMIN pStream, uint32_t uFlags, PAUDMIXSTREAM *ppStream);
-int AudioMixerAddStreamOut(PAUDMIXSINK pSink, PPDMIAUDIOCONNECTOR pConnector, PPDMAUDIOGSTSTRMOUT pStream, uint32_t uFlags, PAUDMIXSTREAM *ppStream);
-int AudioMixerControlStream(AUDMIXSTREAM pHandle); /** @todo Implement me. */
 int AudioMixerCreate(const char *pszName, uint32_t uFlags, PAUDIOMIXER *ppMixer);
+int AudioMixerCreateSink(PAUDIOMIXER pMixer, const char *pszName, AUDMIXSINKDIR enmDir, PAUDMIXSINK *ppSink);
 void AudioMixerDestroy(PAUDIOMIXER pMixer);
 int AudioMixerGetDeviceFormat(PAUDIOMIXER pMixer, PPDMAUDIOSTREAMCFG pCfg);
-uint32_t AudioMixerGetStreamCount(PAUDIOMIXER pMixer);
 void AudioMixerInvalidate(PAUDIOMIXER pMixer);
-int AudioMixerProcessSinkIn(PAUDMIXSINK pSink, AUDMIXOP enmOp, void *pvBuf, uint32_t cbBuf, uint32_t *pcbProcessed);
-int AudioMixerProcessSinkOut(PAUDMIXSINK pSink, AUDMIXOP enmOp, const void *pvBuf, uint32_t cbBuf, uint32_t *pcbProcessed);
 void AudioMixerRemoveSink(PAUDIOMIXER pMixer, PAUDMIXSINK pSink);
-void AudioMixerRemoveStream(PAUDMIXSINK pSink, PAUDMIXSTREAM pStream);
 int AudioMixerSetDeviceFormat(PAUDIOMIXER pMixer, PPDMAUDIOSTREAMCFG pCfg);
 int AudioMixerSetMasterVolume(PAUDIOMIXER pMixer, PPDMAUDIOVOLUME pVol);
-int AudioMixerSetSinkVolume(PAUDMIXSINK pSink, PPDMAUDIOVOLUME pVol);
 void AudioMixerDebug(PAUDIOMIXER pMixer, PCDBGFINFOHLP pHlp, const char *pszArgs);
+
+int AudioMixerSinkAddStream(PAUDMIXSINK pSink, PAUDMIXSTREAM pStream);
+int AudioMixerSinkCtl(PAUDMIXSINK pSink, AUDMIXSINKCMD enmCmd);
+void AudioMixerSinkDestroy(PAUDMIXSINK pSink);
+PAUDMIXSTREAM AudioMixerSinkGetStream(PAUDMIXSINK pSink, uint8_t uIndex);
+uint8_t AudioMixerSinkGetStreamCount(PAUDMIXSINK pSink);
+int AudioMixerSinkRead(PAUDMIXSINK pSink, AUDMIXOP enmOp, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead);
+void AudioMixerSinkRemoveStream(PAUDMIXSINK pSink, PAUDMIXSTREAM pStream);
+void AudioMixerSinkRemoveAllStreams(PAUDMIXSINK pSink);
+int AudioMixerSinkSetFormat(PAUDMIXSINK pSink, PPDMPCMPROPS pPCMProps);
+int AudioMixerSinkSetVolume(PAUDMIXSINK pSink, PPDMAUDIOVOLUME pVol);
+int AudioMixerSinkWrite(PAUDMIXSINK pSink, AUDMIXOP enmOp, const void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten);
+int AudioMixerSinkUpdate(PAUDMIXSINK pSink);
+
+int AudioMixerStreamCreate(PPDMIAUDIOCONNECTOR pConnector, PPDMAUDIOSTREAMCFG pCfg, uint32_t fFlags, PAUDMIXSTREAM *ppStream);
+int AudioMixerStreamCtl(PAUDMIXSTREAM pStream, PDMAUDIOSTREAMCMD enmCmd, uint32_t fCtl);
+void AudioMixerStreamDestroy(PAUDMIXSTREAM pStream);
+bool AudioMixerStreamIsActive(PAUDMIXSTREAM pStream);
+bool AudioMixerStreamIsValid(PAUDMIXSTREAM pStream);
 
 #endif /* AUDIO_MIXER_H */

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

@@ -52 +52 @@
 #define AC97_SSM_VERSION 1
 
+#define AC97_TIMER_HZ 200
+
 #ifdef VBOX
 # define SOFT_VOLUME /** @todo Get rid of this crap. */
@@ -58 +60 @@
 #endif
 
+/** @todo Use AC97_ prefixes! */
 #define SR_FIFOE RT_BIT(4)          /* rwc, FIFO error. */
 #define SR_BCIS  RT_BIT(3)          /* rwc, Buffer completion interrupt status. */
@@ -113 +116 @@
 /** @name Buffer Descriptor
  * @{ */
-#define BD_IOC RT_BIT(31)          /**< Interrupt on Completion */
-#define BD_BUP RT_BIT(30)          /**< Buffer Underrun Policy */
+#define BD_IOC RT_BIT(31)          /**< Interrupt on Completion. */
+#define BD_BUP RT_BIT(30)          /**< Buffer Underrun Policy. */
+
+#define BD_MAX_LEN_MASK 0xFFFE
 /** @} */
 
-#define EACS_VRA 1
-#define EACS_VRM 8
+/** @name Extended Audio Status and Control Register
+ * @{ */
+#define EACS_VRA 1                 /**< Variable Rate Audio (4.2.1.1). */
+#define EACS_VRM 8                 /**< Variable Rate Mic Audio (4.2.1.1). */
+/** @} */
 
 #define VOL_MASK 0x1f
@@ -193 +201 @@
 
 /** Emits registers for a specific (Native Audio Bus Master BAR) NABMBAR. */
-#define AC97_NABMBAR_REGS(prefix, off) \
-    enum {                             \
-        prefix ## _BDBAR = off,        \
-        prefix ## _CIV   = off + 4,    \
-        prefix ## _LVI   = off + 5,    \
-        prefix ## _SR    = off + 6,    \
-        prefix ## _PICB  = off + 8,    \
-        prefix ## _PIV   = off + 10,   \
-        prefix ## _CR    = off + 11    \
+#define AC97_NABMBAR_REGS(prefix, off)                                    \
+    enum {                                                                \
+        prefix ## _BDBAR = off,      /* Buffer Descriptor Base Address */ \
+        prefix ## _CIV   = off + 4,  /* Current Index Value */            \
+        prefix ## _LVI   = off + 5,  /* Last Valid Index */               \
+        prefix ## _SR    = off + 6,  /* Status Register */                \
+        prefix ## _PICB  = off + 8,  /* Position in Current Buffer */     \
+        prefix ## _PIV   = off + 10, /* Prefetched Index Value */         \
+        prefix ## _CR    = off + 11  /* Control Register */               \
     }
 
@@ -264 +272 @@
 typedef struct AC97STREAMSTATE
 {
-    /* Nothing yet. */
+    /** Temporary FIFO write buffer. */
+    R3PTRTYPE(uint8_t *) au8FIFOW;
+    /** Size of the temporary FIFO write buffer. */
+    uint32_t             cbFIFOW;
+    /** Current write offset in FIFO write buffer. */
+    uint32_t             offFIFOW;
+    uint8_t              Padding;
 } AC97STREAMSTATE, *PAC97STREAMSTATE;
 
@@ -286 +300 @@
 {
     /** PCM line input stream. */
-    R3PTRTYPE(PPDMAUDIOGSTSTRMIN)      pStrmIn;
+    R3PTRTYPE(PPDMAUDIOGSTSTRMIN) pStrmIn;
     /** Mixer handle for line input stream. */
-    R3PTRTYPE(PAUDMIXSTREAM)           phStrmIn;
+    R3PTRTYPE(PAUDMIXSTREAM)      pMixStrm;
 } AC97INPUTSTREAM, *PAC97INPUTSTREAM;
 
@@ -294 +308 @@
 {
     /** PCM output stream. */
-    R3PTRTYPE(PPDMAUDIOGSTSTRMOUT)     pStrmOut;
+    R3PTRTYPE(PPDMAUDIOGSTSTRMOUT) pStrmOut;
     /** Mixer handle for output stream. */
-    R3PTRTYPE(PAUDMIXSTREAM)           phStrmOut;
+    R3PTRTYPE(PAUDMIXSTREAM)       pMixStrm;
 } AC97OUTPUTSTREAM, *PAC97OUTPUTSTREAM;
 
@@ -335 +349 @@
     /** R3 Pointer to the device instance. */
     PPDMDEVINSR3            pDevInsR3;
-    /** Global Control (Bus Master Control Register) */
+    /** Global Control (Bus Master Control Register). */
     uint32_t                glob_cnt;
-    /** Global Status (Bus Master Control Register) */
+    /** Global Status (Bus Master Control Register). */
     uint32_t                glob_sta;
-    /** Codec Access Semaphore Register (Bus Master Control Register) */
+    /** Codec Access Semaphore Register (Bus Master Control Register). */
     uint32_t                cas;
     uint32_t                last_samp;
@@ -379 +393 @@
     /** Base port of the I/O space region. */
     RTIOPORT                IOPortBase[2];
-    /** Pointer to temporary scratch read/write buffer. */
-    R3PTRTYPE(uint8_t *)    pvReadWriteBuf;
-    /** Size of the temporary scratch read/write buffer. */
-    uint32_t                cbReadWriteBuf;
     /** Codec model. */
     uint32_t                uCodecModel;
@@ -393 +403 @@
 #ifndef VBOX_DEVICE_STRUCT_TESTCASE
 
+static void ichac97CloseIn(PAC97STATE pThis, PDMAUDIORECSOURCE enmRecSource);
+static void ichac97CloseOut(PAC97STATE pThis);
 DECLINLINE(PAC97STREAM) ichac97GetStreamFromID(PAC97STATE pThis, uint32_t uID);
+static int ichac97StreamInit(PAC97STATE pThis, PAC97STREAM pStream, uint8_t u8Strm);
 static DECLCALLBACK(void) ichac97Reset(PPDMDEVINS pDevIns);
 #ifndef VBOX_WITH_AUDIO_CALLBACKS
 static DECLCALLBACK(void) ichac97Timer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser);
 #endif
-static int ichac97TransferAudio(PAC97STATE pThis, AC97SOUNDSOURCE enmSrc, uint32_t cbElapsed);
+static int ichac97TransferAudio(PAC97STATE pThis, PAC97STREAM pStream, uint32_t cbElapsed);
 
 static void ichac97WarmReset(PAC97STATE pThis)
@@ -410 +423 @@
 }
 
+DECLINLINE(PAUDMIXSINK) ichac97IndexToSink(PAC97STATE pThis, uint8_t uIndex)
+{
+    AssertPtrReturn(pThis, NULL);
+
+    switch (uIndex)
+    {
+        case PI_INDEX: return pThis->pSinkLineIn; break;
+        case PO_INDEX: return pThis->pSinkOutput; break;
+        case MC_INDEX: return pThis->pSinkMicIn;  break;
+        default:       break;
+    }
+
+    AssertMsgFailed(("Wrong index %RU8\n", uIndex));
+    return NULL;
+}
+
 /** Fetches the buffer descriptor at _CIV. */
-static void ichac97StreamFetchBDLE(PAC97STATE pThis, PAC97STREAM pStrmSt)
+static void ichac97StreamFetchBDLE(PAC97STATE pThis, PAC97STREAM pStream)
 {
     PPDMDEVINS  pDevIns = ICHAC97STATE_2_DEVINS(pThis);
-    PAC97BMREGS pRegs   = &pStrmSt->Regs;
+    PAC97BMREGS pRegs   = &pStream->Regs;
 
     uint32_t u32[2];
@@ -426 +455 @@
     pRegs->bd.ctl_len = RT_H2LE_U32(u32[1]);
 #endif
-    pRegs->picb       = pRegs->bd.ctl_len & 0xffff;
+    pRegs->picb       = pRegs->bd.ctl_len & BD_MAX_LEN_MASK;
     LogFlowFunc(("bd %2d addr=%#x ctl=%#06x len=%#x(%d bytes)\n",
                   pRegs->civ, pRegs->bd.addr, pRegs->bd.ctl_len >> 16,
-                  pRegs->bd.ctl_len & 0xffff, (pRegs->bd.ctl_len & 0xffff) << 1));
+                  pRegs->bd.ctl_len & BD_MAX_LEN_MASK,
+                 (pRegs->bd.ctl_len & BD_MAX_LEN_MASK) << 1)); /** @todo r=andy Assumes 16bit samples. */
 }
 
@@ -435 +465 @@
  * Update the BM status register
  */
-static void ichac97StreamUpdateStatus(PAC97STATE pThis, PAC97STREAM pStrmSt, uint32_t new_sr)
+static void ichac97StreamUpdateStatus(PAC97STATE pThis, PAC97STREAM pStream, uint32_t new_sr)
 {
     PPDMDEVINS  pDevIns = ICHAC97STATE_2_DEVINS(pThis);
-    PAC97BMREGS pRegs   = &pStrmSt->Regs;
-
-    bool fSignal   = false;
-    bool iIrqLevel;
+    PAC97BMREGS pRegs   = &pStream->Regs;
+
+    bool fSignal = false;
+    int  iIRQL;
 
     uint32_t new_mask = new_sr & SR_INT_MASK;
@@ -453 +483 @@
         if (!new_mask)
         {
-            fSignal   = true;
-            iIrqLevel = 0;
+            fSignal = true;
+            iIRQL   = 0;
         }
         else if ((new_mask & SR_LVBCI) && (pRegs->cr & CR_LVBIE))
         {
-            fSignal   = true;
-            iIrqLevel = 1;
+            fSignal = true;
+            iIRQL   = 1;
         }
         else if ((new_mask & SR_BCIS) && (pRegs->cr & CR_IOCE))
         {
-            fSignal   = true;
-            iIrqLevel = 1;
+            fSignal = true;
+            iIRQL   = 1;
         }
     }
@@ -470 +500 @@
     pRegs->sr = new_sr;
 
-    LogFlowFunc(("IOC%d, LVB%d, sr=%#x, fSignal=%RTbool, iIrqLevel=%d\n",
-                 pRegs->sr & SR_BCIS, pRegs->sr & SR_LVBCI, pRegs->sr, fSignal, iIrqLevel));
+    LogFlowFunc(("IOC%d, LVB%d, sr=%#x, fSignal=%RTbool, IRQL=%d\n",
+                 pRegs->sr & SR_BCIS, pRegs->sr & SR_LVBCI, pRegs->sr, fSignal, iIRQL));
 
     if (fSignal)
     {
-        if (iIrqLevel)
-            pThis->glob_sta |=  masks[pStrmSt->u8Strm];
+        if (iIRQL)
+            pThis->glob_sta |=  masks[pStream->u8Strm];
         else
-            pThis->glob_sta &= ~masks[pStrmSt->u8Strm];
-
-        LogFlowFunc(("set irq level=%d\n", !!iIrqLevel));
-        PDMDevHlpPCISetIrq(pDevIns, 0, !!iIrqLevel);
-    }
-}
-
-static int ichac97StreamSetActive(PAC97STATE pThis, PAC97STREAM pStrmSt, bool fActive)
+            pThis->glob_sta &= ~masks[pStream->u8Strm];
+
+        LogFlowFunc(("Setting IRQ level=%d\n", iIRQL));
+        PDMDevHlpPCISetIrq(pDevIns, 0, iIRQL);
+    }
+}
+
+static int ichac97StreamSetActive(PAC97STATE pThis, PAC97STREAM pStream, bool fActive)
 {
     AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
-    AssertPtrReturn(pStrmSt, VERR_INVALID_POINTER);
-
-    LogFlowFunc(("u8Strm=%RU8, fActive=%RTbool\n", pStrmSt->u8Strm, fActive));
-
-    int rc = VINF_SUCCESS;
-
-    PAC97DRIVER pDrv;
-    switch (pStrmSt->u8Strm)
-    {
-        case PI_INDEX:
-            RTListForEach(&pThis->lstDrv, pDrv, AC97DRIVER, Node)
-            {
-                int rc2 = pDrv->pConnector->pfnEnableIn(pDrv->pConnector,
-                                                        pDrv->LineIn.pStrmIn, fActive);
-                if (RT_SUCCESS(rc))
-                    rc = rc2;
-            }
-            break;
-
-        case PO_INDEX:
-            RTListForEach(&pThis->lstDrv, pDrv, AC97DRIVER, Node)
-            {
-                int rc2 = pDrv->pConnector->pfnEnableOut(pDrv->pConnector,
-                                                         pDrv->Out.pStrmOut, fActive);
-                if (RT_SUCCESS(rc))
-                    rc = rc2;
-            }
-            break;
-
-        case MC_INDEX:
-            RTListForEach(&pThis->lstDrv, pDrv, AC97DRIVER, Node)
-            {
-                int rc2 = pDrv->pConnector->pfnEnableIn(pDrv->pConnector,
-                                                        pDrv->MicIn.pStrmIn, fActive);
-                if (RT_SUCCESS(rc))
-                    rc = rc2;
-            }
-            break;
-
-        default:
-            AssertMsgFailed(("Wrong index %RU32\n", pStrmSt->u8Strm));
-            rc = VERR_NOT_SUPPORTED;
-            break;
-    }
-
-    return rc;
-}
-
-static void ichac97StreamResetBMRegs(PAC97STATE pThis, PAC97STREAM pStrmSt)
+    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
+
+    LogFlowFunc(("u8Strm=%RU8, fActive=%RTbool\n", pStream->u8Strm, fActive));
+
+    return AudioMixerSinkCtl(ichac97IndexToSink(pThis, pStream->u8Strm),
+                             fActive ? AUDMIXSINKCMD_ENABLE : AUDMIXSINKCMD_DISABLE);
+}
+
+static void ichac97StreamResetBMRegs(PAC97STATE pThis, PAC97STREAM pStream)
 {
     AssertPtrReturnVoid(pThis);
-    AssertPtrReturnVoid(pStrmSt);
+    AssertPtrReturnVoid(pStream);
 
     LogFlowFuncEnter();
 
-    PAC97BMREGS pRegs = &pStrmSt->Regs;
+    PAC97BMREGS pRegs = &pStream->Regs;
 
     pRegs->bdbar    = 0;
@@ -549 +539 @@
     pRegs->lvi      = 0;
 
-    ichac97StreamUpdateStatus(pThis, pStrmSt, SR_DCH); /** @todo Do we need to do that? */
+    ichac97StreamUpdateStatus(pThis, pStream, SR_DCH); /** @todo Do we need to do that? */
 
     pRegs->picb     = 0;
@@ -556 +546 @@
     pRegs->bd_valid = 0;
 
-    int rc = ichac97StreamSetActive(pThis, pStrmSt, false /* fActive */);
+    int rc = ichac97StreamSetActive(pThis, pStream, false /* fActive */);
     AssertRC(rc);
 
     RT_ZERO(pThis->silence);
+}
+
+static void ichac97StreamDestroy(PAC97STREAM pStream)
+{
+    if (pStream->State.au8FIFOW)
+    {
+        Assert(pStream->State.cbFIFOW);
+        RTMemFree(pStream->State.au8FIFOW);
+        pStream->State.au8FIFOW = NULL;
+    }
+
+    pStream->State.cbFIFOW  = 0;
+    pStream->State.offFIFOW = 0;
+}
+
+static void ichac97StreamsDestroy(PAC97STATE pThis)
+{
+    LogFlowFuncEnter();
+
+    ichac97CloseIn(pThis, PDMAUDIORECSOURCE_LINE);
+    ichac97CloseIn(pThis, PDMAUDIORECSOURCE_MIC);
+    ichac97CloseOut(pThis);
+
+    ichac97StreamDestroy(&pThis->StrmStLineIn);
+    ichac97StreamDestroy(&pThis->StrmStMicIn);
+    ichac97StreamDestroy(&pThis->StrmStOut);
+}
+
+static int ichac97StreamsInit(PAC97STATE pThis)
+{
+    LogFlowFuncEnter();
+
+    ichac97StreamInit(pThis, &pThis->StrmStLineIn, PI_INDEX);
+    ichac97StreamInit(pThis, &pThis->StrmStMicIn,  MC_INDEX);
+    ichac97StreamInit(pThis, &pThis->StrmStOut,    PO_INDEX);
+
+    return VINF_SUCCESS;
 }
 
@@ -589 +616 @@
 }
 
-static DECLCALLBACK(void) ichac97CloseIn(PAC97STATE pThis, PDMAUDIORECSOURCE enmRecSource)
-{
-    NOREF(pThis);
-    NOREF(enmRecSource);
+static void ichac97CloseIn(PAC97STATE pThis, PDMAUDIORECSOURCE enmRecSource)
+{
+    AssertPtrReturnVoid(pThis);
+
     LogFlowFuncEnter();
-}
-
-static DECLCALLBACK(void) ichac97CloseOut(PAC97STATE pThis)
-{
-    NOREF(pThis);
-    LogFlowFuncEnter();
-}
-
-static int ichac97OpenIn(PAC97STATE pThis,
-                         const char *pszName, PDMAUDIORECSOURCE enmRecSource,
-                         PPDMAUDIOSTREAMCFG pCfg)
-{
-    AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
-    AssertPtrReturn(pszName, VERR_INVALID_POINTER);
-    AssertPtrReturn(pCfg,    VERR_INVALID_POINTER);
 
     PAUDMIXSINK pSink;
@@ -621 +633 @@
         default:
             AssertMsgFailed(("Audio source %ld not supported\n", enmRecSource));
-            return VERR_NOT_SUPPORTED;
-    }
-
-    int rc = VINF_SUCCESS;
+            return;
+    }
 
     PAC97DRIVER pDrv;
     RTListForEach(&pThis->lstDrv, pDrv, AC97DRIVER, Node)
     {
-        char *pszDesc;
-        if (RTStrAPrintf(&pszDesc, "[LUN#%RU8] %s", pDrv->uLUN, pszName) <= 0)
-        {
-            rc = VERR_NO_MEMORY;
-            break;
-        }
-
         PAC97INPUTSTREAM pStrmIn;
         if (enmRecSource == PDMAUDIORECSOURCE_MIC) /** @todo Refine this once we have more streams. */
@@ -642 +645 @@
             pStrmIn = &pDrv->LineIn;
 
-        int rc2 = pDrv->pConnector->pfnCreateIn(pDrv->pConnector, pszDesc, pCfg, &pStrmIn->pStrmIn);
-        LogFlowFunc(("LUN#%RU8: Created input \"%s\", with rc=%Rrc\n", pDrv->uLUN, pszDesc, rc2));
-        if (RT_SUCCESS(rc2))
-        {
-            AudioMixerRemoveStream(pSink, pStrmIn->phStrmIn);
-            rc2 = AudioMixerAddStreamIn(pSink,
-                                        pDrv->pConnector, pStrmIn->pStrmIn,
-                                        0 /* uFlags */, &pStrmIn->phStrmIn);
-        }
-
-        if (RT_SUCCESS(rc))
-            rc = rc2;
-
-        RTStrFree(pszDesc);
-    }
-
-    LogFlowFuncLeaveRC(rc);
-    return rc;
-}
-
-static int ichac97OpenOut(PAC97STATE pThis, const char *pszName, PPDMAUDIOSTREAMCFG pCfg)
+        AudioMixerSinkRemoveStream(pSink, pStrmIn->pMixStrm);
+        AudioMixerStreamDestroy(pStrmIn->pMixStrm);
+        pStrmIn->pMixStrm = NULL;
+    }
+}
+
+static void ichac97CloseOut(PAC97STATE pThis)
+{
+    AssertPtrReturnVoid(pThis);
+
+    LogFlowFuncEnter();
+
+    PAC97DRIVER pDrv;
+    RTListForEach(&pThis->lstDrv, pDrv, AC97DRIVER, Node)
+    {
+        AudioMixerSinkRemoveStream(pThis->pSinkOutput, pDrv->Out.pMixStrm);
+        AudioMixerStreamDestroy(pDrv->Out.pMixStrm);
+        pDrv->Out.pMixStrm = NULL;
+    }
+}
+
+static int ichac97OpenIn(PAC97STATE pThis,
+                         const char *pszName, PDMAUDIORECSOURCE enmRecSource, PPDMAUDIOSTREAMCFG pCfg)
 {
     AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
@@ -668 +673 @@
     AssertPtrReturn(pCfg,    VERR_INVALID_POINTER);
 
-    int rc = VINF_SUCCESS;
-    char *pszDesc;
+    PAUDMIXSINK pSink;
+    switch (enmRecSource)
+    {
+        case PDMAUDIORECSOURCE_MIC:
+            pSink = pThis->pSinkMicIn;
+            break;
+        case PDMAUDIORECSOURCE_LINE:
+            pSink = pThis->pSinkLineIn;
+            break;
+        default:
+            AssertMsgFailed(("Audio source %ld not supported\n", enmRecSource));
+            return VERR_NOT_SUPPORTED;
+    }
+
+    /* Update the sink's format. */
+    PDMPCMPROPS PCMProps;
+    int rc = DrvAudioStreamCfgToProps(pCfg, &PCMProps);
+    if (RT_SUCCESS(rc))
+        rc = AudioMixerSinkSetFormat(pSink, &PCMProps);
+
+    if (RT_FAILURE(rc))
+        return rc;
 
     PAC97DRIVER pDrv;
     RTListForEach(&pThis->lstDrv, pDrv, AC97DRIVER, Node)
     {
-        if (RTStrAPrintf(&pszDesc, "[LUN#%RU8] %s (%RU32Hz, %RU8 %s)",
-                         pDrv->uLUN, pszName, pCfg->uHz, pCfg->cChannels, pCfg->cChannels > 1 ? "Channels" : "Channel") <= 0)
-        {
-            rc = VERR_NO_MEMORY;
-            break;
-        }
-
-        int rc2 = pDrv->pConnector->pfnCreateOut(pDrv->pConnector, pszDesc, pCfg, &pDrv->Out.pStrmOut);
-        LogFlowFunc(("LUN#%RU8: Created output \"%s\", with rc=%Rrc\n", pDrv->uLUN, pszDesc, rc2));
+        if (!RTStrPrintf(pCfg->szName, sizeof(pCfg->szName), "[LUN#%RU8] %s", pDrv->uLUN, pszName))
+        {
+            rc = VERR_BUFFER_OVERFLOW;
+            break;
+        }
+
+        PAC97INPUTSTREAM pStrmIn;
+        if (enmRecSource == PDMAUDIORECSOURCE_MIC) /** @todo Refine this once we have more streams. */
+            pStrmIn = &pDrv->MicIn;
+        else
+            pStrmIn = &pDrv->LineIn;
+
+        AudioMixerSinkRemoveStream(pSink, pStrmIn->pMixStrm);
+
+        AudioMixerStreamDestroy(pStrmIn->pMixStrm);
+        pStrmIn->pMixStrm = NULL;
+
+        int rc2 = AudioMixerStreamCreate(pDrv->pConnector, pCfg, 0 /* fFlags */ , &pStrmIn->pMixStrm);
         if (RT_SUCCESS(rc2))
         {
-            AudioMixerRemoveStream(pThis->pSinkOutput, pDrv->Out.phStrmOut);
-            rc2 = AudioMixerAddStreamOut(pThis->pSinkOutput,
-                                         pDrv->pConnector, pDrv->Out.pStrmOut,
-                                         0 /* uFlags */, &pDrv->Out.phStrmOut);
+            rc2 = AudioMixerSinkAddStream(pSink, pStrmIn->pMixStrm);
+            LogFlowFunc(("LUN#%RU8: Created input \"%s\", rc=%Rrc\n", pDrv->uLUN, pCfg->szName, rc2));
         }
 
         if (RT_SUCCESS(rc))
             rc = rc2;
-
-        RTStrFree(pszDesc);
     }
 
@@ -701 +731 @@
 }
 
-static int ichac97StreamInitEx(PAC97STATE pThis, PAC97STREAM pStrmSt, uint8_t u8Strm, PPDMAUDIOSTREAMCFG pCfg)
+static int ichac97OpenOut(PAC97STATE pThis, const char *pszName, PPDMAUDIOSTREAMCFG pCfg)
+{
+    AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
+    AssertPtrReturn(pszName, VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfg,    VERR_INVALID_POINTER);
+
+    /* Update the sink's format. */
+    PDMPCMPROPS PCMProps;
+    int rc = DrvAudioStreamCfgToProps(pCfg, &PCMProps);
+    if (RT_SUCCESS(rc))
+        rc = AudioMixerSinkSetFormat(pThis->pSinkOutput, &PCMProps);
+
+    if (RT_FAILURE(rc))
+        return rc;
+
+    PAC97DRIVER pDrv;
+    RTListForEach(&pThis->lstDrv, pDrv, AC97DRIVER, Node)
+    {
+        if (!RTStrPrintf(pCfg->szName, sizeof(pCfg->szName), "[LUN#%RU8] %s (%RU32Hz, %RU8 %s)",
+                         pDrv->uLUN, pszName, pCfg->uHz, pCfg->cChannels, pCfg->cChannels > 1 ? "Channels" : "Channel"))
+        {
+            rc = VERR_BUFFER_OVERFLOW;
+            break;
+        }
+
+        AudioMixerSinkRemoveStream(pThis->pSinkOutput, pDrv->Out.pMixStrm);
+
+        AudioMixerStreamDestroy(pDrv->Out.pMixStrm);
+        pDrv->Out.pMixStrm = NULL;
+
+        int rc2 = AudioMixerStreamCreate(pDrv->pConnector, pCfg, 0 /* fFlags */, &pDrv->Out.pMixStrm);
+        if (RT_SUCCESS(rc2))
+        {
+            rc2 = AudioMixerSinkAddStream(pThis->pSinkOutput, pDrv->Out.pMixStrm);
+            LogFlowFunc(("LUN#%RU8: Created output \"%s\", rc=%Rrc\n", pDrv->uLUN, pCfg->szName, rc2));
+        }
+
+        if (RT_SUCCESS(rc))
+            rc = rc2;
+    }
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+static int ichac97StreamInitEx(PAC97STATE pThis, PAC97STREAM pStream, uint8_t u8Strm, PPDMAUDIOSTREAMCFG pCfg)
 {
     AssertPtrReturn(pThis,             VERR_INVALID_POINTER);
-    AssertPtrReturn(pStrmSt,           VERR_INVALID_POINTER);
+    AssertPtrReturn(pStream,           VERR_INVALID_POINTER);
     AssertReturn(u8Strm <= LAST_INDEX, VERR_INVALID_PARAMETER);
     AssertPtrReturn(pCfg,              VERR_INVALID_POINTER);
 
-    pStrmSt->u8Strm = u8Strm;
+    pStream->u8Strm = u8Strm;
 
     LogFlowFunc(("u8Strm=%RU8, %RU32Hz, %RU8 %s\n",
-                 pStrmSt->u8Strm, pCfg->uHz, pCfg->cChannels, pCfg->cChannels > 1 ? "Channels" : "Channel"));
+                 pStream->u8Strm, pCfg->uHz, pCfg->cChannels, pCfg->cChannels > 1 ? "Channels" : "Channel"));
 
     int rc;
-    switch (pStrmSt->u8Strm)
+    switch (pStream->u8Strm)
     {
         case PI_INDEX:
@@ -733 +808 @@
     }
 
+    if (RT_FAILURE(rc))
+        LogRel2(("AC97: Error opening stream #%RU8, rc=%Rrc\n", pStream->u8Strm, rc));
+
     LogFlowFuncLeaveRC(rc);
     return rc;
 }
 
-static int ichac97StreamInit(PAC97STATE pThis, PAC97STREAM pStrmSt, uint8_t u8Strm)
+static int ichac97StreamInit(PAC97STATE pThis, PAC97STREAM pStream, uint8_t u8Strm)
 {
     int rc = VINF_SUCCESS;
@@ -769 +847 @@
     }
 
-    if (RT_FAILURE(rc))
-        return rc;
-
-    if (streamCfg.uHz)
-    {
-        streamCfg.cChannels     = 2;
-        streamCfg.enmFormat     = AUD_FMT_S16;
-        streamCfg.enmEndianness = PDMAUDIOHOSTENDIANNESS;
-
-        return ichac97StreamInitEx(pThis, pStrmSt, u8Strm, &streamCfg);
-    }
-
-    /* If no frequency is given, disable the stream. */
-    return ichac97StreamSetActive(pThis, pStrmSt, false /* fActive */);
-}
-
-static int ichac97StreamReInit(PAC97STATE pThis, PAC97STREAM pStrmSt)
-{
-    return ichac97StreamInit(pThis, pStrmSt, pStrmSt->u8Strm);
-}
-
-static void ichac97StreamReset(PAC97STATE pThis, PAC97STREAM pStrmSt)
+    if (RT_SUCCESS(rc))
+    {
+        pStream->State.cbFIFOW  = 256; /** @todo Make FIFOW size configurable. */
+        pStream->State.offFIFOW = 0;
+        pStream->State.au8FIFOW = (uint8_t *)RTMemAllocZ(pStream->State.cbFIFOW);
+        if (!pStream->State.au8FIFOW)
+            rc = VERR_NO_MEMORY;
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        if (streamCfg.uHz)
+        {
+            streamCfg.cChannels     = 2; /** @todo Handle mono channels? */
+            streamCfg.enmFormat     = PDMAUDIOFMT_S16;
+            streamCfg.enmEndianness = PDMAUDIOHOSTENDIANNESS;
+
+            rc = ichac97StreamInitEx(pThis, pStream, u8Strm, &streamCfg);
+        }
+        else
+        {
+            /* If no frequency is given, disable the stream. */
+            rc = ichac97StreamSetActive(pThis, pStream, false /* fActive */);
+        }
+    }
+
+    LogFlowFunc(("Index=%RU8, rc=%Rrc\n", u8Strm, rc));
+    return rc;
+}
+
+static int ichac97StreamReInit(PAC97STATE pThis, PAC97STREAM pStrm)
+{
+    return ichac97StreamInit(pThis, pStrm, pStrm->u8Strm);
+}
+
+static void ichac97StreamReset(PAC97STATE pThis, PAC97STREAM pStrm)
 {
     AssertPtrReturnVoid(pThis);
-    AssertPtrReturnVoid(pStrmSt);
-
-    LogFlowFunc(("uStrm=%RU8\n", pStrmSt->u8Strm));
+    AssertPtrReturnVoid(pStrm);
+
+    if (pStrm->State.au8FIFOW)
+    {
+        Assert(pStrm->State.cbFIFOW);
+        RT_BZERO(pStrm->State.au8FIFOW, pStrm->State.cbFIFOW);
+    }
+
+    pStrm->State.offFIFOW = 0;
+
+    LogFlowFunc(("uStrm=%RU8\n", pStrm->u8Strm));
 }
 
@@ -832 +932 @@
 
             case PDMAUDIOMIXERCTL_FRONT:
-                rc = AudioMixerSetSinkVolume(pThis->pSinkOutput, &vol);
+                rc = AudioMixerSinkSetVolume(pThis->pSinkOutput, &vol);
                 break;
 
             case PDMAUDIOMIXERCTL_MIC_IN:
-                rc = AudioMixerSetSinkVolume(pThis->pSinkMicIn, &vol);
+                rc = AudioMixerSinkSetVolume(pThis->pSinkMicIn, &vol);
                 break;
 
             case PDMAUDIOMIXERCTL_LINE_IN:
-                rc = AudioMixerSetSinkVolume(pThis->pSinkLineIn, &vol);
+                rc = AudioMixerSinkSetVolume(pThis->pSinkLineIn, &vol);
                 break;
 
@@ -991 +1091 @@
  * @return  IPRT status code.
  * @param   pThis
- * @param   pStrmSt
+ * @param   pStream
  * @param   cbMax
  * @param   pcbWritten
  */
-static int ichac97WriteAudio(PAC97STATE pThis, PAC97STREAM pStrmSt, uint32_t cbMax, uint32_t *pcbWritten)
-{
-    AssertPtrReturn(pThis,      VERR_INVALID_POINTER);
-    AssertPtrReturn(pStrmSt,    VERR_INVALID_POINTER);
-    AssertReturn(cbMax,         VERR_INVALID_PARAMETER);
+static int ichac97WriteAudio(PAC97STATE pThis, PAC97STREAM pStream, uint32_t cbMax, uint32_t *pcbWritten)
+{
+    AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
+    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
+    AssertReturn(cbMax,      VERR_INVALID_PARAMETER);
     /* pcbWritten is optional. */
 
     PPDMDEVINS  pDevIns = ICHAC97STATE_2_DEVINS(pThis);
-    PAC97BMREGS pRegs   = &pStrmSt->Regs;
+    PAC97BMREGS pRegs   = &pStream->Regs;
 
     uint32_t    addr           = pRegs->bd.addr;
     uint32_t    cbWrittenTotal = 0;
-    uint32_t    cbToRead;
-
-    uint32_t cbToWrite = RT_MIN((uint32_t)(pRegs->picb << 1), cbMax);
+
+    Log3Func(("PICB=%RU16, cbMax=%RU32\n", pRegs->picb, cbMax));
+
+    uint32_t cbToWrite = RT_MIN((uint32_t)(pRegs->picb << 1), cbMax); /** @todo r=andy Assumes 16bit sample size. */
     if (!cbToWrite)
     {
@@ -1021 +1122 @@
     LogFlowFunc(("pReg=%p, cbMax=%RU32, cbToWrite=%RU32\n", pRegs, cbMax, cbToWrite));
 
+    Assert(pStream->State.offFIFOW <= pStream->State.cbFIFOW);
+    uint32_t  cbFIFOW  = pStream->State.cbFIFOW - pStream->State.offFIFOW;
+    uint8_t  *pu8FIFOW = &pStream->State.au8FIFOW[pStream->State.offFIFOW];
+
+    uint32_t cbToRead;
     while (cbToWrite)
     {
-        cbToRead = RT_MIN(cbToWrite, pThis->cbReadWriteBuf);
-        PDMDevHlpPhysRead(pDevIns, addr, pThis->pvReadWriteBuf, cbToRead); /** @todo Check rc? */
-
+        cbToRead = RT_MIN(cbToWrite, cbFIFOW);
+        PDMDevHlpPhysRead(pDevIns, addr, pu8FIFOW, cbToRead); /** @todo r=andy Check rc? */
+
+        /*
+         * Write data to the mixer sink.
+         */
         uint32_t cbWritten;
-
-        /* Just multiplex the output to the connected backends.
-         * No need to utilize the virtual mixer here (yet). */
-        PAC97DRIVER pDrv;
-        RTListForEach(&pThis->lstDrv, pDrv, AC97DRIVER, Node)
-        {
-            int rc2 = pDrv->pConnector->pfnWrite(pDrv->pConnector, pDrv->Out.pStrmOut,
-                                                 pThis->pvReadWriteBuf, cbToRead, &cbWritten);
-            LogFlowFunc(("\tLUN#%RU8: rc=%Rrc, cbWritten=%RU32\n", pDrv->uLUN, rc2, cbWritten));
-        }
-
-        LogFlowFunc(("\tcbToRead=%RU32, cbToWrite=%RU32, cbLeft=%RU32\n",
-                     cbToRead, cbToWrite, cbToWrite - cbWrittenTotal));
-
+        rc = AudioMixerSinkWrite(pThis->pSinkOutput, AUDMIXOP_COPY, pu8FIFOW, cbToRead, &cbWritten);
+
+        LogFlowFunc(("\tcbToRead=%RU32, cbToWrite=%RU32, cbWritten=%RU32, cbLeft=%RU32, rc=%Rrc\n",
+                     cbToRead, cbToWrite, cbWritten, cbToWrite - cbWrittenTotal, rc));
+
+        if (RT_FAILURE(rc))
+            break;
+
+        /* Advance. */
         Assert(cbToWrite >= cbToRead);
         cbToWrite      -= cbToRead;
@@ -1047 +1151 @@
     }
 
+    /* Set new buffer descriptor address. */
     pRegs->bd.addr = addr;
 
@@ -1059 +1164 @@
             }
             else
-                pThis->last_samp = *(uint32_t *)&pThis->pvReadWriteBuf[cbToRead - 4];
+                pThis->last_samp = *(uint32_t *)&pStream->State.au8FIFOW[pStream->State.offFIFOW + cbToRead - 4];
         }
 
@@ -1122 +1227 @@
 }
 
-static int ichac97ReadAudio(PAC97STATE pThis, PAC97STREAM pStrmSt, uint32_t cbMax, uint32_t *pcbRead)
+static int ichac97ReadAudio(PAC97STATE pThis, PAC97STREAM pStream, uint32_t cbMax, uint32_t *pcbRead)
 {
     AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
-    AssertPtrReturn(pStrmSt, VERR_INVALID_POINTER);
+    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
     AssertReturn(cbMax,      VERR_INVALID_PARAMETER);
     /* pcbRead is optional. */
 
     PPDMDEVINS pDevIns = ICHAC97STATE_2_DEVINS(pThis);
-    PAC97BMREGS pRegs  = &pStrmSt->Regs;
+    PAC97BMREGS pRegs  = &pStream->Regs;
 
     /* Select audio sink to process. */
-    AssertMsg(pStrmSt->u8Strm != PO_INDEX, ("Can't read from output\n"));
-    PAUDMIXSINK pSink = pStrmSt->u8Strm == MC_INDEX ? pThis->pSinkMicIn : pThis->pSinkLineIn;
+    AssertMsg(pStream->u8Strm != PO_INDEX, ("Can't read from output\n"));
+    PAUDMIXSINK pSink = pStream->u8Strm == MC_INDEX ? pThis->pSinkMicIn : pThis->pSinkLineIn;
     AssertPtr(pSink);
 
     uint32_t cbRead   = 0;
-
-    uint32_t cbMixBuf = cbMax;
-    uint32_t cbToRead = RT_MIN((uint32_t)(pRegs->picb << 1), cbMixBuf);
+    uint32_t cbToRead = RT_MIN((uint32_t)(pRegs->picb << 1),
+                               RT_MIN(pStream->State.cbFIFOW, cbMax)); /** @todo r=andy Assumes 16bit samples. */
 
     if (!cbToRead)
@@ -1151 +1255 @@
     int rc;
 
-    uint8_t *pvMixBuf = (uint8_t *)RTMemAlloc(cbMixBuf);
-    if (pvMixBuf)
-    {
-        rc = AudioMixerProcessSinkIn(pSink, AUDMIXOP_BLEND, pvMixBuf, cbToRead, &cbRead);
-        if (   RT_SUCCESS(rc)
-            && cbRead)
-        {
-            PDMDevHlpPCIPhysWrite(pDevIns, pRegs->bd.addr, pvMixBuf, cbRead);
-            pRegs->bd.addr += cbRead;
-        }
-
-        RTMemFree(pvMixBuf);
-    }
-    else
-        rc = VERR_NO_MEMORY;
+    rc = AudioMixerSinkRead(pSink, AUDMIXOP_BLEND, &pStream->State.au8FIFOW[pStream->State.offFIFOW], cbToRead, &cbRead);
+    if (   RT_SUCCESS(rc)
+        && cbRead)
+    {
+        PDMDevHlpPCIPhysWrite(pDevIns, pRegs->bd.addr, &pStream->State.au8FIFOW[pStream->State.offFIFOW], cbRead);
+        pRegs->bd.addr += cbRead;
+    }
 
     if (RT_SUCCESS(rc))
     {
+        if (!cbRead)
+            rc = VINF_EOF;
+
         if (pcbRead)
             *pcbRead = cbRead;
@@ -1189 +1288 @@
     uint32_t cbOutMin = UINT32_MAX;
 
-    PAC97DRIVER pDrv;
+//    PAC97DRIVER pDrv;
 
     uint64_t cTicksNow     = TMTimerGet(pTimer);
@@ -1197 +1296 @@
     pThis->uTimerTS = cTicksNow;
 
+#if 0
     /*
      * Calculate the mixer's (fixed) sampling rate.
@@ -1277 +1377 @@
     if (cbInMax)
         ichac97TransferAudio(pThis, PI_INDEX, cbInMax); /** @todo Add rc! */
+#else
+    AudioMixerSinkUpdate(pThis->pSinkLineIn);
+    AudioMixerSinkUpdate(pThis->pSinkMicIn);
+    AudioMixerSinkUpdate(pThis->pSinkOutput);
+
+    uint32_t cMixerSamplesMin  = (int)((2 * cTicksElapsed *   pThis->pSinkOutput->PCMProps.uHz + cTicksPerSec) / cTicksPerSec / 2);
+    uint32_t cbMixerSamplesMin = cMixerSamplesMin <<  pThis->pSinkOutput->PCMProps.cShift;
+
+    Log3Func(("cMixerSamplesMin=%RU32, cbMixerSamplesMin=%RU32, mixerHz=%RU32\n",
+              cMixerSamplesMin, cbMixerSamplesMin,  pThis->pSinkOutput->PCMProps.uHz));
+
+    //uint32_t cbSamplesElapsed = 5120; //((48000 / AC97_TIMER_HZ) * 20) / 8;
+
+    uint32_t cMixerSamplesMinIn  = (int)((2 * cTicksElapsed *   pThis->pSinkLineIn->PCMProps.uHz + cTicksPerSec) / cTicksPerSec / 2);
+    uint32_t cbMixerSamplesMinIn = cMixerSamplesMinIn <<  pThis->pSinkLineIn->PCMProps.cShift;
+
+    ichac97TransferAudio(pThis, &pThis->StrmStLineIn, cMixerSamplesMinIn); /** @todo Add rc! */
+    ichac97TransferAudio(pThis, &pThis->StrmStOut,    cbMixerSamplesMin);  /** @todo Add rc! */
+#endif
 
     /* Kick the timer again. */
@@ -1288 +1407 @@
 #endif
 
-static int ichac97TransferAudio(PAC97STATE pThis, AC97SOUNDSOURCE enmSrc, uint32_t cbElapsed)
-{
-    LogFlowFunc(("pThis=%p, enmSrc=%RU32, cbElapsed=%RU32\n", pThis, enmSrc, cbElapsed));
-
-    PAC97STREAM pStrmSt;
-    switch (enmSrc)
-    {
-        case PI_INDEX: pStrmSt = &pThis->StrmStLineIn; break;
-        case MC_INDEX: pStrmSt = &pThis->StrmStMicIn;  break;
-        case PO_INDEX: pStrmSt = &pThis->StrmStOut;    break;
-        default:
-        {
-            AssertMsgFailed(("Unknown source index %ld\n", enmSrc));
-            return VERR_NOT_SUPPORTED;
-        }
-    }
-
-    PAC97BMREGS pRegs = &pStrmSt->Regs;
+static int ichac97TransferAudio(PAC97STATE pThis, PAC97STREAM pStream, uint32_t cbElapsed)
+{
+    Log3Func(("SD=%RU8, cbElapsed=%RU32\n", pStream->u8Strm , cbElapsed));
+
+    PAC97BMREGS pRegs = &pStream->Regs;
 
     if (pRegs->sr & SR_DCH) /* Controller halted? */
@@ -1311 +1417 @@
         if (pRegs->cr & CR_RPBM)
         {
-            switch (enmSrc)
+            switch (pStream->u8Strm)
             {
                 case PO_INDEX:
@@ -1325 +1431 @@
     }
 
+    /* BCIS flag still set? Skip iteration. */
+    if (pRegs->sr & SR_BCIS)
+        return VINF_SUCCESS;
+
     int rc = VINF_SUCCESS;
     uint32_t cbWrittenTotal = 0;
 
-    while (cbElapsed >> 1)
+    while (cbElapsed >> 1) /** @todo r=andy This assumes (hardcodes) 16bit sample size.*/
     {
         if (!pRegs->bd_valid)
         {
             LogFlowFunc(("Invalid buffer descriptor, fetching next one ...\n"));
-            ichac97StreamFetchBDLE(pThis, pStrmSt);
+            ichac97StreamFetchBDLE(pThis, pStream);
         }
 
@@ -1351 +1461 @@
             pRegs->sr &= ~SR_CELV;
             pRegs->civ = pRegs->piv;
-            pRegs->piv = (pRegs->piv + 1) % 32;
-
-            ichac97StreamFetchBDLE(pThis, pStrmSt);
+            pRegs->piv = (pRegs->piv + 1) % 32; /** @todo r=andy Define for max BDLEs? */
+
+            ichac97StreamFetchBDLE(pThis, pStream);
             continue;
         }
 
         uint32_t cbTransferred;
-        switch (enmSrc)
+        switch (pStream->u8Strm)
         {
             case PO_INDEX:
             {
-                rc = ichac97WriteAudio(pThis, pStrmSt, cbElapsed, &cbTransferred);
+                rc = ichac97WriteAudio(pThis, pStream, cbElapsed, &cbTransferred);
                 if (   RT_SUCCESS(rc)
                     && cbTransferred)
@@ -1370 +1480 @@
                     cbElapsed      -= cbTransferred;
                     Assert((cbTransferred & 1) == 0);    /* Else the following shift won't work */
-                    pRegs->picb    -= (cbTransferred >> 1);
+                    pRegs->picb    -= (cbTransferred >> 1); /** @todo r=andy Assumes 16bit samples. */
                 }
                 break;
@@ -1378 +1488 @@
             case MC_INDEX:
             {
-                rc = ichac97ReadAudio(pThis, pStrmSt, cbElapsed, &cbTransferred);
+                rc = ichac97ReadAudio(pThis, pStream, cbElapsed, &cbTransferred);
                 if (   RT_SUCCESS(rc)
                     && cbTransferred)
                 {
                     Assert(cbElapsed >= cbTransferred);
-                    cbElapsed  -= cbTransferred;
+                    cbElapsed   -= cbTransferred;
                     Assert((cbTransferred & 1) == 0);    /* Else the following shift won't work */
-                    pRegs->picb -= (cbTransferred >> 1);
+                    pRegs->picb -= (cbTransferred >> 1); /** @todo r=andy Assumes 16bit samples. */
                 }
                 break;
@@ -1391 +1501 @@
 
             default:
-                AssertMsgFailed(("Source %RU32 not supported\n", enmSrc));
+                AssertMsgFailed(("Stream #%RU8 not supported\n", pStream->u8Strm));
                 rc = VERR_NOT_SUPPORTED;
                 break;
         }
 
-        LogFlowFunc(("pReg->picb=%#x, cbWrittenTotal=%RU32\n", pRegs->picb, cbWrittenTotal));
+        Log3Func(("PICB=%RU16 (%#x), cbTransferred=%RU32 (%zu samples), cbWrittenTotal=%RU32\n",
+                  pRegs->picb, pRegs->picb, cbTransferred, (cbTransferred >> 1), cbWrittenTotal));
 
         if (!pRegs->picb)
@@ -1409 +1520 @@
             if (pRegs->civ == pRegs->lvi)
             {
-                LogFlowFunc(("Underrun civ (%RU8) == lvi (%RU8)\n", pRegs->civ, pRegs->lvi));
+                Log3Func(("Underrun civ (%RU8) == lvi (%RU8)\n", pRegs->civ, pRegs->lvi));
                 new_sr |= SR_LVBCI | SR_DCH | SR_CELV;
                 pThis->bup_flag = (pRegs->bd.ctl_len & BD_BUP) ? BUP_LAST : 0;
@@ -1418 +1529 @@
             {
                 pRegs->civ = pRegs->piv;
-                pRegs->piv = (pRegs->piv + 1) % 32;
-                ichac97StreamFetchBDLE(pThis, pStrmSt);
+                pRegs->piv = (pRegs->piv + 1) % 32; /** @todo r=andy Define for max BDLEs? */
+                ichac97StreamFetchBDLE(pThis, pStream);
             }
 
-            ichac97StreamUpdateStatus(pThis, pStrmSt, new_sr);
+            ichac97StreamUpdateStatus(pThis, pStream, new_sr);
         }
 
@@ -1447 +1558 @@
     const uint32_t uPortIdx = Port - pThis->IOPortBase[1];
 
-    PAC97STREAM pStrmSt     = ichac97GetStreamFromID(pThis, AC97_PORT2IDX(uPortIdx));
-    PAC97BMREGS pRegs       = pStrmSt ? &pStrmSt->Regs : NULL;
+    PAC97STREAM pStream = ichac97GetStreamFromID(pThis, AC97_PORT2IDX(uPortIdx));
+    PAC97BMREGS pRegs   = pStream ? &pStream->Regs : NULL;
 
     switch (cbVal)
@@ -1519 +1630 @@
                 case PO_PICB:
                 case MC_PICB:
-                    /* Position in Current Buffer Register */
+                    /* Position in Current Buffer */
                     *pu32Val = pRegs->picb;
                     LogFlowFunc(("PICB[%d] -> %#x\n", AC97_PORT2IDX(uPortIdx), *pu32Val));
@@ -1597 +1708 @@
     const uint32_t uPortIdx = Port - pThis->IOPortBase[1];
 
-    PAC97STREAM pStrmSt     = ichac97GetStreamFromID(pThis, AC97_PORT2IDX(uPortIdx));
-    PAC97BMREGS pRegs       = pStrmSt ? &pStrmSt->Regs : NULL;
+    PAC97STREAM pStream = ichac97GetStreamFromID(pThis, AC97_PORT2IDX(uPortIdx));
+    PAC97BMREGS pRegs   = pStream ? &pStream->Regs : NULL;
 
     switch (cbVal)
@@ -1616 +1727 @@
                         pRegs->piv = (pRegs->piv + 1) % 32;
 
-                        ichac97StreamFetchBDLE(pThis, pStrmSt);
+                        ichac97StreamFetchBDLE(pThis, pStream);
                     }
                     pRegs->lvi = u32Val % 32;
@@ -1628 +1739 @@
                     if (u32Val & CR_RR) /* Busmaster reset */
                     {
-                        ichac97StreamResetBMRegs(pThis, pStrmSt);
+                        ichac97StreamResetBMRegs(pThis, pStream);
                     }
                     else
@@ -1635 +1746 @@
                         if (!(pRegs->cr & CR_RPBM))
                         {
-                            ichac97StreamSetActive(pThis, pStrmSt, false /* fActive */);
+                            ichac97StreamSetActive(pThis, pStream, false /* fActive */);
                             pRegs->sr |= SR_DCH;
                         }
@@ -1643 +1754 @@
                             pRegs->piv = (pRegs->piv + 1) % 32;
 
-                            ichac97StreamFetchBDLE(pThis, pStrmSt);
+                            ichac97StreamFetchBDLE(pThis, pStream);
 
                             pRegs->sr &= ~SR_DCH;
-                            ichac97StreamSetActive(pThis, pStrmSt, true /* fActive */);
+                            ichac97StreamSetActive(pThis, pStream, true /* fActive */);
                         }
                     }
@@ -1657 +1768 @@
                     /* Status Register */
                     pRegs->sr |= u32Val & ~(SR_RO_MASK | SR_WCLEAR_MASK);
-                    ichac97StreamUpdateStatus(pThis, pStrmSt, pRegs->sr & ~(u32Val & SR_WCLEAR_MASK));
+                    ichac97StreamUpdateStatus(pThis, pStream, pRegs->sr & ~(u32Val & SR_WCLEAR_MASK));
                     LogFlowFunc(("SR[%d] <- %#x (sr %#x)\n", AC97_PORT2IDX(uPortIdx), u32Val, pRegs->sr));
                     break;
@@ -1676 +1787 @@
                     /* Status Register */
                     pRegs->sr |= u32Val & ~(SR_RO_MASK | SR_WCLEAR_MASK);
-                    ichac97StreamUpdateStatus(pThis, pStrmSt, pRegs->sr & ~(u32Val & SR_WCLEAR_MASK));
+                    ichac97StreamUpdateStatus(pThis, pStream, pRegs->sr & ~(u32Val & SR_WCLEAR_MASK));
                     LogFlowFunc(("SR[%d] <- %#x (sr %#x)\n", AC97_PORT2IDX(uPortIdx), u32Val, pRegs->sr));
                     break;
@@ -1857 +1968 @@
                     }
                     else
-                        LogFlowFunc(("Attempt to set front DAC rate to %RU32, but VRA is not set\n", u32Val));
+                        AssertMsgFailed(("Attempt to set front DAC rate to %RU32, but VRA is not set\n", u32Val));
                     break;
                 case AC97_MIC_ADC_Rate:
@@ -1867 +1978 @@
                     }
                     else
-                        LogFlowFunc(("Attempt to set MIC ADC rate to %RU32, but VRM is not set\n", u32Val));
+                        AssertMsgFailed(("Attempt to set MIC ADC rate to %RU32, but VRM is not set\n", u32Val));
                     break;
                 case AC97_PCM_LR_ADC_Rate:
@@ -1877 +1988 @@
                     }
                     else
-                        LogFlowFunc(("Attempt to set LR ADC rate to %RU32, but VRA is not set\n", u32Val));
+                        AssertMsgFailed(("Attempt to set LR ADC rate to %RU32, but VRA is not set\n", u32Val));
                     break;
                 default:
@@ -1949 +2060 @@
 
 #ifdef IN_RING3
-static int ichac97SaveStream(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, PAC97STREAM pStrmSt)
-{
-    PAC97BMREGS pRegs = &pStrmSt->Regs;
+static int ichac97SaveStream(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, PAC97STREAM pStream)
+{
+    PAC97BMREGS pRegs = &pStream->Regs;
 
     SSMR3PutU32(pSSM, pRegs->bdbar);
@@ -2006 +2117 @@
 }
 
-static int ichac97LoadStream(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, PAC97STREAM pStrmSt)
-{
-    PAC97BMREGS pRegs = &pStrmSt->Regs;
+static int ichac97LoadStream(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, PAC97STREAM pStream)
+{
+    PAC97BMREGS pRegs = &pStream->Regs;
 
     SSMR3GetU32(pSSM, &pRegs->bdbar);
@@ -2064 +2175 @@
                              ichac97MixerGet(pThis, AC97_Headphone_Volume_Mute));
 
-    int rc;
-    rc = ichac97StreamInit(pThis, &pThis->StrmStLineIn, PI_INDEX);
-    AssertRC(rc);
-    rc = ichac97StreamInit(pThis, &pThis->StrmStMicIn,  MC_INDEX);
-    AssertRC(rc);
-    rc = ichac97StreamInit(pThis, &pThis->StrmStOut,    PO_INDEX);
+    int rc = ichac97StreamsInit(pThis);
     AssertRC(rc);
 
@@ -2101 +2207 @@
 
 /**
+ * Powers off the device.
+ *
+ * @param   pDevIns             Device instance to power off.
+ */
+static DECLCALLBACK(void) ichac97PowerOff(PPDMDEVINS pDevIns)
+{
+    PAC97STATE pThis = PDMINS_2_DATA(pDevIns, PAC97STATE);
+
+    LogRel2(("AC97: Powering off ...\n"));
+
+    /**
+     * Note: Destroy the mixer while powering off and *not* in ichac97Destruct,
+     *       giving the mixer the chance to release any references held to
+     *       PDM audio streams it maintains.
+     */
+    if (pThis->pMixer)
+    {
+        AudioMixerDestroy(pThis->pMixer);
+        pThis->pMixer = NULL;
+    }
+}
+
+
+/**
  * @interface_method_impl{PDMDEVREG,pfnReset}
  *
@@ -2129 +2259 @@
      * Stop any audio currently playing.
      */
-    PAC97DRIVER pDrv;
-    RTListForEach(&pThis->lstDrv, pDrv, AC97DRIVER, Node)
-    {
-        pDrv->pConnector->pfnEnableIn(pDrv->pConnector,  pDrv->LineIn.pStrmIn, false /* Disable */);
-        /* Ignore rc. */
-        pDrv->pConnector->pfnEnableIn(pDrv->pConnector,  pDrv->MicIn.pStrmIn,  false /* Disable */);
-        /* Ditto. */
-        pDrv->pConnector->pfnEnableOut(pDrv->pConnector, pDrv->Out.pStrmOut,   false /* Disable */);
-        /* Ditto. */
-    }
+    /*
+     * Stop any audio currently playing and/or recording.
+     */
+    AudioMixerSinkCtl(pThis->pSinkOutput, AUDMIXSINKCMD_DISABLE);
+    AudioMixerSinkCtl(pThis->pSinkMicIn,  AUDMIXSINKCMD_DISABLE);
+    AudioMixerSinkCtl(pThis->pSinkLineIn, AUDMIXSINKCMD_DISABLE);
 
     /*
@@ -2169 +2295 @@
     }
 
-    if (pThis->pMixer)
-    {
-        AudioMixerDestroy(pThis->pMixer);
-        pThis->pMixer = NULL;
-    }
-
-    if (pThis->pvReadWriteBuf)
-    {
-        RTMemFree(pThis->pvReadWriteBuf);
-        pThis->pvReadWriteBuf = NULL;
-        pThis->cbReadWriteBuf = 0;
-    }
+    ichac97StreamsDestroy(pThis);
 
     LogFlowFuncLeave();
@@ -2319 +2434 @@
 #define RC_CHECK() if (RT_FAILURE(rc)) { AssertReleaseRC(rc); break; }
 
-    int rc = VINF_SUCCESS;
+    int rc;
     do
     {
@@ -2379 +2494 @@
 #ifndef VBOX_WITH_AUDIO_CALLBACKS
     uint16_t uTimerHz;
-    rc = CFGMR3QueryU16Def(pCfg, "TimerHz", &uTimerHz, 200 /* Hz */);
+    rc = CFGMR3QueryU16Def(pCfg, "TimerHz", &uTimerHz, AC97_TIMER_HZ /* Default value, if not set. */);
     if (RT_FAILURE(rc))
         return PDMDEV_SET_ERROR(pDevIns, rc,
@@ -2500 +2615 @@
             streamCfg.uHz           = 44100;
             streamCfg.cChannels     = 2;
-            streamCfg.enmFormat     = AUD_FMT_S16;
+            streamCfg.enmFormat     = PDMAUDIOFMT_S16;
             streamCfg.enmEndianness = PDMAUDIOHOSTENDIANNESS;
 
@@ -2507 +2622 @@
 
             /* Add all required audio sinks. */
-            rc = AudioMixerAddSink(pThis->pMixer, "[Playback] PCM Output", AUDMIXSINKDIR_OUTPUT, &pThis->pSinkOutput);
-            AssertRC(rc);
-
-            rc = AudioMixerAddSink(pThis->pMixer, "[Recording] Line In", AUDMIXSINKDIR_INPUT, &pThis->pSinkLineIn);
-            AssertRC(rc);
-
-            rc = AudioMixerAddSink(pThis->pMixer, "[Recording] Microphone In", AUDMIXSINKDIR_INPUT, &pThis->pSinkMicIn);
-            AssertRC(rc);
+            int rc2 = AudioMixerCreateSink(pThis->pMixer, "[Playback] PCM Output", AUDMIXSINKDIR_OUTPUT, &pThis->pSinkOutput);
+            AssertRC(rc2);
+
+            rc2 = AudioMixerCreateSink(pThis->pMixer, "[Recording] Line In", AUDMIXSINKDIR_INPUT, &pThis->pSinkLineIn);
+            AssertRC(rc2);
+
+            rc2 = AudioMixerCreateSink(pThis->pMixer, "[Recording] Microphone In", AUDMIXSINKDIR_INPUT, &pThis->pSinkMicIn);
+            AssertRC(rc2);
         }
     }
@@ -2522 +2637 @@
     if (RT_SUCCESS(rc))
     {
-        rc = ichac97StreamInit(pThis, &pThis->StrmStLineIn, PI_INDEX);
-        if (RT_FAILURE(rc))
-            return rc;
-        rc = ichac97StreamInit(pThis, &pThis->StrmStMicIn,  MC_INDEX);
-        if (RT_FAILURE(rc))
-            return rc;
-        rc = ichac97StreamInit(pThis, &pThis->StrmStOut,    PO_INDEX);
-        if (RT_FAILURE(rc))
-            return rc;
+        ichac97StreamsInit(pThis);
 
         PAC97DRIVER pDrv;
@@ -2545 +2652 @@
             AssertPtr(pCon);
 
-            bool fValidLineIn = pCon->pfnIsValidIn (pCon, pDrv->LineIn.pStrmIn);
-            bool fValidMicIn  = pCon->pfnIsValidIn (pCon, pDrv->MicIn.pStrmIn);
-            bool fValidOut    = pCon->pfnIsValidOut(pCon, pDrv->Out.pStrmOut);
+            bool fValidLineIn = AudioMixerStreamIsValid(pDrv->LineIn.pMixStrm);
+            bool fValidMicIn  = AudioMixerStreamIsValid(pDrv->MicIn.pMixStrm);
+            bool fValidOut    = AudioMixerStreamIsValid(pDrv->Out.pMixStrm);
 
             if (    !fValidLineIn
@@ -2555 +2662 @@
                 LogRel(("AC97: Falling back to NULL backend (no sound audible)\n"));
 
+                /* Destroy the streams before re-attaching the NULL driver. */
+                ichac97StreamsDestroy(pThis);
+
                 ichac97Reset(pDevIns);
                 ichac97Reattach(pThis, pDrv, pDrv->uLUN, "NullAudio");
+
+                ichac97StreamsInit(pThis);
 
                 PDMDevHlpVMSetRuntimeError(pDevIns, 0 /*fFlags*/, "HostAudioNotResponding",
@@ -2567 +2679 @@
 
                 PDMAUDIOBACKENDCFG backendCfg;
-                int rc2 = pCon->pfnGetConfiguration(pCon, &backendCfg);
+                int rc2 = pCon->pfnGetConfig(pCon, &backendCfg);
                 if (RT_SUCCESS(rc2))
                 {
@@ -2624 +2736 @@
             }
         }
-    }
-
-    if (RT_SUCCESS(rc))
-    {
-        pThis->cbReadWriteBuf = _4K; /** @todo Make this configurable. */
-        pThis->pvReadWriteBuf = (uint8_t *)RTMemAllocZ(pThis->cbReadWriteBuf);
-        if (!pThis->pvReadWriteBuf)
-            rc = VERR_NO_MEMORY;
     }
 
@@ -2748 +2852 @@
     NULL,
     /* pfnPowerOff */
-    NULL,
+    ichac97PowerOff,
     /* pfnSoftReset */
     NULL,

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

@@ -87 +87 @@
 #define BIRD_THINKS_CORBRP_IS_MOSTLY_RO
 
-/* Make sure that interleaving streams support is enabled if the 5.1 code
- * is being used. */
-#ifdef VBOX_WITH_HDA_51_SURROUND
+/* Make sure that interleaving streams support is enabled if the 5.1 code is being used. */
+#if defined (VBOX_WITH_HDA_51_SURROUND) && !defined(VBOX_WITH_HDA_INTERLEAVING_STREAMS_SUPPORT)
 # define VBOX_WITH_HDA_INTERLEAVING_STREAMS_SUPPORT
 #endif
 
 /**
- * At the moment we support 4 input + 4 output streams (for 7.1 support) max,
- * which is 12 in total. Bidirectional streams are currently *not* supported.
+ * At the moment we support 4 input + 4 output streams max, which is 8 in total.
+ * Bidirectional streams are currently *not* supported.
  *
  * Note: When changing any of those values, be prepared for some saved state
@@ -143 +142 @@
  */
 #define HDA_MAKE_GCAP(oss, iss, bss, bds, b64sup) \
-    (  (((oss)   & 0xF) << 12) \
-     | (((iss)   & 0xF) << 8)  \
-     | (((bss)   & 0xF) << 3)  \
-     | (((bds)   & 0x3) << 1)  \
+    (  (((oss)   & 0xF)  << 12) \
+     | (((iss)   & 0xF)  << 8)  \
+     | (((bss)   & 0x1F) << 3)  \
+     | (((bds)   & 0x3)  << 1)  \
      | ((b64sup) & 1))
 
@@ -588 +587 @@
 
 /**
+ * Structure for keeping an audio stream data mapping.
+ */
+typedef struct HDASTREAMMAPPING
+{
+    /** The stream's layout. */
+    PDMAUDIOSTREAMLAYOUT              enmLayout;
+    /** Number of audio channels in this stream. */
+    uint8_t                           cChannels;
+    /** Array audio channels. */
+    R3PTRTYPE(PPDMAUDIOSTREAMCHANNEL) paChannels;
+    R3PTRTYPE(PRTCIRCBUF)             pCircBuf;
+} HDASTREAMMAPPING, *PHDASTREAMMAPPING;
+
+/**
  * Internal state of a HDA stream.
  */
@@ -594 +607 @@
     /** Current BDLE to use. Wraps around to 0 if
      *  maximum (cBDLE) is reached. */
-    uint16_t            uCurBDLE;
+    uint16_t                uCurBDLE;
     /** Stop indicator. */
-    volatile bool       fDoStop;
+    volatile bool           fDoStop;
     /** Flag indicating whether this stream is in an
      *  active (operative) state or not. */
-    volatile bool       fActive;
+    volatile bool           fActive;
     /** Flag indicating whether this stream currently is
      *  in reset mode and therefore not acccessible by the guest. */
-    volatile bool       fInReset;
+    volatile bool           fInReset;
     /** Unused, padding. */
-    bool                fPadding;
+    bool                    fPadding;
     /** Mutex semaphore handle to serialize access. */
-    RTSEMMUTEX          hMtx;
+    RTSEMMUTEX              hMtx;
     /** Event signalling that the stream's state has been changed. */
-    RTSEMEVENT          hStateChangedEvent;
+    RTSEMEVENT              hStateChangedEvent;
+    /** This stream's data mapping. */
+    HDASTREAMMAPPING        Mapping;
     /** Current BDLE (Buffer Descriptor List Entry). */
-    HDABDLE             BDLE;
+    HDABDLE                 BDLE;
 } HDASTREAMSTATE, *PHDASTREAMSTATE;
 
@@ -659 +674 @@
 } HDATAG, *PHDATAG;
 
-typedef struct HDAINPUTSTREAM
-{
-    /** Pointer to guest input stream. */
-    R3PTRTYPE(PPDMAUDIOGSTSTRMIN) pGstStrm;
+/**
+ * Structure defining an HDA mixer stream.
+ * This is being used together with an audio mixer instance.
+ */
+typedef struct HDAMIXERSTREAM
+{
+    union
+    {
+        /** Desired playback destination (for an output stream). */
+        PDMAUDIOPLAYBACKDEST           Dest;
+        /** Desired recording source (for an input stream). */
+        PDMAUDIORECSOURCE              Source;
+    } DestSource;
+    uint8_t                            Padding1[4];
     /** Associated mixer handle. */
-    R3PTRTYPE(PAUDMIXSTREAM)      pMixStrm;
-} HDAINPUTSTREAM, *PHDAINPUTSTREAM;
-
-typedef struct HDAOUTPUTSTREAM
-{
-    /** Pointer to guest output stream. */
-    R3PTRTYPE(PPDMAUDIOGSTSTRMOUT) pGstStrm;
-    /** Associated mixer handle. */
-    R3PTRTYPE(PAUDMIXSTREAM)       pMixStrm;
-} HDAOUTPUTSTREAM, *PHDAOUTPUTSTREAM;
+    R3PTRTYPE(PAUDMIXSTREAM)           pMixStrm;
+} HDAMIXERSTREAM, *PHDAMIXERSTREAM;
 
 /**
@@ -701 +718 @@
     /** Audio connector interface to the underlying host backend. */
     R3PTRTYPE(PPDMIAUDIOCONNECTOR)     pConnector;
-    /** Stream for line input. */
-    HDAINPUTSTREAM                     LineIn;
+    /** Mixer stream for line input. */
+    HDAMIXERSTREAM                     LineIn;
 #ifdef VBOX_WITH_HDA_MIC_IN
-    /** Stream for mic input. */
-    HDAINPUTSTREAM                     MicIn;
-#endif
-    /** Stream for front output. */
-    HDAOUTPUTSTREAM                    Front;
+    /** Mixer stream for mic input. */
+    HDAMIXERSTREAM                     MicIn;
+#endif
+    /** Mixer stream for front output. */
+    HDAMIXERSTREAM                     Front;
 #ifdef VBOX_WITH_HDA_51_SURROUND
-    /** Stream for center/LFE output. */
-    HDAOUTPUTSTREAM                    CenterLFE;
-    /** Stream for rear output. */
-    HDAOUTPUTSTREAM                    Rear;
+    /** Mixer stream for center/LFE output. */
+    HDAMIXERSTREAM                     CenterLFE;
+    /** Mixer stream for rear output. */
+    HDAMIXERSTREAM                     Rear;
 #endif
 } HDADRIVER;
@@ -807 +824 @@
     /** Padding for alignment. */
     uint8_t                            au8Padding2[7];
-#ifdef VBOX_WITH_HDA_INTERLEAVING_STREAMS_SUPPORT
-    /** Circular buffer for interleaving streams support.
-     *  This is needed for extracting multiple channels out of a single HDA stream. */
-    R3PTRTYPE(PRTCIRCBUF)              pCircBuf;
-#endif
 } HDASTATE;
 /** Pointer to the ICH Intel HD Audio Controller state. */
@@ -853 +865 @@
 static int hdaRegWriteRIRBSTS(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
 static int hdaRegWriteSTATESTS(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
-static int hdaRegReadOUTPAY(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value);
-static int hdaRegWriteOUTPAY(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
-static int hdaRegReadOUTSTRMPAY(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value);
-static int hdaRegWriteOUTSTRMPAY(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
 static int hdaRegWriteIRS(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
 static int hdaRegReadIRS(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value);
@@ -897 +905 @@
 
 #ifdef IN_RING3
-static int       hdaBDLEFetch(PHDASTATE pThis, PHDABDLE pBDLE, uint64_t u64BaseDMA, uint16_t u16Entry);
-DECLINLINE(void) hdaStreamUpdateLPIB(PHDASTATE pThis, PHDASTREAM pStrmSt, uint32_t u32LPIB);
+static int hdaStreamMapInit(PHDASTREAMMAPPING pMapping, PPDMAUDIOSTREAMCFG pCfg);
+static void hdaStreamMapDestroy(PHDASTREAMMAPPING pMapping);
+static void hdaStreamMapReset(PHDASTREAMMAPPING pMapping);
+#endif
+
+#ifdef IN_RING3
+static int           hdaBDLEFetch(PHDASTATE pThis, PHDABDLE pBDLE, uint64_t u64BaseDMA, uint16_t u16Entry);
+DECLINLINE(uint32_t) hdaStreamUpdateLPIB(PHDASTATE pThis, PHDASTREAM pStrmSt, uint32_t u32LPIB);
 # ifdef LOG_ENABLED
-static void             hdaBDLEDumpAll(PHDASTATE pThis, uint64_t u64BaseDMA, uint16_t cBDLE);
+static void          hdaBDLEDumpAll(PHDASTATE pThis, uint64_t u64BaseDMA, uint16_t cBDLE);
 # endif
 #endif
+static int           hdaProcessInterrupt(PHDASTATE pThis);
 
 
@@ -936 +951 @@
     { offset + 0xC,  0x00002, 0x0000FFFF, 0x0000FFFF, hdaRegReadU16, hdaRegWriteSDLVI  , HDA_REG_IDX_STRM(name, LVI)  , #name " Last Valid Index" }, \
     /* Reserved: FIFO Watermark. ** @todo Document this! */ \
-    { offset + 0xE,  0x00002, 0x00000007, 0x00000007, hdaRegReadU16, hdaRegWriteSDFIFOW, HDA_REG_IDX_STRM(name, FIFOW), #name " FIFO Watermark" }, \
+    { offset + 0xE,  0x00002, 0x00000007, 0x00000007, hdaRegReadU16, hdaRegWriteU16,     HDA_REG_IDX_STRM(name, FIFOW), #name " FIFO Watermark" }, \
     /* Offset 0x90 (SD0) */ \
-    { offset + 0x10, 0x00002, 0x000000FF, 0x00000000, hdaRegReadU16, hdaRegWriteSDFIFOS, HDA_REG_IDX_STRM(name, FIFOS), #name " FIFO Size" }, \
+    { offset + 0x10, 0x00002, 0x000000FF, 0x00000000, hdaRegReadU16, hdaRegWriteU16,     HDA_REG_IDX_STRM(name, FIFOS), #name " FIFO Size" }, \
     /* Offset 0x92 (SD0) */ \
     { offset + 0x12, 0x00002, 0x00007F7F, 0x00007F7F, hdaRegReadU16, hdaRegWriteSDFMT  , HDA_REG_IDX_STRM(name, FMT)  , #name " Stream Format" }, \
@@ -980 +995 @@
     { 0x00002, 0x00001, 0x000000FF, 0x00000000, hdaRegReadU8           , hdaRegWriteUnimpl     , HDA_REG_IDX(VMIN)         }, /* Minor Version */
     { 0x00003, 0x00001, 0x000000FF, 0x00000000, hdaRegReadU8           , hdaRegWriteUnimpl     , HDA_REG_IDX(VMAJ)         }, /* Major Version */
-    { 0x00004, 0x00002, 0x0000FFFF, 0x00000000, hdaRegReadOUTPAY       , hdaRegWriteOUTPAY     , HDA_REG_IDX(OUTPAY)       }, /* Output Payload Capabilities */
+    { 0x00004, 0x00002, 0x0000FFFF, 0x00000000, hdaRegReadU16          , hdaRegWriteU16        , HDA_REG_IDX(OUTPAY)       }, /* Output Payload Capabilities */
     { 0x00006, 0x00002, 0x0000FFFF, 0x00000000, hdaRegReadU16          , hdaRegWriteUnimpl     , HDA_REG_IDX(INPAY)        }, /* Input Payload Capabilities */
     { 0x00008, 0x00004, 0x00000103, 0x00000103, hdaRegReadU32          , hdaRegWriteGCTL       , HDA_REG_IDX(GCTL)         }, /* Global Control */
@@ -986 +1001 @@
     { 0x0000e, 0x00002, 0x00000007, 0x00000007, hdaRegReadU8           , hdaRegWriteSTATESTS   , HDA_REG_IDX(STATESTS)     }, /* State Change Status */
     { 0x00010, 0x00002, 0xFFFFFFFF, 0x00000000, hdaRegReadUnimpl       , hdaRegWriteUnimpl     , HDA_REG_IDX(GSTS)         }, /* Global Status */
-    { 0x00018, 0x00002, 0x0000FFFF, 0x00000000, hdaRegReadOUTSTRMPAY   , hdaRegWriteOUTSTRMPAY , HDA_REG_IDX(OUTSTRMPAY)   }, /* Output Stream Payload Capability */
+    { 0x00018, 0x00002, 0x0000FFFF, 0x00000000, hdaRegReadU16          , hdaRegWriteU16        , HDA_REG_IDX(OUTSTRMPAY)   }, /* Output Stream Payload Capability */
     { 0x0001A, 0x00002, 0x0000FFFF, 0x00000000, hdaRegReadU16          , hdaRegWriteUnimpl     , HDA_REG_IDX(INSTRMPAY)    }, /* Input Stream Payload Capability */
     { 0x00020, 0x00004, 0xC00000FF, 0xC00000FF, hdaRegReadU32          , hdaRegWriteU32        , HDA_REG_IDX(INTCTL)       }, /* Interrupt Control */
     { 0x00024, 0x00004, 0xC00000FF, 0x00000000, hdaRegReadINTSTS       , hdaRegWriteUnimpl     , HDA_REG_IDX(INTSTS)       }, /* Interrupt Status */
     { 0x00030, 0x00004, 0xFFFFFFFF, 0x00000000, hdaRegReadWALCLK       , hdaRegWriteUnimpl     , HDA_REG_IDX_LOCAL(WALCLK) }, /* Wall Clock Counter */
-    { 0x00034, 0x00004, 0x000000FF, 0x000000FF, hdaRegReadSSYNC        , hdaRegWriteSSYNC      , HDA_REG_IDX(SSYNC)        }, /* Stream Synchronization */
+    { 0x00034, 0x00004, 0x000000FF, 0x000000FF, hdaRegReadU32          , hdaRegWriteU32        , HDA_REG_IDX(SSYNC)        }, /* Stream Synchronization */
     { 0x00040, 0x00004, 0xFFFFFF80, 0xFFFFFF80, hdaRegReadU32          , hdaRegWriteBase       , HDA_REG_IDX(CORBLBASE)    }, /* CORB Lower Base Address */
     { 0x00044, 0x00004, 0xFFFFFFFF, 0xFFFFFFFF, hdaRegReadU32          , hdaRegWriteBase       , HDA_REG_IDX(CORBUBASE)    }, /* CORB Upper Base Address */
@@ -1011 +1026 @@
     { 0x00070, 0x00004, 0xFFFFFFFF, 0xFFFFFF81, hdaRegReadU32          , hdaRegWriteBase       , HDA_REG_IDX(DPLBASE)      }, /* DMA Position Lower Base */
     { 0x00074, 0x00004, 0xFFFFFFFF, 0xFFFFFFFF, hdaRegReadU32          , hdaRegWriteBase       , HDA_REG_IDX(DPUBASE)      }, /* DMA Position Upper Base */
-    /* 4 Input Stream Descriptors (ISD). */
+    /* 4 Serial Data In (SDI). */
     HDA_REG_MAP_DEF_STREAM(0, SD0),
     HDA_REG_MAP_DEF_STREAM(1, SD1),
     HDA_REG_MAP_DEF_STREAM(2, SD2),
     HDA_REG_MAP_DEF_STREAM(3, SD3),
-    /* 4 Output Stream Descriptors (OSD). */
+    /* 4 Serial Data Out (SDO). */
     HDA_REG_MAP_DEF_STREAM(4, SD4),
     HDA_REG_MAP_DEF_STREAM(5, SD5),
@@ -1086 +1101 @@
 
 #ifdef IN_RING3
-DECLINLINE(void) hdaStreamUpdateLPIB(PHDASTATE pThis, PHDASTREAM pStrmSt, uint32_t u32LPIB)
-{
-    AssertPtrReturnVoid(pThis);
-    AssertPtrReturnVoid(pStrmSt);
+DECLINLINE(uint32_t) hdaStreamUpdateLPIB(PHDASTATE pThis, PHDASTREAM pStrmSt, uint32_t u32LPIB)
+{
+    AssertPtrReturn(pThis,   0);
+    AssertPtrReturn(pStrmSt, 0);
 
     Assert(u32LPIB <= pStrmSt->u32CBL);
@@ -1107 +1122 @@
         AssertRC(rc2);
     }
+
+    return u32LPIB;
 }
 #endif
@@ -1169 +1186 @@
  * @return  IPRT status code.
  */
-DECLINLINE(int) hdaStreamGetNextBDLE(PHDASTATE pThis, PHDASTREAM pStrmSt)
+DECLINLINE(int) hdaStreamGetNextBDLE(PHDASTATE pThis, PHDASTREAM pStream)
 {
     AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
-    AssertPtrReturn(pStrmSt, VERR_INVALID_POINTER);
+    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
 
     NOREF(pThis);
 
-    Assert(pStrmSt->State.uCurBDLE < pStrmSt->u16LVI + 1);
+    Assert(pStream->State.uCurBDLE < pStream->u16LVI + 1);
+
+    LogFlowFuncEnter();
 
 #ifdef DEBUG
-    uint32_t uOldBDLE = pStrmSt->State.uCurBDLE;
-#endif
+    uint32_t uOldBDLE = pStream->State.uCurBDLE;
+#endif
+
+    PHDABDLE pBDLE = &pStream->State.BDLE;
 
     /*
@@ -1186 +1207 @@
      * if we reached the end of the Buffer Descriptor List (BDL).
      */
-    pStrmSt->State.uCurBDLE++;
-    if (pStrmSt->State.uCurBDLE == pStrmSt->u16LVI + 1)
-    {
-        pStrmSt->State.uCurBDLE = 0;
-
-        hdaStreamUpdateLPIB(pThis, pStrmSt, 0);
-    }
-
-    Assert(pStrmSt->State.uCurBDLE < pStrmSt->u16LVI + 1);
-
-    int rc = hdaBDLEFetch(pThis, &pStrmSt->State.BDLE, pStrmSt->u64BDLBase, pStrmSt->State.uCurBDLE);
+    pStream->State.uCurBDLE++;
+    if (pStream->State.uCurBDLE == pStream->u16LVI + 1)
+    {
+        pStream->State.uCurBDLE = 0;
+
+        hdaStreamUpdateLPIB(pThis, pStream, 0);
+    }
+
+    Assert(pStream->State.uCurBDLE < pStream->u16LVI + 1);
+
+    /* Fetch the next BDLE entry. */
+    int rc = hdaBDLEFetch(pThis, pBDLE, pStream->u64BDLBase, pStream->State.uCurBDLE);
 
 #ifdef DEBUG
     LogFlowFunc(("[SD%RU8]: uOldBDLE=%RU16, uCurBDLE=%RU16, LVI=%RU32, rc=%Rrc, %R[bdle]\n",
-                 pStrmSt->u8SD, uOldBDLE, pStrmSt->State.uCurBDLE, pStrmSt->u16LVI, rc, &pStrmSt->State.BDLE));
-#endif
+                 pStream->u8SD, uOldBDLE, pStream->State.uCurBDLE, pStream->u16LVI, rc, pBDLE));
+#endif
+
     return rc;
 }
 #endif /* IN_RING3 */
+
+/**
+ * Returns the audio direction of a specified stream descriptor.
+ *
+ * The register layout specifies that input streams (SDI) come first,
+ * followed by the output streams (SDO). So every stream ID below HDA_MAX_SDI
+ * is an input stream, whereas everything >= HDA_MAX_SDI is an output stream.
+ *
+ * Note: SDnFMT register does not provide that information, so we have to judge
+ *       for ourselves.
+ *
+ * @return  Audio direction.
+ */
+DECLINLINE(PDMAUDIODIR) hdaGetDirFromSD(uint8_t uSD)
+{
+    AssertReturn(uSD <= HDA_MAX_STREAMS, PDMAUDIODIR_UNKNOWN);
+
+    if (uSD < HDA_MAX_SDI)
+        return PDMAUDIODIR_IN;
+
+    return PDMAUDIODIR_OUT;
+}
 
 DECLINLINE(PHDASTREAM) hdaStreamFromSD(PHDASTATE pThis, uint8_t uSD)
@@ -1239 +1284 @@
          && (SDSTS(pThis, num) & HDA_REG_FIELD_FLAG_MASK(SDSTS, BCIS)))
 
-    bool fIrq = false;
+    uint8_t uLevel = 0;
 
     /** @todo Optimize IRQ handling. */
@@ -1248 +1293 @@
            || HDA_REG_FLAG_VALUE(pThis, RIRBSTS, RIRBOIS)
            || (HDA_REG(pThis, STATESTS) & HDA_REG(pThis, WAKEEN))))
-        fIrq = true;
+        uLevel = 1;
 
     if (   IS_INTERRUPT_OCCURED_AND_ENABLED(pThis, 0)
@@ -1259 +1304 @@
         || IS_INTERRUPT_OCCURED_AND_ENABLED(pThis, 7))
     {
-        fIrq = true;
+        uLevel = 1;
     }
 
     if (HDA_REG_FLAG_VALUE(pThis, INTCTL, GIE))
     {
-        Log3Func(("%s\n", fIrq ? "Asserted" : "Deasserted"));
-        PDMDevHlpPCISetIrq(pThis->CTX_SUFF(pDevIns), 0 , fIrq);
+        Log3Func(("Level=%d\n", uLevel));
+        PDMDevHlpPCISetIrq(pThis->CTX_SUFF(pDevIns), 0 , uLevel);
     }
 
@@ -1442 +1487 @@
 static int hdaCORBCmdProcess(PHDASTATE pThis)
 {
-    PFNHDACODECVERBPROCESSOR pfn = (PFNHDACODECVERBPROCESSOR)NULL;
-
     int rc = hdaCmdSync(pThis, true);
     if (RT_FAILURE(rc))
@@ -1453 +1496 @@
 
     Assert((corbWp != corbRp));
-    LogFlowFunc(("CORB(RP:%x, WP:%x) RIRBWP:%x\n", HDA_REG(pThis, CORBRP), HDA_REG(pThis, CORBWP), HDA_REG(pThis, RIRBWP)));
+    Log3Func(("CORB(RP:%x, WP:%x) RIRBWP:%x\n", HDA_REG(pThis, CORBRP), HDA_REG(pThis, CORBWP), HDA_REG(pThis, RIRBWP)));
 
     while (corbRp != corbWp)
     {
-        uint32_t cmd;
-        uint64_t resp;
-        pfn = NULL;
-        corbRp++;
-        cmd = pThis->pu32CorbBuf[corbRp];
-
-        rc = pThis->pCodec->pfnLookup(pThis->pCodec, HDA_CODEC_CMD(cmd, 0 /* Codec index */), &pfn);
-        if (RT_SUCCESS(rc))
-        {
-            AssertPtr(pfn);
-            rc = pfn(pThis->pCodec, HDA_CODEC_CMD(cmd, 0 /* LUN */), &resp);
-        }
-
-        if (RT_FAILURE(rc))
-            AssertRCReturn(rc, rc);
+        uint64_t uResp;
+        uint32_t uCmd = pThis->pu32CorbBuf[++corbRp];
+
+        int rc2 = pThis->pCodec->pfnLookup(pThis->pCodec, HDA_CODEC_CMD(uCmd, 0 /* Codec index */), &uResp);
+        if (RT_FAILURE(rc2))
+            LogFunc(("Codec lookup failed with rc=%Rrc\n", rc2));
+
         (rirbWp)++;
 
-        LogFunc(("verb:%08x->%016lx\n", cmd, resp));
-        if (   (resp & CODEC_RESPONSE_UNSOLICITED)
+        if (   (uResp & CODEC_RESPONSE_UNSOLICITED)
             && !HDA_REG_FLAG_VALUE(pThis, GCTL, UR))
         {
-            LogFunc(("unexpected unsolicited response.\n"));
+            LogFunc(("Unexpected unsolicited response\n"));
             HDA_REG(pThis, CORBRP) = corbRp;
             return rc;
         }
 
-        pThis->pu64RirbBuf[rirbWp] = resp;
+        pThis->pu64RirbBuf[rirbWp] = uResp;
 
         pThis->u8RespIntCnt++;
@@ -1489 +1523 @@
             break;
     }
+
     HDA_REG(pThis, CORBRP) = corbRp;
     HDA_REG(pThis, RIRBWP) = rirbWp;
+
     rc = hdaCmdSync(pThis, false);
-    LogFunc(("CORB(RP:%x, WP:%x) RIRBWP:%x\n", HDA_REG(pThis, CORBRP),
-         HDA_REG(pThis, CORBWP), HDA_REG(pThis, RIRBWP)));
+
+    Log3Func(("CORB(RP:%x, WP:%x) RIRBWP:%x\n", HDA_REG(pThis, CORBRP), HDA_REG(pThis, CORBWP), HDA_REG(pThis, RIRBWP)));
+
     if (HDA_REG_FLAG_VALUE(pThis, RIRBCTL, RIC))
     {
@@ -1501 +1538 @@
         rc = hdaProcessInterrupt(pThis);
     }
+
     if (RT_FAILURE(rc))
         AssertRCReturn(rc, rc);
@@ -1533 +1571 @@
     AssertPtrReturnVoid(pStrmSt);
 
-    LogFlowFunc(("[SD%RU8]: Destroy\n", pStrmSt->u8SD));
+    LogFlowFunc(("[SD%RU8]: Destroying ...\n", pStrmSt->u8SD));
 
     int rc2 = hdaStreamStop(pStrmSt);
     AssertRC(rc2);
+
+    hdaStreamMapDestroy(&pStrmSt->State.Mapping);
 
     if (pStrmSt->State.hMtx != NIL_RTSEMMUTEX)
@@ -1555 +1595 @@
 }
 
-static int hdaStreamInit(PHDASTATE pThis, PHDASTREAM pStrmSt, uint8_t u8SD)
+static int hdaStreamInit(PHDASTATE pThis, PHDASTREAM pStream, uint8_t u8SD)
 {
     AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
-    AssertPtrReturn(pStrmSt, VERR_INVALID_POINTER);
-
-    pStrmSt->u8SD       = u8SD;
-    pStrmSt->u64BDLBase = RT_MAKE_U64(HDA_STREAM_REG(pThis, BDPL, pStrmSt->u8SD),
-                                      HDA_STREAM_REG(pThis, BDPU, pStrmSt->u8SD));
-    pStrmSt->u16LVI     = HDA_STREAM_REG(pThis, LVI, pStrmSt->u8SD);
-    pStrmSt->u32CBL     = HDA_STREAM_REG(pThis, CBL, pStrmSt->u8SD);
-    pStrmSt->u16FIFOS   = hdaSDFIFOSToBytes(HDA_STREAM_REG(pThis, FIFOS, pStrmSt->u8SD));
-
-    RT_ZERO(pStrmSt->State.BDLE);
-    pStrmSt->State.uCurBDLE = 0;
+    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
+
+    pStream->u8SD       = u8SD;
+    pStream->u64BDLBase = RT_MAKE_U64(HDA_STREAM_REG(pThis, BDPL, pStream->u8SD),
+                                      HDA_STREAM_REG(pThis, BDPU, pStream->u8SD));
+    pStream->u16LVI     = HDA_STREAM_REG(pThis, LVI, pStream->u8SD);
+    pStream->u32CBL     = HDA_STREAM_REG(pThis, CBL, pStream->u8SD);
+    pStream->u16FIFOS   = hdaSDFIFOSToBytes(HDA_STREAM_REG(pThis, FIFOS, pStream->u8SD));
+
+    RT_ZERO(pStream->State.BDLE);
+    pStream->State.uCurBDLE = 0;
+
+    hdaStreamMapReset(&pStream->State.Mapping);
 
     LogFlowFunc(("[SD%RU8]: DMA @ 0x%x (%RU32 bytes), LVI=%RU16, FIFOS=%RU16\n",
-                 pStrmSt->u8SD, pStrmSt->u64BDLBase, pStrmSt->u32CBL, pStrmSt->u16LVI, pStrmSt->u16FIFOS));
+                 pStream->u8SD, pStream->u64BDLBase, pStream->u32CBL, pStream->u16LVI, pStream->u16FIFOS));
 
 #ifdef DEBUG
-    uint64_t u64BaseDMA = RT_MAKE_U64(HDA_STREAM_REG(pThis, BDPL, pStrmSt->u8SD),
-                                      HDA_STREAM_REG(pThis, BDPU, pStrmSt->u8SD));
-    uint16_t u16LVI     = HDA_STREAM_REG(pThis, LVI, pStrmSt->u8SD);
-    uint32_t u32CBL     = HDA_STREAM_REG(pThis, CBL, pStrmSt->u8SD);
+    uint64_t u64BaseDMA = RT_MAKE_U64(HDA_STREAM_REG(pThis, BDPL, pStream->u8SD),
+                                      HDA_STREAM_REG(pThis, BDPU, pStream->u8SD));
+    uint16_t u16LVI     = HDA_STREAM_REG(pThis, LVI, pStream->u8SD);
+    uint32_t u32CBL     = HDA_STREAM_REG(pThis, CBL, pStream->u8SD);
 
     LogFlowFunc(("\t-> DMA @ 0x%x, LVI=%RU16, CBL=%RU32\n", u64BaseDMA, u16LVI, u32CBL));
@@ -1587 +1629 @@
 }
 
-static void hdaStreamReset(PHDASTATE pThis, PHDASTREAM pStrmSt, uint8_t u8Strm)
+static void hdaStreamReset(PHDASTATE pThis, PHDASTREAM pStrmSt)
 {
     AssertPtrReturnVoid(pThis);
     AssertPtrReturnVoid(pStrmSt);
-    AssertReturnVoid(u8Strm <= HDA_MAX_STREAMS);
+
+    const uint8_t uSD = pStrmSt->u8SD;
 
 #ifdef VBOX_STRICT
-    AssertReleaseMsg(!RT_BOOL(HDA_STREAM_REG(pThis, CTL, u8Strm) & HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN)),
-                     ("[SD%RU8] Cannot reset stream while in running state\n", u8Strm));
-#endif
+    AssertReleaseMsg(!RT_BOOL(HDA_STREAM_REG(pThis, CTL, uSD) & HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN)),
+                     ("[SD%RU8] Cannot reset stream while in running state\n", uSD));
+#endif
+
+    LogFunc(("[SD%RU8]: Reset\n", uSD));
 
     /*
@@ -1613 +1658 @@
      * Second, initialize the registers.
      */
-    HDA_STREAM_REG(pThis, STS,   u8Strm) = 0;
+    HDA_STREAM_REG(pThis, STS,   uSD) = HDA_REG_FIELD_FLAG_MASK(SDSTS, FIFORDY);
     /* According to the ICH6 datasheet, 0x40000 is the default value for stream descriptor register 23:20
      * bits are reserved for stream number 18.2.33, resets SDnCTL except SRST bit. */
-    HDA_STREAM_REG(pThis, CTL,   u8Strm) = 0x40000 | (HDA_STREAM_REG(pThis, CTL, u8Strm) & HDA_REG_FIELD_FLAG_MASK(SDCTL, SRST));
+    HDA_STREAM_REG(pThis, CTL,   uSD) = 0x40000 | (HDA_STREAM_REG(pThis, CTL, uSD) & HDA_REG_FIELD_FLAG_MASK(SDCTL, SRST));
     /* ICH6 defines default values (0x77 for input and 0xBF for output descriptors) of FIFO size. 18.2.39. */
-    HDA_STREAM_REG(pThis, FIFOS, u8Strm) = u8Strm < 4 ? HDA_SDINFIFO_120B : HDA_SDONFIFO_192B;
+    HDA_STREAM_REG(pThis, FIFOS, uSD) = hdaGetDirFromSD(uSD) == PDMAUDIODIR_IN ? HDA_SDINFIFO_120B : HDA_SDONFIFO_192B;
     /* See 18.2.38: Always defaults to 0x4 (32 bytes). */
-    HDA_STREAM_REG(pThis, FIFOW, u8Strm) = HDA_SDFIFOW_32B;
-    HDA_STREAM_REG(pThis, LPIB,  u8Strm) = 0;
-    HDA_STREAM_REG(pThis, CBL,   u8Strm) = 0;
-    HDA_STREAM_REG(pThis, LVI,   u8Strm) = 0;
-    HDA_STREAM_REG(pThis, FMT,   u8Strm) = HDA_SDFMT_MAKE(HDA_SDFMT_TYPE_PCM, HDA_SDFMT_BASE_44KHZ,
-                                                          HDA_SDFMT_MULT_1X, HDA_SDFMT_DIV_1X, HDA_SDFMT_16_BIT,
-                                                          HDA_SDFMT_CHAN_STEREO);
-    HDA_STREAM_REG(pThis, BDPU,  u8Strm) = 0;
-    HDA_STREAM_REG(pThis, BDPL,  u8Strm) = 0;
-
-    /*
-     * Third, match the internal state to the just set registers.
-     */
-    pStrmSt->u8SD       = u8Strm;
-    pStrmSt->u64BDLBase = RT_MAKE_U64(HDA_STREAM_REG(pThis, BDPL, u8Strm),
-                                      HDA_STREAM_REG(pThis, BDPU, u8Strm));
-    pStrmSt->u32CBL     = HDA_STREAM_REG(pThis, CBL,   u8Strm);
-    pStrmSt->u16FIFOS   = HDA_STREAM_REG(pThis, FIFOS, u8Strm);
-    pStrmSt->u16FMT     = HDA_STREAM_REG(pThis, FMT,   u8Strm);
-    pStrmSt->u16LVI     = HDA_STREAM_REG(pThis, LVI,   u8Strm);
-
-    LogFunc(("[SD%RU8]: Reset\n", u8Strm));
+    HDA_STREAM_REG(pThis, FIFOW, uSD) = HDA_SDFIFOW_32B;
+    HDA_STREAM_REG(pThis, LPIB,  uSD) = 0;
+    HDA_STREAM_REG(pThis, CBL,   uSD) = 0;
+    HDA_STREAM_REG(pThis, LVI,   uSD) = 0;
+    HDA_STREAM_REG(pThis, FMT,   uSD) = HDA_SDFMT_MAKE(HDA_SDFMT_TYPE_PCM, HDA_SDFMT_BASE_44KHZ,
+                                                       HDA_SDFMT_MULT_1X, HDA_SDFMT_DIV_1X, HDA_SDFMT_16_BIT,
+                                                       HDA_SDFMT_CHAN_STEREO);
+    HDA_STREAM_REG(pThis, BDPU,  uSD) = 0;
+    HDA_STREAM_REG(pThis, BDPL,  uSD) = 0;
+
+    int rc2 = hdaStreamInit(pThis, pStrmSt, uSD);
+    AssertRC(rc2);
+
+    /* Report that we're done resetting this stream. */
+    HDA_STREAM_REG(pThis, CTL,   uSD) = 0;
 
     /* Exit reset state. */
@@ -1692 +1730 @@
 }
 
+static int hdaStreamChannelExtract(PPDMAUDIOSTREAMCHANNEL pChan, const void *pvBuf, size_t cbBuf)
+{
+    AssertPtrReturn(pChan, VERR_INVALID_POINTER);
+    AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
+    AssertReturn(cbBuf,    VERR_INVALID_PARAMETER);
+
+    AssertRelease(pChan->cbOff <= cbBuf);
+
+    const uint8_t *pu8Buf = (const uint8_t *)pvBuf;
+
+    size_t         cbSrc = cbBuf - pChan->cbOff;
+    const uint8_t *pvSrc = &pu8Buf[pChan->cbOff];
+
+    size_t         cbDst;
+    uint8_t       *pvDst;
+    RTCircBufAcquireWriteBlock(pChan->Data.pCircBuf, cbBuf, (void **)&pvDst, &cbDst);
+
+    cbSrc = RT_MIN(cbSrc, cbDst);
+
+    while (cbSrc)
+    {
+        AssertBreak(cbDst >= cbSrc);
+
+        /* Enough data for at least one next frame? */
+        if (cbSrc < pChan->cbFrame)
+            break;
+
+        memcpy(pvDst, pvSrc, pChan->cbFrame);
+
+        /* Advance to next channel frame in stream. */
+        pvSrc        += pChan->cbStep;
+        Assert(cbSrc >= pChan->cbStep);
+        cbSrc        -= pChan->cbStep;
+
+        /* Advance destination by one frame. */
+        pvDst        += pChan->cbFrame;
+        Assert(cbDst >= pChan->cbFrame);
+        cbDst        -= pChan->cbFrame;
+
+        /* Adjust offset. */
+        pChan->cbOff += pChan->cbFrame;
+    }
+
+    RTCircBufReleaseWriteBlock(pChan->Data.pCircBuf, cbDst);
+
+    return VINF_SUCCESS;
+}
+
+static int hdaStreamChannelAdvance(PPDMAUDIOSTREAMCHANNEL pChan, size_t cbAdv)
+{
+    AssertPtrReturn(pChan, VERR_INVALID_POINTER);
+
+    if (!cbAdv)
+        return VINF_SUCCESS;
+
+    return VINF_SUCCESS;
+}
+
+static int hdaStreamChannelDataInit(PPDMAUDIOSTREAMCHANNELDATA pChanData, uint32_t fFlags)
+{
+    int rc = RTCircBufCreate(&pChanData->pCircBuf, 256); /** @todo Make this configurable? */
+    if (RT_SUCCESS(rc))
+    {
+        pChanData->fFlags = fFlags;
+    }
+
+    return rc;
+}
+
+/**
+ * Frees a stream channel data block again.
+ *
+ * @param   pChanData           Pointer to channel data to free.
+ */
+static void hdaStreamChannelDataDestroy(PPDMAUDIOSTREAMCHANNELDATA pChanData)
+{
+    if (!pChanData)
+        return;
+
+    if (pChanData->pCircBuf)
+    {
+        RTCircBufDestroy(pChanData->pCircBuf);
+        pChanData->pCircBuf = NULL;
+    }
+
+    pChanData->fFlags = PDMAUDIOSTREAMCHANNELDATA_FLAG_NONE;
+}
+
+static int hdaStreamChannelAcquireData(PPDMAUDIOSTREAMCHANNELDATA pChanData, void *pvData, size_t *pcbData)
+{
+    AssertPtrReturn(pChanData, VERR_INVALID_POINTER);
+    AssertPtrReturn(pvData,    VERR_INVALID_POINTER);
+    AssertPtrReturn(pcbData,   VERR_INVALID_POINTER);
+
+    RTCircBufAcquireReadBlock(pChanData->pCircBuf, 256 /** @todo Make this configurarble? */, &pvData, &pChanData->cbAcq);
+
+    *pcbData = pChanData->cbAcq;
+    return VINF_SUCCESS;
+}
+
+static int hdaStreamChannelReleaseData(PPDMAUDIOSTREAMCHANNELDATA pChanData)
+{
+    AssertPtrReturn(pChanData, VERR_INVALID_POINTER);
+    RTCircBufReleaseReadBlock(pChanData->pCircBuf, pChanData->cbAcq);
+
+    return VINF_SUCCESS;
+}
+
 static int hdaStreamWaitForStateChange(PHDASTREAM pStrmSt, RTMSINTERVAL msTimeout)
 {
@@ -1821 +1967 @@
 }
 
-static int hdaRegReadOUTPAY(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value)
-{
-    uint16_t u16OUTSTRMPAY = HDA_REG(pThis, OUTPAY);
-    LogFlowFunc(("%RU16\n", u16OUTSTRMPAY));
-
-    if (pu32Value)
-        *pu32Value = u16OUTSTRMPAY;
-    return VINF_SUCCESS;
-}
-
-static int hdaRegWriteOUTPAY(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
-{
-    LogFlowFunc(("%RU16\n", (uint16_t)u32Value));
-    return hdaRegWriteU16(pThis, iReg, u32Value);
-}
-
-static int hdaRegReadOUTSTRMPAY(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value)
-{
-    uint16_t u16OUTSTRMPAY = HDA_REG(pThis, OUTSTRMPAY);
-    LogFlowFunc(("%RU16\n", u16OUTSTRMPAY));
-
-    if (pu32Value)
-        *pu32Value = u16OUTSTRMPAY;
-    return VINF_SUCCESS;
-}
-
-static int hdaRegWriteOUTSTRMPAY(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
-{
-    LogFlowFunc(("%RU16\n", (uint16_t)u32Value));
-    return hdaRegWriteU16(pThis, iReg, u32Value);
-}
-
 static int hdaRegReadINTSTS(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value)
 {
@@ -1864 +1978 @@
     }
 
-    for (uint8_t i = 0; i < HDA_MAX_STREAMS; i++)
-    {
-        const uint32_t u32STS = HDA_STREAM_REG(pThis, STS, i);
-        bool fReport =    (u32STS & HDA_REG_FIELD_FLAG_MASK(SDSTS, DE))
-                       || (u32STS & HDA_REG_FIELD_FLAG_MASK(SDSTS, FE))
-                       || (u32STS & HDA_REG_FIELD_FLAG_MASK(SDSTS, BCIS));
-        v |= fReport ? RT_BIT(i) : 0;
-    }
-
-    v |= v ? RT_BIT(31) : 0;
-
-    if (pu32Value)
-        *pu32Value = v;
-
+#define HDA_MARK_STREAM(x)                                             \
+    if (/* Descriptor Error */                                         \
+           (SDSTS((pThis), x) & HDA_REG_FIELD_FLAG_MASK(SDSTS, DE))    \
+        /* FIFO Error */                                               \
+        || (SDSTS((pThis), x) & HDA_REG_FIELD_FLAG_MASK(SDSTS, FE))    \
+        /* Buffer Completion Interrupt Status */                       \
+        || (SDSTS((pThis), x) & HDA_REG_FIELD_FLAG_MASK(SDSTS, BCIS))) \
+    {                                                                  \
+        Log3Func(("[SD%RU8] BCIS: Marked\n", x));                      \
+        v |= RT_BIT(x);                                                \
+    }
+
+    HDA_MARK_STREAM(0); /* SD0: Input. */
+    HDA_MARK_STREAM(4); /* SD4: Output. */
+
+#undef HDA_MARK_STREAM
+
+    /* "OR" bit of all interrupt status bits. */
+    if (v)
+        v |= RT_BIT(31);
+
+    *pu32Value = v;
     return VINF_SUCCESS;
 }
@@ -2011 +2133 @@
     bool fInReset  = RT_BOOL(HDA_REG_IND(pThis, iReg) & HDA_REG_FIELD_FLAG_MASK(SDCTL, SRST));
 
+uint32_t uVal = HDA_REG_IND(pThis, iReg);
+    LogFunc(("uVal=%RU32 vs u32Value=%RU32\n", uVal, u32Value));
+
     if (HDA_REG_IND(pThis, iReg) == u32Value) /* Value already set? */
         return VINF_SUCCESS;
@@ -2075 +2200 @@
 
         LogFunc(("[SD%RU8]: Guest initiated enter to stream reset\n", pStrmSt->u8SD));
-        hdaStreamReset(pThis, pStrmSt, pStrmSt->u8SD);
+        hdaStreamReset(pThis, pStrmSt);
 #endif
     }
@@ -2089 +2214 @@
             LogFunc(("[SD%RU8]: fRun=%RTbool\n", pStrmSt->u8SD, fRun));
 
-            Assert(pStrmSt->u8SD < HDA_MAX_STREAMS);
-
-            /*
-             * The register layout specifies that input streams (SDI) come first,
-             * followed by the output streams (SDO). So every stream ID below HDA_MAX_SDI
-             * is an input stream, whereas everything >= HDA_MAX_SDI is an output stream.
-             */
-            PHDADRIVER pDrv;
-            if (pStrmSt->u8SD < HDA_MAX_SDI)
+            AUDMIXSINKCMD enmCmd = fRun
+                                 ? AUDMIXSINKCMD_ENABLE : AUDMIXSINKCMD_DISABLE;
+
+            if (hdaGetDirFromSD(uSD) == PDMAUDIODIR_IN)
             {
 # ifdef VBOX_WITH_HDA_MIC_IN
-#  error "Implement mic-in support!"
-# else
-                RTListForEach(&pThis->lstDrv, pDrv, HDADRIVER, Node)
-                        pDrv->pConnector->pfnEnableIn(pDrv->pConnector,
-                                                      pDrv->LineIn.pGstStrm, fRun);
+                AudioMixerSinkCtl(pThis->pSinkMicIn,  enmCmd);
 # endif
+                AudioMixerSinkCtl(pThis->pSinkLineIn, enmCmd);
             }
             else
             {
-                RTListForEach(&pThis->lstDrv, pDrv, HDADRIVER, Node)
-                {
-                    pDrv->pConnector->pfnEnableOut(pDrv->pConnector, pDrv->Front.pGstStrm,     fRun);
+                AudioMixerSinkCtl(pThis->pSinkFront,     enmCmd);
 # ifdef VBOX_WITH_HDA_51_SURROUND
-                    pDrv->pConnector->pfnEnableOut(pDrv->pConnector, pDrv->CenterLFE.pGstStrm, fRun);
-                    pDrv->pConnector->pfnEnableOut(pDrv->pConnector, pDrv->Rear.pGstStrm,      fRun);
+                AudioMixerSinkCtl(pThis->pSinkCenterLFE, enmCmd);
+                AudioMixerSinkCtl(pThis->pSinkRear,      enmCmd);
 # endif
-                }
+            }
+
+            if (fRun)
+            {
+                /* (Re-)Fetch the current BDLE entry. */
+                rc2 = hdaBDLEFetch(pThis, &pStrmSt->State.BDLE, pStrmSt->u64BDLBase, pStrmSt->State.uCurBDLE);
+                AssertRC(rc2);
             }
         }
@@ -2124 +2245 @@
 #endif /* IN_RING3 */
     }
+
+    /* Make sure to handle interrupts here as well. */
+    hdaProcessInterrupt(pThis);
 
 #ifdef IN_RING3
@@ -2142 +2266 @@
 
     uint32_t v  = HDA_REG_IND(pThis, iReg);
+             /* Clear (zero) FIFOE and DESE bits when writing 1 to it. */
              v &= ~(u32Value & v);
+
     HDA_REG_IND(pThis, iReg) = v;
 
@@ -2211 +2337 @@
         return VINF_SUCCESS;
 
+    uint8_t  uSD      = HDA_SD_NUM_FROM_REG(pThis, FIFOS, iReg);
     /** @todo Only allow updating FIFOS if RUN bit is 0? */
     uint32_t u32FIFOS = 0;
 
-    /** @todo Check if this is a SDI and deny writes to this. */
+    if (hdaGetDirFromSD(uSD) == PDMAUDIODIR_IN) /* FIFOS for input streams is read-only. */
+    {
+        LogRel(("HDA: Warning: Guest tried to write read-only FIFOS for input stream #%RU8, skipping\n", uSD));
+        AssertFailed();
+        return VINF_SUCCESS;
+    }
+
     switch(u32Value)
     {
@@ -2229 +2362 @@
             /* Fall through is intentional. */
         default:
+            LogRel(("HDA: Warning: Guest tried write unsupported FIFOS (0x%x) to input stream #%RU8, defaulting to 192 bytes\n",
+                    u32Value, uSD));
             u32FIFOS = HDA_SDONFIFO_192B;
+            AssertFailed();
             break;
     }
@@ -2246 +2382 @@
 
 #ifdef IN_RING3
-static int hdaSDFMTToStrmCfg(uint32_t u32SDFMT, PPDMAUDIOSTREAMCFG pCfg)
-{
-    AssertPtrReturn(pCfg, VERR_INVALID_POINTER);
+static int hdaSDFMTToStrmCfg(uint32_t u32SDFMT, PPDMAUDIOSTREAMCFG pStrmCfg)
+{
+    AssertPtrReturn(pStrmCfg, VERR_INVALID_POINTER);
 
 # define EXTRACT_VALUE(v, mask, shift) ((v & ((mask) << (shift))) >> (shift))
@@ -2287 +2423 @@
     }
 
-    PDMAUDIOFMT enmFmt      = AUD_FMT_S16; /* Default to 16-bit signed. */
-    uint8_t     cSampleBits = 16;
+    PDMAUDIOFMT enmFmt;
     switch (EXTRACT_VALUE(u32SDFMT, HDA_SDFMT_BITS_MASK, HDA_SDFMT_BITS_SHIFT))
     {
         case 0:
-            enmFmt      = AUD_FMT_S8;
-            cSampleBits = 8;
+            enmFmt = PDMAUDIOFMT_S8;
             break;
         case 1:
-            enmFmt      = AUD_FMT_S16;
-            break;
-        case 2:
-            cSampleBits = 20;
-            break;
-        case 3:
-            cSampleBits = 24;
+            enmFmt = PDMAUDIOFMT_S16;
             break;
         case 4:
-            enmFmt      = AUD_FMT_S32;
-            cSampleBits = 32;
+            enmFmt = PDMAUDIOFMT_S32;
             break;
         default:
@@ -2317 +2444 @@
     if (RT_SUCCESS(rc))
     {
-        pCfg->uHz           = u32Hz * u32HzMult / u32HzDiv;
-        pCfg->cChannels     = (u32SDFMT & 0xf) + 1;
-        pCfg->enmFormat     = enmFmt;
-        pCfg->enmEndianness = PDMAUDIOHOSTENDIANNESS;
+        pStrmCfg->uHz           = u32Hz * u32HzMult / u32HzDiv;
+        pStrmCfg->cChannels     = (u32SDFMT & 0xf) + 1;
+        pStrmCfg->enmFormat     = enmFmt;
+        pStrmCfg->enmEndianness = PDMAUDIOHOSTENDIANNESS;
     }
 
@@ -2326 +2453 @@
     return rc;
 }
-#endif
+
+static int hdaAddStreamOut(PHDASTATE pThis, PPDMAUDIOSTREAMCFG pCfg)
+{
+    AssertPtrReturn(pThis, VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfg,  VERR_INVALID_POINTER);
+
+    AssertReturn(pCfg->enmDir == PDMAUDIODIR_OUT, VERR_INVALID_PARAMETER);
+
+    LogFlowFunc(("Stream=%s\n", pCfg->szName));
+
+    int rc = VINF_SUCCESS;
+
+    bool fUseFront = true; /* Always use front out by default. */
+#ifdef VBOX_WITH_HDA_51_SURROUND
+    bool fUseRear;
+    bool fUseCenter;
+    bool fUseLFE;
+
+    fUseRear = fUseCenter = fUseLFE = false;
+
+    /*
+     * Use commonly used setups for speaker configurations.
+     */
+
+    /** @todo Make the following configurable through mixer API and/or CFGM? */
+    switch (pCfg->cChannels)
+    {
+        case 3:  /* 2.1: Front (Stereo) + LFE. */
+        {
+            fUseLFE   = true;
+            break;
+        }
+
+        case 4:  /* Quadrophonic: Front (Stereo) + Rear (Stereo). */
+        {
+            fUseRear  = true;
+            break;
+        }
+
+        case 5:  /* 4.1: Front (Stereo) + Rear (Stereo) + LFE. */
+        {
+            fUseRear  = true;
+            fUseLFE   = true;
+            break;
+        }
+
+        case 6:  /* 5.1: Front (Stereo) + Rear (Stereo) + Center/LFE. */
+        {
+            fUseRear   = true;
+            fUseCenter = true;
+            fUseLFE    = true;
+            break;
+        }
+
+        default: /* Unknown; fall back to 2 front channels (stereo). */
+        {
+            rc = VERR_NOT_SUPPORTED;
+            break;
+        }
+    }
+#else /* !VBOX_WITH_HDA_51_SURROUND */
+    if (   pCfg->cChannels != 1 /* Mono */
+        && pCfg->cChannels != 2 /* Stereo */)
+    {
+        rc = VERR_NOT_SUPPORTED;
+    }
+#endif
+
+    if (RT_FAILURE(rc))
+    {
+        LogRel(("HDA: Unsupported channel count (%RU8), falling back to stereo channels\n", pCfg->cChannels));
+        pCfg->cChannels = 2;
+    }
+
+    do
+    {
+        if (fUseFront)
+        {
+            if (!RTStrPrintf(pCfg->szName, RT_ELEMENTS(pCfg->szName), "Front"))
+            {
+                rc = VERR_BUFFER_OVERFLOW;
+                break;
+            }
+
+            pCfg->DestSource.Dest = PDMAUDIOPLAYBACKDEST_FRONT;
+            pCfg->cChannels       = 2;
+            rc = hdaCodecRemoveStream(pThis->pCodec,  PDMAUDIOMIXERCTL_FRONT);
+            if (RT_SUCCESS(rc))
+                rc = hdaCodecAddStream(pThis->pCodec, PDMAUDIOMIXERCTL_FRONT, pCfg);
+        }
+
+#ifdef VBOX_WITH_HDA_51_SURROUND
+        if (   RT_SUCCESS(rc)
+            && (fUseCenter || fUseLFE))
+        {
+            if (!RTStrPrintf(pCfg->szName, RT_ELEMENTS(pCfg->szName), "Center/LFE"))
+            {
+                rc = VERR_BUFFER_OVERFLOW;
+                break;
+            }
+
+            pCfg->DestSource.Dest = PDMAUDIOPLAYBACKDEST_CENTER_LFE;
+            pCfg->cChannels       = (fUseCenter && fUseLFE) ? 2 : 1;
+            rc = hdaCodecRemoveStream(pThis->pCodec,  PDMAUDIOMIXERCTL_CENTER_LFE);
+            if (RT_SUCCESS(rc))
+                rc = hdaCodecAddStream(pThis->pCodec, PDMAUDIOMIXERCTL_CENTER_LFE, pCfg);
+
+            RTStrFree(pszName);
+        }
+
+        if (   RT_SUCCESS(rc)
+            && fUseRear)
+        {
+            if (!RTStrPrintf(pCfg->szName, RT_ELEMENTS(pCfg->szName), "Rear"))
+            {
+                rc = VERR_BUFFER_OVERFLOW;
+                break;
+            }
+
+            pCfg->DestSource.Dest = PDMAUDIOPLAYBACKDEST_REAR;
+            pCfg->cChannels       = 2;
+            rc = hdaCodecRemoveStream(pThis->pCodec,  PDMAUDIOMIXERCTL_REAR);
+            if (RT_SUCCESS(rc))
+                rc = hdaCodecAddStream(pThis->pCodec, PDMAUDIOMIXERCTL_REAR, pCfg);
+        }
+#endif /* VBOX_WITH_HDA_51_SURROUND */
+
+    } while (0);
+
+    return rc;
+}
+
+static int hdaAddStreamIn(PHDASTATE pThis, PPDMAUDIOSTREAMCFG pCfg)
+{
+    AssertPtrReturn(pThis, VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfg,  VERR_INVALID_POINTER);
+
+    AssertReturn(pCfg->enmDir == PDMAUDIODIR_IN, VERR_INVALID_PARAMETER);
+
+    LogFlowFunc(("Stream=%s\n", pCfg->szName));
+
+    int rc;
+
+    switch (pCfg->DestSource.Source)
+    {
+        case PDMAUDIORECSOURCE_LINE:
+        {
+            pCfg->DestSource.Source = PDMAUDIORECSOURCE_LINE;
+            pCfg->cChannels         = 2;
+            rc = hdaCodecRemoveStream(pThis->pCodec,  PDMAUDIOMIXERCTL_LINE_IN);
+            if (RT_SUCCESS(rc))
+                rc = hdaCodecAddStream(pThis->pCodec, PDMAUDIOMIXERCTL_LINE_IN, pCfg);
+            break;
+        }
+#ifdef VBOX_WITH_HDA_MIC_IN
+        case PDMAUDIORECSOURCE_MIC:
+        {
+            pCfg->DestSource.Source = PDMAUDIORECSOURCE_MIC;
+            pCfg->cChannels         = 2;
+            rc = hdaCodecRemoveStream(pThis->pCodec,  PDMAUDIOMIXERCTL_MIC_IN);
+            if (RT_SUCCESS(rc))
+                rc = hdaCodecAddStream(pThis->pCodec, PDMAUDIOMIXERCTL_MIC_IN, pCfg);
+            break;
+        }
+#endif
+        default:
+            rc = VERR_NOT_SUPPORTED;
+            break;
+    }
+
+    return rc;
+}
+#endif /* IN_RING3 */
 
 static int hdaRegWriteSDFMT(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
 {
 #ifdef IN_RING3
+    if (HDA_REG_IND(pThis, iReg) == u32Value) /* Value already set? */
+        return VINF_SUCCESS;
+
     PDMAUDIOSTREAMCFG strmCfg;
+    RT_ZERO(strmCfg);
+
     int rc = hdaSDFMTToStrmCfg(u32Value, &strmCfg);
     if (RT_FAILURE(rc))
         return VINF_SUCCESS; /* Always return success to the MMIO handler. */
 
-    if (HDA_REG_IND(pThis, iReg) == u32Value) /* Value already set? */
-        return VINF_SUCCESS;
-
     PHDASTREAM pStrmSt = hdaStreamFromSD(pThis, HDA_SD_NUM_FROM_REG(pThis, FMT, iReg));
     if (!pStrmSt)
@@ -2350 +2651 @@
     AssertRC(rc);
 
-    LogFlowFunc(("[SD%RU8]: Hz=%RU32, Channels=%RU8, enmFmt=%RU32\n",
-                 pStrmSt->u8SD, strmCfg.uHz, strmCfg.cChannels, strmCfg.enmFormat));
-
-    PDMAUDIOMIXERCTL enmMixerCtl;
-#ifdef VBOX_WITH_HDA_51_SURROUND
-# error "Implement me!"
-#endif
-
-    enmMixerCtl = PDMAUDIOMIXERCTL_FRONT;
-    strmCfg.DestSource.Dest = PDMAUDIOPLAYBACKDEST_FRONT;
+    LogFunc(("[SD%RU8]: Hz=%RU32, Channels=%RU8, enmFmt=%RU32\n",
+             pStrmSt->u8SD, strmCfg.uHz, strmCfg.cChannels, strmCfg.enmFormat));
+
+    /* Set audio direction. */
+    strmCfg.enmDir = hdaGetDirFromSD(pStrmSt->u8SD);
+
+    /*
+     * Initialize the stream mapping in any case, regardless if
+     * we support surround audio or not. This is needed to handle
+     * the supported channels within a single audio stream, e.g. mono/stereo.
+     *
+     * In other words, the stream mapping *always* knowns the real
+     * number of channels in a single audio stream.
+     */
+    rc = hdaStreamMapInit(&pStrmSt->State.Mapping, &strmCfg);
+    AssertRC(rc);
 
     if (RT_SUCCESS(rc))
     {
+        int rc2;
         PHDADRIVER pDrv;
         RTListForEach(&pThis->lstDrv, pDrv, HDADRIVER, Node)
         {
-            int rc2 = hdaCodecRemoveStream(pThis->pCodec, enmMixerCtl);
-            if (RT_SUCCESS(rc2))
-                rc2 = hdaCodecAddStream(pThis->pCodec, enmMixerCtl, &strmCfg);
+            switch (strmCfg.enmDir)
+            {
+                case PDMAUDIODIR_OUT:
+                    rc2 = hdaAddStreamOut(pThis, &strmCfg);
+                    break;
+
+                case PDMAUDIODIR_IN:
+                    rc2 = hdaAddStreamIn(pThis, &strmCfg);
+                    break;
+
+                default:
+                    rc2 = VERR_NOT_SUPPORTED;
+                    AssertFailed();
+                    break;
+            }
 
             if (   RT_FAILURE(rc2)
@@ -2506 +2826 @@
     {
 #ifdef IN_RING3
-        PFNHDACODECVERBPROCESSOR    pfn = NULL;
-        uint64_t                    resp;
-        uint32_t cmd = HDA_REG(pThis, IC);
+        uint32_t uCmd = HDA_REG(pThis, IC);
+
         if (HDA_REG(pThis, CORBWP) != HDA_REG(pThis, CORBRP))
         {
             /*
-             * 3.4.3 defines behavior of immediate Command status register.
+             * 3.4.3: Defines behavior of immediate Command status register.
              */
-            LogRel(("guest attempted process immediate verb (%x) with active CORB\n", cmd));
+            LogRel(("HDA: Guest attempted process immediate verb (%x) with active CORB\n", uCmd));
             return rc;
         }
+
         HDA_REG(pThis, IRS) = HDA_REG_FIELD_FLAG_MASK(IRS, ICB);  /* busy */
-        LogFunc(("IC:%x\n", cmd));
-
-        rc = pThis->pCodec->pfnLookup(pThis->pCodec,
-                                      HDA_CODEC_CMD(cmd, 0 /* LUN */),
-                                      &pfn);
-        if (RT_FAILURE(rc))
-            AssertRCReturn(rc, rc);
-        rc = pfn(pThis->pCodec,
-                 HDA_CODEC_CMD(cmd, 0 /* LUN */), &resp);
-        if (RT_FAILURE(rc))
-            AssertRCReturn(rc, rc);
-
-        HDA_REG(pThis, IR) = (uint32_t)resp;
-        LogFunc(("IR:%x\n", HDA_REG(pThis, IR)));
-        HDA_REG(pThis, IRS) = HDA_REG_FIELD_FLAG_MASK(IRS, IRV);  /* result is ready  */
+
+        uint64_t uResp;
+        int rc2 = pThis->pCodec->pfnLookup(pThis->pCodec,
+                                           HDA_CODEC_CMD(uCmd, 0 /* LUN */), &uResp);
+        if (RT_FAILURE(rc2))
+            LogFunc(("Codec lookup failed with rc=%Rrc\n", rc2));
+
+        HDA_REG(pThis, IR)   = (uint32_t)uResp; /** @todo r=andy Do we need a 64-bit response? */
+        HDA_REG(pThis, IRS)  = HDA_REG_FIELD_FLAG_MASK(IRS, IRV);  /* result is ready  */
         HDA_REG(pThis, IRS) &= ~HDA_REG_FIELD_FLAG_MASK(IRS, ICB); /* busy is clear */
 #else /* !IN_RING3 */
@@ -2589 +2903 @@
 
             /* Also make sure to handle the DMA position enable bit. */
-            pThis->fDMAPosition = pThis->au32Regs[iRegMem] & RT_BIT_32(0);
+            pThis->fDMAPosition = RT_BOOL(pThis->u64DPBase & RT_BIT_64(0));
             LogRel(("HDA: %s DMA position buffer\n", pThis->fDMAPosition ? "Enabled" : "Disabled"));
             break;
@@ -2670 +2984 @@
     AssertPtrReturn(pBDLE,   VERR_INVALID_POINTER);
     AssertReturn(u64BaseDMA, VERR_INVALID_PARAMETER);
+
+    if (!u64BaseDMA)
+    {
+        LogRel2(("HDA: Unable to fetch BDLE #%RU16 - no base DMA address set (yet)\n", u16Entry));
+        return VERR_NOT_FOUND;
+    }
     /** @todo Compare u16Entry with LVI. */
 
@@ -2686 +3006 @@
         return VERR_INVALID_STATE;
 
-    pBDLE->fIntOnCompletion  = (*(uint32_t *)&uBundleEntry[12]) & 0x1;
+    pBDLE->fIntOnCompletion  = (*(uint32_t *)&uBundleEntry[12]) & RT_BIT(0);
 
     return VINF_SUCCESS;
@@ -2699 +3019 @@
 DECLINLINE(uint32_t) hdaStreamGetTransferSize(PHDASTATE pThis, PHDASTREAM pStrmSt, uint32_t cbMax)
 {
-    AssertPtrReturn(pThis, 0);
+    AssertPtrReturn(pThis,   0);
     AssertPtrReturn(pStrmSt, 0);
 
@@ -2707 +3027 @@
     PHDABDLE pBDLE = &pStrmSt->State.BDLE;
 
-    uint32_t cbFree = pStrmSt->u32CBL - HDA_STREAM_REG(pThis, LPIB, pStrmSt->u8SD);
+    uint32_t u32LPIB = HDA_STREAM_REG(pThis, LPIB, pStrmSt->u8SD);
+    Assert(u32LPIB <= pStrmSt->u32CBL);
+
+    uint32_t cbFree = pStrmSt->u32CBL - u32LPIB; /** @todo Convert samples to bytes? */
     if (cbFree)
     {
@@ -2771 +3094 @@
 }
 
+#ifdef IN_RING3
+/**
+ * Initializes a stream mapping structure according to the given stream configuration.
+ *
+ * @return  IPRT status code.
+ * @param   pMapping            Pointer to mapping to initialize.
+ * @param   pCfg                Pointer to stream configuration to use.
+ */
+static int hdaStreamMapInit(PHDASTREAMMAPPING pMapping, PPDMAUDIOSTREAMCFG pCfg)
+{
+    AssertPtrReturn(pMapping, VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfg,     VERR_INVALID_POINTER);
+
+    AssertReturn(pCfg->cChannels, VERR_INVALID_PARAMETER);
+
+    hdaStreamMapReset(pMapping);
+
+    pMapping->paChannels = (PPDMAUDIOSTREAMCHANNEL)RTMemAlloc(sizeof(PDMAUDIOSTREAMCHANNEL) * pCfg->cChannels);
+    if (!pMapping->paChannels)
+        return VERR_NO_MEMORY;
+
+    PDMPCMPROPS Props;
+    int rc = DrvAudioStreamCfgToProps(pCfg, &Props);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    Assert(RT_IS_POWER_OF_TWO(Props.cBits));
+
+    /** @todo We assume all channels in a stream have the same format. */
+    PPDMAUDIOSTREAMCHANNEL pChan = pMapping->paChannels;
+    for (uint8_t i = 0; i < pCfg->cChannels; i++)
+    {
+        pChan->uChannel = i;
+        pChan->cbStep   = (Props.cBits / 2);
+        pChan->cbFrame  = pChan->cbStep * pCfg->cChannels;
+        pChan->cbFirst  = i * pChan->cbStep;
+        pChan->cbOff    = pChan->cbFirst;
+
+        int rc2 = hdaStreamChannelDataInit(&pChan->Data, PDMAUDIOSTREAMCHANNELDATA_FLAG_NONE);
+        if (RT_SUCCESS(rc))
+            rc = rc2;
+
+        if (RT_FAILURE(rc))
+            break;
+
+        pChan++;
+    }
+
+    if (RT_SUCCESS(rc))
+        rc = RTCircBufCreate(&pMapping->pCircBuf, _4K);
+
+    if (RT_SUCCESS(rc))
+    {
+        pMapping->cChannels = pCfg->cChannels;
+#ifdef VBOX_WITH_HDA_INTERLEAVING_STREAMS_SUPPORT
+        pMapping->enmLayout = PDMAUDIOSTREAMLAYOUT_INTERLEAVED;
+#else
+        pMapping->enmLayout = PDMAUDIOSTREAMLAYOUT_NON_INTERLEAVED;
+#endif
+    }
+
+    return rc;
+}
+
+/**
+ * Destroys a given stream mapping.
+ *
+ * @param   pMapping            Pointer to mapping to destroy.
+ */
+static void hdaStreamMapDestroy(PHDASTREAMMAPPING pMapping)
+{
+    hdaStreamMapReset(pMapping);
+
+    if (pMapping->pCircBuf)
+    {
+        RTCircBufDestroy(pMapping->pCircBuf);
+        pMapping->pCircBuf = NULL;
+    }
+}
+
+/**
+ * Resets a given stream mapping.
+ *
+ * @param   pMapping            Pointer to mapping to reset.
+ */
+static void hdaStreamMapReset(PHDASTREAMMAPPING pMapping)
+{
+    AssertPtrReturnVoid(pMapping);
+
+    pMapping->enmLayout = PDMAUDIOSTREAMLAYOUT_UNKNOWN;
+
+    if (pMapping->cChannels)
+    {
+        for (uint8_t i = 0; i < pMapping->cChannels; i++)
+            hdaStreamChannelDataDestroy(&pMapping->paChannels[i].Data);
+
+        AssertPtr(pMapping->paChannels);
+        RTMemFree(pMapping->paChannels);
+        pMapping->paChannels = NULL;
+
+        pMapping->cChannels = 0;
+    }
+}
+#endif /* IN_RING3 */
+
 DECLINLINE(bool) hdaStreamNeedsNextBDLE(PHDASTATE pThis, PHDASTREAM pStrmSt)
 {
@@ -2793 +3221 @@
                  pStrmSt->u8SD, u32LPIB, pStrmSt->u32CBL, fCBLLimitReached, fNeedsNextBDLE, pBDLE));
 
-    if (fCBLLimitReached)
-    {
-        /* Reset LPIB register. */
-        u32LPIB -= RT_MIN(u32LPIB, pStrmSt->u32CBL);
-        hdaStreamUpdateLPIB(pThis, pStrmSt, u32LPIB);
-    }
-
     return fNeedsNextBDLE;
 }
@@ -2811 +3232 @@
 
     Assert(cbInc <= pStrmSt->u16FIFOS);
+
+    if (!cbInc) /* Nothing to do? Bail out early. */
+        return;
 
     PHDABDLE pBDLE = &pStrmSt->State.BDLE;
@@ -2821 +3245 @@
     if (pBDLE->State.cbBelowFIFOW == 0) /* Did we hit (or exceed) the watermark? */
     {
-        const uint32_t u32LPIB = RT_MIN(HDA_STREAM_REG(pThis, LPIB, pStrmSt->u8SD) + cbInc,
-                                        pStrmSt->u32CBL);
+        uint32_t u32LPIB = HDA_STREAM_REG(pThis, LPIB, pStrmSt->u8SD);
+
+        AssertMsg(((u32LPIB + cbInc) <= pStrmSt->u32CBL),
+                  ("[SD%RU8] Increment (%RU32) exceeds CBL (%RU32): LPIB (%RU32)\n",
+                   pStrmSt->u8SD, cbInc, pStrmSt->u32CBL, u32LPIB));
+
+        u32LPIB = RT_MIN(u32LPIB + cbInc, pStrmSt->u32CBL);
 
         LogFlowFunc(("[SD%RU8]: LPIB: %RU32 -> %RU32, CBL=%RU32\n",
@@ -2833 +3262 @@
 }
 
-static bool hdaStreamTransferIsComplete(PHDASTATE pThis, PHDASTREAM pStrmSt)
+static bool hdaStreamTransferIsComplete(PHDASTATE pThis, PHDASTREAM pStream, bool *pfInterrupt)
 {
     AssertPtrReturn(pThis,   true);
-    AssertPtrReturn(pStrmSt, true);
-
+    AssertPtrReturn(pStream, true);
+
+    bool fInterrupt  = false;
     bool fIsComplete = false;
 
-    PHDABDLE       pBDLE   = &pStrmSt->State.BDLE;
-    const uint32_t u32LPIB = HDA_STREAM_REG(pThis, LPIB, pStrmSt->u8SD);
-
-    if (   pBDLE->State.u32BufOff >= pBDLE->u32BufSize
-        || u32LPIB                >= pStrmSt->u32CBL)
+    PHDABDLE       pBDLE   = &pStream->State.BDLE;
+    const uint32_t u32LPIB = HDA_STREAM_REG(pThis, LPIB, pStream->u8SD);
+
+    /* Check if the current BDLE entry is complete (full). */
+    if (pBDLE->State.u32BufOff >= pBDLE->u32BufSize)
     {
         Assert(pBDLE->State.u32BufOff <= pBDLE->u32BufSize);
-        Assert(u32LPIB                <= pStrmSt->u32CBL);
 
         if (/* IOC (Interrupt On Completion) bit set? */
@@ -2855 +3284 @@
            )
         {
-            /**
-             * Set the BCIS (Buffer Completion Interrupt Status) flag as the
-             * last byte of data for the current descriptor has been fetched
-             * from memory and put into the DMA FIFO.
-             *
-             ** @todo More carefully investigate BCIS flag.
-             *
-             * Speech synthesis works fine on Mac Guest if this bit isn't set
-             * but in general sound quality gets worse.
-             */
-            HDA_STREAM_REG(pThis, STS, pStrmSt->u8SD) |= HDA_REG_FIELD_FLAG_MASK(SDSTS, BCIS);
+            LogFlowFunc(("[SD%RU8]: %R[bdle] => COMPLETE\n",  pStream->u8SD, pBDLE));
 
             /*
@@ -2871 +3290 @@
              * we need to generate an interrupt.
              */
-            if (HDA_STREAM_REG(pThis, CTL, pStrmSt->u8SD) & HDA_REG_FIELD_FLAG_MASK(SDCTL, ICE))
-                hdaProcessInterrupt(pThis);
+            if (HDA_STREAM_REG(pThis, CTL, pStream->u8SD) & HDA_REG_FIELD_FLAG_MASK(SDCTL, ICE))
+                fInterrupt = true;
         }
 
@@ -2878 +3297 @@
     }
 
-    LogFlowFunc(("[SD%RU8]: u32LPIB=%RU32, CBL=%RU32, %R[bdle] => %s\n",
-                 pStrmSt->u8SD, u32LPIB, pStrmSt->u32CBL, pBDLE, fIsComplete ? "COMPLETE" : "INCOMPLETE"));
+    if (pfInterrupt)
+        *pfInterrupt = fInterrupt;
+
+    LogFlowFunc(("[SD%RU8]: u32LPIB=%RU32, CBL=%RU32, fIsComplete=%RTbool, fInterrupt=%RTbool, %R[bdle]\n",
+                 pStream->u8SD, u32LPIB, pStream->u32CBL, fIsComplete, fInterrupt, pBDLE));
 
     return fIsComplete;
@@ -2895 +3317 @@
     /* pcbRead is optional. */
 
-    PHDABDLE pBDLE = &pStrmSt->State.BDLE;
-
     int rc;
     uint32_t cbRead = 0;
-    uint32_t cbBuf  = hdaStreamGetTransferSize(pThis, pStrmSt, cbMax);
-
-    LogFlowFunc(("cbBuf=%RU32, %R[bdle]\n", cbBuf, pBDLE));
-
-    if (!cbBuf)
-    {
-        /* Nothing to write, bail out. */
-        rc = VINF_EOF;
-    }
-    else
-    {
-        rc = AudioMixerProcessSinkIn(pStrmSt->pSink, AUDMIXOP_BLEND, pBDLE->State.au8FIFO, cbBuf, &cbRead);
-        if (RT_SUCCESS(rc))
+
+    do
+    {
+        PHDABDLE pBDLE = &pStrmSt->State.BDLE;
+
+        uint32_t cbBuf = hdaStreamGetTransferSize(pThis, pStrmSt, cbMax);
+        Log3Func(("cbBuf=%RU32, %R[bdle]\n", cbBuf, pBDLE));
+
+        if (!cbBuf)
         {
-            Assert(cbRead);
-            Assert(cbRead == cbBuf);
-            Assert(cbRead <= pBDLE->u32BufSize - pBDLE->State.u32BufOff);
-
-            /*
-             * Write to the BDLE's DMA buffer.
-             */
-            rc = PDMDevHlpPCIPhysWrite(pThis->CTX_SUFF(pDevIns),
-                                       pBDLE->u64BufAdr + pBDLE->State.u32BufOff,
-                                       pBDLE->State.au8FIFO, cbRead);
-            AssertRC(rc);
-
-            if (pBDLE->State.cbBelowFIFOW + cbRead > hdaStreamGetFIFOW(pThis, pStrmSt))
-            {
-                pBDLE->State.u32BufOff    += cbRead;
-                pBDLE->State.cbBelowFIFOW  = 0;
-                //hdaBackendReadTransferReported(pBDLE, cbDMAData, cbRead, &cbRead, pcbAvail);
-            }
-            else
-            {
-                pBDLE->State.u32BufOff    += cbRead;
-                pBDLE->State.cbBelowFIFOW += cbRead;
-                Assert(pBDLE->State.cbBelowFIFOW <= hdaStreamGetFIFOW(pThis, pStrmSt));
-                //hdaBackendTransferUnreported(pThis, pBDLE, pStreamDesc, cbRead, pcbAvail);
-
-                rc = VERR_NO_DATA;
-            }
+            rc = VINF_EOF;
+            break;
         }
-    }
-
-    Assert(cbRead <= pStrmSt->u16FIFOS);
+
+        rc = AudioMixerSinkRead(pStrmSt->pSink, AUDMIXOP_BLEND, pBDLE->State.au8FIFO, cbBuf, &cbRead);
+        if (RT_FAILURE(rc))
+            break;
+
+        if (!cbRead)
+        {
+            rc = VINF_EOF;
+            break;
+        }
+
+        /* Sanity checks. */
+        Assert(cbRead <= cbBuf);
+        Assert(cbRead <= pBDLE->u32BufSize - pBDLE->State.u32BufOff);
+        Assert(cbRead <= pStrmSt->u16FIFOS);
+
+        /*
+         * Write to the BDLE's DMA buffer.
+         */
+        rc = PDMDevHlpPCIPhysWrite(pThis->CTX_SUFF(pDevIns),
+                                   pBDLE->u64BufAdr + pBDLE->State.u32BufOff,
+                                   pBDLE->State.au8FIFO, cbRead);
+        AssertRC(rc);
+
+        if (pBDLE->State.cbBelowFIFOW + cbRead > hdaStreamGetFIFOW(pThis, pStrmSt))
+        {
+            pBDLE->State.u32BufOff    += cbRead;
+            pBDLE->State.cbBelowFIFOW  = 0;
+            //hdaBackendReadTransferReported(pBDLE, cbDMAData, cbRead, &cbRead, pcbAvail);
+        }
+        else
+        {
+            pBDLE->State.u32BufOff    += cbRead;
+            pBDLE->State.cbBelowFIFOW += cbRead;
+            Assert(pBDLE->State.cbBelowFIFOW <= hdaStreamGetFIFOW(pThis, pStrmSt));
+            //hdaBackendTransferUnreported(pThis, pBDLE, pStreamDesc, cbRead, pcbAvail);
+
+            rc = VERR_NO_DATA;
+        }
+
+    } while (0);
 
     if (RT_SUCCESS(rc))
@@ -2951 +3380 @@
     }
 
-    LogFunc(("Returning cbRead=%RU32, rc=%Rrc\n", cbRead, rc));
+    Log3Func(("Returning cbRead=%RU32, rc=%Rrc\n", cbRead, rc));
     return rc;
 }
@@ -2965 +3394 @@
 
     uint32_t cbWritten = 0;
-    uint32_t cbData    = hdaStreamGetTransferSize(pThis, pStrmSt, cbMax);
-
-    LogFlowFunc(("cbData=%RU32, %R[bdle]\n", cbData, pBDLE));
+    uint32_t cbToWrite = hdaStreamGetTransferSize(pThis, pStrmSt, cbMax);
+
+    Log3Func(("cbToWrite=%RU32, %R[bdle]\n", cbToWrite, pBDLE));
 
     /*
@@ -2974 +3403 @@
      */
     int rc;
-    if (!cbData)
+    if (!cbToWrite)
     {
         rc = VINF_EOF;
@@ -2980 +3409 @@
     else
     {
+        void    *pvBuf = pBDLE->State.au8FIFO + pBDLE->State.cbBelowFIFOW;
+        Assert(cbToWrite >= pBDLE->State.cbBelowFIFOW);
+        uint32_t cbBuf = cbToWrite - pBDLE->State.cbBelowFIFOW;
+
         /*
          * Read from the current BDLE's DMA buffer.
@@ -2985 +3418 @@
         rc = PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns),
                                pBDLE->u64BufAdr + pBDLE->State.u32BufOff,
-                               pBDLE->State.au8FIFO + pBDLE->State.cbBelowFIFOW, cbData);
+                               pvBuf, cbBuf);
         AssertRC(rc);
-
-#if 0
+#if defined (RT_OS_LINUX) && defined(DEBUG)
         RTFILE fh;
-        RTFileOpen(&fh, "c:\\temp\\hdaWriteAudio.pcm",
+        RTFileOpen(&fh, "/tmp/hdaWriteAudio.pcm",
                    RTFILE_O_OPEN_CREATE | RTFILE_O_APPEND | RTFILE_O_WRITE | RTFILE_O_DENY_NONE);
-        RTFileWrite(fh, pBDLE->State.au8FIFO + pBDLE->State.cbBelowFIFOW, cbData, NULL);
+        RTFileWrite(fh, pvBuf, cbBuf, NULL);
         RTFileClose(fh);
 #endif
 
 #ifdef VBOX_WITH_STATISTICS
-        STAM_COUNTER_ADD(&pThis->StatBytesRead, cbData);
+        STAM_COUNTER_ADD(&pThis->StatBytesRead, cbBuf);
 #endif
         /*
          * Write to audio backend. We should ensure that we have enough bytes to copy to the backend.
          */
-        uint32_t cbToWrite = cbData + pBDLE->State.cbBelowFIFOW;
-        if (cbToWrite >= hdaStreamGetFIFOW(pThis, pStrmSt))
+        if (cbBuf >= hdaStreamGetFIFOW(pThis, pStrmSt))
         {
-            uint32_t cbWrittenToStream;
+            PHDASTREAMMAPPING pMapping            = &pStrmSt->State.Mapping;
+
+            /** @todo Which channel is which? */
+#ifdef VBOX_WITH_HDA_INTERLEAVING_STREAMS_SUPPORT
+            PPDMAUDIOSTREAMCHANNEL pChanFront     = &pMapping->paChannels[0];
+#endif
+#ifdef VBOX_WITH_HDA_51_SURROUND
+            PPDMAUDIOSTREAMCHANNEL pChanCenterLFE = &pMapping->paChannels[2]; /** @todo FIX! */
+            PPDMAUDIOSTREAMCHANNEL pChanRear      = &pMapping->paChannels[4]; /** @todo FIX! */
+#endif
             int rc2;
 
-            PHDADRIVER pDrv;
-            RTListForEach(&pThis->lstDrv, pDrv, HDADRIVER, Node)
-            {
-                if (pDrv->pConnector->pfnIsActiveOut(pDrv->pConnector, pDrv->Front.pGstStrm))
-                {
+            void  *pvDataFront = NULL;
+            size_t cbDataFront;
 #ifdef VBOX_WITH_HDA_INTERLEAVING_STREAMS_SUPPORT
-                    /** @todo Needs more hacking first. */
-# if 0
-                    static int16_t restBuf = 0;
-                    static size_t cbRestOff = 0;
-
-                    uint8_t temp[HDA_SDONFIFO_256B + 1];
-
-                    uint8_t *pu8Src = &pBDLE->State.au8FIFO[0];
-                    uint8_t *pu8Dst = &temp[0];
-
-                    size_t cbSample = sizeof(int16_t) * 2;
-
-                    size_t cbProc     = 0;
-                    size_t cbToSkip   = 5 * cbSample;
-                    size_t cbSkipSize = cbToSkip;
-                    size_t cbDstSize  = 0;
-
-                    while (cbProc < cbToWrite)
-                    {
-                        memcpy(pu8Dst, pu8Src, cbSample);
-
-                        cbSkipSize = RT_MIN(cbToSkip, cbToWrite - cbProc);
-
-                        pu8Src += 10;
-                        cbProc += cbSkipSize;
-
-                        pu8Dst    += 4;
-                        cbDstSize += cbSample;
-                    }
-
-                    /* Sanity. */
-                    AssertMsg(((cbDstSize * 8 /* Bit */) % 16) == 0, ("ASDF\n"));
-
-                    LogFlowFunc(("cbRest=%zu, cbToWrite=%zu, cbProc=%zu, cbDstSize=%zu\n",
-                                 0, cbToWrite, cbProc, cbDstSize));
-
-                    rc2 = pDrv->pConnector->pfnWrite(pDrv->pConnector, pDrv->Out.pStrmOut,
-                                                     temp, cbDstSize, &cbWrittenToStream);
-# if 1
-                    RTFILE fh;
-                    RTFileOpen(&fh, "/tmp/hdaWriteAudio.pcm",
-                               RTFILE_O_OPEN_CREATE | RTFILE_O_APPEND | RTFILE_O_WRITE | RTFILE_O_DENY_NONE);
-                    RTFileWrite(fh, temp, cbDstSize, NULL);
-                    RTFileClose(fh);
-# endif
-
-# else
-                    int16_t *pvStart;
-                    size_t cbAcqWrite;
-                    RTCircBufAcquireWriteBlock(pThis->pCircBuf, cbToWrite, (void **)&pvStart, &cbAcqWrite);
-
-                    uint8_t cChannels = 1;
-                    size_t cbSample = sizeof(int16_t);
-
-                    int16_t *pi16Src = (int16_t *)&pBDLE->State.au8FIFO[0];
-                    int16_t *pi16Dst = pvStart;
-
-                    size_t cbProcSrc     = 0;
-                    size_t cbProcDst     = 0;
-
-                    while (cbProcSrc < cbAcqWrite)
-                    {
-                        memcpy(pi16Dst, pi16Src, cbSample);
-
-                        pi16Src  += 6 * cChannels;
-                        pi16Dst  += cChannels;
-
-                        cbProcSrc += RT_MIN(cbAcqWrite - cbProcSrc, 6 * cbSample);
-                        cbProcDst += cbSample;
-
-                        Assert(cbProcSrc <= cbAcqWrite);
-                        size_t cbLeft = cbAcqWrite - cbProcSrc;
-                        LogFlowFunc(("cbProcSrc=%zu, cbProcDst=%zu, cbLeft=%zu\n", cbProcSrc, cbProcDst, cbLeft));
-                        if (   cbLeft
-                            && cbLeft < cChannels)
-                        {
-                            LogFlowFunc(("%zu bytes left ...\n", cbAcqWrite - cbProcSrc));
-                            break;
-                        }
-                    }
-
-                    RTCircBufReleaseWriteBlock(pThis->pCircBuf, cbProcDst);
-
-                    LogFlowFunc(("cbAcqWrite=%zu, cbToWrite=%zu, cbProcSrc=%zu, cbProcDst=%zu\n",
-                                 cbAcqWrite, cbToWrite, cbProcSrc, cbProcDst));
-
-                    size_t cbAcqRead = 0;
-                    RTCircBufAcquireReadBlock(pThis->pCircBuf, _4K, (void **)&pvStart, &cbAcqRead);
-# if 1
-                    RTFILE fh;
-                    RTFileOpen(&fh, "/tmp/hdaWriteAudio.pcm",
-                               RTFILE_O_OPEN_CREATE | RTFILE_O_APPEND | RTFILE_O_WRITE | RTFILE_O_DENY_NONE);
-                    RTFileWrite(fh, pvStart, cbAcqRead, NULL);
-                    RTFileClose(fh);
-# endif
-                    rc2 = pDrv->pConnector->pfnWrite(pDrv->pConnector, pDrv->Front.pGstStrm,
-                                                     pvStart, cbAcqRead, &cbWrittenToStream);
-
-                    /** @todo Add support for writing to center/LFE + rear. */
-
-                    RTCircBufReleaseReadBlock(pThis->pCircBuf, cbAcqRead);
-# endif
-
-#else  /* !VBOX_WITH_HDA_INTERLEAVING_STREAMS_SUPPORT */
-                    rc2 = pDrv->pConnector->pfnWrite(pDrv->pConnector, pDrv->Front.pGstStrm,
-                                                     pBDLE->State.au8FIFO, cbToWrite, &cbWrittenToStream);
-#endif /* VBOX_WITH_HDA_INTERLEAVING_STREAMS_SUPPORT */
-                    if (RT_SUCCESS(rc2))
-                    {
-                        if (cbWrittenToStream < cbToWrite) /* Lagging behind? */
-                            LogFlowFunc(("\tLUN#%RU8: Warning: Only written %RU32 / %RU32 bytes, expect lags\n",
-                                         pDrv->uLUN, cbWrittenToStream, cbToWrite));
-                    }
-                }
-                else /* Stream disabled, not fatal. */
-                {
-                    cbWrittenToStream = 0;
-                    rc2 = VERR_NOT_AVAILABLE;
-                    /* Keep going. */
-                }
-
-                LogFlowFunc(("\tLUN#%RU8: cbToWrite=%RU32, cbWrittenToStream=%RU32, rc=%Rrc\n",
-                             pDrv->uLUN, cbToWrite, cbWrittenToStream, rc2));
-            }
+            rc2 = hdaStreamChannelExtract(pChanFront, pvBuf, cbBuf);
+            AssertRC(rc2);
+
+            rc2 = hdaStreamChannelAcquireData(&pChanFront->Data, pvDataFront, &cbDataFront);
+            AssertRC(rc2);
+#else
+            /* Use stuff in the whole FIFO to use for the channel data. */
+            pvDataFront = pvBuf;
+            cbDataFront = cbBuf;
+#endif
+#ifdef VBOX_WITH_HDA_51_SURROUND
+            void  *pvDataCenterLFE;
+            size_t cbDataCenterLFE;
+            rc2 = hdaStreamChannelExtract(pChanCenterLFE, pvBuf, cbBuf);
+            AssertRC(rc2);
+
+            rc2 = hdaStreamChannelAcquireData(&pChanCenterLFE->Data, pvDataCenterLFE, &cbDataCenterLFE);
+            AssertRC(rc2);
+
+            void  *pvDataRear;
+            size_t cbDataRear;
+            rc2 = hdaStreamChannelExtract(pChanRear, pvBuf, cbBuf);
+            AssertRC(rc2);
+
+            rc2 = hdaStreamChannelAcquireData(&pChanRear->Data, pvDataRear, &cbDataRear);
+            AssertRC(rc2);
+#endif
+            /*
+             * Write data to according mixer sinks.
+             */
+            rc2 = AudioMixerSinkWrite(pThis->pSinkFront,     AUDMIXOP_COPY, pvDataFront,     cbDataFront,
+                                      NULL /* pcbWritten */);
+            AssertRC(rc2);
+#ifdef VBOX_WITH_HDA_51_SURROUND
+            rc2 = AudioMixerSinkWrite(pThis->pSinkCenterLFE, AUDMIXOP_COPY, pvDataCenterLFE, cbDataCenterLFE,
+                                      NULL /* pcbWritten */);
+            AssertRC(rc2);
+            rc2 = AudioMixerSinkWrite(pThis->pSinkRear,      AUDMIXOP_COPY, pvDataRear,      cbDataRear,
+                                      NULL /* pcbWritten */);
+            AssertRC(rc2);
+#endif
+
+#ifdef VBOX_WITH_HDA_INTERLEAVING_STREAMS_SUPPORT
+            hdaStreamChannelReleaseData(&pChanFront->Data);
+#endif
+#ifdef VBOX_WITH_HDA_51_SURROUND
+            hdaStreamChannelReleaseData(&pChanCenterLFE->Data);
+            hdaStreamChannelReleaseData(&pChanRear->Data);
+#endif
 
             /* Always report all data as being written;
@@ -3143 +3505 @@
             cbWritten = cbToWrite;
 
-            hdaBDLEUpdate(pBDLE, cbData, cbWritten);
+            hdaBDLEUpdate(pBDLE, cbToWrite, cbWritten);
         }
         else
@@ -3165 +3527 @@
     }
 
-    LogFunc(("Returning cbWritten=%RU32, rc=%Rrc\n", cbWritten, rc));
+    Log3Func(("Returning cbMax=%RU32, cbWritten=%RU32, rc=%Rrc\n", cbMax, cbWritten, rc));
     return rc;
 }
@@ -3223 +3585 @@
 }
 
-static DECLCALLBACK(int) hdaMixerAddStreamIn(PHDASTATE pThis, PAUDMIXSINK pSink, PPDMAUDIOSTREAMCFG pCfg)
+static DECLCALLBACK(int) hdaMixerAddStream(PHDASTATE pThis, PAUDMIXSINK pSink, PPDMAUDIOSTREAMCFG pCfg)
 {
     AssertPtrReturn(pThis, VERR_INVALID_POINTER);
@@ -3229 +3591 @@
     AssertPtrReturn(pCfg,  VERR_INVALID_POINTER);
 
-    AssertReturn(pCfg->enmDir == PDMAUDIODIR_IN, VERR_INVALID_PARAMETER);
-
-    LogFunc(("Sink=%s, Source=%ld\n", pSink->pszName, pCfg->DestSource.Source));
+    LogFunc(("Sink=%s, Stream=%s\n", pSink->pszName, pCfg->szName));
 
     int rc = VINF_SUCCESS;
@@ -3238 +3598 @@
     RTListForEach(&pThis->lstDrv, pDrv, HDADRIVER, Node)
     {
-        char *pszDesc;
-        if (RTStrAPrintf(&pszDesc, "[LUN#%RU8] %s", pDrv->uLUN, pCfg->pszName) <= 0)
+        int rc2 = VINF_SUCCESS;
+        PHDAMIXERSTREAM pStream;
+
+        if (pCfg->enmDir == PDMAUDIODIR_IN)
         {
-            rc = VERR_NO_MEMORY;
-            break;
+            switch (pCfg->DestSource.Source)
+            {
+                case PDMAUDIORECSOURCE_LINE:
+                    pStream = &pDrv->LineIn;
+                    break;
+#ifdef VBOX_WITH_HDA_MIC_IN
+                case PDMAUDIORECSOURCE_MIC:
+                    pStream = &pDrv->MicIn;
+                    break;
+#endif
+                default:
+                    rc2 = VERR_NOT_SUPPORTED;
+                    break;
+            }
         }
-
-        int rc2 = VINF_SUCCESS;
-        PHDAINPUTSTREAM pStream;
-        switch (pCfg->DestSource.Source)
+        else if (pCfg->enmDir == PDMAUDIODIR_OUT)
         {
-            case PDMAUDIORECSOURCE_LINE:
-                pStream = &pDrv->LineIn;
-                break;
-#ifdef VBOX_WITH_HDA_MIC_IN
-            case PDMAUDIORECSOURCE_MIC:
-                pStream = &pDrv->MicIn;
-                break;
-#endif
-            default:
-                rc2 = VERR_NOT_SUPPORTED;
-                break;
+            switch (pCfg->DestSource.Dest)
+            {
+                case PDMAUDIOPLAYBACKDEST_FRONT:
+                    pStream = &pDrv->Front;
+                    break;
+#ifdef VBOX_WITH_HDA_51_SURROUND
+                case PDMAUDIOPLAYBACKDEST_CENTER_LFE:
+                    pStream = &pDrv->CenterLFE;
+                    break;
+                case PDMAUDIOPLAYBACKDEST_REAR:
+                    pStream = &pDrv->Rear;
+                    break;
+#endif
+                default:
+                    rc2 = VERR_NOT_SUPPORTED;
+                    break;
+            }
         }
+        else
+            rc2 = VERR_NOT_SUPPORTED;
 
         if (RT_SUCCESS(rc2))
         {
-            PPDMAUDIOGSTSTRMIN pGstStrm;
-            PAUDMIXSTREAM      pMixStrm;
-
-            rc2 = pDrv->pConnector->pfnCreateIn(pDrv->pConnector, pszDesc, pCfg, &pGstStrm);
-            LogFlowFunc(("LUN#%RU8: Created input \"%s\", with rc=%Rrc\n", pDrv->uLUN, pszDesc, rc));
-            if (RT_SUCCESS(rc2))
-                rc2 = AudioMixerAddStreamIn(pSink, pDrv->pConnector, pGstStrm, 0 /* uFlags */, &pMixStrm);
-
+            PAUDMIXSTREAM pMixStrm;
+            rc2 = AudioMixerStreamCreate(pDrv->pConnector, pCfg, 0 /* fFlags */, &pMixStrm);
             if (RT_SUCCESS(rc2))
             {
-                pStream->pGstStrm = pGstStrm;
+                rc2 = AudioMixerSinkAddStream(pSink, pMixStrm);
+                LogFlowFunc(("LUN#%RU8: Added \"%s\" to sink, rc=%Rrc\n", pDrv->uLUN, pCfg->szName , rc2));
+            }
+
+            if (RT_SUCCESS(rc2))
                 pStream->pMixStrm = pMixStrm;
-            }
         }
 
         if (RT_SUCCESS(rc))
             rc = rc2;
-
-        RTStrFree(pszDesc);
-    }
-
-    LogFlowFuncLeaveRC(rc);
-    return rc;
-}
-
-static DECLCALLBACK(int) hdaMixerAddStreamOut(PHDASTATE pThis, PAUDMIXSINK pSink, PPDMAUDIOSTREAMCFG pCfg)
-{
-    AssertPtrReturn(pThis, VERR_INVALID_POINTER);
-    AssertPtrReturn(pSink, VERR_INVALID_POINTER);
-    AssertPtrReturn(pCfg,  VERR_INVALID_POINTER);
-
-    AssertReturn(pCfg->enmDir == PDMAUDIODIR_OUT, VERR_INVALID_PARAMETER);
-
-    LogFunc(("Sink=%s, Dest=%ld\n", pSink->pszName, pCfg->DestSource.Dest));
-
-    int rc = VINF_SUCCESS;
-
-    PHDADRIVER pDrv;
-    RTListForEach(&pThis->lstDrv, pDrv, HDADRIVER, Node)
-    {
-        char *pszDesc;
-        if (RTStrAPrintf(&pszDesc, "[LUN#%RU8] %s (%RU32Hz, %RU8 %s)",
-                         pDrv->uLUN, pCfg->pszName, pCfg->uHz, pCfg->cChannels, pCfg->cChannels > 1 ? "Channels" : "Channel") <= 0)
-        {
-            rc = VERR_NO_MEMORY;
-            break;
-        }
-
-        int rc2 = VINF_SUCCESS;
-        PHDAOUTPUTSTREAM pStream;
-        switch (pCfg->DestSource.Dest)
-        {
-            case PDMAUDIOPLAYBACKDEST_FRONT:
-                pStream = &pDrv->Front;
-                break;
-#ifdef VBOX_WITH_HDA_51_SURROUND
-            case PDMAUDIOPLAYBACKDEST_CENTER_LFE:
-                pStream = &pDrv->CenterLFE;
-                break;
-            case PDMAUDIOPLAYBACKDEST_REAR:
-                pStream = &pDrv->Rear;
-                break;
-#endif
-            default:
-                rc2 = VERR_NOT_SUPPORTED;
-                break;
-        }
-
-        if (RT_SUCCESS(rc2))
-        {
-            PPDMAUDIOGSTSTRMOUT pGstStrm;
-            PAUDMIXSTREAM       pMixStrm;
-
-            rc2 = pDrv->pConnector->pfnCreateOut(pDrv->pConnector, pszDesc, pCfg, &pGstStrm);
-            LogFlowFunc(("LUN#%RU8: Created output \"%s\", with rc=%Rrc\n", pDrv->uLUN, pszDesc, rc2));
-            if (RT_SUCCESS(rc2))
-                rc2 = AudioMixerAddStreamOut(pSink, pDrv->pConnector, pGstStrm, 0 /* uFlags */, &pMixStrm);
-
-            if (RT_SUCCESS(rc2))
-            {
-                pStream->pGstStrm = pGstStrm;
-                pStream->pMixStrm = pMixStrm;
-            }
-        }
-
-        if (RT_SUCCESS(rc))
-            rc = rc2;
-
-        RTStrFree(pszDesc);
     }
 
@@ -3379 +3683 @@
     if (pSink)
     {
-        if (pSink->enmDir == AUDMIXSINKDIR_INPUT)
-        {
-            rc = hdaMixerAddStreamIn(pThis, pSink, pCfg);
-        }
-        else if (pSink->enmDir == AUDMIXSINKDIR_OUTPUT)
-        {
-            rc = hdaMixerAddStreamOut(pThis, pSink, pCfg);
-        }
-        else
-        {
-            rc = VERR_INVALID_PARAMETER;
-            AssertFailed();
-        }
+        rc = hdaMixerAddStream(pThis, pSink, pCfg);
     }
     else
         rc = VERR_NOT_FOUND;
 
-    LogFlowFuncLeaveRC(rc);
+    LogFlowFunc(("Sink=%s, enmMixerCtl=%ld, rc=%Rrc\n", pSink->pszName, enmMixerCtl, rc));
     return rc;
 }
@@ -3416 +3708 @@
     if (pSink)
     {
-        if (pSink->enmDir == AUDMIXSINKDIR_INPUT)
-        {
-            /** @todo Remove streams. */
-        }
-        else if (pSink->enmDir == AUDMIXSINKDIR_OUTPUT)
-        {
-            /** @todo Remove streams. */
-        }
-        else
-        {
-            rc = VERR_INVALID_PARAMETER;
-            AssertFailed();
-        }
+        AudioMixerSinkRemoveAllStreams(pSink);
+        rc = VINF_SUCCESS;
     }
     else
         rc = VERR_NOT_FOUND;
 
-    LogFlowFuncLeaveRC(rc);
+    LogFlowFunc(("enmMixerCtl=%ld, rc=%Rrc\n", enmMixerCtl, rc));
     return rc;
 }
@@ -3455 +3736 @@
         /* Set the volume.
          * We assume that the codec already converted it to the correct range. */
-        rc = AudioMixerSetSinkVolume(pSink, pVol);
+        rc = AudioMixerSinkSetVolume(pSink, pVol);
     }
     else
@@ -3477 +3758 @@
     uint32_t cbOutMin = UINT32_MAX;
 
-    int rc;
-    PHDADRIVER pDrv;
-
     uint64_t cTicksNow     = TMTimerGet(pTimer);
-    uint64_t cTicksElapsed = cTicksNow  - pThis->uTimerTS;
+    uint64_t cTicksElapsed = cTicksNow - pThis->uTimerTS;
     uint64_t cTicksPerSec  = TMTimerGetFreq(pTimer);
 
@@ -3499 +3777 @@
     uint32_t cbCodecSamplesMin = cCodecSamplesMin << 1;
 
+#if 0
     /*
      * Process all driver nodes.
      */
+    PHDADRIVER pDrv;
     RTListForEach(&pThis->lstDrv, pDrv, HDADRIVER, Node)
     {
@@ -3520 +3800 @@
          * This is not the optimal solution, but as we have to deal with this on a timer-based approach
          * (until we have the audio callbacks) we need to have device' DMA engines running. */
-        if (!pDrv->pConnector->pfnIsValidOut(pDrv->pConnector, pDrv->Front.pGstStrm))
+        if (!AudioMixerStreamIsValid(pDrv->Front.pMixStrm))
         {
             /* Use the codec's (fixed) sampling rate. */
@@ -3527 +3807 @@
         }
 
-        const bool fIsActiveOut = pDrv->pConnector->pfnIsActiveOut(pDrv->pConnector, pDrv->Front.pGstStrm);
+        const bool fIsActiveOut = pDrv->pConnector->pfnIsActiveOut(pDrv->pConnector, pDrv->Front.pMixStrm->InOut.pOut);
         if (   RT_FAILURE(rc)
             || !fIsActiveOut)
         {
-            uint32_t cSamplesMin  = (int)((2 * cTicksElapsed * pDrv->Front.pGstStrm->Props.uHz + cTicksPerSec) / cTicksPerSec / 2);
-            uint32_t cbSamplesMin = AUDIOMIXBUF_S2B(&pDrv->Front.pGstStrm->MixBuf, cSamplesMin);
+            uint32_t cSamplesMin  = (int)((2 * cTicksElapsed * pDrv->Front.pMixStrm->InOut.pOut->Props.uHz + cTicksPerSec) / cTicksPerSec / 2);
+            uint32_t cbSamplesMin = AUDIOMIXBUF_S2B(&pDrv->Front.pMixStrm->InOut.pOut->MixBuf, cSamplesMin);
 
 #ifdef DEBUG_TIMER
@@ -3543 +3823 @@
         cbInMax  = RT_MAX(cbInMax, cbIn);
     }
+#else
+    AudioMixerSinkUpdate(pThis->pSinkFront);
+    cbOutMin = _4K; //cbCodecSamplesMin;
+    cbInMax  = _4K;
+#endif
 
 #ifdef DEBUG_TIMER
@@ -3552 +3837 @@
 
     /** @todo Determine the streams to be handled. */
-    PHDASTREAM pStrmStIn  = &pThis->aStreams[0];
-    PHDASTREAM pStrmStOut = &pThis->aStreams[4];
+    PHDASTREAM pStreamLineIn  = &pThis->aStreams[0];
+#ifdef VBOX_WITH_HDA_MIC_IN
+    /** @todo Anything to do for mic-in? */
+#endif
+    PHDASTREAM pStreamOut     = &pThis->aStreams[4];
 
     /* Do the actual device transfers. */
-    hdaTransfer(pThis, pStrmStOut, cbOutMin /* cbToProcess */, NULL /* pcbProcessed */);
-    hdaTransfer(pThis, pStrmStIn,  cbInMax  /* cbToProcess */, NULL /* pcbProcessed */);
+    hdaTransfer(pThis, pStreamOut,     cbOutMin /* cbToProcess */, NULL /* pcbProcessed */);
+    hdaTransfer(pThis, pStreamLineIn,  cbInMax  /* cbToProcess */, NULL /* pcbProcessed */);
 
     /* Kick the timer again. */
@@ -3617 +3905 @@
 #endif /* VBOX_WITH_AUDIO_CALLBACKS */
 
-static int hdaTransfer(PHDASTATE pThis, PHDASTREAM pStrmSt, uint32_t cbToProcess, uint32_t *pcbProcessed)
+static int hdaTransfer(PHDASTATE pThis, PHDASTREAM pStream, uint32_t cbToProcess, uint32_t *pcbProcessed)
 {
     AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
-    AssertPtrReturn(pStrmSt, VERR_INVALID_POINTER);
+    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
     /* pcbProcessed is optional. */
+
+    // 44100 / 200 Hz Timer = cbToProcess = 220,8
+    cbToProcess = 440; // FIFO SIZE
 
     if (ASMAtomicReadBool(&pThis->fInReset)) /* HDA controller in reset mode? Bail out. */
@@ -3633 +3924 @@
 
     bool fProceed = true;
-    int rc = RTSemMutexRequest(pStrmSt->State.hMtx, RT_INDEFINITE_WAIT);
+    int rc = RTSemMutexRequest(pStream->State.hMtx, RT_INDEFINITE_WAIT);
     if (RT_FAILURE(rc))
         return rc;
 
     /* Stop request received? */
-    if (pStrmSt->State.fDoStop)
-    {
-        pStrmSt->State.fActive = false;
-
-        rc = RTSemEventSignal(pStrmSt->State.hStateChangedEvent);
+    if (pStream->State.fDoStop)
+    {
+        pStream->State.fActive = false;
+
+        rc = RTSemEventSignal(pStream->State.hStateChangedEvent);
         AssertRC(rc);
 
@@ -3648 +3939 @@
     }
     /* Is the stream not in a running state currently? */
-    else if (!(HDA_STREAM_REG(pThis, CTL, pStrmSt->u8SD) & HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN)))
+    else if (!(HDA_STREAM_REG(pThis, CTL, pStream->u8SD) & HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN)))
         fProceed = false;
     /* Nothing to process? */
@@ -3654 +3945 @@
         fProceed = false;
 
+#if 0
+    Log3Func(("[SD%RU8] fProceed=%RTbool, fRun=%RTbool, cbToProcess=%RU32\n",
+              pStrmSt->u8SD, fProceed, HDA_STREAM_REG(pThis, CTL, pStrmSt->u8SD) & HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN),
+              cbToProcess));
+#endif
+
+    if ((HDA_STREAM_REG(pThis, STS, pStream->u8SD) & HDA_REG_FIELD_FLAG_MASK(SDSTS, BCIS)))
+    {
+        Log3Func(("[SD%RU8]: BCIS: Skipping\n", pStream->u8SD));
+        fProceed = false;
+    }
+
     if (!fProceed)
     {
-        rc = RTSemMutexRelease(pStrmSt->State.hMtx);
+        rc = RTSemMutexRelease(pStream->State.hMtx);
         AssertRC(rc);
 
@@ -3665 +3968 @@
 
     /* Sanity checks. */
-    Assert(pStrmSt->u8SD <= HDA_MAX_STREAMS);
-    Assert(pStrmSt->u64BDLBase);
-    Assert(pStrmSt->u32CBL);
+    Assert(pStream->u8SD <= HDA_MAX_STREAMS);
+    Assert(pStream->u64BDLBase);
+    Assert(pStream->u32CBL);
 
     /* State sanity checks. */
-    Assert(pStrmSt->State.fInReset == false);
-
-    uint32_t cbProcessedTotal = 0;
-    bool     fIsComplete      = false;
-
-    while (cbToProcess)
-    {
+    Assert(pStream->State.fInReset == false);
+
+//    uint32_t cbLeft  = cbToProcess;
+    uint32_t u32LPIB = HDA_STREAM_REG(pThis, LPIB, pStream->u8SD);
+    Assert(u32LPIB <= pStream->u32CBL);
+
+    if (u32LPIB == pStream->u32CBL)
+         u32LPIB = hdaStreamUpdateLPIB(pThis, pStream, 0);
+
+    uint32_t cbLeft  = pStream->u32CBL - u32LPIB;
+    uint32_t cbTotal = 0;
+
+    bool fInterrupt = false;
+
+    Log3Func(("cbLeft=%RU32\n", cbLeft));
+
+    while (cbLeft)
+    {
+    #if 1
         /* Do we need to fetch the next Buffer Descriptor Entry (BDLE)? */
-        if (hdaStreamNeedsNextBDLE(pThis, pStrmSt))
+        if (hdaStreamNeedsNextBDLE(pThis, pStream))
         {
-            rc = hdaStreamGetNextBDLE(pThis, pStrmSt);
+            rc = hdaStreamGetNextBDLE(pThis, pStream);
             if (RT_FAILURE(rc))
                 break;
         }
+    #else
+        PHDABDLE pBDLE   = &pStream->State.BDLE;
+
+        /* Did we reach the CBL (Cyclic Buffer List) limit? */
+        bool fCBLLimitReached = u32LPIB >= pStream->u32CBL;
+
+        /* Do we need to use the next BDLE entry? Either because we reached
+         * the CBL limit or our internal DMA buffer is full. */
+        bool fNeedsNextBDLE   = (   fCBLLimitReached
+                                 || (pBDLE->State.u32BufOff >= pBDLE->u32BufSize));
+
+        Assert(u32LPIB                <= pStream->u32CBL);
+        Assert(pBDLE->State.u32BufOff <= pBDLE->u32BufSize);
+
+        if (fNeedsNextBDLE)
+        {
+
+
+        #if 1
+            if (/* IOC (Interrupt On Completion) bit set? */
+                   pBDLE->fIntOnCompletion
+                /* All data put into the DMA FIFO? */
+                && pBDLE->State.cbBelowFIFOW == 0
+               )
+            {
+            //    fSetIRQ = true;
+                /*
+                 * If the ICE (IOCE, "Interrupt On Completion Enable") bit of the SDCTL register is set
+                 * we need to generate an interrupt.
+                 */
+               // if (HDA_STREAM_REG(pThis, CTL, pStream->u8SD) & HDA_REG_FIELD_FLAG_MASK(SDCTL, ICE))
+                 //   PDMDevHlpPCISetIrq(pThis->CTX_SUFF(pDevIns), 0 , 1 /* Raised */);
+            }
+        #endif
+
+
+        }
+    #endif
 
         /* Set the FIFORDY bit on the stream while doing the transfer. */
-        HDA_STREAM_REG(pThis, STS, pStrmSt->u8SD) |= HDA_REG_FIELD_FLAG_MASK(SDSTS, FIFORDY);
-
-        /*
-         * The register layout specifies that input streams (SDI) come first,
-         * followed by the output streams (SDO). So every stream ID below HDA_MAX_SDI
-         * is an input stream, whereas everything >= HDA_MAX_SDI is an output stream.
-         */
+    //    HDA_STREAM_REG(pThis, STS, pStream->u8SD) |= HDA_REG_FIELD_FLAG_MASK(SDSTS, FIFORDY);
+
         uint32_t cbProcessed;
-        if (pStrmSt->u8SD < HDA_MAX_SDI)
-            rc = hdaReadAudio (pThis, pStrmSt, cbToProcess, &cbProcessed);
+        if (hdaGetDirFromSD(pStream->u8SD) == PDMAUDIODIR_IN)
+            rc = hdaReadAudio (pThis, pStream, cbLeft, &cbProcessed);
         else
-            rc = hdaWriteAudio(pThis, pStrmSt, cbToProcess, &cbProcessed);
+            rc = hdaWriteAudio(pThis, pStream, cbLeft, &cbProcessed);
 
         /* Remove the FIFORDY bit again. */
-        HDA_STREAM_REG(pThis, STS, pStrmSt->u8SD) &= ~HDA_REG_FIELD_FLAG_MASK(SDSTS, FIFORDY);
+    //    HDA_STREAM_REG(pThis, STS, pStream->u8SD) &= ~HDA_REG_FIELD_FLAG_MASK(SDSTS, FIFORDY);
 
         if (RT_FAILURE(rc))
             break;
 
-        hdaStreamTransferUpdate(pThis, pStrmSt, cbProcessed);
-
-        cbToProcess      -= RT_MIN(cbToProcess, cbProcessed);
+    #if 1
+        hdaStreamTransferUpdate(pThis, pStream, cbProcessed);
+
+        Assert(cbLeft >= cbProcessed);
+        cbLeft  -= cbProcessed;
+        cbTotal += cbProcessed;
+
+        LogFlowFunc(("cbProcessed=%RU32, cbLeft=%RU32, cbTotal=%RU32, rc=%Rrc\n",
+                     cbProcessed, cbLeft, cbTotal, rc));
+
+        if (rc == VINF_EOF)
+            break;
+
+        if (hdaStreamTransferIsComplete(pThis, pStream, &fInterrupt))
+        {
+            rc = hdaStreamGetNextBDLE(pThis, pStream);
+            break;
+        }
+    #else
+        Assert(cbProcessedLeft >= cbProcessed);
+        cbProcessedLeft  -= cbProcessed;
         cbProcessedTotal += cbProcessed;
 
-        LogFlowFunc(("cbProcessed=%RU32, cbToProcess=%RU32, cbProcessedTotal=%RU32, rc=%Rrc\n",
-                     cbProcessed, cbToProcess, cbProcessedTotal, rc));
-
-        if (rc == VINF_EOF)
+
+        u32LPIB = hdaStreamUpdateLPIB(pThis, pStream, u32LPIB + cbProcessed);
+
+        Assert(u32LPIB <= pStream->u32CBL);
+        if (u32LPIB == pStream->u32CBL)
+        {
+           // HDA_STREAM_REG(pThis, STS, pStream->u8SD) |= HDA_REG_FIELD_FLAG_MASK(SDSTS, BCIS);
+            Log3Func(("[SD%RU8]: Transfer complete\n", pStream->u8SD));
+#if 1
+            if (/* IOC (Interrupt On Completion) bit set? */
+                   pBDLE->fIntOnCompletion
+                /* All data put into the DMA FIFO? */
+                && pBDLE->State.cbBelowFIFOW == 0
+               )
+            {
+                fSetIRQ = true;
+                /*
+                 * If the ICE (IOCE, "Interrupt On Completion Enable") bit of the SDCTL register is set
+                 * we need to generate an interrupt.
+                 */
+            //    if (HDA_STREAM_REG(pThis, CTL, pStream->u8SD) & HDA_REG_FIELD_FLAG_MASK(SDCTL, ICE))
+              //      PDMDevHlpPCISetIrq(pThis->CTX_SUFF(pDevIns), 0 , 1 /* Raised */);
+              //  fIRQ = true;
+            }
+#endif
             fIsComplete = true;
-
-        if (!fIsComplete)
-            fIsComplete = hdaStreamTransferIsComplete(pThis, pStrmSt);
-
-        if (fIsComplete)
-            break;
-    }
+        }
+
+        if (   fIsComplete
+            || pBDLE->State.u32BufOff >= pBDLE->u32BufSize)
+        {
+            Assert(pBDLE->State.u32BufOff <= pBDLE->u32BufSize);
+
+            Log3Func(("[SD%RU8]: LPIB=%RU32, CBL=%RU32, %R[bdle] => Next BDLE\n",
+                      pStream->u8SD, u32LPIB, u32LPIB >= pStream->u32CBL, pBDLE));
+
+            /*
+             * Switch to the next BDLE entry and do a wrap around
+             * if we reached the end of the Buffer Descriptor List (BDL).
+             */
+            pStream->State.uCurBDLE++;
+            if (pStream->State.uCurBDLE == pStream->u16LVI + 1)
+            {
+                pStream->State.uCurBDLE = 0;
+                u32LPIB = hdaStreamUpdateLPIB(pThis, pStream, 0);
+            }
+
+            hdaBDLEFetch(pThis, &pStream->State.BDLE, pStream->u64BDLBase, pStream->State.uCurBDLE);
+
+            if (/* IOC (Interrupt On Completion) bit set? */
+                   pBDLE->fIntOnCompletion
+                /* All data put into the DMA FIFO? */
+                && pBDLE->State.cbBelowFIFOW == 0
+               )
+            {
+                fSetIRQ = true;
+            }
+        }
+
+    #endif
+
+        /*if (fIsComplete)
+            break;*/
+    }
+
+    if (fInterrupt)
+    {
+        /**
+         * Set the BCIS (Buffer Completion Interrupt Status) flag as the
+         * last byte of data for the current descriptor has been fetched
+         * from memory and put into the DMA FIFO.
+         *
+         * Speech synthesis works fine on Mac Guest if this bit isn't set
+         * but in general sound quality gets worse.
+         *
+         * This must be set in *any* case.
+         */
+        HDA_STREAM_REG(pThis, STS, pStream->u8SD) |= HDA_REG_FIELD_FLAG_MASK(SDSTS, BCIS);
+        Log3Func(("[SD%RU8]: BCIS: Set (fInterrupt=%RTbool)\n", pStream->u8SD, fInterrupt));
+
+        hdaProcessInterrupt(pThis);
+    }
+
+#if 0
+    if (fSetIRQ)
+    {
+        Log3Func(("[SD%RU8]: IRQ\n", pStream->u8SD));
+
+        /**
+         * Set the BCIS (Buffer Completion Interrupt Status) flag as the
+         * last byte of data for the current descriptor has been fetched
+         * from memory and put into the DMA FIFO.
+         *
+         * Speech synthesis works fine on Mac Guest if this bit isn't set
+         * but in general sound quality gets worse.
+         *
+         * This must be set in *any* case.
+         */
+        HDA_STREAM_REG(pThis, STS, pStream->u8SD) |= HDA_REG_FIELD_FLAG_MASK(SDSTS, BCIS);
+
+        /*
+         * If the ICE (IOCE, "Interrupt On Completion Enable") bit of the SDCTL register is set
+         * we need to generate an interrupt.
+         */
+        if (HDA_STREAM_REG(pThis, CTL, pStream->u8SD) & HDA_REG_FIELD_FLAG_MASK(SDCTL, ICE))
+            PDMDevHlpPCISetIrq(pThis->CTX_SUFF(pDevIns), 0 , 1 /* Raised */);
+    }
+#endif
+
+    Log3Func(("Written %RU32 / %RU32 (left: %RU32), rc=%Rrc\n", cbTotal, cbToProcess, cbLeft, rc));
 
     if (RT_SUCCESS(rc))
     {
         if (pcbProcessed)
-            *pcbProcessed = cbProcessedTotal;
-    }
-    else
-        LogFlowFunc(("Failed with %Rrc\n", rc));
-
-    int rc2 = RTSemMutexRelease(pStrmSt->State.hMtx);
+            *pcbProcessed = cbTotal;
+    }
+
+    int rc2 = RTSemMutexRelease(pStream->State.hMtx);
     if (RT_SUCCESS(rc))
         rc = rc2;
@@ -3838 +4300 @@
     if (pThis->fInReset && idxRegDsc != HDA_REG_GCTL)
     {
-        LogRel2(("HDA: Access to register 0x%x is blocked while reset\n", idxRegDsc));
+        LogRel2(("HDA: Warning: Access to register 0x%x is blocked while reset\n", idxRegDsc));
         return VINF_SUCCESS;
     }
@@ -3847 +4309 @@
 #endif
     int rc = g_aHdaRegMap[idxRegDsc].pfnWrite(pThis, idxRegDsc, u32Value);
-    Log3Func(("write %#x -> %s[%db]; %x => %x%s\n", u32Value, g_aHdaRegMap[idxRegDsc].abbrev,
+    Log3Func(("Written value %#x to %s[%d byte]; %x => %x%s\n", u32Value, g_aHdaRegMap[idxRegDsc].abbrev,
               g_aHdaRegMap[idxRegDsc].size, u32CurValue, pThis->au32Regs[idxRegMem], pszLog));
     return rc;
@@ -4380 +4842 @@
     {
         /*
-         * Update stuff after the state changes.
+         * Update sinks after the state changes.
          */
-        bool fEnableIn    = RT_BOOL(HDA_SDCTL(pThis, 0 /** @todo Use a define. */) & HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN));
+        AUDMIXSINKCMD enmCmdLineIn = RT_BOOL(HDA_SDCTL(pThis, 0 /** @todo Use a define. */) & HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN))
+                                   ? AUDMIXSINKCMD_ENABLE : AUDMIXSINKCMD_DISABLE;
 #ifdef VBOX_WITH_HDA_MIC_IN
-        bool fEnableMicIn = RT_BOOL(HDA_SDCTL(pThis, 2 /** @todo Use a define. */) & HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN));
-#endif
-        bool fEnableOut   = RT_BOOL(HDA_SDCTL(pThis, 4 /** @todo Use a define. */) & HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN));
-
-        PHDADRIVER pDrv;
-        RTListForEach(&pThis->lstDrv, pDrv, HDADRIVER, Node)
-        {
-            PPDMIAUDIOCONNECTOR pCon = pDrv->pConnector;
-            rc = pCon->pfnEnableIn(pCon, pDrv->LineIn.pGstStrm, fEnableIn);
-            if (RT_FAILURE(rc))
-                break;
-#ifdef VBOX_WITH_HDA_MIC_IN
-            rc = pCon->pfnEnableIn(pCon, pDrv->MicIn.pGstStrm, fEnableMicIn);
-            if (RT_FAILURE(rc))
-                break;
-#endif
-            rc = pCon->pfnEnableOut(pCon, pDrv->Front.pGstStrm,     fEnableOut);
-            if (RT_FAILURE(rc))
-                break;
-#ifdef VBOX_WITH_HDA_51_SURROUND
-            rc = pCon->pfnEnableOut(pCon, pDrv->CenterLFE.pGstStrm, fEnableOut);
-            if (RT_FAILURE(rc))
-                break;
-            rc = pCon->pfnEnableOut(pCon, pDrv->Rear.pGstStrm,      fEnableOut);
-            if (RT_FAILURE(rc))
-                break;
-#endif
-            if (RT_FAILURE(rc))
-                break;
-        }
+        AUDMIXSINKCMD enmCmdMicIn  = RT_BOOL(HDA_SDCTL(pThis, 2 /** @todo Use a define. */) & HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN))
+                                   ? AUDMIXSINKCMD_ENABLE : AUDMIXSINKCMD_DISABLE;
+#endif
+        AUDMIXSINKCMD enmCmdOut    = RT_BOOL(HDA_SDCTL(pThis, 4 /** @todo Use a define. */) & HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN))
+                                   ? AUDMIXSINKCMD_ENABLE : AUDMIXSINKCMD_DISABLE;
+
+# ifdef VBOX_WITH_HDA_MIC_IN
+        AudioMixerSinkCtl(pThis->pSinkMicIn,     enmCmdMicIn);
+# endif
+        AudioMixerSinkCtl(pThis->pSinkLineIn,    enmCmdLineIn);
+        AudioMixerSinkCtl(pThis->pSinkFront,     enmCmdOut);
+# ifdef VBOX_WITH_HDA_51_SURROUND
+        AudioMixerSinkCtl(pThis->pSinkCenterLFE, enmCmdOut);
+        AudioMixerSinkCtl(pThis->pSinkRear,      enmCmdOut);
+# endif
     }
 
@@ -4423 +4871 @@
 
         /* Also make sure to update the DMA position bit if this was enabled when saving the state. */
-        pThis->fDMAPosition = RT_BOOL(HDA_REG(pThis, DPLBASE) & RT_BIT_32(0));
+        pThis->fDMAPosition = RT_BOOL(pThis->u64DPBase & RT_BIT_64(0));
     }
     else
@@ -4445 +4893 @@
     PHDABDLE pBDLE = (PHDABDLE)pvValue;
     return RTStrFormat(pfnOutput,  pvArgOutput, NULL, 0,
-                       "BDLE(idx:%RU32, off:%RU32, fifow:%RU32, DMA[%RU32 bytes @ 0x%x])",
-                       pBDLE->State.u32BDLIndex, pBDLE->State.u32BufOff, pBDLE->State.cbBelowFIFOW, pBDLE->u32BufSize, pBDLE->u64BufAdr);
+                       "BDLE(idx:%RU32, off:%RU32, fifow:%RU32, IOC:%RTbool, DMA[%RU32 bytes @ 0x%x])",
+                       pBDLE->State.u32BDLIndex, pBDLE->State.u32BufOff, pBDLE->State.cbBelowFIFOW,  pBDLE->fIntOnCompletion,
+                       pBDLE->u32BufSize, pBDLE->u64BufAdr);
 }
 
@@ -4756 +5205 @@
      * Stop any audio currently playing and/or recording.
      */
-    PHDADRIVER pDrv;
-    RTListForEach(&pThis->lstDrv, pDrv, HDADRIVER, Node)
-    {
-        pDrv->pConnector->pfnEnableIn(pDrv->pConnector, pDrv->LineIn.pGstStrm,      false /* Disable */);
+    AudioMixerSinkCtl(pThis->pSinkFront,     AUDMIXSINKCMD_DISABLE);
 # ifdef VBOX_WITH_HDA_MIC_IN
-        pDrv->pConnector->pfnEnableIn(pDrv->pConnector, pDrv->MicIn.pGstStrm,       false /* Disable */);
+    AudioMixerSinkCtl(pThis->pSinkMicIn,     AUDMIXSINKCMD_DISABLE);
 # endif
-        pDrv->pConnector->pfnEnableOut(pDrv->pConnector, pDrv->Front.pGstStrm,     false /* Disable */);
+    AudioMixerSinkCtl(pThis->pSinkLineIn,    AUDMIXSINKCMD_DISABLE);
 # ifdef VBOX_WITH_HDA_51_SURROUND
-        pDrv->pConnector->pfnEnableOut(pDrv->pConnector, pDrv->CenterLFE.pGstStrm, false /* Disable */);
-        pDrv->pConnector->pfnEnableOut(pDrv->pConnector, pDrv->Rear.pGstStrm,      false /* Disable */);
+    AudioMixerSinkCtl(pThis->pSinkCenterLFE, AUDMIXSINKCMD_DISABLE);
+    AudioMixerSinkCtl(pThis->pSinkRear,      AUDMIXSINKCMD_DISABLE);
 # endif
-    }
 
     pThis->cbCorbBuf = 256 * sizeof(uint32_t); /** @todo Use a define here. */
@@ -4789 +5234 @@
         /* Remove the RUN bit from SDnCTL in case the stream was in a running state before. */
         HDA_STREAM_REG(pThis, CTL, i) &= ~HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN);
-        hdaStreamReset(pThis, &pThis->aStreams[i], i);
+        hdaStreamReset(pThis, &pThis->aStreams[i]);
     }
 
@@ -4830 +5275 @@
     }
 
-    if (pThis->pMixer)
-    {
-        AudioMixerDestroy(pThis->pMixer);
-        pThis->pMixer = NULL;
-    }
-
     if (pThis->pCodec)
     {
-        int rc = hdaCodecDestruct(pThis->pCodec);
-        AssertRC(rc);
+        hdaCodecDestruct(pThis->pCodec);
 
         RTMemFree(pThis->pCodec);
@@ -4957 +5395 @@
 
 /**
- * Re-attach.
+ * Powers off the device.
+ *
+ * @param   pDevIns             Device instance to power off.
+ */
+static DECLCALLBACK(void) hdaPowerOff(PPDMDEVINS pDevIns)
+{
+    PHDASTATE pThis = PDMINS_2_DATA(pDevIns, PHDASTATE);
+
+    LogRel2(("HDA: Powering off ...\n"));
+
+    /**
+     * Note: Destroy the mixer while powering off and *not* in hdaDestruct,
+     *       giving the mixer the chance to release any references held to
+     *       PDM audio streams it maintains.
+     */
+    if (pThis->pMixer)
+    {
+        AudioMixerDestroy(pThis->pMixer);
+        pThis->pMixer = NULL;
+    }
+
+    /* Ditto goes for the codec, which in turn uses the mixer. */
+    hdaCodecPowerOff(pThis->pCodec);
+}
+
+/**
+ * Re-attaches a new driver to the device's driver chain.
  *
  * @returns VBox status code.
- * @param   pThis       Device instance.
+ * @param   pThis       Device instance to re-attach driver to.
  * @param   pDrv        Driver instance used for attaching to.
  *                      If NULL is specified, a new driver will be created and appended
@@ -5166 +5630 @@
 
     RTListInit(&pThis->lstDrv);
-#ifdef VBOX_WITH_HDA_INTERLEAVING_STREAMS_SUPPORT
-    rc = RTCircBufCreate(&pThis->pCircBuf, _4K);
-    if (RT_FAILURE(rc))
-        return rc;
-#endif
 
     uint8_t uLUN;
@@ -5205 +5664 @@
             streamCfg.uHz           = 44100;
             streamCfg.cChannels     = 2;
-            streamCfg.enmFormat     = AUD_FMT_S16;
+            streamCfg.enmFormat     = PDMAUDIOFMT_S16;
             streamCfg.enmEndianness = PDMAUDIOHOSTENDIANNESS;
 
@@ -5215 +5674 @@
              */
 #ifdef VBOX_WITH_HDA_51_SURROUND
-            rc = AudioMixerAddSink(pThis->pMixer, "[Playback] Front",
-                                   AUDMIXSINKDIR_OUTPUT, &pThis->pSinkFront);
+            rc = AudioMixerCreateSink(pThis->pMixer, "[Playback] Front",
+                                      AUDMIXSINKDIR_OUTPUT, &pThis->pSinkFront);
             AssertRC(rc);
-            rc = AudioMixerAddSink(pThis->pMixer, "[Playback] Center / Subwoofer",
-                                   AUDMIXSINKDIR_OUTPUT, &pThis->pSinkCenterLFE);
+            rc = AudioMixerCreateSink(pThis->pMixer, "[Playback] Center / Subwoofer",
+                                      AUDMIXSINKDIR_OUTPUT, &pThis->pSinkCenterLFE);
             AssertRC(rc);
-            rc = AudioMixerAddSink(pThis->pMixer, "[Playback] Rear",
-                                   AUDMIXSINKDIR_OUTPUT, &pThis->pSinkRear);
+            rc = AudioMixerCreateSink(pThis->pMixer, "[Playback] Rear",
+                                      AUDMIXSINKDIR_OUTPUT, &pThis->pSinkRear);
             AssertRC(rc);
 #else
-            rc = AudioMixerAddSink(pThis->pMixer, "[Playback] PCM Output",
-                                   AUDMIXSINKDIR_OUTPUT, &pThis->pSinkFront);
+            rc = AudioMixerCreateSink(pThis->pMixer, "[Playback] PCM Output",
+                                      AUDMIXSINKDIR_OUTPUT, &pThis->pSinkFront);
             AssertRC(rc);
 #endif
@@ -5232 +5691 @@
              * Add mixer input sinks.
              */
-            rc = AudioMixerAddSink(pThis->pMixer, "[Recording] Line In",
-                                   AUDMIXSINKDIR_INPUT, &pThis->pSinkLineIn);
+            rc = AudioMixerCreateSink(pThis->pMixer, "[Recording] Line In",
+                                      AUDMIXSINKDIR_INPUT, &pThis->pSinkLineIn);
             AssertRC(rc);
 #ifdef VBOX_WITH_HDA_MIC_IN
-            rc = AudioMixerAddSink(pThis->pMixer, "[Recording] Microphone In",
-                                   AUDMIXSINKDIR_INPUT, &pThis->pSinkMicIn);
+            rc = AudioMixerCreateSink(pThis->pMixer, "[Recording] Microphone In",
+                                      AUDMIXSINKDIR_INPUT, &pThis->pSinkMicIn);
             AssertRC(rc);
 #endif
@@ -5254 +5713 @@
             return PDMDEV_SET_ERROR(pDevIns, VERR_NO_MEMORY, N_("Out of memory allocating HDA codec state"));
 
-        /* Audio driver callbacks for multiplexing. */
+        /* Set codec callbacks. */
         pThis->pCodec->pfnMixerAddStream    = hdaMixerAddStream;
         pThis->pCodec->pfnMixerRemoveStream = hdaMixerRemoveStream;
@@ -5320 +5779 @@
             AssertPtr(pCon);
 
-            bool fValidLineIn = pCon->pfnIsValidIn(pCon,  pDrv->LineIn.pGstStrm);
+            bool fValidLineIn = AudioMixerStreamIsValid(pDrv->LineIn.pMixStrm);
 #ifdef VBOX_WITH_HDA_MIC_IN
-            bool fValidMicIn  = pCon->pfnIsValidIn (pCon, pDrv->MicIn.pGstStrm);
-#endif
-            bool fValidOut    = pCon->pfnIsValidOut(pCon, pDrv->Front.pGstStrm);
+            bool fValidMicIn  = AudioMixerStreamIsValid(pDrv->MicIn.pMixStrm);
+#endif
+            bool fValidOut    = AudioMixerStreamIsValid(pDrv->Front.pMixStrm);
+#ifdef VBOX_WITH_HDA_51_SURROUND
+            /** @todo Anything to do here? */
+#endif
 
             if (    !fValidLineIn
@@ -5346 +5808 @@
 
                 PDMAUDIOBACKENDCFG backendCfg;
-                int rc2 = pCon->pfnGetConfiguration(pCon, &backendCfg);
+                int rc2 = pCon->pfnGetConfig(pCon, &backendCfg);
                 if (RT_SUCCESS(rc2))
                 {
@@ -5609 +6071 @@
     NULL,
     /* pfnPowerOff */
-    NULL,
+    hdaPowerOff,
     /* pfnSoftReset */
     NULL,

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

@@ -1074 +1074 @@
                                                           CODEC_F1C_COLOR_GREEN,
                                                           CODEC_F1C_MISC_NONE,
-                                                          CODEC_F1C_ASSOCIATION_GROUP_0, 0xF /* Seq */);
+                                                          CODEC_F1C_ASSOCIATION_GROUP_1, 0x0 /* Seq */);
             goto port_init;
         }
@@ -1098 +1098 @@
                                                           CODEC_F1C_COLOR_BLACK,
                                                           CODEC_F1C_MISC_NONE,
-                                                          CODEC_F1C_ASSOCIATION_GROUP_1, 0xE /* Seq */);
+                                                          CODEC_F1C_ASSOCIATION_GROUP_0, 0x1 /* Seq */);
             goto port_init;
         }
@@ -1147 +1147 @@
                                                           CODEC_F1C_COLOR_PINK,
                                                           CODEC_F1C_MISC_NONE,
-                                                          CODEC_F1C_ASSOCIATION_GROUP_15, 0xD /* Seq */);
+                                                          CODEC_F1C_ASSOCIATION_GROUP_4, 0x0 /* Seq */);
             /* Fall through is intentional. */
+
         port_init:
 
@@ -1173 +1174 @@
                                                 | CODEC_F00_09_CAP_UNSOL
                                                 | CODEC_F00_09_CAP_STEREO;
+
             pNode->port.node.au32F00_param[0xC] = CODEC_F00_0C_CAP_INPUT
                                                 | CODEC_F00_0C_CAP_PRESENCE_DETECT;
@@ -1183 +1185 @@
                                                           CODEC_F1C_COLOR_BLUE,
                                                           CODEC_F1C_MISC_NONE,
-                                                          CODEC_F1C_ASSOCIATION_GROUP_15, 0xE /* Seq */);
+                                                          CODEC_F1C_ASSOCIATION_GROUP_4, 0x1 /* Seq */);
             break;
         }
@@ -1198 +1200 @@
                                                 | CODEC_F00_09_CAP_OUT_AMP_PRESENT
                                                 | CODEC_F00_09_CAP_STEREO;
+
             pNode->port.node.au32F00_param[0xC] = CODEC_F00_0C_CAP_INPUT
                                                 | CODEC_F00_0C_CAP_OUTPUT;
@@ -1212 +1215 @@
                                                           CODEC_F1C_COLOR_ORANGE,
                                                           CODEC_F1C_MISC_NONE,
-                                                          CODEC_F1C_ASSOCIATION_GROUP_1, 0x0 /* Seq */);
+                                                          CODEC_F1C_ASSOCIATION_GROUP_0, 0x2 /* Seq */);
             break;
         }
@@ -1267 +1270 @@
                                                            CODEC_F1C_COLOR_BLACK,
                                                            CODEC_F1C_MISC_NONE,
-                                                           CODEC_F1C_ASSOCIATION_GROUP_3, 0x0 /* Seq */);
+                                                           CODEC_F1C_ASSOCIATION_GROUP_5, 0x0 /* Seq */);
             break;
         }
@@ -1280 +1283 @@
         {
             pNode->adcmux.u32F01_param = 1; /* Connection select control index (STAC9220_NID_PIN_CD). */
-
             /* Fall through is intentional. */
+
         adcmux_init:
 
@@ -1304 +1307 @@
 
             /* STAC 9220 v10 6.21-22.{4,5} both(left and right) out amplifiers initialized with 0. */
-            RT_BZERO(pNode->adcmux.B_params, AMPLIFIER_SIZE);
+            RT_ZERO(pNode->adcmux.B_params);
             break;
         }
@@ -1317 +1320 @@
             pNode->pcbeep.node.au32F00_param[0xD]  = CODEC_MAKE_F00_0D(0, 17, 3, 3);
 
-            RT_BZERO(pNode->pcbeep.B_params, AMPLIFIER_SIZE);
+            RT_ZERO(pNode->pcbeep.B_params);
             break;
         }
@@ -1334 +1337 @@
                                                             CODEC_F1C_COLOR_UNKNOWN,
                                                             CODEC_F1C_MISC_NONE,
-                                                            CODEC_F1C_ASSOCIATION_GROUP_15, 0xF /* Seq */);
+                                                            CODEC_F1C_ASSOCIATION_GROUP_4, 0x2 /* Seq */);
             break;
         }
@@ -1355 +1358 @@
         }
 
-        case STAC9220_NID_AMP_ADC0:
+        case STAC9220_NID_AMP_ADC0: /* ADC0Vol */
         {
             pNode->adcvol.node.au32F02_param[0] = STAC9220_NID_ADC0_MUX;
@@ -1361 +1364 @@
         }
 
-        case STAC9220_NID_AMP_ADC1:
+        case STAC9220_NID_AMP_ADC1: /* ADC1Vol */
         {
             pNode->adcvol.node.au32F02_param[0] = STAC9220_NID_ADC1_MUX;
-
             /* Fall through is intentional. */
+
         adcvol_init:
-
-            pNode->adcvol.u32F0c_param = 0;
 
             pNode->adcvol.node.au32F00_param[0x9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_AUDIO_SELECTOR, 0, 0)
@@ -1379 +1380 @@
             pNode->adcvol.node.au32F00_param[0xE] = CODEC_MAKE_F00_0E(CODEC_F00_0E_LIST_NID_SHORT, 1 /* Entries */);
 
-            RT_BZERO(pNode->adcvol.B_params, AMPLIFIER_SIZE);
+            RT_ZERO(pNode->adcvol.B_params);
             AMPLIFIER_REGISTER(pNode->adcvol.B_params, AMPLIFIER_IN, AMPLIFIER_LEFT,  0) = RT_BIT(7);
             AMPLIFIER_REGISTER(pNode->adcvol.B_params, AMPLIFIER_IN, AMPLIFIER_RIGHT, 0) = RT_BIT(7);
@@ -1411 +1412 @@
                                            | CODEC_F00_09_CAP_CONNECTION_LIST
                                            | CODEC_F00_09_CAP_STEREO;
+
             pNode->node.au32F00_param[0xC] = CODEC_F00_0C_CAP_OUTPUT;
 
@@ -1435 +1437 @@
     return VINF_SUCCESS;
 }
-
 
 static int stac9220Construct(PHDACODEC pThis)
@@ -1587 +1588 @@
  * Verb processor functions.
  */
-DECLINLINE(bool) vrbIsValidNode(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
-{
-    AssertPtrReturn(pThis, false);
-    AssertPtrReturn(pResp, false);
-
-    Assert(CODEC_CAD(cmd) == pThis->id);
-    Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
-    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
-    {
-        *pResp = 0;
-
-        AssertMsgFailed(("Invalid node address: 0x%x (NID=0x%x [%RU8])\n", cmd, CODEC_NID(cmd)));
-        return false;
-    }
-
-    return true;
-}
-
 static DECLCALLBACK(int) vrbProcUnimplemented(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
@@ -1624 +1607 @@
 static DECLCALLBACK(int) vrbProcGetAmplifier(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
 
@@ -1673 +1653 @@
 static DECLCALLBACK(int) vrbProcSetAmplifier(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
 
@@ -1735 +1712 @@
 static DECLCALLBACK(int) vrbProcGetParameter(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     Assert((cmd & CODEC_VERB_8BIT_DATA) < CODECNODE_F00_PARAM_LENGTH);
     if ((cmd & CODEC_VERB_8BIT_DATA) >= CODECNODE_F00_PARAM_LENGTH)
@@ -1754 +1728 @@
 static DECLCALLBACK(int) vrbProcGetConSelectCtrl(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
 
@@ -1770 +1741 @@
         *pResp = pThis->paNodes[CODEC_NID(cmd)].adcvol.u32F01_param;
     else
-        LogRel2(("HDA: Warning: Unhandled get connection select control command for NID0x%x: 0x%x\n", CODEC_NID(cmd), cmd));
+        LogRel2(("HDA: Warning: Unhandled get connection select control command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
 
     return VINF_SUCCESS;
@@ -1778 +1749 @@
 static DECLCALLBACK(int) vrbProcSetConSelectCtrl(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
 
@@ -1795 +1763 @@
         pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].adcvol.u32F01_param;
     else
-        LogRel2(("HDA: Warning: Unhandled set connection select control command for NID0x%x: 0x%x\n", CODEC_NID(cmd), cmd));
+        LogRel2(("HDA: Warning: Unhandled set connection select control command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
 
     if (pu32Reg)
@@ -1806 +1774 @@
 static DECLCALLBACK(int) vrbProcGetPinCtrl(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
 
@@ -1824 +1789 @@
         *pResp = pThis->paNodes[CODEC_NID(cmd)].reserved.u32F07_param;
     else
-        LogRel2(("HDA: Warning: Unhandled get pin control command for NID0x%x: 0x%x\n", CODEC_NID(cmd), cmd));
+        LogRel2(("HDA: Warning: Unhandled get pin control command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
 
     return VINF_SUCCESS;
@@ -1832 +1797 @@
 static DECLCALLBACK(int) vrbProcSetPinCtrl(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
 
@@ -1852 +1814 @@
         pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].reserved.u32F07_param;
     else
-        LogRel2(("HDA: Warning: Unhandled set pin control command for NID0x%x: 0x%x\n", CODEC_NID(cmd), cmd));
+        LogRel2(("HDA: Warning: Unhandled set pin control command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
 
     if (pu32Reg)
@@ -1863 +1825 @@
 static DECLCALLBACK(int) vrbProcGetUnsolicitedEnabled(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
 
@@ -1881 +1840 @@
         *pResp = pThis->paNodes[CODEC_NID(cmd)].digin.u32F08_param;
     else
-        LogRel2(("HDA: Warning: Unhandled get unsolicited enabled command for NID0x%x: 0x%x\n", CODEC_NID(cmd), cmd));
+        LogRel2(("HDA: Warning: Unhandled get unsolicited enabled command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
 
     return VINF_SUCCESS;
@@ -1889 +1848 @@
 static DECLCALLBACK(int) vrbProcSetUnsolicitedEnabled(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
 
@@ -1908 +1864 @@
         pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].digout.u32F08_param;
     else
-        LogRel2(("HDA: Warning: Unhandled set unsolicited enabled command for NID0x%x: 0x%x\n", CODEC_NID(cmd), cmd));
+        LogRel2(("HDA: Warning: Unhandled set unsolicited enabled command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
 
     if (pu32Reg)
@@ -1919 +1875 @@
 static DECLCALLBACK(int) vrbProcGetPinSense(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
 
@@ -1929 +1882 @@
         *pResp = pThis->paNodes[CODEC_NID(cmd)].digin.u32F09_param;
     else
-        LogRel2(("HDA: Warning: Unhandled get pin sense command for NID0x%x: 0x%x\n", CODEC_NID(cmd), cmd));
+    {
+        AssertFailed();
+        LogRel2(("HDA: Warning: Unhandled get pin sense command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
+    }
 
     return VINF_SUCCESS;
@@ -1937 +1893 @@
 static DECLCALLBACK(int) vrbProcSetPinSense(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
 
@@ -1948 +1901 @@
         pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].digin.u32F09_param;
     else
-        LogRel2(("HDA: Warning: Unhandled set pin sense command for NID0x%x: 0x%x\n", CODEC_NID(cmd), cmd));
+        LogRel2(("HDA: Warning: Unhandled set pin sense command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
 
     if (pu32Reg)
@@ -1958 +1911 @@
 static DECLCALLBACK(int) vrbProcGetConnectionListEntry(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
 
@@ -1976 +1926 @@
 static DECLCALLBACK(int) vrbProcGetProcessingState(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
 
@@ -1990 +1937 @@
 static DECLCALLBACK(int) vrbProcSetProcessingState(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
 
@@ -2003 +1947 @@
 static DECLCALLBACK(int) vrbProcGetDigitalConverter(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
 
@@ -2018 +1959 @@
 static int codecSetDigitalConverter(PHDACODEC pThis, uint32_t cmd, uint8_t u8Offset, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
 
@@ -2109 +2047 @@
     Assert(CODEC_CAD(cmd) == pThis->id);
     Assert(CODEC_NID(cmd) == STAC9220_NID_AFG);
+
     if (   CODEC_NID(cmd) == STAC9220_NID_AFG
         && pThis->pfnCodecNodeReset)
     {
         uint8_t i;
-        LogFlowFunc(("enters reset\n"));
-        Assert(pThis->pfnCodecNodeReset);
+        LogFunc(("Entering reset ...\n"));
+
+        //pThis->fInReset = true;
+
         for (i = 0; i < pThis->cTotalNodes; ++i)
-        {
             pThis->pfnCodecNodeReset(pThis, i, &pThis->paNodes[i]);
-        }
-        pThis->fInReset = false;
-        LogFlowFunc(("exits reset\n"));
-    }
+
+        //pThis->fInReset = false;
+
+        LogFunc(("Exited reset\n"));
+    }
+
     *pResp = 0;
     return VINF_SUCCESS;
@@ -2129 +2071 @@
 static DECLCALLBACK(int) vrbProcGetPowerState(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
 
@@ -2138 +2077 @@
     else if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
         *pResp = pThis->paNodes[CODEC_NID(cmd)].dac.u32F05_param;
+    else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].adc.u32F05_param;
     else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
         *pResp = pThis->paNodes[CODEC_NID(cmd)].digin.u32F05_param;
     else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
         *pResp = pThis->paNodes[CODEC_NID(cmd)].digout.u32F05_param;
-    else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
-        *pResp = pThis->paNodes[CODEC_NID(cmd)].adc.u32F05_param;
     else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
         *pResp = pThis->paNodes[CODEC_NID(cmd)].spdifout.u32F05_param;
@@ -2151 +2090 @@
         *pResp = pThis->paNodes[CODEC_NID(cmd)].reserved.u32F05_param;
     else
-        LogRel2(("HDA: Warning: Unhandled get power state command for NID0x%x: 0x%x\n", CODEC_NID(cmd), cmd));
-
-    LogFunc(("NID=0x%x, fReset=%RTbool, fStopOk=%RTbool, Set=%RU8, Act=%RU8\n",
-             CODEC_NID(cmd), CODEC_F05_IS_RESET(*pResp), CODEC_F05_IS_STOPOK(*pResp), CODEC_F05_SET(*pResp), CODEC_F05_ACT(*pResp)));
+        LogRel2(("HDA: Warning: Unhandled get power state command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
+
+    LogFunc(("[NID0x%02x]: fReset=%RTbool, fStopOk=%RTbool, Act=D%RU8, Set=D%RU8\n",
+             CODEC_NID(cmd), CODEC_F05_IS_RESET(*pResp), CODEC_F05_IS_STOPOK(*pResp), CODEC_F05_ACT(*pResp), CODEC_F05_SET(*pResp)));
     return VINF_SUCCESS;
 }
 
 /* 705 */
+#if 1
 static DECLCALLBACK(int) vrbProcSetPowerState(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
 
@@ -2184 +2121 @@
         pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].reserved.u32F05_param;
     else
-        LogRel2(("HDA: Warning: Unhandled set power state command for NID0x%x: 0x%x\n", CODEC_NID(cmd), cmd));
+    {
+        AssertFailed();
+        LogRel2(("HDA: Warning: Unhandled set power state command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
+    }
 
     if (!pu32Reg)
@@ -2191 +2131 @@
     bool    fReset  = CODEC_F05_IS_RESET (*pu32Reg);
     bool    fStopOk = CODEC_F05_IS_STOPOK(*pu32Reg);
+    bool    fError  = CODEC_F05_IS_ERROR (*pu32Reg);
     uint8_t uPwrAct = CODEC_F05_ACT      (*pu32Reg);
     uint8_t uPwrSet = CODEC_F05_SET      (*pu32Reg);
+
     uint8_t uPwrCmd = CODEC_F05_SET      (cmd);
 
-    LogFunc(("[NID=0x%x] Cmd=D%RU8, Act=D%RU8, Set=D%RU8 (AFG Act=D%RU8, Set=D%RU8)\n",
-            CODEC_NID(cmd), uPwrCmd, uPwrAct, uPwrSet,
+    LogFunc(("[NID0x%02x] Cmd=D%RU8, fReset=%RTbool, fStopOk=%RTbool, fError=%RTbool, uPwrAct=D%RU8, uPwrSet=D%RU8\n",
+             CODEC_NID(cmd), uPwrCmd, fReset, fStopOk, fError, uPwrAct, uPwrSet));
+
+    LogFunc(("AFG: Act=D%RU8, Set=D%RU8\n",
             CODEC_F05_ACT(pThis->paNodes[STAC9220_NID_AFG].afg.u32F05_param),
             CODEC_F05_SET(pThis->paNodes[STAC9220_NID_AFG].afg.u32F05_param)));
 
-    const uint8_t uAFGPwrSet = CODEC_F05_SET(pThis->paNodes[STAC9220_NID_AFG].afg.u32F05_param);
-
-    /* If this is the AFG node, PS-Act always matches the PS-Set power state.*/
     if (CODEC_NID(cmd) == STAC9220_NID_AFG)
-    {
         *pu32Reg = CODEC_MAKE_F05(fReset, fStopOk, 0, uPwrCmd /* PS-Act */, uPwrCmd /* PS-Set */);
 
+    const uint8_t uAFGPwrAct = CODEC_F05_ACT(pThis->paNodes[STAC9220_NID_AFG].afg.u32F05_param);
+    if (uAFGPwrAct == CODEC_F05_D0) /* Only propagate power state if AFG is on (D0). */
+    {
         /* Propagate to all other nodes under this AFG. */
-        LogFunc(("Propagating Set=D%RU8 to all nodes ...\n", uPwrCmd));
+        LogFunc(("Propagating Act=D%RU8 (AFG), Set=D%RU8 to all AFG child nodes ...\n", uAFGPwrAct, uPwrCmd));
 
 #define PROPAGATE_PWR_STATE(_aList, _aMember) \
         { \
             const uint8_t *pu8NodeIndex = &_aList[0]; \
-            while (*(pu8NodeIndex++)) \
+            while (*(++pu8NodeIndex)) \
             { \
                 pThis->paNodes[*pu8NodeIndex]._aMember.u32F05_param = \
-                    CODEC_MAKE_F05(fReset, fStopOk, 0, RT_MIN((uAFGPwrSet + 1), CODEC_F05_D3), \
-                                   uPwrCmd /* Always update PS-Set with command power state just received. */); \
-                LogFunc(("\t[NID=0x%x]: Act=D%RU8, Set=D%RU8\n", *pu8NodeIndex, \
+                    CODEC_MAKE_F05(fReset, fStopOk, 0, uAFGPwrAct, uPwrCmd); \
+                LogFunc(("\t[NID0x%02x]: Act=D%RU8, Set=D%RU8\n", *pu8NodeIndex, \
                          CODEC_F05_ACT(pThis->paNodes[*pu8NodeIndex]._aMember.u32F05_param), \
                          CODEC_F05_SET(pThis->paNodes[*pu8NodeIndex]._aMember.u32F05_param))); \
@@ -2235 +2177 @@
     }
     /*
-     * If this node is a reqular node (not the AFG one), adpopt PS-Set of the AFG node
+     * If this node is a reqular node (not the AFG one), adopt PS-Set of the AFG node
      * as PS-Set of this node. PS-Act always is one level under PS-Set here.
      */
     else
     {
+        *pu32Reg = CODEC_MAKE_F05(fReset, fStopOk, 0, uAFGPwrAct, uPwrCmd);
+    }
+
+    LogFunc(("[NID0x%02x] fReset=%RTbool, fStopOk=%RTbool, Act=D%RU8, Set=D%RU8\n",
+             CODEC_NID(cmd),
+             CODEC_F05_IS_RESET(*pu32Reg), CODEC_F05_IS_STOPOK(*pu32Reg), CODEC_F05_ACT(*pu32Reg), CODEC_F05_SET(*pu32Reg)));
+
+    return VINF_SUCCESS;
+}
+#else
+DECLINLINE(void) codecPropogatePowerState(uint32_t *pu32F05_param)
+{
+    Assert(pu32F05_param);
+    if (!pu32F05_param)
+        return;
+    bool fReset = CODEC_F05_IS_RESET(*pu32F05_param);
+    bool fStopOk = CODEC_F05_IS_STOPOK(*pu32F05_param);
+    uint8_t u8SetPowerState = CODEC_F05_SET(*pu32F05_param);
+    *pu32F05_param = CODEC_MAKE_F05(fReset, fStopOk, 0, u8SetPowerState, u8SetPowerState);
+}
+
+static DECLCALLBACK(int) vrbProcSetPowerState(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
+    {
+        LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
+        return VINF_SUCCESS;
+    }
+    *pResp = 0;
+    uint32_t *pu32Reg;
+    if (CODEC_NID(cmd) == 1 /* AFG */)
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].afg.u32F05_param;
+    else if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].dac.u32F05_param;
+    else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].digin.u32F05_param;
+    else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].adc.u32F05_param;
+    else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].spdifout.u32F05_param;
+    else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].spdifin.u32F05_param;
+    else if (hdaCodecIsReservedNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].reserved.u32F05_param;
+    else
+        AssertFailedReturn(VINF_SUCCESS);
+
+    bool fReset = CODEC_F05_IS_RESET(*pu32Reg);
+    bool fStopOk = CODEC_F05_IS_STOPOK(*pu32Reg);
+
+    if (CODEC_NID(cmd) != 1 /* AFG */)
+    {
+        /*
+         * We shouldn't propogate actual power state, which actual for AFG
+         */
         *pu32Reg = CODEC_MAKE_F05(fReset, fStopOk, 0,
-                                  RT_MIN((uAFGPwrSet + 1), CODEC_F05_D3),
-                                  uPwrCmd /* Always update PS-Set with command power state just received. */);
-    }
-
-    if (pu32Reg)
-        hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
-
-    LogFunc(("[NID=0x%x] fReset=%RTbool, fStopOk=%RTbool, Act=D%RU8, Set=D%RU8\n",
-             CODEC_NID(cmd), fReset, fStopOk, CODEC_F05_ACT(*pu32Reg), CODEC_F05_SET(*pu32Reg)));
-
-    return VINF_SUCCESS;
-}
+                                  CODEC_F05_ACT(pThis->paNodes[1].afg.u32F05_param),
+                                  CODEC_F05_SET(cmd));
+    }
+
+    /* Propagate next power state only if AFG is on or verb modifies AFG power state */
+    if (   CODEC_NID(cmd) == 1 /* AFG */
+        || !CODEC_F05_ACT(pThis->paNodes[1].afg.u32F05_param))
+    {
+        *pu32Reg = CODEC_MAKE_F05(fReset, fStopOk, 0, CODEC_F05_SET(cmd), CODEC_F05_SET(cmd));
+        if (   CODEC_NID(cmd) == 1 /* AFG */
+            && (CODEC_F05_SET(cmd)) == CODEC_F05_D0)
+        {
+            /* now we're powered on AFG and may propogate power states on nodes */
+            const uint8_t *pu8NodeIndex = &pThis->au8Dacs[0];
+            while (*(++pu8NodeIndex))
+                codecPropogatePowerState(&pThis->paNodes[*pu8NodeIndex].dac.u32F05_param);
+
+            pu8NodeIndex = &pThis->au8Adcs[0];
+            while (*(++pu8NodeIndex))
+                codecPropogatePowerState(&pThis->paNodes[*pu8NodeIndex].adc.u32F05_param);
+
+            pu8NodeIndex = &pThis->au8DigInPins[0];
+            while (*(++pu8NodeIndex))
+                codecPropogatePowerState(&pThis->paNodes[*pu8NodeIndex].digin.u32F05_param);
+        }
+    }
+    return VINF_SUCCESS;
+}
+#endif
 
 static DECLCALLBACK(int) vrbProcGetStreamId(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
 
@@ -2272 +2285 @@
         *pResp = pThis->paNodes[CODEC_NID(cmd)].reserved.u32F06_param;
     else
-        LogRel2(("HDA: Warning: Unhandled get stream ID command for NID0x%x: 0x%x\n", CODEC_NID(cmd), cmd));
-
-    LogFlowFunc(("[NID0x%x] Stream ID is 0x%x\n",
-                 CODEC_NID(cmd), CODEC_F00_06_GET_STREAM_ID(*pResp)));
+        LogRel2(("HDA: Warning: Unhandled get stream ID command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
+
+    /*LogFlowFunc(("[NID0x%02x] Stream ID is 0x%x\n",
+                 CODEC_NID(cmd), CODEC_F00_06_GET_STREAM_ID(*pResp)));*/
 
     return VINF_SUCCESS;
@@ -2283 +2296 @@
 static DECLCALLBACK(int) vrbProcSetStreamId(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
 
@@ -2300 +2310 @@
         pu32Addr = &pThis->paNodes[CODEC_NID(cmd)].reserved.u32F06_param;
     else
-        LogRel2(("HDA: Warning: Unhandled set stream ID command for NID0x%x: 0x%x\n", CODEC_NID(cmd), cmd));
-
-    LogFlowFunc(("[NID0x%x] Setting new stream ID to 0x%x\n",
-                 CODEC_NID(cmd), CODEC_F00_06_GET_STREAM_ID(cmd)));
+        LogRel2(("HDA: Warning: Unhandled set stream ID command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
+
+/*    LogFlowFunc(("[NID0x%02x] Setting new stream ID to 0x%x\n",
+                 CODEC_NID(cmd), CODEC_F00_06_GET_STREAM_ID(cmd)));*/
 
     if (pu32Addr)
@@ -2314 +2324 @@
 static DECLCALLBACK(int) vrbProcGetConverterFormat(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
 
@@ -2330 +2337 @@
         *pResp = pThis->paNodes[CODEC_NID(cmd)].reserved.u32A_param;
     else
-        LogRel2(("HDA: Warning: Unhandled get converter format command for NID0x%x: 0x%x\n", CODEC_NID(cmd), cmd));
+        LogRel2(("HDA: Warning: Unhandled get converter format command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
 
     return VINF_SUCCESS;
@@ -2338 +2345 @@
 static DECLCALLBACK(int) vrbProcSetConverterFormat(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
 
@@ -2352 +2356 @@
         hdaCodecSetRegisterU16(&pThis->paNodes[CODEC_NID(cmd)].spdifin.u32A_param, cmd, 0);
     else
-        LogRel2(("HDA: Warning: Unhandled set converter format command for NID0x%x: 0x%x\n", CODEC_NID(cmd), cmd));
+        LogRel2(("HDA: Warning: Unhandled set converter format command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
 
     return VINF_SUCCESS;
@@ -2360 +2364 @@
 static DECLCALLBACK(int) vrbProcGetEAPD_BTLEnabled(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
 
@@ -2372 +2373 @@
         *pResp = pThis->paNodes[CODEC_NID(cmd)].digin.u32F0c_param;
     else
-        LogRel2(("HDA: Warning: Unhandled get EAPD/BTL enabled command for NID0x%x: 0x%x\n", CODEC_NID(cmd), cmd));
+        LogRel2(("HDA: Warning: Unhandled get EAPD/BTL enabled command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
 
     return VINF_SUCCESS;
@@ -2380 +2381 @@
 static DECLCALLBACK(int) vrbProcSetEAPD_BTLEnabled(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
 
@@ -2393 +2391 @@
         pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].digin.u32F0c_param;
     else
-        LogRel2(("HDA: Warning: Unhandled set EAPD/BTL enabled command for NID0x%x: 0x%x\n", CODEC_NID(cmd), cmd));
+        LogRel2(("HDA: Warning: Unhandled set EAPD/BTL enabled command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
 
     if (pu32Reg)
@@ -2404 +2402 @@
 static DECLCALLBACK(int) vrbProcGetVolumeKnobCtrl(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
 
@@ -2412 +2407 @@
         *pResp = pThis->paNodes[CODEC_NID(cmd)].volumeKnob.u32F0f_param;
     else
-        LogRel2(("HDA: Warning: Unhandled get volume knob control command for NID0x%x: 0x%x\n", CODEC_NID(cmd), cmd));
+        LogRel2(("HDA: Warning: Unhandled get volume knob control command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
 
     return VINF_SUCCESS;
@@ -2420 +2415 @@
 static DECLCALLBACK(int) vrbProcSetVolumeKnobCtrl(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
 
@@ -2429 +2421 @@
         pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].volumeKnob.u32F0f_param;
     else
-        LogRel2(("HDA: Warning: Unhandled set volume knob control command for NID0x%x: 0x%x\n", CODEC_NID(cmd), cmd));
+        LogRel2(("HDA: Warning: Unhandled set volume knob control command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
 
     if (pu32Reg)
@@ -2440 +2432 @@
 static DECLCALLBACK(int) vrbProcGetGPIOData(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
 
@@ -2451 +2440 @@
 static DECLCALLBACK(int) vrbProcSetGPIOData(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
 
@@ -2462 +2448 @@
 static DECLCALLBACK(int) vrbProcGetGPIOEnableMask(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
 
@@ -2473 +2456 @@
 static DECLCALLBACK(int) vrbProcSetGPIOEnableMask(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
 
@@ -2484 +2464 @@
 static DECLCALLBACK(int) vrbProcGetGPIOUnsolisted(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
 
@@ -2493 +2470 @@
         *pResp = pThis->paNodes[1].afg.u32F17_param;
     else
-        LogRel2(("HDA: Warning: Unhandled get GPIO unsolisted command for NID0x%x: 0x%x\n", CODEC_NID(cmd), cmd));
+        LogRel2(("HDA: Warning: Unhandled get GPIO unsolisted command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
 
     return VINF_SUCCESS;
@@ -2501 +2478 @@
 static DECLCALLBACK(int) vrbProcSetGPIOUnsolisted(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
 
@@ -2510 +2484 @@
         pu32Reg = &pThis->paNodes[1].afg.u32F17_param;
     else
-        LogRel2(("HDA: Warning: Unhandled set GPIO unsolisted command for NID0x%x: 0x%x\n", CODEC_NID(cmd), cmd));
+        LogRel2(("HDA: Warning: Unhandled set GPIO unsolisted command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
 
     if (pu32Reg)
@@ -2521 +2495 @@
 static DECLCALLBACK(int) vrbProcGetConfig(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
 
@@ -2539 +2510 @@
         *pResp = pThis->paNodes[CODEC_NID(cmd)].reserved.u32F1c_param;
     else
-        LogRel2(("HDA: Warning: Unhandled get config command for NID0x%x: 0x%x\n", CODEC_NID(cmd), cmd));
+        LogRel2(("HDA: Warning: Unhandled get config command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
 
     return VINF_SUCCESS;
@@ -2560 +2531 @@
         pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].reserved.u32F1c_param;
     else
-        LogRel2(("HDA: Warning: Unhandled set config command (%RU8) for NID0x%x: 0x%x\n", u8Offset, CODEC_NID(cmd), cmd));
+        LogRel2(("HDA: Warning: Unhandled set config command (%RU8) for NID0x%02x: 0x%x\n", u8Offset, CODEC_NID(cmd), cmd));
 
     if (pu32Reg)
@@ -2571 +2542 @@
 static DECLCALLBACK(int) vrbProcSetConfig0(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
     return codecSetConfigX(pThis, cmd, 0);
@@ -2581 +2549 @@
 static DECLCALLBACK(int) vrbProcSetConfig1(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
     return codecSetConfigX(pThis, cmd, 8);
@@ -2591 +2556 @@
 static DECLCALLBACK(int) vrbProcSetConfig2(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
     return codecSetConfigX(pThis, cmd, 16);
@@ -2601 +2563 @@
 static DECLCALLBACK(int) vrbProcSetConfig3(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
-    if (!vrbIsValidNode(pThis, cmd, pResp))
-        return VINF_SUCCESS;
-
     *pResp = 0;
     return codecSetConfigX(pThis, cmd, 24);
 }
 
+/* F04 */
+static DECLCALLBACK(int) vrbProcGetSDISelect(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    *pResp = 0;
+
+    if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].dac.u32F04_param;
+    else
+        LogRel2(("HDA: Warning: Unhandled get SDI select command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
+
+    return VINF_SUCCESS;
+}
+
+/* 704 */
+static DECLCALLBACK(int) vrbProcSetSDISelect(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    *pResp = 0;
+
+    uint32_t *pu32Reg = NULL;
+    if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].dac.u32F04_param;
+    else
+        LogRel2(("HDA: Warning: Unhandled set SDI select command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
+
+    if (pu32Reg)
+        hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
+
+    return VINF_SUCCESS;
+}
 
 /**
@@ -2615 +2603 @@
 static const CODECVERB g_aCodecVerbs[] =
 {
-/*     verb     | verb mask              | callback               */
-/*   -----------  --------------------   -----------------------  */
-    { 0x000F0000, CODEC_VERB_8BIT_CMD , vrbProcGetParameter           },
-    { 0x000F0100, CODEC_VERB_8BIT_CMD , vrbProcGetConSelectCtrl       },
-    { 0x00070100, CODEC_VERB_8BIT_CMD , vrbProcSetConSelectCtrl       },
-    { 0x000F0600, CODEC_VERB_8BIT_CMD , vrbProcGetStreamId            },
-    { 0x00070600, CODEC_VERB_8BIT_CMD , vrbProcSetStreamId            },
-    { 0x000F0700, CODEC_VERB_8BIT_CMD , vrbProcGetPinCtrl             },
-    { 0x00070700, CODEC_VERB_8BIT_CMD , vrbProcSetPinCtrl             },
-    { 0x000F0800, CODEC_VERB_8BIT_CMD , vrbProcGetUnsolicitedEnabled  },
-    { 0x00070800, CODEC_VERB_8BIT_CMD , vrbProcSetUnsolicitedEnabled  },
-    { 0x000F0900, CODEC_VERB_8BIT_CMD , vrbProcGetPinSense            },
-    { 0x00070900, CODEC_VERB_8BIT_CMD , vrbProcSetPinSense            },
-    { 0x000F0200, CODEC_VERB_8BIT_CMD , vrbProcGetConnectionListEntry },
-    { 0x000F0300, CODEC_VERB_8BIT_CMD , vrbProcGetProcessingState     },
-    { 0x00070300, CODEC_VERB_8BIT_CMD , vrbProcSetProcessingState     },
-    { 0x000F0D00, CODEC_VERB_8BIT_CMD , vrbProcGetDigitalConverter    },
-    { 0x00070D00, CODEC_VERB_8BIT_CMD , vrbProcSetDigitalConverter1   },
-    { 0x00070E00, CODEC_VERB_8BIT_CMD , vrbProcSetDigitalConverter2   },
-    { 0x000F2000, CODEC_VERB_8BIT_CMD , vrbProcGetSubId               },
-    { 0x00072000, CODEC_VERB_8BIT_CMD , vrbProcSetSubId0              },
-    { 0x00072100, CODEC_VERB_8BIT_CMD , vrbProcSetSubId1              },
-    { 0x00072200, CODEC_VERB_8BIT_CMD , vrbProcSetSubId2              },
-    { 0x00072300, CODEC_VERB_8BIT_CMD , vrbProcSetSubId3              },
-    { 0x0007FF00, CODEC_VERB_8BIT_CMD , vrbProcReset                  },
-    { 0x000F0500, CODEC_VERB_8BIT_CMD , vrbProcGetPowerState          },
-    { 0x00070500, CODEC_VERB_8BIT_CMD , vrbProcSetPowerState          },
-    { 0x000F0C00, CODEC_VERB_8BIT_CMD , vrbProcGetEAPD_BTLEnabled     },
-    { 0x00070C00, CODEC_VERB_8BIT_CMD , vrbProcSetEAPD_BTLEnabled     },
-    { 0x000F0F00, CODEC_VERB_8BIT_CMD , vrbProcGetVolumeKnobCtrl      },
-    { 0x00070F00, CODEC_VERB_8BIT_CMD , vrbProcSetVolumeKnobCtrl      },
-    { 0x000F1500, CODEC_VERB_8BIT_CMD , vrbProcGetGPIOData            },
-    { 0x00071500, CODEC_VERB_8BIT_CMD , vrbProcSetGPIOData            },
-    { 0x000F1600, CODEC_VERB_8BIT_CMD , vrbProcGetGPIOEnableMask      },
-    { 0x00071600, CODEC_VERB_8BIT_CMD , vrbProcSetGPIOEnableMask      },
-    { 0x000F1700, CODEC_VERB_8BIT_CMD , vrbProcGetGPIOUnsolisted      },
-    { 0x00071700, CODEC_VERB_8BIT_CMD , vrbProcSetGPIOUnsolisted      },
-    { 0x000F1C00, CODEC_VERB_8BIT_CMD , vrbProcGetConfig              },
-    { 0x00071C00, CODEC_VERB_8BIT_CMD , vrbProcSetConfig0             },
-    { 0x00071D00, CODEC_VERB_8BIT_CMD , vrbProcSetConfig1             },
-    { 0x00071E00, CODEC_VERB_8BIT_CMD , vrbProcSetConfig2             },
-    { 0x00071F00, CODEC_VERB_8BIT_CMD , vrbProcSetConfig3             },
-    { 0x000A0000, CODEC_VERB_16BIT_CMD, vrbProcGetConverterFormat     },
-    { 0x00020000, CODEC_VERB_16BIT_CMD, vrbProcSetConverterFormat     },
-    { 0x000B0000, CODEC_VERB_16BIT_CMD, vrbProcGetAmplifier           },
-    { 0x00030000, CODEC_VERB_16BIT_CMD, vrbProcSetAmplifier           },
+    /* Verb        Verb mask            Callback                        Name
+     * ---------- --------------------- ----------------------------------------------------------
+     */
+    { 0x000F0000, CODEC_VERB_8BIT_CMD , vrbProcGetParameter           , "GetParameter          " },
+    { 0x000F0100, CODEC_VERB_8BIT_CMD , vrbProcGetConSelectCtrl       , "GetConSelectCtrl      " },
+    { 0x00070100, CODEC_VERB_8BIT_CMD , vrbProcSetConSelectCtrl       , "SetConSelectCtrl      " },
+    { 0x000F0600, CODEC_VERB_8BIT_CMD , vrbProcGetStreamId            , "GetStreamId           " },
+    { 0x00070600, CODEC_VERB_8BIT_CMD , vrbProcSetStreamId            , "SetStreamId           " },
+    { 0x000F0700, CODEC_VERB_8BIT_CMD , vrbProcGetPinCtrl             , "GetPinCtrl            " },
+    { 0x00070700, CODEC_VERB_8BIT_CMD , vrbProcSetPinCtrl             , "SetPinCtrl            " },
+    { 0x000F0800, CODEC_VERB_8BIT_CMD , vrbProcGetUnsolicitedEnabled  , "GetUnsolicitedEnabled " },
+    { 0x00070800, CODEC_VERB_8BIT_CMD , vrbProcSetUnsolicitedEnabled  , "SetUnsolicitedEnabled " },
+    { 0x000F0900, CODEC_VERB_8BIT_CMD , vrbProcGetPinSense            , "GetPinSense           " },
+    { 0x00070900, CODEC_VERB_8BIT_CMD , vrbProcSetPinSense            , "SetPinSense           " },
+    { 0x000F0200, CODEC_VERB_8BIT_CMD , vrbProcGetConnectionListEntry , "GetConnectionListEntry" },
+    { 0x000F0300, CODEC_VERB_8BIT_CMD , vrbProcGetProcessingState     , "GetProcessingState    " },
+    { 0x00070300, CODEC_VERB_8BIT_CMD , vrbProcSetProcessingState     , "SetProcessingState    " },
+    { 0x000F0D00, CODEC_VERB_8BIT_CMD , vrbProcGetDigitalConverter    , "GetDigitalConverter   " },
+    { 0x00070D00, CODEC_VERB_8BIT_CMD , vrbProcSetDigitalConverter1   , "SetDigitalConverter1  " },
+    { 0x00070E00, CODEC_VERB_8BIT_CMD , vrbProcSetDigitalConverter2   , "SetDigitalConverter2  " },
+    { 0x000F2000, CODEC_VERB_8BIT_CMD , vrbProcGetSubId               , "GetSubId              " },
+    { 0x00072000, CODEC_VERB_8BIT_CMD , vrbProcSetSubId0              , "SetSubId0             " },
+    { 0x00072100, CODEC_VERB_8BIT_CMD , vrbProcSetSubId1              , "SetSubId1             " },
+    { 0x00072200, CODEC_VERB_8BIT_CMD , vrbProcSetSubId2              , "SetSubId2             " },
+    { 0x00072300, CODEC_VERB_8BIT_CMD , vrbProcSetSubId3              , "SetSubId3             " },
+    { 0x0007FF00, CODEC_VERB_8BIT_CMD , vrbProcReset                  , "Reset                 " },
+    { 0x000F0500, CODEC_VERB_8BIT_CMD , vrbProcGetPowerState          , "GetPowerState         " },
+    { 0x00070500, CODEC_VERB_8BIT_CMD , vrbProcSetPowerState          , "SetPowerState         " },
+    { 0x000F0C00, CODEC_VERB_8BIT_CMD , vrbProcGetEAPD_BTLEnabled     , "GetEAPD_BTLEnabled    " },
+    { 0x00070C00, CODEC_VERB_8BIT_CMD , vrbProcSetEAPD_BTLEnabled     , "SetEAPD_BTLEnabled    " },
+    { 0x000F0F00, CODEC_VERB_8BIT_CMD , vrbProcGetVolumeKnobCtrl      , "GetVolumeKnobCtrl     " },
+    { 0x00070F00, CODEC_VERB_8BIT_CMD , vrbProcSetVolumeKnobCtrl      , "SetVolumeKnobCtrl     " },
+    { 0x000F1500, CODEC_VERB_8BIT_CMD , vrbProcGetGPIOData            , "GetGPIOData           " },
+    { 0x00071500, CODEC_VERB_8BIT_CMD , vrbProcSetGPIOData            , "SetGPIOData           " },
+    { 0x000F1600, CODEC_VERB_8BIT_CMD , vrbProcGetGPIOEnableMask      , "GetGPIOEnableMask     " },
+    { 0x00071600, CODEC_VERB_8BIT_CMD , vrbProcSetGPIOEnableMask      , "SetGPIOEnableMask     " },
+    { 0x000F1700, CODEC_VERB_8BIT_CMD , vrbProcGetGPIOUnsolisted      , "GetGPIOUnsolisted     " },
+    { 0x00071700, CODEC_VERB_8BIT_CMD , vrbProcSetGPIOUnsolisted      , "SetGPIOUnsolisted     " },
+    { 0x000F1C00, CODEC_VERB_8BIT_CMD , vrbProcGetConfig              , "GetConfig             " },
+    { 0x00071C00, CODEC_VERB_8BIT_CMD , vrbProcSetConfig0             , "SetConfig0            " },
+    { 0x00071D00, CODEC_VERB_8BIT_CMD , vrbProcSetConfig1             , "SetConfig1            " },
+    { 0x00071E00, CODEC_VERB_8BIT_CMD , vrbProcSetConfig2             , "SetConfig2            " },
+    { 0x00071F00, CODEC_VERB_8BIT_CMD , vrbProcSetConfig3             , "SetConfig3            " },
+    { 0x000A0000, CODEC_VERB_16BIT_CMD, vrbProcGetConverterFormat     , "GetConverterFormat    " },
+    { 0x00020000, CODEC_VERB_16BIT_CMD, vrbProcSetConverterFormat     , "SetConverterFormat    " },
+    { 0x000B0000, CODEC_VERB_16BIT_CMD, vrbProcGetAmplifier           , "GetAmplifier          " },
+    { 0x00030000, CODEC_VERB_16BIT_CMD, vrbProcSetAmplifier           , "SetAmplifier          " },
+    { 0x000F0400, CODEC_VERB_8BIT_CMD , vrbProcGetSDISelect           , "GetSDISelect          " },
+    { 0x00070400, CODEC_VERB_8BIT_CMD , vrbProcSetSDISelect           , "SetSDISelect          " }
     /** @todo Implement 0x7e7: IDT Set GPIO (STAC922x only). */
 };
@@ -2717 +2708 @@
 
     CODECDBG_INDENT
+        codecDbgPrintf(pInfo, "Connections: %RU8\n", CODEC_F00_0E_COUNT(paReg00[0xE]));
         codecDbgPrintf(pInfo, "Amplifier Caps:\n");
         uint32_t uReg = paReg00[0xD];
@@ -2731 +2723 @@
                            CODEC_F00_12_STEP_SIZE(uReg),
                            CODEC_F00_12_OFFSET(uReg),
-                           RT_BOOL(CODEC_F00_0D_IS_CAP_MUTE(uReg)));
+                           RT_BOOL(CODEC_F00_12_IS_CAP_MUTE(uReg)));
         CODECDBG_UNINDENT
     CODECDBG_UNINDENT
@@ -2762 +2754 @@
 }
 
-static void codecDbgPrintNode(PCODECDBGINFO pInfo, PCODECNODE pNode)
+static void codecDbgPrintNode(PCODECDBGINFO pInfo, PCODECNODE pNode, bool fRecursive)
 {
     codecDbgPrintf(pInfo, "Node 0x%02x (%02RU8): ", pNode->node.id, pNode->node.id);
@@ -2854 +2846 @@
     else
         CODECDBG_PRINT("UNKNOWN TYPE 0x%x\n", pNode->node.id);
+
+    if (fRecursive)
+    {
+#define CODECDBG_PRINT_CONLIST_ENTRY(_aNode, _aEntry)                              \
+        if (cCnt >= _aEntry)                                                       \
+        {                                                                          \
+            const uint8_t uID = RT_BYTE##_aEntry(_aNode->node.au32F02_param[0x0]); \
+            if (pNode->node.id == uID)                                             \
+                codecDbgPrintNode(pInfo, _aNode, false /* fRecursive */);          \
+        }
+
+        /* Slow recursion, but this is debug stuff anyway. */
+        for (uint8_t i = 0; i < pInfo->pThis->cTotalNodes; i++)
+        {
+            const PCODECNODE pSubNode = &pInfo->pThis->paNodes[i];
+            if (pSubNode->node.id == pNode->node.id)
+                continue;
+
+            const uint8_t cCnt = CODEC_F00_0E_COUNT(pSubNode->node.au32F00_param[0xE]);
+            if (cCnt == 0) /* No connections present? Skip. */
+                continue;
+
+            CODECDBG_INDENT
+                CODECDBG_PRINT_CONLIST_ENTRY(pSubNode, 1)
+                CODECDBG_PRINT_CONLIST_ENTRY(pSubNode, 2)
+                CODECDBG_PRINT_CONLIST_ENTRY(pSubNode, 3)
+                CODECDBG_PRINT_CONLIST_ENTRY(pSubNode, 4)
+            CODECDBG_UNINDENT
+        }
+
+#undef CODECDBG_PRINT_CONLIST_ENTRY
+   }
 }
 
 static DECLCALLBACK(void) codecDbgListNodes(PHDACODEC pThis, PCDBGFINFOHLP pHlp, const char *pszArgs)
 {
-    pHlp->pfnPrintf(pHlp, "HDA LINK\n");
+    pHlp->pfnPrintf(pHlp, "HDA LINK / INPUTS\n");
 
     CODECDBGINFO dbgInfo;
@@ -2871 +2895 @@
         {
             PCODECNODE pNode = &pThis->paNodes[i];
-            if (pNode->node.au32F00_param[0xE] == 0) /* Start with all nodes connected directly to the HDA (Azalia) link. */
-                codecDbgPrintNode(&dbgInfo, pNode);
+
+            /* Start with all nodes which have connection entries set. */
+            if (CODEC_F00_0E_COUNT(pNode->node.au32F00_param[0xE]))
+                codecDbgPrintNode(&dbgInfo, pNode, true /* fRecursive */);
         }
     CODECDBG_UNINDENT
@@ -2883 +2909 @@
 #endif
 
-static DECLCALLBACK(int) codecLookup(PHDACODEC pThis, uint32_t cmd, PPFNHDACODECVERBPROCESSOR pfn)
-{
-    Assert(CODEC_CAD(cmd) == pThis->id);
+static DECLCALLBACK(int) codecLookup(PHDACODEC pThis, uint32_t cmd, uint64_t *puResp)
+{
+    AssertPtrReturn(pThis,  VERR_INVALID_POINTER);
+    AssertPtrReturn(puResp, VERR_INVALID_POINTER);
+
+    if (CODEC_CAD(cmd) != pThis->id)
+    {
+        *puResp = 0;
+        AssertMsgFailed(("Unknown codec address 0x%x\n", CODEC_CAD(cmd)));
+        return VERR_INVALID_PARAMETER;
+    }
 
     if (   CODEC_VERBDATA(cmd) == 0
         || CODEC_NID(cmd) >= pThis->cTotalNodes)
     {
-        *pfn = vrbProcUnimplemented;
-        AssertMsgFailed(("Unknown / invalid node 0x%x\n", CODEC_NID(cmd)));
-        return VINF_SUCCESS;
-    }
-
-    for (int i = 0; i < pThis->cVerbs; i++)
+        *puResp = 0;
+        AssertMsgFailed(("[NID0x%02x] Unknown / invalid node or data (0x%x)\n", CODEC_NID(cmd), CODEC_VERBDATA(cmd)));
+        return VERR_INVALID_PARAMETER;
+    }
+
+    /** @todo r=andy Implement a binary search here. */
+    for (size_t i = 0; i < pThis->cVerbs; i++)
     {
         if ((CODEC_VERBDATA(cmd) & pThis->paVerbs[i].mask) == pThis->paVerbs[i].verb)
         {
-            *pfn = pThis->paVerbs[i].pfn;
-            return VINF_SUCCESS;
-        }
-    }
-
-    *pfn = vrbProcUnimplemented;
-
-    LogFlowFunc(("[NID0x%x] Callback for %x not found\n", CODEC_NID(cmd), CODEC_VERBDATA(cmd)));
-    return VINF_SUCCESS;
+            int rc2 = pThis->paVerbs[i].pfn(pThis, cmd, puResp);
+            AssertRC(rc2);
+            Log3Func(("[NID0x%02x] (0x%x) %s: 0x%x -> 0x%x\n",
+                      CODEC_NID(cmd), pThis->paVerbs[i].verb, pThis->paVerbs[i].pszName, CODEC_VERB_PAYLOAD8(cmd), *puResp));
+            return rc2;
+        }
+    }
+
+    *puResp = 0;
+    LogFunc(("[NID0x%02x] Callback for %x not found\n", CODEC_NID(cmd), CODEC_VERBDATA(cmd)));
+    return VERR_NOT_FOUND;
 }
 
@@ -2923 +2960 @@
     switch (enmMixerCtl)
     {
+        case PDMAUDIOMIXERCTL_VOLUME:
+        case PDMAUDIOMIXERCTL_FRONT:
+#ifdef VBOX_WITH_HDA_51_SURROUND
+        case PDMAUDIOMIXERCTL_CENTER_LFE:
+        case PDMAUDIOMIXERCTL_REAR:
+#endif
+        {
+            break;
+        }
         case PDMAUDIOMIXERCTL_LINE_IN:
 #ifdef VBOX_WITH_HDA_MIC_IN
@@ -2928 +2974 @@
 #endif
         {
-            pCfg->enmDir = PDMAUDIODIR_IN;
             break;
         }
-
-        case PDMAUDIOMIXERCTL_VOLUME:
-        case PDMAUDIOMIXERCTL_FRONT:
-        {
-            pCfg->enmDir = PDMAUDIODIR_OUT;
-            break;
-        }
-
         default:
             AssertMsgFailed(("Mixer control %ld not implemented\n", enmMixerCtl));
@@ -2954 +2991 @@
 int hdaCodecRemoveStream(PHDACODEC pThis, PDMAUDIOMIXERCTL enmMixerCtl)
 {
-    return VINF_SUCCESS;
+    AssertPtrReturn(pThis, VERR_INVALID_POINTER);
+
+    int rc = pThis->pfnMixerRemoveStream(pThis->pHDAState, enmMixerCtl);
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
 }
 
@@ -3033 +3075 @@
 }
 
-int hdaCodecDestruct(PHDACODEC pThis)
-{
-    AssertPtrReturn(pThis, VERR_INVALID_POINTER);
+/**
+ * Powers off the codec.
+ *
+ * @param   pThis           Codec to power off.
+ */
+void hdaCodecPowerOff(PHDACODEC pThis)
+{
+    if (!pThis)
+        return;
+
+    LogFlowFuncEnter();
+
+    LogRel2(("HDA: Powering off codec ...\n"));
+
+    int rc2 = hdaCodecRemoveStream(pThis, PDMAUDIOMIXERCTL_FRONT);
+    AssertRC(rc2);
+#ifdef VBOX_WITH_HDA_51_SURROUND
+    rc2 = hdaCodecRemoveStream(pThis, PDMAUDIOMIXERCTL_CENTER_LFE);
+    AssertRC(rc2);
+    rc2 = hdaCodecRemoveStream(pThis, PDMAUDIOMIXERCTL_REAR);
+    AssertRC(rc2);
+#endif
+
+#ifdef VBOX_WITH_HDA_MIC_IN
+    rc2 = hdaCodecRemoveStream(pThis, PDMAUDIOMIXERCTL_MIC_IN);
+    AssertRC(rc2);
+#endif
+    rc2 = hdaCodecRemoveStream(pThis, PDMAUDIOMIXERCTL_LINE_IN);
+    AssertRC(rc2);
+}
+
+void hdaCodecDestruct(PHDACODEC pThis)
+{
+    if (!pThis)
+        return;
+
+    LogFlowFuncEnter();
 
     if (pThis->paNodes)
@@ -3042 +3118 @@
         pThis->paNodes = NULL;
     }
-
-    return VINF_SUCCESS;
 }
 
@@ -3064 +3138 @@
 
     int rc = stac9220Construct(pThis);
-    AssertRC(rc);
+    AssertRCReturn(rc, rc);
 
     /* Common root node initializers. */
@@ -3076 +3150 @@
     pThis->paNodes[STAC9220_NID_AFG].afg.u32F20_param = CODEC_MAKE_F20(pThis->u16VendorId, pThis->u8BSKU, pThis->u8AssemblyId);
 
-    /* Initialize the streams to some default values (44.1 kHz, 16-bit signed, 2 channels).
-     * The codec's (fixed) delivery rate is 48kHz, so a frame will be delivered every 20.83us. */
-    PDMAUDIOSTREAMCFG strmCfg;
-    strmCfg.pszName       = NULL;
-    strmCfg.uHz           = 44100;
-    strmCfg.cChannels     = 2;
-    strmCfg.enmFormat     = AUD_FMT_S16;
-    strmCfg.enmEndianness = PDMAUDIOHOSTENDIANNESS;
-
-    /*
-     * Output streams.
-     */
-    strmCfg.enmDir = PDMAUDIODIR_OUT;
-
-    /* Front. */
-    strmCfg.DestSource.Dest = PDMAUDIOPLAYBACKDEST_FRONT;
-    rc = hdaCodecAddStream(pThis, PDMAUDIOMIXERCTL_FRONT, &strmCfg);
-    AssertRC(rc);
+    do
+    {
+        /* Initialize the streams to some default values (44.1 kHz, 16-bit signed, 2 channels).
+         * The codec's (fixed) delivery rate is 48kHz, so a frame will be delivered every 20.83us. */
+        PDMAUDIOSTREAMCFG strmCfg;
+        RT_ZERO(strmCfg);
+        strmCfg.uHz           = 44100;
+        strmCfg.cChannels     = 2;
+        strmCfg.enmFormat     = PDMAUDIOFMT_S16;
+        strmCfg.enmEndianness = PDMAUDIOHOSTENDIANNESS;
+
+        /*
+         * Output streams.
+         */
+        strmCfg.enmDir = PDMAUDIODIR_OUT;
+
+        /* Front. */
+        RTStrPrintf(strmCfg.szName, RT_ELEMENTS(strmCfg.szName), "Front");
+        strmCfg.DestSource.Dest = PDMAUDIOPLAYBACKDEST_FRONT;
+        rc = hdaCodecAddStream(pThis, PDMAUDIOMIXERCTL_FRONT, &strmCfg);
+        AssertRCBreak(rc);
 
 #ifdef VBOX_WITH_HDA_51_SURROUND
-    /* Center / LFE. */
-    strmCfg.DestSource.Dest = PDMAUDIOPLAYBACKDEST_CENTER_LFE;
-    rc = hdaCodecAddStream(pThis, PDMAUDIOMIXERCTL_CENTER_LFE, &strmCfg);
-    AssertRC(rc);
-
-    /* Rear. */
-    strmCfg.DestSource.Dest = PDMAUDIOPLAYBACKDEST_REAR;
-    rc = hdaCodecAddStream(pThis, PDMAUDIOMIXERCTL_REAR, &strmCfg);
-    AssertRC(rc);
+        /* Center / LFE. */
+        RTStrPrintf(strmCfg.szName, RT_ELEMENTS(strmCfg.szName), "Center / LFE");
+        strmCfg.DestSource.Dest = PDMAUDIOPLAYBACKDEST_CENTER_LFE;
+        /** @todo Handle mono channel if only center *or* LFE is available? */
+        rc = hdaCodecAddStream(pThis, PDMAUDIOMIXERCTL_CENTER_LFE, &strmCfg);
+        AssertRCBreak(rc);
+
+        /* Rear. */
+        RTStrPrintf(strmCfg.szName, RT_ELEMENTS(strmCfg.szName), "Rear");
+        strmCfg.DestSource.Dest = PDMAUDIOPLAYBACKDEST_REAR;
+        rc = hdaCodecAddStream(pThis, PDMAUDIOMIXERCTL_REAR, &strmCfg);
+        AssertRCBreak(rc);
 #endif
 
-    /*
-     * Input streams.
-     */
-    strmCfg.enmDir = PDMAUDIODIR_IN;
+        /*
+         * Input streams.
+         */
+        strmCfg.enmDir = PDMAUDIODIR_IN;
 
 #ifdef VBOX_WITH_HDA_MIC_IN
-    strmCfg.DestSource.Source = PDMAUDIORECSOURCE_MIC;
-    rc = hdaCodecAddStream(pThis, PDMAUDIOMIXERCTL_MIC_IN, &strmCfg);
-    AssertRC(rc);
+        RTStrPrintf(strmCfg.szName, RT_ELEMENTS(strmCfg.szName), "Microphone In");
+        strmCfg.DestSource.Source = PDMAUDIORECSOURCE_MIC;
+        rc = hdaCodecAddStream(pThis, PDMAUDIOMIXERCTL_MIC_IN, &strmCfg);
+        AssertRCBreak(rc);
 #endif
-    strmCfg.DestSource.Source = PDMAUDIORECSOURCE_LINE;
-    rc = hdaCodecAddStream(pThis, PDMAUDIOMIXERCTL_LINE_IN, &strmCfg);
-    AssertRC(rc);
+        RTStrPrintf(strmCfg.szName, RT_ELEMENTS(strmCfg.szName), "Line In");
+        strmCfg.DestSource.Source = PDMAUDIORECSOURCE_LINE;
+        rc = hdaCodecAddStream(pThis, PDMAUDIOMIXERCTL_LINE_IN, &strmCfg);
+        AssertRCBreak(rc);
+
+    } while (0);
+
+    /** @todo Handle rc here? */
 
     /*

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

@@ -41 +41 @@
 typedef struct CODECVERB
 {
-    uint32_t verb;
-    /** operation bitness mask */
-    uint32_t mask;
+    /** Verb. */
+    uint32_t                 verb;
+    /** Verb mask. */
+    uint32_t                 mask;
+    /** Function pointer for implementation callback. */
     PFNHDACODECVERBPROCESSOR pfn;
+    /** Friendly name, for debugging. */
+    const char              *pszName;
 } CODECVERB;
 
@@ -65 +69 @@
 
     CODECVERB const        *paVerbs;
-    int                     cVerbs;
+    size_t                  cVerbs;
 
     PCODECNODE              paNodes;
@@ -95 +99 @@
     DECLR3CALLBACKMEMBER(int, pfnMixerSetVolume, (PHDASTATE pThis, PDMAUDIOMIXERCTL enmMixerCtl, PPDMAUDIOVOLUME pVol));
     /** Callbacks by codec implementation. */
-    DECLR3CALLBACKMEMBER(int, pfnLookup, (PHDACODEC pThis, uint32_t verb, PPFNHDACODECVERBPROCESSOR));
+    DECLR3CALLBACKMEMBER(int, pfnLookup, (PHDACODEC pThis, uint32_t uVerb, uint64_t *puResp));
     DECLR3CALLBACKMEMBER(int, pfnReset, (PHDACODEC pThis));
     DECLR3CALLBACKMEMBER(int, pfnCodecNodeReset, (PHDACODEC pThis, uint8_t, PCODECNODE));
@@ -104 +108 @@
 
 int hdaCodecConstruct(PPDMDEVINS pDevIns, PHDACODEC pThis, uint16_t uLUN, PCFGMNODE pCfg);
-int hdaCodecDestruct(PHDACODEC pThis);
+void hdaCodecDestruct(PHDACODEC pThis);
+void hdaCodecPowerOff(PHDACODEC pThis);
 int hdaCodecSaveState(PHDACODEC pThis, PSSMHANDLE pSSM);
 int hdaCodecLoadState(PHDACODEC pThis, PSSMHANDLE pSSM, uint32_t uVersion);

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

@@ -79 +79 @@
     R3PTRTYPE(PPDMAUDIOGSTSTRMOUT)     pStrmOut;
     /** Mixer handle for output stream. */
-    R3PTRTYPE(PAUDMIXSTREAM)           phStrmOut;
+    R3PTRTYPE(PAUDMIXSTREAM)           pMixStrm;
 } SB16OUTPUTSTREAM, *PSB16OUTPUTSTREAM;
 
@@ -473 +473 @@
 static void dma_cmd8(PSB16STATE pThis, int mask, int dma_len)
 {
-    pThis->fmt        = AUD_FMT_U8;
+    pThis->fmt        = PDMAUDIOFMT_U8;
     pThis->use_hdma   = 0;
     pThis->fmt_bits   = 8;
@@ -576 +576 @@
 
     if (16 == pThis->fmt_bits)
-        pThis->fmt = pThis->fmt_signed ? AUD_FMT_S16 : AUD_FMT_U16;
+        pThis->fmt = pThis->fmt_signed ? PDMAUDIOFMT_S16 : PDMAUDIOFMT_U16;
     else
-        pThis->fmt = pThis->fmt_signed ? AUD_FMT_S8 : AUD_FMT_U8;
+        pThis->fmt = pThis->fmt_signed ? PDMAUDIOFMT_S8 : PDMAUDIOFMT_U8;
 
     pThis->left_till_irq = pThis->block_size;
@@ -1095 +1095 @@
     uint8_t rvol = sb16MixRegToVol(pThis, 0x33);
     PDMAUDIOVOLUME vol = { false, lvol, rvol };
-    AudioMixerSetSinkVolume(pThis->pSinkOutput, &vol);
+    AudioMixerSinkSetVolume(pThis->pSinkOutput, &vol);
 }
 
@@ -1108 +1108 @@
     streamCfg.uHz           = pThis->freq;
     streamCfg.cChannels     = 1; /* Mono */
-    streamCfg.enmFormat     = AUD_FMT_U8;
+    streamCfg.enmFormat     = PDMAUDIOFMT_U8;
     streamCfg.enmEndianness = PDMAUDIOHOSTENDIANNESS;
 
@@ -1318 +1318 @@
 
     RTListForEach(&pThis->lstDrv, pDrv, SB16DRIVER, Node)
-        pDrv->Out.phStrmOut = NULL;
+        pDrv->Out.pMixStrm = NULL;
 
     pThis->pSinkOutput = NULL;
@@ -1364 +1364 @@
         streamCfg.uHz           = 44100;
         streamCfg.cChannels     = 2;
-        streamCfg.enmFormat     = AUD_FMT_S16;
+        streamCfg.enmFormat     = PDMAUDIOFMT_S16;
         streamCfg.enmEndianness = PDMAUDIOHOSTENDIANNESS;
 
@@ -1371 +1371 @@
 
         /* Add all required audio sinks. */
-        rc2 = AudioMixerAddSink(pThis->pMixer, "[Playback] PCM Output",
-                                AUDMIXSINKDIR_OUTPUT, &pThis->pSinkOutput);
+        rc2 = AudioMixerCreateSink(pThis->pMixer, "[Playback] PCM Output", AUDMIXSINKDIR_OUTPUT, &pThis->pSinkOutput);
         AssertRC(rc2);
     }
@@ -2066 +2065 @@
         }
 
-        int rc2 = pDrv->pConnector->pfnCreateOut(pDrv->pConnector, pszDesc, pCfg, &pDrv->Out.pStrmOut);
-        LogFlowFunc(("LUN#%RU8: Created output with rc=%Rrc\n", uLUN, rc));
-        if (rc2 == VINF_SUCCESS) /* Note: Could return VWRN_ALREADY_EXISTS. */
+        AudioMixerSinkRemoveStream(pThis->pSinkOutput, pDrv->Out.pMixStrm);
+
+        AudioMixerStreamDestroy(pDrv->Out.pMixStrm);
+        pDrv->Out.pMixStrm = NULL;
+
+        int rc2 = AudioMixerStreamCreate(pDrv->pConnector, pCfg, 0 /* fFlags */, &pDrv->Out.pMixStrm);
+        if (RT_SUCCESS(rc2))
         {
-            AudioMixerRemoveStream(pThis->pSinkOutput, pDrv->Out.phStrmOut);
-            rc = AudioMixerAddStreamOut(pThis->pSinkOutput,
-                                        pDrv->pConnector, pDrv->Out.pStrmOut,
-                                        0 /* uFlags */,
-                                        &pDrv->Out.phStrmOut);
+            rc2 = AudioMixerSinkAddStream(pThis->pSinkOutput, pDrv->Out.pMixStrm);
+            LogFlowFunc(("LUN#%RU8: Created output \"%s\", rc=%Rrc\n", pDrv->uLUN, pszDesc, rc2));
         }
 
@@ -2150 +2150 @@
 
     RTListForEach(&pThis->lstDrv, pDrv, SB16DRIVER, Node)
-        pDrv->Out.phStrmOut = NULL;
+        pDrv->Out.pMixStrm = NULL;
 
     pThis->pSinkOutput = NULL;

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

@@ -65 +65 @@
 #include "AudioMixBuffer.h"
 
+static int drvAudioAllocHstIn(PDRVAUDIO pThis, PPDMAUDIOSTREAMCFG pCfg, PPDMAUDIOHSTSTRMIN *ppHstStrmIn);
+static int drvAudioAllocHstOut(PDRVAUDIO pThis, PPDMAUDIOSTREAMCFG pCfg, PPDMAUDIOHSTSTRMOUT *ppHstStrmOut);
+static int drvAudioCreateStreamPairIn(PDRVAUDIO pThis, PPDMAUDIOSTREAMCFG pCfg, PPDMAUDIOGSTSTRMIN *ppGstStrmIn);
+static int drvAudioDestroyHstIn(PDRVAUDIO pThis, PPDMAUDIOHSTSTRMIN pHstStrmIn);
 static int drvAudioDestroyGstIn(PDRVAUDIO pThis, PPDMAUDIOGSTSTRMIN pGstStrmIn);
-
-static int drvAudioAllocHstIn(PDRVAUDIO pThis, const char *pszName, PPDMAUDIOSTREAMCFG pCfg, PDMAUDIORECSOURCE enmRecSource, PPDMAUDIOHSTSTRMIN *ppHstStrmIn);
-static int drvAudioDestroyHstIn(PDRVAUDIO pThis, PPDMAUDIOHSTSTRMIN pHstStrmIn);
-
-int drvAudioAddHstOut(PDRVAUDIO pThis, const char *pszName, PPDMAUDIOSTREAMCFG pCfg, PPDMAUDIOHSTSTRMOUT *ppHstStrmOut)
+static int drvAudioDestroyGstOut(PDRVAUDIO pThis, PPDMAUDIOGSTSTRMOUT pGstStrmOut);
+static PPDMAUDIOHSTSTRMIN drvAudioFindAnyHstIn(PDRVAUDIO pThis, PPDMAUDIOHSTSTRMIN pHstStrmIn);
+static PPDMAUDIOHSTSTRMOUT drvAudioFindAnyHstOut(PDRVAUDIO pThis, PPDMAUDIOHSTSTRMOUT pHstStrmOut);
+static PPDMAUDIOHSTSTRMOUT drvAudioFindSpecificOut(PDRVAUDIO pThis, PPDMAUDIOHSTSTRMOUT pHstStrmOut, PPDMAUDIOSTREAMCFG pCfg);
+
+static int drvAudioGstInInit(PPDMAUDIOGSTSTRMIN pGstStrmIn, PPDMAUDIOHSTSTRMIN pHstStrmIn, PPDMAUDIOSTREAMCFG pCfg);
+
+static void drvAudioHstInFreeRes(PPDMAUDIOHSTSTRMIN pHstStrmIn);
+static void drvAudioHstOutFreeRes(PPDMAUDIOHSTSTRMOUT pHstStrmOut);
+
+
+int drvAudioAddHstOut(PDRVAUDIO pThis, PPDMAUDIOSTREAMCFG pCfg, PPDMAUDIOHSTSTRMOUT *ppHstStrmOut)
 {
     AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
-    AssertPtrReturn(pszName, VERR_INVALID_POINTER);
     AssertPtrReturn(pCfg,    VERR_INVALID_POINTER);
 
@@ -81 +91 @@
     if (!pHstStrmOut)
     {
-        rc = drvAudioAllocHstOut(pThis, pszName, pCfg, &pHstStrmOut);
+        rc = drvAudioAllocHstOut(pThis, pCfg, &pHstStrmOut);
         if (RT_FAILURE(rc))
             pHstStrmOut = drvAudioFindAnyHstOut(pThis, NULL /* pHstStrmOut */);
@@ -113 +123 @@
     }
 
-    PDMAUDIOFMT fmt = drvAudioHlpStringToFormat(pszValue);
-    if (fmt == AUD_FMT_INVALID)
+    PDMAUDIOFMT fmt = DrvAudioStrToAudFmt(pszValue);
+    if (fmt == PDMAUDIOFMT_INVALID)
     {
          *pfDefault = true;
@@ -275 +285 @@
         switch (pCfg->enmFormat)
         {
-            case AUD_FMT_S8:
-            case AUD_FMT_U8:
-            case AUD_FMT_S16:
-            case AUD_FMT_U16:
-            case AUD_FMT_S32:
-            case AUD_FMT_U32:
+            case PDMAUDIOFMT_S8:
+            case PDMAUDIOFMT_U8:
+            case PDMAUDIOFMT_S16:
+            case PDMAUDIOFMT_U16:
+            case PDMAUDIOFMT_S32:
+            case PDMAUDIOFMT_U32:
                 break;
             default:
@@ -294 +304 @@
 }
 
-/**
- * Clears a sample buffer by the given amount of audio samples.
- *
- * @return  IPRT status code.
- * @param   pPCMProps               PCM properties to use for the buffer to clear.
- * @param   pvBuf                   Buffer to clear.
- * @param   cbBuf                   Size (in bytes) of the buffer.
- * @param   cSamples                Number of audio samples to clear in the buffer.
- */
-void DrvAudioClearBuf(PPDMPCMPROPS pPCMProps, void *pvBuf, size_t cbBuf, uint32_t cSamples)
-{
-    AssertPtrReturnVoid(pPCMProps);
-    AssertPtrReturnVoid(pvBuf);
-
-    if (!cbBuf || !cSamples)
-        return;
-
-    Log2Func(("pPCMInfo=%p, pvBuf=%p, cSamples=%RU32, fSigned=%RTbool, cBits=%RU8, cShift=%RU8\n",
-              pPCMProps, pvBuf, cSamples, pPCMProps->fSigned, pPCMProps->cBits, pPCMProps->cShift));
-
-    if (pPCMProps->fSigned)
-    {
-        memset(pvBuf, 0, cSamples << pPCMProps->cShift);
-    }
-    else
-    {
-        switch (pPCMProps->cBits)
-        {
-            case 8:
-            {
-                memset(pvBuf, 0x80, cSamples << pPCMProps->cShift);
-                break;
-            }
-
-            case 16:
-            {
-                uint16_t *p = (uint16_t *)pvBuf;
-                int shift = pPCMProps->cChannels - 1;
-                short s = INT16_MAX;
-
-                if (pPCMProps->fSwapEndian)
-                    s = RT_BSWAP_U16(s);
-
-                for (unsigned i = 0; i < cSamples << shift; i++)
-                    p[i] = s;
-
-                break;
-            }
-
-            case 32:
-            {
-                uint32_t *p = (uint32_t *)pvBuf;
-                int shift = pPCMProps->cChannels - 1;
-                int32_t s = INT32_MAX;
-
-                if (pPCMProps->fSwapEndian)
-                    s = RT_BSWAP_U32(s);
-
-                for (unsigned i = 0; i < cSamples << shift; i++)
-                    p[i] = s;
-
-                break;
-            }
-
-            default:
-            {
-                AssertMsgFailed(("Invalid bits: %RU8\n", pPCMProps->cBits));
-                break;
-            }
-        }
-    }
-}
-
 static int drvAudioControlHstIn(PDRVAUDIO pThis, PPDMAUDIOHSTSTRMIN pHstStrmIn, PDMAUDIOSTREAMCMD enmStreamCmd)
 {
@@ -375 +312 @@
     if (RT_FAILURE(rc))
         return rc;
+
+    LogFlowFunc(("enmStreamCmd=%ld\n", enmStreamCmd));
 
     switch (enmStreamCmd)
@@ -384 +323 @@
                 rc = pThis->pHostDrvAudio->pfnControlIn(pThis->pHostDrvAudio, pHstStrmIn, PDMAUDIOSTREAMCMD_ENABLE);
                 if (RT_SUCCESS(rc))
-                {
                     pHstStrmIn->fStatus |= PDMAUDIOSTRMSTS_FLAG_ENABLED;
-                }
-                else
-                    LogFlowFunc(("Backend reported an error when opening input stream, rc=%Rrc\n", rc));
             }
             else
@@ -403 +338 @@
                 if (RT_SUCCESS(rc))
                 {
-                    pHstStrmIn->fStatus = PDMAUDIOSTRMSTS_FLAG_NONE; /* Clear all. */
+                    pHstStrmIn->fStatus &= ~PDMAUDIOSTRMSTS_FLAG_ENABLED;
                     AudioMixBufClear(&pHstStrmIn->MixBuf);
                 }
-                else
-                    LogFlowFunc(("Backend vetoed closing output stream, rc=%Rrc\n", rc));
             }
             else
@@ -419 +352 @@
             if (!(pHstStrmIn->fStatus & PDMAUDIOSTRMSTS_FLAG_PAUSED))
             {
-                Assert(pHstStrmIn->fStatus & PDMAUDIOSTRMSTS_FLAG_ENABLED);
                 rc = pThis->pHostDrvAudio->pfnControlIn(pThis->pHostDrvAudio, pHstStrmIn, PDMAUDIOSTREAMCMD_PAUSE);
                 if (RT_SUCCESS(rc))
-                {
-                    LogFunc(("[%s] Pausing stream\n", pHstStrmIn->MixBuf.pszName));
                     pHstStrmIn->fStatus |= PDMAUDIOSTRMSTS_FLAG_PAUSED;
-                }
-                else
-                    LogFlowFunc(("Backend vetoed pausing input stream, rc=%Rrc\n", rc));
             }
             else
@@ -439 +366 @@
             if (pHstStrmIn->fStatus & PDMAUDIOSTRMSTS_FLAG_PAUSED)
             {
-                Assert(pHstStrmIn->fStatus & PDMAUDIOSTRMSTS_FLAG_ENABLED);
                 rc = pThis->pHostDrvAudio->pfnControlIn(pThis->pHostDrvAudio, pHstStrmIn, PDMAUDIOSTREAMCMD_RESUME);
                 if (RT_SUCCESS(rc))
-                {
                     pHstStrmIn->fStatus &= ~PDMAUDIOSTRMSTS_FLAG_PAUSED;
-                    LogFunc(("[%s] Resumed stream\n", pHstStrmIn->MixBuf.pszName));
-                }
-                else
-                    LogFlowFunc(("Backend vetoed resuming input stream, rc=%Rrc\n", rc));
             }
             else
@@ -461 +382 @@
     }
 
+    LogFunc(("[%s] Returned %Rrc\n", pHstStrmIn->MixBuf.pszName, rc));
+
     int rc2 = RTCritSectLeave(&pHstStrmIn->CritSect);
     if (RT_SUCCESS(rc))
@@ -470 +393 @@
 static int drvAudioControlHstOut(PDRVAUDIO pThis, PPDMAUDIOHSTSTRMOUT pHstStrmOut, PDMAUDIOSTREAMCMD enmStreamCmd)
 {
-    AssertPtrReturn(pThis, VERR_INVALID_POINTER);
+    AssertPtrReturn(pThis,       VERR_INVALID_POINTER);
     AssertPtrReturn(pHstStrmOut, VERR_INVALID_POINTER);
 
@@ -476 +399 @@
     if (RT_FAILURE(rc))
         return rc;
+
+    LogFlowFunc(("enmStreamCmd=%ld\n", enmStreamCmd));
 
     switch (enmStreamCmd)
@@ -488 +413 @@
                     Assert(!(pHstStrmOut->fStatus & PDMAUDIOSTRMSTS_FLAG_PENDING_DISABLE));
                     pHstStrmOut->fStatus |= PDMAUDIOSTRMSTS_FLAG_ENABLED;
-                    LogFunc(("[%s] Enabled stream\n", pHstStrmOut->MixBuf.pszName));
                 }
-                else
-                    LogFlowFunc(("[%s] Backend reported an error when enabling output stream, rc=%Rrc\n",
-                                 pHstStrmOut->MixBuf.pszName, rc));
             }
             else
@@ -507 +428 @@
                 if (RT_SUCCESS(rc))
                 {
-                    pHstStrmOut->fStatus = PDMAUDIOSTRMSTS_FLAG_NONE; /* Clear all. */
+                    pHstStrmOut->fStatus &= ~PDMAUDIOSTRMSTS_FLAG_ENABLED;
                     AudioMixBufClear(&pHstStrmOut->MixBuf);
-
-                    LogFunc(("[%s] Disabled stream\n", pHstStrmOut->MixBuf.pszName));
                 }
-                else
-                    LogFlowFunc(("[%s] Backend vetoed disabling output stream, rc=%Rrc\n", pHstStrmOut->MixBuf.pszName, rc));
             }
             else
@@ -525 +442 @@
             if (!(pHstStrmOut->fStatus & PDMAUDIOSTRMSTS_FLAG_PAUSED))
             {
-                Assert(pHstStrmOut->fStatus & PDMAUDIOSTRMSTS_FLAG_ENABLED);
                 rc = pThis->pHostDrvAudio->pfnControlOut(pThis->pHostDrvAudio, pHstStrmOut, PDMAUDIOSTREAMCMD_PAUSE);
                 if (RT_SUCCESS(rc))
-                {
                     pHstStrmOut->fStatus |= PDMAUDIOSTRMSTS_FLAG_PAUSED;
-                    LogFunc(("[%s] Pausing stream\n", pHstStrmOut->MixBuf.pszName));
-                }
-                else
-                    LogFlowFunc(("[%s] Backend vetoed pausing output stream, rc=%Rrc\n", pHstStrmOut->MixBuf.pszName, rc));
             }
             else
@@ -545 +456 @@
             if (pHstStrmOut->fStatus & PDMAUDIOSTRMSTS_FLAG_PAUSED)
             {
-                Assert(pHstStrmOut->fStatus & PDMAUDIOSTRMSTS_FLAG_ENABLED);
                 rc = pThis->pHostDrvAudio->pfnControlOut(pThis->pHostDrvAudio, pHstStrmOut, PDMAUDIOSTREAMCMD_RESUME);
                 if (RT_SUCCESS(rc))
-                {
                     pHstStrmOut->fStatus &= ~PDMAUDIOSTRMSTS_FLAG_PAUSED;
-                    LogFunc(("[%s] Resumed stream\n", pHstStrmOut->MixBuf.pszName));
-                }
-                else
-                    LogFlowFunc(("[%s] Backend vetoed resuming output stream, rc=%Rrc\n", pHstStrmOut->MixBuf.pszName, rc));
             }
             else
@@ -567 +472 @@
     }
 
+    LogFunc(("[%s] Returned %Rrc\n", pHstStrmOut->MixBuf.pszName, rc));
+
     int rc2 = RTCritSectLeave(&pHstStrmOut->CritSect);
     if (RT_SUCCESS(rc))
@@ -574 +481 @@
 }
 
-int drvAudioDestroyHstOut(PDRVAUDIO pThis, PPDMAUDIOHSTSTRMOUT pHstStrmOut)
-{
-    AssertPtrReturn(pThis, VERR_INVALID_POINTER);
+static int drvAudioDestroyHstOut(PDRVAUDIO pThis, PPDMAUDIOHSTSTRMOUT pHstStrmOut)
+{
+    AssertPtrReturn(pThis,       VERR_INVALID_POINTER);
     AssertPtrReturn(pHstStrmOut, VERR_INVALID_POINTER);
 
     LogFlowFunc(("%s\n", pHstStrmOut->MixBuf.pszName));
 
-    int rc;
+    int rc = VINF_SUCCESS;
+
     if (RTListIsEmpty(&pHstStrmOut->lstGstStrmOut))
     {
-        rc = pThis->pHostDrvAudio->pfnFiniOut(pThis->pHostDrvAudio, pHstStrmOut);
-        if (RT_SUCCESS(rc))
-        {
-            drvAudioHstOutFreeRes(pHstStrmOut);
-
-            /* Remove from driver instance list. */
-            RTListNodeRemove(&pHstStrmOut->Node);
-
-            if (RTCritSectIsInitialized(&pHstStrmOut->CritSect))
-            {
-                int rc2 = RTCritSectDelete(&pHstStrmOut->CritSect);
-                AssertRC(rc2);
-            }
-
-            RTMemFree(pHstStrmOut);
-            pThis->cStreamsFreeOut++;
-            return VINF_SUCCESS;
-        }
+        drvAudioHstOutFreeRes(pHstStrmOut);
+
+        /* Remove from driver instance list. */
+        RTListNodeRemove(&pHstStrmOut->Node);
+
+        if (RTCritSectIsInitialized(&pHstStrmOut->CritSect))
+        {
+            int rc2 = RTCritSectDelete(&pHstStrmOut->CritSect);
+            AssertRC(rc2);
+        }
+
+        RTMemFree(pHstStrmOut);
+        pHstStrmOut = NULL;
+
+        pThis->cStreamsFreeOut++;
     }
     else
     {
-        rc = VERR_ACCESS_DENIED;
-        LogFlowFunc(("[%s] Still is being used, rc=%Rrc\n", pHstStrmOut->MixBuf.pszName, rc));
-    }
-
-    return rc;
-}
-
-int drvAudioDestroyGstOut(PDRVAUDIO pThis, PPDMAUDIOGSTSTRMOUT pGstStrmOut)
+        rc = VERR_WRONG_ORDER;
+        LogFlowFunc(("[%s] Still is being used, skipping\n", pHstStrmOut->MixBuf.pszName));
+    }
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+static int drvAudioDestroyGstOut(PDRVAUDIO pThis, PPDMAUDIOGSTSTRMOUT pGstStrmOut)
 {
     AssertPtrReturn(pThis, VERR_INVALID_POINTER);
@@ -619 +525 @@
         return VINF_SUCCESS;
 
+    LogFlowFunc(("%s\n", pGstStrmOut->MixBuf.pszName));
+
     if (pGstStrmOut->State.cRefs > 1) /* Do other objects still have a reference to it? Bail out. */
         return VERR_WRONG_ORDER;
 
-    drvAudioGstOutFreeRes(pGstStrmOut);
-
+    AudioMixBufDestroy(&pGstStrmOut->MixBuf);
+
+    /* Is this guest stream associate to a host stream? */
     if (pGstStrmOut->pHstStrmOut)
     {
         /* Unregister from parent first. */
         RTListNodeRemove(&pGstStrmOut->Node);
-
-        /* Try destroying the associated host output stream. This could
-         * be skipped if there are other guest output streams with this
-         * host stream. */
-        drvAudioDestroyHstOut(pThis, pGstStrmOut->pHstStrmOut);
     }
 
     RTMemFree(pGstStrmOut);
+    pGstStrmOut = NULL;
 
     return VINF_SUCCESS;
 }
 
-PPDMAUDIOHSTSTRMIN drvAudioFindNextHstIn(PDRVAUDIO pThis, PPDMAUDIOHSTSTRMIN pHstStrmIn)
+static PPDMAUDIOHSTSTRMIN drvAudioFindAnyHstIn(PDRVAUDIO pThis, PPDMAUDIOHSTSTRMIN pHstStrmIn)
 {
     if (pHstStrmIn)
@@ -653 +558 @@
 }
 
-PPDMAUDIOHSTSTRMIN drvAudioFindNextEnabledHstIn(PDRVAUDIO pThis, PPDMAUDIOHSTSTRMIN pHstStrmIn)
-{
-    while ((pHstStrmIn = drvAudioFindNextHstIn(pThis, pHstStrmIn)))
-        if (pHstStrmIn->fStatus & PDMAUDIOSTRMSTS_FLAG_ENABLED)
-            return pHstStrmIn;
-
-    return NULL;
-}
-
-PPDMAUDIOHSTSTRMIN drvAudioFindNextEqHstIn(PDRVAUDIO pThis, PPDMAUDIOHSTSTRMIN pHstStrmIn,
-                                           PPDMAUDIOSTREAMCFG pCfg)
-{
-    while ((pHstStrmIn = drvAudioFindNextHstIn(pThis, pHstStrmIn)))
-        if (drvAudioPCMPropsAreEqual(&pHstStrmIn->Props, pCfg))
-            return pHstStrmIn;
-
-    return NULL;
-}
-
-static int drvAudioHstInAdd(PDRVAUDIO pThis, const char *pszName, PPDMAUDIOSTREAMCFG pCfg, PDMAUDIORECSOURCE enmRecSource,
-                            PPDMAUDIOHSTSTRMIN *ppHstStrmIn)
-{
-    AssertPtrReturn(pThis, VERR_INVALID_POINTER);
-    AssertPtrReturn(pCfg, VERR_INVALID_POINTER);
+static int drvAudioHstInAdd(PDRVAUDIO pThis, PPDMAUDIOSTREAMCFG pCfg, PPDMAUDIOHSTSTRMIN *ppHstStrmIn)
+{
+    AssertPtrReturn(pThis,       VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfg,        VERR_INVALID_POINTER);
     AssertPtrReturn(ppHstStrmIn, VERR_INVALID_POINTER);
 
     PPDMAUDIOHSTSTRMIN pHstStrmIn;
-    int rc = drvAudioAllocHstIn(pThis, pszName, pCfg, enmRecSource, &pHstStrmIn);
+    int rc = drvAudioAllocHstIn(pThis, pCfg, &pHstStrmIn);
     if (RT_SUCCESS(rc))
         *ppHstStrmIn = pHstStrmIn;
@@ -688 +573 @@
 }
 
-int drvAudioGstOutInit(PPDMAUDIOGSTSTRMOUT pGstStrmOut, PPDMAUDIOHSTSTRMOUT pHostStrmOut,
-                       const char *pszName, PPDMAUDIOSTREAMCFG pCfg)
+static void drvAudioHstInFreeRes(PPDMAUDIOHSTSTRMIN pHstStrmIn)
+{
+    if (!pHstStrmIn)
+        return;
+
+    AudioMixBufDestroy(&pHstStrmIn->MixBuf);
+}
+
+static int drvAudioGstOutInit(PPDMAUDIOGSTSTRMOUT pGstStrmOut, PPDMAUDIOHSTSTRMOUT pHostStrmOut, PPDMAUDIOSTREAMCFG pCfg)
 {
     AssertPtrReturn(pGstStrmOut,  VERR_INVALID_POINTER);
     AssertPtrReturn(pHostStrmOut, VERR_INVALID_POINTER);
-    AssertPtrReturn(pszName,      VERR_INVALID_POINTER);
     AssertPtrReturn(pCfg,         VERR_INVALID_POINTER);
 
@@ -699 +590 @@
     if (RT_SUCCESS(rc))
     {
-        char *pszTemp;
-        if (RTStrAPrintf(&pszTemp, "%s (Guest)", pszName) <= 0)
+        char *pszName;
+        if (RTStrAPrintf(&pszName, "%s (Guest)", pCfg->szName) <= 0)
             return VERR_NO_MEMORY;
 
-        rc = AudioMixBufInit(&pGstStrmOut->MixBuf, pszTemp, &pGstStrmOut->Props, AudioMixBufSize(&pHostStrmOut->MixBuf));
+        rc = AudioMixBufInit(&pGstStrmOut->MixBuf, pszName, &pGstStrmOut->Props, AudioMixBufSize(&pHostStrmOut->MixBuf));
         if (RT_SUCCESS(rc))
             rc = AudioMixBufLinkTo(&pGstStrmOut->MixBuf, &pHostStrmOut->MixBuf);
-
-        RTStrFree(pszTemp);
 
         if (RT_SUCCESS(rc))
@@ -715 +604 @@
             pGstStrmOut->State.fEmpty  = true;
 
-            pGstStrmOut->State.pszName = RTStrDup(pszName);
-            if (!pGstStrmOut->State.pszName)
-                return VERR_NO_MEMORY;
+            RTStrPrintf(pGstStrmOut->State.szName, RT_ELEMENTS(pGstStrmOut->State.szName),
+                        "%s", pszName);
 
             pGstStrmOut->pHstStrmOut = pHostStrmOut;
         }
-    }
-
-    LogFlowFunc(("pszName=%s, rc=%Rrc\n", pszName, rc));
-    return rc;
-}
-
-int drvAudioAllocHstOut(PDRVAUDIO pThis, const char *pszName, PPDMAUDIOSTREAMCFG pCfg, PPDMAUDIOHSTSTRMOUT *ppHstStrmOut)
+
+        RTStrFree(pszName);
+    }
+
+    LogFlowFunc(("pszName=%s, rc=%Rrc\n", pCfg->szName, rc));
+    return rc;
+}
+
+static int drvAudioAllocHstOut(PDRVAUDIO pThis, PPDMAUDIOSTREAMCFG pCfg, PPDMAUDIOHSTSTRMOUT *ppHstStrmOut)
 {
     AssertPtrReturn(pThis, VERR_INVALID_POINTER);
-    AssertPtrReturn(pszName, VERR_INVALID_POINTER);
-    AssertPtrReturn(pCfg, VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfg,  VERR_INVALID_POINTER);
 
     if (!pThis->cStreamsFreeOut)
@@ -755 +644 @@
 
     int rc;
-    bool fInitialized = false;
 
     do
@@ -761 +649 @@
         RTListInit(&pHstStrmOut->lstGstStrmOut);
 
-        uint32_t cSamples;
-        rc = pThis->pHostDrvAudio->pfnInitOut(pThis->pHostDrvAudio, pHstStrmOut, pCfg, &cSamples);
+        uint32_t cSamples = 0;
+        rc = pThis->pHostDrvAudio->pfnInitOut
+           ? pThis->pHostDrvAudio->pfnInitOut(pThis->pHostDrvAudio, pHstStrmOut, pCfg, &cSamples) : VINF_SUCCESS;
+
         if (RT_FAILURE(rc))
         {
@@ -769 +659 @@
         }
 
-        fInitialized = true;
-
-        char *pszTemp;
-        if (RTStrAPrintf(&pszTemp, "%s (Host)", pszName) <= 0)
+        pHstStrmOut->fStatus |= PDMAUDIOSTRMSTS_FLAG_INITIALIZED;
+
+        char *pszName;
+        if (RTStrAPrintf(&pszName, "%s (Host)", pCfg->szName) <= 0)
         {
             rc = VERR_NO_MEMORY;
@@ -778 +668 @@
         }
 
-        rc = AudioMixBufInit(&pHstStrmOut->MixBuf, pszTemp, &pHstStrmOut->Props, cSamples);
+        rc = AudioMixBufInit(&pHstStrmOut->MixBuf, pszName, &pHstStrmOut->Props, cSamples);
         if (RT_SUCCESS(rc))
             rc = RTCritSectInit(&pHstStrmOut->CritSect);
@@ -788 +678 @@
         }
 
-        RTStrFree(pszTemp);
+        RTStrFree(pszName);
 
     } while (0);
@@ -794 +684 @@
     if (RT_FAILURE(rc))
     {
-        if (fInitialized)
-        {
-            int rc2 = pThis->pHostDrvAudio->pfnFiniOut(pThis->pHostDrvAudio, pHstStrmOut);
-            AssertRC(rc2);
+        if (pHstStrmOut->fStatus & PDMAUDIOSTRMSTS_FLAG_INITIALIZED)
+        {
+            int rc2 = pThis->pHostDrvAudio->pfnFiniOut
+                    ? pThis->pHostDrvAudio->pfnFiniOut(pThis->pHostDrvAudio, pHstStrmOut) : VINF_SUCCESS;
+            if (RT_SUCCESS(rc2))
+                pHstStrmOut->fStatus &= ~PDMAUDIOSTRMSTS_FLAG_INITIALIZED;
         }
 
@@ -810 +702 @@
 }
 
-int drvAudioCreateStreamPairOut(PDRVAUDIO pThis, const char *pszName,
-                                PPDMAUDIOSTREAMCFG pCfg, PPDMAUDIOGSTSTRMOUT *ppGstStrmOut)
+static int drvAudioCreateStreamPairOut(PDRVAUDIO pThis, PPDMAUDIOSTREAMCFG pCfg, PPDMAUDIOGSTSTRMOUT *ppGstStrmOut)
 {
     AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
-    AssertPtrReturn(pszName, VERR_INVALID_POINTER);
     AssertPtrReturn(pCfg,    VERR_INVALID_POINTER);
 
@@ -821 +711 @@
     if (!pGstStrmOut)
     {
-        LogFlowFunc(("Failed to allocate memory for guest output stream \"%s\"\n", pszName));
+        LogFlowFunc(("Failed to allocate memory for guest output stream \"%s\"\n", pCfg->szName));
         return VERR_NO_MEMORY;
     }
@@ -829 +719 @@
      */
     PPDMAUDIOHSTSTRMOUT pHstStrmOut;
-    int rc = drvAudioAddHstOut(pThis, pszName, pCfg, &pHstStrmOut);
+    int rc = drvAudioAddHstOut(pThis, pCfg, &pHstStrmOut);
     if (RT_FAILURE(rc))
     {
-        LogFlowFunc(("Error adding host output stream \"%s\", rc=%Rrc\n", pszName, rc));
+        LogFlowFunc(("Error adding host output stream \"%s\", rc=%Rrc\n", pCfg->szName, rc));
 
         RTMemFree(pGstStrmOut);
@@ -842 +732 @@
      * by the device emulation (which in turn was/could be set by the guest OS).
      */
-    rc = drvAudioGstOutInit(pGstStrmOut, pHstStrmOut, pszName, pCfg);
+    rc = drvAudioGstOutInit(pGstStrmOut, pHstStrmOut, pCfg);
     if (RT_SUCCESS(rc))
     {
@@ -858 +748 @@
 }
 
-static int drvAudioCreateStreamPairIn(PDRVAUDIO pThis, const char *pszName, PDMAUDIORECSOURCE enmRecSource,
-                                      PPDMAUDIOSTREAMCFG pCfg, PPDMAUDIOGSTSTRMIN *ppGstStrmIn)
+static int drvAudioCreateStreamPairIn(PDRVAUDIO pThis, PPDMAUDIOSTREAMCFG pCfg, PPDMAUDIOGSTSTRMIN *ppGstStrmIn)
 {
     AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
-    AssertPtrReturn(pszName, VERR_INVALID_POINTER);
     AssertPtrReturn(pCfg,    VERR_INVALID_POINTER);
 
@@ -873 +761 @@
      */
     PPDMAUDIOHSTSTRMIN pHstStrmIn;
-    int rc = drvAudioHstInAdd(pThis, pszName, pCfg, enmRecSource, &pHstStrmIn);
+    int rc = drvAudioHstInAdd(pThis, pCfg, &pHstStrmIn);
     if (RT_FAILURE(rc))
     {
-        LogFunc(("Failed to add host audio input stream \"%s\", rc=%Rrc\n", pszName, rc));
+        LogFunc(("Failed to add host audio input stream \"%s\", rc=%Rrc\n", pCfg->szName, rc));
 
         RTMemFree(pGstStrmIn);
@@ -886 +774 @@
      * by the device emulation (which in turn was/could be set by the guest OS).
      */
-    rc = drvAudioGstInInit(pGstStrmIn, pHstStrmIn, pszName, pCfg);
+    rc = drvAudioGstInInit(pGstStrmIn, pHstStrmIn, pCfg);
     if (RT_SUCCESS(rc))
     {
@@ -908 +796 @@
  * @param   pHstStrmIn          Pointer to host input stream to associate this guest
  *                              stream with.
- * @param   pszName             Pointer to stream name to use for this stream.
  * @param   pCfg                Pointer to stream configuration to use.
  */
-int drvAudioGstInInit(PPDMAUDIOGSTSTRMIN pGstStrmIn, PPDMAUDIOHSTSTRMIN pHstStrmIn,
-                      const char *pszName, PPDMAUDIOSTREAMCFG pCfg)
+static int drvAudioGstInInit(PPDMAUDIOGSTSTRMIN pGstStrmIn, PPDMAUDIOHSTSTRMIN pHstStrmIn, PPDMAUDIOSTREAMCFG pCfg)
 {
     AssertPtrReturn(pGstStrmIn, VERR_INVALID_POINTER);
     AssertPtrReturn(pHstStrmIn, VERR_INVALID_POINTER);
-    AssertPtrReturn(pszName, VERR_INVALID_POINTER);
     AssertPtrReturn(pCfg, VERR_INVALID_POINTER);
 
@@ -922 +807 @@
     if (RT_SUCCESS(rc))
     {
-        char *pszTemp;
-        if (RTStrAPrintf(&pszTemp, "%s (Guest)", pszName) <= 0)
+        char *pszName;
+        if (RTStrAPrintf(&pszName, "%s (Guest)",
+                         strlen(pCfg->szName) ? pCfg->szName : "<Untitled>") <= 0)
+        {
             return VERR_NO_MEMORY;
-
-        rc = AudioMixBufInit(&pGstStrmIn->MixBuf, pszTemp, &pGstStrmIn->Props, AudioMixBufSize(&pHstStrmIn->MixBuf));
+        }
+
+        rc = AudioMixBufInit(&pGstStrmIn->MixBuf, pszName, &pGstStrmIn->Props, AudioMixBufSize(&pHstStrmIn->MixBuf));
         if (RT_SUCCESS(rc))
             rc = AudioMixBufLinkTo(&pHstStrmIn->MixBuf, &pGstStrmIn->MixBuf);
 
-        RTStrFree(pszTemp);
-
         if (RT_SUCCESS(rc))
         {
 #ifdef DEBUG
-            drvAudioStreamCfgPrint(pCfg);
+            DrvAudioStreamCfgPrint(pCfg);
 #endif
             pGstStrmIn->State.cRefs   = 1;
@@ -941 +827 @@
             pGstStrmIn->State.fEmpty  = true;
 
-            pGstStrmIn->State.pszName = RTStrDup(pszName);
-            if (!pGstStrmIn->State.pszName)
-                return VERR_NO_MEMORY;
+            RTStrPrintf(pGstStrmIn->State.szName, RT_ELEMENTS(pGstStrmIn->State.szName),
+                        "%s", pszName);
 
             pGstStrmIn->pHstStrmIn = pHstStrmIn;
         }
-    }
-
-    LogFlowFunc(("pszName=%s, rc=%Rrc\n", pszName, rc));
-    return rc;
-}
-
-static int drvAudioAllocHstIn(PDRVAUDIO pThis, const char *pszName, PPDMAUDIOSTREAMCFG pCfg,
-                              PDMAUDIORECSOURCE enmRecSource, PPDMAUDIOHSTSTRMIN *ppHstStrmIn)
+
+        RTStrFree(pszName);
+    }
+
+    LogFlowFunc(("pszName=%s, rc=%Rrc\n", pCfg->szName, rc));
+    return rc;
+}
+
+static int drvAudioAllocHstIn(PDRVAUDIO pThis, PPDMAUDIOSTREAMCFG pCfg, PPDMAUDIOHSTSTRMIN *ppHstStrmIn)
 {
     if (!pThis->cStreamsFreeIn)
@@ -979 +865 @@
 
     int rc;
-    bool fInitialized = false;
 
     do
     {
-        uint32_t cSamples;
-        rc = pThis->pHostDrvAudio->pfnInitIn(pThis->pHostDrvAudio, pHstStrmIn,
-                                             pCfg, enmRecSource, &cSamples);
+        uint32_t cSamples = 0;
+        rc = pThis->pHostDrvAudio->pfnInitIn
+           ? pThis->pHostDrvAudio->pfnInitIn(pThis->pHostDrvAudio, pHstStrmIn,
+                                             pCfg, pCfg->DestSource.Source, &cSamples) : VINF_SUCCESS;
         if (RT_FAILURE(rc))
         {
@@ -992 +878 @@
         }
 
-        fInitialized = true;
-
-        char *pszTemp;
-        if (RTStrAPrintf(&pszTemp, "%s (Host)", pszName) <= 0)
+        pHstStrmIn->fStatus |= PDMAUDIOSTRMSTS_FLAG_INITIALIZED;
+
+        char *pszName;
+        if (RTStrAPrintf(&pszName, "%s (Host)", pCfg->szName) <= 0)
         {
             rc = VERR_NO_MEMORY;
@@ -1001 +887 @@
         }
 
-        rc = AudioMixBufInit(&pHstStrmIn->MixBuf, pszTemp, &pHstStrmIn->Props, cSamples);
+        rc = AudioMixBufInit(&pHstStrmIn->MixBuf, pszName, &pHstStrmIn->Props, cSamples);
         if (RT_SUCCESS(rc))
             rc = RTCritSectInit(&pHstStrmIn->CritSect);
@@ -1011 +897 @@
         }
 
-        RTStrFree(pszTemp);
+        RTStrFree(pszName);
 
     } while (0);
@@ -1017 +903 @@
     if (RT_FAILURE(rc))
     {
-        if (fInitialized)
-        {
-            int rc2 = pThis->pHostDrvAudio->pfnFiniIn(pThis->pHostDrvAudio,
-                                                      pHstStrmIn);
-            AssertRC(rc2);
+        if (pHstStrmIn->fStatus & PDMAUDIOSTRMSTS_FLAG_INITIALIZED)
+        {
+            int rc2 = pThis->pHostDrvAudio->pfnFiniIn
+                    ? pThis->pHostDrvAudio->pfnFiniIn(pThis->pHostDrvAudio, pHstStrmIn) : VINF_SUCCESS;
+            if (RT_SUCCESS(rc2))
+                pHstStrmIn->fStatus &= ~PDMAUDIOSTRMSTS_FLAG_INITIALIZED;
         }
 
@@ -1116 +1003 @@
     }
 
-    LogFlowFunc(("%s -> %s: Written pvBuf=%p, cbBuf=%RU32, cWritten=%RU32 (%RU32 bytes), cMixed=%RU32, rc=%Rrc\n",
-                 pGstStrmOut->MixBuf.pszName, pHstStrmOut->MixBuf.pszName, pvBuf, cbBuf, cWritten,
+    LogFlowFunc(("%s -> %s: cbBuf=%RU32, cWritten=%RU32 (%RU32 bytes), cMixed=%RU32, rc=%Rrc\n",
+                 pGstStrmOut->MixBuf.pszName, pHstStrmOut->MixBuf.pszName, cbBuf, cWritten,
                  AUDIOMIXBUF_S2B(&pGstStrmOut->MixBuf, cWritten), cMixed, rc));
 
@@ -1127 +1014 @@
 }
 
-PPDMAUDIOHSTSTRMOUT drvAudioFindAnyHstOut(PDRVAUDIO pThis, PPDMAUDIOHSTSTRMOUT pHstStrmOut)
+static PPDMAUDIOHSTSTRMOUT drvAudioFindAnyHstOut(PDRVAUDIO pThis, PPDMAUDIOHSTSTRMOUT pHstStrmOut)
 {
     if (pHstStrmOut)
@@ -1140 +1027 @@
 }
 
-PPDMAUDIOHSTSTRMOUT drvAudioHstFindAnyEnabledOut(PDRVAUDIO pThis, PPDMAUDIOHSTSTRMOUT pHostStrmOut)
+static PPDMAUDIOHSTSTRMOUT drvAudioHstFindAnyEnabledOut(PDRVAUDIO pThis, PPDMAUDIOHSTSTRMOUT pHostStrmOut)
 {
     while ((pHostStrmOut = drvAudioFindAnyHstOut(pThis, pHostStrmOut)))
@@ -1151 +1038 @@
 }
 
-PPDMAUDIOHSTSTRMOUT drvAudioFindSpecificOut(PDRVAUDIO pThis, PPDMAUDIOHSTSTRMOUT pHstStrmOut,
-                                            PPDMAUDIOSTREAMCFG pCfg)
+static PPDMAUDIOHSTSTRMOUT drvAudioFindSpecificOut(PDRVAUDIO pThis, PPDMAUDIOHSTSTRMOUT pHstStrmOut,
+                                                   PPDMAUDIOSTREAMCFG pCfg)
 {
     while ((pHstStrmOut = drvAudioFindAnyHstOut(pThis, pHstStrmOut)))
     {
-        if (drvAudioPCMPropsAreEqual(&pHstStrmOut->Props, pCfg))
+        if (DrvAudioPCMPropsAreEqual(&pHstStrmOut->Props, pCfg))
             return pHstStrmOut;
     }
@@ -1165 +1052 @@
 int drvAudioDestroyHstIn(PDRVAUDIO pThis, PPDMAUDIOHSTSTRMIN pHstStrmIn)
 {
+    AssertPtrReturn(pThis,      VERR_INVALID_POINTER);
+    AssertPtrReturn(pHstStrmIn, VERR_INVALID_POINTER);
+
+    LogFlowFunc(("%s\n", pHstStrmIn->MixBuf.pszName));
+
+    int rc = VINF_SUCCESS;
+
+    if (!pHstStrmIn->pGstStrmIn)
+    {
+        drvAudioHstInFreeRes(pHstStrmIn);
+
+        if (RTCritSectIsInitialized(&pHstStrmIn->CritSect))
+        {
+            int rc2 = RTCritSectDelete(&pHstStrmIn->CritSect);
+            AssertRC(rc2);
+        }
+
+        /* Remove from driver instance list. */
+        RTListNodeRemove(&pHstStrmIn->Node);
+
+        RTMemFree(pHstStrmIn);
+        pThis->cStreamsFreeIn++;
+    }
+    else
+    {
+        rc = VERR_WRONG_ORDER;
+        LogFlowFunc(("[%s] Still is being used, skipping\n", pHstStrmIn->MixBuf.pszName));
+    }
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+static int drvAudioDestroyGstIn(PDRVAUDIO pThis, PPDMAUDIOGSTSTRMIN pGstStrmIn)
+{
     AssertPtrReturn(pThis, VERR_INVALID_POINTER);
-    AssertPtrReturn(pHstStrmIn, VERR_INVALID_POINTER);
-
-    LogFlowFunc(("%s\n", pHstStrmIn->MixBuf.pszName));
-
-    int rc;
-    if (!pHstStrmIn->pGstStrmIn) /* No parent anymore? */
-    {
-        rc = pThis->pHostDrvAudio->pfnFiniIn(pThis->pHostDrvAudio, pHstStrmIn);
-        if (RT_SUCCESS(rc))
-        {
-            drvAudioHstInFreeRes(pHstStrmIn);
-
-            if (RTCritSectIsInitialized(&pHstStrmIn->CritSect))
-            {
-                int rc2 = RTCritSectDelete(&pHstStrmIn->CritSect);
-                AssertRC(rc2);
-            }
-
-            /* Remove from driver instance list. */
-            RTListNodeRemove(&pHstStrmIn->Node);
-
-            RTMemFree(pHstStrmIn);
-            pThis->cStreamsFreeIn++;
-        }
-    }
-    else
-    {
-        rc = VERR_ACCESS_DENIED;
-        LogFlowFunc(("[%s] Still is being used, rc=%Rrc\n", pHstStrmIn->MixBuf.pszName, rc));
-    }
-
-    return rc;
-}
-
-static int drvAudioDestroyGstIn(PDRVAUDIO pThis, PPDMAUDIOGSTSTRMIN pGstStrmIn)
-{
-    AssertPtrReturn(pThis, VERR_INVALID_POINTER);
-
-    LogFlowFunc(("%s\n", pGstStrmIn->MixBuf.pszName));
 
     if (!pGstStrmIn)
         return VINF_SUCCESS;
 
+    LogFlowFunc(("%s\n", pGstStrmIn->MixBuf.pszName));
+
     if (pGstStrmIn->State.cRefs > 1) /* Do other objects still have a reference to it? Bail out. */
         return VERR_WRONG_ORDER;
 
-    drvAudioGstInFreeRes(pGstStrmIn);
-
+    AudioMixBufDestroy(&pGstStrmIn->MixBuf);
+
+    /* Is this guest stream associate to a host stream? */
     if (pGstStrmIn->pHstStrmIn)
     {
         /* Unlink child. */
         pGstStrmIn->pHstStrmIn->pGstStrmIn = NULL;
-
-        /* Try destroying the associated host input stream. This could
-         * be skipped if there are other guest input streams with this
-         * host stream. */
-        drvAudioDestroyHstIn(pThis, pGstStrmIn->pHstStrmIn);
     }
 
     RTMemFree(pGstStrmIn);
+    pGstStrmIn = NULL;
 
     return VINF_SUCCESS;
+}
+
+static DECLCALLBACK(uint32_t) drvAudioAddRefIn(PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOGSTSTRMIN pGstStrm)
+{
+   AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
+   AssertPtrReturn(pGstStrm, VERR_INVALID_POINTER);
+
+   NOREF(pInterface);
+
+   return ++pGstStrm->State.cRefs;
+}
+
+static DECLCALLBACK(uint32_t) drvAudioAddRefOut(PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOGSTSTRMOUT pGstStrm)
+{
+   AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
+   AssertPtrReturn(pGstStrm,   VERR_INVALID_POINTER);
+
+   NOREF(pInterface);
+
+   return ++pGstStrm->State.cRefs;
+}
+
+static DECLCALLBACK(uint32_t) drvAudioReleaseIn(PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOGSTSTRMIN pGstStrm)
+{
+   AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
+   AssertPtrReturn(pGstStrm,   VERR_INVALID_POINTER);
+
+   NOREF(pInterface);
+
+   Assert(pGstStrm->State.cRefs);
+   if (pGstStrm->State.cRefs)
+       pGstStrm->State.cRefs--;
+
+   return pGstStrm->State.cRefs;
+}
+
+static DECLCALLBACK(uint32_t) drvAudioReleaseOut(PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOGSTSTRMOUT pGstStrm)
+{
+   AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
+   AssertPtrReturn(pGstStrm,   VERR_INVALID_POINTER);
+
+   NOREF(pInterface);
+
+   Assert(pGstStrm->State.cRefs);
+   if (pGstStrm->State.cRefs)
+       pGstStrm->State.cRefs--;
+
+   return pGstStrm->State.cRefs;
 }
 
@@ -1309 +1239 @@
 
     PPDMAUDIOHSTSTRMIN pHstStrmIn = NULL;
-    while ((pHstStrmIn = drvAudioFindNextEnabledHstIn(pThis, pHstStrmIn)))
-    {
+    while ((pHstStrmIn = drvAudioFindAnyHstIn(pThis, pHstStrmIn)))
+    {
+        /* Disabled? Skip it! */
+        if (!(pHstStrmIn->fStatus & PDMAUDIOSTRMSTS_FLAG_ENABLED))
+            continue;
+
         /* Call the host backend to capture the audio input data. */
         uint32_t cSamplesCaptured;
@@ -1373 +1307 @@
         AssertRC(rc);
 
-        if (!pThis->BackendCfg.cMaxStreamsOut)
+        if (   !pThis->BackendCfg.cSinks
+            || !pThis->BackendCfg.cMaxStreamsOut)
         {
             int rc2 = RTCritSectLeave(&pThis->CritSect);
@@ -1422 +1357 @@
         if (RT_FAILURE(rc2))
         {
-            rc2 = pThis->pHostDrvAudio->pfnControlOut(pThis->pHostDrvAudio, pHstStrmOut, PDMAUDIOSTREAMCMD_DISABLE);
-            AssertRC(rc2);
+            int rc3 = pThis->pHostDrvAudio->pfnControlOut(pThis->pHostDrvAudio, pHstStrmOut, PDMAUDIOSTREAMCMD_DISABLE);
+            AssertRC(rc3);
         }
         else
@@ -1620 +1555 @@
     }
 
-    if (pThis->BackendCfg.cbStreamOut)
-    {
+    pThis->cStreamsFreeIn  = 0;
+    pThis->cStreamsFreeOut = 0;
+
+    if (pThis->BackendCfg.cSinks)
+    {
+        Assert(pThis->BackendCfg.cbStreamOut);
+
         pThis->cStreamsFreeOut = pThis->BackendCfg.cMaxStreamsOut;
     }
-    else
-        pThis->cStreamsFreeOut = 0;
-
-    if (pThis->BackendCfg.cbStreamIn)
-    {
-        /*
-         * Note:
-         *  - Our AC'97 emulation has two inputs, line (ac97.pi) and microphone (ac97.mc).
-         *  - Our HDA emulation currently has only line input (hda.pi).
-         */
+
+    if (pThis->BackendCfg.cSources)
+    {
+        Assert(pThis->BackendCfg.cbStreamIn);
+
         pThis->cStreamsFreeIn = pThis->BackendCfg.cMaxStreamsIn;
     }
-    else
-        pThis->cStreamsFreeIn = 0;
 
     LogFlowFunc(("cStreamsFreeIn=%RU8, cStreamsFreeOut=%RU8\n", pThis->cStreamsFreeIn, pThis->cStreamsFreeOut));
@@ -1660 +1593 @@
 
     PPDMAUDIOHSTSTRMOUT pHstStrmOut = NULL;
-    while ((pHstStrmOut = drvAudioHstFindAnyEnabledOut(pThis, pHstStrmOut)))
+    while ((pHstStrmOut = drvAudioFindAnyHstOut(pThis, pHstStrmOut)))
         drvAudioControlHstOut(pThis, pHstStrmOut, enmCmd);
 
     PPDMAUDIOHSTSTRMIN pHstStrmIn = NULL;
-    while ((pHstStrmIn = drvAudioFindNextEnabledHstIn(pThis, pHstStrmIn)))
+    while ((pHstStrmIn = drvAudioFindAnyHstIn(pThis, pHstStrmIn)))
         drvAudioControlHstIn(pThis, pHstStrmIn, enmCmd);
 }
@@ -1674 +1607 @@
 
     PDRVAUDIO pThis = PDMINS_2_DATA(pDrvIns, PDRVAUDIO);
-    LogFlowFunc(("pDrvAudio=%p, pDrvIns=%p\n", pThis, pDrvIns));
+    LogFlowFunc(("pThis=%p, pDrvIns=%p\n", pThis, pDrvIns));
 
     RTListInit(&pThis->lstHstStrmIn);
@@ -1703 +1636 @@
     AssertPtrReturn(pThis, VERR_INVALID_POINTER);
 
-    AssertPtrReturn(pGstStrmIn, VERR_INVALID_POINTER);
+    if (!pGstStrmIn)
+        return VERR_NOT_AVAILABLE;
+
     AssertPtrReturn(pvBuf,      VERR_INVALID_POINTER);
     AssertReturn(cbBuf,         VERR_INVALID_PARAMETER);
@@ -1754 +1689 @@
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
-    /* pGstStrmOut is optional. */
+
+    if (!pGstStrmOut)
+        return VERR_NOT_AVAILABLE;
 
     PDRVAUDIO pThis = PDMIAUDIOCONNECTOR_2_DRVAUDIO(pInterface);
@@ -1760 +1697 @@
     int rc = VINF_SUCCESS;
 
-    if (pGstStrmOut)
-    {
-        PPDMAUDIOHSTSTRMOUT pHstStrmOut = pGstStrmOut->pHstStrmOut;
-        AssertPtr(pHstStrmOut);
-
-        if (fEnable)
-        {
-            /* Is a pending disable outstanding? Then disable first. */
-            if (pHstStrmOut->fStatus & PDMAUDIOSTRMSTS_FLAG_PENDING_DISABLE)
+    PPDMAUDIOHSTSTRMOUT pHstStrmOut = pGstStrmOut->pHstStrmOut;
+    AssertPtr(pHstStrmOut);
+
+    if (fEnable)
+    {
+        /* Is a pending disable outstanding? Then disable first. */
+        if (pHstStrmOut->fStatus & PDMAUDIOSTRMSTS_FLAG_PENDING_DISABLE)
+        {
+            rc = drvAudioControlHstOut(pThis, pHstStrmOut, PDMAUDIOSTREAMCMD_DISABLE);
+            if (RT_SUCCESS(rc))
+                pHstStrmOut->fStatus &= ~PDMAUDIOSTRMSTS_FLAG_PENDING_DISABLE;
+        }
+
+        if (RT_SUCCESS(rc))
+            rc = drvAudioControlHstOut(pThis, pHstStrmOut, PDMAUDIOSTREAMCMD_ENABLE);
+    }
+    else /* Disable */
+    {
+        if (pHstStrmOut->fStatus & PDMAUDIOSTRMSTS_FLAG_ENABLED)
+        {
+            uint32_t cGstStrmsActive = 0;
+
+            /*
+             * Check if there are any active guest streams assigned
+             * to this host stream which still are being marked as active.
+             *
+             * In that case we have to defer closing the host stream and
+             * wait until all guest streams have been finished.
+             */
+            PPDMAUDIOGSTSTRMOUT pIter;
+            RTListForEach(&pHstStrmOut->lstGstStrmOut, pIter, PDMAUDIOGSTSTRMOUT, Node)
             {
+                if (pIter->State.fActive)
+                {
+                    cGstStrmsActive++;
+                    break; /* At least one assigned & active guest stream is enough. */
+                }
+            }
+
+            /* Do we need to defer closing the host stream? */
+            if (cGstStrmsActive >= 1)
+                pHstStrmOut->fStatus |= PDMAUDIOSTRMSTS_FLAG_PENDING_DISABLE;
+
+            /* Can we close the host stream now instead of deferring it? */
+            if (!(pHstStrmOut->fStatus & PDMAUDIOSTRMSTS_FLAG_PENDING_DISABLE))
                 rc = drvAudioControlHstOut(pThis, pHstStrmOut, PDMAUDIOSTREAMCMD_DISABLE);
-                if (RT_SUCCESS(rc))
-                    pHstStrmOut->fStatus &= ~PDMAUDIOSTRMSTS_FLAG_PENDING_DISABLE;
-            }
-
-            if (RT_SUCCESS(rc))
-                rc = drvAudioControlHstOut(pThis, pHstStrmOut, PDMAUDIOSTREAMCMD_ENABLE);
-        }
-        else /* Disable */
-        {
-            if (pHstStrmOut->fStatus & PDMAUDIOSTRMSTS_FLAG_ENABLED)
-            {
-                uint32_t cGstStrmsActive = 0;
-
-                /*
-                 * Check if there are any active guest streams assigned
-                 * to this host stream which still are being marked as active.
-                 *
-                 * In that case we have to defer closing the host stream and
-                 * wait until all guest streams have been finished.
-                 */
-                PPDMAUDIOGSTSTRMOUT pIter;
-                RTListForEach(&pHstStrmOut->lstGstStrmOut, pIter, PDMAUDIOGSTSTRMOUT, Node)
-                {
-                    if (pIter->State.fActive)
-                    {
-                        cGstStrmsActive++;
-                        break; /* At least one assigned & active guest stream is enough. */
-                    }
-                }
-
-                /* Do we need to defer closing the host stream? */
-                if (cGstStrmsActive >= 1)
-                    pHstStrmOut->fStatus |= PDMAUDIOSTRMSTS_FLAG_PENDING_DISABLE;
-
-                /* Can we close the host stream now instead of deferring it? */
-                if (!(pHstStrmOut->fStatus & PDMAUDIOSTRMSTS_FLAG_PENDING_DISABLE))
-                    rc = drvAudioControlHstOut(pThis, pHstStrmOut, PDMAUDIOSTREAMCMD_DISABLE);
-            }
-        }
-
-        if (RT_SUCCESS(rc))
-            pGstStrmOut->State.fActive = fEnable;
-
-        LogFlowFunc(("%s: fEnable=%RTbool, fStatus=0x%x, rc=%Rrc\n",
-                     pGstStrmOut->MixBuf.pszName, fEnable, pHstStrmOut->fStatus, rc));
-    }
+        }
+    }
+
+    if (RT_SUCCESS(rc))
+        pGstStrmOut->State.fActive = fEnable;
+
+    LogFlowFunc(("%s: fEnable=%RTbool, fStatus=0x%x, rc=%Rrc\n",
+                 pGstStrmOut->MixBuf.pszName, fEnable, pHstStrmOut->fStatus, rc));
 
     return rc;
@@ -1825 +1759 @@
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
-    /* pGstStrmIn is optional. */
+
+    if (!pGstStrmIn)
+        return VERR_NOT_AVAILABLE;
 
     PDRVAUDIO pThis = PDMIAUDIOCONNECTOR_2_DRVAUDIO(pInterface);
@@ -1831 +1767 @@
     int rc = VINF_SUCCESS;
 
-    if (pGstStrmIn)
-    {
-        PPDMAUDIOHSTSTRMIN pHstStrmIn = pGstStrmIn->pHstStrmIn;
-        AssertPtr(pHstStrmIn);
-
-        LogFlowFunc(("%s: fEnable=%RTbool\n", pGstStrmIn->MixBuf.pszName, fEnable));
-
-        rc = drvAudioControlHstIn(pThis, pHstStrmIn,
-                                  fEnable ? PDMAUDIOSTREAMCMD_ENABLE : PDMAUDIOSTREAMCMD_DISABLE);
-        if (RT_SUCCESS(rc))
-            pGstStrmIn->State.fActive = fEnable;
-
-        LogFlowFunc(("%s: fEnable=%RTbool, rc=%Rrc\n", pGstStrmIn->MixBuf.pszName, fEnable, rc));
-    }
+    PPDMAUDIOHSTSTRMIN pHstStrmIn = pGstStrmIn->pHstStrmIn;
+    AssertPtr(pHstStrmIn);
+
+    rc = drvAudioControlHstIn(pThis, pHstStrmIn,
+                              fEnable ? PDMAUDIOSTREAMCMD_ENABLE : PDMAUDIOSTREAMCMD_DISABLE);
+    if (RT_SUCCESS(rc))
+        pGstStrmIn->State.fActive = fEnable;
+
+    LogFlowFunc(("%s: fEnable=%RTbool, rc=%Rrc\n", pGstStrmIn->MixBuf.pszName, fEnable, rc));
 
     return rc;
@@ -1861 +1792 @@
 }
 
-static DECLCALLBACK(int) drvAudioCreateIn(PPDMIAUDIOCONNECTOR pInterface, const char *pszName,
-                                          PPDMAUDIOSTREAMCFG pCfg, PPDMAUDIOGSTSTRMIN *ppGstStrmIn)
+static DECLCALLBACK(int) drvAudioCreateIn(PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOSTREAMCFG pCfg,
+                                          PPDMAUDIOGSTSTRMIN *ppGstStrmIn)
 {
     AssertPtrReturn(pInterface,  VERR_INVALID_POINTER);
-    AssertPtrReturn(ppGstStrmIn, VERR_INVALID_POINTER);
-    AssertPtrReturn(pszName,     VERR_INVALID_POINTER);
     AssertPtrReturn(pCfg,        VERR_INVALID_POINTER);
     AssertPtrReturn(ppGstStrmIn, VERR_INVALID_POINTER);
@@ -1878 +1807 @@
         return rc;
 
-    LogFlowFunc(("pszName=%s, pCfg=%p\n", pszName, pCfg));
+    LogFlowFunc(("szName=%s\n", pCfg->szName));
 
     if (!drvAudioStreamCfgIsValid(pCfg))
@@ -1889 +1818 @@
     {
         PPDMAUDIOGSTSTRMIN pGstStrmIn;
-        rc = drvAudioCreateStreamPairIn(pThis, pszName, pCfg->DestSource.Source, pCfg, &pGstStrmIn);
+        rc = drvAudioCreateStreamPairIn(pThis, pCfg, &pGstStrmIn);
         if (RT_SUCCESS(rc))
             *ppGstStrmIn = pGstStrmIn;
@@ -1902 +1831 @@
 }
 
-static DECLCALLBACK(int) drvAudioCreateOut(PPDMIAUDIOCONNECTOR pInterface, const char *pszName,
-                                           PPDMAUDIOSTREAMCFG pCfg, PPDMAUDIOGSTSTRMOUT *ppGstStrmOut)
+static DECLCALLBACK(int) drvAudioCreateOut(PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOSTREAMCFG pCfg,
+                                           PPDMAUDIOGSTSTRMOUT *ppGstStrmOut)
 {
     AssertPtrReturn(pInterface,   VERR_INVALID_POINTER);
-    AssertPtrReturn(pszName,      VERR_INVALID_POINTER);
     AssertPtrReturn(pCfg,         VERR_INVALID_POINTER);
     AssertPtrReturn(ppGstStrmOut, VERR_INVALID_POINTER);
@@ -1918 +1846 @@
         return rc;
 
-    LogFlowFunc(("pszName=%s, pCfg=%p\n", pszName, pCfg));
+    LogFlowFunc(("pszName=%s\n", pCfg->szName));
 
     if (!drvAudioStreamCfgIsValid(pCfg))
@@ -1929 +1857 @@
     {
         PPDMAUDIOGSTSTRMOUT pGstStrmOut;
-        rc = drvAudioCreateStreamPairOut(pThis, pszName, pCfg, &pGstStrmOut);
+        rc = drvAudioCreateStreamPairOut(pThis, pCfg, &pGstStrmOut);
         if (RT_SUCCESS(rc))
             *ppGstStrmOut = pGstStrmOut;
@@ -1942 +1870 @@
 }
 
-static DECLCALLBACK(int) drvAudioGetConfiguration(PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOBACKENDCFG pCfg)
+static DECLCALLBACK(int) drvAudioGetConfig(PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOBACKENDCFG pCfg)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
@@ -2006 +1934 @@
     PDRVAUDIO pThis = PDMIAUDIOCONNECTOR_2_DRVAUDIO(pInterface);
 
+    if (!pGstStrmIn)
+        return;
+
     int rc2 = RTCritSectEnter(&pThis->CritSect);
     AssertRC(rc2);
 
-    if (pGstStrmIn)
-        drvAudioDestroyGstIn(pThis, pGstStrmIn);
+    rc2 = drvAudioDestroyGstIn(pThis, pGstStrmIn);
+    AssertRC(rc2);
 
     rc2 = RTCritSectLeave(&pThis->CritSect);
@@ -2023 +1954 @@
     PDRVAUDIO pThis = PDMIAUDIOCONNECTOR_2_DRVAUDIO(pInterface);
 
+    if (!pGstStrmOut)
+        return;
+
     int rc2 = RTCritSectEnter(&pThis->CritSect);
     AssertRC(rc2);
 
-    if (pGstStrmOut)
-        drvAudioDestroyGstOut(pThis, pGstStrmOut);
+    rc2 = drvAudioDestroyGstOut(pThis, pGstStrmOut);
+    AssertRC(rc2);
 
     rc2 = RTCritSectLeave(&pThis->CritSect);
     AssertRC(rc2);
+}
+
+void drvAudioHstOutFreeRes(PPDMAUDIOHSTSTRMOUT pHstStrmOut)
+{
+    AssertPtrReturnVoid(pHstStrmOut);
+    AudioMixBufDestroy(&pHstStrmOut->MixBuf);
 }
 
@@ -2058 +1998 @@
 static DECLCALLBACK(void) drvAudioPowerOff(PPDMDRVINS pDrvIns)
 {
+    PDRVAUDIO pThis = PDMINS_2_DATA(pDrvIns, PDRVAUDIO);
+
     LogFlowFuncEnter();
-    PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
-
-    PDRVAUDIO pThis = PDMINS_2_DATA(pDrvIns, PDRVAUDIO);
-
-    if (!pThis->pHostDrvAudio)
-        return;
-
-    /* Tear down all host output streams. */
+
+    /* First, disable all streams. */
+    drvAudioStateHandler(pDrvIns, PDMAUDIOSTREAMCMD_DISABLE);
+
+    int rc2;
+
     PPDMAUDIOHSTSTRMOUT pHstStrmOut = NULL;
     while ((pHstStrmOut = drvAudioFindAnyHstOut(pThis, pHstStrmOut)))
     {
-        drvAudioControlHstOut(pThis, pHstStrmOut, PDMAUDIOSTREAMCMD_DISABLE);
-        pThis->pHostDrvAudio->pfnFiniOut(pThis->pHostDrvAudio, pHstStrmOut);
-    }
-
-    /* Tear down all host input streams. */
+        if (pHstStrmOut->fStatus & PDMAUDIOSTRMSTS_FLAG_INITIALIZED)
+        {
+            rc2 = pThis->pHostDrvAudio->pfnFiniOut
+                ? pThis->pHostDrvAudio->pfnFiniOut(pThis->pHostDrvAudio, pHstStrmOut) : VINF_SUCCESS;
+            if (RT_SUCCESS(rc2))
+                pHstStrmOut->fStatus &= ~PDMAUDIOSTRMSTS_FLAG_INITIALIZED;
+        }
+        else
+            rc2 = VINF_SUCCESS;
+
+        AssertMsgRC(rc2, ("Host output stream %p failed to uninit: %Rrc\n",  pHstStrmOut, rc2));
+    }
+
     PPDMAUDIOHSTSTRMIN pHstStrmIn = NULL;
-    while ((pHstStrmIn = drvAudioFindNextHstIn(pThis, pHstStrmIn)))
-    {
-        drvAudioControlHstIn(pThis, pHstStrmIn, PDMAUDIOSTREAMCMD_DISABLE);
-        pThis->pHostDrvAudio->pfnFiniIn(pThis->pHostDrvAudio, pHstStrmIn);
-    }
-
+    while ((pHstStrmIn = drvAudioFindAnyHstIn(pThis, pHstStrmIn)))
+    {
+        if (pHstStrmIn->fStatus & PDMAUDIOSTRMSTS_FLAG_INITIALIZED)
+        {
+            rc2 = pThis->pHostDrvAudio->pfnFiniIn
+                ? pThis->pHostDrvAudio->pfnFiniIn(pThis->pHostDrvAudio, pHstStrmIn) : VINF_SUCCESS;
+            if (RT_SUCCESS(rc2))
+                pHstStrmIn->fStatus &= ~PDMAUDIOSTRMSTS_FLAG_INITIALIZED;
+        }
+        else
+            rc2 = VINF_SUCCESS;
+
+        AssertMsgRC(rc2, ("Host input stream %p failed to uninit: %Rrc\n",  pHstStrmIn, rc2));
+    }
+
+    /*
+     * Last call for the driver below us.
+     * Let it know that we reached end of life.
+     */
     if (pThis->pHostDrvAudio->pfnShutdown)
         pThis->pHostDrvAudio->pfnShutdown(pThis->pHostDrvAudio);
 
-#ifdef VBOX_WITH_AUDIO_CALLBACKS
-    PPDMAUDIOCALLBACK pCB, pCBNext;
-    RTListForEachSafe(&pThis->lstCBIn, pCB, pCBNext, PDMAUDIOCALLBACK, Node)
-        drvAudioCallbackDestroy(pCB);
-
-    RTListForEachSafe(&pThis->lstCBOut, pCB, pCBNext, PDMAUDIOCALLBACK, Node)
-        drvAudioCallbackDestroy(pCB);
-#endif
+    pThis->pHostDrvAudio = NULL;
 
     LogFlowFuncLeave();
@@ -2117 +2071 @@
     /* IAudioConnector. */
     pThis->IAudioConnector.pfnQueryStatus            = drvAudioQueryStatus;
+    pThis->IAudioConnector.pfnAddRefIn               = drvAudioAddRefIn;
+    pThis->IAudioConnector.pfnAddRefOut              = drvAudioAddRefOut;
+    pThis->IAudioConnector.pfnReleaseIn              = drvAudioReleaseIn;
+    pThis->IAudioConnector.pfnReleaseOut             = drvAudioReleaseOut;
     pThis->IAudioConnector.pfnRead                   = drvAudioRead;
     pThis->IAudioConnector.pfnWrite                  = drvAudioWrite;
-    pThis->IAudioConnector.pfnGetConfiguration       = drvAudioGetConfiguration;
+    pThis->IAudioConnector.pfnGetConfig              = drvAudioGetConfig;
     pThis->IAudioConnector.pfnIsActiveIn             = drvAudioIsActiveIn;
     pThis->IAudioConnector.pfnIsActiveOut            = drvAudioIsActiveOut;
@@ -2179 +2137 @@
     PDRVAUDIO pThis = PDMINS_2_DATA(pDrvIns, PDRVAUDIO);
 
-    if (RTCritSectIsInitialized(&pThis->CritSect))
-    {
-        int rc2 = RTCritSectDelete(&pThis->CritSect);
+    int rc2 = RTCritSectEnter(&pThis->CritSect);
+    AssertRC(rc2);
+
+    /*
+     * Note: No calls here to the driver below us anymore,
+     *       as PDM already has destroyed it.
+     *       If you need to call something from the host driver,
+     *       do this in drvAudioPowerOff() instead.
+     */
+
+    /*
+     * Destroy all host input streams.
+     */
+    PPDMAUDIOHSTSTRMOUT pHstStrmOut = NULL;
+    while ((pHstStrmOut = drvAudioFindAnyHstOut(pThis, pHstStrmOut)))
+    {
+        rc2 = drvAudioDestroyHstOut(pThis, pHstStrmOut);
         AssertRC(rc2);
-    }
+
+        /* Sanity. */
+        Assert(RTListIsEmpty(&pHstStrmOut->lstGstStrmOut));
+
+        pHstStrmOut = NULL;
+    }
+
+    /*
+     * Destroy all host input streams.
+     */
+    PPDMAUDIOHSTSTRMIN pHstStrmIn = NULL;
+    while ((pHstStrmIn = drvAudioFindAnyHstIn(pThis, pHstStrmIn)))
+    {
+        rc2 = drvAudioDestroyHstIn(pThis, pHstStrmIn);
+        AssertRC(rc2);
+
+        /* Sanity. */
+        Assert(pHstStrmIn->pGstStrmIn == NULL);
+
+        pHstStrmIn = NULL;
+    }
+
+    /* Sanity. */
+    Assert(RTListIsEmpty(&pThis->lstHstStrmIn));
+    Assert(RTListIsEmpty(&pThis->lstHstStrmOut));
+
+#ifdef VBOX_WITH_AUDIO_CALLBACKS
+    /*
+     * Destroy callbacks, if any.
+     */
+    PPDMAUDIOCALLBACK pCB, pCBNext;
+    RTListForEachSafe(&pThis->lstCBIn, pCB, pCBNext, PDMAUDIOCALLBACK, Node)
+        drvAudioCallbackDestroy(pCB);
+
+    RTListForEachSafe(&pThis->lstCBOut, pCB, pCBNext, PDMAUDIOCALLBACK, Node)
+        drvAudioCallbackDestroy(pCB);
+#endif
+
+    rc2 = RTCritSectLeave(&pThis->CritSect);
+    AssertRC(rc2);
+
+    rc2 = RTCritSectDelete(&pThis->CritSect);
+    AssertRC(rc2);
+
+    LogFlowFuncLeave();
 }
 
@@ -2256 +2272 @@
     PDM_DRVREG_VERSION
 };
+

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

@@ -113 +113 @@
     ( (PDRVAUDIO)((uintptr_t)pInterface - RT_OFFSETOF(DRVAUDIO, IAudioConnector)) )
 
-//const char *drvAudioHlpFormatToString(PDMAUDIOFMT fmt);
-const char *drvAudioRecSourceToString(PDMAUDIORECSOURCE enmRecSource);
-PDMAUDIOFMT drvAudioHlpStringToFormat(const char *pszFormat);
-
-bool drvAudioPCMPropsAreEqual(PPDMPCMPROPS info, PPDMAUDIOSTREAMCFG pCfg);
-void drvAudioStreamCfgPrint(PPDMAUDIOSTREAMCFG pCfg);
-
-/* AUDIO IN function declarations. */
-void drvAudioHlpPcmSwFreeResourcesIn(PPDMAUDIOGSTSTRMIN pGstStrmIn);
-void drvAudioGstInFreeRes(PPDMAUDIOGSTSTRMIN pGstStrmIn);
-void drvAudioGstInRemove(PPDMAUDIOGSTSTRMIN pGstStrmIn);
-uint32_t drvAudioHstInFindMinCaptured(PPDMAUDIOHSTSTRMIN pHstStrmIn);
-void drvAudioHstInFreeRes(PPDMAUDIOHSTSTRMIN pHstStrmIn);
-uint32_t drvAudioHstInGetFree(PPDMAUDIOHSTSTRMIN pHstStrmIn);
-uint32_t drvAudioHstInGetLive(PPDMAUDIOHSTSTRMIN pHstStrmIn);
-void drvAudioGstInRemove(PPDMAUDIOGSTSTRMIN pGstStrmIn);
-int  drvAudioGstInInit(PPDMAUDIOGSTSTRMIN pGstStrmIn, PPDMAUDIOHSTSTRMIN pHstStrmIn, const char *pszName, PPDMAUDIOSTREAMCFG pCfg);
-
-PPDMAUDIOHSTSTRMIN drvAudioFindNextHstIn(PDRVAUDIO pDrvAudio, PPDMAUDIOHSTSTRMIN pHstStrmIn);
-PPDMAUDIOHSTSTRMIN drvAudioFindNextEnabledHstIn(PDRVAUDIO pDrvAudio, PPDMAUDIOHSTSTRMIN pHstStrmIn);
-PPDMAUDIOHSTSTRMIN drvAudioFindNextEqHstIn(PDRVAUDIO pDrvAudio, PPDMAUDIOHSTSTRMIN pHstStrmIn, PPDMAUDIOSTREAMCFG pCfg);
-
-/* AUDIO OUT function declarations. */
-int  drvAudioGstOutAlloc(PPDMAUDIOGSTSTRMOUT pGstStrmOut);
-void drvAudioGstOutFreeRes(PPDMAUDIOGSTSTRMOUT pGstStrmOut);
-void drvAudioHstOutFreeRes(PPDMAUDIOHSTSTRMOUT pHstStrmOut);
-int  drvAudioDestroyGstOut(PDRVAUDIO pDrvAudio, PPDMAUDIOGSTSTRMOUT pGstStrmOut);
-void drvAudioDestroyHstOut(PDRVAUDIO pDrvAudio, PDMAUDIOHSTSTRMOUT pHstStrmOut);
-int  drvAudioGstOutInit(PPDMAUDIOGSTSTRMOUT pGstStrmOut, PPDMAUDIOHSTSTRMOUT pHstStrmOut, const char *pszName, PPDMAUDIOSTREAMCFG pCfg);
-
-PPDMAUDIOHSTSTRMOUT drvAudioFindAnyHstOut(PDRVAUDIO pDrvAudio, PPDMAUDIOHSTSTRMOUT pHstStrmOut);
-PPDMAUDIOHSTSTRMOUT drvAudioHstFindAnyEnabledOut(PDRVAUDIO pDrvAudio, PPDMAUDIOHSTSTRMOUT pHstStrmOut);
-PPDMAUDIOHSTSTRMOUT drvAudioFindSpecificOut(PDRVAUDIO pDrvAudio, PPDMAUDIOHSTSTRMOUT pHstStrmOut, PPDMAUDIOSTREAMCFG pCfg);
-int drvAudioAllocHstOut(PDRVAUDIO pDrvAudio, const char *pszName, PPDMAUDIOSTREAMCFG pCfg, PPDMAUDIOHSTSTRMOUT *ppHstStrmOut);
-int drvAudioHlpPcmHwAddOut(PDRVAUDIO pDrvAudio, PPDMAUDIOSTREAMCFG pCfg, PPDMAUDIOHSTSTRMOUT *ppHstStrmOut);
-int drvAudioHlpPcmCreateVoicePairOut(PDRVAUDIO pDrvAudio, const char *pszName, PPDMAUDIOSTREAMCFG pCfg, PPDMAUDIOGSTSTRMOUT *ppGstStrmOut);
-
-/* Common functions between DrvAudio and backends (host audio drivers). */
+const char *DrvAudioAudFmtToStr(PDMAUDIOFMT enmFmt);
 void DrvAudioClearBuf(PPDMPCMPROPS pPCMInfo, void *pvBuf, size_t cbBuf, uint32_t cSamples);
+bool DrvAudioPCMPropsAreEqual(PPDMPCMPROPS pPCMInfo, PPDMAUDIOSTREAMCFG pCfg);
+const char *DrvAudRecSrcToStr(PDMAUDIORECSOURCE enmRecSource);
+void DrvAudioStreamCfgPrint(PPDMAUDIOSTREAMCFG pCfg);
 int DrvAudioStreamCfgToProps(PPDMAUDIOSTREAMCFG pCfg, PPDMPCMPROPS pProps);
+PDMAUDIOFMT DrvAudioStrToAudFmt(const char *pszFmt);
 
 #endif /* DRV_AUDIO_H */

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

@@ -7 +7 @@
 
 /*
- * Copyright (C) 2006-2015 Oracle Corporation
+ * Copyright (C) 2006-2016 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -61 +61 @@
 #include "AudioMixBuffer.h"
 
-bool drvAudioPCMPropsAreEqual(PPDMPCMPROPS pProps, PPDMAUDIOSTREAMCFG pCfg);
-
-const char *drvAudioRecSourceToString(PDMAUDIORECSOURCE enmRecSource)
-{
-    switch (enmRecSource)
-    {
-        case PDMAUDIORECSOURCE_MIC:     return "Microphone In";
-        case PDMAUDIORECSOURCE_CD:      return "CD";
-        case PDMAUDIORECSOURCE_VIDEO:   return "Video";
-        case PDMAUDIORECSOURCE_AUX:     return "AUX";
-        case PDMAUDIORECSOURCE_LINE: return "Line In";
-        case PDMAUDIORECSOURCE_PHONE:   return "Phone";
-        default:
-            break;
-    }
-
-    AssertMsgFailed(("Bogus recording source %ld\n", enmRecSource));
+/**
+ * Clears a sample buffer by the given amount of audio samples.
+ *
+ * @return  IPRT status code.
+ * @param   pPCMProps               PCM properties to use for the buffer to clear.
+ * @param   pvBuf                   Buffer to clear.
+ * @param   cbBuf                   Size (in bytes) of the buffer.
+ * @param   cSamples                Number of audio samples to clear in the buffer.
+ */
+void DrvAudioClearBuf(PPDMPCMPROPS pPCMProps, void *pvBuf, size_t cbBuf, uint32_t cSamples)
+{
+    AssertPtrReturnVoid(pPCMProps);
+    AssertPtrReturnVoid(pvBuf);
+
+    if (!cbBuf || !cSamples)
+        return;
+
+    Log2Func(("pPCMInfo=%p, pvBuf=%p, cSamples=%RU32, fSigned=%RTbool, cBits=%RU8, cShift=%RU8\n",
+              pPCMProps, pvBuf, cSamples, pPCMProps->fSigned, pPCMProps->cBits, pPCMProps->cShift));
+
+    if (pPCMProps->fSigned)
+    {
+        memset(pvBuf, 0, cSamples << pPCMProps->cShift);
+    }
+    else
+    {
+        switch (pPCMProps->cBits)
+        {
+            case 8:
+            {
+                memset(pvBuf, 0x80, cSamples << pPCMProps->cShift);
+                break;
+            }
+
+            case 16:
+            {
+                uint16_t *p = (uint16_t *)pvBuf;
+                int shift = pPCMProps->cChannels - 1;
+                short s = INT16_MAX;
+
+                if (pPCMProps->fSwapEndian)
+                    s = RT_BSWAP_U16(s);
+
+                for (unsigned i = 0; i < cSamples << shift; i++)
+                    p[i] = s;
+
+                break;
+            }
+
+            case 32:
+            {
+                uint32_t *p = (uint32_t *)pvBuf;
+                int shift = pPCMProps->cChannels - 1;
+                int32_t s = INT32_MAX;
+
+                if (pPCMProps->fSwapEndian)
+                    s = RT_BSWAP_U32(s);
+
+                for (unsigned i = 0; i < cSamples << shift; i++)
+                    p[i] = s;
+
+                break;
+            }
+
+            default:
+            {
+                AssertMsgFailed(("Invalid bits: %RU8\n", pPCMProps->cBits));
+                break;
+            }
+        }
+    }
+}
+
+const char *DrvAudRecSrcToStr(PDMAUDIORECSOURCE enmRecSrc)
+{
+    switch (enmRecSrc)
+    {
+        case PDMAUDIORECSOURCE_MIC:   return "Microphone In";
+        case PDMAUDIORECSOURCE_CD:    return "CD";
+        case PDMAUDIORECSOURCE_VIDEO: return "Video";
+        case PDMAUDIORECSOURCE_AUX:   return "AUX";
+        case PDMAUDIORECSOURCE_LINE:  return "Line In";
+        case PDMAUDIORECSOURCE_PHONE: return "Phone";
+        default:
+            break;
+    }
+
+    AssertMsgFailed(("Invalid recording source %ld\n", enmRecSrc));
     return "Unknown";
 }
 
-const char *drvAudioHlpFormatToString(PDMAUDIOFMT enmFormat)
-{
-    switch (enmFormat)
-    {
-        case AUD_FMT_U8:
+const char *DrvAudioAudFmtToStr(PDMAUDIOFMT enmFmt)
+{
+    switch (enmFmt)
+    {
+        case PDMAUDIOFMT_U8:
             return "U8";
 
-        case AUD_FMT_U16:
+        case PDMAUDIOFMT_U16:
             return "U16";
 
-        case AUD_FMT_U32:
+        case PDMAUDIOFMT_U32:
             return "U32";
 
-        case AUD_FMT_S8:
+        case PDMAUDIOFMT_S8:
             return "S8";
 
-        case AUD_FMT_S16:
+        case PDMAUDIOFMT_S16:
             return "S16";
 
-        case AUD_FMT_S32:
+        case PDMAUDIOFMT_S32:
             return "S32";
 
@@ -107 +178 @@
     }
 
-    AssertMsgFailed(("Bogus audio format %ld\n", enmFormat));
+    AssertMsgFailed(("Bogus audio format %ld\n", enmFmt));
     return "Invalid";
 }
 
-PDMAUDIOFMT drvAudioHlpStringToFormat(const char *pszFormat)
-{
-    if (!RTStrICmp(pszFormat, "u8"))
-        return AUD_FMT_U8;
-    else if (!RTStrICmp(pszFormat, "u16"))
-        return AUD_FMT_U16;
-    else if (!RTStrICmp(pszFormat, "u32"))
-        return AUD_FMT_U32;
-    else if (!RTStrICmp(pszFormat, "s8"))
-        return AUD_FMT_S8;
-    else if (!RTStrICmp(pszFormat, "s16"))
-        return AUD_FMT_S16;
-    else if (!RTStrICmp(pszFormat, "s32"))
-        return AUD_FMT_S32;
-
-    AssertMsgFailed(("Bogus audio format \"%s\"\n", pszFormat));
-    return AUD_FMT_INVALID;
-}
-
-/*********************************** In Stream Functions **********************************************/
-
-void drvAudioGstInFreeRes(PPDMAUDIOGSTSTRMIN pGstStrmIn)
-{
-    AssertPtrReturnVoid(pGstStrmIn);
-
-    if (pGstStrmIn->State.pszName)
-    {
-        RTStrFree(pGstStrmIn->State.pszName);
-        pGstStrmIn->State.pszName = NULL;
-    }
-
-    AudioMixBufDestroy(&pGstStrmIn->MixBuf);
-}
-
-void drvAudioHstInFreeRes(PPDMAUDIOHSTSTRMIN pHstStrmIn)
-{
-    AssertPtrReturnVoid(pHstStrmIn);
-    AudioMixBufDestroy(&pHstStrmIn->MixBuf);
-}
-
-void drvAudioGstOutFreeRes(PPDMAUDIOGSTSTRMOUT pGstStrmOut)
-{
-    if (!pGstStrmOut)
-        return;
-
-    if (pGstStrmOut->State.pszName)
-    {
-        RTStrFree(pGstStrmOut->State.pszName);
-        pGstStrmOut->State.pszName = NULL;
-    }
-
-    AudioMixBufDestroy(&pGstStrmOut->MixBuf);
-}
-
-#if 0
-
-/**
- * Finds the minimum number of not yet captured samples of all
- * attached guest input streams for a certain host input stream.
- *
- * @return  uint32_t            Minimum number of not yet captured samples.
- *                              UINT32_MAX if none found.
- * @param   pHstStrmIn          Host input stream to check for.
- */
-inline uint32_t drvAudioHstInFindMinCaptured(PPDMAUDIOHSTSTRMIN pHstStrmIn)
-{
-    AssertPtrReturn(pHstStrmIn, 0);
-    uint32_t cMinSamples = UINT32_MAX;
-
-    PPDMAUDIOGSTSTRMIN pGstStrmIn;
-    RTListForEach(&pHstStrmIn->lstGstStrmIn, pGstStrmIn, PDMAUDIOGSTSTRMIN, Node)
-    {
-        if (pGstStrmIn->State.fActive)
-            cMinSamples = RT_MIN(cMinSamples, audioMixBufMixed(&pGstStrmIn->MixBuf));
-    }
-
-#ifdef DEBUG_andy
-    LogFlowFunc(("cMinSamples=%RU32\n", cMinSamples));
-#endif
-    return cMinSamples;
-}
-
-uint32_t drvAudioHstInGetFree(PPDMAUDIOHSTSTRMIN pHstStrmIn)
-{
-    AssertPtrReturn(pHstStrmIn, 0);
-
-    return audioMixBufSize(&pHstStrmIn->MixBuf) - drvAudioHstInGetLive(pHstStrmIn);
-}
-
-uint32_t drvAudioHstInGetLive(PPDMAUDIOHSTSTRMIN pHstStrmIn)
-{
-    AssertPtrReturn(pHstStrmIn, 0);
-
-    uint32_t cMinSamplesCaptured = drvAudioHstInFindMinCaptured(pHstStrmIn);
-    uint32_t cSamplesCaptured = audioMixBufMixed(&pHstStrmIn->MixBuf);
-
-    Assert(cSamplesCaptured >= cMinSamplesCaptured);
-    uint32_t cSamplesLive = cSamplesCaptured - cMinSamplesCaptured;
-    Assert(cSamplesLive <= audioMixBufSize(&pHstStrmIn->MixBuf));
-
-#ifdef DEBUG_andy
-    LogFlowFunc(("cSamplesLive=%RU32\n", cSamplesLive));
-#endif
-    return cSamplesLive;
-}
-#endif
-
-void drvAudioHstOutFreeRes(PPDMAUDIOHSTSTRMOUT pHstStrmOut)
-{
-    AssertPtrReturnVoid(pHstStrmOut);
-    AudioMixBufDestroy(&pHstStrmOut->MixBuf);
-}
-
-#if 0
-/**
- * Returns the number of live sample data (in bytes) of a certain
- * guest input stream.
- *
- * @return  uint32_t            Live sample data (in bytes), 0 if none.
- * @param   pGstStrmIn          Guest input stream to check for.
- */
-uint32_t drvAudioGstInGetLiveBytes(PPDMAUDIOGSTSTRMIN pGstStrmIn)
-{
-    AssertPtrReturn(pGstStrmIn, 0);
-    AssertPtrReturn(pGstStrmIn->pHstStrmIn, 0);
-
-    Assert(pGstStrmIn->pHstStrmIn->cTotalSamplesCaptured >= pGstStrmIn->cTotalHostSamplesRead);
-    uint32_t cSamplesLive = pGstStrmIn->pHstStrmIn->cTotalSamplesCaptured - pGstStrmIn->cTotalHostSamplesRead;
-    if (!cSamplesLive)
-        return 0;
-    Assert(cSamplesLive <= pGstStrmIn->pHstStrmIn->cSamples);
-
-    /** @todo Document / refactor this! */
-    return (((int64_t) cSamplesLive << 32) / pGstStrmIn->State.uFreqRatio) << pGstStrmIn->Props.cShift;
-}
-
-
-/**
- * Returns the total number of unused sample data (in bytes) of a certain
- * guest output stream.
- *
- * @return  uint32_t            Number of unused sample data (in bytes), 0 if all used up.
- * @param   pGstStrmOut         Guest output stream to check for.
- */
-uint32_t drvAudioGstOutGetFreeBytes(PPDMAUDIOGSTSTRMOUT pGstStrmOut)
-{
-    AssertPtrReturn(pGstStrmOut, 0);
-
-    Assert(pGstStrmOut->cTotalSamplesWritten <= pGstStrmOut->pHstStrmOut->cSamples);
-    uint32_t cSamplesFree =   pGstStrmOut->pHstStrmOut->cSamples
-                            - pGstStrmOut->cTotalSamplesWritten;
-    if (!cSamplesFree)
-        return 0;
-
-    /** @todo Document / refactor this! */
-    return (((int64_t) cSamplesFree << 32) / pGstStrmOut->State.uFreqRatio) << pGstStrmOut->Props.cShift;
-}
-#endif
-
-bool drvAudioPCMPropsAreEqual(PPDMPCMPROPS pProps, PPDMAUDIOSTREAMCFG pCfg)
+PDMAUDIOFMT DrvAudioStrToAudFmt(const char *pszFmt)
+{
+    AssertPtrReturn(pszFmt, PDMAUDIOFMT_INVALID);
+
+    if (!RTStrICmp(pszFmt, "u8"))
+        return PDMAUDIOFMT_U8;
+    else if (!RTStrICmp(pszFmt, "u16"))
+        return PDMAUDIOFMT_U16;
+    else if (!RTStrICmp(pszFmt, "u32"))
+        return PDMAUDIOFMT_U32;
+    else if (!RTStrICmp(pszFmt, "s8"))
+        return PDMAUDIOFMT_S8;
+    else if (!RTStrICmp(pszFmt, "s16"))
+        return PDMAUDIOFMT_S16;
+    else if (!RTStrICmp(pszFmt, "s32"))
+        return PDMAUDIOFMT_S32;
+
+    AssertMsgFailed(("Invalid audio format \"%s\"\n", pszFmt));
+    return PDMAUDIOFMT_INVALID;
+}
+
+bool DrvAudioPCMPropsAreEqual(PPDMPCMPROPS pProps, PPDMAUDIOSTREAMCFG pCfg)
 {
     int cBits = 8;
@@ -277 +210 @@
     switch (pCfg->enmFormat)
     {
-        case AUD_FMT_S8:
-            fSigned = true;
-        case AUD_FMT_U8:
-            break;
-
-        case AUD_FMT_S16:
-            fSigned = true;
-        case AUD_FMT_U16:
+        case PDMAUDIOFMT_S8:
+            fSigned = true;
+        case PDMAUDIOFMT_U8:
+            break;
+
+        case PDMAUDIOFMT_S16:
+            fSigned = true;
+        case PDMAUDIOFMT_U16:
             cBits = 16;
             break;
 
-        case AUD_FMT_S32:
-            fSigned = true;
-        case AUD_FMT_U32:
+        case PDMAUDIOFMT_S32:
+            fSigned = true;
+        case PDMAUDIOFMT_U32:
             cBits = 32;
             break;
@@ -304 +237 @@
                   && pProps->cBits       == cBits
                   && pProps->fSwapEndian == !(pCfg->enmEndianness == PDMAUDIOHOSTENDIANNESS);
-
-    LogFlowFunc(("fEqual=%RTbool\n", fEqual));
     return fEqual;
 }
@@ -328 +259 @@
     switch (pCfg->enmFormat)
     {
-        case AUD_FMT_S8:
-            fSigned = true;
-        case AUD_FMT_U8:
-            break;
-
-        case AUD_FMT_S16:
-            fSigned = true;
-        case AUD_FMT_U16:
+        case PDMAUDIOFMT_S8:
+            fSigned = true;
+        case PDMAUDIOFMT_U8:
+            break;
+
+        case PDMAUDIOFMT_S16:
+            fSigned = true;
+        case PDMAUDIOFMT_U16:
             cBits = 16;
             cShift = 1;
             break;
 
-        case AUD_FMT_S32:
-            fSigned = true;
-        case AUD_FMT_U32:
+        case PDMAUDIOFMT_S32:
+            fSigned = true;
+        case PDMAUDIOFMT_U32:
             cBits = 32;
             cShift = 2;
@@ -368 +299 @@
 }
 
-void drvAudioStreamCfgPrint(PPDMAUDIOSTREAMCFG pCfg)
-{
-    LogFlowFunc(("uHz=%RU32, cChannels=%RU8, enmFormat=",
-                 pCfg->uHz, pCfg->cChannels));
+void DrvAudioStreamCfgPrint(PPDMAUDIOSTREAMCFG pCfg)
+{
+    AssertPtrReturnVoid(pCfg);
+
+    LogFlowFunc(("uHz=%RU32, cChannels=%RU8, enmFormat=", pCfg->uHz, pCfg->cChannels));
 
     switch (pCfg->enmFormat)
     {
-        case AUD_FMT_S8:
+        case PDMAUDIOFMT_S8:
             LogFlow(("S8"));
             break;
-        case AUD_FMT_U8:
+        case PDMAUDIOFMT_U8:
             LogFlow(("U8"));
             break;
-        case AUD_FMT_S16:
+        case PDMAUDIOFMT_S16:
             LogFlow(("S16"));
             break;
-        case AUD_FMT_U16:
+        case PDMAUDIOFMT_U16:
             LogFlow(("U16"));
             break;
-        case AUD_FMT_S32:
+        case PDMAUDIOFMT_S32:
             LogFlow(("S32"));
             break;
-        case AUD_FMT_U32:
+        case PDMAUDIOFMT_U32:
             LogFlow(("U32"));
             break;
@@ -412 +344 @@
     }
 }
+

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

@@ -181 +181 @@
     switch (fmt)
     {
-        case AUD_FMT_S8:
+        case PDMAUDIOFMT_S8:
             return SND_PCM_FORMAT_S8;
 
-        case AUD_FMT_U8:
+        case PDMAUDIOFMT_U8:
             return SND_PCM_FORMAT_U8;
 
-        case AUD_FMT_S16:
+        case PDMAUDIOFMT_S16:
             return SND_PCM_FORMAT_S16_LE;
 
-        case AUD_FMT_U16:
+        case PDMAUDIOFMT_U16:
             return SND_PCM_FORMAT_U16_LE;
 
-        case AUD_FMT_S32:
+        case PDMAUDIOFMT_S32:
             return SND_PCM_FORMAT_S32_LE;
 
-        case AUD_FMT_U32:
+        case PDMAUDIOFMT_U32:
             return SND_PCM_FORMAT_U32_LE;
 
@@ -216 +216 @@
     {
         case SND_PCM_FORMAT_S8:
-            *pFmt = AUD_FMT_S8;
+            *pFmt = PDMAUDIOFMT_S8;
             if (pEndianness)
                 *pEndianness = PDMAUDIOENDIANNESS_LITTLE;
@@ -222 +222 @@
 
         case SND_PCM_FORMAT_U8:
-            *pFmt = AUD_FMT_U8;
+            *pFmt = PDMAUDIOFMT_U8;
             if (pEndianness)
                 *pEndianness = PDMAUDIOENDIANNESS_LITTLE;
@@ -228 +228 @@
 
         case SND_PCM_FORMAT_S16_LE:
-            *pFmt = AUD_FMT_S16;
+            *pFmt = PDMAUDIOFMT_S16;
             if (pEndianness)
                 *pEndianness = PDMAUDIOENDIANNESS_LITTLE;
@@ -234 +234 @@
 
         case SND_PCM_FORMAT_U16_LE:
-            *pFmt = AUD_FMT_U16;
+            *pFmt = PDMAUDIOFMT_U16;
             if (pEndianness)
                 *pEndianness = PDMAUDIOENDIANNESS_LITTLE;
@@ -240 +240 @@
 
         case SND_PCM_FORMAT_S16_BE:
-            *pFmt = AUD_FMT_S16;
+            *pFmt = PDMAUDIOFMT_S16;
             if (pEndianness)
                 *pEndianness = PDMAUDIOENDIANNESS_BIG;
@@ -246 +246 @@
 
         case SND_PCM_FORMAT_U16_BE:
-            *pFmt = AUD_FMT_U16;
+            *pFmt = PDMAUDIOFMT_U16;
             if (pEndianness)
                 *pEndianness = PDMAUDIOENDIANNESS_BIG;
@@ -252 +252 @@
 
         case SND_PCM_FORMAT_S32_LE:
-            *pFmt = AUD_FMT_S32;
+            *pFmt = PDMAUDIOFMT_S32;
             if (pEndianness)
                 *pEndianness = PDMAUDIOENDIANNESS_LITTLE;
@@ -258 +258 @@
 
         case SND_PCM_FORMAT_U32_LE:
-            *pFmt = AUD_FMT_U32;
+            *pFmt = PDMAUDIOFMT_U32;
             if (pEndianness)
                 *pEndianness = PDMAUDIOENDIANNESS_LITTLE;
@@ -264 +264 @@
 
         case SND_PCM_FORMAT_S32_BE:
-            *pFmt = AUD_FMT_S32;
+            *pFmt = PDMAUDIOFMT_S32;
             if (pEndianness)
                 *pEndianness = PDMAUDIOENDIANNESS_BIG;
@@ -270 +270 @@
 
         case SND_PCM_FORMAT_U32_BE:
-            *pFmt = AUD_FMT_U32;
+            *pFmt = PDMAUDIOFMT_U32;
             if (pEndianness)
                 *pEndianness = PDMAUDIOENDIANNESS_BIG;
@@ -1109 +1109 @@
 
         ALSAAUDIOSTREAMCFG obt;
-        rc = alsaStreamOpen(false /* false */, &req, &obt, &phPCM);
+        rc = alsaStreamOpen(false /* fIn */, &req, &obt, &phPCM);
         if (RT_FAILURE(rc))
             break;
@@ -1365 +1365 @@
         LogRel2(("ALSA: Error enumerating PCM devices: %Rrc (%d)\n", RTErrConvertFromErrno(err), err));
 
-    /* ALSA only allows one input and one output used at a time for
-     * the selected device(s). */
-    pCfg->cMaxStreamsIn   = 1;
-    pCfg->cMaxStreamsOut  = 1;
+    /* ALSA allows exactly one input and one output used at a time for the selected device(s). */
+    pCfg->cMaxStreamsIn  = 1;
+    pCfg->cMaxStreamsOut = 1;
 
     return VINF_SUCCESS;

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

@@ -221 +221 @@
     switch (pCfg->enmFormat)
     {
-        case AUD_FMT_S8:
-        case AUD_FMT_U8:
+        case PDMAUDIOFMT_S8:
+        case PDMAUDIOFMT_U8:
             pFmt->wBitsPerSample = 8;
             break;
 
-        case AUD_FMT_S16:
-        case AUD_FMT_U16:
+        case PDMAUDIOFMT_S16:
+        case PDMAUDIOFMT_U16:
             pFmt->wBitsPerSample = 16;
             pFmt->nAvgBytesPerSec <<= 1;
@@ -233 +233 @@
             break;
 
-        case AUD_FMT_S32:
-        case AUD_FMT_U32:
+        case PDMAUDIOFMT_S32:
+        case PDMAUDIOFMT_U32:
             pFmt->wBitsPerSample = 32;
             pFmt->nAvgBytesPerSec <<= 2;
@@ -916 +916 @@
         {
             DSLOG(("DSound: Guest \"%s\" is using host \"%s\"\n",
-                   drvAudioRecSourceToString(pDSoundStrmIn->enmRecSource), pDev->pszName));
+                   DrvAudRecSrcToStr(pDSoundStrmIn->enmRecSource), pDev->pszName));
 
             pGUID = &pDev->Guid;
@@ -925 +925 @@
     /* This always has to be in the release log. */
     LogRel(("DSound: Guest \"%s\" is using host device with GUID: %s\n",
-            drvAudioRecSourceToString(pDSoundStrmIn->enmRecSource), pszGUID? pszGUID: "{?}"));
+            DrvAudRecSrcToStr(pDSoundStrmIn->enmRecSource), pszGUID? pszGUID: "{?}"));
     RTStrFree(pszGUID);
 

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

@@ -104 +104 @@
     NOREF(pInterface);
 
+    LogFlowFuncLeaveRC(VINF_SUCCESS);
     return VINF_SUCCESS;
 }
@@ -123 +124 @@
     }
 
-    return VINF_SUCCESS;
+    LogFlowFuncLeaveRC(rc);
+    return rc;
 }
 
@@ -146 +148 @@
         }
         else
-        {
             rc = VERR_NO_MEMORY;
-        }
     }
 
+    LogFlowFuncLeaveRC(rc);
     return rc;
 }
@@ -231 +232 @@
 static DECLCALLBACK(int) drvHostNullAudioFiniIn(PPDMIHOSTAUDIO pInterface, PPDMAUDIOHSTSTRMIN pHstStrmIn)
 {
+    LogFlowFuncLeaveRC(VINF_SUCCESS);
     return VINF_SUCCESS;
 }
@@ -236 +238 @@
 static DECLCALLBACK(int) drvHostNullAudioFiniOut(PPDMIHOSTAUDIO pInterface, PPDMAUDIOHSTSTRMOUT pHstStrmOut)
 {
+    PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
+
     PNULLAUDIOSTREAMOUT pNullStrmOut = (PNULLAUDIOSTREAMOUT)pHstStrmOut;
     if (   pNullStrmOut
@@ -241 +245 @@
     {
         RTMemFree(pNullStrmOut->pu8PlayBuffer);
+        pNullStrmOut->pu8PlayBuffer = NULL;
     }
+
+    LogFlowFuncLeaveRC(VINF_SUCCESS);
     return VINF_SUCCESS;
 }

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

@@ -155 +155 @@
     switch (fmt)
     {
-        case AUD_FMT_S8:
+        case PDMAUDIOFMT_S8:
             return AFMT_S8;
 
-        case AUD_FMT_U8:
+        case PDMAUDIOFMT_U8:
             return AFMT_U8;
 
-        case AUD_FMT_S16:
+        case PDMAUDIOFMT_S16:
             return AFMT_S16_LE;
 
-        case AUD_FMT_U16:
+        case PDMAUDIOFMT_U16:
             return AFMT_U16_LE;
 
@@ -180 +180 @@
     {
         case AFMT_S8:
-            *pFmt = AUD_FMT_S8;
+            *pFmt = PDMAUDIOFMT_S8;
             if (pENDIANNESS)
                 *pENDIANNESS = PDMAUDIOENDIANNESS_LITTLE;
@@ -186 +186 @@
 
         case AFMT_U8:
-            *pFmt = AUD_FMT_U8;
+            *pFmt = PDMAUDIOFMT_U8;
             if (pENDIANNESS)
                 *pENDIANNESS = PDMAUDIOENDIANNESS_LITTLE;
@@ -192 +192 @@
 
         case AFMT_S16_LE:
-            *pFmt = AUD_FMT_S16;
+            *pFmt = PDMAUDIOFMT_S16;
             if (pENDIANNESS)
                 *pENDIANNESS = PDMAUDIOENDIANNESS_LITTLE;
@@ -198 +198 @@
 
         case AFMT_U16_LE:
-            *pFmt = AUD_FMT_U16;
+            *pFmt = PDMAUDIOFMT_U16;
             if (pENDIANNESS)
                 *pENDIANNESS = PDMAUDIOENDIANNESS_LITTLE;
@@ -204 +204 @@
 
         case AFMT_S16_BE:
-            *pFmt = AUD_FMT_S16;
+            *pFmt = PDMAUDIOFMT_S16;
             if (pENDIANNESS)
                 *pENDIANNESS = PDMAUDIOENDIANNESS_BIG;
@@ -210 +210 @@
 
         case AFMT_U16_BE:
-            *pFmt = AUD_FMT_U16;
+            *pFmt = PDMAUDIOFMT_U16;
             if (pENDIANNESS)
                 *pENDIANNESS = PDMAUDIOENDIANNESS_BIG;

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

@@ -182 +182 @@
     switch (fmt)
     {
-        case AUD_FMT_U8:
+        case PDMAUDIOFMT_U8:
             return PA_SAMPLE_U8;
 
-        case AUD_FMT_S16:
+        case PDMAUDIOFMT_S16:
             return PA_SAMPLE_S16LE;
 
 #ifdef PA_SAMPLE_S32LE
-        case AUD_FMT_S32:
+        case PDMAUDIOFMT_S32:
             return PA_SAMPLE_S32LE;
 #endif
@@ -206 +206 @@
     {
         case PA_SAMPLE_U8:
-            *pFmt = AUD_FMT_U8;
+            *pFmt = PDMAUDIOFMT_U8;
             *pEndianness = PDMAUDIOENDIANNESS_LITTLE;
             break;
 
         case PA_SAMPLE_S16LE:
-            *pFmt = AUD_FMT_S16;
+            *pFmt = PDMAUDIOFMT_S16;
             *pEndianness = PDMAUDIOENDIANNESS_LITTLE;
             break;
 
         case PA_SAMPLE_S16BE:
-            *pFmt = AUD_FMT_S16;
+            *pFmt = PDMAUDIOFMT_S16;
             *pEndianness = PDMAUDIOENDIANNESS_BIG;
             break;
@@ -222 +222 @@
 #ifdef PA_SAMPLE_S32LE
         case PA_SAMPLE_S32LE:
-            *pFmt = AUD_FMT_S32;
+            *pFmt = PDMAUDIOFMT_S32;
             *pEndianness = PDMAUDIOENDIANNESS_LITTLE;
             break;
@@ -229 +229 @@
 #ifdef PA_SAMPLE_S32BE
         case PA_SAMPLE_S32BE:
-            *pFmt = AUD_FMT_S32;
+            *pFmt = PDMAUDIOFMT_S32;
             *pEndianness = PDMAUDIOENDIANNESS_BIG;
             break;
@@ -899 +899 @@
     if (!cLive)
     {
-        LogFlowFunc(("%p: No live samples, skipping\n", pHstStrmOut));
-
+#if 0
+        LogFlowFunc(("No live samples, skipping\n"));
+#endif
         if (pcSamplesPlayed)
             *pcSamplesPlayed = 0;

trunk/src/VBox/Devices/Audio/testcase/tstAudioMixBuffer.cpp

@@ -48 +48 @@
         44100,                    /* Hz */
         2                         /* Channels */,
-        AUD_FMT_S16               /* Format */,
+        PDMAUDIOFMT_S16               /* Format */,
         PDMAUDIOENDIANNESS_LITTLE /* ENDIANNESS */
     };
@@ -150 +150 @@
         44100,                    /* Hz */
         2                         /* Channels */,
-        AUD_FMT_S16               /* Format */,
+        PDMAUDIOFMT_S16               /* Format */,
         PDMAUDIOENDIANNESS_LITTLE /* ENDIANNESS */
     };
@@ -168 +168 @@
         22050,                    /* Hz */
         2                         /* Channels */,
-        AUD_FMT_S16               /* Format */,
+        PDMAUDIOFMT_S16               /* Format */,
         PDMAUDIOENDIANNESS_LITTLE /* ENDIANNESS */
     };
@@ -186 +186 @@
         48000,                    /* Hz */
         2                         /* Channels */,
-        AUD_FMT_S16               /* Format */,
+        PDMAUDIOFMT_S16               /* Format */,
         PDMAUDIOENDIANNESS_LITTLE /* ENDIANNESS */
     };
@@ -271 +271 @@
         44100,                    /* Hz */
         1                         /* Channels */,
-        AUD_FMT_U8                /* Format */,
+        PDMAUDIOFMT_U8                /* Format */,
         PDMAUDIOENDIANNESS_LITTLE /* ENDIANNESS */
     };
@@ -295 +295 @@
         22050,                    /* Hz */
         1                         /* Channels */,
-        AUD_FMT_U8                /* Format */,
+        PDMAUDIOFMT_U8                /* Format */,
         PDMAUDIOENDIANNESS_LITTLE /* ENDIANNESS */
     };
@@ -381 +381 @@
         44100,                    /* Hz */
         1                         /* Channels */,
-        AUD_FMT_S16               /* Format */,
+        PDMAUDIOFMT_S16               /* Format */,
         PDMAUDIOENDIANNESS_LITTLE /* ENDIANNESS */
     };
@@ -398 +398 @@
         22050,                    /* Hz */
         1                         /* Channels */,
-        AUD_FMT_S16               /* Format */,
+        PDMAUDIOFMT_S16               /* Format */,
         PDMAUDIOENDIANNESS_LITTLE /* ENDIANNESS */
     };
@@ -485 +485 @@
         44100,                    /* Hz */
         2                         /* Channels */,
-        AUD_FMT_S16               /* Format */,
+        PDMAUDIOFMT_S16               /* Format */,
         PDMAUDIOENDIANNESS_LITTLE /* ENDIANNESS */
     };

trunk/src/VBox/Devices/Makefile.kmk

@@ -540 +540 @@
  # --- Audio bits. ---
 
+ if 0
+  VBoxDD_DEFS += VBOX_WITH_HDA_INTERLEAVING_STREAMS_SUPPORT
+  VBoxDD_DEFS += VBOX_WITH_HDA_51_SURROUND
+ endif
+
  VBoxDD_SOURCES         += \
    Audio/AudioMixBuffer.cpp \

trunk/src/VBox/Devices/testcase/tstDeviceStructSizeRC.cpp

@@ -1923 +1923 @@
     GEN_CHECK_OFF(AC97DRIVER, Out);
 
-    GEN_CHECK_SIZE(HDAINPUTSTREAM);
-    GEN_CHECK_OFF(HDAINPUTSTREAM, pGstStrm);
-    GEN_CHECK_OFF(HDAINPUTSTREAM, pMixStrm);
-
-    GEN_CHECK_SIZE(HDAOUTPUTSTREAM);
-    GEN_CHECK_OFF(HDAOUTPUTSTREAM, pGstStrm);
-    GEN_CHECK_OFF(HDAOUTPUTSTREAM, pMixStrm);
+    GEN_CHECK_SIZE(HDAMIXERSTREAM);
+    GEN_CHECK_OFF(HDAMIXERSTREAM, DestSource);
+    GEN_CHECK_OFF(HDAMIXERSTREAM, pMixStrm);
 
     GEN_CHECK_SIZE(HDADRIVER);
@@ -1943 +1939 @@
 #endif
     GEN_CHECK_OFF(HDADRIVER, Front);
+#ifdef VBOX_WITH_HDA_51_SURROUND
+    GEN_CHECK_OFF(HDADRIVER, CenterLFE);
+    GEN_CHECK_OFF(HDADRIVER, Rear);
+#endif
 
     GEN_CHECK_SIZE(HDABDLESTATE);
@@ -2015 +2015 @@
     GEN_CHECK_OFF(HDASTATE, u64BaseTS);
     GEN_CHECK_OFF(HDASTATE, u8RespIntCnt);
-#ifdef VBOX_WITH_HDA_INTERLEAVING_STREAMS_SUPPORT
-    GEN_CHECK_OFF(HDASTATE, pCircBuf);
-#endif
 
 #ifdef VBOX_WITH_NVME_IMPL

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

@@ -139 +139 @@
     switch (as->enmFormat)
     {
-        case AUD_FMT_S8:
+        case PDMAUDIOFMT_S8:
             fSigned = 1;
-        case AUD_FMT_U8:
+        case PDMAUDIOFMT_U8:
             break;
 
-        case AUD_FMT_S16:
+        case PDMAUDIOFMT_S16:
             fSigned = 1;
-        case AUD_FMT_U16:
+        case PDMAUDIOFMT_U16:
             cBits = 16;
             cShift = 1;
             break;
 
-        case AUD_FMT_S32:
+        case PDMAUDIOFMT_S32:
             fSigned = 1;
-        case AUD_FMT_U32:
+        case PDMAUDIOFMT_U32:
             cBits = 32;
             cShift = 2;