Changeset 60941 in vbox for trunk/src/VBox/Devices/Audio

Timestamp:

May 12, 2016 1:12:20 PM (9 years ago)

Author:

vboxsync

Message:

Audio/HDA:

• Lowered timer to 100Hz and start/stop it only if needed. Should improve overall performance.
• More work on dynamic stream assignments (SDI/SDO select) by the guest -- should make more Linux guests compatible with HDA.

Location:

trunk/src/VBox/Devices/Audio

Files:

• AudioMixer.cpp (modified) (3 diffs)
• AudioMixer.h (modified) (1 diff)
• DevIchHda.cpp (modified) (44 diffs)
• DevIchHdaCodec.cpp (modified) (18 diffs)
• DevIchHdaCodec.h (modified) (1 diff)

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

@@ -312 +312 @@
     }
 
-    LogFlowFunc(("Sink=%s, Cmd=%ld, rc=%Rrc\n", pSink->pszName, enmCmd, rc));
+    LogFlowFunc(("%s: enmCmd=%ld, rc=%Rrc\n", pSink->pszName, enmCmd, rc));
     return rc;
 }
@@ -342 +342 @@
 
     RTMemFree(pSink);
+}
+
+/**
+ * Returns the sink's mixing direction.
+ *
+ * @returns Mixing direction.
+ * @param   pSink           Sink to return direction for.
+ *
+ * @remark
+ */
+AUDMIXSINKDIR AudioMixerSinkGetDir(PAUDMIXSINK pSink)
+{
+    AssertPtrReturn(pSink, AUDMIXSINKDIR_UNKNOWN);
+    return pSink->enmDir;
 }
 
@@ -519 +533 @@
 void AudioMixerSinkTimerUpdate(PAUDMIXSINK pSink, uint64_t cTicksPerSec, uint64_t cTicksElapsed, uint32_t *pcbData)
 {
+    AssertPtrReturnVoid(pSink);
+    /* pcbData is optional. */
+
     uint32_t cSamplesMin  = (uint32_t)((2 * cTicksElapsed * pSink->PCMProps.uHz + cTicksPerSec) / cTicksPerSec / 2);
     uint32_t cbSamplesMin = cSamplesMin << pSink->PCMProps.cShift;

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

@@ -156 +156 @@
 int AudioMixerSinkCtl(PAUDMIXSINK pSink, AUDMIXSINKCMD enmCmd);
 void AudioMixerSinkDestroy(PAUDMIXSINK pSink);
+AUDMIXSINKDIR AudioMixerSinkGetDir(PAUDMIXSINK pSink);
 PAUDMIXSTREAM AudioMixerSinkGetStream(PAUDMIXSINK pSink, uint8_t uIndex);
 uint8_t AudioMixerSinkGetStreamCount(PAUDMIXSINK pSink);

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

@@ -629 +629 @@
 
 /**
+ * Structure defining an HDA mixer sink.
+ * Its purpose is to know which audio mixer sink is bound to
+ * which SDn (SDI/SDO) device stream.
+ *
+ * This is needed in order to handle interleaved streams
+ * (that is, multiple channels in one stream) or non-interleaved
+ * streams (each channel has a dedicated stream).
+ *
+ * This is only known to the actual device emulation level.
+ */
+typedef struct HDAMIXERSINK
+{
+    /** SDn ID this sink is assigned to. 0 if not assigned. */
+    uint8_t                uSD;
+    /** Channel ID of SDn ID. Only valid if SDn ID is valid. */
+    uint8_t                uChannel;
+    uint8_t                Padding[3];
+    /** Pointer to the actual audio mixer sink. */
+    R3PTRTYPE(PAUDMIXSINK) pMixSink;
+} HDAMIXERSINK, *PHDAMIXERSINK;
+
+/**
  * Structure for keeping a HDA stream state.
  *
@@ -637 +659 @@
 {
     /** Stream descriptor number (SDn). */
-    uint8_t                 u8SD;
-    uint8_t                 Padding0[7];
+    uint8_t                  u8SD;
+    uint8_t                  Padding0[7];
     /** DMA base address (SDnBDPU - SDnBDPL). */
-    uint64_t                u64BDLBase;
+    uint64_t                 u64BDLBase;
     /** Cyclic Buffer Length (SDnCBL).
      *  Represents the size of the ring buffer. */
-    uint32_t                u32CBL;
+    uint32_t                 u32CBL;
     /** Format (SDnFMT). */
-    uint16_t                u16FMT;
+    uint16_t                 u16FMT;
     /** FIFO Size (FIFOS).
      *  Maximum number of bytes that may have been DMA'd into
@@ -651 +673 @@
      *
      *  Must be a power of two. */
-    uint16_t                u16FIFOS;
+    uint16_t                 u16FIFOS;
     /** Last Valid Index (SDnLVI). */
-    uint16_t                u16LVI;
-    uint16_t                Padding1[3];
-    /** Pointer to mixer sink this stream is attached to. */
-    R3PTRTYPE(PAUDMIXSINK)  pSink;
+    uint16_t                 u16LVI;
+    uint16_t                 Padding1[3];
+    /** Pointer to HDA sink this stream is attached to. */
+    R3PTRTYPE(PHDAMIXERSINK) pMixSink;
     /** Internal state of this stream. */
-    HDASTREAMSTATE          State;
+    HDASTREAMSTATE           State;
 } HDASTREAM, *PHDASTREAM;
 
 /**
- * Structure for mapping a stream tag to
- * an internal stream state.
+ * Structure for mapping a stream tag to an HDA stream.
  */
 typedef struct HDATAG
 {
-    /** Own Tag. */
+    /** Own stream tag. */
     uint8_t               uTag;
     uint8_t               Padding[7];
@@ -785 +806 @@
     /** Flag whether the RC part is enabled. */
     bool                               fRCEnabled;
+    /** Number of active (running) SDn streams. */
+    uint8_t                            cStreamsActive;
 #ifndef VBOX_WITH_AUDIO_CALLBACKS
     /** The timer for pumping data thru the attached LUN drivers. */
@@ -807 +830 @@
     /** The device' software mixer. */
     R3PTRTYPE(PAUDIOMIXER)             pMixer;
-    /** Audio sink for PCM output. */
-    R3PTRTYPE(PAUDMIXSINK)             pSinkFront;
+    /** HDA sink for (front) output. */
+    HDAMIXERSINK                       SinkFront;
 #ifdef VBOX_WITH_HDA_51_SURROUND
-    R3PTRTYPE(PAUDMIXSINK)             pSinkCenterLFE;
-    R3PTRTYPE(PAUDMIXSINK)             pSinkRear;
-#endif
-    /** Audio mixer sink for line input. */
-    R3PTRTYPE(PAUDMIXSINK)             pSinkLineIn;
+    /** HDA sink for center / LFE output. */
+    HDAMIXERSINK                       SinkCenterLFE;
+    /** HDA sink for rear output. */
+    HDAMIXERSINK                       SinkRear;
+#endif
+    /** HDA mixer sink for line input. */
+    HDAMIXERSINK                       SinkLineIn;
 #ifdef VBOX_WITH_HDA_MIC_IN
     /** Audio mixer sink for microphone input. */
-    R3PTRTYPE(PAUDMIXSINK)             pSinkMicIn;
+    HDAMIXERSINK                       SinkMicIn;
 #endif
     uint64_t                           u64BaseTS;
@@ -898 +923 @@
 #ifdef IN_RING3
 static void hdaStreamDestroy(PHDASTREAM pStrmSt);
+static int hdaStreamSetActive(PHDASTATE pThis, PHDASTREAM pStream, bool fActive);
 static int hdaStreamStart(PHDASTREAM pStrmSt);
 static int hdaStreamStop(PHDASTREAM pStrmSt);
@@ -919 +945 @@
 static int           hdaProcessInterrupt(PHDASTATE pThis);
 
+/*
+ * Timer routines.
+ */
+#ifndef VBOX_WITH_AUDIO_CALLBACKS
+static void hdaTimerMaybeStart(PHDASTATE pThis);
+static void hdaTimerMaybeStop(PHDASTATE pThis);
+static DECLCALLBACK(void) hdaTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser);
+#endif
 
 /*********************************************************************************************************************************
@@ -1251 +1285 @@
 }
 
+/**
+ * Returns the HDA stream of specified stream descriptor number.
+ *
+ * @return  Pointer to HDA stream, or NULL if none found.
+ */
 DECLINLINE(PHDASTREAM) hdaStreamFromSD(PHDASTATE pThis, uint8_t uSD)
 {
     AssertPtrReturn(pThis, NULL);
     AssertReturn(uSD <= HDA_MAX_STREAMS, NULL);
+
+    if (uSD >= HDA_MAX_STREAMS)
+        return NULL;
+
     return &pThis->aStreams[uSD];
+}
+
+/**
+ * Returns the HDA stream of specified HDA sink.
+ *
+ * @return  Pointer to HDA stream, or NULL if none found.
+ */
+DECLINLINE(PHDASTREAM) hdaGetStreamFromSink(PHDASTATE pThis, PHDAMIXERSINK pSink)
+{
+    AssertPtrReturn(pThis, NULL);
+    AssertPtrReturn(pSink, NULL);
+
+    /** @todo Do something with the channel mapping here? */
+    return hdaStreamFromSD(pThis, pSink->uSD);
 }
 
@@ -1556 +1613 @@
     {
         pStrmSt->u8SD           = uSD;
-        pStrmSt->pSink          = NULL;
+        pStrmSt->pMixSink       = NULL;
 
         pStrmSt->State.fActive  = false;
@@ -1685 +1742 @@
 }
 
+static int hdaStreamSetActive(PHDASTATE pThis, PHDASTREAM pStream, bool fActive)
+{
+    AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
+    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
+
+    AUDMIXSINKCMD enmCmd = fActive
+                         ? AUDMIXSINKCMD_ENABLE : AUDMIXSINKCMD_DISABLE;
+
+    /* First, enable or disable the stream's sink, if any. */
+    AssertPtr(pStream->pMixSink);
+    if (pStream->pMixSink->pMixSink)
+        AudioMixerSinkCtl(pStream->pMixSink->pMixSink, enmCmd);
+
+    /* Second, see if we need to start or stop the timer. */
+    if (!fActive)
+    {
+        if (pThis->cStreamsActive) /* Disable can be called mupltiple times. */
+            pThis->cStreamsActive--;
+
+#ifndef VBOX_WITH_AUDIO_CALLBACKS
+        hdaTimerMaybeStop(pThis);
+#endif
+    }
+    else
+    {
+        pThis->cStreamsActive++;
+#ifndef VBOX_WITH_AUDIO_CALLBACKS
+        hdaTimerMaybeStart(pThis);
+#endif
+    }
+
+    LogFlowFunc(("u8Strm=%RU8, fActive=%RTbool, cStreamsActive=%RU8\n", pStream->u8SD, fActive, pThis->cStreamsActive));
+
+    return VINF_SUCCESS;
+}
+
+static void hdaStreamAssignToSink(PHDASTREAM pStrmSt, PHDAMIXERSINK pMixSink)
+{
+    AssertPtrReturnVoid(pStrmSt);
+
+    int rc2 = RTSemMutexRequest(pStrmSt->State.hMtx, RT_INDEFINITE_WAIT);
+    if (RT_SUCCESS(rc2))
+    {
+        pStrmSt->pMixSink = pMixSink;
+
+        rc2 = RTSemMutexRelease(pStrmSt->State.hMtx);
+        AssertRC(rc2);
+    }
+}
+
 static int hdaStreamStart(PHDASTREAM pStrmSt)
 {
@@ -2150 +2257 @@
      */
     uint8_t uTag = (u32Value >> HDA_SDCTL_NUM_SHIFT) & HDA_SDCTL_NUM_MASK;
-
-    /* Tag 0 is reserved for software / invalid, just skip. */
-    if (   !uTag
-        || (uTag > HDA_MAX_TAGS))
+    if (uTag > HDA_MAX_TAGS)
     {
         LogFunc(("[SD%RU8]: Warning: Invalid stream tag %RU8 specified!\n", uSD, uTag));
@@ -2163 +2267 @@
     AssertPtr(pTag);
 
-    if (pTag->uTag)
-        LogFunc(("[SD%RU8]: Warning: Tag %RU8 already assigned to %RU8 (pStrm=%p)\n", uSD, uTag, pTag->uTag, pTag->pStrm));
+    LogFunc(("[SD%RU8]: Using stream tag=%RU8\n", uSD, uTag));
 
     /* Assign new values. */
     pTag->uTag  = uTag;
     pTag->pStrm = hdaStreamFromSD(pThis, uSD);
-
-    LogFunc(("[SD%RU8]: Using stream tag=%RU8\n", uSD, uTag));
 
     PHDASTREAM pStrmSt = pTag->pStrm;
@@ -2214 +2315 @@
             LogFunc(("[SD%RU8]: fRun=%RTbool\n", pStrmSt->u8SD, fRun));
 
-            AUDMIXSINKCMD enmCmd = fRun
-                                 ? AUDMIXSINKCMD_ENABLE : AUDMIXSINKCMD_DISABLE;
-
-            if (hdaGetDirFromSD(uSD) == PDMAUDIODIR_IN)
-            {
-# ifdef VBOX_WITH_HDA_MIC_IN
-                AudioMixerSinkCtl(pThis->pSinkMicIn,  enmCmd);
-# endif
-                AudioMixerSinkCtl(pThis->pSinkLineIn, enmCmd);
-            }
-            else
-            {
-                AudioMixerSinkCtl(pThis->pSinkFront,     enmCmd);
-# ifdef VBOX_WITH_HDA_51_SURROUND
-                AudioMixerSinkCtl(pThis->pSinkCenterLFE, enmCmd);
-                AudioMixerSinkCtl(pThis->pSinkRear,      enmCmd);
-# endif
-            }
+            hdaStreamSetActive(pThis, pStrmSt, fRun);
 
             if (fRun)
@@ -2630 +2714 @@
 {
 #ifdef IN_RING3
-    if (HDA_REG_IND(pThis, iReg) == u32Value) /* Value already set? */
-        return VINF_SUCCESS;
-
     PDMAUDIOSTREAMCFG strmCfg;
     RT_ZERO(strmCfg);
@@ -3333 +3414 @@
         }
 
-        rc = AudioMixerSinkRead(pStrmSt->pSink, AUDMIXOP_BLEND, pBDLE->State.au8FIFO, cbBuf, &cbRead);
+        AssertPtr(pStrmSt->pMixSink);
+        AssertPtr(pStrmSt->pMixSink->pMixSink);
+        rc = AudioMixerSinkRead(pStrmSt->pMixSink->pMixSink, AUDMIXOP_BLEND, pBDLE->State.au8FIFO, cbBuf, &cbRead);
         if (RT_FAILURE(rc))
             break;
@@ -3481 +3564 @@
              * Write data to according mixer sinks.
              */
-            rc2 = AudioMixerSinkWrite(pThis->pSinkFront,     AUDMIXOP_COPY, pvDataFront,     cbDataFront,
+            rc2 = AudioMixerSinkWrite(pThis->SinkFront.pMixSink, AUDMIXOP_COPY, pvDataFront,     cbDataFront,
                                       NULL /* pcbWritten */);
             AssertRC(rc2);
 #ifdef VBOX_WITH_HDA_51_SURROUND
-            rc2 = AudioMixerSinkWrite(pThis->pSinkCenterLFE, AUDMIXOP_COPY, pvDataCenterLFE, cbDataCenterLFE,
+            rc2 = AudioMixerSinkWrite(pThis->SinkCenterLFE,      AUDMIXOP_COPY, pvDataCenterLFE, cbDataCenterLFE,
                                       NULL /* pcbWritten */);
             AssertRC(rc2);
-            rc2 = AudioMixerSinkWrite(pThis->pSinkRear,      AUDMIXOP_COPY, pvDataRear,      cbDataRear,
+            rc2 = AudioMixerSinkWrite(pThis->SinkRear,           AUDMIXOP_COPY, pvDataRear,      cbDataRear,
                                       NULL /* pcbWritten */);
             AssertRC(rc2);
@@ -3545 +3628 @@
  * Returns NULL if no sink is found.
  *
- * @return  PAUDMIXSINK
+ * @return  PHDAMIXERSINK
  * @param   pThis               HDA state.
  * @param   enmMixerCtl         Mixer control to get the corresponding sink for.
  */
-static PAUDMIXSINK hdaMixerControlToSink(PHDASTATE pThis, PDMAUDIOMIXERCTL enmMixerCtl)
-{
-    PAUDMIXSINK pSink;
+static PHDAMIXERSINK hdaMixerControlToSink(PHDASTATE pThis, PDMAUDIOMIXERCTL enmMixerCtl)
+{
+    PHDAMIXERSINK pSink;
 
     switch (enmMixerCtl)
@@ -3558 +3641 @@
             /* Fall through is intentional. */
         case PDMAUDIOMIXERCTL_FRONT:
-            pSink = pThis->pSinkFront;
+            pSink = &pThis->SinkFront;
             break;
 #ifdef VBOX_WITH_HDA_51_SURROUND
         case PDMAUDIOMIXERCTL_CENTER_LFE:
-            pSink = pThis->pSinkCenterLFE;
+            pSink = &pThis->SinkCenterLFE;
             break;
         case PDMAUDIOMIXERCTL_REAR:
-            pSink = pThis->pSinkRear;
+            pSink = &pThis->SinkRear;
             break;
 #endif
         case PDMAUDIOMIXERCTL_LINE_IN:
-            pSink = pThis->pSinkLineIn;
+            pSink = &pThis->SinkLineIn;
             break;
 #ifdef VBOX_WITH_HDA_MIC_IN
         case PDMAUDIOMIXERCTL_MIC_IN:
-            pSink = pThis->pSinkMicIn;
+            pSink = &pThis->SinkMicIn;
             break;
 #endif
@@ -3585 +3668 @@
 }
 
-static DECLCALLBACK(int) hdaMixerAddStream(PHDASTATE pThis, PAUDMIXSINK pSink, PPDMAUDIOSTREAMCFG pCfg)
+static DECLCALLBACK(int) hdaMixerAddStream(PHDASTATE pThis, PHDAMIXERSINK pSink, PPDMAUDIOSTREAMCFG pCfg)
 {
     AssertPtrReturn(pThis, VERR_INVALID_POINTER);
@@ -3591 +3674 @@
     AssertPtrReturn(pCfg,  VERR_INVALID_POINTER);
 
-    LogFunc(("Sink=%s, Stream=%s\n", pSink->pszName, pCfg->szName));
-
-    int rc = VINF_SUCCESS;
+    LogFunc(("Sink=%s, Stream=%s\n", pSink->pMixSink->pszName, pCfg->szName));
+
+    /* Update the sink's format. */
+    PDMPCMPROPS PCMProps;
+    int rc = DrvAudioStreamCfgToProps(pCfg, &PCMProps);
+    if (RT_SUCCESS(rc))
+        rc = AudioMixerSinkSetFormat(pSink->pMixSink, &PCMProps);
 
     PHDADRIVER pDrv;
@@ -3643 +3730 @@
         if (RT_SUCCESS(rc2))
         {
+            AudioMixerSinkRemoveStream(pSink->pMixSink, pStream->pMixStrm);
+
+            AudioMixerStreamDestroy(pStream->pMixStrm);
+            pStream->pMixStrm = NULL;
+
             PAUDMIXSTREAM pMixStrm;
             rc2 = AudioMixerStreamCreate(pDrv->pConnector, pCfg, 0 /* fFlags */, &pMixStrm);
             if (RT_SUCCESS(rc2))
             {
-                rc2 = AudioMixerSinkAddStream(pSink, pMixStrm);
+                rc2 = AudioMixerSinkAddStream(pSink->pMixSink, pMixStrm);
                 LogFlowFunc(("LUN#%RU8: Added \"%s\" to sink, rc=%Rrc\n", pDrv->uLUN, pCfg->szName , rc2));
             }
@@ -3680 +3772 @@
     int rc;
 
-    PAUDMIXSINK pSink = hdaMixerControlToSink(pThis, enmMixerCtl);
+    PHDAMIXERSINK pSink = hdaMixerControlToSink(pThis, enmMixerCtl);
     if (pSink)
     {
@@ -3688 +3780 @@
         rc = VERR_NOT_FOUND;
 
-    LogFlowFunc(("Sink=%s, enmMixerCtl=%ld, rc=%Rrc\n", pSink->pszName, enmMixerCtl, rc));
+    LogFlowFunc(("Sink=%s, enmMixerCtl=%ld, rc=%Rrc\n", pSink->pMixSink->pszName, enmMixerCtl, rc));
     return rc;
 }
@@ -3705 +3797 @@
     int rc;
 
-    PAUDMIXSINK pSink = hdaMixerControlToSink(pThis, enmMixerCtl);
+    PHDAMIXERSINK pSink = hdaMixerControlToSink(pThis, enmMixerCtl);
     if (pSink)
     {
-        AudioMixerSinkRemoveAllStreams(pSink);
+        PHDADRIVER pDrv;
+        RTListForEach(&pThis->lstDrv, pDrv, HDADRIVER, Node)
+        {
+            PAUDMIXSTREAM pMixStream;
+            switch (enmMixerCtl)
+            {
+                /*
+                 * Input.
+                 */
+                case PDMAUDIOMIXERCTL_LINE_IN:
+                    pMixStream = pDrv->LineIn.pMixStrm;
+                    pDrv->LineIn.pMixStrm = NULL;
+                    break;
+#ifdef VBOX_WITH_HDA_MIC_IN
+                case PDMAUDIOMIXERCTL_MIC_IN:
+                    pMixStream = pDrv->MicIn.pMixStrm;
+                    pDrv->MicIn.pMixStrm = NULL;
+                    break;
+#endif
+                /*
+                 * Output.
+                 */
+                case PDMAUDIOMIXERCTL_FRONT:
+                    pMixStream = pDrv->Front.pMixStrm;
+                    pDrv->Front.pMixStrm = NULL;
+                    break;
+#ifdef VBOX_WITH_HDA_51_SURROUND
+                case PDMAUDIOMIXERCTL_CENTER_LFE:
+                    pMixStream = pDrv->CenterLFE.pMixStrm;
+                    pDrv->CenterLFE.pMixStrm = NULL;
+                    break;
+                case PDMAUDIOMIXERCTL_REAR:
+                    pMixStream = pDrv->Rear.pMixStrm;
+                    pDrv->Rear.pMixStrm = NULL;
+                    break;
+#endif
+                default:
+                    AssertMsgFailed(("Mixer control %ld not implemented\n", enmMixerCtl));
+                    break;
+            }
+
+            AudioMixerSinkRemoveStream(pSink->pMixSink, pMixStream);
+            AudioMixerStreamDestroy(pMixStream);
+        }
+
+        AudioMixerSinkRemoveAllStreams(pSink->pMixSink);
         rc = VINF_SUCCESS;
     }
@@ -3715 +3852 @@
 
     LogFlowFunc(("enmMixerCtl=%ld, rc=%Rrc\n", enmMixerCtl, rc));
+    return rc;
+}
+
+/**
+ * Sets a SDn stream number and channel to a particular mixer control.
+ *
+ * @returns IPRT status code.
+ * @param   pThis               HDA State.
+ * @param   enmMixerCtl         Mixer control to set SD stream number and channel for.
+ * @param   uSD                 SD stream number (number + 1) to set. Set to 0 for unassign.
+ * @param   uChannel            Channel to set. Only valid if a valid SD stream number is specified.
+ */
+static DECLCALLBACK(int) hdaMixerSetStream(PHDASTATE pThis,
+                                           PDMAUDIOMIXERCTL enmMixerCtl, uint8_t uSD, uint8_t uChannel)
+{
+    LogFlowFunc(("enmMixerCtl=%RU32, uSD=%RU8, uChannel=%RU8\n", enmMixerCtl, uSD, uChannel));
+
+    if (uSD == 0) /* Stream number 0 is reserved. */
+    {
+        LogFlowFunc(("Invalid SDn (%RU8) number for mixer control %ld, ignoring\n", uSD, enmMixerCtl));
+        return VINF_SUCCESS;
+    }
+    /* uChannel is optional. */
+
+    /* SDn0 starts as 1. */
+    Assert(uSD);
+    uSD--;
+
+    int rc;
+
+    PHDAMIXERSINK pSink = hdaMixerControlToSink(pThis, enmMixerCtl);
+    if (pSink)
+    {
+        if (   (uSD < HDA_MAX_SDI)
+            && AudioMixerSinkGetDir(pSink->pMixSink) == AUDMIXSINKDIR_OUTPUT)
+        {
+            uSD += HDA_MAX_SDI;
+        }
+
+        LogFlowFunc(("%s: Setting to stream ID=%RU8, channel=%RU8, enmMixerCtl=%RU32\n",
+                     pSink->pMixSink->pszName, uSD, uChannel, enmMixerCtl));
+
+        Assert(uSD < HDA_MAX_STREAMS);
+
+        PHDASTREAM pStream = hdaStreamFromSD(pThis, pSink->uSD);
+        if (pStream)
+        {
+            pSink->uSD      = uSD;
+            pSink->uChannel = uChannel;
+
+            /* Make sure that the stream also has this sink set. */
+            hdaStreamAssignToSink(pStream, pSink);
+
+            rc = VINF_SUCCESS;
+        }
+        else
+        {
+            LogRel(("HDA: Guest wanted to assign invalid stream ID=%RU8 (channel %RU8) to mixer control %RU32, skipping\n",
+                    uSD, uChannel, enmMixerCtl));
+            rc = VERR_INVALID_PARAMETER;
+        }
+    }
+    else
+        rc = VERR_NOT_FOUND;
+
+    LogFlowFuncLeaveRC(rc);
     return rc;
 }
@@ -3731 +3934 @@
     int rc;
 
-    PAUDMIXSINK pSink = hdaMixerControlToSink(pThis, enmMixerCtl);
+    PHDAMIXERSINK pSink = hdaMixerControlToSink(pThis, enmMixerCtl);
     if (pSink)
     {
         /* Set the volume.
          * We assume that the codec already converted it to the correct range. */
-        rc = AudioMixerSinkSetVolume(pSink, pVol);
+        rc = AudioMixerSinkSetVolume(pSink->pMixSink, pVol);
     }
     else
@@ -3746 +3949 @@
 
 #ifndef VBOX_WITH_AUDIO_CALLBACKS
+
+static void hdaTimerMaybeStart(PHDASTATE pThis)
+{
+    if (pThis->cStreamsActive == 0) /* Only start the timer if there are no active streams. */
+        return;
+
+    if (!pThis->pTimer)
+        return;
+
+    LogFlowFuncEnter();
+
+    /* Fire off timer. */
+    TMTimerSet(pThis->pTimer, TMTimerGet(pThis->pTimer) + pThis->cTimerTicks);
+}
+
+static void hdaTimerMaybeStop(PHDASTATE pThis)
+{
+    if (pThis->cStreamsActive) /* Some streams still active? Bail out. */
+        return;
+
+    if (!pThis->pTimer)
+        return;
+
+    LogFlowFuncEnter();
+
+    int rc2 = TMTimerStop(pThis->pTimer);
+    AssertRC(rc2);
+}
 
 static DECLCALLBACK(void) hdaTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
@@ -3764 +3995 @@
     pThis->uTimerTS = cTicksNow;
 
-    /*
-     * Calculate the codec's (fixed) sampling rate.
-     */
-    AssertPtr(pThis->pCodec);
-
-    /* Since the codec always runs at a fixed delivery rate (48 kHz), calculate the sample processing rate based
-     * on the clock ticks elapsed (the clock itself runs at 24 Mhz).
-     * A stream itself can have a higher or lower delivery rate, which in turn then results in more or less
-     * stream samples per frame. */
-    uint32_t cCodecSamplesMin  = (int)((2 * cTicksElapsed * 48000 /* Hz */ + cTicksPerSec) / cTicksPerSec / 2);
-    /* We always use 32-bit as containers to make sure all data is being pumped if we need to. */
-    uint32_t cbCodecSamplesMin = cCodecSamplesMin << 1;
-
-#if 0
-    /*
-     * Process all driver nodes.
-     */
-    PHDADRIVER pDrv;
-    RTListForEach(&pThis->lstDrv, pDrv, HDADRIVER, Node)
-    {
-        uint32_t cbIn = 0;
-        uint32_t cbOut = 0;
-
-        rc = pDrv->pConnector->pfnQueryStatus(pDrv->pConnector, &cbIn, &cbOut, NULL /* pcSamplesLive */);
-        if (RT_SUCCESS(rc))
-            rc = pDrv->pConnector->pfnPlayOut(pDrv->pConnector, NULL /* pcSamplesPlayed */);
-
-#ifdef DEBUG_TIMER
-        LogFlowFunc(("LUN#%RU8: rc=%Rrc, cbIn=%RU32, cbOut=%RU32\n", pDrv->uLUN, rc, cbIn, cbOut));
-#endif
-        /* If we there was an error handling (available) output or there simply is no output available,
-         * then calculate the minimum data rate which must be processed by the device emulation in order
-         * to function correctly.
-         *
-         * 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 (!AudioMixerStreamIsValid(pDrv->Front.pMixStrm))
-        {
-            /* Use the codec's (fixed) sampling rate. */
-            cbOut = RT_MAX(cbOut, cbCodecSamplesMin);
-            continue;
-        }
-
-        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.pMixStrm->InOut.pOut->Props.uHz + cTicksPerSec) / cTicksPerSec / 2);
-            uint32_t cbSamplesMin = AUDIOMIXBUF_S2B(&pDrv->Front.pMixStrm->InOut.pOut->MixBuf, cSamplesMin);
-
-#ifdef DEBUG_TIMER
-            LogFlowFunc(("\trc=%Rrc, cSamplesMin=%RU32, cbSamplesMin=%RU32\n", rc, cSamplesMin, cbSamplesMin));
-#endif
-            cbOut = RT_MAX(cbOut, cbSamplesMin);
-        }
-
-        cbOutMin = RT_MIN(cbOutMin, cbOut);
-        cbInMax  = RT_MAX(cbInMax, cbIn);
-    }
-#else
-    AudioMixerSinkUpdate(pThis->pSinkFront);
-    cbOutMin = _4K; //cbCodecSamplesMin;
-    cbInMax  = _4K;
-#endif
-
-#ifdef DEBUG_TIMER
-    LogFlowFunc(("cbInMax=%RU32, cbOutMin=%RU32\n", cbInMax, cbOutMin));
-#endif
-
-    if (cbOutMin == UINT32_MAX)
-        cbOutMin = 0;
-
-    /** @todo Determine the streams to be handled. */
-    PHDASTREAM pStreamLineIn  = &pThis->aStreams[0];
+    PHDASTREAM pStreamLineIn  = hdaGetStreamFromSink(pThis, &pThis->SinkLineIn);
 #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, pStreamOut,     cbOutMin /* cbToProcess */, NULL /* pcbProcessed */);
-    hdaTransfer(pThis, pStreamLineIn,  cbInMax  /* cbToProcess */, NULL /* pcbProcessed */);
+    PHDASTREAM pStreamMicIn   = hdaGetStreamFromSink(pThis, &pThis->SinkMicIn);
+#endif
+    PHDASTREAM pStreamFront   = hdaGetStreamFromSink(pThis, &pThis->SinkFront);
+
+    uint32_t cbLineIn;
+    AudioMixerSinkTimerUpdate(pThis->SinkLineIn.pMixSink, cTicksPerSec, cTicksElapsed, &cbLineIn);
+    if (cbLineIn)
+        hdaTransfer(pThis, pStreamLineIn, cbLineIn, NULL); /** @todo Add rc! */
+
+#ifdef VBOX_WITH_HDA_MIC_IN
+    uint32_t cbMicIn;
+    AudioMixerSinkTimerUpdate(pThis->SinkMicIn.pMixSink , cTicksPerSec, cTicksElapsed, &cbMicIn);
+#endif
+
+    uint32_t cbOut;
+    AudioMixerSinkTimerUpdate(pThis->SinkFront.pMixSink, cTicksPerSec, cTicksElapsed, &cbOut);
+    if (cbOut)
+        hdaTransfer(pThis, pStreamFront, cbOut, NULL);  /** @todo Add rc! */
 
     /* Kick the timer again. */
@@ -3911 +4080 @@
     /* 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. */
     {
@@ -3975 +4141 @@
     Assert(pStream->State.fInReset == false);
 
-//    uint32_t cbLeft  = cbToProcess;
     uint32_t u32LPIB = HDA_STREAM_REG(pThis, LPIB, pStream->u8SD);
     Assert(u32LPIB <= pStream->u32CBL);
@@ -4039 +4204 @@
 
         /* Set the FIFORDY bit on the stream while doing the transfer. */
-    //    HDA_STREAM_REG(pThis, STS, pStream->u8SD) |= HDA_REG_FIELD_FLAG_MASK(SDSTS, FIFORDY);
+        HDA_STREAM_REG(pThis, STS, pStream->u8SD) |= HDA_REG_FIELD_FLAG_MASK(SDSTS, FIFORDY);
 
         uint32_t cbProcessed;
@@ -4048 +4213 @@
 
         /* Remove the FIFORDY bit again. */
-    //    HDA_STREAM_REG(pThis, STS, pStream->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))
@@ -4854 +5019 @@
 
 # ifdef VBOX_WITH_HDA_MIC_IN
-        AudioMixerSinkCtl(pThis->pSinkMicIn,     enmCmdMicIn);
+        AudioMixerSinkCtl(pThis->SinkMicIn.pMixSink,     enmCmdMicIn);
 # endif
-        AudioMixerSinkCtl(pThis->pSinkLineIn,    enmCmdLineIn);
-        AudioMixerSinkCtl(pThis->pSinkFront,     enmCmdOut);
+        AudioMixerSinkCtl(pThis->SinkLineIn.pMixSink,    enmCmdLineIn);
+        AudioMixerSinkCtl(pThis->SinkFront.pMixSink,     enmCmdOut);
 # ifdef VBOX_WITH_HDA_51_SURROUND
-        AudioMixerSinkCtl(pThis->pSinkCenterLFE, enmCmdOut);
-        AudioMixerSinkCtl(pThis->pSinkRear,      enmCmdOut);
+        AudioMixerSinkCtl(pThis->SinkCenterLFE.pMixSink, enmCmdOut);
+        AudioMixerSinkCtl(pThis->SinkRear.pMixSink,      enmCmdOut);
 # endif
     }
@@ -5177 +5342 @@
      * Stop the timer, if any.
      */
-    int rc2;
-    if (pThis->pTimer)
-    {
-        rc2 = TMTimerStop(pThis->pTimer);
-        AssertRC(rc2);
-    }
+    hdaTimerMaybeStop(pThis);
 # endif
 
@@ -5205 +5365 @@
      * Stop any audio currently playing and/or recording.
      */
-    AudioMixerSinkCtl(pThis->pSinkFront,     AUDMIXSINKCMD_DISABLE);
+    AudioMixerSinkCtl(pThis->SinkFront.pMixSink,     AUDMIXSINKCMD_DISABLE);
 # ifdef VBOX_WITH_HDA_MIC_IN
-    AudioMixerSinkCtl(pThis->pSinkMicIn,     AUDMIXSINKCMD_DISABLE);
+    AudioMixerSinkCtl(pThis->SinkMicIn.pMixSink,     AUDMIXSINKCMD_DISABLE);
 # endif
-    AudioMixerSinkCtl(pThis->pSinkLineIn,    AUDMIXSINKCMD_DISABLE);
+    AudioMixerSinkCtl(pThis->SinkLineIn.pMixSink,    AUDMIXSINKCMD_DISABLE);
 # ifdef VBOX_WITH_HDA_51_SURROUND
-    AudioMixerSinkCtl(pThis->pSinkCenterLFE, AUDMIXSINKCMD_DISABLE);
-    AudioMixerSinkCtl(pThis->pSinkRear,      AUDMIXSINKCMD_DISABLE);
+    AudioMixerSinkCtl(pThis->SinkCenterLFE.pMixSink, AUDMIXSINKCMD_DISABLE);
+    AudioMixerSinkCtl(pThis->SinkRear.pMixSink,      AUDMIXSINKCMD_DISABLE);
 # endif
+
+    /*
+     * Set some sensible defaults for which HDA sinks
+     * are connected to which stream number.
+     *
+     * We use SD0 for input and SD4 for output by default.
+     * These stream numbers can be changed by the guest dynamically lateron.
+     */
+#ifdef VBOX_WITH_HDA_MIC_IN
+    hdaMixerSetStream(pThis, PDMAUDIOMIXERCTL_MIC_IN    , 1 /* SD0 */, 0 /* Channel */);
+#endif
+    hdaMixerSetStream(pThis, PDMAUDIOMIXERCTL_LINE_IN   , 1 /* SD0 */, 0 /* Channel */);
+
+    hdaMixerSetStream(pThis, PDMAUDIOMIXERCTL_FRONT     , 5 /* SD4 */, 0 /* Channel */);
+#ifdef VBOX_WITH_HDA_51_SURROUND
+    hdaMixerSetStream(pThis, PDMAUDIOMIXERCTL_CENTER_LFE, 5 /* SD4 */, 0 /* Channel */);
+    hdaMixerSetStream(pThis, PDMAUDIOMIXERCTL_REAR      , 5 /* SD4 */, 0 /* Channel */);
+#endif
 
     pThis->cbCorbBuf = 256 * sizeof(uint32_t); /** @todo Use a define here. */
@@ -5244 +5422 @@
 
 # ifndef VBOX_WITH_AUDIO_CALLBACKS
-    /*
-     * Start timer again, if any.
-     */
-    if (pThis->pTimer)
-    {
-        LogFunc(("Restarting timer\n"));
-        rc2 = TMTimerSet(pThis->pTimer, TMTimerGet(pThis->pTimer) + pThis->cTimerTicks);
-        AssertRC(rc2);
-    }
+    hdaTimerMaybeStart(pThis);
 # endif
 
@@ -5405 +5575 @@
     LogRel2(("HDA: Powering off ...\n"));
 
+    /* Ditto goes for the codec, which in turn uses the mixer. */
+    hdaCodecPowerOff(pThis->pCodec);
+
     /**
      * Note: Destroy the mixer while powering off and *not* in hdaDestruct,
@@ -5415 +5588 @@
         pThis->pMixer = NULL;
     }
-
-    /* Ditto goes for the codec, which in turn uses the mixer. */
-    hdaCodecPowerOff(pThis->pCodec);
 }
 
@@ -5508 +5678 @@
 #ifndef VBOX_WITH_AUDIO_CALLBACKS
     uint16_t uTimerHz;
-    rc = CFGMR3QueryU16Def(pCfg, "TimerHz", &uTimerHz, 200 /* Hz */);
+    rc = CFGMR3QueryU16Def(pCfg, "TimerHz", &uTimerHz, 100 /* Hz */);
     if (RT_FAILURE(rc))
         return PDMDEV_SET_ERROR(pDevIns, rc,
@@ -5675 +5845 @@
 #ifdef VBOX_WITH_HDA_51_SURROUND
             rc = AudioMixerCreateSink(pThis->pMixer, "[Playback] Front",
-                                      AUDMIXSINKDIR_OUTPUT, &pThis->pSinkFront);
+                                      AUDMIXSINKDIR_OUTPUT, &pThis->SinkFront.pMixSink);
             AssertRC(rc);
             rc = AudioMixerCreateSink(pThis->pMixer, "[Playback] Center / Subwoofer",
-                                      AUDMIXSINKDIR_OUTPUT, &pThis->pSinkCenterLFE);
+                                      AUDMIXSINKDIR_OUTPUT, &pThis->SinkCenterLFE.pMixSink);
             AssertRC(rc);
             rc = AudioMixerCreateSink(pThis->pMixer, "[Playback] Rear",
-                                      AUDMIXSINKDIR_OUTPUT, &pThis->pSinkRear);
+                                      AUDMIXSINKDIR_OUTPUT, &pThis->SinkRear.pMixSink);
             AssertRC(rc);
 #else
             rc = AudioMixerCreateSink(pThis->pMixer, "[Playback] PCM Output",
-                                      AUDMIXSINKDIR_OUTPUT, &pThis->pSinkFront);
+                                      AUDMIXSINKDIR_OUTPUT, &pThis->SinkFront.pMixSink);
             AssertRC(rc);
 #endif
@@ -5692 +5862 @@
              */
             rc = AudioMixerCreateSink(pThis->pMixer, "[Recording] Line In",
-                                      AUDMIXSINKDIR_INPUT, &pThis->pSinkLineIn);
+                                      AUDMIXSINKDIR_INPUT, &pThis->SinkLineIn.pMixSink);
             AssertRC(rc);
 #ifdef VBOX_WITH_HDA_MIC_IN
             rc = AudioMixerCreateSink(pThis->pMixer, "[Recording] Microphone In",
-                                      AUDMIXSINKDIR_INPUT, &pThis->pSinkMicIn);
+                                      AUDMIXSINKDIR_INPUT, &pThis->SinkMicIn.pMixSink);
             AssertRC(rc);
 #endif
@@ -5716 +5886 @@
         pThis->pCodec->pfnMixerAddStream    = hdaMixerAddStream;
         pThis->pCodec->pfnMixerRemoveStream = hdaMixerRemoveStream;
+        pThis->pCodec->pfnMixerSetStream    = hdaMixerSetStream;
         pThis->pCodec->pfnMixerSetVolume    = hdaMixerSetVolume;
         pThis->pCodec->pfnReset             = hdaCodecReset;
@@ -5744 +5915 @@
             AssertRC(rc);
         }
-
-        /*
-         * As we don't have any dynamic stream <-> mixer sink mapping (yet),
-         * hard-wire the associations here.
-         */
-#ifdef VBOX_WITH_HDA_51_SURROUND
-# error "Implement me!" /** @todo */
-#else
-        /* Same goes for the input sink. */
-        for (uint8_t i = 0; i < HDA_MAX_SDI; i++)
-            pThis->aStreams[i].pSink = pThis->pSinkLineIn;
-# ifdef VBOX_WITH_HDA_MIC_IN
-#  error "Implement me!" /** @todo */
-# endif
-        /* Assign all output streams to the one-and-only output sink. */
-        for (uint8_t i = HDA_MAX_SDI; i < HDA_MAX_SDO; i++)
-            pThis->aStreams[i].pSink = pThis->pSinkFront;
-#endif /* VBOX_WITH_HDA_51_SURROUND */
 
         /*
@@ -5969 +6122 @@
             LogFunc(("Timer ticks=%RU64 (%RU16 Hz)\n", pThis->cTimerTicks, uTimerHz));
 
-            /* Fire off timer. */
-            TMTimerSet(pThis->pTimer, TMTimerGet(pThis->pTimer) + pThis->cTimerTicks);
+            hdaTimerMaybeStart(pThis);
         }
     }

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

@@ -550 +550 @@
 typedef struct CODECCOMMONNODE
 {
-    /** Node id - 7 bit format */
-    uint8_t         id;
-    /** The node name. */
+    /** The node's ID. */
+    uint8_t         uID;
+    /** The node's name. */
     char const     *pszName;
+    /** The SDn ID this node is assigned to.
+     *  0 means not assigned, 1 is SDn0. */
+    uint8_t         uSD;
+    /** The SDn's channel to use.
+     *  Only valid if a valid SDn ID is set. */
+    uint8_t         uChannel;
     /* PRM 5.3.6 */
     uint32_t au32F00_param[CODECNODE_F00_PARAM_LENGTH];
@@ -839 +845 @@
 static SSMFIELD const g_aCodecNodeFields[] =
 {
-    SSMFIELD_ENTRY(     CODECSAVEDSTATENODE, Core.id),
+    SSMFIELD_ENTRY(     CODECSAVEDSTATENODE, Core.uID),
     SSMFIELD_ENTRY_PAD_HC_AUTO(3, 3),
     SSMFIELD_ENTRY(     CODECSAVEDSTATENODE, Core.au32F00_param),
@@ -850 +856 @@
 static SSMFIELD const g_aCodecNodeFieldsV1[] =
 {
-    SSMFIELD_ENTRY(     CODECSAVEDSTATENODE, Core.id),
+    SSMFIELD_ENTRY(     CODECSAVEDSTATENODE, Core.uID),
     SSMFIELD_ENTRY_PAD_HC_AUTO(3, 7),
     SSMFIELD_ENTRY_OLD_HCPTR(Core.name),
@@ -890 +896 @@
 
     /* Set common parameters across all nodes. */
-    pNode->node.id = uNID;
+    pNode->node.uID = uNID;
+    pNode->node.uSD = 0;
 
     switch (uNID)
@@ -2051 +2058 @@
         && pThis->pfnCodecNodeReset)
     {
-        uint8_t i;
         LogFunc(("Entering reset ...\n"));
 
-        //pThis->fInReset = true;
-
-        for (i = 0; i < pThis->cTotalNodes; ++i)
+        pThis->fInReset = true;
+
+        for (uint8_t i = 0; i < pThis->cTotalNodes; ++i)
             pThis->pfnCodecNodeReset(pThis, i, &pThis->paNodes[i]);
 
-        //pThis->fInReset = false;
+        pThis->fInReset = false;
 
         LogFunc(("Exited reset\n"));
@@ -2274 +2280 @@
     *pResp = 0;
 
+    bool fIsOut;
+
     if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
         *pResp = pThis->paNodes[CODEC_NID(cmd)].dac.u32F06_param;
@@ -2287 +2295 @@
         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)));*/
+    LogFlowFunc(("[NID0x%02x] Stream ID=%RU8, channel=%RU8\n",
+                 CODEC_NID(cmd), CODEC_F00_06_GET_STREAM_ID(cmd), CODEC_F00_06_GET_CHANNEL_ID(cmd)));
 
     return VINF_SUCCESS;
@@ -2298 +2306 @@
     *pResp = 0;
 
+    PDMAUDIODIR enmDir;
+
     uint32_t *pu32Addr = NULL;
     if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
+    {
         pu32Addr = &pThis->paNodes[CODEC_NID(cmd)].dac.u32F06_param;
+        enmDir = PDMAUDIODIR_OUT;
+    }
     else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
+    {
         pu32Addr = &pThis->paNodes[CODEC_NID(cmd)].adc.u32F06_param;
+        enmDir = PDMAUDIODIR_IN;
+    }
     else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
+    {
         pu32Addr = &pThis->paNodes[CODEC_NID(cmd)].spdifout.u32F06_param;
+        enmDir = PDMAUDIODIR_OUT;
+    }
     else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
+    {
         pu32Addr = &pThis->paNodes[CODEC_NID(cmd)].spdifin.u32F06_param;
-    else if (hdaCodecIsReservedNode(pThis, CODEC_NID(cmd)))
-        pu32Addr = &pThis->paNodes[CODEC_NID(cmd)].reserved.u32F06_param;
+        enmDir = PDMAUDIODIR_IN;
+    }
     else
+    {
+        enmDir = PDMAUDIODIR_UNKNOWN;
         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)));*/
+    }
+
+    /* Do we (re-)assign our input/output SDn (SDI/SDO) IDs? */
+    if (enmDir != PDMAUDIODIR_UNKNOWN)
+    {
+        uint8_t uSD      = CODEC_F00_06_GET_STREAM_ID(cmd);
+        uint8_t uChannel = CODEC_F00_06_GET_CHANNEL_ID(cmd);
+
+        LogFlowFunc(("[NID0x%02x] Setting to stream ID=%RU8, channel=%RU8, enmDir=%RU32\n",
+                     CODEC_NID(cmd), uSD, uChannel, enmDir));
+
+        pThis->paNodes[CODEC_NID(cmd)].node.uSD      = uSD;
+        pThis->paNodes[CODEC_NID(cmd)].node.uChannel = uChannel;
+
+        if (enmDir == PDMAUDIODIR_OUT)
+        {
+            /** @todo Check if non-interleaved streams need a different channel / SDn? */
+
+            /* Propagate to the controller. */
+            pThis->pfnMixerSetStream(pThis->pHDAState, PDMAUDIOMIXERCTL_FRONT,      uSD, uChannel);
+#ifdef VBOX_WITH_HDA_51_SURROUND
+            pThis->pfnMixerSetStream(pThis->pHDAState, PDMAUDIOMIXERCTL_CENTER_LFE, uSD, uChannel);
+            pThis->pfnMixerSetStream(pThis->pHDAState, PDMAUDIOMIXERCTL_REAR,       uSD, uChannel);
+#endif
+        }
+        else if (enmDir == PDMAUDIODIR_IN)
+        {
+            pThis->pfnMixerSetStream(pThis->pHDAState, PDMAUDIOMIXERCTL_LINE_IN,    uSD, uChannel);
+#ifdef VBOX_WITH_HDA_MIC_IN
+            pThis->pfnMixerSetStream(pThis->pHDAState, PDMAUDIOMIXERCTL_MIC_IN,     uSD, uChannel);
+#endif
+        }
+    }
 
     if (pu32Addr)
@@ -2756 +2808 @@
 static void codecDbgPrintNode(PCODECDBGINFO pInfo, PCODECNODE pNode, bool fRecursive)
 {
-    codecDbgPrintf(pInfo, "Node 0x%02x (%02RU8): ", pNode->node.id, pNode->node.id);
-
-    if (pNode->node.id == STAC9220_NID_ROOT)
+    codecDbgPrintf(pInfo, "Node 0x%02x (%02RU8): ", pNode->node.uID, pNode->node.uID);
+
+    if (pNode->node.uID == STAC9220_NID_ROOT)
     {
         CODECDBG_PRINT("ROOT\n");
     }
-    else if (pNode->node.id == STAC9220_NID_AFG)
+    else if (pNode->node.uID == STAC9220_NID_AFG)
     {
         CODECDBG_PRINT("AFG\n");
@@ -2770 +2822 @@
         CODECDBG_UNINDENT
     }
-    else if (hdaCodecIsPortNode(pInfo->pThis, pNode->node.id))
+    else if (hdaCodecIsPortNode(pInfo->pThis, pNode->node.uID))
     {
         CODECDBG_PRINT("PORT\n");
     }
-    else if (hdaCodecIsDacNode(pInfo->pThis, pNode->node.id))
+    else if (hdaCodecIsDacNode(pInfo->pThis, pNode->node.uID))
     {
         CODECDBG_PRINT("DAC\n");
@@ -2784 +2836 @@
         CODECDBG_UNINDENT
     }
-    else if (hdaCodecIsAdcVolNode(pInfo->pThis, pNode->node.id))
+    else if (hdaCodecIsAdcVolNode(pInfo->pThis, pNode->node.uID))
     {
         CODECDBG_PRINT("ADC VOLUME\n");
@@ -2793 +2845 @@
         CODECDBG_UNINDENT
     }
-    else if (hdaCodecIsAdcNode(pInfo->pThis, pNode->node.id))
+    else if (hdaCodecIsAdcNode(pInfo->pThis, pNode->node.uID))
     {
         CODECDBG_PRINT("ADC\n");
@@ -2803 +2855 @@
         CODECDBG_UNINDENT
     }
-    else if (hdaCodecIsAdcMuxNode(pInfo->pThis, pNode->node.id))
+    else if (hdaCodecIsAdcMuxNode(pInfo->pThis, pNode->node.uID))
     {
         CODECDBG_PRINT("ADC MUX\n");
@@ -2812 +2864 @@
         CODECDBG_UNINDENT
     }
-    else if (hdaCodecIsPcbeepNode(pInfo->pThis, pNode->node.id))
+    else if (hdaCodecIsPcbeepNode(pInfo->pThis, pNode->node.uID))
     {
         CODECDBG_PRINT("PC BEEP\n");
     }
-    else if (hdaCodecIsSpdifOutNode(pInfo->pThis, pNode->node.id))
+    else if (hdaCodecIsSpdifOutNode(pInfo->pThis, pNode->node.uID))
     {
         CODECDBG_PRINT("SPDIF OUT\n");
     }
-    else if (hdaCodecIsSpdifInNode(pInfo->pThis, pNode->node.id))
+    else if (hdaCodecIsSpdifInNode(pInfo->pThis, pNode->node.uID))
     {
         CODECDBG_PRINT("SPDIF IN\n");
     }
-    else if (hdaCodecIsDigInPinNode(pInfo->pThis, pNode->node.id))
+    else if (hdaCodecIsDigInPinNode(pInfo->pThis, pNode->node.uID))
     {
         CODECDBG_PRINT("DIGITAL IN PIN\n");
     }
-    else if (hdaCodecIsDigOutPinNode(pInfo->pThis, pNode->node.id))
+    else if (hdaCodecIsDigOutPinNode(pInfo->pThis, pNode->node.uID))
     {
         CODECDBG_PRINT("DIGITAL OUT PIN\n");
     }
-    else if (hdaCodecIsCdNode(pInfo->pThis, pNode->node.id))
+    else if (hdaCodecIsCdNode(pInfo->pThis, pNode->node.uID))
     {
         CODECDBG_PRINT("CD\n");
     }
-    else if (hdaCodecIsVolKnobNode(pInfo->pThis, pNode->node.id))
+    else if (hdaCodecIsVolKnobNode(pInfo->pThis, pNode->node.uID))
     {
         CODECDBG_PRINT("VOLUME KNOB\n");
     }
-    else if (hdaCodecIsReservedNode(pInfo->pThis, pNode->node.id))
+    else if (hdaCodecIsReservedNode(pInfo->pThis, pNode->node.uID))
     {
         CODECDBG_PRINT("RESERVED\n");
     }
     else
-        CODECDBG_PRINT("UNKNOWN TYPE 0x%x\n", pNode->node.id);
+        CODECDBG_PRINT("UNKNOWN TYPE 0x%x\n", pNode->node.uID);
 
     if (fRecursive)
@@ -2853 +2905 @@
         {                                                                          \
             const uint8_t uID = RT_BYTE##_aEntry(_aNode->node.au32F02_param[0x0]); \
-            if (pNode->node.id == uID)                                             \
+            if (pNode->node.uID == uID)                                             \
                 codecDbgPrintNode(pInfo, _aNode, false /* fRecursive */);          \
         }
@@ -2861 +2913 @@
         {
             const PCODECNODE pSubNode = &pInfo->pThis->paNodes[i];
-            if (pSubNode->node.id == pNode->node.id)
+            if (pSubNode->node.uID == pNode->node.uID)
                 continue;
 
@@ -3052 +3104 @@
     for (unsigned idxNode = 0; idxNode < pThis->cTotalNodes; ++idxNode)
     {
-        uint8_t idOld = pThis->paNodes[idxNode].SavedState.Core.id;
+        uint8_t idOld = pThis->paNodes[idxNode].SavedState.Core.uID;
         int rc = SSMR3GetStructEx(pSSM, &pThis->paNodes[idxNode].SavedState,
                                   sizeof(pThis->paNodes[idxNode].SavedState),
@@ -3058 +3110 @@
         if (RT_FAILURE(rc))
             return rc;
-        AssertLogRelMsgReturn(idOld == pThis->paNodes[idxNode].SavedState.Core.id,
-                              ("loaded %#x, expected %#x\n", pThis->paNodes[idxNode].SavedState.Core.id, idOld),
+        AssertLogRelMsgReturn(idOld == pThis->paNodes[idxNode].SavedState.Core.uID,
+                              ("loaded %#x, expected %#x\n", pThis->paNodes[idxNode].SavedState.Core.uID, idOld),
                               VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
     }

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

@@ -97 +97 @@
     DECLR3CALLBACKMEMBER(int, pfnMixerAddStream, (PHDASTATE pThis, PDMAUDIOMIXERCTL enmMixerCtl, PPDMAUDIOSTREAMCFG pCfg));
     DECLR3CALLBACKMEMBER(int, pfnMixerRemoveStream, (PHDASTATE pThis, PDMAUDIOMIXERCTL enmMixerCtl));
+    DECLR3CALLBACKMEMBER(int, pfnMixerSetStream, (PHDASTATE pThis, PDMAUDIOMIXERCTL enmMixerCtl, uint8_t uSD, uint8_t uChannel));
     DECLR3CALLBACKMEMBER(int, pfnMixerSetVolume, (PHDASTATE pThis, PDMAUDIOMIXERCTL enmMixerCtl, PPDMAUDIOVOLUME pVol));
     /** Callbacks by codec implementation. */