Changeset 96260 in vbox

Timestamp:

Aug 17, 2022 12:02:46 PM (3 years ago)

Author:

vboxsync

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

153072

Message:

Recording/Main: Greatly reduced workload spent in the recording driver's async I/O thread by also encoding the audio data in the dedicated recording thread (using two different block maps, see comments for details). bugref:10275

Location:

trunk/src/VBox/Main

Files:

• include/Recording.h (modified) (2 diffs)
• include/RecordingStream.h (modified) (1 diff)
• src-client/DrvAudioRec.cpp (modified) (15 diffs)
• src-client/Recording.cpp (modified) (13 diffs)
• src-client/RecordingStream.cpp (modified) (2 diffs)

trunk/src/VBox/Main/include/Recording.h

@@ -83 +83 @@
     RecordingStream *getStreamInternal(unsigned uScreen) const;
 
-    int writeCommonData(PRECORDINGCODEC pCodec, const void *pvData, size_t cbData, uint64_t msAbsPTS, uint32_t uFlags);
+    int processCommonData(RecordingBlockMap &mapCommon, RTMSINTERVAL msTimeout);
+    int writeCommonData(RecordingBlockMap &mapCommon, PRECORDINGCODEC pCodec, const void *pvData, size_t cbData, uint64_t msAbsPTS, uint32_t uFlags);
 
     int lock(void);
@@ -145 +146 @@
     RECORDINGCODEC               CodecAudio;
 #endif /* VBOX_WITH_AUDIO_RECORDING */
-    /** Block map of common blocks which need to get multiplexed
-     *  to all recording streams. This common block maps should help
-     *  reducing the time spent in EMT and avoid doing the (expensive)
-     *  multiplexing work in there.
+    /** Block map of raw common data blocks which need to get encoded first. */
+    RecordingBlockMap            mapBlocksRaw;
+    /** Block map of encoded common blocks.
+     *
+     *  Only do the encoding of common data blocks only once and then multiplex
+     *  the encoded data to all affected recording streams.
+     *
+     *  This avoids doing the (expensive) encoding + multiplexing work in other
+     *  threads like EMT / audio async I/O..
      *
      *  For now this only affects audio, e.g. all recording streams
      *  need to have the same audio data at a specific point in time. */
-    RecordingBlockMap            mapBlocksCommon;
+    RecordingBlockMap            mapBlocksEncoded;
 };
 #endif /* !MAIN_INCLUDED_Recording_h */

trunk/src/VBox/Main/include/RecordingStream.h

@@ -120 +120 @@
 
     int Process(RecordingBlockMap &mapBlocksCommon);
+    int SendAudioFrame(const void *pvData, size_t cbData, uint64_t msTimestamp);
     int SendVideoFrame(uint32_t x, uint32_t y, uint32_t uPixelFormat, uint32_t uBPP, uint32_t uBytesPerLine,
                        uint32_t uSrcWidth, uint32_t uSrcHeight, uint8_t *puSrcData, uint64_t msTimestamp);

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

@@ -171 +171 @@
 typedef struct AVRECSINK
 {
-    /** Pointer (weak) to audio codec to use. */
-    PRECORDINGCODEC      pCodec;
+    /** Pointer (weak) to recording stream to bind to. */
+    RecordingStream     *pRecStream;
     /** Container data to use for data processing. */
     AVRECCONTAINER       Con;
@@ -323 +323 @@
  */
 static int avRecCreateStreamOut(PDRVAUDIORECORDING pThis, PAVRECSTREAM pStreamAV,
-                                PAVRECSINK pSink, PRECORDINGCODEC pCodec, PCPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
+                                PAVRECSINK pSink, PCPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
 {
     AssertPtrReturn(pThis,     VERR_INVALID_POINTER);
     AssertPtrReturn(pStreamAV, VERR_INVALID_POINTER);
     AssertPtrReturn(pSink,     VERR_INVALID_POINTER);
-    AssertPtrReturn(pCodec,    VERR_INVALID_POINTER);
     AssertPtrReturn(pCfgReq,   VERR_INVALID_POINTER);
     AssertPtrReturn(pCfgAcq,   VERR_INVALID_POINTER);
@@ -338 +337 @@
         return VERR_NOT_SUPPORTED;
     }
+
+    PRECORDINGCODEC pCodec = pSink->pRecStream->GetAudioCodec();
 
     /* Stuff which has to be set by now. */
@@ -357 +358 @@
             /* Make sure to let the driver backend know that we need the audio data in
              * a specific sampling rate the codec is optimized for. */
-/** @todo r=bird: pCfgAcq->Props isn't initialized at all, except for uHz... */
-            pCfgAcq->Props.uHz         = pCodec->Parms.Audio.PCMProps.uHz;
-//                pCfgAcq->Props.cShift      = PDMAUDIOPCMPROPS_MAKE_SHIFT_PARMS(pCfgAcq->Props.cbSample, pCfgAcq->Props.cChannels);
-
-            /* Every Opus frame marks a period for now. Optimize this later. */
+            pCfgAcq->Props = pCodec->Parms.Audio.PCMProps;
+
+            /* Every codec frame marks a period for now. Optimize this later. */
             pCfgAcq->Backend.cFramesPeriod       = PDMAudioPropsMilliToFrames(&pCfgAcq->Props, pCodec->Parms.msFrame);
-            pCfgAcq->Backend.cFramesBufferSize   = PDMAudioPropsMilliToFrames(&pCfgAcq->Props, 100 /*ms*/); /** @todo Make this configurable. */
-            pCfgAcq->Backend.cFramesPreBuffering = pCfgAcq->Backend.cFramesPeriod * 2;
+            pCfgAcq->Backend.cFramesBufferSize   = pCfgAcq->Backend.cFramesPeriod * 2;
+            pCfgAcq->Backend.cFramesPreBuffering = pCfgAcq->Backend.cFramesPeriod;
         }
         else
@@ -394 +393 @@
     PAVRECSINK pSink = &pThis->Sink;
 
-    int vrc = avRecCreateStreamOut(pThis, pStreamAV, pSink, pSink->pCodec, pCfgReq, pCfgAcq);
+    int vrc = avRecCreateStreamOut(pThis, pStreamAV, pSink, pCfgReq, pCfgAcq);
     PDMAudioStrmCfgCopy(&pStreamAV->Cfg, pCfgAcq);
 
@@ -516 +515 @@
 static DECLCALLBACK(uint32_t) drvAudioVideoRecHA_StreamGetWritable(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
 {
-    RT_NOREF(pInterface, pStream);
-    return UINT32_MAX;
+    RT_NOREF(pInterface);
+    PAVRECSTREAM pStreamAV = (PAVRECSTREAM)pStream;
+
+    RecordingStream *pRecStream = pStreamAV->pSink->pRecStream;
+    PRECORDINGCODEC  pCodec     = pRecStream->GetAudioCodec();
+
+    return pCodec->Parms.cbFrame;
 }
 
@@ -540 +544 @@
     PAVRECSINK pSink       = pStreamAV->pSink;
     AssertPtr(pSink);
-    PRECORDINGCODEC pCodec = pSink->pCodec;
-    AssertPtr(pCodec);
     PRTCIRCBUF pCircBuf    = pStreamAV->pCircBuf;
     AssertPtr(pCircBuf);
 
-    uint32_t cbToWrite = cbBuf;
+    uint32_t cbToWrite = RT_MIN(cbBuf, RTCircBufFree(pCircBuf));
+    AssertReturn(cbToWrite, VERR_BUFFER_OVERFLOW);
 
     /*
      * Write as much as we can into our internal ring buffer.
      */
-    while (   cbToWrite > 0
-           && RTCircBufFree(pCircBuf))
+    while (cbToWrite)
     {
         void  *pvCircBuf = NULL;
@@ -557 +559 @@
         RTCircBufAcquireWriteBlock(pCircBuf, cbToWrite, &pvCircBuf, &cbCircBuf);
 
-        if (cbCircBuf)
-        {
-            memcpy(pvCircBuf, (uint8_t *)pvBuf + cbWrittenTotal, cbCircBuf),
-            cbWrittenTotal += (uint32_t)cbCircBuf;
-            Assert(cbToWrite >= cbCircBuf);
-            cbToWrite      -= (uint32_t)cbCircBuf;
-        }
+        Log3Func(("cbToWrite=%RU32, cbCircBuf=%zu\n", cbToWrite, cbCircBuf));
+
+        memcpy(pvCircBuf, (uint8_t *)pvBuf + cbWrittenTotal, cbCircBuf),
+        cbWrittenTotal += (uint32_t)cbCircBuf;
+        Assert(cbWrittenTotal <= cbBuf);
+        Assert(cbToWrite >= cbCircBuf);
+        cbToWrite      -= (uint32_t)cbCircBuf;
 
         RTCircBufReleaseWriteBlock(pCircBuf, cbCircBuf);
-        AssertBreak(cbCircBuf);
-    }
-
-    /*
-     * Process our internal ring buffer and encode the data.
-     */
-
-    /* Only encode data if we have data for at least one full frame. */
-    while (RTCircBufUsed(pCircBuf) >= pCodec->Parms.cbFrame)
-    {
-        LogFunc(("cbAvail=%zu, csFrame=%RU32, cbFrame=%RU32\n",
-                 RTCircBufUsed(pCircBuf), pCodec->Parms.csFrame, pCodec->Parms.cbFrame));
-
-        /** @todo Can we encode more than a frame at a time? Optimize this! */
-        uint32_t const cbFramesToEncode = pCodec->Parms.cbFrame; /* 1 frame. */
-
+    }
+
+    RecordingStream *pRecStream = pStreamAV->pSink->pRecStream;
+    PRECORDINGCODEC  pCodec     = pRecStream->GetAudioCodec();
+
+    /*
+     * Process our internal ring buffer and send the obtained audio data to our encoding thread.
+     */
+    cbToWrite = RTCircBufUsed(pCircBuf);
+
+    /** @todo Can we encode more than a frame at a time? Optimize this! */
+    uint32_t const cbFrame = pCodec->Parms.cbFrame;
+
+    /* Only encode data if we have data for at least one full codec frame. */
+    while (cbToWrite >= cbFrame)
+    {
         uint32_t cbSrc = 0;
-        while (cbSrc < cbFramesToEncode)
+        do
         {
             void  *pvCircBuf = NULL;
             size_t cbCircBuf = 0;
-            RTCircBufAcquireReadBlock(pCircBuf, cbFramesToEncode - cbSrc, &pvCircBuf, &cbCircBuf);
-
-            if (cbCircBuf)
+            RTCircBufAcquireReadBlock(pCircBuf, cbFrame - cbSrc, &pvCircBuf, &cbCircBuf);
+
+            Log3Func(("cbSrc=%RU32, cbCircBuf=%zu\n", cbSrc, cbCircBuf));
+
+            memcpy((uint8_t *)pStreamAV->pvSrcBuf + cbSrc, pvCircBuf, cbCircBuf);
+
+            cbSrc += (uint32_t)cbCircBuf;
+            Assert(cbSrc <= pStreamAV->cbSrcBuf);
+            Assert(cbSrc <= cbFrame);
+
+            RTCircBufReleaseReadBlock(pCircBuf, cbCircBuf);
+
+            if (cbSrc == cbFrame) /* Only send full codec frames. */
             {
-                memcpy((uint8_t *)pStreamAV->pvSrcBuf + cbSrc, pvCircBuf, cbCircBuf);
-
-                cbSrc += (uint32_t)cbCircBuf;
-                Assert(cbSrc <= pStreamAV->cbSrcBuf);
+                vrc = pRecStream->SendAudioFrame(pStreamAV->pvSrcBuf, cbSrc, 0);
+                if (RT_FAILURE(vrc))
+                    break;
             }
 
-            RTCircBufReleaseReadBlock(pCircBuf, cbCircBuf);
-            AssertBreak(cbCircBuf);
-        }
-
-        Assert(cbSrc == cbFramesToEncode);
-
-        RECORDINGFRAME Frame;
-        Frame.Audio.cbBuf = cbFramesToEncode;
-        Frame.Audio.pvBuf = (uint8_t *)pStreamAV->pvSrcBuf;
-
-        size_t cEncoded /* Blocks encoded */, cbEncoded /* Bytes encoded */;
-        vrc = recordingCodecEncode(pSink->pCodec,
-                                   /* Source */
-                                   &Frame, &cEncoded, &cbEncoded);
-        if (   RT_SUCCESS(vrc)
-            && cEncoded)
-        {
-            Assert(cbEncoded);
-        }
-        else if (RT_FAILURE(vrc)) /* Something went wrong -- report all bytes as being processed, to not hold up others. */
-            cbWrittenTotal = cbBuf;
+        } while (cbSrc < cbFrame);
+
+        Assert(cbToWrite >= cbFrame);
+        cbToWrite -= cbFrame;
 
         if (RT_FAILURE(vrc))
@@ -626 +620 @@
     *pcbWritten = cbWrittenTotal;
 
-    LogFlowFunc(("csReadTotal=%RU32, vrc=%Rrc\n", cbWrittenTotal, vrc));
+    LogFlowFunc(("cbBuf=%RU32, cbWrittenTotal=%RU32, vrc=%Rrc\n", cbBuf, cbWrittenTotal, vrc));
     return VINF_SUCCESS; /* Don't propagate encoding errors to the caller. */
 }
@@ -685 +679 @@
     AssertPtrReturnVoid(pSink);
 
-    pSink->pCodec = NULL;
+    pSink->pRecStream = NULL;
 
     switch (pSink->Con.Parms.enmType)
@@ -768 +762 @@
  * @param   pSink               Sink to initialize.
  * @param   pConParms           Container parameters to set.
- * @param   pCodec              Codec to use.
- */
-static int avRecSinkInit(PDRVAUDIORECORDING pThis, PAVRECSINK pSink, PAVRECCONTAINERPARMS pConParms, PRECORDINGCODEC pCodec)
-{
-    AssertReturn(pCodec->Parms.enmType == RECORDINGCODECTYPE_AUDIO, VERR_INVALID_PARAMETER);
+ * @param   pStream             Recording stream to asssign sink to.
+ */
+static int avRecSinkInit(PDRVAUDIORECORDING pThis, PAVRECSINK pSink, PAVRECCONTAINERPARMS pConParms, RecordingStream *pStream)
+{
+    pSink->pRecStream = pStream;
 
     int vrc = VINF_SUCCESS;
-
-    pSink->pCodec = pCodec;
 
     /*
@@ -798 +790 @@
             case AVRECCONTAINERTYPE_WEBM:
             {
+        #if 0
                 /* If we only record audio, create our own WebM writer instance here. */
                 if (!pSink->Con.WebM.pWebM) /* Do we already have our WebM writer instance? */
@@ -828 +821 @@
                 }
                 break;
+        #endif
             }
 
@@ -948 +942 @@
      * Obtain the recording context.
      */
-    pThis->pRecCtx =  pConsole->i_recordingGetContext();
+    pThis->pRecCtx = pConsole->i_recordingGetContext();
     AssertPtrReturn(pThis->pRecCtx, VERR_INVALID_POINTER);
 
@@ -957 +951 @@
     AssertPtrReturn(pStream, VERR_INVALID_POINTER);
 
-    const PRECORDINGCODEC pCodec = pStream->GetAudioCodec();
-    AssertPtrReturn(pCodec, VERR_INVALID_POINTER);
-
     /*
      * Init the recording sink.
      */
-    vrc = avRecSinkInit(pThis, &pThis->Sink, &pThis->ContainerParms, pCodec);
+    vrc = avRecSinkInit(pThis, &pThis->Sink, &pThis->ContainerParms, pStream);
     if (RT_SUCCESS(vrc))
         LogRel2(("Recording: Audio recording driver initialized\n"));

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

@@ -115 +115 @@
     RTThreadUserSignal(hThreadSelf);
 
-    LogFunc(("Thread started\n"));
+    LogRel2(("Recording: Thread started\n"));
 
     for (;;)
@@ -123 +123 @@
 
         Log2Func(("Processing %zu streams\n", pThis->vecStreams.size()));
+
+        /* Process common raw blocks (data which not has been encoded yet). */
+        vrc = pThis->processCommonData(pThis->mapBlocksRaw, 100 /* ms timeout */);
 
         /** @todo r=andy This is inefficient -- as we already wake up this thread
@@ -132 +135 @@
             RecordingStream *pStream = (*itStream);
 
-            vrc = pStream->Process(pThis->mapBlocksCommon);
+            /* Hand-in common encoded blocks. */
+            vrc = pStream->Process(pThis->mapBlocksEncoded);
             if (RT_FAILURE(vrc))
             {
@@ -155 +159 @@
     } /* for */
 
-    LogFunc(("Thread ended\n"));
+    LogRel2(("Recording: Thread ended\n"));
     return VINF_SUCCESS;
 }
@@ -170 +174 @@
 
 /**
- * Writes block data which are common (shared) between all streams.
- *
- * To save time spent in EMT or other important threads (such as audio async I/O),
- * do the required audio multiplexing in the encoding thread.
+ * Worker function for processing common block data.
+ *
+ * @returns VBox status code.
+ * @param   mapCommon           Common block map to handle.
+ * @param   msTimeout           Timeout to use for maximum time spending to process data.
+ *                              Use RT_INDEFINITE_WAIT for processing all data.
+ *
+ * @note    Runs in recording thread.
+ */
+int RecordingContext::processCommonData(RecordingBlockMap &mapCommon, RTMSINTERVAL msTimeout)
+{
+    Log2Func(("Processing %zu common blocks (%RU32ms timeout)\n", mapCommon.size(), msTimeout));
+
+    int vrc = VINF_SUCCESS;
+
+    uint64_t const msStart = RTTimeMilliTS();
+    RecordingBlockMap::iterator itCommonBlocks = mapCommon.begin();
+    while (itCommonBlocks != mapCommon.end())
+    {
+        RecordingBlockList::iterator itBlock = itCommonBlocks->second->List.begin();
+        while (itBlock != itCommonBlocks->second->List.end())
+        {
+            RecordingBlock *pBlockCommon = (RecordingBlock *)(*itBlock);
+            switch (pBlockCommon->enmType)
+            {
+#ifdef VBOX_WITH_AUDIO_RECORDING
+                case RECORDINGBLOCKTYPE_AUDIO:
+                {
+                    PRECORDINGAUDIOFRAME pAudioFrame = (PRECORDINGAUDIOFRAME)pBlockCommon->pvData;
+
+                    RECORDINGFRAME Frame;
+                    Frame.msTimestamp = pBlockCommon->msTimestamp;
+                    Frame.Audio.pvBuf = pAudioFrame->pvBuf;
+                    Frame.Audio.cbBuf = pAudioFrame->cbBuf;
+
+                    vrc = recordingCodecEncode(&this->CodecAudio, &Frame, NULL, NULL);
+                    break;
+                }
+#endif /* VBOX_WITH_AUDIO_RECORDING */
+                default:
+                    /* Skip unknown stuff. */
+                    break;
+            }
+
+            itCommonBlocks->second->List.erase(itBlock);
+            delete pBlockCommon;
+            itBlock = itCommonBlocks->second->List.begin();
+
+            if (RT_FAILURE(vrc) || RTTimeMilliTS() > msStart + msTimeout)
+                break;
+        }
+
+        /* If no entries are left over in the block map, remove it altogether. */
+        if (itCommonBlocks->second->List.empty())
+        {
+            delete itCommonBlocks->second;
+            mapCommon.erase(itCommonBlocks);
+            itCommonBlocks = mapCommon.begin();
+        }
+        else
+            ++itCommonBlocks;
+
+        if (RT_FAILURE(vrc))
+            break;
+    }
+
+    return vrc;
+}
+
+/**
+ * Writes common block data (i.e. shared / the same) in all streams.
  *
  * The multiplexing is needed to supply all recorded (enabled) screens with the same
@@ -179 +250 @@
  *
  * Currently this only is being used for audio data.
- */
-int RecordingContext::writeCommonData(PRECORDINGCODEC pCodec, const void *pvData, size_t cbData,
-                                      uint64_t msAbsPTS, uint32_t uFlags)
+ *
+ * @returns VBox status code.
+ * @param   mapCommon       Common block map to write data to.
+ * @param   pCodec          Pointer to codec instance which has written the data.
+ * @param   pvData          Pointer to written data (encoded).
+ * @param   cbData          Size (in bytes) of \a pvData.
+ * @param   msTimestamp     Absolute PTS (in ms) of the written data.
+ * @param   uFlags          Encoding flags of type RECORDINGCODEC_ENC_F_XXX.
+ */
+int RecordingContext::writeCommonData(RecordingBlockMap &mapCommon, PRECORDINGCODEC pCodec, const void *pvData, size_t cbData,
+                                      uint64_t msTimestamp, uint32_t uFlags)
 {
     AssertPtrReturn(pvData, VERR_INVALID_POINTER);
     AssertReturn(cbData, VERR_INVALID_PARAMETER);
 
-    LogFlowFunc(("pCodec=%p, cbData=%zu, msAbsPTS=%zu, uFlags=%#x\n",
-                 pCodec, cbData, msAbsPTS, uFlags));
+    LogFlowFunc(("pCodec=%p, cbData=%zu, msTimestamp=%zu, uFlags=%#x\n",
+                 pCodec, cbData, msTimestamp, uFlags));
 
     /** @todo Optimize this! Three allocations in here! */
@@ -215 +294 @@
             pBlock->cbData      = sizeof(RECORDINGAUDIOFRAME) + cbData;
             pBlock->cRefs       = this->cStreamsEnabled;
-            pBlock->msTimestamp = msAbsPTS;
+            pBlock->msTimestamp = msTimestamp;
             pBlock->uFlags      = uFlags;
 
@@ -232 +311 @@
     try
     {
-        RecordingBlockMap::iterator itBlocks = this->mapBlocksCommon.find(msAbsPTS);
-        if (itBlocks == this->mapBlocksCommon.end())
+        RecordingBlockMap::iterator itBlocks = mapCommon.find(msTimestamp);
+        if (itBlocks == mapCommon.end())
         {
             RecordingBlocks *pRecordingBlocks = new RecordingBlocks();
             pRecordingBlocks->List.push_back(pBlock);
 
-            this->mapBlocksCommon.insert(std::make_pair(msAbsPTS, pRecordingBlocks));
+            mapCommon.insert(std::make_pair(msTimestamp, pRecordingBlocks));
         }
         else
@@ -261 +340 @@
 #ifdef VBOX_WITH_AUDIO_RECORDING
 /**
- * Callback function for taking care of multiplexing the encoded audio data to all connected streams.
+ * Callback function for writing encoded audio data into the common encoded block map.
+ *
+ * This is called by the audio codec when finishing encoding audio data.
  *
  * @copydoc RECORDINGCODECCALLBACKS::pfnWriteData
@@ -269 +350 @@
                                                                 uint64_t msAbsPTS, uint32_t uFlags, void *pvUser)
 {
-#if 0
     RecordingContext *pThis = (RecordingContext *)pvUser;
-
-    int vrc = VINF_SUCCESS;
-
-    RecordingStreams::iterator itStream = pThis->vecStreams.begin();
-    while (itStream != pThis->vecStreams.end())
-    {
-        RecordingStream *pStream = (*itStream);
-
-        LogFlowFunc(("pStream=%p\n", pStream));
-
-        if (pStream->GetConfig().isFeatureEnabled(RecordingFeature_Audio)) /** @todo Optimize this! Use a dedicated stream group for video-only / audio-only streams. */
-        {
-            vrc = RecordingStream::codecWriteDataCallback(pCodec, pvData, cbData, msAbsPTS, uFlags, pStream);
-            if (RT_FAILURE(vrc))
-            {
-                LogRel(("Recording: Calling audio write callback for stream #%RU16 failed (%Rrc)\n", pStream->GetID(), vrc));
-                break;
-            }
-        }
-
-        ++itStream;
-    }
-
-    return vrc;
-#else
-    RecordingContext *pThis = (RecordingContext *)pvUser;
-
-    return pThis->writeCommonData(pCodec, pvData, cbData, msAbsPTS, uFlags);
-#endif
+    return pThis->writeCommonData(pThis->mapBlocksEncoded, pCodec, pvData, cbData, msAbsPTS, uFlags);
 }
 
@@ -503 +555 @@
     /* Sanity. */
     Assert(this->vecStreams.empty());
-    Assert(this->mapBlocksCommon.size() == 0);
+    Assert(this->mapBlocksRaw.size() == 0);
+    Assert(this->mapBlocksEncoded.size() == 0);
 
     this->enmState = RECORDINGSTS_UNINITIALIZED;
@@ -779 +832 @@
  * Sends an audio frame to the video encoding thread.
  *
- * @thread  EMT
- *
  * @returns VBox status code.
  * @param   pvData              Audio frame data to send.
@@ -789 +840 @@
 {
 #ifdef VBOX_WITH_AUDIO_RECORDING
-    return writeCommonData(&this->CodecAudio, pvData, cbData, msTimestamp, RECORDINGCODEC_ENC_F_BLOCK_IS_KEY);
+    return writeCommonData(this->mapBlocksRaw, &this->CodecAudio,
+                           pvData, cbData, msTimestamp, RECORDINGCODEC_ENC_F_BLOCK_IS_KEY);
 #else
     RT_NOREF(pvData, cbData, msTimestamp);
-    return VINF_SUCCESS;
+    return VERR_NOT_SUPPORTED;
 #endif
 }

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

@@ -319 +319 @@
             AssertPtr(pBlock);
 
-            if (pBlock->enmType == RECORDINGBLOCKTYPE_VIDEO)
-            {
-                RECORDINGFRAME Frame;
-                Frame.VideoPtr    = (PRECORDINGVIDEOFRAME)pBlock->pvData;
-                Frame.msTimestamp = msTimestamp;
-
-                int vrc2 = recordingCodecEncode(&this->CodecVideo, &Frame, NULL, NULL);
-                AssertRC(vrc2);
-                if (RT_SUCCESS(vrc))
-                    vrc = vrc2;
+            switch (pBlock->enmType)
+            {
+                case RECORDINGBLOCKTYPE_VIDEO:
+                {
+                    RECORDINGFRAME Frame;
+                    Frame.VideoPtr    = (PRECORDINGVIDEOFRAME)pBlock->pvData;
+                    Frame.msTimestamp = msTimestamp;
+
+                    int vrc2 = recordingCodecEncode(&this->CodecVideo, &Frame, NULL, NULL);
+                    AssertRC(vrc2);
+                    if (RT_SUCCESS(vrc))
+                        vrc = vrc2;
+
+                    break;
+                }
+
+                default:
+                    /* Note: Audio data already is encoded. */
+                    break;
             }
 
@@ -410 +419 @@
     LogFlowFuncLeaveRC(vrc);
     return vrc;
+}
+
+/**
+ * Sends a raw (e.g. not yet encoded) audio frame to the recording stream.
+ *
+ * @returns VBox status code.
+ * @param   pvData              Pointer to audio data.
+ * @param   cbData              Size (in bytes) of \a pvData.
+ * @param   msTimestamp         Absolute PTS timestamp (in ms).
+ */
+int RecordingStream::SendAudioFrame(const void *pvData, size_t cbData, uint64_t msTimestamp)
+{
+    /* As audio data is common across all streams, re-route this to the recording context, where
+     * the data is being encoded and stored in the common blocks queue. */
+    return m_pCtx->SendAudioFrame(pvData, cbData, msTimestamp);
 }