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

Timestamp:

Feb 9, 2018 9:51:46 AM (7 years ago)

Author:

vboxsync

Message:

Audio/DrvHostDSound.cpp: Also use the notification thread for capturing audio.

File:

• trunk/src/VBox/Devices/Audio/DrvHostDSound.cpp (modified) (31 diffs)

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

@@ -121 +121 @@
     bool               fEnabled;
     RTCRITSECT         CritSect;
+    PRTCIRCBUF         pCircBuf;
     union
     {
@@ -132 +133 @@
             /** Size (in bytes) of the DirectSound buffer. */
             DWORD                       cbBufSize;
-            HRESULT                     hrLastCapture;
         } In;
         struct
@@ -154 +154 @@
             bool fPendingPlayback;
             bool fPendingClose;
-            PRTCIRCBUF                  pCircBuf;
         } Out;
     };
@@ -236 +235 @@
 static HRESULT  directSoundPlayRestore(PDRVHOSTDSOUND pThis, LPDIRECTSOUNDBUFFER8 pDSB);
 static HRESULT  directSoundPlayStop(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS, bool fFlush);
-static HRESULT  directSoundCaptureStop(PDSOUNDSTREAM pStreamDS);
+static HRESULT  directSoundCaptureStop(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS, bool fFlush);
 
 static void     dsoundDeviceRemove(PDSOUNDDEV pDev);
@@ -586 +585 @@
     DSLOG(("DSound: Closing playback stream\n"));
 
-    if (pStreamDS->Out.pCircBuf)
-        Assert(RTCircBufUsed(pStreamDS->Out.pCircBuf) == 0);
+    if (pStreamDS->pCircBuf)
+        Assert(RTCircBufUsed(pStreamDS->pCircBuf) == 0);
 
     if (SUCCEEDED(hr))
@@ -593 +592 @@
         RTCritSectEnter(&pThis->CritSect);
 
-        if (pStreamDS->Out.pCircBuf)
-        {
-            RTCircBufDestroy(pStreamDS->Out.pCircBuf);
-            pStreamDS->Out.pCircBuf = NULL;
+        if (pStreamDS->pCircBuf)
+        {
+            RTCircBufDestroy(pStreamDS->pCircBuf);
+            pStreamDS->pCircBuf = NULL;
         }
 
@@ -766 +765 @@
         RTCritSectEnter(&pThis->CritSect);
 
-        rc = RTCircBufCreate(&pStreamDS->Out.pCircBuf, pStreamDS->Out.cbBufSize);
+        rc = RTCircBufCreate(&pStreamDS->pCircBuf, pStreamDS->Out.cbBufSize);
         AssertRC(rc);
 
@@ -906 +905 @@
     {
         if (fFlush)
-            RTCircBufReset(pStreamDS->Out.pCircBuf);
+            RTCircBufReset(pStreamDS->pCircBuf);
     }
 
@@ -1069 +1068 @@
 
 
-static HRESULT directSoundCaptureClose(PDSOUNDSTREAM pStreamDS)
-{
+static HRESULT directSoundCaptureClose(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS)
+{
+    AssertPtrReturn(pThis,     E_POINTER);
     AssertPtrReturn(pStreamDS, E_POINTER);
 
     LogFlowFuncEnter();
 
-    HRESULT hr = S_OK;
+    HRESULT hr = directSoundCaptureStop(pThis, pStreamDS, true /* fFlush */);
+    if (FAILED(hr))
+        return hr;
 
     if (   pStreamDS
@@ -1082 +1084 @@
         DSLOG(("DSound: Closing capturing stream\n"));
 
-        hr = directSoundCaptureStop(pStreamDS);
-        if (SUCCEEDED(hr))
-        {
-            IDirectSoundCaptureBuffer8_Release(pStreamDS->In.pDSCB);
-            pStreamDS->In.pDSCB = NULL;
-        }
-        else
-            DSLOGREL(("DSound: Stopping capture buffer failed with %Rhrc\n", hr));
+        IDirectSoundCaptureBuffer8_Release(pStreamDS->In.pDSCB);
+        pStreamDS->In.pDSCB = NULL;
     }
 
@@ -1212 +1208 @@
 
         /* Initial state: reading at the initial capture position, no error. */
-        pStreamDS->In.offReadPos    = offByteReadPos;
+        pStreamDS->In.offReadPos    = 0;
         pStreamDS->In.cbBufSize     = bc.dwBufferBytes;
-        pStreamDS->In.hrLastCapture = S_OK;
-
-        pCfgAcq->cFrameBufferHint = PDMAUDIOSTREAMCFG_B2F(pCfgAcq, bc.dwBufferBytes);
+
+        rc = RTCircBufCreate(&pStreamDS->pCircBuf, pStreamDS->In.cbBufSize);
+        AssertRC(rc);
+
+        /*
+         * Install notification.
+         */
+        LPDIRECTSOUNDNOTIFY8 pNotify;
+        hr = IDirectSoundNotify_QueryInterface(pStreamDS->In.pDSCB, IID_IDirectSoundNotify8, (PVOID *)&pNotify);
+        if (SUCCEEDED(hr))
+        {
+            DSBPOSITIONNOTIFY dsPosNotify[3];
+            RT_ZERO(dsPosNotify);
+
+            dsPosNotify[0].dwOffset     = 0;
+            dsPosNotify[0].hEventNotify = pThis->aEvents[DSOUNDEVENT_INPUT];
+
+            dsPosNotify[1].dwOffset     = float(pStreamDS->In.cbBufSize * 0.3);
+            dsPosNotify[1].hEventNotify = pThis->aEvents[DSOUNDEVENT_INPUT];
+
+            dsPosNotify[2].dwOffset     = float(pStreamDS->In.cbBufSize * 0.6);
+            dsPosNotify[2].hEventNotify = pThis->aEvents[DSOUNDEVENT_INPUT];
+
+            hr = IDirectSoundNotify_SetNotificationPositions(pNotify, 3 /* Count */, dsPosNotify);
+            if (FAILED(hr))
+                DSLOGREL(("DSound: Setting capture position notification failed with %Rhrc\n", hr));
+
+            IDirectSoundNotify_Release(pNotify);
+
+            pThis->pDSStrmIn = pStreamDS;
+        }
+
+        pCfgAcq->cFrameBufferHint = PDMAUDIOSTREAMCFG_B2F(pCfgAcq, pStreamDS->In.cbBufSize);
 
     } while (0);
 
     if (FAILED(hr))
-        directSoundCaptureClose(pStreamDS);
+        directSoundCaptureClose(pThis, pStreamDS);
 
     LogFlowFunc(("Returning %Rhrc\n", hr));
@@ -1228 +1254 @@
 
 
-static HRESULT directSoundCaptureStop(PDSOUNDSTREAM pStreamDS)
-{
+static HRESULT directSoundCaptureStop(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS, bool fFlush)
+{
+    AssertPtrReturn(pThis,     E_POINTER);
     AssertPtrReturn(pStreamDS, E_POINTER);
+
+    RT_NOREF(pThis);
 
     HRESULT hr = S_OK;
@@ -1244 +1273 @@
                 pStreamDS->fEnabled = false;
         }
+    }
+
+    if (SUCCEEDED(hr))
+    {
+        if (fFlush)
+            RTCircBufReset(pStreamDS->pCircBuf);
     }
 
@@ -1609 +1644 @@
 
     uint8_t   *pbBuf    = (uint8_t *)pvBuf;
-    PRTCIRCBUF pCircBuf = pStreamDS->Out.pCircBuf;
+    PRTCIRCBUF pCircBuf = pStreamDS->pCircBuf;
 
     uint32_t cbToPlay = RT_MIN(cxBuf, (uint32_t)RTCircBufFree(pCircBuf));
@@ -1683 +1718 @@
     pStreamDS->In.cbBufSize     = 0;
     pStreamDS->In.pDSCB         = NULL;
-    pStreamDS->In.hrLastCapture = S_OK;
 
     int rc = VINF_SUCCESS;
@@ -1711 +1745 @@
             if (FAILED(hr))
             {
-                hr = directSoundCaptureClose(pStreamDS);
+                hr = directSoundCaptureClose(pThis, pStreamDS);
                 if (SUCCEEDED(hr))
                 {
@@ -1740 +1774 @@
             AssertPtr(pThis->pDSC);
 
-            directSoundCaptureStop(pStreamDS);
+            directSoundCaptureStop(pThis, pStreamDS,
+                                   enmStreamCmd == PDMAUDIOSTREAMCMD_DISABLE /* fFlush */);
 
             /* Return success in any case, as stopping the capture can fail if
@@ -1761 +1796 @@
 }
 
-
 /**
  * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamCapture}
@@ -1777 +1811 @@
     PDSOUNDSTREAM  pStreamDS = (PDSOUNDSTREAM)pStream;
 
-    LPDIRECTSOUNDCAPTUREBUFFER8 pDSCB = pStreamDS->In.pDSCB;
-    AssertPtr(pDSCB);
-
     int rc = VINF_SUCCESS;
 
     uint32_t cbReadTotal = 0;
 
-    do
-    {
-        if (pDSCB == NULL)
-        {
-            rc = VERR_NOT_AVAILABLE;
-            break;
-        }
-
-        /* Get DirectSound capture position in bytes. */
-        DWORD offCurPos;
-        HRESULT hr = IDirectSoundCaptureBuffer_GetCurrentPosition(pDSCB, NULL, &offCurPos);
-        if (FAILED(hr))
-        {
-            if (hr != pStreamDS->In.hrLastCapture)
-            {
-                DSLOGREL(("DSound: Getting capture position failed with %Rhrc\n", hr));
-                pStreamDS->In.hrLastCapture = hr;
-            }
-
-            rc = VERR_NOT_AVAILABLE;
-            break;
-        }
-
-        pStreamDS->In.hrLastCapture = hr;
-
-        if (offCurPos & pStreamDS->uAlign)
-            DSLOGF(("DSound: Misaligned capture read position %ld (alignment: %RU32)\n",
-                    offCurPos, pStreamDS->uAlign + 1));
-
-        /* Number of samples available in the DirectSound capture buffer. */
-        DWORD cbToCapture = dsoundRingDistance(offCurPos, pStreamDS->In.offReadPos, pStreamDS->In.cbBufSize);
-        if (cbToCapture == 0)
-            break;
-
-        if (cxBuf == 0)
-        {
-            DSLOGF(("DSound: Capture buffer full\n"));
-            break;
-        }
-
-        DSLOGF(("DSound: Capture cxBuf=%RU32, offCurPos=%ld, offReadPos=%ld, cbToCapture=%ld\n",
-                cxBuf, offCurPos, pStreamDS->In.offReadPos, cbToCapture));
-
-        /* No need to fetch more samples than mix buffer can receive. */
-        cbToCapture = RT_MIN(cbToCapture, cxBuf);
-
-        /* Lock relevant range in the DirectSound capture buffer. */
-        PVOID pv1, pv2;
-        DWORD cb1, cb2;
-        hr = directSoundCaptureLock(pStreamDS,
-                                    pStreamDS->In.offReadPos,  /* dwOffset */
-                                    cbToCapture,               /* dwBytes */
-                                    &pv1, &pv2, &cb1, &cb2,
-                                    0                          /* dwFlags */);
-        if (FAILED(hr))
-        {
-            rc = VERR_ACCESS_DENIED;
-            break;
-        }
-
-        if (pv1 && cb1)
-        {
-            memcpy((uint8_t *)pvBuf + cbReadTotal, pv1, cb1);
-            cbReadTotal += cb1;
-        }
-
-        if (pv2 && cb2)
-        {
-            memcpy((uint8_t *)pvBuf + cbReadTotal, pv2, cb2);
-            cbReadTotal += cb2;
-        }
-
-        directSoundCaptureUnlock(pDSCB, pv1, pv2, cb1, cb2);
-
-        if (RT_SUCCESS(rc))
-        {
-            pStreamDS->In.offReadPos = (pStreamDS->In.offReadPos + cbReadTotal)
-                                     % pStreamDS->In.cbBufSize;
-            DSLOGF(("DSound: Captured %ld bytes (%RU32 total)\n", cbToCapture, cbReadTotal));
-        }
-
-    } while (0);
+    uint32_t cbToRead = RT_MIN((uint32_t)RTCircBufUsed(pStreamDS->pCircBuf), cxBuf);
+    while (cbToRead)
+    {
+        void   *pvChunk;
+        size_t  cbChunk;
+        RTCircBufAcquireReadBlock(pStreamDS->pCircBuf, cbToRead, &pvChunk, &cbChunk);
+
+        if (cbChunk)
+        {
+            memcpy((uint8_t *)pvBuf + cbReadTotal, pvChunk, cbChunk);
+            cbReadTotal += (uint32_t)cbChunk;
+            Assert(cbToRead >= cbChunk);
+            cbToRead    -= (uint32_t)cbChunk;
+        }
+
+        RTCircBufReleaseReadBlock(pStreamDS->pCircBuf, cbChunk);
+    }
 
     if (RT_SUCCESS(rc))
@@ -1878 +1844 @@
 }
 
-static int dsoundDestroyStreamIn(PDSOUNDSTREAM pStreamDS)
+static int dsoundDestroyStreamIn(PDRVHOSTDSOUND pThis, PDSOUNDSTREAM pStreamDS)
 {
     LogFlowFuncEnter();
 
-    directSoundCaptureClose(pStreamDS);
+    directSoundCaptureClose(pThis, pStreamDS);
 
     return VINF_SUCCESS;
@@ -1974 +1940 @@
                 dwObj -= WAIT_OBJECT_0;
 
-                Log3Func(("Event %ld\n",  dwObj));
-
-                PDSOUNDSTREAM pStreamDS = pThis->pDSStrmOut;
-
-                if (!    pStreamDS
-                    ||  !pStreamDS->fEnabled)
-                    break;
-
                 if (dwObj == DSOUNDEVENT_NOTIFY)
                 {
+                    Log3Func(("Notify\n"));
                 }
                 else if (dwObj == DSOUNDEVENT_INPUT)
                 {
+                    PDSOUNDSTREAM pStreamDS = pThis->pDSStrmIn;
+
+                    if (   !pStreamDS
+                        || !pStreamDS->fEnabled)
+                    {
+                        Log3Func(("Skipping capture\n"));
+                        break;
+                    }
+
+                    LPDIRECTSOUNDCAPTUREBUFFER8 pDSCB = pStreamDS->In.pDSCB;
+                    AssertPtr(pDSCB);
+
+                    DWORD offCaptureCursor;
+                    HRESULT hr = IDirectSoundCaptureBuffer_GetCurrentPosition(pDSCB, NULL, &offCaptureCursor);
+                    if (FAILED(hr))
+                        break;
+
+                    DWORD cbUsed = dsoundRingDistance(offCaptureCursor, pStreamDS->In.offReadPos, pStreamDS->In.cbBufSize);
+
+                    PRTCIRCBUF pCircBuf = pStreamDS->pCircBuf;
+                    AssertPtr(pCircBuf);
+
+                    uint32_t cbFree = (uint32_t)RTCircBufFree(pCircBuf);
+                    if (!cbFree)
+                        DSLOG(("DSound: Warning: Capture buffer full, skipping to record data (%RU32 bytes)\n", cbUsed));
+
+                    DWORD cbToCapture = RT_MIN(cbUsed, cbFree);
+
+                    Log3Func(("cbUsed=%ld, cbToCapture=%ld\n", cbUsed, cbToCapture));
+
+                    while (cbToCapture)
+                    {
+                        void  *pvBuf;
+                        size_t cbBuf;
+                        RTCircBufAcquireWriteBlock(pCircBuf, cbToCapture, &pvBuf, &cbBuf);
+
+                        if (cbBuf)
+                        {
+                            PVOID pv1, pv2;
+                            DWORD cb1, cb2;
+                            hr = directSoundCaptureLock(pStreamDS, pStreamDS->In.offReadPos, (DWORD)cbBuf,
+                                                        &pv1, &pv2, &cb1, &cb2, 0 /* dwFlags */);
+                            if (FAILED(hr))
+                                break;
+
+                            AssertPtr(pv1);
+                            Assert(cb1);
+
+                            memcpy(pvBuf, pv1, cb1);
+
+                            if (pv2 && cb2) /* Buffer wrap-around? Write second part. */
+                                memcpy((uint8_t *)pvBuf + cb1, pv2, cb2);
+
+                            directSoundCaptureUnlock(pDSCB, pv1, pv2, cb1, cb2);
+
+                            pStreamDS->In.offReadPos = (pStreamDS->In.offReadPos + cb1 + cb2) % pStreamDS->In.cbBufSize;
+
+                            Assert(cbToCapture >= cbBuf);
+                            cbToCapture -= (uint32_t)cbBuf;
+                        }
+
+#ifdef VBOX_AUDIO_DEBUG_DUMP_PCM_DATA
+                        if (cbBuf)
+                        {
+                            RTFILE fh;
+                            int rc2 = RTFileOpen(&fh, VBOX_AUDIO_DEBUG_DUMP_PCM_DATA_PATH "dsoundCapture.pcm",
+                                                 RTFILE_O_OPEN_CREATE | RTFILE_O_APPEND | RTFILE_O_WRITE | RTFILE_O_DENY_NONE);
+                            if (RT_SUCCESS(rc2))
+                            {
+                                RTFileWrite(fh, pvBuf, cbBuf, NULL);
+                                RTFileClose(fh);
+                            }
+                        }
+#endif
+                        RTCircBufReleaseWriteBlock(pCircBuf, cbBuf);
+                    }
                 }
                 else if (dwObj == DSOUNDEVENT_OUTPUT)
                 {
+                    PDSOUNDSTREAM pStreamDS = pThis->pDSStrmOut;
+
+                    if (   !pStreamDS
+                        || !pStreamDS->fEnabled)
+                    {
+                        Log3Func(("Skipping playback\n"));
+                        break;
+                    }
+
                     LPDIRECTSOUNDBUFFER8 pDSB = pStreamDS->Out.pDSB;
-                    if (!pDSB)
-                        break;
+                    AssertPtr(pDSB);
 
                     HRESULT hr;
-
-                    DWORD offPlayCursor; DWORD offWriteCursor2;
-                    hr = IDirectSoundBuffer8_GetCurrentPosition(pStreamDS->Out.pDSB, &offPlayCursor, &offWriteCursor2);
-
-                    //Log3Func(("p=%ld, w=%ld\n", offPlayCursor, offWriteCursor2));
 
                     DWORD cbFree, cbRemaining;
@@ -2005 +2043 @@
                     {
                         DWORD offWriteCursor;
-                        hr = IDirectSoundBuffer8_GetCurrentPosition(pStreamDS->Out.pDSB, NULL, &offWriteCursor);
+                        hr = IDirectSoundBuffer8_GetCurrentPosition(pDSB, NULL, &offWriteCursor);
                         if (FAILED(hr))
                             break;
@@ -2017 +2055 @@
                     {
                         DWORD offPlayCursor;
-                        hr = IDirectSoundBuffer8_GetCurrentPosition(pStreamDS->Out.pDSB, &offPlayCursor, NULL);
+                        hr = IDirectSoundBuffer8_GetCurrentPosition(pDSB, &offPlayCursor, NULL);
                         if (FAILED(hr))
                             break;
@@ -2025 +2063 @@
                     }
 
-                    PRTCIRCBUF pCircBuf = pStreamDS->Out.pCircBuf;
+                    PRTCIRCBUF pCircBuf = pStreamDS->pCircBuf;
                     AssertPtr(pCircBuf);
 
                     DWORD cbUsed   = (uint32_t)RTCircBufUsed(pCircBuf);
+                    if (!cbUsed)
+                        DSLOG(("DSound: Warning: No more playback data available within time (%RU32 bytes free)\n", cbFree));
+
                     DWORD cbToPlay = RT_MIN(cbFree, cbUsed);
 
-                    //Log3Func(("cbUsed=%ld, cbToPlay=%ld\n", cbUsed, cbToPlay));
+                    Log3Func(("cbUsed=%ld, cbToPlay=%ld\n", cbUsed, cbToPlay));
 
                     while (cbToPlay)
@@ -2075 +2116 @@
                         for (unsigned i = 0; i < DRV_DSOUND_RESTORE_ATTEMPTS_MAX; i++)
                         {
-                            hr = IDirectSoundBuffer8_Play(pStreamDS->Out.pDSB, 0, 0, fFlags);
+                            hr = IDirectSoundBuffer8_Play(pDSB, 0, 0, fFlags);
                             if (   SUCCEEDED(hr)
                                 || hr != DSERR_BUFFERLOST)
@@ -2082 +2123 @@
                             {
                                 LogFunc(("Restarting playback failed due to lost buffer, restoring ...\n"));
-                                directSoundPlayRestore(pThis, pStreamDS->Out.pDSB);
+                                directSoundPlayRestore(pThis, pDSB);
                             }
                         }
@@ -2099 +2140 @@
                         {
                             DSLOG(("DSound: Stopping playing output\n"));
-                            hr = IDirectSoundBuffer8_Stop(pStreamDS->Out.pDSB);
+                            hr = IDirectSoundBuffer8_Stop(pDSB);
                         }
                     }
@@ -2303 +2344 @@
     int rc;
     if (pStreamDS->pCfg->enmDir == PDMAUDIODIR_IN)
-        rc = dsoundDestroyStreamIn(pStreamDS);
+        rc = dsoundDestroyStreamIn(pThis, pStreamDS);
     else
         rc = dsoundDestroyStreamOut(pThis, pStreamDS);
@@ -2352 +2393 @@
     PDSOUNDSTREAM pStreamDS = (PDSOUNDSTREAM)pStream;
 
-    if (pStreamDS->fEnabled)
-        return UINT32_MAX;
+    if (   pStreamDS->fEnabled
+        && pStreamDS->pCircBuf)
+    {
+        return (uint32_t)RTCircBufUsed(pStreamDS->pCircBuf);
+    }
 
     return 0;
@@ -2370 +2414 @@
 
     if (pStreamDS->fEnabled)
-        return (uint32_t)RTCircBufFree(pStreamDS->Out.pCircBuf);
+        return (uint32_t)RTCircBufFree(pStreamDS->pCircBuf);
 
     return 0;
@@ -2391 +2435 @@
 
         /* Any uncommitted data left? */
-        if (pStreamDS->Out.pCircBuf)
-            cbPending = (uint32_t)RTCircBufUsed(pStreamDS->Out.pCircBuf);
+        if (pStreamDS->pCircBuf)
+            cbPending = (uint32_t)RTCircBufUsed(pStreamDS->pCircBuf);
 
         /* Check if we have committed data which still needs to be played by