Changeset 89466 in vbox for trunk/src/VBox/ValidationKit

Timestamp:

Jun 2, 2021 1:03:44 PM (4 years ago)

Author:

vboxsync

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

144821

Message:

ValKit/AudioTest: Added a 'rec' command. bugref:10008

Location:

trunk/src/VBox/ValidationKit/utils/audio

Files:

• vkat.cpp (modified) (12 diffs)
• vkatDriverStack.cpp (modified) (10 diffs)
• vkatInternal.h (modified) (2 diffs)

trunk/src/VBox/ValidationKit/utils/audio/vkat.cpp

@@ -53 +53 @@
 # include <iprt/win/windows.h> /* for CoInitializeEx */
 #endif
+#include <signal.h>
 
 /**
@@ -391 +392 @@
 AssertCompile(sizeof(g_aBackends) > 0 /* port me */);
 
-static volatile bool g_fTerminated = false;
+
+/** Terminate ASAP if set.  Set on Ctrl-C. */
+static bool volatile    g_fTerminate = false;
 /** The release logger. */
-static PRTLOGGER    g_pRelLogger = NULL;
+static PRTLOGGER        g_pRelLogger = NULL;
 
 
@@ -404 +407 @@
 /** DrvAudio: The debug output path. */
 const char   *g_pszDrvAudioDebug = NULL;
-
 
 
@@ -1292 +1294 @@
         RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "ATS running\n");
 
-        while (!g_fTerminated) /** @todo Implement signal handling. */
+        while (!g_fTerminate) /** @todo Implement signal handling. */
         {
             RTThreadSleep(100);
@@ -1821 +1823 @@
     uint32_t const  cbSamplesAligned = PDMAudioPropsFloorBytesToFrame(pMix->pProps, sizeof(abSamples));
     uint64_t        offStream        = 0;
-    for (;;)
+    while (!g_fTerminate)
     {
         /* Read a chunk from the wave file. */
@@ -1854 +1856 @@
                         }
                         else
-                            return RTMsgErrorExitFailure("Played zero out of %#x bytes - %#x bytes reported playable!\n",
-                                                         cbToPlay, cbCanWrite);
+                            return RTMsgErrorExitFailure("Played zero bytes - %#x bytes reported playable!\n", cbCanWrite);
                     }
                     else
@@ -1959 +1960 @@
                 {
                     if (g_uVerbosity > 0)
-                        RTMsgInfo("Stream: %s cbBacked=%#RX32%s\n", PDMAudioPropsToString(&pStream->Props, szTmp, sizeof(szTmp)),
+                        RTMsgInfo("Stream: %s cbBackend=%#RX32%s\n", PDMAudioPropsToString(&pStream->Props, szTmp, sizeof(szTmp)),
                                   pStream->cbBackend, fWithMixer ? " mixed" : "");
 
@@ -1965 +1966 @@
                      * Enable the stream and start playing.
                      */
-                    rc = audioTestDriverStackStreamEnable(&DrvStack, pStream);
+                    rc = AudioTestMixStreamEnable(&Mix);
                     if (RT_SUCCESS(rc))
                         rcExit = audioTestPlayOneInner(&Mix, &WaveFile, &CfgAcq, pszFile);
@@ -2099 +2100 @@
 
 /*********************************************************************************************************************************
+*   Command: rec                                                                                                                 *
+*********************************************************************************************************************************/
+
+/**
+ * Worker for audioTestRecOne implementing the recording loop.
+ */
+static RTEXITCODE audioTestRecOneInner(PAUDIOTESTDRVMIXSTREAM pMix, PAUDIOTESTWAVEFILE pWaveFile,
+                                       PCPDMAUDIOSTREAMCFG pCfgAcq, uint64_t cMaxFrames, const char *pszFile)
+{
+    int             rc;
+    uint32_t const  cbPreBuffer = PDMAudioPropsFramesToBytes(pMix->pProps, pCfgAcq->Backend.cFramesPreBuffering);
+    uint64_t const  nsStarted   = RTTimeNanoTS();
+
+    /*
+     * Transfer data as quickly as we're allowed.
+     */
+    uint8_t         abSamples[16384];
+    uint32_t const  cbSamplesAligned     = PDMAudioPropsFloorBytesToFrame(pMix->pProps, sizeof(abSamples));
+    uint64_t        cFramesCapturedTotal = 0;
+    while (!g_fTerminate && cFramesCapturedTotal < cMaxFrames)
+    {
+        /*
+         * Anything we can read?
+         */
+        uint32_t const cbCanRead = AudioTestMixStreamGetReadable(pMix);
+        if (cbCanRead)
+        {
+            uint32_t const cbToRead   = RT_MIN(cbCanRead, cbSamplesAligned);
+            uint32_t       cbCaptured = 0;
+            rc = AudioTestMixStreamCapture(pMix, abSamples, cbToRead, &cbCaptured);
+            if (RT_SUCCESS(rc))
+            {
+                if (cbCaptured)
+                {
+                    uint32_t cFramesCaptured = PDMAudioPropsBytesToFrames(pMix->pProps, cbCaptured);
+                    if (cFramesCaptured + cFramesCaptured < cMaxFrames)
+                    { /* likely */ }
+                    else
+                    {
+                        cFramesCaptured = cMaxFrames - cFramesCaptured;
+                        cbCaptured      = PDMAudioPropsFramesToBytes(pMix->pProps, cFramesCaptured);
+                    }
+
+                    rc = AudioTestWaveFileWrite(pWaveFile, abSamples, cbCaptured);
+                    if (RT_SUCCESS(rc))
+                        cFramesCapturedTotal += cFramesCaptured;
+                    else
+                        return RTMsgErrorExitFailure("Error writing to '%s': %Rrc", pszFile, rc);
+                }
+                else
+                    return RTMsgErrorExitFailure("Captured zero bytes - %#x bytes reported readable!\n", cbCanRead);
+            }
+            else
+                return RTMsgErrorExitFailure("Failed to capture %#x bytes: %Rrc (%#x available)\n", cbToRead, rc, cbCanRead);
+        }
+        else if (AudioTestMixStreamIsOkay(pMix))
+            RTThreadSleep(RT_MIN(RT_MAX(1, pCfgAcq->Device.cMsSchedulingHint), 256));
+        else
+            return RTMsgErrorExitFailure("Stream is not okay!\n");
+    }
+
+    /*
+     * Disable the stream.
+     */
+    rc = AudioTestMixStreamDisable(pMix);
+    if (RT_SUCCESS(rc) && g_uVerbosity > 0)
+        RTMsgInfo("%'RU64 ns: Stopped after recording %RU64 frames%s\n", RTTimeNanoTS() - nsStarted, cFramesCapturedTotal,
+                  g_fTerminate ? " - Ctrl-C" : ".");
+    else if (RT_FAILURE(rc))
+        return RTMsgErrorExitFailure("Disabling stream failed: %Rrc", rc);
+
+    return RTEXITCODE_SUCCESS;
+}
+
+
+/**
+ * Worker for audioTestCmdRecHandler that recs one file.
+ */
+static RTEXITCODE audioTestRecOne(const char *pszFile, uint8_t cWaveChannels, uint8_t cbWaveSample, uint32_t uWaveHz,
+                                  PCPDMDRVREG pDrvReg, const char *pszDevId, uint32_t cMsBufferSize,
+                                  uint32_t cMsPreBuffer, uint32_t cMsSchedulingHint,
+                                  uint8_t cChannels, uint8_t cbSample, uint32_t uHz, bool fWithDrvAudio, bool fWithMixer,
+                                  uint64_t cMaxFrames, uint64_t cNsMaxDuration)
+{
+    /*
+     * Construct the driver stack.
+     */
+    RTEXITCODE          rcExit = RTEXITCODE_FAILURE;
+    AUDIOTESTDRVSTACK   DrvStack;
+    int rc = audioTestDriverStackInit(&DrvStack, pDrvReg, fWithDrvAudio);
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * Set the input device if one is specified.
+         */
+        rc = audioTestDriverStackSetDevice(&DrvStack, PDMAUDIODIR_IN, pszDevId);
+        if (RT_SUCCESS(rc))
+        {
+            /*
+             * Create an input stream.
+             */
+            PDMAUDIOPCMPROPS  ReqProps;
+            PDMAudioPropsInit(&ReqProps,
+                              cbSample ? cbSample : cbWaveSample ? cbWaveSample : 2,
+                              true /*fSigned*/,
+                              cChannels ? cChannels : cWaveChannels ? cWaveChannels : 2,
+                              uHz ? uHz : uWaveHz ? uWaveHz : 44100);
+            PDMAUDIOSTREAMCFG CfgAcq;
+            PPDMAUDIOSTREAM   pStream  = NULL;
+            rc = audioTestDriverStackStreamCreateInput(&DrvStack, &ReqProps, cMsBufferSize,
+                                                       cMsPreBuffer, cMsSchedulingHint, &pStream, &CfgAcq);
+            if (RT_SUCCESS(rc))
+            {
+                /*
+                 * Determine the wave file properties.  If it differs from the stream
+                 * properties, make sure the mixer is enabled.
+                 */
+                PDMAUDIOPCMPROPS WaveProps;
+                PDMAudioPropsInit(&WaveProps,
+                                  cbWaveSample ? cbWaveSample : PDMAudioPropsSampleSize(&CfgAcq.Props),
+                                  true /*fSigned*/,
+                                  cWaveChannels ? cWaveChannels : PDMAudioPropsChannels(&CfgAcq.Props),
+                                  uWaveHz ? uWaveHz : PDMAudioPropsHz(&CfgAcq.Props));
+                if (!fWithMixer && !PDMAudioPropsAreEqual(&WaveProps, &CfgAcq.Props))
+                {
+                    RTMsgInfo("Enabling the mixer buffer.\n");
+                    fWithMixer = true;
+                }
+
+                /* Console the max duration into frames now that we've got the wave file format. */
+                if (cMaxFrames != UINT64_MAX && cNsMaxDuration != UINT64_MAX)
+                {
+                    uint64_t cMaxFrames2 = PDMAudioPropsNanoToBytes64(&WaveProps, cNsMaxDuration);
+                    cMaxFrames = RT_MAX(cMaxFrames, cMaxFrames2);
+                }
+                else if (cNsMaxDuration != UINT64_MAX)
+                    cMaxFrames = PDMAudioPropsNanoToBytes64(&WaveProps, cNsMaxDuration);
+
+                /*
+                 * Create a mixer wrapper.  This is just a thin wrapper if fWithMixer
+                 * is false, otherwise it's doing mixing, resampling and recoding.
+                 */
+                AUDIOTESTDRVMIXSTREAM Mix;
+                rc = AudioTestMixStreamInit(&Mix, &DrvStack, pStream, fWithMixer ? &WaveProps : NULL, 100 /*ms*/);
+                if (RT_SUCCESS(rc))
+                {
+                    char szTmp[128];
+                    if (g_uVerbosity > 0)
+                        RTMsgInfo("Stream: %s cbBackend=%#RX32%s\n", PDMAudioPropsToString(&pStream->Props, szTmp, sizeof(szTmp)),
+                                  pStream->cbBackend, fWithMixer ? " mixed" : "");
+
+                    /*
+                     * Open the wave output file.
+                     */
+                    AUDIOTESTWAVEFILE WaveFile;
+                    RTERRINFOSTATIC ErrInfo;
+                    rc = AudioTestWaveFileCreate(pszFile, &WaveProps, &WaveFile, RTErrInfoInitStatic(&ErrInfo));
+                    if (RT_SUCCESS(rc))
+                    {
+                        if (g_uVerbosity > 0)
+                        {
+                            RTMsgInfo("Opened '%s' for playing\n", pszFile);
+                            RTMsgInfo("Format: %s\n", PDMAudioPropsToString(&WaveFile.Props, szTmp, sizeof(szTmp)));
+                        }
+
+                        /*
+                         * Enable the stream and start recording.
+                         */
+                        rc = AudioTestMixStreamEnable(&Mix);
+                        if (RT_SUCCESS(rc))
+                            rcExit = audioTestRecOneInner(&Mix, &WaveFile, &CfgAcq, cMaxFrames, pszFile);
+                        else
+                            rcExit = RTMsgErrorExitFailure("Enabling the input stream failed: %Rrc", rc);
+                        if (rcExit != RTEXITCODE_SUCCESS)
+                            AudioTestMixStreamDisable(&Mix);
+
+                        /*
+                         * Clean up.
+                         */
+                        rc = AudioTestWaveFileClose(&WaveFile);
+                        if (RT_FAILURE(rc))
+                            rcExit = RTMsgErrorExitFailure("Error closing '%s': %Rrc", pszFile, rc);
+                    }
+                    else
+                        rcExit = RTMsgErrorExitFailure("Failed to open '%s': %Rrc%#RTeim", pszFile, rc, &ErrInfo.Core.pszMsg);
+
+                    AudioTestMixStreamTerm(&Mix);
+                }
+                audioTestDriverStackStreamDestroy(&DrvStack, pStream);
+            }
+            else
+                rcExit = RTMsgErrorExitFailure("Creating output stream failed: %Rrc", rc);
+        }
+        else
+            rcExit = RTMsgErrorExitFailure("Failed to set output device to '%s': %Rrc", pszDevId, rc);
+        audioTestDriverStackDelete(&DrvStack);
+    }
+    else
+        rcExit = RTMsgErrorExitFailure("Driver stack construction failed: %Rrc", rc);
+    return rcExit;
+}
+
+/**
+ * Options for 'rec'.
+ */
+static const RTGETOPTDEF g_aCmdRecOptions[] =
+{
+    { "--backend",          'b',                          RTGETOPT_REQ_STRING  },
+    { "--channels",         'c',                          RTGETOPT_REQ_UINT8 },
+    { "--hz",               'f',                          RTGETOPT_REQ_UINT32 },
+    { "--frequency",        'f',                          RTGETOPT_REQ_UINT32 },
+    { "--sample-size",      'z',                          RTGETOPT_REQ_UINT8 },
+    { "--input-device",     'i',                          RTGETOPT_REQ_STRING  },
+    { "--wav-channels",     'C',                          RTGETOPT_REQ_UINT8 },
+    { "--wav-hz",           'F',                          RTGETOPT_REQ_UINT32 },
+    { "--wav-frequency",    'F',                          RTGETOPT_REQ_UINT32 },
+    { "--wav-sample-size",  'Z',                          RTGETOPT_REQ_UINT8 },
+    { "--with-drv-audio",   'd',                          RTGETOPT_REQ_NOTHING },
+    { "--with-mixer",       'm',                          RTGETOPT_REQ_NOTHING },
+    { "--max-frames",       'r',                          RTGETOPT_REQ_UINT64 },
+    { "--max-sec",          's',                          RTGETOPT_REQ_UINT64 },
+    { "--max-seconds",      's',                          RTGETOPT_REQ_UINT64 },
+    { "--max-ms",           't',                          RTGETOPT_REQ_UINT64 },
+    { "--max-milliseconds", 't',                          RTGETOPT_REQ_UINT64 },
+    { "--max-ns",           'T',                          RTGETOPT_REQ_UINT64 },
+    { "--max-nanoseconds",  'T',                          RTGETOPT_REQ_UINT64 },
+};
+
+/** The 'rec' command option help. */
+static DECLCALLBACK(const char *) audioTestCmdRecHelp(PCRTGETOPTDEF pOpt)
+{
+    switch (pOpt->iShort)
+    {
+        case 'b': return "The audio backend to use.";
+        case 'c': return "Number of backend input channels";
+        case 'C': return "Number of wave-file channels";
+        case 'd': return "Go via DrvAudio instead of directly interfacing with the backend.";
+        case 'f': return "Input frequency (Hz)";
+        case 'F': return "Wave-file frequency (Hz)";
+        case 'z': return "Input sample size (bits)";
+        case 'Z': return "Wave-file sample size (bits)";
+        case 'm': return "Go via the mixer.";
+        case 'i': return "The ID of the input device to use.";
+        case 'r': return "Max recording duration in frames.";
+        case 's': return "Max recording duration in seconds.";
+        case 't': return "Max recording duration in milliseconds.";
+        case 'T': return "Max recording duration in nanoseconds.";
+        default:  return NULL;
+    }
+}
+
+/**
+ * The 'play' command handler.
+ *
+ * @returns Program exit code.
+ * @param   pGetState   RTGetOpt state.
+ */
+static DECLCALLBACK(RTEXITCODE) audioTestCmdRecHandler(PRTGETOPTSTATE pGetState)
+{
+    /* Option values: */
+    PCPDMDRVREG pDrvReg             = g_aBackends[0].pDrvReg;
+    uint32_t    cMsBufferSize       = UINT32_MAX;
+    uint32_t    cMsPreBuffer        = UINT32_MAX;
+    uint32_t    cMsSchedulingHint   = UINT32_MAX;
+    const char *pszDevId            = NULL;
+    bool        fWithDrvAudio       = false;
+    bool        fWithMixer          = false;
+    uint8_t     cbSample            = 0;
+    uint8_t     cChannels           = 0;
+    uint32_t    uHz                 = 0;
+    uint8_t     cbWaveSample        = 0;
+    uint8_t     cWaveChannels       = 0;
+    uint32_t    uWaveHz             = 0;
+    uint64_t    cMaxFrames          = UINT64_MAX;
+    uint64_t    cNsMaxDuration      = UINT64_MAX;
+
+    /* Argument processing loop: */
+    int           rc;
+    RTGETOPTUNION ValueUnion;
+    while ((rc = RTGetOpt(pGetState, &ValueUnion)) != 0)
+    {
+        switch (rc)
+        {
+            case 'b':
+                pDrvReg = audioTestFindBackendOpt(ValueUnion.psz);
+                if (pDrvReg == NULL)
+                    return RTEXITCODE_SYNTAX;
+                break;
+
+            case 'c':
+                cChannels = ValueUnion.u8;
+                break;
+
+            case 'C':
+                cWaveChannels = ValueUnion.u8;
+                break;
+
+            case 'd':
+                fWithDrvAudio = true;
+                break;
+
+            case 'f':
+                uHz = ValueUnion.u32;
+                break;
+
+            case 'F':
+                uWaveHz = ValueUnion.u32;
+                break;
+
+            case 'i':
+                pszDevId = ValueUnion.psz;
+                break;
+
+            case 'm':
+                fWithMixer = true;
+                break;
+
+            case 'r':
+                cMaxFrames = ValueUnion.u64;
+                break;
+
+            case 's':
+                cNsMaxDuration = ValueUnion.u64 >= UINT64_MAX / RT_NS_1SEC ? UINT64_MAX : ValueUnion.u64 * RT_NS_1SEC;
+                break;
+
+            case 't':
+                cNsMaxDuration = ValueUnion.u64 >= UINT64_MAX / RT_NS_1MS  ? UINT64_MAX : ValueUnion.u64 * RT_NS_1MS;
+                break;
+
+            case 'T':
+                cNsMaxDuration = ValueUnion.u64;
+                break;
+
+            case 'z':
+                cbSample = ValueUnion.u8 / 8;
+                break;
+
+            case 'Z':
+                cbWaveSample = ValueUnion.u8 / 8;
+                break;
+
+            case VINF_GETOPT_NOT_OPTION:
+            {
+                RTEXITCODE rcExit = audioTestRecOne(ValueUnion.psz, cWaveChannels, cbWaveSample, uWaveHz,
+                                                    pDrvReg, pszDevId, cMsBufferSize, cMsPreBuffer, cMsSchedulingHint,
+                                                    cChannels, cbSample, uHz, fWithDrvAudio, fWithMixer,
+                                                    cMaxFrames, cNsMaxDuration);
+                if (rcExit != RTEXITCODE_SUCCESS)
+                    return rcExit;
+                break;
+            }
+
+            AUDIO_TEST_COMMON_OPTION_CASES(ValueUnion);
+
+            default:
+                return RTGetOptPrintError(rc, &ValueUnion);
+        }
+    }
+    return RTEXITCODE_SUCCESS;
+}
+
+
+/*********************************************************************************************************************************
 *   Command: selftest                                                                                                            *
 *********************************************************************************************************************************/
@@ -2286 +2650 @@
 
 /**
+ * Ctrl-C signal handler.
+ *
+ * This just sets g_fTerminate and hope it will be noticed soon.  It restores
+ * the SIGINT action to default, so that a second Ctrl-C will have the normal
+ * effect (just in case the code doesn't respond to g_fTerminate).
+ */
+static void audioTestSignalHandler(int iSig) RT_NOEXCEPT
+{
+    Assert(iSig == SIGINT); RT_NOREF(iSig);
+    RTPrintf("Ctrl-C!\n");
+    ASMAtomicWriteBool(&g_fTerminate, true);
+    signal(SIGINT, SIG_DFL);
+}
+
+
+/**
  * Commands.
  */
@@ -2324 +2704 @@
         "Plays one or more wave files.",
         g_aCmdPlayOptions,      RT_ELEMENTS(g_aCmdPlayOptions),     audioTestCmdPlayHelp,
+    },
+    {
+        "rec",      audioTestCmdRecHandler,
+        "Records audio to a wave file.",
+        g_aCmdRecOptions,       RT_ELEMENTS(g_aCmdRecOptions),      audioTestCmdRecHelp,
     },
     {
@@ -2430 +2815 @@
 
     /*
+     * Install a Ctrl-C signal handler.
+     */
+#ifdef RT_OS_WINDOWS
+    signal(SIGINT, audioTestSignalHandler);
+#else
+    struct sigaction sa;
+    RT_ZERO(sa);
+    sa.sa_handler = audioTestSignalHandler;
+    sigaction(SIGINT, &sa, NULL);
+#endif
+
+    /*
      * Process common options.
      */

trunk/src/VBox/ValidationKit/utils/audio/vkatDriverStack.cpp

@@ -623 +623 @@
                 {
                     pStreamAt->Core.uMagic     = PDMAUDIOSTREAM_MAGIC;
-                    pStreamAt->Core.enmDir     = PDMAUDIODIR_OUT;
+                    pStreamAt->Core.enmDir     = pCfgReq->enmDir;
                     pStreamAt->Core.cbBackend  = cbStream;
                     pStreamAt->Core.Props      = pCfgReq->Props;
@@ -1044 +1044 @@
     else
     {
-        PAUDIOTESTDRVSTACKSTREAM pStreamAt    = (PAUDIOTESTDRVSTACKSTREAM)pStream;
+        PAUDIOTESTDRVSTACKSTREAM pStreamAt = (PAUDIOTESTDRVSTACKSTREAM)pStream;
         cbWritable = pDrvStack->pIHostAudio->pfnStreamGetWritable(pDrvStack->pIHostAudio, &pStreamAt->Backend);
     }
@@ -1062 +1062 @@
         rc = pDrvStack->pIAudioConnector->pfnStreamPlay(pDrvStack->pIAudioConnector, pStream, pvBuf, cbBuf, pcbPlayed);
         if (RT_FAILURE(rc))
-            RTTestFailed(g_hTest, "pfnStreamPlay(,,,%#x) failed: %Rrc", cbBuf, rc);
+            RTTestFailed(g_hTest, "pfnStreamPlay(,,,%#x,) failed: %Rrc", cbBuf, rc);
     }
     else
@@ -1069 +1069 @@
         rc = pDrvStack->pIHostAudio->pfnStreamPlay(pDrvStack->pIHostAudio, &pStreamAt->Backend, pvBuf, cbBuf, pcbPlayed);
         if (RT_FAILURE(rc))
-            RTTestFailed(g_hTest, "PDMIHOSTAUDIO::pfnStreamPlay(,,,%#x) failed: %Rrc", cbBuf, rc);
+            RTTestFailed(g_hTest, "PDMIHOSTAUDIO::pfnStreamPlay(,,,%#x,) failed: %Rrc", cbBuf, rc);
     }
     return rc;
+}
+
+
+/**
+ * Gets the number of bytes it's currently possible to write to the stream.
+ */
+uint32_t audioTestDriverStackStreamGetReadable(PAUDIOTESTDRVSTACK pDrvStack, PPDMAUDIOSTREAM pStream)
+{
+    uint32_t cbReadable;
+    if (pDrvStack->pIAudioConnector)
+        cbReadable = pDrvStack->pIAudioConnector->pfnStreamGetReadable(pDrvStack->pIAudioConnector, pStream);
+    else
+    {
+        PAUDIOTESTDRVSTACKSTREAM pStreamAt = (PAUDIOTESTDRVSTACKSTREAM)pStream;
+        cbReadable = pDrvStack->pIHostAudio->pfnStreamGetReadable(pDrvStack->pIHostAudio, &pStreamAt->Backend);
+    }
+    return cbReadable;
 }
 
@@ -1086 +1103 @@
         rc = pDrvStack->pIAudioConnector->pfnStreamCapture(pDrvStack->pIAudioConnector, pStream, pvBuf, cbBuf, pcbCaptured);
         if (RT_FAILURE(rc))
-            RTTestFailed(g_hTest, "pfnStreamCapture(,,,%#x) failed: %Rrc", cbBuf, rc);
+            RTTestFailed(g_hTest, "pfnStreamCapture(,,,%#x,) failed: %Rrc", cbBuf, rc);
     }
     else
@@ -1093 +1110 @@
         rc = pDrvStack->pIHostAudio->pfnStreamCapture(pDrvStack->pIHostAudio, &pStreamAt->Backend, pvBuf, cbBuf, pcbCaptured);
         if (RT_FAILURE(rc))
-            RTTestFailed(g_hTest, "PDMIHOSTAUDIO::pfnStreamCapture(,,,%#x) failed: %Rrc", cbBuf, rc);
+            RTTestFailed(g_hTest, "PDMIHOSTAUDIO::pfnStreamCapture(,,,%#x,) failed: %Rrc", cbBuf, rc);
     }
     return rc;
@@ -1249 +1266 @@
 
 /**
+ * Same as audioTestDriverStackStreamEnable.
+ */
+int AudioTestMixStreamEnable(PAUDIOTESTDRVMIXSTREAM pMix)
+{
+    return audioTestDriverStackStreamEnable(pMix->pDrvStack, pMix->pStream);
+}
+
+
+/**
  * Same as audioTestDriverStackStreamDrain.
  */
@@ -1272 +1298 @@
 }
 
-
-/**
- * Same as audioTestDriverStackStreamEnable.
- */
-int AudioTestMixStreamEnable(PAUDIOTESTDRVMIXSTREAM pMix)
-{
-    return audioTestDriverStackStreamEnable(pMix->pDrvStack, pMix->pStream);
+/**
+ * Same as audioTestDriverStackStreamDisable.
+ */
+int AudioTestMixStreamDisable(PAUDIOTESTDRVMIXSTREAM pMix)
+{
+    return AudioTestDriverStackStreamDisable(pMix->pDrvStack, pMix->pStream);
+}
+
+
+/**
+ * Same as audioTestDriverStackStreamIsOkay.
+ */
+bool AudioTestMixStreamIsOkay(PAUDIOTESTDRVMIXSTREAM pMix)
+{
+    return audioTestDriverStackStreamIsOkay(pMix->pDrvStack, pMix->pStream);
 }
 
@@ -1299 +1333 @@
 
 
-/**
- * Same as audioTestDriverStackStreamIsOkay.
- */
-bool AudioTestMixStreamIsOkay(PAUDIOTESTDRVMIXSTREAM pMix)
-{
-    return audioTestDriverStackStreamIsOkay(pMix->pDrvStack, pMix->pStream);
-}
 
 
@@ -1349 +1376 @@
 }
 
+
+/**
+ * Same as audioTestDriverStackStreamGetReadable
+ */
+uint32_t AudioTestMixStreamGetReadable(PAUDIOTESTDRVMIXSTREAM pMix)
+{
+    if (!pMix->fDoMixing)
+        return audioTestDriverStackStreamGetReadable(pMix->pDrvStack, pMix->pStream);
+
+    audioTestMixStreamTransfer(pMix);
+    uint32_t cbRet = AudioMixBufUsedBytes(&pMix->MixBuf);
+    return cbRet;
+}
+
+
+
+
+/**
+ * Same as audioTestDriverStackStreamCapture.
+ */
+int AudioTestMixStreamCapture(PAUDIOTESTDRVMIXSTREAM pMix, void *pvBuf, uint32_t cbBuf, uint32_t *pcbCaptured)
+{
+    if (!pMix->fDoMixing)
+        return audioTestDriverStackStreamCapture(pMix->pDrvStack, pMix->pStream, pvBuf, cbBuf, pcbCaptured);
+
+    *pcbCaptured = 0;
+
+    int rc = audioTestMixStreamTransfer(pMix);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    uint32_t const cbFrame = PDMAudioPropsFrameSize(&pMix->MixBuf.Props);
+    while (cbBuf >= cbFrame)
+    {
+        uint32_t const cFrames = AudioMixBufUsed(&pMix->MixBuf);
+        if (!cFrames)
+            break;
+        uint32_t cbToRead = PDMAudioPropsFramesToBytes(&pMix->MixBuf.Props, cFrames);
+        cbToRead = RT_MIN(cbToRead, cbBuf);
+        cbToRead = PDMAudioPropsFloorBytesToFrame(&pMix->MixBuf.Props, cbToRead);
+
+        uint32_t cFramesPeeked = 0;
+        uint32_t cbPeeked      = 0;
+        AudioMixBufPeek(&pMix->MixBuf, 0 /*offSrcFrame*/, cFrames, &cFramesPeeked, &pMix->PeekState, pvBuf, cbToRead, &cbPeeked);
+        Assert(cFramesPeeked == PDMAudioPropsBytesToFrames(&pMix->MixBuf.Props, cbPeeked));
+        AudioMixBufAdvance(&pMix->MixBuf, cFramesPeeked);
+
+        *pcbCaptured += cbToRead;
+        cbBuf        -= cbToRead;
+        pvBuf         = (uint8_t *)pvBuf + cbToRead;
+
+        rc = audioTestMixStreamTransfer(pMix);
+        if (RT_FAILURE(rc))
+            return *pcbCaptured ? VINF_SUCCESS : rc;
+    }
+
+    return VINF_SUCCESS;
+}
+

trunk/src/VBox/ValidationKit/utils/audio/vkatInternal.h

@@ -130 +130 @@
 int         audioTestDriverStackStreamDrain(PAUDIOTESTDRVSTACK pDrvStack, PPDMAUDIOSTREAM pStream, bool fSync);
 int         audioTestDriverStackStreamEnable(PAUDIOTESTDRVSTACK pDrvStack, PPDMAUDIOSTREAM pStream);
-int         audioTestDriverStackStreamDisable(PAUDIOTESTDRVSTACK pDrvStack, PPDMAUDIOSTREAM pStream);
+int         AudioTestDriverStackStreamDisable(PAUDIOTESTDRVSTACK pDrvStack, PPDMAUDIOSTREAM pStream);
+bool        audioTestDriverStackStreamIsOkay(PAUDIOTESTDRVSTACK pDrvStack, PPDMAUDIOSTREAM pStream);
 uint32_t    audioTestDriverStackStreamGetWritable(PAUDIOTESTDRVSTACK pDrvStack, PPDMAUDIOSTREAM pStream);
-bool        audioTestDriverStackStreamIsOkay(PAUDIOTESTDRVSTACK pDrvStack, PPDMAUDIOSTREAM pStream);
 int         audioTestDriverStackStreamPlay(PAUDIOTESTDRVSTACK pDrvStack, PPDMAUDIOSTREAM pStream, void const *pvBuf,
                                            uint32_t cbBuf, uint32_t *pcbPlayed);
+uint32_t    audioTestDriverStackStreamGetReadable(PAUDIOTESTDRVSTACK pDrvStack, PPDMAUDIOSTREAM pStream);
 int         audioTestDriverStackStreamCapture(PAUDIOTESTDRVSTACK pDrvStack, PPDMAUDIOSTREAM pStream,
                                               void *pvBuf, uint32_t cbBuf, uint32_t *pcbCaptured);
@@ -145 +146 @@
                                    PCPDMAUDIOPCMPROPS pProps, uint32_t cMsBuffer);
 void        AudioTestMixStreamTerm(PAUDIOTESTDRVMIXSTREAM pMix);
+int         AudioTestMixStreamEnable(PAUDIOTESTDRVMIXSTREAM pMix);
 int         AudioTestMixStreamDrain(PAUDIOTESTDRVMIXSTREAM pMix, bool fSync);
-int         AudioTestMixStreamEnable(PAUDIOTESTDRVMIXSTREAM pMix);
+int         AudioTestMixStreamDisable(PAUDIOTESTDRVMIXSTREAM pMix);
+bool        AudioTestMixStreamIsOkay(PAUDIOTESTDRVMIXSTREAM pMix);
 uint32_t    AudioTestMixStreamGetWritable(PAUDIOTESTDRVMIXSTREAM pMix);
-bool        AudioTestMixStreamIsOkay(PAUDIOTESTDRVMIXSTREAM pMix);
 int         AudioTestMixStreamPlay(PAUDIOTESTDRVMIXSTREAM pMix, void const *pvBuf, uint32_t cbBuf, uint32_t *pcbPlayed);
+uint32_t    AudioTestMixStreamGetReadable(PAUDIOTESTDRVMIXSTREAM pMix);
 int         AudioTestMixStreamCapture(PAUDIOTESTDRVMIXSTREAM pMix, void *pvBuf, uint32_t cbBuf, uint32_t *pcbCaptured);
 /** @}  */