Changeset 75040 in vbox

Timestamp:

Oct 24, 2018 1:54:50 PM (7 years ago)

Author:

vboxsync

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

126083

Message:

VideoRec/Main: Factored out the stream processing code into an own function VideoRecStreamProcess() and made it more resilient against errors.

Location:

trunk/src/VBox/Main

Files:

• include/VideoRecStream.h (modified) (1 diff)
• src-client/VideoRec.cpp (modified) (2 diffs)
• src-client/VideoRecStream.cpp (modified) (2 diffs)

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

@@ -169 +169 @@
 PVIDEORECSTREAM videoRecStreamGet(PVIDEORECCONTEXT pCtx, uint32_t uScreen);
 int videoRecStreamOpen(PVIDEORECSTREAM pStream, PVIDEORECCFG pCfg);
+int VideoRecStreamProcess(PVIDEORECSTREAM pStream);
 int videoRecStreamUninit(PVIDEORECSTREAM pStream);
 int videoRecStreamUnitVideo(PVIDEORECSTREAM pStream);

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

@@ -122 +122 @@
         AssertRCBreak(rc);
 
+        Log2Func(("Processing %zu streams\n", pCtx->vecStreams.size()));
+
         /** @todo r=andy This is inefficient -- as we already wake up this thread
          *               for every screen from Main, we here go again (on every wake up) through
          *               all screens.  */
-        for (VideoRecStreams::iterator itStream = pCtx->vecStreams.begin(); itStream != pCtx->vecStreams.end(); itStream++)
+        VideoRecStreams::iterator itStream = pCtx->vecStreams.begin();
+        while (itStream != pCtx->vecStreams.end())
         {
             PVIDEORECSTREAM pStream = (*itStream);
 
-            videoRecStreamLock(pStream);
-
-            if (!pStream->fEnabled)
-            {
-                videoRecStreamUnlock(pStream);
-                continue;
-            }
-
-            VideoRecBlockMap::iterator itBlockStream = pStream->Blocks.Map.begin();
-            while (itBlockStream != pStream->Blocks.Map.end())
-            {
-                const uint64_t        uTimeStampMs = itBlockStream->first;
-                      VideoRecBlocks *pBlocks      = itBlockStream->second;
-
-                AssertPtr(pBlocks);
-
-                while (!pBlocks->List.empty())
-                {
-                    PVIDEORECBLOCK pBlock = pBlocks->List.front();
-                    AssertPtr(pBlock);
-
-#ifdef VBOX_WITH_LIBVPX
-                    if (pBlock->enmType == VIDEORECBLOCKTYPE_VIDEO)
-                    {
-                        PVIDEORECVIDEOFRAME pVideoFrame  = (PVIDEORECVIDEOFRAME)pBlock->pvData;
-
-                        rc = videoRecRGBToYUV(pVideoFrame->uPixelFormat,
-                                              /* Destination */
-                                              pStream->Video.Codec.VPX.pu8YuvBuf, pVideoFrame->uWidth, pVideoFrame->uHeight,
-                                              /* Source */
-                                              pVideoFrame->pu8RGBBuf, pStream->Video.uWidth, pStream->Video.uHeight);
-                        if (RT_SUCCESS(rc))
-                            rc = videoRecStreamWriteVideoVPX(pStream, uTimeStampMs, pVideoFrame);
-                    }
-#endif
-                    VideoRecBlockFree(pBlock);
-                    pBlock = NULL;
-
-                    pBlocks->List.pop_front();
-                }
-
-#ifdef VBOX_WITH_AUDIO_VIDEOREC
-                /* As each (enabled) screen has to get the same audio data, look for common (audio) data which needs to be
-                 * written to the screen's assigned recording stream. */
-                VideoRecBlockMap::iterator itCommon = pCtx->mapBlocksCommon.begin();
-                while (itCommon != pCtx->mapBlocksCommon.end())
-                {
-                    VideoRecBlockList::iterator itBlockCommon = itCommon->second->List.begin();
-                    while (itBlockCommon != itCommon->second->List.end())
-                    {
-                        PVIDEORECBLOCK pBlockCommon = (PVIDEORECBLOCK)(*itBlockCommon);
-                        switch (pBlockCommon->enmType)
-                        {
-                            case VIDEORECBLOCKTYPE_AUDIO:
-                            {
-                                PVIDEORECAUDIOFRAME pAudioFrame = (PVIDEORECAUDIOFRAME)pBlockCommon->pvData;
-                                AssertPtr(pAudioFrame);
-                                AssertPtr(pAudioFrame->pvBuf);
-                                Assert(pAudioFrame->cbBuf);
-
-                                WebMWriter::BlockData_Opus blockData = { pAudioFrame->pvBuf, pAudioFrame->cbBuf,
-                                                                         pBlockCommon->uTimeStampMs };
-                                rc = pStream->File.pWEBM->WriteBlock(pStream->uTrackAudio, &blockData, sizeof(blockData));
-                                break;
-                            }
-
-                            default:
-                                AssertFailed();
-                                break;
-                        }
-
-                        Assert(pBlockCommon->cRefs);
-                        if (--pBlockCommon->cRefs == 0)
-                        {
-                            VideoRecBlockFree(pBlockCommon);
-                            itCommon->second->List.erase(itBlockCommon);
-                            itBlockCommon = itCommon->second->List.begin();
-                        }
-                        else
-                            ++itBlockCommon;
-                    }
-
-                    /* If no entries are left over in the block map, remove it altogether. */
-                    if (itCommon->second->List.empty())
-                    {
-                        delete itCommon->second;
-                        pCtx->mapBlocksCommon.erase(itCommon);
-                    }
-
-                    itCommon = pCtx->mapBlocksCommon.begin();
-
-                    LogFunc(("Common blocks: %zu\n", pCtx->mapBlocksCommon.size()));
-                }
-#endif
-                ++itBlockStream;
-            }
-
-            videoRecStreamUnlock(pStream);
-        }
+            rc = VideoRecStreamProcess(pStream);
+            if (RT_FAILURE(rc))
+                break;
+
+            ++itStream;
+        }
+
+        if (RT_FAILURE(rc))
+            LogRel(("VideoRec: Encoding thread failed with rc=%Rrc\n", rc));
 
         /* Keep going in case of errors. */
@@ -379 +292 @@
         rc = videoRecThreadNotify(pCtx);
         if (RT_SUCCESS(rc))
-            rc = RTThreadWait(pCtx->Thread, 10 * 1000 /* 10s timeout */, NULL);
+            rc = RTThreadWait(pCtx->Thread, 30 * 1000 /* 10s timeout */, NULL);
 
         if (RT_SUCCESS(rc))

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

@@ -38 +38 @@
 #include "VideoRec.h"
 #include "VideoRecStream.h"
+#include "VideoRecUtils.h"
 #include "WebMWriter.h"
 
@@ -193 +194 @@
 
     LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+/**
+ * Processes a recording stream.
+ * This function takes care of the actual encoding and writing of a certain stream.
+ * As this can be very CPU intensive, this function usually is called from a separate thread.
+ *
+ * @returns IPRT status code.
+ * @param   pStream             Recording stream to process.
+ */
+int VideoRecStreamProcess(PVIDEORECSTREAM pStream)
+{
+    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
+
+    videoRecStreamLock(pStream);
+
+    if (!pStream->fEnabled)
+    {
+        videoRecStreamUnlock(pStream);
+        return VINF_SUCCESS;
+    }
+
+    int rc = VINF_SUCCESS;
+
+    const PVIDEORECCONTEXT pCtx = pStream->pCtx;
+    AssertPtr(pCtx);
+
+    VideoRecBlockMap::iterator itStreamBlocks = pStream->Blocks.Map.begin();
+    while (itStreamBlocks != pStream->Blocks.Map.end())
+    {
+        const uint64_t        uTimeStampMs = itStreamBlocks->first;
+              VideoRecBlocks *pBlocks      = itStreamBlocks->second;
+
+        AssertPtr(pBlocks);
+
+        while (!pBlocks->List.empty())
+        {
+            PVIDEORECBLOCK pBlock = pBlocks->List.front();
+            AssertPtr(pBlock);
+
+#ifdef VBOX_WITH_LIBVPX
+            if (pBlock->enmType == VIDEORECBLOCKTYPE_VIDEO)
+            {
+                PVIDEORECVIDEOFRAME pVideoFrame  = (PVIDEORECVIDEOFRAME)pBlock->pvData;
+
+                rc = videoRecRGBToYUV(pVideoFrame->uPixelFormat,
+                                      /* Destination */
+                                      pStream->Video.Codec.VPX.pu8YuvBuf, pVideoFrame->uWidth, pVideoFrame->uHeight,
+                                      /* Source */
+                                      pVideoFrame->pu8RGBBuf, pStream->Video.uWidth, pStream->Video.uHeight);
+                if (RT_SUCCESS(rc))
+                {
+                    rc = videoRecStreamWriteVideoVPX(pStream, uTimeStampMs, pVideoFrame);
+                }
+                else
+                    break;
+            }
+#endif
+            VideoRecBlockFree(pBlock);
+            pBlock = NULL;
+
+            pBlocks->List.pop_front();
+        }
+
+        ++itStreamBlocks;
+    }
+
+#ifdef VBOX_WITH_AUDIO_VIDEOREC
+    /* As each (enabled) screen has to get the same audio data, look for common (audio) data which needs to be
+     * written to the screen's assigned recording stream. */
+    VideoRecBlockMap::iterator itCommonBlocks = pCtx->mapBlocksCommon.begin();
+    while (itCommonBlocks != pCtx->mapBlocksCommon.end())
+    {
+        VideoRecBlockList::iterator itBlock = itCommonBlocks->second->List.begin();
+        while (itBlock != itCommonBlocks->second->List.end())
+        {
+            PVIDEORECBLOCK pBlockCommon = (PVIDEORECBLOCK)(*itBlock);
+            switch (pBlockCommon->enmType)
+            {
+                case VIDEORECBLOCKTYPE_AUDIO:
+                {
+                    PVIDEORECAUDIOFRAME pAudioFrame = (PVIDEORECAUDIOFRAME)pBlockCommon->pvData;
+                    AssertPtr(pAudioFrame);
+                    AssertPtr(pAudioFrame->pvBuf);
+                    Assert(pAudioFrame->cbBuf);
+
+                    WebMWriter::BlockData_Opus blockData = { pAudioFrame->pvBuf, pAudioFrame->cbBuf,
+                                                             pBlockCommon->uTimeStampMs };
+                    AssertPtr(pStream->File.pWEBM);
+                    rc = pStream->File.pWEBM->WriteBlock(pStream->uTrackAudio, &blockData, sizeof(blockData));
+                    break;
+                }
+
+                default:
+                    AssertFailed();
+                    break;
+            }
+
+            if (RT_FAILURE(rc))
+                break;
+
+            Assert(pBlockCommon->cRefs);
+            pBlockCommon->cRefs--;
+            if (pBlockCommon->cRefs == 0)
+            {
+                VideoRecBlockFree(pBlockCommon);
+                itCommonBlocks->second->List.erase(itBlock);
+                itBlock = itCommonBlocks->second->List.begin();
+            }
+            else
+                ++itBlock;
+        }
+
+        /* If no entries are left over in the block map, remove it altogether. */
+        if (itCommonBlocks->second->List.empty())
+        {
+            delete itCommonBlocks->second;
+            pCtx->mapBlocksCommon.erase(itCommonBlocks);
+            itCommonBlocks = pCtx->mapBlocksCommon.begin();
+        }
+        else
+            ++itCommonBlocks;
+
+        LogFunc(("Common blocks: %zu\n", pCtx->mapBlocksCommon.size()));
+
+        if (RT_FAILURE(rc))
+            break;
+    }
+#endif
+
+    videoRecStreamUnlock(pStream);
+
     return rc;
 }