Changeset 89302 in vbox

Timestamp:

May 26, 2021 9:00:51 PM (4 years ago)

Author:

vboxsync

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

144649

Message:

Audio: Reworking the capture (recording) code path, part 1: Start doing device side mixing in preparation of DrvAudio stopping it's mixing. Code for blending/merging more than one input isn't entirely done. Resampling is completely untested. bugref:9890

Location:

trunk/src/VBox/Devices/Audio

Files:

• AudioMixBuffer.cpp (modified) (12 diffs)
• AudioMixBuffer.h (modified) (4 diffs)
• AudioMixer.cpp (modified) (23 diffs)
• AudioMixer.h (modified) (3 diffs)
• DevHda.cpp (modified) (4 diffs)
• DevHdaStream.cpp (modified) (2 diffs)
• DevIchAc97.cpp (modified) (4 diffs)

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

@@ -498 +498 @@
             pDst[1] = audioMixBufClipTo##a_Name(pi64Src[1]); \
             AUDMIXBUF_MACRO_LOG(("%p: %RI64 / %RI64 => %RI64 / %RI64\n", \
-                                 pi64Src[0], pi64Src[0], pi64Src[1], (int64_t)pDst[0], (int64_t)pDst[1])); \
+                                 &pi64Src[0], pi64Src[0], pi64Src[1], (int64_t)pDst[0], (int64_t)pDst[1])); \
             pDst    += 2; \
             pi64Src += 2; \
@@ -543 +543 @@
              pi64Src += 2; /** @todo when we do multi channel mixbuf support, this can change to 1 */ \
         } \
-    }
-
+    } \
+    \
+    /* Decoders for write: */ \
+    \
+    /* 2ch -> 2ch */ \
+    static DECLCALLBACK(void) RT_CONCAT(audioMixBufDecode2ChTo2Ch,a_Name)(int64_t *pi64Dst, void const *pvSrc, uint32_t cFrames, \
+                                                                          PAUDIOMIXBUFWRITESTATE pState) \
+    { \
+        RT_NOREF_PV(pState); \
+        a_Type const *pSrc = (a_Type const *)pvSrc; \
+        while (cFrames-- > 0) \
+        { \
+            pi64Dst[0] = audioMixBufClipFrom##a_Name(pSrc[0]); \
+            pi64Dst[1] = audioMixBufClipFrom##a_Name(pSrc[1]); \
+            AUDMIXBUF_MACRO_LOG(("%p: %RI64 / %RI64 => %RI64 / %RI64\n", \
+                                 &pSrc[0], (int64_t)pSrc[0], (int64_t)pSrc[1], pi64Dst[0], pi64Dst[1])); \
+            pi64Dst  += 2; \
+            pSrc     += 2; \
+        } \
+    } \
+    \
+    /* 2ch -> 1ch */ \
+    static DECLCALLBACK(void) RT_CONCAT(audioMixBufDecode2ChTo1Ch,a_Name)(int64_t *pi64Dst, void const *pvSrc, uint32_t cFrames, \
+                                                                          PAUDIOMIXBUFWRITESTATE pState) \
+    { \
+        RT_NOREF_PV(pState); \
+        a_Type const *pSrc = (a_Type const *)pvSrc; \
+        while (cFrames-- > 0) \
+        { \
+            pi64Dst[0] = (audioMixBufClipFrom##a_Name(pSrc[0]) + audioMixBufClipFrom##a_Name(pSrc[1])) / 2; \
+            pi64Dst  += 2; /** @todo when we do multi channel mixbuf support, this can change to 1 */ \
+            pSrc     += 2; \
+        } \
+    } \
+    \
+    /* 1ch -> 2ch */ \
+    static DECLCALLBACK(void) RT_CONCAT(audioMixBufDecode1ChTo2Ch,a_Name)(int64_t *pi64Dst, void const *pvSrc, uint32_t cFrames, \
+                                                                          PAUDIOMIXBUFWRITESTATE pState) \
+    { \
+        RT_NOREF_PV(pState); \
+        a_Type const *pSrc = (a_Type const *)pvSrc; \
+        while (cFrames-- > 0) \
+        { \
+            pi64Dst[1] = pi64Dst[0] = audioMixBufClipFrom##a_Name(pSrc[0]); \
+            pi64Dst  += 2; \
+            pSrc     += 1; \
+        } \
+    } \
+    \
+    /* 1ch -> 1ch */ \
+    static DECLCALLBACK(void) RT_CONCAT(audioMixBufDecode1ChTo1Ch,a_Name)(int64_t *pi64Dst, void const *pvSrc, uint32_t cFrames, \
+                                                                          PAUDIOMIXBUFWRITESTATE pState) \
+    { \
+        RT_NOREF_PV(pState); \
+        a_Type const *pSrc = (a_Type const *)pvSrc; \
+        while (cFrames-- > 0) \
+        { \
+            pi64Dst[0] = audioMixBufClipFrom##a_Name(pSrc[0]); \
+            pi64Dst  += 2; /** @todo when we do multi channel mixbuf support, this can change to 1 */ \
+            pSrc     += 1; \
+        } \
+    }
 
 /* audioMixBufConvXXXS8: 8 bit, signed. */
@@ -589 +649 @@
 }
 
+/* Encoders for peek: */
 
 static DECLCALLBACK(void)
@@ -635 +696 @@
          pi64Dst += 1;
          pi64Src += 2;
+    }
+}
+
+
+/* Decoders for write: */
+
+static DECLCALLBACK(void)
+audioMixBufDecode2ChTo2ChRaw(int64_t *pi64Dst, void const *pvSrc, uint32_t cFrames, PAUDIOMIXBUFWRITESTATE pState)
+{
+    RT_NOREF_PV(pState);
+    memcpy(pi64Dst, pvSrc, sizeof(int64_t) * 2 * cFrames);
+}
+
+static DECLCALLBACK(void)
+audioMixBufDecode2ChTo1ChRaw(int64_t *pi64Dst, void const *pvSrc, uint32_t cFrames, PAUDIOMIXBUFWRITESTATE pState)
+{
+    RT_NOREF_PV(pState);
+    int64_t const *pi64Src = (int64_t const *)pvSrc;
+    while (cFrames-- > 0)
+    {
+         *pi64Dst = (pi64Src[0] + pi64Src[1]) / 2;
+         pi64Dst += 2;  /** @todo when we do multi channel mixbuf support, this can change to 1 */
+         pi64Src += 2;
+    }
+}
+
+static DECLCALLBACK(void)
+audioMixBufDecode1ChTo2ChRaw(int64_t *pi64Dst, void const *pvSrc, uint32_t cFrames, PAUDIOMIXBUFWRITESTATE pState)
+{
+    RT_NOREF_PV(pState);
+    int64_t const *pi64Src = (int64_t const *)pvSrc;
+    while (cFrames-- > 0)
+    {
+         pi64Dst[0] = pi64Dst[1] = *pi64Src;
+         pi64Dst += 2;
+         pi64Src += 1;
+    }
+}
+
+static DECLCALLBACK(void)
+audioMixBufDecode1ChTo1ChRaw(int64_t *pi64Dst, void const *pvSrc, uint32_t cFrames, PAUDIOMIXBUFWRITESTATE pState)
+{
+    RT_NOREF_PV(pState);
+    /** @todo memcpy(pi64Dst, pvSrc, sizeof(int64_t) * 1 * cFrames); when we do
+     *        multi channel mixbuf support. */
+    int64_t const *pi64Src = (int64_t const *)pvSrc;
+    while (cFrames-- > 0)
+    {
+         *pi64Dst = *pi64Src;
+         pi64Dst += 2; /** @todo when we do multi channel mixbuf support, this can change to 1 */
+         pi64Src += 1;
     }
 }
@@ -1529 +1641 @@
 
 /**
- * Reads audio frames at a specific offset.
- *
- * @returns VBox status code.
- * @param   pMixBuf                 Mixing buffer to read audio frames from.
- * @param   offFrames               Offset (in audio frames) to start reading from.
- * @param   pvBuf                   Pointer to buffer to write output to.
- * @param   cbBuf                   Size (in bytes) of buffer to write to.
- * @param   pcbRead                 Size (in bytes) of data read. Optional.
- */
-int AudioMixBufReadAt(PAUDIOMIXBUF pMixBuf, uint32_t offFrames, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead)
-{
-    return AudioMixBufReadAtEx(pMixBuf, &pMixBuf->Props, offFrames, pvBuf, cbBuf, pcbRead);
-}
-
-/**
- * Reads audio frames at a specific offset.
- * If the audio format of the mixing buffer and the requested audio format do
- * not match the output will be converted accordingly.
- *
- * @returns VBox status code.
- * @param   pMixBuf     Mixing buffer to read audio frames from.
- * @param   pDstProps   The target format.
- * @param   offFrames   Offset (in audio frames) to start reading from.
- * @param   pvBuf       Pointer to buffer to write output to.
- * @param   cbBuf       Size (in bytes) of buffer to write to.
- * @param   pcbRead     Size (in bytes) of data read. Optional.
- */
-int AudioMixBufReadAtEx(PAUDIOMIXBUF pMixBuf, PCPDMAUDIOPCMPROPS pDstProps,
-                        uint32_t offFrames, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead)
-{
-    AssertPtrReturn(pMixBuf, VERR_INVALID_POINTER);
-    AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
-    /* pcbRead is optional. */
-
-    uint32_t cDstFrames = pMixBuf->cFrames;
-    uint32_t cLive = pMixBuf->cUsed;
-
-    uint32_t cDead = cDstFrames - cLive;
-    uint32_t cToProcess = (uint32_t)AUDIOMIXBUF_F2F_RATIO(pMixBuf, cDead);
-    cToProcess = RT_MIN(cToProcess, AUDIOMIXBUF_B2F(pMixBuf, cbBuf));
-
-    AUDMIXBUF_LOG(("%s: offFrames=%RU32, cLive=%RU32, cDead=%RU32, cToProcess=%RU32\n",
-                   pMixBuf->pszName, offFrames, cLive, cDead, cToProcess));
-
-    int rc;
-    if (cToProcess)
-    {
-        PFNAUDIOMIXBUFCONVTO pfnConvTo = NULL;
-        if (PDMAudioPropsAreEqual(&pMixBuf->Props, pDstProps))
-            pfnConvTo = pMixBuf->pfnConvTo;
-        else
-            pfnConvTo = audioMixBufConvToLookup(pDstProps);
-        if (pfnConvTo)
-        {
-            AUDMIXBUFCONVOPTS convOpts;
-            RT_ZERO(convOpts);
-            /* Note: No volume handling/conversion done in the conversion-to macros (yet). */
-
-            convOpts.cFrames = cToProcess;
-
-            pfnConvTo(pvBuf, pMixBuf->pFrames + offFrames, &convOpts);
-
-#ifdef DEBUG
-            AudioMixBufDbgPrint(pMixBuf);
-#endif
-            rc = VINF_SUCCESS;
-        }
-        else
-        {
-            AssertFailed();
-            rc = VERR_NOT_SUPPORTED;
-        }
-    }
-    else
-        rc = VINF_SUCCESS;
-
-    if (RT_SUCCESS(rc))
-    {
-        if (pcbRead)
-            *pcbRead = AUDIOMIXBUF_F2B(pMixBuf, cToProcess);
-    }
-
-    AUDMIXBUF_LOG(("cbRead=%RU32, rc=%Rrc\n", AUDIOMIXBUF_F2B(pMixBuf, cToProcess), rc));
-    return rc;
-}
-
-/**
  * Reads audio frames. The audio format of the mixing buffer will be used.
  *
@@ -1866 +1891 @@
 
 /**
+ * Resets the resampling state unconditionally.
+ *
+ * @param   pRate   The state to reset.
+ */
+static void audioMixBufRateResetAlways(PAUDIOSTREAMRATE pRate)
+{
+    pRate->offDst = 0;
+    pRate->offSrc = 0;
+    for (uintptr_t i = 0; i < RT_ELEMENTS(pRate->SrcLast.ai64Samples); i++)
+        pRate->SrcLast.ai64Samples[0] = 0;
+}
+
+
+/**
+ * Resets the resampling state.
+ *
+ * @param   pRate   The state to reset.
+ */
+DECLINLINE(void) audioMixBufRateReset(PAUDIOSTREAMRATE pRate)
+{
+    if (pRate->offDst == 0)
+    { /* likely */ }
+    else
+    {
+        Assert(!pRate->fNoConversionNeeded);
+        audioMixBufRateResetAlways(pRate);
+    }
+}
+
+
+/**
+ * Initializes the frame rate converter state.
+ *
+ * @returns VBox status code.
+ * @param   pRate       The state to initialize.
+ * @param   uSrcHz      The source frame rate.
+ * @param   uDstHz      The destination frame rate.
+ * @param   cChannels   The number of channels in a frame.
+ */
+DECLINLINE(int) audioMixBufRateInit(PAUDIOSTREAMRATE pRate, uint32_t uSrcHz, uint32_t uDstHz, uint8_t cChannels)
+{
+    /*
+     * Do we need to set up frequency conversion?
+     *
+     * Some examples to get an idea of what uDstInc holds:
+     *   44100 to 44100 -> (44100<<32) / 44100 = 0x01'00000000 (4294967296)
+     *   22050 to 44100 -> (22050<<32) / 44100 = 0x00'80000000 (2147483648)
+     *   44100 to 22050 -> (44100<<32) / 22050 = 0x02'00000000 (8589934592)
+     *   44100 to 48000 -> (44100<<32) / 48000 = 0x00'EB333333 (3946001203.2)
+     *   48000 to 44100 -> (48000<<32) / 44100 = 0x01'16A3B35F (4674794335.7823129251700680272109)
+     */
+    audioMixBufRateResetAlways(pRate);
+    if (uSrcHz == uDstHz)
+    {
+        pRate->fNoConversionNeeded = true;
+        pRate->uDstInc             = RT_BIT_64(32);
+        pRate->pfnResample         = NULL;
+    }
+    else
+    {
+        pRate->fNoConversionNeeded = false;
+        pRate->uDstInc             = ((uint64_t)uSrcHz << 32) / uDstHz;
+        AssertReturn(uSrcHz != 0, VERR_INVALID_PARAMETER);
+        switch (cChannels)
+        {
+            case 1: pRate->pfnResample = audioMixBufResample1ChGeneric; break;
+            case 2: pRate->pfnResample = audioMixBufResample2ChGeneric; break;
+            default:
+                AssertMsgFailedReturn(("resampling %u changes is not implemented yet\n", cChannels), VERR_OUT_OF_RANGE);
+        }
+    }
+    return VINF_SUCCESS;
+}
+
+
+
+/**
  * Initializes the peek state, setting up encoder and (if necessary) resampling.
  *
@@ -1982 +2084 @@
                 AssertMsgFailedReturn(("from %u to %u channels is not implemented yet\n", cSrcCh, cDstCh), VERR_OUT_OF_RANGE);
         }
-
-    }
+    }
+
+    int rc = audioMixBufRateInit(&pState->Rate, PDMAudioPropsHz(&pMixBuf->Props), PDMAudioPropsHz(pProps), cSrcCh);
+    AUDMIXBUF_LOG(("%s: %RU32 Hz to %RU32 Hz => uDstInc=0x%'RX64\n", pMixBuf->pszName, PDMAudioPropsHz(&pMixBuf->Props),
+                   PDMAudioPropsHz(pProps), pState->Rate.uDstInc));
+    return rc;
+}
+
+
+/**
+ * Initializes the write/blend state, setting up decoders and (if necessary)
+ * resampling.
+ *
+ * @returns VBox status code.
+ */
+int AudioMixBufInitWriteState(PCAUDIOMIXBUF pMixBuf, PAUDIOMIXBUFWRITESTATE pState, PCPDMAUDIOPCMPROPS pProps)
+{
+    AssertPtr(pMixBuf);
+    AssertPtr(pState);
+    AssertPtr(pProps);
 
     /*
-     * Do we need to set up frequency conversion?
-     *
-     * Some examples to get an idea of what uDstInc holds:
-     *   44100 to 44100 -> (44100<<32) / 44100 = 0x01'00000000 (4294967296)
-     *   22050 to 44100 -> (22050<<32) / 44100 = 0x00'80000000 (2147483648)
-     *   44100 to 22050 -> (44100<<32) / 22050 = 0x02'00000000 (8589934592)
-     *   44100 to 48000 -> (44100<<32) / 48000 = 0x00'EB333333 (3946001203.2)
-     *   48000 to 44100 -> (48000<<32) / 44100 = 0x01'16A3B35F (4674794335.7823129251700680272109)
+     * Pick the encoding function first.
      */
-    uint32_t const uSrcHz = PDMAudioPropsHz(&pMixBuf->Props);
-    uint32_t const uDstHz = PDMAudioPropsHz(pProps);
-    RT_ZERO(pState->Rate);
-    if (uSrcHz == uDstHz)
-    {
-        pState->Rate.fNoConversionNeeded = true;
-        pState->Rate.uDstInc             = RT_BIT_64(32);
-        pState->Rate.pfnResample         = NULL;
+    uint8_t const cSrcCh = PDMAudioPropsChannels(pProps);
+    uint8_t const cDstCh = PDMAudioPropsChannels(&pMixBuf->Props);
+    pState->cSrcChannels = cSrcCh;
+    pState->cDstChannels = cDstCh;
+    pState->cbSrcFrame   = PDMAudioPropsFrameSize(pProps);
+    if (PDMAudioPropsIsSigned(pProps))
+    {
+        switch (cDstCh)
+        {
+            case 1:
+                AssertReturn(cSrcCh == 1 || cSrcCh == 2, VERR_OUT_OF_RANGE);
+                switch (PDMAudioPropsSampleSize(pProps))
+                {
+                    case 1:
+                        pState->pfnDecode = cSrcCh == 1 ? audioMixBufDecode1ChTo1ChS8  : audioMixBufDecode2ChTo1ChS8;
+                        break;
+                    case 2:
+                        pState->pfnDecode = cSrcCh == 1 ? audioMixBufDecode1ChTo1ChS16 : audioMixBufDecode2ChTo1ChS16;
+                        break;
+                    case 4:
+                        pState->pfnDecode = cSrcCh == 1 ? audioMixBufDecode1ChTo1ChS32 : audioMixBufDecode2ChTo1ChS32;
+                        break;
+                    case 8:
+                        AssertReturn(pProps->fRaw, VERR_DISK_INVALID_FORMAT);
+                        pState->pfnDecode = cSrcCh == 1 ? audioMixBufDecode1ChTo1ChRaw : audioMixBufDecode2ChTo1ChRaw;
+                        break;
+                    default:
+                        AssertMsgFailedReturn(("%u bytes\n", PDMAudioPropsSampleSize(pProps)), VERR_OUT_OF_RANGE);
+                }
+                break;
+            case 2:
+                AssertReturn(cSrcCh == 1 || cSrcCh == 2, VERR_OUT_OF_RANGE);
+                switch (PDMAudioPropsSampleSize(pProps))
+                {
+                    case 1:
+                        pState->pfnDecode = cSrcCh == 1 ? audioMixBufDecode1ChTo2ChS8  : audioMixBufDecode2ChTo2ChS8;
+                        break;
+                    case 2:
+                        pState->pfnDecode = cSrcCh == 1 ? audioMixBufDecode1ChTo2ChS16 : audioMixBufDecode2ChTo2ChS16;
+                        break;
+                    case 4:
+                        pState->pfnDecode = cSrcCh == 1 ? audioMixBufDecode1ChTo2ChS32 : audioMixBufDecode2ChTo2ChS32;
+                        break;
+                    case 8:
+                        AssertReturn(pProps->fRaw, VERR_DISK_INVALID_FORMAT);
+                        pState->pfnDecode = cSrcCh == 1 ? audioMixBufDecode1ChTo2ChRaw : audioMixBufDecode2ChTo2ChRaw;
+                        break;
+                    default:
+                        AssertMsgFailedReturn(("%u bytes\n", PDMAudioPropsSampleSize(pProps)), VERR_OUT_OF_RANGE);
+                }
+                break;
+            default:
+                /* Note: We may have dedicated encoders for a few selected multichannel
+                         configurations, and generic ones that encodes channel by channel (i.e.
+                         add the mixer channel count, destination frame size, and an array of
+                         destination channel frame offsets to the state). */
+                AssertMsgFailedReturn(("from %u to %u channels is not implemented yet\n", cSrcCh, cDstCh), VERR_OUT_OF_RANGE);
+        }
     }
     else
     {
-        AssertReturn(uSrcHz != 0, VERR_INVALID_PARAMETER);
-        pState->Rate.fNoConversionNeeded = false;
-        pState->Rate.uDstInc             = ((uint64_t)uSrcHz << 32) / uDstHz;
-        switch (cSrcCh)
+        switch (cDstCh)
         {
-            case 1: pState->Rate.pfnResample = audioMixBufResample1ChGeneric; break;
-            case 2: pState->Rate.pfnResample = audioMixBufResample2ChGeneric; break;
+            case 1:
+                AssertReturn(cSrcCh == 1 || cSrcCh == 2, VERR_OUT_OF_RANGE);
+                switch (PDMAudioPropsSampleSize(pProps))
+                {
+                    case 1:
+                        pState->pfnDecode = cSrcCh == 1 ? audioMixBufDecode1ChTo1ChU8  : audioMixBufDecode2ChTo1ChU8;
+                        break;
+                    case 2:
+                        pState->pfnDecode = cSrcCh == 1 ? audioMixBufDecode1ChTo1ChU16 : audioMixBufDecode2ChTo1ChU16;
+                        break;
+                    case 4:
+                        pState->pfnDecode = cSrcCh == 1 ? audioMixBufDecode1ChTo1ChU32 : audioMixBufDecode2ChTo1ChU32;
+                        break;
+                    default:
+                        AssertMsgFailedReturn(("%u bytes\n", PDMAudioPropsSampleSize(pProps)), VERR_OUT_OF_RANGE);
+                }
+                break;
+            case 2:
+                AssertReturn(cSrcCh == 1 || cSrcCh == 2, VERR_OUT_OF_RANGE);
+                switch (PDMAudioPropsSampleSize(pProps))
+                {
+                    case 1:
+                        pState->pfnDecode = cSrcCh == 1 ? audioMixBufDecode1ChTo2ChU8  : audioMixBufDecode2ChTo2ChU8;
+                        break;
+                    case 2:
+                        pState->pfnDecode = cSrcCh == 1 ? audioMixBufDecode1ChTo2ChU16 : audioMixBufDecode2ChTo2ChU16;
+                        break;
+                    case 4:
+                        pState->pfnDecode = cSrcCh == 1 ? audioMixBufDecode1ChTo2ChU32 : audioMixBufDecode2ChTo2ChU32;
+                        break;
+                    default:
+                        AssertMsgFailedReturn(("%u bytes\n", PDMAudioPropsSampleSize(pProps)), VERR_OUT_OF_RANGE);
+                }
+                break;
             default:
-                AssertMsgFailedReturn(("resampling %u changes is not implemented yet\n", cSrcCh), VERR_OUT_OF_RANGE);
+                /* Note: We may have dedicated encoders for a few selected multichannel
+                         configurations, and generic ones that encodes channel by channel (i.e.
+                         add an array of destination channel frame offsets to the state). */
+                AssertMsgFailedReturn(("from %u to %u channels is not implemented yet\n", cSrcCh, cDstCh), VERR_OUT_OF_RANGE);
         }
     }
-    AUDMIXBUF_LOG(("%s: %RU32 Hz to %RU32 Hz => uDstInc=0x%'RX64\n", pMixBuf->pszName, uSrcHz, uDstHz, pState->Rate.uDstInc));
-    return VINF_SUCCESS;
+
+    int rc = audioMixBufRateInit(&pState->Rate, PDMAudioPropsHz(pProps), PDMAudioPropsHz(&pMixBuf->Props), cDstCh);
+    AUDMIXBUF_LOG(("%s: %RU32 Hz to %RU32 Hz => uDstInc=0x%'RX64\n", pMixBuf->pszName, PDMAudioPropsHz(pProps),
+                   PDMAudioPropsHz(&pMixBuf->Props), pState->Rate.uDstInc));
+    return rc;
 }
 
@@ -2038 +2236 @@
         uint32_t cMaxDstFrames = RT_MIN(RT_ELEMENTS(ai64DstRate) / pState->cDstChannels, cbDst / pState->cbDstFrame);
         uint32_t const cDstFrames = pState->Rate.pfnResample(ai64DstRate, cMaxDstFrames,
-                                                            &pMixBuf->pFrames[offSrcFrame].i64LSample, cSrcFrames, &cSrcFrames,
-                                                            &pState->Rate);
+                                                             &pMixBuf->pFrames[offSrcFrame].i64LSample, cSrcFrames, &cSrcFrames,
+                                                             &pState->Rate);
         *pcSrcFramesPeeked += cSrcFrames;
         cMaxSrcFrames      -= cSrcFrames;
@@ -2052 +2250 @@
     }
 }
-
 
 
@@ -2123 +2320 @@
 
 /**
+ * Worker for AudioMixBufPeek that handles the rate conversion case.
+ */
+DECL_NO_INLINE(static, void)
+AudioMixBufWriteResampling(PAUDIOMIXBUF pMixBuf, PAUDIOMIXBUFWRITESTATE pState, const void *pvSrcBuf, uint32_t cbSrcBuf,
+                           uint32_t offDstFrame, uint32_t cMaxDstFrames, uint32_t *pcDstFramesWritten)
+{
+    *pcDstFramesWritten = 0;
+    while (cMaxDstFrames > 0 && cbSrcBuf >= pState->cbSrcFrame)
+    {
+        /* Decode into temporary buffer. */
+        int64_t  ai64SrcDecoded[1024];
+        uint32_t cFramesDecoded = RT_MIN(RT_ELEMENTS(ai64SrcDecoded) / pState->cSrcChannels, cbSrcBuf / pState->cbSrcFrame);
+        pState->pfnDecode(ai64SrcDecoded, pvSrcBuf, cFramesDecoded, pState);
+        cbSrcBuf -= cFramesDecoded * pState->cbSrcFrame;
+        pvSrcBuf  = (uint8_t const *)pvSrcBuf + cFramesDecoded * pState->cbSrcFrame;
+
+        /* Rate convert that into the mixer. */
+        uint32_t iFrameDecoded = 0;
+        while (iFrameDecoded < cFramesDecoded)
+        {
+            uint32_t cDstMaxFrames    = RT_MIN(pMixBuf->cFrames - offDstFrame, cMaxDstFrames);
+            uint32_t cSrcFrames       = cFramesDecoded - iFrameDecoded;
+            uint32_t const cDstFrames = pState->Rate.pfnResample(&pMixBuf->pFrames[offDstFrame].i64LSample, cDstMaxFrames,
+                                                                 &ai64SrcDecoded[iFrameDecoded * pState->cSrcChannels],
+                                                                 cSrcFrames, &cSrcFrames, &pState->Rate);
+
+            iFrameDecoded       += cSrcFrames;
+            *pcDstFramesWritten += cDstFrames;
+            offDstFrame          = (offDstFrame + cDstFrames) % pMixBuf->cFrames;
+        }
+    }
+
+    /** @todo How to squeeze odd frames out of 22050 => 44100 conversion?   */
+}
+
+
+/**
+ * Writes @a cbSrcBuf bytes to the mixer buffer starting at @a offDstFrame,
+ * converting it as needed, leaving the write offset untouched.
+ *
+ * @param   pMixBuf             The mixing buffer.
+ * @param   pState              Source configuration & conversion state.
+ * @param   pvSrcBuf            The source frames.
+ * @param   cbSrcBuf            Number of bytes of source frames.  This will be
+ *                              convered in full.
+ * @param   offDstFrame         Mixing buffer offset relative to the write
+ *                              position.
+ * @param   cMaxDstFrames       Max number of frames to write.
+ * @param   pcDstFramesWritten  Where to return the number of frames actually
+ *                              written.
+ *
+ * @note    Does not advance the write position, please call AudioMixBufCommit()
+ *          to do that.
+ */
+void AudioMixBufWrite(PAUDIOMIXBUF pMixBuf, PAUDIOMIXBUFWRITESTATE pState, const void *pvSrcBuf, uint32_t cbSrcBuf,
+                      uint32_t offDstFrame, uint32_t cMaxDstFrames, uint32_t *pcDstFramesWritten)
+{
+    /*
+     * Check inputs.
+     */
+    AssertPtr(pMixBuf);
+    Assert(pMixBuf->uMagic == AUDIOMIXBUF_MAGIC);
+    AssertPtr(pState);
+    AssertPtr(pState->pfnDecode);
+    Assert(pState->cDstChannels == PDMAudioPropsChannels(&pMixBuf->Props));
+    Assert(cMaxDstFrames > 0);
+    Assert(cMaxDstFrames <= pMixBuf->cFrames - pMixBuf->cUsed);
+    Assert(offDstFrame <= pMixBuf->cFrames);
+    AssertPtr(pcDstFramesWritten);
+    AssertPtr(pvSrcBuf);
+    Assert(!(cbSrcBuf % pState->cbSrcFrame));
+    AssertPtr(pcDstFramesWritten);
+
+    /*
+     * Make start frame absolute.
+     */
+    offDstFrame = (pMixBuf->offWrite + offDstFrame) % pMixBuf->cFrames;
+
+    /*
+     * Hopefully no sample rate conversion is necessary...
+     */
+    if (pState->Rate.fNoConversionNeeded)
+    {
+        /* Figure out how much we should convert. */
+        Assert(cMaxDstFrames >= cbSrcBuf / pState->cbSrcFrame);
+        cMaxDstFrames       = RT_MIN(cMaxDstFrames, cbSrcBuf / pState->cbSrcFrame);
+        *pcDstFramesWritten = cMaxDstFrames;
+
+        /* First chunk. */
+        uint32_t const cDstFrames1 = RT_MIN(pMixBuf->cFrames - offDstFrame, cMaxDstFrames);
+        pState->pfnDecode(&pMixBuf->pFrames[offDstFrame].i64LSample, pvSrcBuf, cDstFrames1, pState);
+
+        /* Another chunk from the start of the mixing buffer? */
+        if (cMaxDstFrames > cDstFrames1)
+            pState->pfnDecode(&pMixBuf->pFrames[0].i64LSample, (uint8_t *)pvSrcBuf + cDstFrames1 * pState->cbSrcFrame,
+                              cMaxDstFrames - cDstFrames1, pState);
+    }
+    else
+        AudioMixBufWriteResampling(pMixBuf, pState, pvSrcBuf, cbSrcBuf, offDstFrame, cMaxDstFrames, pcDstFramesWritten);
+}
+
+
+/**
+ * @todo not sure if 'blend' is the appropriate term here, but you know what
+ *       we mean.
+ */
+void AudioMixBufBlend(PAUDIOMIXBUF pMixBuf, PAUDIOMIXBUFWRITESTATE pState, const void *pvSrcBuf, uint32_t cbSrcBuf,
+                      uint32_t offDstFrame, uint32_t cMaxDstFrames, uint32_t *pcDstFramesBlended)
+{
+    /** @todo */
+    RT_NOREF(pMixBuf, pState, pvSrcBuf, cbSrcBuf, offDstFrame, cMaxDstFrames, pcDstFramesBlended);
+}
+
+
+/**
+ * Writes @a cFrames of silence at @a offFrame relative to current write pos.
+ *
+ * This will also adjust the resampling state.
+ *
+ * @param   pMixBuf     The mixing buffer.
+ * @param   pState      The write state.
+ * @param   offFrames   Where to start writing silence relative to the current
+ *                      write position.
+ * @param   cFrames     Number of frames of silence.
+ * @sa      AudioMixBufSilence
+ *
+ * @note    Does not advance the write position, please call AudioMixBufCommit()
+ *          to do that.
+ */
+void AudioMixBufSilence(PAUDIOMIXBUF pMixBuf, PAUDIOMIXBUFWRITESTATE pState, uint32_t offFrame, uint32_t cFrames)
+{
+    /*
+     * Check inputs.
+     */
+    AssertPtr(pMixBuf);
+    Assert(pMixBuf->uMagic == AUDIOMIXBUF_MAGIC);
+    AssertPtr(pState);
+    AssertPtr(pState->pfnDecode);
+    Assert(pState->cDstChannels == PDMAudioPropsChannels(&pMixBuf->Props));
+    Assert(cFrames > 0);
+    Assert(cFrames <= pMixBuf->cFrames);
+    Assert(offFrame <= pMixBuf->cFrames);
+    Assert(offFrame + cFrames <= pMixBuf->cUsed);
+
+    /*
+     * Make start frame absolute.
+     */
+    offFrame = (pMixBuf->offWrite + offFrame) % pMixBuf->cFrames;
+
+    /*
+     * First chunk.
+     */
+    uint32_t cChunk = RT_MIN(pMixBuf->cFrames - offFrame, cFrames);
+    RT_BZERO(&pMixBuf->pFrames[offFrame], cChunk * sizeof(pMixBuf->pFrames[0]));
+    cFrames -= cChunk;
+
+    /*
+     * Second chunk, if needed.
+     */
+    if (cFrames > 0)
+    {
+        AssertStmt(cFrames <= pMixBuf->cFrames, cFrames = pMixBuf->cFrames);
+        RT_BZERO(&pMixBuf->pFrames[0], cFrames * sizeof(pMixBuf->pFrames[0]));
+    }
+
+    /*
+     * Reset the resampling state.
+     */
+    audioMixBufRateReset(&pState->Rate);
+}
+
+
+/**
+ * Records a blending gap (silence) of @a cFrames.
+ *
+ * This is used to adjust or reset the resampling state so we start from a
+ * silence state the next time we need to blend or write using @a pState.
+ *
+ * @param   pMixBuf     The mixing buffer.
+ * @param   pState      The write state.
+ * @param   cFrames     Number of frames of silence.
+ * @sa      AudioMixBufSilence
+ */
+void AudioMixBufBlendGap(PAUDIOMIXBUF pMixBuf, PAUDIOMIXBUFWRITESTATE pState, uint32_t cFrames)
+{
+    /*
+     * For now we'll just reset the resampling state regardless of how many
+     * frames of silence there is.
+     */
+    audioMixBufRateReset(&pState->Rate);
+    RT_NOREF(pMixBuf, cFrames);
+}
+
+
+/**
  * Advances the read position of the buffer.
  *
@@ -2129 +2521 @@
  * @param   pMixBuf     The mixing buffer.
  * @param   cFrames     Number of frames to advance.
+ * @sa      AudioMixBufCommit
  */
 void AudioMixBufAdvance(PAUDIOMIXBUF pMixBuf, uint32_t cFrames)
@@ -2139 +2532 @@
     pMixBuf->offRead  = (pMixBuf->offRead + cFrames) % pMixBuf->cFrames;
     LogFlowFunc(("%s: Advanced %u frames: offRead=%u cUsed=%u\n", pMixBuf->pszName, cFrames, pMixBuf->offRead, pMixBuf->cUsed));
+}
+
+
+/**
+ * Advances the write position of the buffer.
+ *
+ * For use after done peeking with AudioMixBufWrite(), AudioMixBufSilence(),
+ * AudioMixBufBlend() and AudioMixBufBlendGap().
+ *
+ * @param   pMixBuf     The mixing buffer.
+ * @param   cFrames     Number of frames to advance.
+ * @sa      AudioMixBufAdvance
+ */
+void AudioMixBufCommit(PAUDIOMIXBUF pMixBuf, uint32_t cFrames)
+{
+    AssertPtrReturnVoid(pMixBuf);
+    AssertReturnVoid(pMixBuf->uMagic == AUDIOMIXBUF_MAGIC);
+
+    AssertStmt(cFrames <= pMixBuf->cFrames - pMixBuf->cUsed, cFrames = pMixBuf->cFrames - pMixBuf->cUsed);
+    pMixBuf->cUsed   += cFrames;
+    pMixBuf->offWrite = (pMixBuf->offWrite + cFrames) % pMixBuf->cFrames;
+    LogFlowFunc(("%s: Advanced %u frames: offWrite=%u cUsed=%u\n", pMixBuf->pszName, cFrames, pMixBuf->offWrite, pMixBuf->cUsed));
 }
 

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

@@ -159 +159 @@
     /** Source (mixer) channels. */
     uint8_t                     cSrcChannels;
-    /** Destination (mixer) channels. */
+    /** Destination channels. */
     uint8_t                     cDstChannels;
     /** Destination frame size. */
@@ -166 +166 @@
 /** Pointer to peek state & config. */
 typedef AUDIOMIXBUFPEEKSTATE *PAUDIOMIXBUFPEEKSTATE;
+
+
+/**
+ * State & config for AudioMixBufWrite, AudioMixBufSilence, AudioMixBufBlend and
+ * AudioMixBufBlendGap, created by AudioMixBufInitWriteState.
+ */
+typedef struct AUDIOMIXBUFWRITESTATE
+{
+    /** Encodes @a cFrames from @a pvSrc to @a paDst. */
+    DECLR3CALLBACKMEMBER(void,  pfnDecode,(int64_t *paDst, const void *pvSrc, uint32_t cFrames, struct AUDIOMIXBUFWRITESTATE *pState));
+    /** Encodes @a cFrames from @a pvSrc blending into @a paDst. */
+    DECLR3CALLBACKMEMBER(void,  pfnDecodeBlend,(int64_t *paDst, const void *pvSrc, uint32_t cFrames, struct AUDIOMIXBUFWRITESTATE *pState));
+    /** Sample rate conversion state (only used when needed). */
+    AUDIOSTREAMRATE             Rate;
+    /** Destination (mixer) channels. */
+    uint8_t                     cDstChannels;
+    /** Source hannels. */
+    uint8_t                     cSrcChannels;
+    /** Source frame size. */
+    uint8_t                     cbSrcFrame;
+} AUDIOMIXBUFWRITESTATE;
+/** Pointer to write state & config. */
+typedef AUDIOMIXBUFWRITESTATE *PAUDIOMIXBUFWRITESTATE;
 
 
@@ -279 +302 @@
 void    AudioMixBufDrop(PAUDIOMIXBUF pMixBuf);
 
+int     AudioMixBufInitWriteState(PCAUDIOMIXBUF pMixBuf, PAUDIOMIXBUFWRITESTATE pState, PCPDMAUDIOPCMPROPS pSrcProps);
+void    AudioMixBufWrite(PAUDIOMIXBUF pMixBuf, PAUDIOMIXBUFWRITESTATE pState, const void *pvSrcBuf, uint32_t cbSrcBuf,
+                         uint32_t offDstFrame, uint32_t cMaxDstFrames, uint32_t *pcDstFramesWritten);
+void    AudioMixBufSilence(PAUDIOMIXBUF pMixBuf, PAUDIOMIXBUFWRITESTATE pState, uint32_t offFrame, uint32_t cFrames);
+void    AudioMixBufBlend(PAUDIOMIXBUF pMixBuf, PAUDIOMIXBUFWRITESTATE pState, const void *pvSrcBuf, uint32_t cbSrcBuf,
+                         uint32_t offDstFrame, uint32_t cMaxDstFrames, uint32_t *pcDstFramesBlended);
+void    AudioMixBufBlendGap(PAUDIOMIXBUF pMixBuf, PAUDIOMIXBUFWRITESTATE pState, uint32_t cFrames);
+void    AudioMixBufCommit(PAUDIOMIXBUF pMixBuf, uint32_t cFrames);
+
 void AudioMixBufClear(PAUDIOMIXBUF pMixBuf);
 void AudioMixBufFinish(PAUDIOMIXBUF pMixBuf, uint32_t cFramesToClear);
@@ -291 +323 @@
 uint32_t AudioMixBufUsed(PAUDIOMIXBUF pMixBuf);
 uint32_t AudioMixBufUsedBytes(PAUDIOMIXBUF pMixBuf);
-int         AudioMixBufReadAt(PAUDIOMIXBUF pMixBuf, uint32_t offFrames, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead);
-int         AudioMixBufReadAtEx(PAUDIOMIXBUF pMixBuf, PCPDMAUDIOPCMPROPS pDstProps, uint32_t offFrames,
-                                void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead);
 int         AudioMixBufAcquireReadBlock(PAUDIOMIXBUF pMixBuf, void *pvBuf, uint32_t cbBuf, uint32_t *pcAcquiredFrames);
 int         AudioMixBufAcquireReadBlockEx(PAUDIOMIXBUF pMixBuf, PCPDMAUDIOPCMPROPS pDstProps,

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

@@ -643 +643 @@
 
                     /* Set up the mixing buffer conversion state. */
-                    if (pSink->enmDir == PDMAUDIODIR_OUT)
+                    if (pSink->enmDir == PDMAUDIODIR_IN)
+                        rc = AudioMixBufInitWriteState(&pSink->MixBuf, &pMixStream->WriteState, &pStream->Props);
+                    else
                         rc = AudioMixBufInitPeekState(&pSink->MixBuf, &pMixStream->PeekState, &pStream->Props);
                     if (RT_SUCCESS(rc))
@@ -703 +705 @@
     LogFunc(("Starting '%s'. Old status: %s\n", pSink->pszName, dbgAudioMixerSinkStatusToStr(pSink->fStatus, szStatus)));
 
+    AssertReturnStmt(pSink->enmDir == PDMAUDIODIR_IN || pSink->enmDir == PDMAUDIODIR_OUT,
+                     RTCritSectLeave(&pSink->CritSect), VERR_INTERNAL_ERROR_3);
+
     /*
      * Make sure the sink and its streams are all stopped.
@@ -724 +729 @@
      * Send the command to the streams.
      */
-    if (pSink->enmDir == PDMAUDIODIR_OUT)
-    {
-        PAUDMIXSTREAM pStream;
-        RTListForEach(&pSink->lstStreams, pStream, AUDMIXSTREAM, Node)
-        {
-            audioMixerStreamCtlInternal(pStream, PDMAUDIOSTREAMCMD_ENABLE);
-        }
-    }
-    else
-    {
-        AssertReturnStmt(pSink->enmDir == PDMAUDIODIR_IN, RTCritSectLeave(&pSink->CritSect), VERR_INTERNAL_ERROR_3);
-        if (pSink->In.pStreamRecSource) /* Any recording source set? */
-        {
-            Assert(audioMixerSinkIsStreamInList(pSink, pSink->In.pStreamRecSource));
-            audioMixerStreamCtlInternal(pSink->In.pStreamRecSource, PDMAUDIOSTREAMCMD_ENABLE);
-        }
+    PAUDMIXSTREAM pStream;
+    RTListForEach(&pSink->lstStreams, pStream, AUDMIXSTREAM, Node)
+    {
+        audioMixerStreamCtlInternal(pStream, PDMAUDIOSTREAMCMD_ENABLE);
     }
 
@@ -826 +819 @@
     LogFunc(("Draining '%s' with %#x bytes left. Old status: %s\n",
              pSink->pszName, cbComming, dbgAudioMixerSinkStatusToStr(pSink->fStatus, szStatus) ));
+
+    AssertReturnStmt(pSink->enmDir == PDMAUDIODIR_IN || pSink->enmDir == PDMAUDIODIR_OUT,
+                     RTCritSectLeave(&pSink->CritSect), VERR_INTERNAL_ERROR_3);
 
     if (pSink->fStatus & AUDMIXSINK_STS_RUNNING)
@@ -878 +874 @@
         else
         {
-            AssertReturnStmt(pSink->enmDir == PDMAUDIODIR_IN, RTCritSectLeave(&pSink->CritSect), VERR_INTERNAL_ERROR_3);
-            if (pSink->In.pStreamRecSource) /* Any recording source set? */
+            PAUDMIXSTREAM pStream;
+            RTListForEach(&pSink->lstStreams, pStream, AUDMIXSTREAM, Node)
             {
-                Assert(audioMixerSinkIsStreamInList(pSink, pSink->In.pStreamRecSource));
-                audioMixerStreamCtlInternal(pSink->In.pStreamRecSource, PDMAUDIOSTREAMCMD_DISABLE);
+                audioMixerStreamCtlInternal(pStream, PDMAUDIOSTREAMCMD_DISABLE);
             }
             audioMixerSinkReset(pSink);
@@ -1062 +1057 @@
     if (pSink->fStatus & AUDMIXSINK_STS_RUNNING)
     {
-#ifdef VBOX_AUDIO_MIXER_WITH_MIXBUF_IN
-# error "Implement me!"
-#else
-        PAUDMIXSTREAM pStreamRecSource = pSink->In.pStreamRecSource;
-        if (   pStreamRecSource
-            && (pStreamRecSource->fStatus & AUDMIXSTREAM_STATUS_CAN_READ))
-        {
-            AssertPtr(pStreamRecSource->pConn);
-            cbReadable = pStreamRecSource->pConn->pfnStreamGetReadable(pStreamRecSource->pConn, pStreamRecSource->pStream);
-        }
-        else if (!pStreamRecSource)
-            Log3Func(("[%s] No recording source specified, skipping ...\n", pSink->pszName));
-        else
-            Log3Func(("[%s] The recording source is not readable!\n", pSink->pszName));
-#endif
+        uint32_t const cFrames = AudioMixBufLive(&pSink->MixBuf);
+        cbReadable = PDMAudioPropsFramesToBytes(&pSink->PCMProps, cFrames);
     }
 
@@ -1085 +1067 @@
 
     return cbReadable;
-}
-
-/**
- * Returns the sink's current recording source.
- *
- * @return  Mixer stream which currently is set as current recording source, NULL if none is set.
- * @param   pSink               Audio mixer sink to return current recording source for.
- */
-PAUDMIXSTREAM AudioMixerSinkGetRecordingSource(PAUDMIXSINK pSink)
-{
-    Assert(pSink->uMagic == AUDMIXSINK_MAGIC);
-    int rc = RTCritSectEnter(&pSink->CritSect);
-    AssertRCReturn(rc, NULL);
-
-    AssertMsg(pSink->enmDir == PDMAUDIODIR_IN, ("Specified sink is not an input sink\n"));
-
-    PAUDMIXSTREAM pStream = pSink->In.pStreamRecSource;
-
-    int rc2 = RTCritSectLeave(&pSink->CritSect);
-    AssertRC(rc2);
-
-    return pStream;
 }
 
@@ -1220 +1180 @@
 
 /**
- * Reads audio data from a mixer sink.
- *
- * @returns VBox status code.
- * @param   pSink               Mixer sink to read data from.
- * @param   pvBuf               Buffer where to store the read data.
- * @param   cbBuf               Buffer size (in bytes) where to store the data.
- * @param   pcbRead             Number of bytes read.
- */
-int AudioMixerSinkRead(PAUDMIXSINK pSink, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead)
-{
-    AssertPtrReturn(pSink, VERR_INVALID_POINTER);
-    Assert(pSink->uMagic == AUDMIXSINK_MAGIC);
-    AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
-    AssertReturn(cbBuf,    VERR_INVALID_PARAMETER);
-    AssertPtrReturn(pcbRead, VERR_INVALID_POINTER);
-
-    int rc = RTCritSectEnter(&pSink->CritSect);
-    AssertRCReturn(rc, rc);
-
-    AssertMsg(pSink->enmDir == PDMAUDIODIR_IN,
-              ("Can't read from a sink which is not an input sink\n"));
-
-    uint32_t cbRead = 0;
-
-    /* Flag indicating whether this sink is in a 'clean' state,
-     * e.g. there is no more data to read from. */
-    bool fClean = true;
-
-    PAUDMIXSTREAM pStreamRecSource = pSink->In.pStreamRecSource;
-    if (!pStreamRecSource)
-    {
-        Log3Func(("[%s] No recording source specified, skipping ...\n", pSink->pszName));
-    }
-    else if (!(pStreamRecSource->fStatus & AUDMIXSTREAM_STATUS_ENABLED)) /** @todo r=bird: AUDMIXSTREAM_STATUS_CAN_READ ?*/
-    {
-        Log3Func(("[%s] Stream '%s' disabled, skipping ...\n", pSink->pszName, pStreamRecSource->pszName));
-    }
-    else
-    {
-        uint32_t cbToRead = cbBuf;
-        while (cbToRead)
-        {
-            uint32_t cbReadStrm;
-            AssertPtr(pStreamRecSource->pConn);
-#ifdef VBOX_AUDIO_MIXER_WITH_MIXBUF_IN
-# error "Implement me!"
-#else
-            rc = pStreamRecSource->pConn->pfnStreamRead(pStreamRecSource->pConn, pStreamRecSource->pStream,
-                                                        (uint8_t *)pvBuf + cbRead, cbToRead, &cbReadStrm);
-#endif
-            if (RT_FAILURE(rc))
-                LogFunc(("[%s] Failed reading from stream '%s': %Rrc\n", pSink->pszName, pStreamRecSource->pszName, rc));
-
-            Log3Func(("[%s] Stream '%s': Read %RU32 bytes\n", pSink->pszName, pStreamRecSource->pszName, cbReadStrm));
-
-            if (   RT_FAILURE(rc)
-                || !cbReadStrm)
-                break;
-
-            AssertBreakStmt(cbReadStrm <= cbToRead, rc = VERR_BUFFER_OVERFLOW);
-            cbToRead -= cbReadStrm;
-            cbRead   += cbReadStrm;
-            Assert(cbRead <= cbBuf);
-        }
-
-        uint32_t cbReadable = pStreamRecSource->pConn->pfnStreamGetReadable(pStreamRecSource->pConn, pStreamRecSource->pStream);
-
-        /* Still some data available? Then sink is not clean (yet). */
-        if (cbReadable)
-            fClean = false;
-
-        if (RT_SUCCESS(rc))
-        {
-            if (fClean)
-                pSink->fStatus &= ~AUDMIXSINK_STS_DIRTY;
-
-            /* Update our last read time stamp. */
-            pSink->tsLastReadWrittenNs = RTTimeNanoTS();
-
-            if (pSink->pParent->fFlags & AUDMIXER_FLAGS_DEBUG)
-            {
-                int rc2 = AudioHlpFileWrite(pSink->Dbg.pFile, pvBuf, cbRead, 0 /* fFlags */);
-                AssertRC(rc2);
-            }
-        }
-    }
-    *pcbRead = cbRead;
-
-#ifdef LOG_ENABLED
-    char szStatus[AUDIOMIXERSINK_STATUS_STR_MAX];
-#endif
-    Log2Func(("[%s] cbRead=%RU32, fClean=%RTbool, fStatus=%s, rc=%Rrc\n",
-              pSink->pszName, cbRead, fClean, dbgAudioMixerSinkStatusToStr(pSink->fStatus, szStatus), rc));
-
-    RTCritSectLeave(&pSink->CritSect);
-    return rc;
-}
-
-/**
  * Removes a mixer stream from a mixer sink, internal version.
  *
@@ -1328 +1189 @@
 {
     AssertPtrReturn(pSink, VERR_INVALID_PARAMETER);
-    if (   !pStream
-        || !pStream->pSink) /* Not part of a sink anymore? */
-    {
+    if (pStream)
+    { /* likely */ }
+    else
         return VERR_NOT_FOUND;
-    }
-
     AssertMsgReturn(pStream->pSink == pSink, ("Stream '%s' is not part of sink '%s'\n",
                                               pStream->pszName, pSink->pszName), VERR_NOT_FOUND);
@@ -1343 +1202 @@
     RTListNodeRemove(&pStream->Node);
 
-    int rc = VINF_SUCCESS;
-
-    if (pSink->enmDir == PDMAUDIODIR_IN)
-    {
-        /* Make sure to also un-set the recording source if this stream was set
-         * as the recording source before. */
-        if (pStream == pSink->In.pStreamRecSource)
-            rc = audioMixerSinkSetRecSourceInternal(pSink, NULL);
-    }
-
     /* Set sink to NULL so that we know we're not part of any sink anymore. */
     pStream->pSink = NULL;
 
-    return rc;
+    return VINF_SUCCESS;
 }
 
@@ -1470 +1319 @@
  *
  * @returns VBox status code.
- * @param   pSink       The sink to set audio format for.
- * @param   pPCMProps   Audio format (PCM properties) to set.
- */
-int AudioMixerSinkSetFormat(PAUDMIXSINK pSink, PCPDMAUDIOPCMPROPS pPCMProps)
-{
-    AssertPtrReturn(pSink,     VERR_INVALID_POINTER);
-    Assert(pSink->uMagic == AUDMIXSINK_MAGIC);
-    AssertPtrReturn(pPCMProps, VERR_INVALID_POINTER);
-    AssertReturn(AudioHlpPcmPropsAreValid(pPCMProps), VERR_INVALID_PARAMETER);
+ * @param   pSink   The sink to set audio format for.
+ * @param   pProps  The properties of the new audio format.
+ */
+int AudioMixerSinkSetFormat(PAUDMIXSINK pSink, PCPDMAUDIOPCMPROPS pProps)
+{
+    AssertPtrReturn(pSink, VERR_INVALID_POINTER);
+    AssertReturn(pSink->uMagic == AUDMIXSINK_MAGIC, VERR_INVALID_MAGIC);
+    AssertPtrReturn(pProps, VERR_INVALID_POINTER);
+    AssertReturn(AudioHlpPcmPropsAreValid(pProps), VERR_INVALID_PARAMETER);
 
     int rc = RTCritSectEnter(&pSink->CritSect);
-    if (RT_FAILURE(rc))
-        return rc;
-
-    if (PDMAudioPropsAreEqual(&pSink->PCMProps, pPCMProps)) /* Bail out early if PCM properties are equal. */
-    {
-        rc = RTCritSectLeave(&pSink->CritSect);
-        AssertRC(rc);
-
-        return rc;
-    }
-
-    if (pSink->PCMProps.uHz)
-        LogFlowFunc(("[%s] Old format: %u bit, %RU8 channels, %RU32Hz\n", pSink->pszName,
-                     PDMAudioPropsSampleBits(&pSink->PCMProps), PDMAudioPropsChannels(&pSink->PCMProps), pSink->PCMProps.uHz));
-
-    memcpy(&pSink->PCMProps, pPCMProps, sizeof(PDMAUDIOPCMPROPS));
-
-    LogFlowFunc(("[%s] New format %u bit, %RU8 channels, %RU32Hz\n", pSink->pszName, PDMAudioPropsSampleBits(&pSink->PCMProps),
-                 PDMAudioPropsChannels(&pSink->PCMProps), pSink->PCMProps.uHz));
-
-    /* Also update the sink's mixing buffer format. */
-    AudioMixBufDestroy(&pSink->MixBuf);
-    rc = AudioMixBufInit(&pSink->MixBuf, pSink->pszName, &pSink->PCMProps,
-                         PDMAudioPropsMilliToFrames(&pSink->PCMProps, 100 /*ms*/)); /** @todo Make this configurable? */
-    if (RT_SUCCESS(rc))
-    {
-        PAUDMIXSTREAM pStream;
-        RTListForEach(&pSink->lstStreams, pStream, AUDMIXSTREAM, Node)
-        {
-            /** @todo Invalidate mix buffers! */
-        }
-    }
-
-    if (   RT_SUCCESS(rc)
-        && (pSink->pParent->fFlags & AUDMIXER_FLAGS_DEBUG))
-    {
-        AudioHlpFileClose(pSink->Dbg.pFile);
-
-        char szName[64];
-        RTStrPrintf(szName, sizeof(szName), "MixerSink-%s", pSink->pszName);
-
-        char szFile[RTPATH_MAX];
-        int rc2 = AudioHlpFileNameGet(szFile, RT_ELEMENTS(szFile), NULL /* Use temporary directory */, szName,
-                                      0 /* Instance */, AUDIOHLPFILETYPE_WAV, AUDIOHLPFILENAME_FLAGS_NONE);
-        if (RT_SUCCESS(rc2))
-        {
-            rc2 = AudioHlpFileCreate(AUDIOHLPFILETYPE_WAV, szFile, AUDIOHLPFILE_FLAGS_NONE, &pSink->Dbg.pFile);
-            if (RT_SUCCESS(rc2))
-                rc2 = AudioHlpFileOpen(pSink->Dbg.pFile, AUDIOHLPFILE_DEFAULT_OPEN_FLAGS, &pSink->PCMProps);
-        }
-    }
-
-    int rc2 = RTCritSectLeave(&pSink->CritSect);
-    AssertRC(rc2);
-
-    LogFlowFuncLeaveRC(rc);
-    return rc;
-}
-
-/**
- * Set the current recording source of an input mixer sink, internal version.
- *
- * @returns VBox status code.
- * @param   pSink               Input mixer sink to set recording source for.
- * @param   pStream             Mixer stream to set as current recording source. Must be an input stream.
- *                              Specify NULL to un-set the current recording source.
- */
-static int audioMixerSinkSetRecSourceInternal(PAUDMIXSINK pSink, PAUDMIXSTREAM pStream)
-{
-    AssertMsg(pSink->enmDir == PDMAUDIODIR_IN, ("Specified sink is not an input sink\n"));
-
-    int rc;
+    AssertRCReturn(rc, rc);
 
     /*
-     * Warning: Do *not* use pfnConn->pfnEnable() for enabling/disabling streams here, as this will unconditionally (re-)enable
-     *          streams, which would violate / run against the (global) VM settings. See @bugref{9882}.
+     * Nothing to do here unless the format changed.
      */
-
-    /* Get pointers of current recording source to make code easier to read below. */
-    PAUDMIXSTREAM       pCurRecSrc       = pSink->In.pStreamRecSource; /* Can be NULL. */
-    PPDMIAUDIOCONNECTOR pCurRecSrcConn   = NULL;
-    PPDMAUDIOSTREAM     pCurRecSrcStream = NULL;
-
-    if (pCurRecSrc) /* First, disable old recording source, if any is set. */
-    {
-        pCurRecSrcConn   = pSink->In.pStreamRecSource->pConn;
-        AssertPtrReturn(pCurRecSrcConn, VERR_INVALID_POINTER);
-        pCurRecSrcStream = pCurRecSrc->pStream;
-        AssertPtrReturn(pCurRecSrcStream, VERR_INVALID_POINTER);
-
-        rc = pCurRecSrcConn->pfnStreamControl(pCurRecSrcConn, pCurRecSrcStream, PDMAUDIOSTREAMCMD_DISABLE);
-    }
-    else
-        rc = VINF_SUCCESS;
-
-    if (RT_SUCCESS(rc))
-    {
-        if (pStream)
-        {
-            AssertPtr(pStream->pStream);
-            AssertMsg(pStream->pStream->enmDir == PDMAUDIODIR_IN, ("Specified stream is not an input stream\n"));
-            AssertPtr(pStream->pConn);
-            rc = pStream->pConn->pfnStreamControl(pStream->pConn, pStream->pStream, PDMAUDIOSTREAMCMD_ENABLE);
+    if (!PDMAudioPropsAreEqual(&pSink->PCMProps, pProps))
+    {
+#ifdef LOG_ENABLED
+        char szTmp[PDMAUDIOPROPSTOSTRING_MAX];
+#endif
+        if (PDMAudioPropsHz(&pSink->PCMProps) != 0)
+            LogFlowFunc(("[%s] Old format: %s\n", pSink->pszName, PDMAudioPropsToString(&pSink->PCMProps, szTmp, sizeof(szTmp)) ));
+
+        pSink->PCMProps = *pProps;
+        LogFlowFunc(("[%s] New format: %s\n", pSink->pszName, PDMAudioPropsToString(&pSink->PCMProps, szTmp, sizeof(szTmp)) ));
+
+        /*
+         * Also update the sink's mixing buffer format.
+         */
+        AudioMixBufDestroy(&pSink->MixBuf);
+
+        /** @todo r=bird: Make sure we've got more room here than what's expected to
+         *        be moved in one guest DMA period. */
+        rc = AudioMixBufInit(&pSink->MixBuf, pSink->pszName, &pSink->PCMProps,
+                             PDMAudioPropsMilliToFrames(&pSink->PCMProps, 100 /*ms*/)); /** @todo Make this configurable? */
+        if (RT_SUCCESS(rc))
+        {
+            /*
+             * Input sinks must init their (mostly dummy) peek state.
+             */
+            if (pSink->enmDir == PDMAUDIODIR_IN)
+                rc = AudioMixBufInitPeekState(&pSink->MixBuf, &pSink->In.State, &pSink->PCMProps);
             if (RT_SUCCESS(rc))
             {
-                pCurRecSrc = pStream;
+                /*
+                 * Re-initialize the peek/write states as the frequency, channel count
+                 * and other things may have changed now.
+                 */
+                PAUDMIXSTREAM pMixStream;
+                if (pSink->enmDir == PDMAUDIODIR_IN)
+                {
+                    RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
+                    {
+                        int rc2 = AudioMixBufInitWriteState(&pSink->MixBuf, &pMixStream->WriteState, &pMixStream->pStream->Props);
+                        /** @todo remember this. */
+                        AssertLogRelRC(rc2);
+                    }
+                }
+                else
+                {
+                    RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
+                    {
+                        int rc2 = AudioMixBufInitPeekState(&pSink->MixBuf, &pMixStream->PeekState, &pMixStream->pStream->Props);
+                        /** @todo remember this. */
+                        AssertLogRelRC(rc2);
+                    }
+                }
+
+                /*
+                 * Debug.
+                 */
+                if (!(pSink->pParent->fFlags & AUDMIXER_FLAGS_DEBUG))
+                { /* likely */ }
+                else
+                {
+                    AudioHlpFileClose(pSink->Dbg.pFile);
+
+                    char szName[64];
+                    RTStrPrintf(szName, sizeof(szName), "MixerSink-%s", pSink->pszName);
+                    AudioHlpFileCreateAndOpen(&pSink->Dbg.pFile, NULL /*pszDir - use temp dir*/, szName,
+                                              0 /*iInstance*/, &pSink->PCMProps);
+                }
             }
-            else if (pCurRecSrc) /* Stay with the current recording source (if any) and re-enable it. */
-            {
-                rc = pCurRecSrcConn->pfnStreamControl(pCurRecSrcConn, pCurRecSrcStream, PDMAUDIOSTREAMCMD_ENABLE);
-            }
+            else
+                LogFunc(("AudioMixBufInitPeekState failed: %Rrc\n", rc));
         }
         else
-            pCurRecSrc = NULL; /* Unsetting, see audioMixerSinkRemoveStreamInternal. */
-    }
-
-    /* Invalidate pointers. */
-    pSink->In.pStreamRecSource = pCurRecSrc;
-
-    LogFunc(("[%s] Recording source is now '%s', rc=%Rrc\n",
-             pSink->pszName, pSink->In.pStreamRecSource ? pSink->In.pStreamRecSource->pszName : "<None>", rc));
-
-    if (RT_SUCCESS(rc))
-        LogRel(("Audio Mixer: Setting recording source of sink '%s' to '%s'\n",
-                pSink->pszName, pSink->In.pStreamRecSource ? pSink->In.pStreamRecSource->pszName : "<None>"));
-    else if (rc != VERR_AUDIO_STREAM_NOT_READY)
-        LogRel(("Audio Mixer: Setting recording source of sink '%s' to '%s' failed with %Rrc\n",
-                pSink->pszName, pSink->In.pStreamRecSource ? pSink->In.pStreamRecSource->pszName : "<None>", rc));
-
-    return rc;
-}
-
-/**
- * Set the current recording source of an input mixer sink.
- *
- * @returns VBox status code.
- * @param   pSink               Input mixer sink to set recording source for.
- * @param   pStream             Mixer stream to set as current recording source. Must be an input stream.
- *                              Set to NULL to un-set the current recording source.
- */
-int AudioMixerSinkSetRecordingSource(PAUDMIXSINK pSink, PAUDMIXSTREAM pStream)
-{
-    AssertPtrReturn(pSink, VERR_INVALID_POINTER);
-    Assert(pSink->uMagic == AUDMIXSINK_MAGIC);
-    if (pStream)
-        Assert(pStream->uMagic == AUDMIXSTREAM_MAGIC);
-
-    int rc = RTCritSectEnter(&pSink->CritSect);
-    AssertRCReturn(rc, rc);
-
-    rc = audioMixerSinkSetRecSourceInternal(pSink, pStream);
-
-    int rc2 = RTCritSectLeave(&pSink->CritSect);
-    AssertRC(rc2);
-
+            LogFunc(("AudioMixBufInit failed: %Rrc\n", rc));
+    }
+
+    RTCritSectLeave(&pSink->CritSect);
+    LogFlowFuncLeaveRC(rc);
     return rc;
 }
@@ -1669 +1445 @@
 }
 
-/**
- * Updates an input mixer sink.
- *
- * @returns VBox status code.
- * @param   pSink               Mixer sink to update.
- */
-static int audioMixerSinkUpdateInput(PAUDMIXSINK pSink)
-{
-    /*
-     * Warning!  We currently do _not_ use the mixing buffer for input streams!
-     * Warning!  We currently do _not_ use the mixing buffer for input streams!
-     * Warning!  We currently do _not_ use the mixing buffer for input streams!
-     */
-
-    /*
-     * Skip input sinks without a recoring source.
-     */
-    if (pSink->In.pStreamRecSource == NULL)
-        return VINF_SUCCESS;
-
-    /*
-     * Update each mixing sink stream's status.
-     */
+
+/**
+ * Helper for audioMixerSinkUpdateInput that determins now many frames it can
+ * transfer from the drivers and into the sink's mixer buffer.
+ *
+ * This also updates the mixer stream status, which may involve stream re-inits.
+ *
+ * @returns Number of frames.
+ * @param   pSink               The sink.
+ * @param   pcReadableStreams   Where to return the number of readable streams.
+ */
+static uint32_t audioMixerSinkUpdateInputCalcFramesToTransfer(PAUDMIXSINK pSink, uint32_t *pcReadableStreams)
+{
+    uint32_t      cFramesToRead    = AudioMixBufFree(&pSink->MixBuf);
+    uint32_t      cReadableStreams = 0;
     PAUDMIXSTREAM pMixStream;
     RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
@@ -1697 +1465 @@
         int rc2 = audioMixerStreamUpdateStatus(pMixStream);
         AssertRC(rc2);
-    }
+
+        if (pMixStream->fStatus & AUDMIXSTREAM_STATUS_CAN_READ)
+        {
+            PPDMIAUDIOCONNECTOR const pIConnector = pMixStream->pConn;
+            PPDMAUDIOSTREAM const     pStream     = pMixStream->pStream;
+            uint32_t                  cIgnored    = 0;
+            pIConnector->pfnStreamCapture(pIConnector, pStream, &cIgnored);
+            pIConnector->pfnStreamIterate(pIConnector, pStream);
+
+            uint32_t const cbReadable = pIConnector->pfnStreamGetReadable(pIConnector, pStream);
+            uint32_t cFrames = PDMAudioPropsBytesToFrames(&pStream->Props, cbReadable);
+            pMixStream->cFramesLastAvail = cFrames;
+            if (PDMAudioPropsHz(&pStream->Props) == PDMAudioPropsHz(&pSink->MixBuf.Props))
+            { /* likely */ }
+            else
+            {
+                cFrames = cFrames * PDMAudioPropsHz(&pSink->MixBuf.Props) / PDMAudioPropsHz(&pStream->Props);
+                cFrames = cFrames > 2 ? cFrames - 2 : 0; /* rounding safety fudge */
+            }
+            if (cFramesToRead > cFrames && !pMixStream->fUnreliable)
+            {
+                Log4Func(("%s: cFramesToRead %u -> %u; %s (%u bytes writable)\n",
+                          pSink->pszName, cFramesToRead, cFrames, pMixStream->pszName, cbReadable));
+                cFramesToRead = cFrames;
+            }
+            cReadableStreams++;
+        }
+    }
+
+    *pcReadableStreams = cReadableStreams;
+    return cFramesToRead;
+}
+
+
+/**
+ * Updates an input mixer sink.
+ *
+ * @returns VBox status code.
+ * @param   pSink       Mixer sink to update.
+ * @param   cbDmaBuf    The number of bytes in the DMA buffer.  For detecting
+ *                      underruns.  Zero if we don't know.
+ * @param   cbDmaPeriod The minimum number of bytes required for reliable DMA
+ *                      operation.  Zero if we don't know.
+ */
+static int audioMixerSinkUpdateInput(PAUDMIXSINK pSink, uint32_t cbDmaBuf, uint32_t cbDmaPeriod)
+{
+    PAUDMIXSTREAM pMixStream;
+    Assert(!(pSink->fStatus & AUDMIXSINK_STS_DRAINED_MIXBUF)); /* (can't drain input sink) */
 
     /*
-     * Iterate and do capture on the recording source.  We ignore all other streams.
+     * Iterate, update status and check each mixing sink stream for how much
+     * we can transfer.
+     *
+     * We're currently using the minimum size of all streams, however this
+     * isn't a smart approach as it means one disfunctional stream can block
+     * working ones.  So, if we end up with zero frames and a full mixer
+     * buffer we'll disregard the stream that accept the smallest amount and
+     * try again.
      */
-    int rc = VINF_SUCCESS; /* not sure if error propagation is worth it... */
-#if 1
-    pMixStream = pSink->In.pStreamRecSource;
-#else
-    RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
-#endif
-    {
-        if (pMixStream->fStatus & AUDMIXSTREAM_STATUS_ENABLED)
-        {
-            uint32_t cFramesCaptured = 0;
-            int rc2 = pMixStream->pConn->pfnStreamIterate(pMixStream->pConn, pMixStream->pStream);
-            if (RT_SUCCESS(rc2))
+    uint32_t cReadableStreams  = 0;
+    uint32_t cFramesToXfer     = audioMixerSinkUpdateInputCalcFramesToTransfer(pSink, &cReadableStreams);
+    if (   cFramesToXfer != 0
+        || cReadableStreams <= 1
+        || cbDmaPeriod == 0 /* Insufficient info to decide. The update function will call us again, at least for HDA. */
+        || cbDmaBuf + PDMAudioPropsFramesToBytes(&pSink->PCMProps, AudioMixBufUsed(&pSink->MixBuf)) >= cbDmaPeriod)
+        Log3Func(("%s: cFreeFrames=%#x cFramesToXfer=%#x cReadableStreams=%#x\n", pSink->pszName,
+                  AudioMixBufFree(&pSink->MixBuf), cFramesToXfer, cReadableStreams));
+    else
+    {
+        Log3Func(("%s: MixBuf is underrunning but one or more streams only provides zero frames.  Try disregarding those...\n", pSink->pszName));
+        uint32_t        cReliableStreams  = 0;
+        uint32_t        cMarkedUnreliable = 0;
+        PAUDMIXSTREAM   pMixStreamMin     = NULL;
+        RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
+        {
+            if (pMixStream->fStatus & AUDMIXSTREAM_STATUS_CAN_READ)
             {
-                /** @todo r=bird: Check for AUDMIXSTREAM_STATUS_CAN_READ? */
-                rc2 = pMixStream->pConn->pfnStreamCapture(pMixStream->pConn, pMixStream->pStream, &cFramesCaptured);
-                if (RT_SUCCESS(rc2))
+                if (!pMixStream->fUnreliable)
                 {
-                    if (cFramesCaptured)
-                        pSink->fStatus |= AUDMIXSINK_STS_DIRTY;
-                }
-                else
-                {
-                    LogFunc(("%s: Failed capturing stream '%s', rc=%Rrc\n", pSink->pszName, pMixStream->pStream->szName, rc2));
-                    if (RT_SUCCESS(rc))
-                        rc = rc2;
+                    if (pMixStream->cFramesLastAvail == 0)
+                    {
+                        cMarkedUnreliable++;
+                        pMixStream->fUnreliable = true;
+                        Log3Func(("%s: Marked '%s' as unreliable.\n", pSink->pszName, pMixStream->pszName));
+                        pMixStreamMin = pMixStream;
+                    }
+                    else
+                    {
+                        if (!pMixStreamMin || pMixStream->cFramesLastAvail < pMixStreamMin->cFramesLastAvail)
+                            pMixStreamMin = pMixStream;
+                        cReliableStreams++;
+                    }
                 }
             }
-            else if (RT_SUCCESS(rc))
-                rc = rc2;
-            Log3Func(("%s: cFramesCaptured=%RU32 (rc2=%Rrc)\n", pMixStream->pStream->szName, cFramesCaptured, rc2));
-        }
+        }
+
+        if (cMarkedUnreliable == 0 && cReliableStreams > 1 && pMixStreamMin != NULL)
+        {
+            cReliableStreams--;
+            cMarkedUnreliable++;
+            pMixStreamMin->fUnreliable = true;
+            Log3Func(("%s: Marked '%s' as unreliable (%u frames).\n",
+                      pSink->pszName, pMixStreamMin->pszName, pMixStreamMin->cFramesLastAvail));
+        }
+
+        if (cMarkedUnreliable > 0)
+        {
+            cReadableStreams = 0;
+            cFramesToXfer = audioMixerSinkUpdateInputCalcFramesToTransfer(pSink, &cReadableStreams);
+        }
+
+        Log3Func(("%s: cFreeFrames=%#x cFramesToXfer=%#x cReadableStreams=%#x cMarkedUnreliable=%#x cReliableStreams=%#x\n",
+                  pSink->pszName, AudioMixBufFree(&pSink->MixBuf), cFramesToXfer,
+                  cReadableStreams, cMarkedUnreliable, cReliableStreams));
+    }
+
+    if (cReadableStreams > 0)
+    {
+        if (cFramesToXfer > 0)
+        {
+/*#define ELECTRIC_INPUT_BUFFER*/ /* if buffer code is misbehaving, enable this to catch overflows. */
+#ifndef ELECTRIC_INPUT_BUFFER
+            union
+            {
+                uint8_t  ab[8192];
+                uint64_t au64[8192 / sizeof(uint64_t)]; /* Use uint64_t to ensure good alignment. */
+            } Buf;
+            void * const   pvBuf = &Buf;
+            uint32_t const cbBuf = sizeof(Buf);
+#else
+            uint32_t const cbBuf = 0x2000 - 16;
+            void * const   pvBuf = RTMemEfAlloc(cbBuf, RTMEM_TAG, RT_SRC_POS);
+#endif
+
+            /*
+             * For each of the enabled streams, read cFramesToXfer frames worth
+             * of samples from them and merge that into the mixing buffer.
+             */
+            bool fAssign = true;
+            RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
+            {
+                if (pMixStream->fStatus & AUDMIXSTREAM_STATUS_CAN_READ)
+                {
+                    PPDMIAUDIOCONNECTOR const pIConnector = pMixStream->pConn;
+                    PPDMAUDIOSTREAM const     pStream     = pMixStream->pStream;
+
+                    /* Calculate how many bytes we should read from this stream. */
+                    bool const     fResampleSrc = PDMAudioPropsHz(&pStream->Props) != PDMAudioPropsHz(&pSink->MixBuf.Props);
+                    uint32_t const cbSrcToXfer  = !fResampleSrc
+                                                ? PDMAudioPropsFramesToBytes(&pStream->Props, cFramesToXfer)
+                                                : PDMAudioPropsFramesToBytes(&pStream->Props, /** @todo check rounding errors here... */
+                                                                             cFramesToXfer * PDMAudioPropsHz(&pSink->MixBuf.Props)
+                                                                             / PDMAudioPropsHz(&pStream->Props));
+
+                    /* Do the reading. */
+                    uint32_t offSrc      = 0;
+                    uint32_t offDstFrame = 0;
+                    do
+                    {
+                        /*
+                         * Read a chunk from the backend.
+                         */
+                        uint32_t const cbSrcToRead = RT_MIN(cbBuf, cbSrcToXfer - offSrc);
+                        uint32_t       cbSrcRead   = 0;
+                        if (cbSrcToRead > 0)
+                        {
+                            int rc2 = pIConnector->pfnStreamRead(pIConnector, pStream, pvBuf, cbSrcToRead, &cbSrcRead);
+                            Log3Func(("%s: %#x L %#x => %#x bytes; rc2=%Rrc %s\n",
+                                      pSink->pszName, offSrc, cbSrcToRead, cbSrcRead, rc2, pMixStream->pszName));
+
+                            if (RT_SUCCESS(rc2))
+                                AssertLogRelMsg(cbSrcRead == cbSrcToRead || pMixStream->fUnreliable,
+                                                ("cbSrcRead=%#x cbSrcToRead=%#x - (sink '%s')\n",
+                                                 cbSrcRead, cbSrcToRead, pSink->pszName));
+                            else if (rc2 == VERR_AUDIO_STREAM_NOT_READY)
+                            {
+                                LogRel2(("Audio Mixer: '%s' (sink '%s'): Stream not ready - skipping.\n",
+                                         pMixStream->pszName, pSink->pszName)); /* must've changed status, stop processing */
+                                break;
+                            }
+                            else
+                            {
+                                Assert(rc2 != VERR_BUFFER_OVERFLOW);
+                                LogRel2(("Audio Mixer: Reading from mixer stream '%s' (sink '%s') failed, rc=%Rrc\n",
+                                         pMixStream->pszName, pSink->pszName, rc2));
+                                break;
+                            }
+                            offSrc += cbSrcRead;
+                        }
+                        else
+                            Assert(fResampleSrc); /** @todo test this case */
+
+                        /*
+                         * Assign or blend it into the mixer buffer.
+                         */
+                        uint32_t cFramesDstTransferred = 0;
+                        if (fAssign)
+                        {
+                            /** @todo could complicate this by detecting silence here too and stay in
+                             *        assign mode till we get a stream with non-silence... */
+                            AudioMixBufWrite(&pSink->MixBuf, &pMixStream->WriteState, pvBuf, cbSrcRead,
+                                             offDstFrame, cFramesToXfer - offDstFrame, &cFramesDstTransferred);
+                        }
+                        /* We don't need to blend silence buffers.  For simplicity, always blend
+                           when we're resampling (for rounding). */
+                        else if (fResampleSrc || !PDMAudioPropsIsBufferSilence(&pStream->Props, pvBuf, cbSrcRead))
+                        {
+                            AudioMixBufBlend(&pSink->MixBuf, &pMixStream->WriteState, pvBuf, cbSrcRead,
+                                             offDstFrame, cFramesToXfer - offDstFrame, &cFramesDstTransferred);
+                        }
+                        else
+                        {
+                            cFramesDstTransferred = PDMAudioPropsBytesToFrames(&pStream->Props, cbSrcRead);
+                            AudioMixBufBlendGap(&pSink->MixBuf, &pMixStream->WriteState, cFramesDstTransferred);
+                        }
+                        AssertBreak(cFramesDstTransferred > 0);
+
+                        /* Advance. */
+                        offDstFrame += cFramesDstTransferred;
+                    } while (offDstFrame < cFramesToXfer);
+
+                    /*
+                     * In case the first stream is misbehaving, make sure we written the entire area.
+                     */
+                    if (offDstFrame >= cFramesToXfer)
+                    { /* likely */ }
+                    else if (fAssign)
+                        AudioMixBufSilence(&pSink->MixBuf, &pMixStream->WriteState, offDstFrame, cFramesToXfer - offDstFrame);
+                    else
+                        AudioMixBufBlendGap(&pSink->MixBuf, &pMixStream->WriteState, cFramesToXfer - offDstFrame);
+                    fAssign = false;
+                }
+            }
+
+            /*
+             * Commit the buffer area we've written and blended into.
+             */
+            AudioMixBufCommit(&pSink->MixBuf, cFramesToXfer);
+
+#ifdef ELECTRIC_INPUT_BUFFER
+            RTMemEfFree(pvBuf, RT_SRC_POS);
+#endif
+        }
+
+        /*
+         * Set the dirty flag for what it's worth.
+         */
+        pSink->fStatus |= AUDMIXSINK_STS_DIRTY;
+    }
+    else
+    {
+        /*
+         * No readable stream. Clear the dirty flag if empty (pointless flag).
+         */
+        if (!AudioMixBufUsed(&pSink->MixBuf))
+            pSink->fStatus &= ~AUDMIXSINK_STS_DIRTY;
     }
 
@@ -1738 +1726 @@
     pSink->tsLastUpdatedMs = RTTimeMilliTS();
 
-    Assert(!(pSink->fStatus & AUDMIXSINK_STS_DRAINING));
-    return rc;
+    return VINF_SUCCESS;
 }
 
@@ -1816 +1803 @@
      * try again.
      */
-    uint32_t cReliableStreams  = 0;
-    uint32_t cMarkedUnreliable = 0;
     uint32_t cWritableStreams  = 0;
     uint32_t cFramesToRead     = audioMixerSinkUpdateOutputCalcFramesToRead(pSink, &cWritableStreams);
@@ -1828 +1813 @@
     {
         Log3Func(("%s: MixBuf is full but one or more streams only want zero frames.  Try disregarding those...\n", pSink->pszName));
-        PAUDMIXSTREAM pMixStreamMin     = NULL;
+        uint32_t        cReliableStreams  = 0;
+        uint32_t        cMarkedUnreliable = 0;
+        PAUDMIXSTREAM   pMixStreamMin     = NULL;
         RTListForEach(&pSink->lstStreams, pMixStream, AUDMIXSTREAM, Node)
         {
@@ -2037 +2024 @@
  *
  * @returns VBox status code.
- * @param   pSink               Mixer sink to update.
- */
-int AudioMixerSinkUpdate(PAUDMIXSINK pSink)
+ * @param   pSink           Mixer sink to update.
+ * @param   cbDmaUsed       The DMA buffer fill for input stream, ignored for
+ *                          output sinks.
+ * @param   cbDmaPeriod     The DMA period in bytes for input stream, ignored
+ *                          for output sinks.
+ */
+int AudioMixerSinkUpdate(PAUDMIXSINK pSink, uint32_t cbDmaUsed, uint32_t cbDmaPeriod)
 {
     AssertPtrReturn(pSink, VERR_INVALID_POINTER);
@@ -2058 +2049 @@
             rc = audioMixerSinkUpdateOutput(pSink);
         else if (pSink->enmDir == PDMAUDIODIR_IN)
-            rc = audioMixerSinkUpdateInput(pSink);
+            rc = audioMixerSinkUpdateInput(pSink, cbDmaUsed, cbDmaPeriod);
         else
-            AssertFailed();
+            AssertFailedStmt(rc = VERR_INTERNAL_ERROR_3);
     }
     else
@@ -2095 +2086 @@
              */
             if (pSink->enmDir == PDMAUDIODIR_IN)
-                audioMixerSinkUpdateInput(pSink);
+                audioMixerSinkUpdateInput(pSink, 0 /*cbDmaUsed*/, 0 /*cbDmaPeriod*/);
 
             /*
@@ -2400 +2391 @@
     const uint32_t cbCircBufWritable = (uint32_t)RTCircBufFree(pCircBuf);
     uint32_t       cbToTransfer      = RT_MIN(cbCircBufWritable, cbSinkReadable);
-
-    /* Make sure that we always align the number of bytes when reading to the stream's PCM properties. */
-    cbToTransfer = PDMAudioPropsFloorBytesToFrame(&pSink->PCMProps, cbToTransfer);
-
-    Log3Func(("idStream=%u: cbSinkReadable=%#RX32 cbCircBufWritable=%#RX32 -> cbToTransfer=%#RX32 @%#RX64\n",
-              idStream, cbSinkReadable, cbCircBufWritable, cbToTransfer, offStream));
+    uint32_t       cFramesToTransfer = PDMAudioPropsBytesToFrames(&pSink->PCMProps, cbToTransfer);
+    cbToTransfer = PDMAudioPropsFramesToBytes(&pSink->PCMProps, cFramesToTransfer);
+
+    Log3Func(("idStream=%u: cbSinkReadable=%#RX32 cbCircBufWritable=%#RX32 -> cbToTransfer=%#RX32 (%RU32 frames) @%#RX64\n",
+              idStream, cbSinkReadable, cbCircBufWritable, cbToTransfer, cFramesToTransfer, offStream));
     RT_NOREF(idStream);
 
@@ -2421 +2411 @@
         uint8_t  abBuf[4096];
         uint32_t cbRead = 0;
-        int rc = AudioMixerSinkRead(pSink, abBuf, RT_MIN(cbToTransfer, sizeof(abBuf)), &cbRead);
-        AssertRCBreak(rc);
-        AssertMsgBreak(cbRead > 0, ("Nothing read from sink, even if %#RX32 bytes were (still) announced\n", cbToTransfer));
+        uint32_t cFramesRead = 0;
+        AudioMixBufPeek(&pSink->MixBuf, 0, cFramesToTransfer, &cFramesRead,
+                        &pSink->In.State, abBuf, RT_MIN(cbToTransfer, sizeof(abBuf)), &cbRead);
+        AssertBreak(cFramesRead > 0);
+        Assert(cbRead > 0);
+
+        cFramesToTransfer -= cFramesRead;
+        AudioMixBufAdvance(&pSink->MixBuf, cFramesRead);
 
         /* Write it to the internal DMA buffer. */
@@ -2592 +2587 @@
 
     uint32_t cbWritten = 0;
-    uint32_t cbToWrite = RT_MIN(AudioMixBufFreeBytes(&pSink->MixBuf), cbBuf);
-    while (cbToWrite)
+    uint32_t cbToWrite = AudioMixBufFreeBytes(&pSink->MixBuf);
+    cbToWrite = RT_MIN(cbToWrite, cbBuf);
+    while (cbToWrite > 0)
     {
         /* Write the data to the mixer sink's own mixing buffer.
@@ -2690 +2686 @@
                 rc = AudioMixBufInitPeekState(&pSink->MixBuf, &pMixStream->PeekState, &pStream->Props);
                 /** @todo we need to remember this, don't we? */
-                AssertRCReturn(rc, VINF_SUCCESS);
+                AssertLogRelRCReturn(rc, VINF_SUCCESS);
+            }
+            else
+            {
+                rc = AudioMixBufInitWriteState(&pSink->MixBuf, &pMixStream->WriteState, &pStream->Props);
+                /** @todo we need to remember this, don't we? */
+                AssertLogRelRCReturn(rc, VINF_SUCCESS);
             }
         }

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

@@ -106 +106 @@
     /** Pointer to PDM audio stream this mixer stream handles. */
     PPDMAUDIOSTREAM         pStream;
-    /** Mixing buffer peeking state & config. */
-    AUDIOMIXBUFPEEKSTATE    PeekState;
+    union
+    {
+        /** Output: Mixing buffer peeking state & config. */
+        AUDIOMIXBUFPEEKSTATE    PeekState;
+        /** Input:  Mixing buffer writing state & config. */
+        AUDIOMIXBUFWRITESTATE   WriteState;
+    };
     /** Last read (recording) / written (playback) timestamp (in ns). */
     uint64_t                tsLastReadWrittenNs;
@@ -196 +201 @@
         struct
         {
-            /** The current recording source. Can be NULL if not set. */
-            PAUDMIXSTREAM  pStreamRecSource;
+            /** The sink's peek state. */
+            AUDIOMIXBUFPEEKSTATE    State;
         } In;
-        /*struct
-        {
-        } Out; */
     };
     struct
@@ -300 +302 @@
 uint32_t AudioMixerSinkGetWritable(PAUDMIXSINK pSink);
 PDMAUDIODIR   AudioMixerSinkGetDir(PAUDMIXSINK pSink);
-PAUDMIXSTREAM AudioMixerSinkGetRecordingSource(PAUDMIXSINK pSink);
 uint32_t AudioMixerSinkGetStatus(PAUDMIXSINK pSink);
 bool AudioMixerSinkIsActive(PAUDMIXSINK pSink);
-int AudioMixerSinkRead(PAUDMIXSINK pSink, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead);
 void AudioMixerSinkRemoveStream(PAUDMIXSINK pSink, PAUDMIXSTREAM pStream);
 void AudioMixerSinkRemoveAllStreams(PAUDMIXSINK pSink);
 void AudioMixerSinkReset(PAUDMIXSINK pSink);
 int AudioMixerSinkSetFormat(PAUDMIXSINK pSink, PCPDMAUDIOPCMPROPS pPCMProps);
-int AudioMixerSinkSetRecordingSource(PAUDMIXSINK pSink, PAUDMIXSTREAM pStream);
 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 AudioMixerSinkUpdate(PAUDMIXSINK pSink, uint32_t cbDmaUsed, uint32_t cbDmaPeriod);
 
 int         AudioMixerSinkAddUpdateJob(PAUDMIXSINK pSink, PFNAUDMIXSINKUPDATE pfnUpdate, void *pvUser, uint32_t cMsTypicalInterval);

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

@@ -2211 +2211 @@
     if (pDrv->LineIn.pMixStrm)
     {
-        if (AudioMixerSinkGetRecordingSource(pThisCC->SinkLineIn.pMixSink) == pDrv->LineIn.pMixStrm)
-            AudioMixerSinkSetRecordingSource(pThisCC->SinkLineIn.pMixSink, NULL);
-
         AudioMixerSinkRemoveStream(pThisCC->SinkLineIn.pMixSink, pDrv->LineIn.pMixStrm);
         AudioMixerStreamDestroy(pDrv->LineIn.pMixStrm, pDevIns, true /*fImmediate*/);
@@ -2222 +2219 @@
     if (pDrv->MicIn.pMixStrm)
     {
-        if (AudioMixerSinkGetRecordingSource(pThisCC->SinkMicIn.pMixSink) == pDrv->MicIn.pMixStrm)
-            AudioMixerSinkSetRecordingSource(&pThisCC->SinkMicIn.pMixSink, NULL);
-
         AudioMixerSinkRemoveStream(pThisCC->SinkMicIn.pMixSink, pDrv->MicIn.pMixStrm);
         AudioMixerStreamDestroy(pDrv->MicIn.pMixStrm, pDevIns, true /*fImmediate*/);
@@ -2335 +2329 @@
         rc = AudioMixerSinkAddStream(pMixSink, pMixStrm);
         LogFlowFunc(("LUN#%RU8: Added stream \"%s\" to sink, rc=%Rrc\n", pDrv->uLUN, StreamCfg.szName, rc));
-        if (RT_SUCCESS(rc))
-        {
-            /* If this is an input stream, always set the latest (added) stream
-             * as the recording source. */
-            /** @todo Make the recording source dynamic (CFGM?). */
-            if (StreamCfg.enmDir == PDMAUDIODIR_IN)
-            {
-                PDMAUDIOBACKENDCFG Cfg;
-                rc = pDrv->pConnector->pfnGetConfig(pDrv->pConnector, &Cfg);
-                if (RT_SUCCESS(rc))
-                {
-                    if (Cfg.cMaxStreamsIn) /* At least one input source available? */
-                    {
-                        rc = AudioMixerSinkSetRecordingSource(pMixSink, pMixStrm);
-                        LogFlowFunc(("LUN#%RU8: Recording source for '%s' -> '%s', rc=%Rrc\n",
-                                     pDrv->uLUN, StreamCfg.szName, Cfg.szName, rc));
-
-                        if (RT_SUCCESS(rc))
-                            LogRel(("HDA: Set recording source for '%s' to '%s'\n",
-                                    StreamCfg.szName, Cfg.szName));
-                    }
-                    else
-                        LogRel(("HDA: Backend '%s' currently is not offering any recording source for '%s'\n",
-                                Cfg.szName, StreamCfg.szName));
-                }
-                else if (RT_FAILURE(rc))
-                    LogFunc(("LUN#%RU8: Unable to retrieve backend configuration for '%s', rc=%Rrc\n",
-                             pDrv->uLUN, StreamCfg.szName, rc));
-            }
-            if (RT_FAILURE(rc))
-                AudioMixerSinkRemoveStream(pMixSink, pMixStrm);
-        }
         if (RT_FAILURE(rc))
             AudioMixerStreamDestroy(pMixStrm, pDevIns, true /*fImmediate*/);
@@ -4518 +4480 @@
 static void hdaR3DetachInternal(PPDMDEVINS pDevIns, PHDASTATER3 pThisCC, PHDADRIVER pDrv)
 {
-    /* First, remove the driver from our list and destory it's associated streams.
-     * This also will un-set the driver as a recording source (if associated). */
+    /* Remove the driver from our list and destory it's associated streams.
+       This also will un-set the driver as a recording source (if associated). */
     hdaR3MixerRemoveDrv(pDevIns, pThisCC, pDrv);
-
-    /* Next, search backwards for a capable (attached) driver which now will be the
-     * new recording source. */
-/** @todo r=bird: This looks completely wrong.  What if the detatched devices wasn't the recording source
- * and we pick a different one here?  I also don't get why we need to do this in revese order, given that
- * the primary device is first.  I guess this code isn't really tested. */
-    PHDADRIVER pDrvCur;
-    RTListForEachReverse(&pThisCC->lstDrv, pDrvCur, HDADRIVER, Node)
-    {
-        if (!pDrvCur->pConnector)
-            continue;
-
-        PDMAUDIOBACKENDCFG Cfg;
-        int rc2 = pDrvCur->pConnector->pfnGetConfig(pDrvCur->pConnector, &Cfg);
-        if (RT_FAILURE(rc2))
-            continue;
-
-        PHDADRIVERSTREAM pDrvStrm;
-# ifdef VBOX_WITH_AUDIO_HDA_MIC_IN
-        pDrvStrm = &pDrvCur->MicIn;
-        if (   pDrvStrm
-            && pDrvStrm->pMixStrm)
-        {
-            rc2 = AudioMixerSinkSetRecordingSource(pThisCC->SinkMicIn.pMixSink, pDrvStrm->pMixStrm);
-            if (RT_SUCCESS(rc2))
-                LogRel2(("HDA: Set new recording source for 'Mic In' to '%s'\n", Cfg.szName));
-        }
-# endif
-        pDrvStrm = &pDrvCur->LineIn;
-        if (   pDrvStrm
-            && pDrvStrm->pMixStrm)
-        {
-            rc2 = AudioMixerSinkSetRecordingSource(pThisCC->SinkLineIn.pMixSink, pDrvStrm->pMixStrm);
-            if (RT_SUCCESS(rc2))
-                LogRel2(("HDA: Set new recording source for 'Line In' to '%s'\n", Cfg.szName));
-        }
-    }
-
     LogFunc(("LUN#%u detached\n", pDrv->uLUN));
 }

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

@@ -1949 +1949 @@
             {
                 hdaR3StreamPushToMixer(pStreamShared, pStreamR3, pSink, tsNowNs);
-                AudioMixerSinkUpdate(pSink);
+                AudioMixerSinkUpdate(pSink, 0, 0);
                 AudioMixerSinkUnlock(pSink);
             }
@@ -2088 +2088 @@
             if (RT_SUCCESS(rc))
             {
-                AudioMixerSinkUpdate(pSink);
+                AudioMixerSinkUpdate(pSink, cbStreamUsed, cbPeriod);
                 hdaR3StreamPullFromMixer(pStreamR3, pSink);
                 AudioMixerSinkUnlock(pSink);

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

@@ -1511 +1511 @@
             rc = AudioMixerSinkAddStream(pMixSink, pMixStrm);
             LogFlowFunc(("LUN#%RU8: Added stream \"%s\" to sink, rc=%Rrc\n", pDrv->uLUN, pStreamCfg->szName, rc));
-            if (RT_SUCCESS(rc))
-            {
-                /* If this is an input stream, always set the latest (added) stream
-                 * as the recording source. */
-                /** @todo Make the recording source dynamic (CFGM?). */
-                if (pStreamCfg->enmDir == PDMAUDIODIR_IN)
-                {
-                    PDMAUDIOBACKENDCFG Cfg;
-                    rc = pDrv->pConnector->pfnGetConfig(pDrv->pConnector, &Cfg);
-                    if (RT_SUCCESS(rc))
-                    {
-                        if (Cfg.cMaxStreamsIn) /* At least one input source available? */
-                        {
-                            rc = AudioMixerSinkSetRecordingSource(pMixSink, pMixStrm);
-                            LogFlowFunc(("LUN#%RU8: Recording source for '%s' -> '%s', rc=%Rrc\n",
-                                         pDrv->uLUN, pStreamCfg->szName, Cfg.szName, rc));
-
-                            if (RT_SUCCESS(rc))
-                                LogRel2(("AC97: Set recording source for '%s' to '%s'\n", pStreamCfg->szName, Cfg.szName));
-                        }
-                        else
-                            LogRel(("AC97: Backend '%s' currently is not offering any recording source for '%s'\n",
-                                    Cfg.szName, pStreamCfg->szName));
-                    }
-                    else if (RT_FAILURE(rc))
-                        LogFunc(("LUN#%RU8: Unable to retrieve backend configuratio for '%s', rc=%Rrc\n",
-                                 pDrv->uLUN, pStreamCfg->szName, rc));
-                }
-                if (RT_FAILURE(rc))
-                    AudioMixerSinkRemoveStream(pMixSink, pMixStrm);
-            }
             if (RT_FAILURE(rc))
                 AudioMixerStreamDestroy(pMixStrm, pDevIns, true /*fImmediate*/);
@@ -1640 +1609 @@
     if (pDrv->MicIn.pMixStrm)
     {
-        if (AudioMixerSinkGetRecordingSource(pThisCC->pSinkMicIn) == pDrv->MicIn.pMixStrm)
-            AudioMixerSinkSetRecordingSource(pThisCC->pSinkMicIn, NULL);
-
         AudioMixerSinkRemoveStream(pThisCC->pSinkMicIn,  pDrv->MicIn.pMixStrm);
         AudioMixerStreamDestroy(pDrv->MicIn.pMixStrm, pDevIns, true /*fImmediate*/);
@@ -1650 +1616 @@
     if (pDrv->LineIn.pMixStrm)
     {
-        if (AudioMixerSinkGetRecordingSource(pThisCC->pSinkLineIn) == pDrv->LineIn.pMixStrm)
-            AudioMixerSinkSetRecordingSource(pThisCC->pSinkLineIn, NULL);
-
         AudioMixerSinkRemoveStream(pThisCC->pSinkLineIn, pDrv->LineIn.pMixStrm);
         AudioMixerStreamDestroy(pDrv->LineIn.pMixStrm, pDevIns, true /*fImmediate*/);
@@ -3655 +3618 @@
 static void ichac97R3DetachInternal(PPDMDEVINS pDevIns, PAC97STATER3 pThisCC, PAC97DRIVER pDrv)
 {
-    /* First, remove the driver from our list and destory it's associated streams.
-     * This also will un-set the driver as a recording source (if associated). */
+    /* Remove the driver from our list and destory it's associated streams.
+       This also will un-set the driver as a recording source (if associated). */
     ichac97R3MixerRemoveDrv(pDevIns, pThisCC, pDrv);
-
-    /* Next, search backwards for a capable (attached) driver which now will be the
-     * new recording source. */
-/** @todo r=bird: This looks completely wrong.  What if the detatched devices wasn't the recording source
- * and we pick a different one here?  I also don't get why we need to do this in revese order, given that
- * the primary device is first.  I guess this code isn't really tested. */
-    PAC97DRIVER pDrvCur;
-    RTListForEachReverse(&pThisCC->lstDrv, pDrvCur, AC97DRIVER, Node)
-    {
-        if (!pDrvCur->pConnector)
-            continue;
-
-        PDMAUDIOBACKENDCFG Cfg;
-        int rc2 = pDrvCur->pConnector->pfnGetConfig(pDrvCur->pConnector, &Cfg);
-        if (RT_FAILURE(rc2))
-            continue;
-
-        PAC97DRIVERSTREAM pDrvStrm = ichac97R3MixerGetDrvStream(pDrvCur, PDMAUDIODIR_IN, PDMAUDIOPATH_IN_MIC);
-        if (   pDrvStrm
-            && pDrvStrm->pMixStrm)
-        {
-            rc2 = AudioMixerSinkSetRecordingSource(pThisCC->pSinkMicIn, pDrvStrm->pMixStrm);
-            if (RT_SUCCESS(rc2))
-                LogRel2(("AC97: Set new recording source for 'Mic In' to '%s'\n", Cfg.szName));
-        }
-
-        pDrvStrm = ichac97R3MixerGetDrvStream(pDrvCur, PDMAUDIODIR_IN, PDMAUDIOPATH_IN_LINE);
-        if (   pDrvStrm
-            && pDrvStrm->pMixStrm)
-        {
-            rc2 = AudioMixerSinkSetRecordingSource(pThisCC->pSinkLineIn, pDrvStrm->pMixStrm);
-            if (RT_SUCCESS(rc2))
-                LogRel2(("AC97: Set new recording source for 'Line In' to '%s'\n", Cfg.szName));
-        }
-    }
-
     LogFunc(("Detached LUN#%u\n", pDrv->uLUN));
 }